#define GL_GLEXT_PROTOTYPES 1
#include <GLES2/gl2.h>
#include <GLES2/gl2ext.h>
extern "C" {
#include <GLES2/gl2ext_angle.h>
}
#include <GLES3/gl3.h>

#include <LibWeb/WebGL/GLFunctions.h>

namespace Web::WebGL {

void GLFunctions::active_texture(GLenum texture)
{
    ::glActiveTexture(texture);
}

void GLFunctions::attach_shader(GLuint program, GLuint shader)
{
    ::glAttachShader(program, shader);
}

void GLFunctions::begin_query(GLenum target, GLuint id)
{
    ::glBeginQuery(target, id);
}

void GLFunctions::begin_transform_feedback(GLenum primitiveMode)
{
    ::glBeginTransformFeedback(primitiveMode);
}

void GLFunctions::bind_attrib_location(GLuint program, GLuint index, GLchar const* name)
{
    ::glBindAttribLocation(program, index, name);
}

void GLFunctions::bind_buffer(GLenum target, GLuint buffer)
{
    ::glBindBuffer(target, buffer);
}

void GLFunctions::bind_buffer_base(GLenum target, GLuint index, GLuint buffer)
{
    ::glBindBufferBase(target, index, buffer);
}

void GLFunctions::bind_buffer_range(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)
{
    ::glBindBufferRange(target, index, buffer, offset, size);
}

void GLFunctions::bind_framebuffer(GLenum target, GLuint framebuffer)
{
    ::glBindFramebuffer(target, framebuffer);
}

void GLFunctions::bind_renderbuffer(GLenum target, GLuint renderbuffer)
{
    ::glBindRenderbuffer(target, renderbuffer);
}

void GLFunctions::bind_sampler(GLuint unit, GLuint sampler)
{
    ::glBindSampler(unit, sampler);
}

void GLFunctions::bind_texture(GLenum target, GLuint texture)
{
    ::glBindTexture(target, texture);
}

void GLFunctions::bind_transform_feedback(GLenum target, GLuint id)
{
    ::glBindTransformFeedback(target, id);
}

void GLFunctions::bind_vertex_array(GLuint array)
{
    ::glBindVertexArray(array);
}

void GLFunctions::bind_vertex_array_oes(GLuint array)
{
    ::glBindVertexArrayOES(array);
}

void GLFunctions::blend_color(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
{
    ::glBlendColor(red, green, blue, alpha);
}

void GLFunctions::blend_equation(GLenum mode)
{
    ::glBlendEquation(mode);
}

void GLFunctions::blend_equation_separate(GLenum modeRGB, GLenum modeAlpha)
{
    ::glBlendEquationSeparate(modeRGB, modeAlpha);
}

void GLFunctions::blend_func(GLenum sfactor, GLenum dfactor)
{
    ::glBlendFunc(sfactor, dfactor);
}

void GLFunctions::blend_func_separate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
{
    ::glBlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
}

void GLFunctions::blit_framebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
{
    ::glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
}

void GLFunctions::buffer_data(GLenum target, GLsizeiptr size, void const* data, GLenum usage)
{
    ::glBufferData(target, size, data, usage);
}

void GLFunctions::buffer_sub_data(GLenum target, GLintptr offset, GLsizeiptr size, void const* data)
{
    ::glBufferSubData(target, offset, size, data);
}

GLenum GLFunctions::check_framebuffer_status(GLenum target)
{
    return ::glCheckFramebufferStatus(target);
}

void GLFunctions::clear(GLbitfield mask)
{
    ::glClear(mask);
}

void GLFunctions::clear_bufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil)
{
    ::glClearBufferfi(buffer, drawbuffer, depth, stencil);
}

void GLFunctions::clear_bufferfv(GLenum buffer, GLint drawbuffer, GLfloat const* value)
{
    ::glClearBufferfv(buffer, drawbuffer, value);
}

void GLFunctions::clear_bufferiv(GLenum buffer, GLint drawbuffer, GLint const* value)
{
    ::glClearBufferiv(buffer, drawbuffer, value);
}

void GLFunctions::clear_bufferuiv(GLenum buffer, GLint drawbuffer, GLuint const* value)
{
    ::glClearBufferuiv(buffer, drawbuffer, value);
}

void GLFunctions::clear_color(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
{
    ::glClearColor(red, green, blue, alpha);
}

void GLFunctions::clear_depthf(GLfloat d)
{
    ::glClearDepthf(d);
}

void GLFunctions::clear_stencil(GLint s)
{
    ::glClearStencil(s);
}

GLenum GLFunctions::client_wait_sync(GLsync sync, GLbitfield flags, GLuint64 timeout)
{
    return ::glClientWaitSync(sync, flags, timeout);
}

void GLFunctions::color_mask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
{
    ::glColorMask(red, green, blue, alpha);
}

void GLFunctions::compile_shader(GLuint shader)
{
    ::glCompileShader(shader);
}

void GLFunctions::compressed_tex_image2d_robust_angle(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, GLsizei bufSize, void const* data)
{
    ::glCompressedTexImage2DRobustANGLE(target, level, internalformat, width, height, border, imageSize, bufSize, data);
}

void GLFunctions::compressed_tex_image3d_robust_angle(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, GLsizei bufSize, void const* data)
{
    ::glCompressedTexImage3DRobustANGLE(target, level, internalformat, width, height, depth, border, imageSize, bufSize, data);
}

void GLFunctions::compressed_tex_sub_image2d_robust_angle(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, GLsizei bufSize, void const* data)
{
    ::glCompressedTexSubImage2DRobustANGLE(target, level, xoffset, yoffset, width, height, format, imageSize, bufSize, data);
}

void GLFunctions::compressed_tex_sub_image3d_robust_angle(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, GLsizei bufSize, void const* data)
{
    ::glCompressedTexSubImage3DRobustANGLE(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, bufSize, data);
}

void GLFunctions::copy_buffer_sub_data(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)
{
    ::glCopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
}

void GLFunctions::copy_tex_image2d(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
{
    ::glCopyTexImage2D(target, level, internalformat, x, y, width, height, border);
}

void GLFunctions::copy_tex_sub_image2d(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
{
    ::glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
}

GLuint GLFunctions::create_program()
{
    return ::glCreateProgram();
}

GLuint GLFunctions::create_shader(GLenum type)
{
    return ::glCreateShader(type);
}

void GLFunctions::cull_face(GLenum mode)
{
    ::glCullFace(mode);
}

void GLFunctions::delete_buffers(GLsizei n, GLuint const* buffers)
{
    ::glDeleteBuffers(n, buffers);
}

void GLFunctions::delete_framebuffers(GLsizei n, GLuint const* framebuffers)
{
    ::glDeleteFramebuffers(n, framebuffers);
}

void GLFunctions::delete_program(GLuint program)
{
    ::glDeleteProgram(program);
}

void GLFunctions::delete_queries(GLsizei n, GLuint const* ids)
{
    ::glDeleteQueries(n, ids);
}

void GLFunctions::delete_renderbuffers(GLsizei n, GLuint const* renderbuffers)
{
    ::glDeleteRenderbuffers(n, renderbuffers);
}

void GLFunctions::delete_samplers(GLsizei count, GLuint const* samplers)
{
    ::glDeleteSamplers(count, samplers);
}

void GLFunctions::delete_shader(GLuint shader)
{
    ::glDeleteShader(shader);
}

void GLFunctions::delete_sync(GLsync sync)
{
    ::glDeleteSync(sync);
}

void GLFunctions::delete_textures(GLsizei n, GLuint const* textures)
{
    ::glDeleteTextures(n, textures);
}

void GLFunctions::delete_transform_feedbacks(GLsizei n, GLuint const* ids)
{
    ::glDeleteTransformFeedbacks(n, ids);
}

void GLFunctions::delete_vertex_arrays(GLsizei n, GLuint const* arrays)
{
    ::glDeleteVertexArrays(n, arrays);
}

void GLFunctions::delete_vertex_arrays_oes(GLsizei n, GLuint const* arrays)
{
    ::glDeleteVertexArraysOES(n, arrays);
}

void GLFunctions::depth_func(GLenum func)
{
    ::glDepthFunc(func);
}

void GLFunctions::depth_mask(GLboolean flag)
{
    ::glDepthMask(flag);
}

void GLFunctions::depth_rangef(GLfloat n, GLfloat f)
{
    ::glDepthRangef(n, f);
}

void GLFunctions::detach_shader(GLuint program, GLuint shader)
{
    ::glDetachShader(program, shader);
}

void GLFunctions::disable(GLenum cap)
{
    ::glDisable(cap);
}

void GLFunctions::disable_vertex_attrib_array(GLuint index)
{
    ::glDisableVertexAttribArray(index);
}

void GLFunctions::draw_arrays(GLenum mode, GLint first, GLsizei count)
{
    ::glDrawArrays(mode, first, count);
}

void GLFunctions::draw_arrays_instanced(GLenum mode, GLint first, GLsizei count, GLsizei instancecount)
{
    ::glDrawArraysInstanced(mode, first, count, instancecount);
}

void GLFunctions::draw_arrays_instanced_angle(GLenum mode, GLint first, GLsizei count, GLsizei primcount)
{
    ::glDrawArraysInstancedANGLE(mode, first, count, primcount);
}

void GLFunctions::draw_buffers(GLsizei n, GLenum const* bufs)
{
    ::glDrawBuffers(n, bufs);
}

void GLFunctions::draw_buffers_ext(GLsizei n, GLenum const* bufs)
{
    ::glDrawBuffersEXT(n, bufs);
}

void GLFunctions::draw_elements(GLenum mode, GLsizei count, GLenum type, void const* indices)
{
    ::glDrawElements(mode, count, type, indices);
}

void GLFunctions::draw_elements_instanced(GLenum mode, GLsizei count, GLenum type, void const* indices, GLsizei instancecount)
{
    ::glDrawElementsInstanced(mode, count, type, indices, instancecount);
}

void GLFunctions::draw_elements_instanced_angle(GLenum mode, GLsizei count, GLenum type, void const* indices, GLsizei primcount)
{
    ::glDrawElementsInstancedANGLE(mode, count, type, indices, primcount);
}

void GLFunctions::draw_range_elements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, void const* indices)
{
    ::glDrawRangeElements(mode, start, end, count, type, indices);
}

void GLFunctions::enable(GLenum cap)
{
    ::glEnable(cap);
}

void GLFunctions::enable_vertex_attrib_array(GLuint index)
{
    ::glEnableVertexAttribArray(index);
}

void GLFunctions::end_query(GLenum target)
{
    ::glEndQuery(target);
}

void GLFunctions::end_transform_feedback()
{
    ::glEndTransformFeedback();
}

GLsync GLFunctions::fence_sync(GLenum condition, GLbitfield flags)
{
    return ::glFenceSync(condition, flags);
}

void GLFunctions::finish()
{
    ::glFinish();
}

void GLFunctions::flush()
{
    ::glFlush();
}

void GLFunctions::framebuffer_renderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
{
    ::glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
}

void GLFunctions::framebuffer_texture2d(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
{
    ::glFramebufferTexture2D(target, attachment, textarget, texture, level);
}

void GLFunctions::framebuffer_texture_layer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer)
{
    ::glFramebufferTextureLayer(target, attachment, texture, level, layer);
}

void GLFunctions::front_face(GLenum mode)
{
    ::glFrontFace(mode);
}

void GLFunctions::gen_buffers(GLsizei n, GLuint* buffers)
{
    ::glGenBuffers(n, buffers);
}

void GLFunctions::gen_framebuffers(GLsizei n, GLuint* framebuffers)
{
    ::glGenFramebuffers(n, framebuffers);
}

void GLFunctions::gen_queries(GLsizei n, GLuint* ids)
{
    ::glGenQueries(n, ids);
}

void GLFunctions::gen_renderbuffers(GLsizei n, GLuint* renderbuffers)
{
    ::glGenRenderbuffers(n, renderbuffers);
}

void GLFunctions::gen_samplers(GLsizei count, GLuint* samplers)
{
    ::glGenSamplers(count, samplers);
}

void GLFunctions::gen_textures(GLsizei n, GLuint* textures)
{
    ::glGenTextures(n, textures);
}

void GLFunctions::gen_transform_feedbacks(GLsizei n, GLuint* ids)
{
    ::glGenTransformFeedbacks(n, ids);
}

void GLFunctions::gen_vertex_arrays(GLsizei n, GLuint* arrays)
{
    ::glGenVertexArrays(n, arrays);
}

void GLFunctions::gen_vertex_arrays_oes(GLsizei n, GLuint* arrays)
{
    ::glGenVertexArraysOES(n, arrays);
}

void GLFunctions::generate_mipmap(GLenum target)
{
    ::glGenerateMipmap(target);
}

void GLFunctions::get_active_attrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GLenum* type, GLchar* name)
{
    ::glGetActiveAttrib(program, index, bufSize, length, size, type, name);
}

void GLFunctions::get_active_uniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GLenum* type, GLchar* name)
{
    ::glGetActiveUniform(program, index, bufSize, length, size, type, name);
}

void GLFunctions::get_active_uniform_block_name(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformBlockName)
{
    ::glGetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName);
}

