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