Add bindless texturing

code/cmdline/cmdline.cpp

@@ -219,6 +219,7 @@ Flag exe_params[] =
 	{ "-set_cpu_affinity",	"Sets processor affinity to config value",	true,	0,					EASY_DEFAULT,		"Troubleshoot", "", },
 	{ "-nograb",			"Disables mouse grabbing",					true,	0,					EASY_DEFAULT,		"Troubleshoot", "http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-nograb", },
 	{ "-noshadercache",		"Disables the shader cache",				true,	0,					EASY_DEFAULT,		"Troubleshoot", "http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-noshadercache", },
+	{ "-no_bindless_tex",	"Disable bindless texturing",				true,	0,					EASY_DEFAULT,		"Troubleshoot", "http://www.hard-light.net/wiki/index.php/Command-Line_Reference#-no_bindless_tex", },
 #ifdef WIN32
 	{ "-fix_registry",	"Use a different registry path",			true,		0,					EASY_DEFAULT,		"Troubleshoot", "", },
 #endif
@@ -449,6 +450,7 @@ cmdline_parm no_geo_sdr_effects("-no_geo_effects", NULL, AT_NONE);
 cmdline_parm set_cpu_affinity("-set_cpu_affinity", NULL, AT_NONE);
 cmdline_parm nograb_arg("-nograb", NULL, AT_NONE);
 cmdline_parm noshadercache_arg("-noshadercache", NULL, AT_NONE);
+cmdline_parm no_bindless_tex_arg("-no_bindless_tex", NULL, AT_NONE);
 #ifdef WIN32
 cmdline_parm fix_registry("-fix_registry", NULL, AT_NONE);
 #endif
@@ -467,6 +469,7 @@ bool Cmdline_no_geo_sdr_effects = false;
 bool Cmdline_set_cpu_affinity = false;
 bool Cmdline_nograb = false;
 bool Cmdline_noshadercache = false;
+bool Cmdline_no_bindless_textures = false;
 #ifdef WIN32
 bool Cmdline_alternate_registry_path = false;
 #endif
@@ -1937,6 +1940,11 @@ bool SetCmdlineParams()
 		Cmdline_noshadercache = true;
 	}
 
