tmpl8/template/template.cpp - main - redgpu/tinybvh

tmpl8/template/template.cpp
1 714 строк82 KB
Jacco Bikker
Deploying new mesh collapse functionality.
18 июн 2025, 19:29
18 июн 2025, 19:29d3289df
// Template, 2024 IGAD Edition
// Get the latest version from: https://github.com/jbikker/tmpl8
// IGAD/NHTV/BUAS/UU - Jacco Bikker - 2006-2024

#include "precomp.h"

#pragma comment( linker, "/subsystem:windows /ENTRY:mainCRTStartup" )

#define TINY_OCL_GLINTEROP
#ifndef GLTF_DEMO
#define TINY_OCL_IMPLEMENTATION
#endif
#include "tiny_ocl.h"
#ifndef GLTF_DEMO
#define TINYBVH_IMPLEMENTATION
#endif
#include "tiny_bvh.h"
using namespace tinybvh;
using namespace tinyocl;
#ifdef GLTF_DEMO
// #define TINYSCENE_IMPLEMENTATION
#define TINYSCENE_USE_CUSTOM_VECTOR_TYPES
namespace tinyscene
{
using ts_int2 = int2;
using ts_int3 = int3;
using ts_uint2 = uint2;
using ts_uint3 = uint3;
using ts_uint4 = uint4;
using ts_vec2 = float2;
using ts_vec3 = float3;
using ts_vec4 = float4;
using ts_mat = mat4;
}
#include "tiny_scene.h"
#include "gltfdemo.h"
#else
#include "game.h"
#endif

using namespace Tmpl8;

// Enable usage of dedicated GPUs in notebooks
// Note: this does cause the linker to produce a .lib and .exp file;
// see http://developer.download.nvidia.com/devzone/devcenter/gamegraphics/files/OptimusRenderingPolicies.pdf
// Alternatively, you can *disable* this to make your app use less power.
#ifdef WIN32
extern "C"
{
	__declspec(dllexport) unsigned long NvOptimusEnablement = 0x00000001;
}

extern "C"
{
	__declspec(dllexport) int AmdPowerXpressRequestHighPerformance = 1;
}
#endif

GLFWwindow* window = 0;
GLFWwindow* GetGLFWWindow() { return window; }
static bool hasFocus = true, running = true;
static GLTexture* renderTarget = 0;
static int scrwidth = 0, scrheight = 0;
static TheApp* app = 0;

uint keystate[256] = { 0 };

// static member data for instruction set support class
static const CPUCaps cpucaps;

// provide access to the render target, for OpenCL / OpenGL interop
GLTexture* GetRenderTarget() { return renderTarget; }

// provide access to window focus state
bool WindowHasFocus() { return hasFocus; }

// provide access to key state array
bool IsKeyDown( const uint key ) { return keystate[key & 255] == 1; }

// GLFW callbacks
void InitRenderTarget( int w, int h )
{
	// allocate render target and surface
	scrwidth = w, scrheight = h;
	renderTarget = new GLTexture( scrwidth, scrheight, GLTexture::INTTARGET );
}
void ReshapeWindowCallback( GLFWwindow*, int w, int h )
{
	glViewport( 0, 0, w, h );
}
void KeyEventCallback( GLFWwindow*, int key, int, int action, int )
{
	if (key == GLFW_KEY_ESCAPE) running = false;
	if (action == GLFW_PRESS) { if (app) if (key >= 0) app->KeyDown( key ); keystate[key & 255] = 1; }
	else if (action == GLFW_RELEASE) { if (app) if (key >= 0) app->KeyUp( key ); keystate[key & 255] = 0; }
}
void CharEventCallback( GLFWwindow*, uint ) { /* nothing here yet */ }
void WindowFocusCallback( GLFWwindow*, int focused ) { hasFocus = (focused == GL_TRUE); }
void MouseButtonCallback( GLFWwindow*, int button, int action, int )
{
	if (action == GLFW_PRESS) { if (app) app->MouseDown( button ); }
	else if (action == GLFW_RELEASE) { if (app) app->MouseUp( button ); }
}
void MouseScrollCallback( GLFWwindow*, double, double y )
{
	app->MouseWheel( (float)y );
}
void MousePosCallback( GLFWwindow*, double x, double y )
{
	if (app) app->MouseMove( (int)x, (int)y );
}
void ErrorCallback( int, const char* description )
{
	fprintf( stderr, "GLFW Error: %s\n", description );
}

// Application entry point
int main()
{
	// open a window
	if (!glfwInit()) FatalError( "glfwInit failed." );
	glfwSetErrorCallback( ErrorCallback );
	glfwWindowHint( GLFW_CONTEXT_VERSION_MAJOR, 3 ); // 3.3 is enough for our needs
	glfwWindowHint( GLFW_CONTEXT_VERSION_MINOR, 3 );
	glfwWindowHint( GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE );
	glfwWindowHint( GLFW_STENCIL_BITS, GL_FALSE );
	glfwWindowHint( GLFW_RESIZABLE, GL_FALSE /* easier :) */ );
#ifdef FULLSCREEN
	window = glfwCreateWindow( SCRWIDTH, SCRHEIGHT, "Tmpl8-2024", glfwGetPrimaryMonitor(), 0 );
#else
	window = glfwCreateWindow( SCRWIDTH, SCRHEIGHT, "Tmpl8-2024", 0, 0 );
#endif
	if (!window) FatalError( "glfwCreateWindow failed." );
	glfwMakeContextCurrent( window );
	// register callbacks
	glfwSetWindowSizeCallback( window, ReshapeWindowCallback );
	glfwSetKeyCallback( window, KeyEventCallback );
	glfwSetWindowFocusCallback( window, WindowFocusCallback );
	glfwSetMouseButtonCallback( window, MouseButtonCallback );
	glfwSetScrollCallback( window, MouseScrollCallback );
	glfwSetCursorPosCallback( window, MousePosCallback );
	glfwSetCharCallback( window, CharEventCallback );
	// initialize GLAD
	if (gladLoaderLoadGL() == 0) FatalError( "gladLoadGLLoader failed." );
	glfwSwapInterval( 0 );
	// prepare OpenGL state
	glDisable( GL_DEPTH_TEST );
	glDisable( GL_CULL_FACE );
	glDisable( GL_BLEND );
	CheckGL();
	// we want a console window for text output
#ifndef FULLSCREEN
	CONSOLE_SCREEN_BUFFER_INFO coninfo;
	AllocConsole();
	GetConsoleScreenBufferInfo( GetStdHandle( STD_OUTPUT_HANDLE ), &coninfo );
	coninfo.dwSize.X = 1280;
	coninfo.dwSize.Y = 800;
	SetConsoleScreenBufferSize( GetStdHandle( STD_OUTPUT_HANDLE ), coninfo.dwSize );
	FILE* file = nullptr;
	freopen_s( &file, "CON", "w", stdout );
	freopen_s( &file, "CON", "w", stderr );
	SetWindowPos( GetConsoleWindow(), HWND_TOP, 0, 0, 1280, 800, 0 );
	glfwShowWindow( window );
	// use the new console window to print some important things
	printf( "Running Tmpl8-2024, updated on July 21\n" );
	char dir[2048];
	printf( "Working directory: %s\n", getcwd( dir, 2048 ) );
#endif
	// initialize application
	InitRenderTarget( SCRWIDTH, SCRHEIGHT );
	Surface* screen = new Surface( SCRWIDTH, SCRHEIGHT );
#ifdef GLTF_DEMO
	app = new GLTFDemo();
#else
	app = new Game();
#endif
	app->screen = screen;
	app->Init();
	// done, enter main loop
#if 0
	// crt shader, https://github.com/libretro/slang-shaders/tree/master/crt/shaders/hyllian
	char fs[] =
		"#version 330											\n"
		"uniform sampler2D c; in vec2 uv; out vec4 f;			\n"
		"#define SCRWIDTH             							\n"
		"#define SCRHEIGHT             							\n"
		"#define MASK_INTENSITY 0.5								\n"
		"#define InputGamma		2.4								\n"
		"#define OutputGamma	2.2								\n"
		"#define BRIGHTBOOST	1.5								\n"
		"#define SCANLINES		0.72							\n"
		"#define SHARPER		0								\n"
		"#define GAMMA_IN(color)  pow(color, vec3(InputGamma, InputGamma, InputGamma)) \n"
		"#define GAMMA_OUT(color) pow(color, vec3(1.0 / OutputGamma, 1.0 / OutputGamma, 1.0 / OutputGamma)) \n"
		"void main(){											\n"
		"vec2 vt = uv; /* vec2(uv.x-0.499999,uv.y); */			\n"
		"vec2 ss = vec2( SCRWIDTH, SCRHEIGHT );					\n"
		"vec2 ps = vec2( 1.0 / ss.x, 1.0 / ss.y );				\n"
		"vec2 dx = vec2( ps.x, 0.0 ), dy = vec2( 0.0, ps.y );	\n"
		"vec2 tc = (floor( vt.xy * ss.xy ) + vec2( 0.49999, 0.49999 )) / ss.xy; \n"
		"vec2 fp = fract( vt.xy * ss.xy );						\n"
		"vec3 c10 = texture( c, tc - dx ).xyz;					\n"
		"vec3 c11 = texture( c, tc ).xyz;						\n"
		"vec3 c12 = texture( c, tc + dx ).xyz;					\n"
		"vec3 c13 = texture( c, tc + 2.0 * dx ).xyz;			\n"
		"vec4 lobes = vec4( fp.x * fp.x * fp.x, fp.x * fp.x, fp.x, 1.0 ); \n"
		"vec4 i = vec4( 0.0 );									\n"
		"if (SHARPER == 0.0) { /* CATROM */						\n"
		"i.x = dot( vec4( -0.5, 1.0, -0.5, 0.0 ), lobes );		\n"
		"i.y = dot( vec4( 1.5, -2.5, 0.0, 1.0 ), lobes );		\n"
		"i.z = dot( vec4( -1.5, 2.0, 0.5, 0.0 ), lobes );		\n"
		"i.w = dot( vec4( 0.5, -0.5, 0.0, 0.0 ), lobes );		\n"
		"} else if (SHARPER == 1.0) { /* HERMITE */				\n"
		"i.x = dot( vec4( 0.0, 0.0, 0.0, 0.0 ), lobes );		\n"
		"i.y = dot( vec4( 2.0, -3.0, 0.0, 1.0 ), lobes );		\n"
		"i.z = dot( vec4( -2.0, 3.0, 0.0, 0.0 ), lobes );		\n"
		"i.w = dot( vec4( 0.0, 0.0, 0.0, 0.0 ), lobes );}		\n"
		"vec3 color = i.x * c10.xyz;							\n"
		"color += i.y * c11.xyz + i.z * c12.xyz + i.w * c13.xyz; \n"
		"color = GAMMA_IN( color );								\n"
		"float pos1 = 1.5 - SCANLINES - abs( fp.y - 0.5 );		\n"
		"float d1 = max( 0.0, min( 1.0, pos1 ) );				\n"
		"float d = d1 * d1 * (3.0 + BRIGHTBOOST - (2.0 * d1));	\n"
		"vec4 dmw = mix(										\n"
		"vec4( 1.0, 1.0 - MASK_INTENSITY, 1.0, 1. ),			\n"
		"vec4( 1.0 - MASK_INTENSITY, 1.0, 1.0 - MASK_INTENSITY, 1.),	\n"
		"floor( mod( vt.x * ss.x * 4, 2.0 ) ) );				\n"
		"color *= d * vec3( dmw.x, dmw.y, dmw.z );				\n"
		"f = vec4( GAMMA_OUT( color ), 1.0 );}";
	char* sw = strstr( fs, "SCRWIDTH " ), * sh = strstr( fs, "SCRHEIGHT " );
	char swt[16], sht[16];
	sprintf( swt, "%i", SCRWIDTH / 4 );
	sprintf( sht, "%i", SCRHEIGHT / 4 );
	memcpy( sw + 9, swt, strlen( swt ) );
	memcpy( sh + 10, sht, strlen( sht ) );
	Shader* shader = new Shader(
		"#version 330\nin vec4 p;\nout vec2 uv;void main(){uv=vec2((p.x+1)/2,1-(p.y+1)/2);gl_Position=vec4(p.x,p.y,1,1);}",
		fs, true );
#else
#if 1
	// basic shader, no gamma correction
	Shader* shader = new Shader(
		"#version 330\nin vec4 p;\nout vec2 u;void main(){u=vec2((p.x+1)/2,1-(p.y+1)/2);gl_Position=vec4(p.x,p.y,1,1);}",
		"#version 330\nuniform sampler2D c;in vec2 u;out vec4 f;void main(){f=texture(c,u);}", true );
#else
	// fxaa shader
	Shader* shader = new Shader(
		"#version 330\nin vec4 p;\nout vec2 uv;void main(){uv=vec2((p.x+1)/2,1-(p.y+1)/2);gl_Position=vec4(p.x,p.y,1,1);}",
		// FXAA 3.11 Implementation - effendiian
		// https://www.shadertoy.com/view/ttXGzn
		"#version 330\nuniform sampler2D tex;\nin vec2 uv;out vec4 f; \n"							\
		"#define FXAA_LUMINANCE 			1					\n"									\
		"#define FXAA_EDGE_THRESHOLD	  	(1.0/8.0)			\n"									\
		"#define FXAA_EDGE_THRESHOLD_MIN  	(1.0/24.0)			\n"									\
		"#define FXAA_SEARCH_STEPS			32					\n"									\
		"#define FXAA_SEARCH_ACCELERATION 	1					\n"									\
		"#define FXAA_SEARCH_THRESHOLD		(1.0/4.0)			\n"									\
		"#define FXAA_SUBPIX				2 // 1 is crisper	\n"									\
		"#define FXAA_SUBPIX_CAP			(3.0/4.0)			\n"									\
		"#define FXAA_SUBPIX_TRIM			(1.0/4.0)			\n"									\
		"#define FXAA_SUBPIX_TRIM_SCALE (1.0/(1.0 - FXAA_SUBPIX_TRIM))	\n"							\
		"float lum( vec3 color ) {\n #if FXAA_LUMINANCE == 0 \n"									\
		"	return color.x * 0.2126729 + color.y * 0.7151522 + color.z * 0.0721750; \n"				\
		"#else \n return color.g * (0.587 / 0.299) + color.r; \n #endif \n }"						\
		"float vertEdge( float lumaO, float lumaN, float lumaE, float lumaS,"						\
		"	float lumaW, float lumaNW, float lumaNE, float lumaSW, float lumaSE )"					\
		"{	float top = (0.25 * lumaNW) + (-0.5 * lumaN) + (0.25 * lumaNE);"						\
		"	float middle = (0.50 * lumaW) + (-1.0 * lumaO) + (0.50 * lumaE);"						\
		"	float bottom = (0.25 * lumaSW) + (-0.5 * lumaS) + (0.25 * lumaSE);"						\
		"	return abs( top ) + abs( middle ) + abs( bottom ); }"									\
		"float horEdge( float lumaO, float lumaN, float lumaE, float lumaS,"						\
		"	float lumaW, float lumaNW, float lumaNE, float lumaSW, float lumaSE )"					\
		"{	float top = (0.25 * lumaNW) + (-0.5 * lumaW) + (0.25 * lumaSW);"						\
		"	float middle = (0.50 * lumaN) + (-1.0 * lumaO) + (0.50 * lumaS);"						\
		"	float bottom = (0.25 * lumaNE) + (-0.5 * lumaE) + (0.25 * lumaSE);"						\
		"	return abs( top ) + abs( middle ) + abs( bottom ); }"									\
		"vec3 fxaa( vec2 textureDimensions, vec2 uv )"												\
		"{	vec2 texel = vec2( 1.0, 1.0 ) / textureDimensions;"										\
		"	vec3 rgbN = texture( tex, uv + vec2( 0, -texel.y ) ).rgb,"								\
		"		 rgbW = texture( tex, uv + vec2( -texel.x, 0 ) ).rgb,"								\
		"		 rgbO = texture( tex, uv + vec2( 0, 0 ) ).rgb,"										\
		"		 rgbE = texture( tex, uv + vec2( texel.x, 0 ) ).rgb,"								\
		"		 rgbS = texture( tex, uv + vec2( 0, texel.y ) ).rgb;"								\
		"	float lumaN = lum( rgbN ), lumaW = lum( rgbW );"										\
		"	float lumaO = lum( rgbO ), lumaE = lum( rgbE ), lumaS = lum( rgbS );"					\
		"	float minLuma = min( lumaO, min( min( lumaN, lumaW ), min( lumaS, lumaE ) ) );"			\
		"	float maxLuma = max( lumaO, max( max( lumaN, lumaW ), max( lumaS, lumaE ) ) );"			\
		"	float localContrast = maxLuma - minLuma;"												\
		"	if (localContrast < max( FXAA_EDGE_THRESHOLD_MIN, maxLuma* FXAA_EDGE_THRESHOLD ))"		\
		"		return rgbO;"																		\
		"	vec3 rgbL = rgbN + rgbW + rgbO + rgbE + rgbS;"											\
		"	float lumaL = (lumaN + lumaW + lumaS + lumaE) * 0.25;"									\
		"	float pixelContrast = abs( lumaL - lumaO );"											\
		"	float contrastRatio = pixelContrast / localContrast;"									\
		"	float lowpassBlend = 0;			\n"														\
		"#if FXAA_SUBPIX == 1				\n"														\
		"	lowpassBlend = max( 0.0, contrastRatio - FXAA_SUBPIX_TRIM ) * FXAA_SUBPIX_TRIM_SCALE;"	\
		"	lowpassBlend = min( FXAA_SUBPIX_CAP, lowpassBlend );	\n"								\
		"#elif FXAA_SUBPIX == 2				\n"														\
		"	lowpassBlend = contrastRatio;	\n"														\
		"#endif								\n"														\
		"	vec3 rgbNW = texture( tex, uv + vec2( -texel.x, -texel.y ) ).rgb,"						\
		"		 rgbNE = texture( tex, uv + vec2( texel.x, -texel.y ) ).rgb,"						\
		"		 rgbSW = texture( tex, uv + vec2( -texel.x, texel.y ) ).rgb,"						\
		"		 rgbSE = texture( tex, uv + vec2( texel.x, texel.y ) ).rgb;"						\
		"	rgbL += (rgbNW + rgbNE + rgbSW + rgbSE);"												\
		"	rgbL *= (1.0 / 9.0);"																	\
		"	float lumaNW = lum( rgbNW ), lumaNE = lum( rgbNE );"									\
		"	float lumaSW = lum( rgbSW ), lumaSE = lum( rgbSE );"									\
		"	float edgeVert = vertEdge( lumaO, lumaN, lumaE, lumaS, lumaW, lumaNW, lumaNE, lumaSW, lumaSE );" \
		"	float edgeHori = horEdge( lumaO, lumaN, lumaE, lumaS, lumaW, lumaNW, lumaNE, lumaSW, lumaSE );" \
		"	bool isHorizontal = edgeHori >= edgeVert;"												\
		"	float edgeSign = isHorizontal ? -texel.y : -texel.x;"									\
		"	float gradNeg = isHorizontal ? abs( lumaN - lumaO ) : abs( lumaW - lumaO );"			\
		"	float gradPos = isHorizontal ? abs( lumaS - lumaO ) : abs( lumaE - lumaO );"			\
		"	float lumaNeg = isHorizontal ? ((lumaN + lumaO) * 0.5) : ((lumaW + lumaO) * 0.5);"		\
		"	float lumaPos = isHorizontal ? ((lumaS + lumaO) * 0.5) : ((lumaE + lumaO) * 0.5);"		\
		"	bool isNegative = (gradNeg >= gradPos);"												\
		"	float gradientHighest = isNegative ? gradNeg : gradPos;"								\
		"	float lumaHighest = isNegative ? lumaNeg : lumaPos;"									\
		"	if (isNegative) edgeSign *= -1.0;"														\
		"	vec2 pointN = vec2( 0.0, 0.0 );"														\
		"	pointN.x = uv.x + (isHorizontal ? 0.0 : edgeSign * 0.5);"								\
		"	pointN.y = uv.y + (isHorizontal ? edgeSign * 0.5 : 0.0);"								\
		"	gradientHighest *= FXAA_SEARCH_THRESHOLD;"												\
		"	vec2 pointP = pointN;"																	\
		"	vec2 offset = isHorizontal ? vec2( texel.x, 0.0 ) : vec2( 0.0, texel.y );"				\
		"	float lumaNegEnd = lumaNeg, lumaPosEnd = lumaPos;"										\
		"	bool searchNeg = false, searchPos = false;\n"											\
		"#if FXAA_SEARCH_ACCELERATION == 1\n"														\
		"	pointN -= offset, pointP += offset;\n"													\
		"#elif FXAA_SEARCH_ACCELERATION == 2\n"														\
		"	pointN -= offset * 1.5, pointP += offset * 1.5, offset *= 2;\n"							\
		"#elif FXAA_SEARCH_ACCELERATION == 3\n"														\
		"	pointN -= offset * 2, pointP += offset * 2, offset *= 3;\n"								\
		"#elif FXAA_SEARCH_ACCELERATION == 4\n"														\
		"	pointN -= offset * 2.5, pointP += offset * 2.5, offset *= 4;\n"							\
		"#endif\n"																					\
		"	for (int i = 0; i < FXAA_SEARCH_STEPS; i++) {\n"										\
		"	#if FXAA_SEARCH_ACCELERATION == 1\n"													\
		"		if (!searchNeg) lumaNegEnd = lum( texture( tex, pointN ).rgb );"					\
		"		if (!searchPos) lumaPosEnd = lum( texture( tex, pointP ).rgb );\n"					\
		"	#else \n"																				\
		"		if (!searchNeg) lumaNegEnd = lum( textureGrad( tex, pointN, offset, offset ).rgb );"	\
		"		if (!searchPos) lumaPosEnd = lum( textureGrad( tex, pointP, offset, offset ).rgb );\n"	\
		"	#endif \n"																				\
		"		searchNeg = searchNeg || (abs( lumaNegEnd - lumaHighest ) >= gradientHighest);"		\
		"		searchPos = searchPos || (abs( lumaPosEnd - lumaPos ) >= gradPos);"					\
		"		if (searchNeg && searchPos) break;"													\
		"		if (!searchNeg) pointN -= offset;"													\
		"		if (!searchPos) pointP += offset; }"												\
		"	float distanceNeg = isHorizontal ? uv.x - pointN.x : uv.y - pointN.y;"					\
		"	float distancePos = isHorizontal ? pointP.x - uv.x : pointP.y - uv.y;"					\
		"	bool isCloserToNegative = distanceNeg < distancePos;"									\
		"	float lumaEnd = isCloserToNegative ? lumaNegEnd : lumaPosEnd;"							\
		"	if (((lumaO - lumaNeg) < 0.0) == ((lumaEnd - lumaNeg) < 0.0)) edgeSign = 0.0;"			\
		"	float spanLen = distancePos + distanceNeg;"												\
		"	float dist = isCloserToNegative ? distanceNeg : distancePos;"							\
		"	float subOffs = (0.5 + (dist * (-1.0 / spanLen))) * edgeSign;"							\
		"	vec3 rgbOffset = textureLod( tex, vec2( uv.x + (isHorizontal ? 0.0 :"					\
		"		subOffs), uv.y + (isHorizontal ? subOffs : 0.0) ), 0.0 ).rgb;"						\
		"	return mix( rgbOffset, rgbL, lowpassBlend ); }"											\
		"void main(){f=vec4(sqrt(fxaa(vec2(1240,800),uv)),1);}", true );
#endif
#endif
	float deltaTime = 0;
	static int frameNr = 0;
	static Timer timer;
	while (!glfwWindowShouldClose( window ))
	{
		deltaTime = min( 500.0f, 1000.0f * timer.elapsed() );
		timer.reset();
		app->Tick( deltaTime );
		// send the rendering result to the screen using OpenGL
		if (frameNr++ > 1)
		{
			if (app->screen) renderTarget->CopyFrom( app->screen );
			shader->Bind();
			shader->SetInputTexture( 0, "c", renderTarget );
			DrawQuad();
			shader->Unbind();
			glfwSwapBuffers( window );
			glfwPollEvents();
		}
		if (!running) break;
	}
	// close down
	app->Shutdown();
	glfwDestroyWindow( window );
	glfwTerminate();
	return 0;
}

