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