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