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