taisei/src/renderer/glcommon/opengl.c

/*
 * This software is licensed under the terms of the MIT License.
 * See COPYING for further information.
 * ---
 * Copyright (c) 2011-2019, Lukas Weber <laochailan@web.de>.
 * Copyright (c) 2012-2019, Andrei Alexeyev <akari@taisei-project.org>.
 */

#include "taisei.h"

#include "util.h"
#include "rwops/rwops_autobuf.h"
#include "opengl.h"
#include "debug.h"
#include "shaders.h"

// undef extension abstraction macros
#undef glDebugMessageControl
#undef glDebugMessageCallback
#undef glObjectLabel
#undef glDrawArraysInstanced
#undef glDrawElementsInstanced
#undef glVertexAttribDivisor
#undef glDrawArraysInstancedBaseInstance
#undef glDrawElementsInstancedBaseInstance
#undef glDrawBuffers
#undef glClearTexImage
// #undef glClearTexSubImage
#undef glBindVertexArray
#undef glDeleteVertexArrays
#undef glGenVertexArrays
#undef glIsVertexArray
#undef glGetFloati_v
#undef glViewportIndexedfv

struct glext_s glext;

typedef void (*glad_glproc_ptr)(void);

#ifndef STATIC_GLES3
//
//	Extension not yet handled by glad
//

// GL_ANGLE_base_vertex_base_instance
typedef void (APIENTRYP PFNGLDRAWARRAYSINSTANCEDBASEINSTANCEANGLEPROC)(GLenum mode, GLint first, GLsizei count, GLsizei instanceCount, GLuint baseInstance);
static PFNGLDRAWARRAYSINSTANCEDBASEINSTANCEANGLEPROC glad_glDrawArraysInstancedBaseInstanceANGLE;
typedef void (APIENTRYP PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEANGLEPROC)(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex, GLuint baseinstance);
static PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEANGLEPROC glad_glDrawElementsInstancedBaseVertexBaseInstanceANGLE;

APIENTRY
static void glad_glDrawElementsInstancedBaseInstanceANGLE(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLuint baseinstance) {
	// shim
	glad_glDrawElementsInstancedBaseVertexBaseInstanceANGLE(mode, count, type, indices, instancecount, 0, baseinstance);
}
#endif

// WEBGL_debug_renderer_info
const GLenum GL_UNMASKED_VENDOR_WEBGL = 0x9245;
const GLenum GL_UNMASKED_RENDERER_WEBGL = 0x9246;

static const char *const ext_vendor_table[] = {
	#define TSGL_EXT_VENDOR(v) [_TSGL_EXTVNUM_##v] = #v,
	TSGL_EXT_VENDORS
	#undef TSGL_EXT_VENDOR

	NULL,
};

static ext_flag_t glcommon_ext_flag(const char *ext) {
	assert(ext != NULL);
	ext = strchr(ext, '_');

	if(ext == NULL) {
		log_fatal("Bad extension string: %s", ext);
	}

	const char *sep = strchr(++ext, '_');

	if(sep == NULL) {
		log_fatal("Bad extension string: %s", ext);
	}

	char vendor[sep - ext + 1];
	strlcpy(vendor, ext, sizeof(vendor));

	for(const char *const *p = ext_vendor_table; *p; ++p) {
		if(!strcmp(*p, vendor)) {
			return 1 << (p - ext_vendor_table);
		}
	}

	log_fatal("Unknown vendor '%s' in extension string %s", vendor, ext);
}