// Jobmanager implementation
DWORD JobThreadProc( LPVOID lpParameter )
{
	JobThread* JobThreadInstance = (JobThread*)lpParameter;
	if (JobThreadInstance /* just here to avoid 'unreachable code' warning */)
		JobThreadInstance->BackgroundTask();
	return 0;
}

void JobThread::CreateAndStartThread( unsigned int threadId )
{
	m_GoSignal = CreateEvent( 0, FALSE, FALSE, 0 );
	m_ThreadHandle = CreateThread( 0, 0, (LPTHREAD_START_ROUTINE)&JobThreadProc, (LPVOID)this, 0, 0 );
	m_ThreadID = threadId;
}
void JobThread::BackgroundTask()
{
	while (1)
	{
		WaitForSingleObject( m_GoSignal, INFINITE );
		while (1)
		{
			Job* job = JobManager::GetJobManager()->GetNextJob();
			if (!job)
			{
				JobManager::GetJobManager()->ThreadDone( m_ThreadID );
				break;
			}
			job->RunCodeWrapper();
		}
	}
}

void JobThread::Go()
{
	SetEvent( m_GoSignal );
}

void Job::RunCodeWrapper()
{
	Main();
}

JobManager* JobManager::m_JobManager = 0;

JobManager::JobManager( unsigned int threads ) : m_NumThreads( threads )
{
	InitializeCriticalSection( &m_CS );
}

JobManager::~JobManager()
{
	DeleteCriticalSection( &m_CS );
}

void JobManager::CreateJobManager( unsigned int numThreads )
{
	m_JobManager = new JobManager( numThreads );
	m_JobManager->m_JobThreadList = new JobThread[numThreads];
	for (unsigned int i = 0; i < numThreads; i++)
	{
		m_JobManager->m_JobThreadList[i].CreateAndStartThread( i );
		m_JobManager->m_ThreadDone[i] = CreateEvent( 0, FALSE, FALSE, 0 );
	}
	m_JobManager->m_JobCount = 0;
}

void JobManager::AddJob2( Job* a_Job )
{
	m_JobList[m_JobCount++] = a_Job;
}

Job* JobManager::GetNextJob()
{
	Job* job = 0;
	EnterCriticalSection( &m_CS );
	if (m_JobCount > 0) job = m_JobList[--m_JobCount];
	LeaveCriticalSection( &m_CS );
	return job;
}

void JobManager::RunJobs()
{
	if (m_JobCount == 0) return;
	for (unsigned int i = 0; i < m_NumThreads; i++) m_JobThreadList[i].Go();
	WaitForMultipleObjects( m_NumThreads, m_ThreadDone, TRUE, INFINITE );
}

void JobManager::ThreadDone( unsigned int n )
{
	SetEvent( m_ThreadDone[n] );
}

DWORD CountSetBits( ULONG_PTR bitMask )
{
	DWORD LSHIFT = sizeof( ULONG_PTR ) * 8 - 1, bitSetCount = 0;
	ULONG_PTR bitTest = (ULONG_PTR)1 << LSHIFT;
	for (DWORD i = 0; i <= LSHIFT; ++i) bitSetCount += ((bitMask & bitTest) ? 1 : 0), bitTest /= 2;
	return bitSetCount;
}

void JobManager::GetProcessorCount( uint& cores, uint& logical )
{
	// https://github.com/GPUOpen-LibrariesAndSDKs/cpu-core-counts
	cores = logical = 0;
	char* buffer = NULL;
	DWORD len = 0;
	if (FALSE == GetLogicalProcessorInformationEx( RelationAll, (PSYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX)buffer, &len ))
	{
		if (GetLastError() == ERROR_INSUFFICIENT_BUFFER)
		{
			buffer = (char*)malloc( len );
			if (GetLogicalProcessorInformationEx( RelationAll, (PSYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX)buffer, &len ))
			{
				char* ptr = buffer;
				while (ptr < buffer + len)
				{
					PSYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX pi = (PSYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX)ptr;
					if (pi->Relationship == RelationProcessorCore)
					{
						cores++;
						for (size_t g = 0; g < pi->Processor.GroupCount; ++g)
							logical += CountSetBits( pi->Processor.GroupMask[g].Mask );
					}
					ptr += pi->Size;
				}
			}
			free( buffer );
		}
	}
}

JobManager* JobManager::GetJobManager()
{
	if (!m_JobManager)
	{
		uint c, l;
		GetProcessorCount( c, l );
		CreateJobManager( l );
	}
	return m_JobManager;
}

// Helper functions
bool FileIsNewer( const char* file1, const char* file2 )
{
	struct stat f1;
	struct stat f2;

	auto ret = stat( file1, &f1 );
	FATALERROR_IF( ret, "File %s not found!", file1 );

	if (stat( file2, &f2 )) return true; // second file does not exist

#ifdef _MSC_VER
	return f1.st_mtime >= f2.st_mtime;
#else
	if (f1.st_mtim.tv_sec >= f2.st_mtim.tv_sec)
		return true;
	return f1.st_mtim.tv_nsec >= f2.st_mtim.tv_nsec;
#endif
}

bool FileExists( const char* f )
{
	ifstream s( f );
	return s.good();
}

bool RemoveFile( const char* f )
{
	if (!FileExists( f )) return false;
	return !remove( f );
}

uint FileSize( string filename )
{
	ifstream s( filename );
	return s.good();
}

string TextFileRead( const char* _File )
{
	ifstream s( _File );
	string str( (istreambuf_iterator<char>( s )), istreambuf_iterator<char>() );
	s.close();
	return str;
}

void TextFileWrite( const string& text, const char* _File )
{
	ofstream s( _File, ios::binary );
	int len = (int)text.size();
	s.write( (const char*)&len, sizeof( len ) );
	s.write( text.c_str(), len );
}

