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