ext_flag_t glcommon_check_extension(const char *ext) {
	assert(*ext != 0);
	assert(strchr(ext, ' ') == NULL);

	const char *overrides = env_get("TAISEI_GL_EXT_OVERRIDES", "");
	ext_flag_t flag = glcommon_ext_flag(ext);

	if(*overrides) {
		char buf[strlen(overrides)+1], *save, *arg, *e;
		strcpy(buf, overrides);
		arg = buf;

		while((e = strtok_r(arg, " ", &save))) {
			bool r = true;

			if(*e == '-') {
				++e;
				r = false;
			}

			if(!strcmp(e, ext)) {
				return r ? flag : 0;
			}

			arg = NULL;
		}
	}

	// SDL_GL_ExtensionSupported is stupid and requires dlopen() with emscripten.
	// Let's reinvent it!

	// SDL does this
	if(env_get_int(ext, 1) == 0) {
		return 0;
	}

#ifndef STATIC_GLES3
	if(GL_ATLEAST(3, 0) || GLES_ATLEAST(3, 0))
#endif
	{
		GLint num_exts = 0;
		glGetIntegerv(GL_NUM_EXTENSIONS, &num_exts);
		for(GLint i = 0; i < num_exts; ++i) {
			const char *e = (const char*)glGetStringi(GL_EXTENSIONS, i);
			if(!strcmp(ext, e)) {
				return flag;
			}
		}

		return 0;
	}

#ifndef STATIC_GLES3
	// The legacy way
	const char *extensions = (const char*)glGetString(GL_EXTENSIONS);

	if(!extensions) {
		return 0;
	}

	const char *start = extensions;
	size_t ext_len = strlen(ext);

	for(;;) {
		const char *where = strstr(start, ext);
		if(!where) {
			return 0;
		}

		const char *term = where + ext_len;

		if(
			(where == extensions || where[-1] == ' ') &&
			(*term == ' ' || *term == ' ')
		) {
			return flag;
		}
	}
#endif
}

ext_flag_t glcommon_require_extension(const char *ext) {
	ext_flag_t val = glcommon_check_extension(ext);

	if(!val) {
		if(env_get("TAISEI_GL_REQUIRE_EXTENSION_FATAL", 0)) {
			log_fatal("Required extension %s is not available", ext);
		}

		log_error("Required extension %s is not available, expect crashes or rendering errors", ext);
	}

	return val;
}

static void glcommon_ext_debug_output(void) {
#ifndef STATIC_GLES3
	if(
		GL_ATLEAST(4, 3)
		&& (glext.DebugMessageCallback = GL_FUNC(DebugMessageCallback))
		&& (glext.DebugMessageControl = GL_FUNC(DebugMessageControl))
		&& (glext.ObjectLabel = GL_FUNC(ObjectLabel))
	) {
		glext.debug_output = TSGL_EXTFLAG_NATIVE;
		log_info("Using core functionality");
		return;
	}

	if(glext.version.is_es) {
		if((glext.debug_output = glcommon_check_extension("GL_KHR_debug"))
			&& (glext.DebugMessageCallback = GL_FUNC(DebugMessageCallbackKHR))
			&& (glext.DebugMessageControl = GL_FUNC(DebugMessageControlKHR))
			&& (glext.ObjectLabel = GL_FUNC(ObjectLabelKHR))
		) {
			log_info("Using GL_KHR_debug");
			return;
		}
	} else {
		if((glext.debug_output = glcommon_check_extension("GL_KHR_debug"))
			&& (glext.DebugMessageCallback = GL_FUNC(DebugMessageCallback))
			&& (glext.DebugMessageControl = GL_FUNC(DebugMessageControl))
			&& (glext.ObjectLabel = GL_FUNC(ObjectLabel))
		) {
			log_info("Using GL_KHR_debug");
			return;
		}
	}

	if((glext.debug_output = glcommon_check_extension("GL_ARB_debug_output"))
		&& (glext.DebugMessageCallback = GL_FUNC(DebugMessageCallbackARB))
		&& (glext.DebugMessageControl = GL_FUNC(DebugMessageControlARB))
	) {
		log_info("Using GL_ARB_debug_output");
		return;
	}
#endif

	glext.debug_output = 0;
	log_warn("Extension not supported");
}

static void glcommon_ext_base_instance(void) {
#ifndef STATIC_GLES3
	if(
		GL_ATLEAST(4, 2)
		&& (glext.DrawArraysInstancedBaseInstance = GL_FUNC(DrawArraysInstancedBaseInstance))
		&& (glext.DrawElementsInstancedBaseInstance = GL_FUNC(DrawElementsInstancedBaseInstance))
	) {
		glext.base_instance = TSGL_EXTFLAG_NATIVE;
		log_info("Using core functionality");
		return;
	}

	if((glext.base_instance = glcommon_check_extension("GL_ARB_base_instance"))
		&& (glext.DrawArraysInstancedBaseInstance = GL_FUNC(DrawArraysInstancedBaseInstance))
		&& (glext.DrawElementsInstancedBaseInstance = GL_FUNC(DrawElementsInstancedBaseInstance))
	) {
		log_info("Using GL_ARB_base_instance");
		return;
	}

	if((glext.base_instance = glcommon_check_extension("GL_EXT_base_instance"))
		&& (glext.DrawArraysInstancedBaseInstance = GL_FUNC(DrawArraysInstancedBaseInstanceEXT))
		&& (glext.DrawElementsInstancedBaseInstance = GL_FUNC(DrawElementsInstancedBaseInstanceEXT))
	) {
		log_info("Using GL_EXT_base_instance");
		return;
	}

	if((glext.base_instance = glcommon_check_extension("GL_ANGLE_base_vertex_base_instance"))
		&& (glext.DrawArraysInstancedBaseInstance = GL_FUNC(DrawArraysInstancedBaseInstanceANGLE))
		&& (glext.DrawElementsInstancedBaseInstance = GL_FUNC(DrawElementsInstancedBaseInstanceANGLE))
	) {
		log_info("Using GL_ANGLE_base_vertex_base_instance");
		return;
	}
#endif

	glext.base_instance = 0;
	log_warn("Extension not supported");
}

