diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 5197ab3d6..87676244f 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -26,6 +26,7 @@ add_executable(SRB2SDL2 MACOSX_BUNDLE WIN32
 	font.c
 	hu_stuff.c
 	i_time.c
+	i_video_common.cpp
 	y_inter.c
 	st_stuff.c
 	m_aatree.c
@@ -224,6 +225,9 @@ target_sources(SRB2SDL2 PRIVATE discord.c stun.c)
 target_link_libraries(SRB2SDL2 PRIVATE tcbrindle::span)
 target_link_libraries(SRB2SDL2 PRIVATE stb_vorbis)
 target_link_libraries(SRB2SDL2 PRIVATE xmp-lite::xmp-lite)
+target_link_libraries(SRB2SDL2 PRIVATE glad::glad)
+target_link_libraries(SRB2SDL2 PRIVATE fmt)
+target_link_libraries(SRB2SDL2 PRIVATE imgui::imgui)
 
 set(SRB2_HAVE_THREADS ON)
 target_compile_definitions(SRB2SDL2 PRIVATE -DHAVE_THREADS)
@@ -528,9 +532,12 @@ if(SRB2_CONFIG_PROFILEMODE AND "${CMAKE_C_COMPILER_ID}" STREQUAL "GNU")
 endif()
 
 add_subdirectory(audio)
+add_subdirectory(core)
+add_subdirectory(hwr2)
 add_subdirectory(io)
 add_subdirectory(sdl)
 add_subdirectory(objects)
+add_subdirectory(rhi)
 add_subdirectory(tests)
 add_subdirectory(menus)
 
diff --git a/src/core/CMakeLists.txt b/src/core/CMakeLists.txt
new file mode 100644
index 000000000..f4ee13e1f
--- /dev/null
+++ b/src/core/CMakeLists.txt
@@ -0,0 +1,3 @@
+target_sources(SRB2SDL2 PRIVATE
+	static_vec.hpp
+)
diff --git a/src/core/static_vec.hpp b/src/core/static_vec.hpp
new file mode 100644
index 000000000..f7bd26d69
--- /dev/null
+++ b/src/core/static_vec.hpp
@@ -0,0 +1,288 @@
+#ifndef __SRB2_CORE_STATIC_VEC_HPP__
+#define __SRB2_CORE_STATIC_VEC_HPP__
+
+#include <array>
+#include <cstddef>
+#include <cstdint>
+#include <functional>
+#include <iterator>
+#include <initializer_list>
+#include <stdexcept>
+#include <type_traits>
+
+#include "../cxxutil.hpp"
+
+namespace srb2 {
+
+template <typename T, size_t Limit>
+class StaticVec
+{
+	std::array<T, Limit> arr_ {{}};
+	size_t size_ = 0;
+
+public:
+	constexpr StaticVec() {}
+
+	StaticVec(const StaticVec& rhs)
+	{
+		for (size_t i = size_; i > 0; i--)
+		{
+			arr_[i] = T();
+		}
+		size_ = rhs.size();
+		for (size_t i = 0; i < size_; i++)
+		{
+			arr_[i] = rhs.arr_[i];
+		}
+	}
+
+	StaticVec(StaticVec&& rhs) noexcept(std::is_nothrow_move_assignable_v<T>)
+	{
+		for (size_t i = size_; i > 0; i--)
+		{
+			arr_[i] = T();
+		}
+		size_ = rhs.size();
+		for (size_t i = 0; i < size_; i++)
+		{
+			arr_[i] = std::move(rhs.arr_[i]);
+		}
+		while (rhs.size() > 0)
+		{
+			rhs.pop_back();
+		}
+	}
+
+	constexpr StaticVec(std::initializer_list<T> list) noexcept(std::is_nothrow_move_assignable_v<T>)
+	{
+		size_ = list.size();
+		size_t i = 0;
+		for (auto itr = list.begin(); itr != list.end(); itr++)
+		{
+			arr_[i] = *itr;
+			i++;
+		}
+	}
+
+	~StaticVec() = default;
+
+	StaticVec& operator=(const StaticVec& rhs)
+	{
+		for (size_t i = size_; i > 0; i--)
+		{
+			arr_[i] = T();
+		}
+		size_ = rhs.size();
+		for (size_t i = 0; i < size_; i++)
+		{
+			arr_[i] = rhs.arr_[i];
+		}
+		return *this;
+	}
+
+	StaticVec& operator=(StaticVec&& rhs) noexcept(std::is_nothrow_move_constructible_v<T>)
+	{
+		for (size_t i = size_; i > 0; i--)
+		{
+			arr_[i] = T();
+		}
+		size_ = rhs.size();
+		for (size_t i = 0; i < size_; i++)
+		{
+			arr_[i] = std::move(rhs.arr_[i]);
+		}
+		while (rhs.size() > 0)
+		{
+			rhs.pop_back();
+		}
+		return *this;
+	}
+
+	void push_back(const T& value)
+	{
+		arr_[size_++] = value;
+	}
+
+	void pop_back()
+	{
+		arr_[size_--] = T();
+	}
+
+	void resize(size_t size, T value = T())
+	{
+		if (size >= Limit)
+		{
+			throw std::length_error("new size >= Capacity");
+		}
+
+		if (size == size_)
+		{
+			return;
+		}
+		else if (size < size_)
+		{
+			while (size_ > size)
+			{
+				pop_back();
+			}
+		}
+		else
+		{
+			while (size_ < size)
+			{
+				push_back(value);
+			}
+		}
+	}
+
+	constexpr T* begin() noexcept
+	{
+		return &arr_[0];
+	}
+
+	constexpr const T* begin() const noexcept
+	{
+		return cbegin();
+	}
+
+	constexpr const T* cbegin() const noexcept
+	{
+		return &arr_[0];
+	}
+
+	constexpr T* end() noexcept
+	{
+		return &arr_[size_];
+	}
+
+	constexpr const T* end() const noexcept
+	{
+		return cend();
+	}
+
+	constexpr const T* cend() const noexcept
+	{
+		return &arr_[size_];
+	}
+
+	constexpr std::reverse_iterator<T*> rbegin() noexcept
+	{
+		return &arr_[size_];
+	}
+
+	constexpr std::reverse_iterator<const T*> crbegin() const noexcept
+	{
+		return &arr_[size_];
+	}
+
+	constexpr std::reverse_iterator<T*> rend() noexcept
+	{
+		return &arr_[0];
+	}
+
+	constexpr std::reverse_iterator<const T*> crend() const noexcept
+	{
+		return &arr_[0];
+	}
+
+	constexpr bool empty() const noexcept
+	{
+		return size_ == 0;
+	}
+
+	constexpr size_t size() const noexcept
+	{
+		return size_;
+	}
+
+	constexpr size_t capacity() const noexcept
+	{
+		return Limit;
+	}
+
+	constexpr size_t max_size() const noexcept
+	{
+		return Limit;
+	}
+
+	constexpr T& operator[](size_t index) noexcept
+	{
+		return arr_[index];
+	}
+
+	T& at(size_t index)
+	{
+		if (index >= size_)
+		{
+			throw std::out_of_range("index >= size");
+		}
+		return this[index];
+	}
+
+	constexpr const T& operator[](size_t index) const noexcept
+	{
+		return arr_[index];
+	}
+
+	const T& at(size_t index) const
+	{
+		if (index >= size_)
+		{
+			throw std::out_of_range("index >= size");
+		}
+		return this[index];
+	}
+
+	T& front()
+	{
+		return *arr_[0];
+	}
+
+	T& back()
+	{
+		return *arr_[size_ - 1];
+	}
+};
+
+} // namespace srb2
+
+template <typename T, size_t L1, size_t L2>
+bool operator==(const srb2::StaticVec<T, L1>& lhs, const srb2::StaticVec<T, L2>& rhs)
+{
+	const size_t size = lhs.size();
+	if (size != rhs.size())
+	{
+		return false;
+	}
+	for (size_t i = 0; i < lhs; i++) {
+		if (rhs[i] != lhs[i])
+		{
+			return false;
+		}
+	}
+	return true;
+}
+
+template <typename T, size_t L1, size_t L2>
+bool operator!=(const srb2::StaticVec<T, L1>& lhs, const srb2::StaticVec<T, L2>& rhs)
+{
+	return !(lhs == rhs);
+}
+
+template <typename T, size_t Limit>
+struct std::hash<srb2::StaticVec<T, Limit>>
+{
+	uint64_t operator()(const srb2::StaticVec<T, Limit>& input) const
+	{
+		constexpr const uint64_t prime { 0x00000100000001B3 };
+		std::size_t ret { 0xcbf29ce484222325 };
+
+		for (auto itr = input.begin(); itr != input.end(); itr++)
+		{
+			ret = (ret * prime) ^ std::hash<T>(*itr);
+		}
+		return ret;
+	}
+};
+
+#endif // __SRB2_CORE_STATIC_VEC_HPP__
diff --git a/src/d_main.c b/src/d_main.c
index 128fe9c0b..94183e53d 100644
--- a/src/d_main.c
+++ b/src/d_main.c
@@ -1115,6 +1115,7 @@ static void IdentifyVersion(void)
 #define PATCHNAME "MISC_SCRIPTS.pk3"
 #define UNLOCKNAME "MISC_UNLOCKS.pk3"
 #define MUSICNAME "MISC_MUSIC.PK3"
+#define SHADERSNAME "MISC_SHADERS.pk3"
 ////
 #else
 ////
@@ -1123,6 +1124,7 @@ static void IdentifyVersion(void)
 #define PATCHNAME "scripts.pk3"
 #define UNLOCKNAME "unlocks.pk3"
 #define MUSICNAME "music.pk3"
+#define SHADERSNAME "shaders.pk3"
 ////
 #endif
 ////
@@ -1140,6 +1142,7 @@ static void IdentifyVersion(void)
 #if defined(DEVELOP) && defined(UNLOCKTESTING)
 	D_AddFile(startupiwads, va(pandf,srb2waddir,UNLOCKNAME));
 #endif
+	D_AddFile(startupiwads, va(pandf,srb2waddir,SHADERSNAME));
 ////
 #undef TEXTURESNAME
 #undef MAPSNAME
diff --git a/src/hwr2/CMakeLists.txt b/src/hwr2/CMakeLists.txt
new file mode 100644
index 000000000..504818105
--- /dev/null
+++ b/src/hwr2/CMakeLists.txt
@@ -0,0 +1,8 @@
+target_sources(SRB2SDL2 PRIVATE
+	pass_imgui.cpp
+	pass_imgui.hpp
+	pass_software.cpp
+	pass_software.hpp
+	pass.cpp
+	pass.hpp
+)
diff --git a/src/hwr2/pass.cpp b/src/hwr2/pass.cpp
new file mode 100644
index 000000000..48b331492
--- /dev/null
+++ b/src/hwr2/pass.cpp
@@ -0,0 +1,3 @@
+#include "pass.hpp"
+
+srb2::hwr2::Pass::~Pass() = default;
diff --git a/src/hwr2/pass.hpp b/src/hwr2/pass.hpp
new file mode 100644
index 000000000..2556bf8f8
--- /dev/null
+++ b/src/hwr2/pass.hpp
@@ -0,0 +1,35 @@
+#ifndef __SRB2_HWR2_PASS_HPP__
+#define __SRB2_HWR2_PASS_HPP__
+
+#include "../rhi/rhi.hpp"
+
+namespace srb2::hwr2
+{
+
+/// @brief A rendering pass which performs logic during each phase of a frame render.
+/// During rendering, all registered Pass's individual stages will be run together.
+struct Pass {
+	virtual ~Pass();
+
+	/// @brief Perform rendering logic and create necessary GPU resources.
+	/// @param rhi
+	virtual void prepass(rhi::Rhi& rhi) = 0;
+
+	/// @brief Upload contents for needed GPU resources.
+	/// @param rhi
+	/// @param ctx
+	virtual void transfer(rhi::Rhi& rhi, rhi::Handle<rhi::TransferContext> ctx) = 0;
+
+	/// @brief Issue draw calls.
+	/// @param rhi
+	/// @param ctx
+	virtual void graphics(rhi::Rhi& rhi, rhi::Handle<rhi::GraphicsContext> ctx) = 0;
+
+	/// @brief Cleanup GPU resources. Transient resources should be cleaned up here.
+	/// @param rhi
+	virtual void postpass(rhi::Rhi& rhi) = 0;
+};
+
+} // namespace srb2::hwr2
+
+#endif // __SRB2_HWR2_PASS_HPP__
diff --git a/src/hwr2/pass_imgui.cpp b/src/hwr2/pass_imgui.cpp
new file mode 100644
index 000000000..6d8e02861
--- /dev/null
+++ b/src/hwr2/pass_imgui.cpp
@@ -0,0 +1,255 @@
+#include "pass_imgui.hpp"
+
+#include <imgui.h>
+
+#include "../v_video.h"
+
+using namespace srb2;
+using namespace srb2::hwr2;
+using namespace srb2::rhi;
+
+static const PipelineDesc kPipelineDesc =
+{
+	PipelineProgram::kUnshaded,
+	{
+		{
+			{sizeof(ImDrawVert)}
+		},
+		{
+			{VertexAttributeName::kPosition, 0, 0},
+			{VertexAttributeName::kTexCoord0, 0, 12},
+			{VertexAttributeName::kColor, 0, 24}
+		}
+	},
+	{{
+		{{UniformName::kProjection}},
+		{{UniformName::kModelView, UniformName::kTexCoord0Transform}}
+	}},
+	{{
+		SamplerName::kSampler0
+	}},
+	PipelineDepthAttachmentDesc {
+		PixelFormat::kDepth16,
+		CompareFunc::kAlways,
+		true
+	},
+	{
+		PixelFormat::kRGBA8,
+		BlendDesc {
+			BlendFactor::kSourceAlpha,
+			BlendFactor::kOneMinusSourceAlpha,
+			BlendFunction::kAdd,
+			BlendFactor::kOne,
+			BlendFactor::kOneMinusSourceAlpha,
+			BlendFunction::kAdd
+		},
+		{true, true, true, true}
+	},
+	PrimitiveType::kTriangles,
+	CullMode::kNone,
+	FaceWinding::kCounterClockwise,
+	{0.f, 0.f, 0.f, 1.f}
+};
+
+ImguiPass::~ImguiPass() = default;
+
+void ImguiPass::prepass(Rhi& rhi)
+{
+	if (!pipeline_)
+	{
+		pipeline_ = rhi.create_pipeline(kPipelineDesc);
+	}
+
+	ImGuiIO& io = ImGui::GetIO();
+
+	if (!font_atlas_)
+	{
+		unsigned char* pixels;
+		int width;
+		int height;
+		io.Fonts->GetTexDataAsRGBA32(&pixels, &width, &height);
+
+		uint32_t uwidth = static_cast<uint32_t>(width);
+		uint32_t uheight = static_cast<uint32_t>(height);
+
+		font_atlas_ = rhi.create_texture({TextureFormat::kRGBA, uwidth, uheight});
+		io.Fonts->SetTexID(font_atlas_);
+	}
+
+	ImGui::Render();
+
+	ImDrawData* data = ImGui::GetDrawData();
+	ImVec2 clip_off(data->DisplayPos);
+	ImVec2 clip_scale(data->FramebufferScale);
+	tcb::span<ImDrawList*> draw_lists = tcb::span(data->CmdLists, data->CmdListsCount);
+
+	for (auto list : draw_lists)
+	{
+		Handle<Buffer> vbo = rhi.create_buffer(
+			{
+				static_cast<uint32_t>(list->VtxBuffer.size_in_bytes()),
+				BufferType::kVertexBuffer,
+				BufferUsage::kImmutable
+			}
+		);
+		Handle<Buffer> ibo = rhi.create_buffer(
+			{
+				static_cast<uint32_t>(list->IdxBuffer.size_in_bytes()),
+				BufferType::kIndexBuffer,
+				BufferUsage::kImmutable
+			}
+		);
+
+		DrawList hwr2_list;
+		hwr2_list.list = list;
+		hwr2_list.vbo = vbo;
+		hwr2_list.ibo = ibo;
+
+		for (auto& cmd : list->CmdBuffer)
+		{
+			if (cmd.UserCallback)
+			{
+				cmd.UserCallback(list, &cmd);
+				continue;
+			}
+
+			ImVec2 clip_min((cmd.ClipRect.x - clip_off.x) * clip_scale.x, (cmd.ClipRect.y - clip_off.y) * clip_scale.y);
+			ImVec2 clip_max((cmd.ClipRect.z - clip_off.x) * clip_scale.x, (cmd.ClipRect.w - clip_off.y) * clip_scale.y);
+			if (clip_max.x <= clip_min.x || clip_max.y <= clip_min.y)
+			{
+				continue;
+			}
+
+			DrawCmd draw_cmd;
+			ImTextureID tex_id = cmd.GetTexID();
+			draw_cmd.tex = tex_id;
+			draw_cmd.v_offset = cmd.VtxOffset;
+			draw_cmd.i_offset = cmd.IdxOffset;
+			draw_cmd.elems = cmd.ElemCount;
+			draw_cmd.clip =
+			{
+				static_cast<int32_t>(clip_min.x),
+				static_cast<int32_t>((data->DisplaySize.y * data->FramebufferScale.y) - clip_max.y),
+				static_cast<uint32_t>(clip_max.x - clip_min.x),
+				static_cast<uint32_t>(clip_max.y - clip_min.y)
+			};
+			hwr2_list.cmds.push_back(std::move(draw_cmd));
+		}
+		draw_lists_.push_back(std::move(hwr2_list));
+	}
+}
+
+void ImguiPass::transfer(Rhi& rhi, Handle<TransferContext> ctx)
+{
+	ImGuiIO& io = ImGui::GetIO();
+
+	{
+		unsigned char* pixels;
+		int width, height;
+		io.Fonts->GetTexDataAsRGBA32(&pixels, &width, &height);
+		rhi.update_texture(
+			ctx,
+			font_atlas_,
+			{0, 0, static_cast<uint32_t>(width), static_cast<uint32_t>(height)},
+			rhi::PixelFormat::kRGBA8,
+			tcb::as_bytes(tcb::span(pixels, static_cast<size_t>(width * height * 4)))
+		);
+	}
+
+	for (auto& draw_list : draw_lists_)
+	{
+		Handle<Buffer> vbo = draw_list.vbo;
+		Handle<Buffer> ibo = draw_list.ibo;
+
+		ImDrawList* im_list = static_cast<ImDrawList*>(draw_list.list);
+
+		for (auto& vtx : im_list->VtxBuffer)
+		{
+			vtx.pos.z = 0.f;
+			vtx.colf[0] = ((vtx.col & 0xFF) >> 0) / 255.f;
+			vtx.colf[1] = ((vtx.col & 0xFF00) >> 8) / 255.f;
+			vtx.colf[2] = ((vtx.col & 0xFF0000) >> 16) / 255.f;
+			vtx.colf[3] = ((vtx.col & 0xFF000000) >> 24) / 255.f;
+		}
+
+		tcb::span<ImDrawVert> vert_span = tcb::span(im_list->VtxBuffer.Data, im_list->VtxBuffer.size());
+		rhi.update_buffer_contents(ctx, vbo, 0, tcb::as_bytes(vert_span));
+
+		tcb::span<ImDrawIdx> index_span = tcb::span(im_list->IdxBuffer.Data, im_list->IdxBuffer.size());
+		rhi.update_buffer_contents(ctx, ibo, 0, tcb::as_bytes(index_span));
+
+		// Uniform sets
+		std::array<UniformVariant, 1> g1_uniforms =
+		{{
+			// Projection
+			std::array<std::array<float, 4>, 4>
+			{{
+				{2.f / vid.realwidth, 0.f, 0.f, 0.f},
+				{0.f, 2.f / vid.realheight, 0.f, 0.f},
+				{0.f, 0.f, 1.f, 0.f},
+				{-1.f, 1.f, 0.f, 1.f}
+			}},
+		}};
+		std::array<UniformVariant, 2> g2_uniforms =
+		{{
+			// ModelView
+			std::array<std::array<float, 4>, 4>
+			{{
+				{1.f, 0.f, 0.f, 0.f},
+				{0.f, -1.f, 0.f, 0.f},
+				{0.f, 0.f, 1.f, 0.f},
+				{0.f, 0, 0.f, 1.f}
+			}},
+			// Texcoord0 Transform
+			std::array<std::array<float, 3>, 3>
+			{{
+				{1.f, 0.f, 0.f},
+				{0.f, 1.f, 0.f},
+				{0.f, 0.f, 1.f}
+			}}
+		}};
+		Handle<UniformSet> us_1 = rhi.create_uniform_set(ctx, {g1_uniforms});
+		Handle<UniformSet> us_2 = rhi.create_uniform_set(ctx, {g2_uniforms});
+
+		draw_list.us_1 = us_1;
+		draw_list.us_2 = us_2;
+
+		for (auto& draw_cmd : draw_list.cmds)
+		{
+			// Binding set
+			std::array<rhi::VertexAttributeBufferBinding, 1> vbos = {{0, vbo}};
+			std::array<rhi::TextureBinding, 1> tbs = {{{rhi::SamplerName::kSampler0, draw_cmd.tex}}};
+			rhi::Handle<rhi::BindingSet> binding_set = rhi.create_binding_set(ctx, pipeline_, {vbos, tbs});
+			draw_cmd.binding_set = binding_set;
+		}
+	}
+}
+
+void ImguiPass::graphics(Rhi& rhi, Handle<GraphicsContext> ctx)
+{
+	rhi.begin_default_render_pass(ctx, false);
+	rhi.bind_pipeline(ctx, pipeline_);
+	for (auto& draw_list : draw_lists_)
+	{
+		rhi.bind_uniform_set(ctx, 0, draw_list.us_1);
+		rhi.bind_uniform_set(ctx, 1, draw_list.us_2);
+		for (auto& cmd : draw_list.cmds)
+		{
+			rhi.bind_binding_set(ctx, cmd.binding_set);
+			rhi.bind_index_buffer(ctx, draw_list.ibo);
+			rhi.set_scissor(ctx, cmd.clip);
+			rhi.draw_indexed(ctx, cmd.elems, cmd.i_offset);
+		}
+	}
+	rhi.end_render_pass(ctx);
+}
+
+void ImguiPass::postpass(Rhi& rhi)
+{
+	for (auto& list : draw_lists_)
+	{
+		rhi.destroy_buffer(list.vbo);
+		rhi.destroy_buffer(list.ibo);
+	}
+	draw_lists_.clear();
+}
diff --git a/src/hwr2/pass_imgui.hpp b/src/hwr2/pass_imgui.hpp
new file mode 100644
index 000000000..280e7fc9c
--- /dev/null
+++ b/src/hwr2/pass_imgui.hpp
@@ -0,0 +1,52 @@
+#ifndef __SRB2_HWR2_PASS_IMGUI_HPP__
+#define __SRB2_HWR2_PASS_IMGUI_HPP__
+
+#include <vector>
+
+#include "../rhi/rhi.hpp"
+#include "pass.hpp"
+
+namespace srb2::hwr2
+{
+
+class ImguiPass : public Pass
+{
+	struct DrawCmd
+	{
+		rhi::Handle<rhi::Texture> tex;
+		uint32_t v_offset;
+		uint32_t elems;
+		uint32_t i_offset;
+		rhi::Rect clip;
+		rhi::Handle<rhi::BindingSet> binding_set;
+	};
+	struct DrawList
+	{
+		void* list;
+		rhi::Handle<rhi::Buffer> vbo;
+		rhi::Handle<rhi::Buffer> ibo;
+		rhi::Handle<rhi::UniformSet> us_1;
+		rhi::Handle<rhi::UniformSet> us_2;
+		std::vector<DrawCmd> cmds;
+	};
+
+	rhi::Handle<rhi::Pipeline> pipeline_;
+	rhi::Handle<rhi::Texture> font_atlas_;
+
+	std::vector<DrawList> draw_lists_;
+
+public:
+	virtual ~ImguiPass();
+
+	virtual void prepass(rhi::Rhi& rhi) override;
+
+	virtual void transfer(rhi::Rhi& rhi, rhi::Handle<rhi::TransferContext> ctx) override;
+
+	virtual void graphics(rhi::Rhi& rhi, rhi::Handle<rhi::GraphicsContext> ctx) override;
+
+	virtual void postpass(rhi::Rhi& rhi) override;
+};
+
+} // namespace srb2::hwr2
+
+#endif // __SRB2_HWR2_PASS_IMGUI_HPP__
diff --git a/src/hwr2/pass_software.cpp b/src/hwr2/pass_software.cpp
new file mode 100644
index 000000000..4876a52cd
--- /dev/null
+++ b/src/hwr2/pass_software.cpp
@@ -0,0 +1,284 @@
+#include "pass_software.hpp"
+
+#include <optional>
+
+#include <tcb/span.hpp>
+
+#include "../cxxutil.hpp"
+#include "../d_netcmd.h"
+#ifdef HAVE_DISCORDRPC
+#include "../discord.h"
+#endif
+#include "../doomstat.h"
+#include "../st_stuff.h"
+#include "../s_sound.h"
+#include "../v_video.h"
+
+using namespace srb2;
+using namespace srb2::hwr2;
+using namespace srb2::rhi;
+
+SoftwareBlitPass::~SoftwareBlitPass() = default;
+
+namespace
+{
+struct SwBlitVertex
+{
+	float x = 0.f;
+	float y = 0.f;
+	float z = 0.f;
+	float u = 0.f;
+	float v = 0.f;
+};
+} // namespace
+
+static const SwBlitVertex kVerts[] =
+{
+	{-.5f, -.5f, 0.f, 0.f, 0.f},
+	{.5f, -.5f, 0.f, 1.f, 0.f},
+	{-.5f, .5f, 0.f, 0.f, 1.f},
+	{.5f, .5f, 0.f, 1.f, 1.f}
+};
+
+static const uint16_t kIndices[] = {0, 1, 2, 1, 3, 2};
+
+static const PipelineDesc kPipelineDescription =
+{
+	PipelineProgram::kUnshadedPaletted,
+	{
+		{
+			{sizeof(SwBlitVertex)}
+		},
+		{
+			{VertexAttributeName::kPosition, 0, 0},
+			{VertexAttributeName::kTexCoord0, 0, 12}
+		}
+	},
+	{{
+		{{UniformName::kProjection}},
+		{{UniformName::kModelView, UniformName::kTexCoord0Transform}}
+	}},
+	{{
+		// R8 index texture
+		SamplerName::kSampler0,
+		// 256x1 palette texture
+		SamplerName::kSampler1
+	}},
+	std::nullopt,
+	{
+		PixelFormat::kRGBA8,
+		std::nullopt,
+		{true, true, true, true}
+	},
+	PrimitiveType::kTriangles,
+	CullMode::kNone,
+	FaceWinding::kCounterClockwise,
+	{0.f, 0.f, 0.f, 1.f}
+};
+
+static uint32_t next_pow_of_2(uint32_t in)
+{
+	in--;
+	in |= in >> 1;
+	in |= in >> 2;
+	in |= in >> 4;
+	in |= in >> 8;
+	in |= in >> 16;
+	in++;
+	return in;
+}
+
+static void temp_legacy_finishupdate_draws()
+{
+	SCR_CalculateFPS();
+	if (st_overlay)
+	{
+		if (cv_ticrate.value)
+			SCR_DisplayTicRate();
+
+		if (cv_showping.value && netgame &&
+				( consoleplayer != serverplayer || ! server_lagless ))
+		{
+			if (server_lagless)
+			{
+				if (consoleplayer != serverplayer)
+					SCR_DisplayLocalPing();
+			}
+			else
+			{
+				for (
+						int player = 1;
+						player < MAXPLAYERS;
+						player++
+				){
+					if (D_IsPlayerHumanAndGaming(player))
+					{
+						SCR_DisplayLocalPing();
+						break;
+					}
+				}
+			}
+		}
+		if (cv_mindelay.value && consoleplayer == serverplayer && Playing())
+			SCR_DisplayLocalPing();
+	}
+
+	if (marathonmode)
+		SCR_DisplayMarathonInfo();
+
+	// draw captions if enabled
+	if (cv_closedcaptioning.value)
+		SCR_ClosedCaptions();
+
+#ifdef HAVE_DISCORDRPC
+	if (discordRequestList != NULL)
+		ST_AskToJoinEnvelope();
+#endif
+}
+
+void SoftwareBlitPass::prepass(Rhi& rhi)
+{
+	if (!pipeline_)
+	{
+		pipeline_ = rhi.create_pipeline(kPipelineDescription);
+	}
+
+	if (!quad_vbo_)
+	{
+		quad_vbo_ = rhi.create_buffer({sizeof(kVerts), BufferType::kVertexBuffer, BufferUsage::kImmutable});
+		quad_vbo_needs_upload_ = true;
+	}
+
+	if (!quad_ibo_)
+	{
+		quad_ibo_ = rhi.create_buffer({sizeof(kIndices), BufferType::kIndexBuffer, BufferUsage::kImmutable});
+		quad_ibo_needs_upload_ = true;
+	}
+
+	temp_legacy_finishupdate_draws();
+
+	uint32_t vid_width = static_cast<uint32_t>(vid.width);
+	uint32_t vid_height = static_cast<uint32_t>(vid.height);
+
+	if (screen_tex_ && (screen_tex_width_ < vid_width || screen_tex_height_ < vid_height))
+	{
+		rhi.destroy_texture(screen_tex_);
+		screen_tex_ = kNullHandle;
+	}
+
+	if (!screen_tex_)
+	{
+		screen_tex_width_ = next_pow_of_2(vid_width);
+		screen_tex_height_ = next_pow_of_2(vid_height);
+		screen_tex_ = rhi.create_texture({TextureFormat::kLuminance, screen_tex_width_, screen_tex_height_});
+	}
+
+	if (!palette_tex_)
+	{
+		palette_tex_ = rhi.create_texture({TextureFormat::kRGBA, 256, 1});
+	}
+}
+
+void SoftwareBlitPass::upload_screen(Rhi& rhi, Handle<TransferContext> ctx)
+{
+	rhi::Rect screen_rect = {
+		0,
+		0,
+		static_cast<uint32_t>(vid.width),
+		static_cast<uint32_t>(vid.height)
+	};
+
+	tcb::span<uint8_t> screen_span = tcb::span(vid.buffer, static_cast<size_t>(vid.width * vid.height));
+	rhi.update_texture(ctx, screen_tex_, screen_rect, rhi::PixelFormat::kR8, tcb::as_bytes(screen_span));
+}
+
+void SoftwareBlitPass::upload_palette(Rhi& rhi, Handle<TransferContext> ctx)
+{
+	// Unfortunately, pMasterPalette must be swizzled to get a linear layout.
+	// Maybe some adjustments to palette storage can make this a straight upload.
+	std::array<byteColor_t, 256> palette_32;
+	for (size_t i = 0; i < 256; i++)
+	{
+		palette_32[i] = pMasterPalette[i].s;
+	}
+	rhi.update_texture(ctx, palette_tex_, {0, 0, 256, 1}, rhi::PixelFormat::kRGBA8, tcb::as_bytes(tcb::span(palette_32)));
+}
+
+void SoftwareBlitPass::transfer(Rhi& rhi, Handle<TransferContext> ctx)
+{
+	if (quad_vbo_needs_upload_ && quad_vbo_)
+	{
+		rhi.update_buffer_contents(ctx, quad_vbo_, 0, tcb::as_bytes(tcb::span(kVerts)));
+		quad_vbo_needs_upload_ = false;
+	}
+
+	if (quad_ibo_needs_upload_ && quad_ibo_)
+	{
+		rhi.update_buffer_contents(ctx, quad_ibo_, 0, tcb::as_bytes(tcb::span(kIndices)));
+		quad_ibo_needs_upload_ = false;
+	}
+
+	upload_screen(rhi, ctx);
+	upload_palette(rhi, ctx);
+
+	// Calculate aspect ratio for black borders
+	float aspect = static_cast<float>(vid.width) / static_cast<float>(vid.height);
+	float real_aspect = static_cast<float>(vid.realwidth) / static_cast<float>(vid.realheight);
+	bool taller = aspect > real_aspect;
+
+	std::array<rhi::UniformVariant, 1> g1_uniforms = {{
+		// Projection
+		std::array<std::array<float, 4>, 4> {{
+			{taller ? 1.f : 1.f / real_aspect, 0.f, 0.f, 0.f},
+			{0.f, taller ? -1.f / (1.f / real_aspect) : -1.f, 0.f, 0.f},
+			{0.f, 0.f, 1.f, 0.f},
+			{0.f, 0.f, 0.f, 1.f}
+		}},
+	}};
+
+	std::array<rhi::UniformVariant, 2> g2_uniforms =
+	{{
+		// ModelView
+		std::array<std::array<float, 4>, 4>
+		{{
+			{taller ? 2.f : 2.f * aspect, 0.f, 0.f, 0.f},
+			{0.f, taller ? 2.f * (1.f / aspect) : 2.f, 0.f, 0.f},
+			{0.f, 0.f, 1.f, 0.f},
+			{0.f, 0.f, 0.f, 1.f}
+		}},
+		// Texcoord0 Transform
+		std::array<std::array<float, 3>, 3>
+		{{
+			{vid.width / static_cast<float>(screen_tex_width_), 0.f, 0.f},
+			{0.f, vid.height / static_cast<float>(screen_tex_height_), 0.f},
+			{0.f, 0.f, 1.f}
+		}}
+	}};
+
+	uniform_sets_[0] = rhi.create_uniform_set(ctx, {g1_uniforms});
+	uniform_sets_[1] = rhi.create_uniform_set(ctx, {g2_uniforms});
+
+	std::array<rhi::VertexAttributeBufferBinding, 1> vbs = {{{0, quad_vbo_}}};
+	std::array<rhi::TextureBinding, 2> tbs = {{
+		{rhi::SamplerName::kSampler0, screen_tex_},
+		{rhi::SamplerName::kSampler1, palette_tex_}
+	}};
+	binding_set_ = rhi.create_binding_set(ctx, pipeline_, {vbs, tbs});
+}
+
+void SoftwareBlitPass::graphics(Rhi& rhi, Handle<GraphicsContext> ctx)
+{
+	rhi.begin_default_render_pass(ctx, true);
+	rhi.bind_pipeline(ctx, pipeline_);
+	rhi.bind_uniform_set(ctx, 0, uniform_sets_[0]);
+	rhi.bind_uniform_set(ctx, 1, uniform_sets_[1]);
+	rhi.bind_binding_set(ctx, binding_set_);
+	rhi.bind_index_buffer(ctx, quad_ibo_);
+	rhi.draw_indexed(ctx, 6, 0);
+	rhi.end_render_pass(ctx);
+}
+
+void SoftwareBlitPass::postpass(Rhi& rhi)
+{
+	// no-op
+}
diff --git a/src/hwr2/pass_software.hpp b/src/hwr2/pass_software.hpp
new file mode 100644
index 000000000..f36c82973
--- /dev/null
+++ b/src/hwr2/pass_software.hpp
@@ -0,0 +1,44 @@
+#ifndef __SRB2_HWR2_PASS_SOFTWARE_HPP__
+#define __SRB2_HWR2_PASS_SOFTWARE_HPP__
+
+#include <array>
+
+#include "../rhi/rhi.hpp"
+#include "pass.hpp"
+
+namespace srb2::hwr2
+{
+
+class SoftwareBlitPass : public Pass
+{
+	rhi::Handle<rhi::Pipeline> pipeline_;
+	rhi::Handle<rhi::Texture> screen_tex_;
+	rhi::Handle<rhi::Texture> palette_tex_;
+	rhi::Handle<rhi::Buffer> quad_vbo_;
+	rhi::Handle<rhi::Buffer> quad_ibo_;
+	std::array<rhi::Handle<rhi::UniformSet>, 2> uniform_sets_;
+	rhi::Handle<rhi::BindingSet> binding_set_;
+
+	uint32_t screen_tex_width_ = 0;
+	uint32_t screen_tex_height_ = 0;
+	bool quad_vbo_needs_upload_ = false;
+	bool quad_ibo_needs_upload_ = false;
+
+	void upload_screen(rhi::Rhi& rhi, rhi::Handle<rhi::TransferContext> ctx);
+	void upload_palette(rhi::Rhi& rhi, rhi::Handle<rhi::TransferContext> ctx);
+
+public:
+	virtual ~SoftwareBlitPass();
+
+	virtual void prepass(rhi::Rhi& rhi) override;
+
+	virtual void transfer(rhi::Rhi& rhi, rhi::Handle<rhi::TransferContext> ctx) override;
+
+	virtual void graphics(rhi::Rhi& rhi, rhi::Handle<rhi::GraphicsContext> ctx) override;
+
+	virtual void postpass(rhi::Rhi& rhi) override;
+};
+
+} // namespace srb2::hwr2
+
+#endif // __SRB2_HWR2_PASS_SOFTWARE_HPP__
diff --git a/src/i_video.h b/src/i_video.h
index 1c9a9a64c..a80bd33dc 100644
--- a/src/i_video.h
+++ b/src/i_video.h
@@ -17,6 +17,17 @@
 #include "doomtype.h"
 
 #ifdef __cplusplus
+
+#include "rhi/rhi.hpp"
+
+namespace srb2::sys {
+
+extern rhi::Handle<rhi::Rhi> g_current_rhi;
+
+rhi::Rhi* get_rhi(rhi::Handle<rhi::Rhi> handle);
+
+} // namespace
+
 extern "C" {
 #endif
 
@@ -44,10 +55,6 @@ extern rendermode_t rendermode;
 */
 extern rendermode_t chosenrendermode;
 
-/**	\brief use highcolor modes if true
-*/
-extern boolean highcolor;
-
 /**	\brief setup video mode
 */
 void I_StartupGraphics(void);
diff --git a/src/i_video_common.cpp b/src/i_video_common.cpp
new file mode 100644
index 000000000..cd99ed618
--- /dev/null
+++ b/src/i_video_common.cpp
@@ -0,0 +1,100 @@
+#include "i_video.h"
+
+#include <algorithm>
+#include <array>
+#include <vector>
+
+#include <imgui.h>
+
+#include "cxxutil.hpp"
+#include "v_video.h"
+#include "hwr2/pass_imgui.hpp"
+#include "hwr2/pass_software.hpp"
+
+using namespace srb2;
+using namespace srb2::hwr2;
+using namespace srb2::rhi;
+
+static SoftwareBlitPass g_sw_pass;
+static ImguiPass g_imgui_pass;
+
+Handle<Rhi> srb2::sys::g_current_rhi = kNullHandle;
+
+static bool rhi_changed()
+{
+	return false;
+}
+
+void I_FinishUpdate(void)
+{
+	if (rendermode == render_none)
+	{
+		return;
+	}
+
+	// TODO move this to srb2loop
+	ImGuiIO& io = ImGui::GetIO();
+	io.DisplaySize.x = vid.realwidth;
+	io.DisplaySize.y = vid.realheight;
+	ImGui::NewFrame();
+
+	if (rhi_changed())
+	{
+		// reinitialize passes
+		g_sw_pass = SoftwareBlitPass();
+		g_imgui_pass = ImguiPass();
+	}
+
+	rhi::Rhi* rhi = sys::get_rhi(sys::g_current_rhi);
+
+	if (rhi == nullptr)
+	{
+		// ???
+		return;
+	}
+
+	// Prepare phase
+	if (rendermode == render_soft)
+	{
+		g_sw_pass.prepass(*rhi);
+	}
+	g_imgui_pass.prepass(*rhi);
+
+	// Transfer phase
+	Handle<TransferContext> tc;
+	tc = rhi->begin_transfer();
+
+	if (rendermode == render_soft)
+	{
+		g_sw_pass.transfer(*rhi, tc);
+	}
+	g_imgui_pass.transfer(*rhi, tc);
+
+	rhi->end_transfer(tc);
+
+	// Graphics phase
+	Handle<GraphicsContext> gc;
+	gc = rhi->begin_graphics();
+
+	// Standard drawing passes...
+	if (rendermode == render_soft)
+	{
+		g_sw_pass.graphics(*rhi, gc);
+	}
+	g_imgui_pass.graphics(*rhi, gc);
+
+	rhi->end_graphics(gc);
+
+	// Postpass phase
+	if (rendermode == render_soft)
+	{
+		g_sw_pass.postpass(*rhi);
+	}
+	g_imgui_pass.postpass(*rhi);
+
+	// Present
+
+	rhi->present();
+
+	rhi->finish();
+}
diff --git a/src/r_data.c b/src/r_data.c
index 353a9bbf5..0174ee9ef 100644
--- a/src/r_data.c
+++ b/src/r_data.c
@@ -1167,12 +1167,6 @@ static void R_Init8to16(void)
 //
 void R_InitTextureData(void)
 {
-	if (highcolor)
-	{
-		CONS_Printf("InitHighColor...\n");
-		R_Init8to16();
-	}
-
 	CONS_Printf("R_LoadTextures()...\n");
 	R_LoadTextures();
 
diff --git a/src/rhi/CMakeLists.txt b/src/rhi/CMakeLists.txt
new file mode 100644
index 000000000..4ba10ae5b
--- /dev/null
+++ b/src/rhi/CMakeLists.txt
@@ -0,0 +1,7 @@
+target_sources(SRB2SDL2 PRIVATE
+	handle.hpp
+	rhi.cpp
+	rhi.hpp
+)
+
+add_subdirectory(gl3_core)
diff --git a/src/rhi/gl3_core/CMakeLists.txt b/src/rhi/gl3_core/CMakeLists.txt
new file mode 100644
index 000000000..0d59dde88
--- /dev/null
+++ b/src/rhi/gl3_core/CMakeLists.txt
@@ -0,0 +1,4 @@
+target_sources(SRB2SDL2 PRIVATE
+	gl3_core_rhi.cpp
+	gl3_core_rhi.hpp
+)
diff --git a/src/rhi/gl3_core/gl3_core_rhi.cpp b/src/rhi/gl3_core/gl3_core_rhi.cpp
new file mode 100644
index 000000000..f80667470
--- /dev/null
+++ b/src/rhi/gl3_core/gl3_core_rhi.cpp
@@ -0,0 +1,1260 @@
+#include "gl3_core_rhi.hpp"
+
+#include <memory>
+#include <string>
+#include <string_view>
+#include <tuple>
+#include <unordered_map>
+#include <utility>
+
+#include <fmt/format.h>
+#include <glad/gl.h>
+
+using namespace srb2;
+
+using srb2::rhi::GlCorePlatform;
+using srb2::rhi::GlCoreRhi;
+
+#if 1
+#define GL_ASSERT {GLenum __err = gl_->GetError(); if (__err != GL_NO_ERROR) { I_Error("GL Error at %s %d: %d", __FILE__, __LINE__, __err); }}
+#else
+#define GL_ASSERT ;
+#endif
+
+namespace {
+
+template <typename D, typename B>
+std::unique_ptr<D, std::default_delete<D>> static_unique_ptr_cast(std::unique_ptr<B, std::default_delete<B>> ptr) {
+	D* derived = static_cast<D*>(ptr.release());
+	return std::unique_ptr<D, std::default_delete<D>>(derived, std::default_delete<D>());
+}
+
+constexpr GLenum map_pixel_format(rhi::PixelFormat format) {
+	switch (format) {
+	case rhi::PixelFormat::kRGBA8:
+		return GL_RGBA8;
+	case rhi::PixelFormat::kDepth16:
+		return GL_DEPTH_COMPONENT16;
+	case rhi::PixelFormat::kStencil8:
+		return GL_STENCIL_INDEX8;
+	default:
+		return GL_ZERO;
+	}
+}
+
+constexpr std::tuple<GLenum, GLenum, GLuint> map_pixel_data_format(rhi::PixelFormat format) {
+	GLenum layout = GL_ZERO;
+	GLenum type = GL_ZERO;
+	GLuint size = 0;
+	switch (format) {
+	case rhi::PixelFormat::kR8:
+		layout = GL_RED;
+		type = GL_UNSIGNED_BYTE;
+		size = 1;
+		break;
+	case rhi::PixelFormat::kRGBA8:
+		layout = GL_RGBA;
+		type = GL_UNSIGNED_BYTE;
+		size = 4;
+		break;
+	default:
+		break;
+	}
+	return std::tuple(layout, type, size);
+}
+
+constexpr GLenum map_texture_format(rhi::TextureFormat format) {
+	switch (format) {
+	case rhi::TextureFormat::kRGBA:
+		return GL_RGBA;
+	case rhi::TextureFormat::kRGB:
+		return GL_RGB;
+	case rhi::TextureFormat::kLuminance:
+		return GL_RED;
+	default:
+		return GL_ZERO;
+	}
+}
+
+constexpr GLenum map_buffer_type(rhi::BufferType type) {
+	switch (type) {
+	case rhi::BufferType::kVertexBuffer:
+		return GL_ARRAY_BUFFER;
+	case rhi::BufferType::kIndexBuffer:
+		return GL_ELEMENT_ARRAY_BUFFER;
+	default:
+		return GL_ZERO;
+	}
+}
+
+constexpr GLenum map_buffer_usage(rhi::BufferUsage usage) {
+	switch (usage) {
+	case rhi::BufferUsage::kImmutable:
+		return GL_STATIC_DRAW;
+	case rhi::BufferUsage::kDynamic:
+		return GL_DYNAMIC_DRAW;
+	default:
+		return GL_ZERO;
+	}
+}
+
+constexpr GLenum map_compare_func(rhi::CompareFunc func) {
+	switch (func) {
+	case rhi::CompareFunc::kNever:
+		return GL_NEVER;
+	case rhi::CompareFunc::kLess:
+		return GL_LESS;
+	case rhi::CompareFunc::kEqual:
+		return GL_EQUAL;
+	case rhi::CompareFunc::kLessEqual:
+		return GL_LEQUAL;
+	case rhi::CompareFunc::kGreater:
+		return GL_GREATER;
+	case rhi::CompareFunc::kNotEqual:
+		return GL_NOTEQUAL;
+	case rhi::CompareFunc::kGreaterEqual:
+		return GL_GEQUAL;
+	case rhi::CompareFunc::kAlways:
+		return GL_ALWAYS;
+	default:
+		return GL_ZERO;
+	}
+}
+
+constexpr GLenum map_blend_factor(rhi::BlendFactor factor) {
+	switch (factor) {
+	case rhi::BlendFactor::kZero:
+		return GL_ZERO;
+	case rhi::BlendFactor::kOne:
+		return GL_ONE;
+	case rhi::BlendFactor::kSource:
+		return GL_SRC_COLOR;
+	case rhi::BlendFactor::kOneMinusSource:
+		return GL_ONE_MINUS_SRC_COLOR;
+	case rhi::BlendFactor::kSourceAlpha:
+		return GL_SRC_ALPHA;
+	case rhi::BlendFactor::kOneMinusSourceAlpha:
+		return GL_ONE_MINUS_SRC_ALPHA;
+	case rhi::BlendFactor::kDest:
+		return GL_DST_COLOR;
+	case rhi::BlendFactor::kOneMinusDest:
+		return GL_ONE_MINUS_DST_COLOR;
+	case rhi::BlendFactor::kDestAlpha:
+		return GL_DST_ALPHA;
+	case rhi::BlendFactor::kOneMinusDestAlpha:
+		return GL_ONE_MINUS_DST_ALPHA;
+	case rhi::BlendFactor::kConstant:
+		return GL_CONSTANT_COLOR;
+	case rhi::BlendFactor::kOneMinusConstant:
+		return GL_ONE_MINUS_CONSTANT_COLOR;
+	case rhi::BlendFactor::kConstantAlpha:
+		return GL_CONSTANT_ALPHA;
+	case rhi::BlendFactor::kOneMinusConstantAlpha:
+		return GL_ONE_MINUS_CONSTANT_ALPHA;
+	case rhi::BlendFactor::kSourceAlphaSaturated:
+		return GL_SRC_ALPHA_SATURATE;
+	default:
+		return GL_ONE;
+	}
+}
+
+constexpr GLenum map_blend_function(rhi::BlendFunction function) {
+	switch (function) {
+	case rhi::BlendFunction::kAdd:
+		return GL_FUNC_ADD;
+	case rhi::BlendFunction::kSubtract:
+		return GL_FUNC_SUBTRACT;
+	case rhi::BlendFunction::kReverseSubtract:
+		return GL_FUNC_REVERSE_SUBTRACT;
+	default:
+		return GL_FUNC_ADD;
+	}
+}
+
+constexpr GLenum map_cull_mode(rhi::CullMode mode) {
+	switch (mode) {
+	case rhi::CullMode::kNone:
+		return GL_NONE;
+	case rhi::CullMode::kFront:
+		return GL_FRONT;
+	case rhi::CullMode::kBack:
+		return GL_BACK;
+	default:
+		return GL_NONE;
+	}
+}
+
+constexpr GLenum map_winding(rhi::FaceWinding winding) {
+	switch (winding) {
+	case rhi::FaceWinding::kCounterClockwise:
+		return GL_CCW;
+	case rhi::FaceWinding::kClockwise:
+		return GL_CW;
+	default:
+		return GL_CCW;
+	}
+}
+
+constexpr GLenum map_primitive_mode(rhi::PrimitiveType type) {
+	switch (type) {
+	case rhi::PrimitiveType::kPoints:
+		return GL_POINTS;
+	case rhi::PrimitiveType::kLines:
+		return GL_LINES;
+	case rhi::PrimitiveType::kLineStrip:
+		return GL_LINE_STRIP;
+	case rhi::PrimitiveType::kTriangles:
+		return GL_TRIANGLES;
+	case rhi::PrimitiveType::kTriangleStrip:
+		return GL_TRIANGLE_STRIP;
+	case rhi::PrimitiveType::kTriangleFan:
+		return GL_TRIANGLE_FAN;
+	default:
+		return GL_ZERO;
+	}
+}
+
+constexpr const char* map_vertex_attribute_symbol_name(rhi::VertexAttributeName name) {
+	switch (name) {
+	case rhi::VertexAttributeName::kPosition:
+		return "a_position";
+	case rhi::VertexAttributeName::kNormal:
+		return "a_normal";
+	case rhi::VertexAttributeName::kColor:
+		return "a_color";
+	case rhi::VertexAttributeName::kTexCoord0:
+		return "a_texcoord0";
+	case rhi::VertexAttributeName::kTexCoord1:
+		return "a_texcoord1";
+	default:
+		return nullptr;
+	}
+}
+
+constexpr const char* map_vertex_attribute_enable_define(rhi::VertexAttributeName name) {
+	switch (name) {
+	case rhi::VertexAttributeName::kPosition:
+		return "ENABLE_VA_POSITION";
+	case rhi::VertexAttributeName::kNormal:
+		return "ENABLE_VA_NORMAL";
+	case rhi::VertexAttributeName::kColor:
+		return "ENABLE_VA_COLOR";
+	case rhi::VertexAttributeName::kTexCoord0:
+		return "ENABLE_VA_TEXCOORD0";
+	case rhi::VertexAttributeName::kTexCoord1:
+		return "ENABLE_VA_TEXCOORD1";
+	default:
+		return nullptr;
+	}
+}
+
+constexpr const char* map_uniform_attribute_symbol_name(rhi::UniformName name) {
+	switch (name) {
+	case rhi::UniformName::kTime:
+		return "u_time";
+	case rhi::UniformName::kModelView:
+		return "u_modelview";
+	case rhi::UniformName::kProjection:
+		return "u_projection";
+	case rhi::UniformName::kTexCoord0Transform:
+		return "u_texcoord0_transform";
+	default:
+		return nullptr;
+	}
+}
+
+constexpr const char* map_sampler_symbol_name(rhi::SamplerName name) {
+	switch (name) {
+	case rhi::SamplerName::kSampler0:
+		return "s_sampler0";
+	case rhi::SamplerName::kSampler1:
+		return "s_sampler1";
+	case rhi::SamplerName::kSampler2:
+		return "s_sampler2";
+	case rhi::SamplerName::kSampler3:
+		return "s_sampler3";
+	default:
+		return nullptr;
+	}
+}
+
+constexpr GLenum map_vertex_attribute_format(rhi::VertexAttributeFormat format) {
+	switch (format) {
+	case rhi::VertexAttributeFormat::kFloat:
+		return GL_FLOAT;
+	case rhi::VertexAttributeFormat::kFloat2:
+		return GL_FLOAT_VEC2;
+	case rhi::VertexAttributeFormat::kFloat3:
+		return GL_FLOAT_VEC3;
+	case rhi::VertexAttributeFormat::kFloat4:
+		return GL_FLOAT_VEC4;
+	default:
+		return GL_ZERO;
+	}
+}
+
+constexpr GLenum map_vertex_attribute_type(rhi::VertexAttributeFormat format) {
+	switch (format) {
+	case rhi::VertexAttributeFormat::kFloat:
+		return GL_FLOAT;
+	case rhi::VertexAttributeFormat::kFloat2:
+		return GL_FLOAT;
+	case rhi::VertexAttributeFormat::kFloat3:
+		return GL_FLOAT;
+	case rhi::VertexAttributeFormat::kFloat4:
+		return GL_FLOAT;
+	default:
+		return GL_ZERO;
+	}
+}
+
+constexpr GLint map_vertex_attribute_format_size(rhi::VertexAttributeFormat format) {
+	switch (format) {
+	case rhi::VertexAttributeFormat::kFloat:
+		return 1;
+	case rhi::VertexAttributeFormat::kFloat2:
+		return 2;
+	case rhi::VertexAttributeFormat::kFloat3:
+		return 3;
+	case rhi::VertexAttributeFormat::kFloat4:
+		return 4;
+	default:
+		return 0;
+	}
+}
+
+constexpr GLenum map_uniform_format(rhi::UniformFormat format) {
+	switch (format) {
+	case rhi::UniformFormat::kFloat:
+		return GL_FLOAT;
+	case rhi::UniformFormat::kFloat2:
+		return GL_FLOAT_VEC2;
+	case rhi::UniformFormat::kFloat3:
+		return GL_FLOAT_VEC3;
+	case rhi::UniformFormat::kFloat4:
+		return GL_FLOAT_VEC4;
+	case rhi::UniformFormat::kInt:
+		return GL_INT;
+	case rhi::UniformFormat::kInt2:
+		return GL_INT_VEC2;
+	case rhi::UniformFormat::kInt3:
+		return GL_INT_VEC3;
+	case rhi::UniformFormat::kInt4:
+		return GL_INT_VEC4;
+	case rhi::UniformFormat::kMat2:
+		return GL_FLOAT_MAT2;
+	case rhi::UniformFormat::kMat3:
+		return GL_FLOAT_MAT3;
+	case rhi::UniformFormat::kMat4:
+		return GL_FLOAT_MAT4;
+	default:
+		return GL_ZERO;
+	}
+}
+
+struct GlCoreTexture : public rhi::Texture {
+	GLuint texture;
+	rhi::TextureDesc desc;
+	GlCoreTexture(GLuint texture, const rhi::TextureDesc& desc) noexcept : texture(texture), desc(desc) {}
+};
+
+struct GlCoreBuffer : public rhi::Buffer {
+	GLuint buffer;
+	rhi::BufferDesc desc;
+	GlCoreBuffer(GLuint buffer, const rhi::BufferDesc& desc) noexcept : buffer(buffer), desc(desc) {}
+};
+
+struct GlCoreRenderPass : public rhi::RenderPass {
+	rhi::RenderPassDesc desc;
+	explicit GlCoreRenderPass(const rhi::RenderPassDesc& desc) noexcept : desc(desc) {}
+};
+
+struct GlCoreRenderbuffer : public rhi::Renderbuffer {
+	GLuint renderbuffer;
+
+	explicit GlCoreRenderbuffer(GLuint renderbuffer) noexcept : renderbuffer(renderbuffer) {}
+};
+
+struct GlCoreUniformSet : public rhi::UniformSet
+{
+	std::vector<rhi::UniformVariant> uniforms;
+};
+
+struct GlCoreBindingSet : public rhi::BindingSet
+{
+	GLuint vao;
+	std::unordered_map<rhi::SamplerName, GLuint> textures {4};
+};
+
+struct GlCorePipeline : public rhi::Pipeline {
+	GLuint vertex_shader = 0;
+	GLuint fragment_shader = 0;
+	GLuint program = 0;
+	std::unordered_map<rhi::VertexAttributeName, GLuint> attrib_locations {2};
+	std::unordered_map<rhi::UniformName, GLuint> uniform_locations {2};
+	std::unordered_map<rhi::SamplerName, GLuint> sampler_locations {2};
+	rhi::PipelineDesc desc;
+};
+
+struct GlCoreGraphicsContext : public rhi::GraphicsContext {};
+
+struct GlCoreTransferContext : public rhi::TransferContext {};
+
+struct GlCoreActiveUniform {
+	GLenum type;
+	GLuint location;
+};
+
+} // namespace
+
+GlCorePlatform::~GlCorePlatform() = default;
+
+GlCoreRhi::GlCoreRhi(std::unique_ptr<GlCorePlatform>&& platform, GlLoadFunc load_func)
+	: platform_(std::move(platform)) {
+	gl_ = std::make_unique<GladGLContext>();
+	gladLoadGLContext(gl_.get(), load_func);
+}
+
+GlCoreRhi::~GlCoreRhi() = default;
+
+rhi::Handle<rhi::RenderPass> GlCoreRhi::create_render_pass(const rhi::RenderPassDesc& desc) {
+	SRB2_ASSERT(graphics_context_active_ == false);
+
+	// GL has no formal render pass object
+	return render_pass_slab_.insert(std::make_unique<GlCoreRenderPass>(desc));
+}
+
+void GlCoreRhi::destroy_render_pass(rhi::Handle<rhi::RenderPass> handle) {
+	SRB2_ASSERT(graphics_context_active_ == false);
+
+	std::unique_ptr<rhi::RenderPass> buffer = render_pass_slab_.remove(handle);
+	std::unique_ptr<GlCoreRenderPass> casted(static_cast<GlCoreRenderPass*>(buffer.release()));
+}
+
+rhi::Handle<rhi::Texture> GlCoreRhi::create_texture(const rhi::TextureDesc& desc) {
+	SRB2_ASSERT(graphics_context_active_ == false);
+
+	GLenum internal_format = map_texture_format(desc.format);
+	SRB2_ASSERT(internal_format != GL_ZERO);
+
+	GLuint name = 0;
+	gl_->GenTextures(1, &name);
+
+	gl_->BindTexture(GL_TEXTURE_2D, name);
+
+	gl_->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); GL_ASSERT
+	gl_->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); GL_ASSERT
+	gl_->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); GL_ASSERT
+	gl_->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); GL_ASSERT
+	gl_->TexImage2D(GL_TEXTURE_2D, 0, internal_format, desc.width, desc.height, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr); GL_ASSERT
+
+	return texture_slab_.insert(std::make_unique<GlCoreTexture>(name, desc));
+}
+
+void GlCoreRhi::destroy_texture(rhi::Handle<rhi::Texture> handle) {
+	SRB2_ASSERT(graphics_context_active_ == false);
+
+	SRB2_ASSERT(texture_slab_.is_valid(handle) == true);
+	std::unique_ptr<GlCoreTexture> casted = static_unique_ptr_cast<GlCoreTexture>(texture_slab_.remove(handle));
+	GLuint name = casted->texture;
+	disposal_.push_back([this, name] { gl_->DeleteTextures(1, &name); });
+}
+
+void GlCoreRhi::update_texture(Handle<TransferContext> ctx, Handle<Texture> texture, Rect region, srb2::rhi::PixelFormat data_format, tcb::span<const std::byte> data) {
+	SRB2_ASSERT(graphics_context_active_ == false);
+	SRB2_ASSERT(transfer_context_active_ == true);
+	SRB2_ASSERT(ctx.generation() == transfer_context_generation_);
+
+	if (data.empty())
+	{
+		return;
+	}
+
+	SRB2_ASSERT(texture_slab_.is_valid(texture) == true);
+	auto& t = *static_cast<GlCoreTexture*>(&texture_slab_[texture]);
+
+	GLenum format = GL_RGBA;
+	GLenum type = GL_UNSIGNED_BYTE;
+	GLuint size = 0;
+	std::tie(format, type, size) = map_pixel_data_format(data_format);
+	SRB2_ASSERT(format != GL_ZERO && type != GL_ZERO);
+	SRB2_ASSERT(map_texture_format(t.desc.format) == format);
+	SRB2_ASSERT(region.w * region.h * size == data.size_bytes());
+	SRB2_ASSERT(region.x + region.w <= t.desc.width && region.y + region.h <= t.desc.height);
+
+	gl_->ActiveTexture(GL_TEXTURE0); GL_ASSERT
+	gl_->BindTexture(GL_TEXTURE_2D, t.texture);  GL_ASSERT
+	gl_->TexSubImage2D(GL_TEXTURE_2D, 0, region.x, region.y, region.w, region.h, format, type, reinterpret_cast<const void*>(data.data())); GL_ASSERT
+}
+
+rhi::Handle<rhi::Buffer> GlCoreRhi::create_buffer(const rhi::BufferDesc& desc) {
+	SRB2_ASSERT(graphics_context_active_ == false);
+
+	GLenum target = map_buffer_type(desc.type);
+	SRB2_ASSERT(target != GL_ZERO);
+
+	GLenum usage = map_buffer_usage(desc.usage);
+	SRB2_ASSERT(usage != GL_ZERO);
+
+	GLuint name = 0;
+	gl_->GenBuffers(1, &name); GL_ASSERT
+
+	gl_->BindBuffer(target, name); GL_ASSERT
+
+	gl_->BufferData(target, desc.size, nullptr, usage); GL_ASSERT
+
+	return buffer_slab_.insert(std::make_unique<GlCoreBuffer>(name, desc));
+}
+
+void GlCoreRhi::destroy_buffer(rhi::Handle<rhi::Buffer> handle) {
+	SRB2_ASSERT(graphics_context_active_ == false);
+
+	SRB2_ASSERT(buffer_slab_.is_valid(handle) == true);
+	SRB2_ASSERT(graphics_context_active_ == false);
+	std::unique_ptr<GlCoreBuffer> casted = static_unique_ptr_cast<GlCoreBuffer>(buffer_slab_.remove(handle));
+	GLuint name = casted->buffer;
+
+	disposal_.push_back([this, name] { gl_->DeleteBuffers(1, &name); });
+}
+
+void GlCoreRhi::update_buffer_contents(rhi::Handle<TransferContext> ctx, rhi::Handle<rhi::Buffer> handle, uint32_t offset, tcb::span<const std::byte> data) {
+	SRB2_ASSERT(graphics_context_active_ == false);
+	SRB2_ASSERT(transfer_context_active_ == true);
+	SRB2_ASSERT(ctx.generation() == transfer_context_generation_);
+
+	if (data.empty())
+	{
+		return;
+	}
+
+	SRB2_ASSERT(buffer_slab_.is_valid(handle) == true);
+	auto& b = *static_cast<GlCoreBuffer*>(&buffer_slab_[handle]);
+
+	SRB2_ASSERT(offset < b.desc.size && offset + data.size() <= b.desc.size);
+
+	GLenum target = GL_ZERO;
+	switch (b.desc.type) {
+	case rhi::BufferType::kVertexBuffer:
+		target = GL_ARRAY_BUFFER;
+		break;
+	case rhi::BufferType::kIndexBuffer:
+		target = GL_ELEMENT_ARRAY_BUFFER;
+		break;
+	}
+
+	gl_->BindBuffer(target, b.buffer); GL_ASSERT
+	gl_->BufferSubData(target, offset, data.size(), data.data()); GL_ASSERT
+}
+
+rhi::Handle<rhi::UniformSet> GlCoreRhi::create_uniform_set(rhi::Handle<rhi::TransferContext> ctx, const rhi::CreateUniformSetInfo& info)
+{
+	SRB2_ASSERT(graphics_context_active_ == false);
+	SRB2_ASSERT(transfer_context_active_ == true);
+	SRB2_ASSERT(ctx.generation() == transfer_context_generation_);
+
+	GlCoreUniformSet uniform_set;
+
+	for (auto& uniform : info.uniforms)
+	{
+		uniform_set.uniforms.push_back(uniform);
+	}
+
+	return uniform_set_slab_.insert(std::make_unique<GlCoreUniformSet>(std::move(uniform_set)));
+}
+
+rhi::Handle<rhi::BindingSet> GlCoreRhi::create_binding_set(rhi::Handle<rhi::TransferContext> ctx, Handle<Pipeline> pipeline, const rhi::CreateBindingSetInfo& info)
+{
+	SRB2_ASSERT(graphics_context_active_ == false);
+	SRB2_ASSERT(transfer_context_active_ == true);
+	SRB2_ASSERT(ctx.generation() == transfer_context_generation_);
+
+	SRB2_ASSERT(pipeline_slab_.is_valid(pipeline) == true);
+	auto& pl = *static_cast<GlCorePipeline*>(&pipeline_slab_[pipeline]);
+
+	SRB2_ASSERT(info.vertex_buffers.size() == pl.desc.vertex_input.buffer_layouts.size());
+
+	GlCoreBindingSet binding_set;
+
+	GLuint vao = 0;
+	gl_->GenVertexArrays(1, &vao); GL_ASSERT
+	gl_->BindVertexArray(vao); GL_ASSERT
+
+	for (auto& attr_layout : pl.desc.vertex_input.attr_layouts)
+	{
+		SRB2_ASSERT(buffer_slab_.is_valid(info.vertex_buffers[attr_layout.buffer_index].vertex_buffer));
+		auto& buf = *static_cast<GlCoreBuffer*>(&buffer_slab_[info.vertex_buffers[attr_layout.buffer_index].vertex_buffer]);
+		SRB2_ASSERT(buf.desc.type == rhi::BufferType::kVertexBuffer);
+
+		auto& buffer_layout = pl.desc.vertex_input.buffer_layouts[attr_layout.buffer_index];
+
+		gl_->BindBuffer(GL_ARRAY_BUFFER, buf.buffer); GL_ASSERT
+
+		GLuint attrib_location = pl.attrib_locations[attr_layout.name];
+		VertexAttributeFormat vert_attr_format = rhi::vertex_attribute_format(attr_layout.name);
+		GLenum vertex_attr_type = map_vertex_attribute_type(vert_attr_format);
+		SRB2_ASSERT(vertex_attr_type != GL_ZERO);
+		GLint vertex_attr_size = map_vertex_attribute_format_size(vert_attr_format);
+		SRB2_ASSERT(vertex_attr_size != 0);
+		uint32_t vertex_buffer_offset = 0; // TODO allow binding set to specify
+		gl_->EnableVertexAttribArray(pl.attrib_locations[attr_layout.name]); GL_ASSERT
+		gl_->VertexAttribPointer(attrib_location, vertex_attr_size, vertex_attr_type, GL_FALSE, buffer_layout.stride, reinterpret_cast<const void*>(vertex_buffer_offset + attr_layout.offset)); GL_ASSERT
+	}
+
+	binding_set.vao = vao;
+
+	// Set textures
+	for (size_t i = 0; i < info.sampler_textures.size(); i++)
+	{
+		auto& binding = info.sampler_textures[i];
+		auto& sampler_name = pl.desc.sampler_input.enabled_samplers[i];
+		SRB2_ASSERT(binding.name == sampler_name);
+
+		SRB2_ASSERT(texture_slab_.is_valid(binding.texture));
+		auto& tx = *static_cast<GlCoreTexture*>(&texture_slab_[binding.texture]);
+		binding_set.textures.insert({sampler_name, tx.texture});
+	}
+
+	return binding_set_slab_.insert(std::make_unique<GlCoreBindingSet>(std::move(binding_set)));
+}
+
+rhi::Handle<rhi::Renderbuffer> GlCoreRhi::create_renderbuffer(const rhi::RenderbufferDesc& desc) {
+	SRB2_ASSERT(graphics_context_active_ == false);
+
+	GLuint name = 0;
+	gl_->GenRenderbuffers(1, &name);
+
+	// Obtain storage up-front.
+	gl_->BindRenderbuffer(GL_RENDERBUFFER, name); GL_ASSERT
+	gl_->RenderbufferStorage(GL_RENDERBUFFER, map_pixel_format(desc.format), desc.width, desc.height); GL_ASSERT
+
+	return renderbuffer_slab_.insert(std::make_unique<GlCoreRenderbuffer>(GlCoreRenderbuffer {name}));
+}
+
+void GlCoreRhi::destroy_renderbuffer(rhi::Handle<rhi::Renderbuffer> handle) {
+	SRB2_ASSERT(graphics_context_active_ == false);
+
+	SRB2_ASSERT(renderbuffer_slab_.is_valid(handle) == true);
+	std::unique_ptr<GlCoreRenderbuffer> casted =
+		static_unique_ptr_cast<GlCoreRenderbuffer>(renderbuffer_slab_.remove(handle));
+	GLuint name = casted->renderbuffer;
+	disposal_.push_back([this, name] { gl_->DeleteRenderbuffers(1, &name); });
+}
+
+rhi::Handle<rhi::Pipeline> GlCoreRhi::create_pipeline(const PipelineDesc& desc) {
+	SRB2_ASSERT(graphics_context_active_ == false);
+	SRB2_ASSERT(platform_ != nullptr);
+	// TODO assert compatibility of pipeline description with program using ProgramRequirements
+
+	const rhi::ProgramRequirements& reqs = rhi::program_requirements_for_program(desc.program);
+
+	GLuint vertex = 0;
+	GLuint fragment = 0;
+	GLuint program = 0;
+	GlCorePipeline pipeline;
+
+	auto [vert_src, frag_src] = platform_->find_shader_sources(desc.program);
+
+	// TODO make use of multiple source files.
+	// In Khronos Group's brilliance, #version is required to be the first directive,
+	// but we need to insert #defines in-between.
+	std::string vert_src_processed;
+	std::string::size_type string_i = 0;
+	do
+	{
+		std::string::size_type new_i = vert_src.find('\n', string_i);
+		if (new_i == std::string::npos)
+		{
+			break;
+		}
+		std::string_view line_view(vert_src.c_str() + string_i, new_i - string_i + 1);
+		vert_src_processed.append(line_view);
+		if (line_view.rfind("#version ", 0) == 0)
+		{
+			for (auto& attribute : desc.vertex_input.attr_layouts)
+			{
+				for (auto const& require_attr : reqs.vertex_input.attributes)
+				{
+					if (require_attr.name == attribute.name && !require_attr.required)
+					{
+						vert_src_processed.append("#define ");
+						vert_src_processed.append(map_vertex_attribute_enable_define(attribute.name));
+						vert_src_processed.append("\n");
+					}
+				}
+			}
+		}
+		string_i = new_i + 1;
+	} while (string_i != std::string::npos);
+
+	const char* vert_src_arr[1] = {vert_src_processed.c_str()};
+	const GLint vert_src_arr_lens[1] = {static_cast<GLint>(vert_src_processed.size())};
+	const char* frag_src_arr[1] = {frag_src.c_str()};
+	const GLint frag_src_arr_lens[1] = {static_cast<GLint>(frag_src.size())};
+
+	vertex = gl_->CreateShader(GL_VERTEX_SHADER);
+	gl_->ShaderSource(vertex, 1, vert_src_arr, vert_src_arr_lens);
+	gl_->CompileShader(vertex);
+	GLint is_compiled = 0;
+	gl_->GetShaderiv(vertex, GL_COMPILE_STATUS, &is_compiled);
+	if (is_compiled == GL_FALSE) {
+		GLint max_length = 0;
+		gl_->GetShaderiv(vertex, GL_INFO_LOG_LENGTH, &max_length);
+		std::vector<GLchar> compile_error(max_length);
+		gl_->GetShaderInfoLog(vertex, max_length, &max_length, compile_error.data());
+
+		gl_->DeleteShader(vertex);
+		throw std::runtime_error(fmt::format("Vertex shader compilation failed: {}", std::string(compile_error.data())));
+	}
+	fragment = gl_->CreateShader(GL_FRAGMENT_SHADER);
+	gl_->ShaderSource(fragment, 1, frag_src_arr, frag_src_arr_lens);
+	gl_->CompileShader(fragment);
+	gl_->GetShaderiv(vertex, GL_COMPILE_STATUS, &is_compiled);
+	if (is_compiled == GL_FALSE) {
+		GLint max_length = 0;
+		gl_->GetShaderiv(fragment, GL_INFO_LOG_LENGTH, &max_length);
+		std::vector<GLchar> compile_error(max_length);
+		gl_->GetShaderInfoLog(fragment, max_length, &max_length, compile_error.data());
+
+		gl_->DeleteShader(fragment);
+		gl_->DeleteShader(vertex);
+		throw std::runtime_error(fmt::format("Fragment shader compilation failed: {}", std::string(compile_error.data())));
+	}
+
+	// Program link
+
+	program = gl_->CreateProgram();
+	gl_->AttachShader(program, vertex);
+	gl_->AttachShader(program, fragment);
+	gl_->LinkProgram(program);
+	gl_->GetProgramiv(program, GL_LINK_STATUS, &is_compiled);
+	if (is_compiled == GL_FALSE) {
+		GLint max_length = 0;
+		gl_->GetProgramiv(program, GL_INFO_LOG_LENGTH, &max_length);
+		std::vector<GLchar> link_error(max_length);
+		gl_->GetProgramInfoLog(program, max_length, &max_length, link_error.data());
+
+		gl_->DeleteProgram(program);
+		gl_->DeleteShader(fragment);
+		gl_->DeleteShader(vertex);
+		throw std::runtime_error(fmt::format("Pipeline program link failed: {}", std::string(link_error.data())));
+	}
+
+	std::unordered_map<std::string, GlCoreActiveUniform> active_attributes;
+	GLint active_attribute_total = -1;
+	gl_->GetProgramiv(program, GL_ACTIVE_ATTRIBUTES, &active_attribute_total);
+	if (active_attribute_total < 0) {
+		gl_->DeleteProgram(program);
+		gl_->DeleteShader(fragment);
+		gl_->DeleteShader(vertex);
+		throw std::runtime_error("Unable to retrieve program active attributes");
+	}
+	if (desc.vertex_input.attr_layouts.size() != static_cast<GLuint>(active_attribute_total)) {
+		gl_->DeleteProgram(program);
+		gl_->DeleteShader(fragment);
+		gl_->DeleteShader(vertex);
+		throw std::runtime_error(
+			fmt::format(
+				"Pipeline's enabled attribute count does not match the linked program's total: {} vs {}",
+				desc.vertex_input.attr_layouts.size(),
+				static_cast<GLuint>(active_attribute_total)
+			)
+		);
+	}
+	for (GLint i = 0; i < active_attribute_total; i++) {
+		GLsizei name_len = 0;
+		GLint size = 0;
+		GLenum type = GL_ZERO;
+		char name[256];
+		gl_->GetActiveAttrib(program, i, 255, &name_len, &size, &type, name); GL_ASSERT
+		GLint location = gl_->GetAttribLocation(program, name); GL_ASSERT
+		active_attributes.insert({std::string(name), GlCoreActiveUniform {type, static_cast<GLuint>(location)}});
+	}
+
+	std::unordered_map<std::string, GlCoreActiveUniform> active_uniforms;
+	size_t total_enabled_uniforms = 0;
+	for (auto g = desc.uniform_input.enabled_uniforms.cbegin() ; g != desc.uniform_input.enabled_uniforms.cend(); g = std::next(g))
+	{
+		total_enabled_uniforms += g->size();
+	}
+	GLint active_uniform_total = -1;
+	gl_->GetProgramiv(program, GL_ACTIVE_UNIFORMS, &active_uniform_total);
+	if (active_uniform_total < 0) {
+		gl_->DeleteProgram(program);
+		gl_->DeleteShader(fragment);
+		gl_->DeleteShader(vertex);
+		throw std::runtime_error("Unable to retrieve program active uniforms");
+	}
+	if (total_enabled_uniforms + desc.sampler_input.enabled_samplers.size() != static_cast<GLuint>(active_uniform_total)) {
+		gl_->DeleteProgram(program);
+		gl_->DeleteShader(fragment);
+		gl_->DeleteShader(vertex);
+		throw std::runtime_error(
+			fmt::format(
+				"Pipeline's enabled uniform count (uniforms + samplers) does not match the linked program's total: {} vs {}",
+				total_enabled_uniforms + desc.sampler_input.enabled_samplers.size(),
+				static_cast<GLuint>(active_uniform_total)
+			)
+		);
+	}
+	for (GLint i = 0; i < active_uniform_total; i++) {
+		GLsizei name_len = 0;
+		GLint size = 0;
+		GLenum type = GL_ZERO;
+		char name[256];
+		gl_->GetActiveUniform(program, i, 255, &name_len, &size, &type, name); GL_ASSERT
+		GLint location = gl_->GetUniformLocation(program, name); GL_ASSERT
+		active_uniforms.insert({std::string(name), GlCoreActiveUniform {type, static_cast<GLuint>(location)}});
+	}
+
+	for (auto& attr : desc.vertex_input.attr_layouts) {
+		const char* symbol_name = map_vertex_attribute_symbol_name(attr.name);
+		SRB2_ASSERT(symbol_name != nullptr);
+		if (active_attributes.find(symbol_name) == active_attributes.end()) {
+			gl_->DeleteProgram(program);
+			gl_->DeleteShader(fragment);
+			gl_->DeleteShader(vertex);
+			throw std::runtime_error("Enabled attribute not found in linked program");
+		}
+		auto& active_attr = active_attributes[symbol_name];
+		auto expected_format = rhi::vertex_attribute_format(attr.name);
+		auto expected_gl_type = map_vertex_attribute_format(expected_format);
+		SRB2_ASSERT(expected_gl_type != GL_ZERO);
+		if (expected_gl_type != active_attr.type) {
+			gl_->DeleteProgram(program);
+			gl_->DeleteShader(fragment);
+			gl_->DeleteShader(vertex);
+			throw std::runtime_error("Active attribute type does not match expected type");
+		}
+
+		pipeline.attrib_locations.insert({attr.name, active_attr.location});
+	}
+
+	for (auto group_itr = desc.uniform_input.enabled_uniforms.cbegin(); group_itr != desc.uniform_input.enabled_uniforms.cend(); group_itr = std::next(group_itr))
+	{
+		auto& group = *group_itr;
+		for (auto itr = group.cbegin(); itr != group.cend(); itr = std::next(itr))
+		{
+			auto& uniform = *itr;
+			const char* symbol_name = map_uniform_attribute_symbol_name(uniform);
+			SRB2_ASSERT(symbol_name != nullptr);
+			if (active_uniforms.find(symbol_name) == active_uniforms.end()) {
+				gl_->DeleteProgram(program);
+				gl_->DeleteShader(fragment);
+				gl_->DeleteShader(vertex);
+				throw std::runtime_error("Enabled uniform not found in linked program");
+			}
+			auto& active_uniform = active_uniforms[symbol_name];
+			auto expected_format = rhi::uniform_format(uniform);
+			auto expected_gl_type = map_uniform_format(expected_format);
+			SRB2_ASSERT(expected_gl_type != GL_ZERO);
+			if (expected_gl_type != active_uniform.type) {
+				gl_->DeleteProgram(program);
+				gl_->DeleteShader(fragment);
+				gl_->DeleteShader(vertex);
+				throw std::runtime_error("Active uniform type does not match expected type");
+			}
+			SRB2_ASSERT(pipeline.uniform_locations.find(uniform) == pipeline.uniform_locations.end());
+			pipeline.uniform_locations.insert({uniform, active_uniform.location});
+		}
+	}
+
+	for (auto& sampler : desc.sampler_input.enabled_samplers) {
+		const char* symbol_name = map_sampler_symbol_name(sampler);
+		SRB2_ASSERT(symbol_name != nullptr);
+		if (active_uniforms.find(symbol_name) == active_uniforms.end()) {
+			gl_->DeleteProgram(program);
+			gl_->DeleteShader(fragment);
+			gl_->DeleteShader(vertex);
+			throw std::runtime_error("Enabled sampler not found in linked program");
+		}
+		auto& active_sampler = active_uniforms[symbol_name];
+		if (active_sampler.type != GL_SAMPLER_2D) {
+			gl_->DeleteProgram(program);
+			gl_->DeleteShader(fragment);
+			gl_->DeleteShader(vertex);
+			throw std::runtime_error("Active sampler type does not match expected type");
+		}
+
+		pipeline.sampler_locations.insert({sampler, active_sampler.location});
+	}
+
+	pipeline.desc = desc;
+	pipeline.vertex_shader = vertex;
+	pipeline.fragment_shader = fragment;
+	pipeline.program = program;
+
+	return pipeline_slab_.insert(std::make_unique<GlCorePipeline>(std::move(pipeline)));
+}
+
+void GlCoreRhi::destroy_pipeline(rhi::Handle<rhi::Pipeline> handle) {
+	SRB2_ASSERT(graphics_context_active_ == false);
+
+	SRB2_ASSERT(pipeline_slab_.is_valid(handle) == true);
+	std::unique_ptr<GlCorePipeline> casted = static_unique_ptr_cast<GlCorePipeline>(pipeline_slab_.remove(handle));
+	GLuint vertex_shader = casted->vertex_shader;
+	GLuint fragment_shader = casted->fragment_shader;
+	GLuint program = casted->program;
+
+	disposal_.push_back([this, fragment_shader] { gl_->DeleteShader(fragment_shader); });
+	disposal_.push_back([this, vertex_shader] { gl_->DeleteShader(vertex_shader); });
+	disposal_.push_back([this, program] { gl_->DeleteProgram(program); });
+}
+
+rhi::Handle<rhi::GraphicsContext> GlCoreRhi::begin_graphics() {
+	SRB2_ASSERT(graphics_context_active_ == false);
+	graphics_context_active_ = true;
+	return rhi::Handle<rhi::GraphicsContext>(0, graphics_context_generation_);
+}
+
+void GlCoreRhi::end_graphics(rhi::Handle<rhi::GraphicsContext> handle) {
+	SRB2_ASSERT(graphics_context_active_ == true);
+	SRB2_ASSERT(current_pipeline_.has_value() == false && current_render_pass_.has_value() == false);
+	graphics_context_generation_ += 1;
+	graphics_context_active_ = false;
+	gl_->Flush(); GL_ASSERT
+}
+
+rhi::Handle<rhi::TransferContext> GlCoreRhi::begin_transfer()
+{
+	SRB2_ASSERT(graphics_context_active_ == false);
+	SRB2_ASSERT(transfer_context_active_ == false);
+
+	transfer_context_generation_ += 1;
+	transfer_context_active_ = true;
+
+	return rhi::Handle<rhi::TransferContext>(0, transfer_context_generation_);
+}
+
+void GlCoreRhi::end_transfer(rhi::Handle<rhi::TransferContext> ctx)
+{
+	SRB2_ASSERT(graphics_context_active_ == false);
+	SRB2_ASSERT(transfer_context_active_ == true);
+
+	transfer_context_active_ = false;
+}
+
+void GlCoreRhi::present() {
+	SRB2_ASSERT(platform_ != nullptr);
+	SRB2_ASSERT(graphics_context_active_ == false);
+
+	platform_->present();
+}
+
+void GlCoreRhi::begin_default_render_pass(Handle<GraphicsContext> ctx, bool clear) {
+	SRB2_ASSERT(platform_ != nullptr);
+	SRB2_ASSERT(graphics_context_active_ == true);
+	SRB2_ASSERT(current_render_pass_.has_value() == false);
+
+	const Rect fb_rect = platform_->get_default_framebuffer_dimensions();
+
+	gl_->BindFramebuffer(GL_FRAMEBUFFER, 0); GL_ASSERT
+	gl_->Disable(GL_SCISSOR_TEST);
+	gl_->Viewport(0, 0, fb_rect.w, fb_rect.h); GL_ASSERT
+
+	if (clear)
+	{
+		gl_->ClearColor(0.0f, 0.0f, 0.0f, 1.0f); GL_ASSERT
+		gl_->ClearDepth(1.0f); GL_ASSERT
+		gl_->ClearStencil(0); GL_ASSERT
+		gl_->Clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); GL_ASSERT
+	}
+
+	current_render_pass_ = GlCoreRhi::DefaultRenderPassState {};
+}
+
+void GlCoreRhi::begin_render_pass(Handle<GraphicsContext> ctx, const RenderPassBeginInfo& info) {
+	SRB2_ASSERT(graphics_context_active_ == true && graphics_context_generation_ == ctx.generation());
+	SRB2_ASSERT(current_render_pass_.has_value() == false);
+
+	SRB2_ASSERT(render_pass_slab_.is_valid(info.render_pass) == true);
+	auto& rp = *static_cast<GlCoreRenderPass*>(&render_pass_slab_[info.render_pass]);
+	SRB2_ASSERT(rp.desc.depth_format.has_value() == info.depth_attachment.has_value());
+
+	auto fb_itr = framebuffers_.find(GlCoreFramebufferKey {info.color_attachment, info.depth_attachment});
+	if (fb_itr == framebuffers_.end()) {
+		// Create a new framebuffer for this color-depth pair
+		GLuint fb_name;
+		gl_->GenFramebuffers(1, &fb_name);
+		gl_->BindFramebuffer(GL_FRAMEBUFFER, fb_name);
+		fb_itr = framebuffers_.insert(
+			{GlCoreFramebufferKey {info.color_attachment, info.depth_attachment}, static_cast<uint32_t>(fb_name)}).first;
+
+		// TODO bind buffers correctly
+	}
+	auto& fb = *fb_itr;
+	gl_->BindFramebuffer(GL_FRAMEBUFFER, fb.second);
+	gl_->Disable(GL_SCISSOR_TEST);
+
+	if (rp.desc.load_op == rhi::AttachmentLoadOp::kClear) {
+		gl_->ClearColor(info.clear_color.r, info.clear_color.g, info.clear_color.b, info.clear_color.a);
+		gl_->ClearDepth(1.f);
+		gl_->ClearStencil(0);
+		gl_->Clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
+	}
+
+	current_render_pass_ = info;
+}
+
+void GlCoreRhi::end_render_pass(Handle<GraphicsContext> ctx) {
+	SRB2_ASSERT(graphics_context_active_ == true && graphics_context_generation_ == ctx.generation());
+	SRB2_ASSERT(current_render_pass_.has_value() == true);
+
+	current_pipeline_ = std::nullopt;
+	current_render_pass_ = std::nullopt;
+}
+
+void GlCoreRhi::bind_pipeline(Handle<GraphicsContext> ctx, Handle<Pipeline> pipeline) {
+	SRB2_ASSERT(graphics_context_active_ == true && graphics_context_generation_ == ctx.generation());
+	SRB2_ASSERT(current_render_pass_.has_value() == true);
+
+	SRB2_ASSERT(pipeline_slab_.is_valid(pipeline) == true);
+	auto& pl = *static_cast<GlCorePipeline*>(&pipeline_slab_[pipeline]);
+	auto& desc = pl.desc;
+
+	gl_->UseProgram(pl.program); GL_ASSERT
+
+	gl_->Disable(GL_SCISSOR_TEST); GL_ASSERT
+
+	if (desc.depth_attachment) {
+		gl_->Enable(GL_DEPTH_TEST); GL_ASSERT
+		GLenum depth_func = map_compare_func(desc.depth_attachment->func);
+		SRB2_ASSERT(depth_func != GL_ZERO);
+		gl_->DepthFunc(depth_func); GL_ASSERT
+		gl_->DepthMask(desc.depth_attachment->write ? GL_TRUE : GL_FALSE); GL_ASSERT
+	} else {
+		gl_->Disable(GL_DEPTH_TEST); GL_ASSERT
+	}
+
+	if (desc.color_attachment.blend) {
+		rhi::BlendDesc& bl = *desc.color_attachment.blend;
+		gl_->Enable(GL_BLEND); GL_ASSERT
+		gl_->BlendFuncSeparate(map_blend_factor(bl.source_factor_color),
+							map_blend_factor(bl.dest_factor_color),
+							map_blend_factor(bl.source_factor_alpha),
+							map_blend_factor(bl.dest_factor_alpha)); GL_ASSERT
+		gl_->BlendEquationSeparate(map_blend_function(bl.color_function), map_blend_function(bl.alpha_function)); GL_ASSERT
+		gl_->BlendColor(desc.blend_color.r, desc.blend_color.g, desc.blend_color.b, desc.blend_color.a); GL_ASSERT
+	} else {
+		gl_->Disable(GL_BLEND);
+	}
+
+	gl_->ColorMask(desc.color_attachment.color_mask.r ? GL_TRUE : GL_FALSE,
+				desc.color_attachment.color_mask.g ? GL_TRUE : GL_FALSE,
+				desc.color_attachment.color_mask.b ? GL_TRUE : GL_FALSE,
+				desc.color_attachment.color_mask.a ? GL_TRUE : GL_FALSE); GL_ASSERT
+
+	GLenum cull_face = map_cull_mode(desc.cull);
+	if (cull_face == GL_NONE) {
+		gl_->Disable(GL_CULL_FACE); GL_ASSERT
+	} else {
+		gl_->Enable(GL_CULL_FACE); GL_ASSERT
+		gl_->CullFace(cull_face); GL_ASSERT
+	}
+	gl_->FrontFace(map_winding(desc.winding)); GL_ASSERT
+
+	current_pipeline_ = pipeline;
+	current_primitive_type_ = desc.primitive;
+}
+
+void GlCoreRhi::bind_uniform_set(Handle<GraphicsContext> ctx, uint32_t slot, Handle<UniformSet> set)
+{
+	SRB2_ASSERT(graphics_context_active_ == true && graphics_context_generation_ == ctx.generation());
+	SRB2_ASSERT(current_render_pass_.has_value() == true && current_pipeline_.has_value() == true);
+
+	SRB2_ASSERT(pipeline_slab_.is_valid(*current_pipeline_));
+	auto& pl = *static_cast<GlCorePipeline*>(&pipeline_slab_[*current_pipeline_]);
+
+	SRB2_ASSERT(uniform_set_slab_.is_valid(set));
+	auto& us = *static_cast<GlCoreUniformSet*>(&uniform_set_slab_[set]);
+
+	auto& uniform_input = pl.desc.uniform_input;
+	SRB2_ASSERT(slot < uniform_input.enabled_uniforms.size());
+	SRB2_ASSERT(us.uniforms.size() == uniform_input.enabled_uniforms[slot].size());
+
+	// Assert compatibility of uniform set with pipeline's set slot
+	for (size_t i = 0; i < us.uniforms.size(); i++)
+	{
+		SRB2_ASSERT(
+			rhi::uniform_format(uniform_input.enabled_uniforms[slot][i]) == rhi::uniform_variant_format(us.uniforms[i])
+		);
+	}
+
+	// Apply uniforms
+	// TODO use Uniform Buffer Objects to optimize this.
+	// We don't really *need* to, though, probably...
+	// Also, we know that any given uniform name is uniquely present in a single uniform group asserted during pipeline
+	// compilation. This is an RHI requirement to support backends that don't have UBOs.
+	for (size_t i = 0; i < us.uniforms.size(); i++)
+	{
+		auto& uniform_name = uniform_input.enabled_uniforms[slot][i];
+		auto& update_data = us.uniforms[i];
+		SRB2_ASSERT(pl.uniform_locations.find(uniform_name) != pl.uniform_locations.end());
+		GLuint pipeline_uniform = pl.uniform_locations[uniform_name];
+
+		struct UniformVariantVisitor {
+			GladGLContext* gl_;
+			rhi::UniformName name;
+			GLuint uniform;
+
+			void operator()(const float& value) const noexcept {
+				gl_->Uniform1f(uniform, value); GL_ASSERT
+			}
+			void operator()(const std::array<float, 2>& value) const noexcept {
+				gl_->Uniform2f(uniform, value[0], value[1]); GL_ASSERT
+			}
+			void operator()(const std::array<float, 3>& value) const noexcept {
+				gl_->Uniform3f(uniform, value[0], value[1], value[2]); GL_ASSERT
+			}
+			void operator()(const std::array<float, 4>& value) const noexcept {
+				gl_->Uniform4f(uniform, value[0], value[1], value[2], value[3]); GL_ASSERT
+			}
+			void operator()(const int32_t& value) const noexcept {
+				gl_->Uniform1i(uniform, value); GL_ASSERT
+			}
+			void operator()(const std::array<int32_t, 2>& value) const noexcept {
+				gl_->Uniform2i(uniform, value[0], value[1]); GL_ASSERT
+			}
+			void operator()(const std::array<int32_t, 3>& value) const noexcept {
+				gl_->Uniform3i(uniform, value[0], value[1], value[2]); GL_ASSERT
+			}
+			void operator()(const std::array<int32_t, 4>& value) const noexcept {
+				gl_->Uniform4i(uniform, value[0], value[1], value[2], value[3]); GL_ASSERT
+			}
+			void operator()(const std::array<std::array<float, 2>, 2>& value) const noexcept {
+				gl_->UniformMatrix2fv(uniform, 1, false, reinterpret_cast<const GLfloat*>(&value)); GL_ASSERT
+			}
+			void operator()(const std::array<std::array<float, 3>, 3>& value) const noexcept {
+				gl_->UniformMatrix3fv(uniform, 1, false, reinterpret_cast<const GLfloat*>(&value)); GL_ASSERT
+			}
+			void operator()(const std::array<std::array<float, 4>, 4>& value) const noexcept {
+				gl_->UniformMatrix4fv(uniform, 1, false, reinterpret_cast<const GLfloat*>(&value)); GL_ASSERT
+			}
+		};
+		std::visit(UniformVariantVisitor {gl_.get(), uniform_name, pipeline_uniform}, update_data);
+	}
+}
+
+void GlCoreRhi::bind_binding_set(Handle<GraphicsContext> ctx, Handle<BindingSet> set)
+{
+	SRB2_ASSERT(graphics_context_active_ == true && graphics_context_generation_ == ctx.generation());
+	SRB2_ASSERT(current_render_pass_.has_value() == true && current_pipeline_.has_value() == true);
+
+	SRB2_ASSERT(pipeline_slab_.is_valid(*current_pipeline_));
+	auto& pl = *static_cast<GlCorePipeline*>(&pipeline_slab_[*current_pipeline_]);
+
+	SRB2_ASSERT(binding_set_slab_.is_valid(set));
+	auto& bs = *static_cast<GlCoreBindingSet*>(&binding_set_slab_[set]);
+
+	SRB2_ASSERT(bs.textures.size() == pl.desc.sampler_input.enabled_samplers.size());
+
+	// Bind the vertex array for drawing
+	// TODO assert compatibility of binding set. The VAO's attributes must match the pipeline.
+	gl_->BindVertexArray(bs.vao);
+
+	// Index buffer is part of VAO.
+	gl_->BindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
+
+	// Bind the samplers to the uniforms
+	for (auto& texture_binding : bs.textures)
+	{
+		auto sampler_name = texture_binding.first;
+		GLuint texture_gl_name = texture_binding.second;
+		GLuint sampler_uniform_loc = pl.sampler_locations[sampler_name];
+		GLenum active_texture = GL_TEXTURE0;
+		GLuint uniform_value = 0;
+		switch (sampler_name) {
+		case rhi::SamplerName::kSampler0:
+			active_texture = GL_TEXTURE0;
+			uniform_value = 0;
+			break;
+		case rhi::SamplerName::kSampler1:
+			active_texture = GL_TEXTURE0 + 1;
+			uniform_value = 1;
+			break;
+		case rhi::SamplerName::kSampler2:
+			active_texture = GL_TEXTURE0 + 2;
+			uniform_value = 2;
+			break;
+		case rhi::SamplerName::kSampler3:
+			active_texture = GL_TEXTURE0 + 3;
+			uniform_value = 3;
+			break;
+		}
+		gl_->ActiveTexture(active_texture); GL_ASSERT
+		gl_->BindTexture(GL_TEXTURE_2D, texture_gl_name); GL_ASSERT
+		gl_->Uniform1i(sampler_uniform_loc, uniform_value); GL_ASSERT
+	}
+}
+
+void GlCoreRhi::bind_index_buffer(Handle<GraphicsContext> ctx, Handle<Buffer> buffer)
+{
+	SRB2_ASSERT(transfer_context_active_ == false);
+	SRB2_ASSERT(graphics_context_active_ == true && graphics_context_generation_ == ctx.generation());
+	SRB2_ASSERT(current_render_pass_.has_value() == true && current_pipeline_.has_value() == true);
+
+	SRB2_ASSERT(buffer_slab_.is_valid(buffer));
+	auto& ib = *static_cast<GlCoreBuffer*>(&buffer_slab_[buffer]);
+
+	SRB2_ASSERT(ib.desc.type == rhi::BufferType::kIndexBuffer);
+
+	gl_->BindBuffer(GL_ELEMENT_ARRAY_BUFFER, ib.buffer);
+}
+
+void GlCoreRhi::set_scissor(Handle<GraphicsContext> ctx, const Rect& rect) {
+	SRB2_ASSERT(graphics_context_active_ == true && graphics_context_generation_ == ctx.generation());
+	SRB2_ASSERT(current_render_pass_.has_value() == true && current_pipeline_.has_value() == true);
+
+	gl_->Enable(GL_SCISSOR_TEST);
+	gl_->Scissor(rect.x, rect.y, rect.w, rect.h);
+}
+
+void GlCoreRhi::set_viewport(Handle<GraphicsContext> ctx, const Rect& rect) {
+	SRB2_ASSERT(graphics_context_active_ == true && graphics_context_generation_ == ctx.generation());
+	SRB2_ASSERT(current_render_pass_.has_value() == true && current_pipeline_.has_value() == true);
+
+	gl_->Viewport(rect.x, rect.y, rect.w, rect.h);
+}
+
+void GlCoreRhi::draw(Handle<GraphicsContext> ctx, uint32_t vertex_count, uint32_t first_vertex) {
+	SRB2_ASSERT(graphics_context_active_ == true && graphics_context_generation_ == ctx.generation());
+	SRB2_ASSERT(current_render_pass_.has_value() == true && current_pipeline_.has_value() == true);
+
+	gl_->DrawArrays(map_primitive_mode(current_primitive_type_), first_vertex, vertex_count); GL_ASSERT
+}
+
+void GlCoreRhi::draw_indexed(Handle<GraphicsContext> ctx,
+							uint32_t index_count,
+							uint32_t first_index) {
+	SRB2_ASSERT(graphics_context_active_ == true && graphics_context_generation_ == ctx.generation());
+	gl_->DrawElements(map_primitive_mode(current_primitive_type_), index_count, GL_UNSIGNED_SHORT, reinterpret_cast<const void*>(first_index * 2 + index_buffer_offset_)); GL_ASSERT
+}
+
+
+void GlCoreRhi::read_pixels(Handle<GraphicsContext> ctx, const Rect& rect, tcb::span<std::byte> out)
+{
+	SRB2_ASSERT(graphics_context_active_ == true && graphics_context_generation_ == ctx.generation());
+	SRB2_ASSERT(current_render_pass_.has_value());
+
+	SRB2_ASSERT(out.size_bytes() == rect.w * rect.h);
+	gl_->ReadPixels(rect.x, rect.y, rect.w, rect.h, GL_RGBA, GL_UNSIGNED_BYTE, out.data());
+}
+
+void GlCoreRhi::finish() {
+	SRB2_ASSERT(graphics_context_active_ == false);
+
+	for (auto it = binding_set_slab_.cbegin(); it != binding_set_slab_.cend(); it++)
+	{
+		gl_->BindVertexArray(0); GL_ASSERT
+		GLuint vao = reinterpret_cast<const GlCoreBindingSet&>(*it).vao;
+		gl_->DeleteVertexArrays(1, &vao); GL_ASSERT
+	}
+	binding_set_slab_.clear();
+	uniform_set_slab_.clear();
+
+	for (auto it = disposal_.begin(); it != disposal_.end(); it++)
+	{
+		(*it)();
+	}
+
+	disposal_.clear(); GL_ASSERT
+}
diff --git a/src/rhi/gl3_core/gl3_core_rhi.hpp b/src/rhi/gl3_core/gl3_core_rhi.hpp
new file mode 100644
index 000000000..a11d58d52
--- /dev/null
+++ b/src/rhi/gl3_core/gl3_core_rhi.hpp
@@ -0,0 +1,148 @@
+#ifndef __SRB2_RHI_GLES2_RHI_HPP__
+#define __SRB2_RHI_GLES2_RHI_HPP__
+
+#include <functional>
+#include <memory>
+#include <optional>
+#include <string>
+#include <tuple>
+#include <unordered_map>
+#include <vector>
+
+#include "../rhi.hpp"
+
+namespace srb2::rhi {
+
+struct GlCoreFramebufferKey {
+	TextureOrRenderbuffer color;
+	std::optional<TextureOrRenderbuffer> depth;
+
+	bool operator==(const GlCoreFramebufferKey& rhs) const noexcept {
+		return color == rhs.color && depth == rhs.depth;
+	}
+
+	bool operator!=(const GlCoreFramebufferKey& rhs) const noexcept {
+		return !(*this == rhs);
+	}
+};
+
+} // namespace srb2::rhi
+
+// To make sure the compiler selects the struct specialization of std::hash for GlCoreFramebufferKey,
+// we need to split the namespace declarations _before_ the instantiation of std::unordered_map.
+
+template <>
+struct std::hash<srb2::rhi::GlCoreFramebufferKey> {
+	std::size_t operator()(const srb2::rhi::GlCoreFramebufferKey& key) const {
+		struct GetHandleHashVisitor {
+			uint32_t operator()(const srb2::rhi::Handle<srb2::rhi::Texture>& handle) const noexcept {
+				return std::hash<srb2::rhi::Handle<srb2::rhi::Texture>>()(handle);
+			}
+			uint32_t operator()(const srb2::rhi::Handle<srb2::rhi::Renderbuffer>& handle) const noexcept {
+				return std::hash<srb2::rhi::Handle<srb2::rhi::Renderbuffer>>()(handle);
+			}
+		};
+		std::size_t color_hash = std::visit(GetHandleHashVisitor {}, key.color);
+		std::size_t depth_hash = 0;
+		if (key.depth) {
+			depth_hash = std::visit(GetHandleHashVisitor {}, *key.depth);
+		}
+		return color_hash ^ (depth_hash << 1);
+	}
+};
+
+struct GladGLContext;
+
+namespace srb2::rhi {
+
+typedef void (*GlProc)(void);
+typedef GlProc (*GlLoadFunc)(const char* name);
+
+/// @brief Platform-specific implementation details for the GLES2 backend.
+struct GlCorePlatform {
+	virtual ~GlCorePlatform();
+
+	virtual void present() = 0;
+	virtual std::tuple<std::string, std::string> find_shader_sources(PipelineProgram program) = 0;
+	virtual Rect get_default_framebuffer_dimensions() = 0;
+};
+
+class GlCoreRhi final : public Rhi {
+	std::unique_ptr<GlCorePlatform> platform_;
+
+	std::unique_ptr<GladGLContext> gl_;
+
+	Slab<RenderPass> render_pass_slab_;
+	Slab<Texture> texture_slab_;
+	Slab<Buffer> buffer_slab_;
+	Slab<Renderbuffer> renderbuffer_slab_;
+	Slab<Pipeline> pipeline_slab_;
+	Slab<UniformSet> uniform_set_slab_;
+	Slab<BindingSet> binding_set_slab_;
+
+	std::unordered_map<GlCoreFramebufferKey, uint32_t> framebuffers_ {16};
+
+	struct DefaultRenderPassState {};
+	using RenderPassState = std::variant<DefaultRenderPassState, RenderPassBeginInfo>;
+	std::optional<RenderPassState> current_render_pass_;
+	std::optional<Handle<Pipeline>> current_pipeline_;
+	PrimitiveType current_primitive_type_ = PrimitiveType::kPoints;
+	bool graphics_context_active_ = false;
+	bool transfer_context_active_ = false;
+	uint32_t graphics_context_generation_ = 0;
+	uint32_t index_buffer_offset_ = 0;
+	uint32_t transfer_context_generation_ = 0;
+
+	std::vector<std::function<void()>> disposal_;
+
+public:
+	GlCoreRhi(std::unique_ptr<GlCorePlatform>&& platform, GlLoadFunc load_func);
+	virtual ~GlCoreRhi();
+
+	virtual Handle<RenderPass> create_render_pass(const RenderPassDesc& desc) override;
+	virtual void destroy_render_pass(Handle<RenderPass> handle) override;
+	virtual Handle<Pipeline> create_pipeline(const PipelineDesc& desc) override;
+	virtual void destroy_pipeline(Handle<Pipeline> handle) override;
+
+	virtual Handle<Texture> create_texture(const TextureDesc& desc) override;
+	virtual void destroy_texture(Handle<Texture> handle) override;
+	virtual Handle<Buffer> create_buffer(const BufferDesc& desc) override;
+	virtual void destroy_buffer(Handle<Buffer> handle) override;
+	virtual Handle<Renderbuffer> create_renderbuffer(const RenderbufferDesc& desc) override;
+	virtual void destroy_renderbuffer(Handle<Renderbuffer> handle) override;
+
+	virtual Handle<TransferContext> begin_transfer() override;
+	virtual void end_transfer(Handle<TransferContext> handle) override;
+
+	virtual void update_buffer_contents(Handle<TransferContext> ctx, Handle<Buffer> buffer, uint32_t offset, tcb::span<const std::byte> data) override;
+	virtual void update_texture(Handle<TransferContext> ctx, Handle<Texture> texture, Rect region, srb2::rhi::PixelFormat data_format, tcb::span<const std::byte> data) override;
+	virtual Handle<UniformSet> create_uniform_set(Handle<TransferContext> ctx, const CreateUniformSetInfo& info) override;
+	virtual Handle<BindingSet> create_binding_set(Handle<TransferContext> ctx, Handle<Pipeline> pipeline, const CreateBindingSetInfo& info) override;
+
+	virtual Handle<GraphicsContext> begin_graphics() override;
+	virtual void end_graphics(Handle<GraphicsContext> ctx) override;
+
+	// Graphics context functions
+	virtual void begin_default_render_pass(Handle<GraphicsContext> ctx, bool clear) override;
+	virtual void begin_render_pass(Handle<GraphicsContext> ctx, const RenderPassBeginInfo& info) override;
+	virtual void end_render_pass(Handle<GraphicsContext> ctx) override;
+	virtual void bind_pipeline(Handle<GraphicsContext> ctx, Handle<Pipeline> pipeline) override;
+	virtual void bind_uniform_set(Handle<GraphicsContext> ctx, uint32_t slot, Handle<UniformSet> set) override;
+	virtual void bind_binding_set(Handle<GraphicsContext> ctx, Handle<BindingSet> set) override;
+	virtual void bind_index_buffer(Handle<GraphicsContext> ctx, Handle<Buffer> buffer) override;
+	virtual void set_scissor(Handle<GraphicsContext> ctx, const Rect& rect) override;
+	virtual void set_viewport(Handle<GraphicsContext> ctx, const Rect& rect) override;
+	virtual void draw(Handle<GraphicsContext> ctx, uint32_t vertex_count, uint32_t first_vertex) override;
+	virtual void draw_indexed(Handle<GraphicsContext> ctx,
+							  uint32_t index_count,
+							  uint32_t first_index) override;
+	virtual void read_pixels(Handle<GraphicsContext> ctx, const Rect& rect, tcb::span<std::byte> out) override;
+
+	virtual void present() override;
+
+	virtual void finish() override;
+};
+
+} // namespace srb2::rhi
+
+#endif // __SRB2_RHI_GLES2_RHI_HPP__
diff --git a/src/rhi/gles2/CMakeLists.txt b/src/rhi/gles2/CMakeLists.txt
new file mode 100644
index 000000000..eaa80c4fa
--- /dev/null
+++ b/src/rhi/gles2/CMakeLists.txt
@@ -0,0 +1 @@
+# Backend not available yet :)
diff --git a/src/rhi/gles2/gles2_rhi.cpp b/src/rhi/gles2/gles2_rhi.cpp
new file mode 100644
index 000000000..8e9d61f7d
--- /dev/null
+++ b/src/rhi/gles2/gles2_rhi.cpp
@@ -0,0 +1,1122 @@
+#include "gles2_rhi.hpp"
+
+#include <memory>
+#include <string>
+#include <tuple>
+#include <unordered_map>
+#include <utility>
+
+#include <glad/gles2.h>
+
+using namespace srb2;
+
+using srb2::rhi::Gles2Platform;
+using srb2::rhi::Gles2Rhi;
+
+namespace {
+
+template <typename D, typename B>
+std::unique_ptr<D, std::default_delete<D>> static_unique_ptr_cast(std::unique_ptr<B, std::default_delete<B>> ptr) {
+	D* derived = static_cast<D*>(ptr.release());
+	return std::unique_ptr<D, std::default_delete<D>>(derived, std::default_delete<D>());
+}
+
+constexpr GLenum map_pixel_format(rhi::PixelFormat format) {
+	switch (format) {
+	case rhi::PixelFormat::kRGBA8:
+		// requires extension GL_OES_rgb8_rgba8, which is always requested
+		return GL_RGBA8_OES;
+	case rhi::PixelFormat::kDepth16:
+		return GL_DEPTH_COMPONENT16;
+	case rhi::PixelFormat::kStencil8:
+		return GL_STENCIL_INDEX8;
+	default:
+		return GL_ZERO;
+	}
+}
+
+constexpr std::tuple<GLenum, GLenum, GLuint> map_pixel_data_format(rhi::PixelFormat format) {
+	GLenum layout = GL_ZERO;
+	GLenum type = GL_ZERO;
+	GLuint size = 0;
+	switch (format) {
+	case rhi::PixelFormat::kR8:
+		layout = GL_LUMINANCE;
+		type = GL_UNSIGNED_BYTE;
+		size = 1;
+		break;
+	case rhi::PixelFormat::kRGBA8:
+		layout = GL_RGBA;
+		type = GL_UNSIGNED_BYTE;
+		size = 4;
+		break;
+	default:
+		break;
+	}
+	return std::tuple(layout, type, size);
+}
+
+constexpr GLenum map_texture_format(rhi::TextureFormat format) {
+	switch (format) {
+	case rhi::TextureFormat::kRGBA:
+		return GL_RGBA;
+	case rhi::TextureFormat::kRGB:
+		return GL_RGB;
+	case rhi::TextureFormat::kLuminance:
+		return GL_LUMINANCE;
+	default:
+		return GL_ZERO;
+	}
+}
+
+constexpr GLenum map_buffer_type(rhi::BufferType type) {
+	switch (type) {
+	case rhi::BufferType::kVertexBuffer:
+		return GL_ARRAY_BUFFER;
+	case rhi::BufferType::kIndexBuffer:
+		return GL_ELEMENT_ARRAY_BUFFER;
+	default:
+		return GL_ZERO;
+	}
+}
+
+constexpr GLenum map_buffer_usage(rhi::BufferUsage usage) {
+	switch (usage) {
+	case rhi::BufferUsage::kImmutable:
+		return GL_STATIC_DRAW;
+	case rhi::BufferUsage::kDynamic:
+		return GL_DYNAMIC_DRAW;
+	default:
+		return GL_ZERO;
+	}
+}
+
+constexpr GLenum map_compare_func(rhi::CompareFunc func) {
+	switch (func) {
+	case rhi::CompareFunc::kNever:
+		return GL_NEVER;
+	case rhi::CompareFunc::kLess:
+		return GL_LESS;
+	case rhi::CompareFunc::kEqual:
+		return GL_EQUAL;
+	case rhi::CompareFunc::kLessEqual:
+		return GL_LEQUAL;
+	case rhi::CompareFunc::kGreater:
+		return GL_GREATER;
+	case rhi::CompareFunc::kNotEqual:
+		return GL_NOTEQUAL;
+	case rhi::CompareFunc::kGreaterEqual:
+		return GL_GEQUAL;
+	case rhi::CompareFunc::kAlways:
+		return GL_ALWAYS;
+	default:
+		return GL_ZERO;
+	}
+}
+
+constexpr GLenum map_blend_factor(rhi::BlendFactor factor) {
+	switch (factor) {
+	case rhi::BlendFactor::kZero:
+		return GL_ZERO;
+	case rhi::BlendFactor::kOne:
+		return GL_ONE;
+	case rhi::BlendFactor::kSource:
+		return GL_SRC_COLOR;
+	case rhi::BlendFactor::kOneMinusSource:
+		return GL_ONE_MINUS_SRC_COLOR;
+	case rhi::BlendFactor::kSourceAlpha:
+		return GL_SRC_ALPHA;
+	case rhi::BlendFactor::kOneMinusSourceAlpha:
+		return GL_ONE_MINUS_SRC_ALPHA;
+	case rhi::BlendFactor::kDest:
+		return GL_DST_COLOR;
+	case rhi::BlendFactor::kOneMinusDest:
+		return GL_ONE_MINUS_DST_COLOR;
+	case rhi::BlendFactor::kDestAlpha:
+		return GL_DST_ALPHA;
+	case rhi::BlendFactor::kOneMinusDestAlpha:
+		return GL_ONE_MINUS_DST_ALPHA;
+	case rhi::BlendFactor::kConstant:
+		return GL_CONSTANT_COLOR;
+	case rhi::BlendFactor::kOneMinusConstant:
+		return GL_ONE_MINUS_CONSTANT_COLOR;
+	case rhi::BlendFactor::kConstantAlpha:
+		return GL_CONSTANT_ALPHA;
+	case rhi::BlendFactor::kOneMinusConstantAlpha:
+		return GL_ONE_MINUS_CONSTANT_ALPHA;
+	case rhi::BlendFactor::kSourceAlphaSaturated:
+		return GL_SRC_ALPHA_SATURATE;
+	default:
+		return GL_ONE;
+	}
+}
+
+constexpr GLenum map_blend_function(rhi::BlendFunction function) {
+	switch (function) {
+	case rhi::BlendFunction::kAdd:
+		return GL_FUNC_ADD;
+	case rhi::BlendFunction::kSubtract:
+		return GL_FUNC_SUBTRACT;
+	case rhi::BlendFunction::kReverseSubtract:
+		return GL_FUNC_REVERSE_SUBTRACT;
+	default:
+		return GL_FUNC_ADD;
+	}
+}
+
+constexpr GLenum map_cull_mode(rhi::CullMode mode) {
+	switch (mode) {
+	case rhi::CullMode::kNone:
+		return GL_NONE;
+	case rhi::CullMode::kFront:
+		return GL_FRONT;
+	case rhi::CullMode::kBack:
+		return GL_BACK;
+	default:
+		return GL_NONE;
+	}
+}
+
+constexpr GLenum map_winding(rhi::FaceWinding winding) {
+	switch (winding) {
+	case rhi::FaceWinding::kCounterClockwise:
+		return GL_CCW;
+	case rhi::FaceWinding::kClockwise:
+		return GL_CW;
+	default:
+		return GL_CCW;
+	}
+}
+
+constexpr GLenum map_primitive_mode(rhi::PrimitiveType type) {
+	switch (type) {
+	case rhi::PrimitiveType::kPoints:
+		return GL_POINTS;
+	case rhi::PrimitiveType::kLines:
+		return GL_LINES;
+	case rhi::PrimitiveType::kLineStrip:
+		return GL_LINE_STRIP;
+	case rhi::PrimitiveType::kTriangles:
+		return GL_TRIANGLES;
+	case rhi::PrimitiveType::kTriangleStrip:
+		return GL_TRIANGLE_STRIP;
+	case rhi::PrimitiveType::kTriangleFan:
+		return GL_TRIANGLE_FAN;
+	default:
+		return GL_ZERO;
+	}
+}
+
+constexpr const char* map_vertex_attribute_symbol_name(rhi::VertexAttributeName name) {
+	switch (name) {
+	case rhi::VertexAttributeName::kPosition:
+		return "a_position";
+	case rhi::VertexAttributeName::kNormal:
+		return "a_normal";
+	case rhi::VertexAttributeName::kColor:
+		return "a_color";
+	case rhi::VertexAttributeName::kTexCoord0:
+		return "a_texcoord0";
+	case rhi::VertexAttributeName::kTexCoord1:
+		return "a_texcoord1";
+	default:
+		return nullptr;
+	}
+}
+
+/*
+constexpr const char* map_vertex_attribute_enable_define(rhi::VertexAttributeName name) {
+	switch (name) {
+	case rhi::VertexAttributeName::kPosition:
+		return "ENABLE_VA_POSITION";
+	case rhi::VertexAttributeName::kNormal:
+		return "ENABLE_VA_NORMAL";
+	case rhi::VertexAttributeName::kColor:
+		return "ENABLE_VA_COLOR";
+	case rhi::VertexAttributeName::kTexCoord0:
+		return "ENABLE_VA_TEXCOORD0";
+	case rhi::VertexAttributeName::kTexCoord1:
+		return "ENABLE_VA_TEXCOORD1";
+	default:
+		return nullptr;
+	}
+}
+*/
+
+constexpr const char* map_uniform_attribute_symbol_name(rhi::UniformName name) {
+	switch (name) {
+	case rhi::UniformName::kTime:
+		return "u_time";
+	case rhi::UniformName::kModelView:
+		return "u_modelview";
+	case rhi::UniformName::kProjection:
+		return "u_projection";
+	default:
+		return nullptr;
+	}
+}
+
+/*
+constexpr const char* map_uniform_attribute_enable_define(rhi::UniformName name) {
+	switch (name) {
+	case rhi::UniformName::kTime:
+		return "ENABLE_U_TIME";
+	case rhi::UniformName::kModelView:
+		return "ENABLE_U_MODELVIEW";
+	case rhi::UniformName::kProjection:
+		return "ENABLE_U_PROJECTION";
+	default:
+		return nullptr;
+	}
+}
+*/
+
+constexpr const char* map_sampler_symbol_name(rhi::SamplerName name) {
+	switch (name) {
+	case rhi::SamplerName::kSampler0:
+		return "s_sampler0";
+	case rhi::SamplerName::kSampler1:
+		return "s_sampler1";
+	case rhi::SamplerName::kSampler2:
+		return "s_sampler2";
+	case rhi::SamplerName::kSampler3:
+		return "s_sampler3";
+	default:
+		return nullptr;
+	}
+}
+
+constexpr GLenum map_vertex_attribute_format(rhi::VertexAttributeFormat format) {
+	switch (format) {
+	case rhi::VertexAttributeFormat::kFloat:
+		return GL_FLOAT;
+	case rhi::VertexAttributeFormat::kFloat2:
+		return GL_FLOAT_VEC2;
+	case rhi::VertexAttributeFormat::kFloat3:
+		return GL_FLOAT_VEC3;
+	case rhi::VertexAttributeFormat::kFloat4:
+		return GL_FLOAT_VEC4;
+	default:
+		return GL_ZERO;
+	}
+}
+
+constexpr GLenum map_vertex_attribute_type(rhi::VertexAttributeFormat format) {
+	switch (format) {
+	case rhi::VertexAttributeFormat::kFloat:
+		return GL_FLOAT;
+	case rhi::VertexAttributeFormat::kFloat2:
+		return GL_FLOAT;
+	case rhi::VertexAttributeFormat::kFloat3:
+		return GL_FLOAT;
+	case rhi::VertexAttributeFormat::kFloat4:
+		return GL_FLOAT;
+	default:
+		return GL_ZERO;
+	}
+}
+
+constexpr GLint map_vertex_attribute_format_size(rhi::VertexAttributeFormat format) {
+	switch (format) {
+	case rhi::VertexAttributeFormat::kFloat:
+		return 1;
+	case rhi::VertexAttributeFormat::kFloat2:
+		return 2;
+	case rhi::VertexAttributeFormat::kFloat3:
+		return 3;
+	case rhi::VertexAttributeFormat::kFloat4:
+		return 4;
+	default:
+		return 0;
+	}
+}
+
+constexpr GLenum map_uniform_format(rhi::UniformFormat format) {
+	switch (format) {
+	case rhi::UniformFormat::kFloat:
+		return GL_FLOAT;
+	case rhi::UniformFormat::kFloat2:
+		return GL_FLOAT_VEC2;
+	case rhi::UniformFormat::kFloat3:
+		return GL_FLOAT_VEC3;
+	case rhi::UniformFormat::kFloat4:
+		return GL_FLOAT_VEC4;
+	case rhi::UniformFormat::kInt:
+		return GL_INT;
+	case rhi::UniformFormat::kInt2:
+		return GL_INT_VEC2;
+	case rhi::UniformFormat::kInt3:
+		return GL_INT_VEC3;
+	case rhi::UniformFormat::kInt4:
+		return GL_INT_VEC4;
+	case rhi::UniformFormat::kMat2:
+		return GL_FLOAT_MAT2;
+	case rhi::UniformFormat::kMat3:
+		return GL_FLOAT_MAT3;
+	case rhi::UniformFormat::kMat4:
+		return GL_FLOAT_MAT4;
+	default:
+		return GL_ZERO;
+	}
+}
+
+struct Gles2Texture : public rhi::Texture {
+	GLuint texture;
+	rhi::TextureDesc desc;
+	Gles2Texture(GLuint texture, const rhi::TextureDesc& desc) noexcept : texture(texture), desc(desc) {}
+};
+
+struct Gles2Buffer : public rhi::Buffer {
+	GLuint buffer;
+	rhi::BufferDesc desc;
+	Gles2Buffer(GLuint buffer, const rhi::BufferDesc& desc) noexcept : buffer(buffer), desc(desc) {}
+};
+
+struct Gles2RenderPass : public rhi::RenderPass {
+	rhi::RenderPassDesc desc;
+	explicit Gles2RenderPass(const rhi::RenderPassDesc& desc) noexcept : desc(desc) {}
+};
+
+struct Gles2Renderbuffer : public rhi::Renderbuffer {
+	GLuint renderbuffer;
+
+	explicit Gles2Renderbuffer(GLuint renderbuffer) noexcept : renderbuffer(renderbuffer) {}
+};
+
+struct Gles2Pipeline : public rhi::Pipeline {
+	GLuint vertex_shader = 0;
+	GLuint fragment_shader = 0;
+	GLuint program = 0;
+	std::unordered_map<rhi::VertexAttributeName, GLuint> attrib_locations {2};
+	std::unordered_map<rhi::UniformName, GLuint> uniform_locations {2};
+	std::unordered_map<rhi::SamplerName, GLuint> sampler_locations {2};
+	rhi::PipelineDesc desc;
+
+	Gles2Pipeline() = default;
+	explicit Gles2Pipeline(GLuint vertex_shader,
+						   GLuint fragment_shader,
+						   GLuint program,
+						   const rhi::PipelineDesc& desc) noexcept
+		: vertex_shader(vertex_shader), fragment_shader(fragment_shader), program(program), desc(desc) {}
+};
+
+struct Gles2GraphicsContext : public rhi::GraphicsContext {};
+
+struct Gles2ActiveUniform {
+	GLenum type;
+	GLuint location;
+};
+
+} // namespace
+
+Gles2Platform::~Gles2Platform() = default;
+
+Gles2Rhi::Gles2Rhi(std::unique_ptr<Gles2Platform>&& platform)
+	: platform_(std::move(platform)) {
+}
+
+Gles2Rhi::~Gles2Rhi() = default;
+
+rhi::Handle<rhi::RenderPass> Gles2Rhi::create_render_pass(const rhi::RenderPassDesc& desc) {
+	SRB2_ASSERT(graphics_context_active_ == false);
+
+	// GL has no formal render pass object
+	return render_pass_slab_.insert(std::make_unique<Gles2RenderPass>(desc));
+}
+
+void Gles2Rhi::destroy_render_pass(rhi::Handle<rhi::RenderPass>&& handle) {
+	SRB2_ASSERT(graphics_context_active_ == false);
+
+	std::unique_ptr<rhi::RenderPass> buffer = render_pass_slab_.remove(handle);
+	std::unique_ptr<Gles2RenderPass> casted(static_cast<Gles2RenderPass*>(buffer.release()));
+}
+
+rhi::Handle<rhi::Texture> Gles2Rhi::create_texture(const rhi::TextureDesc& desc, srb2::rhi::PixelFormat data_format, tcb::span<const std::byte> data) {
+	SRB2_ASSERT(graphics_context_active_ == false);
+
+	GLint internal_format = map_texture_format(desc.format);
+	SRB2_ASSERT(internal_format != GL_ZERO);
+
+	GLuint name = 0;
+	glGenTextures(1, &name);
+
+	glBindTexture(GL_TEXTURE_2D, name);
+
+	// if no data is provided, the initial texture is undefined
+	GLenum format = GL_RGBA;
+	GLenum type = GL_UNSIGNED_BYTE;
+	GLuint size = 0;
+
+	const void* raw_data = nullptr;
+	std::tie(format, type, size) = map_pixel_data_format(data_format);
+	SRB2_ASSERT(format != GL_ZERO && type != GL_ZERO);
+	SRB2_ASSERT(internal_format == format);
+	if (!data.empty()) {
+		SRB2_ASSERT(size * desc.width * desc.height == data.size_bytes());
+		raw_data = static_cast<const void*>(data.data());
+	}
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
+	glTexImage2D(GL_TEXTURE_2D, 0, internal_format, desc.width, desc.height, 0, format, type, raw_data);
+
+	return texture_slab_.insert(std::make_unique<Gles2Texture>(name, desc));
+}
+
+void Gles2Rhi::destroy_texture(rhi::Handle<rhi::Texture>&& handle) {
+	SRB2_ASSERT(graphics_context_active_ == false);
+
+	SRB2_ASSERT(texture_slab_.is_valid(handle) == true);
+	std::unique_ptr<Gles2Texture> casted = static_unique_ptr_cast<Gles2Texture>(texture_slab_.remove(handle));
+	GLuint name = casted->texture;
+	disposal_.push_back([name] { glDeleteTextures(1, &name); });
+}
+
+void Gles2Rhi::update_texture(Handle<Texture> texture, Rect region, srb2::rhi::PixelFormat data_format, tcb::span<const std::byte> data) {
+	SRB2_ASSERT(graphics_context_active_ == false);
+
+	SRB2_ASSERT(texture_slab_.is_valid(texture) == true);
+	auto& t = *static_cast<Gles2Texture*>(&texture_slab_[texture]);
+
+	GLenum format = GL_RGBA;
+	GLenum type = GL_UNSIGNED_BYTE;
+	GLuint size = 0;
+	std::tie(format, type, size) = map_pixel_data_format(data_format);
+	SRB2_ASSERT(format != GL_ZERO && type != GL_ZERO);
+	SRB2_ASSERT(map_texture_format(t.desc.format) == format);
+	SRB2_ASSERT(region.w * region.h * size == data.size_bytes());
+	SRB2_ASSERT(region.x + region.w < t.desc.width && region.y + region.h < t.desc.height);
+
+	glActiveTexture(GL_TEXTURE0);
+	glBindTexture(GL_TEXTURE_2D, t.texture);
+	glTexSubImage2D(GL_TEXTURE_2D, 0, region.x, region.y, region.w, region.h, format, type, reinterpret_cast<const void*>(data.data()));
+}
+
+rhi::Handle<rhi::Buffer> Gles2Rhi::create_buffer(const rhi::BufferDesc& desc, tcb::span<const std::byte> data) {
+	SRB2_ASSERT(graphics_context_active_ == false);
+
+	// If data is provided, it must match the buffer description size exactly
+	SRB2_ASSERT(data.size() != 0 ? data.size() == desc.size : true);
+
+	GLenum target = map_buffer_type(desc.type);
+	SRB2_ASSERT(target != GL_ZERO);
+
+	GLenum usage = map_buffer_usage(desc.usage);
+	SRB2_ASSERT(usage != GL_ZERO);
+
+	GLuint name = 0;
+	glGenBuffers(1, &name);
+
+	glBindBuffer(target, name);
+
+	// if no data is provided, the initial buffer data is undefined
+	const void* raw_data = nullptr;
+	if (!data.empty()) {
+		raw_data = static_cast<const void*>(data.data());
+	}
+	glBufferData(target, desc.size, raw_data, usage);
+
+	return buffer_slab_.insert(std::make_unique<Gles2Buffer>(name, desc));
+}
+
+void Gles2Rhi::destroy_buffer(rhi::Handle<rhi::Buffer>&& handle) {
+	SRB2_ASSERT(graphics_context_active_ == false);
+
+	SRB2_ASSERT(buffer_slab_.is_valid(handle) == true);
+	SRB2_ASSERT(graphics_context_active_ == false);
+	std::unique_ptr<Gles2Buffer> casted = static_unique_ptr_cast<Gles2Buffer>(buffer_slab_.remove(handle));
+	GLuint name = casted->buffer;
+
+	disposal_.push_back([name] { glDeleteBuffers(1, &name); });
+}
+
+void Gles2Rhi::update_buffer_contents(rhi::Handle<rhi::Buffer> handle, uint32_t offset, tcb::span<const std::byte> data) {
+	SRB2_ASSERT(graphics_context_active_ == false);
+
+	SRB2_ASSERT(buffer_slab_.is_valid(handle) == true);
+	auto& b = *static_cast<Gles2Buffer*>(&buffer_slab_[handle]);
+
+	if (data.size() == 0)
+		return;
+
+	SRB2_ASSERT(offset < b.desc.size && offset + data.size() < b.desc.size);
+
+	switch (b.desc.type) {
+	case rhi::BufferType::kVertexBuffer:
+		glBindBuffer(GL_ARRAY_BUFFER, b.buffer);
+		glBufferSubData(GL_ARRAY_BUFFER, offset, data.size(), data.data());
+		break;
+	case rhi::BufferType::kIndexBuffer:
+		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, b.buffer);
+		glBufferSubData(GL_ARRAY_BUFFER, offset, data.size(), data.data());
+		break;
+	}
+}
+
+rhi::Handle<rhi::Renderbuffer> Gles2Rhi::create_renderbuffer(const rhi::RenderbufferDesc& desc) {
+	SRB2_ASSERT(graphics_context_active_ == false);
+
+	GLuint name = 0;
+	glGenRenderbuffers(1, &name);
+
+	// Obtain storage up-front.
+	glBindRenderbuffer(GL_RENDERBUFFER, name);
+	glRenderbufferStorage(GL_RENDERBUFFER, map_pixel_format(desc.format), desc.width, desc.height);
+
+	return renderbuffer_slab_.insert(std::make_unique<Gles2Renderbuffer>(Gles2Renderbuffer {name}));
+}
+
+void Gles2Rhi::destroy_renderbuffer(rhi::Handle<rhi::Renderbuffer>&& handle) {
+	SRB2_ASSERT(graphics_context_active_ == false);
+
+	SRB2_ASSERT(renderbuffer_slab_.is_valid(handle) == true);
+	std::unique_ptr<Gles2Renderbuffer> casted =
+		static_unique_ptr_cast<Gles2Renderbuffer>(renderbuffer_slab_.remove(handle));
+	GLuint name = casted->renderbuffer;
+	disposal_.push_back([name] { glDeleteRenderbuffers(1, &name); });
+}
+
+rhi::Handle<rhi::Pipeline> Gles2Rhi::create_pipeline(const PipelineDesc& desc) {
+	SRB2_ASSERT(platform_ != nullptr);
+	// TODO assert compatibility of pipeline description with program using ProgramRequirements
+
+	GLuint vertex = 0;
+	GLuint fragment = 0;
+	GLuint program = 0;
+	Gles2Pipeline pipeline;
+
+	auto [vert_src, frag_src] = platform_->find_shader_sources(desc.program);
+
+	// TODO preprocess shader code with specialization defines based on pipeline configuration
+
+	const char* vert_src_arr[1] = {vert_src.c_str()};
+	const GLint vert_src_arr_lens[1] = {static_cast<GLint>(vert_src.size())};
+	const char* frag_src_arr[1] = {frag_src.c_str()};
+	const GLint frag_src_arr_lens[1] = {static_cast<GLint>(frag_src.size())};
+
+	vertex = glCreateShader(GL_VERTEX_SHADER);
+	glShaderSource(vertex, 1, vert_src_arr, vert_src_arr_lens);
+	glCompileShader(vertex);
+	GLint is_compiled = 0;
+	glGetShaderiv(vertex, GL_COMPILE_STATUS, &is_compiled);
+	if (is_compiled == GL_FALSE) {
+		GLint max_length = 0;
+		glGetShaderiv(vertex, GL_INFO_LOG_LENGTH, &max_length);
+		std::vector<GLchar> compile_error(max_length);
+		glGetShaderInfoLog(vertex, max_length, &max_length, compile_error.data());
+
+		glDeleteShader(vertex);
+		throw std::runtime_error(std::string("Vertex shader compilation failed: ") + std::string(compile_error.data()));
+	}
+	fragment = glCreateShader(GL_FRAGMENT_SHADER);
+	glShaderSource(fragment, 1, frag_src_arr, frag_src_arr_lens);
+	glCompileShader(fragment);
+	glGetShaderiv(vertex, GL_COMPILE_STATUS, &is_compiled);
+	if (is_compiled == GL_FALSE) {
+		GLint max_length = 0;
+		glGetShaderiv(fragment, GL_INFO_LOG_LENGTH, &max_length);
+		std::vector<GLchar> compile_error(max_length);
+		glGetShaderInfoLog(fragment, max_length, &max_length, compile_error.data());
+
+		glDeleteShader(fragment);
+		glDeleteShader(vertex);
+		throw std::runtime_error(std::string("Fragment shader compilation failed: ") + std::string(compile_error.data()));
+	}
+	program = glCreateProgram();
+	glAttachShader(program, vertex);
+	glAttachShader(program, fragment);
+	glLinkProgram(program);
+	glGetProgramiv(program, GL_LINK_STATUS, &is_compiled);
+	if (is_compiled == GL_FALSE) {
+		GLint max_length = 0;
+		glGetProgramiv(program, GL_INFO_LOG_LENGTH, &max_length);
+		std::vector<GLchar> link_error(max_length);
+		glGetProgramInfoLog(program, max_length, &max_length, link_error.data());
+
+		glDeleteProgram(program);
+		glDeleteShader(fragment);
+		glDeleteShader(vertex);
+		throw std::runtime_error(std::string("Pipeline program link failed: ") + std::string(link_error.data()));
+	}
+
+	std::unordered_map<std::string, Gles2ActiveUniform> active_attributes;
+	GLint active_attribute_total = -1;
+	glGetProgramiv(program, GL_ACTIVE_ATTRIBUTES, &active_attribute_total);
+	if (active_attribute_total < 0) {
+		glDeleteProgram(program);
+		glDeleteShader(fragment);
+		glDeleteShader(vertex);
+		throw std::runtime_error("Unable to retrieve program active attributes");
+	}
+	if (desc.vertex_input.attr_layouts.size() != static_cast<GLuint>(active_attribute_total)) {
+		glDeleteProgram(program);
+		glDeleteShader(fragment);
+		glDeleteShader(vertex);
+		std::string ex_msg("Pipeline's enabled attribute count does not match the linked program's total: ");
+		ex_msg.append(std::to_string(desc.vertex_input.attr_layouts.size()));
+		ex_msg.append(" vs ");
+		ex_msg.append(std::to_string(static_cast<GLuint>(active_attribute_total)));
+		throw std::runtime_error(std::move(ex_msg));
+	}
+	for (GLint i = 0; i < active_attribute_total; i++) {
+		GLsizei name_len = 0;
+		GLint size = 0;
+		GLenum type = GL_ZERO;
+		char name[256];
+		glGetActiveAttrib(program, i, 255, &name_len, &size, &type, name);
+		active_attributes.insert({std::string(name), Gles2ActiveUniform {type, static_cast<GLuint>(i)}});
+	}
+
+	std::unordered_map<std::string, Gles2ActiveUniform> active_uniforms;
+	GLint active_uniform_total = -1;
+	glGetProgramiv(program, GL_ACTIVE_UNIFORMS, &active_uniform_total);
+	if (active_uniform_total < 0) {
+		glDeleteProgram(program);
+		glDeleteShader(fragment);
+		glDeleteShader(vertex);
+		throw std::runtime_error("Unable to retrieve program active uniforms");
+	}
+	if (desc.uniform_input.enabled_uniforms.size() + desc.sampler_input.enabled_samplers.size() != static_cast<GLuint>(active_uniform_total)) {
+		glDeleteProgram(program);
+		glDeleteShader(fragment);
+		glDeleteShader(vertex);
+		std::string ex_msg("Pipeline's enabled uniform count (uniforms + samplers) does not match the linked program's total: ");
+		ex_msg.append(std::to_string(desc.uniform_input.enabled_uniforms.size()));
+		ex_msg.append(" vs ");
+		ex_msg.append(std::to_string(static_cast<GLuint>(active_uniform_total)));
+		throw std::runtime_error(std::move(ex_msg));
+	}
+	for (GLint i = 0; i < active_uniform_total; i++) {
+		GLsizei name_len = 0;
+		GLint size = 0;
+		GLenum type = GL_ZERO;
+		char name[256];
+		glGetActiveUniform(program, i, 255, &name_len, &size, &type, name);
+		active_uniforms.insert({std::string(name), Gles2ActiveUniform {type, static_cast<GLuint>(i)}});
+	}
+
+	for (auto& attr : desc.vertex_input.attr_layouts) {
+		const char* symbol_name = map_vertex_attribute_symbol_name(attr.name);
+		SRB2_ASSERT(symbol_name != nullptr);
+		if (active_attributes.find(symbol_name) == active_attributes.end()) {
+			glDeleteProgram(program);
+			glDeleteShader(fragment);
+			glDeleteShader(vertex);
+			throw std::runtime_error("Enabled attribute not found in linked program");
+		}
+		auto& active_attr = active_attributes[symbol_name];
+		auto expected_format = rhi::vertex_attribute_format(attr.name);
+		auto expected_gl_type = map_vertex_attribute_format(expected_format);
+		SRB2_ASSERT(expected_gl_type != GL_ZERO);
+		if (expected_gl_type != active_attr.type) {
+			glDeleteProgram(program);
+			glDeleteShader(fragment);
+			glDeleteShader(vertex);
+			throw std::runtime_error("Active attribute type does not match expected type");
+		}
+
+		pipeline.attrib_locations.insert({attr.name, active_attr.location});
+	}
+	for (auto& uniform : desc.uniform_input.enabled_uniforms) {
+		const char* symbol_name = map_uniform_attribute_symbol_name(uniform);
+		SRB2_ASSERT(symbol_name != nullptr);
+		if (active_uniforms.find(symbol_name) == active_uniforms.end()) {
+			glDeleteProgram(program);
+			glDeleteShader(fragment);
+			glDeleteShader(vertex);
+			throw std::runtime_error("Enabled uniform not found in linked program");
+		}
+		auto& active_uniform = active_uniforms[symbol_name];
+		auto expected_format = rhi::uniform_format(uniform);
+		auto expected_gl_type = map_uniform_format(expected_format);
+		SRB2_ASSERT(expected_gl_type != GL_ZERO);
+		if (expected_gl_type != active_uniform.type) {
+			glDeleteProgram(program);
+			glDeleteShader(fragment);
+			glDeleteShader(vertex);
+			throw std::runtime_error("Active uniform type does not match expected type");
+		}
+
+		pipeline.uniform_locations.insert({uniform, active_uniform.location});
+	}
+	for (auto& sampler : desc.sampler_input.enabled_samplers) {
+		const char* symbol_name = map_sampler_symbol_name(sampler);
+		SRB2_ASSERT(symbol_name != nullptr);
+		if (active_uniforms.find(symbol_name) == active_uniforms.end()) {
+			glDeleteProgram(program);
+			glDeleteShader(fragment);
+			glDeleteShader(vertex);
+			throw std::runtime_error("Enabled sampler not found in linked program");
+		}
+		auto& active_sampler = active_uniforms[symbol_name];
+		if (active_sampler.type != GL_SAMPLER_2D) {
+			glDeleteProgram(program);
+			glDeleteShader(fragment);
+			glDeleteShader(vertex);
+			throw std::runtime_error("Active sampler type does not match expected type");
+		}
+
+		pipeline.sampler_locations.insert({sampler, active_sampler.location});
+	}
+
+	pipeline.desc = desc;
+	pipeline.vertex_shader = vertex;
+	pipeline.fragment_shader = fragment;
+	pipeline.program = program;
+
+	return pipeline_slab_.insert(std::make_unique<Gles2Pipeline>(std::move(pipeline)));
+}
+
+void Gles2Rhi::destroy_pipeline(rhi::Handle<rhi::Pipeline>&& handle) {
+	SRB2_ASSERT(graphics_context_active_ == false);
+
+	SRB2_ASSERT(pipeline_slab_.is_valid(handle) == true);
+	std::unique_ptr<Gles2Pipeline> casted = static_unique_ptr_cast<Gles2Pipeline>(pipeline_slab_.remove(handle));
+	GLuint vertex_shader = casted->vertex_shader;
+	GLuint fragment_shader = casted->fragment_shader;
+	GLuint program = casted->program;
+
+	disposal_.push_back([=] { glDeleteShader(fragment_shader); });
+	disposal_.push_back([=] { glDeleteShader(vertex_shader); });
+	disposal_.push_back([=] { glDeleteProgram(program); });
+}
+
+rhi::Handle<rhi::GraphicsContext> Gles2Rhi::begin_graphics() {
+	SRB2_ASSERT(graphics_context_active_ == false);
+	graphics_context_active_ = true;
+	return rhi::Handle<rhi::GraphicsContext>(0, graphics_context_generation_);
+}
+
+void Gles2Rhi::end_graphics(rhi::Handle<rhi::GraphicsContext>&& handle) {
+	SRB2_ASSERT(graphics_context_active_ == true);
+	SRB2_ASSERT(current_pipeline_.has_value() == false && current_render_pass_.has_value() == false);
+	graphics_context_generation_ += 1;
+	graphics_context_active_ = false;
+	glFlush();
+}
+
+void Gles2Rhi::present() {
+	SRB2_ASSERT(platform_ != nullptr);
+	SRB2_ASSERT(graphics_context_active_ == false);
+
+	platform_->present();
+}
+
+void Gles2Rhi::begin_default_render_pass(Handle<GraphicsContext> ctx) {
+	SRB2_ASSERT(platform_ != nullptr);
+	SRB2_ASSERT(graphics_context_active_ == true);
+	SRB2_ASSERT(current_render_pass_.has_value() == false);
+
+	const Rect fb_rect = platform_->get_default_framebuffer_dimensions();
+
+	glBindFramebuffer(GL_FRAMEBUFFER, 0);
+	glViewport(0, 0, fb_rect.w, fb_rect.h);
+
+	glClearColor(0.5f, 0.5f, 0.5f, 1.0f);
+	glClearDepthf(1.0f);
+	glClearStencil(0);
+	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+	current_render_pass_ = Gles2Rhi::DefaultRenderPassState {};
+}
+
+void Gles2Rhi::begin_render_pass(Handle<GraphicsContext> ctx, const RenderPassBeginInfo& info) {
+	SRB2_ASSERT(graphics_context_active_ == true && graphics_context_generation_ == ctx.generation());
+	SRB2_ASSERT(current_render_pass_.has_value() == false);
+
+	SRB2_ASSERT(render_pass_slab_.is_valid(info.render_pass) == true);
+	auto& rp = *static_cast<Gles2RenderPass*>(&render_pass_slab_[info.render_pass]);
+	SRB2_ASSERT(rp.desc.depth_format.has_value() == info.depth_attachment.has_value());
+
+	auto fb_itr = framebuffers_.find(Gles2FramebufferKey {info.color_attachment, info.depth_attachment});
+	if (fb_itr == framebuffers_.end()) {
+		// Create a new framebuffer for this color-depth pair
+		GLuint fb_name;
+		glGenFramebuffers(1, &fb_name);
+		glBindFramebuffer(GL_FRAMEBUFFER, fb_name);
+		fb_itr = framebuffers_.insert(
+			{Gles2FramebufferKey {info.color_attachment, info.depth_attachment}, static_cast<uint32_t>(fb_name)}).first;
+
+		// TODO bind buffers correctly
+	}
+	auto& fb = *fb_itr;
+	glBindFramebuffer(GL_FRAMEBUFFER, fb.second);
+
+	if (rp.desc.load_op == rhi::AttachmentLoadOp::kClear) {
+		glClearColor(info.clear_color.r, info.clear_color.g, info.clear_color.b, info.clear_color.a);
+		glClearDepthf(1.f);
+		glClearStencil(0);
+		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
+	}
+
+	current_render_pass_ = info;
+}
+
+void Gles2Rhi::end_render_pass(Handle<GraphicsContext> ctx) {
+	SRB2_ASSERT(graphics_context_active_ == true && graphics_context_generation_ == ctx.generation());
+	SRB2_ASSERT(current_render_pass_.has_value() == true);
+
+	current_pipeline_ = std::nullopt;
+	current_render_pass_ = std::nullopt;
+}
+
+void Gles2Rhi::bind_pipeline(Handle<GraphicsContext> ctx, Handle<Pipeline> pipeline) {
+	SRB2_ASSERT(graphics_context_active_ == true && graphics_context_generation_ == ctx.generation());
+	SRB2_ASSERT(current_render_pass_.has_value() == true);
+
+	SRB2_ASSERT(pipeline_slab_.is_valid(pipeline) == true);
+	auto& pl = *static_cast<Gles2Pipeline*>(&pipeline_slab_[pipeline]);
+	auto& desc = pl.desc;
+
+	glUseProgram(pl.program);
+
+	glDisable(GL_SCISSOR_TEST);
+
+	if (desc.depth_attachment) {
+		glEnable(GL_DEPTH_TEST);
+		GLenum depth_func = map_compare_func(desc.depth_attachment->func);
+		SRB2_ASSERT(depth_func != GL_ZERO);
+		glDepthFunc(depth_func);
+		glDepthMask(desc.depth_attachment->write ? GL_TRUE : GL_FALSE);
+	} else {
+		glDisable(GL_DEPTH_TEST);
+	}
+
+	if (desc.color_attachment.blend) {
+		rhi::BlendDesc& bl = *desc.color_attachment.blend;
+		glEnable(GL_BLEND);
+		glBlendFuncSeparate(map_blend_factor(bl.source_factor_color),
+							map_blend_factor(bl.dest_factor_color),
+							map_blend_factor(bl.source_factor_alpha),
+							map_blend_factor(bl.dest_factor_alpha));
+		glBlendEquationSeparate(map_blend_function(bl.color_function), map_blend_function(bl.alpha_function));
+		glBlendColor(desc.blend_color.r, desc.blend_color.g, desc.blend_color.b, desc.blend_color.a);
+	} else {
+		glDisable(GL_BLEND);
+	}
+
+	glColorMask(desc.color_attachment.color_mask.r ? GL_TRUE : GL_FALSE,
+				desc.color_attachment.color_mask.g ? GL_TRUE : GL_FALSE,
+				desc.color_attachment.color_mask.b ? GL_TRUE : GL_FALSE,
+				desc.color_attachment.color_mask.a ? GL_TRUE : GL_FALSE);
+
+	GLenum cull_face = map_cull_mode(desc.cull);
+	if (cull_face == GL_NONE) {
+		glDisable(GL_CULL_FACE);
+	} else {
+		glEnable(GL_CULL_FACE);
+		glCullFace(cull_face);
+	}
+	glFrontFace(map_winding(desc.winding));
+
+	current_pipeline_ = pipeline;
+	current_primitive_type_ = desc.primitive;
+}
+
+void Gles2Rhi::update_bindings(Handle<GraphicsContext> ctx, const UpdateBindingsInfo& info) {
+	SRB2_ASSERT(graphics_context_active_ == true && graphics_context_generation_ == ctx.generation());
+	SRB2_ASSERT(current_render_pass_.has_value() == true && current_pipeline_.has_value() == true);
+
+	SRB2_ASSERT(pipeline_slab_.is_valid(*current_pipeline_));
+	auto& pl = *static_cast<Gles2Pipeline*>(&pipeline_slab_[*current_pipeline_]);
+
+	// TODO assert compatibility of binding data with pipeline
+	SRB2_ASSERT(info.vertex_buffers.size() == pl.desc.vertex_input.buffer_layouts.size());
+	SRB2_ASSERT(info.sampler_textures.size() == pl.desc.sampler_input.enabled_samplers.size());
+
+	// TODO only disable the vertex attributes of the previously bound pipeline (performance)
+	for (GLuint i = 0; i < kMaxVertexAttributes; i++) {
+		glDisableVertexAttribArray(i);
+	}
+
+	// Update the vertex attributes with the new vertex buffer bindings.
+
+	// OpenGL ES does not require binding buffers to the pipeline the same way Vulkan does.
+	// Instead, we need to find the pipeline vertex attributes which would be affected by
+	// the changing set of vertex buffers, and reassign their Vertex Attribute Pointers.
+	for (size_t i = 0; i < pl.desc.vertex_input.attr_layouts.size(); i++) {
+		auto& attr_layout = pl.desc.vertex_input.attr_layouts[i];
+		uint32_t attr_buffer_index = attr_layout.buffer_index;
+		VertexAttributeName attr_name = attr_layout.name;
+
+		auto& buffer_layout = pl.desc.vertex_input.buffer_layouts[attr_buffer_index];
+
+		SRB2_ASSERT(pl.attrib_locations.find(attr_name) != pl.attrib_locations.end());
+		auto gl_attr_location = pl.attrib_locations[pl.desc.vertex_input.attr_layouts[i].name];
+
+		VertexAttributeFormat vert_attr_format = rhi::vertex_attribute_format(attr_name);
+		GLenum vertex_attr_type = map_vertex_attribute_type(vert_attr_format);
+		SRB2_ASSERT(vertex_attr_type != GL_ZERO);
+		GLint vertex_attr_size = map_vertex_attribute_format_size(vert_attr_format);
+		SRB2_ASSERT(vertex_attr_size != 0);
+
+		rhi::Handle<rhi::Buffer> vertex_buffer_handle;
+		uint32_t vertex_buffer_offset;
+		std::tie(vertex_buffer_handle, vertex_buffer_offset) = info.vertex_buffers[attr_layout.buffer_index];
+		SRB2_ASSERT(buffer_slab_.is_valid(vertex_buffer_handle) == true);
+		auto& buffer = *static_cast<Gles2Buffer*>(&buffer_slab_[vertex_buffer_handle]);
+		SRB2_ASSERT(buffer.desc.type == rhi::BufferType::kVertexBuffer);
+
+		glBindBuffer(GL_ARRAY_BUFFER, buffer.buffer);
+		glEnableVertexAttribArray(gl_attr_location);
+		glVertexAttribPointer(gl_attr_location, vertex_attr_size, vertex_attr_type, GL_FALSE, buffer_layout.stride, reinterpret_cast<const void*>(vertex_buffer_offset + attr_layout.offset));
+	}
+
+	rhi::Handle<rhi::Buffer> index_buffer_handle;
+	std::tie(index_buffer_handle, index_buffer_offset_) = info.index_buffer;
+	if (index_buffer_handle == rhi::kNullHandle) {
+		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
+	} else {
+		SRB2_ASSERT(buffer_slab_.is_valid(index_buffer_handle));
+		auto& ib = *static_cast<Gles2Buffer*>(&buffer_slab_[index_buffer_handle]);
+		SRB2_ASSERT(ib.desc.type == rhi::BufferType::kIndexBuffer);
+		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ib.buffer);
+	}
+
+	for (size_t i = 0; i < info.sampler_textures.size(); i++) {
+		auto& sampler_name = pl.desc.sampler_input.enabled_samplers[i];
+		rhi::Handle<rhi::Texture> texture_handle = info.sampler_textures[i];
+		SRB2_ASSERT(texture_slab_.is_valid(texture_handle));
+		auto& t = *static_cast<Gles2Texture*>(&texture_slab_[texture_handle]);
+		SRB2_ASSERT(pl.sampler_locations.find(sampler_name) != pl.sampler_locations.end());
+		GLuint sampler_uniform_loc = pl.sampler_locations[sampler_name];
+
+		GLenum active_texture = GL_TEXTURE0;
+		GLuint uniform_value = 0;
+
+		switch (sampler_name) {
+		case rhi::SamplerName::kSampler0:
+			active_texture = GL_TEXTURE0;
+			uniform_value = 0;
+			break;
+		case rhi::SamplerName::kSampler1:
+			active_texture = GL_TEXTURE0 + 1;
+			uniform_value = 1;
+			break;
+		case rhi::SamplerName::kSampler2:
+			active_texture = GL_TEXTURE0 + 2;
+			uniform_value = 2;
+			break;
+		case rhi::SamplerName::kSampler3:
+			active_texture = GL_TEXTURE0 + 3;
+			uniform_value = 3;
+			break;
+		}
+		glActiveTexture(active_texture);
+		glBindTexture(GL_TEXTURE_2D, t.texture);
+		glUniform1i(sampler_uniform_loc, uniform_value);
+	}
+}
+
+void Gles2Rhi::update_uniforms(Handle<GraphicsContext> ctx, tcb::span<UniformUpdateData> uniforms) {
+	SRB2_ASSERT(graphics_context_active_ == true && graphics_context_generation_ == ctx.generation());
+	SRB2_ASSERT(current_render_pass_.has_value() == true && current_pipeline_.has_value() == true);
+
+	SRB2_ASSERT(pipeline_slab_.is_valid(*current_pipeline_));
+	auto& pl = *static_cast<Gles2Pipeline*>(&pipeline_slab_[*current_pipeline_]);
+
+	// TODO assert compatibility of uniform data with pipeline
+	// The uniforms need to be the same size, names and value types as the pipeline.
+	// RHI doesn't support updating selectively; the whole set must be updated at once altogether.
+	SRB2_ASSERT(uniforms.size() == pl.desc.uniform_input.enabled_uniforms.size());
+
+	for (size_t i = 0; i < uniforms.size(); i++) {
+		auto& update_data = uniforms[i];
+
+		SRB2_ASSERT(pl.uniform_locations.find(update_data.name) != pl.uniform_locations.end());
+		SRB2_ASSERT(pl.desc.uniform_input.enabled_uniforms[i] == update_data.name);
+		GLuint pipeline_uniform = pl.uniform_locations[update_data.name];
+
+		struct UniformVariantVisitor {
+			rhi::UniformName name;
+			GLuint uniform;
+
+			void operator()(const float& value) const noexcept {
+				SRB2_ASSERT(rhi::uniform_format(name) == rhi::UniformFormat::kFloat);
+				glUniform1f(uniform, value);
+			}
+			void operator()(const std::array<float, 2>& value) const noexcept {
+				SRB2_ASSERT(rhi::uniform_format(name) == rhi::UniformFormat::kFloat2);
+				glUniform2f(uniform, value[0], value[1]);
+			}
+			void operator()(const std::array<float, 3>& value) const noexcept {
+				SRB2_ASSERT(rhi::uniform_format(name) == rhi::UniformFormat::kFloat3);
+				glUniform3f(uniform, value[0], value[1], value[2]);
+			}
+			void operator()(const std::array<float, 4>& value) const noexcept {
+				SRB2_ASSERT(rhi::uniform_format(name) == rhi::UniformFormat::kFloat4);
+				glUniform4f(uniform, value[0], value[1], value[2], value[3]);
+			}
+			void operator()(const int32_t& value) const noexcept {
+				SRB2_ASSERT(rhi::uniform_format(name) == rhi::UniformFormat::kInt);
+				glUniform1i(uniform, value);
+			}
+			void operator()(const std::array<int32_t, 2>& value) const noexcept {
+				SRB2_ASSERT(rhi::uniform_format(name) == rhi::UniformFormat::kInt2);
+				glUniform2i(uniform, value[0], value[1]);
+			}
+			void operator()(const std::array<int32_t, 3>& value) const noexcept {
+				SRB2_ASSERT(rhi::uniform_format(name) == rhi::UniformFormat::kInt3);
+				glUniform3i(uniform, value[0], value[1], value[2]);
+			}
+			void operator()(const std::array<int32_t, 4>& value) const noexcept {
+				SRB2_ASSERT(rhi::uniform_format(name) == rhi::UniformFormat::kInt4);
+				glUniform4i(uniform, value[0], value[1], value[2], value[3]);
+			}
+			void operator()(const std::array<std::array<float, 2>, 2>& value) const noexcept {
+				SRB2_ASSERT(rhi::uniform_format(name) == rhi::UniformFormat::kMat2);
+				glUniformMatrix2fv(uniform, 1, false, reinterpret_cast<const GLfloat*>(&value));
+			}
+			void operator()(const std::array<std::array<float, 3>, 3>& value) const noexcept {
+				SRB2_ASSERT(rhi::uniform_format(name) == rhi::UniformFormat::kMat3);
+				glUniformMatrix3fv(uniform, 1, false, reinterpret_cast<const GLfloat*>(&value));
+			}
+			void operator()(const std::array<std::array<float, 4>, 4>& value) const noexcept {
+				SRB2_ASSERT(rhi::uniform_format(name) == rhi::UniformFormat::kMat4);
+				glUniformMatrix4fv(uniform, 1, false, reinterpret_cast<const GLfloat*>(&value));
+			}
+		};
+		std::visit(UniformVariantVisitor {update_data.name, pipeline_uniform}, update_data.value);
+	}
+}
+
+void Gles2Rhi::set_scissor(Handle<GraphicsContext> ctx, const Rect& rect) {
+	SRB2_ASSERT(graphics_context_active_ == true && graphics_context_generation_ == ctx.generation());
+	SRB2_ASSERT(current_render_pass_.has_value() == true && current_pipeline_.has_value() == true);
+	// TODO handle scissor pipeline state
+}
+
+void Gles2Rhi::set_viewport(Handle<GraphicsContext> ctx, const Rect& rect) {
+	SRB2_ASSERT(graphics_context_active_ == true && graphics_context_generation_ == ctx.generation());
+	SRB2_ASSERT(current_render_pass_.has_value() == true && current_pipeline_.has_value() == true);
+	// TODO handle viewport pipeline state
+}
+
+void Gles2Rhi::draw(Handle<GraphicsContext> ctx, uint32_t vertex_count, uint32_t first_vertex) {
+	SRB2_ASSERT(graphics_context_active_ == true && graphics_context_generation_ == ctx.generation());
+	SRB2_ASSERT(current_render_pass_.has_value() == true && current_pipeline_.has_value() == true);
+
+	glDrawArrays(map_primitive_mode(current_primitive_type_), first_vertex, vertex_count);
+}
+
+void Gles2Rhi::draw_indexed(Handle<GraphicsContext> ctx,
+							uint32_t index_count,
+							uint32_t first_index,
+							uint32_t vertex_offset) {
+	SRB2_ASSERT(graphics_context_active_ == true && graphics_context_generation_ == ctx.generation());
+	glDrawElements(map_primitive_mode(current_primitive_type_), first_index, GL_UNSIGNED_SHORT, reinterpret_cast<const void*>(index_buffer_offset_));
+}
+
+void Gles2Rhi::finish() {
+	SRB2_ASSERT(graphics_context_active_ == false);
+
+	for (auto it = disposal_.begin(); it != disposal_.end(); it++) {
+		(*it)();
+	}
+	disposal_.clear();
+}
+
+void rhi::load_gles2(Gles2LoadFunc func) {
+	gladLoadGLES2(static_cast<GLADloadfunc>(func));
+}
diff --git a/src/rhi/gles2/gles2_rhi.hpp b/src/rhi/gles2/gles2_rhi.hpp
new file mode 100644
index 000000000..4f19aa7c5
--- /dev/null
+++ b/src/rhi/gles2/gles2_rhi.hpp
@@ -0,0 +1,135 @@
+#ifndef __SRB2_RHI_GLES2_RHI_HPP__
+#define __SRB2_RHI_GLES2_RHI_HPP__
+
+#include <functional>
+#include <memory>
+#include <optional>
+#include <string>
+#include <tuple>
+#include <unordered_map>
+#include <vector>
+
+#include "../rhi.hpp"
+
+namespace srb2::rhi {
+
+struct Gles2FramebufferKey {
+	TextureOrRenderbuffer color;
+	std::optional<TextureOrRenderbuffer> depth;
+
+	bool operator==(const Gles2FramebufferKey& rhs) const noexcept {
+		return color == rhs.color && depth == rhs.depth;
+	}
+
+	bool operator!=(const Gles2FramebufferKey& rhs) const noexcept {
+		return !(*this == rhs);
+	}
+};
+
+} // namespace srb2::rhi
+
+// To make sure the compiler selects the struct specialization of std::hash for Gles2FramebufferKey,
+// we need to split the namespace declarations _before_ the instantiation of std::unordered_map.
+
+template <>
+struct std::hash<srb2::rhi::Gles2FramebufferKey> {
+	std::size_t operator()(const srb2::rhi::Gles2FramebufferKey& key) const {
+		struct GetHandleHashVisitor {
+			uint32_t operator()(const srb2::rhi::Handle<srb2::rhi::Texture>& handle) const noexcept {
+				return std::hash<srb2::rhi::Handle<srb2::rhi::Texture>>()(handle);
+			}
+			uint32_t operator()(const srb2::rhi::Handle<srb2::rhi::Renderbuffer>& handle) const noexcept {
+				return std::hash<srb2::rhi::Handle<srb2::rhi::Renderbuffer>>()(handle);
+			}
+		};
+		std::size_t color_hash = std::visit(GetHandleHashVisitor {}, key.color);
+		std::size_t depth_hash = 0;
+		if (key.depth) {
+			depth_hash = std::visit(GetHandleHashVisitor {}, *key.depth);
+		}
+		return color_hash ^ (depth_hash << 1);
+	}
+};
+
+namespace srb2::rhi {
+
+/// @brief Platform-specific implementation details for the GLES2 backend.
+struct Gles2Platform {
+	virtual ~Gles2Platform();
+
+	virtual void present() = 0;
+	virtual std::tuple<std::string, std::string> find_shader_sources(PipelineProgram program) = 0;
+	virtual Rect get_default_framebuffer_dimensions() = 0;
+};
+
+class Gles2Rhi final : public Rhi {
+	std::unique_ptr<Gles2Platform> platform_;
+
+	Slab<RenderPass> render_pass_slab_;
+	Slab<Texture> texture_slab_;
+	Slab<Buffer> buffer_slab_;
+	Slab<Renderbuffer> renderbuffer_slab_;
+	Slab<Pipeline> pipeline_slab_;
+
+	std::unordered_map<Gles2FramebufferKey, uint32_t> framebuffers_ {16};
+
+	struct DefaultRenderPassState {};
+	using RenderPassState = std::variant<DefaultRenderPassState, RenderPassBeginInfo>;
+	std::optional<RenderPassState> current_render_pass_;
+	std::optional<Handle<Pipeline>> current_pipeline_;
+	PrimitiveType current_primitive_type_ = PrimitiveType::kPoints;
+	bool graphics_context_active_ = false;
+	uint32_t graphics_context_generation_ = 0;
+	uint32_t index_buffer_offset_ = 0;
+
+	std::vector<std::function<void()>> disposal_;
+
+public:
+	Gles2Rhi(std::unique_ptr<Gles2Platform>&& platform);
+	virtual ~Gles2Rhi();
+
+	virtual Handle<RenderPass> create_render_pass(const RenderPassDesc& desc) override;
+	virtual void destroy_render_pass(Handle<RenderPass>&& handle) override;
+	virtual Handle<Texture> create_texture(const TextureDesc& desc, srb2::rhi::PixelFormat data_format, tcb::span<const std::byte> data) override;
+	virtual void destroy_texture(Handle<Texture>&& handle) override;
+	virtual Handle<Buffer> create_buffer(const BufferDesc& desc, tcb::span<const std::byte> data) override;
+	virtual void destroy_buffer(Handle<Buffer>&& handle) override;
+	virtual Handle<Renderbuffer> create_renderbuffer(const RenderbufferDesc& desc) override;
+	virtual void destroy_renderbuffer(Handle<Renderbuffer>&& handle) override;
+	virtual Handle<Pipeline> create_pipeline(const PipelineDesc& desc) override;
+	virtual void destroy_pipeline(Handle<Pipeline>&& handle) override;
+
+	virtual void update_buffer_contents(Handle<Buffer> buffer, uint32_t offset, tcb::span<const std::byte> data) override;
+	virtual void update_texture(Handle<Texture> texture, Rect region, srb2::rhi::PixelFormat data_format, tcb::span<const std::byte> data) override;
+
+	virtual Handle<GraphicsContext> begin_graphics() override;
+	virtual void end_graphics(Handle<GraphicsContext>&& ctx) override;
+
+	// Graphics context functions
+	virtual void begin_default_render_pass(Handle<GraphicsContext> ctx) override;
+	virtual void begin_render_pass(Handle<GraphicsContext> ctx, const RenderPassBeginInfo& info) override;
+	virtual void end_render_pass(Handle<GraphicsContext> ctx) override;
+	virtual void bind_pipeline(Handle<GraphicsContext> ctx, Handle<Pipeline> pipeline) override;
+	virtual void update_bindings(Handle<GraphicsContext> ctx, const UpdateBindingsInfo& info) override;
+	virtual void update_uniforms(Handle<GraphicsContext> ctx, tcb::span<UniformUpdateData> uniforms) override;
+	virtual void set_scissor(Handle<GraphicsContext> ctx, const Rect& rect) override;
+	virtual void set_viewport(Handle<GraphicsContext> ctx, const Rect& rect) override;
+	virtual void draw(Handle<GraphicsContext> ctx, uint32_t vertex_count, uint32_t first_vertex) override;
+	virtual void draw_indexed(Handle<GraphicsContext> ctx,
+							  uint32_t index_count,
+							  uint32_t first_index,
+							  uint32_t vertex_offset) override;
+
+	virtual void present() override;
+
+	virtual void finish() override;
+};
+
+typedef void (*Gles2Proc)(void);
+typedef Gles2Proc (*Gles2LoadFunc)(const char* name);
+
+void load_gles2(Gles2LoadFunc func);
+
+} // namespace srb2::rhi
+
+#endif // __SRB2_RHI_GLES2_RHI_HPP__
diff --git a/src/rhi/handle.hpp b/src/rhi/handle.hpp
new file mode 100644
index 000000000..7a780d8ca
--- /dev/null
+++ b/src/rhi/handle.hpp
@@ -0,0 +1,317 @@
+#ifndef __SRB2_RHI_HANDLE_HPP__
+#define __SRB2_RHI_HANDLE_HPP__
+
+#include <atomic>
+#include <cstdint>
+#include <memory>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include "../cxxutil.hpp"
+
+namespace srb2::rhi {
+
+struct NullHandleType {};
+
+constexpr const NullHandleType kNullHandle = NullHandleType {};
+
+template <typename T = void>
+class Handle {
+	uint32_t id_;
+	uint32_t generation_;
+
+public:
+	Handle(uint32_t id, uint32_t generation) noexcept : id_(id), generation_(generation) {}
+	Handle(uint64_t combined) noexcept
+		: id_(combined & 0xFFFFFFFF)
+		, generation_((combined & 0xFFFFFFFF00000000) >> 32)
+	{}
+	Handle() noexcept : Handle(0, 0) {}
+
+	Handle(NullHandleType) noexcept : Handle() {}
+
+	Handle(const Handle&) = default;
+	Handle(Handle&& rhs) noexcept {
+		id_ = std::exchange(rhs.id_, 0);
+		generation_ = std::exchange(rhs.generation_, 0);
+	};
+
+	Handle& operator=(const Handle&) = default;
+	Handle& operator=(Handle&& rhs) noexcept {
+		id_ = std::exchange(rhs.id_, 0);
+		generation_ = std::exchange(rhs.generation_, 0);
+		return *this;
+	}
+
+	// Conversions from Handles of derived type U to base type T
+
+	template <typename U, typename std::enable_if_t<std::is_base_of_v<T, U>, bool> = true>
+	Handle(const Handle<U>& rhs) noexcept : id_(rhs.id_), generation_(rhs.generation_) {}
+
+	template <typename U, typename std::enable_if_t<std::is_base_of_v<T, U>, bool> = true>
+	Handle(Handle<U>&& rhs) noexcept {
+		id_ = std::exchange(rhs.id_, 0);
+		generation_ = std::exchange(rhs.generation_, 0);
+	}
+
+	template <typename U, typename std::enable_if_t<std::is_base_of_v<T, U>, bool> = true>
+	Handle& operator=(const Handle<U>& rhs) noexcept {
+		id_ = rhs.id_;
+		generation_ = rhs.generation_;
+	}
+
+	template <typename U, typename std::enable_if_t<std::is_base_of_v<T, U>, bool> = true>
+	Handle& operator=(Handle<U>&& rhs) noexcept {
+		id_ = std::exchange(rhs.id_, 0);
+		generation_ = std::exchange(rhs.generation_, 0);
+		return *this;
+	}
+
+	uint32_t id() const noexcept { return id_; }
+	uint32_t generation() const noexcept { return generation_; }
+
+	/// @return true if this Handle is valid (belonging to a generation > 0); false otherwise
+	bool valid() const noexcept { return generation_ != 0; }
+
+	bool operator==(const Handle& handle) const noexcept {
+		return handle.generation_ == generation_ && handle.id_ == id_;
+	}
+	bool operator!=(const Handle& handle) const noexcept { return !(handle == *this); }
+	bool operator==(const NullHandleType&) const noexcept { return generation_ == 0; }
+	bool operator!=(const NullHandleType&) const noexcept { return generation_ != 0; }
+
+	operator bool() const { return id_ != 0 || generation_ != 0; }
+	operator uint64_t() const { return static_cast<uint64_t>(id_) + (static_cast<uint64_t>(generation_) << 32); }
+};
+
+template <typename T>
+inline bool operator==(const Handle<T>& lhs, const NullHandleType&) noexcept
+{
+	return lhs.generation() == 0 || lhs.id() == 0;
+}
+
+template <typename T>
+inline bool operator==(const Handle<T>& lhs, const std::nullptr_t&) noexcept
+{
+	return lhs.generation() == 0 || lhs.id() == 0;
+}
+
+// Non-member equality of base Handle<T> to derived Handle<U>
+
+template <typename T, typename U, typename std::enable_if_t<std::is_base_of_v<T, U>, bool> = true>
+inline bool operator==(const Handle<T>& lhs, const Handle<U>& rhs) noexcept {
+	return lhs.generation() == rhs.generation() && lhs.id() == rhs.id();
+}
+
+template <typename T, typename U, typename std::enable_if_t<std::is_base_of_v<T, U>, bool> = true>
+inline bool operator!=(const Handle<T>& lhs, const Handle<U>& rhs) noexcept {
+	return !(lhs == rhs);
+}
+
+template <typename T = void>
+class HandlePool {
+	std::atomic_uint32_t current_id_ {0};
+	std::atomic_uint32_t current_gen_ {1};
+
+public:
+	HandlePool() = default;
+	HandlePool(const HandlePool& rhs) = delete;
+	HandlePool(HandlePool&& rhs) = default;
+
+	HandlePool& operator=(const HandlePool& rhs) = delete;
+	HandlePool& operator=(HandlePool&& rhs) = default;
+
+	/// @brief Create a new unique Handle in the current generation.
+	/// @return the new Handle.
+	Handle<T> create() noexcept {
+		const uint32_t id = current_id_.fetch_add(1);
+		SRB2_ASSERT(id != UINT32_MAX);
+		const uint32_t gen = current_gen_.load();
+		return Handle<T>(id, gen);
+	}
+
+	/// @brief Increment the generation. All handles created after this will belong to a new generation.
+	void generation() noexcept {
+		const uint32_t old_gen = current_gen_.fetch_add(1);
+		SRB2_ASSERT(old_gen != UINT32_MAX);
+	}
+};
+
+template <typename T>
+class Slab;
+
+template <typename T>
+class SlabIterator
+{
+	size_t index_ = 0;
+	const Slab<std::remove_const_t<T>>* slab_ = nullptr;
+
+	SlabIterator(size_t index, const Slab<std::remove_const_t<T>>* slab) : index_(index), slab_(slab) {}
+
+	friend Slab<std::remove_const_t<T>>;
+public:
+	SlabIterator() = default;
+	SlabIterator(const SlabIterator&) = default;
+	SlabIterator(SlabIterator&&) = default;
+
+	SlabIterator& operator=(const SlabIterator&) = default;
+	SlabIterator& operator=(SlabIterator&&) = default;
+
+	T& operator*() const noexcept
+	{
+		return *slab_->vec_[index_].item.get();
+	}
+
+	SlabIterator& operator++() noexcept
+	{
+		index_++;
+		return *this;
+	}
+
+	SlabIterator& operator--() noexcept
+	{
+		index_--;
+		return *this;
+	}
+
+	SlabIterator operator++(int) noexcept
+	{
+		index_++;
+		return SlabIterator {index_ - 1, slab_};
+	}
+
+	SlabIterator operator--(int) noexcept
+	{
+		index_--;
+		return SlabIterator {index_ + 1, slab_};
+	}
+
+	bool operator==(const SlabIterator& rhs) const noexcept
+	{
+		return slab_ == rhs.slab_ && index_ == rhs.index_;
+	}
+
+	bool operator!=(const SlabIterator& rhs) const noexcept
+	{
+		return !(*this == rhs);
+	}
+};
+
+template <typename T>
+class Slab {
+	struct SlabStorage {
+		std::unique_ptr<T> item;
+		uint32_t gen;
+	};
+	std::vector<SlabStorage> vec_;
+	std::vector<uint32_t> free_list_;
+	uint32_t gen_ = 1;
+
+	friend SlabIterator<T>;
+	friend SlabIterator<const T>;
+public:
+	Slab() = default;
+	Slab(const Slab&) = delete;
+	Slab& operator=(const Slab&) = delete;
+
+	Handle<T> insert(std::unique_ptr<T>&& value) {
+		uint32_t ret_id = 0;
+		if (!free_list_.empty()) {
+			ret_id = free_list_.back();
+			free_list_.pop_back();
+			SlabStorage& storage = vec_[ret_id];
+			storage.item = std::move(value);
+			storage.gen = gen_;
+		} else {
+			ret_id = vec_.size();
+			vec_.push_back(SlabStorage {std::move(value), gen_});
+		}
+		return Handle<T>(ret_id, gen_);
+	}
+
+	std::unique_ptr<T> remove(Handle<T> handle) {
+		uint32_t handle_id = handle.id();
+		uint32_t handle_gen = handle.generation();
+		if (handle_id >= vec_.size()) {
+			return nullptr;
+		}
+		SlabStorage& storage = vec_[handle_id];
+		if (storage.gen > handle_gen) {
+			return nullptr;
+		}
+		std::unique_ptr<T> ret = std::move(storage.item);
+		storage.item = nullptr;
+		free_list_.push_back(handle_id);
+		gen_ += 1;
+		if (gen_ == 0)
+		{
+			gen_ = 1;
+		}
+		return ret;
+	}
+
+	bool is_valid(Handle<T> handle) {
+		uint32_t handle_id = handle.id();
+		uint32_t handle_gen = handle.generation();
+		if (handle_id >= vec_.size()) {
+			return false;
+		}
+		SlabStorage& storage = vec_[handle_id];
+		if (storage.gen > handle_gen) {
+			return false;
+		}
+		return true;
+	}
+
+	void clear()
+	{
+		vec_.clear();
+		free_list_.clear();
+		gen_ += 1;
+		if (gen_ == 0)
+		{
+			gen_ = 1;
+		}
+	}
+
+	T& operator[](Handle<T> handle) {
+		SRB2_ASSERT(is_valid(handle));
+		return *vec_[handle.id()].item;
+	}
+
+	SlabIterator<T> begin()
+	{
+		return SlabIterator<T> {0, this};
+	}
+
+	SlabIterator<T> end()
+	{
+		return SlabIterator<T> {vec_.size(), this};
+	}
+
+	SlabIterator<const T> cbegin() const
+	{
+		return SlabIterator<const T> {0, this};
+	}
+
+	SlabIterator<const T> cend() const
+	{
+		return SlabIterator<const T> {vec_.size(), this};
+	}
+};
+
+} // namespace srb2::rhi
+
+namespace std {
+
+template <typename T>
+struct hash<srb2::rhi::Handle<T>> {
+	std::size_t operator()(const srb2::rhi::Handle<T>& e) const {
+		return std::hash<uint32_t>()(e.generation()) ^ (std::hash<uint32_t>()(e.id()) << 1);
+	}
+};
+
+} // namespace std
+
+#endif // __SRB2_RHI_HANDLE_HPP__
diff --git a/src/rhi/rhi.cpp b/src/rhi/rhi.cpp
new file mode 100644
index 000000000..c5fd0b973
--- /dev/null
+++ b/src/rhi/rhi.cpp
@@ -0,0 +1,51 @@
+#include "rhi.hpp"
+
+#include <exception>
+#include <stdexcept>
+
+using namespace srb2;
+using namespace srb2::rhi;
+
+Rhi::~Rhi() = default;
+
+const ProgramRequirements srb2::rhi::kProgramRequirementsUnshaded = {
+	ProgramVertexInputRequirements {{
+		ProgramVertexInput {VertexAttributeName::kPosition, VertexAttributeFormat::kFloat3, true},
+		ProgramVertexInput {VertexAttributeName::kTexCoord0, VertexAttributeFormat::kFloat2, false},
+		ProgramVertexInput {VertexAttributeName::kColor, VertexAttributeFormat::kFloat4, false}
+	}},
+	ProgramUniformRequirements {{
+		{{UniformName::kProjection}},
+		{{UniformName::kModelView, UniformName::kTexCoord0Transform}}
+	}},
+	ProgramSamplerRequirements {{
+		ProgramSamplerInput {SamplerName::kSampler0, true}
+	}}
+};
+
+const ProgramRequirements srb2::rhi::kProgramRequirementsUnshadedPaletted = {
+	ProgramVertexInputRequirements {{
+		ProgramVertexInput {VertexAttributeName::kPosition, VertexAttributeFormat::kFloat3, true},
+		ProgramVertexInput {VertexAttributeName::kTexCoord0, VertexAttributeFormat::kFloat2, false},
+		ProgramVertexInput {VertexAttributeName::kColor, VertexAttributeFormat::kFloat4, false}
+	}},
+	ProgramUniformRequirements {{
+		{{UniformName::kProjection}},
+		{{UniformName::kModelView, UniformName::kTexCoord0Transform}}
+	}},
+	ProgramSamplerRequirements {{
+		ProgramSamplerInput {SamplerName::kSampler0, true},
+		ProgramSamplerInput {SamplerName::kSampler1, true}
+	}}
+};
+
+const ProgramRequirements& rhi::program_requirements_for_program(PipelineProgram program) noexcept {
+	switch (program) {
+	case PipelineProgram::kUnshaded:
+		return kProgramRequirementsUnshaded;
+	case PipelineProgram::kUnshadedPaletted:
+		return kProgramRequirementsUnshadedPaletted;
+	default:
+		std::terminate();
+	}
+}
diff --git a/src/rhi/rhi.hpp b/src/rhi/rhi.hpp
new file mode 100644
index 000000000..1da54fbf0
--- /dev/null
+++ b/src/rhi/rhi.hpp
@@ -0,0 +1,466 @@
+#ifndef __SRB2_RHI_RHI_HPP__
+#define __SRB2_RHI_RHI_HPP__
+
+#include <cstdint>
+#include <optional>
+#include <set>
+#include <variant>
+#include <vector>
+
+#include <tcb/span.hpp>
+
+#include "../core/static_vec.hpp"
+#include "handle.hpp"
+
+namespace srb2::rhi {
+
+struct Buffer {};
+
+struct Texture {};
+
+struct Pipeline {};
+
+struct RenderPass {};
+
+struct Renderbuffer {};
+
+using TextureOrRenderbuffer = std::variant<Handle<Texture>, Handle<Renderbuffer>>;
+
+enum class VertexAttributeFormat {
+	kFloat,
+	kFloat2,
+	kFloat3,
+	kFloat4
+};
+
+enum class UniformFormat {
+	kFloat,
+	kFloat2,
+	kFloat3,
+	kFloat4,
+	kInt,
+	kInt2,
+	kInt3,
+	kInt4,
+	kMat2,
+	kMat3,
+	kMat4
+};
+
+enum class PixelFormat {
+	kR8,
+	kRGBA8,
+	kDepth16,
+	kStencil8
+};
+
+enum class TextureFormat {
+	kLuminance,
+	kRGB,
+	kRGBA
+};
+
+enum class CompareFunc {
+	kNever,
+	kLess,
+	kEqual,
+	kLessEqual,
+	kGreater,
+	kNotEqual,
+	kGreaterEqual,
+	kAlways
+};
+
+enum class BlendFactor {
+	kZero,
+	kOne,
+	kSource,
+	kOneMinusSource,
+	kSourceAlpha,
+	kOneMinusSourceAlpha,
+	kDest,
+	kOneMinusDest,
+	kDestAlpha,
+	kOneMinusDestAlpha,
+	kConstant,
+	kOneMinusConstant,
+	kConstantAlpha,
+	kOneMinusConstantAlpha,
+	kSourceAlphaSaturated
+};
+
+enum class BlendFunction {
+	kAdd,
+	kSubtract,
+	kReverseSubtract
+};
+
+enum class PrimitiveType {
+	kPoints,
+	kLines,
+	kLineStrip,
+	kTriangles,
+	kTriangleStrip,
+	kTriangleFan
+};
+
+enum class CullMode {
+	kNone,
+	kFront,
+	kBack
+};
+
+enum class FaceWinding {
+	kCounterClockwise,
+	kClockwise
+};
+
+enum class AttachmentLoadOp {
+	kLoad,
+	kClear,
+	kDontCare
+};
+
+enum class AttachmentStoreOp {
+	kStore,
+	kDontCare
+};
+
+enum class PipelineProgram {
+	kUnshaded,
+	kUnshadedPaletted
+};
+
+enum class BufferType {
+	kVertexBuffer,
+	kIndexBuffer
+};
+
+enum class BufferUsage {
+	kImmutable,
+	kDynamic
+};
+
+enum class VertexAttributeName {
+	kPosition,
+	kNormal,
+	kTexCoord0,
+	kTexCoord1,
+	kColor
+};
+
+enum class UniformName {
+	kTime,
+	kModelView,
+	kProjection,
+	kTexCoord0Transform
+};
+
+enum class SamplerName {
+	kSampler0,
+	kSampler1,
+	kSampler2,
+	kSampler3
+};
+
+struct Color {
+	float r;
+	float g;
+	float b;
+	float a;
+};
+
+struct Rect {
+	int32_t x;
+	int32_t y;
+	uint32_t w;
+	uint32_t h;
+};
+
+constexpr const size_t kMaxVertexAttributes = 8;
+constexpr const size_t kMaxSamplers = 4;
+
+struct ProgramVertexInput {
+	VertexAttributeName name;
+	VertexAttributeFormat type;
+	bool required;
+};
+
+struct ProgramUniformInput {
+	UniformName name;
+	bool required;
+};
+
+struct ProgramSamplerInput {
+	SamplerName name;
+	bool required;
+};
+
+struct ProgramVertexInputRequirements {
+	srb2::StaticVec<ProgramVertexInput, kMaxVertexAttributes> attributes;
+};
+
+struct ProgramUniformRequirements {
+	srb2::StaticVec<srb2::StaticVec<UniformName, 16>, 4> uniform_groups;
+};
+
+struct ProgramSamplerRequirements {
+	std::array<std::optional<ProgramSamplerInput>, kMaxSamplers> samplers;
+};
+
+struct ProgramRequirements {
+	ProgramVertexInputRequirements vertex_input;
+	ProgramUniformRequirements uniforms;
+	ProgramSamplerRequirements samplers;
+};
+
+extern const ProgramRequirements kProgramRequirementsUnshaded;
+extern const ProgramRequirements kProgramRequirementsUnshadedPaletted;
+
+const ProgramRequirements& program_requirements_for_program(PipelineProgram program) noexcept;
+
+inline constexpr const VertexAttributeFormat vertex_attribute_format(VertexAttributeName name) noexcept
+{
+	switch (name) {
+	case VertexAttributeName::kPosition:
+		return VertexAttributeFormat::kFloat3;
+	case VertexAttributeName::kNormal:
+		return VertexAttributeFormat::kFloat3;
+	case VertexAttributeName::kTexCoord0:
+		return VertexAttributeFormat::kFloat2;
+	case VertexAttributeName::kTexCoord1:
+		return VertexAttributeFormat::kFloat2;
+	case VertexAttributeName::kColor:
+		return VertexAttributeFormat::kFloat4;
+	default:
+		return VertexAttributeFormat::kFloat;
+	};
+}
+
+inline constexpr const UniformFormat uniform_format(UniformName name) noexcept
+{
+	switch (name) {
+	case UniformName::kTime:
+		return UniformFormat::kFloat;
+	case UniformName::kModelView:
+		return UniformFormat::kMat4;
+	case UniformName::kProjection:
+		return UniformFormat::kMat4;
+	case UniformName::kTexCoord0Transform:
+		return UniformFormat::kMat3;
+	default:
+		return UniformFormat::kFloat;
+	}
+}
+
+struct VertexBufferLayoutDesc {
+	uint32_t stride;
+};
+
+struct VertexAttributeLayoutDesc {
+	VertexAttributeName name;
+	uint32_t buffer_index;
+	uint32_t offset;
+};
+
+// constexpr const size_t kMaxVertexBufferBindings = 4;
+
+struct VertexInputDesc {
+	std::vector<VertexBufferLayoutDesc> buffer_layouts;
+	std::vector<VertexAttributeLayoutDesc> attr_layouts;
+};
+
+struct UniformInputDesc {
+	srb2::StaticVec<srb2::StaticVec<UniformName, 16>, 4> enabled_uniforms;
+};
+
+struct SamplerInputDesc {
+	std::vector<SamplerName> enabled_samplers;
+};
+
+struct ColorMask {
+	bool r;
+	bool g;
+	bool b;
+	bool a;
+};
+
+struct BlendDesc {
+	BlendFactor source_factor_color;
+	BlendFactor dest_factor_color;
+	BlendFunction color_function;
+	BlendFactor source_factor_alpha;
+	BlendFactor dest_factor_alpha;
+	BlendFunction alpha_function;
+};
+
+struct PipelineDepthAttachmentDesc {
+	PixelFormat format;
+	CompareFunc func;
+	bool write;
+};
+
+struct PipelineColorAttachmentDesc {
+	PixelFormat format;
+	std::optional<BlendDesc> blend;
+	ColorMask color_mask;
+};
+
+struct PipelineDesc {
+	PipelineProgram program;
+	VertexInputDesc vertex_input;
+	UniformInputDesc uniform_input;
+	SamplerInputDesc sampler_input;
+	std::optional<PipelineDepthAttachmentDesc> depth_attachment;
+	// std::optional<StencilAttachmentDesc> stencil_attachment;
+	PipelineColorAttachmentDesc color_attachment;
+	PrimitiveType primitive;
+	CullMode cull;
+	FaceWinding winding;
+	Color blend_color;
+};
+
+struct RenderPassDesc {
+	std::optional<PixelFormat> depth_format;
+	PixelFormat color_format;
+	AttachmentLoadOp load_op;
+	AttachmentStoreOp store_op;
+};
+
+struct RenderbufferDesc {
+	PixelFormat format;
+	uint32_t width;
+	uint32_t height;
+};
+
+struct TextureDesc {
+	TextureFormat format;
+	uint32_t width;
+	uint32_t height;
+};
+
+struct BufferDesc {
+	uint32_t size;
+	BufferType type;
+	BufferUsage usage;
+};
+
+struct RenderPassBeginInfo {
+	Handle<RenderPass> render_pass;
+	TextureOrRenderbuffer color_attachment;
+	std::optional<TextureOrRenderbuffer> depth_attachment;
+	Color clear_color;
+};
+
+using UniformVariant = std::variant<
+	float,
+	std::array<float, 2>,
+	std::array<float, 3>,
+	std::array<float, 4>,
+
+	int32_t,
+	std::array<int32_t, 2>,
+	std::array<int32_t, 3>,
+	std::array<int32_t, 4>,
+
+	// The indexing order of matrices is [row][column].
+
+	std::array<std::array<float, 2>, 2>,
+	std::array<std::array<float, 3>, 3>,
+	std::array<std::array<float, 4>, 4>
+>;
+
+inline constexpr UniformFormat uniform_variant_format(const UniformVariant& variant)
+{
+	struct Visitor
+	{
+		UniformFormat operator()(const float&) const noexcept { return UniformFormat::kFloat; }
+		UniformFormat operator()(const std::array<float, 2>&) const noexcept { return UniformFormat::kFloat2; }
+		UniformFormat operator()(const std::array<float, 3>&) const noexcept { return UniformFormat::kFloat3; }
+		UniformFormat operator()(const std::array<float, 4>&) const noexcept { return UniformFormat::kFloat4; }
+		UniformFormat operator()(const int32_t&) const noexcept { return UniformFormat::kInt; }
+		UniformFormat operator()(const std::array<int32_t, 2>&) const noexcept { return UniformFormat::kInt2; }
+		UniformFormat operator()(const std::array<int32_t, 3>&) const noexcept { return UniformFormat::kInt3; }
+		UniformFormat operator()(const std::array<int32_t, 4>&) const noexcept { return UniformFormat::kInt4; }
+		UniformFormat operator()(const std::array<std::array<float, 2>, 2>&) const noexcept { return UniformFormat::kMat2; }
+		UniformFormat operator()(const std::array<std::array<float, 3>, 3>&) const noexcept { return UniformFormat::kMat3; }
+		UniformFormat operator()(const std::array<std::array<float, 4>, 4>&) const noexcept { return UniformFormat::kMat4; }
+	};
+	return std::visit(Visitor{}, variant);
+}
+
+struct VertexAttributeBufferBinding {
+	uint32_t attribute_index;
+	Handle<Buffer> vertex_buffer;
+};
+
+struct TextureBinding {
+	SamplerName name;
+	Handle<Texture> texture;
+};
+
+struct CreateUniformSetInfo {
+	tcb::span<UniformVariant> uniforms;
+};
+
+struct CreateBindingSetInfo {
+	tcb::span<VertexAttributeBufferBinding> vertex_buffers;
+	tcb::span<TextureBinding> sampler_textures;
+};
+
+struct UniformSet {};
+struct BindingSet {};
+
+struct TransferContext {};
+struct GraphicsContext {};
+
+/// @brief An active handle to a rendering device.
+struct Rhi {
+	virtual ~Rhi();
+
+	virtual Handle<RenderPass> create_render_pass(const RenderPassDesc& desc) = 0;
+	virtual void destroy_render_pass(Handle<RenderPass> handle) = 0;
+	virtual Handle<Pipeline> create_pipeline(const PipelineDesc& desc) = 0;
+	virtual void destroy_pipeline(Handle<Pipeline> handle) = 0;
+
+	virtual Handle<Texture> create_texture(const TextureDesc& desc) = 0;
+	virtual void destroy_texture(Handle<Texture> handle) = 0;
+	virtual Handle<Buffer> create_buffer(const BufferDesc& desc) = 0;
+	virtual void destroy_buffer(Handle<Buffer> handle) = 0;
+	virtual Handle<Renderbuffer> create_renderbuffer(const RenderbufferDesc& desc) = 0;
+	virtual void destroy_renderbuffer(Handle<Renderbuffer> handle) = 0;
+
+	virtual Handle<TransferContext> begin_transfer() = 0;
+	virtual void end_transfer(Handle<TransferContext> handle) = 0;
+
+	// Transfer Context functions
+	virtual void update_buffer_contents(Handle<TransferContext> ctx, Handle<Buffer> buffer, uint32_t offset, tcb::span<const std::byte> data) = 0;
+	virtual void update_texture(Handle<TransferContext> ctx, Handle<Texture> texture, Rect region, srb2::rhi::PixelFormat data_format, tcb::span<const std::byte> data) = 0;
+	virtual Handle<UniformSet> create_uniform_set(Handle<TransferContext> ctx, const CreateUniformSetInfo& info) = 0;
+	virtual Handle<BindingSet> create_binding_set(Handle<TransferContext> ctx, Handle<Pipeline> pipeline, const CreateBindingSetInfo& info) = 0;
+
+	virtual Handle<GraphicsContext> begin_graphics() = 0;
+	virtual void end_graphics(Handle<GraphicsContext> ctx) = 0;
+
+	// Graphics context functions
+	virtual void begin_default_render_pass(Handle<GraphicsContext> ctx, bool clear) = 0;
+	virtual void begin_render_pass(Handle<GraphicsContext> ctx, const RenderPassBeginInfo& info) = 0;
+	virtual void end_render_pass(Handle<GraphicsContext> ctx) = 0;
+	virtual void bind_pipeline(Handle<GraphicsContext> ctx, Handle<Pipeline> pipeline) = 0;
+	virtual void bind_uniform_set(Handle<GraphicsContext> ctx, uint32_t slot, Handle<UniformSet> set) = 0;
+	virtual void bind_binding_set(Handle<GraphicsContext> ctx, Handle<BindingSet> set) = 0;
+	virtual void bind_index_buffer(Handle<GraphicsContext> ctx, Handle<Buffer> buffer) = 0;
+	virtual void set_scissor(Handle<GraphicsContext> ctx, const Rect& rect) = 0;
+	virtual void set_viewport(Handle<GraphicsContext> ctx, const Rect& rect) = 0;
+	virtual void draw(Handle<GraphicsContext> ctx, uint32_t vertex_count, uint32_t first_vertex) = 0;
+	virtual void draw_indexed(Handle<GraphicsContext> ctx, uint32_t index_count, uint32_t first_index) = 0;
+	virtual void read_pixels(Handle<GraphicsContext> ctx, const Rect& rect, tcb::span<std::byte> out) = 0;
+
+	virtual void present() = 0;
+
+	virtual void finish() = 0;
+};
+
+} // namespace srb2::rhi
+
+#endif // __SRB2_RHI_RHI_HPP__
diff --git a/src/screen.h b/src/screen.h
index 23498de59..f76fe05a3 100644
--- a/src/screen.h
+++ b/src/screen.h
@@ -57,6 +57,8 @@ struct viddef_t
 	size_t rowbytes; // bytes per scanline of the VIDEO mode
 	INT32 width; // PIXELS per scanline
 	INT32 height;
+	UINT32 realwidth; // real pixel width of window/screen
+	UINT32 realheight; // real pixel height of window/screen
 	union { // don't need numpages for OpenGL, so we can use it for fullscreen/windowed mode
 		INT32 numpages; // always 1, page flipping todo
 		INT32 windowed; // windowed or fullscren mode?
diff --git a/src/sdl/CMakeLists.txt b/src/sdl/CMakeLists.txt
index 2994ba2e3..e77b40910 100644
--- a/src/sdl/CMakeLists.txt
+++ b/src/sdl/CMakeLists.txt
@@ -3,6 +3,8 @@
 target_sources(SRB2SDL2 PRIVATE
 	new_sound.cpp
 	ogl_sdl.c
+	rhi_gl3_core_platform.cpp
+	rhi_gl3_core_platform.hpp
 	i_threads.c
 	i_net.c
 	i_system.c
diff --git a/src/sdl/i_video.cpp b/src/sdl/i_video.cpp
index 715c9ebf9..dd5003fba 100644
--- a/src/sdl/i_video.cpp
+++ b/src/sdl/i_video.cpp
@@ -21,9 +21,16 @@
 
 #include <stdlib.h>
 #include <errno.h>
+#include <memory>
 
 #include <signal.h>
 
+#include <imgui.h>
+
+#include "../rhi/rhi.hpp"
+#include "../rhi/gl3_core/gl3_core_rhi.hpp"
+#include "rhi_gl3_core_platform.hpp"
+
 #ifdef _MSC_VER
 #pragma warning(disable : 4214 4244)
 #endif
@@ -93,6 +100,8 @@
 // maximum number of windowed modes (see windowedModes[][])
 #define MAXWINMODES (18)
 
+using namespace srb2;
+
 /**	\brief
 */
 static INT32 numVidModes = -1;
@@ -104,9 +113,6 @@ static char vidModeName[33][32]; // allow 33 different modes
 rendermode_t rendermode = render_soft;
 rendermode_t chosenrendermode = render_none; // set by command line arguments
 
-boolean highcolor = false;
-
-
 // synchronize page flipping with screen refresh
 consvar_t cv_vidwait = CVAR_INIT ("vid_wait", "Off", CV_SAVE, CV_OnOff, NULL);
 static consvar_t cv_stretch = CVAR_INIT ("stretch", "Off", CV_SAVE|CV_NOSHOWHELP, CV_OnOff, NULL);
@@ -134,27 +140,30 @@ static      SDL_Surface *vidSurface = NULL;
 static      SDL_Surface *bufSurface = NULL;
 static      SDL_Surface *icoSurface = NULL;
 static      SDL_Color    localPalette[256];
-#if 0
-static      SDL_Rect   **modeList = NULL;
-static       Uint8       BitsPerPixel = 16;
-#endif
 Uint16      realwidth = BASEVIDWIDTH;
 Uint16      realheight = BASEVIDHEIGHT;
 static       SDL_bool    mousegrabok = SDL_TRUE;
 static       SDL_bool    wrapmouseok = SDL_FALSE;
-#define HalfWarpMouse(x,y) if (wrapmouseok) SDL_WarpMouseInWindow(window, (Uint16)(x/2),(Uint16)(y/2))
-static       SDL_bool    videoblitok = SDL_FALSE;
 static       SDL_bool    exposevideo = SDL_FALSE;
-static       SDL_bool    usesdl2soft = SDL_FALSE;
 static       SDL_bool    borderlesswindow = SDL_FALSE;
 
 // SDL2 vars
 SDL_Window   *window;
-SDL_Renderer *renderer;
-static SDL_Texture  *texture;
 static SDL_bool      havefocus = SDL_TRUE;
 static const char *fallback_resolution_name = "Fallback";
 
+struct RhiSwState {
+	rhi::Handle<rhi::Pipeline> g_sw_palette_pipeline;
+	rhi::Handle<rhi::Texture> g_sw_screen_texture;
+	rhi::Handle<rhi::Texture> g_palette_texture;
+	rhi::Handle<rhi::Buffer> g_quad_vb;
+	rhi::Handle<rhi::Buffer> g_quad_ib;
+};
+
+static std::unique_ptr<rhi::Rhi> g_rhi;
+static uint32_t g_rhi_generation = 0;
+static RhiSwState g_rhi_sw_state;
+
 // windowed video modes from which to choose from.
 static INT32 windowedModes[MAXWINMODES][2] =
 {
@@ -178,35 +187,14 @@ static INT32 windowedModes[MAXWINMODES][2] =
 	{ 320, 200}, // 1.60,1.00
 };
 
-static void Impl_VideoSetupSDLBuffer(void);
 static void Impl_VideoSetupBuffer(void);
 static SDL_bool Impl_CreateWindow(SDL_bool fullscreen);
 //static void Impl_SetWindowName(const char *title);
 static void Impl_SetWindowIcon(void);
 
-static void Impl_SetSoftwareVsync(int vsync)
-{
-#if SDL_VERSION_ATLEAST(2,0,18)
-	static int oldvsync = 0;
-	if (oldvsync != vsync)
-	{
-		SDL_RenderSetVSync(renderer, vsync);
-	}
-	oldvsync = vsync;
-#else
-	(void)vsync;
-#endif
-}
-
 static void SDLSetMode(INT32 width, INT32 height, SDL_bool fullscreen, SDL_bool reposition)
 {
 	static SDL_bool wasfullscreen = SDL_FALSE;
-	Uint32 rmask;
-	Uint32 gmask;
-	Uint32 bmask;
-	Uint32 amask;
-	int bpp = 16;
-	int sw_texture_format = SDL_PIXELFORMAT_ABGR8888;
 
 	realwidth = vid.width;
 	realheight = vid.height;
@@ -247,51 +235,9 @@ static void SDLSetMode(INT32 width, INT32 height, SDL_bool fullscreen, SDL_bool
 		}
 	}
 
-#ifdef HWRENDER
-	if (rendermode == render_opengl)
-	{
-		OglSdlSurface(vid.width, vid.height);
-	}
-#endif
-
-	if (rendermode == render_soft)
-	{
-		SDL_RenderClear(renderer);
-		SDL_RenderSetLogicalSize(renderer, width, height);
-		// Set up Texture
-		realwidth = width;
-		realheight = height;
-		if (texture != NULL)
-		{
-			SDL_DestroyTexture(texture);
-		}
-
-		if (!usesdl2soft)
-		{
-			sw_texture_format = SDL_PIXELFORMAT_RGB565;
-		}
-		else
-		{
-			bpp = 32;
-			sw_texture_format = SDL_PIXELFORMAT_RGBA8888;
-		}
-
-		texture = SDL_CreateTexture(renderer, sw_texture_format, SDL_TEXTUREACCESS_STREAMING, width, height);
-
-		// Set up SW surface
-		if (vidSurface != NULL)
-		{
-			SDL_FreeSurface(vidSurface);
-		}
-		if (vid.buffer)
-		{
-			free(vid.buffer);
-			vid.buffer = NULL;
-		}
-		SDL_PixelFormatEnumToMasks(sw_texture_format, &bpp, &rmask, &gmask, &bmask, &amask);
-		vidSurface = SDL_CreateRGBSurface(0, width, height, bpp, rmask, gmask, bmask, amask);
-		Impl_SetSoftwareVsync(cv_vidwait.value);
-	}
+	SDL_GetWindowSize(window, &width, &height);
+	vid.realwidth = static_cast<uint32_t>(width);
+	vid.realheight = static_cast<uint32_t>(height);
 }
 
 static INT32 Impl_SDL_Scancode_To_Keycode(SDL_Scancode code)
@@ -458,51 +404,8 @@ static void SurfaceInfo(const SDL_Surface *infoSurface, const char *SurfaceText)
 
 static void VID_Command_Info_f (void)
 {
-#if 0
-	SDL2STUB();
-#else
-#if 0
-	const SDL_VideoInfo *videoInfo;
-	videoInfo = SDL_GetVideoInfo(); //Alam: Double-Check
-	if (videoInfo)
-	{
-		CONS_Printf("%s", M_GetText("Video Interface Capabilities:\n"));
-		if (videoInfo->hw_available)
-			CONS_Printf("%s", M_GetText(" Hardware surfaces\n"));
-		if (videoInfo->wm_available)
-			CONS_Printf("%s", M_GetText(" Window manager\n"));
-		//UnusedBits1  :6
-		//UnusedBits2  :1
-		if (videoInfo->blit_hw)
-			CONS_Printf("%s", M_GetText(" Accelerated blits HW-2-HW\n"));
-		if (videoInfo->blit_hw_CC)
-			CONS_Printf("%s", M_GetText(" Accelerated blits HW-2-HW with Colorkey\n"));
-		if (videoInfo->wm_available)
-			CONS_Printf("%s", M_GetText(" Accelerated blits HW-2-HW with Alpha\n"));
-		if (videoInfo->blit_sw)
-		{
-			CONS_Printf("%s", M_GetText(" Accelerated blits SW-2-HW\n"));
-			if (!M_CheckParm("-noblit")) videoblitok = SDL_TRUE;
-		}
-		if (videoInfo->blit_sw_CC)
-			CONS_Printf("%s", M_GetText(" Accelerated blits SW-2-HW with Colorkey\n"));
-		if (videoInfo->blit_sw_A)
-			CONS_Printf("%s", M_GetText(" Accelerated blits SW-2-HW with Alpha\n"));
-		if (videoInfo->blit_fill)
-			CONS_Printf("%s", M_GetText(" Accelerated Color filling\n"));
-		//UnusedBits3  :16
-		if (videoInfo->video_mem)
-			CONS_Printf(M_GetText(" There is %i KB of video memory\n"), videoInfo->video_mem);
-		else
-			CONS_Printf("%s", M_GetText(" There no video memory for SDL\n"));
-		//*vfmt
-	}
-#else
-	if (!M_CheckParm("-noblit")) videoblitok = SDL_TRUE;
-#endif
 	SurfaceInfo(bufSurface, M_GetText("Current Engine Mode"));
 	SurfaceInfo(vidSurface, M_GetText("Current Video Mode"));
-#endif
 }
 
 static void VID_Command_ModeList_f(void)
@@ -875,6 +778,204 @@ static void Impl_HandleControllerButtonEvent(SDL_ControllerButtonEvent evt, Uint
 	}
 }
 
+static ImGuiKey ImGui_ImplSDL2_KeycodeToImGuiKey(int keycode)
+{
+	switch (keycode)
+	{
+		case SDLK_TAB: return ImGuiKey_Tab;
+		case SDLK_LEFT: return ImGuiKey_LeftArrow;
+		case SDLK_RIGHT: return ImGuiKey_RightArrow;
+		case SDLK_UP: return ImGuiKey_UpArrow;
+		case SDLK_DOWN: return ImGuiKey_DownArrow;
+		case SDLK_PAGEUP: return ImGuiKey_PageUp;
+		case SDLK_PAGEDOWN: return ImGuiKey_PageDown;
+		case SDLK_HOME: return ImGuiKey_Home;
+		case SDLK_END: return ImGuiKey_End;
+		case SDLK_INSERT: return ImGuiKey_Insert;
+		case SDLK_DELETE: return ImGuiKey_Delete;
+		case SDLK_BACKSPACE: return ImGuiKey_Backspace;
+		case SDLK_SPACE: return ImGuiKey_Space;
+		case SDLK_RETURN: return ImGuiKey_Enter;
+		case SDLK_ESCAPE: return ImGuiKey_Escape;
+		case SDLK_QUOTE: return ImGuiKey_Apostrophe;
+		case SDLK_COMMA: return ImGuiKey_Comma;
+		case SDLK_MINUS: return ImGuiKey_Minus;
+		case SDLK_PERIOD: return ImGuiKey_Period;
+		case SDLK_SLASH: return ImGuiKey_Slash;
+		case SDLK_SEMICOLON: return ImGuiKey_Semicolon;
+		case SDLK_EQUALS: return ImGuiKey_Equal;
+		case SDLK_LEFTBRACKET: return ImGuiKey_LeftBracket;
+		case SDLK_BACKSLASH: return ImGuiKey_Backslash;
+		case SDLK_RIGHTBRACKET: return ImGuiKey_RightBracket;
+		case SDLK_BACKQUOTE: return ImGuiKey_GraveAccent;
+		case SDLK_CAPSLOCK: return ImGuiKey_CapsLock;
+		case SDLK_SCROLLLOCK: return ImGuiKey_ScrollLock;
+		case SDLK_NUMLOCKCLEAR: return ImGuiKey_NumLock;
+		case SDLK_PRINTSCREEN: return ImGuiKey_PrintScreen;
+		case SDLK_PAUSE: return ImGuiKey_Pause;
+		case SDLK_KP_0: return ImGuiKey_Keypad0;
+		case SDLK_KP_1: return ImGuiKey_Keypad1;
+		case SDLK_KP_2: return ImGuiKey_Keypad2;
+		case SDLK_KP_3: return ImGuiKey_Keypad3;
+		case SDLK_KP_4: return ImGuiKey_Keypad4;
+		case SDLK_KP_5: return ImGuiKey_Keypad5;
+		case SDLK_KP_6: return ImGuiKey_Keypad6;
+		case SDLK_KP_7: return ImGuiKey_Keypad7;
+		case SDLK_KP_8: return ImGuiKey_Keypad8;
+		case SDLK_KP_9: return ImGuiKey_Keypad9;
+		case SDLK_KP_PERIOD: return ImGuiKey_KeypadDecimal;
+		case SDLK_KP_DIVIDE: return ImGuiKey_KeypadDivide;
+		case SDLK_KP_MULTIPLY: return ImGuiKey_KeypadMultiply;
+		case SDLK_KP_MINUS: return ImGuiKey_KeypadSubtract;
+		case SDLK_KP_PLUS: return ImGuiKey_KeypadAdd;
+		case SDLK_KP_ENTER: return ImGuiKey_KeypadEnter;
+		case SDLK_KP_EQUALS: return ImGuiKey_KeypadEqual;
+		case SDLK_LCTRL: return ImGuiKey_LeftCtrl;
+		case SDLK_LSHIFT: return ImGuiKey_LeftShift;
+		case SDLK_LALT: return ImGuiKey_LeftAlt;
+		case SDLK_LGUI: return ImGuiKey_LeftSuper;
+		case SDLK_RCTRL: return ImGuiKey_RightCtrl;
+		case SDLK_RSHIFT: return ImGuiKey_RightShift;
+		case SDLK_RALT: return ImGuiKey_RightAlt;
+		case SDLK_RGUI: return ImGuiKey_RightSuper;
+		case SDLK_APPLICATION: return ImGuiKey_Menu;
+		case SDLK_0: return ImGuiKey_0;
+		case SDLK_1: return ImGuiKey_1;
+		case SDLK_2: return ImGuiKey_2;
+		case SDLK_3: return ImGuiKey_3;
+		case SDLK_4: return ImGuiKey_4;
+		case SDLK_5: return ImGuiKey_5;
+		case SDLK_6: return ImGuiKey_6;
+		case SDLK_7: return ImGuiKey_7;
+		case SDLK_8: return ImGuiKey_8;
+		case SDLK_9: return ImGuiKey_9;
+		case SDLK_a: return ImGuiKey_A;
+		case SDLK_b: return ImGuiKey_B;
+		case SDLK_c: return ImGuiKey_C;
+		case SDLK_d: return ImGuiKey_D;
+		case SDLK_e: return ImGuiKey_E;
+		case SDLK_f: return ImGuiKey_F;
+		case SDLK_g: return ImGuiKey_G;
+		case SDLK_h: return ImGuiKey_H;
+		case SDLK_i: return ImGuiKey_I;
+		case SDLK_j: return ImGuiKey_J;
+		case SDLK_k: return ImGuiKey_K;
+		case SDLK_l: return ImGuiKey_L;
+		case SDLK_m: return ImGuiKey_M;
+		case SDLK_n: return ImGuiKey_N;
+		case SDLK_o: return ImGuiKey_O;
+		case SDLK_p: return ImGuiKey_P;
+		case SDLK_q: return ImGuiKey_Q;
+		case SDLK_r: return ImGuiKey_R;
+		case SDLK_s: return ImGuiKey_S;
+		case SDLK_t: return ImGuiKey_T;
+		case SDLK_u: return ImGuiKey_U;
+		case SDLK_v: return ImGuiKey_V;
+		case SDLK_w: return ImGuiKey_W;
+		case SDLK_x: return ImGuiKey_X;
+		case SDLK_y: return ImGuiKey_Y;
+		case SDLK_z: return ImGuiKey_Z;
+		case SDLK_F1: return ImGuiKey_F1;
+		case SDLK_F2: return ImGuiKey_F2;
+		case SDLK_F3: return ImGuiKey_F3;
+		case SDLK_F4: return ImGuiKey_F4;
+		case SDLK_F5: return ImGuiKey_F5;
+		case SDLK_F6: return ImGuiKey_F6;
+		case SDLK_F7: return ImGuiKey_F7;
+		case SDLK_F8: return ImGuiKey_F8;
+		case SDLK_F9: return ImGuiKey_F9;
+		case SDLK_F10: return ImGuiKey_F10;
+		case SDLK_F11: return ImGuiKey_F11;
+		case SDLK_F12: return ImGuiKey_F12;
+	}
+	return ImGuiKey_None;
+}
+
+static void ImGui_ImplSDL2_UpdateKeyModifiers(SDL_Keymod sdl_key_mods)
+{
+	ImGuiIO& io = ImGui::GetIO();
+	io.AddKeyEvent(ImGuiMod_Ctrl, (sdl_key_mods & KMOD_CTRL) != 0);
+	io.AddKeyEvent(ImGuiMod_Shift, (sdl_key_mods & KMOD_SHIFT) != 0);
+	io.AddKeyEvent(ImGuiMod_Alt, (sdl_key_mods & KMOD_ALT) != 0);
+	io.AddKeyEvent(ImGuiMod_Super, (sdl_key_mods & KMOD_GUI) != 0);
+}
+
+// You can read the io.WantCaptureMouse, io.WantCaptureKeyboard flags to tell if dear imgui wants to use your inputs.
+// - When io.WantCaptureMouse is true, do not dispatch mouse input data to your main application, or clear/overwrite your copy of the mouse data.
+// - When io.WantCaptureKeyboard is true, do not dispatch keyboard input data to your main application, or clear/overwrite your copy of the keyboard data.
+// Generally you may always pass all inputs to dear imgui, and hide them from your application based on those two flags.
+// If you have multiple SDL events and some of them are not meant to be used by dear imgui, you may need to filter events based on their windowID field.
+bool ImGui_ImplSDL2_ProcessEvent(const SDL_Event* event)
+{
+	ImGuiIO& io = ImGui::GetIO();
+
+	switch (event->type)
+	{
+		case SDL_MOUSEMOTION:
+		{
+			io.AddMousePosEvent((float)event->motion.x, (float)event->motion.y);
+			return true;
+		}
+		case SDL_MOUSEWHEEL:
+		{
+			float wheel_x = (event->wheel.x > 0) ? 1.0f : (event->wheel.x < 0) ? -1.0f : 0.0f;
+			float wheel_y = (event->wheel.y > 0) ? 1.0f : (event->wheel.y < 0) ? -1.0f : 0.0f;
+			io.AddMouseWheelEvent(wheel_x, wheel_y);
+			return true;
+		}
+		case SDL_MOUSEBUTTONDOWN:
+		case SDL_MOUSEBUTTONUP:
+		{
+			int mouse_button = -1;
+			if (event->button.button == SDL_BUTTON_LEFT) { mouse_button = 0; }
+			if (event->button.button == SDL_BUTTON_RIGHT) { mouse_button = 1; }
+			if (event->button.button == SDL_BUTTON_MIDDLE) { mouse_button = 2; }
+			if (event->button.button == SDL_BUTTON_X1) { mouse_button = 3; }
+			if (event->button.button == SDL_BUTTON_X2) { mouse_button = 4; }
+			if (mouse_button == -1)
+				break;
+			io.AddMouseButtonEvent(mouse_button, (event->type == SDL_MOUSEBUTTONDOWN));
+			// bd->MouseButtonsDown = (event->type == SDL_MOUSEBUTTONDOWN) ? (bd->MouseButtonsDown | (1 << mouse_button)) : (bd->MouseButtonsDown & ~(1 << mouse_button));
+			return true;
+		}
+		case SDL_TEXTINPUT:
+		{
+			io.AddInputCharactersUTF8(event->text.text);
+			return true;
+		}
+		case SDL_KEYDOWN:
+		case SDL_KEYUP:
+		{
+			ImGui_ImplSDL2_UpdateKeyModifiers((SDL_Keymod)event->key.keysym.mod);
+			ImGuiKey key = ImGui_ImplSDL2_KeycodeToImGuiKey(event->key.keysym.sym);
+			io.AddKeyEvent(key, (event->type == SDL_KEYDOWN));
+			io.SetKeyEventNativeData(key, event->key.keysym.sym, event->key.keysym.scancode, event->key.keysym.scancode); // To support legacy indexing (<1.87 user code). Legacy backend uses SDLK_*** as indices to IsKeyXXX() functions.
+			return true;
+		}
+		case SDL_WINDOWEVENT:
+		{
+			// - When capturing mouse, SDL will send a bunch of conflicting LEAVE/ENTER event on every mouse move, but the final ENTER tends to be right.
+			// - However we won't get a correct LEAVE event for a captured window.
+			// - In some cases, when detaching a window from main viewport SDL may send SDL_WINDOWEVENT_ENTER one frame too late,
+			//   causing SDL_WINDOWEVENT_LEAVE on previous frame to interrupt drag operation by clear mouse position. This is why
+			//   we delay process the SDL_WINDOWEVENT_LEAVE events by one frame. See issue #5012 for details.
+			Uint8 window_event = event->window.event;
+			if (window_event == SDL_WINDOWEVENT_ENTER)
+				(void)0;
+				// bd->PendingMouseLeaveFrame = 0;
+			if (window_event == SDL_WINDOWEVENT_LEAVE)
+				(void)0;
+				// bd->PendingMouseLeaveFrame = ImGui::GetFrameCount() + 1;
+			if (window_event == SDL_WINDOWEVENT_FOCUS_GAINED)
+				io.AddFocusEvent(true);
+			else if (event->window.event == SDL_WINDOWEVENT_FOCUS_LOST)
+				io.AddFocusEvent(false);
+			return true;
+		}
+	}
+	return false;
+}
+
 void I_GetEvent(void)
 {
 	SDL_Event evt;
@@ -892,8 +993,16 @@ void I_GetEvent(void)
 
 	mousemovex = mousemovey = 0;
 
+	ImGuiIO& io = ImGui::GetIO();
+
 	while (SDL_PollEvent(&evt))
 	{
+		ImGui_ImplSDL2_ProcessEvent(&evt);
+		if (io.WantCaptureMouse || io.WantCaptureKeyboard)
+		{
+			continue;
+		}
+
 		switch (evt.type)
 		{
 			case SDL_WINDOWEVENT:
@@ -1093,6 +1202,13 @@ void I_GetEvent(void)
 	}
 }
 
+static void half_warp_mouse(uint16_t x, uint16_t y) {
+	if (wrapmouseok)
+	{
+		SDL_WarpMouseInWindow(window, (Uint16)(x/2),(Uint16)(y/2));
+	}
+}
+
 void I_StartupMouse(void)
 {
 	static SDL_bool firsttimeonmouse = SDL_TRUE;
@@ -1102,7 +1218,7 @@ void I_StartupMouse(void)
 
 	if (!firsttimeonmouse)
 	{
-		HalfWarpMouse(realwidth, realheight); // warp to center
+		half_warp_mouse(realwidth, realheight); // warp to center
 	}
 	else
 		firsttimeonmouse = SDL_FALSE;
@@ -1149,145 +1265,15 @@ void I_UpdateNoBlit(void)
 		return;
 	if (exposevideo)
 	{
-#ifdef HWRENDER
-		if (rendermode == render_opengl)
-		{
-			OglSdlFinishUpdate(cv_vidwait.value);
-		}
-		else
-#endif
-		if (rendermode == render_soft)
-		{
-			SDL_RenderCopy(renderer, texture, NULL, NULL);
-			SDL_RenderPresent(renderer);
-		}
 	}
 	exposevideo = SDL_FALSE;
 }
 
-// I_SkipFrame
-//
-// Returns true if it thinks we can afford to skip this frame
-// from PrBoom's src/SDL/i_video.c
-static inline boolean I_SkipFrame(void)
-{
-#if 1
-	// While I fixed the FPS counter bugging out with this,
-	// I actually really like being able to pause and
-	// use perfstats to measure rendering performance
-	// without game logic changes.
-	return false;
-#else
-	static boolean skip = false;
-
-	skip = !skip;
-
-	switch (gamestate)
-	{
-		case GS_LEVEL:
-			if (!paused)
-				return false;
-			/* FALLTHRU */
-		case GS_WAITINGPLAYERS:
-			return skip; // Skip odd frames
-		default:
-			return false;
-	}
-#endif
-}
-
 //
 // I_FinishUpdate
 //
 static SDL_Rect src_rect = { 0, 0, 0, 0 };
 
-void I_FinishUpdate(void)
-{
-	int player;
-
-	if (rendermode == render_none)
-		return; //Alam: No software or OpenGl surface
-
-	SCR_CalculateFPS();
-
-	if (I_SkipFrame())
-		return;
-
-	if (st_overlay)
-	{
-		if (cv_ticrate.value)
-			SCR_DisplayTicRate();
-
-		if (cv_showping.value && netgame &&
-				( consoleplayer != serverplayer || ! server_lagless ))
-		{
-			if (server_lagless)
-			{
-				if (consoleplayer != serverplayer)
-					SCR_DisplayLocalPing();
-			}
-			else
-			{
-				for (
-						player = 1;
-						player < MAXPLAYERS;
-						player++
-				){
-					if (D_IsPlayerHumanAndGaming(player))
-					{
-						SCR_DisplayLocalPing();
-						break;
-					}
-				}
-			}
-		}
-		if (cv_mindelay.value && consoleplayer == serverplayer && Playing())
-			SCR_DisplayLocalPing();
-	}
-
-	if (marathonmode)
-		SCR_DisplayMarathonInfo();
-
-	// draw captions if enabled
-	if (cv_closedcaptioning.value)
-		SCR_ClosedCaptions();
-
-#ifdef HAVE_DISCORDRPC
-	if (discordRequestList != NULL)
-		ST_AskToJoinEnvelope();
-#endif
-
-	if (rendermode == render_soft && screens[0])
-	{
-		if (!bufSurface) //Double-Check
-		{
-			Impl_VideoSetupSDLBuffer();
-		}
-
-		if (bufSurface)
-		{
-			SDL_BlitSurface(bufSurface, &src_rect, vidSurface, &src_rect);
-			// Fury -- there's no way around UpdateTexture, the GL backend uses it anyway
-			SDL_LockSurface(vidSurface);
-			SDL_UpdateTexture(texture, &src_rect, vidSurface->pixels, vidSurface->pitch);
-			SDL_UnlockSurface(vidSurface);
-		}
-
-		SDL_RenderClear(renderer);
-		SDL_RenderCopy(renderer, texture, &src_rect, NULL);
-		SDL_RenderPresent(renderer);
-		Impl_SetSoftwareVsync(cv_vidwait.value);
-	}
-#ifdef HWRENDER
-	else if (rendermode == render_opengl)
-	{
-		OglSdlFinishUpdate(cv_vidwait.value);
-	}
-#endif
-
-	exposevideo = SDL_FALSE;
-}
-
 //
 // I_UpdateNoVsync
 //
@@ -1324,9 +1310,6 @@ void I_SetPalette(RGBA_t *palette)
 		localPalette[i].g = palette[i].s.green;
 		localPalette[i].b = palette[i].s.blue;
 	}
-	//if (vidSurface) SDL_SetPaletteColors(vidSurface->format->palette, localPalette, 0, 256);
-	// Fury -- SDL2 vidSurface is a 32-bit surface buffer copied to the texture. It's not palletized, like bufSurface.
-	if (bufSurface) SDL_SetPaletteColors(bufSurface->format->palette, localPalette, 0, 256);
 }
 
 // return number of fullscreen + X11 modes
@@ -1480,44 +1463,40 @@ void VID_PrepareModeList(void)
 
 static SDL_bool Impl_CreateContext(void)
 {
-	// Renderer-specific stuff
-#ifdef HWRENDER
-	if ((rendermode == render_opengl)
-	&& (vid.glstate != VID_GL_LIBRARY_ERROR))
+	// RHI always uses OpenGL 3.2 Core (for now)
+	if (!sdlglcontext)
 	{
-		if (!sdlglcontext)
-			sdlglcontext = SDL_GL_CreateContext(window);
-		if (sdlglcontext == NULL)
-		{
-			SDL_DestroyWindow(window);
-			I_Error("Failed to create a GL context: %s\n", SDL_GetError());
-		}
-		SDL_GL_MakeCurrent(window, sdlglcontext);
+		SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
+		SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
+		SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 2);
+		sdlglcontext = SDL_GL_CreateContext(window);
 	}
-	else
-#endif
-	if (rendermode == render_soft)
+	if (sdlglcontext == NULL)
 	{
-		int flags = 0; // Use this to set SDL_RENDERER_* flags now
-		if (usesdl2soft)
-			flags |= SDL_RENDERER_SOFTWARE;
-
-		// 3 August 2022
-		// Possibly a Windows 11 issue; the default
-		// "direct3d" driver (D3D9) causes Drmingw exchndl
-		// to not write RPT files. Every other driver
-		// seems fine.
-		SDL_SetHint(SDL_HINT_RENDER_DRIVER, "opengl");
-
-		if (!renderer)
-			renderer = SDL_CreateRenderer(window, -1, flags);
-		if (renderer == NULL)
-		{
-			CONS_Printf(M_GetText("Couldn't create rendering context: %s\n"), SDL_GetError());
-			return SDL_FALSE;
-		}
-		SDL_RenderSetLogicalSize(renderer, BASEVIDWIDTH, BASEVIDHEIGHT);
+		SDL_DestroyWindow(window);
+		I_Error("Failed to create a GL context: %s\n", SDL_GetError());
 	}
+	SDL_GL_MakeCurrent(window, sdlglcontext);
+
+	std::unique_ptr<rhi::SdlGlCorePlatform> platform = std::make_unique<rhi::SdlGlCorePlatform>();
+	platform->window = window;
+	g_rhi = std::make_unique<rhi::GlCoreRhi>(std::move(platform), reinterpret_cast<rhi::GlLoadFunc>(SDL_GL_GetProcAddress));
+	g_rhi_generation += 1;
+
+	ImGui::CreateContext();
+    ImGuiIO& io = ImGui::GetIO(); (void)io;
+	io.IniFilename = NULL;
+	io.BackendFlags = 0;
+	io.BackendRendererName = "SRB2 SDL 2 RHI";
+	io.Fonts->AddFontDefault();
+	{
+		unsigned char* pixels;
+		int width;
+		int height;
+		io.Fonts->GetTexDataAsRGBA32(&pixels, &width, &height);
+	}
+	ImGui::StyleColorsDark();
+
 	return SDL_TRUE;
 }
 
@@ -1544,9 +1523,6 @@ boolean VID_CheckRenderer(void)
 {
 	boolean rendererchanged = false;
 	boolean contextcreated = false;
-#ifdef HWRENDER
-	rendermode_t oldrenderer = rendermode;
-#endif
 
 	if (dedicated)
 		return false;
@@ -1556,46 +1532,6 @@ boolean VID_CheckRenderer(void)
 		rendermode = static_cast<rendermode_t>(setrenderneeded);
 		rendererchanged = true;
 
-#ifdef HWRENDER
-		if (rendermode == render_opengl)
-		{
-			VID_CheckGLLoaded(oldrenderer);
-
-			// Initialise OpenGL before calling SDLSetMode!!!
-			// This is because SDLSetMode calls OglSdlSurface.
-			if (vid.glstate == VID_GL_LIBRARY_NOTLOADED)
-			{
-				VID_StartupOpenGL();
-
-				// Loaded successfully!
-				if (vid.glstate == VID_GL_LIBRARY_LOADED)
-				{
-					// Destroy the current window, if it exists.
-					if (window)
-					{
-						SDL_DestroyWindow(window);
-						window = NULL;
-					}
-
-					// Destroy the current window rendering context, if that also exists.
-					if (renderer)
-					{
-						SDL_DestroyRenderer(renderer);
-						renderer = NULL;
-					}
-
-					// Create a new window.
-					Impl_CreateWindow(static_cast<SDL_bool>(USE_FULLSCREEN));
-
-					// From there, the OpenGL context was already created.
-					contextcreated = true;
-				}
-			}
-			else if (vid.glstate == VID_GL_LIBRARY_ERROR)
-				rendererchanged = false;
-		}
-#endif
-
 		if (!contextcreated)
 			Impl_CreateContext();
 
@@ -1607,21 +1543,8 @@ boolean VID_CheckRenderer(void)
 
 	if (rendermode == render_soft)
 	{
-		if (bufSurface)
-		{
-			SDL_FreeSurface(bufSurface);
-			bufSurface = NULL;
-		}
-
 		SCR_SetDrawFuncs();
 	}
-#ifdef HWRENDER
-	else if (rendermode == render_opengl && rendererchanged)
-	{
-		HWR_Switch();
-		V_SetPalette(0);
-	}
-#endif
 
 	return rendererchanged;
 }
@@ -1661,6 +1584,8 @@ INT32 VID_SetMode(INT32 modeNum)
 
 	vid.width = windowedModes[modeNum][0];
 	vid.height = windowedModes[modeNum][1];
+	vid.realwidth = vid.width;
+	vid.realheight = vid.height;
 	vid.modenum = modeNum;
 
 	src_rect.w = vid.width;
@@ -1668,7 +1593,6 @@ INT32 VID_SetMode(INT32 modeNum)
 
 	refresh_rate = VID_GetRefreshRate();
 
-	//Impl_SetWindowName("Dr. Robotnik's Ring Racers "VERSIONSTRING);
 	VID_CheckRenderer();
 	return SDL_TRUE;
 }
@@ -1689,16 +1613,13 @@ static SDL_bool Impl_CreateWindow(SDL_bool fullscreen)
 	if (borderlesswindow)
 		flags |= SDL_WINDOW_BORDERLESS;
 
-#ifdef HWRENDER
-	if (vid.glstate == VID_GL_LIBRARY_LOADED)
-		flags |= SDL_WINDOW_OPENGL;
-#endif
+	// RHI: always create window as OPENGL
+	flags |= SDL_WINDOW_OPENGL;
 
 	// Create a window
 	window = SDL_CreateWindow("Dr. Robotnik's Ring Racers " VERSIONSTRING, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,
 			realwidth, realheight, flags);
 
-
 	if (window == NULL)
 	{
 		CONS_Printf(M_GetText("Couldn't create window: %s\n"), SDL_GetError());
@@ -1710,51 +1631,12 @@ static SDL_bool Impl_CreateWindow(SDL_bool fullscreen)
 	return Impl_CreateContext();
 }
 
-/*
-static void Impl_SetWindowName(const char *title)
-{
-	if (window == NULL)
-	{
-		return;
-	}
-	SDL_SetWindowTitle(window, title);
-}
-*/
-
 static void Impl_SetWindowIcon(void)
 {
 	if (window && icoSurface)
 		SDL_SetWindowIcon(window, icoSurface);
 }
 
-static void Impl_VideoSetupSDLBuffer(void)
-{
-	if (bufSurface != NULL)
-	{
-		SDL_FreeSurface(bufSurface);
-		bufSurface = NULL;
-	}
-	// Set up the SDL palletized buffer (copied to vidbuffer before being rendered to texture)
-	if (vid.bpp == 1)
-	{
-		bufSurface = SDL_CreateRGBSurfaceFrom(screens[0],vid.width,vid.height,8,
-			(int)vid.rowbytes,0x00000000,0x00000000,0x00000000,0x00000000); // 256 mode
-	}
-	else if (vid.bpp == 2) // Fury -- don't think this is used at all anymore
-	{
-		bufSurface = SDL_CreateRGBSurfaceFrom(screens[0],vid.width,vid.height,15,
-			(int)vid.rowbytes,0x00007C00,0x000003E0,0x0000001F,0x00000000); // 555 mode
-	}
-	if (bufSurface)
-	{
-		SDL_SetPaletteColors(bufSurface->format->palette, localPalette, 0, 256);
-	}
-	else
-	{
-		I_Error("%s", M_GetText("No system memory for SDL buffer surface\n"));
-	}
-}
-
 static void Impl_VideoSetupBuffer(void)
 {
 	// Set up game's software render buffer
@@ -1791,87 +1673,14 @@ void I_StartupGraphics(void)
 
 	keyboard_started = true;
 
-#if !defined(HAVE_TTF)
-	// Previously audio was init here for questionable reasons?
-	if (SDL_InitSubSystem(SDL_INIT_VIDEO) < 0)
-	{
-		CONS_Printf(M_GetText("Couldn't initialize SDL's Video System: %s\n"), SDL_GetError());
-		return;
-	}
-#endif
-	{
-		const char *vd = SDL_GetCurrentVideoDriver();
-		//CONS_Printf(M_GetText("Starting up with video driver: %s\n"), vd);
-		if (vd && (
-			strncasecmp(vd, "gcvideo", 8) == 0 ||
-			strncasecmp(vd, "fbcon", 6) == 0 ||
-			strncasecmp(vd, "wii", 4) == 0 ||
-			strncasecmp(vd, "psl1ght", 8) == 0
-		))
-			framebuffer = SDL_TRUE;
-	}
+	// TEMPORARY OVERRIDES FOR RHI - SOFTWARE ONLY
+	chosenrendermode = render_soft;
+	rendermode = render_soft;
 
-	// Renderer choices
-	// Takes priority over the config.
-	if (M_CheckParm("-renderer"))
-	{
-		INT32 i = 0;
-		CV_PossibleValue_t *renderer_list = cv_renderer_t;
-		const char *modeparm = M_GetNextParm();
-		while (renderer_list[i].strvalue)
-		{
-			if (!stricmp(modeparm, renderer_list[i].strvalue))
-			{
-				chosenrendermode = static_cast<rendermode_t>(renderer_list[i].value);
-				break;
-			}
-			i++;
-		}
-	}
-
-	// Choose Software renderer
-	else if (M_CheckParm("-software"))
-		chosenrendermode = render_soft;
-
-#ifdef HWRENDER
-	// Choose OpenGL renderer
-	else if (M_CheckParm("-opengl"))
-		chosenrendermode = render_opengl;
-
-	// Don't startup OpenGL
-	if (M_CheckParm("-nogl"))
-	{
-		vid.glstate = VID_GL_LIBRARY_ERROR;
-		if (chosenrendermode == render_opengl)
-			chosenrendermode = render_none;
-	}
-#endif
-
-	if (chosenrendermode != render_none)
-		rendermode = chosenrendermode;
-
-	usesdl2soft = M_CheckParm("-softblit") ? SDL_TRUE : SDL_FALSE;
 	borderlesswindow = M_CheckParm("-borderless") ? SDL_TRUE : SDL_FALSE;
 
-	//SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY>>1,SDL_DEFAULT_REPEAT_INTERVAL<<2);
 	VID_Command_ModeList_f();
 
-#ifdef HWRENDER
-	if (rendermode == render_opengl)
-		VID_StartupOpenGL();
-#endif
-
-	// Window icon
-#ifdef HAVE_IMAGE
-	icoSurface = IMG_ReadXPMFromArray(SDL_icon_xpm);
-#endif
-
-	// Fury: we do window initialization after GL setup to allow
-	// SDL_GL_LoadLibrary to work well on Windows
-
-	// Create window
-	//Impl_CreateWindow(USE_FULLSCREEN);
-	//Impl_SetWindowName("Dr. Robotnik's Ring Racers "VERSIONSTRING);
 	VID_SetMode(VID_GetModeForSize(BASEVIDWIDTH, BASEVIDHEIGHT));
 
 	vid.width = BASEVIDWIDTH; // Default size for startup
@@ -1881,24 +1690,10 @@ void I_StartupGraphics(void)
 	vid.bpp = 1; // This is the game engine's Bpp
 	vid.WndParent = NULL; //For the window?
 
-#ifdef HAVE_TTF
-	I_ShutdownTTF();
-#endif
-
 	VID_SetMode(VID_GetModeForSize(BASEVIDWIDTH, BASEVIDHEIGHT));
 
 	if (M_CheckParm("-nomousegrab"))
 		mousegrabok = SDL_FALSE;
-#if 0 // defined (_DEBUG)
-	else
-	{
-		char videodriver[4] = {'S','D','L',0};
-		if (!M_CheckParm("-mousegrab") &&
-		    *strncpy(videodriver, SDL_GetCurrentVideoDriver(), 4) != '\0' &&
-		    strncasecmp("x11",videodriver,4) == 0)
-			mousegrabok = SDL_FALSE; //X11's XGrabPointer not good
-	}
-#endif
 	realwidth = (Uint16)vid.width;
 	realheight = (Uint16)vid.height;
 
@@ -1915,100 +1710,36 @@ void I_StartupGraphics(void)
 
 void VID_StartupOpenGL(void)
 {
-#ifdef HWRENDER
-	static boolean glstartup = false;
-	if (!glstartup)
-	{
-		CONS_Printf("VID_StartupOpenGL()...\n");
-		*(void**)&HWD.pfnInit             = hwSym("Init",NULL);
-		*(void**)&HWD.pfnFinishUpdate     = NULL;
-		*(void**)&HWD.pfnDraw2DLine       = hwSym("Draw2DLine",NULL);
-		*(void**)&HWD.pfnDrawPolygon      = hwSym("DrawPolygon",NULL);
-		*(void**)&HWD.pfnDrawIndexedTriangles = hwSym("DrawIndexedTriangles",NULL);
-		*(void**)&HWD.pfnRenderSkyDome    = hwSym("RenderSkyDome",NULL);
-		*(void**)&HWD.pfnSetBlend         = hwSym("SetBlend",NULL);
-		*(void**)&HWD.pfnClearBuffer      = hwSym("ClearBuffer",NULL);
-		*(void**)&HWD.pfnSetTexture       = hwSym("SetTexture",NULL);
-		*(void**)&HWD.pfnUpdateTexture    = hwSym("UpdateTexture",NULL);
-		*(void**)&HWD.pfnDeleteTexture    = hwSym("DeleteTexture",NULL);
-		*(void**)&HWD.pfnReadRect         = hwSym("ReadRect",NULL);
-		*(void**)&HWD.pfnGClipRect        = hwSym("GClipRect",NULL);
-		*(void**)&HWD.pfnClearMipMapCache = hwSym("ClearMipMapCache",NULL);
-		*(void**)&HWD.pfnSetSpecialState  = hwSym("SetSpecialState",NULL);
-		*(void**)&HWD.pfnSetPalette       = hwSym("SetPalette",NULL);
-		*(void**)&HWD.pfnGetTextureUsed   = hwSym("GetTextureUsed",NULL);
-		*(void**)&HWD.pfnDrawModel        = hwSym("DrawModel",NULL);
-		*(void**)&HWD.pfnCreateModelVBOs  = hwSym("CreateModelVBOs",NULL);
-		*(void**)&HWD.pfnSetTransform     = hwSym("SetTransform",NULL);
-		*(void**)&HWD.pfnPostImgRedraw    = hwSym("PostImgRedraw",NULL);
-		*(void**)&HWD.pfnFlushScreenTextures=hwSym("FlushScreenTextures",NULL);
-		*(void**)&HWD.pfnStartScreenWipe  = hwSym("StartScreenWipe",NULL);
-		*(void**)&HWD.pfnEndScreenWipe    = hwSym("EndScreenWipe",NULL);
-		*(void**)&HWD.pfnDoScreenWipe     = hwSym("DoScreenWipe",NULL);
-		*(void**)&HWD.pfnDrawIntermissionBG=hwSym("DrawIntermissionBG",NULL);
-		*(void**)&HWD.pfnMakeScreenTexture= hwSym("MakeScreenTexture",NULL);
-		*(void**)&HWD.pfnMakeScreenFinalTexture=hwSym("MakeScreenFinalTexture",NULL);
-		*(void**)&HWD.pfnDrawScreenFinalTexture=hwSym("DrawScreenFinalTexture",NULL);
-
-		*(void**)&HWD.pfnCompileShaders   = hwSym("CompileShaders",NULL);
-		*(void**)&HWD.pfnCleanShaders     = hwSym("CleanShaders",NULL);
-		*(void**)&HWD.pfnSetShader        = hwSym("SetShader",NULL);
-		*(void**)&HWD.pfnUnSetShader      = hwSym("UnSetShader",NULL);
-
-		*(void**)&HWD.pfnSetShaderInfo    = hwSym("SetShaderInfo",NULL);
-		*(void**)&HWD.pfnLoadCustomShader = hwSym("LoadCustomShader",NULL);
-
-		vid.glstate = HWD.pfnInit() ? VID_GL_LIBRARY_LOADED : VID_GL_LIBRARY_ERROR; // let load the OpenGL library
-
-		if (vid.glstate == VID_GL_LIBRARY_ERROR)
-		{
-			rendermode = render_soft;
-			setrenderneeded = 0;
-		}
-		glstartup = true;
-	}
-#endif
+	CONS_Alert(CONS_WARNING, "VID_StartupOpenGL called (no longer going to use)");
+	rendermode = render_soft;
+	setrenderneeded = 0;
 }
 
 void I_ShutdownGraphics(void)
 {
-	const rendermode_t oldrendermode = rendermode;
-
 	rendermode = render_none;
 	if (icoSurface) SDL_FreeSurface(icoSurface);
 	icoSurface = NULL;
-	if (oldrendermode == render_soft)
-	{
-		if (vidSurface) SDL_FreeSurface(vidSurface);
-		vidSurface = NULL;
-		if (vid.buffer) free(vid.buffer);
-		vid.buffer = NULL;
-		if (bufSurface) SDL_FreeSurface(bufSurface);
-		bufSurface = NULL;
-	}
 
 	I_OutputMsg("I_ShutdownGraphics(): ");
 
 	// was graphics initialized anyway?
 	if (!graphics_started)
 	{
-		I_OutputMsg("graphics never started\n");
 		return;
 	}
 	graphics_started = false;
-	I_OutputMsg("shut down\n");
 
-#ifdef HWRENDER
-	if (GLUhandle)
-		hwClose(GLUhandle);
-	if (sdlglcontext)
-	{
-		SDL_GL_DeleteContext(sdlglcontext);
-	}
-#endif
 	SDL_QuitSubSystem(SDL_INIT_VIDEO);
 	framebuffer = SDL_FALSE;
 }
+
+rhi::Rhi* srb2::sys::get_rhi(rhi::Handle<rhi::Rhi> handle)
+{
+	// TODO actually use handle...
+	return g_rhi.get();
+}
+
 #endif
 
 UINT32 I_GetRefreshRate(void)
diff --git a/src/sdl/new_sound.cpp b/src/sdl/new_sound.cpp
index 1a2d25b1c..5a3dc824d 100644
--- a/src/sdl/new_sound.cpp
+++ b/src/sdl/new_sound.cpp
@@ -359,7 +359,8 @@ void I_InitMusic(void)
 
 	SdlAudioLockHandle _;
 
-	*music_player = audio::MusicPlayer();
+	if (music_player != nullptr)
+		*music_player = audio::MusicPlayer();
 }
 
 void I_ShutdownMusic(void)
diff --git a/src/sdl/ogl_sdl.h b/src/sdl/ogl_sdl.h
index 00697074a..8b60b6242 100644
--- a/src/sdl/ogl_sdl.h
+++ b/src/sdl/ogl_sdl.h
@@ -32,7 +32,6 @@ boolean OglSdlSurface(INT32 w, INT32 h);
 
 void OglSdlFinishUpdate(boolean vidwait);
 
-extern SDL_Renderer *renderer;
 extern SDL_GLContext sdlglcontext;
 extern Uint16      realwidth;
 extern Uint16      realheight;
diff --git a/src/sdl/rhi_gl3_core_platform.cpp b/src/sdl/rhi_gl3_core_platform.cpp
new file mode 100644
index 000000000..e6971873d
--- /dev/null
+++ b/src/sdl/rhi_gl3_core_platform.cpp
@@ -0,0 +1,56 @@
+#include "rhi_gl3_core_platform.hpp"
+
+#include <SDL.h>
+
+#include "../cxxutil.hpp"
+#include "../w_wad.h"
+#include "../z_zone.h"
+
+using namespace srb2;
+using namespace srb2::rhi;
+
+SdlGlCorePlatform::~SdlGlCorePlatform() = default;
+
+void SdlGlCorePlatform::present() {
+	SRB2_ASSERT(window != nullptr);
+	SRB2_ASSERT(SDL_GetWindowID(window) != 0);
+
+	SDL_GL_SwapWindow(window);
+}
+
+std::tuple<std::string, std::string> SdlGlCorePlatform::find_shader_sources(rhi::PipelineProgram program) {
+	const char* vertex_lump_name = nullptr;
+	const char* fragment_lump_name = nullptr;
+	switch (program) {
+	case rhi::PipelineProgram::kUnshaded:
+		vertex_lump_name = "rhi_glcore_vertex_unshaded";
+		fragment_lump_name = "rhi_glcore_fragment_unshaded";
+		break;
+	case rhi::PipelineProgram::kUnshadedPaletted:
+		vertex_lump_name = "rhi_glcore_vertex_unshadedpaletted";
+		fragment_lump_name = "rhi_glcore_fragment_unshadedpaletted";
+		break;
+	default:
+		std::terminate();
+	}
+
+	lumpnum_t vertex_lump_num = W_GetNumForLongName(vertex_lump_name);
+	lumpnum_t fragment_lump_num = W_GetNumForLongName(fragment_lump_name);
+	size_t vertex_lump_length = W_LumpLength(vertex_lump_num);
+	size_t fragment_lump_length = W_LumpLength(fragment_lump_num);
+	void* vertex_lump = W_CacheLumpNum(vertex_lump_num, PU_CACHE);
+	void* fragment_lump = W_CacheLumpNum(fragment_lump_num, PU_CACHE);
+
+	std::string vertex_shader(static_cast<const char*>(vertex_lump), vertex_lump_length);
+	std::string fragment_shader(static_cast<const char*>(fragment_lump), fragment_lump_length);
+
+	return std::make_tuple(std::move(vertex_shader), std::move(fragment_shader));
+}
+
+rhi::Rect SdlGlCorePlatform::get_default_framebuffer_dimensions() {
+	SRB2_ASSERT(window != nullptr);
+	int w;
+	int h;
+	SDL_GL_GetDrawableSize(window, &w, &h);
+	return {0, 0, static_cast<uint32_t>(w), static_cast<uint32_t>(h)};
+}
diff --git a/src/sdl/rhi_gl3_core_platform.hpp b/src/sdl/rhi_gl3_core_platform.hpp
new file mode 100644
index 000000000..0683a428b
--- /dev/null
+++ b/src/sdl/rhi_gl3_core_platform.hpp
@@ -0,0 +1,23 @@
+#ifndef __SRB2_SDL_RHI_GLES2_PLATFORM_HPP__
+#define __SRB2_SDL_RHI_GLES2_PLATFORM_HPP__
+
+#include "../rhi/rhi.hpp"
+#include "../rhi/gl3_core/gl3_core_rhi.hpp"
+
+#include <SDL.h>
+
+namespace srb2::rhi {
+
+struct SdlGlCorePlatform final : public GlCorePlatform {
+	SDL_Window* window = nullptr;
+
+	virtual ~SdlGlCorePlatform();
+
+	virtual void present() override;
+	virtual std::tuple<std::string, std::string> find_shader_sources(PipelineProgram program) override;
+	virtual Rect get_default_framebuffer_dimensions() override;
+};
+
+} // namespace srb2::rhi
+
+#endif // __SRB2_SDL_RHI_GLES2_PLATFORM_HPP__
diff --git a/src/sdl/rhi_gles2_platform.cpp b/src/sdl/rhi_gles2_platform.cpp
new file mode 100644
index 000000000..d9d8546e5
--- /dev/null
+++ b/src/sdl/rhi_gles2_platform.cpp
@@ -0,0 +1,56 @@
+#include "rhi_gles2_platform.hpp"
+
+#include <SDL.h>
+
+#include "../cxxutil.hpp"
+#include "../w_wad.h"
+#include "../z_zone.h"
+
+using namespace srb2;
+using namespace srb2::rhi;
+
+SdlGles2Platform::~SdlGles2Platform() = default;
+
+void SdlGles2Platform::present() {
+	SRB2_ASSERT(window != nullptr);
+	SRB2_ASSERT(SDL_GetWindowID(window) != 0);
+
+	SDL_GL_SwapWindow(window);
+}
+
+std::tuple<std::string, std::string> SdlGles2Platform::find_shader_sources(rhi::PipelineProgram program) {
+	const char* vertex_lump_name = nullptr;
+	const char* fragment_lump_name = nullptr;
+	switch (program) {
+	case rhi::PipelineProgram::kUnshaded:
+		vertex_lump_name = "rhi_glsles_vertex_unshaded";
+		fragment_lump_name = "rhi_glsles_fragment_unshaded";
+		break;
+	case rhi::PipelineProgram::kUnshadedPaletted:
+		vertex_lump_name = "rhi_glsles_vertex_unshadedpaletted";
+		fragment_lump_name = "rhi_glsles_fragment_unshadedpaletted";
+		break;
+	default:
+		std::terminate();
+	}
+
+	lumpnum_t vertex_lump_num = W_GetNumForLongName(vertex_lump_name);
+	lumpnum_t fragment_lump_num = W_GetNumForLongName(fragment_lump_name);
+	size_t vertex_lump_length = W_LumpLength(vertex_lump_num);
+	size_t fragment_lump_length = W_LumpLength(fragment_lump_num);
+	void* vertex_lump = W_CacheLumpNum(vertex_lump_num, PU_CACHE);
+	void* fragment_lump = W_CacheLumpNum(fragment_lump_num, PU_CACHE);
+
+	std::string vertex_shader(static_cast<const char*>(vertex_lump), vertex_lump_length);
+	std::string fragment_shader(static_cast<const char*>(fragment_lump), fragment_lump_length);
+
+	return std::make_tuple(std::move(vertex_shader), std::move(fragment_shader));
+}
+
+rhi::Rect SdlGles2Platform::get_default_framebuffer_dimensions() {
+	SRB2_ASSERT(window != nullptr);
+	int w;
+	int h;
+	SDL_GL_GetDrawableSize(window, &w, &h);
+	return {0, 0, static_cast<uint32_t>(w), static_cast<uint32_t>(h)};
+}
diff --git a/src/sdl/rhi_gles2_platform.hpp b/src/sdl/rhi_gles2_platform.hpp
new file mode 100644
index 000000000..0476931d0
--- /dev/null
+++ b/src/sdl/rhi_gles2_platform.hpp
@@ -0,0 +1,23 @@
+#ifndef __SRB2_SDL_RHI_GLES2_PLATFORM_HPP__
+#define __SRB2_SDL_RHI_GLES2_PLATFORM_HPP__
+
+#include "../rhi/rhi.hpp"
+#include "../rhi/gles2/gles2_rhi.hpp"
+
+#include <SDL.h>
+
+namespace srb2::rhi {
+
+struct SdlGles2Platform final : public Gles2Platform {
+	SDL_Window* window = nullptr;
+
+	virtual ~SdlGles2Platform();
+
+	virtual void present() override;
+	virtual std::tuple<std::string, std::string> find_shader_sources(PipelineProgram program) override;
+	virtual Rect get_default_framebuffer_dimensions() override;
+};
+
+} // namespace srb2::rhi
+
+#endif // __SRB2_SDL_RHI_GLES2_PLATFORM_HPP__
diff --git a/thirdparty/CMakeLists.txt b/thirdparty/CMakeLists.txt
index 86a090b07..cb6c7bc4e 100644
--- a/thirdparty/CMakeLists.txt
+++ b/thirdparty/CMakeLists.txt
@@ -20,6 +20,9 @@ endif()
 include("cpm-rapidjson.cmake")
 include("cpm-discordrpc.cmake")
 include("cpm-xmp-lite.cmake")
+include("cpm-fmt.cmake")
+include("cpm-imgui.cmake")
 
 add_subdirectory(tcbrindle_span)
 add_subdirectory(stb_vorbis)
+add_subdirectory(glad)
diff --git a/thirdparty/cpm-fmt.cmake b/thirdparty/cpm-fmt.cmake
new file mode 100644
index 000000000..888d105b5
--- /dev/null
+++ b/thirdparty/cpm-fmt.cmake
@@ -0,0 +1,6 @@
+CPMAddPackage(
+	NAME fmt
+	VERSION 9.1.0
+	URL "https://github.com/fmtlib/fmt/releases/download/9.1.0/fmt-9.1.0.zip"
+	EXCLUDE_FROM_ALL ON
+)
diff --git a/thirdparty/cpm-imgui.cmake b/thirdparty/cpm-imgui.cmake
new file mode 100644
index 000000000..d4cffc7d3
--- /dev/null
+++ b/thirdparty/cpm-imgui.cmake
@@ -0,0 +1,34 @@
+CPMAddPackage(
+	NAME imgui
+	VERSION 1.89.2
+	URL "https://github.com/ocornut/imgui/archive/refs/tags/v1.89.2.zip"
+	EXCLUDE_FROM_ALL ON
+)
+if(imgui_ADDED)
+	set(imgui_SOURCES
+		imgui.cpp
+		imgui.h
+		imgui_demo.cpp
+		imgui_draw.cpp
+		imgui_internal.h
+		imgui_tables.cpp
+		imgui_widgets.cpp
+		imstb_rectpack.h
+		imstb_textedit.h
+		imstb_truetype.h
+	)
+	list(TRANSFORM imgui_SOURCES PREPEND "${imgui_SOURCE_DIR}/")
+
+	add_custom_command(
+		OUTPUT "${imgui_BINARY_DIR}/include/imgui.h" "${imgui_BINARY_DIR}/include/imconfig.h"
+		COMMAND ${CMAKE_COMMAND} -E copy "${imgui_SOURCE_DIR}/imgui.h" "${imgui_SOURCE_DIR}/imconfig.h" "${imgui_BINARY_DIR}/include"
+		DEPENDS "${imgui_SOURCE_DIR}/imgui.h" "${imgui_SOURCE_DIR}/imconfig.h"
+		VERBATIM
+	)
+	list(APPEND imgui_SOURCES "${imgui_BINARY_DIR}/include/imgui.h" "${imgui_BINARY_DIR}/include/imconfig.h" "${CMAKE_CURRENT_SOURCE_DIR}/imgui_config/srb2_imconfig.h")
+	add_library(imgui STATIC ${imgui_SOURCES})
+	target_include_directories(imgui PUBLIC "${imgui_BINARY_DIR}/include" "${CMAKE_CURRENT_SOURCE_DIR}/imgui_config")
+	target_compile_definitions(imgui PUBLIC IMGUI_USER_CONFIG="srb2_imconfig.h")
+	target_compile_features(imgui PUBLIC cxx_std_11)
+	add_library(imgui::imgui ALIAS imgui)
+endif()
diff --git a/thirdparty/glad/CMakeLists.txt b/thirdparty/glad/CMakeLists.txt
new file mode 100644
index 000000000..7100a98cb
--- /dev/null
+++ b/thirdparty/glad/CMakeLists.txt
@@ -0,0 +1,3 @@
+add_library(glad STATIC src/gles2.c src/gl.c include/glad/gles2.h include/glad/gl.h include/KHR/khrplatform.h)
+add_library(glad::glad ALIAS glad)
+target_include_directories(glad PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/include")
diff --git a/thirdparty/glad/include/KHR/khrplatform.h b/thirdparty/glad/include/KHR/khrplatform.h
new file mode 100644
index 000000000..01646449c
--- /dev/null
+++ b/thirdparty/glad/include/KHR/khrplatform.h
@@ -0,0 +1,311 @@
+#ifndef __khrplatform_h_
+#define __khrplatform_h_
+
+/*
+** Copyright (c) 2008-2018 The Khronos Group Inc.
+**
+** Permission is hereby granted, free of charge, to any person obtaining a
+** copy of this software and/or associated documentation files (the
+** "Materials"), to deal in the Materials without restriction, including
+** without limitation the rights to use, copy, modify, merge, publish,
+** distribute, sublicense, and/or sell copies of the Materials, and to
+** permit persons to whom the Materials are furnished to do so, subject to
+** the following conditions:
+**
+** The above copyright notice and this permission notice shall be included
+** in all copies or substantial portions of the Materials.
+**
+** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
+*/
+
+/* Khronos platform-specific types and definitions.
+ *
+ * The master copy of khrplatform.h is maintained in the Khronos EGL
+ * Registry repository at https://github.com/KhronosGroup/EGL-Registry
+ * The last semantic modification to khrplatform.h was at commit ID:
+ *      67a3e0864c2d75ea5287b9f3d2eb74a745936692
+ *
+ * Adopters may modify this file to suit their platform. Adopters are
+ * encouraged to submit platform specific modifications to the Khronos
+ * group so that they can be included in future versions of this file.
+ * Please submit changes by filing pull requests or issues on
+ * the EGL Registry repository linked above.
+ *
+ *
+ * See the Implementer's Guidelines for information about where this file
+ * should be located on your system and for more details of its use:
+ *    http://www.khronos.org/registry/implementers_guide.pdf
+ *
+ * This file should be included as
+ *        #include <KHR/khrplatform.h>
+ * by Khronos client API header files that use its types and defines.
+ *
+ * The types in khrplatform.h should only be used to define API-specific types.
+ *
+ * Types defined in khrplatform.h:
+ *    khronos_int8_t              signed   8  bit
+ *    khronos_uint8_t             unsigned 8  bit
+ *    khronos_int16_t             signed   16 bit
+ *    khronos_uint16_t            unsigned 16 bit
+ *    khronos_int32_t             signed   32 bit
+ *    khronos_uint32_t            unsigned 32 bit
+ *    khronos_int64_t             signed   64 bit
+ *    khronos_uint64_t            unsigned 64 bit
+ *    khronos_intptr_t            signed   same number of bits as a pointer
+ *    khronos_uintptr_t           unsigned same number of bits as a pointer
+ *    khronos_ssize_t             signed   size
+ *    khronos_usize_t             unsigned size
+ *    khronos_float_t             signed   32 bit floating point
+ *    khronos_time_ns_t           unsigned 64 bit time in nanoseconds
+ *    khronos_utime_nanoseconds_t unsigned time interval or absolute time in
+ *                                         nanoseconds
+ *    khronos_stime_nanoseconds_t signed time interval in nanoseconds
+ *    khronos_boolean_enum_t      enumerated boolean type. This should
+ *      only be used as a base type when a client API's boolean type is
+ *      an enum. Client APIs which use an integer or other type for
+ *      booleans cannot use this as the base type for their boolean.
+ *
+ * Tokens defined in khrplatform.h:
+ *
+ *    KHRONOS_FALSE, KHRONOS_TRUE Enumerated boolean false/true values.
+ *
+ *    KHRONOS_SUPPORT_INT64 is 1 if 64 bit integers are supported; otherwise 0.
+ *    KHRONOS_SUPPORT_FLOAT is 1 if floats are supported; otherwise 0.
+ *
+ * Calling convention macros defined in this file:
+ *    KHRONOS_APICALL
+ *    KHRONOS_APIENTRY
+ *    KHRONOS_APIATTRIBUTES
+ *
+ * These may be used in function prototypes as:
+ *
+ *      KHRONOS_APICALL void KHRONOS_APIENTRY funcname(
+ *                                  int arg1,
+ *                                  int arg2) KHRONOS_APIATTRIBUTES;
+ */
+
+#if defined(__SCITECH_SNAP__) && !defined(KHRONOS_STATIC)
+#   define KHRONOS_STATIC 1
+#endif
+
+/*-------------------------------------------------------------------------
+ * Definition of KHRONOS_APICALL
+ *-------------------------------------------------------------------------
+ * This precedes the return type of the function in the function prototype.
+ */
+#if defined(KHRONOS_STATIC)
+    /* If the preprocessor constant KHRONOS_STATIC is defined, make the
+     * header compatible with static linking. */
+#   define KHRONOS_APICALL
+#elif defined(_WIN32)
+#   define KHRONOS_APICALL __declspec(dllimport)
+#elif defined (__SYMBIAN32__)
+#   define KHRONOS_APICALL IMPORT_C
+#elif defined(__ANDROID__)
+#   define KHRONOS_APICALL __attribute__((visibility("default")))
+#else
+#   define KHRONOS_APICALL
+#endif
+
+/*-------------------------------------------------------------------------
+ * Definition of KHRONOS_APIENTRY
+ *-------------------------------------------------------------------------
+ * This follows the return type of the function  and precedes the function
+ * name in the function prototype.
+ */
+#if defined(_WIN32) && !defined(_WIN32_WCE) && !defined(__SCITECH_SNAP__)
+    /* Win32 but not WinCE */
+#   define KHRONOS_APIENTRY __stdcall
+#else
+#   define KHRONOS_APIENTRY
+#endif
+
+/*-------------------------------------------------------------------------
+ * Definition of KHRONOS_APIATTRIBUTES
+ *-------------------------------------------------------------------------
+ * This follows the closing parenthesis of the function prototype arguments.
+ */
+#if defined (__ARMCC_2__)
+#define KHRONOS_APIATTRIBUTES __softfp
+#else
+#define KHRONOS_APIATTRIBUTES
+#endif
+
+/*-------------------------------------------------------------------------
+ * basic type definitions
+ *-----------------------------------------------------------------------*/
+#if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) || defined(__GNUC__) || defined(__SCO__) || defined(__USLC__)
+
+
+/*
+ * Using <stdint.h>
+ */
+#include <stdint.h>
+typedef int32_t                 khronos_int32_t;
+typedef uint32_t                khronos_uint32_t;
+typedef int64_t                 khronos_int64_t;
+typedef uint64_t                khronos_uint64_t;
+#define KHRONOS_SUPPORT_INT64   1
+#define KHRONOS_SUPPORT_FLOAT   1
+/*
+ * To support platform where unsigned long cannot be used interchangeably with
+ * inptr_t (e.g. CHERI-extended ISAs), we can use the stdint.h intptr_t.
+ * Ideally, we could just use (u)intptr_t everywhere, but this could result in
+ * ABI breakage if khronos_uintptr_t is changed from unsigned long to
+ * unsigned long long or similar (this results in different C++ name mangling).
+ * To avoid changes for existing platforms, we restrict usage of intptr_t to
+ * platforms where the size of a pointer is larger than the size of long.
+ */
+#if defined(__SIZEOF_LONG__) && defined(__SIZEOF_POINTER__)
+#if __SIZEOF_POINTER__ > __SIZEOF_LONG__
+#define KHRONOS_USE_INTPTR_T
+#endif
+#endif
+
+#elif defined(__VMS ) || defined(__sgi)
+
+/*
+ * Using <inttypes.h>
+ */
+#include <inttypes.h>
+typedef int32_t                 khronos_int32_t;
+typedef uint32_t                khronos_uint32_t;
+typedef int64_t                 khronos_int64_t;
+typedef uint64_t                khronos_uint64_t;
+#define KHRONOS_SUPPORT_INT64   1
+#define KHRONOS_SUPPORT_FLOAT   1
+
+#elif defined(_WIN32) && !defined(__SCITECH_SNAP__)
+
+/*
+ * Win32
+ */
+typedef __int32                 khronos_int32_t;
+typedef unsigned __int32        khronos_uint32_t;
+typedef __int64                 khronos_int64_t;
+typedef unsigned __int64        khronos_uint64_t;
+#define KHRONOS_SUPPORT_INT64   1
+#define KHRONOS_SUPPORT_FLOAT   1
+
+#elif defined(__sun__) || defined(__digital__)
+
+/*
+ * Sun or Digital
+ */
+typedef int                     khronos_int32_t;
+typedef unsigned int            khronos_uint32_t;
+#if defined(__arch64__) || defined(_LP64)
+typedef long int                khronos_int64_t;
+typedef unsigned long int       khronos_uint64_t;
+#else
+typedef long long int           khronos_int64_t;
+typedef unsigned long long int  khronos_uint64_t;
+#endif /* __arch64__ */
+#define KHRONOS_SUPPORT_INT64   1
+#define KHRONOS_SUPPORT_FLOAT   1
+
+#elif 0
+
+/*
+ * Hypothetical platform with no float or int64 support
+ */
+typedef int                     khronos_int32_t;
+typedef unsigned int            khronos_uint32_t;
+#define KHRONOS_SUPPORT_INT64   0
+#define KHRONOS_SUPPORT_FLOAT   0
+
+#else
+
+/*
+ * Generic fallback
+ */
+#include <stdint.h>
+typedef int32_t                 khronos_int32_t;
+typedef uint32_t                khronos_uint32_t;
+typedef int64_t                 khronos_int64_t;
+typedef uint64_t                khronos_uint64_t;
+#define KHRONOS_SUPPORT_INT64   1
+#define KHRONOS_SUPPORT_FLOAT   1
+
+#endif
+
+
+/*
+ * Types that are (so far) the same on all platforms
+ */
+typedef signed   char          khronos_int8_t;
+typedef unsigned char          khronos_uint8_t;
+typedef signed   short int     khronos_int16_t;
+typedef unsigned short int     khronos_uint16_t;
+
+/*
+ * Types that differ between LLP64 and LP64 architectures - in LLP64,
+ * pointers are 64 bits, but 'long' is still 32 bits. Win64 appears
+ * to be the only LLP64 architecture in current use.
+ */
+#ifdef KHRONOS_USE_INTPTR_T
+typedef intptr_t               khronos_intptr_t;
+typedef uintptr_t              khronos_uintptr_t;
+#elif defined(_WIN64)
+typedef signed   long long int khronos_intptr_t;
+typedef unsigned long long int khronos_uintptr_t;
+#else
+typedef signed   long  int     khronos_intptr_t;
+typedef unsigned long  int     khronos_uintptr_t;
+#endif
+
+#if defined(_WIN64)
+typedef signed   long long int khronos_ssize_t;
+typedef unsigned long long int khronos_usize_t;
+#else
+typedef signed   long  int     khronos_ssize_t;
+typedef unsigned long  int     khronos_usize_t;
+#endif
+
+#if KHRONOS_SUPPORT_FLOAT
+/*
+ * Float type
+ */
+typedef          float         khronos_float_t;
+#endif
+
+#if KHRONOS_SUPPORT_INT64
+/* Time types
+ *
+ * These types can be used to represent a time interval in nanoseconds or
+ * an absolute Unadjusted System Time.  Unadjusted System Time is the number
+ * of nanoseconds since some arbitrary system event (e.g. since the last
+ * time the system booted).  The Unadjusted System Time is an unsigned
+ * 64 bit value that wraps back to 0 every 584 years.  Time intervals
+ * may be either signed or unsigned.
+ */
+typedef khronos_uint64_t       khronos_utime_nanoseconds_t;
+typedef khronos_int64_t        khronos_stime_nanoseconds_t;
+#endif
+
+/*
+ * Dummy value used to pad enum types to 32 bits.
+ */
+#ifndef KHRONOS_MAX_ENUM
+#define KHRONOS_MAX_ENUM 0x7FFFFFFF
+#endif
+
+/*
+ * Enumerated boolean type
+ *
+ * Values other than zero should be considered to be true.  Therefore
+ * comparisons should not be made against KHRONOS_TRUE.
+ */
+typedef enum {
+    KHRONOS_FALSE = 0,
+    KHRONOS_TRUE  = 1,
+    KHRONOS_BOOLEAN_ENUM_FORCE_SIZE = KHRONOS_MAX_ENUM
+} khronos_boolean_enum_t;
+
+#endif /* __khrplatform_h_ */
diff --git a/thirdparty/glad/include/glad/gl.h b/thirdparty/glad/include/glad/gl.h
new file mode 100644
index 000000000..4f1348196
--- /dev/null
+++ b/thirdparty/glad/include/glad/gl.h
@@ -0,0 +1,3795 @@
+/**
+ * Loader generated by glad 2.0.2 on Sun Jan  8 22:32:41 2023
+ *
+ * SPDX-License-Identifier: (WTFPL OR CC0-1.0) AND Apache-2.0
+ *
+ * Generator: C/C++
+ * Specification: gl
+ * Extensions: 62
+ *
+ * APIs:
+ *  - gl:core=3.2
+ *
+ * Options:
+ *  - ALIAS = True
+ *  - DEBUG = False
+ *  - HEADER_ONLY = False
+ *  - LOADER = False
+ *  - MX = True
+ *  - ON_DEMAND = False
+ *
+ * Commandline:
+ *    --api='gl:core=3.2' --extensions='GL_APPLE_flush_buffer_range,GL_APPLE_vertex_array_object,GL_ARB_color_buffer_float,GL_ARB_copy_buffer,GL_ARB_draw_buffers,GL_ARB_draw_elements_base_vertex,GL_ARB_draw_instanced,GL_ARB_framebuffer_object,GL_ARB_geometry_shader4,GL_ARB_imaging,GL_ARB_map_buffer_range,GL_ARB_multisample,GL_ARB_multitexture,GL_ARB_occlusion_query,GL_ARB_point_parameters,GL_ARB_provoking_vertex,GL_ARB_shader_objects,GL_ARB_sync,GL_ARB_texture_buffer_object,GL_ARB_texture_compression,GL_ARB_texture_multisample,GL_ARB_uniform_buffer_object,GL_ARB_vertex_array_object,GL_ARB_vertex_buffer_object,GL_ARB_vertex_program,GL_ARB_vertex_shader,GL_ATI_draw_buffers,GL_ATI_separate_stencil,GL_EXT_blend_color,GL_EXT_blend_equation_separate,GL_EXT_blend_func_separate,GL_EXT_blend_minmax,GL_EXT_copy_texture,GL_EXT_direct_state_access,GL_EXT_draw_buffers2,GL_EXT_draw_instanced,GL_EXT_draw_range_elements,GL_EXT_framebuffer_blit,GL_EXT_framebuffer_multisample,GL_EXT_framebuffer_object,GL_EXT_gpu_shader4,GL_EXT_multi_draw_arrays,GL_EXT_point_parameters,GL_EXT_provoking_vertex,GL_EXT_subtexture,GL_EXT_texture3D,GL_EXT_texture_array,GL_EXT_texture_buffer_object,GL_EXT_texture_integer,GL_EXT_texture_object,GL_EXT_transform_feedback,GL_EXT_vertex_array,GL_INGR_blend_func_separate,GL_NVX_conditional_render,GL_NV_conditional_render,GL_NV_explicit_multisample,GL_NV_geometry_program4,GL_NV_point_sprite,GL_NV_transform_feedback,GL_NV_vertex_program,GL_NV_vertex_program4,GL_SGIS_point_parameters' c --alias --mx
+ *
+ * Online:
+ *    http://glad.sh/#api=gl%3Acore%3D3.2&extensions=GL_APPLE_flush_buffer_range%2CGL_APPLE_vertex_array_object%2CGL_ARB_color_buffer_float%2CGL_ARB_copy_buffer%2CGL_ARB_draw_buffers%2CGL_ARB_draw_elements_base_vertex%2CGL_ARB_draw_instanced%2CGL_ARB_framebuffer_object%2CGL_ARB_geometry_shader4%2CGL_ARB_imaging%2CGL_ARB_map_buffer_range%2CGL_ARB_multisample%2CGL_ARB_multitexture%2CGL_ARB_occlusion_query%2CGL_ARB_point_parameters%2CGL_ARB_provoking_vertex%2CGL_ARB_shader_objects%2CGL_ARB_sync%2CGL_ARB_texture_buffer_object%2CGL_ARB_texture_compression%2CGL_ARB_texture_multisample%2CGL_ARB_uniform_buffer_object%2CGL_ARB_vertex_array_object%2CGL_ARB_vertex_buffer_object%2CGL_ARB_vertex_program%2CGL_ARB_vertex_shader%2CGL_ATI_draw_buffers%2CGL_ATI_separate_stencil%2CGL_EXT_blend_color%2CGL_EXT_blend_equation_separate%2CGL_EXT_blend_func_separate%2CGL_EXT_blend_minmax%2CGL_EXT_copy_texture%2CGL_EXT_direct_state_access%2CGL_EXT_draw_buffers2%2CGL_EXT_draw_instanced%2CGL_EXT_draw_range_elements%2CGL_EXT_framebuffer_blit%2CGL_EXT_framebuffer_multisample%2CGL_EXT_framebuffer_object%2CGL_EXT_gpu_shader4%2CGL_EXT_multi_draw_arrays%2CGL_EXT_point_parameters%2CGL_EXT_provoking_vertex%2CGL_EXT_subtexture%2CGL_EXT_texture3D%2CGL_EXT_texture_array%2CGL_EXT_texture_buffer_object%2CGL_EXT_texture_integer%2CGL_EXT_texture_object%2CGL_EXT_transform_feedback%2CGL_EXT_vertex_array%2CGL_INGR_blend_func_separate%2CGL_NVX_conditional_render%2CGL_NV_conditional_render%2CGL_NV_explicit_multisample%2CGL_NV_geometry_program4%2CGL_NV_point_sprite%2CGL_NV_transform_feedback%2CGL_NV_vertex_program%2CGL_NV_vertex_program4%2CGL_SGIS_point_parameters&generator=c&options=ALIAS%2CMX
+ *
+ */
+
+#ifndef GLAD_GL_H_
+#define GLAD_GL_H_
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wreserved-id-macro"
+#endif
+#ifdef __gl_h_
+  #error OpenGL (gl.h) header already included (API: gl), remove previous include!
+#endif
+#define __gl_h_ 1
+#ifdef __gl3_h_
+  #error OpenGL (gl3.h) header already included (API: gl), remove previous include!
+#endif
+#define __gl3_h_ 1
+#ifdef __glext_h_
+  #error OpenGL (glext.h) header already included (API: gl), remove previous include!
+#endif
+#define __glext_h_ 1
+#ifdef __gl3ext_h_
+  #error OpenGL (gl3ext.h) header already included (API: gl), remove previous include!
+#endif
+#define __gl3ext_h_ 1
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+#define GLAD_GL
+#define GLAD_OPTION_GL_ALIAS
+#define GLAD_OPTION_GL_MX
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef GLAD_PLATFORM_H_
+#define GLAD_PLATFORM_H_
+
+#ifndef GLAD_PLATFORM_WIN32
+  #if defined(_WIN32) || defined(__WIN32__) || defined(WIN32) || defined(__MINGW32__)
+    #define GLAD_PLATFORM_WIN32 1
+  #else
+    #define GLAD_PLATFORM_WIN32 0
+  #endif
+#endif
+
+#ifndef GLAD_PLATFORM_APPLE
+  #ifdef __APPLE__
+    #define GLAD_PLATFORM_APPLE 1
+  #else
+    #define GLAD_PLATFORM_APPLE 0
+  #endif
+#endif
+
+#ifndef GLAD_PLATFORM_EMSCRIPTEN
+  #ifdef __EMSCRIPTEN__
+    #define GLAD_PLATFORM_EMSCRIPTEN 1
+  #else
+    #define GLAD_PLATFORM_EMSCRIPTEN 0
+  #endif
+#endif
+
+#ifndef GLAD_PLATFORM_UWP
+  #if defined(_MSC_VER) && !defined(GLAD_INTERNAL_HAVE_WINAPIFAMILY)
+    #ifdef __has_include
+      #if __has_include(<winapifamily.h>)
+        #define GLAD_INTERNAL_HAVE_WINAPIFAMILY 1
+      #endif
+    #elif _MSC_VER >= 1700 && !_USING_V110_SDK71_
+      #define GLAD_INTERNAL_HAVE_WINAPIFAMILY 1
+    #endif
+  #endif
+
+  #ifdef GLAD_INTERNAL_HAVE_WINAPIFAMILY
+    #include <winapifamily.h>
+    #if !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) && WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP)
+      #define GLAD_PLATFORM_UWP 1
+    #endif
+  #endif
+
+  #ifndef GLAD_PLATFORM_UWP
+    #define GLAD_PLATFORM_UWP 0
+  #endif
+#endif
+
+#ifdef __GNUC__
+  #define GLAD_GNUC_EXTENSION __extension__
+#else
+  #define GLAD_GNUC_EXTENSION
+#endif
+
+#define GLAD_UNUSED(x) (void)(x)
+
+#ifndef GLAD_API_CALL
+  #if defined(GLAD_API_CALL_EXPORT)
+    #if GLAD_PLATFORM_WIN32 || defined(__CYGWIN__)
+      #if defined(GLAD_API_CALL_EXPORT_BUILD)
+        #if defined(__GNUC__)
+          #define GLAD_API_CALL __attribute__ ((dllexport)) extern
+        #else
+          #define GLAD_API_CALL __declspec(dllexport) extern
+        #endif
+      #else
+        #if defined(__GNUC__)
+          #define GLAD_API_CALL __attribute__ ((dllimport)) extern
+        #else
+          #define GLAD_API_CALL __declspec(dllimport) extern
+        #endif
+      #endif
+    #elif defined(__GNUC__) && defined(GLAD_API_CALL_EXPORT_BUILD)
+      #define GLAD_API_CALL __attribute__ ((visibility ("default"))) extern
+    #else
+      #define GLAD_API_CALL extern
+    #endif
+  #else
+    #define GLAD_API_CALL extern
+  #endif
+#endif
+
+#ifdef APIENTRY
+  #define GLAD_API_PTR APIENTRY
+#elif GLAD_PLATFORM_WIN32
+  #define GLAD_API_PTR __stdcall
+#else
+  #define GLAD_API_PTR
+#endif
+
+#ifndef GLAPI
+#define GLAPI GLAD_API_CALL
+#endif
+
+#ifndef GLAPIENTRY
+#define GLAPIENTRY GLAD_API_PTR
+#endif
+
+#define GLAD_MAKE_VERSION(major, minor) (major * 10000 + minor)
+#define GLAD_VERSION_MAJOR(version) (version / 10000)
+#define GLAD_VERSION_MINOR(version) (version % 10000)
+
+#define GLAD_GENERATOR_VERSION "2.0.2"
+
+typedef void (*GLADapiproc)(void);
+
+typedef GLADapiproc (*GLADloadfunc)(const char *name);
+typedef GLADapiproc (*GLADuserptrloadfunc)(void *userptr, const char *name);
+
+typedef void (*GLADprecallback)(const char *name, GLADapiproc apiproc, int len_args, ...);
+typedef void (*GLADpostcallback)(void *ret, const char *name, GLADapiproc apiproc, int len_args, ...);
+
+#endif /* GLAD_PLATFORM_H_ */
+
+#define GL_ACTIVE_ATTRIBUTES 0x8B89
+#define GL_ACTIVE_ATTRIBUTE_MAX_LENGTH 0x8B8A
+#define GL_ACTIVE_TEXTURE 0x84E0
+#define GL_ACTIVE_TEXTURE_ARB 0x84E0
+#define GL_ACTIVE_UNIFORMS 0x8B86
+#define GL_ACTIVE_UNIFORM_BLOCKS 0x8A36
+#define GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH 0x8A35
+#define GL_ACTIVE_UNIFORM_MAX_LENGTH 0x8B87
+#define GL_ACTIVE_VARYINGS_NV 0x8C81
+#define GL_ACTIVE_VARYING_MAX_LENGTH_NV 0x8C82
+#define GL_ALIASED_LINE_WIDTH_RANGE 0x846E
+#define GL_ALPHA 0x1906
+#define GL_ALPHA16I_EXT 0x8D8A
+#define GL_ALPHA16UI_EXT 0x8D78
+#define GL_ALPHA32I_EXT 0x8D84
+#define GL_ALPHA32UI_EXT 0x8D72
+#define GL_ALPHA8I_EXT 0x8D90
+#define GL_ALPHA8UI_EXT 0x8D7E
+#define GL_ALPHA_INTEGER_EXT 0x8D97
+#define GL_ALREADY_SIGNALED 0x911A
+#define GL_ALWAYS 0x0207
+#define GL_AND 0x1501
+#define GL_AND_INVERTED 0x1504
+#define GL_AND_REVERSE 0x1502
+#define GL_ARRAY_BUFFER 0x8892
+#define GL_ARRAY_BUFFER_ARB 0x8892
+#define GL_ARRAY_BUFFER_BINDING 0x8894
+#define GL_ARRAY_BUFFER_BINDING_ARB 0x8894
+#define GL_ATTACHED_SHADERS 0x8B85
+#define GL_ATTRIB_ARRAY_POINTER_NV 0x8645
+#define GL_ATTRIB_ARRAY_SIZE_NV 0x8623
+#define GL_ATTRIB_ARRAY_STRIDE_NV 0x8624
+#define GL_ATTRIB_ARRAY_TYPE_NV 0x8625
+#define GL_BACK 0x0405
+#define GL_BACK_LEFT 0x0402
+#define GL_BACK_PRIMARY_COLOR_NV 0x8C77
+#define GL_BACK_RIGHT 0x0403
+#define GL_BACK_SECONDARY_COLOR_NV 0x8C78
+#define GL_BGR 0x80E0
+#define GL_BGRA 0x80E1
+#define GL_BGRA_INTEGER 0x8D9B
+#define GL_BGRA_INTEGER_EXT 0x8D9B
+#define GL_BGR_INTEGER 0x8D9A
+#define GL_BGR_INTEGER_EXT 0x8D9A
+#define GL_BLEND 0x0BE2
+#define GL_BLEND_COLOR 0x8005
+#define GL_BLEND_COLOR_EXT 0x8005
+#define GL_BLEND_DST 0x0BE0
+#define GL_BLEND_DST_ALPHA 0x80CA
+#define GL_BLEND_DST_ALPHA_EXT 0x80CA
+#define GL_BLEND_DST_RGB 0x80C8
+#define GL_BLEND_DST_RGB_EXT 0x80C8
+#define GL_BLEND_EQUATION 0x8009
+#define GL_BLEND_EQUATION_ALPHA 0x883D
+#define GL_BLEND_EQUATION_ALPHA_EXT 0x883D
+#define GL_BLEND_EQUATION_EXT 0x8009
+#define GL_BLEND_EQUATION_RGB 0x8009
+#define GL_BLEND_EQUATION_RGB_EXT 0x8009
+#define GL_BLEND_SRC 0x0BE1
+#define GL_BLEND_SRC_ALPHA 0x80CB
+#define GL_BLEND_SRC_ALPHA_EXT 0x80CB
+#define GL_BLEND_SRC_RGB 0x80C9
+#define GL_BLEND_SRC_RGB_EXT 0x80C9
+#define GL_BLUE 0x1905
+#define GL_BLUE_INTEGER 0x8D96
+#define GL_BLUE_INTEGER_EXT 0x8D96
+#define GL_BOOL 0x8B56
+#define GL_BOOL_ARB 0x8B56
+#define GL_BOOL_VEC2 0x8B57
+#define GL_BOOL_VEC2_ARB 0x8B57
+#define GL_BOOL_VEC3 0x8B58
+#define GL_BOOL_VEC3_ARB 0x8B58
+#define GL_BOOL_VEC4 0x8B59
+#define GL_BOOL_VEC4_ARB 0x8B59
+#define GL_BUFFER_ACCESS 0x88BB
+#define GL_BUFFER_ACCESS_ARB 0x88BB
+#define GL_BUFFER_ACCESS_FLAGS 0x911F
+#define GL_BUFFER_FLUSHING_UNMAP_APPLE 0x8A13
+#define GL_BUFFER_MAPPED 0x88BC
+#define GL_BUFFER_MAPPED_ARB 0x88BC
+#define GL_BUFFER_MAP_LENGTH 0x9120
+#define GL_BUFFER_MAP_OFFSET 0x9121
+#define GL_BUFFER_MAP_POINTER 0x88BD
+#define GL_BUFFER_MAP_POINTER_ARB 0x88BD
+#define GL_BUFFER_SERIALIZED_MODIFY_APPLE 0x8A12
+#define GL_BUFFER_SIZE 0x8764
+#define GL_BUFFER_SIZE_ARB 0x8764
+#define GL_BUFFER_USAGE 0x8765
+#define GL_BUFFER_USAGE_ARB 0x8765
+#define GL_BYTE 0x1400
+#define GL_CCW 0x0901
+#define GL_CLAMP_FRAGMENT_COLOR_ARB 0x891B
+#define GL_CLAMP_READ_COLOR 0x891C
+#define GL_CLAMP_READ_COLOR_ARB 0x891C
+#define GL_CLAMP_TO_BORDER 0x812D
+#define GL_CLAMP_TO_EDGE 0x812F
+#define GL_CLAMP_VERTEX_COLOR_ARB 0x891A
+#define GL_CLEAR 0x1500
+#define GL_CLIENT_ACTIVE_TEXTURE_ARB 0x84E1
+#define GL_CLIP_DISTANCE0 0x3000
+#define GL_CLIP_DISTANCE1 0x3001
+#define GL_CLIP_DISTANCE2 0x3002
+#define GL_CLIP_DISTANCE3 0x3003
+#define GL_CLIP_DISTANCE4 0x3004
+#define GL_CLIP_DISTANCE5 0x3005
+#define GL_CLIP_DISTANCE6 0x3006
+#define GL_CLIP_DISTANCE7 0x3007
+#define GL_CLIP_DISTANCE_NV 0x8C7A
+#define GL_COLOR 0x1800
+#define GL_COLOR_ARRAY_BUFFER_BINDING_ARB 0x8898
+#define GL_COLOR_ARRAY_COUNT_EXT 0x8084
+#define GL_COLOR_ARRAY_EXT 0x8076
+#define GL_COLOR_ARRAY_POINTER_EXT 0x8090
+#define GL_COLOR_ARRAY_SIZE_EXT 0x8081
+#define GL_COLOR_ARRAY_STRIDE_EXT 0x8083
+#define GL_COLOR_ARRAY_TYPE_EXT 0x8082
+#define GL_COLOR_ATTACHMENT0 0x8CE0
+#define GL_COLOR_ATTACHMENT0_EXT 0x8CE0
+#define GL_COLOR_ATTACHMENT1 0x8CE1
+#define GL_COLOR_ATTACHMENT10 0x8CEA
+#define GL_COLOR_ATTACHMENT10_EXT 0x8CEA
+#define GL_COLOR_ATTACHMENT11 0x8CEB
+#define GL_COLOR_ATTACHMENT11_EXT 0x8CEB
+#define GL_COLOR_ATTACHMENT12 0x8CEC
+#define GL_COLOR_ATTACHMENT12_EXT 0x8CEC
+#define GL_COLOR_ATTACHMENT13 0x8CED
+#define GL_COLOR_ATTACHMENT13_EXT 0x8CED
+#define GL_COLOR_ATTACHMENT14 0x8CEE
+#define GL_COLOR_ATTACHMENT14_EXT 0x8CEE
+#define GL_COLOR_ATTACHMENT15 0x8CEF
+#define GL_COLOR_ATTACHMENT15_EXT 0x8CEF
+#define GL_COLOR_ATTACHMENT16 0x8CF0
+#define GL_COLOR_ATTACHMENT17 0x8CF1
+#define GL_COLOR_ATTACHMENT18 0x8CF2
+#define GL_COLOR_ATTACHMENT19 0x8CF3
+#define GL_COLOR_ATTACHMENT1_EXT 0x8CE1
+#define GL_COLOR_ATTACHMENT2 0x8CE2
+#define GL_COLOR_ATTACHMENT20 0x8CF4
+#define GL_COLOR_ATTACHMENT21 0x8CF5
+#define GL_COLOR_ATTACHMENT22 0x8CF6
+#define GL_COLOR_ATTACHMENT23 0x8CF7
+#define GL_COLOR_ATTACHMENT24 0x8CF8
+#define GL_COLOR_ATTACHMENT25 0x8CF9
+#define GL_COLOR_ATTACHMENT26 0x8CFA
+#define GL_COLOR_ATTACHMENT27 0x8CFB
+#define GL_COLOR_ATTACHMENT28 0x8CFC
+#define GL_COLOR_ATTACHMENT29 0x8CFD
+#define GL_COLOR_ATTACHMENT2_EXT 0x8CE2
+#define GL_COLOR_ATTACHMENT3 0x8CE3
+#define GL_COLOR_ATTACHMENT30 0x8CFE
+#define GL_COLOR_ATTACHMENT31 0x8CFF
+#define GL_COLOR_ATTACHMENT3_EXT 0x8CE3
+#define GL_COLOR_ATTACHMENT4 0x8CE4
+#define GL_COLOR_ATTACHMENT4_EXT 0x8CE4
+#define GL_COLOR_ATTACHMENT5 0x8CE5
+#define GL_COLOR_ATTACHMENT5_EXT 0x8CE5
+#define GL_COLOR_ATTACHMENT6 0x8CE6
+#define GL_COLOR_ATTACHMENT6_EXT 0x8CE6
+#define GL_COLOR_ATTACHMENT7 0x8CE7
+#define GL_COLOR_ATTACHMENT7_EXT 0x8CE7
+#define GL_COLOR_ATTACHMENT8 0x8CE8
+#define GL_COLOR_ATTACHMENT8_EXT 0x8CE8
+#define GL_COLOR_ATTACHMENT9 0x8CE9
+#define GL_COLOR_ATTACHMENT9_EXT 0x8CE9
+#define GL_COLOR_BUFFER_BIT 0x00004000
+#define GL_COLOR_CLEAR_VALUE 0x0C22
+#define GL_COLOR_LOGIC_OP 0x0BF2
+#define GL_COLOR_SUM_ARB 0x8458
+#define GL_COLOR_WRITEMASK 0x0C23
+#define GL_COMPARE_REF_DEPTH_TO_TEXTURE_EXT 0x884E
+#define GL_COMPARE_REF_TO_TEXTURE 0x884E
+#define GL_COMPILE_STATUS 0x8B81
+#define GL_COMPRESSED_ALPHA_ARB 0x84E9
+#define GL_COMPRESSED_INTENSITY_ARB 0x84EC
+#define GL_COMPRESSED_LUMINANCE_ALPHA_ARB 0x84EB
+#define GL_COMPRESSED_LUMINANCE_ARB 0x84EA
+#define GL_COMPRESSED_RED 0x8225
+#define GL_COMPRESSED_RED_RGTC1 0x8DBB
+#define GL_COMPRESSED_RG 0x8226
+#define GL_COMPRESSED_RGB 0x84ED
+#define GL_COMPRESSED_RGBA 0x84EE
+#define GL_COMPRESSED_RGBA_ARB 0x84EE
+#define GL_COMPRESSED_RGB_ARB 0x84ED
+#define GL_COMPRESSED_RG_RGTC2 0x8DBD
+#define GL_COMPRESSED_SIGNED_RED_RGTC1 0x8DBC
+#define GL_COMPRESSED_SIGNED_RG_RGTC2 0x8DBE
+#define GL_COMPRESSED_SRGB 0x8C48
+#define GL_COMPRESSED_SRGB_ALPHA 0x8C49
+#define GL_COMPRESSED_TEXTURE_FORMATS 0x86A3
+#define GL_COMPRESSED_TEXTURE_FORMATS_ARB 0x86A3
+#define GL_CONDITION_SATISFIED 0x911C
+#define GL_CONSTANT_ALPHA 0x8003
+#define GL_CONSTANT_ALPHA_EXT 0x8003
+#define GL_CONSTANT_COLOR 0x8001
+#define GL_CONSTANT_COLOR_EXT 0x8001
+#define GL_CONTEXT_COMPATIBILITY_PROFILE_BIT 0x00000002
+#define GL_CONTEXT_CORE_PROFILE_BIT 0x00000001
+#define GL_CONTEXT_FLAGS 0x821E
+#define GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT 0x00000001
+#define GL_CONTEXT_PROFILE_MASK 0x9126
+#define GL_COORD_REPLACE_NV 0x8862
+#define GL_COPY 0x1503
+#define GL_COPY_INVERTED 0x150C
+#define GL_COPY_READ_BUFFER 0x8F36
+#define GL_COPY_WRITE_BUFFER 0x8F37
+#define GL_CULL_FACE 0x0B44
+#define GL_CULL_FACE_MODE 0x0B45
+#define GL_CURRENT_ATTRIB_NV 0x8626
+#define GL_CURRENT_MATRIX_ARB 0x8641
+#define GL_CURRENT_MATRIX_NV 0x8641
+#define GL_CURRENT_MATRIX_STACK_DEPTH_ARB 0x8640
+#define GL_CURRENT_MATRIX_STACK_DEPTH_NV 0x8640
+#define GL_CURRENT_PROGRAM 0x8B8D
+#define GL_CURRENT_QUERY 0x8865
+#define GL_CURRENT_QUERY_ARB 0x8865
+#define GL_CURRENT_VERTEX_ATTRIB 0x8626
+#define GL_CURRENT_VERTEX_ATTRIB_ARB 0x8626
+#define GL_CW 0x0900
+#define GL_DECR 0x1E03
+#define GL_DECR_WRAP 0x8508
+#define GL_DELETE_STATUS 0x8B80
+#define GL_DEPTH 0x1801
+#define GL_DEPTH24_STENCIL8 0x88F0
+#define GL_DEPTH32F_STENCIL8 0x8CAD
+#define GL_DEPTH_ATTACHMENT 0x8D00
+#define GL_DEPTH_ATTACHMENT_EXT 0x8D00
+#define GL_DEPTH_BUFFER_BIT 0x00000100
+#define GL_DEPTH_CLAMP 0x864F
+#define GL_DEPTH_CLEAR_VALUE 0x0B73
+#define GL_DEPTH_COMPONENT 0x1902
+#define GL_DEPTH_COMPONENT16 0x81A5
+#define GL_DEPTH_COMPONENT24 0x81A6
+#define GL_DEPTH_COMPONENT32 0x81A7
+#define GL_DEPTH_COMPONENT32F 0x8CAC
+#define GL_DEPTH_FUNC 0x0B74
+#define GL_DEPTH_RANGE 0x0B70
+#define GL_DEPTH_STENCIL 0x84F9
+#define GL_DEPTH_STENCIL_ATTACHMENT 0x821A
+#define GL_DEPTH_TEST 0x0B71
+#define GL_DEPTH_WRITEMASK 0x0B72
+#define GL_DISTANCE_ATTENUATION_EXT 0x8129
+#define GL_DISTANCE_ATTENUATION_SGIS 0x8129
+#define GL_DITHER 0x0BD0
+#define GL_DONT_CARE 0x1100
+#define GL_DOUBLE 0x140A
+#define GL_DOUBLEBUFFER 0x0C32
+#define GL_DRAW_BUFFER 0x0C01
+#define GL_DRAW_BUFFER0 0x8825
+#define GL_DRAW_BUFFER0_ARB 0x8825
+#define GL_DRAW_BUFFER0_ATI 0x8825
+#define GL_DRAW_BUFFER1 0x8826
+#define GL_DRAW_BUFFER10 0x882F
+#define GL_DRAW_BUFFER10_ARB 0x882F
+#define GL_DRAW_BUFFER10_ATI 0x882F
+#define GL_DRAW_BUFFER11 0x8830
+#define GL_DRAW_BUFFER11_ARB 0x8830
+#define GL_DRAW_BUFFER11_ATI 0x8830
+#define GL_DRAW_BUFFER12 0x8831
+#define GL_DRAW_BUFFER12_ARB 0x8831
+#define GL_DRAW_BUFFER12_ATI 0x8831
+#define GL_DRAW_BUFFER13 0x8832
+#define GL_DRAW_BUFFER13_ARB 0x8832
+#define GL_DRAW_BUFFER13_ATI 0x8832
+#define GL_DRAW_BUFFER14 0x8833
+#define GL_DRAW_BUFFER14_ARB 0x8833
+#define GL_DRAW_BUFFER14_ATI 0x8833
+#define GL_DRAW_BUFFER15 0x8834
+#define GL_DRAW_BUFFER15_ARB 0x8834
+#define GL_DRAW_BUFFER15_ATI 0x8834
+#define GL_DRAW_BUFFER1_ARB 0x8826
+#define GL_DRAW_BUFFER1_ATI 0x8826
+#define GL_DRAW_BUFFER2 0x8827
+#define GL_DRAW_BUFFER2_ARB 0x8827
+#define GL_DRAW_BUFFER2_ATI 0x8827
+#define GL_DRAW_BUFFER3 0x8828
+#define GL_DRAW_BUFFER3_ARB 0x8828
+#define GL_DRAW_BUFFER3_ATI 0x8828
+#define GL_DRAW_BUFFER4 0x8829
+#define GL_DRAW_BUFFER4_ARB 0x8829
+#define GL_DRAW_BUFFER4_ATI 0x8829
+#define GL_DRAW_BUFFER5 0x882A
+#define GL_DRAW_BUFFER5_ARB 0x882A
+#define GL_DRAW_BUFFER5_ATI 0x882A
+#define GL_DRAW_BUFFER6 0x882B
+#define GL_DRAW_BUFFER6_ARB 0x882B
+#define GL_DRAW_BUFFER6_ATI 0x882B
+#define GL_DRAW_BUFFER7 0x882C
+#define GL_DRAW_BUFFER7_ARB 0x882C
+#define GL_DRAW_BUFFER7_ATI 0x882C
+#define GL_DRAW_BUFFER8 0x882D
+#define GL_DRAW_BUFFER8_ARB 0x882D
+#define GL_DRAW_BUFFER8_ATI 0x882D
+#define GL_DRAW_BUFFER9 0x882E
+#define GL_DRAW_BUFFER9_ARB 0x882E
+#define GL_DRAW_BUFFER9_ATI 0x882E
+#define GL_DRAW_FRAMEBUFFER 0x8CA9
+#define GL_DRAW_FRAMEBUFFER_BINDING 0x8CA6
+#define GL_DRAW_FRAMEBUFFER_BINDING_EXT 0x8CA6
+#define GL_DRAW_FRAMEBUFFER_EXT 0x8CA9
+#define GL_DST_ALPHA 0x0304
+#define GL_DST_COLOR 0x0306
+#define GL_DYNAMIC_COPY 0x88EA
+#define GL_DYNAMIC_COPY_ARB 0x88EA
+#define GL_DYNAMIC_DRAW 0x88E8
+#define GL_DYNAMIC_DRAW_ARB 0x88E8
+#define GL_DYNAMIC_READ 0x88E9
+#define GL_DYNAMIC_READ_ARB 0x88E9
+#define GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB 0x889B
+#define GL_EDGE_FLAG_ARRAY_COUNT_EXT 0x808D
+#define GL_EDGE_FLAG_ARRAY_EXT 0x8079
+#define GL_EDGE_FLAG_ARRAY_POINTER_EXT 0x8093
+#define GL_EDGE_FLAG_ARRAY_STRIDE_EXT 0x808C
+#define GL_ELEMENT_ARRAY_BUFFER 0x8893
+#define GL_ELEMENT_ARRAY_BUFFER_ARB 0x8893
+#define GL_ELEMENT_ARRAY_BUFFER_BINDING 0x8895
+#define GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB 0x8895
+#define GL_EQUAL 0x0202
+#define GL_EQUIV 0x1509
+#define GL_EXTENSIONS 0x1F03
+#define GL_FALSE 0
+#define GL_FASTEST 0x1101
+#define GL_FILL 0x1B02
+#define GL_FIRST_VERTEX_CONVENTION 0x8E4D
+#define GL_FIRST_VERTEX_CONVENTION_EXT 0x8E4D
+#define GL_FIXED_ONLY 0x891D
+#define GL_FIXED_ONLY_ARB 0x891D
+#define GL_FLOAT 0x1406
+#define GL_FLOAT_32_UNSIGNED_INT_24_8_REV 0x8DAD
+#define GL_FLOAT_MAT2 0x8B5A
+#define GL_FLOAT_MAT2_ARB 0x8B5A
+#define GL_FLOAT_MAT2x3 0x8B65
+#define GL_FLOAT_MAT2x4 0x8B66
+#define GL_FLOAT_MAT3 0x8B5B
+#define GL_FLOAT_MAT3_ARB 0x8B5B
+#define GL_FLOAT_MAT3x2 0x8B67
+#define GL_FLOAT_MAT3x4 0x8B68
+#define GL_FLOAT_MAT4 0x8B5C
+#define GL_FLOAT_MAT4_ARB 0x8B5C
+#define GL_FLOAT_MAT4x2 0x8B69
+#define GL_FLOAT_MAT4x3 0x8B6A
+#define GL_FLOAT_VEC2 0x8B50
+#define GL_FLOAT_VEC2_ARB 0x8B50
+#define GL_FLOAT_VEC3 0x8B51
+#define GL_FLOAT_VEC3_ARB 0x8B51
+#define GL_FLOAT_VEC4 0x8B52
+#define GL_FLOAT_VEC4_ARB 0x8B52
+#define GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB 0x889D
+#define GL_FRAGMENT_SHADER 0x8B30
+#define GL_FRAGMENT_SHADER_DERIVATIVE_HINT 0x8B8B
+#define GL_FRAMEBUFFER 0x8D40
+#define GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE 0x8215
+#define GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE 0x8214
+#define GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING 0x8210
+#define GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE 0x8211
+#define GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE 0x8216
+#define GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE 0x8213
+#define GL_FRAMEBUFFER_ATTACHMENT_LAYERED 0x8DA7
+#define GL_FRAMEBUFFER_ATTACHMENT_LAYERED_ARB 0x8DA7
+#define GL_FRAMEBUFFER_ATTACHMENT_LAYERED_EXT 0x8DA7
+#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME 0x8CD1
+#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT 0x8CD1
+#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE 0x8CD0
+#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT 0x8CD0
+#define GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE 0x8212
+#define GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE 0x8217
+#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT 0x8CD4
+#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE 0x8CD3
+#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT 0x8CD3
+#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER 0x8CD4
+#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT 0x8CD4
+#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL 0x8CD2
+#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT 0x8CD2
+#define GL_FRAMEBUFFER_BINDING 0x8CA6
+#define GL_FRAMEBUFFER_BINDING_EXT 0x8CA6
+#define GL_FRAMEBUFFER_COMPLETE 0x8CD5
+#define GL_FRAMEBUFFER_COMPLETE_EXT 0x8CD5
+#define GL_FRAMEBUFFER_DEFAULT 0x8218
+#define GL_FRAMEBUFFER_EXT 0x8D40
+#define GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT 0x8CD6
+#define GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT 0x8CD6
+#define GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT 0x8CD9
+#define GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER 0x8CDB
+#define GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT 0x8CDB
+#define GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT 0x8CDA
+#define GL_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_ARB 0x8DA9
+#define GL_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_EXT 0x8DA9
+#define GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS 0x8DA8
+#define GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_ARB 0x8DA8
+#define GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_EXT 0x8DA8
+#define GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT 0x8CD7
+#define GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT 0x8CD7
+#define GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE 0x8D56
+#define GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_EXT 0x8D56
+#define GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER 0x8CDC
+#define GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT 0x8CDC
+#define GL_FRAMEBUFFER_SRGB 0x8DB9
+#define GL_FRAMEBUFFER_UNDEFINED 0x8219
+#define GL_FRAMEBUFFER_UNSUPPORTED 0x8CDD
+#define GL_FRAMEBUFFER_UNSUPPORTED_EXT 0x8CDD
+#define GL_FRONT 0x0404
+#define GL_FRONT_AND_BACK 0x0408
+#define GL_FRONT_FACE 0x0B46
+#define GL_FRONT_LEFT 0x0400
+#define GL_FRONT_RIGHT 0x0401
+#define GL_FUNC_ADD 0x8006
+#define GL_FUNC_ADD_EXT 0x8006
+#define GL_FUNC_REVERSE_SUBTRACT 0x800B
+#define GL_FUNC_SUBTRACT 0x800A
+#define GL_GENERIC_ATTRIB_NV 0x8C7D
+#define GL_GEOMETRY_INPUT_TYPE 0x8917
+#define GL_GEOMETRY_INPUT_TYPE_ARB 0x8DDB
+#define GL_GEOMETRY_INPUT_TYPE_EXT 0x8DDB
+#define GL_GEOMETRY_OUTPUT_TYPE 0x8918
+#define GL_GEOMETRY_OUTPUT_TYPE_ARB 0x8DDC
+#define GL_GEOMETRY_OUTPUT_TYPE_EXT 0x8DDC
+#define GL_GEOMETRY_PROGRAM_NV 0x8C26
+#define GL_GEOMETRY_SHADER 0x8DD9
+#define GL_GEOMETRY_SHADER_ARB 0x8DD9
+#define GL_GEOMETRY_VERTICES_OUT 0x8916
+#define GL_GEOMETRY_VERTICES_OUT_ARB 0x8DDA
+#define GL_GEOMETRY_VERTICES_OUT_EXT 0x8DDA
+#define GL_GEQUAL 0x0206
+#define GL_GREATER 0x0204
+#define GL_GREEN 0x1904
+#define GL_GREEN_INTEGER 0x8D95
+#define GL_GREEN_INTEGER_EXT 0x8D95
+#define GL_HALF_FLOAT 0x140B
+#define GL_IDENTITY_NV 0x862A
+#define GL_INCR 0x1E02
+#define GL_INCR_WRAP 0x8507
+#define GL_INDEX_ARRAY_BUFFER_BINDING_ARB 0x8899
+#define GL_INDEX_ARRAY_COUNT_EXT 0x8087
+#define GL_INDEX_ARRAY_EXT 0x8077
+#define GL_INDEX_ARRAY_POINTER_EXT 0x8091
+#define GL_INDEX_ARRAY_STRIDE_EXT 0x8086
+#define GL_INDEX_ARRAY_TYPE_EXT 0x8085
+#define GL_INFO_LOG_LENGTH 0x8B84
+#define GL_INT 0x1404
+#define GL_INTENSITY16I_EXT 0x8D8B
+#define GL_INTENSITY16UI_EXT 0x8D79
+#define GL_INTENSITY32I_EXT 0x8D85
+#define GL_INTENSITY32UI_EXT 0x8D73
+#define GL_INTENSITY8I_EXT 0x8D91
+#define GL_INTENSITY8UI_EXT 0x8D7F
+#define GL_INTERLEAVED_ATTRIBS 0x8C8C
+#define GL_INTERLEAVED_ATTRIBS_EXT 0x8C8C
+#define GL_INTERLEAVED_ATTRIBS_NV 0x8C8C
+#define GL_INT_SAMPLER_1D 0x8DC9
+#define GL_INT_SAMPLER_1D_ARRAY 0x8DCE
+#define GL_INT_SAMPLER_1D_ARRAY_EXT 0x8DCE
+#define GL_INT_SAMPLER_1D_EXT 0x8DC9
+#define GL_INT_SAMPLER_2D 0x8DCA
+#define GL_INT_SAMPLER_2D_ARRAY 0x8DCF
+#define GL_INT_SAMPLER_2D_ARRAY_EXT 0x8DCF
+#define GL_INT_SAMPLER_2D_EXT 0x8DCA
+#define GL_INT_SAMPLER_2D_MULTISAMPLE 0x9109
+#define GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910C
+#define GL_INT_SAMPLER_2D_RECT 0x8DCD
+#define GL_INT_SAMPLER_2D_RECT_EXT 0x8DCD
+#define GL_INT_SAMPLER_3D 0x8DCB
+#define GL_INT_SAMPLER_3D_EXT 0x8DCB
+#define GL_INT_SAMPLER_BUFFER 0x8DD0
+#define GL_INT_SAMPLER_BUFFER_EXT 0x8DD0
+#define GL_INT_SAMPLER_CUBE 0x8DCC
+#define GL_INT_SAMPLER_CUBE_EXT 0x8DCC
+#define GL_INT_SAMPLER_RENDERBUFFER_NV 0x8E57
+#define GL_INT_VEC2 0x8B53
+#define GL_INT_VEC2_ARB 0x8B53
+#define GL_INT_VEC3 0x8B54
+#define GL_INT_VEC3_ARB 0x8B54
+#define GL_INT_VEC4 0x8B55
+#define GL_INT_VEC4_ARB 0x8B55
+#define GL_INVALID_ENUM 0x0500
+#define GL_INVALID_FRAMEBUFFER_OPERATION 0x0506
+#define GL_INVALID_FRAMEBUFFER_OPERATION_EXT 0x0506
+#define GL_INVALID_INDEX 0xFFFFFFFF
+#define GL_INVALID_OPERATION 0x0502
+#define GL_INVALID_VALUE 0x0501
+#define GL_INVERSE_NV 0x862B
+#define GL_INVERSE_TRANSPOSE_NV 0x862D
+#define GL_INVERT 0x150A
+#define GL_KEEP 0x1E00
+#define GL_LAST_VERTEX_CONVENTION 0x8E4E
+#define GL_LAST_VERTEX_CONVENTION_EXT 0x8E4E
+#define GL_LAYER_NV 0x8DAA
+#define GL_LEFT 0x0406
+#define GL_LEQUAL 0x0203
+#define GL_LESS 0x0201
+#define GL_LINE 0x1B01
+#define GL_LINEAR 0x2601
+#define GL_LINEAR_MIPMAP_LINEAR 0x2703
+#define GL_LINEAR_MIPMAP_NEAREST 0x2701
+#define GL_LINES 0x0001
+#define GL_LINES_ADJACENCY 0x000A
+#define GL_LINES_ADJACENCY_ARB 0x000A
+#define GL_LINES_ADJACENCY_EXT 0x000A
+#define GL_LINE_LOOP 0x0002
+#define GL_LINE_SMOOTH 0x0B20
+#define GL_LINE_SMOOTH_HINT 0x0C52
+#define GL_LINE_STRIP 0x0003
+#define GL_LINE_STRIP_ADJACENCY 0x000B
+#define GL_LINE_STRIP_ADJACENCY_ARB 0x000B
+#define GL_LINE_STRIP_ADJACENCY_EXT 0x000B
+#define GL_LINE_WIDTH 0x0B21
+#define GL_LINE_WIDTH_GRANULARITY 0x0B23
+#define GL_LINE_WIDTH_RANGE 0x0B22
+#define GL_LINK_STATUS 0x8B82
+#define GL_LOGIC_OP_MODE 0x0BF0
+#define GL_LOWER_LEFT 0x8CA1
+#define GL_LUMINANCE16I_EXT 0x8D8C
+#define GL_LUMINANCE16UI_EXT 0x8D7A
+#define GL_LUMINANCE32I_EXT 0x8D86
+#define GL_LUMINANCE32UI_EXT 0x8D74
+#define GL_LUMINANCE8I_EXT 0x8D92
+#define GL_LUMINANCE8UI_EXT 0x8D80
+#define GL_LUMINANCE_ALPHA16I_EXT 0x8D8D
+#define GL_LUMINANCE_ALPHA16UI_EXT 0x8D7B
+#define GL_LUMINANCE_ALPHA32I_EXT 0x8D87
+#define GL_LUMINANCE_ALPHA32UI_EXT 0x8D75
+#define GL_LUMINANCE_ALPHA8I_EXT 0x8D93
+#define GL_LUMINANCE_ALPHA8UI_EXT 0x8D81
+#define GL_LUMINANCE_ALPHA_INTEGER_EXT 0x8D9D
+#define GL_LUMINANCE_INTEGER_EXT 0x8D9C
+#define GL_MAJOR_VERSION 0x821B
+#define GL_MAP1_VERTEX_ATTRIB0_4_NV 0x8660
+#define GL_MAP1_VERTEX_ATTRIB10_4_NV 0x866A
+#define GL_MAP1_VERTEX_ATTRIB11_4_NV 0x866B
+#define GL_MAP1_VERTEX_ATTRIB12_4_NV 0x866C
+#define GL_MAP1_VERTEX_ATTRIB13_4_NV 0x866D
+#define GL_MAP1_VERTEX_ATTRIB14_4_NV 0x866E
+#define GL_MAP1_VERTEX_ATTRIB15_4_NV 0x866F
+#define GL_MAP1_VERTEX_ATTRIB1_4_NV 0x8661
+#define GL_MAP1_VERTEX_ATTRIB2_4_NV 0x8662
+#define GL_MAP1_VERTEX_ATTRIB3_4_NV 0x8663
+#define GL_MAP1_VERTEX_ATTRIB4_4_NV 0x8664
+#define GL_MAP1_VERTEX_ATTRIB5_4_NV 0x8665
+#define GL_MAP1_VERTEX_ATTRIB6_4_NV 0x8666
+#define GL_MAP1_VERTEX_ATTRIB7_4_NV 0x8667
+#define GL_MAP1_VERTEX_ATTRIB8_4_NV 0x8668
+#define GL_MAP1_VERTEX_ATTRIB9_4_NV 0x8669
+#define GL_MAP2_VERTEX_ATTRIB0_4_NV 0x8670
+#define GL_MAP2_VERTEX_ATTRIB10_4_NV 0x867A
+#define GL_MAP2_VERTEX_ATTRIB11_4_NV 0x867B
+#define GL_MAP2_VERTEX_ATTRIB12_4_NV 0x867C
+#define GL_MAP2_VERTEX_ATTRIB13_4_NV 0x867D
+#define GL_MAP2_VERTEX_ATTRIB14_4_NV 0x867E
+#define GL_MAP2_VERTEX_ATTRIB15_4_NV 0x867F
+#define GL_MAP2_VERTEX_ATTRIB1_4_NV 0x8671
+#define GL_MAP2_VERTEX_ATTRIB2_4_NV 0x8672
+#define GL_MAP2_VERTEX_ATTRIB3_4_NV 0x8673
+#define GL_MAP2_VERTEX_ATTRIB4_4_NV 0x8674
+#define GL_MAP2_VERTEX_ATTRIB5_4_NV 0x8675
+#define GL_MAP2_VERTEX_ATTRIB6_4_NV 0x8676
+#define GL_MAP2_VERTEX_ATTRIB7_4_NV 0x8677
+#define GL_MAP2_VERTEX_ATTRIB8_4_NV 0x8678
+#define GL_MAP2_VERTEX_ATTRIB9_4_NV 0x8679
+#define GL_MAP_FLUSH_EXPLICIT_BIT 0x0010
+#define GL_MAP_INVALIDATE_BUFFER_BIT 0x0008
+#define GL_MAP_INVALIDATE_RANGE_BIT 0x0004
+#define GL_MAP_READ_BIT 0x0001
+#define GL_MAP_UNSYNCHRONIZED_BIT 0x0020
+#define GL_MAP_WRITE_BIT 0x0002
+#define GL_MATRIX0_ARB 0x88C0
+#define GL_MATRIX0_NV 0x8630
+#define GL_MATRIX10_ARB 0x88CA
+#define GL_MATRIX11_ARB 0x88CB
+#define GL_MATRIX12_ARB 0x88CC
+#define GL_MATRIX13_ARB 0x88CD
+#define GL_MATRIX14_ARB 0x88CE
+#define GL_MATRIX15_ARB 0x88CF
+#define GL_MATRIX16_ARB 0x88D0
+#define GL_MATRIX17_ARB 0x88D1
+#define GL_MATRIX18_ARB 0x88D2
+#define GL_MATRIX19_ARB 0x88D3
+#define GL_MATRIX1_ARB 0x88C1
+#define GL_MATRIX1_NV 0x8631
+#define GL_MATRIX20_ARB 0x88D4
+#define GL_MATRIX21_ARB 0x88D5
+#define GL_MATRIX22_ARB 0x88D6
+#define GL_MATRIX23_ARB 0x88D7
+#define GL_MATRIX24_ARB 0x88D8
+#define GL_MATRIX25_ARB 0x88D9
+#define GL_MATRIX26_ARB 0x88DA
+#define GL_MATRIX27_ARB 0x88DB
+#define GL_MATRIX28_ARB 0x88DC
+#define GL_MATRIX29_ARB 0x88DD
+#define GL_MATRIX2_ARB 0x88C2
+#define GL_MATRIX2_NV 0x8632
+#define GL_MATRIX30_ARB 0x88DE
+#define GL_MATRIX31_ARB 0x88DF
+#define GL_MATRIX3_ARB 0x88C3
+#define GL_MATRIX3_NV 0x8633
+#define GL_MATRIX4_ARB 0x88C4
+#define GL_MATRIX4_NV 0x8634
+#define GL_MATRIX5_ARB 0x88C5
+#define GL_MATRIX5_NV 0x8635
+#define GL_MATRIX6_ARB 0x88C6
+#define GL_MATRIX6_NV 0x8636
+#define GL_MATRIX7_ARB 0x88C7
+#define GL_MATRIX7_NV 0x8637
+#define GL_MATRIX8_ARB 0x88C8
+#define GL_MATRIX9_ARB 0x88C9
+#define GL_MAX 0x8008
+#define GL_MAX_3D_TEXTURE_SIZE 0x8073
+#define GL_MAX_3D_TEXTURE_SIZE_EXT 0x8073
+#define GL_MAX_ARRAY_TEXTURE_LAYERS 0x88FF
+#define GL_MAX_ARRAY_TEXTURE_LAYERS_EXT 0x88FF
+#define GL_MAX_CLIP_DISTANCES 0x0D32
+#define GL_MAX_COLOR_ATTACHMENTS 0x8CDF
+#define GL_MAX_COLOR_ATTACHMENTS_EXT 0x8CDF
+#define GL_MAX_COLOR_TEXTURE_SAMPLES 0x910E
+#define GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS 0x8A33
+#define GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS 0x8A32
+#define GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS 0x8B4D
+#define GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB 0x8B4D
+#define GL_MAX_COMBINED_UNIFORM_BLOCKS 0x8A2E
+#define GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS 0x8A31
+#define GL_MAX_CUBE_MAP_TEXTURE_SIZE 0x851C
+#define GL_MAX_DEPTH_TEXTURE_SAMPLES 0x910F
+#define GL_MAX_DRAW_BUFFERS 0x8824
+#define GL_MAX_DRAW_BUFFERS_ARB 0x8824
+#define GL_MAX_DRAW_BUFFERS_ATI 0x8824
+#define GL_MAX_ELEMENTS_INDICES 0x80E9
+#define GL_MAX_ELEMENTS_INDICES_EXT 0x80E9
+#define GL_MAX_ELEMENTS_VERTICES 0x80E8
+#define GL_MAX_ELEMENTS_VERTICES_EXT 0x80E8
+#define GL_MAX_EXT 0x8008
+#define GL_MAX_FRAGMENT_INPUT_COMPONENTS 0x9125
+#define GL_MAX_FRAGMENT_UNIFORM_BLOCKS 0x8A2D
+#define GL_MAX_FRAGMENT_UNIFORM_COMPONENTS 0x8B49
+#define GL_MAX_GEOMETRY_INPUT_COMPONENTS 0x9123
+#define GL_MAX_GEOMETRY_OUTPUT_COMPONENTS 0x9124
+#define GL_MAX_GEOMETRY_OUTPUT_VERTICES 0x8DE0
+#define GL_MAX_GEOMETRY_OUTPUT_VERTICES_ARB 0x8DE0
+#define GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS 0x8C29
+#define GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_ARB 0x8C29
+#define GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_EXT 0x8C29
+#define GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS 0x8DE1
+#define GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_ARB 0x8DE1
+#define GL_MAX_GEOMETRY_UNIFORM_BLOCKS 0x8A2C
+#define GL_MAX_GEOMETRY_UNIFORM_COMPONENTS 0x8DDF
+#define GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_ARB 0x8DDF
+#define GL_MAX_GEOMETRY_VARYING_COMPONENTS_ARB 0x8DDD
+#define GL_MAX_INTEGER_SAMPLES 0x9110
+#define GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB 0x88B1
+#define GL_MAX_PROGRAM_ATTRIBS_ARB 0x88AD
+#define GL_MAX_PROGRAM_ENV_PARAMETERS_ARB 0x88B5
+#define GL_MAX_PROGRAM_INSTRUCTIONS_ARB 0x88A1
+#define GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB 0x88B4
+#define GL_MAX_PROGRAM_MATRICES_ARB 0x862F
+#define GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB 0x862E
+#define GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB 0x88B3
+#define GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB 0x88AF
+#define GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB 0x88A3
+#define GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB 0x88AB
+#define GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB 0x88A7
+#define GL_MAX_PROGRAM_OUTPUT_VERTICES_NV 0x8C27
+#define GL_MAX_PROGRAM_PARAMETERS_ARB 0x88A9
+#define GL_MAX_PROGRAM_TEMPORARIES_ARB 0x88A5
+#define GL_MAX_PROGRAM_TEXEL_OFFSET 0x8905
+#define GL_MAX_PROGRAM_TEXEL_OFFSET_EXT 0x8905
+#define GL_MAX_PROGRAM_TOTAL_OUTPUT_COMPONENTS_NV 0x8C28
+#define GL_MAX_RECTANGLE_TEXTURE_SIZE 0x84F8
+#define GL_MAX_RENDERBUFFER_SIZE 0x84E8
+#define GL_MAX_RENDERBUFFER_SIZE_EXT 0x84E8
+#define GL_MAX_SAMPLES 0x8D57
+#define GL_MAX_SAMPLES_EXT 0x8D57
+#define GL_MAX_SAMPLE_MASK_WORDS 0x8E59
+#define GL_MAX_SAMPLE_MASK_WORDS_NV 0x8E59
+#define GL_MAX_SERVER_WAIT_TIMEOUT 0x9111
+#define GL_MAX_TEXTURE_BUFFER_SIZE 0x8C2B
+#define GL_MAX_TEXTURE_BUFFER_SIZE_ARB 0x8C2B
+#define GL_MAX_TEXTURE_BUFFER_SIZE_EXT 0x8C2B
+#define GL_MAX_TEXTURE_COORDS_ARB 0x8871
+#define GL_MAX_TEXTURE_IMAGE_UNITS 0x8872
+#define GL_MAX_TEXTURE_IMAGE_UNITS_ARB 0x8872
+#define GL_MAX_TEXTURE_LOD_BIAS 0x84FD
+#define GL_MAX_TEXTURE_SIZE 0x0D33
+#define GL_MAX_TEXTURE_UNITS_ARB 0x84E2
+#define GL_MAX_TRACK_MATRICES_NV 0x862F
+#define GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV 0x862E
+#define GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS 0x8C8A
+#define GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS_EXT 0x8C8A
+#define GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS_NV 0x8C8A
+#define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS 0x8C8B
+#define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_EXT 0x8C8B
+#define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_NV 0x8C8B
+#define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS 0x8C80
+#define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_EXT 0x8C80
+#define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_NV 0x8C80
+#define GL_MAX_UNIFORM_BLOCK_SIZE 0x8A30
+#define GL_MAX_UNIFORM_BUFFER_BINDINGS 0x8A2F
+#define GL_MAX_VARYING_COMPONENTS 0x8B4B
+#define GL_MAX_VARYING_FLOATS 0x8B4B
+#define GL_MAX_VARYING_FLOATS_ARB 0x8B4B
+#define GL_MAX_VERTEX_ATTRIBS 0x8869
+#define GL_MAX_VERTEX_ATTRIBS_ARB 0x8869
+#define GL_MAX_VERTEX_OUTPUT_COMPONENTS 0x9122
+#define GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS 0x8B4C
+#define GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB 0x8B4C
+#define GL_MAX_VERTEX_UNIFORM_BLOCKS 0x8A2B
+#define GL_MAX_VERTEX_UNIFORM_COMPONENTS 0x8B4A
+#define GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB 0x8B4A
+#define GL_MAX_VERTEX_VARYING_COMPONENTS_ARB 0x8DDE
+#define GL_MAX_VIEWPORT_DIMS 0x0D3A
+#define GL_MIN 0x8007
+#define GL_MINOR_VERSION 0x821C
+#define GL_MIN_EXT 0x8007
+#define GL_MIN_PROGRAM_TEXEL_OFFSET 0x8904
+#define GL_MIN_PROGRAM_TEXEL_OFFSET_EXT 0x8904
+#define GL_MIRRORED_REPEAT 0x8370
+#define GL_MODELVIEW_PROJECTION_NV 0x8629
+#define GL_MULTISAMPLE 0x809D
+#define GL_MULTISAMPLE_ARB 0x809D
+#define GL_MULTISAMPLE_BIT_ARB 0x20000000
+#define GL_NAND 0x150E
+#define GL_NEAREST 0x2600
+#define GL_NEAREST_MIPMAP_LINEAR 0x2702
+#define GL_NEAREST_MIPMAP_NEAREST 0x2700
+#define GL_NEVER 0x0200
+#define GL_NEXT_BUFFER_NV -2
+#define GL_NICEST 0x1102
+#define GL_NONE 0
+#define GL_NOOP 0x1505
+#define GL_NOR 0x1508
+#define GL_NORMAL_ARRAY_BUFFER_BINDING_ARB 0x8897
+#define GL_NORMAL_ARRAY_COUNT_EXT 0x8080
+#define GL_NORMAL_ARRAY_EXT 0x8075
+#define GL_NORMAL_ARRAY_POINTER_EXT 0x808F
+#define GL_NORMAL_ARRAY_STRIDE_EXT 0x807F
+#define GL_NORMAL_ARRAY_TYPE_EXT 0x807E
+#define GL_NOTEQUAL 0x0205
+#define GL_NO_ERROR 0
+#define GL_NUM_COMPRESSED_TEXTURE_FORMATS 0x86A2
+#define GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB 0x86A2
+#define GL_NUM_EXTENSIONS 0x821D
+#define GL_OBJECT_ACTIVE_ATTRIBUTES_ARB 0x8B89
+#define GL_OBJECT_ACTIVE_ATTRIBUTE_MAX_LENGTH_ARB 0x8B8A
+#define GL_OBJECT_ACTIVE_UNIFORMS_ARB 0x8B86
+#define GL_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB 0x8B87
+#define GL_OBJECT_ATTACHED_OBJECTS_ARB 0x8B85
+#define GL_OBJECT_COMPILE_STATUS_ARB 0x8B81
+#define GL_OBJECT_DELETE_STATUS_ARB 0x8B80
+#define GL_OBJECT_INFO_LOG_LENGTH_ARB 0x8B84
+#define GL_OBJECT_LINK_STATUS_ARB 0x8B82
+#define GL_OBJECT_SHADER_SOURCE_LENGTH_ARB 0x8B88
+#define GL_OBJECT_SUBTYPE_ARB 0x8B4F
+#define GL_OBJECT_TYPE 0x9112
+#define GL_OBJECT_TYPE_ARB 0x8B4E
+#define GL_OBJECT_VALIDATE_STATUS_ARB 0x8B83
+#define GL_ONE 1
+#define GL_ONE_MINUS_CONSTANT_ALPHA 0x8004
+#define GL_ONE_MINUS_CONSTANT_ALPHA_EXT 0x8004
+#define GL_ONE_MINUS_CONSTANT_COLOR 0x8002
+#define GL_ONE_MINUS_CONSTANT_COLOR_EXT 0x8002
+#define GL_ONE_MINUS_DST_ALPHA 0x0305
+#define GL_ONE_MINUS_DST_COLOR 0x0307
+#define GL_ONE_MINUS_SRC_ALPHA 0x0303
+#define GL_ONE_MINUS_SRC_COLOR 0x0301
+#define GL_OR 0x1507
+#define GL_OR_INVERTED 0x150D
+#define GL_OR_REVERSE 0x150B
+#define GL_OUT_OF_MEMORY 0x0505
+#define GL_PACK_ALIGNMENT 0x0D05
+#define GL_PACK_IMAGE_HEIGHT 0x806C
+#define GL_PACK_IMAGE_HEIGHT_EXT 0x806C
+#define GL_PACK_LSB_FIRST 0x0D01
+#define GL_PACK_ROW_LENGTH 0x0D02
+#define GL_PACK_SKIP_IMAGES 0x806B
+#define GL_PACK_SKIP_IMAGES_EXT 0x806B
+#define GL_PACK_SKIP_PIXELS 0x0D04
+#define GL_PACK_SKIP_ROWS 0x0D03
+#define GL_PACK_SWAP_BYTES 0x0D00
+#define GL_PIXEL_PACK_BUFFER 0x88EB
+#define GL_PIXEL_PACK_BUFFER_BINDING 0x88ED
+#define GL_PIXEL_UNPACK_BUFFER 0x88EC
+#define GL_PIXEL_UNPACK_BUFFER_BINDING 0x88EF
+#define GL_POINT 0x1B00
+#define GL_POINTS 0x0000
+#define GL_POINT_DISTANCE_ATTENUATION_ARB 0x8129
+#define GL_POINT_FADE_THRESHOLD_SIZE 0x8128
+#define GL_POINT_FADE_THRESHOLD_SIZE_ARB 0x8128
+#define GL_POINT_FADE_THRESHOLD_SIZE_EXT 0x8128
+#define GL_POINT_FADE_THRESHOLD_SIZE_SGIS 0x8128
+#define GL_POINT_SIZE 0x0B11
+#define GL_POINT_SIZE_GRANULARITY 0x0B13
+#define GL_POINT_SIZE_MAX_ARB 0x8127
+#define GL_POINT_SIZE_MAX_EXT 0x8127
+#define GL_POINT_SIZE_MAX_SGIS 0x8127
+#define GL_POINT_SIZE_MIN_ARB 0x8126
+#define GL_POINT_SIZE_MIN_EXT 0x8126
+#define GL_POINT_SIZE_MIN_SGIS 0x8126
+#define GL_POINT_SIZE_RANGE 0x0B12
+#define GL_POINT_SPRITE_COORD_ORIGIN 0x8CA0
+#define GL_POINT_SPRITE_NV 0x8861
+#define GL_POINT_SPRITE_R_MODE_NV 0x8863
+#define GL_POLYGON_MODE 0x0B40
+#define GL_POLYGON_OFFSET_FACTOR 0x8038
+#define GL_POLYGON_OFFSET_FILL 0x8037
+#define GL_POLYGON_OFFSET_LINE 0x2A02
+#define GL_POLYGON_OFFSET_POINT 0x2A01
+#define GL_POLYGON_OFFSET_UNITS 0x2A00
+#define GL_POLYGON_SMOOTH 0x0B41
+#define GL_POLYGON_SMOOTH_HINT 0x0C53
+#define GL_PRIMITIVES_GENERATED 0x8C87
+#define GL_PRIMITIVES_GENERATED_EXT 0x8C87
+#define GL_PRIMITIVES_GENERATED_NV 0x8C87
+#define GL_PRIMITIVE_ID_NV 0x8C7C
+#define GL_PRIMITIVE_RESTART 0x8F9D
+#define GL_PRIMITIVE_RESTART_INDEX 0x8F9E
+#define GL_PROGRAM_ADDRESS_REGISTERS_ARB 0x88B0
+#define GL_PROGRAM_ATTRIBS_ARB 0x88AC
+#define GL_PROGRAM_BINDING_ARB 0x8677
+#define GL_PROGRAM_ERROR_POSITION_ARB 0x864B
+#define GL_PROGRAM_ERROR_POSITION_NV 0x864B
+#define GL_PROGRAM_ERROR_STRING_ARB 0x8874
+#define GL_PROGRAM_FORMAT_ARB 0x8876
+#define GL_PROGRAM_FORMAT_ASCII_ARB 0x8875
+#define GL_PROGRAM_INSTRUCTIONS_ARB 0x88A0
+#define GL_PROGRAM_LENGTH_ARB 0x8627
+#define GL_PROGRAM_LENGTH_NV 0x8627
+#define GL_PROGRAM_MATRIX_EXT 0x8E2D
+#define GL_PROGRAM_MATRIX_STACK_DEPTH_EXT 0x8E2F
+#define GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB 0x88B2
+#define GL_PROGRAM_NATIVE_ATTRIBS_ARB 0x88AE
+#define GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB 0x88A2
+#define GL_PROGRAM_NATIVE_PARAMETERS_ARB 0x88AA
+#define GL_PROGRAM_NATIVE_TEMPORARIES_ARB 0x88A6
+#define GL_PROGRAM_OBJECT_ARB 0x8B40
+#define GL_PROGRAM_PARAMETERS_ARB 0x88A8
+#define GL_PROGRAM_PARAMETER_NV 0x8644
+#define GL_PROGRAM_POINT_SIZE 0x8642
+#define GL_PROGRAM_POINT_SIZE_ARB 0x8642
+#define GL_PROGRAM_POINT_SIZE_EXT 0x8642
+#define GL_PROGRAM_RESIDENT_NV 0x8647
+#define GL_PROGRAM_STRING_ARB 0x8628
+#define GL_PROGRAM_STRING_NV 0x8628
+#define GL_PROGRAM_TARGET_NV 0x8646
+#define GL_PROGRAM_TEMPORARIES_ARB 0x88A4
+#define GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB 0x88B6
+#define GL_PROVOKING_VERTEX 0x8E4F
+#define GL_PROVOKING_VERTEX_EXT 0x8E4F
+#define GL_PROXY_TEXTURE_1D 0x8063
+#define GL_PROXY_TEXTURE_1D_ARRAY 0x8C19
+#define GL_PROXY_TEXTURE_1D_ARRAY_EXT 0x8C19
+#define GL_PROXY_TEXTURE_2D 0x8064
+#define GL_PROXY_TEXTURE_2D_ARRAY 0x8C1B
+#define GL_PROXY_TEXTURE_2D_ARRAY_EXT 0x8C1B
+#define GL_PROXY_TEXTURE_2D_MULTISAMPLE 0x9101
+#define GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY 0x9103
+#define GL_PROXY_TEXTURE_3D 0x8070
+#define GL_PROXY_TEXTURE_3D_EXT 0x8070
+#define GL_PROXY_TEXTURE_CUBE_MAP 0x851B
+#define GL_PROXY_TEXTURE_RECTANGLE 0x84F7
+#define GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION 0x8E4C
+#define GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION_EXT 0x8E4C
+#define GL_QUERY_BY_REGION_NO_WAIT 0x8E16
+#define GL_QUERY_BY_REGION_NO_WAIT_NV 0x8E16
+#define GL_QUERY_BY_REGION_WAIT 0x8E15
+#define GL_QUERY_BY_REGION_WAIT_NV 0x8E15
+#define GL_QUERY_COUNTER_BITS 0x8864
+#define GL_QUERY_COUNTER_BITS_ARB 0x8864
+#define GL_QUERY_NO_WAIT 0x8E14
+#define GL_QUERY_NO_WAIT_NV 0x8E14
+#define GL_QUERY_RESULT 0x8866
+#define GL_QUERY_RESULT_ARB 0x8866
+#define GL_QUERY_RESULT_AVAILABLE 0x8867
+#define GL_QUERY_RESULT_AVAILABLE_ARB 0x8867
+#define GL_QUERY_WAIT 0x8E13
+#define GL_QUERY_WAIT_NV 0x8E13
+#define GL_R11F_G11F_B10F 0x8C3A
+#define GL_R16 0x822A
+#define GL_R16F 0x822D
+#define GL_R16I 0x8233
+#define GL_R16UI 0x8234
+#define GL_R16_SNORM 0x8F98
+#define GL_R32F 0x822E
+#define GL_R32I 0x8235
+#define GL_R32UI 0x8236
+#define GL_R3_G3_B2 0x2A10
+#define GL_R8 0x8229
+#define GL_R8I 0x8231
+#define GL_R8UI 0x8232
+#define GL_R8_SNORM 0x8F94
+#define GL_RASTERIZER_DISCARD 0x8C89
+#define GL_RASTERIZER_DISCARD_EXT 0x8C89
+#define GL_RASTERIZER_DISCARD_NV 0x8C89
+#define GL_READ_BUFFER 0x0C02
+#define GL_READ_FRAMEBUFFER 0x8CA8
+#define GL_READ_FRAMEBUFFER_BINDING 0x8CAA
+#define GL_READ_FRAMEBUFFER_BINDING_EXT 0x8CAA
+#define GL_READ_FRAMEBUFFER_EXT 0x8CA8
+#define GL_READ_ONLY 0x88B8
+#define GL_READ_ONLY_ARB 0x88B8
+#define GL_READ_WRITE 0x88BA
+#define GL_READ_WRITE_ARB 0x88BA
+#define GL_RED 0x1903
+#define GL_RED_INTEGER 0x8D94
+#define GL_RED_INTEGER_EXT 0x8D94
+#define GL_RENDERBUFFER 0x8D41
+#define GL_RENDERBUFFER_ALPHA_SIZE 0x8D53
+#define GL_RENDERBUFFER_ALPHA_SIZE_EXT 0x8D53
+#define GL_RENDERBUFFER_BINDING 0x8CA7
+#define GL_RENDERBUFFER_BINDING_EXT 0x8CA7
+#define GL_RENDERBUFFER_BLUE_SIZE 0x8D52
+#define GL_RENDERBUFFER_BLUE_SIZE_EXT 0x8D52
+#define GL_RENDERBUFFER_DEPTH_SIZE 0x8D54
+#define GL_RENDERBUFFER_DEPTH_SIZE_EXT 0x8D54
+#define GL_RENDERBUFFER_EXT 0x8D41
+#define GL_RENDERBUFFER_GREEN_SIZE 0x8D51
+#define GL_RENDERBUFFER_GREEN_SIZE_EXT 0x8D51
+#define GL_RENDERBUFFER_HEIGHT 0x8D43
+#define GL_RENDERBUFFER_HEIGHT_EXT 0x8D43
+#define GL_RENDERBUFFER_INTERNAL_FORMAT 0x8D44
+#define GL_RENDERBUFFER_INTERNAL_FORMAT_EXT 0x8D44
+#define GL_RENDERBUFFER_RED_SIZE 0x8D50
+#define GL_RENDERBUFFER_RED_SIZE_EXT 0x8D50
+#define GL_RENDERBUFFER_SAMPLES 0x8CAB
+#define GL_RENDERBUFFER_SAMPLES_EXT 0x8CAB
+#define GL_RENDERBUFFER_STENCIL_SIZE 0x8D55
+#define GL_RENDERBUFFER_STENCIL_SIZE_EXT 0x8D55
+#define GL_RENDERBUFFER_WIDTH 0x8D42
+#define GL_RENDERBUFFER_WIDTH_EXT 0x8D42
+#define GL_RENDERER 0x1F01
+#define GL_REPEAT 0x2901
+#define GL_REPLACE 0x1E01
+#define GL_RG 0x8227
+#define GL_RG16 0x822C
+#define GL_RG16F 0x822F
+#define GL_RG16I 0x8239
+#define GL_RG16UI 0x823A
+#define GL_RG16_SNORM 0x8F99
+#define GL_RG32F 0x8230
+#define GL_RG32I 0x823B
+#define GL_RG32UI 0x823C
+#define GL_RG8 0x822B
+#define GL_RG8I 0x8237
+#define GL_RG8UI 0x8238
+#define GL_RG8_SNORM 0x8F95
+#define GL_RGB 0x1907
+#define GL_RGB10 0x8052
+#define GL_RGB10_A2 0x8059
+#define GL_RGB12 0x8053
+#define GL_RGB16 0x8054
+#define GL_RGB16F 0x881B
+#define GL_RGB16I 0x8D89
+#define GL_RGB16I_EXT 0x8D89
+#define GL_RGB16UI 0x8D77
+#define GL_RGB16UI_EXT 0x8D77
+#define GL_RGB16_SNORM 0x8F9A
+#define GL_RGB32F 0x8815
+#define GL_RGB32I 0x8D83
+#define GL_RGB32I_EXT 0x8D83
+#define GL_RGB32UI 0x8D71
+#define GL_RGB32UI_EXT 0x8D71
+#define GL_RGB4 0x804F
+#define GL_RGB5 0x8050
+#define GL_RGB5_A1 0x8057
+#define GL_RGB8 0x8051
+#define GL_RGB8I 0x8D8F
+#define GL_RGB8I_EXT 0x8D8F
+#define GL_RGB8UI 0x8D7D
+#define GL_RGB8UI_EXT 0x8D7D
+#define GL_RGB8_SNORM 0x8F96
+#define GL_RGB9_E5 0x8C3D
+#define GL_RGBA 0x1908
+#define GL_RGBA12 0x805A
+#define GL_RGBA16 0x805B
+#define GL_RGBA16F 0x881A
+#define GL_RGBA16I 0x8D88
+#define GL_RGBA16I_EXT 0x8D88
+#define GL_RGBA16UI 0x8D76
+#define GL_RGBA16UI_EXT 0x8D76
+#define GL_RGBA16_SNORM 0x8F9B
+#define GL_RGBA2 0x8055
+#define GL_RGBA32F 0x8814
+#define GL_RGBA32I 0x8D82
+#define GL_RGBA32I_EXT 0x8D82
+#define GL_RGBA32UI 0x8D70
+#define GL_RGBA32UI_EXT 0x8D70
+#define GL_RGBA4 0x8056
+#define GL_RGBA8 0x8058
+#define GL_RGBA8I 0x8D8E
+#define GL_RGBA8I_EXT 0x8D8E
+#define GL_RGBA8UI 0x8D7C
+#define GL_RGBA8UI_EXT 0x8D7C
+#define GL_RGBA8_SNORM 0x8F97
+#define GL_RGBA_FLOAT_MODE_ARB 0x8820
+#define GL_RGBA_INTEGER 0x8D99
+#define GL_RGBA_INTEGER_EXT 0x8D99
+#define GL_RGBA_INTEGER_MODE_EXT 0x8D9E
+#define GL_RGB_INTEGER 0x8D98
+#define GL_RGB_INTEGER_EXT 0x8D98
+#define GL_RG_INTEGER 0x8228
+#define GL_RIGHT 0x0407
+#define GL_SAMPLER_1D 0x8B5D
+#define GL_SAMPLER_1D_ARB 0x8B5D
+#define GL_SAMPLER_1D_ARRAY 0x8DC0
+#define GL_SAMPLER_1D_ARRAY_EXT 0x8DC0
+#define GL_SAMPLER_1D_ARRAY_SHADOW 0x8DC3
+#define GL_SAMPLER_1D_ARRAY_SHADOW_EXT 0x8DC3
+#define GL_SAMPLER_1D_SHADOW 0x8B61
+#define GL_SAMPLER_1D_SHADOW_ARB 0x8B61
+#define GL_SAMPLER_2D 0x8B5E
+#define GL_SAMPLER_2D_ARB 0x8B5E
+#define GL_SAMPLER_2D_ARRAY 0x8DC1
+#define GL_SAMPLER_2D_ARRAY_EXT 0x8DC1
+#define GL_SAMPLER_2D_ARRAY_SHADOW 0x8DC4
+#define GL_SAMPLER_2D_ARRAY_SHADOW_EXT 0x8DC4
+#define GL_SAMPLER_2D_MULTISAMPLE 0x9108
+#define GL_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910B
+#define GL_SAMPLER_2D_RECT 0x8B63
+#define GL_SAMPLER_2D_RECT_ARB 0x8B63
+#define GL_SAMPLER_2D_RECT_SHADOW 0x8B64
+#define GL_SAMPLER_2D_RECT_SHADOW_ARB 0x8B64
+#define GL_SAMPLER_2D_SHADOW 0x8B62
+#define GL_SAMPLER_2D_SHADOW_ARB 0x8B62
+#define GL_SAMPLER_3D 0x8B5F
+#define GL_SAMPLER_3D_ARB 0x8B5F
+#define GL_SAMPLER_BUFFER 0x8DC2
+#define GL_SAMPLER_BUFFER_EXT 0x8DC2
+#define GL_SAMPLER_CUBE 0x8B60
+#define GL_SAMPLER_CUBE_ARB 0x8B60
+#define GL_SAMPLER_CUBE_SHADOW 0x8DC5
+#define GL_SAMPLER_CUBE_SHADOW_EXT 0x8DC5
+#define GL_SAMPLER_RENDERBUFFER_NV 0x8E56
+#define GL_SAMPLES 0x80A9
+#define GL_SAMPLES_ARB 0x80A9
+#define GL_SAMPLES_PASSED 0x8914
+#define GL_SAMPLES_PASSED_ARB 0x8914
+#define GL_SAMPLE_ALPHA_TO_COVERAGE 0x809E
+#define GL_SAMPLE_ALPHA_TO_COVERAGE_ARB 0x809E
+#define GL_SAMPLE_ALPHA_TO_ONE 0x809F
+#define GL_SAMPLE_ALPHA_TO_ONE_ARB 0x809F
+#define GL_SAMPLE_BUFFERS 0x80A8
+#define GL_SAMPLE_BUFFERS_ARB 0x80A8
+#define GL_SAMPLE_COVERAGE 0x80A0
+#define GL_SAMPLE_COVERAGE_ARB 0x80A0
+#define GL_SAMPLE_COVERAGE_INVERT 0x80AB
+#define GL_SAMPLE_COVERAGE_INVERT_ARB 0x80AB
+#define GL_SAMPLE_COVERAGE_VALUE 0x80AA
+#define GL_SAMPLE_COVERAGE_VALUE_ARB 0x80AA
+#define GL_SAMPLE_MASK 0x8E51
+#define GL_SAMPLE_MASK_NV 0x8E51
+#define GL_SAMPLE_MASK_VALUE 0x8E52
+#define GL_SAMPLE_MASK_VALUE_NV 0x8E52
+#define GL_SAMPLE_POSITION 0x8E50
+#define GL_SAMPLE_POSITION_NV 0x8E50
+#define GL_SCISSOR_BOX 0x0C10
+#define GL_SCISSOR_TEST 0x0C11
+#define GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB 0x889C
+#define GL_SEPARATE_ATTRIBS 0x8C8D
+#define GL_SEPARATE_ATTRIBS_EXT 0x8C8D
+#define GL_SEPARATE_ATTRIBS_NV 0x8C8D
+#define GL_SET 0x150F
+#define GL_SHADER_OBJECT_ARB 0x8B48
+#define GL_SHADER_SOURCE_LENGTH 0x8B88
+#define GL_SHADER_TYPE 0x8B4F
+#define GL_SHADING_LANGUAGE_VERSION 0x8B8C
+#define GL_SHORT 0x1402
+#define GL_SIGNALED 0x9119
+#define GL_SIGNED_NORMALIZED 0x8F9C
+#define GL_SKIP_COMPONENTS1_NV -6
+#define GL_SKIP_COMPONENTS2_NV -5
+#define GL_SKIP_COMPONENTS3_NV -4
+#define GL_SKIP_COMPONENTS4_NV -3
+#define GL_SMOOTH_LINE_WIDTH_GRANULARITY 0x0B23
+#define GL_SMOOTH_LINE_WIDTH_RANGE 0x0B22
+#define GL_SMOOTH_POINT_SIZE_GRANULARITY 0x0B13
+#define GL_SMOOTH_POINT_SIZE_RANGE 0x0B12
+#define GL_SRC1_ALPHA 0x8589
+#define GL_SRC_ALPHA 0x0302
+#define GL_SRC_ALPHA_SATURATE 0x0308
+#define GL_SRC_COLOR 0x0300
+#define GL_SRGB 0x8C40
+#define GL_SRGB8 0x8C41
+#define GL_SRGB8_ALPHA8 0x8C43
+#define GL_SRGB_ALPHA 0x8C42
+#define GL_STATIC_COPY 0x88E6
+#define GL_STATIC_COPY_ARB 0x88E6
+#define GL_STATIC_DRAW 0x88E4
+#define GL_STATIC_DRAW_ARB 0x88E4
+#define GL_STATIC_READ 0x88E5
+#define GL_STATIC_READ_ARB 0x88E5
+#define GL_STENCIL 0x1802
+#define GL_STENCIL_ATTACHMENT 0x8D20
+#define GL_STENCIL_ATTACHMENT_EXT 0x8D20
+#define GL_STENCIL_BACK_FAIL 0x8801
+#define GL_STENCIL_BACK_FAIL_ATI 0x8801
+#define GL_STENCIL_BACK_FUNC 0x8800
+#define GL_STENCIL_BACK_FUNC_ATI 0x8800
+#define GL_STENCIL_BACK_PASS_DEPTH_FAIL 0x8802
+#define GL_STENCIL_BACK_PASS_DEPTH_FAIL_ATI 0x8802
+#define GL_STENCIL_BACK_PASS_DEPTH_PASS 0x8803
+#define GL_STENCIL_BACK_PASS_DEPTH_PASS_ATI 0x8803
+#define GL_STENCIL_BACK_REF 0x8CA3
+#define GL_STENCIL_BACK_VALUE_MASK 0x8CA4
+#define GL_STENCIL_BACK_WRITEMASK 0x8CA5
+#define GL_STENCIL_BUFFER_BIT 0x00000400
+#define GL_STENCIL_CLEAR_VALUE 0x0B91
+#define GL_STENCIL_FAIL 0x0B94
+#define GL_STENCIL_FUNC 0x0B92
+#define GL_STENCIL_INDEX 0x1901
+#define GL_STENCIL_INDEX1 0x8D46
+#define GL_STENCIL_INDEX16 0x8D49
+#define GL_STENCIL_INDEX16_EXT 0x8D49
+#define GL_STENCIL_INDEX1_EXT 0x8D46
+#define GL_STENCIL_INDEX4 0x8D47
+#define GL_STENCIL_INDEX4_EXT 0x8D47
+#define GL_STENCIL_INDEX8 0x8D48
+#define GL_STENCIL_INDEX8_EXT 0x8D48
+#define GL_STENCIL_PASS_DEPTH_FAIL 0x0B95
+#define GL_STENCIL_PASS_DEPTH_PASS 0x0B96
+#define GL_STENCIL_REF 0x0B97
+#define GL_STENCIL_TEST 0x0B90
+#define GL_STENCIL_VALUE_MASK 0x0B93
+#define GL_STENCIL_WRITEMASK 0x0B98
+#define GL_STEREO 0x0C33
+#define GL_STREAM_COPY 0x88E2
+#define GL_STREAM_COPY_ARB 0x88E2
+#define GL_STREAM_DRAW 0x88E0
+#define GL_STREAM_DRAW_ARB 0x88E0
+#define GL_STREAM_READ 0x88E1
+#define GL_STREAM_READ_ARB 0x88E1
+#define GL_SUBPIXEL_BITS 0x0D50
+#define GL_SYNC_CONDITION 0x9113
+#define GL_SYNC_FENCE 0x9116
+#define GL_SYNC_FLAGS 0x9115
+#define GL_SYNC_FLUSH_COMMANDS_BIT 0x00000001
+#define GL_SYNC_GPU_COMMANDS_COMPLETE 0x9117
+#define GL_SYNC_STATUS 0x9114
+#define GL_TEXTURE 0x1702
+#define GL_TEXTURE0 0x84C0
+#define GL_TEXTURE0_ARB 0x84C0
+#define GL_TEXTURE1 0x84C1
+#define GL_TEXTURE10 0x84CA
+#define GL_TEXTURE10_ARB 0x84CA
+#define GL_TEXTURE11 0x84CB
+#define GL_TEXTURE11_ARB 0x84CB
+#define GL_TEXTURE12 0x84CC
+#define GL_TEXTURE12_ARB 0x84CC
+#define GL_TEXTURE13 0x84CD
+#define GL_TEXTURE13_ARB 0x84CD
+#define GL_TEXTURE14 0x84CE
+#define GL_TEXTURE14_ARB 0x84CE
+#define GL_TEXTURE15 0x84CF
+#define GL_TEXTURE15_ARB 0x84CF
+#define GL_TEXTURE16 0x84D0
+#define GL_TEXTURE16_ARB 0x84D0
+#define GL_TEXTURE17 0x84D1
+#define GL_TEXTURE17_ARB 0x84D1
+#define GL_TEXTURE18 0x84D2
+#define GL_TEXTURE18_ARB 0x84D2
+#define GL_TEXTURE19 0x84D3
+#define GL_TEXTURE19_ARB 0x84D3
+#define GL_TEXTURE1_ARB 0x84C1
+#define GL_TEXTURE2 0x84C2
+#define GL_TEXTURE20 0x84D4
+#define GL_TEXTURE20_ARB 0x84D4
+#define GL_TEXTURE21 0x84D5
+#define GL_TEXTURE21_ARB 0x84D5
+#define GL_TEXTURE22 0x84D6
+#define GL_TEXTURE22_ARB 0x84D6
+#define GL_TEXTURE23 0x84D7
+#define GL_TEXTURE23_ARB 0x84D7
+#define GL_TEXTURE24 0x84D8
+#define GL_TEXTURE24_ARB 0x84D8
+#define GL_TEXTURE25 0x84D9
+#define GL_TEXTURE25_ARB 0x84D9
+#define GL_TEXTURE26 0x84DA
+#define GL_TEXTURE26_ARB 0x84DA
+#define GL_TEXTURE27 0x84DB
+#define GL_TEXTURE27_ARB 0x84DB
+#define GL_TEXTURE28 0x84DC
+#define GL_TEXTURE28_ARB 0x84DC
+#define GL_TEXTURE29 0x84DD
+#define GL_TEXTURE29_ARB 0x84DD
+#define GL_TEXTURE2_ARB 0x84C2
+#define GL_TEXTURE3 0x84C3
+#define GL_TEXTURE30 0x84DE
+#define GL_TEXTURE30_ARB 0x84DE
+#define GL_TEXTURE31 0x84DF
+#define GL_TEXTURE31_ARB 0x84DF
+#define GL_TEXTURE3_ARB 0x84C3
+#define GL_TEXTURE4 0x84C4
+#define GL_TEXTURE4_ARB 0x84C4
+#define GL_TEXTURE5 0x84C5
+#define GL_TEXTURE5_ARB 0x84C5
+#define GL_TEXTURE6 0x84C6
+#define GL_TEXTURE6_ARB 0x84C6
+#define GL_TEXTURE7 0x84C7
+#define GL_TEXTURE7_ARB 0x84C7
+#define GL_TEXTURE8 0x84C8
+#define GL_TEXTURE8_ARB 0x84C8
+#define GL_TEXTURE9 0x84C9
+#define GL_TEXTURE9_ARB 0x84C9
+#define GL_TEXTURE_1D 0x0DE0
+#define GL_TEXTURE_1D_ARRAY 0x8C18
+#define GL_TEXTURE_1D_ARRAY_EXT 0x8C18
+#define GL_TEXTURE_1D_BINDING_EXT 0x8068
+#define GL_TEXTURE_2D 0x0DE1
+#define GL_TEXTURE_2D_ARRAY 0x8C1A
+#define GL_TEXTURE_2D_ARRAY_EXT 0x8C1A
+#define GL_TEXTURE_2D_BINDING_EXT 0x8069
+#define GL_TEXTURE_2D_MULTISAMPLE 0x9100
+#define GL_TEXTURE_2D_MULTISAMPLE_ARRAY 0x9102
+#define GL_TEXTURE_3D 0x806F
+#define GL_TEXTURE_3D_BINDING_EXT 0x806A
+#define GL_TEXTURE_3D_EXT 0x806F
+#define GL_TEXTURE_ALPHA_SIZE 0x805F
+#define GL_TEXTURE_ALPHA_TYPE 0x8C13
+#define GL_TEXTURE_BASE_LEVEL 0x813C
+#define GL_TEXTURE_BINDING_1D 0x8068
+#define GL_TEXTURE_BINDING_1D_ARRAY 0x8C1C
+#define GL_TEXTURE_BINDING_1D_ARRAY_EXT 0x8C1C
+#define GL_TEXTURE_BINDING_2D 0x8069
+#define GL_TEXTURE_BINDING_2D_ARRAY 0x8C1D
+#define GL_TEXTURE_BINDING_2D_ARRAY_EXT 0x8C1D
+#define GL_TEXTURE_BINDING_2D_MULTISAMPLE 0x9104
+#define GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY 0x9105
+#define GL_TEXTURE_BINDING_3D 0x806A
+#define GL_TEXTURE_BINDING_BUFFER 0x8C2C
+#define GL_TEXTURE_BINDING_BUFFER_ARB 0x8C2C
+#define GL_TEXTURE_BINDING_BUFFER_EXT 0x8C2C
+#define GL_TEXTURE_BINDING_CUBE_MAP 0x8514
+#define GL_TEXTURE_BINDING_RECTANGLE 0x84F6
+#define GL_TEXTURE_BINDING_RENDERBUFFER_NV 0x8E53
+#define GL_TEXTURE_BLUE_SIZE 0x805E
+#define GL_TEXTURE_BLUE_TYPE 0x8C12
+#define GL_TEXTURE_BORDER_COLOR 0x1004
+#define GL_TEXTURE_BUFFER 0x8C2A
+#define GL_TEXTURE_BUFFER_ARB 0x8C2A
+#define GL_TEXTURE_BUFFER_DATA_STORE_BINDING 0x8C2D
+#define GL_TEXTURE_BUFFER_DATA_STORE_BINDING_ARB 0x8C2D
+#define GL_TEXTURE_BUFFER_DATA_STORE_BINDING_EXT 0x8C2D
+#define GL_TEXTURE_BUFFER_EXT 0x8C2A
+#define GL_TEXTURE_BUFFER_FORMAT_ARB 0x8C2E
+#define GL_TEXTURE_BUFFER_FORMAT_EXT 0x8C2E
+#define GL_TEXTURE_COMPARE_FUNC 0x884D
+#define GL_TEXTURE_COMPARE_MODE 0x884C
+#define GL_TEXTURE_COMPRESSED 0x86A1
+#define GL_TEXTURE_COMPRESSED_ARB 0x86A1
+#define GL_TEXTURE_COMPRESSED_IMAGE_SIZE 0x86A0
+#define GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB 0x86A0
+#define GL_TEXTURE_COMPRESSION_HINT 0x84EF
+#define GL_TEXTURE_COMPRESSION_HINT_ARB 0x84EF
+#define GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB 0x889A
+#define GL_TEXTURE_COORD_ARRAY_COUNT_EXT 0x808B
+#define GL_TEXTURE_COORD_ARRAY_EXT 0x8078
+#define GL_TEXTURE_COORD_ARRAY_POINTER_EXT 0x8092
+#define GL_TEXTURE_COORD_ARRAY_SIZE_EXT 0x8088
+#define GL_TEXTURE_COORD_ARRAY_STRIDE_EXT 0x808A
+#define GL_TEXTURE_COORD_ARRAY_TYPE_EXT 0x8089
+#define GL_TEXTURE_COORD_NV 0x8C79
+#define GL_TEXTURE_CUBE_MAP 0x8513
+#define GL_TEXTURE_CUBE_MAP_NEGATIVE_X 0x8516
+#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y 0x8518
+#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z 0x851A
+#define GL_TEXTURE_CUBE_MAP_POSITIVE_X 0x8515
+#define GL_TEXTURE_CUBE_MAP_POSITIVE_Y 0x8517
+#define GL_TEXTURE_CUBE_MAP_POSITIVE_Z 0x8519
+#define GL_TEXTURE_CUBE_MAP_SEAMLESS 0x884F
+#define GL_TEXTURE_DEPTH 0x8071
+#define GL_TEXTURE_DEPTH_EXT 0x8071
+#define GL_TEXTURE_DEPTH_SIZE 0x884A
+#define GL_TEXTURE_DEPTH_TYPE 0x8C16
+#define GL_TEXTURE_FIXED_SAMPLE_LOCATIONS 0x9107
+#define GL_TEXTURE_GREEN_SIZE 0x805D
+#define GL_TEXTURE_GREEN_TYPE 0x8C11
+#define GL_TEXTURE_HEIGHT 0x1001
+#define GL_TEXTURE_INTERNAL_FORMAT 0x1003
+#define GL_TEXTURE_LOD_BIAS 0x8501
+#define GL_TEXTURE_MAG_FILTER 0x2800
+#define GL_TEXTURE_MAX_LEVEL 0x813D
+#define GL_TEXTURE_MAX_LOD 0x813B
+#define GL_TEXTURE_MIN_FILTER 0x2801
+#define GL_TEXTURE_MIN_LOD 0x813A
+#define GL_TEXTURE_PRIORITY_EXT 0x8066
+#define GL_TEXTURE_RECTANGLE 0x84F5
+#define GL_TEXTURE_RED_SIZE 0x805C
+#define GL_TEXTURE_RED_TYPE 0x8C10
+#define GL_TEXTURE_RENDERBUFFER_DATA_STORE_BINDING_NV 0x8E54
+#define GL_TEXTURE_RENDERBUFFER_NV 0x8E55
+#define GL_TEXTURE_RESIDENT_EXT 0x8067
+#define GL_TEXTURE_SAMPLES 0x9106
+#define GL_TEXTURE_SHARED_SIZE 0x8C3F
+#define GL_TEXTURE_STENCIL_SIZE 0x88F1
+#define GL_TEXTURE_WIDTH 0x1000
+#define GL_TEXTURE_WRAP_R 0x8072
+#define GL_TEXTURE_WRAP_R_EXT 0x8072
+#define GL_TEXTURE_WRAP_S 0x2802
+#define GL_TEXTURE_WRAP_T 0x2803
+#define GL_TIMEOUT_EXPIRED 0x911B
+#define GL_TIMEOUT_IGNORED 0xFFFFFFFFFFFFFFFF
+#define GL_TRACK_MATRIX_NV 0x8648
+#define GL_TRACK_MATRIX_TRANSFORM_NV 0x8649
+#define GL_TRANSFORM_FEEDBACK_ATTRIBS_NV 0x8C7E
+#define GL_TRANSFORM_FEEDBACK_BUFFER 0x8C8E
+#define GL_TRANSFORM_FEEDBACK_BUFFER_BINDING 0x8C8F
+#define GL_TRANSFORM_FEEDBACK_BUFFER_BINDING_EXT 0x8C8F
+#define GL_TRANSFORM_FEEDBACK_BUFFER_BINDING_NV 0x8C8F
+#define GL_TRANSFORM_FEEDBACK_BUFFER_EXT 0x8C8E
+#define GL_TRANSFORM_FEEDBACK_BUFFER_MODE 0x8C7F
+#define GL_TRANSFORM_FEEDBACK_BUFFER_MODE_EXT 0x8C7F
+#define GL_TRANSFORM_FEEDBACK_BUFFER_MODE_NV 0x8C7F
+#define GL_TRANSFORM_FEEDBACK_BUFFER_NV 0x8C8E
+#define GL_TRANSFORM_FEEDBACK_BUFFER_SIZE 0x8C85
+#define GL_TRANSFORM_FEEDBACK_BUFFER_SIZE_EXT 0x8C85
+#define GL_TRANSFORM_FEEDBACK_BUFFER_SIZE_NV 0x8C85
+#define GL_TRANSFORM_FEEDBACK_BUFFER_START 0x8C84
+#define GL_TRANSFORM_FEEDBACK_BUFFER_START_EXT 0x8C84
+#define GL_TRANSFORM_FEEDBACK_BUFFER_START_NV 0x8C84
+#define GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN 0x8C88
+#define GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_EXT 0x8C88
+#define GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_NV 0x8C88
+#define GL_TRANSFORM_FEEDBACK_RECORD_NV 0x8C86
+#define GL_TRANSFORM_FEEDBACK_VARYINGS 0x8C83
+#define GL_TRANSFORM_FEEDBACK_VARYINGS_EXT 0x8C83
+#define GL_TRANSFORM_FEEDBACK_VARYINGS_NV 0x8C83
+#define GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH 0x8C76
+#define GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH_EXT 0x8C76
+#define GL_TRANSPOSE_CURRENT_MATRIX_ARB 0x88B7
+#define GL_TRANSPOSE_NV 0x862C
+#define GL_TRANSPOSE_PROGRAM_MATRIX_EXT 0x8E2E
+#define GL_TRIANGLES 0x0004
+#define GL_TRIANGLES_ADJACENCY 0x000C
+#define GL_TRIANGLES_ADJACENCY_ARB 0x000C
+#define GL_TRIANGLES_ADJACENCY_EXT 0x000C
+#define GL_TRIANGLE_FAN 0x0006
+#define GL_TRIANGLE_STRIP 0x0005
+#define GL_TRIANGLE_STRIP_ADJACENCY 0x000D
+#define GL_TRIANGLE_STRIP_ADJACENCY_ARB 0x000D
+#define GL_TRIANGLE_STRIP_ADJACENCY_EXT 0x000D
+#define GL_TRUE 1
+#define GL_UNIFORM_ARRAY_STRIDE 0x8A3C
+#define GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS 0x8A42
+#define GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES 0x8A43
+#define GL_UNIFORM_BLOCK_BINDING 0x8A3F
+#define GL_UNIFORM_BLOCK_DATA_SIZE 0x8A40
+#define GL_UNIFORM_BLOCK_INDEX 0x8A3A
+#define GL_UNIFORM_BLOCK_NAME_LENGTH 0x8A41
+#define GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER 0x8A46
+#define GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER 0x8A45
+#define GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER 0x8A44
+#define GL_UNIFORM_BUFFER 0x8A11
+#define GL_UNIFORM_BUFFER_BINDING 0x8A28
+#define GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT 0x8A34
+#define GL_UNIFORM_BUFFER_SIZE 0x8A2A
+#define GL_UNIFORM_BUFFER_START 0x8A29
+#define GL_UNIFORM_IS_ROW_MAJOR 0x8A3E
+#define GL_UNIFORM_MATRIX_STRIDE 0x8A3D
+#define GL_UNIFORM_NAME_LENGTH 0x8A39
+#define GL_UNIFORM_OFFSET 0x8A3B
+#define GL_UNIFORM_SIZE 0x8A38
+#define GL_UNIFORM_TYPE 0x8A37
+#define GL_UNPACK_ALIGNMENT 0x0CF5
+#define GL_UNPACK_IMAGE_HEIGHT 0x806E
+#define GL_UNPACK_IMAGE_HEIGHT_EXT 0x806E
+#define GL_UNPACK_LSB_FIRST 0x0CF1
+#define GL_UNPACK_ROW_LENGTH 0x0CF2
+#define GL_UNPACK_SKIP_IMAGES 0x806D
+#define GL_UNPACK_SKIP_IMAGES_EXT 0x806D
+#define GL_UNPACK_SKIP_PIXELS 0x0CF4
+#define GL_UNPACK_SKIP_ROWS 0x0CF3
+#define GL_UNPACK_SWAP_BYTES 0x0CF0
+#define GL_UNSIGNALED 0x9118
+#define GL_UNSIGNED_BYTE 0x1401
+#define GL_UNSIGNED_BYTE_2_3_3_REV 0x8362
+#define GL_UNSIGNED_BYTE_3_3_2 0x8032
+#define GL_UNSIGNED_INT 0x1405
+#define GL_UNSIGNED_INT_10F_11F_11F_REV 0x8C3B
+#define GL_UNSIGNED_INT_10_10_10_2 0x8036
+#define GL_UNSIGNED_INT_24_8 0x84FA
+#define GL_UNSIGNED_INT_2_10_10_10_REV 0x8368
+#define GL_UNSIGNED_INT_5_9_9_9_REV 0x8C3E
+#define GL_UNSIGNED_INT_8_8_8_8 0x8035
+#define GL_UNSIGNED_INT_8_8_8_8_REV 0x8367
+#define GL_UNSIGNED_INT_SAMPLER_1D 0x8DD1
+#define GL_UNSIGNED_INT_SAMPLER_1D_ARRAY 0x8DD6
+#define GL_UNSIGNED_INT_SAMPLER_1D_ARRAY_EXT 0x8DD6
+#define GL_UNSIGNED_INT_SAMPLER_1D_EXT 0x8DD1
+#define GL_UNSIGNED_INT_SAMPLER_2D 0x8DD2
+#define GL_UNSIGNED_INT_SAMPLER_2D_ARRAY 0x8DD7
+#define GL_UNSIGNED_INT_SAMPLER_2D_ARRAY_EXT 0x8DD7
+#define GL_UNSIGNED_INT_SAMPLER_2D_EXT 0x8DD2
+#define GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE 0x910A
+#define GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910D
+#define GL_UNSIGNED_INT_SAMPLER_2D_RECT 0x8DD5
+#define GL_UNSIGNED_INT_SAMPLER_2D_RECT_EXT 0x8DD5
+#define GL_UNSIGNED_INT_SAMPLER_3D 0x8DD3
+#define GL_UNSIGNED_INT_SAMPLER_3D_EXT 0x8DD3
+#define GL_UNSIGNED_INT_SAMPLER_BUFFER 0x8DD8
+#define GL_UNSIGNED_INT_SAMPLER_BUFFER_EXT 0x8DD8
+#define GL_UNSIGNED_INT_SAMPLER_CUBE 0x8DD4
+#define GL_UNSIGNED_INT_SAMPLER_CUBE_EXT 0x8DD4
+#define GL_UNSIGNED_INT_SAMPLER_RENDERBUFFER_NV 0x8E58
+#define GL_UNSIGNED_INT_VEC2 0x8DC6
+#define GL_UNSIGNED_INT_VEC2_EXT 0x8DC6
+#define GL_UNSIGNED_INT_VEC3 0x8DC7
+#define GL_UNSIGNED_INT_VEC3_EXT 0x8DC7
+#define GL_UNSIGNED_INT_VEC4 0x8DC8
+#define GL_UNSIGNED_INT_VEC4_EXT 0x8DC8
+#define GL_UNSIGNED_NORMALIZED 0x8C17
+#define GL_UNSIGNED_SHORT 0x1403
+#define GL_UNSIGNED_SHORT_1_5_5_5_REV 0x8366
+#define GL_UNSIGNED_SHORT_4_4_4_4 0x8033
+#define GL_UNSIGNED_SHORT_4_4_4_4_REV 0x8365
+#define GL_UNSIGNED_SHORT_5_5_5_1 0x8034
+#define GL_UNSIGNED_SHORT_5_6_5 0x8363
+#define GL_UNSIGNED_SHORT_5_6_5_REV 0x8364
+#define GL_UPPER_LEFT 0x8CA2
+#define GL_VALIDATE_STATUS 0x8B83
+#define GL_VENDOR 0x1F00
+#define GL_VERSION 0x1F02
+#define GL_VERTEX_ARRAY_BINDING 0x85B5
+#define GL_VERTEX_ARRAY_BINDING_APPLE 0x85B5
+#define GL_VERTEX_ARRAY_BUFFER_BINDING_ARB 0x8896
+#define GL_VERTEX_ARRAY_COUNT_EXT 0x807D
+#define GL_VERTEX_ARRAY_EXT 0x8074
+#define GL_VERTEX_ARRAY_POINTER_EXT 0x808E
+#define GL_VERTEX_ARRAY_SIZE_EXT 0x807A
+#define GL_VERTEX_ARRAY_STRIDE_EXT 0x807C
+#define GL_VERTEX_ARRAY_TYPE_EXT 0x807B
+#define GL_VERTEX_ATTRIB_ARRAY0_NV 0x8650
+#define GL_VERTEX_ATTRIB_ARRAY10_NV 0x865A
+#define GL_VERTEX_ATTRIB_ARRAY11_NV 0x865B
+#define GL_VERTEX_ATTRIB_ARRAY12_NV 0x865C
+#define GL_VERTEX_ATTRIB_ARRAY13_NV 0x865D
+#define GL_VERTEX_ATTRIB_ARRAY14_NV 0x865E
+#define GL_VERTEX_ATTRIB_ARRAY15_NV 0x865F
+#define GL_VERTEX_ATTRIB_ARRAY1_NV 0x8651
+#define GL_VERTEX_ATTRIB_ARRAY2_NV 0x8652
+#define GL_VERTEX_ATTRIB_ARRAY3_NV 0x8653
+#define GL_VERTEX_ATTRIB_ARRAY4_NV 0x8654
+#define GL_VERTEX_ATTRIB_ARRAY5_NV 0x8655
+#define GL_VERTEX_ATTRIB_ARRAY6_NV 0x8656
+#define GL_VERTEX_ATTRIB_ARRAY7_NV 0x8657
+#define GL_VERTEX_ATTRIB_ARRAY8_NV 0x8658
+#define GL_VERTEX_ATTRIB_ARRAY9_NV 0x8659
+#define GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING 0x889F
+#define GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB 0x889F
+#define GL_VERTEX_ATTRIB_ARRAY_ENABLED 0x8622
+#define GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB 0x8622
+#define GL_VERTEX_ATTRIB_ARRAY_INTEGER 0x88FD
+#define GL_VERTEX_ATTRIB_ARRAY_INTEGER_EXT 0x88FD
+#define GL_VERTEX_ATTRIB_ARRAY_INTEGER_NV 0x88FD
+#define GL_VERTEX_ATTRIB_ARRAY_NORMALIZED 0x886A
+#define GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB 0x886A
+#define GL_VERTEX_ATTRIB_ARRAY_POINTER 0x8645
+#define GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB 0x8645
+#define GL_VERTEX_ATTRIB_ARRAY_SIZE 0x8623
+#define GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB 0x8623
+#define GL_VERTEX_ATTRIB_ARRAY_STRIDE 0x8624
+#define GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB 0x8624
+#define GL_VERTEX_ATTRIB_ARRAY_TYPE 0x8625
+#define GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB 0x8625
+#define GL_VERTEX_ID_NV 0x8C7B
+#define GL_VERTEX_PROGRAM_ARB 0x8620
+#define GL_VERTEX_PROGRAM_BINDING_NV 0x864A
+#define GL_VERTEX_PROGRAM_NV 0x8620
+#define GL_VERTEX_PROGRAM_POINT_SIZE 0x8642
+#define GL_VERTEX_PROGRAM_POINT_SIZE_ARB 0x8642
+#define GL_VERTEX_PROGRAM_POINT_SIZE_NV 0x8642
+#define GL_VERTEX_PROGRAM_TWO_SIDE_ARB 0x8643
+#define GL_VERTEX_PROGRAM_TWO_SIDE_NV 0x8643
+#define GL_VERTEX_SHADER 0x8B31
+#define GL_VERTEX_SHADER_ARB 0x8B31
+#define GL_VERTEX_STATE_PROGRAM_NV 0x8621
+#define GL_VIEWPORT 0x0BA2
+#define GL_WAIT_FAILED 0x911D
+#define GL_WEIGHT_ARRAY_BUFFER_BINDING_ARB 0x889E
+#define GL_WRITE_ONLY 0x88B9
+#define GL_WRITE_ONLY_ARB 0x88B9
+#define GL_XOR 0x1506
+#define GL_ZERO 0
+
+
+#include <KHR/khrplatform.h>
+typedef unsigned int GLenum;
+typedef unsigned char GLboolean;
+typedef unsigned int GLbitfield;
+typedef void GLvoid;
+typedef khronos_int8_t GLbyte;
+typedef khronos_uint8_t GLubyte;
+typedef khronos_int16_t GLshort;
+typedef khronos_uint16_t GLushort;
+typedef int GLint;
+typedef unsigned int GLuint;
+typedef khronos_int32_t GLclampx;
+typedef int GLsizei;
+typedef khronos_float_t GLfloat;
+typedef khronos_float_t GLclampf;
+typedef double GLdouble;
+typedef double GLclampd;
+typedef void *GLeglClientBufferEXT;
+typedef void *GLeglImageOES;
+typedef char GLchar;
+typedef char GLcharARB;
+#ifdef __APPLE__
+typedef void *GLhandleARB;
+#else
+typedef unsigned int GLhandleARB;
+#endif
+typedef khronos_uint16_t GLhalf;
+typedef khronos_uint16_t GLhalfARB;
+typedef khronos_int32_t GLfixed;
+#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && (__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ > 1060)
+typedef khronos_intptr_t GLintptr;
+#else
+typedef khronos_intptr_t GLintptr;
+#endif
+#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && (__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ > 1060)
+typedef khronos_intptr_t GLintptrARB;
+#else
+typedef khronos_intptr_t GLintptrARB;
+#endif
+#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && (__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ > 1060)
+typedef khronos_ssize_t GLsizeiptr;
+#else
+typedef khronos_ssize_t GLsizeiptr;
+#endif
+#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && (__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ > 1060)
+typedef khronos_ssize_t GLsizeiptrARB;
+#else
+typedef khronos_ssize_t GLsizeiptrARB;
+#endif
+typedef khronos_int64_t GLint64;
+typedef khronos_int64_t GLint64EXT;
+typedef khronos_uint64_t GLuint64;
+typedef khronos_uint64_t GLuint64EXT;
+typedef struct __GLsync *GLsync;
+struct _cl_context;
+struct _cl_event;
+typedef void (GLAD_API_PTR *GLDEBUGPROC)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam);
+typedef void (GLAD_API_PTR *GLDEBUGPROCARB)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam);
+typedef void (GLAD_API_PTR *GLDEBUGPROCKHR)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam);
+typedef void (GLAD_API_PTR *GLDEBUGPROCAMD)(GLuint id,GLenum category,GLenum severity,GLsizei length,const GLchar *message,void *userParam);
+typedef unsigned short GLhalfNV;
+typedef GLintptr GLvdpauSurfaceNV;
+typedef void (GLAD_API_PTR *GLVULKANPROCNV)(void);
+
+
+#define GL_VERSION_1_0 1
+#define GL_VERSION_1_1 1
+#define GL_VERSION_1_2 1
+#define GL_VERSION_1_3 1
+#define GL_VERSION_1_4 1
+#define GL_VERSION_1_5 1
+#define GL_VERSION_2_0 1
+#define GL_VERSION_2_1 1
+#define GL_VERSION_3_0 1
+#define GL_VERSION_3_1 1
+#define GL_VERSION_3_2 1
+#define GL_APPLE_flush_buffer_range 1
+#define GL_APPLE_vertex_array_object 1
+#define GL_ARB_color_buffer_float 1
+#define GL_ARB_copy_buffer 1
+#define GL_ARB_draw_buffers 1
+#define GL_ARB_draw_elements_base_vertex 1
+#define GL_ARB_draw_instanced 1
+#define GL_ARB_framebuffer_object 1
+#define GL_ARB_geometry_shader4 1
+#define GL_ARB_imaging 1
+#define GL_ARB_map_buffer_range 1
+#define GL_ARB_multisample 1
+#define GL_ARB_multitexture 1
+#define GL_ARB_occlusion_query 1
+#define GL_ARB_point_parameters 1
+#define GL_ARB_provoking_vertex 1
+#define GL_ARB_shader_objects 1
+#define GL_ARB_sync 1
+#define GL_ARB_texture_buffer_object 1
+#define GL_ARB_texture_compression 1
+#define GL_ARB_texture_multisample 1
+#define GL_ARB_uniform_buffer_object 1
+#define GL_ARB_vertex_array_object 1
+#define GL_ARB_vertex_buffer_object 1
+#define GL_ARB_vertex_program 1
+#define GL_ARB_vertex_shader 1
+#define GL_ATI_draw_buffers 1
+#define GL_ATI_separate_stencil 1
+#define GL_EXT_blend_color 1
+#define GL_EXT_blend_equation_separate 1
+#define GL_EXT_blend_func_separate 1
+#define GL_EXT_blend_minmax 1
+#define GL_EXT_copy_texture 1
+#define GL_EXT_direct_state_access 1
+#define GL_EXT_draw_buffers2 1
+#define GL_EXT_draw_instanced 1
+#define GL_EXT_draw_range_elements 1
+#define GL_EXT_framebuffer_blit 1
+#define GL_EXT_framebuffer_multisample 1
+#define GL_EXT_framebuffer_object 1
+#define GL_EXT_gpu_shader4 1
+#define GL_EXT_multi_draw_arrays 1
+#define GL_EXT_point_parameters 1
+#define GL_EXT_provoking_vertex 1
+#define GL_EXT_subtexture 1
+#define GL_EXT_texture3D 1
+#define GL_EXT_texture_array 1
+#define GL_EXT_texture_buffer_object 1
+#define GL_EXT_texture_integer 1
+#define GL_EXT_texture_object 1
+#define GL_EXT_transform_feedback 1
+#define GL_EXT_vertex_array 1
+#define GL_INGR_blend_func_separate 1
+#define GL_NVX_conditional_render 1
+#define GL_NV_conditional_render 1
+#define GL_NV_explicit_multisample 1
+#define GL_NV_geometry_program4 1
+#define GL_NV_point_sprite 1
+#define GL_NV_transform_feedback 1
+#define GL_NV_vertex_program 1
+#define GL_NV_vertex_program4 1
+#define GL_SGIS_point_parameters 1
+
+
+typedef void (GLAD_API_PTR *PFNGLACTIVETEXTUREPROC)(GLenum texture);
+typedef void (GLAD_API_PTR *PFNGLACTIVETEXTUREARBPROC)(GLenum texture);
+typedef void (GLAD_API_PTR *PFNGLACTIVEVARYINGNVPROC)(GLuint program, const GLchar * name);
+typedef GLboolean (GLAD_API_PTR *PFNGLAREPROGRAMSRESIDENTNVPROC)(GLsizei n, const GLuint * programs, GLboolean * residences);
+typedef GLboolean (GLAD_API_PTR *PFNGLARETEXTURESRESIDENTEXTPROC)(GLsizei n, const GLuint * textures, GLboolean * residences);
+typedef void (GLAD_API_PTR *PFNGLARRAYELEMENTEXTPROC)(GLint i);
+typedef void (GLAD_API_PTR *PFNGLATTACHOBJECTARBPROC)(GLhandleARB containerObj, GLhandleARB obj);
+typedef void (GLAD_API_PTR *PFNGLATTACHSHADERPROC)(GLuint program, GLuint shader);
+typedef void (GLAD_API_PTR *PFNGLBEGINCONDITIONALRENDERPROC)(GLuint id, GLenum mode);
+typedef void (GLAD_API_PTR *PFNGLBEGINCONDITIONALRENDERNVPROC)(GLuint id, GLenum mode);
+typedef void (GLAD_API_PTR *PFNGLBEGINCONDITIONALRENDERNVXPROC)(GLuint id);
+typedef void (GLAD_API_PTR *PFNGLBEGINQUERYPROC)(GLenum target, GLuint id);
+typedef void (GLAD_API_PTR *PFNGLBEGINQUERYARBPROC)(GLenum target, GLuint id);
+typedef void (GLAD_API_PTR *PFNGLBEGINTRANSFORMFEEDBACKPROC)(GLenum primitiveMode);
+typedef void (GLAD_API_PTR *PFNGLBEGINTRANSFORMFEEDBACKEXTPROC)(GLenum primitiveMode);
+typedef void (GLAD_API_PTR *PFNGLBEGINTRANSFORMFEEDBACKNVPROC)(GLenum primitiveMode);
+typedef void (GLAD_API_PTR *PFNGLBINDATTRIBLOCATIONPROC)(GLuint program, GLuint index, const GLchar * name);
+typedef void (GLAD_API_PTR *PFNGLBINDATTRIBLOCATIONARBPROC)(GLhandleARB programObj, GLuint index, const GLcharARB * name);
+typedef void (GLAD_API_PTR *PFNGLBINDBUFFERPROC)(GLenum target, GLuint buffer);
+typedef void (GLAD_API_PTR *PFNGLBINDBUFFERARBPROC)(GLenum target, GLuint buffer);
+typedef void (GLAD_API_PTR *PFNGLBINDBUFFERBASEPROC)(GLenum target, GLuint index, GLuint buffer);
+typedef void (GLAD_API_PTR *PFNGLBINDBUFFERBASEEXTPROC)(GLenum target, GLuint index, GLuint buffer);
+typedef void (GLAD_API_PTR *PFNGLBINDBUFFERBASENVPROC)(GLenum target, GLuint index, GLuint buffer);
+typedef void (GLAD_API_PTR *PFNGLBINDBUFFEROFFSETEXTPROC)(GLenum target, GLuint index, GLuint buffer, GLintptr offset);
+typedef void (GLAD_API_PTR *PFNGLBINDBUFFEROFFSETNVPROC)(GLenum target, GLuint index, GLuint buffer, GLintptr offset);
+typedef void (GLAD_API_PTR *PFNGLBINDBUFFERRANGEPROC)(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size);
+typedef void (GLAD_API_PTR *PFNGLBINDBUFFERRANGEEXTPROC)(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size);
+typedef void (GLAD_API_PTR *PFNGLBINDBUFFERRANGENVPROC)(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size);
+typedef void (GLAD_API_PTR *PFNGLBINDFRAGDATALOCATIONPROC)(GLuint program, GLuint color, const GLchar * name);
+typedef void (GLAD_API_PTR *PFNGLBINDFRAGDATALOCATIONEXTPROC)(GLuint program, GLuint color, const GLchar * name);
+typedef void (GLAD_API_PTR *PFNGLBINDFRAMEBUFFERPROC)(GLenum target, GLuint framebuffer);
+typedef void (GLAD_API_PTR *PFNGLBINDFRAMEBUFFEREXTPROC)(GLenum target, GLuint framebuffer);
+typedef void (GLAD_API_PTR *PFNGLBINDMULTITEXTUREEXTPROC)(GLenum texunit, GLenum target, GLuint texture);
+typedef void (GLAD_API_PTR *PFNGLBINDPROGRAMARBPROC)(GLenum target, GLuint program);
+typedef void (GLAD_API_PTR *PFNGLBINDPROGRAMNVPROC)(GLenum target, GLuint id);
+typedef void (GLAD_API_PTR *PFNGLBINDRENDERBUFFERPROC)(GLenum target, GLuint renderbuffer);
+typedef void (GLAD_API_PTR *PFNGLBINDRENDERBUFFEREXTPROC)(GLenum target, GLuint renderbuffer);
+typedef void (GLAD_API_PTR *PFNGLBINDTEXTUREPROC)(GLenum target, GLuint texture);
+typedef void (GLAD_API_PTR *PFNGLBINDTEXTUREEXTPROC)(GLenum target, GLuint texture);
+typedef void (GLAD_API_PTR *PFNGLBINDVERTEXARRAYPROC)(GLuint array);
+typedef void (GLAD_API_PTR *PFNGLBINDVERTEXARRAYAPPLEPROC)(GLuint array);
+typedef void (GLAD_API_PTR *PFNGLBLENDCOLORPROC)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
+typedef void (GLAD_API_PTR *PFNGLBLENDCOLOREXTPROC)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
+typedef void (GLAD_API_PTR *PFNGLBLENDEQUATIONPROC)(GLenum mode);
+typedef void (GLAD_API_PTR *PFNGLBLENDEQUATIONEXTPROC)(GLenum mode);
+typedef void (GLAD_API_PTR *PFNGLBLENDEQUATIONSEPARATEPROC)(GLenum modeRGB, GLenum modeAlpha);
+typedef void (GLAD_API_PTR *PFNGLBLENDEQUATIONSEPARATEEXTPROC)(GLenum modeRGB, GLenum modeAlpha);
+typedef void (GLAD_API_PTR *PFNGLBLENDFUNCPROC)(GLenum sfactor, GLenum dfactor);
+typedef void (GLAD_API_PTR *PFNGLBLENDFUNCSEPARATEPROC)(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
+typedef void (GLAD_API_PTR *PFNGLBLENDFUNCSEPARATEEXTPROC)(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
+typedef void (GLAD_API_PTR *PFNGLBLENDFUNCSEPARATEINGRPROC)(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
+typedef void (GLAD_API_PTR *PFNGLBLITFRAMEBUFFERPROC)(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
+typedef void (GLAD_API_PTR *PFNGLBLITFRAMEBUFFEREXTPROC)(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
+typedef void (GLAD_API_PTR *PFNGLBUFFERDATAPROC)(GLenum target, GLsizeiptr size, const void * data, GLenum usage);
+typedef void (GLAD_API_PTR *PFNGLBUFFERDATAARBPROC)(GLenum target, GLsizeiptrARB size, const void * data, GLenum usage);
+typedef void (GLAD_API_PTR *PFNGLBUFFERPARAMETERIAPPLEPROC)(GLenum target, GLenum pname, GLint param);
+typedef void (GLAD_API_PTR *PFNGLBUFFERSUBDATAPROC)(GLenum target, GLintptr offset, GLsizeiptr size, const void * data);
+typedef void (GLAD_API_PTR *PFNGLBUFFERSUBDATAARBPROC)(GLenum target, GLintptrARB offset, GLsizeiptrARB size, const void * data);
+typedef GLenum (GLAD_API_PTR *PFNGLCHECKFRAMEBUFFERSTATUSPROC)(GLenum target);
+typedef GLenum (GLAD_API_PTR *PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC)(GLenum target);
+typedef GLenum (GLAD_API_PTR *PFNGLCHECKNAMEDFRAMEBUFFERSTATUSEXTPROC)(GLuint framebuffer, GLenum target);
+typedef void (GLAD_API_PTR *PFNGLCLAMPCOLORPROC)(GLenum target, GLenum clamp);
+typedef void (GLAD_API_PTR *PFNGLCLAMPCOLORARBPROC)(GLenum target, GLenum clamp);
+typedef void (GLAD_API_PTR *PFNGLCLEARPROC)(GLbitfield mask);
+typedef void (GLAD_API_PTR *PFNGLCLEARBUFFERFIPROC)(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil);
+typedef void (GLAD_API_PTR *PFNGLCLEARBUFFERFVPROC)(GLenum buffer, GLint drawbuffer, const GLfloat * value);
+typedef void (GLAD_API_PTR *PFNGLCLEARBUFFERIVPROC)(GLenum buffer, GLint drawbuffer, const GLint * value);
+typedef void (GLAD_API_PTR *PFNGLCLEARBUFFERUIVPROC)(GLenum buffer, GLint drawbuffer, const GLuint * value);
+typedef void (GLAD_API_PTR *PFNGLCLEARCOLORPROC)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
+typedef void (GLAD_API_PTR *PFNGLCLEARCOLORIIEXTPROC)(GLint red, GLint green, GLint blue, GLint alpha);
+typedef void (GLAD_API_PTR *PFNGLCLEARCOLORIUIEXTPROC)(GLuint red, GLuint green, GLuint blue, GLuint alpha);
+typedef void (GLAD_API_PTR *PFNGLCLEARDEPTHPROC)(GLdouble depth);
+typedef void (GLAD_API_PTR *PFNGLCLEARNAMEDBUFFERDATAEXTPROC)(GLuint buffer, GLenum internalformat, GLenum format, GLenum type, const void * data);
+typedef void (GLAD_API_PTR *PFNGLCLEARNAMEDBUFFERSUBDATAEXTPROC)(GLuint buffer, GLenum internalformat, GLsizeiptr offset, GLsizeiptr size, GLenum format, GLenum type, const void * data);
+typedef void (GLAD_API_PTR *PFNGLCLEARSTENCILPROC)(GLint s);
+typedef void (GLAD_API_PTR *PFNGLCLIENTACTIVETEXTUREARBPROC)(GLenum texture);
+typedef void (GLAD_API_PTR *PFNGLCLIENTATTRIBDEFAULTEXTPROC)(GLbitfield mask);
+typedef GLenum (GLAD_API_PTR *PFNGLCLIENTWAITSYNCPROC)(GLsync sync, GLbitfield flags, GLuint64 timeout);
+typedef void (GLAD_API_PTR *PFNGLCOLORMASKPROC)(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
+typedef void (GLAD_API_PTR *PFNGLCOLORMASKINDEXEDEXTPROC)(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a);
+typedef void (GLAD_API_PTR *PFNGLCOLORMASKIPROC)(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a);
+typedef void (GLAD_API_PTR *PFNGLCOLORPOINTEREXTPROC)(GLint size, GLenum type, GLsizei stride, GLsizei count, const void * pointer);
+typedef void (GLAD_API_PTR *PFNGLCOMPILESHADERPROC)(GLuint shader);
+typedef void (GLAD_API_PTR *PFNGLCOMPILESHADERARBPROC)(GLhandleARB shaderObj);
+typedef void (GLAD_API_PTR *PFNGLCOMPRESSEDMULTITEXIMAGE1DEXTPROC)(GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void * bits);
+typedef void (GLAD_API_PTR *PFNGLCOMPRESSEDMULTITEXIMAGE2DEXTPROC)(GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void * bits);
+typedef void (GLAD_API_PTR *PFNGLCOMPRESSEDMULTITEXIMAGE3DEXTPROC)(GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void * bits);
+typedef void (GLAD_API_PTR *PFNGLCOMPRESSEDMULTITEXSUBIMAGE1DEXTPROC)(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void * bits);
+typedef void (GLAD_API_PTR *PFNGLCOMPRESSEDMULTITEXSUBIMAGE2DEXTPROC)(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void * bits);
+typedef void (GLAD_API_PTR *PFNGLCOMPRESSEDMULTITEXSUBIMAGE3DEXTPROC)(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void * bits);
+typedef void (GLAD_API_PTR *PFNGLCOMPRESSEDTEXIMAGE1DPROC)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void * data);
+typedef void (GLAD_API_PTR *PFNGLCOMPRESSEDTEXIMAGE1DARBPROC)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void * data);
+typedef void (GLAD_API_PTR *PFNGLCOMPRESSEDTEXIMAGE2DPROC)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void * data);
+typedef void (GLAD_API_PTR *PFNGLCOMPRESSEDTEXIMAGE2DARBPROC)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void * data);
+typedef void (GLAD_API_PTR *PFNGLCOMPRESSEDTEXIMAGE3DPROC)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void * data);
+typedef void (GLAD_API_PTR *PFNGLCOMPRESSEDTEXIMAGE3DARBPROC)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void * data);
+typedef void (GLAD_API_PTR *PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void * data);
+typedef void (GLAD_API_PTR *PFNGLCOMPRESSEDTEXSUBIMAGE1DARBPROC)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void * data);
+typedef void (GLAD_API_PTR *PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void * data);
+typedef void (GLAD_API_PTR *PFNGLCOMPRESSEDTEXSUBIMAGE2DARBPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void * data);
+typedef void (GLAD_API_PTR *PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void * data);
+typedef void (GLAD_API_PTR *PFNGLCOMPRESSEDTEXSUBIMAGE3DARBPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void * data);
+typedef void (GLAD_API_PTR *PFNGLCOMPRESSEDTEXTUREIMAGE1DEXTPROC)(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void * bits);
+typedef void (GLAD_API_PTR *PFNGLCOMPRESSEDTEXTUREIMAGE2DEXTPROC)(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void * bits);
+typedef void (GLAD_API_PTR *PFNGLCOMPRESSEDTEXTUREIMAGE3DEXTPROC)(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void * bits);
+typedef void (GLAD_API_PTR *PFNGLCOMPRESSEDTEXTURESUBIMAGE1DEXTPROC)(GLuint texture, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void * bits);
+typedef void (GLAD_API_PTR *PFNGLCOMPRESSEDTEXTURESUBIMAGE2DEXTPROC)(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void * bits);
+typedef void (GLAD_API_PTR *PFNGLCOMPRESSEDTEXTURESUBIMAGE3DEXTPROC)(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void * bits);
+typedef void (GLAD_API_PTR *PFNGLCOPYBUFFERSUBDATAPROC)(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size);
+typedef void (GLAD_API_PTR *PFNGLCOPYMULTITEXIMAGE1DEXTPROC)(GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border);
+typedef void (GLAD_API_PTR *PFNGLCOPYMULTITEXIMAGE2DEXTPROC)(GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
+typedef void (GLAD_API_PTR *PFNGLCOPYMULTITEXSUBIMAGE1DEXTPROC)(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
+typedef void (GLAD_API_PTR *PFNGLCOPYMULTITEXSUBIMAGE2DEXTPROC)(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
+typedef void (GLAD_API_PTR *PFNGLCOPYMULTITEXSUBIMAGE3DEXTPROC)(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
+typedef void (GLAD_API_PTR *PFNGLCOPYTEXIMAGE1DPROC)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border);
+typedef void (GLAD_API_PTR *PFNGLCOPYTEXIMAGE1DEXTPROC)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border);
+typedef void (GLAD_API_PTR *PFNGLCOPYTEXIMAGE2DPROC)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
+typedef void (GLAD_API_PTR *PFNGLCOPYTEXIMAGE2DEXTPROC)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
+typedef void (GLAD_API_PTR *PFNGLCOPYTEXSUBIMAGE1DPROC)(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
+typedef void (GLAD_API_PTR *PFNGLCOPYTEXSUBIMAGE1DEXTPROC)(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
+typedef void (GLAD_API_PTR *PFNGLCOPYTEXSUBIMAGE2DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
+typedef void (GLAD_API_PTR *PFNGLCOPYTEXSUBIMAGE2DEXTPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
+typedef void (GLAD_API_PTR *PFNGLCOPYTEXSUBIMAGE3DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
+typedef void (GLAD_API_PTR *PFNGLCOPYTEXSUBIMAGE3DEXTPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
+typedef void (GLAD_API_PTR *PFNGLCOPYTEXTUREIMAGE1DEXTPROC)(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border);
+typedef void (GLAD_API_PTR *PFNGLCOPYTEXTUREIMAGE2DEXTPROC)(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
+typedef void (GLAD_API_PTR *PFNGLCOPYTEXTURESUBIMAGE1DEXTPROC)(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
+typedef void (GLAD_API_PTR *PFNGLCOPYTEXTURESUBIMAGE2DEXTPROC)(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
+typedef void (GLAD_API_PTR *PFNGLCOPYTEXTURESUBIMAGE3DEXTPROC)(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
+typedef GLuint (GLAD_API_PTR *PFNGLCREATEPROGRAMPROC)(void);
+typedef GLhandleARB (GLAD_API_PTR *PFNGLCREATEPROGRAMOBJECTARBPROC)(void);
+typedef GLuint (GLAD_API_PTR *PFNGLCREATESHADERPROC)(GLenum type);
+typedef GLhandleARB (GLAD_API_PTR *PFNGLCREATESHADEROBJECTARBPROC)(GLenum shaderType);
+typedef void (GLAD_API_PTR *PFNGLCULLFACEPROC)(GLenum mode);
+typedef void (GLAD_API_PTR *PFNGLDELETEBUFFERSPROC)(GLsizei n, const GLuint * buffers);
+typedef void (GLAD_API_PTR *PFNGLDELETEBUFFERSARBPROC)(GLsizei n, const GLuint * buffers);
+typedef void (GLAD_API_PTR *PFNGLDELETEFRAMEBUFFERSPROC)(GLsizei n, const GLuint * framebuffers);
+typedef void (GLAD_API_PTR *PFNGLDELETEFRAMEBUFFERSEXTPROC)(GLsizei n, const GLuint * framebuffers);
+typedef void (GLAD_API_PTR *PFNGLDELETEOBJECTARBPROC)(GLhandleARB obj);
+typedef void (GLAD_API_PTR *PFNGLDELETEPROGRAMPROC)(GLuint program);
+typedef void (GLAD_API_PTR *PFNGLDELETEPROGRAMSARBPROC)(GLsizei n, const GLuint * programs);
+typedef void (GLAD_API_PTR *PFNGLDELETEPROGRAMSNVPROC)(GLsizei n, const GLuint * programs);
+typedef void (GLAD_API_PTR *PFNGLDELETEQUERIESPROC)(GLsizei n, const GLuint * ids);
+typedef void (GLAD_API_PTR *PFNGLDELETEQUERIESARBPROC)(GLsizei n, const GLuint * ids);
+typedef void (GLAD_API_PTR *PFNGLDELETERENDERBUFFERSPROC)(GLsizei n, const GLuint * renderbuffers);
+typedef void (GLAD_API_PTR *PFNGLDELETERENDERBUFFERSEXTPROC)(GLsizei n, const GLuint * renderbuffers);
+typedef void (GLAD_API_PTR *PFNGLDELETESHADERPROC)(GLuint shader);
+typedef void (GLAD_API_PTR *PFNGLDELETESYNCPROC)(GLsync sync);
+typedef void (GLAD_API_PTR *PFNGLDELETETEXTURESPROC)(GLsizei n, const GLuint * textures);
+typedef void (GLAD_API_PTR *PFNGLDELETETEXTURESEXTPROC)(GLsizei n, const GLuint * textures);
+typedef void (GLAD_API_PTR *PFNGLDELETEVERTEXARRAYSPROC)(GLsizei n, const GLuint * arrays);
+typedef void (GLAD_API_PTR *PFNGLDELETEVERTEXARRAYSAPPLEPROC)(GLsizei n, const GLuint * arrays);
+typedef void (GLAD_API_PTR *PFNGLDEPTHFUNCPROC)(GLenum func);
+typedef void (GLAD_API_PTR *PFNGLDEPTHMASKPROC)(GLboolean flag);
+typedef void (GLAD_API_PTR *PFNGLDEPTHRANGEPROC)(GLdouble n, GLdouble f);
+typedef void (GLAD_API_PTR *PFNGLDETACHOBJECTARBPROC)(GLhandleARB containerObj, GLhandleARB attachedObj);
+typedef void (GLAD_API_PTR *PFNGLDETACHSHADERPROC)(GLuint program, GLuint shader);
+typedef void (GLAD_API_PTR *PFNGLDISABLEPROC)(GLenum cap);
+typedef void (GLAD_API_PTR *PFNGLDISABLECLIENTSTATEINDEXEDEXTPROC)(GLenum array, GLuint index);
+typedef void (GLAD_API_PTR *PFNGLDISABLECLIENTSTATEIEXTPROC)(GLenum array, GLuint index);
+typedef void (GLAD_API_PTR *PFNGLDISABLEINDEXEDEXTPROC)(GLenum target, GLuint index);
+typedef void (GLAD_API_PTR *PFNGLDISABLEVERTEXARRAYATTRIBEXTPROC)(GLuint vaobj, GLuint index);
+typedef void (GLAD_API_PTR *PFNGLDISABLEVERTEXARRAYEXTPROC)(GLuint vaobj, GLenum array);
+typedef void (GLAD_API_PTR *PFNGLDISABLEVERTEXATTRIBARRAYPROC)(GLuint index);
+typedef void (GLAD_API_PTR *PFNGLDISABLEVERTEXATTRIBARRAYARBPROC)(GLuint index);
+typedef void (GLAD_API_PTR *PFNGLDISABLEIPROC)(GLenum target, GLuint index);
+typedef void (GLAD_API_PTR *PFNGLDRAWARRAYSPROC)(GLenum mode, GLint first, GLsizei count);
+typedef void (GLAD_API_PTR *PFNGLDRAWARRAYSEXTPROC)(GLenum mode, GLint first, GLsizei count);
+typedef void (GLAD_API_PTR *PFNGLDRAWARRAYSINSTANCEDPROC)(GLenum mode, GLint first, GLsizei count, GLsizei instancecount);
+typedef void (GLAD_API_PTR *PFNGLDRAWARRAYSINSTANCEDARBPROC)(GLenum mode, GLint first, GLsizei count, GLsizei primcount);
+typedef void (GLAD_API_PTR *PFNGLDRAWARRAYSINSTANCEDEXTPROC)(GLenum mode, GLint start, GLsizei count, GLsizei primcount);
+typedef void (GLAD_API_PTR *PFNGLDRAWBUFFERPROC)(GLenum buf);
+typedef void (GLAD_API_PTR *PFNGLDRAWBUFFERSPROC)(GLsizei n, const GLenum * bufs);
+typedef void (GLAD_API_PTR *PFNGLDRAWBUFFERSARBPROC)(GLsizei n, const GLenum * bufs);
+typedef void (GLAD_API_PTR *PFNGLDRAWBUFFERSATIPROC)(GLsizei n, const GLenum * bufs);
+typedef void (GLAD_API_PTR *PFNGLDRAWELEMENTSPROC)(GLenum mode, GLsizei count, GLenum type, const void * indices);
+typedef void (GLAD_API_PTR *PFNGLDRAWELEMENTSBASEVERTEXPROC)(GLenum mode, GLsizei count, GLenum type, const void * indices, GLint basevertex);
+typedef void (GLAD_API_PTR *PFNGLDRAWELEMENTSINSTANCEDPROC)(GLenum mode, GLsizei count, GLenum type, const void * indices, GLsizei instancecount);
+typedef void (GLAD_API_PTR *PFNGLDRAWELEMENTSINSTANCEDARBPROC)(GLenum mode, GLsizei count, GLenum type, const void * indices, GLsizei primcount);
+typedef void (GLAD_API_PTR *PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC)(GLenum mode, GLsizei count, GLenum type, const void * indices, GLsizei instancecount, GLint basevertex);
+typedef void (GLAD_API_PTR *PFNGLDRAWELEMENTSINSTANCEDEXTPROC)(GLenum mode, GLsizei count, GLenum type, const void * indices, GLsizei primcount);
+typedef void (GLAD_API_PTR *PFNGLDRAWRANGEELEMENTSPROC)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void * indices);
+typedef void (GLAD_API_PTR *PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void * indices, GLint basevertex);
+typedef void (GLAD_API_PTR *PFNGLDRAWRANGEELEMENTSEXTPROC)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void * indices);
+typedef void (GLAD_API_PTR *PFNGLEDGEFLAGPOINTEREXTPROC)(GLsizei stride, GLsizei count, const GLboolean * pointer);
+typedef void (GLAD_API_PTR *PFNGLENABLEPROC)(GLenum cap);
+typedef void (GLAD_API_PTR *PFNGLENABLECLIENTSTATEINDEXEDEXTPROC)(GLenum array, GLuint index);
+typedef void (GLAD_API_PTR *PFNGLENABLECLIENTSTATEIEXTPROC)(GLenum array, GLuint index);
+typedef void (GLAD_API_PTR *PFNGLENABLEINDEXEDEXTPROC)(GLenum target, GLuint index);
+typedef void (GLAD_API_PTR *PFNGLENABLEVERTEXARRAYATTRIBEXTPROC)(GLuint vaobj, GLuint index);
+typedef void (GLAD_API_PTR *PFNGLENABLEVERTEXARRAYEXTPROC)(GLuint vaobj, GLenum array);
+typedef void (GLAD_API_PTR *PFNGLENABLEVERTEXATTRIBARRAYPROC)(GLuint index);
+typedef void (GLAD_API_PTR *PFNGLENABLEVERTEXATTRIBARRAYARBPROC)(GLuint index);
+typedef void (GLAD_API_PTR *PFNGLENABLEIPROC)(GLenum target, GLuint index);
+typedef void (GLAD_API_PTR *PFNGLENDCONDITIONALRENDERPROC)(void);
+typedef void (GLAD_API_PTR *PFNGLENDCONDITIONALRENDERNVPROC)(void);
+typedef void (GLAD_API_PTR *PFNGLENDCONDITIONALRENDERNVXPROC)(void);
+typedef void (GLAD_API_PTR *PFNGLENDQUERYPROC)(GLenum target);
+typedef void (GLAD_API_PTR *PFNGLENDQUERYARBPROC)(GLenum target);
+typedef void (GLAD_API_PTR *PFNGLENDTRANSFORMFEEDBACKPROC)(void);
+typedef void (GLAD_API_PTR *PFNGLENDTRANSFORMFEEDBACKEXTPROC)(void);
+typedef void (GLAD_API_PTR *PFNGLENDTRANSFORMFEEDBACKNVPROC)(void);
+typedef void (GLAD_API_PTR *PFNGLEXECUTEPROGRAMNVPROC)(GLenum target, GLuint id, const GLfloat * params);
+typedef GLsync (GLAD_API_PTR *PFNGLFENCESYNCPROC)(GLenum condition, GLbitfield flags);
+typedef void (GLAD_API_PTR *PFNGLFINISHPROC)(void);
+typedef void (GLAD_API_PTR *PFNGLFLUSHPROC)(void);
+typedef void (GLAD_API_PTR *PFNGLFLUSHMAPPEDBUFFERRANGEPROC)(GLenum target, GLintptr offset, GLsizeiptr length);
+typedef void (GLAD_API_PTR *PFNGLFLUSHMAPPEDBUFFERRANGEAPPLEPROC)(GLenum target, GLintptr offset, GLsizeiptr size);
+typedef void (GLAD_API_PTR *PFNGLFLUSHMAPPEDNAMEDBUFFERRANGEEXTPROC)(GLuint buffer, GLintptr offset, GLsizeiptr length);
+typedef void (GLAD_API_PTR *PFNGLFRAMEBUFFERDRAWBUFFEREXTPROC)(GLuint framebuffer, GLenum mode);
+typedef void (GLAD_API_PTR *PFNGLFRAMEBUFFERDRAWBUFFERSEXTPROC)(GLuint framebuffer, GLsizei n, const GLenum * bufs);
+typedef void (GLAD_API_PTR *PFNGLFRAMEBUFFERREADBUFFEREXTPROC)(GLuint framebuffer, GLenum mode);
+typedef void (GLAD_API_PTR *PFNGLFRAMEBUFFERRENDERBUFFERPROC)(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
+typedef void (GLAD_API_PTR *PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC)(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
+typedef void (GLAD_API_PTR *PFNGLFRAMEBUFFERTEXTUREPROC)(GLenum target, GLenum attachment, GLuint texture, GLint level);
+typedef void (GLAD_API_PTR *PFNGLFRAMEBUFFERTEXTURE1DPROC)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
+typedef void (GLAD_API_PTR *PFNGLFRAMEBUFFERTEXTURE1DEXTPROC)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
+typedef void (GLAD_API_PTR *PFNGLFRAMEBUFFERTEXTURE2DPROC)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
+typedef void (GLAD_API_PTR *PFNGLFRAMEBUFFERTEXTURE2DEXTPROC)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
+typedef void (GLAD_API_PTR *PFNGLFRAMEBUFFERTEXTURE3DPROC)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset);
+typedef void (GLAD_API_PTR *PFNGLFRAMEBUFFERTEXTURE3DEXTPROC)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset);
+typedef void (GLAD_API_PTR *PFNGLFRAMEBUFFERTEXTUREARBPROC)(GLenum target, GLenum attachment, GLuint texture, GLint level);
+typedef void (GLAD_API_PTR *PFNGLFRAMEBUFFERTEXTUREEXTPROC)(GLenum target, GLenum attachment, GLuint texture, GLint level);
+typedef void (GLAD_API_PTR *PFNGLFRAMEBUFFERTEXTUREFACEARBPROC)(GLenum target, GLenum attachment, GLuint texture, GLint level, GLenum face);
+typedef void (GLAD_API_PTR *PFNGLFRAMEBUFFERTEXTUREFACEEXTPROC)(GLenum target, GLenum attachment, GLuint texture, GLint level, GLenum face);
+typedef void (GLAD_API_PTR *PFNGLFRAMEBUFFERTEXTURELAYERPROC)(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer);
+typedef void (GLAD_API_PTR *PFNGLFRAMEBUFFERTEXTURELAYERARBPROC)(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer);
+typedef void (GLAD_API_PTR *PFNGLFRAMEBUFFERTEXTURELAYEREXTPROC)(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer);
+typedef void (GLAD_API_PTR *PFNGLFRONTFACEPROC)(GLenum mode);
+typedef void (GLAD_API_PTR *PFNGLGENBUFFERSPROC)(GLsizei n, GLuint * buffers);
+typedef void (GLAD_API_PTR *PFNGLGENBUFFERSARBPROC)(GLsizei n, GLuint * buffers);
+typedef void (GLAD_API_PTR *PFNGLGENFRAMEBUFFERSPROC)(GLsizei n, GLuint * framebuffers);
+typedef void (GLAD_API_PTR *PFNGLGENFRAMEBUFFERSEXTPROC)(GLsizei n, GLuint * framebuffers);
+typedef void (GLAD_API_PTR *PFNGLGENPROGRAMSARBPROC)(GLsizei n, GLuint * programs);
+typedef void (GLAD_API_PTR *PFNGLGENPROGRAMSNVPROC)(GLsizei n, GLuint * programs);
+typedef void (GLAD_API_PTR *PFNGLGENQUERIESPROC)(GLsizei n, GLuint * ids);
+typedef void (GLAD_API_PTR *PFNGLGENQUERIESARBPROC)(GLsizei n, GLuint * ids);
+typedef void (GLAD_API_PTR *PFNGLGENRENDERBUFFERSPROC)(GLsizei n, GLuint * renderbuffers);
+typedef void (GLAD_API_PTR *PFNGLGENRENDERBUFFERSEXTPROC)(GLsizei n, GLuint * renderbuffers);
+typedef void (GLAD_API_PTR *PFNGLGENTEXTURESPROC)(GLsizei n, GLuint * textures);
+typedef void (GLAD_API_PTR *PFNGLGENTEXTURESEXTPROC)(GLsizei n, GLuint * textures);
+typedef void (GLAD_API_PTR *PFNGLGENVERTEXARRAYSPROC)(GLsizei n, GLuint * arrays);
+typedef void (GLAD_API_PTR *PFNGLGENVERTEXARRAYSAPPLEPROC)(GLsizei n, GLuint * arrays);
+typedef void (GLAD_API_PTR *PFNGLGENERATEMIPMAPPROC)(GLenum target);
+typedef void (GLAD_API_PTR *PFNGLGENERATEMIPMAPEXTPROC)(GLenum target);
+typedef void (GLAD_API_PTR *PFNGLGENERATEMULTITEXMIPMAPEXTPROC)(GLenum texunit, GLenum target);
+typedef void (GLAD_API_PTR *PFNGLGENERATETEXTUREMIPMAPEXTPROC)(GLuint texture, GLenum target);
+typedef void (GLAD_API_PTR *PFNGLGETACTIVEATTRIBPROC)(GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLint * size, GLenum * type, GLchar * name);
+typedef void (GLAD_API_PTR *PFNGLGETACTIVEATTRIBARBPROC)(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei * length, GLint * size, GLenum * type, GLcharARB * name);
+typedef void (GLAD_API_PTR *PFNGLGETACTIVEUNIFORMPROC)(GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLint * size, GLenum * type, GLchar * name);
+typedef void (GLAD_API_PTR *PFNGLGETACTIVEUNIFORMARBPROC)(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei * length, GLint * size, GLenum * type, GLcharARB * name);
+typedef void (GLAD_API_PTR *PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC)(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei * length, GLchar * uniformBlockName);
+typedef void (GLAD_API_PTR *PFNGLGETACTIVEUNIFORMBLOCKIVPROC)(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint * params);
+typedef void (GLAD_API_PTR *PFNGLGETACTIVEUNIFORMNAMEPROC)(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei * length, GLchar * uniformName);
+typedef void (GLAD_API_PTR *PFNGLGETACTIVEUNIFORMSIVPROC)(GLuint program, GLsizei uniformCount, const GLuint * uniformIndices, GLenum pname, GLint * params);
+typedef void (GLAD_API_PTR *PFNGLGETACTIVEVARYINGNVPROC)(GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLsizei * size, GLenum * type, GLchar * name);
+typedef void (GLAD_API_PTR *PFNGLGETATTACHEDOBJECTSARBPROC)(GLhandleARB containerObj, GLsizei maxCount, GLsizei * count, GLhandleARB * obj);
+typedef void (GLAD_API_PTR *PFNGLGETATTACHEDSHADERSPROC)(GLuint program, GLsizei maxCount, GLsizei * count, GLuint * shaders);
+typedef GLint (GLAD_API_PTR *PFNGLGETATTRIBLOCATIONPROC)(GLuint program, const GLchar * name);
+typedef GLint (GLAD_API_PTR *PFNGLGETATTRIBLOCATIONARBPROC)(GLhandleARB programObj, const GLcharARB * name);
+typedef void (GLAD_API_PTR *PFNGLGETBOOLEANINDEXEDVEXTPROC)(GLenum target, GLuint index, GLboolean * data);
+typedef void (GLAD_API_PTR *PFNGLGETBOOLEANI_VPROC)(GLenum target, GLuint index, GLboolean * data);
+typedef void (GLAD_API_PTR *PFNGLGETBOOLEANVPROC)(GLenum pname, GLboolean * data);
+typedef void (GLAD_API_PTR *PFNGLGETBUFFERPARAMETERI64VPROC)(GLenum target, GLenum pname, GLint64 * params);
+typedef void (GLAD_API_PTR *PFNGLGETBUFFERPARAMETERIVPROC)(GLenum target, GLenum pname, GLint * params);
+typedef void (GLAD_API_PTR *PFNGLGETBUFFERPARAMETERIVARBPROC)(GLenum target, GLenum pname, GLint * params);
+typedef void (GLAD_API_PTR *PFNGLGETBUFFERPOINTERVPROC)(GLenum target, GLenum pname, void ** params);
+typedef void (GLAD_API_PTR *PFNGLGETBUFFERPOINTERVARBPROC)(GLenum target, GLenum pname, void ** params);
+typedef void (GLAD_API_PTR *PFNGLGETBUFFERSUBDATAPROC)(GLenum target, GLintptr offset, GLsizeiptr size, void * data);
+typedef void (GLAD_API_PTR *PFNGLGETBUFFERSUBDATAARBPROC)(GLenum target, GLintptrARB offset, GLsizeiptrARB size, void * data);
+typedef void (GLAD_API_PTR *PFNGLGETCOMPRESSEDMULTITEXIMAGEEXTPROC)(GLenum texunit, GLenum target, GLint lod, void * img);
+typedef void (GLAD_API_PTR *PFNGLGETCOMPRESSEDTEXIMAGEPROC)(GLenum target, GLint level, void * img);
+typedef void (GLAD_API_PTR *PFNGLGETCOMPRESSEDTEXIMAGEARBPROC)(GLenum target, GLint level, void * img);
+typedef void (GLAD_API_PTR *PFNGLGETCOMPRESSEDTEXTUREIMAGEEXTPROC)(GLuint texture, GLenum target, GLint lod, void * img);
+typedef void (GLAD_API_PTR *PFNGLGETDOUBLEINDEXEDVEXTPROC)(GLenum target, GLuint index, GLdouble * data);
+typedef void (GLAD_API_PTR *PFNGLGETDOUBLEI_VEXTPROC)(GLenum pname, GLuint index, GLdouble * params);
+typedef void (GLAD_API_PTR *PFNGLGETDOUBLEVPROC)(GLenum pname, GLdouble * data);
+typedef GLenum (GLAD_API_PTR *PFNGLGETERRORPROC)(void);
+typedef void (GLAD_API_PTR *PFNGLGETFLOATINDEXEDVEXTPROC)(GLenum target, GLuint index, GLfloat * data);
+typedef void (GLAD_API_PTR *PFNGLGETFLOATI_VEXTPROC)(GLenum pname, GLuint index, GLfloat * params);
+typedef void (GLAD_API_PTR *PFNGLGETFLOATVPROC)(GLenum pname, GLfloat * data);
+typedef GLint (GLAD_API_PTR *PFNGLGETFRAGDATALOCATIONPROC)(GLuint program, const GLchar * name);
+typedef GLint (GLAD_API_PTR *PFNGLGETFRAGDATALOCATIONEXTPROC)(GLuint program, const GLchar * name);
+typedef void (GLAD_API_PTR *PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC)(GLenum target, GLenum attachment, GLenum pname, GLint * params);
+typedef void (GLAD_API_PTR *PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC)(GLenum target, GLenum attachment, GLenum pname, GLint * params);
+typedef void (GLAD_API_PTR *PFNGLGETFRAMEBUFFERPARAMETERIVEXTPROC)(GLuint framebuffer, GLenum pname, GLint * params);
+typedef GLhandleARB (GLAD_API_PTR *PFNGLGETHANDLEARBPROC)(GLenum pname);
+typedef void (GLAD_API_PTR *PFNGLGETINFOLOGARBPROC)(GLhandleARB obj, GLsizei maxLength, GLsizei * length, GLcharARB * infoLog);
+typedef void (GLAD_API_PTR *PFNGLGETINTEGER64I_VPROC)(GLenum target, GLuint index, GLint64 * data);
+typedef void (GLAD_API_PTR *PFNGLGETINTEGER64VPROC)(GLenum pname, GLint64 * data);
+typedef void (GLAD_API_PTR *PFNGLGETINTEGERINDEXEDVEXTPROC)(GLenum target, GLuint index, GLint * data);
+typedef void (GLAD_API_PTR *PFNGLGETINTEGERI_VPROC)(GLenum target, GLuint index, GLint * data);
+typedef void (GLAD_API_PTR *PFNGLGETINTEGERVPROC)(GLenum pname, GLint * data);
+typedef void (GLAD_API_PTR *PFNGLGETMULTITEXENVFVEXTPROC)(GLenum texunit, GLenum target, GLenum pname, GLfloat * params);
+typedef void (GLAD_API_PTR *PFNGLGETMULTITEXENVIVEXTPROC)(GLenum texunit, GLenum target, GLenum pname, GLint * params);
+typedef void (GLAD_API_PTR *PFNGLGETMULTITEXGENDVEXTPROC)(GLenum texunit, GLenum coord, GLenum pname, GLdouble * params);
+typedef void (GLAD_API_PTR *PFNGLGETMULTITEXGENFVEXTPROC)(GLenum texunit, GLenum coord, GLenum pname, GLfloat * params);
+typedef void (GLAD_API_PTR *PFNGLGETMULTITEXGENIVEXTPROC)(GLenum texunit, GLenum coord, GLenum pname, GLint * params);
+typedef void (GLAD_API_PTR *PFNGLGETMULTITEXIMAGEEXTPROC)(GLenum texunit, GLenum target, GLint level, GLenum format, GLenum type, void * pixels);
+typedef void (GLAD_API_PTR *PFNGLGETMULTITEXLEVELPARAMETERFVEXTPROC)(GLenum texunit, GLenum target, GLint level, GLenum pname, GLfloat * params);
+typedef void (GLAD_API_PTR *PFNGLGETMULTITEXLEVELPARAMETERIVEXTPROC)(GLenum texunit, GLenum target, GLint level, GLenum pname, GLint * params);
+typedef void (GLAD_API_PTR *PFNGLGETMULTITEXPARAMETERIIVEXTPROC)(GLenum texunit, GLenum target, GLenum pname, GLint * params);
+typedef void (GLAD_API_PTR *PFNGLGETMULTITEXPARAMETERIUIVEXTPROC)(GLenum texunit, GLenum target, GLenum pname, GLuint * params);
+typedef void (GLAD_API_PTR *PFNGLGETMULTITEXPARAMETERFVEXTPROC)(GLenum texunit, GLenum target, GLenum pname, GLfloat * params);
+typedef void (GLAD_API_PTR *PFNGLGETMULTITEXPARAMETERIVEXTPROC)(GLenum texunit, GLenum target, GLenum pname, GLint * params);
+typedef void (GLAD_API_PTR *PFNGLGETMULTISAMPLEFVPROC)(GLenum pname, GLuint index, GLfloat * val);
+typedef void (GLAD_API_PTR *PFNGLGETMULTISAMPLEFVNVPROC)(GLenum pname, GLuint index, GLfloat * val);
+typedef void (GLAD_API_PTR *PFNGLGETNAMEDBUFFERPARAMETERIVEXTPROC)(GLuint buffer, GLenum pname, GLint * params);
+typedef void (GLAD_API_PTR *PFNGLGETNAMEDBUFFERPOINTERVEXTPROC)(GLuint buffer, GLenum pname, void ** params);
+typedef void (GLAD_API_PTR *PFNGLGETNAMEDBUFFERSUBDATAEXTPROC)(GLuint buffer, GLintptr offset, GLsizeiptr size, void * data);
+typedef void (GLAD_API_PTR *PFNGLGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC)(GLuint framebuffer, GLenum attachment, GLenum pname, GLint * params);
+typedef void (GLAD_API_PTR *PFNGLGETNAMEDFRAMEBUFFERPARAMETERIVEXTPROC)(GLuint framebuffer, GLenum pname, GLint * params);
+typedef void (GLAD_API_PTR *PFNGLGETNAMEDPROGRAMLOCALPARAMETERIIVEXTPROC)(GLuint program, GLenum target, GLuint index, GLint * params);
+typedef void (GLAD_API_PTR *PFNGLGETNAMEDPROGRAMLOCALPARAMETERIUIVEXTPROC)(GLuint program, GLenum target, GLuint index, GLuint * params);
+typedef void (GLAD_API_PTR *PFNGLGETNAMEDPROGRAMLOCALPARAMETERDVEXTPROC)(GLuint program, GLenum target, GLuint index, GLdouble * params);
+typedef void (GLAD_API_PTR *PFNGLGETNAMEDPROGRAMLOCALPARAMETERFVEXTPROC)(GLuint program, GLenum target, GLuint index, GLfloat * params);
+typedef void (GLAD_API_PTR *PFNGLGETNAMEDPROGRAMSTRINGEXTPROC)(GLuint program, GLenum target, GLenum pname, void * string);
+typedef void (GLAD_API_PTR *PFNGLGETNAMEDPROGRAMIVEXTPROC)(GLuint program, GLenum target, GLenum pname, GLint * params);
+typedef void (GLAD_API_PTR *PFNGLGETNAMEDRENDERBUFFERPARAMETERIVEXTPROC)(GLuint renderbuffer, GLenum pname, GLint * params);
+typedef void (GLAD_API_PTR *PFNGLGETOBJECTPARAMETERFVARBPROC)(GLhandleARB obj, GLenum pname, GLfloat * params);
+typedef void (GLAD_API_PTR *PFNGLGETOBJECTPARAMETERIVARBPROC)(GLhandleARB obj, GLenum pname, GLint * params);
+typedef void (GLAD_API_PTR *PFNGLGETPOINTERINDEXEDVEXTPROC)(GLenum target, GLuint index, void ** data);
+typedef void (GLAD_API_PTR *PFNGLGETPOINTERI_VEXTPROC)(GLenum pname, GLuint index, void ** params);
+typedef void (GLAD_API_PTR *PFNGLGETPOINTERVEXTPROC)(GLenum pname, void ** params);
+typedef void (GLAD_API_PTR *PFNGLGETPROGRAMENVPARAMETERDVARBPROC)(GLenum target, GLuint index, GLdouble * params);
+typedef void (GLAD_API_PTR *PFNGLGETPROGRAMENVPARAMETERFVARBPROC)(GLenum target, GLuint index, GLfloat * params);
+typedef void (GLAD_API_PTR *PFNGLGETPROGRAMINFOLOGPROC)(GLuint program, GLsizei bufSize, GLsizei * length, GLchar * infoLog);
+typedef void (GLAD_API_PTR *PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC)(GLenum target, GLuint index, GLdouble * params);
+typedef void (GLAD_API_PTR *PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC)(GLenum target, GLuint index, GLfloat * params);
+typedef void (GLAD_API_PTR *PFNGLGETPROGRAMPARAMETERDVNVPROC)(GLenum target, GLuint index, GLenum pname, GLdouble * params);
+typedef void (GLAD_API_PTR *PFNGLGETPROGRAMPARAMETERFVNVPROC)(GLenum target, GLuint index, GLenum pname, GLfloat * params);
+typedef void (GLAD_API_PTR *PFNGLGETPROGRAMSTRINGARBPROC)(GLenum target, GLenum pname, void * string);
+typedef void (GLAD_API_PTR *PFNGLGETPROGRAMSTRINGNVPROC)(GLuint id, GLenum pname, GLubyte * program);
+typedef void (GLAD_API_PTR *PFNGLGETPROGRAMIVPROC)(GLuint program, GLenum pname, GLint * params);
+typedef void (GLAD_API_PTR *PFNGLGETPROGRAMIVARBPROC)(GLenum target, GLenum pname, GLint * params);
+typedef void (GLAD_API_PTR *PFNGLGETPROGRAMIVNVPROC)(GLuint id, GLenum pname, GLint * params);
+typedef void (GLAD_API_PTR *PFNGLGETQUERYOBJECTIVPROC)(GLuint id, GLenum pname, GLint * params);
+typedef void (GLAD_API_PTR *PFNGLGETQUERYOBJECTIVARBPROC)(GLuint id, GLenum pname, GLint * params);
+typedef void (GLAD_API_PTR *PFNGLGETQUERYOBJECTUIVPROC)(GLuint id, GLenum pname, GLuint * params);
+typedef void (GLAD_API_PTR *PFNGLGETQUERYOBJECTUIVARBPROC)(GLuint id, GLenum pname, GLuint * params);
+typedef void (GLAD_API_PTR *PFNGLGETQUERYIVPROC)(GLenum target, GLenum pname, GLint * params);
+typedef void (GLAD_API_PTR *PFNGLGETQUERYIVARBPROC)(GLenum target, GLenum pname, GLint * params);
+typedef void (GLAD_API_PTR *PFNGLGETRENDERBUFFERPARAMETERIVPROC)(GLenum target, GLenum pname, GLint * params);
+typedef void (GLAD_API_PTR *PFNGLGETRENDERBUFFERPARAMETERIVEXTPROC)(GLenum target, GLenum pname, GLint * params);
+typedef void (GLAD_API_PTR *PFNGLGETSHADERINFOLOGPROC)(GLuint shader, GLsizei bufSize, GLsizei * length, GLchar * infoLog);
+typedef void (GLAD_API_PTR *PFNGLGETSHADERSOURCEPROC)(GLuint shader, GLsizei bufSize, GLsizei * length, GLchar * source);
+typedef void (GLAD_API_PTR *PFNGLGETSHADERSOURCEARBPROC)(GLhandleARB obj, GLsizei maxLength, GLsizei * length, GLcharARB * source);
+typedef void (GLAD_API_PTR *PFNGLGETSHADERIVPROC)(GLuint shader, GLenum pname, GLint * params);
+typedef const GLubyte * (GLAD_API_PTR *PFNGLGETSTRINGPROC)(GLenum name);
+typedef const GLubyte * (GLAD_API_PTR *PFNGLGETSTRINGIPROC)(GLenum name, GLuint index);
+typedef void (GLAD_API_PTR *PFNGLGETSYNCIVPROC)(GLsync sync, GLenum pname, GLsizei count, GLsizei * length, GLint * values);
+typedef void (GLAD_API_PTR *PFNGLGETTEXIMAGEPROC)(GLenum target, GLint level, GLenum format, GLenum type, void * pixels);
+typedef void (GLAD_API_PTR *PFNGLGETTEXLEVELPARAMETERFVPROC)(GLenum target, GLint level, GLenum pname, GLfloat * params);
+typedef void (GLAD_API_PTR *PFNGLGETTEXLEVELPARAMETERIVPROC)(GLenum target, GLint level, GLenum pname, GLint * params);
+typedef void (GLAD_API_PTR *PFNGLGETTEXPARAMETERIIVPROC)(GLenum target, GLenum pname, GLint * params);
+typedef void (GLAD_API_PTR *PFNGLGETTEXPARAMETERIIVEXTPROC)(GLenum target, GLenum pname, GLint * params);
+typedef void (GLAD_API_PTR *PFNGLGETTEXPARAMETERIUIVPROC)(GLenum target, GLenum pname, GLuint * params);
+typedef void (GLAD_API_PTR *PFNGLGETTEXPARAMETERIUIVEXTPROC)(GLenum target, GLenum pname, GLuint * params);
+typedef void (GLAD_API_PTR *PFNGLGETTEXPARAMETERFVPROC)(GLenum target, GLenum pname, GLfloat * params);
+typedef void (GLAD_API_PTR *PFNGLGETTEXPARAMETERIVPROC)(GLenum target, GLenum pname, GLint * params);
+typedef void (GLAD_API_PTR *PFNGLGETTEXTUREIMAGEEXTPROC)(GLuint texture, GLenum target, GLint level, GLenum format, GLenum type, void * pixels);
+typedef void (GLAD_API_PTR *PFNGLGETTEXTURELEVELPARAMETERFVEXTPROC)(GLuint texture, GLenum target, GLint level, GLenum pname, GLfloat * params);
+typedef void (GLAD_API_PTR *PFNGLGETTEXTURELEVELPARAMETERIVEXTPROC)(GLuint texture, GLenum target, GLint level, GLenum pname, GLint * params);
+typedef void (GLAD_API_PTR *PFNGLGETTEXTUREPARAMETERIIVEXTPROC)(GLuint texture, GLenum target, GLenum pname, GLint * params);
+typedef void (GLAD_API_PTR *PFNGLGETTEXTUREPARAMETERIUIVEXTPROC)(GLuint texture, GLenum target, GLenum pname, GLuint * params);
+typedef void (GLAD_API_PTR *PFNGLGETTEXTUREPARAMETERFVEXTPROC)(GLuint texture, GLenum target, GLenum pname, GLfloat * params);
+typedef void (GLAD_API_PTR *PFNGLGETTEXTUREPARAMETERIVEXTPROC)(GLuint texture, GLenum target, GLenum pname, GLint * params);
+typedef void (GLAD_API_PTR *PFNGLGETTRACKMATRIXIVNVPROC)(GLenum target, GLuint address, GLenum pname, GLint * params);
+typedef void (GLAD_API_PTR *PFNGLGETTRANSFORMFEEDBACKVARYINGPROC)(GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLsizei * size, GLenum * type, GLchar * name);
+typedef void (GLAD_API_PTR *PFNGLGETTRANSFORMFEEDBACKVARYINGEXTPROC)(GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLsizei * size, GLenum * type, GLchar * name);
+typedef void (GLAD_API_PTR *PFNGLGETTRANSFORMFEEDBACKVARYINGNVPROC)(GLuint program, GLuint index, GLint * location);
+typedef GLuint (GLAD_API_PTR *PFNGLGETUNIFORMBLOCKINDEXPROC)(GLuint program, const GLchar * uniformBlockName);
+typedef void (GLAD_API_PTR *PFNGLGETUNIFORMINDICESPROC)(GLuint program, GLsizei uniformCount, const GLchar *const* uniformNames, GLuint * uniformIndices);
+typedef GLint (GLAD_API_PTR *PFNGLGETUNIFORMLOCATIONPROC)(GLuint program, const GLchar * name);
+typedef GLint (GLAD_API_PTR *PFNGLGETUNIFORMLOCATIONARBPROC)(GLhandleARB programObj, const GLcharARB * name);
+typedef void (GLAD_API_PTR *PFNGLGETUNIFORMFVPROC)(GLuint program, GLint location, GLfloat * params);
+typedef void (GLAD_API_PTR *PFNGLGETUNIFORMFVARBPROC)(GLhandleARB programObj, GLint location, GLfloat * params);
+typedef void (GLAD_API_PTR *PFNGLGETUNIFORMIVPROC)(GLuint program, GLint location, GLint * params);
+typedef void (GLAD_API_PTR *PFNGLGETUNIFORMIVARBPROC)(GLhandleARB programObj, GLint location, GLint * params);
+typedef void (GLAD_API_PTR *PFNGLGETUNIFORMUIVPROC)(GLuint program, GLint location, GLuint * params);
+typedef void (GLAD_API_PTR *PFNGLGETUNIFORMUIVEXTPROC)(GLuint program, GLint location, GLuint * params);
+typedef GLint (GLAD_API_PTR *PFNGLGETVARYINGLOCATIONNVPROC)(GLuint program, const GLchar * name);
+typedef void (GLAD_API_PTR *PFNGLGETVERTEXARRAYINTEGERI_VEXTPROC)(GLuint vaobj, GLuint index, GLenum pname, GLint * param);
+typedef void (GLAD_API_PTR *PFNGLGETVERTEXARRAYINTEGERVEXTPROC)(GLuint vaobj, GLenum pname, GLint * param);
+typedef void (GLAD_API_PTR *PFNGLGETVERTEXARRAYPOINTERI_VEXTPROC)(GLuint vaobj, GLuint index, GLenum pname, void ** param);
+typedef void (GLAD_API_PTR *PFNGLGETVERTEXARRAYPOINTERVEXTPROC)(GLuint vaobj, GLenum pname, void ** param);
+typedef void (GLAD_API_PTR *PFNGLGETVERTEXATTRIBIIVPROC)(GLuint index, GLenum pname, GLint * params);
+typedef void (GLAD_API_PTR *PFNGLGETVERTEXATTRIBIIVEXTPROC)(GLuint index, GLenum pname, GLint * params);
+typedef void (GLAD_API_PTR *PFNGLGETVERTEXATTRIBIUIVPROC)(GLuint index, GLenum pname, GLuint * params);
+typedef void (GLAD_API_PTR *PFNGLGETVERTEXATTRIBIUIVEXTPROC)(GLuint index, GLenum pname, GLuint * params);
+typedef void (GLAD_API_PTR *PFNGLGETVERTEXATTRIBPOINTERVPROC)(GLuint index, GLenum pname, void ** pointer);
+typedef void (GLAD_API_PTR *PFNGLGETVERTEXATTRIBPOINTERVARBPROC)(GLuint index, GLenum pname, void ** pointer);
+typedef void (GLAD_API_PTR *PFNGLGETVERTEXATTRIBPOINTERVNVPROC)(GLuint index, GLenum pname, void ** pointer);
+typedef void (GLAD_API_PTR *PFNGLGETVERTEXATTRIBDVPROC)(GLuint index, GLenum pname, GLdouble * params);
+typedef void (GLAD_API_PTR *PFNGLGETVERTEXATTRIBDVARBPROC)(GLuint index, GLenum pname, GLdouble * params);
+typedef void (GLAD_API_PTR *PFNGLGETVERTEXATTRIBDVNVPROC)(GLuint index, GLenum pname, GLdouble * params);
+typedef void (GLAD_API_PTR *PFNGLGETVERTEXATTRIBFVPROC)(GLuint index, GLenum pname, GLfloat * params);
+typedef void (GLAD_API_PTR *PFNGLGETVERTEXATTRIBFVARBPROC)(GLuint index, GLenum pname, GLfloat * params);
+typedef void (GLAD_API_PTR *PFNGLGETVERTEXATTRIBFVNVPROC)(GLuint index, GLenum pname, GLfloat * params);
+typedef void (GLAD_API_PTR *PFNGLGETVERTEXATTRIBIVPROC)(GLuint index, GLenum pname, GLint * params);
+typedef void (GLAD_API_PTR *PFNGLGETVERTEXATTRIBIVARBPROC)(GLuint index, GLenum pname, GLint * params);
+typedef void (GLAD_API_PTR *PFNGLGETVERTEXATTRIBIVNVPROC)(GLuint index, GLenum pname, GLint * params);
+typedef void (GLAD_API_PTR *PFNGLHINTPROC)(GLenum target, GLenum mode);
+typedef void (GLAD_API_PTR *PFNGLINDEXPOINTEREXTPROC)(GLenum type, GLsizei stride, GLsizei count, const void * pointer);
+typedef GLboolean (GLAD_API_PTR *PFNGLISBUFFERPROC)(GLuint buffer);
+typedef GLboolean (GLAD_API_PTR *PFNGLISBUFFERARBPROC)(GLuint buffer);
+typedef GLboolean (GLAD_API_PTR *PFNGLISENABLEDPROC)(GLenum cap);
+typedef GLboolean (GLAD_API_PTR *PFNGLISENABLEDINDEXEDEXTPROC)(GLenum target, GLuint index);
+typedef GLboolean (GLAD_API_PTR *PFNGLISENABLEDIPROC)(GLenum target, GLuint index);
+typedef GLboolean (GLAD_API_PTR *PFNGLISFRAMEBUFFERPROC)(GLuint framebuffer);
+typedef GLboolean (GLAD_API_PTR *PFNGLISFRAMEBUFFEREXTPROC)(GLuint framebuffer);
+typedef GLboolean (GLAD_API_PTR *PFNGLISPROGRAMPROC)(GLuint program);
+typedef GLboolean (GLAD_API_PTR *PFNGLISPROGRAMARBPROC)(GLuint program);
+typedef GLboolean (GLAD_API_PTR *PFNGLISPROGRAMNVPROC)(GLuint id);
+typedef GLboolean (GLAD_API_PTR *PFNGLISQUERYPROC)(GLuint id);
+typedef GLboolean (GLAD_API_PTR *PFNGLISQUERYARBPROC)(GLuint id);
+typedef GLboolean (GLAD_API_PTR *PFNGLISRENDERBUFFERPROC)(GLuint renderbuffer);
+typedef GLboolean (GLAD_API_PTR *PFNGLISRENDERBUFFEREXTPROC)(GLuint renderbuffer);
+typedef GLboolean (GLAD_API_PTR *PFNGLISSHADERPROC)(GLuint shader);
+typedef GLboolean (GLAD_API_PTR *PFNGLISSYNCPROC)(GLsync sync);
+typedef GLboolean (GLAD_API_PTR *PFNGLISTEXTUREPROC)(GLuint texture);
+typedef GLboolean (GLAD_API_PTR *PFNGLISTEXTUREEXTPROC)(GLuint texture);
+typedef GLboolean (GLAD_API_PTR *PFNGLISVERTEXARRAYPROC)(GLuint array);
+typedef GLboolean (GLAD_API_PTR *PFNGLISVERTEXARRAYAPPLEPROC)(GLuint array);
+typedef void (GLAD_API_PTR *PFNGLLINEWIDTHPROC)(GLfloat width);
+typedef void (GLAD_API_PTR *PFNGLLINKPROGRAMPROC)(GLuint program);
+typedef void (GLAD_API_PTR *PFNGLLINKPROGRAMARBPROC)(GLhandleARB programObj);
+typedef void (GLAD_API_PTR *PFNGLLOADPROGRAMNVPROC)(GLenum target, GLuint id, GLsizei len, const GLubyte * program);
+typedef void (GLAD_API_PTR *PFNGLLOGICOPPROC)(GLenum opcode);
+typedef void * (GLAD_API_PTR *PFNGLMAPBUFFERPROC)(GLenum target, GLenum access);
+typedef void * (GLAD_API_PTR *PFNGLMAPBUFFERARBPROC)(GLenum target, GLenum access);
+typedef void * (GLAD_API_PTR *PFNGLMAPBUFFERRANGEPROC)(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access);
+typedef void * (GLAD_API_PTR *PFNGLMAPNAMEDBUFFEREXTPROC)(GLuint buffer, GLenum access);
+typedef void * (GLAD_API_PTR *PFNGLMAPNAMEDBUFFERRANGEEXTPROC)(GLuint buffer, GLintptr offset, GLsizeiptr length, GLbitfield access);
+typedef void (GLAD_API_PTR *PFNGLMATRIXFRUSTUMEXTPROC)(GLenum mode, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
+typedef void (GLAD_API_PTR *PFNGLMATRIXLOADIDENTITYEXTPROC)(GLenum mode);
+typedef void (GLAD_API_PTR *PFNGLMATRIXLOADTRANSPOSEDEXTPROC)(GLenum mode, const GLdouble * m);
+typedef void (GLAD_API_PTR *PFNGLMATRIXLOADTRANSPOSEFEXTPROC)(GLenum mode, const GLfloat * m);
+typedef void (GLAD_API_PTR *PFNGLMATRIXLOADDEXTPROC)(GLenum mode, const GLdouble * m);
+typedef void (GLAD_API_PTR *PFNGLMATRIXLOADFEXTPROC)(GLenum mode, const GLfloat * m);
+typedef void (GLAD_API_PTR *PFNGLMATRIXMULTTRANSPOSEDEXTPROC)(GLenum mode, const GLdouble * m);
+typedef void (GLAD_API_PTR *PFNGLMATRIXMULTTRANSPOSEFEXTPROC)(GLenum mode, const GLfloat * m);
+typedef void (GLAD_API_PTR *PFNGLMATRIXMULTDEXTPROC)(GLenum mode, const GLdouble * m);
+typedef void (GLAD_API_PTR *PFNGLMATRIXMULTFEXTPROC)(GLenum mode, const GLfloat * m);
+typedef void (GLAD_API_PTR *PFNGLMATRIXORTHOEXTPROC)(GLenum mode, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
+typedef void (GLAD_API_PTR *PFNGLMATRIXPOPEXTPROC)(GLenum mode);
+typedef void (GLAD_API_PTR *PFNGLMATRIXPUSHEXTPROC)(GLenum mode);
+typedef void (GLAD_API_PTR *PFNGLMATRIXROTATEDEXTPROC)(GLenum mode, GLdouble angle, GLdouble x, GLdouble y, GLdouble z);
+typedef void (GLAD_API_PTR *PFNGLMATRIXROTATEFEXTPROC)(GLenum mode, GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
+typedef void (GLAD_API_PTR *PFNGLMATRIXSCALEDEXTPROC)(GLenum mode, GLdouble x, GLdouble y, GLdouble z);
+typedef void (GLAD_API_PTR *PFNGLMATRIXSCALEFEXTPROC)(GLenum mode, GLfloat x, GLfloat y, GLfloat z);
+typedef void (GLAD_API_PTR *PFNGLMATRIXTRANSLATEDEXTPROC)(GLenum mode, GLdouble x, GLdouble y, GLdouble z);
+typedef void (GLAD_API_PTR *PFNGLMATRIXTRANSLATEFEXTPROC)(GLenum mode, GLfloat x, GLfloat y, GLfloat z);
+typedef void (GLAD_API_PTR *PFNGLMULTIDRAWARRAYSPROC)(GLenum mode, const GLint * first, const GLsizei * count, GLsizei drawcount);
+typedef void (GLAD_API_PTR *PFNGLMULTIDRAWARRAYSEXTPROC)(GLenum mode, const GLint * first, const GLsizei * count, GLsizei primcount);
+typedef void (GLAD_API_PTR *PFNGLMULTIDRAWELEMENTSPROC)(GLenum mode, const GLsizei * count, GLenum type, const void *const* indices, GLsizei drawcount);
+typedef void (GLAD_API_PTR *PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC)(GLenum mode, const GLsizei * count, GLenum type, const void *const* indices, GLsizei drawcount, const GLint * basevertex);
+typedef void (GLAD_API_PTR *PFNGLMULTIDRAWELEMENTSEXTPROC)(GLenum mode, const GLsizei * count, GLenum type, const void *const* indices, GLsizei primcount);
+typedef void (GLAD_API_PTR *PFNGLMULTITEXBUFFEREXTPROC)(GLenum texunit, GLenum target, GLenum internalformat, GLuint buffer);
+typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD1DARBPROC)(GLenum target, GLdouble s);
+typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD1DVARBPROC)(GLenum target, const GLdouble * v);
+typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD1FARBPROC)(GLenum target, GLfloat s);
+typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD1FVARBPROC)(GLenum target, const GLfloat * v);
+typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD1IARBPROC)(GLenum target, GLint s);
+typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD1IVARBPROC)(GLenum target, const GLint * v);
+typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD1SARBPROC)(GLenum target, GLshort s);
+typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD1SVARBPROC)(GLenum target, const GLshort * v);
+typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD2DARBPROC)(GLenum target, GLdouble s, GLdouble t);
+typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD2DVARBPROC)(GLenum target, const GLdouble * v);
+typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD2FARBPROC)(GLenum target, GLfloat s, GLfloat t);
+typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD2FVARBPROC)(GLenum target, const GLfloat * v);
+typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD2IARBPROC)(GLenum target, GLint s, GLint t);
+typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD2IVARBPROC)(GLenum target, const GLint * v);
+typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD2SARBPROC)(GLenum target, GLshort s, GLshort t);
+typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD2SVARBPROC)(GLenum target, const GLshort * v);
+typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD3DARBPROC)(GLenum target, GLdouble s, GLdouble t, GLdouble r);
+typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD3DVARBPROC)(GLenum target, const GLdouble * v);
+typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD3FARBPROC)(GLenum target, GLfloat s, GLfloat t, GLfloat r);
+typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD3FVARBPROC)(GLenum target, const GLfloat * v);
+typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD3IARBPROC)(GLenum target, GLint s, GLint t, GLint r);
+typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD3IVARBPROC)(GLenum target, const GLint * v);
+typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD3SARBPROC)(GLenum target, GLshort s, GLshort t, GLshort r);
+typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD3SVARBPROC)(GLenum target, const GLshort * v);
+typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD4DARBPROC)(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q);
+typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD4DVARBPROC)(GLenum target, const GLdouble * v);
+typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD4FARBPROC)(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q);
+typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD4FVARBPROC)(GLenum target, const GLfloat * v);
+typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD4IARBPROC)(GLenum target, GLint s, GLint t, GLint r, GLint q);
+typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD4IVARBPROC)(GLenum target, const GLint * v);
+typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD4SARBPROC)(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q);
+typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD4SVARBPROC)(GLenum target, const GLshort * v);
+typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORDPOINTEREXTPROC)(GLenum texunit, GLint size, GLenum type, GLsizei stride, const void * pointer);
+typedef void (GLAD_API_PTR *PFNGLMULTITEXENVFEXTPROC)(GLenum texunit, GLenum target, GLenum pname, GLfloat param);
+typedef void (GLAD_API_PTR *PFNGLMULTITEXENVFVEXTPROC)(GLenum texunit, GLenum target, GLenum pname, const GLfloat * params);
+typedef void (GLAD_API_PTR *PFNGLMULTITEXENVIEXTPROC)(GLenum texunit, GLenum target, GLenum pname, GLint param);
+typedef void (GLAD_API_PTR *PFNGLMULTITEXENVIVEXTPROC)(GLenum texunit, GLenum target, GLenum pname, const GLint * params);
+typedef void (GLAD_API_PTR *PFNGLMULTITEXGENDEXTPROC)(GLenum texunit, GLenum coord, GLenum pname, GLdouble param);
+typedef void (GLAD_API_PTR *PFNGLMULTITEXGENDVEXTPROC)(GLenum texunit, GLenum coord, GLenum pname, const GLdouble * params);
+typedef void (GLAD_API_PTR *PFNGLMULTITEXGENFEXTPROC)(GLenum texunit, GLenum coord, GLenum pname, GLfloat param);
+typedef void (GLAD_API_PTR *PFNGLMULTITEXGENFVEXTPROC)(GLenum texunit, GLenum coord, GLenum pname, const GLfloat * params);
+typedef void (GLAD_API_PTR *PFNGLMULTITEXGENIEXTPROC)(GLenum texunit, GLenum coord, GLenum pname, GLint param);
+typedef void (GLAD_API_PTR *PFNGLMULTITEXGENIVEXTPROC)(GLenum texunit, GLenum coord, GLenum pname, const GLint * params);
+typedef void (GLAD_API_PTR *PFNGLMULTITEXIMAGE1DEXTPROC)(GLenum texunit, GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void * pixels);
+typedef void (GLAD_API_PTR *PFNGLMULTITEXIMAGE2DEXTPROC)(GLenum texunit, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void * pixels);
+typedef void (GLAD_API_PTR *PFNGLMULTITEXIMAGE3DEXTPROC)(GLenum texunit, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void * pixels);
+typedef void (GLAD_API_PTR *PFNGLMULTITEXPARAMETERIIVEXTPROC)(GLenum texunit, GLenum target, GLenum pname, const GLint * params);
+typedef void (GLAD_API_PTR *PFNGLMULTITEXPARAMETERIUIVEXTPROC)(GLenum texunit, GLenum target, GLenum pname, const GLuint * params);
+typedef void (GLAD_API_PTR *PFNGLMULTITEXPARAMETERFEXTPROC)(GLenum texunit, GLenum target, GLenum pname, GLfloat param);
+typedef void (GLAD_API_PTR *PFNGLMULTITEXPARAMETERFVEXTPROC)(GLenum texunit, GLenum target, GLenum pname, const GLfloat * params);
+typedef void (GLAD_API_PTR *PFNGLMULTITEXPARAMETERIEXTPROC)(GLenum texunit, GLenum target, GLenum pname, GLint param);
+typedef void (GLAD_API_PTR *PFNGLMULTITEXPARAMETERIVEXTPROC)(GLenum texunit, GLenum target, GLenum pname, const GLint * params);
+typedef void (GLAD_API_PTR *PFNGLMULTITEXRENDERBUFFEREXTPROC)(GLenum texunit, GLenum target, GLuint renderbuffer);
+typedef void (GLAD_API_PTR *PFNGLMULTITEXSUBIMAGE1DEXTPROC)(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void * pixels);
+typedef void (GLAD_API_PTR *PFNGLMULTITEXSUBIMAGE2DEXTPROC)(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void * pixels);
+typedef void (GLAD_API_PTR *PFNGLMULTITEXSUBIMAGE3DEXTPROC)(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void * pixels);
+typedef void (GLAD_API_PTR *PFNGLNAMEDBUFFERDATAEXTPROC)(GLuint buffer, GLsizeiptr size, const void * data, GLenum usage);
+typedef void (GLAD_API_PTR *PFNGLNAMEDBUFFERSTORAGEEXTPROC)(GLuint buffer, GLsizeiptr size, const void * data, GLbitfield flags);
+typedef void (GLAD_API_PTR *PFNGLNAMEDBUFFERSUBDATAEXTPROC)(GLuint buffer, GLintptr offset, GLsizeiptr size, const void * data);
+typedef void (GLAD_API_PTR *PFNGLNAMEDCOPYBUFFERSUBDATAEXTPROC)(GLuint readBuffer, GLuint writeBuffer, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size);
+typedef void (GLAD_API_PTR *PFNGLNAMEDFRAMEBUFFERPARAMETERIEXTPROC)(GLuint framebuffer, GLenum pname, GLint param);
+typedef void (GLAD_API_PTR *PFNGLNAMEDFRAMEBUFFERRENDERBUFFEREXTPROC)(GLuint framebuffer, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
+typedef void (GLAD_API_PTR *PFNGLNAMEDFRAMEBUFFERTEXTURE1DEXTPROC)(GLuint framebuffer, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
+typedef void (GLAD_API_PTR *PFNGLNAMEDFRAMEBUFFERTEXTURE2DEXTPROC)(GLuint framebuffer, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
+typedef void (GLAD_API_PTR *PFNGLNAMEDFRAMEBUFFERTEXTURE3DEXTPROC)(GLuint framebuffer, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset);
+typedef void (GLAD_API_PTR *PFNGLNAMEDFRAMEBUFFERTEXTUREEXTPROC)(GLuint framebuffer, GLenum attachment, GLuint texture, GLint level);
+typedef void (GLAD_API_PTR *PFNGLNAMEDFRAMEBUFFERTEXTUREFACEEXTPROC)(GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLenum face);
+typedef void (GLAD_API_PTR *PFNGLNAMEDFRAMEBUFFERTEXTURELAYEREXTPROC)(GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLint layer);
+typedef void (GLAD_API_PTR *PFNGLNAMEDPROGRAMLOCALPARAMETER4DEXTPROC)(GLuint program, GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+typedef void (GLAD_API_PTR *PFNGLNAMEDPROGRAMLOCALPARAMETER4DVEXTPROC)(GLuint program, GLenum target, GLuint index, const GLdouble * params);
+typedef void (GLAD_API_PTR *PFNGLNAMEDPROGRAMLOCALPARAMETER4FEXTPROC)(GLuint program, GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+typedef void (GLAD_API_PTR *PFNGLNAMEDPROGRAMLOCALPARAMETER4FVEXTPROC)(GLuint program, GLenum target, GLuint index, const GLfloat * params);
+typedef void (GLAD_API_PTR *PFNGLNAMEDPROGRAMLOCALPARAMETERI4IEXTPROC)(GLuint program, GLenum target, GLuint index, GLint x, GLint y, GLint z, GLint w);
+typedef void (GLAD_API_PTR *PFNGLNAMEDPROGRAMLOCALPARAMETERI4IVEXTPROC)(GLuint program, GLenum target, GLuint index, const GLint * params);
+typedef void (GLAD_API_PTR *PFNGLNAMEDPROGRAMLOCALPARAMETERI4UIEXTPROC)(GLuint program, GLenum target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w);
+typedef void (GLAD_API_PTR *PFNGLNAMEDPROGRAMLOCALPARAMETERI4UIVEXTPROC)(GLuint program, GLenum target, GLuint index, const GLuint * params);
+typedef void (GLAD_API_PTR *PFNGLNAMEDPROGRAMLOCALPARAMETERS4FVEXTPROC)(GLuint program, GLenum target, GLuint index, GLsizei count, const GLfloat * params);
+typedef void (GLAD_API_PTR *PFNGLNAMEDPROGRAMLOCALPARAMETERSI4IVEXTPROC)(GLuint program, GLenum target, GLuint index, GLsizei count, const GLint * params);
+typedef void (GLAD_API_PTR *PFNGLNAMEDPROGRAMLOCALPARAMETERSI4UIVEXTPROC)(GLuint program, GLenum target, GLuint index, GLsizei count, const GLuint * params);
+typedef void (GLAD_API_PTR *PFNGLNAMEDPROGRAMSTRINGEXTPROC)(GLuint program, GLenum target, GLenum format, GLsizei len, const void * string);
+typedef void (GLAD_API_PTR *PFNGLNAMEDRENDERBUFFERSTORAGEEXTPROC)(GLuint renderbuffer, GLenum internalformat, GLsizei width, GLsizei height);
+typedef void (GLAD_API_PTR *PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLECOVERAGEEXTPROC)(GLuint renderbuffer, GLsizei coverageSamples, GLsizei colorSamples, GLenum internalformat, GLsizei width, GLsizei height);
+typedef void (GLAD_API_PTR *PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC)(GLuint renderbuffer, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);
+typedef void (GLAD_API_PTR *PFNGLNORMALPOINTEREXTPROC)(GLenum type, GLsizei stride, GLsizei count, const void * pointer);
+typedef void (GLAD_API_PTR *PFNGLPIXELSTOREFPROC)(GLenum pname, GLfloat param);
+typedef void (GLAD_API_PTR *PFNGLPIXELSTOREIPROC)(GLenum pname, GLint param);
+typedef void (GLAD_API_PTR *PFNGLPOINTPARAMETERFPROC)(GLenum pname, GLfloat param);
+typedef void (GLAD_API_PTR *PFNGLPOINTPARAMETERFARBPROC)(GLenum pname, GLfloat param);
+typedef void (GLAD_API_PTR *PFNGLPOINTPARAMETERFEXTPROC)(GLenum pname, GLfloat param);
+typedef void (GLAD_API_PTR *PFNGLPOINTPARAMETERFSGISPROC)(GLenum pname, GLfloat param);
+typedef void (GLAD_API_PTR *PFNGLPOINTPARAMETERFVPROC)(GLenum pname, const GLfloat * params);
+typedef void (GLAD_API_PTR *PFNGLPOINTPARAMETERFVARBPROC)(GLenum pname, const GLfloat * params);
+typedef void (GLAD_API_PTR *PFNGLPOINTPARAMETERFVEXTPROC)(GLenum pname, const GLfloat * params);
+typedef void (GLAD_API_PTR *PFNGLPOINTPARAMETERFVSGISPROC)(GLenum pname, const GLfloat * params);
+typedef void (GLAD_API_PTR *PFNGLPOINTPARAMETERIPROC)(GLenum pname, GLint param);
+typedef void (GLAD_API_PTR *PFNGLPOINTPARAMETERINVPROC)(GLenum pname, GLint param);
+typedef void (GLAD_API_PTR *PFNGLPOINTPARAMETERIVPROC)(GLenum pname, const GLint * params);
+typedef void (GLAD_API_PTR *PFNGLPOINTPARAMETERIVNVPROC)(GLenum pname, const GLint * params);
+typedef void (GLAD_API_PTR *PFNGLPOINTSIZEPROC)(GLfloat size);
+typedef void (GLAD_API_PTR *PFNGLPOLYGONMODEPROC)(GLenum face, GLenum mode);
+typedef void (GLAD_API_PTR *PFNGLPOLYGONOFFSETPROC)(GLfloat factor, GLfloat units);
+typedef void (GLAD_API_PTR *PFNGLPRIMITIVERESTARTINDEXPROC)(GLuint index);
+typedef void (GLAD_API_PTR *PFNGLPRIORITIZETEXTURESEXTPROC)(GLsizei n, const GLuint * textures, const GLclampf * priorities);
+typedef void (GLAD_API_PTR *PFNGLPROGRAMENVPARAMETER4DARBPROC)(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+typedef void (GLAD_API_PTR *PFNGLPROGRAMENVPARAMETER4DVARBPROC)(GLenum target, GLuint index, const GLdouble * params);
+typedef void (GLAD_API_PTR *PFNGLPROGRAMENVPARAMETER4FARBPROC)(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+typedef void (GLAD_API_PTR *PFNGLPROGRAMENVPARAMETER4FVARBPROC)(GLenum target, GLuint index, const GLfloat * params);
+typedef void (GLAD_API_PTR *PFNGLPROGRAMLOCALPARAMETER4DARBPROC)(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+typedef void (GLAD_API_PTR *PFNGLPROGRAMLOCALPARAMETER4DVARBPROC)(GLenum target, GLuint index, const GLdouble * params);
+typedef void (GLAD_API_PTR *PFNGLPROGRAMLOCALPARAMETER4FARBPROC)(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+typedef void (GLAD_API_PTR *PFNGLPROGRAMLOCALPARAMETER4FVARBPROC)(GLenum target, GLuint index, const GLfloat * params);
+typedef void (GLAD_API_PTR *PFNGLPROGRAMPARAMETER4DNVPROC)(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+typedef void (GLAD_API_PTR *PFNGLPROGRAMPARAMETER4DVNVPROC)(GLenum target, GLuint index, const GLdouble * v);
+typedef void (GLAD_API_PTR *PFNGLPROGRAMPARAMETER4FNVPROC)(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+typedef void (GLAD_API_PTR *PFNGLPROGRAMPARAMETER4FVNVPROC)(GLenum target, GLuint index, const GLfloat * v);
+typedef void (GLAD_API_PTR *PFNGLPROGRAMPARAMETERIARBPROC)(GLuint program, GLenum pname, GLint value);
+typedef void (GLAD_API_PTR *PFNGLPROGRAMPARAMETERS4DVNVPROC)(GLenum target, GLuint index, GLsizei count, const GLdouble * v);
+typedef void (GLAD_API_PTR *PFNGLPROGRAMPARAMETERS4FVNVPROC)(GLenum target, GLuint index, GLsizei count, const GLfloat * v);
+typedef void (GLAD_API_PTR *PFNGLPROGRAMSTRINGARBPROC)(GLenum target, GLenum format, GLsizei len, const void * string);
+typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORM1DEXTPROC)(GLuint program, GLint location, GLdouble x);
+typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORM1DVEXTPROC)(GLuint program, GLint location, GLsizei count, const GLdouble * value);
+typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORM1FEXTPROC)(GLuint program, GLint location, GLfloat v0);
+typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORM1FVEXTPROC)(GLuint program, GLint location, GLsizei count, const GLfloat * value);
+typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORM1IEXTPROC)(GLuint program, GLint location, GLint v0);
+typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORM1IVEXTPROC)(GLuint program, GLint location, GLsizei count, const GLint * value);
+typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORM1UIEXTPROC)(GLuint program, GLint location, GLuint v0);
+typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORM1UIVEXTPROC)(GLuint program, GLint location, GLsizei count, const GLuint * value);
+typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORM2DEXTPROC)(GLuint program, GLint location, GLdouble x, GLdouble y);
+typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORM2DVEXTPROC)(GLuint program, GLint location, GLsizei count, const GLdouble * value);
+typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORM2FEXTPROC)(GLuint program, GLint location, GLfloat v0, GLfloat v1);
+typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORM2FVEXTPROC)(GLuint program, GLint location, GLsizei count, const GLfloat * value);
+typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORM2IEXTPROC)(GLuint program, GLint location, GLint v0, GLint v1);
+typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORM2IVEXTPROC)(GLuint program, GLint location, GLsizei count, const GLint * value);
+typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORM2UIEXTPROC)(GLuint program, GLint location, GLuint v0, GLuint v1);
+typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORM2UIVEXTPROC)(GLuint program, GLint location, GLsizei count, const GLuint * value);
+typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORM3DEXTPROC)(GLuint program, GLint location, GLdouble x, GLdouble y, GLdouble z);
+typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORM3DVEXTPROC)(GLuint program, GLint location, GLsizei count, const GLdouble * value);
+typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORM3FEXTPROC)(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
+typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORM3FVEXTPROC)(GLuint program, GLint location, GLsizei count, const GLfloat * value);
+typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORM3IEXTPROC)(GLuint program, GLint location, GLint v0, GLint v1, GLint v2);
+typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORM3IVEXTPROC)(GLuint program, GLint location, GLsizei count, const GLint * value);
+typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORM3UIEXTPROC)(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2);
+typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORM3UIVEXTPROC)(GLuint program, GLint location, GLsizei count, const GLuint * value);
+typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORM4DEXTPROC)(GLuint program, GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORM4DVEXTPROC)(GLuint program, GLint location, GLsizei count, const GLdouble * value);
+typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORM4FEXTPROC)(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
+typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORM4FVEXTPROC)(GLuint program, GLint location, GLsizei count, const GLfloat * value);
+typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORM4IEXTPROC)(GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
+typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORM4IVEXTPROC)(GLuint program, GLint location, GLsizei count, const GLint * value);
+typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORM4UIEXTPROC)(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
+typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORM4UIVEXTPROC)(GLuint program, GLint location, GLsizei count, const GLuint * value);
+typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORMMATRIX2DVEXTPROC)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value);
+typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORMMATRIX2FVEXTPROC)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value);
+typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORMMATRIX2X3DVEXTPROC)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value);
+typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORMMATRIX2X3FVEXTPROC)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value);
+typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORMMATRIX2X4DVEXTPROC)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value);
+typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORMMATRIX2X4FVEXTPROC)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value);
+typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORMMATRIX3DVEXTPROC)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value);
+typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORMMATRIX3FVEXTPROC)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value);
+typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORMMATRIX3X2DVEXTPROC)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value);
+typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORMMATRIX3X2FVEXTPROC)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value);
+typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORMMATRIX3X4DVEXTPROC)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value);
+typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORMMATRIX3X4FVEXTPROC)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value);
+typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORMMATRIX4DVEXTPROC)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value);
+typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORMMATRIX4FVEXTPROC)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value);
+typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORMMATRIX4X2DVEXTPROC)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value);
+typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORMMATRIX4X2FVEXTPROC)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value);
+typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORMMATRIX4X3DVEXTPROC)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value);
+typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORMMATRIX4X3FVEXTPROC)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value);
+typedef void (GLAD_API_PTR *PFNGLPROGRAMVERTEXLIMITNVPROC)(GLenum target, GLint limit);
+typedef void (GLAD_API_PTR *PFNGLPROVOKINGVERTEXPROC)(GLenum mode);
+typedef void (GLAD_API_PTR *PFNGLPROVOKINGVERTEXEXTPROC)(GLenum mode);
+typedef void (GLAD_API_PTR *PFNGLPUSHCLIENTATTRIBDEFAULTEXTPROC)(GLbitfield mask);
+typedef void (GLAD_API_PTR *PFNGLREADBUFFERPROC)(GLenum src);
+typedef void (GLAD_API_PTR *PFNGLREADPIXELSPROC)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void * pixels);
+typedef void (GLAD_API_PTR *PFNGLRENDERBUFFERSTORAGEPROC)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
+typedef void (GLAD_API_PTR *PFNGLRENDERBUFFERSTORAGEEXTPROC)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
+typedef void (GLAD_API_PTR *PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);
+typedef void (GLAD_API_PTR *PFNGLRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);
+typedef void (GLAD_API_PTR *PFNGLREQUESTRESIDENTPROGRAMSNVPROC)(GLsizei n, const GLuint * programs);
+typedef void (GLAD_API_PTR *PFNGLSAMPLECOVERAGEPROC)(GLfloat value, GLboolean invert);
+typedef void (GLAD_API_PTR *PFNGLSAMPLECOVERAGEARBPROC)(GLfloat value, GLboolean invert);
+typedef void (GLAD_API_PTR *PFNGLSAMPLEMASKINDEXEDNVPROC)(GLuint index, GLbitfield mask);
+typedef void (GLAD_API_PTR *PFNGLSAMPLEMASKIPROC)(GLuint maskNumber, GLbitfield mask);
+typedef void (GLAD_API_PTR *PFNGLSCISSORPROC)(GLint x, GLint y, GLsizei width, GLsizei height);
+typedef void (GLAD_API_PTR *PFNGLSHADERSOURCEPROC)(GLuint shader, GLsizei count, const GLchar *const* string, const GLint * length);
+typedef void (GLAD_API_PTR *PFNGLSHADERSOURCEARBPROC)(GLhandleARB shaderObj, GLsizei count, const GLcharARB ** string, const GLint * length);
+typedef void (GLAD_API_PTR *PFNGLSTENCILFUNCPROC)(GLenum func, GLint ref, GLuint mask);
+typedef void (GLAD_API_PTR *PFNGLSTENCILFUNCSEPARATEPROC)(GLenum face, GLenum func, GLint ref, GLuint mask);
+typedef void (GLAD_API_PTR *PFNGLSTENCILFUNCSEPARATEATIPROC)(GLenum frontfunc, GLenum backfunc, GLint ref, GLuint mask);
+typedef void (GLAD_API_PTR *PFNGLSTENCILMASKPROC)(GLuint mask);
+typedef void (GLAD_API_PTR *PFNGLSTENCILMASKSEPARATEPROC)(GLenum face, GLuint mask);
+typedef void (GLAD_API_PTR *PFNGLSTENCILOPPROC)(GLenum fail, GLenum zfail, GLenum zpass);
+typedef void (GLAD_API_PTR *PFNGLSTENCILOPSEPARATEPROC)(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass);
+typedef void (GLAD_API_PTR *PFNGLSTENCILOPSEPARATEATIPROC)(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass);
+typedef void (GLAD_API_PTR *PFNGLTEXBUFFERPROC)(GLenum target, GLenum internalformat, GLuint buffer);
+typedef void (GLAD_API_PTR *PFNGLTEXBUFFERARBPROC)(GLenum target, GLenum internalformat, GLuint buffer);
+typedef void (GLAD_API_PTR *PFNGLTEXBUFFEREXTPROC)(GLenum target, GLenum internalformat, GLuint buffer);
+typedef void (GLAD_API_PTR *PFNGLTEXCOORDPOINTEREXTPROC)(GLint size, GLenum type, GLsizei stride, GLsizei count, const void * pointer);
+typedef void (GLAD_API_PTR *PFNGLTEXIMAGE1DPROC)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void * pixels);
+typedef void (GLAD_API_PTR *PFNGLTEXIMAGE2DPROC)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void * pixels);
+typedef void (GLAD_API_PTR *PFNGLTEXIMAGE2DMULTISAMPLEPROC)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations);
+typedef void (GLAD_API_PTR *PFNGLTEXIMAGE3DPROC)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void * pixels);
+typedef void (GLAD_API_PTR *PFNGLTEXIMAGE3DEXTPROC)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void * pixels);
+typedef void (GLAD_API_PTR *PFNGLTEXIMAGE3DMULTISAMPLEPROC)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations);
+typedef void (GLAD_API_PTR *PFNGLTEXPARAMETERIIVPROC)(GLenum target, GLenum pname, const GLint * params);
+typedef void (GLAD_API_PTR *PFNGLTEXPARAMETERIIVEXTPROC)(GLenum target, GLenum pname, const GLint * params);
+typedef void (GLAD_API_PTR *PFNGLTEXPARAMETERIUIVPROC)(GLenum target, GLenum pname, const GLuint * params);
+typedef void (GLAD_API_PTR *PFNGLTEXPARAMETERIUIVEXTPROC)(GLenum target, GLenum pname, const GLuint * params);
+typedef void (GLAD_API_PTR *PFNGLTEXPARAMETERFPROC)(GLenum target, GLenum pname, GLfloat param);
+typedef void (GLAD_API_PTR *PFNGLTEXPARAMETERFVPROC)(GLenum target, GLenum pname, const GLfloat * params);
+typedef void (GLAD_API_PTR *PFNGLTEXPARAMETERIPROC)(GLenum target, GLenum pname, GLint param);
+typedef void (GLAD_API_PTR *PFNGLTEXPARAMETERIVPROC)(GLenum target, GLenum pname, const GLint * params);
+typedef void (GLAD_API_PTR *PFNGLTEXRENDERBUFFERNVPROC)(GLenum target, GLuint renderbuffer);
+typedef void (GLAD_API_PTR *PFNGLTEXSUBIMAGE1DPROC)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void * pixels);
+typedef void (GLAD_API_PTR *PFNGLTEXSUBIMAGE1DEXTPROC)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void * pixels);
+typedef void (GLAD_API_PTR *PFNGLTEXSUBIMAGE2DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void * pixels);
+typedef void (GLAD_API_PTR *PFNGLTEXSUBIMAGE2DEXTPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void * pixels);
+typedef void (GLAD_API_PTR *PFNGLTEXSUBIMAGE3DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void * pixels);
+typedef void (GLAD_API_PTR *PFNGLTEXSUBIMAGE3DEXTPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void * pixels);
+typedef void (GLAD_API_PTR *PFNGLTEXTUREBUFFEREXTPROC)(GLuint texture, GLenum target, GLenum internalformat, GLuint buffer);
+typedef void (GLAD_API_PTR *PFNGLTEXTUREBUFFERRANGEEXTPROC)(GLuint texture, GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size);
+typedef void (GLAD_API_PTR *PFNGLTEXTUREIMAGE1DEXTPROC)(GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void * pixels);
+typedef void (GLAD_API_PTR *PFNGLTEXTUREIMAGE2DEXTPROC)(GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void * pixels);
+typedef void (GLAD_API_PTR *PFNGLTEXTUREIMAGE3DEXTPROC)(GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void * pixels);
+typedef void (GLAD_API_PTR *PFNGLTEXTUREPAGECOMMITMENTEXTPROC)(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLboolean commit);
+typedef void (GLAD_API_PTR *PFNGLTEXTUREPARAMETERIIVEXTPROC)(GLuint texture, GLenum target, GLenum pname, const GLint * params);
+typedef void (GLAD_API_PTR *PFNGLTEXTUREPARAMETERIUIVEXTPROC)(GLuint texture, GLenum target, GLenum pname, const GLuint * params);
+typedef void (GLAD_API_PTR *PFNGLTEXTUREPARAMETERFEXTPROC)(GLuint texture, GLenum target, GLenum pname, GLfloat param);
+typedef void (GLAD_API_PTR *PFNGLTEXTUREPARAMETERFVEXTPROC)(GLuint texture, GLenum target, GLenum pname, const GLfloat * params);
+typedef void (GLAD_API_PTR *PFNGLTEXTUREPARAMETERIEXTPROC)(GLuint texture, GLenum target, GLenum pname, GLint param);
+typedef void (GLAD_API_PTR *PFNGLTEXTUREPARAMETERIVEXTPROC)(GLuint texture, GLenum target, GLenum pname, const GLint * params);
+typedef void (GLAD_API_PTR *PFNGLTEXTURERENDERBUFFEREXTPROC)(GLuint texture, GLenum target, GLuint renderbuffer);
+typedef void (GLAD_API_PTR *PFNGLTEXTURESTORAGE1DEXTPROC)(GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width);
+typedef void (GLAD_API_PTR *PFNGLTEXTURESTORAGE2DEXTPROC)(GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height);
+typedef void (GLAD_API_PTR *PFNGLTEXTURESTORAGE2DMULTISAMPLEEXTPROC)(GLuint texture, GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations);
+typedef void (GLAD_API_PTR *PFNGLTEXTURESTORAGE3DEXTPROC)(GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth);
+typedef void (GLAD_API_PTR *PFNGLTEXTURESTORAGE3DMULTISAMPLEEXTPROC)(GLuint texture, GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations);
+typedef void (GLAD_API_PTR *PFNGLTEXTURESUBIMAGE1DEXTPROC)(GLuint texture, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void * pixels);
+typedef void (GLAD_API_PTR *PFNGLTEXTURESUBIMAGE2DEXTPROC)(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void * pixels);
+typedef void (GLAD_API_PTR *PFNGLTEXTURESUBIMAGE3DEXTPROC)(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void * pixels);
+typedef void (GLAD_API_PTR *PFNGLTRACKMATRIXNVPROC)(GLenum target, GLuint address, GLenum matrix, GLenum transform);
+typedef void (GLAD_API_PTR *PFNGLTRANSFORMFEEDBACKATTRIBSNVPROC)(GLsizei count, const GLint * attribs, GLenum bufferMode);
+typedef void (GLAD_API_PTR *PFNGLTRANSFORMFEEDBACKSTREAMATTRIBSNVPROC)(GLsizei count, const GLint * attribs, GLsizei nbuffers, const GLint * bufstreams, GLenum bufferMode);
+typedef void (GLAD_API_PTR *PFNGLTRANSFORMFEEDBACKVARYINGSPROC)(GLuint program, GLsizei count, const GLchar *const* varyings, GLenum bufferMode);
+typedef void (GLAD_API_PTR *PFNGLTRANSFORMFEEDBACKVARYINGSEXTPROC)(GLuint program, GLsizei count, const GLchar *const* varyings, GLenum bufferMode);
+typedef void (GLAD_API_PTR *PFNGLTRANSFORMFEEDBACKVARYINGSNVPROC)(GLuint program, GLsizei count, const GLint * locations, GLenum bufferMode);
+typedef void (GLAD_API_PTR *PFNGLUNIFORM1FPROC)(GLint location, GLfloat v0);
+typedef void (GLAD_API_PTR *PFNGLUNIFORM1FARBPROC)(GLint location, GLfloat v0);
+typedef void (GLAD_API_PTR *PFNGLUNIFORM1FVPROC)(GLint location, GLsizei count, const GLfloat * value);
+typedef void (GLAD_API_PTR *PFNGLUNIFORM1FVARBPROC)(GLint location, GLsizei count, const GLfloat * value);
+typedef void (GLAD_API_PTR *PFNGLUNIFORM1IPROC)(GLint location, GLint v0);
+typedef void (GLAD_API_PTR *PFNGLUNIFORM1IARBPROC)(GLint location, GLint v0);
+typedef void (GLAD_API_PTR *PFNGLUNIFORM1IVPROC)(GLint location, GLsizei count, const GLint * value);
+typedef void (GLAD_API_PTR *PFNGLUNIFORM1IVARBPROC)(GLint location, GLsizei count, const GLint * value);
+typedef void (GLAD_API_PTR *PFNGLUNIFORM1UIPROC)(GLint location, GLuint v0);
+typedef void (GLAD_API_PTR *PFNGLUNIFORM1UIEXTPROC)(GLint location, GLuint v0);
+typedef void (GLAD_API_PTR *PFNGLUNIFORM1UIVPROC)(GLint location, GLsizei count, const GLuint * value);
+typedef void (GLAD_API_PTR *PFNGLUNIFORM1UIVEXTPROC)(GLint location, GLsizei count, const GLuint * value);
+typedef void (GLAD_API_PTR *PFNGLUNIFORM2FPROC)(GLint location, GLfloat v0, GLfloat v1);
+typedef void (GLAD_API_PTR *PFNGLUNIFORM2FARBPROC)(GLint location, GLfloat v0, GLfloat v1);
+typedef void (GLAD_API_PTR *PFNGLUNIFORM2FVPROC)(GLint location, GLsizei count, const GLfloat * value);
+typedef void (GLAD_API_PTR *PFNGLUNIFORM2FVARBPROC)(GLint location, GLsizei count, const GLfloat * value);
+typedef void (GLAD_API_PTR *PFNGLUNIFORM2IPROC)(GLint location, GLint v0, GLint v1);
+typedef void (GLAD_API_PTR *PFNGLUNIFORM2IARBPROC)(GLint location, GLint v0, GLint v1);
+typedef void (GLAD_API_PTR *PFNGLUNIFORM2IVPROC)(GLint location, GLsizei count, const GLint * value);
+typedef void (GLAD_API_PTR *PFNGLUNIFORM2IVARBPROC)(GLint location, GLsizei count, const GLint * value);
+typedef void (GLAD_API_PTR *PFNGLUNIFORM2UIPROC)(GLint location, GLuint v0, GLuint v1);
+typedef void (GLAD_API_PTR *PFNGLUNIFORM2UIEXTPROC)(GLint location, GLuint v0, GLuint v1);
+typedef void (GLAD_API_PTR *PFNGLUNIFORM2UIVPROC)(GLint location, GLsizei count, const GLuint * value);
+typedef void (GLAD_API_PTR *PFNGLUNIFORM2UIVEXTPROC)(GLint location, GLsizei count, const GLuint * value);
+typedef void (GLAD_API_PTR *PFNGLUNIFORM3FPROC)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
+typedef void (GLAD_API_PTR *PFNGLUNIFORM3FARBPROC)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
+typedef void (GLAD_API_PTR *PFNGLUNIFORM3FVPROC)(GLint location, GLsizei count, const GLfloat * value);
+typedef void (GLAD_API_PTR *PFNGLUNIFORM3FVARBPROC)(GLint location, GLsizei count, const GLfloat * value);
+typedef void (GLAD_API_PTR *PFNGLUNIFORM3IPROC)(GLint location, GLint v0, GLint v1, GLint v2);
+typedef void (GLAD_API_PTR *PFNGLUNIFORM3IARBPROC)(GLint location, GLint v0, GLint v1, GLint v2);
+typedef void (GLAD_API_PTR *PFNGLUNIFORM3IVPROC)(GLint location, GLsizei count, const GLint * value);
+typedef void (GLAD_API_PTR *PFNGLUNIFORM3IVARBPROC)(GLint location, GLsizei count, const GLint * value);
+typedef void (GLAD_API_PTR *PFNGLUNIFORM3UIPROC)(GLint location, GLuint v0, GLuint v1, GLuint v2);
+typedef void (GLAD_API_PTR *PFNGLUNIFORM3UIEXTPROC)(GLint location, GLuint v0, GLuint v1, GLuint v2);
+typedef void (GLAD_API_PTR *PFNGLUNIFORM3UIVPROC)(GLint location, GLsizei count, const GLuint * value);
+typedef void (GLAD_API_PTR *PFNGLUNIFORM3UIVEXTPROC)(GLint location, GLsizei count, const GLuint * value);
+typedef void (GLAD_API_PTR *PFNGLUNIFORM4FPROC)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
+typedef void (GLAD_API_PTR *PFNGLUNIFORM4FARBPROC)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
+typedef void (GLAD_API_PTR *PFNGLUNIFORM4FVPROC)(GLint location, GLsizei count, const GLfloat * value);
+typedef void (GLAD_API_PTR *PFNGLUNIFORM4FVARBPROC)(GLint location, GLsizei count, const GLfloat * value);
+typedef void (GLAD_API_PTR *PFNGLUNIFORM4IPROC)(GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
+typedef void (GLAD_API_PTR *PFNGLUNIFORM4IARBPROC)(GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
+typedef void (GLAD_API_PTR *PFNGLUNIFORM4IVPROC)(GLint location, GLsizei count, const GLint * value);
+typedef void (GLAD_API_PTR *PFNGLUNIFORM4IVARBPROC)(GLint location, GLsizei count, const GLint * value);
+typedef void (GLAD_API_PTR *PFNGLUNIFORM4UIPROC)(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
+typedef void (GLAD_API_PTR *PFNGLUNIFORM4UIEXTPROC)(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
+typedef void (GLAD_API_PTR *PFNGLUNIFORM4UIVPROC)(GLint location, GLsizei count, const GLuint * value);
+typedef void (GLAD_API_PTR *PFNGLUNIFORM4UIVEXTPROC)(GLint location, GLsizei count, const GLuint * value);
+typedef void (GLAD_API_PTR *PFNGLUNIFORMBLOCKBINDINGPROC)(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding);
+typedef void (GLAD_API_PTR *PFNGLUNIFORMMATRIX2FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value);
+typedef void (GLAD_API_PTR *PFNGLUNIFORMMATRIX2FVARBPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value);
+typedef void (GLAD_API_PTR *PFNGLUNIFORMMATRIX2X3FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value);
+typedef void (GLAD_API_PTR *PFNGLUNIFORMMATRIX2X4FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value);
+typedef void (GLAD_API_PTR *PFNGLUNIFORMMATRIX3FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value);
+typedef void (GLAD_API_PTR *PFNGLUNIFORMMATRIX3FVARBPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value);
+typedef void (GLAD_API_PTR *PFNGLUNIFORMMATRIX3X2FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value);
+typedef void (GLAD_API_PTR *PFNGLUNIFORMMATRIX3X4FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value);
+typedef void (GLAD_API_PTR *PFNGLUNIFORMMATRIX4FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value);
+typedef void (GLAD_API_PTR *PFNGLUNIFORMMATRIX4FVARBPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value);
+typedef void (GLAD_API_PTR *PFNGLUNIFORMMATRIX4X2FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value);
+typedef void (GLAD_API_PTR *PFNGLUNIFORMMATRIX4X3FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value);
+typedef GLboolean (GLAD_API_PTR *PFNGLUNMAPBUFFERPROC)(GLenum target);
+typedef GLboolean (GLAD_API_PTR *PFNGLUNMAPBUFFERARBPROC)(GLenum target);
+typedef GLboolean (GLAD_API_PTR *PFNGLUNMAPNAMEDBUFFEREXTPROC)(GLuint buffer);
+typedef void (GLAD_API_PTR *PFNGLUSEPROGRAMPROC)(GLuint program);
+typedef void (GLAD_API_PTR *PFNGLUSEPROGRAMOBJECTARBPROC)(GLhandleARB programObj);
+typedef void (GLAD_API_PTR *PFNGLVALIDATEPROGRAMPROC)(GLuint program);
+typedef void (GLAD_API_PTR *PFNGLVALIDATEPROGRAMARBPROC)(GLhandleARB programObj);
+typedef void (GLAD_API_PTR *PFNGLVERTEXARRAYBINDVERTEXBUFFEREXTPROC)(GLuint vaobj, GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride);
+typedef void (GLAD_API_PTR *PFNGLVERTEXARRAYCOLOROFFSETEXTPROC)(GLuint vaobj, GLuint buffer, GLint size, GLenum type, GLsizei stride, GLintptr offset);
+typedef void (GLAD_API_PTR *PFNGLVERTEXARRAYEDGEFLAGOFFSETEXTPROC)(GLuint vaobj, GLuint buffer, GLsizei stride, GLintptr offset);
+typedef void (GLAD_API_PTR *PFNGLVERTEXARRAYFOGCOORDOFFSETEXTPROC)(GLuint vaobj, GLuint buffer, GLenum type, GLsizei stride, GLintptr offset);
+typedef void (GLAD_API_PTR *PFNGLVERTEXARRAYINDEXOFFSETEXTPROC)(GLuint vaobj, GLuint buffer, GLenum type, GLsizei stride, GLintptr offset);
+typedef void (GLAD_API_PTR *PFNGLVERTEXARRAYMULTITEXCOORDOFFSETEXTPROC)(GLuint vaobj, GLuint buffer, GLenum texunit, GLint size, GLenum type, GLsizei stride, GLintptr offset);
+typedef void (GLAD_API_PTR *PFNGLVERTEXARRAYNORMALOFFSETEXTPROC)(GLuint vaobj, GLuint buffer, GLenum type, GLsizei stride, GLintptr offset);
+typedef void (GLAD_API_PTR *PFNGLVERTEXARRAYSECONDARYCOLOROFFSETEXTPROC)(GLuint vaobj, GLuint buffer, GLint size, GLenum type, GLsizei stride, GLintptr offset);
+typedef void (GLAD_API_PTR *PFNGLVERTEXARRAYTEXCOORDOFFSETEXTPROC)(GLuint vaobj, GLuint buffer, GLint size, GLenum type, GLsizei stride, GLintptr offset);
+typedef void (GLAD_API_PTR *PFNGLVERTEXARRAYVERTEXATTRIBBINDINGEXTPROC)(GLuint vaobj, GLuint attribindex, GLuint bindingindex);
+typedef void (GLAD_API_PTR *PFNGLVERTEXARRAYVERTEXATTRIBDIVISOREXTPROC)(GLuint vaobj, GLuint index, GLuint divisor);
+typedef void (GLAD_API_PTR *PFNGLVERTEXARRAYVERTEXATTRIBFORMATEXTPROC)(GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset);
+typedef void (GLAD_API_PTR *PFNGLVERTEXARRAYVERTEXATTRIBIFORMATEXTPROC)(GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset);
+typedef void (GLAD_API_PTR *PFNGLVERTEXARRAYVERTEXATTRIBIOFFSETEXTPROC)(GLuint vaobj, GLuint buffer, GLuint index, GLint size, GLenum type, GLsizei stride, GLintptr offset);
+typedef void (GLAD_API_PTR *PFNGLVERTEXARRAYVERTEXATTRIBLFORMATEXTPROC)(GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset);
+typedef void (GLAD_API_PTR *PFNGLVERTEXARRAYVERTEXATTRIBLOFFSETEXTPROC)(GLuint vaobj, GLuint buffer, GLuint index, GLint size, GLenum type, GLsizei stride, GLintptr offset);
+typedef void (GLAD_API_PTR *PFNGLVERTEXARRAYVERTEXATTRIBOFFSETEXTPROC)(GLuint vaobj, GLuint buffer, GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, GLintptr offset);
+typedef void (GLAD_API_PTR *PFNGLVERTEXARRAYVERTEXBINDINGDIVISOREXTPROC)(GLuint vaobj, GLuint bindingindex, GLuint divisor);
+typedef void (GLAD_API_PTR *PFNGLVERTEXARRAYVERTEXOFFSETEXTPROC)(GLuint vaobj, GLuint buffer, GLint size, GLenum type, GLsizei stride, GLintptr offset);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB1DPROC)(GLuint index, GLdouble x);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB1DARBPROC)(GLuint index, GLdouble x);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB1DNVPROC)(GLuint index, GLdouble x);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB1DVPROC)(GLuint index, const GLdouble * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB1DVARBPROC)(GLuint index, const GLdouble * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB1DVNVPROC)(GLuint index, const GLdouble * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB1FPROC)(GLuint index, GLfloat x);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB1FARBPROC)(GLuint index, GLfloat x);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB1FNVPROC)(GLuint index, GLfloat x);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB1FVPROC)(GLuint index, const GLfloat * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB1FVARBPROC)(GLuint index, const GLfloat * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB1FVNVPROC)(GLuint index, const GLfloat * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB1SPROC)(GLuint index, GLshort x);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB1SARBPROC)(GLuint index, GLshort x);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB1SNVPROC)(GLuint index, GLshort x);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB1SVPROC)(GLuint index, const GLshort * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB1SVARBPROC)(GLuint index, const GLshort * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB1SVNVPROC)(GLuint index, const GLshort * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB2DPROC)(GLuint index, GLdouble x, GLdouble y);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB2DARBPROC)(GLuint index, GLdouble x, GLdouble y);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB2DNVPROC)(GLuint index, GLdouble x, GLdouble y);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB2DVPROC)(GLuint index, const GLdouble * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB2DVARBPROC)(GLuint index, const GLdouble * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB2DVNVPROC)(GLuint index, const GLdouble * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB2FPROC)(GLuint index, GLfloat x, GLfloat y);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB2FARBPROC)(GLuint index, GLfloat x, GLfloat y);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB2FNVPROC)(GLuint index, GLfloat x, GLfloat y);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB2FVPROC)(GLuint index, const GLfloat * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB2FVARBPROC)(GLuint index, const GLfloat * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB2FVNVPROC)(GLuint index, const GLfloat * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB2SPROC)(GLuint index, GLshort x, GLshort y);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB2SARBPROC)(GLuint index, GLshort x, GLshort y);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB2SNVPROC)(GLuint index, GLshort x, GLshort y);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB2SVPROC)(GLuint index, const GLshort * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB2SVARBPROC)(GLuint index, const GLshort * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB2SVNVPROC)(GLuint index, const GLshort * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB3DPROC)(GLuint index, GLdouble x, GLdouble y, GLdouble z);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB3DARBPROC)(GLuint index, GLdouble x, GLdouble y, GLdouble z);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB3DNVPROC)(GLuint index, GLdouble x, GLdouble y, GLdouble z);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB3DVPROC)(GLuint index, const GLdouble * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB3DVARBPROC)(GLuint index, const GLdouble * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB3DVNVPROC)(GLuint index, const GLdouble * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB3FPROC)(GLuint index, GLfloat x, GLfloat y, GLfloat z);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB3FARBPROC)(GLuint index, GLfloat x, GLfloat y, GLfloat z);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB3FNVPROC)(GLuint index, GLfloat x, GLfloat y, GLfloat z);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB3FVPROC)(GLuint index, const GLfloat * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB3FVARBPROC)(GLuint index, const GLfloat * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB3FVNVPROC)(GLuint index, const GLfloat * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB3SPROC)(GLuint index, GLshort x, GLshort y, GLshort z);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB3SARBPROC)(GLuint index, GLshort x, GLshort y, GLshort z);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB3SNVPROC)(GLuint index, GLshort x, GLshort y, GLshort z);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB3SVPROC)(GLuint index, const GLshort * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB3SVARBPROC)(GLuint index, const GLshort * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB3SVNVPROC)(GLuint index, const GLshort * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4NBVPROC)(GLuint index, const GLbyte * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4NBVARBPROC)(GLuint index, const GLbyte * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4NIVPROC)(GLuint index, const GLint * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4NIVARBPROC)(GLuint index, const GLint * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4NSVPROC)(GLuint index, const GLshort * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4NSVARBPROC)(GLuint index, const GLshort * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4NUBPROC)(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4NUBARBPROC)(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4NUBVPROC)(GLuint index, const GLubyte * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4NUBVARBPROC)(GLuint index, const GLubyte * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4NUIVPROC)(GLuint index, const GLuint * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4NUIVARBPROC)(GLuint index, const GLuint * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4NUSVPROC)(GLuint index, const GLushort * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4NUSVARBPROC)(GLuint index, const GLushort * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4BVPROC)(GLuint index, const GLbyte * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4BVARBPROC)(GLuint index, const GLbyte * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4DPROC)(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4DARBPROC)(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4DNVPROC)(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4DVPROC)(GLuint index, const GLdouble * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4DVARBPROC)(GLuint index, const GLdouble * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4DVNVPROC)(GLuint index, const GLdouble * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4FPROC)(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4FARBPROC)(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4FNVPROC)(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4FVPROC)(GLuint index, const GLfloat * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4FVARBPROC)(GLuint index, const GLfloat * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4FVNVPROC)(GLuint index, const GLfloat * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4IVPROC)(GLuint index, const GLint * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4IVARBPROC)(GLuint index, const GLint * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4SPROC)(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4SARBPROC)(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4SNVPROC)(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4SVPROC)(GLuint index, const GLshort * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4SVARBPROC)(GLuint index, const GLshort * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4SVNVPROC)(GLuint index, const GLshort * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4UBNVPROC)(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4UBVPROC)(GLuint index, const GLubyte * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4UBVARBPROC)(GLuint index, const GLubyte * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4UBVNVPROC)(GLuint index, const GLubyte * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4UIVPROC)(GLuint index, const GLuint * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4UIVARBPROC)(GLuint index, const GLuint * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4USVPROC)(GLuint index, const GLushort * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4USVARBPROC)(GLuint index, const GLushort * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBI1IPROC)(GLuint index, GLint x);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBI1IEXTPROC)(GLuint index, GLint x);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBI1IVPROC)(GLuint index, const GLint * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBI1IVEXTPROC)(GLuint index, const GLint * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBI1UIPROC)(GLuint index, GLuint x);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBI1UIEXTPROC)(GLuint index, GLuint x);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBI1UIVPROC)(GLuint index, const GLuint * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBI1UIVEXTPROC)(GLuint index, const GLuint * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBI2IPROC)(GLuint index, GLint x, GLint y);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBI2IEXTPROC)(GLuint index, GLint x, GLint y);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBI2IVPROC)(GLuint index, const GLint * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBI2IVEXTPROC)(GLuint index, const GLint * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBI2UIPROC)(GLuint index, GLuint x, GLuint y);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBI2UIEXTPROC)(GLuint index, GLuint x, GLuint y);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBI2UIVPROC)(GLuint index, const GLuint * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBI2UIVEXTPROC)(GLuint index, const GLuint * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBI3IPROC)(GLuint index, GLint x, GLint y, GLint z);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBI3IEXTPROC)(GLuint index, GLint x, GLint y, GLint z);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBI3IVPROC)(GLuint index, const GLint * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBI3IVEXTPROC)(GLuint index, const GLint * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBI3UIPROC)(GLuint index, GLuint x, GLuint y, GLuint z);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBI3UIEXTPROC)(GLuint index, GLuint x, GLuint y, GLuint z);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBI3UIVPROC)(GLuint index, const GLuint * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBI3UIVEXTPROC)(GLuint index, const GLuint * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBI4BVPROC)(GLuint index, const GLbyte * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBI4BVEXTPROC)(GLuint index, const GLbyte * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBI4IPROC)(GLuint index, GLint x, GLint y, GLint z, GLint w);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBI4IEXTPROC)(GLuint index, GLint x, GLint y, GLint z, GLint w);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBI4IVPROC)(GLuint index, const GLint * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBI4IVEXTPROC)(GLuint index, const GLint * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBI4SVPROC)(GLuint index, const GLshort * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBI4SVEXTPROC)(GLuint index, const GLshort * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBI4UBVPROC)(GLuint index, const GLubyte * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBI4UBVEXTPROC)(GLuint index, const GLubyte * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBI4UIPROC)(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBI4UIEXTPROC)(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBI4UIVPROC)(GLuint index, const GLuint * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBI4UIVEXTPROC)(GLuint index, const GLuint * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBI4USVPROC)(GLuint index, const GLushort * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBI4USVEXTPROC)(GLuint index, const GLushort * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBIPOINTERPROC)(GLuint index, GLint size, GLenum type, GLsizei stride, const void * pointer);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBIPOINTEREXTPROC)(GLuint index, GLint size, GLenum type, GLsizei stride, const void * pointer);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBPOINTERPROC)(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void * pointer);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBPOINTERARBPROC)(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void * pointer);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBPOINTERNVPROC)(GLuint index, GLint fsize, GLenum type, GLsizei stride, const void * pointer);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBS1DVNVPROC)(GLuint index, GLsizei count, const GLdouble * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBS1FVNVPROC)(GLuint index, GLsizei count, const GLfloat * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBS1SVNVPROC)(GLuint index, GLsizei count, const GLshort * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBS2DVNVPROC)(GLuint index, GLsizei count, const GLdouble * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBS2FVNVPROC)(GLuint index, GLsizei count, const GLfloat * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBS2SVNVPROC)(GLuint index, GLsizei count, const GLshort * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBS3DVNVPROC)(GLuint index, GLsizei count, const GLdouble * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBS3FVNVPROC)(GLuint index, GLsizei count, const GLfloat * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBS3SVNVPROC)(GLuint index, GLsizei count, const GLshort * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBS4DVNVPROC)(GLuint index, GLsizei count, const GLdouble * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBS4FVNVPROC)(GLuint index, GLsizei count, const GLfloat * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBS4SVNVPROC)(GLuint index, GLsizei count, const GLshort * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBS4UBVNVPROC)(GLuint index, GLsizei count, const GLubyte * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXPOINTEREXTPROC)(GLint size, GLenum type, GLsizei stride, GLsizei count, const void * pointer);
+typedef void (GLAD_API_PTR *PFNGLVIEWPORTPROC)(GLint x, GLint y, GLsizei width, GLsizei height);
+typedef void (GLAD_API_PTR *PFNGLWAITSYNCPROC)(GLsync sync, GLbitfield flags, GLuint64 timeout);
+
+typedef struct GladGLContext {
+    void* userptr;
+
+    int VERSION_1_0;
+    int VERSION_1_1;
+    int VERSION_1_2;
+    int VERSION_1_3;
+    int VERSION_1_4;
+    int VERSION_1_5;
+    int VERSION_2_0;
+    int VERSION_2_1;
+    int VERSION_3_0;
+    int VERSION_3_1;
+    int VERSION_3_2;
+    int APPLE_flush_buffer_range;
+    int APPLE_vertex_array_object;
+    int ARB_color_buffer_float;
+    int ARB_copy_buffer;
+    int ARB_draw_buffers;
+    int ARB_draw_elements_base_vertex;
+    int ARB_draw_instanced;
+    int ARB_framebuffer_object;
+    int ARB_geometry_shader4;
+    int ARB_imaging;
+    int ARB_map_buffer_range;
+    int ARB_multisample;
+    int ARB_multitexture;
+    int ARB_occlusion_query;
+    int ARB_point_parameters;
+    int ARB_provoking_vertex;
+    int ARB_shader_objects;
+    int ARB_sync;
+    int ARB_texture_buffer_object;
+    int ARB_texture_compression;
+    int ARB_texture_multisample;
+    int ARB_uniform_buffer_object;
+    int ARB_vertex_array_object;
+    int ARB_vertex_buffer_object;
+    int ARB_vertex_program;
+    int ARB_vertex_shader;
+    int ATI_draw_buffers;
+    int ATI_separate_stencil;
+    int EXT_blend_color;
+    int EXT_blend_equation_separate;
+    int EXT_blend_func_separate;
+    int EXT_blend_minmax;
+    int EXT_copy_texture;
+    int EXT_direct_state_access;
+    int EXT_draw_buffers2;
+    int EXT_draw_instanced;
+    int EXT_draw_range_elements;
+    int EXT_framebuffer_blit;
+    int EXT_framebuffer_multisample;
+    int EXT_framebuffer_object;
+    int EXT_gpu_shader4;
+    int EXT_multi_draw_arrays;
+    int EXT_point_parameters;
+    int EXT_provoking_vertex;
+    int EXT_subtexture;
+    int EXT_texture3D;
+    int EXT_texture_array;
+    int EXT_texture_buffer_object;
+    int EXT_texture_integer;
+    int EXT_texture_object;
+    int EXT_transform_feedback;
+    int EXT_vertex_array;
+    int INGR_blend_func_separate;
+    int NVX_conditional_render;
+    int NV_conditional_render;
+    int NV_explicit_multisample;
+    int NV_geometry_program4;
+    int NV_point_sprite;
+    int NV_transform_feedback;
+    int NV_vertex_program;
+    int NV_vertex_program4;
+    int SGIS_point_parameters;
+
+    PFNGLACTIVETEXTUREPROC ActiveTexture;
+    PFNGLACTIVETEXTUREARBPROC ActiveTextureARB;
+    PFNGLACTIVEVARYINGNVPROC ActiveVaryingNV;
+    PFNGLAREPROGRAMSRESIDENTNVPROC AreProgramsResidentNV;
+    PFNGLARETEXTURESRESIDENTEXTPROC AreTexturesResidentEXT;
+    PFNGLARRAYELEMENTEXTPROC ArrayElementEXT;
+    PFNGLATTACHOBJECTARBPROC AttachObjectARB;
+    PFNGLATTACHSHADERPROC AttachShader;
+    PFNGLBEGINCONDITIONALRENDERPROC BeginConditionalRender;
+    PFNGLBEGINCONDITIONALRENDERNVPROC BeginConditionalRenderNV;
+    PFNGLBEGINCONDITIONALRENDERNVXPROC BeginConditionalRenderNVX;
+    PFNGLBEGINQUERYPROC BeginQuery;
+    PFNGLBEGINQUERYARBPROC BeginQueryARB;
+    PFNGLBEGINTRANSFORMFEEDBACKPROC BeginTransformFeedback;
+    PFNGLBEGINTRANSFORMFEEDBACKEXTPROC BeginTransformFeedbackEXT;
+    PFNGLBEGINTRANSFORMFEEDBACKNVPROC BeginTransformFeedbackNV;
+    PFNGLBINDATTRIBLOCATIONPROC BindAttribLocation;
+    PFNGLBINDATTRIBLOCATIONARBPROC BindAttribLocationARB;
+    PFNGLBINDBUFFERPROC BindBuffer;
+    PFNGLBINDBUFFERARBPROC BindBufferARB;
+    PFNGLBINDBUFFERBASEPROC BindBufferBase;
+    PFNGLBINDBUFFERBASEEXTPROC BindBufferBaseEXT;
+    PFNGLBINDBUFFERBASENVPROC BindBufferBaseNV;
+    PFNGLBINDBUFFEROFFSETEXTPROC BindBufferOffsetEXT;
+    PFNGLBINDBUFFEROFFSETNVPROC BindBufferOffsetNV;
+    PFNGLBINDBUFFERRANGEPROC BindBufferRange;
+    PFNGLBINDBUFFERRANGEEXTPROC BindBufferRangeEXT;
+    PFNGLBINDBUFFERRANGENVPROC BindBufferRangeNV;
+    PFNGLBINDFRAGDATALOCATIONPROC BindFragDataLocation;
+    PFNGLBINDFRAGDATALOCATIONEXTPROC BindFragDataLocationEXT;
+    PFNGLBINDFRAMEBUFFERPROC BindFramebuffer;
+    PFNGLBINDFRAMEBUFFEREXTPROC BindFramebufferEXT;
+    PFNGLBINDMULTITEXTUREEXTPROC BindMultiTextureEXT;
+    PFNGLBINDPROGRAMARBPROC BindProgramARB;
+    PFNGLBINDPROGRAMNVPROC BindProgramNV;
+    PFNGLBINDRENDERBUFFERPROC BindRenderbuffer;
+    PFNGLBINDRENDERBUFFEREXTPROC BindRenderbufferEXT;
+    PFNGLBINDTEXTUREPROC BindTexture;
+    PFNGLBINDTEXTUREEXTPROC BindTextureEXT;
+    PFNGLBINDVERTEXARRAYPROC BindVertexArray;
+    PFNGLBINDVERTEXARRAYAPPLEPROC BindVertexArrayAPPLE;
+    PFNGLBLENDCOLORPROC BlendColor;
+    PFNGLBLENDCOLOREXTPROC BlendColorEXT;
+    PFNGLBLENDEQUATIONPROC BlendEquation;
+    PFNGLBLENDEQUATIONEXTPROC BlendEquationEXT;
+    PFNGLBLENDEQUATIONSEPARATEPROC BlendEquationSeparate;
+    PFNGLBLENDEQUATIONSEPARATEEXTPROC BlendEquationSeparateEXT;
+    PFNGLBLENDFUNCPROC BlendFunc;
+    PFNGLBLENDFUNCSEPARATEPROC BlendFuncSeparate;
+    PFNGLBLENDFUNCSEPARATEEXTPROC BlendFuncSeparateEXT;
+    PFNGLBLENDFUNCSEPARATEINGRPROC BlendFuncSeparateINGR;
+    PFNGLBLITFRAMEBUFFERPROC BlitFramebuffer;
+    PFNGLBLITFRAMEBUFFEREXTPROC BlitFramebufferEXT;
+    PFNGLBUFFERDATAPROC BufferData;
+    PFNGLBUFFERDATAARBPROC BufferDataARB;
+    PFNGLBUFFERPARAMETERIAPPLEPROC BufferParameteriAPPLE;
+    PFNGLBUFFERSUBDATAPROC BufferSubData;
+    PFNGLBUFFERSUBDATAARBPROC BufferSubDataARB;
+    PFNGLCHECKFRAMEBUFFERSTATUSPROC CheckFramebufferStatus;
+    PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC CheckFramebufferStatusEXT;
+    PFNGLCHECKNAMEDFRAMEBUFFERSTATUSEXTPROC CheckNamedFramebufferStatusEXT;
+    PFNGLCLAMPCOLORPROC ClampColor;
+    PFNGLCLAMPCOLORARBPROC ClampColorARB;
+    PFNGLCLEARPROC Clear;
+    PFNGLCLEARBUFFERFIPROC ClearBufferfi;
+    PFNGLCLEARBUFFERFVPROC ClearBufferfv;
+    PFNGLCLEARBUFFERIVPROC ClearBufferiv;
+    PFNGLCLEARBUFFERUIVPROC ClearBufferuiv;
+    PFNGLCLEARCOLORPROC ClearColor;
+    PFNGLCLEARCOLORIIEXTPROC ClearColorIiEXT;
+    PFNGLCLEARCOLORIUIEXTPROC ClearColorIuiEXT;
+    PFNGLCLEARDEPTHPROC ClearDepth;
+    PFNGLCLEARNAMEDBUFFERDATAEXTPROC ClearNamedBufferDataEXT;
+    PFNGLCLEARNAMEDBUFFERSUBDATAEXTPROC ClearNamedBufferSubDataEXT;
+    PFNGLCLEARSTENCILPROC ClearStencil;
+    PFNGLCLIENTACTIVETEXTUREARBPROC ClientActiveTextureARB;
+    PFNGLCLIENTATTRIBDEFAULTEXTPROC ClientAttribDefaultEXT;
+    PFNGLCLIENTWAITSYNCPROC ClientWaitSync;
+    PFNGLCOLORMASKPROC ColorMask;
+    PFNGLCOLORMASKINDEXEDEXTPROC ColorMaskIndexedEXT;
+    PFNGLCOLORMASKIPROC ColorMaski;
+    PFNGLCOLORPOINTEREXTPROC ColorPointerEXT;
+    PFNGLCOMPILESHADERPROC CompileShader;
+    PFNGLCOMPILESHADERARBPROC CompileShaderARB;
+    PFNGLCOMPRESSEDMULTITEXIMAGE1DEXTPROC CompressedMultiTexImage1DEXT;
+    PFNGLCOMPRESSEDMULTITEXIMAGE2DEXTPROC CompressedMultiTexImage2DEXT;
+    PFNGLCOMPRESSEDMULTITEXIMAGE3DEXTPROC CompressedMultiTexImage3DEXT;
+    PFNGLCOMPRESSEDMULTITEXSUBIMAGE1DEXTPROC CompressedMultiTexSubImage1DEXT;
+    PFNGLCOMPRESSEDMULTITEXSUBIMAGE2DEXTPROC CompressedMultiTexSubImage2DEXT;
+    PFNGLCOMPRESSEDMULTITEXSUBIMAGE3DEXTPROC CompressedMultiTexSubImage3DEXT;
+    PFNGLCOMPRESSEDTEXIMAGE1DPROC CompressedTexImage1D;
+    PFNGLCOMPRESSEDTEXIMAGE1DARBPROC CompressedTexImage1DARB;
+    PFNGLCOMPRESSEDTEXIMAGE2DPROC CompressedTexImage2D;
+    PFNGLCOMPRESSEDTEXIMAGE2DARBPROC CompressedTexImage2DARB;
+    PFNGLCOMPRESSEDTEXIMAGE3DPROC CompressedTexImage3D;
+    PFNGLCOMPRESSEDTEXIMAGE3DARBPROC CompressedTexImage3DARB;
+    PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC CompressedTexSubImage1D;
+    PFNGLCOMPRESSEDTEXSUBIMAGE1DARBPROC CompressedTexSubImage1DARB;
+    PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC CompressedTexSubImage2D;
+    PFNGLCOMPRESSEDTEXSUBIMAGE2DARBPROC CompressedTexSubImage2DARB;
+    PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC CompressedTexSubImage3D;
+    PFNGLCOMPRESSEDTEXSUBIMAGE3DARBPROC CompressedTexSubImage3DARB;
+    PFNGLCOMPRESSEDTEXTUREIMAGE1DEXTPROC CompressedTextureImage1DEXT;
+    PFNGLCOMPRESSEDTEXTUREIMAGE2DEXTPROC CompressedTextureImage2DEXT;
+    PFNGLCOMPRESSEDTEXTUREIMAGE3DEXTPROC CompressedTextureImage3DEXT;
+    PFNGLCOMPRESSEDTEXTURESUBIMAGE1DEXTPROC CompressedTextureSubImage1DEXT;
+    PFNGLCOMPRESSEDTEXTURESUBIMAGE2DEXTPROC CompressedTextureSubImage2DEXT;
+    PFNGLCOMPRESSEDTEXTURESUBIMAGE3DEXTPROC CompressedTextureSubImage3DEXT;
+    PFNGLCOPYBUFFERSUBDATAPROC CopyBufferSubData;
+    PFNGLCOPYMULTITEXIMAGE1DEXTPROC CopyMultiTexImage1DEXT;
+    PFNGLCOPYMULTITEXIMAGE2DEXTPROC CopyMultiTexImage2DEXT;
+    PFNGLCOPYMULTITEXSUBIMAGE1DEXTPROC CopyMultiTexSubImage1DEXT;
+    PFNGLCOPYMULTITEXSUBIMAGE2DEXTPROC CopyMultiTexSubImage2DEXT;
+    PFNGLCOPYMULTITEXSUBIMAGE3DEXTPROC CopyMultiTexSubImage3DEXT;
+    PFNGLCOPYTEXIMAGE1DPROC CopyTexImage1D;
+    PFNGLCOPYTEXIMAGE1DEXTPROC CopyTexImage1DEXT;
+    PFNGLCOPYTEXIMAGE2DPROC CopyTexImage2D;
+    PFNGLCOPYTEXIMAGE2DEXTPROC CopyTexImage2DEXT;
+    PFNGLCOPYTEXSUBIMAGE1DPROC CopyTexSubImage1D;
+    PFNGLCOPYTEXSUBIMAGE1DEXTPROC CopyTexSubImage1DEXT;
+    PFNGLCOPYTEXSUBIMAGE2DPROC CopyTexSubImage2D;
+    PFNGLCOPYTEXSUBIMAGE2DEXTPROC CopyTexSubImage2DEXT;
+    PFNGLCOPYTEXSUBIMAGE3DPROC CopyTexSubImage3D;
+    PFNGLCOPYTEXSUBIMAGE3DEXTPROC CopyTexSubImage3DEXT;
+    PFNGLCOPYTEXTUREIMAGE1DEXTPROC CopyTextureImage1DEXT;
+    PFNGLCOPYTEXTUREIMAGE2DEXTPROC CopyTextureImage2DEXT;
+    PFNGLCOPYTEXTURESUBIMAGE1DEXTPROC CopyTextureSubImage1DEXT;
+    PFNGLCOPYTEXTURESUBIMAGE2DEXTPROC CopyTextureSubImage2DEXT;
+    PFNGLCOPYTEXTURESUBIMAGE3DEXTPROC CopyTextureSubImage3DEXT;
+    PFNGLCREATEPROGRAMPROC CreateProgram;
+    PFNGLCREATEPROGRAMOBJECTARBPROC CreateProgramObjectARB;
+    PFNGLCREATESHADERPROC CreateShader;
+    PFNGLCREATESHADEROBJECTARBPROC CreateShaderObjectARB;
+    PFNGLCULLFACEPROC CullFace;
+    PFNGLDELETEBUFFERSPROC DeleteBuffers;
+    PFNGLDELETEBUFFERSARBPROC DeleteBuffersARB;
+    PFNGLDELETEFRAMEBUFFERSPROC DeleteFramebuffers;
+    PFNGLDELETEFRAMEBUFFERSEXTPROC DeleteFramebuffersEXT;
+    PFNGLDELETEOBJECTARBPROC DeleteObjectARB;
+    PFNGLDELETEPROGRAMPROC DeleteProgram;
+    PFNGLDELETEPROGRAMSARBPROC DeleteProgramsARB;
+    PFNGLDELETEPROGRAMSNVPROC DeleteProgramsNV;
+    PFNGLDELETEQUERIESPROC DeleteQueries;
+    PFNGLDELETEQUERIESARBPROC DeleteQueriesARB;
+    PFNGLDELETERENDERBUFFERSPROC DeleteRenderbuffers;
+    PFNGLDELETERENDERBUFFERSEXTPROC DeleteRenderbuffersEXT;
+    PFNGLDELETESHADERPROC DeleteShader;
+    PFNGLDELETESYNCPROC DeleteSync;
+    PFNGLDELETETEXTURESPROC DeleteTextures;
+    PFNGLDELETETEXTURESEXTPROC DeleteTexturesEXT;
+    PFNGLDELETEVERTEXARRAYSPROC DeleteVertexArrays;
+    PFNGLDELETEVERTEXARRAYSAPPLEPROC DeleteVertexArraysAPPLE;
+    PFNGLDEPTHFUNCPROC DepthFunc;
+    PFNGLDEPTHMASKPROC DepthMask;
+    PFNGLDEPTHRANGEPROC DepthRange;
+    PFNGLDETACHOBJECTARBPROC DetachObjectARB;
+    PFNGLDETACHSHADERPROC DetachShader;
+    PFNGLDISABLEPROC Disable;
+    PFNGLDISABLECLIENTSTATEINDEXEDEXTPROC DisableClientStateIndexedEXT;
+    PFNGLDISABLECLIENTSTATEIEXTPROC DisableClientStateiEXT;
+    PFNGLDISABLEINDEXEDEXTPROC DisableIndexedEXT;
+    PFNGLDISABLEVERTEXARRAYATTRIBEXTPROC DisableVertexArrayAttribEXT;
+    PFNGLDISABLEVERTEXARRAYEXTPROC DisableVertexArrayEXT;
+    PFNGLDISABLEVERTEXATTRIBARRAYPROC DisableVertexAttribArray;
+    PFNGLDISABLEVERTEXATTRIBARRAYARBPROC DisableVertexAttribArrayARB;
+    PFNGLDISABLEIPROC Disablei;
+    PFNGLDRAWARRAYSPROC DrawArrays;
+    PFNGLDRAWARRAYSEXTPROC DrawArraysEXT;
+    PFNGLDRAWARRAYSINSTANCEDPROC DrawArraysInstanced;
+    PFNGLDRAWARRAYSINSTANCEDARBPROC DrawArraysInstancedARB;
+    PFNGLDRAWARRAYSINSTANCEDEXTPROC DrawArraysInstancedEXT;
+    PFNGLDRAWBUFFERPROC DrawBuffer;
+    PFNGLDRAWBUFFERSPROC DrawBuffers;
+    PFNGLDRAWBUFFERSARBPROC DrawBuffersARB;
+    PFNGLDRAWBUFFERSATIPROC DrawBuffersATI;
+    PFNGLDRAWELEMENTSPROC DrawElements;
+    PFNGLDRAWELEMENTSBASEVERTEXPROC DrawElementsBaseVertex;
+    PFNGLDRAWELEMENTSINSTANCEDPROC DrawElementsInstanced;
+    PFNGLDRAWELEMENTSINSTANCEDARBPROC DrawElementsInstancedARB;
+    PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC DrawElementsInstancedBaseVertex;
+    PFNGLDRAWELEMENTSINSTANCEDEXTPROC DrawElementsInstancedEXT;
+    PFNGLDRAWRANGEELEMENTSPROC DrawRangeElements;
+    PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC DrawRangeElementsBaseVertex;
+    PFNGLDRAWRANGEELEMENTSEXTPROC DrawRangeElementsEXT;
+    PFNGLEDGEFLAGPOINTEREXTPROC EdgeFlagPointerEXT;
+    PFNGLENABLEPROC Enable;
+    PFNGLENABLECLIENTSTATEINDEXEDEXTPROC EnableClientStateIndexedEXT;
+    PFNGLENABLECLIENTSTATEIEXTPROC EnableClientStateiEXT;
+    PFNGLENABLEINDEXEDEXTPROC EnableIndexedEXT;
+    PFNGLENABLEVERTEXARRAYATTRIBEXTPROC EnableVertexArrayAttribEXT;
+    PFNGLENABLEVERTEXARRAYEXTPROC EnableVertexArrayEXT;
+    PFNGLENABLEVERTEXATTRIBARRAYPROC EnableVertexAttribArray;
+    PFNGLENABLEVERTEXATTRIBARRAYARBPROC EnableVertexAttribArrayARB;
+    PFNGLENABLEIPROC Enablei;
+    PFNGLENDCONDITIONALRENDERPROC EndConditionalRender;
+    PFNGLENDCONDITIONALRENDERNVPROC EndConditionalRenderNV;
+    PFNGLENDCONDITIONALRENDERNVXPROC EndConditionalRenderNVX;
+    PFNGLENDQUERYPROC EndQuery;
+    PFNGLENDQUERYARBPROC EndQueryARB;
+    PFNGLENDTRANSFORMFEEDBACKPROC EndTransformFeedback;
+    PFNGLENDTRANSFORMFEEDBACKEXTPROC EndTransformFeedbackEXT;
+    PFNGLENDTRANSFORMFEEDBACKNVPROC EndTransformFeedbackNV;
+    PFNGLEXECUTEPROGRAMNVPROC ExecuteProgramNV;
+    PFNGLFENCESYNCPROC FenceSync;
+    PFNGLFINISHPROC Finish;
+    PFNGLFLUSHPROC Flush;
+    PFNGLFLUSHMAPPEDBUFFERRANGEPROC FlushMappedBufferRange;
+    PFNGLFLUSHMAPPEDBUFFERRANGEAPPLEPROC FlushMappedBufferRangeAPPLE;
+    PFNGLFLUSHMAPPEDNAMEDBUFFERRANGEEXTPROC FlushMappedNamedBufferRangeEXT;
+    PFNGLFRAMEBUFFERDRAWBUFFEREXTPROC FramebufferDrawBufferEXT;
+    PFNGLFRAMEBUFFERDRAWBUFFERSEXTPROC FramebufferDrawBuffersEXT;
+    PFNGLFRAMEBUFFERREADBUFFEREXTPROC FramebufferReadBufferEXT;
+    PFNGLFRAMEBUFFERRENDERBUFFERPROC FramebufferRenderbuffer;
+    PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC FramebufferRenderbufferEXT;
+    PFNGLFRAMEBUFFERTEXTUREPROC FramebufferTexture;
+    PFNGLFRAMEBUFFERTEXTURE1DPROC FramebufferTexture1D;
+    PFNGLFRAMEBUFFERTEXTURE1DEXTPROC FramebufferTexture1DEXT;
+    PFNGLFRAMEBUFFERTEXTURE2DPROC FramebufferTexture2D;
+    PFNGLFRAMEBUFFERTEXTURE2DEXTPROC FramebufferTexture2DEXT;
+    PFNGLFRAMEBUFFERTEXTURE3DPROC FramebufferTexture3D;
+    PFNGLFRAMEBUFFERTEXTURE3DEXTPROC FramebufferTexture3DEXT;
+    PFNGLFRAMEBUFFERTEXTUREARBPROC FramebufferTextureARB;
+    PFNGLFRAMEBUFFERTEXTUREEXTPROC FramebufferTextureEXT;
+    PFNGLFRAMEBUFFERTEXTUREFACEARBPROC FramebufferTextureFaceARB;
+    PFNGLFRAMEBUFFERTEXTUREFACEEXTPROC FramebufferTextureFaceEXT;
+    PFNGLFRAMEBUFFERTEXTURELAYERPROC FramebufferTextureLayer;
+    PFNGLFRAMEBUFFERTEXTURELAYERARBPROC FramebufferTextureLayerARB;
+    PFNGLFRAMEBUFFERTEXTURELAYEREXTPROC FramebufferTextureLayerEXT;
+    PFNGLFRONTFACEPROC FrontFace;
+    PFNGLGENBUFFERSPROC GenBuffers;
+    PFNGLGENBUFFERSARBPROC GenBuffersARB;
+    PFNGLGENFRAMEBUFFERSPROC GenFramebuffers;
+    PFNGLGENFRAMEBUFFERSEXTPROC GenFramebuffersEXT;
+    PFNGLGENPROGRAMSARBPROC GenProgramsARB;
+    PFNGLGENPROGRAMSNVPROC GenProgramsNV;
+    PFNGLGENQUERIESPROC GenQueries;
+    PFNGLGENQUERIESARBPROC GenQueriesARB;
+    PFNGLGENRENDERBUFFERSPROC GenRenderbuffers;
+    PFNGLGENRENDERBUFFERSEXTPROC GenRenderbuffersEXT;
+    PFNGLGENTEXTURESPROC GenTextures;
+    PFNGLGENTEXTURESEXTPROC GenTexturesEXT;
+    PFNGLGENVERTEXARRAYSPROC GenVertexArrays;
+    PFNGLGENVERTEXARRAYSAPPLEPROC GenVertexArraysAPPLE;
+    PFNGLGENERATEMIPMAPPROC GenerateMipmap;
+    PFNGLGENERATEMIPMAPEXTPROC GenerateMipmapEXT;
+    PFNGLGENERATEMULTITEXMIPMAPEXTPROC GenerateMultiTexMipmapEXT;
+    PFNGLGENERATETEXTUREMIPMAPEXTPROC GenerateTextureMipmapEXT;
+    PFNGLGETACTIVEATTRIBPROC GetActiveAttrib;
+    PFNGLGETACTIVEATTRIBARBPROC GetActiveAttribARB;
+    PFNGLGETACTIVEUNIFORMPROC GetActiveUniform;
+    PFNGLGETACTIVEUNIFORMARBPROC GetActiveUniformARB;
+    PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC GetActiveUniformBlockName;
+    PFNGLGETACTIVEUNIFORMBLOCKIVPROC GetActiveUniformBlockiv;
+    PFNGLGETACTIVEUNIFORMNAMEPROC GetActiveUniformName;
+    PFNGLGETACTIVEUNIFORMSIVPROC GetActiveUniformsiv;
+    PFNGLGETACTIVEVARYINGNVPROC GetActiveVaryingNV;
+    PFNGLGETATTACHEDOBJECTSARBPROC GetAttachedObjectsARB;
+    PFNGLGETATTACHEDSHADERSPROC GetAttachedShaders;
+    PFNGLGETATTRIBLOCATIONPROC GetAttribLocation;
+    PFNGLGETATTRIBLOCATIONARBPROC GetAttribLocationARB;
+    PFNGLGETBOOLEANINDEXEDVEXTPROC GetBooleanIndexedvEXT;
+    PFNGLGETBOOLEANI_VPROC GetBooleani_v;
+    PFNGLGETBOOLEANVPROC GetBooleanv;
+    PFNGLGETBUFFERPARAMETERI64VPROC GetBufferParameteri64v;
+    PFNGLGETBUFFERPARAMETERIVPROC GetBufferParameteriv;
+    PFNGLGETBUFFERPARAMETERIVARBPROC GetBufferParameterivARB;
+    PFNGLGETBUFFERPOINTERVPROC GetBufferPointerv;
+    PFNGLGETBUFFERPOINTERVARBPROC GetBufferPointervARB;
+    PFNGLGETBUFFERSUBDATAPROC GetBufferSubData;
+    PFNGLGETBUFFERSUBDATAARBPROC GetBufferSubDataARB;
+    PFNGLGETCOMPRESSEDMULTITEXIMAGEEXTPROC GetCompressedMultiTexImageEXT;
+    PFNGLGETCOMPRESSEDTEXIMAGEPROC GetCompressedTexImage;
+    PFNGLGETCOMPRESSEDTEXIMAGEARBPROC GetCompressedTexImageARB;
+    PFNGLGETCOMPRESSEDTEXTUREIMAGEEXTPROC GetCompressedTextureImageEXT;
+    PFNGLGETDOUBLEINDEXEDVEXTPROC GetDoubleIndexedvEXT;
+    PFNGLGETDOUBLEI_VEXTPROC GetDoublei_vEXT;
+    PFNGLGETDOUBLEVPROC GetDoublev;
+    PFNGLGETERRORPROC GetError;
+    PFNGLGETFLOATINDEXEDVEXTPROC GetFloatIndexedvEXT;
+    PFNGLGETFLOATI_VEXTPROC GetFloati_vEXT;
+    PFNGLGETFLOATVPROC GetFloatv;
+    PFNGLGETFRAGDATALOCATIONPROC GetFragDataLocation;
+    PFNGLGETFRAGDATALOCATIONEXTPROC GetFragDataLocationEXT;
+    PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC GetFramebufferAttachmentParameteriv;
+    PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC GetFramebufferAttachmentParameterivEXT;
+    PFNGLGETFRAMEBUFFERPARAMETERIVEXTPROC GetFramebufferParameterivEXT;
+    PFNGLGETHANDLEARBPROC GetHandleARB;
+    PFNGLGETINFOLOGARBPROC GetInfoLogARB;
+    PFNGLGETINTEGER64I_VPROC GetInteger64i_v;
+    PFNGLGETINTEGER64VPROC GetInteger64v;
+    PFNGLGETINTEGERINDEXEDVEXTPROC GetIntegerIndexedvEXT;
+    PFNGLGETINTEGERI_VPROC GetIntegeri_v;
+    PFNGLGETINTEGERVPROC GetIntegerv;
+    PFNGLGETMULTITEXENVFVEXTPROC GetMultiTexEnvfvEXT;
+    PFNGLGETMULTITEXENVIVEXTPROC GetMultiTexEnvivEXT;
+    PFNGLGETMULTITEXGENDVEXTPROC GetMultiTexGendvEXT;
+    PFNGLGETMULTITEXGENFVEXTPROC GetMultiTexGenfvEXT;
+    PFNGLGETMULTITEXGENIVEXTPROC GetMultiTexGenivEXT;
+    PFNGLGETMULTITEXIMAGEEXTPROC GetMultiTexImageEXT;
+    PFNGLGETMULTITEXLEVELPARAMETERFVEXTPROC GetMultiTexLevelParameterfvEXT;
+    PFNGLGETMULTITEXLEVELPARAMETERIVEXTPROC GetMultiTexLevelParameterivEXT;
+    PFNGLGETMULTITEXPARAMETERIIVEXTPROC GetMultiTexParameterIivEXT;
+    PFNGLGETMULTITEXPARAMETERIUIVEXTPROC GetMultiTexParameterIuivEXT;
+    PFNGLGETMULTITEXPARAMETERFVEXTPROC GetMultiTexParameterfvEXT;
+    PFNGLGETMULTITEXPARAMETERIVEXTPROC GetMultiTexParameterivEXT;
+    PFNGLGETMULTISAMPLEFVPROC GetMultisamplefv;
+    PFNGLGETMULTISAMPLEFVNVPROC GetMultisamplefvNV;
+    PFNGLGETNAMEDBUFFERPARAMETERIVEXTPROC GetNamedBufferParameterivEXT;
+    PFNGLGETNAMEDBUFFERPOINTERVEXTPROC GetNamedBufferPointervEXT;
+    PFNGLGETNAMEDBUFFERSUBDATAEXTPROC GetNamedBufferSubDataEXT;
+    PFNGLGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC GetNamedFramebufferAttachmentParameterivEXT;
+    PFNGLGETNAMEDFRAMEBUFFERPARAMETERIVEXTPROC GetNamedFramebufferParameterivEXT;
+    PFNGLGETNAMEDPROGRAMLOCALPARAMETERIIVEXTPROC GetNamedProgramLocalParameterIivEXT;
+    PFNGLGETNAMEDPROGRAMLOCALPARAMETERIUIVEXTPROC GetNamedProgramLocalParameterIuivEXT;
+    PFNGLGETNAMEDPROGRAMLOCALPARAMETERDVEXTPROC GetNamedProgramLocalParameterdvEXT;
+    PFNGLGETNAMEDPROGRAMLOCALPARAMETERFVEXTPROC GetNamedProgramLocalParameterfvEXT;
+    PFNGLGETNAMEDPROGRAMSTRINGEXTPROC GetNamedProgramStringEXT;
+    PFNGLGETNAMEDPROGRAMIVEXTPROC GetNamedProgramivEXT;
+    PFNGLGETNAMEDRENDERBUFFERPARAMETERIVEXTPROC GetNamedRenderbufferParameterivEXT;
+    PFNGLGETOBJECTPARAMETERFVARBPROC GetObjectParameterfvARB;
+    PFNGLGETOBJECTPARAMETERIVARBPROC GetObjectParameterivARB;
+    PFNGLGETPOINTERINDEXEDVEXTPROC GetPointerIndexedvEXT;
+    PFNGLGETPOINTERI_VEXTPROC GetPointeri_vEXT;
+    PFNGLGETPOINTERVEXTPROC GetPointervEXT;
+    PFNGLGETPROGRAMENVPARAMETERDVARBPROC GetProgramEnvParameterdvARB;
+    PFNGLGETPROGRAMENVPARAMETERFVARBPROC GetProgramEnvParameterfvARB;
+    PFNGLGETPROGRAMINFOLOGPROC GetProgramInfoLog;
+    PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC GetProgramLocalParameterdvARB;
+    PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC GetProgramLocalParameterfvARB;
+    PFNGLGETPROGRAMPARAMETERDVNVPROC GetProgramParameterdvNV;
+    PFNGLGETPROGRAMPARAMETERFVNVPROC GetProgramParameterfvNV;
+    PFNGLGETPROGRAMSTRINGARBPROC GetProgramStringARB;
+    PFNGLGETPROGRAMSTRINGNVPROC GetProgramStringNV;
+    PFNGLGETPROGRAMIVPROC GetProgramiv;
+    PFNGLGETPROGRAMIVARBPROC GetProgramivARB;
+    PFNGLGETPROGRAMIVNVPROC GetProgramivNV;
+    PFNGLGETQUERYOBJECTIVPROC GetQueryObjectiv;
+    PFNGLGETQUERYOBJECTIVARBPROC GetQueryObjectivARB;
+    PFNGLGETQUERYOBJECTUIVPROC GetQueryObjectuiv;
+    PFNGLGETQUERYOBJECTUIVARBPROC GetQueryObjectuivARB;
+    PFNGLGETQUERYIVPROC GetQueryiv;
+    PFNGLGETQUERYIVARBPROC GetQueryivARB;
+    PFNGLGETRENDERBUFFERPARAMETERIVPROC GetRenderbufferParameteriv;
+    PFNGLGETRENDERBUFFERPARAMETERIVEXTPROC GetRenderbufferParameterivEXT;
+    PFNGLGETSHADERINFOLOGPROC GetShaderInfoLog;
+    PFNGLGETSHADERSOURCEPROC GetShaderSource;
+    PFNGLGETSHADERSOURCEARBPROC GetShaderSourceARB;
+    PFNGLGETSHADERIVPROC GetShaderiv;
+    PFNGLGETSTRINGPROC GetString;
+    PFNGLGETSTRINGIPROC GetStringi;
+    PFNGLGETSYNCIVPROC GetSynciv;
+    PFNGLGETTEXIMAGEPROC GetTexImage;
+    PFNGLGETTEXLEVELPARAMETERFVPROC GetTexLevelParameterfv;
+    PFNGLGETTEXLEVELPARAMETERIVPROC GetTexLevelParameteriv;
+    PFNGLGETTEXPARAMETERIIVPROC GetTexParameterIiv;
+    PFNGLGETTEXPARAMETERIIVEXTPROC GetTexParameterIivEXT;
+    PFNGLGETTEXPARAMETERIUIVPROC GetTexParameterIuiv;
+    PFNGLGETTEXPARAMETERIUIVEXTPROC GetTexParameterIuivEXT;
+    PFNGLGETTEXPARAMETERFVPROC GetTexParameterfv;
+    PFNGLGETTEXPARAMETERIVPROC GetTexParameteriv;
+    PFNGLGETTEXTUREIMAGEEXTPROC GetTextureImageEXT;
+    PFNGLGETTEXTURELEVELPARAMETERFVEXTPROC GetTextureLevelParameterfvEXT;
+    PFNGLGETTEXTURELEVELPARAMETERIVEXTPROC GetTextureLevelParameterivEXT;
+    PFNGLGETTEXTUREPARAMETERIIVEXTPROC GetTextureParameterIivEXT;
+    PFNGLGETTEXTUREPARAMETERIUIVEXTPROC GetTextureParameterIuivEXT;
+    PFNGLGETTEXTUREPARAMETERFVEXTPROC GetTextureParameterfvEXT;
+    PFNGLGETTEXTUREPARAMETERIVEXTPROC GetTextureParameterivEXT;
+    PFNGLGETTRACKMATRIXIVNVPROC GetTrackMatrixivNV;
+    PFNGLGETTRANSFORMFEEDBACKVARYINGPROC GetTransformFeedbackVarying;
+    PFNGLGETTRANSFORMFEEDBACKVARYINGEXTPROC GetTransformFeedbackVaryingEXT;
+    PFNGLGETTRANSFORMFEEDBACKVARYINGNVPROC GetTransformFeedbackVaryingNV;
+    PFNGLGETUNIFORMBLOCKINDEXPROC GetUniformBlockIndex;
+    PFNGLGETUNIFORMINDICESPROC GetUniformIndices;
+    PFNGLGETUNIFORMLOCATIONPROC GetUniformLocation;
+    PFNGLGETUNIFORMLOCATIONARBPROC GetUniformLocationARB;
+    PFNGLGETUNIFORMFVPROC GetUniformfv;
+    PFNGLGETUNIFORMFVARBPROC GetUniformfvARB;
+    PFNGLGETUNIFORMIVPROC GetUniformiv;
+    PFNGLGETUNIFORMIVARBPROC GetUniformivARB;
+    PFNGLGETUNIFORMUIVPROC GetUniformuiv;
+    PFNGLGETUNIFORMUIVEXTPROC GetUniformuivEXT;
+    PFNGLGETVARYINGLOCATIONNVPROC GetVaryingLocationNV;
+    PFNGLGETVERTEXARRAYINTEGERI_VEXTPROC GetVertexArrayIntegeri_vEXT;
+    PFNGLGETVERTEXARRAYINTEGERVEXTPROC GetVertexArrayIntegervEXT;
+    PFNGLGETVERTEXARRAYPOINTERI_VEXTPROC GetVertexArrayPointeri_vEXT;
+    PFNGLGETVERTEXARRAYPOINTERVEXTPROC GetVertexArrayPointervEXT;
+    PFNGLGETVERTEXATTRIBIIVPROC GetVertexAttribIiv;
+    PFNGLGETVERTEXATTRIBIIVEXTPROC GetVertexAttribIivEXT;
+    PFNGLGETVERTEXATTRIBIUIVPROC GetVertexAttribIuiv;
+    PFNGLGETVERTEXATTRIBIUIVEXTPROC GetVertexAttribIuivEXT;
+    PFNGLGETVERTEXATTRIBPOINTERVPROC GetVertexAttribPointerv;
+    PFNGLGETVERTEXATTRIBPOINTERVARBPROC GetVertexAttribPointervARB;
+    PFNGLGETVERTEXATTRIBPOINTERVNVPROC GetVertexAttribPointervNV;
+    PFNGLGETVERTEXATTRIBDVPROC GetVertexAttribdv;
+    PFNGLGETVERTEXATTRIBDVARBPROC GetVertexAttribdvARB;
+    PFNGLGETVERTEXATTRIBDVNVPROC GetVertexAttribdvNV;
+    PFNGLGETVERTEXATTRIBFVPROC GetVertexAttribfv;
+    PFNGLGETVERTEXATTRIBFVARBPROC GetVertexAttribfvARB;
+    PFNGLGETVERTEXATTRIBFVNVPROC GetVertexAttribfvNV;
+    PFNGLGETVERTEXATTRIBIVPROC GetVertexAttribiv;
+    PFNGLGETVERTEXATTRIBIVARBPROC GetVertexAttribivARB;
+    PFNGLGETVERTEXATTRIBIVNVPROC GetVertexAttribivNV;
+    PFNGLHINTPROC Hint;
+    PFNGLINDEXPOINTEREXTPROC IndexPointerEXT;
+    PFNGLISBUFFERPROC IsBuffer;
+    PFNGLISBUFFERARBPROC IsBufferARB;
+    PFNGLISENABLEDPROC IsEnabled;
+    PFNGLISENABLEDINDEXEDEXTPROC IsEnabledIndexedEXT;
+    PFNGLISENABLEDIPROC IsEnabledi;
+    PFNGLISFRAMEBUFFERPROC IsFramebuffer;
+    PFNGLISFRAMEBUFFEREXTPROC IsFramebufferEXT;
+    PFNGLISPROGRAMPROC IsProgram;
+    PFNGLISPROGRAMARBPROC IsProgramARB;
+    PFNGLISPROGRAMNVPROC IsProgramNV;
+    PFNGLISQUERYPROC IsQuery;
+    PFNGLISQUERYARBPROC IsQueryARB;
+    PFNGLISRENDERBUFFERPROC IsRenderbuffer;
+    PFNGLISRENDERBUFFEREXTPROC IsRenderbufferEXT;
+    PFNGLISSHADERPROC IsShader;
+    PFNGLISSYNCPROC IsSync;
+    PFNGLISTEXTUREPROC IsTexture;
+    PFNGLISTEXTUREEXTPROC IsTextureEXT;
+    PFNGLISVERTEXARRAYPROC IsVertexArray;
+    PFNGLISVERTEXARRAYAPPLEPROC IsVertexArrayAPPLE;
+    PFNGLLINEWIDTHPROC LineWidth;
+    PFNGLLINKPROGRAMPROC LinkProgram;
+    PFNGLLINKPROGRAMARBPROC LinkProgramARB;
+    PFNGLLOADPROGRAMNVPROC LoadProgramNV;
+    PFNGLLOGICOPPROC LogicOp;
+    PFNGLMAPBUFFERPROC MapBuffer;
+    PFNGLMAPBUFFERARBPROC MapBufferARB;
+    PFNGLMAPBUFFERRANGEPROC MapBufferRange;
+    PFNGLMAPNAMEDBUFFEREXTPROC MapNamedBufferEXT;
+    PFNGLMAPNAMEDBUFFERRANGEEXTPROC MapNamedBufferRangeEXT;
+    PFNGLMATRIXFRUSTUMEXTPROC MatrixFrustumEXT;
+    PFNGLMATRIXLOADIDENTITYEXTPROC MatrixLoadIdentityEXT;
+    PFNGLMATRIXLOADTRANSPOSEDEXTPROC MatrixLoadTransposedEXT;
+    PFNGLMATRIXLOADTRANSPOSEFEXTPROC MatrixLoadTransposefEXT;
+    PFNGLMATRIXLOADDEXTPROC MatrixLoaddEXT;
+    PFNGLMATRIXLOADFEXTPROC MatrixLoadfEXT;
+    PFNGLMATRIXMULTTRANSPOSEDEXTPROC MatrixMultTransposedEXT;
+    PFNGLMATRIXMULTTRANSPOSEFEXTPROC MatrixMultTransposefEXT;
+    PFNGLMATRIXMULTDEXTPROC MatrixMultdEXT;
+    PFNGLMATRIXMULTFEXTPROC MatrixMultfEXT;
+    PFNGLMATRIXORTHOEXTPROC MatrixOrthoEXT;
+    PFNGLMATRIXPOPEXTPROC MatrixPopEXT;
+    PFNGLMATRIXPUSHEXTPROC MatrixPushEXT;
+    PFNGLMATRIXROTATEDEXTPROC MatrixRotatedEXT;
+    PFNGLMATRIXROTATEFEXTPROC MatrixRotatefEXT;
+    PFNGLMATRIXSCALEDEXTPROC MatrixScaledEXT;
+    PFNGLMATRIXSCALEFEXTPROC MatrixScalefEXT;
+    PFNGLMATRIXTRANSLATEDEXTPROC MatrixTranslatedEXT;
+    PFNGLMATRIXTRANSLATEFEXTPROC MatrixTranslatefEXT;
+    PFNGLMULTIDRAWARRAYSPROC MultiDrawArrays;
+    PFNGLMULTIDRAWARRAYSEXTPROC MultiDrawArraysEXT;
+    PFNGLMULTIDRAWELEMENTSPROC MultiDrawElements;
+    PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC MultiDrawElementsBaseVertex;
+    PFNGLMULTIDRAWELEMENTSEXTPROC MultiDrawElementsEXT;
+    PFNGLMULTITEXBUFFEREXTPROC MultiTexBufferEXT;
+    PFNGLMULTITEXCOORD1DARBPROC MultiTexCoord1dARB;
+    PFNGLMULTITEXCOORD1DVARBPROC MultiTexCoord1dvARB;
+    PFNGLMULTITEXCOORD1FARBPROC MultiTexCoord1fARB;
+    PFNGLMULTITEXCOORD1FVARBPROC MultiTexCoord1fvARB;
+    PFNGLMULTITEXCOORD1IARBPROC MultiTexCoord1iARB;
+    PFNGLMULTITEXCOORD1IVARBPROC MultiTexCoord1ivARB;
+    PFNGLMULTITEXCOORD1SARBPROC MultiTexCoord1sARB;
+    PFNGLMULTITEXCOORD1SVARBPROC MultiTexCoord1svARB;
+    PFNGLMULTITEXCOORD2DARBPROC MultiTexCoord2dARB;
+    PFNGLMULTITEXCOORD2DVARBPROC MultiTexCoord2dvARB;
+    PFNGLMULTITEXCOORD2FARBPROC MultiTexCoord2fARB;
+    PFNGLMULTITEXCOORD2FVARBPROC MultiTexCoord2fvARB;
+    PFNGLMULTITEXCOORD2IARBPROC MultiTexCoord2iARB;
+    PFNGLMULTITEXCOORD2IVARBPROC MultiTexCoord2ivARB;
+    PFNGLMULTITEXCOORD2SARBPROC MultiTexCoord2sARB;
+    PFNGLMULTITEXCOORD2SVARBPROC MultiTexCoord2svARB;
+    PFNGLMULTITEXCOORD3DARBPROC MultiTexCoord3dARB;
+    PFNGLMULTITEXCOORD3DVARBPROC MultiTexCoord3dvARB;
+    PFNGLMULTITEXCOORD3FARBPROC MultiTexCoord3fARB;
+    PFNGLMULTITEXCOORD3FVARBPROC MultiTexCoord3fvARB;
+    PFNGLMULTITEXCOORD3IARBPROC MultiTexCoord3iARB;
+    PFNGLMULTITEXCOORD3IVARBPROC MultiTexCoord3ivARB;
+    PFNGLMULTITEXCOORD3SARBPROC MultiTexCoord3sARB;
+    PFNGLMULTITEXCOORD3SVARBPROC MultiTexCoord3svARB;
+    PFNGLMULTITEXCOORD4DARBPROC MultiTexCoord4dARB;
+    PFNGLMULTITEXCOORD4DVARBPROC MultiTexCoord4dvARB;
+    PFNGLMULTITEXCOORD4FARBPROC MultiTexCoord4fARB;
+    PFNGLMULTITEXCOORD4FVARBPROC MultiTexCoord4fvARB;
+    PFNGLMULTITEXCOORD4IARBPROC MultiTexCoord4iARB;
+    PFNGLMULTITEXCOORD4IVARBPROC MultiTexCoord4ivARB;
+    PFNGLMULTITEXCOORD4SARBPROC MultiTexCoord4sARB;
+    PFNGLMULTITEXCOORD4SVARBPROC MultiTexCoord4svARB;
+    PFNGLMULTITEXCOORDPOINTEREXTPROC MultiTexCoordPointerEXT;
+    PFNGLMULTITEXENVFEXTPROC MultiTexEnvfEXT;
+    PFNGLMULTITEXENVFVEXTPROC MultiTexEnvfvEXT;
+    PFNGLMULTITEXENVIEXTPROC MultiTexEnviEXT;
+    PFNGLMULTITEXENVIVEXTPROC MultiTexEnvivEXT;
+    PFNGLMULTITEXGENDEXTPROC MultiTexGendEXT;
+    PFNGLMULTITEXGENDVEXTPROC MultiTexGendvEXT;
+    PFNGLMULTITEXGENFEXTPROC MultiTexGenfEXT;
+    PFNGLMULTITEXGENFVEXTPROC MultiTexGenfvEXT;
+    PFNGLMULTITEXGENIEXTPROC MultiTexGeniEXT;
+    PFNGLMULTITEXGENIVEXTPROC MultiTexGenivEXT;
+    PFNGLMULTITEXIMAGE1DEXTPROC MultiTexImage1DEXT;
+    PFNGLMULTITEXIMAGE2DEXTPROC MultiTexImage2DEXT;
+    PFNGLMULTITEXIMAGE3DEXTPROC MultiTexImage3DEXT;
+    PFNGLMULTITEXPARAMETERIIVEXTPROC MultiTexParameterIivEXT;
+    PFNGLMULTITEXPARAMETERIUIVEXTPROC MultiTexParameterIuivEXT;
+    PFNGLMULTITEXPARAMETERFEXTPROC MultiTexParameterfEXT;
+    PFNGLMULTITEXPARAMETERFVEXTPROC MultiTexParameterfvEXT;
+    PFNGLMULTITEXPARAMETERIEXTPROC MultiTexParameteriEXT;
+    PFNGLMULTITEXPARAMETERIVEXTPROC MultiTexParameterivEXT;
+    PFNGLMULTITEXRENDERBUFFEREXTPROC MultiTexRenderbufferEXT;
+    PFNGLMULTITEXSUBIMAGE1DEXTPROC MultiTexSubImage1DEXT;
+    PFNGLMULTITEXSUBIMAGE2DEXTPROC MultiTexSubImage2DEXT;
+    PFNGLMULTITEXSUBIMAGE3DEXTPROC MultiTexSubImage3DEXT;
+    PFNGLNAMEDBUFFERDATAEXTPROC NamedBufferDataEXT;
+    PFNGLNAMEDBUFFERSTORAGEEXTPROC NamedBufferStorageEXT;
+    PFNGLNAMEDBUFFERSUBDATAEXTPROC NamedBufferSubDataEXT;
+    PFNGLNAMEDCOPYBUFFERSUBDATAEXTPROC NamedCopyBufferSubDataEXT;
+    PFNGLNAMEDFRAMEBUFFERPARAMETERIEXTPROC NamedFramebufferParameteriEXT;
+    PFNGLNAMEDFRAMEBUFFERRENDERBUFFEREXTPROC NamedFramebufferRenderbufferEXT;
+    PFNGLNAMEDFRAMEBUFFERTEXTURE1DEXTPROC NamedFramebufferTexture1DEXT;
+    PFNGLNAMEDFRAMEBUFFERTEXTURE2DEXTPROC NamedFramebufferTexture2DEXT;
+    PFNGLNAMEDFRAMEBUFFERTEXTURE3DEXTPROC NamedFramebufferTexture3DEXT;
+    PFNGLNAMEDFRAMEBUFFERTEXTUREEXTPROC NamedFramebufferTextureEXT;
+    PFNGLNAMEDFRAMEBUFFERTEXTUREFACEEXTPROC NamedFramebufferTextureFaceEXT;
+    PFNGLNAMEDFRAMEBUFFERTEXTURELAYEREXTPROC NamedFramebufferTextureLayerEXT;
+    PFNGLNAMEDPROGRAMLOCALPARAMETER4DEXTPROC NamedProgramLocalParameter4dEXT;
+    PFNGLNAMEDPROGRAMLOCALPARAMETER4DVEXTPROC NamedProgramLocalParameter4dvEXT;
+    PFNGLNAMEDPROGRAMLOCALPARAMETER4FEXTPROC NamedProgramLocalParameter4fEXT;
+    PFNGLNAMEDPROGRAMLOCALPARAMETER4FVEXTPROC NamedProgramLocalParameter4fvEXT;
+    PFNGLNAMEDPROGRAMLOCALPARAMETERI4IEXTPROC NamedProgramLocalParameterI4iEXT;
+    PFNGLNAMEDPROGRAMLOCALPARAMETERI4IVEXTPROC NamedProgramLocalParameterI4ivEXT;
+    PFNGLNAMEDPROGRAMLOCALPARAMETERI4UIEXTPROC NamedProgramLocalParameterI4uiEXT;
+    PFNGLNAMEDPROGRAMLOCALPARAMETERI4UIVEXTPROC NamedProgramLocalParameterI4uivEXT;
+    PFNGLNAMEDPROGRAMLOCALPARAMETERS4FVEXTPROC NamedProgramLocalParameters4fvEXT;
+    PFNGLNAMEDPROGRAMLOCALPARAMETERSI4IVEXTPROC NamedProgramLocalParametersI4ivEXT;
+    PFNGLNAMEDPROGRAMLOCALPARAMETERSI4UIVEXTPROC NamedProgramLocalParametersI4uivEXT;
+    PFNGLNAMEDPROGRAMSTRINGEXTPROC NamedProgramStringEXT;
+    PFNGLNAMEDRENDERBUFFERSTORAGEEXTPROC NamedRenderbufferStorageEXT;
+    PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLECOVERAGEEXTPROC NamedRenderbufferStorageMultisampleCoverageEXT;
+    PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC NamedRenderbufferStorageMultisampleEXT;
+    PFNGLNORMALPOINTEREXTPROC NormalPointerEXT;
+    PFNGLPIXELSTOREFPROC PixelStoref;
+    PFNGLPIXELSTOREIPROC PixelStorei;
+    PFNGLPOINTPARAMETERFPROC PointParameterf;
+    PFNGLPOINTPARAMETERFARBPROC PointParameterfARB;
+    PFNGLPOINTPARAMETERFEXTPROC PointParameterfEXT;
+    PFNGLPOINTPARAMETERFSGISPROC PointParameterfSGIS;
+    PFNGLPOINTPARAMETERFVPROC PointParameterfv;
+    PFNGLPOINTPARAMETERFVARBPROC PointParameterfvARB;
+    PFNGLPOINTPARAMETERFVEXTPROC PointParameterfvEXT;
+    PFNGLPOINTPARAMETERFVSGISPROC PointParameterfvSGIS;
+    PFNGLPOINTPARAMETERIPROC PointParameteri;
+    PFNGLPOINTPARAMETERINVPROC PointParameteriNV;
+    PFNGLPOINTPARAMETERIVPROC PointParameteriv;
+    PFNGLPOINTPARAMETERIVNVPROC PointParameterivNV;
+    PFNGLPOINTSIZEPROC PointSize;
+    PFNGLPOLYGONMODEPROC PolygonMode;
+    PFNGLPOLYGONOFFSETPROC PolygonOffset;
+    PFNGLPRIMITIVERESTARTINDEXPROC PrimitiveRestartIndex;
+    PFNGLPRIORITIZETEXTURESEXTPROC PrioritizeTexturesEXT;
+    PFNGLPROGRAMENVPARAMETER4DARBPROC ProgramEnvParameter4dARB;
+    PFNGLPROGRAMENVPARAMETER4DVARBPROC ProgramEnvParameter4dvARB;
+    PFNGLPROGRAMENVPARAMETER4FARBPROC ProgramEnvParameter4fARB;
+    PFNGLPROGRAMENVPARAMETER4FVARBPROC ProgramEnvParameter4fvARB;
+    PFNGLPROGRAMLOCALPARAMETER4DARBPROC ProgramLocalParameter4dARB;
+    PFNGLPROGRAMLOCALPARAMETER4DVARBPROC ProgramLocalParameter4dvARB;
+    PFNGLPROGRAMLOCALPARAMETER4FARBPROC ProgramLocalParameter4fARB;
+    PFNGLPROGRAMLOCALPARAMETER4FVARBPROC ProgramLocalParameter4fvARB;
+    PFNGLPROGRAMPARAMETER4DNVPROC ProgramParameter4dNV;
+    PFNGLPROGRAMPARAMETER4DVNVPROC ProgramParameter4dvNV;
+    PFNGLPROGRAMPARAMETER4FNVPROC ProgramParameter4fNV;
+    PFNGLPROGRAMPARAMETER4FVNVPROC ProgramParameter4fvNV;
+    PFNGLPROGRAMPARAMETERIARBPROC ProgramParameteriARB;
+    PFNGLPROGRAMPARAMETERS4DVNVPROC ProgramParameters4dvNV;
+    PFNGLPROGRAMPARAMETERS4FVNVPROC ProgramParameters4fvNV;
+    PFNGLPROGRAMSTRINGARBPROC ProgramStringARB;
+    PFNGLPROGRAMUNIFORM1DEXTPROC ProgramUniform1dEXT;
+    PFNGLPROGRAMUNIFORM1DVEXTPROC ProgramUniform1dvEXT;
+    PFNGLPROGRAMUNIFORM1FEXTPROC ProgramUniform1fEXT;
+    PFNGLPROGRAMUNIFORM1FVEXTPROC ProgramUniform1fvEXT;
+    PFNGLPROGRAMUNIFORM1IEXTPROC ProgramUniform1iEXT;
+    PFNGLPROGRAMUNIFORM1IVEXTPROC ProgramUniform1ivEXT;
+    PFNGLPROGRAMUNIFORM1UIEXTPROC ProgramUniform1uiEXT;
+    PFNGLPROGRAMUNIFORM1UIVEXTPROC ProgramUniform1uivEXT;
+    PFNGLPROGRAMUNIFORM2DEXTPROC ProgramUniform2dEXT;
+    PFNGLPROGRAMUNIFORM2DVEXTPROC ProgramUniform2dvEXT;
+    PFNGLPROGRAMUNIFORM2FEXTPROC ProgramUniform2fEXT;
+    PFNGLPROGRAMUNIFORM2FVEXTPROC ProgramUniform2fvEXT;
+    PFNGLPROGRAMUNIFORM2IEXTPROC ProgramUniform2iEXT;
+    PFNGLPROGRAMUNIFORM2IVEXTPROC ProgramUniform2ivEXT;
+    PFNGLPROGRAMUNIFORM2UIEXTPROC ProgramUniform2uiEXT;
+    PFNGLPROGRAMUNIFORM2UIVEXTPROC ProgramUniform2uivEXT;
+    PFNGLPROGRAMUNIFORM3DEXTPROC ProgramUniform3dEXT;
+    PFNGLPROGRAMUNIFORM3DVEXTPROC ProgramUniform3dvEXT;
+    PFNGLPROGRAMUNIFORM3FEXTPROC ProgramUniform3fEXT;
+    PFNGLPROGRAMUNIFORM3FVEXTPROC ProgramUniform3fvEXT;
+    PFNGLPROGRAMUNIFORM3IEXTPROC ProgramUniform3iEXT;
+    PFNGLPROGRAMUNIFORM3IVEXTPROC ProgramUniform3ivEXT;
+    PFNGLPROGRAMUNIFORM3UIEXTPROC ProgramUniform3uiEXT;
+    PFNGLPROGRAMUNIFORM3UIVEXTPROC ProgramUniform3uivEXT;
+    PFNGLPROGRAMUNIFORM4DEXTPROC ProgramUniform4dEXT;
+    PFNGLPROGRAMUNIFORM4DVEXTPROC ProgramUniform4dvEXT;
+    PFNGLPROGRAMUNIFORM4FEXTPROC ProgramUniform4fEXT;
+    PFNGLPROGRAMUNIFORM4FVEXTPROC ProgramUniform4fvEXT;
+    PFNGLPROGRAMUNIFORM4IEXTPROC ProgramUniform4iEXT;
+    PFNGLPROGRAMUNIFORM4IVEXTPROC ProgramUniform4ivEXT;
+    PFNGLPROGRAMUNIFORM4UIEXTPROC ProgramUniform4uiEXT;
+    PFNGLPROGRAMUNIFORM4UIVEXTPROC ProgramUniform4uivEXT;
+    PFNGLPROGRAMUNIFORMMATRIX2DVEXTPROC ProgramUniformMatrix2dvEXT;
+    PFNGLPROGRAMUNIFORMMATRIX2FVEXTPROC ProgramUniformMatrix2fvEXT;
+    PFNGLPROGRAMUNIFORMMATRIX2X3DVEXTPROC ProgramUniformMatrix2x3dvEXT;
+    PFNGLPROGRAMUNIFORMMATRIX2X3FVEXTPROC ProgramUniformMatrix2x3fvEXT;
+    PFNGLPROGRAMUNIFORMMATRIX2X4DVEXTPROC ProgramUniformMatrix2x4dvEXT;
+    PFNGLPROGRAMUNIFORMMATRIX2X4FVEXTPROC ProgramUniformMatrix2x4fvEXT;
+    PFNGLPROGRAMUNIFORMMATRIX3DVEXTPROC ProgramUniformMatrix3dvEXT;
+    PFNGLPROGRAMUNIFORMMATRIX3FVEXTPROC ProgramUniformMatrix3fvEXT;
+    PFNGLPROGRAMUNIFORMMATRIX3X2DVEXTPROC ProgramUniformMatrix3x2dvEXT;
+    PFNGLPROGRAMUNIFORMMATRIX3X2FVEXTPROC ProgramUniformMatrix3x2fvEXT;
+    PFNGLPROGRAMUNIFORMMATRIX3X4DVEXTPROC ProgramUniformMatrix3x4dvEXT;
+    PFNGLPROGRAMUNIFORMMATRIX3X4FVEXTPROC ProgramUniformMatrix3x4fvEXT;
+    PFNGLPROGRAMUNIFORMMATRIX4DVEXTPROC ProgramUniformMatrix4dvEXT;
+    PFNGLPROGRAMUNIFORMMATRIX4FVEXTPROC ProgramUniformMatrix4fvEXT;
+    PFNGLPROGRAMUNIFORMMATRIX4X2DVEXTPROC ProgramUniformMatrix4x2dvEXT;
+    PFNGLPROGRAMUNIFORMMATRIX4X2FVEXTPROC ProgramUniformMatrix4x2fvEXT;
+    PFNGLPROGRAMUNIFORMMATRIX4X3DVEXTPROC ProgramUniformMatrix4x3dvEXT;
+    PFNGLPROGRAMUNIFORMMATRIX4X3FVEXTPROC ProgramUniformMatrix4x3fvEXT;
+    PFNGLPROGRAMVERTEXLIMITNVPROC ProgramVertexLimitNV;
+    PFNGLPROVOKINGVERTEXPROC ProvokingVertex;
+    PFNGLPROVOKINGVERTEXEXTPROC ProvokingVertexEXT;
+    PFNGLPUSHCLIENTATTRIBDEFAULTEXTPROC PushClientAttribDefaultEXT;
+    PFNGLREADBUFFERPROC ReadBuffer;
+    PFNGLREADPIXELSPROC ReadPixels;
+    PFNGLRENDERBUFFERSTORAGEPROC RenderbufferStorage;
+    PFNGLRENDERBUFFERSTORAGEEXTPROC RenderbufferStorageEXT;
+    PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC RenderbufferStorageMultisample;
+    PFNGLRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC RenderbufferStorageMultisampleEXT;
+    PFNGLREQUESTRESIDENTPROGRAMSNVPROC RequestResidentProgramsNV;
+    PFNGLSAMPLECOVERAGEPROC SampleCoverage;
+    PFNGLSAMPLECOVERAGEARBPROC SampleCoverageARB;
+    PFNGLSAMPLEMASKINDEXEDNVPROC SampleMaskIndexedNV;
+    PFNGLSAMPLEMASKIPROC SampleMaski;
+    PFNGLSCISSORPROC Scissor;
+    PFNGLSHADERSOURCEPROC ShaderSource;
+    PFNGLSHADERSOURCEARBPROC ShaderSourceARB;
+    PFNGLSTENCILFUNCPROC StencilFunc;
+    PFNGLSTENCILFUNCSEPARATEPROC StencilFuncSeparate;
+    PFNGLSTENCILFUNCSEPARATEATIPROC StencilFuncSeparateATI;
+    PFNGLSTENCILMASKPROC StencilMask;
+    PFNGLSTENCILMASKSEPARATEPROC StencilMaskSeparate;
+    PFNGLSTENCILOPPROC StencilOp;
+    PFNGLSTENCILOPSEPARATEPROC StencilOpSeparate;
+    PFNGLSTENCILOPSEPARATEATIPROC StencilOpSeparateATI;
+    PFNGLTEXBUFFERPROC TexBuffer;
+    PFNGLTEXBUFFERARBPROC TexBufferARB;
+    PFNGLTEXBUFFEREXTPROC TexBufferEXT;
+    PFNGLTEXCOORDPOINTEREXTPROC TexCoordPointerEXT;
+    PFNGLTEXIMAGE1DPROC TexImage1D;
+    PFNGLTEXIMAGE2DPROC TexImage2D;
+    PFNGLTEXIMAGE2DMULTISAMPLEPROC TexImage2DMultisample;
+    PFNGLTEXIMAGE3DPROC TexImage3D;
+    PFNGLTEXIMAGE3DEXTPROC TexImage3DEXT;
+    PFNGLTEXIMAGE3DMULTISAMPLEPROC TexImage3DMultisample;
+    PFNGLTEXPARAMETERIIVPROC TexParameterIiv;
+    PFNGLTEXPARAMETERIIVEXTPROC TexParameterIivEXT;
+    PFNGLTEXPARAMETERIUIVPROC TexParameterIuiv;
+    PFNGLTEXPARAMETERIUIVEXTPROC TexParameterIuivEXT;
+    PFNGLTEXPARAMETERFPROC TexParameterf;
+    PFNGLTEXPARAMETERFVPROC TexParameterfv;
+    PFNGLTEXPARAMETERIPROC TexParameteri;
+    PFNGLTEXPARAMETERIVPROC TexParameteriv;
+    PFNGLTEXRENDERBUFFERNVPROC TexRenderbufferNV;
+    PFNGLTEXSUBIMAGE1DPROC TexSubImage1D;
+    PFNGLTEXSUBIMAGE1DEXTPROC TexSubImage1DEXT;
+    PFNGLTEXSUBIMAGE2DPROC TexSubImage2D;
+    PFNGLTEXSUBIMAGE2DEXTPROC TexSubImage2DEXT;
+    PFNGLTEXSUBIMAGE3DPROC TexSubImage3D;
+    PFNGLTEXSUBIMAGE3DEXTPROC TexSubImage3DEXT;
+    PFNGLTEXTUREBUFFEREXTPROC TextureBufferEXT;
+    PFNGLTEXTUREBUFFERRANGEEXTPROC TextureBufferRangeEXT;
+    PFNGLTEXTUREIMAGE1DEXTPROC TextureImage1DEXT;
+    PFNGLTEXTUREIMAGE2DEXTPROC TextureImage2DEXT;
+    PFNGLTEXTUREIMAGE3DEXTPROC TextureImage3DEXT;
+    PFNGLTEXTUREPAGECOMMITMENTEXTPROC TexturePageCommitmentEXT;
+    PFNGLTEXTUREPARAMETERIIVEXTPROC TextureParameterIivEXT;
+    PFNGLTEXTUREPARAMETERIUIVEXTPROC TextureParameterIuivEXT;
+    PFNGLTEXTUREPARAMETERFEXTPROC TextureParameterfEXT;
+    PFNGLTEXTUREPARAMETERFVEXTPROC TextureParameterfvEXT;
+    PFNGLTEXTUREPARAMETERIEXTPROC TextureParameteriEXT;
+    PFNGLTEXTUREPARAMETERIVEXTPROC TextureParameterivEXT;
+    PFNGLTEXTURERENDERBUFFEREXTPROC TextureRenderbufferEXT;
+    PFNGLTEXTURESTORAGE1DEXTPROC TextureStorage1DEXT;
+    PFNGLTEXTURESTORAGE2DEXTPROC TextureStorage2DEXT;
+    PFNGLTEXTURESTORAGE2DMULTISAMPLEEXTPROC TextureStorage2DMultisampleEXT;
+    PFNGLTEXTURESTORAGE3DEXTPROC TextureStorage3DEXT;
+    PFNGLTEXTURESTORAGE3DMULTISAMPLEEXTPROC TextureStorage3DMultisampleEXT;
+    PFNGLTEXTURESUBIMAGE1DEXTPROC TextureSubImage1DEXT;
+    PFNGLTEXTURESUBIMAGE2DEXTPROC TextureSubImage2DEXT;
+    PFNGLTEXTURESUBIMAGE3DEXTPROC TextureSubImage3DEXT;
+    PFNGLTRACKMATRIXNVPROC TrackMatrixNV;
+    PFNGLTRANSFORMFEEDBACKATTRIBSNVPROC TransformFeedbackAttribsNV;
+    PFNGLTRANSFORMFEEDBACKSTREAMATTRIBSNVPROC TransformFeedbackStreamAttribsNV;
+    PFNGLTRANSFORMFEEDBACKVARYINGSPROC TransformFeedbackVaryings;
+    PFNGLTRANSFORMFEEDBACKVARYINGSEXTPROC TransformFeedbackVaryingsEXT;
+    PFNGLTRANSFORMFEEDBACKVARYINGSNVPROC TransformFeedbackVaryingsNV;
+    PFNGLUNIFORM1FPROC Uniform1f;
+    PFNGLUNIFORM1FARBPROC Uniform1fARB;
+    PFNGLUNIFORM1FVPROC Uniform1fv;
+    PFNGLUNIFORM1FVARBPROC Uniform1fvARB;
+    PFNGLUNIFORM1IPROC Uniform1i;
+    PFNGLUNIFORM1IARBPROC Uniform1iARB;
+    PFNGLUNIFORM1IVPROC Uniform1iv;
+    PFNGLUNIFORM1IVARBPROC Uniform1ivARB;
+    PFNGLUNIFORM1UIPROC Uniform1ui;
+    PFNGLUNIFORM1UIEXTPROC Uniform1uiEXT;
+    PFNGLUNIFORM1UIVPROC Uniform1uiv;
+    PFNGLUNIFORM1UIVEXTPROC Uniform1uivEXT;
+    PFNGLUNIFORM2FPROC Uniform2f;
+    PFNGLUNIFORM2FARBPROC Uniform2fARB;
+    PFNGLUNIFORM2FVPROC Uniform2fv;
+    PFNGLUNIFORM2FVARBPROC Uniform2fvARB;
+    PFNGLUNIFORM2IPROC Uniform2i;
+    PFNGLUNIFORM2IARBPROC Uniform2iARB;
+    PFNGLUNIFORM2IVPROC Uniform2iv;
+    PFNGLUNIFORM2IVARBPROC Uniform2ivARB;
+    PFNGLUNIFORM2UIPROC Uniform2ui;
+    PFNGLUNIFORM2UIEXTPROC Uniform2uiEXT;
+    PFNGLUNIFORM2UIVPROC Uniform2uiv;
+    PFNGLUNIFORM2UIVEXTPROC Uniform2uivEXT;
+    PFNGLUNIFORM3FPROC Uniform3f;
+    PFNGLUNIFORM3FARBPROC Uniform3fARB;
+    PFNGLUNIFORM3FVPROC Uniform3fv;
+    PFNGLUNIFORM3FVARBPROC Uniform3fvARB;
+    PFNGLUNIFORM3IPROC Uniform3i;
+    PFNGLUNIFORM3IARBPROC Uniform3iARB;
+    PFNGLUNIFORM3IVPROC Uniform3iv;
+    PFNGLUNIFORM3IVARBPROC Uniform3ivARB;
+    PFNGLUNIFORM3UIPROC Uniform3ui;
+    PFNGLUNIFORM3UIEXTPROC Uniform3uiEXT;
+    PFNGLUNIFORM3UIVPROC Uniform3uiv;
+    PFNGLUNIFORM3UIVEXTPROC Uniform3uivEXT;
+    PFNGLUNIFORM4FPROC Uniform4f;
+    PFNGLUNIFORM4FARBPROC Uniform4fARB;
+    PFNGLUNIFORM4FVPROC Uniform4fv;
+    PFNGLUNIFORM4FVARBPROC Uniform4fvARB;
+    PFNGLUNIFORM4IPROC Uniform4i;
+    PFNGLUNIFORM4IARBPROC Uniform4iARB;
+    PFNGLUNIFORM4IVPROC Uniform4iv;
+    PFNGLUNIFORM4IVARBPROC Uniform4ivARB;
+    PFNGLUNIFORM4UIPROC Uniform4ui;
+    PFNGLUNIFORM4UIEXTPROC Uniform4uiEXT;
+    PFNGLUNIFORM4UIVPROC Uniform4uiv;
+    PFNGLUNIFORM4UIVEXTPROC Uniform4uivEXT;
+    PFNGLUNIFORMBLOCKBINDINGPROC UniformBlockBinding;
+    PFNGLUNIFORMMATRIX2FVPROC UniformMatrix2fv;
+    PFNGLUNIFORMMATRIX2FVARBPROC UniformMatrix2fvARB;
+    PFNGLUNIFORMMATRIX2X3FVPROC UniformMatrix2x3fv;
+    PFNGLUNIFORMMATRIX2X4FVPROC UniformMatrix2x4fv;
+    PFNGLUNIFORMMATRIX3FVPROC UniformMatrix3fv;
+    PFNGLUNIFORMMATRIX3FVARBPROC UniformMatrix3fvARB;
+    PFNGLUNIFORMMATRIX3X2FVPROC UniformMatrix3x2fv;
+    PFNGLUNIFORMMATRIX3X4FVPROC UniformMatrix3x4fv;
+    PFNGLUNIFORMMATRIX4FVPROC UniformMatrix4fv;
+    PFNGLUNIFORMMATRIX4FVARBPROC UniformMatrix4fvARB;
+    PFNGLUNIFORMMATRIX4X2FVPROC UniformMatrix4x2fv;
+    PFNGLUNIFORMMATRIX4X3FVPROC UniformMatrix4x3fv;
+    PFNGLUNMAPBUFFERPROC UnmapBuffer;
+    PFNGLUNMAPBUFFERARBPROC UnmapBufferARB;
+    PFNGLUNMAPNAMEDBUFFEREXTPROC UnmapNamedBufferEXT;
+    PFNGLUSEPROGRAMPROC UseProgram;
+    PFNGLUSEPROGRAMOBJECTARBPROC UseProgramObjectARB;
+    PFNGLVALIDATEPROGRAMPROC ValidateProgram;
+    PFNGLVALIDATEPROGRAMARBPROC ValidateProgramARB;
+    PFNGLVERTEXARRAYBINDVERTEXBUFFEREXTPROC VertexArrayBindVertexBufferEXT;
+    PFNGLVERTEXARRAYCOLOROFFSETEXTPROC VertexArrayColorOffsetEXT;
+    PFNGLVERTEXARRAYEDGEFLAGOFFSETEXTPROC VertexArrayEdgeFlagOffsetEXT;
+    PFNGLVERTEXARRAYFOGCOORDOFFSETEXTPROC VertexArrayFogCoordOffsetEXT;
+    PFNGLVERTEXARRAYINDEXOFFSETEXTPROC VertexArrayIndexOffsetEXT;
+    PFNGLVERTEXARRAYMULTITEXCOORDOFFSETEXTPROC VertexArrayMultiTexCoordOffsetEXT;
+    PFNGLVERTEXARRAYNORMALOFFSETEXTPROC VertexArrayNormalOffsetEXT;
+    PFNGLVERTEXARRAYSECONDARYCOLOROFFSETEXTPROC VertexArraySecondaryColorOffsetEXT;
+    PFNGLVERTEXARRAYTEXCOORDOFFSETEXTPROC VertexArrayTexCoordOffsetEXT;
+    PFNGLVERTEXARRAYVERTEXATTRIBBINDINGEXTPROC VertexArrayVertexAttribBindingEXT;
+    PFNGLVERTEXARRAYVERTEXATTRIBDIVISOREXTPROC VertexArrayVertexAttribDivisorEXT;
+    PFNGLVERTEXARRAYVERTEXATTRIBFORMATEXTPROC VertexArrayVertexAttribFormatEXT;
+    PFNGLVERTEXARRAYVERTEXATTRIBIFORMATEXTPROC VertexArrayVertexAttribIFormatEXT;
+    PFNGLVERTEXARRAYVERTEXATTRIBIOFFSETEXTPROC VertexArrayVertexAttribIOffsetEXT;
+    PFNGLVERTEXARRAYVERTEXATTRIBLFORMATEXTPROC VertexArrayVertexAttribLFormatEXT;
+    PFNGLVERTEXARRAYVERTEXATTRIBLOFFSETEXTPROC VertexArrayVertexAttribLOffsetEXT;
+    PFNGLVERTEXARRAYVERTEXATTRIBOFFSETEXTPROC VertexArrayVertexAttribOffsetEXT;
+    PFNGLVERTEXARRAYVERTEXBINDINGDIVISOREXTPROC VertexArrayVertexBindingDivisorEXT;
+    PFNGLVERTEXARRAYVERTEXOFFSETEXTPROC VertexArrayVertexOffsetEXT;
+    PFNGLVERTEXATTRIB1DPROC VertexAttrib1d;
+    PFNGLVERTEXATTRIB1DARBPROC VertexAttrib1dARB;
+    PFNGLVERTEXATTRIB1DNVPROC VertexAttrib1dNV;
+    PFNGLVERTEXATTRIB1DVPROC VertexAttrib1dv;
+    PFNGLVERTEXATTRIB1DVARBPROC VertexAttrib1dvARB;
+    PFNGLVERTEXATTRIB1DVNVPROC VertexAttrib1dvNV;
+    PFNGLVERTEXATTRIB1FPROC VertexAttrib1f;
+    PFNGLVERTEXATTRIB1FARBPROC VertexAttrib1fARB;
+    PFNGLVERTEXATTRIB1FNVPROC VertexAttrib1fNV;
+    PFNGLVERTEXATTRIB1FVPROC VertexAttrib1fv;
+    PFNGLVERTEXATTRIB1FVARBPROC VertexAttrib1fvARB;
+    PFNGLVERTEXATTRIB1FVNVPROC VertexAttrib1fvNV;
+    PFNGLVERTEXATTRIB1SPROC VertexAttrib1s;
+    PFNGLVERTEXATTRIB1SARBPROC VertexAttrib1sARB;
+    PFNGLVERTEXATTRIB1SNVPROC VertexAttrib1sNV;
+    PFNGLVERTEXATTRIB1SVPROC VertexAttrib1sv;
+    PFNGLVERTEXATTRIB1SVARBPROC VertexAttrib1svARB;
+    PFNGLVERTEXATTRIB1SVNVPROC VertexAttrib1svNV;
+    PFNGLVERTEXATTRIB2DPROC VertexAttrib2d;
+    PFNGLVERTEXATTRIB2DARBPROC VertexAttrib2dARB;
+    PFNGLVERTEXATTRIB2DNVPROC VertexAttrib2dNV;
+    PFNGLVERTEXATTRIB2DVPROC VertexAttrib2dv;
+    PFNGLVERTEXATTRIB2DVARBPROC VertexAttrib2dvARB;
+    PFNGLVERTEXATTRIB2DVNVPROC VertexAttrib2dvNV;
+    PFNGLVERTEXATTRIB2FPROC VertexAttrib2f;
+    PFNGLVERTEXATTRIB2FARBPROC VertexAttrib2fARB;
+    PFNGLVERTEXATTRIB2FNVPROC VertexAttrib2fNV;
+    PFNGLVERTEXATTRIB2FVPROC VertexAttrib2fv;
+    PFNGLVERTEXATTRIB2FVARBPROC VertexAttrib2fvARB;
+    PFNGLVERTEXATTRIB2FVNVPROC VertexAttrib2fvNV;
+    PFNGLVERTEXATTRIB2SPROC VertexAttrib2s;
+    PFNGLVERTEXATTRIB2SARBPROC VertexAttrib2sARB;
+    PFNGLVERTEXATTRIB2SNVPROC VertexAttrib2sNV;
+    PFNGLVERTEXATTRIB2SVPROC VertexAttrib2sv;
+    PFNGLVERTEXATTRIB2SVARBPROC VertexAttrib2svARB;
+    PFNGLVERTEXATTRIB2SVNVPROC VertexAttrib2svNV;
+    PFNGLVERTEXATTRIB3DPROC VertexAttrib3d;
+    PFNGLVERTEXATTRIB3DARBPROC VertexAttrib3dARB;
+    PFNGLVERTEXATTRIB3DNVPROC VertexAttrib3dNV;
+    PFNGLVERTEXATTRIB3DVPROC VertexAttrib3dv;
+    PFNGLVERTEXATTRIB3DVARBPROC VertexAttrib3dvARB;
+    PFNGLVERTEXATTRIB3DVNVPROC VertexAttrib3dvNV;
+    PFNGLVERTEXATTRIB3FPROC VertexAttrib3f;
+    PFNGLVERTEXATTRIB3FARBPROC VertexAttrib3fARB;
+    PFNGLVERTEXATTRIB3FNVPROC VertexAttrib3fNV;
+    PFNGLVERTEXATTRIB3FVPROC VertexAttrib3fv;
+    PFNGLVERTEXATTRIB3FVARBPROC VertexAttrib3fvARB;
+    PFNGLVERTEXATTRIB3FVNVPROC VertexAttrib3fvNV;
+    PFNGLVERTEXATTRIB3SPROC VertexAttrib3s;
+    PFNGLVERTEXATTRIB3SARBPROC VertexAttrib3sARB;
+    PFNGLVERTEXATTRIB3SNVPROC VertexAttrib3sNV;
+    PFNGLVERTEXATTRIB3SVPROC VertexAttrib3sv;
+    PFNGLVERTEXATTRIB3SVARBPROC VertexAttrib3svARB;
+    PFNGLVERTEXATTRIB3SVNVPROC VertexAttrib3svNV;
+    PFNGLVERTEXATTRIB4NBVPROC VertexAttrib4Nbv;
+    PFNGLVERTEXATTRIB4NBVARBPROC VertexAttrib4NbvARB;
+    PFNGLVERTEXATTRIB4NIVPROC VertexAttrib4Niv;
+    PFNGLVERTEXATTRIB4NIVARBPROC VertexAttrib4NivARB;
+    PFNGLVERTEXATTRIB4NSVPROC VertexAttrib4Nsv;
+    PFNGLVERTEXATTRIB4NSVARBPROC VertexAttrib4NsvARB;
+    PFNGLVERTEXATTRIB4NUBPROC VertexAttrib4Nub;
+    PFNGLVERTEXATTRIB4NUBARBPROC VertexAttrib4NubARB;
+    PFNGLVERTEXATTRIB4NUBVPROC VertexAttrib4Nubv;
+    PFNGLVERTEXATTRIB4NUBVARBPROC VertexAttrib4NubvARB;
+    PFNGLVERTEXATTRIB4NUIVPROC VertexAttrib4Nuiv;
+    PFNGLVERTEXATTRIB4NUIVARBPROC VertexAttrib4NuivARB;
+    PFNGLVERTEXATTRIB4NUSVPROC VertexAttrib4Nusv;
+    PFNGLVERTEXATTRIB4NUSVARBPROC VertexAttrib4NusvARB;
+    PFNGLVERTEXATTRIB4BVPROC VertexAttrib4bv;
+    PFNGLVERTEXATTRIB4BVARBPROC VertexAttrib4bvARB;
+    PFNGLVERTEXATTRIB4DPROC VertexAttrib4d;
+    PFNGLVERTEXATTRIB4DARBPROC VertexAttrib4dARB;
+    PFNGLVERTEXATTRIB4DNVPROC VertexAttrib4dNV;
+    PFNGLVERTEXATTRIB4DVPROC VertexAttrib4dv;
+    PFNGLVERTEXATTRIB4DVARBPROC VertexAttrib4dvARB;
+    PFNGLVERTEXATTRIB4DVNVPROC VertexAttrib4dvNV;
+    PFNGLVERTEXATTRIB4FPROC VertexAttrib4f;
+    PFNGLVERTEXATTRIB4FARBPROC VertexAttrib4fARB;
+    PFNGLVERTEXATTRIB4FNVPROC VertexAttrib4fNV;
+    PFNGLVERTEXATTRIB4FVPROC VertexAttrib4fv;
+    PFNGLVERTEXATTRIB4FVARBPROC VertexAttrib4fvARB;
+    PFNGLVERTEXATTRIB4FVNVPROC VertexAttrib4fvNV;
+    PFNGLVERTEXATTRIB4IVPROC VertexAttrib4iv;
+    PFNGLVERTEXATTRIB4IVARBPROC VertexAttrib4ivARB;
+    PFNGLVERTEXATTRIB4SPROC VertexAttrib4s;
+    PFNGLVERTEXATTRIB4SARBPROC VertexAttrib4sARB;
+    PFNGLVERTEXATTRIB4SNVPROC VertexAttrib4sNV;
+    PFNGLVERTEXATTRIB4SVPROC VertexAttrib4sv;
+    PFNGLVERTEXATTRIB4SVARBPROC VertexAttrib4svARB;
+    PFNGLVERTEXATTRIB4SVNVPROC VertexAttrib4svNV;
+    PFNGLVERTEXATTRIB4UBNVPROC VertexAttrib4ubNV;
+    PFNGLVERTEXATTRIB4UBVPROC VertexAttrib4ubv;
+    PFNGLVERTEXATTRIB4UBVARBPROC VertexAttrib4ubvARB;
+    PFNGLVERTEXATTRIB4UBVNVPROC VertexAttrib4ubvNV;
+    PFNGLVERTEXATTRIB4UIVPROC VertexAttrib4uiv;
+    PFNGLVERTEXATTRIB4UIVARBPROC VertexAttrib4uivARB;
+    PFNGLVERTEXATTRIB4USVPROC VertexAttrib4usv;
+    PFNGLVERTEXATTRIB4USVARBPROC VertexAttrib4usvARB;
+    PFNGLVERTEXATTRIBI1IPROC VertexAttribI1i;
+    PFNGLVERTEXATTRIBI1IEXTPROC VertexAttribI1iEXT;
+    PFNGLVERTEXATTRIBI1IVPROC VertexAttribI1iv;
+    PFNGLVERTEXATTRIBI1IVEXTPROC VertexAttribI1ivEXT;
+    PFNGLVERTEXATTRIBI1UIPROC VertexAttribI1ui;
+    PFNGLVERTEXATTRIBI1UIEXTPROC VertexAttribI1uiEXT;
+    PFNGLVERTEXATTRIBI1UIVPROC VertexAttribI1uiv;
+    PFNGLVERTEXATTRIBI1UIVEXTPROC VertexAttribI1uivEXT;
+    PFNGLVERTEXATTRIBI2IPROC VertexAttribI2i;
+    PFNGLVERTEXATTRIBI2IEXTPROC VertexAttribI2iEXT;
+    PFNGLVERTEXATTRIBI2IVPROC VertexAttribI2iv;
+    PFNGLVERTEXATTRIBI2IVEXTPROC VertexAttribI2ivEXT;
+    PFNGLVERTEXATTRIBI2UIPROC VertexAttribI2ui;
+    PFNGLVERTEXATTRIBI2UIEXTPROC VertexAttribI2uiEXT;
+    PFNGLVERTEXATTRIBI2UIVPROC VertexAttribI2uiv;
+    PFNGLVERTEXATTRIBI2UIVEXTPROC VertexAttribI2uivEXT;
+    PFNGLVERTEXATTRIBI3IPROC VertexAttribI3i;
+    PFNGLVERTEXATTRIBI3IEXTPROC VertexAttribI3iEXT;
+    PFNGLVERTEXATTRIBI3IVPROC VertexAttribI3iv;
+    PFNGLVERTEXATTRIBI3IVEXTPROC VertexAttribI3ivEXT;
+    PFNGLVERTEXATTRIBI3UIPROC VertexAttribI3ui;
+    PFNGLVERTEXATTRIBI3UIEXTPROC VertexAttribI3uiEXT;
+    PFNGLVERTEXATTRIBI3UIVPROC VertexAttribI3uiv;
+    PFNGLVERTEXATTRIBI3UIVEXTPROC VertexAttribI3uivEXT;
+    PFNGLVERTEXATTRIBI4BVPROC VertexAttribI4bv;
+    PFNGLVERTEXATTRIBI4BVEXTPROC VertexAttribI4bvEXT;
+    PFNGLVERTEXATTRIBI4IPROC VertexAttribI4i;
+    PFNGLVERTEXATTRIBI4IEXTPROC VertexAttribI4iEXT;
+    PFNGLVERTEXATTRIBI4IVPROC VertexAttribI4iv;
+    PFNGLVERTEXATTRIBI4IVEXTPROC VertexAttribI4ivEXT;
+    PFNGLVERTEXATTRIBI4SVPROC VertexAttribI4sv;
+    PFNGLVERTEXATTRIBI4SVEXTPROC VertexAttribI4svEXT;
+    PFNGLVERTEXATTRIBI4UBVPROC VertexAttribI4ubv;
+    PFNGLVERTEXATTRIBI4UBVEXTPROC VertexAttribI4ubvEXT;
+    PFNGLVERTEXATTRIBI4UIPROC VertexAttribI4ui;
+    PFNGLVERTEXATTRIBI4UIEXTPROC VertexAttribI4uiEXT;
+    PFNGLVERTEXATTRIBI4UIVPROC VertexAttribI4uiv;
+    PFNGLVERTEXATTRIBI4UIVEXTPROC VertexAttribI4uivEXT;
+    PFNGLVERTEXATTRIBI4USVPROC VertexAttribI4usv;
+    PFNGLVERTEXATTRIBI4USVEXTPROC VertexAttribI4usvEXT;
+    PFNGLVERTEXATTRIBIPOINTERPROC VertexAttribIPointer;
+    PFNGLVERTEXATTRIBIPOINTEREXTPROC VertexAttribIPointerEXT;
+    PFNGLVERTEXATTRIBPOINTERPROC VertexAttribPointer;
+    PFNGLVERTEXATTRIBPOINTERARBPROC VertexAttribPointerARB;
+    PFNGLVERTEXATTRIBPOINTERNVPROC VertexAttribPointerNV;
+    PFNGLVERTEXATTRIBS1DVNVPROC VertexAttribs1dvNV;
+    PFNGLVERTEXATTRIBS1FVNVPROC VertexAttribs1fvNV;
+    PFNGLVERTEXATTRIBS1SVNVPROC VertexAttribs1svNV;
+    PFNGLVERTEXATTRIBS2DVNVPROC VertexAttribs2dvNV;
+    PFNGLVERTEXATTRIBS2FVNVPROC VertexAttribs2fvNV;
+    PFNGLVERTEXATTRIBS2SVNVPROC VertexAttribs2svNV;
+    PFNGLVERTEXATTRIBS3DVNVPROC VertexAttribs3dvNV;
+    PFNGLVERTEXATTRIBS3FVNVPROC VertexAttribs3fvNV;
+    PFNGLVERTEXATTRIBS3SVNVPROC VertexAttribs3svNV;
+    PFNGLVERTEXATTRIBS4DVNVPROC VertexAttribs4dvNV;
+    PFNGLVERTEXATTRIBS4FVNVPROC VertexAttribs4fvNV;
+    PFNGLVERTEXATTRIBS4SVNVPROC VertexAttribs4svNV;
+    PFNGLVERTEXATTRIBS4UBVNVPROC VertexAttribs4ubvNV;
+    PFNGLVERTEXPOINTEREXTPROC VertexPointerEXT;
+    PFNGLVIEWPORTPROC Viewport;
+    PFNGLWAITSYNCPROC WaitSync;
+
+} GladGLContext;
+
+
+
+
+
+
+GLAD_API_CALL int gladLoadGLContextUserPtr(GladGLContext *context, GLADuserptrloadfunc load, void *userptr);
+GLAD_API_CALL int gladLoadGLContext(GladGLContext *context, GLADloadfunc load);
+
+
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/thirdparty/glad/include/glad/gles2.h b/thirdparty/glad/include/glad/gles2.h
new file mode 100644
index 000000000..a03d1e261
--- /dev/null
+++ b/thirdparty/glad/include/glad/gles2.h
@@ -0,0 +1,861 @@
+/**
+ * Loader generated by glad 2.0.2 on Sun Jan  8 22:32:41 2023
+ *
+ * SPDX-License-Identifier: (WTFPL OR CC0-1.0) AND Apache-2.0
+ *
+ * Generator: C/C++
+ * Specification: gl
+ * Extensions: 1
+ *
+ * APIs:
+ *  - gles2=2.0
+ *
+ * Options:
+ *  - ALIAS = True
+ *  - DEBUG = False
+ *  - HEADER_ONLY = False
+ *  - LOADER = False
+ *  - MX = True
+ *  - ON_DEMAND = False
+ *
+ * Commandline:
+ *    --api='gles2=2.0' --extensions='GL_OES_rgb8_rgba8' c --alias --mx
+ *
+ * Online:
+ *    http://glad.sh/#api=gles2%3D2.0&extensions=GL_OES_rgb8_rgba8&generator=c&options=ALIAS%2CMX
+ *
+ */
+
+#ifndef GLAD_GLES2_H_
+#define GLAD_GLES2_H_
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wreserved-id-macro"
+#endif
+#ifdef __gl2_h_
+  #error OpenGL ES 2 header already included (API: gles2), remove previous include!
+#endif
+#define __gl2_h_ 1
+#ifdef __gles2_gl2_h_
+  #error OpenGL ES 2 header already included (API: gles2), remove previous include!
+#endif
+#define __gles2_gl2_h_ 1
+#ifdef __gl3_h_
+  #error OpenGL ES 3 header already included (API: gles2), remove previous include!
+#endif
+#define __gl3_h_ 1
+#ifdef __gles2_gl3_h_
+  #error OpenGL ES 3 header already included (API: gles2), remove previous include!
+#endif
+#define __gles2_gl3_h_ 1
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+#define GLAD_GLES2
+#define GLAD_OPTION_GLES2_ALIAS
+#define GLAD_OPTION_GLES2_MX
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef GLAD_PLATFORM_H_
+#define GLAD_PLATFORM_H_
+
+#ifndef GLAD_PLATFORM_WIN32
+  #if defined(_WIN32) || defined(__WIN32__) || defined(WIN32) || defined(__MINGW32__)
+    #define GLAD_PLATFORM_WIN32 1
+  #else
+    #define GLAD_PLATFORM_WIN32 0
+  #endif
+#endif
+
+#ifndef GLAD_PLATFORM_APPLE
+  #ifdef __APPLE__
+    #define GLAD_PLATFORM_APPLE 1
+  #else
+    #define GLAD_PLATFORM_APPLE 0
+  #endif
+#endif
+
+#ifndef GLAD_PLATFORM_EMSCRIPTEN
+  #ifdef __EMSCRIPTEN__
+    #define GLAD_PLATFORM_EMSCRIPTEN 1
+  #else
+    #define GLAD_PLATFORM_EMSCRIPTEN 0
+  #endif
+#endif
+
+#ifndef GLAD_PLATFORM_UWP
+  #if defined(_MSC_VER) && !defined(GLAD_INTERNAL_HAVE_WINAPIFAMILY)
+    #ifdef __has_include
+      #if __has_include(<winapifamily.h>)
+        #define GLAD_INTERNAL_HAVE_WINAPIFAMILY 1
+      #endif
+    #elif _MSC_VER >= 1700 && !_USING_V110_SDK71_
+      #define GLAD_INTERNAL_HAVE_WINAPIFAMILY 1
+    #endif
+  #endif
+
+  #ifdef GLAD_INTERNAL_HAVE_WINAPIFAMILY
+    #include <winapifamily.h>
+    #if !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) && WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP)
+      #define GLAD_PLATFORM_UWP 1
+    #endif
+  #endif
+
+  #ifndef GLAD_PLATFORM_UWP
+    #define GLAD_PLATFORM_UWP 0
+  #endif
+#endif
+
+#ifdef __GNUC__
+  #define GLAD_GNUC_EXTENSION __extension__
+#else
+  #define GLAD_GNUC_EXTENSION
+#endif
+
+#define GLAD_UNUSED(x) (void)(x)
+
+#ifndef GLAD_API_CALL
+  #if defined(GLAD_API_CALL_EXPORT)
+    #if GLAD_PLATFORM_WIN32 || defined(__CYGWIN__)
+      #if defined(GLAD_API_CALL_EXPORT_BUILD)
+        #if defined(__GNUC__)
+          #define GLAD_API_CALL __attribute__ ((dllexport)) extern
+        #else
+          #define GLAD_API_CALL __declspec(dllexport) extern
+        #endif
+      #else
+        #if defined(__GNUC__)
+          #define GLAD_API_CALL __attribute__ ((dllimport)) extern
+        #else
+          #define GLAD_API_CALL __declspec(dllimport) extern
+        #endif
+      #endif
+    #elif defined(__GNUC__) && defined(GLAD_API_CALL_EXPORT_BUILD)
+      #define GLAD_API_CALL __attribute__ ((visibility ("default"))) extern
+    #else
+      #define GLAD_API_CALL extern
+    #endif
+  #else
+    #define GLAD_API_CALL extern
+  #endif
+#endif
+
+#ifdef APIENTRY
+  #define GLAD_API_PTR APIENTRY
+#elif GLAD_PLATFORM_WIN32
+  #define GLAD_API_PTR __stdcall
+#else
+  #define GLAD_API_PTR
+#endif
+
+#ifndef GLAPI
+#define GLAPI GLAD_API_CALL
+#endif
+
+#ifndef GLAPIENTRY
+#define GLAPIENTRY GLAD_API_PTR
+#endif
+
+#define GLAD_MAKE_VERSION(major, minor) (major * 10000 + minor)
+#define GLAD_VERSION_MAJOR(version) (version / 10000)
+#define GLAD_VERSION_MINOR(version) (version % 10000)
+
+#define GLAD_GENERATOR_VERSION "2.0.2"
+
+typedef void (*GLADapiproc)(void);
+
+typedef GLADapiproc (*GLADloadfunc)(const char *name);
+typedef GLADapiproc (*GLADuserptrloadfunc)(void *userptr, const char *name);
+
+typedef void (*GLADprecallback)(const char *name, GLADapiproc apiproc, int len_args, ...);
+typedef void (*GLADpostcallback)(void *ret, const char *name, GLADapiproc apiproc, int len_args, ...);
+
+#endif /* GLAD_PLATFORM_H_ */
+
+#define GL_ACTIVE_ATTRIBUTES 0x8B89
+#define GL_ACTIVE_ATTRIBUTE_MAX_LENGTH 0x8B8A
+#define GL_ACTIVE_TEXTURE 0x84E0
+#define GL_ACTIVE_UNIFORMS 0x8B86
+#define GL_ACTIVE_UNIFORM_MAX_LENGTH 0x8B87
+#define GL_ALIASED_LINE_WIDTH_RANGE 0x846E
+#define GL_ALIASED_POINT_SIZE_RANGE 0x846D
+#define GL_ALPHA 0x1906
+#define GL_ALPHA_BITS 0x0D55
+#define GL_ALWAYS 0x0207
+#define GL_ARRAY_BUFFER 0x8892
+#define GL_ARRAY_BUFFER_BINDING 0x8894
+#define GL_ATTACHED_SHADERS 0x8B85
+#define GL_BACK 0x0405
+#define GL_BLEND 0x0BE2
+#define GL_BLEND_COLOR 0x8005
+#define GL_BLEND_DST_ALPHA 0x80CA
+#define GL_BLEND_DST_RGB 0x80C8
+#define GL_BLEND_EQUATION 0x8009
+#define GL_BLEND_EQUATION_ALPHA 0x883D
+#define GL_BLEND_EQUATION_RGB 0x8009
+#define GL_BLEND_SRC_ALPHA 0x80CB
+#define GL_BLEND_SRC_RGB 0x80C9
+#define GL_BLUE_BITS 0x0D54
+#define GL_BOOL 0x8B56
+#define GL_BOOL_VEC2 0x8B57
+#define GL_BOOL_VEC3 0x8B58
+#define GL_BOOL_VEC4 0x8B59
+#define GL_BUFFER_SIZE 0x8764
+#define GL_BUFFER_USAGE 0x8765
+#define GL_BYTE 0x1400
+#define GL_CCW 0x0901
+#define GL_CLAMP_TO_EDGE 0x812F
+#define GL_COLOR_ATTACHMENT0 0x8CE0
+#define GL_COLOR_BUFFER_BIT 0x00004000
+#define GL_COLOR_CLEAR_VALUE 0x0C22
+#define GL_COLOR_WRITEMASK 0x0C23
+#define GL_COMPILE_STATUS 0x8B81
+#define GL_COMPRESSED_TEXTURE_FORMATS 0x86A3
+#define GL_CONSTANT_ALPHA 0x8003
+#define GL_CONSTANT_COLOR 0x8001
+#define GL_CULL_FACE 0x0B44
+#define GL_CULL_FACE_MODE 0x0B45
+#define GL_CURRENT_PROGRAM 0x8B8D
+#define GL_CURRENT_VERTEX_ATTRIB 0x8626
+#define GL_CW 0x0900
+#define GL_DECR 0x1E03
+#define GL_DECR_WRAP 0x8508
+#define GL_DELETE_STATUS 0x8B80
+#define GL_DEPTH_ATTACHMENT 0x8D00
+#define GL_DEPTH_BITS 0x0D56
+#define GL_DEPTH_BUFFER_BIT 0x00000100
+#define GL_DEPTH_CLEAR_VALUE 0x0B73
+#define GL_DEPTH_COMPONENT 0x1902
+#define GL_DEPTH_COMPONENT16 0x81A5
+#define GL_DEPTH_FUNC 0x0B74
+#define GL_DEPTH_RANGE 0x0B70
+#define GL_DEPTH_TEST 0x0B71
+#define GL_DEPTH_WRITEMASK 0x0B72
+#define GL_DITHER 0x0BD0
+#define GL_DONT_CARE 0x1100
+#define GL_DST_ALPHA 0x0304
+#define GL_DST_COLOR 0x0306
+#define GL_DYNAMIC_DRAW 0x88E8
+#define GL_ELEMENT_ARRAY_BUFFER 0x8893
+#define GL_ELEMENT_ARRAY_BUFFER_BINDING 0x8895
+#define GL_EQUAL 0x0202
+#define GL_EXTENSIONS 0x1F03
+#define GL_FALSE 0
+#define GL_FASTEST 0x1101
+#define GL_FIXED 0x140C
+#define GL_FLOAT 0x1406
+#define GL_FLOAT_MAT2 0x8B5A
+#define GL_FLOAT_MAT3 0x8B5B
+#define GL_FLOAT_MAT4 0x8B5C
+#define GL_FLOAT_VEC2 0x8B50
+#define GL_FLOAT_VEC3 0x8B51
+#define GL_FLOAT_VEC4 0x8B52
+#define GL_FRAGMENT_SHADER 0x8B30
+#define GL_FRAMEBUFFER 0x8D40
+#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME 0x8CD1
+#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE 0x8CD0
+#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE 0x8CD3
+#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL 0x8CD2
+#define GL_FRAMEBUFFER_BINDING 0x8CA6
+#define GL_FRAMEBUFFER_COMPLETE 0x8CD5
+#define GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT 0x8CD6
+#define GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS 0x8CD9
+#define GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT 0x8CD7
+#define GL_FRAMEBUFFER_UNSUPPORTED 0x8CDD
+#define GL_FRONT 0x0404
+#define GL_FRONT_AND_BACK 0x0408
+#define GL_FRONT_FACE 0x0B46
+#define GL_FUNC_ADD 0x8006
+#define GL_FUNC_REVERSE_SUBTRACT 0x800B
+#define GL_FUNC_SUBTRACT 0x800A
+#define GL_GENERATE_MIPMAP_HINT 0x8192
+#define GL_GEQUAL 0x0206
+#define GL_GREATER 0x0204
+#define GL_GREEN_BITS 0x0D53
+#define GL_HIGH_FLOAT 0x8DF2
+#define GL_HIGH_INT 0x8DF5
+#define GL_IMPLEMENTATION_COLOR_READ_FORMAT 0x8B9B
+#define GL_IMPLEMENTATION_COLOR_READ_TYPE 0x8B9A
+#define GL_INCR 0x1E02
+#define GL_INCR_WRAP 0x8507
+#define GL_INFO_LOG_LENGTH 0x8B84
+#define GL_INT 0x1404
+#define GL_INT_VEC2 0x8B53
+#define GL_INT_VEC3 0x8B54
+#define GL_INT_VEC4 0x8B55
+#define GL_INVALID_ENUM 0x0500
+#define GL_INVALID_FRAMEBUFFER_OPERATION 0x0506
+#define GL_INVALID_OPERATION 0x0502
+#define GL_INVALID_VALUE 0x0501
+#define GL_INVERT 0x150A
+#define GL_KEEP 0x1E00
+#define GL_LEQUAL 0x0203
+#define GL_LESS 0x0201
+#define GL_LINEAR 0x2601
+#define GL_LINEAR_MIPMAP_LINEAR 0x2703
+#define GL_LINEAR_MIPMAP_NEAREST 0x2701
+#define GL_LINES 0x0001
+#define GL_LINE_LOOP 0x0002
+#define GL_LINE_STRIP 0x0003
+#define GL_LINE_WIDTH 0x0B21
+#define GL_LINK_STATUS 0x8B82
+#define GL_LOW_FLOAT 0x8DF0
+#define GL_LOW_INT 0x8DF3
+#define GL_LUMINANCE 0x1909
+#define GL_LUMINANCE_ALPHA 0x190A
+#define GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS 0x8B4D
+#define GL_MAX_CUBE_MAP_TEXTURE_SIZE 0x851C
+#define GL_MAX_FRAGMENT_UNIFORM_VECTORS 0x8DFD
+#define GL_MAX_RENDERBUFFER_SIZE 0x84E8
+#define GL_MAX_TEXTURE_IMAGE_UNITS 0x8872
+#define GL_MAX_TEXTURE_SIZE 0x0D33
+#define GL_MAX_VARYING_VECTORS 0x8DFC
+#define GL_MAX_VERTEX_ATTRIBS 0x8869
+#define GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS 0x8B4C
+#define GL_MAX_VERTEX_UNIFORM_VECTORS 0x8DFB
+#define GL_MAX_VIEWPORT_DIMS 0x0D3A
+#define GL_MEDIUM_FLOAT 0x8DF1
+#define GL_MEDIUM_INT 0x8DF4
+#define GL_MIRRORED_REPEAT 0x8370
+#define GL_NEAREST 0x2600
+#define GL_NEAREST_MIPMAP_LINEAR 0x2702
+#define GL_NEAREST_MIPMAP_NEAREST 0x2700
+#define GL_NEVER 0x0200
+#define GL_NICEST 0x1102
+#define GL_NONE 0
+#define GL_NOTEQUAL 0x0205
+#define GL_NO_ERROR 0
+#define GL_NUM_COMPRESSED_TEXTURE_FORMATS 0x86A2
+#define GL_NUM_SHADER_BINARY_FORMATS 0x8DF9
+#define GL_ONE 1
+#define GL_ONE_MINUS_CONSTANT_ALPHA 0x8004
+#define GL_ONE_MINUS_CONSTANT_COLOR 0x8002
+#define GL_ONE_MINUS_DST_ALPHA 0x0305
+#define GL_ONE_MINUS_DST_COLOR 0x0307
+#define GL_ONE_MINUS_SRC_ALPHA 0x0303
+#define GL_ONE_MINUS_SRC_COLOR 0x0301
+#define GL_OUT_OF_MEMORY 0x0505
+#define GL_PACK_ALIGNMENT 0x0D05
+#define GL_POINTS 0x0000
+#define GL_POLYGON_OFFSET_FACTOR 0x8038
+#define GL_POLYGON_OFFSET_FILL 0x8037
+#define GL_POLYGON_OFFSET_UNITS 0x2A00
+#define GL_RED_BITS 0x0D52
+#define GL_RENDERBUFFER 0x8D41
+#define GL_RENDERBUFFER_ALPHA_SIZE 0x8D53
+#define GL_RENDERBUFFER_BINDING 0x8CA7
+#define GL_RENDERBUFFER_BLUE_SIZE 0x8D52
+#define GL_RENDERBUFFER_DEPTH_SIZE 0x8D54
+#define GL_RENDERBUFFER_GREEN_SIZE 0x8D51
+#define GL_RENDERBUFFER_HEIGHT 0x8D43
+#define GL_RENDERBUFFER_INTERNAL_FORMAT 0x8D44
+#define GL_RENDERBUFFER_RED_SIZE 0x8D50
+#define GL_RENDERBUFFER_STENCIL_SIZE 0x8D55
+#define GL_RENDERBUFFER_WIDTH 0x8D42
+#define GL_RENDERER 0x1F01
+#define GL_REPEAT 0x2901
+#define GL_REPLACE 0x1E01
+#define GL_RGB 0x1907
+#define GL_RGB565 0x8D62
+#define GL_RGB5_A1 0x8057
+#define GL_RGB8_OES 0x8051
+#define GL_RGBA 0x1908
+#define GL_RGBA4 0x8056
+#define GL_RGBA8_OES 0x8058
+#define GL_SAMPLER_2D 0x8B5E
+#define GL_SAMPLER_CUBE 0x8B60
+#define GL_SAMPLES 0x80A9
+#define GL_SAMPLE_ALPHA_TO_COVERAGE 0x809E
+#define GL_SAMPLE_BUFFERS 0x80A8
+#define GL_SAMPLE_COVERAGE 0x80A0
+#define GL_SAMPLE_COVERAGE_INVERT 0x80AB
+#define GL_SAMPLE_COVERAGE_VALUE 0x80AA
+#define GL_SCISSOR_BOX 0x0C10
+#define GL_SCISSOR_TEST 0x0C11
+#define GL_SHADER_BINARY_FORMATS 0x8DF8
+#define GL_SHADER_COMPILER 0x8DFA
+#define GL_SHADER_SOURCE_LENGTH 0x8B88
+#define GL_SHADER_TYPE 0x8B4F
+#define GL_SHADING_LANGUAGE_VERSION 0x8B8C
+#define GL_SHORT 0x1402
+#define GL_SRC_ALPHA 0x0302
+#define GL_SRC_ALPHA_SATURATE 0x0308
+#define GL_SRC_COLOR 0x0300
+#define GL_STATIC_DRAW 0x88E4
+#define GL_STENCIL_ATTACHMENT 0x8D20
+#define GL_STENCIL_BACK_FAIL 0x8801
+#define GL_STENCIL_BACK_FUNC 0x8800
+#define GL_STENCIL_BACK_PASS_DEPTH_FAIL 0x8802
+#define GL_STENCIL_BACK_PASS_DEPTH_PASS 0x8803
+#define GL_STENCIL_BACK_REF 0x8CA3
+#define GL_STENCIL_BACK_VALUE_MASK 0x8CA4
+#define GL_STENCIL_BACK_WRITEMASK 0x8CA5
+#define GL_STENCIL_BITS 0x0D57
+#define GL_STENCIL_BUFFER_BIT 0x00000400
+#define GL_STENCIL_CLEAR_VALUE 0x0B91
+#define GL_STENCIL_FAIL 0x0B94
+#define GL_STENCIL_FUNC 0x0B92
+#define GL_STENCIL_INDEX8 0x8D48
+#define GL_STENCIL_PASS_DEPTH_FAIL 0x0B95
+#define GL_STENCIL_PASS_DEPTH_PASS 0x0B96
+#define GL_STENCIL_REF 0x0B97
+#define GL_STENCIL_TEST 0x0B90
+#define GL_STENCIL_VALUE_MASK 0x0B93
+#define GL_STENCIL_WRITEMASK 0x0B98
+#define GL_STREAM_DRAW 0x88E0
+#define GL_SUBPIXEL_BITS 0x0D50
+#define GL_TEXTURE 0x1702
+#define GL_TEXTURE0 0x84C0
+#define GL_TEXTURE1 0x84C1
+#define GL_TEXTURE10 0x84CA
+#define GL_TEXTURE11 0x84CB
+#define GL_TEXTURE12 0x84CC
+#define GL_TEXTURE13 0x84CD
+#define GL_TEXTURE14 0x84CE
+#define GL_TEXTURE15 0x84CF
+#define GL_TEXTURE16 0x84D0
+#define GL_TEXTURE17 0x84D1
+#define GL_TEXTURE18 0x84D2
+#define GL_TEXTURE19 0x84D3
+#define GL_TEXTURE2 0x84C2
+#define GL_TEXTURE20 0x84D4
+#define GL_TEXTURE21 0x84D5
+#define GL_TEXTURE22 0x84D6
+#define GL_TEXTURE23 0x84D7
+#define GL_TEXTURE24 0x84D8
+#define GL_TEXTURE25 0x84D9
+#define GL_TEXTURE26 0x84DA
+#define GL_TEXTURE27 0x84DB
+#define GL_TEXTURE28 0x84DC
+#define GL_TEXTURE29 0x84DD
+#define GL_TEXTURE3 0x84C3
+#define GL_TEXTURE30 0x84DE
+#define GL_TEXTURE31 0x84DF
+#define GL_TEXTURE4 0x84C4
+#define GL_TEXTURE5 0x84C5
+#define GL_TEXTURE6 0x84C6
+#define GL_TEXTURE7 0x84C7
+#define GL_TEXTURE8 0x84C8
+#define GL_TEXTURE9 0x84C9
+#define GL_TEXTURE_2D 0x0DE1
+#define GL_TEXTURE_BINDING_2D 0x8069
+#define GL_TEXTURE_BINDING_CUBE_MAP 0x8514
+#define GL_TEXTURE_CUBE_MAP 0x8513
+#define GL_TEXTURE_CUBE_MAP_NEGATIVE_X 0x8516
+#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y 0x8518
+#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z 0x851A
+#define GL_TEXTURE_CUBE_MAP_POSITIVE_X 0x8515
+#define GL_TEXTURE_CUBE_MAP_POSITIVE_Y 0x8517
+#define GL_TEXTURE_CUBE_MAP_POSITIVE_Z 0x8519
+#define GL_TEXTURE_MAG_FILTER 0x2800
+#define GL_TEXTURE_MIN_FILTER 0x2801
+#define GL_TEXTURE_WRAP_S 0x2802
+#define GL_TEXTURE_WRAP_T 0x2803
+#define GL_TRIANGLES 0x0004
+#define GL_TRIANGLE_FAN 0x0006
+#define GL_TRIANGLE_STRIP 0x0005
+#define GL_TRUE 1
+#define GL_UNPACK_ALIGNMENT 0x0CF5
+#define GL_UNSIGNED_BYTE 0x1401
+#define GL_UNSIGNED_INT 0x1405
+#define GL_UNSIGNED_SHORT 0x1403
+#define GL_UNSIGNED_SHORT_4_4_4_4 0x8033
+#define GL_UNSIGNED_SHORT_5_5_5_1 0x8034
+#define GL_UNSIGNED_SHORT_5_6_5 0x8363
+#define GL_VALIDATE_STATUS 0x8B83
+#define GL_VENDOR 0x1F00
+#define GL_VERSION 0x1F02
+#define GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING 0x889F
+#define GL_VERTEX_ATTRIB_ARRAY_ENABLED 0x8622
+#define GL_VERTEX_ATTRIB_ARRAY_NORMALIZED 0x886A
+#define GL_VERTEX_ATTRIB_ARRAY_POINTER 0x8645
+#define GL_VERTEX_ATTRIB_ARRAY_SIZE 0x8623
+#define GL_VERTEX_ATTRIB_ARRAY_STRIDE 0x8624
+#define GL_VERTEX_ATTRIB_ARRAY_TYPE 0x8625
+#define GL_VERTEX_SHADER 0x8B31
+#define GL_VIEWPORT 0x0BA2
+#define GL_ZERO 0
+
+
+#include <KHR/khrplatform.h>
+typedef unsigned int GLenum;
+typedef unsigned char GLboolean;
+typedef unsigned int GLbitfield;
+typedef void GLvoid;
+typedef khronos_int8_t GLbyte;
+typedef khronos_uint8_t GLubyte;
+typedef khronos_int16_t GLshort;
+typedef khronos_uint16_t GLushort;
+typedef int GLint;
+typedef unsigned int GLuint;
+typedef khronos_int32_t GLclampx;
+typedef int GLsizei;
+typedef khronos_float_t GLfloat;
+typedef khronos_float_t GLclampf;
+typedef double GLdouble;
+typedef double GLclampd;
+typedef void *GLeglClientBufferEXT;
+typedef void *GLeglImageOES;
+typedef char GLchar;
+typedef char GLcharARB;
+#ifdef __APPLE__
+typedef void *GLhandleARB;
+#else
+typedef unsigned int GLhandleARB;
+#endif
+typedef khronos_uint16_t GLhalf;
+typedef khronos_uint16_t GLhalfARB;
+typedef khronos_int32_t GLfixed;
+#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && (__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ > 1060)
+typedef khronos_intptr_t GLintptr;
+#else
+typedef khronos_intptr_t GLintptr;
+#endif
+#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && (__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ > 1060)
+typedef khronos_intptr_t GLintptrARB;
+#else
+typedef khronos_intptr_t GLintptrARB;
+#endif
+#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && (__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ > 1060)
+typedef khronos_ssize_t GLsizeiptr;
+#else
+typedef khronos_ssize_t GLsizeiptr;
+#endif
+#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && (__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ > 1060)
+typedef khronos_ssize_t GLsizeiptrARB;
+#else
+typedef khronos_ssize_t GLsizeiptrARB;
+#endif
+typedef khronos_int64_t GLint64;
+typedef khronos_int64_t GLint64EXT;
+typedef khronos_uint64_t GLuint64;
+typedef khronos_uint64_t GLuint64EXT;
+typedef struct __GLsync *GLsync;
+struct _cl_context;
+struct _cl_event;
+typedef void (GLAD_API_PTR *GLDEBUGPROC)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam);
+typedef void (GLAD_API_PTR *GLDEBUGPROCARB)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam);
+typedef void (GLAD_API_PTR *GLDEBUGPROCKHR)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam);
+typedef void (GLAD_API_PTR *GLDEBUGPROCAMD)(GLuint id,GLenum category,GLenum severity,GLsizei length,const GLchar *message,void *userParam);
+typedef unsigned short GLhalfNV;
+typedef GLintptr GLvdpauSurfaceNV;
+typedef void (GLAD_API_PTR *GLVULKANPROCNV)(void);
+
+
+#define GL_ES_VERSION_2_0 1
+#define GL_OES_rgb8_rgba8 1
+
+
+typedef void (GLAD_API_PTR *PFNGLACTIVETEXTUREPROC)(GLenum texture);
+typedef void (GLAD_API_PTR *PFNGLATTACHSHADERPROC)(GLuint program, GLuint shader);
+typedef void (GLAD_API_PTR *PFNGLBINDATTRIBLOCATIONPROC)(GLuint program, GLuint index, const GLchar * name);
+typedef void (GLAD_API_PTR *PFNGLBINDBUFFERPROC)(GLenum target, GLuint buffer);
+typedef void (GLAD_API_PTR *PFNGLBINDFRAMEBUFFERPROC)(GLenum target, GLuint framebuffer);
+typedef void (GLAD_API_PTR *PFNGLBINDRENDERBUFFERPROC)(GLenum target, GLuint renderbuffer);
+typedef void (GLAD_API_PTR *PFNGLBINDTEXTUREPROC)(GLenum target, GLuint texture);
+typedef void (GLAD_API_PTR *PFNGLBLENDCOLORPROC)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
+typedef void (GLAD_API_PTR *PFNGLBLENDEQUATIONPROC)(GLenum mode);
+typedef void (GLAD_API_PTR *PFNGLBLENDEQUATIONSEPARATEPROC)(GLenum modeRGB, GLenum modeAlpha);
+typedef void (GLAD_API_PTR *PFNGLBLENDFUNCPROC)(GLenum sfactor, GLenum dfactor);
+typedef void (GLAD_API_PTR *PFNGLBLENDFUNCSEPARATEPROC)(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
+typedef void (GLAD_API_PTR *PFNGLBUFFERDATAPROC)(GLenum target, GLsizeiptr size, const void * data, GLenum usage);
+typedef void (GLAD_API_PTR *PFNGLBUFFERSUBDATAPROC)(GLenum target, GLintptr offset, GLsizeiptr size, const void * data);
+typedef GLenum (GLAD_API_PTR *PFNGLCHECKFRAMEBUFFERSTATUSPROC)(GLenum target);
+typedef void (GLAD_API_PTR *PFNGLCLEARPROC)(GLbitfield mask);
+typedef void (GLAD_API_PTR *PFNGLCLEARCOLORPROC)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
+typedef void (GLAD_API_PTR *PFNGLCLEARDEPTHFPROC)(GLfloat d);
+typedef void (GLAD_API_PTR *PFNGLCLEARSTENCILPROC)(GLint s);
+typedef void (GLAD_API_PTR *PFNGLCOLORMASKPROC)(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
+typedef void (GLAD_API_PTR *PFNGLCOMPILESHADERPROC)(GLuint shader);
+typedef void (GLAD_API_PTR *PFNGLCOMPRESSEDTEXIMAGE2DPROC)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void * data);
+typedef void (GLAD_API_PTR *PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void * data);
+typedef void (GLAD_API_PTR *PFNGLCOPYTEXIMAGE2DPROC)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
+typedef void (GLAD_API_PTR *PFNGLCOPYTEXSUBIMAGE2DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
+typedef GLuint (GLAD_API_PTR *PFNGLCREATEPROGRAMPROC)(void);
+typedef GLuint (GLAD_API_PTR *PFNGLCREATESHADERPROC)(GLenum type);
+typedef void (GLAD_API_PTR *PFNGLCULLFACEPROC)(GLenum mode);
+typedef void (GLAD_API_PTR *PFNGLDELETEBUFFERSPROC)(GLsizei n, const GLuint * buffers);
+typedef void (GLAD_API_PTR *PFNGLDELETEFRAMEBUFFERSPROC)(GLsizei n, const GLuint * framebuffers);
+typedef void (GLAD_API_PTR *PFNGLDELETEPROGRAMPROC)(GLuint program);
+typedef void (GLAD_API_PTR *PFNGLDELETERENDERBUFFERSPROC)(GLsizei n, const GLuint * renderbuffers);
+typedef void (GLAD_API_PTR *PFNGLDELETESHADERPROC)(GLuint shader);
+typedef void (GLAD_API_PTR *PFNGLDELETETEXTURESPROC)(GLsizei n, const GLuint * textures);
+typedef void (GLAD_API_PTR *PFNGLDEPTHFUNCPROC)(GLenum func);
+typedef void (GLAD_API_PTR *PFNGLDEPTHMASKPROC)(GLboolean flag);
+typedef void (GLAD_API_PTR *PFNGLDEPTHRANGEFPROC)(GLfloat n, GLfloat f);
+typedef void (GLAD_API_PTR *PFNGLDETACHSHADERPROC)(GLuint program, GLuint shader);
+typedef void (GLAD_API_PTR *PFNGLDISABLEPROC)(GLenum cap);
+typedef void (GLAD_API_PTR *PFNGLDISABLEVERTEXATTRIBARRAYPROC)(GLuint index);
+typedef void (GLAD_API_PTR *PFNGLDRAWARRAYSPROC)(GLenum mode, GLint first, GLsizei count);
+typedef void (GLAD_API_PTR *PFNGLDRAWELEMENTSPROC)(GLenum mode, GLsizei count, GLenum type, const void * indices);
+typedef void (GLAD_API_PTR *PFNGLENABLEPROC)(GLenum cap);
+typedef void (GLAD_API_PTR *PFNGLENABLEVERTEXATTRIBARRAYPROC)(GLuint index);
+typedef void (GLAD_API_PTR *PFNGLFINISHPROC)(void);
+typedef void (GLAD_API_PTR *PFNGLFLUSHPROC)(void);
+typedef void (GLAD_API_PTR *PFNGLFRAMEBUFFERRENDERBUFFERPROC)(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
+typedef void (GLAD_API_PTR *PFNGLFRAMEBUFFERTEXTURE2DPROC)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
+typedef void (GLAD_API_PTR *PFNGLFRONTFACEPROC)(GLenum mode);
+typedef void (GLAD_API_PTR *PFNGLGENBUFFERSPROC)(GLsizei n, GLuint * buffers);
+typedef void (GLAD_API_PTR *PFNGLGENFRAMEBUFFERSPROC)(GLsizei n, GLuint * framebuffers);
+typedef void (GLAD_API_PTR *PFNGLGENRENDERBUFFERSPROC)(GLsizei n, GLuint * renderbuffers);
+typedef void (GLAD_API_PTR *PFNGLGENTEXTURESPROC)(GLsizei n, GLuint * textures);
+typedef void (GLAD_API_PTR *PFNGLGENERATEMIPMAPPROC)(GLenum target);
+typedef void (GLAD_API_PTR *PFNGLGETACTIVEATTRIBPROC)(GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLint * size, GLenum * type, GLchar * name);
+typedef void (GLAD_API_PTR *PFNGLGETACTIVEUNIFORMPROC)(GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLint * size, GLenum * type, GLchar * name);
+typedef void (GLAD_API_PTR *PFNGLGETATTACHEDSHADERSPROC)(GLuint program, GLsizei maxCount, GLsizei * count, GLuint * shaders);
+typedef GLint (GLAD_API_PTR *PFNGLGETATTRIBLOCATIONPROC)(GLuint program, const GLchar * name);
+typedef void (GLAD_API_PTR *PFNGLGETBOOLEANVPROC)(GLenum pname, GLboolean * data);
+typedef void (GLAD_API_PTR *PFNGLGETBUFFERPARAMETERIVPROC)(GLenum target, GLenum pname, GLint * params);
+typedef GLenum (GLAD_API_PTR *PFNGLGETERRORPROC)(void);
+typedef void (GLAD_API_PTR *PFNGLGETFLOATVPROC)(GLenum pname, GLfloat * data);
+typedef void (GLAD_API_PTR *PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC)(GLenum target, GLenum attachment, GLenum pname, GLint * params);
+typedef void (GLAD_API_PTR *PFNGLGETINTEGERVPROC)(GLenum pname, GLint * data);
+typedef void (GLAD_API_PTR *PFNGLGETPROGRAMINFOLOGPROC)(GLuint program, GLsizei bufSize, GLsizei * length, GLchar * infoLog);
+typedef void (GLAD_API_PTR *PFNGLGETPROGRAMIVPROC)(GLuint program, GLenum pname, GLint * params);
+typedef void (GLAD_API_PTR *PFNGLGETRENDERBUFFERPARAMETERIVPROC)(GLenum target, GLenum pname, GLint * params);
+typedef void (GLAD_API_PTR *PFNGLGETSHADERINFOLOGPROC)(GLuint shader, GLsizei bufSize, GLsizei * length, GLchar * infoLog);
+typedef void (GLAD_API_PTR *PFNGLGETSHADERPRECISIONFORMATPROC)(GLenum shadertype, GLenum precisiontype, GLint * range, GLint * precision);
+typedef void (GLAD_API_PTR *PFNGLGETSHADERSOURCEPROC)(GLuint shader, GLsizei bufSize, GLsizei * length, GLchar * source);
+typedef void (GLAD_API_PTR *PFNGLGETSHADERIVPROC)(GLuint shader, GLenum pname, GLint * params);
+typedef const GLubyte * (GLAD_API_PTR *PFNGLGETSTRINGPROC)(GLenum name);
+typedef void (GLAD_API_PTR *PFNGLGETTEXPARAMETERFVPROC)(GLenum target, GLenum pname, GLfloat * params);
+typedef void (GLAD_API_PTR *PFNGLGETTEXPARAMETERIVPROC)(GLenum target, GLenum pname, GLint * params);
+typedef GLint (GLAD_API_PTR *PFNGLGETUNIFORMLOCATIONPROC)(GLuint program, const GLchar * name);
+typedef void (GLAD_API_PTR *PFNGLGETUNIFORMFVPROC)(GLuint program, GLint location, GLfloat * params);
+typedef void (GLAD_API_PTR *PFNGLGETUNIFORMIVPROC)(GLuint program, GLint location, GLint * params);
+typedef void (GLAD_API_PTR *PFNGLGETVERTEXATTRIBPOINTERVPROC)(GLuint index, GLenum pname, void ** pointer);
+typedef void (GLAD_API_PTR *PFNGLGETVERTEXATTRIBFVPROC)(GLuint index, GLenum pname, GLfloat * params);
+typedef void (GLAD_API_PTR *PFNGLGETVERTEXATTRIBIVPROC)(GLuint index, GLenum pname, GLint * params);
+typedef void (GLAD_API_PTR *PFNGLHINTPROC)(GLenum target, GLenum mode);
+typedef GLboolean (GLAD_API_PTR *PFNGLISBUFFERPROC)(GLuint buffer);
+typedef GLboolean (GLAD_API_PTR *PFNGLISENABLEDPROC)(GLenum cap);
+typedef GLboolean (GLAD_API_PTR *PFNGLISFRAMEBUFFERPROC)(GLuint framebuffer);
+typedef GLboolean (GLAD_API_PTR *PFNGLISPROGRAMPROC)(GLuint program);
+typedef GLboolean (GLAD_API_PTR *PFNGLISRENDERBUFFERPROC)(GLuint renderbuffer);
+typedef GLboolean (GLAD_API_PTR *PFNGLISSHADERPROC)(GLuint shader);
+typedef GLboolean (GLAD_API_PTR *PFNGLISTEXTUREPROC)(GLuint texture);
+typedef void (GLAD_API_PTR *PFNGLLINEWIDTHPROC)(GLfloat width);
+typedef void (GLAD_API_PTR *PFNGLLINKPROGRAMPROC)(GLuint program);
+typedef void (GLAD_API_PTR *PFNGLPIXELSTOREIPROC)(GLenum pname, GLint param);
+typedef void (GLAD_API_PTR *PFNGLPOLYGONOFFSETPROC)(GLfloat factor, GLfloat units);
+typedef void (GLAD_API_PTR *PFNGLREADPIXELSPROC)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void * pixels);
+typedef void (GLAD_API_PTR *PFNGLRELEASESHADERCOMPILERPROC)(void);
+typedef void (GLAD_API_PTR *PFNGLRENDERBUFFERSTORAGEPROC)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
+typedef void (GLAD_API_PTR *PFNGLSAMPLECOVERAGEPROC)(GLfloat value, GLboolean invert);
+typedef void (GLAD_API_PTR *PFNGLSCISSORPROC)(GLint x, GLint y, GLsizei width, GLsizei height);
+typedef void (GLAD_API_PTR *PFNGLSHADERBINARYPROC)(GLsizei count, const GLuint * shaders, GLenum binaryFormat, const void * binary, GLsizei length);
+typedef void (GLAD_API_PTR *PFNGLSHADERSOURCEPROC)(GLuint shader, GLsizei count, const GLchar *const* string, const GLint * length);
+typedef void (GLAD_API_PTR *PFNGLSTENCILFUNCPROC)(GLenum func, GLint ref, GLuint mask);
+typedef void (GLAD_API_PTR *PFNGLSTENCILFUNCSEPARATEPROC)(GLenum face, GLenum func, GLint ref, GLuint mask);
+typedef void (GLAD_API_PTR *PFNGLSTENCILMASKPROC)(GLuint mask);
+typedef void (GLAD_API_PTR *PFNGLSTENCILMASKSEPARATEPROC)(GLenum face, GLuint mask);
+typedef void (GLAD_API_PTR *PFNGLSTENCILOPPROC)(GLenum fail, GLenum zfail, GLenum zpass);
+typedef void (GLAD_API_PTR *PFNGLSTENCILOPSEPARATEPROC)(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass);
+typedef void (GLAD_API_PTR *PFNGLTEXIMAGE2DPROC)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void * pixels);
+typedef void (GLAD_API_PTR *PFNGLTEXPARAMETERFPROC)(GLenum target, GLenum pname, GLfloat param);
+typedef void (GLAD_API_PTR *PFNGLTEXPARAMETERFVPROC)(GLenum target, GLenum pname, const GLfloat * params);
+typedef void (GLAD_API_PTR *PFNGLTEXPARAMETERIPROC)(GLenum target, GLenum pname, GLint param);
+typedef void (GLAD_API_PTR *PFNGLTEXPARAMETERIVPROC)(GLenum target, GLenum pname, const GLint * params);
+typedef void (GLAD_API_PTR *PFNGLTEXSUBIMAGE2DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void * pixels);
+typedef void (GLAD_API_PTR *PFNGLUNIFORM1FPROC)(GLint location, GLfloat v0);
+typedef void (GLAD_API_PTR *PFNGLUNIFORM1FVPROC)(GLint location, GLsizei count, const GLfloat * value);
+typedef void (GLAD_API_PTR *PFNGLUNIFORM1IPROC)(GLint location, GLint v0);
+typedef void (GLAD_API_PTR *PFNGLUNIFORM1IVPROC)(GLint location, GLsizei count, const GLint * value);
+typedef void (GLAD_API_PTR *PFNGLUNIFORM2FPROC)(GLint location, GLfloat v0, GLfloat v1);
+typedef void (GLAD_API_PTR *PFNGLUNIFORM2FVPROC)(GLint location, GLsizei count, const GLfloat * value);
+typedef void (GLAD_API_PTR *PFNGLUNIFORM2IPROC)(GLint location, GLint v0, GLint v1);
+typedef void (GLAD_API_PTR *PFNGLUNIFORM2IVPROC)(GLint location, GLsizei count, const GLint * value);
+typedef void (GLAD_API_PTR *PFNGLUNIFORM3FPROC)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
+typedef void (GLAD_API_PTR *PFNGLUNIFORM3FVPROC)(GLint location, GLsizei count, const GLfloat * value);
+typedef void (GLAD_API_PTR *PFNGLUNIFORM3IPROC)(GLint location, GLint v0, GLint v1, GLint v2);
+typedef void (GLAD_API_PTR *PFNGLUNIFORM3IVPROC)(GLint location, GLsizei count, const GLint * value);
+typedef void (GLAD_API_PTR *PFNGLUNIFORM4FPROC)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
+typedef void (GLAD_API_PTR *PFNGLUNIFORM4FVPROC)(GLint location, GLsizei count, const GLfloat * value);
+typedef void (GLAD_API_PTR *PFNGLUNIFORM4IPROC)(GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
+typedef void (GLAD_API_PTR *PFNGLUNIFORM4IVPROC)(GLint location, GLsizei count, const GLint * value);
+typedef void (GLAD_API_PTR *PFNGLUNIFORMMATRIX2FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value);
+typedef void (GLAD_API_PTR *PFNGLUNIFORMMATRIX3FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value);
+typedef void (GLAD_API_PTR *PFNGLUNIFORMMATRIX4FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value);
+typedef void (GLAD_API_PTR *PFNGLUSEPROGRAMPROC)(GLuint program);
+typedef void (GLAD_API_PTR *PFNGLVALIDATEPROGRAMPROC)(GLuint program);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB1FPROC)(GLuint index, GLfloat x);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB1FVPROC)(GLuint index, const GLfloat * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB2FPROC)(GLuint index, GLfloat x, GLfloat y);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB2FVPROC)(GLuint index, const GLfloat * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB3FPROC)(GLuint index, GLfloat x, GLfloat y, GLfloat z);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB3FVPROC)(GLuint index, const GLfloat * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4FPROC)(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4FVPROC)(GLuint index, const GLfloat * v);
+typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBPOINTERPROC)(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void * pointer);
+typedef void (GLAD_API_PTR *PFNGLVIEWPORTPROC)(GLint x, GLint y, GLsizei width, GLsizei height);
+
+typedef struct GladGLES2Context {
+    void* userptr;
+
+    int ES_VERSION_2_0;
+    int OES_rgb8_rgba8;
+
+    PFNGLACTIVETEXTUREPROC ActiveTexture;
+    PFNGLATTACHSHADERPROC AttachShader;
+    PFNGLBINDATTRIBLOCATIONPROC BindAttribLocation;
+    PFNGLBINDBUFFERPROC BindBuffer;
+    PFNGLBINDFRAMEBUFFERPROC BindFramebuffer;
+    PFNGLBINDRENDERBUFFERPROC BindRenderbuffer;
+    PFNGLBINDTEXTUREPROC BindTexture;
+    PFNGLBLENDCOLORPROC BlendColor;
+    PFNGLBLENDEQUATIONPROC BlendEquation;
+    PFNGLBLENDEQUATIONSEPARATEPROC BlendEquationSeparate;
+    PFNGLBLENDFUNCPROC BlendFunc;
+    PFNGLBLENDFUNCSEPARATEPROC BlendFuncSeparate;
+    PFNGLBUFFERDATAPROC BufferData;
+    PFNGLBUFFERSUBDATAPROC BufferSubData;
+    PFNGLCHECKFRAMEBUFFERSTATUSPROC CheckFramebufferStatus;
+    PFNGLCLEARPROC Clear;
+    PFNGLCLEARCOLORPROC ClearColor;
+    PFNGLCLEARDEPTHFPROC ClearDepthf;
+    PFNGLCLEARSTENCILPROC ClearStencil;
+    PFNGLCOLORMASKPROC ColorMask;
+    PFNGLCOMPILESHADERPROC CompileShader;
+    PFNGLCOMPRESSEDTEXIMAGE2DPROC CompressedTexImage2D;
+    PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC CompressedTexSubImage2D;
+    PFNGLCOPYTEXIMAGE2DPROC CopyTexImage2D;
+    PFNGLCOPYTEXSUBIMAGE2DPROC CopyTexSubImage2D;
+    PFNGLCREATEPROGRAMPROC CreateProgram;
+    PFNGLCREATESHADERPROC CreateShader;
+    PFNGLCULLFACEPROC CullFace;
+    PFNGLDELETEBUFFERSPROC DeleteBuffers;
+    PFNGLDELETEFRAMEBUFFERSPROC DeleteFramebuffers;
+    PFNGLDELETEPROGRAMPROC DeleteProgram;
+    PFNGLDELETERENDERBUFFERSPROC DeleteRenderbuffers;
+    PFNGLDELETESHADERPROC DeleteShader;
+    PFNGLDELETETEXTURESPROC DeleteTextures;
+    PFNGLDEPTHFUNCPROC DepthFunc;
+    PFNGLDEPTHMASKPROC DepthMask;
+    PFNGLDEPTHRANGEFPROC DepthRangef;
+    PFNGLDETACHSHADERPROC DetachShader;
+    PFNGLDISABLEPROC Disable;
+    PFNGLDISABLEVERTEXATTRIBARRAYPROC DisableVertexAttribArray;
+    PFNGLDRAWARRAYSPROC DrawArrays;
+    PFNGLDRAWELEMENTSPROC DrawElements;
+    PFNGLENABLEPROC Enable;
+    PFNGLENABLEVERTEXATTRIBARRAYPROC EnableVertexAttribArray;
+    PFNGLFINISHPROC Finish;
+    PFNGLFLUSHPROC Flush;
+    PFNGLFRAMEBUFFERRENDERBUFFERPROC FramebufferRenderbuffer;
+    PFNGLFRAMEBUFFERTEXTURE2DPROC FramebufferTexture2D;
+    PFNGLFRONTFACEPROC FrontFace;
+    PFNGLGENBUFFERSPROC GenBuffers;
+    PFNGLGENFRAMEBUFFERSPROC GenFramebuffers;
+    PFNGLGENRENDERBUFFERSPROC GenRenderbuffers;
+    PFNGLGENTEXTURESPROC GenTextures;
+    PFNGLGENERATEMIPMAPPROC GenerateMipmap;
+    PFNGLGETACTIVEATTRIBPROC GetActiveAttrib;
+    PFNGLGETACTIVEUNIFORMPROC GetActiveUniform;
+    PFNGLGETATTACHEDSHADERSPROC GetAttachedShaders;
+    PFNGLGETATTRIBLOCATIONPROC GetAttribLocation;
+    PFNGLGETBOOLEANVPROC GetBooleanv;
+    PFNGLGETBUFFERPARAMETERIVPROC GetBufferParameteriv;
+    PFNGLGETERRORPROC GetError;
+    PFNGLGETFLOATVPROC GetFloatv;
+    PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC GetFramebufferAttachmentParameteriv;
+    PFNGLGETINTEGERVPROC GetIntegerv;
+    PFNGLGETPROGRAMINFOLOGPROC GetProgramInfoLog;
+    PFNGLGETPROGRAMIVPROC GetProgramiv;
+    PFNGLGETRENDERBUFFERPARAMETERIVPROC GetRenderbufferParameteriv;
+    PFNGLGETSHADERINFOLOGPROC GetShaderInfoLog;
+    PFNGLGETSHADERPRECISIONFORMATPROC GetShaderPrecisionFormat;
+    PFNGLGETSHADERSOURCEPROC GetShaderSource;
+    PFNGLGETSHADERIVPROC GetShaderiv;
+    PFNGLGETSTRINGPROC GetString;
+    PFNGLGETTEXPARAMETERFVPROC GetTexParameterfv;
+    PFNGLGETTEXPARAMETERIVPROC GetTexParameteriv;
+    PFNGLGETUNIFORMLOCATIONPROC GetUniformLocation;
+    PFNGLGETUNIFORMFVPROC GetUniformfv;
+    PFNGLGETUNIFORMIVPROC GetUniformiv;
+    PFNGLGETVERTEXATTRIBPOINTERVPROC GetVertexAttribPointerv;
+    PFNGLGETVERTEXATTRIBFVPROC GetVertexAttribfv;
+    PFNGLGETVERTEXATTRIBIVPROC GetVertexAttribiv;
+    PFNGLHINTPROC Hint;
+    PFNGLISBUFFERPROC IsBuffer;
+    PFNGLISENABLEDPROC IsEnabled;
+    PFNGLISFRAMEBUFFERPROC IsFramebuffer;
+    PFNGLISPROGRAMPROC IsProgram;
+    PFNGLISRENDERBUFFERPROC IsRenderbuffer;
+    PFNGLISSHADERPROC IsShader;
+    PFNGLISTEXTUREPROC IsTexture;
+    PFNGLLINEWIDTHPROC LineWidth;
+    PFNGLLINKPROGRAMPROC LinkProgram;
+    PFNGLPIXELSTOREIPROC PixelStorei;
+    PFNGLPOLYGONOFFSETPROC PolygonOffset;
+    PFNGLREADPIXELSPROC ReadPixels;
+    PFNGLRELEASESHADERCOMPILERPROC ReleaseShaderCompiler;
+    PFNGLRENDERBUFFERSTORAGEPROC RenderbufferStorage;
+    PFNGLSAMPLECOVERAGEPROC SampleCoverage;
+    PFNGLSCISSORPROC Scissor;
+    PFNGLSHADERBINARYPROC ShaderBinary;
+    PFNGLSHADERSOURCEPROC ShaderSource;
+    PFNGLSTENCILFUNCPROC StencilFunc;
+    PFNGLSTENCILFUNCSEPARATEPROC StencilFuncSeparate;
+    PFNGLSTENCILMASKPROC StencilMask;
+    PFNGLSTENCILMASKSEPARATEPROC StencilMaskSeparate;
+    PFNGLSTENCILOPPROC StencilOp;
+    PFNGLSTENCILOPSEPARATEPROC StencilOpSeparate;
+    PFNGLTEXIMAGE2DPROC TexImage2D;
+    PFNGLTEXPARAMETERFPROC TexParameterf;
+    PFNGLTEXPARAMETERFVPROC TexParameterfv;
+    PFNGLTEXPARAMETERIPROC TexParameteri;
+    PFNGLTEXPARAMETERIVPROC TexParameteriv;
+    PFNGLTEXSUBIMAGE2DPROC TexSubImage2D;
+    PFNGLUNIFORM1FPROC Uniform1f;
+    PFNGLUNIFORM1FVPROC Uniform1fv;
+    PFNGLUNIFORM1IPROC Uniform1i;
+    PFNGLUNIFORM1IVPROC Uniform1iv;
+    PFNGLUNIFORM2FPROC Uniform2f;
+    PFNGLUNIFORM2FVPROC Uniform2fv;
+    PFNGLUNIFORM2IPROC Uniform2i;
+    PFNGLUNIFORM2IVPROC Uniform2iv;
+    PFNGLUNIFORM3FPROC Uniform3f;
+    PFNGLUNIFORM3FVPROC Uniform3fv;
+    PFNGLUNIFORM3IPROC Uniform3i;
+    PFNGLUNIFORM3IVPROC Uniform3iv;
+    PFNGLUNIFORM4FPROC Uniform4f;
+    PFNGLUNIFORM4FVPROC Uniform4fv;
+    PFNGLUNIFORM4IPROC Uniform4i;
+    PFNGLUNIFORM4IVPROC Uniform4iv;
+    PFNGLUNIFORMMATRIX2FVPROC UniformMatrix2fv;
+    PFNGLUNIFORMMATRIX3FVPROC UniformMatrix3fv;
+    PFNGLUNIFORMMATRIX4FVPROC UniformMatrix4fv;
+    PFNGLUSEPROGRAMPROC UseProgram;
+    PFNGLVALIDATEPROGRAMPROC ValidateProgram;
+    PFNGLVERTEXATTRIB1FPROC VertexAttrib1f;
+    PFNGLVERTEXATTRIB1FVPROC VertexAttrib1fv;
+    PFNGLVERTEXATTRIB2FPROC VertexAttrib2f;
+    PFNGLVERTEXATTRIB2FVPROC VertexAttrib2fv;
+    PFNGLVERTEXATTRIB3FPROC VertexAttrib3f;
+    PFNGLVERTEXATTRIB3FVPROC VertexAttrib3fv;
+    PFNGLVERTEXATTRIB4FPROC VertexAttrib4f;
+    PFNGLVERTEXATTRIB4FVPROC VertexAttrib4fv;
+    PFNGLVERTEXATTRIBPOINTERPROC VertexAttribPointer;
+    PFNGLVIEWPORTPROC Viewport;
+
+} GladGLES2Context;
+
+
+
+
+
+
+GLAD_API_CALL int gladLoadGLES2ContextUserPtr(GladGLES2Context *context, GLADuserptrloadfunc load, void *userptr);
+GLAD_API_CALL int gladLoadGLES2Context(GladGLES2Context *context, GLADloadfunc load);
+
+
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/thirdparty/glad/src/gl.c b/thirdparty/glad/src/gl.c
new file mode 100644
index 000000000..d97b1ded4
--- /dev/null
+++ b/thirdparty/glad/src/gl.c
@@ -0,0 +1,2274 @@
+/**
+ * SPDX-License-Identifier: (WTFPL OR CC0-1.0) AND Apache-2.0
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <glad/gl.h>
+
+#ifndef GLAD_IMPL_UTIL_C_
+#define GLAD_IMPL_UTIL_C_
+
+#ifdef _MSC_VER
+#define GLAD_IMPL_UTIL_SSCANF sscanf_s
+#else
+#define GLAD_IMPL_UTIL_SSCANF sscanf
+#endif
+
+#endif /* GLAD_IMPL_UTIL_C_ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+
+
+
+
+
+
+static void glad_gl_load_GL_VERSION_1_0(GladGLContext *context, GLADuserptrloadfunc load, void* userptr) {
+    if(!context->VERSION_1_0) return;
+    context->BlendFunc = (PFNGLBLENDFUNCPROC) load(userptr, "glBlendFunc");
+    context->Clear = (PFNGLCLEARPROC) load(userptr, "glClear");
+    context->ClearColor = (PFNGLCLEARCOLORPROC) load(userptr, "glClearColor");
+    context->ClearDepth = (PFNGLCLEARDEPTHPROC) load(userptr, "glClearDepth");
+    context->ClearStencil = (PFNGLCLEARSTENCILPROC) load(userptr, "glClearStencil");
+    context->ColorMask = (PFNGLCOLORMASKPROC) load(userptr, "glColorMask");
+    context->CullFace = (PFNGLCULLFACEPROC) load(userptr, "glCullFace");
+    context->DepthFunc = (PFNGLDEPTHFUNCPROC) load(userptr, "glDepthFunc");
+    context->DepthMask = (PFNGLDEPTHMASKPROC) load(userptr, "glDepthMask");
+    context->DepthRange = (PFNGLDEPTHRANGEPROC) load(userptr, "glDepthRange");
+    context->Disable = (PFNGLDISABLEPROC) load(userptr, "glDisable");
+    context->DrawBuffer = (PFNGLDRAWBUFFERPROC) load(userptr, "glDrawBuffer");
+    context->Enable = (PFNGLENABLEPROC) load(userptr, "glEnable");
+    context->Finish = (PFNGLFINISHPROC) load(userptr, "glFinish");
+    context->Flush = (PFNGLFLUSHPROC) load(userptr, "glFlush");
+    context->FrontFace = (PFNGLFRONTFACEPROC) load(userptr, "glFrontFace");
+    context->GetBooleanv = (PFNGLGETBOOLEANVPROC) load(userptr, "glGetBooleanv");
+    context->GetDoublev = (PFNGLGETDOUBLEVPROC) load(userptr, "glGetDoublev");
+    context->GetError = (PFNGLGETERRORPROC) load(userptr, "glGetError");
+    context->GetFloatv = (PFNGLGETFLOATVPROC) load(userptr, "glGetFloatv");
+    context->GetIntegerv = (PFNGLGETINTEGERVPROC) load(userptr, "glGetIntegerv");
+    context->GetString = (PFNGLGETSTRINGPROC) load(userptr, "glGetString");
+    context->GetTexImage = (PFNGLGETTEXIMAGEPROC) load(userptr, "glGetTexImage");
+    context->GetTexLevelParameterfv = (PFNGLGETTEXLEVELPARAMETERFVPROC) load(userptr, "glGetTexLevelParameterfv");
+    context->GetTexLevelParameteriv = (PFNGLGETTEXLEVELPARAMETERIVPROC) load(userptr, "glGetTexLevelParameteriv");
+    context->GetTexParameterfv = (PFNGLGETTEXPARAMETERFVPROC) load(userptr, "glGetTexParameterfv");
+    context->GetTexParameteriv = (PFNGLGETTEXPARAMETERIVPROC) load(userptr, "glGetTexParameteriv");
+    context->Hint = (PFNGLHINTPROC) load(userptr, "glHint");
+    context->IsEnabled = (PFNGLISENABLEDPROC) load(userptr, "glIsEnabled");
+    context->LineWidth = (PFNGLLINEWIDTHPROC) load(userptr, "glLineWidth");
+    context->LogicOp = (PFNGLLOGICOPPROC) load(userptr, "glLogicOp");
+    context->PixelStoref = (PFNGLPIXELSTOREFPROC) load(userptr, "glPixelStoref");
+    context->PixelStorei = (PFNGLPIXELSTOREIPROC) load(userptr, "glPixelStorei");
+    context->PointSize = (PFNGLPOINTSIZEPROC) load(userptr, "glPointSize");
+    context->PolygonMode = (PFNGLPOLYGONMODEPROC) load(userptr, "glPolygonMode");
+    context->ReadBuffer = (PFNGLREADBUFFERPROC) load(userptr, "glReadBuffer");
+    context->ReadPixels = (PFNGLREADPIXELSPROC) load(userptr, "glReadPixels");
+    context->Scissor = (PFNGLSCISSORPROC) load(userptr, "glScissor");
+    context->StencilFunc = (PFNGLSTENCILFUNCPROC) load(userptr, "glStencilFunc");
+    context->StencilMask = (PFNGLSTENCILMASKPROC) load(userptr, "glStencilMask");
+    context->StencilOp = (PFNGLSTENCILOPPROC) load(userptr, "glStencilOp");
+    context->TexImage1D = (PFNGLTEXIMAGE1DPROC) load(userptr, "glTexImage1D");
+    context->TexImage2D = (PFNGLTEXIMAGE2DPROC) load(userptr, "glTexImage2D");
+    context->TexParameterf = (PFNGLTEXPARAMETERFPROC) load(userptr, "glTexParameterf");
+    context->TexParameterfv = (PFNGLTEXPARAMETERFVPROC) load(userptr, "glTexParameterfv");
+    context->TexParameteri = (PFNGLTEXPARAMETERIPROC) load(userptr, "glTexParameteri");
+    context->TexParameteriv = (PFNGLTEXPARAMETERIVPROC) load(userptr, "glTexParameteriv");
+    context->Viewport = (PFNGLVIEWPORTPROC) load(userptr, "glViewport");
+}
+static void glad_gl_load_GL_VERSION_1_1(GladGLContext *context, GLADuserptrloadfunc load, void* userptr) {
+    if(!context->VERSION_1_1) return;
+    context->BindTexture = (PFNGLBINDTEXTUREPROC) load(userptr, "glBindTexture");
+    context->CopyTexImage1D = (PFNGLCOPYTEXIMAGE1DPROC) load(userptr, "glCopyTexImage1D");
+    context->CopyTexImage2D = (PFNGLCOPYTEXIMAGE2DPROC) load(userptr, "glCopyTexImage2D");
+    context->CopyTexSubImage1D = (PFNGLCOPYTEXSUBIMAGE1DPROC) load(userptr, "glCopyTexSubImage1D");
+    context->CopyTexSubImage2D = (PFNGLCOPYTEXSUBIMAGE2DPROC) load(userptr, "glCopyTexSubImage2D");
+    context->DeleteTextures = (PFNGLDELETETEXTURESPROC) load(userptr, "glDeleteTextures");
+    context->DrawArrays = (PFNGLDRAWARRAYSPROC) load(userptr, "glDrawArrays");
+    context->DrawElements = (PFNGLDRAWELEMENTSPROC) load(userptr, "glDrawElements");
+    context->GenTextures = (PFNGLGENTEXTURESPROC) load(userptr, "glGenTextures");
+    context->IsTexture = (PFNGLISTEXTUREPROC) load(userptr, "glIsTexture");
+    context->PolygonOffset = (PFNGLPOLYGONOFFSETPROC) load(userptr, "glPolygonOffset");
+    context->TexSubImage1D = (PFNGLTEXSUBIMAGE1DPROC) load(userptr, "glTexSubImage1D");
+    context->TexSubImage2D = (PFNGLTEXSUBIMAGE2DPROC) load(userptr, "glTexSubImage2D");
+}
+static void glad_gl_load_GL_VERSION_1_2(GladGLContext *context, GLADuserptrloadfunc load, void* userptr) {
+    if(!context->VERSION_1_2) return;
+    context->CopyTexSubImage3D = (PFNGLCOPYTEXSUBIMAGE3DPROC) load(userptr, "glCopyTexSubImage3D");
+    context->DrawRangeElements = (PFNGLDRAWRANGEELEMENTSPROC) load(userptr, "glDrawRangeElements");
+    context->TexImage3D = (PFNGLTEXIMAGE3DPROC) load(userptr, "glTexImage3D");
+    context->TexSubImage3D = (PFNGLTEXSUBIMAGE3DPROC) load(userptr, "glTexSubImage3D");
+}
+static void glad_gl_load_GL_VERSION_1_3(GladGLContext *context, GLADuserptrloadfunc load, void* userptr) {
+    if(!context->VERSION_1_3) return;
+    context->ActiveTexture = (PFNGLACTIVETEXTUREPROC) load(userptr, "glActiveTexture");
+    context->CompressedTexImage1D = (PFNGLCOMPRESSEDTEXIMAGE1DPROC) load(userptr, "glCompressedTexImage1D");
+    context->CompressedTexImage2D = (PFNGLCOMPRESSEDTEXIMAGE2DPROC) load(userptr, "glCompressedTexImage2D");
+    context->CompressedTexImage3D = (PFNGLCOMPRESSEDTEXIMAGE3DPROC) load(userptr, "glCompressedTexImage3D");
+    context->CompressedTexSubImage1D = (PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC) load(userptr, "glCompressedTexSubImage1D");
+    context->CompressedTexSubImage2D = (PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC) load(userptr, "glCompressedTexSubImage2D");
+    context->CompressedTexSubImage3D = (PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC) load(userptr, "glCompressedTexSubImage3D");
+    context->GetCompressedTexImage = (PFNGLGETCOMPRESSEDTEXIMAGEPROC) load(userptr, "glGetCompressedTexImage");
+    context->SampleCoverage = (PFNGLSAMPLECOVERAGEPROC) load(userptr, "glSampleCoverage");
+}
+static void glad_gl_load_GL_VERSION_1_4(GladGLContext *context, GLADuserptrloadfunc load, void* userptr) {
+    if(!context->VERSION_1_4) return;
+    context->BlendColor = (PFNGLBLENDCOLORPROC) load(userptr, "glBlendColor");
+    context->BlendEquation = (PFNGLBLENDEQUATIONPROC) load(userptr, "glBlendEquation");
+    context->BlendFuncSeparate = (PFNGLBLENDFUNCSEPARATEPROC) load(userptr, "glBlendFuncSeparate");
+    context->MultiDrawArrays = (PFNGLMULTIDRAWARRAYSPROC) load(userptr, "glMultiDrawArrays");
+    context->MultiDrawElements = (PFNGLMULTIDRAWELEMENTSPROC) load(userptr, "glMultiDrawElements");
+    context->PointParameterf = (PFNGLPOINTPARAMETERFPROC) load(userptr, "glPointParameterf");
+    context->PointParameterfv = (PFNGLPOINTPARAMETERFVPROC) load(userptr, "glPointParameterfv");
+    context->PointParameteri = (PFNGLPOINTPARAMETERIPROC) load(userptr, "glPointParameteri");
+    context->PointParameteriv = (PFNGLPOINTPARAMETERIVPROC) load(userptr, "glPointParameteriv");
+}
+static void glad_gl_load_GL_VERSION_1_5(GladGLContext *context, GLADuserptrloadfunc load, void* userptr) {
+    if(!context->VERSION_1_5) return;
+    context->BeginQuery = (PFNGLBEGINQUERYPROC) load(userptr, "glBeginQuery");
+    context->BindBuffer = (PFNGLBINDBUFFERPROC) load(userptr, "glBindBuffer");
+    context->BufferData = (PFNGLBUFFERDATAPROC) load(userptr, "glBufferData");
+    context->BufferSubData = (PFNGLBUFFERSUBDATAPROC) load(userptr, "glBufferSubData");
+    context->DeleteBuffers = (PFNGLDELETEBUFFERSPROC) load(userptr, "glDeleteBuffers");
+    context->DeleteQueries = (PFNGLDELETEQUERIESPROC) load(userptr, "glDeleteQueries");
+    context->EndQuery = (PFNGLENDQUERYPROC) load(userptr, "glEndQuery");
+    context->GenBuffers = (PFNGLGENBUFFERSPROC) load(userptr, "glGenBuffers");
+    context->GenQueries = (PFNGLGENQUERIESPROC) load(userptr, "glGenQueries");
+    context->GetBufferParameteriv = (PFNGLGETBUFFERPARAMETERIVPROC) load(userptr, "glGetBufferParameteriv");
+    context->GetBufferPointerv = (PFNGLGETBUFFERPOINTERVPROC) load(userptr, "glGetBufferPointerv");
+    context->GetBufferSubData = (PFNGLGETBUFFERSUBDATAPROC) load(userptr, "glGetBufferSubData");
+    context->GetQueryObjectiv = (PFNGLGETQUERYOBJECTIVPROC) load(userptr, "glGetQueryObjectiv");
+    context->GetQueryObjectuiv = (PFNGLGETQUERYOBJECTUIVPROC) load(userptr, "glGetQueryObjectuiv");
+    context->GetQueryiv = (PFNGLGETQUERYIVPROC) load(userptr, "glGetQueryiv");
+    context->IsBuffer = (PFNGLISBUFFERPROC) load(userptr, "glIsBuffer");
+    context->IsQuery = (PFNGLISQUERYPROC) load(userptr, "glIsQuery");
+    context->MapBuffer = (PFNGLMAPBUFFERPROC) load(userptr, "glMapBuffer");
+    context->UnmapBuffer = (PFNGLUNMAPBUFFERPROC) load(userptr, "glUnmapBuffer");
+}
+static void glad_gl_load_GL_VERSION_2_0(GladGLContext *context, GLADuserptrloadfunc load, void* userptr) {
+    if(!context->VERSION_2_0) return;
+    context->AttachShader = (PFNGLATTACHSHADERPROC) load(userptr, "glAttachShader");
+    context->BindAttribLocation = (PFNGLBINDATTRIBLOCATIONPROC) load(userptr, "glBindAttribLocation");
+    context->BlendEquationSeparate = (PFNGLBLENDEQUATIONSEPARATEPROC) load(userptr, "glBlendEquationSeparate");
+    context->CompileShader = (PFNGLCOMPILESHADERPROC) load(userptr, "glCompileShader");
+    context->CreateProgram = (PFNGLCREATEPROGRAMPROC) load(userptr, "glCreateProgram");
+    context->CreateShader = (PFNGLCREATESHADERPROC) load(userptr, "glCreateShader");
+    context->DeleteProgram = (PFNGLDELETEPROGRAMPROC) load(userptr, "glDeleteProgram");
+    context->DeleteShader = (PFNGLDELETESHADERPROC) load(userptr, "glDeleteShader");
+    context->DetachShader = (PFNGLDETACHSHADERPROC) load(userptr, "glDetachShader");
+    context->DisableVertexAttribArray = (PFNGLDISABLEVERTEXATTRIBARRAYPROC) load(userptr, "glDisableVertexAttribArray");
+    context->DrawBuffers = (PFNGLDRAWBUFFERSPROC) load(userptr, "glDrawBuffers");
+    context->EnableVertexAttribArray = (PFNGLENABLEVERTEXATTRIBARRAYPROC) load(userptr, "glEnableVertexAttribArray");
+    context->GetActiveAttrib = (PFNGLGETACTIVEATTRIBPROC) load(userptr, "glGetActiveAttrib");
+    context->GetActiveUniform = (PFNGLGETACTIVEUNIFORMPROC) load(userptr, "glGetActiveUniform");
+    context->GetAttachedShaders = (PFNGLGETATTACHEDSHADERSPROC) load(userptr, "glGetAttachedShaders");
+    context->GetAttribLocation = (PFNGLGETATTRIBLOCATIONPROC) load(userptr, "glGetAttribLocation");
+    context->GetProgramInfoLog = (PFNGLGETPROGRAMINFOLOGPROC) load(userptr, "glGetProgramInfoLog");
+    context->GetProgramiv = (PFNGLGETPROGRAMIVPROC) load(userptr, "glGetProgramiv");
+    context->GetShaderInfoLog = (PFNGLGETSHADERINFOLOGPROC) load(userptr, "glGetShaderInfoLog");
+    context->GetShaderSource = (PFNGLGETSHADERSOURCEPROC) load(userptr, "glGetShaderSource");
+    context->GetShaderiv = (PFNGLGETSHADERIVPROC) load(userptr, "glGetShaderiv");
+    context->GetUniformLocation = (PFNGLGETUNIFORMLOCATIONPROC) load(userptr, "glGetUniformLocation");
+    context->GetUniformfv = (PFNGLGETUNIFORMFVPROC) load(userptr, "glGetUniformfv");
+    context->GetUniformiv = (PFNGLGETUNIFORMIVPROC) load(userptr, "glGetUniformiv");
+    context->GetVertexAttribPointerv = (PFNGLGETVERTEXATTRIBPOINTERVPROC) load(userptr, "glGetVertexAttribPointerv");
+    context->GetVertexAttribdv = (PFNGLGETVERTEXATTRIBDVPROC) load(userptr, "glGetVertexAttribdv");
+    context->GetVertexAttribfv = (PFNGLGETVERTEXATTRIBFVPROC) load(userptr, "glGetVertexAttribfv");
+    context->GetVertexAttribiv = (PFNGLGETVERTEXATTRIBIVPROC) load(userptr, "glGetVertexAttribiv");
+    context->IsProgram = (PFNGLISPROGRAMPROC) load(userptr, "glIsProgram");
+    context->IsShader = (PFNGLISSHADERPROC) load(userptr, "glIsShader");
+    context->LinkProgram = (PFNGLLINKPROGRAMPROC) load(userptr, "glLinkProgram");
+    context->ShaderSource = (PFNGLSHADERSOURCEPROC) load(userptr, "glShaderSource");
+    context->StencilFuncSeparate = (PFNGLSTENCILFUNCSEPARATEPROC) load(userptr, "glStencilFuncSeparate");
+    context->StencilMaskSeparate = (PFNGLSTENCILMASKSEPARATEPROC) load(userptr, "glStencilMaskSeparate");
+    context->StencilOpSeparate = (PFNGLSTENCILOPSEPARATEPROC) load(userptr, "glStencilOpSeparate");
+    context->Uniform1f = (PFNGLUNIFORM1FPROC) load(userptr, "glUniform1f");
+    context->Uniform1fv = (PFNGLUNIFORM1FVPROC) load(userptr, "glUniform1fv");
+    context->Uniform1i = (PFNGLUNIFORM1IPROC) load(userptr, "glUniform1i");
+    context->Uniform1iv = (PFNGLUNIFORM1IVPROC) load(userptr, "glUniform1iv");
+    context->Uniform2f = (PFNGLUNIFORM2FPROC) load(userptr, "glUniform2f");
+    context->Uniform2fv = (PFNGLUNIFORM2FVPROC) load(userptr, "glUniform2fv");
+    context->Uniform2i = (PFNGLUNIFORM2IPROC) load(userptr, "glUniform2i");
+    context->Uniform2iv = (PFNGLUNIFORM2IVPROC) load(userptr, "glUniform2iv");
+    context->Uniform3f = (PFNGLUNIFORM3FPROC) load(userptr, "glUniform3f");
+    context->Uniform3fv = (PFNGLUNIFORM3FVPROC) load(userptr, "glUniform3fv");
+    context->Uniform3i = (PFNGLUNIFORM3IPROC) load(userptr, "glUniform3i");
+    context->Uniform3iv = (PFNGLUNIFORM3IVPROC) load(userptr, "glUniform3iv");
+    context->Uniform4f = (PFNGLUNIFORM4FPROC) load(userptr, "glUniform4f");
+    context->Uniform4fv = (PFNGLUNIFORM4FVPROC) load(userptr, "glUniform4fv");
+    context->Uniform4i = (PFNGLUNIFORM4IPROC) load(userptr, "glUniform4i");
+    context->Uniform4iv = (PFNGLUNIFORM4IVPROC) load(userptr, "glUniform4iv");
+    context->UniformMatrix2fv = (PFNGLUNIFORMMATRIX2FVPROC) load(userptr, "glUniformMatrix2fv");
+    context->UniformMatrix3fv = (PFNGLUNIFORMMATRIX3FVPROC) load(userptr, "glUniformMatrix3fv");
+    context->UniformMatrix4fv = (PFNGLUNIFORMMATRIX4FVPROC) load(userptr, "glUniformMatrix4fv");
+    context->UseProgram = (PFNGLUSEPROGRAMPROC) load(userptr, "glUseProgram");
+    context->ValidateProgram = (PFNGLVALIDATEPROGRAMPROC) load(userptr, "glValidateProgram");
+    context->VertexAttrib1d = (PFNGLVERTEXATTRIB1DPROC) load(userptr, "glVertexAttrib1d");
+    context->VertexAttrib1dv = (PFNGLVERTEXATTRIB1DVPROC) load(userptr, "glVertexAttrib1dv");
+    context->VertexAttrib1f = (PFNGLVERTEXATTRIB1FPROC) load(userptr, "glVertexAttrib1f");
+    context->VertexAttrib1fv = (PFNGLVERTEXATTRIB1FVPROC) load(userptr, "glVertexAttrib1fv");
+    context->VertexAttrib1s = (PFNGLVERTEXATTRIB1SPROC) load(userptr, "glVertexAttrib1s");
+    context->VertexAttrib1sv = (PFNGLVERTEXATTRIB1SVPROC) load(userptr, "glVertexAttrib1sv");
+    context->VertexAttrib2d = (PFNGLVERTEXATTRIB2DPROC) load(userptr, "glVertexAttrib2d");
+    context->VertexAttrib2dv = (PFNGLVERTEXATTRIB2DVPROC) load(userptr, "glVertexAttrib2dv");
+    context->VertexAttrib2f = (PFNGLVERTEXATTRIB2FPROC) load(userptr, "glVertexAttrib2f");
+    context->VertexAttrib2fv = (PFNGLVERTEXATTRIB2FVPROC) load(userptr, "glVertexAttrib2fv");
+    context->VertexAttrib2s = (PFNGLVERTEXATTRIB2SPROC) load(userptr, "glVertexAttrib2s");
+    context->VertexAttrib2sv = (PFNGLVERTEXATTRIB2SVPROC) load(userptr, "glVertexAttrib2sv");
+    context->VertexAttrib3d = (PFNGLVERTEXATTRIB3DPROC) load(userptr, "glVertexAttrib3d");
+    context->VertexAttrib3dv = (PFNGLVERTEXATTRIB3DVPROC) load(userptr, "glVertexAttrib3dv");
+    context->VertexAttrib3f = (PFNGLVERTEXATTRIB3FPROC) load(userptr, "glVertexAttrib3f");
+    context->VertexAttrib3fv = (PFNGLVERTEXATTRIB3FVPROC) load(userptr, "glVertexAttrib3fv");
+    context->VertexAttrib3s = (PFNGLVERTEXATTRIB3SPROC) load(userptr, "glVertexAttrib3s");
+    context->VertexAttrib3sv = (PFNGLVERTEXATTRIB3SVPROC) load(userptr, "glVertexAttrib3sv");
+    context->VertexAttrib4Nbv = (PFNGLVERTEXATTRIB4NBVPROC) load(userptr, "glVertexAttrib4Nbv");
+    context->VertexAttrib4Niv = (PFNGLVERTEXATTRIB4NIVPROC) load(userptr, "glVertexAttrib4Niv");
+    context->VertexAttrib4Nsv = (PFNGLVERTEXATTRIB4NSVPROC) load(userptr, "glVertexAttrib4Nsv");
+    context->VertexAttrib4Nub = (PFNGLVERTEXATTRIB4NUBPROC) load(userptr, "glVertexAttrib4Nub");
+    context->VertexAttrib4Nubv = (PFNGLVERTEXATTRIB4NUBVPROC) load(userptr, "glVertexAttrib4Nubv");
+    context->VertexAttrib4Nuiv = (PFNGLVERTEXATTRIB4NUIVPROC) load(userptr, "glVertexAttrib4Nuiv");
+    context->VertexAttrib4Nusv = (PFNGLVERTEXATTRIB4NUSVPROC) load(userptr, "glVertexAttrib4Nusv");
+    context->VertexAttrib4bv = (PFNGLVERTEXATTRIB4BVPROC) load(userptr, "glVertexAttrib4bv");
+    context->VertexAttrib4d = (PFNGLVERTEXATTRIB4DPROC) load(userptr, "glVertexAttrib4d");
+    context->VertexAttrib4dv = (PFNGLVERTEXATTRIB4DVPROC) load(userptr, "glVertexAttrib4dv");
+    context->VertexAttrib4f = (PFNGLVERTEXATTRIB4FPROC) load(userptr, "glVertexAttrib4f");
+    context->VertexAttrib4fv = (PFNGLVERTEXATTRIB4FVPROC) load(userptr, "glVertexAttrib4fv");
+    context->VertexAttrib4iv = (PFNGLVERTEXATTRIB4IVPROC) load(userptr, "glVertexAttrib4iv");
+    context->VertexAttrib4s = (PFNGLVERTEXATTRIB4SPROC) load(userptr, "glVertexAttrib4s");
+    context->VertexAttrib4sv = (PFNGLVERTEXATTRIB4SVPROC) load(userptr, "glVertexAttrib4sv");
+    context->VertexAttrib4ubv = (PFNGLVERTEXATTRIB4UBVPROC) load(userptr, "glVertexAttrib4ubv");
+    context->VertexAttrib4uiv = (PFNGLVERTEXATTRIB4UIVPROC) load(userptr, "glVertexAttrib4uiv");
+    context->VertexAttrib4usv = (PFNGLVERTEXATTRIB4USVPROC) load(userptr, "glVertexAttrib4usv");
+    context->VertexAttribPointer = (PFNGLVERTEXATTRIBPOINTERPROC) load(userptr, "glVertexAttribPointer");
+}
+static void glad_gl_load_GL_VERSION_2_1(GladGLContext *context, GLADuserptrloadfunc load, void* userptr) {
+    if(!context->VERSION_2_1) return;
+    context->UniformMatrix2x3fv = (PFNGLUNIFORMMATRIX2X3FVPROC) load(userptr, "glUniformMatrix2x3fv");
+    context->UniformMatrix2x4fv = (PFNGLUNIFORMMATRIX2X4FVPROC) load(userptr, "glUniformMatrix2x4fv");
+    context->UniformMatrix3x2fv = (PFNGLUNIFORMMATRIX3X2FVPROC) load(userptr, "glUniformMatrix3x2fv");
+    context->UniformMatrix3x4fv = (PFNGLUNIFORMMATRIX3X4FVPROC) load(userptr, "glUniformMatrix3x4fv");
+    context->UniformMatrix4x2fv = (PFNGLUNIFORMMATRIX4X2FVPROC) load(userptr, "glUniformMatrix4x2fv");
+    context->UniformMatrix4x3fv = (PFNGLUNIFORMMATRIX4X3FVPROC) load(userptr, "glUniformMatrix4x3fv");
+}
+static void glad_gl_load_GL_VERSION_3_0(GladGLContext *context, GLADuserptrloadfunc load, void* userptr) {
+    if(!context->VERSION_3_0) return;
+    context->BeginConditionalRender = (PFNGLBEGINCONDITIONALRENDERPROC) load(userptr, "glBeginConditionalRender");
+    context->BeginTransformFeedback = (PFNGLBEGINTRANSFORMFEEDBACKPROC) load(userptr, "glBeginTransformFeedback");
+    context->BindBufferBase = (PFNGLBINDBUFFERBASEPROC) load(userptr, "glBindBufferBase");
+    context->BindBufferRange = (PFNGLBINDBUFFERRANGEPROC) load(userptr, "glBindBufferRange");
+    context->BindFragDataLocation = (PFNGLBINDFRAGDATALOCATIONPROC) load(userptr, "glBindFragDataLocation");
+    context->BindFramebuffer = (PFNGLBINDFRAMEBUFFERPROC) load(userptr, "glBindFramebuffer");
+    context->BindRenderbuffer = (PFNGLBINDRENDERBUFFERPROC) load(userptr, "glBindRenderbuffer");
+    context->BindVertexArray = (PFNGLBINDVERTEXARRAYPROC) load(userptr, "glBindVertexArray");
+    context->BlitFramebuffer = (PFNGLBLITFRAMEBUFFERPROC) load(userptr, "glBlitFramebuffer");
+    context->CheckFramebufferStatus = (PFNGLCHECKFRAMEBUFFERSTATUSPROC) load(userptr, "glCheckFramebufferStatus");
+    context->ClampColor = (PFNGLCLAMPCOLORPROC) load(userptr, "glClampColor");
+    context->ClearBufferfi = (PFNGLCLEARBUFFERFIPROC) load(userptr, "glClearBufferfi");
+    context->ClearBufferfv = (PFNGLCLEARBUFFERFVPROC) load(userptr, "glClearBufferfv");
+    context->ClearBufferiv = (PFNGLCLEARBUFFERIVPROC) load(userptr, "glClearBufferiv");
+    context->ClearBufferuiv = (PFNGLCLEARBUFFERUIVPROC) load(userptr, "glClearBufferuiv");
+    context->ColorMaski = (PFNGLCOLORMASKIPROC) load(userptr, "glColorMaski");
+    context->DeleteFramebuffers = (PFNGLDELETEFRAMEBUFFERSPROC) load(userptr, "glDeleteFramebuffers");
+    context->DeleteRenderbuffers = (PFNGLDELETERENDERBUFFERSPROC) load(userptr, "glDeleteRenderbuffers");
+    context->DeleteVertexArrays = (PFNGLDELETEVERTEXARRAYSPROC) load(userptr, "glDeleteVertexArrays");
+    context->Disablei = (PFNGLDISABLEIPROC) load(userptr, "glDisablei");
+    context->Enablei = (PFNGLENABLEIPROC) load(userptr, "glEnablei");
+    context->EndConditionalRender = (PFNGLENDCONDITIONALRENDERPROC) load(userptr, "glEndConditionalRender");
+    context->EndTransformFeedback = (PFNGLENDTRANSFORMFEEDBACKPROC) load(userptr, "glEndTransformFeedback");
+    context->FlushMappedBufferRange = (PFNGLFLUSHMAPPEDBUFFERRANGEPROC) load(userptr, "glFlushMappedBufferRange");
+    context->FramebufferRenderbuffer = (PFNGLFRAMEBUFFERRENDERBUFFERPROC) load(userptr, "glFramebufferRenderbuffer");
+    context->FramebufferTexture1D = (PFNGLFRAMEBUFFERTEXTURE1DPROC) load(userptr, "glFramebufferTexture1D");
+    context->FramebufferTexture2D = (PFNGLFRAMEBUFFERTEXTURE2DPROC) load(userptr, "glFramebufferTexture2D");
+    context->FramebufferTexture3D = (PFNGLFRAMEBUFFERTEXTURE3DPROC) load(userptr, "glFramebufferTexture3D");
+    context->FramebufferTextureLayer = (PFNGLFRAMEBUFFERTEXTURELAYERPROC) load(userptr, "glFramebufferTextureLayer");
+    context->GenFramebuffers = (PFNGLGENFRAMEBUFFERSPROC) load(userptr, "glGenFramebuffers");
+    context->GenRenderbuffers = (PFNGLGENRENDERBUFFERSPROC) load(userptr, "glGenRenderbuffers");
+    context->GenVertexArrays = (PFNGLGENVERTEXARRAYSPROC) load(userptr, "glGenVertexArrays");
+    context->GenerateMipmap = (PFNGLGENERATEMIPMAPPROC) load(userptr, "glGenerateMipmap");
+    context->GetBooleani_v = (PFNGLGETBOOLEANI_VPROC) load(userptr, "glGetBooleani_v");
+    context->GetFragDataLocation = (PFNGLGETFRAGDATALOCATIONPROC) load(userptr, "glGetFragDataLocation");
+    context->GetFramebufferAttachmentParameteriv = (PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC) load(userptr, "glGetFramebufferAttachmentParameteriv");
+    context->GetIntegeri_v = (PFNGLGETINTEGERI_VPROC) load(userptr, "glGetIntegeri_v");
+    context->GetRenderbufferParameteriv = (PFNGLGETRENDERBUFFERPARAMETERIVPROC) load(userptr, "glGetRenderbufferParameteriv");
+    context->GetStringi = (PFNGLGETSTRINGIPROC) load(userptr, "glGetStringi");
+    context->GetTexParameterIiv = (PFNGLGETTEXPARAMETERIIVPROC) load(userptr, "glGetTexParameterIiv");
+    context->GetTexParameterIuiv = (PFNGLGETTEXPARAMETERIUIVPROC) load(userptr, "glGetTexParameterIuiv");
+    context->GetTransformFeedbackVarying = (PFNGLGETTRANSFORMFEEDBACKVARYINGPROC) load(userptr, "glGetTransformFeedbackVarying");
+    context->GetUniformuiv = (PFNGLGETUNIFORMUIVPROC) load(userptr, "glGetUniformuiv");
+    context->GetVertexAttribIiv = (PFNGLGETVERTEXATTRIBIIVPROC) load(userptr, "glGetVertexAttribIiv");
+    context->GetVertexAttribIuiv = (PFNGLGETVERTEXATTRIBIUIVPROC) load(userptr, "glGetVertexAttribIuiv");
+    context->IsEnabledi = (PFNGLISENABLEDIPROC) load(userptr, "glIsEnabledi");
+    context->IsFramebuffer = (PFNGLISFRAMEBUFFERPROC) load(userptr, "glIsFramebuffer");
+    context->IsRenderbuffer = (PFNGLISRENDERBUFFERPROC) load(userptr, "glIsRenderbuffer");
+    context->IsVertexArray = (PFNGLISVERTEXARRAYPROC) load(userptr, "glIsVertexArray");
+    context->MapBufferRange = (PFNGLMAPBUFFERRANGEPROC) load(userptr, "glMapBufferRange");
+    context->RenderbufferStorage = (PFNGLRENDERBUFFERSTORAGEPROC) load(userptr, "glRenderbufferStorage");
+    context->RenderbufferStorageMultisample = (PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC) load(userptr, "glRenderbufferStorageMultisample");
+    context->TexParameterIiv = (PFNGLTEXPARAMETERIIVPROC) load(userptr, "glTexParameterIiv");
+    context->TexParameterIuiv = (PFNGLTEXPARAMETERIUIVPROC) load(userptr, "glTexParameterIuiv");
+    context->TransformFeedbackVaryings = (PFNGLTRANSFORMFEEDBACKVARYINGSPROC) load(userptr, "glTransformFeedbackVaryings");
+    context->Uniform1ui = (PFNGLUNIFORM1UIPROC) load(userptr, "glUniform1ui");
+    context->Uniform1uiv = (PFNGLUNIFORM1UIVPROC) load(userptr, "glUniform1uiv");
+    context->Uniform2ui = (PFNGLUNIFORM2UIPROC) load(userptr, "glUniform2ui");
+    context->Uniform2uiv = (PFNGLUNIFORM2UIVPROC) load(userptr, "glUniform2uiv");
+    context->Uniform3ui = (PFNGLUNIFORM3UIPROC) load(userptr, "glUniform3ui");
+    context->Uniform3uiv = (PFNGLUNIFORM3UIVPROC) load(userptr, "glUniform3uiv");
+    context->Uniform4ui = (PFNGLUNIFORM4UIPROC) load(userptr, "glUniform4ui");
+    context->Uniform4uiv = (PFNGLUNIFORM4UIVPROC) load(userptr, "glUniform4uiv");
+    context->VertexAttribI1i = (PFNGLVERTEXATTRIBI1IPROC) load(userptr, "glVertexAttribI1i");
+    context->VertexAttribI1iv = (PFNGLVERTEXATTRIBI1IVPROC) load(userptr, "glVertexAttribI1iv");
+    context->VertexAttribI1ui = (PFNGLVERTEXATTRIBI1UIPROC) load(userptr, "glVertexAttribI1ui");
+    context->VertexAttribI1uiv = (PFNGLVERTEXATTRIBI1UIVPROC) load(userptr, "glVertexAttribI1uiv");
+    context->VertexAttribI2i = (PFNGLVERTEXATTRIBI2IPROC) load(userptr, "glVertexAttribI2i");
+    context->VertexAttribI2iv = (PFNGLVERTEXATTRIBI2IVPROC) load(userptr, "glVertexAttribI2iv");
+    context->VertexAttribI2ui = (PFNGLVERTEXATTRIBI2UIPROC) load(userptr, "glVertexAttribI2ui");
+    context->VertexAttribI2uiv = (PFNGLVERTEXATTRIBI2UIVPROC) load(userptr, "glVertexAttribI2uiv");
+    context->VertexAttribI3i = (PFNGLVERTEXATTRIBI3IPROC) load(userptr, "glVertexAttribI3i");
+    context->VertexAttribI3iv = (PFNGLVERTEXATTRIBI3IVPROC) load(userptr, "glVertexAttribI3iv");
+    context->VertexAttribI3ui = (PFNGLVERTEXATTRIBI3UIPROC) load(userptr, "glVertexAttribI3ui");
+    context->VertexAttribI3uiv = (PFNGLVERTEXATTRIBI3UIVPROC) load(userptr, "glVertexAttribI3uiv");
+    context->VertexAttribI4bv = (PFNGLVERTEXATTRIBI4BVPROC) load(userptr, "glVertexAttribI4bv");
+    context->VertexAttribI4i = (PFNGLVERTEXATTRIBI4IPROC) load(userptr, "glVertexAttribI4i");
+    context->VertexAttribI4iv = (PFNGLVERTEXATTRIBI4IVPROC) load(userptr, "glVertexAttribI4iv");
+    context->VertexAttribI4sv = (PFNGLVERTEXATTRIBI4SVPROC) load(userptr, "glVertexAttribI4sv");
+    context->VertexAttribI4ubv = (PFNGLVERTEXATTRIBI4UBVPROC) load(userptr, "glVertexAttribI4ubv");
+    context->VertexAttribI4ui = (PFNGLVERTEXATTRIBI4UIPROC) load(userptr, "glVertexAttribI4ui");
+    context->VertexAttribI4uiv = (PFNGLVERTEXATTRIBI4UIVPROC) load(userptr, "glVertexAttribI4uiv");
+    context->VertexAttribI4usv = (PFNGLVERTEXATTRIBI4USVPROC) load(userptr, "glVertexAttribI4usv");
+    context->VertexAttribIPointer = (PFNGLVERTEXATTRIBIPOINTERPROC) load(userptr, "glVertexAttribIPointer");
+}
+static void glad_gl_load_GL_VERSION_3_1(GladGLContext *context, GLADuserptrloadfunc load, void* userptr) {
+    if(!context->VERSION_3_1) return;
+    context->BindBufferBase = (PFNGLBINDBUFFERBASEPROC) load(userptr, "glBindBufferBase");
+    context->BindBufferRange = (PFNGLBINDBUFFERRANGEPROC) load(userptr, "glBindBufferRange");
+    context->CopyBufferSubData = (PFNGLCOPYBUFFERSUBDATAPROC) load(userptr, "glCopyBufferSubData");
+    context->DrawArraysInstanced = (PFNGLDRAWARRAYSINSTANCEDPROC) load(userptr, "glDrawArraysInstanced");
+    context->DrawElementsInstanced = (PFNGLDRAWELEMENTSINSTANCEDPROC) load(userptr, "glDrawElementsInstanced");
+    context->GetActiveUniformBlockName = (PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC) load(userptr, "glGetActiveUniformBlockName");
+    context->GetActiveUniformBlockiv = (PFNGLGETACTIVEUNIFORMBLOCKIVPROC) load(userptr, "glGetActiveUniformBlockiv");
+    context->GetActiveUniformName = (PFNGLGETACTIVEUNIFORMNAMEPROC) load(userptr, "glGetActiveUniformName");
+    context->GetActiveUniformsiv = (PFNGLGETACTIVEUNIFORMSIVPROC) load(userptr, "glGetActiveUniformsiv");
+    context->GetIntegeri_v = (PFNGLGETINTEGERI_VPROC) load(userptr, "glGetIntegeri_v");
+    context->GetUniformBlockIndex = (PFNGLGETUNIFORMBLOCKINDEXPROC) load(userptr, "glGetUniformBlockIndex");
+    context->GetUniformIndices = (PFNGLGETUNIFORMINDICESPROC) load(userptr, "glGetUniformIndices");
+    context->PrimitiveRestartIndex = (PFNGLPRIMITIVERESTARTINDEXPROC) load(userptr, "glPrimitiveRestartIndex");
+    context->TexBuffer = (PFNGLTEXBUFFERPROC) load(userptr, "glTexBuffer");
+    context->UniformBlockBinding = (PFNGLUNIFORMBLOCKBINDINGPROC) load(userptr, "glUniformBlockBinding");
+}
+static void glad_gl_load_GL_VERSION_3_2(GladGLContext *context, GLADuserptrloadfunc load, void* userptr) {
+    if(!context->VERSION_3_2) return;
+    context->ClientWaitSync = (PFNGLCLIENTWAITSYNCPROC) load(userptr, "glClientWaitSync");
+    context->DeleteSync = (PFNGLDELETESYNCPROC) load(userptr, "glDeleteSync");
+    context->DrawElementsBaseVertex = (PFNGLDRAWELEMENTSBASEVERTEXPROC) load(userptr, "glDrawElementsBaseVertex");
+    context->DrawElementsInstancedBaseVertex = (PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC) load(userptr, "glDrawElementsInstancedBaseVertex");
+    context->DrawRangeElementsBaseVertex = (PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC) load(userptr, "glDrawRangeElementsBaseVertex");
+    context->FenceSync = (PFNGLFENCESYNCPROC) load(userptr, "glFenceSync");
+    context->FramebufferTexture = (PFNGLFRAMEBUFFERTEXTUREPROC) load(userptr, "glFramebufferTexture");
+    context->GetBufferParameteri64v = (PFNGLGETBUFFERPARAMETERI64VPROC) load(userptr, "glGetBufferParameteri64v");
+    context->GetInteger64i_v = (PFNGLGETINTEGER64I_VPROC) load(userptr, "glGetInteger64i_v");
+    context->GetInteger64v = (PFNGLGETINTEGER64VPROC) load(userptr, "glGetInteger64v");
+    context->GetMultisamplefv = (PFNGLGETMULTISAMPLEFVPROC) load(userptr, "glGetMultisamplefv");
+    context->GetSynciv = (PFNGLGETSYNCIVPROC) load(userptr, "glGetSynciv");
+    context->IsSync = (PFNGLISSYNCPROC) load(userptr, "glIsSync");
+    context->MultiDrawElementsBaseVertex = (PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC) load(userptr, "glMultiDrawElementsBaseVertex");
+    context->ProvokingVertex = (PFNGLPROVOKINGVERTEXPROC) load(userptr, "glProvokingVertex");
+    context->SampleMaski = (PFNGLSAMPLEMASKIPROC) load(userptr, "glSampleMaski");
+    context->TexImage2DMultisample = (PFNGLTEXIMAGE2DMULTISAMPLEPROC) load(userptr, "glTexImage2DMultisample");
+    context->TexImage3DMultisample = (PFNGLTEXIMAGE3DMULTISAMPLEPROC) load(userptr, "glTexImage3DMultisample");
+    context->WaitSync = (PFNGLWAITSYNCPROC) load(userptr, "glWaitSync");
+}
+static void glad_gl_load_GL_APPLE_flush_buffer_range(GladGLContext *context, GLADuserptrloadfunc load, void* userptr) {
+    if(!context->APPLE_flush_buffer_range) return;
+    context->BufferParameteriAPPLE = (PFNGLBUFFERPARAMETERIAPPLEPROC) load(userptr, "glBufferParameteriAPPLE");
+    context->FlushMappedBufferRangeAPPLE = (PFNGLFLUSHMAPPEDBUFFERRANGEAPPLEPROC) load(userptr, "glFlushMappedBufferRangeAPPLE");
+}
+static void glad_gl_load_GL_APPLE_vertex_array_object(GladGLContext *context, GLADuserptrloadfunc load, void* userptr) {
+    if(!context->APPLE_vertex_array_object) return;
+    context->BindVertexArrayAPPLE = (PFNGLBINDVERTEXARRAYAPPLEPROC) load(userptr, "glBindVertexArrayAPPLE");
+    context->DeleteVertexArraysAPPLE = (PFNGLDELETEVERTEXARRAYSAPPLEPROC) load(userptr, "glDeleteVertexArraysAPPLE");
+    context->GenVertexArraysAPPLE = (PFNGLGENVERTEXARRAYSAPPLEPROC) load(userptr, "glGenVertexArraysAPPLE");
+    context->IsVertexArrayAPPLE = (PFNGLISVERTEXARRAYAPPLEPROC) load(userptr, "glIsVertexArrayAPPLE");
+}
+static void glad_gl_load_GL_ARB_color_buffer_float(GladGLContext *context, GLADuserptrloadfunc load, void* userptr) {
+    if(!context->ARB_color_buffer_float) return;
+    context->ClampColorARB = (PFNGLCLAMPCOLORARBPROC) load(userptr, "glClampColorARB");
+}
+static void glad_gl_load_GL_ARB_copy_buffer(GladGLContext *context, GLADuserptrloadfunc load, void* userptr) {
+    if(!context->ARB_copy_buffer) return;
+    context->CopyBufferSubData = (PFNGLCOPYBUFFERSUBDATAPROC) load(userptr, "glCopyBufferSubData");
+}
+static void glad_gl_load_GL_ARB_draw_buffers(GladGLContext *context, GLADuserptrloadfunc load, void* userptr) {
+    if(!context->ARB_draw_buffers) return;
+    context->DrawBuffersARB = (PFNGLDRAWBUFFERSARBPROC) load(userptr, "glDrawBuffersARB");
+}
+static void glad_gl_load_GL_ARB_draw_elements_base_vertex(GladGLContext *context, GLADuserptrloadfunc load, void* userptr) {
+    if(!context->ARB_draw_elements_base_vertex) return;
+    context->DrawElementsBaseVertex = (PFNGLDRAWELEMENTSBASEVERTEXPROC) load(userptr, "glDrawElementsBaseVertex");
+    context->DrawElementsInstancedBaseVertex = (PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC) load(userptr, "glDrawElementsInstancedBaseVertex");
+    context->DrawRangeElementsBaseVertex = (PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC) load(userptr, "glDrawRangeElementsBaseVertex");
+    context->MultiDrawElementsBaseVertex = (PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC) load(userptr, "glMultiDrawElementsBaseVertex");
+}
+static void glad_gl_load_GL_ARB_draw_instanced(GladGLContext *context, GLADuserptrloadfunc load, void* userptr) {
+    if(!context->ARB_draw_instanced) return;
+    context->DrawArraysInstancedARB = (PFNGLDRAWARRAYSINSTANCEDARBPROC) load(userptr, "glDrawArraysInstancedARB");
+    context->DrawElementsInstancedARB = (PFNGLDRAWELEMENTSINSTANCEDARBPROC) load(userptr, "glDrawElementsInstancedARB");
+}
+static void glad_gl_load_GL_ARB_framebuffer_object(GladGLContext *context, GLADuserptrloadfunc load, void* userptr) {
+    if(!context->ARB_framebuffer_object) return;
+    context->BindFramebuffer = (PFNGLBINDFRAMEBUFFERPROC) load(userptr, "glBindFramebuffer");
+    context->BindRenderbuffer = (PFNGLBINDRENDERBUFFERPROC) load(userptr, "glBindRenderbuffer");
+    context->BlitFramebuffer = (PFNGLBLITFRAMEBUFFERPROC) load(userptr, "glBlitFramebuffer");
+    context->CheckFramebufferStatus = (PFNGLCHECKFRAMEBUFFERSTATUSPROC) load(userptr, "glCheckFramebufferStatus");
+    context->DeleteFramebuffers = (PFNGLDELETEFRAMEBUFFERSPROC) load(userptr, "glDeleteFramebuffers");
+    context->DeleteRenderbuffers = (PFNGLDELETERENDERBUFFERSPROC) load(userptr, "glDeleteRenderbuffers");
+    context->FramebufferRenderbuffer = (PFNGLFRAMEBUFFERRENDERBUFFERPROC) load(userptr, "glFramebufferRenderbuffer");
+    context->FramebufferTexture1D = (PFNGLFRAMEBUFFERTEXTURE1DPROC) load(userptr, "glFramebufferTexture1D");
+    context->FramebufferTexture2D = (PFNGLFRAMEBUFFERTEXTURE2DPROC) load(userptr, "glFramebufferTexture2D");
+    context->FramebufferTexture3D = (PFNGLFRAMEBUFFERTEXTURE3DPROC) load(userptr, "glFramebufferTexture3D");
+    context->FramebufferTextureLayer = (PFNGLFRAMEBUFFERTEXTURELAYERPROC) load(userptr, "glFramebufferTextureLayer");
+    context->GenFramebuffers = (PFNGLGENFRAMEBUFFERSPROC) load(userptr, "glGenFramebuffers");
+    context->GenRenderbuffers = (PFNGLGENRENDERBUFFERSPROC) load(userptr, "glGenRenderbuffers");
+    context->GenerateMipmap = (PFNGLGENERATEMIPMAPPROC) load(userptr, "glGenerateMipmap");
+    context->GetFramebufferAttachmentParameteriv = (PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC) load(userptr, "glGetFramebufferAttachmentParameteriv");
+    context->GetRenderbufferParameteriv = (PFNGLGETRENDERBUFFERPARAMETERIVPROC) load(userptr, "glGetRenderbufferParameteriv");
+    context->IsFramebuffer = (PFNGLISFRAMEBUFFERPROC) load(userptr, "glIsFramebuffer");
+    context->IsRenderbuffer = (PFNGLISRENDERBUFFERPROC) load(userptr, "glIsRenderbuffer");
+    context->RenderbufferStorage = (PFNGLRENDERBUFFERSTORAGEPROC) load(userptr, "glRenderbufferStorage");
+    context->RenderbufferStorageMultisample = (PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC) load(userptr, "glRenderbufferStorageMultisample");
+}
+static void glad_gl_load_GL_ARB_geometry_shader4(GladGLContext *context, GLADuserptrloadfunc load, void* userptr) {
+    if(!context->ARB_geometry_shader4) return;
+    context->FramebufferTextureARB = (PFNGLFRAMEBUFFERTEXTUREARBPROC) load(userptr, "glFramebufferTextureARB");
+    context->FramebufferTextureFaceARB = (PFNGLFRAMEBUFFERTEXTUREFACEARBPROC) load(userptr, "glFramebufferTextureFaceARB");
+    context->FramebufferTextureLayerARB = (PFNGLFRAMEBUFFERTEXTURELAYERARBPROC) load(userptr, "glFramebufferTextureLayerARB");
+    context->ProgramParameteriARB = (PFNGLPROGRAMPARAMETERIARBPROC) load(userptr, "glProgramParameteriARB");
+}
+static void glad_gl_load_GL_ARB_imaging(GladGLContext *context, GLADuserptrloadfunc load, void* userptr) {
+    if(!context->ARB_imaging) return;
+    context->BlendColor = (PFNGLBLENDCOLORPROC) load(userptr, "glBlendColor");
+    context->BlendEquation = (PFNGLBLENDEQUATIONPROC) load(userptr, "glBlendEquation");
+}
+static void glad_gl_load_GL_ARB_map_buffer_range(GladGLContext *context, GLADuserptrloadfunc load, void* userptr) {
+    if(!context->ARB_map_buffer_range) return;
+    context->FlushMappedBufferRange = (PFNGLFLUSHMAPPEDBUFFERRANGEPROC) load(userptr, "glFlushMappedBufferRange");
+    context->MapBufferRange = (PFNGLMAPBUFFERRANGEPROC) load(userptr, "glMapBufferRange");
+}
+static void glad_gl_load_GL_ARB_multisample(GladGLContext *context, GLADuserptrloadfunc load, void* userptr) {
+    if(!context->ARB_multisample) return;
+    context->SampleCoverageARB = (PFNGLSAMPLECOVERAGEARBPROC) load(userptr, "glSampleCoverageARB");
+}
+static void glad_gl_load_GL_ARB_multitexture(GladGLContext *context, GLADuserptrloadfunc load, void* userptr) {
+    if(!context->ARB_multitexture) return;
+    context->ActiveTextureARB = (PFNGLACTIVETEXTUREARBPROC) load(userptr, "glActiveTextureARB");
+    context->ClientActiveTextureARB = (PFNGLCLIENTACTIVETEXTUREARBPROC) load(userptr, "glClientActiveTextureARB");
+    context->MultiTexCoord1dARB = (PFNGLMULTITEXCOORD1DARBPROC) load(userptr, "glMultiTexCoord1dARB");
+    context->MultiTexCoord1dvARB = (PFNGLMULTITEXCOORD1DVARBPROC) load(userptr, "glMultiTexCoord1dvARB");
+    context->MultiTexCoord1fARB = (PFNGLMULTITEXCOORD1FARBPROC) load(userptr, "glMultiTexCoord1fARB");
+    context->MultiTexCoord1fvARB = (PFNGLMULTITEXCOORD1FVARBPROC) load(userptr, "glMultiTexCoord1fvARB");
+    context->MultiTexCoord1iARB = (PFNGLMULTITEXCOORD1IARBPROC) load(userptr, "glMultiTexCoord1iARB");
+    context->MultiTexCoord1ivARB = (PFNGLMULTITEXCOORD1IVARBPROC) load(userptr, "glMultiTexCoord1ivARB");
+    context->MultiTexCoord1sARB = (PFNGLMULTITEXCOORD1SARBPROC) load(userptr, "glMultiTexCoord1sARB");
+    context->MultiTexCoord1svARB = (PFNGLMULTITEXCOORD1SVARBPROC) load(userptr, "glMultiTexCoord1svARB");
+    context->MultiTexCoord2dARB = (PFNGLMULTITEXCOORD2DARBPROC) load(userptr, "glMultiTexCoord2dARB");
+    context->MultiTexCoord2dvARB = (PFNGLMULTITEXCOORD2DVARBPROC) load(userptr, "glMultiTexCoord2dvARB");
+    context->MultiTexCoord2fARB = (PFNGLMULTITEXCOORD2FARBPROC) load(userptr, "glMultiTexCoord2fARB");
+    context->MultiTexCoord2fvARB = (PFNGLMULTITEXCOORD2FVARBPROC) load(userptr, "glMultiTexCoord2fvARB");
+    context->MultiTexCoord2iARB = (PFNGLMULTITEXCOORD2IARBPROC) load(userptr, "glMultiTexCoord2iARB");
+    context->MultiTexCoord2ivARB = (PFNGLMULTITEXCOORD2IVARBPROC) load(userptr, "glMultiTexCoord2ivARB");
+    context->MultiTexCoord2sARB = (PFNGLMULTITEXCOORD2SARBPROC) load(userptr, "glMultiTexCoord2sARB");
+    context->MultiTexCoord2svARB = (PFNGLMULTITEXCOORD2SVARBPROC) load(userptr, "glMultiTexCoord2svARB");
+    context->MultiTexCoord3dARB = (PFNGLMULTITEXCOORD3DARBPROC) load(userptr, "glMultiTexCoord3dARB");
+    context->MultiTexCoord3dvARB = (PFNGLMULTITEXCOORD3DVARBPROC) load(userptr, "glMultiTexCoord3dvARB");
+    context->MultiTexCoord3fARB = (PFNGLMULTITEXCOORD3FARBPROC) load(userptr, "glMultiTexCoord3fARB");
+    context->MultiTexCoord3fvARB = (PFNGLMULTITEXCOORD3FVARBPROC) load(userptr, "glMultiTexCoord3fvARB");
+    context->MultiTexCoord3iARB = (PFNGLMULTITEXCOORD3IARBPROC) load(userptr, "glMultiTexCoord3iARB");
+    context->MultiTexCoord3ivARB = (PFNGLMULTITEXCOORD3IVARBPROC) load(userptr, "glMultiTexCoord3ivARB");
+    context->MultiTexCoord3sARB = (PFNGLMULTITEXCOORD3SARBPROC) load(userptr, "glMultiTexCoord3sARB");
+    context->MultiTexCoord3svARB = (PFNGLMULTITEXCOORD3SVARBPROC) load(userptr, "glMultiTexCoord3svARB");
+    context->MultiTexCoord4dARB = (PFNGLMULTITEXCOORD4DARBPROC) load(userptr, "glMultiTexCoord4dARB");
+    context->MultiTexCoord4dvARB = (PFNGLMULTITEXCOORD4DVARBPROC) load(userptr, "glMultiTexCoord4dvARB");
+    context->MultiTexCoord4fARB = (PFNGLMULTITEXCOORD4FARBPROC) load(userptr, "glMultiTexCoord4fARB");
+    context->MultiTexCoord4fvARB = (PFNGLMULTITEXCOORD4FVARBPROC) load(userptr, "glMultiTexCoord4fvARB");
+    context->MultiTexCoord4iARB = (PFNGLMULTITEXCOORD4IARBPROC) load(userptr, "glMultiTexCoord4iARB");
+    context->MultiTexCoord4ivARB = (PFNGLMULTITEXCOORD4IVARBPROC) load(userptr, "glMultiTexCoord4ivARB");
+    context->MultiTexCoord4sARB = (PFNGLMULTITEXCOORD4SARBPROC) load(userptr, "glMultiTexCoord4sARB");
+    context->MultiTexCoord4svARB = (PFNGLMULTITEXCOORD4SVARBPROC) load(userptr, "glMultiTexCoord4svARB");
+}
+static void glad_gl_load_GL_ARB_occlusion_query(GladGLContext *context, GLADuserptrloadfunc load, void* userptr) {
+    if(!context->ARB_occlusion_query) return;
+    context->BeginQueryARB = (PFNGLBEGINQUERYARBPROC) load(userptr, "glBeginQueryARB");
+    context->DeleteQueriesARB = (PFNGLDELETEQUERIESARBPROC) load(userptr, "glDeleteQueriesARB");
+    context->EndQueryARB = (PFNGLENDQUERYARBPROC) load(userptr, "glEndQueryARB");
+    context->GenQueriesARB = (PFNGLGENQUERIESARBPROC) load(userptr, "glGenQueriesARB");
+    context->GetQueryObjectivARB = (PFNGLGETQUERYOBJECTIVARBPROC) load(userptr, "glGetQueryObjectivARB");
+    context->GetQueryObjectuivARB = (PFNGLGETQUERYOBJECTUIVARBPROC) load(userptr, "glGetQueryObjectuivARB");
+    context->GetQueryivARB = (PFNGLGETQUERYIVARBPROC) load(userptr, "glGetQueryivARB");
+    context->IsQueryARB = (PFNGLISQUERYARBPROC) load(userptr, "glIsQueryARB");
+}
+static void glad_gl_load_GL_ARB_point_parameters(GladGLContext *context, GLADuserptrloadfunc load, void* userptr) {
+    if(!context->ARB_point_parameters) return;
+    context->PointParameterfARB = (PFNGLPOINTPARAMETERFARBPROC) load(userptr, "glPointParameterfARB");
+    context->PointParameterfvARB = (PFNGLPOINTPARAMETERFVARBPROC) load(userptr, "glPointParameterfvARB");
+}
+static void glad_gl_load_GL_ARB_provoking_vertex(GladGLContext *context, GLADuserptrloadfunc load, void* userptr) {
+    if(!context->ARB_provoking_vertex) return;
+    context->ProvokingVertex = (PFNGLPROVOKINGVERTEXPROC) load(userptr, "glProvokingVertex");
+}
+static void glad_gl_load_GL_ARB_shader_objects(GladGLContext *context, GLADuserptrloadfunc load, void* userptr) {
+    if(!context->ARB_shader_objects) return;
+    context->AttachObjectARB = (PFNGLATTACHOBJECTARBPROC) load(userptr, "glAttachObjectARB");
+    context->CompileShaderARB = (PFNGLCOMPILESHADERARBPROC) load(userptr, "glCompileShaderARB");
+    context->CreateProgramObjectARB = (PFNGLCREATEPROGRAMOBJECTARBPROC) load(userptr, "glCreateProgramObjectARB");
+    context->CreateShaderObjectARB = (PFNGLCREATESHADEROBJECTARBPROC) load(userptr, "glCreateShaderObjectARB");
+    context->DeleteObjectARB = (PFNGLDELETEOBJECTARBPROC) load(userptr, "glDeleteObjectARB");
+    context->DetachObjectARB = (PFNGLDETACHOBJECTARBPROC) load(userptr, "glDetachObjectARB");
+    context->GetActiveUniformARB = (PFNGLGETACTIVEUNIFORMARBPROC) load(userptr, "glGetActiveUniformARB");
+    context->GetAttachedObjectsARB = (PFNGLGETATTACHEDOBJECTSARBPROC) load(userptr, "glGetAttachedObjectsARB");
+    context->GetHandleARB = (PFNGLGETHANDLEARBPROC) load(userptr, "glGetHandleARB");
+    context->GetInfoLogARB = (PFNGLGETINFOLOGARBPROC) load(userptr, "glGetInfoLogARB");
+    context->GetObjectParameterfvARB = (PFNGLGETOBJECTPARAMETERFVARBPROC) load(userptr, "glGetObjectParameterfvARB");
+    context->GetObjectParameterivARB = (PFNGLGETOBJECTPARAMETERIVARBPROC) load(userptr, "glGetObjectParameterivARB");
+    context->GetShaderSourceARB = (PFNGLGETSHADERSOURCEARBPROC) load(userptr, "glGetShaderSourceARB");
+    context->GetUniformLocationARB = (PFNGLGETUNIFORMLOCATIONARBPROC) load(userptr, "glGetUniformLocationARB");
+    context->GetUniformfvARB = (PFNGLGETUNIFORMFVARBPROC) load(userptr, "glGetUniformfvARB");
+    context->GetUniformivARB = (PFNGLGETUNIFORMIVARBPROC) load(userptr, "glGetUniformivARB");
+    context->LinkProgramARB = (PFNGLLINKPROGRAMARBPROC) load(userptr, "glLinkProgramARB");
+    context->ShaderSourceARB = (PFNGLSHADERSOURCEARBPROC) load(userptr, "glShaderSourceARB");
+    context->Uniform1fARB = (PFNGLUNIFORM1FARBPROC) load(userptr, "glUniform1fARB");
+    context->Uniform1fvARB = (PFNGLUNIFORM1FVARBPROC) load(userptr, "glUniform1fvARB");
+    context->Uniform1iARB = (PFNGLUNIFORM1IARBPROC) load(userptr, "glUniform1iARB");
+    context->Uniform1ivARB = (PFNGLUNIFORM1IVARBPROC) load(userptr, "glUniform1ivARB");
+    context->Uniform2fARB = (PFNGLUNIFORM2FARBPROC) load(userptr, "glUniform2fARB");
+    context->Uniform2fvARB = (PFNGLUNIFORM2FVARBPROC) load(userptr, "glUniform2fvARB");
+    context->Uniform2iARB = (PFNGLUNIFORM2IARBPROC) load(userptr, "glUniform2iARB");
+    context->Uniform2ivARB = (PFNGLUNIFORM2IVARBPROC) load(userptr, "glUniform2ivARB");
+    context->Uniform3fARB = (PFNGLUNIFORM3FARBPROC) load(userptr, "glUniform3fARB");
+    context->Uniform3fvARB = (PFNGLUNIFORM3FVARBPROC) load(userptr, "glUniform3fvARB");
+    context->Uniform3iARB = (PFNGLUNIFORM3IARBPROC) load(userptr, "glUniform3iARB");
+    context->Uniform3ivARB = (PFNGLUNIFORM3IVARBPROC) load(userptr, "glUniform3ivARB");
+    context->Uniform4fARB = (PFNGLUNIFORM4FARBPROC) load(userptr, "glUniform4fARB");
+    context->Uniform4fvARB = (PFNGLUNIFORM4FVARBPROC) load(userptr, "glUniform4fvARB");
+    context->Uniform4iARB = (PFNGLUNIFORM4IARBPROC) load(userptr, "glUniform4iARB");
+    context->Uniform4ivARB = (PFNGLUNIFORM4IVARBPROC) load(userptr, "glUniform4ivARB");
+    context->UniformMatrix2fvARB = (PFNGLUNIFORMMATRIX2FVARBPROC) load(userptr, "glUniformMatrix2fvARB");
+    context->UniformMatrix3fvARB = (PFNGLUNIFORMMATRIX3FVARBPROC) load(userptr, "glUniformMatrix3fvARB");
+    context->UniformMatrix4fvARB = (PFNGLUNIFORMMATRIX4FVARBPROC) load(userptr, "glUniformMatrix4fvARB");
+    context->UseProgramObjectARB = (PFNGLUSEPROGRAMOBJECTARBPROC) load(userptr, "glUseProgramObjectARB");
+    context->ValidateProgramARB = (PFNGLVALIDATEPROGRAMARBPROC) load(userptr, "glValidateProgramARB");
+}
+static void glad_gl_load_GL_ARB_sync(GladGLContext *context, GLADuserptrloadfunc load, void* userptr) {
+    if(!context->ARB_sync) return;
+    context->ClientWaitSync = (PFNGLCLIENTWAITSYNCPROC) load(userptr, "glClientWaitSync");
+    context->DeleteSync = (PFNGLDELETESYNCPROC) load(userptr, "glDeleteSync");
+    context->FenceSync = (PFNGLFENCESYNCPROC) load(userptr, "glFenceSync");
+    context->GetInteger64v = (PFNGLGETINTEGER64VPROC) load(userptr, "glGetInteger64v");
+    context->GetSynciv = (PFNGLGETSYNCIVPROC) load(userptr, "glGetSynciv");
+    context->IsSync = (PFNGLISSYNCPROC) load(userptr, "glIsSync");
+    context->WaitSync = (PFNGLWAITSYNCPROC) load(userptr, "glWaitSync");
+}
+static void glad_gl_load_GL_ARB_texture_buffer_object(GladGLContext *context, GLADuserptrloadfunc load, void* userptr) {
+    if(!context->ARB_texture_buffer_object) return;
+    context->TexBufferARB = (PFNGLTEXBUFFERARBPROC) load(userptr, "glTexBufferARB");
+}
+static void glad_gl_load_GL_ARB_texture_compression(GladGLContext *context, GLADuserptrloadfunc load, void* userptr) {
+    if(!context->ARB_texture_compression) return;
+    context->CompressedTexImage1DARB = (PFNGLCOMPRESSEDTEXIMAGE1DARBPROC) load(userptr, "glCompressedTexImage1DARB");
+    context->CompressedTexImage2DARB = (PFNGLCOMPRESSEDTEXIMAGE2DARBPROC) load(userptr, "glCompressedTexImage2DARB");
+    context->CompressedTexImage3DARB = (PFNGLCOMPRESSEDTEXIMAGE3DARBPROC) load(userptr, "glCompressedTexImage3DARB");
+    context->CompressedTexSubImage1DARB = (PFNGLCOMPRESSEDTEXSUBIMAGE1DARBPROC) load(userptr, "glCompressedTexSubImage1DARB");
+    context->CompressedTexSubImage2DARB = (PFNGLCOMPRESSEDTEXSUBIMAGE2DARBPROC) load(userptr, "glCompressedTexSubImage2DARB");
+    context->CompressedTexSubImage3DARB = (PFNGLCOMPRESSEDTEXSUBIMAGE3DARBPROC) load(userptr, "glCompressedTexSubImage3DARB");
+    context->GetCompressedTexImageARB = (PFNGLGETCOMPRESSEDTEXIMAGEARBPROC) load(userptr, "glGetCompressedTexImageARB");
+}
+static void glad_gl_load_GL_ARB_texture_multisample(GladGLContext *context, GLADuserptrloadfunc load, void* userptr) {
+    if(!context->ARB_texture_multisample) return;
+    context->GetMultisamplefv = (PFNGLGETMULTISAMPLEFVPROC) load(userptr, "glGetMultisamplefv");
+    context->SampleMaski = (PFNGLSAMPLEMASKIPROC) load(userptr, "glSampleMaski");
+    context->TexImage2DMultisample = (PFNGLTEXIMAGE2DMULTISAMPLEPROC) load(userptr, "glTexImage2DMultisample");
+    context->TexImage3DMultisample = (PFNGLTEXIMAGE3DMULTISAMPLEPROC) load(userptr, "glTexImage3DMultisample");
+}
+static void glad_gl_load_GL_ARB_uniform_buffer_object(GladGLContext *context, GLADuserptrloadfunc load, void* userptr) {
+    if(!context->ARB_uniform_buffer_object) return;
+    context->BindBufferBase = (PFNGLBINDBUFFERBASEPROC) load(userptr, "glBindBufferBase");
+    context->BindBufferRange = (PFNGLBINDBUFFERRANGEPROC) load(userptr, "glBindBufferRange");
+    context->GetActiveUniformBlockName = (PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC) load(userptr, "glGetActiveUniformBlockName");
+    context->GetActiveUniformBlockiv = (PFNGLGETACTIVEUNIFORMBLOCKIVPROC) load(userptr, "glGetActiveUniformBlockiv");
+    context->GetActiveUniformName = (PFNGLGETACTIVEUNIFORMNAMEPROC) load(userptr, "glGetActiveUniformName");
+    context->GetActiveUniformsiv = (PFNGLGETACTIVEUNIFORMSIVPROC) load(userptr, "glGetActiveUniformsiv");
+    context->GetIntegeri_v = (PFNGLGETINTEGERI_VPROC) load(userptr, "glGetIntegeri_v");
+    context->GetUniformBlockIndex = (PFNGLGETUNIFORMBLOCKINDEXPROC) load(userptr, "glGetUniformBlockIndex");
+    context->GetUniformIndices = (PFNGLGETUNIFORMINDICESPROC) load(userptr, "glGetUniformIndices");
+    context->UniformBlockBinding = (PFNGLUNIFORMBLOCKBINDINGPROC) load(userptr, "glUniformBlockBinding");
+}
+static void glad_gl_load_GL_ARB_vertex_array_object(GladGLContext *context, GLADuserptrloadfunc load, void* userptr) {
+    if(!context->ARB_vertex_array_object) return;
+    context->BindVertexArray = (PFNGLBINDVERTEXARRAYPROC) load(userptr, "glBindVertexArray");
+    context->DeleteVertexArrays = (PFNGLDELETEVERTEXARRAYSPROC) load(userptr, "glDeleteVertexArrays");
+    context->GenVertexArrays = (PFNGLGENVERTEXARRAYSPROC) load(userptr, "glGenVertexArrays");
+    context->IsVertexArray = (PFNGLISVERTEXARRAYPROC) load(userptr, "glIsVertexArray");
+}
+static void glad_gl_load_GL_ARB_vertex_buffer_object(GladGLContext *context, GLADuserptrloadfunc load, void* userptr) {
+    if(!context->ARB_vertex_buffer_object) return;
+    context->BindBufferARB = (PFNGLBINDBUFFERARBPROC) load(userptr, "glBindBufferARB");
+    context->BufferDataARB = (PFNGLBUFFERDATAARBPROC) load(userptr, "glBufferDataARB");
+    context->BufferSubDataARB = (PFNGLBUFFERSUBDATAARBPROC) load(userptr, "glBufferSubDataARB");
+    context->DeleteBuffersARB = (PFNGLDELETEBUFFERSARBPROC) load(userptr, "glDeleteBuffersARB");
+    context->GenBuffersARB = (PFNGLGENBUFFERSARBPROC) load(userptr, "glGenBuffersARB");
+    context->GetBufferParameterivARB = (PFNGLGETBUFFERPARAMETERIVARBPROC) load(userptr, "glGetBufferParameterivARB");
+    context->GetBufferPointervARB = (PFNGLGETBUFFERPOINTERVARBPROC) load(userptr, "glGetBufferPointervARB");
+    context->GetBufferSubDataARB = (PFNGLGETBUFFERSUBDATAARBPROC) load(userptr, "glGetBufferSubDataARB");
+    context->IsBufferARB = (PFNGLISBUFFERARBPROC) load(userptr, "glIsBufferARB");
+    context->MapBufferARB = (PFNGLMAPBUFFERARBPROC) load(userptr, "glMapBufferARB");
+    context->UnmapBufferARB = (PFNGLUNMAPBUFFERARBPROC) load(userptr, "glUnmapBufferARB");
+}
+static void glad_gl_load_GL_ARB_vertex_program(GladGLContext *context, GLADuserptrloadfunc load, void* userptr) {
+    if(!context->ARB_vertex_program) return;
+    context->BindProgramARB = (PFNGLBINDPROGRAMARBPROC) load(userptr, "glBindProgramARB");
+    context->DeleteProgramsARB = (PFNGLDELETEPROGRAMSARBPROC) load(userptr, "glDeleteProgramsARB");
+    context->DisableVertexAttribArrayARB = (PFNGLDISABLEVERTEXATTRIBARRAYARBPROC) load(userptr, "glDisableVertexAttribArrayARB");
+    context->EnableVertexAttribArrayARB = (PFNGLENABLEVERTEXATTRIBARRAYARBPROC) load(userptr, "glEnableVertexAttribArrayARB");
+    context->GenProgramsARB = (PFNGLGENPROGRAMSARBPROC) load(userptr, "glGenProgramsARB");
+    context->GetProgramEnvParameterdvARB = (PFNGLGETPROGRAMENVPARAMETERDVARBPROC) load(userptr, "glGetProgramEnvParameterdvARB");
+    context->GetProgramEnvParameterfvARB = (PFNGLGETPROGRAMENVPARAMETERFVARBPROC) load(userptr, "glGetProgramEnvParameterfvARB");
+    context->GetProgramLocalParameterdvARB = (PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC) load(userptr, "glGetProgramLocalParameterdvARB");
+    context->GetProgramLocalParameterfvARB = (PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC) load(userptr, "glGetProgramLocalParameterfvARB");
+    context->GetProgramStringARB = (PFNGLGETPROGRAMSTRINGARBPROC) load(userptr, "glGetProgramStringARB");
+    context->GetProgramivARB = (PFNGLGETPROGRAMIVARBPROC) load(userptr, "glGetProgramivARB");
+    context->GetVertexAttribPointervARB = (PFNGLGETVERTEXATTRIBPOINTERVARBPROC) load(userptr, "glGetVertexAttribPointervARB");
+    context->GetVertexAttribdvARB = (PFNGLGETVERTEXATTRIBDVARBPROC) load(userptr, "glGetVertexAttribdvARB");
+    context->GetVertexAttribfvARB = (PFNGLGETVERTEXATTRIBFVARBPROC) load(userptr, "glGetVertexAttribfvARB");
+    context->GetVertexAttribivARB = (PFNGLGETVERTEXATTRIBIVARBPROC) load(userptr, "glGetVertexAttribivARB");
+    context->IsProgramARB = (PFNGLISPROGRAMARBPROC) load(userptr, "glIsProgramARB");
+    context->ProgramEnvParameter4dARB = (PFNGLPROGRAMENVPARAMETER4DARBPROC) load(userptr, "glProgramEnvParameter4dARB");
+    context->ProgramEnvParameter4dvARB = (PFNGLPROGRAMENVPARAMETER4DVARBPROC) load(userptr, "glProgramEnvParameter4dvARB");
+    context->ProgramEnvParameter4fARB = (PFNGLPROGRAMENVPARAMETER4FARBPROC) load(userptr, "glProgramEnvParameter4fARB");
+    context->ProgramEnvParameter4fvARB = (PFNGLPROGRAMENVPARAMETER4FVARBPROC) load(userptr, "glProgramEnvParameter4fvARB");
+    context->ProgramLocalParameter4dARB = (PFNGLPROGRAMLOCALPARAMETER4DARBPROC) load(userptr, "glProgramLocalParameter4dARB");
+    context->ProgramLocalParameter4dvARB = (PFNGLPROGRAMLOCALPARAMETER4DVARBPROC) load(userptr, "glProgramLocalParameter4dvARB");
+    context->ProgramLocalParameter4fARB = (PFNGLPROGRAMLOCALPARAMETER4FARBPROC) load(userptr, "glProgramLocalParameter4fARB");
+    context->ProgramLocalParameter4fvARB = (PFNGLPROGRAMLOCALPARAMETER4FVARBPROC) load(userptr, "glProgramLocalParameter4fvARB");
+    context->ProgramStringARB = (PFNGLPROGRAMSTRINGARBPROC) load(userptr, "glProgramStringARB");
+    context->VertexAttrib1dARB = (PFNGLVERTEXATTRIB1DARBPROC) load(userptr, "glVertexAttrib1dARB");
+    context->VertexAttrib1dvARB = (PFNGLVERTEXATTRIB1DVARBPROC) load(userptr, "glVertexAttrib1dvARB");
+    context->VertexAttrib1fARB = (PFNGLVERTEXATTRIB1FARBPROC) load(userptr, "glVertexAttrib1fARB");
+    context->VertexAttrib1fvARB = (PFNGLVERTEXATTRIB1FVARBPROC) load(userptr, "glVertexAttrib1fvARB");
+    context->VertexAttrib1sARB = (PFNGLVERTEXATTRIB1SARBPROC) load(userptr, "glVertexAttrib1sARB");
+    context->VertexAttrib1svARB = (PFNGLVERTEXATTRIB1SVARBPROC) load(userptr, "glVertexAttrib1svARB");
+    context->VertexAttrib2dARB = (PFNGLVERTEXATTRIB2DARBPROC) load(userptr, "glVertexAttrib2dARB");
+    context->VertexAttrib2dvARB = (PFNGLVERTEXATTRIB2DVARBPROC) load(userptr, "glVertexAttrib2dvARB");
+    context->VertexAttrib2fARB = (PFNGLVERTEXATTRIB2FARBPROC) load(userptr, "glVertexAttrib2fARB");
+    context->VertexAttrib2fvARB = (PFNGLVERTEXATTRIB2FVARBPROC) load(userptr, "glVertexAttrib2fvARB");
+    context->VertexAttrib2sARB = (PFNGLVERTEXATTRIB2SARBPROC) load(userptr, "glVertexAttrib2sARB");
+    context->VertexAttrib2svARB = (PFNGLVERTEXATTRIB2SVARBPROC) load(userptr, "glVertexAttrib2svARB");
+    context->VertexAttrib3dARB = (PFNGLVERTEXATTRIB3DARBPROC) load(userptr, "glVertexAttrib3dARB");
+    context->VertexAttrib3dvARB = (PFNGLVERTEXATTRIB3DVARBPROC) load(userptr, "glVertexAttrib3dvARB");
+    context->VertexAttrib3fARB = (PFNGLVERTEXATTRIB3FARBPROC) load(userptr, "glVertexAttrib3fARB");
+    context->VertexAttrib3fvARB = (PFNGLVERTEXATTRIB3FVARBPROC) load(userptr, "glVertexAttrib3fvARB");
+    context->VertexAttrib3sARB = (PFNGLVERTEXATTRIB3SARBPROC) load(userptr, "glVertexAttrib3sARB");
+    context->VertexAttrib3svARB = (PFNGLVERTEXATTRIB3SVARBPROC) load(userptr, "glVertexAttrib3svARB");
+    context->VertexAttrib4NbvARB = (PFNGLVERTEXATTRIB4NBVARBPROC) load(userptr, "glVertexAttrib4NbvARB");
+    context->VertexAttrib4NivARB = (PFNGLVERTEXATTRIB4NIVARBPROC) load(userptr, "glVertexAttrib4NivARB");
+    context->VertexAttrib4NsvARB = (PFNGLVERTEXATTRIB4NSVARBPROC) load(userptr, "glVertexAttrib4NsvARB");
+    context->VertexAttrib4NubARB = (PFNGLVERTEXATTRIB4NUBARBPROC) load(userptr, "glVertexAttrib4NubARB");
+    context->VertexAttrib4NubvARB = (PFNGLVERTEXATTRIB4NUBVARBPROC) load(userptr, "glVertexAttrib4NubvARB");
+    context->VertexAttrib4NuivARB = (PFNGLVERTEXATTRIB4NUIVARBPROC) load(userptr, "glVertexAttrib4NuivARB");
+    context->VertexAttrib4NusvARB = (PFNGLVERTEXATTRIB4NUSVARBPROC) load(userptr, "glVertexAttrib4NusvARB");
+    context->VertexAttrib4bvARB = (PFNGLVERTEXATTRIB4BVARBPROC) load(userptr, "glVertexAttrib4bvARB");
+    context->VertexAttrib4dARB = (PFNGLVERTEXATTRIB4DARBPROC) load(userptr, "glVertexAttrib4dARB");
+    context->VertexAttrib4dvARB = (PFNGLVERTEXATTRIB4DVARBPROC) load(userptr, "glVertexAttrib4dvARB");
+    context->VertexAttrib4fARB = (PFNGLVERTEXATTRIB4FARBPROC) load(userptr, "glVertexAttrib4fARB");
+    context->VertexAttrib4fvARB = (PFNGLVERTEXATTRIB4FVARBPROC) load(userptr, "glVertexAttrib4fvARB");
+    context->VertexAttrib4ivARB = (PFNGLVERTEXATTRIB4IVARBPROC) load(userptr, "glVertexAttrib4ivARB");
+    context->VertexAttrib4sARB = (PFNGLVERTEXATTRIB4SARBPROC) load(userptr, "glVertexAttrib4sARB");
+    context->VertexAttrib4svARB = (PFNGLVERTEXATTRIB4SVARBPROC) load(userptr, "glVertexAttrib4svARB");
+    context->VertexAttrib4ubvARB = (PFNGLVERTEXATTRIB4UBVARBPROC) load(userptr, "glVertexAttrib4ubvARB");
+    context->VertexAttrib4uivARB = (PFNGLVERTEXATTRIB4UIVARBPROC) load(userptr, "glVertexAttrib4uivARB");
+    context->VertexAttrib4usvARB = (PFNGLVERTEXATTRIB4USVARBPROC) load(userptr, "glVertexAttrib4usvARB");
+    context->VertexAttribPointerARB = (PFNGLVERTEXATTRIBPOINTERARBPROC) load(userptr, "glVertexAttribPointerARB");
+}
+static void glad_gl_load_GL_ARB_vertex_shader(GladGLContext *context, GLADuserptrloadfunc load, void* userptr) {
+    if(!context->ARB_vertex_shader) return;
+    context->BindAttribLocationARB = (PFNGLBINDATTRIBLOCATIONARBPROC) load(userptr, "glBindAttribLocationARB");
+    context->DisableVertexAttribArrayARB = (PFNGLDISABLEVERTEXATTRIBARRAYARBPROC) load(userptr, "glDisableVertexAttribArrayARB");
+    context->EnableVertexAttribArrayARB = (PFNGLENABLEVERTEXATTRIBARRAYARBPROC) load(userptr, "glEnableVertexAttribArrayARB");
+    context->GetActiveAttribARB = (PFNGLGETACTIVEATTRIBARBPROC) load(userptr, "glGetActiveAttribARB");
+    context->GetAttribLocationARB = (PFNGLGETATTRIBLOCATIONARBPROC) load(userptr, "glGetAttribLocationARB");
+    context->GetVertexAttribPointervARB = (PFNGLGETVERTEXATTRIBPOINTERVARBPROC) load(userptr, "glGetVertexAttribPointervARB");
+    context->GetVertexAttribdvARB = (PFNGLGETVERTEXATTRIBDVARBPROC) load(userptr, "glGetVertexAttribdvARB");
+    context->GetVertexAttribfvARB = (PFNGLGETVERTEXATTRIBFVARBPROC) load(userptr, "glGetVertexAttribfvARB");
+    context->GetVertexAttribivARB = (PFNGLGETVERTEXATTRIBIVARBPROC) load(userptr, "glGetVertexAttribivARB");
+    context->VertexAttrib1dARB = (PFNGLVERTEXATTRIB1DARBPROC) load(userptr, "glVertexAttrib1dARB");
+    context->VertexAttrib1dvARB = (PFNGLVERTEXATTRIB1DVARBPROC) load(userptr, "glVertexAttrib1dvARB");
+    context->VertexAttrib1fARB = (PFNGLVERTEXATTRIB1FARBPROC) load(userptr, "glVertexAttrib1fARB");
+    context->VertexAttrib1fvARB = (PFNGLVERTEXATTRIB1FVARBPROC) load(userptr, "glVertexAttrib1fvARB");
+    context->VertexAttrib1sARB = (PFNGLVERTEXATTRIB1SARBPROC) load(userptr, "glVertexAttrib1sARB");
+    context->VertexAttrib1svARB = (PFNGLVERTEXATTRIB1SVARBPROC) load(userptr, "glVertexAttrib1svARB");
+    context->VertexAttrib2dARB = (PFNGLVERTEXATTRIB2DARBPROC) load(userptr, "glVertexAttrib2dARB");
+    context->VertexAttrib2dvARB = (PFNGLVERTEXATTRIB2DVARBPROC) load(userptr, "glVertexAttrib2dvARB");
+    context->VertexAttrib2fARB = (PFNGLVERTEXATTRIB2FARBPROC) load(userptr, "glVertexAttrib2fARB");
+    context->VertexAttrib2fvARB = (PFNGLVERTEXATTRIB2FVARBPROC) load(userptr, "glVertexAttrib2fvARB");
+    context->VertexAttrib2sARB = (PFNGLVERTEXATTRIB2SARBPROC) load(userptr, "glVertexAttrib2sARB");
+    context->VertexAttrib2svARB = (PFNGLVERTEXATTRIB2SVARBPROC) load(userptr, "glVertexAttrib2svARB");
+    context->VertexAttrib3dARB = (PFNGLVERTEXATTRIB3DARBPROC) load(userptr, "glVertexAttrib3dARB");
+    context->VertexAttrib3dvARB = (PFNGLVERTEXATTRIB3DVARBPROC) load(userptr, "glVertexAttrib3dvARB");
+    context->VertexAttrib3fARB = (PFNGLVERTEXATTRIB3FARBPROC) load(userptr, "glVertexAttrib3fARB");
+    context->VertexAttrib3fvARB = (PFNGLVERTEXATTRIB3FVARBPROC) load(userptr, "glVertexAttrib3fvARB");
+    context->VertexAttrib3sARB = (PFNGLVERTEXATTRIB3SARBPROC) load(userptr, "glVertexAttrib3sARB");
+    context->VertexAttrib3svARB = (PFNGLVERTEXATTRIB3SVARBPROC) load(userptr, "glVertexAttrib3svARB");
+    context->VertexAttrib4NbvARB = (PFNGLVERTEXATTRIB4NBVARBPROC) load(userptr, "glVertexAttrib4NbvARB");
+    context->VertexAttrib4NivARB = (PFNGLVERTEXATTRIB4NIVARBPROC) load(userptr, "glVertexAttrib4NivARB");
+    context->VertexAttrib4NsvARB = (PFNGLVERTEXATTRIB4NSVARBPROC) load(userptr, "glVertexAttrib4NsvARB");
+    context->VertexAttrib4NubARB = (PFNGLVERTEXATTRIB4NUBARBPROC) load(userptr, "glVertexAttrib4NubARB");
+    context->VertexAttrib4NubvARB = (PFNGLVERTEXATTRIB4NUBVARBPROC) load(userptr, "glVertexAttrib4NubvARB");
+    context->VertexAttrib4NuivARB = (PFNGLVERTEXATTRIB4NUIVARBPROC) load(userptr, "glVertexAttrib4NuivARB");
+    context->VertexAttrib4NusvARB = (PFNGLVERTEXATTRIB4NUSVARBPROC) load(userptr, "glVertexAttrib4NusvARB");
+    context->VertexAttrib4bvARB = (PFNGLVERTEXATTRIB4BVARBPROC) load(userptr, "glVertexAttrib4bvARB");
+    context->VertexAttrib4dARB = (PFNGLVERTEXATTRIB4DARBPROC) load(userptr, "glVertexAttrib4dARB");
+    context->VertexAttrib4dvARB = (PFNGLVERTEXATTRIB4DVARBPROC) load(userptr, "glVertexAttrib4dvARB");
+    context->VertexAttrib4fARB = (PFNGLVERTEXATTRIB4FARBPROC) load(userptr, "glVertexAttrib4fARB");
+    context->VertexAttrib4fvARB = (PFNGLVERTEXATTRIB4FVARBPROC) load(userptr, "glVertexAttrib4fvARB");
+    context->VertexAttrib4ivARB = (PFNGLVERTEXATTRIB4IVARBPROC) load(userptr, "glVertexAttrib4ivARB");
+    context->VertexAttrib4sARB = (PFNGLVERTEXATTRIB4SARBPROC) load(userptr, "glVertexAttrib4sARB");
+    context->VertexAttrib4svARB = (PFNGLVERTEXATTRIB4SVARBPROC) load(userptr, "glVertexAttrib4svARB");
+    context->VertexAttrib4ubvARB = (PFNGLVERTEXATTRIB4UBVARBPROC) load(userptr, "glVertexAttrib4ubvARB");
+    context->VertexAttrib4uivARB = (PFNGLVERTEXATTRIB4UIVARBPROC) load(userptr, "glVertexAttrib4uivARB");
+    context->VertexAttrib4usvARB = (PFNGLVERTEXATTRIB4USVARBPROC) load(userptr, "glVertexAttrib4usvARB");
+    context->VertexAttribPointerARB = (PFNGLVERTEXATTRIBPOINTERARBPROC) load(userptr, "glVertexAttribPointerARB");
+}
+static void glad_gl_load_GL_ATI_draw_buffers(GladGLContext *context, GLADuserptrloadfunc load, void* userptr) {
+    if(!context->ATI_draw_buffers) return;
+    context->DrawBuffersATI = (PFNGLDRAWBUFFERSATIPROC) load(userptr, "glDrawBuffersATI");
+}
+static void glad_gl_load_GL_ATI_separate_stencil(GladGLContext *context, GLADuserptrloadfunc load, void* userptr) {
+    if(!context->ATI_separate_stencil) return;
+    context->StencilFuncSeparateATI = (PFNGLSTENCILFUNCSEPARATEATIPROC) load(userptr, "glStencilFuncSeparateATI");
+    context->StencilOpSeparateATI = (PFNGLSTENCILOPSEPARATEATIPROC) load(userptr, "glStencilOpSeparateATI");
+}
+static void glad_gl_load_GL_EXT_blend_color(GladGLContext *context, GLADuserptrloadfunc load, void* userptr) {
+    if(!context->EXT_blend_color) return;
+    context->BlendColorEXT = (PFNGLBLENDCOLOREXTPROC) load(userptr, "glBlendColorEXT");
+}
+static void glad_gl_load_GL_EXT_blend_equation_separate(GladGLContext *context, GLADuserptrloadfunc load, void* userptr) {
+    if(!context->EXT_blend_equation_separate) return;
+    context->BlendEquationSeparateEXT = (PFNGLBLENDEQUATIONSEPARATEEXTPROC) load(userptr, "glBlendEquationSeparateEXT");
+}
+static void glad_gl_load_GL_EXT_blend_func_separate(GladGLContext *context, GLADuserptrloadfunc load, void* userptr) {
+    if(!context->EXT_blend_func_separate) return;
+    context->BlendFuncSeparateEXT = (PFNGLBLENDFUNCSEPARATEEXTPROC) load(userptr, "glBlendFuncSeparateEXT");
+}
+static void glad_gl_load_GL_EXT_blend_minmax(GladGLContext *context, GLADuserptrloadfunc load, void* userptr) {
+    if(!context->EXT_blend_minmax) return;
+    context->BlendEquationEXT = (PFNGLBLENDEQUATIONEXTPROC) load(userptr, "glBlendEquationEXT");
+}
+static void glad_gl_load_GL_EXT_copy_texture(GladGLContext *context, GLADuserptrloadfunc load, void* userptr) {
+    if(!context->EXT_copy_texture) return;
+    context->CopyTexImage1DEXT = (PFNGLCOPYTEXIMAGE1DEXTPROC) load(userptr, "glCopyTexImage1DEXT");
+    context->CopyTexImage2DEXT = (PFNGLCOPYTEXIMAGE2DEXTPROC) load(userptr, "glCopyTexImage2DEXT");
+    context->CopyTexSubImage1DEXT = (PFNGLCOPYTEXSUBIMAGE1DEXTPROC) load(userptr, "glCopyTexSubImage1DEXT");
+    context->CopyTexSubImage2DEXT = (PFNGLCOPYTEXSUBIMAGE2DEXTPROC) load(userptr, "glCopyTexSubImage2DEXT");
+    context->CopyTexSubImage3DEXT = (PFNGLCOPYTEXSUBIMAGE3DEXTPROC) load(userptr, "glCopyTexSubImage3DEXT");
+}
+static void glad_gl_load_GL_EXT_direct_state_access(GladGLContext *context, GLADuserptrloadfunc load, void* userptr) {
+    if(!context->EXT_direct_state_access) return;
+    context->BindMultiTextureEXT = (PFNGLBINDMULTITEXTUREEXTPROC) load(userptr, "glBindMultiTextureEXT");
+    context->CheckNamedFramebufferStatusEXT = (PFNGLCHECKNAMEDFRAMEBUFFERSTATUSEXTPROC) load(userptr, "glCheckNamedFramebufferStatusEXT");
+    context->ClearNamedBufferDataEXT = (PFNGLCLEARNAMEDBUFFERDATAEXTPROC) load(userptr, "glClearNamedBufferDataEXT");
+    context->ClearNamedBufferSubDataEXT = (PFNGLCLEARNAMEDBUFFERSUBDATAEXTPROC) load(userptr, "glClearNamedBufferSubDataEXT");
+    context->ClientAttribDefaultEXT = (PFNGLCLIENTATTRIBDEFAULTEXTPROC) load(userptr, "glClientAttribDefaultEXT");
+    context->CompressedMultiTexImage1DEXT = (PFNGLCOMPRESSEDMULTITEXIMAGE1DEXTPROC) load(userptr, "glCompressedMultiTexImage1DEXT");
+    context->CompressedMultiTexImage2DEXT = (PFNGLCOMPRESSEDMULTITEXIMAGE2DEXTPROC) load(userptr, "glCompressedMultiTexImage2DEXT");
+    context->CompressedMultiTexImage3DEXT = (PFNGLCOMPRESSEDMULTITEXIMAGE3DEXTPROC) load(userptr, "glCompressedMultiTexImage3DEXT");
+    context->CompressedMultiTexSubImage1DEXT = (PFNGLCOMPRESSEDMULTITEXSUBIMAGE1DEXTPROC) load(userptr, "glCompressedMultiTexSubImage1DEXT");
+    context->CompressedMultiTexSubImage2DEXT = (PFNGLCOMPRESSEDMULTITEXSUBIMAGE2DEXTPROC) load(userptr, "glCompressedMultiTexSubImage2DEXT");
+    context->CompressedMultiTexSubImage3DEXT = (PFNGLCOMPRESSEDMULTITEXSUBIMAGE3DEXTPROC) load(userptr, "glCompressedMultiTexSubImage3DEXT");
+    context->CompressedTextureImage1DEXT = (PFNGLCOMPRESSEDTEXTUREIMAGE1DEXTPROC) load(userptr, "glCompressedTextureImage1DEXT");
+    context->CompressedTextureImage2DEXT = (PFNGLCOMPRESSEDTEXTUREIMAGE2DEXTPROC) load(userptr, "glCompressedTextureImage2DEXT");
+    context->CompressedTextureImage3DEXT = (PFNGLCOMPRESSEDTEXTUREIMAGE3DEXTPROC) load(userptr, "glCompressedTextureImage3DEXT");
+    context->CompressedTextureSubImage1DEXT = (PFNGLCOMPRESSEDTEXTURESUBIMAGE1DEXTPROC) load(userptr, "glCompressedTextureSubImage1DEXT");
+    context->CompressedTextureSubImage2DEXT = (PFNGLCOMPRESSEDTEXTURESUBIMAGE2DEXTPROC) load(userptr, "glCompressedTextureSubImage2DEXT");
+    context->CompressedTextureSubImage3DEXT = (PFNGLCOMPRESSEDTEXTURESUBIMAGE3DEXTPROC) load(userptr, "glCompressedTextureSubImage3DEXT");
+    context->CopyMultiTexImage1DEXT = (PFNGLCOPYMULTITEXIMAGE1DEXTPROC) load(userptr, "glCopyMultiTexImage1DEXT");
+    context->CopyMultiTexImage2DEXT = (PFNGLCOPYMULTITEXIMAGE2DEXTPROC) load(userptr, "glCopyMultiTexImage2DEXT");
+    context->CopyMultiTexSubImage1DEXT = (PFNGLCOPYMULTITEXSUBIMAGE1DEXTPROC) load(userptr, "glCopyMultiTexSubImage1DEXT");
+    context->CopyMultiTexSubImage2DEXT = (PFNGLCOPYMULTITEXSUBIMAGE2DEXTPROC) load(userptr, "glCopyMultiTexSubImage2DEXT");
+    context->CopyMultiTexSubImage3DEXT = (PFNGLCOPYMULTITEXSUBIMAGE3DEXTPROC) load(userptr, "glCopyMultiTexSubImage3DEXT");
+    context->CopyTextureImage1DEXT = (PFNGLCOPYTEXTUREIMAGE1DEXTPROC) load(userptr, "glCopyTextureImage1DEXT");
+    context->CopyTextureImage2DEXT = (PFNGLCOPYTEXTUREIMAGE2DEXTPROC) load(userptr, "glCopyTextureImage2DEXT");
+    context->CopyTextureSubImage1DEXT = (PFNGLCOPYTEXTURESUBIMAGE1DEXTPROC) load(userptr, "glCopyTextureSubImage1DEXT");
+    context->CopyTextureSubImage2DEXT = (PFNGLCOPYTEXTURESUBIMAGE2DEXTPROC) load(userptr, "glCopyTextureSubImage2DEXT");
+    context->CopyTextureSubImage3DEXT = (PFNGLCOPYTEXTURESUBIMAGE3DEXTPROC) load(userptr, "glCopyTextureSubImage3DEXT");
+    context->DisableClientStateIndexedEXT = (PFNGLDISABLECLIENTSTATEINDEXEDEXTPROC) load(userptr, "glDisableClientStateIndexedEXT");
+    context->DisableClientStateiEXT = (PFNGLDISABLECLIENTSTATEIEXTPROC) load(userptr, "glDisableClientStateiEXT");
+    context->DisableIndexedEXT = (PFNGLDISABLEINDEXEDEXTPROC) load(userptr, "glDisableIndexedEXT");
+    context->DisableVertexArrayAttribEXT = (PFNGLDISABLEVERTEXARRAYATTRIBEXTPROC) load(userptr, "glDisableVertexArrayAttribEXT");
+    context->DisableVertexArrayEXT = (PFNGLDISABLEVERTEXARRAYEXTPROC) load(userptr, "glDisableVertexArrayEXT");
+    context->EnableClientStateIndexedEXT = (PFNGLENABLECLIENTSTATEINDEXEDEXTPROC) load(userptr, "glEnableClientStateIndexedEXT");
+    context->EnableClientStateiEXT = (PFNGLENABLECLIENTSTATEIEXTPROC) load(userptr, "glEnableClientStateiEXT");
+    context->EnableIndexedEXT = (PFNGLENABLEINDEXEDEXTPROC) load(userptr, "glEnableIndexedEXT");
+    context->EnableVertexArrayAttribEXT = (PFNGLENABLEVERTEXARRAYATTRIBEXTPROC) load(userptr, "glEnableVertexArrayAttribEXT");
+    context->EnableVertexArrayEXT = (PFNGLENABLEVERTEXARRAYEXTPROC) load(userptr, "glEnableVertexArrayEXT");
+    context->FlushMappedNamedBufferRangeEXT = (PFNGLFLUSHMAPPEDNAMEDBUFFERRANGEEXTPROC) load(userptr, "glFlushMappedNamedBufferRangeEXT");
+    context->FramebufferDrawBufferEXT = (PFNGLFRAMEBUFFERDRAWBUFFEREXTPROC) load(userptr, "glFramebufferDrawBufferEXT");
+    context->FramebufferDrawBuffersEXT = (PFNGLFRAMEBUFFERDRAWBUFFERSEXTPROC) load(userptr, "glFramebufferDrawBuffersEXT");
+    context->FramebufferReadBufferEXT = (PFNGLFRAMEBUFFERREADBUFFEREXTPROC) load(userptr, "glFramebufferReadBufferEXT");
+    context->GenerateMultiTexMipmapEXT = (PFNGLGENERATEMULTITEXMIPMAPEXTPROC) load(userptr, "glGenerateMultiTexMipmapEXT");
+    context->GenerateTextureMipmapEXT = (PFNGLGENERATETEXTUREMIPMAPEXTPROC) load(userptr, "glGenerateTextureMipmapEXT");
+    context->GetBooleanIndexedvEXT = (PFNGLGETBOOLEANINDEXEDVEXTPROC) load(userptr, "glGetBooleanIndexedvEXT");
+    context->GetCompressedMultiTexImageEXT = (PFNGLGETCOMPRESSEDMULTITEXIMAGEEXTPROC) load(userptr, "glGetCompressedMultiTexImageEXT");
+    context->GetCompressedTextureImageEXT = (PFNGLGETCOMPRESSEDTEXTUREIMAGEEXTPROC) load(userptr, "glGetCompressedTextureImageEXT");
+    context->GetDoubleIndexedvEXT = (PFNGLGETDOUBLEINDEXEDVEXTPROC) load(userptr, "glGetDoubleIndexedvEXT");
+    context->GetDoublei_vEXT = (PFNGLGETDOUBLEI_VEXTPROC) load(userptr, "glGetDoublei_vEXT");
+    context->GetFloatIndexedvEXT = (PFNGLGETFLOATINDEXEDVEXTPROC) load(userptr, "glGetFloatIndexedvEXT");
+    context->GetFloati_vEXT = (PFNGLGETFLOATI_VEXTPROC) load(userptr, "glGetFloati_vEXT");
+    context->GetFramebufferParameterivEXT = (PFNGLGETFRAMEBUFFERPARAMETERIVEXTPROC) load(userptr, "glGetFramebufferParameterivEXT");
+    context->GetIntegerIndexedvEXT = (PFNGLGETINTEGERINDEXEDVEXTPROC) load(userptr, "glGetIntegerIndexedvEXT");
+    context->GetMultiTexEnvfvEXT = (PFNGLGETMULTITEXENVFVEXTPROC) load(userptr, "glGetMultiTexEnvfvEXT");
+    context->GetMultiTexEnvivEXT = (PFNGLGETMULTITEXENVIVEXTPROC) load(userptr, "glGetMultiTexEnvivEXT");
+    context->GetMultiTexGendvEXT = (PFNGLGETMULTITEXGENDVEXTPROC) load(userptr, "glGetMultiTexGendvEXT");
+    context->GetMultiTexGenfvEXT = (PFNGLGETMULTITEXGENFVEXTPROC) load(userptr, "glGetMultiTexGenfvEXT");
+    context->GetMultiTexGenivEXT = (PFNGLGETMULTITEXGENIVEXTPROC) load(userptr, "glGetMultiTexGenivEXT");
+    context->GetMultiTexImageEXT = (PFNGLGETMULTITEXIMAGEEXTPROC) load(userptr, "glGetMultiTexImageEXT");
+    context->GetMultiTexLevelParameterfvEXT = (PFNGLGETMULTITEXLEVELPARAMETERFVEXTPROC) load(userptr, "glGetMultiTexLevelParameterfvEXT");
+    context->GetMultiTexLevelParameterivEXT = (PFNGLGETMULTITEXLEVELPARAMETERIVEXTPROC) load(userptr, "glGetMultiTexLevelParameterivEXT");
+    context->GetMultiTexParameterIivEXT = (PFNGLGETMULTITEXPARAMETERIIVEXTPROC) load(userptr, "glGetMultiTexParameterIivEXT");
+    context->GetMultiTexParameterIuivEXT = (PFNGLGETMULTITEXPARAMETERIUIVEXTPROC) load(userptr, "glGetMultiTexParameterIuivEXT");
+    context->GetMultiTexParameterfvEXT = (PFNGLGETMULTITEXPARAMETERFVEXTPROC) load(userptr, "glGetMultiTexParameterfvEXT");
+    context->GetMultiTexParameterivEXT = (PFNGLGETMULTITEXPARAMETERIVEXTPROC) load(userptr, "glGetMultiTexParameterivEXT");
+    context->GetNamedBufferParameterivEXT = (PFNGLGETNAMEDBUFFERPARAMETERIVEXTPROC) load(userptr, "glGetNamedBufferParameterivEXT");
+    context->GetNamedBufferPointervEXT = (PFNGLGETNAMEDBUFFERPOINTERVEXTPROC) load(userptr, "glGetNamedBufferPointervEXT");
+    context->GetNamedBufferSubDataEXT = (PFNGLGETNAMEDBUFFERSUBDATAEXTPROC) load(userptr, "glGetNamedBufferSubDataEXT");
+    context->GetNamedFramebufferAttachmentParameterivEXT = (PFNGLGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC) load(userptr, "glGetNamedFramebufferAttachmentParameterivEXT");
+    context->GetNamedFramebufferParameterivEXT = (PFNGLGETNAMEDFRAMEBUFFERPARAMETERIVEXTPROC) load(userptr, "glGetNamedFramebufferParameterivEXT");
+    context->GetNamedProgramLocalParameterIivEXT = (PFNGLGETNAMEDPROGRAMLOCALPARAMETERIIVEXTPROC) load(userptr, "glGetNamedProgramLocalParameterIivEXT");
+    context->GetNamedProgramLocalParameterIuivEXT = (PFNGLGETNAMEDPROGRAMLOCALPARAMETERIUIVEXTPROC) load(userptr, "glGetNamedProgramLocalParameterIuivEXT");
+    context->GetNamedProgramLocalParameterdvEXT = (PFNGLGETNAMEDPROGRAMLOCALPARAMETERDVEXTPROC) load(userptr, "glGetNamedProgramLocalParameterdvEXT");
+    context->GetNamedProgramLocalParameterfvEXT = (PFNGLGETNAMEDPROGRAMLOCALPARAMETERFVEXTPROC) load(userptr, "glGetNamedProgramLocalParameterfvEXT");
+    context->GetNamedProgramStringEXT = (PFNGLGETNAMEDPROGRAMSTRINGEXTPROC) load(userptr, "glGetNamedProgramStringEXT");
+    context->GetNamedProgramivEXT = (PFNGLGETNAMEDPROGRAMIVEXTPROC) load(userptr, "glGetNamedProgramivEXT");
+    context->GetNamedRenderbufferParameterivEXT = (PFNGLGETNAMEDRENDERBUFFERPARAMETERIVEXTPROC) load(userptr, "glGetNamedRenderbufferParameterivEXT");
+    context->GetPointerIndexedvEXT = (PFNGLGETPOINTERINDEXEDVEXTPROC) load(userptr, "glGetPointerIndexedvEXT");
+    context->GetPointeri_vEXT = (PFNGLGETPOINTERI_VEXTPROC) load(userptr, "glGetPointeri_vEXT");
+    context->GetTextureImageEXT = (PFNGLGETTEXTUREIMAGEEXTPROC) load(userptr, "glGetTextureImageEXT");
+    context->GetTextureLevelParameterfvEXT = (PFNGLGETTEXTURELEVELPARAMETERFVEXTPROC) load(userptr, "glGetTextureLevelParameterfvEXT");
+    context->GetTextureLevelParameterivEXT = (PFNGLGETTEXTURELEVELPARAMETERIVEXTPROC) load(userptr, "glGetTextureLevelParameterivEXT");
+    context->GetTextureParameterIivEXT = (PFNGLGETTEXTUREPARAMETERIIVEXTPROC) load(userptr, "glGetTextureParameterIivEXT");
+    context->GetTextureParameterIuivEXT = (PFNGLGETTEXTUREPARAMETERIUIVEXTPROC) load(userptr, "glGetTextureParameterIuivEXT");
+    context->GetTextureParameterfvEXT = (PFNGLGETTEXTUREPARAMETERFVEXTPROC) load(userptr, "glGetTextureParameterfvEXT");
+    context->GetTextureParameterivEXT = (PFNGLGETTEXTUREPARAMETERIVEXTPROC) load(userptr, "glGetTextureParameterivEXT");
+    context->GetVertexArrayIntegeri_vEXT = (PFNGLGETVERTEXARRAYINTEGERI_VEXTPROC) load(userptr, "glGetVertexArrayIntegeri_vEXT");
+    context->GetVertexArrayIntegervEXT = (PFNGLGETVERTEXARRAYINTEGERVEXTPROC) load(userptr, "glGetVertexArrayIntegervEXT");
+    context->GetVertexArrayPointeri_vEXT = (PFNGLGETVERTEXARRAYPOINTERI_VEXTPROC) load(userptr, "glGetVertexArrayPointeri_vEXT");
+    context->GetVertexArrayPointervEXT = (PFNGLGETVERTEXARRAYPOINTERVEXTPROC) load(userptr, "glGetVertexArrayPointervEXT");
+    context->IsEnabledIndexedEXT = (PFNGLISENABLEDINDEXEDEXTPROC) load(userptr, "glIsEnabledIndexedEXT");
+    context->MapNamedBufferEXT = (PFNGLMAPNAMEDBUFFEREXTPROC) load(userptr, "glMapNamedBufferEXT");
+    context->MapNamedBufferRangeEXT = (PFNGLMAPNAMEDBUFFERRANGEEXTPROC) load(userptr, "glMapNamedBufferRangeEXT");
+    context->MatrixFrustumEXT = (PFNGLMATRIXFRUSTUMEXTPROC) load(userptr, "glMatrixFrustumEXT");
+    context->MatrixLoadIdentityEXT = (PFNGLMATRIXLOADIDENTITYEXTPROC) load(userptr, "glMatrixLoadIdentityEXT");
+    context->MatrixLoadTransposedEXT = (PFNGLMATRIXLOADTRANSPOSEDEXTPROC) load(userptr, "glMatrixLoadTransposedEXT");
+    context->MatrixLoadTransposefEXT = (PFNGLMATRIXLOADTRANSPOSEFEXTPROC) load(userptr, "glMatrixLoadTransposefEXT");
+    context->MatrixLoaddEXT = (PFNGLMATRIXLOADDEXTPROC) load(userptr, "glMatrixLoaddEXT");
+    context->MatrixLoadfEXT = (PFNGLMATRIXLOADFEXTPROC) load(userptr, "glMatrixLoadfEXT");
+    context->MatrixMultTransposedEXT = (PFNGLMATRIXMULTTRANSPOSEDEXTPROC) load(userptr, "glMatrixMultTransposedEXT");
+    context->MatrixMultTransposefEXT = (PFNGLMATRIXMULTTRANSPOSEFEXTPROC) load(userptr, "glMatrixMultTransposefEXT");
+    context->MatrixMultdEXT = (PFNGLMATRIXMULTDEXTPROC) load(userptr, "glMatrixMultdEXT");
+    context->MatrixMultfEXT = (PFNGLMATRIXMULTFEXTPROC) load(userptr, "glMatrixMultfEXT");
+    context->MatrixOrthoEXT = (PFNGLMATRIXORTHOEXTPROC) load(userptr, "glMatrixOrthoEXT");
+    context->MatrixPopEXT = (PFNGLMATRIXPOPEXTPROC) load(userptr, "glMatrixPopEXT");
+    context->MatrixPushEXT = (PFNGLMATRIXPUSHEXTPROC) load(userptr, "glMatrixPushEXT");
+    context->MatrixRotatedEXT = (PFNGLMATRIXROTATEDEXTPROC) load(userptr, "glMatrixRotatedEXT");
+    context->MatrixRotatefEXT = (PFNGLMATRIXROTATEFEXTPROC) load(userptr, "glMatrixRotatefEXT");
+    context->MatrixScaledEXT = (PFNGLMATRIXSCALEDEXTPROC) load(userptr, "glMatrixScaledEXT");
+    context->MatrixScalefEXT = (PFNGLMATRIXSCALEFEXTPROC) load(userptr, "glMatrixScalefEXT");
+    context->MatrixTranslatedEXT = (PFNGLMATRIXTRANSLATEDEXTPROC) load(userptr, "glMatrixTranslatedEXT");
+    context->MatrixTranslatefEXT = (PFNGLMATRIXTRANSLATEFEXTPROC) load(userptr, "glMatrixTranslatefEXT");
+    context->MultiTexBufferEXT = (PFNGLMULTITEXBUFFEREXTPROC) load(userptr, "glMultiTexBufferEXT");
+    context->MultiTexCoordPointerEXT = (PFNGLMULTITEXCOORDPOINTEREXTPROC) load(userptr, "glMultiTexCoordPointerEXT");
+    context->MultiTexEnvfEXT = (PFNGLMULTITEXENVFEXTPROC) load(userptr, "glMultiTexEnvfEXT");
+    context->MultiTexEnvfvEXT = (PFNGLMULTITEXENVFVEXTPROC) load(userptr, "glMultiTexEnvfvEXT");
+    context->MultiTexEnviEXT = (PFNGLMULTITEXENVIEXTPROC) load(userptr, "glMultiTexEnviEXT");
+    context->MultiTexEnvivEXT = (PFNGLMULTITEXENVIVEXTPROC) load(userptr, "glMultiTexEnvivEXT");
+    context->MultiTexGendEXT = (PFNGLMULTITEXGENDEXTPROC) load(userptr, "glMultiTexGendEXT");
+    context->MultiTexGendvEXT = (PFNGLMULTITEXGENDVEXTPROC) load(userptr, "glMultiTexGendvEXT");
+    context->MultiTexGenfEXT = (PFNGLMULTITEXGENFEXTPROC) load(userptr, "glMultiTexGenfEXT");
+    context->MultiTexGenfvEXT = (PFNGLMULTITEXGENFVEXTPROC) load(userptr, "glMultiTexGenfvEXT");
+    context->MultiTexGeniEXT = (PFNGLMULTITEXGENIEXTPROC) load(userptr, "glMultiTexGeniEXT");
+    context->MultiTexGenivEXT = (PFNGLMULTITEXGENIVEXTPROC) load(userptr, "glMultiTexGenivEXT");
+    context->MultiTexImage1DEXT = (PFNGLMULTITEXIMAGE1DEXTPROC) load(userptr, "glMultiTexImage1DEXT");
+    context->MultiTexImage2DEXT = (PFNGLMULTITEXIMAGE2DEXTPROC) load(userptr, "glMultiTexImage2DEXT");
+    context->MultiTexImage3DEXT = (PFNGLMULTITEXIMAGE3DEXTPROC) load(userptr, "glMultiTexImage3DEXT");
+    context->MultiTexParameterIivEXT = (PFNGLMULTITEXPARAMETERIIVEXTPROC) load(userptr, "glMultiTexParameterIivEXT");
+    context->MultiTexParameterIuivEXT = (PFNGLMULTITEXPARAMETERIUIVEXTPROC) load(userptr, "glMultiTexParameterIuivEXT");
+    context->MultiTexParameterfEXT = (PFNGLMULTITEXPARAMETERFEXTPROC) load(userptr, "glMultiTexParameterfEXT");
+    context->MultiTexParameterfvEXT = (PFNGLMULTITEXPARAMETERFVEXTPROC) load(userptr, "glMultiTexParameterfvEXT");
+    context->MultiTexParameteriEXT = (PFNGLMULTITEXPARAMETERIEXTPROC) load(userptr, "glMultiTexParameteriEXT");
+    context->MultiTexParameterivEXT = (PFNGLMULTITEXPARAMETERIVEXTPROC) load(userptr, "glMultiTexParameterivEXT");
+    context->MultiTexRenderbufferEXT = (PFNGLMULTITEXRENDERBUFFEREXTPROC) load(userptr, "glMultiTexRenderbufferEXT");
+    context->MultiTexSubImage1DEXT = (PFNGLMULTITEXSUBIMAGE1DEXTPROC) load(userptr, "glMultiTexSubImage1DEXT");
+    context->MultiTexSubImage2DEXT = (PFNGLMULTITEXSUBIMAGE2DEXTPROC) load(userptr, "glMultiTexSubImage2DEXT");
+    context->MultiTexSubImage3DEXT = (PFNGLMULTITEXSUBIMAGE3DEXTPROC) load(userptr, "glMultiTexSubImage3DEXT");
+    context->NamedBufferDataEXT = (PFNGLNAMEDBUFFERDATAEXTPROC) load(userptr, "glNamedBufferDataEXT");
+    context->NamedBufferStorageEXT = (PFNGLNAMEDBUFFERSTORAGEEXTPROC) load(userptr, "glNamedBufferStorageEXT");
+    context->NamedBufferSubDataEXT = (PFNGLNAMEDBUFFERSUBDATAEXTPROC) load(userptr, "glNamedBufferSubDataEXT");
+    context->NamedCopyBufferSubDataEXT = (PFNGLNAMEDCOPYBUFFERSUBDATAEXTPROC) load(userptr, "glNamedCopyBufferSubDataEXT");
+    context->NamedFramebufferParameteriEXT = (PFNGLNAMEDFRAMEBUFFERPARAMETERIEXTPROC) load(userptr, "glNamedFramebufferParameteriEXT");
+    context->NamedFramebufferRenderbufferEXT = (PFNGLNAMEDFRAMEBUFFERRENDERBUFFEREXTPROC) load(userptr, "glNamedFramebufferRenderbufferEXT");
+    context->NamedFramebufferTexture1DEXT = (PFNGLNAMEDFRAMEBUFFERTEXTURE1DEXTPROC) load(userptr, "glNamedFramebufferTexture1DEXT");
+    context->NamedFramebufferTexture2DEXT = (PFNGLNAMEDFRAMEBUFFERTEXTURE2DEXTPROC) load(userptr, "glNamedFramebufferTexture2DEXT");
+    context->NamedFramebufferTexture3DEXT = (PFNGLNAMEDFRAMEBUFFERTEXTURE3DEXTPROC) load(userptr, "glNamedFramebufferTexture3DEXT");
+    context->NamedFramebufferTextureEXT = (PFNGLNAMEDFRAMEBUFFERTEXTUREEXTPROC) load(userptr, "glNamedFramebufferTextureEXT");
+    context->NamedFramebufferTextureFaceEXT = (PFNGLNAMEDFRAMEBUFFERTEXTUREFACEEXTPROC) load(userptr, "glNamedFramebufferTextureFaceEXT");
+    context->NamedFramebufferTextureLayerEXT = (PFNGLNAMEDFRAMEBUFFERTEXTURELAYEREXTPROC) load(userptr, "glNamedFramebufferTextureLayerEXT");
+    context->NamedProgramLocalParameter4dEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETER4DEXTPROC) load(userptr, "glNamedProgramLocalParameter4dEXT");
+    context->NamedProgramLocalParameter4dvEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETER4DVEXTPROC) load(userptr, "glNamedProgramLocalParameter4dvEXT");
+    context->NamedProgramLocalParameter4fEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETER4FEXTPROC) load(userptr, "glNamedProgramLocalParameter4fEXT");
+    context->NamedProgramLocalParameter4fvEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETER4FVEXTPROC) load(userptr, "glNamedProgramLocalParameter4fvEXT");
+    context->NamedProgramLocalParameterI4iEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETERI4IEXTPROC) load(userptr, "glNamedProgramLocalParameterI4iEXT");
+    context->NamedProgramLocalParameterI4ivEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETERI4IVEXTPROC) load(userptr, "glNamedProgramLocalParameterI4ivEXT");
+    context->NamedProgramLocalParameterI4uiEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETERI4UIEXTPROC) load(userptr, "glNamedProgramLocalParameterI4uiEXT");
+    context->NamedProgramLocalParameterI4uivEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETERI4UIVEXTPROC) load(userptr, "glNamedProgramLocalParameterI4uivEXT");
+    context->NamedProgramLocalParameters4fvEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETERS4FVEXTPROC) load(userptr, "glNamedProgramLocalParameters4fvEXT");
+    context->NamedProgramLocalParametersI4ivEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETERSI4IVEXTPROC) load(userptr, "glNamedProgramLocalParametersI4ivEXT");
+    context->NamedProgramLocalParametersI4uivEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETERSI4UIVEXTPROC) load(userptr, "glNamedProgramLocalParametersI4uivEXT");
+    context->NamedProgramStringEXT = (PFNGLNAMEDPROGRAMSTRINGEXTPROC) load(userptr, "glNamedProgramStringEXT");
+    context->NamedRenderbufferStorageEXT = (PFNGLNAMEDRENDERBUFFERSTORAGEEXTPROC) load(userptr, "glNamedRenderbufferStorageEXT");
+    context->NamedRenderbufferStorageMultisampleCoverageEXT = (PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLECOVERAGEEXTPROC) load(userptr, "glNamedRenderbufferStorageMultisampleCoverageEXT");
+    context->NamedRenderbufferStorageMultisampleEXT = (PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC) load(userptr, "glNamedRenderbufferStorageMultisampleEXT");
+    context->ProgramUniform1dEXT = (PFNGLPROGRAMUNIFORM1DEXTPROC) load(userptr, "glProgramUniform1dEXT");
+    context->ProgramUniform1dvEXT = (PFNGLPROGRAMUNIFORM1DVEXTPROC) load(userptr, "glProgramUniform1dvEXT");
+    context->ProgramUniform1fEXT = (PFNGLPROGRAMUNIFORM1FEXTPROC) load(userptr, "glProgramUniform1fEXT");
+    context->ProgramUniform1fvEXT = (PFNGLPROGRAMUNIFORM1FVEXTPROC) load(userptr, "glProgramUniform1fvEXT");
+    context->ProgramUniform1iEXT = (PFNGLPROGRAMUNIFORM1IEXTPROC) load(userptr, "glProgramUniform1iEXT");
+    context->ProgramUniform1ivEXT = (PFNGLPROGRAMUNIFORM1IVEXTPROC) load(userptr, "glProgramUniform1ivEXT");
+    context->ProgramUniform1uiEXT = (PFNGLPROGRAMUNIFORM1UIEXTPROC) load(userptr, "glProgramUniform1uiEXT");
+    context->ProgramUniform1uivEXT = (PFNGLPROGRAMUNIFORM1UIVEXTPROC) load(userptr, "glProgramUniform1uivEXT");
+    context->ProgramUniform2dEXT = (PFNGLPROGRAMUNIFORM2DEXTPROC) load(userptr, "glProgramUniform2dEXT");
+    context->ProgramUniform2dvEXT = (PFNGLPROGRAMUNIFORM2DVEXTPROC) load(userptr, "glProgramUniform2dvEXT");
+    context->ProgramUniform2fEXT = (PFNGLPROGRAMUNIFORM2FEXTPROC) load(userptr, "glProgramUniform2fEXT");
+    context->ProgramUniform2fvEXT = (PFNGLPROGRAMUNIFORM2FVEXTPROC) load(userptr, "glProgramUniform2fvEXT");
+    context->ProgramUniform2iEXT = (PFNGLPROGRAMUNIFORM2IEXTPROC) load(userptr, "glProgramUniform2iEXT");
+    context->ProgramUniform2ivEXT = (PFNGLPROGRAMUNIFORM2IVEXTPROC) load(userptr, "glProgramUniform2ivEXT");
+    context->ProgramUniform2uiEXT = (PFNGLPROGRAMUNIFORM2UIEXTPROC) load(userptr, "glProgramUniform2uiEXT");
+    context->ProgramUniform2uivEXT = (PFNGLPROGRAMUNIFORM2UIVEXTPROC) load(userptr, "glProgramUniform2uivEXT");
+    context->ProgramUniform3dEXT = (PFNGLPROGRAMUNIFORM3DEXTPROC) load(userptr, "glProgramUniform3dEXT");
+    context->ProgramUniform3dvEXT = (PFNGLPROGRAMUNIFORM3DVEXTPROC) load(userptr, "glProgramUniform3dvEXT");
+    context->ProgramUniform3fEXT = (PFNGLPROGRAMUNIFORM3FEXTPROC) load(userptr, "glProgramUniform3fEXT");
+    context->ProgramUniform3fvEXT = (PFNGLPROGRAMUNIFORM3FVEXTPROC) load(userptr, "glProgramUniform3fvEXT");
+    context->ProgramUniform3iEXT = (PFNGLPROGRAMUNIFORM3IEXTPROC) load(userptr, "glProgramUniform3iEXT");
+    context->ProgramUniform3ivEXT = (PFNGLPROGRAMUNIFORM3IVEXTPROC) load(userptr, "glProgramUniform3ivEXT");
+    context->ProgramUniform3uiEXT = (PFNGLPROGRAMUNIFORM3UIEXTPROC) load(userptr, "glProgramUniform3uiEXT");
+    context->ProgramUniform3uivEXT = (PFNGLPROGRAMUNIFORM3UIVEXTPROC) load(userptr, "glProgramUniform3uivEXT");
+    context->ProgramUniform4dEXT = (PFNGLPROGRAMUNIFORM4DEXTPROC) load(userptr, "glProgramUniform4dEXT");
+    context->ProgramUniform4dvEXT = (PFNGLPROGRAMUNIFORM4DVEXTPROC) load(userptr, "glProgramUniform4dvEXT");
+    context->ProgramUniform4fEXT = (PFNGLPROGRAMUNIFORM4FEXTPROC) load(userptr, "glProgramUniform4fEXT");
+    context->ProgramUniform4fvEXT = (PFNGLPROGRAMUNIFORM4FVEXTPROC) load(userptr, "glProgramUniform4fvEXT");
+    context->ProgramUniform4iEXT = (PFNGLPROGRAMUNIFORM4IEXTPROC) load(userptr, "glProgramUniform4iEXT");
+    context->ProgramUniform4ivEXT = (PFNGLPROGRAMUNIFORM4IVEXTPROC) load(userptr, "glProgramUniform4ivEXT");
+    context->ProgramUniform4uiEXT = (PFNGLPROGRAMUNIFORM4UIEXTPROC) load(userptr, "glProgramUniform4uiEXT");
+    context->ProgramUniform4uivEXT = (PFNGLPROGRAMUNIFORM4UIVEXTPROC) load(userptr, "glProgramUniform4uivEXT");
+    context->ProgramUniformMatrix2dvEXT = (PFNGLPROGRAMUNIFORMMATRIX2DVEXTPROC) load(userptr, "glProgramUniformMatrix2dvEXT");
+    context->ProgramUniformMatrix2fvEXT = (PFNGLPROGRAMUNIFORMMATRIX2FVEXTPROC) load(userptr, "glProgramUniformMatrix2fvEXT");
+    context->ProgramUniformMatrix2x3dvEXT = (PFNGLPROGRAMUNIFORMMATRIX2X3DVEXTPROC) load(userptr, "glProgramUniformMatrix2x3dvEXT");
+    context->ProgramUniformMatrix2x3fvEXT = (PFNGLPROGRAMUNIFORMMATRIX2X3FVEXTPROC) load(userptr, "glProgramUniformMatrix2x3fvEXT");
+    context->ProgramUniformMatrix2x4dvEXT = (PFNGLPROGRAMUNIFORMMATRIX2X4DVEXTPROC) load(userptr, "glProgramUniformMatrix2x4dvEXT");
+    context->ProgramUniformMatrix2x4fvEXT = (PFNGLPROGRAMUNIFORMMATRIX2X4FVEXTPROC) load(userptr, "glProgramUniformMatrix2x4fvEXT");
+    context->ProgramUniformMatrix3dvEXT = (PFNGLPROGRAMUNIFORMMATRIX3DVEXTPROC) load(userptr, "glProgramUniformMatrix3dvEXT");
+    context->ProgramUniformMatrix3fvEXT = (PFNGLPROGRAMUNIFORMMATRIX3FVEXTPROC) load(userptr, "glProgramUniformMatrix3fvEXT");
+    context->ProgramUniformMatrix3x2dvEXT = (PFNGLPROGRAMUNIFORMMATRIX3X2DVEXTPROC) load(userptr, "glProgramUniformMatrix3x2dvEXT");
+    context->ProgramUniformMatrix3x2fvEXT = (PFNGLPROGRAMUNIFORMMATRIX3X2FVEXTPROC) load(userptr, "glProgramUniformMatrix3x2fvEXT");
+    context->ProgramUniformMatrix3x4dvEXT = (PFNGLPROGRAMUNIFORMMATRIX3X4DVEXTPROC) load(userptr, "glProgramUniformMatrix3x4dvEXT");
+    context->ProgramUniformMatrix3x4fvEXT = (PFNGLPROGRAMUNIFORMMATRIX3X4FVEXTPROC) load(userptr, "glProgramUniformMatrix3x4fvEXT");
+    context->ProgramUniformMatrix4dvEXT = (PFNGLPROGRAMUNIFORMMATRIX4DVEXTPROC) load(userptr, "glProgramUniformMatrix4dvEXT");
+    context->ProgramUniformMatrix4fvEXT = (PFNGLPROGRAMUNIFORMMATRIX4FVEXTPROC) load(userptr, "glProgramUniformMatrix4fvEXT");
+    context->ProgramUniformMatrix4x2dvEXT = (PFNGLPROGRAMUNIFORMMATRIX4X2DVEXTPROC) load(userptr, "glProgramUniformMatrix4x2dvEXT");
+    context->ProgramUniformMatrix4x2fvEXT = (PFNGLPROGRAMUNIFORMMATRIX4X2FVEXTPROC) load(userptr, "glProgramUniformMatrix4x2fvEXT");
+    context->ProgramUniformMatrix4x3dvEXT = (PFNGLPROGRAMUNIFORMMATRIX4X3DVEXTPROC) load(userptr, "glProgramUniformMatrix4x3dvEXT");
+    context->ProgramUniformMatrix4x3fvEXT = (PFNGLPROGRAMUNIFORMMATRIX4X3FVEXTPROC) load(userptr, "glProgramUniformMatrix4x3fvEXT");
+    context->PushClientAttribDefaultEXT = (PFNGLPUSHCLIENTATTRIBDEFAULTEXTPROC) load(userptr, "glPushClientAttribDefaultEXT");
+    context->TextureBufferEXT = (PFNGLTEXTUREBUFFEREXTPROC) load(userptr, "glTextureBufferEXT");
+    context->TextureBufferRangeEXT = (PFNGLTEXTUREBUFFERRANGEEXTPROC) load(userptr, "glTextureBufferRangeEXT");
+    context->TextureImage1DEXT = (PFNGLTEXTUREIMAGE1DEXTPROC) load(userptr, "glTextureImage1DEXT");
+    context->TextureImage2DEXT = (PFNGLTEXTUREIMAGE2DEXTPROC) load(userptr, "glTextureImage2DEXT");
+    context->TextureImage3DEXT = (PFNGLTEXTUREIMAGE3DEXTPROC) load(userptr, "glTextureImage3DEXT");
+    context->TexturePageCommitmentEXT = (PFNGLTEXTUREPAGECOMMITMENTEXTPROC) load(userptr, "glTexturePageCommitmentEXT");
+    context->TextureParameterIivEXT = (PFNGLTEXTUREPARAMETERIIVEXTPROC) load(userptr, "glTextureParameterIivEXT");
+    context->TextureParameterIuivEXT = (PFNGLTEXTUREPARAMETERIUIVEXTPROC) load(userptr, "glTextureParameterIuivEXT");
+    context->TextureParameterfEXT = (PFNGLTEXTUREPARAMETERFEXTPROC) load(userptr, "glTextureParameterfEXT");
+    context->TextureParameterfvEXT = (PFNGLTEXTUREPARAMETERFVEXTPROC) load(userptr, "glTextureParameterfvEXT");
+    context->TextureParameteriEXT = (PFNGLTEXTUREPARAMETERIEXTPROC) load(userptr, "glTextureParameteriEXT");
+    context->TextureParameterivEXT = (PFNGLTEXTUREPARAMETERIVEXTPROC) load(userptr, "glTextureParameterivEXT");
+    context->TextureRenderbufferEXT = (PFNGLTEXTURERENDERBUFFEREXTPROC) load(userptr, "glTextureRenderbufferEXT");
+    context->TextureStorage1DEXT = (PFNGLTEXTURESTORAGE1DEXTPROC) load(userptr, "glTextureStorage1DEXT");
+    context->TextureStorage2DEXT = (PFNGLTEXTURESTORAGE2DEXTPROC) load(userptr, "glTextureStorage2DEXT");
+    context->TextureStorage2DMultisampleEXT = (PFNGLTEXTURESTORAGE2DMULTISAMPLEEXTPROC) load(userptr, "glTextureStorage2DMultisampleEXT");
+    context->TextureStorage3DEXT = (PFNGLTEXTURESTORAGE3DEXTPROC) load(userptr, "glTextureStorage3DEXT");
+    context->TextureStorage3DMultisampleEXT = (PFNGLTEXTURESTORAGE3DMULTISAMPLEEXTPROC) load(userptr, "glTextureStorage3DMultisampleEXT");
+    context->TextureSubImage1DEXT = (PFNGLTEXTURESUBIMAGE1DEXTPROC) load(userptr, "glTextureSubImage1DEXT");
+    context->TextureSubImage2DEXT = (PFNGLTEXTURESUBIMAGE2DEXTPROC) load(userptr, "glTextureSubImage2DEXT");
+    context->TextureSubImage3DEXT = (PFNGLTEXTURESUBIMAGE3DEXTPROC) load(userptr, "glTextureSubImage3DEXT");
+    context->UnmapNamedBufferEXT = (PFNGLUNMAPNAMEDBUFFEREXTPROC) load(userptr, "glUnmapNamedBufferEXT");
+    context->VertexArrayBindVertexBufferEXT = (PFNGLVERTEXARRAYBINDVERTEXBUFFEREXTPROC) load(userptr, "glVertexArrayBindVertexBufferEXT");
+    context->VertexArrayColorOffsetEXT = (PFNGLVERTEXARRAYCOLOROFFSETEXTPROC) load(userptr, "glVertexArrayColorOffsetEXT");
+    context->VertexArrayEdgeFlagOffsetEXT = (PFNGLVERTEXARRAYEDGEFLAGOFFSETEXTPROC) load(userptr, "glVertexArrayEdgeFlagOffsetEXT");
+    context->VertexArrayFogCoordOffsetEXT = (PFNGLVERTEXARRAYFOGCOORDOFFSETEXTPROC) load(userptr, "glVertexArrayFogCoordOffsetEXT");
+    context->VertexArrayIndexOffsetEXT = (PFNGLVERTEXARRAYINDEXOFFSETEXTPROC) load(userptr, "glVertexArrayIndexOffsetEXT");
+    context->VertexArrayMultiTexCoordOffsetEXT = (PFNGLVERTEXARRAYMULTITEXCOORDOFFSETEXTPROC) load(userptr, "glVertexArrayMultiTexCoordOffsetEXT");
+    context->VertexArrayNormalOffsetEXT = (PFNGLVERTEXARRAYNORMALOFFSETEXTPROC) load(userptr, "glVertexArrayNormalOffsetEXT");
+    context->VertexArraySecondaryColorOffsetEXT = (PFNGLVERTEXARRAYSECONDARYCOLOROFFSETEXTPROC) load(userptr, "glVertexArraySecondaryColorOffsetEXT");
+    context->VertexArrayTexCoordOffsetEXT = (PFNGLVERTEXARRAYTEXCOORDOFFSETEXTPROC) load(userptr, "glVertexArrayTexCoordOffsetEXT");
+    context->VertexArrayVertexAttribBindingEXT = (PFNGLVERTEXARRAYVERTEXATTRIBBINDINGEXTPROC) load(userptr, "glVertexArrayVertexAttribBindingEXT");
+    context->VertexArrayVertexAttribDivisorEXT = (PFNGLVERTEXARRAYVERTEXATTRIBDIVISOREXTPROC) load(userptr, "glVertexArrayVertexAttribDivisorEXT");
+    context->VertexArrayVertexAttribFormatEXT = (PFNGLVERTEXARRAYVERTEXATTRIBFORMATEXTPROC) load(userptr, "glVertexArrayVertexAttribFormatEXT");
+    context->VertexArrayVertexAttribIFormatEXT = (PFNGLVERTEXARRAYVERTEXATTRIBIFORMATEXTPROC) load(userptr, "glVertexArrayVertexAttribIFormatEXT");
+    context->VertexArrayVertexAttribIOffsetEXT = (PFNGLVERTEXARRAYVERTEXATTRIBIOFFSETEXTPROC) load(userptr, "glVertexArrayVertexAttribIOffsetEXT");
+    context->VertexArrayVertexAttribLFormatEXT = (PFNGLVERTEXARRAYVERTEXATTRIBLFORMATEXTPROC) load(userptr, "glVertexArrayVertexAttribLFormatEXT");
+    context->VertexArrayVertexAttribLOffsetEXT = (PFNGLVERTEXARRAYVERTEXATTRIBLOFFSETEXTPROC) load(userptr, "glVertexArrayVertexAttribLOffsetEXT");
+    context->VertexArrayVertexAttribOffsetEXT = (PFNGLVERTEXARRAYVERTEXATTRIBOFFSETEXTPROC) load(userptr, "glVertexArrayVertexAttribOffsetEXT");
+    context->VertexArrayVertexBindingDivisorEXT = (PFNGLVERTEXARRAYVERTEXBINDINGDIVISOREXTPROC) load(userptr, "glVertexArrayVertexBindingDivisorEXT");
+    context->VertexArrayVertexOffsetEXT = (PFNGLVERTEXARRAYVERTEXOFFSETEXTPROC) load(userptr, "glVertexArrayVertexOffsetEXT");
+}
+static void glad_gl_load_GL_EXT_draw_buffers2(GladGLContext *context, GLADuserptrloadfunc load, void* userptr) {
+    if(!context->EXT_draw_buffers2) return;
+    context->ColorMaskIndexedEXT = (PFNGLCOLORMASKINDEXEDEXTPROC) load(userptr, "glColorMaskIndexedEXT");
+    context->DisableIndexedEXT = (PFNGLDISABLEINDEXEDEXTPROC) load(userptr, "glDisableIndexedEXT");
+    context->EnableIndexedEXT = (PFNGLENABLEINDEXEDEXTPROC) load(userptr, "glEnableIndexedEXT");
+    context->GetBooleanIndexedvEXT = (PFNGLGETBOOLEANINDEXEDVEXTPROC) load(userptr, "glGetBooleanIndexedvEXT");
+    context->GetIntegerIndexedvEXT = (PFNGLGETINTEGERINDEXEDVEXTPROC) load(userptr, "glGetIntegerIndexedvEXT");
+    context->IsEnabledIndexedEXT = (PFNGLISENABLEDINDEXEDEXTPROC) load(userptr, "glIsEnabledIndexedEXT");
+}
+static void glad_gl_load_GL_EXT_draw_instanced(GladGLContext *context, GLADuserptrloadfunc load, void* userptr) {
+    if(!context->EXT_draw_instanced) return;
+    context->DrawArraysInstancedEXT = (PFNGLDRAWARRAYSINSTANCEDEXTPROC) load(userptr, "glDrawArraysInstancedEXT");
+    context->DrawElementsInstancedEXT = (PFNGLDRAWELEMENTSINSTANCEDEXTPROC) load(userptr, "glDrawElementsInstancedEXT");
+}
+static void glad_gl_load_GL_EXT_draw_range_elements(GladGLContext *context, GLADuserptrloadfunc load, void* userptr) {
+    if(!context->EXT_draw_range_elements) return;
+    context->DrawRangeElementsEXT = (PFNGLDRAWRANGEELEMENTSEXTPROC) load(userptr, "glDrawRangeElementsEXT");
+}
+static void glad_gl_load_GL_EXT_framebuffer_blit(GladGLContext *context, GLADuserptrloadfunc load, void* userptr) {
+    if(!context->EXT_framebuffer_blit) return;
+    context->BlitFramebufferEXT = (PFNGLBLITFRAMEBUFFEREXTPROC) load(userptr, "glBlitFramebufferEXT");
+}
+static void glad_gl_load_GL_EXT_framebuffer_multisample(GladGLContext *context, GLADuserptrloadfunc load, void* userptr) {
+    if(!context->EXT_framebuffer_multisample) return;
+    context->RenderbufferStorageMultisampleEXT = (PFNGLRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC) load(userptr, "glRenderbufferStorageMultisampleEXT");
+}
+static void glad_gl_load_GL_EXT_framebuffer_object(GladGLContext *context, GLADuserptrloadfunc load, void* userptr) {
+    if(!context->EXT_framebuffer_object) return;
+    context->BindFramebufferEXT = (PFNGLBINDFRAMEBUFFEREXTPROC) load(userptr, "glBindFramebufferEXT");
+    context->BindRenderbufferEXT = (PFNGLBINDRENDERBUFFEREXTPROC) load(userptr, "glBindRenderbufferEXT");
+    context->CheckFramebufferStatusEXT = (PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC) load(userptr, "glCheckFramebufferStatusEXT");
+    context->DeleteFramebuffersEXT = (PFNGLDELETEFRAMEBUFFERSEXTPROC) load(userptr, "glDeleteFramebuffersEXT");
+    context->DeleteRenderbuffersEXT = (PFNGLDELETERENDERBUFFERSEXTPROC) load(userptr, "glDeleteRenderbuffersEXT");
+    context->FramebufferRenderbufferEXT = (PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC) load(userptr, "glFramebufferRenderbufferEXT");
+    context->FramebufferTexture1DEXT = (PFNGLFRAMEBUFFERTEXTURE1DEXTPROC) load(userptr, "glFramebufferTexture1DEXT");
+    context->FramebufferTexture2DEXT = (PFNGLFRAMEBUFFERTEXTURE2DEXTPROC) load(userptr, "glFramebufferTexture2DEXT");
+    context->FramebufferTexture3DEXT = (PFNGLFRAMEBUFFERTEXTURE3DEXTPROC) load(userptr, "glFramebufferTexture3DEXT");
+    context->GenFramebuffersEXT = (PFNGLGENFRAMEBUFFERSEXTPROC) load(userptr, "glGenFramebuffersEXT");
+    context->GenRenderbuffersEXT = (PFNGLGENRENDERBUFFERSEXTPROC) load(userptr, "glGenRenderbuffersEXT");
+    context->GenerateMipmapEXT = (PFNGLGENERATEMIPMAPEXTPROC) load(userptr, "glGenerateMipmapEXT");
+    context->GetFramebufferAttachmentParameterivEXT = (PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC) load(userptr, "glGetFramebufferAttachmentParameterivEXT");
+    context->GetRenderbufferParameterivEXT = (PFNGLGETRENDERBUFFERPARAMETERIVEXTPROC) load(userptr, "glGetRenderbufferParameterivEXT");
+    context->IsFramebufferEXT = (PFNGLISFRAMEBUFFEREXTPROC) load(userptr, "glIsFramebufferEXT");
+    context->IsRenderbufferEXT = (PFNGLISRENDERBUFFEREXTPROC) load(userptr, "glIsRenderbufferEXT");
+    context->RenderbufferStorageEXT = (PFNGLRENDERBUFFERSTORAGEEXTPROC) load(userptr, "glRenderbufferStorageEXT");
+}
+static void glad_gl_load_GL_EXT_gpu_shader4(GladGLContext *context, GLADuserptrloadfunc load, void* userptr) {
+    if(!context->EXT_gpu_shader4) return;
+    context->BindFragDataLocationEXT = (PFNGLBINDFRAGDATALOCATIONEXTPROC) load(userptr, "glBindFragDataLocationEXT");
+    context->GetFragDataLocationEXT = (PFNGLGETFRAGDATALOCATIONEXTPROC) load(userptr, "glGetFragDataLocationEXT");
+    context->GetUniformuivEXT = (PFNGLGETUNIFORMUIVEXTPROC) load(userptr, "glGetUniformuivEXT");
+    context->GetVertexAttribIivEXT = (PFNGLGETVERTEXATTRIBIIVEXTPROC) load(userptr, "glGetVertexAttribIivEXT");
+    context->GetVertexAttribIuivEXT = (PFNGLGETVERTEXATTRIBIUIVEXTPROC) load(userptr, "glGetVertexAttribIuivEXT");
+    context->Uniform1uiEXT = (PFNGLUNIFORM1UIEXTPROC) load(userptr, "glUniform1uiEXT");
+    context->Uniform1uivEXT = (PFNGLUNIFORM1UIVEXTPROC) load(userptr, "glUniform1uivEXT");
+    context->Uniform2uiEXT = (PFNGLUNIFORM2UIEXTPROC) load(userptr, "glUniform2uiEXT");
+    context->Uniform2uivEXT = (PFNGLUNIFORM2UIVEXTPROC) load(userptr, "glUniform2uivEXT");
+    context->Uniform3uiEXT = (PFNGLUNIFORM3UIEXTPROC) load(userptr, "glUniform3uiEXT");
+    context->Uniform3uivEXT = (PFNGLUNIFORM3UIVEXTPROC) load(userptr, "glUniform3uivEXT");
+    context->Uniform4uiEXT = (PFNGLUNIFORM4UIEXTPROC) load(userptr, "glUniform4uiEXT");
+    context->Uniform4uivEXT = (PFNGLUNIFORM4UIVEXTPROC) load(userptr, "glUniform4uivEXT");
+    context->VertexAttribI1iEXT = (PFNGLVERTEXATTRIBI1IEXTPROC) load(userptr, "glVertexAttribI1iEXT");
+    context->VertexAttribI1ivEXT = (PFNGLVERTEXATTRIBI1IVEXTPROC) load(userptr, "glVertexAttribI1ivEXT");
+    context->VertexAttribI1uiEXT = (PFNGLVERTEXATTRIBI1UIEXTPROC) load(userptr, "glVertexAttribI1uiEXT");
+    context->VertexAttribI1uivEXT = (PFNGLVERTEXATTRIBI1UIVEXTPROC) load(userptr, "glVertexAttribI1uivEXT");
+    context->VertexAttribI2iEXT = (PFNGLVERTEXATTRIBI2IEXTPROC) load(userptr, "glVertexAttribI2iEXT");
+    context->VertexAttribI2ivEXT = (PFNGLVERTEXATTRIBI2IVEXTPROC) load(userptr, "glVertexAttribI2ivEXT");
+    context->VertexAttribI2uiEXT = (PFNGLVERTEXATTRIBI2UIEXTPROC) load(userptr, "glVertexAttribI2uiEXT");
+    context->VertexAttribI2uivEXT = (PFNGLVERTEXATTRIBI2UIVEXTPROC) load(userptr, "glVertexAttribI2uivEXT");
+    context->VertexAttribI3iEXT = (PFNGLVERTEXATTRIBI3IEXTPROC) load(userptr, "glVertexAttribI3iEXT");
+    context->VertexAttribI3ivEXT = (PFNGLVERTEXATTRIBI3IVEXTPROC) load(userptr, "glVertexAttribI3ivEXT");
+    context->VertexAttribI3uiEXT = (PFNGLVERTEXATTRIBI3UIEXTPROC) load(userptr, "glVertexAttribI3uiEXT");
+    context->VertexAttribI3uivEXT = (PFNGLVERTEXATTRIBI3UIVEXTPROC) load(userptr, "glVertexAttribI3uivEXT");
+    context->VertexAttribI4bvEXT = (PFNGLVERTEXATTRIBI4BVEXTPROC) load(userptr, "glVertexAttribI4bvEXT");
+    context->VertexAttribI4iEXT = (PFNGLVERTEXATTRIBI4IEXTPROC) load(userptr, "glVertexAttribI4iEXT");
+    context->VertexAttribI4ivEXT = (PFNGLVERTEXATTRIBI4IVEXTPROC) load(userptr, "glVertexAttribI4ivEXT");
+    context->VertexAttribI4svEXT = (PFNGLVERTEXATTRIBI4SVEXTPROC) load(userptr, "glVertexAttribI4svEXT");
+    context->VertexAttribI4ubvEXT = (PFNGLVERTEXATTRIBI4UBVEXTPROC) load(userptr, "glVertexAttribI4ubvEXT");
+    context->VertexAttribI4uiEXT = (PFNGLVERTEXATTRIBI4UIEXTPROC) load(userptr, "glVertexAttribI4uiEXT");
+    context->VertexAttribI4uivEXT = (PFNGLVERTEXATTRIBI4UIVEXTPROC) load(userptr, "glVertexAttribI4uivEXT");
+    context->VertexAttribI4usvEXT = (PFNGLVERTEXATTRIBI4USVEXTPROC) load(userptr, "glVertexAttribI4usvEXT");
+    context->VertexAttribIPointerEXT = (PFNGLVERTEXATTRIBIPOINTEREXTPROC) load(userptr, "glVertexAttribIPointerEXT");
+}
+static void glad_gl_load_GL_EXT_multi_draw_arrays(GladGLContext *context, GLADuserptrloadfunc load, void* userptr) {
+    if(!context->EXT_multi_draw_arrays) return;
+    context->MultiDrawArraysEXT = (PFNGLMULTIDRAWARRAYSEXTPROC) load(userptr, "glMultiDrawArraysEXT");
+    context->MultiDrawElementsEXT = (PFNGLMULTIDRAWELEMENTSEXTPROC) load(userptr, "glMultiDrawElementsEXT");
+}
+static void glad_gl_load_GL_EXT_point_parameters(GladGLContext *context, GLADuserptrloadfunc load, void* userptr) {
+    if(!context->EXT_point_parameters) return;
+    context->PointParameterfEXT = (PFNGLPOINTPARAMETERFEXTPROC) load(userptr, "glPointParameterfEXT");
+    context->PointParameterfvEXT = (PFNGLPOINTPARAMETERFVEXTPROC) load(userptr, "glPointParameterfvEXT");
+}
+static void glad_gl_load_GL_EXT_provoking_vertex(GladGLContext *context, GLADuserptrloadfunc load, void* userptr) {
+    if(!context->EXT_provoking_vertex) return;
+    context->ProvokingVertexEXT = (PFNGLPROVOKINGVERTEXEXTPROC) load(userptr, "glProvokingVertexEXT");
+}
+static void glad_gl_load_GL_EXT_subtexture(GladGLContext *context, GLADuserptrloadfunc load, void* userptr) {
+    if(!context->EXT_subtexture) return;
+    context->TexSubImage1DEXT = (PFNGLTEXSUBIMAGE1DEXTPROC) load(userptr, "glTexSubImage1DEXT");
+    context->TexSubImage2DEXT = (PFNGLTEXSUBIMAGE2DEXTPROC) load(userptr, "glTexSubImage2DEXT");
+}
+static void glad_gl_load_GL_EXT_texture3D(GladGLContext *context, GLADuserptrloadfunc load, void* userptr) {
+    if(!context->EXT_texture3D) return;
+    context->TexImage3DEXT = (PFNGLTEXIMAGE3DEXTPROC) load(userptr, "glTexImage3DEXT");
+    context->TexSubImage3DEXT = (PFNGLTEXSUBIMAGE3DEXTPROC) load(userptr, "glTexSubImage3DEXT");
+}
+static void glad_gl_load_GL_EXT_texture_array(GladGLContext *context, GLADuserptrloadfunc load, void* userptr) {
+    if(!context->EXT_texture_array) return;
+    context->FramebufferTextureLayerEXT = (PFNGLFRAMEBUFFERTEXTURELAYEREXTPROC) load(userptr, "glFramebufferTextureLayerEXT");
+}
+static void glad_gl_load_GL_EXT_texture_buffer_object(GladGLContext *context, GLADuserptrloadfunc load, void* userptr) {
+    if(!context->EXT_texture_buffer_object) return;
+    context->TexBufferEXT = (PFNGLTEXBUFFEREXTPROC) load(userptr, "glTexBufferEXT");
+}
+static void glad_gl_load_GL_EXT_texture_integer(GladGLContext *context, GLADuserptrloadfunc load, void* userptr) {
+    if(!context->EXT_texture_integer) return;
+    context->ClearColorIiEXT = (PFNGLCLEARCOLORIIEXTPROC) load(userptr, "glClearColorIiEXT");
+    context->ClearColorIuiEXT = (PFNGLCLEARCOLORIUIEXTPROC) load(userptr, "glClearColorIuiEXT");
+    context->GetTexParameterIivEXT = (PFNGLGETTEXPARAMETERIIVEXTPROC) load(userptr, "glGetTexParameterIivEXT");
+    context->GetTexParameterIuivEXT = (PFNGLGETTEXPARAMETERIUIVEXTPROC) load(userptr, "glGetTexParameterIuivEXT");
+    context->TexParameterIivEXT = (PFNGLTEXPARAMETERIIVEXTPROC) load(userptr, "glTexParameterIivEXT");
+    context->TexParameterIuivEXT = (PFNGLTEXPARAMETERIUIVEXTPROC) load(userptr, "glTexParameterIuivEXT");
+}
+static void glad_gl_load_GL_EXT_texture_object(GladGLContext *context, GLADuserptrloadfunc load, void* userptr) {
+    if(!context->EXT_texture_object) return;
+    context->AreTexturesResidentEXT = (PFNGLARETEXTURESRESIDENTEXTPROC) load(userptr, "glAreTexturesResidentEXT");
+    context->BindTextureEXT = (PFNGLBINDTEXTUREEXTPROC) load(userptr, "glBindTextureEXT");
+    context->DeleteTexturesEXT = (PFNGLDELETETEXTURESEXTPROC) load(userptr, "glDeleteTexturesEXT");
+    context->GenTexturesEXT = (PFNGLGENTEXTURESEXTPROC) load(userptr, "glGenTexturesEXT");
+    context->IsTextureEXT = (PFNGLISTEXTUREEXTPROC) load(userptr, "glIsTextureEXT");
+    context->PrioritizeTexturesEXT = (PFNGLPRIORITIZETEXTURESEXTPROC) load(userptr, "glPrioritizeTexturesEXT");
+}
+static void glad_gl_load_GL_EXT_transform_feedback(GladGLContext *context, GLADuserptrloadfunc load, void* userptr) {
+    if(!context->EXT_transform_feedback) return;
+    context->BeginTransformFeedbackEXT = (PFNGLBEGINTRANSFORMFEEDBACKEXTPROC) load(userptr, "glBeginTransformFeedbackEXT");
+    context->BindBufferBaseEXT = (PFNGLBINDBUFFERBASEEXTPROC) load(userptr, "glBindBufferBaseEXT");
+    context->BindBufferOffsetEXT = (PFNGLBINDBUFFEROFFSETEXTPROC) load(userptr, "glBindBufferOffsetEXT");
+    context->BindBufferRangeEXT = (PFNGLBINDBUFFERRANGEEXTPROC) load(userptr, "glBindBufferRangeEXT");
+    context->EndTransformFeedbackEXT = (PFNGLENDTRANSFORMFEEDBACKEXTPROC) load(userptr, "glEndTransformFeedbackEXT");
+    context->GetTransformFeedbackVaryingEXT = (PFNGLGETTRANSFORMFEEDBACKVARYINGEXTPROC) load(userptr, "glGetTransformFeedbackVaryingEXT");
+    context->TransformFeedbackVaryingsEXT = (PFNGLTRANSFORMFEEDBACKVARYINGSEXTPROC) load(userptr, "glTransformFeedbackVaryingsEXT");
+}
+static void glad_gl_load_GL_EXT_vertex_array(GladGLContext *context, GLADuserptrloadfunc load, void* userptr) {
+    if(!context->EXT_vertex_array) return;
+    context->ArrayElementEXT = (PFNGLARRAYELEMENTEXTPROC) load(userptr, "glArrayElementEXT");
+    context->ColorPointerEXT = (PFNGLCOLORPOINTEREXTPROC) load(userptr, "glColorPointerEXT");
+    context->DrawArraysEXT = (PFNGLDRAWARRAYSEXTPROC) load(userptr, "glDrawArraysEXT");
+    context->EdgeFlagPointerEXT = (PFNGLEDGEFLAGPOINTEREXTPROC) load(userptr, "glEdgeFlagPointerEXT");
+    context->GetPointervEXT = (PFNGLGETPOINTERVEXTPROC) load(userptr, "glGetPointervEXT");
+    context->IndexPointerEXT = (PFNGLINDEXPOINTEREXTPROC) load(userptr, "glIndexPointerEXT");
+    context->NormalPointerEXT = (PFNGLNORMALPOINTEREXTPROC) load(userptr, "glNormalPointerEXT");
+    context->TexCoordPointerEXT = (PFNGLTEXCOORDPOINTEREXTPROC) load(userptr, "glTexCoordPointerEXT");
+    context->VertexPointerEXT = (PFNGLVERTEXPOINTEREXTPROC) load(userptr, "glVertexPointerEXT");
+}
+static void glad_gl_load_GL_INGR_blend_func_separate(GladGLContext *context, GLADuserptrloadfunc load, void* userptr) {
+    if(!context->INGR_blend_func_separate) return;
+    context->BlendFuncSeparateINGR = (PFNGLBLENDFUNCSEPARATEINGRPROC) load(userptr, "glBlendFuncSeparateINGR");
+}
+static void glad_gl_load_GL_NVX_conditional_render(GladGLContext *context, GLADuserptrloadfunc load, void* userptr) {
+    if(!context->NVX_conditional_render) return;
+    context->BeginConditionalRenderNVX = (PFNGLBEGINCONDITIONALRENDERNVXPROC) load(userptr, "glBeginConditionalRenderNVX");
+    context->EndConditionalRenderNVX = (PFNGLENDCONDITIONALRENDERNVXPROC) load(userptr, "glEndConditionalRenderNVX");
+}
+static void glad_gl_load_GL_NV_conditional_render(GladGLContext *context, GLADuserptrloadfunc load, void* userptr) {
+    if(!context->NV_conditional_render) return;
+    context->BeginConditionalRenderNV = (PFNGLBEGINCONDITIONALRENDERNVPROC) load(userptr, "glBeginConditionalRenderNV");
+    context->EndConditionalRenderNV = (PFNGLENDCONDITIONALRENDERNVPROC) load(userptr, "glEndConditionalRenderNV");
+}
+static void glad_gl_load_GL_NV_explicit_multisample(GladGLContext *context, GLADuserptrloadfunc load, void* userptr) {
+    if(!context->NV_explicit_multisample) return;
+    context->GetMultisamplefvNV = (PFNGLGETMULTISAMPLEFVNVPROC) load(userptr, "glGetMultisamplefvNV");
+    context->SampleMaskIndexedNV = (PFNGLSAMPLEMASKINDEXEDNVPROC) load(userptr, "glSampleMaskIndexedNV");
+    context->TexRenderbufferNV = (PFNGLTEXRENDERBUFFERNVPROC) load(userptr, "glTexRenderbufferNV");
+}
+static void glad_gl_load_GL_NV_geometry_program4(GladGLContext *context, GLADuserptrloadfunc load, void* userptr) {
+    if(!context->NV_geometry_program4) return;
+    context->FramebufferTextureEXT = (PFNGLFRAMEBUFFERTEXTUREEXTPROC) load(userptr, "glFramebufferTextureEXT");
+    context->FramebufferTextureFaceEXT = (PFNGLFRAMEBUFFERTEXTUREFACEEXTPROC) load(userptr, "glFramebufferTextureFaceEXT");
+    context->FramebufferTextureLayerEXT = (PFNGLFRAMEBUFFERTEXTURELAYEREXTPROC) load(userptr, "glFramebufferTextureLayerEXT");
+    context->ProgramVertexLimitNV = (PFNGLPROGRAMVERTEXLIMITNVPROC) load(userptr, "glProgramVertexLimitNV");
+}
+static void glad_gl_load_GL_NV_point_sprite(GladGLContext *context, GLADuserptrloadfunc load, void* userptr) {
+    if(!context->NV_point_sprite) return;
+    context->PointParameteriNV = (PFNGLPOINTPARAMETERINVPROC) load(userptr, "glPointParameteriNV");
+    context->PointParameterivNV = (PFNGLPOINTPARAMETERIVNVPROC) load(userptr, "glPointParameterivNV");
+}
+static void glad_gl_load_GL_NV_transform_feedback(GladGLContext *context, GLADuserptrloadfunc load, void* userptr) {
+    if(!context->NV_transform_feedback) return;
+    context->ActiveVaryingNV = (PFNGLACTIVEVARYINGNVPROC) load(userptr, "glActiveVaryingNV");
+    context->BeginTransformFeedbackNV = (PFNGLBEGINTRANSFORMFEEDBACKNVPROC) load(userptr, "glBeginTransformFeedbackNV");
+    context->BindBufferBaseNV = (PFNGLBINDBUFFERBASENVPROC) load(userptr, "glBindBufferBaseNV");
+    context->BindBufferOffsetNV = (PFNGLBINDBUFFEROFFSETNVPROC) load(userptr, "glBindBufferOffsetNV");
+    context->BindBufferRangeNV = (PFNGLBINDBUFFERRANGENVPROC) load(userptr, "glBindBufferRangeNV");
+    context->EndTransformFeedbackNV = (PFNGLENDTRANSFORMFEEDBACKNVPROC) load(userptr, "glEndTransformFeedbackNV");
+    context->GetActiveVaryingNV = (PFNGLGETACTIVEVARYINGNVPROC) load(userptr, "glGetActiveVaryingNV");
+    context->GetTransformFeedbackVaryingNV = (PFNGLGETTRANSFORMFEEDBACKVARYINGNVPROC) load(userptr, "glGetTransformFeedbackVaryingNV");
+    context->GetVaryingLocationNV = (PFNGLGETVARYINGLOCATIONNVPROC) load(userptr, "glGetVaryingLocationNV");
+    context->TransformFeedbackAttribsNV = (PFNGLTRANSFORMFEEDBACKATTRIBSNVPROC) load(userptr, "glTransformFeedbackAttribsNV");
+    context->TransformFeedbackStreamAttribsNV = (PFNGLTRANSFORMFEEDBACKSTREAMATTRIBSNVPROC) load(userptr, "glTransformFeedbackStreamAttribsNV");
+    context->TransformFeedbackVaryingsNV = (PFNGLTRANSFORMFEEDBACKVARYINGSNVPROC) load(userptr, "glTransformFeedbackVaryingsNV");
+}
+static void glad_gl_load_GL_NV_vertex_program(GladGLContext *context, GLADuserptrloadfunc load, void* userptr) {
+    if(!context->NV_vertex_program) return;
+    context->AreProgramsResidentNV = (PFNGLAREPROGRAMSRESIDENTNVPROC) load(userptr, "glAreProgramsResidentNV");
+    context->BindProgramNV = (PFNGLBINDPROGRAMNVPROC) load(userptr, "glBindProgramNV");
+    context->DeleteProgramsNV = (PFNGLDELETEPROGRAMSNVPROC) load(userptr, "glDeleteProgramsNV");
+    context->ExecuteProgramNV = (PFNGLEXECUTEPROGRAMNVPROC) load(userptr, "glExecuteProgramNV");
+    context->GenProgramsNV = (PFNGLGENPROGRAMSNVPROC) load(userptr, "glGenProgramsNV");
+    context->GetProgramParameterdvNV = (PFNGLGETPROGRAMPARAMETERDVNVPROC) load(userptr, "glGetProgramParameterdvNV");
+    context->GetProgramParameterfvNV = (PFNGLGETPROGRAMPARAMETERFVNVPROC) load(userptr, "glGetProgramParameterfvNV");
+    context->GetProgramStringNV = (PFNGLGETPROGRAMSTRINGNVPROC) load(userptr, "glGetProgramStringNV");
+    context->GetProgramivNV = (PFNGLGETPROGRAMIVNVPROC) load(userptr, "glGetProgramivNV");
+    context->GetTrackMatrixivNV = (PFNGLGETTRACKMATRIXIVNVPROC) load(userptr, "glGetTrackMatrixivNV");
+    context->GetVertexAttribPointervNV = (PFNGLGETVERTEXATTRIBPOINTERVNVPROC) load(userptr, "glGetVertexAttribPointervNV");
+    context->GetVertexAttribdvNV = (PFNGLGETVERTEXATTRIBDVNVPROC) load(userptr, "glGetVertexAttribdvNV");
+    context->GetVertexAttribfvNV = (PFNGLGETVERTEXATTRIBFVNVPROC) load(userptr, "glGetVertexAttribfvNV");
+    context->GetVertexAttribivNV = (PFNGLGETVERTEXATTRIBIVNVPROC) load(userptr, "glGetVertexAttribivNV");
+    context->IsProgramNV = (PFNGLISPROGRAMNVPROC) load(userptr, "glIsProgramNV");
+    context->LoadProgramNV = (PFNGLLOADPROGRAMNVPROC) load(userptr, "glLoadProgramNV");
+    context->ProgramParameter4dNV = (PFNGLPROGRAMPARAMETER4DNVPROC) load(userptr, "glProgramParameter4dNV");
+    context->ProgramParameter4dvNV = (PFNGLPROGRAMPARAMETER4DVNVPROC) load(userptr, "glProgramParameter4dvNV");
+    context->ProgramParameter4fNV = (PFNGLPROGRAMPARAMETER4FNVPROC) load(userptr, "glProgramParameter4fNV");
+    context->ProgramParameter4fvNV = (PFNGLPROGRAMPARAMETER4FVNVPROC) load(userptr, "glProgramParameter4fvNV");
+    context->ProgramParameters4dvNV = (PFNGLPROGRAMPARAMETERS4DVNVPROC) load(userptr, "glProgramParameters4dvNV");
+    context->ProgramParameters4fvNV = (PFNGLPROGRAMPARAMETERS4FVNVPROC) load(userptr, "glProgramParameters4fvNV");
+    context->RequestResidentProgramsNV = (PFNGLREQUESTRESIDENTPROGRAMSNVPROC) load(userptr, "glRequestResidentProgramsNV");
+    context->TrackMatrixNV = (PFNGLTRACKMATRIXNVPROC) load(userptr, "glTrackMatrixNV");
+    context->VertexAttrib1dNV = (PFNGLVERTEXATTRIB1DNVPROC) load(userptr, "glVertexAttrib1dNV");
+    context->VertexAttrib1dvNV = (PFNGLVERTEXATTRIB1DVNVPROC) load(userptr, "glVertexAttrib1dvNV");
+    context->VertexAttrib1fNV = (PFNGLVERTEXATTRIB1FNVPROC) load(userptr, "glVertexAttrib1fNV");
+    context->VertexAttrib1fvNV = (PFNGLVERTEXATTRIB1FVNVPROC) load(userptr, "glVertexAttrib1fvNV");
+    context->VertexAttrib1sNV = (PFNGLVERTEXATTRIB1SNVPROC) load(userptr, "glVertexAttrib1sNV");
+    context->VertexAttrib1svNV = (PFNGLVERTEXATTRIB1SVNVPROC) load(userptr, "glVertexAttrib1svNV");
+    context->VertexAttrib2dNV = (PFNGLVERTEXATTRIB2DNVPROC) load(userptr, "glVertexAttrib2dNV");
+    context->VertexAttrib2dvNV = (PFNGLVERTEXATTRIB2DVNVPROC) load(userptr, "glVertexAttrib2dvNV");
+    context->VertexAttrib2fNV = (PFNGLVERTEXATTRIB2FNVPROC) load(userptr, "glVertexAttrib2fNV");
+    context->VertexAttrib2fvNV = (PFNGLVERTEXATTRIB2FVNVPROC) load(userptr, "glVertexAttrib2fvNV");
+    context->VertexAttrib2sNV = (PFNGLVERTEXATTRIB2SNVPROC) load(userptr, "glVertexAttrib2sNV");
+    context->VertexAttrib2svNV = (PFNGLVERTEXATTRIB2SVNVPROC) load(userptr, "glVertexAttrib2svNV");
+    context->VertexAttrib3dNV = (PFNGLVERTEXATTRIB3DNVPROC) load(userptr, "glVertexAttrib3dNV");
+    context->VertexAttrib3dvNV = (PFNGLVERTEXATTRIB3DVNVPROC) load(userptr, "glVertexAttrib3dvNV");
+    context->VertexAttrib3fNV = (PFNGLVERTEXATTRIB3FNVPROC) load(userptr, "glVertexAttrib3fNV");
+    context->VertexAttrib3fvNV = (PFNGLVERTEXATTRIB3FVNVPROC) load(userptr, "glVertexAttrib3fvNV");
+    context->VertexAttrib3sNV = (PFNGLVERTEXATTRIB3SNVPROC) load(userptr, "glVertexAttrib3sNV");
+    context->VertexAttrib3svNV = (PFNGLVERTEXATTRIB3SVNVPROC) load(userptr, "glVertexAttrib3svNV");
+    context->VertexAttrib4dNV = (PFNGLVERTEXATTRIB4DNVPROC) load(userptr, "glVertexAttrib4dNV");
+    context->VertexAttrib4dvNV = (PFNGLVERTEXATTRIB4DVNVPROC) load(userptr, "glVertexAttrib4dvNV");
+    context->VertexAttrib4fNV = (PFNGLVERTEXATTRIB4FNVPROC) load(userptr, "glVertexAttrib4fNV");
+    context->VertexAttrib4fvNV = (PFNGLVERTEXATTRIB4FVNVPROC) load(userptr, "glVertexAttrib4fvNV");
+    context->VertexAttrib4sNV = (PFNGLVERTEXATTRIB4SNVPROC) load(userptr, "glVertexAttrib4sNV");
+    context->VertexAttrib4svNV = (PFNGLVERTEXATTRIB4SVNVPROC) load(userptr, "glVertexAttrib4svNV");
+    context->VertexAttrib4ubNV = (PFNGLVERTEXATTRIB4UBNVPROC) load(userptr, "glVertexAttrib4ubNV");
+    context->VertexAttrib4ubvNV = (PFNGLVERTEXATTRIB4UBVNVPROC) load(userptr, "glVertexAttrib4ubvNV");
+    context->VertexAttribPointerNV = (PFNGLVERTEXATTRIBPOINTERNVPROC) load(userptr, "glVertexAttribPointerNV");
+    context->VertexAttribs1dvNV = (PFNGLVERTEXATTRIBS1DVNVPROC) load(userptr, "glVertexAttribs1dvNV");
+    context->VertexAttribs1fvNV = (PFNGLVERTEXATTRIBS1FVNVPROC) load(userptr, "glVertexAttribs1fvNV");
+    context->VertexAttribs1svNV = (PFNGLVERTEXATTRIBS1SVNVPROC) load(userptr, "glVertexAttribs1svNV");
+    context->VertexAttribs2dvNV = (PFNGLVERTEXATTRIBS2DVNVPROC) load(userptr, "glVertexAttribs2dvNV");
+    context->VertexAttribs2fvNV = (PFNGLVERTEXATTRIBS2FVNVPROC) load(userptr, "glVertexAttribs2fvNV");
+    context->VertexAttribs2svNV = (PFNGLVERTEXATTRIBS2SVNVPROC) load(userptr, "glVertexAttribs2svNV");
+    context->VertexAttribs3dvNV = (PFNGLVERTEXATTRIBS3DVNVPROC) load(userptr, "glVertexAttribs3dvNV");
+    context->VertexAttribs3fvNV = (PFNGLVERTEXATTRIBS3FVNVPROC) load(userptr, "glVertexAttribs3fvNV");
+    context->VertexAttribs3svNV = (PFNGLVERTEXATTRIBS3SVNVPROC) load(userptr, "glVertexAttribs3svNV");
+    context->VertexAttribs4dvNV = (PFNGLVERTEXATTRIBS4DVNVPROC) load(userptr, "glVertexAttribs4dvNV");
+    context->VertexAttribs4fvNV = (PFNGLVERTEXATTRIBS4FVNVPROC) load(userptr, "glVertexAttribs4fvNV");
+    context->VertexAttribs4svNV = (PFNGLVERTEXATTRIBS4SVNVPROC) load(userptr, "glVertexAttribs4svNV");
+    context->VertexAttribs4ubvNV = (PFNGLVERTEXATTRIBS4UBVNVPROC) load(userptr, "glVertexAttribs4ubvNV");
+}
+static void glad_gl_load_GL_NV_vertex_program4(GladGLContext *context, GLADuserptrloadfunc load, void* userptr) {
+    if(!context->NV_vertex_program4) return;
+    context->GetVertexAttribIivEXT = (PFNGLGETVERTEXATTRIBIIVEXTPROC) load(userptr, "glGetVertexAttribIivEXT");
+    context->GetVertexAttribIuivEXT = (PFNGLGETVERTEXATTRIBIUIVEXTPROC) load(userptr, "glGetVertexAttribIuivEXT");
+    context->VertexAttribI1iEXT = (PFNGLVERTEXATTRIBI1IEXTPROC) load(userptr, "glVertexAttribI1iEXT");
+    context->VertexAttribI1ivEXT = (PFNGLVERTEXATTRIBI1IVEXTPROC) load(userptr, "glVertexAttribI1ivEXT");
+    context->VertexAttribI1uiEXT = (PFNGLVERTEXATTRIBI1UIEXTPROC) load(userptr, "glVertexAttribI1uiEXT");
+    context->VertexAttribI1uivEXT = (PFNGLVERTEXATTRIBI1UIVEXTPROC) load(userptr, "glVertexAttribI1uivEXT");
+    context->VertexAttribI2iEXT = (PFNGLVERTEXATTRIBI2IEXTPROC) load(userptr, "glVertexAttribI2iEXT");
+    context->VertexAttribI2ivEXT = (PFNGLVERTEXATTRIBI2IVEXTPROC) load(userptr, "glVertexAttribI2ivEXT");
+    context->VertexAttribI2uiEXT = (PFNGLVERTEXATTRIBI2UIEXTPROC) load(userptr, "glVertexAttribI2uiEXT");
+    context->VertexAttribI2uivEXT = (PFNGLVERTEXATTRIBI2UIVEXTPROC) load(userptr, "glVertexAttribI2uivEXT");
+    context->VertexAttribI3iEXT = (PFNGLVERTEXATTRIBI3IEXTPROC) load(userptr, "glVertexAttribI3iEXT");
+    context->VertexAttribI3ivEXT = (PFNGLVERTEXATTRIBI3IVEXTPROC) load(userptr, "glVertexAttribI3ivEXT");
+    context->VertexAttribI3uiEXT = (PFNGLVERTEXATTRIBI3UIEXTPROC) load(userptr, "glVertexAttribI3uiEXT");
+    context->VertexAttribI3uivEXT = (PFNGLVERTEXATTRIBI3UIVEXTPROC) load(userptr, "glVertexAttribI3uivEXT");
+    context->VertexAttribI4bvEXT = (PFNGLVERTEXATTRIBI4BVEXTPROC) load(userptr, "glVertexAttribI4bvEXT");
+    context->VertexAttribI4iEXT = (PFNGLVERTEXATTRIBI4IEXTPROC) load(userptr, "glVertexAttribI4iEXT");
+    context->VertexAttribI4ivEXT = (PFNGLVERTEXATTRIBI4IVEXTPROC) load(userptr, "glVertexAttribI4ivEXT");
+    context->VertexAttribI4svEXT = (PFNGLVERTEXATTRIBI4SVEXTPROC) load(userptr, "glVertexAttribI4svEXT");
+    context->VertexAttribI4ubvEXT = (PFNGLVERTEXATTRIBI4UBVEXTPROC) load(userptr, "glVertexAttribI4ubvEXT");
+    context->VertexAttribI4uiEXT = (PFNGLVERTEXATTRIBI4UIEXTPROC) load(userptr, "glVertexAttribI4uiEXT");
+    context->VertexAttribI4uivEXT = (PFNGLVERTEXATTRIBI4UIVEXTPROC) load(userptr, "glVertexAttribI4uivEXT");
+    context->VertexAttribI4usvEXT = (PFNGLVERTEXATTRIBI4USVEXTPROC) load(userptr, "glVertexAttribI4usvEXT");
+    context->VertexAttribIPointerEXT = (PFNGLVERTEXATTRIBIPOINTEREXTPROC) load(userptr, "glVertexAttribIPointerEXT");
+}
+static void glad_gl_load_GL_SGIS_point_parameters(GladGLContext *context, GLADuserptrloadfunc load, void* userptr) {
+    if(!context->SGIS_point_parameters) return;
+    context->PointParameterfSGIS = (PFNGLPOINTPARAMETERFSGISPROC) load(userptr, "glPointParameterfSGIS");
+    context->PointParameterfvSGIS = (PFNGLPOINTPARAMETERFVSGISPROC) load(userptr, "glPointParameterfvSGIS");
+}
+
+
+static void glad_gl_resolve_aliases(GladGLContext *context) {
+    if (context->ActiveTexture == NULL && context->ActiveTextureARB != NULL) context->ActiveTexture = (PFNGLACTIVETEXTUREPROC)context->ActiveTextureARB;
+    if (context->ActiveTextureARB == NULL && context->ActiveTexture != NULL) context->ActiveTextureARB = (PFNGLACTIVETEXTUREARBPROC)context->ActiveTexture;
+    if (context->AttachObjectARB == NULL && context->AttachShader != NULL) context->AttachObjectARB = (PFNGLATTACHOBJECTARBPROC)context->AttachShader;
+    if (context->AttachShader == NULL && context->AttachObjectARB != NULL) context->AttachShader = (PFNGLATTACHSHADERPROC)context->AttachObjectARB;
+    if (context->BeginConditionalRender == NULL && context->BeginConditionalRenderNV != NULL) context->BeginConditionalRender = (PFNGLBEGINCONDITIONALRENDERPROC)context->BeginConditionalRenderNV;
+    if (context->BeginConditionalRenderNV == NULL && context->BeginConditionalRender != NULL) context->BeginConditionalRenderNV = (PFNGLBEGINCONDITIONALRENDERNVPROC)context->BeginConditionalRender;
+    if (context->BeginQuery == NULL && context->BeginQueryARB != NULL) context->BeginQuery = (PFNGLBEGINQUERYPROC)context->BeginQueryARB;
+    if (context->BeginQueryARB == NULL && context->BeginQuery != NULL) context->BeginQueryARB = (PFNGLBEGINQUERYARBPROC)context->BeginQuery;
+    if (context->BeginTransformFeedback == NULL && context->BeginTransformFeedbackEXT != NULL) context->BeginTransformFeedback = (PFNGLBEGINTRANSFORMFEEDBACKPROC)context->BeginTransformFeedbackEXT;
+    if (context->BeginTransformFeedback == NULL && context->BeginTransformFeedbackNV != NULL) context->BeginTransformFeedback = (PFNGLBEGINTRANSFORMFEEDBACKPROC)context->BeginTransformFeedbackNV;
+    if (context->BeginTransformFeedbackEXT == NULL && context->BeginTransformFeedback != NULL) context->BeginTransformFeedbackEXT = (PFNGLBEGINTRANSFORMFEEDBACKEXTPROC)context->BeginTransformFeedback;
+    if (context->BeginTransformFeedbackEXT == NULL && context->BeginTransformFeedbackNV != NULL) context->BeginTransformFeedbackEXT = (PFNGLBEGINTRANSFORMFEEDBACKEXTPROC)context->BeginTransformFeedbackNV;
+    if (context->BeginTransformFeedbackNV == NULL && context->BeginTransformFeedback != NULL) context->BeginTransformFeedbackNV = (PFNGLBEGINTRANSFORMFEEDBACKNVPROC)context->BeginTransformFeedback;
+    if (context->BeginTransformFeedbackNV == NULL && context->BeginTransformFeedbackEXT != NULL) context->BeginTransformFeedbackNV = (PFNGLBEGINTRANSFORMFEEDBACKNVPROC)context->BeginTransformFeedbackEXT;
+    if (context->BindAttribLocation == NULL && context->BindAttribLocationARB != NULL) context->BindAttribLocation = (PFNGLBINDATTRIBLOCATIONPROC)context->BindAttribLocationARB;
+    if (context->BindAttribLocationARB == NULL && context->BindAttribLocation != NULL) context->BindAttribLocationARB = (PFNGLBINDATTRIBLOCATIONARBPROC)context->BindAttribLocation;
+    if (context->BindBuffer == NULL && context->BindBufferARB != NULL) context->BindBuffer = (PFNGLBINDBUFFERPROC)context->BindBufferARB;
+    if (context->BindBufferARB == NULL && context->BindBuffer != NULL) context->BindBufferARB = (PFNGLBINDBUFFERARBPROC)context->BindBuffer;
+    if (context->BindBufferBase == NULL && context->BindBufferBaseEXT != NULL) context->BindBufferBase = (PFNGLBINDBUFFERBASEPROC)context->BindBufferBaseEXT;
+    if (context->BindBufferBase == NULL && context->BindBufferBaseNV != NULL) context->BindBufferBase = (PFNGLBINDBUFFERBASEPROC)context->BindBufferBaseNV;
+    if (context->BindBufferBaseEXT == NULL && context->BindBufferBase != NULL) context->BindBufferBaseEXT = (PFNGLBINDBUFFERBASEEXTPROC)context->BindBufferBase;
+    if (context->BindBufferBaseEXT == NULL && context->BindBufferBaseNV != NULL) context->BindBufferBaseEXT = (PFNGLBINDBUFFERBASEEXTPROC)context->BindBufferBaseNV;
+    if (context->BindBufferBaseNV == NULL && context->BindBufferBase != NULL) context->BindBufferBaseNV = (PFNGLBINDBUFFERBASENVPROC)context->BindBufferBase;
+    if (context->BindBufferBaseNV == NULL && context->BindBufferBaseEXT != NULL) context->BindBufferBaseNV = (PFNGLBINDBUFFERBASENVPROC)context->BindBufferBaseEXT;
+    if (context->BindBufferOffsetEXT == NULL && context->BindBufferOffsetNV != NULL) context->BindBufferOffsetEXT = (PFNGLBINDBUFFEROFFSETEXTPROC)context->BindBufferOffsetNV;
+    if (context->BindBufferOffsetNV == NULL && context->BindBufferOffsetEXT != NULL) context->BindBufferOffsetNV = (PFNGLBINDBUFFEROFFSETNVPROC)context->BindBufferOffsetEXT;
+    if (context->BindBufferRange == NULL && context->BindBufferRangeEXT != NULL) context->BindBufferRange = (PFNGLBINDBUFFERRANGEPROC)context->BindBufferRangeEXT;
+    if (context->BindBufferRange == NULL && context->BindBufferRangeNV != NULL) context->BindBufferRange = (PFNGLBINDBUFFERRANGEPROC)context->BindBufferRangeNV;
+    if (context->BindBufferRangeEXT == NULL && context->BindBufferRange != NULL) context->BindBufferRangeEXT = (PFNGLBINDBUFFERRANGEEXTPROC)context->BindBufferRange;
+    if (context->BindBufferRangeEXT == NULL && context->BindBufferRangeNV != NULL) context->BindBufferRangeEXT = (PFNGLBINDBUFFERRANGEEXTPROC)context->BindBufferRangeNV;
+    if (context->BindBufferRangeNV == NULL && context->BindBufferRange != NULL) context->BindBufferRangeNV = (PFNGLBINDBUFFERRANGENVPROC)context->BindBufferRange;
+    if (context->BindBufferRangeNV == NULL && context->BindBufferRangeEXT != NULL) context->BindBufferRangeNV = (PFNGLBINDBUFFERRANGENVPROC)context->BindBufferRangeEXT;
+    if (context->BindFragDataLocation == NULL && context->BindFragDataLocationEXT != NULL) context->BindFragDataLocation = (PFNGLBINDFRAGDATALOCATIONPROC)context->BindFragDataLocationEXT;
+    if (context->BindFragDataLocationEXT == NULL && context->BindFragDataLocation != NULL) context->BindFragDataLocationEXT = (PFNGLBINDFRAGDATALOCATIONEXTPROC)context->BindFragDataLocation;
+    if (context->BindProgramARB == NULL && context->BindProgramNV != NULL) context->BindProgramARB = (PFNGLBINDPROGRAMARBPROC)context->BindProgramNV;
+    if (context->BindProgramNV == NULL && context->BindProgramARB != NULL) context->BindProgramNV = (PFNGLBINDPROGRAMNVPROC)context->BindProgramARB;
+    if (context->BindTexture == NULL && context->BindTextureEXT != NULL) context->BindTexture = (PFNGLBINDTEXTUREPROC)context->BindTextureEXT;
+    if (context->BindTextureEXT == NULL && context->BindTexture != NULL) context->BindTextureEXT = (PFNGLBINDTEXTUREEXTPROC)context->BindTexture;
+    if (context->BlendColor == NULL && context->BlendColorEXT != NULL) context->BlendColor = (PFNGLBLENDCOLORPROC)context->BlendColorEXT;
+    if (context->BlendColorEXT == NULL && context->BlendColor != NULL) context->BlendColorEXT = (PFNGLBLENDCOLOREXTPROC)context->BlendColor;
+    if (context->BlendEquation == NULL && context->BlendEquationEXT != NULL) context->BlendEquation = (PFNGLBLENDEQUATIONPROC)context->BlendEquationEXT;
+    if (context->BlendEquationEXT == NULL && context->BlendEquation != NULL) context->BlendEquationEXT = (PFNGLBLENDEQUATIONEXTPROC)context->BlendEquation;
+    if (context->BlendEquationSeparate == NULL && context->BlendEquationSeparateEXT != NULL) context->BlendEquationSeparate = (PFNGLBLENDEQUATIONSEPARATEPROC)context->BlendEquationSeparateEXT;
+    if (context->BlendEquationSeparateEXT == NULL && context->BlendEquationSeparate != NULL) context->BlendEquationSeparateEXT = (PFNGLBLENDEQUATIONSEPARATEEXTPROC)context->BlendEquationSeparate;
+    if (context->BlendFuncSeparate == NULL && context->BlendFuncSeparateEXT != NULL) context->BlendFuncSeparate = (PFNGLBLENDFUNCSEPARATEPROC)context->BlendFuncSeparateEXT;
+    if (context->BlendFuncSeparate == NULL && context->BlendFuncSeparateINGR != NULL) context->BlendFuncSeparate = (PFNGLBLENDFUNCSEPARATEPROC)context->BlendFuncSeparateINGR;
+    if (context->BlendFuncSeparateEXT == NULL && context->BlendFuncSeparate != NULL) context->BlendFuncSeparateEXT = (PFNGLBLENDFUNCSEPARATEEXTPROC)context->BlendFuncSeparate;
+    if (context->BlendFuncSeparateEXT == NULL && context->BlendFuncSeparateINGR != NULL) context->BlendFuncSeparateEXT = (PFNGLBLENDFUNCSEPARATEEXTPROC)context->BlendFuncSeparateINGR;
+    if (context->BlendFuncSeparateINGR == NULL && context->BlendFuncSeparate != NULL) context->BlendFuncSeparateINGR = (PFNGLBLENDFUNCSEPARATEINGRPROC)context->BlendFuncSeparate;
+    if (context->BlendFuncSeparateINGR == NULL && context->BlendFuncSeparateEXT != NULL) context->BlendFuncSeparateINGR = (PFNGLBLENDFUNCSEPARATEINGRPROC)context->BlendFuncSeparateEXT;
+    if (context->BlitFramebuffer == NULL && context->BlitFramebufferEXT != NULL) context->BlitFramebuffer = (PFNGLBLITFRAMEBUFFERPROC)context->BlitFramebufferEXT;
+    if (context->BlitFramebufferEXT == NULL && context->BlitFramebuffer != NULL) context->BlitFramebufferEXT = (PFNGLBLITFRAMEBUFFEREXTPROC)context->BlitFramebuffer;
+    if (context->BufferData == NULL && context->BufferDataARB != NULL) context->BufferData = (PFNGLBUFFERDATAPROC)context->BufferDataARB;
+    if (context->BufferDataARB == NULL && context->BufferData != NULL) context->BufferDataARB = (PFNGLBUFFERDATAARBPROC)context->BufferData;
+    if (context->BufferSubData == NULL && context->BufferSubDataARB != NULL) context->BufferSubData = (PFNGLBUFFERSUBDATAPROC)context->BufferSubDataARB;
+    if (context->BufferSubDataARB == NULL && context->BufferSubData != NULL) context->BufferSubDataARB = (PFNGLBUFFERSUBDATAARBPROC)context->BufferSubData;
+    if (context->CheckFramebufferStatus == NULL && context->CheckFramebufferStatusEXT != NULL) context->CheckFramebufferStatus = (PFNGLCHECKFRAMEBUFFERSTATUSPROC)context->CheckFramebufferStatusEXT;
+    if (context->CheckFramebufferStatusEXT == NULL && context->CheckFramebufferStatus != NULL) context->CheckFramebufferStatusEXT = (PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC)context->CheckFramebufferStatus;
+    if (context->ClampColor == NULL && context->ClampColorARB != NULL) context->ClampColor = (PFNGLCLAMPCOLORPROC)context->ClampColorARB;
+    if (context->ClampColorARB == NULL && context->ClampColor != NULL) context->ClampColorARB = (PFNGLCLAMPCOLORARBPROC)context->ClampColor;
+    if (context->ColorMaski == NULL && context->ColorMaskIndexedEXT != NULL) context->ColorMaski = (PFNGLCOLORMASKIPROC)context->ColorMaskIndexedEXT;
+    if (context->ColorMaskIndexedEXT == NULL && context->ColorMaski != NULL) context->ColorMaskIndexedEXT = (PFNGLCOLORMASKINDEXEDEXTPROC)context->ColorMaski;
+    if (context->CompileShader == NULL && context->CompileShaderARB != NULL) context->CompileShader = (PFNGLCOMPILESHADERPROC)context->CompileShaderARB;
+    if (context->CompileShaderARB == NULL && context->CompileShader != NULL) context->CompileShaderARB = (PFNGLCOMPILESHADERARBPROC)context->CompileShader;
+    if (context->CompressedTexImage1D == NULL && context->CompressedTexImage1DARB != NULL) context->CompressedTexImage1D = (PFNGLCOMPRESSEDTEXIMAGE1DPROC)context->CompressedTexImage1DARB;
+    if (context->CompressedTexImage1DARB == NULL && context->CompressedTexImage1D != NULL) context->CompressedTexImage1DARB = (PFNGLCOMPRESSEDTEXIMAGE1DARBPROC)context->CompressedTexImage1D;
+    if (context->CompressedTexImage2D == NULL && context->CompressedTexImage2DARB != NULL) context->CompressedTexImage2D = (PFNGLCOMPRESSEDTEXIMAGE2DPROC)context->CompressedTexImage2DARB;
+    if (context->CompressedTexImage2DARB == NULL && context->CompressedTexImage2D != NULL) context->CompressedTexImage2DARB = (PFNGLCOMPRESSEDTEXIMAGE2DARBPROC)context->CompressedTexImage2D;
+    if (context->CompressedTexImage3D == NULL && context->CompressedTexImage3DARB != NULL) context->CompressedTexImage3D = (PFNGLCOMPRESSEDTEXIMAGE3DPROC)context->CompressedTexImage3DARB;
+    if (context->CompressedTexImage3DARB == NULL && context->CompressedTexImage3D != NULL) context->CompressedTexImage3DARB = (PFNGLCOMPRESSEDTEXIMAGE3DARBPROC)context->CompressedTexImage3D;
+    if (context->CompressedTexSubImage1D == NULL && context->CompressedTexSubImage1DARB != NULL) context->CompressedTexSubImage1D = (PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC)context->CompressedTexSubImage1DARB;
+    if (context->CompressedTexSubImage1DARB == NULL && context->CompressedTexSubImage1D != NULL) context->CompressedTexSubImage1DARB = (PFNGLCOMPRESSEDTEXSUBIMAGE1DARBPROC)context->CompressedTexSubImage1D;
+    if (context->CompressedTexSubImage2D == NULL && context->CompressedTexSubImage2DARB != NULL) context->CompressedTexSubImage2D = (PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC)context->CompressedTexSubImage2DARB;
+    if (context->CompressedTexSubImage2DARB == NULL && context->CompressedTexSubImage2D != NULL) context->CompressedTexSubImage2DARB = (PFNGLCOMPRESSEDTEXSUBIMAGE2DARBPROC)context->CompressedTexSubImage2D;
+    if (context->CompressedTexSubImage3D == NULL && context->CompressedTexSubImage3DARB != NULL) context->CompressedTexSubImage3D = (PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC)context->CompressedTexSubImage3DARB;
+    if (context->CompressedTexSubImage3DARB == NULL && context->CompressedTexSubImage3D != NULL) context->CompressedTexSubImage3DARB = (PFNGLCOMPRESSEDTEXSUBIMAGE3DARBPROC)context->CompressedTexSubImage3D;
+    if (context->CopyTexImage1D == NULL && context->CopyTexImage1DEXT != NULL) context->CopyTexImage1D = (PFNGLCOPYTEXIMAGE1DPROC)context->CopyTexImage1DEXT;
+    if (context->CopyTexImage1DEXT == NULL && context->CopyTexImage1D != NULL) context->CopyTexImage1DEXT = (PFNGLCOPYTEXIMAGE1DEXTPROC)context->CopyTexImage1D;
+    if (context->CopyTexImage2D == NULL && context->CopyTexImage2DEXT != NULL) context->CopyTexImage2D = (PFNGLCOPYTEXIMAGE2DPROC)context->CopyTexImage2DEXT;
+    if (context->CopyTexImage2DEXT == NULL && context->CopyTexImage2D != NULL) context->CopyTexImage2DEXT = (PFNGLCOPYTEXIMAGE2DEXTPROC)context->CopyTexImage2D;
+    if (context->CopyTexSubImage1D == NULL && context->CopyTexSubImage1DEXT != NULL) context->CopyTexSubImage1D = (PFNGLCOPYTEXSUBIMAGE1DPROC)context->CopyTexSubImage1DEXT;
+    if (context->CopyTexSubImage1DEXT == NULL && context->CopyTexSubImage1D != NULL) context->CopyTexSubImage1DEXT = (PFNGLCOPYTEXSUBIMAGE1DEXTPROC)context->CopyTexSubImage1D;
+    if (context->CopyTexSubImage2D == NULL && context->CopyTexSubImage2DEXT != NULL) context->CopyTexSubImage2D = (PFNGLCOPYTEXSUBIMAGE2DPROC)context->CopyTexSubImage2DEXT;
+    if (context->CopyTexSubImage2DEXT == NULL && context->CopyTexSubImage2D != NULL) context->CopyTexSubImage2DEXT = (PFNGLCOPYTEXSUBIMAGE2DEXTPROC)context->CopyTexSubImage2D;
+    if (context->CopyTexSubImage3D == NULL && context->CopyTexSubImage3DEXT != NULL) context->CopyTexSubImage3D = (PFNGLCOPYTEXSUBIMAGE3DPROC)context->CopyTexSubImage3DEXT;
+    if (context->CopyTexSubImage3DEXT == NULL && context->CopyTexSubImage3D != NULL) context->CopyTexSubImage3DEXT = (PFNGLCOPYTEXSUBIMAGE3DEXTPROC)context->CopyTexSubImage3D;
+    if (context->CreateProgram == NULL && context->CreateProgramObjectARB != NULL) context->CreateProgram = (PFNGLCREATEPROGRAMPROC)context->CreateProgramObjectARB;
+    if (context->CreateProgramObjectARB == NULL && context->CreateProgram != NULL) context->CreateProgramObjectARB = (PFNGLCREATEPROGRAMOBJECTARBPROC)context->CreateProgram;
+    if (context->CreateShader == NULL && context->CreateShaderObjectARB != NULL) context->CreateShader = (PFNGLCREATESHADERPROC)context->CreateShaderObjectARB;
+    if (context->CreateShaderObjectARB == NULL && context->CreateShader != NULL) context->CreateShaderObjectARB = (PFNGLCREATESHADEROBJECTARBPROC)context->CreateShader;
+    if (context->DeleteBuffers == NULL && context->DeleteBuffersARB != NULL) context->DeleteBuffers = (PFNGLDELETEBUFFERSPROC)context->DeleteBuffersARB;
+    if (context->DeleteBuffersARB == NULL && context->DeleteBuffers != NULL) context->DeleteBuffersARB = (PFNGLDELETEBUFFERSARBPROC)context->DeleteBuffers;
+    if (context->DeleteFramebuffers == NULL && context->DeleteFramebuffersEXT != NULL) context->DeleteFramebuffers = (PFNGLDELETEFRAMEBUFFERSPROC)context->DeleteFramebuffersEXT;
+    if (context->DeleteFramebuffersEXT == NULL && context->DeleteFramebuffers != NULL) context->DeleteFramebuffersEXT = (PFNGLDELETEFRAMEBUFFERSEXTPROC)context->DeleteFramebuffers;
+    if (context->DeleteProgramsARB == NULL && context->DeleteProgramsNV != NULL) context->DeleteProgramsARB = (PFNGLDELETEPROGRAMSARBPROC)context->DeleteProgramsNV;
+    if (context->DeleteProgramsNV == NULL && context->DeleteProgramsARB != NULL) context->DeleteProgramsNV = (PFNGLDELETEPROGRAMSNVPROC)context->DeleteProgramsARB;
+    if (context->DeleteQueries == NULL && context->DeleteQueriesARB != NULL) context->DeleteQueries = (PFNGLDELETEQUERIESPROC)context->DeleteQueriesARB;
+    if (context->DeleteQueriesARB == NULL && context->DeleteQueries != NULL) context->DeleteQueriesARB = (PFNGLDELETEQUERIESARBPROC)context->DeleteQueries;
+    if (context->DeleteRenderbuffers == NULL && context->DeleteRenderbuffersEXT != NULL) context->DeleteRenderbuffers = (PFNGLDELETERENDERBUFFERSPROC)context->DeleteRenderbuffersEXT;
+    if (context->DeleteRenderbuffersEXT == NULL && context->DeleteRenderbuffers != NULL) context->DeleteRenderbuffersEXT = (PFNGLDELETERENDERBUFFERSEXTPROC)context->DeleteRenderbuffers;
+    if (context->DeleteVertexArrays == NULL && context->DeleteVertexArraysAPPLE != NULL) context->DeleteVertexArrays = (PFNGLDELETEVERTEXARRAYSPROC)context->DeleteVertexArraysAPPLE;
+    if (context->DeleteVertexArraysAPPLE == NULL && context->DeleteVertexArrays != NULL) context->DeleteVertexArraysAPPLE = (PFNGLDELETEVERTEXARRAYSAPPLEPROC)context->DeleteVertexArrays;
+    if (context->DetachObjectARB == NULL && context->DetachShader != NULL) context->DetachObjectARB = (PFNGLDETACHOBJECTARBPROC)context->DetachShader;
+    if (context->DetachShader == NULL && context->DetachObjectARB != NULL) context->DetachShader = (PFNGLDETACHSHADERPROC)context->DetachObjectARB;
+    if (context->Disablei == NULL && context->DisableIndexedEXT != NULL) context->Disablei = (PFNGLDISABLEIPROC)context->DisableIndexedEXT;
+    if (context->DisableIndexedEXT == NULL && context->Disablei != NULL) context->DisableIndexedEXT = (PFNGLDISABLEINDEXEDEXTPROC)context->Disablei;
+    if (context->DisableVertexAttribArray == NULL && context->DisableVertexAttribArrayARB != NULL) context->DisableVertexAttribArray = (PFNGLDISABLEVERTEXATTRIBARRAYPROC)context->DisableVertexAttribArrayARB;
+    if (context->DisableVertexAttribArrayARB == NULL && context->DisableVertexAttribArray != NULL) context->DisableVertexAttribArrayARB = (PFNGLDISABLEVERTEXATTRIBARRAYARBPROC)context->DisableVertexAttribArray;
+    if (context->DrawArrays == NULL && context->DrawArraysEXT != NULL) context->DrawArrays = (PFNGLDRAWARRAYSPROC)context->DrawArraysEXT;
+    if (context->DrawArraysEXT == NULL && context->DrawArrays != NULL) context->DrawArraysEXT = (PFNGLDRAWARRAYSEXTPROC)context->DrawArrays;
+    if (context->DrawArraysInstanced == NULL && context->DrawArraysInstancedARB != NULL) context->DrawArraysInstanced = (PFNGLDRAWARRAYSINSTANCEDPROC)context->DrawArraysInstancedARB;
+    if (context->DrawArraysInstanced == NULL && context->DrawArraysInstancedEXT != NULL) context->DrawArraysInstanced = (PFNGLDRAWARRAYSINSTANCEDPROC)context->DrawArraysInstancedEXT;
+    if (context->DrawArraysInstancedARB == NULL && context->DrawArraysInstanced != NULL) context->DrawArraysInstancedARB = (PFNGLDRAWARRAYSINSTANCEDARBPROC)context->DrawArraysInstanced;
+    if (context->DrawArraysInstancedARB == NULL && context->DrawArraysInstancedEXT != NULL) context->DrawArraysInstancedARB = (PFNGLDRAWARRAYSINSTANCEDARBPROC)context->DrawArraysInstancedEXT;
+    if (context->DrawArraysInstancedEXT == NULL && context->DrawArraysInstanced != NULL) context->DrawArraysInstancedEXT = (PFNGLDRAWARRAYSINSTANCEDEXTPROC)context->DrawArraysInstanced;
+    if (context->DrawArraysInstancedEXT == NULL && context->DrawArraysInstancedARB != NULL) context->DrawArraysInstancedEXT = (PFNGLDRAWARRAYSINSTANCEDEXTPROC)context->DrawArraysInstancedARB;
+    if (context->DrawBuffers == NULL && context->DrawBuffersARB != NULL) context->DrawBuffers = (PFNGLDRAWBUFFERSPROC)context->DrawBuffersARB;
+    if (context->DrawBuffers == NULL && context->DrawBuffersATI != NULL) context->DrawBuffers = (PFNGLDRAWBUFFERSPROC)context->DrawBuffersATI;
+    if (context->DrawBuffersARB == NULL && context->DrawBuffers != NULL) context->DrawBuffersARB = (PFNGLDRAWBUFFERSARBPROC)context->DrawBuffers;
+    if (context->DrawBuffersARB == NULL && context->DrawBuffersATI != NULL) context->DrawBuffersARB = (PFNGLDRAWBUFFERSARBPROC)context->DrawBuffersATI;
+    if (context->DrawBuffersATI == NULL && context->DrawBuffers != NULL) context->DrawBuffersATI = (PFNGLDRAWBUFFERSATIPROC)context->DrawBuffers;
+    if (context->DrawBuffersATI == NULL && context->DrawBuffersARB != NULL) context->DrawBuffersATI = (PFNGLDRAWBUFFERSATIPROC)context->DrawBuffersARB;
+    if (context->DrawElementsInstanced == NULL && context->DrawElementsInstancedARB != NULL) context->DrawElementsInstanced = (PFNGLDRAWELEMENTSINSTANCEDPROC)context->DrawElementsInstancedARB;
+    if (context->DrawElementsInstanced == NULL && context->DrawElementsInstancedEXT != NULL) context->DrawElementsInstanced = (PFNGLDRAWELEMENTSINSTANCEDPROC)context->DrawElementsInstancedEXT;
+    if (context->DrawElementsInstancedARB == NULL && context->DrawElementsInstanced != NULL) context->DrawElementsInstancedARB = (PFNGLDRAWELEMENTSINSTANCEDARBPROC)context->DrawElementsInstanced;
+    if (context->DrawElementsInstancedARB == NULL && context->DrawElementsInstancedEXT != NULL) context->DrawElementsInstancedARB = (PFNGLDRAWELEMENTSINSTANCEDARBPROC)context->DrawElementsInstancedEXT;
+    if (context->DrawElementsInstancedEXT == NULL && context->DrawElementsInstanced != NULL) context->DrawElementsInstancedEXT = (PFNGLDRAWELEMENTSINSTANCEDEXTPROC)context->DrawElementsInstanced;
+    if (context->DrawElementsInstancedEXT == NULL && context->DrawElementsInstancedARB != NULL) context->DrawElementsInstancedEXT = (PFNGLDRAWELEMENTSINSTANCEDEXTPROC)context->DrawElementsInstancedARB;
+    if (context->DrawRangeElements == NULL && context->DrawRangeElementsEXT != NULL) context->DrawRangeElements = (PFNGLDRAWRANGEELEMENTSPROC)context->DrawRangeElementsEXT;
+    if (context->DrawRangeElementsEXT == NULL && context->DrawRangeElements != NULL) context->DrawRangeElementsEXT = (PFNGLDRAWRANGEELEMENTSEXTPROC)context->DrawRangeElements;
+    if (context->Enablei == NULL && context->EnableIndexedEXT != NULL) context->Enablei = (PFNGLENABLEIPROC)context->EnableIndexedEXT;
+    if (context->EnableIndexedEXT == NULL && context->Enablei != NULL) context->EnableIndexedEXT = (PFNGLENABLEINDEXEDEXTPROC)context->Enablei;
+    if (context->EnableVertexAttribArray == NULL && context->EnableVertexAttribArrayARB != NULL) context->EnableVertexAttribArray = (PFNGLENABLEVERTEXATTRIBARRAYPROC)context->EnableVertexAttribArrayARB;
+    if (context->EnableVertexAttribArrayARB == NULL && context->EnableVertexAttribArray != NULL) context->EnableVertexAttribArrayARB = (PFNGLENABLEVERTEXATTRIBARRAYARBPROC)context->EnableVertexAttribArray;
+    if (context->EndConditionalRender == NULL && context->EndConditionalRenderNV != NULL) context->EndConditionalRender = (PFNGLENDCONDITIONALRENDERPROC)context->EndConditionalRenderNV;
+    if (context->EndConditionalRender == NULL && context->EndConditionalRenderNVX != NULL) context->EndConditionalRender = (PFNGLENDCONDITIONALRENDERPROC)context->EndConditionalRenderNVX;
+    if (context->EndConditionalRenderNV == NULL && context->EndConditionalRender != NULL) context->EndConditionalRenderNV = (PFNGLENDCONDITIONALRENDERNVPROC)context->EndConditionalRender;
+    if (context->EndConditionalRenderNV == NULL && context->EndConditionalRenderNVX != NULL) context->EndConditionalRenderNV = (PFNGLENDCONDITIONALRENDERNVPROC)context->EndConditionalRenderNVX;
+    if (context->EndConditionalRenderNVX == NULL && context->EndConditionalRender != NULL) context->EndConditionalRenderNVX = (PFNGLENDCONDITIONALRENDERNVXPROC)context->EndConditionalRender;
+    if (context->EndConditionalRenderNVX == NULL && context->EndConditionalRenderNV != NULL) context->EndConditionalRenderNVX = (PFNGLENDCONDITIONALRENDERNVXPROC)context->EndConditionalRenderNV;
+    if (context->EndQuery == NULL && context->EndQueryARB != NULL) context->EndQuery = (PFNGLENDQUERYPROC)context->EndQueryARB;
+    if (context->EndQueryARB == NULL && context->EndQuery != NULL) context->EndQueryARB = (PFNGLENDQUERYARBPROC)context->EndQuery;
+    if (context->EndTransformFeedback == NULL && context->EndTransformFeedbackEXT != NULL) context->EndTransformFeedback = (PFNGLENDTRANSFORMFEEDBACKPROC)context->EndTransformFeedbackEXT;
+    if (context->EndTransformFeedback == NULL && context->EndTransformFeedbackNV != NULL) context->EndTransformFeedback = (PFNGLENDTRANSFORMFEEDBACKPROC)context->EndTransformFeedbackNV;
+    if (context->EndTransformFeedbackEXT == NULL && context->EndTransformFeedback != NULL) context->EndTransformFeedbackEXT = (PFNGLENDTRANSFORMFEEDBACKEXTPROC)context->EndTransformFeedback;
+    if (context->EndTransformFeedbackEXT == NULL && context->EndTransformFeedbackNV != NULL) context->EndTransformFeedbackEXT = (PFNGLENDTRANSFORMFEEDBACKEXTPROC)context->EndTransformFeedbackNV;
+    if (context->EndTransformFeedbackNV == NULL && context->EndTransformFeedback != NULL) context->EndTransformFeedbackNV = (PFNGLENDTRANSFORMFEEDBACKNVPROC)context->EndTransformFeedback;
+    if (context->EndTransformFeedbackNV == NULL && context->EndTransformFeedbackEXT != NULL) context->EndTransformFeedbackNV = (PFNGLENDTRANSFORMFEEDBACKNVPROC)context->EndTransformFeedbackEXT;
+    if (context->FlushMappedBufferRange == NULL && context->FlushMappedBufferRangeAPPLE != NULL) context->FlushMappedBufferRange = (PFNGLFLUSHMAPPEDBUFFERRANGEPROC)context->FlushMappedBufferRangeAPPLE;
+    if (context->FlushMappedBufferRangeAPPLE == NULL && context->FlushMappedBufferRange != NULL) context->FlushMappedBufferRangeAPPLE = (PFNGLFLUSHMAPPEDBUFFERRANGEAPPLEPROC)context->FlushMappedBufferRange;
+    if (context->FramebufferRenderbuffer == NULL && context->FramebufferRenderbufferEXT != NULL) context->FramebufferRenderbuffer = (PFNGLFRAMEBUFFERRENDERBUFFERPROC)context->FramebufferRenderbufferEXT;
+    if (context->FramebufferRenderbufferEXT == NULL && context->FramebufferRenderbuffer != NULL) context->FramebufferRenderbufferEXT = (PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC)context->FramebufferRenderbuffer;
+    if (context->FramebufferTexture == NULL && context->FramebufferTextureARB != NULL) context->FramebufferTexture = (PFNGLFRAMEBUFFERTEXTUREPROC)context->FramebufferTextureARB;
+    if (context->FramebufferTexture == NULL && context->FramebufferTextureEXT != NULL) context->FramebufferTexture = (PFNGLFRAMEBUFFERTEXTUREPROC)context->FramebufferTextureEXT;
+    if (context->FramebufferTexture1D == NULL && context->FramebufferTexture1DEXT != NULL) context->FramebufferTexture1D = (PFNGLFRAMEBUFFERTEXTURE1DPROC)context->FramebufferTexture1DEXT;
+    if (context->FramebufferTexture1DEXT == NULL && context->FramebufferTexture1D != NULL) context->FramebufferTexture1DEXT = (PFNGLFRAMEBUFFERTEXTURE1DEXTPROC)context->FramebufferTexture1D;
+    if (context->FramebufferTexture2D == NULL && context->FramebufferTexture2DEXT != NULL) context->FramebufferTexture2D = (PFNGLFRAMEBUFFERTEXTURE2DPROC)context->FramebufferTexture2DEXT;
+    if (context->FramebufferTexture2DEXT == NULL && context->FramebufferTexture2D != NULL) context->FramebufferTexture2DEXT = (PFNGLFRAMEBUFFERTEXTURE2DEXTPROC)context->FramebufferTexture2D;
+    if (context->FramebufferTexture3D == NULL && context->FramebufferTexture3DEXT != NULL) context->FramebufferTexture3D = (PFNGLFRAMEBUFFERTEXTURE3DPROC)context->FramebufferTexture3DEXT;
+    if (context->FramebufferTexture3DEXT == NULL && context->FramebufferTexture3D != NULL) context->FramebufferTexture3DEXT = (PFNGLFRAMEBUFFERTEXTURE3DEXTPROC)context->FramebufferTexture3D;
+    if (context->FramebufferTextureARB == NULL && context->FramebufferTexture != NULL) context->FramebufferTextureARB = (PFNGLFRAMEBUFFERTEXTUREARBPROC)context->FramebufferTexture;
+    if (context->FramebufferTextureARB == NULL && context->FramebufferTextureEXT != NULL) context->FramebufferTextureARB = (PFNGLFRAMEBUFFERTEXTUREARBPROC)context->FramebufferTextureEXT;
+    if (context->FramebufferTextureEXT == NULL && context->FramebufferTexture != NULL) context->FramebufferTextureEXT = (PFNGLFRAMEBUFFERTEXTUREEXTPROC)context->FramebufferTexture;
+    if (context->FramebufferTextureEXT == NULL && context->FramebufferTextureARB != NULL) context->FramebufferTextureEXT = (PFNGLFRAMEBUFFERTEXTUREEXTPROC)context->FramebufferTextureARB;
+    if (context->FramebufferTextureFaceARB == NULL && context->FramebufferTextureFaceEXT != NULL) context->FramebufferTextureFaceARB = (PFNGLFRAMEBUFFERTEXTUREFACEARBPROC)context->FramebufferTextureFaceEXT;
+    if (context->FramebufferTextureFaceEXT == NULL && context->FramebufferTextureFaceARB != NULL) context->FramebufferTextureFaceEXT = (PFNGLFRAMEBUFFERTEXTUREFACEEXTPROC)context->FramebufferTextureFaceARB;
+    if (context->FramebufferTextureLayer == NULL && context->FramebufferTextureLayerARB != NULL) context->FramebufferTextureLayer = (PFNGLFRAMEBUFFERTEXTURELAYERPROC)context->FramebufferTextureLayerARB;
+    if (context->FramebufferTextureLayer == NULL && context->FramebufferTextureLayerEXT != NULL) context->FramebufferTextureLayer = (PFNGLFRAMEBUFFERTEXTURELAYERPROC)context->FramebufferTextureLayerEXT;
+    if (context->FramebufferTextureLayerARB == NULL && context->FramebufferTextureLayer != NULL) context->FramebufferTextureLayerARB = (PFNGLFRAMEBUFFERTEXTURELAYERARBPROC)context->FramebufferTextureLayer;
+    if (context->FramebufferTextureLayerARB == NULL && context->FramebufferTextureLayerEXT != NULL) context->FramebufferTextureLayerARB = (PFNGLFRAMEBUFFERTEXTURELAYERARBPROC)context->FramebufferTextureLayerEXT;
+    if (context->FramebufferTextureLayerEXT == NULL && context->FramebufferTextureLayer != NULL) context->FramebufferTextureLayerEXT = (PFNGLFRAMEBUFFERTEXTURELAYEREXTPROC)context->FramebufferTextureLayer;
+    if (context->FramebufferTextureLayerEXT == NULL && context->FramebufferTextureLayerARB != NULL) context->FramebufferTextureLayerEXT = (PFNGLFRAMEBUFFERTEXTURELAYEREXTPROC)context->FramebufferTextureLayerARB;
+    if (context->GenBuffers == NULL && context->GenBuffersARB != NULL) context->GenBuffers = (PFNGLGENBUFFERSPROC)context->GenBuffersARB;
+    if (context->GenBuffersARB == NULL && context->GenBuffers != NULL) context->GenBuffersARB = (PFNGLGENBUFFERSARBPROC)context->GenBuffers;
+    if (context->GenerateMipmap == NULL && context->GenerateMipmapEXT != NULL) context->GenerateMipmap = (PFNGLGENERATEMIPMAPPROC)context->GenerateMipmapEXT;
+    if (context->GenerateMipmapEXT == NULL && context->GenerateMipmap != NULL) context->GenerateMipmapEXT = (PFNGLGENERATEMIPMAPEXTPROC)context->GenerateMipmap;
+    if (context->GenFramebuffers == NULL && context->GenFramebuffersEXT != NULL) context->GenFramebuffers = (PFNGLGENFRAMEBUFFERSPROC)context->GenFramebuffersEXT;
+    if (context->GenFramebuffersEXT == NULL && context->GenFramebuffers != NULL) context->GenFramebuffersEXT = (PFNGLGENFRAMEBUFFERSEXTPROC)context->GenFramebuffers;
+    if (context->GenProgramsARB == NULL && context->GenProgramsNV != NULL) context->GenProgramsARB = (PFNGLGENPROGRAMSARBPROC)context->GenProgramsNV;
+    if (context->GenProgramsNV == NULL && context->GenProgramsARB != NULL) context->GenProgramsNV = (PFNGLGENPROGRAMSNVPROC)context->GenProgramsARB;
+    if (context->GenQueries == NULL && context->GenQueriesARB != NULL) context->GenQueries = (PFNGLGENQUERIESPROC)context->GenQueriesARB;
+    if (context->GenQueriesARB == NULL && context->GenQueries != NULL) context->GenQueriesARB = (PFNGLGENQUERIESARBPROC)context->GenQueries;
+    if (context->GenRenderbuffers == NULL && context->GenRenderbuffersEXT != NULL) context->GenRenderbuffers = (PFNGLGENRENDERBUFFERSPROC)context->GenRenderbuffersEXT;
+    if (context->GenRenderbuffersEXT == NULL && context->GenRenderbuffers != NULL) context->GenRenderbuffersEXT = (PFNGLGENRENDERBUFFERSEXTPROC)context->GenRenderbuffers;
+    if (context->GenVertexArrays == NULL && context->GenVertexArraysAPPLE != NULL) context->GenVertexArrays = (PFNGLGENVERTEXARRAYSPROC)context->GenVertexArraysAPPLE;
+    if (context->GenVertexArraysAPPLE == NULL && context->GenVertexArrays != NULL) context->GenVertexArraysAPPLE = (PFNGLGENVERTEXARRAYSAPPLEPROC)context->GenVertexArrays;
+    if (context->GetActiveAttrib == NULL && context->GetActiveAttribARB != NULL) context->GetActiveAttrib = (PFNGLGETACTIVEATTRIBPROC)context->GetActiveAttribARB;
+    if (context->GetActiveAttribARB == NULL && context->GetActiveAttrib != NULL) context->GetActiveAttribARB = (PFNGLGETACTIVEATTRIBARBPROC)context->GetActiveAttrib;
+    if (context->GetActiveUniform == NULL && context->GetActiveUniformARB != NULL) context->GetActiveUniform = (PFNGLGETACTIVEUNIFORMPROC)context->GetActiveUniformARB;
+    if (context->GetActiveUniformARB == NULL && context->GetActiveUniform != NULL) context->GetActiveUniformARB = (PFNGLGETACTIVEUNIFORMARBPROC)context->GetActiveUniform;
+    if (context->GetAttribLocation == NULL && context->GetAttribLocationARB != NULL) context->GetAttribLocation = (PFNGLGETATTRIBLOCATIONPROC)context->GetAttribLocationARB;
+    if (context->GetAttribLocationARB == NULL && context->GetAttribLocation != NULL) context->GetAttribLocationARB = (PFNGLGETATTRIBLOCATIONARBPROC)context->GetAttribLocation;
+    if (context->GetBooleani_v == NULL && context->GetBooleanIndexedvEXT != NULL) context->GetBooleani_v = (PFNGLGETBOOLEANI_VPROC)context->GetBooleanIndexedvEXT;
+    if (context->GetBooleanIndexedvEXT == NULL && context->GetBooleani_v != NULL) context->GetBooleanIndexedvEXT = (PFNGLGETBOOLEANINDEXEDVEXTPROC)context->GetBooleani_v;
+    if (context->GetBufferParameteriv == NULL && context->GetBufferParameterivARB != NULL) context->GetBufferParameteriv = (PFNGLGETBUFFERPARAMETERIVPROC)context->GetBufferParameterivARB;
+    if (context->GetBufferParameterivARB == NULL && context->GetBufferParameteriv != NULL) context->GetBufferParameterivARB = (PFNGLGETBUFFERPARAMETERIVARBPROC)context->GetBufferParameteriv;
+    if (context->GetBufferPointerv == NULL && context->GetBufferPointervARB != NULL) context->GetBufferPointerv = (PFNGLGETBUFFERPOINTERVPROC)context->GetBufferPointervARB;
+    if (context->GetBufferPointervARB == NULL && context->GetBufferPointerv != NULL) context->GetBufferPointervARB = (PFNGLGETBUFFERPOINTERVARBPROC)context->GetBufferPointerv;
+    if (context->GetBufferSubData == NULL && context->GetBufferSubDataARB != NULL) context->GetBufferSubData = (PFNGLGETBUFFERSUBDATAPROC)context->GetBufferSubDataARB;
+    if (context->GetBufferSubDataARB == NULL && context->GetBufferSubData != NULL) context->GetBufferSubDataARB = (PFNGLGETBUFFERSUBDATAARBPROC)context->GetBufferSubData;
+    if (context->GetCompressedTexImage == NULL && context->GetCompressedTexImageARB != NULL) context->GetCompressedTexImage = (PFNGLGETCOMPRESSEDTEXIMAGEPROC)context->GetCompressedTexImageARB;
+    if (context->GetCompressedTexImageARB == NULL && context->GetCompressedTexImage != NULL) context->GetCompressedTexImageARB = (PFNGLGETCOMPRESSEDTEXIMAGEARBPROC)context->GetCompressedTexImage;
+    if (context->GetFragDataLocation == NULL && context->GetFragDataLocationEXT != NULL) context->GetFragDataLocation = (PFNGLGETFRAGDATALOCATIONPROC)context->GetFragDataLocationEXT;
+    if (context->GetFragDataLocationEXT == NULL && context->GetFragDataLocation != NULL) context->GetFragDataLocationEXT = (PFNGLGETFRAGDATALOCATIONEXTPROC)context->GetFragDataLocation;
+    if (context->GetFramebufferAttachmentParameteriv == NULL && context->GetFramebufferAttachmentParameterivEXT != NULL) context->GetFramebufferAttachmentParameteriv = (PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC)context->GetFramebufferAttachmentParameterivEXT;
+    if (context->GetFramebufferAttachmentParameterivEXT == NULL && context->GetFramebufferAttachmentParameteriv != NULL) context->GetFramebufferAttachmentParameterivEXT = (PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC)context->GetFramebufferAttachmentParameteriv;
+    if (context->GetIntegeri_v == NULL && context->GetIntegerIndexedvEXT != NULL) context->GetIntegeri_v = (PFNGLGETINTEGERI_VPROC)context->GetIntegerIndexedvEXT;
+    if (context->GetIntegerIndexedvEXT == NULL && context->GetIntegeri_v != NULL) context->GetIntegerIndexedvEXT = (PFNGLGETINTEGERINDEXEDVEXTPROC)context->GetIntegeri_v;
+    if (context->GetMultisamplefv == NULL && context->GetMultisamplefvNV != NULL) context->GetMultisamplefv = (PFNGLGETMULTISAMPLEFVPROC)context->GetMultisamplefvNV;
+    if (context->GetMultisamplefvNV == NULL && context->GetMultisamplefv != NULL) context->GetMultisamplefvNV = (PFNGLGETMULTISAMPLEFVNVPROC)context->GetMultisamplefv;
+    if (context->GetQueryiv == NULL && context->GetQueryivARB != NULL) context->GetQueryiv = (PFNGLGETQUERYIVPROC)context->GetQueryivARB;
+    if (context->GetQueryivARB == NULL && context->GetQueryiv != NULL) context->GetQueryivARB = (PFNGLGETQUERYIVARBPROC)context->GetQueryiv;
+    if (context->GetQueryObjectiv == NULL && context->GetQueryObjectivARB != NULL) context->GetQueryObjectiv = (PFNGLGETQUERYOBJECTIVPROC)context->GetQueryObjectivARB;
+    if (context->GetQueryObjectivARB == NULL && context->GetQueryObjectiv != NULL) context->GetQueryObjectivARB = (PFNGLGETQUERYOBJECTIVARBPROC)context->GetQueryObjectiv;
+    if (context->GetQueryObjectuiv == NULL && context->GetQueryObjectuivARB != NULL) context->GetQueryObjectuiv = (PFNGLGETQUERYOBJECTUIVPROC)context->GetQueryObjectuivARB;
+    if (context->GetQueryObjectuivARB == NULL && context->GetQueryObjectuiv != NULL) context->GetQueryObjectuivARB = (PFNGLGETQUERYOBJECTUIVARBPROC)context->GetQueryObjectuiv;
+    if (context->GetRenderbufferParameteriv == NULL && context->GetRenderbufferParameterivEXT != NULL) context->GetRenderbufferParameteriv = (PFNGLGETRENDERBUFFERPARAMETERIVPROC)context->GetRenderbufferParameterivEXT;
+    if (context->GetRenderbufferParameterivEXT == NULL && context->GetRenderbufferParameteriv != NULL) context->GetRenderbufferParameterivEXT = (PFNGLGETRENDERBUFFERPARAMETERIVEXTPROC)context->GetRenderbufferParameteriv;
+    if (context->GetShaderSource == NULL && context->GetShaderSourceARB != NULL) context->GetShaderSource = (PFNGLGETSHADERSOURCEPROC)context->GetShaderSourceARB;
+    if (context->GetShaderSourceARB == NULL && context->GetShaderSource != NULL) context->GetShaderSourceARB = (PFNGLGETSHADERSOURCEARBPROC)context->GetShaderSource;
+    if (context->GetTexParameterIiv == NULL && context->GetTexParameterIivEXT != NULL) context->GetTexParameterIiv = (PFNGLGETTEXPARAMETERIIVPROC)context->GetTexParameterIivEXT;
+    if (context->GetTexParameterIivEXT == NULL && context->GetTexParameterIiv != NULL) context->GetTexParameterIivEXT = (PFNGLGETTEXPARAMETERIIVEXTPROC)context->GetTexParameterIiv;
+    if (context->GetTexParameterIuiv == NULL && context->GetTexParameterIuivEXT != NULL) context->GetTexParameterIuiv = (PFNGLGETTEXPARAMETERIUIVPROC)context->GetTexParameterIuivEXT;
+    if (context->GetTexParameterIuivEXT == NULL && context->GetTexParameterIuiv != NULL) context->GetTexParameterIuivEXT = (PFNGLGETTEXPARAMETERIUIVEXTPROC)context->GetTexParameterIuiv;
+    if (context->GetTransformFeedbackVarying == NULL && context->GetTransformFeedbackVaryingEXT != NULL) context->GetTransformFeedbackVarying = (PFNGLGETTRANSFORMFEEDBACKVARYINGPROC)context->GetTransformFeedbackVaryingEXT;
+    if (context->GetTransformFeedbackVaryingEXT == NULL && context->GetTransformFeedbackVarying != NULL) context->GetTransformFeedbackVaryingEXT = (PFNGLGETTRANSFORMFEEDBACKVARYINGEXTPROC)context->GetTransformFeedbackVarying;
+    if (context->GetUniformfv == NULL && context->GetUniformfvARB != NULL) context->GetUniformfv = (PFNGLGETUNIFORMFVPROC)context->GetUniformfvARB;
+    if (context->GetUniformfvARB == NULL && context->GetUniformfv != NULL) context->GetUniformfvARB = (PFNGLGETUNIFORMFVARBPROC)context->GetUniformfv;
+    if (context->GetUniformiv == NULL && context->GetUniformivARB != NULL) context->GetUniformiv = (PFNGLGETUNIFORMIVPROC)context->GetUniformivARB;
+    if (context->GetUniformivARB == NULL && context->GetUniformiv != NULL) context->GetUniformivARB = (PFNGLGETUNIFORMIVARBPROC)context->GetUniformiv;
+    if (context->GetUniformLocation == NULL && context->GetUniformLocationARB != NULL) context->GetUniformLocation = (PFNGLGETUNIFORMLOCATIONPROC)context->GetUniformLocationARB;
+    if (context->GetUniformLocationARB == NULL && context->GetUniformLocation != NULL) context->GetUniformLocationARB = (PFNGLGETUNIFORMLOCATIONARBPROC)context->GetUniformLocation;
+    if (context->GetUniformuiv == NULL && context->GetUniformuivEXT != NULL) context->GetUniformuiv = (PFNGLGETUNIFORMUIVPROC)context->GetUniformuivEXT;
+    if (context->GetUniformuivEXT == NULL && context->GetUniformuiv != NULL) context->GetUniformuivEXT = (PFNGLGETUNIFORMUIVEXTPROC)context->GetUniformuiv;
+    if (context->GetVertexAttribdv == NULL && context->GetVertexAttribdvARB != NULL) context->GetVertexAttribdv = (PFNGLGETVERTEXATTRIBDVPROC)context->GetVertexAttribdvARB;
+    if (context->GetVertexAttribdv == NULL && context->GetVertexAttribdvNV != NULL) context->GetVertexAttribdv = (PFNGLGETVERTEXATTRIBDVPROC)context->GetVertexAttribdvNV;
+    if (context->GetVertexAttribdvARB == NULL && context->GetVertexAttribdv != NULL) context->GetVertexAttribdvARB = (PFNGLGETVERTEXATTRIBDVARBPROC)context->GetVertexAttribdv;
+    if (context->GetVertexAttribdvARB == NULL && context->GetVertexAttribdvNV != NULL) context->GetVertexAttribdvARB = (PFNGLGETVERTEXATTRIBDVARBPROC)context->GetVertexAttribdvNV;
+    if (context->GetVertexAttribdvNV == NULL && context->GetVertexAttribdv != NULL) context->GetVertexAttribdvNV = (PFNGLGETVERTEXATTRIBDVNVPROC)context->GetVertexAttribdv;
+    if (context->GetVertexAttribdvNV == NULL && context->GetVertexAttribdvARB != NULL) context->GetVertexAttribdvNV = (PFNGLGETVERTEXATTRIBDVNVPROC)context->GetVertexAttribdvARB;
+    if (context->GetVertexAttribfv == NULL && context->GetVertexAttribfvARB != NULL) context->GetVertexAttribfv = (PFNGLGETVERTEXATTRIBFVPROC)context->GetVertexAttribfvARB;
+    if (context->GetVertexAttribfv == NULL && context->GetVertexAttribfvNV != NULL) context->GetVertexAttribfv = (PFNGLGETVERTEXATTRIBFVPROC)context->GetVertexAttribfvNV;
+    if (context->GetVertexAttribfvARB == NULL && context->GetVertexAttribfv != NULL) context->GetVertexAttribfvARB = (PFNGLGETVERTEXATTRIBFVARBPROC)context->GetVertexAttribfv;
+    if (context->GetVertexAttribfvARB == NULL && context->GetVertexAttribfvNV != NULL) context->GetVertexAttribfvARB = (PFNGLGETVERTEXATTRIBFVARBPROC)context->GetVertexAttribfvNV;
+    if (context->GetVertexAttribfvNV == NULL && context->GetVertexAttribfv != NULL) context->GetVertexAttribfvNV = (PFNGLGETVERTEXATTRIBFVNVPROC)context->GetVertexAttribfv;
+    if (context->GetVertexAttribfvNV == NULL && context->GetVertexAttribfvARB != NULL) context->GetVertexAttribfvNV = (PFNGLGETVERTEXATTRIBFVNVPROC)context->GetVertexAttribfvARB;
+    if (context->GetVertexAttribIiv == NULL && context->GetVertexAttribIivEXT != NULL) context->GetVertexAttribIiv = (PFNGLGETVERTEXATTRIBIIVPROC)context->GetVertexAttribIivEXT;
+    if (context->GetVertexAttribIivEXT == NULL && context->GetVertexAttribIiv != NULL) context->GetVertexAttribIivEXT = (PFNGLGETVERTEXATTRIBIIVEXTPROC)context->GetVertexAttribIiv;
+    if (context->GetVertexAttribIuiv == NULL && context->GetVertexAttribIuivEXT != NULL) context->GetVertexAttribIuiv = (PFNGLGETVERTEXATTRIBIUIVPROC)context->GetVertexAttribIuivEXT;
+    if (context->GetVertexAttribIuivEXT == NULL && context->GetVertexAttribIuiv != NULL) context->GetVertexAttribIuivEXT = (PFNGLGETVERTEXATTRIBIUIVEXTPROC)context->GetVertexAttribIuiv;
+    if (context->GetVertexAttribiv == NULL && context->GetVertexAttribivARB != NULL) context->GetVertexAttribiv = (PFNGLGETVERTEXATTRIBIVPROC)context->GetVertexAttribivARB;
+    if (context->GetVertexAttribiv == NULL && context->GetVertexAttribivNV != NULL) context->GetVertexAttribiv = (PFNGLGETVERTEXATTRIBIVPROC)context->GetVertexAttribivNV;
+    if (context->GetVertexAttribivARB == NULL && context->GetVertexAttribiv != NULL) context->GetVertexAttribivARB = (PFNGLGETVERTEXATTRIBIVARBPROC)context->GetVertexAttribiv;
+    if (context->GetVertexAttribivARB == NULL && context->GetVertexAttribivNV != NULL) context->GetVertexAttribivARB = (PFNGLGETVERTEXATTRIBIVARBPROC)context->GetVertexAttribivNV;
+    if (context->GetVertexAttribivNV == NULL && context->GetVertexAttribiv != NULL) context->GetVertexAttribivNV = (PFNGLGETVERTEXATTRIBIVNVPROC)context->GetVertexAttribiv;
+    if (context->GetVertexAttribivNV == NULL && context->GetVertexAttribivARB != NULL) context->GetVertexAttribivNV = (PFNGLGETVERTEXATTRIBIVNVPROC)context->GetVertexAttribivARB;
+    if (context->GetVertexAttribPointerv == NULL && context->GetVertexAttribPointervARB != NULL) context->GetVertexAttribPointerv = (PFNGLGETVERTEXATTRIBPOINTERVPROC)context->GetVertexAttribPointervARB;
+    if (context->GetVertexAttribPointerv == NULL && context->GetVertexAttribPointervNV != NULL) context->GetVertexAttribPointerv = (PFNGLGETVERTEXATTRIBPOINTERVPROC)context->GetVertexAttribPointervNV;
+    if (context->GetVertexAttribPointervARB == NULL && context->GetVertexAttribPointerv != NULL) context->GetVertexAttribPointervARB = (PFNGLGETVERTEXATTRIBPOINTERVARBPROC)context->GetVertexAttribPointerv;
+    if (context->GetVertexAttribPointervARB == NULL && context->GetVertexAttribPointervNV != NULL) context->GetVertexAttribPointervARB = (PFNGLGETVERTEXATTRIBPOINTERVARBPROC)context->GetVertexAttribPointervNV;
+    if (context->GetVertexAttribPointervNV == NULL && context->GetVertexAttribPointerv != NULL) context->GetVertexAttribPointervNV = (PFNGLGETVERTEXATTRIBPOINTERVNVPROC)context->GetVertexAttribPointerv;
+    if (context->GetVertexAttribPointervNV == NULL && context->GetVertexAttribPointervARB != NULL) context->GetVertexAttribPointervNV = (PFNGLGETVERTEXATTRIBPOINTERVNVPROC)context->GetVertexAttribPointervARB;
+    if (context->IsBuffer == NULL && context->IsBufferARB != NULL) context->IsBuffer = (PFNGLISBUFFERPROC)context->IsBufferARB;
+    if (context->IsBufferARB == NULL && context->IsBuffer != NULL) context->IsBufferARB = (PFNGLISBUFFERARBPROC)context->IsBuffer;
+    if (context->IsEnabledi == NULL && context->IsEnabledIndexedEXT != NULL) context->IsEnabledi = (PFNGLISENABLEDIPROC)context->IsEnabledIndexedEXT;
+    if (context->IsEnabledIndexedEXT == NULL && context->IsEnabledi != NULL) context->IsEnabledIndexedEXT = (PFNGLISENABLEDINDEXEDEXTPROC)context->IsEnabledi;
+    if (context->IsFramebuffer == NULL && context->IsFramebufferEXT != NULL) context->IsFramebuffer = (PFNGLISFRAMEBUFFERPROC)context->IsFramebufferEXT;
+    if (context->IsFramebufferEXT == NULL && context->IsFramebuffer != NULL) context->IsFramebufferEXT = (PFNGLISFRAMEBUFFEREXTPROC)context->IsFramebuffer;
+    if (context->IsProgramARB == NULL && context->IsProgramNV != NULL) context->IsProgramARB = (PFNGLISPROGRAMARBPROC)context->IsProgramNV;
+    if (context->IsProgramNV == NULL && context->IsProgramARB != NULL) context->IsProgramNV = (PFNGLISPROGRAMNVPROC)context->IsProgramARB;
+    if (context->IsQuery == NULL && context->IsQueryARB != NULL) context->IsQuery = (PFNGLISQUERYPROC)context->IsQueryARB;
+    if (context->IsQueryARB == NULL && context->IsQuery != NULL) context->IsQueryARB = (PFNGLISQUERYARBPROC)context->IsQuery;
+    if (context->IsRenderbuffer == NULL && context->IsRenderbufferEXT != NULL) context->IsRenderbuffer = (PFNGLISRENDERBUFFERPROC)context->IsRenderbufferEXT;
+    if (context->IsRenderbufferEXT == NULL && context->IsRenderbuffer != NULL) context->IsRenderbufferEXT = (PFNGLISRENDERBUFFEREXTPROC)context->IsRenderbuffer;
+    if (context->IsVertexArray == NULL && context->IsVertexArrayAPPLE != NULL) context->IsVertexArray = (PFNGLISVERTEXARRAYPROC)context->IsVertexArrayAPPLE;
+    if (context->IsVertexArrayAPPLE == NULL && context->IsVertexArray != NULL) context->IsVertexArrayAPPLE = (PFNGLISVERTEXARRAYAPPLEPROC)context->IsVertexArray;
+    if (context->LinkProgram == NULL && context->LinkProgramARB != NULL) context->LinkProgram = (PFNGLLINKPROGRAMPROC)context->LinkProgramARB;
+    if (context->LinkProgramARB == NULL && context->LinkProgram != NULL) context->LinkProgramARB = (PFNGLLINKPROGRAMARBPROC)context->LinkProgram;
+    if (context->MapBuffer == NULL && context->MapBufferARB != NULL) context->MapBuffer = (PFNGLMAPBUFFERPROC)context->MapBufferARB;
+    if (context->MapBufferARB == NULL && context->MapBuffer != NULL) context->MapBufferARB = (PFNGLMAPBUFFERARBPROC)context->MapBuffer;
+    if (context->MultiDrawArrays == NULL && context->MultiDrawArraysEXT != NULL) context->MultiDrawArrays = (PFNGLMULTIDRAWARRAYSPROC)context->MultiDrawArraysEXT;
+    if (context->MultiDrawArraysEXT == NULL && context->MultiDrawArrays != NULL) context->MultiDrawArraysEXT = (PFNGLMULTIDRAWARRAYSEXTPROC)context->MultiDrawArrays;
+    if (context->MultiDrawElements == NULL && context->MultiDrawElementsEXT != NULL) context->MultiDrawElements = (PFNGLMULTIDRAWELEMENTSPROC)context->MultiDrawElementsEXT;
+    if (context->MultiDrawElementsEXT == NULL && context->MultiDrawElements != NULL) context->MultiDrawElementsEXT = (PFNGLMULTIDRAWELEMENTSEXTPROC)context->MultiDrawElements;
+    if (context->PointParameterf == NULL && context->PointParameterfARB != NULL) context->PointParameterf = (PFNGLPOINTPARAMETERFPROC)context->PointParameterfARB;
+    if (context->PointParameterf == NULL && context->PointParameterfEXT != NULL) context->PointParameterf = (PFNGLPOINTPARAMETERFPROC)context->PointParameterfEXT;
+    if (context->PointParameterf == NULL && context->PointParameterfSGIS != NULL) context->PointParameterf = (PFNGLPOINTPARAMETERFPROC)context->PointParameterfSGIS;
+    if (context->PointParameterfARB == NULL && context->PointParameterf != NULL) context->PointParameterfARB = (PFNGLPOINTPARAMETERFARBPROC)context->PointParameterf;
+    if (context->PointParameterfARB == NULL && context->PointParameterfEXT != NULL) context->PointParameterfARB = (PFNGLPOINTPARAMETERFARBPROC)context->PointParameterfEXT;
+    if (context->PointParameterfARB == NULL && context->PointParameterfSGIS != NULL) context->PointParameterfARB = (PFNGLPOINTPARAMETERFARBPROC)context->PointParameterfSGIS;
+    if (context->PointParameterfEXT == NULL && context->PointParameterf != NULL) context->PointParameterfEXT = (PFNGLPOINTPARAMETERFEXTPROC)context->PointParameterf;
+    if (context->PointParameterfEXT == NULL && context->PointParameterfARB != NULL) context->PointParameterfEXT = (PFNGLPOINTPARAMETERFEXTPROC)context->PointParameterfARB;
+    if (context->PointParameterfEXT == NULL && context->PointParameterfSGIS != NULL) context->PointParameterfEXT = (PFNGLPOINTPARAMETERFEXTPROC)context->PointParameterfSGIS;
+    if (context->PointParameterfSGIS == NULL && context->PointParameterf != NULL) context->PointParameterfSGIS = (PFNGLPOINTPARAMETERFSGISPROC)context->PointParameterf;
+    if (context->PointParameterfSGIS == NULL && context->PointParameterfARB != NULL) context->PointParameterfSGIS = (PFNGLPOINTPARAMETERFSGISPROC)context->PointParameterfARB;
+    if (context->PointParameterfSGIS == NULL && context->PointParameterfEXT != NULL) context->PointParameterfSGIS = (PFNGLPOINTPARAMETERFSGISPROC)context->PointParameterfEXT;
+    if (context->PointParameterfv == NULL && context->PointParameterfvARB != NULL) context->PointParameterfv = (PFNGLPOINTPARAMETERFVPROC)context->PointParameterfvARB;
+    if (context->PointParameterfv == NULL && context->PointParameterfvEXT != NULL) context->PointParameterfv = (PFNGLPOINTPARAMETERFVPROC)context->PointParameterfvEXT;
+    if (context->PointParameterfv == NULL && context->PointParameterfvSGIS != NULL) context->PointParameterfv = (PFNGLPOINTPARAMETERFVPROC)context->PointParameterfvSGIS;
+    if (context->PointParameterfvARB == NULL && context->PointParameterfv != NULL) context->PointParameterfvARB = (PFNGLPOINTPARAMETERFVARBPROC)context->PointParameterfv;
+    if (context->PointParameterfvARB == NULL && context->PointParameterfvEXT != NULL) context->PointParameterfvARB = (PFNGLPOINTPARAMETERFVARBPROC)context->PointParameterfvEXT;
+    if (context->PointParameterfvARB == NULL && context->PointParameterfvSGIS != NULL) context->PointParameterfvARB = (PFNGLPOINTPARAMETERFVARBPROC)context->PointParameterfvSGIS;
+    if (context->PointParameterfvEXT == NULL && context->PointParameterfv != NULL) context->PointParameterfvEXT = (PFNGLPOINTPARAMETERFVEXTPROC)context->PointParameterfv;
+    if (context->PointParameterfvEXT == NULL && context->PointParameterfvARB != NULL) context->PointParameterfvEXT = (PFNGLPOINTPARAMETERFVEXTPROC)context->PointParameterfvARB;
+    if (context->PointParameterfvEXT == NULL && context->PointParameterfvSGIS != NULL) context->PointParameterfvEXT = (PFNGLPOINTPARAMETERFVEXTPROC)context->PointParameterfvSGIS;
+    if (context->PointParameterfvSGIS == NULL && context->PointParameterfv != NULL) context->PointParameterfvSGIS = (PFNGLPOINTPARAMETERFVSGISPROC)context->PointParameterfv;
+    if (context->PointParameterfvSGIS == NULL && context->PointParameterfvARB != NULL) context->PointParameterfvSGIS = (PFNGLPOINTPARAMETERFVSGISPROC)context->PointParameterfvARB;
+    if (context->PointParameterfvSGIS == NULL && context->PointParameterfvEXT != NULL) context->PointParameterfvSGIS = (PFNGLPOINTPARAMETERFVSGISPROC)context->PointParameterfvEXT;
+    if (context->PointParameteri == NULL && context->PointParameteriNV != NULL) context->PointParameteri = (PFNGLPOINTPARAMETERIPROC)context->PointParameteriNV;
+    if (context->PointParameteriNV == NULL && context->PointParameteri != NULL) context->PointParameteriNV = (PFNGLPOINTPARAMETERINVPROC)context->PointParameteri;
+    if (context->PointParameteriv == NULL && context->PointParameterivNV != NULL) context->PointParameteriv = (PFNGLPOINTPARAMETERIVPROC)context->PointParameterivNV;
+    if (context->PointParameterivNV == NULL && context->PointParameteriv != NULL) context->PointParameterivNV = (PFNGLPOINTPARAMETERIVNVPROC)context->PointParameteriv;
+    if (context->ProvokingVertex == NULL && context->ProvokingVertexEXT != NULL) context->ProvokingVertex = (PFNGLPROVOKINGVERTEXPROC)context->ProvokingVertexEXT;
+    if (context->ProvokingVertexEXT == NULL && context->ProvokingVertex != NULL) context->ProvokingVertexEXT = (PFNGLPROVOKINGVERTEXEXTPROC)context->ProvokingVertex;
+    if (context->RenderbufferStorage == NULL && context->RenderbufferStorageEXT != NULL) context->RenderbufferStorage = (PFNGLRENDERBUFFERSTORAGEPROC)context->RenderbufferStorageEXT;
+    if (context->RenderbufferStorageEXT == NULL && context->RenderbufferStorage != NULL) context->RenderbufferStorageEXT = (PFNGLRENDERBUFFERSTORAGEEXTPROC)context->RenderbufferStorage;
+    if (context->RenderbufferStorageMultisample == NULL && context->RenderbufferStorageMultisampleEXT != NULL) context->RenderbufferStorageMultisample = (PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC)context->RenderbufferStorageMultisampleEXT;
+    if (context->RenderbufferStorageMultisampleEXT == NULL && context->RenderbufferStorageMultisample != NULL) context->RenderbufferStorageMultisampleEXT = (PFNGLRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC)context->RenderbufferStorageMultisample;
+    if (context->SampleCoverage == NULL && context->SampleCoverageARB != NULL) context->SampleCoverage = (PFNGLSAMPLECOVERAGEPROC)context->SampleCoverageARB;
+    if (context->SampleCoverageARB == NULL && context->SampleCoverage != NULL) context->SampleCoverageARB = (PFNGLSAMPLECOVERAGEARBPROC)context->SampleCoverage;
+    if (context->ShaderSource == NULL && context->ShaderSourceARB != NULL) context->ShaderSource = (PFNGLSHADERSOURCEPROC)context->ShaderSourceARB;
+    if (context->ShaderSourceARB == NULL && context->ShaderSource != NULL) context->ShaderSourceARB = (PFNGLSHADERSOURCEARBPROC)context->ShaderSource;
+    if (context->StencilOpSeparate == NULL && context->StencilOpSeparateATI != NULL) context->StencilOpSeparate = (PFNGLSTENCILOPSEPARATEPROC)context->StencilOpSeparateATI;
+    if (context->StencilOpSeparateATI == NULL && context->StencilOpSeparate != NULL) context->StencilOpSeparateATI = (PFNGLSTENCILOPSEPARATEATIPROC)context->StencilOpSeparate;
+    if (context->TexBuffer == NULL && context->TexBufferARB != NULL) context->TexBuffer = (PFNGLTEXBUFFERPROC)context->TexBufferARB;
+    if (context->TexBuffer == NULL && context->TexBufferEXT != NULL) context->TexBuffer = (PFNGLTEXBUFFERPROC)context->TexBufferEXT;
+    if (context->TexBufferARB == NULL && context->TexBuffer != NULL) context->TexBufferARB = (PFNGLTEXBUFFERARBPROC)context->TexBuffer;
+    if (context->TexBufferARB == NULL && context->TexBufferEXT != NULL) context->TexBufferARB = (PFNGLTEXBUFFERARBPROC)context->TexBufferEXT;
+    if (context->TexBufferEXT == NULL && context->TexBuffer != NULL) context->TexBufferEXT = (PFNGLTEXBUFFEREXTPROC)context->TexBuffer;
+    if (context->TexBufferEXT == NULL && context->TexBufferARB != NULL) context->TexBufferEXT = (PFNGLTEXBUFFEREXTPROC)context->TexBufferARB;
+    if (context->TexImage3D == NULL && context->TexImage3DEXT != NULL) context->TexImage3D = (PFNGLTEXIMAGE3DPROC)context->TexImage3DEXT;
+    if (context->TexImage3DEXT == NULL && context->TexImage3D != NULL) context->TexImage3DEXT = (PFNGLTEXIMAGE3DEXTPROC)context->TexImage3D;
+    if (context->TexParameterIiv == NULL && context->TexParameterIivEXT != NULL) context->TexParameterIiv = (PFNGLTEXPARAMETERIIVPROC)context->TexParameterIivEXT;
+    if (context->TexParameterIivEXT == NULL && context->TexParameterIiv != NULL) context->TexParameterIivEXT = (PFNGLTEXPARAMETERIIVEXTPROC)context->TexParameterIiv;
+    if (context->TexParameterIuiv == NULL && context->TexParameterIuivEXT != NULL) context->TexParameterIuiv = (PFNGLTEXPARAMETERIUIVPROC)context->TexParameterIuivEXT;
+    if (context->TexParameterIuivEXT == NULL && context->TexParameterIuiv != NULL) context->TexParameterIuivEXT = (PFNGLTEXPARAMETERIUIVEXTPROC)context->TexParameterIuiv;
+    if (context->TexSubImage1D == NULL && context->TexSubImage1DEXT != NULL) context->TexSubImage1D = (PFNGLTEXSUBIMAGE1DPROC)context->TexSubImage1DEXT;
+    if (context->TexSubImage1DEXT == NULL && context->TexSubImage1D != NULL) context->TexSubImage1DEXT = (PFNGLTEXSUBIMAGE1DEXTPROC)context->TexSubImage1D;
+    if (context->TexSubImage2D == NULL && context->TexSubImage2DEXT != NULL) context->TexSubImage2D = (PFNGLTEXSUBIMAGE2DPROC)context->TexSubImage2DEXT;
+    if (context->TexSubImage2DEXT == NULL && context->TexSubImage2D != NULL) context->TexSubImage2DEXT = (PFNGLTEXSUBIMAGE2DEXTPROC)context->TexSubImage2D;
+    if (context->TexSubImage3D == NULL && context->TexSubImage3DEXT != NULL) context->TexSubImage3D = (PFNGLTEXSUBIMAGE3DPROC)context->TexSubImage3DEXT;
+    if (context->TexSubImage3DEXT == NULL && context->TexSubImage3D != NULL) context->TexSubImage3DEXT = (PFNGLTEXSUBIMAGE3DEXTPROC)context->TexSubImage3D;
+    if (context->TransformFeedbackVaryings == NULL && context->TransformFeedbackVaryingsEXT != NULL) context->TransformFeedbackVaryings = (PFNGLTRANSFORMFEEDBACKVARYINGSPROC)context->TransformFeedbackVaryingsEXT;
+    if (context->TransformFeedbackVaryingsEXT == NULL && context->TransformFeedbackVaryings != NULL) context->TransformFeedbackVaryingsEXT = (PFNGLTRANSFORMFEEDBACKVARYINGSEXTPROC)context->TransformFeedbackVaryings;
+    if (context->Uniform1f == NULL && context->Uniform1fARB != NULL) context->Uniform1f = (PFNGLUNIFORM1FPROC)context->Uniform1fARB;
+    if (context->Uniform1fARB == NULL && context->Uniform1f != NULL) context->Uniform1fARB = (PFNGLUNIFORM1FARBPROC)context->Uniform1f;
+    if (context->Uniform1fv == NULL && context->Uniform1fvARB != NULL) context->Uniform1fv = (PFNGLUNIFORM1FVPROC)context->Uniform1fvARB;
+    if (context->Uniform1fvARB == NULL && context->Uniform1fv != NULL) context->Uniform1fvARB = (PFNGLUNIFORM1FVARBPROC)context->Uniform1fv;
+    if (context->Uniform1i == NULL && context->Uniform1iARB != NULL) context->Uniform1i = (PFNGLUNIFORM1IPROC)context->Uniform1iARB;
+    if (context->Uniform1iARB == NULL && context->Uniform1i != NULL) context->Uniform1iARB = (PFNGLUNIFORM1IARBPROC)context->Uniform1i;
+    if (context->Uniform1iv == NULL && context->Uniform1ivARB != NULL) context->Uniform1iv = (PFNGLUNIFORM1IVPROC)context->Uniform1ivARB;
+    if (context->Uniform1ivARB == NULL && context->Uniform1iv != NULL) context->Uniform1ivARB = (PFNGLUNIFORM1IVARBPROC)context->Uniform1iv;
+    if (context->Uniform1ui == NULL && context->Uniform1uiEXT != NULL) context->Uniform1ui = (PFNGLUNIFORM1UIPROC)context->Uniform1uiEXT;
+    if (context->Uniform1uiEXT == NULL && context->Uniform1ui != NULL) context->Uniform1uiEXT = (PFNGLUNIFORM1UIEXTPROC)context->Uniform1ui;
+    if (context->Uniform1uiv == NULL && context->Uniform1uivEXT != NULL) context->Uniform1uiv = (PFNGLUNIFORM1UIVPROC)context->Uniform1uivEXT;
+    if (context->Uniform1uivEXT == NULL && context->Uniform1uiv != NULL) context->Uniform1uivEXT = (PFNGLUNIFORM1UIVEXTPROC)context->Uniform1uiv;
+    if (context->Uniform2f == NULL && context->Uniform2fARB != NULL) context->Uniform2f = (PFNGLUNIFORM2FPROC)context->Uniform2fARB;
+    if (context->Uniform2fARB == NULL && context->Uniform2f != NULL) context->Uniform2fARB = (PFNGLUNIFORM2FARBPROC)context->Uniform2f;
+    if (context->Uniform2fv == NULL && context->Uniform2fvARB != NULL) context->Uniform2fv = (PFNGLUNIFORM2FVPROC)context->Uniform2fvARB;
+    if (context->Uniform2fvARB == NULL && context->Uniform2fv != NULL) context->Uniform2fvARB = (PFNGLUNIFORM2FVARBPROC)context->Uniform2fv;
+    if (context->Uniform2i == NULL && context->Uniform2iARB != NULL) context->Uniform2i = (PFNGLUNIFORM2IPROC)context->Uniform2iARB;
+    if (context->Uniform2iARB == NULL && context->Uniform2i != NULL) context->Uniform2iARB = (PFNGLUNIFORM2IARBPROC)context->Uniform2i;
+    if (context->Uniform2iv == NULL && context->Uniform2ivARB != NULL) context->Uniform2iv = (PFNGLUNIFORM2IVPROC)context->Uniform2ivARB;
+    if (context->Uniform2ivARB == NULL && context->Uniform2iv != NULL) context->Uniform2ivARB = (PFNGLUNIFORM2IVARBPROC)context->Uniform2iv;
+    if (context->Uniform2ui == NULL && context->Uniform2uiEXT != NULL) context->Uniform2ui = (PFNGLUNIFORM2UIPROC)context->Uniform2uiEXT;
+    if (context->Uniform2uiEXT == NULL && context->Uniform2ui != NULL) context->Uniform2uiEXT = (PFNGLUNIFORM2UIEXTPROC)context->Uniform2ui;
+    if (context->Uniform2uiv == NULL && context->Uniform2uivEXT != NULL) context->Uniform2uiv = (PFNGLUNIFORM2UIVPROC)context->Uniform2uivEXT;
+    if (context->Uniform2uivEXT == NULL && context->Uniform2uiv != NULL) context->Uniform2uivEXT = (PFNGLUNIFORM2UIVEXTPROC)context->Uniform2uiv;
+    if (context->Uniform3f == NULL && context->Uniform3fARB != NULL) context->Uniform3f = (PFNGLUNIFORM3FPROC)context->Uniform3fARB;
+    if (context->Uniform3fARB == NULL && context->Uniform3f != NULL) context->Uniform3fARB = (PFNGLUNIFORM3FARBPROC)context->Uniform3f;
+    if (context->Uniform3fv == NULL && context->Uniform3fvARB != NULL) context->Uniform3fv = (PFNGLUNIFORM3FVPROC)context->Uniform3fvARB;
+    if (context->Uniform3fvARB == NULL && context->Uniform3fv != NULL) context->Uniform3fvARB = (PFNGLUNIFORM3FVARBPROC)context->Uniform3fv;
+    if (context->Uniform3i == NULL && context->Uniform3iARB != NULL) context->Uniform3i = (PFNGLUNIFORM3IPROC)context->Uniform3iARB;
+    if (context->Uniform3iARB == NULL && context->Uniform3i != NULL) context->Uniform3iARB = (PFNGLUNIFORM3IARBPROC)context->Uniform3i;
+    if (context->Uniform3iv == NULL && context->Uniform3ivARB != NULL) context->Uniform3iv = (PFNGLUNIFORM3IVPROC)context->Uniform3ivARB;
+    if (context->Uniform3ivARB == NULL && context->Uniform3iv != NULL) context->Uniform3ivARB = (PFNGLUNIFORM3IVARBPROC)context->Uniform3iv;
+    if (context->Uniform3ui == NULL && context->Uniform3uiEXT != NULL) context->Uniform3ui = (PFNGLUNIFORM3UIPROC)context->Uniform3uiEXT;
+    if (context->Uniform3uiEXT == NULL && context->Uniform3ui != NULL) context->Uniform3uiEXT = (PFNGLUNIFORM3UIEXTPROC)context->Uniform3ui;
+    if (context->Uniform3uiv == NULL && context->Uniform3uivEXT != NULL) context->Uniform3uiv = (PFNGLUNIFORM3UIVPROC)context->Uniform3uivEXT;
+    if (context->Uniform3uivEXT == NULL && context->Uniform3uiv != NULL) context->Uniform3uivEXT = (PFNGLUNIFORM3UIVEXTPROC)context->Uniform3uiv;
+    if (context->Uniform4f == NULL && context->Uniform4fARB != NULL) context->Uniform4f = (PFNGLUNIFORM4FPROC)context->Uniform4fARB;
+    if (context->Uniform4fARB == NULL && context->Uniform4f != NULL) context->Uniform4fARB = (PFNGLUNIFORM4FARBPROC)context->Uniform4f;
+    if (context->Uniform4fv == NULL && context->Uniform4fvARB != NULL) context->Uniform4fv = (PFNGLUNIFORM4FVPROC)context->Uniform4fvARB;
+    if (context->Uniform4fvARB == NULL && context->Uniform4fv != NULL) context->Uniform4fvARB = (PFNGLUNIFORM4FVARBPROC)context->Uniform4fv;
+    if (context->Uniform4i == NULL && context->Uniform4iARB != NULL) context->Uniform4i = (PFNGLUNIFORM4IPROC)context->Uniform4iARB;
+    if (context->Uniform4iARB == NULL && context->Uniform4i != NULL) context->Uniform4iARB = (PFNGLUNIFORM4IARBPROC)context->Uniform4i;
+    if (context->Uniform4iv == NULL && context->Uniform4ivARB != NULL) context->Uniform4iv = (PFNGLUNIFORM4IVPROC)context->Uniform4ivARB;
+    if (context->Uniform4ivARB == NULL && context->Uniform4iv != NULL) context->Uniform4ivARB = (PFNGLUNIFORM4IVARBPROC)context->Uniform4iv;
+    if (context->Uniform4ui == NULL && context->Uniform4uiEXT != NULL) context->Uniform4ui = (PFNGLUNIFORM4UIPROC)context->Uniform4uiEXT;
+    if (context->Uniform4uiEXT == NULL && context->Uniform4ui != NULL) context->Uniform4uiEXT = (PFNGLUNIFORM4UIEXTPROC)context->Uniform4ui;
+    if (context->Uniform4uiv == NULL && context->Uniform4uivEXT != NULL) context->Uniform4uiv = (PFNGLUNIFORM4UIVPROC)context->Uniform4uivEXT;
+    if (context->Uniform4uivEXT == NULL && context->Uniform4uiv != NULL) context->Uniform4uivEXT = (PFNGLUNIFORM4UIVEXTPROC)context->Uniform4uiv;
+    if (context->UniformMatrix2fv == NULL && context->UniformMatrix2fvARB != NULL) context->UniformMatrix2fv = (PFNGLUNIFORMMATRIX2FVPROC)context->UniformMatrix2fvARB;
+    if (context->UniformMatrix2fvARB == NULL && context->UniformMatrix2fv != NULL) context->UniformMatrix2fvARB = (PFNGLUNIFORMMATRIX2FVARBPROC)context->UniformMatrix2fv;
+    if (context->UniformMatrix3fv == NULL && context->UniformMatrix3fvARB != NULL) context->UniformMatrix3fv = (PFNGLUNIFORMMATRIX3FVPROC)context->UniformMatrix3fvARB;
+    if (context->UniformMatrix3fvARB == NULL && context->UniformMatrix3fv != NULL) context->UniformMatrix3fvARB = (PFNGLUNIFORMMATRIX3FVARBPROC)context->UniformMatrix3fv;
+    if (context->UniformMatrix4fv == NULL && context->UniformMatrix4fvARB != NULL) context->UniformMatrix4fv = (PFNGLUNIFORMMATRIX4FVPROC)context->UniformMatrix4fvARB;
+    if (context->UniformMatrix4fvARB == NULL && context->UniformMatrix4fv != NULL) context->UniformMatrix4fvARB = (PFNGLUNIFORMMATRIX4FVARBPROC)context->UniformMatrix4fv;
+    if (context->UnmapBuffer == NULL && context->UnmapBufferARB != NULL) context->UnmapBuffer = (PFNGLUNMAPBUFFERPROC)context->UnmapBufferARB;
+    if (context->UnmapBufferARB == NULL && context->UnmapBuffer != NULL) context->UnmapBufferARB = (PFNGLUNMAPBUFFERARBPROC)context->UnmapBuffer;
+    if (context->UseProgram == NULL && context->UseProgramObjectARB != NULL) context->UseProgram = (PFNGLUSEPROGRAMPROC)context->UseProgramObjectARB;
+    if (context->UseProgramObjectARB == NULL && context->UseProgram != NULL) context->UseProgramObjectARB = (PFNGLUSEPROGRAMOBJECTARBPROC)context->UseProgram;
+    if (context->ValidateProgram == NULL && context->ValidateProgramARB != NULL) context->ValidateProgram = (PFNGLVALIDATEPROGRAMPROC)context->ValidateProgramARB;
+    if (context->ValidateProgramARB == NULL && context->ValidateProgram != NULL) context->ValidateProgramARB = (PFNGLVALIDATEPROGRAMARBPROC)context->ValidateProgram;
+    if (context->VertexAttrib1d == NULL && context->VertexAttrib1dARB != NULL) context->VertexAttrib1d = (PFNGLVERTEXATTRIB1DPROC)context->VertexAttrib1dARB;
+    if (context->VertexAttrib1d == NULL && context->VertexAttrib1dNV != NULL) context->VertexAttrib1d = (PFNGLVERTEXATTRIB1DPROC)context->VertexAttrib1dNV;
+    if (context->VertexAttrib1dARB == NULL && context->VertexAttrib1d != NULL) context->VertexAttrib1dARB = (PFNGLVERTEXATTRIB1DARBPROC)context->VertexAttrib1d;
+    if (context->VertexAttrib1dARB == NULL && context->VertexAttrib1dNV != NULL) context->VertexAttrib1dARB = (PFNGLVERTEXATTRIB1DARBPROC)context->VertexAttrib1dNV;
+    if (context->VertexAttrib1dNV == NULL && context->VertexAttrib1d != NULL) context->VertexAttrib1dNV = (PFNGLVERTEXATTRIB1DNVPROC)context->VertexAttrib1d;
+    if (context->VertexAttrib1dNV == NULL && context->VertexAttrib1dARB != NULL) context->VertexAttrib1dNV = (PFNGLVERTEXATTRIB1DNVPROC)context->VertexAttrib1dARB;
+    if (context->VertexAttrib1dv == NULL && context->VertexAttrib1dvARB != NULL) context->VertexAttrib1dv = (PFNGLVERTEXATTRIB1DVPROC)context->VertexAttrib1dvARB;
+    if (context->VertexAttrib1dv == NULL && context->VertexAttrib1dvNV != NULL) context->VertexAttrib1dv = (PFNGLVERTEXATTRIB1DVPROC)context->VertexAttrib1dvNV;
+    if (context->VertexAttrib1dvARB == NULL && context->VertexAttrib1dv != NULL) context->VertexAttrib1dvARB = (PFNGLVERTEXATTRIB1DVARBPROC)context->VertexAttrib1dv;
+    if (context->VertexAttrib1dvARB == NULL && context->VertexAttrib1dvNV != NULL) context->VertexAttrib1dvARB = (PFNGLVERTEXATTRIB1DVARBPROC)context->VertexAttrib1dvNV;
+    if (context->VertexAttrib1dvNV == NULL && context->VertexAttrib1dv != NULL) context->VertexAttrib1dvNV = (PFNGLVERTEXATTRIB1DVNVPROC)context->VertexAttrib1dv;
+    if (context->VertexAttrib1dvNV == NULL && context->VertexAttrib1dvARB != NULL) context->VertexAttrib1dvNV = (PFNGLVERTEXATTRIB1DVNVPROC)context->VertexAttrib1dvARB;
+    if (context->VertexAttrib1f == NULL && context->VertexAttrib1fARB != NULL) context->VertexAttrib1f = (PFNGLVERTEXATTRIB1FPROC)context->VertexAttrib1fARB;
+    if (context->VertexAttrib1f == NULL && context->VertexAttrib1fNV != NULL) context->VertexAttrib1f = (PFNGLVERTEXATTRIB1FPROC)context->VertexAttrib1fNV;
+    if (context->VertexAttrib1fARB == NULL && context->VertexAttrib1f != NULL) context->VertexAttrib1fARB = (PFNGLVERTEXATTRIB1FARBPROC)context->VertexAttrib1f;
+    if (context->VertexAttrib1fARB == NULL && context->VertexAttrib1fNV != NULL) context->VertexAttrib1fARB = (PFNGLVERTEXATTRIB1FARBPROC)context->VertexAttrib1fNV;
+    if (context->VertexAttrib1fNV == NULL && context->VertexAttrib1f != NULL) context->VertexAttrib1fNV = (PFNGLVERTEXATTRIB1FNVPROC)context->VertexAttrib1f;
+    if (context->VertexAttrib1fNV == NULL && context->VertexAttrib1fARB != NULL) context->VertexAttrib1fNV = (PFNGLVERTEXATTRIB1FNVPROC)context->VertexAttrib1fARB;
+    if (context->VertexAttrib1fv == NULL && context->VertexAttrib1fvARB != NULL) context->VertexAttrib1fv = (PFNGLVERTEXATTRIB1FVPROC)context->VertexAttrib1fvARB;
+    if (context->VertexAttrib1fv == NULL && context->VertexAttrib1fvNV != NULL) context->VertexAttrib1fv = (PFNGLVERTEXATTRIB1FVPROC)context->VertexAttrib1fvNV;
+    if (context->VertexAttrib1fvARB == NULL && context->VertexAttrib1fv != NULL) context->VertexAttrib1fvARB = (PFNGLVERTEXATTRIB1FVARBPROC)context->VertexAttrib1fv;
+    if (context->VertexAttrib1fvARB == NULL && context->VertexAttrib1fvNV != NULL) context->VertexAttrib1fvARB = (PFNGLVERTEXATTRIB1FVARBPROC)context->VertexAttrib1fvNV;
+    if (context->VertexAttrib1fvNV == NULL && context->VertexAttrib1fv != NULL) context->VertexAttrib1fvNV = (PFNGLVERTEXATTRIB1FVNVPROC)context->VertexAttrib1fv;
+    if (context->VertexAttrib1fvNV == NULL && context->VertexAttrib1fvARB != NULL) context->VertexAttrib1fvNV = (PFNGLVERTEXATTRIB1FVNVPROC)context->VertexAttrib1fvARB;
+    if (context->VertexAttrib1s == NULL && context->VertexAttrib1sARB != NULL) context->VertexAttrib1s = (PFNGLVERTEXATTRIB1SPROC)context->VertexAttrib1sARB;
+    if (context->VertexAttrib1s == NULL && context->VertexAttrib1sNV != NULL) context->VertexAttrib1s = (PFNGLVERTEXATTRIB1SPROC)context->VertexAttrib1sNV;
+    if (context->VertexAttrib1sARB == NULL && context->VertexAttrib1s != NULL) context->VertexAttrib1sARB = (PFNGLVERTEXATTRIB1SARBPROC)context->VertexAttrib1s;
+    if (context->VertexAttrib1sARB == NULL && context->VertexAttrib1sNV != NULL) context->VertexAttrib1sARB = (PFNGLVERTEXATTRIB1SARBPROC)context->VertexAttrib1sNV;
+    if (context->VertexAttrib1sNV == NULL && context->VertexAttrib1s != NULL) context->VertexAttrib1sNV = (PFNGLVERTEXATTRIB1SNVPROC)context->VertexAttrib1s;
+    if (context->VertexAttrib1sNV == NULL && context->VertexAttrib1sARB != NULL) context->VertexAttrib1sNV = (PFNGLVERTEXATTRIB1SNVPROC)context->VertexAttrib1sARB;
+    if (context->VertexAttrib1sv == NULL && context->VertexAttrib1svARB != NULL) context->VertexAttrib1sv = (PFNGLVERTEXATTRIB1SVPROC)context->VertexAttrib1svARB;
+    if (context->VertexAttrib1sv == NULL && context->VertexAttrib1svNV != NULL) context->VertexAttrib1sv = (PFNGLVERTEXATTRIB1SVPROC)context->VertexAttrib1svNV;
+    if (context->VertexAttrib1svARB == NULL && context->VertexAttrib1sv != NULL) context->VertexAttrib1svARB = (PFNGLVERTEXATTRIB1SVARBPROC)context->VertexAttrib1sv;
+    if (context->VertexAttrib1svARB == NULL && context->VertexAttrib1svNV != NULL) context->VertexAttrib1svARB = (PFNGLVERTEXATTRIB1SVARBPROC)context->VertexAttrib1svNV;
+    if (context->VertexAttrib1svNV == NULL && context->VertexAttrib1sv != NULL) context->VertexAttrib1svNV = (PFNGLVERTEXATTRIB1SVNVPROC)context->VertexAttrib1sv;
+    if (context->VertexAttrib1svNV == NULL && context->VertexAttrib1svARB != NULL) context->VertexAttrib1svNV = (PFNGLVERTEXATTRIB1SVNVPROC)context->VertexAttrib1svARB;
+    if (context->VertexAttrib2d == NULL && context->VertexAttrib2dARB != NULL) context->VertexAttrib2d = (PFNGLVERTEXATTRIB2DPROC)context->VertexAttrib2dARB;
+    if (context->VertexAttrib2d == NULL && context->VertexAttrib2dNV != NULL) context->VertexAttrib2d = (PFNGLVERTEXATTRIB2DPROC)context->VertexAttrib2dNV;
+    if (context->VertexAttrib2dARB == NULL && context->VertexAttrib2d != NULL) context->VertexAttrib2dARB = (PFNGLVERTEXATTRIB2DARBPROC)context->VertexAttrib2d;
+    if (context->VertexAttrib2dARB == NULL && context->VertexAttrib2dNV != NULL) context->VertexAttrib2dARB = (PFNGLVERTEXATTRIB2DARBPROC)context->VertexAttrib2dNV;
+    if (context->VertexAttrib2dNV == NULL && context->VertexAttrib2d != NULL) context->VertexAttrib2dNV = (PFNGLVERTEXATTRIB2DNVPROC)context->VertexAttrib2d;
+    if (context->VertexAttrib2dNV == NULL && context->VertexAttrib2dARB != NULL) context->VertexAttrib2dNV = (PFNGLVERTEXATTRIB2DNVPROC)context->VertexAttrib2dARB;
+    if (context->VertexAttrib2dv == NULL && context->VertexAttrib2dvARB != NULL) context->VertexAttrib2dv = (PFNGLVERTEXATTRIB2DVPROC)context->VertexAttrib2dvARB;
+    if (context->VertexAttrib2dv == NULL && context->VertexAttrib2dvNV != NULL) context->VertexAttrib2dv = (PFNGLVERTEXATTRIB2DVPROC)context->VertexAttrib2dvNV;
+    if (context->VertexAttrib2dvARB == NULL && context->VertexAttrib2dv != NULL) context->VertexAttrib2dvARB = (PFNGLVERTEXATTRIB2DVARBPROC)context->VertexAttrib2dv;
+    if (context->VertexAttrib2dvARB == NULL && context->VertexAttrib2dvNV != NULL) context->VertexAttrib2dvARB = (PFNGLVERTEXATTRIB2DVARBPROC)context->VertexAttrib2dvNV;
+    if (context->VertexAttrib2dvNV == NULL && context->VertexAttrib2dv != NULL) context->VertexAttrib2dvNV = (PFNGLVERTEXATTRIB2DVNVPROC)context->VertexAttrib2dv;
+    if (context->VertexAttrib2dvNV == NULL && context->VertexAttrib2dvARB != NULL) context->VertexAttrib2dvNV = (PFNGLVERTEXATTRIB2DVNVPROC)context->VertexAttrib2dvARB;
+    if (context->VertexAttrib2f == NULL && context->VertexAttrib2fARB != NULL) context->VertexAttrib2f = (PFNGLVERTEXATTRIB2FPROC)context->VertexAttrib2fARB;
+    if (context->VertexAttrib2f == NULL && context->VertexAttrib2fNV != NULL) context->VertexAttrib2f = (PFNGLVERTEXATTRIB2FPROC)context->VertexAttrib2fNV;
+    if (context->VertexAttrib2fARB == NULL && context->VertexAttrib2f != NULL) context->VertexAttrib2fARB = (PFNGLVERTEXATTRIB2FARBPROC)context->VertexAttrib2f;
+    if (context->VertexAttrib2fARB == NULL && context->VertexAttrib2fNV != NULL) context->VertexAttrib2fARB = (PFNGLVERTEXATTRIB2FARBPROC)context->VertexAttrib2fNV;
+    if (context->VertexAttrib2fNV == NULL && context->VertexAttrib2f != NULL) context->VertexAttrib2fNV = (PFNGLVERTEXATTRIB2FNVPROC)context->VertexAttrib2f;
+    if (context->VertexAttrib2fNV == NULL && context->VertexAttrib2fARB != NULL) context->VertexAttrib2fNV = (PFNGLVERTEXATTRIB2FNVPROC)context->VertexAttrib2fARB;
+    if (context->VertexAttrib2fv == NULL && context->VertexAttrib2fvARB != NULL) context->VertexAttrib2fv = (PFNGLVERTEXATTRIB2FVPROC)context->VertexAttrib2fvARB;
+    if (context->VertexAttrib2fv == NULL && context->VertexAttrib2fvNV != NULL) context->VertexAttrib2fv = (PFNGLVERTEXATTRIB2FVPROC)context->VertexAttrib2fvNV;
+    if (context->VertexAttrib2fvARB == NULL && context->VertexAttrib2fv != NULL) context->VertexAttrib2fvARB = (PFNGLVERTEXATTRIB2FVARBPROC)context->VertexAttrib2fv;
+    if (context->VertexAttrib2fvARB == NULL && context->VertexAttrib2fvNV != NULL) context->VertexAttrib2fvARB = (PFNGLVERTEXATTRIB2FVARBPROC)context->VertexAttrib2fvNV;
+    if (context->VertexAttrib2fvNV == NULL && context->VertexAttrib2fv != NULL) context->VertexAttrib2fvNV = (PFNGLVERTEXATTRIB2FVNVPROC)context->VertexAttrib2fv;
+    if (context->VertexAttrib2fvNV == NULL && context->VertexAttrib2fvARB != NULL) context->VertexAttrib2fvNV = (PFNGLVERTEXATTRIB2FVNVPROC)context->VertexAttrib2fvARB;
+    if (context->VertexAttrib2s == NULL && context->VertexAttrib2sARB != NULL) context->VertexAttrib2s = (PFNGLVERTEXATTRIB2SPROC)context->VertexAttrib2sARB;
+    if (context->VertexAttrib2s == NULL && context->VertexAttrib2sNV != NULL) context->VertexAttrib2s = (PFNGLVERTEXATTRIB2SPROC)context->VertexAttrib2sNV;
+    if (context->VertexAttrib2sARB == NULL && context->VertexAttrib2s != NULL) context->VertexAttrib2sARB = (PFNGLVERTEXATTRIB2SARBPROC)context->VertexAttrib2s;
+    if (context->VertexAttrib2sARB == NULL && context->VertexAttrib2sNV != NULL) context->VertexAttrib2sARB = (PFNGLVERTEXATTRIB2SARBPROC)context->VertexAttrib2sNV;
+    if (context->VertexAttrib2sNV == NULL && context->VertexAttrib2s != NULL) context->VertexAttrib2sNV = (PFNGLVERTEXATTRIB2SNVPROC)context->VertexAttrib2s;
+    if (context->VertexAttrib2sNV == NULL && context->VertexAttrib2sARB != NULL) context->VertexAttrib2sNV = (PFNGLVERTEXATTRIB2SNVPROC)context->VertexAttrib2sARB;
+    if (context->VertexAttrib2sv == NULL && context->VertexAttrib2svARB != NULL) context->VertexAttrib2sv = (PFNGLVERTEXATTRIB2SVPROC)context->VertexAttrib2svARB;
+    if (context->VertexAttrib2sv == NULL && context->VertexAttrib2svNV != NULL) context->VertexAttrib2sv = (PFNGLVERTEXATTRIB2SVPROC)context->VertexAttrib2svNV;
+    if (context->VertexAttrib2svARB == NULL && context->VertexAttrib2sv != NULL) context->VertexAttrib2svARB = (PFNGLVERTEXATTRIB2SVARBPROC)context->VertexAttrib2sv;
+    if (context->VertexAttrib2svARB == NULL && context->VertexAttrib2svNV != NULL) context->VertexAttrib2svARB = (PFNGLVERTEXATTRIB2SVARBPROC)context->VertexAttrib2svNV;
+    if (context->VertexAttrib2svNV == NULL && context->VertexAttrib2sv != NULL) context->VertexAttrib2svNV = (PFNGLVERTEXATTRIB2SVNVPROC)context->VertexAttrib2sv;
+    if (context->VertexAttrib2svNV == NULL && context->VertexAttrib2svARB != NULL) context->VertexAttrib2svNV = (PFNGLVERTEXATTRIB2SVNVPROC)context->VertexAttrib2svARB;
+    if (context->VertexAttrib3d == NULL && context->VertexAttrib3dARB != NULL) context->VertexAttrib3d = (PFNGLVERTEXATTRIB3DPROC)context->VertexAttrib3dARB;
+    if (context->VertexAttrib3d == NULL && context->VertexAttrib3dNV != NULL) context->VertexAttrib3d = (PFNGLVERTEXATTRIB3DPROC)context->VertexAttrib3dNV;
+    if (context->VertexAttrib3dARB == NULL && context->VertexAttrib3d != NULL) context->VertexAttrib3dARB = (PFNGLVERTEXATTRIB3DARBPROC)context->VertexAttrib3d;
+    if (context->VertexAttrib3dARB == NULL && context->VertexAttrib3dNV != NULL) context->VertexAttrib3dARB = (PFNGLVERTEXATTRIB3DARBPROC)context->VertexAttrib3dNV;
+    if (context->VertexAttrib3dNV == NULL && context->VertexAttrib3d != NULL) context->VertexAttrib3dNV = (PFNGLVERTEXATTRIB3DNVPROC)context->VertexAttrib3d;
+    if (context->VertexAttrib3dNV == NULL && context->VertexAttrib3dARB != NULL) context->VertexAttrib3dNV = (PFNGLVERTEXATTRIB3DNVPROC)context->VertexAttrib3dARB;
+    if (context->VertexAttrib3dv == NULL && context->VertexAttrib3dvARB != NULL) context->VertexAttrib3dv = (PFNGLVERTEXATTRIB3DVPROC)context->VertexAttrib3dvARB;
+    if (context->VertexAttrib3dv == NULL && context->VertexAttrib3dvNV != NULL) context->VertexAttrib3dv = (PFNGLVERTEXATTRIB3DVPROC)context->VertexAttrib3dvNV;
+    if (context->VertexAttrib3dvARB == NULL && context->VertexAttrib3dv != NULL) context->VertexAttrib3dvARB = (PFNGLVERTEXATTRIB3DVARBPROC)context->VertexAttrib3dv;
+    if (context->VertexAttrib3dvARB == NULL && context->VertexAttrib3dvNV != NULL) context->VertexAttrib3dvARB = (PFNGLVERTEXATTRIB3DVARBPROC)context->VertexAttrib3dvNV;
+    if (context->VertexAttrib3dvNV == NULL && context->VertexAttrib3dv != NULL) context->VertexAttrib3dvNV = (PFNGLVERTEXATTRIB3DVNVPROC)context->VertexAttrib3dv;
+    if (context->VertexAttrib3dvNV == NULL && context->VertexAttrib3dvARB != NULL) context->VertexAttrib3dvNV = (PFNGLVERTEXATTRIB3DVNVPROC)context->VertexAttrib3dvARB;
+    if (context->VertexAttrib3f == NULL && context->VertexAttrib3fARB != NULL) context->VertexAttrib3f = (PFNGLVERTEXATTRIB3FPROC)context->VertexAttrib3fARB;
+    if (context->VertexAttrib3f == NULL && context->VertexAttrib3fNV != NULL) context->VertexAttrib3f = (PFNGLVERTEXATTRIB3FPROC)context->VertexAttrib3fNV;
+    if (context->VertexAttrib3fARB == NULL && context->VertexAttrib3f != NULL) context->VertexAttrib3fARB = (PFNGLVERTEXATTRIB3FARBPROC)context->VertexAttrib3f;
+    if (context->VertexAttrib3fARB == NULL && context->VertexAttrib3fNV != NULL) context->VertexAttrib3fARB = (PFNGLVERTEXATTRIB3FARBPROC)context->VertexAttrib3fNV;
+    if (context->VertexAttrib3fNV == NULL && context->VertexAttrib3f != NULL) context->VertexAttrib3fNV = (PFNGLVERTEXATTRIB3FNVPROC)context->VertexAttrib3f;
+    if (context->VertexAttrib3fNV == NULL && context->VertexAttrib3fARB != NULL) context->VertexAttrib3fNV = (PFNGLVERTEXATTRIB3FNVPROC)context->VertexAttrib3fARB;
+    if (context->VertexAttrib3fv == NULL && context->VertexAttrib3fvARB != NULL) context->VertexAttrib3fv = (PFNGLVERTEXATTRIB3FVPROC)context->VertexAttrib3fvARB;
+    if (context->VertexAttrib3fv == NULL && context->VertexAttrib3fvNV != NULL) context->VertexAttrib3fv = (PFNGLVERTEXATTRIB3FVPROC)context->VertexAttrib3fvNV;
+    if (context->VertexAttrib3fvARB == NULL && context->VertexAttrib3fv != NULL) context->VertexAttrib3fvARB = (PFNGLVERTEXATTRIB3FVARBPROC)context->VertexAttrib3fv;
+    if (context->VertexAttrib3fvARB == NULL && context->VertexAttrib3fvNV != NULL) context->VertexAttrib3fvARB = (PFNGLVERTEXATTRIB3FVARBPROC)context->VertexAttrib3fvNV;
+    if (context->VertexAttrib3fvNV == NULL && context->VertexAttrib3fv != NULL) context->VertexAttrib3fvNV = (PFNGLVERTEXATTRIB3FVNVPROC)context->VertexAttrib3fv;
+    if (context->VertexAttrib3fvNV == NULL && context->VertexAttrib3fvARB != NULL) context->VertexAttrib3fvNV = (PFNGLVERTEXATTRIB3FVNVPROC)context->VertexAttrib3fvARB;
+    if (context->VertexAttrib3s == NULL && context->VertexAttrib3sARB != NULL) context->VertexAttrib3s = (PFNGLVERTEXATTRIB3SPROC)context->VertexAttrib3sARB;
+    if (context->VertexAttrib3s == NULL && context->VertexAttrib3sNV != NULL) context->VertexAttrib3s = (PFNGLVERTEXATTRIB3SPROC)context->VertexAttrib3sNV;
+    if (context->VertexAttrib3sARB == NULL && context->VertexAttrib3s != NULL) context->VertexAttrib3sARB = (PFNGLVERTEXATTRIB3SARBPROC)context->VertexAttrib3s;
+    if (context->VertexAttrib3sARB == NULL && context->VertexAttrib3sNV != NULL) context->VertexAttrib3sARB = (PFNGLVERTEXATTRIB3SARBPROC)context->VertexAttrib3sNV;
+    if (context->VertexAttrib3sNV == NULL && context->VertexAttrib3s != NULL) context->VertexAttrib3sNV = (PFNGLVERTEXATTRIB3SNVPROC)context->VertexAttrib3s;
+    if (context->VertexAttrib3sNV == NULL && context->VertexAttrib3sARB != NULL) context->VertexAttrib3sNV = (PFNGLVERTEXATTRIB3SNVPROC)context->VertexAttrib3sARB;
+    if (context->VertexAttrib3sv == NULL && context->VertexAttrib3svARB != NULL) context->VertexAttrib3sv = (PFNGLVERTEXATTRIB3SVPROC)context->VertexAttrib3svARB;
+    if (context->VertexAttrib3sv == NULL && context->VertexAttrib3svNV != NULL) context->VertexAttrib3sv = (PFNGLVERTEXATTRIB3SVPROC)context->VertexAttrib3svNV;
+    if (context->VertexAttrib3svARB == NULL && context->VertexAttrib3sv != NULL) context->VertexAttrib3svARB = (PFNGLVERTEXATTRIB3SVARBPROC)context->VertexAttrib3sv;
+    if (context->VertexAttrib3svARB == NULL && context->VertexAttrib3svNV != NULL) context->VertexAttrib3svARB = (PFNGLVERTEXATTRIB3SVARBPROC)context->VertexAttrib3svNV;
+    if (context->VertexAttrib3svNV == NULL && context->VertexAttrib3sv != NULL) context->VertexAttrib3svNV = (PFNGLVERTEXATTRIB3SVNVPROC)context->VertexAttrib3sv;
+    if (context->VertexAttrib3svNV == NULL && context->VertexAttrib3svARB != NULL) context->VertexAttrib3svNV = (PFNGLVERTEXATTRIB3SVNVPROC)context->VertexAttrib3svARB;
+    if (context->VertexAttrib4bv == NULL && context->VertexAttrib4bvARB != NULL) context->VertexAttrib4bv = (PFNGLVERTEXATTRIB4BVPROC)context->VertexAttrib4bvARB;
+    if (context->VertexAttrib4bvARB == NULL && context->VertexAttrib4bv != NULL) context->VertexAttrib4bvARB = (PFNGLVERTEXATTRIB4BVARBPROC)context->VertexAttrib4bv;
+    if (context->VertexAttrib4d == NULL && context->VertexAttrib4dARB != NULL) context->VertexAttrib4d = (PFNGLVERTEXATTRIB4DPROC)context->VertexAttrib4dARB;
+    if (context->VertexAttrib4d == NULL && context->VertexAttrib4dNV != NULL) context->VertexAttrib4d = (PFNGLVERTEXATTRIB4DPROC)context->VertexAttrib4dNV;
+    if (context->VertexAttrib4dARB == NULL && context->VertexAttrib4d != NULL) context->VertexAttrib4dARB = (PFNGLVERTEXATTRIB4DARBPROC)context->VertexAttrib4d;
+    if (context->VertexAttrib4dARB == NULL && context->VertexAttrib4dNV != NULL) context->VertexAttrib4dARB = (PFNGLVERTEXATTRIB4DARBPROC)context->VertexAttrib4dNV;
+    if (context->VertexAttrib4dNV == NULL && context->VertexAttrib4d != NULL) context->VertexAttrib4dNV = (PFNGLVERTEXATTRIB4DNVPROC)context->VertexAttrib4d;
+    if (context->VertexAttrib4dNV == NULL && context->VertexAttrib4dARB != NULL) context->VertexAttrib4dNV = (PFNGLVERTEXATTRIB4DNVPROC)context->VertexAttrib4dARB;
+    if (context->VertexAttrib4dv == NULL && context->VertexAttrib4dvARB != NULL) context->VertexAttrib4dv = (PFNGLVERTEXATTRIB4DVPROC)context->VertexAttrib4dvARB;
+    if (context->VertexAttrib4dv == NULL && context->VertexAttrib4dvNV != NULL) context->VertexAttrib4dv = (PFNGLVERTEXATTRIB4DVPROC)context->VertexAttrib4dvNV;
+    if (context->VertexAttrib4dvARB == NULL && context->VertexAttrib4dv != NULL) context->VertexAttrib4dvARB = (PFNGLVERTEXATTRIB4DVARBPROC)context->VertexAttrib4dv;
+    if (context->VertexAttrib4dvARB == NULL && context->VertexAttrib4dvNV != NULL) context->VertexAttrib4dvARB = (PFNGLVERTEXATTRIB4DVARBPROC)context->VertexAttrib4dvNV;
+    if (context->VertexAttrib4dvNV == NULL && context->VertexAttrib4dv != NULL) context->VertexAttrib4dvNV = (PFNGLVERTEXATTRIB4DVNVPROC)context->VertexAttrib4dv;
+    if (context->VertexAttrib4dvNV == NULL && context->VertexAttrib4dvARB != NULL) context->VertexAttrib4dvNV = (PFNGLVERTEXATTRIB4DVNVPROC)context->VertexAttrib4dvARB;
+    if (context->VertexAttrib4f == NULL && context->VertexAttrib4fARB != NULL) context->VertexAttrib4f = (PFNGLVERTEXATTRIB4FPROC)context->VertexAttrib4fARB;
+    if (context->VertexAttrib4f == NULL && context->VertexAttrib4fNV != NULL) context->VertexAttrib4f = (PFNGLVERTEXATTRIB4FPROC)context->VertexAttrib4fNV;
+    if (context->VertexAttrib4fARB == NULL && context->VertexAttrib4f != NULL) context->VertexAttrib4fARB = (PFNGLVERTEXATTRIB4FARBPROC)context->VertexAttrib4f;
+    if (context->VertexAttrib4fARB == NULL && context->VertexAttrib4fNV != NULL) context->VertexAttrib4fARB = (PFNGLVERTEXATTRIB4FARBPROC)context->VertexAttrib4fNV;
+    if (context->VertexAttrib4fNV == NULL && context->VertexAttrib4f != NULL) context->VertexAttrib4fNV = (PFNGLVERTEXATTRIB4FNVPROC)context->VertexAttrib4f;
+    if (context->VertexAttrib4fNV == NULL && context->VertexAttrib4fARB != NULL) context->VertexAttrib4fNV = (PFNGLVERTEXATTRIB4FNVPROC)context->VertexAttrib4fARB;
+    if (context->VertexAttrib4fv == NULL && context->VertexAttrib4fvARB != NULL) context->VertexAttrib4fv = (PFNGLVERTEXATTRIB4FVPROC)context->VertexAttrib4fvARB;
+    if (context->VertexAttrib4fv == NULL && context->VertexAttrib4fvNV != NULL) context->VertexAttrib4fv = (PFNGLVERTEXATTRIB4FVPROC)context->VertexAttrib4fvNV;
+    if (context->VertexAttrib4fvARB == NULL && context->VertexAttrib4fv != NULL) context->VertexAttrib4fvARB = (PFNGLVERTEXATTRIB4FVARBPROC)context->VertexAttrib4fv;
+    if (context->VertexAttrib4fvARB == NULL && context->VertexAttrib4fvNV != NULL) context->VertexAttrib4fvARB = (PFNGLVERTEXATTRIB4FVARBPROC)context->VertexAttrib4fvNV;
+    if (context->VertexAttrib4fvNV == NULL && context->VertexAttrib4fv != NULL) context->VertexAttrib4fvNV = (PFNGLVERTEXATTRIB4FVNVPROC)context->VertexAttrib4fv;
+    if (context->VertexAttrib4fvNV == NULL && context->VertexAttrib4fvARB != NULL) context->VertexAttrib4fvNV = (PFNGLVERTEXATTRIB4FVNVPROC)context->VertexAttrib4fvARB;
+    if (context->VertexAttrib4iv == NULL && context->VertexAttrib4ivARB != NULL) context->VertexAttrib4iv = (PFNGLVERTEXATTRIB4IVPROC)context->VertexAttrib4ivARB;
+    if (context->VertexAttrib4ivARB == NULL && context->VertexAttrib4iv != NULL) context->VertexAttrib4ivARB = (PFNGLVERTEXATTRIB4IVARBPROC)context->VertexAttrib4iv;
+    if (context->VertexAttrib4Nbv == NULL && context->VertexAttrib4NbvARB != NULL) context->VertexAttrib4Nbv = (PFNGLVERTEXATTRIB4NBVPROC)context->VertexAttrib4NbvARB;
+    if (context->VertexAttrib4NbvARB == NULL && context->VertexAttrib4Nbv != NULL) context->VertexAttrib4NbvARB = (PFNGLVERTEXATTRIB4NBVARBPROC)context->VertexAttrib4Nbv;
+    if (context->VertexAttrib4Niv == NULL && context->VertexAttrib4NivARB != NULL) context->VertexAttrib4Niv = (PFNGLVERTEXATTRIB4NIVPROC)context->VertexAttrib4NivARB;
+    if (context->VertexAttrib4NivARB == NULL && context->VertexAttrib4Niv != NULL) context->VertexAttrib4NivARB = (PFNGLVERTEXATTRIB4NIVARBPROC)context->VertexAttrib4Niv;
+    if (context->VertexAttrib4Nsv == NULL && context->VertexAttrib4NsvARB != NULL) context->VertexAttrib4Nsv = (PFNGLVERTEXATTRIB4NSVPROC)context->VertexAttrib4NsvARB;
+    if (context->VertexAttrib4NsvARB == NULL && context->VertexAttrib4Nsv != NULL) context->VertexAttrib4NsvARB = (PFNGLVERTEXATTRIB4NSVARBPROC)context->VertexAttrib4Nsv;
+    if (context->VertexAttrib4Nub == NULL && context->VertexAttrib4NubARB != NULL) context->VertexAttrib4Nub = (PFNGLVERTEXATTRIB4NUBPROC)context->VertexAttrib4NubARB;
+    if (context->VertexAttrib4Nub == NULL && context->VertexAttrib4ubNV != NULL) context->VertexAttrib4Nub = (PFNGLVERTEXATTRIB4NUBPROC)context->VertexAttrib4ubNV;
+    if (context->VertexAttrib4NubARB == NULL && context->VertexAttrib4Nub != NULL) context->VertexAttrib4NubARB = (PFNGLVERTEXATTRIB4NUBARBPROC)context->VertexAttrib4Nub;
+    if (context->VertexAttrib4NubARB == NULL && context->VertexAttrib4ubNV != NULL) context->VertexAttrib4NubARB = (PFNGLVERTEXATTRIB4NUBARBPROC)context->VertexAttrib4ubNV;
+    if (context->VertexAttrib4Nubv == NULL && context->VertexAttrib4NubvARB != NULL) context->VertexAttrib4Nubv = (PFNGLVERTEXATTRIB4NUBVPROC)context->VertexAttrib4NubvARB;
+    if (context->VertexAttrib4Nubv == NULL && context->VertexAttrib4ubvNV != NULL) context->VertexAttrib4Nubv = (PFNGLVERTEXATTRIB4NUBVPROC)context->VertexAttrib4ubvNV;
+    if (context->VertexAttrib4NubvARB == NULL && context->VertexAttrib4Nubv != NULL) context->VertexAttrib4NubvARB = (PFNGLVERTEXATTRIB4NUBVARBPROC)context->VertexAttrib4Nubv;
+    if (context->VertexAttrib4NubvARB == NULL && context->VertexAttrib4ubvNV != NULL) context->VertexAttrib4NubvARB = (PFNGLVERTEXATTRIB4NUBVARBPROC)context->VertexAttrib4ubvNV;
+    if (context->VertexAttrib4Nuiv == NULL && context->VertexAttrib4NuivARB != NULL) context->VertexAttrib4Nuiv = (PFNGLVERTEXATTRIB4NUIVPROC)context->VertexAttrib4NuivARB;
+    if (context->VertexAttrib4NuivARB == NULL && context->VertexAttrib4Nuiv != NULL) context->VertexAttrib4NuivARB = (PFNGLVERTEXATTRIB4NUIVARBPROC)context->VertexAttrib4Nuiv;
+    if (context->VertexAttrib4Nusv == NULL && context->VertexAttrib4NusvARB != NULL) context->VertexAttrib4Nusv = (PFNGLVERTEXATTRIB4NUSVPROC)context->VertexAttrib4NusvARB;
+    if (context->VertexAttrib4NusvARB == NULL && context->VertexAttrib4Nusv != NULL) context->VertexAttrib4NusvARB = (PFNGLVERTEXATTRIB4NUSVARBPROC)context->VertexAttrib4Nusv;
+    if (context->VertexAttrib4s == NULL && context->VertexAttrib4sARB != NULL) context->VertexAttrib4s = (PFNGLVERTEXATTRIB4SPROC)context->VertexAttrib4sARB;
+    if (context->VertexAttrib4s == NULL && context->VertexAttrib4sNV != NULL) context->VertexAttrib4s = (PFNGLVERTEXATTRIB4SPROC)context->VertexAttrib4sNV;
+    if (context->VertexAttrib4sARB == NULL && context->VertexAttrib4s != NULL) context->VertexAttrib4sARB = (PFNGLVERTEXATTRIB4SARBPROC)context->VertexAttrib4s;
+    if (context->VertexAttrib4sARB == NULL && context->VertexAttrib4sNV != NULL) context->VertexAttrib4sARB = (PFNGLVERTEXATTRIB4SARBPROC)context->VertexAttrib4sNV;
+    if (context->VertexAttrib4sNV == NULL && context->VertexAttrib4s != NULL) context->VertexAttrib4sNV = (PFNGLVERTEXATTRIB4SNVPROC)context->VertexAttrib4s;
+    if (context->VertexAttrib4sNV == NULL && context->VertexAttrib4sARB != NULL) context->VertexAttrib4sNV = (PFNGLVERTEXATTRIB4SNVPROC)context->VertexAttrib4sARB;
+    if (context->VertexAttrib4sv == NULL && context->VertexAttrib4svARB != NULL) context->VertexAttrib4sv = (PFNGLVERTEXATTRIB4SVPROC)context->VertexAttrib4svARB;
+    if (context->VertexAttrib4sv == NULL && context->VertexAttrib4svNV != NULL) context->VertexAttrib4sv = (PFNGLVERTEXATTRIB4SVPROC)context->VertexAttrib4svNV;
+    if (context->VertexAttrib4svARB == NULL && context->VertexAttrib4sv != NULL) context->VertexAttrib4svARB = (PFNGLVERTEXATTRIB4SVARBPROC)context->VertexAttrib4sv;
+    if (context->VertexAttrib4svARB == NULL && context->VertexAttrib4svNV != NULL) context->VertexAttrib4svARB = (PFNGLVERTEXATTRIB4SVARBPROC)context->VertexAttrib4svNV;
+    if (context->VertexAttrib4svNV == NULL && context->VertexAttrib4sv != NULL) context->VertexAttrib4svNV = (PFNGLVERTEXATTRIB4SVNVPROC)context->VertexAttrib4sv;
+    if (context->VertexAttrib4svNV == NULL && context->VertexAttrib4svARB != NULL) context->VertexAttrib4svNV = (PFNGLVERTEXATTRIB4SVNVPROC)context->VertexAttrib4svARB;
+    if (context->VertexAttrib4ubNV == NULL && context->VertexAttrib4Nub != NULL) context->VertexAttrib4ubNV = (PFNGLVERTEXATTRIB4UBNVPROC)context->VertexAttrib4Nub;
+    if (context->VertexAttrib4ubNV == NULL && context->VertexAttrib4NubARB != NULL) context->VertexAttrib4ubNV = (PFNGLVERTEXATTRIB4UBNVPROC)context->VertexAttrib4NubARB;
+    if (context->VertexAttrib4ubv == NULL && context->VertexAttrib4ubvARB != NULL) context->VertexAttrib4ubv = (PFNGLVERTEXATTRIB4UBVPROC)context->VertexAttrib4ubvARB;
+    if (context->VertexAttrib4ubvARB == NULL && context->VertexAttrib4ubv != NULL) context->VertexAttrib4ubvARB = (PFNGLVERTEXATTRIB4UBVARBPROC)context->VertexAttrib4ubv;
+    if (context->VertexAttrib4ubvNV == NULL && context->VertexAttrib4Nubv != NULL) context->VertexAttrib4ubvNV = (PFNGLVERTEXATTRIB4UBVNVPROC)context->VertexAttrib4Nubv;
+    if (context->VertexAttrib4ubvNV == NULL && context->VertexAttrib4NubvARB != NULL) context->VertexAttrib4ubvNV = (PFNGLVERTEXATTRIB4UBVNVPROC)context->VertexAttrib4NubvARB;
+    if (context->VertexAttrib4uiv == NULL && context->VertexAttrib4uivARB != NULL) context->VertexAttrib4uiv = (PFNGLVERTEXATTRIB4UIVPROC)context->VertexAttrib4uivARB;
+    if (context->VertexAttrib4uivARB == NULL && context->VertexAttrib4uiv != NULL) context->VertexAttrib4uivARB = (PFNGLVERTEXATTRIB4UIVARBPROC)context->VertexAttrib4uiv;
+    if (context->VertexAttrib4usv == NULL && context->VertexAttrib4usvARB != NULL) context->VertexAttrib4usv = (PFNGLVERTEXATTRIB4USVPROC)context->VertexAttrib4usvARB;
+    if (context->VertexAttrib4usvARB == NULL && context->VertexAttrib4usv != NULL) context->VertexAttrib4usvARB = (PFNGLVERTEXATTRIB4USVARBPROC)context->VertexAttrib4usv;
+    if (context->VertexAttribI1i == NULL && context->VertexAttribI1iEXT != NULL) context->VertexAttribI1i = (PFNGLVERTEXATTRIBI1IPROC)context->VertexAttribI1iEXT;
+    if (context->VertexAttribI1iEXT == NULL && context->VertexAttribI1i != NULL) context->VertexAttribI1iEXT = (PFNGLVERTEXATTRIBI1IEXTPROC)context->VertexAttribI1i;
+    if (context->VertexAttribI1iv == NULL && context->VertexAttribI1ivEXT != NULL) context->VertexAttribI1iv = (PFNGLVERTEXATTRIBI1IVPROC)context->VertexAttribI1ivEXT;
+    if (context->VertexAttribI1ivEXT == NULL && context->VertexAttribI1iv != NULL) context->VertexAttribI1ivEXT = (PFNGLVERTEXATTRIBI1IVEXTPROC)context->VertexAttribI1iv;
+    if (context->VertexAttribI1ui == NULL && context->VertexAttribI1uiEXT != NULL) context->VertexAttribI1ui = (PFNGLVERTEXATTRIBI1UIPROC)context->VertexAttribI1uiEXT;
+    if (context->VertexAttribI1uiEXT == NULL && context->VertexAttribI1ui != NULL) context->VertexAttribI1uiEXT = (PFNGLVERTEXATTRIBI1UIEXTPROC)context->VertexAttribI1ui;
+    if (context->VertexAttribI1uiv == NULL && context->VertexAttribI1uivEXT != NULL) context->VertexAttribI1uiv = (PFNGLVERTEXATTRIBI1UIVPROC)context->VertexAttribI1uivEXT;
+    if (context->VertexAttribI1uivEXT == NULL && context->VertexAttribI1uiv != NULL) context->VertexAttribI1uivEXT = (PFNGLVERTEXATTRIBI1UIVEXTPROC)context->VertexAttribI1uiv;
+    if (context->VertexAttribI2i == NULL && context->VertexAttribI2iEXT != NULL) context->VertexAttribI2i = (PFNGLVERTEXATTRIBI2IPROC)context->VertexAttribI2iEXT;
+    if (context->VertexAttribI2iEXT == NULL && context->VertexAttribI2i != NULL) context->VertexAttribI2iEXT = (PFNGLVERTEXATTRIBI2IEXTPROC)context->VertexAttribI2i;
+    if (context->VertexAttribI2iv == NULL && context->VertexAttribI2ivEXT != NULL) context->VertexAttribI2iv = (PFNGLVERTEXATTRIBI2IVPROC)context->VertexAttribI2ivEXT;
+    if (context->VertexAttribI2ivEXT == NULL && context->VertexAttribI2iv != NULL) context->VertexAttribI2ivEXT = (PFNGLVERTEXATTRIBI2IVEXTPROC)context->VertexAttribI2iv;
+    if (context->VertexAttribI2ui == NULL && context->VertexAttribI2uiEXT != NULL) context->VertexAttribI2ui = (PFNGLVERTEXATTRIBI2UIPROC)context->VertexAttribI2uiEXT;
+    if (context->VertexAttribI2uiEXT == NULL && context->VertexAttribI2ui != NULL) context->VertexAttribI2uiEXT = (PFNGLVERTEXATTRIBI2UIEXTPROC)context->VertexAttribI2ui;
+    if (context->VertexAttribI2uiv == NULL && context->VertexAttribI2uivEXT != NULL) context->VertexAttribI2uiv = (PFNGLVERTEXATTRIBI2UIVPROC)context->VertexAttribI2uivEXT;
+    if (context->VertexAttribI2uivEXT == NULL && context->VertexAttribI2uiv != NULL) context->VertexAttribI2uivEXT = (PFNGLVERTEXATTRIBI2UIVEXTPROC)context->VertexAttribI2uiv;
+    if (context->VertexAttribI3i == NULL && context->VertexAttribI3iEXT != NULL) context->VertexAttribI3i = (PFNGLVERTEXATTRIBI3IPROC)context->VertexAttribI3iEXT;
+    if (context->VertexAttribI3iEXT == NULL && context->VertexAttribI3i != NULL) context->VertexAttribI3iEXT = (PFNGLVERTEXATTRIBI3IEXTPROC)context->VertexAttribI3i;
+    if (context->VertexAttribI3iv == NULL && context->VertexAttribI3ivEXT != NULL) context->VertexAttribI3iv = (PFNGLVERTEXATTRIBI3IVPROC)context->VertexAttribI3ivEXT;
+    if (context->VertexAttribI3ivEXT == NULL && context->VertexAttribI3iv != NULL) context->VertexAttribI3ivEXT = (PFNGLVERTEXATTRIBI3IVEXTPROC)context->VertexAttribI3iv;
+    if (context->VertexAttribI3ui == NULL && context->VertexAttribI3uiEXT != NULL) context->VertexAttribI3ui = (PFNGLVERTEXATTRIBI3UIPROC)context->VertexAttribI3uiEXT;
+    if (context->VertexAttribI3uiEXT == NULL && context->VertexAttribI3ui != NULL) context->VertexAttribI3uiEXT = (PFNGLVERTEXATTRIBI3UIEXTPROC)context->VertexAttribI3ui;
+    if (context->VertexAttribI3uiv == NULL && context->VertexAttribI3uivEXT != NULL) context->VertexAttribI3uiv = (PFNGLVERTEXATTRIBI3UIVPROC)context->VertexAttribI3uivEXT;
+    if (context->VertexAttribI3uivEXT == NULL && context->VertexAttribI3uiv != NULL) context->VertexAttribI3uivEXT = (PFNGLVERTEXATTRIBI3UIVEXTPROC)context->VertexAttribI3uiv;
+    if (context->VertexAttribI4bv == NULL && context->VertexAttribI4bvEXT != NULL) context->VertexAttribI4bv = (PFNGLVERTEXATTRIBI4BVPROC)context->VertexAttribI4bvEXT;
+    if (context->VertexAttribI4bvEXT == NULL && context->VertexAttribI4bv != NULL) context->VertexAttribI4bvEXT = (PFNGLVERTEXATTRIBI4BVEXTPROC)context->VertexAttribI4bv;
+    if (context->VertexAttribI4i == NULL && context->VertexAttribI4iEXT != NULL) context->VertexAttribI4i = (PFNGLVERTEXATTRIBI4IPROC)context->VertexAttribI4iEXT;
+    if (context->VertexAttribI4iEXT == NULL && context->VertexAttribI4i != NULL) context->VertexAttribI4iEXT = (PFNGLVERTEXATTRIBI4IEXTPROC)context->VertexAttribI4i;
+    if (context->VertexAttribI4iv == NULL && context->VertexAttribI4ivEXT != NULL) context->VertexAttribI4iv = (PFNGLVERTEXATTRIBI4IVPROC)context->VertexAttribI4ivEXT;
+    if (context->VertexAttribI4ivEXT == NULL && context->VertexAttribI4iv != NULL) context->VertexAttribI4ivEXT = (PFNGLVERTEXATTRIBI4IVEXTPROC)context->VertexAttribI4iv;
+    if (context->VertexAttribI4sv == NULL && context->VertexAttribI4svEXT != NULL) context->VertexAttribI4sv = (PFNGLVERTEXATTRIBI4SVPROC)context->VertexAttribI4svEXT;
+    if (context->VertexAttribI4svEXT == NULL && context->VertexAttribI4sv != NULL) context->VertexAttribI4svEXT = (PFNGLVERTEXATTRIBI4SVEXTPROC)context->VertexAttribI4sv;
+    if (context->VertexAttribI4ubv == NULL && context->VertexAttribI4ubvEXT != NULL) context->VertexAttribI4ubv = (PFNGLVERTEXATTRIBI4UBVPROC)context->VertexAttribI4ubvEXT;
+    if (context->VertexAttribI4ubvEXT == NULL && context->VertexAttribI4ubv != NULL) context->VertexAttribI4ubvEXT = (PFNGLVERTEXATTRIBI4UBVEXTPROC)context->VertexAttribI4ubv;
+    if (context->VertexAttribI4ui == NULL && context->VertexAttribI4uiEXT != NULL) context->VertexAttribI4ui = (PFNGLVERTEXATTRIBI4UIPROC)context->VertexAttribI4uiEXT;
+    if (context->VertexAttribI4uiEXT == NULL && context->VertexAttribI4ui != NULL) context->VertexAttribI4uiEXT = (PFNGLVERTEXATTRIBI4UIEXTPROC)context->VertexAttribI4ui;
+    if (context->VertexAttribI4uiv == NULL && context->VertexAttribI4uivEXT != NULL) context->VertexAttribI4uiv = (PFNGLVERTEXATTRIBI4UIVPROC)context->VertexAttribI4uivEXT;
+    if (context->VertexAttribI4uivEXT == NULL && context->VertexAttribI4uiv != NULL) context->VertexAttribI4uivEXT = (PFNGLVERTEXATTRIBI4UIVEXTPROC)context->VertexAttribI4uiv;
+    if (context->VertexAttribI4usv == NULL && context->VertexAttribI4usvEXT != NULL) context->VertexAttribI4usv = (PFNGLVERTEXATTRIBI4USVPROC)context->VertexAttribI4usvEXT;
+    if (context->VertexAttribI4usvEXT == NULL && context->VertexAttribI4usv != NULL) context->VertexAttribI4usvEXT = (PFNGLVERTEXATTRIBI4USVEXTPROC)context->VertexAttribI4usv;
+    if (context->VertexAttribIPointer == NULL && context->VertexAttribIPointerEXT != NULL) context->VertexAttribIPointer = (PFNGLVERTEXATTRIBIPOINTERPROC)context->VertexAttribIPointerEXT;
+    if (context->VertexAttribIPointerEXT == NULL && context->VertexAttribIPointer != NULL) context->VertexAttribIPointerEXT = (PFNGLVERTEXATTRIBIPOINTEREXTPROC)context->VertexAttribIPointer;
+    if (context->VertexAttribPointer == NULL && context->VertexAttribPointerARB != NULL) context->VertexAttribPointer = (PFNGLVERTEXATTRIBPOINTERPROC)context->VertexAttribPointerARB;
+    if (context->VertexAttribPointerARB == NULL && context->VertexAttribPointer != NULL) context->VertexAttribPointerARB = (PFNGLVERTEXATTRIBPOINTERARBPROC)context->VertexAttribPointer;
+}
+
+#if defined(GL_ES_VERSION_3_0) || defined(GL_VERSION_3_0)
+#define GLAD_GL_IS_SOME_NEW_VERSION 1
+#else
+#define GLAD_GL_IS_SOME_NEW_VERSION 0
+#endif
+
+static int glad_gl_get_extensions(GladGLContext *context, int version, const char **out_exts, unsigned int *out_num_exts_i, char ***out_exts_i) {
+#if GLAD_GL_IS_SOME_NEW_VERSION
+    if(GLAD_VERSION_MAJOR(version) < 3) {
+#else
+    GLAD_UNUSED(version);
+    GLAD_UNUSED(out_num_exts_i);
+    GLAD_UNUSED(out_exts_i);
+#endif
+        if (context->GetString == NULL) {
+            return 0;
+        }
+        *out_exts = (const char *)context->GetString(GL_EXTENSIONS);
+#if GLAD_GL_IS_SOME_NEW_VERSION
+    } else {
+        unsigned int index = 0;
+        unsigned int num_exts_i = 0;
+        char **exts_i = NULL;
+        if (context->GetStringi == NULL || context->GetIntegerv == NULL) {
+            return 0;
+        }
+        context->GetIntegerv(GL_NUM_EXTENSIONS, (int*) &num_exts_i);
+        if (num_exts_i > 0) {
+            exts_i = (char **) malloc(num_exts_i * (sizeof *exts_i));
+        }
+        if (exts_i == NULL) {
+            return 0;
+        }
+        for(index = 0; index < num_exts_i; index++) {
+            const char *gl_str_tmp = (const char*) context->GetStringi(GL_EXTENSIONS, index);
+            size_t len = strlen(gl_str_tmp) + 1;
+
+            char *local_str = (char*) malloc(len * sizeof(char));
+            if(local_str != NULL) {
+                memcpy(local_str, gl_str_tmp, len * sizeof(char));
+            }
+
+            exts_i[index] = local_str;
+        }
+
+        *out_num_exts_i = num_exts_i;
+        *out_exts_i = exts_i;
+    }
+#endif
+    return 1;
+}
+static void glad_gl_free_extensions(char **exts_i, unsigned int num_exts_i) {
+    if (exts_i != NULL) {
+        unsigned int index;
+        for(index = 0; index < num_exts_i; index++) {
+            free((void *) (exts_i[index]));
+        }
+        free((void *)exts_i);
+        exts_i = NULL;
+    }
+}
+static int glad_gl_has_extension(int version, const char *exts, unsigned int num_exts_i, char **exts_i, const char *ext) {
+    if(GLAD_VERSION_MAJOR(version) < 3 || !GLAD_GL_IS_SOME_NEW_VERSION) {
+        const char *extensions;
+        const char *loc;
+        const char *terminator;
+        extensions = exts;
+        if(extensions == NULL || ext == NULL) {
+            return 0;
+        }
+        while(1) {
+            loc = strstr(extensions, ext);
+            if(loc == NULL) {
+                return 0;
+            }
+            terminator = loc + strlen(ext);
+            if((loc == extensions || *(loc - 1) == ' ') &&
+                (*terminator == ' ' || *terminator == '\0')) {
+                return 1;
+            }
+            extensions = terminator;
+        }
+    } else {
+        unsigned int index;
+        for(index = 0; index < num_exts_i; index++) {
+            const char *e = exts_i[index];
+            if(strcmp(e, ext) == 0) {
+                return 1;
+            }
+        }
+    }
+    return 0;
+}
+
+static GLADapiproc glad_gl_get_proc_from_userptr(void *userptr, const char* name) {
+    return (GLAD_GNUC_EXTENSION (GLADapiproc (*)(const char *name)) userptr)(name);
+}
+
+static int glad_gl_find_extensions_gl(GladGLContext *context, int version) {
+    const char *exts = NULL;
+    unsigned int num_exts_i = 0;
+    char **exts_i = NULL;
+    if (!glad_gl_get_extensions(context, version, &exts, &num_exts_i, &exts_i)) return 0;
+
+    context->APPLE_flush_buffer_range = glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_APPLE_flush_buffer_range");
+    context->APPLE_vertex_array_object = glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_APPLE_vertex_array_object");
+    context->ARB_color_buffer_float = glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_ARB_color_buffer_float");
+    context->ARB_copy_buffer = glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_ARB_copy_buffer");
+    context->ARB_draw_buffers = glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_ARB_draw_buffers");
+    context->ARB_draw_elements_base_vertex = glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_ARB_draw_elements_base_vertex");
+    context->ARB_draw_instanced = glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_ARB_draw_instanced");
+    context->ARB_framebuffer_object = glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_ARB_framebuffer_object");
+    context->ARB_geometry_shader4 = glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_ARB_geometry_shader4");
+    context->ARB_imaging = glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_ARB_imaging");
+    context->ARB_map_buffer_range = glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_ARB_map_buffer_range");
+    context->ARB_multisample = glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_ARB_multisample");
+    context->ARB_multitexture = glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_ARB_multitexture");
+    context->ARB_occlusion_query = glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_ARB_occlusion_query");
+    context->ARB_point_parameters = glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_ARB_point_parameters");
+    context->ARB_provoking_vertex = glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_ARB_provoking_vertex");
+    context->ARB_shader_objects = glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_ARB_shader_objects");
+    context->ARB_sync = glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_ARB_sync");
+    context->ARB_texture_buffer_object = glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_ARB_texture_buffer_object");
+    context->ARB_texture_compression = glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_ARB_texture_compression");
+    context->ARB_texture_multisample = glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_ARB_texture_multisample");
+    context->ARB_uniform_buffer_object = glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_ARB_uniform_buffer_object");
+    context->ARB_vertex_array_object = glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_ARB_vertex_array_object");
+    context->ARB_vertex_buffer_object = glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_ARB_vertex_buffer_object");
+    context->ARB_vertex_program = glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_ARB_vertex_program");
+    context->ARB_vertex_shader = glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_ARB_vertex_shader");
+    context->ATI_draw_buffers = glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_ATI_draw_buffers");
+    context->ATI_separate_stencil = glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_ATI_separate_stencil");
+    context->EXT_blend_color = glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_EXT_blend_color");
+    context->EXT_blend_equation_separate = glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_EXT_blend_equation_separate");
+    context->EXT_blend_func_separate = glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_EXT_blend_func_separate");
+    context->EXT_blend_minmax = glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_EXT_blend_minmax");
+    context->EXT_copy_texture = glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_EXT_copy_texture");
+    context->EXT_direct_state_access = glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_EXT_direct_state_access");
+    context->EXT_draw_buffers2 = glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_EXT_draw_buffers2");
+    context->EXT_draw_instanced = glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_EXT_draw_instanced");
+    context->EXT_draw_range_elements = glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_EXT_draw_range_elements");
+    context->EXT_framebuffer_blit = glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_EXT_framebuffer_blit");
+    context->EXT_framebuffer_multisample = glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_EXT_framebuffer_multisample");
+    context->EXT_framebuffer_object = glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_EXT_framebuffer_object");
+    context->EXT_gpu_shader4 = glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_EXT_gpu_shader4");
+    context->EXT_multi_draw_arrays = glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_EXT_multi_draw_arrays");
+    context->EXT_point_parameters = glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_EXT_point_parameters");
+    context->EXT_provoking_vertex = glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_EXT_provoking_vertex");
+    context->EXT_subtexture = glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_EXT_subtexture");
+    context->EXT_texture3D = glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_EXT_texture3D");
+    context->EXT_texture_array = glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_EXT_texture_array");
+    context->EXT_texture_buffer_object = glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_EXT_texture_buffer_object");
+    context->EXT_texture_integer = glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_EXT_texture_integer");
+    context->EXT_texture_object = glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_EXT_texture_object");
+    context->EXT_transform_feedback = glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_EXT_transform_feedback");
+    context->EXT_vertex_array = glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_EXT_vertex_array");
+    context->INGR_blend_func_separate = glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_INGR_blend_func_separate");
+    context->NVX_conditional_render = glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_NVX_conditional_render");
+    context->NV_conditional_render = glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_NV_conditional_render");
+    context->NV_explicit_multisample = glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_NV_explicit_multisample");
+    context->NV_geometry_program4 = glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_NV_geometry_program4");
+    context->NV_point_sprite = glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_NV_point_sprite");
+    context->NV_transform_feedback = glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_NV_transform_feedback");
+    context->NV_vertex_program = glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_NV_vertex_program");
+    context->NV_vertex_program4 = glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_NV_vertex_program4");
+    context->SGIS_point_parameters = glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_SGIS_point_parameters");
+
+    glad_gl_free_extensions(exts_i, num_exts_i);
+
+    return 1;
+}
+
+static int glad_gl_find_core_gl(GladGLContext *context) {
+    int i;
+    const char* version;
+    const char* prefixes[] = {
+        "OpenGL ES-CM ",
+        "OpenGL ES-CL ",
+        "OpenGL ES ",
+        "OpenGL SC ",
+        NULL
+    };
+    int major = 0;
+    int minor = 0;
+    version = (const char*) context->GetString(GL_VERSION);
+    if (!version) return 0;
+    for (i = 0;  prefixes[i];  i++) {
+        const size_t length = strlen(prefixes[i]);
+        if (strncmp(version, prefixes[i], length) == 0) {
+            version += length;
+            break;
+        }
+    }
+
+    GLAD_IMPL_UTIL_SSCANF(version, "%d.%d", &major, &minor);
+
+    context->VERSION_1_0 = (major == 1 && minor >= 0) || major > 1;
+    context->VERSION_1_1 = (major == 1 && minor >= 1) || major > 1;
+    context->VERSION_1_2 = (major == 1 && minor >= 2) || major > 1;
+    context->VERSION_1_3 = (major == 1 && minor >= 3) || major > 1;
+    context->VERSION_1_4 = (major == 1 && minor >= 4) || major > 1;
+    context->VERSION_1_5 = (major == 1 && minor >= 5) || major > 1;
+    context->VERSION_2_0 = (major == 2 && minor >= 0) || major > 2;
+    context->VERSION_2_1 = (major == 2 && minor >= 1) || major > 2;
+    context->VERSION_3_0 = (major == 3 && minor >= 0) || major > 3;
+    context->VERSION_3_1 = (major == 3 && minor >= 1) || major > 3;
+    context->VERSION_3_2 = (major == 3 && minor >= 2) || major > 3;
+
+    return GLAD_MAKE_VERSION(major, minor);
+}
+
+int gladLoadGLContextUserPtr(GladGLContext *context, GLADuserptrloadfunc load, void *userptr) {
+    int version;
+
+    context->GetString = (PFNGLGETSTRINGPROC) load(userptr, "glGetString");
+    if(context->GetString == NULL) return 0;
+    if(context->GetString(GL_VERSION) == NULL) return 0;
+    version = glad_gl_find_core_gl(context);
+
+    glad_gl_load_GL_VERSION_1_0(context, load, userptr);
+    glad_gl_load_GL_VERSION_1_1(context, load, userptr);
+    glad_gl_load_GL_VERSION_1_2(context, load, userptr);
+    glad_gl_load_GL_VERSION_1_3(context, load, userptr);
+    glad_gl_load_GL_VERSION_1_4(context, load, userptr);
+    glad_gl_load_GL_VERSION_1_5(context, load, userptr);
+    glad_gl_load_GL_VERSION_2_0(context, load, userptr);
+    glad_gl_load_GL_VERSION_2_1(context, load, userptr);
+    glad_gl_load_GL_VERSION_3_0(context, load, userptr);
+    glad_gl_load_GL_VERSION_3_1(context, load, userptr);
+    glad_gl_load_GL_VERSION_3_2(context, load, userptr);
+
+    if (!glad_gl_find_extensions_gl(context, version)) return 0;
+    glad_gl_load_GL_APPLE_flush_buffer_range(context, load, userptr);
+    glad_gl_load_GL_APPLE_vertex_array_object(context, load, userptr);
+    glad_gl_load_GL_ARB_color_buffer_float(context, load, userptr);
+    glad_gl_load_GL_ARB_copy_buffer(context, load, userptr);
+    glad_gl_load_GL_ARB_draw_buffers(context, load, userptr);
+    glad_gl_load_GL_ARB_draw_elements_base_vertex(context, load, userptr);
+    glad_gl_load_GL_ARB_draw_instanced(context, load, userptr);
+    glad_gl_load_GL_ARB_framebuffer_object(context, load, userptr);
+    glad_gl_load_GL_ARB_geometry_shader4(context, load, userptr);
+    glad_gl_load_GL_ARB_imaging(context, load, userptr);
+    glad_gl_load_GL_ARB_map_buffer_range(context, load, userptr);
+    glad_gl_load_GL_ARB_multisample(context, load, userptr);
+    glad_gl_load_GL_ARB_multitexture(context, load, userptr);
+    glad_gl_load_GL_ARB_occlusion_query(context, load, userptr);
+    glad_gl_load_GL_ARB_point_parameters(context, load, userptr);
+    glad_gl_load_GL_ARB_provoking_vertex(context, load, userptr);
+    glad_gl_load_GL_ARB_shader_objects(context, load, userptr);
+    glad_gl_load_GL_ARB_sync(context, load, userptr);
+    glad_gl_load_GL_ARB_texture_buffer_object(context, load, userptr);
+    glad_gl_load_GL_ARB_texture_compression(context, load, userptr);
+    glad_gl_load_GL_ARB_texture_multisample(context, load, userptr);
+    glad_gl_load_GL_ARB_uniform_buffer_object(context, load, userptr);
+    glad_gl_load_GL_ARB_vertex_array_object(context, load, userptr);
+    glad_gl_load_GL_ARB_vertex_buffer_object(context, load, userptr);
+    glad_gl_load_GL_ARB_vertex_program(context, load, userptr);
+    glad_gl_load_GL_ARB_vertex_shader(context, load, userptr);
+    glad_gl_load_GL_ATI_draw_buffers(context, load, userptr);
+    glad_gl_load_GL_ATI_separate_stencil(context, load, userptr);
+    glad_gl_load_GL_EXT_blend_color(context, load, userptr);
+    glad_gl_load_GL_EXT_blend_equation_separate(context, load, userptr);
+    glad_gl_load_GL_EXT_blend_func_separate(context, load, userptr);
+    glad_gl_load_GL_EXT_blend_minmax(context, load, userptr);
+    glad_gl_load_GL_EXT_copy_texture(context, load, userptr);
+    glad_gl_load_GL_EXT_direct_state_access(context, load, userptr);
+    glad_gl_load_GL_EXT_draw_buffers2(context, load, userptr);
+    glad_gl_load_GL_EXT_draw_instanced(context, load, userptr);
+    glad_gl_load_GL_EXT_draw_range_elements(context, load, userptr);
+    glad_gl_load_GL_EXT_framebuffer_blit(context, load, userptr);
+    glad_gl_load_GL_EXT_framebuffer_multisample(context, load, userptr);
+    glad_gl_load_GL_EXT_framebuffer_object(context, load, userptr);
+    glad_gl_load_GL_EXT_gpu_shader4(context, load, userptr);
+    glad_gl_load_GL_EXT_multi_draw_arrays(context, load, userptr);
+    glad_gl_load_GL_EXT_point_parameters(context, load, userptr);
+    glad_gl_load_GL_EXT_provoking_vertex(context, load, userptr);
+    glad_gl_load_GL_EXT_subtexture(context, load, userptr);
+    glad_gl_load_GL_EXT_texture3D(context, load, userptr);
+    glad_gl_load_GL_EXT_texture_array(context, load, userptr);
+    glad_gl_load_GL_EXT_texture_buffer_object(context, load, userptr);
+    glad_gl_load_GL_EXT_texture_integer(context, load, userptr);
+    glad_gl_load_GL_EXT_texture_object(context, load, userptr);
+    glad_gl_load_GL_EXT_transform_feedback(context, load, userptr);
+    glad_gl_load_GL_EXT_vertex_array(context, load, userptr);
+    glad_gl_load_GL_INGR_blend_func_separate(context, load, userptr);
+    glad_gl_load_GL_NVX_conditional_render(context, load, userptr);
+    glad_gl_load_GL_NV_conditional_render(context, load, userptr);
+    glad_gl_load_GL_NV_explicit_multisample(context, load, userptr);
+    glad_gl_load_GL_NV_geometry_program4(context, load, userptr);
+    glad_gl_load_GL_NV_point_sprite(context, load, userptr);
+    glad_gl_load_GL_NV_transform_feedback(context, load, userptr);
+    glad_gl_load_GL_NV_vertex_program(context, load, userptr);
+    glad_gl_load_GL_NV_vertex_program4(context, load, userptr);
+    glad_gl_load_GL_SGIS_point_parameters(context, load, userptr);
+
+
+    glad_gl_resolve_aliases(context);
+
+    return version;
+}
+
+
+int gladLoadGLContext(GladGLContext *context, GLADloadfunc load) {
+    return gladLoadGLContextUserPtr(context, glad_gl_get_proc_from_userptr, GLAD_GNUC_EXTENSION (void*) load);
+}
+
+
+
+ 
+
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/thirdparty/glad/src/gles2.c b/thirdparty/glad/src/gles2.c
new file mode 100644
index 000000000..5157bf288
--- /dev/null
+++ b/thirdparty/glad/src/gles2.c
@@ -0,0 +1,351 @@
+/**
+ * SPDX-License-Identifier: (WTFPL OR CC0-1.0) AND Apache-2.0
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <glad/gles2.h>
+
+#ifndef GLAD_IMPL_UTIL_C_
+#define GLAD_IMPL_UTIL_C_
+
+#ifdef _MSC_VER
+#define GLAD_IMPL_UTIL_SSCANF sscanf_s
+#else
+#define GLAD_IMPL_UTIL_SSCANF sscanf
+#endif
+
+#endif /* GLAD_IMPL_UTIL_C_ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+
+
+
+
+
+
+static void glad_gl_load_GL_ES_VERSION_2_0(GladGLES2Context *context, GLADuserptrloadfunc load, void* userptr) {
+    if(!context->ES_VERSION_2_0) return;
+    context->ActiveTexture = (PFNGLACTIVETEXTUREPROC) load(userptr, "glActiveTexture");
+    context->AttachShader = (PFNGLATTACHSHADERPROC) load(userptr, "glAttachShader");
+    context->BindAttribLocation = (PFNGLBINDATTRIBLOCATIONPROC) load(userptr, "glBindAttribLocation");
+    context->BindBuffer = (PFNGLBINDBUFFERPROC) load(userptr, "glBindBuffer");
+    context->BindFramebuffer = (PFNGLBINDFRAMEBUFFERPROC) load(userptr, "glBindFramebuffer");
+    context->BindRenderbuffer = (PFNGLBINDRENDERBUFFERPROC) load(userptr, "glBindRenderbuffer");
+    context->BindTexture = (PFNGLBINDTEXTUREPROC) load(userptr, "glBindTexture");
+    context->BlendColor = (PFNGLBLENDCOLORPROC) load(userptr, "glBlendColor");
+    context->BlendEquation = (PFNGLBLENDEQUATIONPROC) load(userptr, "glBlendEquation");
+    context->BlendEquationSeparate = (PFNGLBLENDEQUATIONSEPARATEPROC) load(userptr, "glBlendEquationSeparate");
+    context->BlendFunc = (PFNGLBLENDFUNCPROC) load(userptr, "glBlendFunc");
+    context->BlendFuncSeparate = (PFNGLBLENDFUNCSEPARATEPROC) load(userptr, "glBlendFuncSeparate");
+    context->BufferData = (PFNGLBUFFERDATAPROC) load(userptr, "glBufferData");
+    context->BufferSubData = (PFNGLBUFFERSUBDATAPROC) load(userptr, "glBufferSubData");
+    context->CheckFramebufferStatus = (PFNGLCHECKFRAMEBUFFERSTATUSPROC) load(userptr, "glCheckFramebufferStatus");
+    context->Clear = (PFNGLCLEARPROC) load(userptr, "glClear");
+    context->ClearColor = (PFNGLCLEARCOLORPROC) load(userptr, "glClearColor");
+    context->ClearDepthf = (PFNGLCLEARDEPTHFPROC) load(userptr, "glClearDepthf");
+    context->ClearStencil = (PFNGLCLEARSTENCILPROC) load(userptr, "glClearStencil");
+    context->ColorMask = (PFNGLCOLORMASKPROC) load(userptr, "glColorMask");
+    context->CompileShader = (PFNGLCOMPILESHADERPROC) load(userptr, "glCompileShader");
+    context->CompressedTexImage2D = (PFNGLCOMPRESSEDTEXIMAGE2DPROC) load(userptr, "glCompressedTexImage2D");
+    context->CompressedTexSubImage2D = (PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC) load(userptr, "glCompressedTexSubImage2D");
+    context->CopyTexImage2D = (PFNGLCOPYTEXIMAGE2DPROC) load(userptr, "glCopyTexImage2D");
+    context->CopyTexSubImage2D = (PFNGLCOPYTEXSUBIMAGE2DPROC) load(userptr, "glCopyTexSubImage2D");
+    context->CreateProgram = (PFNGLCREATEPROGRAMPROC) load(userptr, "glCreateProgram");
+    context->CreateShader = (PFNGLCREATESHADERPROC) load(userptr, "glCreateShader");
+    context->CullFace = (PFNGLCULLFACEPROC) load(userptr, "glCullFace");
+    context->DeleteBuffers = (PFNGLDELETEBUFFERSPROC) load(userptr, "glDeleteBuffers");
+    context->DeleteFramebuffers = (PFNGLDELETEFRAMEBUFFERSPROC) load(userptr, "glDeleteFramebuffers");
+    context->DeleteProgram = (PFNGLDELETEPROGRAMPROC) load(userptr, "glDeleteProgram");
+    context->DeleteRenderbuffers = (PFNGLDELETERENDERBUFFERSPROC) load(userptr, "glDeleteRenderbuffers");
+    context->DeleteShader = (PFNGLDELETESHADERPROC) load(userptr, "glDeleteShader");
+    context->DeleteTextures = (PFNGLDELETETEXTURESPROC) load(userptr, "glDeleteTextures");
+    context->DepthFunc = (PFNGLDEPTHFUNCPROC) load(userptr, "glDepthFunc");
+    context->DepthMask = (PFNGLDEPTHMASKPROC) load(userptr, "glDepthMask");
+    context->DepthRangef = (PFNGLDEPTHRANGEFPROC) load(userptr, "glDepthRangef");
+    context->DetachShader = (PFNGLDETACHSHADERPROC) load(userptr, "glDetachShader");
+    context->Disable = (PFNGLDISABLEPROC) load(userptr, "glDisable");
+    context->DisableVertexAttribArray = (PFNGLDISABLEVERTEXATTRIBARRAYPROC) load(userptr, "glDisableVertexAttribArray");
+    context->DrawArrays = (PFNGLDRAWARRAYSPROC) load(userptr, "glDrawArrays");
+    context->DrawElements = (PFNGLDRAWELEMENTSPROC) load(userptr, "glDrawElements");
+    context->Enable = (PFNGLENABLEPROC) load(userptr, "glEnable");
+    context->EnableVertexAttribArray = (PFNGLENABLEVERTEXATTRIBARRAYPROC) load(userptr, "glEnableVertexAttribArray");
+    context->Finish = (PFNGLFINISHPROC) load(userptr, "glFinish");
+    context->Flush = (PFNGLFLUSHPROC) load(userptr, "glFlush");
+    context->FramebufferRenderbuffer = (PFNGLFRAMEBUFFERRENDERBUFFERPROC) load(userptr, "glFramebufferRenderbuffer");
+    context->FramebufferTexture2D = (PFNGLFRAMEBUFFERTEXTURE2DPROC) load(userptr, "glFramebufferTexture2D");
+    context->FrontFace = (PFNGLFRONTFACEPROC) load(userptr, "glFrontFace");
+    context->GenBuffers = (PFNGLGENBUFFERSPROC) load(userptr, "glGenBuffers");
+    context->GenFramebuffers = (PFNGLGENFRAMEBUFFERSPROC) load(userptr, "glGenFramebuffers");
+    context->GenRenderbuffers = (PFNGLGENRENDERBUFFERSPROC) load(userptr, "glGenRenderbuffers");
+    context->GenTextures = (PFNGLGENTEXTURESPROC) load(userptr, "glGenTextures");
+    context->GenerateMipmap = (PFNGLGENERATEMIPMAPPROC) load(userptr, "glGenerateMipmap");
+    context->GetActiveAttrib = (PFNGLGETACTIVEATTRIBPROC) load(userptr, "glGetActiveAttrib");
+    context->GetActiveUniform = (PFNGLGETACTIVEUNIFORMPROC) load(userptr, "glGetActiveUniform");
+    context->GetAttachedShaders = (PFNGLGETATTACHEDSHADERSPROC) load(userptr, "glGetAttachedShaders");
+    context->GetAttribLocation = (PFNGLGETATTRIBLOCATIONPROC) load(userptr, "glGetAttribLocation");
+    context->GetBooleanv = (PFNGLGETBOOLEANVPROC) load(userptr, "glGetBooleanv");
+    context->GetBufferParameteriv = (PFNGLGETBUFFERPARAMETERIVPROC) load(userptr, "glGetBufferParameteriv");
+    context->GetError = (PFNGLGETERRORPROC) load(userptr, "glGetError");
+    context->GetFloatv = (PFNGLGETFLOATVPROC) load(userptr, "glGetFloatv");
+    context->GetFramebufferAttachmentParameteriv = (PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC) load(userptr, "glGetFramebufferAttachmentParameteriv");
+    context->GetIntegerv = (PFNGLGETINTEGERVPROC) load(userptr, "glGetIntegerv");
+    context->GetProgramInfoLog = (PFNGLGETPROGRAMINFOLOGPROC) load(userptr, "glGetProgramInfoLog");
+    context->GetProgramiv = (PFNGLGETPROGRAMIVPROC) load(userptr, "glGetProgramiv");
+    context->GetRenderbufferParameteriv = (PFNGLGETRENDERBUFFERPARAMETERIVPROC) load(userptr, "glGetRenderbufferParameteriv");
+    context->GetShaderInfoLog = (PFNGLGETSHADERINFOLOGPROC) load(userptr, "glGetShaderInfoLog");
+    context->GetShaderPrecisionFormat = (PFNGLGETSHADERPRECISIONFORMATPROC) load(userptr, "glGetShaderPrecisionFormat");
+    context->GetShaderSource = (PFNGLGETSHADERSOURCEPROC) load(userptr, "glGetShaderSource");
+    context->GetShaderiv = (PFNGLGETSHADERIVPROC) load(userptr, "glGetShaderiv");
+    context->GetString = (PFNGLGETSTRINGPROC) load(userptr, "glGetString");
+    context->GetTexParameterfv = (PFNGLGETTEXPARAMETERFVPROC) load(userptr, "glGetTexParameterfv");
+    context->GetTexParameteriv = (PFNGLGETTEXPARAMETERIVPROC) load(userptr, "glGetTexParameteriv");
+    context->GetUniformLocation = (PFNGLGETUNIFORMLOCATIONPROC) load(userptr, "glGetUniformLocation");
+    context->GetUniformfv = (PFNGLGETUNIFORMFVPROC) load(userptr, "glGetUniformfv");
+    context->GetUniformiv = (PFNGLGETUNIFORMIVPROC) load(userptr, "glGetUniformiv");
+    context->GetVertexAttribPointerv = (PFNGLGETVERTEXATTRIBPOINTERVPROC) load(userptr, "glGetVertexAttribPointerv");
+    context->GetVertexAttribfv = (PFNGLGETVERTEXATTRIBFVPROC) load(userptr, "glGetVertexAttribfv");
+    context->GetVertexAttribiv = (PFNGLGETVERTEXATTRIBIVPROC) load(userptr, "glGetVertexAttribiv");
+    context->Hint = (PFNGLHINTPROC) load(userptr, "glHint");
+    context->IsBuffer = (PFNGLISBUFFERPROC) load(userptr, "glIsBuffer");
+    context->IsEnabled = (PFNGLISENABLEDPROC) load(userptr, "glIsEnabled");
+    context->IsFramebuffer = (PFNGLISFRAMEBUFFERPROC) load(userptr, "glIsFramebuffer");
+    context->IsProgram = (PFNGLISPROGRAMPROC) load(userptr, "glIsProgram");
+    context->IsRenderbuffer = (PFNGLISRENDERBUFFERPROC) load(userptr, "glIsRenderbuffer");
+    context->IsShader = (PFNGLISSHADERPROC) load(userptr, "glIsShader");
+    context->IsTexture = (PFNGLISTEXTUREPROC) load(userptr, "glIsTexture");
+    context->LineWidth = (PFNGLLINEWIDTHPROC) load(userptr, "glLineWidth");
+    context->LinkProgram = (PFNGLLINKPROGRAMPROC) load(userptr, "glLinkProgram");
+    context->PixelStorei = (PFNGLPIXELSTOREIPROC) load(userptr, "glPixelStorei");
+    context->PolygonOffset = (PFNGLPOLYGONOFFSETPROC) load(userptr, "glPolygonOffset");
+    context->ReadPixels = (PFNGLREADPIXELSPROC) load(userptr, "glReadPixels");
+    context->ReleaseShaderCompiler = (PFNGLRELEASESHADERCOMPILERPROC) load(userptr, "glReleaseShaderCompiler");
+    context->RenderbufferStorage = (PFNGLRENDERBUFFERSTORAGEPROC) load(userptr, "glRenderbufferStorage");
+    context->SampleCoverage = (PFNGLSAMPLECOVERAGEPROC) load(userptr, "glSampleCoverage");
+    context->Scissor = (PFNGLSCISSORPROC) load(userptr, "glScissor");
+    context->ShaderBinary = (PFNGLSHADERBINARYPROC) load(userptr, "glShaderBinary");
+    context->ShaderSource = (PFNGLSHADERSOURCEPROC) load(userptr, "glShaderSource");
+    context->StencilFunc = (PFNGLSTENCILFUNCPROC) load(userptr, "glStencilFunc");
+    context->StencilFuncSeparate = (PFNGLSTENCILFUNCSEPARATEPROC) load(userptr, "glStencilFuncSeparate");
+    context->StencilMask = (PFNGLSTENCILMASKPROC) load(userptr, "glStencilMask");
+    context->StencilMaskSeparate = (PFNGLSTENCILMASKSEPARATEPROC) load(userptr, "glStencilMaskSeparate");
+    context->StencilOp = (PFNGLSTENCILOPPROC) load(userptr, "glStencilOp");
+    context->StencilOpSeparate = (PFNGLSTENCILOPSEPARATEPROC) load(userptr, "glStencilOpSeparate");
+    context->TexImage2D = (PFNGLTEXIMAGE2DPROC) load(userptr, "glTexImage2D");
+    context->TexParameterf = (PFNGLTEXPARAMETERFPROC) load(userptr, "glTexParameterf");
+    context->TexParameterfv = (PFNGLTEXPARAMETERFVPROC) load(userptr, "glTexParameterfv");
+    context->TexParameteri = (PFNGLTEXPARAMETERIPROC) load(userptr, "glTexParameteri");
+    context->TexParameteriv = (PFNGLTEXPARAMETERIVPROC) load(userptr, "glTexParameteriv");
+    context->TexSubImage2D = (PFNGLTEXSUBIMAGE2DPROC) load(userptr, "glTexSubImage2D");
+    context->Uniform1f = (PFNGLUNIFORM1FPROC) load(userptr, "glUniform1f");
+    context->Uniform1fv = (PFNGLUNIFORM1FVPROC) load(userptr, "glUniform1fv");
+    context->Uniform1i = (PFNGLUNIFORM1IPROC) load(userptr, "glUniform1i");
+    context->Uniform1iv = (PFNGLUNIFORM1IVPROC) load(userptr, "glUniform1iv");
+    context->Uniform2f = (PFNGLUNIFORM2FPROC) load(userptr, "glUniform2f");
+    context->Uniform2fv = (PFNGLUNIFORM2FVPROC) load(userptr, "glUniform2fv");
+    context->Uniform2i = (PFNGLUNIFORM2IPROC) load(userptr, "glUniform2i");
+    context->Uniform2iv = (PFNGLUNIFORM2IVPROC) load(userptr, "glUniform2iv");
+    context->Uniform3f = (PFNGLUNIFORM3FPROC) load(userptr, "glUniform3f");
+    context->Uniform3fv = (PFNGLUNIFORM3FVPROC) load(userptr, "glUniform3fv");
+    context->Uniform3i = (PFNGLUNIFORM3IPROC) load(userptr, "glUniform3i");
+    context->Uniform3iv = (PFNGLUNIFORM3IVPROC) load(userptr, "glUniform3iv");
+    context->Uniform4f = (PFNGLUNIFORM4FPROC) load(userptr, "glUniform4f");
+    context->Uniform4fv = (PFNGLUNIFORM4FVPROC) load(userptr, "glUniform4fv");
+    context->Uniform4i = (PFNGLUNIFORM4IPROC) load(userptr, "glUniform4i");
+    context->Uniform4iv = (PFNGLUNIFORM4IVPROC) load(userptr, "glUniform4iv");
+    context->UniformMatrix2fv = (PFNGLUNIFORMMATRIX2FVPROC) load(userptr, "glUniformMatrix2fv");
+    context->UniformMatrix3fv = (PFNGLUNIFORMMATRIX3FVPROC) load(userptr, "glUniformMatrix3fv");
+    context->UniformMatrix4fv = (PFNGLUNIFORMMATRIX4FVPROC) load(userptr, "glUniformMatrix4fv");
+    context->UseProgram = (PFNGLUSEPROGRAMPROC) load(userptr, "glUseProgram");
+    context->ValidateProgram = (PFNGLVALIDATEPROGRAMPROC) load(userptr, "glValidateProgram");
+    context->VertexAttrib1f = (PFNGLVERTEXATTRIB1FPROC) load(userptr, "glVertexAttrib1f");
+    context->VertexAttrib1fv = (PFNGLVERTEXATTRIB1FVPROC) load(userptr, "glVertexAttrib1fv");
+    context->VertexAttrib2f = (PFNGLVERTEXATTRIB2FPROC) load(userptr, "glVertexAttrib2f");
+    context->VertexAttrib2fv = (PFNGLVERTEXATTRIB2FVPROC) load(userptr, "glVertexAttrib2fv");
+    context->VertexAttrib3f = (PFNGLVERTEXATTRIB3FPROC) load(userptr, "glVertexAttrib3f");
+    context->VertexAttrib3fv = (PFNGLVERTEXATTRIB3FVPROC) load(userptr, "glVertexAttrib3fv");
+    context->VertexAttrib4f = (PFNGLVERTEXATTRIB4FPROC) load(userptr, "glVertexAttrib4f");
+    context->VertexAttrib4fv = (PFNGLVERTEXATTRIB4FVPROC) load(userptr, "glVertexAttrib4fv");
+    context->VertexAttribPointer = (PFNGLVERTEXATTRIBPOINTERPROC) load(userptr, "glVertexAttribPointer");
+    context->Viewport = (PFNGLVIEWPORTPROC) load(userptr, "glViewport");
+}
+
+
+static void glad_gl_resolve_aliases(GladGLES2Context *context) {
+}
+
+#if defined(GL_ES_VERSION_3_0) || defined(GL_VERSION_3_0)
+#define GLAD_GL_IS_SOME_NEW_VERSION 1
+#else
+#define GLAD_GL_IS_SOME_NEW_VERSION 0
+#endif
+
+static int glad_gl_get_extensions(GladGLES2Context *context, int version, const char **out_exts, unsigned int *out_num_exts_i, char ***out_exts_i) {
+#if GLAD_GL_IS_SOME_NEW_VERSION
+    if(GLAD_VERSION_MAJOR(version) < 3) {
+#else
+    GLAD_UNUSED(version);
+    GLAD_UNUSED(out_num_exts_i);
+    GLAD_UNUSED(out_exts_i);
+#endif
+        if (context->GetString == NULL) {
+            return 0;
+        }
+        *out_exts = (const char *)context->GetString(GL_EXTENSIONS);
+#if GLAD_GL_IS_SOME_NEW_VERSION
+    } else {
+        unsigned int index = 0;
+        unsigned int num_exts_i = 0;
+        char **exts_i = NULL;
+        if (context->GetStringi == NULL || context->GetIntegerv == NULL) {
+            return 0;
+        }
+        context->GetIntegerv(GL_NUM_EXTENSIONS, (int*) &num_exts_i);
+        if (num_exts_i > 0) {
+            exts_i = (char **) malloc(num_exts_i * (sizeof *exts_i));
+        }
+        if (exts_i == NULL) {
+            return 0;
+        }
+        for(index = 0; index < num_exts_i; index++) {
+            const char *gl_str_tmp = (const char*) context->GetStringi(GL_EXTENSIONS, index);
+            size_t len = strlen(gl_str_tmp) + 1;
+
+            char *local_str = (char*) malloc(len * sizeof(char));
+            if(local_str != NULL) {
+                memcpy(local_str, gl_str_tmp, len * sizeof(char));
+            }
+
+            exts_i[index] = local_str;
+        }
+
+        *out_num_exts_i = num_exts_i;
+        *out_exts_i = exts_i;
+    }
+#endif
+    return 1;
+}
+static void glad_gl_free_extensions(char **exts_i, unsigned int num_exts_i) {
+    if (exts_i != NULL) {
+        unsigned int index;
+        for(index = 0; index < num_exts_i; index++) {
+            free((void *) (exts_i[index]));
+        }
+        free((void *)exts_i);
+        exts_i = NULL;
+    }
+}
+static int glad_gl_has_extension(int version, const char *exts, unsigned int num_exts_i, char **exts_i, const char *ext) {
+    if(GLAD_VERSION_MAJOR(version) < 3 || !GLAD_GL_IS_SOME_NEW_VERSION) {
+        const char *extensions;
+        const char *loc;
+        const char *terminator;
+        extensions = exts;
+        if(extensions == NULL || ext == NULL) {
+            return 0;
+        }
+        while(1) {
+            loc = strstr(extensions, ext);
+            if(loc == NULL) {
+                return 0;
+            }
+            terminator = loc + strlen(ext);
+            if((loc == extensions || *(loc - 1) == ' ') &&
+                (*terminator == ' ' || *terminator == '\0')) {
+                return 1;
+            }
+            extensions = terminator;
+        }
+    } else {
+        unsigned int index;
+        for(index = 0; index < num_exts_i; index++) {
+            const char *e = exts_i[index];
+            if(strcmp(e, ext) == 0) {
+                return 1;
+            }
+        }
+    }
+    return 0;
+}
+
+static GLADapiproc glad_gl_get_proc_from_userptr(void *userptr, const char* name) {
+    return (GLAD_GNUC_EXTENSION (GLADapiproc (*)(const char *name)) userptr)(name);
+}
+
+static int glad_gl_find_extensions_gles2(GladGLES2Context *context, int version) {
+    const char *exts = NULL;
+    unsigned int num_exts_i = 0;
+    char **exts_i = NULL;
+    if (!glad_gl_get_extensions(context, version, &exts, &num_exts_i, &exts_i)) return 0;
+
+    context->OES_rgb8_rgba8 = glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_OES_rgb8_rgba8");
+
+    glad_gl_free_extensions(exts_i, num_exts_i);
+
+    return 1;
+}
+
+static int glad_gl_find_core_gles2(GladGLES2Context *context) {
+    int i;
+    const char* version;
+    const char* prefixes[] = {
+        "OpenGL ES-CM ",
+        "OpenGL ES-CL ",
+        "OpenGL ES ",
+        "OpenGL SC ",
+        NULL
+    };
+    int major = 0;
+    int minor = 0;
+    version = (const char*) context->GetString(GL_VERSION);
+    if (!version) return 0;
+    for (i = 0;  prefixes[i];  i++) {
+        const size_t length = strlen(prefixes[i]);
+        if (strncmp(version, prefixes[i], length) == 0) {
+            version += length;
+            break;
+        }
+    }
+
+    GLAD_IMPL_UTIL_SSCANF(version, "%d.%d", &major, &minor);
+
+    context->ES_VERSION_2_0 = (major == 2 && minor >= 0) || major > 2;
+
+    return GLAD_MAKE_VERSION(major, minor);
+}
+
+int gladLoadGLES2ContextUserPtr(GladGLES2Context *context, GLADuserptrloadfunc load, void *userptr) {
+    int version;
+
+    context->GetString = (PFNGLGETSTRINGPROC) load(userptr, "glGetString");
+    if(context->GetString == NULL) return 0;
+    if(context->GetString(GL_VERSION) == NULL) return 0;
+    version = glad_gl_find_core_gles2(context);
+
+    glad_gl_load_GL_ES_VERSION_2_0(context, load, userptr);
+
+    if (!glad_gl_find_extensions_gles2(context, version)) return 0;
+
+
+    glad_gl_resolve_aliases(context);
+
+    return version;
+}
+
+
+int gladLoadGLES2Context(GladGLES2Context *context, GLADloadfunc load) {
+    return gladLoadGLES2ContextUserPtr(context, glad_gl_get_proc_from_userptr, GLAD_GNUC_EXTENSION (void*) load);
+}
+
+
+
+ 
+
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/thirdparty/imgui_config/srb2_imconfig.h b/thirdparty/imgui_config/srb2_imconfig.h
new file mode 100644
index 000000000..5c09001b2
--- /dev/null
+++ b/thirdparty/imgui_config/srb2_imconfig.h
@@ -0,0 +1,38 @@
+#ifndef __SRB2_IMCONFIG_H__
+#define __SRB2_IMCONFIG_H__
+
+#include <stdint.h>
+
+#define IMGUI_DISABLE_OBSOLETE_FUNCTIONS
+#define IMGUI_DISABLE_OBSOLETE_KEYIO
+
+// We provide needed functionalities provided by default win32 impls through the interface layer
+#define IMGUI_DISABLE_WIN32_FUNCTIONS
+
+// RHI Handles are essentially 64-bit integers
+#define ImTextureID uint64_t
+
+// RHI does not support integer vectors
+#define IMGUI_OVERRIDE_DRAWVERT_STRUCT_LAYOUT \
+struct ImVec3 \
+{ \
+    float x, y, z; \
+    constexpr ImVec3()                                : x(0.0f), y(0.0f), z(0.0f) { } \
+	constexpr ImVec3(float _x, float _y)              : x(_x), y(_y), z(0.0f) { } \
+    constexpr ImVec3(float _x, float _y, float _z)    : x(_x), y(_y), z(_z) { } \
+	constexpr ImVec3(const ImVec2& rhs) : x(rhs.x), y(rhs.y), z(0.f) { } \
+	ImVec3& operator=(const ImVec2& rhs) { x = rhs.x; y = rhs.y; return *this; } \
+	operator ImVec2() const { return ImVec2(x, y); } \
+    float operator[](size_t index) const { switch (index) {case 0: return x; case 1: return y; case 2: return z; default: return 0.f;} } \
+    float operator[](size_t index) { switch (index) {case 0: return x; case 1: return y; case 2: return z; default: return 0.f;} } \
+ \
+}; \
+struct ImDrawVert \
+{ \
+    ImVec3  pos; \
+    ImVec2  uv; \
+    ImU32   col; \
+    float   colf[4]; \
+};
+
+#endif // __SRB2_IMCONFIG_H__