void GLFunctions::get_active_uniform_blockiv_robust_angle(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* params)
{
    ::glGetActiveUniformBlockivRobustANGLE(program, uniformBlockIndex, pname, bufSize, length, params);
}

void GLFunctions::get_active_uniformsiv(GLuint program, GLsizei uniformCount, GLuint const* uniformIndices, GLenum pname, GLint* params)
{
    ::glGetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);
}

GLint GLFunctions::get_attrib_location(GLuint program, GLchar const* name)
{
    return ::glGetAttribLocation(program, name);
}

void GLFunctions::get_booleanv_robust_angle(GLenum pname, GLsizei bufSize, GLsizei* length, GLboolean* data)
{
    ::glGetBooleanvRobustANGLE(pname, bufSize, length, data);
}

void GLFunctions::get_buffer_parameteriv_robust_angle(GLenum target, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* params)
{
    ::glGetBufferParameterivRobustANGLE(target, pname, bufSize, length, params);
}

GLenum GLFunctions::get_error()
{
    return ::glGetError();
}

void GLFunctions::get_floatv_robust_angle(GLenum pname, GLsizei bufSize, GLsizei* length, GLfloat* data)
{
    ::glGetFloatvRobustANGLE(pname, bufSize, length, data);
}

void GLFunctions::get_integer64v_robust_angle(GLenum pname, GLsizei bufSize, GLsizei* length, GLint64* data)
{
    ::glGetInteger64vRobustANGLE(pname, bufSize, length, data);
}