static void glcommon_ext_pixel_buffer_object(void) {
#ifdef STATIC_GLES3
	glext.pixel_buffer_object = TSGL_EXTFLAG_NATIVE;
	log_info("Using core functionality");
	return;
#else
	// TODO: verify that these requirements are correct
	if(GL_ATLEAST(2, 0) || GLES_ATLEAST(3, 0)) {
		glext.pixel_buffer_object = TSGL_EXTFLAG_NATIVE;
		log_info("Using core functionality");
		return;
	}

	const char *exts[] = {
		"GL_ARB_pixel_buffer_object",
		"GL_EXT_pixel_buffer_object",
		"GL_NV_pixel_buffer_object",
		NULL
	};

	for(const char **p = exts; *p; ++p) {
		if((glext.pixel_buffer_object = glcommon_check_extension(*p))) {
			log_info("Using %s", *p);
			return;
		}
	}

	glext.pixel_buffer_object = 0;
	log_warn("Extension not supported");
#endif
}

static void glcommon_ext_depth_texture(void) {
#ifdef STATIC_GLES3
	glext.depth_texture = TSGL_EXTFLAG_NATIVE;
	log_info("Using core functionality");
	return;
#else
	// TODO: detect this for core OpenGL properly
	if(!glext.version.is_es || GLES_ATLEAST(3, 0)) {
		glext.depth_texture = TSGL_EXTFLAG_NATIVE;
		log_info("Using core functionality");
		return;
	}

	const char *exts[] = {
		"GL_OES_depth_texture",
		"GL_ANGLE_depth_texture",
		NULL
	};

	for(const char **p = exts; *p; ++p) {
		if((glext.pixel_buffer_object = glcommon_check_extension(*p))) {
			log_info("Using %s", *p);
			return;
		}
	}

	glext.depth_texture = 0;
	log_warn("Extension not supported");
#endif
}

static void glcommon_ext_instanced_arrays(void) {
#ifdef STATIC_GLES3
	glext.instanced_arrays = TSGL_EXTFLAG_NATIVE;
	log_info("Using core functionality");
	return;
#else
	if(
		(GL_ATLEAST(3, 3) || GLES_ATLEAST(3, 0))
		&& (glext.DrawArraysInstanced = GL_FUNC(DrawArraysInstanced))
		&& (glext.DrawElementsInstanced = GL_FUNC(DrawElementsInstanced))
		&& (glext.VertexAttribDivisor = GL_FUNC(VertexAttribDivisor))
	) {
		glext.instanced_arrays = TSGL_EXTFLAG_NATIVE;
		log_info("Using core functionality");
		return;
	}

	if((glext.instanced_arrays = glcommon_check_extension("GL_ARB_instanced_arrays"))
		&& (glext.DrawArraysInstanced = GL_FUNC(DrawArraysInstancedARB))
		&& (glext.DrawElementsInstanced = GL_FUNC(DrawElementsInstancedARB))
		&& (glext.VertexAttribDivisor = GL_FUNC(VertexAttribDivisorARB))
	) {
		log_info("Using GL_ARB_instanced_arrays (GL_ARB_draw_instanced assumed)");
		return;
	}

	if((glext.instanced_arrays = glcommon_check_extension("GL_EXT_instanced_arrays"))
		&& (glext.DrawArraysInstanced = GL_FUNC(DrawArraysInstancedEXT))
		&& (glext.DrawElementsInstanced = GL_FUNC(DrawElementsInstancedEXT))
		&& (glext.VertexAttribDivisor = GL_FUNC(VertexAttribDivisorEXT))
	) {
		log_info("Using GL_EXT_instanced_arrays");
		return;
	}

	if((glext.instanced_arrays = glcommon_check_extension("GL_ANGLE_instanced_arrays"))
		&& (glext.DrawArraysInstanced = GL_FUNC(DrawArraysInstancedANGLE))
		&& (glext.DrawElementsInstanced = GL_FUNC(DrawElementsInstancedANGLE))
		&& (glext.VertexAttribDivisor = GL_FUNC(VertexAttribDivisorANGLE))
	) {
		log_info("Using GL_ANGLE_instanced_arrays");
		return;
	}

	if((glext.instanced_arrays = glcommon_check_extension("GL_NV_instanced_arrays"))
		&& (glext.DrawArraysInstanced = GL_FUNC(DrawArraysInstancedNV))
		&& (glext.DrawElementsInstanced = GL_FUNC(DrawElementsInstancedNV))
		&& (glext.VertexAttribDivisor = GL_FUNC(VertexAttribDivisorNV))
	) {
		log_info("Using GL_NV_instanced_arrays (GL_NV_draw_instanced assumed)");
		return;
	}

	glext.instanced_arrays = 0;
	log_warn("Extension not supported");
#endif
}

