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         Sys_Printf( "Shutting down GL ..." );
 522
 523         if ( g_hGLDLL ) {
 524 #ifdef _WIN32
 525                 FreeLibrary( g_hGLDLL );
 526 #endif
 527
 528 #if defined ( __linux__ ) || defined ( __APPLE__ )
 529                 dlclose( g_hGLDLL );
 530 #endif
 531
 532                 g_hGLDLL = NULL;
 533         }
 534
 535         Sys_Printf( "Done.\n" );
 536
 537         qglAccum                     = NULL;
 538         qglAlphaFunc                 = NULL;
 539         qglAreTexturesResident       = NULL;
 540         qglArrayElement              = NULL;
 541         qglBegin                     = NULL;
 542         qglBindTexture               = NULL;
 543         qglBitmap                    = NULL;
 544         qglBlendFunc                 = NULL;
 545         qglCallList                  = NULL;
 546         qglCallLists                 = NULL;
 547         qglClear                     = NULL;
 548         qglClearAccum                = NULL;
 549         qglClearColor                = NULL;
 550         qglClearDepth                = NULL;
 551         qglClearIndex                = NULL;
 552         qglClearStencil              = NULL;
 553         qglClipPlane                 = NULL;
 554         qglColor3b                   = NULL;
 555         qglColor3bv                  = NULL;
 556         qglColor3d                   = NULL;
 557         qglColor3dv                  = NULL;
 558         qglColor3f                   = NULL;
 559         qglColor3fv                  = NULL;
 560         qglColor3i                   = NULL;
 561         qglColor3iv                  = NULL;
 562         qglColor3s                   = NULL;
 563         qglColor3sv                  = NULL;
 564         qglColor3ub                  = NULL;
 565         qglColor3ubv                 = NULL;
 566         qglColor3ui                  = NULL;
 567         qglColor3uiv                 = NULL;
 568         qglColor3us                  = NULL;
 569         qglColor3usv                 = NULL;
 570         qglColor4b                   = NULL;
 571         qglColor4bv                  = NULL;
 572         qglColor4d                   = NULL;
 573         qglColor4dv                  = NULL;
 574         qglColor4f                   = NULL;
 575         qglColor4fv                  = NULL;
 576         qglColor4i                   = NULL;
 577         qglColor4iv                  = NULL;
 578         qglColor4s                   = NULL;
 579         qglColor4sv                  = NULL;
 580         qglColor4ub                  = NULL;
 581         qglColor4ubv                 = NULL;
 582         qglColor4ui                  = NULL;
 583         qglColor4uiv                 = NULL;
 584         qglColor4us                  = NULL;
 585         qglColor4usv                 = NULL;
 586         qglColorMask                 = NULL;
 587         qglColorMaterial             = NULL;
 588         qglColorPointer              = NULL;
 589         qglCopyPixels                = NULL;
 590         qglCopyTexImage1D            = NULL;
 591         qglCopyTexImage2D            = NULL;
 592         qglCopyTexSubImage1D         = NULL;
 593         qglCopyTexSubImage2D         = NULL;
 594         qglCullFace                  = NULL;
 595         qglDeleteLists               = NULL;
 596         qglDeleteTextures            = NULL;
 597         qglDepthFunc                 = NULL;
 598         qglDepthMask                 = NULL;
 599         qglDepthRange                = NULL;
 600         qglDisable                   = NULL;
 601         qglDisableClientState        = NULL;
 602         qglDrawArrays                = NULL;
 603         qglDrawBuffer                = NULL;
 604         qglDrawElements              = NULL;
 605         qglDrawPixels                = NULL;
 606         qglEdgeFlag                  = NULL;
 607         qglEdgeFlagPointer           = NULL;
 608         qglEdgeFlagv                 = NULL;
 609         qglEnable                    = NULL;
 610         qglEnableClientState         = NULL;
 611         qglEnd                       = NULL;
 612         qglEndList                   = NULL;
 613         qglEvalCoord1d               = NULL;
 614         qglEvalCoord1dv              = NULL;
 615         qglEvalCoord1f               = NULL;
 616         qglEvalCoord1fv              = NULL;
 617         qglEvalCoord2d               = NULL;
 618         qglEvalCoord2dv              = NULL;
 619         qglEvalCoord2f               = NULL;
 620         qglEvalCoord2fv              = NULL;
 621         qglEvalMesh1                 = NULL;
 622         qglEvalMesh2                 = NULL;
 623         qglEvalPoint1                = NULL;
 624         qglEvalPoint2                = NULL;
 625         qglFeedbackBuffer            = NULL;
 626         qglFinish                    = NULL;
 627         qglFlush                     = NULL;
 628         qglFogf                      = NULL;
 629         qglFogfv                     = NULL;
 630         qglFogi                      = NULL;
 631         qglFogiv                     = NULL;
 632         qglFrontFace                 = NULL;
 633         qglFrustum                   = NULL;
 634         qglGenLists                  = NULL;
 635         qglGenTextures               = NULL;
 636         qglGetBooleanv               = NULL;
 637         qglGetClipPlane              = NULL;
 638         qglGetDoublev                = NULL;
 639         qglGetError                  = NULL;
 640         qglGetFloatv                 = NULL;
 641         qglGetIntegerv               = NULL;
 642         qglGetLightfv                = NULL;
 643         qglGetLightiv                = NULL;
 644         qglGetMapdv                  = NULL;
 645         qglGetMapfv                  = NULL;
 646         qglGetMapiv                  = NULL;
 647         qglGetMaterialfv             = NULL;
 648         qglGetMaterialiv             = NULL;
 649         qglGetPixelMapfv             = NULL;
 650         qglGetPixelMapuiv            = NULL;
 651         qglGetPixelMapusv            = NULL;
 652         qglGetPointerv               = NULL;
 653         qglGetPolygonStipple         = NULL;
 654         qglGetString                 = NULL;
 655         qglGetTexEnvfv               = NULL;
 656         qglGetTexEnviv               = NULL;
 657         qglGetTexGendv               = NULL;
 658         qglGetTexGenfv               = NULL;
 659         qglGetTexGeniv               = NULL;
 660         qglGetTexImage               = NULL;
 661         qglGetTexLevelParameterfv    = NULL;
 662         qglGetTexLevelParameteriv    = NULL;
 663         qglGetTexParameterfv         = NULL;
 664         qglGetTexParameteriv         = NULL;
 665         qglHint                      = NULL;
 666         qglIndexMask                 = NULL;
 667         qglIndexPointer              = NULL;
 668         qglIndexd                    = NULL;
 669         qglIndexdv                   = NULL;
 670         qglIndexf                    = NULL;
 671         qglIndexfv                   = NULL;
 672         qglIndexi                    = NULL;
 673         qglIndexiv                   = NULL;
 674         qglIndexs                    = NULL;
 675         qglIndexsv                   = NULL;
 676         qglIndexub                   = NULL;
 677         qglIndexubv                  = NULL;
 678         qglInitNames                 = NULL;
 679         qglInterleavedArrays         = NULL;
 680         qglIsEnabled                 = NULL;
 681         qglIsList                    = NULL;
 682         qglIsTexture                 = NULL;
 683         qglLightModelf               = NULL;
 684         qglLightModelfv              = NULL;
 685         qglLightModeli               = NULL;
 686         qglLightModeliv              = NULL;
 687         qglLightf                    = NULL;
 688         qglLightfv                   = NULL;
 689         qglLighti                    = NULL;
 690         qglLightiv                   = NULL;
 691         qglLineStipple               = NULL;
 692         qglLineWidth                 = NULL;
 693         qglListBase                  = NULL;
 694         qglLoadIdentity              = NULL;
 695         qglLoadMatrixd               = NULL;
 696         qglLoadMatrixf               = NULL;
 697         qglLoadName                  = NULL;
 698         qglLogicOp                   = NULL;
 699         qglMap1d                     = NULL;
 700         qglMap1f                     = NULL;
 701         qglMap2d                     = NULL;
 702         qglMap2f                     = NULL;
 703         qglMapGrid1d                 = NULL;
 704         qglMapGrid1f                 = NULL;
 705         qglMapGrid2d                 = NULL;
 706         qglMapGrid2f                 = NULL;
 707         qglMaterialf                 = NULL;
 708         qglMaterialfv                = NULL;
 709         qglMateriali                 = NULL;
 710         qglMaterialiv                = NULL;
 711         qglMatrixMode                = NULL;
 712         qglMultMatrixd               = NULL;
 713         qglMultMatrixf               = NULL;
 714         qglNewList                   = NULL;
 715         qglNormal3b                  = NULL;
 716         qglNormal3bv                 = NULL;
 717         qglNormal3d                  = NULL;
 718         qglNormal3dv                 = NULL;
 719         qglNormal3f                  = NULL;
 720         qglNormal3fv                 = NULL;
 721         qglNormal3i                  = NULL;
 722         qglNormal3iv                 = NULL;
 723         qglNormal3s                  = NULL;
 724         qglNormal3sv                 = NULL;
 725         qglNormalPointer             = NULL;
 726         qglOrtho                     = NULL;
 727         qglPassThrough               = NULL;
 728         qglPixelMapfv                = NULL;
 729         qglPixelMapuiv               = NULL;
 730         qglPixelMapusv               = NULL;
 731         qglPixelStoref               = NULL;
 732         qglPixelStorei               = NULL;
 733         qglPixelTransferf            = NULL;
 734         qglPixelTransferi            = NULL;
 735         qglPixelZoom                 = NULL;
 736         qglPointSize                 = NULL;
 737         qglPolygonMode               = NULL;
 738         qglPolygonOffset             = NULL;
 739         qglPolygonStipple            = NULL;
 740         qglPopAttrib                 = NULL;
 741         qglPopClientAttrib           = NULL;
 742         qglPopMatrix                 = NULL;
 743         qglPopName                   = NULL;
 744         qglPrioritizeTextures        = NULL;
 745         qglPushAttrib                = NULL;
 746         qglPushClientAttrib          = NULL;
 747         qglPushMatrix                = NULL;
 748         qglPushName                  = NULL;
 749         qglRasterPos2d               = NULL;
 750         qglRasterPos2dv              = NULL;
 751         qglRasterPos2f               = NULL;
 752         qglRasterPos2fv              = NULL;
 753         qglRasterPos2i               = NULL;
 754         qglRasterPos2iv              = NULL;
 755         qglRasterPos2s               = NULL;
 756         qglRasterPos2sv              = NULL;
 757         qglRasterPos3d               = NULL;
 758         qglRasterPos3dv              = NULL;
 759         qglRasterPos3f               = NULL;
 760         qglRasterPos3fv              = NULL;
 761         qglRasterPos3i               = NULL;
 762         qglRasterPos3iv              = NULL;
 763         qglRasterPos3s               = NULL;
 764         qglRasterPos3sv              = NULL;
 765         qglRasterPos4d               = NULL;
 766         qglRasterPos4dv              = NULL;
 767         qglRasterPos4f               = NULL;
 768         qglRasterPos4fv              = NULL;
 769         qglRasterPos4i               = NULL;
 770         qglRasterPos4iv              = NULL;
 771         qglRasterPos4s               = NULL;
 772         qglRasterPos4sv              = NULL;
 773         qglReadBuffer                = NULL;
 774         qglReadPixels                = NULL;
 775         qglRectd                     = NULL;
 776         qglRectdv                    = NULL;
 777         qglRectf                     = NULL;
 778         qglRectfv                    = NULL;
 779         qglRecti                     = NULL;
 780         qglRectiv                    = NULL;
 781         qglRects                     = NULL;
 782         qglRectsv                    = NULL;
 783         qglRenderMode                = NULL;
 784         qglRotated                   = NULL;
 785         qglRotatef                   = NULL;
 786         qglScaled                    = NULL;
 787         qglScalef                    = NULL;
 788         qglScissor                   = NULL;
 789         qglSelectBuffer              = NULL;
 790         qglShadeModel                = NULL;
 791         qglStencilFunc               = NULL;
 792         qglStencilMask               = NULL;
 793         qglStencilOp                 = NULL;
 794         qglTexCoord1d                = NULL;
 795         qglTexCoord1dv               = NULL;
 796         qglTexCoord1f                = NULL;
 797         qglTexCoord1fv               = NULL;
 798         qglTexCoord1i                = NULL;
 799         qglTexCoord1iv               = NULL;
 800         qglTexCoord1s                = NULL;
 801         qglTexCoord1sv               = NULL;
 802         qglTexCoord2d                = NULL;
 803         qglTexCoord2dv               = NULL;
 804         qglTexCoord2f                = NULL;
 805         qglTexCoord2fv               = NULL;
 806         qglTexCoord2i                = NULL;
 807         qglTexCoord2iv               = NULL;
 808         qglTexCoord2s                = NULL;
 809         qglTexCoord2sv               = NULL;
 810         qglTexCoord3d                = NULL;
 811         qglTexCoord3dv               = NULL;
 812         qglTexCoord3f                = NULL;
 813         qglTexCoord3fv               = NULL;
 814         qglTexCoord3i                = NULL;
 815         qglTexCoord3iv               = NULL;
 816         qglTexCoord3s                = NULL;
 817         qglTexCoord3sv               = NULL;
 818         qglTexCoord4d                = NULL;
 819         qglTexCoord4dv               = NULL;
 820         qglTexCoord4f                = NULL;
 821         qglTexCoord4fv               = NULL;
 822         qglTexCoord4i                = NULL;
 823         qglTexCoord4iv               = NULL;
 824         qglTexCoord4s                = NULL;
 825         qglTexCoord4sv               = NULL;
 826         qglTexCoordPointer           = NULL;
 827         qglTexEnvf                   = NULL;
 828         qglTexEnvfv                  = NULL;
 829         qglTexEnvi                   = NULL;
 830         qglTexEnviv                  = NULL;
 831         qglTexGend                   = NULL;
 832         qglTexGendv                  = NULL;
 833         qglTexGenf                   = NULL;
 834         qglTexGenfv                  = NULL;
 835         qglTexGeni                   = NULL;
 836         qglTexGeniv                  = NULL;
 837         qglTexImage1D                = NULL;
 838         qglTexImage2D                = NULL;
 839         qglTexParameterf             = NULL;
 840         qglTexParameterfv            = NULL;
 841         qglTexParameteri             = NULL;
 842         qglTexParameteriv            = NULL;
 843         qglTexSubImage1D             = NULL;
 844         qglTexSubImage2D             = NULL;
 845         qglTranslated                = NULL;
 846         qglTranslatef                = NULL;
 847         qglVertex2d                  = NULL;
 848         qglVertex2dv                 = NULL;
 849         qglVertex2f                  = NULL;
 850         qglVertex2fv                 = NULL;
 851         qglVertex2i                  = NULL;
 852         qglVertex2iv                 = NULL;
 853         qglVertex2s                  = NULL;
 854         qglVertex2sv                 = NULL;
 855         qglVertex3d                  = NULL;
 856         qglVertex3dv                 = NULL;
 857         qglVertex3f                  = NULL;
 858         qglVertex3fv                 = NULL;
 859         qglVertex3i                  = NULL;
 860         qglVertex3iv                 = NULL;
 861         qglVertex3s                  = NULL;
 862         qglVertex3sv                 = NULL;
 863         qglVertex4d                  = NULL;
 864         qglVertex4dv                 = NULL;
 865         qglVertex4f                  = NULL;
 866         qglVertex4fv                 = NULL;
 867         qglVertex4i                  = NULL;
 868         qglVertex4iv                 = NULL;
 869         qglVertex4s                  = NULL;
 870         qglVertex4sv                 = NULL;
 871         qglVertexPointer             = NULL;
 872         qglViewport                  = NULL;
 873
 874         qglActiveTextureARB = NULL;
 875         qglClientActiveTextureARB = NULL;
 876         qglMultiTexCoord1dARB = NULL;
 877         qglMultiTexCoord1dvARB = NULL;
 878         qglMultiTexCoord1fARB = NULL;
 879         qglMultiTexCoord1fvARB = NULL;
 880         qglMultiTexCoord1iARB = NULL;
 881         qglMultiTexCoord1ivARB = NULL;
 882         qglMultiTexCoord1sARB = NULL;
 883         qglMultiTexCoord1svARB = NULL;
 884         qglMultiTexCoord2dARB = NULL;
 885         qglMultiTexCoord2dvARB = NULL;
 886         qglMultiTexCoord2fARB = NULL;
 887         qglMultiTexCoord2fvARB = NULL;
 888         qglMultiTexCoord2iARB = NULL;
 889         qglMultiTexCoord2ivARB = NULL;
 890         qglMultiTexCoord2sARB = NULL;
 891         qglMultiTexCoord2svARB = NULL;
 892         qglMultiTexCoord3dARB = NULL;
 893         qglMultiTexCoord3dvARB = NULL;
 894         qglMultiTexCoord3fARB = NULL;
 895         qglMultiTexCoord3fvARB = NULL;
 896         qglMultiTexCoord3iARB = NULL;
 897         qglMultiTexCoord3ivARB = NULL;
 898         qglMultiTexCoord3sARB = NULL;
 899         qglMultiTexCoord3svARB = NULL;
 900         qglMultiTexCoord4dARB = NULL;
 901         qglMultiTexCoord4dvARB = NULL;
 902         qglMultiTexCoord4fARB = NULL;
 903         qglMultiTexCoord4fvARB = NULL;
 904         qglMultiTexCoord4iARB = NULL;
 905         qglMultiTexCoord4ivARB = NULL;
 906         qglMultiTexCoord4sARB = NULL;
 907         qglMultiTexCoord4svARB = NULL;
 908
 909 #ifdef _WIN32
 910         qwglCopyContext              = NULL;
 911         qwglCreateContext            = NULL;
 912         qwglCreateLayerContext       = NULL;
 913         qwglDeleteContext            = NULL;
 914         qwglDescribeLayerPlane       = NULL;
 915         qwglGetCurrentContext        = NULL;
 916         qwglGetCurrentDC             = NULL;
 917         qwglGetLayerPaletteEntries   = NULL;
 918         qwglGetProcAddress           = NULL;
 919         qwglMakeCurrent              = NULL;
 920         qwglRealizeLayerPalette      = NULL;
 921         qwglSetLayerPaletteEntries   = NULL;
 922         qwglShareLists               = NULL;
 923         qwglSwapLayerBuffers         = NULL;
 924         qwglUseFontBitmaps           = NULL;
 925         qwglUseFontOutlines          = NULL;
 926
 927         qwglChoosePixelFormat        = NULL;
 928         qwglDescribePixelFormat      = NULL;
 929         qwglGetPixelFormat           = NULL;
 930         qwglSetPixelFormat           = NULL;
 931         qwglSwapBuffers              = NULL;
 932
 933         qwglSwapIntervalEXT          = NULL;
 934
 935         qwglGetDeviceGammaRampEXT    = NULL;
 936         qwglSetDeviceGammaRampEXT    = NULL;
 937 #endif
 938
 939 #if defined ( __linux__ ) || defined ( __APPLE__ )
 940         qglXChooseVisual             = NULL;
 941         qglXCreateContext            = NULL;
 942         qglXDestroyContext           = NULL;
 943         qglXMakeCurrent              = NULL;
 944         qglXCopyContext              = NULL;
 945         qglXSwapBuffers              = NULL;
 946         qglXCreateGLXPixmap          = NULL;
 947         qglXDestroyGLXPixmap         = NULL;
 948         qglXQueryExtension           = NULL;
 949         qglXQueryVersion             = NULL;
 950         qglXIsDirect                 = NULL;
 951         qglXGetConfig                = NULL;
 952         qglXGetCurrentContext        = NULL;
 953         qglXGetCurrentDrawable       = NULL;
 954         qglXWaitGL                   = NULL;
 955         qglXWaitX                    = NULL;
 956         qglXUseXFont                 = NULL;
 957         qglXGetProcAddressARB        = NULL;
 958 #endif
 959
 960         qgluPerspective = NULL;
 961         qgluErrorString = NULL;
 962         qgluLookAt = NULL;
 963
 964 #ifdef ATIHACK_812
 965         qglCullFace_real              = NULL;
 966         qglDisable_real               = NULL;
 967         qglEnable_real                = NULL;
 968         qglPolygonMode_real           = NULL;
 969 #endif
 970 }
 971
 972 /*
 973 ** QGL_Init
 974 **
 975 ** This is responsible for binding our qgl function pointers to
 976 ** the appropriate GL stuff.  In Windows this means doing a
 977 ** LoadLibrary and a bunch of calls to GetProcAddress.  On other
 978 ** operating systems we need to do the right thing, whatever that
 979 ** might be.
 980 **
 981 */
 982 static int init_error;
 983
 984 static void* safe_dlsym( void *handle, char *symbol ){
 985 #ifdef _WIN32
 986         return GetProcAddress( handle, symbol );
 987 #endif
 988
 989 #if defined ( __linux__ ) || defined ( __APPLE__ )
 990         void* ret = dlsym( handle, symbol );
 991         const char *err = dlerror();
 992         if ( err ) {
 993                 init_error = 1;
 994 #ifndef __APPLE__
 995                 printf( "Error loading OpenGL libraries: %s\n", err );
 996 #else
 997                 printf( "Error loading OpenGL libraries: %s %s\n", err, symbol );
 998 #endif
 999         }
1000         return ret;
1001 #endif
1002 }
1003
1004 #include <math.h>
1005 #include <stdlib.h>
1006 #ifdef _WIN32
1007 #define M_PI 3.14159
1008 #endif
1009
1010 void WINAPI gluLookAt2( GLdouble ex, GLdouble ey, GLdouble ez, GLdouble cx, GLdouble cy, GLdouble cz,
1011                                                 GLdouble ux, GLdouble uy, GLdouble uz ){
1012         GLdouble x[3], y[3], z[3] = { ex - cx, ey - cy, ez - cz };
1013         GLdouble inv;
1014
1015         inv = sqrt( z[0] * z[0] + z[1] * z[1] + z[2] * z[2] );
1016         if ( inv ) {
1017                 inv = 1.0 / inv;
1018                 z[0] *= inv;
1019                 z[1] *= inv;
1020                 z[2] *= inv;
1021         }
1022
1023         x[0] =  uy * z[2] - uz * z[1];
1024         x[1] = -ux * z[2] + uz * z[0];
1025         x[2] =  ux * z[1] - uy * z[0];
1026
1027         y[0] =  z[1] * x[2] - z[2] * x[1];
1028         y[1] = -z[0] * x[2] + z[2] * x[0];
1029         y[2] =  z[0] * x[1] - z[1] * x[0];
1030
1031         inv = sqrt( x[0] * x[0] + x[1] * x[1] + x[2] * x[2] );
1032         if ( inv ) {
1033                 x[0] *= inv;
1034                 x[1] *= inv;
1035                 x[2] *= inv;
1036         }
1037
1038         inv = sqrt( y[0] * y[0] + y[1] * y[1] + y[2] * y[2] );
1039         if ( inv ) {
1040                 y[0] *= inv;
1041                 y[1] *= inv;
1042                 y[2] *= inv;
1043         }
1044
1045         {
1046                 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 };
1047                 qglMultMatrixd( m );
1048                 qglTranslated( -ex, -ey, -ez );
1049         }
1050 }
1051
1052 void WINAPI gluPerspective2( GLdouble fovy, GLdouble aspect, GLdouble zNear, GLdouble zFar ){
1053         GLdouble y = zNear * tan( fovy * M_PI / 360.0 );
1054         qglFrustum( -y * aspect, y * aspect, -y, y, zNear, zFar );
1055 }
1056
1057 static void* WINAPI ResizeImage( GLubyte* old_image, int srcw, int srch, int destw, int desth ){
1058         int i, j;
1059         float sx, sy;
1060         GLubyte* new_image = (GLubyte *)malloc( destw * desth * 4 * sizeof( GLubyte ) );
1061         if ( new_image == NULL ) {
1062                 return NULL;
1063         }
1064
1065         if ( destw > 1 ) {
1066                 sx = (GLfloat) ( srcw - 1 ) / (GLfloat) ( destw - 1 );
1067         }
1068         else{
1069                 sx = (GLfloat) ( srcw - 1 );
1070         }
1071         if ( desth > 1 ) {
1072                 sy = (GLfloat) ( srch - 1 ) / (GLfloat) ( desth - 1 );
1073         }
1074         else{
1075                 sy = (GLfloat) ( srch - 1 );
1076         }
1077
1078         for ( i = 0; i < desth; i++ )
1079         {
1080                 GLint ii = (GLint)( i * sy );
1081                 for ( j = 0; j < destw; j++ )
1082                 {
1083                         GLint jj = (GLint)( j * sx );
1084                         GLubyte *src = old_image + ( ii * srcw + jj ) * 4;
1085                         GLubyte *dst = new_image + ( i * destw + j ) * 4;
1086
1087                         *dst++ = *src++;
1088                         *dst++ = *src++;
1089                         *dst++ = *src++;
1090                         *dst++ = *src++;
1091                 }
1092         }
1093
1094         return new_image;
1095 }
1096
1097 #define CEILING( A, B )  ( ( A ) % ( B ) == 0 ? ( A ) / ( B ) : ( A ) / (B)+1 )
1098
1099 typedef struct glu_error_struct
1100 {
1101         int errnum;
1102         const char *errstr;
1103 } GLU_ERROR_STRUCT;
1104
1105 GLU_ERROR_STRUCT glu_errlist[] = {
1106         {GL_NO_ERROR, "GL_NO_ERROR - no error"},
1107         {GL_INVALID_ENUM, "GL_INVALID_ENUM - An unacceptable value is specified for an enumerated argument."},
1108         {GL_INVALID_VALUE, "GL_INVALID_VALUE - A numeric argument is out of range."},
1109         {GL_INVALID_OPERATION, "GL_INVALID_OPERATION - The specified operation is not allowed in the current state."},
1110         {GL_STACK_OVERFLOW, "GL_STACK_OVERFLOW - Function would cause a stack overflow."},
1111         {GL_STACK_UNDERFLOW, "GL_STACK_UNDERFLOW - Function would cause a stack underflow."},
1112         {GL_OUT_OF_MEMORY, "GL_OUT_OF_MEMORY - There is not enough memory left to execute the function."},
1113         {-1, NULL}
1114 };
1115
1116 const GLubyte* WINAPI gluErrorString( GLenum errCode ){
1117         int search = 0;
1118         for ( search = 0; glu_errlist[search].errstr; search++ )
1119         {
1120                 if ( errCode == glu_errlist[search].errnum ) {
1121                         return (const char *)glu_errlist[search].errstr;
1122                 }
1123         } //end for
1124         return "Unknown error";
1125 }
1126
1127 #ifdef ATIHACK_812
1128 int ATIhack_culling;
1129 GLenum ATIhack_cullmode;
1130 GLenum ATIhack_backmode;
1131 GLenum ATIhack_frontmode;
1132
1133 static void ATIhack_update( void ){
1134         if ( !ATIhack_culling || ( GL_FRONT_AND_BACK == ATIhack_cullmode ) ) {
1135                 qglPolygonMode_real( GL_FRONT, ATIhack_frontmode );
1136                 qglPolygonMode_real( GL_BACK, ATIhack_backmode );
1137         }
1138         else{
1139                 switch ( ATIhack_cullmode )
1140                 {
1141                 case GL_FRONT:
1142                         qglPolygonMode_real( GL_FRONT_AND_BACK, ATIhack_backmode );
1143                         break;
1144                 case GL_BACK:
1145                         qglPolygonMode_real( GL_FRONT_AND_BACK, ATIhack_frontmode );
1146                 default:
1147                         break;
1148                 }
1149         }
1150 }
1151
1152 void APIENTRY qglEnable_ATIHack( GLenum cap ){
1153         qglEnable_real( cap );
1154         if ( GL_CULL_FACE != cap ) {
1155                 return;
1156         }
1157         if ( ATIhack_culling ) {
1158                 return;
1159         }
1160         ATIhack_culling = 1;
1161         ATIhack_update();
1162 }
1163
1164 void APIENTRY qglDisable_ATIHack( GLenum cap ){
1165         qglDisable_real( cap );
1166         if ( GL_CULL_FACE != cap ) {
1167                 return;
1168         }
1169         if ( !ATIhack_culling ) {
1170                 return;
1171         }
1172         ATIhack_culling = 0;
1173         ATIhack_update();
1174 }
1175
1176 void APIENTRY qglCullFace_ATIHack( GLenum mode ){
1177         if ( ATIhack_cullmode == mode ) {
1178                 return;
1179         }
1180         qglCullFace_real( mode );
1181         ATIhack_cullmode = mode;
1182         ATIhack_update();
1183 }
1184
1185 void APIENTRY qglPolygonMode_ATIHack( GLenum face, GLenum mode ){
1186         switch ( face )
1187         {
1188         case GL_FRONT:
1189                 if ( ATIhack_frontmode == mode ) {
1190                         return;
1191                 }
1192                 ATIhack_frontmode = mode;
1193                 break;
1194         case GL_BACK:
1195                 if ( ATIhack_backmode == mode ) {
1196                         return;
1197                 }
1198                 ATIhack_backmode = mode;
1199                 break;
1200         case GL_FRONT_AND_BACK:
1201                 if ( ( ATIhack_frontmode == mode ) && ( ATIhack_backmode == mode ) ) {
1202                         return;
1203                 }
1204                 ATIhack_frontmode = ATIhack_backmode = mode;
1205         default:
1206                 break;
1207         }
1208         ATIhack_update();
1209 }
1210 #endif
1211
1212 int QGL_Init( const char *dllname, const char* gluname ){
1213 #ifdef _WIN32
1214         g_hGLDLL = LoadLibrary( dllname );
1215 #endif
1216
1217 #if defined ( __linux__ ) || ( __APPLE__ )
1218         const char *err;
1219
1220         // NOTE TTimo
1221         // I don't like RTLD_LAZY|RTLD_GLOBAL too much .. it's dangerous
1222         // maybe try RTLD_NOW? or would that break compatibility .. you never know when that stuff is going to explode
1223         g_hGLDLL = dlopen( dllname, RTLD_LAZY | RTLD_GLOBAL );
1224         err = dlerror();
1225         if ( err ) {
1226                 printf( "Error loading GL lib:\n%s\n", err );
1227         }
1228 #endif
1229         init_error = 0;
1230
1231         if ( g_hGLDLL == NULL ) {
1232                 return 0;
1233         }
1234
1235         Sys_Printf( "Loading GL library: %s ...", dllname );
1236
1237         qgluPerspective              = &gluPerspective2;
1238
1239         qgluLookAt                   = &gluLookAt2;
1240         qgluErrorString              = &gluErrorString;
1241         qglAccum                     = safe_dlsym( g_hGLDLL, "glAccum" );
1242         qglAlphaFunc                 = safe_dlsym( g_hGLDLL, "glAlphaFunc" );
1243         qglAreTexturesResident       = safe_dlsym( g_hGLDLL, "glAreTexturesResident" );
1244         qglArrayElement              = safe_dlsym( g_hGLDLL, "glArrayElement" );
1245         qglBegin                     = safe_dlsym( g_hGLDLL, "glBegin" );
1246         qglBindTexture               = safe_dlsym( g_hGLDLL, "glBindTexture" );
1247         qglBitmap                    = safe_dlsym( g_hGLDLL, "glBitmap" );
1248         qglBlendFunc                 = safe_dlsym( g_hGLDLL, "glBlendFunc" );
1249         qglCallList                  = safe_dlsym( g_hGLDLL, "glCallList" );
1250         qglCallLists                 = safe_dlsym( g_hGLDLL, "glCallLists" );
1251         qglClear                     = safe_dlsym( g_hGLDLL, "glClear" );
1252         qglClearAccum                = safe_dlsym( g_hGLDLL, "glClearAccum" );
1253         qglClearColor                = safe_dlsym( g_hGLDLL, "glClearColor" );
1254         qglClearDepth                = safe_dlsym( g_hGLDLL, "glClearDepth" );
1255         qglClearIndex                = safe_dlsym( g_hGLDLL, "glClearIndex" );
1256         qglClearStencil              = safe_dlsym( g_hGLDLL, "glClearStencil" );
1257         qglClipPlane                 = safe_dlsym( g_hGLDLL, "glClipPlane" );
1258         qglColor3b                   = safe_dlsym( g_hGLDLL, "glColor3b" );
1259         qglColor3bv                  = safe_dlsym( g_hGLDLL, "glColor3bv" );
1260         qglColor3d                   = safe_dlsym( g_hGLDLL, "glColor3d" );
1261         qglColor3dv                  = safe_dlsym( g_hGLDLL, "glColor3dv" );
1262         qglColor3f                   = safe_dlsym( g_hGLDLL, "glColor3f" );
1263         qglColor3fv                  = safe_dlsym( g_hGLDLL, "glColor3fv" );
1264         qglColor3i                   = safe_dlsym( g_hGLDLL, "glColor3i" );
1265         qglColor3iv                  = safe_dlsym( g_hGLDLL, "glColor3iv" );
1266         qglColor3s                   = safe_dlsym( g_hGLDLL, "glColor3s" );
1267         qglColor3sv                  = safe_dlsym( g_hGLDLL, "glColor3sv" );
1268         qglColor3ub                  = safe_dlsym( g_hGLDLL, "glColor3ub" );
1269         qglColor3ubv                 = safe_dlsym( g_hGLDLL, "glColor3ubv" );
1270         qglColor3ui                  = safe_dlsym( g_hGLDLL, "glColor3ui" );
1271         qglColor3uiv                 = safe_dlsym( g_hGLDLL, "glColor3uiv" );
1272         qglColor3us                  = safe_dlsym( g_hGLDLL, "glColor3us" );
1273         qglColor3usv                 = safe_dlsym( g_hGLDLL, "glColor3usv" );
1274         qglColor4b                   = safe_dlsym( g_hGLDLL, "glColor4b" );
1275         qglColor4bv                  = safe_dlsym( g_hGLDLL, "glColor4bv" );
1276         qglColor4d                   = safe_dlsym( g_hGLDLL, "glColor4d" );
1277         qglColor4dv                  = safe_dlsym( g_hGLDLL, "glColor4dv" );
1278         qglColor4f                   = safe_dlsym( g_hGLDLL, "glColor4f" );
1279         qglColor4fv                  = safe_dlsym( g_hGLDLL, "glColor4fv" );
1280         qglColor4i                   = safe_dlsym( g_hGLDLL, "glColor4i" );
1281         qglColor4iv                  = safe_dlsym( g_hGLDLL, "glColor4iv" );
1282         qglColor4s                   = safe_dlsym( g_hGLDLL, "glColor4s" );
1283         qglColor4sv                  = safe_dlsym( g_hGLDLL, "glColor4sv" );
1284         qglColor4ub                  = safe_dlsym( g_hGLDLL, "glColor4ub" );
1285         qglColor4ubv                 = safe_dlsym( g_hGLDLL, "glColor4ubv" );
1286         qglColor4ui                  = safe_dlsym( g_hGLDLL, "glColor4ui" );
1287         qglColor4uiv                 = safe_dlsym( g_hGLDLL, "glColor4uiv" );
1288         qglColor4us                  = safe_dlsym( g_hGLDLL, "glColor4us" );
1289         qglColor4usv                 = safe_dlsym( g_hGLDLL, "glColor4usv" );
1290         qglColorMask                 = safe_dlsym( g_hGLDLL, "glColorMask" );
1291         qglColorMaterial             = safe_dlsym( g_hGLDLL, "glColorMaterial" );
1292         qglColorPointer              = safe_dlsym( g_hGLDLL, "glColorPointer" );
1293         qglCopyPixels                = safe_dlsym( g_hGLDLL, "glCopyPixels" );
1294         qglCopyTexImage1D            = safe_dlsym( g_hGLDLL, "glCopyTexImage1D" );
1295         qglCopyTexImage2D            = safe_dlsym( g_hGLDLL, "glCopyTexImage2D" );
1296         qglCopyTexSubImage1D         = safe_dlsym( g_hGLDLL, "glCopyTexSubImage1D" );
1297         qglCopyTexSubImage2D         = safe_dlsym( g_hGLDLL, "glCopyTexSubImage2D" );
1298 #ifdef ATIHACK_812
1299         qglCullFace_real              = safe_dlsym( g_hGLDLL, "glCullFace" );
1300         qglCullFace                  = qglCullFace_real;
1301 #else
1302         qglCullFace                  = safe_dlsym( g_hGLDLL, "glCullFace" );
1303 #endif
1304         qglDeleteLists               = safe_dlsym( g_hGLDLL, "glDeleteLists" );
1305         qglDeleteTextures            = safe_dlsym( g_hGLDLL, "glDeleteTextures" );
1306         qglDepthFunc                 = safe_dlsym( g_hGLDLL, "glDepthFunc" );
1307         qglDepthMask                 = safe_dlsym( g_hGLDLL, "glDepthMask" );
1308         qglDepthRange                = safe_dlsym( g_hGLDLL, "glDepthRange" );
1309 #ifdef ATIHACK_812
1310         qglDisable_real               = safe_dlsym( g_hGLDLL, "glDisable" );
1311         qglDisable                   = qglDisable_real;
1312 #else
1313         qglDisable                   = safe_dlsym( g_hGLDLL, "glDisable" );
1314 #endif
1315         qglDisableClientState        = safe_dlsym( g_hGLDLL, "glDisableClientState" );
1316         qglDrawArrays                = safe_dlsym( g_hGLDLL, "glDrawArrays" );
1317         qglDrawBuffer                = safe_dlsym( g_hGLDLL, "glDrawBuffer" );
1318         qglDrawElements              = safe_dlsym( g_hGLDLL, "glDrawElements" );
1319         qglDrawPixels                = safe_dlsym( g_hGLDLL, "glDrawPixels" );
1320         qglEdgeFlag                  = safe_dlsym( g_hGLDLL, "glEdgeFlag" );
1321         qglEdgeFlagPointer           = safe_dlsym( g_hGLDLL, "glEdgeFlagPointer" );
1322         qglEdgeFlagv                 = safe_dlsym( g_hGLDLL, "glEdgeFlagv" );
1323 #ifdef ATIHACK_812
1324         qglEnable_real                = safe_dlsym( g_hGLDLL, "glEnable" );
1325         qglEnable                    = qglEnable_real;
1326 #else
1327         qglEnable                    = safe_dlsym( g_hGLDLL, "glEnable" );
1328 #endif
1329         qglEnableClientState         = safe_dlsym( g_hGLDLL, "glEnableClientState" );
1330         qglEnd                       = safe_dlsym( g_hGLDLL, "glEnd" );
1331         qglEndList                   = safe_dlsym( g_hGLDLL, "glEndList" );
1332         qglEvalCoord1d               = safe_dlsym( g_hGLDLL, "glEvalCoord1d" );
1333         qglEvalCoord1dv              = safe_dlsym( g_hGLDLL, "glEvalCoord1dv" );
1334         qglEvalCoord1f               = safe_dlsym( g_hGLDLL, "glEvalCoord1f" );
1335         qglEvalCoord1fv              = safe_dlsym( g_hGLDLL, "glEvalCoord1fv" );
1336         qglEvalCoord2d               = safe_dlsym( g_hGLDLL, "glEvalCoord2d" );
1337         qglEvalCoord2dv              = safe_dlsym( g_hGLDLL, "glEvalCoord2dv" );
1338         qglEvalCoord2f               = safe_dlsym( g_hGLDLL, "glEvalCoord2f" );
1339         qglEvalCoord2fv              = safe_dlsym( g_hGLDLL, "glEvalCoord2fv" );
1340         qglEvalMesh1                 = safe_dlsym( g_hGLDLL, "glEvalMesh1" );
1341         qglEvalMesh2                 = safe_dlsym( g_hGLDLL, "glEvalMesh2" );
1342         qglEvalPoint1                = safe_dlsym( g_hGLDLL, "glEvalPoint1" );
1343         qglEvalPoint2                = safe_dlsym( g_hGLDLL, "glEvalPoint2" );
1344         qglFeedbackBuffer            = safe_dlsym( g_hGLDLL, "glFeedbackBuffer" );
1345         qglFinish                    = safe_dlsym( g_hGLDLL, "glFinish" );
1346         qglFlush                     = safe_dlsym( g_hGLDLL, "glFlush" );
1347         qglFogf                      = safe_dlsym( g_hGLDLL, "glFogf" );
1348         qglFogfv                     = safe_dlsym( g_hGLDLL, "glFogfv" );
1349         qglFogi                      = safe_dlsym( g_hGLDLL, "glFogi" );
1350         qglFogiv                     = safe_dlsym( g_hGLDLL, "glFogiv" );
1351         qglFrontFace                 = safe_dlsym( g_hGLDLL, "glFrontFace" );
1352         qglFrustum                   = safe_dlsym( g_hGLDLL, "glFrustum" );
1353         qglGenLists                  = safe_dlsym( g_hGLDLL, "glGenLists" );
1354         qglGenTextures               = safe_dlsym( g_hGLDLL, "glGenTextures" );
1355         qglGetBooleanv               = safe_dlsym( g_hGLDLL, "glGetBooleanv" );
1356         qglGetClipPlane              = safe_dlsym( g_hGLDLL, "glGetClipPlane" );
1357         qglGetDoublev                = safe_dlsym( g_hGLDLL, "glGetDoublev" );
1358         qglGetError                  = safe_dlsym( g_hGLDLL, "glGetError" );
1359         qglGetFloatv                 = safe_dlsym( g_hGLDLL, "glGetFloatv" );
1360         qglGetIntegerv               = safe_dlsym( g_hGLDLL, "glGetIntegerv" );
1361         qglGetLightfv                = safe_dlsym( g_hGLDLL, "glGetLightfv" );
1362         qglGetLightiv                = safe_dlsym( g_hGLDLL, "glGetLightiv" );
1363         qglGetMapdv                  = safe_dlsym( g_hGLDLL, "glGetMapdv" );
1364         qglGetMapfv                  = safe_dlsym( g_hGLDLL, "glGetMapfv" );
1365         qglGetMapiv                  = safe_dlsym( g_hGLDLL, "glGetMapiv" );
1366         qglGetMaterialfv             = safe_dlsym( g_hGLDLL, "glGetMaterialfv" );
1367         qglGetMaterialiv             = safe_dlsym( g_hGLDLL, "glGetMaterialiv" );
1368         qglGetPixelMapfv             = safe_dlsym( g_hGLDLL, "glGetPixelMapfv" );
1369         qglGetPixelMapuiv            = safe_dlsym( g_hGLDLL, "glGetPixelMapuiv" );
1370         qglGetPixelMapusv            = safe_dlsym( g_hGLDLL, "glGetPixelMapusv" );
1371         qglGetPointerv               = safe_dlsym( g_hGLDLL, "glGetPointerv" );
1372         qglGetPolygonStipple         = safe_dlsym( g_hGLDLL, "glGetPolygonStipple" );
1373         qglGetString                 = safe_dlsym( g_hGLDLL, "glGetString" );
1374         qglGetTexEnvfv               = safe_dlsym( g_hGLDLL, "glGetTexEnvfv" );
1375         qglGetTexEnviv               = safe_dlsym( g_hGLDLL, "glGetTexEnviv" );
1376         qglGetTexGendv               = safe_dlsym( g_hGLDLL, "glGetTexGendv" );
1377         qglGetTexGenfv               = safe_dlsym( g_hGLDLL, "glGetTexGenfv" );
1378         qglGetTexGeniv               = safe_dlsym( g_hGLDLL, "glGetTexGeniv" );
1379         qglGetTexImage               = safe_dlsym( g_hGLDLL, "glGetTexImage" );
1380         qglGetTexLevelParameterfv    = safe_dlsym( g_hGLDLL, "glGetTexLevelParameterfv" );
1381         qglGetTexLevelParameteriv    = safe_dlsym( g_hGLDLL, "glGetTexLevelParameteriv" );
1382         qglGetTexParameterfv         = safe_dlsym( g_hGLDLL, "glGetTexParameterfv" );
1383         qglGetTexParameteriv         = safe_dlsym( g_hGLDLL, "glGetTexParameteriv" );
1384         qglHint                      = safe_dlsym( g_hGLDLL, "glHint" );
1385         qglIndexMask                 = safe_dlsym( g_hGLDLL, "glIndexMask" );
1386         qglIndexPointer              = safe_dlsym( g_hGLDLL, "glIndexPointer" );
1387         qglIndexd                    = safe_dlsym( g_hGLDLL, "glIndexd" );
1388         qglIndexdv                   = safe_dlsym( g_hGLDLL, "glIndexdv" );
1389         qglIndexf                    = safe_dlsym( g_hGLDLL, "glIndexf" );
1390         qglIndexfv                   = safe_dlsym( g_hGLDLL, "glIndexfv" );
1391         qglIndexi                    = safe_dlsym( g_hGLDLL, "glIndexi" );
1392         qglIndexiv                   = safe_dlsym( g_hGLDLL, "glIndexiv" );
1393         qglIndexs                    = safe_dlsym( g_hGLDLL, "glIndexs" );
1394         qglIndexsv                   = safe_dlsym( g_hGLDLL, "glIndexsv" );
1395         qglIndexub                   = safe_dlsym( g_hGLDLL, "glIndexub" );
1396         qglIndexubv                  = safe_dlsym( g_hGLDLL, "glIndexubv" );
1397         qglInitNames                 = safe_dlsym( g_hGLDLL, "glInitNames" );
1398         qglInterleavedArrays         = safe_dlsym( g_hGLDLL, "glInterleavedArrays" );
1399         qglIsEnabled                 = safe_dlsym( g_hGLDLL, "glIsEnabled" );
1400         qglIsList                    = safe_dlsym( g_hGLDLL, "glIsList" );
1401         qglIsTexture                 = safe_dlsym( g_hGLDLL, "glIsTexture" );
1402         qglLightModelf               = safe_dlsym( g_hGLDLL, "glLightModelf" );
1403         qglLightModelfv              = safe_dlsym( g_hGLDLL, "glLightModelfv" );
1404         qglLightModeli               = safe_dlsym( g_hGLDLL, "glLightModeli" );
1405         qglLightModeliv              = safe_dlsym( g_hGLDLL, "glLightModeliv" );
1406         qglLightf                    = safe_dlsym( g_hGLDLL, "glLightf" );
1407         qglLightfv                   = safe_dlsym( g_hGLDLL, "glLightfv" );
1408         qglLighti                    = safe_dlsym( g_hGLDLL, "glLighti" );
1409         qglLightiv                   = safe_dlsym( g_hGLDLL, "glLightiv" );
1410         qglLineStipple               = safe_dlsym( g_hGLDLL, "glLineStipple" );
1411         qglLineWidth                 = safe_dlsym( g_hGLDLL, "glLineWidth" );
1412         qglListBase                  = safe_dlsym( g_hGLDLL, "glListBase" );
1413         qglLoadIdentity              = safe_dlsym( g_hGLDLL, "glLoadIdentity" );
1414         qglLoadMatrixd               = safe_dlsym( g_hGLDLL, "glLoadMatrixd" );
1415         qglLoadMatrixf               = safe_dlsym( g_hGLDLL, "glLoadMatrixf" );
1416         qglLoadName                  = safe_dlsym( g_hGLDLL, "glLoadName" );
1417         qglLogicOp                   = safe_dlsym( g_hGLDLL, "glLogicOp" );
1418         qglMap1d                     = safe_dlsym( g_hGLDLL, "glMap1d" );
1419         qglMap1f                     = safe_dlsym( g_hGLDLL, "glMap1f" );
1420         qglMap2d                     = safe_dlsym( g_hGLDLL, "glMap2d" );
1421         qglMap2f                     = safe_dlsym( g_hGLDLL, "glMap2f" );
1422         qglMapGrid1d                 = safe_dlsym( g_hGLDLL, "glMapGrid1d" );
1423         qglMapGrid1f                 = safe_dlsym( g_hGLDLL, "glMapGrid1f" );
1424         qglMapGrid2d                 = safe_dlsym( g_hGLDLL, "glMapGrid2d" );
1425         qglMapGrid2f                 = safe_dlsym( g_hGLDLL, "glMapGrid2f" );
1426         qglMaterialf                 = safe_dlsym( g_hGLDLL, "glMaterialf" );
1427         qglMaterialfv                = safe_dlsym( g_hGLDLL, "glMaterialfv" );
1428         qglMateriali                 = safe_dlsym( g_hGLDLL, "glMateriali" );
1429         qglMaterialiv                = safe_dlsym( g_hGLDLL, "glMaterialiv" );
1430         qglMatrixMode                = safe_dlsym( g_hGLDLL, "glMatrixMode" );
1431         qglMultMatrixd               = safe_dlsym( g_hGLDLL, "glMultMatrixd" );
1432         qglMultMatrixf               = safe_dlsym( g_hGLDLL, "glMultMatrixf" );
1433         qglNewList                   = safe_dlsym( g_hGLDLL, "glNewList" );
1434         qglNormal3b                  = safe_dlsym( g_hGLDLL, "glNormal3b" );
1435         qglNormal3bv                 = safe_dlsym( g_hGLDLL, "glNormal3bv" );
1436         qglNormal3d                  = safe_dlsym( g_hGLDLL, "glNormal3d" );
1437         qglNormal3dv                 = safe_dlsym( g_hGLDLL, "glNormal3dv" );
1438         qglNormal3f                  = safe_dlsym( g_hGLDLL, "glNormal3f" );
1439         qglNormal3fv                 = safe_dlsym( g_hGLDLL, "glNormal3fv" );
1440         qglNormal3i                  = safe_dlsym( g_hGLDLL, "glNormal3i" );
1441         qglNormal3iv                 = safe_dlsym( g_hGLDLL, "glNormal3iv" );
1442         qglNormal3s                  = safe_dlsym( g_hGLDLL, "glNormal3s" );
1443         qglNormal3sv                 = safe_dlsym( g_hGLDLL, "glNormal3sv" );
1444         qglNormalPointer             = safe_dlsym( g_hGLDLL, "glNormalPointer" );
1445         qglOrtho                     = safe_dlsym( g_hGLDLL, "glOrtho" );
1446         qglPassThrough               = safe_dlsym( g_hGLDLL, "glPassThrough" );
1447         qglPixelMapfv                = safe_dlsym( g_hGLDLL, "glPixelMapfv" );
1448         qglPixelMapuiv               = safe_dlsym( g_hGLDLL, "glPixelMapuiv" );
1449         qglPixelMapusv               = safe_dlsym( g_hGLDLL, "glPixelMapusv" );
1450         qglPixelStoref               = safe_dlsym( g_hGLDLL, "glPixelStoref" );
1451         qglPixelStorei               = safe_dlsym( g_hGLDLL, "glPixelStorei" );
1452         qglPixelTransferf            = safe_dlsym( g_hGLDLL, "glPixelTransferf" );
1453         qglPixelTransferi            = safe_dlsym( g_hGLDLL, "glPixelTransferi" );
1454         qglPixelZoom                 = safe_dlsym( g_hGLDLL, "glPixelZoom" );
1455         qglPointSize                 = safe_dlsym( g_hGLDLL, "glPointSize" );
1456 #ifdef ATIHACK_812
1457         qglPolygonMode_real           = safe_dlsym( g_hGLDLL, "glPolygonMode" );
1458         qglPolygonMode               = qglPolygonMode_real;
1459 #else
1460         qglPolygonMode               = safe_dlsym( g_hGLDLL, "glPolygonMode" );
1461 #endif
1462         qglPolygonOffset             = safe_dlsym( g_hGLDLL, "glPolygonOffset" );
1463         qglPolygonStipple            = safe_dlsym( g_hGLDLL, "glPolygonStipple" );
1464         qglPopAttrib                 = safe_dlsym( g_hGLDLL, "glPopAttrib" );
1465         qglPopClientAttrib           = safe_dlsym( g_hGLDLL, "glPopClientAttrib" );
1466         qglPopMatrix                 = safe_dlsym( g_hGLDLL, "glPopMatrix" );
1467         qglPopName                   = safe_dlsym( g_hGLDLL, "glPopName" );
1468         qglPrioritizeTextures        = safe_dlsym( g_hGLDLL, "glPrioritizeTextures" );
1469         qglPushAttrib                = safe_dlsym( g_hGLDLL, "glPushAttrib" );
1470         qglPushClientAttrib          = safe_dlsym( g_hGLDLL, "glPushClientAttrib" );
1471         qglPushMatrix                = safe_dlsym( g_hGLDLL, "glPushMatrix" );
1472         qglPushName                  = safe_dlsym( g_hGLDLL, "glPushName" );
1473         qglRasterPos2d               = safe_dlsym( g_hGLDLL, "glRasterPos2d" );
1474         qglRasterPos2dv              = safe_dlsym( g_hGLDLL, "glRasterPos2dv" );
1475         qglRasterPos2f               = safe_dlsym( g_hGLDLL, "glRasterPos2f" );
1476         qglRasterPos2fv              = safe_dlsym( g_hGLDLL, "glRasterPos2fv" );
1477         qglRasterPos2i               = safe_dlsym( g_hGLDLL, "glRasterPos2i" );
1478         qglRasterPos2iv              = safe_dlsym( g_hGLDLL, "glRasterPos2iv" );
1479         qglRasterPos2s               = safe_dlsym( g_hGLDLL, "glRasterPos2s" );
1480         qglRasterPos2sv              = safe_dlsym( g_hGLDLL, "glRasterPos2sv" );
1481         qglRasterPos3d               = safe_dlsym( g_hGLDLL, "glRasterPos3d" );
1482         qglRasterPos3dv              = safe_dlsym( g_hGLDLL, "glRasterPos3dv" );
1483         qglRasterPos3f               = safe_dlsym( g_hGLDLL, "glRasterPos3f" );
1484         qglRasterPos3fv              = safe_dlsym( g_hGLDLL, "glRasterPos3fv" );
1485         qglRasterPos3i               = safe_dlsym( g_hGLDLL, "glRasterPos3i" );
1486         qglRasterPos3iv              = safe_dlsym( g_hGLDLL, "glRasterPos3iv" );
1487         qglRasterPos3s               = safe_dlsym( g_hGLDLL, "glRasterPos3s" );
1488         qglRasterPos3sv              = safe_dlsym( g_hGLDLL, "glRasterPos3sv" );
1489         qglRasterPos4d               = safe_dlsym( g_hGLDLL, "glRasterPos4d" );
1490         qglRasterPos4dv              = safe_dlsym( g_hGLDLL, "glRasterPos4dv" );
1491         qglRasterPos4f               = safe_dlsym( g_hGLDLL, "glRasterPos4f" );
1492         qglRasterPos4fv              = safe_dlsym( g_hGLDLL, "glRasterPos4fv" );
1493         qglRasterPos4i               = safe_dlsym( g_hGLDLL, "glRasterPos4i" );
1494         qglRasterPos4iv              = safe_dlsym( g_hGLDLL, "glRasterPos4iv" );
1495         qglRasterPos4s               = safe_dlsym( g_hGLDLL, "glRasterPos4s" );
1496         qglRasterPos4sv              = safe_dlsym( g_hGLDLL, "glRasterPos4sv" );
1497         qglReadBuffer                = safe_dlsym( g_hGLDLL, "glReadBuffer" );
1498         qglReadPixels                = safe_dlsym( g_hGLDLL, "glReadPixels" );
1499         qglRectd                     = safe_dlsym( g_hGLDLL, "glRectd" );
1500         qglRectdv                    = safe_dlsym( g_hGLDLL, "glRectdv" );
1501         qglRectf                     = safe_dlsym( g_hGLDLL, "glRectf" );
1502         qglRectfv                    = safe_dlsym( g_hGLDLL, "glRectfv" );
1503         qglRecti                     = safe_dlsym( g_hGLDLL, "glRecti" );
1504         qglRectiv                    = safe_dlsym( g_hGLDLL, "glRectiv" );
1505         qglRects                     = safe_dlsym( g_hGLDLL, "glRects" );
1506         qglRectsv                    = safe_dlsym( g_hGLDLL, "glRectsv" );
1507         qglRenderMode                = safe_dlsym( g_hGLDLL, "glRenderMode" );
1508         qglRotated                   = safe_dlsym( g_hGLDLL, "glRotated" );
1509         qglRotatef                   = safe_dlsym( g_hGLDLL, "glRotatef" );
1510         qglScaled                    = safe_dlsym( g_hGLDLL, "glScaled" );
1511         qglScalef                    = safe_dlsym( g_hGLDLL, "glScalef" );
1512         qglScissor                   = safe_dlsym( g_hGLDLL, "glScissor" );
1513         qglSelectBuffer              = safe_dlsym( g_hGLDLL, "glSelectBuffer" );
1514         qglShadeModel                = safe_dlsym( g_hGLDLL, "glShadeModel" );
1515         qglStencilFunc               = safe_dlsym( g_hGLDLL, "glStencilFunc" );
1516         qglStencilMask               = safe_dlsym( g_hGLDLL, "glStencilMask" );
1517         qglStencilOp                 = safe_dlsym( g_hGLDLL, "glStencilOp" );
1518         qglTexCoord1d                = safe_dlsym( g_hGLDLL, "glTexCoord1d" );
1519         qglTexCoord1dv               = safe_dlsym( g_hGLDLL, "glTexCoord1dv" );
1520         qglTexCoord1f                = safe_dlsym( g_hGLDLL, "glTexCoord1f" );
1521         qglTexCoord1fv               = safe_dlsym( g_hGLDLL, "glTexCoord1fv" );
1522         qglTexCoord1i                = safe_dlsym( g_hGLDLL, "glTexCoord1i" );
1523         qglTexCoord1iv               = safe_dlsym( g_hGLDLL, "glTexCoord1iv" );
1524         qglTexCoord1s                = safe_dlsym( g_hGLDLL, "glTexCoord1s" );
1525         qglTexCoord1sv               = safe_dlsym( g_hGLDLL, "glTexCoord1sv" );
1526         qglTexCoord2d                = safe_dlsym( g_hGLDLL, "glTexCoord2d" );
1527         qglTexCoord2dv               = safe_dlsym( g_hGLDLL, "glTexCoord2dv" );
1528         qglTexCoord2f                = safe_dlsym( g_hGLDLL, "glTexCoord2f" );
1529         qglTexCoord2fv               = safe_dlsym( g_hGLDLL, "glTexCoord2fv" );
1530         qglTexCoord2i                = safe_dlsym( g_hGLDLL, "glTexCoord2i" );
1531         qglTexCoord2iv               = safe_dlsym( g_hGLDLL, "glTexCoord2iv" );
1532         qglTexCoord2s                = safe_dlsym( g_hGLDLL, "glTexCoord2s" );
1533         qglTexCoord2sv               = safe_dlsym( g_hGLDLL, "glTexCoord2sv" );
1534         qglTexCoord3d                = safe_dlsym( g_hGLDLL, "glTexCoord3d" );
1535         qglTexCoord3dv               = safe_dlsym( g_hGLDLL, "glTexCoord3dv" );
1536         qglTexCoord3f                = safe_dlsym( g_hGLDLL, "glTexCoord3f" );
1537         qglTexCoord3fv               = safe_dlsym( g_hGLDLL, "glTexCoord3fv" );
1538         qglTexCoord3i                = safe_dlsym( g_hGLDLL, "glTexCoord3i" );
1539         qglTexCoord3iv               = safe_dlsym( g_hGLDLL, "glTexCoord3iv" );
1540         qglTexCoord3s                = safe_dlsym( g_hGLDLL, "glTexCoord3s" );
1541         qglTexCoord3sv               = safe_dlsym( g_hGLDLL, "glTexCoord3sv" );
1542         qglTexCoord4d                = safe_dlsym( g_hGLDLL, "glTexCoord4d" );
1543         qglTexCoord4dv               = safe_dlsym( g_hGLDLL, "glTexCoord4dv" );
1544         qglTexCoord4f                = safe_dlsym( g_hGLDLL, "glTexCoord4f" );
1545         qglTexCoord4fv               = safe_dlsym( g_hGLDLL, "glTexCoord4fv" );
1546         qglTexCoord4i                = safe_dlsym( g_hGLDLL, "glTexCoord4i" );
1547         qglTexCoord4iv               = safe_dlsym( g_hGLDLL, "glTexCoord4iv" );
1548         qglTexCoord4s                = safe_dlsym( g_hGLDLL, "glTexCoord4s" );
1549         qglTexCoord4sv               = safe_dlsym( g_hGLDLL, "glTexCoord4sv" );
1550         qglTexCoordPointer           = safe_dlsym( g_hGLDLL, "glTexCoordPointer" );
1551         qglTexEnvf                   = safe_dlsym( g_hGLDLL, "glTexEnvf" );
1552         qglTexEnvfv                  = safe_dlsym( g_hGLDLL, "glTexEnvfv" );
1553         qglTexEnvi                   = safe_dlsym( g_hGLDLL, "glTexEnvi" );
1554         qglTexEnviv                  = safe_dlsym( g_hGLDLL, "glTexEnviv" );
1555         qglTexGend                   = safe_dlsym( g_hGLDLL, "glTexGend" );
1556         qglTexGendv                  = safe_dlsym( g_hGLDLL, "glTexGendv" );
1557         qglTexGenf                   = safe_dlsym( g_hGLDLL, "glTexGenf" );
1558         qglTexGenfv                  = safe_dlsym( g_hGLDLL, "glTexGenfv" );
1559         qglTexGeni                   = safe_dlsym( g_hGLDLL, "glTexGeni" );
1560         qglTexGeniv                  = safe_dlsym( g_hGLDLL, "glTexGeniv" );
1561         qglTexImage1D                = safe_dlsym( g_hGLDLL, "glTexImage1D" );
1562         qglTexImage2D                = safe_dlsym( g_hGLDLL, "glTexImage2D" );
1563         qglTexParameterf             = safe_dlsym( g_hGLDLL, "glTexParameterf" );
1564         qglTexParameterfv            = safe_dlsym( g_hGLDLL, "glTexParameterfv" );
1565         qglTexParameteri             = safe_dlsym( g_hGLDLL, "glTexParameteri" );
1566         qglTexParameteriv            = safe_dlsym( g_hGLDLL, "glTexParameteriv" );
1567         qglTexSubImage1D             = safe_dlsym( g_hGLDLL, "glTexSubImage1D" );
1568         qglTexSubImage2D             = safe_dlsym( g_hGLDLL, "glTexSubImage2D" );
1569         qglTranslated                = safe_dlsym( g_hGLDLL, "glTranslated" );
1570         qglTranslatef                = safe_dlsym( g_hGLDLL, "glTranslatef" );
1571         qglVertex2d                  = safe_dlsym( g_hGLDLL, "glVertex2d" );
1572         qglVertex2dv                 = safe_dlsym( g_hGLDLL, "glVertex2dv" );
1573         qglVertex2f                  = safe_dlsym( g_hGLDLL, "glVertex2f" );
1574         qglVertex2fv                 = safe_dlsym( g_hGLDLL, "glVertex2fv" );
1575         qglVertex2i                  = safe_dlsym( g_hGLDLL, "glVertex2i" );
1576         qglVertex2iv                 = safe_dlsym( g_hGLDLL, "glVertex2iv" );
1577         qglVertex2s                  = safe_dlsym( g_hGLDLL, "glVertex2s" );
1578         qglVertex2sv                 = safe_dlsym( g_hGLDLL, "glVertex2sv" );
1579         qglVertex3d                  = safe_dlsym( g_hGLDLL, "glVertex3d" );
1580         qglVertex3dv                 = safe_dlsym( g_hGLDLL, "glVertex3dv" );
1581         qglVertex3f                  = safe_dlsym( g_hGLDLL, "glVertex3f" );
1582         qglVertex3fv                 = safe_dlsym( g_hGLDLL, "glVertex3fv" );
1583         qglVertex3i                  = safe_dlsym( g_hGLDLL, "glVertex3i" );
1584         qglVertex3iv                 = safe_dlsym( g_hGLDLL, "glVertex3iv" );
1585         qglVertex3s                  = safe_dlsym( g_hGLDLL, "glVertex3s" );
1586         qglVertex3sv                 = safe_dlsym( g_hGLDLL, "glVertex3sv" );
1587         qglVertex4d                  = safe_dlsym( g_hGLDLL, "glVertex4d" );
1588         qglVertex4dv                 = safe_dlsym( g_hGLDLL, "glVertex4dv" );
1589         qglVertex4f                  = safe_dlsym( g_hGLDLL, "glVertex4f" );
1590         qglVertex4fv                 = safe_dlsym( g_hGLDLL, "glVertex4fv" );
1591         qglVertex4i                  = safe_dlsym( g_hGLDLL, "glVertex4i" );
1592         qglVertex4iv                 = safe_dlsym( g_hGLDLL, "glVertex4iv" );
1593         qglVertex4s                  = safe_dlsym( g_hGLDLL, "glVertex4s" );
1594         qglVertex4sv                 = safe_dlsym( g_hGLDLL, "glVertex4sv" );
1595         qglVertexPointer             = safe_dlsym( g_hGLDLL, "glVertexPointer" );
1596         qglViewport                  = safe_dlsym( g_hGLDLL, "glViewport" );
1597
1598         // must be init with an active context
1599         qglActiveTextureARB = NULL;
1600         qglClientActiveTextureARB = NULL;
1601         qglMultiTexCoord1dARB = NULL;
1602         qglMultiTexCoord1dvARB = NULL;
1603         qglMultiTexCoord1fARB = NULL;
1604         qglMultiTexCoord1fvARB = NULL;
1605         qglMultiTexCoord1iARB = NULL;
1606         qglMultiTexCoord1ivARB = NULL;
1607         qglMultiTexCoord1sARB = NULL;
1608         qglMultiTexCoord1svARB = NULL;
1609         qglMultiTexCoord2dARB = NULL;
1610         qglMultiTexCoord2dvARB = NULL;
1611         qglMultiTexCoord2fARB = NULL;
1612         qglMultiTexCoord2fvARB = NULL;
1613         qglMultiTexCoord2iARB = NULL;
1614         qglMultiTexCoord2ivARB = NULL;
1615         qglMultiTexCoord2sARB = NULL;
1616         qglMultiTexCoord2svARB = NULL;
1617         qglMultiTexCoord3dARB = NULL;
1618         qglMultiTexCoord3dvARB = NULL;
1619         qglMultiTexCoord3fARB = NULL;
1620         qglMultiTexCoord3fvARB = NULL;
1621         qglMultiTexCoord3iARB = NULL;
1622         qglMultiTexCoord3ivARB = NULL;
1623         qglMultiTexCoord3sARB = NULL;
1624         qglMultiTexCoord3svARB = NULL;
1625         qglMultiTexCoord4dARB = NULL;
1626         qglMultiTexCoord4dvARB = NULL;
1627         qglMultiTexCoord4fARB = NULL;
1628         qglMultiTexCoord4fvARB = NULL;
1629         qglMultiTexCoord4iARB = NULL;
1630         qglMultiTexCoord4ivARB = NULL;
1631         qglMultiTexCoord4sARB = NULL;
1632         qglMultiTexCoord4svARB = NULL;
1633
1634 #ifdef _WIN32
1635         qwglCopyContext              = safe_dlsym( g_hGLDLL, "wglCopyContext" );
1636         qwglCreateContext            = safe_dlsym( g_hGLDLL, "wglCreateContext" );
1637         qwglCreateLayerContext       = safe_dlsym( g_hGLDLL, "wglCreateLayerContext" );
1638         qwglDeleteContext            = safe_dlsym( g_hGLDLL, "wglDeleteContext" );
1639         qwglDescribeLayerPlane       = safe_dlsym( g_hGLDLL, "wglDescribeLayerPlane" );
1640         qwglGetCurrentContext        = safe_dlsym( g_hGLDLL, "wglGetCurrentContext" );
1641         qwglGetCurrentDC             = safe_dlsym( g_hGLDLL, "wglGetCurrentDC" );
1642         qwglGetLayerPaletteEntries   = safe_dlsym( g_hGLDLL, "wglGetLayerPaletteEntries" );
1643         qwglGetProcAddress           = safe_dlsym( g_hGLDLL, "wglGetProcAddress" );
1644         qwglMakeCurrent              = safe_dlsym( g_hGLDLL, "wglMakeCurrent" );
1645         qwglRealizeLayerPalette      = safe_dlsym( g_hGLDLL, "wglRealizeLayerPalette" );
1646         qwglSetLayerPaletteEntries   = safe_dlsym( g_hGLDLL, "wglSetLayerPaletteEntries" );
1647         qwglShareLists               = safe_dlsym( g_hGLDLL, "wglShareLists" );
1648         qwglSwapLayerBuffers         = safe_dlsym( g_hGLDLL, "wglSwapLayerBuffers" );
1649         qwglUseFontBitmaps           = safe_dlsym( g_hGLDLL, "wglUseFontBitmapsA" );
1650         qwglUseFontOutlines          = safe_dlsym( g_hGLDLL, "wglUseFontOutlinesA" );
1651
1652         qwglChoosePixelFormat        = safe_dlsym( g_hGLDLL, "wglChoosePixelFormat" );
1653         qwglDescribePixelFormat      = safe_dlsym( g_hGLDLL, "wglDescribePixelFormat" );
1654         qwglGetPixelFormat           = safe_dlsym( g_hGLDLL, "wglGetPixelFormat" );
1655         qwglSetPixelFormat           = safe_dlsym( g_hGLDLL, "wglSetPixelFormat" );
1656         qwglSwapBuffers              = safe_dlsym( g_hGLDLL, "wglSwapBuffers" );
1657
1658         qwglSwapIntervalEXT = 0;
1659         qglPointParameterfEXT = 0;
1660         qglPointParameterfvEXT = 0;
1661         qglColorTableEXT = 0;
1662         qglSelectTextureSGIS = 0;
1663         qglMTexCoord2fSGIS = 0;
1664 #endif
1665
1666 #if defined ( __linux__ ) || defined ( __APPLE__ )
1667         qglXChooseVisual             = safe_dlsym( g_hGLDLL, "glXChooseVisual" );
1668         qglXCreateContext            = safe_dlsym( g_hGLDLL, "glXCreateContext" );
1669         qglXDestroyContext           = safe_dlsym( g_hGLDLL, "glXDestroyContext" );
1670         qglXMakeCurrent              = safe_dlsym( g_hGLDLL, "glXMakeCurrent" );
1671         qglXCopyContext              = safe_dlsym( g_hGLDLL, "glXCopyContext" );
1672         qglXSwapBuffers              = safe_dlsym( g_hGLDLL, "glXSwapBuffers" );
1673         qglXCreateGLXPixmap          = safe_dlsym( g_hGLDLL, "glXCreateGLXPixmap" );
1674         qglXDestroyGLXPixmap         = safe_dlsym( g_hGLDLL, "glXDestroyGLXPixmap" );
1675         qglXQueryExtension           = safe_dlsym( g_hGLDLL, "glXQueryExtension" );
1676         qglXQueryVersion             = safe_dlsym( g_hGLDLL, "glXQueryVersion" );
1677         qglXIsDirect                 = safe_dlsym( g_hGLDLL, "glXIsDirect" );
1678         qglXGetConfig                = safe_dlsym( g_hGLDLL, "glXGetConfig" );
1679         qglXGetCurrentContext        = safe_dlsym( g_hGLDLL, "glXGetCurrentContext" );
1680         qglXGetCurrentDrawable       = safe_dlsym( g_hGLDLL, "glXGetCurrentDrawable" );
1681         qglXWaitGL                   = safe_dlsym( g_hGLDLL, "glXWaitGL" );
1682         qglXWaitX                    = safe_dlsym( g_hGLDLL, "glXWaitX" );
1683         qglXUseXFont                 = safe_dlsym( g_hGLDLL, "glXUseXFont" );
1684 //  qglXGetProcAddressARB        = dlsym (g_hGLDLL, "glXGetProcAddressARB"); // Utah-GLX fix
1685 #endif
1686
1687         qglPointParameterfEXT = 0;
1688         qglPointParameterfvEXT = 0;
1689         qglColorTableEXT = 0;
1690         qglSelectTextureSGIS = 0;
1691         qglMTexCoord2fSGIS = 0;
1692
1693         // texture compression
1694         Sys_Printf( "Done.\n" );
1695
1696 #ifdef ATIHACK_812
1697         ATIhack_culling = 0;
1698         ATIhack_cullmode = GL_BACK;
1699         ATIhack_backmode = GL_FILL;
1700         ATIhack_frontmode = GL_FILL;
1701 #endif
1702
1703         if ( init_error == 1 ) {
1704                 return 0;
1705         }
1706
1707         return 1;
1708 }
1709
1710 int GL_ExtensionSupported( const char *extension ){
1711         const GLubyte *extensions = NULL;
1712         const GLubyte *start;
1713         GLubyte *where, *terminator;
1714
1715         // Extension names should not have spaces.
1716         where = (GLubyte *) strchr( extension, ' ' );
1717         if ( where || *extension == '\0' ) {
1718                 return 0;
1719         }
1720
1721         extensions = qglGetString( GL_EXTENSIONS );
1722 #ifndef __APPLE__
1723         if ( !extensions ) {
1724                 return 0;
1725         }
1726 #endif
1727
1728         // It takes a bit of care to be fool-proof about parsing the
1729         // OpenGL extensions string. Don't be fooled by sub-strings, etc.
1730         for ( start = extensions; ; )
1731         {
1732                 where = (GLubyte *) strstr( (const char *) start, extension );
1733                 if ( !where ) {
1734                         break;
1735                 }
1736
1737                 terminator = where + strlen( extension );
1738                 if ( where == start || *( where - 1 ) == ' ' ) {
1739                         if ( *terminator == ' ' || *terminator == '\0' ) {
1740                                 return 1;
1741                         }
1742                 }
1743
1744                 start = terminator;
1745         }
1746
1747         return 0;
1748 }
1749
1750 void* Sys_GLGetExtension( const char *symbol ){
1751 #if defined ( __linux__ ) || defined ( __APPLE__ )
1752         if ( qglXGetProcAddressARB == NULL ) {
1753                 return NULL;
1754         }
1755         else{
1756                 return qglXGetProcAddressARB( (GLubyte*)symbol );
1757         }
1758 #else
1759         return qwglGetProcAddress( symbol );
1760 #endif
1761 }
1762
1763 void QGL_InitExtensions(){
1764         if ( GL_ExtensionSupported( "GL_ARB_multitexture" ) ) {
1765                 qglActiveTextureARB = Sys_GLGetExtension( "glActiveTextureARB" );
1766                 qglClientActiveTextureARB = Sys_GLGetExtension( "glClientActiveTextureARB" );
1767                 qglMultiTexCoord1dARB = Sys_GLGetExtension( "glMultiTexCoord1dARB" );
1768                 qglMultiTexCoord1dvARB = Sys_GLGetExtension( "glMultiTexCoord1dvARB" );
1769                 qglMultiTexCoord1fARB = Sys_GLGetExtension( "glMultiTexCoord1fARB" );
1770                 qglMultiTexCoord1fvARB = Sys_GLGetExtension( "glMultiTexCoord1fvARB" );
1771                 qglMultiTexCoord1iARB = Sys_GLGetExtension( "glMultiTexCoord1iARB" );
1772                 qglMultiTexCoord1ivARB = Sys_GLGetExtension( "glMultiTexCoord1ivARB" );
1773                 qglMultiTexCoord1sARB = Sys_GLGetExtension( "glMultiTexCoord1sARB" );
1774                 qglMultiTexCoord1svARB = Sys_GLGetExtension( "glMultiTexCoord1svARB" );
1775                 qglMultiTexCoord2dARB = Sys_GLGetExtension( "glMultiTexCoord2dARB" );
1776                 qglMultiTexCoord2dvARB = Sys_GLGetExtension( "glMultiTexCoord2dvARB" );
1777                 qglMultiTexCoord2fARB = Sys_GLGetExtension( "glMultiTexCoord2fARB" );
1778                 qglMultiTexCoord2fvARB = Sys_GLGetExtension( "glMultiTexCoord2fvARB" );
1779                 qglMultiTexCoord2iARB = Sys_GLGetExtension( "glMultiTexCoord2iARB" );
1780                 qglMultiTexCoord2ivARB = Sys_GLGetExtension( "glMultiTexCoord2ivARB" );
1781                 qglMultiTexCoord2sARB = Sys_GLGetExtension( "glMultiTexCoord2sARB" );
1782                 qglMultiTexCoord2svARB = Sys_GLGetExtension( "glMultiTexCoord2svARB" );
1783                 qglMultiTexCoord3dARB = Sys_GLGetExtension( "glMultiTexCoord3dARB" );
1784                 qglMultiTexCoord3dvARB = Sys_GLGetExtension( "glMultiTexCoord3dvARB" );
1785                 qglMultiTexCoord3fARB = Sys_GLGetExtension( "glMultiTexCoord3fARB" );
1786                 qglMultiTexCoord3fvARB = Sys_GLGetExtension( "glMultiTexCoord3fvARB" );
1787                 qglMultiTexCoord3iARB = Sys_GLGetExtension( "glMultiTexCoord3iARB" );
1788                 qglMultiTexCoord3ivARB = Sys_GLGetExtension( "glMultiTexCoord3ivARB" );
1789                 qglMultiTexCoord3sARB = Sys_GLGetExtension( "glMultiTexCoord3sARB" );
1790                 qglMultiTexCoord3svARB = Sys_GLGetExtension( "glMultiTexCoord3svARB" );
1791                 qglMultiTexCoord4dARB = Sys_GLGetExtension( "glMultiTexCoord4dARB" );
1792                 qglMultiTexCoord4dvARB = Sys_GLGetExtension( "glMultiTexCoord4dvARB" );
1793                 qglMultiTexCoord4fARB = Sys_GLGetExtension( "glMultiTexCoord4fARB" );
1794                 qglMultiTexCoord4fvARB = Sys_GLGetExtension( "glMultiTexCoord4fvARB" );
1795                 qglMultiTexCoord4iARB = Sys_GLGetExtension( "glMultiTexCoord4iARB" );
1796                 qglMultiTexCoord4ivARB = Sys_GLGetExtension( "glMultiTexCoord4ivARB" );
1797                 qglMultiTexCoord4sARB = Sys_GLGetExtension( "glMultiTexCoord4sARB" );
1798                 qglMultiTexCoord4svARB = Sys_GLGetExtension( "glMultiTexCoord4svARB" );
1799         }
1800 }