From 0b3fdd26c53c3da6606126999e0eb8451ff29b1f Mon Sep 17 00:00:00 2001 From: yulya3102 Date: Sat, 1 Feb 2025 08:03:34 +0100 Subject: [PATCH 1/8] Add necessary GLES fixes and missing JS functions --- libs/gfx/api/gles32/source/gl.cpp | 27 ++++++++++++++++++++++++++- package/CMakeLists.txt | 1 + 2 files changed, 27 insertions(+), 1 deletion(-) diff --git a/libs/gfx/api/gles32/source/gl.cpp b/libs/gfx/api/gles32/source/gl.cpp index 8d5f7cea..14269da1 100644 --- a/libs/gfx/api/gles32/source/gl.cpp +++ b/libs/gfx/api/gles32/source/gl.cpp @@ -803,10 +803,12 @@ namespace gl if (!internal::glGetQueryiv) return false; internal::glGetQueryObjectuiv = reinterpret_cast(internal::get_proc_address("glGetQueryObjectuiv")); if (!internal::glGetQueryObjectuiv) return false; +#if !defined(__EMSCRIPTEN__) internal::glUnmapBuffer = reinterpret_cast(internal::get_proc_address("glUnmapBuffer")); if (!internal::glUnmapBuffer) return false; internal::glGetBufferPointerv = reinterpret_cast(internal::get_proc_address("glGetBufferPointerv")); if (!internal::glGetBufferPointerv) return false; +#endif internal::glDrawBuffers = reinterpret_cast(internal::get_proc_address("glDrawBuffers")); if (!internal::glDrawBuffers) return false; internal::glUniformMatrix2x3fv = reinterpret_cast(internal::get_proc_address("glUniformMatrix2x3fv")); @@ -827,10 +829,12 @@ namespace gl if (!internal::glRenderbufferStorageMultisample) return false; internal::glFramebufferTextureLayer = reinterpret_cast(internal::get_proc_address("glFramebufferTextureLayer")); if (!internal::glFramebufferTextureLayer) return false; +#if !defined(__EMSCRIPTEN__) internal::glMapBufferRange = reinterpret_cast(internal::get_proc_address("glMapBufferRange")); if (!internal::glMapBufferRange) return false; internal::glFlushMappedBufferRange = reinterpret_cast(internal::get_proc_address("glFlushMappedBufferRange")); if (!internal::glFlushMappedBufferRange) return false; +#endif internal::glBindVertexArray = reinterpret_cast(internal::get_proc_address("glBindVertexArray")); if (!internal::glBindVertexArray) return false; internal::glDeleteVertexArrays = reinterpret_cast(internal::get_proc_address("glDeleteVertexArrays")); @@ -984,6 +988,10 @@ namespace gl internal::glGetInternalformativ = reinterpret_cast(internal::get_proc_address("glGetInternalformativ")); if (!internal::glGetInternalformativ) return false; +#if defined(__EMSCRIPTEN__) + return true; +#endif + // OpenGL ES 3.1 internal::glDispatchCompute = reinterpret_cast(internal::get_proc_address("glDispatchCompute")); @@ -1259,7 +1267,13 @@ namespace gl int major_version(){ return 3; } - int minor_version(){ return 2; } + int minor_version(){ +#if defined(__EMSCRIPTEN__) + return 0; +#else + return 2; +#endif + } bool has_extension(const char * name){ return extensions.contains(name); } @@ -1269,6 +1283,16 @@ namespace gl const char * shader_prefix() { +#if defined(__EMSCRIPTEN__) + return R"(#version 300 es + +precision highp int; +precision highp float; +precision highp sampler2D; +precision highp usampler2D; + +)"; +#else return R"(#version 320 es precision highp int; @@ -1277,6 +1301,7 @@ precision highp sampler2D; precision highp usampler2D; )"; +#endif } } // namespace sys diff --git a/package/CMakeLists.txt b/package/CMakeLists.txt index 862baf91..a76bf419 100644 --- a/package/CMakeLists.txt +++ b/package/CMakeLists.txt @@ -24,6 +24,7 @@ if(PSEMEK_PACKAGE_MODE) if(CMAKE_SYSTEM_NAME STREQUAL Emscripten) list(APPEND PSEMEK_PACKAGE_LINK_FLAGS_RAW "-sMIN_WEBGL_VERSION=2" "-sNO_DISABLE_EXCEPTION_CATCHING") + list(APPEND PSEMEK_PACKAGE_LINK_FLAGS_RAW "-sDEFAULT_LIBRARY_FUNCS_TO_INCLUDE='$autoResumeAudioContext','$dynCall'") if(CMAKE_BUILD_TYPE STREQUAL Debug) list(APPEND PSEMEK_PACKAGE_LINK_FLAGS_RAW "-g") endif() -- 2.45.3 From b2d34fd602dc023fba16c52d11bb4340e98651d5 Mon Sep 17 00:00:00 2001 From: yulya3102 Date: Sat, 1 Feb 2025 08:07:39 +0100 Subject: [PATCH 2/8] Disable GL context attributes on web --- libs/sdl2/source/window.cpp | 2 ++ 1 file changed, 2 insertions(+) diff --git a/libs/sdl2/source/window.cpp b/libs/sdl2/source/window.cpp index 7cda833f..7bb071ae 100644 --- a/libs/sdl2/source/window.cpp +++ b/libs/sdl2/source/window.cpp @@ -27,6 +27,7 @@ namespace psemek::sdl2 if (options.highdpi) flags |= SDL_WINDOW_ALLOW_HIGHDPI; #if defined(PSEMEK_GRAPHICS_API_OPENGL) +#if !defined(__EMSCRIPTEN__) SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE); SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, gl::sys::major_version()); SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, gl::sys::minor_version()); @@ -46,6 +47,7 @@ namespace psemek::sdl2 SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1); SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, options.multisampling); } +#endif flags |= SDL_WINDOW_OPENGL; #endif -- 2.45.3 From 1f1feaccf3e851cbbff3808d843643df52120e02 Mon Sep 17 00:00:00 2001 From: yulya3102 Date: Sat, 1 Feb 2025 07:18:08 +0100 Subject: [PATCH 3/8] Don't crash executable_path() on web --- libs/util/source/executable_path.cpp | 2 ++ 1 file changed, 2 insertions(+) diff --git a/libs/util/source/executable_path.cpp b/libs/util/source/executable_path.cpp index 3095fe52..a261eb83 100644 --- a/libs/util/source/executable_path.cpp +++ b/libs/util/source/executable_path.cpp @@ -39,6 +39,8 @@ namespace psemek::util std::string path(path_length, '\0'); _NSGetExecutablePath(path.data(), &path_length); return std::filesystem::path(std::move(path)); +#elif defined __EMSCRIPTEN__ + return std::filesystem::canonical(""); #else throw exception("executable_path() is not implemented for this platform"); #endif -- 2.45.3 From 8adb68630ee63c1bf615ada2907cd64e3e959ac4 Mon Sep 17 00:00:00 2001 From: lisyarus Date: Sat, 1 Feb 2025 07:16:58 +0100 Subject: [PATCH 4/8] Change mainloop for web builds --- libs/sdl2/source/main.cpp | 39 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 39 insertions(+) diff --git a/libs/sdl2/source/main.cpp b/libs/sdl2/source/main.cpp index 20d433b0..1307cf03 100644 --- a/libs/sdl2/source/main.cpp +++ b/libs/sdl2/source/main.cpp @@ -11,6 +11,18 @@ #include #include +#ifdef __EMSCRIPTEN__ + #include + #include + #include + + struct em_state + { + std::unique_ptr application; + std::unique_ptr window; + } em_state; +#endif + #undef main int main(int argc, char ** argv) try @@ -40,7 +52,12 @@ int main(int argc, char ** argv) try auto const factory = app::make_application_factory(); auto const options = factory->options(); +#ifdef __EMSCRIPTEN__ + em_state.window = std::make_unique(options); + auto & window = *em_state.window; +#else sdl2::window window(options); +#endif app::application::context context; for (int i = 0; i < argc; ++i) @@ -61,7 +78,13 @@ int main(int argc, char ** argv) try context.device = window.wgpu_device(); #endif + +#ifdef __EMSCRIPTEN__ + em_state.application = factory->create(options, context); + auto application = em_state.application.get(); +#else auto application = factory->create(options, context); +#endif if (!application) return EXIT_FAILURE; @@ -75,6 +98,21 @@ int main(int argc, char ** argv) try SDL_StopTextInput(); +#ifdef __EMSCRIPTEN__ + emscripten_request_animation_frame_loop([](double, void*) -> EM_BOOL { + if (sdl2::poll_events(*em_state.application)) + em_state.application->stop(); + + if (!em_state.application->running()) + return EM_FALSE; + + em_state.application->update(); + em_state.application->present(); + em_state.window->swap(); + + return EM_TRUE; + }, nullptr); +#else while (application->running()) { if (sdl2::poll_events(*application)) @@ -84,6 +122,7 @@ int main(int argc, char ** argv) try application->present(); window.swap(); } +#endif log::info() << "Quitting"; return EXIT_SUCCESS; -- 2.45.3 From 2407c1262e3be18111d0c8aab3a52b9be5808f7e Mon Sep 17 00:00:00 2001 From: yulya3102 Date: Fri, 3 Jul 2026 19:32:16 +0200 Subject: [PATCH 5/8] Add -sFULL_ES3 for web builds --- package/CMakeLists.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/package/CMakeLists.txt b/package/CMakeLists.txt index a76bf419..f7ca822a 100644 --- a/package/CMakeLists.txt +++ b/package/CMakeLists.txt @@ -23,7 +23,7 @@ if(PSEMEK_PACKAGE_MODE) set(PSEMEK_PACKAGE_LINK_FLAGS_RAW) if(CMAKE_SYSTEM_NAME STREQUAL Emscripten) - list(APPEND PSEMEK_PACKAGE_LINK_FLAGS_RAW "-sMIN_WEBGL_VERSION=2" "-sNO_DISABLE_EXCEPTION_CATCHING") + list(APPEND PSEMEK_PACKAGE_LINK_FLAGS_RAW "-sMIN_WEBGL_VERSION=2" "-sNO_DISABLE_EXCEPTION_CATCHING" "-sFULL_ES3") list(APPEND PSEMEK_PACKAGE_LINK_FLAGS_RAW "-sDEFAULT_LIBRARY_FUNCS_TO_INCLUDE='$autoResumeAudioContext','$dynCall'") if(CMAKE_BUILD_TYPE STREQUAL Debug) list(APPEND PSEMEK_PACKAGE_LINK_FLAGS_RAW "-g") -- 2.45.3 From bd70f197abc1f50c5970370f86a917d6882cbb3c Mon Sep 17 00:00:00 2001 From: yulya3102 Date: Fri, 3 Jul 2026 19:31:51 +0200 Subject: [PATCH 6/8] Use gles30-emscripten for web builds instead of gles32 --- CMakeLists.txt | 2 +- .../include/psemek/gfx/gl.hpp | 1311 +++++++++++++++++ libs/gfx/api/gles30-emscripten/source/gl.cpp | 902 ++++++++++++ libs/gfx/api/gles32/source/gl.cpp | 27 +- ...er-generator-config-gles30-emscripten.json | 19 + 5 files changed, 2234 insertions(+), 27 deletions(-) create mode 100644 libs/gfx/api/gles30-emscripten/include/psemek/gfx/gl.hpp create mode 100644 libs/gfx/api/gles30-emscripten/source/gl.cpp create mode 100644 libs/gfx/gl-loader-generator-config-gles30-emscripten.json diff --git a/CMakeLists.txt b/CMakeLists.txt index 906298fa..0c6f09c2 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -51,7 +51,7 @@ if(PSEMEK_BACKEND STREQUAL "ANDROID") set(PSEMEK_PACKAGE_AS_LIBRARY ON CACHE INTERNAL "Build applications as shared libraries") list(APPEND PSEMEK_CXX_FLAGS -fPIC) elseif(CMAKE_SYSTEM_NAME STREQUAL Emscripten) - set(PSEMEK_GL_API gles32) + set(PSEMEK_GL_API gles30-emscripten) set(PSEMEK_GL_LIBRARIES EGL) set(PSEMEK_PACKAGE_AS_LIBRARY OFF CACHE INTERNAL "Build applications as shared libraries") list(APPEND PSEMEK_DEFINITIONS "-DPSEMEK_GLES=1") diff --git a/libs/gfx/api/gles30-emscripten/include/psemek/gfx/gl.hpp b/libs/gfx/api/gles30-emscripten/include/psemek/gfx/gl.hpp new file mode 100644 index 00000000..08bf384e --- /dev/null +++ b/libs/gfx/api/gles30-emscripten/include/psemek/gfx/gl.hpp @@ -0,0 +1,1311 @@ +#pragma once + +// Prevent inclusion of other OpenGL-related headers + +#if defined(__glew_h__) || defined(__GLEW_H__) +#error Attempt to include auto-generated header after including glew.h +#endif +#if defined(__gl_h_) || defined(__GL_H__) +#error Attempt to include auto-generated header after including gl.h +#endif +#if defined(__glext_h_) || defined(__GLEXT_H_) +#error Attempt to include auto-generated header after including glext.h +#endif +#if defined(__gltypes_h_) +#error Attempt to include auto-generated header after gltypes.h +#endif +#if defined(__gl_ATI_h_) +#error Attempt to include auto-generated header after including glATI.h +#endif + +#define __glew_h__ +#define __GLEW_H__ +#define __gl_h_ +#define __GL_H__ +#define __glext_h_ +#define __GLEXT_H_ +#define __gltypes_h_ +#define __gl_ATI_h_ + +// Undefine some macros that may interfere with OpenGL ES constants + +#undef ZERO +#undef NONE +#undef TRUE +#undef ONE +#undef LOAD +#undef MULT +#undef ADD +#undef LESS +#undef BACK +#undef LEFT +#undef AUX0 +#undef AUX1 +#undef AUX2 +#undef AUX3 +#undef EXP +#undef EXP2 +#undef CW +#undef CCW +#undef FOG +#undef BYTE +#undef INT +#undef AND +#undef COPY +#undef NOOP +#undef XOR +#undef OR +#undef NOR +#undef NAND +#undef SET +#undef RED +#undef BLUE +#undef RGB +#undef RGBA +#undef LINE +#undef FILL +#undef FLAT +#undef KEEP +#undef INCR +#undef DECR +#undef S +#undef T +#undef R +#undef Q +#undef V2F +#undef V3F +#undef MIN +#undef MAX +#undef RGB4 +#undef RGB5 +#undef RGB8 +#undef BGR +#undef BGRA +#undef RG +#undef R8 +#undef R16 +#undef RG8 +#undef RG16 +#undef R16F +#undef R32F +#undef R8I +#undef R8UI +#undef R16I +#undef R32I +#undef RG8I +#undef BOOL +#undef SRGB +#undef TYPE + +// OpenGL ES type definitions + +#include +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; +typedef khronos_intptr_t GLintptr; +typedef khronos_intptr_t GLintptrARB; +typedef khronos_ssize_t GLsizeiptr; +typedef khronos_ssize_t GLsizeiptrARB; +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 (GLDEBUGPROC)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam); +typedef void (GLDEBUGPROCARB)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam); +typedef void (GLDEBUGPROCKHR)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam); +typedef void (GLDEBUGPROCAMD)(GLuint id,GLenum category,GLenum severity,GLsizei length,const GLchar *message,void *userParam); +typedef unsigned short GLhalfNV; +typedef GLintptr GLvdpauSurfaceNV; +typedef void (GLVULKANPROCNV)(void); + +namespace gl +{ + + namespace internal + { + + // OpenGL ES 2.0 + + extern void (*glActiveTexture)(GLenum texture); + extern void (*glAttachShader)(GLuint program, GLuint shader); + extern void (*glBindAttribLocation)(GLuint program, GLuint index, const GLchar *name); + extern void (*glBindBuffer)(GLenum target, GLuint buffer); + extern void (*glBindFramebuffer)(GLenum target, GLuint framebuffer); + extern void (*glBindRenderbuffer)(GLenum target, GLuint renderbuffer); + extern void (*glBindTexture)(GLenum target, GLuint texture); + extern void (*glBlendColor)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); + extern void (*glBlendEquation)(GLenum mode); + extern void (*glBlendEquationSeparate)(GLenum modeRGB, GLenum modeAlpha); + extern void (*glBlendFunc)(GLenum sfactor, GLenum dfactor); + extern void (*glBlendFuncSeparate)(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha); + extern void (*glBufferData)(GLenum target, GLsizeiptr size, const void *data, GLenum usage); + extern void (*glBufferSubData)(GLenum target, GLintptr offset, GLsizeiptr size, const void *data); + extern GLenum (*glCheckFramebufferStatus)(GLenum target); + extern void (*glClear)(GLbitfield mask); + extern void (*glClearColor)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); + extern void (*glClearDepthf)(GLfloat d); + extern void (*glClearStencil)(GLint s); + extern void (*glColorMask)(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); + extern void (*glCompileShader)(GLuint shader); + extern void (*glCompressedTexImage2D)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *data); + extern void (*glCompressedTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data); + extern void (*glCopyTexImage2D)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); + extern void (*glCopyTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); + extern GLuint (*glCreateProgram)(); + extern GLuint (*glCreateShader)(GLenum type); + extern void (*glCullFace)(GLenum mode); + extern void (*glDeleteBuffers)(GLsizei n, const GLuint *buffers); + extern void (*glDeleteFramebuffers)(GLsizei n, const GLuint *framebuffers); + extern void (*glDeleteProgram)(GLuint program); + extern void (*glDeleteRenderbuffers)(GLsizei n, const GLuint *renderbuffers); + extern void (*glDeleteShader)(GLuint shader); + extern void (*glDeleteTextures)(GLsizei n, const GLuint *textures); + extern void (*glDepthFunc)(GLenum func); + extern void (*glDepthMask)(GLboolean flag); + extern void (*glDepthRangef)(GLfloat n, GLfloat f); + extern void (*glDetachShader)(GLuint program, GLuint shader); + extern void (*glDisable)(GLenum cap); + extern void (*glDisableVertexAttribArray)(GLuint index); + extern void (*glDrawArrays)(GLenum mode, GLint first, GLsizei count); + extern void (*glDrawElements)(GLenum mode, GLsizei count, GLenum type, const void *indices); + extern void (*glEnable)(GLenum cap); + extern void (*glEnableVertexAttribArray)(GLuint index); + extern void (*glFinish)(); + extern void (*glFlush)(); + extern void (*glFramebufferRenderbuffer)(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); + extern void (*glFramebufferTexture2D)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); + extern void (*glFrontFace)(GLenum mode); + extern void (*glGenBuffers)(GLsizei n, GLuint *buffers); + extern void (*glGenerateMipmap)(GLenum target); + extern void (*glGenFramebuffers)(GLsizei n, GLuint *framebuffers); + extern void (*glGenRenderbuffers)(GLsizei n, GLuint *renderbuffers); + extern void (*glGenTextures)(GLsizei n, GLuint *textures); + extern void (*glGetActiveAttrib)(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name); + extern void (*glGetActiveUniform)(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name); + extern void (*glGetAttachedShaders)(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *shaders); + extern GLint (*glGetAttribLocation)(GLuint program, const GLchar *name); + extern void (*glGetBooleanv)(GLenum pname, GLboolean *data); + extern void (*glGetBufferParameteriv)(GLenum target, GLenum pname, GLint *params); + extern GLenum (*glGetError)(); + extern void (*glGetFloatv)(GLenum pname, GLfloat *data); + extern void (*glGetFramebufferAttachmentParameteriv)(GLenum target, GLenum attachment, GLenum pname, GLint *params); + extern void (*glGetIntegerv)(GLenum pname, GLint *data); + extern void (*glGetProgramiv)(GLuint program, GLenum pname, GLint *params); + extern void (*glGetProgramInfoLog)(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog); + extern void (*glGetRenderbufferParameteriv)(GLenum target, GLenum pname, GLint *params); + extern void (*glGetShaderiv)(GLuint shader, GLenum pname, GLint *params); + extern void (*glGetShaderInfoLog)(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog); + extern void (*glGetShaderPrecisionFormat)(GLenum shadertype, GLenum precisiontype, GLint *range, GLint *precision); + extern void (*glGetShaderSource)(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source); + extern const GLubyte *(*glGetString)(GLenum name); + extern void (*glGetTexParameterfv)(GLenum target, GLenum pname, GLfloat *params); + extern void (*glGetTexParameteriv)(GLenum target, GLenum pname, GLint *params); + extern void (*glGetUniformfv)(GLuint program, GLint location, GLfloat *params); + extern void (*glGetUniformiv)(GLuint program, GLint location, GLint *params); + extern GLint (*glGetUniformLocation)(GLuint program, const GLchar *name); + extern void (*glGetVertexAttribfv)(GLuint index, GLenum pname, GLfloat *params); + extern void (*glGetVertexAttribiv)(GLuint index, GLenum pname, GLint *params); + extern void (*glGetVertexAttribPointerv)(GLuint index, GLenum pname, void **pointer); + extern void (*glHint)(GLenum target, GLenum mode); + extern GLboolean (*glIsBuffer)(GLuint buffer); + extern GLboolean (*glIsEnabled)(GLenum cap); + extern GLboolean (*glIsFramebuffer)(GLuint framebuffer); + extern GLboolean (*glIsProgram)(GLuint program); + extern GLboolean (*glIsRenderbuffer)(GLuint renderbuffer); + extern GLboolean (*glIsShader)(GLuint shader); + extern GLboolean (*glIsTexture)(GLuint texture); + extern void (*glLineWidth)(GLfloat width); + extern void (*glLinkProgram)(GLuint program); + extern void (*glPixelStorei)(GLenum pname, GLint param); + extern void (*glPolygonOffset)(GLfloat factor, GLfloat units); + extern void (*glReadPixels)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *pixels); + extern void (*glReleaseShaderCompiler)(); + extern void (*glRenderbufferStorage)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height); + extern void (*glSampleCoverage)(GLfloat value, GLboolean invert); + extern void (*glScissor)(GLint x, GLint y, GLsizei width, GLsizei height); + extern void (*glShaderBinary)(GLsizei count, const GLuint *shaders, GLenum binaryFormat, const void *binary, GLsizei length); + extern void (*glShaderSource)(GLuint shader, GLsizei count, const GLchar *const*string, const GLint *length); + extern void (*glStencilFunc)(GLenum func, GLint ref, GLuint mask); + extern void (*glStencilFuncSeparate)(GLenum face, GLenum func, GLint ref, GLuint mask); + extern void (*glStencilMask)(GLuint mask); + extern void (*glStencilMaskSeparate)(GLenum face, GLuint mask); + extern void (*glStencilOp)(GLenum fail, GLenum zfail, GLenum zpass); + extern void (*glStencilOpSeparate)(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass); + extern void (*glTexImage2D)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels); + extern void (*glTexParameterf)(GLenum target, GLenum pname, GLfloat param); + extern void (*glTexParameterfv)(GLenum target, GLenum pname, const GLfloat *params); + extern void (*glTexParameteri)(GLenum target, GLenum pname, GLint param); + extern void (*glTexParameteriv)(GLenum target, GLenum pname, const GLint *params); + extern void (*glTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels); + extern void (*glUniform1f)(GLint location, GLfloat v0); + extern void (*glUniform1fv)(GLint location, GLsizei count, const GLfloat *value); + extern void (*glUniform1i)(GLint location, GLint v0); + extern void (*glUniform1iv)(GLint location, GLsizei count, const GLint *value); + extern void (*glUniform2f)(GLint location, GLfloat v0, GLfloat v1); + extern void (*glUniform2fv)(GLint location, GLsizei count, const GLfloat *value); + extern void (*glUniform2i)(GLint location, GLint v0, GLint v1); + extern void (*glUniform2iv)(GLint location, GLsizei count, const GLint *value); + extern void (*glUniform3f)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2); + extern void (*glUniform3fv)(GLint location, GLsizei count, const GLfloat *value); + extern void (*glUniform3i)(GLint location, GLint v0, GLint v1, GLint v2); + extern void (*glUniform3iv)(GLint location, GLsizei count, const GLint *value); + extern void (*glUniform4f)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); + extern void (*glUniform4fv)(GLint location, GLsizei count, const GLfloat *value); + extern void (*glUniform4i)(GLint location, GLint v0, GLint v1, GLint v2, GLint v3); + extern void (*glUniform4iv)(GLint location, GLsizei count, const GLint *value); + extern void (*glUniformMatrix2fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); + extern void (*glUniformMatrix3fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); + extern void (*glUniformMatrix4fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); + extern void (*glUseProgram)(GLuint program); + extern void (*glValidateProgram)(GLuint program); + extern void (*glVertexAttrib1f)(GLuint index, GLfloat x); + extern void (*glVertexAttrib1fv)(GLuint index, const GLfloat *v); + extern void (*glVertexAttrib2f)(GLuint index, GLfloat x, GLfloat y); + extern void (*glVertexAttrib2fv)(GLuint index, const GLfloat *v); + extern void (*glVertexAttrib3f)(GLuint index, GLfloat x, GLfloat y, GLfloat z); + extern void (*glVertexAttrib3fv)(GLuint index, const GLfloat *v); + extern void (*glVertexAttrib4f)(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); + extern void (*glVertexAttrib4fv)(GLuint index, const GLfloat *v); + extern void (*glVertexAttribPointer)(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer); + extern void (*glViewport)(GLint x, GLint y, GLsizei width, GLsizei height); + + // OpenGL ES 3.0 + + extern void (*glReadBuffer)(GLenum src); + extern void (*glDrawRangeElements)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices); + extern void (*glTexImage3D)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels); + extern void (*glTexSubImage3D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels); + extern void (*glCopyTexSubImage3D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); + extern void (*glCompressedTexImage3D)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *data); + extern void (*glCompressedTexSubImage3D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data); + extern void (*glGenQueries)(GLsizei n, GLuint *ids); + extern void (*glDeleteQueries)(GLsizei n, const GLuint *ids); + extern GLboolean (*glIsQuery)(GLuint id); + extern void (*glBeginQuery)(GLenum target, GLuint id); + extern void (*glEndQuery)(GLenum target); + extern void (*glGetQueryiv)(GLenum target, GLenum pname, GLint *params); + extern void (*glGetQueryObjectuiv)(GLuint id, GLenum pname, GLuint *params); + extern GLboolean (*glUnmapBuffer)(GLenum target); + extern void (*glGetBufferPointerv)(GLenum target, GLenum pname, void **params); + extern void (*glDrawBuffers)(GLsizei n, const GLenum *bufs); + extern void (*glUniformMatrix2x3fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); + extern void (*glUniformMatrix3x2fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); + extern void (*glUniformMatrix2x4fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); + extern void (*glUniformMatrix4x2fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); + extern void (*glUniformMatrix3x4fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); + extern void (*glUniformMatrix4x3fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); + extern void (*glBlitFramebuffer)(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter); + extern void (*glRenderbufferStorageMultisample)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height); + extern void (*glFramebufferTextureLayer)(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer); + extern void *(*glMapBufferRange)(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access); + extern void (*glFlushMappedBufferRange)(GLenum target, GLintptr offset, GLsizeiptr length); + extern void (*glBindVertexArray)(GLuint array); + extern void (*glDeleteVertexArrays)(GLsizei n, const GLuint *arrays); + extern void (*glGenVertexArrays)(GLsizei n, GLuint *arrays); + extern GLboolean (*glIsVertexArray)(GLuint array); + extern void (*glGetIntegeri_v)(GLenum target, GLuint index, GLint *data); + extern void (*glBeginTransformFeedback)(GLenum primitiveMode); + extern void (*glEndTransformFeedback)(); + extern void (*glBindBufferRange)(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size); + extern void (*glBindBufferBase)(GLenum target, GLuint index, GLuint buffer); + extern void (*glTransformFeedbackVaryings)(GLuint program, GLsizei count, const GLchar *const*varyings, GLenum bufferMode); + extern void (*glGetTransformFeedbackVarying)(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name); + extern void (*glVertexAttribIPointer)(GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer); + extern void (*glGetVertexAttribIiv)(GLuint index, GLenum pname, GLint *params); + extern void (*glGetVertexAttribIuiv)(GLuint index, GLenum pname, GLuint *params); + extern void (*glVertexAttribI4i)(GLuint index, GLint x, GLint y, GLint z, GLint w); + extern void (*glVertexAttribI4ui)(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w); + extern void (*glVertexAttribI4iv)(GLuint index, const GLint *v); + extern void (*glVertexAttribI4uiv)(GLuint index, const GLuint *v); + extern void (*glGetUniformuiv)(GLuint program, GLint location, GLuint *params); + extern GLint (*glGetFragDataLocation)(GLuint program, const GLchar *name); + extern void (*glUniform1ui)(GLint location, GLuint v0); + extern void (*glUniform2ui)(GLint location, GLuint v0, GLuint v1); + extern void (*glUniform3ui)(GLint location, GLuint v0, GLuint v1, GLuint v2); + extern void (*glUniform4ui)(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3); + extern void (*glUniform1uiv)(GLint location, GLsizei count, const GLuint *value); + extern void (*glUniform2uiv)(GLint location, GLsizei count, const GLuint *value); + extern void (*glUniform3uiv)(GLint location, GLsizei count, const GLuint *value); + extern void (*glUniform4uiv)(GLint location, GLsizei count, const GLuint *value); + extern void (*glClearBufferiv)(GLenum buffer, GLint drawbuffer, const GLint *value); + extern void (*glClearBufferuiv)(GLenum buffer, GLint drawbuffer, const GLuint *value); + extern void (*glClearBufferfv)(GLenum buffer, GLint drawbuffer, const GLfloat *value); + extern void (*glClearBufferfi)(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil); + extern const GLubyte *(*glGetStringi)(GLenum name, GLuint index); + extern void (*glCopyBufferSubData)(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size); + extern void (*glGetUniformIndices)(GLuint program, GLsizei uniformCount, const GLchar *const*uniformNames, GLuint *uniformIndices); + extern void (*glGetActiveUniformsiv)(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params); + extern GLuint (*glGetUniformBlockIndex)(GLuint program, const GLchar *uniformBlockName); + extern void (*glGetActiveUniformBlockiv)(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params); + extern void (*glGetActiveUniformBlockName)(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName); + extern void (*glUniformBlockBinding)(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding); + extern void (*glDrawArraysInstanced)(GLenum mode, GLint first, GLsizei count, GLsizei instancecount); + extern void (*glDrawElementsInstanced)(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount); + extern GLsync (*glFenceSync)(GLenum condition, GLbitfield flags); + extern GLboolean (*glIsSync)(GLsync sync); + extern void (*glDeleteSync)(GLsync sync); + extern GLenum (*glClientWaitSync)(GLsync sync, GLbitfield flags, GLuint64 timeout); + extern void (*glWaitSync)(GLsync sync, GLbitfield flags, GLuint64 timeout); + extern void (*glGetInteger64v)(GLenum pname, GLint64 *data); + extern void (*glGetSynciv)(GLsync sync, GLenum pname, GLsizei count, GLsizei *length, GLint *values); + extern void (*glGetInteger64i_v)(GLenum target, GLuint index, GLint64 *data); + extern void (*glGetBufferParameteri64v)(GLenum target, GLenum pname, GLint64 *params); + extern void (*glGenSamplers)(GLsizei count, GLuint *samplers); + extern void (*glDeleteSamplers)(GLsizei count, const GLuint *samplers); + extern GLboolean (*glIsSampler)(GLuint sampler); + extern void (*glBindSampler)(GLuint unit, GLuint sampler); + extern void (*glSamplerParameteri)(GLuint sampler, GLenum pname, GLint param); + extern void (*glSamplerParameteriv)(GLuint sampler, GLenum pname, const GLint *param); + extern void (*glSamplerParameterf)(GLuint sampler, GLenum pname, GLfloat param); + extern void (*glSamplerParameterfv)(GLuint sampler, GLenum pname, const GLfloat *param); + extern void (*glGetSamplerParameteriv)(GLuint sampler, GLenum pname, GLint *params); + extern void (*glGetSamplerParameterfv)(GLuint sampler, GLenum pname, GLfloat *params); + extern void (*glVertexAttribDivisor)(GLuint index, GLuint divisor); + extern void (*glBindTransformFeedback)(GLenum target, GLuint id); + extern void (*glDeleteTransformFeedbacks)(GLsizei n, const GLuint *ids); + extern void (*glGenTransformFeedbacks)(GLsizei n, GLuint *ids); + extern GLboolean (*glIsTransformFeedback)(GLuint id); + extern void (*glPauseTransformFeedback)(); + extern void (*glResumeTransformFeedback)(); + extern void (*glGetProgramBinary)(GLuint program, GLsizei bufSize, GLsizei *length, GLenum *binaryFormat, void *binary); + extern void (*glProgramBinary)(GLuint program, GLenum binaryFormat, const void *binary, GLsizei length); + extern void (*glProgramParameteri)(GLuint program, GLenum pname, GLint value); + extern void (*glInvalidateFramebuffer)(GLenum target, GLsizei numAttachments, const GLenum *attachments); + extern void (*glInvalidateSubFramebuffer)(GLenum target, GLsizei numAttachments, const GLenum *attachments, GLint x, GLint y, GLsizei width, GLsizei height); + extern void (*glTexStorage2D)(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height); + extern void (*glTexStorage3D)(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth); + extern void (*glGetInternalformativ)(GLenum target, GLenum internalformat, GLenum pname, GLsizei count, GLint *params); + + // GL_EXT_texture_filter_anisotropic + + + } // namespace internal + + // OpenGL ES 2.0 + + constexpr GLenum DEPTH_BUFFER_BIT = 0x00000100; + constexpr GLenum STENCIL_BUFFER_BIT = 0x00000400; + constexpr GLenum COLOR_BUFFER_BIT = 0x00004000; + constexpr GLenum FALSE = 0; + constexpr GLenum TRUE = 1; + constexpr GLenum POINTS = 0x0000; + constexpr GLenum LINES = 0x0001; + constexpr GLenum LINE_LOOP = 0x0002; + constexpr GLenum LINE_STRIP = 0x0003; + constexpr GLenum TRIANGLES = 0x0004; + constexpr GLenum TRIANGLE_STRIP = 0x0005; + constexpr GLenum TRIANGLE_FAN = 0x0006; + constexpr GLenum ZERO = 0; + constexpr GLenum ONE = 1; + constexpr GLenum SRC_COLOR = 0x0300; + constexpr GLenum ONE_MINUS_SRC_COLOR = 0x0301; + constexpr GLenum SRC_ALPHA = 0x0302; + constexpr GLenum ONE_MINUS_SRC_ALPHA = 0x0303; + constexpr GLenum DST_ALPHA = 0x0304; + constexpr GLenum ONE_MINUS_DST_ALPHA = 0x0305; + constexpr GLenum DST_COLOR = 0x0306; + constexpr GLenum ONE_MINUS_DST_COLOR = 0x0307; + constexpr GLenum SRC_ALPHA_SATURATE = 0x0308; + constexpr GLenum FUNC_ADD = 0x8006; + constexpr GLenum BLEND_EQUATION = 0x8009; + constexpr GLenum BLEND_EQUATION_RGB = 0x8009; + constexpr GLenum BLEND_EQUATION_ALPHA = 0x883D; + constexpr GLenum FUNC_SUBTRACT = 0x800A; + constexpr GLenum FUNC_REVERSE_SUBTRACT = 0x800B; + constexpr GLenum BLEND_DST_RGB = 0x80C8; + constexpr GLenum BLEND_SRC_RGB = 0x80C9; + constexpr GLenum BLEND_DST_ALPHA = 0x80CA; + constexpr GLenum BLEND_SRC_ALPHA = 0x80CB; + constexpr GLenum CONSTANT_COLOR = 0x8001; + constexpr GLenum ONE_MINUS_CONSTANT_COLOR = 0x8002; + constexpr GLenum CONSTANT_ALPHA = 0x8003; + constexpr GLenum ONE_MINUS_CONSTANT_ALPHA = 0x8004; + constexpr GLenum BLEND_COLOR = 0x8005; + constexpr GLenum ARRAY_BUFFER = 0x8892; + constexpr GLenum ELEMENT_ARRAY_BUFFER = 0x8893; + constexpr GLenum ARRAY_BUFFER_BINDING = 0x8894; + constexpr GLenum ELEMENT_ARRAY_BUFFER_BINDING = 0x8895; + constexpr GLenum STREAM_DRAW = 0x88E0; + constexpr GLenum STATIC_DRAW = 0x88E4; + constexpr GLenum DYNAMIC_DRAW = 0x88E8; + constexpr GLenum BUFFER_SIZE = 0x8764; + constexpr GLenum BUFFER_USAGE = 0x8765; + constexpr GLenum CURRENT_VERTEX_ATTRIB = 0x8626; + constexpr GLenum FRONT = 0x0404; + constexpr GLenum BACK = 0x0405; + constexpr GLenum FRONT_AND_BACK = 0x0408; + constexpr GLenum TEXTURE_2D = 0x0DE1; + constexpr GLenum CULL_FACE = 0x0B44; + constexpr GLenum BLEND = 0x0BE2; + constexpr GLenum DITHER = 0x0BD0; + constexpr GLenum STENCIL_TEST = 0x0B90; + constexpr GLenum DEPTH_TEST = 0x0B71; + constexpr GLenum SCISSOR_TEST = 0x0C11; + constexpr GLenum POLYGON_OFFSET_FILL = 0x8037; + constexpr GLenum SAMPLE_ALPHA_TO_COVERAGE = 0x809E; + constexpr GLenum SAMPLE_COVERAGE = 0x80A0; + constexpr GLenum NO_ERROR = 0; + constexpr GLenum INVALID_ENUM = 0x0500; + constexpr GLenum INVALID_VALUE = 0x0501; + constexpr GLenum INVALID_OPERATION = 0x0502; + constexpr GLenum OUT_OF_MEMORY = 0x0505; + constexpr GLenum CW = 0x0900; + constexpr GLenum CCW = 0x0901; + constexpr GLenum LINE_WIDTH = 0x0B21; + constexpr GLenum ALIASED_POINT_SIZE_RANGE = 0x846D; + constexpr GLenum ALIASED_LINE_WIDTH_RANGE = 0x846E; + constexpr GLenum CULL_FACE_MODE = 0x0B45; + constexpr GLenum FRONT_FACE = 0x0B46; + constexpr GLenum DEPTH_RANGE = 0x0B70; + constexpr GLenum DEPTH_WRITEMASK = 0x0B72; + constexpr GLenum DEPTH_CLEAR_VALUE = 0x0B73; + constexpr GLenum DEPTH_FUNC = 0x0B74; + constexpr GLenum STENCIL_CLEAR_VALUE = 0x0B91; + constexpr GLenum STENCIL_FUNC = 0x0B92; + constexpr GLenum STENCIL_FAIL = 0x0B94; + constexpr GLenum STENCIL_PASS_DEPTH_FAIL = 0x0B95; + constexpr GLenum STENCIL_PASS_DEPTH_PASS = 0x0B96; + constexpr GLenum STENCIL_REF = 0x0B97; + constexpr GLenum STENCIL_VALUE_MASK = 0x0B93; + constexpr GLenum STENCIL_WRITEMASK = 0x0B98; + constexpr GLenum STENCIL_BACK_FUNC = 0x8800; + constexpr GLenum STENCIL_BACK_FAIL = 0x8801; + constexpr GLenum STENCIL_BACK_PASS_DEPTH_FAIL = 0x8802; + constexpr GLenum STENCIL_BACK_PASS_DEPTH_PASS = 0x8803; + constexpr GLenum STENCIL_BACK_REF = 0x8CA3; + constexpr GLenum STENCIL_BACK_VALUE_MASK = 0x8CA4; + constexpr GLenum STENCIL_BACK_WRITEMASK = 0x8CA5; + constexpr GLenum VIEWPORT = 0x0BA2; + constexpr GLenum SCISSOR_BOX = 0x0C10; + constexpr GLenum COLOR_CLEAR_VALUE = 0x0C22; + constexpr GLenum COLOR_WRITEMASK = 0x0C23; + constexpr GLenum UNPACK_ALIGNMENT = 0x0CF5; + constexpr GLenum PACK_ALIGNMENT = 0x0D05; + constexpr GLenum MAX_TEXTURE_SIZE = 0x0D33; + constexpr GLenum MAX_VIEWPORT_DIMS = 0x0D3A; + constexpr GLenum SUBPIXEL_BITS = 0x0D50; + constexpr GLenum RED_BITS = 0x0D52; + constexpr GLenum GREEN_BITS = 0x0D53; + constexpr GLenum BLUE_BITS = 0x0D54; + constexpr GLenum ALPHA_BITS = 0x0D55; + constexpr GLenum DEPTH_BITS = 0x0D56; + constexpr GLenum STENCIL_BITS = 0x0D57; + constexpr GLenum POLYGON_OFFSET_UNITS = 0x2A00; + constexpr GLenum POLYGON_OFFSET_FACTOR = 0x8038; + constexpr GLenum TEXTURE_BINDING_2D = 0x8069; + constexpr GLenum SAMPLE_BUFFERS = 0x80A8; + constexpr GLenum SAMPLES = 0x80A9; + constexpr GLenum SAMPLE_COVERAGE_VALUE = 0x80AA; + constexpr GLenum SAMPLE_COVERAGE_INVERT = 0x80AB; + constexpr GLenum NUM_COMPRESSED_TEXTURE_FORMATS = 0x86A2; + constexpr GLenum COMPRESSED_TEXTURE_FORMATS = 0x86A3; + constexpr GLenum DONT_CARE = 0x1100; + constexpr GLenum FASTEST = 0x1101; + constexpr GLenum NICEST = 0x1102; + constexpr GLenum GENERATE_MIPMAP_HINT = 0x8192; + constexpr GLenum BYTE = 0x1400; + constexpr GLenum UNSIGNED_BYTE = 0x1401; + constexpr GLenum SHORT = 0x1402; + constexpr GLenum UNSIGNED_SHORT = 0x1403; + constexpr GLenum INT = 0x1404; + constexpr GLenum UNSIGNED_INT = 0x1405; + constexpr GLenum FLOAT = 0x1406; + constexpr GLenum FIXED = 0x140C; + constexpr GLenum DEPTH_COMPONENT = 0x1902; + constexpr GLenum ALPHA = 0x1906; + constexpr GLenum RGB = 0x1907; + constexpr GLenum RGBA = 0x1908; + constexpr GLenum LUMINANCE = 0x1909; + constexpr GLenum LUMINANCE_ALPHA = 0x190A; + constexpr GLenum UNSIGNED_SHORT_4_4_4_4 = 0x8033; + constexpr GLenum UNSIGNED_SHORT_5_5_5_1 = 0x8034; + constexpr GLenum UNSIGNED_SHORT_5_6_5 = 0x8363; + constexpr GLenum FRAGMENT_SHADER = 0x8B30; + constexpr GLenum VERTEX_SHADER = 0x8B31; + constexpr GLenum MAX_VERTEX_ATTRIBS = 0x8869; + constexpr GLenum MAX_VERTEX_UNIFORM_VECTORS = 0x8DFB; + constexpr GLenum MAX_VARYING_VECTORS = 0x8DFC; + constexpr GLenum MAX_COMBINED_TEXTURE_IMAGE_UNITS = 0x8B4D; + constexpr GLenum MAX_VERTEX_TEXTURE_IMAGE_UNITS = 0x8B4C; + constexpr GLenum MAX_TEXTURE_IMAGE_UNITS = 0x8872; + constexpr GLenum MAX_FRAGMENT_UNIFORM_VECTORS = 0x8DFD; + constexpr GLenum SHADER_TYPE = 0x8B4F; + constexpr GLenum DELETE_STATUS = 0x8B80; + constexpr GLenum LINK_STATUS = 0x8B82; + constexpr GLenum VALIDATE_STATUS = 0x8B83; + constexpr GLenum ATTACHED_SHADERS = 0x8B85; + constexpr GLenum ACTIVE_UNIFORMS = 0x8B86; + constexpr GLenum ACTIVE_UNIFORM_MAX_LENGTH = 0x8B87; + constexpr GLenum ACTIVE_ATTRIBUTES = 0x8B89; + constexpr GLenum ACTIVE_ATTRIBUTE_MAX_LENGTH = 0x8B8A; + constexpr GLenum SHADING_LANGUAGE_VERSION = 0x8B8C; + constexpr GLenum CURRENT_PROGRAM = 0x8B8D; + constexpr GLenum NEVER = 0x0200; + constexpr GLenum LESS = 0x0201; + constexpr GLenum EQUAL = 0x0202; + constexpr GLenum LEQUAL = 0x0203; + constexpr GLenum GREATER = 0x0204; + constexpr GLenum NOTEQUAL = 0x0205; + constexpr GLenum GEQUAL = 0x0206; + constexpr GLenum ALWAYS = 0x0207; + constexpr GLenum KEEP = 0x1E00; + constexpr GLenum REPLACE = 0x1E01; + constexpr GLenum INCR = 0x1E02; + constexpr GLenum DECR = 0x1E03; + constexpr GLenum INVERT = 0x150A; + constexpr GLenum INCR_WRAP = 0x8507; + constexpr GLenum DECR_WRAP = 0x8508; + constexpr GLenum VENDOR = 0x1F00; + constexpr GLenum RENDERER = 0x1F01; + constexpr GLenum VERSION = 0x1F02; + constexpr GLenum EXTENSIONS = 0x1F03; + constexpr GLenum NEAREST = 0x2600; + constexpr GLenum LINEAR = 0x2601; + constexpr GLenum NEAREST_MIPMAP_NEAREST = 0x2700; + constexpr GLenum LINEAR_MIPMAP_NEAREST = 0x2701; + constexpr GLenum NEAREST_MIPMAP_LINEAR = 0x2702; + constexpr GLenum LINEAR_MIPMAP_LINEAR = 0x2703; + constexpr GLenum TEXTURE_MAG_FILTER = 0x2800; + constexpr GLenum TEXTURE_MIN_FILTER = 0x2801; + constexpr GLenum TEXTURE_WRAP_S = 0x2802; + constexpr GLenum TEXTURE_WRAP_T = 0x2803; + constexpr GLenum TEXTURE = 0x1702; + constexpr GLenum TEXTURE_CUBE_MAP = 0x8513; + constexpr GLenum TEXTURE_BINDING_CUBE_MAP = 0x8514; + constexpr GLenum TEXTURE_CUBE_MAP_POSITIVE_X = 0x8515; + constexpr GLenum TEXTURE_CUBE_MAP_NEGATIVE_X = 0x8516; + constexpr GLenum TEXTURE_CUBE_MAP_POSITIVE_Y = 0x8517; + constexpr GLenum TEXTURE_CUBE_MAP_NEGATIVE_Y = 0x8518; + constexpr GLenum TEXTURE_CUBE_MAP_POSITIVE_Z = 0x8519; + constexpr GLenum TEXTURE_CUBE_MAP_NEGATIVE_Z = 0x851A; + constexpr GLenum MAX_CUBE_MAP_TEXTURE_SIZE = 0x851C; + constexpr GLenum TEXTURE0 = 0x84C0; + constexpr GLenum TEXTURE1 = 0x84C1; + constexpr GLenum TEXTURE2 = 0x84C2; + constexpr GLenum TEXTURE3 = 0x84C3; + constexpr GLenum TEXTURE4 = 0x84C4; + constexpr GLenum TEXTURE5 = 0x84C5; + constexpr GLenum TEXTURE6 = 0x84C6; + constexpr GLenum TEXTURE7 = 0x84C7; + constexpr GLenum TEXTURE8 = 0x84C8; + constexpr GLenum TEXTURE9 = 0x84C9; + constexpr GLenum TEXTURE10 = 0x84CA; + constexpr GLenum TEXTURE11 = 0x84CB; + constexpr GLenum TEXTURE12 = 0x84CC; + constexpr GLenum TEXTURE13 = 0x84CD; + constexpr GLenum TEXTURE14 = 0x84CE; + constexpr GLenum TEXTURE15 = 0x84CF; + constexpr GLenum TEXTURE16 = 0x84D0; + constexpr GLenum TEXTURE17 = 0x84D1; + constexpr GLenum TEXTURE18 = 0x84D2; + constexpr GLenum TEXTURE19 = 0x84D3; + constexpr GLenum TEXTURE20 = 0x84D4; + constexpr GLenum TEXTURE21 = 0x84D5; + constexpr GLenum TEXTURE22 = 0x84D6; + constexpr GLenum TEXTURE23 = 0x84D7; + constexpr GLenum TEXTURE24 = 0x84D8; + constexpr GLenum TEXTURE25 = 0x84D9; + constexpr GLenum TEXTURE26 = 0x84DA; + constexpr GLenum TEXTURE27 = 0x84DB; + constexpr GLenum TEXTURE28 = 0x84DC; + constexpr GLenum TEXTURE29 = 0x84DD; + constexpr GLenum TEXTURE30 = 0x84DE; + constexpr GLenum TEXTURE31 = 0x84DF; + constexpr GLenum ACTIVE_TEXTURE = 0x84E0; + constexpr GLenum REPEAT = 0x2901; + constexpr GLenum CLAMP_TO_EDGE = 0x812F; + constexpr GLenum MIRRORED_REPEAT = 0x8370; + constexpr GLenum FLOAT_VEC2 = 0x8B50; + constexpr GLenum FLOAT_VEC3 = 0x8B51; + constexpr GLenum FLOAT_VEC4 = 0x8B52; + constexpr GLenum INT_VEC2 = 0x8B53; + constexpr GLenum INT_VEC3 = 0x8B54; + constexpr GLenum INT_VEC4 = 0x8B55; + constexpr GLenum BOOL = 0x8B56; + constexpr GLenum BOOL_VEC2 = 0x8B57; + constexpr GLenum BOOL_VEC3 = 0x8B58; + constexpr GLenum BOOL_VEC4 = 0x8B59; + constexpr GLenum FLOAT_MAT2 = 0x8B5A; + constexpr GLenum FLOAT_MAT3 = 0x8B5B; + constexpr GLenum FLOAT_MAT4 = 0x8B5C; + constexpr GLenum SAMPLER_2D = 0x8B5E; + constexpr GLenum SAMPLER_CUBE = 0x8B60; + constexpr GLenum VERTEX_ATTRIB_ARRAY_ENABLED = 0x8622; + constexpr GLenum VERTEX_ATTRIB_ARRAY_SIZE = 0x8623; + constexpr GLenum VERTEX_ATTRIB_ARRAY_STRIDE = 0x8624; + constexpr GLenum VERTEX_ATTRIB_ARRAY_TYPE = 0x8625; + constexpr GLenum VERTEX_ATTRIB_ARRAY_NORMALIZED = 0x886A; + constexpr GLenum VERTEX_ATTRIB_ARRAY_POINTER = 0x8645; + constexpr GLenum VERTEX_ATTRIB_ARRAY_BUFFER_BINDING = 0x889F; + constexpr GLenum IMPLEMENTATION_COLOR_READ_TYPE = 0x8B9A; + constexpr GLenum IMPLEMENTATION_COLOR_READ_FORMAT = 0x8B9B; + constexpr GLenum COMPILE_STATUS = 0x8B81; + constexpr GLenum INFO_LOG_LENGTH = 0x8B84; + constexpr GLenum SHADER_SOURCE_LENGTH = 0x8B88; + constexpr GLenum SHADER_COMPILER = 0x8DFA; + constexpr GLenum SHADER_BINARY_FORMATS = 0x8DF8; + constexpr GLenum NUM_SHADER_BINARY_FORMATS = 0x8DF9; + constexpr GLenum LOW_FLOAT = 0x8DF0; + constexpr GLenum MEDIUM_FLOAT = 0x8DF1; + constexpr GLenum HIGH_FLOAT = 0x8DF2; + constexpr GLenum LOW_INT = 0x8DF3; + constexpr GLenum MEDIUM_INT = 0x8DF4; + constexpr GLenum HIGH_INT = 0x8DF5; + constexpr GLenum FRAMEBUFFER = 0x8D40; + constexpr GLenum RENDERBUFFER = 0x8D41; + constexpr GLenum RGBA4 = 0x8056; + constexpr GLenum RGB5_A1 = 0x8057; + constexpr GLenum RGB565 = 0x8D62; + constexpr GLenum DEPTH_COMPONENT16 = 0x81A5; + constexpr GLenum STENCIL_INDEX8 = 0x8D48; + constexpr GLenum RENDERBUFFER_WIDTH = 0x8D42; + constexpr GLenum RENDERBUFFER_HEIGHT = 0x8D43; + constexpr GLenum RENDERBUFFER_INTERNAL_FORMAT = 0x8D44; + constexpr GLenum RENDERBUFFER_RED_SIZE = 0x8D50; + constexpr GLenum RENDERBUFFER_GREEN_SIZE = 0x8D51; + constexpr GLenum RENDERBUFFER_BLUE_SIZE = 0x8D52; + constexpr GLenum RENDERBUFFER_ALPHA_SIZE = 0x8D53; + constexpr GLenum RENDERBUFFER_DEPTH_SIZE = 0x8D54; + constexpr GLenum RENDERBUFFER_STENCIL_SIZE = 0x8D55; + constexpr GLenum FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE = 0x8CD0; + constexpr GLenum FRAMEBUFFER_ATTACHMENT_OBJECT_NAME = 0x8CD1; + constexpr GLenum FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL = 0x8CD2; + constexpr GLenum FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE = 0x8CD3; + constexpr GLenum COLOR_ATTACHMENT0 = 0x8CE0; + constexpr GLenum DEPTH_ATTACHMENT = 0x8D00; + constexpr GLenum STENCIL_ATTACHMENT = 0x8D20; + constexpr GLenum NONE = 0; + constexpr GLenum FRAMEBUFFER_COMPLETE = 0x8CD5; + constexpr GLenum FRAMEBUFFER_INCOMPLETE_ATTACHMENT = 0x8CD6; + constexpr GLenum FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT = 0x8CD7; + constexpr GLenum FRAMEBUFFER_INCOMPLETE_DIMENSIONS = 0x8CD9; + constexpr GLenum FRAMEBUFFER_UNSUPPORTED = 0x8CDD; + constexpr GLenum FRAMEBUFFER_BINDING = 0x8CA6; + constexpr GLenum RENDERBUFFER_BINDING = 0x8CA7; + constexpr GLenum MAX_RENDERBUFFER_SIZE = 0x84E8; + constexpr GLenum INVALID_FRAMEBUFFER_OPERATION = 0x0506; + + inline void ActiveTexture(GLenum texture){ return internal::glActiveTexture(texture); } + inline void AttachShader(GLuint program, GLuint shader){ return internal::glAttachShader(program, shader); } + inline void BindAttribLocation(GLuint program, GLuint index, const GLchar *name){ return internal::glBindAttribLocation(program, index, name); } + inline void BindBuffer(GLenum target, GLuint buffer){ return internal::glBindBuffer(target, buffer); } + inline void BindFramebuffer(GLenum target, GLuint framebuffer){ return internal::glBindFramebuffer(target, framebuffer); } + inline void BindRenderbuffer(GLenum target, GLuint renderbuffer){ return internal::glBindRenderbuffer(target, renderbuffer); } + inline void BindTexture(GLenum target, GLuint texture){ return internal::glBindTexture(target, texture); } + inline void BlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha){ return internal::glBlendColor(red, green, blue, alpha); } + inline void BlendEquation(GLenum mode){ return internal::glBlendEquation(mode); } + inline void BlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha){ return internal::glBlendEquationSeparate(modeRGB, modeAlpha); } + inline void BlendFunc(GLenum sfactor, GLenum dfactor){ return internal::glBlendFunc(sfactor, dfactor); } + inline void BlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha){ return internal::glBlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha); } + inline void BufferData(GLenum target, GLsizeiptr size, const void *data, GLenum usage){ return internal::glBufferData(target, size, data, usage); } + inline void BufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void *data){ return internal::glBufferSubData(target, offset, size, data); } + inline GLenum CheckFramebufferStatus(GLenum target){ return internal::glCheckFramebufferStatus(target); } + inline void Clear(GLbitfield mask){ return internal::glClear(mask); } + inline void ClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha){ return internal::glClearColor(red, green, blue, alpha); } + inline void ClearDepthf(GLfloat d){ return internal::glClearDepthf(d); } + inline void ClearStencil(GLint s){ return internal::glClearStencil(s); } + inline void ColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha){ return internal::glColorMask(red, green, blue, alpha); } + inline void CompileShader(GLuint shader){ return internal::glCompileShader(shader); } + inline void CompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *data){ return internal::glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data); } + inline void CompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data){ return internal::glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data); } + inline void CopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border){ return internal::glCopyTexImage2D(target, level, internalformat, x, y, width, height, border); } + inline void CopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height){ return internal::glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height); } + inline GLuint CreateProgram(){ return internal::glCreateProgram(); } + inline GLuint CreateShader(GLenum type){ return internal::glCreateShader(type); } + inline void CullFace(GLenum mode){ return internal::glCullFace(mode); } + inline void DeleteBuffers(GLsizei n, const GLuint *buffers){ return internal::glDeleteBuffers(n, buffers); } + inline void DeleteFramebuffers(GLsizei n, const GLuint *framebuffers){ return internal::glDeleteFramebuffers(n, framebuffers); } + inline void DeleteProgram(GLuint program){ return internal::glDeleteProgram(program); } + inline void DeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers){ return internal::glDeleteRenderbuffers(n, renderbuffers); } + inline void DeleteShader(GLuint shader){ return internal::glDeleteShader(shader); } + inline void DeleteTextures(GLsizei n, const GLuint *textures){ return internal::glDeleteTextures(n, textures); } + inline void DepthFunc(GLenum func){ return internal::glDepthFunc(func); } + inline void DepthMask(GLboolean flag){ return internal::glDepthMask(flag); } + inline void DepthRangef(GLfloat n, GLfloat f){ return internal::glDepthRangef(n, f); } + inline void DetachShader(GLuint program, GLuint shader){ return internal::glDetachShader(program, shader); } + inline void Disable(GLenum cap){ return internal::glDisable(cap); } + inline void DisableVertexAttribArray(GLuint index){ return internal::glDisableVertexAttribArray(index); } + inline void DrawArrays(GLenum mode, GLint first, GLsizei count){ return internal::glDrawArrays(mode, first, count); } + inline void DrawElements(GLenum mode, GLsizei count, GLenum type, const void *indices){ return internal::glDrawElements(mode, count, type, indices); } + inline void Enable(GLenum cap){ return internal::glEnable(cap); } + inline void EnableVertexAttribArray(GLuint index){ return internal::glEnableVertexAttribArray(index); } + inline void Finish(){ return internal::glFinish(); } + inline void Flush(){ return internal::glFlush(); } + inline void FramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer){ return internal::glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer); } + inline void FramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level){ return internal::glFramebufferTexture2D(target, attachment, textarget, texture, level); } + inline void FrontFace(GLenum mode){ return internal::glFrontFace(mode); } + inline void GenBuffers(GLsizei n, GLuint *buffers){ return internal::glGenBuffers(n, buffers); } + inline void GenerateMipmap(GLenum target){ return internal::glGenerateMipmap(target); } + inline void GenFramebuffers(GLsizei n, GLuint *framebuffers){ return internal::glGenFramebuffers(n, framebuffers); } + inline void GenRenderbuffers(GLsizei n, GLuint *renderbuffers){ return internal::glGenRenderbuffers(n, renderbuffers); } + inline void GenTextures(GLsizei n, GLuint *textures){ return internal::glGenTextures(n, textures); } + inline void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name){ return internal::glGetActiveAttrib(program, index, bufSize, length, size, type, name); } + inline void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name){ return internal::glGetActiveUniform(program, index, bufSize, length, size, type, name); } + inline void GetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *shaders){ return internal::glGetAttachedShaders(program, maxCount, count, shaders); } + inline GLint GetAttribLocation(GLuint program, const GLchar *name){ return internal::glGetAttribLocation(program, name); } + inline void GetBooleanv(GLenum pname, GLboolean *data){ return internal::glGetBooleanv(pname, data); } + inline void GetBufferParameteriv(GLenum target, GLenum pname, GLint *params){ return internal::glGetBufferParameteriv(target, pname, params); } + inline GLenum GetError(){ return internal::glGetError(); } + inline void GetFloatv(GLenum pname, GLfloat *data){ return internal::glGetFloatv(pname, data); } + inline void GetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params){ return internal::glGetFramebufferAttachmentParameteriv(target, attachment, pname, params); } + inline void GetIntegerv(GLenum pname, GLint *data){ return internal::glGetIntegerv(pname, data); } + inline void GetProgramiv(GLuint program, GLenum pname, GLint *params){ return internal::glGetProgramiv(program, pname, params); } + inline void GetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog){ return internal::glGetProgramInfoLog(program, bufSize, length, infoLog); } + inline void GetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params){ return internal::glGetRenderbufferParameteriv(target, pname, params); } + inline void GetShaderiv(GLuint shader, GLenum pname, GLint *params){ return internal::glGetShaderiv(shader, pname, params); } + inline void GetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog){ return internal::glGetShaderInfoLog(shader, bufSize, length, infoLog); } + inline void GetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint *range, GLint *precision){ return internal::glGetShaderPrecisionFormat(shadertype, precisiontype, range, precision); } + inline void GetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source){ return internal::glGetShaderSource(shader, bufSize, length, source); } + inline const GLubyte *GetString(GLenum name){ return internal::glGetString(name); } + inline void GetTexParameterfv(GLenum target, GLenum pname, GLfloat *params){ return internal::glGetTexParameterfv(target, pname, params); } + inline void GetTexParameteriv(GLenum target, GLenum pname, GLint *params){ return internal::glGetTexParameteriv(target, pname, params); } + inline void GetUniformfv(GLuint program, GLint location, GLfloat *params){ return internal::glGetUniformfv(program, location, params); } + inline void GetUniformiv(GLuint program, GLint location, GLint *params){ return internal::glGetUniformiv(program, location, params); } + inline GLint GetUniformLocation(GLuint program, const GLchar *name){ return internal::glGetUniformLocation(program, name); } + inline void GetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params){ return internal::glGetVertexAttribfv(index, pname, params); } + inline void GetVertexAttribiv(GLuint index, GLenum pname, GLint *params){ return internal::glGetVertexAttribiv(index, pname, params); } + inline void GetVertexAttribPointerv(GLuint index, GLenum pname, void **pointer){ return internal::glGetVertexAttribPointerv(index, pname, pointer); } + inline void Hint(GLenum target, GLenum mode){ return internal::glHint(target, mode); } + inline GLboolean IsBuffer(GLuint buffer){ return internal::glIsBuffer(buffer); } + inline GLboolean IsEnabled(GLenum cap){ return internal::glIsEnabled(cap); } + inline GLboolean IsFramebuffer(GLuint framebuffer){ return internal::glIsFramebuffer(framebuffer); } + inline GLboolean IsProgram(GLuint program){ return internal::glIsProgram(program); } + inline GLboolean IsRenderbuffer(GLuint renderbuffer){ return internal::glIsRenderbuffer(renderbuffer); } + inline GLboolean IsShader(GLuint shader){ return internal::glIsShader(shader); } + inline GLboolean IsTexture(GLuint texture){ return internal::glIsTexture(texture); } + inline void LineWidth(GLfloat width){ return internal::glLineWidth(width); } + inline void LinkProgram(GLuint program){ return internal::glLinkProgram(program); } + inline void PixelStorei(GLenum pname, GLint param){ return internal::glPixelStorei(pname, param); } + inline void PolygonOffset(GLfloat factor, GLfloat units){ return internal::glPolygonOffset(factor, units); } + inline void ReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *pixels){ return internal::glReadPixels(x, y, width, height, format, type, pixels); } + inline void ReleaseShaderCompiler(){ return internal::glReleaseShaderCompiler(); } + inline void RenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height){ return internal::glRenderbufferStorage(target, internalformat, width, height); } + inline void SampleCoverage(GLfloat value, GLboolean invert){ return internal::glSampleCoverage(value, invert); } + inline void Scissor(GLint x, GLint y, GLsizei width, GLsizei height){ return internal::glScissor(x, y, width, height); } + inline void ShaderBinary(GLsizei count, const GLuint *shaders, GLenum binaryFormat, const void *binary, GLsizei length){ return internal::glShaderBinary(count, shaders, binaryFormat, binary, length); } + inline void ShaderSource(GLuint shader, GLsizei count, const GLchar *const*string, const GLint *length){ return internal::glShaderSource(shader, count, string, length); } + inline void StencilFunc(GLenum func, GLint ref, GLuint mask){ return internal::glStencilFunc(func, ref, mask); } + inline void StencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask){ return internal::glStencilFuncSeparate(face, func, ref, mask); } + inline void StencilMask(GLuint mask){ return internal::glStencilMask(mask); } + inline void StencilMaskSeparate(GLenum face, GLuint mask){ return internal::glStencilMaskSeparate(face, mask); } + inline void StencilOp(GLenum fail, GLenum zfail, GLenum zpass){ return internal::glStencilOp(fail, zfail, zpass); } + inline void StencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass){ return internal::glStencilOpSeparate(face, sfail, dpfail, dppass); } + inline void TexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels){ return internal::glTexImage2D(target, level, internalformat, width, height, border, format, type, pixels); } + inline void TexParameterf(GLenum target, GLenum pname, GLfloat param){ return internal::glTexParameterf(target, pname, param); } + inline void TexParameterfv(GLenum target, GLenum pname, const GLfloat *params){ return internal::glTexParameterfv(target, pname, params); } + inline void TexParameteri(GLenum target, GLenum pname, GLint param){ return internal::glTexParameteri(target, pname, param); } + inline void TexParameteriv(GLenum target, GLenum pname, const GLint *params){ return internal::glTexParameteriv(target, pname, params); } + inline void TexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels){ return internal::glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels); } + inline void Uniform1f(GLint location, GLfloat v0){ return internal::glUniform1f(location, v0); } + inline void Uniform1fv(GLint location, GLsizei count, const GLfloat *value){ return internal::glUniform1fv(location, count, value); } + inline void Uniform1i(GLint location, GLint v0){ return internal::glUniform1i(location, v0); } + inline void Uniform1iv(GLint location, GLsizei count, const GLint *value){ return internal::glUniform1iv(location, count, value); } + inline void Uniform2f(GLint location, GLfloat v0, GLfloat v1){ return internal::glUniform2f(location, v0, v1); } + inline void Uniform2fv(GLint location, GLsizei count, const GLfloat *value){ return internal::glUniform2fv(location, count, value); } + inline void Uniform2i(GLint location, GLint v0, GLint v1){ return internal::glUniform2i(location, v0, v1); } + inline void Uniform2iv(GLint location, GLsizei count, const GLint *value){ return internal::glUniform2iv(location, count, value); } + inline void Uniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2){ return internal::glUniform3f(location, v0, v1, v2); } + inline void Uniform3fv(GLint location, GLsizei count, const GLfloat *value){ return internal::glUniform3fv(location, count, value); } + inline void Uniform3i(GLint location, GLint v0, GLint v1, GLint v2){ return internal::glUniform3i(location, v0, v1, v2); } + inline void Uniform3iv(GLint location, GLsizei count, const GLint *value){ return internal::glUniform3iv(location, count, value); } + inline void Uniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3){ return internal::glUniform4f(location, v0, v1, v2, v3); } + inline void Uniform4fv(GLint location, GLsizei count, const GLfloat *value){ return internal::glUniform4fv(location, count, value); } + inline void Uniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3){ return internal::glUniform4i(location, v0, v1, v2, v3); } + inline void Uniform4iv(GLint location, GLsizei count, const GLint *value){ return internal::glUniform4iv(location, count, value); } + inline void UniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value){ return internal::glUniformMatrix2fv(location, count, transpose, value); } + inline void UniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value){ return internal::glUniformMatrix3fv(location, count, transpose, value); } + inline void UniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value){ return internal::glUniformMatrix4fv(location, count, transpose, value); } + inline void UseProgram(GLuint program){ return internal::glUseProgram(program); } + inline void ValidateProgram(GLuint program){ return internal::glValidateProgram(program); } + inline void VertexAttrib1f(GLuint index, GLfloat x){ return internal::glVertexAttrib1f(index, x); } + inline void VertexAttrib1fv(GLuint index, const GLfloat *v){ return internal::glVertexAttrib1fv(index, v); } + inline void VertexAttrib2f(GLuint index, GLfloat x, GLfloat y){ return internal::glVertexAttrib2f(index, x, y); } + inline void VertexAttrib2fv(GLuint index, const GLfloat *v){ return internal::glVertexAttrib2fv(index, v); } + inline void VertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z){ return internal::glVertexAttrib3f(index, x, y, z); } + inline void VertexAttrib3fv(GLuint index, const GLfloat *v){ return internal::glVertexAttrib3fv(index, v); } + inline void VertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w){ return internal::glVertexAttrib4f(index, x, y, z, w); } + inline void VertexAttrib4fv(GLuint index, const GLfloat *v){ return internal::glVertexAttrib4fv(index, v); } + inline void VertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer){ return internal::glVertexAttribPointer(index, size, type, normalized, stride, pointer); } + inline void Viewport(GLint x, GLint y, GLsizei width, GLsizei height){ return internal::glViewport(x, y, width, height); } + + // OpenGL ES 3.0 + + constexpr GLenum READ_BUFFER = 0x0C02; + constexpr GLenum UNPACK_ROW_LENGTH = 0x0CF2; + constexpr GLenum UNPACK_SKIP_ROWS = 0x0CF3; + constexpr GLenum UNPACK_SKIP_PIXELS = 0x0CF4; + constexpr GLenum PACK_ROW_LENGTH = 0x0D02; + constexpr GLenum PACK_SKIP_ROWS = 0x0D03; + constexpr GLenum PACK_SKIP_PIXELS = 0x0D04; + constexpr GLenum COLOR = 0x1800; + constexpr GLenum DEPTH = 0x1801; + constexpr GLenum STENCIL = 0x1802; + constexpr GLenum RED = 0x1903; + constexpr GLenum RGB8 = 0x8051; + constexpr GLenum RGBA8 = 0x8058; + constexpr GLenum RGB10_A2 = 0x8059; + constexpr GLenum TEXTURE_BINDING_3D = 0x806A; + constexpr GLenum UNPACK_SKIP_IMAGES = 0x806D; + constexpr GLenum UNPACK_IMAGE_HEIGHT = 0x806E; + constexpr GLenum TEXTURE_3D = 0x806F; + constexpr GLenum TEXTURE_WRAP_R = 0x8072; + constexpr GLenum MAX_3D_TEXTURE_SIZE = 0x8073; + constexpr GLenum UNSIGNED_INT_2_10_10_10_REV = 0x8368; + constexpr GLenum MAX_ELEMENTS_VERTICES = 0x80E8; + constexpr GLenum MAX_ELEMENTS_INDICES = 0x80E9; + constexpr GLenum TEXTURE_MIN_LOD = 0x813A; + constexpr GLenum TEXTURE_MAX_LOD = 0x813B; + constexpr GLenum TEXTURE_BASE_LEVEL = 0x813C; + constexpr GLenum TEXTURE_MAX_LEVEL = 0x813D; + constexpr GLenum MIN = 0x8007; + constexpr GLenum MAX = 0x8008; + constexpr GLenum DEPTH_COMPONENT24 = 0x81A6; + constexpr GLenum MAX_TEXTURE_LOD_BIAS = 0x84FD; + constexpr GLenum TEXTURE_COMPARE_MODE = 0x884C; + constexpr GLenum TEXTURE_COMPARE_FUNC = 0x884D; + constexpr GLenum CURRENT_QUERY = 0x8865; + constexpr GLenum QUERY_RESULT = 0x8866; + constexpr GLenum QUERY_RESULT_AVAILABLE = 0x8867; + constexpr GLenum BUFFER_MAPPED = 0x88BC; + constexpr GLenum BUFFER_MAP_POINTER = 0x88BD; + constexpr GLenum STREAM_READ = 0x88E1; + constexpr GLenum STREAM_COPY = 0x88E2; + constexpr GLenum STATIC_READ = 0x88E5; + constexpr GLenum STATIC_COPY = 0x88E6; + constexpr GLenum DYNAMIC_READ = 0x88E9; + constexpr GLenum DYNAMIC_COPY = 0x88EA; + constexpr GLenum MAX_DRAW_BUFFERS = 0x8824; + constexpr GLenum DRAW_BUFFER0 = 0x8825; + constexpr GLenum DRAW_BUFFER1 = 0x8826; + constexpr GLenum DRAW_BUFFER2 = 0x8827; + constexpr GLenum DRAW_BUFFER3 = 0x8828; + constexpr GLenum DRAW_BUFFER4 = 0x8829; + constexpr GLenum DRAW_BUFFER5 = 0x882A; + constexpr GLenum DRAW_BUFFER6 = 0x882B; + constexpr GLenum DRAW_BUFFER7 = 0x882C; + constexpr GLenum DRAW_BUFFER8 = 0x882D; + constexpr GLenum DRAW_BUFFER9 = 0x882E; + constexpr GLenum DRAW_BUFFER10 = 0x882F; + constexpr GLenum DRAW_BUFFER11 = 0x8830; + constexpr GLenum DRAW_BUFFER12 = 0x8831; + constexpr GLenum DRAW_BUFFER13 = 0x8832; + constexpr GLenum DRAW_BUFFER14 = 0x8833; + constexpr GLenum DRAW_BUFFER15 = 0x8834; + constexpr GLenum MAX_FRAGMENT_UNIFORM_COMPONENTS = 0x8B49; + constexpr GLenum MAX_VERTEX_UNIFORM_COMPONENTS = 0x8B4A; + constexpr GLenum SAMPLER_3D = 0x8B5F; + constexpr GLenum SAMPLER_2D_SHADOW = 0x8B62; + constexpr GLenum FRAGMENT_SHADER_DERIVATIVE_HINT = 0x8B8B; + constexpr GLenum PIXEL_PACK_BUFFER = 0x88EB; + constexpr GLenum PIXEL_UNPACK_BUFFER = 0x88EC; + constexpr GLenum PIXEL_PACK_BUFFER_BINDING = 0x88ED; + constexpr GLenum PIXEL_UNPACK_BUFFER_BINDING = 0x88EF; + constexpr GLenum FLOAT_MAT2x3 = 0x8B65; + constexpr GLenum FLOAT_MAT2x4 = 0x8B66; + constexpr GLenum FLOAT_MAT3x2 = 0x8B67; + constexpr GLenum FLOAT_MAT3x4 = 0x8B68; + constexpr GLenum FLOAT_MAT4x2 = 0x8B69; + constexpr GLenum FLOAT_MAT4x3 = 0x8B6A; + constexpr GLenum SRGB = 0x8C40; + constexpr GLenum SRGB8 = 0x8C41; + constexpr GLenum SRGB8_ALPHA8 = 0x8C43; + constexpr GLenum COMPARE_REF_TO_TEXTURE = 0x884E; + constexpr GLenum MAJOR_VERSION = 0x821B; + constexpr GLenum MINOR_VERSION = 0x821C; + constexpr GLenum NUM_EXTENSIONS = 0x821D; + constexpr GLenum RGBA32F = 0x8814; + constexpr GLenum RGB32F = 0x8815; + constexpr GLenum RGBA16F = 0x881A; + constexpr GLenum RGB16F = 0x881B; + constexpr GLenum VERTEX_ATTRIB_ARRAY_INTEGER = 0x88FD; + constexpr GLenum MAX_ARRAY_TEXTURE_LAYERS = 0x88FF; + constexpr GLenum MIN_PROGRAM_TEXEL_OFFSET = 0x8904; + constexpr GLenum MAX_PROGRAM_TEXEL_OFFSET = 0x8905; + constexpr GLenum MAX_VARYING_COMPONENTS = 0x8B4B; + constexpr GLenum TEXTURE_2D_ARRAY = 0x8C1A; + constexpr GLenum TEXTURE_BINDING_2D_ARRAY = 0x8C1D; + constexpr GLenum R11F_G11F_B10F = 0x8C3A; + constexpr GLenum UNSIGNED_INT_10F_11F_11F_REV = 0x8C3B; + constexpr GLenum RGB9_E5 = 0x8C3D; + constexpr GLenum UNSIGNED_INT_5_9_9_9_REV = 0x8C3E; + constexpr GLenum TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH = 0x8C76; + constexpr GLenum TRANSFORM_FEEDBACK_BUFFER_MODE = 0x8C7F; + constexpr GLenum MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS = 0x8C80; + constexpr GLenum TRANSFORM_FEEDBACK_VARYINGS = 0x8C83; + constexpr GLenum TRANSFORM_FEEDBACK_BUFFER_START = 0x8C84; + constexpr GLenum TRANSFORM_FEEDBACK_BUFFER_SIZE = 0x8C85; + constexpr GLenum TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN = 0x8C88; + constexpr GLenum RASTERIZER_DISCARD = 0x8C89; + constexpr GLenum MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS = 0x8C8A; + constexpr GLenum MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS = 0x8C8B; + constexpr GLenum INTERLEAVED_ATTRIBS = 0x8C8C; + constexpr GLenum SEPARATE_ATTRIBS = 0x8C8D; + constexpr GLenum TRANSFORM_FEEDBACK_BUFFER = 0x8C8E; + constexpr GLenum TRANSFORM_FEEDBACK_BUFFER_BINDING = 0x8C8F; + constexpr GLenum RGBA32UI = 0x8D70; + constexpr GLenum RGB32UI = 0x8D71; + constexpr GLenum RGBA16UI = 0x8D76; + constexpr GLenum RGB16UI = 0x8D77; + constexpr GLenum RGBA8UI = 0x8D7C; + constexpr GLenum RGB8UI = 0x8D7D; + constexpr GLenum RGBA32I = 0x8D82; + constexpr GLenum RGB32I = 0x8D83; + constexpr GLenum RGBA16I = 0x8D88; + constexpr GLenum RGB16I = 0x8D89; + constexpr GLenum RGBA8I = 0x8D8E; + constexpr GLenum RGB8I = 0x8D8F; + constexpr GLenum RED_INTEGER = 0x8D94; + constexpr GLenum RGB_INTEGER = 0x8D98; + constexpr GLenum RGBA_INTEGER = 0x8D99; + constexpr GLenum SAMPLER_2D_ARRAY = 0x8DC1; + constexpr GLenum SAMPLER_2D_ARRAY_SHADOW = 0x8DC4; + constexpr GLenum SAMPLER_CUBE_SHADOW = 0x8DC5; + constexpr GLenum UNSIGNED_INT_VEC2 = 0x8DC6; + constexpr GLenum UNSIGNED_INT_VEC3 = 0x8DC7; + constexpr GLenum UNSIGNED_INT_VEC4 = 0x8DC8; + constexpr GLenum INT_SAMPLER_2D = 0x8DCA; + constexpr GLenum INT_SAMPLER_3D = 0x8DCB; + constexpr GLenum INT_SAMPLER_CUBE = 0x8DCC; + constexpr GLenum INT_SAMPLER_2D_ARRAY = 0x8DCF; + constexpr GLenum UNSIGNED_INT_SAMPLER_2D = 0x8DD2; + constexpr GLenum UNSIGNED_INT_SAMPLER_3D = 0x8DD3; + constexpr GLenum UNSIGNED_INT_SAMPLER_CUBE = 0x8DD4; + constexpr GLenum UNSIGNED_INT_SAMPLER_2D_ARRAY = 0x8DD7; + constexpr GLenum BUFFER_ACCESS_FLAGS = 0x911F; + constexpr GLenum BUFFER_MAP_LENGTH = 0x9120; + constexpr GLenum BUFFER_MAP_OFFSET = 0x9121; + constexpr GLenum DEPTH_COMPONENT32F = 0x8CAC; + constexpr GLenum DEPTH32F_STENCIL8 = 0x8CAD; + constexpr GLenum FLOAT_32_UNSIGNED_INT_24_8_REV = 0x8DAD; + constexpr GLenum FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING = 0x8210; + constexpr GLenum FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE = 0x8211; + constexpr GLenum FRAMEBUFFER_ATTACHMENT_RED_SIZE = 0x8212; + constexpr GLenum FRAMEBUFFER_ATTACHMENT_GREEN_SIZE = 0x8213; + constexpr GLenum FRAMEBUFFER_ATTACHMENT_BLUE_SIZE = 0x8214; + constexpr GLenum FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE = 0x8215; + constexpr GLenum FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE = 0x8216; + constexpr GLenum FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE = 0x8217; + constexpr GLenum FRAMEBUFFER_DEFAULT = 0x8218; + constexpr GLenum FRAMEBUFFER_UNDEFINED = 0x8219; + constexpr GLenum DEPTH_STENCIL_ATTACHMENT = 0x821A; + constexpr GLenum DEPTH_STENCIL = 0x84F9; + constexpr GLenum UNSIGNED_INT_24_8 = 0x84FA; + constexpr GLenum DEPTH24_STENCIL8 = 0x88F0; + constexpr GLenum UNSIGNED_NORMALIZED = 0x8C17; + constexpr GLenum DRAW_FRAMEBUFFER_BINDING = 0x8CA6; + constexpr GLenum READ_FRAMEBUFFER = 0x8CA8; + constexpr GLenum DRAW_FRAMEBUFFER = 0x8CA9; + constexpr GLenum READ_FRAMEBUFFER_BINDING = 0x8CAA; + constexpr GLenum RENDERBUFFER_SAMPLES = 0x8CAB; + constexpr GLenum FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER = 0x8CD4; + constexpr GLenum MAX_COLOR_ATTACHMENTS = 0x8CDF; + constexpr GLenum COLOR_ATTACHMENT1 = 0x8CE1; + constexpr GLenum COLOR_ATTACHMENT2 = 0x8CE2; + constexpr GLenum COLOR_ATTACHMENT3 = 0x8CE3; + constexpr GLenum COLOR_ATTACHMENT4 = 0x8CE4; + constexpr GLenum COLOR_ATTACHMENT5 = 0x8CE5; + constexpr GLenum COLOR_ATTACHMENT6 = 0x8CE6; + constexpr GLenum COLOR_ATTACHMENT7 = 0x8CE7; + constexpr GLenum COLOR_ATTACHMENT8 = 0x8CE8; + constexpr GLenum COLOR_ATTACHMENT9 = 0x8CE9; + constexpr GLenum COLOR_ATTACHMENT10 = 0x8CEA; + constexpr GLenum COLOR_ATTACHMENT11 = 0x8CEB; + constexpr GLenum COLOR_ATTACHMENT12 = 0x8CEC; + constexpr GLenum COLOR_ATTACHMENT13 = 0x8CED; + constexpr GLenum COLOR_ATTACHMENT14 = 0x8CEE; + constexpr GLenum COLOR_ATTACHMENT15 = 0x8CEF; + constexpr GLenum COLOR_ATTACHMENT16 = 0x8CF0; + constexpr GLenum COLOR_ATTACHMENT17 = 0x8CF1; + constexpr GLenum COLOR_ATTACHMENT18 = 0x8CF2; + constexpr GLenum COLOR_ATTACHMENT19 = 0x8CF3; + constexpr GLenum COLOR_ATTACHMENT20 = 0x8CF4; + constexpr GLenum COLOR_ATTACHMENT21 = 0x8CF5; + constexpr GLenum COLOR_ATTACHMENT22 = 0x8CF6; + constexpr GLenum COLOR_ATTACHMENT23 = 0x8CF7; + constexpr GLenum COLOR_ATTACHMENT24 = 0x8CF8; + constexpr GLenum COLOR_ATTACHMENT25 = 0x8CF9; + constexpr GLenum COLOR_ATTACHMENT26 = 0x8CFA; + constexpr GLenum COLOR_ATTACHMENT27 = 0x8CFB; + constexpr GLenum COLOR_ATTACHMENT28 = 0x8CFC; + constexpr GLenum COLOR_ATTACHMENT29 = 0x8CFD; + constexpr GLenum COLOR_ATTACHMENT30 = 0x8CFE; + constexpr GLenum COLOR_ATTACHMENT31 = 0x8CFF; + constexpr GLenum FRAMEBUFFER_INCOMPLETE_MULTISAMPLE = 0x8D56; + constexpr GLenum MAX_SAMPLES = 0x8D57; + constexpr GLenum HALF_FLOAT = 0x140B; + constexpr GLenum MAP_READ_BIT = 0x0001; + constexpr GLenum MAP_WRITE_BIT = 0x0002; + constexpr GLenum MAP_INVALIDATE_RANGE_BIT = 0x0004; + constexpr GLenum MAP_INVALIDATE_BUFFER_BIT = 0x0008; + constexpr GLenum MAP_FLUSH_EXPLICIT_BIT = 0x0010; + constexpr GLenum MAP_UNSYNCHRONIZED_BIT = 0x0020; + constexpr GLenum RG = 0x8227; + constexpr GLenum RG_INTEGER = 0x8228; + constexpr GLenum R8 = 0x8229; + constexpr GLenum RG8 = 0x822B; + constexpr GLenum R16F = 0x822D; + constexpr GLenum R32F = 0x822E; + constexpr GLenum RG16F = 0x822F; + constexpr GLenum RG32F = 0x8230; + constexpr GLenum R8I = 0x8231; + constexpr GLenum R8UI = 0x8232; + constexpr GLenum R16I = 0x8233; + constexpr GLenum R16UI = 0x8234; + constexpr GLenum R32I = 0x8235; + constexpr GLenum R32UI = 0x8236; + constexpr GLenum RG8I = 0x8237; + constexpr GLenum RG8UI = 0x8238; + constexpr GLenum RG16I = 0x8239; + constexpr GLenum RG16UI = 0x823A; + constexpr GLenum RG32I = 0x823B; + constexpr GLenum RG32UI = 0x823C; + constexpr GLenum VERTEX_ARRAY_BINDING = 0x85B5; + constexpr GLenum R8_SNORM = 0x8F94; + constexpr GLenum RG8_SNORM = 0x8F95; + constexpr GLenum RGB8_SNORM = 0x8F96; + constexpr GLenum RGBA8_SNORM = 0x8F97; + constexpr GLenum SIGNED_NORMALIZED = 0x8F9C; + constexpr GLenum PRIMITIVE_RESTART_FIXED_INDEX = 0x8D69; + constexpr GLenum COPY_READ_BUFFER = 0x8F36; + constexpr GLenum COPY_WRITE_BUFFER = 0x8F37; + constexpr GLenum COPY_READ_BUFFER_BINDING = 0x8F36; + constexpr GLenum COPY_WRITE_BUFFER_BINDING = 0x8F37; + constexpr GLenum UNIFORM_BUFFER = 0x8A11; + constexpr GLenum UNIFORM_BUFFER_BINDING = 0x8A28; + constexpr GLenum UNIFORM_BUFFER_START = 0x8A29; + constexpr GLenum UNIFORM_BUFFER_SIZE = 0x8A2A; + constexpr GLenum MAX_VERTEX_UNIFORM_BLOCKS = 0x8A2B; + constexpr GLenum MAX_FRAGMENT_UNIFORM_BLOCKS = 0x8A2D; + constexpr GLenum MAX_COMBINED_UNIFORM_BLOCKS = 0x8A2E; + constexpr GLenum MAX_UNIFORM_BUFFER_BINDINGS = 0x8A2F; + constexpr GLenum MAX_UNIFORM_BLOCK_SIZE = 0x8A30; + constexpr GLenum MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS = 0x8A31; + constexpr GLenum MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS = 0x8A33; + constexpr GLenum UNIFORM_BUFFER_OFFSET_ALIGNMENT = 0x8A34; + constexpr GLenum ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH = 0x8A35; + constexpr GLenum ACTIVE_UNIFORM_BLOCKS = 0x8A36; + constexpr GLenum UNIFORM_TYPE = 0x8A37; + constexpr GLenum UNIFORM_SIZE = 0x8A38; + constexpr GLenum UNIFORM_NAME_LENGTH = 0x8A39; + constexpr GLenum UNIFORM_BLOCK_INDEX = 0x8A3A; + constexpr GLenum UNIFORM_OFFSET = 0x8A3B; + constexpr GLenum UNIFORM_ARRAY_STRIDE = 0x8A3C; + constexpr GLenum UNIFORM_MATRIX_STRIDE = 0x8A3D; + constexpr GLenum UNIFORM_IS_ROW_MAJOR = 0x8A3E; + constexpr GLenum UNIFORM_BLOCK_BINDING = 0x8A3F; + constexpr GLenum UNIFORM_BLOCK_DATA_SIZE = 0x8A40; + constexpr GLenum UNIFORM_BLOCK_NAME_LENGTH = 0x8A41; + constexpr GLenum UNIFORM_BLOCK_ACTIVE_UNIFORMS = 0x8A42; + constexpr GLenum UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES = 0x8A43; + constexpr GLenum UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER = 0x8A44; + constexpr GLenum UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER = 0x8A46; + constexpr unsigned INVALID_INDEX = 0xFFFFFFFF; + constexpr GLenum MAX_VERTEX_OUTPUT_COMPONENTS = 0x9122; + constexpr GLenum MAX_FRAGMENT_INPUT_COMPONENTS = 0x9125; + constexpr GLenum MAX_SERVER_WAIT_TIMEOUT = 0x9111; + constexpr GLenum OBJECT_TYPE = 0x9112; + constexpr GLenum SYNC_CONDITION = 0x9113; + constexpr GLenum SYNC_STATUS = 0x9114; + constexpr GLenum SYNC_FLAGS = 0x9115; + constexpr GLenum SYNC_FENCE = 0x9116; + constexpr GLenum SYNC_GPU_COMMANDS_COMPLETE = 0x9117; + constexpr GLenum UNSIGNALED = 0x9118; + constexpr GLenum SIGNALED = 0x9119; + constexpr GLenum ALREADY_SIGNALED = 0x911A; + constexpr GLenum TIMEOUT_EXPIRED = 0x911B; + constexpr GLenum CONDITION_SATISFIED = 0x911C; + constexpr GLenum WAIT_FAILED = 0x911D; + constexpr GLenum SYNC_FLUSH_COMMANDS_BIT = 0x00000001; + constexpr unsigned long long TIMEOUT_IGNORED = 0xFFFFFFFFFFFFFFFF; + constexpr GLenum VERTEX_ATTRIB_ARRAY_DIVISOR = 0x88FE; + constexpr GLenum ANY_SAMPLES_PASSED = 0x8C2F; + constexpr GLenum ANY_SAMPLES_PASSED_CONSERVATIVE = 0x8D6A; + constexpr GLenum SAMPLER_BINDING = 0x8919; + constexpr GLenum RGB10_A2UI = 0x906F; + constexpr GLenum TEXTURE_SWIZZLE_R = 0x8E42; + constexpr GLenum TEXTURE_SWIZZLE_G = 0x8E43; + constexpr GLenum TEXTURE_SWIZZLE_B = 0x8E44; + constexpr GLenum TEXTURE_SWIZZLE_A = 0x8E45; + constexpr GLenum GREEN = 0x1904; + constexpr GLenum BLUE = 0x1905; + constexpr GLenum INT_2_10_10_10_REV = 0x8D9F; + constexpr GLenum TRANSFORM_FEEDBACK = 0x8E22; + constexpr GLenum TRANSFORM_FEEDBACK_PAUSED = 0x8E23; + constexpr GLenum TRANSFORM_FEEDBACK_ACTIVE = 0x8E24; + constexpr GLenum TRANSFORM_FEEDBACK_BINDING = 0x8E25; + constexpr GLenum PROGRAM_BINARY_RETRIEVABLE_HINT = 0x8257; + constexpr GLenum PROGRAM_BINARY_LENGTH = 0x8741; + constexpr GLenum NUM_PROGRAM_BINARY_FORMATS = 0x87FE; + constexpr GLenum PROGRAM_BINARY_FORMATS = 0x87FF; + constexpr GLenum COMPRESSED_R11_EAC = 0x9270; + constexpr GLenum COMPRESSED_SIGNED_R11_EAC = 0x9271; + constexpr GLenum COMPRESSED_RG11_EAC = 0x9272; + constexpr GLenum COMPRESSED_SIGNED_RG11_EAC = 0x9273; + constexpr GLenum COMPRESSED_RGB8_ETC2 = 0x9274; + constexpr GLenum COMPRESSED_SRGB8_ETC2 = 0x9275; + constexpr GLenum COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 = 0x9276; + constexpr GLenum COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 = 0x9277; + constexpr GLenum COMPRESSED_RGBA8_ETC2_EAC = 0x9278; + constexpr GLenum COMPRESSED_SRGB8_ALPHA8_ETC2_EAC = 0x9279; + constexpr GLenum TEXTURE_IMMUTABLE_FORMAT = 0x912F; + constexpr GLenum MAX_ELEMENT_INDEX = 0x8D6B; + constexpr GLenum NUM_SAMPLE_COUNTS = 0x9380; + constexpr GLenum TEXTURE_IMMUTABLE_LEVELS = 0x82DF; + + inline void ReadBuffer(GLenum src){ return internal::glReadBuffer(src); } + inline void DrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices){ return internal::glDrawRangeElements(mode, start, end, count, type, indices); } + inline void TexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels){ return internal::glTexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels); } + inline void TexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels){ return internal::glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels); } + inline void CopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height){ return internal::glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height); } + inline void CompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *data){ return internal::glCompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data); } + inline void CompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data){ return internal::glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data); } + inline void GenQueries(GLsizei n, GLuint *ids){ return internal::glGenQueries(n, ids); } + inline void DeleteQueries(GLsizei n, const GLuint *ids){ return internal::glDeleteQueries(n, ids); } + inline GLboolean IsQuery(GLuint id){ return internal::glIsQuery(id); } + inline void BeginQuery(GLenum target, GLuint id){ return internal::glBeginQuery(target, id); } + inline void EndQuery(GLenum target){ return internal::glEndQuery(target); } + inline void GetQueryiv(GLenum target, GLenum pname, GLint *params){ return internal::glGetQueryiv(target, pname, params); } + inline void GetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params){ return internal::glGetQueryObjectuiv(id, pname, params); } + inline GLboolean UnmapBuffer(GLenum target){ return internal::glUnmapBuffer(target); } + inline void GetBufferPointerv(GLenum target, GLenum pname, void **params){ return internal::glGetBufferPointerv(target, pname, params); } + inline void DrawBuffers(GLsizei n, const GLenum *bufs){ return internal::glDrawBuffers(n, bufs); } + inline void UniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value){ return internal::glUniformMatrix2x3fv(location, count, transpose, value); } + inline void UniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value){ return internal::glUniformMatrix3x2fv(location, count, transpose, value); } + inline void UniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value){ return internal::glUniformMatrix2x4fv(location, count, transpose, value); } + inline void UniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value){ return internal::glUniformMatrix4x2fv(location, count, transpose, value); } + inline void UniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value){ return internal::glUniformMatrix3x4fv(location, count, transpose, value); } + inline void UniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value){ return internal::glUniformMatrix4x3fv(location, count, transpose, value); } + inline void BlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter){ return internal::glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter); } + inline void RenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height){ return internal::glRenderbufferStorageMultisample(target, samples, internalformat, width, height); } + inline void FramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer){ return internal::glFramebufferTextureLayer(target, attachment, texture, level, layer); } + inline void *MapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access){ return internal::glMapBufferRange(target, offset, length, access); } + inline void FlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length){ return internal::glFlushMappedBufferRange(target, offset, length); } + inline void BindVertexArray(GLuint array){ return internal::glBindVertexArray(array); } + inline void DeleteVertexArrays(GLsizei n, const GLuint *arrays){ return internal::glDeleteVertexArrays(n, arrays); } + inline void GenVertexArrays(GLsizei n, GLuint *arrays){ return internal::glGenVertexArrays(n, arrays); } + inline GLboolean IsVertexArray(GLuint array){ return internal::glIsVertexArray(array); } + inline void GetIntegeri_v(GLenum target, GLuint index, GLint *data){ return internal::glGetIntegeri_v(target, index, data); } + inline void BeginTransformFeedback(GLenum primitiveMode){ return internal::glBeginTransformFeedback(primitiveMode); } + inline void EndTransformFeedback(){ return internal::glEndTransformFeedback(); } + inline void BindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size){ return internal::glBindBufferRange(target, index, buffer, offset, size); } + inline void BindBufferBase(GLenum target, GLuint index, GLuint buffer){ return internal::glBindBufferBase(target, index, buffer); } + inline void TransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar *const*varyings, GLenum bufferMode){ return internal::glTransformFeedbackVaryings(program, count, varyings, bufferMode); } + inline void GetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name){ return internal::glGetTransformFeedbackVarying(program, index, bufSize, length, size, type, name); } + inline void VertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer){ return internal::glVertexAttribIPointer(index, size, type, stride, pointer); } + inline void GetVertexAttribIiv(GLuint index, GLenum pname, GLint *params){ return internal::glGetVertexAttribIiv(index, pname, params); } + inline void GetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params){ return internal::glGetVertexAttribIuiv(index, pname, params); } + inline void VertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w){ return internal::glVertexAttribI4i(index, x, y, z, w); } + inline void VertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w){ return internal::glVertexAttribI4ui(index, x, y, z, w); } + inline void VertexAttribI4iv(GLuint index, const GLint *v){ return internal::glVertexAttribI4iv(index, v); } + inline void VertexAttribI4uiv(GLuint index, const GLuint *v){ return internal::glVertexAttribI4uiv(index, v); } + inline void GetUniformuiv(GLuint program, GLint location, GLuint *params){ return internal::glGetUniformuiv(program, location, params); } + inline GLint GetFragDataLocation(GLuint program, const GLchar *name){ return internal::glGetFragDataLocation(program, name); } + inline void Uniform1ui(GLint location, GLuint v0){ return internal::glUniform1ui(location, v0); } + inline void Uniform2ui(GLint location, GLuint v0, GLuint v1){ return internal::glUniform2ui(location, v0, v1); } + inline void Uniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2){ return internal::glUniform3ui(location, v0, v1, v2); } + inline void Uniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3){ return internal::glUniform4ui(location, v0, v1, v2, v3); } + inline void Uniform1uiv(GLint location, GLsizei count, const GLuint *value){ return internal::glUniform1uiv(location, count, value); } + inline void Uniform2uiv(GLint location, GLsizei count, const GLuint *value){ return internal::glUniform2uiv(location, count, value); } + inline void Uniform3uiv(GLint location, GLsizei count, const GLuint *value){ return internal::glUniform3uiv(location, count, value); } + inline void Uniform4uiv(GLint location, GLsizei count, const GLuint *value){ return internal::glUniform4uiv(location, count, value); } + inline void ClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value){ return internal::glClearBufferiv(buffer, drawbuffer, value); } + inline void ClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value){ return internal::glClearBufferuiv(buffer, drawbuffer, value); } + inline void ClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value){ return internal::glClearBufferfv(buffer, drawbuffer, value); } + inline void ClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil){ return internal::glClearBufferfi(buffer, drawbuffer, depth, stencil); } + inline const GLubyte *GetStringi(GLenum name, GLuint index){ return internal::glGetStringi(name, index); } + inline void CopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size){ return internal::glCopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size); } + inline void GetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar *const*uniformNames, GLuint *uniformIndices){ return internal::glGetUniformIndices(program, uniformCount, uniformNames, uniformIndices); } + inline void GetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params){ return internal::glGetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params); } + inline GLuint GetUniformBlockIndex(GLuint program, const GLchar *uniformBlockName){ return internal::glGetUniformBlockIndex(program, uniformBlockName); } + inline void GetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params){ return internal::glGetActiveUniformBlockiv(program, uniformBlockIndex, pname, params); } + inline void GetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName){ return internal::glGetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName); } + inline void UniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding){ return internal::glUniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding); } + inline void DrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instancecount){ return internal::glDrawArraysInstanced(mode, first, count, instancecount); } + inline void DrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount){ return internal::glDrawElementsInstanced(mode, count, type, indices, instancecount); } + inline GLsync FenceSync(GLenum condition, GLbitfield flags){ return internal::glFenceSync(condition, flags); } + inline GLboolean IsSync(GLsync sync){ return internal::glIsSync(sync); } + inline void DeleteSync(GLsync sync){ return internal::glDeleteSync(sync); } + inline GLenum ClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout){ return internal::glClientWaitSync(sync, flags, timeout); } + inline void WaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout){ return internal::glWaitSync(sync, flags, timeout); } + inline void GetInteger64v(GLenum pname, GLint64 *data){ return internal::glGetInteger64v(pname, data); } + inline void GetSynciv(GLsync sync, GLenum pname, GLsizei count, GLsizei *length, GLint *values){ return internal::glGetSynciv(sync, pname, count, length, values); } + inline void GetInteger64i_v(GLenum target, GLuint index, GLint64 *data){ return internal::glGetInteger64i_v(target, index, data); } + inline void GetBufferParameteri64v(GLenum target, GLenum pname, GLint64 *params){ return internal::glGetBufferParameteri64v(target, pname, params); } + inline void GenSamplers(GLsizei count, GLuint *samplers){ return internal::glGenSamplers(count, samplers); } + inline void DeleteSamplers(GLsizei count, const GLuint *samplers){ return internal::glDeleteSamplers(count, samplers); } + inline GLboolean IsSampler(GLuint sampler){ return internal::glIsSampler(sampler); } + inline void BindSampler(GLuint unit, GLuint sampler){ return internal::glBindSampler(unit, sampler); } + inline void SamplerParameteri(GLuint sampler, GLenum pname, GLint param){ return internal::glSamplerParameteri(sampler, pname, param); } + inline void SamplerParameteriv(GLuint sampler, GLenum pname, const GLint *param){ return internal::glSamplerParameteriv(sampler, pname, param); } + inline void SamplerParameterf(GLuint sampler, GLenum pname, GLfloat param){ return internal::glSamplerParameterf(sampler, pname, param); } + inline void SamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat *param){ return internal::glSamplerParameterfv(sampler, pname, param); } + inline void GetSamplerParameteriv(GLuint sampler, GLenum pname, GLint *params){ return internal::glGetSamplerParameteriv(sampler, pname, params); } + inline void GetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat *params){ return internal::glGetSamplerParameterfv(sampler, pname, params); } + inline void VertexAttribDivisor(GLuint index, GLuint divisor){ return internal::glVertexAttribDivisor(index, divisor); } + inline void BindTransformFeedback(GLenum target, GLuint id){ return internal::glBindTransformFeedback(target, id); } + inline void DeleteTransformFeedbacks(GLsizei n, const GLuint *ids){ return internal::glDeleteTransformFeedbacks(n, ids); } + inline void GenTransformFeedbacks(GLsizei n, GLuint *ids){ return internal::glGenTransformFeedbacks(n, ids); } + inline GLboolean IsTransformFeedback(GLuint id){ return internal::glIsTransformFeedback(id); } + inline void PauseTransformFeedback(){ return internal::glPauseTransformFeedback(); } + inline void ResumeTransformFeedback(){ return internal::glResumeTransformFeedback(); } + inline void GetProgramBinary(GLuint program, GLsizei bufSize, GLsizei *length, GLenum *binaryFormat, void *binary){ return internal::glGetProgramBinary(program, bufSize, length, binaryFormat, binary); } + inline void ProgramBinary(GLuint program, GLenum binaryFormat, const void *binary, GLsizei length){ return internal::glProgramBinary(program, binaryFormat, binary, length); } + inline void ProgramParameteri(GLuint program, GLenum pname, GLint value){ return internal::glProgramParameteri(program, pname, value); } + inline void InvalidateFramebuffer(GLenum target, GLsizei numAttachments, const GLenum *attachments){ return internal::glInvalidateFramebuffer(target, numAttachments, attachments); } + inline void InvalidateSubFramebuffer(GLenum target, GLsizei numAttachments, const GLenum *attachments, GLint x, GLint y, GLsizei width, GLsizei height){ return internal::glInvalidateSubFramebuffer(target, numAttachments, attachments, x, y, width, height); } + inline void TexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height){ return internal::glTexStorage2D(target, levels, internalformat, width, height); } + inline void TexStorage3D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth){ return internal::glTexStorage3D(target, levels, internalformat, width, height, depth); } + inline void GetInternalformativ(GLenum target, GLenum internalformat, GLenum pname, GLsizei count, GLint *params){ return internal::glGetInternalformativ(target, internalformat, pname, count, params); } + + // GL_EXT_texture_filter_anisotropic + + constexpr GLenum TEXTURE_MAX_ANISOTROPY_EXT = 0x84FE; + constexpr GLenum MAX_TEXTURE_MAX_ANISOTROPY_EXT = 0x84FF; + + + namespace sys + { + + bool initialize(); + const char * api(); + int major_version(); + int minor_version(); + + bool has_extension(const char * name); + bool ext_EXT_texture_filter_anisotropic(); + + const char * shader_prefix(); + + } // namespace sys + +} // namespace gl + diff --git a/libs/gfx/api/gles30-emscripten/source/gl.cpp b/libs/gfx/api/gles30-emscripten/source/gl.cpp new file mode 100644 index 00000000..2cef2465 --- /dev/null +++ b/libs/gfx/api/gles30-emscripten/source/gl.cpp @@ -0,0 +1,902 @@ +#include + + +#include +#include + +#if defined(__APPLE__) +#include +#elif defined(__sgi) || defined (__sun) +#include +#include +#elif defined(_WIN32) +#include +#else +#include +#endif + +namespace gl +{ + + namespace internal + { + + + #if defined(__APPLE__) + + static void * get_proc_address(const char *func) + { + static void * image = dlopen("/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL", RTLD_LAZY); + + if (!image) return nullptr; + + return dlsym(image, func); + } + + #elif defined(__sgi) || defined (__sun) + + static void * get_proc_address(const char *func) + { + static void * image = dlopen(nullptr, RTLD_LAZY | RTLD_LOCAL); + static void * gpa = image ? dlsym(image, "glXGetProcAddress") : nullptr; + + if (gpa) + return reinterpret_cast(gpa)(reinterpret_cast(name)); + else + return dlsym(image, name); + } + + #elif defined(_WIN32) + + #ifdef _MSC_VER + #pragma warning(disable: 4055) + #pragma warning(disable: 4054) + #pragma warning(disable: 4996) + #endif + + static int test_pointer(const PROC p) + { + ptrdiff_t i; + if (!p) return 0; + i = (ptrdiff_t)p; + + if(i == 1 || i == 2 || i == 3 || i == -1) return 0; + + return 1; + } + + static void * get_proc_address(const char *name) + { + static HMODULE image = GetModuleHandleA("opengl32.dll"); + + PROC func = wglGetProcAddress(reinterpret_cast(name)); + if (test_pointer(func)) + { + return reinterpret_cast(func); + } + + return reinterpret_cast(GetProcAddress(image, reinterpret_cast(name))); + } + + #else // GLX + + static void * get_proc_address(const char *func) + { + return reinterpret_cast(glXGetProcAddress(reinterpret_cast(func))); + } + + #endif + + // OpenGL ES 2.0 + + void (*glActiveTexture)(GLenum texture) = nullptr; + void (*glAttachShader)(GLuint program, GLuint shader) = nullptr; + void (*glBindAttribLocation)(GLuint program, GLuint index, const GLchar *name) = nullptr; + void (*glBindBuffer)(GLenum target, GLuint buffer) = nullptr; + void (*glBindFramebuffer)(GLenum target, GLuint framebuffer) = nullptr; + void (*glBindRenderbuffer)(GLenum target, GLuint renderbuffer) = nullptr; + void (*glBindTexture)(GLenum target, GLuint texture) = nullptr; + void (*glBlendColor)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) = nullptr; + void (*glBlendEquation)(GLenum mode) = nullptr; + void (*glBlendEquationSeparate)(GLenum modeRGB, GLenum modeAlpha) = nullptr; + void (*glBlendFunc)(GLenum sfactor, GLenum dfactor) = nullptr; + void (*glBlendFuncSeparate)(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha) = nullptr; + void (*glBufferData)(GLenum target, GLsizeiptr size, const void *data, GLenum usage) = nullptr; + void (*glBufferSubData)(GLenum target, GLintptr offset, GLsizeiptr size, const void *data) = nullptr; + GLenum (*glCheckFramebufferStatus)(GLenum target) = nullptr; + void (*glClear)(GLbitfield mask) = nullptr; + void (*glClearColor)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) = nullptr; + void (*glClearDepthf)(GLfloat d) = nullptr; + void (*glClearStencil)(GLint s) = nullptr; + void (*glColorMask)(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) = nullptr; + void (*glCompileShader)(GLuint shader) = nullptr; + void (*glCompressedTexImage2D)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *data) = nullptr; + void (*glCompressedTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data) = nullptr; + void (*glCopyTexImage2D)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) = nullptr; + void (*glCopyTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) = nullptr; + GLuint (*glCreateProgram)() = nullptr; + GLuint (*glCreateShader)(GLenum type) = nullptr; + void (*glCullFace)(GLenum mode) = nullptr; + void (*glDeleteBuffers)(GLsizei n, const GLuint *buffers) = nullptr; + void (*glDeleteFramebuffers)(GLsizei n, const GLuint *framebuffers) = nullptr; + void (*glDeleteProgram)(GLuint program) = nullptr; + void (*glDeleteRenderbuffers)(GLsizei n, const GLuint *renderbuffers) = nullptr; + void (*glDeleteShader)(GLuint shader) = nullptr; + void (*glDeleteTextures)(GLsizei n, const GLuint *textures) = nullptr; + void (*glDepthFunc)(GLenum func) = nullptr; + void (*glDepthMask)(GLboolean flag) = nullptr; + void (*glDepthRangef)(GLfloat n, GLfloat f) = nullptr; + void (*glDetachShader)(GLuint program, GLuint shader) = nullptr; + void (*glDisable)(GLenum cap) = nullptr; + void (*glDisableVertexAttribArray)(GLuint index) = nullptr; + void (*glDrawArrays)(GLenum mode, GLint first, GLsizei count) = nullptr; + void (*glDrawElements)(GLenum mode, GLsizei count, GLenum type, const void *indices) = nullptr; + void (*glEnable)(GLenum cap) = nullptr; + void (*glEnableVertexAttribArray)(GLuint index) = nullptr; + void (*glFinish)() = nullptr; + void (*glFlush)() = nullptr; + void (*glFramebufferRenderbuffer)(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) = nullptr; + void (*glFramebufferTexture2D)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) = nullptr; + void (*glFrontFace)(GLenum mode) = nullptr; + void (*glGenBuffers)(GLsizei n, GLuint *buffers) = nullptr; + void (*glGenerateMipmap)(GLenum target) = nullptr; + void (*glGenFramebuffers)(GLsizei n, GLuint *framebuffers) = nullptr; + void (*glGenRenderbuffers)(GLsizei n, GLuint *renderbuffers) = nullptr; + void (*glGenTextures)(GLsizei n, GLuint *textures) = nullptr; + void (*glGetActiveAttrib)(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name) = nullptr; + void (*glGetActiveUniform)(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name) = nullptr; + void (*glGetAttachedShaders)(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *shaders) = nullptr; + GLint (*glGetAttribLocation)(GLuint program, const GLchar *name) = nullptr; + void (*glGetBooleanv)(GLenum pname, GLboolean *data) = nullptr; + void (*glGetBufferParameteriv)(GLenum target, GLenum pname, GLint *params) = nullptr; + GLenum (*glGetError)() = nullptr; + void (*glGetFloatv)(GLenum pname, GLfloat *data) = nullptr; + void (*glGetFramebufferAttachmentParameteriv)(GLenum target, GLenum attachment, GLenum pname, GLint *params) = nullptr; + void (*glGetIntegerv)(GLenum pname, GLint *data) = nullptr; + void (*glGetProgramiv)(GLuint program, GLenum pname, GLint *params) = nullptr; + void (*glGetProgramInfoLog)(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog) = nullptr; + void (*glGetRenderbufferParameteriv)(GLenum target, GLenum pname, GLint *params) = nullptr; + void (*glGetShaderiv)(GLuint shader, GLenum pname, GLint *params) = nullptr; + void (*glGetShaderInfoLog)(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog) = nullptr; + void (*glGetShaderPrecisionFormat)(GLenum shadertype, GLenum precisiontype, GLint *range, GLint *precision) = nullptr; + void (*glGetShaderSource)(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source) = nullptr; + const GLubyte *(*glGetString)(GLenum name) = nullptr; + void (*glGetTexParameterfv)(GLenum target, GLenum pname, GLfloat *params) = nullptr; + void (*glGetTexParameteriv)(GLenum target, GLenum pname, GLint *params) = nullptr; + void (*glGetUniformfv)(GLuint program, GLint location, GLfloat *params) = nullptr; + void (*glGetUniformiv)(GLuint program, GLint location, GLint *params) = nullptr; + GLint (*glGetUniformLocation)(GLuint program, const GLchar *name) = nullptr; + void (*glGetVertexAttribfv)(GLuint index, GLenum pname, GLfloat *params) = nullptr; + void (*glGetVertexAttribiv)(GLuint index, GLenum pname, GLint *params) = nullptr; + void (*glGetVertexAttribPointerv)(GLuint index, GLenum pname, void **pointer) = nullptr; + void (*glHint)(GLenum target, GLenum mode) = nullptr; + GLboolean (*glIsBuffer)(GLuint buffer) = nullptr; + GLboolean (*glIsEnabled)(GLenum cap) = nullptr; + GLboolean (*glIsFramebuffer)(GLuint framebuffer) = nullptr; + GLboolean (*glIsProgram)(GLuint program) = nullptr; + GLboolean (*glIsRenderbuffer)(GLuint renderbuffer) = nullptr; + GLboolean (*glIsShader)(GLuint shader) = nullptr; + GLboolean (*glIsTexture)(GLuint texture) = nullptr; + void (*glLineWidth)(GLfloat width) = nullptr; + void (*glLinkProgram)(GLuint program) = nullptr; + void (*glPixelStorei)(GLenum pname, GLint param) = nullptr; + void (*glPolygonOffset)(GLfloat factor, GLfloat units) = nullptr; + void (*glReadPixels)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *pixels) = nullptr; + void (*glReleaseShaderCompiler)() = nullptr; + void (*glRenderbufferStorage)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height) = nullptr; + void (*glSampleCoverage)(GLfloat value, GLboolean invert) = nullptr; + void (*glScissor)(GLint x, GLint y, GLsizei width, GLsizei height) = nullptr; + void (*glShaderBinary)(GLsizei count, const GLuint *shaders, GLenum binaryFormat, const void *binary, GLsizei length) = nullptr; + void (*glShaderSource)(GLuint shader, GLsizei count, const GLchar *const*string, const GLint *length) = nullptr; + void (*glStencilFunc)(GLenum func, GLint ref, GLuint mask) = nullptr; + void (*glStencilFuncSeparate)(GLenum face, GLenum func, GLint ref, GLuint mask) = nullptr; + void (*glStencilMask)(GLuint mask) = nullptr; + void (*glStencilMaskSeparate)(GLenum face, GLuint mask) = nullptr; + void (*glStencilOp)(GLenum fail, GLenum zfail, GLenum zpass) = nullptr; + void (*glStencilOpSeparate)(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass) = nullptr; + void (*glTexImage2D)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels) = nullptr; + void (*glTexParameterf)(GLenum target, GLenum pname, GLfloat param) = nullptr; + void (*glTexParameterfv)(GLenum target, GLenum pname, const GLfloat *params) = nullptr; + void (*glTexParameteri)(GLenum target, GLenum pname, GLint param) = nullptr; + void (*glTexParameteriv)(GLenum target, GLenum pname, const GLint *params) = nullptr; + void (*glTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels) = nullptr; + void (*glUniform1f)(GLint location, GLfloat v0) = nullptr; + void (*glUniform1fv)(GLint location, GLsizei count, const GLfloat *value) = nullptr; + void (*glUniform1i)(GLint location, GLint v0) = nullptr; + void (*glUniform1iv)(GLint location, GLsizei count, const GLint *value) = nullptr; + void (*glUniform2f)(GLint location, GLfloat v0, GLfloat v1) = nullptr; + void (*glUniform2fv)(GLint location, GLsizei count, const GLfloat *value) = nullptr; + void (*glUniform2i)(GLint location, GLint v0, GLint v1) = nullptr; + void (*glUniform2iv)(GLint location, GLsizei count, const GLint *value) = nullptr; + void (*glUniform3f)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2) = nullptr; + void (*glUniform3fv)(GLint location, GLsizei count, const GLfloat *value) = nullptr; + void (*glUniform3i)(GLint location, GLint v0, GLint v1, GLint v2) = nullptr; + void (*glUniform3iv)(GLint location, GLsizei count, const GLint *value) = nullptr; + void (*glUniform4f)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) = nullptr; + void (*glUniform4fv)(GLint location, GLsizei count, const GLfloat *value) = nullptr; + void (*glUniform4i)(GLint location, GLint v0, GLint v1, GLint v2, GLint v3) = nullptr; + void (*glUniform4iv)(GLint location, GLsizei count, const GLint *value) = nullptr; + void (*glUniformMatrix2fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) = nullptr; + void (*glUniformMatrix3fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) = nullptr; + void (*glUniformMatrix4fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) = nullptr; + void (*glUseProgram)(GLuint program) = nullptr; + void (*glValidateProgram)(GLuint program) = nullptr; + void (*glVertexAttrib1f)(GLuint index, GLfloat x) = nullptr; + void (*glVertexAttrib1fv)(GLuint index, const GLfloat *v) = nullptr; + void (*glVertexAttrib2f)(GLuint index, GLfloat x, GLfloat y) = nullptr; + void (*glVertexAttrib2fv)(GLuint index, const GLfloat *v) = nullptr; + void (*glVertexAttrib3f)(GLuint index, GLfloat x, GLfloat y, GLfloat z) = nullptr; + void (*glVertexAttrib3fv)(GLuint index, const GLfloat *v) = nullptr; + void (*glVertexAttrib4f)(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w) = nullptr; + void (*glVertexAttrib4fv)(GLuint index, const GLfloat *v) = nullptr; + void (*glVertexAttribPointer)(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer) = nullptr; + void (*glViewport)(GLint x, GLint y, GLsizei width, GLsizei height) = nullptr; + + // OpenGL ES 3.0 + + void (*glReadBuffer)(GLenum src) = nullptr; + void (*glDrawRangeElements)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices) = nullptr; + void (*glTexImage3D)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels) = nullptr; + void (*glTexSubImage3D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels) = nullptr; + void (*glCopyTexSubImage3D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) = nullptr; + void (*glCompressedTexImage3D)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *data) = nullptr; + void (*glCompressedTexSubImage3D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data) = nullptr; + void (*glGenQueries)(GLsizei n, GLuint *ids) = nullptr; + void (*glDeleteQueries)(GLsizei n, const GLuint *ids) = nullptr; + GLboolean (*glIsQuery)(GLuint id) = nullptr; + void (*glBeginQuery)(GLenum target, GLuint id) = nullptr; + void (*glEndQuery)(GLenum target) = nullptr; + void (*glGetQueryiv)(GLenum target, GLenum pname, GLint *params) = nullptr; + void (*glGetQueryObjectuiv)(GLuint id, GLenum pname, GLuint *params) = nullptr; + GLboolean (*glUnmapBuffer)(GLenum target) = nullptr; + void (*glGetBufferPointerv)(GLenum target, GLenum pname, void **params) = nullptr; + void (*glDrawBuffers)(GLsizei n, const GLenum *bufs) = nullptr; + void (*glUniformMatrix2x3fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) = nullptr; + void (*glUniformMatrix3x2fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) = nullptr; + void (*glUniformMatrix2x4fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) = nullptr; + void (*glUniformMatrix4x2fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) = nullptr; + void (*glUniformMatrix3x4fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) = nullptr; + void (*glUniformMatrix4x3fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) = nullptr; + void (*glBlitFramebuffer)(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) = nullptr; + void (*glRenderbufferStorageMultisample)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height) = nullptr; + void (*glFramebufferTextureLayer)(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer) = nullptr; + void *(*glMapBufferRange)(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access) = nullptr; + void (*glFlushMappedBufferRange)(GLenum target, GLintptr offset, GLsizeiptr length) = nullptr; + void (*glBindVertexArray)(GLuint array) = nullptr; + void (*glDeleteVertexArrays)(GLsizei n, const GLuint *arrays) = nullptr; + void (*glGenVertexArrays)(GLsizei n, GLuint *arrays) = nullptr; + GLboolean (*glIsVertexArray)(GLuint array) = nullptr; + void (*glGetIntegeri_v)(GLenum target, GLuint index, GLint *data) = nullptr; + void (*glBeginTransformFeedback)(GLenum primitiveMode) = nullptr; + void (*glEndTransformFeedback)() = nullptr; + void (*glBindBufferRange)(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size) = nullptr; + void (*glBindBufferBase)(GLenum target, GLuint index, GLuint buffer) = nullptr; + void (*glTransformFeedbackVaryings)(GLuint program, GLsizei count, const GLchar *const*varyings, GLenum bufferMode) = nullptr; + void (*glGetTransformFeedbackVarying)(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name) = nullptr; + void (*glVertexAttribIPointer)(GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer) = nullptr; + void (*glGetVertexAttribIiv)(GLuint index, GLenum pname, GLint *params) = nullptr; + void (*glGetVertexAttribIuiv)(GLuint index, GLenum pname, GLuint *params) = nullptr; + void (*glVertexAttribI4i)(GLuint index, GLint x, GLint y, GLint z, GLint w) = nullptr; + void (*glVertexAttribI4ui)(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w) = nullptr; + void (*glVertexAttribI4iv)(GLuint index, const GLint *v) = nullptr; + void (*glVertexAttribI4uiv)(GLuint index, const GLuint *v) = nullptr; + void (*glGetUniformuiv)(GLuint program, GLint location, GLuint *params) = nullptr; + GLint (*glGetFragDataLocation)(GLuint program, const GLchar *name) = nullptr; + void (*glUniform1ui)(GLint location, GLuint v0) = nullptr; + void (*glUniform2ui)(GLint location, GLuint v0, GLuint v1) = nullptr; + void (*glUniform3ui)(GLint location, GLuint v0, GLuint v1, GLuint v2) = nullptr; + void (*glUniform4ui)(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) = nullptr; + void (*glUniform1uiv)(GLint location, GLsizei count, const GLuint *value) = nullptr; + void (*glUniform2uiv)(GLint location, GLsizei count, const GLuint *value) = nullptr; + void (*glUniform3uiv)(GLint location, GLsizei count, const GLuint *value) = nullptr; + void (*glUniform4uiv)(GLint location, GLsizei count, const GLuint *value) = nullptr; + void (*glClearBufferiv)(GLenum buffer, GLint drawbuffer, const GLint *value) = nullptr; + void (*glClearBufferuiv)(GLenum buffer, GLint drawbuffer, const GLuint *value) = nullptr; + void (*glClearBufferfv)(GLenum buffer, GLint drawbuffer, const GLfloat *value) = nullptr; + void (*glClearBufferfi)(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil) = nullptr; + const GLubyte *(*glGetStringi)(GLenum name, GLuint index) = nullptr; + void (*glCopyBufferSubData)(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size) = nullptr; + void (*glGetUniformIndices)(GLuint program, GLsizei uniformCount, const GLchar *const*uniformNames, GLuint *uniformIndices) = nullptr; + void (*glGetActiveUniformsiv)(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params) = nullptr; + GLuint (*glGetUniformBlockIndex)(GLuint program, const GLchar *uniformBlockName) = nullptr; + void (*glGetActiveUniformBlockiv)(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params) = nullptr; + void (*glGetActiveUniformBlockName)(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName) = nullptr; + void (*glUniformBlockBinding)(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding) = nullptr; + void (*glDrawArraysInstanced)(GLenum mode, GLint first, GLsizei count, GLsizei instancecount) = nullptr; + void (*glDrawElementsInstanced)(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount) = nullptr; + GLsync (*glFenceSync)(GLenum condition, GLbitfield flags) = nullptr; + GLboolean (*glIsSync)(GLsync sync) = nullptr; + void (*glDeleteSync)(GLsync sync) = nullptr; + GLenum (*glClientWaitSync)(GLsync sync, GLbitfield flags, GLuint64 timeout) = nullptr; + void (*glWaitSync)(GLsync sync, GLbitfield flags, GLuint64 timeout) = nullptr; + void (*glGetInteger64v)(GLenum pname, GLint64 *data) = nullptr; + void (*glGetSynciv)(GLsync sync, GLenum pname, GLsizei count, GLsizei *length, GLint *values) = nullptr; + void (*glGetInteger64i_v)(GLenum target, GLuint index, GLint64 *data) = nullptr; + void (*glGetBufferParameteri64v)(GLenum target, GLenum pname, GLint64 *params) = nullptr; + void (*glGenSamplers)(GLsizei count, GLuint *samplers) = nullptr; + void (*glDeleteSamplers)(GLsizei count, const GLuint *samplers) = nullptr; + GLboolean (*glIsSampler)(GLuint sampler) = nullptr; + void (*glBindSampler)(GLuint unit, GLuint sampler) = nullptr; + void (*glSamplerParameteri)(GLuint sampler, GLenum pname, GLint param) = nullptr; + void (*glSamplerParameteriv)(GLuint sampler, GLenum pname, const GLint *param) = nullptr; + void (*glSamplerParameterf)(GLuint sampler, GLenum pname, GLfloat param) = nullptr; + void (*glSamplerParameterfv)(GLuint sampler, GLenum pname, const GLfloat *param) = nullptr; + void (*glGetSamplerParameteriv)(GLuint sampler, GLenum pname, GLint *params) = nullptr; + void (*glGetSamplerParameterfv)(GLuint sampler, GLenum pname, GLfloat *params) = nullptr; + void (*glVertexAttribDivisor)(GLuint index, GLuint divisor) = nullptr; + void (*glBindTransformFeedback)(GLenum target, GLuint id) = nullptr; + void (*glDeleteTransformFeedbacks)(GLsizei n, const GLuint *ids) = nullptr; + void (*glGenTransformFeedbacks)(GLsizei n, GLuint *ids) = nullptr; + GLboolean (*glIsTransformFeedback)(GLuint id) = nullptr; + void (*glPauseTransformFeedback)() = nullptr; + void (*glResumeTransformFeedback)() = nullptr; + void (*glGetProgramBinary)(GLuint program, GLsizei bufSize, GLsizei *length, GLenum *binaryFormat, void *binary) = nullptr; + void (*glProgramBinary)(GLuint program, GLenum binaryFormat, const void *binary, GLsizei length) = nullptr; + void (*glProgramParameteri)(GLuint program, GLenum pname, GLint value) = nullptr; + void (*glInvalidateFramebuffer)(GLenum target, GLsizei numAttachments, const GLenum *attachments) = nullptr; + void (*glInvalidateSubFramebuffer)(GLenum target, GLsizei numAttachments, const GLenum *attachments, GLint x, GLint y, GLsizei width, GLsizei height) = nullptr; + void (*glTexStorage2D)(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height) = nullptr; + void (*glTexStorage3D)(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth) = nullptr; + void (*glGetInternalformativ)(GLenum target, GLenum internalformat, GLenum pname, GLsizei count, GLint *params) = nullptr; + + // GL_EXT_texture_filter_anisotropic + + + } // namespace internal + + namespace sys + { + + static bool ext_GL_EXT_texture_filter_anisotropic_loaded = false; + + static bool load_core() + { + // OpenGL ES 2.0 + + internal::glActiveTexture = reinterpret_cast(internal::get_proc_address("glActiveTexture")); + if (!internal::glActiveTexture) return false; + internal::glAttachShader = reinterpret_cast(internal::get_proc_address("glAttachShader")); + if (!internal::glAttachShader) return false; + internal::glBindAttribLocation = reinterpret_cast(internal::get_proc_address("glBindAttribLocation")); + if (!internal::glBindAttribLocation) return false; + internal::glBindBuffer = reinterpret_cast(internal::get_proc_address("glBindBuffer")); + if (!internal::glBindBuffer) return false; + internal::glBindFramebuffer = reinterpret_cast(internal::get_proc_address("glBindFramebuffer")); + if (!internal::glBindFramebuffer) return false; + internal::glBindRenderbuffer = reinterpret_cast(internal::get_proc_address("glBindRenderbuffer")); + if (!internal::glBindRenderbuffer) return false; + internal::glBindTexture = reinterpret_cast(internal::get_proc_address("glBindTexture")); + if (!internal::glBindTexture) return false; + internal::glBlendColor = reinterpret_cast(internal::get_proc_address("glBlendColor")); + if (!internal::glBlendColor) return false; + internal::glBlendEquation = reinterpret_cast(internal::get_proc_address("glBlendEquation")); + if (!internal::glBlendEquation) return false; + internal::glBlendEquationSeparate = reinterpret_cast(internal::get_proc_address("glBlendEquationSeparate")); + if (!internal::glBlendEquationSeparate) return false; + internal::glBlendFunc = reinterpret_cast(internal::get_proc_address("glBlendFunc")); + if (!internal::glBlendFunc) return false; + internal::glBlendFuncSeparate = reinterpret_cast(internal::get_proc_address("glBlendFuncSeparate")); + if (!internal::glBlendFuncSeparate) return false; + internal::glBufferData = reinterpret_cast(internal::get_proc_address("glBufferData")); + if (!internal::glBufferData) return false; + internal::glBufferSubData = reinterpret_cast(internal::get_proc_address("glBufferSubData")); + if (!internal::glBufferSubData) return false; + internal::glCheckFramebufferStatus = reinterpret_cast(internal::get_proc_address("glCheckFramebufferStatus")); + if (!internal::glCheckFramebufferStatus) return false; + internal::glClear = reinterpret_cast(internal::get_proc_address("glClear")); + if (!internal::glClear) return false; + internal::glClearColor = reinterpret_cast(internal::get_proc_address("glClearColor")); + if (!internal::glClearColor) return false; + internal::glClearDepthf = reinterpret_cast(internal::get_proc_address("glClearDepthf")); + if (!internal::glClearDepthf) return false; + internal::glClearStencil = reinterpret_cast(internal::get_proc_address("glClearStencil")); + if (!internal::glClearStencil) return false; + internal::glColorMask = reinterpret_cast(internal::get_proc_address("glColorMask")); + if (!internal::glColorMask) return false; + internal::glCompileShader = reinterpret_cast(internal::get_proc_address("glCompileShader")); + if (!internal::glCompileShader) return false; + internal::glCompressedTexImage2D = reinterpret_cast(internal::get_proc_address("glCompressedTexImage2D")); + if (!internal::glCompressedTexImage2D) return false; + internal::glCompressedTexSubImage2D = reinterpret_cast(internal::get_proc_address("glCompressedTexSubImage2D")); + if (!internal::glCompressedTexSubImage2D) return false; + internal::glCopyTexImage2D = reinterpret_cast(internal::get_proc_address("glCopyTexImage2D")); + if (!internal::glCopyTexImage2D) return false; + internal::glCopyTexSubImage2D = reinterpret_cast(internal::get_proc_address("glCopyTexSubImage2D")); + if (!internal::glCopyTexSubImage2D) return false; + internal::glCreateProgram = reinterpret_cast(internal::get_proc_address("glCreateProgram")); + if (!internal::glCreateProgram) return false; + internal::glCreateShader = reinterpret_cast(internal::get_proc_address("glCreateShader")); + if (!internal::glCreateShader) return false; + internal::glCullFace = reinterpret_cast(internal::get_proc_address("glCullFace")); + if (!internal::glCullFace) return false; + internal::glDeleteBuffers = reinterpret_cast(internal::get_proc_address("glDeleteBuffers")); + if (!internal::glDeleteBuffers) return false; + internal::glDeleteFramebuffers = reinterpret_cast(internal::get_proc_address("glDeleteFramebuffers")); + if (!internal::glDeleteFramebuffers) return false; + internal::glDeleteProgram = reinterpret_cast(internal::get_proc_address("glDeleteProgram")); + if (!internal::glDeleteProgram) return false; + internal::glDeleteRenderbuffers = reinterpret_cast(internal::get_proc_address("glDeleteRenderbuffers")); + if (!internal::glDeleteRenderbuffers) return false; + internal::glDeleteShader = reinterpret_cast(internal::get_proc_address("glDeleteShader")); + if (!internal::glDeleteShader) return false; + internal::glDeleteTextures = reinterpret_cast(internal::get_proc_address("glDeleteTextures")); + if (!internal::glDeleteTextures) return false; + internal::glDepthFunc = reinterpret_cast(internal::get_proc_address("glDepthFunc")); + if (!internal::glDepthFunc) return false; + internal::glDepthMask = reinterpret_cast(internal::get_proc_address("glDepthMask")); + if (!internal::glDepthMask) return false; + internal::glDepthRangef = reinterpret_cast(internal::get_proc_address("glDepthRangef")); + if (!internal::glDepthRangef) return false; + internal::glDetachShader = reinterpret_cast(internal::get_proc_address("glDetachShader")); + if (!internal::glDetachShader) return false; + internal::glDisable = reinterpret_cast(internal::get_proc_address("glDisable")); + if (!internal::glDisable) return false; + internal::glDisableVertexAttribArray = reinterpret_cast(internal::get_proc_address("glDisableVertexAttribArray")); + if (!internal::glDisableVertexAttribArray) return false; + internal::glDrawArrays = reinterpret_cast(internal::get_proc_address("glDrawArrays")); + if (!internal::glDrawArrays) return false; + internal::glDrawElements = reinterpret_cast(internal::get_proc_address("glDrawElements")); + if (!internal::glDrawElements) return false; + internal::glEnable = reinterpret_cast(internal::get_proc_address("glEnable")); + if (!internal::glEnable) return false; + internal::glEnableVertexAttribArray = reinterpret_cast(internal::get_proc_address("glEnableVertexAttribArray")); + if (!internal::glEnableVertexAttribArray) return false; + internal::glFinish = reinterpret_cast(internal::get_proc_address("glFinish")); + if (!internal::glFinish) return false; + internal::glFlush = reinterpret_cast(internal::get_proc_address("glFlush")); + if (!internal::glFlush) return false; + internal::glFramebufferRenderbuffer = reinterpret_cast(internal::get_proc_address("glFramebufferRenderbuffer")); + if (!internal::glFramebufferRenderbuffer) return false; + internal::glFramebufferTexture2D = reinterpret_cast(internal::get_proc_address("glFramebufferTexture2D")); + if (!internal::glFramebufferTexture2D) return false; + internal::glFrontFace = reinterpret_cast(internal::get_proc_address("glFrontFace")); + if (!internal::glFrontFace) return false; + internal::glGenBuffers = reinterpret_cast(internal::get_proc_address("glGenBuffers")); + if (!internal::glGenBuffers) return false; + internal::glGenerateMipmap = reinterpret_cast(internal::get_proc_address("glGenerateMipmap")); + if (!internal::glGenerateMipmap) return false; + internal::glGenFramebuffers = reinterpret_cast(internal::get_proc_address("glGenFramebuffers")); + if (!internal::glGenFramebuffers) return false; + internal::glGenRenderbuffers = reinterpret_cast(internal::get_proc_address("glGenRenderbuffers")); + if (!internal::glGenRenderbuffers) return false; + internal::glGenTextures = reinterpret_cast(internal::get_proc_address("glGenTextures")); + if (!internal::glGenTextures) return false; + internal::glGetActiveAttrib = reinterpret_cast(internal::get_proc_address("glGetActiveAttrib")); + if (!internal::glGetActiveAttrib) return false; + internal::glGetActiveUniform = reinterpret_cast(internal::get_proc_address("glGetActiveUniform")); + if (!internal::glGetActiveUniform) return false; + internal::glGetAttachedShaders = reinterpret_cast(internal::get_proc_address("glGetAttachedShaders")); + if (!internal::glGetAttachedShaders) return false; + internal::glGetAttribLocation = reinterpret_cast(internal::get_proc_address("glGetAttribLocation")); + if (!internal::glGetAttribLocation) return false; + internal::glGetBooleanv = reinterpret_cast(internal::get_proc_address("glGetBooleanv")); + if (!internal::glGetBooleanv) return false; + internal::glGetBufferParameteriv = reinterpret_cast(internal::get_proc_address("glGetBufferParameteriv")); + if (!internal::glGetBufferParameteriv) return false; + internal::glGetError = reinterpret_cast(internal::get_proc_address("glGetError")); + if (!internal::glGetError) return false; + internal::glGetFloatv = reinterpret_cast(internal::get_proc_address("glGetFloatv")); + if (!internal::glGetFloatv) return false; + internal::glGetFramebufferAttachmentParameteriv = reinterpret_cast(internal::get_proc_address("glGetFramebufferAttachmentParameteriv")); + if (!internal::glGetFramebufferAttachmentParameteriv) return false; + internal::glGetIntegerv = reinterpret_cast(internal::get_proc_address("glGetIntegerv")); + if (!internal::glGetIntegerv) return false; + internal::glGetProgramiv = reinterpret_cast(internal::get_proc_address("glGetProgramiv")); + if (!internal::glGetProgramiv) return false; + internal::glGetProgramInfoLog = reinterpret_cast(internal::get_proc_address("glGetProgramInfoLog")); + if (!internal::glGetProgramInfoLog) return false; + internal::glGetRenderbufferParameteriv = reinterpret_cast(internal::get_proc_address("glGetRenderbufferParameteriv")); + if (!internal::glGetRenderbufferParameteriv) return false; + internal::glGetShaderiv = reinterpret_cast(internal::get_proc_address("glGetShaderiv")); + if (!internal::glGetShaderiv) return false; + internal::glGetShaderInfoLog = reinterpret_cast(internal::get_proc_address("glGetShaderInfoLog")); + if (!internal::glGetShaderInfoLog) return false; + internal::glGetShaderPrecisionFormat = reinterpret_cast(internal::get_proc_address("glGetShaderPrecisionFormat")); + if (!internal::glGetShaderPrecisionFormat) return false; + internal::glGetShaderSource = reinterpret_cast(internal::get_proc_address("glGetShaderSource")); + if (!internal::glGetShaderSource) return false; + internal::glGetString = reinterpret_cast(internal::get_proc_address("glGetString")); + if (!internal::glGetString) return false; + internal::glGetTexParameterfv = reinterpret_cast(internal::get_proc_address("glGetTexParameterfv")); + if (!internal::glGetTexParameterfv) return false; + internal::glGetTexParameteriv = reinterpret_cast(internal::get_proc_address("glGetTexParameteriv")); + if (!internal::glGetTexParameteriv) return false; + internal::glGetUniformfv = reinterpret_cast(internal::get_proc_address("glGetUniformfv")); + if (!internal::glGetUniformfv) return false; + internal::glGetUniformiv = reinterpret_cast(internal::get_proc_address("glGetUniformiv")); + if (!internal::glGetUniformiv) return false; + internal::glGetUniformLocation = reinterpret_cast(internal::get_proc_address("glGetUniformLocation")); + if (!internal::glGetUniformLocation) return false; + internal::glGetVertexAttribfv = reinterpret_cast(internal::get_proc_address("glGetVertexAttribfv")); + if (!internal::glGetVertexAttribfv) return false; + internal::glGetVertexAttribiv = reinterpret_cast(internal::get_proc_address("glGetVertexAttribiv")); + if (!internal::glGetVertexAttribiv) return false; + internal::glGetVertexAttribPointerv = reinterpret_cast(internal::get_proc_address("glGetVertexAttribPointerv")); + if (!internal::glGetVertexAttribPointerv) return false; + internal::glHint = reinterpret_cast(internal::get_proc_address("glHint")); + if (!internal::glHint) return false; + internal::glIsBuffer = reinterpret_cast(internal::get_proc_address("glIsBuffer")); + if (!internal::glIsBuffer) return false; + internal::glIsEnabled = reinterpret_cast(internal::get_proc_address("glIsEnabled")); + if (!internal::glIsEnabled) return false; + internal::glIsFramebuffer = reinterpret_cast(internal::get_proc_address("glIsFramebuffer")); + if (!internal::glIsFramebuffer) return false; + internal::glIsProgram = reinterpret_cast(internal::get_proc_address("glIsProgram")); + if (!internal::glIsProgram) return false; + internal::glIsRenderbuffer = reinterpret_cast(internal::get_proc_address("glIsRenderbuffer")); + if (!internal::glIsRenderbuffer) return false; + internal::glIsShader = reinterpret_cast(internal::get_proc_address("glIsShader")); + if (!internal::glIsShader) return false; + internal::glIsTexture = reinterpret_cast(internal::get_proc_address("glIsTexture")); + if (!internal::glIsTexture) return false; + internal::glLineWidth = reinterpret_cast(internal::get_proc_address("glLineWidth")); + if (!internal::glLineWidth) return false; + internal::glLinkProgram = reinterpret_cast(internal::get_proc_address("glLinkProgram")); + if (!internal::glLinkProgram) return false; + internal::glPixelStorei = reinterpret_cast(internal::get_proc_address("glPixelStorei")); + if (!internal::glPixelStorei) return false; + internal::glPolygonOffset = reinterpret_cast(internal::get_proc_address("glPolygonOffset")); + if (!internal::glPolygonOffset) return false; + internal::glReadPixels = reinterpret_cast(internal::get_proc_address("glReadPixels")); + if (!internal::glReadPixels) return false; + internal::glReleaseShaderCompiler = reinterpret_cast(internal::get_proc_address("glReleaseShaderCompiler")); + if (!internal::glReleaseShaderCompiler) return false; + internal::glRenderbufferStorage = reinterpret_cast(internal::get_proc_address("glRenderbufferStorage")); + if (!internal::glRenderbufferStorage) return false; + internal::glSampleCoverage = reinterpret_cast(internal::get_proc_address("glSampleCoverage")); + if (!internal::glSampleCoverage) return false; + internal::glScissor = reinterpret_cast(internal::get_proc_address("glScissor")); + if (!internal::glScissor) return false; + internal::glShaderBinary = reinterpret_cast(internal::get_proc_address("glShaderBinary")); + if (!internal::glShaderBinary) return false; + internal::glShaderSource = reinterpret_cast(internal::get_proc_address("glShaderSource")); + if (!internal::glShaderSource) return false; + internal::glStencilFunc = reinterpret_cast(internal::get_proc_address("glStencilFunc")); + if (!internal::glStencilFunc) return false; + internal::glStencilFuncSeparate = reinterpret_cast(internal::get_proc_address("glStencilFuncSeparate")); + if (!internal::glStencilFuncSeparate) return false; + internal::glStencilMask = reinterpret_cast(internal::get_proc_address("glStencilMask")); + if (!internal::glStencilMask) return false; + internal::glStencilMaskSeparate = reinterpret_cast(internal::get_proc_address("glStencilMaskSeparate")); + if (!internal::glStencilMaskSeparate) return false; + internal::glStencilOp = reinterpret_cast(internal::get_proc_address("glStencilOp")); + if (!internal::glStencilOp) return false; + internal::glStencilOpSeparate = reinterpret_cast(internal::get_proc_address("glStencilOpSeparate")); + if (!internal::glStencilOpSeparate) return false; + internal::glTexImage2D = reinterpret_cast(internal::get_proc_address("glTexImage2D")); + if (!internal::glTexImage2D) return false; + internal::glTexParameterf = reinterpret_cast(internal::get_proc_address("glTexParameterf")); + if (!internal::glTexParameterf) return false; + internal::glTexParameterfv = reinterpret_cast(internal::get_proc_address("glTexParameterfv")); + if (!internal::glTexParameterfv) return false; + internal::glTexParameteri = reinterpret_cast(internal::get_proc_address("glTexParameteri")); + if (!internal::glTexParameteri) return false; + internal::glTexParameteriv = reinterpret_cast(internal::get_proc_address("glTexParameteriv")); + if (!internal::glTexParameteriv) return false; + internal::glTexSubImage2D = reinterpret_cast(internal::get_proc_address("glTexSubImage2D")); + if (!internal::glTexSubImage2D) return false; + internal::glUniform1f = reinterpret_cast(internal::get_proc_address("glUniform1f")); + if (!internal::glUniform1f) return false; + internal::glUniform1fv = reinterpret_cast(internal::get_proc_address("glUniform1fv")); + if (!internal::glUniform1fv) return false; + internal::glUniform1i = reinterpret_cast(internal::get_proc_address("glUniform1i")); + if (!internal::glUniform1i) return false; + internal::glUniform1iv = reinterpret_cast(internal::get_proc_address("glUniform1iv")); + if (!internal::glUniform1iv) return false; + internal::glUniform2f = reinterpret_cast(internal::get_proc_address("glUniform2f")); + if (!internal::glUniform2f) return false; + internal::glUniform2fv = reinterpret_cast(internal::get_proc_address("glUniform2fv")); + if (!internal::glUniform2fv) return false; + internal::glUniform2i = reinterpret_cast(internal::get_proc_address("glUniform2i")); + if (!internal::glUniform2i) return false; + internal::glUniform2iv = reinterpret_cast(internal::get_proc_address("glUniform2iv")); + if (!internal::glUniform2iv) return false; + internal::glUniform3f = reinterpret_cast(internal::get_proc_address("glUniform3f")); + if (!internal::glUniform3f) return false; + internal::glUniform3fv = reinterpret_cast(internal::get_proc_address("glUniform3fv")); + if (!internal::glUniform3fv) return false; + internal::glUniform3i = reinterpret_cast(internal::get_proc_address("glUniform3i")); + if (!internal::glUniform3i) return false; + internal::glUniform3iv = reinterpret_cast(internal::get_proc_address("glUniform3iv")); + if (!internal::glUniform3iv) return false; + internal::glUniform4f = reinterpret_cast(internal::get_proc_address("glUniform4f")); + if (!internal::glUniform4f) return false; + internal::glUniform4fv = reinterpret_cast(internal::get_proc_address("glUniform4fv")); + if (!internal::glUniform4fv) return false; + internal::glUniform4i = reinterpret_cast(internal::get_proc_address("glUniform4i")); + if (!internal::glUniform4i) return false; + internal::glUniform4iv = reinterpret_cast(internal::get_proc_address("glUniform4iv")); + if (!internal::glUniform4iv) return false; + internal::glUniformMatrix2fv = reinterpret_cast(internal::get_proc_address("glUniformMatrix2fv")); + if (!internal::glUniformMatrix2fv) return false; + internal::glUniformMatrix3fv = reinterpret_cast(internal::get_proc_address("glUniformMatrix3fv")); + if (!internal::glUniformMatrix3fv) return false; + internal::glUniformMatrix4fv = reinterpret_cast(internal::get_proc_address("glUniformMatrix4fv")); + if (!internal::glUniformMatrix4fv) return false; + internal::glUseProgram = reinterpret_cast(internal::get_proc_address("glUseProgram")); + if (!internal::glUseProgram) return false; + internal::glValidateProgram = reinterpret_cast(internal::get_proc_address("glValidateProgram")); + if (!internal::glValidateProgram) return false; + internal::glVertexAttrib1f = reinterpret_cast(internal::get_proc_address("glVertexAttrib1f")); + if (!internal::glVertexAttrib1f) return false; + internal::glVertexAttrib1fv = reinterpret_cast(internal::get_proc_address("glVertexAttrib1fv")); + if (!internal::glVertexAttrib1fv) return false; + internal::glVertexAttrib2f = reinterpret_cast(internal::get_proc_address("glVertexAttrib2f")); + if (!internal::glVertexAttrib2f) return false; + internal::glVertexAttrib2fv = reinterpret_cast(internal::get_proc_address("glVertexAttrib2fv")); + if (!internal::glVertexAttrib2fv) return false; + internal::glVertexAttrib3f = reinterpret_cast(internal::get_proc_address("glVertexAttrib3f")); + if (!internal::glVertexAttrib3f) return false; + internal::glVertexAttrib3fv = reinterpret_cast(internal::get_proc_address("glVertexAttrib3fv")); + if (!internal::glVertexAttrib3fv) return false; + internal::glVertexAttrib4f = reinterpret_cast(internal::get_proc_address("glVertexAttrib4f")); + if (!internal::glVertexAttrib4f) return false; + internal::glVertexAttrib4fv = reinterpret_cast(internal::get_proc_address("glVertexAttrib4fv")); + if (!internal::glVertexAttrib4fv) return false; + internal::glVertexAttribPointer = reinterpret_cast(internal::get_proc_address("glVertexAttribPointer")); + if (!internal::glVertexAttribPointer) return false; + internal::glViewport = reinterpret_cast(internal::get_proc_address("glViewport")); + if (!internal::glViewport) return false; + + // OpenGL ES 3.0 + + internal::glReadBuffer = reinterpret_cast(internal::get_proc_address("glReadBuffer")); + if (!internal::glReadBuffer) return false; + internal::glDrawRangeElements = reinterpret_cast(internal::get_proc_address("glDrawRangeElements")); + if (!internal::glDrawRangeElements) return false; + internal::glTexImage3D = reinterpret_cast(internal::get_proc_address("glTexImage3D")); + if (!internal::glTexImage3D) return false; + internal::glTexSubImage3D = reinterpret_cast(internal::get_proc_address("glTexSubImage3D")); + if (!internal::glTexSubImage3D) return false; + internal::glCopyTexSubImage3D = reinterpret_cast(internal::get_proc_address("glCopyTexSubImage3D")); + if (!internal::glCopyTexSubImage3D) return false; + internal::glCompressedTexImage3D = reinterpret_cast(internal::get_proc_address("glCompressedTexImage3D")); + if (!internal::glCompressedTexImage3D) return false; + internal::glCompressedTexSubImage3D = reinterpret_cast(internal::get_proc_address("glCompressedTexSubImage3D")); + if (!internal::glCompressedTexSubImage3D) return false; + internal::glGenQueries = reinterpret_cast(internal::get_proc_address("glGenQueries")); + if (!internal::glGenQueries) return false; + internal::glDeleteQueries = reinterpret_cast(internal::get_proc_address("glDeleteQueries")); + if (!internal::glDeleteQueries) return false; + internal::glIsQuery = reinterpret_cast(internal::get_proc_address("glIsQuery")); + if (!internal::glIsQuery) return false; + internal::glBeginQuery = reinterpret_cast(internal::get_proc_address("glBeginQuery")); + if (!internal::glBeginQuery) return false; + internal::glEndQuery = reinterpret_cast(internal::get_proc_address("glEndQuery")); + if (!internal::glEndQuery) return false; + internal::glGetQueryiv = reinterpret_cast(internal::get_proc_address("glGetQueryiv")); + if (!internal::glGetQueryiv) return false; + internal::glGetQueryObjectuiv = reinterpret_cast(internal::get_proc_address("glGetQueryObjectuiv")); + if (!internal::glGetQueryObjectuiv) return false; + internal::glUnmapBuffer = reinterpret_cast(internal::get_proc_address("glUnmapBuffer")); + if (!internal::glUnmapBuffer) return false; + internal::glGetBufferPointerv = reinterpret_cast(internal::get_proc_address("glGetBufferPointerv")); + if (!internal::glGetBufferPointerv) return false; + internal::glDrawBuffers = reinterpret_cast(internal::get_proc_address("glDrawBuffers")); + if (!internal::glDrawBuffers) return false; + internal::glUniformMatrix2x3fv = reinterpret_cast(internal::get_proc_address("glUniformMatrix2x3fv")); + if (!internal::glUniformMatrix2x3fv) return false; + internal::glUniformMatrix3x2fv = reinterpret_cast(internal::get_proc_address("glUniformMatrix3x2fv")); + if (!internal::glUniformMatrix3x2fv) return false; + internal::glUniformMatrix2x4fv = reinterpret_cast(internal::get_proc_address("glUniformMatrix2x4fv")); + if (!internal::glUniformMatrix2x4fv) return false; + internal::glUniformMatrix4x2fv = reinterpret_cast(internal::get_proc_address("glUniformMatrix4x2fv")); + if (!internal::glUniformMatrix4x2fv) return false; + internal::glUniformMatrix3x4fv = reinterpret_cast(internal::get_proc_address("glUniformMatrix3x4fv")); + if (!internal::glUniformMatrix3x4fv) return false; + internal::glUniformMatrix4x3fv = reinterpret_cast(internal::get_proc_address("glUniformMatrix4x3fv")); + if (!internal::glUniformMatrix4x3fv) return false; + internal::glBlitFramebuffer = reinterpret_cast(internal::get_proc_address("glBlitFramebuffer")); + if (!internal::glBlitFramebuffer) return false; + internal::glRenderbufferStorageMultisample = reinterpret_cast(internal::get_proc_address("glRenderbufferStorageMultisample")); + if (!internal::glRenderbufferStorageMultisample) return false; + internal::glFramebufferTextureLayer = reinterpret_cast(internal::get_proc_address("glFramebufferTextureLayer")); + if (!internal::glFramebufferTextureLayer) return false; + internal::glMapBufferRange = reinterpret_cast(internal::get_proc_address("glMapBufferRange")); + if (!internal::glMapBufferRange) return false; + internal::glFlushMappedBufferRange = reinterpret_cast(internal::get_proc_address("glFlushMappedBufferRange")); + if (!internal::glFlushMappedBufferRange) return false; + internal::glBindVertexArray = reinterpret_cast(internal::get_proc_address("glBindVertexArray")); + if (!internal::glBindVertexArray) return false; + internal::glDeleteVertexArrays = reinterpret_cast(internal::get_proc_address("glDeleteVertexArrays")); + if (!internal::glDeleteVertexArrays) return false; + internal::glGenVertexArrays = reinterpret_cast(internal::get_proc_address("glGenVertexArrays")); + if (!internal::glGenVertexArrays) return false; + internal::glIsVertexArray = reinterpret_cast(internal::get_proc_address("glIsVertexArray")); + if (!internal::glIsVertexArray) return false; + internal::glGetIntegeri_v = reinterpret_cast(internal::get_proc_address("glGetIntegeri_v")); + if (!internal::glGetIntegeri_v) return false; + internal::glBeginTransformFeedback = reinterpret_cast(internal::get_proc_address("glBeginTransformFeedback")); + if (!internal::glBeginTransformFeedback) return false; + internal::glEndTransformFeedback = reinterpret_cast(internal::get_proc_address("glEndTransformFeedback")); + if (!internal::glEndTransformFeedback) return false; + internal::glBindBufferRange = reinterpret_cast(internal::get_proc_address("glBindBufferRange")); + if (!internal::glBindBufferRange) return false; + internal::glBindBufferBase = reinterpret_cast(internal::get_proc_address("glBindBufferBase")); + if (!internal::glBindBufferBase) return false; + internal::glTransformFeedbackVaryings = reinterpret_cast(internal::get_proc_address("glTransformFeedbackVaryings")); + if (!internal::glTransformFeedbackVaryings) return false; + internal::glGetTransformFeedbackVarying = reinterpret_cast(internal::get_proc_address("glGetTransformFeedbackVarying")); + if (!internal::glGetTransformFeedbackVarying) return false; + internal::glVertexAttribIPointer = reinterpret_cast(internal::get_proc_address("glVertexAttribIPointer")); + if (!internal::glVertexAttribIPointer) return false; + internal::glGetVertexAttribIiv = reinterpret_cast(internal::get_proc_address("glGetVertexAttribIiv")); + if (!internal::glGetVertexAttribIiv) return false; + internal::glGetVertexAttribIuiv = reinterpret_cast(internal::get_proc_address("glGetVertexAttribIuiv")); + if (!internal::glGetVertexAttribIuiv) return false; + internal::glVertexAttribI4i = reinterpret_cast(internal::get_proc_address("glVertexAttribI4i")); + if (!internal::glVertexAttribI4i) return false; + internal::glVertexAttribI4ui = reinterpret_cast(internal::get_proc_address("glVertexAttribI4ui")); + if (!internal::glVertexAttribI4ui) return false; + internal::glVertexAttribI4iv = reinterpret_cast(internal::get_proc_address("glVertexAttribI4iv")); + if (!internal::glVertexAttribI4iv) return false; + internal::glVertexAttribI4uiv = reinterpret_cast(internal::get_proc_address("glVertexAttribI4uiv")); + if (!internal::glVertexAttribI4uiv) return false; + internal::glGetUniformuiv = reinterpret_cast(internal::get_proc_address("glGetUniformuiv")); + if (!internal::glGetUniformuiv) return false; + internal::glGetFragDataLocation = reinterpret_cast(internal::get_proc_address("glGetFragDataLocation")); + if (!internal::glGetFragDataLocation) return false; + internal::glUniform1ui = reinterpret_cast(internal::get_proc_address("glUniform1ui")); + if (!internal::glUniform1ui) return false; + internal::glUniform2ui = reinterpret_cast(internal::get_proc_address("glUniform2ui")); + if (!internal::glUniform2ui) return false; + internal::glUniform3ui = reinterpret_cast(internal::get_proc_address("glUniform3ui")); + if (!internal::glUniform3ui) return false; + internal::glUniform4ui = reinterpret_cast(internal::get_proc_address("glUniform4ui")); + if (!internal::glUniform4ui) return false; + internal::glUniform1uiv = reinterpret_cast(internal::get_proc_address("glUniform1uiv")); + if (!internal::glUniform1uiv) return false; + internal::glUniform2uiv = reinterpret_cast(internal::get_proc_address("glUniform2uiv")); + if (!internal::glUniform2uiv) return false; + internal::glUniform3uiv = reinterpret_cast(internal::get_proc_address("glUniform3uiv")); + if (!internal::glUniform3uiv) return false; + internal::glUniform4uiv = reinterpret_cast(internal::get_proc_address("glUniform4uiv")); + if (!internal::glUniform4uiv) return false; + internal::glClearBufferiv = reinterpret_cast(internal::get_proc_address("glClearBufferiv")); + if (!internal::glClearBufferiv) return false; + internal::glClearBufferuiv = reinterpret_cast(internal::get_proc_address("glClearBufferuiv")); + if (!internal::glClearBufferuiv) return false; + internal::glClearBufferfv = reinterpret_cast(internal::get_proc_address("glClearBufferfv")); + if (!internal::glClearBufferfv) return false; + internal::glClearBufferfi = reinterpret_cast(internal::get_proc_address("glClearBufferfi")); + if (!internal::glClearBufferfi) return false; + internal::glGetStringi = reinterpret_cast(internal::get_proc_address("glGetStringi")); + if (!internal::glGetStringi) return false; + internal::glCopyBufferSubData = reinterpret_cast(internal::get_proc_address("glCopyBufferSubData")); + if (!internal::glCopyBufferSubData) return false; + internal::glGetUniformIndices = reinterpret_cast(internal::get_proc_address("glGetUniformIndices")); + if (!internal::glGetUniformIndices) return false; + internal::glGetActiveUniformsiv = reinterpret_cast(internal::get_proc_address("glGetActiveUniformsiv")); + if (!internal::glGetActiveUniformsiv) return false; + internal::glGetUniformBlockIndex = reinterpret_cast(internal::get_proc_address("glGetUniformBlockIndex")); + if (!internal::glGetUniformBlockIndex) return false; + internal::glGetActiveUniformBlockiv = reinterpret_cast(internal::get_proc_address("glGetActiveUniformBlockiv")); + if (!internal::glGetActiveUniformBlockiv) return false; + internal::glGetActiveUniformBlockName = reinterpret_cast(internal::get_proc_address("glGetActiveUniformBlockName")); + if (!internal::glGetActiveUniformBlockName) return false; + internal::glUniformBlockBinding = reinterpret_cast(internal::get_proc_address("glUniformBlockBinding")); + if (!internal::glUniformBlockBinding) return false; + internal::glDrawArraysInstanced = reinterpret_cast(internal::get_proc_address("glDrawArraysInstanced")); + if (!internal::glDrawArraysInstanced) return false; + internal::glDrawElementsInstanced = reinterpret_cast(internal::get_proc_address("glDrawElementsInstanced")); + if (!internal::glDrawElementsInstanced) return false; + internal::glFenceSync = reinterpret_cast(internal::get_proc_address("glFenceSync")); + if (!internal::glFenceSync) return false; + internal::glIsSync = reinterpret_cast(internal::get_proc_address("glIsSync")); + if (!internal::glIsSync) return false; + internal::glDeleteSync = reinterpret_cast(internal::get_proc_address("glDeleteSync")); + if (!internal::glDeleteSync) return false; + internal::glClientWaitSync = reinterpret_cast(internal::get_proc_address("glClientWaitSync")); + if (!internal::glClientWaitSync) return false; + internal::glWaitSync = reinterpret_cast(internal::get_proc_address("glWaitSync")); + if (!internal::glWaitSync) return false; + internal::glGetInteger64v = reinterpret_cast(internal::get_proc_address("glGetInteger64v")); + if (!internal::glGetInteger64v) return false; + internal::glGetSynciv = reinterpret_cast(internal::get_proc_address("glGetSynciv")); + if (!internal::glGetSynciv) return false; + internal::glGetInteger64i_v = reinterpret_cast(internal::get_proc_address("glGetInteger64i_v")); + if (!internal::glGetInteger64i_v) return false; + internal::glGetBufferParameteri64v = reinterpret_cast(internal::get_proc_address("glGetBufferParameteri64v")); + if (!internal::glGetBufferParameteri64v) return false; + internal::glGenSamplers = reinterpret_cast(internal::get_proc_address("glGenSamplers")); + if (!internal::glGenSamplers) return false; + internal::glDeleteSamplers = reinterpret_cast(internal::get_proc_address("glDeleteSamplers")); + if (!internal::glDeleteSamplers) return false; + internal::glIsSampler = reinterpret_cast(internal::get_proc_address("glIsSampler")); + if (!internal::glIsSampler) return false; + internal::glBindSampler = reinterpret_cast(internal::get_proc_address("glBindSampler")); + if (!internal::glBindSampler) return false; + internal::glSamplerParameteri = reinterpret_cast(internal::get_proc_address("glSamplerParameteri")); + if (!internal::glSamplerParameteri) return false; + internal::glSamplerParameteriv = reinterpret_cast(internal::get_proc_address("glSamplerParameteriv")); + if (!internal::glSamplerParameteriv) return false; + internal::glSamplerParameterf = reinterpret_cast(internal::get_proc_address("glSamplerParameterf")); + if (!internal::glSamplerParameterf) return false; + internal::glSamplerParameterfv = reinterpret_cast(internal::get_proc_address("glSamplerParameterfv")); + if (!internal::glSamplerParameterfv) return false; + internal::glGetSamplerParameteriv = reinterpret_cast(internal::get_proc_address("glGetSamplerParameteriv")); + if (!internal::glGetSamplerParameteriv) return false; + internal::glGetSamplerParameterfv = reinterpret_cast(internal::get_proc_address("glGetSamplerParameterfv")); + if (!internal::glGetSamplerParameterfv) return false; + internal::glVertexAttribDivisor = reinterpret_cast(internal::get_proc_address("glVertexAttribDivisor")); + if (!internal::glVertexAttribDivisor) return false; + internal::glBindTransformFeedback = reinterpret_cast(internal::get_proc_address("glBindTransformFeedback")); + if (!internal::glBindTransformFeedback) return false; + internal::glDeleteTransformFeedbacks = reinterpret_cast(internal::get_proc_address("glDeleteTransformFeedbacks")); + if (!internal::glDeleteTransformFeedbacks) return false; + internal::glGenTransformFeedbacks = reinterpret_cast(internal::get_proc_address("glGenTransformFeedbacks")); + if (!internal::glGenTransformFeedbacks) return false; + internal::glIsTransformFeedback = reinterpret_cast(internal::get_proc_address("glIsTransformFeedback")); + if (!internal::glIsTransformFeedback) return false; + internal::glPauseTransformFeedback = reinterpret_cast(internal::get_proc_address("glPauseTransformFeedback")); + if (!internal::glPauseTransformFeedback) return false; + internal::glResumeTransformFeedback = reinterpret_cast(internal::get_proc_address("glResumeTransformFeedback")); + if (!internal::glResumeTransformFeedback) return false; + internal::glGetProgramBinary = reinterpret_cast(internal::get_proc_address("glGetProgramBinary")); + if (!internal::glGetProgramBinary) return false; + internal::glProgramBinary = reinterpret_cast(internal::get_proc_address("glProgramBinary")); + if (!internal::glProgramBinary) return false; + internal::glProgramParameteri = reinterpret_cast(internal::get_proc_address("glProgramParameteri")); + if (!internal::glProgramParameteri) return false; + internal::glInvalidateFramebuffer = reinterpret_cast(internal::get_proc_address("glInvalidateFramebuffer")); + if (!internal::glInvalidateFramebuffer) return false; + internal::glInvalidateSubFramebuffer = reinterpret_cast(internal::get_proc_address("glInvalidateSubFramebuffer")); + if (!internal::glInvalidateSubFramebuffer) return false; + internal::glTexStorage2D = reinterpret_cast(internal::get_proc_address("glTexStorage2D")); + if (!internal::glTexStorage2D) return false; + internal::glTexStorage3D = reinterpret_cast(internal::get_proc_address("glTexStorage3D")); + if (!internal::glTexStorage3D) return false; + internal::glGetInternalformativ = reinterpret_cast(internal::get_proc_address("glGetInternalformativ")); + if (!internal::glGetInternalformativ) return false; + + return true; + } + + static bool load_ext_GL_EXT_texture_filter_anisotropic() + { + + return true; + } + + static std::unordered_set extensions; + bool initialize() + { + if (!load_core()) return false; + + GLint num_extensions; + internal::glGetIntegerv(0x821D, &num_extensions); + for (GLint i = 0; i < num_extensions; ++i) + extensions.insert(reinterpret_cast(internal::glGetStringi(0x1F03, i))); + + if (extensions.count("GL_EXT_texture_filter_anisotropic") > 0) + ext_GL_EXT_texture_filter_anisotropic_loaded = load_ext_GL_EXT_texture_filter_anisotropic(); + + return true; + } + + const char * api(){ return "OpenGL ES"; } + + int major_version(){ return 3; } + + int minor_version(){ return 0; } + + bool has_extension(const char * name){ return extensions.contains(name); } + + bool ext_EXT_texture_filter_anisotropic(){ return ext_GL_EXT_texture_filter_anisotropic_loaded; } + + const char * shader_prefix() + { + return R"(#version 300 es + +precision highp int; +precision highp float; +precision highp sampler2D; +precision highp usampler2D; + +)"; + } + + } // namespace sys + +} // namespace gl + diff --git a/libs/gfx/api/gles32/source/gl.cpp b/libs/gfx/api/gles32/source/gl.cpp index 14269da1..8d5f7cea 100644 --- a/libs/gfx/api/gles32/source/gl.cpp +++ b/libs/gfx/api/gles32/source/gl.cpp @@ -803,12 +803,10 @@ namespace gl if (!internal::glGetQueryiv) return false; internal::glGetQueryObjectuiv = reinterpret_cast(internal::get_proc_address("glGetQueryObjectuiv")); if (!internal::glGetQueryObjectuiv) return false; -#if !defined(__EMSCRIPTEN__) internal::glUnmapBuffer = reinterpret_cast(internal::get_proc_address("glUnmapBuffer")); if (!internal::glUnmapBuffer) return false; internal::glGetBufferPointerv = reinterpret_cast(internal::get_proc_address("glGetBufferPointerv")); if (!internal::glGetBufferPointerv) return false; -#endif internal::glDrawBuffers = reinterpret_cast(internal::get_proc_address("glDrawBuffers")); if (!internal::glDrawBuffers) return false; internal::glUniformMatrix2x3fv = reinterpret_cast(internal::get_proc_address("glUniformMatrix2x3fv")); @@ -829,12 +827,10 @@ namespace gl if (!internal::glRenderbufferStorageMultisample) return false; internal::glFramebufferTextureLayer = reinterpret_cast(internal::get_proc_address("glFramebufferTextureLayer")); if (!internal::glFramebufferTextureLayer) return false; -#if !defined(__EMSCRIPTEN__) internal::glMapBufferRange = reinterpret_cast(internal::get_proc_address("glMapBufferRange")); if (!internal::glMapBufferRange) return false; internal::glFlushMappedBufferRange = reinterpret_cast(internal::get_proc_address("glFlushMappedBufferRange")); if (!internal::glFlushMappedBufferRange) return false; -#endif internal::glBindVertexArray = reinterpret_cast(internal::get_proc_address("glBindVertexArray")); if (!internal::glBindVertexArray) return false; internal::glDeleteVertexArrays = reinterpret_cast(internal::get_proc_address("glDeleteVertexArrays")); @@ -988,10 +984,6 @@ namespace gl internal::glGetInternalformativ = reinterpret_cast(internal::get_proc_address("glGetInternalformativ")); if (!internal::glGetInternalformativ) return false; -#if defined(__EMSCRIPTEN__) - return true; -#endif - // OpenGL ES 3.1 internal::glDispatchCompute = reinterpret_cast(internal::get_proc_address("glDispatchCompute")); @@ -1267,13 +1259,7 @@ namespace gl int major_version(){ return 3; } - int minor_version(){ -#if defined(__EMSCRIPTEN__) - return 0; -#else - return 2; -#endif - } + int minor_version(){ return 2; } bool has_extension(const char * name){ return extensions.contains(name); } @@ -1283,16 +1269,6 @@ namespace gl const char * shader_prefix() { -#if defined(__EMSCRIPTEN__) - return R"(#version 300 es - -precision highp int; -precision highp float; -precision highp sampler2D; -precision highp usampler2D; - -)"; -#else return R"(#version 320 es precision highp int; @@ -1301,7 +1277,6 @@ precision highp sampler2D; precision highp usampler2D; )"; -#endif } } // namespace sys diff --git a/libs/gfx/gl-loader-generator-config-gles30-emscripten.json b/libs/gfx/gl-loader-generator-config-gles30-emscripten.json new file mode 100644 index 00000000..c639f5ec --- /dev/null +++ b/libs/gfx/gl-loader-generator-config-gles30-emscripten.json @@ -0,0 +1,19 @@ +{ + "spec_file": "gl.xml", + "api": "gles2", + "version": "3.0", + "profile": "core", + "extensions": [ + "EXT_texture_filter_anisotropic" + ], + "indent": "\t", + "namespace": "gl", + "loader_namespace": "sys", + "internal_namespace": "internal", + "internal_prefix": "", + "undef": 4, + "strip": true, + "out_header": "gl.hpp", + "out_source": "gl.cpp", + "include": "" +} -- 2.45.3 From 2e94515c050ab2124370e799f72252ad1a2f3b7f Mon Sep 17 00:00:00 2001 From: yulya3102 Date: Fri, 3 Jul 2026 20:24:56 +0200 Subject: [PATCH 7/8] Disable parts of gfx library on web --- libs/gfx/include/psemek/gfx/buffer.hpp | 2 ++ libs/gfx/include/psemek/gfx/texture.hpp | 4 ++++ 2 files changed, 6 insertions(+) diff --git a/libs/gfx/include/psemek/gfx/buffer.hpp b/libs/gfx/include/psemek/gfx/buffer.hpp index 4a56db41..e75d8d42 100644 --- a/libs/gfx/include/psemek/gfx/buffer.hpp +++ b/libs/gfx/include/psemek/gfx/buffer.hpp @@ -153,6 +153,7 @@ namespace psemek::gfx return size_; } +#ifndef __EMSCRIPTEN__ template std::shared_ptr map(GLbitfield access) { @@ -167,6 +168,7 @@ namespace psemek::gfx mapped_ = p; return p; } +#endif private: GLuint id_ = 0; diff --git a/libs/gfx/include/psemek/gfx/texture.hpp b/libs/gfx/include/psemek/gfx/texture.hpp index de20fa8f..5f86d714 100644 --- a/libs/gfx/include/psemek/gfx/texture.hpp +++ b/libs/gfx/include/psemek/gfx/texture.hpp @@ -215,6 +215,7 @@ namespace psemek::gfx }; #endif +#ifndef PSEMEK_GLES struct buffer_texture { buffer_texture(); @@ -248,6 +249,7 @@ namespace psemek::gfx explicit buffer_texture(std::nullptr_t); }; +#endif namespace detail { @@ -543,6 +545,7 @@ namespace psemek::gfx } #endif +#ifndef PSEMEK_GLES inline buffer_texture::buffer_texture() { gl::GenTextures(1, &id_); @@ -609,6 +612,7 @@ namespace psemek::gfx inline buffer_texture::buffer_texture(std::nullptr_t) : id_(0) {} +#endif template std::size_t mipmap_count(math::vector const & size) -- 2.45.3 From 4d7926b698fd7beef22105259bb0e9899f2ce061 Mon Sep 17 00:00:00 2001 From: lisyarus Date: Fri, 3 Jul 2026 22:29:58 +0300 Subject: [PATCH 8/8] Final Emscripten OpenGL fixes --- .../include/psemek/gfx/gl.hpp | 4 +-- libs/gfx/api/gles30-emscripten/source/gl.cpp | 28 +++++++++++++------ libs/gfx/include/psemek/gfx/framebuffer.hpp | 6 ++++ libs/gfx/include/psemek/gfx/program.hpp | 5 +++- libs/gfx/source/framebuffer.cpp | 6 ++++ libs/gfx/source/painter.cpp | 5 +--- libs/gfx/source/program.cpp | 12 ++++---- libs/gfx/source/texture.cpp | 4 +++ 8 files changed, 49 insertions(+), 21 deletions(-) diff --git a/libs/gfx/api/gles30-emscripten/include/psemek/gfx/gl.hpp b/libs/gfx/api/gles30-emscripten/include/psemek/gfx/gl.hpp index 08bf384e..0d208f26 100644 --- a/libs/gfx/api/gles30-emscripten/include/psemek/gfx/gl.hpp +++ b/libs/gfx/api/gles30-emscripten/include/psemek/gfx/gl.hpp @@ -1288,8 +1288,8 @@ namespace gl // GL_EXT_texture_filter_anisotropic - constexpr GLenum TEXTURE_MAX_ANISOTROPY_EXT = 0x84FE; - constexpr GLenum MAX_TEXTURE_MAX_ANISOTROPY_EXT = 0x84FF; + constexpr GLenum TEXTURE_MAX_ANISOTROPY = 0x84FE; + constexpr GLenum MAX_TEXTURE_MAX_ANISOTROPY = 0x84FF; namespace sys diff --git a/libs/gfx/api/gles30-emscripten/source/gl.cpp b/libs/gfx/api/gles30-emscripten/source/gl.cpp index 2cef2465..a422f863 100644 --- a/libs/gfx/api/gles30-emscripten/source/gl.cpp +++ b/libs/gfx/api/gles30-emscripten/source/gl.cpp @@ -11,6 +11,9 @@ #include #elif defined(_WIN32) #include +#elif defined(__EMSCRIPTEN__) +#include +#include #else #include #endif @@ -77,7 +80,14 @@ namespace gl return reinterpret_cast(GetProcAddress(image, reinterpret_cast(name))); } - + + #elif defined(__EMSCRIPTEN__) + + static void * get_proc_address(const char *func) + { + return reinterpret_cast(eglGetProcAddress(func)); + } + #else // GLX static void * get_proc_address(const char *func) @@ -886,14 +896,14 @@ namespace gl const char * shader_prefix() { - return R"(#version 300 es - -precision highp int; -precision highp float; -precision highp sampler2D; -precision highp usampler2D; - -)"; + return R"(#version 300 es + +precision highp int; +precision highp float; +precision highp sampler2D; +precision highp usampler2D; + +)"; } } // namespace sys diff --git a/libs/gfx/include/psemek/gfx/framebuffer.hpp b/libs/gfx/include/psemek/gfx/framebuffer.hpp index abc27ff3..f4f69da6 100644 --- a/libs/gfx/include/psemek/gfx/framebuffer.hpp +++ b/libs/gfx/include/psemek/gfx/framebuffer.hpp @@ -34,17 +34,23 @@ namespace psemek::gfx void color(texture_2d const & tex, int attachment = 0); void color(texture_2d_array const & tex, int layer, int attachment = 0); +#ifndef __EMSCRIPTEN__ void color(texture_cubemap const & tex, int attachment = 0); +#endif void color(texture_cubemap const & tex, int face, int attachment = 0); void color(renderbuffer const & rb, int attachment = 0); void depth(texture_2d const & tex); void depth(texture_2d_array const & tex, int layer); +#ifndef __EMSCRIPTEN__ void depth(texture_cubemap const & tex); +#endif void depth(texture_cubemap const & tex, int face); void depth(renderbuffer const & rb); void depth_stencil(texture_2d const & tex); void depth_stencil(texture_2d_array const & tex, int layer); +#ifndef __EMSCRIPTEN__ void depth_stencil(texture_cubemap const & tex); +#endif void depth_stencil(texture_cubemap const & tex, int face); void depth_stencil(renderbuffer const & rb); diff --git a/libs/gfx/include/psemek/gfx/program.hpp b/libs/gfx/include/psemek/gfx/program.hpp index 08136ce8..2b6774ba 100644 --- a/libs/gfx/include/psemek/gfx/program.hpp +++ b/libs/gfx/include/psemek/gfx/program.hpp @@ -16,9 +16,12 @@ namespace psemek::gfx struct program { - program(std::string_view compute_source); program(std::string_view vertex_source, std::string_view fragment_source); + +#ifndef __EMSCRIPTEN__ + program(std::string_view compute_source); program(std::string_view vertex_source, std::string_view geometry_source, std::string_view fragment_source); +#endif program(program && other); diff --git a/libs/gfx/source/framebuffer.cpp b/libs/gfx/source/framebuffer.cpp index d3cb3f4c..811c4c52 100644 --- a/libs/gfx/source/framebuffer.cpp +++ b/libs/gfx/source/framebuffer.cpp @@ -102,11 +102,13 @@ namespace psemek::gfx gl::FramebufferTextureLayer(gl::DRAW_FRAMEBUFFER, gl::COLOR_ATTACHMENT0 + attachment, tex.id(), 0, layer); } +#ifndef __EMSCRIPTEN__ void framebuffer::color(texture_cubemap const & tex, int attachment) { bind(); gl::FramebufferTexture(gl::DRAW_FRAMEBUFFER, gl::COLOR_ATTACHMENT0 + attachment, tex.id(), 0); } +#endif void framebuffer::color(texture_cubemap const & tex, int face, int attachment) { @@ -140,11 +142,13 @@ namespace psemek::gfx gl::FramebufferTextureLayer(gl::DRAW_FRAMEBUFFER, gl::DEPTH_ATTACHMENT, tex.id(), 0, layer); } +#ifndef __EMSCRIPTEN__ void framebuffer::depth(texture_cubemap const & tex) { bind(); gl::FramebufferTexture(gl::DRAW_FRAMEBUFFER, gl::DEPTH_ATTACHMENT, tex.id(), 0); } +#endif void framebuffer::depth(texture_cubemap const & tex, int face) { @@ -178,11 +182,13 @@ namespace psemek::gfx gl::FramebufferTextureLayer(gl::DRAW_FRAMEBUFFER, gl::DEPTH_STENCIL_ATTACHMENT, tex.id(), 0, layer); } +#ifndef __EMSCRIPTEN__ void framebuffer::depth_stencil(texture_cubemap const & tex) { bind(); gl::FramebufferTexture(gl::DRAW_FRAMEBUFFER, gl::DEPTH_STENCIL_ATTACHMENT, tex.id(), 0); } +#endif void framebuffer::depth_stencil(texture_cubemap const & tex, int face) { diff --git a/libs/gfx/source/painter.cpp b/libs/gfx/source/painter.cpp index 28bbac6d..2295192a 100644 --- a/libs/gfx/source/painter.cpp +++ b/libs/gfx/source/painter.cpp @@ -67,7 +67,7 @@ out vec4 out_color; void main() { - out_color = color * texture(u_texture, texcoord); + out_color = color * vec4(vec3(1.0), texture(u_texture, texcoord).r); } )"; @@ -164,9 +164,6 @@ namespace psemek::gfx font_texture.load(gfx::read_image(io::memory_istream{resource::font_9x12_png.data})); font_texture.bind(); - gl::TexParameteri(gl::TEXTURE_2D, gl::TEXTURE_SWIZZLE_G, gl::RED); - gl::TexParameteri(gl::TEXTURE_2D, gl::TEXTURE_SWIZZLE_B, gl::RED); - gl::TexParameteri(gl::TEXTURE_2D, gl::TEXTURE_SWIZZLE_A, gl::RED); gl::TexParameteri(gl::TEXTURE_2D, gl::TEXTURE_MAG_FILTER, gl::NEAREST); gl::TexParameteri(gl::TEXTURE_2D, gl::TEXTURE_MIN_FILTER, gl::NEAREST); gl::TexParameteri(gl::TEXTURE_2D, gl::TEXTURE_WRAP_S, gl::CLAMP_TO_EDGE); diff --git a/libs/gfx/source/program.cpp b/libs/gfx/source/program.cpp index a092048a..a0d39c27 100644 --- a/libs/gfx/source/program.cpp +++ b/libs/gfx/source/program.cpp @@ -313,20 +313,22 @@ namespace psemek::gfx return program; } - program::program(std::string_view compute_source) - { - program_ = create_program({{gl::COMPUTE_SHADER, compute_source}}); - } - program::program(std::string_view vertex_source, std::string_view fragment_source) { program_ = create_program({{gl::VERTEX_SHADER, vertex_source}, {gl::FRAGMENT_SHADER, fragment_source}}); } +#ifndef __EMSCRIPTEN__ + program::program(std::string_view compute_source) + { + program_ = create_program({{gl::COMPUTE_SHADER, compute_source}}); + } + program::program(std::string_view vertex_source, std::string_view geometry_source, std::string_view fragment_source) { program_ = create_program({{gl::VERTEX_SHADER, vertex_source}, {gl::GEOMETRY_SHADER, geometry_source}, {gl::FRAGMENT_SHADER, fragment_source}}); } +#endif program::program(program && other) : program_(other.program_) diff --git a/libs/gfx/source/texture.cpp b/libs/gfx/source/texture.cpp index feac9408..6297c35e 100644 --- a/libs/gfx/source/texture.cpp +++ b/libs/gfx/source/texture.cpp @@ -19,7 +19,11 @@ namespace psemek::gfx static std::optional get_max_anisotropy() { +#ifdef __EMSCRIPTEN__ + if (!gl::sys::ext_EXT_texture_filter_anisotropic()) return std::nullopt; +#else if (!gl::sys::ext_ARB_texture_filter_anisotropic()) return std::nullopt; +#endif float level; gl::GetFloatv(gl::MAX_TEXTURE_MAX_ANISOTROPY, &level); -- 2.45.3