opengl_wrap.h

这是一款2d游戏引擎

	// multitexture:

	CL_TEXTURE0                 = 0x84C0,
	CL_TEXTURE1                 = 0x84C1,
	CL_TEXTURE2                 = 0x84C2,
	CL_TEXTURE3                 = 0x84C3,
	CL_TEXTURE4                 = 0x84C4,
	CL_TEXTURE5                 = 0x84C5,
	CL_TEXTURE6                 = 0x84C6,
	CL_TEXTURE7                 = 0x84C7,
	CL_TEXTURE8                 = 0x84C8,
	CL_TEXTURE9                 = 0x84C9,
	CL_TEXTURE10                = 0x84CA,
	CL_TEXTURE11                = 0x84CB,
	CL_TEXTURE12                = 0x84CC,
	CL_TEXTURE13                = 0x84CD,
	CL_TEXTURE14                = 0x84CE,
	CL_TEXTURE15                = 0x84CF,
	CL_TEXTURE16                = 0x84D0,
	CL_TEXTURE17                = 0x84D1,
	CL_TEXTURE18                = 0x84D2,
	CL_TEXTURE19                = 0x84D3,
	CL_TEXTURE20                = 0x84D4,
	CL_TEXTURE21                = 0x84D5,
	CL_TEXTURE22                = 0x84D6,
	CL_TEXTURE23                = 0x84D7,
	CL_TEXTURE24                = 0x84D8,
	CL_TEXTURE25                = 0x84D9,
	CL_TEXTURE26                = 0x84DA,
	CL_TEXTURE27                = 0x84DB,
	CL_TEXTURE28                = 0x84DC,
	CL_TEXTURE29                = 0x84DD,
	CL_TEXTURE30                = 0x84DE,
	CL_TEXTURE31                = 0x84DF,
	CL_ACTIVE_TEXTURE           = 0x84E0,
	CL_CLIENT_ACTIVE_TEXTURE    = 0x84E1,
	CL_MAX_TEXTURE_UNITS        = 0x84E2,

	// EXT_abgr:

	CL_ABGR                     = 0x8000,

	// EXT_blend_color:

	// CL_CONSTANT_COLOR           = 0x8001,
	// CL_ONE_MINUS_CONSTANT_COLOR = 0x8002,
	// CL_CONSTANT_ALPHA           = 0x8003,
	// CL_ONE_MINUS_CONSTANT_ALPHA = 0x8004,
	// CL_BLEND_COLOR              = 0x8005,

	// EXT_blend_minmax:

	// CL_FUNC_ADD                 = 0x8006,
	// CL_MIN                      = 0x8007,
	// CL_MAX                      = 0x8008,
	// CL_BLEND_EQUATION           = 0x8009,

	// EXT_blend_subtract:

	// CL_FUNC_SUBTRACT            = 0x800A,
	// CL_FUNC_REVERSE_SUBTRACT    = 0x800B,

	// EXT_texture_env_combine:

	CL_COMBINE                  = 0x8570,
	CL_COMBINE_RGB              = 0x8571,
	CL_COMBINE_ALPHA            = 0x8572,
	CL_RGB_SCALE                = 0x8573,
	CL_ADD_SIGNED               = 0x8574,
	CL_INTERPOLATE              = 0x8575,
	CL_CONSTANT                 = 0x8576,
	CL_PRIMARY_COLOR            = 0x8577,
	CL_PREVIOUS                 = 0x8578,
	CL_SOURCE0_RGB              = 0x8580,
	CL_SOURCE1_RGB              = 0x8581,
	CL_SOURCE2_RGB              = 0x8582,
	CL_SOURCE0_ALPHA            = 0x8588,
	CL_SOURCE1_ALPHA            = 0x8589,
	CL_SOURCE2_ALPHA            = 0x858A,
	CL_OPERAND0_RGB             = 0x8590,
	CL_OPERAND1_RGB             = 0x8591,
	CL_OPERAND2_RGB             = 0x8592,
	CL_OPERAND0_ALPHA           = 0x8598,
	CL_OPERAND1_ALPHA           = 0x8599,
	CL_OPERAND2_ALPHA           = 0x859A,

	// ARB_texture_compression:

	CL_COMPRESSED_ALPHA           = 0x84e9,
	CL_COMPRESSED_LUMINANCE       = 0x84ea,
	CL_COMPRESSED_LUMINANCE_ALPHA = 0x84eb,
	CL_COMPRESSED_INTENSITY       = 0x84ec,
	CL_COMPRESSED_RGB             = 0x84ed,
	CL_COMPRESSED_RGBA            = 0x84ee,
	CL_TEXTURE_COMPRESSION_HINT   = 0x84ef,
	CL_TEXTURE_COMPRESSED_IMAGE_SIZE = 0x86a0,
	CL_TEXTURE_COMPRESSED         = 0x86a1,
	CL_NUM_COMPRESSED_TEXTURE_FORMATS = 0x86a2,
	CL_COMPRESSED_TEXTURE_FORMATS = 0x86a3,

	// ARB_texture_cube_map:

	CL_NORMAL_MAP                 = 0x8511,
	CL_REFLECTION_MAP             = 0x8512,
	CL_TEXTURE_CUBE_MAP           = 0x8513,
	CL_TEXTURE_BINDING_CUBE_MAP   = 0x8514,
	CL_TEXTURE_CUBE_MAP_POSITIVE_X = 0x8515,
	CL_TEXTURE_CUBE_MAP_NEGATIVE_X = 0x8516,
	CL_TEXTURE_CUBE_MAP_POSITIVE_Y = 0x8517,
	CL_TEXTURE_CUBE_MAP_NEGATIVE_Y = 0x8518,
	CL_TEXTURE_CUBE_MAP_POSITIVE_Z = 0x8519,
	CL_TEXTURE_CUBE_MAP_NEGATIVE_Z = 0x851a,
	CL_PROXY_TEXTURE_CUBE_MAP     = 0x851b,
	CL_MAX_CUBE_MAP_TEXTURE_SIZE  = 0x851c,

	// ARB_multisample:

	CL_MULTISAMPLE                = 0x809d,
	CL_SAMPLE_ALPHA_TO_COVERAGE   = 0x809e,
	CL_SAMPLE_ALPHA_TO_ONE        = 0x809f,
	CL_SAMPLE_COVERAGE            = 0x80a0,
	CL_SAMPLE_BUFFERS             = 0x80a8,
	CL_SAMPLES                    = 0x80a9,
	CL_SAMPLE_COVERAGE_VALUE      = 0x80aa,
	CL_SAMPLE_COVERAGE_INVERT     = 0x80ab,
	CL_MULTISAMPLE_BIT            = 0x20000000,

	// ARB_texture_env_combine:

	CL_SUBTRACT                   = 0x84e7,
	// CL_COMBINE                    = 0x8570,
	// CL_COMBINE_RGB                = 0x8571,
	// CL_COMBINE_ALPHA              = 0x8572,
	// CL_RGB_SCALE                  = 0x8573,
	// CL_ADD_SIGNED                 = 0x8574,
	// CL_INTERPOLATE                = 0x8575,
	// CL_CONSTANT                   = 0x8576,
	// CL_PRIMARY_COLOR              = 0x8577,
	// CL_PREVIOUS                   = 0x8578,
	// CL_SOURCE0_RGB                = 0x8580,
	// CL_SOURCE1_RGB                = 0x8581,
	// CL_SOURCE2_RGB                = 0x8582,
	// CL_SOURCE0_ALPHA              = 0x8588,
	// CL_SOURCE1_ALPHA              = 0x8589,
	// CL_SOURCE2_ALPHA              = 0x858a,
	// CL_OPERAND0_RGB               = 0x8590,
	// CL_OPERAND1_RGB               = 0x8591,
	// CL_OPERAND2_RGB               = 0x8592,
	// CL_OPERAND0_ALPHA             = 0x8598,
	// CL_OPERAND1_ALPHA             = 0x8599,
	// CL_OPERAND2_ALPHA             = 0x859a,

	// ARB_texture_env_dot3:

	CL_DOT3_RGB                   = 0x86ae,
	CL_DOT3_RGBA                  = 0x86af,

	// ARB_transpose_matrix:

	CL_TRANSPOSE_MODELVIEW_MATRIX  = 0x84e3,
	CL_TRANSPOSE_PROJECTION_MATRIX = 0x84e4,
	CL_TRANSPOSE_TEXTURE_MATRIX    = 0x84e5,
	CL_TRANSPOSE_COLOR_MATRIX      = 0x84e6,

	// SGIS_generate_mipmap:

	CL_GENERATE_MIPMAP             = 0x8191,
	CL_GENERATE_MIPMAP_HINT        = 0x8192,

	// ARB_depth_texture:

	CL_DEPTH_COMPONENT16           = 0x81a5,
	CL_DEPTH_COMPONENT24           = 0x81a6,
	CL_DEPTH_COMPONENT32           = 0x81a7,
	CL_TEXTURE_DEPTH_SIZE          = 0x884a,
	CL_DEPTH_TEXTURE_MODE          = 0x884b,

	// ARB_shadow:

	CL_TEXTURE_COMPARE_MODE        = 0x884c,
	CL_TEXTURE_COMPARE_FUNC        = 0x884d,
	CL_COMPARE_R_TO_TEXTURE        = 0x884e,

	// EXT_fog_coord:

	CL_FOG_COORDINATE_SOURCE       = 0x8450,
	CL_FOG_COORDINATE              = 0x8451,
	CL_FRAGMENT_DEPTH              = 0x8452,
	CL_CURRENT_FOG_COORDINATE      = 0x8453,
	CL_FOG_COORDINATE_ARRAY_TYPE   = 0x8454,
	CL_FOG_COORDINATE_ARRAY_STRIDE = 0x8455,
	CL_FOG_COORDINATE_ARRAY_POINTER = 0x8456,
	CL_FOG_COORDINATE_ARRAY        = 0x8457,

	// ARB_point_parameters:

	CL_POINT_SIZE_MIN              = 0x8126,
	CL_POINT_SIZE_MAX_ARB          = 0x8127,
	CL_POINT_FADE_THRESHOLD_SIZE   = 0x8128,
	CL_POINT_DISTANCE_ATTENUATION  = 0x8129,

	// EXT_secondary_color:

	CL_COLOR_SUM                   = 0x8458,
	CL_CURRENT_SECONDARY_COLOR     = 0x8459,
	CL_SECONDARY_COLOR_ARRAY_SIZE  = 0x845a,
	CL_SECONDARY_COLOR_ARRAY_TYPE  = 0x845b,
	CL_SECONDARY_COLOR_ARRAY_STRIDE = 0x845c,
	CL_SECONDARY_COLOR_ARRAY_POINTER = 0x845d,
	CL_SECONDARY_COLOR_ARRAY       = 0x845e,

	// EXT_blend_func_separate:

	CL_BLEND_DST_RGB               = 0x80c8,
	CL_BLEND_SRC_RGB               = 0x80c9,
	CL_BLEND_DST_ALPHA             = 0x80ca,
	CL_BLEND_SRC_ALPHA             = 0x80cb,

	// EXT_stencil_wrap:

	CL_INCR_WRAP                   = 0x8507,
	CL_DECR_WRAP                   = 0x8508,

	// EXT_texture_lod_bias:

	CL_MAX_TEXTURE_LOD_BIAS        = 0x84fd,
	CL_TEXTURE_FILTER_CONTROL      = 0x8500,
	CL_TEXTURE_LOD_BIAS            = 0x8501
};