+	if (no_bindless_tex_arg.found())
+	{
+		Cmdline_no_bindless_textures = true;
+	}
+
 	if (portable_mode.found())
 	{
 		Cmdline_portable_mode = true;

code/cmdline/cmdline.h

@@ -135,6 +135,7 @@ extern bool Cmdline_no_geo_sdr_effects;
 extern bool Cmdline_set_cpu_affinity;
 extern bool Cmdline_nograb;
 extern bool Cmdline_noshadercache;
+extern bool Cmdline_no_bindless_textures;
 #ifdef WIN32
 extern bool Cmdline_alternate_registry_path;
 #endif

code/def_files/data/effects/main-f.sdr

@@ -1,4 +1,8 @@
 
+#ifdef FEATURE_BINDLESS_TEXTURES
+#extension GL_ARB_bindless_texture : require
+#endif
+
 #include "shadows.sdr"
 #include "lighting.sdr"
 #include "gamma.sdr"
@@ -19,6 +23,96 @@ struct model_light {
 	vec3 direction;
 };
 
+#ifdef FEATURE_BINDLESS_TEXTURES
+layout (std140) uniform modelData {
+	mat4 modelViewMatrix;
+	mat4 modelMatrix;
+	mat4 viewMatrix;
+	mat4 projMatrix;
+	mat4 textureMatrix;
+	mat4 shadow_mv_matrix;
+	mat4 shadow_proj_matrix[4];
+	mat4 envMatrix;
+
+	vec4 color;
+
+	model_light lights[MAX_LIGHTS];
+
+	float extrudeWidth;
+	float fogStart;
+	float fogScale;
+	int buffer_matrix_offset;
+
+	vec4 clip_equation;
+
+	float thruster_scale;
+	bool use_clip_plane;
+	int n_lights;
+	float defaultGloss;
+
+	vec3 ambientFactor;
+	int desaturate;
+
+	vec3 diffuseFactor;
+	int blend_alpha;
+
+	vec3 emissionFactor;
+	bool overrideDiffuse;
+
+	vec3 diffuseClr;
+	bool overrideGlow;
+
+	vec3 glowClr;
+	bool overrideSpec;
+
+	vec3 specClr;
+	bool alphaGloss;
+
+	bool gammaSpec;
+	bool envGloss;
+	bool alpha_spec;
+	int effect_num;
+
+	vec4 fogColor;
+
+	vec3 base_color;
+	float anim_timer;
+
+	vec3 stripe_color;
+	float vpwidth;
+
+	float vpheight;
+	bool team_glow_enabled;
+	float znear;
+	float zfar;
+
+	float veryneardist;
+	float neardist;
+	float middist;
+	float fardist;
+
+	vec2 normalAlphaMinMax;
+	int sBasemapIndex;
+	int sGlowmapIndex;
+
+	int sSpecmapIndex;
+	int sNormalmapIndex;
+	int sAmbientmapIndex;
+	int sMiscmapIndex;
+
+	sampler2DArray sBasemap;
+	sampler2DArray sGlowmap;
+
+	sampler2DArray sSpecmap;
+	samplerCube sEnvmap;
+
+	sampler2DArray sNormalmap;
+	sampler2DArray sAmbientmap;
+
+	sampler2DArray sMiscmap;
+	sampler2DArray sHeightmap;
+};
+#else
 layout (std140) uniform modelData {
 	mat4 modelViewMatrix;
 	mat4 modelMatrix;
@@ -95,6 +189,17 @@ layout (std140) uniform modelData {
 	int sAmbientmapIndex;
 	int sMiscmapIndex;
 };
+uniform sampler2DArray sBasemap;
+uniform sampler2DArray sGlowmap;
+uniform sampler2DArray sSpecmap;
+uniform samplerCube sEnvmap;
+uniform sampler2DArray sNormalmap;
+uniform sampler2DArray sAmbientmap;
+uniform sampler2DArray sMiscmap;
+#endif
+
+uniform sampler2D sFramebuffer;
+uniform sampler2DArray shadow_map;
 
 in VertexOutput {
 #ifdef FLAG_ENV_MAP
@@ -120,36 +225,9 @@ in VertexOutput {
 #endif
 } vertIn;
 
-#ifdef FLAG_DIFFUSE_MAP
-uniform sampler2DArray sBasemap;
-#endif
-#ifdef FLAG_GLOW_MAP
-uniform sampler2DArray sGlowmap;
-#endif
-#ifdef FLAG_SPEC_MAP
-uniform sampler2DArray sSpecmap;
-#endif
-#ifdef FLAG_ENV_MAP
-uniform samplerCube sEnvmap;
-#endif
-#ifdef FLAG_NORMAL_MAP
-uniform sampler2DArray sNormalmap;
-#endif
-#ifdef FLAG_AMBIENT_MAP
-uniform sampler2DArray sAmbientmap;
-#endif
-#ifdef FLAG_ANIMATED
-uniform sampler2D sFramebuffer;
-#endif
 #ifdef FLAG_TEAMCOLOR
 vec2 teamMask = vec2(0.0, 0.0);
 #endif
-#ifdef FLAG_MISC_MAP
-uniform sampler2DArray sMiscmap;
-#endif
-#ifdef FLAG_SHADOWS
-uniform sampler2DArray shadow_map;
-#endif
 
 out vec4 fragOut0;
 out vec4 fragOut1;

code/def_files/data/effects/main-g.sdr

@@ -1,5 +1,9 @@
 #extension GL_ARB_gpu_shader5: enable
 
+#ifdef FEATURE_BINDLESS_TEXTURES
+#extension GL_ARB_bindless_texture : require
+#endif
+
 layout (triangles) in;
 layout (triangle_strip, max_vertices = 3) out;
 #ifdef GL_ARB_gpu_shader5
@@ -19,6 +23,96 @@ struct model_light {
 	vec3 direction;
 };
 
+#ifdef FEATURE_BINDLESS_TEXTURES
+layout (std140) uniform modelData {
+	mat4 modelViewMatrix;
+	mat4 modelMatrix;
+	mat4 viewMatrix;
+	mat4 projMatrix;
+	mat4 textureMatrix;
+	mat4 shadow_mv_matrix;
+	mat4 shadow_proj_matrix[4];
+	mat4 envMatrix;
+
+	vec4 color;
+
+	model_light lights[MAX_LIGHTS];
+
+	float extrudeWidth;
+	float fogStart;
+	float fogScale;
+	int buffer_matrix_offset;
+
+	vec4 clip_equation;
+
+	float thruster_scale;
+	bool use_clip_plane;
+	int n_lights;
+	float defaultGloss;
+
+	vec3 ambientFactor;
+	int desaturate;
+
+	vec3 diffuseFactor;
+	int blend_alpha;
+
+	vec3 emissionFactor;
+	bool overrideDiffuse;
+
+	vec3 diffuseClr;
+	bool overrideGlow;
+
+	vec3 glowClr;
+	bool overrideSpec;
+
+	vec3 specClr;
+	bool alphaGloss;
+
+	bool gammaSpec;
+	bool envGloss;
+	bool alpha_spec;
+	int effect_num;
+
+	vec4 fogColor;
+
+	vec3 base_color;
+	float anim_timer;
+
+	vec3 stripe_color;
+	float vpwidth;
+
+	float vpheight;
+	bool team_glow_enabled;
+	float znear;
+	float zfar;
+
+	float veryneardist;
+	float neardist;
+	float middist;
+	float fardist;
+
+	vec2 normalAlphaMinMax;
+	int sBasemapIndex;
+	int sGlowmapIndex;
+
+	int sSpecmapIndex;
+	int sNormalmapIndex;
+	int sAmbientmapIndex;
+	int sMiscmapIndex;
+
+	sampler2DArray sBasemap;
+	sampler2DArray sGlowmap;
+
+	sampler2DArray sSpecmap;
+	samplerCube sEnvmap;
+
+	sampler2DArray sNormalmap;
+	sampler2DArray sAmbientmap;
+
+	sampler2DArray sMiscmap;
+	sampler2DArray sHeightmap;
+};
+#else
 layout (std140) uniform modelData {
 	mat4 modelViewMatrix;
 	mat4 modelMatrix;
@@ -95,6 +189,7 @@ layout (std140) uniform modelData {
 	int sAmbientmapIndex;
 	int sMiscmapIndex;
 };
+#endif
 
 in VertexOutput {
 #ifdef FLAG_ENV_MAP

code/def_files/data/effects/main-v.sdr

@@ -1,4 +1,7 @@
 #extension GL_ARB_gpu_shader5: enable
+#ifdef FEATURE_BINDLESS_TEXTURES
+#extension GL_ARB_bindless_texture : require
+#endif
 
 #include "shadows.sdr"
 
@@ -22,6 +25,96 @@ struct model_light {
 	vec3 direction;
 };
 
+#ifdef FEATURE_BINDLESS_TEXTURES
+layout (std140) uniform modelData {
+	mat4 modelViewMatrix;
+	mat4 modelMatrix;
+	mat4 viewMatrix;
+	mat4 projMatrix;
+	mat4 textureMatrix;
+	mat4 shadow_mv_matrix;
+	mat4 shadow_proj_matrix[4];
+	mat4 envMatrix;
+
+	vec4 color;
+
+	model_light lights[MAX_LIGHTS];
+
+	float extrudeWidth;
+	float fogStart;
+	float fogScale;
+	int buffer_matrix_offset;
+
+	vec4 clip_equation;
+
+	float thruster_scale;
+	bool use_clip_plane;
+	int n_lights;
+	float defaultGloss;
+
+	vec3 ambientFactor;
+	int desaturate;
+
+	vec3 diffuseFactor;
+	int blend_alpha;
+
+	vec3 emissionFactor;
+	bool overrideDiffuse;
+
+	vec3 diffuseClr;
+	bool overrideGlow;
+
+	vec3 glowClr;
+	bool overrideSpec;
+
+	vec3 specClr;
+	bool alphaGloss;
+
+	bool gammaSpec;
+	bool envGloss;
+	bool alpha_spec;
+	int effect_num;
+
+	vec4 fogColor;
+
+	vec3 base_color;
+	float anim_timer;
+
+	vec3 stripe_color;
+	float vpwidth;
+
+	float vpheight;
+	bool team_glow_enabled;
+	float znear;
+	float zfar;
+
+	float veryneardist;
+	float neardist;
+	float middist;
+	float fardist;
+
+	vec2 normalAlphaMinMax;
+	int sBasemapIndex;
+	int sGlowmapIndex;
+
+	int sSpecmapIndex;
+	int sNormalmapIndex;
+	int sAmbientmapIndex;
+	int sMiscmapIndex;
+
+	sampler2DArray sBasemap;
+	sampler2DArray sGlowmap;
+
+	sampler2DArray sSpecmap;
+	samplerCube sEnvmap;
+
+	sampler2DArray sNormalmap;
+	sampler2DArray sAmbientmap;
+
+	sampler2DArray sMiscmap;
+	sampler2DArray sHeightmap;
+};
+#else
 layout (std140) uniform modelData {
 	mat4 modelViewMatrix;
 	mat4 modelMatrix;
@@ -98,11 +191,10 @@ layout (std140) uniform modelData {
 	int sAmbientmapIndex;
 	int sMiscmapIndex;
 };
-
-#ifdef FLAG_TRANSFORM
-uniform samplerBuffer transform_tex;
 #endif
 
+uniform samplerBuffer transform_tex;
+
 out VertexOutput {
 #ifdef FLAG_ENV_MAP
 	vec3 envReflect;

code/graphics/2d.cpp

@@ -1125,6 +1125,9 @@ bool gr_init(std::unique_ptr<os::GraphicsOperations>&& graphicsOps, int d_mode,
 
 	gpu_heap_init();
 
+	mprintf(("Checking graphics capabilities:\n"));
+	mprintf(("  Bindless texturing: %s\n", gr_is_capable(CAPABILITY_BINDLESS_TEXTURING) ? "Enabled" : "Disabled"));
+
 	bool missing_installation = false;
 	if (!running_unittests && Web_cursor == nullptr) {
 		if (Is_standalone) {

code/graphics/2d.h

@@ -286,6 +286,7 @@ typedef enum gr_capability {
 	CAPABILITY_POINT_PARTICLES,
 	CAPABILITY_TIMESTAMP_QUERY,
 	CAPABILITY_SEPARATE_BLEND_FUNCTIONS,
+	CAPABILITY_BINDLESS_TEXTURING, //!< This is the ability to encode textures in uniform buffers
 } gr_capability;
 
 enum class gr_property {
@@ -803,6 +804,8 @@ typedef struct screen {
 	void (*gf_sync_delete)(gr_sync sync);
 
 	void (*gf_set_viewport)(int x, int y, int width, int height);
+
+	uint64_t (*gf_get_texture_handle)(int bitmap_handle, int bitmap_type);
 } screen;
 
 // handy macro
@@ -1108,6 +1111,10 @@ inline void gr_sync_delete(gr_sync sync) {
 	(*gr_screen.gf_sync_delete)(sync);
 }
 
+inline uint64_t gr_get_texture_handle(int bitmap, int bitmap_type) {
+	return (*gr_screen.gf_get_texture_handle)(bitmap, bitmap_type);
+}
+
 // color functions
 void gr_get_color( int *r, int *g, int  b );
 void gr_init_color(color *c, int r, int g, int b);

code/graphics/grstub.cpp

@@ -385,6 +385,10 @@ void gr_stub_delete_query_object(int obj)
 {
 }
 
+uint64_t gr_stub_get_texture_handle(int bitmap_handle, int bitmap_type) {
+	return 0;
+}
+
 bool gr_stub_init() 
 {
 	if (gr_screen.res != GR_640) {
@@ -532,5 +536,7 @@ bool gr_stub_init()
 
 	gr_screen.gf_bind_uniform_buffer = [](uniform_block_type, size_t, size_t, int) {};
 
+	gr_screen.gf_get_texture_handle = gr_stub_get_texture_handle;
+
 	return true;
 }

code/graphics/opengl/gropengl.cpp

@@ -1194,6 +1194,8 @@ void opengl_setup_function_pointers()
 
 	gr_screen.gf_set_viewport = gr_opengl_set_viewport;
 
+	gr_screen.gf_get_texture_handle = gr_opengl_get_texture_handle;
+
 	// NOTE: All function pointers here should have a Cmdline_nohtl check at the top
 	//       if they shouldn't be run in non-HTL mode, Don't keep separate entries.
 	// *****************************************************************************
@@ -1581,6 +1583,8 @@ bool gr_opengl_is_capable(gr_capability capability)
 		return GLAD_GL_ARB_timer_query != 0; // Timestamp queries are available from 3.3 onwards
 	case CAPABILITY_SEPARATE_BLEND_FUNCTIONS:
 		return GLAD_GL_ARB_draw_buffers_blend != 0; // We need an OpenGL extension for this
+	case CAPABILITY_BINDLESS_TEXTURING:
+		return GLAD_GL_ARB_bindless_texture != 0 && !Cmdline_no_bindless_textures;
 	}
 
 	return false;

code/graphics/opengl/gropenglshader.cpp

@@ -240,6 +240,15 @@ static opengl_shader_variant_t GL_shader_variants[] = {
 
 static const int GL_num_shader_variants = sizeof(GL_shader_variants) / sizeof(opengl_shader_variant_t);
 
+struct opengl_shader_feature {
+	const char* shader_define;
+	std::function<bool()> feature_test;
+};
+
+static SCP_vector<opengl_shader_feature> GL_shader_features = {
+	{ "FEATURE_BINDLESS_TEXTURES", []() { return gr_opengl_is_capable(CAPABILITY_BINDLESS_TEXTURING); } },
+};
+
 opengl_shader_t *Current_shader = NULL;
 
 opengl_shader_t::opengl_shader_t() : shader(SDR_TYPE_NONE), flags(0), flags2(0)
@@ -362,6 +371,13 @@ static SCP_string opengl_shader_get_header(shader_type type_id, int flags, shade
 				sflags << "#define " << variant.flag_text << "\n";
 			}
 		}
+
+		// Check the global shader features
+		for (auto& feature : GL_shader_features) {
+			if (feature.feature_test()) {
+				sflags << "#define " << feature.shader_define << "\n";
+			}
+		}
 	}
 
 	return sflags.str();

code/graphics/opengl/gropengltexture.cpp

@@ -1903,6 +1903,39 @@ void gr_opengl_bm_generate_mip_maps(int slot)
 
 	glGenerateMipmap(ts->texture_target);
 }
+uint64_t gr_opengl_get_texture_handle(int bitmap, int bitmap_type) {
+	Assertion(gr_opengl_is_capable(CAPABILITY_BINDLESS_TEXTURING),
+			  "Bindless texturing is not supported! Support must be checked before calling gr_get_texture_handle().");
+
+	int n = bm_get_cache_slot (bitmap, 1);
+	tcache_slot_opengl *t = &Textures[n];
+
+	if (t->texture_handle != 0) {
+		// We already have a texture handle for this texture
+		return t->texture_handle;
+	}
+
+	if (!bm_is_render_target(bitmap) && t->bitmap_handle < 0)
+	{
+		GL_state.Texture.SetActiveUnit(0);
+
+		auto ret_val = opengl_create_texture( bitmap, bitmap_type, t );
+
+		if (!ret_val) {
+			return 0;
+		}
+	}
+
+	// everything went ok
+	if (t->texture_id) {
+		t->texture_handle = glGetTextureHandleARB(t->texture_id);
+
+		// Always make the handles resident. Could be replaced by more sophisticated handling later
+		glMakeTextureHandleResidentARB(t->texture_handle);
+	}
+
+	return t->texture_handle;
+}
 
 //
 // End of GL_EXT_framebuffer_object stuff

code/graphics/opengl/gropengltexture.h

@@ -18,6 +18,7 @@
 
 typedef struct tcache_slot_opengl {
 	GLuint texture_id;
+	GLuint64 texture_handle; // Handle for bindless texturing
 	GLenum texture_target;
 	GLenum wrap_mode;
 	float u_scale, v_scale;
@@ -39,6 +40,7 @@ typedef struct tcache_slot_opengl {
 	void reset()
 	{
 		texture_id = 0;
+		texture_handle = 0;
 		texture_target = GL_TEXTURE_2D;
 		wrap_mode = GL_REPEAT;
 		u_scale = 1.0f;
@@ -93,4 +95,6 @@ GLuint opengl_get_rtt_framebuffer();
 void gr_opengl_bm_generate_mip_maps(int slot);
 void gr_opengl_get_texture_scale(int bitmap_handle, float *u_scale, float *v_scale);
 
+uint64_t gr_opengl_get_texture_handle(int bitmap, int bitmap_type);
+
 #endif	//_GROPENGLTEXTURE_H

code/graphics/opengl/gropengltnl.cpp

@@ -773,73 +773,80 @@ void opengl_tnl_set_model_material(model_material *material_info)
 	}
 
 	uint32_t array_index;
-	if ( Current_shader->flags & SDR_FLAG_MODEL_DIFFUSE_MAP ) {
-		Current_shader->program->Uniforms.setUniformi("sBasemap", render_pass);
+	if (!gr_opengl_is_capable(CAPABILITY_BINDLESS_TEXTURING)) {
+		// If we don't have bindless texturing support then we have to pass the texture the old-fashioned way
+		if ( Current_shader->flags & SDR_FLAG_MODEL_DIFFUSE_MAP ) {
+			Current_shader->program->Uniforms.setUniformi("sBasemap", render_pass);
 
-		gr_opengl_tcache_set(material_info->get_texture_map(TM_BASE_TYPE), TCACHE_TYPE_NORMAL, &u_scale, &v_scale, &array_index, render_pass);
-		++render_pass;
-	}
+			gr_opengl_tcache_set(material_info->get_texture_map(TM_BASE_TYPE), TCACHE_TYPE_NORMAL, &u_scale, &v_scale, &array_index, render_pass);
 
-	if ( Current_shader->flags & SDR_FLAG_MODEL_GLOW_MAP ) {
-		Current_shader->program->Uniforms.setUniformi("sGlowmap", render_pass);
-
-		gr_opengl_tcache_set(material_info->get_texture_map(TM_GLOW_TYPE), TCACHE_TYPE_NORMAL, &u_scale, &v_scale, &array_index, render_pass);
-
-		++render_pass;
-	}
-
-	if ( Current_shader->flags & SDR_FLAG_MODEL_SPEC_MAP ) {
-		Current_shader->program->Uniforms.setUniformi("sSpecmap", render_pass);
-
-		if ( material_info->get_texture_map(TM_SPEC_GLOSS_TYPE) > 0 ) {
-			gr_opengl_tcache_set(material_info->get_texture_map(TM_SPEC_GLOSS_TYPE), TCACHE_TYPE_NORMAL, &u_scale, &v_scale, &array_index, render_pass);
-		} else {
-			gr_opengl_tcache_set(material_info->get_texture_map(TM_SPECULAR_TYPE), TCACHE_TYPE_NORMAL, &u_scale, &v_scale, &array_index, render_pass);
+			++render_pass;
 		}
-		++render_pass;
 
-		if ( Current_shader->flags & SDR_FLAG_MODEL_ENV_MAP ) {
-			Current_shader->program->Uniforms.setUniformi("sEnvmap", render_pass);
+		if ( Current_shader->flags & SDR_FLAG_MODEL_GLOW_MAP ) {
+			Current_shader->program->Uniforms.setUniformi("sGlowmap", render_pass);
 
-			gr_opengl_tcache_set(ENVMAP, TCACHE_TYPE_CUBEMAP, &u_scale, &v_scale, &array_index, render_pass);
-			Assertion(array_index == 0, "Cube map arrays are not supported yet!");
+			gr_opengl_tcache_set(material_info->get_texture_map(TM_GLOW_TYPE), TCACHE_TYPE_NORMAL, &u_scale, &v_scale, &array_index, render_pass);
+
+			++render_pass;
+		}
+
+		if ( Current_shader->flags & SDR_FLAG_MODEL_SPEC_MAP ) {
+			Current_shader->program->Uniforms.setUniformi("sSpecmap", render_pass);
+
+			if ( material_info->get_texture_map(TM_SPEC_GLOSS_TYPE) > 0 ) {
+				gr_opengl_tcache_set(material_info->get_texture_map(TM_SPEC_GLOSS_TYPE), TCACHE_TYPE_NORMAL, &u_scale, &v_scale, &array_index, render_pass);
+			} else {
+				gr_opengl_tcache_set(material_info->get_texture_map(TM_SPECULAR_TYPE), TCACHE_TYPE_NORMAL, &u_scale, &v_scale, &array_index, render_pass);
+			}
+
+			++render_pass;
+
+			if ( Current_shader->flags & SDR_FLAG_MODEL_ENV_MAP ) {
+				Current_shader->program->Uniforms.setUniformi("sEnvmap", render_pass);
+
+				gr_opengl_tcache_set(ENVMAP, TCACHE_TYPE_CUBEMAP, &u_scale, &v_scale, &array_index, render_pass);
+				Assertion(array_index == 0, "Cube map arrays are not supported yet!");
+
+				++render_pass;
+			}
+		}
+
+		if ( Current_shader->flags & SDR_FLAG_MODEL_NORMAL_MAP ) {
+			Current_shader->program->Uniforms.setUniformi("sNormalmap", render_pass);
+
+			gr_opengl_tcache_set(material_info->get_texture_map(TM_NORMAL_TYPE), TCACHE_TYPE_NORMAL, &u_scale, &v_scale, &array_index, render_pass);
+
+			++render_pass;
+		}
+
+		if ( Current_shader->flags & SDR_FLAG_MODEL_HEIGHT_MAP ) {
+			Current_shader->program->Uniforms.setUniformi("sHeightmap", render_pass);
+
+			gr_opengl_tcache_set(material_info->get_texture_map(TM_HEIGHT_TYPE), TCACHE_TYPE_NORMAL, &u_scale, &v_scale, &array_index, render_pass);
+
+			++render_pass;
+		}
+
+		if ( Current_shader->flags & SDR_FLAG_MODEL_AMBIENT_MAP ) {
+			Current_shader->program->Uniforms.setUniformi("sAmbientmap", render_pass);
+
+			gr_opengl_tcache_set(material_info->get_texture_map(TM_AMBIENT_TYPE), TCACHE_TYPE_NORMAL, &u_scale, &v_scale, &array_index, render_pass);
+
+			++render_pass;
+		}
+
+		if ( Current_shader->flags & SDR_FLAG_MODEL_MISC_MAP ) {
+			Current_shader->program->Uniforms.setUniformi("sMiscmap", render_pass);
+
+			gr_opengl_tcache_set(material_info->get_texture_map(TM_MISC_TYPE), TCACHE_TYPE_NORMAL, &u_scale, &v_scale, &array_index, render_pass);
 
 			++render_pass;
 		}
 	}
 
-	if ( Current_shader->flags & SDR_FLAG_MODEL_NORMAL_MAP ) {
-		Current_shader->program->Uniforms.setUniformi("sNormalmap", render_pass);
-
-		gr_opengl_tcache_set(material_info->get_texture_map(TM_NORMAL_TYPE), TCACHE_TYPE_NORMAL, &u_scale, &v_scale, &array_index, render_pass);
-
-		++render_pass;
-	}
-
-	if ( Current_shader->flags & SDR_FLAG_MODEL_HEIGHT_MAP ) {
-		Current_shader->program->Uniforms.setUniformi("sHeightmap", render_pass);
-
-		gr_opengl_tcache_set(material_info->get_texture_map(TM_HEIGHT_TYPE), TCACHE_TYPE_NORMAL, &u_scale, &v_scale, &array_index, render_pass);
-
-		++render_pass;
-	}
-
-	if ( Current_shader->flags & SDR_FLAG_MODEL_AMBIENT_MAP ) {
-		Current_shader->program->Uniforms.setUniformi("sAmbientmap", render_pass);
-
-		gr_opengl_tcache_set(material_info->get_texture_map(TM_AMBIENT_TYPE), TCACHE_TYPE_NORMAL, &u_scale, &v_scale, &array_index, render_pass);
-
-		++render_pass;
-	}
-
-	if ( Current_shader->flags & SDR_FLAG_MODEL_MISC_MAP ) {
-		Current_shader->program->Uniforms.setUniformi("sMiscmap", render_pass);
-
-		gr_opengl_tcache_set(material_info->get_texture_map(TM_MISC_TYPE), TCACHE_TYPE_NORMAL, &u_scale, &v_scale, &array_index, render_pass);
-
-		++render_pass;
-	}
-
+	// The rest of the textures are mostly static so bindless texturing doesn't matter too much here (and it would be
+	// hard to expose the handles to the outside without some serious refactoring)
 	if ( Current_shader->flags & SDR_FLAG_MODEL_SHADOWS ) {
 		Current_shader->program->Uniforms.setUniformi("shadow_map", render_pass);
 

code/graphics/uniforms.cpp

@@ -72,7 +72,7 @@ void convert_model_material(model_uniform_data* data_out,
 	}
 
 	if (shader_flags & SDR_FLAG_MODEL_LIGHT) {
-		int num_lights = MIN(Num_active_gr_lights, (int)graphics::MAX_UNIFORM_LIGHTS);
+		int num_lights = MIN(Num_active_gr_lights, (int) graphics::MAX_UNIFORM_LIGHTS);
 		data_out->n_lights = num_lights;
 
 		std::copy(std::begin(gr_light_uniforms), std::end(gr_light_uniforms), std::begin(data_out->lights));
@@ -187,15 +187,15 @@ void convert_model_material(model_uniform_data* data_out,
 		}
 	}
 
-	if ( shader_flags & SDR_FLAG_MODEL_NORMAL_MAP ) {
+	if (shader_flags & SDR_FLAG_MODEL_NORMAL_MAP) {
 		data_out->sNormalmapIndex = bm_get_array_index(material.get_texture_map(TM_NORMAL_TYPE));
 	}
 
-	if ( shader_flags & SDR_FLAG_MODEL_AMBIENT_MAP ) {
+	if (shader_flags & SDR_FLAG_MODEL_AMBIENT_MAP) {
 		data_out->sAmbientmapIndex = bm_get_array_index(material.get_texture_map(TM_AMBIENT_TYPE));
 	}
 
-	if ( shader_flags & SDR_FLAG_MODEL_MISC_MAP ) {
+	if (shader_flags & SDR_FLAG_MODEL_MISC_MAP) {
 		data_out->sMiscmapIndex = bm_get_array_index(material.get_texture_map(TM_MISC_TYPE));
 	}
 
@@ -270,5 +270,52 @@ void convert_model_material(model_uniform_data* data_out,
 	}
 }
 
+void convert_bindless_model_material(model_uniform_data_bindless* data_out,
+									 const model_material& material,
+									 const matrix4& model_transform,
+									 const vec3d& scale,
+									 size_t transform_buffer_offset) {
+	// Convert the normal data with the existing function
+	convert_model_material(&data_out->model_data, material, model_transform, scale, transform_buffer_offset);
+
+	auto shader_flags = material.get_shader_flags();
+
+	if ( shader_flags & SDR_FLAG_MODEL_DIFFUSE_MAP ) {
+		data_out->sBasemap = gr_get_texture_handle(material.get_texture_map(TM_BASE_TYPE), TCACHE_TYPE_NORMAL);
+	}
+
+	if ( shader_flags & SDR_FLAG_MODEL_GLOW_MAP ) {
+		data_out->sGlowmap = gr_get_texture_handle(material.get_texture_map(TM_GLOW_TYPE), TCACHE_TYPE_NORMAL);
+	}
+
+	if ( shader_flags & SDR_FLAG_MODEL_SPEC_MAP ) {
+		if ( material.get_texture_map(TM_SPEC_GLOSS_TYPE) > 0 ) {
+			data_out->sSpecmap = gr_get_texture_handle(material.get_texture_map(TM_SPEC_GLOSS_TYPE), TCACHE_TYPE_NORMAL);
+		} else {
+			data_out->sSpecmap = gr_get_texture_handle(material.get_texture_map(TM_SPECULAR_TYPE), TCACHE_TYPE_NORMAL);
+		}
+
+		if ( shader_flags & SDR_FLAG_MODEL_ENV_MAP ) {
+			data_out->sEnvmap = gr_get_texture_handle(ENVMAP, TCACHE_TYPE_CUBEMAP);
+		}
+	}
+
+	if ( shader_flags & SDR_FLAG_MODEL_NORMAL_MAP ) {
+		data_out->sNormalmap = gr_get_texture_handle(material.get_texture_map(TM_NORMAL_TYPE), TCACHE_TYPE_NORMAL);
+	}
+
+	if ( shader_flags & SDR_FLAG_MODEL_HEIGHT_MAP ) {
+		data_out->sHeightmap = gr_get_texture_handle(material.get_texture_map(TM_HEIGHT_TYPE), TCACHE_TYPE_NORMAL);
+	}
+
+	if ( shader_flags & SDR_FLAG_MODEL_AMBIENT_MAP ) {
+		data_out->sAmbientmap = gr_get_texture_handle(material.get_texture_map(TM_AMBIENT_TYPE), TCACHE_TYPE_NORMAL);
+	}
+
+	if ( shader_flags & SDR_FLAG_MODEL_MISC_MAP ) {
+		data_out->sMiscmap = gr_get_texture_handle(material.get_texture_map(TM_MISC_TYPE), TCACHE_TYPE_NORMAL);
+	}
+}
+
 }
 }

code/graphics/uniforms.h

@@ -18,5 +18,11 @@ void convert_model_material(model_uniform_data* data_out,
 							const vec3d& scale,
 							size_t transform_buffer_offset);
 
+void convert_bindless_model_material(model_uniform_data_bindless* data_out,
+									 const model_material& material,
+									 const matrix4& model_transform,
+									 const vec3d& scale,
+									 size_t transform_buffer_offset);
+
 }
 }

code/graphics/util/UniformBufferManager.cpp

@@ -10,7 +10,11 @@ size_t getElementSize(uniform_block_type type) {
 	case uniform_block_type::Lights:
 		return sizeof(graphics::deferred_light_data);
 	case uniform_block_type::ModelData:
-		return sizeof(graphics::model_uniform_data);
+		if (gr_is_capable(CAPABILITY_BINDLESS_TEXTURING)) {
+			return sizeof(graphics::model_uniform_data_bindless);
+		} else {
+			return sizeof(graphics::model_uniform_data);
+		}
 	case uniform_block_type::NanoVGData:
 		return sizeof(graphics::nanovg_draw_data);
 	case uniform_block_type::DecalInfo:

code/graphics/util/uniform_structs.h

@@ -143,6 +143,22 @@ struct model_uniform_data {
 	int sMiscmapIndex;
 };
 
+struct model_uniform_data_bindless {
+	model_uniform_data model_data;
+
+	uint64_t sBasemap;
+	uint64_t sGlowmap;
+
+	uint64_t sSpecmap;
+	uint64_t sEnvmap;
+
+	uint64_t sNormalmap;
+	uint64_t sAmbientmap;
+
+	uint64_t sMiscmap;
+	uint64_t sHeightmap;
+};
+
 enum class NanoVGShaderType: int32_t {
 	FillGradient = 0, FillImage = 1, Simple = 2, Image = 3
 };

code/model/modelrender.cpp

@@ -543,7 +543,7 @@ void model_draw_list::render_buffer(queued_buffer_draw &render_elements)
 
 	gr_bind_uniform_buffer(uniform_block_type::ModelData,
 						   render_elements.uniform_buffer_offset,
-						   sizeof(graphics::model_uniform_data),
+						   render_elements.uniform_data_size,
 						   _dataBuffer->bufferHandle());
 
 	gr_render_model(&render_elements.render_material, render_elements.vert_src, render_elements.buffer, render_elements.texi);
@@ -797,6 +797,7 @@ void model_draw_list::build_uniform_buffer() {
 	TRACE_SCOPE(tracing::BuildModelUniforms);
 
 	_dataBuffer = gr_get_uniform_buffer(uniform_block_type::ModelData);
+	auto bindless_textures = gr_is_capable(CAPABILITY_BINDLESS_TEXTURING);
 
 	for (auto render_index : Render_keys) {
 		auto& queued_draw = Render_elements[render_index];
@@ -810,12 +811,23 @@ void model_draw_list::build_uniform_buffer() {
 			Scene_light_handler.resetLightState();
 		}
 
-		auto element = _dataBuffer->aligner().addTypedElement<graphics::model_uniform_data>();
-		graphics::uniforms::convert_model_material(element,
-												   queued_draw.render_material,
-												   queued_draw.transform,
-												   queued_draw.scale,
-												   queued_draw.transform_buffer_offset);
+		if (bindless_textures) {
+			auto element = _dataBuffer->aligner().addTypedElement<graphics::model_uniform_data_bindless>();
+			graphics::uniforms::convert_bindless_model_material(element,
+																queued_draw.render_material,
+																queued_draw.transform,
+																queued_draw.scale,
+																queued_draw.transform_buffer_offset);
+			queued_draw.uniform_data_size = sizeof(graphics::model_uniform_data_bindless);
+		} else {
+			auto element = _dataBuffer->aligner().addTypedElement<graphics::model_uniform_data>();
+			graphics::uniforms::convert_model_material(element,
+													   queued_draw.render_material,
+													   queued_draw.transform,
+													   queued_draw.scale,
+													   queued_draw.transform_buffer_offset);
+			queued_draw.uniform_data_size = sizeof(graphics::model_uniform_data);
+		}
 		queued_draw.uniform_buffer_offset = _dataBuffer->aligner().getCurrentOffset();
 	}
 

code/model/modelrender.h

@@ -183,6 +183,7 @@ struct queued_buffer_draw
 {
 	size_t transform_buffer_offset = 0;
 	size_t uniform_buffer_offset = 0;
+	size_t uniform_data_size = 0;
 
 	model_material render_material;
 

lib/opengl/gl/extensions.txt

@@ -9,3 +9,4 @@ GL_ARB_texture_storage
 GL_ARB_gpu_shader5
 GL_ARB_vertex_attrib_binding
 GL_ARB_draw_buffers_blend
+GL_ARB_bindless_texture

lib/opengl/gl/glad/include/glad/glad.h

@@ -1,12 +1,13 @@
 /*
 
-    OpenGL loader generated by glad 0.1.16a0 on Thu Mar  1 11:53:09 2018.
+    OpenGL loader generated by glad 0.1.16a0 on Tue Apr  3 09:52:46 2018.
 
     Language/Generator: C/C++
     Specification: gl
     APIs: gl=3.2
     Profile: core
     Extensions:
+        GL_ARB_bindless_texture,
         GL_ARB_debug_output,
         GL_ARB_draw_buffers_blend,
         GL_ARB_get_program_binary,
@@ -23,9 +24,9 @@
     Omit khrplatform: False
 
     Commandline:
-        --profile="core" --api="gl=3.2" --generator="c" --spec="gl" --no-loader --extensions="GL_ARB_debug_output,GL_ARB_draw_buffers_blend,GL_ARB_get_program_binary,GL_ARB_gpu_shader5,GL_ARB_shader_texture_lod,GL_ARB_texture_storage,GL_ARB_timer_query,GL_ARB_vertex_attrib_binding,GL_EXT_texture_compression_s3tc,GL_EXT_texture_filter_anisotropic,GL_KHR_debug"
+        --profile="core" --api="gl=3.2" --generator="c" --spec="gl" --no-loader --extensions="GL_ARB_bindless_texture,GL_ARB_debug_output,GL_ARB_draw_buffers_blend,GL_ARB_get_program_binary,GL_ARB_gpu_shader5,GL_ARB_shader_texture_lod,GL_ARB_texture_storage,GL_ARB_timer_query,GL_ARB_vertex_attrib_binding,GL_EXT_texture_compression_s3tc,GL_EXT_texture_filter_anisotropic,GL_KHR_debug"
     Online:
-        http://glad.dav1d.de/#profile=core&language=c&specification=gl&api=gl%3D3.2&extensions=GL_ARB_debug_output&extensions=GL_ARB_draw_buffers_blend&extensions=GL_ARB_get_program_binary&extensions=GL_ARB_gpu_shader5&extensions=GL_ARB_shader_texture_lod&extensions=GL_ARB_texture_storage&extensions=GL_ARB_timer_query&extensions=GL_ARB_vertex_attrib_binding&extensions=GL_EXT_texture_compression_s3tc&extensions=GL_EXT_texture_filter_anisotropic&extensions=GL_KHR_debug
+        http://glad.dav1d.de/#profile=core&language=c&specification=gl&api=gl%3D3.2&extensions=GL_ARB_bindless_texture&extensions=GL_ARB_debug_output&extensions=GL_ARB_draw_buffers_blend&extensions=GL_ARB_get_program_binary&extensions=GL_ARB_gpu_shader5&extensions=GL_ARB_shader_texture_lod&extensions=GL_ARB_texture_storage&extensions=GL_ARB_timer_query&extensions=GL_ARB_vertex_attrib_binding&extensions=GL_EXT_texture_compression_s3tc&extensions=GL_EXT_texture_filter_anisotropic&extensions=GL_KHR_debug
 */
 
 
@@ -1139,7 +1140,7 @@ GLAPI PFNGLGETTEXLEVELPARAMETERIVPROC glad_glGetTexLevelParameteriv;
 typedef GLboolean (APIENTRYP PFNGLISENABLEDPROC)(GLenum cap);
 GLAPI PFNGLISENABLEDPROC glad_glIsEnabled;
 #define glIsEnabled glad_glIsEnabled
-typedef void (APIENTRYP PFNGLDEPTHRANGEPROC)(GLdouble near, GLdouble far);
+typedef void (APIENTRYP PFNGLDEPTHRANGEPROC)(GLdouble n, GLdouble f);
 GLAPI PFNGLDEPTHRANGEPROC glad_glDepthRange;
 #define glDepthRange glad_glDepthRange
 typedef void (APIENTRYP PFNGLVIEWPORTPROC)(GLint x, GLint y, GLsizei width, GLsizei height);
@@ -1990,6 +1991,7 @@ typedef void (APIENTRYP PFNGLSAMPLEMASKIPROC)(GLuint maskNumber, GLbitfield mask
 GLAPI PFNGLSAMPLEMASKIPROC glad_glSampleMaski;
 #define glSampleMaski glad_glSampleMaski
 #endif
+#define GL_UNSIGNED_INT64_ARB 0x140F
 #define GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB 0x8242
 #define GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH_ARB 0x8243
 #define GL_DEBUG_CALLBACK_FUNCTION_ARB 0x8244
@@ -2119,6 +2121,58 @@ GLAPI PFNGLSAMPLEMASKIPROC glad_glSampleMaski;
 #define GL_STACK_OVERFLOW_KHR 0x0503
 #define GL_STACK_UNDERFLOW_KHR 0x0504
 #define GL_DISPLAY_LIST 0x82E7
+#ifndef GL_ARB_bindless_texture
+#define GL_ARB_bindless_texture 1
+GLAPI int GLAD_GL_ARB_bindless_texture;
+typedef GLuint64 (APIENTRYP PFNGLGETTEXTUREHANDLEARBPROC)(GLuint texture);
+GLAPI PFNGLGETTEXTUREHANDLEARBPROC glad_glGetTextureHandleARB;
+#define glGetTextureHandleARB glad_glGetTextureHandleARB
+typedef GLuint64 (APIENTRYP PFNGLGETTEXTURESAMPLERHANDLEARBPROC)(GLuint texture, GLuint sampler);
+GLAPI PFNGLGETTEXTURESAMPLERHANDLEARBPROC glad_glGetTextureSamplerHandleARB;
+#define glGetTextureSamplerHandleARB glad_glGetTextureSamplerHandleARB
+typedef void (APIENTRYP PFNGLMAKETEXTUREHANDLERESIDENTARBPROC)(GLuint64 handle);
+GLAPI PFNGLMAKETEXTUREHANDLERESIDENTARBPROC glad_glMakeTextureHandleResidentARB;
+#define glMakeTextureHandleResidentARB glad_glMakeTextureHandleResidentARB
+typedef void (APIENTRYP PFNGLMAKETEXTUREHANDLENONRESIDENTARBPROC)(GLuint64 handle);
+GLAPI PFNGLMAKETEXTUREHANDLENONRESIDENTARBPROC glad_glMakeTextureHandleNonResidentARB;
+#define glMakeTextureHandleNonResidentARB glad_glMakeTextureHandleNonResidentARB
+typedef GLuint64 (APIENTRYP PFNGLGETIMAGEHANDLEARBPROC)(GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum format);
+GLAPI PFNGLGETIMAGEHANDLEARBPROC glad_glGetImageHandleARB;
+#define glGetImageHandleARB glad_glGetImageHandleARB
+typedef void (APIENTRYP PFNGLMAKEIMAGEHANDLERESIDENTARBPROC)(GLuint64 handle, GLenum access);
+GLAPI PFNGLMAKEIMAGEHANDLERESIDENTARBPROC glad_glMakeImageHandleResidentARB;
+#define glMakeImageHandleResidentARB glad_glMakeImageHandleResidentARB
+typedef void (APIENTRYP PFNGLMAKEIMAGEHANDLENONRESIDENTARBPROC)(GLuint64 handle);
+GLAPI PFNGLMAKEIMAGEHANDLENONRESIDENTARBPROC glad_glMakeImageHandleNonResidentARB;
+#define glMakeImageHandleNonResidentARB glad_glMakeImageHandleNonResidentARB
+typedef void (APIENTRYP PFNGLUNIFORMHANDLEUI64ARBPROC)(GLint location, GLuint64 value);
+GLAPI PFNGLUNIFORMHANDLEUI64ARBPROC glad_glUniformHandleui64ARB;
+#define glUniformHandleui64ARB glad_glUniformHandleui64ARB
+typedef void (APIENTRYP PFNGLUNIFORMHANDLEUI64VARBPROC)(GLint location, GLsizei count, const GLuint64 *value);
+GLAPI PFNGLUNIFORMHANDLEUI64VARBPROC glad_glUniformHandleui64vARB;
+#define glUniformHandleui64vARB glad_glUniformHandleui64vARB
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORMHANDLEUI64ARBPROC)(GLuint program, GLint location, GLuint64 value);
+GLAPI PFNGLPROGRAMUNIFORMHANDLEUI64ARBPROC glad_glProgramUniformHandleui64ARB;
+#define glProgramUniformHandleui64ARB glad_glProgramUniformHandleui64ARB
+typedef void (APIENTRYP PFNGLPROGRAMUNIFORMHANDLEUI64VARBPROC)(GLuint program, GLint location, GLsizei count, const GLuint64 *values);
+GLAPI PFNGLPROGRAMUNIFORMHANDLEUI64VARBPROC glad_glProgramUniformHandleui64vARB;
+#define glProgramUniformHandleui64vARB glad_glProgramUniformHandleui64vARB
+typedef GLboolean (APIENTRYP PFNGLISTEXTUREHANDLERESIDENTARBPROC)(GLuint64 handle);
+GLAPI PFNGLISTEXTUREHANDLERESIDENTARBPROC glad_glIsTextureHandleResidentARB;
+#define glIsTextureHandleResidentARB glad_glIsTextureHandleResidentARB
+typedef GLboolean (APIENTRYP PFNGLISIMAGEHANDLERESIDENTARBPROC)(GLuint64 handle);
+GLAPI PFNGLISIMAGEHANDLERESIDENTARBPROC glad_glIsImageHandleResidentARB;
+#define glIsImageHandleResidentARB glad_glIsImageHandleResidentARB
+typedef void (APIENTRYP PFNGLVERTEXATTRIBL1UI64ARBPROC)(GLuint index, GLuint64EXT x);
+GLAPI PFNGLVERTEXATTRIBL1UI64ARBPROC glad_glVertexAttribL1ui64ARB;
+#define glVertexAttribL1ui64ARB glad_glVertexAttribL1ui64ARB
+typedef void (APIENTRYP PFNGLVERTEXATTRIBL1UI64VARBPROC)(GLuint index, const GLuint64EXT *v);
+GLAPI PFNGLVERTEXATTRIBL1UI64VARBPROC glad_glVertexAttribL1ui64vARB;
+#define glVertexAttribL1ui64vARB glad_glVertexAttribL1ui64vARB
+typedef void (APIENTRYP PFNGLGETVERTEXATTRIBLUI64VARBPROC)(GLuint index, GLenum pname, GLuint64EXT *params);
+GLAPI PFNGLGETVERTEXATTRIBLUI64VARBPROC glad_glGetVertexAttribLui64vARB;
+#define glGetVertexAttribLui64vARB glad_glGetVertexAttribLui64vARB
+#endif
 #ifndef GL_ARB_debug_output
 #define GL_ARB_debug_output 1
 GLAPI int GLAD_GL_ARB_debug_output;

lib/opengl/gl/glad/src/glad.c

@@ -1,12 +1,13 @@
 /*
 
-    OpenGL loader generated by glad 0.1.16a0 on Thu Mar  1 11:53:09 2018.
+    OpenGL loader generated by glad 0.1.16a0 on Tue Apr  3 09:52:46 2018.
 
     Language/Generator: C/C++
     Specification: gl
     APIs: gl=3.2
     Profile: core
     Extensions:
+        GL_ARB_bindless_texture,
         GL_ARB_debug_output,
         GL_ARB_draw_buffers_blend,
         GL_ARB_get_program_binary,
@@ -23,9 +24,9 @@
     Omit khrplatform: False
 
     Commandline:
-        --profile="core" --api="gl=3.2" --generator="c" --spec="gl" --no-loader --extensions="GL_ARB_debug_output,GL_ARB_draw_buffers_blend,GL_ARB_get_program_binary,GL_ARB_gpu_shader5,GL_ARB_shader_texture_lod,GL_ARB_texture_storage,GL_ARB_timer_query,GL_ARB_vertex_attrib_binding,GL_EXT_texture_compression_s3tc,GL_EXT_texture_filter_anisotropic,GL_KHR_debug"
+        --profile="core" --api="gl=3.2" --generator="c" --spec="gl" --no-loader --extensions="GL_ARB_bindless_texture,GL_ARB_debug_output,GL_ARB_draw_buffers_blend,GL_ARB_get_program_binary,GL_ARB_gpu_shader5,GL_ARB_shader_texture_lod,GL_ARB_texture_storage,GL_ARB_timer_query,GL_ARB_vertex_attrib_binding,GL_EXT_texture_compression_s3tc,GL_EXT_texture_filter_anisotropic,GL_KHR_debug"
     Online:
-        http://glad.dav1d.de/#profile=core&language=c&specification=gl&api=gl%3D3.2&extensions=GL_ARB_debug_output&extensions=GL_ARB_draw_buffers_blend&extensions=GL_ARB_get_program_binary&extensions=GL_ARB_gpu_shader5&extensions=GL_ARB_shader_texture_lod&extensions=GL_ARB_texture_storage&extensions=GL_ARB_timer_query&extensions=GL_ARB_vertex_attrib_binding&extensions=GL_EXT_texture_compression_s3tc&extensions=GL_EXT_texture_filter_anisotropic&extensions=GL_KHR_debug
+        http://glad.dav1d.de/#profile=core&language=c&specification=gl&api=gl%3D3.2&extensions=GL_ARB_bindless_texture&extensions=GL_ARB_debug_output&extensions=GL_ARB_draw_buffers_blend&extensions=GL_ARB_get_program_binary&extensions=GL_ARB_gpu_shader5&extensions=GL_ARB_shader_texture_lod&extensions=GL_ARB_texture_storage&extensions=GL_ARB_timer_query&extensions=GL_ARB_vertex_attrib_binding&extensions=GL_EXT_texture_compression_s3tc&extensions=GL_EXT_texture_filter_anisotropic&extensions=GL_KHR_debug
 */
 
 #include <stdio.h>
@@ -147,333 +148,350 @@ int GLAD_GL_VERSION_2_1;
 int GLAD_GL_VERSION_3_0;
 int GLAD_GL_VERSION_3_1;
 int GLAD_GL_VERSION_3_2;
+PFNGLGENTEXTURESPROC glad_glGenTextures;
+PFNGLSAMPLECOVERAGEPROC glad_glSampleCoverage;
+PFNGLGENQUERIESPROC glad_glGenQueries;
+PFNGLDRAWELEMENTSINSTANCEDPROC glad_glDrawElementsInstanced;
+PFNGLREADBUFFERPROC glad_glReadBuffer;
 PFNGLVERTEXATTRIB4UBVPROC glad_glVertexAttrib4ubv;
-PFNGLGETSTRINGIPROC glad_glGetStringi;
+PFNGLDEPTHMASKPROC glad_glDepthMask;
+PFNGLPOINTPARAMETERIPROC glad_glPointParameteri;
+PFNGLGETDOUBLEVPROC glad_glGetDoublev;
+PFNGLDRAWELEMENTSPROC glad_glDrawElements;
+PFNGLLINKPROGRAMPROC glad_glLinkProgram;
+PFNGLGETERRORPROC glad_glGetError;
+PFNGLVERTEXATTRIB3DVPROC glad_glVertexAttrib3dv;
+PFNGLBINDFRAMEBUFFERPROC glad_glBindFramebuffer;
+PFNGLVERTEXATTRIB2DVPROC glad_glVertexAttrib2dv;
+PFNGLISSYNCPROC glad_glIsSync;
+PFNGLBINDBUFFERPROC glad_glBindBuffer;
+PFNGLBLENDEQUATIONPROC glad_glBlendEquation;
+PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC glad_glCompressedTexSubImage2D;
+PFNGLENDCONDITIONALRENDERPROC glad_glEndConditionalRender;
 PFNGLGETINTEGER64VPROC glad_glGetInteger64v;
-PFNGLUNIFORM1FPROC glad_glUniform1f;
+PFNGLTEXPARAMETERFVPROC glad_glTexParameterfv;
+PFNGLLINEWIDTHPROC glad_glLineWidth;
+PFNGLGETFLOATVPROC glad_glGetFloatv;
+PFNGLENDTRANSFORMFEEDBACKPROC glad_glEndTransformFeedback;
+PFNGLCLEARBUFFERFVPROC glad_glClearBufferfv;
+PFNGLFINISHPROC glad_glFinish;
+PFNGLVERTEXATTRIB3FPROC glad_glVertexAttrib3f;
+PFNGLBEGINTRANSFORMFEEDBACKPROC glad_glBeginTransformFeedback;
+PFNGLGETATTACHEDSHADERSPROC glad_glGetAttachedShaders;
+PFNGLCLEARBUFFERFIPROC glad_glClearBufferfi;
+PFNGLVERTEXATTRIBI3IPROC glad_glVertexAttribI3i;
+PFNGLUNIFORMMATRIX3X4FVPROC glad_glUniformMatrix3x4fv;
+PFNGLCREATEPROGRAMPROC glad_glCreateProgram;
+PFNGLGENBUFFERSPROC glad_glGenBuffers;
+PFNGLGETTEXPARAMETERIIVPROC glad_glGetTexParameterIiv;
+PFNGLVERTEXATTRIBI3UIPROC glad_glVertexAttribI3ui;
+PFNGLCOPYTEXIMAGE2DPROC glad_glCopyTexImage2D;
+PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC glad_glCompressedTexSubImage3D;
+PFNGLGETRENDERBUFFERPARAMETERIVPROC glad_glGetRenderbufferParameteriv;
+PFNGLGETBOOLEANVPROC glad_glGetBooleanv;
+PFNGLTEXPARAMETERFPROC glad_glTexParameterf;
+PFNGLPROVOKINGVERTEXPROC glad_glProvokingVertex;
+PFNGLGETCOMPRESSEDTEXIMAGEPROC glad_glGetCompressedTexImage;
+PFNGLDELETEPROGRAMPROC glad_glDeleteProgram;
+PFNGLGETPROGRAMIVPROC glad_glGetProgramiv;
+PFNGLCLEARDEPTHPROC glad_glClearDepth;
+PFNGLDELETETEXTURESPROC glad_glDeleteTextures;
+PFNGLBLITFRAMEBUFFERPROC glad_glBlitFramebuffer;
+PFNGLUNIFORM4IPROC glad_glUniform4i;
+PFNGLVERTEXATTRIB4NUSVPROC glad_glVertexAttrib4Nusv;
+PFNGLUNIFORM3IVPROC glad_glUniform3iv;
+PFNGLGETVERTEXATTRIBIIVPROC glad_glGetVertexAttribIiv;
+PFNGLVERTEXATTRIBI4USVPROC glad_glVertexAttribI4usv;
+PFNGLGENVERTEXARRAYSPROC glad_glGenVertexArrays;
+PFNGLISFRAMEBUFFERPROC glad_glIsFramebuffer;
+PFNGLISTEXTUREPROC glad_glIsTexture;
+PFNGLVERTEXATTRIB1FPROC glad_glVertexAttrib1f;
+PFNGLGETUNIFORMFVPROC glad_glGetUniformfv;
+PFNGLTEXPARAMETERIVPROC glad_glTexParameteriv;
+PFNGLVERTEXATTRIB1FVPROC glad_glVertexAttrib1fv;
+PFNGLBUFFERDATAPROC glad_glBufferData;
+PFNGLDISABLEPROC glad_glDisable;
+PFNGLPOINTPARAMETERIVPROC glad_glPointParameteriv;
+PFNGLUNIFORM2IPROC glad_glUniform2i;
+PFNGLVERTEXATTRIB2DPROC glad_glVertexAttrib2d;
+PFNGLUNIFORMMATRIX4X3FVPROC glad_glUniformMatrix4x3fv;
+PFNGLGETQUERYOBJECTUIVPROC glad_glGetQueryObjectuiv;
+PFNGLMULTIDRAWARRAYSPROC glad_glMultiDrawArrays;
+PFNGLVERTEXATTRIBI4UBVPROC glad_glVertexAttribI4ubv;
+PFNGLVERTEXATTRIBI1IVPROC glad_glVertexAttribI1iv;
+PFNGLUNIFORM1UIPROC glad_glUniform1ui;
+PFNGLVERTEXATTRIB4UIVPROC glad_glVertexAttrib4uiv;
+PFNGLISVERTEXARRAYPROC glad_glIsVertexArray;
+PFNGLENDQUERYPROC glad_glEndQuery;
+PFNGLVERTEXATTRIBI2UIPROC glad_glVertexAttribI2ui;
+PFNGLGETTRANSFORMFEEDBACKVARYINGPROC glad_glGetTransformFeedbackVarying;
+PFNGLSTENCILOPSEPARATEPROC glad_glStencilOpSeparate;
+PFNGLUSEPROGRAMPROC glad_glUseProgram;
+PFNGLGENFRAMEBUFFERSPROC glad_glGenFramebuffers;
+PFNGLCLIENTWAITSYNCPROC glad_glClientWaitSync;
+PFNGLUNIFORM2FPROC glad_glUniform2f;
+PFNGLFRAMEBUFFERRENDERBUFFERPROC glad_glFramebufferRenderbuffer;
+PFNGLVERTEXATTRIB4NIVPROC glad_glVertexAttrib4Niv;
+PFNGLVERTEXATTRIB4NUBVPROC glad_glVertexAttrib4Nubv;
+PFNGLGETINTEGER64I_VPROC glad_glGetInteger64i_v;
+PFNGLGETBUFFERPARAMETERI64VPROC glad_glGetBufferParameteri64v;
+PFNGLBINDBUFFERBASEPROC glad_glBindBufferBase;
+PFNGLBINDTEXTUREPROC glad_glBindTexture;
+PFNGLDETACHSHADERPROC glad_glDetachShader;
+PFNGLVERTEXATTRIB4NUIVPROC glad_glVertexAttrib4Nuiv;
+PFNGLGETVERTEXATTRIBIUIVPROC glad_glGetVertexAttribIuiv;
+PFNGLVALIDATEPROGRAMPROC glad_glValidateProgram;
+PFNGLGETACTIVEUNIFORMBLOCKIVPROC glad_glGetActiveUniformBlockiv;
+PFNGLGETUNIFORMIVPROC glad_glGetUniformiv;
+PFNGLDRAWBUFFERSPROC glad_glDrawBuffers;
+PFNGLDELETEQUERIESPROC glad_glDeleteQueries;
+PFNGLUNMAPBUFFERPROC glad_glUnmapBuffer;
+PFNGLVERTEXATTRIB3SVPROC glad_glVertexAttrib3sv;
+PFNGLCOPYTEXSUBIMAGE1DPROC glad_glCopyTexSubImage1D;
+PFNGLSCISSORPROC glad_glScissor;
+PFNGLLOGICOPPROC glad_glLogicOp;
+PFNGLISENABLEDPROC glad_glIsEnabled;
+PFNGLISPROGRAMPROC glad_glIsProgram;
+PFNGLVERTEXATTRIBI4IPROC glad_glVertexAttribI4i;
+PFNGLVERTEXATTRIB3FVPROC glad_glVertexAttrib3fv;
+PFNGLBEGINCONDITIONALRENDERPROC glad_glBeginConditionalRender;
+PFNGLUNIFORMMATRIX4FVPROC glad_glUniformMatrix4fv;
+PFNGLCOMPILESHADERPROC glad_glCompileShader;
+PFNGLVERTEXATTRIBI1IPROC glad_glVertexAttribI1i;
+PFNGLVERTEXATTRIBIPOINTERPROC glad_glVertexAttribIPointer;
+PFNGLUNIFORM3UIPROC glad_glUniform3ui;
+PFNGLGETTEXPARAMETERIUIVPROC glad_glGetTexParameterIuiv;
+PFNGLFRONTFACEPROC glad_glFrontFace;
+PFNGLDRAWBUFFERPROC glad_glDrawBuffer;
+PFNGLENABLEVERTEXATTRIBARRAYPROC glad_glEnableVertexAttribArray;
+PFNGLDEPTHRANGEPROC glad_glDepthRange;
+PFNGLGETPROGRAMINFOLOGPROC glad_glGetProgramInfoLog;
+PFNGLUNIFORM2UIPROC glad_glUniform2ui;
+PFNGLCLEARBUFFERIVPROC glad_glClearBufferiv;
+PFNGLTEXIMAGE1DPROC glad_glTexImage1D;
+PFNGLACTIVETEXTUREPROC glad_glActiveTexture;
 PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC glad_glCompressedTexSubImage1D;
-PFNGLPOINTSIZEPROC glad_glPointSize;
-PFNGLVERTEXATTRIB2FVPROC glad_glVertexAttrib2fv;
+PFNGLMULTIDRAWELEMENTSPROC glad_glMultiDrawElements;
+PFNGLVERTEXATTRIBI3IVPROC glad_glVertexAttribI3iv;
+PFNGLGENERATEMIPMAPPROC glad_glGenerateMipmap;
+PFNGLUNIFORMMATRIX2X4FVPROC glad_glUniformMatrix2x4fv;
+PFNGLDRAWARRAYSINSTANCEDPROC glad_glDrawArraysInstanced;
+PFNGLGETACTIVEUNIFORMPROC glad_glGetActiveUniform;
+PFNGLCULLFACEPROC glad_glCullFace;
+PFNGLTEXIMAGE3DMULTISAMPLEPROC glad_glTexImage3DMultisample;
+PFNGLVERTEXATTRIB4BVPROC glad_glVertexAttrib4bv;
+PFNGLVERTEXATTRIB4SPROC glad_glVertexAttrib4s;
+PFNGLFRAMEBUFFERTEXTURE3DPROC glad_glFramebufferTexture3D;
+PFNGLVERTEXATTRIB1SVPROC glad_glVertexAttrib1sv;
+PFNGLBLENDFUNCSEPARATEPROC glad_glBlendFuncSeparate;
+PFNGLVERTEXATTRIB2FPROC glad_glVertexAttrib2f;
+PFNGLISSHADERPROC glad_glIsShader;
+PFNGLTEXSUBIMAGE1DPROC glad_glTexSubImage1D;
+PFNGLVERTEXATTRIBI2UIVPROC glad_glVertexAttribI2uiv;
+PFNGLUNIFORM1UIVPROC glad_glUniform1uiv;
+PFNGLVERTEXATTRIB1SPROC glad_glVertexAttrib1s;
+PFNGLISRENDERBUFFERPROC glad_glIsRenderbuffer;
+PFNGLGETINTEGERI_VPROC glad_glGetIntegeri_v;
+PFNGLCOMPRESSEDTEXIMAGE2DPROC glad_glCompressedTexImage2D;
+PFNGLMAPBUFFERPROC glad_glMapBuffer;
+PFNGLBINDBUFFERRANGEPROC glad_glBindBufferRange;
+PFNGLCOPYTEXSUBIMAGE3DPROC glad_glCopyTexSubImage3D;
+PFNGLDELETEBUFFERSPROC glad_glDeleteBuffers;
+PFNGLUNIFORM3UIVPROC glad_glUniform3uiv;
+PFNGLGETUNIFORMINDICESPROC glad_glGetUniformIndices;
+PFNGLGETQUERYOBJECTIVPROC glad_glGetQueryObjectiv;
+PFNGLCOLORMASKIPROC glad_glColorMaski;
+PFNGLFRAMEBUFFERTEXTURELAYERPROC glad_glFramebufferTextureLayer;
+PFNGLCHECKFRAMEBUFFERSTATUSPROC glad_glCheckFramebufferStatus;
+PFNGLCLEARBUFFERUIVPROC glad_glClearBufferuiv;
+PFNGLENABLEPROC glad_glEnable;
+PFNGLGETBUFFERPARAMETERIVPROC glad_glGetBufferParameteriv;
+PFNGLSTENCILMASKSEPARATEPROC glad_glStencilMaskSeparate;
+PFNGLGETBUFFERSUBDATAPROC glad_glGetBufferSubData;
+PFNGLGETFRAGDATALOCATIONPROC glad_glGetFragDataLocation;
+PFNGLVERTEXATTRIBI4BVPROC glad_glVertexAttribI4bv;
+PFNGLSTENCILFUNCSEPARATEPROC glad_glStencilFuncSeparate;
+PFNGLDRAWARRAYSPROC glad_glDrawArrays;
+PFNGLUNIFORM1FPROC glad_glUniform1f;
+PFNGLVERTEXATTRIBI1UIPROC glad_glVertexAttribI1ui;
+PFNGLATTACHSHADERPROC glad_glAttachShader;
+PFNGLDELETEFRAMEBUFFERSPROC glad_glDeleteFramebuffers;
+PFNGLVERTEXATTRIB4IVPROC glad_glVertexAttrib4iv;
+PFNGLBINDATTRIBLOCATIONPROC glad_glBindAttribLocation;
+PFNGLTEXIMAGE2DMULTISAMPLEPROC glad_glTexImage2DMultisample;
+PFNGLVERTEXATTRIB1DVPROC glad_glVertexAttrib1dv;
+PFNGLUNIFORM2IVPROC glad_glUniform2iv;
+PFNGLCOMPRESSEDTEXIMAGE1DPROC glad_glCompressedTexImage1D;
+PFNGLFLUSHMAPPEDBUFFERRANGEPROC glad_glFlushMappedBufferRange;
+PFNGLCREATESHADERPROC glad_glCreateShader;
+PFNGLMAPBUFFERRANGEPROC glad_glMapBufferRange;
 PFNGLDRAWELEMENTSBASEVERTEXPROC glad_glDrawElementsBaseVertex;
+PFNGLVERTEXATTRIB4USVPROC glad_glVertexAttrib4usv;
+PFNGLCOPYTEXIMAGE1DPROC glad_glCopyTexImage1D;
+PFNGLTEXSUBIMAGE3DPROC glad_glTexSubImage3D;
+PFNGLRENDERBUFFERSTORAGEPROC glad_glRenderbufferStorage;
+PFNGLDEPTHFUNCPROC glad_glDepthFunc;
+PFNGLBLENDCOLORPROC glad_glBlendColor;
+PFNGLVERTEXATTRIBI3UIVPROC glad_glVertexAttribI3uiv;
+PFNGLVERTEXATTRIBI1UIVPROC glad_glVertexAttribI1uiv;
+PFNGLTEXBUFFERPROC glad_glTexBuffer;
+PFNGLCLEARCOLORPROC glad_glClearColor;
+PFNGLGETTEXIMAGEPROC glad_glGetTexImage;
+PFNGLTEXPARAMETERIPROC glad_glTexParameteri;
+PFNGLGETACTIVEATTRIBPROC glad_glGetActiveAttrib;
+PFNGLUNIFORMMATRIX3FVPROC glad_glUniformMatrix3fv;
+PFNGLREADPIXELSPROC glad_glReadPixels;
 PFNGLGETINTEGERVPROC glad_glGetIntegerv;
+PFNGLGETVERTEXATTRIBFVPROC glad_glGetVertexAttribfv;
+PFNGLSTENCILOPPROC glad_glStencilOp;
+PFNGLPIXELSTOREIPROC glad_glPixelStorei;
+PFNGLVERTEXATTRIB1DPROC glad_glVertexAttrib1d;
+PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC glad_glGetFramebufferAttachmentParameteriv;
+PFNGLUNIFORM1FVPROC glad_glUniform1fv;
+PFNGLTEXSUBIMAGE2DPROC glad_glTexSubImage2D;
+PFNGLVERTEXATTRIBI2IPROC glad_glVertexAttribI2i;
+PFNGLVERTEXATTRIBI4SVPROC glad_glVertexAttribI4sv;
+PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC glad_glRenderbufferStorageMultisample;
+PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC glad_glMultiDrawElementsBaseVertex;
+PFNGLDELETESHADERPROC glad_glDeleteShader;
+PFNGLVERTEXATTRIB4DVPROC glad_glVertexAttrib4dv;
+PFNGLVERTEXATTRIB3SPROC glad_glVertexAttrib3s;
+PFNGLSHADERSOURCEPROC glad_glShaderSource;
+PFNGLGETTEXPARAMETERIVPROC glad_glGetTexParameteriv;
 PFNGLENABLEIPROC glad_glEnablei;
+PFNGLISENABLEDIPROC glad_glIsEnabledi;
+PFNGLVERTEXATTRIBI4IVPROC glad_glVertexAttribI4iv;
+PFNGLTEXPARAMETERIIVPROC glad_glTexParameterIiv;
+PFNGLBINDVERTEXARRAYPROC glad_glBindVertexArray;
+PFNGLPIXELSTOREFPROC glad_glPixelStoref;
+PFNGLGETVERTEXATTRIBIVPROC glad_glGetVertexAttribiv;
 PFNGLFRAMEBUFFERTEXTUREPROC glad_glFramebufferTexture;
 PFNGLISBUFFERPROC glad_glIsBuffer;
-PFNGLUNIFORM4FVPROC glad_glUniform4fv;
-PFNGLBLENDCOLORPROC glad_glBlendColor;
-PFNGLVERTEXATTRIBI3IPROC glad_glVertexAttribI3i;
-PFNGLGETVERTEXATTRIBPOINTERVPROC glad_glGetVertexAttribPointerv;
-PFNGLUNIFORM4UIPROC glad_glUniform4ui;
-PFNGLVERTEXATTRIB4SVPROC glad_glVertexAttrib4sv;
-PFNGLGENERATEMIPMAPPROC glad_glGenerateMipmap;
-PFNGLDRAWELEMENTSINSTANCEDPROC glad_glDrawElementsInstanced;
-PFNGLDELETEBUFFERSPROC glad_glDeleteBuffers;
-PFNGLISENABLEDPROC glad_glIsEnabled;
-PFNGLTEXSUBIMAGE1DPROC glad_glTexSubImage1D;
-PFNGLMAPBUFFERPROC glad_glMapBuffer;
-PFNGLSTENCILFUNCSEPARATEPROC glad_glStencilFuncSeparate;
-PFNGLUNIFORM3FVPROC glad_glUniform3fv;
-PFNGLVERTEXATTRIBI3IVPROC glad_glVertexAttribI3iv;
-PFNGLBINDVERTEXARRAYPROC glad_glBindVertexArray;
-PFNGLVERTEXATTRIB1DVPROC glad_glVertexAttrib1dv;
-PFNGLVERTEXATTRIB4USVPROC glad_glVertexAttrib4usv;
-PFNGLGETATTRIBLOCATIONPROC glad_glGetAttribLocation;
-PFNGLVERTEXATTRIB3SVPROC glad_glVertexAttrib3sv;
-PFNGLISQUERYPROC glad_glIsQuery;
-PFNGLDEPTHFUNCPROC glad_glDepthFunc;
-PFNGLPOLYGONOFFSETPROC glad_glPolygonOffset;
-PFNGLLOGICOPPROC glad_glLogicOp;
-PFNGLCOMPRESSEDTEXIMAGE2DPROC glad_glCompressedTexImage2D;
-PFNGLVERTEXATTRIB4BVPROC glad_glVertexAttrib4bv;
-PFNGLUNIFORM1IPROC glad_glUniform1i;
-PFNGLTEXPARAMETERIIVPROC glad_glTexParameterIiv;
 PFNGLBLENDEQUATIONSEPARATEPROC glad_glBlendEquationSeparate;
-PFNGLFRONTFACEPROC glad_glFrontFace;
-PFNGLVERTEXATTRIB1FPROC glad_glVertexAttrib1f;
-PFNGLVERTEXATTRIBI1UIPROC glad_glVertexAttribI1ui;
-PFNGLUNIFORM4IVPROC glad_glUniform4iv;
-PFNGLVERTEXATTRIBI4UBVPROC glad_glVertexAttribI4ubv;
-PFNGLTEXPARAMETERIUIVPROC glad_glTexParameterIuiv;
-PFNGLVERTEXATTRIBI1UIVPROC glad_glVertexAttribI1uiv;
-PFNGLPROVOKINGVERTEXPROC glad_glProvokingVertex;
-PFNGLPIXELSTOREIPROC glad_glPixelStorei;
-PFNGLDISABLEVERTEXATTRIBARRAYPROC glad_glDisableVertexAttribArray;
-PFNGLCOPYTEXSUBIMAGE1DPROC glad_glCopyTexSubImage1D;
-PFNGLGETVERTEXATTRIBIIVPROC glad_glGetVertexAttribIiv;
-PFNGLUNIFORM4UIVPROC glad_glUniform4uiv;
-PFNGLDEPTHRANGEPROC glad_glDepthRange;
-PFNGLVERTEXATTRIB4NIVPROC glad_glVertexAttrib4Niv;
-PFNGLGETSHADERINFOLOGPROC glad_glGetShaderInfoLog;
-PFNGLDISABLEPROC glad_glDisable;
-PFNGLGENFRAMEBUFFERSPROC glad_glGenFramebuffers;
-PFNGLGENBUFFERSPROC glad_glGenBuffers;
-PFNGLCOMPRESSEDTEXIMAGE3DPROC glad_glCompressedTexImage3D;
-PFNGLVERTEXATTRIB2FPROC glad_glVertexAttrib2f;
-PFNGLVERTEXATTRIB4NUBVPROC glad_glVertexAttrib4Nubv;
-PFNGLTEXPARAMETERFVPROC glad_glTexParameterfv;
-PFNGLGETBUFFERPARAMETERIVPROC glad_glGetBufferParameteriv;
-PFNGLDRAWELEMENTSPROC glad_glDrawElements;
-PFNGLVERTEXATTRIB3FVPROC glad_glVertexAttrib3fv;
+PFNGLGETTEXLEVELPARAMETERIVPROC glad_glGetTexLevelParameteriv;
+PFNGLVERTEXATTRIB4FVPROC glad_glVertexAttrib4fv;
+PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC glad_glDrawElementsInstancedBaseVertex;
+PFNGLBINDFRAGDATALOCATIONPROC glad_glBindFragDataLocation;
 PFNGLVERTEXATTRIB4NBVPROC glad_glVertexAttrib4Nbv;
-PFNGLVERTEXATTRIBI4UIPROC glad_glVertexAttribI4ui;
-PFNGLGETFLOATVPROC glad_glGetFloatv;
-PFNGLGETBUFFERSUBDATAPROC glad_glGetBufferSubData;
-PFNGLGETPROGRAMIVPROC glad_glGetProgramiv;
-PFNGLTEXPARAMETERIVPROC glad_glTexParameteriv;
-PFNGLMAPBUFFERRANGEPROC glad_glMapBufferRange;
-PFNGLGETTEXIMAGEPROC glad_glGetTexImage;
-PFNGLVERTEXATTRIB4NSVPROC glad_glVertexAttrib4Nsv;
-PFNGLVERTEXATTRIBI1IVPROC glad_glVertexAttribI1iv;
-PFNGLFLUSHMAPPEDBUFFERRANGEPROC glad_glFlushMappedBufferRange;
 PFNGLDISABLEIPROC glad_glDisablei;
-PFNGLCLEARBUFFERFIPROC glad_glClearBufferfi;
-PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC glad_glCompressedTexSubImage3D;
-PFNGLPOINTPARAMETERIVPROC glad_glPointParameteriv;
-PFNGLVERTEXATTRIB2DPROC glad_glVertexAttrib2d;
-PFNGLUNIFORM2FPROC glad_glUniform2f;
-PFNGLVERTEXATTRIBI4BVPROC glad_glVertexAttribI4bv;
-PFNGLTEXIMAGE2DMULTISAMPLEPROC glad_glTexImage2DMultisample;
-PFNGLSAMPLECOVERAGEPROC glad_glSampleCoverage;
-PFNGLBINDTEXTUREPROC glad_glBindTexture;
-PFNGLTEXPARAMETERFPROC glad_glTexParameterf;
-PFNGLCULLFACEPROC glad_glCullFace;
-PFNGLGETACTIVEUNIFORMPROC glad_glGetActiveUniform;
-PFNGLGETUNIFORMINDICESPROC glad_glGetUniformIndices;
-PFNGLBLENDFUNCSEPARATEPROC glad_glBlendFuncSeparate;
-PFNGLGENQUERIESPROC glad_glGenQueries;
-PFNGLUNIFORM3IPROC glad_glUniform3i;
-PFNGLRENDERBUFFERSTORAGEPROC glad_glRenderbufferStorage;
-PFNGLCOPYBUFFERSUBDATAPROC glad_glCopyBufferSubData;
-PFNGLVERTEXATTRIB4DVPROC glad_glVertexAttrib4dv;
-PFNGLUNIFORM1IVPROC glad_glUniform1iv;
-PFNGLBINDRENDERBUFFERPROC glad_glBindRenderbuffer;
-PFNGLBEGINTRANSFORMFEEDBACKPROC glad_glBeginTransformFeedback;
-PFNGLWAITSYNCPROC glad_glWaitSync;
-PFNGLGETINTEGERI_VPROC glad_glGetIntegeri_v;
-PFNGLSTENCILOPPROC glad_glStencilOp;
-PFNGLSHADERSOURCEPROC glad_glShaderSource;
-PFNGLCOPYTEXIMAGE2DPROC glad_glCopyTexImage2D;
-PFNGLCLEARBUFFERIVPROC glad_glClearBufferiv;
-PFNGLVERTEXATTRIBI2UIPROC glad_glVertexAttribI2ui;
-PFNGLDELETEPROGRAMPROC glad_glDeleteProgram;
-PFNGLDELETETEXTURESPROC glad_glDeleteTextures;
-PFNGLUNIFORMMATRIX2X3FVPROC glad_glUniformMatrix2x3fv;
-PFNGLCLEARPROC glad_glClear;
-PFNGLGETTRANSFORMFEEDBACKVARYINGPROC glad_glGetTransformFeedbackVarying;
-PFNGLUNIFORMMATRIX3FVPROC glad_glUniformMatrix3fv;
-PFNGLUNIFORM1FVPROC glad_glUniform1fv;
-PFNGLVERTEXATTRIB1FVPROC glad_glVertexAttrib1fv;
-PFNGLCREATEPROGRAMPROC glad_glCreateProgram;
-PFNGLUNIFORMMATRIX2X4FVPROC glad_glUniformMatrix2x4fv;
-PFNGLISENABLEDIPROC glad_glIsEnabledi;
-PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC glad_glGetActiveUniformBlockName;
-PFNGLSTENCILFUNCPROC glad_glStencilFunc;
-PFNGLVERTEXATTRIBI3UIVPROC glad_glVertexAttribI3uiv;
-PFNGLBINDATTRIBLOCATIONPROC glad_glBindAttribLocation;
-PFNGLUNIFORM1UIPROC glad_glUniform1ui;
-PFNGLENABLEVERTEXATTRIBARRAYPROC glad_glEnableVertexAttribArray;
-PFNGLGETQUERYOBJECTUIVPROC glad_glGetQueryObjectuiv;
-PFNGLBEGINQUERYPROC glad_glBeginQuery;
-PFNGLUNIFORM1UIVPROC glad_glUniform1uiv;
-PFNGLGETVERTEXATTRIBIUIVPROC glad_glGetVertexAttribIuiv;
-PFNGLISVERTEXARRAYPROC glad_glIsVertexArray;
+PFNGLGETACTIVEUNIFORMNAMEPROC glad_glGetActiveUniformName;
+PFNGLHINTPROC glad_glHint;
 PFNGLGETACTIVEUNIFORMSIVPROC glad_glGetActiveUniformsiv;
-PFNGLISSYNCPROC glad_glIsSync;
-PFNGLDRAWARRAYSPROC glad_glDrawArrays;
-PFNGLCLEARBUFFERUIVPROC glad_glClearBufferuiv;
+PFNGLGETVERTEXATTRIBDVPROC glad_glGetVertexAttribdv;
+PFNGLGETTEXPARAMETERFVPROC glad_glGetTexParameterfv;
+PFNGLUNIFORM4FPROC glad_glUniform4f;
+PFNGLPRIMITIVERESTARTINDEXPROC glad_glPrimitiveRestartIndex;
+PFNGLFRAMEBUFFERTEXTURE2DPROC glad_glFramebufferTexture2D;
+PFNGLGETMULTISAMPLEFVPROC glad_glGetMultisamplefv;
+PFNGLCOPYTEXSUBIMAGE2DPROC glad_glCopyTexSubImage2D;
+PFNGLGETSHADERSOURCEPROC glad_glGetShaderSource;
+PFNGLCLAMPCOLORPROC glad_glClampColor;
+PFNGLBINDRENDERBUFFERPROC glad_glBindRenderbuffer;
+PFNGLSTENCILMASKPROC glad_glStencilMask;
+PFNGLUNIFORM1IVPROC glad_glUniform1iv;
+PFNGLTEXPARAMETERIUIVPROC glad_glTexParameterIuiv;
+PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC glad_glDrawRangeElementsBaseVertex;
+PFNGLGETUNIFORMBLOCKINDEXPROC glad_glGetUniformBlockIndex;
+PFNGLGENRENDERBUFFERSPROC glad_glGenRenderbuffers;
+PFNGLWAITSYNCPROC glad_glWaitSync;
+PFNGLUNIFORM2FVPROC glad_glUniform2fv;
+PFNGLVERTEXATTRIBI4UIPROC glad_glVertexAttribI4ui;
+PFNGLDELETEVERTEXARRAYSPROC glad_glDeleteVertexArrays;
+PFNGLUNIFORM1IPROC glad_glUniform1i;
+PFNGLCLEARPROC glad_glClear;
+PFNGLUNIFORM4FVPROC glad_glUniform4fv;
+PFNGLVERTEXATTRIB2FVPROC glad_glVertexAttrib2fv;
+PFNGLVERTEXATTRIB3DPROC glad_glVertexAttrib3d;
+PFNGLTEXIMAGE3DPROC glad_glTexImage3D;
+PFNGLUNIFORMMATRIX3X2FVPROC glad_glUniformMatrix3x2fv;
+PFNGLBEGINQUERYPROC glad_glBeginQuery;
+PFNGLGETATTRIBLOCATIONPROC glad_glGetAttribLocation;
+PFNGLUNIFORM4IVPROC glad_glUniform4iv;
+PFNGLVERTEXATTRIB4FPROC glad_glVertexAttrib4f;
+PFNGLUNIFORMMATRIX2X3FVPROC glad_glUniformMatrix2x3fv;
+PFNGLFRAMEBUFFERTEXTURE1DPROC glad_glFramebufferTexture1D;
+PFNGLVERTEXATTRIBI2IVPROC glad_glVertexAttribI2iv;
+PFNGLUNIFORM4UIPROC glad_glUniform4ui;
+PFNGLVERTEXATTRIB4NUBPROC glad_glVertexAttrib4Nub;
+PFNGLDELETERENDERBUFFERSPROC glad_glDeleteRenderbuffers;
+PFNGLDISABLEVERTEXATTRIBARRAYPROC glad_glDisableVertexAttribArray;
+PFNGLVERTEXATTRIB4NSVPROC glad_glVertexAttrib4Nsv;
+PFNGLPOLYGONOFFSETPROC glad_glPolygonOffset;
+PFNGLGETSTRINGIPROC glad_glGetStringi;
+PFNGLGETSHADERINFOLOGPROC glad_glGetShaderInfoLog;
+PFNGLVERTEXATTRIB4DPROC glad_glVertexAttrib4d;
+PFNGLSTENCILFUNCPROC glad_glStencilFunc;
+PFNGLFENCESYNCPROC glad_glFenceSync;
+PFNGLTEXIMAGE2DPROC glad_glTexImage2D;
+PFNGLPOLYGONMODEPROC glad_glPolygonMode;
 PFNGLDRAWRANGEELEMENTSPROC glad_glDrawRangeElements;
-PFNGLCOLORMASKIPROC glad_glColorMaski;
-PFNGLCOPYTEXIMAGE1DPROC glad_glCopyTexImage1D;
-PFNGLPOINTPARAMETERFPROC glad_glPointParameterf;
-PFNGLTEXIMAGE1DPROC glad_glTexImage1D;
-PFNGLBLITFRAMEBUFFERPROC glad_glBlitFramebuffer;
-PFNGLBINDBUFFERBASEPROC glad_glBindBufferBase;
-PFNGLDELETESHADERPROC glad_glDeleteShader;
-PFNGLCLIENTWAITSYNCPROC glad_glClientWaitSync;
-PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC glad_glCompressedTexSubImage2D;
-PFNGLCOPYTEXSUBIMAGE3DPROC glad_glCopyTexSubImage3D;
-PFNGLTEXSUBIMAGE2DPROC glad_glTexSubImage2D;
-PFNGLUNIFORM3IVPROC glad_glUniform3iv;
-PFNGLVERTEXATTRIB4IVPROC glad_glVertexAttrib4iv;
-PFNGLISFRAMEBUFFERPROC glad_glIsFramebuffer;
+PFNGLVERTEXATTRIB2SPROC glad_glVertexAttrib2s;
+PFNGLPOINTPARAMETERFVPROC glad_glPointParameterfv;
+PFNGLCLEARSTENCILPROC glad_glClearStencil;
+PFNGLUNIFORMMATRIX4X2FVPROC glad_glUniformMatrix4x2fv;
+PFNGLGETVERTEXATTRIBPOINTERVPROC glad_glGetVertexAttribPointerv;
 PFNGLTRANSFORMFEEDBACKVARYINGSPROC glad_glTransformFeedbackVaryings;
+PFNGLGETUNIFORMUIVPROC glad_glGetUniformuiv;
+PFNGLUNIFORM4UIVPROC glad_glUniform4uiv;
+PFNGLUNIFORMMATRIX2FVPROC glad_glUniformMatrix2fv;
+PFNGLDELETESYNCPROC glad_glDeleteSync;
+PFNGLGETSYNCIVPROC glad_glGetSynciv;
+PFNGLFLUSHPROC glad_glFlush;
+PFNGLVERTEXATTRIB4SVPROC glad_glVertexAttrib4sv;
+PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC glad_glGetActiveUniformBlockName;
+PFNGLCOMPRESSEDTEXIMAGE3DPROC glad_glCompressedTexImage3D;
+PFNGLVIEWPORTPROC glad_glViewport;
+PFNGLCOPYBUFFERSUBDATAPROC glad_glCopyBufferSubData;
+PFNGLSAMPLEMASKIPROC glad_glSampleMaski;
+PFNGLUNIFORM3FVPROC glad_glUniform3fv;
+PFNGLBLENDFUNCPROC glad_glBlendFunc;
+PFNGLPOINTPARAMETERFPROC glad_glPointParameterf;
+PFNGLGETQUERYIVPROC glad_glGetQueryiv;
+PFNGLISQUERYPROC glad_glIsQuery;
+PFNGLUNIFORM3IPROC glad_glUniform3i;
+PFNGLVERTEXATTRIBI4UIVPROC glad_glVertexAttribI4uiv;
+PFNGLGETUNIFORMLOCATIONPROC glad_glGetUniformLocation;
+PFNGLUNIFORM2UIVPROC glad_glUniform2uiv;
+PFNGLGETSTRINGPROC glad_glGetString;
+PFNGLBUFFERSUBDATAPROC glad_glBufferSubData;
+PFNGLGETSHADERIVPROC glad_glGetShaderiv;
+PFNGLCOLORMASKPROC glad_glColorMask;
+PFNGLVERTEXATTRIB2SVPROC glad_glVertexAttrib2sv;
+PFNGLGETBUFFERPOINTERVPROC glad_glGetBufferPointerv;
+PFNGLUNIFORMBLOCKBINDINGPROC glad_glUniformBlockBinding;
+PFNGLPOINTSIZEPROC glad_glPointSize;
+PFNGLVERTEXATTRIBPOINTERPROC glad_glVertexAttribPointer;
+PFNGLGETBOOLEANI_VPROC glad_glGetBooleani_v;
 PFNGLGETTEXLEVELPARAMETERFVPROC glad_glGetTexLevelParameterfv;
 PFNGLUNIFORM3FPROC glad_glUniform3f;
-PFNGLGETACTIVEUNIFORMBLOCKIVPROC glad_glGetActiveUniformBlockiv;
-PFNGLGETUNIFORMUIVPROC glad_glGetUniformuiv;
-PFNGLGETMULTISAMPLEFVPROC glad_glGetMultisamplefv;
-PFNGLVERTEXATTRIB4DPROC glad_glVertexAttrib4d;
-PFNGLDRAWBUFFERPROC glad_glDrawBuffer;
-PFNGLPOLYGONMODEPROC glad_glPolygonMode;
-PFNGLVERTEXATTRIB2DVPROC glad_glVertexAttrib2dv;
-PFNGLUNIFORMMATRIX2FVPROC glad_glUniformMatrix2fv;
-PFNGLSTENCILMASKPROC glad_glStencilMask;
-PFNGLUNIFORMMATRIX4X3FVPROC glad_glUniformMatrix4x3fv;
-PFNGLENABLEPROC glad_glEnable;
-PFNGLUNIFORM2UIVPROC glad_glUniform2uiv;
-PFNGLTEXBUFFERPROC glad_glTexBuffer;
-PFNGLGETINTEGER64I_VPROC glad_glGetInteger64i_v;
-PFNGLGETTEXLEVELPARAMETERIVPROC glad_glGetTexLevelParameteriv;
-PFNGLLINKPROGRAMPROC glad_glLinkProgram;
-PFNGLDETACHSHADERPROC glad_glDetachShader;
-PFNGLCREATESHADERPROC glad_glCreateShader;
-PFNGLMULTIDRAWARRAYSPROC glad_glMultiDrawArrays;
-PFNGLISPROGRAMPROC glad_glIsProgram;
-PFNGLTEXIMAGE2DPROC glad_glTexImage2D;
-PFNGLSTENCILOPSEPARATEPROC glad_glStencilOpSeparate;
-PFNGLFENCESYNCPROC glad_glFenceSync;
-PFNGLUNIFORM2FVPROC glad_glUniform2fv;
-PFNGLCOMPRESSEDTEXIMAGE1DPROC glad_glCompressedTexImage1D;
-PFNGLGETBUFFERPOINTERVPROC glad_glGetBufferPointerv;
-PFNGLGETQUERYIVPROC glad_glGetQueryiv;
-PFNGLVERTEXATTRIBI3UIPROC glad_glVertexAttribI3ui;
-PFNGLVERTEXATTRIBI4SVPROC glad_glVertexAttribI4sv;
-PFNGLPIXELSTOREFPROC glad_glPixelStoref;
-PFNGLVIEWPORTPROC glad_glViewport;
-PFNGLUSEPROGRAMPROC glad_glUseProgram;
-PFNGLBUFFERSUBDATAPROC glad_glBufferSubData;
-PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC glad_glDrawElementsInstancedBaseVertex;
-PFNGLDELETESYNCPROC glad_glDeleteSync;
-PFNGLGETVERTEXATTRIBIVPROC glad_glGetVertexAttribiv;
-PFNGLVERTEXATTRIB1SVPROC glad_glVertexAttrib1sv;
-PFNGLREADBUFFERPROC glad_glReadBuffer;
-PFNGLUNIFORM3UIVPROC glad_glUniform3uiv;
-PFNGLUNIFORM4IPROC glad_glUniform4i;
-PFNGLGETFRAGDATALOCATIONPROC glad_glGetFragDataLocation;
-PFNGLDELETEVERTEXARRAYSPROC glad_glDeleteVertexArrays;
-PFNGLFLUSHPROC glad_glFlush;
-PFNGLGETERRORPROC glad_glGetError;
-PFNGLISTEXTUREPROC glad_glIsTexture;
-PFNGLBINDBUFFERRANGEPROC glad_glBindBufferRange;
-PFNGLFRAMEBUFFERTEXTURE1DPROC glad_glFramebufferTexture1D;
-PFNGLVERTEXATTRIB1DPROC glad_glVertexAttrib1d;
-PFNGLENDCONDITIONALRENDERPROC glad_glEndConditionalRender;
-PFNGLBINDFRAMEBUFFERPROC glad_glBindFramebuffer;
-PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC glad_glRenderbufferStorageMultisample;
-PFNGLVERTEXATTRIBI4UIVPROC glad_glVertexAttribI4uiv;
-PFNGLFRAMEBUFFERTEXTURE2DPROC glad_glFramebufferTexture2D;
-PFNGLGETATTACHEDSHADERSPROC glad_glGetAttachedShaders;
-PFNGLVERTEXATTRIB2SPROC glad_glVertexAttrib2s;
-PFNGLISSHADERPROC glad_glIsShader;
-PFNGLVERTEXATTRIB4NUIVPROC glad_glVertexAttrib4Nuiv;
-PFNGLPOINTPARAMETERFVPROC glad_glPointParameterfv;
-PFNGLVERTEXATTRIB4NUSVPROC glad_glVertexAttrib4Nusv;
-PFNGLVERTEXATTRIB4UIVPROC glad_glVertexAttrib4uiv;
-PFNGLCLAMPCOLORPROC glad_glClampColor;
-PFNGLUNIFORM2UIPROC glad_glUniform2ui;
-PFNGLFRAMEBUFFERTEXTURE3DPROC glad_glFramebufferTexture3D;
-PFNGLGETBUFFERPARAMETERI64VPROC glad_glGetBufferParameteri64v;
-PFNGLUNIFORMBLOCKBINDINGPROC glad_glUniformBlockBinding;
-PFNGLVERTEXATTRIBI1IPROC glad_glVertexAttribI1i;
-PFNGLCLEARBUFFERFVPROC glad_glClearBufferfv;
-PFNGLCLEARSTENCILPROC glad_glClearStencil;
-PFNGLTEXIMAGE3DMULTISAMPLEPROC glad_glTexImage3DMultisample;
-PFNGLFINISHPROC glad_glFinish;
-PFNGLCOMPILESHADERPROC glad_glCompileShader;
-PFNGLGENTEXTURESPROC glad_glGenTextures;
-PFNGLGETSHADERIVPROC glad_glGetShaderiv;
-PFNGLDELETEFRAMEBUFFERSPROC glad_glDeleteFramebuffers;
-PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC glad_glDrawRangeElementsBaseVertex;
-PFNGLVERTEXATTRIBPOINTERPROC glad_glVertexAttribPointer;
-PFNGLUNIFORMMATRIX4X2FVPROC glad_glUniformMatrix4x2fv;
-PFNGLLINEWIDTHPROC glad_glLineWidth;
-PFNGLBINDFRAGDATALOCATIONPROC glad_glBindFragDataLocation;
-PFNGLVERTEXATTRIB3SPROC glad_glVertexAttrib3s;
-PFNGLGETBOOLEANVPROC glad_glGetBooleanv;
-PFNGLBINDBUFFERPROC glad_glBindBuffer;
-PFNGLTEXIMAGE3DPROC glad_glTexImage3D;
-PFNGLSAMPLEMASKIPROC glad_glSampleMaski;
-PFNGLGETVERTEXATTRIBFVPROC glad_glGetVertexAttribfv;
-PFNGLGETACTIVEATTRIBPROC glad_glGetActiveAttrib;
-PFNGLDRAWARRAYSINSTANCEDPROC glad_glDrawArraysInstanced;
-PFNGLTEXPARAMETERIPROC glad_glTexParameteri;
-PFNGLSCISSORPROC glad_glScissor;
-PFNGLGETDOUBLEVPROC glad_glGetDoublev;
-PFNGLBLENDEQUATIONPROC glad_glBlendEquation;
-PFNGLGETPROGRAMINFOLOGPROC glad_glGetProgramInfoLog;
-PFNGLUNIFORM2IPROC glad_glUniform2i;
-PFNGLGENRENDERBUFFERSPROC glad_glGenRenderbuffers;
-PFNGLCLEARCOLORPROC glad_glClearColor;
-PFNGLVERTEXATTRIBI4IPROC glad_glVertexAttribI4i;
-PFNGLSTENCILMASKSEPARATEPROC glad_glStencilMaskSeparate;
-PFNGLMULTIDRAWELEMENTSPROC glad_glMultiDrawElements;
-PFNGLVERTEXATTRIB3FPROC glad_glVertexAttrib3f;
-PFNGLVERTEXATTRIB2SVPROC glad_glVertexAttrib2sv;
-PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC glad_glGetFramebufferAttachmentParameteriv;
-PFNGLVERTEXATTRIBI4IVPROC glad_glVertexAttribI4iv;
-PFNGLPOINTPARAMETERIPROC glad_glPointParameteri;
-PFNGLGETTEXPARAMETERIVPROC glad_glGetTexParameteriv;
-PFNGLDELETEQUERIESPROC glad_glDeleteQueries;
-PFNGLUNIFORM3UIPROC glad_glUniform3ui;
-PFNGLGETSTRINGPROC glad_glGetString;
-PFNGLGETUNIFORMLOCATIONPROC glad_glGetUniformLocation;
-PFNGLGETACTIVEUNIFORMNAMEPROC glad_glGetActiveUniformName;
-PFNGLBLENDFUNCPROC glad_glBlendFunc;
-PFNGLCOPYTEXSUBIMAGE2DPROC glad_glCopyTexSubImage2D;
-PFNGLDRAWBUFFERSPROC glad_glDrawBuffers;
-PFNGLGETVERTEXATTRIBDVPROC glad_glGetVertexAttribdv;
-PFNGLUNIFORM2IVPROC glad_glUniform2iv;
-PFNGLGETUNIFORMIVPROC glad_glGetUniformiv;
-PFNGLUNMAPBUFFERPROC glad_glUnmapBuffer;
-PFNGLGETTEXPARAMETERIIVPROC glad_glGetTexParameterIiv;
-PFNGLVERTEXATTRIB4NUBPROC glad_glVertexAttrib4Nub;
-PFNGLGETTEXPARAMETERIUIVPROC glad_glGetTexParameterIuiv;
-PFNGLGETBOOLEANI_VPROC glad_glGetBooleani_v;
-PFNGLATTACHSHADERPROC glad_glAttachShader;
-PFNGLGETCOMPRESSEDTEXIMAGEPROC glad_glGetCompressedTexImage;
-PFNGLVERTEXATTRIB1SPROC glad_glVertexAttrib1s;
-PFNGLFRAMEBUFFERTEXTURELAYERPROC glad_glFramebufferTextureLayer;
-PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC glad_glMultiDrawElementsBaseVertex;
-PFNGLVERTEXATTRIB4SPROC glad_glVertexAttrib4s;
-PFNGLVERTEXATTRIBIPOINTERPROC glad_glVertexAttribIPointer;
-PFNGLCHECKFRAMEBUFFERSTATUSPROC glad_glCheckFramebufferStatus;
-PFNGLVERTEXATTRIB4FPROC glad_glVertexAttrib4f;
-PFNGLDEPTHMASKPROC glad_glDepthMask;
-PFNGLUNIFORMMATRIX3X4FVPROC glad_glUniformMatrix3x4fv;
-PFNGLDELETERENDERBUFFERSPROC glad_glDeleteRenderbuffers;
-PFNGLVERTEXATTRIBI4USVPROC glad_glVertexAttribI4usv;
-PFNGLVERTEXATTRIBI2IPROC glad_glVertexAttribI2i;
-PFNGLVERTEXATTRIBI2UIVPROC glad_glVertexAttribI2uiv;
-PFNGLHINTPROC glad_glHint;
-PFNGLGETRENDERBUFFERPARAMETERIVPROC glad_glGetRenderbufferParameteriv;
-PFNGLUNIFORMMATRIX3X2FVPROC glad_glUniformMatrix3x2fv;
-PFNGLREADPIXELSPROC glad_glReadPixels;
-PFNGLENDQUERYPROC glad_glEndQuery;
-PFNGLUNIFORM4FPROC glad_glUniform4f;
-PFNGLENDTRANSFORMFEEDBACKPROC glad_glEndTransformFeedback;
-PFNGLGETSHADERSOURCEPROC glad_glGetShaderSource;
-PFNGLBEGINCONDITIONALRENDERPROC glad_glBeginConditionalRender;
-PFNGLPRIMITIVERESTARTINDEXPROC glad_glPrimitiveRestartIndex;
-PFNGLTEXSUBIMAGE3DPROC glad_glTexSubImage3D;
-PFNGLFRAMEBUFFERRENDERBUFFERPROC glad_glFramebufferRenderbuffer;
-PFNGLGETUNIFORMBLOCKINDEXPROC glad_glGetUniformBlockIndex;
-PFNGLCLEARDEPTHPROC glad_glClearDepth;
-PFNGLGETQUERYOBJECTIVPROC glad_glGetQueryObjectiv;
-PFNGLGETTEXPARAMETERFVPROC glad_glGetTexParameterfv;
-PFNGLISRENDERBUFFERPROC glad_glIsRenderbuffer;
-PFNGLVALIDATEPROGRAMPROC glad_glValidateProgram;
-PFNGLBUFFERDATAPROC glad_glBufferData;
-PFNGLVERTEXATTRIB3DPROC glad_glVertexAttrib3d;
-PFNGLGETSYNCIVPROC glad_glGetSynciv;
-PFNGLUNIFORMMATRIX4FVPROC glad_glUniformMatrix4fv;
-PFNGLCOLORMASKPROC glad_glColorMask;
-PFNGLACTIVETEXTUREPROC glad_glActiveTexture;
-PFNGLVERTEXATTRIBI2IVPROC glad_glVertexAttribI2iv;
-PFNGLVERTEXATTRIB3DVPROC glad_glVertexAttrib3dv;
-PFNGLGETUNIFORMFVPROC glad_glGetUniformfv;
-PFNGLVERTEXATTRIB4FVPROC glad_glVertexAttrib4fv;
-PFNGLGENVERTEXARRAYSPROC glad_glGenVertexArrays;
-int GLAD_GL_ARB_texture_storage;
-int GLAD_GL_ARB_timer_query;
-int GLAD_GL_KHR_debug;
 int GLAD_GL_ARB_debug_output;
-int GLAD_GL_EXT_texture_filter_anisotropic;
-int GLAD_GL_ARB_gpu_shader5;
+int GLAD_GL_ARB_bindless_texture;
 int GLAD_GL_EXT_texture_compression_s3tc;
-int GLAD_GL_ARB_vertex_attrib_binding;
+int GLAD_GL_KHR_debug;
 int GLAD_GL_ARB_get_program_binary;
+int GLAD_GL_ARB_vertex_attrib_binding;
 int GLAD_GL_ARB_draw_buffers_blend;
+int GLAD_GL_ARB_timer_query;
+int GLAD_GL_ARB_texture_storage;
 int GLAD_GL_ARB_shader_texture_lod;
+int GLAD_GL_ARB_gpu_shader5;
+int GLAD_GL_EXT_texture_filter_anisotropic;
+PFNGLGETTEXTUREHANDLEARBPROC glad_glGetTextureHandleARB;
+PFNGLGETTEXTURESAMPLERHANDLEARBPROC glad_glGetTextureSamplerHandleARB;
+PFNGLMAKETEXTUREHANDLERESIDENTARBPROC glad_glMakeTextureHandleResidentARB;
+PFNGLMAKETEXTUREHANDLENONRESIDENTARBPROC glad_glMakeTextureHandleNonResidentARB;
+PFNGLGETIMAGEHANDLEARBPROC glad_glGetImageHandleARB;
+PFNGLMAKEIMAGEHANDLERESIDENTARBPROC glad_glMakeImageHandleResidentARB;
+PFNGLMAKEIMAGEHANDLENONRESIDENTARBPROC glad_glMakeImageHandleNonResidentARB;
+PFNGLUNIFORMHANDLEUI64ARBPROC glad_glUniformHandleui64ARB;
+PFNGLUNIFORMHANDLEUI64VARBPROC glad_glUniformHandleui64vARB;
+PFNGLPROGRAMUNIFORMHANDLEUI64ARBPROC glad_glProgramUniformHandleui64ARB;
+PFNGLPROGRAMUNIFORMHANDLEUI64VARBPROC glad_glProgramUniformHandleui64vARB;
+PFNGLISTEXTUREHANDLERESIDENTARBPROC glad_glIsTextureHandleResidentARB;
+PFNGLISIMAGEHANDLERESIDENTARBPROC glad_glIsImageHandleResidentARB;
+PFNGLVERTEXATTRIBL1UI64ARBPROC glad_glVertexAttribL1ui64ARB;
+PFNGLVERTEXATTRIBL1UI64VARBPROC glad_glVertexAttribL1ui64vARB;
+PFNGLGETVERTEXATTRIBLUI64VARBPROC glad_glGetVertexAttribLui64vARB;
 PFNGLDEBUGMESSAGECONTROLARBPROC glad_glDebugMessageControlARB;
 PFNGLDEBUGMESSAGEINSERTARBPROC glad_glDebugMessageInsertARB;
 PFNGLDEBUGMESSAGECALLBACKARBPROC glad_glDebugMessageCallbackARB;
@@ -871,6 +889,25 @@ static void load_GL_VERSION_3_2(GLADloadproc load) {
 	glad_glGetMultisamplefv = (PFNGLGETMULTISAMPLEFVPROC)load("glGetMultisamplefv");
 	glad_glSampleMaski = (PFNGLSAMPLEMASKIPROC)load("glSampleMaski");
 }
+static void load_GL_ARB_bindless_texture(GLADloadproc load) {
+	if(!GLAD_GL_ARB_bindless_texture) return;
+	glad_glGetTextureHandleARB = (PFNGLGETTEXTUREHANDLEARBPROC)load("glGetTextureHandleARB");
+	glad_glGetTextureSamplerHandleARB = (PFNGLGETTEXTURESAMPLERHANDLEARBPROC)load("glGetTextureSamplerHandleARB");
+	glad_glMakeTextureHandleResidentARB = (PFNGLMAKETEXTUREHANDLERESIDENTARBPROC)load("glMakeTextureHandleResidentARB");
+	glad_glMakeTextureHandleNonResidentARB = (PFNGLMAKETEXTUREHANDLENONRESIDENTARBPROC)load("glMakeTextureHandleNonResidentARB");
+	glad_glGetImageHandleARB = (PFNGLGETIMAGEHANDLEARBPROC)load("glGetImageHandleARB");
+	glad_glMakeImageHandleResidentARB = (PFNGLMAKEIMAGEHANDLERESIDENTARBPROC)load("glMakeImageHandleResidentARB");
+	glad_glMakeImageHandleNonResidentARB = (PFNGLMAKEIMAGEHANDLENONRESIDENTARBPROC)load("glMakeImageHandleNonResidentARB");
+	glad_glUniformHandleui64ARB = (PFNGLUNIFORMHANDLEUI64ARBPROC)load("glUniformHandleui64ARB");
+	glad_glUniformHandleui64vARB = (PFNGLUNIFORMHANDLEUI64VARBPROC)load("glUniformHandleui64vARB");
+	glad_glProgramUniformHandleui64ARB = (PFNGLPROGRAMUNIFORMHANDLEUI64ARBPROC)load("glProgramUniformHandleui64ARB");
+	glad_glProgramUniformHandleui64vARB = (PFNGLPROGRAMUNIFORMHANDLEUI64VARBPROC)load("glProgramUniformHandleui64vARB");
+	glad_glIsTextureHandleResidentARB = (PFNGLISTEXTUREHANDLERESIDENTARBPROC)load("glIsTextureHandleResidentARB");
+	glad_glIsImageHandleResidentARB = (PFNGLISIMAGEHANDLERESIDENTARBPROC)load("glIsImageHandleResidentARB");
+	glad_glVertexAttribL1ui64ARB = (PFNGLVERTEXATTRIBL1UI64ARBPROC)load("glVertexAttribL1ui64ARB");
+	glad_glVertexAttribL1ui64vARB = (PFNGLVERTEXATTRIBL1UI64VARBPROC)load("glVertexAttribL1ui64vARB");
+	glad_glGetVertexAttribLui64vARB = (PFNGLGETVERTEXATTRIBLUI64VARBPROC)load("glGetVertexAttribLui64vARB");
+}
 static void load_GL_ARB_debug_output(GLADloadproc load) {
 	if(!GLAD_GL_ARB_debug_output) return;
 	glad_glDebugMessageControlARB = (PFNGLDEBUGMESSAGECONTROLARBPROC)load("glDebugMessageControlARB");
@@ -939,6 +976,7 @@ static void load_GL_KHR_debug(GLADloadproc load) {
 }
 static int find_extensionsGL(void) {
 	if (!get_exts()) return 0;
+	GLAD_GL_ARB_bindless_texture = has_ext("GL_ARB_bindless_texture");
 	GLAD_GL_ARB_debug_output = has_ext("GL_ARB_debug_output");
 	GLAD_GL_ARB_draw_buffers_blend = has_ext("GL_ARB_draw_buffers_blend");
 	GLAD_GL_ARB_get_program_binary = has_ext("GL_ARB_get_program_binary");
@@ -1026,6 +1064,7 @@ int gladLoadGLLoader(GLADloadproc load) {
 	load_GL_VERSION_3_2(load);
 
 	if (!find_extensionsGL()) return 0;
+	load_GL_ARB_bindless_texture(load);
 	load_GL_ARB_debug_output(load);
 	load_GL_ARB_draw_buffers_blend(load);
 	load_GL_ARB_get_program_binary(load);

lib/opengl/gl/glad_wgl/include/glad/glad_wgl.h

@@ -1,6 +1,6 @@
 /*
 
-    WGL loader generated by glad 0.1.16a0 on Thu Mar  1 11:53:10 2018.
+    WGL loader generated by glad 0.1.16a0 on Tue Apr  3 09:52:47 2018.
 
     Language/Generator: C/C++
     Specification: wgl

lib/opengl/gl/glad_wgl/src/glad_wgl.c

@@ -1,6 +1,6 @@
 /*
 
-    WGL loader generated by glad 0.1.16a0 on Thu Mar  1 11:53:10 2018.
+    WGL loader generated by glad 0.1.16a0 on Tue Apr  3 09:52:47 2018.
 
     Language/Generator: C/C++
     Specification: wgl
@@ -70,11 +70,11 @@ static int has_ext(const char *ext) {
     return 0;
 }
 int GLAD_WGL_VERSION_1_0;
+int GLAD_WGL_ARB_create_context;
 int GLAD_WGL_ARB_extensions_string;
 int GLAD_WGL_EXT_extensions_string;
-int GLAD_WGL_EXT_swap_control;
-int GLAD_WGL_ARB_create_context;
 int GLAD_WGL_ARB_create_context_profile;
+int GLAD_WGL_EXT_swap_control;
 PFNWGLCREATECONTEXTATTRIBSARBPROC glad_wglCreateContextAttribsARB;
 PFNWGLGETEXTENSIONSSTRINGARBPROC glad_wglGetExtensionsStringARB;
 PFNWGLGETEXTENSIONSSTRINGEXTPROC glad_wglGetExtensionsStringEXT;