static void glcommon_ext_draw_buffers(void) {
#ifdef STATIC_GLES3
	glext.draw_buffers = TSGL_EXTFLAG_NATIVE;
	log_info("Using core functionality");
	return;
#else
	if(
		(GL_ATLEAST(2, 0) || GLES_ATLEAST(3, 0))
		&& (glext.DrawBuffers = GL_FUNC(DrawBuffers))
	) {
		glext.draw_buffers = TSGL_EXTFLAG_NATIVE;
		log_info("Using core functionality");
		return;
	}

	if((glext.instanced_arrays = glcommon_check_extension("GL_ARB_draw_buffers"))
		&& (glext.DrawBuffers = GL_FUNC(DrawBuffersARB))
	) {
		log_info("Using GL_ARB_draw_buffers");
		return;
	}

	if((glext.instanced_arrays = glcommon_check_extension("GL_EXT_draw_buffers"))
		&& (glext.DrawBuffers = GL_FUNC(DrawBuffersEXT))
	) {
		log_info("Using GL_EXT_draw_buffers");
		return;
	}

	glext.draw_buffers = 0;
	log_warn("Extension not supported");
#endif
}

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");
}

static void glcommon_ext_clear_texture(void) {
#ifdef STATIC_GLES3
	if((glext.clear_texture = glcommon_check_extension("GL_EXT_clear_texture"))) {
		log_info("Using GL_EXT_clear_texture");
		return;
	}
#else
	if(
		GL_ATLEAST(4, 4)
		&& (glext.ClearTexImage = GL_FUNC(ClearTexImage))
	) {
		glext.clear_texture = TSGL_EXTFLAG_NATIVE;
		log_info("Using core functionality");
		return;
	}

	if((glext.clear_texture = glcommon_check_extension("GL_ARB_clear_texture"))
		&& (glext.ClearTexImage = GL_FUNC(ClearTexImage))
	) {
		log_info("Using GL_ARB_clear_texture");
		return;
	}

	if((glext.clear_texture = glcommon_check_extension("GL_EXT_clear_texture"))
		&& (glext.ClearTexImage = GL_FUNC(ClearTexImageEXT))
	) {
		log_info("Using GL_EXT_clear_texture");
		return;
	}
#endif

	glext.clear_texture = 0;
	log_warn("Extension not supported");
}

static void glcommon_ext_texture_norm16(void) {
	if(!glext.version.is_es) {
		glext.texture_norm16 = TSGL_EXTFLAG_NATIVE;
		log_info("Using core functionality");
		return;
	}

	if((glext.texture_norm16 = glcommon_check_extension("GL_EXT_texture_norm16"))) {
		log_info("Using GL_EXT_texture_norm16");
		return;
	}

	glext.texture_norm16 = 0;
	log_warn("Extension not supported");
}

static void glcommon_ext_texture_rg(void) {
	if(!glext.version.is_es) {
		glext.texture_rg = TSGL_EXTFLAG_NATIVE;
		log_info("Using core functionality");
		return;
	}

	if((glext.texture_rg = glcommon_check_extension("GL_EXT_texture_rg"))) {
		log_info("Using GL_EXT_texture_rg");
		return;
	}

	glext.texture_rg = 0;
	log_warn("Extension not supported");
}

