Jason McKesson avatar Jason McKesson committed 7a93a75

glsdk now works with the new GL Load.
From 69e63484133c

Comments (0)

Files changed (30)

examples/font_test/font_test.cpp

 		"}\n"
 		);
 
-	GLuint vertShader = glutil::CompileShader(gl::GL_VERTEX_SHADER, vertexShader);
-	GLuint fragShader = glutil::CompileShader(gl::GL_FRAGMENT_SHADER, fragmentShader);
+	GLuint vertShader = glutil::CompileShader(gl::VERTEX_SHADER, vertexShader);
+	GLuint fragShader = glutil::CompileShader(gl::FRAGMENT_SHADER, fragmentShader);
 
 	g_program = glutil::LinkProgram(vertShader, fragShader);
 
 
 	gl::GenBuffers(1, &g_dataBufferObject);
 
-	gl::BindBuffer(gl::GL_ARRAY_BUFFER, g_dataBufferObject);
-	gl::BufferData(gl::GL_ARRAY_BUFFER, sizeof(GLfloat) * vecVertex.size(), &vecVertex[0], gl::GL_STATIC_DRAW);
+	gl::BindBuffer(gl::ARRAY_BUFFER, g_dataBufferObject);
+	gl::BufferData(gl::ARRAY_BUFFER, sizeof(GLfloat) * vecVertex.size(), &vecVertex[0], gl::STATIC_DRAW);
 
 	gl::GenVertexArrays(1, &g_vao);
 
 	gl::BindVertexArray(g_vao);
-	gl::BindBuffer(gl::GL_ARRAY_BUFFER, g_dataBufferObject);
+	gl::BindBuffer(gl::ARRAY_BUFFER, g_dataBufferObject);
 	gl::EnableVertexAttribArray(0);
-	gl::VertexAttribPointer(0, 2, gl::GL_FLOAT, gl::GL_FALSE, 4 * sizeof(GLfloat), (void*)0);
+	gl::VertexAttribPointer(0, 2, gl::FLOAT, gl::FALSE_, 4 * sizeof(GLfloat), (void*)0);
 	gl::EnableVertexAttribArray(1);
-	gl::VertexAttribPointer(1, 2, gl::GL_FLOAT, gl::GL_FALSE, 4 * sizeof(GLfloat), (void*)(2 * sizeof(GLfloat)));
+	gl::VertexAttribPointer(1, 2, gl::FLOAT, gl::FALSE_, 4 * sizeof(GLfloat), (void*)(2 * sizeof(GLfloat)));
 
 	gl::BindVertexArray(0);
-	gl::BindBuffer(gl::GL_ARRAY_BUFFER, 0);
+	gl::BindBuffer(gl::ARRAY_BUFFER, 0);
 }
 
 //Called after the window and OpenGL are initialized. Called exactly once, before the main loop.
 	std::vector<glutil::GlyphQuad> glyphs = g_pFont->LayoutLine(text.c_str(), text.size(),
 		location, glutil::REF_BOTTOM);
 
-	glmesh::Draw imm(gl::GL_TRIANGLES, glyphs.size() * 6, *g_pVertFmt, *g_pStreamBuf);
+	glmesh::Draw imm(gl::TRIANGLES, glyphs.size() * 6, *g_pVertFmt, *g_pStreamBuf);
 
 	for(size_t loop = 0; loop < glyphs.size(); ++loop)
 	{
 void display()
 {
 	gl::ClearColor(0.0f, 0.0f, 0.0f, 1.0f);
-	gl::Clear(gl::GL_COLOR_BUFFER_BIT);
+	gl::Clear(gl::COLOR_BUFFER_BIT);
 
-	gl::Enable(gl::GL_BLEND);
-	gl::BlendEquation(gl::GL_FUNC_ADD);
-	gl::BlendFunc(gl::GL_ONE, gl::GL_ONE_MINUS_SRC_ALPHA);
+	gl::Enable(gl::BLEND);
+	gl::BlendEquation(gl::FUNC_ADD);
+	gl::BlendFunc(gl::ONE, gl::ONE_MINUS_SRC_ALPHA);
 
 	gl::UseProgram(g_program);
-	gl::ActiveTexture(gl::GL_TEXTURE0);
-	gl::BindTexture(gl::GL_TEXTURE_2D, g_pFont->GetTexture());
+	gl::ActiveTexture(gl::TEXTURE0);
+	gl::BindTexture(gl::TEXTURE_2D, g_pFont->GetTexture());
 
 	glutil::MatrixStack persMatrix;
 	persMatrix.PixelPerfectOrtho(g_windowSize, glm::vec2(-1.0f, 1.0f), false);
 
-	gl::UniformMatrix4fv(g_cameraToClipMatrixUnif, 1, gl::GL_FALSE, glm::value_ptr(persMatrix.Top()));
+	gl::UniformMatrix4fv(g_cameraToClipMatrixUnif, 1, gl::FALSE_, glm::value_ptr(persMatrix.Top()));
 
 	glm::vec2 currPt(50.0f, 5.0f);
 	if(!g_currString.empty())
 
 /*
 	gl::BindVertexArray(g_vao);
-	gl::DrawArrays(gl::GL_TRIANGLES, 0, 6 * g_numGlyphsToDraw);
+	gl::DrawArrays(gl::TRIANGLES, 0, 6 * g_numGlyphsToDraw);
 	gl::BindVertexArray(0);
 */
 
-	gl::BindTexture(gl::GL_TEXTURE_2D, 0);
+	gl::BindTexture(gl::TEXTURE_2D, 0);
 	gl::UseProgram(0);
 
 	glfwSwapBuffers();
 	delete g_pStreamBuf;
 	g_pStreamBuf = NULL;
 
-	return gl::GL_TRUE;
+	return gl::TRUE_;
 }
 
 void GLFWCALL CharFunc(int unicodepoint, int action)
 	glfwOpenWindowHint(GLFW_OPENGL_VERSION_MINOR, 3);
 	glfwOpenWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
 #ifdef DEBUG
-	glfwOpenWindowHint(GLFW_OPENGL_DEBUG_CONTEXT, gl::GL_TRUE);
+	glfwOpenWindowHint(GLFW_OPENGL_DEBUG_CONTEXT, gl::TRUE_);
 #endif
 
 	if(!glfwOpenWindow(g_windowSize.x, g_windowSize.y, 8, 8, 8, 8, 24, 8, GLFW_WINDOW))
 
 	glfwSetWindowPos(wndPos.x, wndPos.y);
 
-	if(glload::LoadFunctions() == glload::LS_LOAD_FAILED)
+	if(!glload::LoadFunctions())
 	{
 		glfwTerminate();
 		return -1;

examples/simple_glfw/simple_glfw.cpp

 		return -1;
 	}
 
-	if(glload::LoadFunctions() == glload::LS_LOAD_FAILED)
+	if(!glload::LoadFunctions())
 	{
 		glfwTerminate();
 		return -1;

glimg/Test/main.cpp

 	}
 }
 
