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