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