-void GLE_FUNCPTR DebugFunc(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length,
+void CODEGEN_FUNCPTR DebugFunc(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length,
 						const GLchar* message, GLvoid* userParam)
 {
 	std::string srcName;

glimg/source/TextureGenerator.cpp

 
 #include <assert.h>
 #include <glload/gl_all.hpp>
-#include <glload/gll.hpp>
+#include <glload/gl_load.hpp>
 #include "glimg/TextureGeneratorExceptions.h"
 #include "glimg/TextureGenerator.h"
 #include "ImageSetImpl.h"
 	{
 		void ThrowIfS3TCNotSupported()
 		{
-			if(!glext_EXT_texture_compression_s3tc)
+			if(!gl::exts::var_EXT_texture_compression_s3tc)
 				throw ImageFormatUnsupportedException("S3TC not supported.");
 		}
 
 		void ThrowIfLATCNotSupported()
 		{
-			if(!glext_EXT_texture_compression_latc)
+			if(!gl::exts::var_EXT_texture_compression_latc)
 				throw ImageFormatUnsupportedException("LATC not supported.");
 		}
 
 		{
 			if(!glload::IsVersionGEQ(3, 0))
 			{
-				if(!(glext_ARB_texture_compression_rgtc || glext_EXT_texture_compression_rgtc))
+				if(!(gl::exts::var_ARB_texture_compression_rgtc || gl::exts::var_EXT_texture_compression_rgtc))
 					throw ImageFormatUnsupportedException("RGTC, part of GL 3.0 and above, is not supported.");
 			}
 		}
 
 		void ThrowIfBPTCNotSupported()
 		{
-			if(!glext_ARB_texture_compression_bptc)
+			if(!gl::exts::var_ARB_texture_compression_bptc)
 				throw ImageFormatUnsupportedException("PBTC not supported.");
 		}
 
 		{
 			if(!glload::IsVersionGEQ(2, 1))
 			{
-				if(!glext_EXT_texture_sRGB)
+				if(!gl::exts::var_EXT_texture_sRGB)
 					throw ImageFormatUnsupportedException("sRGB textures not supported.");
 			}
 		}
 
 		void ThrowIfEXT_SRGBNotSupported()
 		{
-				if(!glext_EXT_texture_sRGB)
+				if(!gl::exts::var_EXT_texture_sRGB)
 					throw ImageFormatUnsupportedException("sRGB and S3TC textures not supported.");
 		}
 
 		{
 			if(!glload::IsVersionGEQ(3, 0))
 			{
-				if(!glext_EXT_texture_shared_exponent)
+				if(!gl::exts::var_EXT_texture_shared_exponent)
 					throw ImageFormatUnsupportedException("Shared exponent texture format not supported.");
 			}
 		}
 		{
 			if(!glload::IsVersionGEQ(3, 0))
 			{
-				if(!glext_ARB_texture_float)
+				if(!gl::exts::var_ARB_texture_float)
 					throw ImageFormatUnsupportedException("Float textures not supported.");
 			}
 		}
 
 		void ThrowIfEXT_FloatNotSupported()
 		{
-			if(!glext_ARB_texture_float)
+			if(!gl::exts::var_ARB_texture_float)
 				throw ImageFormatUnsupportedException("ARB Float textures not supported.");
 		}
 
 		{
 			if(!glload::IsVersionGEQ(3, 0))
 			{
-				if(!glext_ARB_half_float_pixel)
+				if(!gl::exts::var_ARB_half_float_pixel)
 					throw ImageFormatUnsupportedException("Half floats textures not supported.");
 			}
 		}
 		{
 			if(!glload::IsVersionGEQ(3, 1))
 			{
-				if(!glext_EXT_texture_snorm)
+				if(!gl::exts::var_EXT_texture_snorm)
 					throw ImageFormatUnsupportedException("Signed normalized textures not supported.");
 			}
 		}
 
 		void ThrowIfEXT_SnormNotSupported()
 		{
-			if(!glext_EXT_texture_snorm)
+			if(!gl::exts::var_EXT_texture_snorm)
 				throw ImageFormatUnsupportedException("Signed normalized texture extension not supported.");
 		}
 
 		{
 			if(!glload::IsVersionGEQ(3, 0))
 			{
-				if(!glext_EXT_packed_float)
+				if(!gl::exts::var_EXT_packed_float)
 					throw ImageFormatUnsupportedException("Packed 11, 11, 10 float textures not supported.");
 			}
 		}
 		{
 			if(!glload::IsVersionGEQ(3, 0))
 			{
-				if(!glext_EXT_texture_integer)
+				if(!gl::exts::var_EXT_texture_integer)
 					throw ImageFormatUnsupportedException("Integral textures not supported.");
 			}
 		}
 
 		void ThrowIfEXT_IntegralNotSupported()
 		{
-			if(!glext_EXT_texture_integer)
+			if(!gl::exts::var_EXT_texture_integer)
 				throw ImageFormatUnsupportedException("Integral texture extension not supported.");
 		}
 
 		{
 			if(!glload::IsVersionGEQ(3, 0))
 			{
-				if(!glext_ARB_texture_rg)
+				if(!gl::exts::var_ARB_texture_rg)
 					throw ImageFormatUnsupportedException("RG textures not supported.");
 			}
 		}
 				return;
 			if(!glload::IsVersionGEQ(3,2))
 			{
-				if(!glext_ARB_compatibility)
+				if(!gl::exts::var_ARB_compatibility)
 					throw ImageFormatUnsupportedException("Core OpenGL contexts cannot use Luminance/alpha.");
 			}
 			else
 			{
 				GLint profileMask = 0;
-				gl::GetIntegerv(gl::GL_CONTEXT_PROFILE_MASK, &profileMask);
-				if(profileMask & gl::GL_CONTEXT_CORE_PROFILE_BIT)
+				gl::GetIntegerv(gl::CONTEXT_PROFILE_MASK, &profileMask);
+				if(profileMask & gl::CONTEXT_CORE_PROFILE_BIT)
 					throw ImageFormatUnsupportedException("Core OpenGL contexts cannot use Luminance/alpha.");
 			}
 		}
 		{
 			if(!glload::IsVersionGEQ(1, 4)) //Yes, really. Depth textures are old.
 			{
-				if(!glext_ARB_depth_texture)
+				if(!gl::exts::var_ARB_depth_texture)
 					throw ImageFormatUnsupportedException("Depth textures not supported.");
 			}
 		}
 		{
 			if(!glload::IsVersionGEQ(3, 0))
 			{
-				if(!(glext_EXT_packed_depth_stencil || glext_ARB_framebuffer_object))
+				if(!(gl::exts::var_EXT_packed_depth_stencil || gl::exts::var_ARB_framebuffer_object))
 					throw ImageFormatUnsupportedException("Depth/stencil textures not supported.");
 			}
 		}
 		{
 			if(!glload::IsVersionGEQ(3, 0))
 			{
-				if(!glext_NV_depth_buffer_float)
+				if(!gl::exts::var_NV_depth_buffer_float)
 					throw ImageFormatUnsupportedException("Floating-point depth buffers not supported.");
 			}
 		}
 		//Ordered by BaseDataFormat*2. The first is 16-bit, the second is 32-bit.
 		GLenum g_floatFormats[] =
 		{
-			gl::GL_R16F,
-			gl::GL_R32F,
-			gl::GL_RG16F,
-			gl::GL_RG32F,
-			gl::GL_RGB16F,
-			gl::GL_RGB32F,
-			gl::GL_RGB16F,
-			gl::GL_RGB32F,
-			gl::GL_RGBA16F,
-			gl::GL_RGBA32F,
+			gl::R16F,
+			gl::R32F,
+			gl::RG16F,
+			gl::RG32F,
+			gl::RGB16F,
+			gl::RGB32F,
+			gl::RGB16F,
+			gl::RGB32F,
+			gl::RGBA16F,
+			gl::RGBA32F,
 			0,			//sRGB
 			0,			//sRGB
 			0,			//sRGB
 			0,			//sRGB
 			0,			//sRGB
 			0,			//16-bit float depth buffer. 
-			gl::GL_DEPTH_COMPONENT32F,
+			gl::DEPTH_COMPONENT32F,
 			0,			//UNorm+stencil.
 		};
 
 		//Ordered by number of components * size (8, 16, 32=>0, 1, 2).
 		GLenum g_signIntegralFormats[] =
 		{
-			gl::GL_R8I,			gl::GL_R16I,			gl::GL_R32I,
-			gl::GL_RG8I,		gl::GL_RG16I,			gl::GL_RG32I,
-			gl::GL_RGB8I,		gl::GL_RGB16I,			gl::GL_RGB32I,
-			gl::GL_RGBA8I,		gl::GL_RGBA16I,			gl::GL_RGBA32I,
+			gl::R8I,			gl::R16I,			gl::R32I,
+			gl::RG8I,		gl::RG16I,			gl::RG32I,
+			gl::RGB8I,		gl::RGB16I,			gl::RGB32I,
+			gl::RGBA8I,		gl::RGBA16I,			gl::RGBA32I,
 		};
 
 		//Ordered by number of components * size (8, 16, 32=>0, 1, 2).
 		GLenum g_unsignIntegralFormats[] =
 		{
-			gl::GL_R8UI,		gl::GL_R16UI,			gl::GL_R32UI,
-			gl::GL_RG8UI,		gl::GL_RG16UI,			gl::GL_RG32UI,
-			gl::GL_RGB8UI,		gl::GL_RGB16UI,			gl::GL_RGB32UI,
-			gl::GL_RGBA8UI,		gl::GL_RGBA16UI,		gl::GL_RGBA32UI,
+			gl::R8UI,		gl::R16UI,			gl::R32UI,
+			gl::RG8UI,		gl::RG16UI,			gl::RG32UI,
+			gl::RGB8UI,		gl::RGB16UI,			gl::RGB32UI,
+			gl::RGBA8UI,		gl::RGBA16UI,		gl::RGBA32UI,
 		};
 
 		//Ordered by number of components * size (8, 16=>0, 1, 2).
 		GLenum g_signedNormFormats[] =
 		{
-			gl::GL_R8_SNORM,		gl::GL_R16_SNORM,
-			gl::GL_RG8_SNORM,		gl::GL_RG16_SNORM,
-			gl::GL_RGB8_SNORM,		gl::GL_RGB16_SNORM,
-			gl::GL_RGBA8_SNORM,		gl::GL_RGBA16_SNORM,
+			gl::R8_SNORM,		gl::R16_SNORM,
+			gl::RG8_SNORM,		gl::RG16_SNORM,
+			gl::RGB8_SNORM,		gl::RGB16_SNORM,
+			gl::RGBA8_SNORM,		gl::RGBA16_SNORM,
 		};
 
 		GLenum ThrowInvalidFormatIfZero(GLenum input)
 				if(format.Components() == FMT_DEPTH)
 				{
 					ThrowIfDepthNotSupported();
-					return gl::GL_DEPTH_COMPONENT16;
+					return gl::DEPTH_COMPONENT16;
 				}
 
 				//Only 24x8 for this.
 				if(format.Components() == FMT_DEPTH_X)
 				{
 					ThrowIfDepthStencilNotSupported();
-					return gl::GL_DEPTH24_STENCIL8;
+					return gl::DEPTH24_STENCIL8;
 				}
 
 				//Color formats.
 				{
 					ThrowIfSRGBNotSupported();
 					if(ComponentCount(format, forceConvertBits) == 3)
-						return gl::GL_SRGB8;
+						return gl::SRGB8;
 					else
-						return gl::GL_SRGB8_ALPHA8;
+						return gl::SRGB8_ALPHA8;
 				}
 
 				switch(format.Depth())
 				{
 				case BD_PER_COMP_8:
 					{
-						GLenum components[] = {gl::GL_R8, gl::GL_RG8, gl::GL_RGB8, gl::GL_RGBA8};
+						GLenum components[] = {gl::R8, gl::RG8, gl::RGB8, gl::RGBA8};
 						int numComponents = ComponentCount(format, forceConvertBits);
 
 						return components[numComponents - 1];
 					}
 				case BD_PER_COMP_16:
 					{
-						GLenum components[] = {gl::GL_R16, gl::GL_RG16, gl::GL_RGB16, gl::GL_RGBA16};
+						GLenum components[] = {gl::R16, gl::RG16, gl::RGB16, gl::RGBA16};
 						int numComponents = ComponentCount(format, forceConvertBits);
 
 						return components[numComponents - 1];
 
 				case BD_PACKED_16_BIT_565:
 				case BD_PACKED_16_BIT_565_REV:
-					return gl::GL_RGB8;
+					return gl::RGB8;
 
 				case BD_PACKED_16_BIT_5551:
 				case BD_PACKED_16_BIT_1555_REV:
-					return gl::GL_RGB5_A1;
+					return gl::RGB5_A1;
 
 				case BD_PACKED_16_BIT_4444:
 				case BD_PACKED_16_BIT_4444_REV:
-					return gl::GL_RGBA4;
+					return gl::RGBA4;
 
 				case BD_PACKED_32_BIT_8888:
 				case BD_PACKED_32_BIT_8888_REV:
-					return gl::GL_RGBA8;
+					return gl::RGBA8;
 
 				case BD_PACKED_32_BIT_1010102:
 				case BD_PACKED_32_BIT_2101010_REV:
-					return gl::GL_RGB10_A2;
+					return gl::RGB10_A2;
 				}
 
 				throw ImageFormatUnsupportedException("Unisgned normalize integer doesn't match accepted bitdepths.");
 				{
 					//Only one packed format.
 					ThrowIfPackedFloatNotSupported();
-					return gl::GL_R11F_G11F_B10F;
+					return gl::R11F_G11F_B10F;
 				}
 
 			case DT_SHARED_EXP_FLOAT:
 				ThrowIfSharedExpNotSupported();
 				ThrowIfForceRendertarget(forceConvertBits);
-				return gl::GL_RGB9_E5;
+				return gl::RGB9_E5;
 
 			case DT_COMPRESSED_BC1:
 				ThrowIfS3TCNotSupported();
 				{
 					ThrowIfEXT_SRGBNotSupported();
 					if(forceConvertBits & FORCE_BC1_ALPHA_FMT)
-						return gl::GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT;
+						return gl::COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT;
 					else
 					{
 						if(ComponentCount(format, forceConvertBits) == 3)
-							return gl::GL_COMPRESSED_SRGB_S3TC_DXT1_EXT;
+							return gl::COMPRESSED_SRGB_S3TC_DXT1_EXT;
 						else
-							return gl::GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT;
+							return gl::COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT;
 					}
 				}
 				else
 				{
 					if(forceConvertBits & FORCE_BC1_ALPHA_FMT)
-						return gl::GL_COMPRESSED_RGBA_S3TC_DXT1_EXT;
+						return gl::COMPRESSED_RGBA_S3TC_DXT1_EXT;
 					else
 					{
 						if(ComponentCount(format, forceConvertBits) == 3)
-							return gl::GL_COMPRESSED_RGB_S3TC_DXT1_EXT;
+							return gl::COMPRESSED_RGB_S3TC_DXT1_EXT;
 						else
-							return gl::GL_COMPRESSED_RGBA_S3TC_DXT1_EXT;
+							return gl::COMPRESSED_RGBA_S3TC_DXT1_EXT;
 					}
 				}
 
 				if(IsSRGBFormat(format, forceConvertBits))
 				{
 					ThrowIfEXT_SRGBNotSupported();
-					return gl::GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT;
+					return gl::COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT;
 				}
 				else
-					return gl::GL_COMPRESSED_RGBA_S3TC_DXT3_EXT;
+					return gl::COMPRESSED_RGBA_S3TC_DXT3_EXT;
 
 			case DT_COMPRESSED_BC3:
 				ThrowIfS3TCNotSupported();
 				if(IsSRGBFormat(format, forceConvertBits))
 				{
 					ThrowIfEXT_SRGBNotSupported();
-					return gl::GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT;
+					return gl::COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT;
 				}
 				else
-					return gl::GL_COMPRESSED_RGBA_S3TC_DXT5_EXT;
+					return gl::COMPRESSED_RGBA_S3TC_DXT5_EXT;
 
 			case DT_COMPRESSED_UNSIGNED_BC4:
-				return gl::GL_COMPRESSED_RED_RGTC1;
+				return gl::COMPRESSED_RED_RGTC1;
 			case DT_COMPRESSED_SIGNED_BC4:
-				return gl::GL_COMPRESSED_SIGNED_RED_RGTC1;
+				return gl::COMPRESSED_SIGNED_RED_RGTC1;
 
 			case DT_COMPRESSED_UNSIGNED_BC5:
-				return gl::GL_COMPRESSED_RG_RGTC2;
+				return gl::COMPRESSED_RG_RGTC2;
 			case DT_COMPRESSED_SIGNED_BC5:
-				return gl::GL_COMPRESSED_SIGNED_RG_RGTC2;
+				return gl::COMPRESSED_SIGNED_RG_RGTC2;
 
 			case DT_COMPRESSED_UNSIGNED_BC6H:
 				ThrowIfBPTCNotSupported();
-				return gl::GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_ARB;
+				return gl::COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_ARB;
 
 			case DT_COMPRESSED_SIGNED_BC6H:
 				ThrowIfBPTCNotSupported();
-				return gl::GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_ARB;
+				return gl::COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_ARB;
 
 			case DT_COMPRESSED_BC7:
 				ThrowIfBPTCNotSupported();
 				if(IsSRGBFormat(format, forceConvertBits))
-					return gl::GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_ARB;
+					return gl::COMPRESSED_SRGB_ALPHA_BPTC_UNORM_ARB;
 				else
-					return gl::GL_COMPRESSED_RGBA_BPTC_UNORM_ARB;
+					return gl::COMPRESSED_RGBA_BPTC_UNORM_ARB;
 			}
 
 			throw ImageFormatUnsupportedException("???");
 		break;
 
 
-#define ONE_COMP_RG(size, suffix) gl::GL_R ## size ## suffix
-#define TWO_COMP_RG(size, suffix) gl::GL_RG ## size ## suffix
-#define ONE_COMP_LA(size, suffix) gl::GL_LUMINANCE ## size ## suffix ## _EXT
-#define TWO_COMP_LA(size, suffix) gl::GL_LUMINANCE_ALPHA ## size ## suffix ## _EXT
-#define ONE_ARB_LA(size, suffix) gl::GL_LUMINANCE ## size ## suffix ## _ARB
-#define TWO_ARB_LA(size, suffix) gl::GL_LUMINANCE_ALPHA ## size ## suffix ## _ARB
-#define ONE_SNORM_LA(size, suffix) gl::GL_LUMINANCE ## size ## suffix
-#define TWO_SNORM_LA(size, suffix) gl::GL_LUMINANCE ## size ## _ALPHA ## size ## suffix
+#define ONE_COMP_RG(size, suffix) gl::R ## size ## suffix
+#define TWO_COMP_RG(size, suffix) gl::RG ## size ## suffix
+#define ONE_COMP_LA(size, suffix) gl::LUMINANCE ## size ## suffix ## _EXT
+#define TWO_COMP_LA(size, suffix) gl::LUMINANCE_ALPHA ## size ## suffix ## _EXT
+#define ONE_ARB_LA(size, suffix) gl::LUMINANCE ## size ## suffix ## _ARB
+#define TWO_ARB_LA(size, suffix) gl::LUMINANCE_ALPHA ## size ## suffix ## _ARB
+#define ONE_SNORM_LA(size, suffix) gl::LUMINANCE ## size ## suffix
+#define TWO_SNORM_LA(size, suffix) gl::LUMINANCE ## size ## _ALPHA ## size ## suffix
 
 	unsigned int GetOpenGLType( const ImageFormat &format, OpenGLPixelTransferParams &ret, PixelDataType eType, GLenum g_packedTypes );
 	unsigned int GetInternalFormat( const ImageFormat &format, unsigned int forceConvertBits )
 		//Convert any R or RG formats to L or LA formats.
 		switch(internalFormat)
 		{
-			LARG_COMPRESSED_CONV(gl::GL_COMPRESSED_RED_RGTC1, gl::GL_COMPRESSED_LUMINANCE_LATC1_EXT);
-			LARG_COMPRESSED_CONV(gl::GL_COMPRESSED_SIGNED_RED_RGTC1, gl::GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT);
-			LARG_COMPRESSED_CONV(gl::GL_COMPRESSED_RG_RGTC2, gl::GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT);
-			LARG_COMPRESSED_CONV(gl::GL_COMPRESSED_SIGNED_RG_RGTC2, gl::GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT);
+			LARG_COMPRESSED_CONV(gl::COMPRESSED_RED_RGTC1, gl::COMPRESSED_LUMINANCE_LATC1_EXT);
+			LARG_COMPRESSED_CONV(gl::COMPRESSED_SIGNED_RED_RGTC1, gl::COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT);
+			LARG_COMPRESSED_CONV(gl::COMPRESSED_RG_RGTC2, gl::COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT);
+			LARG_COMPRESSED_CONV(gl::COMPRESSED_SIGNED_RG_RGTC2, gl::COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT);
 
 			LARG_INTEGRAL_CONV(ONE_COMP_RG(8, I), ONE_COMP_LA(8, I));
 			LARG_INTEGRAL_CONV(ONE_COMP_RG(16, I), ONE_COMP_LA(16, I));
 			LARG_SNORM_CONV(TWO_COMP_RG(8, _SNORM), TWO_SNORM_LA(8, _SNORM));
 			LARG_SNORM_CONV(TWO_COMP_RG(16, _SNORM), TWO_SNORM_LA(16, _SNORM));
 
-			LARG_NORM_CONV(gl::GL_R8, gl::GL_LUMINANCE8);
-			LARG_NORM_CONV(gl::GL_R16, gl::GL_LUMINANCE16);
-			LARG_NORM_CONV(gl::GL_RG8, gl::GL_LUMINANCE8_ALPHA8);
-			LARG_NORM_CONV(gl::GL_RG16, gl::GL_LUMINANCE16_ALPHA16);
+			LARG_NORM_CONV(gl::R8, gl::LUMINANCE8);
+			LARG_NORM_CONV(gl::R16, gl::LUMINANCE16);
+			LARG_NORM_CONV(gl::RG8, gl::LUMINANCE8_ALPHA8);
+			LARG_NORM_CONV(gl::RG16, gl::LUMINANCE16_ALPHA16);
 		}
 
 		return internalFormat;
 
 		GLenum g_packedTypes[] =
 		{
-			gl::GL_UNSIGNED_SHORT_5_6_5,			//BD_PACKED_16_BIT_565
-			gl::GL_UNSIGNED_SHORT_5_5_5_1,			//BD_PACKED_16_BIT_5551
-			gl::GL_UNSIGNED_SHORT_4_4_4_4,			//BD_PACKED_16_BIT_4444
+			gl::UNSIGNED_SHORT_5_6_5,			//BD_PACKED_16_BIT_565
+			gl::UNSIGNED_SHORT_5_5_5_1,			//BD_PACKED_16_BIT_5551
+			gl::UNSIGNED_SHORT_4_4_4_4,			//BD_PACKED_16_BIT_4444
 
-			gl::GL_UNSIGNED_INT_8_8_8_8,			//BD_PACKED_32_BIT_8888
-			gl::GL_UNSIGNED_INT_10_10_10_2,			//BD_PACKED_32_BIT_1010102
-			gl::GL_UNSIGNED_INT_24_8,				//BD_PACKED_32_BIT_248
+			gl::UNSIGNED_INT_8_8_8_8,			//BD_PACKED_32_BIT_8888
+			gl::UNSIGNED_INT_10_10_10_2,			//BD_PACKED_32_BIT_1010102
+			gl::UNSIGNED_INT_24_8,				//BD_PACKED_32_BIT_248
 
-			gl::GL_UNSIGNED_SHORT_5_6_5_REV,		//BD_PACKED_16_BIT_565_REV
-			gl::GL_UNSIGNED_SHORT_1_5_5_5_REV,		//BD_PACKED_16_BIT_1555_REV
-			gl::GL_UNSIGNED_SHORT_4_4_4_4_REV,		//BD_PACKED_16_BIT_4444_REV
+			gl::UNSIGNED_SHORT_5_6_5_REV,		//BD_PACKED_16_BIT_565_REV
+			gl::UNSIGNED_SHORT_1_5_5_5_REV,		//BD_PACKED_16_BIT_1555_REV
+			gl::UNSIGNED_SHORT_4_4_4_4_REV,		//BD_PACKED_16_BIT_4444_REV
 
-			gl::GL_UNSIGNED_INT_8_8_8_8_REV,		//BD_PACKED_32_BIT_8888_REV
-			gl::GL_UNSIGNED_INT_2_10_10_10_REV,		//BD_PACKED_32_BIT_2101010_REV
-			gl::GL_UNSIGNED_INT_10F_11F_11F_REV,	//BD_PACKED_32_BIT_101111_REV
-			gl::GL_UNSIGNED_INT_5_9_9_9_REV,		//BD_PACKED_32_BIT_5999_REV
+			gl::UNSIGNED_INT_8_8_8_8_REV,		//BD_PACKED_32_BIT_8888_REV
+			gl::UNSIGNED_INT_2_10_10_10_REV,		//BD_PACKED_32_BIT_2101010_REV
+			gl::UNSIGNED_INT_10F_11F_11F_REV,	//BD_PACKED_32_BIT_101111_REV
+			gl::UNSIGNED_INT_5_9_9_9_REV,		//BD_PACKED_32_BIT_5999_REV
 		};
 
 		GLenum GetOpenGLType( const ImageFormat &format, PixelDataType eType, unsigned int forceConvertBits )
 				return 0xFFFFFFFF;
 			case BD_PER_COMP_8:
 				if(IsTypeSigned(eType))
-					return gl::GL_BYTE;
+					return gl::BYTE;
 				else
-					return gl::GL_UNSIGNED_BYTE;
+					return gl::UNSIGNED_BYTE;
 				break;
 			case BD_PER_COMP_16:
 				if(eType == DT_FLOAT)
 				{
 					ThrowIfHalfFloatNotSupported();
-					return gl::GL_HALF_FLOAT;
+					return gl::HALF_FLOAT;
 				}
 				else
 				{
 					if(IsTypeSigned(eType))
-						return gl::GL_SHORT;
+						return gl::SHORT;
 					else
-						return gl::GL_UNSIGNED_SHORT;
+						return gl::UNSIGNED_SHORT;
 				}
 				break;
 			case BD_PER_COMP_32:
 				if(eType == DT_FLOAT)
 				{
 					ThrowIfFloatNotSupported();
-					return gl::GL_FLOAT;
+					return gl::FLOAT;
 				}
 				else
 				{
 					if(IsTypeSigned(eType))
-						return gl::GL_INT;
+						return gl::INT;
 					else
-						return gl::GL_UNSIGNED_INT;
+						return gl::UNSIGNED_INT;
 				}
 				break;
 			default:
 					//Test for implemented features.
 					switch(testType)
 					{
-					case gl::GL_UNSIGNED_INT_10F_11F_11F_REV:
+					case gl::UNSIGNED_INT_10F_11F_11F_REV:
 						ThrowIfPackedFloatNotSupported();
 						break;
-					case gl::GL_UNSIGNED_INT_5_9_9_9_REV:
+					case gl::UNSIGNED_INT_5_9_9_9_REV:
 						ThrowIfSharedExpNotSupported();
 						break;
 					}
 		//Starts from FMT_COLOR_RGB. non-integral vs. integral.
 		GLenum g_bgraFormats[] =
 		{
-			gl::GL_BGR,			gl::GL_BGR_INTEGER,		//FMT_COLOR_RGB
-			gl::GL_BGRA,		gl::GL_BGRA_INTEGER,	//FMT_COLOR_RGBX
-			gl::GL_BGRA,		gl::GL_BGRA_INTEGER,	//FMT_COLOR_RGBA
-			gl::GL_BGR,			gl::GL_BGR_INTEGER,		//FMT_COLOR_RGB_sRGB
-			gl::GL_BGRA,		gl::GL_BGRA_INTEGER,	//FMT_COLOR_RGBX_sRGB
-			gl::GL_BGRA,		gl::GL_BGRA_INTEGER,	//FMT_COLOR_RGBA_sRGB
+			gl::BGR,			gl::BGR_INTEGER,		//FMT_COLOR_RGB
+			gl::BGRA,		gl::BGRA_INTEGER,	//FMT_COLOR_RGBX
+			gl::BGRA,		gl::BGRA_INTEGER,	//FMT_COLOR_RGBA
+			gl::BGR,			gl::BGR_INTEGER,		//FMT_COLOR_RGB_sRGB
+			gl::BGRA,		gl::BGRA_INTEGER,	//FMT_COLOR_RGBX_sRGB
+			gl::BGRA,		gl::BGRA_INTEGER,	//FMT_COLOR_RGBA_sRGB
 		};
 
 		//Non-integral vs. integral.
 		GLenum g_rgbaFormats[] =
 		{
-			gl::GL_RED,			gl::GL_RED_INTEGER,		//FMT_COLOR_RED
-			gl::GL_RG,			gl::GL_RG_INTEGER,		//FMT_COLOR_RG
-			gl::GL_RGB,			gl::GL_RGB_INTEGER,		//FMT_COLOR_RGB
-			gl::GL_RGBA,		gl::GL_RGBA_INTEGER,	//FMT_COLOR_RGBX
-			gl::GL_RGBA,		gl::GL_RGBA_INTEGER,	//FMT_COLOR_RGBA
-			gl::GL_RGB,			gl::GL_RGB_INTEGER,		//FMT_COLOR_RGB_sRGB
-			gl::GL_RGBA,		gl::GL_RGBA_INTEGER,	//FMT_COLOR_RGBX_sRGB
-			gl::GL_RGBA,		gl::GL_RGBA_INTEGER,	//FMT_COLOR_RGBA_sRGB
+			gl::RED,			gl::RED_INTEGER,		//FMT_COLOR_RED
+			gl::RG,			gl::RG_INTEGER,		//FMT_COLOR_RG
+			gl::RGB,			gl::RGB_INTEGER,		//FMT_COLOR_RGB
+			gl::RGBA,		gl::RGBA_INTEGER,	//FMT_COLOR_RGBX
+			gl::RGBA,		gl::RGBA_INTEGER,	//FMT_COLOR_RGBA
+			gl::RGB,			gl::RGB_INTEGER,		//FMT_COLOR_RGB_sRGB
+			gl::RGBA,		gl::RGBA_INTEGER,	//FMT_COLOR_RGBX_sRGB
+			gl::RGBA,		gl::RGBA_INTEGER,	//FMT_COLOR_RGBA_sRGB
 		};
 
 		//Non-integral vs. integral.
 		GLenum g_rgbaLuminanceFormats[] =
 		{
-			gl::GL_LUMINANCE,			gl::GL_LUMINANCE_INTEGER_EXT,				//FMT_COLOR_RED
-			gl::GL_LUMINANCE_ALPHA,		gl::GL_LUMINANCE_ALPHA_INTEGER_EXT,			//FMT_COLOR_RG
-			gl::GL_RGB,					gl::GL_RGB_INTEGER,		//FMT_COLOR_RGB
-			gl::GL_RGBA,				gl::GL_RGBA_INTEGER,	//FMT_COLOR_RGBX
-			gl::GL_RGBA,				gl::GL_RGBA_INTEGER,	//FMT_COLOR_RGBA
-			gl::GL_RGB,					gl::GL_RGB_INTEGER,		//FMT_COLOR_RGB_sRGB
-			gl::GL_RGBA,				gl::GL_RGBA_INTEGER,	//FMT_COLOR_RGBX_sRGB
-			gl::GL_RGBA,				gl::GL_RGBA_INTEGER,	//FMT_COLOR_RGBA_sRGB
+			gl::LUMINANCE,			gl::LUMINANCE_INTEGER_EXT,				//FMT_COLOR_RED
+			gl::LUMINANCE_ALPHA,		gl::LUMINANCE_ALPHA_INTEGER_EXT,			//FMT_COLOR_RG
+			gl::RGB,					gl::RGB_INTEGER,		//FMT_COLOR_RGB
+			gl::RGBA,				gl::RGBA_INTEGER,	//FMT_COLOR_RGBX
+			gl::RGBA,				gl::RGBA_INTEGER,	//FMT_COLOR_RGBA
+			gl::RGB,					gl::RGB_INTEGER,		//FMT_COLOR_RGB_sRGB
+			gl::RGBA,				gl::RGBA_INTEGER,	//FMT_COLOR_RGBX_sRGB
+			gl::RGBA,				gl::RGBA_INTEGER,	//FMT_COLOR_RGBA_sRGB
 		};
 
 		GLenum GetOpenGLFormat(const ImageFormat &format, PixelDataType eType, unsigned int forceConvertBits)
 			if(format.Components() == FMT_DEPTH)
 			{
 				ThrowIfDepthNotSupported();
-				return gl::GL_DEPTH_COMPONENT;
+				return gl::DEPTH_COMPONENT;
 			}
 
 			if(format.Components() == FMT_DEPTH_X)
 			{
 				ThrowIfDepthStencilNotSupported();
-				return gl::GL_DEPTH_STENCIL;
+				return gl::DEPTH_STENCIL;
 			}
 
 			if(IsTypeIntegral(eType))
 			}
 
 			//Provide reasonable parameters.
-			ret.format = gl::GL_RGBA;
+			ret.format = gl::RGBA;
 			if(eType != DT_COMPRESSED_UNSIGNED_BC6H || eType != DT_COMPRESSED_SIGNED_BC6H)
-				ret.type = gl::GL_FLOAT;
+				ret.type = gl::FLOAT;
 			else
-				ret.type = gl::GL_UNSIGNED_BYTE;
+				ret.type = gl::UNSIGNED_BYTE;
 			return ret;
 		}
 
 	{
 		void SetupUploadState(const ImageFormat &format, unsigned int forceConvertBits)
 		{
-			gl::PixelStorei(gl::GL_UNPACK_SWAP_BYTES, gl::GL_FALSE);
-			gl::PixelStorei(gl::GL_UNPACK_LSB_FIRST, gl::GL_FALSE);
-			gl::PixelStorei(gl::GL_UNPACK_ROW_LENGTH, 0);
-			gl::PixelStorei(gl::GL_UNPACK_SKIP_ROWS, 0);
-			gl::PixelStorei(gl::GL_UNPACK_SKIP_PIXELS, 0);
-			gl::PixelStorei(gl::GL_UNPACK_IMAGE_HEIGHT, 0);
-			gl::PixelStorei(gl::GL_UNPACK_SKIP_IMAGES, 0);
-			gl::PixelStorei(gl::GL_UNPACK_ALIGNMENT, format.LineAlign());
+			gl::PixelStorei(gl::UNPACK_SWAP_BYTES, gl::FALSE_);
+			gl::PixelStorei(gl::UNPACK_LSB_FIRST, gl::FALSE_);
+			gl::PixelStorei(gl::UNPACK_ROW_LENGTH, 0);
+			gl::PixelStorei(gl::UNPACK_SKIP_ROWS, 0);
+			gl::PixelStorei(gl::UNPACK_SKIP_PIXELS, 0);
+			gl::PixelStorei(gl::UNPACK_IMAGE_HEIGHT, 0);
+			gl::PixelStorei(gl::UNPACK_SKIP_IMAGES, 0);
+			gl::PixelStorei(gl::UNPACK_ALIGNMENT, format.LineAlign());
 		}
 
 		//Texture must be bound to the target.
 		void FinalizeTexture(GLenum texTarget, const detail::ImageSetImpl *pImage)
 		{
 			int numMipmaps = pImage->GetMipmapCount();
-			gl::TexParameteri(texTarget, gl::GL_TEXTURE_BASE_LEVEL, 0);
-			gl::TexParameteri(texTarget, gl::GL_TEXTURE_MAX_LEVEL, numMipmaps - 1);
+			gl::TexParameteri(texTarget, gl::TEXTURE_BASE_LEVEL, 0);
+			gl::TexParameteri(texTarget, gl::TEXTURE_MAX_LEVEL, numMipmaps - 1);
 
 			//Ensure the texture is texture-complete.
 			const ImageFormat &format = pImage->GetFormat();
 			if(IsTypeIntegral(format.Type()))
 			{
-				gl::TexParameteri(texTarget, gl::GL_TEXTURE_MAG_FILTER, gl::GL_NEAREST);
-				gl::TexParameteri(texTarget, gl::GL_TEXTURE_MIN_FILTER, gl::GL_NEAREST);
+				gl::TexParameteri(texTarget, gl::TEXTURE_MAG_FILTER, gl::NEAREST);
+				gl::TexParameteri(texTarget, gl::TEXTURE_MIN_FILTER, gl::NEAREST);
 			}
 			else
 			{
-				gl::TexParameteri(texTarget, gl::GL_TEXTURE_MAG_FILTER, gl::GL_LINEAR);
-				gl::TexParameteri(texTarget, gl::GL_TEXTURE_MIN_FILTER, gl::GL_LINEAR);
+				gl::TexParameteri(texTarget, gl::TEXTURE_MAG_FILTER, gl::LINEAR);
+				gl::TexParameteri(texTarget, gl::TEXTURE_MIN_FILTER, gl::LINEAR);
 			}
 		}
 
 			}
 
 			int numMipmaps = pImage->GetMipmapCount();