void GLFunctions::get_integerv_robust_angle(GLenum pname, GLsizei bufSize, GLsizei* length, GLint* data)
{
    ::glGetIntegervRobustANGLE(pname, bufSize, length, data);
}

void GLFunctions::get_internalformativ_robust_angle(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* params)
{
    ::glGetInternalformativRobustANGLE(target, internalformat, pname, bufSize, length, params);
}

void GLFunctions::get_program_info_log(GLuint program, GLsizei bufSize, GLsizei* length, GLchar* infoLog)
{
    ::glGetProgramInfoLog(program, bufSize, length, infoLog);
}

void GLFunctions::get_programiv(GLuint program, GLenum pname, GLint* params)
{
    ::glGetProgramiv(program, pname, params);
}

void GLFunctions::get_programiv_robust_angle(GLuint program, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* params)
{
    ::glGetProgramivRobustANGLE(program, pname, bufSize, length, params);
}

void GLFunctions::get_query_objectuiv_robust_angle(GLuint id, GLenum pname, GLsizei bufSize, GLsizei* length, GLuint* params)
{
    ::glGetQueryObjectuivRobustANGLE(id, pname, bufSize, length, params);
}

void GLFunctions::get_renderbuffer_parameteriv_robust_angle(GLenum target, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* params)
{
    ::glGetRenderbufferParameterivRobustANGLE(target, pname, bufSize, length, params);
}

