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