-			gl::TextureParameteriEXT(texture, texTarget, gl::GL_TEXTURE_BASE_LEVEL, 0);
-			gl::TextureParameteriEXT(texture, texTarget, gl::GL_TEXTURE_MAX_LEVEL, numMipmaps - 1);
+			gl::TextureParameteriEXT(texture, texTarget, gl::TEXTURE_BASE_LEVEL, 0);
+			gl::TextureParameteriEXT(texture, texTarget, gl::TEXTURE_MAX_LEVEL, numMipmaps - 1);
 
 			//Ensure the texture is texture-complete.
 			const ImageFormat &format = pImage->GetFormat();
 			if(IsTypeIntegral(format.Type()))
 			{
-				gl::TextureParameteriEXT(texture, texTarget, gl::GL_TEXTURE_MAG_FILTER, gl::GL_NEAREST);
-				gl::TextureParameteriEXT(texture, texTarget, gl::GL_TEXTURE_MIN_FILTER, gl::GL_NEAREST);
+				gl::TextureParameteriEXT(texture, texTarget, gl::TEXTURE_MAG_FILTER, gl::NEAREST);
+				gl::TextureParameteriEXT(texture, texTarget, gl::TEXTURE_MIN_FILTER, gl::NEAREST);
 			}
 			else
 			{
-				gl::TextureParameteriEXT(texture, texTarget, gl::GL_TEXTURE_MAG_FILTER, gl::GL_LINEAR);
-				gl::TextureParameteriEXT(texture, texTarget, gl::GL_TEXTURE_MIN_FILTER, gl::GL_LINEAR);
+				gl::TextureParameteriEXT(texture, texTarget, gl::TEXTURE_MAG_FILTER, gl::LINEAR);
+				gl::TextureParameteriEXT(texture, texTarget, gl::TEXTURE_MIN_FILTER, gl::LINEAR);
 			}
 		}
 
 		{
 			if(!glload::IsVersionGEQ(3, 0))
 			{
-				if(!glext_EXT_texture_array)
+				if(!gl::exts::var_EXT_texture_array)
 					throw TextureUnsupportedException("No Array texture support.");
 			}
 		}
 		{
 			if(!glload::IsVersionGEQ(4, 0))
 			{
-				if(!glext_ARB_texture_cube_map_array)
+				if(!gl::exts::var_ARB_texture_cube_map_array)
 					throw TextureUnsupportedException("No cube-map array texture support.");
 			}
 		}
 		{
 			if(!glload::IsVersionGEQ(4, 2))
 			{
-				if(!glext_ARB_texture_storage)
+				if(!gl::exts::var_ARB_texture_storage)
 					return false;
 			}
 
 
 		bool IsDirectStateAccessSupported()
 		{
-			if(!glext_EXT_direct_state_access)
+			if(!gl::exts::var_EXT_direct_state_access)
 				return false;
 
 			return true;
 						upload.format, upload.type, NULL);
 					break;
 				case 2:
-					if(texTarget == gl::GL_TEXTURE_CUBE_MAP_ARRAY)
+					if(texTarget == gl::TEXTURE_CUBE_MAP_ARRAY)
 						arrayCount *= 6;
 
 					gl::TexImage3D(texTarget, mipmap, internalFormat, levelDims.width, levelDims.height, arrayCount,
 			for(GLuint mipmap = 0; mipmap < numMipmaps; ++mipmap)
 			{
 				Dimensions levelDims = ModifySizeForMipmap(dims, mipmap);
-				gl::TexImage2D(gl::GL_TEXTURE_CUBE_MAP_POSITIVE_X, mipmap, internalFormat,
+				gl::TexImage2D(gl::TEXTURE_CUBE_MAP_POSITIVE_X, mipmap, internalFormat,
 					levelDims.width, levelDims.height, 0, upload.format, upload.type, NULL);
-				gl::TexImage2D(gl::GL_TEXTURE_CUBE_MAP_NEGATIVE_X, mipmap, internalFormat,
+				gl::TexImage2D(gl::TEXTURE_CUBE_MAP_NEGATIVE_X, mipmap, internalFormat,
 					levelDims.width, levelDims.height, 0, upload.format, upload.type, NULL);
-				gl::TexImage2D(gl::GL_TEXTURE_CUBE_MAP_POSITIVE_Y, mipmap, internalFormat,
+				gl::TexImage2D(gl::TEXTURE_CUBE_MAP_POSITIVE_Y, mipmap, internalFormat,
 					levelDims.width, levelDims.height, 0, upload.format, upload.type, NULL);
-				gl::TexImage2D(gl::GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, mipmap, internalFormat,
+				gl::TexImage2D(gl::TEXTURE_CUBE_MAP_NEGATIVE_Y, mipmap, internalFormat,
 					levelDims.width, levelDims.height, 0, upload.format, upload.type, NULL);
-				gl::TexImage2D(gl::GL_TEXTURE_CUBE_MAP_POSITIVE_Z, mipmap, internalFormat,
+				gl::TexImage2D(gl::TEXTURE_CUBE_MAP_POSITIVE_Z, mipmap, internalFormat,
 					levelDims.width, levelDims.height, 0, upload.format, upload.type, NULL);
-				gl::TexImage2D(gl::GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, mipmap, internalFormat,
+				gl::TexImage2D(gl::TEXTURE_CUBE_MAP_NEGATIVE_Z, mipmap, internalFormat,
 					levelDims.width, levelDims.height, 0, upload.format, upload.type, NULL);
 			}
 		}
 			for(GLuint mipmap = 0; mipmap < numMipmaps; ++mipmap)
 			{
 				Dimensions levelDims = ModifySizeForMipmap(dims, mipmap);
-				gl::TextureImage2DEXT(texture, gl::GL_TEXTURE_CUBE_MAP_POSITIVE_X, mipmap, internalFormat,
+				gl::TextureImage2DEXT(texture, gl::TEXTURE_CUBE_MAP_POSITIVE_X, mipmap, internalFormat,
 					levelDims.width, levelDims.height, 0, upload.format, upload.type, NULL);
-				gl::TextureImage2DEXT(texture, gl::GL_TEXTURE_CUBE_MAP_NEGATIVE_X, mipmap, internalFormat,
+				gl::TextureImage2DEXT(texture, gl::TEXTURE_CUBE_MAP_NEGATIVE_X, mipmap, internalFormat,
 					levelDims.width, levelDims.height, 0, upload.format, upload.type, NULL);
-				gl::TextureImage2DEXT(texture, gl::GL_TEXTURE_CUBE_MAP_POSITIVE_Y, mipmap, internalFormat,
+				gl::TextureImage2DEXT(texture, gl::TEXTURE_CUBE_MAP_POSITIVE_Y, mipmap, internalFormat,
 					levelDims.width, levelDims.height, 0, upload.format, upload.type, NULL);
-				gl::TextureImage2DEXT(texture, gl::GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, mipmap, internalFormat,
+				gl::TextureImage2DEXT(texture, gl::TEXTURE_CUBE_MAP_NEGATIVE_Y, mipmap, internalFormat,
 					levelDims.width, levelDims.height, 0, upload.format, upload.type, NULL);
-				gl::TextureImage2DEXT(texture, gl::GL_TEXTURE_CUBE_MAP_POSITIVE_Z, mipmap, internalFormat,
+				gl::TextureImage2DEXT(texture, gl::TEXTURE_CUBE_MAP_POSITIVE_Z, mipmap, internalFormat,
 					levelDims.width, levelDims.height, 0, upload.format, upload.type, NULL);
-				gl::TextureImage2DEXT(texture, gl::GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, mipmap, internalFormat,
+				gl::TextureImage2DEXT(texture, gl::TEXTURE_CUBE_MAP_NEGATIVE_Z, mipmap, internalFormat,
 					levelDims.width, levelDims.height, 0, upload.format, upload.type, NULL);
 			}
 		}
 			TextureBinder bind;
 			if(!(forceConvertBits & USE_DSA))
 			{
-				bind.Bind(gl::GL_TEXTURE_1D, textureName);
+				bind.Bind(gl::TEXTURE_1D, textureName);
 				textureName = 0;
 			}
 
 			const int numMipmaps = pImage->GetMipmapCount();
-			TexStorageBase(gl::GL_TEXTURE_1D, forceConvertBits, pImage->GetDimensions(),
+			TexStorageBase(gl::TEXTURE_1D, forceConvertBits, pImage->GetDimensions(),
 				numMipmaps, internalFormat, upload, textureName);
 
 			for(int mipmap = 0; mipmap < numMipmaps; mipmap++)
 				Dimensions dims = pImage->GetDimensions(mipmap);
 				const void *pPixelData = pImage->GetImageData(mipmap, 0, 0);
 
-				TexSubImage(textureName, gl::GL_TEXTURE_1D, mipmap, internalFormat, dims, upload,
+				TexSubImage(textureName, gl::TEXTURE_1D, mipmap, internalFormat, dims, upload,
 					pPixelData, pImage->GetImageByteSize(mipmap));
 			}
 
-			FinalizeTexture(textureName, gl::GL_TEXTURE_1D, pImage);
+			FinalizeTexture(textureName, gl::TEXTURE_1D, pImage);
 		}
 
 		void Build2DCubeArrayTexture(unsigned int textureName, const detail::ImageSetImpl *pImage,
 			TextureBinder bind;
 			if(!(forceConvertBits & USE_DSA))
 			{
-				bind.Bind(gl::GL_TEXTURE_CUBE_MAP, textureName);
+				bind.Bind(gl::TEXTURE_CUBE_MAP, textureName);
 				textureName = 0;
 			}
 
 			const int numMipmaps = pImage->GetMipmapCount();
-			TexStorageCube(gl::GL_TEXTURE_CUBE_MAP, forceConvertBits, pImage->GetDimensions(),
+			TexStorageCube(gl::TEXTURE_CUBE_MAP, forceConvertBits, pImage->GetDimensions(),
 				numMipmaps, internalFormat, upload, textureName);
 
 			for(int mipmap = 0; mipmap < numMipmaps; mipmap++)
 				{
 					const void *pPixelData = pImage->GetImageData(mipmap, 0, faceIx);
 
-					TexSubImage(textureName, gl::GL_TEXTURE_CUBE_MAP_POSITIVE_X + faceIx,
+					TexSubImage(textureName, gl::TEXTURE_CUBE_MAP_POSITIVE_X + faceIx,
 						mipmap, internalFormat, dims, upload,
 						pPixelData, pImage->GetImageByteSize(mipmap));
 				}
 			}
 
-			FinalizeTexture(textureName, gl::GL_TEXTURE_CUBE_MAP, pImage);
+			FinalizeTexture(textureName, gl::TEXTURE_CUBE_MAP, pImage);
 		}
 
 		void Build2DTexture(unsigned int textureName, const detail::ImageSetImpl *pImage,
 			TextureBinder bind;
 			if(!(forceConvertBits & USE_DSA))
 			{
-				bind.Bind(gl::GL_TEXTURE_2D, textureName);
+				bind.Bind(gl::TEXTURE_2D, textureName);
 				textureName = 0;
 			}
 
 			const int numMipmaps = pImage->GetMipmapCount();
-			TexStorageBase(gl::GL_TEXTURE_2D, forceConvertBits, pImage->GetDimensions(),
+			TexStorageBase(gl::TEXTURE_2D, forceConvertBits, pImage->GetDimensions(),
 				numMipmaps, internalFormat, upload, textureName);
 
 			for(int mipmap = 0; mipmap < numMipmaps; mipmap++)
 				Dimensions dims = pImage->GetDimensions(mipmap);
 				const void *pPixelData = pImage->GetImageData(mipmap);
 
-				TexSubImage(textureName, gl::GL_TEXTURE_2D, mipmap, internalFormat, dims, upload,
+				TexSubImage(textureName, gl::TEXTURE_2D, mipmap, internalFormat, dims, upload,
 					pPixelData, pImage->GetImageByteSize(mipmap));
 			}
 
-			FinalizeTexture(textureName, gl::GL_TEXTURE_2D, pImage);
+			FinalizeTexture(textureName, gl::TEXTURE_2D, pImage);
 		}
 
 		void Build3DTexture(unsigned int textureName, const detail::ImageSetImpl *pImage,
 			TextureBinder bind;
 			if(!(forceConvertBits & USE_DSA))
 			{
-				bind.Bind(gl::GL_TEXTURE_3D, textureName);
+				bind.Bind(gl::TEXTURE_3D, textureName);
 				textureName = 0;
 			}
 
 			const int numMipmaps = pImage->GetMipmapCount();
-			TexStorageBase(gl::GL_TEXTURE_3D, forceConvertBits, pImage->GetDimensions(),
+			TexStorageBase(gl::TEXTURE_3D, forceConvertBits, pImage->GetDimensions(),
 				numMipmaps, internalFormat, upload, textureName);
 
 			for(int mipmap = 0; mipmap < numMipmaps; mipmap++)
 				Dimensions dims = pImage->GetDimensions(mipmap);
 				const void *pPixelData = pImage->GetImageData(mipmap);
 
-				TexSubImage(textureName, gl::GL_TEXTURE_3D, mipmap, internalFormat, dims, upload, pPixelData,
+				TexSubImage(textureName, gl::TEXTURE_3D, mipmap, internalFormat, dims, upload, pPixelData,
 					pImage->GetImageByteSize(mipmap));
 			}
 
-			FinalizeTexture(textureName, gl::GL_TEXTURE_3D, pImage);
+			FinalizeTexture(textureName, gl::TEXTURE_3D, pImage);
 		}
 
 		bool IsArrayTexture(const ImageSet *pImage, unsigned int forceConvertBits)
 		case 1:
 			//May be 1D or 1D array.
 			if(IsArrayTexture(pImage, forceConvertBits))
-				return gl::GL_TEXTURE_1D_ARRAY;
+				return gl::TEXTURE_1D_ARRAY;
 			else
-				return gl::GL_TEXTURE_1D;
+				return gl::TEXTURE_1D;
 		case 2:
 			//2D, 2D array, 2D cube, or 2D array cube.
 			if(IsArrayTexture(pImage, forceConvertBits))
 			{
 				if(pImage->GetFaceCount() > 1)
-					return gl::GL_TEXTURE_CUBE_MAP_ARRAY;
+					return gl::TEXTURE_CUBE_MAP_ARRAY;
 				else
-					return gl::GL_TEXTURE_2D_ARRAY;
+					return gl::TEXTURE_2D_ARRAY;
 			}
 			else
 			{
 				if(pImage->GetFaceCount() > 1)
-					return gl::GL_TEXTURE_CUBE_MAP;
+					return gl::TEXTURE_CUBE_MAP;
 				else
-					return gl::GL_TEXTURE_2D;
+					return gl::TEXTURE_2D;
 			}
 			break;
 		case 3:
 			//3D.
-			return gl::GL_TEXTURE_3D;
+			return gl::TEXTURE_3D;
 		}
 
 		return 0xFFFFFFFF;
 
 		switch(GetTextureType(pImage, forceConvertBits))
 		{
-		case gl::GL_TEXTURE_1D:
+		case gl::TEXTURE_1D:
 			Build1DTexture(textureName, pImage->m_pImpl, forceConvertBits,
 				internalFormat, upload);
 			break;
-		case gl::GL_TEXTURE_2D:
+		case gl::TEXTURE_2D:
 			Build2DTexture(textureName, pImage->m_pImpl, forceConvertBits,
 				internalFormat, upload);
 			break;
-		case gl::GL_TEXTURE_3D:
+		case gl::TEXTURE_3D:
 			Build3DTexture(textureName, pImage->m_pImpl, forceConvertBits,
 				internalFormat, upload);
 			break;
-		case gl::GL_TEXTURE_1D_ARRAY:
+		case gl::TEXTURE_1D_ARRAY:
 			Build1DArrayTexture(textureName, pImage->m_pImpl, forceConvertBits,
 				internalFormat, upload);
 			break;
-		case gl::GL_TEXTURE_2D_ARRAY:
+		case gl::TEXTURE_2D_ARRAY:
 			Build2DArrayTexture(textureName, pImage->m_pImpl, forceConvertBits,
 				internalFormat, upload);
 			break;
-		case gl::GL_TEXTURE_CUBE_MAP:
+		case gl::TEXTURE_CUBE_MAP:
 			Build2DCubeTexture(textureName, pImage->m_pImpl, forceConvertBits,
 				internalFormat, upload);
 			break;
-		case gl::GL_TEXTURE_CUBE_MAP_ARRAY:
+		case gl::TEXTURE_CUBE_MAP_ARRAY:
 			Build2DCubeArrayTexture(textureName, pImage->m_pImpl, forceConvertBits,
 				internalFormat, upload);
 			break;

glload/include/glload/_int_gl_1_1_rem.hpp

 {
 	enum
 	{
-		//CURRENT_BIT taken from 1.1
-		//POINT_BIT taken from 1.1
-		//LINE_BIT taken from 1.1
-		//POLYGON_BIT taken from 1.1
-		//POLYGON_STIPPLE_BIT taken from 1.1
-		//PIXEL_MODE_BIT taken from 1.1
-		//LIGHTING_BIT taken from 1.1
-		//FOG_BIT taken from 1.1
-		//ACCUM_BUFFER_BIT taken from 1.1
-		//VIEWPORT_BIT taken from 1.1
-		//TRANSFORM_BIT taken from 1.1
-		//ENABLE_BIT taken from 1.1
-		//HINT_BIT taken from 1.1
-		//EVAL_BIT taken from 1.1
-		//LIST_BIT taken from 1.1
-		//TEXTURE_BIT taken from 1.1
-		//SCISSOR_BIT taken from 1.1
-		//ALL_ATTRIB_BITS taken from 1.1
-		//CLIENT_PIXEL_STORE_BIT taken from 1.1
-		//CLIENT_VERTEX_ARRAY_BIT taken from 1.1
-		//CLIENT_ALL_ATTRIB_BITS taken from 1.1
-		//QUAD_STRIP taken from 1.1
-		//POLYGON taken from 1.1
-		//ACCUM taken from 1.1
-		//LOAD taken from 1.1
-		//RETURN taken from 1.1
-		//MULT taken from 1.1
-		//ADD taken from 1.1
-		//AUX0 taken from 1.1
-		//AUX1 taken from 1.1
-		//AUX2 taken from 1.1
-		//AUX3 taken from 1.1
-		//2D taken from 1.1
-		//3D taken from 1.1
-		//3D_COLOR taken from 1.1
-		//3D_COLOR_TEXTURE taken from 1.1
-		//4D_COLOR_TEXTURE taken from 1.1
-		//PASS_THROUGH_TOKEN taken from 1.1
-		//POINT_TOKEN taken from 1.1
-		//LINE_TOKEN taken from 1.1
-		//POLYGON_TOKEN taken from 1.1
-		//BITMAP_TOKEN taken from 1.1
-		//DRAW_PIXEL_TOKEN taken from 1.1
-		//COPY_PIXEL_TOKEN taken from 1.1
-		//LINE_RESET_TOKEN taken from 1.1
-		//EXP taken from 1.1
-		//EXP2 taken from 1.1
-		//COEFF taken from 1.1
-		//ORDER taken from 1.1
-		//DOMAIN taken from 1.1
-		//PIXEL_MAP_I_TO_I taken from 1.1
-		//PIXEL_MAP_S_TO_S taken from 1.1
-		//PIXEL_MAP_I_TO_R taken from 1.1
-		//PIXEL_MAP_I_TO_G taken from 1.1
-		//PIXEL_MAP_I_TO_B taken from 1.1
-		//PIXEL_MAP_I_TO_A taken from 1.1
-		//PIXEL_MAP_R_TO_R taken from 1.1
-		//PIXEL_MAP_G_TO_G taken from 1.1
-		//PIXEL_MAP_B_TO_B taken from 1.1
-		//PIXEL_MAP_A_TO_A taken from 1.1
-		//VERTEX_ARRAY_POINTER taken from 1.1
-		//NORMAL_ARRAY_POINTER taken from 1.1
-		//COLOR_ARRAY_POINTER taken from 1.1
-		//INDEX_ARRAY_POINTER taken from 1.1
-		//TEXTURE_COORD_ARRAY_POINTER taken from 1.1
-		//EDGE_FLAG_ARRAY_POINTER taken from 1.1
-		//FEEDBACK_BUFFER_POINTER taken from 1.1
-		//SELECTION_BUFFER_POINTER taken from 1.1
-		//CURRENT_COLOR taken from 1.1
-		//CURRENT_INDEX taken from 1.1
-		//CURRENT_NORMAL taken from 1.1
-		//CURRENT_TEXTURE_COORDS taken from 1.1
-		//CURRENT_RASTER_COLOR taken from 1.1
-		//CURRENT_RASTER_INDEX taken from 1.1
-		//CURRENT_RASTER_TEXTURE_COORDS taken from 1.1
-		//CURRENT_RASTER_POSITION taken from 1.1
-		//CURRENT_RASTER_POSITION_VALID taken from 1.1
-		//CURRENT_RASTER_DISTANCE taken from 1.1
-		//POINT_SMOOTH taken from 1.1
-		//LINE_STIPPLE taken from 1.1
-		//LINE_STIPPLE_PATTERN taken from 1.1
-		//LINE_STIPPLE_REPEAT taken from 1.1
-		//LIST_MODE taken from 1.1
-		//MAX_LIST_NESTING taken from 1.1
-		//LIST_BASE taken from 1.1
-		//LIST_INDEX taken from 1.1
-		//POLYGON_STIPPLE taken from 1.1
-		//EDGE_FLAG taken from 1.1
-		//LIGHTING taken from 1.1
-		//LIGHT_MODEL_LOCAL_VIEWER taken from 1.1
-		//LIGHT_MODEL_TWO_SIDE taken from 1.1
-		//LIGHT_MODEL_AMBIENT taken from 1.1
-		//SHADE_MODEL taken from 1.1
-		//COLOR_MATERIAL_FACE taken from 1.1
-		//COLOR_MATERIAL_PARAMETER taken from 1.1
-		//COLOR_MATERIAL taken from 1.1
-		//FOG_INDEX taken from 1.1
-		//FOG_DENSITY taken from 1.1
-		//FOG_START taken from 1.1
-		//FOG_END taken from 1.1
-		//FOG_MODE taken from 1.1
-		//FOG_COLOR taken from 1.1
-		//ACCUM_CLEAR_VALUE taken from 1.1
-		//MATRIX_MODE taken from 1.1
-		//NORMALIZE taken from 1.1
-		//MODELVIEW_STACK_DEPTH taken from 1.1
-		//PROJECTION_STACK_DEPTH taken from 1.1
-		//TEXTURE_STACK_DEPTH taken from 1.1
-		//MODELVIEW_MATRIX taken from 1.1
-		//PROJECTION_MATRIX taken from 1.1
-		//TEXTURE_MATRIX taken from 1.1
-		//ATTRIB_STACK_DEPTH taken from 1.1
-		//CLIENT_ATTRIB_STACK_DEPTH taken from 1.1
-		//ALPHA_TEST taken from 1.1
-		//ALPHA_TEST_FUNC taken from 1.1
-		//ALPHA_TEST_REF taken from 1.1
-		//INDEX_LOGIC_OP taken from 1.1
-		//LOGIC_OP taken from 1.1
-		//AUX_BUFFERS taken from 1.1
-		//INDEX_CLEAR_VALUE taken from 1.1
-		//INDEX_WRITEMASK taken from 1.1
-		//INDEX_MODE taken from 1.1
-		//RGBA_MODE taken from 1.1
-		//RENDER_MODE taken from 1.1
-		//PERSPECTIVE_CORRECTION_HINT taken from 1.1
-		//POINT_SMOOTH_HINT taken from 1.1
-		//FOG_HINT taken from 1.1
-		//TEXTURE_GEN_S taken from 1.1
-		//TEXTURE_GEN_T taken from 1.1
-		//TEXTURE_GEN_R taken from 1.1
-		//TEXTURE_GEN_Q taken from 1.1
-		//PIXEL_MAP_I_TO_I_SIZE taken from 1.1
-		//PIXEL_MAP_S_TO_S_SIZE taken from 1.1
-		//PIXEL_MAP_I_TO_R_SIZE taken from 1.1
-		//PIXEL_MAP_I_TO_G_SIZE taken from 1.1
-		//PIXEL_MAP_I_TO_B_SIZE taken from 1.1
-		//PIXEL_MAP_I_TO_A_SIZE taken from 1.1
-		//PIXEL_MAP_R_TO_R_SIZE taken from 1.1
-		//PIXEL_MAP_G_TO_G_SIZE taken from 1.1
-		//PIXEL_MAP_B_TO_B_SIZE taken from 1.1
-		//PIXEL_MAP_A_TO_A_SIZE taken from 1.1
-		//MAP_COLOR taken from 1.1
-		//MAP_STENCIL taken from 1.1
-		//INDEX_SHIFT taken from 1.1
-		//INDEX_OFFSET taken from 1.1
-		//RED_SCALE taken from 1.1
-		//RED_BIAS taken from 1.1
-		//ZOOM_X taken from 1.1
-		//ZOOM_Y taken from 1.1
-		//GREEN_SCALE taken from 1.1
-		//GREEN_BIAS taken from 1.1
-		//BLUE_SCALE taken from 1.1
-		//BLUE_BIAS taken from 1.1
-		//ALPHA_SCALE taken from 1.1
-		//ALPHA_BIAS taken from 1.1
-		//DEPTH_SCALE taken from 1.1
-		//DEPTH_BIAS taken from 1.1
-		//MAX_EVAL_ORDER taken from 1.1
-		//MAX_LIGHTS taken from 1.1
-		//MAX_CLIP_PLANES taken from 1.1
-		//MAX_PIXEL_MAP_TABLE taken from 1.1
-		//MAX_ATTRIB_STACK_DEPTH taken from 1.1
-		//MAX_MODELVIEW_STACK_DEPTH taken from 1.1
-		//MAX_NAME_STACK_DEPTH taken from 1.1
-		//MAX_PROJECTION_STACK_DEPTH taken from 1.1
-		//MAX_TEXTURE_STACK_DEPTH taken from 1.1
-		//MAX_CLIENT_ATTRIB_STACK_DEPTH taken from 1.1
-		//INDEX_BITS taken from 1.1
-		//RED_BITS taken from 1.1
-		//GREEN_BITS taken from 1.1
-		//BLUE_BITS taken from 1.1
-		//ALPHA_BITS taken from 1.1
-		//DEPTH_BITS taken from 1.1
-		//STENCIL_BITS taken from 1.1
-		//ACCUM_RED_BITS taken from 1.1
-		//ACCUM_GREEN_BITS taken from 1.1
-		//ACCUM_BLUE_BITS taken from 1.1
-		//ACCUM_ALPHA_BITS taken from 1.1
-		//NAME_STACK_DEPTH taken from 1.1
-		//AUTO_NORMAL taken from 1.1
-		//MAP1_COLOR_4 taken from 1.1
-		//MAP1_INDEX taken from 1.1
-		//MAP1_NORMAL taken from 1.1
-		//MAP1_TEXTURE_COORD_1 taken from 1.1
-		//MAP1_TEXTURE_COORD_2 taken from 1.1
-		//MAP1_TEXTURE_COORD_3 taken from 1.1
-		//MAP1_TEXTURE_COORD_4 taken from 1.1
-		//MAP1_VERTEX_3 taken from 1.1
-		//MAP1_VERTEX_4 taken from 1.1
-		//MAP2_COLOR_4 taken from 1.1
-		//MAP2_INDEX taken from 1.1
-		//MAP2_NORMAL taken from 1.1
-		//MAP2_TEXTURE_COORD_1 taken from 1.1
-		//MAP2_TEXTURE_COORD_2 taken from 1.1
-		//MAP2_TEXTURE_COORD_3 taken from 1.1
-		//MAP2_TEXTURE_COORD_4 taken from 1.1
-		//MAP2_VERTEX_3 taken from 1.1
-		//MAP2_VERTEX_4 taken from 1.1
-		//MAP1_GRID_DOMAIN taken from 1.1
-		//MAP1_GRID_SEGMENTS taken from 1.1
-		//MAP2_GRID_DOMAIN taken from 1.1
-		//MAP2_GRID_SEGMENTS taken from 1.1
-		//FEEDBACK_BUFFER_SIZE taken from 1.1
-		//FEEDBACK_BUFFER_TYPE taken from 1.1
-		//SELECTION_BUFFER_SIZE taken from 1.1
-		//VERTEX_ARRAY taken from 1.1
-		//NORMAL_ARRAY taken from 1.1
-		//COLOR_ARRAY taken from 1.1
-		//INDEX_ARRAY taken from 1.1
-		//TEXTURE_COORD_ARRAY taken from 1.1
-		//EDGE_FLAG_ARRAY taken from 1.1
-		//VERTEX_ARRAY_SIZE taken from 1.1
-		//VERTEX_ARRAY_TYPE taken from 1.1
-		//VERTEX_ARRAY_STRIDE taken from 1.1
-		//NORMAL_ARRAY_TYPE taken from 1.1
-		//NORMAL_ARRAY_STRIDE taken from 1.1
-		//COLOR_ARRAY_SIZE taken from 1.1
-		//COLOR_ARRAY_TYPE taken from 1.1
-		//COLOR_ARRAY_STRIDE taken from 1.1
-		//INDEX_ARRAY_TYPE taken from 1.1
-		//INDEX_ARRAY_STRIDE taken from 1.1
-		//TEXTURE_COORD_ARRAY_SIZE taken from 1.1
-		//TEXTURE_COORD_ARRAY_TYPE taken from 1.1
-		//TEXTURE_COORD_ARRAY_STRIDE taken from 1.1
-		//EDGE_FLAG_ARRAY_STRIDE taken from 1.1
-		//TEXTURE_COMPONENTS taken from 1.1
-		//TEXTURE_BORDER taken from 1.1
-		//TEXTURE_LUMINANCE_SIZE taken from 1.1
-		//TEXTURE_INTENSITY_SIZE taken from 1.1
-		//TEXTURE_PRIORITY taken from 1.1
-		//TEXTURE_RESIDENT taken from 1.1
-		//AMBIENT taken from 1.1
-		//DIFFUSE taken from 1.1
-		//SPECULAR taken from 1.1
-		//POSITION taken from 1.1
-		//SPOT_DIRECTION taken from 1.1
-		//SPOT_EXPONENT taken from 1.1
-		//SPOT_CUTOFF taken from 1.1
-		//CONSTANT_ATTENUATION taken from 1.1
-		//LINEAR_ATTENUATION taken from 1.1
-		//QUADRATIC_ATTENUATION taken from 1.1
-		//COMPILE taken from 1.1
-		//COMPILE_AND_EXECUTE taken from 1.1
-		//2_BYTES taken from 1.1
-		//3_BYTES taken from 1.1
-		//4_BYTES taken from 1.1
-		//EMISSION taken from 1.1
-		//SHININESS taken from 1.1
-		//AMBIENT_AND_DIFFUSE taken from 1.1
-		//COLOR_INDEXES taken from 1.1
-		//MODELVIEW taken from 1.1
-		//PROJECTION taken from 1.1
-		//COLOR_INDEX taken from 1.1
-		//LUMINANCE taken from 1.1
-		//LUMINANCE_ALPHA taken from 1.1
-		//BITMAP taken from 1.1
-		//RENDER taken from 1.1
-		//FEEDBACK taken from 1.1
-		//SELECT taken from 1.1
-		//FLAT taken from 1.1
-		//SMOOTH taken from 1.1
-		//S taken from 1.1
-		//T taken from 1.1
-		//R taken from 1.1
-		//Q taken from 1.1
-		//MODULATE taken from 1.1
-		//DECAL taken from 1.1
-		//TEXTURE_ENV_MODE taken from 1.1
-		//TEXTURE_ENV_COLOR taken from 1.1
-		//TEXTURE_ENV taken from 1.1
-		//EYE_LINEAR taken from 1.1
-		//OBJECT_LINEAR taken from 1.1
-		//SPHERE_MAP taken from 1.1
-		//TEXTURE_GEN_MODE taken from 1.1
-		//OBJECT_PLANE taken from 1.1
-		//CLAMP taken from 1.1
-		//ALPHA4 taken from 1.1
-		//ALPHA8 taken from 1.1
-		//ALPHA12 taken from 1.1
-		//ALPHA16 taken from 1.1
-		//LUMINANCE4 taken from 1.1
-		//LUMINANCE8 taken from 1.1
-		//LUMINANCE12 taken from 1.1
-		//LUMINANCE16 taken from 1.1
-		//LUMINANCE4_ALPHA4 taken from 1.1
-		//LUMINANCE6_ALPHA2 taken from 1.1
-		//LUMINANCE8_ALPHA8 taken from 1.1
-		//LUMINANCE12_ALPHA4 taken from 1.1
-		//LUMINANCE12_ALPHA12 taken from 1.1
-		//LUMINANCE16_ALPHA16 taken from 1.1
-		//INTENSITY taken from 1.1
-		//INTENSITY4 taken from 1.1
-		//INTENSITY8 taken from 1.1
-		//INTENSITY12 taken from 1.1
-		//INTENSITY16 taken from 1.1
-		//V2F taken from 1.1
-		//V3F taken from 1.1
-		//C4UB_V2F taken from 1.1
-		//C4UB_V3F taken from 1.1
-		//C3F_V3F taken from 1.1
-		//N3F_V3F taken from 1.1
-		//C4F_N3F_V3F taken from 1.1
-		//T2F_V3F taken from 1.1
-		//T4F_V4F taken from 1.1
-		//T2F_C4UB_V3F taken from 1.1
-		//T2F_C3F_V3F taken from 1.1
-		//T2F_N3F_V3F taken from 1.1
-		//T2F_C4F_N3F_V3F taken from 1.1
-		//T4F_C4F_N3F_V4F taken from 1.1
-		//CLIP_PLANE0 taken from 1.1
-		//CLIP_PLANE1 taken from 1.1
-		//CLIP_PLANE2 taken from 1.1
-		//CLIP_PLANE3 taken from 1.1
-		//CLIP_PLANE4 taken from 1.1
-		//CLIP_PLANE5 taken from 1.1
-		//LIGHT0 taken from 1.1
-		//LIGHT1 taken from 1.1
-		//LIGHT2 taken from 1.1
-		//LIGHT3 taken from 1.1
-		//LIGHT4 taken from 1.1
-		//LIGHT5 taken from 1.1
-		//LIGHT6 taken from 1.1
-		//LIGHT7 taken from 1.1
+		CURRENT_BIT                      = 0x00000001,
+		POINT_BIT                        = 0x00000002,
+		LINE_BIT                         = 0x00000004,
+		POLYGON_BIT                      = 0x00000008,
+		POLYGON_STIPPLE_BIT              = 0x00000010,
+		PIXEL_MODE_BIT                   = 0x00000020,
+		LIGHTING_BIT                     = 0x00000040,
+		FOG_BIT                          = 0x00000080,
+		ACCUM_BUFFER_BIT                 = 0x00000200,
+		VIEWPORT_BIT                     = 0x00000800,
+		TRANSFORM_BIT                    = 0x00001000,
+		ENABLE_BIT                       = 0x00002000,
+		HINT_BIT                         = 0x00008000,
+		EVAL_BIT                         = 0x00010000,
+		LIST_BIT                         = 0x00020000,
+		TEXTURE_BIT                      = 0x00040000,
+		SCISSOR_BIT                      = 0x00080000,
+		ALL_ATTRIB_BITS                  = 0xFFFFFFFF,
+		CLIENT_PIXEL_STORE_BIT           = 0x00000001,
+		CLIENT_VERTEX_ARRAY_BIT          = 0x00000002,
+		CLIENT_ALL_ATTRIB_BITS           = 0xFFFFFFFF,
+		QUAD_STRIP                       = 0x0008,
+		POLYGON                          = 0x0009,
+		ACCUM                            = 0x0100,
+		LOAD                             = 0x0101,
+		RETURN                           = 0x0102,
+		MULT                             = 0x0103,
+		ADD                              = 0x0104,
+		AUX0                             = 0x0409,
+		AUX1                             = 0x040A,
+		AUX2                             = 0x040B,
+		AUX3                             = 0x040C,
+		_2D                              = 0x0600,
+		_3D                              = 0x0601,
+		_3D_COLOR                        = 0x0602,
+		_3D_COLOR_TEXTURE                = 0x0603,
+		_4D_COLOR_TEXTURE                = 0x0604,
+		PASS_THROUGH_TOKEN               = 0x0700,
+		POINT_TOKEN                      = 0x0701,
+		LINE_TOKEN                       = 0x0702,
+		POLYGON_TOKEN                    = 0x0703,
+		BITMAP_TOKEN                     = 0x0704,
+		DRAW_PIXEL_TOKEN                 = 0x0705,
+		COPY_PIXEL_TOKEN                 = 0x0706,
+		LINE_RESET_TOKEN                 = 0x0707,
+		EXP                              = 0x0800,
+		EXP2                             = 0x0801,
+		COEFF                            = 0x0A00,
+		ORDER                            = 0x0A01,
+		DOMAIN_                          = 0x0A02,
+		PIXEL_MAP_I_TO_I                 = 0x0C70,
+		PIXEL_MAP_S_TO_S                 = 0x0C71,
+		PIXEL_MAP_I_TO_R                 = 0x0C72,
+		PIXEL_MAP_I_TO_G                 = 0x0C73,
+		PIXEL_MAP_I_TO_B                 = 0x0C74,
+		PIXEL_MAP_I_TO_A                 = 0x0C75,
+		PIXEL_MAP_R_TO_R                 = 0x0C76,
+		PIXEL_MAP_G_TO_G                 = 0x0C77,
+		PIXEL_MAP_B_TO_B                 = 0x0C78,
+		PIXEL_MAP_A_TO_A                 = 0x0C79,
+		VERTEX_ARRAY_POINTER             = 0x808E,
+		NORMAL_ARRAY_POINTER             = 0x808F,
+		COLOR_ARRAY_POINTER              = 0x8090,
+		INDEX_ARRAY_POINTER              = 0x8091,
+		TEXTURE_COORD_ARRAY_POINTER      = 0x8092,
+		EDGE_FLAG_ARRAY_POINTER          = 0x8093,
+		FEEDBACK_BUFFER_POINTER          = 0x0DF0,
+		SELECTION_BUFFER_POINTER         = 0x0DF3,
+		CURRENT_COLOR                    = 0x0B00,
+		CURRENT_INDEX                    = 0x0B01,
+		CURRENT_NORMAL                   = 0x0B02,
+		CURRENT_TEXTURE_COORDS           = 0x0B03,
+		CURRENT_RASTER_COLOR             = 0x0B04,
+		CURRENT_RASTER_INDEX             = 0x0B05,
+		CURRENT_RASTER_TEXTURE_COORDS    = 0x0B06,
+		CURRENT_RASTER_POSITION          = 0x0B07,
+		CURRENT_RASTER_POSITION_VALID    = 0x0B08,
+		CURRENT_RASTER_DISTANCE          = 0x0B09,
+		POINT_SMOOTH                     = 0x0B10,
+		LINE_STIPPLE                     = 0x0B24,
+		LINE_STIPPLE_PATTERN             = 0x0B25,
+		LINE_STIPPLE_REPEAT              = 0x0B26,
+		LIST_MODE                        = 0x0B30,
+		MAX_LIST_NESTING                 = 0x0B31,
+		LIST_BASE                        = 0x0B32,
+		LIST_INDEX                       = 0x0B33,
+		POLYGON_STIPPLE                  = 0x0B42,
+		EDGE_FLAG                        = 0x0B43,
+		LIGHTING                         = 0x0B50,
+		LIGHT_MODEL_LOCAL_VIEWER         = 0x0B51,
+		LIGHT_MODEL_TWO_SIDE             = 0x0B52,
+		LIGHT_MODEL_AMBIENT              = 0x0B53,
+		SHADE_MODEL                      = 0x0B54,
+		COLOR_MATERIAL_FACE              = 0x0B55,
+		COLOR_MATERIAL_PARAMETER         = 0x0B56,
+		COLOR_MATERIAL                   = 0x0B57,
+		FOG_INDEX                        = 0x0B61,
+		FOG_DENSITY                      = 0x0B62,
+		FOG_START                        = 0x0B63,
+		FOG_END                          = 0x0B64,
+		FOG_MODE                         = 0x0B65,
+		FOG_COLOR                        = 0x0B66,
+		ACCUM_CLEAR_VALUE                = 0x0B80,
+		MATRIX_MODE                      = 0x0BA0,
+		NORMALIZE                        = 0x0BA1,
+		MODELVIEW_STACK_DEPTH            = 0x0BA3,
+		PROJECTION_STACK_DEPTH           = 0x0BA4,
+		TEXTURE_STACK_DEPTH              = 0x0BA5,
+		MODELVIEW_MATRIX                 = 0x0BA6,
+		PROJECTION_MATRIX                = 0x0BA7,
+		TEXTURE_MATRIX                   = 0x0BA8,
+		ATTRIB_STACK_DEPTH               = 0x0BB0,
+		CLIENT_ATTRIB_STACK_DEPTH        = 0x0BB1,
+		ALPHA_TEST                       = 0x0BC0,
+		ALPHA_TEST_FUNC                  = 0x0BC1,
+		ALPHA_TEST_REF                   = 0x0BC2,
+		INDEX_LOGIC_OP                   = 0x0BF1,
+		LOGIC_OP                         = 0x0BF1,
+		AUX_BUFFERS                      = 0x0C00,
+		INDEX_CLEAR_VALUE                = 0x0C20,
+		INDEX_WRITEMASK                  = 0x0C21,
+		INDEX_MODE                       = 0x0C30,
+		RGBA_MODE                        = 0x0C31,
+		RENDER_MODE                      = 0x0C40,
+		PERSPECTIVE_CORRECTION_HINT      = 0x0C50,
+		POINT_SMOOTH_HINT                = 0x0C51,
+		FOG_HINT                         = 0x0C54,
+		TEXTURE_GEN_S                    = 0x0C60,
+		TEXTURE_GEN_T                    = 0x0C61,
+		TEXTURE_GEN_R                    = 0x0C62,
+		TEXTURE_GEN_Q                    = 0x0C63,
+		PIXEL_MAP_I_TO_I_SIZE            = 0x0CB0,
+		PIXEL_MAP_S_TO_S_SIZE            = 0x0CB1,
+		PIXEL_MAP_I_TO_R_SIZE            = 0x0CB2,
+		PIXEL_MAP_I_TO_G_SIZE            = 0x0CB3,
+		PIXEL_MAP_I_TO_B_SIZE            = 0x0CB4,
+		PIXEL_MAP_I_TO_A_SIZE            = 0x0CB5,
+		PIXEL_MAP_R_TO_R_SIZE            = 0x0CB6,
+		PIXEL_MAP_G_TO_G_SIZE            = 0x0CB7,
+		PIXEL_MAP_B_TO_B_SIZE            = 0x0CB8,
+		PIXEL_MAP_A_TO_A_SIZE            = 0x0CB9,
+		MAP_COLOR                        = 0x0D10,
+		MAP_STENCIL                      = 0x0D11,
+		INDEX_SHIFT                      = 0x0D12,
+		INDEX_OFFSET                     = 0x0D13,
+		RED_SCALE                        = 0x0D14,
+		RED_BIAS                         = 0x0D15,
+		ZOOM_X                           = 0x0D16,
+		ZOOM_Y                           = 0x0D17,
+		GREEN_SCALE                      = 0x0D18,
+		GREEN_BIAS                       = 0x0D19,
+		BLUE_SCALE                       = 0x0D1A,
+		BLUE_BIAS                        = 0x0D1B,
+		ALPHA_SCALE                      = 0x0D1C,
+		ALPHA_BIAS                       = 0x0D1D,
+		DEPTH_SCALE                      = 0x0D1E,
+		DEPTH_BIAS                       = 0x0D1F,
+		MAX_EVAL_ORDER                   = 0x0D30,
+		MAX_LIGHTS                       = 0x0D31,
+		MAX_CLIP_PLANES                  = 0x0D32,
+		MAX_PIXEL_MAP_TABLE              = 0x0D34,
+		MAX_ATTRIB_STACK_DEPTH           = 0x0D35,
+		MAX_MODELVIEW_STACK_DEPTH        = 0x0D36,
+		MAX_NAME_STACK_DEPTH             = 0x0D37,
+		MAX_PROJECTION_STACK_DEPTH       = 0x0D38,
+		MAX_TEXTURE_STACK_DEPTH          = 0x0D39,
+		MAX_CLIENT_ATTRIB_STACK_DEPTH    = 0x0D3B,
+		INDEX_BITS                       = 0x0D51,
+		RED_BITS                         = 0x0D52,
+		GREEN_BITS                       = 0x0D53,
+		BLUE_BITS                        = 0x0D54,
+		ALPHA_BITS                       = 0x0D55,
+		DEPTH_BITS                       = 0x0D56,
+		STENCIL_BITS                     = 0x0D57,
+		ACCUM_RED_BITS                   = 0x0D58,
+		ACCUM_GREEN_BITS                 = 0x0D59,
+		ACCUM_BLUE_BITS                  = 0x0D5A,
+		ACCUM_ALPHA_BITS                 = 0x0D5B,
+		NAME_STACK_DEPTH                 = 0x0D70,
+		AUTO_NORMAL                      = 0x0D80,
+		MAP1_COLOR_4                     = 0x0D90,
+		MAP1_INDEX                       = 0x0D91,
+		MAP1_NORMAL                      = 0x0D92,
+		MAP1_TEXTURE_COORD_1             = 0x0D93,
+		MAP1_TEXTURE_COORD_2             = 0x0D94,
+		MAP1_TEXTURE_COORD_3             = 0x0D95,
+		MAP1_TEXTURE_COORD_4             = 0x0D96,
+		MAP1_VERTEX_3                    = 0x0D97,
+		MAP1_VERTEX_4                    = 0x0D98,
+		MAP2_COLOR_4                     = 0x0DB0,
+		MAP2_INDEX                       = 0x0DB1,
+		MAP2_NORMAL                      = 0x0DB2,
+		MAP2_TEXTURE_COORD_1             = 0x0DB3,
+		MAP2_TEXTURE_COORD_2             = 0x0DB4,
+		MAP2_TEXTURE_COORD_3             = 0x0DB5,
+		MAP2_TEXTURE_COORD_4             = 0x0DB6,
+		MAP2_VERTEX_3                    = 0x0DB7,
+		MAP2_VERTEX_4                    = 0x0DB8,
+		MAP1_GRID_DOMAIN                 = 0x0DD0,
+		MAP1_GRID_SEGMENTS               = 0x0DD1,
+		MAP2_GRID_DOMAIN                 = 0x0DD2,
+		MAP2_GRID_SEGMENTS               = 0x0DD3,
+		FEEDBACK_BUFFER_SIZE             = 0x0DF1,
+		FEEDBACK_BUFFER_TYPE             = 0x0DF2,
+		SELECTION_BUFFER_SIZE            = 0x0DF4,
+		VERTEX_ARRAY                     = 0x8074,
+		NORMAL_ARRAY                     = 0x8075,
+		COLOR_ARRAY                      = 0x8076,
+		INDEX_ARRAY                      = 0x8077,
+		TEXTURE_COORD_ARRAY              = 0x8078,
+		EDGE_FLAG_ARRAY                  = 0x8079,
+		VERTEX_ARRAY_SIZE                = 0x807A,
+		VERTEX_ARRAY_TYPE                = 0x807B,
+		VERTEX_ARRAY_STRIDE              = 0x807C,
+		NORMAL_ARRAY_TYPE                = 0x807E,
+		NORMAL_ARRAY_STRIDE              = 0x807F,
+		COLOR_ARRAY_SIZE                 = 0x8081,
+		COLOR_ARRAY_TYPE                 = 0x8082,
+		COLOR_ARRAY_STRIDE               = 0x8083,
+		INDEX_ARRAY_TYPE                 = 0x8085,
+		INDEX_ARRAY_STRIDE               = 0x8086,
+		TEXTURE_COORD_ARRAY_SIZE         = 0x8088,
+		TEXTURE_COORD_ARRAY_TYPE         = 0x8089,
+		TEXTURE_COORD_ARRAY_STRIDE       = 0x808A,
+		EDGE_FLAG_ARRAY_STRIDE           = 0x808C,
+		TEXTURE_COMPONENTS               = 0x1003,
+		TEXTURE_BORDER                   = 0x1005,
+		TEXTURE_LUMINANCE_SIZE           = 0x8060,
+		TEXTURE_INTENSITY_SIZE           = 0x8061,
+		TEXTURE_PRIORITY                 = 0x8066,
+		TEXTURE_RESIDENT                 = 0x8067,
+		AMBIENT                          = 0x1200,
+		DIFFUSE                          = 0x1201,
+		SPECULAR                         = 0x1202,
+		POSITION                         = 0x1203,
+		SPOT_DIRECTION                   = 0x1204,
+		SPOT_EXPONENT                    = 0x1205,
+		SPOT_CUTOFF                      = 0x1206,
+		CONSTANT_ATTENUATION             = 0x1207,
+		LINEAR_ATTENUATION               = 0x1208,
+		QUADRATIC_ATTENUATION            = 0x1209,
+		COMPILE                          = 0x1300,
+		COMPILE_AND_EXECUTE              = 0x1301,
+		_2_BYTES                         = 0x1407,
+		_3_BYTES                         = 0x1408,
+		_4_BYTES                         = 0x1409,
+		EMISSION                         = 0x1600,
+		SHININESS                        = 0x1601,
+		AMBIENT_AND_DIFFUSE              = 0x1602,
+		COLOR_INDEXES                    = 0x1603,
+		MODELVIEW                        = 0x1700,
+		PROJECTION                       = 0x1701,
+		COLOR_INDEX                      = 0x1900,
+		LUMINANCE                        = 0x1909,
+		LUMINANCE_ALPHA                  = 0x190A,
+		BITMAP                           = 0x1A00,
+		RENDER                           = 0x1C00,
+		FEEDBACK                         = 0x1C01,
+		SELECT                           = 0x1C02,
+		FLAT                             = 0x1D00,
+		SMOOTH                           = 0x1D01,
+		S                                = 0x2000,
+		T                                = 0x2001,
+		R                                = 0x2002,
+		Q                                = 0x2003,
+		MODULATE                         = 0x2100,
+		DECAL                            = 0x2101,
+		TEXTURE_ENV_MODE                 = 0x2200,
+		TEXTURE_ENV_COLOR                = 0x2201,
+		TEXTURE_ENV                      = 0x2300,
+		EYE_LINEAR                       = 0x2400,
+		OBJECT_LINEAR                    = 0x2401,
+		SPHERE_MAP                       = 0x2402,
+		TEXTURE_GEN_MODE                 = 0x2500,
+		OBJECT_PLANE                     = 0x2501,
+		CLAMP                            = 0x2900,
+		ALPHA4                           = 0x803B,
+		ALPHA8                           = 0x803C,
+		ALPHA12                          = 0x803D,
+		ALPHA16                          = 0x803E,
+		LUMINANCE4                       = 0x803F,
+		LUMINANCE8                       = 0x8040,
+		LUMINANCE12                      = 0x8041,
+		LUMINANCE16                      = 0x8042,
+		LUMINANCE4_ALPHA4                = 0x8043,
+		LUMINANCE6_ALPHA2                = 0x8044,
+		LUMINANCE8_ALPHA8                = 0x8045,
+		LUMINANCE12_ALPHA4               = 0x8046,
+		LUMINANCE12_ALPHA12              = 0x8047,
+		LUMINANCE16_ALPHA16              = 0x8048,
+		INTENSITY                        = 0x8049,
+		INTENSITY4                       = 0x804A,
+		INTENSITY8                       = 0x804B,
+		INTENSITY12                      = 0x804C,
+		INTENSITY16                      = 0x804D,
+		V2F                              = 0x2A20,
+		V3F                              = 0x2A21,
+		C4UB_V2F                         = 0x2A22,
+		C4UB_V3F                         = 0x2A23,
+		C3F_V3F                          = 0x2A24,
+		N3F_V3F                          = 0x2A25,
+		C4F_N3F_V3F                      = 0x2A26,
+		T2F_V3F                          = 0x2A27,
+		T4F_V4F                          = 0x2A28,
+		T2F_C4UB_V3F                     = 0x2A29,
+		T2F_C3F_V3F                      = 0x2A2A,
+		T2F_N3F_V3F                      = 0x2A2B,
+		T2F_C4F_N3F_V3F                  = 0x2A2C,
+		T4F_C4F_N3F_V4F                  = 0x2A2D,
+		CLIP_PLANE0                      = 0x3000,
+		CLIP_PLANE1                      = 0x3001,
+		CLIP_PLANE2                      = 0x3002,
+		CLIP_PLANE3                      = 0x3003,
+		CLIP_PLANE4                      = 0x3004,
+		CLIP_PLANE5                      = 0x3005,
+		LIGHT0                           = 0x4000,
+		LIGHT1                           = 0x4001,
+		LIGHT2                           = 0x4002,
+		LIGHT3                           = 0x4003,
+		LIGHT4                           = 0x4004,
+		LIGHT5                           = 0x4005,
+		LIGHT6                           = 0x4006,
+		LIGHT7                           = 0x4007,
 	};
 	
 	namespace _detail

glload/include/glload/_int_gl_1_2_rem.hpp

 {
 	enum
 	{
-		//RESCALE_NORMAL taken from 1.2
-		//LIGHT_MODEL_COLOR_CONTROL taken from 1.2
-		//SINGLE_COLOR taken from 1.2
-		//SEPARATE_SPECULAR_COLOR taken from 1.2
-		//ALIASED_POINT_SIZE_RANGE taken from 1.2
+		RESCALE_NORMAL                   = 0x803A,
+		LIGHT_MODEL_COLOR_CONTROL        = 0x81F8,
+		SINGLE_COLOR                     = 0x81F9,
+		SEPARATE_SPECULAR_COLOR          = 0x81FA,
+		ALIASED_POINT_SIZE_RANGE         = 0x846D,
 	};
 	
 	namespace _detail

glload/include/glload/_int_gl_1_3_rem.hpp

 {
 	enum
 	{
-		//CLIENT_ACTIVE_TEXTURE taken from 1.3
-		//MAX_TEXTURE_UNITS taken from 1.3
-		//TRANSPOSE_MODELVIEW_MATRIX taken from 1.3
-		//TRANSPOSE_PROJECTION_MATRIX taken from 1.3
-		//TRANSPOSE_TEXTURE_MATRIX taken from 1.3
-		//TRANSPOSE_COLOR_MATRIX taken from 1.3
-		//MULTISAMPLE_BIT taken from 1.3
-		//NORMAL_MAP taken from 1.3
-		//REFLECTION_MAP taken from 1.3
-		//COMPRESSED_ALPHA taken from 1.3
-		//COMPRESSED_LUMINANCE taken from 1.3
-		//COMPRESSED_LUMINANCE_ALPHA taken from 1.3
-		//COMPRESSED_INTENSITY taken from 1.3
-		//COMBINE taken from 1.3
-		//COMBINE_RGB taken from 1.3
-		//COMBINE_ALPHA taken from 1.3
-		//SOURCE0_RGB taken from 1.3
-		//SOURCE1_RGB taken from 1.3
-		//SOURCE2_RGB taken from 1.3
-		//SOURCE0_ALPHA taken from 1.3
-		//SOURCE1_ALPHA taken from 1.3
-		//SOURCE2_ALPHA taken from 1.3
-		//OPERAND0_RGB taken from 1.3
-		//OPERAND1_RGB taken from 1.3
-		//OPERAND2_RGB taken from 1.3
-		//OPERAND0_ALPHA taken from 1.3
-		//OPERAND1_ALPHA taken from 1.3
-		//OPERAND2_ALPHA taken from 1.3
-		//RGB_SCALE taken from 1.3
-		//ADD_SIGNED taken from 1.3
-		//INTERPOLATE taken from 1.3
-		//SUBTRACT taken from 1.3
-		//CONSTANT taken from 1.3
-		//PRIMARY_COLOR taken from 1.3
-		//PREVIOUS taken from 1.3
-		//DOT3_RGB taken from 1.3
-		//DOT3_RGBA taken from 1.3
+		CLIENT_ACTIVE_TEXTURE            = 0x84E1,
+		MAX_TEXTURE_UNITS                = 0x84E2,
+		TRANSPOSE_MODELVIEW_MATRIX       = 0x84E3,
+		TRANSPOSE_PROJECTION_MATRIX      = 0x84E4,
+		TRANSPOSE_TEXTURE_MATRIX         = 0x84E5,
+		TRANSPOSE_COLOR_MATRIX           = 0x84E6,
+		MULTISAMPLE_BIT                  = 0x20000000,
+		NORMAL_MAP                       = 0x8511,
+		REFLECTION_MAP                   = 0x8512,
+		COMPRESSED_ALPHA                 = 0x84E9,
+		COMPRESSED_LUMINANCE             = 0x84EA,
+		COMPRESSED_LUMINANCE_ALPHA       = 0x84EB,
+		COMPRESSED_INTENSITY             = 0x84EC,
+		COMBINE                          = 0x8570,
+		COMBINE_RGB                      = 0x8571,
+		COMBINE_ALPHA                    = 0x8572,
+		SOURCE0_RGB                      = 0x8580,
+		SOURCE1_RGB                      = 0x8581,
+		SOURCE2_RGB                      = 0x8582,
+		SOURCE0_ALPHA                    = 0x8588,
+		SOURCE1_ALPHA                    = 0x8589,
+		SOURCE2_ALPHA                    = 0x858A,
+		OPERAND0_RGB                     = 0x8590,
+		OPERAND1_RGB                     = 0x8591,
+		OPERAND2_RGB                     = 0x8592,
+		OPERAND0_ALPHA                   = 0x8598,
+		OPERAND1_ALPHA                   = 0x8599,
+		OPERAND2_ALPHA                   = 0x859A,
+		RGB_SCALE                        = 0x8573,
+		ADD_SIGNED                       = 0x8574,
+		INTERPOLATE                      = 0x8575,
+		SUBTRACT                         = 0x84E7,
+		CONSTANT                         = 0x8576,
+		PRIMARY_COLOR                    = 0x8577,
+		PREVIOUS                         = 0x8578,
+		DOT3_RGB                         = 0x86AE,
+		DOT3_RGBA                        = 0x86AF,
 	};
 	
 	namespace _detail

glload/include/glload/_int_gl_1_4_rem.hpp

 {
 	enum
 	{
-		//POINT_SIZE_MIN taken from 1.4
-		//POINT_SIZE_MAX taken from 1.4
-		//POINT_DISTANCE_ATTENUATION taken from 1.4
-		//GENERATE_MIPMAP taken from 1.4
-		//GENERATE_MIPMAP_HINT taken from 1.4
-		//FOG_COORDINATE_SOURCE taken from 1.4
-		//FOG_COORDINATE taken from 1.4
-		//FRAGMENT_DEPTH taken from 1.4
-		//CURRENT_FOG_COORDINATE taken from 1.4
-		//FOG_COORDINATE_ARRAY_TYPE taken from 1.4
-		//FOG_COORDINATE_ARRAY_STRIDE taken from 1.4
-		//FOG_COORDINATE_ARRAY_POINTER taken from 1.4
-		//FOG_COORDINATE_ARRAY taken from 1.4
-		//COLOR_SUM taken from 1.4
-		//CURRENT_SECONDARY_COLOR taken from 1.4
-		//SECONDARY_COLOR_ARRAY_SIZE taken from 1.4
-		//SECONDARY_COLOR_ARRAY_TYPE taken from 1.4
-		//SECONDARY_COLOR_ARRAY_STRIDE taken from 1.4
-		//SECONDARY_COLOR_ARRAY_POINTER taken from 1.4
-		//SECONDARY_COLOR_ARRAY taken from 1.4
-		//TEXTURE_FILTER_CONTROL taken from 1.4
-		//DEPTH_TEXTURE_MODE taken from 1.4
-		//COMPARE_R_TO_TEXTURE taken from 1.4
+		POINT_SIZE_MIN                   = 0x8126,
+		POINT_SIZE_MAX                   = 0x8127,
+		POINT_DISTANCE_ATTENUATION       = 0x8129,
+		GENERATE_MIPMAP                  = 0x8191,
+		GENERATE_MIPMAP_HINT             = 0x8192,
+		FOG_COORDINATE_SOURCE            = 0x8450,
+		FOG_COORDINATE                   = 0x8451,
+		FRAGMENT_DEPTH                   = 0x8452,
+		CURRENT_FOG_COORDINATE           = 0x8453,
+		FOG_COORDINATE_ARRAY_TYPE        = 0x8454,
+		FOG_COORDINATE_ARRAY_STRIDE      = 0x8455,
+		FOG_COORDINATE_ARRAY_POINTER     = 0x8456,
+		FOG_COORDINATE_ARRAY             = 0x8457,
+		COLOR_SUM                        = 0x8458,
+		CURRENT_SECONDARY_COLOR          = 0x8459,
+		SECONDARY_COLOR_ARRAY_SIZE       = 0x845A,
+		SECONDARY_COLOR_ARRAY_TYPE       = 0x845B,
+		SECONDARY_COLOR_ARRAY_STRIDE     = 0x845C,
+		SECONDARY_COLOR_ARRAY_POINTER    = 0x845D,
+		SECONDARY_COLOR_ARRAY            = 0x845E,
+		TEXTURE_FILTER_CONTROL           = 0x8500,
+		DEPTH_TEXTURE_MODE               = 0x884B,
+		COMPARE_R_TO_TEXTURE             = 0x884E,
 	};
 	
 	namespace _detail

glload/include/glload/_int_gl_1_5_rem.hpp

 {
 	enum
 	{
-		//VERTEX_ARRAY_BUFFER_BINDING taken from 1.5
-		//NORMAL_ARRAY_BUFFER_BINDING taken from 1.5
-		//COLOR_ARRAY_BUFFER_BINDING taken from 1.5
-		//INDEX_ARRAY_BUFFER_BINDING taken from 1.5
-		//TEXTURE_COORD_ARRAY_BUFFER_BINDING taken from 1.5
-		//EDGE_FLAG_ARRAY_BUFFER_BINDING taken from 1.5
-		//SECONDARY_COLOR_ARRAY_BUFFER_BINDING taken from 1.5
-		//FOG_COORDINATE_ARRAY_BUFFER_BINDING taken from 1.5
-		//WEIGHT_ARRAY_BUFFER_BINDING taken from 1.5
-		//FOG_COORD_SRC taken from 1.5
-		//FOG_COORD taken from 1.5
-		//CURRENT_FOG_COORD taken from 1.5
-		//FOG_COORD_ARRAY_TYPE taken from 1.5
-		//FOG_COORD_ARRAY_STRIDE taken from 1.5
-		//FOG_COORD_ARRAY_POINTER taken from 1.5
-		//FOG_COORD_ARRAY taken from 1.5
-		//FOG_COORD_ARRAY_BUFFER_BINDING taken from 1.5
-		//SRC0_RGB taken from 1.5
-		//SRC1_RGB taken from 1.5
-		//SRC2_RGB taken from 1.5
-		//SRC0_ALPHA taken from 1.5
-		//SRC2_ALPHA taken from 1.5
+		VERTEX_ARRAY_BUFFER_BINDING      = 0x8896,
+		NORMAL_ARRAY_BUFFER_BINDING      = 0x8897,
+		COLOR_ARRAY_BUFFER_BINDING       = 0x8898,
+		INDEX_ARRAY_BUFFER_BINDING       = 0x8899,
+		TEXTURE_COORD_ARRAY_BUFFER_BINDING = 0x889A,
+		EDGE_FLAG_ARRAY_BUFFER_BINDING   = 0x889B,
+		SECONDARY_COLOR_ARRAY_BUFFER_BINDING = 0x889C,
+		FOG_COORDINATE_ARRAY_BUFFER_BINDING = 0x889D,
+		WEIGHT_ARRAY_BUFFER_BINDING      = 0x889E,
+		FOG_COORD_SRC                    = 0x8450,
+		FOG_COORD                        = 0x8451,
+		CURRENT_FOG_COORD                = 0x8453,
+		FOG_COORD_ARRAY_TYPE             = 0x8454,
+		FOG_COORD_ARRAY_STRIDE           = 0x8455,
+		FOG_COORD_ARRAY_POINTER          = 0x8456,
+		FOG_COORD_ARRAY                  = 0x8457,
+		FOG_COORD_ARRAY_BUFFER_BINDING   = 0x889D,
+		SRC0_RGB                         = 0x8580,
+		SRC1_RGB                         = 0x8581,
+		SRC2_RGB                         = 0x8582,
+		SRC0_ALPHA                       = 0x8588,
+		SRC2_ALPHA                       = 0x858A,
 	};
 	
 	namespace _detail