void GLFunctions::get_shader_info_log(GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* infoLog)
{
    ::glGetShaderInfoLog(shader, bufSize, length, infoLog);
}

void GLFunctions::get_shader_precision_format(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision)
{
    ::glGetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
}

void GLFunctions::get_shader_source(GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* source)
{
    ::glGetShaderSource(shader, bufSize, length, source);
}

void GLFunctions::get_shaderiv(GLuint shader, GLenum pname, GLint* params)
{
    ::glGetShaderiv(shader, pname, params);
}

void GLFunctions::get_shaderiv_robust_angle(GLuint shader, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* params)
{
    ::glGetShaderivRobustANGLE(shader, pname, bufSize, length, params);
}

GLubyte const* GLFunctions::get_string(GLenum name)
{
    return ::glGetString(name);
}

void GLFunctions::get_synciv(GLsync sync, GLenum pname, GLsizei count, GLsizei* length, GLint* values)
{
    ::glGetSynciv(sync, pname, count, length, values);
}

void GLFunctions::get_tex_parameterfv_robust_angle(GLenum target, GLenum pname, GLsizei bufSize, GLsizei* length, GLfloat* params)
{
    ::glGetTexParameterfvRobustANGLE(target, pname, bufSize, length, params);
}

void GLFunctions::get_tex_parameteriv_robust_angle(GLenum target, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* params)
{
    ::glGetTexParameterivRobustANGLE(target, pname, bufSize, length, params);
}

