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