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