diff --git a/dlls/wined3d/Makefile.in b/dlls/wined3d/Makefile.in index b08b050d15..16587b3ba8 100644 --- a/dlls/wined3d/Makefile.in +++ b/dlls/wined3d/Makefile.in @@ -5,8 +5,7 @@ VPATH = @srcdir@ MODULE = wined3d.dll IMPORTLIB = libwined3d.$(IMPLIBEXT) IMPORTS = user32 gdi32 advapi32 kernel32 -EXTRAINCL = @X_CFLAGS@ -EXTRALIBS = -luuid @X_LIBS@ @X_PRE_LIBS@ @XLIB@ @X_EXTRA_LIBS@ @OPENGL_LIBS@ +EXTRALIBS = -luuid C_SRCS = \ arb_program_shader.c \ diff --git a/dlls/wined3d/directx.c b/dlls/wined3d/directx.c index 563c714b36..22487bcd1d 100644 --- a/dlls/wined3d/directx.c +++ b/dlls/wined3d/directx.c @@ -414,6 +414,24 @@ BOOL IWineD3DImpl_FillGLCaps(WineD3D_GL_Info *gl_info) { TRACE_(d3d_caps)("(%p)\n", gl_info); + /* To bypass the opengl32 thunks load wglGetProcAddress from gdi32 (glXGetProcAddress wrapper) instead of opengl32's */ + mod_gl = LoadLibraryA("gdi32.dll"); + if(!mod_gl) { + ERR("Can't load gdi32.dll!\n"); + return FALSE; + } + + p_wglGetProcAddress = (void*)GetProcAddress(mod_gl, "wglGetProcAddress"); + if(!p_wglGetProcAddress) { + ERR("Unable to load wglGetProcAddress!\n"); + return FALSE; + } + +/* Dynamicly load all GL core functions */ +#define USE_GL_FUNC(pfn) pfn = (void*)p_wglGetProcAddress( (const char *) #pfn); + GL_FUNCS_GEN; +#undef USE_GL_FUNC + gl_string = (const char *) glGetString(GL_RENDERER); if (NULL == gl_string) gl_string = "None"; @@ -579,20 +597,7 @@ BOOL IWineD3DImpl_FillGLCaps(WineD3D_GL_Info *gl_info) { gl_info->vs_arb_constantsF = 0; gl_info->ps_arb_constantsF = 0; - /* To bypass the opengl32 thunks load wglGetProcAddress from gdi32 (glXGetProcAddress wrapper) instead of opengl32's */ - mod_gl = LoadLibraryA("gdi32.dll"); - if(!mod_gl) { - ERR("Can't load gdi32.dll!\n"); - return FALSE; - } - - p_wglGetProcAddress = (void*)GetProcAddress(mod_gl, "wglGetProcAddress"); - if(!p_wglGetProcAddress) { - ERR("Unable to load wglGetProcAddress!\n"); - return FALSE; - } - - /* Now work out what GL support this card really has */ +/* Now work out what GL support this card really has */ #define USE_GL_FUNC(type, pfn) gl_info->pfn = (type) p_wglGetProcAddress( (const char *) #pfn); GL_EXT_FUNCS_GEN; WGL_EXT_FUNCS_GEN; diff --git a/include/wine/wined3d_gl.h b/include/wine/wined3d_gl.h index 87edccdac5..fa808ccb82 100644 --- a/include/wine/wined3d_gl.h +++ b/include/wine/wined3d_gl.h @@ -4,6 +4,7 @@ * Copyright 2002-2003 The wine-d3d team * Copyright 2002-2004 Jason Edmeades * Raphael Junqueira + * Copyright 2007 Roderick Colenbrander * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public @@ -18,29 +19,1469 @@ * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + * + * + * Most OpenGL 1.0/1.1/1.2/1.3 constants/types come from the Mesa-project: + * Copyright (C) 1999-2006 Brian Paul + * + * From the Mesa-license: + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN + * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ #ifndef __WINE_WINED3D_GL_H #define __WINE_WINED3D_GL_H -#ifndef __WINE_CONFIG_H -# error You must include config.h to use this header -#endif - -#ifdef HAVE_OPENGL - #undef APIENTRY #undef CALLBACK #undef WINAPI -#define XMD_H /* This is to prevent the Xmd.h inclusion bug :-/ */ -#define GL_GLEXT_LEGACY -#include -#undef XMD_H - #undef APIENTRY #define APIENTRY +/* Use this in the future for calling convention magic */ +#define WINE_GLAPI + + +/**************************************************** + * OpenGL 1.0/1.1/1.2/1.3 + * types, #defines and function pointers + ****************************************************/ + +/* Types */ +typedef unsigned int GLbitfield; +typedef unsigned char GLboolean; +typedef signed char GLbyte; +typedef unsigned char GLubyte; +typedef short GLshort; +typedef unsigned short GLushort; +typedef int GLint; +typedef unsigned int GLuint; +typedef unsigned int GLenum; +typedef float GLfloat; +typedef int GLsizei; +typedef float GLclampf; +typedef double GLdouble; +typedef double GLclampd; +typedef void GLvoid; + +/* Booleans */ +#define GL_FALSE 0x0 +#define GL_TRUE 0x1 + +/* Data types */ +#define GL_BYTE 0x1400 +#define GL_UNSIGNED_BYTE 0x1401 +#define GL_SHORT 0x1402 +#define GL_UNSIGNED_SHORT 0x1403 +#define GL_INT 0x1404 +#define GL_UNSIGNED_INT 0x1405 +#define GL_FLOAT 0x1406 +#define GL_DOUBLE 0x140A +#define GL_2_BYTES 0x1407 +#define GL_3_BYTES 0x1408 +#define GL_4_BYTES 0x1409 + +/* Errors */ +#define GL_NO_ERROR 0x0 +#define GL_INVALID_VALUE 0x0501 +#define GL_INVALID_ENUM 0x0500 +#define GL_INVALID_OPERATION 0x0502 +#define GL_STACK_OVERFLOW 0x0503 +#define GL_STACK_UNDERFLOW 0x0504 +#define GL_OUT_OF_MEMORY 0x0505 + +/* Utility */ +#define GL_VENDOR 0x1F00 +#define GL_RENDERER 0x1F01 +#define GL_VERSION 0x1F02 +#define GL_EXTENSIONS 0x1F03 + +/* Accumulation buffer */ +#define GL_ACCUM_RED_BITS 0x0D58 +#define GL_ACCUM_GREEN_BITS 0x0D59 +#define GL_ACCUM_BLUE_BITS 0x0D5A +#define GL_ACCUM_ALPHA_BITS 0x0D5B +#define GL_ACCUM_CLEAR_VALUE 0x0B80 +#define GL_ACCUM 0x0100 +#define GL_ADD 0x0104 +#define GL_LOAD 0x0101 +#define GL_MULT 0x0103 +#define GL_RETURN 0x0102 + +/* Alpha testing */ +#define GL_ALPHA_TEST 0x0BC0 +#define GL_ALPHA_TEST_REF 0x0BC2 +#define GL_ALPHA_TEST_FUNC 0x0BC1 + +/* Blending */ +#define GL_BLEND 0x0BE2 +#define GL_BLEND_SRC 0x0BE1 +#define GL_BLEND_DST 0x0BE0 +#define GL_ZERO 0x0 +#define GL_ONE 0x1 +#define GL_SRC_COLOR 0x0300 +#define GL_ONE_MINUS_SRC_COLOR 0x0301 +#define GL_SRC_ALPHA 0x0302 +#define GL_ONE_MINUS_SRC_ALPHA 0x0303 +#define GL_DST_ALPHA 0x0304 +#define GL_ONE_MINUS_DST_ALPHA 0x0305 +#define GL_DST_COLOR 0x0306 +#define GL_ONE_MINUS_DST_COLOR 0x0307 +#define GL_SRC_ALPHA_SATURATE 0x0308 +#define GL_CONSTANT_COLOR 0x8001 +#define GL_ONE_MINUS_CONSTANT_COLOR 0x8002 +#define GL_CONSTANT_ALPHA 0x8003 +#define GL_ONE_MINUS_CONSTANT_ALPHA 0x8004 + +/* Buffers, Pixel Drawing/Reading */ +#define GL_NONE 0x0 +#define GL_FRONT_LEFT 0x0400 +#define GL_FRONT_RIGHT 0x0401 +#define GL_BACK_LEFT 0x0402 +#define GL_BACK_RIGHT 0x0403 +#define GL_FRONT 0x0404 +#define GL_BACK 0x0405 +#define GL_LEFT 0x0406 +#define GL_RIGHT 0x0407 +#define GL_FRONT_AND_BACK 0x0408 +#define GL_AUX0 0x0409 +#define GL_AUX1 0x040A +#define GL_AUX2 0x040B +#define GL_AUX3 0x040C +#define GL_COLOR_INDEX 0x1900 +#define GL_RED 0x1903 +#define GL_GREEN 0x1904 +#define GL_BLUE 0x1905 +#define GL_ALPHA 0x1906 +#define GL_LUMINANCE 0x1909 +#define GL_LUMINANCE_ALPHA 0x190A +#define GL_ALPHA_BITS 0x0D55 +#define GL_RED_BITS 0x0D52 +#define GL_GREEN_BITS 0x0D53 +#define GL_BLUE_BITS 0x0D54 +#define GL_INDEX_BITS 0x0D51 +#define GL_SUBPIXEL_BITS 0x0D50 +#define GL_AUX_BUFFERS 0x0C00 +#define GL_READ_BUFFER 0x0C02 +#define GL_DRAW_BUFFER 0x0C01 +#define GL_DOUBLEBUFFER 0x0C32 +#define GL_STEREO 0x0C33 +#define GL_BITMAP 0x1A00 +#define GL_COLOR 0x1800 +#define GL_DEPTH 0x1801 +#define GL_STENCIL 0x1802 +#define GL_DITHER 0x0BD0 +#define GL_RGB 0x1907 +#define GL_RGBA 0x1908 + +/* Clipping */ +#define GL_CLIP_PLANE0 0x3000 +#define GL_CLIP_PLANE1 0x3001 +#define GL_CLIP_PLANE2 0x3002 +#define GL_CLIP_PLANE3 0x3003 +#define GL_CLIP_PLANE4 0x3004 +#define GL_CLIP_PLANE5 0x3005 + +/* Depth buffer */ +#define GL_NEVER 0x0200 +#define GL_LESS 0x0201 +#define GL_EQUAL 0x0202 +#define GL_LEQUAL 0x0203 +#define GL_GREATER 0x0204 +#define GL_NOTEQUAL 0x0205 +#define GL_GEQUAL 0x0206 +#define GL_ALWAYS 0x0207 +#define GL_DEPTH_TEST 0x0B71 +#define GL_DEPTH_BITS 0x0D56 +#define GL_DEPTH_CLEAR_VALUE 0x0B73 +#define GL_DEPTH_FUNC 0x0B74 +#define GL_DEPTH_RANGE 0x0B70 +#define GL_DEPTH_WRITEMASK 0x0B72 +#define GL_DEPTH_COMPONENT 0x1902 + +/* Evaluators */ +#define GL_AUTO_NORMAL 0x0D80 +#define GL_MAP1_COLOR_4 0x0D90 +#define GL_MAP1_GRID_DOMAIN 0x0DD0 +#define GL_MAP1_GRID_SEGMENTS 0x0DD1 +#define GL_MAP1_INDEX 0x0D91 +#define GL_MAP1_NORMAL 0x0D92 +#define GL_MAP1_TEXTURE_COORD_1 0x0D93 +#define GL_MAP1_TEXTURE_COORD_2 0x0D94 +#define GL_MAP1_TEXTURE_COORD_3 0x0D95 +#define GL_MAP1_TEXTURE_COORD_4 0x0D96 +#define GL_MAP1_VERTEX_3 0x0D97 +#define GL_MAP1_VERTEX_4 0x0D98 +#define GL_MAP2_COLOR_4 0x0DB0 +#define GL_MAP2_GRID_DOMAIN 0x0DD2 +#define GL_MAP2_GRID_SEGMENTS 0x0DD3 +#define GL_MAP2_INDEX 0x0DB1 +#define GL_MAP2_NORMAL 0x0DB2 +#define GL_MAP2_TEXTURE_COORD_1 0x0DB3 +#define GL_MAP2_TEXTURE_COORD_2 0x0DB4 +#define GL_MAP2_TEXTURE_COORD_3 0x0DB5 +#define GL_MAP2_TEXTURE_COORD_4 0x0DB6 +#define GL_MAP2_VERTEX_3 0x0DB7 +#define GL_MAP2_VERTEX_4 0x0DB8 +#define GL_COEFF 0x0A00 +#define GL_DOMAIN 0x0A02 +#define GL_ORDER 0x0A01 + +/* Feedback */ +#define GL_2D 0x0600 +#define GL_3D 0x0601 +#define GL_3D_COLOR 0x0602 +#define GL_3D_COLOR_TEXTURE 0x0603 +#define GL_4D_COLOR_TEXTURE 0x0604 +#define GL_POINT_TOKEN 0x0701 +#define GL_LINE_TOKEN 0x0702 +#define GL_LINE_RESET_TOKEN 0x0707 +#define GL_POLYGON_TOKEN 0x0703 +#define GL_BITMAP_TOKEN 0x0704 +#define GL_DRAW_PIXEL_TOKEN 0x0705 +#define GL_COPY_PIXEL_TOKEN 0x0706 +#define GL_PASS_THROUGH_TOKEN 0x0700 +#define GL_FEEDBACK_BUFFER_POINTER 0x0DF0 +#define GL_FEEDBACK_BUFFER_SIZE 0x0DF1 +#define GL_FEEDBACK_BUFFER_TYPE 0x0DF2 + +/* Fog */ +#define GL_FOG 0x0B60 +#define GL_FOG_MODE 0x0B65 +#define GL_FOG_DENSITY 0x0B62 +#define GL_FOG_COLOR 0x0B66 +#define GL_FOG_INDEX 0x0B61 +#define GL_FOG_START 0x0B63 +#define GL_FOG_END 0x0B64 +#define GL_LINEAR 0x2601 +#define GL_EXP 0x0800 +#define GL_EXP2 0x0801 + +/* Gets */ +#define GL_ATTRIB_STACK_DEPTH 0x0BB0 +#define GL_CLIENT_ATTRIB_STACK_DEPTH 0x0BB1 +#define GL_COLOR_CLEAR_VALUE 0x0C22 +#define GL_COLOR_WRITEMASK 0x0C23 +#define GL_CURRENT_INDEX 0x0B01 +#define GL_CURRENT_COLOR 0x0B00 +#define GL_CURRENT_NORMAL 0x0B02 +#define GL_CURRENT_RASTER_COLOR 0x0B04 +#define GL_CURRENT_RASTER_DISTANCE 0x0B09 +#define GL_CURRENT_RASTER_INDEX 0x0B05 +#define GL_CURRENT_RASTER_POSITION 0x0B07 +#define GL_CURRENT_RASTER_TEXTURE_COORDS 0x0B06 +#define GL_CURRENT_RASTER_POSITION_VALID 0x0B08 +#define GL_CURRENT_TEXTURE_COORDS 0x0B03 +#define GL_INDEX_CLEAR_VALUE 0x0C20 +#define GL_INDEX_MODE 0x0C30 +#define GL_INDEX_WRITEMASK 0x0C21 +#define GL_MODELVIEW_MATRIX 0x0BA6 +#define GL_MODELVIEW_STACK_DEPTH 0x0BA3 +#define GL_NAME_STACK_DEPTH 0x0D70 +#define GL_PROJECTION_MATRIX 0x0BA7 +#define GL_PROJECTION_STACK_DEPTH 0x0BA4 +#define GL_RENDER_MODE 0x0C40 +#define GL_RGBA_MODE 0x0C31 +#define GL_TEXTURE_MATRIX 0x0BA8 +#define GL_TEXTURE_STACK_DEPTH 0x0BA5 +#define GL_VIEWPORT 0x0BA2 + +/* Hints */ +#define GL_FOG_HINT 0x0C54 +#define GL_LINE_SMOOTH_HINT 0x0C52 +#define GL_PERSPECTIVE_CORRECTION_HINT 0x0C50 +#define GL_POINT_SMOOTH_HINT 0x0C51 +#define GL_POLYGON_SMOOTH_HINT 0x0C53 +#define GL_DONT_CARE 0x1100 +#define GL_FASTEST 0x1101 +#define GL_NICEST 0x1102 + +/* Implementation limits */ +#define GL_MAX_LIST_NESTING 0x0B31 +#define GL_MAX_ATTRIB_STACK_DEPTH 0x0D35 +#define GL_MAX_MODELVIEW_STACK_DEPTH 0x0D36 +#define GL_MAX_NAME_STACK_DEPTH 0x0D37 +#define GL_MAX_PROJECTION_STACK_DEPTH 0x0D38 +#define GL_MAX_TEXTURE_STACK_DEPTH 0x0D39 +#define GL_MAX_EVAL_ORDER 0x0D30 +#define GL_MAX_LIGHTS 0x0D31 +#define GL_MAX_CLIP_PLANES 0x0D32 +#define GL_MAX_TEXTURE_SIZE 0x0D33 +#define GL_MAX_PIXEL_MAP_TABLE 0x0D34 +#define GL_MAX_VIEWPORT_DIMS 0x0D3A +#define GL_MAX_CLIENT_ATTRIB_STACK_DEPTH 0x0D3B + +/* Lighting */ +#define GL_LIGHTING 0x0B50 +#define GL_LIGHT0 0x4000 +#define GL_LIGHT1 0x4001 +#define GL_LIGHT2 0x4002 +#define GL_LIGHT3 0x4003 +#define GL_LIGHT4 0x4004 +#define GL_LIGHT5 0x4005 +#define GL_LIGHT6 0x4006 +#define GL_LIGHT7 0x4007 +#define GL_SPOT_EXPONENT 0x1205 +#define GL_SPOT_CUTOFF 0x1206 +#define GL_CONSTANT_ATTENUATION 0x1207 +#define GL_LINEAR_ATTENUATION 0x1208 +#define GL_QUADRATIC_ATTENUATION 0x1209 +#define GL_AMBIENT 0x1200 +#define GL_DIFFUSE 0x1201 +#define GL_SPECULAR 0x1202 +#define GL_SHININESS 0x1601 +#define GL_EMISSION 0x1600 +#define GL_POSITION 0x1203 +#define GL_SPOT_DIRECTION 0x1204 +#define GL_AMBIENT_AND_DIFFUSE 0x1602 +#define GL_COLOR_INDEXES 0x1603 +#define GL_LIGHT_MODEL_TWO_SIDE 0x0B52 +#define GL_LIGHT_MODEL_LOCAL_VIEWER 0x0B51 +#define GL_LIGHT_MODEL_AMBIENT 0x0B53 +#define GL_FRONT_AND_BACK 0x0408 +#define GL_SHADE_MODEL 0x0B54 +#define GL_FLAT 0x1D00 +#define GL_SMOOTH 0x1D01 +#define GL_COLOR_MATERIAL 0x0B57 +#define GL_COLOR_MATERIAL_FACE 0x0B55 +#define GL_COLOR_MATERIAL_PARAMETER 0x0B56 +#define GL_NORMALIZE 0x0BA1 + +/* Lines */ +#define GL_LINE_SMOOTH 0x0B20 +#define GL_LINE_STIPPLE 0x0B24 +#define GL_LINE_STIPPLE_PATTERN 0x0B25 +#define GL_LINE_STIPPLE_REPEAT 0x0B26 +#define GL_LINE_WIDTH 0x0B21 +#define GL_LINE_WIDTH_GRANULARITY 0x0B23 +#define GL_LINE_WIDTH_RANGE 0x0B22 + +/* Logic Ops */ +#define GL_LOGIC_OP 0x0BF1 +#define GL_INDEX_LOGIC_OP 0x0BF1 +#define GL_COLOR_LOGIC_OP 0x0BF2 +#define GL_LOGIC_OP_MODE 0x0BF0 +#define GL_CLEAR 0x1500 +#define GL_SET 0x150F +#define GL_COPY 0x1503 +#define GL_COPY_INVERTED 0x150C +#define GL_NOOP 0x1505 +#define GL_INVERT 0x150A +#define GL_AND 0x1501 +#define GL_NAND 0x150E +#define GL_OR 0x1507 +#define GL_NOR 0x1508 +#define GL_XOR 0x1506 +#define GL_EQUIV 0x1509 +#define GL_AND_REVERSE 0x1502 +#define GL_AND_INVERTED 0x1504 +#define GL_OR_REVERSE 0x150B +#define GL_OR_INVERTED 0x150D + +/* Matrix Mode */ +#define GL_MATRIX_MODE 0x0BA0 +#define GL_MODELVIEW 0x1700 +#define GL_PROJECTION 0x1701 +#define GL_TEXTURE 0x1702 + +/* Pixel Mode / Transfer */ +#define GL_MAP_COLOR 0x0D10 +#define GL_MAP_STENCIL 0x0D11 +#define GL_INDEX_SHIFT 0x0D12 +#define GL_INDEX_OFFSET 0x0D13 +#define GL_RED_SCALE 0x0D14 +#define GL_RED_BIAS 0x0D15 +#define GL_GREEN_SCALE 0x0D18 +#define GL_GREEN_BIAS 0x0D19 +#define GL_BLUE_SCALE 0x0D1A +#define GL_BLUE_BIAS 0x0D1B +#define GL_ALPHA_SCALE 0x0D1C +#define GL_ALPHA_BIAS 0x0D1D +#define GL_DEPTH_SCALE 0x0D1E +#define GL_DEPTH_BIAS 0x0D1F +#define GL_PIXEL_MAP_S_TO_S_SIZE 0x0CB1 +#define GL_PIXEL_MAP_I_TO_I_SIZE 0x0CB0 +#define GL_PIXEL_MAP_I_TO_R_SIZE 0x0CB2 +#define GL_PIXEL_MAP_I_TO_G_SIZE 0x0CB3 +#define GL_PIXEL_MAP_I_TO_B_SIZE 0x0CB4 +#define GL_PIXEL_MAP_I_TO_A_SIZE 0x0CB5 +#define GL_PIXEL_MAP_R_TO_R_SIZE 0x0CB6 +#define GL_PIXEL_MAP_G_TO_G_SIZE 0x0CB7 +#define GL_PIXEL_MAP_B_TO_B_SIZE 0x0CB8 +#define GL_PIXEL_MAP_A_TO_A_SIZE 0x0CB9 +#define GL_PIXEL_MAP_S_TO_S 0x0C71 +#define GL_PIXEL_MAP_I_TO_I 0x0C70 +#define GL_PIXEL_MAP_I_TO_R 0x0C72 +#define GL_PIXEL_MAP_I_TO_G 0x0C73 +#define GL_PIXEL_MAP_I_TO_B 0x0C74 +#define GL_PIXEL_MAP_I_TO_A 0x0C75 +#define GL_PIXEL_MAP_R_TO_R 0x0C76 +#define GL_PIXEL_MAP_G_TO_G 0x0C77 +#define GL_PIXEL_MAP_B_TO_B 0x0C78 +#define GL_PIXEL_MAP_A_TO_A 0x0C79 +#define GL_PACK_ALIGNMENT 0x0D05 +#define GL_PACK_LSB_FIRST 0x0D01 +#define GL_PACK_ROW_LENGTH 0x0D02 +#define GL_PACK_SKIP_PIXELS 0x0D04 +#define GL_PACK_SKIP_ROWS 0x0D03 +#define GL_PACK_SWAP_BYTES 0x0D00 +#define GL_UNPACK_ALIGNMENT 0x0CF5 +#define GL_UNPACK_LSB_FIRST 0x0CF1 +#define GL_UNPACK_ROW_LENGTH 0x0CF2 +#define GL_UNPACK_SKIP_PIXELS 0x0CF4 +#define GL_UNPACK_SKIP_ROWS 0x0CF3 +#define GL_UNPACK_SWAP_BYTES 0x0CF0 +#define GL_ZOOM_X 0x0D16 +#define GL_ZOOM_Y 0x0D17 + +/* Points */ +#define GL_POINT_SMOOTH 0x0B10 +#define GL_POINT_SIZE 0x0B11 +#define GL_POINT_SIZE_GRANULARITY 0x0B13 +#define GL_POINT_SIZE_RANGE 0x0B12 + +/* Polygons */ +#define GL_POINT 0x1B00 +#define GL_LINE 0x1B01 +#define GL_FILL 0x1B02 +#define GL_CW 0x0900 +#define GL_CCW 0x0901 +#define GL_FRONT 0x0404 +#define GL_BACK 0x0405 +#define GL_POLYGON_MODE 0x0B40 +#define GL_POLYGON_SMOOTH 0x0B41 +#define GL_POLYGON_STIPPLE 0x0B42 +#define GL_EDGE_FLAG 0x0B43 +#define GL_CULL_FACE 0x0B44 +#define GL_CULL_FACE_MODE 0x0B45 +#define GL_FRONT_FACE 0x0B46 +#define GL_POLYGON_OFFSET_FACTOR 0x8038 +#define GL_POLYGON_OFFSET_UNITS 0x2A00 +#define GL_POLYGON_OFFSET_POINT 0x2A01 +#define GL_POLYGON_OFFSET_LINE 0x2A02 +#define GL_POLYGON_OFFSET_FILL 0x8037 + +/* Primitives */ +#define GL_POINTS 0x0000 +#define GL_LINES 0x0001 +#define GL_LINE_LOOP 0x0002 +#define GL_LINE_STRIP 0x0003 +#define GL_TRIANGLES 0x0004 +#define GL_TRIANGLE_STRIP 0x0005 +#define GL_TRIANGLE_FAN 0x0006 +#define GL_QUADS 0x0007 +#define GL_QUAD_STRIP 0x0008 +#define GL_POLYGON 0x0009 + +/* Push/Pop bits */ +#define GL_CURRENT_BIT 0x00000001 +#define GL_POINT_BIT 0x00000002 +#define GL_LINE_BIT 0x00000004 +#define GL_POLYGON_BIT 0x00000008 +#define GL_POLYGON_STIPPLE_BIT 0x00000010 +#define GL_PIXEL_MODE_BIT 0x00000020 +#define GL_LIGHTING_BIT 0x00000040 +#define GL_FOG_BIT 0x00000080 +#define GL_DEPTH_BUFFER_BIT 0x00000100 +#define GL_ACCUM_BUFFER_BIT 0x00000200 +#define GL_STENCIL_BUFFER_BIT 0x00000400 +#define GL_VIEWPORT_BIT 0x00000800 +#define GL_TRANSFORM_BIT 0x00001000 +#define GL_ENABLE_BIT 0x00002000 +#define GL_COLOR_BUFFER_BIT 0x00004000 +#define GL_HINT_BIT 0x00008000 +#define GL_EVAL_BIT 0x00010000 +#define GL_LIST_BIT 0x00020000 +#define GL_TEXTURE_BIT 0x00040000 +#define GL_SCISSOR_BIT 0x00080000 +#define GL_ALL_ATTRIB_BITS 0x000FFFFF + +/* Render Mode */ +#define GL_FEEDBACK 0x1C01 +#define GL_RENDER 0x1C00 +#define GL_SELECT 0x1C02 + +/* Scissor box */ +#define GL_SCISSOR_TEST 0x0C11 +#define GL_SCISSOR_BOX 0x0C10 + +/* Stencil */ +#define GL_STENCIL_TEST 0x0B90 +#define GL_STENCIL_WRITEMASK 0x0B98 +#define GL_STENCIL_BITS 0x0D57 +#define GL_STENCIL_FUNC 0x0B92 +#define GL_STENCIL_VALUE_MASK 0x0B93 +#define GL_STENCIL_REF 0x0B97 +#define GL_STENCIL_FAIL 0x0B94 +#define GL_STENCIL_PASS_DEPTH_PASS 0x0B96 +#define GL_STENCIL_PASS_DEPTH_FAIL 0x0B95 +#define GL_STENCIL_CLEAR_VALUE 0x0B91 +#define GL_STENCIL_INDEX 0x1901 +#define GL_KEEP 0x1E00 +#define GL_REPLACE 0x1E01 +#define GL_INCR 0x1E02 +#define GL_DECR 0x1E03 + +/* Texture mapping */ +#define GL_TEXTURE_ENV 0x2300 +#define GL_TEXTURE_ENV_MODE 0x2200 +#define GL_TEXTURE_1D 0x0DE0 +#define GL_TEXTURE_2D 0x0DE1 +#define GL_TEXTURE_WRAP_S 0x2802 +#define GL_TEXTURE_WRAP_T 0x2803 +#define GL_TEXTURE_MAG_FILTER 0x2800 +#define GL_TEXTURE_MIN_FILTER 0x2801 +#define GL_TEXTURE_ENV_COLOR 0x2201 +#define GL_TEXTURE_GEN_S 0x0C60 +#define GL_TEXTURE_GEN_T 0x0C61 +#define GL_TEXTURE_GEN_MODE 0x2500 +#define GL_TEXTURE_BORDER_COLOR 0x1004 +#define GL_TEXTURE_WIDTH 0x1000 +#define GL_TEXTURE_HEIGHT 0x1001 +#define GL_TEXTURE_BORDER 0x1005 +#define GL_TEXTURE_COMPONENTS 0x1003 +#define GL_TEXTURE_RED_SIZE 0x805C +#define GL_TEXTURE_GREEN_SIZE 0x805D +#define GL_TEXTURE_BLUE_SIZE 0x805E +#define GL_TEXTURE_ALPHA_SIZE 0x805F +#define GL_TEXTURE_LUMINANCE_SIZE 0x8060 +#define GL_TEXTURE_INTENSITY_SIZE 0x8061 +#define GL_NEAREST_MIPMAP_NEAREST 0x2700 +#define GL_NEAREST_MIPMAP_LINEAR 0x2702 +#define GL_LINEAR_MIPMAP_NEAREST 0x2701 +#define GL_LINEAR_MIPMAP_LINEAR 0x2703 +#define GL_OBJECT_LINEAR 0x2401 +#define GL_OBJECT_PLANE 0x2501 +#define GL_EYE_LINEAR 0x2400 +#define GL_EYE_PLANE 0x2502 +#define GL_SPHERE_MAP 0x2402 +#define GL_DECAL 0x2101 +#define GL_MODULATE 0x2100 +#define GL_NEAREST 0x2600 +#define GL_REPEAT 0x2901 +#define GL_CLAMP 0x2900 +#define GL_S 0x2000 +#define GL_T 0x2001 +#define GL_R 0x2002 +#define GL_Q 0x2003 +#define GL_TEXTURE_GEN_R 0x0C62 +#define GL_TEXTURE_GEN_Q 0x0C63 + +/* Vertex Arrays */ +#define GL_VERTEX_ARRAY 0x8074 +#define GL_NORMAL_ARRAY 0x8075 +#define GL_COLOR_ARRAY 0x8076 +#define GL_INDEX_ARRAY 0x8077 +#define GL_TEXTURE_COORD_ARRAY 0x8078 +#define GL_EDGE_FLAG_ARRAY 0x8079 +#define GL_VERTEX_ARRAY_SIZE 0x807A +#define GL_VERTEX_ARRAY_TYPE 0x807B +#define GL_VERTEX_ARRAY_STRIDE 0x807C +#define GL_NORMAL_ARRAY_TYPE 0x807E +#define GL_NORMAL_ARRAY_STRIDE 0x807F +#define GL_COLOR_ARRAY_SIZE 0x8081 +#define GL_COLOR_ARRAY_TYPE 0x8082 +#define GL_COLOR_ARRAY_STRIDE 0x8083 +#define GL_INDEX_ARRAY_TYPE 0x8085 +#define GL_INDEX_ARRAY_STRIDE 0x8086 +#define GL_TEXTURE_COORD_ARRAY_SIZE 0x8088 +#define GL_TEXTURE_COORD_ARRAY_TYPE 0x8089 +#define GL_TEXTURE_COORD_ARRAY_STRIDE 0x808A +#define GL_EDGE_FLAG_ARRAY_STRIDE 0x808C +#define GL_VERTEX_ARRAY_POINTER 0x808E +#define GL_NORMAL_ARRAY_POINTER 0x808F +#define GL_COLOR_ARRAY_POINTER 0x8090 +#define GL_INDEX_ARRAY_POINTER 0x8091 +#define GL_TEXTURE_COORD_ARRAY_POINTER 0x8092 +#define GL_EDGE_FLAG_ARRAY_POINTER 0x8093 +#define GL_V2F 0x2A20 +#define GL_V3F 0x2A21 +#define GL_C4UB_V2F 0x2A22 +#define GL_C4UB_V3F 0x2A23 +#define GL_C3F_V3F 0x2A24 +#define GL_N3F_V3F 0x2A25 +#define GL_C4F_N3F_V3F 0x2A26 +#define GL_T2F_V3F 0x2A27 +#define GL_T4F_V4F 0x2A28 +#define GL_T2F_C4UB_V3F 0x2A29 +#define GL_T2F_C3F_V3F 0x2A2A +#define GL_T2F_N3F_V3F 0x2A2B +#define GL_T2F_C4F_N3F_V3F 0x2A2C +#define GL_T4F_C4F_N3F_V4F 0x2A2D + +/* OpenGL 1.1 */ +#define GL_PROXY_TEXTURE_1D 0x8063 +#define GL_PROXY_TEXTURE_2D 0x8064 +#define GL_TEXTURE_PRIORITY 0x8066 +#define GL_TEXTURE_RESIDENT 0x8067 +#define GL_TEXTURE_BINDING_1D 0x8068 +#define GL_TEXTURE_BINDING_2D 0x8069 +#define GL_TEXTURE_INTERNAL_FORMAT 0x1003 +#define GL_ALPHA4 0x803B +#define GL_ALPHA8 0x803C +#define GL_ALPHA12 0x803D +#define GL_ALPHA16 0x803E +#define GL_LUMINANCE4 0x803F +#define GL_LUMINANCE8 0x8040 +#define GL_LUMINANCE12 0x8041 +#define GL_LUMINANCE16 0x8042 +#define GL_LUMINANCE4_ALPHA4 0x8043 +#define GL_LUMINANCE6_ALPHA2 0x8044 +#define GL_LUMINANCE8_ALPHA8 0x8045 +#define GL_LUMINANCE12_ALPHA4 0x8046 +#define GL_LUMINANCE12_ALPHA12 0x8047 +#define GL_LUMINANCE16_ALPHA16 0x8048 +#define GL_INTENSITY 0x8049 +#define GL_INTENSITY4 0x804A +#define GL_INTENSITY8 0x804B +#define GL_INTENSITY12 0x804C +#define GL_INTENSITY16 0x804D +#define GL_R3_G3_B2 0x2A10 +#define GL_RGB4 0x804F +#define GL_RGB5 0x8050 +#define GL_RGB8 0x8051 +#define GL_RGB10 0x8052 +#define GL_RGB12 0x8053 +#define GL_RGB16 0x8054 +#define GL_RGBA2 0x8055 +#define GL_RGBA4 0x8056 +#define GL_RGB5_A1 0x8057 +#define GL_RGBA8 0x8058 +#define GL_RGB10_A2 0x8059 +#define GL_RGBA12 0x805A +#define GL_RGBA16 0x805B +#define GL_CLIENT_PIXEL_STORE_BIT 0x00000001 +#define GL_CLIENT_VERTEX_ARRAY_BIT 0x00000002 +#define GL_ALL_CLIENT_ATTRIB_BITS 0xFFFFFFFF +#define GL_CLIENT_ALL_ATTRIB_BITS 0xFFFFFFFF + +/* OpenGL 1.2 constants */ +#define GL_PACK_SKIP_IMAGES 0x806B +#define GL_PACK_IMAGE_HEIGHT 0x806C +#define GL_UNPACK_SKIP_IMAGES 0x806D +#define GL_UNPACK_IMAGE_HEIGHT 0x806E +#define GL_TEXTURE_3D 0x806F +#define GL_PROXY_TEXTURE_3D 0x8070 +#define GL_TEXTURE_DEPTH 0x8071 +#define GL_TEXTURE_WRAP_R 0x8072 +#define GL_MAX_3D_TEXTURE_SIZE 0x8073 +#define GL_BGR 0x80E0 +#define GL_BGRA 0x80E1 +#define GL_UNSIGNED_BYTE_3_3_2 0x8032 +#define GL_UNSIGNED_BYTE_2_3_3_REV 0x8362 +#define GL_UNSIGNED_SHORT_5_6_5 0x8363 +#define GL_UNSIGNED_SHORT_5_6_5_REV 0x8364 +#define GL_UNSIGNED_SHORT_4_4_4_4 0x8033 +#define GL_UNSIGNED_SHORT_4_4_4_4_REV 0x8365 +#define GL_UNSIGNED_SHORT_5_5_5_1 0x8034 +#define GL_UNSIGNED_SHORT_1_5_5_5_REV 0x8366 +#define GL_UNSIGNED_INT_8_8_8_8 0x8035 +#define GL_UNSIGNED_INT_8_8_8_8_REV 0x8367 +#define GL_UNSIGNED_INT_10_10_10_2 0x8036 +#define GL_UNSIGNED_INT_2_10_10_10_REV 0x8368 +#define GL_RESCALE_NORMAL 0x803A +#define GL_LIGHT_MODEL_COLOR_CONTROL 0x81F8 +#define GL_SINGLE_COLOR 0x81F9 +#define GL_SEPARATE_SPECULAR_COLOR 0x81FA +#define GL_CLAMP_TO_EDGE 0x812F +#define GL_TEXTURE_MIN_LOD 0x813A +#define GL_TEXTURE_MAX_LOD 0x813B +#define GL_TEXTURE_BASE_LEVEL 0x813C +#define GL_TEXTURE_MAX_LEVEL 0x813D +#define GL_MAX_ELEMENTS_VERTICES 0x80E8 +#define GL_MAX_ELEMENTS_INDICES 0x80E9 +#define GL_ALIASED_POINT_SIZE_RANGE 0x846D +#define GL_ALIASED_LINE_WIDTH_RANGE 0x846E + +/* OpenGL 1.3 constants */ +#define GL_ACTIVE_TEXTURE 0x84E0 +#define GL_CLIENT_ACTIVE_TEXTURE 0x84E1 +#define GL_MAX_TEXTURE_UNITS 0x84E2 +#define GL_TEXTURE0 0x84C0 +#define GL_TEXTURE1 0x84C1 +#define GL_TEXTURE2 0x84C2 +#define GL_TEXTURE3 0x84C3 +#define GL_TEXTURE4 0x84C4 +#define GL_TEXTURE5 0x84C5 +#define GL_TEXTURE6 0x84C6 +#define GL_TEXTURE7 0x84C7 +#define GL_TEXTURE8 0x84C8 +#define GL_TEXTURE9 0x84C9 +#define GL_TEXTURE10 0x84CA +#define GL_TEXTURE11 0x84CB +#define GL_TEXTURE12 0x84CC +#define GL_TEXTURE13 0x84CD +#define GL_TEXTURE14 0x84CE +#define GL_TEXTURE15 0x84CF +#define GL_TEXTURE16 0x84D0 +#define GL_TEXTURE17 0x84D1 +#define GL_TEXTURE18 0x84D2 +#define GL_TEXTURE19 0x84D3 +#define GL_TEXTURE20 0x84D4 +#define GL_TEXTURE21 0x84D5 +#define GL_TEXTURE22 0x84D6 +#define GL_TEXTURE23 0x84D7 +#define GL_TEXTURE24 0x84D8 +#define GL_TEXTURE25 0x84D9 +#define GL_TEXTURE26 0x84DA +#define GL_TEXTURE27 0x84DB +#define GL_TEXTURE28 0x84DC +#define GL_TEXTURE29 0x84DD +#define GL_TEXTURE30 0x84DE +#define GL_TEXTURE31 0x84DF +#define GL_NORMAL_MAP 0x8511 +#define GL_REFLECTION_MAP 0x8512 +#define GL_TEXTURE_CUBE_MAP 0x8513 +#define GL_TEXTURE_BINDING_CUBE_MAP 0x8514 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_X 0x8515 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_X 0x8516 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_Y 0x8517 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y 0x8518 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_Z 0x8519 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z 0x851A +#define GL_PROXY_TEXTURE_CUBE_MAP 0x851B +#define GL_MAX_CUBE_MAP_TEXTURE_SIZE 0x851C +#define GL_COMBINE 0x8570 +#define GL_COMBINE_RGB 0x8571 +#define GL_COMBINE_ALPHA 0x8572 +#define GL_RGB_SCALE 0x8573 +#define GL_ADD_SIGNED 0x8574 +#define GL_INTERPOLATE 0x8575 +#define GL_CONSTANT 0x8576 +#define GL_PRIMARY_COLOR 0x8577 +#define GL_PREVIOUS 0x8578 +#define GL_SOURCE0_RGB 0x8580 +#define GL_SOURCE1_RGB 0x8581 +#define GL_SOURCE2_RGB 0x8582 +#define GL_SOURCE0_ALPHA 0x8588 +#define GL_SOURCE1_ALPHA 0x8589 +#define GL_SOURCE2_ALPHA 0x858A +#define GL_OPERAND0_RGB 0x8590 +#define GL_OPERAND1_RGB 0x8591 +#define GL_OPERAND2_RGB 0x8592 +#define GL_OPERAND0_ALPHA 0x8598 +#define GL_OPERAND1_ALPHA 0x8599 +#define GL_OPERAND2_ALPHA 0x859A +#define GL_SUBTRACT 0x84E7 +#define GL_TRANSPOSE_MODELVIEW_MATRIX 0x84E3 +#define GL_TRANSPOSE_PROJECTION_MATRIX 0x84E4 +#define GL_TRANSPOSE_TEXTURE_MATRIX 0x84E5 +#define GL_TRANSPOSE_COLOR_MATRIX 0x84E6 +#define GL_COMPRESSED_ALPHA 0x84E9 +#define GL_COMPRESSED_LUMINANCE 0x84EA +#define GL_COMPRESSED_LUMINANCE_ALPHA 0x84EB +#define GL_COMPRESSED_INTENSITY 0x84EC +#define GL_COMPRESSED_RGB 0x84ED +#define GL_COMPRESSED_RGBA 0x84EE +#define GL_TEXTURE_COMPRESSION_HINT 0x84EF +#define GL_TEXTURE_COMPRESSED_IMAGE_SIZE 0x86A0 +#define GL_TEXTURE_COMPRESSED 0x86A1 +#define GL_NUM_COMPRESSED_TEXTURE_FORMATS 0x86A2 +#define GL_COMPRESSED_TEXTURE_FORMATS 0x86A3 +#define GL_DOT3_RGB 0x86AE +#define GL_DOT3_RGBA 0x86AF +#define GL_CLAMP_TO_BORDER 0x812D +#define GL_MULTISAMPLE 0x809D +#define GL_SAMPLE_ALPHA_TO_COVERAGE 0x809E +#define GL_SAMPLE_ALPHA_TO_ONE 0x809F +#define GL_SAMPLE_COVERAGE 0x80A0 +#define GL_SAMPLE_BUFFERS 0x80A8 +#define GL_SAMPLES 0x80A9 +#define GL_SAMPLE_COVERAGE_VALUE 0x80AA +#define GL_SAMPLE_COVERAGE_INVERT 0x80AB +#define GL_MULTISAMPLE_BIT 0x20000000 + +void (WINE_GLAPI *glAccum) (GLenum op, GLfloat value); +void (WINE_GLAPI *glAlphaFunc) (GLenum func, GLclampf ref); +GLboolean (WINE_GLAPI *glAreTexturesResident) (GLsizei n, const GLuint* textures, const GLboolean* residences); +void (WINE_GLAPI *glArrayElement) (GLint i); +void (WINE_GLAPI *glBegin) (GLenum mode); +void (WINE_GLAPI *glBindTexture) (GLenum target, GLuint texture); +void (WINE_GLAPI *glBitmap) (GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte* bitmap); +void (WINE_GLAPI *glBlendFunc) (GLenum sfactor, GLenum dfactor); +void (WINE_GLAPI *glCallList) (GLuint list); +void (WINE_GLAPI *glCallLists) (GLsizei n, GLenum type, const GLvoid* lists); +void (WINE_GLAPI *glClear) (GLbitfield mask); +void (WINE_GLAPI *glClearAccum) (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void (WINE_GLAPI *glClearColor) (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha); +void (WINE_GLAPI *glClearDepth) (GLclampd depth); +void (WINE_GLAPI *glClearIndex) (GLfloat c); +void (WINE_GLAPI *glClearStencil) (GLint s); +void (WINE_GLAPI *glClipPlane) (GLenum plane, const GLdouble* equation); +void (WINE_GLAPI *glColor3b) (GLbyte red, GLbyte green, GLbyte blue); +void (WINE_GLAPI *glColor3bv) (const GLbyte* v); +void (WINE_GLAPI *glColor3d) (GLdouble red, GLdouble green, GLdouble blue); +void (WINE_GLAPI *glColor3dv) (const GLdouble* v); +void (WINE_GLAPI *glColor3f) (GLfloat red, GLfloat green, GLfloat blue); +void (WINE_GLAPI *glColor3fv) (const GLfloat* v); +void (WINE_GLAPI *glColor3i) (GLint red, GLint green, GLint blue); +void (WINE_GLAPI *glColor3iv) (const GLint* v); +void (WINE_GLAPI *glColor3s) (GLshort red, GLshort green, GLshort blue); +void (WINE_GLAPI *glColor3sv) (const GLshort* v); +void (WINE_GLAPI *glColor3ub) (GLubyte red, GLubyte green, GLubyte blue); +void (WINE_GLAPI *glColor3ubv) (const GLubyte* v); +void (WINE_GLAPI *glColor3ui) (GLuint red, GLuint green, GLuint blue); +void (WINE_GLAPI *glColor3uiv) (const GLuint* v); +void (WINE_GLAPI *glColor3us) (GLushort red, GLushort green, GLushort blue); +void (WINE_GLAPI *glColor3usv) (const GLushort* v); +void (WINE_GLAPI *glColor4b) (GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha); +void (WINE_GLAPI *glColor4bv) (const GLbyte* v); +void (WINE_GLAPI *glColor4d) (GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha); +void (WINE_GLAPI *glColor4dv) (const GLdouble* v); +void (WINE_GLAPI *glColor4f) (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void (WINE_GLAPI *glColor4fv) (const GLfloat* v); +void (WINE_GLAPI *glColor4i) (GLint red, GLint green, GLint blue, GLint alpha); +void (WINE_GLAPI *glColor4iv) (const GLint* v); +void (WINE_GLAPI *glColor4s) (GLshort red, GLshort green, GLshort blue, GLshort alpha); +void (WINE_GLAPI *glColor4sv) (const GLshort* v); +void (WINE_GLAPI *glColor4ub) (GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha); +void (WINE_GLAPI *glColor4ubv) (const GLubyte* v); +void (WINE_GLAPI *glColor4ui) (GLuint red, GLuint green, GLuint blue, GLuint alpha); +void (WINE_GLAPI *glColor4uiv) (const GLuint* v); +void (WINE_GLAPI *glColor4us) (GLushort red, GLushort green, GLushort blue, GLushort alpha); +void (WINE_GLAPI *glColor4usv) (const GLushort* v); +void (WINE_GLAPI *glColorMask) (GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); +void (WINE_GLAPI *glColorMaterial) (GLenum face, GLenum mode); +void (WINE_GLAPI *glColorPointer) (GLint size, GLenum type, GLsizei stride, const GLvoid* pointer); +void (WINE_GLAPI *glCopyPixels) (GLint x, GLint y, GLsizei width, GLsizei height, GLenum type); +void (WINE_GLAPI *glCopyTexImage1D) (GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border); +void (WINE_GLAPI *glCopyTexImage2D) (GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); +void (WINE_GLAPI *glCopyTexSubImage1D) (GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width); +void (WINE_GLAPI *glCopyTexSubImage2D) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); +void (WINE_GLAPI *glCullFace) (GLenum mode); +void (WINE_GLAPI *glDeleteLists) (GLuint list, GLsizei range); +void (WINE_GLAPI *glDeleteTextures) (GLsizei n, const GLuint* textures); +void (WINE_GLAPI *glDepthFunc) (GLenum func); +void (WINE_GLAPI *glDepthMask) (GLboolean flag); +void (WINE_GLAPI *glDepthRange) (GLclampd nearParam, GLclampd farParam); +void (WINE_GLAPI *glDisable) (GLenum cap); +void (WINE_GLAPI *glDisableClientState) (GLenum array); +void (WINE_GLAPI *glDrawArrays) (GLenum mode, GLint first, GLsizei count); +void (WINE_GLAPI *glDrawBuffer) (GLenum mode); +void (WINE_GLAPI *glDrawElements) (GLenum mode, GLsizei count, GLenum type, const GLvoid* indices); +void (WINE_GLAPI *glDrawPixels) (GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid* pixels); +void (WINE_GLAPI *glEdgeFlag) (GLboolean flag); +void (WINE_GLAPI *glEdgeFlagPointer) (GLsizei stride, const GLvoid* pointer); +void (WINE_GLAPI *glEdgeFlagv) (const GLboolean* flag); +void (WINE_GLAPI *glEnable) (GLenum cap); +void (WINE_GLAPI *glEnableClientState) (GLenum array); +void (WINE_GLAPI *glEnd) (); +void (WINE_GLAPI *glEndList) (); +void (WINE_GLAPI *glEvalCoord1d) (GLdouble u); +void (WINE_GLAPI *glEvalCoord1dv) (const GLdouble* u); +void (WINE_GLAPI *glEvalCoord1f) (GLfloat u); +void (WINE_GLAPI *glEvalCoord1fv) (const GLfloat* u); +void (WINE_GLAPI *glEvalCoord2d) (GLdouble u, GLdouble v); +void (WINE_GLAPI *glEvalCoord2dv) (const GLdouble* u); +void (WINE_GLAPI *glEvalCoord2f) (GLfloat u, GLfloat v); +void (WINE_GLAPI *glEvalCoord2fv) (const GLfloat* u); +void (WINE_GLAPI *glEvalMesh1) (GLenum mode, GLint i1, GLint i2); +void (WINE_GLAPI *glEvalMesh2) (GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2); +void (WINE_GLAPI *glEvalPoint1) (GLint i); +void (WINE_GLAPI *glEvalPoint2) (GLint i, GLint j); +void (WINE_GLAPI *glFeedbackBuffer) (GLsizei size, GLenum type, const GLfloat* buffer); +void (WINE_GLAPI *glFinish) (); +void (WINE_GLAPI *glFlush) (); +void (WINE_GLAPI *glFogf) (GLenum pname, GLfloat param); +void (WINE_GLAPI *glFogfv) (GLenum pname, const GLfloat* params); +void (WINE_GLAPI *glFogi) (GLenum pname, GLint param); +void (WINE_GLAPI *glFogiv) (GLenum pname, const GLint* params); +void (WINE_GLAPI *glFrontFace) (GLenum mode); +void (WINE_GLAPI *glFrustum) (GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); +GLuint (WINE_GLAPI *glGenLists) (GLsizei range); +void (WINE_GLAPI *glGenTextures) (GLsizei n, const GLuint* textures); +void (WINE_GLAPI *glGetBooleanv) (GLenum pname, const GLboolean* params); +void (WINE_GLAPI *glGetClipPlane) (GLenum plane, const GLdouble* equation); +void (WINE_GLAPI *glGetDoublev) (GLenum pname, const GLdouble* params); +GLenum (WINE_GLAPI *glGetError) (); +void (WINE_GLAPI *glGetFloatv) (GLenum pname, const GLfloat* params); +void (WINE_GLAPI *glGetIntegerv) (GLenum pname, const GLint* params); +void (WINE_GLAPI *glGetLightfv) (GLenum light, GLenum pname, const GLfloat* params); +void (WINE_GLAPI *glGetLightiv) (GLenum light, GLenum pname, const GLint* params); +void (WINE_GLAPI *glGetMapdv) (GLenum target, GLenum query, const GLdouble* v); +void (WINE_GLAPI *glGetMapfv) (GLenum target, GLenum query, const GLfloat* v); +void (WINE_GLAPI *glGetMapiv) (GLenum target, GLenum query, const GLint* v); +void (WINE_GLAPI *glGetMaterialfv) (GLenum face, GLenum pname, const GLfloat* params); +void (WINE_GLAPI *glGetMaterialiv) (GLenum face, GLenum pname, const GLint* params); +void (WINE_GLAPI *glGetPixelMapfv) (GLenum map, const GLfloat* values); +void (WINE_GLAPI *glGetPixelMapuiv) (GLenum map, const GLuint* values); +void (WINE_GLAPI *glGetPixelMapusv) (GLenum map, const GLushort* values); +void (WINE_GLAPI *glGetPointerv) (GLenum pname, const GLvoid** params); +void (WINE_GLAPI *glGetPolygonStipple) (const GLubyte* mask); +const GLubyte * (WINE_GLAPI *glGetString) (GLenum name); +void (WINE_GLAPI *glGetTexEnvfv) (GLenum target, GLenum pname, const GLfloat* params); +void (WINE_GLAPI *glGetTexEnviv) (GLenum target, GLenum pname, const GLint* params); +void (WINE_GLAPI *glGetTexGendv) (GLenum coord, GLenum pname, const GLdouble* params); +void (WINE_GLAPI *glGetTexGenfv) (GLenum coord, GLenum pname, const GLfloat* params); +void (WINE_GLAPI *glGetTexGeniv) (GLenum coord, GLenum pname, const GLint* params); +void (WINE_GLAPI *glGetTexImage) (GLenum target, GLint level, GLenum format, GLenum type, const GLvoid* pixels); +void (WINE_GLAPI *glGetTexLevelParameterfv) (GLenum target, GLint level, GLenum pname, const GLfloat* params); +void (WINE_GLAPI *glGetTexLevelParameteriv) (GLenum target, GLint level, GLenum pname, const GLint* params); +void (WINE_GLAPI *glGetTexParameterfv) (GLenum target, GLenum pname, const GLfloat* params); +void (WINE_GLAPI *glGetTexParameteriv) (GLenum target, GLenum pname, const GLint* params); +void (WINE_GLAPI *glHint) (GLenum target, GLenum mode); +void (WINE_GLAPI *glIndexMask) (GLuint mask); +void (WINE_GLAPI *glIndexPointer) (GLenum type, GLsizei stride, const GLvoid* pointer); +void (WINE_GLAPI *glIndexd) (GLdouble c); +void (WINE_GLAPI *glIndexdv) (const GLdouble* c); +void (WINE_GLAPI *glIndexf) (GLfloat c); +void (WINE_GLAPI *glIndexfv) (const GLfloat* c); +void (WINE_GLAPI *glIndexi) (GLint c); +void (WINE_GLAPI *glIndexiv) (const GLint* c); +void (WINE_GLAPI *glIndexs) (GLshort c); +void (WINE_GLAPI *glIndexsv) (const GLshort* c); +void (WINE_GLAPI *glIndexub) (GLubyte c); +void (WINE_GLAPI *glIndexubv) (const GLubyte* c); +void (WINE_GLAPI *glInitNames) (); +void (WINE_GLAPI *glInterleavedArrays) (GLenum format, GLsizei stride, const GLvoid* pointer); +GLboolean (WINE_GLAPI *glIsEnabled) (GLenum cap); +GLboolean (WINE_GLAPI *glIsList) (GLuint list); +GLboolean (WINE_GLAPI *glIsTexture) (GLuint texture); +void (WINE_GLAPI *glLightModelf) (GLenum pname, GLfloat param); +void (WINE_GLAPI *glLightModelfv) (GLenum pname, const GLfloat* params); +void (WINE_GLAPI *glLightModeli) (GLenum pname, GLint param); +void (WINE_GLAPI *glLightModeliv) (GLenum pname, const GLint* params); +void (WINE_GLAPI *glLightf) (GLenum light, GLenum pname, GLfloat param); +void (WINE_GLAPI *glLightfv) (GLenum light, GLenum pname, const GLfloat* params); +void (WINE_GLAPI *glLighti) (GLenum light, GLenum pname, GLint param); +void (WINE_GLAPI *glLightiv) (GLenum light, GLenum pname, const GLint* params); +void (WINE_GLAPI *glLineStipple) (GLint factor, GLushort pattern); +void (WINE_GLAPI *glLineWidth) (GLfloat width); +void (WINE_GLAPI *glListBase) (GLuint base); +void (WINE_GLAPI *glLoadIdentity) (); +void (WINE_GLAPI *glLoadMatrixd) (const GLdouble* m); +void (WINE_GLAPI *glLoadMatrixf) (const GLfloat* m); +void (WINE_GLAPI *glLoadName) (GLuint name); +void (WINE_GLAPI *glLogicOp) (GLenum opcode); +void (WINE_GLAPI *glMap1d) (GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble* points); +void (WINE_GLAPI *glMap1f) (GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat* points); +void (WINE_GLAPI *glMap2d) (GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble* points); +void (WINE_GLAPI *glMap2f) (GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat* points); +void (WINE_GLAPI *glMapGrid1d) (GLint un, GLdouble u1, GLdouble u2); +void (WINE_GLAPI *glMapGrid1f) (GLint un, GLfloat u1, GLfloat u2); +void (WINE_GLAPI *glMapGrid2d) (GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2); +void (WINE_GLAPI *glMapGrid2f) (GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2); +void (WINE_GLAPI *glMaterialf) (GLenum face, GLenum pname, GLfloat param); +void (WINE_GLAPI *glMaterialfv) (GLenum face, GLenum pname, const GLfloat* params); +void (WINE_GLAPI *glMateriali) (GLenum face, GLenum pname, GLint param); +void (WINE_GLAPI *glMaterialiv) (GLenum face, GLenum pname, const GLint* params); +void (WINE_GLAPI *glMatrixMode) (GLenum mode); +void (WINE_GLAPI *glMultMatrixd) (const GLdouble* m); +void (WINE_GLAPI *glMultMatrixf) (const GLfloat* m); +void (WINE_GLAPI *glNewList) (GLuint list, GLenum mode); +void (WINE_GLAPI *glNormal3b) (GLbyte nx, GLbyte ny, GLbyte nz); +void (WINE_GLAPI *glNormal3bv) (const GLbyte* v); +void (WINE_GLAPI *glNormal3d) (GLdouble nx, GLdouble ny, GLdouble nz); +void (WINE_GLAPI *glNormal3dv) (const GLdouble* v); +void (WINE_GLAPI *glNormal3f) (GLfloat nx, GLfloat ny, GLfloat nz); +void (WINE_GLAPI *glNormal3fv) (const GLfloat* v); +void (WINE_GLAPI *glNormal3i) (GLint nx, GLint ny, GLint nz); +void (WINE_GLAPI *glNormal3iv) (const GLint* v); +void (WINE_GLAPI *glNormal3s) (GLshort nx, GLshort ny, GLshort nz); +void (WINE_GLAPI *glNormal3sv) (const GLshort* v); +void (WINE_GLAPI *glNormalPointer) (GLenum type, GLsizei stride, const GLvoid* pointer); +void (WINE_GLAPI *glOrtho) (GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); +void (WINE_GLAPI *glPassThrough) (GLfloat token); +void (WINE_GLAPI *glPixelMapfv) (GLenum map, GLint mapsize, const GLfloat* values); +void (WINE_GLAPI *glPixelMapuiv) (GLenum map, GLint mapsize, const GLuint* values); +void (WINE_GLAPI *glPixelMapusv) (GLenum map, GLint mapsize, const GLushort* values); +void (WINE_GLAPI *glPixelStoref) (GLenum pname, GLfloat param); +void (WINE_GLAPI *glPixelStorei) (GLenum pname, GLint param); +void (WINE_GLAPI *glPixelTransferf) (GLenum pname, GLfloat param); +void (WINE_GLAPI *glPixelTransferi) (GLenum pname, GLint param); +void (WINE_GLAPI *glPixelZoom) (GLfloat xfactor, GLfloat yfactor); +void (WINE_GLAPI *glPointSize) (GLfloat size); +void (WINE_GLAPI *glPolygonMode) (GLenum face, GLenum mode); +void (WINE_GLAPI *glPolygonOffset) (GLfloat factor, GLfloat units); +void (WINE_GLAPI *glPolygonStipple) (const GLubyte* mask); +void (WINE_GLAPI *glPopAttrib) (); +void (WINE_GLAPI *glPopClientAttrib) (); +void (WINE_GLAPI *glPopMatrix) (); +void (WINE_GLAPI *glPopName) (); +void (WINE_GLAPI *glPrioritizeTextures) (GLsizei n, const GLuint* textures, const GLclampf* priorities); +void (WINE_GLAPI *glPushAttrib) (GLbitfield mask); +void (WINE_GLAPI *glPushClientAttrib) (GLbitfield mask); +void (WINE_GLAPI *glPushMatrix) (); +void (WINE_GLAPI *glPushName) (GLuint name); +void (WINE_GLAPI *glRasterPos2d) (GLdouble x, GLdouble y); +void (WINE_GLAPI *glRasterPos2dv) (const GLdouble* v); +void (WINE_GLAPI *glRasterPos2f) (GLfloat x, GLfloat y); +void (WINE_GLAPI *glRasterPos2fv) (const GLfloat* v); +void (WINE_GLAPI *glRasterPos2i) (GLint x, GLint y); +void (WINE_GLAPI *glRasterPos2iv) (const GLint* v); +void (WINE_GLAPI *glRasterPos2s) (GLshort x, GLshort y); +void (WINE_GLAPI *glRasterPos2sv) (const GLshort* v); +void (WINE_GLAPI *glRasterPos3d) (GLdouble x, GLdouble y, GLdouble z); +void (WINE_GLAPI *glRasterPos3dv) (const GLdouble* v); +void (WINE_GLAPI *glRasterPos3f) (GLfloat x, GLfloat y, GLfloat z); +void (WINE_GLAPI *glRasterPos3fv) (const GLfloat* v); +void (WINE_GLAPI *glRasterPos3i) (GLint x, GLint y, GLint z); +void (WINE_GLAPI *glRasterPos3iv) (const GLint* v); +void (WINE_GLAPI *glRasterPos3s) (GLshort x, GLshort y, GLshort z); +void (WINE_GLAPI *glRasterPos3sv) (const GLshort* v); +void (WINE_GLAPI *glRasterPos4d) (GLdouble x, GLdouble y, GLdouble z, GLdouble w); +void (WINE_GLAPI *glRasterPos4dv) (const GLdouble* v); +void (WINE_GLAPI *glRasterPos4f) (GLfloat x, GLfloat y, GLfloat z, GLfloat w); +void (WINE_GLAPI *glRasterPos4fv) (const GLfloat* v); +void (WINE_GLAPI *glRasterPos4i) (GLint x, GLint y, GLint z, GLint w); +void (WINE_GLAPI *glRasterPos4iv) (const GLint* v); +void (WINE_GLAPI *glRasterPos4s) (GLshort x, GLshort y, GLshort z, GLshort w); +void (WINE_GLAPI *glRasterPos4sv) (const GLshort* v); +void (WINE_GLAPI *glReadBuffer) (GLenum mode); +void (WINE_GLAPI *glReadPixels) (GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid* pixels); +void (WINE_GLAPI *glRectd) (GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2); +void (WINE_GLAPI *glRectdv) (const GLdouble* v1, const GLdouble* v2); +void (WINE_GLAPI *glRectf) (GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2); +void (WINE_GLAPI *glRectfv) (const GLfloat* v1, const GLfloat* v2); +void (WINE_GLAPI *glRecti) (GLint x1, GLint y1, GLint x2, GLint y2); +void (WINE_GLAPI *glRectiv) (const GLint* v1, const GLint* v2); +void (WINE_GLAPI *glRects) (GLshort x1, GLshort y1, GLshort x2, GLshort y2); +void (WINE_GLAPI *glRectsv) (const GLshort* v1, const GLshort* v2); +GLint (WINE_GLAPI *glRenderMode) (GLenum mode); +void (WINE_GLAPI *glRotated) (GLdouble angle, GLdouble x, GLdouble y, GLdouble z); +void (WINE_GLAPI *glRotatef) (GLfloat angle, GLfloat x, GLfloat y, GLfloat z); +void (WINE_GLAPI *glScaled) (GLdouble x, GLdouble y, GLdouble z); +void (WINE_GLAPI *glScalef) (GLfloat x, GLfloat y, GLfloat z); +void (WINE_GLAPI *glScissor) (GLint x, GLint y, GLsizei width, GLsizei height); +void (WINE_GLAPI *glSelectBuffer) (GLsizei size, const GLuint* buffer); +void (WINE_GLAPI *glShadeModel) (GLenum mode); +void (WINE_GLAPI *glStencilFunc) (GLenum func, GLint ref, GLuint mask); +void (WINE_GLAPI *glStencilMask) (GLuint mask); +void (WINE_GLAPI *glStencilOp) (GLenum fail, GLenum zfail, GLenum zpass); +void (WINE_GLAPI *glTexCoord1d) (GLdouble s); +void (WINE_GLAPI *glTexCoord1dv) (const GLdouble* v); +void (WINE_GLAPI *glTexCoord1f) (GLfloat s); +void (WINE_GLAPI *glTexCoord1fv) (const GLfloat* v); +void (WINE_GLAPI *glTexCoord1i) (GLint s); +void (WINE_GLAPI *glTexCoord1iv) (const GLint* v); +void (WINE_GLAPI *glTexCoord1s) (GLshort s); +void (WINE_GLAPI *glTexCoord1sv) (const GLshort* v); +void (WINE_GLAPI *glTexCoord2d) (GLdouble s, GLdouble t); +void (WINE_GLAPI *glTexCoord2dv) (const GLdouble* v); +void (WINE_GLAPI *glTexCoord2f) (GLfloat s, GLfloat t); +void (WINE_GLAPI *glTexCoord2fv) (const GLfloat* v); +void (WINE_GLAPI *glTexCoord2i) (GLint s, GLint t); +void (WINE_GLAPI *glTexCoord2iv) (const GLint* v); +void (WINE_GLAPI *glTexCoord2s) (GLshort s, GLshort t); +void (WINE_GLAPI *glTexCoord2sv) (const GLshort* v); +void (WINE_GLAPI *glTexCoord3d) (GLdouble s, GLdouble t, GLdouble r); +void (WINE_GLAPI *glTexCoord3dv) (const GLdouble* v); +void (WINE_GLAPI *glTexCoord3f) (GLfloat s, GLfloat t, GLfloat r); +void (WINE_GLAPI *glTexCoord3fv) (const GLfloat* v); +void (WINE_GLAPI *glTexCoord3i) (GLint s, GLint t, GLint r); +void (WINE_GLAPI *glTexCoord3iv) (const GLint* v); +void (WINE_GLAPI *glTexCoord3s) (GLshort s, GLshort t, GLshort r); +void (WINE_GLAPI *glTexCoord3sv) (const GLshort* v); +void (WINE_GLAPI *glTexCoord4d) (GLdouble s, GLdouble t, GLdouble r, GLdouble q); +void (WINE_GLAPI *glTexCoord4dv) (const GLdouble* v); +void (WINE_GLAPI *glTexCoord4f) (GLfloat s, GLfloat t, GLfloat r, GLfloat q); +void (WINE_GLAPI *glTexCoord4fv) (const GLfloat* v); +void (WINE_GLAPI *glTexCoord4i) (GLint s, GLint t, GLint r, GLint q); +void (WINE_GLAPI *glTexCoord4iv) (const GLint* v); +void (WINE_GLAPI *glTexCoord4s) (GLshort s, GLshort t, GLshort r, GLshort q); +void (WINE_GLAPI *glTexCoord4sv) (const GLshort* v); +void (WINE_GLAPI *glTexCoordPointer) (GLint size, GLenum type, GLsizei stride, const GLvoid* pointer); +void (WINE_GLAPI *glTexEnvf) (GLenum target, GLenum pname, GLfloat param); +void (WINE_GLAPI *glTexEnvfv) (GLenum target, GLenum pname, const GLfloat* params); +void (WINE_GLAPI *glTexEnvi) (GLenum target, GLenum pname, GLint param); +void (WINE_GLAPI *glTexEnviv) (GLenum target, GLenum pname, const GLint* params); +void (WINE_GLAPI *glTexGend) (GLenum coord, GLenum pname, GLdouble param); +void (WINE_GLAPI *glTexGendv) (GLenum coord, GLenum pname, const GLdouble* params); +void (WINE_GLAPI *glTexGenf) (GLenum coord, GLenum pname, GLfloat param); +void (WINE_GLAPI *glTexGenfv) (GLenum coord, GLenum pname, const GLfloat* params); +void (WINE_GLAPI *glTexGeni) (GLenum coord, GLenum pname, GLint param); +void (WINE_GLAPI *glTexGeniv) (GLenum coord, GLenum pname, const GLint* params); +void (WINE_GLAPI *glTexImage1D) (GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid* pixels); +void (WINE_GLAPI *glTexImage2D) (GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid* pixels); +void (WINE_GLAPI *glTexParameterf) (GLenum target, GLenum pname, GLfloat param); +void (WINE_GLAPI *glTexParameterfv) (GLenum target, GLenum pname, const GLfloat* params); +void (WINE_GLAPI *glTexParameteri) (GLenum target, GLenum pname, GLint param); +void (WINE_GLAPI *glTexParameteriv) (GLenum target, GLenum pname, const GLint* params); +void (WINE_GLAPI *glTexSubImage1D) (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid* pixels); +void (WINE_GLAPI *glTexSubImage2D) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid* pixels); +void (WINE_GLAPI *glTranslated) (GLdouble x, GLdouble y, GLdouble z); +void (WINE_GLAPI *glTranslatef) (GLfloat x, GLfloat y, GLfloat z); +void (WINE_GLAPI *glVertex2d) (GLdouble x, GLdouble y); +void (WINE_GLAPI *glVertex2dv) (const GLdouble* v); +void (WINE_GLAPI *glVertex2f) (GLfloat x, GLfloat y); +void (WINE_GLAPI *glVertex2fv) (const GLfloat* v); +void (WINE_GLAPI *glVertex2i) (GLint x, GLint y); +void (WINE_GLAPI *glVertex2iv) (const GLint* v); +void (WINE_GLAPI *glVertex2s) (GLshort x, GLshort y); +void (WINE_GLAPI *glVertex2sv) (const GLshort* v); +void (WINE_GLAPI *glVertex3d) (GLdouble x, GLdouble y, GLdouble z); +void (WINE_GLAPI *glVertex3dv) (const GLdouble* v); +void (WINE_GLAPI *glVertex3f) (GLfloat x, GLfloat y, GLfloat z); +void (WINE_GLAPI *glVertex3fv) (const GLfloat* v); +void (WINE_GLAPI *glVertex3i) (GLint x, GLint y, GLint z); +void (WINE_GLAPI *glVertex3iv) (const GLint* v); +void (WINE_GLAPI *glVertex3s) (GLshort x, GLshort y, GLshort z); +void (WINE_GLAPI *glVertex3sv) (const GLshort* v); +void (WINE_GLAPI *glVertex4d) (GLdouble x, GLdouble y, GLdouble z, GLdouble w); +void (WINE_GLAPI *glVertex4dv) (const GLdouble* v); +void (WINE_GLAPI *glVertex4f) (GLfloat x, GLfloat y, GLfloat z, GLfloat w); +void (WINE_GLAPI *glVertex4fv) (const GLfloat* v); +void (WINE_GLAPI *glVertex4i) (GLint x, GLint y, GLint z, GLint w); +void (WINE_GLAPI *glVertex4iv) (const GLint* v); +void (WINE_GLAPI *glVertex4s) (GLshort x, GLshort y, GLshort z, GLshort w); +void (WINE_GLAPI *glVertex4sv) (const GLshort* v); +void (WINE_GLAPI *glVertexPointer) (GLint size, GLenum type, GLsizei stride, const GLvoid* pointer); +void (WINE_GLAPI *glViewport) (GLint x, GLint y, GLsizei width, GLsizei height); + +#define GL_FUNCS_GEN \ + USE_GL_FUNC(glAccum) \ + USE_GL_FUNC(glAlphaFunc) \ + USE_GL_FUNC(glAreTexturesResident) \ + USE_GL_FUNC(glArrayElement) \ + USE_GL_FUNC(glBegin) \ + USE_GL_FUNC(glBindTexture) \ + USE_GL_FUNC(glBitmap) \ + USE_GL_FUNC(glBlendFunc) \ + USE_GL_FUNC(glCallList) \ + USE_GL_FUNC(glCallLists) \ + USE_GL_FUNC(glClear) \ + USE_GL_FUNC(glClearAccum) \ + USE_GL_FUNC(glClearColor) \ + USE_GL_FUNC(glClearDepth) \ + USE_GL_FUNC(glClearIndex) \ + USE_GL_FUNC(glClearStencil) \ + USE_GL_FUNC(glClipPlane) \ + USE_GL_FUNC(glColor3b) \ + USE_GL_FUNC(glColor3bv) \ + USE_GL_FUNC(glColor3d) \ + USE_GL_FUNC(glColor3dv) \ + USE_GL_FUNC(glColor3f) \ + USE_GL_FUNC(glColor3fv) \ + USE_GL_FUNC(glColor3i) \ + USE_GL_FUNC(glColor3iv) \ + USE_GL_FUNC(glColor3s) \ + USE_GL_FUNC(glColor3sv) \ + USE_GL_FUNC(glColor3ub) \ + USE_GL_FUNC(glColor3ubv) \ + USE_GL_FUNC(glColor3ui) \ + USE_GL_FUNC(glColor3uiv) \ + USE_GL_FUNC(glColor3us) \ + USE_GL_FUNC(glColor3usv) \ + USE_GL_FUNC(glColor4b) \ + USE_GL_FUNC(glColor4bv) \ + USE_GL_FUNC(glColor4d) \ + USE_GL_FUNC(glColor4dv) \ + USE_GL_FUNC(glColor4f) \ + USE_GL_FUNC(glColor4fv) \ + USE_GL_FUNC(glColor4i) \ + USE_GL_FUNC(glColor4iv) \ + USE_GL_FUNC(glColor4s) \ + USE_GL_FUNC(glColor4sv) \ + USE_GL_FUNC(glColor4ub) \ + USE_GL_FUNC(glColor4ubv) \ + USE_GL_FUNC(glColor4ui) \ + USE_GL_FUNC(glColor4uiv) \ + USE_GL_FUNC(glColor4us) \ + USE_GL_FUNC(glColor4usv) \ + USE_GL_FUNC(glColorMask) \ + USE_GL_FUNC(glColorMaterial) \ + USE_GL_FUNC(glColorPointer) \ + USE_GL_FUNC(glCopyPixels) \ + USE_GL_FUNC(glCopyTexImage1D) \ + USE_GL_FUNC(glCopyTexImage2D) \ + USE_GL_FUNC(glCopyTexSubImage1D) \ + USE_GL_FUNC(glCopyTexSubImage2D) \ + USE_GL_FUNC(glCullFace) \ + USE_GL_FUNC(glDeleteLists) \ + USE_GL_FUNC(glDeleteTextures) \ + USE_GL_FUNC(glDepthFunc) \ + USE_GL_FUNC(glDepthMask) \ + USE_GL_FUNC(glDepthRange) \ + USE_GL_FUNC(glDisable) \ + USE_GL_FUNC(glDisableClientState) \ + USE_GL_FUNC(glDrawArrays) \ + USE_GL_FUNC(glDrawBuffer) \ + USE_GL_FUNC(glDrawElements) \ + USE_GL_FUNC(glDrawPixels) \ + USE_GL_FUNC(glEdgeFlag) \ + USE_GL_FUNC(glEdgeFlagPointer) \ + USE_GL_FUNC(glEdgeFlagv) \ + USE_GL_FUNC(glEnable) \ + USE_GL_FUNC(glEnableClientState) \ + USE_GL_FUNC(glEnd) \ + USE_GL_FUNC(glEndList) \ + USE_GL_FUNC(glEvalCoord1d) \ + USE_GL_FUNC(glEvalCoord1dv) \ + USE_GL_FUNC(glEvalCoord1f) \ + USE_GL_FUNC(glEvalCoord1fv) \ + USE_GL_FUNC(glEvalCoord2d) \ + USE_GL_FUNC(glEvalCoord2dv) \ + USE_GL_FUNC(glEvalCoord2f) \ + USE_GL_FUNC(glEvalCoord2fv) \ + USE_GL_FUNC(glEvalMesh1) \ + USE_GL_FUNC(glEvalMesh2) \ + USE_GL_FUNC(glEvalPoint1) \ + USE_GL_FUNC(glEvalPoint2) \ + USE_GL_FUNC(glFeedbackBuffer) \ + USE_GL_FUNC(glFinish) \ + USE_GL_FUNC(glFlush) \ + USE_GL_FUNC(glFogf) \ + USE_GL_FUNC(glFogfv) \ + USE_GL_FUNC(glFogi) \ + USE_GL_FUNC(glFogiv) \ + USE_GL_FUNC(glFrontFace) \ + USE_GL_FUNC(glFrustum) \ + USE_GL_FUNC(glGenLists) \ + USE_GL_FUNC(glGenTextures) \ + USE_GL_FUNC(glGetBooleanv) \ + USE_GL_FUNC(glGetClipPlane) \ + USE_GL_FUNC(glGetDoublev) \ + USE_GL_FUNC(glGetError) \ + USE_GL_FUNC(glGetFloatv) \ + USE_GL_FUNC(glGetIntegerv) \ + USE_GL_FUNC(glGetLightfv) \ + USE_GL_FUNC(glGetLightiv) \ + USE_GL_FUNC(glGetMapdv) \ + USE_GL_FUNC(glGetMapfv) \ + USE_GL_FUNC(glGetMapiv) \ + USE_GL_FUNC(glGetMaterialfv) \ + USE_GL_FUNC(glGetMaterialiv) \ + USE_GL_FUNC(glGetPixelMapfv) \ + USE_GL_FUNC(glGetPixelMapuiv) \ + USE_GL_FUNC(glGetPixelMapusv) \ + USE_GL_FUNC(glGetPointerv) \ + USE_GL_FUNC(glGetPolygonStipple) \ + USE_GL_FUNC(glGetString) \ + USE_GL_FUNC(glGetTexEnvfv) \ + USE_GL_FUNC(glGetTexEnviv) \ + USE_GL_FUNC(glGetTexGendv) \ + USE_GL_FUNC(glGetTexGenfv) \ + USE_GL_FUNC(glGetTexGeniv) \ + USE_GL_FUNC(glGetTexImage) \ + USE_GL_FUNC(glGetTexLevelParameterfv) \ + USE_GL_FUNC(glGetTexLevelParameteriv) \ + USE_GL_FUNC(glGetTexParameterfv) \ + USE_GL_FUNC(glGetTexParameteriv) \ + USE_GL_FUNC(glHint) \ + USE_GL_FUNC(glIndexMask) \ + USE_GL_FUNC(glIndexPointer) \ + USE_GL_FUNC(glIndexd) \ + USE_GL_FUNC(glIndexdv) \ + USE_GL_FUNC(glIndexf) \ + USE_GL_FUNC(glIndexfv) \ + USE_GL_FUNC(glIndexi) \ + USE_GL_FUNC(glIndexiv) \ + USE_GL_FUNC(glIndexs) \ + USE_GL_FUNC(glIndexsv) \ + USE_GL_FUNC(glIndexub) \ + USE_GL_FUNC(glIndexubv) \ + USE_GL_FUNC(glInitNames) \ + USE_GL_FUNC(glInterleavedArrays) \ + USE_GL_FUNC(glIsEnabled) \ + USE_GL_FUNC(glIsList) \ + USE_GL_FUNC(glIsTexture) \ + USE_GL_FUNC(glLightModelf) \ + USE_GL_FUNC(glLightModelfv) \ + USE_GL_FUNC(glLightModeli) \ + USE_GL_FUNC(glLightModeliv) \ + USE_GL_FUNC(glLightf) \ + USE_GL_FUNC(glLightfv) \ + USE_GL_FUNC(glLighti) \ + USE_GL_FUNC(glLightiv) \ + USE_GL_FUNC(glLineStipple) \ + USE_GL_FUNC(glLineWidth) \ + USE_GL_FUNC(glListBase) \ + USE_GL_FUNC(glLoadIdentity) \ + USE_GL_FUNC(glLoadMatrixd) \ + USE_GL_FUNC(glLoadMatrixf) \ + USE_GL_FUNC(glLoadName) \ + USE_GL_FUNC(glLogicOp) \ + USE_GL_FUNC(glMap1d) \ + USE_GL_FUNC(glMap1f) \ + USE_GL_FUNC(glMap2d) \ + USE_GL_FUNC(glMap2f) \ + USE_GL_FUNC(glMapGrid1d) \ + USE_GL_FUNC(glMapGrid1f) \ + USE_GL_FUNC(glMapGrid2d) \ + USE_GL_FUNC(glMapGrid2f) \ + USE_GL_FUNC(glMaterialf) \ + USE_GL_FUNC(glMaterialfv) \ + USE_GL_FUNC(glMateriali) \ + USE_GL_FUNC(glMaterialiv) \ + USE_GL_FUNC(glMatrixMode) \ + USE_GL_FUNC(glMultMatrixd) \ + USE_GL_FUNC(glMultMatrixf) \ + USE_GL_FUNC(glNewList) \ + USE_GL_FUNC(glNormal3b) \ + USE_GL_FUNC(glNormal3bv) \ + USE_GL_FUNC(glNormal3d) \ + USE_GL_FUNC(glNormal3dv) \ + USE_GL_FUNC(glNormal3f) \ + USE_GL_FUNC(glNormal3fv) \ + USE_GL_FUNC(glNormal3i) \ + USE_GL_FUNC(glNormal3iv) \ + USE_GL_FUNC(glNormal3s) \ + USE_GL_FUNC(glNormal3sv) \ + USE_GL_FUNC(glNormalPointer) \ + USE_GL_FUNC(glOrtho) \ + USE_GL_FUNC(glPassThrough) \ + USE_GL_FUNC(glPixelMapfv) \ + USE_GL_FUNC(glPixelMapuiv) \ + USE_GL_FUNC(glPixelMapusv) \ + USE_GL_FUNC(glPixelStoref) \ + USE_GL_FUNC(glPixelStorei) \ + USE_GL_FUNC(glPixelTransferf) \ + USE_GL_FUNC(glPixelTransferi) \ + USE_GL_FUNC(glPixelZoom) \ + USE_GL_FUNC(glPointSize) \ + USE_GL_FUNC(glPolygonMode) \ + USE_GL_FUNC(glPolygonOffset) \ + USE_GL_FUNC(glPolygonStipple) \ + USE_GL_FUNC(glPopAttrib) \ + USE_GL_FUNC(glPopClientAttrib) \ + USE_GL_FUNC(glPopMatrix) \ + USE_GL_FUNC(glPopName) \ + USE_GL_FUNC(glPrioritizeTextures) \ + USE_GL_FUNC(glPushAttrib) \ + USE_GL_FUNC(glPushClientAttrib) \ + USE_GL_FUNC(glPushMatrix) \ + USE_GL_FUNC(glPushName) \ + USE_GL_FUNC(glRasterPos2d) \ + USE_GL_FUNC(glRasterPos2dv) \ + USE_GL_FUNC(glRasterPos2f) \ + USE_GL_FUNC(glRasterPos2fv) \ + USE_GL_FUNC(glRasterPos2i) \ + USE_GL_FUNC(glRasterPos2iv) \ + USE_GL_FUNC(glRasterPos2s) \ + USE_GL_FUNC(glRasterPos2sv) \ + USE_GL_FUNC(glRasterPos3d) \ + USE_GL_FUNC(glRasterPos3dv) \ + USE_GL_FUNC(glRasterPos3f) \ + USE_GL_FUNC(glRasterPos3fv) \ + USE_GL_FUNC(glRasterPos3i) \ + USE_GL_FUNC(glRasterPos3iv) \ + USE_GL_FUNC(glRasterPos3s) \ + USE_GL_FUNC(glRasterPos3sv) \ + USE_GL_FUNC(glRasterPos4d) \ + USE_GL_FUNC(glRasterPos4dv) \ + USE_GL_FUNC(glRasterPos4f) \ + USE_GL_FUNC(glRasterPos4fv) \ + USE_GL_FUNC(glRasterPos4i) \ + USE_GL_FUNC(glRasterPos4iv) \ + USE_GL_FUNC(glRasterPos4s) \ + USE_GL_FUNC(glRasterPos4sv) \ + USE_GL_FUNC(glReadBuffer) \ + USE_GL_FUNC(glReadPixels) \ + USE_GL_FUNC(glRectd) \ + USE_GL_FUNC(glRectdv) \ + USE_GL_FUNC(glRectf) \ + USE_GL_FUNC(glRectfv) \ + USE_GL_FUNC(glRecti) \ + USE_GL_FUNC(glRectiv) \ + USE_GL_FUNC(glRects) \ + USE_GL_FUNC(glRectsv) \ + USE_GL_FUNC(glRenderMode) \ + USE_GL_FUNC(glRotated) \ + USE_GL_FUNC(glRotatef) \ + USE_GL_FUNC(glScaled) \ + USE_GL_FUNC(glScalef) \ + USE_GL_FUNC(glScissor) \ + USE_GL_FUNC(glSelectBuffer) \ + USE_GL_FUNC(glShadeModel) \ + USE_GL_FUNC(glStencilFunc) \ + USE_GL_FUNC(glStencilMask) \ + USE_GL_FUNC(glStencilOp) \ + USE_GL_FUNC(glTexCoord1d) \ + USE_GL_FUNC(glTexCoord1dv) \ + USE_GL_FUNC(glTexCoord1f) \ + USE_GL_FUNC(glTexCoord1fv) \ + USE_GL_FUNC(glTexCoord1i) \ + USE_GL_FUNC(glTexCoord1iv) \ + USE_GL_FUNC(glTexCoord1s) \ + USE_GL_FUNC(glTexCoord1sv) \ + USE_GL_FUNC(glTexCoord2d) \ + USE_GL_FUNC(glTexCoord2dv) \ + USE_GL_FUNC(glTexCoord2f) \ + USE_GL_FUNC(glTexCoord2fv) \ + USE_GL_FUNC(glTexCoord2i) \ + USE_GL_FUNC(glTexCoord2iv) \ + USE_GL_FUNC(glTexCoord2s) \ + USE_GL_FUNC(glTexCoord2sv) \ + USE_GL_FUNC(glTexCoord3d) \ + USE_GL_FUNC(glTexCoord3dv) \ + USE_GL_FUNC(glTexCoord3f) \ + USE_GL_FUNC(glTexCoord3fv) \ + USE_GL_FUNC(glTexCoord3i) \ + USE_GL_FUNC(glTexCoord3iv) \ + USE_GL_FUNC(glTexCoord3s) \ + USE_GL_FUNC(glTexCoord3sv) \ + USE_GL_FUNC(glTexCoord4d) \ + USE_GL_FUNC(glTexCoord4dv) \ + USE_GL_FUNC(glTexCoord4f) \ + USE_GL_FUNC(glTexCoord4fv) \ + USE_GL_FUNC(glTexCoord4i) \ + USE_GL_FUNC(glTexCoord4iv) \ + USE_GL_FUNC(glTexCoord4s) \ + USE_GL_FUNC(glTexCoord4sv) \ + USE_GL_FUNC(glTexCoordPointer) \ + USE_GL_FUNC(glTexEnvf) \ + USE_GL_FUNC(glTexEnvfv) \ + USE_GL_FUNC(glTexEnvi) \ + USE_GL_FUNC(glTexEnviv) \ + USE_GL_FUNC(glTexGend) \ + USE_GL_FUNC(glTexGendv) \ + USE_GL_FUNC(glTexGenf) \ + USE_GL_FUNC(glTexGenfv) \ + USE_GL_FUNC(glTexGeni) \ + USE_GL_FUNC(glTexGeniv) \ + USE_GL_FUNC(glTexImage1D) \ + USE_GL_FUNC(glTexImage2D) \ + USE_GL_FUNC(glTexParameterf) \ + USE_GL_FUNC(glTexParameterfv) \ + USE_GL_FUNC(glTexParameteri) \ + USE_GL_FUNC(glTexParameteriv) \ + USE_GL_FUNC(glTexSubImage1D) \ + USE_GL_FUNC(glTexSubImage2D) \ + USE_GL_FUNC(glTranslated) \ + USE_GL_FUNC(glTranslatef) \ + USE_GL_FUNC(glVertex2d) \ + USE_GL_FUNC(glVertex2dv) \ + USE_GL_FUNC(glVertex2f) \ + USE_GL_FUNC(glVertex2fv) \ + USE_GL_FUNC(glVertex2i) \ + USE_GL_FUNC(glVertex2iv) \ + USE_GL_FUNC(glVertex2s) \ + USE_GL_FUNC(glVertex2sv) \ + USE_GL_FUNC(glVertex3d) \ + USE_GL_FUNC(glVertex3dv) \ + USE_GL_FUNC(glVertex3f) \ + USE_GL_FUNC(glVertex3fv) \ + USE_GL_FUNC(glVertex3i) \ + USE_GL_FUNC(glVertex3iv) \ + USE_GL_FUNC(glVertex3s) \ + USE_GL_FUNC(glVertex3sv) \ + USE_GL_FUNC(glVertex4d) \ + USE_GL_FUNC(glVertex4dv) \ + USE_GL_FUNC(glVertex4f) \ + USE_GL_FUNC(glVertex4fv) \ + USE_GL_FUNC(glVertex4i) \ + USE_GL_FUNC(glVertex4iv) \ + USE_GL_FUNC(glVertex4s) \ + USE_GL_FUNC(glVertex4sv) \ + USE_GL_FUNC(glVertexPointer) \ + USE_GL_FUNC(glViewport) + + /**************************************************** * OpenGL Extensions (EXT and ARB) * #defines and functions pointer @@ -2280,6 +3721,4 @@ typedef struct _WineD3D_GL_Info { } WineD3D_GL_Info; #undef USE_GL_FUNC -#endif /* HAVE_OPENGL */ - #endif /* __WINE_WINED3D_GL */