static void glcommon_ext_texture_float_linear(void) {
	if(!glext.version.is_es) {
		glext.texture_float_linear = TSGL_EXTFLAG_NATIVE;
		log_info("Using core functionality");
		return;
	}

	if((glext.texture_float_linear = glcommon_check_extension("GL_OES_texture_float_linear"))) {
		log_info("Using GL_OES_texture_float_linear");
		return;
	}

	glext.texture_float_linear = 0;
	log_warn("Extension not supported");
}

static void glcommon_ext_texture_half_float_linear(void) {
	if(!glext.version.is_es) {
		glext.texture_half_float_linear = TSGL_EXTFLAG_NATIVE;
		log_info("Using core functionality");
		return;
	}

	if((glext.texture_half_float_linear = glcommon_check_extension("GL_OES_texture_half_float_linear"))) {
		log_info("Using GL_OES_texture_half_float_linear");
		return;
	}

	glext.texture_half_float_linear = 0;
	log_warn("Extension not supported");
}

static void glcommon_ext_color_buffer_float(void) {
	if(!glext.version.is_es) {
		glext.color_buffer_float = TSGL_EXTFLAG_NATIVE;
		log_info("Using core functionality");
		return;
	}

	if((glext.color_buffer_float = glcommon_check_extension("GL_EXT_color_buffer_float"))) {
		log_info("Using GL_EXT_color_buffer_float");
		return;
	}

	glext.color_buffer_float = 0;
	log_warn("Extension not supported");
}

static void glcommon_ext_float_blend(void) {
	if(!glext.version.is_es) {
		glext.float_blend = TSGL_EXTFLAG_NATIVE;
		log_info("Using core functionality");
		return;
	}

	if((glext.float_blend = glcommon_check_extension("GL_EXT_float_blend"))) {
		log_info("Using GL_EXT_float_blend");
		return;
	}

	glext.float_blend = 0;
	log_warn("Extension not supported");
}

static void glcommon_ext_vertex_array_object(void) {
#ifdef STATIC_GLES3
	glext.vertex_array_object = TSGL_EXTFLAG_NATIVE;
	log_info("Using core functionality");
	return;
#else
	if((GL_ATLEAST(3, 0) || GLES_ATLEAST(3, 0))
		&& (glext.BindVertexArray = GL_FUNC(BindVertexArray))
		&& (glext.DeleteVertexArrays = GL_FUNC(DeleteVertexArrays))
		&& (glext.GenVertexArrays = GL_FUNC(GenVertexArrays))
		&& (glext.IsVertexArray = GL_FUNC(IsVertexArray))
	) {
		glext.vertex_array_object = TSGL_EXTFLAG_NATIVE;
		log_info("Using core functionality");
		return;
	}

	if((glext.vertex_array_object = glcommon_check_extension("GL_ARB_vertex_array_object"))
		&& (glext.BindVertexArray = GL_FUNC(BindVertexArray))
		&& (glext.DeleteVertexArrays = GL_FUNC(DeleteVertexArrays))
		&& (glext.GenVertexArrays = GL_FUNC(GenVertexArrays))
		&& (glext.IsVertexArray = GL_FUNC(IsVertexArray))
	) {
		log_info("Using GL_ARB_vertex_array_object");
		return;
	}

	if((glext.vertex_array_object = glcommon_check_extension("GL_OES_vertex_array_object"))
		&& (glext.BindVertexArray = GL_FUNC(BindVertexArrayOES))
		&& (glext.DeleteVertexArrays = GL_FUNC(DeleteVertexArraysOES))
		&& (glext.GenVertexArrays = GL_FUNC(GenVertexArraysOES))
		&& (glext.IsVertexArray = GL_FUNC(IsVertexArrayOES))
	) {
		log_info("Using GL_OES_vertex_array_object");
		return;
	}

	if((glext.vertex_array_object = glcommon_check_extension("GL_APPLE_vertex_array_object"))
		&& (glext.BindVertexArray = GL_FUNC(BindVertexArrayAPPLE))
		&& (glext.DeleteVertexArrays = GL_FUNC(DeleteVertexArraysAPPLE))
		&& (glext.GenVertexArrays = GL_FUNC(GenVertexArraysAPPLE))
		&& (glext.IsVertexArray = GL_FUNC(IsVertexArrayAPPLE))
	) {
		log_info("Using GL_APPLE_vertex_array_object");
		return;
	}

	glext.vertex_array_object = 0;
	log_warn("Extension not supported");
#endif
}

