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