support mipmaps and anisotropy (not used until we have premultiplied alpha)

2018-07-10 12:14:29 +03:00 · 2018-07-10 12:14:29 +03:00 · c57d1130aa
commit c57d1130aa
parent b4a6f5dfb4
24 changed files with 972 additions and 590 deletions
--- a/resources/shader/texture_post_load.frag.glsl
+++ b/resources/shader/texture_post_load.frag.glsl
@ -2,28 +2,12 @@

 #include "interface/standard.glslh"

-UNIFORM(1) int width;
-UNIFORM(2) int height;
-
-vec2 tc_normalize(ivec2 tc) {
-	return vec2(tc) / vec2(width, height);
-}
-
-ivec2 tc_denormalize(vec2 tc) {
-	return ivec2(tc * vec2(width, height));
-}
-
 vec4 replace_color(vec4 texel, vec4 neighbour) {
 	return mix(texel, neighbour, float(neighbour.a > texel.a));
 }

-vec4 sampleofs(ivec2 origin, int ofsx, int ofsy) {
-	return texture(tex, tc_normalize(origin + ivec2(ofsx, ofsy)));
-}
-
 void main(void) {
-	ivec2 tc = tc_denormalize(texCoordRaw);
-	vec4 texel = texture(tex, texCoordRaw);
+	vec4 texel = textureLod(tex, texCoordRaw, 0);
 	vec4 new_texel = texel;

 	/*
@ -33,11 +17,11 @@ void main(void) {
 	 *  As a workaround, we change the RGB values of such pixels to those of the most opaque nearby one.
 	 */

-	new_texel = replace_color(new_texel, sampleofs(tc,  0,  1));
-	new_texel = replace_color(new_texel, sampleofs(tc,  1,  0));
-	new_texel = replace_color(new_texel, sampleofs(tc,  0, -1));
-	new_texel = replace_color(new_texel, sampleofs(tc, -1,  0));
-	texel = mix(texel, vec4(new_texel.rgb, texel.a), float(texel.a <= 0.0));
+	new_texel = replace_color(new_texel, textureLodOffset(tex, texCoordRaw, 0, ivec2( 0,  1)));
+	new_texel = replace_color(new_texel, textureLodOffset(tex, texCoordRaw, 0, ivec2( 1,  0)));
+	new_texel = replace_color(new_texel, textureLodOffset(tex, texCoordRaw, 0, ivec2( 0, -1)));
+	new_texel = replace_color(new_texel, textureLodOffset(tex, texCoordRaw, 0, ivec2(-1,  0)));
+	texel = mix(texel, vec4(new_texel.rgb, texel.a), float(texel.a <= 0.5));

 	fragColor = texel;
 }
--- a/src/renderer/api.c
+++ b/src/renderer/api.c
@ -325,22 +325,30 @@ void r_texture_create(Texture *tex, const TextureParams *params) {
 	B.texture_create(tex, params);
 }