GLuint GLFunctions::get_uniform_block_index(GLuint program, GLchar const* uniformBlockName)
{
    return ::glGetUniformBlockIndex(program, uniformBlockName);
}

void GLFunctions::get_uniform_indices(GLuint program, GLsizei uniformCount, GLchar const* const* uniformNames, GLuint* uniformIndices)
{
    ::glGetUniformIndices(program, uniformCount, uniformNames, uniformIndices);
}

GLint GLFunctions::get_uniform_location(GLuint program, GLchar const* name)
{
    return ::glGetUniformLocation(program, name);
}

void GLFunctions::get_vertex_attrib_pointerv_robust_angle(GLuint index, GLenum pname, GLsizei bufSize, GLsizei* length, void** pointer)
{
    ::glGetVertexAttribPointervRobustANGLE(index, pname, bufSize, length, pointer);
}

void GLFunctions::get_vertex_attribfv_robust_angle(GLuint index, GLenum pname, GLsizei bufSize, GLsizei* length, GLfloat* params)
{
    ::glGetVertexAttribfvRobustANGLE(index, pname, bufSize, length, params);
}

void GLFunctions::get_vertex_attribiv_robust_angle(GLuint index, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* params)
{
    ::glGetVertexAttribivRobustANGLE(index, pname, bufSize, length, params);
}

void GLFunctions::hint(GLenum target, GLenum mode)
{
    ::glHint(target, mode);
}

void GLFunctions::invalidate_framebuffer(GLenum target, GLsizei numAttachments, GLenum const* attachments)
{
    ::glInvalidateFramebuffer(target, numAttachments, attachments);
}

void GLFunctions::invalidate_sub_framebuffer(GLenum target, GLsizei numAttachments, GLenum const* attachments, GLint x, GLint y, GLsizei width, GLsizei height)
{
    ::glInvalidateSubFramebuffer(target, numAttachments, attachments, x, y, width, height);
}

GLboolean GLFunctions::is_buffer(GLuint buffer)
{
    return ::glIsBuffer(buffer);
}

GLboolean GLFunctions::is_enabled(GLenum cap)
{
    return ::glIsEnabled(cap);
}

GLboolean GLFunctions::is_framebuffer(GLuint framebuffer)
{
    return ::glIsFramebuffer(framebuffer);
}

GLboolean GLFunctions::is_program(GLuint program)
{
    return ::glIsProgram(program);
}

GLboolean GLFunctions::is_renderbuffer(GLuint renderbuffer)
{
    return ::glIsRenderbuffer(renderbuffer);
}

GLboolean GLFunctions::is_shader(GLuint shader)
{
    return ::glIsShader(shader);
}

GLboolean GLFunctions::is_texture(GLuint texture)
{
    return ::glIsTexture(texture);
}

GLboolean GLFunctions::is_vertex_array(GLuint array)
{
    return ::glIsVertexArray(array);
}

GLboolean GLFunctions::is_vertex_array_oes(GLuint array)
{
    return ::glIsVertexArrayOES(array);
}

void GLFunctions::line_width(GLfloat width)
{
    ::glLineWidth(width);
}

void GLFunctions::link_program(GLuint program)
{
    ::glLinkProgram(program);
}

void* GLFunctions::map_buffer_range(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access)
{
    return ::glMapBufferRange(target, offset, length, access);
}

void GLFunctions::pause_transform_feedback()
{
    ::glPauseTransformFeedback();
}