//! OpenGL 1.5 binds:
//- !group=GL/System!
//- !header=gl.h!
class CL_GLFunctions
{
//! Typedefs:
public:
	typedef void (CL_GLFUNC *ptr_glAccum)(CLenum op, CLfloat value);
	typedef void (CL_GLFUNC *ptr_glAlphaFunc)(CLenum func, CLclampf ref);
	typedef CLboolean (CL_GLFUNC *ptr_glAreTexturesResident)(CLsizei n, const CLuint *textures, CLboolean *residences);
	typedef void (CL_GLFUNC *ptr_glArrayElement)(CLint i);
	typedef void (CL_GLFUNC *ptr_glBegin)(CLenum mode);
	typedef void (CL_GLFUNC *ptr_glBindTexture)(CLenum target, CLuint texture);
	typedef void (CL_GLFUNC *ptr_glBitmap)(CLsizei width, CLsizei height, CLfloat xorig, CLfloat yorig, CLfloat xmove, CLfloat ymove, const CLubyte *bitmap);
	typedef void (CL_GLFUNC *ptr_glBlendFunc)(CLenum sfactor, CLenum dfactor);
	typedef void (CL_GLFUNC *ptr_glCallList)(CLuint list);
	typedef void (CL_GLFUNC *ptr_glCallLists)(CLsizei n, CLenum type, const CLvoid *lists);
	typedef void (CL_GLFUNC *ptr_glClear)(CLbitfield mask);
	typedef void (CL_GLFUNC *ptr_glClearAccum)(CLfloat red, CLfloat green, CLfloat blue, CLfloat alpha);
	typedef void (CL_GLFUNC *ptr_glClearColor)(CLclampf red, CLclampf green, CLclampf blue, CLclampf alpha);
	typedef void (CL_GLFUNC *ptr_glClearDepth)(CLclampd depth);
	typedef void (CL_GLFUNC *ptr_glClearIndex)(CLfloat c);
	typedef void (CL_GLFUNC *ptr_glClearStencil)(CLint s);
	typedef void (CL_GLFUNC *ptr_glClipPlane)(CLenum plane, const CLdouble *equation);
	typedef void (CL_GLFUNC *ptr_glColor3b)(CLbyte red, CLbyte green, CLbyte blue);
	typedef void (CL_GLFUNC *ptr_glColor3bv)(const CLbyte *v);
	typedef void (CL_GLFUNC *ptr_glColor3d)(CLdouble red, CLdouble green, CLdouble blue);
	typedef void (CL_GLFUNC *ptr_glColor3dv)(const CLdouble *v);
	typedef void (CL_GLFUNC *ptr_glColor3f)(CLfloat red, CLfloat green, CLfloat blue);
	typedef void (CL_GLFUNC *ptr_glColor3fv)(const CLfloat *v);
	typedef void (CL_GLFUNC *ptr_glColor3i)(CLint red, CLint green, CLint blue);
	typedef void (CL_GLFUNC *ptr_glColor3iv)(const CLint *v);
	typedef void (CL_GLFUNC *ptr_glColor3s)(CLshort red, CLshort green, CLshort blue);
	typedef void (CL_GLFUNC *ptr_glColor3sv)(const CLshort *v);
	typedef void (CL_GLFUNC *ptr_glColor3ub)(CLubyte red, CLubyte green, CLubyte blue);
	typedef void (CL_GLFUNC *ptr_glColor3ubv)(const CLubyte *v);
	typedef void (CL_GLFUNC *ptr_glColor3ui)(CLuint red, CLuint green, CLuint blue);
	typedef void (CL_GLFUNC *ptr_glColor3uiv)(const CLuint *v);
	typedef void (CL_GLFUNC *ptr_glColor3us)(CLushort red, CLushort green, CLushort blue);
	typedef void (CL_GLFUNC *ptr_glColor3usv)(const CLushort *v);
	typedef void (CL_GLFUNC *ptr_glColor4b)(CLbyte red, CLbyte green, CLbyte blue, CLbyte alpha);
	typedef void (CL_GLFUNC *ptr_glColor4bv)(const CLbyte *v);
	typedef void (CL_GLFUNC *ptr_glColor4d)(CLdouble red, CLdouble green, CLdouble blue, CLdouble alpha);
	typedef void (CL_GLFUNC *ptr_glColor4dv)(const CLdouble *v);
	typedef void (CL_GLFUNC *ptr_glColor4f)(CLfloat red, CLfloat green, CLfloat blue, CLfloat alpha);
	typedef void (CL_GLFUNC *ptr_glColor4fv)(const CLfloat *v);
	typedef void (CL_GLFUNC *ptr_glColor4i)(CLint red, CLint green, CLint blue, CLint alpha);
	typedef void (CL_GLFUNC *ptr_glColor4iv)(const CLint *v);
	typedef void (CL_GLFUNC *ptr_glColor4s)(CLshort red, CLshort green, CLshort blue, CLshort alpha);
	typedef void (CL_GLFUNC *ptr_glColor4sv)(const CLshort *v);
	typedef void (CL_GLFUNC *ptr_glColor4ub)(CLubyte red, CLubyte green, CLubyte blue, CLubyte alpha);
	typedef void (CL_GLFUNC *ptr_glColor4ubv)(const CLubyte *v);
	typedef void (CL_GLFUNC *ptr_glColor4ui)(CLuint red, CLuint green, CLuint blue, CLuint alpha);
	typedef void (CL_GLFUNC *ptr_glColor4uiv)(const CLuint *v);
	typedef void (CL_GLFUNC *ptr_glColor4us)(CLushort red, CLushort green, CLushort blue, CLushort alpha);
	typedef void (CL_GLFUNC *ptr_glColor4usv)(const CLushort *v);
	typedef void (CL_GLFUNC *ptr_glColorMask)(CLboolean red, CLboolean green, CLboolean blue, CLboolean alpha);
	typedef void (CL_GLFUNC *ptr_glColorMaterial)(CLenum face, CLenum mode);
	typedef void (CL_GLFUNC *ptr_glColorPointer)(CLint size, CLenum type, CLsizei stride, const CLvoid *pointer);
	typedef void (CL_GLFUNC *ptr_glCopyPixels)(CLint x, CLint y, CLsizei width, CLsizei height, CLenum type);
	typedef void (CL_GLFUNC *ptr_glCopyTexImage1D)(CLenum target, CLint level, CLenum internalformat, CLint x, CLint y, CLsizei width, CLint border);
	typedef void (CL_GLFUNC *ptr_glCopyTexImage2D)(CLenum target, CLint level, CLenum internalformat, CLint x, CLint y, CLsizei width, CLsizei height, CLint border);
	typedef void (CL_GLFUNC *ptr_glCopyTexSubImage1D)(CLenum target, CLint level, CLint xoffset, CLint x, CLint y, CLsizei width);
	typedef void (CL_GLFUNC *ptr_glCopyTexSubImage2D)(CLenum target, CLint level, CLint xoffset, CLint yoffset, CLint x, CLint y, CLsizei width, CLsizei height);
	typedef void (CL_GLFUNC *ptr_glCullFace)(CLenum mode);
	typedef void (CL_GLFUNC *ptr_glDeleteLists)(CLuint list, CLsizei range);
	typedef void (CL_GLFUNC *ptr_glDeleteTextures)(CLsizei n, const CLuint *textures);
	typedef void (CL_GLFUNC *ptr_glDepthFunc)(CLenum func);
	typedef void (CL_GLFUNC *ptr_glDepthMask)(CLboolean flag);
	typedef void (CL_GLFUNC *ptr_glDepthRange)(CLclampd zNear, CLclampd zFar);
	typedef void (CL_GLFUNC *ptr_glDisable)(CLenum cap);
	typedef void (CL_GLFUNC *ptr_glDisableClientState)(CLenum array);
	typedef void (CL_GLFUNC *ptr_glDrawArrays)(CLenum mode, CLint first, CLsizei count);
	typedef void (CL_GLFUNC *ptr_glDrawBuffer)(CLenum mode);
	typedef void (CL_GLFUNC *ptr_glDrawElements)(CLenum mode, CLsizei count, CLenum type, const CLvoid *indices);
	typedef void (CL_GLFUNC *ptr_glDrawPixels)(CLsizei width, CLsizei height, CLenum format, CLenum type, const CLvoid *pixels);
	typedef void (CL_GLFUNC *ptr_glEdgeFlag)(CLboolean flag);
	typedef void (CL_GLFUNC *ptr_glEdgeFlagPointer)(CLsizei stride, const CLvoid *pointer);
	typedef void (CL_GLFUNC *ptr_glEdgeFlagv)(const CLboolean *flag);
	typedef void (CL_GLFUNC *ptr_glEnable)(CLenum cap);
	typedef void (CL_GLFUNC *ptr_glEnableClientState)(CLenum array);
	typedef void (CL_GLFUNC *ptr_glEnd)(void);
	typedef void (CL_GLFUNC *ptr_glEndList)(void);
	typedef void (CL_GLFUNC *ptr_glEvalCoord1d)(CLdouble u);
	typedef void (CL_GLFUNC *ptr_glEvalCoord1dv)(const CLdouble *u);
	typedef void (CL_GLFUNC *ptr_glEvalCoord1f)(CLfloat u);
	typedef void (CL_GLFUNC *ptr_glEvalCoord1fv)(const CLfloat *u);
	typedef void (CL_GLFUNC *ptr_glEvalCoord2d)(CLdouble u, CLdouble v);
	typedef void (CL_GLFUNC *ptr_glEvalCoord2dv)(const CLdouble *u);
	typedef void (CL_GLFUNC *ptr_glEvalCoord2f)(CLfloat u, CLfloat v);
	typedef void (CL_GLFUNC *ptr_glEvalCoord2fv)(const CLfloat *u);
	typedef void (CL_GLFUNC *ptr_glEvalMesh1)(CLenum mode, CLint i1, CLint i2);
	typedef void (CL_GLFUNC *ptr_glEvalMesh2)(CLenum mode, CLint i1, CLint i2, CLint j1, CLint j2);
	typedef void (CL_GLFUNC *ptr_glEvalPoint1)(CLint i);
	typedef void (CL_GLFUNC *ptr_glEvalPoint2)(CLint i, CLint j);
	typedef void (CL_GLFUNC *ptr_glFeedbackBuffer)(CLsizei size, CLenum type, CLfloat *buffer);
	typedef void (CL_GLFUNC *ptr_glFinish)(void);
	typedef void (CL_GLFUNC *ptr_glFlush)(void);
	typedef void (CL_GLFUNC *ptr_glFogf)(CLenum pname, CLfloat param);
	typedef void (CL_GLFUNC *ptr_glFogfv)(CLenum pname, const CLfloat *params);
	typedef void (CL_GLFUNC *ptr_glFogi)(CLenum pname, CLint param);
	typedef void (CL_GLFUNC *ptr_glFogiv)(CLenum pname, const CLint *params);
	typedef void (CL_GLFUNC *ptr_glFrontFace)(CLenum mode);
	typedef void (CL_GLFUNC *ptr_glFrustum)(CLdouble left, CLdouble right, CLdouble bottom, CLdouble top, CLdouble zNear, CLdouble zFar);
	typedef CLuint (CL_GLFUNC *ptr_glGenLists)(CLsizei range);
	typedef void (CL_GLFUNC *ptr_glGenTextures)(CLsizei n, CLuint *textures);
	typedef void (CL_GLFUNC *ptr_glGetBooleanv)(CLenum pname, CLboolean *params);
	typedef void (CL_GLFUNC *ptr_glGetClipPlane)(CLenum plane, CLdouble *equation);
	typedef void (CL_GLFUNC *ptr_glGetDoublev)(CLenum pname, CLdouble *params);
	typedef CLenum (CL_GLFUNC *ptr_glGetError)(void);
	typedef void (CL_GLFUNC *ptr_glGetFloatv)(CLenum pname, CLfloat *params);
	typedef void (CL_GLFUNC *ptr_glGetIntegerv)(CLenum pname, CLint *params);
	typedef void (CL_GLFUNC *ptr_glGetLightfv)(CLenum light, CLenum pname, CLfloat *params);
	typedef void (CL_GLFUNC *ptr_glGetLightiv)(CLenum light, CLenum pname, CLint *params);
	typedef void (CL_GLFUNC *ptr_glGetMapdv)(CLenum target, CLenum query, CLdouble *v);
	typedef void (CL_GLFUNC *ptr_glGetMapfv)(CLenum target, CLenum query, CLfloat *v);
	typedef void (CL_GLFUNC *ptr_glGetMapiv)(CLenum target, CLenum query, CLint *v);
	typedef void (CL_GLFUNC *ptr_glGetMaterialfv)(CLenum face, CLenum pname, CLfloat *params);
	typedef void (CL_GLFUNC *ptr_glGetMaterialiv)(CLenum face, CLenum pname, CLint *params);
	typedef void (CL_GLFUNC *ptr_glGetPixelMapfv)(CLenum map, CLfloat *values);
	typedef void (CL_GLFUNC *ptr_glGetPixelMapuiv)(CLenum map, CLuint *values);
	typedef void (CL_GLFUNC *ptr_glGetPixelMapusv)(CLenum map, CLushort *values);
	typedef void (CL_GLFUNC *ptr_glGetPointerv)(CLenum pname, CLvoid* *params);
	typedef void (CL_GLFUNC *ptr_glGetPolygonStipple)(CLubyte *mask);
	typedef const CLubyte *(CL_GLFUNC *ptr_glGetString)(CLenum name);
	typedef void (CL_GLFUNC *ptr_glGetTexEnvfv)(CLenum target, CLenum pname, CLfloat *params);
	typedef void (CL_GLFUNC *ptr_glGetTexEnviv)(CLenum target, CLenum pname, CLint *params);
	typedef void (CL_GLFUNC *ptr_glGetTexGendv)(CLenum coord, CLenum pname, CLdouble *params);
	typedef void (CL_GLFUNC *ptr_glGetTexGenfv)(CLenum coord, CLenum pname, CLfloat *params);
	typedef void (CL_GLFUNC *ptr_glGetTexGeniv)(CLenum coord, CLenum pname, CLint *params);
	typedef void (CL_GLFUNC *ptr_glGetTexImage)(CLenum target, CLint level, CLenum format, CLenum type, CLvoid *pixels);
	typedef void (CL_GLFUNC *ptr_glGetTexLevelParameterfv)(CLenum target, CLint level, CLenum pname, CLfloat *params);
	typedef void (CL_GLFUNC *ptr_glGetTexLevelParameteriv)(CLenum target, CLint level, CLenum pname, CLint *params);
	typedef void (CL_GLFUNC *ptr_glGetTexParameterfv)(CLenum target, CLenum pname, CLfloat *params);
	typedef void (CL_GLFUNC *ptr_glGetTexParameteriv)(CLenum target, CLenum pname, CLint *params);
	typedef void (CL_GLFUNC *ptr_glHint)(CLenum target, CLenum mode);
	typedef void (CL_GLFUNC *ptr_glIndexMask)(CLuint mask);
	typedef void (CL_GLFUNC *ptr_glIndexPointer)(CLenum type, CLsizei stride, const CLvoid *pointer);
	typedef void (CL_GLFUNC *ptr_glIndexd)(CLdouble c);
	typedef void (CL_GLFUNC *ptr_glIndexdv)(const CLdouble *c);
	typedef void (CL_GLFUNC *ptr_glIndexf)(CLfloat c);
	typedef void (CL_GLFUNC *ptr_glIndexfv)(const CLfloat *c);
	typedef void (CL_GLFUNC *ptr_glIndexi)(CLint c);
	typedef void (CL_GLFUNC *ptr_glIndexiv)(const CLint *c);
	typedef void (CL_GLFUNC *ptr_glIndexs)(CLshort c);
	typedef void (CL_GLFUNC *ptr_glIndexsv)(const CLshort *c);
	typedef void (CL_GLFUNC *ptr_glIndexub)(CLubyte c);
	typedef void (CL_GLFUNC *ptr_glIndexubv)(const CLubyte *c);
	typedef void (CL_GLFUNC *ptr_glInitNames)(void);
	typedef void (CL_GLFUNC *ptr_glInterleavedArrays)(CLenum format, CLsizei stride, const CLvoid *pointer);
	typedef CLboolean (CL_GLFUNC *ptr_glIsEnabled)(CLenum cap);
	typedef CLboolean (CL_GLFUNC *ptr_glIsList)(CLuint list);
	typedef CLboolean (CL_GLFUNC *ptr_glIsTexture)(CLuint texture);
	typedef void (CL_GLFUNC *ptr_glLightModelf)(CLenum pname, CLfloat param);
	typedef void (CL_GLFUNC *ptr_glLightModelfv)(CLenum pname, const CLfloat *params);
	typedef void (CL_GLFUNC *ptr_glLightModeli)(CLenum pname, CLint param);
	typedef void (CL_GLFUNC *ptr_glLightModeliv)(CLenum pname, const CLint *params);
	typedef void (CL_GLFUNC *ptr_glLightf)(CLenum light, CLenum pname, CLfloat param);
	typedef void (CL_GLFUNC *ptr_glLightfv)(CLenum light, CLenum pname, const CLfloat *params);
	typedef void (CL_GLFUNC *ptr_glLighti)(CLenum light, CLenum pname, CLint param);
	typedef void (CL_GLFUNC *ptr_glLightiv)(CLenum light, CLenum pname, const CLint *params);
	typedef void (CL_GLFUNC *ptr_glLineStipple)(CLint factor, CLushort pattern);
	typedef void (CL_GLFUNC *ptr_glLineWidth)(CLfloat width);
	typedef void (CL_GLFUNC *ptr_glListBase)(CLuint base