static void glcommon_ext_viewport_array(void) {
#ifndef STATIC_GLES3
	if((GL_ATLEAST(4, 1))
		&& (glext.GetFloati_v = GL_FUNC(GetFloati_v))
		&& (glext.ViewportIndexedfv = GL_FUNC(ViewportIndexedfv))
	) {
		glext.viewport_array = TSGL_EXTFLAG_NATIVE;
		log_info("Using core functionality");
		return;
	}

	if((glext.viewport_array = glcommon_check_extension("GL_ARB_viewport_array"))
		&& (glext.GetFloati_v = GL_FUNC(GetFloati_v))
		&& (glext.ViewportIndexedfv = GL_FUNC(ViewportIndexedfv))
	) {
		log_info("Using GL_ARB_viewport_array");
		return;
	}

	if((glext.viewport_array = glcommon_check_extension("GL_OES_viewport_array"))
		&& (glext.GetFloati_v = GL_FUNC(GetFloati_vOES))
		&& (glext.ViewportIndexedfv = GL_FUNC(ViewportIndexedfvOES))
	) {
		log_info("Using GL_OES_viewport_array");
		return;
	}
#endif

	glext.viewport_array = 0;
	log_warn("Extension not supported");
}

#ifndef STATIC_GLES3
static APIENTRY GLvoid shim_glClearDepth(GLdouble depthval) {
	glClearDepthf(depthval);
}

static APIENTRY GLvoid shim_glClearDepthf(GLfloat depthval) {
	glClearDepth(depthval);
}
#endif

static const char *get_unmasked_property(GLenum prop, bool fallback) {
	const char *val = NULL;

	if(glext.version.is_webgl) {
		if(glcommon_check_extension("GL_WEBGL_debug_renderer_info")) {
			GLenum prop_unmasked;

			switch(prop) {
				case GL_VENDOR:   prop_unmasked = GL_UNMASKED_VENDOR_WEBGL;   break;
				case GL_RENDERER: prop_unmasked = GL_UNMASKED_RENDERER_WEBGL; break;
				default: UNREACHABLE;
			}

			val = (const char*)glGetString(prop_unmasked);

			if(!*val) {
				val = NULL;
			}
		}
	}

	if(val == NULL && fallback) {
		val = (const char*)glGetString(prop);
	}

	return val;
}

static void detect_broken_intel_driver(void) {
#ifdef TAISEI_BUILDCONF_WINDOWS_ANGLE_INTEL
	extern DECLSPEC int SDLCALL SDL_ShowMessageBox(const SDL_MessageBoxData *messageboxdata, int *buttonid);

	bool is_broken_intel_driver = (
		!glext.version.is_es &&
		strstartswith((const char*)glGetString(GL_VENDOR), "Intel") &&
		strstr((const char*)glGetString(GL_SHADING_LANGUAGE_VERSION), " - Build ")
	);

	if(!is_broken_intel_driver) {
		return;
	}

	int button;
	SDL_MessageBoxData mbdata = { 0 };

	mbdata.flags = SDL_MESSAGEBOX_WARNING;
	mbdata.title = "Taisei Project";

	char *msg = strfmt(
		"Looks like you have a broken OpenGL driver.\n"
		"Taisei will probably not work correctly, if at all.\n\n"
		"Starting the game in ANGLE mode should fix the problem, but may introduce slowdown.\n\n"
		"Restart in ANGLE mode now? (If unsure, press YES)"
	);

	mbdata.message = msg;
	mbdata.numbuttons = 3;
	mbdata.buttons = (SDL_MessageBoxButtonData[]) {
		{ SDL_MESSAGEBOX_BUTTON_ESCAPEKEY_DEFAULT, 2, "Abort" },
		{ 0, 1, "No" },
		{ SDL_MESSAGEBOX_BUTTON_RETURNKEY_DEFAULT, 0, "Yes (safe)" },
	};

	int mbresult = SDL_ShowMessageBox(&mbdata, &button);
	free(msg);

	if(mbresult < 0) {
		log_sdl_error(LOG_ERROR, "SDL_ShowMessageBox");
	} else if(button == 1) {
		return;
	} else if(button == 2) {
		exit(1);
	}

	const WCHAR *cmdline = GetCommandLine();
	const WCHAR renderer_args[] = L" --renderer gles30";
	WCHAR new_cmdline[wcslen(cmdline) + wcslen(renderer_args) + 1];
	memcpy(new_cmdline, cmdline, sizeof(WCHAR) * wcslen(cmdline));
	memcpy(new_cmdline + wcslen(cmdline), renderer_args, sizeof(renderer_args));

	PROCESS_INFORMATION pi;
	STARTUPINFO si = { sizeof(si) };

	CreateProcessW(
		NULL,
		new_cmdline,
		NULL,
		NULL,
		false,
		0,
		NULL,
		NULL,
		&si,
		&pi
	);

	exit(0);

#endif
}