-void r_texture_fill(Texture *tex, void *image_data) {
-	B.texture_fill(tex, image_data);
+void r_texture_get_params(Texture *tex, TextureParams *params) {
+	B.texture_get_params(tex, params);
 }

-void r_texture_fill_region(Texture *tex, uint x, uint y, uint w, uint h, void *image_data) {
-	B.texture_fill_region(tex, x, y, w, h, image_data);
+void r_texture_set_filter(Texture *tex, TextureFilterMode fmin, TextureFilterMode fmag) {
+	B.texture_set_filter(tex, fmin, fmag);
+}
+
+void r_texture_set_wrap(Texture *tex, TextureWrapMode ws, TextureWrapMode wt) {
+	B.texture_set_wrap(tex, ws, wt);
+}
+
+void r_texture_fill(Texture *tex, uint mipmap, void *image_data) {
+	B.texture_fill(tex, mipmap, image_data);
+}
+
+void r_texture_fill_region(Texture *tex, uint mipmap, uint x, uint y, uint w, uint h, void *image_data) {
+	B.texture_fill_region(tex, mipmap, x, y, w, h, image_data);
 }

 void r_texture_invalidate(Texture *tex) {
 	B.texture_invalidate(tex);
 }

-void r_texture_replace(Texture *tex, TextureType type, uint w, uint h, void *image_data) {
-	B.texture_replace(tex, type, w, h, image_data);
-}
-
 void r_texture_destroy(Texture *tex) {
 	B.texture_destroy(tex);
 }
@ -358,14 +366,18 @@ void r_framebuffer_create(Framebuffer *fb) {
 	B.framebuffer_create(fb);
 }

-void r_framebuffer_attach(Framebuffer *fb, Texture *tex, FramebufferAttachment attachment) {
-	B.framebuffer_attach(fb, tex, attachment);
+void r_framebuffer_attach(Framebuffer *fb, Texture *tex, uint mipmap, FramebufferAttachment attachment) {
+	B.framebuffer_attach(fb, tex, mipmap, attachment);
 }

 Texture* r_framebuffer_get_attachment(Framebuffer *fb, FramebufferAttachment attachment) {
 	return B.framebuffer_get_attachment(fb, attachment);
 }

+uint r_framebuffer_get_attachment_mipmap(Framebuffer *fb, FramebufferAttachment attachment) {
+	return B.framebuffer_get_attachment_mipmap(fb, attachment);
+}
+
 void r_framebuffer_viewport(Framebuffer *fb, int x, int y, int w, int h) {
 	r_framebuffer_viewport_rect(fb, (IntRect) { x, y, w, h });
 }
--- a/src/renderer/api.h
+++ b/src/renderer/api.h
@ -48,35 +48,47 @@ typedef enum MatrixMode {
 } MatrixMode;

 typedef enum TextureType {
-	TEX_TYPE_DEFAULT,
-	TEX_TYPE_R,
-	TEX_TYPE_RG,
-	TEX_TYPE_RGB,
+	// NOTE: whichever is placed first here is considered the "default" where applicable.
 	TEX_TYPE_RGBA,
+	TEX_TYPE_RGB,
+	TEX_TYPE_RG,
+	TEX_TYPE_R,
 	TEX_TYPE_DEPTH,
 } TextureType;

 typedef enum TextureFilterMode {
-	TEX_FILTER_DEFAULT,
-	TEX_FILTER_NEAREST,
+	// NOTE: whichever is placed first here is considered the "default" where applicable.
 	TEX_FILTER_LINEAR,
+	TEX_FILTER_LINEAR_MIPMAP_NEAREST,
+	TEX_FILTER_LINEAR_MIPMAP_LINEAR,
+	TEX_FILTER_NEAREST,
+	TEX_FILTER_NEAREST_MIPMAP_NEAREST,
+	TEX_FILTER_NEAREST_MIPMAP_LINEAR,
 } TextureFilterMode;

 typedef enum TextureWrapMode {
-	TEX_WRAP_DEFAULT,
+	// NOTE: whichever is placed first here is considered the "default" where applicable.
 	TEX_WRAP_REPEAT,
 	TEX_WRAP_MIRROR,
 	TEX_WRAP_CLAMP,
 } TextureWrapMode;

+typedef enum TextureMipmapMode {
+	TEX_MIPMAP_MANUAL,
+	TEX_MIPMAP_AUTO,
+} TextureMipmapMode;
+
+#define TEX_ANISOTROPY_DEFAULT 1
+#define TEX_MIPMAPS_MAX ((uint)(-1))
+
 typedef struct TextureParams {
 	uint width;
 	uint height;
 	TextureType type;

 	struct {
-		TextureFilterMode upscale;
-		TextureFilterMode downscale;
+		TextureFilterMode mag;
+		TextureFilterMode min;
 	} filter;

 	struct {
@ -84,8 +96,9 @@ typedef struct TextureParams {
 		TextureWrapMode t;
 	} wrap;

+	int anisotropy;
 	uint mipmaps;
-	uint8_t *image_data;
+	TextureMipmapMode mipmap_mode;
 	bool stream;
 } attr_designated_init TextureParams;

@ -404,18 +417,21 @@ UniformType r_uniform_type(Uniform *uniform);
 void r_draw(Primitive prim, uint first, uint count, uint32_t *indices, uint instances, uint base_instance);

 void r_texture_create(Texture *tex, const TextureParams *params) attr_nonnull(1, 2);
-void r_texture_fill(Texture *tex, void *image_data) attr_nonnull(1, 2);
-void r_texture_fill_region(Texture *tex, uint x, uint y, uint w, uint h, void *image_data) attr_nonnull(1, 6);
+void r_texture_get_params(Texture *tex, TextureParams *params) attr_nonnull(1, 2);
+void r_texture_set_filter(Texture *tex, TextureFilterMode fmin, TextureFilterMode fmag) attr_nonnull(1);
+void r_texture_set_wrap(Texture *tex, TextureWrapMode ws, TextureWrapMode wt) attr_nonnull(1);
+void r_texture_fill(Texture *tex, uint mipmap, void *image_data) attr_nonnull(1, 3);
+void r_texture_fill_region(Texture *tex, uint mipmap, uint x, uint y, uint w, uint h, void *image_data) attr_nonnull(1, 7);
 void r_texture_invalidate(Texture *tex) attr_nonnull(1);
-void r_texture_replace(Texture *tex, TextureType type, uint w, uint h, void *image_data) attr_nonnull(1);
 void r_texture_destroy(Texture *tex) attr_nonnull(1);

 void r_texture_ptr(uint unit, Texture *tex);
 Texture* r_texture_current(uint unit);

 void r_framebuffer_create(Framebuffer *fb) attr_nonnull(1);
-void r_framebuffer_attach(Framebuffer *fb, Texture *tex, FramebufferAttachment attachment) attr_nonnull(1);
+void r_framebuffer_attach(Framebuffer *fb, Texture *tex, uint mipmap, FramebufferAttachment attachment) attr_nonnull(1);
 Texture* r_framebuffer_get_attachment(Framebuffer *fb, FramebufferAttachment attachment) attr_nonnull(1);
+uint r_framebuffer_get_attachment_mipmap(Framebuffer *fb, FramebufferAttachment attachment) attr_nonnull(1);
 void r_framebuffer_viewport(Framebuffer *fb, int x, int y, int w, int h);
 void r_framebuffer_viewport_rect(Framebuffer *fb, IntRect viewport);
 void r_framebuffer_viewport_current(Framebuffer *fb, IntRect *viewport) attr_nonnull(2);
--- a/src/renderer/common/backend.h
+++ b/src/renderer/common/backend.h
@ -46,21 +46,24 @@ typedef struct RendererFuncs {
 	UniformType (*uniform_type)(Uniform *uniform);

 	void (*texture_create)(Texture *tex, const TextureParams *params);
+	void (*texture_get_params)(Texture *tex, TextureParams *params);
+	void (*texture_set_filter)(Texture *tex, TextureFilterMode fmin, TextureFilterMode fmag);
+	void (*texture_set_wrap)(Texture *tex, TextureWrapMode ws, TextureWrapMode wt);
 	void (*texture_destroy)(Texture *tex);
 	void (*texture_invalidate)(Texture *tex);
-	void (*texture_fill)(Texture *tex, void *image_data);
-	void (*texture_fill_region)(Texture *tex, uint x, uint y, uint w, uint h, void *image_data);
-	void (*texture_replace)(Texture *tex, TextureType type, uint w, uint h, void *image_data);
+	void (*texture_fill)(Texture *tex, uint mipmap, void *image_data);
+	void (*texture_fill_region)(Texture *tex, uint mipmap, uint x, uint y, uint w, uint h, void *image_data);

 	void (*texture)(uint unit, Texture *tex);
 	Texture* (*texture_current)(uint unit);

 	void (*framebuffer_create)(Framebuffer *framebuffer);
 	void (*framebuffer_destroy)(Framebuffer *framebuffer);
-	void (*framebuffer_attach)(Framebuffer *framebuffer, Texture *tex, FramebufferAttachment attachment);
+	void (*framebuffer_attach)(Framebuffer *framebuffer, Texture *tex, uint mipmap, FramebufferAttachment attachment);
 	void (*framebuffer_viewport)(Framebuffer *framebuffer, IntRect vp);
 	void (*framebuffer_viewport_current)(Framebuffer *framebuffer, IntRect *vp);
 	Texture* (*framebuffer_get_attachment)(Framebuffer *framebuffer, FramebufferAttachment attachment);
+	uint (*framebuffer_get_attachment_mipmap)(Framebuffer *framebuffer, FramebufferAttachment attachment);

 	void (*framebuffer)(Framebuffer *framebuffer);
 	Framebuffer* (*framebuffer_current)(void);
--- a/src/renderer/gl33/core.c
+++ b/src/renderer/gl33/core.c
@ -278,7 +278,6 @@ static void gl33_sync_viewport(void) {
 }

 static void gl33_sync_state(void) {
-
 	gl33_sync_capabilities();
 	gl33_sync_shader();
 	r_uniform("r_modelViewMatrix", 1, _r_matrices.modelview.head);
@ -286,7 +285,7 @@ static void gl33_sync_state(void) {
 	r_uniform("r_textureMatrix", 1, _r_matrices.texture.head);
 	r_uniform("r_color", 1, R.color);
 	gl33_sync_uniforms(R.progs.active);
-	gl33_sync_texunits();
+	gl33_sync_texunits(true);
 	gl33_sync_framebuffer();
 	gl33_sync_viewport();
 	gl33_sync_vertex_array();
@ -323,7 +322,7 @@ void gl33_sync_capabilities(void) {
 	R.capabilities.active = R.capabilities.pending;
 }

-void gl33_sync_texunit(uint unit) {
+void gl33_sync_texunit(uint unit, bool prepare_rendering) {
 	TextureUnit *u = R.texunits.indexed + unit;
 	Texture *tex = u->tex2d.pending;

@ -340,11 +339,15 @@ void gl33_sync_texunit(uint unit) {
 		u->tex2d.gl_handle = tex->impl->gl_handle;
 		u->tex2d.active = tex;
 	}
+
+	if(prepare_rendering && u->tex2d.active != NULL) {
+		gl33_texture_prepare(u->tex2d.active);
+	}
 }

-void gl33_sync_texunits(void) {
+void gl33_sync_texunits(bool prepare_rendering) {
 	for(uint i = 0; i < R_MAX_TEXUNITS; ++i) {
-		gl33_sync_texunit(i);
+		gl33_sync_texunit(i, prepare_rendering);
 	}
 }

@ -416,7 +419,7 @@ void gl33_sync_framebuffer(void) {
 	}

 	if(R.framebuffer.active) {
-		gl33_framebuffer_initialize(R.framebuffer.active);
+		gl33_framebuffer_prepare(R.framebuffer.active);
 	}
 }

@ -880,17 +883,20 @@ RendererBackend _r_backend_gl33 = {
 		.uniform = gl33_uniform,
 		.uniform_type = gl33_uniform_type,
 		.texture_create = gl33_texture_create,
+		.texture_get_params = gl33_texture_get_params,
+		.texture_set_filter = gl33_texture_set_filter,
+		.texture_set_wrap = gl33_texture_set_wrap,
 		.texture_destroy = gl33_texture_destroy,
 		.texture_invalidate = gl33_texture_invalidate,
 		.texture_fill = gl33_texture_fill,
 		.texture_fill_region = gl33_texture_fill_region,
-		.texture_replace = gl33_texture_replace,
 		.texture = gl33_texture,
 		.texture_current = gl33_texture_current,
 		.framebuffer_create = gl33_framebuffer_create,
 		.framebuffer_destroy = gl33_framebuffer_destroy,
 		.framebuffer_attach = gl33_framebuffer_attach,
 		.framebuffer_get_attachment = gl33_framebuffer_get_attachment,
+		.framebuffer_get_attachment_mipmap = gl33_framebuffer_get_attachment_mipmap,
 		.framebuffer_viewport = gl33_framebuffer_viewport,
 		.framebuffer_viewport_current = gl33_framebuffer_viewport_current,
 		.framebuffer = gl33_framebuffer,
--- a/src/renderer/gl33/core.h
+++ b/src/renderer/gl33/core.h
@ -24,8 +24,8 @@ void gl33_bind_vao(GLuint vao);
 void gl33_bind_vbo(GLuint vbo);

 void gl33_sync_shader(void);
-void gl33_sync_texunit(uint unit);
-void gl33_sync_texunits(void);
+void gl33_sync_texunit(uint unit, bool prepare_rendering);
+void gl33_sync_texunits(bool prepare_rendering);
 void gl33_sync_framebuffer(void);
 void gl33_sync_vertex_array(void);
 void gl33_sync_blend_mode(void);
--- a/src/renderer/gl33/framebuffer.c
+++ b/src/renderer/gl33/framebuffer.c
@ -27,8 +27,9 @@ void gl33_framebuffer_create(Framebuffer *framebuffer) {
 	glGenFramebuffers(1, &framebuffer->impl->gl_fbo);
 }

-void gl33_framebuffer_attach(Framebuffer *framebuffer, Texture *tex, FramebufferAttachment attachment) {
+void gl33_framebuffer_attach(Framebuffer *framebuffer, Texture *tex, uint mipmap, FramebufferAttachment attachment) {
 	assert(attachment >= 0 && attachment < FRAMEBUFFER_MAX_ATTACHMENTS);
+	assert(mipmap < tex->impl->params.mipmaps);

 	GLuint gl_tex = tex ? tex->impl->gl_handle : 0;
 	Framebuffer *prev_fb = r_framebuffer_current();
@ -38,10 +39,11 @@ void gl33_framebuffer_attach(Framebuffer *framebuffer, Texture *tex, Framebuffer

 	r_framebuffer(framebuffer);
 	gl33_sync_framebuffer();
-	glFramebufferTexture2D(GL_FRAMEBUFFER, r_attachment_to_gl_attachment[attachment], GL_TEXTURE_2D, gl_tex, 0);
+	glFramebufferTexture2D(GL_FRAMEBUFFER, r_attachment_to_gl_attachment[attachment], GL_TEXTURE_2D, gl_tex, mipmap);
 	r_framebuffer(prev_fb);

 	framebuffer->impl->attachments[attachment] = tex;
+	framebuffer->impl->attachment_mipmaps[attachment] = mipmap;

 	// need to update draw buffers
 	framebuffer->impl->initialized = false;
@ -61,6 +63,14 @@ Texture* gl33_framebuffer_get_attachment(Framebuffer *framebuffer, FramebufferAt
 	return framebuffer->impl->attachments[attachment];
 }

+
+uint gl33_framebuffer_get_attachment_mipmap(Framebuffer *framebuffer, FramebufferAttachment attachment) {
+	assert(framebuffer->impl != NULL);
+	assert(attachment >= 0 && attachment < FRAMEBUFFER_MAX_ATTACHMENTS);
+
+	return framebuffer->impl->attachment_mipmaps[attachment];
+}
+
 void gl33_framebuffer_destroy(Framebuffer *framebuffer) {
 	if(framebuffer->impl != NULL) {
 		gl33_framebuffer_deleted(framebuffer);
@ -70,7 +80,15 @@ void gl33_framebuffer_destroy(Framebuffer *framebuffer) {
 	}
 }

-void gl33_framebuffer_initialize(Framebuffer *framebuffer) {
+void gl33_framebuffer_taint(Framebuffer *framebuffer) {
+	for(uint i = 0; i < FRAMEBUFFER_MAX_ATTACHMENTS; ++i) {
+		if(framebuffer->impl->attachments[i] != NULL) {
+			gl33_texture_taint(framebuffer->impl->attachments[i]);
+		}
+	}
+}
+
+void gl33_framebuffer_prepare(Framebuffer *framebuffer) {
 	if(!framebuffer->impl->initialized) {
 		// NOTE: this framebuffer is guaranteed to be active at this point

@ -87,13 +105,5 @@ void gl33_framebuffer_initialize(Framebuffer *framebuffer) {

 			glDrawBuffers(FRAMEBUFFER_MAX_COLOR_ATTACHMENTS, drawbufs);
 		}
-
-		Color cc_saved = r_clear_color_current();
-		r_clear_color4(0, 0, 0, 0);
-		// NOTE: r_clear would cause an infinite recursion here
-		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-		r_clear_color(cc_saved);
-
-		framebuffer->impl->initialized = true;
 	}
 }
--- a/src/renderer/gl33/framebuffer.h
+++ b/src/renderer/gl33/framebuffer.h
@ -17,12 +17,14 @@ struct FramebufferImpl {
 	GLuint gl_fbo;
 	bool initialized;
 	Texture *attachments[FRAMEBUFFER_MAX_ATTACHMENTS];
+	uint attachment_mipmaps[FRAMEBUFFER_MAX_ATTACHMENTS];
 	IntRect viewport;
 };

-void gl33_framebuffer_initialize(Framebuffer *framebuffer);
+void gl33_framebuffer_prepare(Framebuffer *framebuffer);

 void gl33_framebuffer_create(Framebuffer *framebuffer);
-void gl33_framebuffer_attach(Framebuffer *framebuffer, Texture *tex, FramebufferAttachment attachment);
+void gl33_framebuffer_attach(Framebuffer *framebuffer, Texture *tex, uint mipmap, FramebufferAttachment attachment);
 Texture *gl33_framebuffer_get_attachment(Framebuffer *framebuffer, FramebufferAttachment attachment);
+uint gl33_framebuffer_get_attachment_mipmap(Framebuffer *framebuffer, FramebufferAttachment attachment);
 void gl33_framebuffer_destroy(Framebuffer *framebuffer);
--- a/src/renderer/gl33/texture.c
+++ b/src/renderer/gl33/texture.c
@ -15,9 +15,12 @@

 static GLuint r_filter_to_gl_filter(TextureFilterMode mode) {
 	static GLuint map[] = {
-		[TEX_FILTER_DEFAULT] = GL_LINEAR,
 		[TEX_FILTER_LINEAR]  = GL_LINEAR,
+		[TEX_FILTER_LINEAR_MIPMAP_NEAREST]  = GL_LINEAR_MIPMAP_NEAREST,
+		[TEX_FILTER_LINEAR_MIPMAP_LINEAR]  = GL_LINEAR_MIPMAP_LINEAR,
 		[TEX_FILTER_NEAREST] = GL_NEAREST,
+		[TEX_FILTER_NEAREST_MIPMAP_NEAREST]  = GL_NEAREST_MIPMAP_NEAREST,
+		[TEX_FILTER_NEAREST_MIPMAP_LINEAR]  = GL_NEAREST_MIPMAP_LINEAR,
 	};

 	assert((uint)mode < sizeof(map)/sizeof(*map));
@ -26,7 +29,6 @@ static GLuint r_filter_to_gl_filter(TextureFilterMode mode) {

 static GLuint r_wrap_to_gl_wrap(TextureWrapMode mode) {
 	static GLuint map[] = {
-		[TEX_WRAP_DEFAULT]   = GL_REPEAT,
 		[TEX_WRAP_CLAMP]     = GL_CLAMP_TO_EDGE,
 		[TEX_WRAP_MIRROR]    = GL_MIRRORED_REPEAT,
 		[TEX_WRAP_REPEAT]    = GL_REPEAT,
@ -38,7 +40,6 @@ static GLuint r_wrap_to_gl_wrap(TextureWrapMode mode) {

 GLTextureTypeInfo* gl33_texture_type_info(TextureType type) {
 	static GLTextureTypeInfo map[] = {
-		[TEX_TYPE_DEFAULT]   = { GL_RGBA8,             GL_RGBA,            GL_UNSIGNED_BYTE,  4 },
 		[TEX_TYPE_R]         = { GL_R8,                GL_RED,             GL_UNSIGNED_BYTE,  1 },
 		[TEX_TYPE_RG]        = { GL_RG8,               GL_RG,              GL_UNSIGNED_BYTE,  2 },
 		[TEX_TYPE_RGB]       = { GL_RGB8,              GL_RGB,             GL_UNSIGNED_BYTE,  3 },
@ -50,8 +51,9 @@ GLTextureTypeInfo* gl33_texture_type_info(TextureType type) {
 	return map + type;
 }

-static void gl33_texture_set_assume_active(Texture *tex, void *image_data) {
+static void gl33_texture_set_assume_active(Texture *tex, uint mipmap, void *image_data) {
 	assert(tex->impl != NULL);
+	assert(mipmap < tex->impl->params.mipmaps);

 	gl33_bind_pbo(tex->impl->pbo);

@ -63,10 +65,10 @@ static void gl33_texture_set_assume_active(Texture *tex, void *image_data) {

 	glTexImage2D(
 		GL_TEXTURE_2D,
-		0,
+		mipmap,
 		tex->impl->type_info->internal_fmt,
-		tex->w,
-		tex->h,
+		max(1, floor(tex->w / pow(2, mipmap))),
+		max(1, floor(tex->h / pow(2, mipmap))),
 		0,
 		tex->impl->type_info->external_fmt,
 		tex->impl->type_info->component_type,
@ -74,16 +76,17 @@ static void gl33_texture_set_assume_active(Texture *tex, void *image_data) {
 	);

 	gl33_bind_pbo(0);
+	tex->impl->mipmaps_outdated = true;
 }

-static void gl33_texture_set(Texture *tex, void *image_data) {
+static void gl33_texture_set(Texture *tex, uint mipmap, void *image_data) {
 	assert(tex->impl != NULL);

 	uint unit = gl33_active_texunit();
 	Texture *prev_tex = r_texture_current(unit);
 	r_texture_ptr(unit, tex);
-	gl33_sync_texunit(unit);
-	gl33_texture_set_assume_active(tex, image_data);
+	gl33_sync_texunit(unit, false);
+	gl33_texture_set_assume_active(tex, mipmap, image_data);
 	r_texture_ptr(unit, prev_tex);
 }

@ -94,67 +97,148 @@ void gl33_texture_create(Texture *tex, const TextureParams *params) {
 	tex->h = params->height;
 	tex->type = params->type;
 	tex->impl = calloc(1, sizeof(TextureImpl));
+	memcpy(&tex->impl->params, params, sizeof(*params));
+	TextureParams *p = &tex->impl->params;
+
+	uint max_mipmaps = 1 + floor(log2(max(tex->w, tex->h)));
+
+	if(p->mipmaps == 0) {
+		if(p->mipmap_mode == TEX_MIPMAP_AUTO) {
+			p->mipmaps = TEX_MIPMAPS_MAX;
+		} else {
+			p->mipmaps = 1;
+		}
+	}
+
+	if(p->mipmaps == TEX_MIPMAPS_MAX || p->mipmaps > max_mipmaps) {
+		p->mipmaps = max_mipmaps;
+	}
+
+	if(p->anisotropy == 0) {
+		p->anisotropy = TEX_ANISOTROPY_DEFAULT;
+	}

 	uint unit = gl33_active_texunit();
 	Texture *prev_tex = r_texture_current(unit);

 	glGenTextures(1, &tex->impl->gl_handle);
 	r_texture_ptr(unit, tex);
-	gl33_sync_texunit(unit);
+	gl33_sync_texunit(unit, false);

-	// TODO: mipmaps
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, r_wrap_to_gl_wrap(p->wrap.s));
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, r_wrap_to_gl_wrap(p->wrap.t));
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, r_filter_to_gl_filter(p->filter.min));
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, r_filter_to_gl_filter(p->filter.mag));
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, p->mipmaps - 1);

-	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, r_wrap_to_gl_wrap(params->wrap.s));
-	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, r_wrap_to_gl_wrap(params->wrap.t));
-	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, r_filter_to_gl_filter(params->filter.downscale));
-	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, r_filter_to_gl_filter(params->filter.upscale));
+	if(glext.texture_filter_anisotropic) {
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY, p->anisotropy);
+	}

-	tex->impl->type_info = GLVT.texture_type_info(params->type);
+	tex->impl->type_info = GLVT.texture_type_info(p->type);

-	if(params->stream && glext.pixel_buffer_object) {
+	if(p->stream && glext.pixel_buffer_object) {
 		glGenBuffers(1, &tex->impl->pbo);
 	}

-	gl33_texture_set_assume_active(tex, params->image_data);
+	uint width = p->width;
+	uint height = p->height;
+
+	for(uint i = 0; i < p->mipmaps; ++i) {
+		assert(width == max(1, floor(tex->w / pow(2, i))));
+		assert(height == max(1, floor(tex->h / pow(2, i))));
+
+		glTexImage2D(
+			GL_TEXTURE_2D,
+			i,
+			tex->impl->type_info->internal_fmt,
+			width,
+			height,
+			0,
+			tex->impl->type_info->external_fmt,
+			tex->impl->type_info->component_type,
+			NULL
+		);
+
+		width = max(1, floor(width / 2));
+		height = max(1, floor(height / 2));
+	}
+
+	r_texture_ptr(unit, prev_tex);
+}
+
+void gl33_texture_get_params(Texture *tex, TextureParams *params) {
+	assert(tex->impl != NULL);
+	memcpy(params, &tex->impl->params, sizeof(*params));
+}
+
+void gl33_texture_set_filter(Texture *tex, TextureFilterMode fmin, TextureFilterMode fmag) {
+	uint unit = gl33_active_texunit();
+	Texture *prev_tex = r_texture_current(unit);
+	r_texture_ptr(unit, tex);
+
+	if(tex->impl->params.filter.min != fmin) {
+		gl33_sync_texunit(unit, false);
+		tex->impl->params.filter.min = fmin;
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, r_filter_to_gl_filter(fmin));
+	}
+
+	if(tex->impl->params.filter.mag != fmag) {
+		gl33_sync_texunit(unit, false);
+		tex->impl->params.filter.mag = fmag;
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, r_filter_to_gl_filter(fmag));
+	}
+
+	r_texture_ptr(unit, prev_tex);
+}
+
+void gl33_texture_set_wrap(Texture *tex, TextureWrapMode ws, TextureWrapMode wt) {
+	uint unit = gl33_active_texunit();
+	Texture *prev_tex = r_texture_current(unit);
+	r_texture_ptr(unit, tex);
+
+	if(tex->impl->params.wrap.s != ws) {
+		gl33_sync_texunit(unit, false);
+		tex->impl->params.wrap.s = ws;
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, r_wrap_to_gl_wrap(ws));
+	}
+
+	if(tex->impl->params.wrap.t != wt) {
+		gl33_sync_texunit(unit, false);
+		tex->impl->params.wrap.t = wt;
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, r_wrap_to_gl_wrap(wt));
+	}
+
 	r_texture_ptr(unit, prev_tex);
 }

 void gl33_texture_invalidate(Texture *tex) {
-	gl33_texture_set(tex, NULL);
+	for(uint i = 0; i < tex->impl->params.mipmaps; ++i) {
+		gl33_texture_set(tex, i, NULL);
+	}
 }

-void gl33_texture_fill(Texture *tex, void *image_data) {
-	// r_texture_fill_region(tex, 0, 0, tex->w, tex->h, image_data);
-	gl33_texture_set(tex, image_data);
+void gl33_texture_fill(Texture *tex, uint mipmap, void *image_data) {
+	assert(mipmap == 0 || tex->impl->params.mipmap_mode != TEX_MIPMAP_AUTO);
+	gl33_texture_set(tex, mipmap, image_data);
 }

-void gl33_texture_fill_region(Texture *tex, uint x, uint y, uint w, uint h, void *image_data) {
+void gl33_texture_fill_region(Texture *tex, uint mipmap, uint x, uint y, uint w, uint h, void *image_data) {
+	assert(mipmap == 0 || tex->impl->params.mipmap_mode != TEX_MIPMAP_AUTO);
+
 	uint unit = gl33_active_texunit();
 	Texture *prev_tex = r_texture_current(unit);
 	r_texture_ptr(unit, tex);
-	gl33_sync_texunit(unit);
+	gl33_sync_texunit(unit, false);
 	glTexSubImage2D(
-		GL_TEXTURE_2D, 0,
+		GL_TEXTURE_2D, mipmap,
 		x, y, w, h,
 		GLVT.texture_type_info(tex->type)->external_fmt,
 		GL_UNSIGNED_BYTE,
 		image_data
 	);
 	r_texture_ptr(unit, prev_tex);
-}
-
-void gl33_texture_replace(Texture *tex, TextureType type, uint w, uint h, void *image_data) {
-	assert(tex->impl != NULL);
-
-	tex->w = w;
-	tex->h = h;
-
-	if(type != tex->type) {
-		tex->type = type;
-		tex->impl->type_info = GLVT.texture_type_info(type);
-	}
-
-	gl33_texture_set(tex, image_data);
+	tex->impl->mipmaps_outdated = true;
 }

 void gl33_texture_destroy(Texture *tex) {
@ -171,3 +255,23 @@ void gl33_texture_destroy(Texture *tex) {
 		tex->impl = NULL;
 	}
 }
+
+void gl33_texture_taint(Texture *tex) {
+	tex->impl->mipmaps_outdated = true;
+}
+
+void gl33_texture_prepare(Texture *tex) {
+	assert(tex->impl != NULL);
+
+	if(tex->impl->params.mipmap_mode == TEX_MIPMAP_AUTO && tex->impl->mipmaps_outdated) {
+		log_debug("Generating mipmaps for texture %u", tex->impl->gl_handle);
+
+		uint unit = gl33_active_texunit();
+		Texture *prev_tex = r_texture_current(unit);
+		r_texture_ptr(unit, tex);
+		gl33_sync_texunit(unit, false);
+		glGenerateMipmap(GL_TEXTURE_2D);
+		r_texture_ptr(unit, prev_tex);
+		tex->impl->mipmaps_outdated = false;
+	}
+}
--- a/src/renderer/gl33/texture.h
+++ b/src/renderer/gl33/texture.h
@ -19,13 +19,19 @@ typedef struct TextureImpl {
 	GLuint gl_handle;
 	GLuint pbo;
 	GLTextureTypeInfo *type_info;
+	TextureParams params;
+	bool mipmaps_outdated;
 } TextureImpl;

 void gl33_texture_create(Texture *tex, const TextureParams *params);
+void gl33_texture_get_params(Texture *tex, TextureParams *params);
+void gl33_texture_set_filter(Texture *tex, TextureFilterMode fmin, TextureFilterMode fmag);
+void gl33_texture_set_wrap(Texture *tex, TextureWrapMode ws, TextureWrapMode wt);
 void gl33_texture_invalidate(Texture *tex);
-void gl33_texture_fill(Texture *tex, void *image_data);
-void gl33_texture_fill_region(Texture *tex, uint x, uint y, uint w, uint h, void *image_data);
-void gl33_texture_replace(Texture *tex, TextureType type, uint w, uint h, void *image_data);
+void gl33_texture_fill(Texture *tex, uint mipmap, void *image_data);
+void gl33_texture_fill_region(Texture *tex, uint mipmap, uint x, uint y, uint w, uint h, void *image_data);
+void gl33_texture_prepare(Texture *tex);
+void gl33_texture_taint(Texture *tex);
 void gl33_texture_destroy(Texture *tex);

 GLTextureTypeInfo* gl33_texture_type_info(TextureType type);
--- a/src/renderer/glcommon/opengl.c
+++ b/src/renderer/glcommon/opengl.c
@ -297,6 +297,27 @@ static void glcommon_ext_draw_buffers(void) {
 	log_warn("Extension not supported");
 }

+static void glcommon_ext_texture_filter_anisotropic(void) {
+	if(GL_ATLEAST(4, 6)) {
+		glext.texture_filter_anisotropic = TSGL_EXTFLAG_NATIVE;
+		log_info("Using core functionality");
+		return;
+	}
+
+	if((glext.texture_filter_anisotropic = glcommon_check_extension("GL_ARB_texture_filter_anisotropic"))) {
+		log_info("Using ARB_texture_filter_anisotropic");
+		return;
+	}
+
+	if((glext.texture_filter_anisotropic = glcommon_check_extension("GL_EXT_texture_filter_anisotropic"))) {
+		log_info("Using EXT_texture_filter_anisotropic");
+		return;
+	}
+
+	glext.texture_filter_anisotropic = 0;
+	log_warn("Extension not supported");
+}
+
 void glcommon_check_extensions(void) {
 	memset(&glext, 0, sizeof(glext));
 	glext.version.major = GLVersion.major;
@ -344,6 +365,7 @@ void glcommon_check_extensions(void) {
 	glcommon_ext_draw_buffers();
 	glcommon_ext_instanced_arrays();
 	glcommon_ext_pixel_buffer_object();
+	glcommon_ext_texture_filter_anisotropic();
 }

 void glcommon_load_library(void) {
--- a/src/renderer/glcommon/opengl.h
+++ b/src/renderer/glcommon/opengl.h
@ -67,6 +67,7 @@ struct glext_s {
 	ext_flag_t pixel_buffer_object;
 	ext_flag_t depth_texture;
 	ext_flag_t draw_buffers;
+	ext_flag_t texture_filter_anisotropic;

 	//
 	// debug_output
--- a/src/renderer/gles20/core.c
+++ b/src/renderer/gles20/core.c
@ -51,7 +51,6 @@ static void gles30_init(void) {

 GLTextureTypeInfo* gles20_texture_type_info(TextureType type) {
 	static GLTextureTypeInfo map[] = {
-		[TEX_TYPE_DEFAULT] = { GL_RGBA,            GL_RGBA,            GL_UNSIGNED_BYTE,  4 },
 		[TEX_TYPE_R]       = { GL_RED,             GL_RED,             GL_UNSIGNED_BYTE,  1 },
 		[TEX_TYPE_RG]      = { GL_RG,              GL_RG,              GL_UNSIGNED_BYTE,  2 },
 		[TEX_TYPE_RGB]     = { GL_RGBA,            GL_RGBA,            GL_UNSIGNED_BYTE,  4 },
--- a/src/renderer/null/null.c
+++ b/src/renderer/null/null.c
@ -61,10 +61,18 @@ void null_texture_create(Texture *tex, const TextureParams *params) {
 	tex->impl = (void*)&placeholder;
 }

-void null_texture_fill(Texture *tex, void *image_data) { }
-void null_texture_fill_region(Texture *tex, uint x, uint y, uint w, uint h, void *image_data) { }
+void null_texture_get_params(Texture *tex, TextureParams *params) {
+	memset(params, 0, sizeof(*params));
+	params->width = tex->w;
+	params->height = tex->h;
+	params->type = tex->type;
+}
+
+void null_texture_set_filter(Texture *tex, TextureFilterMode fmin, TextureFilterMode fmag) { }
+void null_texture_set_wrap(Texture *tex, TextureWrapMode fmin, TextureWrapMode fmag) { }
+void null_texture_fill(Texture *tex, uint mipmap, void *image_data) { }
+void null_texture_fill_region(Texture *tex, uint mipmap, uint x, uint y, uint w, uint h, void *image_data) { }
 void null_texture_invalidate(Texture *tex) { }
-void null_texture_replace(Texture *tex, TextureType type, uint w, uint h, void *image_data) { }

 void null_texture_destroy(Texture *tex) {
 	memset(tex, 0, sizeof(Texture));
@ -84,7 +92,7 @@ void null_framebuffer_create(Framebuffer *framebuffer) {
 	framebuffer->impl = calloc(1, sizeof(FramebufferImpl));
 }

-void null_framebuffer_attach(Framebuffer *framebuffer, Texture *tex, FramebufferAttachment attachment) {
+void null_framebuffer_attach(Framebuffer *framebuffer, Texture *tex, uint mipmap, FramebufferAttachment attachment) {
 	framebuffer->impl->attachments[attachment] = tex;
 }

@ -92,6 +100,10 @@ Texture* null_framebuffer_attachment(Framebuffer *framebuffer, FramebufferAttach
 	return framebuffer->impl->attachments[attachment];
 }

+uint null_framebuffer_attachment_mipmap(Framebuffer *framebuffer, FramebufferAttachment attachment) {
+	return 0;
+}
+
 void null_framebuffer_destroy(Framebuffer *framebuffer) {
 	free(framebuffer->impl);
 	memset(framebuffer, 0, sizeof(Framebuffer));
@ -249,17 +261,20 @@ RendererBackend _r_backend_null = {
 		.uniform = null_uniform,
 		.uniform_type = null_uniform_type,
 		.texture_create = null_texture_create,
+		.texture_get_params = null_texture_get_params,
+		.texture_set_filter = null_texture_set_filter,
+		.texture_set_wrap = null_texture_set_wrap,
 		.texture_destroy = null_texture_destroy,
 		.texture_invalidate = null_texture_invalidate,
 		.texture_fill = null_texture_fill,
 		.texture_fill_region = null_texture_fill_region,
-		.texture_replace = null_texture_replace,
 		.texture = null_texture,
 		.texture_current = null_texture_current,
 		.framebuffer_create = null_framebuffer_create,
 		.framebuffer_destroy = null_framebuffer_destroy,
 		.framebuffer_attach = null_framebuffer_attach,
 		.framebuffer_get_attachment = null_framebuffer_attachment,
+		.framebuffer_get_attachment_mipmap = null_framebuffer_attachment_mipmap,
 		.framebuffer_viewport = null_framebuffer_viewport,
 		.framebuffer_viewport_current = null_framebuffer_viewport_current,
 		.framebuffer = null_framebuffer,
--- a/src/resource/font.c
+++ b/src/resource/font.c
@ -183,7 +183,7 @@ static void init_fonts(void) {
 	});

 	r_framebuffer_create(&globals.render_buf);
-	r_framebuffer_attach(&globals.render_buf, &globals.render_tex, FRAMEBUFFER_ATTACH_COLOR0);
+	r_framebuffer_attach(&globals.render_buf, &globals.render_tex, 0, FRAMEBUFFER_ATTACH_COLOR0);
 	r_framebuffer_viewport(&globals.render_buf, 0, 0, globals.render_tex.w, globals.render_tex.h);
 }

@ -325,8 +325,8 @@ static SpriteSheet* add_spritesheet(SpriteSheetAnchor *spritesheets) {
 		.width = SS_WIDTH,
 		.height = SS_HEIGHT,
 		.type = TEX_TYPE_R,
-		.filter.upscale = TEX_FILTER_LINEAR,
-		.filter.downscale = TEX_FILTER_LINEAR,
+		.filter.mag = TEX_FILTER_LINEAR,
+		.filter.min = TEX_FILTER_LINEAR,
 		.wrap.s = TEX_WRAP_CLAMP,
 		.wrap.t = TEX_WRAP_CLAMP,
 	});
@ -345,7 +345,7 @@ static SpriteSheet* add_spritesheet(SpriteSheetAnchor *spritesheets) {
 	Framebuffer atlast_fb;
 	Color cc_prev = r_clear_color_current();
 	r_framebuffer_create(&atlast_fb);
-	r_framebuffer_attach(&atlast_fb, &ss->tex, FRAMEBUFFER_ATTACH_COLOR0);
+	r_framebuffer_attach(&atlast_fb, &ss->tex, 0, FRAMEBUFFER_ATTACH_COLOR0);
 	r_framebuffer(&atlast_fb);
 	r_clear_color4(0, 0, 0, 0);
 	r_clear(CLEAR_COLOR);
@ -375,6 +375,7 @@ static bool add_glyph_to_spritesheet(Font *font, Glyph *glyph, FT_Bitmap bitmap,

 	r_texture_fill_region(
 		&ss->tex,
+		0,
 		rect_x(sprite_pos),
 		rect_y(sprite_pos),
 		bitmap.width,
@ -962,7 +963,14 @@ void text_render(const char *text, Font *font, Sprite *out_sprite, BBox *out_bbo
 			tex_new_w, tex_new_h
 		);

-		r_texture_replace(tex, TEX_TYPE_R, tex_new_w, tex_new_h, NULL);
+		TextureParams params;
+		r_texture_get_params(tex, &params);
+		r_texture_destroy(tex);
+		params.width = tex_new_w;
+		params.height = tex_new_h;
+		params.mipmaps = 0;
+		r_texture_create(tex, &params);
+		r_framebuffer_attach(&globals.render_buf, tex, 0, FRAMEBUFFER_ATTACH_COLOR0);
 		r_framebuffer_viewport(&globals.render_buf, 0, 0, tex_new_w, tex_new_h);
 	}

--- a/src/resource/texture.c
+++ b/src/resource/texture.c
@ -91,12 +91,94 @@ bool check_texture_path(const char *path) {
 	return strendswith_any(path, texture_image_exts);
 }

-typedef struct ImageData {
-	int width;
-	int height;
-	int depth;
-	uint32_t *pixels;
-} ImageData;
+typedef struct TexLoadData {
+	SDL_Surface *surf;
+	TextureParams params;
+} TexLoadData;
+
+static void parse_filter(const char *val, TextureFilterMode *out, bool allow_mipmaps) {
+	if(!val) {
+		return;
+	}
+
+	char buf[strlen(val) + 1];
+	strcpy(buf, val);
+	char *ignore, *pbuf = strtok_r(buf, " \t", &ignore);
+
+	if(!SDL_strcasecmp(pbuf, "default")) {
+		return;
+	}
+
+	if(!SDL_strcasecmp(pbuf, "nearest")) {
+		*out = TEX_FILTER_NEAREST;
+		return;
+	}
+
+	if(!SDL_strcasecmp(pbuf, "linear")) {
+		*out = TEX_FILTER_LINEAR;
+		return;
+	}
+
+	if(allow_mipmaps) {
+		if(!SDL_strcasecmp(pbuf, "nearest_mipmap_nearest")) {
+			*out = TEX_FILTER_NEAREST_MIPMAP_NEAREST;
+			return;
+		}
+
+		if(!SDL_strcasecmp(pbuf, "nearest_mipmap_linear")) {
+			*out = TEX_FILTER_NEAREST_MIPMAP_LINEAR;
+			return;
+		}
+
+		if(!SDL_strcasecmp(pbuf, "linear_mipmap_nearest")) {
+			*out = TEX_FILTER_LINEAR_MIPMAP_NEAREST;
+			return;
+		}
+
+		if(!SDL_strcasecmp(pbuf, "linear_mipmap_linear")) {
+			*out = TEX_FILTER_LINEAR_MIPMAP_LINEAR;
+			return;
+		}
+	}
+
+	log_fatal("Bad value `%s`, assuming default", pbuf);
+}
+
+static void parse_wrap(const char *val, TextureWrapMode *out) {
+	if(!val) {
+		return;
+	}
+
+	char buf[strlen(val) + 1];
+	strcpy(buf, val);
+	char *ignore, *pbuf = strtok_r(buf, " \t", &ignore);
+
+	if(!SDL_strcasecmp(pbuf, "default")) {
+		return;
+	}
+
+	if(!SDL_strcasecmp(pbuf, "clamp")) {
+		*out = TEX_WRAP_CLAMP;
+		return;
+	}
+
+	if(!SDL_strcasecmp(pbuf, "mirror")) {
+		*out = TEX_WRAP_MIRROR;
+		return;
+	}
+
+	if(!SDL_strcasecmp(pbuf, "repeat")) {
+		*out = TEX_WRAP_REPEAT;
+		return;
+	}
+
+	log_warn("Bad value `%s`, assuming default", pbuf);
+}
+
+typedef struct TextureLoadData {
+	SDL_Surface *surf;
+	TextureParams params;
+} TextureLoadData;

 static void* load_texture_begin(const char *path, uint flags) {
 	const char *source = path;
@ -104,10 +186,35 @@ static void* load_texture_begin(const char *path, uint flags) {
 	SDL_Surface *surf = NULL;
 	SDL_RWops *srcrw = NULL;

+	TextureLoadData ld = {
+		.params = {
+			.type = TEX_TYPE_RGBA,
+			.filter = {
+				.mag = TEX_FILTER_LINEAR,
+				.min = TEX_FILTER_LINEAR,
+			},
+			.wrap = {
+				.s = TEX_WRAP_REPEAT,
+				.t = TEX_WRAP_REPEAT,
+			},
+			.mipmap_mode = TEX_MIPMAP_MANUAL,
+			.mipmaps = 1,
+		}
+	};
+
 	if(strendswith(path, TEX_EXTENSION)) {
+		char *str_filter_min = NULL;
+		char *str_filter_mag = NULL;
+		char *str_wrap_s = NULL;
+		char *str_wrap_t = NULL;
+
 		if(!parse_keyvalue_file_with_spec(path, (KVSpec[]) {
-			{ "source", .out_str = &source_allocated },
-			// TODO: more parameters, e.g. filtering, wrap modes, post-load shaders, mipmaps, compression, etc.
+			{ "source",     .out_str  = &source_allocated },
+			{ "filter_min", .out_str  = &str_filter_min },
+			{ "filter_mag", .out_str  = &str_filter_mag },
+			{ "wrap_s",     .out_str  = &str_wrap_s },
+			{ "wrap_t",     .out_str  = &str_wrap_t },
+			{ "mipmaps",    .out_int  = (int*)&ld.params.mipmaps },
 			{ NULL }
 		})) {
 			free(source_allocated);
@ -132,6 +239,18 @@ static void* load_texture_begin(const char *path, uint flags) {
 		}

 		source = source_allocated;
+
+		parse_filter(str_filter_min, &ld.params.filter.min, true);
+		free(str_filter_min);
+
+		parse_filter(str_filter_mag, &ld.params.filter.mag, false);
+		free(str_filter_mag);
+
+		parse_wrap(str_wrap_s, &ld.params.wrap.s);
+		free(str_wrap_s);
+
+		parse_wrap(str_wrap_t, &ld.params.wrap.t);
+		free(str_wrap_t);
 	}

 	srcrw = vfs_open(source, VFS_MODE_READ | VFS_MODE_SEEKABLE);
@ -148,8 +267,11 @@ static void* load_texture_begin(const char *path, uint flags) {
 		surf = IMG_Load_RW(srcrw, false);
 	}

+	free(source_allocated);
+
 	if(!surf) {
 		log_warn("IMG_Load_RW failed: %s", IMG_GetError());
+		return NULL;
 	}

 	SDL_RWclose(srcrw);
@ -162,7 +284,15 @@ static void* load_texture_begin(const char *path, uint flags) {
 		return NULL;
 	}

-	return converted_surf;
+	if(ld.params.mipmaps == 0) {
+		ld.params.mipmaps = TEX_MIPMAPS_MAX;
+	}
+
+	ld.params.width = converted_surf->w;
+	ld.params.height = converted_surf->h;
+	ld.surf = converted_surf;
+
+	return memdup(&ld, sizeof(ld));
 }

 static void texture_post_load(Texture *tex) {
@ -176,31 +306,17 @@ static void texture_post_load(Texture *tex) {
 	bool cullcap_saved = r_capability_current(RCAP_CULL_FACE);

 	Texture fbo_tex;
+	TextureParams params;
 	Framebuffer fb;

 	r_blend(BLEND_NONE);
 	r_disable(RCAP_CULL_FACE);
-	r_texture_create(&fbo_tex, &(TextureParams) {
-		.width = tex->w,
-		.height = tex->h,
-		.type = tex->type,
-		.filter = {
-			.upscale = TEX_FILTER_LINEAR,
-			.downscale = TEX_FILTER_LINEAR,
-		},
-		.wrap = {
-			.s = TEX_WRAP_REPEAT,
-			.t = TEX_WRAP_REPEAT,
-		},
-	});
-	r_framebuffer_create(&fb);
-	r_framebuffer_attach(&fb, &fbo_tex, FRAMEBUFFER_ATTACH_COLOR0);
-	r_framebuffer_viewport(&fb, 0, 0, tex->w, tex->h);
-	r_framebuffer(&fb);
+	r_texture_get_params(tex, &params);
+	params.mipmap_mode = TEX_MIPMAP_MANUAL;
+	r_texture_set_filter(tex, TEX_FILTER_LINEAR, TEX_FILTER_LINEAR);
+	r_texture_create(&fbo_tex, &params);
 	r_texture_ptr(0, tex);
 	r_shader("texture_post_load");
-	r_uniform_int("width", tex->w);
-	r_uniform_int("height", tex->h);
 	r_mat_push();
 	r_mat_identity();
 	r_mat_mode(MM_PROJECTION);
@ -211,7 +327,15 @@ static void texture_post_load(Texture *tex) {
 	r_mat_scale(tex->w, tex->h, 1);
 	r_mat_translate(0.5, 0.5, 0);
 	r_mat_scale(1, -1, 1);
-	r_draw_quad();
+	r_framebuffer_create(&fb);
+
+	for(uint mipmap = 0; mipmap < params.mipmaps; ++mipmap) {
+		r_framebuffer_attach(&fb, &fbo_tex, mipmap, FRAMEBUFFER_ATTACH_COLOR0);
+		r_framebuffer_viewport(&fb, 0, 0, max(1, floor(tex->w / pow(2, mipmap))), max(1, floor(tex->h / pow(2, mipmap))));
+		r_framebuffer(&fb);
+		r_draw_quad();
+	}
+
 	r_mat_pop();
 	r_mat_mode(MM_PROJECTION);
 	r_mat_pop();
@ -228,16 +352,20 @@ static void texture_post_load(Texture *tex) {
 }

 static void* load_texture_end(void *opaque, const char *path, uint flags) {
-	SDL_Surface *surface = opaque;
+	TextureLoadData *ld = opaque;

-	if(!surface) {
+	if(!ld) {
 		return NULL;
 	}

 	Texture *texture = malloc(sizeof(Texture));

-	load_sdl_surf(surface, texture);
-	SDL_FreeSurface(surface);
+	r_texture_create(texture, &ld->params);
+	SDL_LockSurface(ld->surf);
+	r_texture_fill(texture, 0, ld->surf->pixels);
+	SDL_UnlockSurface(ld->surf);
+	SDL_FreeSurface(ld->surf);
+	free(ld);

 	texture_post_load(texture);
 	return texture;
@ -254,25 +382,6 @@ Texture* prefix_get_tex(const char *name, const char *prefix) {
 	return tex;
 }

-void load_sdl_surf(SDL_Surface *surface, Texture *texture) {
-	SDL_LockSurface(surface);
-	r_texture_create(texture, &(TextureParams) {
-		.width = surface->w,
-		.height = surface->h,
-		.type = TEX_TYPE_RGBA,
-		.image_data = surface->pixels,
-		.filter = {
-			.upscale = TEX_FILTER_LINEAR,
-			.downscale = TEX_FILTER_LINEAR,
-		},
-		.wrap = {
-			.s = TEX_WRAP_REPEAT,
-			.t = TEX_WRAP_REPEAT,
-		},
-	});
-	SDL_UnlockSurface(surface);
-}
-
 static void free_texture(Texture *tex) {
 	r_texture_destroy(tex);
 	free(tex);
--- a/src/resource/texture.h
+++ b/src/resource/texture.h
@ -33,8 +33,6 @@ void fill_screen_p(Texture *tex);
 void loop_tex_line_p(complex a, complex b, float w, float t, Texture *texture);
 void loop_tex_line(complex a, complex b, float w, float t, const char *texture);

-void load_sdl_surf(SDL_Surface *surface, Texture *texture);
-
 Texture* get_tex(const char *name);
 Texture* prefix_get_tex(const char *name, const char *prefix);

--- a/src/stagedraw.c
+++ b/src/stagedraw.c
@ -134,8 +134,8 @@ static void stage_draw_setup_framebuffers(void) {

 	// Set up some parameters shared by all attachments
 	TextureParams tex_common = {
-		.filter.upscale = TEX_FILTER_LINEAR,
-		.filter.downscale = TEX_FILTER_LINEAR,
+		.filter.min = TEX_FILTER_LINEAR,
+		.filter.mag = TEX_FILTER_LINEAR,
 		.wrap.s = TEX_WRAP_MIRROR,
 		.wrap.t = TEX_WRAP_MIRROR,
 	};
--- a/src/util/fbpair.c
+++ b/src/util/fbpair.c
@ -18,7 +18,7 @@ static void fbpair_create_fb(Framebuffer *fb, uint num_attachments, FBAttachment
 	for(uint i = 0; i < num_attachments; ++i) {
 		Texture *tex = calloc(1, sizeof(Texture));
 		r_texture_create(tex, &attachments[i].tex_params);
-		r_framebuffer_attach(fb, tex, attachments[i].attachment);
+		r_framebuffer_attach(fb, tex, 0, attachments[i].attachment);
 	}
 }

@ -44,12 +44,14 @@ static void fbpair_resize_fb(Framebuffer *fb, FramebufferAttachment attachment,

 	// TODO: We could render a rescaled version of the old texture contents here

-	r_texture_replace(tex, tex->type, width, height, NULL);
-	r_state_push();
-	r_framebuffer(fb);
-	r_clear_color4(0, 0, 0, 0);
-	r_clear(CLEAR_ALL);
-	r_state_pop();
+	TextureParams params;
+	r_texture_get_params(tex, &params);
+	r_texture_destroy(tex);
+	params.width = width;
+	params.height = height;
+	params.mipmaps = 0; // FIXME
+	r_texture_create(tex, &params);
+	r_framebuffer_attach(fb, tex, 0, attachment);
 }

 void fbpair_create(FBPair *pair, uint num_attachments, FBAttachmentConfig attachments[num_attachments]) {
@ -70,15 +72,29 @@ void fbpair_swap(FBPair *pair) {
 	*(void**)&pair->back  = tmp;
 }

+static void fbpair_clear(FBPair *pair) {
+	r_state_push();
+	r_clear_color4(0, 0, 0, 0);
+	r_framebuffer(pair->framebuffers + 0);
+	r_clear(CLEAR_ALL);
+	r_framebuffer(pair->framebuffers + 1);
+	r_clear(CLEAR_ALL);
+	r_state_pop();
+}
+
 void fbpair_resize(FBPair *pair, FramebufferAttachment attachment, uint width, uint height) {
 	fbpair_resize_fb(pair->framebuffers + 0, attachment, width, height);
 	fbpair_resize_fb(pair->framebuffers + 1, attachment, width, height);
+	fbpair_clear(pair);
 }

 void fbpair_resize_all(FBPair *pair, uint width, uint height) {
 	for(uint i = 0; i < FRAMEBUFFER_MAX_ATTACHMENTS; ++i) {
-		fbpair_resize(pair, i, width, height);
+		fbpair_resize_fb(pair->framebuffers + 0, i, width, height);
+		fbpair_resize_fb(pair->framebuffers + 1, i, width, height);
 	}
+
+	fbpair_clear(pair);
 }

 void fbpair_viewport(FBPair *pair, int x, int y, int w, int h) {
--- a/src/util/kvparser.c
+++ b/src/util/kvparser.c
@ -122,6 +122,10 @@ static bool kvcallback_spec(const char *key, const char *val, void *data) {
 				*s->out_double = strtod(val, NULL);
 			}

+			if(s->out_bool) {
+				*s->out_bool = parse_bool(val, *s->out_bool);
+			}
+
 			return true;
 		}
 	}
@ -137,3 +141,40 @@ bool parse_keyvalue_stream_with_spec(SDL_RWops *strm, KVSpec *spec) {
 bool parse_keyvalue_file_with_spec(const char *filename, KVSpec *spec) {
 	return parse_keyvalue_file_cb(filename, kvcallback_spec, spec);
 }
+
+bool parse_bool(const char *str, bool fallback) {
+	while(isspace(*str)) {
+		++str;
+	}
+
+	char buf[strlen(str) + 1], *bufp = buf;
+
+	while(*str && !isspace(*str)) {
+		*bufp++ = *str++;
+	}
+
+	*bufp = 0;
+	double numeric_val = strtod(buf, &bufp);
+
+	if(*buf && !*bufp) {
+		return (bool)numeric_val;
+	}
+
+	static const char *true_vals[]  = { "on",  "yes", "true",  NULL };
+	static const char *false_vals[] = { "off", "no",  "false", NULL };
+
+	for(const char **v = true_vals; v; ++v) {
+		if(!SDL_strcasecmp(buf, *v)) {
+			return true;
+		}
+	}
+
+	for(const char **v = false_vals; v; ++v) {
+		if(!SDL_strcasecmp(buf, *v)) {
+			return false;
+		}
+	}
+
+	log_warn("Bad value `%s`, assuming %s", buf, fallback ? "true" : "false");
+	return fallback;
+}
--- a/src/util/kvparser.h
+++ b/src/util/kvparser.h
@ -25,6 +25,7 @@ typedef struct KVSpec {
 	long *out_long;
 	double *out_double;
 	float *out_float;
+	bool *out_bool;
 } KVSpec;

 bool parse_keyvalue_stream_cb(SDL_RWops *strm, KVCallback callback, void *data);
@ -33,3 +34,5 @@ bool parse_keyvalue_stream(SDL_RWops *strm, ht_str2ptr_t *hashtable);
 bool parse_keyvalue_file(const char *filename, ht_str2ptr_t *hashtable);
 bool parse_keyvalue_stream_with_spec(SDL_RWops *strm, KVSpec *spec);
 bool parse_keyvalue_file_with_spec(const char *filename, KVSpec *spec);
+
+bool parse_bool(const char *str, bool fallback) attr_nonnull(1);
--- a/subprojects/glad/include/glad/glad.h
+++ b/subprojects/glad/include/glad/glad.h
@ -1,6 +1,6 @@
 /*

-    OpenGL, OpenGL ES loader generated by glad 0.1.24a0 on Sat Jun 30 23:07:02 2018.
+    OpenGL, OpenGL ES loader generated by glad 0.1.24a0 on Mon Jul  9 16:00:07 2018.

    Language/Generator: C/C++
    Specification: gl
@ -16,12 +16,14 @@
        GL_ARB_draw_instanced,
        GL_ARB_instanced_arrays,
        GL_ARB_pixel_buffer_object,
+        GL_ARB_texture_filter_anisotropic,
        GL_ATI_draw_buffers,
        GL_EXT_base_instance,
        GL_EXT_draw_buffers,
        GL_EXT_draw_instanced,
        GL_EXT_instanced_arrays,
        GL_EXT_pixel_buffer_object,
+        GL_EXT_texture_filter_anisotropic,
        GL_KHR_debug,
        GL_NV_draw_instanced,
        GL_NV_instanced_arrays,
@ -33,9 +35,9 @@
    Omit khrplatform: False

    Commandline:
-        --profile="core" --api="gl=3.3,gles2=3.0" --generator="c" --spec="gl" --no-loader --extensions="GL_ANGLE_depth_texture,GL_ANGLE_instanced_arrays,GL_ARB_base_instance,GL_ARB_debug_output,GL_ARB_depth_texture,GL_ARB_draw_buffers,GL_ARB_draw_instanced,GL_ARB_instanced_arrays,GL_ARB_pixel_buffer_object,GL_ATI_draw_buffers,GL_EXT_base_instance,GL_EXT_draw_buffers,GL_EXT_draw_instanced,GL_EXT_instanced_arrays,GL_EXT_pixel_buffer_object,GL_KHR_debug,GL_NV_draw_instanced,GL_NV_instanced_arrays,GL_NV_pixel_buffer_object,GL_OES_depth_texture,GL_SGIX_depth_texture"
+        --profile="core" --api="gl=3.3,gles2=3.0" --generator="c" --spec="gl" --no-loader --extensions="GL_ANGLE_depth_texture,GL_ANGLE_instanced_arrays,GL_ARB_base_instance,GL_ARB_debug_output,GL_ARB_depth_texture,GL_ARB_draw_buffers,GL_ARB_draw_instanced,GL_ARB_instanced_arrays,GL_ARB_pixel_buffer_object,GL_ARB_texture_filter_anisotropic,GL_ATI_draw_buffers,GL_EXT_base_instance,GL_EXT_draw_buffers,GL_EXT_draw_instanced,GL_EXT_instanced_arrays,GL_EXT_pixel_buffer_object,GL_EXT_texture_filter_anisotropic,GL_KHR_debug,GL_NV_draw_instanced,GL_NV_instanced_arrays,GL_NV_pixel_buffer_object,GL_OES_depth_texture,GL_SGIX_depth_texture"
    Online:
-        http://glad.dav1d.de/#profile=core&language=c&specification=gl&api=gl%3D3.3&api=gles2%3D3.0&extensions=GL_ANGLE_depth_texture&extensions=GL_ANGLE_instanced_arrays&extensions=GL_ARB_base_instance&extensions=GL_ARB_debug_output&extensions=GL_ARB_depth_texture&extensions=GL_ARB_draw_buffers&extensions=GL_ARB_draw_instanced&extensions=GL_ARB_instanced_arrays&extensions=GL_ARB_pixel_buffer_object&extensions=GL_ATI_draw_buffers&extensions=GL_EXT_base_instance&extensions=GL_EXT_draw_buffers&extensions=GL_EXT_draw_instanced&extensions=GL_EXT_instanced_arrays&extensions=GL_EXT_pixel_buffer_object&extensions=GL_KHR_debug&extensions=GL_NV_draw_instanced&extensions=GL_NV_instanced_arrays&extensions=GL_NV_pixel_buffer_object&extensions=GL_OES_depth_texture&extensions=GL_SGIX_depth_texture
+        http://glad.dav1d.de/#profile=core&language=c&specification=gl&api=gl%3D3.3&api=gles2%3D3.0&extensions=GL_ANGLE_depth_texture&extensions=GL_ANGLE_instanced_arrays&extensions=GL_ARB_base_instance&extensions=GL_ARB_debug_output&extensions=GL_ARB_depth_texture&extensions=GL_ARB_draw_buffers&extensions=GL_ARB_draw_instanced&extensions=GL_ARB_instanced_arrays&extensions=GL_ARB_pixel_buffer_object&extensions=GL_ARB_texture_filter_anisotropic&extensions=GL_ATI_draw_buffers&extensions=GL_EXT_base_instance&extensions=GL_EXT_draw_buffers&extensions=GL_EXT_draw_instanced&extensions=GL_EXT_instanced_arrays&extensions=GL_EXT_pixel_buffer_object&extensions=GL_EXT_texture_filter_anisotropic&extensions=GL_KHR_debug&extensions=GL_NV_draw_instanced&extensions=GL_NV_instanced_arrays&extensions=GL_NV_pixel_buffer_object&extensions=GL_OES_depth_texture&extensions=GL_SGIX_depth_texture
 */


@ -2365,6 +2367,8 @@ GLAPI PFNGLGETINTERNALFORMATIVPROC glad_glGetInternalformativ;
 #define GL_PIXEL_UNPACK_BUFFER_ARB 0x88EC
 #define GL_PIXEL_PACK_BUFFER_BINDING_ARB 0x88ED
 #define GL_PIXEL_UNPACK_BUFFER_BINDING_ARB 0x88EF
+#define GL_TEXTURE_MAX_ANISOTROPY 0x84FE
+#define GL_MAX_TEXTURE_MAX_ANISOTROPY 0x84FF
 #define GL_MAX_DRAW_BUFFERS_ATI 0x8824
 #define GL_DRAW_BUFFER0_ATI 0x8825
 #define GL_DRAW_BUFFER1_ATI 0x8826
@ -2386,6 +2390,8 @@ GLAPI PFNGLGETINTERNALFORMATIVPROC glad_glGetInternalformativ;
 #define GL_PIXEL_UNPACK_BUFFER_EXT 0x88EC
 #define GL_PIXEL_PACK_BUFFER_BINDING_EXT 0x88ED
 #define GL_PIXEL_UNPACK_BUFFER_BINDING_EXT 0x88EF
+#define GL_TEXTURE_MAX_ANISOTROPY_EXT 0x84FE
+#define GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT 0x84FF
 #define GL_DEBUG_OUTPUT_SYNCHRONOUS 0x8242
 #define GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH 0x8243
 #define GL_DEBUG_CALLBACK_FUNCTION 0x8244
@ -2576,6 +2582,10 @@ GLAPI PFNGLVERTEXATTRIBDIVISORARBPROC glad_glVertexAttribDivisorARB;
 #define GL_ARB_pixel_buffer_object 1
 GLAPI int GLAD_GL_ARB_pixel_buffer_object;
 #endif
+#ifndef GL_ARB_texture_filter_anisotropic
+#define GL_ARB_texture_filter_anisotropic 1
+GLAPI int GLAD_GL_ARB_texture_filter_anisotropic;
+#endif
 #ifndef GL_ATI_draw_buffers
 #define GL_ATI_draw_buffers 1
 GLAPI int GLAD_GL_ATI_draw_buffers;
@ -2597,6 +2607,10 @@ GLAPI PFNGLDRAWELEMENTSINSTANCEDEXTPROC glad_glDrawElementsInstancedEXT;
 #define GL_EXT_pixel_buffer_object 1
 GLAPI int GLAD_GL_EXT_pixel_buffer_object;
 #endif
+#ifndef GL_EXT_texture_filter_anisotropic
+#define GL_EXT_texture_filter_anisotropic 1
+GLAPI int GLAD_GL_EXT_texture_filter_anisotropic;
+#endif
 #ifndef GL_KHR_debug
 #define GL_KHR_debug 1
 GLAPI int GLAD_GL_KHR_debug;
@ -2719,6 +2733,10 @@ typedef void (APIENTRYP PFNGLVERTEXATTRIBDIVISOREXTPROC)(GLuint index, GLuint di
 GLAPI PFNGLVERTEXATTRIBDIVISOREXTPROC glad_glVertexAttribDivisorEXT;
 #define glVertexAttribDivisorEXT glad_glVertexAttribDivisorEXT
 #endif
+#ifndef GL_EXT_texture_filter_anisotropic
+#define GL_EXT_texture_filter_anisotropic 1
+GLAPI int GLAD_GL_EXT_texture_filter_anisotropic;
+#endif
 #ifndef GL_KHR_debug
 #define GL_KHR_debug 1
 GLAPI int GLAD_GL_KHR_debug;
--- a/subprojects/glad/meson.build
+++ b/subprojects/glad/meson.build
@ -12,12 +12,14 @@ glad_extensions = [
    'GL_ARB_draw_instanced',
    'GL_ARB_instanced_arrays',
    'GL_ARB_pixel_buffer_object',
+    'GL_ARB_texture_filter_anisotropic',
    'GL_ATI_draw_buffers',
    'GL_EXT_base_instance',
    'GL_EXT_draw_buffers',
    'GL_EXT_draw_instanced',
    'GL_EXT_instanced_arrays',
    'GL_EXT_pixel_buffer_object',
+    'GL_EXT_texture_filter_anisotropic',
    'GL_KHR_debug',
    'GL_NV_draw_instanced',
    'GL_NV_instanced_arrays',
--- a/subprojects/glad/src/glad.c
+++ b/subprojects/glad/src/glad.c
@ -1,6 +1,6 @@
 /*

-    OpenGL, OpenGL ES loader generated by glad 0.1.24a0 on Sat Jun 30 23:07:02 2018.
+    OpenGL, OpenGL ES loader generated by glad 0.1.24a0 on Mon Jul  9 16:00:07 2018.

    Language/Generator: C/C++
    Specification: gl
@ -16,12 +16,14 @@
        GL_ARB_draw_instanced,
        GL_ARB_instanced_arrays,
        GL_ARB_pixel_buffer_object,
+        GL_ARB_texture_filter_anisotropic,
        GL_ATI_draw_buffers,
        GL_EXT_base_instance,
        GL_EXT_draw_buffers,
        GL_EXT_draw_instanced,
        GL_EXT_instanced_arrays,
        GL_EXT_pixel_buffer_object,
+        GL_EXT_texture_filter_anisotropic,
        GL_KHR_debug,
        GL_NV_draw_instanced,
        GL_NV_instanced_arrays,
@ -33,9 +35,9 @@
    Omit khrplatform: False

    Commandline:
-        --profile="core" --api="gl=3.3,gles2=3.0" --generator="c" --spec="gl" --no-loader --extensions="GL_ANGLE_depth_texture,GL_ANGLE_instanced_arrays,GL_ARB_base_instance,GL_ARB_debug_output,GL_ARB_depth_texture,GL_ARB_draw_buffers,GL_ARB_draw_instanced,GL_ARB_instanced_arrays,GL_ARB_pixel_buffer_object,GL_ATI_draw_buffers,GL_EXT_base_instance,GL_EXT_draw_buffers,GL_EXT_draw_instanced,GL_EXT_instanced_arrays,GL_EXT_pixel_buffer_object,GL_KHR_debug,GL_NV_draw_instanced,GL_NV_instanced_arrays,GL_NV_pixel_buffer_object,GL_OES_depth_texture,GL_SGIX_depth_texture"
+        --profile="core" --api="gl=3.3,gles2=3.0" --generator="c" --spec="gl" --no-loader --extensions="GL_ANGLE_depth_texture,GL_ANGLE_instanced_arrays,GL_ARB_base_instance,GL_ARB_debug_output,GL_ARB_depth_texture,GL_ARB_draw_buffers,GL_ARB_draw_instanced,GL_ARB_instanced_arrays,GL_ARB_pixel_buffer_object,GL_ARB_texture_filter_anisotropic,GL_ATI_draw_buffers,GL_EXT_base_instance,GL_EXT_draw_buffers,GL_EXT_draw_instanced,GL_EXT_instanced_arrays,GL_EXT_pixel_buffer_object,GL_EXT_texture_filter_anisotropic,GL_KHR_debug,GL_NV_draw_instanced,GL_NV_instanced_arrays,GL_NV_pixel_buffer_object,GL_OES_depth_texture,GL_SGIX_depth_texture"
    Online:
-        http://glad.dav1d.de/#profile=core&language=c&specification=gl&api=gl%3D3.3&api=gles2%3D3.0&extensions=GL_ANGLE_depth_texture&extensions=GL_ANGLE_instanced_arrays&extensions=GL_ARB_base_instance&extensions=GL_ARB_debug_output&extensions=GL_ARB_depth_texture&extensions=GL_ARB_draw_buffers&extensions=GL_ARB_draw_instanced&extensions=GL_ARB_instanced_arrays&extensions=GL_ARB_pixel_buffer_object&extensions=GL_ATI_draw_buffers&extensions=GL_EXT_base_instance&extensions=GL_EXT_draw_buffers&extensions=GL_EXT_draw_instanced&extensions=GL_EXT_instanced_arrays&extensions=GL_EXT_pixel_buffer_object&extensions=GL_KHR_debug&extensions=GL_NV_draw_instanced&extensions=GL_NV_instanced_arrays&extensions=GL_NV_pixel_buffer_object&extensions=GL_OES_depth_texture&extensions=GL_SGIX_depth_texture
+        http://glad.dav1d.de/#profile=core&language=c&specification=gl&api=gl%3D3.3&api=gles2%3D3.0&extensions=GL_ANGLE_depth_texture&extensions=GL_ANGLE_instanced_arrays&extensions=GL_ARB_base_instance&extensions=GL_ARB_debug_output&extensions=GL_ARB_depth_texture&extensions=GL_ARB_draw_buffers&extensions=GL_ARB_draw_instanced&extensions=GL_ARB_instanced_arrays&extensions=GL_ARB_pixel_buffer_object&extensions=GL_ARB_texture_filter_anisotropic&extensions=GL_ATI_draw_buffers&extensions=GL_EXT_base_instance&extensions=GL_EXT_draw_buffers&extensions=GL_EXT_draw_instanced&extensions=GL_EXT_instanced_arrays&extensions=GL_EXT_pixel_buffer_object&extensions=GL_EXT_texture_filter_anisotropic&extensions=GL_KHR_debug&extensions=GL_NV_draw_instanced&extensions=GL_NV_instanced_arrays&extensions=GL_NV_pixel_buffer_object&extensions=GL_OES_depth_texture&extensions=GL_SGIX_depth_texture
 */

 #include <stdio.h>
@ -160,420 +162,422 @@ int GLAD_GL_VERSION_3_2;
 int GLAD_GL_VERSION_3_3;
 int GLAD_GL_ES_VERSION_2_0;
 int GLAD_GL_ES_VERSION_3_0;
-PFNGLUNIFORM4FPROC glad_glUniform4f;
-PFNGLDELETEBUFFERSPROC glad_glDeleteBuffers;
-PFNGLUNIFORMMATRIX3FVPROC glad_glUniformMatrix3fv;
-PFNGLUNIFORM1UIPROC glad_glUniform1ui;
-PFNGLBUFFERSUBDATAPROC glad_glBufferSubData;
-PFNGLUNIFORM4FVPROC glad_glUniform4fv;
-PFNGLVERTEXATTRIB1SVPROC glad_glVertexAttrib1sv;
-PFNGLVERTEXATTRIB4SVPROC glad_glVertexAttrib4sv;
-PFNGLPOINTPARAMETERIPROC glad_glPointParameteri;
-PFNGLPRIMITIVERESTARTINDEXPROC glad_glPrimitiveRestartIndex;
-PFNGLCOMPRESSEDTEXIMAGE2DPROC glad_glCompressedTexImage2D;
-PFNGLBEGINTRANSFORMFEEDBACKPROC glad_glBeginTransformFeedback;
-PFNGLBINDTEXTUREPROC glad_glBindTexture;
-PFNGLMAPBUFFERPROC glad_glMapBuffer;
-PFNGLCOMPRESSEDTEXIMAGE1DPROC glad_glCompressedTexImage1D;
-PFNGLGETVERTEXATTRIBIVPROC glad_glGetVertexAttribiv;
-PFNGLVERTEXATTRIB2FVPROC glad_glVertexAttrib2fv;
+PFNGLUNIFORM1FPROC glad_glUniform1f;
+PFNGLBLENDEQUATIONSEPARATEPROC glad_glBlendEquationSeparate;
+PFNGLINVALIDATEFRAMEBUFFERPROC glad_glInvalidateFramebuffer;
 PFNGLPOINTSIZEPROC glad_glPointSize;
+PFNGLGENERATEMIPMAPPROC glad_glGenerateMipmap;
+PFNGLDEPTHMASKPROC glad_glDepthMask;
+PFNGLBINDSAMPLERPROC glad_glBindSampler;
 PFNGLDETACHSHADERPROC glad_glDetachShader;
-PFNGLUNIFORM2FVPROC glad_glUniform2fv;
-PFNGLDELETETEXTURESPROC glad_glDeleteTextures;
-PFNGLVERTEXP4UIPROC glad_glVertexP4ui;
-PFNGLREADPIXELSPROC glad_glReadPixels;
-PFNGLCOPYTEXSUBIMAGE3DPROC glad_glCopyTexSubImage3D;
-PFNGLUNIFORM4UIPROC glad_glUniform4ui;
-PFNGLVERTEXATTRIB4IVPROC glad_glVertexAttrib4iv;
-PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC glad_glDrawElementsInstancedBaseVertex;
-PFNGLVERTEXATTRIBI3IPROC glad_glVertexAttribI3i;
-PFNGLBINDTRANSFORMFEEDBACKPROC glad_glBindTransformFeedback;
+PFNGLPROVOKINGVERTEXPROC glad_glProvokingVertex;
+PFNGLTEXPARAMETERIUIVPROC glad_glTexParameterIuiv;
+PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC glad_glCompressedTexSubImage2D;
+PFNGLISSHADERPROC glad_glIsShader;
+PFNGLGETINTERNALFORMATIVPROC glad_glGetInternalformativ;
+PFNGLVERTEXATTRIB2DVPROC glad_glVertexAttrib2dv;
+PFNGLMULTIDRAWELEMENTSPROC glad_glMultiDrawElements;
+PFNGLMAPBUFFERRANGEPROC glad_glMapBufferRange;
+PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC glad_glCompressedTexSubImage3D;
+PFNGLBLENDEQUATIONPROC glad_glBlendEquation;
+PFNGLUNIFORM3UIVPROC glad_glUniform3uiv;
 PFNGLFRAMEBUFFERRENDERBUFFERPROC glad_glFramebufferRenderbuffer;
-PFNGLCOLORP3UIPROC glad_glColorP3ui;
-PFNGLUNIFORM4IVPROC glad_glUniform4iv;
-PFNGLGETSYNCIVPROC glad_glGetSynciv;
-PFNGLVERTEXATTRIBI1UIPROC glad_glVertexAttribI1ui;
-PFNGLVERTEXATTRIBP3UIVPROC glad_glVertexAttribP3uiv;
-PFNGLCULLFACEPROC glad_glCullFace;
-PFNGLVERTEXATTRIBI4USVPROC glad_glVertexAttribI4usv;
-PFNGLGETSHADERSOURCEPROC glad_glGetShaderSource;
+PFNGLDRAWELEMENTSINSTANCEDPROC glad_glDrawElementsInstanced;
+PFNGLTEXCOORDP2UIVPROC glad_glTexCoordP2uiv;
+PFNGLTEXCOORDP3UIPROC glad_glTexCoordP3ui;
+PFNGLDELETEFRAMEBUFFERSPROC glad_glDeleteFramebuffers;
+PFNGLGETBUFFERPARAMETERI64VPROC glad_glGetBufferParameteri64v;
+PFNGLENDCONDITIONALRENDERPROC glad_glEndConditionalRender;
+PFNGLREADBUFFERPROC glad_glReadBuffer;
+PFNGLUNIFORM3IPROC glad_glUniform3i;
 PFNGLTEXPARAMETERFVPROC glad_glTexParameterfv;
+PFNGLGETSAMPLERPARAMETERFVPROC glad_glGetSamplerParameterfv;
 PFNGLVERTEXATTRIBP2UIPROC glad_glVertexAttribP2ui;
+PFNGLVERTEXATTRIBI3UIPROC glad_glVertexAttribI3ui;
+PFNGLBINDFRAMEBUFFERPROC glad_glBindFramebuffer;
+PFNGLTEXSTORAGE2DPROC glad_glTexStorage2D;
+PFNGLFLUSHMAPPEDBUFFERRANGEPROC glad_glFlushMappedBufferRange;
+PFNGLGETACTIVEATTRIBPROC glad_glGetActiveAttrib;
+PFNGLCLEARCOLORPROC glad_glClearColor;
+PFNGLGETERRORPROC glad_glGetError;
+PFNGLGETQUERYOBJECTI64VPROC glad_glGetQueryObjecti64v;
+PFNGLPOINTPARAMETERIPROC glad_glPointParameteri;
+PFNGLVERTEXATTRIBI1UIVPROC glad_glVertexAttribI1uiv;
+PFNGLDELETETRANSFORMFEEDBACKSPROC glad_glDeleteTransformFeedbacks;
+PFNGLGETVERTEXATTRIBPOINTERVPROC glad_glGetVertexAttribPointerv;
+PFNGLUNIFORM1UIPROC glad_glUniform1ui;
+PFNGLISBUFFERPROC glad_glIsBuffer;
+PFNGLVERTEXATTRIB2DPROC glad_glVertexAttrib2d;
+PFNGLVERTEXATTRIB1FPROC glad_glVertexAttrib1f;
+PFNGLFRAMEBUFFERTEXTUREPROC glad_glFramebufferTexture;
+PFNGLBINDTEXTUREPROC glad_glBindTexture;
+PFNGLDEPTHRANGEFPROC glad_glDepthRangef;
+PFNGLGETVERTEXATTRIBIIVPROC glad_glGetVertexAttribIiv;
+PFNGLDELETEBUFFERSPROC glad_glDeleteBuffers;
+PFNGLGETBOOLEANI_VPROC glad_glGetBooleani_v;
+PFNGLSCISSORPROC glad_glScissor;
+PFNGLVERTEXP2UIPROC glad_glVertexP2ui;
+PFNGLUNIFORM1IPROC glad_glUniform1i;
+PFNGLUNIFORM3FVPROC glad_glUniform3fv;
+PFNGLDELETERENDERBUFFERSPROC glad_glDeleteRenderbuffers;
+PFNGLGETTRANSFORMFEEDBACKVARYINGPROC glad_glGetTransformFeedbackVarying;
+PFNGLGETTEXPARAMETERFVPROC glad_glGetTexParameterfv;
+PFNGLBLENDCOLORPROC glad_glBlendColor;
+PFNGLVERTEXATTRIB4SPROC glad_glVertexAttrib4s;
+PFNGLPOINTPARAMETERFPROC glad_glPointParameterf;
+PFNGLVERTEXATTRIBP1UIVPROC glad_glVertexAttribP1uiv;
+PFNGLVERTEXP2UIVPROC glad_glVertexP2uiv;
+PFNGLGETTEXIMAGEPROC glad_glGetTexImage;
+PFNGLISVERTEXARRAYPROC glad_glIsVertexArray;
+PFNGLRESUMETRANSFORMFEEDBACKPROC glad_glResumeTransformFeedback;
+PFNGLBINDFRAGDATALOCATIONINDEXEDPROC glad_glBindFragDataLocationIndexed;
+PFNGLUSEPROGRAMPROC glad_glUseProgram;
+PFNGLBINDATTRIBLOCATIONPROC glad_glBindAttribLocation;
+PFNGLVERTEXATTRIB4FPROC glad_glVertexAttrib4f;
+PFNGLGETATTRIBLOCATIONPROC glad_glGetAttribLocation;
+PFNGLUNIFORM3UIPROC glad_glUniform3ui;
+PFNGLSAMPLECOVERAGEPROC glad_glSampleCoverage;
+PFNGLTEXSUBIMAGE3DPROC glad_glTexSubImage3D;
+PFNGLPRIMITIVERESTARTINDEXPROC glad_glPrimitiveRestartIndex;
+PFNGLLOGICOPPROC glad_glLogicOp;
+PFNGLISPROGRAMPROC glad_glIsProgram;
+PFNGLVERTEXATTRIB3FPROC glad_glVertexAttrib3f;
+PFNGLRENDERBUFFERSTORAGEPROC glad_glRenderbufferStorage;
+PFNGLCOLORP4UIVPROC glad_glColorP4uiv;
+PFNGLMULTITEXCOORDP2UIPROC glad_glMultiTexCoordP2ui;
+PFNGLDEPTHRANGEPROC glad_glDepthRange;
+PFNGLGETUNIFORMUIVPROC glad_glGetUniformuiv;
+PFNGLSAMPLERPARAMETERIPROC glad_glSamplerParameteri;
+PFNGLDRAWBUFFERPROC glad_glDrawBuffer;
+PFNGLTEXPARAMETERIVPROC glad_glTexParameteriv;
+PFNGLNORMALP3UIVPROC glad_glNormalP3uiv;
+PFNGLGETQUERYOBJECTIVPROC glad_glGetQueryObjectiv;
+PFNGLGETVERTEXATTRIBDVPROC glad_glGetVertexAttribdv;
+PFNGLVERTEXATTRIB4DVPROC glad_glVertexAttrib4dv;
+PFNGLSTENCILMASKPROC glad_glStencilMask;
+PFNGLTEXIMAGE2DMULTISAMPLEPROC glad_glTexImage2DMultisample;
+PFNGLSTENCILMASKSEPARATEPROC glad_glStencilMaskSeparate;
+PFNGLTEXPARAMETERFPROC glad_glTexParameterf;
+PFNGLGETSTRINGIPROC glad_glGetStringi;
+PFNGLVERTEXATTRIB4USVPROC glad_glVertexAttrib4usv;
+PFNGLBUFFERDATAPROC glad_glBufferData;
+PFNGLVERTEXATTRIBI2UIPROC glad_glVertexAttribI2ui;
+PFNGLPOLYGONOFFSETPROC glad_glPolygonOffset;
+PFNGLBUFFERSUBDATAPROC glad_glBufferSubData;
+PFNGLTEXCOORDP2UIPROC glad_glTexCoordP2ui;
+PFNGLCLEARBUFFERUIVPROC glad_glClearBufferuiv;
+PFNGLWAITSYNCPROC glad_glWaitSync;
+PFNGLGENQUERIESPROC glad_glGenQueries;
+PFNGLGETSHADERPRECISIONFORMATPROC glad_glGetShaderPrecisionFormat;
+PFNGLTEXSTORAGE3DPROC glad_glTexStorage3D;
+PFNGLVERTEXP4UIPROC glad_glVertexP4ui;
+PFNGLTEXCOORDP1UIVPROC glad_glTexCoordP1uiv;
+PFNGLVERTEXATTRIB4NUSVPROC glad_glVertexAttrib4Nusv;
+PFNGLCOLORP3UIPROC glad_glColorP3ui;
+PFNGLVERTEXATTRIBI4IVPROC glad_glVertexAttribI4iv;
+PFNGLSHADERBINARYPROC glad_glShaderBinary;
+PFNGLGENRENDERBUFFERSPROC glad_glGenRenderbuffers;
+PFNGLTEXIMAGE3DMULTISAMPLEPROC glad_glTexImage3DMultisample;
+PFNGLGETTEXPARAMETERIVPROC glad_glGetTexParameteriv;
+PFNGLDELETEVERTEXARRAYSPROC glad_glDeleteVertexArrays;
+PFNGLUNIFORM1FVPROC glad_glUniform1fv;
+PFNGLVERTEXATTRIBI4USVPROC glad_glVertexAttribI4usv;
+PFNGLUNIFORM1IVPROC glad_glUniform1iv;
+PFNGLISENABLEDIPROC glad_glIsEnabledi;
+PFNGLCOMPRESSEDTEXIMAGE3DPROC glad_glCompressedTexImage3D;
+PFNGLATTACHSHADERPROC glad_glAttachShader;
+PFNGLGETUNIFORMIVPROC glad_glGetUniformiv;
+PFNGLVERTEXATTRIB2FPROC glad_glVertexAttrib2f;
+PFNGLGETACTIVEUNIFORMSIVPROC glad_glGetActiveUniformsiv;
+PFNGLISSYNCPROC glad_glIsSync;
+PFNGLGETVERTEXATTRIBFVPROC glad_glGetVertexAttribfv;
+PFNGLHINTPROC glad_glHint;
+PFNGLSECONDARYCOLORP3UIVPROC glad_glSecondaryColorP3uiv;
+PFNGLTEXSUBIMAGE1DPROC glad_glTexSubImage1D;
+PFNGLVALIDATEPROGRAMPROC glad_glValidateProgram;
+PFNGLVERTEXATTRIBI4IPROC glad_glVertexAttribI4i;
+PFNGLUNIFORM3IVPROC glad_glUniform3iv;
+PFNGLTEXCOORDP1UIPROC glad_glTexCoordP1ui;
+PFNGLBEGINQUERYPROC glad_glBeginQuery;
+PFNGLCOPYTEXSUBIMAGE1DPROC glad_glCopyTexSubImage1D;
+PFNGLUNIFORMMATRIX4FVPROC glad_glUniformMatrix4fv;
+PFNGLVERTEXATTRIBI2IPROC glad_glVertexAttribI2i;
+PFNGLSAMPLERPARAMETERFVPROC glad_glSamplerParameterfv;
+PFNGLUNIFORM2UIVPROC glad_glUniform2uiv;
+PFNGLCREATEPROGRAMPROC glad_glCreateProgram;
+PFNGLGETFLOATVPROC glad_glGetFloatv;
+PFNGLDISABLEVERTEXATTRIBARRAYPROC glad_glDisableVertexAttribArray;
+PFNGLGETQUERYOBJECTUIVPROC glad_glGetQueryObjectuiv;
+PFNGLGETVERTEXATTRIBIUIVPROC glad_glGetVertexAttribIuiv;
+PFNGLUNIFORM2FVPROC glad_glUniform2fv;
+PFNGLPROGRAMPARAMETERIPROC glad_glProgramParameteri;
+PFNGLGETCOMPRESSEDTEXIMAGEPROC glad_glGetCompressedTexImage;
 PFNGLVERTEXATTRIB4NUBPROC glad_glVertexAttrib4Nub;
-PFNGLTRANSFORMFEEDBACKVARYINGSPROC glad_glTransformFeedbackVaryings;
-PFNGLPOINTPARAMETERFVPROC glad_glPointParameterfv;
+PFNGLVERTEXATTRIBPOINTERPROC glad_glVertexAttribPointer;
+PFNGLGETBUFFERPARAMETERIVPROC glad_glGetBufferParameteriv;
+PFNGLUNIFORMBLOCKBINDINGPROC glad_glUniformBlockBinding;
+PFNGLISRENDERBUFFERPROC glad_glIsRenderbuffer;
+PFNGLCOPYBUFFERSUBDATAPROC glad_glCopyBufferSubData;
+PFNGLISQUERYPROC glad_glIsQuery;
+PFNGLGETINTEGER64I_VPROC glad_glGetInteger64i_v;
+PFNGLBINDVERTEXARRAYPROC glad_glBindVertexArray;
+PFNGLBINDRENDERBUFFERPROC glad_glBindRenderbuffer;
+PFNGLGETACTIVEUNIFORMNAMEPROC glad_glGetActiveUniformName;
+PFNGLCOPYTEXIMAGE2DPROC glad_glCopyTexImage2D;
+PFNGLUNIFORM4IVPROC glad_glUniform4iv;
+PFNGLSTENCILFUNCSEPARATEPROC glad_glStencilFuncSeparate;
+PFNGLUNIFORMMATRIX3X2FVPROC glad_glUniformMatrix3x2fv;
+PFNGLVERTEXATTRIB4DPROC glad_glVertexAttrib4d;
+PFNGLVIEWPORTPROC glad_glViewport;
+PFNGLCOMPILESHADERPROC glad_glCompileShader;
+PFNGLGETSYNCIVPROC glad_glGetSynciv;
+PFNGLGENTRANSFORMFEEDBACKSPROC glad_glGenTransformFeedbacks;
+PFNGLVERTEXATTRIB4NUIVPROC glad_glVertexAttrib4Nuiv;
+PFNGLDISABLEPROC glad_glDisable;
+PFNGLUNIFORMMATRIX2FVPROC glad_glUniformMatrix2fv;
+PFNGLGETSAMPLERPARAMETERIVPROC glad_glGetSamplerParameteriv;
+PFNGLCLEARBUFFERFIPROC glad_glClearBufferfi;
+PFNGLVERTEXATTRIB4BVPROC glad_glVertexAttrib4bv;
+PFNGLPIXELSTOREIPROC glad_glPixelStorei;
+PFNGLVERTEXATTRIB4NBVPROC glad_glVertexAttrib4Nbv;
+PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC glad_glDrawRangeElementsBaseVertex;
+PFNGLGETUNIFORMINDICESPROC glad_glGetUniformIndices;
+PFNGLPOINTPARAMETERIVPROC glad_glPointParameteriv;
+PFNGLCOLORMASKPROC glad_glColorMask;
+PFNGLGETRENDERBUFFERPARAMETERIVPROC glad_glGetRenderbufferParameteriv;
+PFNGLCLEARPROC glad_glClear;
+PFNGLTEXSUBIMAGE2DPROC glad_glTexSubImage2D;
+PFNGLGETBUFFERSUBDATAPROC glad_glGetBufferSubData;
+PFNGLREADPIXELSPROC glad_glReadPixels;
+PFNGLGETBUFFERPOINTERVPROC glad_glGetBufferPointerv;
+PFNGLUNIFORM3FPROC glad_glUniform3f;
+PFNGLACTIVETEXTUREPROC glad_glActiveTexture;
+PFNGLVERTEXATTRIBI1IPROC glad_glVertexAttribI1i;
+PFNGLVERTEXATTRIBP4UIPROC glad_glVertexAttribP4ui;
+PFNGLUNMAPBUFFERPROC glad_glUnmapBuffer;
+PFNGLGETPROGRAMBINARYPROC glad_glGetProgramBinary;
+PFNGLISTEXTUREPROC glad_glIsTexture;
+PFNGLENDQUERYPROC glad_glEndQuery;
+PFNGLGETTEXPARAMETERIUIVPROC glad_glGetTexParameterIuiv;
+PFNGLISSAMPLERPROC glad_glIsSampler;
+PFNGLGETACTIVEUNIFORMBLOCKIVPROC glad_glGetActiveUniformBlockiv;
+PFNGLGETQUERYOBJECTUI64VPROC glad_glGetQueryObjectui64v;
+PFNGLVERTEXATTRIB1SPROC glad_glVertexAttrib1s;
+PFNGLCLIENTWAITSYNCPROC glad_glClientWaitSync;
+PFNGLVERTEXATTRIBI4UBVPROC glad_glVertexAttribI4ubv;
+PFNGLUNIFORM1UIVPROC glad_glUniform1uiv;
+PFNGLVERTEXATTRIBP4UIVPROC glad_glVertexAttribP4uiv;
+PFNGLBINDFRAGDATALOCATIONPROC glad_glBindFragDataLocation;
+PFNGLDISABLEIPROC glad_glDisablei;
+PFNGLVERTEXATTRIB4UBVPROC glad_glVertexAttrib4ubv;
+PFNGLGETUNIFORMFVPROC glad_glGetUniformfv;
+PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC glad_glCompressedTexSubImage1D;
+PFNGLUNIFORMMATRIX4X2FVPROC glad_glUniformMatrix4x2fv;
+PFNGLUNIFORMMATRIX3FVPROC glad_glUniformMatrix3fv;
+PFNGLCLEARDEPTHFPROC glad_glClearDepthf;
+PFNGLNORMALP3UIPROC glad_glNormalP3ui;
+PFNGLMULTITEXCOORDP4UIPROC glad_glMultiTexCoordP4ui;
+PFNGLSTENCILFUNCPROC glad_glStencilFunc;
+PFNGLCLEARBUFFERIVPROC glad_glClearBufferiv;
+PFNGLUNIFORMMATRIX2X3FVPROC glad_glUniformMatrix2x3fv;
+PFNGLVERTEXATTRIB4IVPROC glad_glVertexAttrib4iv;
+PFNGLUNIFORM2UIPROC glad_glUniform2ui;
+PFNGLGETSHADERIVPROC glad_glGetShaderiv;
+PFNGLISENABLEDPROC glad_glIsEnabled;
+PFNGLVERTEXATTRIBDIVISORPROC glad_glVertexAttribDivisor;
+PFNGLFINISHPROC glad_glFinish;
+PFNGLGETBOOLEANVPROC glad_glGetBooleanv;
+PFNGLBLENDFUNCPROC glad_glBlendFunc;
+PFNGLGETSHADERINFOLOGPROC glad_glGetShaderInfoLog;
+PFNGLPAUSETRANSFORMFEEDBACKPROC glad_glPauseTransformFeedback;
+PFNGLCHECKFRAMEBUFFERSTATUSPROC glad_glCheckFramebufferStatus;
+PFNGLMULTITEXCOORDP2UIVPROC glad_glMultiTexCoordP2uiv;
+PFNGLDELETETEXTURESPROC glad_glDeleteTextures;
+PFNGLCOLORMASKIPROC glad_glColorMaski;
+PFNGLVERTEXATTRIBI3IPROC glad_glVertexAttribI3i;
+PFNGLLINEWIDTHPROC glad_glLineWidth;
+PFNGLVERTEXATTRIB3SPROC glad_glVertexAttrib3s;
+PFNGLDELETESYNCPROC glad_glDeleteSync;
+PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC glad_glMultiDrawElementsBaseVertex;
 PFNGLMULTITEXCOORDP4UIVPROC glad_glMultiTexCoordP4uiv;
+PFNGLFLUSHPROC glad_glFlush;
+PFNGLMAPBUFFERPROC glad_glMapBuffer;
+PFNGLVERTEXP3UIPROC glad_glVertexP3ui;
+PFNGLUNIFORMMATRIX4X3FVPROC glad_glUniformMatrix4x3fv;
+PFNGLVERTEXATTRIBP3UIPROC glad_glVertexAttribP3ui;
+PFNGLSAMPLERPARAMETERIIVPROC glad_glSamplerParameterIiv;
+PFNGLUNIFORM2IVPROC glad_glUniform2iv;
+PFNGLVERTEXATTRIB1DPROC glad_glVertexAttrib1d;
+PFNGLGETDOUBLEVPROC glad_glGetDoublev;
+PFNGLMULTITEXCOORDP3UIPROC glad_glMultiTexCoordP3ui;
+PFNGLPIXELSTOREFPROC glad_glPixelStoref;
+PFNGLVERTEXATTRIB4NUBVPROC glad_glVertexAttrib4Nubv;
+PFNGLBINDBUFFERRANGEPROC glad_glBindBufferRange;
+PFNGLVERTEXATTRIBP2UIVPROC glad_glVertexAttribP2uiv;
+PFNGLDRAWARRAYSPROC glad_glDrawArrays;
+PFNGLGETSTRINGPROC glad_glGetString;
+PFNGLSTENCILOPPROC glad_glStencilOp;
+PFNGLVERTEXATTRIB1SVPROC glad_glVertexAttrib1sv;
+PFNGLSAMPLERPARAMETERIVPROC glad_glSamplerParameteriv;
+PFNGLQUERYCOUNTERPROC glad_glQueryCounter;
+PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC glad_glGetActiveUniformBlockName;
+PFNGLSTENCILOPSEPARATEPROC glad_glStencilOpSeparate;
+PFNGLBEGINTRANSFORMFEEDBACKPROC glad_glBeginTransformFeedback;
+PFNGLGETATTACHEDSHADERSPROC glad_glGetAttachedShaders;
+PFNGLUNIFORMMATRIX3X4FVPROC glad_glUniformMatrix3x4fv;
+PFNGLVERTEXATTRIB2SVPROC glad_glVertexAttrib2sv;
+PFNGLCLAMPCOLORPROC glad_glClampColor;
+PFNGLDEPTHFUNCPROC glad_glDepthFunc;
+PFNGLGENVERTEXARRAYSPROC glad_glGenVertexArrays;
 PFNGLGETINTEGERI_VPROC glad_glGetIntegeri_v;
 PFNGLMULTITEXCOORDP1UIVPROC glad_glMultiTexCoordP1uiv;
-PFNGLCOLORMASKPROC glad_glColorMask;
-PFNGLVERTEXATTRIB4NIVPROC glad_glVertexAttrib4Niv;
-PFNGLBINDFRAGDATALOCATIONINDEXEDPROC glad_glBindFragDataLocationIndexed;
-PFNGLQUERYCOUNTERPROC glad_glQueryCounter;
-PFNGLVERTEXP3UIVPROC glad_glVertexP3uiv;
-PFNGLDELETESAMPLERSPROC glad_glDeleteSamplers;
-PFNGLGETVERTEXATTRIBIIVPROC glad_glGetVertexAttribIiv;
-PFNGLBEGINCONDITIONALRENDERPROC glad_glBeginConditionalRender;
-PFNGLMULTITEXCOORDP3UIPROC glad_glMultiTexCoordP3ui;
-PFNGLCREATEPROGRAMPROC glad_glCreateProgram;
-PFNGLVERTEXATTRIBI4BVPROC glad_glVertexAttribI4bv;
-PFNGLGETACTIVEUNIFORMPROC glad_glGetActiveUniform;
-PFNGLISTEXTUREPROC glad_glIsTexture;
-PFNGLVERTEXATTRIB4DVPROC glad_glVertexAttrib4dv;
-PFNGLSCISSORPROC glad_glScissor;
-PFNGLUNIFORM1FPROC glad_glUniform1f;
-PFNGLDEPTHRANGEPROC glad_glDepthRange;
-PFNGLUNIFORMMATRIX3X2FVPROC glad_glUniformMatrix3x2fv;
-PFNGLGETATTRIBLOCATIONPROC glad_glGetAttribLocation;
-PFNGLTEXSTORAGE2DPROC glad_glTexStorage2D;
-PFNGLSTENCILFUNCSEPARATEPROC glad_glStencilFuncSeparate;
-PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC glad_glCompressedTexSubImage3D;
-PFNGLGETSHADERINFOLOGPROC glad_glGetShaderInfoLog;
-PFNGLGETUNIFORMBLOCKINDEXPROC glad_glGetUniformBlockIndex;
-PFNGLISSHADERPROC glad_glIsShader;
-PFNGLISTRANSFORMFEEDBACKPROC glad_glIsTransformFeedback;
-PFNGLPROGRAMPARAMETERIPROC glad_glProgramParameteri;
-PFNGLGETTEXLEVELPARAMETERFVPROC glad_glGetTexLevelParameterfv;
-PFNGLVERTEXATTRIBI4SVPROC glad_glVertexAttribI4sv;
-PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC glad_glRenderbufferStorageMultisample;
-PFNGLDRAWELEMENTSINSTANCEDPROC glad_glDrawElementsInstanced;
-PFNGLLINEWIDTHPROC glad_glLineWidth;
-PFNGLGETATTACHEDSHADERSPROC glad_glGetAttachedShaders;
-PFNGLCOLORP4UIPROC glad_glColorP4ui;
-PFNGLBEGINQUERYPROC glad_glBeginQuery;
-PFNGLUNIFORM1IPROC glad_glUniform1i;
-PFNGLTEXBUFFERPROC glad_glTexBuffer;
-PFNGLENDTRANSFORMFEEDBACKPROC glad_glEndTransformFeedback;
-PFNGLPOINTPARAMETERFPROC glad_glPointParameterf;
-PFNGLCLEARSTENCILPROC glad_glClearStencil;
-PFNGLENDQUERYPROC glad_glEndQuery;
-PFNGLSTENCILMASKSEPARATEPROC glad_glStencilMaskSeparate;
-PFNGLTEXCOORDP1UIVPROC glad_glTexCoordP1uiv;
-PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC glad_glDrawRangeElementsBaseVertex;
-PFNGLVERTEXATTRIB2SVPROC glad_glVertexAttrib2sv;
-PFNGLCOPYBUFFERSUBDATAPROC glad_glCopyBufferSubData;
-PFNGLUNIFORMMATRIX3X4FVPROC glad_glUniformMatrix3x4fv;
-PFNGLUNIFORM2UIVPROC glad_glUniform2uiv;
-PFNGLRENDERBUFFERSTORAGEPROC glad_glRenderbufferStorage;
-PFNGLFINISHPROC glad_glFinish;
-PFNGLUNIFORM3UIVPROC glad_glUniform3uiv;
-PFNGLGENFRAMEBUFFERSPROC glad_glGenFramebuffers;
-PFNGLDRAWELEMENTSBASEVERTEXPROC glad_glDrawElementsBaseVertex;
-PFNGLISENABLEDPROC glad_glIsEnabled;
-PFNGLVERTEXATTRIBIPOINTERPROC glad_glVertexAttribIPointer;
-PFNGLGETINTEGER64I_VPROC glad_glGetInteger64i_v;
-PFNGLGETSAMPLERPARAMETERIVPROC glad_glGetSamplerParameteriv;
-PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC glad_glCompressedTexSubImage1D;
-PFNGLVERTEXP2UIVPROC glad_glVertexP2uiv;
-PFNGLENABLEIPROC glad_glEnablei;
-PFNGLVERTEXATTRIBI2UIPROC glad_glVertexAttribI2ui;
-PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC glad_glCompressedTexSubImage2D;
-PFNGLUNIFORM1FVPROC glad_glUniform1fv;
-PFNGLSHADERBINARYPROC glad_glShaderBinary;
-PFNGLUNIFORM3IVPROC glad_glUniform3iv;
-PFNGLPOLYGONMODEPROC glad_glPolygonMode;
-PFNGLUNIFORMMATRIX2X4FVPROC glad_glUniformMatrix2x4fv;
-PFNGLCLEARBUFFERFIPROC glad_glClearBufferfi;
-PFNGLVALIDATEPROGRAMPROC glad_glValidateProgram;
-PFNGLBINDFRAGDATALOCATIONPROC glad_glBindFragDataLocation;
-PFNGLGETTEXIMAGEPROC glad_glGetTexImage;
-PFNGLISPROGRAMPROC glad_glIsProgram;
-PFNGLUNIFORM2IPROC glad_glUniform2i;
-PFNGLVERTEXATTRIB1FVPROC glad_glVertexAttrib1fv;
-PFNGLVERTEXATTRIB3SPROC glad_glVertexAttrib3s;
-PFNGLSAMPLERPARAMETERFPROC glad_glSamplerParameterf;
-PFNGLBINDSAMPLERPROC glad_glBindSampler;
-PFNGLUNIFORMMATRIX4X3FVPROC glad_glUniformMatrix4x3fv;
-PFNGLGETTEXPARAMETERFVPROC glad_glGetTexParameterfv;
-PFNGLVERTEXATTRIB4USVPROC glad_glVertexAttrib4usv;
-PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC glad_glGetActiveUniformBlockName;
-PFNGLGETBOOLEANI_VPROC glad_glGetBooleani_v;
-PFNGLBINDRENDERBUFFERPROC glad_glBindRenderbuffer;
-PFNGLSAMPLERPARAMETERIVPROC glad_glSamplerParameteriv;
-PFNGLTEXPARAMETERIUIVPROC glad_glTexParameterIuiv;
-PFNGLTEXSUBIMAGE3DPROC glad_glTexSubImage3D;
-PFNGLTEXPARAMETERFPROC glad_glTexParameterf;
-PFNGLVERTEXATTRIB4BVPROC glad_glVertexAttrib4bv;
-PFNGLDELETESYNCPROC glad_glDeleteSync;
-PFNGLPAUSETRANSFORMFEEDBACKPROC glad_glPauseTransformFeedback;
-PFNGLDRAWELEMENTSPROC glad_glDrawElements;
-PFNGLCLEARBUFFERUIVPROC glad_glClearBufferuiv;
-PFNGLDRAWARRAYSINSTANCEDPROC glad_glDrawArraysInstanced;
-PFNGLFRONTFACEPROC glad_glFrontFace;
-PFNGLCLEARDEPTHFPROC glad_glClearDepthf;
-PFNGLWAITSYNCPROC glad_glWaitSync;
-PFNGLVERTEXATTRIB1SPROC glad_glVertexAttrib1s;
-PFNGLCREATESHADERPROC glad_glCreateShader;
-PFNGLDEPTHRANGEFPROC glad_glDepthRangef;
-PFNGLGENTEXTURESPROC glad_glGenTextures;
-PFNGLVERTEXATTRIB4NUIVPROC glad_glVertexAttrib4Nuiv;
-PFNGLCLIENTWAITSYNCPROC glad_glClientWaitSync;
-PFNGLGETRENDERBUFFERPARAMETERIVPROC glad_glGetRenderbufferParameteriv;
-PFNGLGETBUFFERPARAMETERIVPROC glad_glGetBufferParameteriv;
-PFNGLGENVERTEXARRAYSPROC glad_glGenVertexArrays;
-PFNGLUNIFORM2FPROC glad_glUniform2f;
-PFNGLVERTEXP4UIVPROC glad_glVertexP4uiv;
-PFNGLCOLORP4UIVPROC glad_glColorP4uiv;
-PFNGLDELETERENDERBUFFERSPROC glad_glDeleteRenderbuffers;
-PFNGLVERTEXATTRIBP3UIPROC glad_glVertexAttribP3ui;
-PFNGLGETFRAGDATALOCATIONPROC glad_glGetFragDataLocation;
-PFNGLVERTEXATTRIB1FPROC glad_glVertexAttrib1f;
-PFNGLENDCONDITIONALRENDERPROC glad_glEndConditionalRender;
-PFNGLGETSHADERPRECISIONFORMATPROC glad_glGetShaderPrecisionFormat;
-PFNGLVERTEXATTRIB3FPROC glad_glVertexAttrib3f;
-PFNGLCOMPILESHADERPROC glad_glCompileShader;
-PFNGLFRAMEBUFFERTEXTURELAYERPROC glad_glFramebufferTextureLayer;
-PFNGLGENTRANSFORMFEEDBACKSPROC glad_glGenTransformFeedbacks;
-PFNGLUNIFORMMATRIX2X3FVPROC glad_glUniformMatrix2x3fv;
-PFNGLGETACTIVEATTRIBPROC glad_glGetActiveAttrib;
-PFNGLGETBUFFERPARAMETERI64VPROC glad_glGetBufferParameteri64v;
-PFNGLBINDBUFFERPROC glad_glBindBuffer;
-PFNGLMULTITEXCOORDP2UIPROC glad_glMultiTexCoordP2ui;
-PFNGLVERTEXATTRIBP1UIVPROC glad_glVertexAttribP1uiv;
-PFNGLPIXELSTOREIPROC glad_glPixelStorei;
-PFNGLLINKPROGRAMPROC glad_glLinkProgram;
-PFNGLVERTEXATTRIB3DPROC glad_glVertexAttrib3d;
-PFNGLGETQUERYOBJECTUI64VPROC glad_glGetQueryObjectui64v;
-PFNGLATTACHSHADERPROC glad_glAttachShader;
-PFNGLTEXIMAGE2DMULTISAMPLEPROC glad_glTexImage2DMultisample;
-PFNGLGETPROGRAMINFOLOGPROC glad_glGetProgramInfoLog;
-PFNGLSECONDARYCOLORP3UIVPROC glad_glSecondaryColorP3uiv;
-PFNGLGETUNIFORMFVPROC glad_glGetUniformfv;
-PFNGLVERTEXATTRIBI1IPROC glad_glVertexAttribI1i;
-PFNGLSTENCILFUNCPROC glad_glStencilFunc;
-PFNGLCOMPRESSEDTEXIMAGE3DPROC glad_glCompressedTexImage3D;
-PFNGLMULTITEXCOORDP4UIPROC glad_glMultiTexCoordP4ui;
-PFNGLVERTEXATTRIB4FVPROC glad_glVertexAttrib4fv;
-PFNGLGETINTEGERVPROC glad_glGetIntegerv;
-PFNGLGETPROGRAMBINARYPROC glad_glGetProgramBinary;
-PFNGLVERTEXATTRIB3DVPROC glad_glVertexAttrib3dv;
-PFNGLVIEWPORTPROC glad_glViewport;
-PFNGLTEXPARAMETERIPROC glad_glTexParameteri;
-PFNGLMULTIDRAWELEMENTSPROC glad_glMultiDrawElements;
-PFNGLDELETESHADERPROC glad_glDeleteShader;
-PFNGLVERTEXATTRIBPOINTERPROC glad_glVertexAttribPointer;
-PFNGLTEXIMAGE3DMULTISAMPLEPROC glad_glTexImage3DMultisample;
-PFNGLDELETEVERTEXARRAYSPROC glad_glDeleteVertexArrays;
-PFNGLUNMAPBUFFERPROC glad_glUnmapBuffer;
-PFNGLBUFFERDATAPROC glad_glBufferData;
-PFNGLPROVOKINGVERTEXPROC glad_glProvokingVertex;
-PFNGLISFRAMEBUFFERPROC glad_glIsFramebuffer;
-PFNGLTEXCOORDP1UIPROC glad_glTexCoordP1ui;
-PFNGLDEPTHMASKPROC glad_glDepthMask;
-PFNGLGETSTRINGPROC glad_glGetString;
-PFNGLVERTEXATTRIB4DPROC glad_glVertexAttrib4d;
-PFNGLTEXPARAMETERIVPROC glad_glTexParameteriv;
-PFNGLGETBOOLEANVPROC glad_glGetBooleanv;
-PFNGLUNIFORMMATRIX2FVPROC glad_glUniformMatrix2fv;
-PFNGLGETSAMPLERPARAMETERIIVPROC glad_glGetSamplerParameterIiv;
-PFNGLVERTEXATTRIB4NUBVPROC glad_glVertexAttrib4Nubv;
-PFNGLUNIFORMBLOCKBINDINGPROC glad_glUniformBlockBinding;
-PFNGLUNIFORM1UIVPROC glad_glUniform1uiv;
-PFNGLGENBUFFERSPROC glad_glGenBuffers;
-PFNGLGETUNIFORMIVPROC glad_glGetUniformiv;
-PFNGLVERTEXATTRIB4UIVPROC glad_glVertexAttrib4uiv;
-PFNGLTEXCOORDP2UIPROC glad_glTexCoordP2ui;
-PFNGLMULTITEXCOORDP3UIVPROC glad_glMultiTexCoordP3uiv;
-PFNGLBLITFRAMEBUFFERPROC glad_glBlitFramebuffer;
-PFNGLSAMPLECOVERAGEPROC glad_glSampleCoverage;
-PFNGLENABLEVERTEXATTRIBARRAYPROC glad_glEnableVertexAttribArray;
-PFNGLFRAMEBUFFERTEXTURE1DPROC glad_glFramebufferTexture1D;
-PFNGLDELETEQUERIESPROC glad_glDeleteQueries;
-PFNGLGETACTIVEUNIFORMBLOCKIVPROC glad_glGetActiveUniformBlockiv;
-PFNGLVERTEXATTRIB2DVPROC glad_glVertexAttrib2dv;
-PFNGLTEXIMAGE3DPROC glad_glTexImage3D;
-PFNGLVERTEXATTRIBI3UIPROC glad_glVertexAttribI3ui;
-PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC glad_glMultiDrawElementsBaseVertex;
-PFNGLGETMULTISAMPLEFVPROC glad_glGetMultisamplefv;
-PFNGLGETBUFFERSUBDATAPROC glad_glGetBufferSubData;
-PFNGLMULTITEXCOORDP1UIPROC glad_glMultiTexCoordP1ui;
-PFNGLPROGRAMBINARYPROC glad_glProgramBinary;
-PFNGLGETFRAGDATAINDEXPROC glad_glGetFragDataIndex;
-PFNGLSAMPLEMASKIPROC glad_glSampleMaski;
-PFNGLSHADERSOURCEPROC glad_glShaderSource;
-PFNGLBINDATTRIBLOCATIONPROC glad_glBindAttribLocation;
-PFNGLLOGICOPPROC glad_glLogicOp;
-PFNGLUNIFORM3UIPROC glad_glUniform3ui;
-PFNGLUNIFORMMATRIX4FVPROC glad_glUniformMatrix4fv;
-PFNGLVERTEXATTRIBI1IVPROC glad_glVertexAttribI1iv;
-PFNGLFRAMEBUFFERTEXTURE3DPROC glad_glFramebufferTexture3D;
-PFNGLUNIFORM4UIVPROC glad_glUniform4uiv;
-PFNGLTEXIMAGE1DPROC glad_glTexImage1D;
-PFNGLGETCOMPRESSEDTEXIMAGEPROC glad_glGetCompressedTexImage;
-PFNGLVERTEXATTRIB3SVPROC glad_glVertexAttrib3sv;
-PFNGLSTENCILMASKPROC glad_glStencilMask;
-PFNGLDRAWBUFFERPROC glad_glDrawBuffer;
-PFNGLTEXSUBIMAGE2DPROC glad_glTexSubImage2D;
-PFNGLGENSAMPLERSPROC glad_glGenSamplers;
-PFNGLINVALIDATESUBFRAMEBUFFERPROC glad_glInvalidateSubFramebuffer;
-PFNGLISQUERYPROC glad_glIsQuery;
-PFNGLGETQUERYIVPROC glad_glGetQueryiv;
-PFNGLVERTEXATTRIB1DVPROC glad_glVertexAttrib1dv;
-PFNGLBLENDCOLORPROC glad_glBlendColor;
-PFNGLMAPBUFFERRANGEPROC glad_glMapBufferRange;
-PFNGLDISABLEIPROC glad_glDisablei;
-PFNGLGETSHADERIVPROC glad_glGetShaderiv;
-PFNGLGETTEXPARAMETERIVPROC glad_glGetTexParameteriv;
-PFNGLDELETETRANSFORMFEEDBACKSPROC glad_glDeleteTransformFeedbacks;
-PFNGLISSYNCPROC glad_glIsSync;
-PFNGLBLENDEQUATIONSEPARATEPROC glad_glBlendEquationSeparate;
-PFNGLPOINTPARAMETERIVPROC glad_glPointParameteriv;
-PFNGLUNIFORM2IVPROC glad_glUniform2iv;
-PFNGLGETSAMPLERPARAMETERFVPROC glad_glGetSamplerParameterfv;
-PFNGLBLENDFUNCPROC glad_glBlendFunc;
-PFNGLTEXCOORDP2UIVPROC glad_glTexCoordP2uiv;
-PFNGLCHECKFRAMEBUFFERSTATUSPROC glad_glCheckFramebufferStatus;
-PFNGLUNIFORM1IVPROC glad_glUniform1iv;
-PFNGLGETQUERYOBJECTI64VPROC glad_glGetQueryObjecti64v;
-PFNGLNORMALP3UIPROC glad_glNormalP3ui;
-PFNGLGETACTIVEUNIFORMSIVPROC glad_glGetActiveUniformsiv;
-PFNGLUNIFORM3FVPROC glad_glUniform3fv;
-PFNGLBINDBUFFERBASEPROC glad_glBindBufferBase;
-PFNGLVERTEXATTRIBI3UIVPROC glad_glVertexAttribI3uiv;
-PFNGLVERTEXATTRIBI4UIVPROC glad_glVertexAttribI4uiv;
-PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC glad_glGetFramebufferAttachmentParameteriv;
-PFNGLTEXCOORDP3UIPROC glad_glTexCoordP3ui;
-PFNGLUNIFORMMATRIX4X2FVPROC glad_glUniformMatrix4x2fv;
-PFNGLUSEPROGRAMPROC glad_glUseProgram;
-PFNGLGETINTERNALFORMATIVPROC glad_glGetInternalformativ;
-PFNGLGETFLOATVPROC glad_glGetFloatv;
-PFNGLVERTEXATTRIBI3IVPROC glad_glVertexAttribI3iv;
-PFNGLDISABLEVERTEXATTRIBARRAYPROC glad_glDisableVertexAttribArray;
-PFNGLBLENDEQUATIONPROC glad_glBlendEquation;
 PFNGLGETINTEGER64VPROC glad_glGetInteger64v;
-PFNGLDELETEFRAMEBUFFERSPROC glad_glDeleteFramebuffers;
-PFNGLGETVERTEXATTRIBIUIVPROC glad_glGetVertexAttribIuiv;
-PFNGLVERTEXATTRIBI4UBVPROC glad_glVertexAttribI4ubv;
-PFNGLTEXCOORDP4UIPROC glad_glTexCoordP4ui;
-PFNGLSTENCILOPSEPARATEPROC glad_glStencilOpSeparate;
-PFNGLUNIFORM3FPROC glad_glUniform3f;
-PFNGLGETSTRINGIPROC glad_glGetStringi;
-PFNGLGETVERTEXATTRIBFVPROC glad_glGetVertexAttribfv;
-PFNGLVERTEXATTRIBI4IVPROC glad_glVertexAttribI4iv;
-PFNGLVERTEXATTRIB2FPROC glad_glVertexAttrib2f;
-PFNGLCOPYTEXIMAGE1DPROC glad_glCopyTexImage1D;
-PFNGLSAMPLERPARAMETERIPROC glad_glSamplerParameteri;
-PFNGLSAMPLERPARAMETERFVPROC glad_glSamplerParameterfv;
-PFNGLDRAWBUFFERSPROC glad_glDrawBuffers;
-PFNGLGENERATEMIPMAPPROC glad_glGenerateMipmap;
-PFNGLUNIFORM4IPROC glad_glUniform4i;
-PFNGLGETTEXPARAMETERIUIVPROC glad_glGetTexParameterIuiv;
-PFNGLGENQUERIESPROC glad_glGenQueries;
-PFNGLSTENCILOPPROC glad_glStencilOp;
-PFNGLGETERRORPROC glad_glGetError;
-PFNGLISSAMPLERPROC glad_glIsSampler;
-PFNGLVERTEXATTRIBI2IPROC glad_glVertexAttribI2i;
-PFNGLISBUFFERPROC glad_glIsBuffer;
-PFNGLVERTEXATTRIB4NUSVPROC glad_glVertexAttrib4Nusv;
-PFNGLCOPYTEXIMAGE2DPROC glad_glCopyTexImage2D;
-PFNGLCLAMPCOLORPROC glad_glClampColor;
-PFNGLGETSAMPLERPARAMETERIUIVPROC glad_glGetSamplerParameterIuiv;
-PFNGLGETQUERYOBJECTUIVPROC glad_glGetQueryObjectuiv;
-PFNGLTEXPARAMETERIIVPROC glad_glTexParameterIiv;
-PFNGLISVERTEXARRAYPROC glad_glIsVertexArray;
-PFNGLUNIFORM2UIPROC glad_glUniform2ui;
-PFNGLTEXCOORDP4UIVPROC glad_glTexCoordP4uiv;
-PFNGLMULTIDRAWARRAYSPROC glad_glMultiDrawArrays;
-PFNGLDELETEPROGRAMPROC glad_glDeleteProgram;
-PFNGLVERTEXATTRIBI4IPROC glad_glVertexAttribI4i;
-PFNGLACTIVETEXTUREPROC glad_glActiveTexture;
-PFNGLINVALIDATEFRAMEBUFFERPROC glad_glInvalidateFramebuffer;
-PFNGLVERTEXATTRIB4NBVPROC glad_glVertexAttrib4Nbv;
-PFNGLVERTEXATTRIB4UBVPROC glad_glVertexAttrib4ubv;
-PFNGLTEXIMAGE2DPROC glad_glTexImage2D;
-PFNGLCLEARDEPTHPROC glad_glClearDepth;
-PFNGLTEXSTORAGE3DPROC glad_glTexStorage3D;
-PFNGLFENCESYNCPROC glad_glFenceSync;
-PFNGLGETDOUBLEVPROC glad_glGetDoublev;
-PFNGLDISABLEPROC glad_glDisable;
-PFNGLGETPROGRAMIVPROC glad_glGetProgramiv;
-PFNGLGETVERTEXATTRIBPOINTERVPROC glad_glGetVertexAttribPointerv;
-PFNGLVERTEXATTRIBP4UIVPROC glad_glVertexAttribP4uiv;
-PFNGLCOLORMASKIPROC glad_glColorMaski;
-PFNGLFLUSHPROC glad_glFlush;
-PFNGLCLEARCOLORPROC glad_glClearColor;
-PFNGLCLEARBUFFERFVPROC glad_glClearBufferfv;
-PFNGLDRAWARRAYSPROC glad_glDrawArrays;
-PFNGLVERTEXATTRIBP1UIPROC glad_glVertexAttribP1ui;
-PFNGLVERTEXATTRIBI2IVPROC glad_glVertexAttribI2iv;
-PFNGLCLEARPROC glad_glClear;
-PFNGLBINDVERTEXARRAYPROC glad_glBindVertexArray;
-PFNGLMULTITEXCOORDP2UIVPROC glad_glMultiTexCoordP2uiv;
-PFNGLVERTEXATTRIB4NSVPROC glad_glVertexAttrib4Nsv;
-PFNGLDRAWRANGEELEMENTSPROC glad_glDrawRangeElements;
-PFNGLGETTEXLEVELPARAMETERIVPROC glad_glGetTexLevelParameteriv;
-PFNGLDEPTHFUNCPROC glad_glDepthFunc;
-PFNGLFLUSHMAPPEDBUFFERRANGEPROC glad_glFlushMappedBufferRange;
-PFNGLISRENDERBUFFERPROC glad_glIsRenderbuffer;
-PFNGLRESUMETRANSFORMFEEDBACKPROC glad_glResumeTransformFeedback;
-PFNGLVERTEXP3UIPROC glad_glVertexP3ui;
-PFNGLBINDBUFFERRANGEPROC glad_glBindBufferRange;
-PFNGLVERTEXP2UIPROC glad_glVertexP2ui;
-PFNGLCLEARBUFFERIVPROC glad_glClearBufferiv;
-PFNGLFRAMEBUFFERTEXTURE2DPROC glad_glFramebufferTexture2D;
-PFNGLVERTEXATTRIBI2UIVPROC glad_glVertexAttribI2uiv;
-PFNGLBINDFRAMEBUFFERPROC glad_glBindFramebuffer;
-PFNGLGENRENDERBUFFERSPROC glad_glGenRenderbuffers;
-PFNGLGETTEXPARAMETERIIVPROC glad_glGetTexParameterIiv;
-PFNGLNORMALP3UIVPROC glad_glNormalP3uiv;
-PFNGLREADBUFFERPROC glad_glReadBuffer;
-PFNGLVERTEXATTRIBP4UIPROC glad_glVertexAttribP4ui;
-PFNGLVERTEXATTRIB3FVPROC glad_glVertexAttrib3fv;
-PFNGLVERTEXATTRIB2SPROC glad_glVertexAttrib2s;
-PFNGLFRAMEBUFFERTEXTUREPROC glad_glFramebufferTexture;
-PFNGLVERTEXATTRIBDIVISORPROC glad_glVertexAttribDivisor;
-PFNGLBLENDFUNCSEPARATEPROC glad_glBlendFuncSeparate;
-PFNGLGETBUFFERPOINTERVPROC glad_glGetBufferPointerv;
-PFNGLPOLYGONOFFSETPROC glad_glPolygonOffset;
-PFNGLVERTEXATTRIB1DPROC glad_glVertexAttrib1d;
-PFNGLHINTPROC glad_glHint;
-PFNGLSAMPLERPARAMETERIUIVPROC glad_glSamplerParameterIuiv;
-PFNGLTEXSUBIMAGE1DPROC glad_glTexSubImage1D;
-PFNGLCOLORP3UIVPROC glad_glColorP3uiv;
-PFNGLUNIFORM3IPROC glad_glUniform3i;
 PFNGLGETUNIFORMLOCATIONPROC glad_glGetUniformLocation;
-PFNGLRELEASESHADERCOMPILERPROC glad_glReleaseShaderCompiler;
-PFNGLGETQUERYOBJECTIVPROC glad_glGetQueryObjectiv;
-PFNGLGETUNIFORMINDICESPROC glad_glGetUniformIndices;
-PFNGLVERTEXATTRIB4FPROC glad_glVertexAttrib4f;
-PFNGLGETUNIFORMUIVPROC glad_glGetUniformuiv;
-PFNGLTEXCOORDP3UIVPROC glad_glTexCoordP3uiv;
-PFNGLPIXELSTOREFPROC glad_glPixelStoref;
-PFNGLVERTEXATTRIBI1UIVPROC glad_glVertexAttribI1uiv;
-PFNGLVERTEXATTRIBP2UIVPROC glad_glVertexAttribP2uiv;
-PFNGLISENABLEDIPROC glad_glIsEnabledi;
-PFNGLSECONDARYCOLORP3UIPROC glad_glSecondaryColorP3ui;
-PFNGLSAMPLERPARAMETERIIVPROC glad_glSamplerParameterIiv;
-PFNGLVERTEXATTRIB4SPROC glad_glVertexAttrib4s;
-PFNGLCOPYTEXSUBIMAGE2DPROC glad_glCopyTexSubImage2D;
-PFNGLGETTRANSFORMFEEDBACKVARYINGPROC glad_glGetTransformFeedbackVarying;
+PFNGLCLEARSTENCILPROC glad_glClearStencil;
+PFNGLVERTEXATTRIB4NIVPROC glad_glVertexAttrib4Niv;
+PFNGLPOLYGONMODEPROC glad_glPolygonMode;
+PFNGLDELETEQUERIESPROC glad_glDeleteQueries;
+PFNGLVERTEXP3UIVPROC glad_glVertexP3uiv;
+PFNGLCLEARBUFFERFVPROC glad_glClearBufferfv;
+PFNGLTEXIMAGE1DPROC glad_glTexImage1D;
+PFNGLSHADERSOURCEPROC glad_glShaderSource;
+PFNGLGETMULTISAMPLEFVPROC glad_glGetMultisamplefv;
+PFNGLPOINTPARAMETERFVPROC glad_glPointParameterfv;
+PFNGLVERTEXATTRIB4FVPROC glad_glVertexAttrib4fv;
+PFNGLVERTEXATTRIB2SPROC glad_glVertexAttrib2s;
+PFNGLVERTEXATTRIB4NSVPROC glad_glVertexAttrib4Nsv;
+PFNGLVERTEXATTRIB3FVPROC glad_glVertexAttrib3fv;
+PFNGLVERTEXATTRIBP1UIPROC glad_glVertexAttribP1ui;
+PFNGLVERTEXP4UIVPROC glad_glVertexP4uiv;
+PFNGLGETSAMPLERPARAMETERIUIVPROC glad_glGetSamplerParameterIuiv;
+PFNGLDELETEPROGRAMPROC glad_glDeleteProgram;
+PFNGLISFRAMEBUFFERPROC glad_glIsFramebuffer;
+PFNGLUNIFORM4IPROC glad_glUniform4i;
+PFNGLENDTRANSFORMFEEDBACKPROC glad_glEndTransformFeedback;
+PFNGLCOMPRESSEDTEXIMAGE1DPROC glad_glCompressedTexImage1D;
+PFNGLBINDBUFFERPROC glad_glBindBuffer;
+PFNGLGETTEXLEVELPARAMETERIVPROC glad_glGetTexLevelParameteriv;
+PFNGLSAMPLEMASKIPROC glad_glSampleMaski;
+PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC glad_glGetFramebufferAttachmentParameteriv;
+PFNGLCOPYTEXIMAGE1DPROC glad_glCopyTexImage1D;
+PFNGLVERTEXATTRIBI4BVPROC glad_glVertexAttribI4bv;
+PFNGLVERTEXATTRIBP3UIVPROC glad_glVertexAttribP3uiv;
+PFNGLGETTEXPARAMETERIIVPROC glad_glGetTexParameterIiv;
+PFNGLBLENDFUNCSEPARATEPROC glad_glBlendFuncSeparate;
+PFNGLDRAWELEMENTSPROC glad_glDrawElements;
+PFNGLTEXIMAGE3DPROC glad_glTexImage3D;
+PFNGLDELETESHADERPROC glad_glDeleteShader;
+PFNGLVERTEXATTRIB4UIVPROC glad_glVertexAttrib4uiv;
+PFNGLUNIFORM2IPROC glad_glUniform2i;
+PFNGLGETSAMPLERPARAMETERIIVPROC glad_glGetSamplerParameterIiv;
+PFNGLGENTEXTURESPROC glad_glGenTextures;
 PFNGLVERTEXATTRIBI4UIPROC glad_glVertexAttribI4ui;
-PFNGLGETACTIVEUNIFORMNAMEPROC glad_glGetActiveUniformName;
-PFNGLGETVERTEXATTRIBDVPROC glad_glGetVertexAttribdv;
-PFNGLVERTEXATTRIB2DPROC glad_glVertexAttrib2d;
-PFNGLCOPYTEXSUBIMAGE1DPROC glad_glCopyTexSubImage1D;
+PFNGLVERTEXATTRIBI3UIVPROC glad_glVertexAttribI3uiv;
+PFNGLCOPYTEXSUBIMAGE2DPROC glad_glCopyTexSubImage2D;
+PFNGLDRAWBUFFERSPROC glad_glDrawBuffers;
+PFNGLENABLEIPROC glad_glEnablei;
+PFNGLPROGRAMBINARYPROC glad_glProgramBinary;
+PFNGLCOLORP3UIVPROC glad_glColorP3uiv;
+PFNGLUNIFORM4UIVPROC glad_glUniform4uiv;
+PFNGLGETVERTEXATTRIBIVPROC glad_glGetVertexAttribiv;
+PFNGLCLEARDEPTHPROC glad_glClearDepth;
+PFNGLTEXCOORDP3UIVPROC glad_glTexCoordP3uiv;
+PFNGLCOPYTEXSUBIMAGE3DPROC glad_glCopyTexSubImage3D;
+PFNGLVERTEXATTRIBI2UIVPROC glad_glVertexAttribI2uiv;
+PFNGLCOLORP4UIPROC glad_glColorP4ui;
+PFNGLLINKPROGRAMPROC glad_glLinkProgram;
+PFNGLGETUNIFORMBLOCKINDEXPROC glad_glGetUniformBlockIndex;
+PFNGLSAMPLERPARAMETERFPROC glad_glSamplerParameterf;
+PFNGLUNIFORM4FPROC glad_glUniform4f;
+PFNGLGETFRAGDATAINDEXPROC glad_glGetFragDataIndex;
+PFNGLVERTEXATTRIB2FVPROC glad_glVertexAttrib2fv;
+PFNGLGETFRAGDATALOCATIONPROC glad_glGetFragDataLocation;
+PFNGLGENFRAMEBUFFERSPROC glad_glGenFramebuffers;
+PFNGLTEXIMAGE2DPROC glad_glTexImage2D;
+PFNGLVERTEXATTRIB1DVPROC glad_glVertexAttrib1dv;
+PFNGLFRAMEBUFFERTEXTURE3DPROC glad_glFramebufferTexture3D;
+PFNGLVERTEXATTRIBI1IVPROC glad_glVertexAttribI1iv;
+PFNGLVERTEXATTRIB4SVPROC glad_glVertexAttrib4sv;
+PFNGLGETSHADERSOURCEPROC glad_glGetShaderSource;
+PFNGLBINDBUFFERBASEPROC glad_glBindBufferBase;
+PFNGLGETQUERYIVPROC glad_glGetQueryiv;
+PFNGLDRAWELEMENTSBASEVERTEXPROC glad_glDrawElementsBaseVertex;
+PFNGLUNIFORMMATRIX2X4FVPROC glad_glUniformMatrix2x4fv;
+PFNGLMULTITEXCOORDP3UIVPROC glad_glMultiTexCoordP3uiv;
+PFNGLMULTIDRAWARRAYSPROC glad_glMultiDrawArrays;
+PFNGLVERTEXATTRIB1FVPROC glad_glVertexAttrib1fv;
+PFNGLSECONDARYCOLORP3UIPROC glad_glSecondaryColorP3ui;
+PFNGLVERTEXATTRIBI3IVPROC glad_glVertexAttribI3iv;
+PFNGLVERTEXATTRIBI4UIVPROC glad_glVertexAttribI4uiv;
+PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC glad_glDrawElementsInstancedBaseVertex;
+PFNGLVERTEXATTRIB3DPROC glad_glVertexAttrib3d;
+PFNGLGETTEXLEVELPARAMETERFVPROC glad_glGetTexLevelParameterfv;
+PFNGLTRANSFORMFEEDBACKVARYINGSPROC glad_glTransformFeedbackVaryings;
+PFNGLBLITFRAMEBUFFERPROC glad_glBlitFramebuffer;
+PFNGLVERTEXATTRIBI1UIPROC glad_glVertexAttribI1ui;
+PFNGLTEXPARAMETERIIVPROC glad_glTexParameterIiv;
+PFNGLCULLFACEPROC glad_glCullFace;
+PFNGLGETACTIVEUNIFORMPROC glad_glGetActiveUniform;
+PFNGLFRONTFACEPROC glad_glFrontFace;
+PFNGLVERTEXATTRIBIPOINTERPROC glad_glVertexAttribIPointer;
+PFNGLVERTEXATTRIB3DVPROC glad_glVertexAttrib3dv;
+PFNGLBEGINCONDITIONALRENDERPROC glad_glBeginConditionalRender;
+PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC glad_glRenderbufferStorageMultisample;
+PFNGLTEXPARAMETERIPROC glad_glTexParameteri;
+PFNGLRELEASESHADERCOMPILERPROC glad_glReleaseShaderCompiler;
+PFNGLFRAMEBUFFERTEXTURE2DPROC glad_glFramebufferTexture2D;
+PFNGLCOMPRESSEDTEXIMAGE2DPROC glad_glCompressedTexImage2D;
+PFNGLDELETESAMPLERSPROC glad_glDeleteSamplers;
+PFNGLGENBUFFERSPROC glad_glGenBuffers;
+PFNGLMULTITEXCOORDP1UIPROC glad_glMultiTexCoordP1ui;
+PFNGLCREATESHADERPROC glad_glCreateShader;
+PFNGLDRAWRANGEELEMENTSPROC glad_glDrawRangeElements;
+PFNGLINVALIDATESUBFRAMEBUFFERPROC glad_glInvalidateSubFramebuffer;
+PFNGLGETINTEGERVPROC glad_glGetIntegerv;
+PFNGLUNIFORM2FPROC glad_glUniform2f;
 PFNGLENABLEPROC glad_glEnable;
-int GLAD_GL_ARB_instanced_arrays;
-int GLAD_GL_EXT_pixel_buffer_object;
-int GLAD_GL_ARB_pixel_buffer_object;
-int GLAD_GL_NV_instanced_arrays;
-int GLAD_GL_ARB_base_instance;
-int GLAD_GL_EXT_instanced_arrays;
-int GLAD_GL_ANGLE_depth_texture;
+PFNGLGETPROGRAMINFOLOGPROC glad_glGetProgramInfoLog;
+PFNGLGENSAMPLERSPROC glad_glGenSamplers;
+PFNGLTEXCOORDP4UIPROC glad_glTexCoordP4ui;
+PFNGLFRAMEBUFFERTEXTURE1DPROC glad_glFramebufferTexture1D;
+PFNGLTEXCOORDP4UIVPROC glad_glTexCoordP4uiv;
+PFNGLDRAWARRAYSINSTANCEDPROC glad_glDrawArraysInstanced;
+PFNGLISTRANSFORMFEEDBACKPROC glad_glIsTransformFeedback;
+PFNGLVERTEXATTRIBI4SVPROC glad_glVertexAttribI4sv;
+PFNGLUNIFORM4UIPROC glad_glUniform4ui;
+PFNGLUNIFORM4FVPROC glad_glUniform4fv;
+PFNGLVERTEXATTRIBI2IVPROC glad_glVertexAttribI2iv;
+PFNGLTEXBUFFERPROC glad_glTexBuffer;
+PFNGLGETPROGRAMIVPROC glad_glGetProgramiv;
+PFNGLFRAMEBUFFERTEXTURELAYERPROC glad_glFramebufferTextureLayer;
+PFNGLBINDTRANSFORMFEEDBACKPROC glad_glBindTransformFeedback;
+PFNGLVERTEXATTRIB3SVPROC glad_glVertexAttrib3sv;
+PFNGLSAMPLERPARAMETERIUIVPROC glad_glSamplerParameterIuiv;
+PFNGLFENCESYNCPROC glad_glFenceSync;
+PFNGLENABLEVERTEXATTRIBARRAYPROC glad_glEnableVertexAttribArray;
+int GLAD_GL_ARB_draw_buffers;
+int GLAD_GL_NV_draw_instanced;
+int GLAD_GL_EXT_draw_buffers;
 int GLAD_GL_NV_pixel_buffer_object;
+int GLAD_GL_ARB_base_instance;
 int GLAD_GL_EXT_base_instance;
 int GLAD_GL_ANGLE_instanced_arrays;
-int GLAD_GL_EXT_draw_instanced;
 int GLAD_GL_ATI_draw_buffers;
-int GLAD_GL_KHR_debug;
-int GLAD_GL_EXT_draw_buffers;
-int GLAD_GL_OES_depth_texture;
-int GLAD_GL_SGIX_depth_texture;
 int GLAD_GL_ARB_draw_instanced;
-int GLAD_GL_NV_draw_instanced;
 int GLAD_GL_ARB_debug_output;
-int GLAD_GL_ARB_draw_buffers;
+int GLAD_GL_ANGLE_depth_texture;
+int GLAD_GL_ARB_pixel_buffer_object;
+int GLAD_GL_ARB_texture_filter_anisotropic;
 int GLAD_GL_ARB_depth_texture;
+int GLAD_GL_ARB_instanced_arrays;
+int GLAD_GL_EXT_texture_filter_anisotropic;
+int GLAD_GL_EXT_draw_instanced;
+int GLAD_GL_EXT_pixel_buffer_object;
+int GLAD_GL_EXT_instanced_arrays;
+int GLAD_GL_NV_instanced_arrays;
+int GLAD_GL_SGIX_depth_texture;
+int GLAD_GL_OES_depth_texture;
+int GLAD_GL_KHR_debug;
 PFNGLDRAWARRAYSINSTANCEDBASEINSTANCEPROC glad_glDrawArraysInstancedBaseInstance;
 PFNGLDRAWELEMENTSINSTANCEDBASEINSTANCEPROC glad_glDrawElementsInstancedBaseInstance;
 PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEPROC glad_glDrawElementsInstancedBaseVertexBaseInstance;
@ -1103,9 +1107,11 @@ static int find_extensionsGL(void) {
 	GLAD_GL_ARB_draw_instanced = has_ext("GL_ARB_draw_instanced");
 	GLAD_GL_ARB_instanced_arrays = has_ext("GL_ARB_instanced_arrays");
 	GLAD_GL_ARB_pixel_buffer_object = has_ext("GL_ARB_pixel_buffer_object");
+	GLAD_GL_ARB_texture_filter_anisotropic = has_ext("GL_ARB_texture_filter_anisotropic");
 	GLAD_GL_ATI_draw_buffers = has_ext("GL_ATI_draw_buffers");
 	GLAD_GL_EXT_draw_instanced = has_ext("GL_EXT_draw_instanced");
 	GLAD_GL_EXT_pixel_buffer_object = has_ext("GL_EXT_pixel_buffer_object");
+	GLAD_GL_EXT_texture_filter_anisotropic = has_ext("GL_EXT_texture_filter_anisotropic");
 	GLAD_GL_KHR_debug = has_ext("GL_KHR_debug");
 	GLAD_GL_SGIX_depth_texture = has_ext("GL_SGIX_depth_texture");
 	free_exts();
@ -1488,6 +1494,7 @@ static int find_extensionsGLES2(void) {
 	GLAD_GL_EXT_draw_buffers = has_ext("GL_EXT_draw_buffers");
 	GLAD_GL_EXT_draw_instanced = has_ext("GL_EXT_draw_instanced");
 	GLAD_GL_EXT_instanced_arrays = has_ext("GL_EXT_instanced_arrays");
+	GLAD_GL_EXT_texture_filter_anisotropic = has_ext("GL_EXT_texture_filter_anisotropic");
 	GLAD_GL_KHR_debug = has_ext("GL_KHR_debug");
 	GLAD_GL_NV_draw_instanced = has_ext("GL_NV_draw_instanced");
 	GLAD_GL_NV_instanced_arrays = has_ext("GL_NV_instanced_arrays");