1 /*
2 ===========================================================================
3 Copyright (C) 1999-2005 Id Software, Inc.
4 Copyright (C) 2000-2006 Tim Angus
5
6 This file is part of Tremulous.
7
8 Tremulous is free software; you can redistribute it
9 and/or modify it under the terms of the GNU General Public License as
10 published by the Free Software Foundation; either version 2 of the License,
11 or (at your option) any later version.
12
13 Tremulous is distributed in the hope that it will be
14 useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with Tremulous; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
21 ===========================================================================
22 */
23 /*
24 ** QGL_WIN.C
25 **
26 ** This file implements the operating system binding of GL to QGL function
27 ** pointers. When doing a port of Quake3 you must implement the following
28 ** two functions:
29 **
30 ** QGL_Init() - loads libraries, assigns function pointers, etc.
31 ** QGL_Shutdown() - unloads libraries, NULLs function pointers
32 */
33 #include <float.h>
34 #include "../renderer/tr_local.h"
35 #include "glw_win.h"
36
37 void QGL_EnableLogging( qboolean enable );
38
39 int ( WINAPI * qwglSwapIntervalEXT)( int interval );
40 BOOL ( WINAPI * qwglGetDeviceGammaRamp3DFX)( HDC, LPVOID );
41 BOOL ( WINAPI * qwglSetDeviceGammaRamp3DFX)( HDC, LPVOID );
42
43 int ( WINAPI * qwglChoosePixelFormat )(HDC, CONST PIXELFORMATDESCRIPTOR *);
44 int ( WINAPI * qwglDescribePixelFormat) (HDC, int, UINT, LPPIXELFORMATDESCRIPTOR);
45 int ( WINAPI * qwglGetPixelFormat)(HDC);
46 BOOL ( WINAPI * qwglSetPixelFormat)(HDC, int, CONST PIXELFORMATDESCRIPTOR *);
47 BOOL ( WINAPI * qwglSwapBuffers)(HDC);
48
49 BOOL ( WINAPI * qwglCopyContext)(HGLRC, HGLRC, UINT);
50 HGLRC ( WINAPI * qwglCreateContext)(HDC);
51 HGLRC ( WINAPI * qwglCreateLayerContext)(HDC, int);
52 BOOL ( WINAPI * qwglDeleteContext)(HGLRC);
53 HGLRC ( WINAPI * qwglGetCurrentContext)(VOID);
54 HDC ( WINAPI * qwglGetCurrentDC)(VOID);
55 PROC ( WINAPI * qwglGetProcAddress)(LPCSTR);
56 BOOL ( WINAPI * qwglMakeCurrent)(HDC, HGLRC);
57 BOOL ( WINAPI * qwglShareLists)(HGLRC, HGLRC);
58 BOOL ( WINAPI * qwglUseFontBitmaps)(HDC, DWORD, DWORD, DWORD);
59
60 BOOL ( WINAPI * qwglUseFontOutlines)(HDC, DWORD, DWORD, DWORD, FLOAT,
61 FLOAT, int, LPGLYPHMETRICSFLOAT);
62
63 BOOL ( WINAPI * qwglDescribeLayerPlane)(HDC, int, int, UINT,
64 LPLAYERPLANEDESCRIPTOR);
65 int ( WINAPI * qwglSetLayerPaletteEntries)(HDC, int, int, int,
66 CONST COLORREF *);
67 int ( WINAPI * qwglGetLayerPaletteEntries)(HDC, int, int, int,
68 COLORREF *);
69 BOOL ( WINAPI * qwglRealizeLayerPalette)(HDC, int, BOOL);
70 BOOL ( WINAPI * qwglSwapLayerBuffers)(HDC, UINT);
71
72 void ( APIENTRY * qglAccum )(GLenum op, GLfloat value);
73 void ( APIENTRY * qglAlphaFunc )(GLenum func, GLclampf ref);
74 GLboolean ( APIENTRY * qglAreTexturesResident )(GLsizei n, const GLuint *textures, GLboolean *residences);
75 void ( APIENTRY * qglArrayElement )(GLint i);
76 void ( APIENTRY * qglBegin )(GLenum mode);
77 void ( APIENTRY * qglBindTexture )(GLenum target, GLuint texture);
78 void ( APIENTRY * qglBitmap )(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap);
79 void ( APIENTRY * qglBlendFunc )(GLenum sfactor, GLenum dfactor);
80 void ( APIENTRY * qglCallList )(GLuint list);
81 void ( APIENTRY * qglCallLists )(GLsizei n, GLenum type, const GLvoid *lists);
82 void ( APIENTRY * qglClear )(GLbitfield mask);
83 void ( APIENTRY * qglClearAccum )(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
84 void ( APIENTRY * qglClearColor )(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
85 void ( APIENTRY * qglClearDepth )(GLclampd depth);
86 void ( APIENTRY * qglClearIndex )(GLfloat c);
87 void ( APIENTRY * qglClearStencil )(GLint s);
88 void ( APIENTRY * qglClipPlane )(GLenum plane, const GLdouble *equation);
89 void ( APIENTRY * qglColor3b )(GLbyte red, GLbyte green, GLbyte blue);
90 void ( APIENTRY * qglColor3bv )(const GLbyte *v);
91 void ( APIENTRY * qglColor3d )(GLdouble red, GLdouble green, GLdouble blue);
92 void ( APIENTRY * qglColor3dv )(const GLdouble *v);
93 void ( APIENTRY * qglColor3f )(GLfloat red, GLfloat green, GLfloat blue);
94 void ( APIENTRY * qglColor3fv )(const GLfloat *v);
95 void ( APIENTRY * qglColor3i )(GLint red, GLint green, GLint blue);
96 void ( APIENTRY * qglColor3iv )(const GLint *v);
97 void ( APIENTRY * qglColor3s )(GLshort red, GLshort green, GLshort blue);
98 void ( APIENTRY * qglColor3sv )(const GLshort *v);
99 void ( APIENTRY * qglColor3ub )(GLubyte red, GLubyte green, GLubyte blue);
100 void ( APIENTRY * qglColor3ubv )(const GLubyte *v);
101 void ( APIENTRY * qglColor3ui )(GLuint red, GLuint green, GLuint blue);
102 void ( APIENTRY * qglColor3uiv )(const GLuint *v);
103 void ( APIENTRY * qglColor3us )(GLushort red, GLushort green, GLushort blue);
104 void ( APIENTRY * qglColor3usv )(const GLushort *v);
105 void ( APIENTRY * qglColor4b )(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha);
106 void ( APIENTRY * qglColor4bv )(const GLbyte *v);
107 void ( APIENTRY * qglColor4d )(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha);
108 void ( APIENTRY * qglColor4dv )(const GLdouble *v);
109 void ( APIENTRY * qglColor4f )(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
110 void ( APIENTRY * qglColor4fv )(const GLfloat *v);
111 void ( APIENTRY * qglColor4i )(GLint red, GLint green, GLint blue, GLint alpha);
112 void ( APIENTRY * qglColor4iv )(const GLint *v);
113 void ( APIENTRY * qglColor4s )(GLshort red, GLshort green, GLshort blue, GLshort alpha);
114 void ( APIENTRY * qglColor4sv )(const GLshort *v);
115 void ( APIENTRY * qglColor4ub )(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha);
116 void ( APIENTRY * qglColor4ubv )(const GLubyte *v);
117 void ( APIENTRY * qglColor4ui )(GLuint red, GLuint green, GLuint blue, GLuint alpha);
118 void ( APIENTRY * qglColor4uiv )(const GLuint *v);
119 void ( APIENTRY * qglColor4us )(GLushort red, GLushort green, GLushort blue, GLushort alpha);
120 void ( APIENTRY * qglColor4usv )(const GLushort *v);
121 void ( APIENTRY * qglColorMask )(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
122 void ( APIENTRY * qglColorMaterial )(GLenum face, GLenum mode);
123 void ( APIENTRY * qglColorPointer )(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
124 void ( APIENTRY * qglCopyPixels )(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type);
125 void ( APIENTRY * qglCopyTexImage1D )(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border);
126 void ( APIENTRY * qglCopyTexImage2D )(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
127 void ( APIENTRY * qglCopyTexSubImage1D )(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
128 void ( APIENTRY * qglCopyTexSubImage2D )(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
129 void ( APIENTRY * qglCullFace )(GLenum mode);
130 void ( APIENTRY * qglDeleteLists )(GLuint list, GLsizei range);
131 void ( APIENTRY * qglDeleteTextures )(GLsizei n, const GLuint *textures);
132 void ( APIENTRY * qglDepthFunc )(GLenum func);
133 void ( APIENTRY * qglDepthMask )(GLboolean flag);
134 void ( APIENTRY * qglDepthRange )(GLclampd zNear, GLclampd zFar);
135 void ( APIENTRY * qglDisable )(GLenum cap);
136 void ( APIENTRY * qglDisableClientState )(GLenum array);
137 void ( APIENTRY * qglDrawArrays )(GLenum mode, GLint first, GLsizei count);
138 void ( APIENTRY * qglDrawBuffer )(GLenum mode);
139 void ( APIENTRY * qglDrawElements )(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices);
140 void ( APIENTRY * qglDrawPixels )(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
141 void ( APIENTRY * qglEdgeFlag )(GLboolean flag);
142 void ( APIENTRY * qglEdgeFlagPointer )(GLsizei stride, const GLvoid *pointer);
143 void ( APIENTRY * qglEdgeFlagv )(const GLboolean *flag);
144 void ( APIENTRY * qglEnable )(GLenum cap);
145 void ( APIENTRY * qglEnableClientState )(GLenum array);
146 void ( APIENTRY * qglEnd )(void);
147 void ( APIENTRY * qglEndList )(void);
148 void ( APIENTRY * qglEvalCoord1d )(GLdouble u);
149 void ( APIENTRY * qglEvalCoord1dv )(const GLdouble *u);
150 void ( APIENTRY * qglEvalCoord1f )(GLfloat u);
151 void ( APIENTRY * qglEvalCoord1fv )(const GLfloat *u);
152 void ( APIENTRY * qglEvalCoord2d )(GLdouble u, GLdouble v);
153 void ( APIENTRY * qglEvalCoord2dv )(const GLdouble *u);
154 void ( APIENTRY * qglEvalCoord2f )(GLfloat u, GLfloat v);
155 void ( APIENTRY * qglEvalCoord2fv )(const GLfloat *u);
156 void ( APIENTRY * qglEvalMesh1 )(GLenum mode, GLint i1, GLint i2);
157 void ( APIENTRY * qglEvalMesh2 )(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2);
158 void ( APIENTRY * qglEvalPoint1 )(GLint i);
159 void ( APIENTRY * qglEvalPoint2 )(GLint i, GLint j);
160 void ( APIENTRY * qglFeedbackBuffer )(GLsizei size, GLenum type, GLfloat *buffer);
161 void ( APIENTRY * qglFinish )(void);
162 void ( APIENTRY * qglFlush )(void);
163 void ( APIENTRY * qglFogf )(GLenum pname, GLfloat param);
164 void ( APIENTRY * qglFogfv )(GLenum pname, const GLfloat *params);
165 void ( APIENTRY * qglFogi )(GLenum pname, GLint param);
166 void ( APIENTRY * qglFogiv )(GLenum pname, const GLint *params);
167 void ( APIENTRY * qglFrontFace )(GLenum mode);
168 void ( APIENTRY * qglFrustum )(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
169 GLuint ( APIENTRY * qglGenLists )(GLsizei range);
170 void ( APIENTRY * qglGenTextures )(GLsizei n, GLuint *textures);
171 void ( APIENTRY * qglGetBooleanv )(GLenum pname, GLboolean *params);
172 void ( APIENTRY * qglGetClipPlane )(GLenum plane, GLdouble *equation);
173 void ( APIENTRY * qglGetDoublev )(GLenum pname, GLdouble *params);
174 GLenum ( APIENTRY * qglGetError )(void);
175 void ( APIENTRY * qglGetFloatv )(GLenum pname, GLfloat *params);
176 void ( APIENTRY * qglGetIntegerv )(GLenum pname, GLint *params);
177 void ( APIENTRY * qglGetLightfv )(GLenum light, GLenum pname, GLfloat *params);
178 void ( APIENTRY * qglGetLightiv )(GLenum light, GLenum pname, GLint *params);
179 void ( APIENTRY * qglGetMapdv )(GLenum target, GLenum query, GLdouble *v);
180 void ( APIENTRY * qglGetMapfv )(GLenum target, GLenum query, GLfloat *v);
181 void ( APIENTRY * qglGetMapiv )(GLenum target, GLenum query, GLint *v);
182 void ( APIENTRY * qglGetMaterialfv )(GLenum face, GLenum pname, GLfloat *params);
183 void ( APIENTRY * qglGetMaterialiv )(GLenum face, GLenum pname, GLint *params);
184 void ( APIENTRY * qglGetPixelMapfv )(GLenum map, GLfloat *values);
185 void ( APIENTRY * qglGetPixelMapuiv )(GLenum map, GLuint *values);
186 void ( APIENTRY * qglGetPixelMapusv )(GLenum map, GLushort *values);
187 void ( APIENTRY * qglGetPointerv )(GLenum pname, GLvoid* *params);
188 void ( APIENTRY * qglGetPolygonStipple )(GLubyte *mask);
189 const GLubyte * ( APIENTRY * qglGetString )(GLenum name);
190 void ( APIENTRY * qglGetTexEnvfv )(GLenum target, GLenum pname, GLfloat *params);
191 void ( APIENTRY * qglGetTexEnviv )(GLenum target, GLenum pname, GLint *params);
192 void ( APIENTRY * qglGetTexGendv )(GLenum coord, GLenum pname, GLdouble *params);
193 void ( APIENTRY * qglGetTexGenfv )(GLenum coord, GLenum pname, GLfloat *params);
194 void ( APIENTRY * qglGetTexGeniv )(GLenum coord, GLenum pname, GLint *params);
195 void ( APIENTRY * qglGetTexImage )(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels);
196 void ( APIENTRY * qglGetTexLevelParameterfv )(GLenum target, GLint level, GLenum pname, GLfloat *params);
197 void ( APIENTRY * qglGetTexLevelParameteriv )(GLenum target, GLint level, GLenum pname, GLint *params);
198 void ( APIENTRY * qglGetTexParameterfv )(GLenum target, GLenum pname, GLfloat *params);
199 void ( APIENTRY * qglGetTexParameteriv )(GLenum target, GLenum pname, GLint *params);
200 void ( APIENTRY * qglHint )(GLenum target, GLenum mode);
201 void ( APIENTRY * qglIndexMask )(GLuint mask);
202 void ( APIENTRY * qglIndexPointer )(GLenum type, GLsizei stride, const GLvoid *pointer);
203 void ( APIENTRY * qglIndexd )(GLdouble c);
204 void ( APIENTRY * qglIndexdv )(const GLdouble *c);
205 void ( APIENTRY * qglIndexf )(GLfloat c);
206 void ( APIENTRY * qglIndexfv )(const GLfloat *c);
207 void ( APIENTRY * qglIndexi )(GLint c);
208 void ( APIENTRY * qglIndexiv )(const GLint *c);
209 void ( APIENTRY * qglIndexs )(GLshort c);
210 void ( APIENTRY * qglIndexsv )(const GLshort *c);
211 void ( APIENTRY * qglIndexub )(GLubyte c);
212 void ( APIENTRY * qglIndexubv )(const GLubyte *c);
213 void ( APIENTRY * qglInitNames )(void);
214 void ( APIENTRY * qglInterleavedArrays )(GLenum format, GLsizei stride, const GLvoid *pointer);
215 GLboolean ( APIENTRY * qglIsEnabled )(GLenum cap);
216 GLboolean ( APIENTRY * qglIsList )(GLuint list);
217 GLboolean ( APIENTRY * qglIsTexture )(GLuint texture);
218 void ( APIENTRY * qglLightModelf )(GLenum pname, GLfloat param);
219 void ( APIENTRY * qglLightModelfv )(GLenum pname, const GLfloat *params);
220 void ( APIENTRY * qglLightModeli )(GLenum pname, GLint param);
221 void ( APIENTRY * qglLightModeliv )(GLenum pname, const GLint *params);
222 void ( APIENTRY * qglLightf )(GLenum light, GLenum pname, GLfloat param);
223 void ( APIENTRY * qglLightfv )(GLenum light, GLenum pname, const GLfloat *params);
224 void ( APIENTRY * qglLighti )(GLenum light, GLenum pname, GLint param);
225 void ( APIENTRY * qglLightiv )(GLenum light, GLenum pname, const GLint *params);
226 void ( APIENTRY * qglLineStipple )(GLint factor, GLushort pattern);
227 void ( APIENTRY * qglLineWidth )(GLfloat width);
228 void ( APIENTRY * qglListBase )(GLuint base);
229 void ( APIENTRY * qglLoadIdentity )(void);
230 void ( APIENTRY * qglLoadMatrixd )(const GLdouble *m);
231 void ( APIENTRY * qglLoadMatrixf )(const GLfloat *m);
232 void ( APIENTRY * qglLoadName )(GLuint name);
233 void ( APIENTRY * qglLogicOp )(GLenum opcode);
234 void ( APIENTRY * qglMap1d )(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points);
235 void ( APIENTRY * qglMap1f )(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points);
236 void ( APIENTRY * qglMap2d )(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points);
237 void ( APIENTRY * qglMap2f )(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points);
238 void ( APIENTRY * qglMapGrid1d )(GLint un, GLdouble u1, GLdouble u2);
239 void ( APIENTRY * qglMapGrid1f )(GLint un, GLfloat u1, GLfloat u2);
240 void ( APIENTRY * qglMapGrid2d )(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2);
241 void ( APIENTRY * qglMapGrid2f )(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2);
242 void ( APIENTRY * qglMaterialf )(GLenum face, GLenum pname, GLfloat param);
243 void ( APIENTRY * qglMaterialfv )(GLenum face, GLenum pname, const GLfloat *params);
244 void ( APIENTRY * qglMateriali )(GLenum face, GLenum pname, GLint param);
245 void ( APIENTRY * qglMaterialiv )(GLenum face, GLenum pname, const GLint *params);
246 void ( APIENTRY * qglMatrixMode )(GLenum mode);
247 void ( APIENTRY * qglMultMatrixd )(const GLdouble *m);
248 void ( APIENTRY * qglMultMatrixf )(const GLfloat *m);
249 void ( APIENTRY * qglNewList )(GLuint list, GLenum mode);
250 void ( APIENTRY * qglNormal3b )(GLbyte nx, GLbyte ny, GLbyte nz);
251 void ( APIENTRY * qglNormal3bv )(const GLbyte *v);
252 void ( APIENTRY * qglNormal3d )(GLdouble nx, GLdouble ny, GLdouble nz);
253 void ( APIENTRY * qglNormal3dv )(const GLdouble *v);
254 void ( APIENTRY * qglNormal3f )(GLfloat nx, GLfloat ny, GLfloat nz);
255 void ( APIENTRY * qglNormal3fv )(const GLfloat *v);
256 void ( APIENTRY * qglNormal3i )(GLint nx, GLint ny, GLint nz);
257 void ( APIENTRY * qglNormal3iv )(const GLint *v);
258 void ( APIENTRY * qglNormal3s )(GLshort nx, GLshort ny, GLshort nz);
259 void ( APIENTRY * qglNormal3sv )(const GLshort *v);
260 void ( APIENTRY * qglNormalPointer )(GLenum type, GLsizei stride, const GLvoid *pointer);
261 void ( APIENTRY * qglOrtho )(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
262 void ( APIENTRY * qglPassThrough )(GLfloat token);
263 void ( APIENTRY * qglPixelMapfv )(GLenum map, GLsizei mapsize, const GLfloat *values);
264 void ( APIENTRY * qglPixelMapuiv )(GLenum map, GLsizei mapsize, const GLuint *values);
265 void ( APIENTRY * qglPixelMapusv )(GLenum map, GLsizei mapsize, const GLushort *values);
266 void ( APIENTRY * qglPixelStoref )(GLenum pname, GLfloat param);
267 void ( APIENTRY * qglPixelStorei )(GLenum pname, GLint param);
268 void ( APIENTRY * qglPixelTransferf )(GLenum pname, GLfloat param);
269 void ( APIENTRY * qglPixelTransferi )(GLenum pname, GLint param);
270 void ( APIENTRY * qglPixelZoom )(GLfloat xfactor, GLfloat yfactor);
271 void ( APIENTRY * qglPointSize )(GLfloat size);
272 void ( APIENTRY * qglPolygonMode )(GLenum face, GLenum mode);
273 void ( APIENTRY * qglPolygonOffset )(GLfloat factor, GLfloat units);
274 void ( APIENTRY * qglPolygonStipple )(const GLubyte *mask);
275 void ( APIENTRY * qglPopAttrib )(void);
276 void ( APIENTRY * qglPopClientAttrib )(void);
277 void ( APIENTRY * qglPopMatrix )(void);
278 void ( APIENTRY * qglPopName )(void);
279 void ( APIENTRY * qglPrioritizeTextures )(GLsizei n, const GLuint *textures, const GLclampf *priorities);
280 void ( APIENTRY * qglPushAttrib )(GLbitfield mask);
281 void ( APIENTRY * qglPushClientAttrib )(GLbitfield mask);
282 void ( APIENTRY * qglPushMatrix )(void);
283 void ( APIENTRY * qglPushName )(GLuint name);
284 void ( APIENTRY * qglRasterPos2d )(GLdouble x, GLdouble y);
285 void ( APIENTRY * qglRasterPos2dv )(const GLdouble *v);
286 void ( APIENTRY * qglRasterPos2f )(GLfloat x, GLfloat y);
287 void ( APIENTRY * qglRasterPos2fv )(const GLfloat *v);
288 void ( APIENTRY * qglRasterPos2i )(GLint x, GLint y);
289 void ( APIENTRY * qglRasterPos2iv )(const GLint *v);
290 void ( APIENTRY * qglRasterPos2s )(GLshort x, GLshort y);
291 void ( APIENTRY * qglRasterPos2sv )(const GLshort *v);
292 void ( APIENTRY * qglRasterPos3d )(GLdouble x, GLdouble y, GLdouble z);
293 void ( APIENTRY * qglRasterPos3dv )(const GLdouble *v);
294 void ( APIENTRY * qglRasterPos3f )(GLfloat x, GLfloat y, GLfloat z);
295 void ( APIENTRY * qglRasterPos3fv )(const GLfloat *v);
296 void ( APIENTRY * qglRasterPos3i )(GLint x, GLint y, GLint z);
297 void ( APIENTRY * qglRasterPos3iv )(const GLint *v);
298 void ( APIENTRY * qglRasterPos3s )(GLshort x, GLshort y, GLshort z);
299 void ( APIENTRY * qglRasterPos3sv )(const GLshort *v);
300 void ( APIENTRY * qglRasterPos4d )(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
301 void ( APIENTRY * qglRasterPos4dv )(const GLdouble *v);
302 void ( APIENTRY * qglRasterPos4f )(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
303 void ( APIENTRY * qglRasterPos4fv )(const GLfloat *v);
304 void ( APIENTRY * qglRasterPos4i )(GLint x, GLint y, GLint z, GLint w);
305 void ( APIENTRY * qglRasterPos4iv )(const GLint *v);
306 void ( APIENTRY * qglRasterPos4s )(GLshort x, GLshort y, GLshort z, GLshort w);
307 void ( APIENTRY * qglRasterPos4sv )(const GLshort *v);
308 void ( APIENTRY * qglReadBuffer )(GLenum mode);
309 void ( APIENTRY * qglReadPixels )(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels);
310 void ( APIENTRY * qglRectd )(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2);
311 void ( APIENTRY * qglRectdv )(const GLdouble *v1, const GLdouble *v2);
312 void ( APIENTRY * qglRectf )(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2);
313 void ( APIENTRY * qglRectfv )(const GLfloat *v1, const GLfloat *v2);
314 void ( APIENTRY * qglRecti )(GLint x1, GLint y1, GLint x2, GLint y2);
315 void ( APIENTRY * qglRectiv )(const GLint *v1, const GLint *v2);
316 void ( APIENTRY * qglRects )(GLshort x1, GLshort y1, GLshort x2, GLshort y2);
317 void ( APIENTRY * qglRectsv )(const GLshort *v1, const GLshort *v2);
318 GLint ( APIENTRY * qglRenderMode )(GLenum mode);
319 void ( APIENTRY * qglRotated )(GLdouble angle, GLdouble x, GLdouble y, GLdouble z);
320 void ( APIENTRY * qglRotatef )(GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
321 void ( APIENTRY * qglScaled )(GLdouble x, GLdouble y, GLdouble z);
322 void ( APIENTRY * qglScalef )(GLfloat x, GLfloat y, GLfloat z);
323 void ( APIENTRY * qglScissor )(GLint x, GLint y, GLsizei width, GLsizei height);
324 void ( APIENTRY * qglSelectBuffer )(GLsizei size, GLuint *buffer);
325 void ( APIENTRY * qglShadeModel )(GLenum mode);
326 void ( APIENTRY * qglStencilFunc )(GLenum func, GLint ref, GLuint mask);
327 void ( APIENTRY * qglStencilMask )(GLuint mask);
328 void ( APIENTRY * qglStencilOp )(GLenum fail, GLenum zfail, GLenum zpass);
329 void ( APIENTRY * qglTexCoord1d )(GLdouble s);
330 void ( APIENTRY * qglTexCoord1dv )(const GLdouble *v);
331 void ( APIENTRY * qglTexCoord1f )(GLfloat s);
332 void ( APIENTRY * qglTexCoord1fv )(const GLfloat *v);
333 void ( APIENTRY * qglTexCoord1i )(GLint s);
334 void ( APIENTRY * qglTexCoord1iv )(const GLint *v);
335 void ( APIENTRY * qglTexCoord1s )(GLshort s);
336 void ( APIENTRY * qglTexCoord1sv )(const GLshort *v);
337 void ( APIENTRY * qglTexCoord2d )(GLdouble s, GLdouble t);
338 void ( APIENTRY * qglTexCoord2dv )(const GLdouble *v);
339 void ( APIENTRY * qglTexCoord2f )(GLfloat s, GLfloat t);
340 void ( APIENTRY * qglTexCoord2fv )(const GLfloat *v);
341 void ( APIENTRY * qglTexCoord2i )(GLint s, GLint t);
342 void ( APIENTRY * qglTexCoord2iv )(const GLint *v);
343 void ( APIENTRY * qglTexCoord2s )(GLshort s, GLshort t);
344 void ( APIENTRY * qglTexCoord2sv )(const GLshort *v);
345 void ( APIENTRY * qglTexCoord3d )(GLdouble s, GLdouble t, GLdouble r);
346 void ( APIENTRY * qglTexCoord3dv )(const GLdouble *v);
347 void ( APIENTRY * qglTexCoord3f )(GLfloat s, GLfloat t, GLfloat r);
348 void ( APIENTRY * qglTexCoord3fv )(const GLfloat *v);
349 void ( APIENTRY * qglTexCoord3i )(GLint s, GLint t, GLint r);
350 void ( APIENTRY * qglTexCoord3iv )(const GLint *v);
351 void ( APIENTRY * qglTexCoord3s )(GLshort s, GLshort t, GLshort r);
352 void ( APIENTRY * qglTexCoord3sv )(const GLshort *v);
353 void ( APIENTRY * qglTexCoord4d )(GLdouble s, GLdouble t, GLdouble r, GLdouble q);
354 void ( APIENTRY * qglTexCoord4dv )(const GLdouble *v);
355 void ( APIENTRY * qglTexCoord4f )(GLfloat s, GLfloat t, GLfloat r, GLfloat q);
356 void ( APIENTRY * qglTexCoord4fv )(const GLfloat *v);
357 void ( APIENTRY * qglTexCoord4i )(GLint s, GLint t, GLint r, GLint q);
358 void ( APIENTRY * qglTexCoord4iv )(const GLint *v);
359 void ( APIENTRY * qglTexCoord4s )(GLshort s, GLshort t, GLshort r, GLshort q);
360 void ( APIENTRY * qglTexCoord4sv )(const GLshort *v);
361 void ( APIENTRY * qglTexCoordPointer )(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
362 void ( APIENTRY * qglTexEnvf )(GLenum target, GLenum pname, GLfloat param);
363 void ( APIENTRY * qglTexEnvfv )(GLenum target, GLenum pname, const GLfloat *params);
364 void ( APIENTRY * qglTexEnvi )(GLenum target, GLenum pname, GLint param);
365 void ( APIENTRY * qglTexEnviv )(GLenum target, GLenum pname, const GLint *params);
366 void ( APIENTRY * qglTexGend )(GLenum coord, GLenum pname, GLdouble param);
367 void ( APIENTRY * qglTexGendv )(GLenum coord, GLenum pname, const GLdouble *params);
368 void ( APIENTRY * qglTexGenf )(GLenum coord, GLenum pname, GLfloat param);
369 void ( APIENTRY * qglTexGenfv )(GLenum coord, GLenum pname, const GLfloat *params);
370 void ( APIENTRY * qglTexGeni )(GLenum coord, GLenum pname, GLint param);
371 void ( APIENTRY * qglTexGeniv )(GLenum coord, GLenum pname, const GLint *params);
372 void ( APIENTRY * qglTexImage1D )(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
373 void ( APIENTRY * qglTexImage2D )(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
374 void ( APIENTRY * qglTexParameterf )(GLenum target, GLenum pname, GLfloat param);
375 void ( APIENTRY * qglTexParameterfv )(GLenum target, GLenum pname, const GLfloat *params);
376 void ( APIENTRY * qglTexParameteri )(GLenum target, GLenum pname, GLint param);
377 void ( APIENTRY * qglTexParameteriv )(GLenum target, GLenum pname, const GLint *params);
378 void ( APIENTRY * qglTexSubImage1D )(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels);
379 void ( APIENTRY * qglTexSubImage2D )(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
380 void ( APIENTRY * qglTranslated )(GLdouble x, GLdouble y, GLdouble z);
381 void ( APIENTRY * qglTranslatef )(GLfloat x, GLfloat y, GLfloat z);
382 void ( APIENTRY * qglVertex2d )(GLdouble x, GLdouble y);
383 void ( APIENTRY * qglVertex2dv )(const GLdouble *v);
384 void ( APIENTRY * qglVertex2f )(GLfloat x, GLfloat y);
385 void ( APIENTRY * qglVertex2fv )(const GLfloat *v);
386 void ( APIENTRY * qglVertex2i )(GLint x, GLint y);
387 void ( APIENTRY * qglVertex2iv )(const GLint *v);
388 void ( APIENTRY * qglVertex2s )(GLshort x, GLshort y);
389 void ( APIENTRY * qglVertex2sv )(const GLshort *v);
390 void ( APIENTRY * qglVertex3d )(GLdouble x, GLdouble y, GLdouble z);
391 void ( APIENTRY * qglVertex3dv )(const GLdouble *v);
392 void ( APIENTRY * qglVertex3f )(GLfloat x, GLfloat y, GLfloat z);
393 void ( APIENTRY * qglVertex3fv )(const GLfloat *v);
394 void ( APIENTRY * qglVertex3i )(GLint x, GLint y, GLint z);
395 void ( APIENTRY * qglVertex3iv )(const GLint *v);
396 void ( APIENTRY * qglVertex3s )(GLshort x, GLshort y, GLshort z);
397 void ( APIENTRY * qglVertex3sv )(const GLshort *v);
398 void ( APIENTRY * qglVertex4d )(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
399 void ( APIENTRY * qglVertex4dv )(const GLdouble *v);
400 void ( APIENTRY * qglVertex4f )(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
401 void ( APIENTRY * qglVertex4fv )(const GLfloat *v);
402 void ( APIENTRY * qglVertex4i )(GLint x, GLint y, GLint z, GLint w);
403 void ( APIENTRY * qglVertex4iv )(const GLint *v);
404 void ( APIENTRY * qglVertex4s )(GLshort x, GLshort y, GLshort z, GLshort w);
405 void ( APIENTRY * qglVertex4sv )(const GLshort *v);
406 void ( APIENTRY * qglVertexPointer )(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
407 void ( APIENTRY * qglViewport )(GLint x, GLint y, GLsizei width, GLsizei height);
408
409 void ( APIENTRY * qglMultiTexCoord2fARB )( GLenum texture, GLfloat s, GLfloat t );
410 void ( APIENTRY * qglActiveTextureARB )( GLenum texture );
411 void ( APIENTRY * qglClientActiveTextureARB )( GLenum texture );
412
413 void ( APIENTRY * qglLockArraysEXT)( GLint, GLint);
414 void ( APIENTRY * qglUnlockArraysEXT) ( void );
415
416
417 static void ( APIENTRY * dllAccum )(GLenum op, GLfloat value);
418 static void ( APIENTRY * dllAlphaFunc )(GLenum func, GLclampf ref);
419 GLboolean ( APIENTRY * dllAreTexturesResident )(GLsizei n, const GLuint *textures, GLboolean *residences);
420 static void ( APIENTRY * dllArrayElement )(GLint i);
421 static void ( APIENTRY * dllBegin )(GLenum mode);
422 static void ( APIENTRY * dllBindTexture )(GLenum target, GLuint texture);
423 static void ( APIENTRY * dllBitmap )(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap);
424 static void ( APIENTRY * dllBlendFunc )(GLenum sfactor, GLenum dfactor);
425 static void ( APIENTRY * dllCallList )(GLuint list);
426 static void ( APIENTRY * dllCallLists )(GLsizei n, GLenum type, const GLvoid *lists);
427 static void ( APIENTRY * dllClear )(GLbitfield mask);
428 static void ( APIENTRY * dllClearAccum )(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
429 static void ( APIENTRY * dllClearColor )(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
430 static void ( APIENTRY * dllClearDepth )(GLclampd depth);
431 static void ( APIENTRY * dllClearIndex )(GLfloat c);
432 static void ( APIENTRY * dllClearStencil )(GLint s);
433 static void ( APIENTRY * dllClipPlane )(GLenum plane, const GLdouble *equation);
434 static void ( APIENTRY * dllColor3b )(GLbyte red, GLbyte green, GLbyte blue);
435 static void ( APIENTRY * dllColor3bv )(const GLbyte *v);
436 static void ( APIENTRY * dllColor3d )(GLdouble red, GLdouble green, GLdouble blue);
437 static void ( APIENTRY * dllColor3dv )(const GLdouble *v);
438 static void ( APIENTRY * dllColor3f )(GLfloat red, GLfloat green, GLfloat blue);
439 static void ( APIENTRY * dllColor3fv )(const GLfloat *v);
440 static void ( APIENTRY * dllColor3i )(GLint red, GLint green, GLint blue);
441 static void ( APIENTRY * dllColor3iv )(const GLint *v);
442 static void ( APIENTRY * dllColor3s )(GLshort red, GLshort green, GLshort blue);
443 static void ( APIENTRY * dllColor3sv )(const GLshort *v);
444 static void ( APIENTRY * dllColor3ub )(GLubyte red, GLubyte green, GLubyte blue);
445 static void ( APIENTRY * dllColor3ubv )(const GLubyte *v);
446 static void ( APIENTRY * dllColor3ui )(GLuint red, GLuint green, GLuint blue);
447 static void ( APIENTRY * dllColor3uiv )(const GLuint *v);
448 static void ( APIENTRY * dllColor3us )(GLushort red, GLushort green, GLushort blue);
449 static void ( APIENTRY * dllColor3usv )(const GLushort *v);
450 static void ( APIENTRY * dllColor4b )(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha);
451 static void ( APIENTRY * dllColor4bv )(const GLbyte *v);
452 static void ( APIENTRY * dllColor4d )(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha);
453 static void ( APIENTRY * dllColor4dv )(const GLdouble *v);
454 static void ( APIENTRY * dllColor4f )(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
455 static void ( APIENTRY * dllColor4fv )(const GLfloat *v);
456 static void ( APIENTRY * dllColor4i )(GLint red, GLint green, GLint blue, GLint alpha);
457 static void ( APIENTRY * dllColor4iv )(const GLint *v);
458 static void ( APIENTRY * dllColor4s )(GLshort red, GLshort green, GLshort blue, GLshort alpha);
459 static void ( APIENTRY * dllColor4sv )(const GLshort *v);
460 static void ( APIENTRY * dllColor4ub )(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha);
461 static void ( APIENTRY * dllColor4ubv )(const GLubyte *v);
462 static void ( APIENTRY * dllColor4ui )(GLuint red, GLuint green, GLuint blue, GLuint alpha);
463 static void ( APIENTRY * dllColor4uiv )(const GLuint *v);
464 static void ( APIENTRY * dllColor4us )(GLushort red, GLushort green, GLushort blue, GLushort alpha);
465 static void ( APIENTRY * dllColor4usv )(const GLushort *v);
466 static void ( APIENTRY * dllColorMask )(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
467 static void ( APIENTRY * dllColorMaterial )(GLenum face, GLenum mode);
468 static void ( APIENTRY * dllColorPointer )(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
469 static void ( APIENTRY * dllCopyPixels )(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type);
470 static void ( APIENTRY * dllCopyTexImage1D )(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border);
471 static void ( APIENTRY * dllCopyTexImage2D )(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
472 static void ( APIENTRY * dllCopyTexSubImage1D )(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
473 static void ( APIENTRY * dllCopyTexSubImage2D )(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
474 static void ( APIENTRY * dllCullFace )(GLenum mode);
475 static void ( APIENTRY * dllDeleteLists )(GLuint list, GLsizei range);
476 static void ( APIENTRY * dllDeleteTextures )(GLsizei n, const GLuint *textures);
477 static void ( APIENTRY * dllDepthFunc )(GLenum func);
478 static void ( APIENTRY * dllDepthMask )(GLboolean flag);
479 static void ( APIENTRY * dllDepthRange )(GLclampd zNear, GLclampd zFar);
480 static void ( APIENTRY * dllDisable )(GLenum cap);
481 static void ( APIENTRY * dllDisableClientState )(GLenum array);
482 static void ( APIENTRY * dllDrawArrays )(GLenum mode, GLint first, GLsizei count);
483 static void ( APIENTRY * dllDrawBuffer )(GLenum mode);
484 static void ( APIENTRY * dllDrawElements )(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices);
485 static void ( APIENTRY * dllDrawPixels )(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
486 static void ( APIENTRY * dllEdgeFlag )(GLboolean flag);
487 static void ( APIENTRY * dllEdgeFlagPointer )(GLsizei stride, const GLvoid *pointer);
488 static void ( APIENTRY * dllEdgeFlagv )(const GLboolean *flag);
489 static void ( APIENTRY * dllEnable )(GLenum cap);
490 static void ( APIENTRY * dllEnableClientState )(GLenum array);
491 static void ( APIENTRY * dllEnd )(void);
492 static void ( APIENTRY * dllEndList )(void);
493 static void ( APIENTRY * dllEvalCoord1d )(GLdouble u);
494 static void ( APIENTRY * dllEvalCoord1dv )(const GLdouble *u);
495 static void ( APIENTRY * dllEvalCoord1f )(GLfloat u);
496 static void ( APIENTRY * dllEvalCoord1fv )(const GLfloat *u);
497 static void ( APIENTRY * dllEvalCoord2d )(GLdouble u, GLdouble v);
498 static void ( APIENTRY * dllEvalCoord2dv )(const GLdouble *u);
499 static void ( APIENTRY * dllEvalCoord2f )(GLfloat u, GLfloat v);
500 static void ( APIENTRY * dllEvalCoord2fv )(const GLfloat *u);
501 static void ( APIENTRY * dllEvalMesh1 )(GLenum mode, GLint i1, GLint i2);
502 static void ( APIENTRY * dllEvalMesh2 )(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2);
503 static void ( APIENTRY * dllEvalPoint1 )(GLint i);
504 static void ( APIENTRY * dllEvalPoint2 )(GLint i, GLint j);
505 static void ( APIENTRY * dllFeedbackBuffer )(GLsizei size, GLenum type, GLfloat *buffer);
506 static void ( APIENTRY * dllFinish )(void);
507 static void ( APIENTRY * dllFlush )(void);
508 static void ( APIENTRY * dllFogf )(GLenum pname, GLfloat param);
509 static void ( APIENTRY * dllFogfv )(GLenum pname, const GLfloat *params);
510 static void ( APIENTRY * dllFogi )(GLenum pname, GLint param);
511 static void ( APIENTRY * dllFogiv )(GLenum pname, const GLint *params);
512 static void ( APIENTRY * dllFrontFace )(GLenum mode);
513 static void ( APIENTRY * dllFrustum )(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
514 GLuint ( APIENTRY * dllGenLists )(GLsizei range);
515 static void ( APIENTRY * dllGenTextures )(GLsizei n, GLuint *textures);
516 static void ( APIENTRY * dllGetBooleanv )(GLenum pname, GLboolean *params);
517 static void ( APIENTRY * dllGetClipPlane )(GLenum plane, GLdouble *equation);
518 static void ( APIENTRY * dllGetDoublev )(GLenum pname, GLdouble *params);
519 GLenum ( APIENTRY * dllGetError )(void);
520 static void ( APIENTRY * dllGetFloatv )(GLenum pname, GLfloat *params);
521 static void ( APIENTRY * dllGetIntegerv )(GLenum pname, GLint *params);
522 static void ( APIENTRY * dllGetLightfv )(GLenum light, GLenum pname, GLfloat *params);
523 static void ( APIENTRY * dllGetLightiv )(GLenum light, GLenum pname, GLint *params);
524 static void ( APIENTRY * dllGetMapdv )(GLenum target, GLenum query, GLdouble *v);
525 static void ( APIENTRY * dllGetMapfv )(GLenum target, GLenum query, GLfloat *v);
526 static void ( APIENTRY * dllGetMapiv )(GLenum target, GLenum query, GLint *v);
527 static void ( APIENTRY * dllGetMaterialfv )(GLenum face, GLenum pname, GLfloat *params);
528 static void ( APIENTRY * dllGetMaterialiv )(GLenum face, GLenum pname, GLint *params);
529 static void ( APIENTRY * dllGetPixelMapfv )(GLenum map, GLfloat *values);
530 static void ( APIENTRY * dllGetPixelMapuiv )(GLenum map, GLuint *values);
531 static void ( APIENTRY * dllGetPixelMapusv )(GLenum map, GLushort *values);
532 static void ( APIENTRY * dllGetPointerv )(GLenum pname, GLvoid* *params);
533 static void ( APIENTRY * dllGetPolygonStipple )(GLubyte *mask);
534 const GLubyte * ( APIENTRY * dllGetString )(GLenum name);
535 static void ( APIENTRY * dllGetTexEnvfv )(GLenum target, GLenum pname, GLfloat *params);
536 static void ( APIENTRY * dllGetTexEnviv )(GLenum target, GLenum pname, GLint *params);
537 static void ( APIENTRY * dllGetTexGendv )(GLenum coord, GLenum pname, GLdouble *params);
538 static void ( APIENTRY * dllGetTexGenfv )(GLenum coord, GLenum pname, GLfloat *params);
539 static void ( APIENTRY * dllGetTexGeniv )(GLenum coord, GLenum pname, GLint *params);
540 static void ( APIENTRY * dllGetTexImage )(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels);
541 static void ( APIENTRY * dllGetTexLevelParameterfv )(GLenum target, GLint level, GLenum pname, GLfloat *params);
542 static void ( APIENTRY * dllGetTexLevelParameteriv )(GLenum target, GLint level, GLenum pname, GLint *params);
543 static void ( APIENTRY * dllGetTexParameterfv )(GLenum target, GLenum pname, GLfloat *params);
544 static void ( APIENTRY * dllGetTexParameteriv )(GLenum target, GLenum pname, GLint *params);
545 static void ( APIENTRY * dllHint )(GLenum target, GLenum mode);
546 static void ( APIENTRY * dllIndexMask )(GLuint mask);
547 static void ( APIENTRY * dllIndexPointer )(GLenum type, GLsizei stride, const GLvoid *pointer);
548 static void ( APIENTRY * dllIndexd )(GLdouble c);
549 static void ( APIENTRY * dllIndexdv )(const GLdouble *c);
550 static void ( APIENTRY * dllIndexf )(GLfloat c);
551 static void ( APIENTRY * dllIndexfv )(const GLfloat *c);
552 static void ( APIENTRY * dllIndexi )(GLint c);
553 static void ( APIENTRY * dllIndexiv )(const GLint *c);
554 static void ( APIENTRY * dllIndexs )(GLshort c);
555 static void ( APIENTRY * dllIndexsv )(const GLshort *c);
556 static void ( APIENTRY * dllIndexub )(GLubyte c);
557 static void ( APIENTRY * dllIndexubv )(const GLubyte *c);
558 static void ( APIENTRY * dllInitNames )(void);
559 static void ( APIENTRY * dllInterleavedArrays )(GLenum format, GLsizei stride, const GLvoid *pointer);
560 GLboolean ( APIENTRY * dllIsEnabled )(GLenum cap);
561 GLboolean ( APIENTRY * dllIsList )(GLuint list);
562 GLboolean ( APIENTRY * dllIsTexture )(GLuint texture);
563 static void ( APIENTRY * dllLightModelf )(GLenum pname, GLfloat param);
564 static void ( APIENTRY * dllLightModelfv )(GLenum pname, const GLfloat *params);
565 static void ( APIENTRY * dllLightModeli )(GLenum pname, GLint param);
566 static void ( APIENTRY * dllLightModeliv )(GLenum pname, const GLint *params);
567 static void ( APIENTRY * dllLightf )(GLenum light, GLenum pname, GLfloat param);
568 static void ( APIENTRY * dllLightfv )(GLenum light, GLenum pname, const GLfloat *params);
569 static void ( APIENTRY * dllLighti )(GLenum light, GLenum pname, GLint param);
570 static void ( APIENTRY * dllLightiv )(GLenum light, GLenum pname, const GLint *params);
571 static void ( APIENTRY * dllLineStipple )(GLint factor, GLushort pattern);
572 static void ( APIENTRY * dllLineWidth )(GLfloat width);
573 static void ( APIENTRY * dllListBase )(GLuint base);
574 static void ( APIENTRY * dllLoadIdentity )(void);
575 static void ( APIENTRY * dllLoadMatrixd )(const GLdouble *m);
576 static void ( APIENTRY * dllLoadMatrixf )(const GLfloat *m);
577 static void ( APIENTRY * dllLoadName )(GLuint name);
578 static void ( APIENTRY * dllLogicOp )(GLenum opcode);
579 static void ( APIENTRY * dllMap1d )(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points);
580 static void ( APIENTRY * dllMap1f )(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points);
581 static void ( APIENTRY * dllMap2d )(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points);
582 static void ( APIENTRY * dllMap2f )(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points);
583 static void ( APIENTRY * dllMapGrid1d )(GLint un, GLdouble u1, GLdouble u2);
584 static void ( APIENTRY * dllMapGrid1f )(GLint un, GLfloat u1, GLfloat u2);
585 static void ( APIENTRY * dllMapGrid2d )(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2);
586 static void ( APIENTRY * dllMapGrid2f )(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2);
587 static void ( APIENTRY * dllMaterialf )(GLenum face, GLenum pname, GLfloat param);
588 static void ( APIENTRY * dllMaterialfv )(GLenum face, GLenum pname, const GLfloat *params);
589 static void ( APIENTRY * dllMateriali )(GLenum face, GLenum pname, GLint param);
590 static void ( APIENTRY * dllMaterialiv )(GLenum face, GLenum pname, const GLint *params);
591 static void ( APIENTRY * dllMatrixMode )(GLenum mode);
592 static void ( APIENTRY * dllMultMatrixd )(const GLdouble *m);
593 static void ( APIENTRY * dllMultMatrixf )(const GLfloat *m);
594 static void ( APIENTRY * dllNewList )(GLuint list, GLenum mode);
595 static void ( APIENTRY * dllNormal3b )(GLbyte nx, GLbyte ny, GLbyte nz);
596 static void ( APIENTRY * dllNormal3bv )(const GLbyte *v);
597 static void ( APIENTRY * dllNormal3d )(GLdouble nx, GLdouble ny, GLdouble nz);
598 static void ( APIENTRY * dllNormal3dv )(const GLdouble *v);
599 static void ( APIENTRY * dllNormal3f )(GLfloat nx, GLfloat ny, GLfloat nz);
600 static void ( APIENTRY * dllNormal3fv )(const GLfloat *v);
601 static void ( APIENTRY * dllNormal3i )(GLint nx, GLint ny, GLint nz);
602 static void ( APIENTRY * dllNormal3iv )(const GLint *v);
603 static void ( APIENTRY * dllNormal3s )(GLshort nx, GLshort ny, GLshort nz);
604 static void ( APIENTRY * dllNormal3sv )(const GLshort *v);
605 static void ( APIENTRY * dllNormalPointer )(GLenum type, GLsizei stride, const GLvoid *pointer);
606 static void ( APIENTRY * dllOrtho )(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
607 static void ( APIENTRY * dllPassThrough )(GLfloat token);
608 static void ( APIENTRY * dllPixelMapfv )(GLenum map, GLsizei mapsize, const GLfloat *values);
609 static void ( APIENTRY * dllPixelMapuiv )(GLenum map, GLsizei mapsize, const GLuint *values);
610 static void ( APIENTRY * dllPixelMapusv )(GLenum map, GLsizei mapsize, const GLushort *values);
611 static void ( APIENTRY * dllPixelStoref )(GLenum pname, GLfloat param);
612 static void ( APIENTRY * dllPixelStorei )(GLenum pname, GLint param);
613 static void ( APIENTRY * dllPixelTransferf )(GLenum pname, GLfloat param);
614 static void ( APIENTRY * dllPixelTransferi )(GLenum pname, GLint param);
615 static void ( APIENTRY * dllPixelZoom )(GLfloat xfactor, GLfloat yfactor);
616 static void ( APIENTRY * dllPointSize )(GLfloat size);
617 static void ( APIENTRY * dllPolygonMode )(GLenum face, GLenum mode);
618 static void ( APIENTRY * dllPolygonOffset )(GLfloat factor, GLfloat units);
619 static void ( APIENTRY * dllPolygonStipple )(const GLubyte *mask);
620 static void ( APIENTRY * dllPopAttrib )(void);
621 static void ( APIENTRY * dllPopClientAttrib )(void);
622 static void ( APIENTRY * dllPopMatrix )(void);
623 static void ( APIENTRY * dllPopName )(void);
624 static void ( APIENTRY * dllPrioritizeTextures )(GLsizei n, const GLuint *textures, const GLclampf *priorities);
625 static void ( APIENTRY * dllPushAttrib )(GLbitfield mask);
626 static void ( APIENTRY * dllPushClientAttrib )(GLbitfield mask);
627 static void ( APIENTRY * dllPushMatrix )(void);
628 static void ( APIENTRY * dllPushName )(GLuint name);
629 static void ( APIENTRY * dllRasterPos2d )(GLdouble x, GLdouble y);
630 static void ( APIENTRY * dllRasterPos2dv )(const GLdouble *v);
631 static void ( APIENTRY * dllRasterPos2f )(GLfloat x, GLfloat y);
632 static void ( APIENTRY * dllRasterPos2fv )(const GLfloat *v);
633 static void ( APIENTRY * dllRasterPos2i )(GLint x, GLint y);
634 static void ( APIENTRY * dllRasterPos2iv )(const GLint *v);
635 static void ( APIENTRY * dllRasterPos2s )(GLshort x, GLshort y);
636 static void ( APIENTRY * dllRasterPos2sv )(const GLshort *v);
637 static void ( APIENTRY * dllRasterPos3d )(GLdouble x, GLdouble y, GLdouble z);
638 static void ( APIENTRY * dllRasterPos3dv )(const GLdouble *v);
639 static void ( APIENTRY * dllRasterPos3f )(GLfloat x, GLfloat y, GLfloat z);
640 static void ( APIENTRY * dllRasterPos3fv )(const GLfloat *v);
641 static void ( APIENTRY * dllRasterPos3i )(GLint x, GLint y, GLint z);
642 static void ( APIENTRY * dllRasterPos3iv )(const GLint *v);
643 static void ( APIENTRY * dllRasterPos3s )(GLshort x, GLshort y, GLshort z);
644 static void ( APIENTRY * dllRasterPos3sv )(const GLshort *v);
645 static void ( APIENTRY * dllRasterPos4d )(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
646 static void ( APIENTRY * dllRasterPos4dv )(const GLdouble *v);
647 static void ( APIENTRY * dllRasterPos4f )(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
648 static void ( APIENTRY * dllRasterPos4fv )(const GLfloat *v);
649 static void ( APIENTRY * dllRasterPos4i )(GLint x, GLint y, GLint z, GLint w);
650 static void ( APIENTRY * dllRasterPos4iv )(const GLint *v);
651 static void ( APIENTRY * dllRasterPos4s )(GLshort x, GLshort y, GLshort z, GLshort w);
652 static void ( APIENTRY * dllRasterPos4sv )(const GLshort *v);
653 static void ( APIENTRY * dllReadBuffer )(GLenum mode);
654 static void ( APIENTRY * dllReadPixels )(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels);
655 static void ( APIENTRY * dllRectd )(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2);
656 static void ( APIENTRY * dllRectdv )(const GLdouble *v1, const GLdouble *v2);
657 static void ( APIENTRY * dllRectf )(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2);
658 static void ( APIENTRY * dllRectfv )(const GLfloat *v1, const GLfloat *v2);
659 static void ( APIENTRY * dllRecti )(GLint x1, GLint y1, GLint x2, GLint y2);
660 static void ( APIENTRY * dllRectiv )(const GLint *v1, const GLint *v2);
661 static void ( APIENTRY * dllRects )(GLshort x1, GLshort y1, GLshort x2, GLshort y2);
662 static void ( APIENTRY * dllRectsv )(const GLshort *v1, const GLshort *v2);
663 GLint ( APIENTRY * dllRenderMode )(GLenum mode);
664 static void ( APIENTRY * dllRotated )(GLdouble angle, GLdouble x, GLdouble y, GLdouble z);
665 static void ( APIENTRY * dllRotatef )(GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
666 static void ( APIENTRY * dllScaled )(GLdouble x, GLdouble y, GLdouble z);
667 static void ( APIENTRY * dllScalef )(GLfloat x, GLfloat y, GLfloat z);
668 static void ( APIENTRY * dllScissor )(GLint x, GLint y, GLsizei width, GLsizei height);
669 static void ( APIENTRY * dllSelectBuffer )(GLsizei size, GLuint *buffer);
670 static void ( APIENTRY * dllShadeModel )(GLenum mode);
671 static void ( APIENTRY * dllStencilFunc )(GLenum func, GLint ref, GLuint mask);
672 static void ( APIENTRY * dllStencilMask )(GLuint mask);
673 static void ( APIENTRY * dllStencilOp )(GLenum fail, GLenum zfail, GLenum zpass);
674 static void ( APIENTRY * dllTexCoord1d )(GLdouble s);
675 static void ( APIENTRY * dllTexCoord1dv )(const GLdouble *v);
676 static void ( APIENTRY * dllTexCoord1f )(GLfloat s);
677 static void ( APIENTRY * dllTexCoord1fv )(const GLfloat *v);
678 static void ( APIENTRY * dllTexCoord1i )(GLint s);
679 static void ( APIENTRY * dllTexCoord1iv )(const GLint *v);
680 static void ( APIENTRY * dllTexCoord1s )(GLshort s);
681 static void ( APIENTRY * dllTexCoord1sv )(const GLshort *v);
682 static void ( APIENTRY * dllTexCoord2d )(GLdouble s, GLdouble t);
683 static void ( APIENTRY * dllTexCoord2dv )(const GLdouble *v);
684 static void ( APIENTRY * dllTexCoord2f )(GLfloat s, GLfloat t);
685 static void ( APIENTRY * dllTexCoord2fv )(const GLfloat *v);
686 static void ( APIENTRY * dllTexCoord2i )(GLint s, GLint t);
687 static void ( APIENTRY * dllTexCoord2iv )(const GLint *v);
688 static void ( APIENTRY * dllTexCoord2s )(GLshort s, GLshort t);
689 static void ( APIENTRY * dllTexCoord2sv )(const GLshort *v);
690 static void ( APIENTRY * dllTexCoord3d )(GLdouble s, GLdouble t, GLdouble r);
691 static void ( APIENTRY * dllTexCoord3dv )(const GLdouble *v);
692 static void ( APIENTRY * dllTexCoord3f )(GLfloat s, GLfloat t, GLfloat r);
693 static void ( APIENTRY * dllTexCoord3fv )(const GLfloat *v);
694 static void ( APIENTRY * dllTexCoord3i )(GLint s, GLint t, GLint r);
695 static void ( APIENTRY * dllTexCoord3iv )(const GLint *v);
696 static void ( APIENTRY * dllTexCoord3s )(GLshort s, GLshort t, GLshort r);
697 static void ( APIENTRY * dllTexCoord3sv )(const GLshort *v);
698 static void ( APIENTRY * dllTexCoord4d )(GLdouble s, GLdouble t, GLdouble r, GLdouble q);
699 static void ( APIENTRY * dllTexCoord4dv )(const GLdouble *v);
700 static void ( APIENTRY * dllTexCoord4f )(GLfloat s, GLfloat t, GLfloat r, GLfloat q);
701 static void ( APIENTRY * dllTexCoord4fv )(const GLfloat *v);
702 static void ( APIENTRY * dllTexCoord4i )(GLint s, GLint t, GLint r, GLint q);
703 static void ( APIENTRY * dllTexCoord4iv )(const GLint *v);
704 static void ( APIENTRY * dllTexCoord4s )(GLshort s, GLshort t, GLshort r, GLshort q);
705 static void ( APIENTRY * dllTexCoord4sv )(const GLshort *v);
706 static void ( APIENTRY * dllTexCoordPointer )(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
707 static void ( APIENTRY * dllTexEnvf )(GLenum target, GLenum pname, GLfloat param);
708 static void ( APIENTRY * dllTexEnvfv )(GLenum target, GLenum pname, const GLfloat *params);
709 static void ( APIENTRY * dllTexEnvi )(GLenum target, GLenum pname, GLint param);
710 static void ( APIENTRY * dllTexEnviv )(GLenum target, GLenum pname, const GLint *params);
711 static void ( APIENTRY * dllTexGend )(GLenum coord, GLenum pname, GLdouble param);
712 static void ( APIENTRY * dllTexGendv )(GLenum coord, GLenum pname, const GLdouble *params);
713 static void ( APIENTRY * dllTexGenf )(GLenum coord, GLenum pname, GLfloat param);
714 static void ( APIENTRY * dllTexGenfv )(GLenum coord, GLenum pname, const GLfloat *params);
715 static void ( APIENTRY * dllTexGeni )(GLenum coord, GLenum pname, GLint param);
716 static void ( APIENTRY * dllTexGeniv )(GLenum coord, GLenum pname, const GLint *params);
717 static void ( APIENTRY * dllTexImage1D )(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
718 static void ( APIENTRY * dllTexImage2D )(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
719 static void ( APIENTRY * dllTexParameterf )(GLenum target, GLenum pname, GLfloat param);
720 static void ( APIENTRY * dllTexParameterfv )(GLenum target, GLenum pname, const GLfloat *params);
721 static void ( APIENTRY * dllTexParameteri )(GLenum target, GLenum pname, GLint param);
722 static void ( APIENTRY * dllTexParameteriv )(GLenum target, GLenum pname, const GLint *params);
723 static void ( APIENTRY * dllTexSubImage1D )(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels);
724 static void ( APIENTRY * dllTexSubImage2D )(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
725 static void ( APIENTRY * dllTranslated )(GLdouble x, GLdouble y, GLdouble z);
726 static void ( APIENTRY * dllTranslatef )(GLfloat x, GLfloat y, GLfloat z);
727 static void ( APIENTRY * dllVertex2d )(GLdouble x, GLdouble y);
728 static void ( APIENTRY * dllVertex2dv )(const GLdouble *v);
729 static void ( APIENTRY * dllVertex2f )(GLfloat x, GLfloat y);
730 static void ( APIENTRY * dllVertex2fv )(const GLfloat *v);
731 static void ( APIENTRY * dllVertex2i )(GLint x, GLint y);
732 static void ( APIENTRY * dllVertex2iv )(const GLint *v);
733 static void ( APIENTRY * dllVertex2s )(GLshort x, GLshort y);
734 static void ( APIENTRY * dllVertex2sv )(const GLshort *v);
735 static void ( APIENTRY * dllVertex3d )(GLdouble x, GLdouble y, GLdouble z);
736 static void ( APIENTRY * dllVertex3dv )(const GLdouble *v);
737 static void ( APIENTRY * dllVertex3f )(GLfloat x, GLfloat y, GLfloat z);
738 static void ( APIENTRY * dllVertex3fv )(const GLfloat *v);
739 static void ( APIENTRY * dllVertex3i )(GLint x, GLint y, GLint z);
740 static void ( APIENTRY * dllVertex3iv )(const GLint *v);
741 static void ( APIENTRY * dllVertex3s )(GLshort x, GLshort y, GLshort z);
742 static void ( APIENTRY * dllVertex3sv )(const GLshort *v);
743 static void ( APIENTRY * dllVertex4d )(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
744 static void ( APIENTRY * dllVertex4dv )(const GLdouble *v);
745 static void ( APIENTRY * dllVertex4f )(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
746 static void ( APIENTRY * dllVertex4fv )(const GLfloat *v);
747 static void ( APIENTRY * dllVertex4i )(GLint x, GLint y, GLint z, GLint w);
748 static void ( APIENTRY * dllVertex4iv )(const GLint *v);
749 static void ( APIENTRY * dllVertex4s )(GLshort x, GLshort y, GLshort z, GLshort w);
750 static void ( APIENTRY * dllVertex4sv )(const GLshort *v);
751 static void ( APIENTRY * dllVertexPointer )(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
752 static void ( APIENTRY * dllViewport )(GLint x, GLint y, GLsizei width, GLsizei height);
753
BooleanToString(GLboolean b)754 static const char * BooleanToString( GLboolean b )
755 {
756 if ( b == GL_FALSE )
757 return "GL_FALSE";
758 else if ( b == GL_TRUE )
759 return "GL_TRUE";
760 else
761 return "OUT OF RANGE FOR BOOLEAN";
762 }
763
FuncToString(GLenum f)764 static const char * FuncToString( GLenum f )
765 {
766 switch ( f )
767 {
768 case GL_ALWAYS:
769 return "GL_ALWAYS";
770 case GL_NEVER:
771 return "GL_NEVER";
772 case GL_LEQUAL:
773 return "GL_LEQUAL";
774 case GL_LESS:
775 return "GL_LESS";
776 case GL_EQUAL:
777 return "GL_EQUAL";
778 case GL_GREATER:
779 return "GL_GREATER";
780 case GL_GEQUAL:
781 return "GL_GEQUAL";
782 case GL_NOTEQUAL:
783 return "GL_NOTEQUAL";
784 default:
785 return "!!! UNKNOWN !!!";
786 }
787 }
788
PrimToString(GLenum mode)789 static const char * PrimToString( GLenum mode )
790 {
791 static char prim[1024];
792
793 if ( mode == GL_TRIANGLES )
794 strcpy( prim, "GL_TRIANGLES" );
795 else if ( mode == GL_TRIANGLE_STRIP )
796 strcpy( prim, "GL_TRIANGLE_STRIP" );
797 else if ( mode == GL_TRIANGLE_FAN )
798 strcpy( prim, "GL_TRIANGLE_FAN" );
799 else if ( mode == GL_QUADS )
800 strcpy( prim, "GL_QUADS" );
801 else if ( mode == GL_QUAD_STRIP )
802 strcpy( prim, "GL_QUAD_STRIP" );
803 else if ( mode == GL_POLYGON )
804 strcpy( prim, "GL_POLYGON" );
805 else if ( mode == GL_POINTS )
806 strcpy( prim, "GL_POINTS" );
807 else if ( mode == GL_LINES )
808 strcpy( prim, "GL_LINES" );
809 else if ( mode == GL_LINE_STRIP )
810 strcpy( prim, "GL_LINE_STRIP" );
811 else if ( mode == GL_LINE_LOOP )
812 strcpy( prim, "GL_LINE_LOOP" );
813 else
814 sprintf( prim, "0x%x", mode );
815
816 return prim;
817 }
818
CapToString(GLenum cap)819 static const char * CapToString( GLenum cap )
820 {
821 static char buffer[1024];
822
823 switch ( cap )
824 {
825 case GL_TEXTURE_2D:
826 return "GL_TEXTURE_2D";
827 case GL_BLEND:
828 return "GL_BLEND";
829 case GL_DEPTH_TEST:
830 return "GL_DEPTH_TEST";
831 case GL_CULL_FACE:
832 return "GL_CULL_FACE";
833 case GL_CLIP_PLANE0:
834 return "GL_CLIP_PLANE0";
835 case GL_COLOR_ARRAY:
836 return "GL_COLOR_ARRAY";
837 case GL_TEXTURE_COORD_ARRAY:
838 return "GL_TEXTURE_COORD_ARRAY";
839 case GL_VERTEX_ARRAY:
840 return "GL_VERTEX_ARRAY";
841 case GL_ALPHA_TEST:
842 return "GL_ALPHA_TEST";
843 case GL_STENCIL_TEST:
844 return "GL_STENCIL_TEST";
845 default:
846 sprintf( buffer, "0x%x", cap );
847 }
848
849 return buffer;
850 }
851
TypeToString(GLenum t)852 static const char * TypeToString( GLenum t )
853 {
854 switch ( t )
855 {
856 case GL_BYTE:
857 return "GL_BYTE";
858 case GL_UNSIGNED_BYTE:
859 return "GL_UNSIGNED_BYTE";
860 case GL_SHORT:
861 return "GL_SHORT";
862 case GL_UNSIGNED_SHORT:
863 return "GL_UNSIGNED_SHORT";
864 case GL_INT:
865 return "GL_INT";
866 case GL_UNSIGNED_INT:
867 return "GL_UNSIGNED_INT";
868 case GL_FLOAT:
869 return "GL_FLOAT";
870 case GL_DOUBLE:
871 return "GL_DOUBLE";
872 default:
873 return "!!! UNKNOWN !!!";
874 }
875 }
876
logAccum(GLenum op,GLfloat value)877 static void APIENTRY logAccum(GLenum op, GLfloat value)
878 {
879 fprintf( glw_state.log_fp, "glAccum\n" );
880 dllAccum( op, value );
881 }
882
logAlphaFunc(GLenum func,GLclampf ref)883 static void APIENTRY logAlphaFunc(GLenum func, GLclampf ref)
884 {
885 fprintf( glw_state.log_fp, "glAlphaFunc( 0x%x, %f )\n", func, ref );
886 dllAlphaFunc( func, ref );
887 }
888
logAreTexturesResident(GLsizei n,const GLuint * textures,GLboolean * residences)889 static GLboolean APIENTRY logAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences)
890 {
891 fprintf( glw_state.log_fp, "glAreTexturesResident\n" );
892 return dllAreTexturesResident( n, textures, residences );
893 }
894
logArrayElement(GLint i)895 static void APIENTRY logArrayElement(GLint i)
896 {
897 fprintf( glw_state.log_fp, "glArrayElement\n" );
898 dllArrayElement( i );
899 }
900
logBegin(GLenum mode)901 static void APIENTRY logBegin(GLenum mode)
902 {
903 fprintf( glw_state.log_fp, "glBegin( %s )\n", PrimToString( mode ));
904 dllBegin( mode );
905 }
906
logBindTexture(GLenum target,GLuint texture)907 static void APIENTRY logBindTexture(GLenum target, GLuint texture)
908 {
909 fprintf( glw_state.log_fp, "glBindTexture( 0x%x, %u )\n", target, texture );
910 dllBindTexture( target, texture );
911 }
912
logBitmap(GLsizei width,GLsizei height,GLfloat xorig,GLfloat yorig,GLfloat xmove,GLfloat ymove,const GLubyte * bitmap)913 static void APIENTRY logBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap)
914 {
915 fprintf( glw_state.log_fp, "glBitmap\n" );
916 dllBitmap( width, height, xorig, yorig, xmove, ymove, bitmap );
917 }
918
BlendToName(char * n,GLenum f)919 static void BlendToName( char *n, GLenum f )
920 {
921 switch ( f )
922 {
923 case GL_ONE:
924 strcpy( n, "GL_ONE" );
925 break;
926 case GL_ZERO:
927 strcpy( n, "GL_ZERO" );
928 break;
929 case GL_SRC_ALPHA:
930 strcpy( n, "GL_SRC_ALPHA" );
931 break;
932 case GL_ONE_MINUS_SRC_ALPHA:
933 strcpy( n, "GL_ONE_MINUS_SRC_ALPHA" );
934 break;
935 case GL_DST_COLOR:
936 strcpy( n, "GL_DST_COLOR" );
937 break;
938 case GL_ONE_MINUS_DST_COLOR:
939 strcpy( n, "GL_ONE_MINUS_DST_COLOR" );
940 break;
941 case GL_DST_ALPHA:
942 strcpy( n, "GL_DST_ALPHA" );
943 break;
944 default:
945 sprintf( n, "0x%x", f );
946 }
947 }
logBlendFunc(GLenum sfactor,GLenum dfactor)948 static void APIENTRY logBlendFunc(GLenum sfactor, GLenum dfactor)
949 {
950 char sf[128], df[128];
951
952 BlendToName( sf, sfactor );
953 BlendToName( df, dfactor );
954
955 fprintf( glw_state.log_fp, "glBlendFunc( %s, %s )\n", sf, df );
956 dllBlendFunc( sfactor, dfactor );
957 }
958
logCallList(GLuint list)959 static void APIENTRY logCallList(GLuint list)
960 {
961 fprintf( glw_state.log_fp, "glCallList( %u )\n", list );
962 dllCallList( list );
963 }
964
logCallLists(GLsizei n,GLenum type,const void * lists)965 static void APIENTRY logCallLists(GLsizei n, GLenum type, const void *lists)
966 {
967 fprintf( glw_state.log_fp, "glCallLists\n" );
968 dllCallLists( n, type, lists );
969 }
970
logClear(GLbitfield mask)971 static void APIENTRY logClear(GLbitfield mask)
972 {
973 fprintf( glw_state.log_fp, "glClear( 0x%x = ", mask );
974
975 if ( mask & GL_COLOR_BUFFER_BIT )
976 fprintf( glw_state.log_fp, "GL_COLOR_BUFFER_BIT " );
977 if ( mask & GL_DEPTH_BUFFER_BIT )
978 fprintf( glw_state.log_fp, "GL_DEPTH_BUFFER_BIT " );
979 if ( mask & GL_STENCIL_BUFFER_BIT )
980 fprintf( glw_state.log_fp, "GL_STENCIL_BUFFER_BIT " );
981 if ( mask & GL_ACCUM_BUFFER_BIT )
982 fprintf( glw_state.log_fp, "GL_ACCUM_BUFFER_BIT " );
983
984 fprintf( glw_state.log_fp, ")\n" );
985 dllClear( mask );
986 }
987
logClearAccum(GLfloat red,GLfloat green,GLfloat blue,GLfloat alpha)988 static void APIENTRY logClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
989 {
990 fprintf( glw_state.log_fp, "glClearAccum\n" );
991 dllClearAccum( red, green, blue, alpha );
992 }
993
logClearColor(GLclampf red,GLclampf green,GLclampf blue,GLclampf alpha)994 static void APIENTRY logClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
995 {
996 fprintf( glw_state.log_fp, "glClearColor\n" );
997 dllClearColor( red, green, blue, alpha );
998 }
999
logClearDepth(GLclampd depth)1000 static void APIENTRY logClearDepth(GLclampd depth)
1001 {
1002 fprintf( glw_state.log_fp, "glClearDepth( %f )\n", ( float ) depth );
1003 dllClearDepth( depth );
1004 }
1005
logClearIndex(GLfloat c)1006 static void APIENTRY logClearIndex(GLfloat c)
1007 {
1008 fprintf( glw_state.log_fp, "glClearIndex\n" );
1009 dllClearIndex( c );
1010 }
1011
logClearStencil(GLint s)1012 static void APIENTRY logClearStencil(GLint s)
1013 {
1014 fprintf( glw_state.log_fp, "glClearStencil( %d )\n", s );
1015 dllClearStencil( s );
1016 }
1017
logClipPlane(GLenum plane,const GLdouble * equation)1018 static void APIENTRY logClipPlane(GLenum plane, const GLdouble *equation)
1019 {
1020 fprintf( glw_state.log_fp, "glClipPlane\n" );
1021 dllClipPlane( plane, equation );
1022 }
1023
logColor3b(GLbyte red,GLbyte green,GLbyte blue)1024 static void APIENTRY logColor3b(GLbyte red, GLbyte green, GLbyte blue)
1025 {
1026 fprintf( glw_state.log_fp, "glColor3b\n" );
1027 dllColor3b( red, green, blue );
1028 }
1029
logColor3bv(const GLbyte * v)1030 static void APIENTRY logColor3bv(const GLbyte *v)
1031 {
1032 fprintf( glw_state.log_fp, "glColor3bv\n" );
1033 dllColor3bv( v );
1034 }
1035
logColor3d(GLdouble red,GLdouble green,GLdouble blue)1036 static void APIENTRY logColor3d(GLdouble red, GLdouble green, GLdouble blue)
1037 {
1038 fprintf( glw_state.log_fp, "glColor3d\n" );
1039 dllColor3d( red, green, blue );
1040 }
1041
logColor3dv(const GLdouble * v)1042 static void APIENTRY logColor3dv(const GLdouble *v)
1043 {
1044 fprintf( glw_state.log_fp, "glColor3dv\n" );
1045 dllColor3dv( v );
1046 }
1047
logColor3f(GLfloat red,GLfloat green,GLfloat blue)1048 static void APIENTRY logColor3f(GLfloat red, GLfloat green, GLfloat blue)
1049 {
1050 fprintf( glw_state.log_fp, "glColor3f\n" );
1051 dllColor3f( red, green, blue );
1052 }
1053
logColor3fv(const GLfloat * v)1054 static void APIENTRY logColor3fv(const GLfloat *v)
1055 {
1056 fprintf( glw_state.log_fp, "glColor3fv\n" );
1057 dllColor3fv( v );
1058 }
1059
logColor3i(GLint red,GLint green,GLint blue)1060 static void APIENTRY logColor3i(GLint red, GLint green, GLint blue)
1061 {
1062 fprintf( glw_state.log_fp, "glColor3i\n" );
1063 dllColor3i( red, green, blue );
1064 }
1065
logColor3iv(const GLint * v)1066 static void APIENTRY logColor3iv(const GLint *v)
1067 {
1068 fprintf( glw_state.log_fp, "glColor3iv\n" );
1069 dllColor3iv( v );
1070 }
1071
logColor3s(GLshort red,GLshort green,GLshort blue)1072 static void APIENTRY logColor3s(GLshort red, GLshort green, GLshort blue)
1073 {
1074 fprintf( glw_state.log_fp, "glColor3s\n" );
1075 dllColor3s( red, green, blue );
1076 }
1077
logColor3sv(const GLshort * v)1078 static void APIENTRY logColor3sv(const GLshort *v)
1079 {
1080 fprintf( glw_state.log_fp, "glColor3sv\n" );
1081 dllColor3sv( v );
1082 }
1083
logColor3ub(GLubyte red,GLubyte green,GLubyte blue)1084 static void APIENTRY logColor3ub(GLubyte red, GLubyte green, GLubyte blue)
1085 {
1086 fprintf( glw_state.log_fp, "glColor3ub\n" );
1087 dllColor3ub( red, green, blue );
1088 }
1089
logColor3ubv(const GLubyte * v)1090 static void APIENTRY logColor3ubv(const GLubyte *v)
1091 {
1092 fprintf( glw_state.log_fp, "glColor3ubv\n" );
1093 dllColor3ubv( v );
1094 }
1095
1096 #define SIG( x ) fprintf( glw_state.log_fp, x "\n" )
1097
logColor3ui(GLuint red,GLuint green,GLuint blue)1098 static void APIENTRY logColor3ui(GLuint red, GLuint green, GLuint blue)
1099 {
1100 SIG( "glColor3ui" );
1101 dllColor3ui( red, green, blue );
1102 }
1103
logColor3uiv(const GLuint * v)1104 static void APIENTRY logColor3uiv(const GLuint *v)
1105 {
1106 SIG( "glColor3uiv" );
1107 dllColor3uiv( v );
1108 }
1109
logColor3us(GLushort red,GLushort green,GLushort blue)1110 static void APIENTRY logColor3us(GLushort red, GLushort green, GLushort blue)
1111 {
1112 SIG( "glColor3us" );
1113 dllColor3us( red, green, blue );
1114 }
1115
logColor3usv(const GLushort * v)1116 static void APIENTRY logColor3usv(const GLushort *v)
1117 {
1118 SIG( "glColor3usv" );
1119 dllColor3usv( v );
1120 }
1121
logColor4b(GLbyte red,GLbyte green,GLbyte blue,GLbyte alpha)1122 static void APIENTRY logColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)
1123 {
1124 SIG( "glColor4b" );
1125 dllColor4b( red, green, blue, alpha );
1126 }
1127
logColor4bv(const GLbyte * v)1128 static void APIENTRY logColor4bv(const GLbyte *v)
1129 {
1130 SIG( "glColor4bv" );
1131 dllColor4bv( v );
1132 }
1133
logColor4d(GLdouble red,GLdouble green,GLdouble blue,GLdouble alpha)1134 static void APIENTRY logColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)
1135 {
1136 SIG( "glColor4d" );
1137 dllColor4d( red, green, blue, alpha );
1138 }
logColor4dv(const GLdouble * v)1139 static void APIENTRY logColor4dv(const GLdouble *v)
1140 {
1141 SIG( "glColor4dv" );
1142 dllColor4dv( v );
1143 }
logColor4f(GLfloat red,GLfloat green,GLfloat blue,GLfloat alpha)1144 static void APIENTRY logColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
1145 {
1146 fprintf( glw_state.log_fp, "glColor4f( %f,%f,%f,%f )\n", red, green, blue, alpha );
1147 dllColor4f( red, green, blue, alpha );
1148 }
logColor4fv(const GLfloat * v)1149 static void APIENTRY logColor4fv(const GLfloat *v)
1150 {
1151 fprintf( glw_state.log_fp, "glColor4fv( %f,%f,%f,%f )\n", v[0], v[1], v[2], v[3] );
1152 dllColor4fv( v );
1153 }
logColor4i(GLint red,GLint green,GLint blue,GLint alpha)1154 static void APIENTRY logColor4i(GLint red, GLint green, GLint blue, GLint alpha)
1155 {
1156 SIG( "glColor4i" );
1157 dllColor4i( red, green, blue, alpha );
1158 }
logColor4iv(const GLint * v)1159 static void APIENTRY logColor4iv(const GLint *v)
1160 {
1161 SIG( "glColor4iv" );
1162 dllColor4iv( v );
1163 }
logColor4s(GLshort red,GLshort green,GLshort blue,GLshort alpha)1164 static void APIENTRY logColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha)
1165 {
1166 SIG( "glColor4s" );
1167 dllColor4s( red, green, blue, alpha );
1168 }
logColor4sv(const GLshort * v)1169 static void APIENTRY logColor4sv(const GLshort *v)
1170 {
1171 SIG( "glColor4sv" );
1172 dllColor4sv( v );
1173 }
logColor4ub(GLubyte red,GLubyte green,GLubyte blue,GLubyte alpha)1174 static void APIENTRY logColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
1175 {
1176 SIG( "glColor4b" );
1177 dllColor4b( red, green, blue, alpha );
1178 }
logColor4ubv(const GLubyte * v)1179 static void APIENTRY logColor4ubv(const GLubyte *v)
1180 {
1181 SIG( "glColor4ubv" );
1182 dllColor4ubv( v );
1183 }
logColor4ui(GLuint red,GLuint green,GLuint blue,GLuint alpha)1184 static void APIENTRY logColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha)
1185 {
1186 SIG( "glColor4ui" );
1187 dllColor4ui( red, green, blue, alpha );
1188 }
logColor4uiv(const GLuint * v)1189 static void APIENTRY logColor4uiv(const GLuint *v)
1190 {
1191 SIG( "glColor4uiv" );
1192 dllColor4uiv( v );
1193 }
logColor4us(GLushort red,GLushort green,GLushort blue,GLushort alpha)1194 static void APIENTRY logColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha)
1195 {
1196 SIG( "glColor4us" );
1197 dllColor4us( red, green, blue, alpha );
1198 }
logColor4usv(const GLushort * v)1199 static void APIENTRY logColor4usv(const GLushort *v)
1200 {
1201 SIG( "glColor4usv" );
1202 dllColor4usv( v );
1203 }
logColorMask(GLboolean red,GLboolean green,GLboolean blue,GLboolean alpha)1204 static void APIENTRY logColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
1205 {
1206 SIG( "glColorMask" );
1207 dllColorMask( red, green, blue, alpha );
1208 }
logColorMaterial(GLenum face,GLenum mode)1209 static void APIENTRY logColorMaterial(GLenum face, GLenum mode)
1210 {
1211 SIG( "glColorMaterial" );
1212 dllColorMaterial( face, mode );
1213 }
1214
logColorPointer(GLint size,GLenum type,GLsizei stride,const void * pointer)1215 static void APIENTRY logColorPointer(GLint size, GLenum type, GLsizei stride, const void *pointer)
1216 {
1217 fprintf( glw_state.log_fp, "glColorPointer( %d, %s, %d, MEM )\n", size, TypeToString( type ), stride );
1218 dllColorPointer( size, type, stride, pointer );
1219 }
1220
logCopyPixels(GLint x,GLint y,GLsizei width,GLsizei height,GLenum type)1221 static void APIENTRY logCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
1222 {
1223 SIG( "glCopyPixels" );
1224 dllCopyPixels( x, y, width, height, type );
1225 }
1226
logCopyTexImage1D(GLenum target,GLint level,GLenum internalFormat,GLint x,GLint y,GLsizei width,GLint border)1227 static void APIENTRY logCopyTexImage1D(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border)
1228 {
1229 SIG( "glCopyTexImage1D" );
1230 dllCopyTexImage1D( target, level, internalFormat, x, y, width, border );
1231 }
1232
logCopyTexImage2D(GLenum target,GLint level,GLenum internalFormat,GLint x,GLint y,GLsizei width,GLsizei height,GLint border)1233 static void APIENTRY logCopyTexImage2D(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
1234 {
1235 SIG( "glCopyTexImage2D" );
1236 dllCopyTexImage2D( target, level, internalFormat, x, y, width, height, border );
1237 }
1238
logCopyTexSubImage1D(GLenum target,GLint level,GLint xoffset,GLint x,GLint y,GLsizei width)1239 static void APIENTRY logCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
1240 {
1241 SIG( "glCopyTexSubImage1D" );
1242 dllCopyTexSubImage1D( target, level, xoffset, x, y, width );
1243 }
1244
logCopyTexSubImage2D(GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint x,GLint y,GLsizei width,GLsizei height)1245 static void APIENTRY logCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
1246 {
1247 SIG( "glCopyTexSubImage2D" );
1248 dllCopyTexSubImage2D( target, level, xoffset, yoffset, x, y, width, height );
1249 }
1250
logCullFace(GLenum mode)1251 static void APIENTRY logCullFace(GLenum mode)
1252 {
1253 fprintf( glw_state.log_fp, "glCullFace( %s )\n", ( mode == GL_FRONT ) ? "GL_FRONT" : "GL_BACK" );
1254 dllCullFace( mode );
1255 }
1256
logDeleteLists(GLuint list,GLsizei range)1257 static void APIENTRY logDeleteLists(GLuint list, GLsizei range)
1258 {
1259 SIG( "glDeleteLists" );
1260 dllDeleteLists( list, range );
1261 }
1262
logDeleteTextures(GLsizei n,const GLuint * textures)1263 static void APIENTRY logDeleteTextures(GLsizei n, const GLuint *textures)
1264 {
1265 SIG( "glDeleteTextures" );
1266 dllDeleteTextures( n, textures );
1267 }
1268
logDepthFunc(GLenum func)1269 static void APIENTRY logDepthFunc(GLenum func)
1270 {
1271 fprintf( glw_state.log_fp, "glDepthFunc( %s )\n", FuncToString( func ) );
1272 dllDepthFunc( func );
1273 }
1274
logDepthMask(GLboolean flag)1275 static void APIENTRY logDepthMask(GLboolean flag)
1276 {
1277 fprintf( glw_state.log_fp, "glDepthMask( %s )\n", BooleanToString( flag ) );
1278 dllDepthMask( flag );
1279 }
1280
logDepthRange(GLclampd zNear,GLclampd zFar)1281 static void APIENTRY logDepthRange(GLclampd zNear, GLclampd zFar)
1282 {
1283 fprintf( glw_state.log_fp, "glDepthRange( %f, %f )\n", ( float ) zNear, ( float ) zFar );
1284 dllDepthRange( zNear, zFar );
1285 }
1286
logDisable(GLenum cap)1287 static void APIENTRY logDisable(GLenum cap)
1288 {
1289 fprintf( glw_state.log_fp, "glDisable( %s )\n", CapToString( cap ) );
1290 dllDisable( cap );
1291 }
1292
logDisableClientState(GLenum array)1293 static void APIENTRY logDisableClientState(GLenum array)
1294 {
1295 fprintf( glw_state.log_fp, "glDisableClientState( %s )\n", CapToString( array ) );
1296 dllDisableClientState( array );
1297 }
1298
logDrawArrays(GLenum mode,GLint first,GLsizei count)1299 static void APIENTRY logDrawArrays(GLenum mode, GLint first, GLsizei count)
1300 {
1301 SIG( "glDrawArrays" );
1302 dllDrawArrays( mode, first, count );
1303 }
1304
logDrawBuffer(GLenum mode)1305 static void APIENTRY logDrawBuffer(GLenum mode)
1306 {
1307 SIG( "glDrawBuffer" );
1308 dllDrawBuffer( mode );
1309 }
1310
logDrawElements(GLenum mode,GLsizei count,GLenum type,const void * indices)1311 static void APIENTRY logDrawElements(GLenum mode, GLsizei count, GLenum type, const void *indices)
1312 {
1313 fprintf( glw_state.log_fp, "glDrawElements( %s, %d, %s, MEM )\n", PrimToString( mode ), count, TypeToString( type ) );
1314 dllDrawElements( mode, count, type, indices );
1315 }
1316
logDrawPixels(GLsizei width,GLsizei height,GLenum format,GLenum type,const void * pixels)1317 static void APIENTRY logDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels)
1318 {
1319 SIG( "glDrawPixels" );
1320 dllDrawPixels( width, height, format, type, pixels );
1321 }
1322
logEdgeFlag(GLboolean flag)1323 static void APIENTRY logEdgeFlag(GLboolean flag)
1324 {
1325 SIG( "glEdgeFlag" );
1326 dllEdgeFlag( flag );
1327 }
1328
logEdgeFlagPointer(GLsizei stride,const void * pointer)1329 static void APIENTRY logEdgeFlagPointer(GLsizei stride, const void *pointer)
1330 {
1331 SIG( "glEdgeFlagPointer" );
1332 dllEdgeFlagPointer( stride, pointer );
1333 }
1334
logEdgeFlagv(const GLboolean * flag)1335 static void APIENTRY logEdgeFlagv(const GLboolean *flag)
1336 {
1337 SIG( "glEdgeFlagv" );
1338 dllEdgeFlagv( flag );
1339 }
1340
logEnable(GLenum cap)1341 static void APIENTRY logEnable(GLenum cap)
1342 {
1343 fprintf( glw_state.log_fp, "glEnable( %s )\n", CapToString( cap ) );
1344 dllEnable( cap );
1345 }
1346
logEnableClientState(GLenum array)1347 static void APIENTRY logEnableClientState(GLenum array)
1348 {
1349 fprintf( glw_state.log_fp, "glEnableClientState( %s )\n", CapToString( array ) );
1350 dllEnableClientState( array );
1351 }
1352
logEnd(void)1353 static void APIENTRY logEnd(void)
1354 {
1355 SIG( "glEnd" );
1356 dllEnd();
1357 }
1358
logEndList(void)1359 static void APIENTRY logEndList(void)
1360 {
1361 SIG( "glEndList" );
1362 dllEndList();
1363 }
1364
logEvalCoord1d(GLdouble u)1365 static void APIENTRY logEvalCoord1d(GLdouble u)
1366 {
1367 SIG( "glEvalCoord1d" );
1368 dllEvalCoord1d( u );
1369 }
1370
logEvalCoord1dv(const GLdouble * u)1371 static void APIENTRY logEvalCoord1dv(const GLdouble *u)
1372 {
1373 SIG( "glEvalCoord1dv" );
1374 dllEvalCoord1dv( u );
1375 }
1376
logEvalCoord1f(GLfloat u)1377 static void APIENTRY logEvalCoord1f(GLfloat u)
1378 {
1379 SIG( "glEvalCoord1f" );
1380 dllEvalCoord1f( u );
1381 }
1382
logEvalCoord1fv(const GLfloat * u)1383 static void APIENTRY logEvalCoord1fv(const GLfloat *u)
1384 {
1385 SIG( "glEvalCoord1fv" );
1386 dllEvalCoord1fv( u );
1387 }
logEvalCoord2d(GLdouble u,GLdouble v)1388 static void APIENTRY logEvalCoord2d(GLdouble u, GLdouble v)
1389 {
1390 SIG( "glEvalCoord2d" );
1391 dllEvalCoord2d( u, v );
1392 }
logEvalCoord2dv(const GLdouble * u)1393 static void APIENTRY logEvalCoord2dv(const GLdouble *u)
1394 {
1395 SIG( "glEvalCoord2dv" );
1396 dllEvalCoord2dv( u );
1397 }
logEvalCoord2f(GLfloat u,GLfloat v)1398 static void APIENTRY logEvalCoord2f(GLfloat u, GLfloat v)
1399 {
1400 SIG( "glEvalCoord2f" );
1401 dllEvalCoord2f( u, v );
1402 }
logEvalCoord2fv(const GLfloat * u)1403 static void APIENTRY logEvalCoord2fv(const GLfloat *u)
1404 {
1405 SIG( "glEvalCoord2fv" );
1406 dllEvalCoord2fv( u );
1407 }
1408
logEvalMesh1(GLenum mode,GLint i1,GLint i2)1409 static void APIENTRY logEvalMesh1(GLenum mode, GLint i1, GLint i2)
1410 {
1411 SIG( "glEvalMesh1" );
1412 dllEvalMesh1( mode, i1, i2 );
1413 }
logEvalMesh2(GLenum mode,GLint i1,GLint i2,GLint j1,GLint j2)1414 static void APIENTRY logEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
1415 {
1416 SIG( "glEvalMesh2" );
1417 dllEvalMesh2( mode, i1, i2, j1, j2 );
1418 }
logEvalPoint1(GLint i)1419 static void APIENTRY logEvalPoint1(GLint i)
1420 {
1421 SIG( "glEvalPoint1" );
1422 dllEvalPoint1( i );
1423 }
logEvalPoint2(GLint i,GLint j)1424 static void APIENTRY logEvalPoint2(GLint i, GLint j)
1425 {
1426 SIG( "glEvalPoint2" );
1427 dllEvalPoint2( i, j );
1428 }
1429
logFeedbackBuffer(GLsizei size,GLenum type,GLfloat * buffer)1430 static void APIENTRY logFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer)
1431 {
1432 SIG( "glFeedbackBuffer" );
1433 dllFeedbackBuffer( size, type, buffer );
1434 }
1435
logFinish(void)1436 static void APIENTRY logFinish(void)
1437 {
1438 SIG( "glFinish" );
1439 dllFinish();
1440 }
1441
logFlush(void)1442 static void APIENTRY logFlush(void)
1443 {
1444 SIG( "glFlush" );
1445 dllFlush();
1446 }
1447
logFogf(GLenum pname,GLfloat param)1448 static void APIENTRY logFogf(GLenum pname, GLfloat param)
1449 {
1450 SIG( "glFogf" );
1451 dllFogf( pname, param );
1452 }
1453
logFogfv(GLenum pname,const GLfloat * params)1454 static void APIENTRY logFogfv(GLenum pname, const GLfloat *params)
1455 {
1456 SIG( "glFogfv" );
1457 dllFogfv( pname, params );
1458 }
1459
logFogi(GLenum pname,GLint param)1460 static void APIENTRY logFogi(GLenum pname, GLint param)
1461 {
1462 SIG( "glFogi" );
1463 dllFogi( pname, param );
1464 }
1465
logFogiv(GLenum pname,const GLint * params)1466 static void APIENTRY logFogiv(GLenum pname, const GLint *params)
1467 {
1468 SIG( "glFogiv" );
1469 dllFogiv( pname, params );
1470 }
1471
logFrontFace(GLenum mode)1472 static void APIENTRY logFrontFace(GLenum mode)
1473 {
1474 SIG( "glFrontFace" );
1475 dllFrontFace( mode );
1476 }
1477
logFrustum(GLdouble left,GLdouble right,GLdouble bottom,GLdouble top,GLdouble zNear,GLdouble zFar)1478 static void APIENTRY logFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
1479 {
1480 SIG( "glFrustum" );
1481 dllFrustum( left, right, bottom, top, zNear, zFar );
1482 }
1483
logGenLists(GLsizei range)1484 static GLuint APIENTRY logGenLists(GLsizei range)
1485 {
1486 SIG( "glGenLists" );
1487 return dllGenLists( range );
1488 }
1489
logGenTextures(GLsizei n,GLuint * textures)1490 static void APIENTRY logGenTextures(GLsizei n, GLuint *textures)
1491 {
1492 SIG( "glGenTextures" );
1493 dllGenTextures( n, textures );
1494 }
1495
logGetBooleanv(GLenum pname,GLboolean * params)1496 static void APIENTRY logGetBooleanv(GLenum pname, GLboolean *params)
1497 {
1498 SIG( "glGetBooleanv" );
1499 dllGetBooleanv( pname, params );
1500 }
1501
logGetClipPlane(GLenum plane,GLdouble * equation)1502 static void APIENTRY logGetClipPlane(GLenum plane, GLdouble *equation)
1503 {
1504 SIG( "glGetClipPlane" );
1505 dllGetClipPlane( plane, equation );
1506 }
1507
logGetDoublev(GLenum pname,GLdouble * params)1508 static void APIENTRY logGetDoublev(GLenum pname, GLdouble *params)
1509 {
1510 SIG( "glGetDoublev" );
1511 dllGetDoublev( pname, params );
1512 }
1513
logGetError(void)1514 static GLenum APIENTRY logGetError(void)
1515 {
1516 SIG( "glGetError" );
1517 return dllGetError();
1518 }
1519
logGetFloatv(GLenum pname,GLfloat * params)1520 static void APIENTRY logGetFloatv(GLenum pname, GLfloat *params)
1521 {
1522 SIG( "glGetFloatv" );
1523 dllGetFloatv( pname, params );
1524 }
1525
logGetIntegerv(GLenum pname,GLint * params)1526 static void APIENTRY logGetIntegerv(GLenum pname, GLint *params)
1527 {
1528 SIG( "glGetIntegerv" );
1529 dllGetIntegerv( pname, params );
1530 }
1531
logGetLightfv(GLenum light,GLenum pname,GLfloat * params)1532 static void APIENTRY logGetLightfv(GLenum light, GLenum pname, GLfloat *params)
1533 {
1534 SIG( "glGetLightfv" );
1535 dllGetLightfv( light, pname, params );
1536 }
1537
logGetLightiv(GLenum light,GLenum pname,GLint * params)1538 static void APIENTRY logGetLightiv(GLenum light, GLenum pname, GLint *params)
1539 {
1540 SIG( "glGetLightiv" );
1541 dllGetLightiv( light, pname, params );
1542 }
1543
logGetMapdv(GLenum target,GLenum query,GLdouble * v)1544 static void APIENTRY logGetMapdv(GLenum target, GLenum query, GLdouble *v)
1545 {
1546 SIG( "glGetMapdv" );
1547 dllGetMapdv( target, query, v );
1548 }
1549
logGetMapfv(GLenum target,GLenum query,GLfloat * v)1550 static void APIENTRY logGetMapfv(GLenum target, GLenum query, GLfloat *v)
1551 {
1552 SIG( "glGetMapfv" );
1553 dllGetMapfv( target, query, v );
1554 }
1555
logGetMapiv(GLenum target,GLenum query,GLint * v)1556 static void APIENTRY logGetMapiv(GLenum target, GLenum query, GLint *v)
1557 {
1558 SIG( "glGetMapiv" );
1559 dllGetMapiv( target, query, v );
1560 }
1561
logGetMaterialfv(GLenum face,GLenum pname,GLfloat * params)1562 static void APIENTRY logGetMaterialfv(GLenum face, GLenum pname, GLfloat *params)
1563 {
1564 SIG( "glGetMaterialfv" );
1565 dllGetMaterialfv( face, pname, params );
1566 }
1567
logGetMaterialiv(GLenum face,GLenum pname,GLint * params)1568 static void APIENTRY logGetMaterialiv(GLenum face, GLenum pname, GLint *params)
1569 {
1570 SIG( "glGetMaterialiv" );
1571 dllGetMaterialiv( face, pname, params );
1572 }
1573
logGetPixelMapfv(GLenum map,GLfloat * values)1574 static void APIENTRY logGetPixelMapfv(GLenum map, GLfloat *values)
1575 {
1576 SIG( "glGetPixelMapfv" );
1577 dllGetPixelMapfv( map, values );
1578 }
1579
logGetPixelMapuiv(GLenum map,GLuint * values)1580 static void APIENTRY logGetPixelMapuiv(GLenum map, GLuint *values)
1581 {
1582 SIG( "glGetPixelMapuiv" );
1583 dllGetPixelMapuiv( map, values );
1584 }
1585
logGetPixelMapusv(GLenum map,GLushort * values)1586 static void APIENTRY logGetPixelMapusv(GLenum map, GLushort *values)
1587 {
1588 SIG( "glGetPixelMapusv" );
1589 dllGetPixelMapusv( map, values );
1590 }
1591
logGetPointerv(GLenum pname,GLvoid ** params)1592 static void APIENTRY logGetPointerv(GLenum pname, GLvoid* *params)
1593 {
1594 SIG( "glGetPointerv" );
1595 dllGetPointerv( pname, params );
1596 }
1597
logGetPolygonStipple(GLubyte * mask)1598 static void APIENTRY logGetPolygonStipple(GLubyte *mask)
1599 {
1600 SIG( "glGetPolygonStipple" );
1601 dllGetPolygonStipple( mask );
1602 }
1603
logGetString(GLenum name)1604 static const GLubyte * APIENTRY logGetString(GLenum name)
1605 {
1606 SIG( "glGetString" );
1607 return dllGetString( name );
1608 }
1609
logGetTexEnvfv(GLenum target,GLenum pname,GLfloat * params)1610 static void APIENTRY logGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params)
1611 {
1612 SIG( "glGetTexEnvfv" );
1613 dllGetTexEnvfv( target, pname, params );
1614 }
1615
logGetTexEnviv(GLenum target,GLenum pname,GLint * params)1616 static void APIENTRY logGetTexEnviv(GLenum target, GLenum pname, GLint *params)
1617 {
1618 SIG( "glGetTexEnviv" );
1619 dllGetTexEnviv( target, pname, params );
1620 }
1621
logGetTexGendv(GLenum coord,GLenum pname,GLdouble * params)1622 static void APIENTRY logGetTexGendv(GLenum coord, GLenum pname, GLdouble *params)
1623 {
1624 SIG( "glGetTexGendv" );
1625 dllGetTexGendv( coord, pname, params );
1626 }
1627
logGetTexGenfv(GLenum coord,GLenum pname,GLfloat * params)1628 static void APIENTRY logGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params)
1629 {
1630 SIG( "glGetTexGenfv" );
1631 dllGetTexGenfv( coord, pname, params );
1632 }
1633
logGetTexGeniv(GLenum coord,GLenum pname,GLint * params)1634 static void APIENTRY logGetTexGeniv(GLenum coord, GLenum pname, GLint *params)
1635 {
1636 SIG( "glGetTexGeniv" );
1637 dllGetTexGeniv( coord, pname, params );
1638 }
1639
logGetTexImage(GLenum target,GLint level,GLenum format,GLenum type,void * pixels)1640 static void APIENTRY logGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, void *pixels)
1641 {
1642 SIG( "glGetTexImage" );
1643 dllGetTexImage( target, level, format, type, pixels );
1644 }
logGetTexLevelParameterfv(GLenum target,GLint level,GLenum pname,GLfloat * params)1645 static void APIENTRY logGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params )
1646 {
1647 SIG( "glGetTexLevelParameterfv" );
1648 dllGetTexLevelParameterfv( target, level, pname, params );
1649 }
1650
logGetTexLevelParameteriv(GLenum target,GLint level,GLenum pname,GLint * params)1651 static void APIENTRY logGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
1652 {
1653 SIG( "glGetTexLevelParameteriv" );
1654 dllGetTexLevelParameteriv( target, level, pname, params );
1655 }
1656
logGetTexParameterfv(GLenum target,GLenum pname,GLfloat * params)1657 static void APIENTRY logGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
1658 {
1659 SIG( "glGetTexParameterfv" );
1660 dllGetTexParameterfv( target, pname, params );
1661 }
1662
logGetTexParameteriv(GLenum target,GLenum pname,GLint * params)1663 static void APIENTRY logGetTexParameteriv(GLenum target, GLenum pname, GLint *params)
1664 {
1665 SIG( "glGetTexParameteriv" );
1666 dllGetTexParameteriv( target, pname, params );
1667 }
1668
logHint(GLenum target,GLenum mode)1669 static void APIENTRY logHint(GLenum target, GLenum mode)
1670 {
1671 fprintf( glw_state.log_fp, "glHint( 0x%x, 0x%x )\n", target, mode );
1672 dllHint( target, mode );
1673 }
1674
logIndexMask(GLuint mask)1675 static void APIENTRY logIndexMask(GLuint mask)
1676 {
1677 SIG( "glIndexMask" );
1678 dllIndexMask( mask );
1679 }
1680
logIndexPointer(GLenum type,GLsizei stride,const void * pointer)1681 static void APIENTRY logIndexPointer(GLenum type, GLsizei stride, const void *pointer)
1682 {
1683 SIG( "glIndexPointer" );
1684 dllIndexPointer( type, stride, pointer );
1685 }
1686
logIndexd(GLdouble c)1687 static void APIENTRY logIndexd(GLdouble c)
1688 {
1689 SIG( "glIndexd" );
1690 dllIndexd( c );
1691 }
1692
logIndexdv(const GLdouble * c)1693 static void APIENTRY logIndexdv(const GLdouble *c)
1694 {
1695 SIG( "glIndexdv" );
1696 dllIndexdv( c );
1697 }
1698
logIndexf(GLfloat c)1699 static void APIENTRY logIndexf(GLfloat c)
1700 {
1701 SIG( "glIndexf" );
1702 dllIndexf( c );
1703 }
1704
logIndexfv(const GLfloat * c)1705 static void APIENTRY logIndexfv(const GLfloat *c)
1706 {
1707 SIG( "glIndexfv" );
1708 dllIndexfv( c );
1709 }
1710
logIndexi(GLint c)1711 static void APIENTRY logIndexi(GLint c)
1712 {
1713 SIG( "glIndexi" );
1714 dllIndexi( c );
1715 }
1716
logIndexiv(const GLint * c)1717 static void APIENTRY logIndexiv(const GLint *c)
1718 {
1719 SIG( "glIndexiv" );
1720 dllIndexiv( c );
1721 }
1722
logIndexs(GLshort c)1723 static void APIENTRY logIndexs(GLshort c)
1724 {
1725 SIG( "glIndexs" );
1726 dllIndexs( c );
1727 }
1728
logIndexsv(const GLshort * c)1729 static void APIENTRY logIndexsv(const GLshort *c)
1730 {
1731 SIG( "glIndexsv" );
1732 dllIndexsv( c );
1733 }
1734
logIndexub(GLubyte c)1735 static void APIENTRY logIndexub(GLubyte c)
1736 {
1737 SIG( "glIndexub" );
1738 dllIndexub( c );
1739 }
1740
logIndexubv(const GLubyte * c)1741 static void APIENTRY logIndexubv(const GLubyte *c)
1742 {
1743 SIG( "glIndexubv" );
1744 dllIndexubv( c );
1745 }
1746
logInitNames(void)1747 static void APIENTRY logInitNames(void)
1748 {
1749 SIG( "glInitNames" );
1750 dllInitNames();
1751 }
1752
logInterleavedArrays(GLenum format,GLsizei stride,const void * pointer)1753 static void APIENTRY logInterleavedArrays(GLenum format, GLsizei stride, const void *pointer)
1754 {
1755 SIG( "glInterleavedArrays" );
1756 dllInterleavedArrays( format, stride, pointer );
1757 }
1758
logIsEnabled(GLenum cap)1759 static GLboolean APIENTRY logIsEnabled(GLenum cap)
1760 {
1761 SIG( "glIsEnabled" );
1762 return dllIsEnabled( cap );
1763 }
logIsList(GLuint list)1764 static GLboolean APIENTRY logIsList(GLuint list)
1765 {
1766 SIG( "glIsList" );
1767 return dllIsList( list );
1768 }
logIsTexture(GLuint texture)1769 static GLboolean APIENTRY logIsTexture(GLuint texture)
1770 {
1771 SIG( "glIsTexture" );
1772 return dllIsTexture( texture );
1773 }
1774
logLightModelf(GLenum pname,GLfloat param)1775 static void APIENTRY logLightModelf(GLenum pname, GLfloat param)
1776 {
1777 SIG( "glLightModelf" );
1778 dllLightModelf( pname, param );
1779 }
1780
logLightModelfv(GLenum pname,const GLfloat * params)1781 static void APIENTRY logLightModelfv(GLenum pname, const GLfloat *params)
1782 {
1783 SIG( "glLightModelfv" );
1784 dllLightModelfv( pname, params );
1785 }
1786
logLightModeli(GLenum pname,GLint param)1787 static void APIENTRY logLightModeli(GLenum pname, GLint param)
1788 {
1789 SIG( "glLightModeli" );
1790 dllLightModeli( pname, param );
1791
1792 }
1793
logLightModeliv(GLenum pname,const GLint * params)1794 static void APIENTRY logLightModeliv(GLenum pname, const GLint *params)
1795 {
1796 SIG( "glLightModeliv" );
1797 dllLightModeliv( pname, params );
1798 }
1799
logLightf(GLenum light,GLenum pname,GLfloat param)1800 static void APIENTRY logLightf(GLenum light, GLenum pname, GLfloat param)
1801 {
1802 SIG( "glLightf" );
1803 dllLightf( light, pname, param );
1804 }
1805
logLightfv(GLenum light,GLenum pname,const GLfloat * params)1806 static void APIENTRY logLightfv(GLenum light, GLenum pname, const GLfloat *params)
1807 {
1808 SIG( "glLightfv" );
1809 dllLightfv( light, pname, params );
1810 }
1811
logLighti(GLenum light,GLenum pname,GLint param)1812 static void APIENTRY logLighti(GLenum light, GLenum pname, GLint param)
1813 {
1814 SIG( "glLighti" );
1815 dllLighti( light, pname, param );
1816 }
1817
logLightiv(GLenum light,GLenum pname,const GLint * params)1818 static void APIENTRY logLightiv(GLenum light, GLenum pname, const GLint *params)
1819 {
1820 SIG( "glLightiv" );
1821 dllLightiv( light, pname, params );
1822 }
1823
logLineStipple(GLint factor,GLushort pattern)1824 static void APIENTRY logLineStipple(GLint factor, GLushort pattern)
1825 {
1826 SIG( "glLineStipple" );
1827 dllLineStipple( factor, pattern );
1828 }
1829
logLineWidth(GLfloat width)1830 static void APIENTRY logLineWidth(GLfloat width)
1831 {
1832 SIG( "glLineWidth" );
1833 dllLineWidth( width );
1834 }
1835
logListBase(GLuint base)1836 static void APIENTRY logListBase(GLuint base)
1837 {
1838 SIG( "glListBase" );
1839 dllListBase( base );
1840 }
1841
logLoadIdentity(void)1842 static void APIENTRY logLoadIdentity(void)
1843 {
1844 SIG( "glLoadIdentity" );
1845 dllLoadIdentity();
1846 }
1847
logLoadMatrixd(const GLdouble * m)1848 static void APIENTRY logLoadMatrixd(const GLdouble *m)
1849 {
1850 SIG( "glLoadMatrixd" );
1851 dllLoadMatrixd( m );
1852 }
1853
logLoadMatrixf(const GLfloat * m)1854 static void APIENTRY logLoadMatrixf(const GLfloat *m)
1855 {
1856 SIG( "glLoadMatrixf" );
1857 dllLoadMatrixf( m );
1858 }
1859
logLoadName(GLuint name)1860 static void APIENTRY logLoadName(GLuint name)
1861 {
1862 SIG( "glLoadName" );
1863 dllLoadName( name );
1864 }
1865
logLogicOp(GLenum opcode)1866 static void APIENTRY logLogicOp(GLenum opcode)
1867 {
1868 SIG( "glLogicOp" );
1869 dllLogicOp( opcode );
1870 }
1871
logMap1d(GLenum target,GLdouble u1,GLdouble u2,GLint stride,GLint order,const GLdouble * points)1872 static void APIENTRY logMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points)
1873 {
1874 SIG( "glMap1d" );
1875 dllMap1d( target, u1, u2, stride, order, points );
1876 }
1877
logMap1f(GLenum target,GLfloat u1,GLfloat u2,GLint stride,GLint order,const GLfloat * points)1878 static void APIENTRY logMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points)
1879 {
1880 SIG( "glMap1f" );
1881 dllMap1f( target, u1, u2, stride, order, points );
1882 }
1883
logMap2d(GLenum target,GLdouble u1,GLdouble u2,GLint ustride,GLint uorder,GLdouble v1,GLdouble v2,GLint vstride,GLint vorder,const GLdouble * points)1884 static void APIENTRY logMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points)
1885 {
1886 SIG( "glMap2d" );
1887 dllMap2d( target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points );
1888 }
1889
logMap2f(GLenum target,GLfloat u1,GLfloat u2,GLint ustride,GLint uorder,GLfloat v1,GLfloat v2,GLint vstride,GLint vorder,const GLfloat * points)1890 static void APIENTRY logMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points)
1891 {
1892 SIG( "glMap2f" );
1893 dllMap2f( target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points );
1894 }
1895
logMapGrid1d(GLint un,GLdouble u1,GLdouble u2)1896 static void APIENTRY logMapGrid1d(GLint un, GLdouble u1, GLdouble u2)
1897 {
1898 SIG( "glMapGrid1d" );
1899 dllMapGrid1d( un, u1, u2 );
1900 }
1901
logMapGrid1f(GLint un,GLfloat u1,GLfloat u2)1902 static void APIENTRY logMapGrid1f(GLint un, GLfloat u1, GLfloat u2)
1903 {
1904 SIG( "glMapGrid1f" );
1905 dllMapGrid1f( un, u1, u2 );
1906 }
1907
logMapGrid2d(GLint un,GLdouble u1,GLdouble u2,GLint vn,GLdouble v1,GLdouble v2)1908 static void APIENTRY logMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2)
1909 {
1910 SIG( "glMapGrid2d" );
1911 dllMapGrid2d( un, u1, u2, vn, v1, v2 );
1912 }
logMapGrid2f(GLint un,GLfloat u1,GLfloat u2,GLint vn,GLfloat v1,GLfloat v2)1913 static void APIENTRY logMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)
1914 {
1915 SIG( "glMapGrid2f" );
1916 dllMapGrid2f( un, u1, u2, vn, v1, v2 );
1917 }
logMaterialf(GLenum face,GLenum pname,GLfloat param)1918 static void APIENTRY logMaterialf(GLenum face, GLenum pname, GLfloat param)
1919 {
1920 SIG( "glMaterialf" );
1921 dllMaterialf( face, pname, param );
1922 }
logMaterialfv(GLenum face,GLenum pname,const GLfloat * params)1923 static void APIENTRY logMaterialfv(GLenum face, GLenum pname, const GLfloat *params)
1924 {
1925 SIG( "glMaterialfv" );
1926 dllMaterialfv( face, pname, params );
1927 }
1928
logMateriali(GLenum face,GLenum pname,GLint param)1929 static void APIENTRY logMateriali(GLenum face, GLenum pname, GLint param)
1930 {
1931 SIG( "glMateriali" );
1932 dllMateriali( face, pname, param );
1933 }
1934
logMaterialiv(GLenum face,GLenum pname,const GLint * params)1935 static void APIENTRY logMaterialiv(GLenum face, GLenum pname, const GLint *params)
1936 {
1937 SIG( "glMaterialiv" );
1938 dllMaterialiv( face, pname, params );
1939 }
1940
logMatrixMode(GLenum mode)1941 static void APIENTRY logMatrixMode(GLenum mode)
1942 {
1943 SIG( "glMatrixMode" );
1944 dllMatrixMode( mode );
1945 }
1946
logMultMatrixd(const GLdouble * m)1947 static void APIENTRY logMultMatrixd(const GLdouble *m)
1948 {
1949 SIG( "glMultMatrixd" );
1950 dllMultMatrixd( m );
1951 }
1952
logMultMatrixf(const GLfloat * m)1953 static void APIENTRY logMultMatrixf(const GLfloat *m)
1954 {
1955 SIG( "glMultMatrixf" );
1956 dllMultMatrixf( m );
1957 }
1958
logNewList(GLuint list,GLenum mode)1959 static void APIENTRY logNewList(GLuint list, GLenum mode)
1960 {
1961 SIG( "glNewList" );
1962 dllNewList( list, mode );
1963 }
1964
logNormal3b(GLbyte nx,GLbyte ny,GLbyte nz)1965 static void APIENTRY logNormal3b(GLbyte nx, GLbyte ny, GLbyte nz)
1966 {
1967 SIG ("glNormal3b" );
1968 dllNormal3b( nx, ny, nz );
1969 }
1970
logNormal3bv(const GLbyte * v)1971 static void APIENTRY logNormal3bv(const GLbyte *v)
1972 {
1973 SIG( "glNormal3bv" );
1974 dllNormal3bv( v );
1975 }
1976
logNormal3d(GLdouble nx,GLdouble ny,GLdouble nz)1977 static void APIENTRY logNormal3d(GLdouble nx, GLdouble ny, GLdouble nz)
1978 {
1979 SIG( "glNormal3d" );
1980 dllNormal3d( nx, ny, nz );
1981 }
1982
logNormal3dv(const GLdouble * v)1983 static void APIENTRY logNormal3dv(const GLdouble *v)
1984 {
1985 SIG( "glNormal3dv" );
1986 dllNormal3dv( v );
1987 }
1988
logNormal3f(GLfloat nx,GLfloat ny,GLfloat nz)1989 static void APIENTRY logNormal3f(GLfloat nx, GLfloat ny, GLfloat nz)
1990 {
1991 SIG( "glNormal3f" );
1992 dllNormal3f( nx, ny, nz );
1993 }
1994
logNormal3fv(const GLfloat * v)1995 static void APIENTRY logNormal3fv(const GLfloat *v)
1996 {
1997 SIG( "glNormal3fv" );
1998 dllNormal3fv( v );
1999 }
logNormal3i(GLint nx,GLint ny,GLint nz)2000 static void APIENTRY logNormal3i(GLint nx, GLint ny, GLint nz)
2001 {
2002 SIG( "glNormal3i" );
2003 dllNormal3i( nx, ny, nz );
2004 }
logNormal3iv(const GLint * v)2005 static void APIENTRY logNormal3iv(const GLint *v)
2006 {
2007 SIG( "glNormal3iv" );
2008 dllNormal3iv( v );
2009 }
logNormal3s(GLshort nx,GLshort ny,GLshort nz)2010 static void APIENTRY logNormal3s(GLshort nx, GLshort ny, GLshort nz)
2011 {
2012 SIG( "glNormal3s" );
2013 dllNormal3s( nx, ny, nz );
2014 }
logNormal3sv(const GLshort * v)2015 static void APIENTRY logNormal3sv(const GLshort *v)
2016 {
2017 SIG( "glNormal3sv" );
2018 dllNormal3sv( v );
2019 }
logNormalPointer(GLenum type,GLsizei stride,const void * pointer)2020 static void APIENTRY logNormalPointer(GLenum type, GLsizei stride, const void *pointer)
2021 {
2022 SIG( "glNormalPointer" );
2023 dllNormalPointer( type, stride, pointer );
2024 }
logOrtho(GLdouble left,GLdouble right,GLdouble bottom,GLdouble top,GLdouble zNear,GLdouble zFar)2025 static void APIENTRY logOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
2026 {
2027 SIG( "glOrtho" );
2028 dllOrtho( left, right, bottom, top, zNear, zFar );
2029 }
2030
logPassThrough(GLfloat token)2031 static void APIENTRY logPassThrough(GLfloat token)
2032 {
2033 SIG( "glPassThrough" );
2034 dllPassThrough( token );
2035 }
2036
logPixelMapfv(GLenum map,GLsizei mapsize,const GLfloat * values)2037 static void APIENTRY logPixelMapfv(GLenum map, GLsizei mapsize, const GLfloat *values)
2038 {
2039 SIG( "glPixelMapfv" );
2040 dllPixelMapfv( map, mapsize, values );
2041 }
2042
logPixelMapuiv(GLenum map,GLsizei mapsize,const GLuint * values)2043 static void APIENTRY logPixelMapuiv(GLenum map, GLsizei mapsize, const GLuint *values)
2044 {
2045 SIG( "glPixelMapuiv" );
2046 dllPixelMapuiv( map, mapsize, values );
2047 }
2048
logPixelMapusv(GLenum map,GLsizei mapsize,const GLushort * values)2049 static void APIENTRY logPixelMapusv(GLenum map, GLsizei mapsize, const GLushort *values)
2050 {
2051 SIG( "glPixelMapusv" );
2052 dllPixelMapusv( map, mapsize, values );
2053 }
logPixelStoref(GLenum pname,GLfloat param)2054 static void APIENTRY logPixelStoref(GLenum pname, GLfloat param)
2055 {
2056 SIG( "glPixelStoref" );
2057 dllPixelStoref( pname, param );
2058 }
logPixelStorei(GLenum pname,GLint param)2059 static void APIENTRY logPixelStorei(GLenum pname, GLint param)
2060 {
2061 SIG( "glPixelStorei" );
2062 dllPixelStorei( pname, param );
2063 }
logPixelTransferf(GLenum pname,GLfloat param)2064 static void APIENTRY logPixelTransferf(GLenum pname, GLfloat param)
2065 {
2066 SIG( "glPixelTransferf" );
2067 dllPixelTransferf( pname, param );
2068 }
2069
logPixelTransferi(GLenum pname,GLint param)2070 static void APIENTRY logPixelTransferi(GLenum pname, GLint param)
2071 {
2072 SIG( "glPixelTransferi" );
2073 dllPixelTransferi( pname, param );
2074 }
2075
logPixelZoom(GLfloat xfactor,GLfloat yfactor)2076 static void APIENTRY logPixelZoom(GLfloat xfactor, GLfloat yfactor)
2077 {
2078 SIG( "glPixelZoom" );
2079 dllPixelZoom( xfactor, yfactor );
2080 }
2081
logPointSize(GLfloat size)2082 static void APIENTRY logPointSize(GLfloat size)
2083 {
2084 SIG( "glPointSize" );
2085 dllPointSize( size );
2086 }
2087
logPolygonMode(GLenum face,GLenum mode)2088 static void APIENTRY logPolygonMode(GLenum face, GLenum mode)
2089 {
2090 fprintf( glw_state.log_fp, "glPolygonMode( 0x%x, 0x%x )\n", face, mode );
2091 dllPolygonMode( face, mode );
2092 }
2093
logPolygonOffset(GLfloat factor,GLfloat units)2094 static void APIENTRY logPolygonOffset(GLfloat factor, GLfloat units)
2095 {
2096 SIG( "glPolygonOffset" );
2097 dllPolygonOffset( factor, units );
2098 }
logPolygonStipple(const GLubyte * mask)2099 static void APIENTRY logPolygonStipple(const GLubyte *mask )
2100 {
2101 SIG( "glPolygonStipple" );
2102 dllPolygonStipple( mask );
2103 }
logPopAttrib(void)2104 static void APIENTRY logPopAttrib(void)
2105 {
2106 SIG( "glPopAttrib" );
2107 dllPopAttrib();
2108 }
2109
logPopClientAttrib(void)2110 static void APIENTRY logPopClientAttrib(void)
2111 {
2112 SIG( "glPopClientAttrib" );
2113 dllPopClientAttrib();
2114 }
2115
logPopMatrix(void)2116 static void APIENTRY logPopMatrix(void)
2117 {
2118 SIG( "glPopMatrix" );
2119 dllPopMatrix();
2120 }
2121
logPopName(void)2122 static void APIENTRY logPopName(void)
2123 {
2124 SIG( "glPopName" );
2125 dllPopName();
2126 }
2127
logPrioritizeTextures(GLsizei n,const GLuint * textures,const GLclampf * priorities)2128 static void APIENTRY logPrioritizeTextures(GLsizei n, const GLuint *textures, const GLclampf *priorities)
2129 {
2130 SIG( "glPrioritizeTextures" );
2131 dllPrioritizeTextures( n, textures, priorities );
2132 }
2133
logPushAttrib(GLbitfield mask)2134 static void APIENTRY logPushAttrib(GLbitfield mask)
2135 {
2136 SIG( "glPushAttrib" );
2137 dllPushAttrib( mask );
2138 }
2139
logPushClientAttrib(GLbitfield mask)2140 static void APIENTRY logPushClientAttrib(GLbitfield mask)
2141 {
2142 SIG( "glPushClientAttrib" );
2143 dllPushClientAttrib( mask );
2144 }
2145
logPushMatrix(void)2146 static void APIENTRY logPushMatrix(void)
2147 {
2148 SIG( "glPushMatrix" );
2149 dllPushMatrix();
2150 }
2151
logPushName(GLuint name)2152 static void APIENTRY logPushName(GLuint name)
2153 {
2154 SIG( "glPushName" );
2155 dllPushName( name );
2156 }
2157
logRasterPos2d(GLdouble x,GLdouble y)2158 static void APIENTRY logRasterPos2d(GLdouble x, GLdouble y)
2159 {
2160 SIG ("glRasterPot2d" );
2161 dllRasterPos2d( x, y );
2162 }
2163
logRasterPos2dv(const GLdouble * v)2164 static void APIENTRY logRasterPos2dv(const GLdouble *v)
2165 {
2166 SIG( "glRasterPos2dv" );
2167 dllRasterPos2dv( v );
2168 }
2169
logRasterPos2f(GLfloat x,GLfloat y)2170 static void APIENTRY logRasterPos2f(GLfloat x, GLfloat y)
2171 {
2172 SIG( "glRasterPos2f" );
2173 dllRasterPos2f( x, y );
2174 }
logRasterPos2fv(const GLfloat * v)2175 static void APIENTRY logRasterPos2fv(const GLfloat *v)
2176 {
2177 SIG( "glRasterPos2dv" );
2178 dllRasterPos2fv( v );
2179 }
logRasterPos2i(GLint x,GLint y)2180 static void APIENTRY logRasterPos2i(GLint x, GLint y)
2181 {
2182 SIG( "glRasterPos2if" );
2183 dllRasterPos2i( x, y );
2184 }
logRasterPos2iv(const GLint * v)2185 static void APIENTRY logRasterPos2iv(const GLint *v)
2186 {
2187 SIG( "glRasterPos2iv" );
2188 dllRasterPos2iv( v );
2189 }
logRasterPos2s(GLshort x,GLshort y)2190 static void APIENTRY logRasterPos2s(GLshort x, GLshort y)
2191 {
2192 SIG( "glRasterPos2s" );
2193 dllRasterPos2s( x, y );
2194 }
logRasterPos2sv(const GLshort * v)2195 static void APIENTRY logRasterPos2sv(const GLshort *v)
2196 {
2197 SIG( "glRasterPos2sv" );
2198 dllRasterPos2sv( v );
2199 }
logRasterPos3d(GLdouble x,GLdouble y,GLdouble z)2200 static void APIENTRY logRasterPos3d(GLdouble x, GLdouble y, GLdouble z)
2201 {
2202 SIG( "glRasterPos3d" );
2203 dllRasterPos3d( x, y, z );
2204 }
logRasterPos3dv(const GLdouble * v)2205 static void APIENTRY logRasterPos3dv(const GLdouble *v)
2206 {
2207 SIG( "glRasterPos3dv" );
2208 dllRasterPos3dv( v );
2209 }
logRasterPos3f(GLfloat x,GLfloat y,GLfloat z)2210 static void APIENTRY logRasterPos3f(GLfloat x, GLfloat y, GLfloat z)
2211 {
2212 SIG( "glRasterPos3f" );
2213 dllRasterPos3f( x, y, z );
2214 }
logRasterPos3fv(const GLfloat * v)2215 static void APIENTRY logRasterPos3fv(const GLfloat *v)
2216 {
2217 SIG( "glRasterPos3fv" );
2218 dllRasterPos3fv( v );
2219 }
logRasterPos3i(GLint x,GLint y,GLint z)2220 static void APIENTRY logRasterPos3i(GLint x, GLint y, GLint z)
2221 {
2222 SIG( "glRasterPos3i" );
2223 dllRasterPos3i( x, y, z );
2224 }
logRasterPos3iv(const GLint * v)2225 static void APIENTRY logRasterPos3iv(const GLint *v)
2226 {
2227 SIG( "glRasterPos3iv" );
2228 dllRasterPos3iv( v );
2229 }
logRasterPos3s(GLshort x,GLshort y,GLshort z)2230 static void APIENTRY logRasterPos3s(GLshort x, GLshort y, GLshort z)
2231 {
2232 SIG( "glRasterPos3s" );
2233 dllRasterPos3s( x, y, z );
2234 }
logRasterPos3sv(const GLshort * v)2235 static void APIENTRY logRasterPos3sv(const GLshort *v)
2236 {
2237 SIG( "glRasterPos3sv" );
2238 dllRasterPos3sv( v );
2239 }
logRasterPos4d(GLdouble x,GLdouble y,GLdouble z,GLdouble w)2240 static void APIENTRY logRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
2241 {
2242 SIG( "glRasterPos4d" );
2243 dllRasterPos4d( x, y, z, w );
2244 }
logRasterPos4dv(const GLdouble * v)2245 static void APIENTRY logRasterPos4dv(const GLdouble *v)
2246 {
2247 SIG( "glRasterPos4dv" );
2248 dllRasterPos4dv( v );
2249 }
logRasterPos4f(GLfloat x,GLfloat y,GLfloat z,GLfloat w)2250 static void APIENTRY logRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
2251 {
2252 SIG( "glRasterPos4f" );
2253 dllRasterPos4f( x, y, z, w );
2254 }
logRasterPos4fv(const GLfloat * v)2255 static void APIENTRY logRasterPos4fv(const GLfloat *v)
2256 {
2257 SIG( "glRasterPos4fv" );
2258 dllRasterPos4fv( v );
2259 }
logRasterPos4i(GLint x,GLint y,GLint z,GLint w)2260 static void APIENTRY logRasterPos4i(GLint x, GLint y, GLint z, GLint w)
2261 {
2262 SIG( "glRasterPos4i" );
2263 dllRasterPos4i( x, y, z, w );
2264 }
logRasterPos4iv(const GLint * v)2265 static void APIENTRY logRasterPos4iv(const GLint *v)
2266 {
2267 SIG( "glRasterPos4iv" );
2268 dllRasterPos4iv( v );
2269 }
logRasterPos4s(GLshort x,GLshort y,GLshort z,GLshort w)2270 static void APIENTRY logRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)
2271 {
2272 SIG( "glRasterPos4s" );
2273 dllRasterPos4s( x, y, z, w );
2274 }
logRasterPos4sv(const GLshort * v)2275 static void APIENTRY logRasterPos4sv(const GLshort *v)
2276 {
2277 SIG( "glRasterPos4sv" );
2278 dllRasterPos4sv( v );
2279 }
logReadBuffer(GLenum mode)2280 static void APIENTRY logReadBuffer(GLenum mode)
2281 {
2282 SIG( "glReadBuffer" );
2283 dllReadBuffer( mode );
2284 }
logReadPixels(GLint x,GLint y,GLsizei width,GLsizei height,GLenum format,GLenum type,void * pixels)2285 static void APIENTRY logReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *pixels)
2286 {
2287 SIG( "glReadPixels" );
2288 dllReadPixels( x, y, width, height, format, type, pixels );
2289 }
2290
logRectd(GLdouble x1,GLdouble y1,GLdouble x2,GLdouble y2)2291 static void APIENTRY logRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
2292 {
2293 SIG( "glRectd" );
2294 dllRectd( x1, y1, x2, y2 );
2295 }
2296
logRectdv(const GLdouble * v1,const GLdouble * v2)2297 static void APIENTRY logRectdv(const GLdouble *v1, const GLdouble *v2)
2298 {
2299 SIG( "glRectdv" );
2300 dllRectdv( v1, v2 );
2301 }
2302
logRectf(GLfloat x1,GLfloat y1,GLfloat x2,GLfloat y2)2303 static void APIENTRY logRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
2304 {
2305 SIG( "glRectf" );
2306 dllRectf( x1, y1, x2, y2 );
2307 }
2308
logRectfv(const GLfloat * v1,const GLfloat * v2)2309 static void APIENTRY logRectfv(const GLfloat *v1, const GLfloat *v2)
2310 {
2311 SIG( "glRectfv" );
2312 dllRectfv( v1, v2 );
2313 }
logRecti(GLint x1,GLint y1,GLint x2,GLint y2)2314 static void APIENTRY logRecti(GLint x1, GLint y1, GLint x2, GLint y2)
2315 {
2316 SIG( "glRecti" );
2317 dllRecti( x1, y1, x2, y2 );
2318 }
logRectiv(const GLint * v1,const GLint * v2)2319 static void APIENTRY logRectiv(const GLint *v1, const GLint *v2)
2320 {
2321 SIG( "glRectiv" );
2322 dllRectiv( v1, v2 );
2323 }
logRects(GLshort x1,GLshort y1,GLshort x2,GLshort y2)2324 static void APIENTRY logRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2)
2325 {
2326 SIG( "glRects" );
2327 dllRects( x1, y1, x2, y2 );
2328 }
logRectsv(const GLshort * v1,const GLshort * v2)2329 static void APIENTRY logRectsv(const GLshort *v1, const GLshort *v2)
2330 {
2331 SIG( "glRectsv" );
2332 dllRectsv( v1, v2 );
2333 }
logRenderMode(GLenum mode)2334 static GLint APIENTRY logRenderMode(GLenum mode)
2335 {
2336 SIG( "glRenderMode" );
2337 return dllRenderMode( mode );
2338 }
logRotated(GLdouble angle,GLdouble x,GLdouble y,GLdouble z)2339 static void APIENTRY logRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
2340 {
2341 SIG( "glRotated" );
2342 dllRotated( angle, x, y, z );
2343 }
2344
logRotatef(GLfloat angle,GLfloat x,GLfloat y,GLfloat z)2345 static void APIENTRY logRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
2346 {
2347 SIG( "glRotatef" );
2348 dllRotatef( angle, x, y, z );
2349 }
2350
logScaled(GLdouble x,GLdouble y,GLdouble z)2351 static void APIENTRY logScaled(GLdouble x, GLdouble y, GLdouble z)
2352 {
2353 SIG( "glScaled" );
2354 dllScaled( x, y, z );
2355 }
2356
logScalef(GLfloat x,GLfloat y,GLfloat z)2357 static void APIENTRY logScalef(GLfloat x, GLfloat y, GLfloat z)
2358 {
2359 SIG( "glScalef" );
2360 dllScalef( x, y, z );
2361 }
2362
logScissor(GLint x,GLint y,GLsizei width,GLsizei height)2363 static void APIENTRY logScissor(GLint x, GLint y, GLsizei width, GLsizei height)
2364 {
2365 fprintf( glw_state.log_fp, "glScissor( %d, %d, %d, %d )\n", x, y, width, height );
2366 dllScissor( x, y, width, height );
2367 }
2368
logSelectBuffer(GLsizei size,GLuint * buffer)2369 static void APIENTRY logSelectBuffer(GLsizei size, GLuint *buffer)
2370 {
2371 SIG( "glSelectBuffer" );
2372 dllSelectBuffer( size, buffer );
2373 }
2374
logShadeModel(GLenum mode)2375 static void APIENTRY logShadeModel(GLenum mode)
2376 {
2377 SIG( "glShadeModel" );
2378 dllShadeModel( mode );
2379 }
2380
logStencilFunc(GLenum func,GLint ref,GLuint mask)2381 static void APIENTRY logStencilFunc(GLenum func, GLint ref, GLuint mask)
2382 {
2383 SIG( "glStencilFunc" );
2384 dllStencilFunc( func, ref, mask );
2385 }
2386
logStencilMask(GLuint mask)2387 static void APIENTRY logStencilMask(GLuint mask)
2388 {
2389 SIG( "glStencilMask" );
2390 dllStencilMask( mask );
2391 }
2392
logStencilOp(GLenum fail,GLenum zfail,GLenum zpass)2393 static void APIENTRY logStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
2394 {
2395 SIG( "glStencilOp" );
2396 dllStencilOp( fail, zfail, zpass );
2397 }
2398
logTexCoord1d(GLdouble s)2399 static void APIENTRY logTexCoord1d(GLdouble s)
2400 {
2401 SIG( "glTexCoord1d" );
2402 dllTexCoord1d( s );
2403 }
2404
logTexCoord1dv(const GLdouble * v)2405 static void APIENTRY logTexCoord1dv(const GLdouble *v)
2406 {
2407 SIG( "glTexCoord1dv" );
2408 dllTexCoord1dv( v );
2409 }
2410
logTexCoord1f(GLfloat s)2411 static void APIENTRY logTexCoord1f(GLfloat s)
2412 {
2413 SIG( "glTexCoord1f" );
2414 dllTexCoord1f( s );
2415 }
logTexCoord1fv(const GLfloat * v)2416 static void APIENTRY logTexCoord1fv(const GLfloat *v)
2417 {
2418 SIG( "glTexCoord1fv" );
2419 dllTexCoord1fv( v );
2420 }
logTexCoord1i(GLint s)2421 static void APIENTRY logTexCoord1i(GLint s)
2422 {
2423 SIG( "glTexCoord1i" );
2424 dllTexCoord1i( s );
2425 }
logTexCoord1iv(const GLint * v)2426 static void APIENTRY logTexCoord1iv(const GLint *v)
2427 {
2428 SIG( "glTexCoord1iv" );
2429 dllTexCoord1iv( v );
2430 }
logTexCoord1s(GLshort s)2431 static void APIENTRY logTexCoord1s(GLshort s)
2432 {
2433 SIG( "glTexCoord1s" );
2434 dllTexCoord1s( s );
2435 }
logTexCoord1sv(const GLshort * v)2436 static void APIENTRY logTexCoord1sv(const GLshort *v)
2437 {
2438 SIG( "glTexCoord1sv" );
2439 dllTexCoord1sv( v );
2440 }
logTexCoord2d(GLdouble s,GLdouble t)2441 static void APIENTRY logTexCoord2d(GLdouble s, GLdouble t)
2442 {
2443 SIG( "glTexCoord2d" );
2444 dllTexCoord2d( s, t );
2445 }
2446
logTexCoord2dv(const GLdouble * v)2447 static void APIENTRY logTexCoord2dv(const GLdouble *v)
2448 {
2449 SIG( "glTexCoord2dv" );
2450 dllTexCoord2dv( v );
2451 }
logTexCoord2f(GLfloat s,GLfloat t)2452 static void APIENTRY logTexCoord2f(GLfloat s, GLfloat t)
2453 {
2454 SIG( "glTexCoord2f" );
2455 dllTexCoord2f( s, t );
2456 }
logTexCoord2fv(const GLfloat * v)2457 static void APIENTRY logTexCoord2fv(const GLfloat *v)
2458 {
2459 SIG( "glTexCoord2fv" );
2460 dllTexCoord2fv( v );
2461 }
logTexCoord2i(GLint s,GLint t)2462 static void APIENTRY logTexCoord2i(GLint s, GLint t)
2463 {
2464 SIG( "glTexCoord2i" );
2465 dllTexCoord2i( s, t );
2466 }
logTexCoord2iv(const GLint * v)2467 static void APIENTRY logTexCoord2iv(const GLint *v)
2468 {
2469 SIG( "glTexCoord2iv" );
2470 dllTexCoord2iv( v );
2471 }
logTexCoord2s(GLshort s,GLshort t)2472 static void APIENTRY logTexCoord2s(GLshort s, GLshort t)
2473 {
2474 SIG( "glTexCoord2s" );
2475 dllTexCoord2s( s, t );
2476 }
logTexCoord2sv(const GLshort * v)2477 static void APIENTRY logTexCoord2sv(const GLshort *v)
2478 {
2479 SIG( "glTexCoord2sv" );
2480 dllTexCoord2sv( v );
2481 }
logTexCoord3d(GLdouble s,GLdouble t,GLdouble r)2482 static void APIENTRY logTexCoord3d(GLdouble s, GLdouble t, GLdouble r)
2483 {
2484 SIG( "glTexCoord3d" );
2485 dllTexCoord3d( s, t, r );
2486 }
logTexCoord3dv(const GLdouble * v)2487 static void APIENTRY logTexCoord3dv(const GLdouble *v)
2488 {
2489 SIG( "glTexCoord3dv" );
2490 dllTexCoord3dv( v );
2491 }
logTexCoord3f(GLfloat s,GLfloat t,GLfloat r)2492 static void APIENTRY logTexCoord3f(GLfloat s, GLfloat t, GLfloat r)
2493 {
2494 SIG( "glTexCoord3f" );
2495 dllTexCoord3f( s, t, r );
2496 }
logTexCoord3fv(const GLfloat * v)2497 static void APIENTRY logTexCoord3fv(const GLfloat *v)
2498 {
2499 SIG( "glTexCoord3fv" );
2500 dllTexCoord3fv( v );
2501 }
logTexCoord3i(GLint s,GLint t,GLint r)2502 static void APIENTRY logTexCoord3i(GLint s, GLint t, GLint r)
2503 {
2504 SIG( "glTexCoord3i" );
2505 dllTexCoord3i( s, t, r );
2506 }
logTexCoord3iv(const GLint * v)2507 static void APIENTRY logTexCoord3iv(const GLint *v)
2508 {
2509 SIG( "glTexCoord3iv" );
2510 dllTexCoord3iv( v );
2511 }
logTexCoord3s(GLshort s,GLshort t,GLshort r)2512 static void APIENTRY logTexCoord3s(GLshort s, GLshort t, GLshort r)
2513 {
2514 SIG( "glTexCoord3s" );
2515 dllTexCoord3s( s, t, r );
2516 }
logTexCoord3sv(const GLshort * v)2517 static void APIENTRY logTexCoord3sv(const GLshort *v)
2518 {
2519 SIG( "glTexCoord3sv" );
2520 dllTexCoord3sv( v );
2521 }
logTexCoord4d(GLdouble s,GLdouble t,GLdouble r,GLdouble q)2522 static void APIENTRY logTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q)
2523 {
2524 SIG( "glTexCoord4d" );
2525 dllTexCoord4d( s, t, r, q );
2526 }
logTexCoord4dv(const GLdouble * v)2527 static void APIENTRY logTexCoord4dv(const GLdouble *v)
2528 {
2529 SIG( "glTexCoord4dv" );
2530 dllTexCoord4dv( v );
2531 }
logTexCoord4f(GLfloat s,GLfloat t,GLfloat r,GLfloat q)2532 static void APIENTRY logTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q)
2533 {
2534 SIG( "glTexCoord4f" );
2535 dllTexCoord4f( s, t, r, q );
2536 }
logTexCoord4fv(const GLfloat * v)2537 static void APIENTRY logTexCoord4fv(const GLfloat *v)
2538 {
2539 SIG( "glTexCoord4fv" );
2540 dllTexCoord4fv( v );
2541 }
logTexCoord4i(GLint s,GLint t,GLint r,GLint q)2542 static void APIENTRY logTexCoord4i(GLint s, GLint t, GLint r, GLint q)
2543 {
2544 SIG( "glTexCoord4i" );
2545 dllTexCoord4i( s, t, r, q );
2546 }
logTexCoord4iv(const GLint * v)2547 static void APIENTRY logTexCoord4iv(const GLint *v)
2548 {
2549 SIG( "glTexCoord4iv" );
2550 dllTexCoord4iv( v );
2551 }
logTexCoord4s(GLshort s,GLshort t,GLshort r,GLshort q)2552 static void APIENTRY logTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q)
2553 {
2554 SIG( "glTexCoord4s" );
2555 dllTexCoord4s( s, t, r, q );
2556 }
logTexCoord4sv(const GLshort * v)2557 static void APIENTRY logTexCoord4sv(const GLshort *v)
2558 {
2559 SIG( "glTexCoord4sv" );
2560 dllTexCoord4sv( v );
2561 }
logTexCoordPointer(GLint size,GLenum type,GLsizei stride,const void * pointer)2562 static void APIENTRY logTexCoordPointer(GLint size, GLenum type, GLsizei stride, const void *pointer)
2563 {
2564 fprintf( glw_state.log_fp, "glTexCoordPointer( %d, %s, %d, MEM )\n", size, TypeToString( type ), stride );
2565 dllTexCoordPointer( size, type, stride, pointer );
2566 }
2567
logTexEnvf(GLenum target,GLenum pname,GLfloat param)2568 static void APIENTRY logTexEnvf(GLenum target, GLenum pname, GLfloat param)
2569 {
2570 fprintf( glw_state.log_fp, "glTexEnvf( 0x%x, 0x%x, %f )\n", target, pname, param );
2571 dllTexEnvf( target, pname, param );
2572 }
2573
logTexEnvfv(GLenum target,GLenum pname,const GLfloat * params)2574 static void APIENTRY logTexEnvfv(GLenum target, GLenum pname, const GLfloat *params)
2575 {
2576 SIG( "glTexEnvfv" );
2577 dllTexEnvfv( target, pname, params );
2578 }
2579
logTexEnvi(GLenum target,GLenum pname,GLint param)2580 static void APIENTRY logTexEnvi(GLenum target, GLenum pname, GLint param)
2581 {
2582 fprintf( glw_state.log_fp, "glTexEnvi( 0x%x, 0x%x, 0x%x )\n", target, pname, param );
2583 dllTexEnvi( target, pname, param );
2584 }
logTexEnviv(GLenum target,GLenum pname,const GLint * params)2585 static void APIENTRY logTexEnviv(GLenum target, GLenum pname, const GLint *params)
2586 {
2587 SIG( "glTexEnviv" );
2588 dllTexEnviv( target, pname, params );
2589 }
2590
logTexGend(GLenum coord,GLenum pname,GLdouble param)2591 static void APIENTRY logTexGend(GLenum coord, GLenum pname, GLdouble param)
2592 {
2593 SIG( "glTexGend" );
2594 dllTexGend( coord, pname, param );
2595 }
2596
logTexGendv(GLenum coord,GLenum pname,const GLdouble * params)2597 static void APIENTRY logTexGendv(GLenum coord, GLenum pname, const GLdouble *params)
2598 {
2599 SIG( "glTexGendv" );
2600 dllTexGendv( coord, pname, params );
2601 }
2602
logTexGenf(GLenum coord,GLenum pname,GLfloat param)2603 static void APIENTRY logTexGenf(GLenum coord, GLenum pname, GLfloat param)
2604 {
2605 SIG( "glTexGenf" );
2606 dllTexGenf( coord, pname, param );
2607 }
logTexGenfv(GLenum coord,GLenum pname,const GLfloat * params)2608 static void APIENTRY logTexGenfv(GLenum coord, GLenum pname, const GLfloat *params)
2609 {
2610 SIG( "glTexGenfv" );
2611 dllTexGenfv( coord, pname, params );
2612 }
logTexGeni(GLenum coord,GLenum pname,GLint param)2613 static void APIENTRY logTexGeni(GLenum coord, GLenum pname, GLint param)
2614 {
2615 SIG( "glTexGeni" );
2616 dllTexGeni( coord, pname, param );
2617 }
logTexGeniv(GLenum coord,GLenum pname,const GLint * params)2618 static void APIENTRY logTexGeniv(GLenum coord, GLenum pname, const GLint *params)
2619 {
2620 SIG( "glTexGeniv" );
2621 dllTexGeniv( coord, pname, params );
2622 }
logTexImage1D(GLenum target,GLint level,GLint internalformat,GLsizei width,GLint border,GLenum format,GLenum type,const void * pixels)2623 static void APIENTRY logTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels)
2624 {
2625 SIG( "glTexImage1D" );
2626 dllTexImage1D( target, level, internalformat, width, border, format, type, pixels );
2627 }
logTexImage2D(GLenum target,GLint level,GLint internalformat,GLsizei width,GLsizei height,GLint border,GLenum format,GLenum type,const void * pixels)2628 static void APIENTRY logTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels)
2629 {
2630 SIG( "glTexImage2D" );
2631 dllTexImage2D( target, level, internalformat, width, height, border, format, type, pixels );
2632 }
2633
logTexParameterf(GLenum target,GLenum pname,GLfloat param)2634 static void APIENTRY logTexParameterf(GLenum target, GLenum pname, GLfloat param)
2635 {
2636 fprintf( glw_state.log_fp, "glTexParameterf( 0x%x, 0x%x, %f )\n", target, pname, param );
2637 dllTexParameterf( target, pname, param );
2638 }
2639
logTexParameterfv(GLenum target,GLenum pname,const GLfloat * params)2640 static void APIENTRY logTexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
2641 {
2642 SIG( "glTexParameterfv" );
2643 dllTexParameterfv( target, pname, params );
2644 }
logTexParameteri(GLenum target,GLenum pname,GLint param)2645 static void APIENTRY logTexParameteri(GLenum target, GLenum pname, GLint param)
2646 {
2647 fprintf( glw_state.log_fp, "glTexParameteri( 0x%x, 0x%x, 0x%x )\n", target, pname, param );
2648 dllTexParameteri( target, pname, param );
2649 }
logTexParameteriv(GLenum target,GLenum pname,const GLint * params)2650 static void APIENTRY logTexParameteriv(GLenum target, GLenum pname, const GLint *params)
2651 {
2652 SIG( "glTexParameteriv" );
2653 dllTexParameteriv( target, pname, params );
2654 }
logTexSubImage1D(GLenum target,GLint level,GLint xoffset,GLsizei width,GLenum format,GLenum type,const void * pixels)2655 static void APIENTRY logTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels)
2656 {
2657 SIG( "glTexSubImage1D" );
2658 dllTexSubImage1D( target, level, xoffset, width, format, type, pixels );
2659 }
logTexSubImage2D(GLenum target,GLint level,GLint xoffset,GLint yoffset,GLsizei width,GLsizei height,GLenum format,GLenum type,const void * pixels)2660 static void APIENTRY logTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels)
2661 {
2662 SIG( "glTexSubImage2D" );
2663 dllTexSubImage2D( target, level, xoffset, yoffset, width, height, format, type, pixels );
2664 }
logTranslated(GLdouble x,GLdouble y,GLdouble z)2665 static void APIENTRY logTranslated(GLdouble x, GLdouble y, GLdouble z)
2666 {
2667 SIG( "glTranslated" );
2668 dllTranslated( x, y, z );
2669 }
2670
logTranslatef(GLfloat x,GLfloat y,GLfloat z)2671 static void APIENTRY logTranslatef(GLfloat x, GLfloat y, GLfloat z)
2672 {
2673 SIG( "glTranslatef" );
2674 dllTranslatef( x, y, z );
2675 }
2676
logVertex2d(GLdouble x,GLdouble y)2677 static void APIENTRY logVertex2d(GLdouble x, GLdouble y)
2678 {
2679 SIG( "glVertex2d" );
2680 dllVertex2d( x, y );
2681 }
2682
logVertex2dv(const GLdouble * v)2683 static void APIENTRY logVertex2dv(const GLdouble *v)
2684 {
2685 SIG( "glVertex2dv" );
2686 dllVertex2dv( v );
2687 }
logVertex2f(GLfloat x,GLfloat y)2688 static void APIENTRY logVertex2f(GLfloat x, GLfloat y)
2689 {
2690 SIG( "glVertex2f" );
2691 dllVertex2f( x, y );
2692 }
logVertex2fv(const GLfloat * v)2693 static void APIENTRY logVertex2fv(const GLfloat *v)
2694 {
2695 SIG( "glVertex2fv" );
2696 dllVertex2fv( v );
2697 }
logVertex2i(GLint x,GLint y)2698 static void APIENTRY logVertex2i(GLint x, GLint y)
2699 {
2700 SIG( "glVertex2i" );
2701 dllVertex2i( x, y );
2702 }
logVertex2iv(const GLint * v)2703 static void APIENTRY logVertex2iv(const GLint *v)
2704 {
2705 SIG( "glVertex2iv" );
2706 dllVertex2iv( v );
2707 }
logVertex2s(GLshort x,GLshort y)2708 static void APIENTRY logVertex2s(GLshort x, GLshort y)
2709 {
2710 SIG( "glVertex2s" );
2711 dllVertex2s( x, y );
2712 }
logVertex2sv(const GLshort * v)2713 static void APIENTRY logVertex2sv(const GLshort *v)
2714 {
2715 SIG( "glVertex2sv" );
2716 dllVertex2sv( v );
2717 }
logVertex3d(GLdouble x,GLdouble y,GLdouble z)2718 static void APIENTRY logVertex3d(GLdouble x, GLdouble y, GLdouble z)
2719 {
2720 SIG( "glVertex3d" );
2721 dllVertex3d( x, y, z );
2722 }
logVertex3dv(const GLdouble * v)2723 static void APIENTRY logVertex3dv(const GLdouble *v)
2724 {
2725 SIG( "glVertex3dv" );
2726 dllVertex3dv( v );
2727 }
logVertex3f(GLfloat x,GLfloat y,GLfloat z)2728 static void APIENTRY logVertex3f(GLfloat x, GLfloat y, GLfloat z)
2729 {
2730 SIG( "glVertex3f" );
2731 dllVertex3f( x, y, z );
2732 }
logVertex3fv(const GLfloat * v)2733 static void APIENTRY logVertex3fv(const GLfloat *v)
2734 {
2735 SIG( "glVertex3fv" );
2736 dllVertex3fv( v );
2737 }
logVertex3i(GLint x,GLint y,GLint z)2738 static void APIENTRY logVertex3i(GLint x, GLint y, GLint z)
2739 {
2740 SIG( "glVertex3i" );
2741 dllVertex3i( x, y, z );
2742 }
logVertex3iv(const GLint * v)2743 static void APIENTRY logVertex3iv(const GLint *v)
2744 {
2745 SIG( "glVertex3iv" );
2746 dllVertex3iv( v );
2747 }
logVertex3s(GLshort x,GLshort y,GLshort z)2748 static void APIENTRY logVertex3s(GLshort x, GLshort y, GLshort z)
2749 {
2750 SIG( "glVertex3s" );
2751 dllVertex3s( x, y, z );
2752 }
logVertex3sv(const GLshort * v)2753 static void APIENTRY logVertex3sv(const GLshort *v)
2754 {
2755 SIG( "glVertex3sv" );
2756 dllVertex3sv( v );
2757 }
logVertex4d(GLdouble x,GLdouble y,GLdouble z,GLdouble w)2758 static void APIENTRY logVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
2759 {
2760 SIG( "glVertex4d" );
2761 dllVertex4d( x, y, z, w );
2762 }
logVertex4dv(const GLdouble * v)2763 static void APIENTRY logVertex4dv(const GLdouble *v)
2764 {
2765 SIG( "glVertex4dv" );
2766 dllVertex4dv( v );
2767 }
logVertex4f(GLfloat x,GLfloat y,GLfloat z,GLfloat w)2768 static void APIENTRY logVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
2769 {
2770 SIG( "glVertex4f" );
2771 dllVertex4f( x, y, z, w );
2772 }
logVertex4fv(const GLfloat * v)2773 static void APIENTRY logVertex4fv(const GLfloat *v)
2774 {
2775 SIG( "glVertex4fv" );
2776 dllVertex4fv( v );
2777 }
logVertex4i(GLint x,GLint y,GLint z,GLint w)2778 static void APIENTRY logVertex4i(GLint x, GLint y, GLint z, GLint w)
2779 {
2780 SIG( "glVertex4i" );
2781 dllVertex4i( x, y, z, w );
2782 }
logVertex4iv(const GLint * v)2783 static void APIENTRY logVertex4iv(const GLint *v)
2784 {
2785 SIG( "glVertex4iv" );
2786 dllVertex4iv( v );
2787 }
logVertex4s(GLshort x,GLshort y,GLshort z,GLshort w)2788 static void APIENTRY logVertex4s(GLshort x, GLshort y, GLshort z, GLshort w)
2789 {
2790 SIG( "glVertex4s" );
2791 dllVertex4s( x, y, z, w );
2792 }
logVertex4sv(const GLshort * v)2793 static void APIENTRY logVertex4sv(const GLshort *v)
2794 {
2795 SIG( "glVertex4sv" );
2796 dllVertex4sv( v );
2797 }
logVertexPointer(GLint size,GLenum type,GLsizei stride,const void * pointer)2798 static void APIENTRY logVertexPointer(GLint size, GLenum type, GLsizei stride, const void *pointer)
2799 {
2800 fprintf( glw_state.log_fp, "glVertexPointer( %d, %s, %d, MEM )\n", size, TypeToString( type ), stride );
2801 dllVertexPointer( size, type, stride, pointer );
2802 }
logViewport(GLint x,GLint y,GLsizei width,GLsizei height)2803 static void APIENTRY logViewport(GLint x, GLint y, GLsizei width, GLsizei height)
2804 {
2805 fprintf( glw_state.log_fp, "glViewport( %d, %d, %d, %d )\n", x, y, width, height );
2806 dllViewport( x, y, width, height );
2807 }
2808
2809 /*
2810 ** QGL_Shutdown
2811 **
2812 ** Unloads the specified DLL then nulls out all the proc pointers. This
2813 ** is only called during a hard shutdown of the OGL subsystem (e.g. vid_restart).
2814 */
QGL_Shutdown(void)2815 void QGL_Shutdown( void )
2816 {
2817 ri.Printf( PRINT_ALL, "...shutting down QGL\n" );
2818
2819 if ( glw_state.hinstOpenGL )
2820 {
2821 ri.Printf( PRINT_ALL, "...unloading OpenGL DLL\n" );
2822 FreeLibrary( glw_state.hinstOpenGL );
2823 }
2824
2825 glw_state.hinstOpenGL = NULL;
2826
2827 qglAccum = NULL;
2828 qglAlphaFunc = NULL;
2829 qglAreTexturesResident = NULL;
2830 qglArrayElement = NULL;
2831 qglBegin = NULL;
2832 qglBindTexture = NULL;
2833 qglBitmap = NULL;
2834 qglBlendFunc = NULL;
2835 qglCallList = NULL;
2836 qglCallLists = NULL;
2837 qglClear = NULL;
2838 qglClearAccum = NULL;
2839 qglClearColor = NULL;
2840 qglClearDepth = NULL;
2841 qglClearIndex = NULL;
2842 qglClearStencil = NULL;
2843 qglClipPlane = NULL;
2844 qglColor3b = NULL;
2845 qglColor3bv = NULL;
2846 qglColor3d = NULL;
2847 qglColor3dv = NULL;
2848 qglColor3f = NULL;
2849 qglColor3fv = NULL;
2850 qglColor3i = NULL;
2851 qglColor3iv = NULL;
2852 qglColor3s = NULL;
2853 qglColor3sv = NULL;
2854 qglColor3ub = NULL;
2855 qglColor3ubv = NULL;
2856 qglColor3ui = NULL;
2857 qglColor3uiv = NULL;
2858 qglColor3us = NULL;
2859 qglColor3usv = NULL;
2860 qglColor4b = NULL;
2861 qglColor4bv = NULL;
2862 qglColor4d = NULL;
2863 qglColor4dv = NULL;
2864 qglColor4f = NULL;
2865 qglColor4fv = NULL;
2866 qglColor4i = NULL;
2867 qglColor4iv = NULL;
2868 qglColor4s = NULL;
2869 qglColor4sv = NULL;
2870 qglColor4ub = NULL;
2871 qglColor4ubv = NULL;
2872 qglColor4ui = NULL;
2873 qglColor4uiv = NULL;
2874 qglColor4us = NULL;
2875 qglColor4usv = NULL;
2876 qglColorMask = NULL;
2877 qglColorMaterial = NULL;
2878 qglColorPointer = NULL;
2879 qglCopyPixels = NULL;
2880 qglCopyTexImage1D = NULL;
2881 qglCopyTexImage2D = NULL;
2882 qglCopyTexSubImage1D = NULL;
2883 qglCopyTexSubImage2D = NULL;
2884 qglCullFace = NULL;
2885 qglDeleteLists = NULL;
2886 qglDeleteTextures = NULL;
2887 qglDepthFunc = NULL;
2888 qglDepthMask = NULL;
2889 qglDepthRange = NULL;
2890 qglDisable = NULL;
2891 qglDisableClientState = NULL;
2892 qglDrawArrays = NULL;
2893 qglDrawBuffer = NULL;
2894 qglDrawElements = NULL;
2895 qglDrawPixels = NULL;
2896 qglEdgeFlag = NULL;
2897 qglEdgeFlagPointer = NULL;
2898 qglEdgeFlagv = NULL;
2899 qglEnable = NULL;
2900 qglEnableClientState = NULL;
2901 qglEnd = NULL;
2902 qglEndList = NULL;
2903 qglEvalCoord1d = NULL;
2904 qglEvalCoord1dv = NULL;
2905 qglEvalCoord1f = NULL;
2906 qglEvalCoord1fv = NULL;
2907 qglEvalCoord2d = NULL;
2908 qglEvalCoord2dv = NULL;
2909 qglEvalCoord2f = NULL;
2910 qglEvalCoord2fv = NULL;
2911 qglEvalMesh1 = NULL;
2912 qglEvalMesh2 = NULL;
2913 qglEvalPoint1 = NULL;
2914 qglEvalPoint2 = NULL;
2915 qglFeedbackBuffer = NULL;
2916 qglFinish = NULL;
2917 qglFlush = NULL;
2918 qglFogf = NULL;
2919 qglFogfv = NULL;
2920 qglFogi = NULL;
2921 qglFogiv = NULL;
2922 qglFrontFace = NULL;
2923 qglFrustum = NULL;
2924 qglGenLists = NULL;
2925 qglGenTextures = NULL;
2926 qglGetBooleanv = NULL;
2927 qglGetClipPlane = NULL;
2928 qglGetDoublev = NULL;
2929 qglGetError = NULL;
2930 qglGetFloatv = NULL;
2931 qglGetIntegerv = NULL;
2932 qglGetLightfv = NULL;
2933 qglGetLightiv = NULL;
2934 qglGetMapdv = NULL;
2935 qglGetMapfv = NULL;
2936 qglGetMapiv = NULL;
2937 qglGetMaterialfv = NULL;
2938 qglGetMaterialiv = NULL;
2939 qglGetPixelMapfv = NULL;
2940 qglGetPixelMapuiv = NULL;
2941 qglGetPixelMapusv = NULL;
2942 qglGetPointerv = NULL;
2943 qglGetPolygonStipple = NULL;
2944 qglGetString = NULL;
2945 qglGetTexEnvfv = NULL;
2946 qglGetTexEnviv = NULL;
2947 qglGetTexGendv = NULL;
2948 qglGetTexGenfv = NULL;
2949 qglGetTexGeniv = NULL;
2950 qglGetTexImage = NULL;
2951 qglGetTexLevelParameterfv = NULL;
2952 qglGetTexLevelParameteriv = NULL;
2953 qglGetTexParameterfv = NULL;
2954 qglGetTexParameteriv = NULL;
2955 qglHint = NULL;
2956 qglIndexMask = NULL;
2957 qglIndexPointer = NULL;
2958 qglIndexd = NULL;
2959 qglIndexdv = NULL;
2960 qglIndexf = NULL;
2961 qglIndexfv = NULL;
2962 qglIndexi = NULL;
2963 qglIndexiv = NULL;
2964 qglIndexs = NULL;
2965 qglIndexsv = NULL;
2966 qglIndexub = NULL;
2967 qglIndexubv = NULL;
2968 qglInitNames = NULL;
2969 qglInterleavedArrays = NULL;
2970 qglIsEnabled = NULL;
2971 qglIsList = NULL;
2972 qglIsTexture = NULL;
2973 qglLightModelf = NULL;
2974 qglLightModelfv = NULL;
2975 qglLightModeli = NULL;
2976 qglLightModeliv = NULL;
2977 qglLightf = NULL;
2978 qglLightfv = NULL;
2979 qglLighti = NULL;
2980 qglLightiv = NULL;
2981 qglLineStipple = NULL;
2982 qglLineWidth = NULL;
2983 qglListBase = NULL;
2984 qglLoadIdentity = NULL;
2985 qglLoadMatrixd = NULL;
2986 qglLoadMatrixf = NULL;
2987 qglLoadName = NULL;
2988 qglLogicOp = NULL;
2989 qglMap1d = NULL;
2990 qglMap1f = NULL;
2991 qglMap2d = NULL;
2992 qglMap2f = NULL;
2993 qglMapGrid1d = NULL;
2994 qglMapGrid1f = NULL;
2995 qglMapGrid2d = NULL;
2996 qglMapGrid2f = NULL;
2997 qglMaterialf = NULL;
2998 qglMaterialfv = NULL;
2999 qglMateriali = NULL;
3000 qglMaterialiv = NULL;
3001 qglMatrixMode = NULL;
3002 qglMultMatrixd = NULL;
3003 qglMultMatrixf = NULL;
3004 qglNewList = NULL;
3005 qglNormal3b = NULL;
3006 qglNormal3bv = NULL;
3007 qglNormal3d = NULL;
3008 qglNormal3dv = NULL;
3009 qglNormal3f = NULL;
3010 qglNormal3fv = NULL;
3011 qglNormal3i = NULL;
3012 qglNormal3iv = NULL;
3013 qglNormal3s = NULL;
3014 qglNormal3sv = NULL;
3015 qglNormalPointer = NULL;
3016 qglOrtho = NULL;
3017 qglPassThrough = NULL;
3018 qglPixelMapfv = NULL;
3019 qglPixelMapuiv = NULL;
3020 qglPixelMapusv = NULL;
3021 qglPixelStoref = NULL;
3022 qglPixelStorei = NULL;
3023 qglPixelTransferf = NULL;
3024 qglPixelTransferi = NULL;
3025 qglPixelZoom = NULL;
3026 qglPointSize = NULL;
3027 qglPolygonMode = NULL;
3028 qglPolygonOffset = NULL;
3029 qglPolygonStipple = NULL;
3030 qglPopAttrib = NULL;
3031 qglPopClientAttrib = NULL;
3032 qglPopMatrix = NULL;
3033 qglPopName = NULL;
3034 qglPrioritizeTextures = NULL;
3035 qglPushAttrib = NULL;
3036 qglPushClientAttrib = NULL;
3037 qglPushMatrix = NULL;
3038 qglPushName = NULL;
3039 qglRasterPos2d = NULL;
3040 qglRasterPos2dv = NULL;
3041 qglRasterPos2f = NULL;
3042 qglRasterPos2fv = NULL;
3043 qglRasterPos2i = NULL;
3044 qglRasterPos2iv = NULL;
3045 qglRasterPos2s = NULL;
3046 qglRasterPos2sv = NULL;
3047 qglRasterPos3d = NULL;
3048 qglRasterPos3dv = NULL;
3049 qglRasterPos3f = NULL;
3050 qglRasterPos3fv = NULL;
3051 qglRasterPos3i = NULL;
3052 qglRasterPos3iv = NULL;
3053 qglRasterPos3s = NULL;
3054 qglRasterPos3sv = NULL;
3055 qglRasterPos4d = NULL;
3056 qglRasterPos4dv = NULL;
3057 qglRasterPos4f = NULL;
3058 qglRasterPos4fv = NULL;
3059 qglRasterPos4i = NULL;
3060 qglRasterPos4iv = NULL;
3061 qglRasterPos4s = NULL;
3062 qglRasterPos4sv = NULL;
3063 qglReadBuffer = NULL;
3064 qglReadPixels = NULL;
3065 qglRectd = NULL;
3066 qglRectdv = NULL;
3067 qglRectf = NULL;
3068 qglRectfv = NULL;
3069 qglRecti = NULL;
3070 qglRectiv = NULL;
3071 qglRects = NULL;
3072 qglRectsv = NULL;
3073 qglRenderMode = NULL;
3074 qglRotated = NULL;
3075 qglRotatef = NULL;
3076 qglScaled = NULL;
3077 qglScalef = NULL;
3078 qglScissor = NULL;
3079 qglSelectBuffer = NULL;
3080 qglShadeModel = NULL;
3081 qglStencilFunc = NULL;
3082 qglStencilMask = NULL;
3083 qglStencilOp = NULL;
3084 qglTexCoord1d = NULL;
3085 qglTexCoord1dv = NULL;
3086 qglTexCoord1f = NULL;
3087 qglTexCoord1fv = NULL;
3088 qglTexCoord1i = NULL;
3089 qglTexCoord1iv = NULL;
3090 qglTexCoord1s = NULL;
3091 qglTexCoord1sv = NULL;
3092 qglTexCoord2d = NULL;
3093 qglTexCoord2dv = NULL;
3094 qglTexCoord2f = NULL;
3095 qglTexCoord2fv = NULL;
3096 qglTexCoord2i = NULL;
3097 qglTexCoord2iv = NULL;
3098 qglTexCoord2s = NULL;
3099 qglTexCoord2sv = NULL;
3100 qglTexCoord3d = NULL;
3101 qglTexCoord3dv = NULL;
3102 qglTexCoord3f = NULL;
3103 qglTexCoord3fv = NULL;
3104 qglTexCoord3i = NULL;
3105 qglTexCoord3iv = NULL;
3106 qglTexCoord3s = NULL;
3107 qglTexCoord3sv = NULL;
3108 qglTexCoord4d = NULL;
3109 qglTexCoord4dv = NULL;
3110 qglTexCoord4f = NULL;
3111 qglTexCoord4fv = NULL;
3112 qglTexCoord4i = NULL;
3113 qglTexCoord4iv = NULL;
3114 qglTexCoord4s = NULL;
3115 qglTexCoord4sv = NULL;
3116 qglTexCoordPointer = NULL;
3117 qglTexEnvf = NULL;
3118 qglTexEnvfv = NULL;
3119 qglTexEnvi = NULL;
3120 qglTexEnviv = NULL;
3121 qglTexGend = NULL;
3122 qglTexGendv = NULL;
3123 qglTexGenf = NULL;
3124 qglTexGenfv = NULL;
3125 qglTexGeni = NULL;
3126 qglTexGeniv = NULL;
3127 qglTexImage1D = NULL;
3128 qglTexImage2D = NULL;
3129 qglTexParameterf = NULL;
3130 qglTexParameterfv = NULL;
3131 qglTexParameteri = NULL;
3132 qglTexParameteriv = NULL;
3133 qglTexSubImage1D = NULL;
3134 qglTexSubImage2D = NULL;
3135 qglTranslated = NULL;
3136 qglTranslatef = NULL;
3137 qglVertex2d = NULL;
3138 qglVertex2dv = NULL;
3139 qglVertex2f = NULL;
3140 qglVertex2fv = NULL;
3141 qglVertex2i = NULL;
3142 qglVertex2iv = NULL;
3143 qglVertex2s = NULL;
3144 qglVertex2sv = NULL;
3145 qglVertex3d = NULL;
3146 qglVertex3dv = NULL;
3147 qglVertex3f = NULL;
3148 qglVertex3fv = NULL;
3149 qglVertex3i = NULL;
3150 qglVertex3iv = NULL;
3151 qglVertex3s = NULL;
3152 qglVertex3sv = NULL;
3153 qglVertex4d = NULL;
3154 qglVertex4dv = NULL;
3155 qglVertex4f = NULL;
3156 qglVertex4fv = NULL;
3157 qglVertex4i = NULL;
3158 qglVertex4iv = NULL;
3159 qglVertex4s = NULL;
3160 qglVertex4sv = NULL;
3161 qglVertexPointer = NULL;
3162 qglViewport = NULL;
3163
3164 qwglCopyContext = NULL;
3165 qwglCreateContext = NULL;
3166 qwglCreateLayerContext = NULL;
3167 qwglDeleteContext = NULL;
3168 qwglDescribeLayerPlane = NULL;
3169 qwglGetCurrentContext = NULL;
3170 qwglGetCurrentDC = NULL;
3171 qwglGetLayerPaletteEntries = NULL;
3172 qwglGetProcAddress = NULL;
3173 qwglMakeCurrent = NULL;
3174 qwglRealizeLayerPalette = NULL;
3175 qwglSetLayerPaletteEntries = NULL;
3176 qwglShareLists = NULL;
3177 qwglSwapLayerBuffers = NULL;
3178 qwglUseFontBitmaps = NULL;
3179 qwglUseFontOutlines = NULL;
3180
3181 qwglChoosePixelFormat = NULL;
3182 qwglDescribePixelFormat = NULL;
3183 qwglGetPixelFormat = NULL;
3184 qwglSetPixelFormat = NULL;
3185 qwglSwapBuffers = NULL;
3186 }
3187
3188 #define GR_NUM_BOARDS 0x0f
3189
GlideIsValid(void)3190 static qboolean GlideIsValid( void )
3191 {
3192 HMODULE hGlide;
3193 // int numBoards;
3194 // void (__stdcall *grGet)(unsigned int, unsigned int, int*);
3195
3196 if ( ( hGlide = LoadLibrary("Glide3X") ) != 0 )
3197 {
3198 // FIXME: 3Dfx needs to fix this shit
3199 return qtrue;
3200
3201 #if 0
3202 grGet = (void *)GetProcAddress( hGlide, "_grGet@12");
3203
3204 if ( grGet )
3205 {
3206 grGet( GR_NUM_BOARDS, sizeof(int), &numBoards);
3207 }
3208 else
3209 {
3210 // if we've reached this point, something is seriously wrong
3211 ri.Printf( PRINT_WARNING, "WARNING: could not find grGet in GLIDE3X.DLL\n" );
3212 numBoards = 0;
3213 }
3214
3215 FreeLibrary( hGlide );
3216 hGlide = NULL;
3217
3218 if ( numBoards > 0 )
3219 {
3220 return qtrue;
3221 }
3222
3223 ri.Printf( PRINT_WARNING, "WARNING: invalid Glide installation!\n" );
3224 #endif
3225 }
3226
3227 return qfalse;
3228 }
3229
3230 #ifdef _MSC_VER
3231 # pragma warning (disable : 4113 4133 4047 )
3232 # define GPA( a ) GetProcAddress( glw_state.hinstOpenGL, a )
3233 #else
3234 # define GPA( a ) (void *)GetProcAddress( glw_state.hinstOpenGL, a )
3235 #endif
3236
3237 /*
3238 ** QGL_Init
3239 **
3240 ** This is responsible for binding our qgl function pointers to
3241 ** the appropriate GL stuff. In Windows this means doing a
3242 ** LoadLibrary and a bunch of calls to GetProcAddress. On other
3243 ** operating systems we need to do the right thing, whatever that
3244 ** might be.
3245 */
QGL_Init(const char * dllname)3246 qboolean QGL_Init( const char *dllname )
3247 {
3248 char systemDir[1024];
3249 char libName[1024];
3250
3251 GetSystemDirectory( systemDir, sizeof( systemDir ) );
3252
3253 assert( glw_state.hinstOpenGL == 0 );
3254
3255 ri.Printf( PRINT_ALL, "...initializing QGL\n" );
3256
3257 // NOTE: this assumes that 'dllname' is lower case (and it should be)!
3258 if ( strstr( dllname, _3DFX_DRIVER_NAME ) )
3259 {
3260 if ( !GlideIsValid() )
3261 {
3262 ri.Printf( PRINT_ALL, "...WARNING: missing Glide installation, assuming no 3Dfx available\n" );
3263 return qfalse;
3264 }
3265 }
3266
3267 if ( dllname[0] != '!' )
3268 {
3269 Com_sprintf( libName, sizeof( libName ), "%s\\%s", systemDir, dllname );
3270 }
3271 else
3272 {
3273 Q_strncpyz( libName, dllname, sizeof( libName ) );
3274 }
3275
3276 ri.Printf( PRINT_ALL, "...calling LoadLibrary( '%s.dll' ): ", libName );
3277
3278 if ( ( glw_state.hinstOpenGL = LoadLibrary( dllname ) ) == 0 )
3279 {
3280 ri.Printf( PRINT_ALL, "failed\n" );
3281 return qfalse;
3282 }
3283 ri.Printf( PRINT_ALL, "succeeded\n" );
3284
3285 qglAccum = dllAccum = GPA( "glAccum" );
3286 qglAlphaFunc = dllAlphaFunc = GPA( "glAlphaFunc" );
3287 qglAreTexturesResident = dllAreTexturesResident = GPA( "glAreTexturesResident" );
3288 qglArrayElement = dllArrayElement = GPA( "glArrayElement" );
3289 qglBegin = dllBegin = GPA( "glBegin" );
3290 qglBindTexture = dllBindTexture = GPA( "glBindTexture" );
3291 qglBitmap = dllBitmap = GPA( "glBitmap" );
3292 qglBlendFunc = dllBlendFunc = GPA( "glBlendFunc" );
3293 qglCallList = dllCallList = GPA( "glCallList" );
3294 qglCallLists = dllCallLists = GPA( "glCallLists" );
3295 qglClear = dllClear = GPA( "glClear" );
3296 qglClearAccum = dllClearAccum = GPA( "glClearAccum" );
3297 qglClearColor = dllClearColor = GPA( "glClearColor" );
3298 qglClearDepth = dllClearDepth = GPA( "glClearDepth" );
3299 qglClearIndex = dllClearIndex = GPA( "glClearIndex" );
3300 qglClearStencil = dllClearStencil = GPA( "glClearStencil" );
3301 qglClipPlane = dllClipPlane = GPA( "glClipPlane" );
3302 qglColor3b = dllColor3b = GPA( "glColor3b" );
3303 qglColor3bv = dllColor3bv = GPA( "glColor3bv" );
3304 qglColor3d = dllColor3d = GPA( "glColor3d" );
3305 qglColor3dv = dllColor3dv = GPA( "glColor3dv" );
3306 qglColor3f = dllColor3f = GPA( "glColor3f" );
3307 qglColor3fv = dllColor3fv = GPA( "glColor3fv" );
3308 qglColor3i = dllColor3i = GPA( "glColor3i" );
3309 qglColor3iv = dllColor3iv = GPA( "glColor3iv" );
3310 qglColor3s = dllColor3s = GPA( "glColor3s" );
3311 qglColor3sv = dllColor3sv = GPA( "glColor3sv" );
3312 qglColor3ub = dllColor3ub = GPA( "glColor3ub" );
3313 qglColor3ubv = dllColor3ubv = GPA( "glColor3ubv" );
3314 qglColor3ui = dllColor3ui = GPA( "glColor3ui" );
3315 qglColor3uiv = dllColor3uiv = GPA( "glColor3uiv" );
3316 qglColor3us = dllColor3us = GPA( "glColor3us" );
3317 qglColor3usv = dllColor3usv = GPA( "glColor3usv" );
3318 qglColor4b = dllColor4b = GPA( "glColor4b" );
3319 qglColor4bv = dllColor4bv = GPA( "glColor4bv" );
3320 qglColor4d = dllColor4d = GPA( "glColor4d" );
3321 qglColor4dv = dllColor4dv = GPA( "glColor4dv" );
3322 qglColor4f = dllColor4f = GPA( "glColor4f" );
3323 qglColor4fv = dllColor4fv = GPA( "glColor4fv" );
3324 qglColor4i = dllColor4i = GPA( "glColor4i" );
3325 qglColor4iv = dllColor4iv = GPA( "glColor4iv" );
3326 qglColor4s = dllColor4s = GPA( "glColor4s" );
3327 qglColor4sv = dllColor4sv = GPA( "glColor4sv" );
3328 qglColor4ub = dllColor4ub = GPA( "glColor4ub" );
3329 qglColor4ubv = dllColor4ubv = GPA( "glColor4ubv" );
3330 qglColor4ui = dllColor4ui = GPA( "glColor4ui" );
3331 qglColor4uiv = dllColor4uiv = GPA( "glColor4uiv" );
3332 qglColor4us = dllColor4us = GPA( "glColor4us" );
3333 qglColor4usv = dllColor4usv = GPA( "glColor4usv" );
3334 qglColorMask = dllColorMask = GPA( "glColorMask" );
3335 qglColorMaterial = dllColorMaterial = GPA( "glColorMaterial" );
3336 qglColorPointer = dllColorPointer = GPA( "glColorPointer" );
3337 qglCopyPixels = dllCopyPixels = GPA( "glCopyPixels" );
3338 qglCopyTexImage1D = dllCopyTexImage1D = GPA( "glCopyTexImage1D" );
3339 qglCopyTexImage2D = dllCopyTexImage2D = GPA( "glCopyTexImage2D" );
3340 qglCopyTexSubImage1D = dllCopyTexSubImage1D = GPA( "glCopyTexSubImage1D" );
3341 qglCopyTexSubImage2D = dllCopyTexSubImage2D = GPA( "glCopyTexSubImage2D" );
3342 qglCullFace = dllCullFace = GPA( "glCullFace" );
3343 qglDeleteLists = dllDeleteLists = GPA( "glDeleteLists" );
3344 qglDeleteTextures = dllDeleteTextures = GPA( "glDeleteTextures" );
3345 qglDepthFunc = dllDepthFunc = GPA( "glDepthFunc" );
3346 qglDepthMask = dllDepthMask = GPA( "glDepthMask" );
3347 qglDepthRange = dllDepthRange = GPA( "glDepthRange" );
3348 qglDisable = dllDisable = GPA( "glDisable" );
3349 qglDisableClientState = dllDisableClientState = GPA( "glDisableClientState" );
3350 qglDrawArrays = dllDrawArrays = GPA( "glDrawArrays" );
3351 qglDrawBuffer = dllDrawBuffer = GPA( "glDrawBuffer" );
3352 qglDrawElements = dllDrawElements = GPA( "glDrawElements" );
3353 qglDrawPixels = dllDrawPixels = GPA( "glDrawPixels" );
3354 qglEdgeFlag = dllEdgeFlag = GPA( "glEdgeFlag" );
3355 qglEdgeFlagPointer = dllEdgeFlagPointer = GPA( "glEdgeFlagPointer" );
3356 qglEdgeFlagv = dllEdgeFlagv = GPA( "glEdgeFlagv" );
3357 qglEnable = dllEnable = GPA( "glEnable" );
3358 qglEnableClientState = dllEnableClientState = GPA( "glEnableClientState" );
3359 qglEnd = dllEnd = GPA( "glEnd" );
3360 qglEndList = dllEndList = GPA( "glEndList" );
3361 qglEvalCoord1d = dllEvalCoord1d = GPA( "glEvalCoord1d" );
3362 qglEvalCoord1dv = dllEvalCoord1dv = GPA( "glEvalCoord1dv" );
3363 qglEvalCoord1f = dllEvalCoord1f = GPA( "glEvalCoord1f" );
3364 qglEvalCoord1fv = dllEvalCoord1fv = GPA( "glEvalCoord1fv" );
3365 qglEvalCoord2d = dllEvalCoord2d = GPA( "glEvalCoord2d" );
3366 qglEvalCoord2dv = dllEvalCoord2dv = GPA( "glEvalCoord2dv" );
3367 qglEvalCoord2f = dllEvalCoord2f = GPA( "glEvalCoord2f" );
3368 qglEvalCoord2fv = dllEvalCoord2fv = GPA( "glEvalCoord2fv" );
3369 qglEvalMesh1 = dllEvalMesh1 = GPA( "glEvalMesh1" );
3370 qglEvalMesh2 = dllEvalMesh2 = GPA( "glEvalMesh2" );
3371 qglEvalPoint1 = dllEvalPoint1 = GPA( "glEvalPoint1" );
3372 qglEvalPoint2 = dllEvalPoint2 = GPA( "glEvalPoint2" );
3373 qglFeedbackBuffer = dllFeedbackBuffer = GPA( "glFeedbackBuffer" );
3374 qglFinish = dllFinish = GPA( "glFinish" );
3375 qglFlush = dllFlush = GPA( "glFlush" );
3376 qglFogf = dllFogf = GPA( "glFogf" );
3377 qglFogfv = dllFogfv = GPA( "glFogfv" );
3378 qglFogi = dllFogi = GPA( "glFogi" );
3379 qglFogiv = dllFogiv = GPA( "glFogiv" );
3380 qglFrontFace = dllFrontFace = GPA( "glFrontFace" );
3381 qglFrustum = dllFrustum = GPA( "glFrustum" );
3382 qglGenLists = dllGenLists = ( GLuint (__stdcall * )(int) ) GPA( "glGenLists" );
3383 qglGenTextures = dllGenTextures = GPA( "glGenTextures" );
3384 qglGetBooleanv = dllGetBooleanv = GPA( "glGetBooleanv" );
3385 qglGetClipPlane = dllGetClipPlane = GPA( "glGetClipPlane" );
3386 qglGetDoublev = dllGetDoublev = GPA( "glGetDoublev" );
3387 qglGetError = dllGetError = ( GLenum (__stdcall * )(void) ) GPA( "glGetError" );
3388 qglGetFloatv = dllGetFloatv = GPA( "glGetFloatv" );
3389 qglGetIntegerv = dllGetIntegerv = GPA( "glGetIntegerv" );
3390 qglGetLightfv = dllGetLightfv = GPA( "glGetLightfv" );
3391 qglGetLightiv = dllGetLightiv = GPA( "glGetLightiv" );
3392 qglGetMapdv = dllGetMapdv = GPA( "glGetMapdv" );
3393 qglGetMapfv = dllGetMapfv = GPA( "glGetMapfv" );
3394 qglGetMapiv = dllGetMapiv = GPA( "glGetMapiv" );
3395 qglGetMaterialfv = dllGetMaterialfv = GPA( "glGetMaterialfv" );
3396 qglGetMaterialiv = dllGetMaterialiv = GPA( "glGetMaterialiv" );
3397 qglGetPixelMapfv = dllGetPixelMapfv = GPA( "glGetPixelMapfv" );
3398 qglGetPixelMapuiv = dllGetPixelMapuiv = GPA( "glGetPixelMapuiv" );
3399 qglGetPixelMapusv = dllGetPixelMapusv = GPA( "glGetPixelMapusv" );
3400 qglGetPointerv = dllGetPointerv = GPA( "glGetPointerv" );
3401 qglGetPolygonStipple = dllGetPolygonStipple = GPA( "glGetPolygonStipple" );
3402 qglGetString = dllGetString = GPA( "glGetString" );
3403 qglGetTexEnvfv = dllGetTexEnvfv = GPA( "glGetTexEnvfv" );
3404 qglGetTexEnviv = dllGetTexEnviv = GPA( "glGetTexEnviv" );
3405 qglGetTexGendv = dllGetTexGendv = GPA( "glGetTexGendv" );
3406 qglGetTexGenfv = dllGetTexGenfv = GPA( "glGetTexGenfv" );
3407 qglGetTexGeniv = dllGetTexGeniv = GPA( "glGetTexGeniv" );
3408 qglGetTexImage = dllGetTexImage = GPA( "glGetTexImage" );
3409 qglGetTexParameterfv = dllGetTexParameterfv = GPA( "glGetTexParameterfv" );
3410 qglGetTexParameteriv = dllGetTexParameteriv = GPA( "glGetTexParameteriv" );
3411 qglHint = dllHint = GPA( "glHint" );
3412 qglIndexMask = dllIndexMask = GPA( "glIndexMask" );
3413 qglIndexPointer = dllIndexPointer = GPA( "glIndexPointer" );
3414 qglIndexd = dllIndexd = GPA( "glIndexd" );
3415 qglIndexdv = dllIndexdv = GPA( "glIndexdv" );
3416 qglIndexf = dllIndexf = GPA( "glIndexf" );
3417 qglIndexfv = dllIndexfv = GPA( "glIndexfv" );
3418 qglIndexi = dllIndexi = GPA( "glIndexi" );
3419 qglIndexiv = dllIndexiv = GPA( "glIndexiv" );
3420 qglIndexs = dllIndexs = GPA( "glIndexs" );
3421 qglIndexsv = dllIndexsv = GPA( "glIndexsv" );
3422 qglIndexub = dllIndexub = GPA( "glIndexub" );
3423 qglIndexubv = dllIndexubv = GPA( "glIndexubv" );
3424 qglInitNames = dllInitNames = GPA( "glInitNames" );
3425 qglInterleavedArrays = dllInterleavedArrays = GPA( "glInterleavedArrays" );
3426 qglIsEnabled = dllIsEnabled = GPA( "glIsEnabled" );
3427 qglIsList = dllIsList = GPA( "glIsList" );
3428 qglIsTexture = dllIsTexture = GPA( "glIsTexture" );
3429 qglLightModelf = dllLightModelf = GPA( "glLightModelf" );
3430 qglLightModelfv = dllLightModelfv = GPA( "glLightModelfv" );
3431 qglLightModeli = dllLightModeli = GPA( "glLightModeli" );
3432 qglLightModeliv = dllLightModeliv = GPA( "glLightModeliv" );
3433 qglLightf = dllLightf = GPA( "glLightf" );
3434 qglLightfv = dllLightfv = GPA( "glLightfv" );
3435 qglLighti = dllLighti = GPA( "glLighti" );
3436 qglLightiv = dllLightiv = GPA( "glLightiv" );
3437 qglLineStipple = dllLineStipple = GPA( "glLineStipple" );
3438 qglLineWidth = dllLineWidth = GPA( "glLineWidth" );
3439 qglListBase = dllListBase = GPA( "glListBase" );
3440 qglLoadIdentity = dllLoadIdentity = GPA( "glLoadIdentity" );
3441 qglLoadMatrixd = dllLoadMatrixd = GPA( "glLoadMatrixd" );
3442 qglLoadMatrixf = dllLoadMatrixf = GPA( "glLoadMatrixf" );
3443 qglLoadName = dllLoadName = GPA( "glLoadName" );
3444 qglLogicOp = dllLogicOp = GPA( "glLogicOp" );
3445 qglMap1d = dllMap1d = GPA( "glMap1d" );
3446 qglMap1f = dllMap1f = GPA( "glMap1f" );
3447 qglMap2d = dllMap2d = GPA( "glMap2d" );
3448 qglMap2f = dllMap2f = GPA( "glMap2f" );
3449 qglMapGrid1d = dllMapGrid1d = GPA( "glMapGrid1d" );
3450 qglMapGrid1f = dllMapGrid1f = GPA( "glMapGrid1f" );
3451 qglMapGrid2d = dllMapGrid2d = GPA( "glMapGrid2d" );
3452 qglMapGrid2f = dllMapGrid2f = GPA( "glMapGrid2f" );
3453 qglMaterialf = dllMaterialf = GPA( "glMaterialf" );
3454 qglMaterialfv = dllMaterialfv = GPA( "glMaterialfv" );
3455 qglMateriali = dllMateriali = GPA( "glMateriali" );
3456 qglMaterialiv = dllMaterialiv = GPA( "glMaterialiv" );
3457 qglMatrixMode = dllMatrixMode = GPA( "glMatrixMode" );
3458 qglMultMatrixd = dllMultMatrixd = GPA( "glMultMatrixd" );
3459 qglMultMatrixf = dllMultMatrixf = GPA( "glMultMatrixf" );
3460 qglNewList = dllNewList = GPA( "glNewList" );
3461 qglNormal3b = dllNormal3b = GPA( "glNormal3b" );
3462 qglNormal3bv = dllNormal3bv = GPA( "glNormal3bv" );
3463 qglNormal3d = dllNormal3d = GPA( "glNormal3d" );
3464 qglNormal3dv = dllNormal3dv = GPA( "glNormal3dv" );
3465 qglNormal3f = dllNormal3f = GPA( "glNormal3f" );
3466 qglNormal3fv = dllNormal3fv = GPA( "glNormal3fv" );
3467 qglNormal3i = dllNormal3i = GPA( "glNormal3i" );
3468 qglNormal3iv = dllNormal3iv = GPA( "glNormal3iv" );
3469 qglNormal3s = dllNormal3s = GPA( "glNormal3s" );
3470 qglNormal3sv = dllNormal3sv = GPA( "glNormal3sv" );
3471 qglNormalPointer = dllNormalPointer = GPA( "glNormalPointer" );
3472 qglOrtho = dllOrtho = GPA( "glOrtho" );
3473 qglPassThrough = dllPassThrough = GPA( "glPassThrough" );
3474 qglPixelMapfv = dllPixelMapfv = GPA( "glPixelMapfv" );
3475 qglPixelMapuiv = dllPixelMapuiv = GPA( "glPixelMapuiv" );
3476 qglPixelMapusv = dllPixelMapusv = GPA( "glPixelMapusv" );
3477 qglPixelStoref = dllPixelStoref = GPA( "glPixelStoref" );
3478 qglPixelStorei = dllPixelStorei = GPA( "glPixelStorei" );
3479 qglPixelTransferf = dllPixelTransferf = GPA( "glPixelTransferf" );
3480 qglPixelTransferi = dllPixelTransferi = GPA( "glPixelTransferi" );
3481 qglPixelZoom = dllPixelZoom = GPA( "glPixelZoom" );
3482 qglPointSize = dllPointSize = GPA( "glPointSize" );
3483 qglPolygonMode = dllPolygonMode = GPA( "glPolygonMode" );
3484 qglPolygonOffset = dllPolygonOffset = GPA( "glPolygonOffset" );
3485 qglPolygonStipple = dllPolygonStipple = GPA( "glPolygonStipple" );
3486 qglPopAttrib = dllPopAttrib = GPA( "glPopAttrib" );
3487 qglPopClientAttrib = dllPopClientAttrib = GPA( "glPopClientAttrib" );
3488 qglPopMatrix = dllPopMatrix = GPA( "glPopMatrix" );
3489 qglPopName = dllPopName = GPA( "glPopName" );
3490 qglPrioritizeTextures = dllPrioritizeTextures = GPA( "glPrioritizeTextures" );
3491 qglPushAttrib = dllPushAttrib = GPA( "glPushAttrib" );
3492 qglPushClientAttrib = dllPushClientAttrib = GPA( "glPushClientAttrib" );
3493 qglPushMatrix = dllPushMatrix = GPA( "glPushMatrix" );
3494 qglPushName = dllPushName = GPA( "glPushName" );
3495 qglRasterPos2d = dllRasterPos2d = GPA( "glRasterPos2d" );
3496 qglRasterPos2dv = dllRasterPos2dv = GPA( "glRasterPos2dv" );
3497 qglRasterPos2f = dllRasterPos2f = GPA( "glRasterPos2f" );
3498 qglRasterPos2fv = dllRasterPos2fv = GPA( "glRasterPos2fv" );
3499 qglRasterPos2i = dllRasterPos2i = GPA( "glRasterPos2i" );
3500 qglRasterPos2iv = dllRasterPos2iv = GPA( "glRasterPos2iv" );
3501 qglRasterPos2s = dllRasterPos2s = GPA( "glRasterPos2s" );
3502 qglRasterPos2sv = dllRasterPos2sv = GPA( "glRasterPos2sv" );
3503 qglRasterPos3d = dllRasterPos3d = GPA( "glRasterPos3d" );
3504 qglRasterPos3dv = dllRasterPos3dv = GPA( "glRasterPos3dv" );
3505 qglRasterPos3f = dllRasterPos3f = GPA( "glRasterPos3f" );
3506 qglRasterPos3fv = dllRasterPos3fv = GPA( "glRasterPos3fv" );
3507 qglRasterPos3i = dllRasterPos3i = GPA( "glRasterPos3i" );
3508 qglRasterPos3iv = dllRasterPos3iv = GPA( "glRasterPos3iv" );
3509 qglRasterPos3s = dllRasterPos3s = GPA( "glRasterPos3s" );
3510 qglRasterPos3sv = dllRasterPos3sv = GPA( "glRasterPos3sv" );
3511 qglRasterPos4d = dllRasterPos4d = GPA( "glRasterPos4d" );
3512 qglRasterPos4dv = dllRasterPos4dv = GPA( "glRasterPos4dv" );
3513 qglRasterPos4f = dllRasterPos4f = GPA( "glRasterPos4f" );
3514 qglRasterPos4fv = dllRasterPos4fv = GPA( "glRasterPos4fv" );
3515 qglRasterPos4i = dllRasterPos4i = GPA( "glRasterPos4i" );
3516 qglRasterPos4iv = dllRasterPos4iv = GPA( "glRasterPos4iv" );
3517 qglRasterPos4s = dllRasterPos4s = GPA( "glRasterPos4s" );
3518 qglRasterPos4sv = dllRasterPos4sv = GPA( "glRasterPos4sv" );
3519 qglReadBuffer = dllReadBuffer = GPA( "glReadBuffer" );
3520 qglReadPixels = dllReadPixels = GPA( "glReadPixels" );
3521 qglRectd = dllRectd = GPA( "glRectd" );
3522 qglRectdv = dllRectdv = GPA( "glRectdv" );
3523 qglRectf = dllRectf = GPA( "glRectf" );
3524 qglRectfv = dllRectfv = GPA( "glRectfv" );
3525 qglRecti = dllRecti = GPA( "glRecti" );
3526 qglRectiv = dllRectiv = GPA( "glRectiv" );
3527 qglRects = dllRects = GPA( "glRects" );
3528 qglRectsv = dllRectsv = GPA( "glRectsv" );
3529 qglRenderMode = dllRenderMode = GPA( "glRenderMode" );
3530 qglRotated = dllRotated = GPA( "glRotated" );
3531 qglRotatef = dllRotatef = GPA( "glRotatef" );
3532 qglScaled = dllScaled = GPA( "glScaled" );
3533 qglScalef = dllScalef = GPA( "glScalef" );
3534 qglScissor = dllScissor = GPA( "glScissor" );
3535 qglSelectBuffer = dllSelectBuffer = GPA( "glSelectBuffer" );
3536 qglShadeModel = dllShadeModel = GPA( "glShadeModel" );
3537 qglStencilFunc = dllStencilFunc = GPA( "glStencilFunc" );
3538 qglStencilMask = dllStencilMask = GPA( "glStencilMask" );
3539 qglStencilOp = dllStencilOp = GPA( "glStencilOp" );
3540 qglTexCoord1d = dllTexCoord1d = GPA( "glTexCoord1d" );
3541 qglTexCoord1dv = dllTexCoord1dv = GPA( "glTexCoord1dv" );
3542 qglTexCoord1f = dllTexCoord1f = GPA( "glTexCoord1f" );
3543 qglTexCoord1fv = dllTexCoord1fv = GPA( "glTexCoord1fv" );
3544 qglTexCoord1i = dllTexCoord1i = GPA( "glTexCoord1i" );
3545 qglTexCoord1iv = dllTexCoord1iv = GPA( "glTexCoord1iv" );
3546 qglTexCoord1s = dllTexCoord1s = GPA( "glTexCoord1s" );
3547 qglTexCoord1sv = dllTexCoord1sv = GPA( "glTexCoord1sv" );
3548 qglTexCoord2d = dllTexCoord2d = GPA( "glTexCoord2d" );
3549 qglTexCoord2dv = dllTexCoord2dv = GPA( "glTexCoord2dv" );
3550 qglTexCoord2f = dllTexCoord2f = GPA( "glTexCoord2f" );
3551 qglTexCoord2fv = dllTexCoord2fv = GPA( "glTexCoord2fv" );
3552 qglTexCoord2i = dllTexCoord2i = GPA( "glTexCoord2i" );
3553 qglTexCoord2iv = dllTexCoord2iv = GPA( "glTexCoord2iv" );
3554 qglTexCoord2s = dllTexCoord2s = GPA( "glTexCoord2s" );
3555 qglTexCoord2sv = dllTexCoord2sv = GPA( "glTexCoord2sv" );
3556 qglTexCoord3d = dllTexCoord3d = GPA( "glTexCoord3d" );
3557 qglTexCoord3dv = dllTexCoord3dv = GPA( "glTexCoord3dv" );
3558 qglTexCoord3f = dllTexCoord3f = GPA( "glTexCoord3f" );
3559 qglTexCoord3fv = dllTexCoord3fv = GPA( "glTexCoord3fv" );
3560 qglTexCoord3i = dllTexCoord3i = GPA( "glTexCoord3i" );
3561 qglTexCoord3iv = dllTexCoord3iv = GPA( "glTexCoord3iv" );
3562 qglTexCoord3s = dllTexCoord3s = GPA( "glTexCoord3s" );
3563 qglTexCoord3sv = dllTexCoord3sv = GPA( "glTexCoord3sv" );
3564 qglTexCoord4d = dllTexCoord4d = GPA( "glTexCoord4d" );
3565 qglTexCoord4dv = dllTexCoord4dv = GPA( "glTexCoord4dv" );
3566 qglTexCoord4f = dllTexCoord4f = GPA( "glTexCoord4f" );
3567 qglTexCoord4fv = dllTexCoord4fv = GPA( "glTexCoord4fv" );
3568 qglTexCoord4i = dllTexCoord4i = GPA( "glTexCoord4i" );
3569 qglTexCoord4iv = dllTexCoord4iv = GPA( "glTexCoord4iv" );
3570 qglTexCoord4s = dllTexCoord4s = GPA( "glTexCoord4s" );
3571 qglTexCoord4sv = dllTexCoord4sv = GPA( "glTexCoord4sv" );
3572 qglTexCoordPointer = dllTexCoordPointer = GPA( "glTexCoordPointer" );
3573 qglTexEnvf = dllTexEnvf = GPA( "glTexEnvf" );
3574 qglTexEnvfv = dllTexEnvfv = GPA( "glTexEnvfv" );
3575 qglTexEnvi = dllTexEnvi = GPA( "glTexEnvi" );
3576 qglTexEnviv = dllTexEnviv = GPA( "glTexEnviv" );
3577 qglTexGend = dllTexGend = GPA( "glTexGend" );
3578 qglTexGendv = dllTexGendv = GPA( "glTexGendv" );
3579 qglTexGenf = dllTexGenf = GPA( "glTexGenf" );
3580 qglTexGenfv = dllTexGenfv = GPA( "glTexGenfv" );
3581 qglTexGeni = dllTexGeni = GPA( "glTexGeni" );
3582 qglTexGeniv = dllTexGeniv = GPA( "glTexGeniv" );
3583 qglTexImage1D = dllTexImage1D = GPA( "glTexImage1D" );
3584 qglTexImage2D = dllTexImage2D = GPA( "glTexImage2D" );
3585 qglTexParameterf = dllTexParameterf = GPA( "glTexParameterf" );
3586 qglTexParameterfv = dllTexParameterfv = GPA( "glTexParameterfv" );
3587 qglTexParameteri = dllTexParameteri = GPA( "glTexParameteri" );
3588 qglTexParameteriv = dllTexParameteriv = GPA( "glTexParameteriv" );
3589 qglTexSubImage1D = dllTexSubImage1D = GPA( "glTexSubImage1D" );
3590 qglTexSubImage2D = dllTexSubImage2D = GPA( "glTexSubImage2D" );
3591 qglTranslated = dllTranslated = GPA( "glTranslated" );
3592 qglTranslatef = dllTranslatef = GPA( "glTranslatef" );
3593 qglVertex2d = dllVertex2d = GPA( "glVertex2d" );
3594 qglVertex2dv = dllVertex2dv = GPA( "glVertex2dv" );
3595 qglVertex2f = dllVertex2f = GPA( "glVertex2f" );
3596 qglVertex2fv = dllVertex2fv = GPA( "glVertex2fv" );
3597 qglVertex2i = dllVertex2i = GPA( "glVertex2i" );
3598 qglVertex2iv = dllVertex2iv = GPA( "glVertex2iv" );
3599 qglVertex2s = dllVertex2s = GPA( "glVertex2s" );
3600 qglVertex2sv = dllVertex2sv = GPA( "glVertex2sv" );
3601 qglVertex3d = dllVertex3d = GPA( "glVertex3d" );
3602 qglVertex3dv = dllVertex3dv = GPA( "glVertex3dv" );
3603 qglVertex3f = dllVertex3f = GPA( "glVertex3f" );
3604 qglVertex3fv = dllVertex3fv = GPA( "glVertex3fv" );
3605 qglVertex3i = dllVertex3i = GPA( "glVertex3i" );
3606 qglVertex3iv = dllVertex3iv = GPA( "glVertex3iv" );
3607 qglVertex3s = dllVertex3s = GPA( "glVertex3s" );
3608 qglVertex3sv = dllVertex3sv = GPA( "glVertex3sv" );
3609 qglVertex4d = dllVertex4d = GPA( "glVertex4d" );
3610 qglVertex4dv = dllVertex4dv = GPA( "glVertex4dv" );
3611 qglVertex4f = dllVertex4f = GPA( "glVertex4f" );
3612 qglVertex4fv = dllVertex4fv = GPA( "glVertex4fv" );
3613 qglVertex4i = dllVertex4i = GPA( "glVertex4i" );
3614 qglVertex4iv = dllVertex4iv = GPA( "glVertex4iv" );
3615 qglVertex4s = dllVertex4s = GPA( "glVertex4s" );
3616 qglVertex4sv = dllVertex4sv = GPA( "glVertex4sv" );
3617 qglVertexPointer = dllVertexPointer = GPA( "glVertexPointer" );
3618 qglViewport = dllViewport = GPA( "glViewport" );
3619
3620 qwglCopyContext = GPA( "wglCopyContext" );
3621 qwglCreateContext = GPA( "wglCreateContext" );
3622 qwglCreateLayerContext = GPA( "wglCreateLayerContext" );
3623 qwglDeleteContext = GPA( "wglDeleteContext" );
3624 qwglDescribeLayerPlane = GPA( "wglDescribeLayerPlane" );
3625 qwglGetCurrentContext = GPA( "wglGetCurrentContext" );
3626 qwglGetCurrentDC = GPA( "wglGetCurrentDC" );
3627 qwglGetLayerPaletteEntries = GPA( "wglGetLayerPaletteEntries" );
3628 qwglGetProcAddress = GPA( "wglGetProcAddress" );
3629 qwglMakeCurrent = GPA( "wglMakeCurrent" );
3630 qwglRealizeLayerPalette = GPA( "wglRealizeLayerPalette" );
3631 qwglSetLayerPaletteEntries = GPA( "wglSetLayerPaletteEntries" );
3632 qwglShareLists = GPA( "wglShareLists" );
3633 qwglSwapLayerBuffers = GPA( "wglSwapLayerBuffers" );
3634 qwglUseFontBitmaps = GPA( "wglUseFontBitmapsA" );
3635 qwglUseFontOutlines = GPA( "wglUseFontOutlinesA" );
3636
3637 qwglChoosePixelFormat = GPA( "wglChoosePixelFormat" );
3638 qwglDescribePixelFormat = GPA( "wglDescribePixelFormat" );
3639 qwglGetPixelFormat = GPA( "wglGetPixelFormat" );
3640 qwglSetPixelFormat = GPA( "wglSetPixelFormat" );
3641 qwglSwapBuffers = GPA( "wglSwapBuffers" );
3642
3643 qwglSwapIntervalEXT = 0;
3644 qglActiveTextureARB = 0;
3645 qglClientActiveTextureARB = 0;
3646 qglMultiTexCoord2fARB = 0;
3647 qglLockArraysEXT = 0;
3648 qglUnlockArraysEXT = 0;
3649 qwglGetDeviceGammaRamp3DFX = NULL;
3650 qwglSetDeviceGammaRamp3DFX = NULL;
3651
3652 // check logging
3653 QGL_EnableLogging( r_logFile->integer );
3654
3655 return qtrue;
3656 }
3657
QGL_EnableLogging(qboolean enable)3658 void QGL_EnableLogging( qboolean enable )
3659 {
3660 static qboolean isEnabled;
3661
3662 // return if we're already active
3663 if ( isEnabled && enable ) {
3664 // decrement log counter and stop if it has reached 0
3665 ri.Cvar_Set( "r_logFile", va("%d", r_logFile->integer - 1 ) );
3666 if ( r_logFile->integer ) {
3667 return;
3668 }
3669 enable = qfalse;
3670 }
3671
3672 // return if we're already disabled
3673 if ( !enable && !isEnabled )
3674 return;
3675
3676 isEnabled = enable;
3677
3678 if ( enable )
3679 {
3680 if ( !glw_state.log_fp )
3681 {
3682 struct tm *newtime;
3683 time_t aclock;
3684 char buffer[1024];
3685 cvar_t *basedir;
3686
3687 time( &aclock );
3688 newtime = localtime( &aclock );
3689
3690 asctime( newtime );
3691
3692 basedir = ri.Cvar_Get( "fs_basepath", "", 0 );
3693 Com_sprintf( buffer, sizeof(buffer), "%s/gl.log", basedir->string );
3694 glw_state.log_fp = fopen( buffer, "wt" );
3695
3696 fprintf( glw_state.log_fp, "%s\n", asctime( newtime ) );
3697 }
3698
3699 qglAccum = logAccum;
3700 qglAlphaFunc = logAlphaFunc;
3701 qglAreTexturesResident = logAreTexturesResident;
3702 qglArrayElement = logArrayElement;
3703 qglBegin = logBegin;
3704 qglBindTexture = logBindTexture;
3705 qglBitmap = logBitmap;
3706 qglBlendFunc = logBlendFunc;
3707 qglCallList = logCallList;
3708 qglCallLists = logCallLists;
3709 qglClear = logClear;
3710 qglClearAccum = logClearAccum;
3711 qglClearColor = logClearColor;
3712 qglClearDepth = logClearDepth;
3713 qglClearIndex = logClearIndex;
3714 qglClearStencil = logClearStencil;
3715 qglClipPlane = logClipPlane;
3716 qglColor3b = logColor3b;
3717 qglColor3bv = logColor3bv;
3718 qglColor3d = logColor3d;
3719 qglColor3dv = logColor3dv;
3720 qglColor3f = logColor3f;
3721 qglColor3fv = logColor3fv;
3722 qglColor3i = logColor3i;
3723 qglColor3iv = logColor3iv;
3724 qglColor3s = logColor3s;
3725 qglColor3sv = logColor3sv;
3726 qglColor3ub = logColor3ub;
3727 qglColor3ubv = logColor3ubv;
3728 qglColor3ui = logColor3ui;
3729 qglColor3uiv = logColor3uiv;
3730 qglColor3us = logColor3us;
3731 qglColor3usv = logColor3usv;
3732 qglColor4b = logColor4b;
3733 qglColor4bv = logColor4bv;
3734 qglColor4d = logColor4d;
3735 qglColor4dv = logColor4dv;
3736 qglColor4f = logColor4f;
3737 qglColor4fv = logColor4fv;
3738 qglColor4i = logColor4i;
3739 qglColor4iv = logColor4iv;
3740 qglColor4s = logColor4s;
3741 qglColor4sv = logColor4sv;
3742 qglColor4ub = logColor4ub;
3743 qglColor4ubv = logColor4ubv;
3744 qglColor4ui = logColor4ui;
3745 qglColor4uiv = logColor4uiv;
3746 qglColor4us = logColor4us;
3747 qglColor4usv = logColor4usv;
3748 qglColorMask = logColorMask;
3749 qglColorMaterial = logColorMaterial;
3750 qglColorPointer = logColorPointer;
3751 qglCopyPixels = logCopyPixels;
3752 qglCopyTexImage1D = logCopyTexImage1D;
3753 qglCopyTexImage2D = logCopyTexImage2D;
3754 qglCopyTexSubImage1D = logCopyTexSubImage1D;
3755 qglCopyTexSubImage2D = logCopyTexSubImage2D;
3756 qglCullFace = logCullFace;
3757 qglDeleteLists = logDeleteLists ;
3758 qglDeleteTextures = logDeleteTextures ;
3759 qglDepthFunc = logDepthFunc ;
3760 qglDepthMask = logDepthMask ;
3761 qglDepthRange = logDepthRange ;
3762 qglDisable = logDisable ;
3763 qglDisableClientState = logDisableClientState ;
3764 qglDrawArrays = logDrawArrays ;
3765 qglDrawBuffer = logDrawBuffer ;
3766 qglDrawElements = logDrawElements ;
3767 qglDrawPixels = logDrawPixels ;
3768 qglEdgeFlag = logEdgeFlag ;
3769 qglEdgeFlagPointer = logEdgeFlagPointer ;
3770 qglEdgeFlagv = logEdgeFlagv ;
3771 qglEnable = logEnable ;
3772 qglEnableClientState = logEnableClientState ;
3773 qglEnd = logEnd ;
3774 qglEndList = logEndList ;
3775 qglEvalCoord1d = logEvalCoord1d ;
3776 qglEvalCoord1dv = logEvalCoord1dv ;
3777 qglEvalCoord1f = logEvalCoord1f ;
3778 qglEvalCoord1fv = logEvalCoord1fv ;
3779 qglEvalCoord2d = logEvalCoord2d ;
3780 qglEvalCoord2dv = logEvalCoord2dv ;
3781 qglEvalCoord2f = logEvalCoord2f ;
3782 qglEvalCoord2fv = logEvalCoord2fv ;
3783 qglEvalMesh1 = logEvalMesh1 ;
3784 qglEvalMesh2 = logEvalMesh2 ;
3785 qglEvalPoint1 = logEvalPoint1 ;
3786 qglEvalPoint2 = logEvalPoint2 ;
3787 qglFeedbackBuffer = logFeedbackBuffer ;
3788 qglFinish = logFinish ;
3789 qglFlush = logFlush ;
3790 qglFogf = logFogf ;
3791 qglFogfv = logFogfv ;
3792 qglFogi = logFogi ;
3793 qglFogiv = logFogiv ;
3794 qglFrontFace = logFrontFace ;
3795 qglFrustum = logFrustum ;
3796 qglGenLists = logGenLists ;
3797 qglGenTextures = logGenTextures ;
3798 qglGetBooleanv = logGetBooleanv ;
3799 qglGetClipPlane = logGetClipPlane ;
3800 qglGetDoublev = logGetDoublev ;
3801 qglGetError = logGetError ;
3802 qglGetFloatv = logGetFloatv ;
3803 qglGetIntegerv = logGetIntegerv ;
3804 qglGetLightfv = logGetLightfv ;
3805 qglGetLightiv = logGetLightiv ;
3806 qglGetMapdv = logGetMapdv ;
3807 qglGetMapfv = logGetMapfv ;
3808 qglGetMapiv = logGetMapiv ;
3809 qglGetMaterialfv = logGetMaterialfv ;
3810 qglGetMaterialiv = logGetMaterialiv ;
3811 qglGetPixelMapfv = logGetPixelMapfv ;
3812 qglGetPixelMapuiv = logGetPixelMapuiv ;
3813 qglGetPixelMapusv = logGetPixelMapusv ;
3814 qglGetPointerv = logGetPointerv ;
3815 qglGetPolygonStipple = logGetPolygonStipple ;
3816 qglGetString = logGetString ;
3817 qglGetTexEnvfv = logGetTexEnvfv ;
3818 qglGetTexEnviv = logGetTexEnviv ;
3819 qglGetTexGendv = logGetTexGendv ;
3820 qglGetTexGenfv = logGetTexGenfv ;
3821 qglGetTexGeniv = logGetTexGeniv ;
3822 qglGetTexImage = logGetTexImage ;
3823 qglGetTexLevelParameterfv = logGetTexLevelParameterfv ;
3824 qglGetTexLevelParameteriv = logGetTexLevelParameteriv ;
3825 qglGetTexParameterfv = logGetTexParameterfv ;
3826 qglGetTexParameteriv = logGetTexParameteriv ;
3827 qglHint = logHint ;
3828 qglIndexMask = logIndexMask ;
3829 qglIndexPointer = logIndexPointer ;
3830 qglIndexd = logIndexd ;
3831 qglIndexdv = logIndexdv ;
3832 qglIndexf = logIndexf ;
3833 qglIndexfv = logIndexfv ;
3834 qglIndexi = logIndexi ;
3835 qglIndexiv = logIndexiv ;
3836 qglIndexs = logIndexs ;
3837 qglIndexsv = logIndexsv ;
3838 qglIndexub = logIndexub ;
3839 qglIndexubv = logIndexubv ;
3840 qglInitNames = logInitNames ;
3841 qglInterleavedArrays = logInterleavedArrays ;
3842 qglIsEnabled = logIsEnabled ;
3843 qglIsList = logIsList ;
3844 qglIsTexture = logIsTexture ;
3845 qglLightModelf = logLightModelf ;
3846 qglLightModelfv = logLightModelfv ;
3847 qglLightModeli = logLightModeli ;
3848 qglLightModeliv = logLightModeliv ;
3849 qglLightf = logLightf ;
3850 qglLightfv = logLightfv ;
3851 qglLighti = logLighti ;
3852 qglLightiv = logLightiv ;
3853 qglLineStipple = logLineStipple ;
3854 qglLineWidth = logLineWidth ;
3855 qglListBase = logListBase ;
3856 qglLoadIdentity = logLoadIdentity ;
3857 qglLoadMatrixd = logLoadMatrixd ;
3858 qglLoadMatrixf = logLoadMatrixf ;
3859 qglLoadName = logLoadName ;
3860 qglLogicOp = logLogicOp ;
3861 qglMap1d = logMap1d ;
3862 qglMap1f = logMap1f ;
3863 qglMap2d = logMap2d ;
3864 qglMap2f = logMap2f ;
3865 qglMapGrid1d = logMapGrid1d ;
3866 qglMapGrid1f = logMapGrid1f ;
3867 qglMapGrid2d = logMapGrid2d ;
3868 qglMapGrid2f = logMapGrid2f ;
3869 qglMaterialf = logMaterialf ;
3870 qglMaterialfv = logMaterialfv ;
3871 qglMateriali = logMateriali ;
3872 qglMaterialiv = logMaterialiv ;
3873 qglMatrixMode = logMatrixMode ;
3874 qglMultMatrixd = logMultMatrixd ;
3875 qglMultMatrixf = logMultMatrixf ;
3876 qglNewList = logNewList ;
3877 qglNormal3b = logNormal3b ;
3878 qglNormal3bv = logNormal3bv ;
3879 qglNormal3d = logNormal3d ;
3880 qglNormal3dv = logNormal3dv ;
3881 qglNormal3f = logNormal3f ;
3882 qglNormal3fv = logNormal3fv ;
3883 qglNormal3i = logNormal3i ;
3884 qglNormal3iv = logNormal3iv ;
3885 qglNormal3s = logNormal3s ;
3886 qglNormal3sv = logNormal3sv ;
3887 qglNormalPointer = logNormalPointer ;
3888 qglOrtho = logOrtho ;
3889 qglPassThrough = logPassThrough ;
3890 qglPixelMapfv = logPixelMapfv ;
3891 qglPixelMapuiv = logPixelMapuiv ;
3892 qglPixelMapusv = logPixelMapusv ;
3893 qglPixelStoref = logPixelStoref ;
3894 qglPixelStorei = logPixelStorei ;
3895 qglPixelTransferf = logPixelTransferf ;
3896 qglPixelTransferi = logPixelTransferi ;
3897 qglPixelZoom = logPixelZoom ;
3898 qglPointSize = logPointSize ;
3899 qglPolygonMode = logPolygonMode ;
3900 qglPolygonOffset = logPolygonOffset ;
3901 qglPolygonStipple = logPolygonStipple ;
3902 qglPopAttrib = logPopAttrib ;
3903 qglPopClientAttrib = logPopClientAttrib ;
3904 qglPopMatrix = logPopMatrix ;
3905 qglPopName = logPopName ;
3906 qglPrioritizeTextures = logPrioritizeTextures ;
3907 qglPushAttrib = logPushAttrib ;
3908 qglPushClientAttrib = logPushClientAttrib ;
3909 qglPushMatrix = logPushMatrix ;
3910 qglPushName = logPushName ;
3911 qglRasterPos2d = logRasterPos2d ;
3912 qglRasterPos2dv = logRasterPos2dv ;
3913 qglRasterPos2f = logRasterPos2f ;
3914 qglRasterPos2fv = logRasterPos2fv ;
3915 qglRasterPos2i = logRasterPos2i ;
3916 qglRasterPos2iv = logRasterPos2iv ;
3917 qglRasterPos2s = logRasterPos2s ;
3918 qglRasterPos2sv = logRasterPos2sv ;
3919 qglRasterPos3d = logRasterPos3d ;
3920 qglRasterPos3dv = logRasterPos3dv ;
3921 qglRasterPos3f = logRasterPos3f ;
3922 qglRasterPos3fv = logRasterPos3fv ;
3923 qglRasterPos3i = logRasterPos3i ;
3924 qglRasterPos3iv = logRasterPos3iv ;
3925 qglRasterPos3s = logRasterPos3s ;
3926 qglRasterPos3sv = logRasterPos3sv ;
3927 qglRasterPos4d = logRasterPos4d ;
3928 qglRasterPos4dv = logRasterPos4dv ;
3929 qglRasterPos4f = logRasterPos4f ;
3930 qglRasterPos4fv = logRasterPos4fv ;
3931 qglRasterPos4i = logRasterPos4i ;
3932 qglRasterPos4iv = logRasterPos4iv ;
3933 qglRasterPos4s = logRasterPos4s ;
3934 qglRasterPos4sv = logRasterPos4sv ;
3935 qglReadBuffer = logReadBuffer ;
3936 qglReadPixels = logReadPixels ;
3937 qglRectd = logRectd ;
3938 qglRectdv = logRectdv ;
3939 qglRectf = logRectf ;
3940 qglRectfv = logRectfv ;
3941 qglRecti = logRecti ;
3942 qglRectiv = logRectiv ;
3943 qglRects = logRects ;
3944 qglRectsv = logRectsv ;
3945 qglRenderMode = logRenderMode ;
3946 qglRotated = logRotated ;
3947 qglRotatef = logRotatef ;
3948 qglScaled = logScaled ;
3949 qglScalef = logScalef ;
3950 qglScissor = logScissor ;
3951 qglSelectBuffer = logSelectBuffer ;
3952 qglShadeModel = logShadeModel ;
3953 qglStencilFunc = logStencilFunc ;
3954 qglStencilMask = logStencilMask ;
3955 qglStencilOp = logStencilOp ;
3956 qglTexCoord1d = logTexCoord1d ;
3957 qglTexCoord1dv = logTexCoord1dv ;
3958 qglTexCoord1f = logTexCoord1f ;
3959 qglTexCoord1fv = logTexCoord1fv ;
3960 qglTexCoord1i = logTexCoord1i ;
3961 qglTexCoord1iv = logTexCoord1iv ;
3962 qglTexCoord1s = logTexCoord1s ;
3963 qglTexCoord1sv = logTexCoord1sv ;
3964 qglTexCoord2d = logTexCoord2d ;
3965 qglTexCoord2dv = logTexCoord2dv ;
3966 qglTexCoord2f = logTexCoord2f ;
3967 qglTexCoord2fv = logTexCoord2fv ;
3968 qglTexCoord2i = logTexCoord2i ;
3969 qglTexCoord2iv = logTexCoord2iv ;
3970 qglTexCoord2s = logTexCoord2s ;
3971 qglTexCoord2sv = logTexCoord2sv ;
3972 qglTexCoord3d = logTexCoord3d ;
3973 qglTexCoord3dv = logTexCoord3dv ;
3974 qglTexCoord3f = logTexCoord3f ;
3975 qglTexCoord3fv = logTexCoord3fv ;
3976 qglTexCoord3i = logTexCoord3i ;
3977 qglTexCoord3iv = logTexCoord3iv ;
3978 qglTexCoord3s = logTexCoord3s ;
3979 qglTexCoord3sv = logTexCoord3sv ;
3980 qglTexCoord4d = logTexCoord4d ;
3981 qglTexCoord4dv = logTexCoord4dv ;
3982 qglTexCoord4f = logTexCoord4f ;
3983 qglTexCoord4fv = logTexCoord4fv ;
3984 qglTexCoord4i = logTexCoord4i ;
3985 qglTexCoord4iv = logTexCoord4iv ;
3986 qglTexCoord4s = logTexCoord4s ;
3987 qglTexCoord4sv = logTexCoord4sv ;
3988 qglTexCoordPointer = logTexCoordPointer ;
3989 qglTexEnvf = logTexEnvf ;
3990 qglTexEnvfv = logTexEnvfv ;
3991 qglTexEnvi = logTexEnvi ;
3992 qglTexEnviv = logTexEnviv ;
3993 qglTexGend = logTexGend ;
3994 qglTexGendv = logTexGendv ;
3995 qglTexGenf = logTexGenf ;
3996 qglTexGenfv = logTexGenfv ;
3997 qglTexGeni = logTexGeni ;
3998 qglTexGeniv = logTexGeniv ;
3999 qglTexImage1D = logTexImage1D ;
4000 qglTexImage2D = logTexImage2D ;
4001 qglTexParameterf = logTexParameterf ;
4002 qglTexParameterfv = logTexParameterfv ;
4003 qglTexParameteri = logTexParameteri ;
4004 qglTexParameteriv = logTexParameteriv ;
4005 qglTexSubImage1D = logTexSubImage1D ;
4006 qglTexSubImage2D = logTexSubImage2D ;
4007 qglTranslated = logTranslated ;
4008 qglTranslatef = logTranslatef ;
4009 qglVertex2d = logVertex2d ;
4010 qglVertex2dv = logVertex2dv ;
4011 qglVertex2f = logVertex2f ;
4012 qglVertex2fv = logVertex2fv ;
4013 qglVertex2i = logVertex2i ;
4014 qglVertex2iv = logVertex2iv ;
4015 qglVertex2s = logVertex2s ;
4016 qglVertex2sv = logVertex2sv ;
4017 qglVertex3d = logVertex3d ;
4018 qglVertex3dv = logVertex3dv ;
4019 qglVertex3f = logVertex3f ;
4020 qglVertex3fv = logVertex3fv ;
4021 qglVertex3i = logVertex3i ;
4022 qglVertex3iv = logVertex3iv ;
4023 qglVertex3s = logVertex3s ;
4024 qglVertex3sv = logVertex3sv ;
4025 qglVertex4d = logVertex4d ;
4026 qglVertex4dv = logVertex4dv ;
4027 qglVertex4f = logVertex4f ;
4028 qglVertex4fv = logVertex4fv ;
4029 qglVertex4i = logVertex4i ;
4030 qglVertex4iv = logVertex4iv ;
4031 qglVertex4s = logVertex4s ;
4032 qglVertex4sv = logVertex4sv ;
4033 qglVertexPointer = logVertexPointer ;
4034 qglViewport = logViewport ;
4035 }
4036 else
4037 {
4038 if ( glw_state.log_fp ) {
4039 fprintf( glw_state.log_fp, "*** CLOSING LOG ***\n" );
4040 fclose( glw_state.log_fp );
4041 glw_state.log_fp = NULL;
4042 }
4043 qglAccum = dllAccum;
4044 qglAlphaFunc = dllAlphaFunc;
4045 qglAreTexturesResident = dllAreTexturesResident;
4046 qglArrayElement = dllArrayElement;
4047 qglBegin = dllBegin;
4048 qglBindTexture = dllBindTexture;
4049 qglBitmap = dllBitmap;
4050 qglBlendFunc = dllBlendFunc;
4051 qglCallList = dllCallList;
4052 qglCallLists = dllCallLists;
4053 qglClear = dllClear;
4054 qglClearAccum = dllClearAccum;
4055 qglClearColor = dllClearColor;
4056 qglClearDepth = dllClearDepth;
4057 qglClearIndex = dllClearIndex;
4058 qglClearStencil = dllClearStencil;
4059 qglClipPlane = dllClipPlane;
4060 qglColor3b = dllColor3b;
4061 qglColor3bv = dllColor3bv;
4062 qglColor3d = dllColor3d;
4063 qglColor3dv = dllColor3dv;
4064 qglColor3f = dllColor3f;
4065 qglColor3fv = dllColor3fv;
4066 qglColor3i = dllColor3i;
4067 qglColor3iv = dllColor3iv;
4068 qglColor3s = dllColor3s;
4069 qglColor3sv = dllColor3sv;
4070 qglColor3ub = dllColor3ub;
4071 qglColor3ubv = dllColor3ubv;
4072 qglColor3ui = dllColor3ui;
4073 qglColor3uiv = dllColor3uiv;
4074 qglColor3us = dllColor3us;
4075 qglColor3usv = dllColor3usv;
4076 qglColor4b = dllColor4b;
4077 qglColor4bv = dllColor4bv;
4078 qglColor4d = dllColor4d;
4079 qglColor4dv = dllColor4dv;
4080 qglColor4f = dllColor4f;
4081 qglColor4fv = dllColor4fv;
4082 qglColor4i = dllColor4i;
4083 qglColor4iv = dllColor4iv;
4084 qglColor4s = dllColor4s;
4085 qglColor4sv = dllColor4sv;
4086 qglColor4ub = dllColor4ub;
4087 qglColor4ubv = dllColor4ubv;
4088 qglColor4ui = dllColor4ui;
4089 qglColor4uiv = dllColor4uiv;
4090 qglColor4us = dllColor4us;
4091 qglColor4usv = dllColor4usv;
4092 qglColorMask = dllColorMask;
4093 qglColorMaterial = dllColorMaterial;
4094 qglColorPointer = dllColorPointer;
4095 qglCopyPixels = dllCopyPixels;
4096 qglCopyTexImage1D = dllCopyTexImage1D;
4097 qglCopyTexImage2D = dllCopyTexImage2D;
4098 qglCopyTexSubImage1D = dllCopyTexSubImage1D;
4099 qglCopyTexSubImage2D = dllCopyTexSubImage2D;
4100 qglCullFace = dllCullFace;
4101 qglDeleteLists = dllDeleteLists ;
4102 qglDeleteTextures = dllDeleteTextures ;
4103 qglDepthFunc = dllDepthFunc ;
4104 qglDepthMask = dllDepthMask ;
4105 qglDepthRange = dllDepthRange ;
4106 qglDisable = dllDisable ;
4107 qglDisableClientState = dllDisableClientState ;
4108 qglDrawArrays = dllDrawArrays ;
4109 qglDrawBuffer = dllDrawBuffer ;
4110 qglDrawElements = dllDrawElements ;
4111 qglDrawPixels = dllDrawPixels ;
4112 qglEdgeFlag = dllEdgeFlag ;
4113 qglEdgeFlagPointer = dllEdgeFlagPointer ;
4114 qglEdgeFlagv = dllEdgeFlagv ;
4115 qglEnable = dllEnable ;
4116 qglEnableClientState = dllEnableClientState ;
4117 qglEnd = dllEnd ;
4118 qglEndList = dllEndList ;
4119 qglEvalCoord1d = dllEvalCoord1d ;
4120 qglEvalCoord1dv = dllEvalCoord1dv ;
4121 qglEvalCoord1f = dllEvalCoord1f ;
4122 qglEvalCoord1fv = dllEvalCoord1fv ;
4123 qglEvalCoord2d = dllEvalCoord2d ;
4124 qglEvalCoord2dv = dllEvalCoord2dv ;
4125 qglEvalCoord2f = dllEvalCoord2f ;
4126 qglEvalCoord2fv = dllEvalCoord2fv ;
4127 qglEvalMesh1 = dllEvalMesh1 ;
4128 qglEvalMesh2 = dllEvalMesh2 ;
4129 qglEvalPoint1 = dllEvalPoint1 ;
4130 qglEvalPoint2 = dllEvalPoint2 ;
4131 qglFeedbackBuffer = dllFeedbackBuffer ;
4132 qglFinish = dllFinish ;
4133 qglFlush = dllFlush ;
4134 qglFogf = dllFogf ;
4135 qglFogfv = dllFogfv ;
4136 qglFogi = dllFogi ;
4137 qglFogiv = dllFogiv ;
4138 qglFrontFace = dllFrontFace ;
4139 qglFrustum = dllFrustum ;
4140 qglGenLists = dllGenLists ;
4141 qglGenTextures = dllGenTextures ;
4142 qglGetBooleanv = dllGetBooleanv ;
4143 qglGetClipPlane = dllGetClipPlane ;
4144 qglGetDoublev = dllGetDoublev ;
4145 qglGetError = dllGetError ;
4146 qglGetFloatv = dllGetFloatv ;
4147 qglGetIntegerv = dllGetIntegerv ;
4148 qglGetLightfv = dllGetLightfv ;
4149 qglGetLightiv = dllGetLightiv ;
4150 qglGetMapdv = dllGetMapdv ;
4151 qglGetMapfv = dllGetMapfv ;
4152 qglGetMapiv = dllGetMapiv ;
4153 qglGetMaterialfv = dllGetMaterialfv ;
4154 qglGetMaterialiv = dllGetMaterialiv ;
4155 qglGetPixelMapfv = dllGetPixelMapfv ;
4156 qglGetPixelMapuiv = dllGetPixelMapuiv ;
4157 qglGetPixelMapusv = dllGetPixelMapusv ;
4158 qglGetPointerv = dllGetPointerv ;
4159 qglGetPolygonStipple = dllGetPolygonStipple ;
4160 qglGetString = dllGetString ;
4161 qglGetTexEnvfv = dllGetTexEnvfv ;
4162 qglGetTexEnviv = dllGetTexEnviv ;
4163 qglGetTexGendv = dllGetTexGendv ;
4164 qglGetTexGenfv = dllGetTexGenfv ;
4165 qglGetTexGeniv = dllGetTexGeniv ;
4166 qglGetTexImage = dllGetTexImage ;
4167 qglGetTexLevelParameterfv = dllGetTexLevelParameterfv ;
4168 qglGetTexLevelParameteriv = dllGetTexLevelParameteriv ;
4169 qglGetTexParameterfv = dllGetTexParameterfv ;
4170 qglGetTexParameteriv = dllGetTexParameteriv ;
4171 qglHint = dllHint ;
4172 qglIndexMask = dllIndexMask ;
4173 qglIndexPointer = dllIndexPointer ;
4174 qglIndexd = dllIndexd ;
4175 qglIndexdv = dllIndexdv ;
4176 qglIndexf = dllIndexf ;
4177 qglIndexfv = dllIndexfv ;
4178 qglIndexi = dllIndexi ;
4179 qglIndexiv = dllIndexiv ;
4180 qglIndexs = dllIndexs ;
4181 qglIndexsv = dllIndexsv ;
4182 qglIndexub = dllIndexub ;
4183 qglIndexubv = dllIndexubv ;
4184 qglInitNames = dllInitNames ;
4185 qglInterleavedArrays = dllInterleavedArrays ;
4186 qglIsEnabled = dllIsEnabled ;
4187 qglIsList = dllIsList ;
4188 qglIsTexture = dllIsTexture ;
4189 qglLightModelf = dllLightModelf ;
4190 qglLightModelfv = dllLightModelfv ;
4191 qglLightModeli = dllLightModeli ;
4192 qglLightModeliv = dllLightModeliv ;
4193 qglLightf = dllLightf ;
4194 qglLightfv = dllLightfv ;
4195 qglLighti = dllLighti ;
4196 qglLightiv = dllLightiv ;
4197 qglLineStipple = dllLineStipple ;
4198 qglLineWidth = dllLineWidth ;
4199 qglListBase = dllListBase ;
4200 qglLoadIdentity = dllLoadIdentity ;
4201 qglLoadMatrixd = dllLoadMatrixd ;
4202 qglLoadMatrixf = dllLoadMatrixf ;
4203 qglLoadName = dllLoadName ;
4204 qglLogicOp = dllLogicOp ;
4205 qglMap1d = dllMap1d ;
4206 qglMap1f = dllMap1f ;
4207 qglMap2d = dllMap2d ;
4208 qglMap2f = dllMap2f ;
4209 qglMapGrid1d = dllMapGrid1d ;
4210 qglMapGrid1f = dllMapGrid1f ;
4211 qglMapGrid2d = dllMapGrid2d ;
4212 qglMapGrid2f = dllMapGrid2f ;
4213 qglMaterialf = dllMaterialf ;
4214 qglMaterialfv = dllMaterialfv ;
4215 qglMateriali = dllMateriali ;
4216 qglMaterialiv = dllMaterialiv ;
4217 qglMatrixMode = dllMatrixMode ;
4218 qglMultMatrixd = dllMultMatrixd ;
4219 qglMultMatrixf = dllMultMatrixf ;
4220 qglNewList = dllNewList ;
4221 qglNormal3b = dllNormal3b ;
4222 qglNormal3bv = dllNormal3bv ;
4223 qglNormal3d = dllNormal3d ;
4224 qglNormal3dv = dllNormal3dv ;
4225 qglNormal3f = dllNormal3f ;
4226 qglNormal3fv = dllNormal3fv ;
4227 qglNormal3i = dllNormal3i ;
4228 qglNormal3iv = dllNormal3iv ;
4229 qglNormal3s = dllNormal3s ;
4230 qglNormal3sv = dllNormal3sv ;
4231 qglNormalPointer = dllNormalPointer ;
4232 qglOrtho = dllOrtho ;
4233 qglPassThrough = dllPassThrough ;
4234 qglPixelMapfv = dllPixelMapfv ;
4235 qglPixelMapuiv = dllPixelMapuiv ;
4236 qglPixelMapusv = dllPixelMapusv ;
4237 qglPixelStoref = dllPixelStoref ;
4238 qglPixelStorei = dllPixelStorei ;
4239 qglPixelTransferf = dllPixelTransferf ;
4240 qglPixelTransferi = dllPixelTransferi ;
4241 qglPixelZoom = dllPixelZoom ;
4242 qglPointSize = dllPointSize ;
4243 qglPolygonMode = dllPolygonMode ;
4244 qglPolygonOffset = dllPolygonOffset ;
4245 qglPolygonStipple = dllPolygonStipple ;
4246 qglPopAttrib = dllPopAttrib ;
4247 qglPopClientAttrib = dllPopClientAttrib ;
4248 qglPopMatrix = dllPopMatrix ;
4249 qglPopName = dllPopName ;
4250 qglPrioritizeTextures = dllPrioritizeTextures ;
4251 qglPushAttrib = dllPushAttrib ;
4252 qglPushClientAttrib = dllPushClientAttrib ;
4253 qglPushMatrix = dllPushMatrix ;
4254 qglPushName = dllPushName ;
4255 qglRasterPos2d = dllRasterPos2d ;
4256 qglRasterPos2dv = dllRasterPos2dv ;
4257 qglRasterPos2f = dllRasterPos2f ;
4258 qglRasterPos2fv = dllRasterPos2fv ;
4259 qglRasterPos2i = dllRasterPos2i ;
4260 qglRasterPos2iv = dllRasterPos2iv ;
4261 qglRasterPos2s = dllRasterPos2s ;
4262 qglRasterPos2sv = dllRasterPos2sv ;
4263 qglRasterPos3d = dllRasterPos3d ;
4264 qglRasterPos3dv = dllRasterPos3dv ;
4265 qglRasterPos3f = dllRasterPos3f ;
4266 qglRasterPos3fv = dllRasterPos3fv ;
4267 qglRasterPos3i = dllRasterPos3i ;
4268 qglRasterPos3iv = dllRasterPos3iv ;
4269 qglRasterPos3s = dllRasterPos3s ;
4270 qglRasterPos3sv = dllRasterPos3sv ;
4271 qglRasterPos4d = dllRasterPos4d ;
4272 qglRasterPos4dv = dllRasterPos4dv ;
4273 qglRasterPos4f = dllRasterPos4f ;
4274 qglRasterPos4fv = dllRasterPos4fv ;
4275 qglRasterPos4i = dllRasterPos4i ;
4276 qglRasterPos4iv = dllRasterPos4iv ;
4277 qglRasterPos4s = dllRasterPos4s ;
4278 qglRasterPos4sv = dllRasterPos4sv ;
4279 qglReadBuffer = dllReadBuffer ;
4280 qglReadPixels = dllReadPixels ;
4281 qglRectd = dllRectd ;
4282 qglRectdv = dllRectdv ;
4283 qglRectf = dllRectf ;
4284 qglRectfv = dllRectfv ;
4285 qglRecti = dllRecti ;
4286 qglRectiv = dllRectiv ;
4287 qglRects = dllRects ;
4288 qglRectsv = dllRectsv ;
4289 qglRenderMode = dllRenderMode ;
4290 qglRotated = dllRotated ;
4291 qglRotatef = dllRotatef ;
4292 qglScaled = dllScaled ;
4293 qglScalef = dllScalef ;
4294 qglScissor = dllScissor ;
4295 qglSelectBuffer = dllSelectBuffer ;
4296 qglShadeModel = dllShadeModel ;
4297 qglStencilFunc = dllStencilFunc ;
4298 qglStencilMask = dllStencilMask ;
4299 qglStencilOp = dllStencilOp ;
4300 qglTexCoord1d = dllTexCoord1d ;
4301 qglTexCoord1dv = dllTexCoord1dv ;
4302 qglTexCoord1f = dllTexCoord1f ;
4303 qglTexCoord1fv = dllTexCoord1fv ;
4304 qglTexCoord1i = dllTexCoord1i ;
4305 qglTexCoord1iv = dllTexCoord1iv ;
4306 qglTexCoord1s = dllTexCoord1s ;
4307 qglTexCoord1sv = dllTexCoord1sv ;
4308 qglTexCoord2d = dllTexCoord2d ;
4309 qglTexCoord2dv = dllTexCoord2dv ;
4310 qglTexCoord2f = dllTexCoord2f ;
4311 qglTexCoord2fv = dllTexCoord2fv ;
4312 qglTexCoord2i = dllTexCoord2i ;
4313 qglTexCoord2iv = dllTexCoord2iv ;
4314 qglTexCoord2s = dllTexCoord2s ;
4315 qglTexCoord2sv = dllTexCoord2sv ;
4316 qglTexCoord3d = dllTexCoord3d ;
4317 qglTexCoord3dv = dllTexCoord3dv ;
4318 qglTexCoord3f = dllTexCoord3f ;
4319 qglTexCoord3fv = dllTexCoord3fv ;
4320 qglTexCoord3i = dllTexCoord3i ;
4321 qglTexCoord3iv = dllTexCoord3iv ;
4322 qglTexCoord3s = dllTexCoord3s ;
4323 qglTexCoord3sv = dllTexCoord3sv ;
4324 qglTexCoord4d = dllTexCoord4d ;
4325 qglTexCoord4dv = dllTexCoord4dv ;
4326 qglTexCoord4f = dllTexCoord4f ;
4327 qglTexCoord4fv = dllTexCoord4fv ;
4328 qglTexCoord4i = dllTexCoord4i ;
4329 qglTexCoord4iv = dllTexCoord4iv ;
4330 qglTexCoord4s = dllTexCoord4s ;
4331 qglTexCoord4sv = dllTexCoord4sv ;
4332 qglTexCoordPointer = dllTexCoordPointer ;
4333 qglTexEnvf = dllTexEnvf ;
4334 qglTexEnvfv = dllTexEnvfv ;
4335 qglTexEnvi = dllTexEnvi ;
4336 qglTexEnviv = dllTexEnviv ;
4337 qglTexGend = dllTexGend ;
4338 qglTexGendv = dllTexGendv ;
4339 qglTexGenf = dllTexGenf ;
4340 qglTexGenfv = dllTexGenfv ;
4341 qglTexGeni = dllTexGeni ;
4342 qglTexGeniv = dllTexGeniv ;
4343 qglTexImage1D = dllTexImage1D ;
4344 qglTexImage2D = dllTexImage2D ;
4345 qglTexParameterf = dllTexParameterf ;
4346 qglTexParameterfv = dllTexParameterfv ;
4347 qglTexParameteri = dllTexParameteri ;
4348 qglTexParameteriv = dllTexParameteriv ;
4349 qglTexSubImage1D = dllTexSubImage1D ;
4350 qglTexSubImage2D = dllTexSubImage2D ;
4351 qglTranslated = dllTranslated ;
4352 qglTranslatef = dllTranslatef ;
4353 qglVertex2d = dllVertex2d ;
4354 qglVertex2dv = dllVertex2dv ;
4355 qglVertex2f = dllVertex2f ;
4356 qglVertex2fv = dllVertex2fv ;
4357 qglVertex2i = dllVertex2i ;
4358 qglVertex2iv = dllVertex2iv ;
4359 qglVertex2s = dllVertex2s ;
4360 qglVertex2sv = dllVertex2sv ;
4361 qglVertex3d = dllVertex3d ;
4362 qglVertex3dv = dllVertex3dv ;
4363 qglVertex3f = dllVertex3f ;
4364 qglVertex3fv = dllVertex3fv ;
4365 qglVertex3i = dllVertex3i ;
4366 qglVertex3iv = dllVertex3iv ;
4367 qglVertex3s = dllVertex3s ;
4368 qglVertex3sv = dllVertex3sv ;
4369 qglVertex4d = dllVertex4d ;
4370 qglVertex4dv = dllVertex4dv ;
4371 qglVertex4f = dllVertex4f ;
4372 qglVertex4fv = dllVertex4fv ;
4373 qglVertex4i = dllVertex4i ;
4374 qglVertex4iv = dllVertex4iv ;
4375 qglVertex4s = dllVertex4s ;
4376 qglVertex4sv = dllVertex4sv ;
4377 qglVertexPointer = dllVertexPointer ;
4378 qglViewport = dllViewport ;
4379 }
4380 }
4381
4382 #ifdef _MSC_VER
4383 #pragma warning (default : 4113 4133 4047 )
4384 #endif
4385
4386
4387
4388