void GLFunctions::pixel_storei(GLenum pname, GLint param)
{
    ::glPixelStorei(pname, param);
}

void GLFunctions::polygon_offset(GLfloat factor, GLfloat units)
{
    ::glPolygonOffset(factor, units);
}

void GLFunctions::read_buffer(GLenum src)
{
    ::glReadBuffer(src);
}

void GLFunctions::read_pixels_robust_angle(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, GLsizei* length, GLsizei* columns, GLsizei* rows, void* pixels)
{
    ::glReadPixelsRobustANGLE(x, y, width, height, format, type, bufSize, length, columns, rows, pixels);
}

void GLFunctions::renderbuffer_storage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
{
    ::glRenderbufferStorage(target, internalformat, width, height);
}

void GLFunctions::renderbuffer_storage_multisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
{
    ::glRenderbufferStorageMultisample(target, samples, internalformat, width, height);
}

void GLFunctions::request_extension_angle(GLchar const* name)
{
    ::glRequestExtensionANGLE(name);
}

void GLFunctions::resume_transform_feedback()
{
    ::glResumeTransformFeedback();
}

void GLFunctions::sample_coverage(GLfloat value, GLboolean invert)
{
    ::glSampleCoverage(value, invert);
}

void GLFunctions::sampler_parameterf(GLuint sampler, GLenum pname, GLfloat param)
{
    ::glSamplerParameterf(sampler, pname, param);
}

void GLFunctions::sampler_parameteri(GLuint sampler, GLenum pname, GLint param)
{
    ::glSamplerParameteri(sampler, pname, param);
}

void GLFunctions::scissor(GLint x, GLint y, GLsizei width, GLsizei height)
{
    ::glScissor(x, y, width, height);
}

void GLFunctions::shader_source(GLuint shader, GLsizei count, GLchar const* const* string, GLint const* length)
{
    ::glShaderSource(shader, count, string, length);
}

void GLFunctions::stencil_func(GLenum func, GLint ref, GLuint mask)
{
    ::glStencilFunc(func, ref, mask);
}

void GLFunctions::stencil_func_separate(GLenum face, GLenum func, GLint ref, GLuint mask)
{
    ::glStencilFuncSeparate(face, func, ref, mask);
}

void GLFunctions::stencil_mask(GLuint mask)
{
    ::glStencilMask(mask);
}

void GLFunctions::stencil_mask_separate(GLenum face, GLuint mask)
{
    ::glStencilMaskSeparate(face, mask);
}

void GLFunctions::stencil_op(GLenum fail, GLenum zfail, GLenum zpass)
{
    ::glStencilOp(fail, zfail, zpass);
}

void GLFunctions::stencil_op_separate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass)
{
    ::glStencilOpSeparate(face, sfail, dpfail, dppass);
}

void GLFunctions::tex_image2d_robust_angle(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, GLsizei bufSize, void const* pixels)
{
    ::glTexImage2DRobustANGLE(target, level, internalformat, width, height, border, format, type, bufSize, pixels);
}

void GLFunctions::tex_image3d_robust_angle(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, GLsizei bufSize, void const* pixels)
{
    ::glTexImage3DRobustANGLE(target, level, internalformat, width, height, depth, border, format, type, bufSize, pixels);
}

void GLFunctions::tex_parameterf(GLenum target, GLenum pname, GLfloat param)
{
    ::glTexParameterf(target, pname, param);
}

void GLFunctions::tex_parameteri(GLenum target, GLenum pname, GLint param)
{
    ::glTexParameteri(target, pname, param);
}

void GLFunctions::tex_storage2d(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height)
{
    ::glTexStorage2D(target, levels, internalformat, width, height);
}

void GLFunctions::tex_storage3d(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth)
{
    ::glTexStorage3D(target, levels, internalformat, width, height, depth);
}

void GLFunctions::tex_sub_image2d_robust_angle(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, void const* pixels)
{
    ::glTexSubImage2DRobustANGLE(target, level, xoffset, yoffset, width, height, format, type, bufSize, pixels);
}

void GLFunctions::tex_sub_image3d_robust_angle(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLsizei bufSize, void const* pixels)
{
    ::glTexSubImage3DRobustANGLE(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, bufSize, pixels);
}

