Commits

Jason McKesson committed aad33a5

New glload generation. Pretty much untested.
From glLoadGen revision 3254e6b699a0

  • Participants
  • Parent commits 96d33a2

Comments (0)

Files changed (150)

glload/Test/test.cpp

 #include <stdexcept>
 #include <stdio.h>
 #include <glload/gl_3_3.h>
-#include <glload/gll.hpp>
+#include <glload/gll.h>
 #include <GL/freeglut.h>
 
 GLuint positionBufferObject;
 
 	glutSetOption(GLUT_ACTION_ON_WINDOW_CLOSE, GLUT_ACTION_CONTINUE_EXECUTION);
 
-	glload::LoadFunctions();
+	LoadFunctions();
 
 	if(glext_ARB_debug_output)
 	{

glload/Test/testpp.cpp

 	gl::CompileShader(shader);
 
 	GLint status;
-	gl::GetShaderiv(shader, gl::GL_COMPILE_STATUS, &status);
-	if (status == gl::GL_FALSE)
+	gl::GetShaderiv(shader, gl::COMPILE_STATUS, &status);
+	if (status == gl::FALSE_)
 	{
 		//With ARB_debug_output, we already get the info log on compile failure.
-		if(!glext_ARB_debug_output)
+		if(!gl::exts::glext_ARB_debug_output)
 		{
 			GLint infoLogLength;
-			gl::GetShaderiv(shader, gl::GL_INFO_LOG_LENGTH, &infoLogLength);
+			gl::GetShaderiv(shader, gl::INFO_LOG_LENGTH, &infoLogLength);
 
 			GLchar *strInfoLog = new GLchar[infoLogLength + 1];
 			gl::GetShaderInfoLog(shader, infoLogLength, NULL, strInfoLog);
 			const char *strShaderType = NULL;
 			switch(eShaderType)
 			{
-			case gl::GL_VERTEX_SHADER: strShaderType = "vertex"; break;
-			case gl::GL_GEOMETRY_SHADER: strShaderType = "geometry"; break;
-			case gl::GL_FRAGMENT_SHADER: strShaderType = "fragment"; break;
+			case gl::VERTEX_SHADER: strShaderType = "vertex"; break;
+			case gl::GEOMETRY_SHADER: strShaderType = "geometry"; break;
+			case gl::FRAGMENT_SHADER: strShaderType = "fragment"; break;
 			}
 
 			fprintf(stderr, "Compile failure in %s shader:\n%s\n", strShaderType, strInfoLog);
 	};
 
 	gl::GenBuffers(1, &positionBufferObject);
-	gl::BindBuffer(gl::GL_ARRAY_BUFFER, positionBufferObject);
-	gl::BufferData(gl::GL_ARRAY_BUFFER, sizeof(vertexPositions), vertexPositions, gl::GL_STATIC_DRAW);
-	gl::BindBuffer(gl::GL_ARRAY_BUFFER, 0);
+	gl::BindBuffer(gl::ARRAY_BUFFER, positionBufferObject);
+	gl::BufferData(gl::ARRAY_BUFFER, sizeof(vertexPositions), vertexPositions, gl::STATIC_DRAW);
+	gl::BindBuffer(gl::ARRAY_BUFFER, 0);
 
 	const std::string vertexShader(
 		"#version 330\n"
 		"}\n"
 		);
 
-	GLuint vertShader = BuildShader(gl::GL_VERTEX_SHADER, vertexShader);
-	GLuint fragShader = BuildShader(gl::GL_FRAGMENT_SHADER, fragmentShader);
+	GLuint vertShader = BuildShader(gl::VERTEX_SHADER, vertexShader);
+	GLuint fragShader = BuildShader(gl::FRAGMENT_SHADER, fragmentShader);
 
 	program = gl::CreateProgram();
 	gl::AttachShader(program, vertShader);
 	gl::LinkProgram(program);
 
 	GLint status;
-	gl::GetProgramiv (program, gl::GL_LINK_STATUS, &status);
-	if (status == gl::GL_FALSE)
+	gl::GetProgramiv (program, gl::LINK_STATUS, &status);
+	if (status == gl::FALSE_)
 	{
-		if(!glext_ARB_debug_output)
+		if(!gl::exts::glext_ARB_debug_output)
 		{
 			GLint infoLogLength;
-			gl::GetProgramiv(program, gl::GL_INFO_LOG_LENGTH, &infoLogLength);
+			gl::GetProgramiv(program, gl::INFO_LOG_LENGTH, &infoLogLength);
 
 			GLchar *strInfoLog = new GLchar[infoLogLength + 1];
 			gl::GetProgramInfoLog(program, infoLogLength, NULL, strInfoLog);
 void display()
 {
 	gl::ClearColor(1.0f, 1.0f, 1.0f, 1.0f);
-	gl::Clear(gl::GL_COLOR_BUFFER_BIT);
+	gl::Clear(gl::COLOR_BUFFER_BIT);
 
 	gl::UseProgram(program);
 
-	gl::BindBuffer(gl::GL_ARRAY_BUFFER, positionBufferObject);
+	gl::BindBuffer(gl::ARRAY_BUFFER, positionBufferObject);
 	gl::EnableVertexAttribArray(0);
-	gl::VertexAttribPointer(0, 4, gl::GL_FLOAT, gl::GL_FALSE, 0, 0);
+	gl::VertexAttribPointer(0, 4, gl::FLOAT, gl::FALSE_, 0, 0);
 
-	gl::DrawArrays(gl::GL_TRIANGLES, 0, 3);
+	gl::DrawArrays(gl::TRIANGLES, 0, 3);
 
 	gl::DisableVertexAttribArray(0);
 	gl::UseProgram(0);
 	std::string srcName;
 	switch(source)
 	{
-	case gl::GL_DEBUG_SOURCE_API_ARB: srcName = "API"; break;
-	case gl::GL_DEBUG_SOURCE_WINDOW_SYSTEM_ARB: srcName = "Window System"; break;
-	case gl::GL_DEBUG_SOURCE_SHADER_COMPILER_ARB: srcName = "Shader Compiler"; break;
-	case gl::GL_DEBUG_SOURCE_THIRD_PARTY_ARB: srcName = "Third Party"; break;
-	case gl::GL_DEBUG_SOURCE_APPLICATION_ARB: srcName = "Application"; break;
-	case gl::GL_DEBUG_SOURCE_OTHER_ARB: srcName = "Other"; break;
+	case gl::DEBUG_SOURCE_API_ARB: srcName = "API"; break;
+	case gl::DEBUG_SOURCE_WINDOW_SYSTEM_ARB: srcName = "Window System"; break;
+	case gl::DEBUG_SOURCE_SHADER_COMPILER_ARB: srcName = "Shader Compiler"; break;
+	case gl::DEBUG_SOURCE_THIRD_PARTY_ARB: srcName = "Third Party"; break;
+	case gl::DEBUG_SOURCE_APPLICATION_ARB: srcName = "Application"; break;
+	case gl::DEBUG_SOURCE_OTHER_ARB: srcName = "Other"; break;
 	}
 
 	std::string errorType;
 	switch(type)
 	{
-	case gl::GL_DEBUG_TYPE_ERROR_ARB: errorType = "Error"; break;
-	case gl::GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB: errorType = "Deprecated Functionality"; break;
-	case gl::GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB: errorType = "Undefined Behavior"; break;
-	case gl::GL_DEBUG_TYPE_PORTABILITY_ARB: errorType = "Portability"; break;
-	case gl::GL_DEBUG_TYPE_PERFORMANCE_ARB: errorType = "Performance"; break;
-	case gl::GL_DEBUG_TYPE_OTHER_ARB: errorType = "Other"; break;
+	case gl::DEBUG_TYPE_ERROR_ARB: errorType = "Error"; break;
+	case gl::DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB: errorType = "Deprecated Functionality"; break;
+	case gl::DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB: errorType = "Undefined Behavior"; break;
+	case gl::DEBUG_TYPE_PORTABILITY_ARB: errorType = "Portability"; break;
+	case gl::DEBUG_TYPE_PERFORMANCE_ARB: errorType = "Performance"; break;
+	case gl::DEBUG_TYPE_OTHER_ARB: errorType = "Other"; break;
 	}
 
 	std::string typeSeverity;
 	switch(severity)
 	{
-	case gl::GL_DEBUG_SEVERITY_HIGH_ARB: typeSeverity = "High"; break;
-	case gl::GL_DEBUG_SEVERITY_MEDIUM_ARB: typeSeverity = "Medium"; break;
-	case gl::GL_DEBUG_SEVERITY_LOW_ARB: typeSeverity = "Low"; break;
+	case gl::DEBUG_SEVERITY_HIGH_ARB: typeSeverity = "High"; break;
+	case gl::DEBUG_SEVERITY_MEDIUM_ARB: typeSeverity = "Medium"; break;
+	case gl::DEBUG_SEVERITY_LOW_ARB: typeSeverity = "Low"; break;
 	}
 
 	printf("%s from %s,\t%s priority\nMessage: %s\n",
 
 	glutSetOption(GLUT_ACTION_ON_WINDOW_CLOSE, GLUT_ACTION_CONTINUE_EXECUTION);
 
-	glload::LoadFunctions();
+	glload::LoadTest test = glload::LoadFunctions();
 
-	if(glext_ARB_debug_output)
+	if(gl::exts::glext_ARB_debug_output)
 	{
-		gl::Enable(gl::GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB);
+		gl::Enable(gl::DEBUG_OUTPUT_SYNCHRONOUS_ARB);
 		gl::DebugMessageCallbackARB(DebugFunc, (void*)15);
 	}
 

glload/glload.lua

 		"include/glload/gl_*.hpp",
 		"include/glload/gll.h",
 		"include/glload/gll.hpp",
-		"source/gll*.c",
-		"source/gll*.cpp",
-		"source/gll*.h",
+		"source/gl_*",
+		"source/gll_c.c",
 	};
 	
 	configuration "plainc"
 		excludes {
-			"source/gll*.cpp",
-			"include/glload/gll.hpp",
-			"include/glload/gl_*.hpp"
+			"source/*.cpp",
+			"include/glload/*.hpp",
 		}
 	
 	configuration "windows"
 		defines {"WIN32"}
 		files {"include/glload/wgl_*.h",}
-		files {"source/wgll*.c",
-			"source/wgll*.cpp",
-			"source/wgll*.h",}
+		files {"source/wgl_*"}
 	
 	configuration "linux"
 	    defines {"LOAD_X11"}
 		files {"include/glload/glx_*.h"}
-		files {"source/glxl*.c",
-			"source/glxl*.cpp",
-			"source/glxl*.h",}
+		files {"source/glx_*"}
 
 	configuration "Debug"
 		flags "Unicode";

glload/include/glload/_int_gl_1_1.h

-#ifndef _INT_GL_1_1_H
-#define _INT_GL_1_1_H
-
-
+#ifndef OPENGL_GEN_CORE_1_1_H
+#define OPENGL_GEN_CORE_1_1_H
 
 #ifdef __cplusplus
 extern "C" {
-#endif //__cplusplus
-
-
+#endif /*__cplusplus*/
 #define GL_DEPTH_BUFFER_BIT 0x00000100
 #define GL_STENCIL_BUFFER_BIT 0x00000400
 #define GL_COLOR_BUFFER_BIT 0x00004000
 #define GL_LINE_WIDTH 0x0B21
 #define GL_LINE_WIDTH_RANGE 0x0B22
 #define GL_LINE_WIDTH_GRANULARITY 0x0B23
+#define GL_POLYGON_MODE 0x0B40
 #define GL_POLYGON_SMOOTH 0x0B41
 #define GL_CULL_FACE 0x0B44
 #define GL_CULL_FACE_MODE 0x0B45
 #define GL_RGB10_A2 0x8059
 #define GL_RGBA12 0x805A
 #define GL_RGBA16 0x805B
-typedef void (GLE_FUNCPTR * PFNGLCULLFACEPROC)(GLenum );
-typedef void (GLE_FUNCPTR * PFNGLFRONTFACEPROC)(GLenum );
-typedef void (GLE_FUNCPTR * PFNGLHINTPROC)(GLenum , GLenum );
-typedef void (GLE_FUNCPTR * PFNGLLINEWIDTHPROC)(GLfloat );
-typedef void (GLE_FUNCPTR * PFNGLPOINTSIZEPROC)(GLfloat );
-typedef void (GLE_FUNCPTR * PFNGLPOLYGONMODEPROC)(GLenum , GLenum );
-typedef void (GLE_FUNCPTR * PFNGLSCISSORPROC)(GLint , GLint , GLsizei , GLsizei );
-typedef void (GLE_FUNCPTR * PFNGLTEXPARAMETERFPROC)(GLenum , GLenum , GLfloat );
-typedef void (GLE_FUNCPTR * PFNGLTEXPARAMETERFVPROC)(GLenum , GLenum , const GLfloat *);
-typedef void (GLE_FUNCPTR * PFNGLTEXPARAMETERIPROC)(GLenum , GLenum , GLint );
-typedef void (GLE_FUNCPTR * PFNGLTEXPARAMETERIVPROC)(GLenum , GLenum , const GLint *);
-typedef void (GLE_FUNCPTR * PFNGLTEXIMAGE1DPROC)(GLenum , GLint , GLint , GLsizei , GLint , GLenum , GLenum , const GLvoid *);
-typedef void (GLE_FUNCPTR * PFNGLTEXIMAGE2DPROC)(GLenum , GLint , GLint , GLsizei , GLsizei , GLint , GLenum , GLenum , const GLvoid *);
-typedef void (GLE_FUNCPTR * PFNGLDRAWBUFFERPROC)(GLenum );
-typedef void (GLE_FUNCPTR * PFNGLCLEARPROC)(GLbitfield );
-typedef void (GLE_FUNCPTR * PFNGLCLEARCOLORPROC)(GLfloat , GLfloat , GLfloat , GLfloat );
-typedef void (GLE_FUNCPTR * PFNGLCLEARSTENCILPROC)(GLint );
-typedef void (GLE_FUNCPTR * PFNGLCLEARDEPTHPROC)(GLdouble );
-typedef void (GLE_FUNCPTR * PFNGLSTENCILMASKPROC)(GLuint );
-typedef void (GLE_FUNCPTR * PFNGLCOLORMASKPROC)(GLboolean , GLboolean , GLboolean , GLboolean );
-typedef void (GLE_FUNCPTR * PFNGLDEPTHMASKPROC)(GLboolean );
-typedef void (GLE_FUNCPTR * PFNGLDISABLEPROC)(GLenum );
-typedef void (GLE_FUNCPTR * PFNGLENABLEPROC)(GLenum );
-typedef void (GLE_FUNCPTR * PFNGLFINISHPROC)();
-typedef void (GLE_FUNCPTR * PFNGLFLUSHPROC)();
-typedef void (GLE_FUNCPTR * PFNGLBLENDFUNCPROC)(GLenum , GLenum );
-typedef void (GLE_FUNCPTR * PFNGLLOGICOPPROC)(GLenum );
-typedef void (GLE_FUNCPTR * PFNGLSTENCILFUNCPROC)(GLenum , GLint , GLuint );
-typedef void (GLE_FUNCPTR * PFNGLSTENCILOPPROC)(GLenum , GLenum , GLenum );
-typedef void (GLE_FUNCPTR * PFNGLDEPTHFUNCPROC)(GLenum );
-typedef void (GLE_FUNCPTR * PFNGLPIXELSTOREFPROC)(GLenum , GLfloat );
-typedef void (GLE_FUNCPTR * PFNGLPIXELSTOREIPROC)(GLenum , GLint );
-typedef void (GLE_FUNCPTR * PFNGLREADBUFFERPROC)(GLenum );
-typedef void (GLE_FUNCPTR * PFNGLREADPIXELSPROC)(GLint , GLint , GLsizei , GLsizei , GLenum , GLenum , GLvoid *);
-typedef void (GLE_FUNCPTR * PFNGLGETBOOLEANVPROC)(GLenum , GLboolean *);
-typedef void (GLE_FUNCPTR * PFNGLGETDOUBLEVPROC)(GLenum , GLdouble *);
-typedef GLenum (GLE_FUNCPTR * PFNGLGETERRORPROC)();
-typedef void (GLE_FUNCPTR * PFNGLGETFLOATVPROC)(GLenum , GLfloat *);
-typedef void (GLE_FUNCPTR * PFNGLGETINTEGERVPROC)(GLenum , GLint *);
-typedef const GLubyte * (GLE_FUNCPTR * PFNGLGETSTRINGPROC)(GLenum );
-typedef void (GLE_FUNCPTR * PFNGLGETTEXIMAGEPROC)(GLenum , GLint , GLenum , GLenum , GLvoid *);
-typedef void (GLE_FUNCPTR * PFNGLGETTEXPARAMETERFVPROC)(GLenum , GLenum , GLfloat *);
-typedef void (GLE_FUNCPTR * PFNGLGETTEXPARAMETERIVPROC)(GLenum , GLenum , GLint *);
-typedef void (GLE_FUNCPTR * PFNGLGETTEXLEVELPARAMETERFVPROC)(GLenum , GLint , GLenum , GLfloat *);
-typedef void (GLE_FUNCPTR * PFNGLGETTEXLEVELPARAMETERIVPROC)(GLenum , GLint , GLenum , GLint *);
-typedef GLboolean (GLE_FUNCPTR * PFNGLISENABLEDPROC)(GLenum );
-typedef void (GLE_FUNCPTR * PFNGLDEPTHRANGEPROC)(GLdouble , GLdouble );
-typedef void (GLE_FUNCPTR * PFNGLVIEWPORTPROC)(GLint , GLint , GLsizei , GLsizei );
-typedef void (GLE_FUNCPTR * PFNGLDRAWARRAYSPROC)(GLenum , GLint , GLsizei );
-typedef void (GLE_FUNCPTR * PFNGLDRAWELEMENTSPROC)(GLenum , GLsizei , GLenum , const GLvoid *);
-typedef void (GLE_FUNCPTR * PFNGLGETPOINTERVPROC)(GLenum , GLvoid* *);
-typedef void (GLE_FUNCPTR * PFNGLPOLYGONOFFSETPROC)(GLfloat , GLfloat );
-typedef void (GLE_FUNCPTR * PFNGLCOPYTEXIMAGE1DPROC)(GLenum , GLint , GLenum , GLint , GLint , GLsizei , GLint );
-typedef void (GLE_FUNCPTR * PFNGLCOPYTEXIMAGE2DPROC)(GLenum , GLint , GLenum , GLint , GLint , GLsizei , GLsizei , GLint );
-typedef void (GLE_FUNCPTR * PFNGLCOPYTEXSUBIMAGE1DPROC)(GLenum , GLint , GLint , GLint , GLint , GLsizei );
-typedef void (GLE_FUNCPTR * PFNGLCOPYTEXSUBIMAGE2DPROC)(GLenum , GLint , GLint , GLint , GLint , GLint , GLsizei , GLsizei );
-typedef void (GLE_FUNCPTR * PFNGLTEXSUBIMAGE1DPROC)(GLenum , GLint , GLint , GLsizei , GLenum , GLenum , const GLvoid *);
-typedef void (GLE_FUNCPTR * PFNGLTEXSUBIMAGE2DPROC)(GLenum , GLint , GLint , GLint , GLsizei , GLsizei , GLenum , GLenum , const GLvoid *);
-typedef void (GLE_FUNCPTR * PFNGLBINDTEXTUREPROC)(GLenum , GLuint );
-typedef void (GLE_FUNCPTR * PFNGLDELETETEXTURESPROC)(GLsizei , const GLuint *);
-typedef void (GLE_FUNCPTR * PFNGLGENTEXTURESPROC)(GLsizei , GLuint *);
-typedef GLboolean (GLE_FUNCPTR * PFNGLISTEXTUREPROC)(GLuint );
-typedef void (GLE_FUNCPTR * PFNGLINDEXUBPROC)(GLubyte );
-typedef void (GLE_FUNCPTR * PFNGLINDEXUBVPROC)(const GLubyte *);
 
-extern PFNGLCULLFACEPROC __gleCullFace;
-#define glCullFace __gleCullFace
-extern PFNGLFRONTFACEPROC __gleFrontFace;
-#define glFrontFace __gleFrontFace
-extern PFNGLHINTPROC __gleHint;
-#define glHint __gleHint
-extern PFNGLLINEWIDTHPROC __gleLineWidth;
-#define glLineWidth __gleLineWidth
-extern PFNGLPOINTSIZEPROC __glePointSize;
-#define glPointSize __glePointSize
-extern PFNGLPOLYGONMODEPROC __glePolygonMode;
-#define glPolygonMode __glePolygonMode
-extern PFNGLSCISSORPROC __gleScissor;
-#define glScissor __gleScissor
-extern PFNGLTEXPARAMETERFPROC __gleTexParameterf;
-#define glTexParameterf __gleTexParameterf
-extern PFNGLTEXPARAMETERFVPROC __gleTexParameterfv;
-#define glTexParameterfv __gleTexParameterfv
-extern PFNGLTEXPARAMETERIPROC __gleTexParameteri;
-#define glTexParameteri __gleTexParameteri
-extern PFNGLTEXPARAMETERIVPROC __gleTexParameteriv;
-#define glTexParameteriv __gleTexParameteriv
-extern PFNGLTEXIMAGE1DPROC __gleTexImage1D;
-#define glTexImage1D __gleTexImage1D
-extern PFNGLTEXIMAGE2DPROC __gleTexImage2D;
-#define glTexImage2D __gleTexImage2D
-extern PFNGLDRAWBUFFERPROC __gleDrawBuffer;
-#define glDrawBuffer __gleDrawBuffer
-extern PFNGLCLEARPROC __gleClear;
-#define glClear __gleClear
-extern PFNGLCLEARCOLORPROC __gleClearColor;
-#define glClearColor __gleClearColor
-extern PFNGLCLEARSTENCILPROC __gleClearStencil;
-#define glClearStencil __gleClearStencil
-extern PFNGLCLEARDEPTHPROC __gleClearDepth;
-#define glClearDepth __gleClearDepth
-extern PFNGLSTENCILMASKPROC __gleStencilMask;
-#define glStencilMask __gleStencilMask
-extern PFNGLCOLORMASKPROC __gleColorMask;
-#define glColorMask __gleColorMask
-extern PFNGLDEPTHMASKPROC __gleDepthMask;
-#define glDepthMask __gleDepthMask
-extern PFNGLDISABLEPROC __gleDisable;
-#define glDisable __gleDisable
-extern PFNGLENABLEPROC __gleEnable;
-#define glEnable __gleEnable
-extern PFNGLFINISHPROC __gleFinish;
-#define glFinish __gleFinish
-extern PFNGLFLUSHPROC __gleFlush;
-#define glFlush __gleFlush
-extern PFNGLBLENDFUNCPROC __gleBlendFunc;
-#define glBlendFunc __gleBlendFunc
-extern PFNGLLOGICOPPROC __gleLogicOp;
-#define glLogicOp __gleLogicOp
-extern PFNGLSTENCILFUNCPROC __gleStencilFunc;
-#define glStencilFunc __gleStencilFunc
-extern PFNGLSTENCILOPPROC __gleStencilOp;
-#define glStencilOp __gleStencilOp
-extern PFNGLDEPTHFUNCPROC __gleDepthFunc;
-#define glDepthFunc __gleDepthFunc
-extern PFNGLPIXELSTOREFPROC __glePixelStoref;
-#define glPixelStoref __glePixelStoref
-extern PFNGLPIXELSTOREIPROC __glePixelStorei;
-#define glPixelStorei __glePixelStorei
-extern PFNGLREADBUFFERPROC __gleReadBuffer;
-#define glReadBuffer __gleReadBuffer
-extern PFNGLREADPIXELSPROC __gleReadPixels;
-#define glReadPixels __gleReadPixels
-extern PFNGLGETBOOLEANVPROC __gleGetBooleanv;
-#define glGetBooleanv __gleGetBooleanv
-extern PFNGLGETDOUBLEVPROC __gleGetDoublev;
-#define glGetDoublev __gleGetDoublev
-extern PFNGLGETERRORPROC __gleGetError;
-#define glGetError __gleGetError
-extern PFNGLGETFLOATVPROC __gleGetFloatv;
-#define glGetFloatv __gleGetFloatv
-extern PFNGLGETINTEGERVPROC __gleGetIntegerv;
-#define glGetIntegerv __gleGetIntegerv
-extern PFNGLGETSTRINGPROC __gleGetString;
-#define glGetString __gleGetString
-extern PFNGLGETTEXIMAGEPROC __gleGetTexImage;
-#define glGetTexImage __gleGetTexImage
-extern PFNGLGETTEXPARAMETERFVPROC __gleGetTexParameterfv;
-#define glGetTexParameterfv __gleGetTexParameterfv
-extern PFNGLGETTEXPARAMETERIVPROC __gleGetTexParameteriv;
-#define glGetTexParameteriv __gleGetTexParameteriv
-extern PFNGLGETTEXLEVELPARAMETERFVPROC __gleGetTexLevelParameterfv;
-#define glGetTexLevelParameterfv __gleGetTexLevelParameterfv
-extern PFNGLGETTEXLEVELPARAMETERIVPROC __gleGetTexLevelParameteriv;
-#define glGetTexLevelParameteriv __gleGetTexLevelParameteriv
-extern PFNGLISENABLEDPROC __gleIsEnabled;
-#define glIsEnabled __gleIsEnabled
-extern PFNGLDEPTHRANGEPROC __gleDepthRange;
-#define glDepthRange __gleDepthRange
-extern PFNGLVIEWPORTPROC __gleViewport;
-#define glViewport __gleViewport
-extern PFNGLDRAWARRAYSPROC __gleDrawArrays;
-#define glDrawArrays __gleDrawArrays
-extern PFNGLDRAWELEMENTSPROC __gleDrawElements;
-#define glDrawElements __gleDrawElements
-extern PFNGLGETPOINTERVPROC __gleGetPointerv;
-#define glGetPointerv __gleGetPointerv
-extern PFNGLPOLYGONOFFSETPROC __glePolygonOffset;
-#define glPolygonOffset __glePolygonOffset
-extern PFNGLCOPYTEXIMAGE1DPROC __gleCopyTexImage1D;
-#define glCopyTexImage1D __gleCopyTexImage1D
-extern PFNGLCOPYTEXIMAGE2DPROC __gleCopyTexImage2D;
-#define glCopyTexImage2D __gleCopyTexImage2D
-extern PFNGLCOPYTEXSUBIMAGE1DPROC __gleCopyTexSubImage1D;
-#define glCopyTexSubImage1D __gleCopyTexSubImage1D
-extern PFNGLCOPYTEXSUBIMAGE2DPROC __gleCopyTexSubImage2D;
-#define glCopyTexSubImage2D __gleCopyTexSubImage2D
-extern PFNGLTEXSUBIMAGE1DPROC __gleTexSubImage1D;
-#define glTexSubImage1D __gleTexSubImage1D
-extern PFNGLTEXSUBIMAGE2DPROC __gleTexSubImage2D;
-#define glTexSubImage2D __gleTexSubImage2D
-extern PFNGLBINDTEXTUREPROC __gleBindTexture;
-#define glBindTexture __gleBindTexture
-extern PFNGLDELETETEXTURESPROC __gleDeleteTextures;
-#define glDeleteTextures __gleDeleteTextures
-extern PFNGLGENTEXTURESPROC __gleGenTextures;
-#define glGenTextures __gleGenTextures
-extern PFNGLISTEXTUREPROC __gleIsTexture;
-#define glIsTexture __gleIsTexture
-extern PFNGLINDEXUBPROC __gleIndexub;
-#define glIndexub __gleIndexub
-extern PFNGLINDEXUBVPROC __gleIndexubv;
-#define glIndexubv __gleIndexubv
+typedef void (CODEGEN_FUNCPTR * PFNGLCULLFACEPROC)(GLenum );
+typedef void (CODEGEN_FUNCPTR * PFNGLFRONTFACEPROC)(GLenum );
+typedef void (CODEGEN_FUNCPTR * PFNGLHINTPROC)(GLenum , GLenum );
+typedef void (CODEGEN_FUNCPTR * PFNGLLINEWIDTHPROC)(GLfloat );
+typedef void (CODEGEN_FUNCPTR * PFNGLPOINTSIZEPROC)(GLfloat );
+typedef void (CODEGEN_FUNCPTR * PFNGLPOLYGONMODEPROC)(GLenum , GLenum );
+typedef void (CODEGEN_FUNCPTR * PFNGLSCISSORPROC)(GLint , GLint , GLsizei , GLsizei );
+typedef void (CODEGEN_FUNCPTR * PFNGLTEXPARAMETERFPROC)(GLenum , GLenum , GLfloat );
+typedef void (CODEGEN_FUNCPTR * PFNGLTEXPARAMETERFVPROC)(GLenum , GLenum , const GLfloat *);
+typedef void (CODEGEN_FUNCPTR * PFNGLTEXPARAMETERIPROC)(GLenum , GLenum , GLint );
+typedef void (CODEGEN_FUNCPTR * PFNGLTEXPARAMETERIVPROC)(GLenum , GLenum , const GLint *);
+typedef void (CODEGEN_FUNCPTR * PFNGLTEXIMAGE1DPROC)(GLenum , GLint , GLint , GLsizei , GLint , GLenum , GLenum , const GLvoid *);
+typedef void (CODEGEN_FUNCPTR * PFNGLTEXIMAGE2DPROC)(GLenum , GLint , GLint , GLsizei , GLsizei , GLint , GLenum , GLenum , const GLvoid *);
+typedef void (CODEGEN_FUNCPTR * PFNGLDRAWBUFFERPROC)(GLenum );
+typedef void (CODEGEN_FUNCPTR * PFNGLCLEARPROC)(GLbitfield );
+typedef void (CODEGEN_FUNCPTR * PFNGLCLEARCOLORPROC)(GLfloat , GLfloat , GLfloat , GLfloat );
+typedef void (CODEGEN_FUNCPTR * PFNGLCLEARSTENCILPROC)(GLint );
+typedef void (CODEGEN_FUNCPTR * PFNGLCLEARDEPTHPROC)(GLdouble );
+typedef void (CODEGEN_FUNCPTR * PFNGLSTENCILMASKPROC)(GLuint );
+typedef void (CODEGEN_FUNCPTR * PFNGLCOLORMASKPROC)(GLboolean , GLboolean , GLboolean , GLboolean );
+typedef void (CODEGEN_FUNCPTR * PFNGLDEPTHMASKPROC)(GLboolean );
+typedef void (CODEGEN_FUNCPTR * PFNGLDISABLEPROC)(GLenum );
+typedef void (CODEGEN_FUNCPTR * PFNGLENABLEPROC)(GLenum );
+typedef void (CODEGEN_FUNCPTR * PFNGLFINISHPROC)();
+typedef void (CODEGEN_FUNCPTR * PFNGLFLUSHPROC)();
+typedef void (CODEGEN_FUNCPTR * PFNGLBLENDFUNCPROC)(GLenum , GLenum );
+typedef void (CODEGEN_FUNCPTR * PFNGLLOGICOPPROC)(GLenum );
+typedef void (CODEGEN_FUNCPTR * PFNGLSTENCILFUNCPROC)(GLenum , GLint , GLuint );
+typedef void (CODEGEN_FUNCPTR * PFNGLSTENCILOPPROC)(GLenum , GLenum , GLenum );
+typedef void (CODEGEN_FUNCPTR * PFNGLDEPTHFUNCPROC)(GLenum );
+typedef void (CODEGEN_FUNCPTR * PFNGLPIXELSTOREFPROC)(GLenum , GLfloat );
+typedef void (CODEGEN_FUNCPTR * PFNGLPIXELSTOREIPROC)(GLenum , GLint );
+typedef void (CODEGEN_FUNCPTR * PFNGLREADBUFFERPROC)(GLenum );
+typedef void (CODEGEN_FUNCPTR * PFNGLREADPIXELSPROC)(GLint , GLint , GLsizei , GLsizei , GLenum , GLenum , GLvoid *);
+typedef void (CODEGEN_FUNCPTR * PFNGLGETBOOLEANVPROC)(GLenum , GLboolean *);
+typedef void (CODEGEN_FUNCPTR * PFNGLGETDOUBLEVPROC)(GLenum , GLdouble *);
+typedef GLenum (CODEGEN_FUNCPTR * PFNGLGETERRORPROC)();
+typedef void (CODEGEN_FUNCPTR * PFNGLGETFLOATVPROC)(GLenum , GLfloat *);
+typedef void (CODEGEN_FUNCPTR * PFNGLGETINTEGERVPROC)(GLenum , GLint *);
+typedef const GLubyte * (CODEGEN_FUNCPTR * PFNGLGETSTRINGPROC)(GLenum );
+typedef void (CODEGEN_FUNCPTR * PFNGLGETTEXIMAGEPROC)(GLenum , GLint , GLenum , GLenum , GLvoid *);
+typedef void (CODEGEN_FUNCPTR * PFNGLGETTEXPARAMETERFVPROC)(GLenum , GLenum , GLfloat *);
+typedef void (CODEGEN_FUNCPTR * PFNGLGETTEXPARAMETERIVPROC)(GLenum , GLenum , GLint *);
+typedef void (CODEGEN_FUNCPTR * PFNGLGETTEXLEVELPARAMETERFVPROC)(GLenum , GLint , GLenum , GLfloat *);
+typedef void (CODEGEN_FUNCPTR * PFNGLGETTEXLEVELPARAMETERIVPROC)(GLenum , GLint , GLenum , GLint *);
+typedef GLboolean (CODEGEN_FUNCPTR * PFNGLISENABLEDPROC)(GLenum );
+typedef void (CODEGEN_FUNCPTR * PFNGLDEPTHRANGEPROC)(GLdouble , GLdouble );
+typedef void (CODEGEN_FUNCPTR * PFNGLVIEWPORTPROC)(GLint , GLint , GLsizei , GLsizei );
+typedef void (CODEGEN_FUNCPTR * PFNGLDRAWARRAYSPROC)(GLenum , GLint , GLsizei );
+typedef void (CODEGEN_FUNCPTR * PFNGLDRAWELEMENTSPROC)(GLenum , GLsizei , GLenum , const GLvoid *);
+typedef void (CODEGEN_FUNCPTR * PFNGLGETPOINTERVPROC)(GLenum , GLvoid* *);
+typedef void (CODEGEN_FUNCPTR * PFNGLPOLYGONOFFSETPROC)(GLfloat , GLfloat );
+typedef void (CODEGEN_FUNCPTR * PFNGLCOPYTEXIMAGE1DPROC)(GLenum , GLint , GLenum , GLint , GLint , GLsizei , GLint );
+typedef void (CODEGEN_FUNCPTR * PFNGLCOPYTEXIMAGE2DPROC)(GLenum , GLint , GLenum , GLint , GLint , GLsizei , GLsizei , GLint );
+typedef void (CODEGEN_FUNCPTR * PFNGLCOPYTEXSUBIMAGE1DPROC)(GLenum , GLint , GLint , GLint , GLint , GLsizei );
+typedef void (CODEGEN_FUNCPTR * PFNGLCOPYTEXSUBIMAGE2DPROC)(GLenum , GLint , GLint , GLint , GLint , GLint , GLsizei , GLsizei );
+typedef void (CODEGEN_FUNCPTR * PFNGLTEXSUBIMAGE1DPROC)(GLenum , GLint , GLint , GLsizei , GLenum , GLenum , const GLvoid *);
+typedef void (CODEGEN_FUNCPTR * PFNGLTEXSUBIMAGE2DPROC)(GLenum , GLint , GLint , GLint , GLsizei , GLsizei , GLenum , GLenum , const GLvoid *);
+typedef void (CODEGEN_FUNCPTR * PFNGLBINDTEXTUREPROC)(GLenum , GLuint );
+typedef void (CODEGEN_FUNCPTR * PFNGLDELETETEXTURESPROC)(GLsizei , const GLuint *);
+typedef void (CODEGEN_FUNCPTR * PFNGLGENTEXTURESPROC)(GLsizei , GLuint *);
+typedef GLboolean (CODEGEN_FUNCPTR * PFNGLISTEXTUREPROC)(GLuint );
+typedef void (CODEGEN_FUNCPTR * PFNGLINDEXUBPROC)(GLubyte );
+typedef void (CODEGEN_FUNCPTR * PFNGLINDEXUBVPROC)(const GLubyte *);
 
+extern PFNGLCULLFACEPROC _funcptr_glCullFace;
+#define glCullFace _funcptr_glCullFace
+extern PFNGLFRONTFACEPROC _funcptr_glFrontFace;
+#define glFrontFace _funcptr_glFrontFace
+extern PFNGLHINTPROC _funcptr_glHint;
+#define glHint _funcptr_glHint
+extern PFNGLLINEWIDTHPROC _funcptr_glLineWidth;
+#define glLineWidth _funcptr_glLineWidth
+extern PFNGLPOINTSIZEPROC _funcptr_glPointSize;
+#define glPointSize _funcptr_glPointSize
+extern PFNGLPOLYGONMODEPROC _funcptr_glPolygonMode;
+#define glPolygonMode _funcptr_glPolygonMode
+extern PFNGLSCISSORPROC _funcptr_glScissor;
+#define glScissor _funcptr_glScissor
+extern PFNGLTEXPARAMETERFPROC _funcptr_glTexParameterf;
+#define glTexParameterf _funcptr_glTexParameterf
+extern PFNGLTEXPARAMETERFVPROC _funcptr_glTexParameterfv;
+#define glTexParameterfv _funcptr_glTexParameterfv
+extern PFNGLTEXPARAMETERIPROC _funcptr_glTexParameteri;
+#define glTexParameteri _funcptr_glTexParameteri
+extern PFNGLTEXPARAMETERIVPROC _funcptr_glTexParameteriv;
+#define glTexParameteriv _funcptr_glTexParameteriv
+extern PFNGLTEXIMAGE1DPROC _funcptr_glTexImage1D;
+#define glTexImage1D _funcptr_glTexImage1D
+extern PFNGLTEXIMAGE2DPROC _funcptr_glTexImage2D;
+#define glTexImage2D _funcptr_glTexImage2D
+extern PFNGLDRAWBUFFERPROC _funcptr_glDrawBuffer;
+#define glDrawBuffer _funcptr_glDrawBuffer
+extern PFNGLCLEARPROC _funcptr_glClear;
+#define glClear _funcptr_glClear
+extern PFNGLCLEARCOLORPROC _funcptr_glClearColor;
+#define glClearColor _funcptr_glClearColor
+extern PFNGLCLEARSTENCILPROC _funcptr_glClearStencil;
+#define glClearStencil _funcptr_glClearStencil
+extern PFNGLCLEARDEPTHPROC _funcptr_glClearDepth;
+#define glClearDepth _funcptr_glClearDepth
+extern PFNGLSTENCILMASKPROC _funcptr_glStencilMask;
+#define glStencilMask _funcptr_glStencilMask
+extern PFNGLCOLORMASKPROC _funcptr_glColorMask;
+#define glColorMask _funcptr_glColorMask
+extern PFNGLDEPTHMASKPROC _funcptr_glDepthMask;
+#define glDepthMask _funcptr_glDepthMask
+extern PFNGLDISABLEPROC _funcptr_glDisable;
+#define glDisable _funcptr_glDisable
+extern PFNGLENABLEPROC _funcptr_glEnable;
+#define glEnable _funcptr_glEnable
+extern PFNGLFINISHPROC _funcptr_glFinish;
+#define glFinish _funcptr_glFinish
+extern PFNGLFLUSHPROC _funcptr_glFlush;
+#define glFlush _funcptr_glFlush
+extern PFNGLBLENDFUNCPROC _funcptr_glBlendFunc;
+#define glBlendFunc _funcptr_glBlendFunc
+extern PFNGLLOGICOPPROC _funcptr_glLogicOp;
+#define glLogicOp _funcptr_glLogicOp
+extern PFNGLSTENCILFUNCPROC _funcptr_glStencilFunc;
+#define glStencilFunc _funcptr_glStencilFunc
+extern PFNGLSTENCILOPPROC _funcptr_glStencilOp;
+#define glStencilOp _funcptr_glStencilOp
+extern PFNGLDEPTHFUNCPROC _funcptr_glDepthFunc;
+#define glDepthFunc _funcptr_glDepthFunc
+extern PFNGLPIXELSTOREFPROC _funcptr_glPixelStoref;
+#define glPixelStoref _funcptr_glPixelStoref
+extern PFNGLPIXELSTOREIPROC _funcptr_glPixelStorei;
+#define glPixelStorei _funcptr_glPixelStorei
+extern PFNGLREADBUFFERPROC _funcptr_glReadBuffer;
+#define glReadBuffer _funcptr_glReadBuffer
+extern PFNGLREADPIXELSPROC _funcptr_glReadPixels;
+#define glReadPixels _funcptr_glReadPixels
+extern PFNGLGETBOOLEANVPROC _funcptr_glGetBooleanv;
+#define glGetBooleanv _funcptr_glGetBooleanv
+extern PFNGLGETDOUBLEVPROC _funcptr_glGetDoublev;
+#define glGetDoublev _funcptr_glGetDoublev
+extern PFNGLGETERRORPROC _funcptr_glGetError;
+#define glGetError _funcptr_glGetError
+extern PFNGLGETFLOATVPROC _funcptr_glGetFloatv;
+#define glGetFloatv _funcptr_glGetFloatv
+extern PFNGLGETINTEGERVPROC _funcptr_glGetIntegerv;
+#define glGetIntegerv _funcptr_glGetIntegerv
+extern PFNGLGETSTRINGPROC _funcptr_glGetString;
+#define glGetString _funcptr_glGetString
+extern PFNGLGETTEXIMAGEPROC _funcptr_glGetTexImage;
+#define glGetTexImage _funcptr_glGetTexImage
+extern PFNGLGETTEXPARAMETERFVPROC _funcptr_glGetTexParameterfv;
+#define glGetTexParameterfv _funcptr_glGetTexParameterfv
+extern PFNGLGETTEXPARAMETERIVPROC _funcptr_glGetTexParameteriv;
+#define glGetTexParameteriv _funcptr_glGetTexParameteriv
+extern PFNGLGETTEXLEVELPARAMETERFVPROC _funcptr_glGetTexLevelParameterfv;
+#define glGetTexLevelParameterfv _funcptr_glGetTexLevelParameterfv
+extern PFNGLGETTEXLEVELPARAMETERIVPROC _funcptr_glGetTexLevelParameteriv;
+#define glGetTexLevelParameteriv _funcptr_glGetTexLevelParameteriv
+extern PFNGLISENABLEDPROC _funcptr_glIsEnabled;
+#define glIsEnabled _funcptr_glIsEnabled
+extern PFNGLDEPTHRANGEPROC _funcptr_glDepthRange;
+#define glDepthRange _funcptr_glDepthRange
+extern PFNGLVIEWPORTPROC _funcptr_glViewport;
+#define glViewport _funcptr_glViewport
+extern PFNGLDRAWARRAYSPROC _funcptr_glDrawArrays;
+#define glDrawArrays _funcptr_glDrawArrays
+extern PFNGLDRAWELEMENTSPROC _funcptr_glDrawElements;
+#define glDrawElements _funcptr_glDrawElements
+extern PFNGLGETPOINTERVPROC _funcptr_glGetPointerv;
+#define glGetPointerv _funcptr_glGetPointerv
+extern PFNGLPOLYGONOFFSETPROC _funcptr_glPolygonOffset;
+#define glPolygonOffset _funcptr_glPolygonOffset
+extern PFNGLCOPYTEXIMAGE1DPROC _funcptr_glCopyTexImage1D;
+#define glCopyTexImage1D _funcptr_glCopyTexImage1D
+extern PFNGLCOPYTEXIMAGE2DPROC _funcptr_glCopyTexImage2D;
+#define glCopyTexImage2D _funcptr_glCopyTexImage2D
+extern PFNGLCOPYTEXSUBIMAGE1DPROC _funcptr_glCopyTexSubImage1D;
+#define glCopyTexSubImage1D _funcptr_glCopyTexSubImage1D
+extern PFNGLCOPYTEXSUBIMAGE2DPROC _funcptr_glCopyTexSubImage2D;
+#define glCopyTexSubImage2D _funcptr_glCopyTexSubImage2D
+extern PFNGLTEXSUBIMAGE1DPROC _funcptr_glTexSubImage1D;
+#define glTexSubImage1D _funcptr_glTexSubImage1D
+extern PFNGLTEXSUBIMAGE2DPROC _funcptr_glTexSubImage2D;
+#define glTexSubImage2D _funcptr_glTexSubImage2D
+extern PFNGLBINDTEXTUREPROC _funcptr_glBindTexture;
+#define glBindTexture _funcptr_glBindTexture
+extern PFNGLDELETETEXTURESPROC _funcptr_glDeleteTextures;
+#define glDeleteTextures _funcptr_glDeleteTextures
+extern PFNGLGENTEXTURESPROC _funcptr_glGenTextures;
+#define glGenTextures _funcptr_glGenTextures
+extern PFNGLISTEXTUREPROC _funcptr_glIsTexture;
+#define glIsTexture _funcptr_glIsTexture
+extern PFNGLINDEXUBPROC _funcptr_glIndexub;
+#define glIndexub _funcptr_glIndexub
+extern PFNGLINDEXUBVPROC _funcptr_glIndexubv;
+#define glIndexubv _funcptr_glIndexubv
 
 #ifdef __cplusplus
 }
-#endif //__cplusplus
-
-
-#endif //_INT_GL_1_1_H
-
+#endif /*__cplusplus*/
+#endif /*OPENGL_GEN_CORE_1_1_H*/

glload/include/glload/_int_gl_1_1.hpp

-#ifndef _INT_GL_1_1_HPP
-#define _INT_GL_1_1_HPP
+#ifndef OPENGL_GEN_CORE_1_1_HPP
+#define OPENGL_GEN_CORE_1_1_HPP
 
-
-
-#ifdef __cplusplus
-extern "C" {
-#endif //__cplusplus
-
-
-extern void (GLE_FUNCPTR *__gleCullFace)(GLenum );
-extern void (GLE_FUNCPTR *__gleFrontFace)(GLenum );
-extern void (GLE_FUNCPTR *__gleHint)(GLenum , GLenum );
-extern void (GLE_FUNCPTR *__gleLineWidth)(GLfloat );
-extern void (GLE_FUNCPTR *__glePointSize)(GLfloat );
-extern void (GLE_FUNCPTR *__glePolygonMode)(GLenum , GLenum );
-extern void (GLE_FUNCPTR *__gleScissor)(GLint , GLint , GLsizei , GLsizei );
-extern void (GLE_FUNCPTR *__gleTexParameterf)(GLenum , GLenum , GLfloat );
-extern void (GLE_FUNCPTR *__gleTexParameterfv)(GLenum , GLenum , const GLfloat *);
-extern void (GLE_FUNCPTR *__gleTexParameteri)(GLenum , GLenum , GLint );
-extern void (GLE_FUNCPTR *__gleTexParameteriv)(GLenum , GLenum , const GLint *);
-extern void (GLE_FUNCPTR *__gleTexImage1D)(GLenum , GLint , GLint , GLsizei , GLint , GLenum , GLenum , const GLvoid *);
-extern void (GLE_FUNCPTR *__gleTexImage2D)(GLenum , GLint , GLint , GLsizei , GLsizei , GLint , GLenum , GLenum , const GLvoid *);
-extern void (GLE_FUNCPTR *__gleDrawBuffer)(GLenum );
-extern void (GLE_FUNCPTR *__gleClear)(GLbitfield );
-extern void (GLE_FUNCPTR *__gleClearColor)(GLfloat , GLfloat , GLfloat , GLfloat );
-extern void (GLE_FUNCPTR *__gleClearStencil)(GLint );
-extern void (GLE_FUNCPTR *__gleClearDepth)(GLdouble );
-extern void (GLE_FUNCPTR *__gleStencilMask)(GLuint );
-extern void (GLE_FUNCPTR *__gleColorMask)(GLboolean , GLboolean , GLboolean , GLboolean );
-extern void (GLE_FUNCPTR *__gleDepthMask)(GLboolean );
-extern void (GLE_FUNCPTR *__gleDisable)(GLenum );
-extern void (GLE_FUNCPTR *__gleEnable)(GLenum );
-extern void (GLE_FUNCPTR *__gleFinish)();
-extern void (GLE_FUNCPTR *__gleFlush)();
-extern void (GLE_FUNCPTR *__gleBlendFunc)(GLenum , GLenum );
-extern void (GLE_FUNCPTR *__gleLogicOp)(GLenum );
-extern void (GLE_FUNCPTR *__gleStencilFunc)(GLenum , GLint , GLuint );
-extern void (GLE_FUNCPTR *__gleStencilOp)(GLenum , GLenum , GLenum );
-extern void (GLE_FUNCPTR *__gleDepthFunc)(GLenum );
-extern void (GLE_FUNCPTR *__glePixelStoref)(GLenum , GLfloat );
-extern void (GLE_FUNCPTR *__glePixelStorei)(GLenum , GLint );
-extern void (GLE_FUNCPTR *__gleReadBuffer)(GLenum );
-extern void (GLE_FUNCPTR *__gleReadPixels)(GLint , GLint , GLsizei , GLsizei , GLenum , GLenum , GLvoid *);
-extern void (GLE_FUNCPTR *__gleGetBooleanv)(GLenum , GLboolean *);
-extern void (GLE_FUNCPTR *__gleGetDoublev)(GLenum , GLdouble *);
-extern GLenum (GLE_FUNCPTR *__gleGetError)();
-extern void (GLE_FUNCPTR *__gleGetFloatv)(GLenum , GLfloat *);
-extern void (GLE_FUNCPTR *__gleGetIntegerv)(GLenum , GLint *);
-extern const GLubyte * (GLE_FUNCPTR *__gleGetString)(GLenum );
-extern void (GLE_FUNCPTR *__gleGetTexImage)(GLenum , GLint , GLenum , GLenum , GLvoid *);
-extern void (GLE_FUNCPTR *__gleGetTexParameterfv)(GLenum , GLenum , GLfloat *);
-extern void (GLE_FUNCPTR *__gleGetTexParameteriv)(GLenum , GLenum , GLint *);
-extern void (GLE_FUNCPTR *__gleGetTexLevelParameterfv)(GLenum , GLint , GLenum , GLfloat *);
-extern void (GLE_FUNCPTR *__gleGetTexLevelParameteriv)(GLenum , GLint , GLenum , GLint *);
-extern GLboolean (GLE_FUNCPTR *__gleIsEnabled)(GLenum );
-extern void (GLE_FUNCPTR *__gleDepthRange)(GLdouble , GLdouble );
-extern void (GLE_FUNCPTR *__gleViewport)(GLint , GLint , GLsizei , GLsizei );
-extern void (GLE_FUNCPTR *__gleDrawArrays)(GLenum , GLint , GLsizei );
-extern void (GLE_FUNCPTR *__gleDrawElements)(GLenum , GLsizei , GLenum , const GLvoid *);
-extern void (GLE_FUNCPTR *__gleGetPointerv)(GLenum , GLvoid* *);
-extern void (GLE_FUNCPTR *__glePolygonOffset)(GLfloat , GLfloat );
-extern void (GLE_FUNCPTR *__gleCopyTexImage1D)(GLenum , GLint , GLenum , GLint , GLint , GLsizei , GLint );
-extern void (GLE_FUNCPTR *__gleCopyTexImage2D)(GLenum , GLint , GLenum , GLint , GLint , GLsizei , GLsizei , GLint );
-extern void (GLE_FUNCPTR *__gleCopyTexSubImage1D)(GLenum , GLint , GLint , GLint , GLint , GLsizei );
-extern void (GLE_FUNCPTR *__gleCopyTexSubImage2D)(GLenum , GLint , GLint , GLint , GLint , GLint , GLsizei , GLsizei );
-extern void (GLE_FUNCPTR *__gleTexSubImage1D)(GLenum , GLint , GLint , GLsizei , GLenum , GLenum , const GLvoid *);
-extern void (GLE_FUNCPTR *__gleTexSubImage2D)(GLenum , GLint , GLint , GLint , GLsizei , GLsizei , GLenum , GLenum , const GLvoid *);
-extern void (GLE_FUNCPTR *__gleBindTexture)(GLenum , GLuint );
-extern void (GLE_FUNCPTR *__gleDeleteTextures)(GLsizei , const GLuint *);
-extern void (GLE_FUNCPTR *__gleGenTextures)(GLsizei , GLuint *);
-extern GLboolean (GLE_FUNCPTR *__gleIsTexture)(GLuint );
-extern void (GLE_FUNCPTR *__gleIndexub)(GLubyte );
-extern void (GLE_FUNCPTR *__gleIndexubv)(const GLubyte *);
-#ifdef __cplusplus
-}
-#endif //__cplusplus
-
-
-
+#include "_int_load_test.hpp"
 namespace gl
 {
-	enum _int_gl_1_1
+	enum
 	{
-		GL_DEPTH_BUFFER_BIT              = 0x00000100,
-		GL_STENCIL_BUFFER_BIT            = 0x00000400,
-		GL_COLOR_BUFFER_BIT              = 0x00004000,
-		GL_FALSE                         = 0,
-		GL_TRUE                          = 1,
-		GL_POINTS                        = 0x0000,
-		GL_LINES                         = 0x0001,
-		GL_LINE_LOOP                     = 0x0002,
-		GL_LINE_STRIP                    = 0x0003,
-		GL_TRIANGLE_STRIP                = 0x0005,
-		GL_TRIANGLE_FAN                  = 0x0006,
-		GL_NEVER                         = 0x0200,
-		GL_LESS                          = 0x0201,
-		GL_LEQUAL                        = 0x0203,
-		GL_GREATER                       = 0x0204,
-		GL_NOTEQUAL                      = 0x0205,
-		GL_GEQUAL                        = 0x0206,
-		GL_ALWAYS                        = 0x0207,
-		GL_ONE                           = 1,
-		GL_SRC_COLOR                     = 0x0300,
-		GL_ONE_MINUS_SRC_COLOR           = 0x0301,
-		GL_SRC_ALPHA                     = 0x0302,
-		GL_ONE_MINUS_SRC_ALPHA           = 0x0303,
-		GL_DST_ALPHA                     = 0x0304,
-		GL_ONE_MINUS_DST_ALPHA           = 0x0305,
-		GL_DST_COLOR                     = 0x0306,
-		GL_ONE_MINUS_DST_COLOR           = 0x0307,
-		GL_SRC_ALPHA_SATURATE            = 0x0308,
-		GL_FRONT_LEFT                    = 0x0400,
-		GL_FRONT_RIGHT                   = 0x0401,
-		GL_BACK_LEFT                     = 0x0402,
-		GL_BACK_RIGHT                    = 0x0403,
-		GL_FRONT                         = 0x0404,
-		GL_BACK                          = 0x0405,
-		GL_LEFT                          = 0x0406,
-		GL_RIGHT                         = 0x0407,
-		GL_FRONT_AND_BACK                = 0x0408,
-		GL_INVALID_ENUM                  = 0x0500,
-		GL_INVALID_VALUE                 = 0x0501,
-		GL_INVALID_OPERATION             = 0x0502,
-		GL_OUT_OF_MEMORY                 = 0x0505,
-		GL_POINT_SIZE                    = 0x0B11,
-		GL_POINT_SIZE_RANGE              = 0x0B12,
-		GL_POINT_SIZE_GRANULARITY        = 0x0B13,
-		GL_LINE_SMOOTH                   = 0x0B20,
-		GL_LINE_WIDTH                    = 0x0B21,
-		GL_LINE_WIDTH_RANGE              = 0x0B22,
-		GL_LINE_WIDTH_GRANULARITY        = 0x0B23,
-		GL_POLYGON_SMOOTH                = 0x0B41,
-		GL_CULL_FACE                     = 0x0B44,
-		GL_CULL_FACE_MODE                = 0x0B45,
-		GL_FRONT_FACE                    = 0x0B46,
-		GL_DEPTH_TEST                    = 0x0B71,
-		GL_DEPTH_WRITEMASK               = 0x0B72,
-		GL_DEPTH_CLEAR_VALUE             = 0x0B73,
-		GL_DEPTH_FUNC                    = 0x0B74,
-		GL_STENCIL_TEST                  = 0x0B90,
-		GL_STENCIL_CLEAR_VALUE           = 0x0B91,
-		GL_STENCIL_FUNC                  = 0x0B92,
-		GL_STENCIL_VALUE_MASK            = 0x0B93,
-		GL_STENCIL_FAIL                  = 0x0B94,
-		GL_STENCIL_PASS_DEPTH_FAIL       = 0x0B95,
-		GL_STENCIL_PASS_DEPTH_PASS       = 0x0B96,
-		GL_STENCIL_REF                   = 0x0B97,
-		GL_STENCIL_WRITEMASK             = 0x0B98,
-		GL_DITHER                        = 0x0BD0,
-		GL_BLEND_DST                     = 0x0BE0,
-		GL_BLEND_SRC                     = 0x0BE1,
-		GL_BLEND                         = 0x0BE2,
-		GL_LOGIC_OP_MODE                 = 0x0BF0,
-		GL_COLOR_LOGIC_OP                = 0x0BF2,
-		GL_DRAW_BUFFER                   = 0x0C01,
-		GL_READ_BUFFER                   = 0x0C02,
-		GL_COLOR_CLEAR_VALUE             = 0x0C22,
-		GL_COLOR_WRITEMASK               = 0x0C23,
-		GL_DOUBLEBUFFER                  = 0x0C32,
-		GL_STEREO                        = 0x0C33,
-		GL_LINE_SMOOTH_HINT              = 0x0C52,
-		GL_POLYGON_SMOOTH_HINT           = 0x0C53,
-		GL_UNPACK_SWAP_BYTES             = 0x0CF0,
-		GL_UNPACK_LSB_FIRST              = 0x0CF1,
-		GL_UNPACK_ROW_LENGTH             = 0x0CF2,
-		GL_UNPACK_SKIP_ROWS              = 0x0CF3,
-		GL_UNPACK_SKIP_PIXELS            = 0x0CF4,
-		GL_UNPACK_ALIGNMENT              = 0x0CF5,
-		GL_PACK_SWAP_BYTES               = 0x0D00,
-		GL_PACK_LSB_FIRST                = 0x0D01,
-		GL_PACK_ROW_LENGTH               = 0x0D02,
-		GL_PACK_SKIP_ROWS                = 0x0D03,
-		GL_PACK_SKIP_PIXELS              = 0x0D04,
-		GL_PACK_ALIGNMENT                = 0x0D05,
-		GL_MAX_TEXTURE_SIZE              = 0x0D33,
-		GL_MAX_VIEWPORT_DIMS             = 0x0D3A,
-		GL_SUBPIXEL_BITS                 = 0x0D50,
-		GL_POLYGON_OFFSET_UNITS          = 0x2A00,
-		GL_POLYGON_OFFSET_POINT          = 0x2A01,
-		GL_POLYGON_OFFSET_LINE           = 0x2A02,
-		GL_POLYGON_OFFSET_FILL           = 0x8037,
-		GL_POLYGON_OFFSET_FACTOR         = 0x8038,
-		GL_TEXTURE_BINDING_1D            = 0x8068,
-		GL_TEXTURE_BINDING_2D            = 0x8069,
-		GL_TEXTURE_WIDTH                 = 0x1000,
-		GL_TEXTURE_HEIGHT                = 0x1001,
-		GL_TEXTURE_INTERNAL_FORMAT       = 0x1003,
-		GL_TEXTURE_BORDER_COLOR          = 0x1004,
-		GL_TEXTURE_RED_SIZE              = 0x805C,
-		GL_TEXTURE_GREEN_SIZE            = 0x805D,
-		GL_TEXTURE_BLUE_SIZE             = 0x805E,
-		GL_TEXTURE_ALPHA_SIZE            = 0x805F,
-		GL_DONT_CARE                     = 0x1100,
-		GL_FASTEST                       = 0x1101,
-		GL_NICEST                        = 0x1102,
-		GL_BYTE                          = 0x1400,
-		GL_UNSIGNED_BYTE                 = 0x1401,
-		GL_SHORT                         = 0x1402,
-		GL_UNSIGNED_SHORT                = 0x1403,
-		GL_INT                           = 0x1404,
-		GL_UNSIGNED_INT                  = 0x1405,
-		GL_FLOAT                         = 0x1406,
-		GL_CLEAR                         = 0x1500,
-		GL_AND                           = 0x1501,
-		GL_AND_REVERSE                   = 0x1502,
-		GL_COPY                          = 0x1503,
-		GL_AND_INVERTED                  = 0x1504,
-		GL_NOOP                          = 0x1505,
-		GL_XOR                           = 0x1506,
-		GL_OR                            = 0x1507,
-		GL_NOR                           = 0x1508,
-		GL_EQUIV                         = 0x1509,
-		GL_INVERT                        = 0x150A,
-		GL_OR_REVERSE                    = 0x150B,
-		GL_COPY_INVERTED                 = 0x150C,
-		GL_OR_INVERTED                   = 0x150D,
-		GL_NAND                          = 0x150E,
-		GL_SET                           = 0x150F,
-		GL_TEXTURE                       = 0x1702,
-		GL_COLOR                         = 0x1800,
-		GL_DEPTH                         = 0x1801,
-		GL_STENCIL                       = 0x1802,
-		GL_STENCIL_INDEX                 = 0x1901,
-		GL_DEPTH_COMPONENT               = 0x1902,
-		GL_RED                           = 0x1903,
-		GL_GREEN                         = 0x1904,
-		GL_BLUE                          = 0x1905,
-		GL_ALPHA                         = 0x1906,
-		GL_RGB                           = 0x1907,
-		GL_RGBA                          = 0x1908,
-		GL_POINT                         = 0x1B00,
-		GL_LINE                          = 0x1B01,
-		GL_FILL                          = 0x1B02,
-		GL_KEEP                          = 0x1E00,
-		GL_REPLACE                       = 0x1E01,
-		GL_INCR                          = 0x1E02,
-		GL_DECR                          = 0x1E03,
-		GL_VENDOR                        = 0x1F00,
-		GL_RENDERER                      = 0x1F01,
-		GL_VERSION                       = 0x1F02,
-		GL_EXTENSIONS                    = 0x1F03,
-		GL_NEAREST                       = 0x2600,
-		GL_LINEAR                        = 0x2601,
-		GL_NEAREST_MIPMAP_NEAREST        = 0x2700,
-		GL_LINEAR_MIPMAP_NEAREST         = 0x2701,
-		GL_NEAREST_MIPMAP_LINEAR         = 0x2702,
-		GL_LINEAR_MIPMAP_LINEAR          = 0x2703,
-		GL_TEXTURE_MAG_FILTER            = 0x2800,
-		GL_TEXTURE_MIN_FILTER            = 0x2801,
-		GL_TEXTURE_WRAP_S                = 0x2802,
-		GL_TEXTURE_WRAP_T                = 0x2803,
-		GL_PROXY_TEXTURE_1D              = 0x8063,
-		GL_PROXY_TEXTURE_2D              = 0x8064,
-		GL_REPEAT                        = 0x2901,
-		GL_R3_G3_B2                      = 0x2A10,
-		GL_RGB4                          = 0x804F,
-		GL_RGB5                          = 0x8050,
-		GL_RGB8                          = 0x8051,
-		GL_RGB10                         = 0x8052,
-		GL_RGB12                         = 0x8053,
-		GL_RGB16                         = 0x8054,
-		GL_RGBA2                         = 0x8055,
-		GL_RGBA4                         = 0x8056,
-		GL_RGB5_A1                       = 0x8057,
-		GL_RGBA8                         = 0x8058,
-		GL_RGB10_A2                      = 0x8059,
-		GL_RGBA12                        = 0x805A,
-		GL_RGBA16                        = 0x805B,
+		DEPTH_BUFFER_BIT                 = 0x00000100,
+		STENCIL_BUFFER_BIT               = 0x00000400,
+		COLOR_BUFFER_BIT                 = 0x00004000,
+		FALSE_                           = 0,
+		TRUE_                            = 1,
+		POINTS                           = 0x0000,
+		LINES                            = 0x0001,
+		LINE_LOOP                        = 0x0002,
+		LINE_STRIP                       = 0x0003,
+		TRIANGLE_STRIP                   = 0x0005,
+		TRIANGLE_FAN                     = 0x0006,
+		NEVER                            = 0x0200,
+		LESS                             = 0x0201,
+		LEQUAL                           = 0x0203,
+		GREATER                          = 0x0204,
+		NOTEQUAL                         = 0x0205,
+		GEQUAL                           = 0x0206,
+		ALWAYS                           = 0x0207,
+		ONE                              = 1,
+		SRC_COLOR                        = 0x0300,
+		ONE_MINUS_SRC_COLOR              = 0x0301,
+		SRC_ALPHA                        = 0x0302,
+		ONE_MINUS_SRC_ALPHA              = 0x0303,
+		DST_ALPHA                        = 0x0304,
+		ONE_MINUS_DST_ALPHA              = 0x0305,
+		DST_COLOR                        = 0x0306,
+		ONE_MINUS_DST_COLOR              = 0x0307,
+		SRC_ALPHA_SATURATE               = 0x0308,
+		FRONT_LEFT                       = 0x0400,
+		FRONT_RIGHT                      = 0x0401,
+		BACK_LEFT                        = 0x0402,
+		BACK_RIGHT                       = 0x0403,
+		FRONT                            = 0x0404,
+		BACK                             = 0x0405,
+		LEFT                             = 0x0406,
+		RIGHT                            = 0x0407,
+		FRONT_AND_BACK                   = 0x0408,
+		INVALID_ENUM                     = 0x0500,
+		INVALID_VALUE                    = 0x0501,
+		INVALID_OPERATION                = 0x0502,
+		OUT_OF_MEMORY                    = 0x0505,
+		POINT_SIZE                       = 0x0B11,
+		POINT_SIZE_RANGE                 = 0x0B12,
+		POINT_SIZE_GRANULARITY           = 0x0B13,
+		LINE_SMOOTH                      = 0x0B20,
+		LINE_WIDTH                       = 0x0B21,
+		LINE_WIDTH_RANGE                 = 0x0B22,
+		LINE_WIDTH_GRANULARITY           = 0x0B23,
+		POLYGON_MODE                     = 0x0B40,
+		POLYGON_SMOOTH                   = 0x0B41,
+		CULL_FACE                        = 0x0B44,
+		CULL_FACE_MODE                   = 0x0B45,
+		FRONT_FACE                       = 0x0B46,
+		DEPTH_TEST                       = 0x0B71,
+		DEPTH_WRITEMASK                  = 0x0B72,
+		DEPTH_CLEAR_VALUE                = 0x0B73,
+		DEPTH_FUNC                       = 0x0B74,
+		STENCIL_TEST                     = 0x0B90,
+		STENCIL_CLEAR_VALUE              = 0x0B91,
+		STENCIL_FUNC                     = 0x0B92,
+		STENCIL_VALUE_MASK               = 0x0B93,
+		STENCIL_FAIL                     = 0x0B94,
+		STENCIL_PASS_DEPTH_FAIL          = 0x0B95,
+		STENCIL_PASS_DEPTH_PASS          = 0x0B96,
+		STENCIL_REF                      = 0x0B97,
+		STENCIL_WRITEMASK                = 0x0B98,
+		DITHER                           = 0x0BD0,
+		BLEND_DST                        = 0x0BE0,
+		BLEND_SRC                        = 0x0BE1,
+		BLEND                            = 0x0BE2,
+		LOGIC_OP_MODE                    = 0x0BF0,
+		COLOR_LOGIC_OP                   = 0x0BF2,
+		DRAW_BUFFER                      = 0x0C01,
+		READ_BUFFER                      = 0x0C02,
+		COLOR_CLEAR_VALUE                = 0x0C22,
+		COLOR_WRITEMASK                  = 0x0C23,
+		DOUBLEBUFFER                     = 0x0C32,
+		STEREO                           = 0x0C33,
+		LINE_SMOOTH_HINT                 = 0x0C52,
+		POLYGON_SMOOTH_HINT              = 0x0C53,
+		UNPACK_SWAP_BYTES                = 0x0CF0,
+		UNPACK_LSB_FIRST                 = 0x0CF1,
+		UNPACK_ROW_LENGTH                = 0x0CF2,
+		UNPACK_SKIP_ROWS                 = 0x0CF3,
+		UNPACK_SKIP_PIXELS               = 0x0CF4,
+		UNPACK_ALIGNMENT                 = 0x0CF5,
+		PACK_SWAP_BYTES                  = 0x0D00,
+		PACK_LSB_FIRST                   = 0x0D01,
+		PACK_ROW_LENGTH                  = 0x0D02,
+		PACK_SKIP_ROWS                   = 0x0D03,
+		PACK_SKIP_PIXELS                 = 0x0D04,
+		PACK_ALIGNMENT                   = 0x0D05,
+		MAX_TEXTURE_SIZE                 = 0x0D33,
+		MAX_VIEWPORT_DIMS                = 0x0D3A,
+		SUBPIXEL_BITS                    = 0x0D50,
+		POLYGON_OFFSET_UNITS             = 0x2A00,
+		POLYGON_OFFSET_POINT             = 0x2A01,
+		POLYGON_OFFSET_LINE              = 0x2A02,
+		POLYGON_OFFSET_FILL              = 0x8037,
+		POLYGON_OFFSET_FACTOR            = 0x8038,
+		TEXTURE_BINDING_1D               = 0x8068,
+		TEXTURE_BINDING_2D               = 0x8069,
+		TEXTURE_WIDTH                    = 0x1000,
+		TEXTURE_HEIGHT                   = 0x1001,
+		TEXTURE_INTERNAL_FORMAT          = 0x1003,
+		TEXTURE_BORDER_COLOR             = 0x1004,
+		TEXTURE_RED_SIZE                 = 0x805C,
+		TEXTURE_GREEN_SIZE               = 0x805D,
+		TEXTURE_BLUE_SIZE                = 0x805E,
+		TEXTURE_ALPHA_SIZE               = 0x805F,
+		DONT_CARE                        = 0x1100,
+		FASTEST                          = 0x1101,
+		NICEST                           = 0x1102,
+		BYTE                             = 0x1400,
+		UNSIGNED_BYTE                    = 0x1401,
+		SHORT                            = 0x1402,
+		UNSIGNED_SHORT                   = 0x1403,
+		INT                              = 0x1404,
+		UNSIGNED_INT                     = 0x1405,
+		FLOAT                            = 0x1406,
+		CLEAR                            = 0x1500,
+		AND                              = 0x1501,
+		AND_REVERSE                      = 0x1502,
+		COPY                             = 0x1503,
+		AND_INVERTED                     = 0x1504,
+		NOOP                             = 0x1505,
+		XOR                              = 0x1506,
+		OR                               = 0x1507,
+		NOR                              = 0x1508,
+		EQUIV                            = 0x1509,
+		INVERT                           = 0x150A,
+		OR_REVERSE                       = 0x150B,
+		COPY_INVERTED                    = 0x150C,
+		OR_INVERTED                      = 0x150D,
+		NAND                             = 0x150E,
+		SET                              = 0x150F,
+		TEXTURE                          = 0x1702,
+		COLOR                            = 0x1800,
+		DEPTH                            = 0x1801,
+		STENCIL                          = 0x1802,
+		STENCIL_INDEX                    = 0x1901,
+		DEPTH_COMPONENT                  = 0x1902,
+		RED                              = 0x1903,
+		GREEN                            = 0x1904,
+		BLUE                             = 0x1905,
+		ALPHA                            = 0x1906,
+		RGB                              = 0x1907,
+		RGBA                             = 0x1908,
+		POINT                            = 0x1B00,
+		LINE                             = 0x1B01,
+		FILL                             = 0x1B02,
+		KEEP                             = 0x1E00,
+		REPLACE                          = 0x1E01,
+		INCR                             = 0x1E02,
+		DECR                             = 0x1E03,
+		VENDOR                           = 0x1F00,
+		RENDERER                         = 0x1F01,
+		VERSION                          = 0x1F02,
+		EXTENSIONS                       = 0x1F03,
+		NEAREST                          = 0x2600,
+		LINEAR                           = 0x2601,
+		NEAREST_MIPMAP_NEAREST           = 0x2700,
+		LINEAR_MIPMAP_NEAREST            = 0x2701,
+		NEAREST_MIPMAP_LINEAR            = 0x2702,
+		LINEAR_MIPMAP_LINEAR             = 0x2703,
+		TEXTURE_MAG_FILTER               = 0x2800,
+		TEXTURE_MIN_FILTER               = 0x2801,
+		TEXTURE_WRAP_S                   = 0x2802,
+		TEXTURE_WRAP_T                   = 0x2803,
+		PROXY_TEXTURE_1D                 = 0x8063,
+		PROXY_TEXTURE_2D                 = 0x8064,
+		REPEAT                           = 0x2901,
+		R3_G3_B2                         = 0x2A10,
+		RGB4                             = 0x804F,
+		RGB5                             = 0x8050,
+		RGB8                             = 0x8051,
+		RGB10                            = 0x8052,
+		RGB12                            = 0x8053,
+		RGB16                            = 0x8054,
+		RGBA2                            = 0x8055,
+		RGBA4                            = 0x8056,
+		RGB5_A1                          = 0x8057,
+		RGBA8                            = 0x8058,
+		RGB10_A2                         = 0x8059,
+		RGBA12                           = 0x805A,
+		RGBA16                           = 0x805B,
 	};
-
-	inline void CullFace(GLenum mode) { ::__gleCullFace(mode); }
-	inline void FrontFace(GLenum mode) { ::__gleFrontFace(mode); }
-	inline void Hint(GLenum target, GLenum mode) { ::__gleHint(target, mode); }
-	inline void LineWidth(GLfloat width) { ::__gleLineWidth(width); }
-	inline void PointSize(GLfloat size) { ::__glePointSize(size); }
-	inline void PolygonMode(GLenum face, GLenum mode) { ::__glePolygonMode(face, mode); }
-	inline void Scissor(GLint x, GLint y, GLsizei width, GLsizei height) { ::__gleScissor(x, y, width, height); }
-	inline void TexParameterf(GLenum target, GLenum pname, GLfloat param) { ::__gleTexParameterf(target, pname, param); }
-	inline void TexParameterfv(GLenum target, GLenum pname, const GLfloat *params) { ::__gleTexParameterfv(target, pname, params); }
-	inline void TexParameteri(GLenum target, GLenum pname, GLint param) { ::__gleTexParameteri(target, pname, param); }
-	inline void TexParameteriv(GLenum target, GLenum pname, const GLint *params) { ::__gleTexParameteriv(target, pname, params); }
-	inline void TexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels) { ::__gleTexImage1D(target, level, internalformat, width, border, format, type, pixels); }
-	inline void TexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels) { ::__gleTexImage2D(target, level, internalformat, width, height, border, format, type, pixels); }
-	inline void DrawBuffer(GLenum mode) { ::__gleDrawBuffer(mode); }
-	inline void Clear(GLbitfield mask) { ::__gleClear(mask); }
-	inline void ClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) { ::__gleClearColor(red, green, blue, alpha); }
-	inline void ClearStencil(GLint s) { ::__gleClearStencil(s); }
-	inline void ClearDepth(GLdouble depth) { ::__gleClearDepth(depth); }
-	inline void StencilMask(GLuint mask) { ::__gleStencilMask(mask); }
-	inline void ColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) { ::__gleColorMask(red, green, blue, alpha); }
-	inline void DepthMask(GLboolean flag) { ::__gleDepthMask(flag); }
-	inline void Disable(GLenum cap) { ::__gleDisable(cap); }
-	inline void Enable(GLenum cap) { ::__gleEnable(cap); }
-	inline void Finish() { ::__gleFinish(); }
-	inline void Flush() { ::__gleFlush(); }
-	inline void BlendFunc(GLenum sfactor, GLenum dfactor) { ::__gleBlendFunc(sfactor, dfactor); }
-	inline void LogicOp(GLenum opcode) { ::__gleLogicOp(opcode); }
-	inline void StencilFunc(GLenum func, GLint ref, GLuint mask) { ::__gleStencilFunc(func, ref, mask); }
-	inline void StencilOp(GLenum fail, GLenum zfail, GLenum zpass) { ::__gleStencilOp(fail, zfail, zpass); }
-	inline void DepthFunc(GLenum func) { ::__gleDepthFunc(func); }
-	inline void PixelStoref(GLenum pname, GLfloat param) { ::__glePixelStoref(pname, param); }
-	inline void PixelStorei(GLenum pname, GLint param) { ::__glePixelStorei(pname, param); }
-	inline void ReadBuffer(GLenum mode) { ::__gleReadBuffer(mode); }
-	inline void ReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels) { ::__gleReadPixels(x, y, width, height, format, type, pixels); }
-	inline void GetBooleanv(GLenum pname, GLboolean *params) { ::__gleGetBooleanv(pname, params); }
-	inline void GetDoublev(GLenum pname, GLdouble *params) { ::__gleGetDoublev(pname, params); }
-	inline GLenum GetError() { return ::__gleGetError(); }
-	inline void GetFloatv(GLenum pname, GLfloat *params) { ::__gleGetFloatv(pname, params); }
-	inline void GetIntegerv(GLenum pname, GLint *params) { ::__gleGetIntegerv(pname, params); }
-	inline const GLubyte * GetString(GLenum name) { return ::__gleGetString(name); }
-	inline void GetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels) { ::__gleGetTexImage(target, level, format, type, pixels); }
-	inline void GetTexParameterfv(GLenum target, GLenum pname, GLfloat *params) { ::__gleGetTexParameterfv(target, pname, params); }
-	inline void GetTexParameteriv(GLenum target, GLenum pname, GLint *params) { ::__gleGetTexParameteriv(target, pname, params); }
-	inline void GetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params) { ::__gleGetTexLevelParameterfv(target, level, pname, params); }
-	inline void GetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params) { ::__gleGetTexLevelParameteriv(target, level, pname, params); }
-	inline GLboolean IsEnabled(GLenum cap) { return ::__gleIsEnabled(cap); }
-	inline void DepthRange(GLdouble ren_near, GLdouble ren_far) { ::__gleDepthRange(ren_near, ren_far); }
-	inline void Viewport(GLint x, GLint y, GLsizei width, GLsizei height) { ::__gleViewport(x, y, width, height); }
-	inline void DrawArrays(GLenum mode, GLint first, GLsizei count) { ::__gleDrawArrays(mode, first, count); }
-	inline void DrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices) { ::__gleDrawElements(mode, count, type, indices); }
-	inline void GetPointerv(GLenum pname, GLvoid* *params) { ::__gleGetPointerv(pname, params); }
-	inline void PolygonOffset(GLfloat factor, GLfloat units) { ::__glePolygonOffset(factor, units); }
-	inline void CopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border) { ::__gleCopyTexImage1D(target, level, internalformat, x, y, width, border); }
-	inline void CopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) { ::__gleCopyTexImage2D(target, level, internalformat, x, y, width, height, border); }
-	inline void CopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width) { ::__gleCopyTexSubImage1D(target, level, xoffset, x, y, width); }
-	inline void CopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) { ::__gleCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height); }
-	inline void TexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels) { ::__gleTexSubImage1D(target, level, xoffset, width, format, type, pixels); }
-	inline void TexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels) { ::__gleTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels); }
-	inline void BindTexture(GLenum target, GLuint texture) { ::__gleBindTexture(target, texture); }
-	inline void DeleteTextures(GLsizei n, const GLuint *textures) { ::__gleDeleteTextures(n, textures); }
-	inline void GenTextures(GLsizei n, GLuint *textures) { ::__gleGenTextures(n, textures); }
-	inline GLboolean IsTexture(GLuint texture) { return ::__gleIsTexture(texture); }
-	inline void Indexub(GLubyte c) { ::__gleIndexub(c); }
-	inline void Indexubv(const GLubyte *c) { ::__gleIndexubv(c); }
-
+	
+	namespace _detail
+	{
+		typedef void (CODEGEN_FUNCPTR * Proc_glCullFace)(GLenum );
+		typedef void (CODEGEN_FUNCPTR * Proc_glFrontFace)(GLenum );
+		typedef void (CODEGEN_FUNCPTR * Proc_glHint)(GLenum , GLenum );
+		typedef void (CODEGEN_FUNCPTR * Proc_glLineWidth)(GLfloat );
+		typedef void (CODEGEN_FUNCPTR * Proc_glPointSize)(GLfloat );
+		typedef void (CODEGEN_FUNCPTR * Proc_glPolygonMode)(GLenum , GLenum );
+		typedef void (CODEGEN_FUNCPTR * Proc_glScissor)(GLint , GLint , GLsizei , GLsizei );
+		typedef void (CODEGEN_FUNCPTR * Proc_glTexParameterf)(GLenum , GLenum , GLfloat );
+		typedef void (CODEGEN_FUNCPTR * Proc_glTexParameterfv)(GLenum , GLenum , const GLfloat *);
+		typedef void (CODEGEN_FUNCPTR * Proc_glTexParameteri)(GLenum , GLenum , GLint );
+		typedef void (CODEGEN_FUNCPTR * Proc_glTexParameteriv)(GLenum , GLenum , const GLint *);
+		typedef void (CODEGEN_FUNCPTR * Proc_glTexImage1D)(GLenum , GLint , GLint , GLsizei , GLint , GLenum , GLenum , const GLvoid *);
+		typedef void (CODEGEN_FUNCPTR * Proc_glTexImage2D)(GLenum , GLint , GLint , GLsizei , GLsizei , GLint , GLenum , GLenum , const GLvoid *);
+		typedef void (CODEGEN_FUNCPTR * Proc_glDrawBuffer)(GLenum );
+		typedef void (CODEGEN_FUNCPTR * Proc_glClear)(GLbitfield );
+		typedef void (CODEGEN_FUNCPTR * Proc_glClearColor)(GLfloat , GLfloat , GLfloat , GLfloat );
+		typedef void (CODEGEN_FUNCPTR * Proc_glClearStencil)(GLint );
+		typedef void (CODEGEN_FUNCPTR * Proc_glClearDepth)(GLdouble );
+		typedef void (CODEGEN_FUNCPTR * Proc_glStencilMask)(GLuint );
+		typedef void (CODEGEN_FUNCPTR * Proc_glColorMask)(GLboolean , GLboolean , GLboolean , GLboolean );
+		typedef void (CODEGEN_FUNCPTR * Proc_glDepthMask)(GLboolean );
+		typedef void (CODEGEN_FUNCPTR * Proc_glDisable)(GLenum );
+		typedef void (CODEGEN_FUNCPTR * Proc_glEnable)(GLenum );
+		typedef void (CODEGEN_FUNCPTR * Proc_glFinish)();
+		typedef void (CODEGEN_FUNCPTR * Proc_glFlush)();
+		typedef void (CODEGEN_FUNCPTR * Proc_glBlendFunc)(GLenum , GLenum );
+		typedef void (CODEGEN_FUNCPTR * Proc_glLogicOp)(GLenum );
+		typedef void (CODEGEN_FUNCPTR * Proc_glStencilFunc)(GLenum , GLint , GLuint );
+		typedef void (CODEGEN_FUNCPTR * Proc_glStencilOp)(GLenum , GLenum , GLenum );
+		typedef void (CODEGEN_FUNCPTR * Proc_glDepthFunc)(GLenum );
+		typedef void (CODEGEN_FUNCPTR * Proc_glPixelStoref)(GLenum , GLfloat );
+		typedef void (CODEGEN_FUNCPTR * Proc_glPixelStorei)(GLenum , GLint );
+		typedef void (CODEGEN_FUNCPTR * Proc_glReadBuffer)(GLenum );
+		typedef void (CODEGEN_FUNCPTR * Proc_glReadPixels)(GLint , GLint , GLsizei , GLsizei , GLenum , GLenum , GLvoid *);
+		typedef void (CODEGEN_FUNCPTR * Proc_glGetBooleanv)(GLenum , GLboolean *);
+		typedef void (CODEGEN_FUNCPTR * Proc_glGetDoublev)(GLenum , GLdouble *);
+		typedef GLenum (CODEGEN_FUNCPTR * Proc_glGetError)();
+		typedef void (CODEGEN_FUNCPTR * Proc_glGetFloatv)(GLenum , GLfloat *);
+		typedef void (CODEGEN_FUNCPTR * Proc_glGetIntegerv)(GLenum , GLint *);
+		typedef const GLubyte * (CODEGEN_FUNCPTR * Proc_glGetString)(GLenum );
+		typedef void (CODEGEN_FUNCPTR * Proc_glGetTexImage)(GLenum , GLint , GLenum , GLenum , GLvoid *);
+		typedef void (CODEGEN_FUNCPTR * Proc_glGetTexParameterfv)(GLenum , GLenum , GLfloat *);
+		typedef void (CODEGEN_FUNCPTR * Proc_glGetTexParameteriv)(GLenum , GLenum , GLint *);
+		typedef void (CODEGEN_FUNCPTR * Proc_glGetTexLevelParameterfv)(GLenum , GLint , GLenum , GLfloat *);
+		typedef void (CODEGEN_FUNCPTR * Proc_glGetTexLevelParameteriv)(GLenum , GLint , GLenum , GLint *);
+		typedef GLboolean (CODEGEN_FUNCPTR * Proc_glIsEnabled)(GLenum );
+		typedef void (CODEGEN_FUNCPTR * Proc_glDepthRange)(GLdouble , GLdouble );
+		typedef void (CODEGEN_FUNCPTR * Proc_glViewport)(GLint , GLint , GLsizei , GLsizei );
+		typedef void (CODEGEN_FUNCPTR * Proc_glDrawArrays)(GLenum , GLint , GLsizei );
+		typedef void (CODEGEN_FUNCPTR * Proc_glDrawElements)(GLenum , GLsizei , GLenum , const GLvoid *);
+		typedef void (CODEGEN_FUNCPTR * Proc_glGetPointerv)(GLenum , GLvoid* *);
+		typedef void (CODEGEN_FUNCPTR * Proc_glPolygonOffset)(GLfloat , GLfloat );
+		typedef void (CODEGEN_FUNCPTR * Proc_glCopyTexImage1D)(GLenum , GLint , GLenum , GLint , GLint , GLsizei , GLint );
+		typedef void (CODEGEN_FUNCPTR * Proc_glCopyTexImage2D)(GLenum , GLint , GLenum , GLint , GLint , GLsizei , GLsizei , GLint );
+		typedef void (CODEGEN_FUNCPTR * Proc_glCopyTexSubImage1D)(GLenum , GLint , GLint , GLint , GLint , GLsizei );
+		typedef void (CODEGEN_FUNCPTR * Proc_glCopyTexSubImage2D)(GLenum , GLint , GLint , GLint , GLint , GLint , GLsizei , GLsizei );
+		typedef void (CODEGEN_FUNCPTR * Proc_glTexSubImage1D)(GLenum , GLint , GLint , GLsizei , GLenum , GLenum , const GLvoid *);
+		typedef void (CODEGEN_FUNCPTR * Proc_glTexSubImage2D)(GLenum , GLint , GLint , GLint , GLsizei , GLsizei , GLenum , GLenum , const GLvoid *);
+		typedef void (CODEGEN_FUNCPTR * Proc_glBindTexture)(GLenum , GLuint );
+		typedef void (CODEGEN_FUNCPTR * Proc_glDeleteTextures)(GLsizei , const GLuint *);
+		typedef void (CODEGEN_FUNCPTR * Proc_glGenTextures)(GLsizei , GLuint *);
+		typedef GLboolean (CODEGEN_FUNCPTR * Proc_glIsTexture)(GLuint );
+		typedef void (CODEGEN_FUNCPTR * Proc_glIndexub)(GLubyte );
+		typedef void (CODEGEN_FUNCPTR * Proc_glIndexubv)(const GLubyte *);
+	}
+	
+	extern _detail::Proc_glCullFace CullFace;
+	extern _detail::Proc_glFrontFace FrontFace;
+	extern _detail::Proc_glHint Hint;
+	extern _detail::Proc_glLineWidth LineWidth;
+	extern _detail::Proc_glPointSize PointSize;
+	extern _detail::Proc_glPolygonMode PolygonMode;
+	extern _detail::Proc_glScissor Scissor;
+	extern _detail::Proc_glTexParameterf TexParameterf;
+	extern _detail::Proc_glTexParameterfv TexParameterfv;
+	extern _detail::Proc_glTexParameteri TexParameteri;
+	extern _detail::Proc_glTexParameteriv TexParameteriv;
+	extern _detail::Proc_glTexImage1D TexImage1D;
+	extern _detail::Proc_glTexImage2D TexImage2D;
+	extern _detail::Proc_glDrawBuffer DrawBuffer;
+	extern _detail::Proc_glClear Clear;
+	extern _detail::Proc_glClearColor ClearColor;
+	extern _detail::Proc_glClearStencil ClearStencil;
+	extern _detail::Proc_glClearDepth ClearDepth;
+	extern _detail::Proc_glStencilMask StencilMask;
+	extern _detail::Proc_glColorMask ColorMask;
+	extern _detail::Proc_glDepthMask DepthMask;
+	extern _detail::Proc_glDisable Disable;
+	extern _detail::Proc_glEnable Enable;
+	extern _detail::Proc_glFinish Finish;
+	extern _detail::Proc_glFlush Flush;
+	extern _detail::Proc_glBlendFunc BlendFunc;
+	extern _detail::Proc_glLogicOp LogicOp;
+	extern _detail::Proc_glStencilFunc StencilFunc;
+	extern _detail::Proc_glStencilOp StencilOp;
+	extern _detail::Proc_glDepthFunc DepthFunc;
+	extern _detail::Proc_glPixelStoref PixelStoref;
+	extern _detail::Proc_glPixelStorei PixelStorei;
+	extern _detail::Proc_glReadBuffer ReadBuffer;
+	extern _detail::Proc_glReadPixels ReadPixels;
+	extern _detail::Proc_glGetBooleanv GetBooleanv;
+	extern _detail::Proc_glGetDoublev GetDoublev;
+	extern _detail::Proc_glGetError GetError;
+	extern _detail::Proc_glGetFloatv GetFloatv;
+	extern _detail::Proc_glGetIntegerv GetIntegerv;
+	extern _detail::Proc_glGetString GetString;
+	extern _detail::Proc_glGetTexImage GetTexImage;
+	extern _detail::Proc_glGetTexParameterfv GetTexParameterfv;
+	extern _detail::Proc_glGetTexParameteriv GetTexParameteriv;
+	extern _detail::Proc_glGetTexLevelParameterfv GetTexLevelParameterfv;
+	extern _detail::Proc_glGetTexLevelParameteriv GetTexLevelParameteriv;
+	extern _detail::Proc_glIsEnabled IsEnabled;
+	extern _detail::Proc_glDepthRange DepthRange;
+	extern _detail::Proc_glViewport Viewport;
+	extern _detail::Proc_glDrawArrays DrawArrays;
+	extern _detail::Proc_glDrawElements DrawElements;
+	extern _detail::Proc_glGetPointerv GetPointerv;
+	extern _detail::Proc_glPolygonOffset PolygonOffset;
+	extern _detail::Proc_glCopyTexImage1D CopyTexImage1D;
+	extern _detail::Proc_glCopyTexImage2D CopyTexImage2D;
+	extern _detail::Proc_glCopyTexSubImage1D CopyTexSubImage1D;
+	extern _detail::Proc_glCopyTexSubImage2D CopyTexSubImage2D;
+	extern _detail::Proc_glTexSubImage1D TexSubImage1D;
+	extern _detail::Proc_glTexSubImage2D TexSubImage2D;
+	extern _detail::Proc_glBindTexture BindTexture;
+	extern _detail::Proc_glDeleteTextures DeleteTextures;
+	extern _detail::Proc_glGenTextures GenTextures;
+	extern _detail::Proc_glIsTexture IsTexture;
+	extern _detail::Proc_glIndexub Indexub;
+	extern _detail::Proc_glIndexubv Indexubv;
+	
 }