static bool glcommon_check_workaround(const char *name, const char *envvar, const char *(*detect)(void)) {
	int env_setting = env_get_int(envvar, -1);
	glext.issues.avoid_sampler_uniform_updates = false;

	if(env_setting > 0) {
		log_warn("Enabled workaround `%s` (forced by environment)", name);
		return true;
	}

	if(env_setting == 0) {
		log_warn("Disabled workaround `%s` (forced by environment)", name);
		return false;
	}

	const char *reason = detect();
	if(reason != NULL) {
		log_warn("Enabled workaround `%s` (%s)", name, reason);
		return true;
	}

	log_info("Workaround `%s` not needed", name);
	return false;
}

#if defined(__EMSCRIPTEN__)
#include <emscripten.h>
EM_JS(bool, webgl_is_mac, (void), {
	try {
		return !!navigator.platform.match(/mac/i);
	} catch(e) {
		// whatever...
		return false;
	}
})
#endif

static const char *detect_slow_sampler_update(void) {
#if defined(__MACOSX__) || defined(__EMSCRIPTEN__)
	const char *gl_vendor = get_unmasked_property(GL_VENDOR, true);
	const char *gl_renderer = get_unmasked_property(GL_RENDERER, true);

	if(
#if defined(__EMSCRIPTEN__)
		webgl_is_mac() &&
#endif
		strstr(gl_renderer, "Radeon") && (                                  // This looks like an AMD Radeon card...
			(strstr(gl_vendor, "ATI") || strstr(gl_vendor, "AMD")) ||       // ...and AMD's official driver...
			(strstr(gl_vendor, "Google") && strstr(gl_renderer, "OpenGL"))  // ...or ANGLE, backed by OpenGL.
		)
	) {
		return "buggy AMD driver on macOS; see https://github.com/taisei-project/taisei/issues/182";
	}
#endif
	return NULL;
}

static void glcommon_check_issues(void) {
	glext.issues.avoid_sampler_uniform_updates = glcommon_check_workaround(
		"avoid sampler uniform updates",
		"TAISEI_GL_WORKAROUND_AVOID_SAMPLER_UNIFORM_UPDATES",
		detect_slow_sampler_update
	);
}