/**
 * Loader generated by glad 2.0.6 on Wed Jun 19 06:26:12 2024
 *
 * SPDX-License-Identifier: (WTFPL OR CC0-1.0) AND Apache-2.0
 *
 * Generator: C/C++
 * Specification: gl
 * Extensions: 0
 *
 * APIs:
 *  - gl:core=4.6
 *
 * Options:
 *  - ALIAS = False
 *  - DEBUG = False
 *  - HEADER_ONLY = False
 *  - LOADER = True
 *  - MX = False
 *  - ON_DEMAND = False
 *
 * Commandline:
 *    --api='gl:core=4.6' --extensions='' c --loader
 *
 * Online:
 *    http://glad.sh/#api=gl%3Acore%3D4.6&extensions=&generator=c&options=LOADER
 *
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "glad.h"

#ifdef _MSC_VER
#define GLAD_IMPL_UTIL_SSCANF sscanf_s
#else
#define GLAD_IMPL_UTIL_SSCANF sscanf
#endif

#ifdef __cplusplus
extern "C" {
#endif

	int GLAD_GL_VERSION_1_0 = 0;
	int GLAD_GL_VERSION_1_1 = 0;
	int GLAD_GL_VERSION_1_2 = 0;
	int GLAD_GL_VERSION_1_3 = 0;
	int GLAD_GL_VERSION_1_4 = 0;
	int GLAD_GL_VERSION_1_5 = 0;
	int GLAD_GL_VERSION_2_0 = 0;
	int GLAD_GL_VERSION_2_1 = 0;
	int GLAD_GL_VERSION_3_0 = 0;
	int GLAD_GL_VERSION_3_1 = 0;
	int GLAD_GL_VERSION_3_2 = 0;
	int GLAD_GL_VERSION_3_3 = 0;

	PFNGLACTIVETEXTUREPROC glad_glActiveTexture = NULL;
	PFNGLATTACHSHADERPROC glad_glAttachShader = NULL;
	PFNGLBEGINCONDITIONALRENDERPROC glad_glBeginConditionalRender = NULL;
	PFNGLBEGINQUERYPROC glad_glBeginQuery = NULL;
	PFNGLBEGINTRANSFORMFEEDBACKPROC glad_glBeginTransformFeedback = NULL;
	PFNGLBINDATTRIBLOCATIONPROC glad_glBindAttribLocation = NULL;
	PFNGLBINDBUFFERPROC glad_glBindBuffer = NULL;
	PFNGLBINDBUFFERBASEPROC glad_glBindBufferBase = NULL;
	PFNGLBINDBUFFERRANGEPROC glad_glBindBufferRange = NULL;
	PFNGLBINDFRAGDATALOCATIONPROC glad_glBindFragDataLocation = NULL;
	PFNGLBINDFRAGDATALOCATIONINDEXEDPROC glad_glBindFragDataLocationIndexed = NULL;
	PFNGLBINDFRAMEBUFFERPROC glad_glBindFramebuffer = NULL;
	PFNGLBINDRENDERBUFFERPROC glad_glBindRenderbuffer = NULL;
	PFNGLBINDSAMPLERPROC glad_glBindSampler = NULL;
	PFNGLBINDTEXTUREPROC glad_glBindTexture = NULL;
	PFNGLBINDVERTEXARRAYPROC glad_glBindVertexArray = NULL;
	PFNGLBLENDCOLORPROC glad_glBlendColor = NULL;
	PFNGLBLENDEQUATIONPROC glad_glBlendEquation = NULL;
	PFNGLBLENDEQUATIONSEPARATEPROC glad_glBlendEquationSeparate = NULL;
	PFNGLBLENDFUNCPROC glad_glBlendFunc = NULL;
	PFNGLBLENDFUNCSEPARATEPROC glad_glBlendFuncSeparate = NULL;
	PFNGLBLITFRAMEBUFFERPROC glad_glBlitFramebuffer = NULL;
	PFNGLBUFFERDATAPROC glad_glBufferData = NULL;
	PFNGLBUFFERSUBDATAPROC glad_glBufferSubData = NULL;
	PFNGLCHECKFRAMEBUFFERSTATUSPROC glad_glCheckFramebufferStatus = NULL;
	PFNGLCLAMPCOLORPROC glad_glClampColor = NULL;
	PFNGLCLEARPROC glad_glClear = NULL;
	PFNGLCLEARBUFFERFIPROC glad_glClearBufferfi = NULL;
	PFNGLCLEARBUFFERFVPROC glad_glClearBufferfv = NULL;
	PFNGLCLEARBUFFERIVPROC glad_glClearBufferiv = NULL;
	PFNGLCLEARBUFFERUIVPROC glad_glClearBufferuiv = NULL;
	PFNGLCLEARCOLORPROC glad_glClearColor = NULL;
	PFNGLCLEARDEPTHPROC glad_glClearDepth = NULL;
	PFNGLCLEARSTENCILPROC glad_glClearStencil = NULL;
	PFNGLCLIENTWAITSYNCPROC glad_glClientWaitSync = NULL;
	PFNGLCOLORMASKPROC glad_glColorMask = NULL;
	PFNGLCOLORMASKIPROC glad_glColorMaski = NULL;
	PFNGLCOMPILESHADERPROC glad_glCompileShader = NULL;
	PFNGLCOMPRESSEDTEXIMAGE1DPROC glad_glCompressedTexImage1D = NULL;
	PFNGLCOMPRESSEDTEXIMAGE2DPROC glad_glCompressedTexImage2D = NULL;
	PFNGLCOMPRESSEDTEXIMAGE3DPROC glad_glCompressedTexImage3D = NULL;
	PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC glad_glCompressedTexSubImage1D = NULL;
	PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC glad_glCompressedTexSubImage2D = NULL;
	PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC glad_glCompressedTexSubImage3D = NULL;
	PFNGLCOPYBUFFERSUBDATAPROC glad_glCopyBufferSubData = NULL;
	PFNGLCOPYTEXIMAGE1DPROC glad_glCopyTexImage1D = NULL;
	PFNGLCOPYTEXIMAGE2DPROC glad_glCopyTexImage2D = NULL;
	PFNGLCOPYTEXSUBIMAGE1DPROC glad_glCopyTexSubImage1D = NULL;
	PFNGLCOPYTEXSUBIMAGE2DPROC glad_glCopyTexSubImage2D = NULL;
	PFNGLCOPYTEXSUBIMAGE3DPROC glad_glCopyTexSubImage3D = NULL;
	PFNGLCREATEPROGRAMPROC glad_glCreateProgram = NULL;
	PFNGLCREATESHADERPROC glad_glCreateShader = NULL;
	PFNGLCULLFACEPROC glad_glCullFace = NULL;
	PFNGLDELETEBUFFERSPROC glad_glDeleteBuffers = NULL;
	PFNGLDELETEFRAMEBUFFERSPROC glad_glDeleteFramebuffers = NULL;
	PFNGLDELETEPROGRAMPROC glad_glDeleteProgram = NULL;
	PFNGLDELETEQUERIESPROC glad_glDeleteQueries = NULL;
	PFNGLDELETERENDERBUFFERSPROC glad_glDeleteRenderbuffers = NULL;
	PFNGLDELETESAMPLERSPROC glad_glDeleteSamplers = NULL;
	PFNGLDELETESHADERPROC glad_glDeleteShader = NULL;
	PFNGLDELETESYNCPROC glad_glDeleteSync = NULL;
	PFNGLDELETETEXTURESPROC glad_glDeleteTextures = NULL;
	PFNGLDELETEVERTEXARRAYSPROC glad_glDeleteVertexArrays = NULL;
	PFNGLDEPTHFUNCPROC glad_glDepthFunc = NULL;
	PFNGLDEPTHMASKPROC glad_glDepthMask = NULL;
	PFNGLDEPTHRANGEPROC glad_glDepthRange = NULL;
	PFNGLDETACHSHADERPROC glad_glDetachShader = NULL;
	PFNGLDISABLEPROC glad_glDisable = NULL;
	PFNGLDISABLEVERTEXATTRIBARRAYPROC glad_glDisableVertexAttribArray = NULL;
	PFNGLDISABLEIPROC glad_glDisablei = NULL;
	PFNGLDRAWARRAYSPROC glad_glDrawArrays = NULL;
	PFNGLDRAWARRAYSINSTANCEDPROC glad_glDrawArraysInstanced = NULL;
	PFNGLDRAWBUFFERPROC glad_glDrawBuffer = NULL;
	PFNGLDRAWBUFFERSPROC glad_glDrawBuffers = NULL;
	PFNGLDRAWELEMENTSPROC glad_glDrawElements = NULL;
	PFNGLDRAWELEMENTSBASEVERTEXPROC glad_glDrawElementsBaseVertex = NULL;
	PFNGLDRAWELEMENTSINSTANCEDPROC glad_glDrawElementsInstanced = NULL;
	PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC glad_glDrawElementsInstancedBaseVertex = NULL;
	PFNGLDRAWRANGEELEMENTSPROC glad_glDrawRangeElements = NULL;
	PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC glad_glDrawRangeElementsBaseVertex = NULL;
	PFNGLENABLEPROC glad_glEnable = NULL;
	PFNGLENABLEVERTEXATTRIBARRAYPROC glad_glEnableVertexAttribArray = NULL;
	PFNGLENABLEIPROC glad_glEnablei = NULL;
	PFNGLENDCONDITIONALRENDERPROC glad_glEndConditionalRender = NULL;
	PFNGLENDQUERYPROC glad_glEndQuery = NULL;
	PFNGLENDTRANSFORMFEEDBACKPROC glad_glEndTransformFeedback = NULL;
	PFNGLFENCESYNCPROC glad_glFenceSync = NULL;
	PFNGLFINISHPROC glad_glFinish = NULL;
	PFNGLFLUSHPROC glad_glFlush = NULL;
	PFNGLFLUSHMAPPEDBUFFERRANGEPROC glad_glFlushMappedBufferRange = NULL;
	PFNGLFRAMEBUFFERRENDERBUFFERPROC glad_glFramebufferRenderbuffer = NULL;
	PFNGLFRAMEBUFFERTEXTUREPROC glad_glFramebufferTexture = NULL;
	PFNGLFRAMEBUFFERTEXTURE1DPROC glad_glFramebufferTexture1D = NULL;
	PFNGLFRAMEBUFFERTEXTURE2DPROC glad_glFramebufferTexture2D = NULL;
	PFNGLFRAMEBUFFERTEXTURE3DPROC glad_glFramebufferTexture3D = NULL;
	PFNGLFRAMEBUFFERTEXTURELAYERPROC glad_glFramebufferTextureLayer = NULL;
	PFNGLFRONTFACEPROC glad_glFrontFace = NULL;
	PFNGLGENBUFFERSPROC glad_glGenBuffers = NULL;
	PFNGLGENFRAMEBUFFERSPROC glad_glGenFramebuffers = NULL;
	PFNGLGENQUERIESPROC glad_glGenQueries = NULL;
	PFNGLGENRENDERBUFFERSPROC glad_glGenRenderbuffers = NULL;
	PFNGLGENSAMPLERSPROC glad_glGenSamplers = NULL;
	PFNGLGENTEXTURESPROC glad_glGenTextures = NULL;
	PFNGLGENVERTEXARRAYSPROC glad_glGenVertexArrays = NULL;
	PFNGLGENERATEMIPMAPPROC glad_glGenerateMipmap = NULL;
	PFNGLGETACTIVEATTRIBPROC glad_glGetActiveAttrib = NULL;
	PFNGLGETACTIVEUNIFORMPROC glad_glGetActiveUniform = NULL;
	PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC glad_glGetActiveUniformBlockName = NULL;
	PFNGLGETACTIVEUNIFORMBLOCKIVPROC glad_glGetActiveUniformBlockiv = NULL;
	PFNGLGETACTIVEUNIFORMNAMEPROC glad_glGetActiveUniformName = NULL;
	PFNGLGETACTIVEUNIFORMSIVPROC glad_glGetActiveUniformsiv = NULL;
	PFNGLGETATTACHEDSHADERSPROC glad_glGetAttachedShaders = NULL;
	PFNGLGETATTRIBLOCATIONPROC glad_glGetAttribLocation = NULL;
	PFNGLGETBOOLEANI_VPROC glad_glGetBooleani_v = NULL;
	PFNGLGETBOOLEANVPROC glad_glGetBooleanv = NULL;
	PFNGLGETBUFFERPARAMETERI64VPROC glad_glGetBufferParameteri64v = NULL;
	PFNGLGETBUFFERPARAMETERIVPROC glad_glGetBufferParameteriv = NULL;
	PFNGLGETBUFFERPOINTERVPROC glad_glGetBufferPointerv = NULL;
	PFNGLGETBUFFERSUBDATAPROC glad_glGetBufferSubData = NULL;
	PFNGLGETCOMPRESSEDTEXIMAGEPROC glad_glGetCompressedTexImage = NULL;
	PFNGLGETDOUBLEVPROC glad_glGetDoublev = NULL;
	PFNGLGETERRORPROC glad_glGetError = NULL;
	PFNGLGETFLOATVPROC glad_glGetFloatv = NULL;
	PFNGLGETFRAGDATAINDEXPROC glad_glGetFragDataIndex = NULL;
	PFNGLGETFRAGDATALOCATIONPROC glad_glGetFragDataLocation = NULL;
	PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC glad_glGetFramebufferAttachmentParameteriv = NULL;
	PFNGLGETINTEGER64I_VPROC glad_glGetInteger64i_v = NULL;
	PFNGLGETINTEGER64VPROC glad_glGetInteger64v = NULL;
	PFNGLGETINTEGERI_VPROC glad_glGetIntegeri_v = NULL;
	PFNGLGETINTEGERVPROC glad_glGetIntegerv = NULL;
	PFNGLGETMULTISAMPLEFVPROC glad_glGetMultisamplefv = NULL;
	PFNGLGETPROGRAMINFOLOGPROC glad_glGetProgramInfoLog = NULL;
	PFNGLGETPROGRAMIVPROC glad_glGetProgramiv = NULL;
	PFNGLGETQUERYOBJECTI64VPROC glad_glGetQueryObjecti64v = NULL;
	PFNGLGETQUERYOBJECTIVPROC glad_glGetQueryObjectiv = NULL;
	PFNGLGETQUERYOBJECTUI64VPROC glad_glGetQueryObjectui64v = NULL;
	PFNGLGETQUERYOBJECTUIVPROC glad_glGetQueryObjectuiv = NULL;
	PFNGLGETQUERYIVPROC glad_glGetQueryiv = NULL;
	PFNGLGETRENDERBUFFERPARAMETERIVPROC glad_glGetRenderbufferParameteriv = NULL;
	PFNGLGETSAMPLERPARAMETERIIVPROC glad_glGetSamplerParameterIiv = NULL;
	PFNGLGETSAMPLERPARAMETERIUIVPROC glad_glGetSamplerParameterIuiv = NULL;
	PFNGLGETSAMPLERPARAMETERFVPROC glad_glGetSamplerParameterfv = NULL;
	PFNGLGETSAMPLERPARAMETERIVPROC glad_glGetSamplerParameteriv = NULL;
	PFNGLGETSHADERINFOLOGPROC glad_glGetShaderInfoLog = NULL;
	PFNGLGETSHADERSOURCEPROC glad_glGetShaderSource = NULL;
	PFNGLGETSHADERIVPROC glad_glGetShaderiv = NULL;
	PFNGLGETSTRINGPROC glad_glGetString = NULL;
	PFNGLGETSTRINGIPROC glad_glGetStringi = NULL;
	PFNGLGETSYNCIVPROC glad_glGetSynciv = NULL;
	PFNGLGETTEXIMAGEPROC glad_glGetTexImage = NULL;
	PFNGLGETTEXLEVELPARAMETERFVPROC glad_glGetTexLevelParameterfv = NULL;
	PFNGLGETTEXLEVELPARAMETERIVPROC glad_glGetTexLevelParameteriv = NULL;
	PFNGLGETTEXPARAMETERIIVPROC glad_glGetTexParameterIiv = NULL;
	PFNGLGETTEXPARAMETERIUIVPROC glad_glGetTexParameterIuiv = NULL;
	PFNGLGETTEXPARAMETERFVPROC glad_glGetTexParameterfv = NULL;
	PFNGLGETTEXPARAMETERIVPROC glad_glGetTexParameteriv = NULL;
	PFNGLGETTRANSFORMFEEDBACKVARYINGPROC glad_glGetTransformFeedbackVarying = NULL;
	PFNGLGETUNIFORMBLOCKINDEXPROC glad_glGetUniformBlockIndex = NULL;
	PFNGLGETUNIFORMINDICESPROC glad_glGetUniformIndices = NULL;
	PFNGLGETUNIFORMLOCATIONPROC glad_glGetUniformLocation = NULL;
	PFNGLGETUNIFORMFVPROC glad_glGetUniformfv = NULL;
	PFNGLGETUNIFORMIVPROC glad_glGetUniformiv = NULL;
	PFNGLGETUNIFORMUIVPROC glad_glGetUniformuiv = NULL;
	PFNGLGETVERTEXATTRIBIIVPROC glad_glGetVertexAttribIiv = NULL;
	PFNGLGETVERTEXATTRIBIUIVPROC glad_glGetVertexAttribIuiv = NULL;
	PFNGLGETVERTEXATTRIBPOINTERVPROC glad_glGetVertexAttribPointerv = NULL;
	PFNGLGETVERTEXATTRIBDVPROC glad_glGetVertexAttribdv = NULL;
	PFNGLGETVERTEXATTRIBFVPROC glad_glGetVertexAttribfv = NULL;
	PFNGLGETVERTEXATTRIBIVPROC glad_glGetVertexAttribiv = NULL;
	PFNGLHINTPROC glad_glHint = NULL;
	PFNGLISBUFFERPROC glad_glIsBuffer = NULL;
	PFNGLISENABLEDPROC glad_glIsEnabled = NULL;
	PFNGLISENABLEDIPROC glad_glIsEnabledi = NULL;
	PFNGLISFRAMEBUFFERPROC glad_glIsFramebuffer = NULL;
	PFNGLISPROGRAMPROC glad_glIsProgram = NULL;
	PFNGLISQUERYPROC glad_glIsQuery = NULL;
	PFNGLISRENDERBUFFERPROC glad_glIsRenderbuffer = NULL;
	PFNGLISSAMPLERPROC glad_glIsSampler = NULL;
	PFNGLISSHADERPROC glad_glIsShader = NULL;
	PFNGLISSYNCPROC glad_glIsSync = NULL;
	PFNGLISTEXTUREPROC glad_glIsTexture = NULL;
	PFNGLISVERTEXARRAYPROC glad_glIsVertexArray = NULL;
	PFNGLLINEWIDTHPROC glad_glLineWidth = NULL;
	PFNGLLINKPROGRAMPROC glad_glLinkProgram = NULL;
	PFNGLLOGICOPPROC glad_glLogicOp = NULL;
	PFNGLMAPBUFFERPROC glad_glMapBuffer = NULL;
	PFNGLMAPBUFFERRANGEPROC glad_glMapBufferRange = NULL;
	PFNGLMULTIDRAWARRAYSPROC glad_glMultiDrawArrays = NULL;
	PFNGLMULTIDRAWELEMENTSPROC glad_glMultiDrawElements = NULL;
	PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC glad_glMultiDrawElementsBaseVertex = NULL;
	PFNGLPIXELSTOREFPROC glad_glPixelStoref = NULL;
	PFNGLPIXELSTOREIPROC glad_glPixelStorei = NULL;
	PFNGLPOINTPARAMETERFPROC glad_glPointParameterf = NULL;
	PFNGLPOINTPARAMETERFVPROC glad_glPointParameterfv = NULL;
	PFNGLPOINTPARAMETERIPROC glad_glPointParameteri = NULL;
	PFNGLPOINTPARAMETERIVPROC glad_glPointParameteriv = NULL;
	PFNGLPOINTSIZEPROC glad_glPointSize = NULL;
	PFNGLPOLYGONMODEPROC glad_glPolygonMode = NULL;
	PFNGLPOLYGONOFFSETPROC glad_glPolygonOffset = NULL;
	PFNGLPRIMITIVERESTARTINDEXPROC glad_glPrimitiveRestartIndex = NULL;
	PFNGLPROVOKINGVERTEXPROC glad_glProvokingVertex = NULL;
	PFNGLQUERYCOUNTERPROC glad_glQueryCounter = NULL;
	PFNGLREADBUFFERPROC glad_glReadBuffer = NULL;
	PFNGLREADPIXELSPROC glad_glReadPixels = NULL;
	PFNGLRENDERBUFFERSTORAGEPROC glad_glRenderbufferStorage = NULL;
	PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC glad_glRenderbufferStorageMultisample = NULL;
	PFNGLSAMPLECOVERAGEPROC glad_glSampleCoverage = NULL;
	PFNGLSAMPLEMASKIPROC glad_glSampleMaski = NULL;
	PFNGLSAMPLERPARAMETERIIVPROC glad_glSamplerParameterIiv = NULL;
	PFNGLSAMPLERPARAMETERIUIVPROC glad_glSamplerParameterIuiv = NULL;
	PFNGLSAMPLERPARAMETERFPROC glad_glSamplerParameterf = NULL;
	PFNGLSAMPLERPARAMETERFVPROC glad_glSamplerParameterfv = NULL;
	PFNGLSAMPLERPARAMETERIPROC glad_glSamplerParameteri = NULL;
	PFNGLSAMPLERPARAMETERIVPROC glad_glSamplerParameteriv = NULL;
	PFNGLSCISSORPROC glad_glScissor = NULL;
	PFNGLSHADERSOURCEPROC glad_glShaderSource = NULL;
	PFNGLSTENCILFUNCPROC glad_glStencilFunc = NULL;
	PFNGLSTENCILFUNCSEPARATEPROC glad_glStencilFuncSeparate = NULL;
	PFNGLSTENCILMASKPROC glad_glStencilMask = NULL;
	PFNGLSTENCILMASKSEPARATEPROC glad_glStencilMaskSeparate = NULL;
	PFNGLSTENCILOPPROC glad_glStencilOp = NULL;
	PFNGLSTENCILOPSEPARATEPROC glad_glStencilOpSeparate = NULL;
	PFNGLTEXBUFFERPROC glad_glTexBuffer = NULL;
	PFNGLTEXIMAGE1DPROC glad_glTexImage1D = NULL;
	PFNGLTEXIMAGE2DPROC glad_glTexImage2D = NULL;
	PFNGLTEXIMAGE2DMULTISAMPLEPROC glad_glTexImage2DMultisample = NULL;
	PFNGLTEXIMAGE3DPROC glad_glTexImage3D = NULL;
	PFNGLTEXIMAGE3DMULTISAMPLEPROC glad_glTexImage3DMultisample = NULL;
	PFNGLTEXPARAMETERIIVPROC glad_glTexParameterIiv = NULL;
	PFNGLTEXPARAMETERIUIVPROC glad_glTexParameterIuiv = NULL;
	PFNGLTEXPARAMETERFPROC glad_glTexParameterf = NULL;
	PFNGLTEXPARAMETERFVPROC glad_glTexParameterfv = NULL;
	PFNGLTEXPARAMETERIPROC glad_glTexParameteri = NULL;
	PFNGLTEXPARAMETERIVPROC glad_glTexParameteriv = NULL;
	PFNGLTEXSUBIMAGE1DPROC glad_glTexSubImage1D = NULL;
	PFNGLTEXSUBIMAGE2DPROC glad_glTexSubImage2D = NULL;
	PFNGLTEXSUBIMAGE3DPROC glad_glTexSubImage3D = NULL;
	PFNGLTRANSFORMFEEDBACKVARYINGSPROC glad_glTransformFeedbackVaryings = NULL;
	PFNGLUNIFORM1FPROC glad_glUniform1f = NULL;
	PFNGLUNIFORM1FVPROC glad_glUniform1fv = NULL;
	PFNGLUNIFORM1IPROC glad_glUniform1i = NULL;
	PFNGLUNIFORM1IVPROC glad_glUniform1iv = NULL;
	PFNGLUNIFORM1UIPROC glad_glUniform1ui = NULL;
	PFNGLUNIFORM1UIVPROC glad_glUniform1uiv = NULL;
	PFNGLUNIFORM2FPROC glad_glUniform2f = NULL;
	PFNGLUNIFORM2FVPROC glad_glUniform2fv = NULL;
	PFNGLUNIFORM2IPROC glad_glUniform2i = NULL;
	PFNGLUNIFORM2IVPROC glad_glUniform2iv = NULL;
	PFNGLUNIFORM2UIPROC glad_glUniform2ui = NULL;
	PFNGLUNIFORM2UIVPROC glad_glUniform2uiv = NULL;
	PFNGLUNIFORM3FPROC glad_glUniform3f = NULL;
	PFNGLUNIFORM3FVPROC glad_glUniform3fv = NULL;
	PFNGLUNIFORM3IPROC glad_glUniform3i = NULL;
	PFNGLUNIFORM3IVPROC glad_glUniform3iv = NULL;
	PFNGLUNIFORM3UIPROC glad_glUniform3ui = NULL;
	PFNGLUNIFORM3UIVPROC glad_glUniform3uiv = NULL;
	PFNGLUNIFORM4FPROC glad_glUniform4f = NULL;
	PFNGLUNIFORM4FVPROC glad_glUniform4fv = NULL;
	PFNGLUNIFORM4IPROC glad_glUniform4i = NULL;
	PFNGLUNIFORM4IVPROC glad_glUniform4iv = NULL;
	PFNGLUNIFORM4UIPROC glad_glUniform4ui = NULL;
	PFNGLUNIFORM4UIVPROC glad_glUniform4uiv = NULL;
	PFNGLUNIFORMBLOCKBINDINGPROC glad_glUniformBlockBinding = NULL;
	PFNGLUNIFORMMATRIX2FVPROC glad_glUniformMatrix2fv = NULL;
	PFNGLUNIFORMMATRIX2X3FVPROC glad_glUniformMatrix2x3fv = NULL;
	PFNGLUNIFORMMATRIX2X4FVPROC glad_glUniformMatrix2x4fv = NULL;
	PFNGLUNIFORMMATRIX3FVPROC glad_glUniformMatrix3fv = NULL;
	PFNGLUNIFORMMATRIX3X2FVPROC glad_glUniformMatrix3x2fv = NULL;
	PFNGLUNIFORMMATRIX3X4FVPROC glad_glUniformMatrix3x4fv = NULL;
	PFNGLUNIFORMMATRIX4FVPROC glad_glUniformMatrix4fv = NULL;
	PFNGLUNIFORMMATRIX4X2FVPROC glad_glUniformMatrix4x2fv = NULL;
	PFNGLUNIFORMMATRIX4X3FVPROC glad_glUniformMatrix4x3fv = NULL;
	PFNGLUNMAPBUFFERPROC glad_glUnmapBuffer = NULL;
	PFNGLUSEPROGRAMPROC glad_glUseProgram = NULL;
	PFNGLVALIDATEPROGRAMPROC glad_glValidateProgram = NULL;
	PFNGLVERTEXATTRIB1DPROC glad_glVertexAttrib1d = NULL;
	PFNGLVERTEXATTRIB1DVPROC glad_glVertexAttrib1dv = NULL;
	PFNGLVERTEXATTRIB1FPROC glad_glVertexAttrib1f = NULL;
	PFNGLVERTEXATTRIB1FVPROC glad_glVertexAttrib1fv = NULL;
	PFNGLVERTEXATTRIB1SPROC glad_glVertexAttrib1s = NULL;
	PFNGLVERTEXATTRIB1SVPROC glad_glVertexAttrib1sv = NULL;
	PFNGLVERTEXATTRIB2DPROC glad_glVertexAttrib2d = NULL;
	PFNGLVERTEXATTRIB2DVPROC glad_glVertexAttrib2dv = NULL;
	PFNGLVERTEXATTRIB2FPROC glad_glVertexAttrib2f = NULL;
	PFNGLVERTEXATTRIB2FVPROC glad_glVertexAttrib2fv = NULL;
	PFNGLVERTEXATTRIB2SPROC glad_glVertexAttrib2s = NULL;
	PFNGLVERTEXATTRIB2SVPROC glad_glVertexAttrib2sv = NULL;
	PFNGLVERTEXATTRIB3DPROC glad_glVertexAttrib3d = NULL;
	PFNGLVERTEXATTRIB3DVPROC glad_glVertexAttrib3dv = NULL;
	PFNGLVERTEXATTRIB3FPROC glad_glVertexAttrib3f = NULL;
	PFNGLVERTEXATTRIB3FVPROC glad_glVertexAttrib3fv = NULL;
	PFNGLVERTEXATTRIB3SPROC glad_glVertexAttrib3s = NULL;
	PFNGLVERTEXATTRIB3SVPROC glad_glVertexAttrib3sv = NULL;
	PFNGLVERTEXATTRIB4NBVPROC glad_glVertexAttrib4Nbv = NULL;
	PFNGLVERTEXATTRIB4NIVPROC glad_glVertexAttrib4Niv = NULL;
	PFNGLVERTEXATTRIB4NSVPROC glad_glVertexAttrib4Nsv = NULL;
	PFNGLVERTEXATTRIB4NUBPROC glad_glVertexAttrib4Nub = NULL;
	PFNGLVERTEXATTRIB4NUBVPROC glad_glVertexAttrib4Nubv = NULL;
	PFNGLVERTEXATTRIB4NUIVPROC glad_glVertexAttrib4Nuiv = NULL;
	PFNGLVERTEXATTRIB4NUSVPROC glad_glVertexAttrib4Nusv = NULL;
	PFNGLVERTEXATTRIB4BVPROC glad_glVertexAttrib4bv = NULL;
	PFNGLVERTEXATTRIB4DPROC glad_glVertexAttrib4d = NULL;
	PFNGLVERTEXATTRIB4DVPROC glad_glVertexAttrib4dv = NULL;
	PFNGLVERTEXATTRIB4FPROC glad_glVertexAttrib4f = NULL;
	PFNGLVERTEXATTRIB4FVPROC glad_glVertexAttrib4fv = NULL;
	PFNGLVERTEXATTRIB4IVPROC glad_glVertexAttrib4iv = NULL;
	PFNGLVERTEXATTRIB4SPROC glad_glVertexAttrib4s = NULL;
	PFNGLVERTEXATTRIB4SVPROC glad_glVertexAttrib4sv = NULL;
	PFNGLVERTEXATTRIB4UBVPROC glad_glVertexAttrib4ubv = NULL;
	PFNGLVERTEXATTRIB4UIVPROC glad_glVertexAttrib4uiv = NULL;
	PFNGLVERTEXATTRIB4USVPROC glad_glVertexAttrib4usv = NULL;
	PFNGLVERTEXATTRIBDIVISORPROC glad_glVertexAttribDivisor = NULL;
	PFNGLVERTEXATTRIBI1IPROC glad_glVertexAttribI1i = NULL;
	PFNGLVERTEXATTRIBI1IVPROC glad_glVertexAttribI1iv = NULL;
	PFNGLVERTEXATTRIBI1UIPROC glad_glVertexAttribI1ui = NULL;
	PFNGLVERTEXATTRIBI1UIVPROC glad_glVertexAttribI1uiv = NULL;
	PFNGLVERTEXATTRIBI2IPROC glad_glVertexAttribI2i = NULL;
	PFNGLVERTEXATTRIBI2IVPROC glad_glVertexAttribI2iv = NULL;
	PFNGLVERTEXATTRIBI2UIPROC glad_glVertexAttribI2ui = NULL;
	PFNGLVERTEXATTRIBI2UIVPROC glad_glVertexAttribI2uiv = NULL;
	PFNGLVERTEXATTRIBI3IPROC glad_glVertexAttribI3i = NULL;
	PFNGLVERTEXATTRIBI3IVPROC glad_glVertexAttribI3iv = NULL;
	PFNGLVERTEXATTRIBI3UIPROC glad_glVertexAttribI3ui = NULL;
	PFNGLVERTEXATTRIBI3UIVPROC glad_glVertexAttribI3uiv = NULL;
	PFNGLVERTEXATTRIBI4BVPROC glad_glVertexAttribI4bv = NULL;
	PFNGLVERTEXATTRIBI4IPROC glad_glVertexAttribI4i = NULL;
	PFNGLVERTEXATTRIBI4IVPROC glad_glVertexAttribI4iv = NULL;
	PFNGLVERTEXATTRIBI4SVPROC glad_glVertexAttribI4sv = NULL;
	PFNGLVERTEXATTRIBI4UBVPROC glad_glVertexAttribI4ubv = NULL;
	PFNGLVERTEXATTRIBI4UIPROC glad_glVertexAttribI4ui = NULL;
	PFNGLVERTEXATTRIBI4UIVPROC glad_glVertexAttribI4uiv = NULL;
	PFNGLVERTEXATTRIBI4USVPROC glad_glVertexAttribI4usv = NULL;
	PFNGLVERTEXATTRIBIPOINTERPROC glad_glVertexAttribIPointer = NULL;
	PFNGLVERTEXATTRIBP1UIPROC glad_glVertexAttribP1ui = NULL;
	PFNGLVERTEXATTRIBP1UIVPROC glad_glVertexAttribP1uiv = NULL;
	PFNGLVERTEXATTRIBP2UIPROC glad_glVertexAttribP2ui = NULL;
	PFNGLVERTEXATTRIBP2UIVPROC glad_glVertexAttribP2uiv = NULL;
	PFNGLVERTEXATTRIBP3UIPROC glad_glVertexAttribP3ui = NULL;
	PFNGLVERTEXATTRIBP3UIVPROC glad_glVertexAttribP3uiv = NULL;
	PFNGLVERTEXATTRIBP4UIPROC glad_glVertexAttribP4ui = NULL;
	PFNGLVERTEXATTRIBP4UIVPROC glad_glVertexAttribP4uiv = NULL;
	PFNGLVERTEXATTRIBPOINTERPROC glad_glVertexAttribPointer = NULL;
	PFNGLVIEWPORTPROC glad_glViewport = NULL;
	PFNGLWAITSYNCPROC glad_glWaitSync = NULL;

	static void glad_gl_load_GL_VERSION_1_0( GLADuserptrloadfunc load, void* userptr ) {
		if (!GLAD_GL_VERSION_1_0) return;
		glad_glBlendFunc = (PFNGLBLENDFUNCPROC)load( userptr, "glBlendFunc" );
		glad_glClear = (PFNGLCLEARPROC)load( userptr, "glClear" );
		glad_glClearColor = (PFNGLCLEARCOLORPROC)load( userptr, "glClearColor" );
		glad_glClearDepth = (PFNGLCLEARDEPTHPROC)load( userptr, "glClearDepth" );
		glad_glClearStencil = (PFNGLCLEARSTENCILPROC)load( userptr, "glClearStencil" );
		glad_glColorMask = (PFNGLCOLORMASKPROC)load( userptr, "glColorMask" );
		glad_glCullFace = (PFNGLCULLFACEPROC)load( userptr, "glCullFace" );
		glad_glDepthFunc = (PFNGLDEPTHFUNCPROC)load( userptr, "glDepthFunc" );
		glad_glDepthMask = (PFNGLDEPTHMASKPROC)load( userptr, "glDepthMask" );
		glad_glDepthRange = (PFNGLDEPTHRANGEPROC)load( userptr, "glDepthRange" );
		glad_glDisable = (PFNGLDISABLEPROC)load( userptr, "glDisable" );
		glad_glDrawBuffer = (PFNGLDRAWBUFFERPROC)load( userptr, "glDrawBuffer" );
		glad_glEnable = (PFNGLENABLEPROC)load( userptr, "glEnable" );
		glad_glFinish = (PFNGLFINISHPROC)load( userptr, "glFinish" );
		glad_glFlush = (PFNGLFLUSHPROC)load( userptr, "glFlush" );
		glad_glFrontFace = (PFNGLFRONTFACEPROC)load( userptr, "glFrontFace" );
		glad_glGetBooleanv = (PFNGLGETBOOLEANVPROC)load( userptr, "glGetBooleanv" );
		glad_glGetDoublev = (PFNGLGETDOUBLEVPROC)load( userptr, "glGetDoublev" );
		glad_glGetError = (PFNGLGETERRORPROC)load( userptr, "glGetError" );
		glad_glGetFloatv = (PFNGLGETFLOATVPROC)load( userptr, "glGetFloatv" );
		glad_glGetIntegerv = (PFNGLGETINTEGERVPROC)load( userptr, "glGetIntegerv" );
		glad_glGetString = (PFNGLGETSTRINGPROC)load( userptr, "glGetString" );
		glad_glGetTexImage = (PFNGLGETTEXIMAGEPROC)load( userptr, "glGetTexImage" );
		glad_glGetTexLevelParameterfv = (PFNGLGETTEXLEVELPARAMETERFVPROC)load( userptr, "glGetTexLevelParameterfv" );
		glad_glGetTexLevelParameteriv = (PFNGLGETTEXLEVELPARAMETERIVPROC)load( userptr, "glGetTexLevelParameteriv" );
		glad_glGetTexParameterfv = (PFNGLGETTEXPARAMETERFVPROC)load( userptr, "glGetTexParameterfv" );
		glad_glGetTexParameteriv = (PFNGLGETTEXPARAMETERIVPROC)load( userptr, "glGetTexParameteriv" );
		glad_glHint = (PFNGLHINTPROC)load( userptr, "glHint" );
		glad_glIsEnabled = (PFNGLISENABLEDPROC)load( userptr, "glIsEnabled" );
		glad_glLineWidth = (PFNGLLINEWIDTHPROC)load( userptr, "glLineWidth" );
		glad_glLogicOp = (PFNGLLOGICOPPROC)load( userptr, "glLogicOp" );
		glad_glPixelStoref = (PFNGLPIXELSTOREFPROC)load( userptr, "glPixelStoref" );
		glad_glPixelStorei = (PFNGLPIXELSTOREIPROC)load( userptr, "glPixelStorei" );
		glad_glPointSize = (PFNGLPOINTSIZEPROC)load( userptr, "glPointSize" );
		glad_glPolygonMode = (PFNGLPOLYGONMODEPROC)load( userptr, "glPolygonMode" );
		glad_glReadBuffer = (PFNGLREADBUFFERPROC)load( userptr, "glReadBuffer" );
		glad_glReadPixels = (PFNGLREADPIXELSPROC)load( userptr, "glReadPixels" );
		glad_glScissor = (PFNGLSCISSORPROC)load( userptr, "glScissor" );
		glad_glStencilFunc = (PFNGLSTENCILFUNCPROC)load( userptr, "glStencilFunc" );
		glad_glStencilMask = (PFNGLSTENCILMASKPROC)load( userptr, "glStencilMask" );
		glad_glStencilOp = (PFNGLSTENCILOPPROC)load( userptr, "glStencilOp" );
		glad_glTexImage1D = (PFNGLTEXIMAGE1DPROC)load( userptr, "glTexImage1D" );
		glad_glTexImage2D = (PFNGLTEXIMAGE2DPROC)load( userptr, "glTexImage2D" );
		glad_glTexParameterf = (PFNGLTEXPARAMETERFPROC)load( userptr, "glTexParameterf" );
		glad_glTexParameterfv = (PFNGLTEXPARAMETERFVPROC)load( userptr, "glTexParameterfv" );
		glad_glTexParameteri = (PFNGLTEXPARAMETERIPROC)load( userptr, "glTexParameteri" );
		glad_glTexParameteriv = (PFNGLTEXPARAMETERIVPROC)load( userptr, "glTexParameteriv" );
		glad_glViewport = (PFNGLVIEWPORTPROC)load( userptr, "glViewport" );
	}
	static void glad_gl_load_GL_VERSION_1_1( GLADuserptrloadfunc load, void* userptr ) {
		if (!GLAD_GL_VERSION_1_1) return;
		glad_glBindTexture = (PFNGLBINDTEXTUREPROC)load( userptr, "glBindTexture" );
		glad_glCopyTexImage1D = (PFNGLCOPYTEXIMAGE1DPROC)load( userptr, "glCopyTexImage1D" );
		glad_glCopyTexImage2D = (PFNGLCOPYTEXIMAGE2DPROC)load( userptr, "glCopyTexImage2D" );
		glad_glCopyTexSubImage1D = (PFNGLCOPYTEXSUBIMAGE1DPROC)load( userptr, "glCopyTexSubImage1D" );
		glad_glCopyTexSubImage2D = (PFNGLCOPYTEXSUBIMAGE2DPROC)load( userptr, "glCopyTexSubImage2D" );
		glad_glDeleteTextures = (PFNGLDELETETEXTURESPROC)load( userptr, "glDeleteTextures" );
		glad_glDrawArrays = (PFNGLDRAWARRAYSPROC)load( userptr, "glDrawArrays" );
		glad_glDrawElements = (PFNGLDRAWELEMENTSPROC)load( userptr, "glDrawElements" );
		glad_glGenTextures = (PFNGLGENTEXTURESPROC)load( userptr, "glGenTextures" );
		glad_glIsTexture = (PFNGLISTEXTUREPROC)load( userptr, "glIsTexture" );
		glad_glPolygonOffset = (PFNGLPOLYGONOFFSETPROC)load( userptr, "glPolygonOffset" );
		glad_glTexSubImage1D = (PFNGLTEXSUBIMAGE1DPROC)load( userptr, "glTexSubImage1D" );
		glad_glTexSubImage2D = (PFNGLTEXSUBIMAGE2DPROC)load( userptr, "glTexSubImage2D" );
	}
	static void glad_gl_load_GL_VERSION_1_2( GLADuserptrloadfunc load, void* userptr ) {
		if (!GLAD_GL_VERSION_1_2) return;
		glad_glCopyTexSubImage3D = (PFNGLCOPYTEXSUBIMAGE3DPROC)load( userptr, "glCopyTexSubImage3D" );
		glad_glDrawRangeElements = (PFNGLDRAWRANGEELEMENTSPROC)load( userptr, "glDrawRangeElements" );
		glad_glTexImage3D = (PFNGLTEXIMAGE3DPROC)load( userptr, "glTexImage3D" );
		glad_glTexSubImage3D = (PFNGLTEXSUBIMAGE3DPROC)load( userptr, "glTexSubImage3D" );
	}
	static void glad_gl_load_GL_VERSION_1_3( GLADuserptrloadfunc load, void* userptr ) {
		if (!GLAD_GL_VERSION_1_3) return;
		glad_glActiveTexture = (PFNGLACTIVETEXTUREPROC)load( userptr, "glActiveTexture" );
		glad_glCompressedTexImage1D = (PFNGLCOMPRESSEDTEXIMAGE1DPROC)load( userptr, "glCompressedTexImage1D" );
		glad_glCompressedTexImage2D = (PFNGLCOMPRESSEDTEXIMAGE2DPROC)load( userptr, "glCompressedTexImage2D" );
		glad_glCompressedTexImage3D = (PFNGLCOMPRESSEDTEXIMAGE3DPROC)load( userptr, "glCompressedTexImage3D" );
		glad_glCompressedTexSubImage1D = (PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC)load( userptr, "glCompressedTexSubImage1D" );
		glad_glCompressedTexSubImage2D = (PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC)load( userptr, "glCompressedTexSubImage2D" );
		glad_glCompressedTexSubImage3D = (PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC)load( userptr, "glCompressedTexSubImage3D" );
		glad_glGetCompressedTexImage = (PFNGLGETCOMPRESSEDTEXIMAGEPROC)load( userptr, "glGetCompressedTexImage" );
		glad_glSampleCoverage = (PFNGLSAMPLECOVERAGEPROC)load( userptr, "glSampleCoverage" );
	}
	static void glad_gl_load_GL_VERSION_1_4( GLADuserptrloadfunc load, void* userptr ) {
		if (!GLAD_GL_VERSION_1_4) return;
		glad_glBlendColor = (PFNGLBLENDCOLORPROC)load( userptr, "glBlendColor" );
		glad_glBlendEquation = (PFNGLBLENDEQUATIONPROC)load( userptr, "glBlendEquation" );
		glad_glBlendFuncSeparate = (PFNGLBLENDFUNCSEPARATEPROC)load( userptr, "glBlendFuncSeparate" );
		glad_glMultiDrawArrays = (PFNGLMULTIDRAWARRAYSPROC)load( userptr, "glMultiDrawArrays" );
		glad_glMultiDrawElements = (PFNGLMULTIDRAWELEMENTSPROC)load( userptr, "glMultiDrawElements" );
		glad_glPointParameterf = (PFNGLPOINTPARAMETERFPROC)load( userptr, "glPointParameterf" );
		glad_glPointParameterfv = (PFNGLPOINTPARAMETERFVPROC)load( userptr, "glPointParameterfv" );
		glad_glPointParameteri = (PFNGLPOINTPARAMETERIPROC)load( userptr, "glPointParameteri" );
		glad_glPointParameteriv = (PFNGLPOINTPARAMETERIVPROC)load( userptr, "glPointParameteriv" );
	}
	static void glad_gl_load_GL_VERSION_1_5( GLADuserptrloadfunc load, void* userptr ) {
		if (!GLAD_GL_VERSION_1_5) return;
		glad_glBeginQuery = (PFNGLBEGINQUERYPROC)load( userptr, "glBeginQuery" );
		glad_glBindBuffer = (PFNGLBINDBUFFERPROC)load( userptr, "glBindBuffer" );
		glad_glBufferData = (PFNGLBUFFERDATAPROC)load( userptr, "glBufferData" );
		glad_glBufferSubData = (PFNGLBUFFERSUBDATAPROC)load( userptr, "glBufferSubData" );
		glad_glDeleteBuffers = (PFNGLDELETEBUFFERSPROC)load( userptr, "glDeleteBuffers" );
		glad_glDeleteQueries = (PFNGLDELETEQUERIESPROC)load( userptr, "glDeleteQueries" );
		glad_glEndQuery = (PFNGLENDQUERYPROC)load( userptr, "glEndQuery" );
		glad_glGenBuffers = (PFNGLGENBUFFERSPROC)load( userptr, "glGenBuffers" );
		glad_glGenQueries = (PFNGLGENQUERIESPROC)load( userptr, "glGenQueries" );
		glad_glGetBufferParameteriv = (PFNGLGETBUFFERPARAMETERIVPROC)load( userptr, "glGetBufferParameteriv" );
		glad_glGetBufferPointerv = (PFNGLGETBUFFERPOINTERVPROC)load( userptr, "glGetBufferPointerv" );
		glad_glGetBufferSubData = (PFNGLGETBUFFERSUBDATAPROC)load( userptr, "glGetBufferSubData" );
		glad_glGetQueryObjectiv = (PFNGLGETQUERYOBJECTIVPROC)load( userptr, "glGetQueryObjectiv" );
		glad_glGetQueryObjectuiv = (PFNGLGETQUERYOBJECTUIVPROC)load( userptr, "glGetQueryObjectuiv" );
		glad_glGetQueryiv = (PFNGLGETQUERYIVPROC)load( userptr, "glGetQueryiv" );
		glad_glIsBuffer = (PFNGLISBUFFERPROC)load( userptr, "glIsBuffer" );
		glad_glIsQuery = (PFNGLISQUERYPROC)load( userptr, "glIsQuery" );
		glad_glMapBuffer = (PFNGLMAPBUFFERPROC)load( userptr, "glMapBuffer" );
		glad_glUnmapBuffer = (PFNGLUNMAPBUFFERPROC)load( userptr, "glUnmapBuffer" );
	}
	static void glad_gl_load_GL_VERSION_2_0( GLADuserptrloadfunc load, void* userptr ) {
		if (!GLAD_GL_VERSION_2_0) return;
		glad_glAttachShader = (PFNGLATTACHSHADERPROC)load( userptr, "glAttachShader" );
		glad_glBindAttribLocation = (PFNGLBINDATTRIBLOCATIONPROC)load( userptr, "glBindAttribLocation" );
		glad_glBlendEquationSeparate = (PFNGLBLENDEQUATIONSEPARATEPROC)load( userptr, "glBlendEquationSeparate" );
		glad_glCompileShader = (PFNGLCOMPILESHADERPROC)load( userptr, "glCompileShader" );
		glad_glCreateProgram = (PFNGLCREATEPROGRAMPROC)load( userptr, "glCreateProgram" );
		glad_glCreateShader = (PFNGLCREATESHADERPROC)load( userptr, "glCreateShader" );
		glad_glDeleteProgram = (PFNGLDELETEPROGRAMPROC)load( userptr, "glDeleteProgram" );
		glad_glDeleteShader = (PFNGLDELETESHADERPROC)load( userptr, "glDeleteShader" );
		glad_glDetachShader = (PFNGLDETACHSHADERPROC)load( userptr, "glDetachShader" );
		glad_glDisableVertexAttribArray = (PFNGLDISABLEVERTEXATTRIBARRAYPROC)load( userptr, "glDisableVertexAttribArray" );
		glad_glDrawBuffers = (PFNGLDRAWBUFFERSPROC)load( userptr, "glDrawBuffers" );
		glad_glEnableVertexAttribArray = (PFNGLENABLEVERTEXATTRIBARRAYPROC)load( userptr, "glEnableVertexAttribArray" );
		glad_glGetActiveAttrib = (PFNGLGETACTIVEATTRIBPROC)load( userptr, "glGetActiveAttrib" );
		glad_glGetActiveUniform = (PFNGLGETACTIVEUNIFORMPROC)load( userptr, "glGetActiveUniform" );
		glad_glGetAttachedShaders = (PFNGLGETATTACHEDSHADERSPROC)load( userptr, "glGetAttachedShaders" );
		glad_glGetAttribLocation = (PFNGLGETATTRIBLOCATIONPROC)load( userptr, "glGetAttribLocation" );
		glad_glGetProgramInfoLog = (PFNGLGETPROGRAMINFOLOGPROC)load( userptr, "glGetProgramInfoLog" );
		glad_glGetProgramiv = (PFNGLGETPROGRAMIVPROC)load( userptr, "glGetProgramiv" );
		glad_glGetShaderInfoLog = (PFNGLGETSHADERINFOLOGPROC)load( userptr, "glGetShaderInfoLog" );
		glad_glGetShaderSource = (PFNGLGETSHADERSOURCEPROC)load( userptr, "glGetShaderSource" );
		glad_glGetShaderiv = (PFNGLGETSHADERIVPROC)load( userptr, "glGetShaderiv" );
		glad_glGetUniformLocation = (PFNGLGETUNIFORMLOCATIONPROC)load( userptr, "glGetUniformLocation" );
		glad_glGetUniformfv = (PFNGLGETUNIFORMFVPROC)load( userptr, "glGetUniformfv" );
		glad_glGetUniformiv = (PFNGLGETUNIFORMIVPROC)load( userptr, "glGetUniformiv" );
		glad_glGetVertexAttribPointerv = (PFNGLGETVERTEXATTRIBPOINTERVPROC)load( userptr, "glGetVertexAttribPointerv" );
		glad_glGetVertexAttribdv = (PFNGLGETVERTEXATTRIBDVPROC)load( userptr, "glGetVertexAttribdv" );
		glad_glGetVertexAttribfv = (PFNGLGETVERTEXATTRIBFVPROC)load( userptr, "glGetVertexAttribfv" );
		glad_glGetVertexAttribiv = (PFNGLGETVERTEXATTRIBIVPROC)load( userptr, "glGetVertexAttribiv" );
		glad_glIsProgram = (PFNGLISPROGRAMPROC)load( userptr, "glIsProgram" );
		glad_glIsShader = (PFNGLISSHADERPROC)load( userptr, "glIsShader" );
		glad_glLinkProgram = (PFNGLLINKPROGRAMPROC)load( userptr, "glLinkProgram" );
		glad_glShaderSource = (PFNGLSHADERSOURCEPROC)load( userptr, "glShaderSource" );
		glad_glStencilFuncSeparate = (PFNGLSTENCILFUNCSEPARATEPROC)load( userptr, "glStencilFuncSeparate" );
		glad_glStencilMaskSeparate = (PFNGLSTENCILMASKSEPARATEPROC)load( userptr, "glStencilMaskSeparate" );
		glad_glStencilOpSeparate = (PFNGLSTENCILOPSEPARATEPROC)load( userptr, "glStencilOpSeparate" );
		glad_glUniform1f = (PFNGLUNIFORM1FPROC)load( userptr, "glUniform1f" );
		glad_glUniform1fv = (PFNGLUNIFORM1FVPROC)load( userptr, "glUniform1fv" );
		glad_glUniform1i = (PFNGLUNIFORM1IPROC)load( userptr, "glUniform1i" );
		glad_glUniform1iv = (PFNGLUNIFORM1IVPROC)load( userptr, "glUniform1iv" );
		glad_glUniform2f = (PFNGLUNIFORM2FPROC)load( userptr, "glUniform2f" );
		glad_glUniform2fv = (PFNGLUNIFORM2FVPROC)load( userptr, "glUniform2fv" );
		glad_glUniform2i = (PFNGLUNIFORM2IPROC)load( userptr, "glUniform2i" );
		glad_glUniform2iv = (PFNGLUNIFORM2IVPROC)load( userptr, "glUniform2iv" );
		glad_glUniform3f = (PFNGLUNIFORM3FPROC)load( userptr, "glUniform3f" );
		glad_glUniform3fv = (PFNGLUNIFORM3FVPROC)load( userptr, "glUniform3fv" );
		glad_glUniform3i = (PFNGLUNIFORM3IPROC)load( userptr, "glUniform3i" );
		glad_glUniform3iv = (PFNGLUNIFORM3IVPROC)load( userptr, "glUniform3iv" );
		glad_glUniform4f = (PFNGLUNIFORM4FPROC)load( userptr, "glUniform4f" );
		glad_glUniform4fv = (PFNGLUNIFORM4FVPROC)load( userptr, "glUniform4fv" );
		glad_glUniform4i = (PFNGLUNIFORM4IPROC)load( userptr, "glUniform4i" );
		glad_glUniform4iv = (PFNGLUNIFORM4IVPROC)load( userptr, "glUniform4iv" );
		glad_glUniformMatrix2fv = (PFNGLUNIFORMMATRIX2FVPROC)load( userptr, "glUniformMatrix2fv" );
		glad_glUniformMatrix3fv = (PFNGLUNIFORMMATRIX3FVPROC)load( userptr, "glUniformMatrix3fv" );
		glad_glUniformMatrix4fv = (PFNGLUNIFORMMATRIX4FVPROC)load( userptr, "glUniformMatrix4fv" );
		glad_glUseProgram = (PFNGLUSEPROGRAMPROC)load( userptr, "glUseProgram" );
		glad_glValidateProgram = (PFNGLVALIDATEPROGRAMPROC)load( userptr, "glValidateProgram" );
		glad_glVertexAttrib1d = (PFNGLVERTEXATTRIB1DPROC)load( userptr, "glVertexAttrib1d" );
		glad_glVertexAttrib1dv = (PFNGLVERTEXATTRIB1DVPROC)load( userptr, "glVertexAttrib1dv" );
		glad_glVertexAttrib1f = (PFNGLVERTEXATTRIB1FPROC)load( userptr, "glVertexAttrib1f" );
		glad_glVertexAttrib1fv = (PFNGLVERTEXATTRIB1FVPROC)load( userptr, "glVertexAttrib1fv" );
		glad_glVertexAttrib1s = (PFNGLVERTEXATTRIB1SPROC)load( userptr, "glVertexAttrib1s" );
		glad_glVertexAttrib1sv = (PFNGLVERTEXATTRIB1SVPROC)load( userptr, "glVertexAttrib1sv" );
		glad_glVertexAttrib2d = (PFNGLVERTEXATTRIB2DPROC)load( userptr, "glVertexAttrib2d" );
		glad_glVertexAttrib2dv = (PFNGLVERTEXATTRIB2DVPROC)load( userptr, "glVertexAttrib2dv" );
		glad_glVertexAttrib2f = (PFNGLVERTEXATTRIB2FPROC)load( userptr, "glVertexAttrib2f" );
		glad_glVertexAttrib2fv = (PFNGLVERTEXATTRIB2FVPROC)load( userptr, "glVertexAttrib2fv" );
		glad_glVertexAttrib2s = (PFNGLVERTEXATTRIB2SPROC)load( userptr, "glVertexAttrib2s" );
		glad_glVertexAttrib2sv = (PFNGLVERTEXATTRIB2SVPROC)load( userptr, "glVertexAttrib2sv" );
		glad_glVertexAttrib3d = (PFNGLVERTEXATTRIB3DPROC)load( userptr, "glVertexAttrib3d" );
		glad_glVertexAttrib3dv = (PFNGLVERTEXATTRIB3DVPROC)load( userptr, "glVertexAttrib3dv" );
		glad_glVertexAttrib3f = (PFNGLVERTEXATTRIB3FPROC)load( userptr, "glVertexAttrib3f" );
		glad_glVertexAttrib3fv = (PFNGLVERTEXATTRIB3FVPROC)load( userptr, "glVertexAttrib3fv" );
		glad_glVertexAttrib3s = (PFNGLVERTEXATTRIB3SPROC)load( userptr, "glVertexAttrib3s" );
		glad_glVertexAttrib3sv = (PFNGLVERTEXATTRIB3SVPROC)load( userptr, "glVertexAttrib3sv" );
		glad_glVertexAttrib4Nbv = (PFNGLVERTEXATTRIB4NBVPROC)load( userptr, "glVertexAttrib4Nbv" );
		glad_glVertexAttrib4Niv = (PFNGLVERTEXATTRIB4NIVPROC)load( userptr, "glVertexAttrib4Niv" );
		glad_glVertexAttrib4Nsv = (PFNGLVERTEXATTRIB4NSVPROC)load( userptr, "glVertexAttrib4Nsv" );
		glad_glVertexAttrib4Nub = (PFNGLVERTEXATTRIB4NUBPROC)load( userptr, "glVertexAttrib4Nub" );
		glad_glVertexAttrib4Nubv = (PFNGLVERTEXATTRIB4NUBVPROC)load( userptr, "glVertexAttrib4Nubv" );
		glad_glVertexAttrib4Nuiv = (PFNGLVERTEXATTRIB4NUIVPROC)load( userptr, "glVertexAttrib4Nuiv" );
		glad_glVertexAttrib4Nusv = (PFNGLVERTEXATTRIB4NUSVPROC)load( userptr, "glVertexAttrib4Nusv" );
		glad_glVertexAttrib4bv = (PFNGLVERTEXATTRIB4BVPROC)load( userptr, "glVertexAttrib4bv" );
		glad_glVertexAttrib4d = (PFNGLVERTEXATTRIB4DPROC)load( userptr, "glVertexAttrib4d" );
		glad_glVertexAttrib4dv = (PFNGLVERTEXATTRIB4DVPROC)load( userptr, "glVertexAttrib4dv" );
		glad_glVertexAttrib4f = (PFNGLVERTEXATTRIB4FPROC)load( userptr, "glVertexAttrib4f" );
		glad_glVertexAttrib4fv = (PFNGLVERTEXATTRIB4FVPROC)load( userptr, "glVertexAttrib4fv" );
		glad_glVertexAttrib4iv = (PFNGLVERTEXATTRIB4IVPROC)load( userptr, "glVertexAttrib4iv" );
		glad_glVertexAttrib4s = (PFNGLVERTEXATTRIB4SPROC)load( userptr, "glVertexAttrib4s" );
		glad_glVertexAttrib4sv = (PFNGLVERTEXATTRIB4SVPROC)load( userptr, "glVertexAttrib4sv" );
		glad_glVertexAttrib4ubv = (PFNGLVERTEXATTRIB4UBVPROC)load( userptr, "glVertexAttrib4ubv" );
		glad_glVertexAttrib4uiv = (PFNGLVERTEXATTRIB4UIVPROC)load( userptr, "glVertexAttrib4uiv" );
		glad_glVertexAttrib4usv = (PFNGLVERTEXATTRIB4USVPROC)load( userptr, "glVertexAttrib4usv" );
		glad_glVertexAttribPointer = (PFNGLVERTEXATTRIBPOINTERPROC)load( userptr, "glVertexAttribPointer" );
	}
	static void glad_gl_load_GL_VERSION_2_1( GLADuserptrloadfunc load, void* userptr ) {
		if (!GLAD_GL_VERSION_2_1) return;
		glad_glUniformMatrix2x3fv = (PFNGLUNIFORMMATRIX2X3FVPROC)load( userptr, "glUniformMatrix2x3fv" );
		glad_glUniformMatrix2x4fv = (PFNGLUNIFORMMATRIX2X4FVPROC)load( userptr, "glUniformMatrix2x4fv" );
		glad_glUniformMatrix3x2fv = (PFNGLUNIFORMMATRIX3X2FVPROC)load( userptr, "glUniformMatrix3x2fv" );
		glad_glUniformMatrix3x4fv = (PFNGLUNIFORMMATRIX3X4FVPROC)load( userptr, "glUniformMatrix3x4fv" );
		glad_glUniformMatrix4x2fv = (PFNGLUNIFORMMATRIX4X2FVPROC)load( userptr, "glUniformMatrix4x2fv" );
		glad_glUniformMatrix4x3fv = (PFNGLUNIFORMMATRIX4X3FVPROC)load( userptr, "glUniformMatrix4x3fv" );
	}
	static void glad_gl_load_GL_VERSION_3_0( GLADuserptrloadfunc load, void* userptr ) {
		if (!GLAD_GL_VERSION_3_0) return;
		glad_glBeginConditionalRender = (PFNGLBEGINCONDITIONALRENDERPROC)load( userptr, "glBeginConditionalRender" );
		glad_glBeginTransformFeedback = (PFNGLBEGINTRANSFORMFEEDBACKPROC)load( userptr, "glBeginTransformFeedback" );
		glad_glBindBufferBase = (PFNGLBINDBUFFERBASEPROC)load( userptr, "glBindBufferBase" );
		glad_glBindBufferRange = (PFNGLBINDBUFFERRANGEPROC)load( userptr, "glBindBufferRange" );
		glad_glBindFragDataLocation = (PFNGLBINDFRAGDATALOCATIONPROC)load( userptr, "glBindFragDataLocation" );
		glad_glBindFramebuffer = (PFNGLBINDFRAMEBUFFERPROC)load( userptr, "glBindFramebuffer" );
		glad_glBindRenderbuffer = (PFNGLBINDRENDERBUFFERPROC)load( userptr, "glBindRenderbuffer" );
		glad_glBindVertexArray = (PFNGLBINDVERTEXARRAYPROC)load( userptr, "glBindVertexArray" );
		glad_glBlitFramebuffer = (PFNGLBLITFRAMEBUFFERPROC)load( userptr, "glBlitFramebuffer" );
		glad_glCheckFramebufferStatus = (PFNGLCHECKFRAMEBUFFERSTATUSPROC)load( userptr, "glCheckFramebufferStatus" );
		glad_glClampColor = (PFNGLCLAMPCOLORPROC)load( userptr, "glClampColor" );
		glad_glClearBufferfi = (PFNGLCLEARBUFFERFIPROC)load( userptr, "glClearBufferfi" );
		glad_glClearBufferfv = (PFNGLCLEARBUFFERFVPROC)load( userptr, "glClearBufferfv" );
		glad_glClearBufferiv = (PFNGLCLEARBUFFERIVPROC)load( userptr, "glClearBufferiv" );
		glad_glClearBufferuiv = (PFNGLCLEARBUFFERUIVPROC)load( userptr, "glClearBufferuiv" );
		glad_glColorMaski = (PFNGLCOLORMASKIPROC)load( userptr, "glColorMaski" );
		glad_glDeleteFramebuffers = (PFNGLDELETEFRAMEBUFFERSPROC)load( userptr, "glDeleteFramebuffers" );
		glad_glDeleteRenderbuffers = (PFNGLDELETERENDERBUFFERSPROC)load( userptr, "glDeleteRenderbuffers" );
		glad_glDeleteVertexArrays = (PFNGLDELETEVERTEXARRAYSPROC)load( userptr, "glDeleteVertexArrays" );
		glad_glDisablei = (PFNGLDISABLEIPROC)load( userptr, "glDisablei" );
		glad_glEnablei = (PFNGLENABLEIPROC)load( userptr, "glEnablei" );
		glad_glEndConditionalRender = (PFNGLENDCONDITIONALRENDERPROC)load( userptr, "glEndConditionalRender" );
		glad_glEndTransformFeedback = (PFNGLENDTRANSFORMFEEDBACKPROC)load( userptr, "glEndTransformFeedback" );
		glad_glFlushMappedBufferRange = (PFNGLFLUSHMAPPEDBUFFERRANGEPROC)load( userptr, "glFlushMappedBufferRange" );
		glad_glFramebufferRenderbuffer = (PFNGLFRAMEBUFFERRENDERBUFFERPROC)load( userptr, "glFramebufferRenderbuffer" );
		glad_glFramebufferTexture1D = (PFNGLFRAMEBUFFERTEXTURE1DPROC)load( userptr, "glFramebufferTexture1D" );
		glad_glFramebufferTexture2D = (PFNGLFRAMEBUFFERTEXTURE2DPROC)load( userptr, "glFramebufferTexture2D" );
		glad_glFramebufferTexture3D = (PFNGLFRAMEBUFFERTEXTURE3DPROC)load( userptr, "glFramebufferTexture3D" );
		glad_glFramebufferTextureLayer = (PFNGLFRAMEBUFFERTEXTURELAYERPROC)load( userptr, "glFramebufferTextureLayer" );
		glad_glGenFramebuffers = (PFNGLGENFRAMEBUFFERSPROC)load( userptr, "glGenFramebuffers" );
		glad_glGenRenderbuffers = (PFNGLGENRENDERBUFFERSPROC)load( userptr, "glGenRenderbuffers" );
		glad_glGenVertexArrays = (PFNGLGENVERTEXARRAYSPROC)load( userptr, "glGenVertexArrays" );
		glad_glGenerateMipmap = (PFNGLGENERATEMIPMAPPROC)load( userptr, "glGenerateMipmap" );
		glad_glGetBooleani_v = (PFNGLGETBOOLEANI_VPROC)load( userptr, "glGetBooleani_v" );
		glad_glGetFragDataLocation = (PFNGLGETFRAGDATALOCATIONPROC)load( userptr, "glGetFragDataLocation" );
		glad_glGetFramebufferAttachmentParameteriv = (PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC)load( userptr, "glGetFramebufferAttachmentParameteriv" );
		glad_glGetIntegeri_v = (PFNGLGETINTEGERI_VPROC)load( userptr, "glGetIntegeri_v" );
		glad_glGetRenderbufferParameteriv = (PFNGLGETRENDERBUFFERPARAMETERIVPROC)load( userptr, "glGetRenderbufferParameteriv" );
		glad_glGetStringi = (PFNGLGETSTRINGIPROC)load( userptr, "glGetStringi" );
		glad_glGetTexParameterIiv = (PFNGLGETTEXPARAMETERIIVPROC)load( userptr, "glGetTexParameterIiv" );
		glad_glGetTexParameterIuiv = (PFNGLGETTEXPARAMETERIUIVPROC)load( userptr, "glGetTexParameterIuiv" );
		glad_glGetTransformFeedbackVarying = (PFNGLGETTRANSFORMFEEDBACKVARYINGPROC)load( userptr, "glGetTransformFeedbackVarying" );
		glad_glGetUniformuiv = (PFNGLGETUNIFORMUIVPROC)load( userptr, "glGetUniformuiv" );
		glad_glGetVertexAttribIiv = (PFNGLGETVERTEXATTRIBIIVPROC)load( userptr, "glGetVertexAttribIiv" );
		glad_glGetVertexAttribIuiv = (PFNGLGETVERTEXATTRIBIUIVPROC)load( userptr, "glGetVertexAttribIuiv" );
		glad_glIsEnabledi = (PFNGLISENABLEDIPROC)load( userptr, "glIsEnabledi" );
		glad_glIsFramebuffer = (PFNGLISFRAMEBUFFERPROC)load( userptr, "glIsFramebuffer" );
		glad_glIsRenderbuffer = (PFNGLISRENDERBUFFERPROC)load( userptr, "glIsRenderbuffer" );
		glad_glIsVertexArray = (PFNGLISVERTEXARRAYPROC)load( userptr, "glIsVertexArray" );
		glad_glMapBufferRange = (PFNGLMAPBUFFERRANGEPROC)load( userptr, "glMapBufferRange" );
		glad_glRenderbufferStorage = (PFNGLRENDERBUFFERSTORAGEPROC)load( userptr, "glRenderbufferStorage" );
		glad_glRenderbufferStorageMultisample = (PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC)load( userptr, "glRenderbufferStorageMultisample" );
		glad_glTexParameterIiv = (PFNGLTEXPARAMETERIIVPROC)load( userptr, "glTexParameterIiv" );
		glad_glTexParameterIuiv = (PFNGLTEXPARAMETERIUIVPROC)load( userptr, "glTexParameterIuiv" );
		glad_glTransformFeedbackVaryings = (PFNGLTRANSFORMFEEDBACKVARYINGSPROC)load( userptr, "glTransformFeedbackVaryings" );
		glad_glUniform1ui = (PFNGLUNIFORM1UIPROC)load( userptr, "glUniform1ui" );
		glad_glUniform1uiv = (PFNGLUNIFORM1UIVPROC)load( userptr, "glUniform1uiv" );
		glad_glUniform2ui = (PFNGLUNIFORM2UIPROC)load( userptr, "glUniform2ui" );
		glad_glUniform2uiv = (PFNGLUNIFORM2UIVPROC)load( userptr, "glUniform2uiv" );
		glad_glUniform3ui = (PFNGLUNIFORM3UIPROC)load( userptr, "glUniform3ui" );
		glad_glUniform3uiv = (PFNGLUNIFORM3UIVPROC)load( userptr, "glUniform3uiv" );
		glad_glUniform4ui = (PFNGLUNIFORM4UIPROC)load( userptr, "glUniform4ui" );
		glad_glUniform4uiv = (PFNGLUNIFORM4UIVPROC)load( userptr, "glUniform4uiv" );
		glad_glVertexAttribI1i = (PFNGLVERTEXATTRIBI1IPROC)load( userptr, "glVertexAttribI1i" );
		glad_glVertexAttribI1iv = (PFNGLVERTEXATTRIBI1IVPROC)load( userptr, "glVertexAttribI1iv" );
		glad_glVertexAttribI1ui = (PFNGLVERTEXATTRIBI1UIPROC)load( userptr, "glVertexAttribI1ui" );
		glad_glVertexAttribI1uiv = (PFNGLVERTEXATTRIBI1UIVPROC)load( userptr, "glVertexAttribI1uiv" );
		glad_glVertexAttribI2i = (PFNGLVERTEXATTRIBI2IPROC)load( userptr, "glVertexAttribI2i" );
		glad_glVertexAttribI2iv = (PFNGLVERTEXATTRIBI2IVPROC)load( userptr, "glVertexAttribI2iv" );
		glad_glVertexAttribI2ui = (PFNGLVERTEXATTRIBI2UIPROC)load( userptr, "glVertexAttribI2ui" );
		glad_glVertexAttribI2uiv = (PFNGLVERTEXATTRIBI2UIVPROC)load( userptr, "glVertexAttribI2uiv" );
		glad_glVertexAttribI3i = (PFNGLVERTEXATTRIBI3IPROC)load( userptr, "glVertexAttribI3i" );
		glad_glVertexAttribI3iv = (PFNGLVERTEXATTRIBI3IVPROC)load( userptr, "glVertexAttribI3iv" );
		glad_glVertexAttribI3ui = (PFNGLVERTEXATTRIBI3UIPROC)load( userptr, "glVertexAttribI3ui" );
		glad_glVertexAttribI3uiv = (PFNGLVERTEXATTRIBI3UIVPROC)load( userptr, "glVertexAttribI3uiv" );
		glad_glVertexAttribI4bv = (PFNGLVERTEXATTRIBI4BVPROC)load( userptr, "glVertexAttribI4bv" );
		glad_glVertexAttribI4i = (PFNGLVERTEXATTRIBI4IPROC)load( userptr, "glVertexAttribI4i" );
		glad_glVertexAttribI4iv = (PFNGLVERTEXATTRIBI4IVPROC)load( userptr, "glVertexAttribI4iv" );
		glad_glVertexAttribI4sv = (PFNGLVERTEXATTRIBI4SVPROC)load( userptr, "glVertexAttribI4sv" );
		glad_glVertexAttribI4ubv = (PFNGLVERTEXATTRIBI4UBVPROC)load( userptr, "glVertexAttribI4ubv" );
		glad_glVertexAttribI4ui = (PFNGLVERTEXATTRIBI4UIPROC)load( userptr, "glVertexAttribI4ui" );
		glad_glVertexAttribI4uiv = (PFNGLVERTEXATTRIBI4UIVPROC)load( userptr, "glVertexAttribI4uiv" );
		glad_glVertexAttribI4usv = (PFNGLVERTEXATTRIBI4USVPROC)load( userptr, "glVertexAttribI4usv" );
		glad_glVertexAttribIPointer = (PFNGLVERTEXATTRIBIPOINTERPROC)load( userptr, "glVertexAttribIPointer" );
	}
	static void glad_gl_load_GL_VERSION_3_1( GLADuserptrloadfunc load, void* userptr ) {
		if (!GLAD_GL_VERSION_3_1) return;
		glad_glBindBufferBase = (PFNGLBINDBUFFERBASEPROC)load( userptr, "glBindBufferBase" );
		glad_glBindBufferRange = (PFNGLBINDBUFFERRANGEPROC)load( userptr, "glBindBufferRange" );
		glad_glCopyBufferSubData = (PFNGLCOPYBUFFERSUBDATAPROC)load( userptr, "glCopyBufferSubData" );
		glad_glDrawArraysInstanced = (PFNGLDRAWARRAYSINSTANCEDPROC)load( userptr, "glDrawArraysInstanced" );
		glad_glDrawElementsInstanced = (PFNGLDRAWELEMENTSINSTANCEDPROC)load( userptr, "glDrawElementsInstanced" );
		glad_glGetActiveUniformBlockName = (PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC)load( userptr, "glGetActiveUniformBlockName" );
		glad_glGetActiveUniformBlockiv = (PFNGLGETACTIVEUNIFORMBLOCKIVPROC)load( userptr, "glGetActiveUniformBlockiv" );
		glad_glGetActiveUniformName = (PFNGLGETACTIVEUNIFORMNAMEPROC)load( userptr, "glGetActiveUniformName" );
		glad_glGetActiveUniformsiv = (PFNGLGETACTIVEUNIFORMSIVPROC)load( userptr, "glGetActiveUniformsiv" );
		glad_glGetIntegeri_v = (PFNGLGETINTEGERI_VPROC)load( userptr, "glGetIntegeri_v" );
		glad_glGetUniformBlockIndex = (PFNGLGETUNIFORMBLOCKINDEXPROC)load( userptr, "glGetUniformBlockIndex" );
		glad_glGetUniformIndices = (PFNGLGETUNIFORMINDICESPROC)load( userptr, "glGetUniformIndices" );
		glad_glPrimitiveRestartIndex = (PFNGLPRIMITIVERESTARTINDEXPROC)load( userptr, "glPrimitiveRestartIndex" );
		glad_glTexBuffer = (PFNGLTEXBUFFERPROC)load( userptr, "glTexBuffer" );
		glad_glUniformBlockBinding = (PFNGLUNIFORMBLOCKBINDINGPROC)load( userptr, "glUniformBlockBinding" );
	}
	static void glad_gl_load_GL_VERSION_3_2( GLADuserptrloadfunc load, void* userptr ) {
		if (!GLAD_GL_VERSION_3_2) return;
		glad_glClientWaitSync = (PFNGLCLIENTWAITSYNCPROC)load( userptr, "glClientWaitSync" );
		glad_glDeleteSync = (PFNGLDELETESYNCPROC)load( userptr, "glDeleteSync" );
		glad_glDrawElementsBaseVertex = (PFNGLDRAWELEMENTSBASEVERTEXPROC)load( userptr, "glDrawElementsBaseVertex" );
		glad_glDrawElementsInstancedBaseVertex = (PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC)load( userptr, "glDrawElementsInstancedBaseVertex" );
		glad_glDrawRangeElementsBaseVertex = (PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC)load( userptr, "glDrawRangeElementsBaseVertex" );
		glad_glFenceSync = (PFNGLFENCESYNCPROC)load( userptr, "glFenceSync" );
		glad_glFramebufferTexture = (PFNGLFRAMEBUFFERTEXTUREPROC)load( userptr, "glFramebufferTexture" );
		glad_glGetBufferParameteri64v = (PFNGLGETBUFFERPARAMETERI64VPROC)load( userptr, "glGetBufferParameteri64v" );
		glad_glGetInteger64i_v = (PFNGLGETINTEGER64I_VPROC)load( userptr, "glGetInteger64i_v" );
		glad_glGetInteger64v = (PFNGLGETINTEGER64VPROC)load( userptr, "glGetInteger64v" );
		glad_glGetMultisamplefv = (PFNGLGETMULTISAMPLEFVPROC)load( userptr, "glGetMultisamplefv" );
		glad_glGetSynciv = (PFNGLGETSYNCIVPROC)load( userptr, "glGetSynciv" );
		glad_glIsSync = (PFNGLISSYNCPROC)load( userptr, "glIsSync" );
		glad_glMultiDrawElementsBaseVertex = (PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC)load( userptr, "glMultiDrawElementsBaseVertex" );
		glad_glProvokingVertex = (PFNGLPROVOKINGVERTEXPROC)load( userptr, "glProvokingVertex" );
		glad_glSampleMaski = (PFNGLSAMPLEMASKIPROC)load( userptr, "glSampleMaski" );
		glad_glTexImage2DMultisample = (PFNGLTEXIMAGE2DMULTISAMPLEPROC)load( userptr, "glTexImage2DMultisample" );
		glad_glTexImage3DMultisample = (PFNGLTEXIMAGE3DMULTISAMPLEPROC)load( userptr, "glTexImage3DMultisample" );
		glad_glWaitSync = (PFNGLWAITSYNCPROC)load( userptr, "glWaitSync" );
	}
	static void glad_gl_load_GL_VERSION_3_3( GLADuserptrloadfunc load, void* userptr ) {
		if (!GLAD_GL_VERSION_3_3) return;
		glad_glBindFragDataLocationIndexed = (PFNGLBINDFRAGDATALOCATIONINDEXEDPROC)load( userptr, "glBindFragDataLocationIndexed" );
		glad_glBindSampler = (PFNGLBINDSAMPLERPROC)load( userptr, "glBindSampler" );
		glad_glDeleteSamplers = (PFNGLDELETESAMPLERSPROC)load( userptr, "glDeleteSamplers" );
		glad_glGenSamplers = (PFNGLGENSAMPLERSPROC)load( userptr, "glGenSamplers" );
		glad_glGetFragDataIndex = (PFNGLGETFRAGDATAINDEXPROC)load( userptr, "glGetFragDataIndex" );
		glad_glGetQueryObjecti64v = (PFNGLGETQUERYOBJECTI64VPROC)load( userptr, "glGetQueryObjecti64v" );
		glad_glGetQueryObjectui64v = (PFNGLGETQUERYOBJECTUI64VPROC)load( userptr, "glGetQueryObjectui64v" );
		glad_glGetSamplerParameterIiv = (PFNGLGETSAMPLERPARAMETERIIVPROC)load( userptr, "glGetSamplerParameterIiv" );
		glad_glGetSamplerParameterIuiv = (PFNGLGETSAMPLERPARAMETERIUIVPROC)load( userptr, "glGetSamplerParameterIuiv" );
		glad_glGetSamplerParameterfv = (PFNGLGETSAMPLERPARAMETERFVPROC)load( userptr, "glGetSamplerParameterfv" );
		glad_glGetSamplerParameteriv = (PFNGLGETSAMPLERPARAMETERIVPROC)load( userptr, "glGetSamplerParameteriv" );
		glad_glIsSampler = (PFNGLISSAMPLERPROC)load( userptr, "glIsSampler" );
		glad_glQueryCounter = (PFNGLQUERYCOUNTERPROC)load( userptr, "glQueryCounter" );
		glad_glSamplerParameterIiv = (PFNGLSAMPLERPARAMETERIIVPROC)load( userptr, "glSamplerParameterIiv" );
		glad_glSamplerParameterIuiv = (PFNGLSAMPLERPARAMETERIUIVPROC)load( userptr, "glSamplerParameterIuiv" );
		glad_glSamplerParameterf = (PFNGLSAMPLERPARAMETERFPROC)load( userptr, "glSamplerParameterf" );
		glad_glSamplerParameterfv = (PFNGLSAMPLERPARAMETERFVPROC)load( userptr, "glSamplerParameterfv" );
		glad_glSamplerParameteri = (PFNGLSAMPLERPARAMETERIPROC)load( userptr, "glSamplerParameteri" );
		glad_glSamplerParameteriv = (PFNGLSAMPLERPARAMETERIVPROC)load( userptr, "glSamplerParameteriv" );
		glad_glVertexAttribDivisor = (PFNGLVERTEXATTRIBDIVISORPROC)load( userptr, "glVertexAttribDivisor" );
		glad_glVertexAttribP1ui = (PFNGLVERTEXATTRIBP1UIPROC)load( userptr, "glVertexAttribP1ui" );
		glad_glVertexAttribP1uiv = (PFNGLVERTEXATTRIBP1UIVPROC)load( userptr, "glVertexAttribP1uiv" );
		glad_glVertexAttribP2ui = (PFNGLVERTEXATTRIBP2UIPROC)load( userptr, "glVertexAttribP2ui" );
		glad_glVertexAttribP2uiv = (PFNGLVERTEXATTRIBP2UIVPROC)load( userptr, "glVertexAttribP2uiv" );
		glad_glVertexAttribP3ui = (PFNGLVERTEXATTRIBP3UIPROC)load( userptr, "glVertexAttribP3ui" );
		glad_glVertexAttribP3uiv = (PFNGLVERTEXATTRIBP3UIVPROC)load( userptr, "glVertexAttribP3uiv" );
		glad_glVertexAttribP4ui = (PFNGLVERTEXATTRIBP4UIPROC)load( userptr, "glVertexAttribP4ui" );
		glad_glVertexAttribP4uiv = (PFNGLVERTEXATTRIBP4UIVPROC)load( userptr, "glVertexAttribP4uiv" );
	}

	static void glad_gl_free_extensions( char** exts_i ) {
		if (exts_i != NULL) {
			unsigned int index;
			for (index = 0; exts_i[index]; index++) {
				free( (void*)(exts_i[index]) );
			}
			free( (void*)exts_i );
			exts_i = NULL;
		}
	}
	static int glad_gl_get_extensions( const char** out_exts, char*** out_exts_i ) {
	#if defined(GL_ES_VERSION_3_0) || defined(GL_VERSION_3_0)
		if (glad_glGetStringi != NULL && glad_glGetIntegerv != NULL) {
			unsigned int index = 0;
			unsigned int num_exts_i = 0;
			char** exts_i = NULL;
			glad_glGetIntegerv( GL_NUM_EXTENSIONS, (int*)&num_exts_i );
			exts_i = (char**)malloc( (num_exts_i + 1) * (sizeof * exts_i) );
			if (exts_i == NULL) {
				return 0;
			}
			for (index = 0; index < num_exts_i; index++) {
				const char* gl_str_tmp = (const char*)glad_glGetStringi( GL_EXTENSIONS, index );
				size_t len = strlen( gl_str_tmp ) + 1;

				char* local_str = (char*)malloc( len * sizeof( char ) );
				if (local_str == NULL) {
					exts_i[index] = NULL;
					glad_gl_free_extensions( exts_i );
					return 0;
				}

				memcpy( local_str, gl_str_tmp, len * sizeof( char ) );
				exts_i[index] = local_str;
			}
			exts_i[index] = NULL;

			*out_exts_i = exts_i;

			return 1;
		}
	#else
		GLAD_UNUSED( out_exts_i );
	#endif
		if (glad_glGetString == NULL) {
			return 0;
		}
		*out_exts = (const char*)glad_glGetString( GL_EXTENSIONS );
		return 1;
	}
	static int glad_gl_has_extension( const char* exts, char** exts_i, const char* ext ) {
		if (exts_i) {
			unsigned int index;
			for (index = 0; exts_i[index]; index++) {
				const char* e = exts_i[index];
				if (strcmp( e, ext ) == 0) {
					return 1;
				}
			}
		}
		else {
			const char* extensions;
			const char* loc;
			const char* terminator;
			extensions = exts;
			if (extensions == NULL || ext == NULL) {
				return 0;
			}
			while (1) {
				loc = strstr( extensions, ext );
				if (loc == NULL) {
					return 0;
				}
				terminator = loc + strlen( ext );
				if ((loc == extensions || *(loc - 1) == ' ') &&
					(*terminator == ' ' || *terminator == '\0')) {
					return 1;
				}
				extensions = terminator;
			}
		}
		return 0;
	}

	static GLADapiproc glad_gl_get_proc_from_userptr( void* userptr, const char* name ) {
		return (GLAD_GNUC_EXTENSION( GLADapiproc( * )(const char* name) ) userptr)(name);
	}

#pragma warning (disable:4551)
	static int glad_gl_find_extensions_gl( void ) {
		const char* exts = NULL;
		char** exts_i = NULL;
		if (!glad_gl_get_extensions( &exts, &exts_i )) return 0;

		GLAD_UNUSED( glad_gl_has_extension );

		glad_gl_free_extensions( exts_i );

		return 1;
	}

	static int glad_gl_find_core_gl( void ) {
		int i;
		const char* version;
		const char* prefixes[] = {
			"OpenGL ES-CM ",
			"OpenGL ES-CL ",
			"OpenGL ES ",
			"OpenGL SC ",
			NULL
		};
		int major = 0;
		int minor = 0;
		version = (const char*)glad_glGetString( GL_VERSION );
		if (!version) return 0;
		for (i = 0; prefixes[i]; i++) {
			const size_t length = strlen( prefixes[i] );
			if (strncmp( version, prefixes[i], length ) == 0) {
				version += length;
				break;
			}
		}

		GLAD_IMPL_UTIL_SSCANF( version, "%d.%d", &major, &minor );

		GLAD_GL_VERSION_1_0 = (major == 1 && minor >= 0) || major > 1;
		GLAD_GL_VERSION_1_1 = (major == 1 && minor >= 1) || major > 1;
		GLAD_GL_VERSION_1_2 = (major == 1 && minor >= 2) || major > 1;
		GLAD_GL_VERSION_1_3 = (major == 1 && minor >= 3) || major > 1;
		GLAD_GL_VERSION_1_4 = (major == 1 && minor >= 4) || major > 1;
		GLAD_GL_VERSION_1_5 = (major == 1 && minor >= 5) || major > 1;
		GLAD_GL_VERSION_2_0 = (major == 2 && minor >= 0) || major > 2;
		GLAD_GL_VERSION_2_1 = (major == 2 && minor >= 1) || major > 2;
		GLAD_GL_VERSION_3_0 = (major == 3 && minor >= 0) || major > 3;
		GLAD_GL_VERSION_3_1 = (major == 3 && minor >= 1) || major > 3;
		GLAD_GL_VERSION_3_2 = (major == 3 && minor >= 2) || major > 3;
		GLAD_GL_VERSION_3_3 = (major == 3 && minor >= 3) || major > 3;

		return GLAD_MAKE_VERSION( major, minor );
	}

	int gladLoadGLUserPtr( GLADuserptrloadfunc load, void* userptr ) {
		int version;

		glad_glGetString = (PFNGLGETSTRINGPROC)load( userptr, "glGetString" );
		if (glad_glGetString == NULL) return 0;
		version = glad_gl_find_core_gl();

		glad_gl_load_GL_VERSION_1_0( load, userptr );
		glad_gl_load_GL_VERSION_1_1( load, userptr );
		glad_gl_load_GL_VERSION_1_2( load, userptr );
		glad_gl_load_GL_VERSION_1_3( load, userptr );
		glad_gl_load_GL_VERSION_1_4( load, userptr );
		glad_gl_load_GL_VERSION_1_5( load, userptr );
		glad_gl_load_GL_VERSION_2_0( load, userptr );
		glad_gl_load_GL_VERSION_2_1( load, userptr );
		glad_gl_load_GL_VERSION_3_0( load, userptr );
		glad_gl_load_GL_VERSION_3_1( load, userptr );
		glad_gl_load_GL_VERSION_3_2( load, userptr );
		glad_gl_load_GL_VERSION_3_3( load, userptr );

		if (!glad_gl_find_extensions_gl()) return 0;

		return version;
	}

	int gladLoadGL( GLADloadfunc load ) {
		return gladLoadGLUserPtr( glad_gl_get_proc_from_userptr, GLAD_GNUC_EXTENSION( void* ) load );
	}

#ifdef GLAD_GL

#ifndef GLAD_LOADER_LIBRARY_C_
#define GLAD_LOADER_LIBRARY_C_

#include <stddef.h>
#include <stdlib.h>

#if GLAD_PLATFORM_WIN32
#include <windows.h>
#else
#include <dlfcn.h>
#endif

	static void* glad_get_dlopen_handle( const char* lib_names[], int length ) {
		void* handle = NULL;
		int i;

		for (i = 0; i < length; ++i) {
		#if GLAD_PLATFORM_WIN32
		#if GLAD_PLATFORM_UWP
			size_t buffer_size = (strlen( lib_names[i] ) + 1) * sizeof( WCHAR );
			LPWSTR buffer = (LPWSTR)malloc( buffer_size );
			if (buffer != NULL) {
				int ret = MultiByteToWideChar( CP_ACP, 0, lib_names[i], -1, buffer, buffer_size );
				if (ret != 0) {
					handle = (void*)LoadPackagedLibrary( buffer, 0 );
				}
				free( (void*)buffer );
			}
		#else
			handle = (void*)LoadLibraryA( lib_names[i] );
		#endif
		#else
			handle = dlopen( lib_names[i], RTLD_LAZY | RTLD_LOCAL );
		#endif
			if (handle != NULL) {
				return handle;
			}
		}

		return NULL;
	}

	static void glad_close_dlopen_handle( void* handle ) {
		if (handle != NULL) {
		#if GLAD_PLATFORM_WIN32
			FreeLibrary( (HMODULE)handle );
		#else
			dlclose( handle );
		#endif
		}
	}

	static GLADapiproc glad_dlsym_handle( void* handle, const char* name ) {
		if (handle == NULL) {
			return NULL;
		}

	#if GLAD_PLATFORM_WIN32
		return (GLADapiproc)GetProcAddress( (HMODULE)handle, name );
	#else
		return GLAD_GNUC_EXTENSION( GLADapiproc ) dlsym( handle, name );
	#endif
	}

#endif /* GLAD_LOADER_LIBRARY_C_ */

	typedef void* (GLAD_API_PTR* GLADglprocaddrfunc)(const char*);
	struct _glad_gl_userptr {
		void* handle;
		GLADglprocaddrfunc gl_get_proc_address_ptr;
	};

	static GLADapiproc glad_gl_get_proc( void* vuserptr, const char* name ) {
		struct _glad_gl_userptr userptr = *(struct _glad_gl_userptr*)vuserptr;
		GLADapiproc result = NULL;

		if (userptr.gl_get_proc_address_ptr != NULL) {
			result = GLAD_GNUC_EXTENSION( GLADapiproc ) userptr.gl_get_proc_address_ptr( name );
		}
		if (result == NULL) {
			result = glad_dlsym_handle( userptr.handle, name );
		}

		return result;
	}

	static void* _glad_GL_loader_handle = NULL;

	static void* glad_gl_dlopen_handle( void ) {
	#if GLAD_PLATFORM_APPLE
		static const char* NAMES[] = {
			"../Frameworks/OpenGL.framework/OpenGL",
			"/Library/Frameworks/OpenGL.framework/OpenGL",
			"/System/Library/Frameworks/OpenGL.framework/OpenGL",
			"/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL"
		};
	#elif GLAD_PLATFORM_WIN32
		static const char* NAMES[] = { "opengl32.dll" };
	#else
		static const char* NAMES[] = {
		#if defined(__CYGWIN__)
			"libGL-1.so",
		#endif
			"libGL.so.1",
			"libGL.so"
		};
	#endif

		if (_glad_GL_loader_handle == NULL) {
			_glad_GL_loader_handle = glad_get_dlopen_handle( NAMES, sizeof( NAMES ) / sizeof( NAMES[0] ) );
		}

		return _glad_GL_loader_handle;
	}

	static struct _glad_gl_userptr glad_gl_build_userptr( void* handle ) {
		struct _glad_gl_userptr userptr;

		userptr.handle = handle;
	#if GLAD_PLATFORM_APPLE || defined(__HAIKU__)
		userptr.gl_get_proc_address_ptr = NULL;
	#elif GLAD_PLATFORM_WIN32
		userptr.gl_get_proc_address_ptr =
			(GLADglprocaddrfunc)glad_dlsym_handle( handle, "wglGetProcAddress" );
	#else
		userptr.gl_get_proc_address_ptr =
			(GLADglprocaddrfunc)glad_dlsym_handle( handle, "glXGetProcAddressARB" );
	#endif

		return userptr;
	}

	int gladLoaderLoadGL( void ) {
		int version = 0;
		void* handle;
		int did_load = 0;
		struct _glad_gl_userptr userptr;

		did_load = _glad_GL_loader_handle == NULL;
		handle = glad_gl_dlopen_handle();
		if (handle) {
			userptr = glad_gl_build_userptr( handle );

			version = gladLoadGLUserPtr( glad_gl_get_proc, &userptr );

			if (did_load) {
				gladLoaderUnloadGL();
			}
		}

		return version;
	}

	void gladLoaderUnloadGL( void ) {
		if (_glad_GL_loader_handle != NULL) {
			glad_close_dlopen_handle( _glad_GL_loader_handle );
			_glad_GL_loader_handle = NULL;
		}
	}

#endif /* GLAD_GL */

#ifdef __cplusplus
}
#endif

// EOF