void GLFunctions::transform_feedback_varyings(GLuint program, GLsizei count, GLchar const* const* varyings, GLenum bufferMode)
{
    ::glTransformFeedbackVaryings(program, count, varyings, bufferMode);
}

void GLFunctions::uniform1f(GLint location, GLfloat v0)
{
    ::glUniform1f(location, v0);
}

void GLFunctions::uniform1fv(GLint location, GLsizei count, GLfloat const* value)
{
    ::glUniform1fv(location, count, value);
}

void GLFunctions::uniform1i(GLint location, GLint v0)
{
    ::glUniform1i(location, v0);
}

void GLFunctions::uniform1iv(GLint location, GLsizei count, GLint const* value)
{
    ::glUniform1iv(location, count, value);
}

void GLFunctions::uniform1ui(GLint location, GLuint v0)
{
    ::glUniform1ui(location, v0);
}

void GLFunctions::uniform1uiv(GLint location, GLsizei count, GLuint const* value)
{
    ::glUniform1uiv(location, count, value);
}

void GLFunctions::uniform2f(GLint location, GLfloat v0, GLfloat v1)
{
    ::glUniform2f(location, v0, v1);
}

void GLFunctions::uniform2fv(GLint location, GLsizei count, GLfloat const* value)
{
    ::glUniform2fv(location, count, value);
}

void GLFunctions::uniform2i(GLint location, GLint v0, GLint v1)
{
    ::glUniform2i(location, v0, v1);
}

void GLFunctions::uniform2iv(GLint location, GLsizei count, GLint const* value)
{
    ::glUniform2iv(location, count, value);
}

void GLFunctions::uniform2ui(GLint location, GLuint v0, GLuint v1)
{
    ::glUniform2ui(location, v0, v1);
}

void GLFunctions::uniform2uiv(GLint location, GLsizei count, GLuint const* value)
{
    ::glUniform2uiv(location, count, value);
}

void GLFunctions::uniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
{
    ::glUniform3f(location, v0, v1, v2);
}

void GLFunctions::uniform3fv(GLint location, GLsizei count, GLfloat const* value)
{
    ::glUniform3fv(location, count, value);
}

void GLFunctions::uniform3i(GLint location, GLint v0, GLint v1, GLint v2)
{
    ::glUniform3i(location, v0, v1, v2);
}

void GLFunctions::uniform3iv(GLint location, GLsizei count, GLint const* value)
{
    ::glUniform3iv(location, count, value);
}

void GLFunctions::uniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2)
{
    ::glUniform3ui(location, v0, v1, v2);
}

void GLFunctions::uniform3uiv(GLint location, GLsizei count, GLuint const* value)
{
    ::glUniform3uiv(location, count, value);
}

void GLFunctions::uniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
{
    ::glUniform4f(location, v0, v1, v2, v3);
}

void GLFunctions::uniform4fv(GLint location, GLsizei count, GLfloat const* value)
{
    ::glUniform4fv(location, count, value);
}

void GLFunctions::uniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
{
    ::glUniform4i(location, v0, v1, v2, v3);
}

void GLFunctions::uniform4iv(GLint location, GLsizei count, GLint const* value)
{
    ::glUniform4iv(location, count, value);
}

void GLFunctions::uniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
{
    ::glUniform4ui(location, v0, v1, v2, v3);
}

void GLFunctions::uniform4uiv(GLint location, GLsizei count, GLuint const* value)
{
    ::glUniform4uiv(location, count, value);
}

void GLFunctions::uniform_block_binding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding)
{
    ::glUniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
}

void GLFunctions::uniform_matrix2fv(GLint location, GLsizei count, GLboolean transpose, GLfloat const* value)
{
    ::glUniformMatrix2fv(location, count, transpose, value);
}

void GLFunctions::uniform_matrix2x3fv(GLint location, GLsizei count, GLboolean transpose, GLfloat const* value)
{
    ::glUniformMatrix2x3fv(location, count, transpose, value);
}

void GLFunctions::uniform_matrix2x4fv(GLint location, GLsizei count, GLboolean transpose, GLfloat const* value)
{
    ::glUniformMatrix2x4fv(location, count, transpose, value);
}