-
-#endif //_INT_GL_1_1_HPP
-
+#endif /*OPENGL_GEN_CORE_1_1_HPP*/

glload/include/glload/_int_gl_1_1_rem.h

+#ifndef OPENGL_GEN_CORE_REM1_1_H
+#define OPENGL_GEN_CORE_REM1_1_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif /*__cplusplus*/
+#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_ACCUM_BUFFER_BIT 0x00000200
+#define GL_VIEWPORT_BIT 0x00000800
+#define GL_TRANSFORM_BIT 0x00001000
+#define GL_ENABLE_BIT 0x00002000
+#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 0xFFFFFFFF
+#define GL_CLIENT_PIXEL_STORE_BIT 0x00000001
+#define GL_CLIENT_VERTEX_ARRAY_BIT 0x00000002
+#define GL_CLIENT_ALL_ATTRIB_BITS 0xFFFFFFFF
+#define GL_QUAD_STRIP 0x0008
+#define GL_POLYGON 0x0009
+#define GL_ACCUM 0x0100
+#define GL_LOAD 0x0101
+#define GL_RETURN 0x0102
+#define GL_MULT 0x0103
+#define GL_ADD 0x0104
+#define GL_AUX0 0x0409
+#define GL_AUX1 0x040A
+#define GL_AUX2 0x040B
+#define GL_AUX3 0x040C
+#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_PASS_THROUGH_TOKEN 0x0700
+#define GL_POINT_TOKEN 0x0701
+#define GL_LINE_TOKEN 0x0702
+#define GL_POLYGON_TOKEN 0x0703
+#define GL_BITMAP_TOKEN 0x0704
+#define GL_DRAW_PIXEL_TOKEN 0x0705
+#define GL_COPY_PIXEL_TOKEN 0x0706
+#define GL_LINE_RESET_TOKEN 0x0707
+#define GL_EXP 0x0800
+#define GL_EXP2 0x0801
+#define GL_COEFF 0x0A00
+#define GL_ORDER 0x0A01
+#define GL_DOMAIN 0x0A02
+#define GL_PIXEL_MAP_I_TO_I 0x0C70
+#define GL_PIXEL_MAP_S_TO_S 0x0C71
+#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_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_FEEDBACK_BUFFER_POINTER 0x0DF0
+#define GL_SELECTION_BUFFER_POINTER 0x0DF3
+#define GL_CURRENT_COLOR 0x0B00
+#define GL_CURRENT_INDEX 0x0B01
+#define GL_CURRENT_NORMAL 0x0B02
+#define GL_CURRENT_TEXTURE_COORDS 0x0B03
+#define GL_CURRENT_RASTER_COLOR 0x0B04
+#define GL_CURRENT_RASTER_INDEX 0x0B05
+#define GL_CURRENT_RASTER_TEXTURE_COORDS 0x0B06
+#define GL_CURRENT_RASTER_POSITION 0x0B07
+#define GL_CURRENT_RASTER_POSITION_VALID 0x0B08
+#define GL_CURRENT_RASTER_DISTANCE 0x0B09
+#define GL_POINT_SMOOTH 0x0B10
+#define GL_LINE_STIPPLE 0x0B24
+#define GL_LINE_STIPPLE_PATTERN 0x0B25
+#define GL_LINE_STIPPLE_REPEAT 0x0B26
+#define GL_LIST_MODE 0x0B30
+#define GL_MAX_LIST_NESTING 0x0B31
+#define GL_LIST_BASE 0x0B32
+#define GL_LIST_INDEX 0x0B33
+#define GL_POLYGON_STIPPLE 0x0B42
+#define GL_EDGE_FLAG 0x0B43
+#define GL_LIGHTING 0x0B50
+#define GL_LIGHT_MODEL_LOCAL_VIEWER 0x0B51
+#define GL_LIGHT_MODEL_TWO_SIDE 0x0B52
+#define GL_LIGHT_MODEL_AMBIENT 0x0B53
+#define GL_SHADE_MODEL 0x0B54
+#define GL_COLOR_MATERIAL_FACE 0x0B55
+#define GL_COLOR_MATERIAL_PARAMETER 0x0B56
+#define GL_COLOR_MATERIAL 0x0B57
+#define GL_FOG_INDEX 0x0B61
+#define GL_FOG_DENSITY 0x0B62
+#define GL_FOG_START 0x0B63
+#define GL_FOG_END 0x0B64
+#define GL_FOG_MODE 0x0B65
+#define GL_FOG_COLOR 0x0B66
+#define GL_ACCUM_CLEAR_VALUE 0x0B80
+#define GL_MATRIX_MODE 0x0BA0
+#define GL_NORMALIZE 0x0BA1
+#define GL_MODELVIEW_STACK_DEPTH 0x0BA3
+#define GL_PROJECTION_STACK_DEPTH 0x0BA4
+#define GL_TEXTURE_STACK_DEPTH 0x0BA5
+#define GL_MODELVIEW_MATRIX 0x0BA6
+#define GL_PROJECTION_MATRIX 0x0BA7
+#define GL_TEXTURE_MATRIX 0x0BA8
+#define GL_ATTRIB_STACK_DEPTH 0x0BB0
+#define GL_CLIENT_ATTRIB_STACK_DEPTH 0x0BB1
+#define GL_ALPHA_TEST 0x0BC0
+#define GL_ALPHA_TEST_FUNC 0x0BC1
+#define GL_ALPHA_TEST_REF 0x0BC2
+#define GL_INDEX_LOGIC_OP 0x0BF1
+#define GL_LOGIC_OP 0x0BF1
+#define GL_AUX_BUFFERS 0x0C00
+#define GL_INDEX_CLEAR_VALUE 0x0C20
+#define GL_INDEX_WRITEMASK 0x0C21
+#define GL_INDEX_MODE 0x0C30
+#define GL_RGBA_MODE 0x0C31
+#define GL_RENDER_MODE 0x0C40
+#define GL_PERSPECTIVE_CORRECTION_HINT 0x0C50
+#define GL_POINT_SMOOTH_HINT 0x0C51
+#define GL_FOG_HINT 0x0C54
+#define GL_TEXTURE_GEN_S 0x0C60
+#define GL_TEXTURE_GEN_T 0x0C61
+#define GL_TEXTURE_GEN_R 0x0C62
+#define GL_TEXTURE_GEN_Q 0x0C63
+#define GL_PIXEL_MAP_I_TO_I_SIZE 0x0CB0
+#define GL_PIXEL_MAP_S_TO_S_SIZE 0x0CB1
+#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_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_ZOOM_X 0x0D16
+#define GL_ZOOM_Y 0x0D17
+#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_MAX_EVAL_ORDER 0x0D30
+#define GL_MAX_LIGHTS 0x0D31
+#define GL_MAX_CLIP_PLANES 0x0D32
+#define GL_MAX_PIXEL_MAP_TABLE 0x0D34
+#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_CLIENT_ATTRIB_STACK_DEPTH 0x0D3B
+#define GL_INDEX_BITS 0x0D51
+#define GL_RED_BITS 0x0D52
+#define GL_GREEN_BITS 0x0D53
+#define GL_BLUE_BITS 0x0D54
+#define GL_ALPHA_BITS 0x0D55
+#define GL_DEPTH_BITS 0x0D56
+#define GL_STENCIL_BITS 0x0D57
+#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_NAME_STACK_DEPTH 0x0D70
+#define GL_AUTO_NORMAL 0x0D80
+#define GL_MAP1_COLOR_4 0x0D90
+#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_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_MAP1_GRID_DOMAIN 0x0DD0
+#define GL_MAP1_GRID_SEGMENTS 0x0DD1
+#define GL_MAP2_GRID_DOMAIN 0x0DD2
+#define GL_MAP2_GRID_SEGMENTS 0x0DD3
+#define GL_FEEDBACK_BUFFER_SIZE 0x0DF1
+#define GL_FEEDBACK_BUFFER_TYPE 0x0DF2
+#define GL_SELECTION_BUFFER_SIZE 0x0DF4
+#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_TEXTURE_COMPONENTS 0x1003
+#define GL_TEXTURE_BORDER 0x1005
+#define GL_TEXTURE_LUMINANCE_SIZE 0x8060
+#define GL_TEXTURE_INTENSITY_SIZE 0x8061
+#define GL_TEXTURE_PRIORITY 0x8066
+#define GL_TEXTURE_RESIDENT 0x8067
+#define GL_AMBIENT 0x1200
+#define GL_DIFFUSE 0x1201
+#define GL_SPECULAR 0x1202
+#define GL_POSITION 0x1203
+#define GL_SPOT_DIRECTION 0x1204
+#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_COMPILE 0x1300
+#define GL_COMPILE_AND_EXECUTE 0x1301
+#define GL_2_BYTES 0x1407
+#define GL_3_BYTES 0x1408
+#define GL_4_BYTES 0x1409
+#define GL_EMISSION 0x1600
+#define GL_SHININESS 0x1601
+#define GL_AMBIENT_AND_DIFFUSE 0x1602
+#define GL_COLOR_INDEXES 0x1603
+#define GL_MODELVIEW 0x1700
+#define GL_PROJECTION 0x1701
+#define GL_COLOR_INDEX 0x1900
+#define GL_LUMINANCE 0x1909
+#define GL_LUMINANCE_ALPHA 0x190A
+#define GL_BITMAP 0x1A00
+#define GL_RENDER 0x1C00
+#define GL_FEEDBACK 0x1C01
+#define GL_SELECT 0x1C02
+#define GL_FLAT 0x1D00
+#define GL_SMOOTH 0x1D01
+#define GL_S 0x2000
+#define GL_T 0x2001
+#define GL_R 0x2002
+#define GL_Q 0x2003
+#define GL_MODULATE 0x2100
+#define GL_DECAL 0x2101
+#define GL_TEXTURE_ENV_MODE 0x2200
+#define GL_TEXTURE_ENV_COLOR 0x2201
+#define GL_TEXTURE_ENV 0x2300
+#define GL_EYE_LINEAR 0x2400
+#define GL_OBJECT_LINEAR 0x2401
+#define GL_SPHERE_MAP 0x2402
+#define GL_TEXTURE_GEN_MODE 0x2500
+#define GL_OBJECT_PLANE 0x2501
+#define GL_CLAMP 0x2900
+#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_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
+#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
+#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
+
+typedef void (CODEGEN_FUNCPTR * PFNGLNEWLISTPROC)(GLuint , GLenum );
+typedef void (CODEGEN_FUNCPTR * PFNGLENDLISTPROC)();
+typedef void (CODEGEN_FUNCPTR * PFNGLCALLLISTPROC)(GLuint );
+typedef void (CODEGEN_FUNCPTR * PFNGLCALLLISTSPROC)(GLsizei , GLenum , const GLvoid *);
+typedef void (CODEGEN_FUNCPTR * PFNGLDELETELISTSPROC)(GLuint , GLsizei );
+typedef GLuint (CODEGEN_FUNCPTR * PFNGLGENLISTSPROC)(GLsizei );
+typedef void (CODEGEN_FUNCPTR * PFNGLLISTBASEPROC)(GLuint );
+typedef void (CODEGEN_FUNCPTR * PFNGLBEGINPROC)(GLenum );
+typedef void (CODEGEN_FUNCPTR * PFNGLBITMAPPROC)(GLsizei , GLsizei , GLfloat , GLfloat , GLfloat , GLfloat , const GLubyte *);
+typedef void (CODEGEN_FUNCPTR * PFNGLCOLOR3BPROC)(GLbyte , GLbyte , GLbyte );
+typedef void (CODEGEN_FUNCPTR * PFNGLCOLOR3BVPROC)(const GLbyte *);
+typedef void (CODEGEN_FUNCPTR * PFNGLCOLOR3DPROC)(GLdouble , GLdouble , GLdouble );
+typedef void (CODEGEN_FUNCPTR * PFNGLCOLOR3DVPROC)(const GLdouble *);
+typedef void (CODEGEN_FUNCPTR * PFNGLCOLOR3FPROC)(GLfloat , GLfloat , GLfloat );
+typedef void (CODEGEN_FUNCPTR * PFNGLCOLOR3FVPROC)(const GLfloat *);
+typedef void (CODEGEN_FUNCPTR * PFNGLCOLOR3IPROC)(GLint , GLint , GLint );
+typedef void (CODEGEN_FUNCPTR * PFNGLCOLOR3IVPROC)(const GLint *);
+typedef void (CODEGEN_FUNCPTR * PFNGLCOLOR3SPROC)(GLshort , GLshort , GLshort );
+typedef void (CODEGEN_FUNCPTR * PFNGLCOLOR3SVPROC)(const GLshort *);
+typedef void (CODEGEN_FUNCPTR * PFNGLCOLOR3UBPROC)(GLubyte , GLubyte , GLubyte );
+typedef void (CODEGEN_FUNCPTR * PFNGLCOLOR3UBVPROC)(const GLubyte *);
+typedef void (CODEGEN_FUNCPTR * PFNGLCOLOR3UIPROC)(GLuint , GLuint , GLuint );
+typedef void (CODEGEN_FUNCPTR * PFNGLCOLOR3UIVPROC)(const GLuint *);
+typedef void (CODEGEN_FUNCPTR * PFNGLCOLOR3USPROC)(GLushort , GLushort , GLushort );
+typedef void (CODEGEN_FUNCPTR * PFNGLCOLOR3USVPROC)(const GLushort *);
+typedef void (CODEGEN_FUNCPTR * PFNGLCOLOR4BPROC)(GLbyte , GLbyte , GLbyte , GLbyte );
+typedef void (CODEGEN_FUNCPTR * PFNGLCOLOR4BVPROC)(const GLbyte *);
+typedef void (CODEGEN_FUNCPTR * PFNGLCOLOR4DPROC)(GLdouble , GLdouble , GLdouble , GLdouble );
+typedef void (CODEGEN_FUNCPTR * PFNGLCOLOR4DVPROC)(const GLdouble *);
+typedef void (CODEGEN_FUNCPTR * PFNGLCOLOR4FPROC)(GLfloat , GLfloat , GLfloat , GLfloat );
+typedef void (CODEGEN_FUNCPTR * PFNGLCOLOR4FVPROC)(const GLfloat *);
+typedef void (CODEGEN_FUNCPTR * PFNGLCOLOR4IPROC)(GLint , GLint , GLint , GLint );
+typedef void (CODEGEN_FUNCPTR * PFNGLCOLOR4IVPROC)(const GLint *);
+typedef void (CODEGEN_FUNCPTR * PFNGLCOLOR4SPROC)(GLshort , GLshort , GLshort , GLshort );
+typedef void (CODEGEN_FUNCPTR * PFNGLCOLOR4SVPROC)(const GLshort *);
+typedef void (CODEGEN_FUNCPTR * PFNGLCOLOR4UBPROC)(GLubyte , GLubyte , GLubyte , GLubyte );
+typedef void (CODEGEN_FUNCPTR * PFNGLCOLOR4UBVPROC)(const GLubyte *);
+typedef void (CODEGEN_FUNCPTR * PFNGLCOLOR4UIPROC)(GLuint , GLuint , GLuint , GLuint );
+typedef void (CODEGEN_FUNCPTR * PFNGLCOLOR4UIVPROC)(const GLuint *);
+typedef void (CODEGEN_FUNCPTR * PFNGLCOLOR4USPROC)(GLushort , GLushort , GLushort , GLushort );
+typedef void (CODEGEN_FUNCPTR * PFNGLCOLOR4USVPROC)(const GLushort *);
+typedef void (CODEGEN_FUNCPTR * PFNGLEDGEFLAGPROC)(GLboolean );
+typedef void (CODEGEN_FUNCPTR * PFNGLEDGEFLAGVPROC)(const GLboolean *);
+typedef void (CODEGEN_FUNCPTR * PFNGLENDPROC)();
+typedef void (CODEGEN_FUNCPTR * PFNGLINDEXDPROC)(GLdouble );
+typedef void (CODEGEN_FUNCPTR * PFNGLINDEXDVPROC)(const GLdouble *);
+typedef void (CODEGEN_FUNCPTR * PFNGLINDEXFPROC)(GLfloat );
+typedef void (CODEGEN_FUNCPTR * PFNGLINDEXFVPROC)(const GLfloat *);
+typedef void (CODEGEN_FUNCPTR * PFNGLINDEXIPROC)(GLint );
+typedef void (CODEGEN_FUNCPTR * PFNGLINDEXIVPROC)(const GLint *);
+typedef void (CODEGEN_FUNCPTR * PFNGLINDEXSPROC)(GLshort );
+typedef void (CODEGEN_FUNCPTR * PFNGLINDEXSVPROC)(const GLshort *);
+typedef void (CODEGEN_FUNCPTR * PFNGLNORMAL3BPROC)(GLbyte , GLbyte , GLbyte );
+typedef void (CODEGEN_FUNCPTR * PFNGLNORMAL3BVPROC)(const GLbyte *);
+typedef void (CODEGEN_FUNCPTR * PFNGLNORMAL3DPROC)(GLdouble , GLdouble , GLdouble );
+typedef void (CODEGEN_FUNCPTR * PFNGLNORMAL3DVPROC)(const GLdouble *);
+typedef void (CODEGEN_FUNCPTR * PFNGLNORMAL3FPROC)(GLfloat , GLfloat , GLfloat );
+typedef void (CODEGEN_FUNCPTR * PFNGLNORMAL3FVPROC)(const GLfloat *);
+typedef void (CODEGEN_FUNCPTR * PFNGLNORMAL3IPROC)(GLint , GLint , GLint );
+typedef void (CODEGEN_FUNCPTR * PFNGLNORMAL3IVPROC)(const GLint *);
+typedef void (CODEGEN_FUNCPTR * PFNGLNORMAL3SPROC)(GLshort , GLshort , GLshort );
+typedef void (CODEGEN_FUNCPTR * PFNGLNORMAL3SVPROC)(const GLshort *);
+typedef void (CODEGEN_FUNCPTR * PFNGLRASTERPOS2DPROC)(GLdouble , GLdouble );
+typedef void (CODEGEN_FUNCPTR * PFNGLRASTERPOS2DVPROC)(const GLdouble *);
+typedef void (CODEGEN_FUNCPTR * PFNGLRASTERPOS2FPROC)(GLfloat , GLfloat );
+typedef void (CODEGEN_FUNCPTR * PFNGLRASTERPOS2FVPROC)(const GLfloat *);
+typedef void (CODEGEN_FUNCPTR * PFNGLRASTERPOS2IPROC)(GLint , GLint );
+typedef void (CODEGEN_FUNCPTR * PFNGLRASTERPOS2IVPROC)(const GLint *);
+typedef void (CODEGEN_FUNCPTR * PFNGLRASTERPOS2SPROC)(GLshort , GLshort );
+typedef void (CODEGEN_FUNCPTR * PFNGLRASTERPOS2SVPROC)(const GLshort *);
+typedef void (CODEGEN_FUNCPTR * PFNGLRASTERPOS3DPROC)(GLdouble , GLdouble , GLdouble );
+typedef void (CODEGEN_FUNCPTR * PFNGLRASTERPOS3DVPROC)(const GLdouble *);
+typedef void (CODEGEN_FUNCPTR * PFNGLRASTERPOS3FPROC)(GLfloat , GLfloat , GLfloat );
+typedef void (CODEGEN_FUNCPTR * PFNGLRASTERPOS3FVPROC)(const GLfloat *);
+typedef void (CODEGEN_FUNCPTR * PFNGLRASTERPOS3IPROC)(GLint , GLint , GLint );
+typedef void (CODEGEN_FUNCPTR * PFNGLRASTERPOS3IVPROC)(const GLint *);
+typedef void (CODEGEN_FUNCPTR * PFNGLRASTERPOS3SPROC)(GLshort , GLshort , GLshort );
+typedef void (CODEGEN_FUNCPTR * PFNGLRASTERPOS3SVPROC)(const GLshort *);
+typedef void (CODEGEN_FUNCPTR * PFNGLRASTERPOS4DPROC)(GLdouble , GLdouble , GLdouble , GLdouble );
+typedef void (CODEGEN_FUNCPTR * PFNGLRASTERPOS4DVPROC)(const GLdouble *);
+typedef void (CODEGEN_FUNCPTR * PFNGLRASTERPOS4FPROC)(GLfloat , GLfloat , GLfloat , GLfloat );
+typedef void (CODEGEN_FUNCPTR * PFNGLRASTERPOS4FVPROC)(const GLfloat *);
+typedef void (CODEGEN_FUNCPTR * PFNGLRASTERPOS4IPROC)(GLint , GLint , GLint , GLint );
+typedef void (CODEGEN_FUNCPTR * PFNGLRASTERPOS4IVPROC)(const GLint *);
+typedef void (CODEGEN_FUNCPTR * PFNGLRASTERPOS4SPROC)(GLshort , GLshort , GLshort , GLshort );
+typedef void (CODEGEN_FUNCPTR * PFNGLRASTERPOS4SVPROC)(const GLshort *);
+typedef void (CODEGEN_FUNCPTR * PFNGLRECTDPROC)(GLdouble , GLdouble , GLdouble , GLdouble );
+typedef void (CODEGEN_FUNCPTR * PFNGLRECTDVPROC)(const GLdouble *, const GLdouble *);
+typedef void (CODEGEN_FUNCPTR * PFNGLRECTFPROC)(GLfloat , GLfloat , GLfloat , GLfloat );
+typedef void (CODEGEN_FUNCPTR * PFNGLRECTFVPROC)(const GLfloat *, const GLfloat *);
+typedef void (CODEGEN_FUNCPTR * PFNGLRECTIPROC)(GLint , GLint , GLint , GLint );
+typedef void (CODEGEN_FUNCPTR * PFNGLRECTIVPROC)(const GLint *, const GLint *);
+typedef void (CODEGEN_FUNCPTR * PFNGLRECTSPROC)(GLshort , GLshort , GLshort , GLshort );
+typedef void (CODEGEN_FUNCPTR * PFNGLRECTSVPROC)(const GLshort *, const GLshort *);
+typedef void (CODEGEN_FUNCPTR * PFNGLTEXCOORD1DPROC)(GLdouble );
+typedef void (CODEGEN_FUNCPTR * PFNGLTEXCOORD1DVPROC)(const GLdouble *);
+typedef void (CODEGEN_FUNCPTR * PFNGLTEXCOORD1FPROC)(GLfloat );
+typedef void (CODEGEN_FUNCPTR * PFNGLTEXCOORD1FVPROC)(const GLfloat *);
+typedef void (CODEGEN_FUNCPTR * PFNGLTEXCOORD1IPROC)(GLint );
+typedef void (CODEGEN_FUNCPTR * PFNGLTEXCOORD1IVPROC)(const GLint *);
+typedef void (CODEGEN_FUNCPTR * PFNGLTEXCOORD1SPROC)(GLshort );
+typedef void (CODEGEN_FUNCPTR * PFNGLTEXCOORD1SVPROC)(const GLshort *);
+typedef void (CODEGEN_FUNCPTR * PFNGLTEXCOORD2DPROC)(GLdouble , GLdouble );
+typedef void (CODEGEN_FUNCPTR * PFNGLTEXCOORD2DVPROC)(const GLdouble *);
+typedef void (CODEGEN_FUNCPTR * PFNGLTEXCOORD2FPROC)(GLfloat , GLfloat );
+typedef void (CODEGEN_FUNCPTR * PFNGLTEXCOORD2FVPROC)(const GLfloat *);
+typedef void (CODEGEN_FUNCPTR * PFNGLTEXCOORD2IPROC)(GLint , GLint );
+typedef void (CODEGEN_FUNCPTR * PFNGLTEXCOORD2IVPROC)(const GLint *);
+typedef void (CODEGEN_FUNCPTR * PFNGLTEXCOORD2SPROC)(GLshort , GLshort );
+typedef void (CODEGEN_FUNCPTR * PFNGLTEXCOORD2SVPROC)(const GLshort *);
+typedef void (CODEGEN_FUNCPTR * PFNGLTEXCOORD3DPROC)(GLdouble , GLdouble , GLdouble );
+typedef void (CODEGEN_FUNCPTR * PFNGLTEXCOORD3DVPROC)(const GLdouble *);
+typedef void (CODEGEN_FUNCPTR * PFNGLTEXCOORD3FPROC)(GLfloat , GLfloat , GLfloat );
+typedef void (CODEGEN_FUNCPTR * PFNGLTEXCOORD3FVPROC)(const GLfloat *);
+typedef void (CODEGEN_FUNCPTR * PFNGLTEXCOORD3IPROC)(GLint , GLint , GLint );
+typedef void (CODEGEN_FUNCPTR * PFNGLTEXCOORD3IVPROC)(const GLint *);
+typedef void (CODEGEN_FUNCPTR * PFNGLTEXCOORD3SPROC)(GLshort , GLshort , GLshort );
+typedef void (CODEGEN_FUNCPTR * PFNGLTEXCOORD3SVPROC)(const GLshort *);
+typedef void (CODEGEN_FUNCPTR * PFNGLTEXCOORD4DPROC)(GLdouble , GLdouble , GLdouble , GLdouble );
+typedef void (CODEGEN_FUNCPTR * PFNGLTEXCOORD4DVPROC)(const GLdouble *);
+typedef void (CODEGEN_FUNCPTR * PFNGLTEXCOORD4FPROC)(GLfloat , GLfloat , GLfloat , GLfloat );
+typedef void (CODEGEN_FUNCPTR * PFNGLTEXCOORD4FVPROC)(const GLfloat *);
+typedef void (CODEGEN_FUNCPTR * PFNGLTEXCOORD4IPROC)(GLint , GLint , GLint , GLint );
+typedef void (CODEGEN_FUNCPTR * PFNGLTEXCOORD4IVPROC)(const GLint *);
+typedef void (CODEGEN_FUNCPTR * PFNGLTEXCOORD4SPROC)(GLshort , GLshort , GLshort , GLshort );
+typedef void (CODEGEN_FUNCPTR * PFNGLTEXCOORD4SVPROC)(const GLshort *);
+typedef void (CODEGEN_FUNCPTR * PFNGLVERTEX2DPROC)(GLdouble , GLdouble );
+typedef void (CODEGEN_FUNCPTR * PFNGLVERTEX2DVPROC)(const GLdouble *);
+typedef void (CODEGEN_FUNCPTR * PFNGLVERTEX2FPROC)(GLfloat , GLfloat );
+typedef void (CODEGEN_FUNCPTR * PFNGLVERTEX2FVPROC)(const GLfloat *);
+typedef void (CODEGEN_FUNCPTR * PFNGLVERTEX2IPROC)(GLint , GLint );
+typedef void (CODEGEN_FUNCPTR * PFNGLVERTEX2IVPROC)(const GLint *);
+typedef void (CODEGEN_FUNCPTR * PFNGLVERTEX2SPROC)(GLshort , GLshort );
+typedef void (CODEGEN_FUNCPTR * PFNGLVERTEX2SVPROC)(const GLshort *);
+typedef void (CODEGEN_FUNCPTR * PFNGLVERTEX3DPROC)(GLdouble , GLdouble , GLdouble );
+typedef void (CODEGEN_FUNCPTR * PFNGLVERTEX3DVPROC)(const GLdouble *);
+typedef void (C