1 /*
2 Copyright (C) 1997-2001 Id Software, Inc.
3
4 This program is free software; you can redistribute it and/or
5 modify it under the terms of the GNU General Public License
6 as published by the Free Software Foundation; either version 2
7 of the License, or (at your option) any later version.
8
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
12
13 See the GNU General Public License for more details.
14
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
18
19 */
20
21 /*
22 ** QGL_WIN.C
23 **
24 ** This file implements the operating system binding of GL to QGL function
25 ** pointers. When doing a port of Quake2 you must implement the following
26 ** two functions:
27 **
28 ** QGL_Init() - loads libraries, assigns function pointers, etc.
29 ** QGL_Shutdown() - unloads libraries, NULLs function pointers
30 */
31
32 #include <GL/glx.h>
33 #include <X11/keysym.h>
34 #include <X11/cursorfont.h>
35 #include <X11/Sunkeysym.h>
36
37 #include "../ref_gl/gl_local.h"
38 #include "../solaris/glw_solaris.h"
39 #include "../solaris/qgl_solaris.h"
40 #include "../solaris/gl_glx.h"
41
42 #include <dlfcn.h>
43
logAccum(GLenum op,GLfloat value)44 static void APIENTRY logAccum(GLenum op, GLfloat value)
45 {
46 fprintf( glw_state.log_fp, "glAccum\n" );
47 dllAccum( op, value );
48 }
49
logAlphaFunc(GLenum func,GLclampf ref)50 static void APIENTRY logAlphaFunc(GLenum func, GLclampf ref)
51 {
52 fprintf( glw_state.log_fp, "glAlphaFunc( 0x%x, %f )\n", func, ref );
53 dllAlphaFunc( func, ref );
54 }
55
logAreTexturesResident(GLsizei n,const GLuint * textures,GLboolean * residences)56 static GLboolean APIENTRY logAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences)
57 {
58 fprintf( glw_state.log_fp, "glAreTexturesResident\n" );
59 return dllAreTexturesResident( n, textures, residences );
60 }
61
logArrayElement(GLint i)62 static void APIENTRY logArrayElement(GLint i)
63 {
64 fprintf( glw_state.log_fp, "glArrayElement\n" );
65 dllArrayElement( i );
66 }
67
logBegin(GLenum mode)68 static void APIENTRY logBegin(GLenum mode)
69 {
70 fprintf( glw_state.log_fp, "glBegin( 0x%x )\n", mode );
71 dllBegin( mode );
72 }
73
logBindTexture(GLenum target,GLuint texture)74 static void APIENTRY logBindTexture(GLenum target, GLuint texture)
75 {
76 fprintf( glw_state.log_fp, "glBindTexture( 0x%x, %u )\n", target, texture );
77 dllBindTexture( target, texture );
78 }
79
logBitmap(GLsizei width,GLsizei height,GLfloat xorig,GLfloat yorig,GLfloat xmove,GLfloat ymove,const GLubyte * bitmap)80 static void APIENTRY logBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap)
81 {
82 fprintf( glw_state.log_fp, "glBitmap\n" );
83 dllBitmap( width, height, xorig, yorig, xmove, ymove, bitmap );
84 }
85
logBlendFunc(GLenum sfactor,GLenum dfactor)86 static void APIENTRY logBlendFunc(GLenum sfactor, GLenum dfactor)
87 {
88 fprintf( glw_state.log_fp, "glBlendFunc( 0x%x, 0x%x )\n", sfactor, dfactor );
89 dllBlendFunc( sfactor, dfactor );
90 }
91
logCallList(GLuint list)92 static void APIENTRY logCallList(GLuint list)
93 {
94 fprintf( glw_state.log_fp, "glCallList( %u )\n", list );
95 dllCallList( list );
96 }
97
logCallLists(GLsizei n,GLenum type,const void * lists)98 static void APIENTRY logCallLists(GLsizei n, GLenum type, const void *lists)
99 {
100 fprintf( glw_state.log_fp, "glCallLists\n" );
101 dllCallLists( n, type, lists );
102 }
103
logClear(GLbitfield mask)104 static void APIENTRY logClear(GLbitfield mask)
105 {
106 fprintf( glw_state.log_fp, "glClear\n" );
107 dllClear( mask );
108 }
109
logClearAccum(GLfloat red,GLfloat green,GLfloat blue,GLfloat alpha)110 static void APIENTRY logClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
111 {
112 fprintf( glw_state.log_fp, "glClearAccum\n" );
113 dllClearAccum( red, green, blue, alpha );
114 }
115
logClearColor(GLclampf red,GLclampf green,GLclampf blue,GLclampf alpha)116 static void APIENTRY logClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
117 {
118 fprintf( glw_state.log_fp, "glClearColor\n" );
119 dllClearColor( red, green, blue, alpha );
120 }
121
logClearDepth(GLclampd depth)122 static void APIENTRY logClearDepth(GLclampd depth)
123 {
124 fprintf( glw_state.log_fp, "glClearDepth\n" );
125 dllClearDepth( depth );
126 }
127
logClearIndex(GLfloat c)128 static void APIENTRY logClearIndex(GLfloat c)
129 {
130 fprintf( glw_state.log_fp, "glClearIndex\n" );
131 dllClearIndex( c );
132 }
133
logClearStencil(GLint s)134 static void APIENTRY logClearStencil(GLint s)
135 {
136 fprintf( glw_state.log_fp, "glClearStencil\n" );
137 dllClearStencil( s );
138 }
139
logClipPlane(GLenum plane,const GLdouble * equation)140 static void APIENTRY logClipPlane(GLenum plane, const GLdouble *equation)
141 {
142 fprintf( glw_state.log_fp, "glClipPlane\n" );
143 dllClipPlane( plane, equation );
144 }
145
logColor3b(GLbyte red,GLbyte green,GLbyte blue)146 static void APIENTRY logColor3b(GLbyte red, GLbyte green, GLbyte blue)
147 {
148 fprintf( glw_state.log_fp, "glColor3b\n" );
149 dllColor3b( red, green, blue );
150 }
151
logColor3bv(const GLbyte * v)152 static void APIENTRY logColor3bv(const GLbyte *v)
153 {
154 fprintf( glw_state.log_fp, "glColor3bv\n" );
155 dllColor3bv( v );
156 }
157
logColor3d(GLdouble red,GLdouble green,GLdouble blue)158 static void APIENTRY logColor3d(GLdouble red, GLdouble green, GLdouble blue)
159 {
160 fprintf( glw_state.log_fp, "glColor3d\n" );
161 dllColor3d( red, green, blue );
162 }
163
logColor3dv(const GLdouble * v)164 static void APIENTRY logColor3dv(const GLdouble *v)
165 {
166 fprintf( glw_state.log_fp, "glColor3dv\n" );
167 dllColor3dv( v );
168 }
169
logColor3f(GLfloat red,GLfloat green,GLfloat blue)170 static void APIENTRY logColor3f(GLfloat red, GLfloat green, GLfloat blue)
171 {
172 fprintf( glw_state.log_fp, "glColor3f\n" );
173 dllColor3f( red, green, blue );
174 }
175
logColor3fv(const GLfloat * v)176 static void APIENTRY logColor3fv(const GLfloat *v)
177 {
178 fprintf( glw_state.log_fp, "glColor3fv\n" );
179 dllColor3fv( v );
180 }
181
logColor3i(GLint red,GLint green,GLint blue)182 static void APIENTRY logColor3i(GLint red, GLint green, GLint blue)
183 {
184 fprintf( glw_state.log_fp, "glColor3i\n" );
185 dllColor3i( red, green, blue );
186 }
187
logColor3iv(const GLint * v)188 static void APIENTRY logColor3iv(const GLint *v)
189 {
190 fprintf( glw_state.log_fp, "glColor3iv\n" );
191 dllColor3iv( v );
192 }
193
logColor3s(GLshort red,GLshort green,GLshort blue)194 static void APIENTRY logColor3s(GLshort red, GLshort green, GLshort blue)
195 {
196 fprintf( glw_state.log_fp, "glColor3s\n" );
197 dllColor3s( red, green, blue );
198 }
199
logColor3sv(const GLshort * v)200 static void APIENTRY logColor3sv(const GLshort *v)
201 {
202 fprintf( glw_state.log_fp, "glColor3sv\n" );
203 dllColor3sv( v );
204 }
205
logColor3ub(GLubyte red,GLubyte green,GLubyte blue)206 static void APIENTRY logColor3ub(GLubyte red, GLubyte green, GLubyte blue)
207 {
208 fprintf( glw_state.log_fp, "glColor3ub\n" );
209 dllColor3ub( red, green, blue );
210 }
211
logColor3ubv(const GLubyte * v)212 static void APIENTRY logColor3ubv(const GLubyte *v)
213 {
214 fprintf( glw_state.log_fp, "glColor3ubv\n" );
215 dllColor3ubv( v );
216 }
217
218 #define SIG( x ) fprintf( glw_state.log_fp, x "\n" )
219
logColor3ui(GLuint red,GLuint green,GLuint blue)220 static void APIENTRY logColor3ui(GLuint red, GLuint green, GLuint blue)
221 {
222 SIG( "glColor3ui" );
223 dllColor3ui( red, green, blue );
224 }
225
logColor3uiv(const GLuint * v)226 static void APIENTRY logColor3uiv(const GLuint *v)
227 {
228 SIG( "glColor3uiv" );
229 dllColor3uiv( v );
230 }
231
logColor3us(GLushort red,GLushort green,GLushort blue)232 static void APIENTRY logColor3us(GLushort red, GLushort green, GLushort blue)
233 {
234 SIG( "glColor3us" );
235 dllColor3us( red, green, blue );
236 }
237
logColor3usv(const GLushort * v)238 static void APIENTRY logColor3usv(const GLushort *v)
239 {
240 SIG( "glColor3usv" );
241 dllColor3usv( v );
242 }
243
logColor4b(GLbyte red,GLbyte green,GLbyte blue,GLbyte alpha)244 static void APIENTRY logColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)
245 {
246 SIG( "glColor4b" );
247 dllColor4b( red, green, blue, alpha );
248 }
249
logColor4bv(const GLbyte * v)250 static void APIENTRY logColor4bv(const GLbyte *v)
251 {
252 SIG( "glColor4bv" );
253 dllColor4bv( v );
254 }
255
logColor4d(GLdouble red,GLdouble green,GLdouble blue,GLdouble alpha)256 static void APIENTRY logColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)
257 {
258 SIG( "glColor4d" );
259 dllColor4d( red, green, blue, alpha );
260 }
logColor4dv(const GLdouble * v)261 static void APIENTRY logColor4dv(const GLdouble *v)
262 {
263 SIG( "glColor4dv" );
264 dllColor4dv( v );
265 }
logColor4f(GLfloat red,GLfloat green,GLfloat blue,GLfloat alpha)266 static void APIENTRY logColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
267 {
268 fprintf( glw_state.log_fp, "glColor4f( %f,%f,%f,%f )\n", red, green, blue, alpha );
269 dllColor4f( red, green, blue, alpha );
270 }
logColor4fv(const GLfloat * v)271 static void APIENTRY logColor4fv(const GLfloat *v)
272 {
273 fprintf( glw_state.log_fp, "glColor4fv( %f,%f,%f,%f )\n", v[0], v[1], v[2], v[3] );
274 dllColor4fv( v );
275 }
logColor4i(GLint red,GLint green,GLint blue,GLint alpha)276 static void APIENTRY logColor4i(GLint red, GLint green, GLint blue, GLint alpha)
277 {
278 SIG( "glColor4i" );
279 dllColor4i( red, green, blue, alpha );
280 }
logColor4iv(const GLint * v)281 static void APIENTRY logColor4iv(const GLint *v)
282 {
283 SIG( "glColor4iv" );
284 dllColor4iv( v );
285 }
logColor4s(GLshort red,GLshort green,GLshort blue,GLshort alpha)286 static void APIENTRY logColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha)
287 {
288 SIG( "glColor4s" );
289 dllColor4s( red, green, blue, alpha );
290 }
logColor4sv(const GLshort * v)291 static void APIENTRY logColor4sv(const GLshort *v)
292 {
293 SIG( "glColor4sv" );
294 dllColor4sv( v );
295 }
logColor4ub(GLubyte red,GLubyte green,GLubyte blue,GLubyte alpha)296 static void APIENTRY logColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
297 {
298 SIG( "glColor4b" );
299 dllColor4b( red, green, blue, alpha );
300 }
logColor4ubv(const GLubyte * v)301 static void APIENTRY logColor4ubv(const GLubyte *v)
302 {
303 SIG( "glColor4ubv" );
304 dllColor4ubv( v );
305 }
logColor4ui(GLuint red,GLuint green,GLuint blue,GLuint alpha)306 static void APIENTRY logColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha)
307 {
308 SIG( "glColor4ui" );
309 dllColor4ui( red, green, blue, alpha );
310 }
logColor4uiv(const GLuint * v)311 static void APIENTRY logColor4uiv(const GLuint *v)
312 {
313 SIG( "glColor4uiv" );
314 dllColor4uiv( v );
315 }
logColor4us(GLushort red,GLushort green,GLushort blue,GLushort alpha)316 static void APIENTRY logColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha)
317 {
318 SIG( "glColor4us" );
319 dllColor4us( red, green, blue, alpha );
320 }
logColor4usv(const GLushort * v)321 static void APIENTRY logColor4usv(const GLushort *v)
322 {
323 SIG( "glColor4usv" );
324 dllColor4usv( v );
325 }
logColorMask(GLboolean red,GLboolean green,GLboolean blue,GLboolean alpha)326 static void APIENTRY logColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
327 {
328 SIG( "glColorMask" );
329 dllColorMask( red, green, blue, alpha );
330 }
logColorMaterial(GLenum face,GLenum mode)331 static void APIENTRY logColorMaterial(GLenum face, GLenum mode)
332 {
333 SIG( "glColorMaterial" );
334 dllColorMaterial( face, mode );
335 }
336
logColorPointer(GLint size,GLenum type,GLsizei stride,const void * pointer)337 static void APIENTRY logColorPointer(GLint size, GLenum type, GLsizei stride, const void *pointer)
338 {
339 SIG( "glColorPointer" );
340 dllColorPointer( size, type, stride, pointer );
341 }
342
logCopyPixels(GLint x,GLint y,GLsizei width,GLsizei height,GLenum type)343 static void APIENTRY logCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
344 {
345 SIG( "glCopyPixels" );
346 dllCopyPixels( x, y, width, height, type );
347 }
348
logCopyTexImage1D(GLenum target,GLint level,GLenum internalFormat,GLint x,GLint y,GLsizei width,GLint border)349 static void APIENTRY logCopyTexImage1D(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border)
350 {
351 SIG( "glCopyTexImage1D" );
352 dllCopyTexImage1D( target, level, internalFormat, x, y, width, border );
353 }
354
logCopyTexImage2D(GLenum target,GLint level,GLenum internalFormat,GLint x,GLint y,GLsizei width,GLsizei height,GLint border)355 static void APIENTRY logCopyTexImage2D(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
356 {
357 SIG( "glCopyTexImage2D" );
358 dllCopyTexImage2D( target, level, internalFormat, x, y, width, height, border );
359 }
360
logCopyTexSubImage1D(GLenum target,GLint level,GLint xoffset,GLint x,GLint y,GLsizei width)361 static void APIENTRY logCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
362 {
363 SIG( "glCopyTexSubImage1D" );
364 dllCopyTexSubImage1D( target, level, xoffset, x, y, width );
365 }
366
logCopyTexSubImage2D(GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint x,GLint y,GLsizei width,GLsizei height)367 static void APIENTRY logCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
368 {
369 SIG( "glCopyTexSubImage2D" );
370 dllCopyTexSubImage2D( target, level, xoffset, yoffset, x, y, width, height );
371 }
372
logCullFace(GLenum mode)373 static void APIENTRY logCullFace(GLenum mode)
374 {
375 SIG( "glCullFace" );
376 dllCullFace( mode );
377 }
378
logDeleteLists(GLuint list,GLsizei range)379 static void APIENTRY logDeleteLists(GLuint list, GLsizei range)
380 {
381 SIG( "glDeleteLists" );
382 dllDeleteLists( list, range );
383 }
384
logDeleteTextures(GLsizei n,const GLuint * textures)385 static void APIENTRY logDeleteTextures(GLsizei n, const GLuint *textures)
386 {
387 SIG( "glDeleteTextures" );
388 dllDeleteTextures( n, textures );
389 }
390
logDepthFunc(GLenum func)391 static void APIENTRY logDepthFunc(GLenum func)
392 {
393 SIG( "glDepthFunc" );
394 dllDepthFunc( func );
395 }
396
logDepthMask(GLboolean flag)397 static void APIENTRY logDepthMask(GLboolean flag)
398 {
399 SIG( "glDepthMask" );
400 dllDepthMask( flag );
401 }
402
logDepthRange(GLclampd zNear,GLclampd zFar)403 static void APIENTRY logDepthRange(GLclampd zNear, GLclampd zFar)
404 {
405 SIG( "glDepthRange" );
406 dllDepthRange( zNear, zFar );
407 }
408
logDisable(GLenum cap)409 static void APIENTRY logDisable(GLenum cap)
410 {
411 fprintf( glw_state.log_fp, "glDisable( 0x%x )\n", cap );
412 dllDisable( cap );
413 }
414
logDisableClientState(GLenum array)415 static void APIENTRY logDisableClientState(GLenum array)
416 {
417 SIG( "glDisableClientState" );
418 dllDisableClientState( array );
419 }
420
logDrawArrays(GLenum mode,GLint first,GLsizei count)421 static void APIENTRY logDrawArrays(GLenum mode, GLint first, GLsizei count)
422 {
423 SIG( "glDrawArrays" );
424 dllDrawArrays( mode, first, count );
425 }
426
logDrawBuffer(GLenum mode)427 static void APIENTRY logDrawBuffer(GLenum mode)
428 {
429 SIG( "glDrawBuffer" );
430 dllDrawBuffer( mode );
431 }
432
logDrawElements(GLenum mode,GLsizei count,GLenum type,const void * indices)433 static void APIENTRY logDrawElements(GLenum mode, GLsizei count, GLenum type, const void *indices)
434 {
435 SIG( "glDrawElements" );
436 dllDrawElements( mode, count, type, indices );
437 }
438
logDrawPixels(GLsizei width,GLsizei height,GLenum format,GLenum type,const void * pixels)439 static void APIENTRY logDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels)
440 {
441 SIG( "glDrawPixels" );
442 dllDrawPixels( width, height, format, type, pixels );
443 }
444
logEdgeFlag(GLboolean flag)445 static void APIENTRY logEdgeFlag(GLboolean flag)
446 {
447 SIG( "glEdgeFlag" );
448 dllEdgeFlag( flag );
449 }
450
logEdgeFlagPointer(GLsizei stride,const void * pointer)451 static void APIENTRY logEdgeFlagPointer(GLsizei stride, const void *pointer)
452 {
453 SIG( "glEdgeFlagPointer" );
454 dllEdgeFlagPointer( stride, pointer );
455 }
456
logEdgeFlagv(const GLboolean * flag)457 static void APIENTRY logEdgeFlagv(const GLboolean *flag)
458 {
459 SIG( "glEdgeFlagv" );
460 dllEdgeFlagv( flag );
461 }
462
logEnable(GLenum cap)463 static void APIENTRY logEnable(GLenum cap)
464 {
465 fprintf( glw_state.log_fp, "glEnable( 0x%x )\n", cap );
466 dllEnable( cap );
467 }
468
logEnableClientState(GLenum array)469 static void APIENTRY logEnableClientState(GLenum array)
470 {
471 SIG( "glEnableClientState" );
472 dllEnableClientState( array );
473 }
474
logEnd(void)475 static void APIENTRY logEnd(void)
476 {
477 SIG( "glEnd" );
478 dllEnd();
479 }
480
logEndList(void)481 static void APIENTRY logEndList(void)
482 {
483 SIG( "glEndList" );
484 dllEndList();
485 }
486
logEvalCoord1d(GLdouble u)487 static void APIENTRY logEvalCoord1d(GLdouble u)
488 {
489 SIG( "glEvalCoord1d" );
490 dllEvalCoord1d( u );
491 }
492
logEvalCoord1dv(const GLdouble * u)493 static void APIENTRY logEvalCoord1dv(const GLdouble *u)
494 {
495 SIG( "glEvalCoord1dv" );
496 dllEvalCoord1dv( u );
497 }
498
logEvalCoord1f(GLfloat u)499 static void APIENTRY logEvalCoord1f(GLfloat u)
500 {
501 SIG( "glEvalCoord1f" );
502 dllEvalCoord1f( u );
503 }
504
logEvalCoord1fv(const GLfloat * u)505 static void APIENTRY logEvalCoord1fv(const GLfloat *u)
506 {
507 SIG( "glEvalCoord1fv" );
508 dllEvalCoord1fv( u );
509 }
logEvalCoord2d(GLdouble u,GLdouble v)510 static void APIENTRY logEvalCoord2d(GLdouble u, GLdouble v)
511 {
512 SIG( "glEvalCoord2d" );
513 dllEvalCoord2d( u, v );
514 }
logEvalCoord2dv(const GLdouble * u)515 static void APIENTRY logEvalCoord2dv(const GLdouble *u)
516 {
517 SIG( "glEvalCoord2dv" );
518 dllEvalCoord2dv( u );
519 }
logEvalCoord2f(GLfloat u,GLfloat v)520 static void APIENTRY logEvalCoord2f(GLfloat u, GLfloat v)
521 {
522 SIG( "glEvalCoord2f" );
523 dllEvalCoord2f( u, v );
524 }
logEvalCoord2fv(const GLfloat * u)525 static void APIENTRY logEvalCoord2fv(const GLfloat *u)
526 {
527 SIG( "glEvalCoord2fv" );
528 dllEvalCoord2fv( u );
529 }
530
logEvalMesh1(GLenum mode,GLint i1,GLint i2)531 static void APIENTRY logEvalMesh1(GLenum mode, GLint i1, GLint i2)
532 {
533 SIG( "glEvalMesh1" );
534 dllEvalMesh1( mode, i1, i2 );
535 }
logEvalMesh2(GLenum mode,GLint i1,GLint i2,GLint j1,GLint j2)536 static void APIENTRY logEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
537 {
538 SIG( "glEvalMesh2" );
539 dllEvalMesh2( mode, i1, i2, j1, j2 );
540 }
logEvalPoint1(GLint i)541 static void APIENTRY logEvalPoint1(GLint i)
542 {
543 SIG( "glEvalPoint1" );
544 dllEvalPoint1( i );
545 }
logEvalPoint2(GLint i,GLint j)546 static void APIENTRY logEvalPoint2(GLint i, GLint j)
547 {
548 SIG( "glEvalPoint2" );
549 dllEvalPoint2( i, j );
550 }
551
logFeedbackBuffer(GLsizei size,GLenum type,GLfloat * buffer)552 static void APIENTRY logFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer)
553 {
554 SIG( "glFeedbackBuffer" );
555 dllFeedbackBuffer( size, type, buffer );
556 }
557
logFinish(void)558 static void APIENTRY logFinish(void)
559 {
560 SIG( "glFinish" );
561 dllFinish();
562 }
563
logFlush(void)564 static void APIENTRY logFlush(void)
565 {
566 SIG( "glFlush" );
567 dllFlush();
568 }
569
logFogf(GLenum pname,GLfloat param)570 static void APIENTRY logFogf(GLenum pname, GLfloat param)
571 {
572 SIG( "glFogf" );
573 dllFogf( pname, param );
574 }
575
logFogfv(GLenum pname,const GLfloat * params)576 static void APIENTRY logFogfv(GLenum pname, const GLfloat *params)
577 {
578 SIG( "glFogfv" );
579 dllFogfv( pname, params );
580 }
581
logFogi(GLenum pname,GLint param)582 static void APIENTRY logFogi(GLenum pname, GLint param)
583 {
584 SIG( "glFogi" );
585 dllFogi( pname, param );
586 }
587
logFogiv(GLenum pname,const GLint * params)588 static void APIENTRY logFogiv(GLenum pname, const GLint *params)
589 {
590 SIG( "glFogiv" );
591 dllFogiv( pname, params );
592 }
593
logFrontFace(GLenum mode)594 static void APIENTRY logFrontFace(GLenum mode)
595 {
596 SIG( "glFrontFace" );
597 dllFrontFace( mode );
598 }
599
logFrustum(GLdouble left,GLdouble right,GLdouble bottom,GLdouble top,GLdouble zNear,GLdouble zFar)600 static void APIENTRY logFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
601 {
602 SIG( "glFrustum" );
603 dllFrustum( left, right, bottom, top, zNear, zFar );
604 }
605
logGenLists(GLsizei range)606 static GLuint APIENTRY logGenLists(GLsizei range)
607 {
608 SIG( "glGenLists" );
609 return dllGenLists( range );
610 }
611
logGenTextures(GLsizei n,GLuint * textures)612 static void APIENTRY logGenTextures(GLsizei n, GLuint *textures)
613 {
614 SIG( "glGenTextures" );
615 dllGenTextures( n, textures );
616 }
617
logGetBooleanv(GLenum pname,GLboolean * params)618 static void APIENTRY logGetBooleanv(GLenum pname, GLboolean *params)
619 {
620 SIG( "glGetBooleanv" );
621 dllGetBooleanv( pname, params );
622 }
623
logGetClipPlane(GLenum plane,GLdouble * equation)624 static void APIENTRY logGetClipPlane(GLenum plane, GLdouble *equation)
625 {
626 SIG( "glGetClipPlane" );
627 dllGetClipPlane( plane, equation );
628 }
629
logGetDoublev(GLenum pname,GLdouble * params)630 static void APIENTRY logGetDoublev(GLenum pname, GLdouble *params)
631 {
632 SIG( "glGetDoublev" );
633 dllGetDoublev( pname, params );
634 }
635
logGetError(void)636 static GLenum APIENTRY logGetError(void)
637 {
638 SIG( "glGetError" );
639 return dllGetError();
640 }
641
logGetFloatv(GLenum pname,GLfloat * params)642 static void APIENTRY logGetFloatv(GLenum pname, GLfloat *params)
643 {
644 SIG( "glGetFloatv" );
645 dllGetFloatv( pname, params );
646 }
647
logGetIntegerv(GLenum pname,GLint * params)648 static void APIENTRY logGetIntegerv(GLenum pname, GLint *params)
649 {
650 SIG( "glGetIntegerv" );
651 dllGetIntegerv( pname, params );
652 }
653
logGetLightfv(GLenum light,GLenum pname,GLfloat * params)654 static void APIENTRY logGetLightfv(GLenum light, GLenum pname, GLfloat *params)
655 {
656 SIG( "glGetLightfv" );
657 dllGetLightfv( light, pname, params );
658 }
659
logGetLightiv(GLenum light,GLenum pname,GLint * params)660 static void APIENTRY logGetLightiv(GLenum light, GLenum pname, GLint *params)
661 {
662 SIG( "glGetLightiv" );
663 dllGetLightiv( light, pname, params );
664 }
665
logGetMapdv(GLenum target,GLenum query,GLdouble * v)666 static void APIENTRY logGetMapdv(GLenum target, GLenum query, GLdouble *v)
667 {
668 SIG( "glGetMapdv" );
669 dllGetMapdv( target, query, v );
670 }
671
logGetMapfv(GLenum target,GLenum query,GLfloat * v)672 static void APIENTRY logGetMapfv(GLenum target, GLenum query, GLfloat *v)
673 {
674 SIG( "glGetMapfv" );
675 dllGetMapfv( target, query, v );
676 }
677
logGetMapiv(GLenum target,GLenum query,GLint * v)678 static void APIENTRY logGetMapiv(GLenum target, GLenum query, GLint *v)
679 {
680 SIG( "glGetMapiv" );
681 dllGetMapiv( target, query, v );
682 }
683
logGetMaterialfv(GLenum face,GLenum pname,GLfloat * params)684 static void APIENTRY logGetMaterialfv(GLenum face, GLenum pname, GLfloat *params)
685 {
686 SIG( "glGetMaterialfv" );
687 dllGetMaterialfv( face, pname, params );
688 }
689
logGetMaterialiv(GLenum face,GLenum pname,GLint * params)690 static void APIENTRY logGetMaterialiv(GLenum face, GLenum pname, GLint *params)
691 {
692 SIG( "glGetMaterialiv" );
693 dllGetMaterialiv( face, pname, params );
694 }
695
logGetPixelMapfv(GLenum map,GLfloat * values)696 static void APIENTRY logGetPixelMapfv(GLenum map, GLfloat *values)
697 {
698 SIG( "glGetPixelMapfv" );
699 dllGetPixelMapfv( map, values );
700 }
701
logGetPixelMapuiv(GLenum map,GLuint * values)702 static void APIENTRY logGetPixelMapuiv(GLenum map, GLuint *values)
703 {
704 SIG( "glGetPixelMapuiv" );
705 dllGetPixelMapuiv( map, values );
706 }
707
logGetPixelMapusv(GLenum map,GLushort * values)708 static void APIENTRY logGetPixelMapusv(GLenum map, GLushort *values)
709 {
710 SIG( "glGetPixelMapusv" );
711 dllGetPixelMapusv( map, values );
712 }
713
logGetPointerv(GLenum pname,GLvoid ** params)714 static void APIENTRY logGetPointerv(GLenum pname, GLvoid* *params)
715 {
716 SIG( "glGetPointerv" );
717 dllGetPointerv( pname, params );
718 }
719
logGetPolygonStipple(GLubyte * mask)720 static void APIENTRY logGetPolygonStipple(GLubyte *mask)
721 {
722 SIG( "glGetPolygonStipple" );
723 dllGetPolygonStipple( mask );
724 }
725
logGetString(GLenum name)726 static const GLubyte * APIENTRY logGetString(GLenum name)
727 {
728 SIG( "glGetString" );
729 return dllGetString( name );
730 }
731
logGetTexEnvfv(GLenum target,GLenum pname,GLfloat * params)732 static void APIENTRY logGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params)
733 {
734 SIG( "glGetTexEnvfv" );
735 dllGetTexEnvfv( target, pname, params );
736 }
737
logGetTexEnviv(GLenum target,GLenum pname,GLint * params)738 static void APIENTRY logGetTexEnviv(GLenum target, GLenum pname, GLint *params)
739 {
740 SIG( "glGetTexEnviv" );
741 dllGetTexEnviv( target, pname, params );
742 }
743
logGetTexGendv(GLenum coord,GLenum pname,GLdouble * params)744 static void APIENTRY logGetTexGendv(GLenum coord, GLenum pname, GLdouble *params)
745 {
746 SIG( "glGetTexGendv" );
747 dllGetTexGendv( coord, pname, params );
748 }
749
logGetTexGenfv(GLenum coord,GLenum pname,GLfloat * params)750 static void APIENTRY logGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params)
751 {
752 SIG( "glGetTexGenfv" );
753 dllGetTexGenfv( coord, pname, params );
754 }
755
logGetTexGeniv(GLenum coord,GLenum pname,GLint * params)756 static void APIENTRY logGetTexGeniv(GLenum coord, GLenum pname, GLint *params)
757 {
758 SIG( "glGetTexGeniv" );
759 dllGetTexGeniv( coord, pname, params );
760 }
761
logGetTexImage(GLenum target,GLint level,GLenum format,GLenum type,void * pixels)762 static void APIENTRY logGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, void *pixels)
763 {
764 SIG( "glGetTexImage" );
765 dllGetTexImage( target, level, format, type, pixels );
766 }
logGetTexLevelParameterfv(GLenum target,GLint level,GLenum pname,GLfloat * params)767 static void APIENTRY logGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params )
768 {
769 SIG( "glGetTexLevelParameterfv" );
770 dllGetTexLevelParameterfv( target, level, pname, params );
771 }
772
logGetTexLevelParameteriv(GLenum target,GLint level,GLenum pname,GLint * params)773 static void APIENTRY logGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
774 {
775 SIG( "glGetTexLevelParameteriv" );
776 dllGetTexLevelParameteriv( target, level, pname, params );
777 }
778
logGetTexParameterfv(GLenum target,GLenum pname,GLfloat * params)779 static void APIENTRY logGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
780 {
781 SIG( "glGetTexParameterfv" );
782 dllGetTexParameterfv( target, pname, params );
783 }
784
logGetTexParameteriv(GLenum target,GLenum pname,GLint * params)785 static void APIENTRY logGetTexParameteriv(GLenum target, GLenum pname, GLint *params)
786 {
787 SIG( "glGetTexParameteriv" );
788 dllGetTexParameteriv( target, pname, params );
789 }
790
logHint(GLenum target,GLenum mode)791 static void APIENTRY logHint(GLenum target, GLenum mode)
792 {
793 fprintf( glw_state.log_fp, "glHint( 0x%x, 0x%x )\n", target, mode );
794 dllHint( target, mode );
795 }
796
logIndexMask(GLuint mask)797 static void APIENTRY logIndexMask(GLuint mask)
798 {
799 SIG( "glIndexMask" );
800 dllIndexMask( mask );
801 }
802
logIndexPointer(GLenum type,GLsizei stride,const void * pointer)803 static void APIENTRY logIndexPointer(GLenum type, GLsizei stride, const void *pointer)
804 {
805 SIG( "glIndexPointer" );
806 dllIndexPointer( type, stride, pointer );
807 }
808
logIndexd(GLdouble c)809 static void APIENTRY logIndexd(GLdouble c)
810 {
811 SIG( "glIndexd" );
812 dllIndexd( c );
813 }
814
logIndexdv(const GLdouble * c)815 static void APIENTRY logIndexdv(const GLdouble *c)
816 {
817 SIG( "glIndexdv" );
818 dllIndexdv( c );
819 }
820
logIndexf(GLfloat c)821 static void APIENTRY logIndexf(GLfloat c)
822 {
823 SIG( "glIndexf" );
824 dllIndexf( c );
825 }
826
logIndexfv(const GLfloat * c)827 static void APIENTRY logIndexfv(const GLfloat *c)
828 {
829 SIG( "glIndexfv" );
830 dllIndexfv( c );
831 }
832
logIndexi(GLint c)833 static void APIENTRY logIndexi(GLint c)
834 {
835 SIG( "glIndexi" );
836 dllIndexi( c );
837 }
838
logIndexiv(const GLint * c)839 static void APIENTRY logIndexiv(const GLint *c)
840 {
841 SIG( "glIndexiv" );
842 dllIndexiv( c );
843 }
844
logIndexs(GLshort c)845 static void APIENTRY logIndexs(GLshort c)
846 {
847 SIG( "glIndexs" );
848 dllIndexs( c );
849 }
850
logIndexsv(const GLshort * c)851 static void APIENTRY logIndexsv(const GLshort *c)
852 {
853 SIG( "glIndexsv" );
854 dllIndexsv( c );
855 }
856
logIndexub(GLubyte c)857 static void APIENTRY logIndexub(GLubyte c)
858 {
859 SIG( "glIndexub" );
860 dllIndexub( c );
861 }
862
logIndexubv(const GLubyte * c)863 static void APIENTRY logIndexubv(const GLubyte *c)
864 {
865 SIG( "glIndexubv" );
866 dllIndexubv( c );
867 }
868
logInitNames(void)869 static void APIENTRY logInitNames(void)
870 {
871 SIG( "glInitNames" );
872 dllInitNames();
873 }
874
logInterleavedArrays(GLenum format,GLsizei stride,const void * pointer)875 static void APIENTRY logInterleavedArrays(GLenum format, GLsizei stride, const void *pointer)
876 {
877 SIG( "glInterleavedArrays" );
878 dllInterleavedArrays( format, stride, pointer );
879 }
880
logIsEnabled(GLenum cap)881 static GLboolean APIENTRY logIsEnabled(GLenum cap)
882 {
883 SIG( "glIsEnabled" );
884 return dllIsEnabled( cap );
885 }
logIsList(GLuint list)886 static GLboolean APIENTRY logIsList(GLuint list)
887 {
888 SIG( "glIsList" );
889 return dllIsList( list );
890 }
logIsTexture(GLuint texture)891 static GLboolean APIENTRY logIsTexture(GLuint texture)
892 {
893 SIG( "glIsTexture" );
894 return dllIsTexture( texture );
895 }
896
logLightModelf(GLenum pname,GLfloat param)897 static void APIENTRY logLightModelf(GLenum pname, GLfloat param)
898 {
899 SIG( "glLightModelf" );
900 dllLightModelf( pname, param );
901 }
902
logLightModelfv(GLenum pname,const GLfloat * params)903 static void APIENTRY logLightModelfv(GLenum pname, const GLfloat *params)
904 {
905 SIG( "glLightModelfv" );
906 dllLightModelfv( pname, params );
907 }
908
logLightModeli(GLenum pname,GLint param)909 static void APIENTRY logLightModeli(GLenum pname, GLint param)
910 {
911 SIG( "glLightModeli" );
912 dllLightModeli( pname, param );
913
914 }
915
logLightModeliv(GLenum pname,const GLint * params)916 static void APIENTRY logLightModeliv(GLenum pname, const GLint *params)
917 {
918 SIG( "glLightModeliv" );
919 dllLightModeliv( pname, params );
920 }
921
logLightf(GLenum light,GLenum pname,GLfloat param)922 static void APIENTRY logLightf(GLenum light, GLenum pname, GLfloat param)
923 {
924 SIG( "glLightf" );
925 dllLightf( light, pname, param );
926 }
927
logLightfv(GLenum light,GLenum pname,const GLfloat * params)928 static void APIENTRY logLightfv(GLenum light, GLenum pname, const GLfloat *params)
929 {
930 SIG( "glLightfv" );
931 dllLightfv( light, pname, params );
932 }
933
logLighti(GLenum light,GLenum pname,GLint param)934 static void APIENTRY logLighti(GLenum light, GLenum pname, GLint param)
935 {
936 SIG( "glLighti" );
937 dllLighti( light, pname, param );
938 }
939
logLightiv(GLenum light,GLenum pname,const GLint * params)940 static void APIENTRY logLightiv(GLenum light, GLenum pname, const GLint *params)
941 {
942 SIG( "glLightiv" );
943 dllLightiv( light, pname, params );
944 }
945
logLineStipple(GLint factor,GLushort pattern)946 static void APIENTRY logLineStipple(GLint factor, GLushort pattern)
947 {
948 SIG( "glLineStipple" );
949 dllLineStipple( factor, pattern );
950 }
951
logLineWidth(GLfloat width)952 static void APIENTRY logLineWidth(GLfloat width)
953 {
954 SIG( "glLineWidth" );
955 dllLineWidth( width );
956 }
957
logListBase(GLuint base)958 static void APIENTRY logListBase(GLuint base)
959 {
960 SIG( "glListBase" );
961 dllListBase( base );
962 }
963
logLoadIdentity(void)964 static void APIENTRY logLoadIdentity(void)
965 {
966 SIG( "glLoadIdentity" );
967 dllLoadIdentity();
968 }
969
logLoadMatrixd(const GLdouble * m)970 static void APIENTRY logLoadMatrixd(const GLdouble *m)
971 {
972 SIG( "glLoadMatrixd" );
973 dllLoadMatrixd( m );
974 }
975
logLoadMatrixf(const GLfloat * m)976 static void APIENTRY logLoadMatrixf(const GLfloat *m)
977 {
978 SIG( "glLoadMatrixf" );
979 dllLoadMatrixf( m );
980 }
981
logLoadName(GLuint name)982 static void APIENTRY logLoadName(GLuint name)
983 {
984 SIG( "glLoadName" );
985 dllLoadName( name );
986 }
987
logLogicOp(GLenum opcode)988 static void APIENTRY logLogicOp(GLenum opcode)
989 {
990 SIG( "glLogicOp" );
991 dllLogicOp( opcode );
992 }
993
logMap1d(GLenum target,GLdouble u1,GLdouble u2,GLint stride,GLint order,const GLdouble * points)994 static void APIENTRY logMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points)
995 {
996 SIG( "glMap1d" );
997 dllMap1d( target, u1, u2, stride, order, points );
998 }
999
logMap1f(GLenum target,GLfloat u1,GLfloat u2,GLint stride,GLint order,const GLfloat * points)1000 static void APIENTRY logMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points)
1001 {
1002 SIG( "glMap1f" );
1003 dllMap1f( target, u1, u2, stride, order, points );
1004 }
1005
logMap2d(GLenum target,GLdouble u1,GLdouble u2,GLint ustride,GLint uorder,GLdouble v1,GLdouble v2,GLint vstride,GLint vorder,const GLdouble * points)1006 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)
1007 {
1008 SIG( "glMap2d" );
1009 dllMap2d( target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points );
1010 }
1011
logMap2f(GLenum target,GLfloat u1,GLfloat u2,GLint ustride,GLint uorder,GLfloat v1,GLfloat v2,GLint vstride,GLint vorder,const GLfloat * points)1012 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)
1013 {
1014 SIG( "glMap2f" );
1015 dllMap2f( target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points );
1016 }
1017
logMapGrid1d(GLint un,GLdouble u1,GLdouble u2)1018 static void APIENTRY logMapGrid1d(GLint un, GLdouble u1, GLdouble u2)
1019 {
1020 SIG( "glMapGrid1d" );
1021 dllMapGrid1d( un, u1, u2 );
1022 }
1023
logMapGrid1f(GLint un,GLfloat u1,GLfloat u2)1024 static void APIENTRY logMapGrid1f(GLint un, GLfloat u1, GLfloat u2)
1025 {
1026 SIG( "glMapGrid1f" );
1027 dllMapGrid1f( un, u1, u2 );
1028 }
1029
logMapGrid2d(GLint un,GLdouble u1,GLdouble u2,GLint vn,GLdouble v1,GLdouble v2)1030 static void APIENTRY logMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2)
1031 {
1032 SIG( "glMapGrid2d" );
1033 dllMapGrid2d( un, u1, u2, vn, v1, v2 );
1034 }
logMapGrid2f(GLint un,GLfloat u1,GLfloat u2,GLint vn,GLfloat v1,GLfloat v2)1035 static void APIENTRY logMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)
1036 {
1037 SIG( "glMapGrid2f" );
1038 dllMapGrid2f( un, u1, u2, vn, v1, v2 );
1039 }
logMaterialf(GLenum face,GLenum pname,GLfloat param)1040 static void APIENTRY logMaterialf(GLenum face, GLenum pname, GLfloat param)
1041 {
1042 SIG( "glMaterialf" );
1043 dllMaterialf( face, pname, param );
1044 }
logMaterialfv(GLenum face,GLenum pname,const GLfloat * params)1045 static void APIENTRY logMaterialfv(GLenum face, GLenum pname, const GLfloat *params)
1046 {
1047 SIG( "glMaterialfv" );
1048 dllMaterialfv( face, pname, params );
1049 }
1050
logMateriali(GLenum face,GLenum pname,GLint param)1051 static void APIENTRY logMateriali(GLenum face, GLenum pname, GLint param)
1052 {
1053 SIG( "glMateriali" );
1054 dllMateriali( face, pname, param );
1055 }
1056
logMaterialiv(GLenum face,GLenum pname,const GLint * params)1057 static void APIENTRY logMaterialiv(GLenum face, GLenum pname, const GLint *params)
1058 {
1059 SIG( "glMaterialiv" );
1060 dllMaterialiv( face, pname, params );
1061 }
1062
logMatrixMode(GLenum mode)1063 static void APIENTRY logMatrixMode(GLenum mode)
1064 {
1065 SIG( "glMatrixMode" );
1066 dllMatrixMode( mode );
1067 }
1068
logMultMatrixd(const GLdouble * m)1069 static void APIENTRY logMultMatrixd(const GLdouble *m)
1070 {
1071 SIG( "glMultMatrixd" );
1072 dllMultMatrixd( m );
1073 }
1074
logMultMatrixf(const GLfloat * m)1075 static void APIENTRY logMultMatrixf(const GLfloat *m)
1076 {
1077 SIG( "glMultMatrixf" );
1078 dllMultMatrixf( m );
1079 }
1080
logNewList(GLuint list,GLenum mode)1081 static void APIENTRY logNewList(GLuint list, GLenum mode)
1082 {
1083 SIG( "glNewList" );
1084 dllNewList( list, mode );
1085 }
1086
logNormal3b(GLbyte nx,GLbyte ny,GLbyte nz)1087 static void APIENTRY logNormal3b(GLbyte nx, GLbyte ny, GLbyte nz)
1088 {
1089 SIG ("glNormal3b" );
1090 dllNormal3b( nx, ny, nz );
1091 }
1092
logNormal3bv(const GLbyte * v)1093 static void APIENTRY logNormal3bv(const GLbyte *v)
1094 {
1095 SIG( "glNormal3bv" );
1096 dllNormal3bv( v );
1097 }
1098
logNormal3d(GLdouble nx,GLdouble ny,GLdouble nz)1099 static void APIENTRY logNormal3d(GLdouble nx, GLdouble ny, GLdouble nz)
1100 {
1101 SIG( "glNormal3d" );
1102 dllNormal3d( nx, ny, nz );
1103 }
1104
logNormal3dv(const GLdouble * v)1105 static void APIENTRY logNormal3dv(const GLdouble *v)
1106 {
1107 SIG( "glNormal3dv" );
1108 dllNormal3dv( v );
1109 }
1110
logNormal3f(GLfloat nx,GLfloat ny,GLfloat nz)1111 static void APIENTRY logNormal3f(GLfloat nx, GLfloat ny, GLfloat nz)
1112 {
1113 SIG( "glNormal3f" );
1114 dllNormal3f( nx, ny, nz );
1115 }
1116
logNormal3fv(const GLfloat * v)1117 static void APIENTRY logNormal3fv(const GLfloat *v)
1118 {
1119 SIG( "glNormal3fv" );
1120 dllNormal3fv( v );
1121 }
logNormal3i(GLint nx,GLint ny,GLint nz)1122 static void APIENTRY logNormal3i(GLint nx, GLint ny, GLint nz)
1123 {
1124 SIG( "glNormal3i" );
1125 dllNormal3i( nx, ny, nz );
1126 }
logNormal3iv(const GLint * v)1127 static void APIENTRY logNormal3iv(const GLint *v)
1128 {
1129 SIG( "glNormal3iv" );
1130 dllNormal3iv( v );
1131 }
logNormal3s(GLshort nx,GLshort ny,GLshort nz)1132 static void APIENTRY logNormal3s(GLshort nx, GLshort ny, GLshort nz)
1133 {
1134 SIG( "glNormal3s" );
1135 dllNormal3s( nx, ny, nz );
1136 }
logNormal3sv(const GLshort * v)1137 static void APIENTRY logNormal3sv(const GLshort *v)
1138 {
1139 SIG( "glNormal3sv" );
1140 dllNormal3sv( v );
1141 }
logNormalPointer(GLenum type,GLsizei stride,const void * pointer)1142 static void APIENTRY logNormalPointer(GLenum type, GLsizei stride, const void *pointer)
1143 {
1144 SIG( "glNormalPointer" );
1145 dllNormalPointer( type, stride, pointer );
1146 }
logOrtho(GLdouble left,GLdouble right,GLdouble bottom,GLdouble top,GLdouble zNear,GLdouble zFar)1147 static void APIENTRY logOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
1148 {
1149 SIG( "glOrtho" );
1150 dllOrtho( left, right, bottom, top, zNear, zFar );
1151 }
1152
logPassThrough(GLfloat token)1153 static void APIENTRY logPassThrough(GLfloat token)
1154 {
1155 SIG( "glPassThrough" );
1156 dllPassThrough( token );
1157 }
1158
logPixelMapfv(GLenum map,GLsizei mapsize,const GLfloat * values)1159 static void APIENTRY logPixelMapfv(GLenum map, GLsizei mapsize, const GLfloat *values)
1160 {
1161 SIG( "glPixelMapfv" );
1162 dllPixelMapfv( map, mapsize, values );
1163 }
1164
logPixelMapuiv(GLenum map,GLsizei mapsize,const GLuint * values)1165 static void APIENTRY logPixelMapuiv(GLenum map, GLsizei mapsize, const GLuint *values)
1166 {
1167 SIG( "glPixelMapuiv" );
1168 dllPixelMapuiv( map, mapsize, values );
1169 }
1170
logPixelMapusv(GLenum map,GLsizei mapsize,const GLushort * values)1171 static void APIENTRY logPixelMapusv(GLenum map, GLsizei mapsize, const GLushort *values)
1172 {
1173 SIG( "glPixelMapusv" );
1174 dllPixelMapusv( map, mapsize, values );
1175 }
logPixelStoref(GLenum pname,GLfloat param)1176 static void APIENTRY logPixelStoref(GLenum pname, GLfloat param)
1177 {
1178 SIG( "glPixelStoref" );
1179 dllPixelStoref( pname, param );
1180 }
logPixelStorei(GLenum pname,GLint param)1181 static void APIENTRY logPixelStorei(GLenum pname, GLint param)
1182 {
1183 SIG( "glPixelStorei" );
1184 dllPixelStorei( pname, param );
1185 }
logPixelTransferf(GLenum pname,GLfloat param)1186 static void APIENTRY logPixelTransferf(GLenum pname, GLfloat param)
1187 {
1188 SIG( "glPixelTransferf" );
1189 dllPixelTransferf( pname, param );
1190 }
1191
logPixelTransferi(GLenum pname,GLint param)1192 static void APIENTRY logPixelTransferi(GLenum pname, GLint param)
1193 {
1194 SIG( "glPixelTransferi" );
1195 dllPixelTransferi( pname, param );
1196 }
1197
logPixelZoom(GLfloat xfactor,GLfloat yfactor)1198 static void APIENTRY logPixelZoom(GLfloat xfactor, GLfloat yfactor)
1199 {
1200 SIG( "glPixelZoom" );
1201 dllPixelZoom( xfactor, yfactor );
1202 }
1203
logPointSize(GLfloat size)1204 static void APIENTRY logPointSize(GLfloat size)
1205 {
1206 SIG( "glPointSize" );
1207 dllPointSize( size );
1208 }
1209
logPolygonMode(GLenum face,GLenum mode)1210 static void APIENTRY logPolygonMode(GLenum face, GLenum mode)
1211 {
1212 fprintf( glw_state.log_fp, "glPolygonMode( 0x%x, 0x%x )\n", face, mode );
1213 dllPolygonMode( face, mode );
1214 }
1215
logPolygonOffset(GLfloat factor,GLfloat units)1216 static void APIENTRY logPolygonOffset(GLfloat factor, GLfloat units)
1217 {
1218 SIG( "glPolygonOffset" );
1219 dllPolygonOffset( factor, units );
1220 }
logPolygonStipple(const GLubyte * mask)1221 static void APIENTRY logPolygonStipple(const GLubyte *mask )
1222 {
1223 SIG( "glPolygonStipple" );
1224 dllPolygonStipple( mask );
1225 }
logPopAttrib(void)1226 static void APIENTRY logPopAttrib(void)
1227 {
1228 SIG( "glPopAttrib" );
1229 dllPopAttrib();
1230 }
1231
logPopClientAttrib(void)1232 static void APIENTRY logPopClientAttrib(void)
1233 {
1234 SIG( "glPopClientAttrib" );
1235 dllPopClientAttrib();
1236 }
1237
logPopMatrix(void)1238 static void APIENTRY logPopMatrix(void)
1239 {
1240 SIG( "glPopMatrix" );
1241 dllPopMatrix();
1242 }
1243
logPopName(void)1244 static void APIENTRY logPopName(void)
1245 {
1246 SIG( "glPopName" );
1247 dllPopName();
1248 }
1249
logPrioritizeTextures(GLsizei n,const GLuint * textures,const GLclampf * priorities)1250 static void APIENTRY logPrioritizeTextures(GLsizei n, const GLuint *textures, const GLclampf *priorities)
1251 {
1252 SIG( "glPrioritizeTextures" );
1253 dllPrioritizeTextures( n, textures, priorities );
1254 }
1255
logPushAttrib(GLbitfield mask)1256 static void APIENTRY logPushAttrib(GLbitfield mask)
1257 {
1258 SIG( "glPushAttrib" );
1259 dllPushAttrib( mask );
1260 }
1261
logPushClientAttrib(GLbitfield mask)1262 static void APIENTRY logPushClientAttrib(GLbitfield mask)
1263 {
1264 SIG( "glPushClientAttrib" );
1265 dllPushClientAttrib( mask );
1266 }
1267
logPushMatrix(void)1268 static void APIENTRY logPushMatrix(void)
1269 {
1270 SIG( "glPushMatrix" );
1271 dllPushMatrix();
1272 }
1273
logPushName(GLuint name)1274 static void APIENTRY logPushName(GLuint name)
1275 {
1276 SIG( "glPushName" );
1277 dllPushName( name );
1278 }
1279
logRasterPos2d(GLdouble x,GLdouble y)1280 static void APIENTRY logRasterPos2d(GLdouble x, GLdouble y)
1281 {
1282 SIG ("glRasterPot2d" );
1283 dllRasterPos2d( x, y );
1284 }
1285
logRasterPos2dv(const GLdouble * v)1286 static void APIENTRY logRasterPos2dv(const GLdouble *v)
1287 {
1288 SIG( "glRasterPos2dv" );
1289 dllRasterPos2dv( v );
1290 }
1291
logRasterPos2f(GLfloat x,GLfloat y)1292 static void APIENTRY logRasterPos2f(GLfloat x, GLfloat y)
1293 {
1294 SIG( "glRasterPos2f" );
1295 dllRasterPos2f( x, y );
1296 }
logRasterPos2fv(const GLfloat * v)1297 static void APIENTRY logRasterPos2fv(const GLfloat *v)
1298 {
1299 SIG( "glRasterPos2dv" );
1300 dllRasterPos2fv( v );
1301 }
logRasterPos2i(GLint x,GLint y)1302 static void APIENTRY logRasterPos2i(GLint x, GLint y)
1303 {
1304 SIG( "glRasterPos2if" );
1305 dllRasterPos2i( x, y );
1306 }
logRasterPos2iv(const GLint * v)1307 static void APIENTRY logRasterPos2iv(const GLint *v)
1308 {
1309 SIG( "glRasterPos2iv" );
1310 dllRasterPos2iv( v );
1311 }
logRasterPos2s(GLshort x,GLshort y)1312 static void APIENTRY logRasterPos2s(GLshort x, GLshort y)
1313 {
1314 SIG( "glRasterPos2s" );
1315 dllRasterPos2s( x, y );
1316 }
logRasterPos2sv(const GLshort * v)1317 static void APIENTRY logRasterPos2sv(const GLshort *v)
1318 {
1319 SIG( "glRasterPos2sv" );
1320 dllRasterPos2sv( v );
1321 }
logRasterPos3d(GLdouble x,GLdouble y,GLdouble z)1322 static void APIENTRY logRasterPos3d(GLdouble x, GLdouble y, GLdouble z)
1323 {
1324 SIG( "glRasterPos3d" );
1325 dllRasterPos3d( x, y, z );
1326 }
logRasterPos3dv(const GLdouble * v)1327 static void APIENTRY logRasterPos3dv(const GLdouble *v)
1328 {
1329 SIG( "glRasterPos3dv" );
1330 dllRasterPos3dv( v );
1331 }
logRasterPos3f(GLfloat x,GLfloat y,GLfloat z)1332 static void APIENTRY logRasterPos3f(GLfloat x, GLfloat y, GLfloat z)
1333 {
1334 SIG( "glRasterPos3f" );
1335 dllRasterPos3f( x, y, z );
1336 }
logRasterPos3fv(const GLfloat * v)1337 static void APIENTRY logRasterPos3fv(const GLfloat *v)
1338 {
1339 SIG( "glRasterPos3fv" );
1340 dllRasterPos3fv( v );
1341 }
logRasterPos3i(GLint x,GLint y,GLint z)1342 static void APIENTRY logRasterPos3i(GLint x, GLint y, GLint z)
1343 {
1344 SIG( "glRasterPos3i" );
1345 dllRasterPos3i( x, y, z );
1346 }
logRasterPos3iv(const GLint * v)1347 static void APIENTRY logRasterPos3iv(const GLint *v)
1348 {
1349 SIG( "glRasterPos3iv" );
1350 dllRasterPos3iv( v );
1351 }
logRasterPos3s(GLshort x,GLshort y,GLshort z)1352 static void APIENTRY logRasterPos3s(GLshort x, GLshort y, GLshort z)
1353 {
1354 SIG( "glRasterPos3s" );
1355 dllRasterPos3s( x, y, z );
1356 }
logRasterPos3sv(const GLshort * v)1357 static void APIENTRY logRasterPos3sv(const GLshort *v)
1358 {
1359 SIG( "glRasterPos3sv" );
1360 dllRasterPos3sv( v );
1361 }
logRasterPos4d(GLdouble x,GLdouble y,GLdouble z,GLdouble w)1362 static void APIENTRY logRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
1363 {
1364 SIG( "glRasterPos4d" );
1365 dllRasterPos4d( x, y, z, w );
1366 }
logRasterPos4dv(const GLdouble * v)1367 static void APIENTRY logRasterPos4dv(const GLdouble *v)
1368 {
1369 SIG( "glRasterPos4dv" );
1370 dllRasterPos4dv( v );
1371 }
logRasterPos4f(GLfloat x,GLfloat y,GLfloat z,GLfloat w)1372 static void APIENTRY logRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
1373 {
1374 SIG( "glRasterPos4f" );
1375 dllRasterPos4f( x, y, z, w );
1376 }
logRasterPos4fv(const GLfloat * v)1377 static void APIENTRY logRasterPos4fv(const GLfloat *v)
1378 {
1379 SIG( "glRasterPos4fv" );
1380 dllRasterPos4fv( v );
1381 }
logRasterPos4i(GLint x,GLint y,GLint z,GLint w)1382 static void APIENTRY logRasterPos4i(GLint x, GLint y, GLint z, GLint w)
1383 {
1384 SIG( "glRasterPos4i" );
1385 dllRasterPos4i( x, y, z, w );
1386 }
logRasterPos4iv(const GLint * v)1387 static void APIENTRY logRasterPos4iv(const GLint *v)
1388 {
1389 SIG( "glRasterPos4iv" );
1390 dllRasterPos4iv( v );
1391 }
logRasterPos4s(GLshort x,GLshort y,GLshort z,GLshort w)1392 static void APIENTRY logRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)
1393 {
1394 SIG( "glRasterPos4s" );
1395 dllRasterPos4s( x, y, z, w );
1396 }
logRasterPos4sv(const GLshort * v)1397 static void APIENTRY logRasterPos4sv(const GLshort *v)
1398 {
1399 SIG( "glRasterPos4sv" );
1400 dllRasterPos4sv( v );
1401 }
logReadBuffer(GLenum mode)1402 static void APIENTRY logReadBuffer(GLenum mode)
1403 {
1404 SIG( "glReadBuffer" );
1405 dllReadBuffer( mode );
1406 }
logReadPixels(GLint x,GLint y,GLsizei width,GLsizei height,GLenum format,GLenum type,void * pixels)1407 static void APIENTRY logReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *pixels)
1408 {
1409 SIG( "glReadPixels" );
1410 dllReadPixels( x, y, width, height, format, type, pixels );
1411 }
1412
logRectd(GLdouble x1,GLdouble y1,GLdouble x2,GLdouble y2)1413 static void APIENTRY logRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
1414 {
1415 SIG( "glRectd" );
1416 dllRectd( x1, y1, x2, y2 );
1417 }
1418
logRectdv(const GLdouble * v1,const GLdouble * v2)1419 static void APIENTRY logRectdv(const GLdouble *v1, const GLdouble *v2)
1420 {
1421 SIG( "glRectdv" );
1422 dllRectdv( v1, v2 );
1423 }
1424
logRectf(GLfloat x1,GLfloat y1,GLfloat x2,GLfloat y2)1425 static void APIENTRY logRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
1426 {
1427 SIG( "glRectf" );
1428 dllRectf( x1, y1, x2, y2 );
1429 }
1430
logRectfv(const GLfloat * v1,const GLfloat * v2)1431 static void APIENTRY logRectfv(const GLfloat *v1, const GLfloat *v2)
1432 {
1433 SIG( "glRectfv" );
1434 dllRectfv( v1, v2 );
1435 }
logRecti(GLint x1,GLint y1,GLint x2,GLint y2)1436 static void APIENTRY logRecti(GLint x1, GLint y1, GLint x2, GLint y2)
1437 {
1438 SIG( "glRecti" );
1439 dllRecti( x1, y1, x2, y2 );
1440 }
logRectiv(const GLint * v1,const GLint * v2)1441 static void APIENTRY logRectiv(const GLint *v1, const GLint *v2)
1442 {
1443 SIG( "glRectiv" );
1444 dllRectiv( v1, v2 );
1445 }
logRects(GLshort x1,GLshort y1,GLshort x2,GLshort y2)1446 static void APIENTRY logRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2)
1447 {
1448 SIG( "glRects" );
1449 dllRects( x1, y1, x2, y2 );
1450 }
logRectsv(const GLshort * v1,const GLshort * v2)1451 static void APIENTRY logRectsv(const GLshort *v1, const GLshort *v2)
1452 {
1453 SIG( "glRectsv" );
1454 dllRectsv( v1, v2 );
1455 }
logRenderMode(GLenum mode)1456 static GLint APIENTRY logRenderMode(GLenum mode)
1457 {
1458 SIG( "glRenderMode" );
1459 return dllRenderMode( mode );
1460 }
logRotated(GLdouble angle,GLdouble x,GLdouble y,GLdouble z)1461 static void APIENTRY logRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
1462 {
1463 SIG( "glRotated" );
1464 dllRotated( angle, x, y, z );
1465 }
1466
logRotatef(GLfloat angle,GLfloat x,GLfloat y,GLfloat z)1467 static void APIENTRY logRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
1468 {
1469 SIG( "glRotatef" );
1470 dllRotatef( angle, x, y, z );
1471 }
1472
logScaled(GLdouble x,GLdouble y,GLdouble z)1473 static void APIENTRY logScaled(GLdouble x, GLdouble y, GLdouble z)
1474 {
1475 SIG( "glScaled" );
1476 dllScaled( x, y, z );
1477 }
1478
logScalef(GLfloat x,GLfloat y,GLfloat z)1479 static void APIENTRY logScalef(GLfloat x, GLfloat y, GLfloat z)
1480 {
1481 SIG( "glScalef" );
1482 dllScalef( x, y, z );
1483 }
1484
logScissor(GLint x,GLint y,GLsizei width,GLsizei height)1485 static void APIENTRY logScissor(GLint x, GLint y, GLsizei width, GLsizei height)
1486 {
1487 SIG( "glScissor" );
1488 dllScissor( x, y, width, height );
1489 }
1490
logSelectBuffer(GLsizei size,GLuint * buffer)1491 static void APIENTRY logSelectBuffer(GLsizei size, GLuint *buffer)
1492 {
1493 SIG( "glSelectBuffer" );
1494 dllSelectBuffer( size, buffer );
1495 }
1496
logShadeModel(GLenum mode)1497 static void APIENTRY logShadeModel(GLenum mode)
1498 {
1499 SIG( "glShadeModel" );
1500 dllShadeModel( mode );
1501 }
1502
logStencilFunc(GLenum func,GLint ref,GLuint mask)1503 static void APIENTRY logStencilFunc(GLenum func, GLint ref, GLuint mask)
1504 {
1505 SIG( "glStencilFunc" );
1506 dllStencilFunc( func, ref, mask );
1507 }
1508
logStencilMask(GLuint mask)1509 static void APIENTRY logStencilMask(GLuint mask)
1510 {
1511 SIG( "glStencilMask" );
1512 dllStencilMask( mask );
1513 }
1514
logStencilOp(GLenum fail,GLenum zfail,GLenum zpass)1515 static void APIENTRY logStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
1516 {
1517 SIG( "glStencilOp" );
1518 dllStencilOp( fail, zfail, zpass );
1519 }
1520
logTexCoord1d(GLdouble s)1521 static void APIENTRY logTexCoord1d(GLdouble s)
1522 {
1523 SIG( "glTexCoord1d" );
1524 dllTexCoord1d( s );
1525 }
1526
logTexCoord1dv(const GLdouble * v)1527 static void APIENTRY logTexCoord1dv(const GLdouble *v)
1528 {
1529 SIG( "glTexCoord1dv" );
1530 dllTexCoord1dv( v );
1531 }
1532
logTexCoord1f(GLfloat s)1533 static void APIENTRY logTexCoord1f(GLfloat s)
1534 {
1535 SIG( "glTexCoord1f" );
1536 dllTexCoord1f( s );
1537 }
logTexCoord1fv(const GLfloat * v)1538 static void APIENTRY logTexCoord1fv(const GLfloat *v)
1539 {
1540 SIG( "glTexCoord1fv" );
1541 dllTexCoord1fv( v );
1542 }
logTexCoord1i(GLint s)1543 static void APIENTRY logTexCoord1i(GLint s)
1544 {
1545 SIG( "glTexCoord1i" );
1546 dllTexCoord1i( s );
1547 }
logTexCoord1iv(const GLint * v)1548 static void APIENTRY logTexCoord1iv(const GLint *v)
1549 {
1550 SIG( "glTexCoord1iv" );
1551 dllTexCoord1iv( v );
1552 }
logTexCoord1s(GLshort s)1553 static void APIENTRY logTexCoord1s(GLshort s)
1554 {
1555 SIG( "glTexCoord1s" );
1556 dllTexCoord1s( s );
1557 }
logTexCoord1sv(const GLshort * v)1558 static void APIENTRY logTexCoord1sv(const GLshort *v)
1559 {
1560 SIG( "glTexCoord1sv" );
1561 dllTexCoord1sv( v );
1562 }
logTexCoord2d(GLdouble s,GLdouble t)1563 static void APIENTRY logTexCoord2d(GLdouble s, GLdouble t)
1564 {
1565 SIG( "glTexCoord2d" );
1566 dllTexCoord2d( s, t );
1567 }
1568
logTexCoord2dv(const GLdouble * v)1569 static void APIENTRY logTexCoord2dv(const GLdouble *v)
1570 {
1571 SIG( "glTexCoord2dv" );
1572 dllTexCoord2dv( v );
1573 }
logTexCoord2f(GLfloat s,GLfloat t)1574 static void APIENTRY logTexCoord2f(GLfloat s, GLfloat t)
1575 {
1576 SIG( "glTexCoord2f" );
1577 dllTexCoord2f( s, t );
1578 }
logTexCoord2fv(const GLfloat * v)1579 static void APIENTRY logTexCoord2fv(const GLfloat *v)
1580 {
1581 SIG( "glTexCoord2fv" );
1582 dllTexCoord2fv( v );
1583 }
logTexCoord2i(GLint s,GLint t)1584 static void APIENTRY logTexCoord2i(GLint s, GLint t)
1585 {
1586 SIG( "glTexCoord2i" );
1587 dllTexCoord2i( s, t );
1588 }
logTexCoord2iv(const GLint * v)1589 static void APIENTRY logTexCoord2iv(const GLint *v)
1590 {
1591 SIG( "glTexCoord2iv" );
1592 dllTexCoord2iv( v );
1593 }
logTexCoord2s(GLshort s,GLshort t)1594 static void APIENTRY logTexCoord2s(GLshort s, GLshort t)
1595 {
1596 SIG( "glTexCoord2s" );
1597 dllTexCoord2s( s, t );
1598 }
logTexCoord2sv(const GLshort * v)1599 static void APIENTRY logTexCoord2sv(const GLshort *v)
1600 {
1601 SIG( "glTexCoord2sv" );
1602 dllTexCoord2sv( v );
1603 }
logTexCoord3d(GLdouble s,GLdouble t,GLdouble r)1604 static void APIENTRY logTexCoord3d(GLdouble s, GLdouble t, GLdouble r)
1605 {
1606 SIG( "glTexCoord3d" );
1607 dllTexCoord3d( s, t, r );
1608 }
logTexCoord3dv(const GLdouble * v)1609 static void APIENTRY logTexCoord3dv(const GLdouble *v)
1610 {
1611 SIG( "glTexCoord3dv" );
1612 dllTexCoord3dv( v );
1613 }
logTexCoord3f(GLfloat s,GLfloat t,GLfloat r)1614 static void APIENTRY logTexCoord3f(GLfloat s, GLfloat t, GLfloat r)
1615 {
1616 SIG( "glTexCoord3f" );
1617 dllTexCoord3f( s, t, r );
1618 }
logTexCoord3fv(const GLfloat * v)1619 static void APIENTRY logTexCoord3fv(const GLfloat *v)
1620 {
1621 SIG( "glTexCoord3fv" );
1622 dllTexCoord3fv( v );
1623 }
logTexCoord3i(GLint s,GLint t,GLint r)1624 static void APIENTRY logTexCoord3i(GLint s, GLint t, GLint r)
1625 {
1626 SIG( "glTexCoord3i" );
1627 dllTexCoord3i( s, t, r );
1628 }
logTexCoord3iv(const GLint * v)1629 static void APIENTRY logTexCoord3iv(const GLint *v)
1630 {
1631 SIG( "glTexCoord3iv" );
1632 dllTexCoord3iv( v );
1633 }
logTexCoord3s(GLshort s,GLshort t,GLshort r)1634 static void APIENTRY logTexCoord3s(GLshort s, GLshort t, GLshort r)
1635 {
1636 SIG( "glTexCoord3s" );
1637 dllTexCoord3s( s, t, r );
1638 }
logTexCoord3sv(const GLshort * v)1639 static void APIENTRY logTexCoord3sv(const GLshort *v)
1640 {
1641 SIG( "glTexCoord3sv" );
1642 dllTexCoord3sv( v );
1643 }
logTexCoord4d(GLdouble s,GLdouble t,GLdouble r,GLdouble q)1644 static void APIENTRY logTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q)
1645 {
1646 SIG( "glTexCoord4d" );
1647 dllTexCoord4d( s, t, r, q );
1648 }
logTexCoord4dv(const GLdouble * v)1649 static void APIENTRY logTexCoord4dv(const GLdouble *v)
1650 {
1651 SIG( "glTexCoord4dv" );
1652 dllTexCoord4dv( v );
1653 }
logTexCoord4f(GLfloat s,GLfloat t,GLfloat r,GLfloat q)1654 static void APIENTRY logTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q)
1655 {
1656 SIG( "glTexCoord4f" );
1657 dllTexCoord4f( s, t, r, q );
1658 }
logTexCoord4fv(const GLfloat * v)1659 static void APIENTRY logTexCoord4fv(const GLfloat *v)
1660 {
1661 SIG( "glTexCoord4fv" );
1662 dllTexCoord4fv( v );
1663 }
logTexCoord4i(GLint s,GLint t,GLint r,GLint q)1664 static void APIENTRY logTexCoord4i(GLint s, GLint t, GLint r, GLint q)
1665 {
1666 SIG( "glTexCoord4i" );
1667 dllTexCoord4i( s, t, r, q );
1668 }
logTexCoord4iv(const GLint * v)1669 static void APIENTRY logTexCoord4iv(const GLint *v)
1670 {
1671 SIG( "glTexCoord4iv" );
1672 dllTexCoord4iv( v );
1673 }
logTexCoord4s(GLshort s,GLshort t,GLshort r,GLshort q)1674 static void APIENTRY logTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q)
1675 {
1676 SIG( "glTexCoord4s" );
1677 dllTexCoord4s( s, t, r, q );
1678 }
logTexCoord4sv(const GLshort * v)1679 static void APIENTRY logTexCoord4sv(const GLshort *v)
1680 {
1681 SIG( "glTexCoord4sv" );
1682 dllTexCoord4sv( v );
1683 }
logTexCoordPointer(GLint size,GLenum type,GLsizei stride,const void * pointer)1684 static void APIENTRY logTexCoordPointer(GLint size, GLenum type, GLsizei stride, const void *pointer)
1685 {
1686 SIG( "glTexCoordPointer" );
1687 dllTexCoordPointer( size, type, stride, pointer );
1688 }
1689
logTexEnvf(GLenum target,GLenum pname,GLfloat param)1690 static void APIENTRY logTexEnvf(GLenum target, GLenum pname, GLfloat param)
1691 {
1692 fprintf( glw_state.log_fp, "glTexEnvf( 0x%x, 0x%x, %f )\n", target, pname, param );
1693 dllTexEnvf( target, pname, param );
1694 }
1695
logTexEnvfv(GLenum target,GLenum pname,const GLfloat * params)1696 static void APIENTRY logTexEnvfv(GLenum target, GLenum pname, const GLfloat *params)
1697 {
1698 SIG( "glTexEnvfv" );
1699 dllTexEnvfv( target, pname, params );
1700 }
1701
logTexEnvi(GLenum target,GLenum pname,GLint param)1702 static void APIENTRY logTexEnvi(GLenum target, GLenum pname, GLint param)
1703 {
1704 fprintf( glw_state.log_fp, "glTexEnvi( 0x%x, 0x%x, 0x%x )\n", target, pname, param );
1705 dllTexEnvi( target, pname, param );
1706 }
logTexEnviv(GLenum target,GLenum pname,const GLint * params)1707 static void APIENTRY logTexEnviv(GLenum target, GLenum pname, const GLint *params)
1708 {
1709 SIG( "glTexEnviv" );
1710 dllTexEnviv( target, pname, params );
1711 }
1712
logTexGend(GLenum coord,GLenum pname,GLdouble param)1713 static void APIENTRY logTexGend(GLenum coord, GLenum pname, GLdouble param)
1714 {
1715 SIG( "glTexGend" );
1716 dllTexGend( coord, pname, param );
1717 }
1718
logTexGendv(GLenum coord,GLenum pname,const GLdouble * params)1719 static void APIENTRY logTexGendv(GLenum coord, GLenum pname, const GLdouble *params)
1720 {
1721 SIG( "glTexGendv" );
1722 dllTexGendv( coord, pname, params );
1723 }
1724
logTexGenf(GLenum coord,GLenum pname,GLfloat param)1725 static void APIENTRY logTexGenf(GLenum coord, GLenum pname, GLfloat param)
1726 {
1727 SIG( "glTexGenf" );
1728 dllTexGenf( coord, pname, param );
1729 }
logTexGenfv(GLenum coord,GLenum pname,const GLfloat * params)1730 static void APIENTRY logTexGenfv(GLenum coord, GLenum pname, const GLfloat *params)
1731 {
1732 SIG( "glTexGenfv" );
1733 dllTexGenfv( coord, pname, params );
1734 }
logTexGeni(GLenum coord,GLenum pname,GLint param)1735 static void APIENTRY logTexGeni(GLenum coord, GLenum pname, GLint param)
1736 {
1737 SIG( "glTexGeni" );
1738 dllTexGeni( coord, pname, param );
1739 }
logTexGeniv(GLenum coord,GLenum pname,const GLint * params)1740 static void APIENTRY logTexGeniv(GLenum coord, GLenum pname, const GLint *params)
1741 {
1742 SIG( "glTexGeniv" );
1743 dllTexGeniv( coord, pname, params );
1744 }
logTexImage1D(GLenum target,GLint level,GLint internalformat,GLsizei width,GLint border,GLenum format,GLenum type,const void * pixels)1745 static void APIENTRY logTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels)
1746 {
1747 SIG( "glTexImage1D" );
1748 dllTexImage1D( target, level, internalformat, width, border, format, type, pixels );
1749 }
logTexImage2D(GLenum target,GLint level,GLint internalformat,GLsizei width,GLsizei height,GLint border,GLenum format,GLenum type,const void * pixels)1750 static void APIENTRY logTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels)
1751 {
1752 SIG( "glTexImage2D" );
1753 dllTexImage2D( target, level, internalformat, width, height, border, format, type, pixels );
1754 }
1755
logTexParameterf(GLenum target,GLenum pname,GLfloat param)1756 static void APIENTRY logTexParameterf(GLenum target, GLenum pname, GLfloat param)
1757 {
1758 fprintf( glw_state.log_fp, "glTexParameterf( 0x%x, 0x%x, %f )\n", target, pname, param );
1759 dllTexParameterf( target, pname, param );
1760 }
1761
logTexParameterfv(GLenum target,GLenum pname,const GLfloat * params)1762 static void APIENTRY logTexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
1763 {
1764 SIG( "glTexParameterfv" );
1765 dllTexParameterfv( target, pname, params );
1766 }
logTexParameteri(GLenum target,GLenum pname,GLint param)1767 static void APIENTRY logTexParameteri(GLenum target, GLenum pname, GLint param)
1768 {
1769 fprintf( glw_state.log_fp, "glTexParameteri( 0x%x, 0x%x, 0x%x )\n", target, pname, param );
1770 dllTexParameteri( target, pname, param );
1771 }
logTexParameteriv(GLenum target,GLenum pname,const GLint * params)1772 static void APIENTRY logTexParameteriv(GLenum target, GLenum pname, const GLint *params)
1773 {
1774 SIG( "glTexParameteriv" );
1775 dllTexParameteriv( target, pname, params );
1776 }
logTexSubImage1D(GLenum target,GLint level,GLint xoffset,GLsizei width,GLenum format,GLenum type,const void * pixels)1777 static void APIENTRY logTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels)
1778 {
1779 SIG( "glTexSubImage1D" );
1780 dllTexSubImage1D( target, level, xoffset, width, format, type, pixels );
1781 }
logTexSubImage2D(GLenum target,GLint level,GLint xoffset,GLint yoffset,GLsizei width,GLsizei height,GLenum format,GLenum type,const void * pixels)1782 static void APIENTRY logTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels)
1783 {
1784 SIG( "glTexSubImage2D" );
1785 dllTexSubImage2D( target, level, xoffset, yoffset, width, height, format, type, pixels );
1786 }
logTranslated(GLdouble x,GLdouble y,GLdouble z)1787 static void APIENTRY logTranslated(GLdouble x, GLdouble y, GLdouble z)
1788 {
1789 SIG( "glTranslated" );
1790 dllTranslated( x, y, z );
1791 }
1792
logTranslatef(GLfloat x,GLfloat y,GLfloat z)1793 static void APIENTRY logTranslatef(GLfloat x, GLfloat y, GLfloat z)
1794 {
1795 SIG( "glTranslatef" );
1796 dllTranslatef( x, y, z );
1797 }
1798
logVertex2d(GLdouble x,GLdouble y)1799 static void APIENTRY logVertex2d(GLdouble x, GLdouble y)
1800 {
1801 SIG( "glVertex2d" );
1802 dllVertex2d( x, y );
1803 }
1804
logVertex2dv(const GLdouble * v)1805 static void APIENTRY logVertex2dv(const GLdouble *v)
1806 {
1807 SIG( "glVertex2dv" );
1808 dllVertex2dv( v );
1809 }
logVertex2f(GLfloat x,GLfloat y)1810 static void APIENTRY logVertex2f(GLfloat x, GLfloat y)
1811 {
1812 SIG( "glVertex2f" );
1813 dllVertex2f( x, y );
1814 }
logVertex2fv(const GLfloat * v)1815 static void APIENTRY logVertex2fv(const GLfloat *v)
1816 {
1817 SIG( "glVertex2fv" );
1818 dllVertex2fv( v );
1819 }
logVertex2i(GLint x,GLint y)1820 static void APIENTRY logVertex2i(GLint x, GLint y)
1821 {
1822 SIG( "glVertex2i" );
1823 dllVertex2i( x, y );
1824 }
logVertex2iv(const GLint * v)1825 static void APIENTRY logVertex2iv(const GLint *v)
1826 {
1827 SIG( "glVertex2iv" );
1828 dllVertex2iv( v );
1829 }
logVertex2s(GLshort x,GLshort y)1830 static void APIENTRY logVertex2s(GLshort x, GLshort y)
1831 {
1832 SIG( "glVertex2s" );
1833 dllVertex2s( x, y );
1834 }
logVertex2sv(const GLshort * v)1835 static void APIENTRY logVertex2sv(const GLshort *v)
1836 {
1837 SIG( "glVertex2sv" );
1838 dllVertex2sv( v );
1839 }
logVertex3d(GLdouble x,GLdouble y,GLdouble z)1840 static void APIENTRY logVertex3d(GLdouble x, GLdouble y, GLdouble z)
1841 {
1842 SIG( "glVertex3d" );
1843 dllVertex3d( x, y, z );
1844 }
logVertex3dv(const GLdouble * v)1845 static void APIENTRY logVertex3dv(const GLdouble *v)
1846 {
1847 SIG( "glVertex3dv" );
1848 dllVertex3dv( v );
1849 }
logVertex3f(GLfloat x,GLfloat y,GLfloat z)1850 static void APIENTRY logVertex3f(GLfloat x, GLfloat y, GLfloat z)
1851 {
1852 SIG( "glVertex3f" );
1853 dllVertex3f( x, y, z );
1854 }
logVertex3fv(const GLfloat * v)1855 static void APIENTRY logVertex3fv(const GLfloat *v)
1856 {
1857 SIG( "glVertex3fv" );
1858 dllVertex3fv( v );
1859 }
logVertex3i(GLint x,GLint y,GLint z)1860 static void APIENTRY logVertex3i(GLint x, GLint y, GLint z)
1861 {
1862 SIG( "glVertex3i" );
1863 dllVertex3i( x, y, z );
1864 }
logVertex3iv(const GLint * v)1865 static void APIENTRY logVertex3iv(const GLint *v)
1866 {
1867 SIG( "glVertex3iv" );
1868 dllVertex3iv( v );
1869 }
logVertex3s(GLshort x,GLshort y,GLshort z)1870 static void APIENTRY logVertex3s(GLshort x, GLshort y, GLshort z)
1871 {
1872 SIG( "glVertex3s" );
1873 dllVertex3s( x, y, z );
1874 }
logVertex3sv(const GLshort * v)1875 static void APIENTRY logVertex3sv(const GLshort *v)
1876 {
1877 SIG( "glVertex3sv" );
1878 dllVertex3sv( v );
1879 }
logVertex4d(GLdouble x,GLdouble y,GLdouble z,GLdouble w)1880 static void APIENTRY logVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
1881 {
1882 SIG( "glVertex4d" );
1883 dllVertex4d( x, y, z, w );
1884 }
logVertex4dv(const GLdouble * v)1885 static void APIENTRY logVertex4dv(const GLdouble *v)
1886 {
1887 SIG( "glVertex4dv" );
1888 dllVertex4dv( v );
1889 }
logVertex4f(GLfloat x,GLfloat y,GLfloat z,GLfloat w)1890 static void APIENTRY logVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
1891 {
1892 SIG( "glVertex4f" );
1893 dllVertex4f( x, y, z, w );
1894 }
logVertex4fv(const GLfloat * v)1895 static void APIENTRY logVertex4fv(const GLfloat *v)
1896 {
1897 SIG( "glVertex4fv" );
1898 dllVertex4fv( v );
1899 }
logVertex4i(GLint x,GLint y,GLint z,GLint w)1900 static void APIENTRY logVertex4i(GLint x, GLint y, GLint z, GLint w)
1901 {
1902 SIG( "glVertex4i" );
1903 dllVertex4i( x, y, z, w );
1904 }
logVertex4iv(const GLint * v)1905 static void APIENTRY logVertex4iv(const GLint *v)
1906 {
1907 SIG( "glVertex4iv" );
1908 dllVertex4iv( v );
1909 }
logVertex4s(GLshort x,GLshort y,GLshort z,GLshort w)1910 static void APIENTRY logVertex4s(GLshort x, GLshort y, GLshort z, GLshort w)
1911 {
1912 SIG( "glVertex4s" );
1913 dllVertex4s( x, y, z, w );
1914 }
logVertex4sv(const GLshort * v)1915 static void APIENTRY logVertex4sv(const GLshort *v)
1916 {
1917 SIG( "glVertex4sv" );
1918 dllVertex4sv( v );
1919 }
logVertexPointer(GLint size,GLenum type,GLsizei stride,const void * pointer)1920 static void APIENTRY logVertexPointer(GLint size, GLenum type, GLsizei stride, const void *pointer)
1921 {
1922 SIG( "glVertexPointer" );
1923 dllVertexPointer( size, type, stride, pointer );
1924 }
logViewport(GLint x,GLint y,GLsizei width,GLsizei height)1925 static void APIENTRY logViewport(GLint x, GLint y, GLsizei width, GLsizei height)
1926 {
1927 SIG( "glViewport" );
1928 dllViewport( x, y, width, height );
1929 }
1930
1931 /*
1932 ** QGL_Shutdown
1933 **
1934 ** Unloads the specified DLL then nulls out all the proc pointers.
1935 */
QGL_Shutdown(void)1936 void QGL_Shutdown( void )
1937 {
1938 if ( glw_state.OpenGLLib )
1939 {
1940 dlclose ( glw_state.OpenGLLib );
1941 glw_state.OpenGLLib = NULL;
1942 }
1943
1944 glw_state.OpenGLLib = NULL;
1945
1946 qglAccum = NULL;
1947 qglAlphaFunc = NULL;
1948 qglAreTexturesResident = NULL;
1949 qglArrayElement = NULL;
1950 qglBegin = NULL;
1951 qglBindTexture = NULL;
1952 qglBitmap = NULL;
1953 qglBlendFunc = NULL;
1954 qglCallList = NULL;
1955 qglCallLists = NULL;
1956 qglClear = NULL;
1957 qglClearAccum = NULL;
1958 qglClearColor = NULL;
1959 qglClearDepth = NULL;
1960 qglClearIndex = NULL;
1961 qglClearStencil = NULL;
1962 qglClipPlane = NULL;
1963 qglColor3b = NULL;
1964 qglColor3bv = NULL;
1965 qglColor3d = NULL;
1966 qglColor3dv = NULL;
1967 qglColor3f = NULL;
1968 qglColor3fv = NULL;
1969 qglColor3i = NULL;
1970 qglColor3iv = NULL;
1971 qglColor3s = NULL;
1972 qglColor3sv = NULL;
1973 qglColor3ub = NULL;
1974 qglColor3ubv = NULL;
1975 qglColor3ui = NULL;
1976 qglColor3uiv = NULL;
1977 qglColor3us = NULL;
1978 qglColor3usv = NULL;
1979 qglColor4b = NULL;
1980 qglColor4bv = NULL;
1981 qglColor4d = NULL;
1982 qglColor4dv = NULL;
1983 qglColor4f = NULL;
1984 qglColor4fv = NULL;
1985 qglColor4i = NULL;
1986 qglColor4iv = NULL;
1987 qglColor4s = NULL;
1988 qglColor4sv = NULL;
1989 qglColor4ub = NULL;
1990 qglColor4ubv = NULL;
1991 qglColor4ui = NULL;
1992 qglColor4uiv = NULL;
1993 qglColor4us = NULL;
1994 qglColor4usv = NULL;
1995 qglColorMask = NULL;
1996 qglColorMaterial = NULL;
1997 qglColorPointer = NULL;
1998 qglCopyPixels = NULL;
1999 qglCopyTexImage1D = NULL;
2000 qglCopyTexImage2D = NULL;
2001 qglCopyTexSubImage1D = NULL;
2002 qglCopyTexSubImage2D = NULL;
2003 qglCullFace = NULL;
2004 qglDeleteLists = NULL;
2005 qglDeleteTextures = NULL;
2006 qglDepthFunc = NULL;
2007 qglDepthMask = NULL;
2008 qglDepthRange = NULL;
2009 qglDisable = NULL;
2010 qglDisableClientState = NULL;
2011 qglDrawArrays = NULL;
2012 qglDrawBuffer = NULL;
2013 qglDrawElements = NULL;
2014 qglDrawPixels = NULL;
2015 qglEdgeFlag = NULL;
2016 qglEdgeFlagPointer = NULL;
2017 qglEdgeFlagv = NULL;
2018 qglEnable = NULL;
2019 qglEnableClientState = NULL;
2020 qglEnd = NULL;
2021 qglEndList = NULL;
2022 qglEvalCoord1d = NULL;
2023 qglEvalCoord1dv = NULL;
2024 qglEvalCoord1f = NULL;
2025 qglEvalCoord1fv = NULL;
2026 qglEvalCoord2d = NULL;
2027 qglEvalCoord2dv = NULL;
2028 qglEvalCoord2f = NULL;
2029 qglEvalCoord2fv = NULL;
2030 qglEvalMesh1 = NULL;
2031 qglEvalMesh2 = NULL;
2032 qglEvalPoint1 = NULL;
2033 qglEvalPoint2 = NULL;
2034 qglFeedbackBuffer = NULL;
2035 qglFinish = NULL;
2036 qglFlush = NULL;
2037 qglFogf = NULL;
2038 qglFogfv = NULL;
2039 qglFogi = NULL;
2040 qglFogiv = NULL;
2041 qglFrontFace = NULL;
2042 qglFrustum = NULL;
2043 qglGenLists = NULL;
2044 qglGenTextures = NULL;
2045 qglGetBooleanv = NULL;
2046 qglGetClipPlane = NULL;
2047 qglGetDoublev = NULL;
2048 qglGetError = NULL;
2049 qglGetFloatv = NULL;
2050 qglGetIntegerv = NULL;
2051 qglGetLightfv = NULL;
2052 qglGetLightiv = NULL;
2053 qglGetMapdv = NULL;
2054 qglGetMapfv = NULL;
2055 qglGetMapiv = NULL;
2056 qglGetMaterialfv = NULL;
2057 qglGetMaterialiv = NULL;
2058 qglGetPixelMapfv = NULL;
2059 qglGetPixelMapuiv = NULL;
2060 qglGetPixelMapusv = NULL;
2061 qglGetPointerv = NULL;
2062 qglGetPolygonStipple = NULL;
2063 qglGetString = NULL;
2064 qglGetTexEnvfv = NULL;
2065 qglGetTexEnviv = NULL;
2066 qglGetTexGendv = NULL;
2067 qglGetTexGenfv = NULL;
2068 qglGetTexGeniv = NULL;
2069 qglGetTexImage = NULL;
2070 qglGetTexLevelParameterfv = NULL;
2071 qglGetTexLevelParameteriv = NULL;
2072 qglGetTexParameterfv = NULL;
2073 qglGetTexParameteriv = NULL;
2074 qglHint = NULL;
2075 qglIndexMask = NULL;
2076 qglIndexPointer = NULL;
2077 qglIndexd = NULL;
2078 qglIndexdv = NULL;
2079 qglIndexf = NULL;
2080 qglIndexfv = NULL;
2081 qglIndexi = NULL;
2082 qglIndexiv = NULL;
2083 qglIndexs = NULL;
2084 qglIndexsv = NULL;
2085 qglIndexub = NULL;
2086 qglIndexubv = NULL;
2087 qglInitNames = NULL;
2088 qglInterleavedArrays = NULL;
2089 qglIsEnabled = NULL;
2090 qglIsList = NULL;
2091 qglIsTexture = NULL;
2092 qglLightModelf = NULL;
2093 qglLightModelfv = NULL;
2094 qglLightModeli = NULL;
2095 qglLightModeliv = NULL;
2096 qglLightf = NULL;
2097 qglLightfv = NULL;
2098 qglLighti = NULL;
2099 qglLightiv = NULL;
2100 qglLineStipple = NULL;
2101 qglLineWidth = NULL;
2102 qglListBase = NULL;
2103 qglLoadIdentity = NULL;
2104 qglLoadMatrixd = NULL;
2105 qglLoadMatrixf = NULL;
2106 qglLoadName = NULL;
2107 qglLogicOp = NULL;
2108 qglMap1d = NULL;
2109 qglMap1f = NULL;
2110 qglMap2d = NULL;
2111 qglMap2f = NULL;
2112 qglMapGrid1d = NULL;
2113 qglMapGrid1f = NULL;
2114 qglMapGrid2d = NULL;
2115 qglMapGrid2f = NULL;
2116 qglMaterialf = NULL;
2117 qglMaterialfv = NULL;
2118 qglMateriali = NULL;
2119 qglMaterialiv = NULL;
2120 qglMatrixMode = NULL;
2121 qglMultMatrixd = NULL;
2122 qglMultMatrixf = NULL;
2123 qglNewList = NULL;
2124 qglNormal3b = NULL;
2125 qglNormal3bv = NULL;
2126 qglNormal3d = NULL;
2127 qglNormal3dv = NULL;
2128 qglNormal3f = NULL;
2129 qglNormal3fv = NULL;
2130 qglNormal3i = NULL;
2131 qglNormal3iv = NULL;
2132 qglNormal3s = NULL;
2133 qglNormal3sv = NULL;
2134 qglNormalPointer = NULL;
2135 qglOrtho = NULL;
2136 qglPassThrough = NULL;
2137 qglPixelMapfv = NULL;
2138 qglPixelMapuiv = NULL;
2139 qglPixelMapusv = NULL;
2140 qglPixelStoref = NULL;
2141 qglPixelStorei = NULL;
2142 qglPixelTransferf = NULL;
2143 qglPixelTransferi = NULL;
2144 qglPixelZoom = NULL;
2145 qglPointSize = NULL;
2146 qglPolygonMode = NULL;
2147 qglPolygonOffset = NULL;
2148 qglPolygonStipple = NULL;
2149 qglPopAttrib = NULL;
2150 qglPopClientAttrib = NULL;
2151 qglPopMatrix = NULL;
2152 qglPopName = NULL;
2153 qglPrioritizeTextures = NULL;
2154 qglPushAttrib = NULL;
2155 qglPushClientAttrib = NULL;
2156 qglPushMatrix = NULL;
2157 qglPushName = NULL;
2158 qglRasterPos2d = NULL;
2159 qglRasterPos2dv = NULL;
2160 qglRasterPos2f = NULL;
2161 qglRasterPos2fv = NULL;
2162 qglRasterPos2i = NULL;
2163 qglRasterPos2iv = NULL;
2164 qglRasterPos2s = NULL;
2165 qglRasterPos2sv = NULL;
2166 qglRasterPos3d = NULL;
2167 qglRasterPos3dv = NULL;
2168 qglRasterPos3f = NULL;
2169 qglRasterPos3fv = NULL;
2170 qglRasterPos3i = NULL;
2171 qglRasterPos3iv = NULL;
2172 qglRasterPos3s = NULL;
2173 qglRasterPos3sv = NULL;
2174 qglRasterPos4d = NULL;
2175 qglRasterPos4dv = NULL;
2176 qglRasterPos4f = NULL;
2177 qglRasterPos4fv = NULL;
2178 qglRasterPos4i = NULL;
2179 qglRasterPos4iv = NULL;
2180 qglRasterPos4s = NULL;
2181 qglRasterPos4sv = NULL;
2182 qglReadBuffer = NULL;
2183 qglReadPixels = NULL;
2184 qglRectd = NULL;
2185 qglRectdv = NULL;
2186 qglRectf = NULL;
2187 qglRectfv = NULL;
2188 qglRecti = NULL;
2189 qglRectiv = NULL;
2190 qglRects = NULL;
2191 qglRectsv = NULL;
2192 qglRenderMode = NULL;
2193 qglRotated = NULL;
2194 qglRotatef = NULL;
2195 qglScaled = NULL;
2196 qglScalef = NULL;
2197 qglScissor = NULL;
2198 qglSelectBuffer = NULL;
2199 qglShadeModel = NULL;
2200 qglStencilFunc = NULL;
2201 qglStencilMask = NULL;
2202 qglStencilOp = NULL;
2203 qglTexCoord1d = NULL;
2204 qglTexCoord1dv = NULL;
2205 qglTexCoord1f = NULL;
2206 qglTexCoord1fv = NULL;
2207 qglTexCoord1i = NULL;
2208 qglTexCoord1iv = NULL;
2209 qglTexCoord1s = NULL;
2210 qglTexCoord1sv = NULL;
2211 qglTexCoord2d = NULL;
2212 qglTexCoord2dv = NULL;
2213 qglTexCoord2f = NULL;
2214 qglTexCoord2fv = NULL;
2215 qglTexCoord2i = NULL;
2216 qglTexCoord2iv = NULL;
2217 qglTexCoord2s = NULL;
2218 qglTexCoord2sv = NULL;
2219 qglTexCoord3d = NULL;
2220 qglTexCoord3dv = NULL;
2221 qglTexCoord3f = NULL;
2222 qglTexCoord3fv = NULL;
2223 qglTexCoord3i = NULL;
2224 qglTexCoord3iv = NULL;
2225 qglTexCoord3s = NULL;
2226 qglTexCoord3sv = NULL;
2227 qglTexCoord4d = NULL;
2228 qglTexCoord4dv = NULL;
2229 qglTexCoord4f = NULL;
2230 qglTexCoord4fv = NULL;
2231 qglTexCoord4i = NULL;
2232 qglTexCoord4iv = NULL;
2233 qglTexCoord4s = NULL;
2234 qglTexCoord4sv = NULL;
2235 qglTexCoordPointer = NULL;
2236 qglTexEnvf = NULL;
2237 qglTexEnvfv = NULL;
2238 qglTexEnvi = NULL;
2239 qglTexEnviv = NULL;
2240 qglTexGend = NULL;
2241 qglTexGendv = NULL;
2242 qglTexGenf = NULL;
2243 qglTexGenfv = NULL;
2244 qglTexGeni = NULL;
2245 qglTexGeniv = NULL;
2246 qglTexImage1D = NULL;
2247 qglTexImage2D = NULL;
2248 qglTexParameterf = NULL;
2249 qglTexParameterfv = NULL;
2250 qglTexParameteri = NULL;
2251 qglTexParameteriv = NULL;
2252 qglTexSubImage1D = NULL;
2253 qglTexSubImage2D = NULL;
2254 qglTranslated = NULL;
2255 qglTranslatef = NULL;
2256 qglVertex2d = NULL;
2257 qglVertex2dv = NULL;
2258 qglVertex2f = NULL;
2259 qglVertex2fv = NULL;
2260 qglVertex2i = NULL;
2261 qglVertex2iv = NULL;
2262 qglVertex2s = NULL;
2263 qglVertex2sv = NULL;
2264 qglVertex3d = NULL;
2265 qglVertex3dv = NULL;
2266 qglVertex3f = NULL;
2267 qglVertex3fv = NULL;
2268 qglVertex3i = NULL;
2269 qglVertex3iv = NULL;
2270 qglVertex3s = NULL;
2271 qglVertex3sv = NULL;
2272 qglVertex4d = NULL;
2273 qglVertex4dv = NULL;
2274 qglVertex4f = NULL;
2275 qglVertex4fv = NULL;
2276 qglVertex4i = NULL;
2277 qglVertex4iv = NULL;
2278 qglVertex4s = NULL;
2279 qglVertex4sv = NULL;
2280 qglVertexPointer = NULL;
2281 qglViewport = NULL;
2282 qglXChooseVisual = NULL;
2283 qglXCreateContext = NULL;
2284 qglXDestroyContext = NULL;
2285 qglXMakeCurrent = NULL;
2286 qglXCopyContext = NULL;
2287 qglXSwapBuffers = NULL;
2288 qglXGetConfig = NULL;
2289 }
2290
2291 #define GPA( a ) dlsym( glw_state.OpenGLLib, a )
2292
qwglGetProcAddress(char * symbol)2293 void *qwglGetProcAddress(char *symbol)
2294 {
2295 if (glw_state.OpenGLLib)
2296 return GPA ( symbol );
2297 return NULL;
2298 }
2299
2300 /*
2301 ** QGL_Init
2302 **
2303 ** This is responsible for binding our qgl function pointers to
2304 ** the appropriate GL stuff. In Windows this means doing a
2305 ** LoadLibrary and a bunch of calls to GetProcAddress. On other
2306 ** operating systems we need to do the right thing, whatever that
2307 ** might be.
2308 **
2309 */
2310
QGL_Init(const char * dllname)2311 qboolean QGL_Init( const char *dllname )
2312 {
2313
2314 if ( glw_state.OpenGLLib )
2315 QGL_Shutdown();
2316
2317 if ( ( glw_state.OpenGLLib = dlopen( dllname, RTLD_LAZY ) ) == 0 )
2318 {
2319 char fn[MAX_OSPATH];
2320 char *path;
2321
2322 // try basedir next
2323 path = ri.Cvar_Get ("basedir", ".", CVAR_NOSET)->string;
2324
2325 snprintf (fn, MAX_OSPATH, "%s/%s", path, dllname );
2326
2327 if ( ( glw_state.OpenGLLib = dlopen( fn, RTLD_LAZY ) ) == 0 ) {
2328 ri.Con_Printf( PRINT_ALL, "%s\n", dlerror() );
2329 return false;
2330 }
2331 Com_Printf ("Using %s for OpenGL...", fn);
2332 } else {
2333 Com_Printf ("Using %s for OpenGL...", dllname);
2334 }
2335
2336 qglAccum = dllAccum = GPA( "glAccum" );
2337 qglAlphaFunc = dllAlphaFunc = GPA( "glAlphaFunc" );
2338 qglAreTexturesResident = dllAreTexturesResident = GPA( "glAreTexturesResident" );
2339 qglArrayElement = dllArrayElement = GPA( "glArrayElement" );
2340 qglBegin = dllBegin = GPA( "glBegin" );
2341 qglBindTexture = dllBindTexture = GPA( "glBindTexture" );
2342 qglBitmap = dllBitmap = GPA( "glBitmap" );
2343 qglBlendFunc = dllBlendFunc = GPA( "glBlendFunc" );
2344 qglCallList = dllCallList = GPA( "glCallList" );
2345 qglCallLists = dllCallLists = GPA( "glCallLists" );
2346 qglClear = dllClear = GPA( "glClear" );
2347 qglClearAccum = dllClearAccum = GPA( "glClearAccum" );
2348 qglClearColor = dllClearColor = GPA( "glClearColor" );
2349 qglClearDepth = dllClearDepth = GPA( "glClearDepth" );
2350 qglClearIndex = dllClearIndex = GPA( "glClearIndex" );
2351 qglClearStencil = dllClearStencil = GPA( "glClearStencil" );
2352 qglClipPlane = dllClipPlane = GPA( "glClipPlane" );
2353 qglColor3b = dllColor3b = GPA( "glColor3b" );
2354 qglColor3bv = dllColor3bv = GPA( "glColor3bv" );
2355 qglColor3d = dllColor3d = GPA( "glColor3d" );
2356 qglColor3dv = dllColor3dv = GPA( "glColor3dv" );
2357 qglColor3f = dllColor3f = GPA( "glColor3f" );
2358 qglColor3fv = dllColor3fv = GPA( "glColor3fv" );
2359 qglColor3i = dllColor3i = GPA( "glColor3i" );
2360 qglColor3iv = dllColor3iv = GPA( "glColor3iv" );
2361 qglColor3s = dllColor3s = GPA( "glColor3s" );
2362 qglColor3sv = dllColor3sv = GPA( "glColor3sv" );
2363 qglColor3ub = dllColor3ub = GPA( "glColor3ub" );
2364 qglColor3ubv = dllColor3ubv = GPA( "glColor3ubv" );
2365 qglColor3ui = dllColor3ui = GPA( "glColor3ui" );
2366 qglColor3uiv = dllColor3uiv = GPA( "glColor3uiv" );
2367 qglColor3us = dllColor3us = GPA( "glColor3us" );
2368 qglColor3usv = dllColor3usv = GPA( "glColor3usv" );
2369 qglColor4b = dllColor4b = GPA( "glColor4b" );
2370 qglColor4bv = dllColor4bv = GPA( "glColor4bv" );
2371 qglColor4d = dllColor4d = GPA( "glColor4d" );
2372 qglColor4dv = dllColor4dv = GPA( "glColor4dv" );
2373 qglColor4f = dllColor4f = GPA( "glColor4f" );
2374 qglColor4fv = dllColor4fv = GPA( "glColor4fv" );
2375 qglColor4i = dllColor4i = GPA( "glColor4i" );
2376 qglColor4iv = dllColor4iv = GPA( "glColor4iv" );
2377 qglColor4s = dllColor4s = GPA( "glColor4s" );
2378 qglColor4sv = dllColor4sv = GPA( "glColor4sv" );
2379 qglColor4ub = dllColor4ub = GPA( "glColor4ub" );
2380 qglColor4ubv = dllColor4ubv = GPA( "glColor4ubv" );
2381 qglColor4ui = dllColor4ui = GPA( "glColor4ui" );
2382 qglColor4uiv = dllColor4uiv = GPA( "glColor4uiv" );
2383 qglColor4us = dllColor4us = GPA( "glColor4us" );
2384 qglColor4usv = dllColor4usv = GPA( "glColor4usv" );
2385 qglColorMask = dllColorMask = GPA( "glColorMask" );
2386 qglColorMaterial = dllColorMaterial = GPA( "glColorMaterial" );
2387 qglColorPointer = dllColorPointer = GPA( "glColorPointer" );
2388 qglCopyPixels = dllCopyPixels = GPA( "glCopyPixels" );
2389 qglCopyTexImage1D = dllCopyTexImage1D = GPA( "glCopyTexImage1D" );
2390 qglCopyTexImage2D = dllCopyTexImage2D = GPA( "glCopyTexImage2D" );
2391 qglCopyTexSubImage1D = dllCopyTexSubImage1D = GPA( "glCopyTexSubImage1D" );
2392 qglCopyTexSubImage2D = dllCopyTexSubImage2D = GPA( "glCopyTexSubImage2D" );
2393 qglCullFace = dllCullFace = GPA( "glCullFace" );
2394 qglDeleteLists = dllDeleteLists = GPA( "glDeleteLists" );
2395 qglDeleteTextures = dllDeleteTextures = GPA( "glDeleteTextures" );
2396 qglDepthFunc = dllDepthFunc = GPA( "glDepthFunc" );
2397 qglDepthMask = dllDepthMask = GPA( "glDepthMask" );
2398 qglDepthRange = dllDepthRange = GPA( "glDepthRange" );
2399 qglDisable = dllDisable = GPA( "glDisable" );
2400 qglDisableClientState = dllDisableClientState = GPA( "glDisableClientState" );
2401 qglDrawArrays = dllDrawArrays = GPA( "glDrawArrays" );
2402 qglDrawBuffer = dllDrawBuffer = GPA( "glDrawBuffer" );
2403 qglDrawElements = dllDrawElements = GPA( "glDrawElements" );
2404 qglDrawPixels = dllDrawPixels = GPA( "glDrawPixels" );
2405 qglEdgeFlag = dllEdgeFlag = GPA( "glEdgeFlag" );
2406 qglEdgeFlagPointer = dllEdgeFlagPointer = GPA( "glEdgeFlagPointer" );
2407 qglEdgeFlagv = dllEdgeFlagv = GPA( "glEdgeFlagv" );
2408 qglEnable = dllEnable = GPA( "glEnable" );
2409 qglEnableClientState = dllEnableClientState = GPA( "glEnableClientState" );
2410 qglEnd = dllEnd = GPA( "glEnd" );
2411 qglEndList = dllEndList = GPA( "glEndList" );
2412 qglEvalCoord1d = dllEvalCoord1d = GPA( "glEvalCoord1d" );
2413 qglEvalCoord1dv = dllEvalCoord1dv = GPA( "glEvalCoord1dv" );
2414 qglEvalCoord1f = dllEvalCoord1f = GPA( "glEvalCoord1f" );
2415 qglEvalCoord1fv = dllEvalCoord1fv = GPA( "glEvalCoord1fv" );
2416 qglEvalCoord2d = dllEvalCoord2d = GPA( "glEvalCoord2d" );
2417 qglEvalCoord2dv = dllEvalCoord2dv = GPA( "glEvalCoord2dv" );
2418 qglEvalCoord2f = dllEvalCoord2f = GPA( "glEvalCoord2f" );
2419 qglEvalCoord2fv = dllEvalCoord2fv = GPA( "glEvalCoord2fv" );
2420 qglEvalMesh1 = dllEvalMesh1 = GPA( "glEvalMesh1" );
2421 qglEvalMesh2 = dllEvalMesh2 = GPA( "glEvalMesh2" );
2422 qglEvalPoint1 = dllEvalPoint1 = GPA( "glEvalPoint1" );
2423 qglEvalPoint2 = dllEvalPoint2 = GPA( "glEvalPoint2" );
2424 qglFeedbackBuffer = dllFeedbackBuffer = GPA( "glFeedbackBuffer" );
2425 qglFinish = dllFinish = GPA( "glFinish" );
2426 qglFlush = dllFlush = GPA( "glFlush" );
2427 qglFogf = dllFogf = GPA( "glFogf" );
2428 qglFogfv = dllFogfv = GPA( "glFogfv" );
2429 qglFogi = dllFogi = GPA( "glFogi" );
2430 qglFogiv = dllFogiv = GPA( "glFogiv" );
2431 qglFrontFace = dllFrontFace = GPA( "glFrontFace" );
2432 qglFrustum = dllFrustum = GPA( "glFrustum" );
2433 qglGenLists = dllGenLists = GPA( "glGenLists" );
2434 qglGenTextures = dllGenTextures = GPA( "glGenTextures" );
2435 qglGetBooleanv = dllGetBooleanv = GPA( "glGetBooleanv" );
2436 qglGetClipPlane = dllGetClipPlane = GPA( "glGetClipPlane" );
2437 qglGetDoublev = dllGetDoublev = GPA( "glGetDoublev" );
2438 qglGetError = dllGetError = GPA( "glGetError" );
2439 qglGetFloatv = dllGetFloatv = GPA( "glGetFloatv" );
2440 qglGetIntegerv = dllGetIntegerv = GPA( "glGetIntegerv" );
2441 qglGetLightfv = dllGetLightfv = GPA( "glGetLightfv" );
2442 qglGetLightiv = dllGetLightiv = GPA( "glGetLightiv" );
2443 qglGetMapdv = dllGetMapdv = GPA( "glGetMapdv" );
2444 qglGetMapfv = dllGetMapfv = GPA( "glGetMapfv" );
2445 qglGetMapiv = dllGetMapiv = GPA( "glGetMapiv" );
2446 qglGetMaterialfv = dllGetMaterialfv = GPA( "glGetMaterialfv" );
2447 qglGetMaterialiv = dllGetMaterialiv = GPA( "glGetMaterialiv" );
2448 qglGetPixelMapfv = dllGetPixelMapfv = GPA( "glGetPixelMapfv" );
2449 qglGetPixelMapuiv = dllGetPixelMapuiv = GPA( "glGetPixelMapuiv" );
2450 qglGetPixelMapusv = dllGetPixelMapusv = GPA( "glGetPixelMapusv" );
2451 qglGetPointerv = dllGetPointerv = GPA( "glGetPointerv" );
2452 qglGetPolygonStipple = dllGetPolygonStipple = GPA( "glGetPolygonStipple" );
2453 qglGetString = dllGetString = GPA( "glGetString" );
2454 qglGetTexEnvfv = dllGetTexEnvfv = GPA( "glGetTexEnvfv" );
2455 qglGetTexEnviv = dllGetTexEnviv = GPA( "glGetTexEnviv" );
2456 qglGetTexGendv = dllGetTexGendv = GPA( "glGetTexGendv" );
2457 qglGetTexGenfv = dllGetTexGenfv = GPA( "glGetTexGenfv" );
2458 qglGetTexGeniv = dllGetTexGeniv = GPA( "glGetTexGeniv" );
2459 qglGetTexImage = dllGetTexImage = GPA( "glGetTexImage" );
2460 qglGetTexLevelParameterfv = dllGetTexLevelParameterfv = GPA( "glGetLevelParameterfv" );
2461 qglGetTexLevelParameteriv = dllGetTexLevelParameteriv = GPA( "glGetLevelParameteriv" );
2462 qglGetTexParameterfv = dllGetTexParameterfv = GPA( "glGetTexParameterfv" );
2463 qglGetTexParameteriv = dllGetTexParameteriv = GPA( "glGetTexParameteriv" );
2464 qglHint = dllHint = GPA( "glHint" );
2465 qglIndexMask = dllIndexMask = GPA( "glIndexMask" );
2466 qglIndexPointer = dllIndexPointer = GPA( "glIndexPointer" );
2467 qglIndexd = dllIndexd = GPA( "glIndexd" );
2468 qglIndexdv = dllIndexdv = GPA( "glIndexdv" );
2469 qglIndexf = dllIndexf = GPA( "glIndexf" );
2470 qglIndexfv = dllIndexfv = GPA( "glIndexfv" );
2471 qglIndexi = dllIndexi = GPA( "glIndexi" );
2472 qglIndexiv = dllIndexiv = GPA( "glIndexiv" );
2473 qglIndexs = dllIndexs = GPA( "glIndexs" );
2474 qglIndexsv = dllIndexsv = GPA( "glIndexsv" );
2475 qglIndexub = dllIndexub = GPA( "glIndexub" );
2476 qglIndexubv = dllIndexubv = GPA( "glIndexubv" );
2477 qglInitNames = dllInitNames = GPA( "glInitNames" );
2478 qglInterleavedArrays = dllInterleavedArrays = GPA( "glInterleavedArrays" );
2479 qglIsEnabled = dllIsEnabled = GPA( "glIsEnabled" );
2480 qglIsList = dllIsList = GPA( "glIsList" );
2481 qglIsTexture = dllIsTexture = GPA( "glIsTexture" );
2482 qglLightModelf = dllLightModelf = GPA( "glLightModelf" );
2483 qglLightModelfv = dllLightModelfv = GPA( "glLightModelfv" );
2484 qglLightModeli = dllLightModeli = GPA( "glLightModeli" );
2485 qglLightModeliv = dllLightModeliv = GPA( "glLightModeliv" );
2486 qglLightf = dllLightf = GPA( "glLightf" );
2487 qglLightfv = dllLightfv = GPA( "glLightfv" );
2488 qglLighti = dllLighti = GPA( "glLighti" );
2489 qglLightiv = dllLightiv = GPA( "glLightiv" );
2490 qglLineStipple = dllLineStipple = GPA( "glLineStipple" );
2491 qglLineWidth = dllLineWidth = GPA( "glLineWidth" );
2492 qglListBase = dllListBase = GPA( "glListBase" );
2493 qglLoadIdentity = dllLoadIdentity = GPA( "glLoadIdentity" );
2494 qglLoadMatrixd = dllLoadMatrixd = GPA( "glLoadMatrixd" );
2495 qglLoadMatrixf = dllLoadMatrixf = GPA( "glLoadMatrixf" );
2496 qglLoadName = dllLoadName = GPA( "glLoadName" );
2497 qglLogicOp = dllLogicOp = GPA( "glLogicOp" );
2498 qglMap1d = dllMap1d = GPA( "glMap1d" );
2499 qglMap1f = dllMap1f = GPA( "glMap1f" );
2500 qglMap2d = dllMap2d = GPA( "glMap2d" );
2501 qglMap2f = dllMap2f = GPA( "glMap2f" );
2502 qglMapGrid1d = dllMapGrid1d = GPA( "glMapGrid1d" );
2503 qglMapGrid1f = dllMapGrid1f = GPA( "glMapGrid1f" );
2504 qglMapGrid2d = dllMapGrid2d = GPA( "glMapGrid2d" );
2505 qglMapGrid2f = dllMapGrid2f = GPA( "glMapGrid2f" );
2506 qglMaterialf = dllMaterialf = GPA( "glMaterialf" );
2507 qglMaterialfv = dllMaterialfv = GPA( "glMaterialfv" );
2508 qglMateriali = dllMateriali = GPA( "glMateriali" );
2509 qglMaterialiv = dllMaterialiv = GPA( "glMaterialiv" );
2510 qglMatrixMode = dllMatrixMode = GPA( "glMatrixMode" );
2511 qglMultMatrixd = dllMultMatrixd = GPA( "glMultMatrixd" );
2512 qglMultMatrixf = dllMultMatrixf = GPA( "glMultMatrixf" );
2513 qglNewList = dllNewList = GPA( "glNewList" );
2514 qglNormal3b = dllNormal3b = GPA( "glNormal3b" );
2515 qglNormal3bv = dllNormal3bv = GPA( "glNormal3bv" );
2516 qglNormal3d = dllNormal3d = GPA( "glNormal3d" );
2517 qglNormal3dv = dllNormal3dv = GPA( "glNormal3dv" );
2518 qglNormal3f = dllNormal3f = GPA( "glNormal3f" );
2519 qglNormal3fv = dllNormal3fv = GPA( "glNormal3fv" );
2520 qglNormal3i = dllNormal3i = GPA( "glNormal3i" );
2521 qglNormal3iv = dllNormal3iv = GPA( "glNormal3iv" );
2522 qglNormal3s = dllNormal3s = GPA( "glNormal3s" );
2523 qglNormal3sv = dllNormal3sv = GPA( "glNormal3sv" );
2524 qglNormalPointer = dllNormalPointer = GPA( "glNormalPointer" );
2525 qglOrtho = dllOrtho = GPA( "glOrtho" );
2526 qglPassThrough = dllPassThrough = GPA( "glPassThrough" );
2527 qglPixelMapfv = dllPixelMapfv = GPA( "glPixelMapfv" );
2528 qglPixelMapuiv = dllPixelMapuiv = GPA( "glPixelMapuiv" );
2529 qglPixelMapusv = dllPixelMapusv = GPA( "glPixelMapusv" );
2530 qglPixelStoref = dllPixelStoref = GPA( "glPixelStoref" );
2531 qglPixelStorei = dllPixelStorei = GPA( "glPixelStorei" );
2532 qglPixelTransferf = dllPixelTransferf = GPA( "glPixelTransferf" );
2533 qglPixelTransferi = dllPixelTransferi = GPA( "glPixelTransferi" );
2534 qglPixelZoom = dllPixelZoom = GPA( "glPixelZoom" );
2535 qglPointSize = dllPointSize = GPA( "glPointSize" );
2536 qglPolygonMode = dllPolygonMode = GPA( "glPolygonMode" );
2537 qglPolygonOffset = dllPolygonOffset = GPA( "glPolygonOffset" );
2538 qglPolygonStipple = dllPolygonStipple = GPA( "glPolygonStipple" );
2539 qglPopAttrib = dllPopAttrib = GPA( "glPopAttrib" );
2540 qglPopClientAttrib = dllPopClientAttrib = GPA( "glPopClientAttrib" );
2541 qglPopMatrix = dllPopMatrix = GPA( "glPopMatrix" );
2542 qglPopName = dllPopName = GPA( "glPopName" );
2543 qglPrioritizeTextures = dllPrioritizeTextures = GPA( "glPrioritizeTextures" );
2544 qglPushAttrib = dllPushAttrib = GPA( "glPushAttrib" );
2545 qglPushClientAttrib = dllPushClientAttrib = GPA( "glPushClientAttrib" );
2546 qglPushMatrix = dllPushMatrix = GPA( "glPushMatrix" );
2547 qglPushName = dllPushName = GPA( "glPushName" );
2548 qglRasterPos2d = dllRasterPos2d = GPA( "glRasterPos2d" );
2549 qglRasterPos2dv = dllRasterPos2dv = GPA( "glRasterPos2dv" );
2550 qglRasterPos2f = dllRasterPos2f = GPA( "glRasterPos2f" );
2551 qglRasterPos2fv = dllRasterPos2fv = GPA( "glRasterPos2fv" );
2552 qglRasterPos2i = dllRasterPos2i = GPA( "glRasterPos2i" );
2553 qglRasterPos2iv = dllRasterPos2iv = GPA( "glRasterPos2iv" );
2554 qglRasterPos2s = dllRasterPos2s = GPA( "glRasterPos2s" );
2555 qglRasterPos2sv = dllRasterPos2sv = GPA( "glRasterPos2sv" );
2556 qglRasterPos3d = dllRasterPos3d = GPA( "glRasterPos3d" );
2557 qglRasterPos3dv = dllRasterPos3dv = GPA( "glRasterPos3dv" );
2558 qglRasterPos3f = dllRasterPos3f = GPA( "glRasterPos3f" );
2559 qglRasterPos3fv = dllRasterPos3fv = GPA( "glRasterPos3fv" );
2560 qglRasterPos3i = dllRasterPos3i = GPA( "glRasterPos3i" );
2561 qglRasterPos3iv = dllRasterPos3iv = GPA( "glRasterPos3iv" );
2562 qglRasterPos3s = dllRasterPos3s = GPA( "glRasterPos3s" );
2563 qglRasterPos3sv = dllRasterPos3sv = GPA( "glRasterPos3sv" );
2564 qglRasterPos4d = dllRasterPos4d = GPA( "glRasterPos4d" );
2565 qglRasterPos4dv = dllRasterPos4dv = GPA( "glRasterPos4dv" );
2566 qglRasterPos4f = dllRasterPos4f = GPA( "glRasterPos4f" );
2567 qglRasterPos4fv = dllRasterPos4fv = GPA( "glRasterPos4fv" );
2568 qglRasterPos4i = dllRasterPos4i = GPA( "glRasterPos4i" );
2569 qglRasterPos4iv = dllRasterPos4iv = GPA( "glRasterPos4iv" );
2570 qglRasterPos4s = dllRasterPos4s = GPA( "glRasterPos4s" );
2571 qglRasterPos4sv = dllRasterPos4sv = GPA( "glRasterPos4sv" );
2572 qglReadBuffer = dllReadBuffer = GPA( "glReadBuffer" );
2573 qglReadPixels = dllReadPixels = GPA( "glReadPixels" );
2574 qglRectd = dllRectd = GPA( "glRectd" );
2575 qglRectdv = dllRectdv = GPA( "glRectdv" );
2576 qglRectf = dllRectf = GPA( "glRectf" );
2577 qglRectfv = dllRectfv = GPA( "glRectfv" );
2578 qglRecti = dllRecti = GPA( "glRecti" );
2579 qglRectiv = dllRectiv = GPA( "glRectiv" );
2580 qglRects = dllRects = GPA( "glRects" );
2581 qglRectsv = dllRectsv = GPA( "glRectsv" );
2582 qglRenderMode = dllRenderMode = GPA( "glRenderMode" );
2583 qglRotated = dllRotated = GPA( "glRotated" );
2584 qglRotatef = dllRotatef = GPA( "glRotatef" );
2585 qglScaled = dllScaled = GPA( "glScaled" );
2586 qglScalef = dllScalef = GPA( "glScalef" );
2587 qglScissor = dllScissor = GPA( "glScissor" );
2588 qglSelectBuffer = dllSelectBuffer = GPA( "glSelectBuffer" );
2589 qglShadeModel = dllShadeModel = GPA( "glShadeModel" );
2590 qglStencilFunc = dllStencilFunc = GPA( "glStencilFunc" );
2591 qglStencilMask = dllStencilMask = GPA( "glStencilMask" );
2592 qglStencilOp = dllStencilOp = GPA( "glStencilOp" );
2593 qglTexCoord1d = dllTexCoord1d = GPA( "glTexCoord1d" );
2594 qglTexCoord1dv = dllTexCoord1dv = GPA( "glTexCoord1dv" );
2595 qglTexCoord1f = dllTexCoord1f = GPA( "glTexCoord1f" );
2596 qglTexCoord1fv = dllTexCoord1fv = GPA( "glTexCoord1fv" );
2597 qglTexCoord1i = dllTexCoord1i = GPA( "glTexCoord1i" );
2598 qglTexCoord1iv = dllTexCoord1iv = GPA( "glTexCoord1iv" );
2599 qglTexCoord1s = dllTexCoord1s = GPA( "glTexCoord1s" );
2600 qglTexCoord1sv = dllTexCoord1sv = GPA( "glTexCoord1sv" );
2601 qglTexCoord2d = dllTexCoord2d = GPA( "glTexCoord2d" );
2602 qglTexCoord2dv = dllTexCoord2dv = GPA( "glTexCoord2dv" );
2603 qglTexCoord2f = dllTexCoord2f = GPA( "glTexCoord2f" );
2604 qglTexCoord2fv = dllTexCoord2fv = GPA( "glTexCoord2fv" );
2605 qglTexCoord2i = dllTexCoord2i = GPA( "glTexCoord2i" );
2606 qglTexCoord2iv = dllTexCoord2iv = GPA( "glTexCoord2iv" );
2607 qglTexCoord2s = dllTexCoord2s = GPA( "glTexCoord2s" );
2608 qglTexCoord2sv = dllTexCoord2sv = GPA( "glTexCoord2sv" );
2609 qglTexCoord3d = dllTexCoord3d = GPA( "glTexCoord3d" );
2610 qglTexCoord3dv = dllTexCoord3dv = GPA( "glTexCoord3dv" );
2611 qglTexCoord3f = dllTexCoord3f = GPA( "glTexCoord3f" );
2612 qglTexCoord3fv = dllTexCoord3fv = GPA( "glTexCoord3fv" );
2613 qglTexCoord3i = dllTexCoord3i = GPA( "glTexCoord3i" );
2614 qglTexCoord3iv = dllTexCoord3iv = GPA( "glTexCoord3iv" );
2615 qglTexCoord3s = dllTexCoord3s = GPA( "glTexCoord3s" );
2616 qglTexCoord3sv = dllTexCoord3sv = GPA( "glTexCoord3sv" );
2617 qglTexCoord4d = dllTexCoord4d = GPA( "glTexCoord4d" );
2618 qglTexCoord4dv = dllTexCoord4dv = GPA( "glTexCoord4dv" );
2619 qglTexCoord4f = dllTexCoord4f = GPA( "glTexCoord4f" );
2620 qglTexCoord4fv = dllTexCoord4fv = GPA( "glTexCoord4fv" );
2621 qglTexCoord4i = dllTexCoord4i = GPA( "glTexCoord4i" );
2622 qglTexCoord4iv = dllTexCoord4iv = GPA( "glTexCoord4iv" );
2623 qglTexCoord4s = dllTexCoord4s = GPA( "glTexCoord4s" );
2624 qglTexCoord4sv = dllTexCoord4sv = GPA( "glTexCoord4sv" );
2625 qglTexCoordPointer = dllTexCoordPointer = GPA( "glTexCoordPointer" );
2626 qglTexEnvf = dllTexEnvf = GPA( "glTexEnvf" );
2627 qglTexEnvfv = dllTexEnvfv = GPA( "glTexEnvfv" );
2628 qglTexEnvi = dllTexEnvi = GPA( "glTexEnvi" );
2629 qglTexEnviv = dllTexEnviv = GPA( "glTexEnviv" );
2630 qglTexGend = dllTexGend = GPA( "glTexGend" );
2631 qglTexGendv = dllTexGendv = GPA( "glTexGendv" );
2632 qglTexGenf = dllTexGenf = GPA( "glTexGenf" );
2633 qglTexGenfv = dllTexGenfv = GPA( "glTexGenfv" );
2634 qglTexGeni = dllTexGeni = GPA( "glTexGeni" );
2635 qglTexGeniv = dllTexGeniv = GPA( "glTexGeniv" );
2636 qglTexImage1D = dllTexImage1D = GPA( "glTexImage1D" );
2637 qglTexImage2D = dllTexImage2D = GPA( "glTexImage2D" );
2638 qglTexParameterf = dllTexParameterf = GPA( "glTexParameterf" );
2639 qglTexParameterfv = dllTexParameterfv = GPA( "glTexParameterfv" );
2640 qglTexParameteri = dllTexParameteri = GPA( "glTexParameteri" );
2641 qglTexParameteriv = dllTexParameteriv = GPA( "glTexParameteriv" );
2642 qglTexSubImage1D = dllTexSubImage1D = GPA( "glTexSubImage1D" );
2643 qglTexSubImage2D = dllTexSubImage2D = GPA( "glTexSubImage2D" );
2644 qglTranslated = dllTranslated = GPA( "glTranslated" );
2645 qglTranslatef = dllTranslatef = GPA( "glTranslatef" );
2646 qglVertex2d = dllVertex2d = GPA( "glVertex2d" );
2647 qglVertex2dv = dllVertex2dv = GPA( "glVertex2dv" );
2648 qglVertex2f = dllVertex2f = GPA( "glVertex2f" );
2649 qglVertex2fv = dllVertex2fv = GPA( "glVertex2fv" );
2650 qglVertex2i = dllVertex2i = GPA( "glVertex2i" );
2651 qglVertex2iv = dllVertex2iv = GPA( "glVertex2iv" );
2652 qglVertex2s = dllVertex2s = GPA( "glVertex2s" );
2653 qglVertex2sv = dllVertex2sv = GPA( "glVertex2sv" );
2654 qglVertex3d = dllVertex3d = GPA( "glVertex3d" );
2655 qglVertex3dv = dllVertex3dv = GPA( "glVertex3dv" );
2656 qglVertex3f = dllVertex3f = GPA( "glVertex3f" );
2657 qglVertex3fv = dllVertex3fv = GPA( "glVertex3fv" );
2658 qglVertex3i = dllVertex3i = GPA( "glVertex3i" );
2659 qglVertex3iv = dllVertex3iv = GPA( "glVertex3iv" );
2660 qglVertex3s = dllVertex3s = GPA( "glVertex3s" );
2661 qglVertex3sv = dllVertex3sv = GPA( "glVertex3sv" );
2662 qglVertex4d = dllVertex4d = GPA( "glVertex4d" );
2663 qglVertex4dv = dllVertex4dv = GPA( "glVertex4dv" );
2664 qglVertex4f = dllVertex4f = GPA( "glVertex4f" );
2665 qglVertex4fv = dllVertex4fv = GPA( "glVertex4fv" );
2666 qglVertex4i = dllVertex4i = GPA( "glVertex4i" );
2667 qglVertex4iv = dllVertex4iv = GPA( "glVertex4iv" );
2668 qglVertex4s = dllVertex4s = GPA( "glVertex4s" );
2669 qglVertex4sv = dllVertex4sv = GPA( "glVertex4sv" );
2670 qglVertexPointer = dllVertexPointer = GPA( "glVertexPointer" );
2671 qglViewport = dllViewport = GPA( "glViewport" );
2672 qglXChooseVisual = GPA("glXChooseVisual");
2673 qglXCreateContext = GPA("glXCreateContext");
2674 qglXDestroyContext = GPA("glXDestroyContext");
2675 qglXMakeCurrent = GPA("glXMakeCurrent");
2676 qglXCopyContext = GPA("glXCopyContext");
2677 qglXSwapBuffers = GPA("glXSwapBuffers");
2678 qglXGetConfig = GPA("glXGetConfig");
2679
2680 qglLockArraysEXT = 0;
2681 qglUnlockArraysEXT = 0;
2682 qglPointParameterfEXT = 0;
2683 qglPointParameterfvEXT = 0;
2684 qglColorTableEXT = 0;
2685 qgl3DfxSetPaletteEXT = 0;
2686 qglSelectTextureSGIS = 0;
2687 qglMTexCoord2fSGIS = 0;
2688 qglActiveTextureARB = 0;
2689 qglClientActiveTextureARB = 0;
2690
2691 return true;
2692 }
2693
GLimp_EnableLogging(qboolean enable)2694 void GLimp_EnableLogging( qboolean enable )
2695 {
2696 if ( enable )
2697 {
2698 if ( !glw_state.log_fp )
2699 {
2700 struct tm *newtime;
2701 time_t aclock;
2702 char buffer[1024];
2703
2704 time( &aclock );
2705 newtime = localtime( &aclock );
2706
2707 asctime( newtime );
2708
2709 Com_sprintf( buffer, sizeof(buffer), "%s/gl.log", ri.FS_Gamedir() );
2710 glw_state.log_fp = fopen( buffer, "wt" );
2711
2712 fprintf( glw_state.log_fp, "%s\n", asctime( newtime ) );
2713 }
2714
2715 qglAccum = logAccum;
2716 qglAlphaFunc = logAlphaFunc;
2717 qglAreTexturesResident = logAreTexturesResident;
2718 qglArrayElement = logArrayElement;
2719 qglBegin = logBegin;
2720 qglBindTexture = logBindTexture;
2721 qglBitmap = logBitmap;
2722 qglBlendFunc = logBlendFunc;
2723 qglCallList = logCallList;
2724 qglCallLists = logCallLists;
2725 qglClear = logClear;
2726 qglClearAccum = logClearAccum;
2727 qglClearColor = logClearColor;
2728 qglClearDepth = logClearDepth;
2729 qglClearIndex = logClearIndex;
2730 qglClearStencil = logClearStencil;
2731 qglClipPlane = logClipPlane;
2732 qglColor3b = logColor3b;
2733 qglColor3bv = logColor3bv;
2734 qglColor3d = logColor3d;
2735 qglColor3dv = logColor3dv;
2736 qglColor3f = logColor3f;
2737 qglColor3fv = logColor3fv;
2738 qglColor3i = logColor3i;
2739 qglColor3iv = logColor3iv;
2740 qglColor3s = logColor3s;
2741 qglColor3sv = logColor3sv;
2742 qglColor3ub = logColor3ub;
2743 qglColor3ubv = logColor3ubv;
2744 qglColor3ui = logColor3ui;
2745 qglColor3uiv = logColor3uiv;
2746 qglColor3us = logColor3us;
2747 qglColor3usv = logColor3usv;
2748 qglColor4b = logColor4b;
2749 qglColor4bv = logColor4bv;
2750 qglColor4d = logColor4d;
2751 qglColor4dv = logColor4dv;
2752 qglColor4f = logColor4f;
2753 qglColor4fv = logColor4fv;
2754 qglColor4i = logColor4i;
2755 qglColor4iv = logColor4iv;
2756 qglColor4s = logColor4s;
2757 qglColor4sv = logColor4sv;
2758 qglColor4ub = logColor4ub;
2759 qglColor4ubv = logColor4ubv;
2760 qglColor4ui = logColor4ui;
2761 qglColor4uiv = logColor4uiv;
2762 qglColor4us = logColor4us;
2763 qglColor4usv = logColor4usv;
2764 qglColorMask = logColorMask;
2765 qglColorMaterial = logColorMaterial;
2766 qglColorPointer = logColorPointer;
2767 qglCopyPixels = logCopyPixels;
2768 qglCopyTexImage1D = logCopyTexImage1D;
2769 qglCopyTexImage2D = logCopyTexImage2D;
2770 qglCopyTexSubImage1D = logCopyTexSubImage1D;
2771 qglCopyTexSubImage2D = logCopyTexSubImage2D;
2772 qglCullFace = logCullFace;
2773 qglDeleteLists = logDeleteLists ;
2774 qglDeleteTextures = logDeleteTextures ;
2775 qglDepthFunc = logDepthFunc ;
2776 qglDepthMask = logDepthMask ;
2777 qglDepthRange = logDepthRange ;
2778 qglDisable = logDisable ;
2779 qglDisableClientState = logDisableClientState ;
2780 qglDrawArrays = logDrawArrays ;
2781 qglDrawBuffer = logDrawBuffer ;
2782 qglDrawElements = logDrawElements ;
2783 qglDrawPixels = logDrawPixels ;
2784 qglEdgeFlag = logEdgeFlag ;
2785 qglEdgeFlagPointer = logEdgeFlagPointer ;
2786 qglEdgeFlagv = logEdgeFlagv ;
2787 qglEnable = logEnable ;
2788 qglEnableClientState = logEnableClientState ;
2789 qglEnd = logEnd ;
2790 qglEndList = logEndList ;
2791 qglEvalCoord1d = logEvalCoord1d ;
2792 qglEvalCoord1dv = logEvalCoord1dv ;
2793 qglEvalCoord1f = logEvalCoord1f ;
2794 qglEvalCoord1fv = logEvalCoord1fv ;
2795 qglEvalCoord2d = logEvalCoord2d ;
2796 qglEvalCoord2dv = logEvalCoord2dv ;
2797 qglEvalCoord2f = logEvalCoord2f ;
2798 qglEvalCoord2fv = logEvalCoord2fv ;
2799 qglEvalMesh1 = logEvalMesh1 ;
2800 qglEvalMesh2 = logEvalMesh2 ;
2801 qglEvalPoint1 = logEvalPoint1 ;
2802 qglEvalPoint2 = logEvalPoint2 ;
2803 qglFeedbackBuffer = logFeedbackBuffer ;
2804 qglFinish = logFinish ;
2805 qglFlush = logFlush ;
2806 qglFogf = logFogf ;
2807 qglFogfv = logFogfv ;
2808 qglFogi = logFogi ;
2809 qglFogiv = logFogiv ;
2810 qglFrontFace = logFrontFace ;
2811 qglFrustum = logFrustum ;
2812 qglGenLists = logGenLists ;
2813 qglGenTextures = logGenTextures ;
2814 qglGetBooleanv = logGetBooleanv ;
2815 qglGetClipPlane = logGetClipPlane ;
2816 qglGetDoublev = logGetDoublev ;
2817 qglGetError = logGetError ;
2818 qglGetFloatv = logGetFloatv ;
2819 qglGetIntegerv = logGetIntegerv ;
2820 qglGetLightfv = logGetLightfv ;
2821 qglGetLightiv = logGetLightiv ;
2822 qglGetMapdv = logGetMapdv ;
2823 qglGetMapfv = logGetMapfv ;
2824 qglGetMapiv = logGetMapiv ;
2825 qglGetMaterialfv = logGetMaterialfv ;
2826 qglGetMaterialiv = logGetMaterialiv ;
2827 qglGetPixelMapfv = logGetPixelMapfv ;
2828 qglGetPixelMapuiv = logGetPixelMapuiv ;
2829 qglGetPixelMapusv = logGetPixelMapusv ;
2830 qglGetPointerv = logGetPointerv ;
2831 qglGetPolygonStipple = logGetPolygonStipple ;
2832 qglGetString = logGetString ;
2833 qglGetTexEnvfv = logGetTexEnvfv ;
2834 qglGetTexEnviv = logGetTexEnviv ;
2835 qglGetTexGendv = logGetTexGendv ;
2836 qglGetTexGenfv = logGetTexGenfv ;
2837 qglGetTexGeniv = logGetTexGeniv ;
2838 qglGetTexImage = logGetTexImage ;
2839 qglGetTexLevelParameterfv = logGetTexLevelParameterfv ;
2840 qglGetTexLevelParameteriv = logGetTexLevelParameteriv ;
2841 qglGetTexParameterfv = logGetTexParameterfv ;
2842 qglGetTexParameteriv = logGetTexParameteriv ;
2843 qglHint = logHint ;
2844 qglIndexMask = logIndexMask ;
2845 qglIndexPointer = logIndexPointer ;
2846 qglIndexd = logIndexd ;
2847 qglIndexdv = logIndexdv ;
2848 qglIndexf = logIndexf ;
2849 qglIndexfv = logIndexfv ;
2850 qglIndexi = logIndexi ;
2851 qglIndexiv = logIndexiv ;
2852 qglIndexs = logIndexs ;
2853 qglIndexsv = logIndexsv ;
2854 qglIndexub = logIndexub ;
2855 qglIndexubv = logIndexubv ;
2856 qglInitNames = logInitNames ;
2857 qglInterleavedArrays = logInterleavedArrays ;
2858 qglIsEnabled = logIsEnabled ;
2859 qglIsList = logIsList ;
2860 qglIsTexture = logIsTexture ;
2861 qglLightModelf = logLightModelf ;
2862 qglLightModelfv = logLightModelfv ;
2863 qglLightModeli = logLightModeli ;
2864 qglLightModeliv = logLightModeliv ;
2865 qglLightf = logLightf ;
2866 qglLightfv = logLightfv ;
2867 qglLighti = logLighti ;
2868 qglLightiv = logLightiv ;
2869 qglLineStipple = logLineStipple ;
2870 qglLineWidth = logLineWidth ;
2871 qglListBase = logListBase ;
2872 qglLoadIdentity = logLoadIdentity ;
2873 qglLoadMatrixd = logLoadMatrixd ;
2874 qglLoadMatrixf = logLoadMatrixf ;
2875 qglLoadName = logLoadName ;
2876 qglLogicOp = logLogicOp ;
2877 qglMap1d = logMap1d ;
2878 qglMap1f = logMap1f ;
2879 qglMap2d = logMap2d ;
2880 qglMap2f = logMap2f ;
2881 qglMapGrid1d = logMapGrid1d ;
2882 qglMapGrid1f = logMapGrid1f ;
2883 qglMapGrid2d = logMapGrid2d ;
2884 qglMapGrid2f = logMapGrid2f ;
2885 qglMaterialf = logMaterialf ;
2886 qglMaterialfv = logMaterialfv ;
2887 qglMateriali = logMateriali ;
2888 qglMaterialiv = logMaterialiv ;
2889 qglMatrixMode = logMatrixMode ;
2890 qglMultMatrixd = logMultMatrixd ;
2891 qglMultMatrixf = logMultMatrixf ;
2892 qglNewList = logNewList ;
2893 qglNormal3b = logNormal3b ;
2894 qglNormal3bv = logNormal3bv ;
2895 qglNormal3d = logNormal3d ;
2896 qglNormal3dv = logNormal3dv ;
2897 qglNormal3f = logNormal3f ;
2898 qglNormal3fv = logNormal3fv ;
2899 qglNormal3i = logNormal3i ;
2900 qglNormal3iv = logNormal3iv ;
2901 qglNormal3s = logNormal3s ;
2902 qglNormal3sv = logNormal3sv ;
2903 qglNormalPointer = logNormalPointer ;
2904 qglOrtho = logOrtho ;
2905 qglPassThrough = logPassThrough ;
2906 qglPixelMapfv = logPixelMapfv ;
2907 qglPixelMapuiv = logPixelMapuiv ;
2908 qglPixelMapusv = logPixelMapusv ;
2909 qglPixelStoref = logPixelStoref ;
2910 qglPixelStorei = logPixelStorei ;
2911 qglPixelTransferf = logPixelTransferf ;
2912 qglPixelTransferi = logPixelTransferi ;
2913 qglPixelZoom = logPixelZoom ;
2914 qglPointSize = logPointSize ;
2915 qglPolygonMode = logPolygonMode ;
2916 qglPolygonOffset = logPolygonOffset ;
2917 qglPolygonStipple = logPolygonStipple ;
2918 qglPopAttrib = logPopAttrib ;
2919 qglPopClientAttrib = logPopClientAttrib ;
2920 qglPopMatrix = logPopMatrix ;
2921 qglPopName = logPopName ;
2922 qglPrioritizeTextures = logPrioritizeTextures ;
2923 qglPushAttrib = logPushAttrib ;
2924 qglPushClientAttrib = logPushClientAttrib ;
2925 qglPushMatrix = logPushMatrix ;
2926 qglPushName = logPushName ;
2927 qglRasterPos2d = logRasterPos2d ;
2928 qglRasterPos2dv = logRasterPos2dv ;
2929 qglRasterPos2f = logRasterPos2f ;
2930 qglRasterPos2fv = logRasterPos2fv ;
2931 qglRasterPos2i = logRasterPos2i ;
2932 qglRasterPos2iv = logRasterPos2iv ;
2933 qglRasterPos2s = logRasterPos2s ;
2934 qglRasterPos2sv = logRasterPos2sv ;
2935 qglRasterPos3d = logRasterPos3d ;
2936 qglRasterPos3dv = logRasterPos3dv ;
2937 qglRasterPos3f = logRasterPos3f ;
2938 qglRasterPos3fv = logRasterPos3fv ;
2939 qglRasterPos3i = logRasterPos3i ;
2940 qglRasterPos3iv = logRasterPos3iv ;
2941 qglRasterPos3s = logRasterPos3s ;
2942 qglRasterPos3sv = logRasterPos3sv ;
2943 qglRasterPos4d = logRasterPos4d ;
2944 qglRasterPos4dv = logRasterPos4dv ;
2945 qglRasterPos4f = logRasterPos4f ;
2946 qglRasterPos4fv = logRasterPos4fv ;
2947 qglRasterPos4i = logRasterPos4i ;
2948 qglRasterPos4iv = logRasterPos4iv ;
2949 qglRasterPos4s = logRasterPos4s ;
2950 qglRasterPos4sv = logRasterPos4sv ;
2951 qglReadBuffer = logReadBuffer ;
2952 qglReadPixels = logReadPixels ;
2953 qglRectd = logRectd ;
2954 qglRectdv = logRectdv ;
2955 qglRectf = logRectf ;
2956 qglRectfv = logRectfv ;
2957 qglRecti = logRecti ;
2958 qglRectiv = logRectiv ;
2959 qglRects = logRects ;
2960 qglRectsv = logRectsv ;
2961 qglRenderMode = logRenderMode ;
2962 qglRotated = logRotated ;
2963 qglRotatef = logRotatef ;
2964 qglScaled = logScaled ;
2965 qglScalef = logScalef ;
2966 qglScissor = logScissor ;
2967 qglSelectBuffer = logSelectBuffer ;
2968 qglShadeModel = logShadeModel ;
2969 qglStencilFunc = logStencilFunc ;
2970 qglStencilMask = logStencilMask ;
2971 qglStencilOp = logStencilOp ;
2972 qglTexCoord1d = logTexCoord1d ;
2973 qglTexCoord1dv = logTexCoord1dv ;
2974 qglTexCoord1f = logTexCoord1f ;
2975 qglTexCoord1fv = logTexCoord1fv ;
2976 qglTexCoord1i = logTexCoord1i ;
2977 qglTexCoord1iv = logTexCoord1iv ;
2978 qglTexCoord1s = logTexCoord1s ;
2979 qglTexCoord1sv = logTexCoord1sv ;
2980 qglTexCoord2d = logTexCoord2d ;
2981 qglTexCoord2dv = logTexCoord2dv ;
2982 qglTexCoord2f = logTexCoord2f ;
2983 qglTexCoord2fv = logTexCoord2fv ;
2984 qglTexCoord2i = logTexCoord2i ;
2985 qglTexCoord2iv = logTexCoord2iv ;
2986 qglTexCoord2s = logTexCoord2s ;
2987 qglTexCoord2sv = logTexCoord2sv ;
2988 qglTexCoord3d = logTexCoord3d ;
2989 qglTexCoord3dv = logTexCoord3dv ;
2990 qglTexCoord3f = logTexCoord3f ;
2991 qglTexCoord3fv = logTexCoord3fv ;
2992 qglTexCoord3i = logTexCoord3i ;
2993 qglTexCoord3iv = logTexCoord3iv ;
2994 qglTexCoord3s = logTexCoord3s ;
2995 qglTexCoord3sv = logTexCoord3sv ;
2996 qglTexCoord4d = logTexCoord4d ;
2997 qglTexCoord4dv = logTexCoord4dv ;
2998 qglTexCoord4f = logTexCoord4f ;
2999 qglTexCoord4fv = logTexCoord4fv ;
3000 qglTexCoord4i = logTexCoord4i ;
3001 qglTexCoord4iv = logTexCoord4iv ;
3002 qglTexCoord4s = logTexCoord4s ;
3003 qglTexCoord4sv = logTexCoord4sv ;
3004 qglTexCoordPointer = logTexCoordPointer ;
3005 qglTexEnvf = logTexEnvf ;
3006 qglTexEnvfv = logTexEnvfv ;
3007 qglTexEnvi = logTexEnvi ;
3008 qglTexEnviv = logTexEnviv ;
3009 qglTexGend = logTexGend ;
3010 qglTexGendv = logTexGendv ;
3011 qglTexGenf = logTexGenf ;
3012 qglTexGenfv = logTexGenfv ;
3013 qglTexGeni = logTexGeni ;
3014 qglTexGeniv = logTexGeniv ;
3015 qglTexImage1D = logTexImage1D ;
3016 qglTexImage2D = logTexImage2D ;
3017 qglTexParameterf = logTexParameterf ;
3018 qglTexParameterfv = logTexParameterfv ;
3019 qglTexParameteri = logTexParameteri ;
3020 qglTexParameteriv = logTexParameteriv ;
3021 qglTexSubImage1D = logTexSubImage1D ;
3022 qglTexSubImage2D = logTexSubImage2D ;
3023 qglTranslated = logTranslated ;
3024 qglTranslatef = logTranslatef ;
3025 qglVertex2d = logVertex2d ;
3026 qglVertex2dv = logVertex2dv ;
3027 qglVertex2f = logVertex2f ;
3028 qglVertex2fv = logVertex2fv ;
3029 qglVertex2i = logVertex2i ;
3030 qglVertex2iv = logVertex2iv ;
3031 qglVertex2s = logVertex2s ;
3032 qglVertex2sv = logVertex2sv ;
3033 qglVertex3d = logVertex3d ;
3034 qglVertex3dv = logVertex3dv ;
3035 qglVertex3f = logVertex3f ;
3036 qglVertex3fv = logVertex3fv ;
3037 qglVertex3i = logVertex3i ;
3038 qglVertex3iv = logVertex3iv ;
3039 qglVertex3s = logVertex3s ;
3040 qglVertex3sv = logVertex3sv ;
3041 qglVertex4d = logVertex4d ;
3042 qglVertex4dv = logVertex4dv ;
3043 qglVertex4f = logVertex4f ;
3044 qglVertex4fv = logVertex4fv ;
3045 qglVertex4i = logVertex4i ;
3046 qglVertex4iv = logVertex4iv ;
3047 qglVertex4s = logVertex4s ;
3048 qglVertex4sv = logVertex4sv ;
3049 qglVertexPointer = logVertexPointer ;
3050 qglViewport = logViewport ;
3051 qglXChooseVisual = glXChooseVisual ;
3052 qglXCreateContext = glXCreateContext ;
3053 qglXDestroyContext = glXDestroyContext ;
3054 qglXMakeCurrent = glXMakeCurrent ;
3055 qglXCopyContext = glXCopyContext ;
3056 qglXSwapBuffers = glXSwapBuffers ;
3057 qglXGetConfig = glXGetConfig ;
3058 }
3059 else
3060 {
3061 qglAccum = dllAccum;
3062 qglAlphaFunc = dllAlphaFunc;
3063 qglAreTexturesResident = dllAreTexturesResident;
3064 qglArrayElement = dllArrayElement;
3065 qglBegin = dllBegin;
3066 qglBindTexture = dllBindTexture;
3067 qglBitmap = dllBitmap;
3068 qglBlendFunc = dllBlendFunc;
3069 qglCallList = dllCallList;
3070 qglCallLists = dllCallLists;
3071 qglClear = dllClear;
3072 qglClearAccum = dllClearAccum;
3073 qglClearColor = dllClearColor;
3074 qglClearDepth = dllClearDepth;
3075 qglClearIndex = dllClearIndex;
3076 qglClearStencil = dllClearStencil;
3077 qglClipPlane = dllClipPlane;
3078 qglColor3b = dllColor3b;
3079 qglColor3bv = dllColor3bv;
3080 qglColor3d = dllColor3d;
3081 qglColor3dv = dllColor3dv;
3082 qglColor3f = dllColor3f;
3083 qglColor3fv = dllColor3fv;
3084 qglColor3i = dllColor3i;
3085 qglColor3iv = dllColor3iv;
3086 qglColor3s = dllColor3s;
3087 qglColor3sv = dllColor3sv;
3088 qglColor3ub = dllColor3ub;
3089 qglColor3ubv = dllColor3ubv;
3090 qglColor3ui = dllColor3ui;
3091 qglColor3uiv = dllColor3uiv;
3092 qglColor3us = dllColor3us;
3093 qglColor3usv = dllColor3usv;
3094 qglColor4b = dllColor4b;
3095 qglColor4bv = dllColor4bv;
3096 qglColor4d = dllColor4d;
3097 qglColor4dv = dllColor4dv;
3098 qglColor4f = dllColor4f;
3099 qglColor4fv = dllColor4fv;
3100 qglColor4i = dllColor4i;
3101 qglColor4iv = dllColor4iv;
3102 qglColor4s = dllColor4s;
3103 qglColor4sv = dllColor4sv;
3104 qglColor4ub = dllColor4ub;
3105 qglColor4ubv = dllColor4ubv;
3106 qglColor4ui = dllColor4ui;
3107 qglColor4uiv = dllColor4uiv;
3108 qglColor4us = dllColor4us;
3109 qglColor4usv = dllColor4usv;
3110 qglColorMask = dllColorMask;
3111 qglColorMaterial = dllColorMaterial;
3112 qglColorPointer = dllColorPointer;
3113 qglCopyPixels = dllCopyPixels;
3114 qglCopyTexImage1D = dllCopyTexImage1D;
3115 qglCopyTexImage2D = dllCopyTexImage2D;
3116 qglCopyTexSubImage1D = dllCopyTexSubImage1D;
3117 qglCopyTexSubImage2D = dllCopyTexSubImage2D;
3118 qglCullFace = dllCullFace;
3119 qglDeleteLists = dllDeleteLists ;
3120 qglDeleteTextures = dllDeleteTextures ;
3121 qglDepthFunc = dllDepthFunc ;
3122 qglDepthMask = dllDepthMask ;
3123 qglDepthRange = dllDepthRange ;
3124 qglDisable = dllDisable ;
3125 qglDisableClientState = dllDisableClientState ;
3126 qglDrawArrays = dllDrawArrays ;
3127 qglDrawBuffer = dllDrawBuffer ;
3128 qglDrawElements = dllDrawElements ;
3129 qglDrawPixels = dllDrawPixels ;
3130 qglEdgeFlag = dllEdgeFlag ;
3131 qglEdgeFlagPointer = dllEdgeFlagPointer ;
3132 qglEdgeFlagv = dllEdgeFlagv ;
3133 qglEnable = dllEnable ;
3134 qglEnableClientState = dllEnableClientState ;
3135 qglEnd = dllEnd ;
3136 qglEndList = dllEndList ;
3137 qglEvalCoord1d = dllEvalCoord1d ;
3138 qglEvalCoord1dv = dllEvalCoord1dv ;
3139 qglEvalCoord1f = dllEvalCoord1f ;
3140 qglEvalCoord1fv = dllEvalCoord1fv ;
3141 qglEvalCoord2d = dllEvalCoord2d ;
3142 qglEvalCoord2dv = dllEvalCoord2dv ;
3143 qglEvalCoord2f = dllEvalCoord2f ;
3144 qglEvalCoord2fv = dllEvalCoord2fv ;
3145 qglEvalMesh1 = dllEvalMesh1 ;
3146 qglEvalMesh2 = dllEvalMesh2 ;
3147 qglEvalPoint1 = dllEvalPoint1 ;
3148 qglEvalPoint2 = dllEvalPoint2 ;
3149 qglFeedbackBuffer = dllFeedbackBuffer ;
3150 qglFinish = dllFinish ;
3151 qglFlush = dllFlush ;
3152 qglFogf = dllFogf ;
3153 qglFogfv = dllFogfv ;
3154 qglFogi = dllFogi ;
3155 qglFogiv = dllFogiv ;
3156 qglFrontFace = dllFrontFace ;
3157 qglFrustum = dllFrustum ;
3158 qglGenLists = dllGenLists ;
3159 qglGenTextures = dllGenTextures ;
3160 qglGetBooleanv = dllGetBooleanv ;
3161 qglGetClipPlane = dllGetClipPlane ;
3162 qglGetDoublev = dllGetDoublev ;
3163 qglGetError = dllGetError ;
3164 qglGetFloatv = dllGetFloatv ;
3165 qglGetIntegerv = dllGetIntegerv ;
3166 qglGetLightfv = dllGetLightfv ;
3167 qglGetLightiv = dllGetLightiv ;
3168 qglGetMapdv = dllGetMapdv ;
3169 qglGetMapfv = dllGetMapfv ;
3170 qglGetMapiv = dllGetMapiv ;
3171 qglGetMaterialfv = dllGetMaterialfv ;
3172 qglGetMaterialiv = dllGetMaterialiv ;
3173 qglGetPixelMapfv = dllGetPixelMapfv ;
3174 qglGetPixelMapuiv = dllGetPixelMapuiv ;
3175 qglGetPixelMapusv = dllGetPixelMapusv ;
3176 qglGetPointerv = dllGetPointerv ;
3177 qglGetPolygonStipple = dllGetPolygonStipple ;
3178 qglGetString = dllGetString ;
3179 qglGetTexEnvfv = dllGetTexEnvfv ;
3180 qglGetTexEnviv = dllGetTexEnviv ;
3181 qglGetTexGendv = dllGetTexGendv ;
3182 qglGetTexGenfv = dllGetTexGenfv ;
3183 qglGetTexGeniv = dllGetTexGeniv ;
3184 qglGetTexImage = dllGetTexImage ;
3185 qglGetTexLevelParameterfv = dllGetTexLevelParameterfv ;
3186 qglGetTexLevelParameteriv = dllGetTexLevelParameteriv ;
3187 qglGetTexParameterfv = dllGetTexParameterfv ;
3188 qglGetTexParameteriv = dllGetTexParameteriv ;
3189 qglHint = dllHint ;
3190 qglIndexMask = dllIndexMask ;
3191 qglIndexPointer = dllIndexPointer ;
3192 qglIndexd = dllIndexd ;
3193 qglIndexdv = dllIndexdv ;
3194 qglIndexf = dllIndexf ;
3195 qglIndexfv = dllIndexfv ;
3196 qglIndexi = dllIndexi ;
3197 qglIndexiv = dllIndexiv ;
3198 qglIndexs = dllIndexs ;
3199 qglIndexsv = dllIndexsv ;
3200 qglIndexub = dllIndexub ;
3201 qglIndexubv = dllIndexubv ;
3202 qglInitNames = dllInitNames ;
3203 qglInterleavedArrays = dllInterleavedArrays ;
3204 qglIsEnabled = dllIsEnabled ;
3205 qglIsList = dllIsList ;
3206 qglIsTexture = dllIsTexture ;
3207 qglLightModelf = dllLightModelf ;
3208 qglLightModelfv = dllLightModelfv ;
3209 qglLightModeli = dllLightModeli ;
3210 qglLightModeliv = dllLightModeliv ;
3211 qglLightf = dllLightf ;
3212 qglLightfv = dllLightfv ;
3213 qglLighti = dllLighti ;
3214 qglLightiv = dllLightiv ;
3215 qglLineStipple = dllLineStipple ;
3216 qglLineWidth = dllLineWidth ;
3217 qglListBase = dllListBase ;
3218 qglLoadIdentity = dllLoadIdentity ;
3219 qglLoadMatrixd = dllLoadMatrixd ;
3220 qglLoadMatrixf = dllLoadMatrixf ;
3221 qglLoadName = dllLoadName ;
3222 qglLogicOp = dllLogicOp ;
3223 qglMap1d = dllMap1d ;
3224 qglMap1f = dllMap1f ;
3225 qglMap2d = dllMap2d ;
3226 qglMap2f = dllMap2f ;
3227 qglMapGrid1d = dllMapGrid1d ;
3228 qglMapGrid1f = dllMapGrid1f ;
3229 qglMapGrid2d = dllMapGrid2d ;
3230 qglMapGrid2f = dllMapGrid2f ;
3231 qglMaterialf = dllMaterialf ;
3232 qglMaterialfv = dllMaterialfv ;
3233 qglMateriali = dllMateriali ;
3234 qglMaterialiv = dllMaterialiv ;
3235 qglMatrixMode = dllMatrixMode ;
3236 qglMultMatrixd = dllMultMatrixd ;
3237 qglMultMatrixf = dllMultMatrixf ;
3238 qglNewList = dllNewList ;
3239 qglNormal3b = dllNormal3b ;
3240 qglNormal3bv = dllNormal3bv ;
3241 qglNormal3d = dllNormal3d ;
3242 qglNormal3dv = dllNormal3dv ;
3243 qglNormal3f = dllNormal3f ;
3244 qglNormal3fv = dllNormal3fv ;
3245 qglNormal3i = dllNormal3i ;
3246 qglNormal3iv = dllNormal3iv ;
3247 qglNormal3s = dllNormal3s ;
3248 qglNormal3sv = dllNormal3sv ;
3249 qglNormalPointer = dllNormalPointer ;
3250 qglOrtho = dllOrtho ;
3251 qglPassThrough = dllPassThrough ;
3252 qglPixelMapfv = dllPixelMapfv ;
3253 qglPixelMapuiv = dllPixelMapuiv ;
3254 qglPixelMapusv = dllPixelMapusv ;
3255 qglPixelStoref = dllPixelStoref ;
3256 qglPixelStorei = dllPixelStorei ;
3257 qglPixelTransferf = dllPixelTransferf ;
3258 qglPixelTransferi = dllPixelTransferi ;
3259 qglPixelZoom = dllPixelZoom ;
3260 qglPointSize = dllPointSize ;
3261 qglPolygonMode = dllPolygonMode ;
3262 qglPolygonOffset = dllPolygonOffset ;
3263 qglPolygonStipple = dllPolygonStipple ;
3264 qglPopAttrib = dllPopAttrib ;
3265 qglPopClientAttrib = dllPopClientAttrib ;
3266 qglPopMatrix = dllPopMatrix ;
3267 qglPopName = dllPopName ;
3268 qglPrioritizeTextures = dllPrioritizeTextures ;
3269 qglPushAttrib = dllPushAttrib ;
3270 qglPushClientAttrib = dllPushClientAttrib ;
3271 qglPushMatrix = dllPushMatrix ;
3272 qglPushName = dllPushName ;
3273 qglRasterPos2d = dllRasterPos2d ;
3274 qglRasterPos2dv = dllRasterPos2dv ;
3275 qglRasterPos2f = dllRasterPos2f ;
3276 qglRasterPos2fv = dllRasterPos2fv ;
3277 qglRasterPos2i = dllRasterPos2i ;
3278 qglRasterPos2iv = dllRasterPos2iv ;
3279 qglRasterPos2s = dllRasterPos2s ;
3280 qglRasterPos2sv = dllRasterPos2sv ;
3281 qglRasterPos3d = dllRasterPos3d ;
3282 qglRasterPos3dv = dllRasterPos3dv ;
3283 qglRasterPos3f = dllRasterPos3f ;
3284 qglRasterPos3fv = dllRasterPos3fv ;
3285 qglRasterPos3i = dllRasterPos3i ;
3286 qglRasterPos3iv = dllRasterPos3iv ;
3287 qglRasterPos3s = dllRasterPos3s ;
3288 qglRasterPos3sv = dllRasterPos3sv ;
3289 qglRasterPos4d = dllRasterPos4d ;
3290 qglRasterPos4dv = dllRasterPos4dv ;
3291 qglRasterPos4f = dllRasterPos4f ;
3292 qglRasterPos4fv = dllRasterPos4fv ;
3293 qglRasterPos4i = dllRasterPos4i ;
3294 qglRasterPos4iv = dllRasterPos4iv ;
3295 qglRasterPos4s = dllRasterPos4s ;
3296 qglRasterPos4sv = dllRasterPos4sv ;
3297 qglReadBuffer = dllReadBuffer ;
3298 qglReadPixels = dllReadPixels ;
3299 qglRectd = dllRectd ;
3300 qglRectdv = dllRectdv ;
3301 qglRectf = dllRectf ;
3302 qglRectfv = dllRectfv ;
3303 qglRecti = dllRecti ;
3304 qglRectiv = dllRectiv ;
3305 qglRects = dllRects ;
3306 qglRectsv = dllRectsv ;
3307 qglRenderMode = dllRenderMode ;
3308 qglRotated = dllRotated ;
3309 qglRotatef = dllRotatef ;
3310 qglScaled = dllScaled ;
3311 qglScalef = dllScalef ;
3312 qglScissor = dllScissor ;
3313 qglSelectBuffer = dllSelectBuffer ;
3314 qglShadeModel = dllShadeModel ;
3315 qglStencilFunc = dllStencilFunc ;
3316 qglStencilMask = dllStencilMask ;
3317 qglStencilOp = dllStencilOp ;
3318 qglTexCoord1d = dllTexCoord1d ;
3319 qglTexCoord1dv = dllTexCoord1dv ;
3320 qglTexCoord1f = dllTexCoord1f ;
3321 qglTexCoord1fv = dllTexCoord1fv ;
3322 qglTexCoord1i = dllTexCoord1i ;
3323 qglTexCoord1iv = dllTexCoord1iv ;
3324 qglTexCoord1s = dllTexCoord1s ;
3325 qglTexCoord1sv = dllTexCoord1sv ;
3326 qglTexCoord2d = dllTexCoord2d ;
3327 qglTexCoord2dv = dllTexCoord2dv ;
3328 qglTexCoord2f = dllTexCoord2f ;
3329 qglTexCoord2fv = dllTexCoord2fv ;
3330 qglTexCoord2i = dllTexCoord2i ;
3331 qglTexCoord2iv = dllTexCoord2iv ;
3332 qglTexCoord2s = dllTexCoord2s ;
3333 qglTexCoord2sv = dllTexCoord2sv ;
3334 qglTexCoord3d = dllTexCoord3d ;
3335 qglTexCoord3dv = dllTexCoord3dv ;
3336 qglTexCoord3f = dllTexCoord3f ;
3337 qglTexCoord3fv = dllTexCoord3fv ;
3338 qglTexCoord3i = dllTexCoord3i ;
3339 qglTexCoord3iv = dllTexCoord3iv ;
3340 qglTexCoord3s = dllTexCoord3s ;
3341 qglTexCoord3sv = dllTexCoord3sv ;
3342 qglTexCoord4d = dllTexCoord4d ;
3343 qglTexCoord4dv = dllTexCoord4dv ;
3344 qglTexCoord4f = dllTexCoord4f ;
3345 qglTexCoord4fv = dllTexCoord4fv ;
3346 qglTexCoord4i = dllTexCoord4i ;
3347 qglTexCoord4iv = dllTexCoord4iv ;
3348 qglTexCoord4s = dllTexCoord4s ;
3349 qglTexCoord4sv = dllTexCoord4sv ;
3350 qglTexCoordPointer = dllTexCoordPointer ;
3351 qglTexEnvf = dllTexEnvf ;
3352 qglTexEnvfv = dllTexEnvfv ;
3353 qglTexEnvi = dllTexEnvi ;
3354 qglTexEnviv = dllTexEnviv ;
3355 qglTexGend = dllTexGend ;
3356 qglTexGendv = dllTexGendv ;
3357 qglTexGenf = dllTexGenf ;
3358 qglTexGenfv = dllTexGenfv ;
3359 qglTexGeni = dllTexGeni ;
3360 qglTexGeniv = dllTexGeniv ;
3361 qglTexImage1D = dllTexImage1D ;
3362 qglTexImage2D = dllTexImage2D ;
3363 qglTexParameterf = dllTexParameterf ;
3364 qglTexParameterfv = dllTexParameterfv ;
3365 qglTexParameteri = dllTexParameteri ;
3366 qglTexParameteriv = dllTexParameteriv ;
3367 qglTexSubImage1D = dllTexSubImage1D ;
3368 qglTexSubImage2D = dllTexSubImage2D ;
3369 qglTranslated = dllTranslated ;
3370 qglTranslatef = dllTranslatef ;
3371 qglVertex2d = dllVertex2d ;
3372 qglVertex2dv = dllVertex2dv ;
3373 qglVertex2f = dllVertex2f ;
3374 qglVertex2fv = dllVertex2fv ;
3375 qglVertex2i = dllVertex2i ;
3376 qglVertex2iv = dllVertex2iv ;
3377 qglVertex2s = dllVertex2s ;
3378 qglVertex2sv = dllVertex2sv ;
3379 qglVertex3d = dllVertex3d ;
3380 qglVertex3dv = dllVertex3dv ;
3381 qglVertex3f = dllVertex3f ;
3382 qglVertex3fv = dllVertex3fv ;
3383 qglVertex3i = dllVertex3i ;
3384 qglVertex3iv = dllVertex3iv ;
3385 qglVertex3s = dllVertex3s ;
3386 qglVertex3sv = dllVertex3sv ;
3387 qglVertex4d = dllVertex4d ;
3388 qglVertex4dv = dllVertex4dv ;
3389 qglVertex4f = dllVertex4f ;
3390 qglVertex4fv = dllVertex4fv ;
3391 qglVertex4i = dllVertex4i ;
3392 qglVertex4iv = dllVertex4iv ;
3393 qglVertex4s = dllVertex4s ;
3394 qglVertex4sv = dllVertex4sv ;
3395 qglVertexPointer = dllVertexPointer ;
3396 qglViewport = dllViewport ;
3397 qglXChooseVisual = glXChooseVisual ;
3398 qglXCreateContext = glXCreateContext ;
3399 qglXDestroyContext = glXDestroyContext ;
3400 qglXMakeCurrent = glXMakeCurrent ;
3401 qglXCopyContext = glXCopyContext ;
3402 qglXSwapBuffers = glXSwapBuffers ;
3403 qglXGetConfig = glXGetConfig ;
3404 }
3405 }
3406
3407
GLimp_LogNewFrame(void)3408 void GLimp_LogNewFrame( void )
3409 {
3410 fprintf( glw_state.log_fp, "*** R_BeginFrame ***\n" );
3411 }
3412
3413
3414