Add a unified cross platform OpenGL core profile binding (#52)

.gitignore

@@ -12,3 +12,6 @@ libs/*
 *.exe
 *.dll
 bin/Linux
+scripts/gl2ext.h
+scripts/glcorearb.h
+scripts/glext.h

include/IContextManager.h

@@ -7,6 +7,7 @@
 
 #include "SExposedVideoData.h"
 #include "SIrrCreationParameters.h"
+#include <string>
 
 namespace irr
 {
@@ -48,6 +49,9 @@ namespace video
 			Note that only 1 thread at a time may access an OpenGL context.	*/
 		virtual bool activateContext(const SExposedVideoData& videoData, bool restorePrimaryOnZero=false) =0;
 
+		//! Get the address of any OpenGL procedure (including core procedures).
+		virtual void* getProcAddress(const std::string &procName) =0;
+
         //! Swap buffers.
         virtual bool swapBuffers() =0;
 	};

scripts/BindingGenerator.lua

@@ -0,0 +1,430 @@
+#!/usr/bin/lua
+-- BindingGenerator.lua (c) hecks 2021
+-- This script is a part of IrrlichtMT, released under the same license.
+
+-- By default we assume you're running this from /scripts/
+-- and that you have the necessary headers there (gitignored for your convenience)
+local sourceTreePath = os.getenv( "IRRMTREPO" ) or "..";
+-- Otherwise run this from wherever you want and set the above env variable.
+local glHeaderPath = os.getenv( "GLHEADERPATH" ) or ".";
+-- GL headers will be looked for in the current directory or GLHEADERPATH.
+-- At the moment we require:
+-- 		"glcorearb.h"
+-- 		"gl2ext.h"
+-- Files other than glcorearb.h are only parsed for vendor specific defines
+-- and aliases. Otherwise we only use what exists in glcorearb.h, further
+-- restricted to procedures that are either core or ARB.
+
+
+-- Emulate a portion of the libraries that this was written against.
+getmetatable( "" ).__index = string;
+getmetatable( "" ).__len = string.len;
+getmetatable( "" ).__call = string.format;
+function string:Split( pat )
+	local r = {};
+	local pos = 1;
+	local from, to;
+	while pos and pos <= #self do
+		from, to = self:find( pat, pos );
+		if not from then
+			break;
+		end
+		r[#r+1] = self:sub( pos, from - 1 );
+		pos = to + 1;
+	end
+	r[#r+1] = self:sub( pos, #self );
+	return r;
+end
+function string:TrimBothEnds()
+	return self:gsub("^%s+",""):gsub("%s+$","");
+end
+local List;
+List = function( t )
+	return setmetatable( t or {}, {
+		__index = {
+			Add = function( t, v )
+				t[#t+1] = v;
+			end;
+			AddFormat = function( t, str, ... )
+				t:Add( str( ... ) );
+			end;
+			Where = function( t, f )
+				local r = {};
+				for i=1, #t do
+					if f(t[i]) then r[#r+1] = t[i]; end
+				end
+				return List( r );
+			end;
+			Select = function( t, f )
+				local r = {};
+				for i=1, #t do
+					r[#r+1] = f( t[i] );
+				end
+				return List( r );
+			end;
+			Join = function( t, n )
+				local r = {};
+				for i=1, #t do
+					r[i] = t[i];
+				end
+				for i=1, #n do
+					r[#r+1] = n[i];
+				end
+				return List( r );
+			end;
+			Concat = table.concat;
+		};
+	} );
+end
+
+
+------------ Header parsing ------------
+
+-- GL and GLES alike
+local driverVendors = {
+	"NV", "AMD", "INTEL", "OVR", "QCOM", "IMG", "ANGLE", "APPLE", "MESA"
+}
+local vendorSuffixes = {
+	"ARB", "EXT", "KHR", "OES",
+	unpack( driverVendors )
+};
+local vendorSuffixPattern = {};
+local constSuffixPattern = {};
+for i=1, #vendorSuffixes do
+	vendorSuffixPattern[i] = vendorSuffixes[i] .. "$";
+	constSuffixPattern[i] = ("_%s$")( vendorSuffixes[i] );
+end
+local constBanned = {};
+for i=1, #driverVendors do
+	constBanned[driverVendors[i]] = true;
+end
+-- Strip the uppercase extension vendor suffix from a name.
+local function StripVendorSuffix( str, const )
+	local patterns = const and constSuffixPattern or vendorSuffixPattern;
+	local n;
+	for i=1, #patterns do
+		str, n = str:gsub( patterns[i], "" );
+		if n > 0 then
+			return str, vendorSuffixes[i];
+		end
+	end
+	return str;
+end
+
+-- Normalize the type of an argument or return, also stripping any suffix
+-- and normalizing all whitespace regions to single spaces.
+local function NormalizeType( str )
+	local chunks = str:Split( "%s+" );
+	for j=1, #chunks do
+		chunks[j] = StripVendorSuffix( chunks[j] );
+	end
+	local T = table.concat(chunks, " " );
+	return T:TrimBothEnds();
+end
+
+-- Normalize an argument, returning the normalized type and the name separately,
+-- always sticking the * of a pointer to the type rather than the name.
+-- We need this to generate a normalized arg list and function signature (below)
+local function NormalizeArgument( str )
+	local chunks = str:Split( "%s+" );
+	for j=1, #chunks do
+		chunks[j] = StripVendorSuffix( chunks[j] );
+	end
+	local last = chunks[#chunks];
+	local name = last:match( "[%w_]+$" );
+	chunks[#chunks] = #name ~= #last and last:sub( 1, #last-#name) or nil;
+	local T = table.concat(chunks, " " ):TrimBothEnds();
+	return T, name
+end
+
+-- Normalize an argument list so that two matching prototypes
+-- will produce the same table if fed to this function.
+local function NormalizeArgList( str )
+	local args = str:Split( ",%s*" );
+	local r = {};
+	for i=1, #args do
+		local T, name = NormalizeArgument( args[i] );
+		r[i] = { T, name };
+	end
+	return r;
+end
+
+-- Normalize a function signature into a unique string for keying
+-- in such a way that if two different GL procedures may be assigned
+-- to the same function pointer, this will produce an identical string for both.
+-- This makes it possible to detect function aliases that may work as a fallback.
+-- You still have to check for the appropriate extension.
+local function NormalizeFunctionSignature( T, str )
+	local args = str:Split( ",%s*" );
+	local r = {};
+	for i=1, #args do
+		r[i] = NormalizeArgument( args[i] );
+	end
+	return ("%s(%s)")( T, table.concat( r, ", " ) );
+end
+
+-- Mangle the PFN name so that we don't collide with a
+-- typedef from any of the GL headers.
+local pfnFormat = "PFNGL%sPROC_MT";
+
+--( T, name, args )
+local typedefFormat = "\ttypedef %s (APIENTRYP %s) (%s);"
+-- Generate a PFN...GL style typedef for a procedure
+--
+local function GetProcedureTypedef( proc )
+	local args = {};
+	for i=1, #proc.args do
+		args[i] = ("%s %s")( unpack( proc.args[i] ) )
+	end
+	return typedefFormat( proc.retType, pfnFormat( proc.name:upper() ), table.concat( args, ", " ) );
+end
+
+local procedures = List();
+local nameset = {};
+local definitions = List();
+local consts = List();
+
+--[[
+	Structured procedure representation:
+
+	ProcSpec = {
+		string name;		-- Normalized name as it appears in the GL spec
+		string? vendor;		-- Uppercase vendor string (ARB, EXT, AMD, NV etc)
+		string signature;
+		string retType;
+		args = { { type, name } };
+	};
+]]
+-- Parse a whole header, extracting the data.
+local function ParseHeader( path, into, apiRegex, defs, consts, nameSet, noNewNames )
+	defs:AddFormat( "\t// %s", path );
+	local f = assert( io.open( path, "r" ), "Could not open " .. path );
+	for line in f:lines() do
+		-- Do not parse PFN typedefs; they're easily reconstructible.
+		local T, rawName, args = line:match( apiRegex );
+		if T then
+			T = NormalizeType( T );
+			-- Strip the 'gl' namespace prefix.
+			local procName = rawName:sub(3,-1);
+			local name, vendor = StripVendorSuffix( procName );
+			if not (noNewNames and nameSet[name]) then
+				nameSet[name] = true;
+				into:Add{
+					name = name;
+					vendor = vendor;
+					-- pfnType = pfnFormat( procName:upper() );
+					signature = NormalizeFunctionSignature( T, args );
+					retType = T;
+					args = NormalizeArgList( args );
+				};
+			end
+		elseif ( line:find( "#" ) and not line:find( "#include" ) ) then
+			local rawName, value = line:match( "#define%s+GL_([_%w]+)%s+0x(%w+)" );
+			if rawName and value then
+				local name, vendor = StripVendorSuffix( rawName, true );
+				if not constBanned[vendor] then
+					consts:Add{ name = name, vendor = vendor, value = "0x"..value };
+				end
+			end
+			::skip::
+		elseif( line:find( "typedef" ) and not line:find( "%(" ) ) then
+			-- Passthrough non-PFN typedefs
+			defs:Add( "\t" .. line );
+		end
+	end
+	defs:Add "";
+	f:close();
+end
+
+------------ Parse the headers ------------
+
+-- ES/gl2.h is a subset of glcorearb.h and does not need parsing.
+
+local funcRegex = "GLAPI%s+(.+)APIENTRY%s+(%w+)%s*%((.*)%)";
+local funcRegexES = "GL_APICALL%s+(.+)GL_APIENTRY%s+(%w+)%s*%((.*)%)";
+ParseHeader( glHeaderPath .. "/glcorearb.h", procedures, funcRegex, definitions, consts, nameset );
+ParseHeader( glHeaderPath .. "/gl2ext.h", procedures, funcRegexES, List(), consts, nameset, true );
+-- Typedefs are redirected to a dummy list here on purpose.
+-- The only unique typedef from gl2ext is this:
+definitions:Add "\ttypedef void *GLeglClientBufferEXT;";
+
+------------ Sort out constants ------------
+
+local cppConsts = List();
+do
+	local constBuckets = {};
+	for i=1, #consts do
+		local vendor = consts[i].vendor or "core";
+		constBuckets[consts[i].name] = constBuckets[consts[i].name] or {};
+		constBuckets[consts[i].name][vendor] = consts[i].value;
+	end
+	local names = {};
+	for i=1, #consts do
+		local k = consts[i].name;
+		local b = constBuckets[k];
+		if k == "WAIT_FAILED" or k == "DIFFERENCE" then
+			-- This is why using #define as const is evil.
+			k = "_" .. k;
+		end
+		if b and not names[k] then
+			names[k] = true;
+			-- I have empirically tested that constants in GL with the same name do not differ,
+			-- at least for these suffixes.
+			local v = b.core or b.KHR or b.ARB or b.OES or b.EXT;
+			if v then
+				local T = v:find( "ull" ) and "GLuint64" or "GLenum";
+				cppConsts:AddFormat( "\tstatic constexpr const %s %s = %s;", T, k, v );
+			end
+		end
+	end
+end
+
+
+------------ Sort out procedures ------------
+
+local procTable = {};
+
+local coreProcedures = procedures:Where( function(x) return not x.vendor; end );
+local arbProcedures = procedures:Where( function(x) return x.vendor == "ARB"; end );
+
+-- Only consider core and ARB functions.
+local nameList = coreProcedures:Join( arbProcedures ):Select(
+	function(p)
+		return p.name;
+	end );
+
+local nameSet = {};
+local uniqueNames = List();
+
+for s, k in ipairs( nameList ) do
+	if not nameSet[k] then
+		nameSet[k] = true;
+		uniqueNames:Add( k );
+	end
+end
+
+for i=1, #procedures do
+	local p = procedures[i];
+	procTable[p.name] = procTable[p.name] or {};
+	local key = p.vendor or "core";
+	procTable[p.name][key] = p;
+end
+
+local priorityList = List{ "core", "ARB", "OES", "KHR" };
+
+local typedefs = List();
+local pointers = List();
+local loader = List();
+
+for s, str in ipairs( uniqueNames ) do
+	pointers:Add( ("\t%s %s = NULL;")( pfnFormat( str:upper() ), str ) );
+	local typeDefGenerated = false;
+	for i=1, #priorityList do
+		local k = priorityList[i];
+		local proc = procTable[str][k]
+		if proc then
+			if not typeDefGenerated then
+				typedefs:Add( GetProcedureTypedef( proc ) );
+				typeDefGenerated = true;
+			end
+			local vendor = k == "core" and "" or k;
+			loader:AddFormat(
+				'\tif (!%s) %s = (%s)cmgr->getProcAddress("%s");\n',
+				str, str, pfnFormat( proc.name:upper() ), ("gl%s%s")(str,vendor)
+			);
+		end
+	end
+end
+
+
+------------ Write files ------------
+
+-- Write loader header
+local f = io.open( sourceTreePath .. "/include/mt_opengl.h", "wb" );
+f:write[[
+// This code was generated by scripts/BindingGenerator.lua
+// Do not modify it, modify and run the generator instead.
+
+#pragma once
+
+#include <string>
+#include <unordered_set>
+#include "IrrCompileConfig.h"
+#include "irrTypes.h"
+#include "IContextManager.h"
+#include <KHR/khrplatform.h>
+
+#ifndef APIENTRY
+	#define APIENTRY
+#endif
+#ifndef APIENTRYP
+	#define APIENTRYP APIENTRY *
+#endif
+#ifndef GLAPI
+	#define GLAPI extern
+#endif
+
+]];
+
+f:write[[
+class OpenGLProcedures {
+private:
+]];
+f:write( definitions:Concat( "\n" ) );
+f:write( "\n" );
+f:write[[
+	// The script will miss this particular typedef thinking it's a PFN,
+	// so we have to paste it in manually. It's the only such type in OpenGL.
+	typedef void (APIENTRY *GLDEBUGPROC)
+		(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam);
+
+]]
+f:write( typedefs:Concat( "\n" ) );
+f:write( "\n\n" );
+f:write [[
+	std::unordered_set<std::string> extensions;
+public:
+	// Call this once after creating the context.
+	void LoadAllProcedures(irr::video::IContextManager *cmgr);
+	// Check if an extension is supported.
+	inline bool IsExtensionPresent(const std::string &ext)
+	{
+		return extensions.find(ext) != extensions.end();
+	}
+
+]];
+f:write( pointers:Concat( "\n" ) );
+f:write( "\n\n" );
+f:write( cppConsts:Concat( "\n" ) );
+f:write( "\n\n" );
+f:write( "};\n" );
+f:write( "\n//Global GL procedures object.\n" );
+f:write( "IRRLICHT_API extern OpenGLProcedures GL;\n" );
+f:close();
+
+-- Write loader implementation
+f = io.open( sourceTreePath .. "/source/Irrlicht/mt_opengl_loader.cpp", "wb" );
+f:write[[
+#include "mt_opengl.h"
+#include <string>
+#include <sstream>
+
+OpenGLProcedures GL = OpenGLProcedures();
+
+void OpenGLProcedures::LoadAllProcedures(irr::video::IContextManager *cmgr)
+{
+
+]];
+f:write( loader:Concat() );
+f:write[[
+
+	// get the extension string, chop it up
+	std::string ext_string = std::string((char*)GetString(EXTENSIONS));
+	std::stringstream ext_ss(ext_string);
+	std::string tmp;
+	while (std::getline(ext_ss, tmp, ' '))
+		extensions.emplace(tmp);
+
+}
+]];
+f:close();

source/Irrlicht/CEGLManager.cpp

@@ -9,6 +9,7 @@
 #include "irrString.h"
 #include "irrArray.h"
 #include "os.h"
+#include <dlfcn.h>
 
 #if defined(_IRR_COMPILE_WITH_ANDROID_DEVICE_)
 #include <android/native_activity.h>
@@ -20,7 +21,7 @@ namespace video
 {
 
 CEGLManager::CEGLManager() : IContextManager(), EglWindow(0), EglDisplay(EGL_NO_DISPLAY),
-    EglSurface(EGL_NO_SURFACE), EglContext(EGL_NO_CONTEXT), EglConfig(0), MajorVersion(0), MinorVersion(0)
+    EglSurface(EGL_NO_SURFACE), EglContext(EGL_NO_CONTEXT), EglConfig(0), MajorVersion(0), MinorVersion(0), libHandle(NULL)
 {
 	#ifdef _DEBUG
 	setDebugName("CEGLManager");
@@ -109,6 +110,9 @@ void CEGLManager::terminate()
 
     MajorVersion = 0;
     MinorVersion = 0;
+
+	if (libHandle)
+		dlclose(libHandle);
 }
 
 bool CEGLManager::generateSurface()
@@ -590,6 +594,19 @@ const SExposedVideoData& CEGLManager::getContext() const
 	return Data;
 }
 
+void* CEGLManager::getProcAddress(const std::string &procName)
+{
+	void* proc = NULL;
+	proc = (void*)eglGetProcAddress(procName.c_str());
+	if (!proc) { // fallback
+		if (!libHandle)
+			libHandle = dlopen("libGLESv2.so", RTLD_LAZY);
+		if (libHandle)
+			proc = dlsym(libHandle, procName.c_str());
+	}
+	return proc;
+}
+
 bool CEGLManager::swapBuffers()
 {
     return (eglSwapBuffers(EglDisplay, EglSurface)==EGL_TRUE);

source/Irrlicht/CEGLManager.h

@@ -67,6 +67,9 @@ namespace video
 
 		virtual bool activateContext(const SExposedVideoData& videoData, bool restorePrimaryOnZero) _IRR_OVERRIDE_;
 
+		// Get procedure address.
+		virtual void* getProcAddress(const std::string &procName) _IRR_OVERRIDE_;
+
 		// Swap buffers.
 		virtual bool swapBuffers() _IRR_OVERRIDE_;
 
@@ -112,6 +115,8 @@ namespace video
 
 		EGLint MajorVersion;
 		EGLint MinorVersion;
+
+		void* libHandle;
 	};
 }
 }

source/Irrlicht/CGLXManager.cpp

@@ -7,6 +7,7 @@
 #ifdef _IRR_COMPILE_WITH_GLX_MANAGER_
 
 #include "os.h"
+#include <dlfcn.h>
 
 #if defined(_IRR_OPENGL_USE_EXTPOINTER_)
 	#define GL_GLEXT_LEGACY 1
@@ -28,7 +29,7 @@ namespace video
 {
 
 CGLXManager::CGLXManager(const SIrrlichtCreationParameters& params, const SExposedVideoData& videodata, int screennr)
-	: Params(params), PrimaryContext(videodata), VisualInfo(0), glxFBConfig(0), GlxWin(0)
+	: Params(params), PrimaryContext(videodata), VisualInfo(0), glxFBConfig(0), GlxWin(0), libHandle(NULL)
 {
 	#ifdef _DEBUG
 	setDebugName("CGLXManager");
@@ -279,6 +280,8 @@ bool CGLXManager::initialize(const SIrrlichtCreationParameters& params, const SE
 
 void CGLXManager::terminate()
 {
+	if (libHandle)
+		dlclose(libHandle);
 	memset(&CurrentContext, 0, sizeof(CurrentContext));
 }
 
@@ -428,6 +431,19 @@ void CGLXManager::destroyContext()
 	}
 }
 
+void* CGLXManager::getProcAddress(const std::string &procName)
+{
+	void* proc = NULL;
+	proc = (void*)glXGetProcAddressARB(reinterpret_cast<const GLubyte*>(procName.c_str()));
+	if (!proc) {
+		if (!libHandle)
+			libHandle = dlopen("libGL.so", RTLD_LAZY);
+		if (libHandle)
+			proc = dlsym(libHandle, procName.c_str());
+	}
+	return proc;
+}
+
 bool CGLXManager::swapBuffers()
 {
 	glXSwapBuffers((Display*)CurrentContext.OpenGLLinux.X11Display, CurrentContext.OpenGLLinux.GLXWindow);

source/Irrlicht/CGLXManager.h

@@ -57,6 +57,9 @@ namespace video
         //! Change render context, disable old and activate new defined by videoData
         virtual bool activateContext(const SExposedVideoData& videoData, bool restorePrimaryOnZero) _IRR_OVERRIDE_;
 
+		// Get procedure address.
+		virtual void* getProcAddress(const std::string &procName) _IRR_OVERRIDE_;
+
         // Swap buffers.
         virtual bool swapBuffers() _IRR_OVERRIDE_;
 
@@ -69,6 +72,7 @@ namespace video
         XVisualInfo* VisualInfo;
         void* glxFBConfig; // GLXFBConfig
         XID GlxWin; // GLXWindow
+		void* libHandle; // handle to libGL.so
 	};
 }
 }

source/Irrlicht/CMakeLists.txt

@@ -10,6 +10,8 @@ if(CMAKE_BUILD_TYPE STREQUAL "Debug")
 	add_definitions(-D_DEBUG)
 endif()
 set(CMAKE_POSITION_INDEPENDENT_CODE TRUE)
+set(CMAKE_CXX_STANDARD 11)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
 if(CMAKE_CXX_COMPILER_ID MATCHES "^(GNU|Clang|AppleClang)$")
 	set(CMAKE_CXX_FLAGS_RELEASE "-O3")
@@ -153,6 +155,7 @@ set(IRRDRVROBJ
 	CGLXManager.cpp
 	CWGLManager.cpp
 	CEGLManager.cpp
+	mt_opengl_loader.cpp
 )
 
 set(IRRIMAGEOBJ

source/Irrlicht/CNSOGLManager.h

@@ -54,6 +54,9 @@ namespace video
 		//! Change render context, disable old and activate new defined by videoData
 		bool activateContext(const SExposedVideoData& videoData, bool restorePrimaryOnZero) _IRR_OVERRIDE_;
 
+		// Get procedure address.
+		virtual void* getProcAddress(const std::string &procName) _IRR_OVERRIDE_;
+
         // Swap buffers.
         bool swapBuffers();
 

source/Irrlicht/CNSOGLManager.mm

@@ -6,6 +6,7 @@
 
 #ifdef _IRR_COMPILE_WITH_NSOGL_MANAGER_
 
+#include <mach-o/dyld.h>
 #include "os.h"
 
 namespace irr
@@ -230,6 +231,18 @@ void CNSOGLManager::destroyContext()
 	}
 }
 
+// It appears that there is no separate GL proc address getter on OSX.
+// https://developer.apple.com/library/archive/documentation/GraphicsImaging/Conceptual/OpenGL-MacProgGuide/opengl_entrypts/opengl_entrypts.html
+void* CNSOGLManager::getProcAddress(const std::string &procName)
+{
+	NSSymbol symbol = NULL;
+	// Allocate a buffer for the name, an underscore prefix, and a cstring terminator.
+	std::string mangledName = "_" + procName;
+	if (NSIsSymbolNameDefined(mangledName.c_str()))
+		symbol = NSLookupAndBindSymbol(mangledName.c_str());
+	return symbol ? NSAddressOfSymbol(symbol) : NULL;
+}
+
 bool CNSOGLManager::swapBuffers()
 {
     [(NSOpenGLContext*)CurrentContext.OpenGLOSX.Context flushBuffer];

source/Irrlicht/COGLES2Driver.cpp

@@ -29,6 +29,8 @@
 #include "android_native_app_glue.h"
 #endif
 
+#include "mt_opengl.h"
+
 namespace irr
 {
 namespace video
@@ -76,6 +78,7 @@ COGLES2Driver::COGLES2Driver(const SIrrlichtCreationParameters& params, io::IFil
 	ContextManager->generateContext();
 	ExposedData = ContextManager->getContext();
 	ContextManager->activateContext(ExposedData, false);
+	GL.LoadAllProcedures(ContextManager);
 }
 
 COGLES2Driver::~COGLES2Driver()

source/Irrlicht/COpenGLDriver.cpp

@@ -20,6 +20,8 @@
 #include "COpenGLCoreTexture.h"
 #include "COpenGLCoreRenderTarget.h"
 
+#include "mt_opengl.h"
+
 #ifdef _IRR_COMPILE_WITH_SDL_DEVICE_
 #include <SDL/SDL.h>
 #endif
@@ -80,6 +82,8 @@ bool COpenGLDriver::initDriver()
 	extGlSwapInterval(Params.Vsync ? 1 : 0);
 #endif
 
+	GL.LoadAllProcedures(ContextManager);
+
 	return true;
 }
 

source/Irrlicht/CWGLManager.cpp

@@ -21,7 +21,7 @@ namespace video
 {
 
 CWGLManager::CWGLManager()
-	: PrimaryContext(SExposedVideoData(0)), PixelFormat(0)
+	: PrimaryContext(SExposedVideoData(0)), PixelFormat(0), libHandle(NULL)
 {
 	#ifdef _DEBUG
 	setDebugName("CWGLManager");
@@ -322,6 +322,8 @@ void CWGLManager::terminate()
 	if (PrimaryContext.OpenGLWin32.HDc && PrimaryContext.OpenGLWin32.HDc == CurrentContext.OpenGLWin32.HDc)
 		memset(&PrimaryContext, 0, sizeof(PrimaryContext));
 	memset(&CurrentContext, 0, sizeof(CurrentContext));
+	if (libHandle)
+		FreeLibrary(libHandle);
 }
 
 bool CWGLManager::generateSurface()
@@ -490,6 +492,19 @@ void CWGLManager::destroyContext()
 	}
 }
 
+void* CWGLManager::getProcAddress(const std::string &procName)
+{
+	void* proc = NULL;
+	proc = (void*)wglGetProcAddress(procName.c_str());
+	if (!proc) { // Fallback
+		if (!libHandle)
+			libHandle = LoadLibraryA("opengl32.dll");
+		if (libHandle)
+			proc = (void*)GetProcAddress(libHandle, procName.c_str());
+	}
+	return proc;
+}
+
 bool CWGLManager::swapBuffers()
 {
 	return SwapBuffers((HDC)CurrentContext.OpenGLWin32.HDc) == TRUE;

source/Irrlicht/CWGLManager.h

@@ -16,6 +16,7 @@
 
 #define WIN32_LEAN_AND_MEAN
 #include <windows.h>
+#include <libloaderapi.h>
 
 namespace irr
 {
@@ -55,6 +56,9 @@ namespace video
 		//! Change render context, disable old and activate new defined by videoData
 		virtual bool activateContext(const SExposedVideoData& videoData, bool restorePrimaryOnZero) _IRR_OVERRIDE_;
 
+		// Get procedure address.
+		virtual void* getProcAddress(const std::string &procName) _IRR_OVERRIDE_;
+
         // Swap buffers.
         virtual bool swapBuffers() _IRR_OVERRIDE_;
 
@@ -66,6 +70,8 @@ namespace video
 		PIXELFORMATDESCRIPTOR pfd;
 		ECOLOR_FORMAT ColorFormat;
         void* FunctionPointers[1];
+
+		HMODULE libHandle;
 	};
 }
 }

source/Irrlicht/mt_opengl_loader.cpp

@@ -0,0 +1,766 @@
+#include "mt_opengl.h"
+#include <string>
+#include <sstream>
+
+OpenGLProcedures GL = OpenGLProcedures();
+
+void OpenGLProcedures::LoadAllProcedures(irr::video::IContextManager *cmgr)
+{
+
+	if (!CullFace) CullFace = (PFNGLCULLFACEPROC_MT)cmgr->getProcAddress("glCullFace");
+	if (!FrontFace) FrontFace = (PFNGLFRONTFACEPROC_MT)cmgr->getProcAddress("glFrontFace");
+	if (!Hint) Hint = (PFNGLHINTPROC_MT)cmgr->getProcAddress("glHint");
+	if (!LineWidth) LineWidth = (PFNGLLINEWIDTHPROC_MT)cmgr->getProcAddress("glLineWidth");
+	if (!PointSize) PointSize = (PFNGLPOINTSIZEPROC_MT)cmgr->getProcAddress("glPointSize");
+	if (!PolygonMode) PolygonMode = (PFNGLPOLYGONMODEPROC_MT)cmgr->getProcAddress("glPolygonMode");
+	if (!Scissor) Scissor = (PFNGLSCISSORPROC_MT)cmgr->getProcAddress("glScissor");
+	if (!TexParameterf) TexParameterf = (PFNGLTEXPARAMETERFPROC_MT)cmgr->getProcAddress("glTexParameterf");
+	if (!TexParameterfv) TexParameterfv = (PFNGLTEXPARAMETERFVPROC_MT)cmgr->getProcAddress("glTexParameterfv");
+	if (!TexParameteri) TexParameteri = (PFNGLTEXPARAMETERIPROC_MT)cmgr->getProcAddress("glTexParameteri");
+	if (!TexParameteriv) TexParameteriv = (PFNGLTEXPARAMETERIVPROC_MT)cmgr->getProcAddress("glTexParameteriv");
+	if (!TexImage1D) TexImage1D = (PFNGLTEXIMAGE1DPROC_MT)cmgr->getProcAddress("glTexImage1D");
+	if (!TexImage2D) TexImage2D = (PFNGLTEXIMAGE2DPROC_MT)cmgr->getProcAddress("glTexImage2D");
+	if (!DrawBuffer) DrawBuffer = (PFNGLDRAWBUFFERPROC_MT)cmgr->getProcAddress("glDrawBuffer");
+	if (!Clear) Clear = (PFNGLCLEARPROC_MT)cmgr->getProcAddress("glClear");
+	if (!ClearColor) ClearColor = (PFNGLCLEARCOLORPROC_MT)cmgr->getProcAddress("glClearColor");
+	if (!ClearStencil) ClearStencil = (PFNGLCLEARSTENCILPROC_MT)cmgr->getProcAddress("glClearStencil");
+	if (!ClearDepth) ClearDepth = (PFNGLCLEARDEPTHPROC_MT)cmgr->getProcAddress("glClearDepth");
+	if (!StencilMask) StencilMask = (PFNGLSTENCILMASKPROC_MT)cmgr->getProcAddress("glStencilMask");
+	if (!ColorMask) ColorMask = (PFNGLCOLORMASKPROC_MT)cmgr->getProcAddress("glColorMask");
+	if (!DepthMask) DepthMask = (PFNGLDEPTHMASKPROC_MT)cmgr->getProcAddress("glDepthMask");
+	if (!Disable) Disable = (PFNGLDISABLEPROC_MT)cmgr->getProcAddress("glDisable");
+	if (!Enable) Enable = (PFNGLENABLEPROC_MT)cmgr->getProcAddress("glEnable");
+	if (!Finish) Finish = (PFNGLFINISHPROC_MT)cmgr->getProcAddress("glFinish");
+	if (!Flush) Flush = (PFNGLFLUSHPROC_MT)cmgr->getProcAddress("glFlush");
+	if (!BlendFunc) BlendFunc = (PFNGLBLENDFUNCPROC_MT)cmgr->getProcAddress("glBlendFunc");
+	if (!LogicOp) LogicOp = (PFNGLLOGICOPPROC_MT)cmgr->getProcAddress("glLogicOp");
+	if (!StencilFunc) StencilFunc = (PFNGLSTENCILFUNCPROC_MT)cmgr->getProcAddress("glStencilFunc");
+	if (!StencilOp) StencilOp = (PFNGLSTENCILOPPROC_MT)cmgr->getProcAddress("glStencilOp");
+	if (!DepthFunc) DepthFunc = (PFNGLDEPTHFUNCPROC_MT)cmgr->getProcAddress("glDepthFunc");
+	if (!PixelStoref) PixelStoref = (PFNGLPIXELSTOREFPROC_MT)cmgr->getProcAddress("glPixelStoref");
+	if (!PixelStorei) PixelStorei = (PFNGLPIXELSTOREIPROC_MT)cmgr->getProcAddress("glPixelStorei");
+	if (!ReadBuffer) ReadBuffer = (PFNGLREADBUFFERPROC_MT)cmgr->getProcAddress("glReadBuffer");
+	if (!ReadPixels) ReadPixels = (PFNGLREADPIXELSPROC_MT)cmgr->getProcAddress("glReadPixels");
+	if (!GetBooleanv) GetBooleanv = (PFNGLGETBOOLEANVPROC_MT)cmgr->getProcAddress("glGetBooleanv");
+	if (!GetDoublev) GetDoublev = (PFNGLGETDOUBLEVPROC_MT)cmgr->getProcAddress("glGetDoublev");
+	if (!GetError) GetError = (PFNGLGETERRORPROC_MT)cmgr->getProcAddress("glGetError");
+	if (!GetFloatv) GetFloatv = (PFNGLGETFLOATVPROC_MT)cmgr->getProcAddress("glGetFloatv");
+	if (!GetIntegerv) GetIntegerv = (PFNGLGETINTEGERVPROC_MT)cmgr->getProcAddress("glGetIntegerv");
+	if (!GetString) GetString = (PFNGLGETSTRINGPROC_MT)cmgr->getProcAddress("glGetString");
+	if (!GetTexImage) GetTexImage = (PFNGLGETTEXIMAGEPROC_MT)cmgr->getProcAddress("glGetTexImage");
+	if (!GetTexParameterfv) GetTexParameterfv = (PFNGLGETTEXPARAMETERFVPROC_MT)cmgr->getProcAddress("glGetTexParameterfv");
+	if (!GetTexParameteriv) GetTexParameteriv = (PFNGLGETTEXPARAMETERIVPROC_MT)cmgr->getProcAddress("glGetTexParameteriv");
+	if (!GetTexLevelParameterfv) GetTexLevelParameterfv = (PFNGLGETTEXLEVELPARAMETERFVPROC_MT)cmgr->getProcAddress("glGetTexLevelParameterfv");
+	if (!GetTexLevelParameteriv) GetTexLevelParameteriv = (PFNGLGETTEXLEVELPARAMETERIVPROC_MT)cmgr->getProcAddress("glGetTexLevelParameteriv");
+	if (!IsEnabled) IsEnabled = (PFNGLISENABLEDPROC_MT)cmgr->getProcAddress("glIsEnabled");
+	if (!DepthRange) DepthRange = (PFNGLDEPTHRANGEPROC_MT)cmgr->getProcAddress("glDepthRange");
+	if (!Viewport) Viewport = (PFNGLVIEWPORTPROC_MT)cmgr->getProcAddress("glViewport");
+	if (!DrawArrays) DrawArrays = (PFNGLDRAWARRAYSPROC_MT)cmgr->getProcAddress("glDrawArrays");
+	if (!DrawElements) DrawElements = (PFNGLDRAWELEMENTSPROC_MT)cmgr->getProcAddress("glDrawElements");
+	if (!GetPointerv) GetPointerv = (PFNGLGETPOINTERVPROC_MT)cmgr->getProcAddress("glGetPointerv");
+	if (!PolygonOffset) PolygonOffset = (PFNGLPOLYGONOFFSETPROC_MT)cmgr->getProcAddress("glPolygonOffset");
+	if (!CopyTexImage1D) CopyTexImage1D = (PFNGLCOPYTEXIMAGE1DPROC_MT)cmgr->getProcAddress("glCopyTexImage1D");
+	if (!CopyTexImage2D) CopyTexImage2D = (PFNGLCOPYTEXIMAGE2DPROC_MT)cmgr->getProcAddress("glCopyTexImage2D");
+	if (!CopyTexSubImage1D) CopyTexSubImage1D = (PFNGLCOPYTEXSUBIMAGE1DPROC_MT)cmgr->getProcAddress("glCopyTexSubImage1D");
+	if (!CopyTexSubImage2D) CopyTexSubImage2D = (PFNGLCOPYTEXSUBIMAGE2DPROC_MT)cmgr->getProcAddress("glCopyTexSubImage2D");
+	if (!TexSubImage1D) TexSubImage1D = (PFNGLTEXSUBIMAGE1DPROC_MT)cmgr->getProcAddress("glTexSubImage1D");
+	if (!TexSubImage2D) TexSubImage2D = (PFNGLTEXSUBIMAGE2DPROC_MT)cmgr->getProcAddress("glTexSubImage2D");
+	if (!BindTexture) BindTexture = (PFNGLBINDTEXTUREPROC_MT)cmgr->getProcAddress("glBindTexture");
+	if (!DeleteTextures) DeleteTextures = (PFNGLDELETETEXTURESPROC_MT)cmgr->getProcAddress("glDeleteTextures");
+	if (!GenTextures) GenTextures = (PFNGLGENTEXTURESPROC_MT)cmgr->getProcAddress("glGenTextures");
+	if (!IsTexture) IsTexture = (PFNGLISTEXTUREPROC_MT)cmgr->getProcAddress("glIsTexture");
+	if (!DrawRangeElements) DrawRangeElements = (PFNGLDRAWRANGEELEMENTSPROC_MT)cmgr->getProcAddress("glDrawRangeElements");
+	if (!TexImage3D) TexImage3D = (PFNGLTEXIMAGE3DPROC_MT)cmgr->getProcAddress("glTexImage3D");
+	if (!TexSubImage3D) TexSubImage3D = (PFNGLTEXSUBIMAGE3DPROC_MT)cmgr->getProcAddress("glTexSubImage3D");
+	if (!CopyTexSubImage3D) CopyTexSubImage3D = (PFNGLCOPYTEXSUBIMAGE3DPROC_MT)cmgr->getProcAddress("glCopyTexSubImage3D");
+	if (!ActiveTexture) ActiveTexture = (PFNGLACTIVETEXTUREPROC_MT)cmgr->getProcAddress("glActiveTexture");
+	if (!SampleCoverage) SampleCoverage = (PFNGLSAMPLECOVERAGEPROC_MT)cmgr->getProcAddress("glSampleCoverage");
+	if (!CompressedTexImage3D) CompressedTexImage3D = (PFNGLCOMPRESSEDTEXIMAGE3DPROC_MT)cmgr->getProcAddress("glCompressedTexImage3D");
+	if (!CompressedTexImage2D) CompressedTexImage2D = (PFNGLCOMPRESSEDTEXIMAGE2DPROC_MT)cmgr->getProcAddress("glCompressedTexImage2D");
+	if (!CompressedTexImage1D) CompressedTexImage1D = (PFNGLCOMPRESSEDTEXIMAGE1DPROC_MT)cmgr->getProcAddress("glCompressedTexImage1D");
+	if (!CompressedTexSubImage3D) CompressedTexSubImage3D = (PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC_MT)cmgr->getProcAddress("glCompressedTexSubImage3D");
+	if (!CompressedTexSubImage2D) CompressedTexSubImage2D = (PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC_MT)cmgr->getProcAddress("glCompressedTexSubImage2D");
+	if (!CompressedTexSubImage1D) CompressedTexSubImage1D = (PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC_MT)cmgr->getProcAddress("glCompressedTexSubImage1D");
+	if (!GetCompressedTexImage) GetCompressedTexImage = (PFNGLGETCOMPRESSEDTEXIMAGEPROC_MT)cmgr->getProcAddress("glGetCompressedTexImage");
+	if (!BlendFuncSeparate) BlendFuncSeparate = (PFNGLBLENDFUNCSEPARATEPROC_MT)cmgr->getProcAddress("glBlendFuncSeparate");
+	if (!MultiDrawArrays) MultiDrawArrays = (PFNGLMULTIDRAWARRAYSPROC_MT)cmgr->getProcAddress("glMultiDrawArrays");
+	if (!MultiDrawElements) MultiDrawElements = (PFNGLMULTIDRAWELEMENTSPROC_MT)cmgr->getProcAddress("glMultiDrawElements");
+	if (!PointParameterf) PointParameterf = (PFNGLPOINTPARAMETERFPROC_MT)cmgr->getProcAddress("glPointParameterf");
+	if (!PointParameterfv) PointParameterfv = (PFNGLPOINTPARAMETERFVPROC_MT)cmgr->getProcAddress("glPointParameterfv");
+	if (!PointParameteri) PointParameteri = (PFNGLPOINTPARAMETERIPROC_MT)cmgr->getProcAddress("glPointParameteri");
+	if (!PointParameteriv) PointParameteriv = (PFNGLPOINTPARAMETERIVPROC_MT)cmgr->getProcAddress("glPointParameteriv");
+	if (!BlendColor) BlendColor = (PFNGLBLENDCOLORPROC_MT)cmgr->getProcAddress("glBlendColor");
+	if (!BlendEquation) BlendEquation = (PFNGLBLENDEQUATIONPROC_MT)cmgr->getProcAddress("glBlendEquation");
+	if (!GenQueries) GenQueries = (PFNGLGENQUERIESPROC_MT)cmgr->getProcAddress("glGenQueries");
+	if (!DeleteQueries) DeleteQueries = (PFNGLDELETEQUERIESPROC_MT)cmgr->getProcAddress("glDeleteQueries");
+	if (!IsQuery) IsQuery = (PFNGLISQUERYPROC_MT)cmgr->getProcAddress("glIsQuery");
+	if (!BeginQuery) BeginQuery = (PFNGLBEGINQUERYPROC_MT)cmgr->getProcAddress("glBeginQuery");
+	if (!EndQuery) EndQuery = (PFNGLENDQUERYPROC_MT)cmgr->getProcAddress("glEndQuery");
+	if (!GetQueryiv) GetQueryiv = (PFNGLGETQUERYIVPROC_MT)cmgr->getProcAddress("glGetQueryiv");
+	if (!GetQueryObjectiv) GetQueryObjectiv = (PFNGLGETQUERYOBJECTIVPROC_MT)cmgr->getProcAddress("glGetQueryObjectiv");
+	if (!GetQueryObjectuiv) GetQueryObjectuiv = (PFNGLGETQUERYOBJECTUIVPROC_MT)cmgr->getProcAddress("glGetQueryObjectuiv");
+	if (!BindBuffer) BindBuffer = (PFNGLBINDBUFFERPROC_MT)cmgr->getProcAddress("glBindBuffer");
+	if (!DeleteBuffers) DeleteBuffers = (PFNGLDELETEBUFFERSPROC_MT)cmgr->getProcAddress("glDeleteBuffers");
+	if (!GenBuffers) GenBuffers = (PFNGLGENBUFFERSPROC_MT)cmgr->getProcAddress("glGenBuffers");
+	if (!IsBuffer) IsBuffer = (PFNGLISBUFFERPROC_MT)cmgr->getProcAddress("glIsBuffer");
+	if (!BufferData) BufferData = (PFNGLBUFFERDATAPROC_MT)cmgr->getProcAddress("glBufferData");
+	if (!BufferSubData) BufferSubData = (PFNGLBUFFERSUBDATAPROC_MT)cmgr->getProcAddress("glBufferSubData");
+	if (!GetBufferSubData) GetBufferSubData = (PFNGLGETBUFFERSUBDATAPROC_MT)cmgr->getProcAddress("glGetBufferSubData");
+	if (!MapBuffer) MapBuffer = (PFNGLMAPBUFFERPROC_MT)cmgr->getProcAddress("glMapBuffer");
+	if (!UnmapBuffer) UnmapBuffer = (PFNGLUNMAPBUFFERPROC_MT)cmgr->getProcAddress("glUnmapBuffer");
+	if (!GetBufferParameteriv) GetBufferParameteriv = (PFNGLGETBUFFERPARAMETERIVPROC_MT)cmgr->getProcAddress("glGetBufferParameteriv");
+	if (!GetBufferPointerv) GetBufferPointerv = (PFNGLGETBUFFERPOINTERVPROC_MT)cmgr->getProcAddress("glGetBufferPointerv");
+	if (!BlendEquationSeparate) BlendEquationSeparate = (PFNGLBLENDEQUATIONSEPARATEPROC_MT)cmgr->getProcAddress("glBlendEquationSeparate");
+	if (!DrawBuffers) DrawBuffers = (PFNGLDRAWBUFFERSPROC_MT)cmgr->getProcAddress("glDrawBuffers");
+	if (!StencilOpSeparate) StencilOpSeparate = (PFNGLSTENCILOPSEPARATEPROC_MT)cmgr->getProcAddress("glStencilOpSeparate");
+	if (!StencilFuncSeparate) StencilFuncSeparate = (PFNGLSTENCILFUNCSEPARATEPROC_MT)cmgr->getProcAddress("glStencilFuncSeparate");
+	if (!StencilMaskSeparate) StencilMaskSeparate = (PFNGLSTENCILMASKSEPARATEPROC_MT)cmgr->getProcAddress("glStencilMaskSeparate");
+	if (!AttachShader) AttachShader = (PFNGLATTACHSHADERPROC_MT)cmgr->getProcAddress("glAttachShader");
+	if (!BindAttribLocation) BindAttribLocation = (PFNGLBINDATTRIBLOCATIONPROC_MT)cmgr->getProcAddress("glBindAttribLocation");
+	if (!CompileShader) CompileShader = (PFNGLCOMPILESHADERPROC_MT)cmgr->getProcAddress("glCompileShader");
+	if (!CreateProgram) CreateProgram = (PFNGLCREATEPROGRAMPROC_MT)cmgr->getProcAddress("glCreateProgram");
+	if (!CreateShader) CreateShader = (PFNGLCREATESHADERPROC_MT)cmgr->getProcAddress("glCreateShader");
+	if (!DeleteProgram) DeleteProgram = (PFNGLDELETEPROGRAMPROC_MT)cmgr->getProcAddress("glDeleteProgram");
+	if (!DeleteShader) DeleteShader = (PFNGLDELETESHADERPROC_MT)cmgr->getProcAddress("glDeleteShader");
+	if (!DetachShader) DetachShader = (PFNGLDETACHSHADERPROC_MT)cmgr->getProcAddress("glDetachShader");
+	if (!DisableVertexAttribArray) DisableVertexAttribArray = (PFNGLDISABLEVERTEXATTRIBARRAYPROC_MT)cmgr->getProcAddress("glDisableVertexAttribArray");
+	if (!EnableVertexAttribArray) EnableVertexAttribArray = (PFNGLENABLEVERTEXATTRIBARRAYPROC_MT)cmgr->getProcAddress("glEnableVertexAttribArray");
+	if (!GetActiveAttrib) GetActiveAttrib = (PFNGLGETACTIVEATTRIBPROC_MT)cmgr->getProcAddress("glGetActiveAttrib");
+	if (!GetActiveUniform) GetActiveUniform = (PFNGLGETACTIVEUNIFORMPROC_MT)cmgr->getProcAddress("glGetActiveUniform");
+	if (!GetAttachedShaders) GetAttachedShaders = (PFNGLGETATTACHEDSHADERSPROC_MT)cmgr->getProcAddress("glGetAttachedShaders");
+	if (!GetAttribLocation) GetAttribLocation = (PFNGLGETATTRIBLOCATIONPROC_MT)cmgr->getProcAddress("glGetAttribLocation");
+	if (!GetProgramiv) GetProgramiv = (PFNGLGETPROGRAMIVPROC_MT)cmgr->getProcAddress("glGetProgramiv");
+	if (!GetProgramInfoLog) GetProgramInfoLog = (PFNGLGETPROGRAMINFOLOGPROC_MT)cmgr->getProcAddress("glGetProgramInfoLog");
+	if (!GetShaderiv) GetShaderiv = (PFNGLGETSHADERIVPROC_MT)cmgr->getProcAddress("glGetShaderiv");
+	if (!GetShaderInfoLog) GetShaderInfoLog = (PFNGLGETSHADERINFOLOGPROC_MT)cmgr->getProcAddress("glGetShaderInfoLog");
+	if (!GetShaderSource) GetShaderSource = (PFNGLGETSHADERSOURCEPROC_MT)cmgr->getProcAddress("glGetShaderSource");
+	if (!GetUniformLocation) GetUniformLocation = (PFNGLGETUNIFORMLOCATIONPROC_MT)cmgr->getProcAddress("glGetUniformLocation");
+	if (!GetUniformfv) GetUniformfv = (PFNGLGETUNIFORMFVPROC_MT)cmgr->getProcAddress("glGetUniformfv");
+	if (!GetUniformiv) GetUniformiv = (PFNGLGETUNIFORMIVPROC_MT)cmgr->getProcAddress("glGetUniformiv");
+	if (!GetVertexAttribdv) GetVertexAttribdv = (PFNGLGETVERTEXATTRIBDVPROC_MT)cmgr->getProcAddress("glGetVertexAttribdv");
+	if (!GetVertexAttribfv) GetVertexAttribfv = (PFNGLGETVERTEXATTRIBFVPROC_MT)cmgr->getProcAddress("glGetVertexAttribfv");
+	if (!GetVertexAttribiv) GetVertexAttribiv = (PFNGLGETVERTEXATTRIBIVPROC_MT)cmgr->getProcAddress("glGetVertexAttribiv");
+	if (!GetVertexAttribPointerv) GetVertexAttribPointerv = (PFNGLGETVERTEXATTRIBPOINTERVPROC_MT)cmgr->getProcAddress("glGetVertexAttribPointerv");
+	if (!IsProgram) IsProgram = (PFNGLISPROGRAMPROC_MT)cmgr->getProcAddress("glIsProgram");
+	if (!IsShader) IsShader = (PFNGLISSHADERPROC_MT)cmgr->getProcAddress("glIsShader");
+	if (!LinkProgram) LinkProgram = (PFNGLLINKPROGRAMPROC_MT)cmgr->getProcAddress("glLinkProgram");
+	if (!ShaderSource) ShaderSource = (PFNGLSHADERSOURCEPROC_MT)cmgr->getProcAddress("glShaderSource");
+	if (!UseProgram) UseProgram = (PFNGLUSEPROGRAMPROC_MT)cmgr->getProcAddress("glUseProgram");
+	if (!Uniform1f) Uniform1f = (PFNGLUNIFORM1FPROC_MT)cmgr->getProcAddress("glUniform1f");
+	if (!Uniform2f) Uniform2f = (PFNGLUNIFORM2FPROC_MT)cmgr->getProcAddress("glUniform2f");
+	if (!Uniform3f) Uniform3f = (PFNGLUNIFORM3FPROC_MT)cmgr->getProcAddress("glUniform3f");
+	if (!Uniform4f) Uniform4f = (PFNGLUNIFORM4FPROC_MT)cmgr->getProcAddress("glUniform4f");
+	if (!Uniform1i) Uniform1i = (PFNGLUNIFORM1IPROC_MT)cmgr->getProcAddress("glUniform1i");
+	if (!Uniform2i) Uniform2i = (PFNGLUNIFORM2IPROC_MT)cmgr->getProcAddress("glUniform2i");
+	if (!Uniform3i) Uniform3i = (PFNGLUNIFORM3IPROC_MT)cmgr->getProcAddress("glUniform3i");
+	if (!Uniform4i) Uniform4i = (PFNGLUNIFORM4IPROC_MT)cmgr->getProcAddress("glUniform4i");
+	if (!Uniform1fv) Uniform1fv = (PFNGLUNIFORM1FVPROC_MT)cmgr->getProcAddress("glUniform1fv");
+	if (!Uniform2fv) Uniform2fv = (PFNGLUNIFORM2FVPROC_MT)cmgr->getProcAddress("glUniform2fv");
+	if (!Uniform3fv) Uniform3fv = (PFNGLUNIFORM3FVPROC_MT)cmgr->getProcAddress("glUniform3fv");
+	if (!Uniform4fv) Uniform4fv = (PFNGLUNIFORM4FVPROC_MT)cmgr->getProcAddress("glUniform4fv");
+	if (!Uniform1iv) Uniform1iv = (PFNGLUNIFORM1IVPROC_MT)cmgr->getProcAddress("glUniform1iv");
+	if (!Uniform2iv) Uniform2iv = (PFNGLUNIFORM2IVPROC_MT)cmgr->getProcAddress("glUniform2iv");
+	if (!Uniform3iv) Uniform3iv = (PFNGLUNIFORM3IVPROC_MT)cmgr->getProcAddress("glUniform3iv");
+	if (!Uniform4iv) Uniform4iv = (PFNGLUNIFORM4IVPROC_MT)cmgr->getProcAddress("glUniform4iv");
+	if (!UniformMatrix2fv) UniformMatrix2fv = (PFNGLUNIFORMMATRIX2FVPROC_MT)cmgr->getProcAddress("glUniformMatrix2fv");
+	if (!UniformMatrix3fv) UniformMatrix3fv = (PFNGLUNIFORMMATRIX3FVPROC_MT)cmgr->getProcAddress("glUniformMatrix3fv");
+	if (!UniformMatrix4fv) UniformMatrix4fv = (PFNGLUNIFORMMATRIX4FVPROC_MT)cmgr->getProcAddress("glUniformMatrix4fv");
+	if (!ValidateProgram) ValidateProgram = (PFNGLVALIDATEPROGRAMPROC_MT)cmgr->getProcAddress("glValidateProgram");
+	if (!VertexAttrib1d) VertexAttrib1d = (PFNGLVERTEXATTRIB1DPROC_MT)cmgr->getProcAddress("glVertexAttrib1d");
+	if (!VertexAttrib1dv) VertexAttrib1dv = (PFNGLVERTEXATTRIB1DVPROC_MT)cmgr->getProcAddress("glVertexAttrib1dv");
+	if (!VertexAttrib1f) VertexAttrib1f = (PFNGLVERTEXATTRIB1FPROC_MT)cmgr->getProcAddress("glVertexAttrib1f");
+	if (!VertexAttrib1fv) VertexAttrib1fv = (PFNGLVERTEXATTRIB1FVPROC_MT)cmgr->getProcAddress("glVertexAttrib1fv");
+	if (!VertexAttrib1s) VertexAttrib1s = (PFNGLVERTEXATTRIB1SPROC_MT)cmgr->getProcAddress("glVertexAttrib1s");
+	if (!VertexAttrib1sv) VertexAttrib1sv = (PFNGLVERTEXATTRIB1SVPROC_MT)cmgr->getProcAddress("glVertexAttrib1sv");
+	if (!VertexAttrib2d) VertexAttrib2d = (PFNGLVERTEXATTRIB2DPROC_MT)cmgr->getProcAddress("glVertexAttrib2d");
+	if (!VertexAttrib2dv) VertexAttrib2dv = (PFNGLVERTEXATTRIB2DVPROC_MT)cmgr->getProcAddress("glVertexAttrib2dv");
+	if (!VertexAttrib2f) VertexAttrib2f = (PFNGLVERTEXATTRIB2FPROC_MT)cmgr->getProcAddress("glVertexAttrib2f");
+	if (!VertexAttrib2fv) VertexAttrib2fv = (PFNGLVERTEXATTRIB2FVPROC_MT)cmgr->getProcAddress("glVertexAttrib2fv");
+	if (!VertexAttrib2s) VertexAttrib2s = (PFNGLVERTEXATTRIB2SPROC_MT)cmgr->getProcAddress("glVertexAttrib2s");
+	if (!VertexAttrib2sv) VertexAttrib2sv = (PFNGLVERTEXATTRIB2SVPROC_MT)cmgr->getProcAddress("glVertexAttrib2sv");
+	if (!VertexAttrib3d) VertexAttrib3d = (PFNGLVERTEXATTRIB3DPROC_MT)cmgr->getProcAddress("glVertexAttrib3d");
+	if (!VertexAttrib3dv) VertexAttrib3dv = (PFNGLVERTEXATTRIB3DVPROC_MT)cmgr->getProcAddress("glVertexAttrib3dv");
+	if (!VertexAttrib3f) VertexAttrib3f = (PFNGLVERTEXATTRIB3FPROC_MT)cmgr->getProcAddress("glVertexAttrib3f");
+	if (!VertexAttrib3fv) VertexAttrib3fv = (PFNGLVERTEXATTRIB3FVPROC_MT)cmgr->getProcAddress("glVertexAttrib3fv");
+	if (!VertexAttrib3s) VertexAttrib3s = (PFNGLVERTEXATTRIB3SPROC_MT)cmgr->getProcAddress("glVertexAttrib3s");
+	if (!VertexAttrib3sv) VertexAttrib3sv = (PFNGLVERTEXATTRIB3SVPROC_MT)cmgr->getProcAddress("glVertexAttrib3sv");
+	if (!VertexAttrib4Nbv) VertexAttrib4Nbv = (PFNGLVERTEXATTRIB4NBVPROC_MT)cmgr->getProcAddress("glVertexAttrib4Nbv");
+	if (!VertexAttrib4Niv) VertexAttrib4Niv = (PFNGLVERTEXATTRIB4NIVPROC_MT)cmgr->getProcAddress("glVertexAttrib4Niv");
+	if (!VertexAttrib4Nsv) VertexAttrib4Nsv = (PFNGLVERTEXATTRIB4NSVPROC_MT)cmgr->getProcAddress("glVertexAttrib4Nsv");
+	if (!VertexAttrib4Nub) VertexAttrib4Nub = (PFNGLVERTEXATTRIB4NUBPROC_MT)cmgr->getProcAddress("glVertexAttrib4Nub");
+	if (!VertexAttrib4Nubv) VertexAttrib4Nubv = (PFNGLVERTEXATTRIB4NUBVPROC_MT)cmgr->getProcAddress("glVertexAttrib4Nubv");
+	if (!VertexAttrib4Nuiv) VertexAttrib4Nuiv = (PFNGLVERTEXATTRIB4NUIVPROC_MT)cmgr->getProcAddress("glVertexAttrib4Nuiv");
+	if (!VertexAttrib4Nusv) VertexAttrib4Nusv = (PFNGLVERTEXATTRIB4NUSVPROC_MT)cmgr->getProcAddress("glVertexAttrib4Nusv");
+	if (!VertexAttrib4bv) VertexAttrib4bv = (PFNGLVERTEXATTRIB4BVPROC_MT)cmgr->getProcAddress("glVertexAttrib4bv");
+	if (!VertexAttrib4d) VertexAttrib4d = (PFNGLVERTEXATTRIB4DPROC_MT)cmgr->getProcAddress("glVertexAttrib4d");
+	if (!VertexAttrib4dv) VertexAttrib4dv = (PFNGLVERTEXATTRIB4DVPROC_MT)cmgr->getProcAddress("glVertexAttrib4dv");
+	if (!VertexAttrib4f) VertexAttrib4f = (PFNGLVERTEXATTRIB4FPROC_MT)cmgr->getProcAddress("glVertexAttrib4f");
+	if (!VertexAttrib4fv) VertexAttrib4fv = (PFNGLVERTEXATTRIB4FVPROC_MT)cmgr->getProcAddress("glVertexAttrib4fv");
+	if (!VertexAttrib4iv) VertexAttrib4iv = (PFNGLVERTEXATTRIB4IVPROC_MT)cmgr->getProcAddress("glVertexAttrib4iv");
+	if (!VertexAttrib4s) VertexAttrib4s = (PFNGLVERTEXATTRIB4SPROC_MT)cmgr->getProcAddress("glVertexAttrib4s");
+	if (!VertexAttrib4sv) VertexAttrib4sv = (PFNGLVERTEXATTRIB4SVPROC_MT)cmgr->getProcAddress("glVertexAttrib4sv");
+	if (!VertexAttrib4ubv) VertexAttrib4ubv = (PFNGLVERTEXATTRIB4UBVPROC_MT)cmgr->getProcAddress("glVertexAttrib4ubv");
+	if (!VertexAttrib4uiv) VertexAttrib4uiv = (PFNGLVERTEXATTRIB4UIVPROC_MT)cmgr->getProcAddress("glVertexAttrib4uiv");
+	if (!VertexAttrib4usv) VertexAttrib4usv = (PFNGLVERTEXATTRIB4USVPROC_MT)cmgr->getProcAddress("glVertexAttrib4usv");
+	if (!VertexAttribPointer) VertexAttribPointer = (PFNGLVERTEXATTRIBPOINTERPROC_MT)cmgr->getProcAddress("glVertexAttribPointer");
+	if (!UniformMatrix2x3fv) UniformMatrix2x3fv = (PFNGLUNIFORMMATRIX2X3FVPROC_MT)cmgr->getProcAddress("glUniformMatrix2x3fv");
+	if (!UniformMatrix3x2fv) UniformMatrix3x2fv = (PFNGLUNIFORMMATRIX3X2FVPROC_MT)cmgr->getProcAddress("glUniformMatrix3x2fv");
+	if (!UniformMatrix2x4fv) UniformMatrix2x4fv = (PFNGLUNIFORMMATRIX2X4FVPROC_MT)cmgr->getProcAddress("glUniformMatrix2x4fv");
+	if (!UniformMatrix4x2fv) UniformMatrix4x2fv = (PFNGLUNIFORMMATRIX4X2FVPROC_MT)cmgr->getProcAddress("glUniformMatrix4x2fv");
+	if (!UniformMatrix3x4fv) UniformMatrix3x4fv = (PFNGLUNIFORMMATRIX3X4FVPROC_MT)cmgr->getProcAddress("glUniformMatrix3x4fv");
+	if (!UniformMatrix4x3fv) UniformMatrix4x3fv = (PFNGLUNIFORMMATRIX4X3FVPROC_MT)cmgr->getProcAddress("glUniformMatrix4x3fv");
+	if (!ColorMaski) ColorMaski = (PFNGLCOLORMASKIPROC_MT)cmgr->getProcAddress("glColorMaski");
+	if (!Enablei) Enablei = (PFNGLENABLEIPROC_MT)cmgr->getProcAddress("glEnablei");
+	if (!Disablei) Disablei = (PFNGLDISABLEIPROC_MT)cmgr->getProcAddress("glDisablei");
+	if (!IsEnabledi) IsEnabledi = (PFNGLISENABLEDIPROC_MT)cmgr->getProcAddress("glIsEnabledi");
+	if (!BeginTransformFeedback) BeginTransformFeedback = (PFNGLBEGINTRANSFORMFEEDBACKPROC_MT)cmgr->getProcAddress("glBeginTransformFeedback");
+	if (!EndTransformFeedback) EndTransformFeedback = (PFNGLENDTRANSFORMFEEDBACKPROC_MT)cmgr->getProcAddress("glEndTransformFeedback");
+	if (!BindBufferRange) BindBufferRange = (PFNGLBINDBUFFERRANGEPROC_MT)cmgr->getProcAddress("glBindBufferRange");
+	if (!BindBufferBase) BindBufferBase = (PFNGLBINDBUFFERBASEPROC_MT)cmgr->getProcAddress("glBindBufferBase");
+	if (!TransformFeedbackVaryings) TransformFeedbackVaryings = (PFNGLTRANSFORMFEEDBACKVARYINGSPROC_MT)cmgr->getProcAddress("glTransformFeedbackVaryings");
+	if (!GetTransformFeedbackVarying) GetTransformFeedbackVarying = (PFNGLGETTRANSFORMFEEDBACKVARYINGPROC_MT)cmgr->getProcAddress("glGetTransformFeedbackVarying");
+	if (!ClampColor) ClampColor = (PFNGLCLAMPCOLORPROC_MT)cmgr->getProcAddress("glClampColor");
+	if (!BeginConditionalRender) BeginConditionalRender = (PFNGLBEGINCONDITIONALRENDERPROC_MT)cmgr->getProcAddress("glBeginConditionalRender");
+	if (!EndConditionalRender) EndConditionalRender = (PFNGLENDCONDITIONALRENDERPROC_MT)cmgr->getProcAddress("glEndConditionalRender");
+	if (!VertexAttribIPointer) VertexAttribIPointer = (PFNGLVERTEXATTRIBIPOINTERPROC_MT)cmgr->getProcAddress("glVertexAttribIPointer");
+	if (!GetVertexAttribIiv) GetVertexAttribIiv = (PFNGLGETVERTEXATTRIBIIVPROC_MT)cmgr->getProcAddress("glGetVertexAttribIiv");
+	if (!GetVertexAttribIuiv) GetVertexAttribIuiv = (PFNGLGETVERTEXATTRIBIUIVPROC_MT)cmgr->getProcAddress("glGetVertexAttribIuiv");
+	if (!VertexAttribI1i) VertexAttribI1i = (PFNGLVERTEXATTRIBI1IPROC_MT)cmgr->getProcAddress("glVertexAttribI1i");
+	if (!VertexAttribI2i) VertexAttribI2i = (PFNGLVERTEXATTRIBI2IPROC_MT)cmgr->getProcAddress("glVertexAttribI2i");
+	if (!VertexAttribI3i) VertexAttribI3i = (PFNGLVERTEXATTRIBI3IPROC_MT)cmgr->getProcAddress("glVertexAttribI3i");
+	if (!VertexAttribI4i) VertexAttribI4i = (PFNGLVERTEXATTRIBI4IPROC_MT)cmgr->getProcAddress("glVertexAttribI4i");
+	if (!VertexAttribI1ui) VertexAttribI1ui = (PFNGLVERTEXATTRIBI1UIPROC_MT)cmgr->getProcAddress("glVertexAttribI1ui");
+	if (!VertexAttribI2ui) VertexAttribI2ui = (PFNGLVERTEXATTRIBI2UIPROC_MT)cmgr->getProcAddress("glVertexAttribI2ui");
+	if (!VertexAttribI3ui) VertexAttribI3ui = (PFNGLVERTEXATTRIBI3UIPROC_MT)cmgr->getProcAddress("glVertexAttribI3ui");
+	if (!VertexAttribI4ui) VertexAttribI4ui = (PFNGLVERTEXATTRIBI4UIPROC_MT)cmgr->getProcAddress("glVertexAttribI4ui");
+	if (!VertexAttribI1iv) VertexAttribI1iv = (PFNGLVERTEXATTRIBI1IVPROC_MT)cmgr->getProcAddress("glVertexAttribI1iv");
+	if (!VertexAttribI2iv) VertexAttribI2iv = (PFNGLVERTEXATTRIBI2IVPROC_MT)cmgr->getProcAddress("glVertexAttribI2iv");
+	if (!VertexAttribI3iv) VertexAttribI3iv = (PFNGLVERTEXATTRIBI3IVPROC_MT)cmgr->getProcAddress("glVertexAttribI3iv");
+	if (!VertexAttribI4iv) VertexAttribI4iv = (PFNGLVERTEXATTRIBI4IVPROC_MT)cmgr->getProcAddress("glVertexAttribI4iv");
+	if (!VertexAttribI1uiv) VertexAttribI1uiv = (PFNGLVERTEXATTRIBI1UIVPROC_MT)cmgr->getProcAddress("glVertexAttribI1uiv");
+	if (!VertexAttribI2uiv) VertexAttribI2uiv = (PFNGLVERTEXATTRIBI2UIVPROC_MT)cmgr->getProcAddress("glVertexAttribI2uiv");
+	if (!VertexAttribI3uiv) VertexAttribI3uiv = (PFNGLVERTEXATTRIBI3UIVPROC_MT)cmgr->getProcAddress("glVertexAttribI3uiv");
+	if (!VertexAttribI4uiv) VertexAttribI4uiv = (PFNGLVERTEXATTRIBI4UIVPROC_MT)cmgr->getProcAddress("glVertexAttribI4uiv");
+	if (!VertexAttribI4bv) VertexAttribI4bv = (PFNGLVERTEXATTRIBI4BVPROC_MT)cmgr->getProcAddress("glVertexAttribI4bv");
+	if (!VertexAttribI4sv) VertexAttribI4sv = (PFNGLVERTEXATTRIBI4SVPROC_MT)cmgr->getProcAddress("glVertexAttribI4sv");
+	if (!VertexAttribI4ubv) VertexAttribI4ubv = (PFNGLVERTEXATTRIBI4UBVPROC_MT)cmgr->getProcAddress("glVertexAttribI4ubv");
+	if (!VertexAttribI4usv) VertexAttribI4usv = (PFNGLVERTEXATTRIBI4USVPROC_MT)cmgr->getProcAddress("glVertexAttribI4usv");
+	if (!GetUniformuiv) GetUniformuiv = (PFNGLGETUNIFORMUIVPROC_MT)cmgr->getProcAddress("glGetUniformuiv");
+	if (!BindFragDataLocation) BindFragDataLocation = (PFNGLBINDFRAGDATALOCATIONPROC_MT)cmgr->getProcAddress("glBindFragDataLocation");
+	if (!GetFragDataLocation) GetFragDataLocation = (PFNGLGETFRAGDATALOCATIONPROC_MT)cmgr->getProcAddress("glGetFragDataLocation");
+	if (!Uniform1ui) Uniform1ui = (PFNGLUNIFORM1UIPROC_MT)cmgr->getProcAddress("glUniform1ui");
+	if (!Uniform2ui) Uniform2ui = (PFNGLUNIFORM2UIPROC_MT)cmgr->getProcAddress("glUniform2ui");
+	if (!Uniform3ui) Uniform3ui = (PFNGLUNIFORM3UIPROC_MT)cmgr->getProcAddress("glUniform3ui");
+	if (!Uniform4ui) Uniform4ui = (PFNGLUNIFORM4UIPROC_MT)cmgr->getProcAddress("glUniform4ui");
+	if (!Uniform1uiv) Uniform1uiv = (PFNGLUNIFORM1UIVPROC_MT)cmgr->getProcAddress("glUniform1uiv");
+	if (!Uniform2uiv) Uniform2uiv = (PFNGLUNIFORM2UIVPROC_MT)cmgr->getProcAddress("glUniform2uiv");
+	if (!Uniform3uiv) Uniform3uiv = (PFNGLUNIFORM3UIVPROC_MT)cmgr->getProcAddress("glUniform3uiv");
+	if (!Uniform4uiv) Uniform4uiv = (PFNGLUNIFORM4UIVPROC_MT)cmgr->getProcAddress("glUniform4uiv");
+	if (!TexParameterIiv) TexParameterIiv = (PFNGLTEXPARAMETERIIVPROC_MT)cmgr->getProcAddress("glTexParameterIiv");
+	if (!TexParameterIuiv) TexParameterIuiv = (PFNGLTEXPARAMETERIUIVPROC_MT)cmgr->getProcAddress("glTexParameterIuiv");
+	if (!GetTexParameterIiv) GetTexParameterIiv = (PFNGLGETTEXPARAMETERIIVPROC_MT)cmgr->getProcAddress("glGetTexParameterIiv");
+	if (!GetTexParameterIuiv) GetTexParameterIuiv = (PFNGLGETTEXPARAMETERIUIVPROC_MT)cmgr->getProcAddress("glGetTexParameterIuiv");
+	if (!ClearBufferiv) ClearBufferiv = (PFNGLCLEARBUFFERIVPROC_MT)cmgr->getProcAddress("glClearBufferiv");
+	if (!ClearBufferuiv) ClearBufferuiv = (PFNGLCLEARBUFFERUIVPROC_MT)cmgr->getProcAddress("glClearBufferuiv");
+	if (!ClearBufferfv) ClearBufferfv = (PFNGLCLEARBUFFERFVPROC_MT)cmgr->getProcAddress("glClearBufferfv");
+	if (!ClearBufferfi) ClearBufferfi = (PFNGLCLEARBUFFERFIPROC_MT)cmgr->getProcAddress("glClearBufferfi");
+	if (!GetStringi) GetStringi = (PFNGLGETSTRINGIPROC_MT)cmgr->getProcAddress("glGetStringi");
+	if (!IsRenderbuffer) IsRenderbuffer = (PFNGLISRENDERBUFFERPROC_MT)cmgr->getProcAddress("glIsRenderbuffer");
+	if (!BindRenderbuffer) BindRenderbuffer = (PFNGLBINDRENDERBUFFERPROC_MT)cmgr->getProcAddress("glBindRenderbuffer");
+	if (!DeleteRenderbuffers) DeleteRenderbuffers = (PFNGLDELETERENDERBUFFERSPROC_MT)cmgr->getProcAddress("glDeleteRenderbuffers");
+	if (!GenRenderbuffers) GenRenderbuffers = (PFNGLGENRENDERBUFFERSPROC_MT)cmgr->getProcAddress("glGenRenderbuffers");
+	if (!RenderbufferStorage) RenderbufferStorage = (PFNGLRENDERBUFFERSTORAGEPROC_MT)cmgr->getProcAddress("glRenderbufferStorage");
+	if (!GetRenderbufferParameteriv) GetRenderbufferParameteriv = (PFNGLGETRENDERBUFFERPARAMETERIVPROC_MT)cmgr->getProcAddress("glGetRenderbufferParameteriv");
+	if (!IsFramebuffer) IsFramebuffer = (PFNGLISFRAMEBUFFERPROC_MT)cmgr->getProcAddress("glIsFramebuffer");
+	if (!BindFramebuffer) BindFramebuffer = (PFNGLBINDFRAMEBUFFERPROC_MT)cmgr->getProcAddress("glBindFramebuffer");
+	if (!DeleteFramebuffers) DeleteFramebuffers = (PFNGLDELETEFRAMEBUFFERSPROC_MT)cmgr->getProcAddress("glDeleteFramebuffers");
+	if (!GenFramebuffers) GenFramebuffers = (PFNGLGENFRAMEBUFFERSPROC_MT)cmgr->getProcAddress("glGenFramebuffers");
+	if (!CheckFramebufferStatus) CheckFramebufferStatus = (PFNGLCHECKFRAMEBUFFERSTATUSPROC_MT)cmgr->getProcAddress("glCheckFramebufferStatus");
+	if (!FramebufferTexture1D) FramebufferTexture1D = (PFNGLFRAMEBUFFERTEXTURE1DPROC_MT)cmgr->getProcAddress("glFramebufferTexture1D");
+	if (!FramebufferTexture2D) FramebufferTexture2D = (PFNGLFRAMEBUFFERTEXTURE2DPROC_MT)cmgr->getProcAddress("glFramebufferTexture2D");
+	if (!FramebufferTexture3D) FramebufferTexture3D = (PFNGLFRAMEBUFFERTEXTURE3DPROC_MT)cmgr->getProcAddress("glFramebufferTexture3D");
+	if (!FramebufferRenderbuffer) FramebufferRenderbuffer = (PFNGLFRAMEBUFFERRENDERBUFFERPROC_MT)cmgr->getProcAddress("glFramebufferRenderbuffer");
+	if (!GetFramebufferAttachmentParameteriv) GetFramebufferAttachmentParameteriv = (PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC_MT)cmgr->getProcAddress("glGetFramebufferAttachmentParameteriv");
+	if (!GenerateMipmap) GenerateMipmap = (PFNGLGENERATEMIPMAPPROC_MT)cmgr->getProcAddress("glGenerateMipmap");
+	if (!BlitFramebuffer) BlitFramebuffer = (PFNGLBLITFRAMEBUFFERPROC_MT)cmgr->getProcAddress("glBlitFramebuffer");
+	if (!RenderbufferStorageMultisample) RenderbufferStorageMultisample = (PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC_MT)cmgr->getProcAddress("glRenderbufferStorageMultisample");
+	if (!FramebufferTextureLayer) FramebufferTextureLayer = (PFNGLFRAMEBUFFERTEXTURELAYERPROC_MT)cmgr->getProcAddress("glFramebufferTextureLayer");
+	if (!FramebufferTextureLayer) FramebufferTextureLayer = (PFNGLFRAMEBUFFERTEXTURELAYERPROC_MT)cmgr->getProcAddress("glFramebufferTextureLayerARB");
+	if (!MapBufferRange) MapBufferRange = (PFNGLMAPBUFFERRANGEPROC_MT)cmgr->getProcAddress("glMapBufferRange");
+	if (!FlushMappedBufferRange) FlushMappedBufferRange = (PFNGLFLUSHMAPPEDBUFFERRANGEPROC_MT)cmgr->getProcAddress("glFlushMappedBufferRange");
+	if (!BindVertexArray) BindVertexArray = (PFNGLBINDVERTEXARRAYPROC_MT)cmgr->getProcAddress("glBindVertexArray");
+	if (!DeleteVertexArrays) DeleteVertexArrays = (PFNGLDELETEVERTEXARRAYSPROC_MT)cmgr->getProcAddress("glDeleteVertexArrays");
+	if (!GenVertexArrays) GenVertexArrays = (PFNGLGENVERTEXARRAYSPROC_MT)cmgr->getProcAddress("glGenVertexArrays");
+	if (!IsVertexArray) IsVertexArray = (PFNGLISVERTEXARRAYPROC_MT)cmgr->getProcAddress("glIsVertexArray");
+	if (!DrawArraysInstanced) DrawArraysInstanced = (PFNGLDRAWARRAYSINSTANCEDPROC_MT)cmgr->getProcAddress("glDrawArraysInstanced");
+	if (!DrawArraysInstanced) DrawArraysInstanced = (PFNGLDRAWARRAYSINSTANCEDPROC_MT)cmgr->getProcAddress("glDrawArraysInstancedARB");
+	if (!DrawElementsInstanced) DrawElementsInstanced = (PFNGLDRAWELEMENTSINSTANCEDPROC_MT)cmgr->getProcAddress("glDrawElementsInstanced");
+	if (!DrawElementsInstanced) DrawElementsInstanced = (PFNGLDRAWELEMENTSINSTANCEDPROC_MT)cmgr->getProcAddress("glDrawElementsInstancedARB");
+	if (!TexBuffer) TexBuffer = (PFNGLTEXBUFFERPROC_MT)cmgr->getProcAddress("glTexBuffer");
+	if (!TexBuffer) TexBuffer = (PFNGLTEXBUFFERPROC_MT)cmgr->getProcAddress("glTexBufferARB");
+	if (!PrimitiveRestartIndex) PrimitiveRestartIndex = (PFNGLPRIMITIVERESTARTINDEXPROC_MT)cmgr->getProcAddress("glPrimitiveRestartIndex");
+	if (!CopyBufferSubData) CopyBufferSubData = (PFNGLCOPYBUFFERSUBDATAPROC_MT)cmgr->getProcAddress("glCopyBufferSubData");
+	if (!GetUniformIndices) GetUniformIndices = (PFNGLGETUNIFORMINDICESPROC_MT)cmgr->getProcAddress("glGetUniformIndices");
+	if (!GetActiveUniformsiv) GetActiveUniformsiv = (PFNGLGETACTIVEUNIFORMSIVPROC_MT)cmgr->getProcAddress("glGetActiveUniformsiv");
+	if (!GetActiveUniformName) GetActiveUniformName = (PFNGLGETACTIVEUNIFORMNAMEPROC_MT)cmgr->getProcAddress("glGetActiveUniformName");
+	if (!GetUniformBlockIndex) GetUniformBlockIndex = (PFNGLGETUNIFORMBLOCKINDEXPROC_MT)cmgr->getProcAddress("glGetUniformBlockIndex");
+	if (!GetActiveUniformBlockiv) GetActiveUniformBlockiv = (PFNGLGETACTIVEUNIFORMBLOCKIVPROC_MT)cmgr->getProcAddress("glGetActiveUniformBlockiv");
+	if (!GetActiveUniformBlockName) GetActiveUniformBlockName = (PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC_MT)cmgr->getProcAddress("glGetActiveUniformBlockName");
+	if (!UniformBlockBinding) UniformBlockBinding = (PFNGLUNIFORMBLOCKBINDINGPROC_MT)cmgr->getProcAddress("glUniformBlockBinding");
+	if (!DrawElementsBaseVertex) DrawElementsBaseVertex = (PFNGLDRAWELEMENTSBASEVERTEXPROC_MT)cmgr->getProcAddress("glDrawElementsBaseVertex");
+	if (!DrawRangeElementsBaseVertex) DrawRangeElementsBaseVertex = (PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC_MT)cmgr->getProcAddress("glDrawRangeElementsBaseVertex");
+	if (!DrawElementsInstancedBaseVertex) DrawElementsInstancedBaseVertex = (PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC_MT)cmgr->getProcAddress("glDrawElementsInstancedBaseVertex");
+	if (!MultiDrawElementsBaseVertex) MultiDrawElementsBaseVertex = (PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC_MT)cmgr->getProcAddress("glMultiDrawElementsBaseVertex");
+	if (!ProvokingVertex) ProvokingVertex = (PFNGLPROVOKINGVERTEXPROC_MT)cmgr->getProcAddress("glProvokingVertex");
+	if (!FenceSync) FenceSync = (PFNGLFENCESYNCPROC_MT)cmgr->getProcAddress("glFenceSync");
+	if (!IsSync) IsSync = (PFNGLISSYNCPROC_MT)cmgr->getProcAddress("glIsSync");
+	if (!DeleteSync) DeleteSync = (PFNGLDELETESYNCPROC_MT)cmgr->getProcAddress("glDeleteSync");
+	if (!ClientWaitSync) ClientWaitSync = (PFNGLCLIENTWAITSYNCPROC_MT)cmgr->getProcAddress("glClientWaitSync");
+	if (!WaitSync) WaitSync = (PFNGLWAITSYNCPROC_MT)cmgr->getProcAddress("glWaitSync");
+	if (!GetInteger64v) GetInteger64v = (PFNGLGETINTEGER64VPROC_MT)cmgr->getProcAddress("glGetInteger64v");
+	if (!GetSynciv) GetSynciv = (PFNGLGETSYNCIVPROC_MT)cmgr->getProcAddress("glGetSynciv");
+	if (!GetBufferParameteri64v) GetBufferParameteri64v = (PFNGLGETBUFFERPARAMETERI64VPROC_MT)cmgr->getProcAddress("glGetBufferParameteri64v");
+	if (!FramebufferTexture) FramebufferTexture = (PFNGLFRAMEBUFFERTEXTUREPROC_MT)cmgr->getProcAddress("glFramebufferTexture");
+	if (!FramebufferTexture) FramebufferTexture = (PFNGLFRAMEBUFFERTEXTUREPROC_MT)cmgr->getProcAddress("glFramebufferTextureARB");
+	if (!TexImage2DMultisample) TexImage2DMultisample = (PFNGLTEXIMAGE2DMULTISAMPLEPROC_MT)cmgr->getProcAddress("glTexImage2DMultisample");
+	if (!TexImage3DMultisample) TexImage3DMultisample = (PFNGLTEXIMAGE3DMULTISAMPLEPROC_MT)cmgr->getProcAddress("glTexImage3DMultisample");
+	if (!GetMultisamplefv) GetMultisamplefv = (PFNGLGETMULTISAMPLEFVPROC_MT)cmgr->getProcAddress("glGetMultisamplefv");
+	if (!SampleMaski) SampleMaski = (PFNGLSAMPLEMASKIPROC_MT)cmgr->getProcAddress("glSampleMaski");
+	if (!BindFragDataLocationIndexed) BindFragDataLocationIndexed = (PFNGLBINDFRAGDATALOCATIONINDEXEDPROC_MT)cmgr->getProcAddress("glBindFragDataLocationIndexed");
+	if (!GetFragDataIndex) GetFragDataIndex = (PFNGLGETFRAGDATAINDEXPROC_MT)cmgr->getProcAddress("glGetFragDataIndex");
+	if (!GenSamplers) GenSamplers = (PFNGLGENSAMPLERSPROC_MT)cmgr->getProcAddress("glGenSamplers");
+	if (!DeleteSamplers) DeleteSamplers = (PFNGLDELETESAMPLERSPROC_MT)cmgr->getProcAddress("glDeleteSamplers");
+	if (!IsSampler) IsSampler = (PFNGLISSAMPLERPROC_MT)cmgr->getProcAddress("glIsSampler");
+	if (!BindSampler) BindSampler = (PFNGLBINDSAMPLERPROC_MT)cmgr->getProcAddress("glBindSampler");
+	if (!SamplerParameteri) SamplerParameteri = (PFNGLSAMPLERPARAMETERIPROC_MT)cmgr->getProcAddress("glSamplerParameteri");
+	if (!SamplerParameteriv) SamplerParameteriv = (PFNGLSAMPLERPARAMETERIVPROC_MT)cmgr->getProcAddress("glSamplerParameteriv");
+	if (!SamplerParameterf) SamplerParameterf = (PFNGLSAMPLERPARAMETERFPROC_MT)cmgr->getProcAddress("glSamplerParameterf");
+	if (!SamplerParameterfv) SamplerParameterfv = (PFNGLSAMPLERPARAMETERFVPROC_MT)cmgr->getProcAddress("glSamplerParameterfv");
+	if (!SamplerParameterIiv) SamplerParameterIiv = (PFNGLSAMPLERPARAMETERIIVPROC_MT)cmgr->getProcAddress("glSamplerParameterIiv");
+	if (!SamplerParameterIuiv) SamplerParameterIuiv = (PFNGLSAMPLERPARAMETERIUIVPROC_MT)cmgr->getProcAddress("glSamplerParameterIuiv");
+	if (!GetSamplerParameteriv) GetSamplerParameteriv = (PFNGLGETSAMPLERPARAMETERIVPROC_MT)cmgr->getProcAddress("glGetSamplerParameteriv");
+	if (!GetSamplerParameterIiv) GetSamplerParameterIiv = (PFNGLGETSAMPLERPARAMETERIIVPROC_MT)cmgr->getProcAddress("glGetSamplerParameterIiv");
+	if (!GetSamplerParameterfv) GetSamplerParameterfv = (PFNGLGETSAMPLERPARAMETERFVPROC_MT)cmgr->getProcAddress("glGetSamplerParameterfv");
+	if (!GetSamplerParameterIuiv) GetSamplerParameterIuiv = (PFNGLGETSAMPLERPARAMETERIUIVPROC_MT)cmgr->getProcAddress("glGetSamplerParameterIuiv");
+	if (!QueryCounter) QueryCounter = (PFNGLQUERYCOUNTERPROC_MT)cmgr->getProcAddress("glQueryCounter");
+	if (!GetQueryObjecti64v) GetQueryObjecti64v = (PFNGLGETQUERYOBJECTI64VPROC_MT)cmgr->getProcAddress("glGetQueryObjecti64v");
+	if (!GetQueryObjectui64v) GetQueryObjectui64v = (PFNGLGETQUERYOBJECTUI64VPROC_MT)cmgr->getProcAddress("glGetQueryObjectui64v");
+	if (!VertexAttribDivisor) VertexAttribDivisor = (PFNGLVERTEXATTRIBDIVISORPROC_MT)cmgr->getProcAddress("glVertexAttribDivisor");
+	if (!VertexAttribDivisor) VertexAttribDivisor = (PFNGLVERTEXATTRIBDIVISORPROC_MT)cmgr->getProcAddress("glVertexAttribDivisorARB");
+	if (!VertexAttribP1ui) VertexAttribP1ui = (PFNGLVERTEXATTRIBP1UIPROC_MT)cmgr->getProcAddress("glVertexAttribP1ui");
+	if (!VertexAttribP1uiv) VertexAttribP1uiv = (PFNGLVERTEXATTRIBP1UIVPROC_MT)cmgr->getProcAddress("glVertexAttribP1uiv");
+	if (!VertexAttribP2ui) VertexAttribP2ui = (PFNGLVERTEXATTRIBP2UIPROC_MT)cmgr->getProcAddress("glVertexAttribP2ui");
+	if (!VertexAttribP2uiv) VertexAttribP2uiv = (PFNGLVERTEXATTRIBP2UIVPROC_MT)cmgr->getProcAddress("glVertexAttribP2uiv");
+	if (!VertexAttribP3ui) VertexAttribP3ui = (PFNGLVERTEXATTRIBP3UIPROC_MT)cmgr->getProcAddress("glVertexAttribP3ui");
+	if (!VertexAttribP3uiv) VertexAttribP3uiv = (PFNGLVERTEXATTRIBP3UIVPROC_MT)cmgr->getProcAddress("glVertexAttribP3uiv");
+	if (!VertexAttribP4ui) VertexAttribP4ui = (PFNGLVERTEXATTRIBP4UIPROC_MT)cmgr->getProcAddress("glVertexAttribP4ui");
+	if (!VertexAttribP4uiv) VertexAttribP4uiv = (PFNGLVERTEXATTRIBP4UIVPROC_MT)cmgr->getProcAddress("glVertexAttribP4uiv");
+	if (!MinSampleShading) MinSampleShading = (PFNGLMINSAMPLESHADINGPROC_MT)cmgr->getProcAddress("glMinSampleShading");
+	if (!MinSampleShading) MinSampleShading = (PFNGLMINSAMPLESHADINGPROC_MT)cmgr->getProcAddress("glMinSampleShadingARB");
+	if (!BlendEquationi) BlendEquationi = (PFNGLBLENDEQUATIONIPROC_MT)cmgr->getProcAddress("glBlendEquationi");
+	if (!BlendEquationi) BlendEquationi = (PFNGLBLENDEQUATIONIPROC_MT)cmgr->getProcAddress("glBlendEquationiARB");
+	if (!BlendEquationSeparatei) BlendEquationSeparatei = (PFNGLBLENDEQUATIONSEPARATEIPROC_MT)cmgr->getProcAddress("glBlendEquationSeparatei");
+	if (!BlendEquationSeparatei) BlendEquationSeparatei = (PFNGLBLENDEQUATIONSEPARATEIPROC_MT)cmgr->getProcAddress("glBlendEquationSeparateiARB");
+	if (!BlendFunci) BlendFunci = (PFNGLBLENDFUNCIPROC_MT)cmgr->getProcAddress("glBlendFunci");
+	if (!BlendFunci) BlendFunci = (PFNGLBLENDFUNCIPROC_MT)cmgr->getProcAddress("glBlendFunciARB");
+	if (!BlendFuncSeparatei) BlendFuncSeparatei = (PFNGLBLENDFUNCSEPARATEIPROC_MT)cmgr->getProcAddress("glBlendFuncSeparatei");
+	if (!BlendFuncSeparatei) BlendFuncSeparatei = (PFNGLBLENDFUNCSEPARATEIPROC_MT)cmgr->getProcAddress("glBlendFuncSeparateiARB");
+	if (!DrawArraysIndirect) DrawArraysIndirect = (PFNGLDRAWARRAYSINDIRECTPROC_MT)cmgr->getProcAddress("glDrawArraysIndirect");
+	if (!DrawElementsIndirect) DrawElementsIndirect = (PFNGLDRAWELEMENTSINDIRECTPROC_MT)cmgr->getProcAddress("glDrawElementsIndirect");
+	if (!Uniform1d) Uniform1d = (PFNGLUNIFORM1DPROC_MT)cmgr->getProcAddress("glUniform1d");
+	if (!Uniform2d) Uniform2d = (PFNGLUNIFORM2DPROC_MT)cmgr->getProcAddress("glUniform2d");
+	if (!Uniform3d) Uniform3d = (PFNGLUNIFORM3DPROC_MT)cmgr->getProcAddress("glUniform3d");
+	if (!Uniform4d) Uniform4d = (PFNGLUNIFORM4DPROC_MT)cmgr->getProcAddress("glUniform4d");
+	if (!Uniform1dv) Uniform1dv = (PFNGLUNIFORM1DVPROC_MT)cmgr->getProcAddress("glUniform1dv");
+	if (!Uniform2dv) Uniform2dv = (PFNGLUNIFORM2DVPROC_MT)cmgr->getProcAddress("glUniform2dv");
+	if (!Uniform3dv) Uniform3dv = (PFNGLUNIFORM3DVPROC_MT)cmgr->getProcAddress("glUniform3dv");
+	if (!Uniform4dv) Uniform4dv = (PFNGLUNIFORM4DVPROC_MT)cmgr->getProcAddress("glUniform4dv");
+	if (!UniformMatrix2dv) UniformMatrix2dv = (PFNGLUNIFORMMATRIX2DVPROC_MT)cmgr->getProcAddress("glUniformMatrix2dv");
+	if (!UniformMatrix3dv) UniformMatrix3dv = (PFNGLUNIFORMMATRIX3DVPROC_MT)cmgr->getProcAddress("glUniformMatrix3dv");
+	if (!UniformMatrix4dv) UniformMatrix4dv = (PFNGLUNIFORMMATRIX4DVPROC_MT)cmgr->getProcAddress("glUniformMatrix4dv");
+	if (!UniformMatrix2x3dv) UniformMatrix2x3dv = (PFNGLUNIFORMMATRIX2X3DVPROC_MT)cmgr->getProcAddress("glUniformMatrix2x3dv");
+	if (!UniformMatrix2x4dv) UniformMatrix2x4dv = (PFNGLUNIFORMMATRIX2X4DVPROC_MT)cmgr->getProcAddress("glUniformMatrix2x4dv");
+	if (!UniformMatrix3x2dv) UniformMatrix3x2dv = (PFNGLUNIFORMMATRIX3X2DVPROC_MT)cmgr->getProcAddress("glUniformMatrix3x2dv");
+	if (!UniformMatrix3x4dv) UniformMatrix3x4dv = (PFNGLUNIFORMMATRIX3X4DVPROC_MT)cmgr->getProcAddress("glUniformMatrix3x4dv");
+	if (!UniformMatrix4x2dv) UniformMatrix4x2dv = (PFNGLUNIFORMMATRIX4X2DVPROC_MT)cmgr->getProcAddress("glUniformMatrix4x2dv");
+	if (!UniformMatrix4x3dv) UniformMatrix4x3dv = (PFNGLUNIFORMMATRIX4X3DVPROC_MT)cmgr->getProcAddress("glUniformMatrix4x3dv");
+	if (!GetUniformdv) GetUniformdv = (PFNGLGETUNIFORMDVPROC_MT)cmgr->getProcAddress("glGetUniformdv");
+	if (!GetSubroutineUniformLocation) GetSubroutineUniformLocation = (PFNGLGETSUBROUTINEUNIFORMLOCATIONPROC_MT)cmgr->getProcAddress("glGetSubroutineUniformLocation");
+	if (!GetSubroutineIndex) GetSubroutineIndex = (PFNGLGETSUBROUTINEINDEXPROC_MT)cmgr->getProcAddress("glGetSubroutineIndex");
+	if (!GetActiveSubroutineUniformiv) GetActiveSubroutineUniformiv = (PFNGLGETACTIVESUBROUTINEUNIFORMIVPROC_MT)cmgr->getProcAddress("glGetActiveSubroutineUniformiv");
+	if (!GetActiveSubroutineUniformName) GetActiveSubroutineUniformName = (PFNGLGETACTIVESUBROUTINEUNIFORMNAMEPROC_MT)cmgr->getProcAddress("glGetActiveSubroutineUniformName");
+	if (!GetActiveSubroutineName) GetActiveSubroutineName = (PFNGLGETACTIVESUBROUTINENAMEPROC_MT)cmgr->getProcAddress("glGetActiveSubroutineName");
+	if (!UniformSubroutinesuiv) UniformSubroutinesuiv = (PFNGLUNIFORMSUBROUTINESUIVPROC_MT)cmgr->getProcAddress("glUniformSubroutinesuiv");
+	if (!GetUniformSubroutineuiv) GetUniformSubroutineuiv = (PFNGLGETUNIFORMSUBROUTINEUIVPROC_MT)cmgr->getProcAddress("glGetUniformSubroutineuiv");
+	if (!GetProgramStageiv) GetProgramStageiv = (PFNGLGETPROGRAMSTAGEIVPROC_MT)cmgr->getProcAddress("glGetProgramStageiv");
+	if (!PatchParameteri) PatchParameteri = (PFNGLPATCHPARAMETERIPROC_MT)cmgr->getProcAddress("glPatchParameteri");
+	if (!PatchParameterfv) PatchParameterfv = (PFNGLPATCHPARAMETERFVPROC_MT)cmgr->getProcAddress("glPatchParameterfv");
+	if (!BindTransformFeedback) BindTransformFeedback = (PFNGLBINDTRANSFORMFEEDBACKPROC_MT)cmgr->getProcAddress("glBindTransformFeedback");
+	if (!DeleteTransformFeedbacks) DeleteTransformFeedbacks = (PFNGLDELETETRANSFORMFEEDBACKSPROC_MT)cmgr->getProcAddress("glDeleteTransformFeedbacks");
+	if (!GenTransformFeedbacks) GenTransformFeedbacks = (PFNGLGENTRANSFORMFEEDBACKSPROC_MT)cmgr->getProcAddress("glGenTransformFeedbacks");
+	if (!IsTransformFeedback) IsTransformFeedback = (PFNGLISTRANSFORMFEEDBACKPROC_MT)cmgr->getProcAddress("glIsTransformFeedback");
+	if (!PauseTransformFeedback) PauseTransformFeedback = (PFNGLPAUSETRANSFORMFEEDBACKPROC_MT)cmgr->getProcAddress("glPauseTransformFeedback");
+	if (!ResumeTransformFeedback) ResumeTransformFeedback = (PFNGLRESUMETRANSFORMFEEDBACKPROC_MT)cmgr->getProcAddress("glResumeTransformFeedback");
+	if (!DrawTransformFeedback) DrawTransformFeedback = (PFNGLDRAWTRANSFORMFEEDBACKPROC_MT)cmgr->getProcAddress("glDrawTransformFeedback");
+	if (!DrawTransformFeedbackStream) DrawTransformFeedbackStream = (PFNGLDRAWTRANSFORMFEEDBACKSTREAMPROC_MT)cmgr->getProcAddress("glDrawTransformFeedbackStream");
+	if (!BeginQueryIndexed) BeginQueryIndexed = (PFNGLBEGINQUERYINDEXEDPROC_MT)cmgr->getProcAddress("glBeginQueryIndexed");
+	if (!EndQueryIndexed) EndQueryIndexed = (PFNGLENDQUERYINDEXEDPROC_MT)cmgr->getProcAddress("glEndQueryIndexed");
+	if (!GetQueryIndexediv) GetQueryIndexediv = (PFNGLGETQUERYINDEXEDIVPROC_MT)cmgr->getProcAddress("glGetQueryIndexediv");
+	if (!ReleaseShaderCompiler) ReleaseShaderCompiler = (PFNGLRELEASESHADERCOMPILERPROC_MT)cmgr->getProcAddress("glReleaseShaderCompiler");
+	if (!ShaderBinary) ShaderBinary = (PFNGLSHADERBINARYPROC_MT)cmgr->getProcAddress("glShaderBinary");
+	if (!GetShaderPrecisionFormat) GetShaderPrecisionFormat = (PFNGLGETSHADERPRECISIONFORMATPROC_MT)cmgr->getProcAddress("glGetShaderPrecisionFormat");
+	if (!DepthRangef) DepthRangef = (PFNGLDEPTHRANGEFPROC_MT)cmgr->getProcAddress("glDepthRangef");
+	if (!ClearDepthf) ClearDepthf = (PFNGLCLEARDEPTHFPROC_MT)cmgr->getProcAddress("glClearDepthf");
+	if (!GetProgramBinary) GetProgramBinary = (PFNGLGETPROGRAMBINARYPROC_MT)cmgr->getProcAddress("glGetProgramBinary");
+	if (!ProgramBinary) ProgramBinary = (PFNGLPROGRAMBINARYPROC_MT)cmgr->getProcAddress("glProgramBinary");
+	if (!ProgramParameteri) ProgramParameteri = (PFNGLPROGRAMPARAMETERIPROC_MT)cmgr->getProcAddress("glProgramParameteri");
+	if (!ProgramParameteri) ProgramParameteri = (PFNGLPROGRAMPARAMETERIPROC_MT)cmgr->getProcAddress("glProgramParameteriARB");
+	if (!UseProgramStages) UseProgramStages = (PFNGLUSEPROGRAMSTAGESPROC_MT)cmgr->getProcAddress("glUseProgramStages");
+	if (!ActiveShaderProgram) ActiveShaderProgram = (PFNGLACTIVESHADERPROGRAMPROC_MT)cmgr->getProcAddress("glActiveShaderProgram");
+	if (!CreateShaderProgramv) CreateShaderProgramv = (PFNGLCREATESHADERPROGRAMVPROC_MT)cmgr->getProcAddress("glCreateShaderProgramv");
+	if (!BindProgramPipeline) BindProgramPipeline = (PFNGLBINDPROGRAMPIPELINEPROC_MT)cmgr->getProcAddress("glBindProgramPipeline");
+	if (!DeleteProgramPipelines) DeleteProgramPipelines = (PFNGLDELETEPROGRAMPIPELINESPROC_MT)cmgr->getProcAddress("glDeleteProgramPipelines");
+	if (!GenProgramPipelines) GenProgramPipelines = (PFNGLGENPROGRAMPIPELINESPROC_MT)cmgr->getProcAddress("glGenProgramPipelines");
+	if (!IsProgramPipeline) IsProgramPipeline = (PFNGLISPROGRAMPIPELINEPROC_MT)cmgr->getProcAddress("glIsProgramPipeline");
+	if (!GetProgramPipelineiv) GetProgramPipelineiv = (PFNGLGETPROGRAMPIPELINEIVPROC_MT)cmgr->getProcAddress("glGetProgramPipelineiv");
+	if (!ProgramUniform1i) ProgramUniform1i = (PFNGLPROGRAMUNIFORM1IPROC_MT)cmgr->getProcAddress("glProgramUniform1i");
+	if (!ProgramUniform1iv) ProgramUniform1iv = (PFNGLPROGRAMUNIFORM1IVPROC_MT)cmgr->getProcAddress("glProgramUniform1iv");
+	if (!ProgramUniform1f) ProgramUniform1f = (PFNGLPROGRAMUNIFORM1FPROC_MT)cmgr->getProcAddress("glProgramUniform1f");
+	if (!ProgramUniform1fv) ProgramUniform1fv = (PFNGLPROGRAMUNIFORM1FVPROC_MT)cmgr->getProcAddress("glProgramUniform1fv");
+	if (!ProgramUniform1d) ProgramUniform1d = (PFNGLPROGRAMUNIFORM1DPROC_MT)cmgr->getProcAddress("glProgramUniform1d");
+	if (!ProgramUniform1dv) ProgramUniform1dv = (PFNGLPROGRAMUNIFORM1DVPROC_MT)cmgr->getProcAddress("glProgramUniform1dv");
+	if (!ProgramUniform1ui) ProgramUniform1ui = (PFNGLPROGRAMUNIFORM1UIPROC_MT)cmgr->getProcAddress("glProgramUniform1ui");
+	if (!ProgramUniform1uiv) ProgramUniform1uiv = (PFNGLPROGRAMUNIFORM1UIVPROC_MT)cmgr->getProcAddress("glProgramUniform1uiv");
+	if (!ProgramUniform2i) ProgramUniform2i = (PFNGLPROGRAMUNIFORM2IPROC_MT)cmgr->getProcAddress("glProgramUniform2i");
+	if (!ProgramUniform2iv) ProgramUniform2iv = (PFNGLPROGRAMUNIFORM2IVPROC_MT)cmgr->getProcAddress("glProgramUniform2iv");
+	if (!ProgramUniform2f) ProgramUniform2f = (PFNGLPROGRAMUNIFORM2FPROC_MT)cmgr->getProcAddress("glProgramUniform2f");
+	if (!ProgramUniform2fv) ProgramUniform2fv = (PFNGLPROGRAMUNIFORM2FVPROC_MT)cmgr->getProcAddress("glProgramUniform2fv");
+	if (!ProgramUniform2d) ProgramUniform2d = (PFNGLPROGRAMUNIFORM2DPROC_MT)cmgr->getProcAddress("glProgramUniform2d");
+	if (!ProgramUniform2dv) ProgramUniform2dv = (PFNGLPROGRAMUNIFORM2DVPROC_MT)cmgr->getProcAddress("glProgramUniform2dv");
+	if (!ProgramUniform2ui) ProgramUniform2ui = (PFNGLPROGRAMUNIFORM2UIPROC_MT)cmgr->getProcAddress("glProgramUniform2ui");
+	if (!ProgramUniform2uiv) ProgramUniform2uiv = (PFNGLPROGRAMUNIFORM2UIVPROC_MT)cmgr->getProcAddress("glProgramUniform2uiv");
+	if (!ProgramUniform3i) ProgramUniform3i = (PFNGLPROGRAMUNIFORM3IPROC_MT)cmgr->getProcAddress("glProgramUniform3i");
+	if (!ProgramUniform3iv) ProgramUniform3iv = (PFNGLPROGRAMUNIFORM3IVPROC_MT)cmgr->getProcAddress("glProgramUniform3iv");
+	if (!ProgramUniform3f) ProgramUniform3f = (PFNGLPROGRAMUNIFORM3FPROC_MT)cmgr->getProcAddress("glProgramUniform3f");
+	if (!ProgramUniform3fv) ProgramUniform3fv = (PFNGLPROGRAMUNIFORM3FVPROC_MT)cmgr->getProcAddress("glProgramUniform3fv");
+	if (!ProgramUniform3d) ProgramUniform3d = (PFNGLPROGRAMUNIFORM3DPROC_MT)cmgr->getProcAddress("glProgramUniform3d");
+	if (!ProgramUniform3dv) ProgramUniform3dv = (PFNGLPROGRAMUNIFORM3DVPROC_MT)cmgr->getProcAddress("glProgramUniform3dv");
+	if (!ProgramUniform3ui) ProgramUniform3ui = (PFNGLPROGRAMUNIFORM3UIPROC_MT)cmgr->getProcAddress("glProgramUniform3ui");
+	if (!ProgramUniform3uiv) ProgramUniform3uiv = (PFNGLPROGRAMUNIFORM3UIVPROC_MT)cmgr->getProcAddress("glProgramUniform3uiv");
+	if (!ProgramUniform4i) ProgramUniform4i = (PFNGLPROGRAMUNIFORM4IPROC_MT)cmgr->getProcAddress("glProgramUniform4i");
+	if (!ProgramUniform4iv) ProgramUniform4iv = (PFNGLPROGRAMUNIFORM4IVPROC_MT)cmgr->getProcAddress("glProgramUniform4iv");
+	if (!ProgramUniform4f) ProgramUniform4f = (PFNGLPROGRAMUNIFORM4FPROC_MT)cmgr->getProcAddress("glProgramUniform4f");
+	if (!ProgramUniform4fv) ProgramUniform4fv = (PFNGLPROGRAMUNIFORM4FVPROC_MT)cmgr->getProcAddress("glProgramUniform4fv");
+	if (!ProgramUniform4d) ProgramUniform4d = (PFNGLPROGRAMUNIFORM4DPROC_MT)cmgr->getProcAddress("glProgramUniform4d");
+	if (!ProgramUniform4dv) ProgramUniform4dv = (PFNGLPROGRAMUNIFORM4DVPROC_MT)cmgr->getProcAddress("glProgramUniform4dv");
+	if (!ProgramUniform4ui) ProgramUniform4ui = (PFNGLPROGRAMUNIFORM4UIPROC_MT)cmgr->getProcAddress("glProgramUniform4ui");
+	if (!ProgramUniform4uiv) ProgramUniform4uiv = (PFNGLPROGRAMUNIFORM4UIVPROC_MT)cmgr->getProcAddress("glProgramUniform4uiv");
+	if (!ProgramUniformMatrix2fv) ProgramUniformMatrix2fv = (PFNGLPROGRAMUNIFORMMATRIX2FVPROC_MT)cmgr->getProcAddress("glProgramUniformMatrix2fv");
+	if (!ProgramUniformMatrix3fv) ProgramUniformMatrix3fv = (PFNGLPROGRAMUNIFORMMATRIX3FVPROC_MT)cmgr->getProcAddress("glProgramUniformMatrix3fv");
+	if (!ProgramUniformMatrix4fv) ProgramUniformMatrix4fv = (PFNGLPROGRAMUNIFORMMATRIX4FVPROC_MT)cmgr->getProcAddress("glProgramUniformMatrix4fv");
+	if (!ProgramUniformMatrix2dv) ProgramUniformMatrix2dv = (PFNGLPROGRAMUNIFORMMATRIX2DVPROC_MT)cmgr->getProcAddress("glProgramUniformMatrix2dv");
+	if (!ProgramUniformMatrix3dv) ProgramUniformMatrix3dv = (PFNGLPROGRAMUNIFORMMATRIX3DVPROC_MT)cmgr->getProcAddress("glProgramUniformMatrix3dv");
+	if (!ProgramUniformMatrix4dv) ProgramUniformMatrix4dv = (PFNGLPROGRAMUNIFORMMATRIX4DVPROC_MT)cmgr->getProcAddress("glProgramUniformMatrix4dv");
+	if (!ProgramUniformMatrix2x3fv) ProgramUniformMatrix2x3fv = (PFNGLPROGRAMUNIFORMMATRIX2X3FVPROC_MT)cmgr->getProcAddress("glProgramUniformMatrix2x3fv");
+	if (!ProgramUniformMatrix3x2fv) ProgramUniformMatrix3x2fv = (PFNGLPROGRAMUNIFORMMATRIX3X2FVPROC_MT)cmgr->getProcAddress("glProgramUniformMatrix3x2fv");
+	if (!ProgramUniformMatrix2x4fv) ProgramUniformMatrix2x4fv = (PFNGLPROGRAMUNIFORMMATRIX2X4FVPROC_MT)cmgr->getProcAddress("glProgramUniformMatrix2x4fv");
+	if (!ProgramUniformMatrix4x2fv) ProgramUniformMatrix4x2fv = (PFNGLPROGRAMUNIFORMMATRIX4X2FVPROC_MT)cmgr->getProcAddress("glProgramUniformMatrix4x2fv");
+	if (!ProgramUniformMatrix3x4fv) ProgramUniformMatrix3x4fv = (PFNGLPROGRAMUNIFORMMATRIX3X4FVPROC_MT)cmgr->getProcAddress("glProgramUniformMatrix3x4fv");
+	if (!ProgramUniformMatrix4x3fv) ProgramUniformMatrix4x3fv = (PFNGLPROGRAMUNIFORMMATRIX4X3FVPROC_MT)cmgr->getProcAddress("glProgramUniformMatrix4x3fv");
+	if (!ProgramUniformMatrix2x3dv) ProgramUniformMatrix2x3dv = (PFNGLPROGRAMUNIFORMMATRIX2X3DVPROC_MT)cmgr->getProcAddress("glProgramUniformMatrix2x3dv");
+	if (!ProgramUniformMatrix3x2dv) ProgramUniformMatrix3x2dv = (PFNGLPROGRAMUNIFORMMATRIX3X2DVPROC_MT)cmgr->getProcAddress("glProgramUniformMatrix3x2dv");
+	if (!ProgramUniformMatrix2x4dv) ProgramUniformMatrix2x4dv = (PFNGLPROGRAMUNIFORMMATRIX2X4DVPROC_MT)cmgr->getProcAddress("glProgramUniformMatrix2x4dv");
+	if (!ProgramUniformMatrix4x2dv) ProgramUniformMatrix4x2dv = (PFNGLPROGRAMUNIFORMMATRIX4X2DVPROC_MT)cmgr->getProcAddress("glProgramUniformMatrix4x2dv");
+	if (!ProgramUniformMatrix3x4dv) ProgramUniformMatrix3x4dv = (PFNGLPROGRAMUNIFORMMATRIX3X4DVPROC_MT)cmgr->getProcAddress("glProgramUniformMatrix3x4dv");
+	if (!ProgramUniformMatrix4x3dv) ProgramUniformMatrix4x3dv = (PFNGLPROGRAMUNIFORMMATRIX4X3DVPROC_MT)cmgr->getProcAddress("glProgramUniformMatrix4x3dv");
+	if (!ValidateProgramPipeline) ValidateProgramPipeline = (PFNGLVALIDATEPROGRAMPIPELINEPROC_MT)cmgr->getProcAddress("glValidateProgramPipeline");
+	if (!GetProgramPipelineInfoLog) GetProgramPipelineInfoLog = (PFNGLGETPROGRAMPIPELINEINFOLOGPROC_MT)cmgr->getProcAddress("glGetProgramPipelineInfoLog");
+	if (!VertexAttribL1d) VertexAttribL1d = (PFNGLVERTEXATTRIBL1DPROC_MT)cmgr->getProcAddress("glVertexAttribL1d");
+	if (!VertexAttribL2d) VertexAttribL2d = (PFNGLVERTEXATTRIBL2DPROC_MT)cmgr->getProcAddress("glVertexAttribL2d");
+	if (!VertexAttribL3d) VertexAttribL3d = (PFNGLVERTEXATTRIBL3DPROC_MT)cmgr->getProcAddress("glVertexAttribL3d");
+	if (!VertexAttribL4d) VertexAttribL4d = (PFNGLVERTEXATTRIBL4DPROC_MT)cmgr->getProcAddress("glVertexAttribL4d");
+	if (!VertexAttribL1dv) VertexAttribL1dv = (PFNGLVERTEXATTRIBL1DVPROC_MT)cmgr->getProcAddress("glVertexAttribL1dv");
+	if (!VertexAttribL2dv) VertexAttribL2dv = (PFNGLVERTEXATTRIBL2DVPROC_MT)cmgr->getProcAddress("glVertexAttribL2dv");
+	if (!VertexAttribL3dv) VertexAttribL3dv = (PFNGLVERTEXATTRIBL3DVPROC_MT)cmgr->getProcAddress("glVertexAttribL3dv");
+	if (!VertexAttribL4dv) VertexAttribL4dv = (PFNGLVERTEXATTRIBL4DVPROC_MT)cmgr->getProcAddress("glVertexAttribL4dv");
+	if (!VertexAttribLPointer) VertexAttribLPointer = (PFNGLVERTEXATTRIBLPOINTERPROC_MT)cmgr->getProcAddress("glVertexAttribLPointer");
+	if (!GetVertexAttribLdv) GetVertexAttribLdv = (PFNGLGETVERTEXATTRIBLDVPROC_MT)cmgr->getProcAddress("glGetVertexAttribLdv");
+	if (!ViewportArrayv) ViewportArrayv = (PFNGLVIEWPORTARRAYVPROC_MT)cmgr->getProcAddress("glViewportArrayv");
+	if (!ViewportIndexedf) ViewportIndexedf = (PFNGLVIEWPORTINDEXEDFPROC_MT)cmgr->getProcAddress("glViewportIndexedf");
+	if (!ViewportIndexedfv) ViewportIndexedfv = (PFNGLVIEWPORTINDEXEDFVPROC_MT)cmgr->getProcAddress("glViewportIndexedfv");
+	if (!ScissorArrayv) ScissorArrayv = (PFNGLSCISSORARRAYVPROC_MT)cmgr->getProcAddress("glScissorArrayv");
+	if (!ScissorIndexed) ScissorIndexed = (PFNGLSCISSORINDEXEDPROC_MT)cmgr->getProcAddress("glScissorIndexed");
+	if (!ScissorIndexedv) ScissorIndexedv = (PFNGLSCISSORINDEXEDVPROC_MT)cmgr->getProcAddress("glScissorIndexedv");
+	if (!DepthRangeArrayv) DepthRangeArrayv = (PFNGLDEPTHRANGEARRAYVPROC_MT)cmgr->getProcAddress("glDepthRangeArrayv");
+	if (!DepthRangeIndexed) DepthRangeIndexed = (PFNGLDEPTHRANGEINDEXEDPROC_MT)cmgr->getProcAddress("glDepthRangeIndexed");
+	if (!DrawArraysInstancedBaseInstance) DrawArraysInstancedBaseInstance = (PFNGLDRAWARRAYSINSTANCEDBASEINSTANCEPROC_MT)cmgr->getProcAddress("glDrawArraysInstancedBaseInstance");
+	if (!DrawElementsInstancedBaseInstance) DrawElementsInstancedBaseInstance = (PFNGLDRAWELEMENTSINSTANCEDBASEINSTANCEPROC_MT)cmgr->getProcAddress("glDrawElementsInstancedBaseInstance");
+	if (!DrawElementsInstancedBaseVertexBaseInstance) DrawElementsInstancedBaseVertexBaseInstance = (PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEPROC_MT)cmgr->getProcAddress("glDrawElementsInstancedBaseVertexBaseInstance");
+	if (!GetInternalformativ) GetInternalformativ = (PFNGLGETINTERNALFORMATIVPROC_MT)cmgr->getProcAddress("glGetInternalformativ");
+	if (!GetActiveAtomicCounterBufferiv) GetActiveAtomicCounterBufferiv = (PFNGLGETACTIVEATOMICCOUNTERBUFFERIVPROC_MT)cmgr->getProcAddress("glGetActiveAtomicCounterBufferiv");
+	if (!BindImageTexture) BindImageTexture = (PFNGLBINDIMAGETEXTUREPROC_MT)cmgr->getProcAddress("glBindImageTexture");
+	if (!MemoryBarrier) MemoryBarrier = (PFNGLMEMORYBARRIERPROC_MT)cmgr->getProcAddress("glMemoryBarrier");
+	if (!TexStorage1D) TexStorage1D = (PFNGLTEXSTORAGE1DPROC_MT)cmgr->getProcAddress("glTexStorage1D");
+	if (!TexStorage2D) TexStorage2D = (PFNGLTEXSTORAGE2DPROC_MT)cmgr->getProcAddress("glTexStorage2D");
+	if (!TexStorage3D) TexStorage3D = (PFNGLTEXSTORAGE3DPROC_MT)cmgr->getProcAddress("glTexStorage3D");
+	if (!DrawTransformFeedbackInstanced) DrawTransformFeedbackInstanced = (PFNGLDRAWTRANSFORMFEEDBACKINSTANCEDPROC_MT)cmgr->getProcAddress("glDrawTransformFeedbackInstanced");
+	if (!DrawTransformFeedbackStreamInstanced) DrawTransformFeedbackStreamInstanced = (PFNGLDRAWTRANSFORMFEEDBACKSTREAMINSTANCEDPROC_MT)cmgr->getProcAddress("glDrawTransformFeedbackStreamInstanced");
+	if (!ClearBufferData) ClearBufferData = (PFNGLCLEARBUFFERDATAPROC_MT)cmgr->getProcAddress("glClearBufferData");
+	if (!ClearBufferSubData) ClearBufferSubData = (PFNGLCLEARBUFFERSUBDATAPROC_MT)cmgr->getProcAddress("glClearBufferSubData");
+	if (!DispatchCompute) DispatchCompute = (PFNGLDISPATCHCOMPUTEPROC_MT)cmgr->getProcAddress("glDispatchCompute");
+	if (!DispatchComputeIndirect) DispatchComputeIndirect = (PFNGLDISPATCHCOMPUTEINDIRECTPROC_MT)cmgr->getProcAddress("glDispatchComputeIndirect");
+	if (!CopyImageSubData) CopyImageSubData = (PFNGLCOPYIMAGESUBDATAPROC_MT)cmgr->getProcAddress("glCopyImageSubData");
+	if (!FramebufferParameteri) FramebufferParameteri = (PFNGLFRAMEBUFFERPARAMETERIPROC_MT)cmgr->getProcAddress("glFramebufferParameteri");
+	if (!GetFramebufferParameteriv) GetFramebufferParameteriv = (PFNGLGETFRAMEBUFFERPARAMETERIVPROC_MT)cmgr->getProcAddress("glGetFramebufferParameteriv");
+	if (!GetInternalformati64v) GetInternalformati64v = (PFNGLGETINTERNALFORMATI64VPROC_MT)cmgr->getProcAddress("glGetInternalformati64v");
+	if (!InvalidateTexSubImage) InvalidateTexSubImage = (PFNGLINVALIDATETEXSUBIMAGEPROC_MT)cmgr->getProcAddress("glInvalidateTexSubImage");
+	if (!InvalidateTexImage) InvalidateTexImage = (PFNGLINVALIDATETEXIMAGEPROC_MT)cmgr->getProcAddress("glInvalidateTexImage");
+	if (!InvalidateBufferSubData) InvalidateBufferSubData = (PFNGLINVALIDATEBUFFERSUBDATAPROC_MT)cmgr->getProcAddress("glInvalidateBufferSubData");
+	if (!InvalidateBufferData) InvalidateBufferData = (PFNGLINVALIDATEBUFFERDATAPROC_MT)cmgr->getProcAddress("glInvalidateBufferData");
+	if (!InvalidateFramebuffer) InvalidateFramebuffer = (PFNGLINVALIDATEFRAMEBUFFERPROC_MT)cmgr->getProcAddress("glInvalidateFramebuffer");
+	if (!InvalidateSubFramebuffer) InvalidateSubFramebuffer = (PFNGLINVALIDATESUBFRAMEBUFFERPROC_MT)cmgr->getProcAddress("glInvalidateSubFramebuffer");
+	if (!MultiDrawArraysIndirect) MultiDrawArraysIndirect = (PFNGLMULTIDRAWARRAYSINDIRECTPROC_MT)cmgr->getProcAddress("glMultiDrawArraysIndirect");
+	if (!MultiDrawElementsIndirect) MultiDrawElementsIndirect = (PFNGLMULTIDRAWELEMENTSINDIRECTPROC_MT)cmgr->getProcAddress("glMultiDrawElementsIndirect");
+	if (!GetProgramInterfaceiv) GetProgramInterfaceiv = (PFNGLGETPROGRAMINTERFACEIVPROC_MT)cmgr->getProcAddress("glGetProgramInterfaceiv");
+	if (!GetProgramResourceIndex) GetProgramResourceIndex = (PFNGLGETPROGRAMRESOURCEINDEXPROC_MT)cmgr->getProcAddress("glGetProgramResourceIndex");
+	if (!GetProgramResourceName) GetProgramResourceName = (PFNGLGETPROGRAMRESOURCENAMEPROC_MT)cmgr->getProcAddress("glGetProgramResourceName");
+	if (!GetProgramResourceiv) GetProgramResourceiv = (PFNGLGETPROGRAMRESOURCEIVPROC_MT)cmgr->getProcAddress("glGetProgramResourceiv");
+	if (!GetProgramResourceLocation) GetProgramResourceLocation = (PFNGLGETPROGRAMRESOURCELOCATIONPROC_MT)cmgr->getProcAddress("glGetProgramResourceLocation");
+	if (!GetProgramResourceLocationIndex) GetProgramResourceLocationIndex = (PFNGLGETPROGRAMRESOURCELOCATIONINDEXPROC_MT)cmgr->getProcAddress("glGetProgramResourceLocationIndex");
+	if (!ShaderStorageBlockBinding) ShaderStorageBlockBinding = (PFNGLSHADERSTORAGEBLOCKBINDINGPROC_MT)cmgr->getProcAddress("glShaderStorageBlockBinding");
+	if (!TexBufferRange) TexBufferRange = (PFNGLTEXBUFFERRANGEPROC_MT)cmgr->getProcAddress("glTexBufferRange");
+	if (!TexStorage2DMultisample) TexStorage2DMultisample = (PFNGLTEXSTORAGE2DMULTISAMPLEPROC_MT)cmgr->getProcAddress("glTexStorage2DMultisample");
+	if (!TexStorage3DMultisample) TexStorage3DMultisample = (PFNGLTEXSTORAGE3DMULTISAMPLEPROC_MT)cmgr->getProcAddress("glTexStorage3DMultisample");
+	if (!TextureView) TextureView = (PFNGLTEXTUREVIEWPROC_MT)cmgr->getProcAddress("glTextureView");
+	if (!BindVertexBuffer) BindVertexBuffer = (PFNGLBINDVERTEXBUFFERPROC_MT)cmgr->getProcAddress("glBindVertexBuffer");
+	if (!VertexAttribFormat) VertexAttribFormat = (PFNGLVERTEXATTRIBFORMATPROC_MT)cmgr->getProcAddress("glVertexAttribFormat");
+	if (!VertexAttribIFormat) VertexAttribIFormat = (PFNGLVERTEXATTRIBIFORMATPROC_MT)cmgr->getProcAddress("glVertexAttribIFormat");
+	if (!VertexAttribLFormat) VertexAttribLFormat = (PFNGLVERTEXATTRIBLFORMATPROC_MT)cmgr->getProcAddress("glVertexAttribLFormat");
+	if (!VertexAttribBinding) VertexAttribBinding = (PFNGLVERTEXATTRIBBINDINGPROC_MT)cmgr->getProcAddress("glVertexAttribBinding");
+	if (!VertexBindingDivisor) VertexBindingDivisor = (PFNGLVERTEXBINDINGDIVISORPROC_MT)cmgr->getProcAddress("glVertexBindingDivisor");
+	if (!DebugMessageControl) DebugMessageControl = (PFNGLDEBUGMESSAGECONTROLPROC_MT)cmgr->getProcAddress("glDebugMessageControl");
+	if (!DebugMessageControl) DebugMessageControl = (PFNGLDEBUGMESSAGECONTROLPROC_MT)cmgr->getProcAddress("glDebugMessageControlARB");
+	if (!DebugMessageInsert) DebugMessageInsert = (PFNGLDEBUGMESSAGEINSERTPROC_MT)cmgr->getProcAddress("glDebugMessageInsert");
+	if (!DebugMessageInsert) DebugMessageInsert = (PFNGLDEBUGMESSAGEINSERTPROC_MT)cmgr->getProcAddress("glDebugMessageInsertARB");
+	if (!DebugMessageCallback) DebugMessageCallback = (PFNGLDEBUGMESSAGECALLBACKPROC_MT)cmgr->getProcAddress("glDebugMessageCallback");
+	if (!DebugMessageCallback) DebugMessageCallback = (PFNGLDEBUGMESSAGECALLBACKPROC_MT)cmgr->getProcAddress("glDebugMessageCallbackARB");
+	if (!GetDebugMessageLog) GetDebugMessageLog = (PFNGLGETDEBUGMESSAGELOGPROC_MT)cmgr->getProcAddress("glGetDebugMessageLog");
+	if (!GetDebugMessageLog) GetDebugMessageLog = (PFNGLGETDEBUGMESSAGELOGPROC_MT)cmgr->getProcAddress("glGetDebugMessageLogARB");
+	if (!PushDebugGroup) PushDebugGroup = (PFNGLPUSHDEBUGGROUPPROC_MT)cmgr->getProcAddress("glPushDebugGroup");
+	if (!PopDebugGroup) PopDebugGroup = (PFNGLPOPDEBUGGROUPPROC_MT)cmgr->getProcAddress("glPopDebugGroup");
+	if (!ObjectLabel) ObjectLabel = (PFNGLOBJECTLABELPROC_MT)cmgr->getProcAddress("glObjectLabel");
+	if (!GetObjectLabel) GetObjectLabel = (PFNGLGETOBJECTLABELPROC_MT)cmgr->getProcAddress("glGetObjectLabel");
+	if (!ObjectPtrLabel) ObjectPtrLabel = (PFNGLOBJECTPTRLABELPROC_MT)cmgr->getProcAddress("glObjectPtrLabel");
+	if (!GetObjectPtrLabel) GetObjectPtrLabel = (PFNGLGETOBJECTPTRLABELPROC_MT)cmgr->getProcAddress("glGetObjectPtrLabel");
+	if (!BufferStorage) BufferStorage = (PFNGLBUFFERSTORAGEPROC_MT)cmgr->getProcAddress("glBufferStorage");
+	if (!ClearTexImage) ClearTexImage = (PFNGLCLEARTEXIMAGEPROC_MT)cmgr->getProcAddress("glClearTexImage");
+	if (!ClearTexSubImage) ClearTexSubImage = (PFNGLCLEARTEXSUBIMAGEPROC_MT)cmgr->getProcAddress("glClearTexSubImage");
+	if (!BindBuffersBase) BindBuffersBase = (PFNGLBINDBUFFERSBASEPROC_MT)cmgr->getProcAddress("glBindBuffersBase");
+	if (!BindBuffersRange) BindBuffersRange = (PFNGLBINDBUFFERSRANGEPROC_MT)cmgr->getProcAddress("glBindBuffersRange");
+	if (!BindTextures) BindTextures = (PFNGLBINDTEXTURESPROC_MT)cmgr->getProcAddress("glBindTextures");
+	if (!BindSamplers) BindSamplers = (PFNGLBINDSAMPLERSPROC_MT)cmgr->getProcAddress("glBindSamplers");
+	if (!BindImageTextures) BindImageTextures = (PFNGLBINDIMAGETEXTURESPROC_MT)cmgr->getProcAddress("glBindImageTextures");
+	if (!BindVertexBuffers) BindVertexBuffers = (PFNGLBINDVERTEXBUFFERSPROC_MT)cmgr->getProcAddress("glBindVertexBuffers");
+	if (!ClipControl) ClipControl = (PFNGLCLIPCONTROLPROC_MT)cmgr->getProcAddress("glClipControl");
+	if (!CreateTransformFeedbacks) CreateTransformFeedbacks = (PFNGLCREATETRANSFORMFEEDBACKSPROC_MT)cmgr->getProcAddress("glCreateTransformFeedbacks");
+	if (!TransformFeedbackBufferBase) TransformFeedbackBufferBase = (PFNGLTRANSFORMFEEDBACKBUFFERBASEPROC_MT)cmgr->getProcAddress("glTransformFeedbackBufferBase");
+	if (!TransformFeedbackBufferRange) TransformFeedbackBufferRange = (PFNGLTRANSFORMFEEDBACKBUFFERRANGEPROC_MT)cmgr->getProcAddress("glTransformFeedbackBufferRange");
+	if (!GetTransformFeedbackiv) GetTransformFeedbackiv = (PFNGLGETTRANSFORMFEEDBACKIVPROC_MT)cmgr->getProcAddress("glGetTransformFeedbackiv");
+	if (!CreateBuffers) CreateBuffers = (PFNGLCREATEBUFFERSPROC_MT)cmgr->getProcAddress("glCreateBuffers");
+	if (!NamedBufferStorage) NamedBufferStorage = (PFNGLNAMEDBUFFERSTORAGEPROC_MT)cmgr->getProcAddress("glNamedBufferStorage");
+	if (!NamedBufferData) NamedBufferData = (PFNGLNAMEDBUFFERDATAPROC_MT)cmgr->getProcAddress("glNamedBufferData");
+	if (!NamedBufferSubData) NamedBufferSubData = (PFNGLNAMEDBUFFERSUBDATAPROC_MT)cmgr->getProcAddress("glNamedBufferSubData");
+	if (!CopyNamedBufferSubData) CopyNamedBufferSubData = (PFNGLCOPYNAMEDBUFFERSUBDATAPROC_MT)cmgr->getProcAddress("glCopyNamedBufferSubData");
+	if (!ClearNamedBufferData) ClearNamedBufferData = (PFNGLCLEARNAMEDBUFFERDATAPROC_MT)cmgr->getProcAddress("glClearNamedBufferData");
+	if (!ClearNamedBufferSubData) ClearNamedBufferSubData = (PFNGLCLEARNAMEDBUFFERSUBDATAPROC_MT)cmgr->getProcAddress("glClearNamedBufferSubData");
+	if (!MapNamedBuffer) MapNamedBuffer = (PFNGLMAPNAMEDBUFFERPROC_MT)cmgr->getProcAddress("glMapNamedBuffer");
+	if (!MapNamedBufferRange) MapNamedBufferRange = (PFNGLMAPNAMEDBUFFERRANGEPROC_MT)cmgr->getProcAddress("glMapNamedBufferRange");
+	if (!UnmapNamedBuffer) UnmapNamedBuffer = (PFNGLUNMAPNAMEDBUFFERPROC_MT)cmgr->getProcAddress("glUnmapNamedBuffer");
+	if (!FlushMappedNamedBufferRange) FlushMappedNamedBufferRange = (PFNGLFLUSHMAPPEDNAMEDBUFFERRANGEPROC_MT)cmgr->getProcAddress("glFlushMappedNamedBufferRange");
+	if (!GetNamedBufferParameteriv) GetNamedBufferParameteriv = (PFNGLGETNAMEDBUFFERPARAMETERIVPROC_MT)cmgr->getProcAddress("glGetNamedBufferParameteriv");
+	if (!GetNamedBufferParameteri64v) GetNamedBufferParameteri64v = (PFNGLGETNAMEDBUFFERPARAMETERI64VPROC_MT)cmgr->getProcAddress("glGetNamedBufferParameteri64v");
+	if (!GetNamedBufferPointerv) GetNamedBufferPointerv = (PFNGLGETNAMEDBUFFERPOINTERVPROC_MT)cmgr->getProcAddress("glGetNamedBufferPointerv");
+	if (!GetNamedBufferSubData) GetNamedBufferSubData = (PFNGLGETNAMEDBUFFERSUBDATAPROC_MT)cmgr->getProcAddress("glGetNamedBufferSubData");
+	if (!CreateFramebuffers) CreateFramebuffers = (PFNGLCREATEFRAMEBUFFERSPROC_MT)cmgr->getProcAddress("glCreateFramebuffers");
+	if (!NamedFramebufferRenderbuffer) NamedFramebufferRenderbuffer = (PFNGLNAMEDFRAMEBUFFERRENDERBUFFERPROC_MT)cmgr->getProcAddress("glNamedFramebufferRenderbuffer");
+	if (!NamedFramebufferParameteri) NamedFramebufferParameteri = (PFNGLNAMEDFRAMEBUFFERPARAMETERIPROC_MT)cmgr->getProcAddress("glNamedFramebufferParameteri");
+	if (!NamedFramebufferTexture) NamedFramebufferTexture = (PFNGLNAMEDFRAMEBUFFERTEXTUREPROC_MT)cmgr->getProcAddress("glNamedFramebufferTexture");
+	if (!NamedFramebufferTextureLayer) NamedFramebufferTextureLayer = (PFNGLNAMEDFRAMEBUFFERTEXTURELAYERPROC_MT)cmgr->getProcAddress("glNamedFramebufferTextureLayer");
+	if (!NamedFramebufferDrawBuffer) NamedFramebufferDrawBuffer = (PFNGLNAMEDFRAMEBUFFERDRAWBUFFERPROC_MT)cmgr->getProcAddress("glNamedFramebufferDrawBuffer");
+	if (!NamedFramebufferDrawBuffers) NamedFramebufferDrawBuffers = (PFNGLNAMEDFRAMEBUFFERDRAWBUFFERSPROC_MT)cmgr->getProcAddress("glNamedFramebufferDrawBuffers");
+	if (!NamedFramebufferReadBuffer) NamedFramebufferReadBuffer = (PFNGLNAMEDFRAMEBUFFERREADBUFFERPROC_MT)cmgr->getProcAddress("glNamedFramebufferReadBuffer");
+	if (!InvalidateNamedFramebufferData) InvalidateNamedFramebufferData = (PFNGLINVALIDATENAMEDFRAMEBUFFERDATAPROC_MT)cmgr->getProcAddress("glInvalidateNamedFramebufferData");
+	if (!InvalidateNamedFramebufferSubData) InvalidateNamedFramebufferSubData = (PFNGLINVALIDATENAMEDFRAMEBUFFERSUBDATAPROC_MT)cmgr->getProcAddress("glInvalidateNamedFramebufferSubData");
+	if (!ClearNamedFramebufferiv) ClearNamedFramebufferiv = (PFNGLCLEARNAMEDFRAMEBUFFERIVPROC_MT)cmgr->getProcAddress("glClearNamedFramebufferiv");
+	if (!ClearNamedFramebufferuiv) ClearNamedFramebufferuiv = (PFNGLCLEARNAMEDFRAMEBUFFERUIVPROC_MT)cmgr->getProcAddress("glClearNamedFramebufferuiv");
+	if (!ClearNamedFramebufferfv) ClearNamedFramebufferfv = (PFNGLCLEARNAMEDFRAMEBUFFERFVPROC_MT)cmgr->getProcAddress("glClearNamedFramebufferfv");
+	if (!ClearNamedFramebufferfi) ClearNamedFramebufferfi = (PFNGLCLEARNAMEDFRAMEBUFFERFIPROC_MT)cmgr->getProcAddress("glClearNamedFramebufferfi");
+	if (!BlitNamedFramebuffer) BlitNamedFramebuffer = (PFNGLBLITNAMEDFRAMEBUFFERPROC_MT)cmgr->getProcAddress("glBlitNamedFramebuffer");
+	if (!CheckNamedFramebufferStatus) CheckNamedFramebufferStatus = (PFNGLCHECKNAMEDFRAMEBUFFERSTATUSPROC_MT)cmgr->getProcAddress("glCheckNamedFramebufferStatus");
+	if (!GetNamedFramebufferParameteriv) GetNamedFramebufferParameteriv = (PFNGLGETNAMEDFRAMEBUFFERPARAMETERIVPROC_MT)cmgr->getProcAddress("glGetNamedFramebufferParameteriv");
+	if (!GetNamedFramebufferAttachmentParameteriv) GetNamedFramebufferAttachmentParameteriv = (PFNGLGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIVPROC_MT)cmgr->getProcAddress("glGetNamedFramebufferAttachmentParameteriv");
+	if (!CreateRenderbuffers) CreateRenderbuffers = (PFNGLCREATERENDERBUFFERSPROC_MT)cmgr->getProcAddress("glCreateRenderbuffers");
+	if (!NamedRenderbufferStorage) NamedRenderbufferStorage = (PFNGLNAMEDRENDERBUFFERSTORAGEPROC_MT)cmgr->getProcAddress("glNamedRenderbufferStorage");
+	if (!NamedRenderbufferStorageMultisample) NamedRenderbufferStorageMultisample = (PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLEPROC_MT)cmgr->getProcAddress("glNamedRenderbufferStorageMultisample");
+	if (!GetNamedRenderbufferParameteriv) GetNamedRenderbufferParameteriv = (PFNGLGETNAMEDRENDERBUFFERPARAMETERIVPROC_MT)cmgr->getProcAddress("glGetNamedRenderbufferParameteriv");
+	if (!CreateTextures) CreateTextures = (PFNGLCREATETEXTURESPROC_MT)cmgr->getProcAddress("glCreateTextures");
+	if (!TextureBuffer) TextureBuffer = (PFNGLTEXTUREBUFFERPROC_MT)cmgr->getProcAddress("glTextureBuffer");
+	if (!TextureBufferRange) TextureBufferRange = (PFNGLTEXTUREBUFFERRANGEPROC_MT)cmgr->getProcAddress("glTextureBufferRange");
+	if (!TextureStorage1D) TextureStorage1D = (PFNGLTEXTURESTORAGE1DPROC_MT)cmgr->getProcAddress("glTextureStorage1D");
+	if (!TextureStorage2D) TextureStorage2D = (PFNGLTEXTURESTORAGE2DPROC_MT)cmgr->getProcAddress("glTextureStorage2D");
+	if (!TextureStorage3D) TextureStorage3D = (PFNGLTEXTURESTORAGE3DPROC_MT)cmgr->getProcAddress("glTextureStorage3D");
+	if (!TextureStorage2DMultisample) TextureStorage2DMultisample = (PFNGLTEXTURESTORAGE2DMULTISAMPLEPROC_MT)cmgr->getProcAddress("glTextureStorage2DMultisample");
+	if (!TextureStorage3DMultisample) TextureStorage3DMultisample = (PFNGLTEXTURESTORAGE3DMULTISAMPLEPROC_MT)cmgr->getProcAddress("glTextureStorage3DMultisample");
+	if (!TextureSubImage1D) TextureSubImage1D = (PFNGLTEXTURESUBIMAGE1DPROC_MT)cmgr->getProcAddress("glTextureSubImage1D");
+	if (!TextureSubImage2D) TextureSubImage2D = (PFNGLTEXTURESUBIMAGE2DPROC_MT)cmgr->getProcAddress("glTextureSubImage2D");
+	if (!TextureSubImage3D) TextureSubImage3D = (PFNGLTEXTURESUBIMAGE3DPROC_MT)cmgr->getProcAddress("glTextureSubImage3D");
+	if (!CompressedTextureSubImage1D) CompressedTextureSubImage1D = (PFNGLCOMPRESSEDTEXTURESUBIMAGE1DPROC_MT)cmgr->getProcAddress("glCompressedTextureSubImage1D");
+	if (!CompressedTextureSubImage2D) CompressedTextureSubImage2D = (PFNGLCOMPRESSEDTEXTURESUBIMAGE2DPROC_MT)cmgr->getProcAddress("glCompressedTextureSubImage2D");
+	if (!CompressedTextureSubImage3D) CompressedTextureSubImage3D = (PFNGLCOMPRESSEDTEXTURESUBIMAGE3DPROC_MT)cmgr->getProcAddress("glCompressedTextureSubImage3D");
+	if (!CopyTextureSubImage1D) CopyTextureSubImage1D = (PFNGLCOPYTEXTURESUBIMAGE1DPROC_MT)cmgr->getProcAddress("glCopyTextureSubImage1D");
+	if (!CopyTextureSubImage2D) CopyTextureSubImage2D = (PFNGLCOPYTEXTURESUBIMAGE2DPROC_MT)cmgr->getProcAddress("glCopyTextureSubImage2D");
+	if (!CopyTextureSubImage3D) CopyTextureSubImage3D = (PFNGLCOPYTEXTURESUBIMAGE3DPROC_MT)cmgr->getProcAddress("glCopyTextureSubImage3D");
+	if (!TextureParameterf) TextureParameterf = (PFNGLTEXTUREPARAMETERFPROC_MT)cmgr->getProcAddress("glTextureParameterf");
+	if (!TextureParameterfv) TextureParameterfv = (PFNGLTEXTUREPARAMETERFVPROC_MT)cmgr->getProcAddress("glTextureParameterfv");
+	if (!TextureParameteri) TextureParameteri = (PFNGLTEXTUREPARAMETERIPROC_MT)cmgr->getProcAddress("glTextureParameteri");
+	if (!TextureParameterIiv) TextureParameterIiv = (PFNGLTEXTUREPARAMETERIIVPROC_MT)cmgr->getProcAddress("glTextureParameterIiv");
+	if (!TextureParameterIuiv) TextureParameterIuiv = (PFNGLTEXTUREPARAMETERIUIVPROC_MT)cmgr->getProcAddress("glTextureParameterIuiv");
+	if (!TextureParameteriv) TextureParameteriv = (PFNGLTEXTUREPARAMETERIVPROC_MT)cmgr->getProcAddress("glTextureParameteriv");
+	if (!GenerateTextureMipmap) GenerateTextureMipmap = (PFNGLGENERATETEXTUREMIPMAPPROC_MT)cmgr->getProcAddress("glGenerateTextureMipmap");
+	if (!BindTextureUnit) BindTextureUnit = (PFNGLBINDTEXTUREUNITPROC_MT)cmgr->getProcAddress("glBindTextureUnit");
+	if (!GetTextureImage) GetTextureImage = (PFNGLGETTEXTUREIMAGEPROC_MT)cmgr->getProcAddress("glGetTextureImage");
+	if (!GetCompressedTextureImage) GetCompressedTextureImage = (PFNGLGETCOMPRESSEDTEXTUREIMAGEPROC_MT)cmgr->getProcAddress("glGetCompressedTextureImage");
+	if (!GetTextureLevelParameterfv) GetTextureLevelParameterfv = (PFNGLGETTEXTURELEVELPARAMETERFVPROC_MT)cmgr->getProcAddress("glGetTextureLevelParameterfv");
+	if (!GetTextureLevelParameteriv) GetTextureLevelParameteriv = (PFNGLGETTEXTURELEVELPARAMETERIVPROC_MT)cmgr->getProcAddress("glGetTextureLevelParameteriv");
+	if (!GetTextureParameterfv) GetTextureParameterfv = (PFNGLGETTEXTUREPARAMETERFVPROC_MT)cmgr->getProcAddress("glGetTextureParameterfv");
+	if (!GetTextureParameterIiv) GetTextureParameterIiv = (PFNGLGETTEXTUREPARAMETERIIVPROC_MT)cmgr->getProcAddress("glGetTextureParameterIiv");
+	if (!GetTextureParameterIuiv) GetTextureParameterIuiv = (PFNGLGETTEXTUREPARAMETERIUIVPROC_MT)cmgr->getProcAddress("glGetTextureParameterIuiv");
+	if (!GetTextureParameteriv) GetTextureParameteriv = (PFNGLGETTEXTUREPARAMETERIVPROC_MT)cmgr->getProcAddress("glGetTextureParameteriv");
+	if (!CreateVertexArrays) CreateVertexArrays = (PFNGLCREATEVERTEXARRAYSPROC_MT)cmgr->getProcAddress("glCreateVertexArrays");
+	if (!DisableVertexArrayAttrib) DisableVertexArrayAttrib = (PFNGLDISABLEVERTEXARRAYATTRIBPROC_MT)cmgr->getProcAddress("glDisableVertexArrayAttrib");
+	if (!EnableVertexArrayAttrib) EnableVertexArrayAttrib = (PFNGLENABLEVERTEXARRAYATTRIBPROC_MT)cmgr->getProcAddress("glEnableVertexArrayAttrib");
+	if (!VertexArrayElementBuffer) VertexArrayElementBuffer = (PFNGLVERTEXARRAYELEMENTBUFFERPROC_MT)cmgr->getProcAddress("glVertexArrayElementBuffer");
+	if (!VertexArrayVertexBuffer) VertexArrayVertexBuffer = (PFNGLVERTEXARRAYVERTEXBUFFERPROC_MT)cmgr->getProcAddress("glVertexArrayVertexBuffer");
+	if (!VertexArrayVertexBuffers) VertexArrayVertexBuffers = (PFNGLVERTEXARRAYVERTEXBUFFERSPROC_MT)cmgr->getProcAddress("glVertexArrayVertexBuffers");
+	if (!VertexArrayAttribBinding) VertexArrayAttribBinding = (PFNGLVERTEXARRAYATTRIBBINDINGPROC_MT)cmgr->getProcAddress("glVertexArrayAttribBinding");
+	if (!VertexArrayAttribFormat) VertexArrayAttribFormat = (PFNGLVERTEXARRAYATTRIBFORMATPROC_MT)cmgr->getProcAddress("glVertexArrayAttribFormat");
+	if (!VertexArrayAttribIFormat) VertexArrayAttribIFormat = (PFNGLVERTEXARRAYATTRIBIFORMATPROC_MT)cmgr->getProcAddress("glVertexArrayAttribIFormat");
+	if (!VertexArrayAttribLFormat) VertexArrayAttribLFormat = (PFNGLVERTEXARRAYATTRIBLFORMATPROC_MT)cmgr->getProcAddress("glVertexArrayAttribLFormat");
+	if (!VertexArrayBindingDivisor) VertexArrayBindingDivisor = (PFNGLVERTEXARRAYBINDINGDIVISORPROC_MT)cmgr->getProcAddress("glVertexArrayBindingDivisor");
+	if (!GetVertexArrayiv) GetVertexArrayiv = (PFNGLGETVERTEXARRAYIVPROC_MT)cmgr->getProcAddress("glGetVertexArrayiv");
+	if (!GetVertexArrayIndexediv) GetVertexArrayIndexediv = (PFNGLGETVERTEXARRAYINDEXEDIVPROC_MT)cmgr->getProcAddress("glGetVertexArrayIndexediv");
+	if (!GetVertexArrayIndexed64iv) GetVertexArrayIndexed64iv = (PFNGLGETVERTEXARRAYINDEXED64IVPROC_MT)cmgr->getProcAddress("glGetVertexArrayIndexed64iv");
+	if (!CreateSamplers) CreateSamplers = (PFNGLCREATESAMPLERSPROC_MT)cmgr->getProcAddress("glCreateSamplers");
+	if (!CreateProgramPipelines) CreateProgramPipelines = (PFNGLCREATEPROGRAMPIPELINESPROC_MT)cmgr->getProcAddress("glCreateProgramPipelines");
+	if (!CreateQueries) CreateQueries = (PFNGLCREATEQUERIESPROC_MT)cmgr->getProcAddress("glCreateQueries");
+	if (!GetQueryBufferObjecti64v) GetQueryBufferObjecti64v = (PFNGLGETQUERYBUFFEROBJECTI64VPROC_MT)cmgr->getProcAddress("glGetQueryBufferObjecti64v");
+	if (!GetQueryBufferObjectiv) GetQueryBufferObjectiv = (PFNGLGETQUERYBUFFEROBJECTIVPROC_MT)cmgr->getProcAddress("glGetQueryBufferObjectiv");
+	if (!GetQueryBufferObjectui64v) GetQueryBufferObjectui64v = (PFNGLGETQUERYBUFFEROBJECTUI64VPROC_MT)cmgr->getProcAddress("glGetQueryBufferObjectui64v");
+	if (!GetQueryBufferObjectuiv) GetQueryBufferObjectuiv = (PFNGLGETQUERYBUFFEROBJECTUIVPROC_MT)cmgr->getProcAddress("glGetQueryBufferObjectuiv");
+	if (!MemoryBarrierByRegion) MemoryBarrierByRegion = (PFNGLMEMORYBARRIERBYREGIONPROC_MT)cmgr->getProcAddress("glMemoryBarrierByRegion");
+	if (!GetTextureSubImage) GetTextureSubImage = (PFNGLGETTEXTURESUBIMAGEPROC_MT)cmgr->getProcAddress("glGetTextureSubImage");
+	if (!GetCompressedTextureSubImage) GetCompressedTextureSubImage = (PFNGLGETCOMPRESSEDTEXTURESUBIMAGEPROC_MT)cmgr->getProcAddress("glGetCompressedTextureSubImage");
+	if (!GetGraphicsResetStatus) GetGraphicsResetStatus = (PFNGLGETGRAPHICSRESETSTATUSPROC_MT)cmgr->getProcAddress("glGetGraphicsResetStatus");
+	if (!GetGraphicsResetStatus) GetGraphicsResetStatus = (PFNGLGETGRAPHICSRESETSTATUSPROC_MT)cmgr->getProcAddress("glGetGraphicsResetStatusARB");
+	if (!GetnCompressedTexImage) GetnCompressedTexImage = (PFNGLGETNCOMPRESSEDTEXIMAGEPROC_MT)cmgr->getProcAddress("glGetnCompressedTexImage");
+	if (!GetnCompressedTexImage) GetnCompressedTexImage = (PFNGLGETNCOMPRESSEDTEXIMAGEPROC_MT)cmgr->getProcAddress("glGetnCompressedTexImageARB");
+	if (!GetnTexImage) GetnTexImage = (PFNGLGETNTEXIMAGEPROC_MT)cmgr->getProcAddress("glGetnTexImage");
+	if (!GetnTexImage) GetnTexImage = (PFNGLGETNTEXIMAGEPROC_MT)cmgr->getProcAddress("glGetnTexImageARB");
+	if (!GetnUniformdv) GetnUniformdv = (PFNGLGETNUNIFORMDVPROC_MT)cmgr->getProcAddress("glGetnUniformdv");
+	if (!GetnUniformdv) GetnUniformdv = (PFNGLGETNUNIFORMDVPROC_MT)cmgr->getProcAddress("glGetnUniformdvARB");
+	if (!GetnUniformfv) GetnUniformfv = (PFNGLGETNUNIFORMFVPROC_MT)cmgr->getProcAddress("glGetnUniformfv");
+	if (!GetnUniformfv) GetnUniformfv = (PFNGLGETNUNIFORMFVPROC_MT)cmgr->getProcAddress("glGetnUniformfvARB");
+	if (!GetnUniformiv) GetnUniformiv = (PFNGLGETNUNIFORMIVPROC_MT)cmgr->getProcAddress("glGetnUniformiv");
+	if (!GetnUniformiv) GetnUniformiv = (PFNGLGETNUNIFORMIVPROC_MT)cmgr->getProcAddress("glGetnUniformivARB");
+	if (!GetnUniformuiv) GetnUniformuiv = (PFNGLGETNUNIFORMUIVPROC_MT)cmgr->getProcAddress("glGetnUniformuiv");
+	if (!GetnUniformuiv) GetnUniformuiv = (PFNGLGETNUNIFORMUIVPROC_MT)cmgr->getProcAddress("glGetnUniformuivARB");
+	if (!ReadnPixels) ReadnPixels = (PFNGLREADNPIXELSPROC_MT)cmgr->getProcAddress("glReadnPixels");
+	if (!ReadnPixels) ReadnPixels = (PFNGLREADNPIXELSPROC_MT)cmgr->getProcAddress("glReadnPixelsARB");
+	if (!TextureBarrier) TextureBarrier = (PFNGLTEXTUREBARRIERPROC_MT)cmgr->getProcAddress("glTextureBarrier");
+	if (!SpecializeShader) SpecializeShader = (PFNGLSPECIALIZESHADERPROC_MT)cmgr->getProcAddress("glSpecializeShader");
+	if (!SpecializeShader) SpecializeShader = (PFNGLSPECIALIZESHADERPROC_MT)cmgr->getProcAddress("glSpecializeShaderARB");
+	if (!MultiDrawArraysIndirectCount) MultiDrawArraysIndirectCount = (PFNGLMULTIDRAWARRAYSINDIRECTCOUNTPROC_MT)cmgr->getProcAddress("glMultiDrawArraysIndirectCount");
+	if (!MultiDrawArraysIndirectCount) MultiDrawArraysIndirectCount = (PFNGLMULTIDRAWARRAYSINDIRECTCOUNTPROC_MT)cmgr->getProcAddress("glMultiDrawArraysIndirectCountARB");
+	if (!MultiDrawElementsIndirectCount) MultiDrawElementsIndirectCount = (PFNGLMULTIDRAWELEMENTSINDIRECTCOUNTPROC_MT)cmgr->getProcAddress("glMultiDrawElementsIndirectCount");
+	if (!MultiDrawElementsIndirectCount) MultiDrawElementsIndirectCount = (PFNGLMULTIDRAWELEMENTSINDIRECTCOUNTPROC_MT)cmgr->getProcAddress("glMultiDrawElementsIndirectCountARB");
+	if (!PolygonOffsetClamp) PolygonOffsetClamp = (PFNGLPOLYGONOFFSETCLAMPPROC_MT)cmgr->getProcAddress("glPolygonOffsetClamp");
+	if (!GenPerfMonitorsEX) GenPerfMonitorsEX = (PFNGLGENPERFMONITORSEXPROC_MT)cmgr->getProcAddress("glGenPerfMonitorsEX");
+	if (!PrimitiveBoundingBox) PrimitiveBoundingBox = (PFNGLPRIMITIVEBOUNDINGBOXPROC_MT)cmgr->getProcAddress("glPrimitiveBoundingBoxARB");
+	if (!GetTextureHandle) GetTextureHandle = (PFNGLGETTEXTUREHANDLEPROC_MT)cmgr->getProcAddress("glGetTextureHandleARB");
+	if (!GetTextureSamplerHandle) GetTextureSamplerHandle = (PFNGLGETTEXTURESAMPLERHANDLEPROC_MT)cmgr->getProcAddress("glGetTextureSamplerHandleARB");
+	if (!MakeTextureHandleResident) MakeTextureHandleResident = (PFNGLMAKETEXTUREHANDLERESIDENTPROC_MT)cmgr->getProcAddress("glMakeTextureHandleResidentARB");
+	if (!MakeTextureHandleNonResident) MakeTextureHandleNonResident = (PFNGLMAKETEXTUREHANDLENONRESIDENTPROC_MT)cmgr->getProcAddress("glMakeTextureHandleNonResidentARB");
+	if (!GetImageHandle) GetImageHandle = (PFNGLGETIMAGEHANDLEPROC_MT)cmgr->getProcAddress("glGetImageHandleARB");
+	if (!MakeImageHandleResident) MakeImageHandleResident = (PFNGLMAKEIMAGEHANDLERESIDENTPROC_MT)cmgr->getProcAddress("glMakeImageHandleResidentARB");
+	if (!MakeImageHandleNonResident) MakeImageHandleNonResident = (PFNGLMAKEIMAGEHANDLENONRESIDENTPROC_MT)cmgr->getProcAddress("glMakeImageHandleNonResidentARB");
+	if (!UniformHandleui64) UniformHandleui64 = (PFNGLUNIFORMHANDLEUI64PROC_MT)cmgr->getProcAddress("glUniformHandleui64ARB");
+	if (!UniformHandleui64v) UniformHandleui64v = (PFNGLUNIFORMHANDLEUI64VPROC_MT)cmgr->getProcAddress("glUniformHandleui64vARB");
+	if (!ProgramUniformHandleui64) ProgramUniformHandleui64 = (PFNGLPROGRAMUNIFORMHANDLEUI64PROC_MT)cmgr->getProcAddress("glProgramUniformHandleui64ARB");
+	if (!ProgramUniformHandleui64v) ProgramUniformHandleui64v = (PFNGLPROGRAMUNIFORMHANDLEUI64VPROC_MT)cmgr->getProcAddress("glProgramUniformHandleui64vARB");
+	if (!IsTextureHandleResident) IsTextureHandleResident = (PFNGLISTEXTUREHANDLERESIDENTPROC_MT)cmgr->getProcAddress("glIsTextureHandleResidentARB");
+	if (!IsImageHandleResident) IsImageHandleResident = (PFNGLISIMAGEHANDLERESIDENTPROC_MT)cmgr->getProcAddress("glIsImageHandleResidentARB");
+	if (!VertexAttribL1ui64) VertexAttribL1ui64 = (PFNGLVERTEXATTRIBL1UI64PROC_MT)cmgr->getProcAddress("glVertexAttribL1ui64ARB");
+	if (!VertexAttribL1ui64v) VertexAttribL1ui64v = (PFNGLVERTEXATTRIBL1UI64VPROC_MT)cmgr->getProcAddress("glVertexAttribL1ui64vARB");
+	if (!GetVertexAttribLui64v) GetVertexAttribLui64v = (PFNGLGETVERTEXATTRIBLUI64VPROC_MT)cmgr->getProcAddress("glGetVertexAttribLui64vARB");
+	if (!CreateSyncFromCLevent) CreateSyncFromCLevent = (PFNGLCREATESYNCFROMCLEVENTPROC_MT)cmgr->getProcAddress("glCreateSyncFromCLeventARB");
+	if (!DispatchComputeGroupSize) DispatchComputeGroupSize = (PFNGLDISPATCHCOMPUTEGROUPSIZEPROC_MT)cmgr->getProcAddress("glDispatchComputeGroupSizeARB");
+	if (!FramebufferTextureFace) FramebufferTextureFace = (PFNGLFRAMEBUFFERTEXTUREFACEPROC_MT)cmgr->getProcAddress("glFramebufferTextureFaceARB");
+	if (!Uniform1i64) Uniform1i64 = (PFNGLUNIFORM1I64PROC_MT)cmgr->getProcAddress("glUniform1i64ARB");
+	if (!Uniform2i64) Uniform2i64 = (PFNGLUNIFORM2I64PROC_MT)cmgr->getProcAddress("glUniform2i64ARB");
+	if (!Uniform3i64) Uniform3i64 = (PFNGLUNIFORM3I64PROC_MT)cmgr->getProcAddress("glUniform3i64ARB");
+	if (!Uniform4i64) Uniform4i64 = (PFNGLUNIFORM4I64PROC_MT)cmgr->getProcAddress("glUniform4i64ARB");
+	if (!Uniform1i64v) Uniform1i64v = (PFNGLUNIFORM1I64VPROC_MT)cmgr->getProcAddress("glUniform1i64vARB");
+	if (!Uniform2i64v) Uniform2i64v = (PFNGLUNIFORM2I64VPROC_MT)cmgr->getProcAddress("glUniform2i64vARB");
+	if (!Uniform3i64v) Uniform3i64v = (PFNGLUNIFORM3I64VPROC_MT)cmgr->getProcAddress("glUniform3i64vARB");
+	if (!Uniform4i64v) Uniform4i64v = (PFNGLUNIFORM4I64VPROC_MT)cmgr->getProcAddress("glUniform4i64vARB");
+	if (!Uniform1ui64) Uniform1ui64 = (PFNGLUNIFORM1UI64PROC_MT)cmgr->getProcAddress("glUniform1ui64ARB");
+	if (!Uniform2ui64) Uniform2ui64 = (PFNGLUNIFORM2UI64PROC_MT)cmgr->getProcAddress("glUniform2ui64ARB");
+	if (!Uniform3ui64) Uniform3ui64 = (PFNGLUNIFORM3UI64PROC_MT)cmgr->getProcAddress("glUniform3ui64ARB");
+	if (!Uniform4ui64) Uniform4ui64 = (PFNGLUNIFORM4UI64PROC_MT)cmgr->getProcAddress("glUniform4ui64ARB");
+	if (!Uniform1ui64v) Uniform1ui64v = (PFNGLUNIFORM1UI64VPROC_MT)cmgr->getProcAddress("glUniform1ui64vARB");
+	if (!Uniform2ui64v) Uniform2ui64v = (PFNGLUNIFORM2UI64VPROC_MT)cmgr->getProcAddress("glUniform2ui64vARB");
+	if (!Uniform3ui64v) Uniform3ui64v = (PFNGLUNIFORM3UI64VPROC_MT)cmgr->getProcAddress("glUniform3ui64vARB");
+	if (!Uniform4ui64v) Uniform4ui64v = (PFNGLUNIFORM4UI64VPROC_MT)cmgr->getProcAddress("glUniform4ui64vARB");
+	if (!GetUniformi64v) GetUniformi64v = (PFNGLGETUNIFORMI64VPROC_MT)cmgr->getProcAddress("glGetUniformi64vARB");
+	if (!GetUniformui64v) GetUniformui64v = (PFNGLGETUNIFORMUI64VPROC_MT)cmgr->getProcAddress("glGetUniformui64vARB");
+	if (!GetnUniformi64v) GetnUniformi64v = (PFNGLGETNUNIFORMI64VPROC_MT)cmgr->getProcAddress("glGetnUniformi64vARB");
+	if (!GetnUniformui64v) GetnUniformui64v = (PFNGLGETNUNIFORMUI64VPROC_MT)cmgr->getProcAddress("glGetnUniformui64vARB");
+	if (!ProgramUniform1i64) ProgramUniform1i64 = (PFNGLPROGRAMUNIFORM1I64PROC_MT)cmgr->getProcAddress("glProgramUniform1i64ARB");
+	if (!ProgramUniform2i64) ProgramUniform2i64 = (PFNGLPROGRAMUNIFORM2I64PROC_MT)cmgr->getProcAddress("glProgramUniform2i64ARB");
+	if (!ProgramUniform3i64) ProgramUniform3i64 = (PFNGLPROGRAMUNIFORM3I64PROC_MT)cmgr->getProcAddress("glProgramUniform3i64ARB");
+	if (!ProgramUniform4i64) ProgramUniform4i64 = (PFNGLPROGRAMUNIFORM4I64PROC_MT)cmgr->getProcAddress("glProgramUniform4i64ARB");
+	if (!ProgramUniform1i64v) ProgramUniform1i64v = (PFNGLPROGRAMUNIFORM1I64VPROC_MT)cmgr->getProcAddress("glProgramUniform1i64vARB");
+	if (!ProgramUniform2i64v) ProgramUniform2i64v = (PFNGLPROGRAMUNIFORM2I64VPROC_MT)cmgr->getProcAddress("glProgramUniform2i64vARB");
+	if (!ProgramUniform3i64v) ProgramUniform3i64v = (PFNGLPROGRAMUNIFORM3I64VPROC_MT)cmgr->getProcAddress("glProgramUniform3i64vARB");
+	if (!ProgramUniform4i64v) ProgramUniform4i64v = (PFNGLPROGRAMUNIFORM4I64VPROC_MT)cmgr->getProcAddress("glProgramUniform4i64vARB");
+	if (!ProgramUniform1ui64) ProgramUniform1ui64 = (PFNGLPROGRAMUNIFORM1UI64PROC_MT)cmgr->getProcAddress("glProgramUniform1ui64ARB");
+	if (!ProgramUniform2ui64) ProgramUniform2ui64 = (PFNGLPROGRAMUNIFORM2UI64PROC_MT)cmgr->getProcAddress("glProgramUniform2ui64ARB");
+	if (!ProgramUniform3ui64) ProgramUniform3ui64 = (PFNGLPROGRAMUNIFORM3UI64PROC_MT)cmgr->getProcAddress("glProgramUniform3ui64ARB");
+	if (!ProgramUniform4ui64) ProgramUniform4ui64 = (PFNGLPROGRAMUNIFORM4UI64PROC_MT)cmgr->getProcAddress("glProgramUniform4ui64ARB");
+	if (!ProgramUniform1ui64v) ProgramUniform1ui64v = (PFNGLPROGRAMUNIFORM1UI64VPROC_MT)cmgr->getProcAddress("glProgramUniform1ui64vARB");
+	if (!ProgramUniform2ui64v) ProgramUniform2ui64v = (PFNGLPROGRAMUNIFORM2UI64VPROC_MT)cmgr->getProcAddress("glProgramUniform2ui64vARB");
+	if (!ProgramUniform3ui64v) ProgramUniform3ui64v = (PFNGLPROGRAMUNIFORM3UI64VPROC_MT)cmgr->getProcAddress("glProgramUniform3ui64vARB");
+	if (!ProgramUniform4ui64v) ProgramUniform4ui64v = (PFNGLPROGRAMUNIFORM4UI64VPROC_MT)cmgr->getProcAddress("glProgramUniform4ui64vARB");
+	if (!MaxShaderCompilerThreads) MaxShaderCompilerThreads = (PFNGLMAXSHADERCOMPILERTHREADSPROC_MT)cmgr->getProcAddress("glMaxShaderCompilerThreadsARB");
+	if (!MaxShaderCompilerThreads) MaxShaderCompilerThreads = (PFNGLMAXSHADERCOMPILERTHREADSPROC_MT)cmgr->getProcAddress("glMaxShaderCompilerThreadsKHR");
+	if (!FramebufferSampleLocationsfv) FramebufferSampleLocationsfv = (PFNGLFRAMEBUFFERSAMPLELOCATIONSFVPROC_MT)cmgr->getProcAddress("glFramebufferSampleLocationsfvARB");
+	if (!NamedFramebufferSampleLocationsfv) NamedFramebufferSampleLocationsfv = (PFNGLNAMEDFRAMEBUFFERSAMPLELOCATIONSFVPROC_MT)cmgr->getProcAddress("glNamedFramebufferSampleLocationsfvARB");
+	if (!EvaluateDepthValues) EvaluateDepthValues = (PFNGLEVALUATEDEPTHVALUESPROC_MT)cmgr->getProcAddress("glEvaluateDepthValuesARB");
+	if (!NamedString) NamedString = (PFNGLNAMEDSTRINGPROC_MT)cmgr->getProcAddress("glNamedStringARB");
+	if (!DeleteNamedString) DeleteNamedString = (PFNGLDELETENAMEDSTRINGPROC_MT)cmgr->getProcAddress("glDeleteNamedStringARB");
+	if (!CompileShaderInclude) CompileShaderInclude = (PFNGLCOMPILESHADERINCLUDEPROC_MT)cmgr->getProcAddress("glCompileShaderIncludeARB");
+	if (!IsNamedString) IsNamedString = (PFNGLISNAMEDSTRINGPROC_MT)cmgr->getProcAddress("glIsNamedStringARB");
+	if (!GetNamedString) GetNamedString = (PFNGLGETNAMEDSTRINGPROC_MT)cmgr->getProcAddress("glGetNamedStringARB");
+	if (!GetNamedStringiv) GetNamedStringiv = (PFNGLGETNAMEDSTRINGIVPROC_MT)cmgr->getProcAddress("glGetNamedStringivARB");
+	if (!BufferPageCommitment) BufferPageCommitment = (PFNGLBUFFERPAGECOMMITMENTPROC_MT)cmgr->getProcAddress("glBufferPageCommitmentARB");
+	if (!NamedBufferPageCommitment) NamedBufferPageCommitment = (PFNGLNAMEDBUFFERPAGECOMMITMENTPROC_MT)cmgr->getProcAddress("glNamedBufferPageCommitmentARB");
+	if (!TexPageCommitment) TexPageCommitment = (PFNGLTEXPAGECOMMITMENTPROC_MT)cmgr->getProcAddress("glTexPageCommitmentARB");
+
+	// get the extension string, chop it up
+	std::string ext_string = std::string((char*)GetString(EXTENSIONS));
+	std::stringstream ext_ss(ext_string);
+	std::string tmp;
+	while (std::getline(ext_ss, tmp, ' '))
+		extensions.emplace(tmp);
+
+}