void GLFunctions::uniform_matrix3fv(GLint location, GLsizei count, GLboolean transpose, GLfloat const* value)
{
    ::glUniformMatrix3fv(location, count, transpose, value);
}

void GLFunctions::uniform_matrix3x2fv(GLint location, GLsizei count, GLboolean transpose, GLfloat const* value)
{
    ::glUniformMatrix3x2fv(location, count, transpose, value);
}

void GLFunctions::uniform_matrix3x4fv(GLint location, GLsizei count, GLboolean transpose, GLfloat const* value)
{
    ::glUniformMatrix3x4fv(location, count, transpose, value);
}

void GLFunctions::uniform_matrix4fv(GLint location, GLsizei count, GLboolean transpose, GLfloat const* value)
{
    ::glUniformMatrix4fv(location, count, transpose, value);
}

void GLFunctions::uniform_matrix4x2fv(GLint location, GLsizei count, GLboolean transpose, GLfloat const* value)
{
    ::glUniformMatrix4x2fv(location, count, transpose, value);
}

void GLFunctions::uniform_matrix4x3fv(GLint location, GLsizei count, GLboolean transpose, GLfloat const* value)
{
    ::glUniformMatrix4x3fv(location, count, transpose, value);
}

GLboolean GLFunctions::unmap_buffer(GLenum target)
{
    return ::glUnmapBuffer(target);
}

void GLFunctions::use_program(GLuint program)
{
    ::glUseProgram(program);
}

void GLFunctions::validate_program(GLuint program)
{
    ::glValidateProgram(program);
}

void GLFunctions::vertex_attrib1f(GLuint index, GLfloat x)
{
    ::glVertexAttrib1f(index, x);
}

void GLFunctions::vertex_attrib1fv(GLuint index, GLfloat const* v)
{
    ::glVertexAttrib1fv(index, v);
}

void GLFunctions::vertex_attrib2f(GLuint index, GLfloat x, GLfloat y)
{
    ::glVertexAttrib2f(index, x, y);
}

void GLFunctions::vertex_attrib2fv(GLuint index, GLfloat const* v)
{
    ::glVertexAttrib2fv(index, v);
}

void GLFunctions::vertex_attrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z)
{
    ::glVertexAttrib3f(index, x, y, z);
}

void GLFunctions::vertex_attrib3fv(GLuint index, GLfloat const* v)
{
    ::glVertexAttrib3fv(index, v);
}

void GLFunctions::vertex_attrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
    ::glVertexAttrib4f(index, x, y, z, w);
}

void GLFunctions::vertex_attrib4fv(GLuint index, GLfloat const* v)
{
    ::glVertexAttrib4fv(index, v);
}

void GLFunctions::vertex_attrib_divisor(GLuint index, GLuint divisor)
{
    ::glVertexAttribDivisor(index, divisor);
}

void GLFunctions::vertex_attrib_divisor_angle(GLuint index, GLuint divisor)
{
    ::glVertexAttribDivisorANGLE(index, divisor);
}

void GLFunctions::vertex_attrib_i4i(GLuint index, GLint x, GLint y, GLint z, GLint w)
{
    ::glVertexAttribI4i(index, x, y, z, w);
}

void GLFunctions::vertex_attrib_i4iv(GLuint index, GLint const* v)
{
    ::glVertexAttribI4iv(index, v);
}

void GLFunctions::vertex_attrib_i4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
{
    ::glVertexAttribI4ui(index, x, y, z, w);
}

void GLFunctions::vertex_attrib_i4uiv(GLuint index, GLuint const* v)
{
    ::glVertexAttribI4uiv(index, v);
}

void GLFunctions::vertex_attrib_i_pointer(GLuint index, GLint size, GLenum type, GLsizei stride, void const* pointer)
{
    ::glVertexAttribIPointer(index, size, type, stride, pointer);
}

void GLFunctions::vertex_attrib_pointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, void const* pointer)
{
    ::glVertexAttribPointer(index, size, type, normalized, stride, pointer);
}

void GLFunctions::viewport(GLint x, GLint y, GLsizei width, GLsizei height)
{
    ::glViewport(x, y, width, height);
}

void GLFunctions::wait_sync(GLsync sync, GLbitfield flags, GLuint64 timeout)
{
    ::glWaitSync(sync, flags, timeout);
}

}