void glcommon_check_capabilities(void) {
	memset(&glext, 0, sizeof(glext));

	const char *glslv = (const char*)glGetString(GL_SHADING_LANGUAGE_VERSION);
	const char *glv = (const char*)glGetString(GL_VERSION);

#ifdef STATIC_GLES3
	GLint major, minor;
	glGetIntegerv(GL_MAJOR_VERSION, &major);
	glGetIntegerv(GL_MINOR_VERSION, &minor);
	glext.version.major = major;
	glext.version.minor = minor;
#else
	glext.version.major = GLVersion.major;
	glext.version.minor = GLVersion.minor;
#endif

	if(!glslv) {
		glslv = "None";
	}

	glext.version.is_es = strstartswith(glv, "OpenGL ES");

#ifdef STATIC_GLES3
	if(!GLES_ATLEAST(3, 0)) {
		log_fatal("Compiled with STATIC_GLES3, but got a non-GLES3 context. Can't work with this");
	}
#endif

	if(glext.version.is_es) {
		glext.version.is_ANGLE = strstr(glv, "(ANGLE ");
		glext.version.is_webgl = strstr(glv, "(WebGL ");
	}

	log_info("OpenGL version: %s", glv);
	log_info("OpenGL vendor: %s", (const char*)glGetString(GL_VENDOR));
	log_info("OpenGL renderer: %s", (const char*)glGetString(GL_RENDERER));

	if(glext.version.is_webgl) {
		const char *unmasked_vendor = get_unmasked_property(GL_VENDOR, false);
		const char *unmasked_renderer = get_unmasked_property(GL_RENDERER, false);
		log_info("OpenGL unmasked vendor: %s",   unmasked_vendor   ? unmasked_vendor   : "Unknown");
		log_info("OpenGL unmasked renderer: %s", unmasked_renderer ? unmasked_renderer : "Unknown");
	}

	log_info("GLSL version: %s", glslv);

	detect_broken_intel_driver();

	// XXX: this is the legacy way, maybe we shouldn't try this first
	const char *exts = (const char*)glGetString(GL_EXTENSIONS);

	if(exts) {
		log_info("Supported extensions: %s", exts);
	} else {
		void *buf;
		SDL_RWops *writer = SDL_RWAutoBuffer(&buf, 1024);
		GLint num_extensions;

		SDL_RWprintf(writer, "Supported extensions:");
		glGetIntegerv(GL_NUM_EXTENSIONS, &num_extensions);

		for(int i = 0; i < num_extensions; ++i) {
			SDL_RWprintf(writer, " %s", (const char*)glGetStringi(GL_EXTENSIONS, i));
		}

		SDL_WriteU8(writer, 0);
		log_info("%s", (char*)buf);
		SDL_RWclose(writer);
	}

	glcommon_ext_base_instance();
	glcommon_ext_clear_texture();
	glcommon_ext_color_buffer_float();
	glcommon_ext_debug_output();
	glcommon_ext_depth_texture();
	glcommon_ext_draw_buffers();
	glcommon_ext_float_blend();
	glcommon_ext_instanced_arrays();
	glcommon_ext_pixel_buffer_object();
	glcommon_ext_texture_filter_anisotropic();
	glcommon_ext_texture_float_linear();
	glcommon_ext_texture_half_float_linear();
	glcommon_ext_texture_norm16();
	glcommon_ext_texture_rg();
	glcommon_ext_vertex_array_object();
	glcommon_ext_viewport_array();

	// GLES has only glClearDepthf
	// Core has only glClearDepth until GL 4.1
#ifndef STATIC_GLES3
	assert(glClearDepth || glClearDepthf);

	if(!glClearDepth) {
		glClearDepth = shim_glClearDepth;
	}

	if(!glClearDepthf) {
		glClearDepthf = shim_glClearDepthf;
	}
#endif

	glcommon_build_shader_lang_table();
	glcommon_check_issues();
}

void glcommon_load_library(void) {
#ifndef STATIC_GLES3
	const char *lib = env_get("TAISEI_LIBGL", "");

	if(!*lib) {
		lib = NULL;
	}

	if(SDL_GL_LoadLibrary(lib) < 0) {
		log_fatal("SDL_GL_LoadLibrary() failed: %s", SDL_GetError());
	}
#endif
}

void glcommon_unload_library(void) {
#ifndef STATIC_GLES3
	SDL_GL_UnloadLibrary();
#endif
	glcommon_free_shader_lang_table();
}

attr_unused
static inline void (*load_func(const char *name))(void) {
	union {
		void *vp;
		void (*fp)(void);
	} c_sucks;
	c_sucks.vp = SDL_GL_GetProcAddress(name);
	return c_sucks.fp;
}

void glcommon_load_functions(void) {
#ifndef STATIC_GLES3
	int profile;

	if(SDL_GL_GetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, &profile) < 0) {
		log_fatal("SDL_GL_GetAttribute() failed: %s", SDL_GetError());
	}

	if(profile == SDL_GL_CONTEXT_PROFILE_ES) {
		if(!gladLoadGLES2Loader(SDL_GL_GetProcAddress)) {
			log_fatal("Failed to load OpenGL ES functions");
		}
	} else {
		if(!gladLoadGLLoader(SDL_GL_GetProcAddress)) {
			log_fatal("Failed to load OpenGL functions");
		}
	}

	glad_glDrawArraysInstancedBaseInstanceANGLE = (PFNGLDRAWARRAYSINSTANCEDBASEINSTANCEANGLEPROC)load_func("glDrawArraysInstancedBaseInstanceANGLE");
	glad_glDrawElementsInstancedBaseVertexBaseInstanceANGLE = (PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEANGLEPROC)load_func("glDrawElementsInstancedBaseVertexBaseInstanceANGLE");
#endif
}

void glcommon_setup_attributes(SDL_GLprofile profile, uint major, uint minor, SDL_GLcontextFlag ctxflags) {
	if(glcommon_debug_requested()) {
		ctxflags |= SDL_GL_CONTEXT_DEBUG_FLAG;
	}

	SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, profile);
	SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, major);
	SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, minor);

#ifndef __EMSCRIPTEN__
	SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
	SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 0);
	SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8);
	SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);
	SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);
	SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS, ctxflags);
#endif
}