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