apply misc fixes from Markus Fischer and Rambetter
[xonotic/netradiant.git] / 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 }