[telegram-desktop/el7: 2/2] Updated to 1.0.35.
by Vitaly Zaitsev
commit 746dab84d7f08172c202bd062484f8757eed2530
Author: Vitaly Zaitsev <vitaly(a)easycoding.org>
Date: Sun Apr 30 23:41:48 2017 +0500
Updated to 1.0.35.
.gitignore | 1 +
fix_build_under_fedora.patch | 8 ++++----
sources | 2 +-
telegram-desktop.spec | 7 +++++--
4 files changed, 11 insertions(+), 7 deletions(-)
---
diff --git a/.gitignore b/.gitignore
index bc194a1..7516b8e 100644
--- a/.gitignore
+++ b/.gitignore
@@ -4,3 +4,4 @@
/variant-916139a.tar.gz
/tdesktop-1.0.33.tar.gz
/tdesktop-1.0.34.tar.gz
+/tdesktop-1.0.35.tar.gz
diff --git a/fix_build_under_fedora.patch b/fix_build_under_fedora.patch
index 540580c..11f1a55 100644
--- a/fix_build_under_fedora.patch
+++ b/fix_build_under_fedora.patch
@@ -1,4 +1,4 @@
-From 3d25af45a3f72a18ea6391ebe84d570d779e9958 Mon Sep 17 00:00:00 2001
+From c477e7a08c753247b78d28fdf7bda64690411a09 Mon Sep 17 00:00:00 2001
From: Vitaly Zaitsev <vitaly(a)easycoding.org>
Date: Fri, 31 Mar 2017 14:29:58 +0200
Subject: [PATCH] Fixed build under Fedora using rpmbuild and mock.
@@ -168,7 +168,7 @@ index 1d4896a..f2f876b 100644
-Q_IMPORT_PLUGIN(QFcitxPlatformInputContextPlugin)
#endif // Q_OS_WIN | Q_OS_MAC | Q_OS_LINUX
diff --git a/Telegram/SourceFiles/ui/text/text.cpp b/Telegram/SourceFiles/ui/text/text.cpp
-index 089a17f..a3b979c 100644
+index dbc2b0d..61fa93c 100644
--- a/Telegram/SourceFiles/ui/text/text.cpp
+++ b/Telegram/SourceFiles/ui/text/text.cpp
@@ -1692,11 +1692,11 @@ private:
@@ -200,10 +200,10 @@ index f89644e..35230cf 100644
layout.createLine();
diff --git a/Telegram/SourceFiles/ui/twidget.cpp b/Telegram/SourceFiles/ui/twidget.cpp
-index abfcd27..1e1049b 100644
+index 5162ac9..0acc77b 100644
--- a/Telegram/SourceFiles/ui/twidget.cpp
+++ b/Telegram/SourceFiles/ui/twidget.cpp
-@@ -107,9 +107,9 @@ void sendSynteticMouseEvent(QWidget *widget, QEvent::Type type, Qt::MouseButton
+@@ -187,9 +187,9 @@ void sendSynteticMouseEvent(QWidget *widget, QEvent::Type type, Qt::MouseButton
, button
, QGuiApplication::mouseButtons() | button
, QGuiApplication::keyboardModifiers()
diff --git a/sources b/sources
index e54ed44..9e2dacf 100644
--- a/sources
+++ b/sources
@@ -1,4 +1,4 @@
1ac9a7ddda444ccaa53f26887dd07700 GSL-3819df6.tar.gz
48687b677c5724aa513278672d6e674b gyp-a7055b3.tar.gz
-583f345ee0a9d0e9fcc9dee3d64679b5 tdesktop-1.0.34.tar.gz
+8fbb8870d6b8fb84e5715023f938dc99 tdesktop-1.0.35.tar.gz
8cb2c878f46705b0295f77e9f1a8890c variant-916139a.tar.gz
diff --git a/telegram-desktop.spec b/telegram-desktop.spec
index 7ebda1b..c8460e1 100644
--- a/telegram-desktop.spec
+++ b/telegram-desktop.spec
@@ -15,8 +15,8 @@
Summary: Telegram is a new era of messaging
Name: telegram-desktop
-Version: 1.0.34
-Release: 2%{?dist}
+Version: 1.0.35
+Release: 1%{?dist}
# Application and 3rd-party modules licensing:
# * S0 (Telegram Desktop) - GPLv3+ with OpenSSL exception -- main source;
@@ -207,6 +207,9 @@ fi
%{_datadir}/appdata/%{name}.appdata.xml
%changelog
+* Sun Apr 30 2017 Vitaly Zaitsev <vitaly(a)easycoding.org> - 1.0.35-1
+- Updated to 1.0.35 (alpha).
+
* Sun Apr 30 2017 Leigh Scott <leigh123linux(a)googlemail.com> - 1.0.34-2
- Rebuild for ffmpeg update
7 years, 7 months
[lives] Add patch for removing GLee dependency
by Antonio
commit 6be8063ed205afcd09557a86d69b4785ef2d20ce
Author: sagitter <sagitter(a)fedoraproject.org>
Date: Sun Apr 30 17:13:38 2017 +0200
Add patch for removing GLee dependency
lives-2620.patch | 9003 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
lives.spec | 13 +-
2 files changed, 9012 insertions(+), 4 deletions(-)
---
diff --git a/lives-2620.patch b/lives-2620.patch
new file mode 100644
index 0000000..4756435
--- /dev/null
+++ b/lives-2620.patch
@@ -0,0 +1,9003 @@
+Index: configure.ac
+===================================================================
+--- configure.ac (revision 2619)
++++ configure.ac (revision 2620)
+@@ -606,38 +606,6 @@
+
+
+
+-dnl check for GLee
+-
+-HAVE_GLEE=false
+-AC_MSG_CHECKING(for GLee)
+-AC_CHECK_HEADERS(GLee.h GL/GLee.h,HAVE_GLEE=true)
+-
+-if test "x$ac_cv_header_GL_GLee_h" != "xno"; then
+-GLEE_CFLAGS="-I $includedir/GL -I/usr/include/GL"
+-fi
+-
+-if test "$HAVE_GLEE" = "true" ; then
+-
+-AC_CHECK_LIB(glee,GLeeEnabled,glee_lower_case=true,glee_lower_case=false)
+-if test "$glee_lower_case" = "true"; then
+-echo "GLee lib is -lglee"
+-GLEE_LIBS="-lglee"
+-else
+-AC_CHECK_LIB(GLee,GLeeEnabled,glee_mixed_case=true,glee_mixed_case=false)
+-if test "$glee_mixed_case" = "true"; then
+-echo "GLee lib is -lGLee"
+-GLEE_LIBS="-lGLee"
+-fi
+-fi
+-fi
+-
+-AC_SUBST(GLEE_CFLAGS)
+-AC_SUBST(GLEE_LIBS)
+-
+-AM_CONDITIONAL(HAVE_GLEE,$HAVE_GLEE)
+-
+-
+-
+ dnl check for GLU
+ PKG_CHECK_MODULES(GLU,glu,HAVE_GLU=true,HAVE_GLU=false)
+ AC_SUBST(GLU_CFLAGS)
+Index: lives-plugins/plugins/playback/video/Makefile.am
+===================================================================
+--- lives-plugins/plugins/playback/video/Makefile.am (revision 2619)
++++ lives-plugins/plugins/playback/video/Makefile.am (revision 2620)
+@@ -70,13 +70,11 @@
+ if HAVE_X11
+ if HAVE_XRENDER
+ if HAVE_OPENGL
+-if HAVE_GLEE
+ if HAVE_GLU
+ openGL_libs = openGL.la
+-openGL_la_SOURCES = openGL.cpp
+-openGL_la_CPPFLAGS = $(shared_cflags) $(weed_cflags) @X11_CFLAGS@ @XRENDER_CFLAGS@ @GL_CFLAGS@ @GLEE_CFLAGS@ \
+- @GLU_CFLAGS@
+-openGL_la_LDFLAGS = $(shared_ldflags) @X11_LIBS@ @XRENDER_LIBS@ @GL_LIBS@ @GLEE_LIBS@ @GLU_LIBS@
++openGL_la_SOURCES = openGL.cpp glad.cpp glad_glx.cpp
++openGL_la_CPPFLAGS = $(shared_cflags) $(weed_cflags) @X11_CFLAGS@ @XRENDER_CFLAGS@ @GL_CFLAGS@ @GLU_CFLAGS@
++openGL_la_LDFLAGS = $(shared_ldflags) @X11_LIBS@ @XRENDER_LIBS@ @GL_LIBS@ @GLU_LIBS@
+
+
+
+@@ -97,7 +95,6 @@
+ endif
+ endif
+ endif
+-endif
+
+ if IS_MINGW
+ else
+Index: lives-plugins/plugins/playback/video/glad.cpp
+===================================================================
+--- lives-plugins/plugins/playback/video/glad.cpp (nonexistent)
++++ lives-plugins/plugins/playback/video/glad.cpp (revision 2620)
+@@ -0,0 +1,1812 @@
++/*
++
++ OpenGL loader generated by glad 0.1.13a0 on Sat Apr 29 18:34:46 2017.
++
++ Language/Generator: C/C++
++ Specification: gl
++ APIs: gl=3.3
++ Profile: compatibility
++ Extensions:
++ GL_ARB_pixel_buffer_object,
++ GL_ARB_texture_non_power_of_two
++ Loader: True
++ Local files: False
++ Omit khrplatform: False
++
++ Commandline:
++ --profile="compatibility" --api="gl=3.3" --generator="c" --spec="gl" --extensions="GL_ARB_pixel_buffer_object,GL_ARB_texture_non_power_of_two"
++ Online:
++ http://glad.dav1d.de/#profile=compatibility&language=c&specification=gl&l...
++*/
++
++#include <stdio.h>
++#include <stdlib.h>
++#include <string.h>
++#include "glad.h"
++
++static void *get_proc(const char *namez);
++
++#ifdef _WIN32
++#include <windows.h>
++static HMODULE libGL;
++
++typedef void *(APIENTRYP PFNWGLGETPROCADDRESSPROC_PRIVATE)(const char *);
++static PFNWGLGETPROCADDRESSPROC_PRIVATE gladGetProcAddressPtr;
++
++static
++int open_gl(void) {
++ libGL = LoadLibraryW(L"opengl32.dll");
++ if (libGL != NULL) {
++ gladGetProcAddressPtr = (PFNWGLGETPROCADDRESSPROC_PRIVATE)GetProcAddress(
++ libGL, "wglGetProcAddress");
++ return gladGetProcAddressPtr != NULL;
++ }
++
++ return 0;
++}
++
++static
++void close_gl(void) {
++ if (libGL != NULL) {
++ FreeLibrary(libGL);
++ libGL = NULL;
++ }
++}
++#else
++#include <dlfcn.h>
++static void *libGL;
++
++#ifndef __APPLE__
++typedef void *(APIENTRYP PFNGLXGETPROCADDRESSPROC_PRIVATE)(const char *);
++static PFNGLXGETPROCADDRESSPROC_PRIVATE gladGetProcAddressPtr;
++#endif
++
++static
++int open_gl(void) {
++#ifdef __APPLE__
++ static const char *NAMES[] = {
++ "../Frameworks/OpenGL.framework/OpenGL",
++ "/Library/Frameworks/OpenGL.framework/OpenGL",
++ "/System/Library/Frameworks/OpenGL.framework/OpenGL",
++ "/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL"
++ };
++#else
++ static const char *NAMES[] = {"libGL.so.1", "libGL.so"};
++#endif
++
++ unsigned int index = 0;
++ for (index = 0; index < (sizeof(NAMES) / sizeof(NAMES[0])); index++) {
++ libGL = dlopen(NAMES[index], RTLD_NOW | RTLD_GLOBAL);
++
++ if (libGL != NULL) {
++#ifdef __APPLE__
++ return 1;
++#else
++ gladGetProcAddressPtr = (PFNGLXGETPROCADDRESSPROC_PRIVATE)dlsym(libGL,
++ "glXGetProcAddressARB");
++ return gladGetProcAddressPtr != NULL;
++#endif
++ }
++ }
++
++ return 0;
++}
++
++static
++void close_gl() {
++ if (libGL != NULL) {
++ dlclose(libGL);
++ libGL = NULL;
++ }
++}
++#endif
++
++static
++void *get_proc(const char *namez) {
++ void *result = NULL;
++ if (libGL == NULL) return NULL;
++
++#ifndef __APPLE__
++ if (gladGetProcAddressPtr != NULL) {
++ result = gladGetProcAddressPtr(namez);
++ }
++#endif
++ if (result == NULL) {
++#ifdef _WIN32
++ result = (void *)GetProcAddress(libGL, namez);
++#else
++ result = dlsym(libGL, namez);
++#endif
++ }
++
++ return result;
++}
++
++int gladLoadGL(void) {
++ int status = 0;
++
++ if (open_gl()) {
++ status = gladLoadGLLoader(&get_proc);
++ close_gl();
++ }
++
++ return status;
++}
++
++struct gladGLversionStruct GLVersion;
++
++#if defined(GL_ES_VERSION_3_0) || defined(GL_VERSION_3_0)
++#define _GLAD_IS_SOME_NEW_VERSION 1
++#endif
++
++static int max_loaded_major;
++static int max_loaded_minor;
++
++static const char *exts = NULL;
++static int num_exts_i = 0;
++static const char **exts_i = NULL;
++
++static int get_exts(void) {
++#ifdef _GLAD_IS_SOME_NEW_VERSION
++ if (max_loaded_major < 3) {
++#endif
++ exts = (const char *)glGetString(GL_EXTENSIONS);
++#ifdef _GLAD_IS_SOME_NEW_VERSION
++ } else {
++ unsigned int index;
++
++ num_exts_i = 0;
++ glGetIntegerv(GL_NUM_EXTENSIONS, &num_exts_i);
++ if (num_exts_i > 0) {
++ exts_i = (const char **)realloc((void *)exts_i, (size_t)num_exts_i * (sizeof *exts_i));
++ }
++
++ if (exts_i == NULL) {
++ return 0;
++ }
++
++ for (index = 0; index < (unsigned)num_exts_i; index++) {
++ exts_i[index] = (const char *)glGetStringi(GL_EXTENSIONS, index);
++ }
++ }
++#endif
++ return 1;
++}
++
++static void free_exts(void) {
++ if (exts_i != NULL) {
++ free(exts_i);
++ exts_i = NULL;
++ }
++}
++
++static int has_ext(const char *ext) {
++#ifdef _GLAD_IS_SOME_NEW_VERSION
++ if (max_loaded_major < 3) {
++#endif
++ const char *extensions;
++ const char *loc;
++ const char *terminator;
++ extensions = exts;
++ if (extensions == NULL || ext == NULL) {
++ return 0;
++ }
++
++ while (1) {
++ loc = strstr(extensions, ext);
++ if (loc == NULL) {
++ return 0;
++ }
++
++ terminator = loc + strlen(ext);
++ if ((loc == extensions || *(loc - 1) == ' ') &&
++ (*terminator == ' ' || *terminator == '\0')) {
++ return 1;
++ }
++ extensions = terminator;
++ }
++#ifdef _GLAD_IS_SOME_NEW_VERSION
++ } else {
++ int index;
++
++ for (index = 0; index < num_exts_i; index++) {
++ const char *e = exts_i[index];
++
++ if (strcmp(e, ext) == 0) {
++ return 1;
++ }
++ }
++ }
++#endif
++
++ return 0;
++}
++int GLAD_GL_VERSION_1_0;
++int GLAD_GL_VERSION_1_1;
++int GLAD_GL_VERSION_1_2;
++int GLAD_GL_VERSION_1_3;
++int GLAD_GL_VERSION_1_4;
++int GLAD_GL_VERSION_1_5;
++int GLAD_GL_VERSION_2_0;
++int GLAD_GL_VERSION_2_1;
++int GLAD_GL_VERSION_3_0;
++int GLAD_GL_VERSION_3_1;
++int GLAD_GL_VERSION_3_2;
++int GLAD_GL_VERSION_3_3;
++PFNGLCOPYTEXIMAGE1DPROC glad_glCopyTexImage1D;
++PFNGLVERTEXATTRIBI3UIPROC glad_glVertexAttribI3ui;
++PFNGLWINDOWPOS2SPROC glad_glWindowPos2s;
++PFNGLWINDOWPOS2IPROC glad_glWindowPos2i;
++PFNGLWINDOWPOS2FPROC glad_glWindowPos2f;
++PFNGLWINDOWPOS2DPROC glad_glWindowPos2d;
++PFNGLVERTEX2FVPROC glad_glVertex2fv;
++PFNGLINDEXIPROC glad_glIndexi;
++PFNGLFRAMEBUFFERRENDERBUFFERPROC glad_glFramebufferRenderbuffer;
++PFNGLRECTDVPROC glad_glRectdv;
++PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC glad_glCompressedTexSubImage3D;
++PFNGLEVALCOORD2DPROC glad_glEvalCoord2d;
++PFNGLEVALCOORD2FPROC glad_glEvalCoord2f;
++PFNGLINDEXDPROC glad_glIndexd;
++PFNGLVERTEXATTRIB1SVPROC glad_glVertexAttrib1sv;
++PFNGLINDEXFPROC glad_glIndexf;
++PFNGLBINDSAMPLERPROC glad_glBindSampler;
++PFNGLLINEWIDTHPROC glad_glLineWidth;
++PFNGLCOLORP3UIVPROC glad_glColorP3uiv;
++PFNGLGETINTEGERI_VPROC glad_glGetIntegeri_v;
++PFNGLGETMAPFVPROC glad_glGetMapfv;
++PFNGLINDEXSPROC glad_glIndexs;
++PFNGLCOMPILESHADERPROC glad_glCompileShader;
++PFNGLGETTRANSFORMFEEDBACKVARYINGPROC glad_glGetTransformFeedbackVarying;
++PFNGLWINDOWPOS2IVPROC glad_glWindowPos2iv;
++PFNGLINDEXFVPROC glad_glIndexfv;
++PFNGLFOGIVPROC glad_glFogiv;
++PFNGLSTENCILMASKSEPARATEPROC glad_glStencilMaskSeparate;
++PFNGLRASTERPOS2FVPROC glad_glRasterPos2fv;
++PFNGLLIGHTMODELIVPROC glad_glLightModeliv;
++PFNGLCOLOR4UIPROC glad_glColor4ui;
++PFNGLSECONDARYCOLOR3FVPROC glad_glSecondaryColor3fv;
++PFNGLMULTITEXCOORDP3UIPROC glad_glMultiTexCoordP3ui;
++PFNGLFOGFVPROC glad_glFogfv;
++PFNGLVERTEXP4UIPROC glad_glVertexP4ui;
++PFNGLENABLEIPROC glad_glEnablei;
++PFNGLVERTEX4IVPROC glad_glVertex4iv;
++PFNGLEVALCOORD1FVPROC glad_glEvalCoord1fv;
++PFNGLWINDOWPOS2SVPROC glad_glWindowPos2sv;
++PFNGLVERTEXATTRIBP4UIPROC glad_glVertexAttribP4ui;
++PFNGLCREATESHADERPROC glad_glCreateShader;
++PFNGLISBUFFERPROC glad_glIsBuffer;
++PFNGLGETMULTISAMPLEFVPROC glad_glGetMultisamplefv;
++PFNGLGENRENDERBUFFERSPROC glad_glGenRenderbuffers;
++PFNGLCOPYTEXSUBIMAGE2DPROC glad_glCopyTexSubImage2D;
++PFNGLCOMPRESSEDTEXIMAGE2DPROC glad_glCompressedTexImage2D;
++PFNGLVERTEXATTRIB1FPROC glad_glVertexAttrib1f;
++PFNGLBLENDFUNCSEPARATEPROC glad_glBlendFuncSeparate;
++PFNGLVERTEX4FVPROC glad_glVertex4fv;
++PFNGLBINDTEXTUREPROC glad_glBindTexture;
++PFNGLVERTEXATTRIB1SPROC glad_glVertexAttrib1s;
++PFNGLTEXCOORD2FVPROC glad_glTexCoord2fv;
++PFNGLSAMPLEMASKIPROC glad_glSampleMaski;
++PFNGLVERTEXP2UIPROC glad_glVertexP2ui;
++PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC glad_glDrawRangeElementsBaseVertex;
++PFNGLTEXCOORD4FVPROC glad_glTexCoord4fv;
++PFNGLUNIFORMMATRIX3X2FVPROC glad_glUniformMatrix3x2fv;
++PFNGLPOINTSIZEPROC glad_glPointSize;
++PFNGLVERTEXATTRIB2DVPROC glad_glVertexAttrib2dv;
++PFNGLDELETEPROGRAMPROC glad_glDeleteProgram;
++PFNGLCOLOR4BVPROC glad_glColor4bv;
++PFNGLRASTERPOS2FPROC glad_glRasterPos2f;
++PFNGLRASTERPOS2DPROC glad_glRasterPos2d;
++PFNGLLOADIDENTITYPROC glad_glLoadIdentity;
++PFNGLRASTERPOS2IPROC glad_glRasterPos2i;
++PFNGLRENDERBUFFERSTORAGEPROC glad_glRenderbufferStorage;
++PFNGLUNIFORMMATRIX4X3FVPROC glad_glUniformMatrix4x3fv;
++PFNGLCOLOR3BPROC glad_glColor3b;
++PFNGLCLEARBUFFERFVPROC glad_glClearBufferfv;
++PFNGLEDGEFLAGPROC glad_glEdgeFlag;
++PFNGLDELETESAMPLERSPROC glad_glDeleteSamplers;
++PFNGLVERTEX3DPROC glad_glVertex3d;
++PFNGLVERTEX3FPROC glad_glVertex3f;
++PFNGLVERTEX3IPROC glad_glVertex3i;
++PFNGLCOLOR3IPROC glad_glColor3i;
++PFNGLUNIFORM3FPROC glad_glUniform3f;
++PFNGLVERTEXATTRIB4UBVPROC glad_glVertexAttrib4ubv;
++PFNGLCOLOR3SPROC glad_glColor3s;
++PFNGLVERTEX3SPROC glad_glVertex3s;
++PFNGLTEXCOORDP2UIPROC glad_glTexCoordP2ui;
++PFNGLCOLORMASKIPROC glad_glColorMaski;
++PFNGLCLEARBUFFERFIPROC glad_glClearBufferfi;
++PFNGLTEXCOORD1IVPROC glad_glTexCoord1iv;
++PFNGLBLITFRAMEBUFFERPROC glad_glBlitFramebuffer;
++PFNGLMULTITEXCOORDP2UIPROC glad_glMultiTexCoordP2ui;
++PFNGLGETSAMPLERPARAMETERIIVPROC glad_glGetSamplerParameterIiv;
++PFNGLGETFRAGDATAINDEXPROC glad_glGetFragDataIndex;
++PFNGLVERTEXATTRIB3FPROC glad_glVertexAttrib3f;
++PFNGLVERTEX2IVPROC glad_glVertex2iv;
++PFNGLCOLOR3SVPROC glad_glColor3sv;
++PFNGLGETVERTEXATTRIBDVPROC glad_glGetVertexAttribdv;
++PFNGLUNIFORMMATRIX3X4FVPROC glad_glUniformMatrix3x4fv;
++PFNGLNORMALPOINTERPROC glad_glNormalPointer;
++PFNGLTEXCOORDP3UIVPROC glad_glTexCoordP3uiv;
++PFNGLVERTEX4SVPROC glad_glVertex4sv;
++PFNGLPASSTHROUGHPROC glad_glPassThrough;
++PFNGLMULTITEXCOORDP4UIPROC glad_glMultiTexCoordP4ui;
++PFNGLFOGIPROC glad_glFogi;
++PFNGLBEGINPROC glad_glBegin;
++PFNGLEVALCOORD2DVPROC glad_glEvalCoord2dv;
++PFNGLCOLOR3UBVPROC glad_glColor3ubv;
++PFNGLVERTEXPOINTERPROC glad_glVertexPointer;
++PFNGLSECONDARYCOLOR3UIVPROC glad_glSecondaryColor3uiv;
++PFNGLDELETEFRAMEBUFFERSPROC glad_glDeleteFramebuffers;
++PFNGLDRAWARRAYSPROC glad_glDrawArrays;
++PFNGLUNIFORM1UIPROC glad_glUniform1ui;
++PFNGLMULTITEXCOORD1DPROC glad_glMultiTexCoord1d;
++PFNGLMULTITEXCOORD1FPROC glad_glMultiTexCoord1f;
++PFNGLLIGHTFVPROC glad_glLightfv;
++PFNGLTEXCOORDP3UIPROC glad_glTexCoordP3ui;
++PFNGLVERTEXATTRIB3DPROC glad_glVertexAttrib3d;
++PFNGLCLEARPROC glad_glClear;
++PFNGLMULTITEXCOORD1IPROC glad_glMultiTexCoord1i;
++PFNGLGETACTIVEUNIFORMNAMEPROC glad_glGetActiveUniformName;
++PFNGLMULTITEXCOORD1SPROC glad_glMultiTexCoord1s;
++PFNGLISENABLEDPROC glad_glIsEnabled;
++PFNGLSTENCILOPPROC glad_glStencilOp;
++PFNGLGETQUERYOBJECTUIVPROC glad_glGetQueryObjectuiv;
++PFNGLFRAMEBUFFERTEXTURE2DPROC glad_glFramebufferTexture2D;
++PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC glad_glGetFramebufferAttachmentParameteriv;
++PFNGLTRANSLATEFPROC glad_glTranslatef;
++PFNGLVERTEXATTRIB4NUBPROC glad_glVertexAttrib4Nub;
++PFNGLTRANSLATEDPROC glad_glTranslated;
++PFNGLTEXCOORD3SVPROC glad_glTexCoord3sv;
++PFNGLGETFRAGDATALOCATIONPROC glad_glGetFragDataLocation;
++PFNGLTEXIMAGE1DPROC glad_glTexImage1D;
++PFNGLVERTEXP3UIVPROC glad_glVertexP3uiv;
++PFNGLTEXPARAMETERIVPROC glad_glTexParameteriv;
++PFNGLSECONDARYCOLOR3BVPROC glad_glSecondaryColor3bv;
++PFNGLGETMATERIALFVPROC glad_glGetMaterialfv;
++PFNGLGETTEXIMAGEPROC glad_glGetTexImage;
++PFNGLFOGCOORDFVPROC glad_glFogCoordfv;
++PFNGLPIXELMAPUIVPROC glad_glPixelMapuiv;
++PFNGLGETSHADERINFOLOGPROC glad_glGetShaderInfoLog;
++PFNGLGETQUERYOBJECTI64VPROC glad_glGetQueryObjecti64v;
++PFNGLGENFRAMEBUFFERSPROC glad_glGenFramebuffers;
++PFNGLINDEXSVPROC glad_glIndexsv;
++PFNGLGETATTACHEDSHADERSPROC glad_glGetAttachedShaders;
++PFNGLISRENDERBUFFERPROC glad_glIsRenderbuffer;
++PFNGLVERTEX3IVPROC glad_glVertex3iv;
++PFNGLBITMAPPROC glad_glBitmap;
++PFNGLMATERIALIPROC glad_glMateriali;
++PFNGLISVERTEXARRAYPROC glad_glIsVertexArray;
++PFNGLDISABLEVERTEXATTRIBARRAYPROC glad_glDisableVertexAttribArray;
++PFNGLGETQUERYIVPROC glad_glGetQueryiv;
++PFNGLTEXCOORD4FPROC glad_glTexCoord4f;
++PFNGLTEXCOORD4DPROC glad_glTexCoord4d;
++PFNGLGETSAMPLERPARAMETERFVPROC glad_glGetSamplerParameterfv;
++PFNGLTEXCOORD4IPROC glad_glTexCoord4i;
++PFNGLMATERIALFPROC glad_glMaterialf;
++PFNGLTEXCOORD4SPROC glad_glTexCoord4s;
++PFNGLGETUNIFORMINDICESPROC glad_glGetUniformIndices;
++PFNGLISSHADERPROC glad_glIsShader;
++PFNGLMULTITEXCOORD2SPROC glad_glMultiTexCoord2s;
++PFNGLVERTEXATTRIBI4UBVPROC glad_glVertexAttribI4ubv;
++PFNGLVERTEX3DVPROC glad_glVertex3dv;
++PFNGLGETINTEGER64VPROC glad_glGetInteger64v;
++PFNGLPOINTPARAMETERIVPROC glad_glPointParameteriv;
++PFNGLENABLEPROC glad_glEnable;
++PFNGLGETACTIVEUNIFORMSIVPROC glad_glGetActiveUniformsiv;
++PFNGLCOLOR4FVPROC glad_glColor4fv;
++PFNGLTEXCOORD1FVPROC glad_glTexCoord1fv;
++PFNGLTEXCOORD2SVPROC glad_glTexCoord2sv;
++PFNGLVERTEXATTRIB4DVPROC glad_glVertexAttrib4dv;
++PFNGLMULTITEXCOORD1DVPROC glad_glMultiTexCoord1dv;
++PFNGLMULTITEXCOORD2IPROC glad_glMultiTexCoord2i;
++PFNGLTEXCOORD3FVPROC glad_glTexCoord3fv;
++PFNGLSECONDARYCOLOR3USVPROC glad_glSecondaryColor3usv;
++PFNGLTEXGENFPROC glad_glTexGenf;
++PFNGLMULTITEXCOORDP3UIVPROC glad_glMultiTexCoordP3uiv;
++PFNGLVERTEXATTRIBP3UIPROC glad_glVertexAttribP3ui;
++PFNGLMULTITEXCOORDP1UIPROC glad_glMultiTexCoordP1ui;
++PFNGLGETPOINTERVPROC glad_glGetPointerv;
++PFNGLPOLYGONOFFSETPROC glad_glPolygonOffset;
++PFNGLGETUNIFORMUIVPROC glad_glGetUniformuiv;
++PFNGLNORMAL3FVPROC glad_glNormal3fv;
++PFNGLSECONDARYCOLOR3SPROC glad_glSecondaryColor3s;
++PFNGLDEPTHRANGEPROC glad_glDepthRange;
++PFNGLFRUSTUMPROC glad_glFrustum;
++PFNGLMULTITEXCOORD4SVPROC glad_glMultiTexCoord4sv;
++PFNGLDRAWBUFFERPROC glad_glDrawBuffer;
++PFNGLPUSHMATRIXPROC glad_glPushMatrix;
++PFNGLRASTERPOS3FVPROC glad_glRasterPos3fv;
++PFNGLORTHOPROC glad_glOrtho;
++PFNGLDRAWELEMENTSINSTANCEDPROC glad_glDrawElementsInstanced;
++PFNGLWINDOWPOS3SVPROC glad_glWindowPos3sv;
++PFNGLCLEARINDEXPROC glad_glClearIndex;
++PFNGLMAP1DPROC glad_glMap1d;
++PFNGLMAP1FPROC glad_glMap1f;
++PFNGLFLUSHPROC glad_glFlush;
++PFNGLGETRENDERBUFFERPARAMETERIVPROC glad_glGetRenderbufferParameteriv;
++PFNGLINDEXIVPROC glad_glIndexiv;
++PFNGLRASTERPOS3SVPROC glad_glRasterPos3sv;
++PFNGLGETVERTEXATTRIBPOINTERVPROC glad_glGetVertexAttribPointerv;
++PFNGLPIXELZOOMPROC glad_glPixelZoom;
++PFNGLFENCESYNCPROC glad_glFenceSync;
++PFNGLDELETEVERTEXARRAYSPROC glad_glDeleteVertexArrays;
++PFNGLCOLORP3UIPROC glad_glColorP3ui;
++PFNGLVERTEXATTRIB3SVPROC glad_glVertexAttrib3sv;
++PFNGLBEGINCONDITIONALRENDERPROC glad_glBeginConditionalRender;
++PFNGLDRAWELEMENTSBASEVERTEXPROC glad_glDrawElementsBaseVertex;
++PFNGLGETTEXLEVELPARAMETERIVPROC glad_glGetTexLevelParameteriv;
++PFNGLLIGHTIPROC glad_glLighti;
++PFNGLMULTITEXCOORDP4UIVPROC glad_glMultiTexCoordP4uiv;
++PFNGLLIGHTFPROC glad_glLightf;
++PFNGLGETATTRIBLOCATIONPROC glad_glGetAttribLocation;
++PFNGLSTENCILFUNCSEPARATEPROC glad_glStencilFuncSeparate;
++PFNGLGENSAMPLERSPROC glad_glGenSamplers;
++PFNGLCLAMPCOLORPROC glad_glClampColor;
++PFNGLUNIFORM4IVPROC glad_glUniform4iv;
++PFNGLCLEARSTENCILPROC glad_glClearStencil;
++PFNGLTEXCOORDP1UIVPROC glad_glTexCoordP1uiv;
++PFNGLMULTITEXCOORD3FVPROC glad_glMultiTexCoord3fv;
++PFNGLGETPIXELMAPUIVPROC glad_glGetPixelMapuiv;
++PFNGLGENTEXTURESPROC glad_glGenTextures;
++PFNGLTEXCOORD4IVPROC glad_glTexCoord4iv;
++PFNGLGETTEXPARAMETERIUIVPROC glad_glGetTexParameterIuiv;
++PFNGLINDEXPOINTERPROC glad_glIndexPointer;
++PFNGLVERTEXATTRIB4NBVPROC glad_glVertexAttrib4Nbv;
++PFNGLISSYNCPROC glad_glIsSync;
++PFNGLVERTEX2FPROC glad_glVertex2f;
++PFNGLVERTEX2DPROC glad_glVertex2d;
++PFNGLDELETERENDERBUFFERSPROC glad_glDeleteRenderbuffers;
++PFNGLUNIFORM2IPROC glad_glUniform2i;
++PFNGLMAPGRID2DPROC glad_glMapGrid2d;
++PFNGLMAPGRID2FPROC glad_glMapGrid2f;
++PFNGLTEXCOORDP4UIPROC glad_glTexCoordP4ui;
++PFNGLVERTEX2IPROC glad_glVertex2i;
++PFNGLVERTEXATTRIBPOINTERPROC glad_glVertexAttribPointer;
++PFNGLFRAMEBUFFERTEXTURELAYERPROC glad_glFramebufferTextureLayer;
++PFNGLVERTEX2SPROC glad_glVertex2s;
++PFNGLNORMAL3BVPROC glad_glNormal3bv;
++PFNGLVERTEXATTRIB4NUIVPROC glad_glVertexAttrib4Nuiv;
++PFNGLFLUSHMAPPEDBUFFERRANGEPROC glad_glFlushMappedBufferRange;
++PFNGLSECONDARYCOLOR3SVPROC glad_glSecondaryColor3sv;
++PFNGLVERTEX3SVPROC glad_glVertex3sv;
++PFNGLGENQUERIESPROC glad_glGenQueries;
++PFNGLGETPIXELMAPFVPROC glad_glGetPixelMapfv;
++PFNGLTEXENVFPROC glad_glTexEnvf;
++PFNGLVERTEXATTRIBP1UIPROC glad_glVertexAttribP1ui;
++PFNGLTEXSUBIMAGE3DPROC glad_glTexSubImage3D;
++PFNGLGETINTEGER64I_VPROC glad_glGetInteger64i_v;
++PFNGLFOGCOORDDPROC glad_glFogCoordd;
++PFNGLFOGCOORDFPROC glad_glFogCoordf;
++PFNGLCOPYTEXIMAGE2DPROC glad_glCopyTexImage2D;
++PFNGLTEXENVIPROC glad_glTexEnvi;
++PFNGLMULTITEXCOORD1IVPROC glad_glMultiTexCoord1iv;
++PFNGLISENABLEDIPROC glad_glIsEnabledi;
++PFNGLSECONDARYCOLORP3UIPROC glad_glSecondaryColorP3ui;
++PFNGLVERTEXATTRIBI2IPROC glad_glVertexAttribI2i;
++PFNGLBINDFRAGDATALOCATIONINDEXEDPROC glad_glBindFragDataLocationIndexed;
++PFNGLMULTITEXCOORD2DVPROC glad_glMultiTexCoord2dv;
++PFNGLUNIFORM2IVPROC glad_glUniform2iv;
++PFNGLVERTEXATTRIB1FVPROC glad_glVertexAttrib1fv;
++PFNGLUNIFORM4UIVPROC glad_glUniform4uiv;
++PFNGLMATRIXMODEPROC glad_glMatrixMode;
++PFNGLFEEDBACKBUFFERPROC glad_glFeedbackBuffer;
++PFNGLGETMAPIVPROC glad_glGetMapiv;
++PFNGLFRAMEBUFFERTEXTURE1DPROC glad_glFramebufferTexture1D;
++PFNGLGETSHADERIVPROC glad_glGetShaderiv;
++PFNGLMULTITEXCOORD2DPROC glad_glMultiTexCoord2d;
++PFNGLMULTITEXCOORD2FPROC glad_glMultiTexCoord2f;
++PFNGLBINDFRAGDATALOCATIONPROC glad_glBindFragDataLocation;
++PFNGLPRIORITIZETEXTURESPROC glad_glPrioritizeTextures;
++PFNGLCALLLISTPROC glad_glCallList;
++PFNGLSECONDARYCOLOR3UBVPROC glad_glSecondaryColor3ubv;
++PFNGLGETDOUBLEVPROC glad_glGetDoublev;
++PFNGLMULTITEXCOORD3IVPROC glad_glMultiTexCoord3iv;
++PFNGLVERTEXATTRIB1DPROC glad_glVertexAttrib1d;
++PFNGLLIGHTMODELFPROC glad_glLightModelf;
++PFNGLGETUNIFORMIVPROC glad_glGetUniformiv;
++PFNGLVERTEX2SVPROC glad_glVertex2sv;
++PFNGLLIGHTMODELIPROC glad_glLightModeli;
++PFNGLWINDOWPOS3IVPROC glad_glWindowPos3iv;
++PFNGLMULTITEXCOORDP1UIVPROC glad_glMultiTexCoordP1uiv;
++PFNGLUNIFORM3FVPROC glad_glUniform3fv;
++PFNGLPIXELSTOREIPROC glad_glPixelStorei;
++PFNGLCALLLISTSPROC glad_glCallLists;
++PFNGLMAPBUFFERPROC glad_glMapBuffer;
++PFNGLSECONDARYCOLOR3DPROC glad_glSecondaryColor3d;
++PFNGLTEXCOORD3IPROC glad_glTexCoord3i;
++PFNGLMULTITEXCOORD4FVPROC glad_glMultiTexCoord4fv;
++PFNGLRASTERPOS3IPROC glad_glRasterPos3i;
++PFNGLSECONDARYCOLOR3BPROC glad_glSecondaryColor3b;
++PFNGLRASTERPOS3DPROC glad_glRasterPos3d;
++PFNGLRASTERPOS3FPROC glad_glRasterPos3f;
++PFNGLCOMPRESSEDTEXIMAGE3DPROC glad_glCompressedTexImage3D;
++PFNGLTEXCOORD3FPROC glad_glTexCoord3f;
++PFNGLDELETESYNCPROC glad_glDeleteSync;
++PFNGLTEXCOORD3DPROC glad_glTexCoord3d;
++PFNGLTEXIMAGE2DMULTISAMPLEPROC glad_glTexImage2DMultisample;
++PFNGLGETVERTEXATTRIBIVPROC glad_glGetVertexAttribiv;
++PFNGLMULTIDRAWELEMENTSPROC glad_glMultiDrawElements;
++PFNGLVERTEXATTRIB3FVPROC glad_glVertexAttrib3fv;
++PFNGLTEXCOORD3SPROC glad_glTexCoord3s;
++PFNGLUNIFORM3IVPROC glad_glUniform3iv;
++PFNGLRASTERPOS3SPROC glad_glRasterPos3s;
++PFNGLPOLYGONMODEPROC glad_glPolygonMode;
++PFNGLDRAWBUFFERSPROC glad_glDrawBuffers;
++PFNGLGETACTIVEUNIFORMBLOCKIVPROC glad_glGetActiveUniformBlockiv;
++PFNGLARETEXTURESRESIDENTPROC glad_glAreTexturesResident;
++PFNGLISLISTPROC glad_glIsList;
++PFNGLRASTERPOS2SVPROC glad_glRasterPos2sv;
++PFNGLRASTERPOS4SVPROC glad_glRasterPos4sv;
++PFNGLCOLOR4SPROC glad_glColor4s;
++PFNGLUSEPROGRAMPROC glad_glUseProgram;
++PFNGLLINESTIPPLEPROC glad_glLineStipple;
++PFNGLMULTITEXCOORD1SVPROC glad_glMultiTexCoord1sv;
++PFNGLGETPROGRAMINFOLOGPROC glad_glGetProgramInfoLog;
++PFNGLGETBUFFERPARAMETERIVPROC glad_glGetBufferParameteriv;
++PFNGLMULTITEXCOORD2IVPROC glad_glMultiTexCoord2iv;
++PFNGLUNIFORMMATRIX2X4FVPROC glad_glUniformMatrix2x4fv;
++PFNGLBINDVERTEXARRAYPROC glad_glBindVertexArray;
++PFNGLCOLOR4BPROC glad_glColor4b;
++PFNGLSECONDARYCOLOR3FPROC glad_glSecondaryColor3f;
++PFNGLCOLOR4FPROC glad_glColor4f;
++PFNGLCOLOR4DPROC glad_glColor4d;
++PFNGLCOLOR4IPROC glad_glColor4i;
++PFNGLSAMPLERPARAMETERIIVPROC glad_glSamplerParameterIiv;
++PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC glad_glMultiDrawElementsBaseVertex;
++PFNGLRASTERPOS3IVPROC glad_glRasterPos3iv;
++PFNGLVERTEX2DVPROC glad_glVertex2dv;
++PFNGLTEXCOORD4SVPROC glad_glTexCoord4sv;
++PFNGLUNIFORM2UIVPROC glad_glUniform2uiv;
++PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC glad_glCompressedTexSubImage1D;
++PFNGLFINISHPROC glad_glFinish;
++PFNGLGETBOOLEANVPROC glad_glGetBooleanv;
++PFNGLDELETESHADERPROC glad_glDeleteShader;
++PFNGLDRAWELEMENTSPROC glad_glDrawElements;
++PFNGLRASTERPOS2SPROC glad_glRasterPos2s;
++PFNGLGETMAPDVPROC glad_glGetMapdv;
++PFNGLVERTEXATTRIB4NSVPROC glad_glVertexAttrib4Nsv;
++PFNGLMATERIALFVPROC glad_glMaterialfv;
++PFNGLVIEWPORTPROC glad_glViewport;
++PFNGLUNIFORM1UIVPROC glad_glUniform1uiv;
++PFNGLTRANSFORMFEEDBACKVARYINGSPROC glad_glTransformFeedbackVaryings;
++PFNGLINDEXDVPROC glad_glIndexdv;
++PFNGLCOPYTEXSUBIMAGE3DPROC glad_glCopyTexSubImage3D;
++PFNGLTEXCOORD3IVPROC glad_glTexCoord3iv;
++PFNGLVERTEXATTRIBI3IPROC glad_glVertexAttribI3i;
++PFNGLCLEARDEPTHPROC glad_glClearDepth;
++PFNGLVERTEXATTRIBI4USVPROC glad_glVertexAttribI4usv;
++PFNGLTEXPARAMETERFPROC glad_glTexParameterf;
++PFNGLTEXPARAMETERIPROC glad_glTexParameteri;
++PFNGLGETSHADERSOURCEPROC glad_glGetShaderSource;
++PFNGLTEXBUFFERPROC glad_glTexBuffer;
++PFNGLPOPNAMEPROC glad_glPopName;
++PFNGLVALIDATEPROGRAMPROC glad_glValidateProgram;
++PFNGLPIXELSTOREFPROC glad_glPixelStoref;
++PFNGLUNIFORM3UIVPROC glad_glUniform3uiv;
++PFNGLRASTERPOS4FVPROC glad_glRasterPos4fv;
++PFNGLEVALCOORD1DVPROC glad_glEvalCoord1dv;
++PFNGLMULTITEXCOORDP2UIVPROC glad_glMultiTexCoordP2uiv;
++PFNGLRECTIPROC glad_glRecti;
++PFNGLCOLOR4UBPROC glad_glColor4ub;
++PFNGLMULTTRANSPOSEMATRIXFPROC glad_glMultTransposeMatrixf;
++PFNGLRECTFPROC glad_glRectf;
++PFNGLRECTDPROC glad_glRectd;
++PFNGLNORMAL3SVPROC glad_glNormal3sv;
++PFNGLNEWLISTPROC glad_glNewList;
++PFNGLCOLOR4USPROC glad_glColor4us;
++PFNGLVERTEXATTRIBP1UIVPROC glad_glVertexAttribP1uiv;
++PFNGLLINKPROGRAMPROC glad_glLinkProgram;
++PFNGLHINTPROC glad_glHint;
++PFNGLRECTSPROC glad_glRects;
++PFNGLTEXCOORD2DVPROC glad_glTexCoord2dv;
++PFNGLRASTERPOS4IVPROC glad_glRasterPos4iv;
++PFNGLGETSTRINGPROC glad_glGetString;
++PFNGLVERTEXATTRIBP2UIVPROC glad_glVertexAttribP2uiv;
++PFNGLEDGEFLAGVPROC glad_glEdgeFlagv;
++PFNGLDETACHSHADERPROC glad_glDetachShader;
++PFNGLSCALEFPROC glad_glScalef;
++PFNGLENDQUERYPROC glad_glEndQuery;
++PFNGLSCALEDPROC glad_glScaled;
++PFNGLEDGEFLAGPOINTERPROC glad_glEdgeFlagPointer;
++PFNGLCOPYPIXELSPROC glad_glCopyPixels;
++PFNGLVERTEXATTRIBI2UIPROC glad_glVertexAttribI2ui;
++PFNGLPOPATTRIBPROC glad_glPopAttrib;
++PFNGLDELETETEXTURESPROC glad_glDeleteTextures;
++PFNGLSTENCILOPSEPARATEPROC glad_glStencilOpSeparate;
++PFNGLDELETEQUERIESPROC glad_glDeleteQueries;
++PFNGLNORMALP3UIVPROC glad_glNormalP3uiv;
++PFNGLVERTEXATTRIB4FPROC glad_glVertexAttrib4f;
++PFNGLVERTEXATTRIB4DPROC glad_glVertexAttrib4d;
++PFNGLINITNAMESPROC glad_glInitNames;
++PFNGLGETBUFFERPARAMETERI64VPROC glad_glGetBufferParameteri64v;
++PFNGLCOLOR3DVPROC glad_glColor3dv;
++PFNGLVERTEXATTRIBI1IPROC glad_glVertexAttribI1i;
++PFNGLGETTEXPARAMETERIVPROC glad_glGetTexParameteriv;
++PFNGLWAITSYNCPROC glad_glWaitSync;
++PFNGLVERTEXATTRIB4SPROC glad_glVertexAttrib4s;
++PFNGLCOLORMATERIALPROC glad_glColorMaterial;
++PFNGLSAMPLECOVERAGEPROC glad_glSampleCoverage;
++PFNGLSAMPLERPARAMETERIPROC glad_glSamplerParameteri;
++PFNGLSAMPLERPARAMETERFPROC glad_glSamplerParameterf;
++PFNGLUNIFORM1FPROC glad_glUniform1f;
++PFNGLGETVERTEXATTRIBFVPROC glad_glGetVertexAttribfv;
++PFNGLRENDERMODEPROC glad_glRenderMode;
++PFNGLGETCOMPRESSEDTEXIMAGEPROC glad_glGetCompressedTexImage;
++PFNGLWINDOWPOS2DVPROC glad_glWindowPos2dv;
++PFNGLUNIFORM1IPROC glad_glUniform1i;
++PFNGLGETACTIVEATTRIBPROC glad_glGetActiveAttrib;
++PFNGLUNIFORM3IPROC glad_glUniform3i;
++PFNGLPIXELTRANSFERIPROC glad_glPixelTransferi;
++PFNGLTEXSUBIMAGE2DPROC glad_glTexSubImage2D;
++PFNGLDISABLEPROC glad_glDisable;
++PFNGLLOGICOPPROC glad_glLogicOp;
++PFNGLEVALPOINT2PROC glad_glEvalPoint2;
++PFNGLPIXELTRANSFERFPROC glad_glPixelTransferf;
++PFNGLSECONDARYCOLOR3IPROC glad_glSecondaryColor3i;
++PFNGLUNIFORM4UIPROC glad_glUniform4ui;
++PFNGLCOLOR3FPROC glad_glColor3f;
++PFNGLBINDFRAMEBUFFERPROC glad_glBindFramebuffer;
++PFNGLGETTEXENVFVPROC glad_glGetTexEnvfv;
++PFNGLRECTFVPROC glad_glRectfv;
++PFNGLCULLFACEPROC glad_glCullFace;
++PFNGLGETLIGHTFVPROC glad_glGetLightfv;
++PFNGLCOLOR3DPROC glad_glColor3d;
++PFNGLTEXGENDPROC glad_glTexGend;
++PFNGLTEXGENIPROC glad_glTexGeni;
++PFNGLMULTITEXCOORD3SPROC glad_glMultiTexCoord3s;
++PFNGLGETSTRINGIPROC glad_glGetStringi;
++PFNGLMULTITEXCOORD3IPROC glad_glMultiTexCoord3i;
++PFNGLMULTITEXCOORD3FPROC glad_glMultiTexCoord3f;
++PFNGLMULTITEXCOORD3DPROC glad_glMultiTexCoord3d;
++PFNGLATTACHSHADERPROC glad_glAttachShader;
++PFNGLFOGCOORDDVPROC glad_glFogCoorddv;
++PFNGLUNIFORMMATRIX2X3FVPROC glad_glUniformMatrix2x3fv;
++PFNGLGETTEXGENFVPROC glad_glGetTexGenfv;
++PFNGLQUERYCOUNTERPROC glad_glQueryCounter;
++PFNGLFOGCOORDPOINTERPROC glad_glFogCoordPointer;
++PFNGLPROVOKINGVERTEXPROC glad_glProvokingVertex;
++PFNGLFRAMEBUFFERTEXTURE3DPROC glad_glFramebufferTexture3D;
++PFNGLTEXGENIVPROC glad_glTexGeniv;
++PFNGLRASTERPOS2DVPROC glad_glRasterPos2dv;
++PFNGLSECONDARYCOLOR3DVPROC glad_glSecondaryColor3dv;
++PFNGLCLIENTACTIVETEXTUREPROC glad_glClientActiveTexture;
++PFNGLVERTEXATTRIBI4SVPROC glad_glVertexAttribI4sv;
++PFNGLSECONDARYCOLOR3USPROC glad_glSecondaryColor3us;
++PFNGLNORMALP3UIPROC glad_glNormalP3ui;
++PFNGLTEXENVFVPROC glad_glTexEnvfv;
++PFNGLREADBUFFERPROC glad_glReadBuffer;
++PFNGLTEXPARAMETERIUIVPROC glad_glTexParameterIuiv;
++PFNGLDRAWARRAYSINSTANCEDPROC glad_glDrawArraysInstanced;
++PFNGLGENERATEMIPMAPPROC glad_glGenerateMipmap;
++PFNGLWINDOWPOS3FVPROC glad_glWindowPos3fv;
++PFNGLLIGHTMODELFVPROC glad_glLightModelfv;
++PFNGLSAMPLERPARAMETERIVPROC glad_glSamplerParameteriv;
++PFNGLDELETELISTSPROC glad_glDeleteLists;
++PFNGLGETCLIPPLANEPROC glad_glGetClipPlane;
++PFNGLVERTEX4DVPROC glad_glVertex4dv;
++PFNGLTEXCOORD2DPROC glad_glTexCoord2d;
++PFNGLPOPMATRIXPROC glad_glPopMatrix;
++PFNGLTEXCOORD2FPROC glad_glTexCoord2f;
++PFNGLCOLOR4IVPROC glad_glColor4iv;
++PFNGLINDEXUBVPROC glad_glIndexubv;
++PFNGLUNMAPBUFFERPROC glad_glUnmapBuffer;
++PFNGLTEXCOORD2IPROC glad_glTexCoord2i;
++PFNGLRASTERPOS4DPROC glad_glRasterPos4d;
++PFNGLRASTERPOS4FPROC glad_glRasterPos4f;
++PFNGLVERTEXATTRIB3SPROC glad_glVertexAttrib3s;
++PFNGLTEXCOORD2SPROC glad_glTexCoord2s;
++PFNGLBINDRENDERBUFFERPROC glad_glBindRenderbuffer;
++PFNGLVERTEX3FVPROC glad_glVertex3fv;
++PFNGLTEXCOORD4DVPROC glad_glTexCoord4dv;
++PFNGLMATERIALIVPROC glad_glMaterialiv;
++PFNGLVERTEXATTRIBP4UIVPROC glad_glVertexAttribP4uiv;
++PFNGLISPROGRAMPROC glad_glIsProgram;
++PFNGLVERTEXATTRIB4BVPROC glad_glVertexAttrib4bv;
++PFNGLVERTEX4SPROC glad_glVertex4s;
++PFNGLVERTEXATTRIB4FVPROC glad_glVertexAttrib4fv;
++PFNGLNORMAL3DVPROC glad_glNormal3dv;
++PFNGLUNIFORM4IPROC glad_glUniform4i;
++PFNGLACTIVETEXTUREPROC glad_glActiveTexture;
++PFNGLENABLEVERTEXATTRIBARRAYPROC glad_glEnableVertexAttribArray;
++PFNGLROTATEDPROC glad_glRotated;
++PFNGLROTATEFPROC glad_glRotatef;
++PFNGLVERTEX4IPROC glad_glVertex4i;
++PFNGLREADPIXELSPROC glad_glReadPixels;
++PFNGLVERTEXATTRIBI3IVPROC glad_glVertexAttribI3iv;
++PFNGLLOADNAMEPROC glad_glLoadName;
++PFNGLUNIFORM4FPROC glad_glUniform4f;
++PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC glad_glRenderbufferStorageMultisample;
++PFNGLGENVERTEXARRAYSPROC glad_glGenVertexArrays;
++PFNGLSHADEMODELPROC glad_glShadeModel;
++PFNGLMAPGRID1DPROC glad_glMapGrid1d;
++PFNGLGETUNIFORMFVPROC glad_glGetUniformfv;
++PFNGLMAPGRID1FPROC glad_glMapGrid1f;
++PFNGLSAMPLERPARAMETERFVPROC glad_glSamplerParameterfv;
++PFNGLDISABLECLIENTSTATEPROC glad_glDisableClientState;
++PFNGLMULTITEXCOORD3SVPROC glad_glMultiTexCoord3sv;
++PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC glad_glDrawElementsInstancedBaseVertex;
++PFNGLSECONDARYCOLORPOINTERPROC glad_glSecondaryColorPointer;
++PFNGLALPHAFUNCPROC glad_glAlphaFunc;
++PFNGLUNIFORM1IVPROC glad_glUniform1iv;
++PFNGLMULTITEXCOORD4IVPROC glad_glMultiTexCoord4iv;
++PFNGLGETQUERYOBJECTIVPROC glad_glGetQueryObjectiv;
++PFNGLSTENCILFUNCPROC glad_glStencilFunc;
++PFNGLMULTITEXCOORD1FVPROC glad_glMultiTexCoord1fv;
++PFNGLUNIFORMBLOCKBINDINGPROC glad_glUniformBlockBinding;
++PFNGLCOLOR4UIVPROC glad_glColor4uiv;
++PFNGLRECTIVPROC glad_glRectiv;
++PFNGLCOLORP4UIPROC glad_glColorP4ui;
++PFNGLRASTERPOS3DVPROC glad_glRasterPos3dv;
++PFNGLEVALMESH2PROC glad_glEvalMesh2;
++PFNGLEVALMESH1PROC glad_glEvalMesh1;
++PFNGLTEXCOORDPOINTERPROC glad_glTexCoordPointer;
++PFNGLVERTEXATTRIB4NUBVPROC glad_glVertexAttrib4Nubv;
++PFNGLVERTEXATTRIBI4IVPROC glad_glVertexAttribI4iv;
++PFNGLEVALCOORD2FVPROC glad_glEvalCoord2fv;
++PFNGLCOLOR4UBVPROC glad_glColor4ubv;
++PFNGLLOADTRANSPOSEMATRIXDPROC glad_glLoadTransposeMatrixd;
++PFNGLLOADTRANSPOSEMATRIXFPROC glad_glLoadTransposeMatrixf;
++PFNGLVERTEXATTRIBI4IPROC glad_glVertexAttribI4i;
++PFNGLRASTERPOS2IVPROC glad_glRasterPos2iv;
++PFNGLGETBUFFERSUBDATAPROC glad_glGetBufferSubData;
++PFNGLTEXENVIVPROC glad_glTexEnviv;
++PFNGLBLENDEQUATIONSEPARATEPROC glad_glBlendEquationSeparate;
++PFNGLVERTEXATTRIBI1UIPROC glad_glVertexAttribI1ui;
++PFNGLGENBUFFERSPROC glad_glGenBuffers;
++PFNGLSELECTBUFFERPROC glad_glSelectBuffer;
++PFNGLVERTEXATTRIB2SVPROC glad_glVertexAttrib2sv;
++PFNGLPUSHATTRIBPROC glad_glPushAttrib;
++PFNGLVERTEXATTRIBIPOINTERPROC glad_glVertexAttribIPointer;
++PFNGLBLENDFUNCPROC glad_glBlendFunc;
++PFNGLCREATEPROGRAMPROC glad_glCreateProgram;
++PFNGLTEXIMAGE3DPROC glad_glTexImage3D;
++PFNGLISFRAMEBUFFERPROC glad_glIsFramebuffer;
++PFNGLLIGHTIVPROC glad_glLightiv;
++PFNGLPRIMITIVERESTARTINDEXPROC glad_glPrimitiveRestartIndex;
++PFNGLTEXGENFVPROC glad_glTexGenfv;
++PFNGLENDPROC glad_glEnd;
++PFNGLDELETEBUFFERSPROC glad_glDeleteBuffers;
++PFNGLSCISSORPROC glad_glScissor;
++PFNGLTEXCOORDP4UIVPROC glad_glTexCoordP4uiv;
++PFNGLCLIPPLANEPROC glad_glClipPlane;
++PFNGLPUSHNAMEPROC glad_glPushName;
++PFNGLTEXGENDVPROC glad_glTexGendv;
++PFNGLINDEXUBPROC glad_glIndexub;
++PFNGLVERTEXP2UIVPROC glad_glVertexP2uiv;
++PFNGLSECONDARYCOLOR3IVPROC glad_glSecondaryColor3iv;
++PFNGLRASTERPOS4IPROC glad_glRasterPos4i;
++PFNGLMULTTRANSPOSEMATRIXDPROC glad_glMultTransposeMatrixd;
++PFNGLCLEARCOLORPROC glad_glClearColor;
++PFNGLVERTEXATTRIB4UIVPROC glad_glVertexAttrib4uiv;
++PFNGLNORMAL3SPROC glad_glNormal3s;
++PFNGLVERTEXATTRIB4NIVPROC glad_glVertexAttrib4Niv;
++PFNGLCLEARBUFFERIVPROC glad_glClearBufferiv;
++PFNGLPOINTPARAMETERIPROC glad_glPointParameteri;
++PFNGLCOLORP4UIVPROC glad_glColorP4uiv;
++PFNGLBLENDCOLORPROC glad_glBlendColor;
++PFNGLWINDOWPOS3DPROC glad_glWindowPos3d;
++PFNGLVERTEXATTRIBI2UIVPROC glad_glVertexAttribI2uiv;
++PFNGLSAMPLERPARAMETERIUIVPROC glad_glSamplerParameterIuiv;
++PFNGLUNIFORM3UIPROC glad_glUniform3ui;
++PFNGLCOLOR4DVPROC glad_glColor4dv;
++PFNGLVERTEXATTRIBI4UIVPROC glad_glVertexAttribI4uiv;
++PFNGLPOINTPARAMETERFVPROC glad_glPointParameterfv;
++PFNGLUNIFORM2FVPROC glad_glUniform2fv;
++PFNGLSECONDARYCOLOR3UBPROC glad_glSecondaryColor3ub;
++PFNGLSECONDARYCOLOR3UIPROC glad_glSecondaryColor3ui;
++PFNGLTEXCOORD3DVPROC glad_glTexCoord3dv;
++PFNGLGETSAMPLERPARAMETERIUIVPROC glad_glGetSamplerParameterIuiv;
++PFNGLBINDBUFFERRANGEPROC glad_glBindBufferRange;
++PFNGLNORMAL3IVPROC glad_glNormal3iv;
++PFNGLWINDOWPOS3SPROC glad_glWindowPos3s;
++PFNGLPOINTPARAMETERFPROC glad_glPointParameterf;
++PFNGLGETVERTEXATTRIBIUIVPROC glad_glGetVertexAttribIuiv;
++PFNGLWINDOWPOS3IPROC glad_glWindowPos3i;
++PFNGLMULTITEXCOORD4SPROC glad_glMultiTexCoord4s;
++PFNGLWINDOWPOS3FPROC glad_glWindowPos3f;
++PFNGLCOLOR3USPROC glad_glColor3us;
++PFNGLCOLOR3UIVPROC glad_glColor3uiv;
++PFNGLVERTEXATTRIB4NUSVPROC glad_glVertexAttrib4Nusv;
++PFNGLGETLIGHTIVPROC glad_glGetLightiv;
++PFNGLDEPTHFUNCPROC glad_glDepthFunc;
++PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC glad_glCompressedTexSubImage2D;
++PFNGLLISTBASEPROC glad_glListBase;
++PFNGLMULTITEXCOORD4FPROC glad_glMultiTexCoord4f;
++PFNGLCOLOR3UBPROC glad_glColor3ub;
++PFNGLMULTITEXCOORD4DPROC glad_glMultiTexCoord4d;
++PFNGLVERTEXATTRIBI4BVPROC glad_glVertexAttribI4bv;
++PFNGLGETTEXPARAMETERFVPROC glad_glGetTexParameterfv;
++PFNGLCOLOR3UIPROC glad_glColor3ui;
++PFNGLMULTITEXCOORD4IPROC glad_glMultiTexCoord4i;
++PFNGLGETPOLYGONSTIPPLEPROC glad_glGetPolygonStipple;
++PFNGLCLIENTWAITSYNCPROC glad_glClientWaitSync;
++PFNGLVERTEXATTRIBI4UIPROC glad_glVertexAttribI4ui;
++PFNGLMULTITEXCOORD4DVPROC glad_glMultiTexCoord4dv;
++PFNGLCOLORMASKPROC glad_glColorMask;
++PFNGLTEXPARAMETERIIVPROC glad_glTexParameterIiv;
++PFNGLBLENDEQUATIONPROC glad_glBlendEquation;
++PFNGLGETUNIFORMLOCATIONPROC glad_glGetUniformLocation;
++PFNGLGETSAMPLERPARAMETERIVPROC glad_glGetSamplerParameteriv;
++PFNGLRASTERPOS4SPROC glad_glRasterPos4s;
++PFNGLENDTRANSFORMFEEDBACKPROC glad_glEndTransformFeedback;
++PFNGLVERTEXATTRIB4USVPROC glad_glVertexAttrib4usv;
++PFNGLMULTITEXCOORD3DVPROC glad_glMultiTexCoord3dv;
++PFNGLCOLOR4SVPROC glad_glColor4sv;
++PFNGLPOPCLIENTATTRIBPROC glad_glPopClientAttrib;
++PFNGLBEGINTRANSFORMFEEDBACKPROC glad_glBeginTransformFeedback;
++PFNGLFOGFPROC glad_glFogf;
++PFNGLVERTEXATTRIBI1IVPROC glad_glVertexAttribI1iv;
++PFNGLISSAMPLERPROC glad_glIsSampler;
++PFNGLVERTEXP3UIPROC glad_glVertexP3ui;
++PFNGLVERTEXATTRIBDIVISORPROC glad_glVertexAttribDivisor;
++PFNGLCOLOR3IVPROC glad_glColor3iv;
++PFNGLCOMPRESSEDTEXIMAGE1DPROC glad_glCompressedTexImage1D;
++PFNGLCOPYTEXSUBIMAGE1DPROC glad_glCopyTexSubImage1D;
++PFNGLTEXCOORD1IPROC glad_glTexCoord1i;
++PFNGLCHECKFRAMEBUFFERSTATUSPROC glad_glCheckFramebufferStatus;
++PFNGLTEXCOORD1DPROC glad_glTexCoord1d;
++PFNGLTEXCOORD1FPROC glad_glTexCoord1f;
++PFNGLENDCONDITIONALRENDERPROC glad_glEndConditionalRender;
++PFNGLENABLECLIENTSTATEPROC glad_glEnableClientState;
++PFNGLBINDATTRIBLOCATIONPROC glad_glBindAttribLocation;
++PFNGLUNIFORMMATRIX4X2FVPROC glad_glUniformMatrix4x2fv;
++PFNGLMULTITEXCOORD2SVPROC glad_glMultiTexCoord2sv;
++PFNGLVERTEXATTRIB1DVPROC glad_glVertexAttrib1dv;
++PFNGLDRAWRANGEELEMENTSPROC glad_glDrawRangeElements;
++PFNGLTEXCOORD1SPROC glad_glTexCoord1s;
++PFNGLBINDBUFFERBASEPROC glad_glBindBufferBase;
++PFNGLBUFFERSUBDATAPROC glad_glBufferSubData;
++PFNGLVERTEXATTRIB4IVPROC glad_glVertexAttrib4iv;
++PFNGLGENLISTSPROC glad_glGenLists;
++PFNGLCOLOR3BVPROC glad_glColor3bv;
++PFNGLMAPBUFFERRANGEPROC glad_glMapBufferRange;
++PFNGLFRAMEBUFFERTEXTUREPROC glad_glFramebufferTexture;
++PFNGLGETTEXGENDVPROC glad_glGetTexGendv;
++PFNGLMULTIDRAWARRAYSPROC glad_glMultiDrawArrays;
++PFNGLENDLISTPROC glad_glEndList;
++PFNGLVERTEXP4UIVPROC glad_glVertexP4uiv;
++PFNGLUNIFORM2UIPROC glad_glUniform2ui;
++PFNGLVERTEXATTRIBI2IVPROC glad_glVertexAttribI2iv;
++PFNGLCOLOR3USVPROC glad_glColor3usv;
++PFNGLWINDOWPOS2FVPROC glad_glWindowPos2fv;
++PFNGLDISABLEIPROC glad_glDisablei;
++PFNGLINDEXMASKPROC glad_glIndexMask;
++PFNGLPUSHCLIENTATTRIBPROC glad_glPushClientAttrib;
++PFNGLSHADERSOURCEPROC glad_glShaderSource;
++PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC glad_glGetActiveUniformBlockName;
++PFNGLVERTEXATTRIBI3UIVPROC glad_glVertexAttribI3uiv;
++PFNGLCLEARACCUMPROC glad_glClearAccum;
++PFNGLGETSYNCIVPROC glad_glGetSynciv;
++PFNGLTEXCOORDP2UIVPROC glad_glTexCoordP2uiv;
++PFNGLUNIFORM2FPROC glad_glUniform2f;
++PFNGLBEGINQUERYPROC glad_glBeginQuery;
++PFNGLGETUNIFORMBLOCKINDEXPROC glad_glGetUniformBlockIndex;
++PFNGLBINDBUFFERPROC glad_glBindBuffer;
++PFNGLMAP2DPROC glad_glMap2d;
++PFNGLMAP2FPROC glad_glMap2f;
++PFNGLVERTEX4DPROC glad_glVertex4d;
++PFNGLUNIFORMMATRIX2FVPROC glad_glUniformMatrix2fv;
++PFNGLTEXCOORD1SVPROC glad_glTexCoord1sv;
++PFNGLBUFFERDATAPROC glad_glBufferData;
++PFNGLEVALPOINT1PROC glad_glEvalPoint1;
++PFNGLGETTEXPARAMETERIIVPROC glad_glGetTexParameterIiv;
++PFNGLTEXCOORD1DVPROC glad_glTexCoord1dv;
++PFNGLTEXCOORDP1UIPROC glad_glTexCoordP1ui;
++PFNGLGETERRORPROC glad_glGetError;
++PFNGLGETTEXENVIVPROC glad_glGetTexEnviv;
++PFNGLGETPROGRAMIVPROC glad_glGetProgramiv;
++PFNGLVERTEXATTRIBP2UIPROC glad_glVertexAttribP2ui;
++PFNGLGETFLOATVPROC glad_glGetFloatv;
++PFNGLTEXSUBIMAGE1DPROC glad_glTexSubImage1D;
++PFNGLMULTITEXCOORD2FVPROC glad_glMultiTexCoord2fv;
++PFNGLVERTEXATTRIB2FVPROC glad_glVertexAttrib2fv;
++PFNGLEVALCOORD1DPROC glad_glEvalCoord1d;
++PFNGLGETTEXLEVELPARAMETERFVPROC glad_glGetTexLevelParameterfv;
++PFNGLEVALCOORD1FPROC glad_glEvalCoord1f;
++PFNGLPIXELMAPFVPROC glad_glPixelMapfv;
++PFNGLVERTEXATTRIBP3UIVPROC glad_glVertexAttribP3uiv;
++PFNGLGETPIXELMAPUSVPROC glad_glGetPixelMapusv;
++PFNGLSECONDARYCOLORP3UIVPROC glad_glSecondaryColorP3uiv;
++PFNGLGETINTEGERVPROC glad_glGetIntegerv;
++PFNGLACCUMPROC glad_glAccum;
++PFNGLGETBUFFERPOINTERVPROC glad_glGetBufferPointerv;
++PFNGLGETVERTEXATTRIBIIVPROC glad_glGetVertexAttribIiv;
++PFNGLRASTERPOS4DVPROC glad_glRasterPos4dv;
++PFNGLTEXCOORD2IVPROC glad_glTexCoord2iv;
++PFNGLISQUERYPROC glad_glIsQuery;
++PFNGLVERTEXATTRIB4SVPROC glad_glVertexAttrib4sv;
++PFNGLWINDOWPOS3DVPROC glad_glWindowPos3dv;
++PFNGLTEXIMAGE2DPROC glad_glTexImage2D;
++PFNGLSTENCILMASKPROC glad_glStencilMask;
++PFNGLDRAWPIXELSPROC glad_glDrawPixels;
++PFNGLMULTMATRIXDPROC glad_glMultMatrixd;
++PFNGLMULTMATRIXFPROC glad_glMultMatrixf;
++PFNGLISTEXTUREPROC glad_glIsTexture;
++PFNGLGETMATERIALIVPROC glad_glGetMaterialiv;
++PFNGLUNIFORM1FVPROC glad_glUniform1fv;
++PFNGLLOADMATRIXFPROC glad_glLoadMatrixf;
++PFNGLLOADMATRIXDPROC glad_glLoadMatrixd;
++PFNGLTEXPARAMETERFVPROC glad_glTexParameterfv;
++PFNGLUNIFORMMATRIX3FVPROC glad_glUniformMatrix3fv;
++PFNGLVERTEX4FPROC glad_glVertex4f;
++PFNGLRECTSVPROC glad_glRectsv;
++PFNGLCOLOR4USVPROC glad_glColor4usv;
++PFNGLPOLYGONSTIPPLEPROC glad_glPolygonStipple;
++PFNGLINTERLEAVEDARRAYSPROC glad_glInterleavedArrays;
++PFNGLNORMAL3IPROC glad_glNormal3i;
++PFNGLNORMAL3FPROC glad_glNormal3f;
++PFNGLNORMAL3DPROC glad_glNormal3d;
++PFNGLNORMAL3BPROC glad_glNormal3b;
++PFNGLPIXELMAPUSVPROC glad_glPixelMapusv;
++PFNGLGETTEXGENIVPROC glad_glGetTexGeniv;
++PFNGLARRAYELEMENTPROC glad_glArrayElement;
++PFNGLCOPYBUFFERSUBDATAPROC glad_glCopyBufferSubData;
++PFNGLVERTEXATTRIBI1UIVPROC glad_glVertexAttribI1uiv;
++PFNGLVERTEXATTRIB2DPROC glad_glVertexAttrib2d;
++PFNGLVERTEXATTRIB2FPROC glad_glVertexAttrib2f;
++PFNGLVERTEXATTRIB3DVPROC glad_glVertexAttrib3dv;
++PFNGLGETQUERYOBJECTUI64VPROC glad_glGetQueryObjectui64v;
++PFNGLDEPTHMASKPROC glad_glDepthMask;
++PFNGLVERTEXATTRIB2SPROC glad_glVertexAttrib2s;
++PFNGLCOLOR3FVPROC glad_glColor3fv;
++PFNGLTEXIMAGE3DMULTISAMPLEPROC glad_glTexImage3DMultisample;
++PFNGLUNIFORMMATRIX4FVPROC glad_glUniformMatrix4fv;
++PFNGLUNIFORM4FVPROC glad_glUniform4fv;
++PFNGLGETACTIVEUNIFORMPROC glad_glGetActiveUniform;
++PFNGLCOLORPOINTERPROC glad_glColorPointer;
++PFNGLFRONTFACEPROC glad_glFrontFace;
++PFNGLGETBOOLEANI_VPROC glad_glGetBooleani_v;
++PFNGLCLEARBUFFERUIVPROC glad_glClearBufferuiv;
++int GLAD_GL_ARB_pixel_buffer_object;
++int GLAD_GL_ARB_texture_non_power_of_two;
++static void load_GL_VERSION_1_0(GLADloadproc load) {
++ if (!GLAD_GL_VERSION_1_0) return;
++ glad_glCullFace = (PFNGLCULLFACEPROC)load("glCullFace");
++ glad_glFrontFace = (PFNGLFRONTFACEPROC)load("glFrontFace");
++ glad_glHint = (PFNGLHINTPROC)load("glHint");
++ glad_glLineWidth = (PFNGLLINEWIDTHPROC)load("glLineWidth");
++ glad_glPointSize = (PFNGLPOINTSIZEPROC)load("glPointSize");
++ glad_glPolygonMode = (PFNGLPOLYGONMODEPROC)load("glPolygonMode");
++ glad_glScissor = (PFNGLSCISSORPROC)load("glScissor");
++ glad_glTexParameterf = (PFNGLTEXPARAMETERFPROC)load("glTexParameterf");
++ glad_glTexParameterfv = (PFNGLTEXPARAMETERFVPROC)load("glTexParameterfv");
++ glad_glTexParameteri = (PFNGLTEXPARAMETERIPROC)load("glTexParameteri");
++ glad_glTexParameteriv = (PFNGLTEXPARAMETERIVPROC)load("glTexParameteriv");
++ glad_glTexImage1D = (PFNGLTEXIMAGE1DPROC)load("glTexImage1D");
++ glad_glTexImage2D = (PFNGLTEXIMAGE2DPROC)load("glTexImage2D");
++ glad_glDrawBuffer = (PFNGLDRAWBUFFERPROC)load("glDrawBuffer");
++ glad_glClear = (PFNGLCLEARPROC)load("glClear");
++ glad_glClearColor = (PFNGLCLEARCOLORPROC)load("glClearColor");
++ glad_glClearStencil = (PFNGLCLEARSTENCILPROC)load("glClearStencil");
++ glad_glClearDepth = (PFNGLCLEARDEPTHPROC)load("glClearDepth");
++ glad_glStencilMask = (PFNGLSTENCILMASKPROC)load("glStencilMask");
++ glad_glColorMask = (PFNGLCOLORMASKPROC)load("glColorMask");
++ glad_glDepthMask = (PFNGLDEPTHMASKPROC)load("glDepthMask");
++ glad_glDisable = (PFNGLDISABLEPROC)load("glDisable");
++ glad_glEnable = (PFNGLENABLEPROC)load("glEnable");
++ glad_glFinish = (PFNGLFINISHPROC)load("glFinish");
++ glad_glFlush = (PFNGLFLUSHPROC)load("glFlush");
++ glad_glBlendFunc = (PFNGLBLENDFUNCPROC)load("glBlendFunc");
++ glad_glLogicOp = (PFNGLLOGICOPPROC)load("glLogicOp");
++ glad_glStencilFunc = (PFNGLSTENCILFUNCPROC)load("glStencilFunc");
++ glad_glStencilOp = (PFNGLSTENCILOPPROC)load("glStencilOp");
++ glad_glDepthFunc = (PFNGLDEPTHFUNCPROC)load("glDepthFunc");
++ glad_glPixelStoref = (PFNGLPIXELSTOREFPROC)load("glPixelStoref");
++ glad_glPixelStorei = (PFNGLPIXELSTOREIPROC)load("glPixelStorei");
++ glad_glReadBuffer = (PFNGLREADBUFFERPROC)load("glReadBuffer");
++ glad_glReadPixels = (PFNGLREADPIXELSPROC)load("glReadPixels");
++ glad_glGetBooleanv = (PFNGLGETBOOLEANVPROC)load("glGetBooleanv");
++ glad_glGetDoublev = (PFNGLGETDOUBLEVPROC)load("glGetDoublev");
++ glad_glGetError = (PFNGLGETERRORPROC)load("glGetError");
++ glad_glGetFloatv = (PFNGLGETFLOATVPROC)load("glGetFloatv");
++ glad_glGetIntegerv = (PFNGLGETINTEGERVPROC)load("glGetIntegerv");
++ glad_glGetString = (PFNGLGETSTRINGPROC)load("glGetString");
++ glad_glGetTexImage = (PFNGLGETTEXIMAGEPROC)load("glGetTexImage");
++ glad_glGetTexParameterfv = (PFNGLGETTEXPARAMETERFVPROC)load("glGetTexParameterfv");
++ glad_glGetTexParameteriv = (PFNGLGETTEXPARAMETERIVPROC)load("glGetTexParameteriv");
++ glad_glGetTexLevelParameterfv = (PFNGLGETTEXLEVELPARAMETERFVPROC)load("glGetTexLevelParameterfv");
++ glad_glGetTexLevelParameteriv = (PFNGLGETTEXLEVELPARAMETERIVPROC)load("glGetTexLevelParameteriv");
++ glad_glIsEnabled = (PFNGLISENABLEDPROC)load("glIsEnabled");
++ glad_glDepthRange = (PFNGLDEPTHRANGEPROC)load("glDepthRange");
++ glad_glViewport = (PFNGLVIEWPORTPROC)load("glViewport");
++ glad_glNewList = (PFNGLNEWLISTPROC)load("glNewList");
++ glad_glEndList = (PFNGLENDLISTPROC)load("glEndList");
++ glad_glCallList = (PFNGLCALLLISTPROC)load("glCallList");
++ glad_glCallLists = (PFNGLCALLLISTSPROC)load("glCallLists");
++ glad_glDeleteLists = (PFNGLDELETELISTSPROC)load("glDeleteLists");
++ glad_glGenLists = (PFNGLGENLISTSPROC)load("glGenLists");
++ glad_glListBase = (PFNGLLISTBASEPROC)load("glListBase");
++ glad_glBegin = (PFNGLBEGINPROC)load("glBegin");
++ glad_glBitmap = (PFNGLBITMAPPROC)load("glBitmap");
++ glad_glColor3b = (PFNGLCOLOR3BPROC)load("glColor3b");
++ glad_glColor3bv = (PFNGLCOLOR3BVPROC)load("glColor3bv");
++ glad_glColor3d = (PFNGLCOLOR3DPROC)load("glColor3d");
++ glad_glColor3dv = (PFNGLCOLOR3DVPROC)load("glColor3dv");
++ glad_glColor3f = (PFNGLCOLOR3FPROC)load("glColor3f");
++ glad_glColor3fv = (PFNGLCOLOR3FVPROC)load("glColor3fv");
++ glad_glColor3i = (PFNGLCOLOR3IPROC)load("glColor3i");
++ glad_glColor3iv = (PFNGLCOLOR3IVPROC)load("glColor3iv");
++ glad_glColor3s = (PFNGLCOLOR3SPROC)load("glColor3s");
++ glad_glColor3sv = (PFNGLCOLOR3SVPROC)load("glColor3sv");
++ glad_glColor3ub = (PFNGLCOLOR3UBPROC)load("glColor3ub");
++ glad_glColor3ubv = (PFNGLCOLOR3UBVPROC)load("glColor3ubv");
++ glad_glColor3ui = (PFNGLCOLOR3UIPROC)load("glColor3ui");
++ glad_glColor3uiv = (PFNGLCOLOR3UIVPROC)load("glColor3uiv");
++ glad_glColor3us = (PFNGLCOLOR3USPROC)load("glColor3us");
++ glad_glColor3usv = (PFNGLCOLOR3USVPROC)load("glColor3usv");
++ glad_glColor4b = (PFNGLCOLOR4BPROC)load("glColor4b");
++ glad_glColor4bv = (PFNGLCOLOR4BVPROC)load("glColor4bv");
++ glad_glColor4d = (PFNGLCOLOR4DPROC)load("glColor4d");
++ glad_glColor4dv = (PFNGLCOLOR4DVPROC)load("glColor4dv");
++ glad_glColor4f = (PFNGLCOLOR4FPROC)load("glColor4f");
++ glad_glColor4fv = (PFNGLCOLOR4FVPROC)load("glColor4fv");
++ glad_glColor4i = (PFNGLCOLOR4IPROC)load("glColor4i");
++ glad_glColor4iv = (PFNGLCOLOR4IVPROC)load("glColor4iv");
++ glad_glColor4s = (PFNGLCOLOR4SPROC)load("glColor4s");
++ glad_glColor4sv = (PFNGLCOLOR4SVPROC)load("glColor4sv");
++ glad_glColor4ub = (PFNGLCOLOR4UBPROC)load("glColor4ub");
++ glad_glColor4ubv = (PFNGLCOLOR4UBVPROC)load("glColor4ubv");
++ glad_glColor4ui = (PFNGLCOLOR4UIPROC)load("glColor4ui");
++ glad_glColor4uiv = (PFNGLCOLOR4UIVPROC)load("glColor4uiv");
++ glad_glColor4us = (PFNGLCOLOR4USPROC)load("glColor4us");
++ glad_glColor4usv = (PFNGLCOLOR4USVPROC)load("glColor4usv");
++ glad_glEdgeFlag = (PFNGLEDGEFLAGPROC)load("glEdgeFlag");
++ glad_glEdgeFlagv = (PFNGLEDGEFLAGVPROC)load("glEdgeFlagv");
++ glad_glEnd = (PFNGLENDPROC)load("glEnd");
++ glad_glIndexd = (PFNGLINDEXDPROC)load("glIndexd");
++ glad_glIndexdv = (PFNGLINDEXDVPROC)load("glIndexdv");
++ glad_glIndexf = (PFNGLINDEXFPROC)load("glIndexf");
++ glad_glIndexfv = (PFNGLINDEXFVPROC)load("glIndexfv");
++ glad_glIndexi = (PFNGLINDEXIPROC)load("glIndexi");
++ glad_glIndexiv = (PFNGLINDEXIVPROC)load("glIndexiv");
++ glad_glIndexs = (PFNGLINDEXSPROC)load("glIndexs");
++ glad_glIndexsv = (PFNGLINDEXSVPROC)load("glIndexsv");
++ glad_glNormal3b = (PFNGLNORMAL3BPROC)load("glNormal3b");
++ glad_glNormal3bv = (PFNGLNORMAL3BVPROC)load("glNormal3bv");
++ glad_glNormal3d = (PFNGLNORMAL3DPROC)load("glNormal3d");
++ glad_glNormal3dv = (PFNGLNORMAL3DVPROC)load("glNormal3dv");
++ glad_glNormal3f = (PFNGLNORMAL3FPROC)load("glNormal3f");
++ glad_glNormal3fv = (PFNGLNORMAL3FVPROC)load("glNormal3fv");
++ glad_glNormal3i = (PFNGLNORMAL3IPROC)load("glNormal3i");
++ glad_glNormal3iv = (PFNGLNORMAL3IVPROC)load("glNormal3iv");
++ glad_glNormal3s = (PFNGLNORMAL3SPROC)load("glNormal3s");
++ glad_glNormal3sv = (PFNGLNORMAL3SVPROC)load("glNormal3sv");
++ glad_glRasterPos2d = (PFNGLRASTERPOS2DPROC)load("glRasterPos2d");
++ glad_glRasterPos2dv = (PFNGLRASTERPOS2DVPROC)load("glRasterPos2dv");
++ glad_glRasterPos2f = (PFNGLRASTERPOS2FPROC)load("glRasterPos2f");
++ glad_glRasterPos2fv = (PFNGLRASTERPOS2FVPROC)load("glRasterPos2fv");
++ glad_glRasterPos2i = (PFNGLRASTERPOS2IPROC)load("glRasterPos2i");
++ glad_glRasterPos2iv = (PFNGLRASTERPOS2IVPROC)load("glRasterPos2iv");
++ glad_glRasterPos2s = (PFNGLRASTERPOS2SPROC)load("glRasterPos2s");
++ glad_glRasterPos2sv = (PFNGLRASTERPOS2SVPROC)load("glRasterPos2sv");
++ glad_glRasterPos3d = (PFNGLRASTERPOS3DPROC)load("glRasterPos3d");
++ glad_glRasterPos3dv = (PFNGLRASTERPOS3DVPROC)load("glRasterPos3dv");
++ glad_glRasterPos3f = (PFNGLRASTERPOS3FPROC)load("glRasterPos3f");
++ glad_glRasterPos3fv = (PFNGLRASTERPOS3FVPROC)load("glRasterPos3fv");
++ glad_glRasterPos3i = (PFNGLRASTERPOS3IPROC)load("glRasterPos3i");
++ glad_glRasterPos3iv = (PFNGLRASTERPOS3IVPROC)load("glRasterPos3iv");
++ glad_glRasterPos3s = (PFNGLRASTERPOS3SPROC)load("glRasterPos3s");
++ glad_glRasterPos3sv = (PFNGLRASTERPOS3SVPROC)load("glRasterPos3sv");
++ glad_glRasterPos4d = (PFNGLRASTERPOS4DPROC)load("glRasterPos4d");
++ glad_glRasterPos4dv = (PFNGLRASTERPOS4DVPROC)load("glRasterPos4dv");
++ glad_glRasterPos4f = (PFNGLRASTERPOS4FPROC)load("glRasterPos4f");
++ glad_glRasterPos4fv = (PFNGLRASTERPOS4FVPROC)load("glRasterPos4fv");
++ glad_glRasterPos4i = (PFNGLRASTERPOS4IPROC)load("glRasterPos4i");
++ glad_glRasterPos4iv = (PFNGLRASTERPOS4IVPROC)load("glRasterPos4iv");
++ glad_glRasterPos4s = (PFNGLRASTERPOS4SPROC)load("glRasterPos4s");
++ glad_glRasterPos4sv = (PFNGLRASTERPOS4SVPROC)load("glRasterPos4sv");
++ glad_glRectd = (PFNGLRECTDPROC)load("glRectd");
++ glad_glRectdv = (PFNGLRECTDVPROC)load("glRectdv");
++ glad_glRectf = (PFNGLRECTFPROC)load("glRectf");
++ glad_glRectfv = (PFNGLRECTFVPROC)load("glRectfv");
++ glad_glRecti = (PFNGLRECTIPROC)load("glRecti");
++ glad_glRectiv = (PFNGLRECTIVPROC)load("glRectiv");
++ glad_glRects = (PFNGLRECTSPROC)load("glRects");
++ glad_glRectsv = (PFNGLRECTSVPROC)load("glRectsv");
++ glad_glTexCoord1d = (PFNGLTEXCOORD1DPROC)load("glTexCoord1d");
++ glad_glTexCoord1dv = (PFNGLTEXCOORD1DVPROC)load("glTexCoord1dv");
++ glad_glTexCoord1f = (PFNGLTEXCOORD1FPROC)load("glTexCoord1f");
++ glad_glTexCoord1fv = (PFNGLTEXCOORD1FVPROC)load("glTexCoord1fv");
++ glad_glTexCoord1i = (PFNGLTEXCOORD1IPROC)load("glTexCoord1i");
++ glad_glTexCoord1iv = (PFNGLTEXCOORD1IVPROC)load("glTexCoord1iv");
++ glad_glTexCoord1s = (PFNGLTEXCOORD1SPROC)load("glTexCoord1s");
++ glad_glTexCoord1sv = (PFNGLTEXCOORD1SVPROC)load("glTexCoord1sv");
++ glad_glTexCoord2d = (PFNGLTEXCOORD2DPROC)load("glTexCoord2d");
++ glad_glTexCoord2dv = (PFNGLTEXCOORD2DVPROC)load("glTexCoord2dv");
++ glad_glTexCoord2f = (PFNGLTEXCOORD2FPROC)load("glTexCoord2f");
++ glad_glTexCoord2fv = (PFNGLTEXCOORD2FVPROC)load("glTexCoord2fv");
++ glad_glTexCoord2i = (PFNGLTEXCOORD2IPROC)load("glTexCoord2i");
++ glad_glTexCoord2iv = (PFNGLTEXCOORD2IVPROC)load("glTexCoord2iv");
++ glad_glTexCoord2s = (PFNGLTEXCOORD2SPROC)load("glTexCoord2s");
++ glad_glTexCoord2sv = (PFNGLTEXCOORD2SVPROC)load("glTexCoord2sv");
++ glad_glTexCoord3d = (PFNGLTEXCOORD3DPROC)load("glTexCoord3d");
++ glad_glTexCoord3dv = (PFNGLTEXCOORD3DVPROC)load("glTexCoord3dv");
++ glad_glTexCoord3f = (PFNGLTEXCOORD3FPROC)load("glTexCoord3f");
++ glad_glTexCoord3fv = (PFNGLTEXCOORD3FVPROC)load("glTexCoord3fv");
++ glad_glTexCoord3i = (PFNGLTEXCOORD3IPROC)load("glTexCoord3i");
++ glad_glTexCoord3iv = (PFNGLTEXCOORD3IVPROC)load("glTexCoord3iv");
++ glad_glTexCoord3s = (PFNGLTEXCOORD3SPROC)load("glTexCoord3s");
++ glad_glTexCoord3sv = (PFNGLTEXCOORD3SVPROC)load("glTexCoord3sv");
++ glad_glTexCoord4d = (PFNGLTEXCOORD4DPROC)load("glTexCoord4d");
++ glad_glTexCoord4dv = (PFNGLTEXCOORD4DVPROC)load("glTexCoord4dv");
++ glad_glTexCoord4f = (PFNGLTEXCOORD4FPROC)load("glTexCoord4f");
++ glad_glTexCoord4fv = (PFNGLTEXCOORD4FVPROC)load("glTexCoord4fv");
++ glad_glTexCoord4i = (PFNGLTEXCOORD4IPROC)load("glTexCoord4i");
++ glad_glTexCoord4iv = (PFNGLTEXCOORD4IVPROC)load("glTexCoord4iv");
++ glad_glTexCoord4s = (PFNGLTEXCOORD4SPROC)load("glTexCoord4s");
++ glad_glTexCoord4sv = (PFNGLTEXCOORD4SVPROC)load("glTexCoord4sv");
++ glad_glVertex2d = (PFNGLVERTEX2DPROC)load("glVertex2d");
++ glad_glVertex2dv = (PFNGLVERTEX2DVPROC)load("glVertex2dv");
++ glad_glVertex2f = (PFNGLVERTEX2FPROC)load("glVertex2f");
++ glad_glVertex2fv = (PFNGLVERTEX2FVPROC)load("glVertex2fv");
++ glad_glVertex2i = (PFNGLVERTEX2IPROC)load("glVertex2i");
++ glad_glVertex2iv = (PFNGLVERTEX2IVPROC)load("glVertex2iv");
++ glad_glVertex2s = (PFNGLVERTEX2SPROC)load("glVertex2s");
++ glad_glVertex2sv = (PFNGLVERTEX2SVPROC)load("glVertex2sv");
++ glad_glVertex3d = (PFNGLVERTEX3DPROC)load("glVertex3d");
++ glad_glVertex3dv = (PFNGLVERTEX3DVPROC)load("glVertex3dv");
++ glad_glVertex3f = (PFNGLVERTEX3FPROC)load("glVertex3f");
++ glad_glVertex3fv = (PFNGLVERTEX3FVPROC)load("glVertex3fv");
++ glad_glVertex3i = (PFNGLVERTEX3IPROC)load("glVertex3i");
++ glad_glVertex3iv = (PFNGLVERTEX3IVPROC)load("glVertex3iv");
++ glad_glVertex3s = (PFNGLVERTEX3SPROC)load("glVertex3s");
++ glad_glVertex3sv = (PFNGLVERTEX3SVPROC)load("glVertex3sv");
++ glad_glVertex4d = (PFNGLVERTEX4DPROC)load("glVertex4d");
++ glad_glVertex4dv = (PFNGLVERTEX4DVPROC)load("glVertex4dv");
++ glad_glVertex4f = (PFNGLVERTEX4FPROC)load("glVertex4f");
++ glad_glVertex4fv = (PFNGLVERTEX4FVPROC)load("glVertex4fv");
++ glad_glVertex4i = (PFNGLVERTEX4IPROC)load("glVertex4i");
++ glad_glVertex4iv = (PFNGLVERTEX4IVPROC)load("glVertex4iv");
++ glad_glVertex4s = (PFNGLVERTEX4SPROC)load("glVertex4s");
++ glad_glVertex4sv = (PFNGLVERTEX4SVPROC)load("glVertex4sv");
++ glad_glClipPlane = (PFNGLCLIPPLANEPROC)load("glClipPlane");
++ glad_glColorMaterial = (PFNGLCOLORMATERIALPROC)load("glColorMaterial");
++ glad_glFogf = (PFNGLFOGFPROC)load("glFogf");
++ glad_glFogfv = (PFNGLFOGFVPROC)load("glFogfv");
++ glad_glFogi = (PFNGLFOGIPROC)load("glFogi");
++ glad_glFogiv = (PFNGLFOGIVPROC)load("glFogiv");
++ glad_glLightf = (PFNGLLIGHTFPROC)load("glLightf");
++ glad_glLightfv = (PFNGLLIGHTFVPROC)load("glLightfv");
++ glad_glLighti = (PFNGLLIGHTIPROC)load("glLighti");
++ glad_glLightiv = (PFNGLLIGHTIVPROC)load("glLightiv");
++ glad_glLightModelf = (PFNGLLIGHTMODELFPROC)load("glLightModelf");
++ glad_glLightModelfv = (PFNGLLIGHTMODELFVPROC)load("glLightModelfv");
++ glad_glLightModeli = (PFNGLLIGHTMODELIPROC)load("glLightModeli");
++ glad_glLightModeliv = (PFNGLLIGHTMODELIVPROC)load("glLightModeliv");
++ glad_glLineStipple = (PFNGLLINESTIPPLEPROC)load("glLineStipple");
++ glad_glMaterialf = (PFNGLMATERIALFPROC)load("glMaterialf");
++ glad_glMaterialfv = (PFNGLMATERIALFVPROC)load("glMaterialfv");
++ glad_glMateriali = (PFNGLMATERIALIPROC)load("glMateriali");
++ glad_glMaterialiv = (PFNGLMATERIALIVPROC)load("glMaterialiv");
++ glad_glPolygonStipple = (PFNGLPOLYGONSTIPPLEPROC)load("glPolygonStipple");
++ glad_glShadeModel = (PFNGLSHADEMODELPROC)load("glShadeModel");
++ glad_glTexEnvf = (PFNGLTEXENVFPROC)load("glTexEnvf");
++ glad_glTexEnvfv = (PFNGLTEXENVFVPROC)load("glTexEnvfv");
++ glad_glTexEnvi = (PFNGLTEXENVIPROC)load("glTexEnvi");
++ glad_glTexEnviv = (PFNGLTEXENVIVPROC)load("glTexEnviv");
++ glad_glTexGend = (PFNGLTEXGENDPROC)load("glTexGend");
++ glad_glTexGendv = (PFNGLTEXGENDVPROC)load("glTexGendv");
++ glad_glTexGenf = (PFNGLTEXGENFPROC)load("glTexGenf");
++ glad_glTexGenfv = (PFNGLTEXGENFVPROC)load("glTexGenfv");
++ glad_glTexGeni = (PFNGLTEXGENIPROC)load("glTexGeni");
++ glad_glTexGeniv = (PFNGLTEXGENIVPROC)load("glTexGeniv");
++ glad_glFeedbackBuffer = (PFNGLFEEDBACKBUFFERPROC)load("glFeedbackBuffer");
++ glad_glSelectBuffer = (PFNGLSELECTBUFFERPROC)load("glSelectBuffer");
++ glad_glRenderMode = (PFNGLRENDERMODEPROC)load("glRenderMode");
++ glad_glInitNames = (PFNGLINITNAMESPROC)load("glInitNames");
++ glad_glLoadName = (PFNGLLOADNAMEPROC)load("glLoadName");
++ glad_glPassThrough = (PFNGLPASSTHROUGHPROC)load("glPassThrough");
++ glad_glPopName = (PFNGLPOPNAMEPROC)load("glPopName");
++ glad_glPushName = (PFNGLPUSHNAMEPROC)load("glPushName");
++ glad_glClearAccum = (PFNGLCLEARACCUMPROC)load("glClearAccum");
++ glad_glClearIndex = (PFNGLCLEARINDEXPROC)load("glClearIndex");
++ glad_glIndexMask = (PFNGLINDEXMASKPROC)load("glIndexMask");
++ glad_glAccum = (PFNGLACCUMPROC)load("glAccum");
++ glad_glPopAttrib = (PFNGLPOPATTRIBPROC)load("glPopAttrib");
++ glad_glPushAttrib = (PFNGLPUSHATTRIBPROC)load("glPushAttrib");
++ glad_glMap1d = (PFNGLMAP1DPROC)load("glMap1d");
++ glad_glMap1f = (PFNGLMAP1FPROC)load("glMap1f");
++ glad_glMap2d = (PFNGLMAP2DPROC)load("glMap2d");
++ glad_glMap2f = (PFNGLMAP2FPROC)load("glMap2f");
++ glad_glMapGrid1d = (PFNGLMAPGRID1DPROC)load("glMapGrid1d");
++ glad_glMapGrid1f = (PFNGLMAPGRID1FPROC)load("glMapGrid1f");
++ glad_glMapGrid2d = (PFNGLMAPGRID2DPROC)load("glMapGrid2d");
++ glad_glMapGrid2f = (PFNGLMAPGRID2FPROC)load("glMapGrid2f");
++ glad_glEvalCoord1d = (PFNGLEVALCOORD1DPROC)load("glEvalCoord1d");
++ glad_glEvalCoord1dv = (PFNGLEVALCOORD1DVPROC)load("glEvalCoord1dv");
++ glad_glEvalCoord1f = (PFNGLEVALCOORD1FPROC)load("glEvalCoord1f");
++ glad_glEvalCoord1fv = (PFNGLEVALCOORD1FVPROC)load("glEvalCoord1fv");
++ glad_glEvalCoord2d = (PFNGLEVALCOORD2DPROC)load("glEvalCoord2d");
++ glad_glEvalCoord2dv = (PFNGLEVALCOORD2DVPROC)load("glEvalCoord2dv");
++ glad_glEvalCoord2f = (PFNGLEVALCOORD2FPROC)load("glEvalCoord2f");
++ glad_glEvalCoord2fv = (PFNGLEVALCOORD2FVPROC)load("glEvalCoord2fv");
++ glad_glEvalMesh1 = (PFNGLEVALMESH1PROC)load("glEvalMesh1");
++ glad_glEvalPoint1 = (PFNGLEVALPOINT1PROC)load("glEvalPoint1");
++ glad_glEvalMesh2 = (PFNGLEVALMESH2PROC)load("glEvalMesh2");
++ glad_glEvalPoint2 = (PFNGLEVALPOINT2PROC)load("glEvalPoint2");
++ glad_glAlphaFunc = (PFNGLALPHAFUNCPROC)load("glAlphaFunc");
++ glad_glPixelZoom = (PFNGLPIXELZOOMPROC)load("glPixelZoom");
++ glad_glPixelTransferf = (PFNGLPIXELTRANSFERFPROC)load("glPixelTransferf");
++ glad_glPixelTransferi = (PFNGLPIXELTRANSFERIPROC)load("glPixelTransferi");
++ glad_glPixelMapfv = (PFNGLPIXELMAPFVPROC)load("glPixelMapfv");
++ glad_glPixelMapuiv = (PFNGLPIXELMAPUIVPROC)load("glPixelMapuiv");
++ glad_glPixelMapusv = (PFNGLPIXELMAPUSVPROC)load("glPixelMapusv");
++ glad_glCopyPixels = (PFNGLCOPYPIXELSPROC)load("glCopyPixels");
++ glad_glDrawPixels = (PFNGLDRAWPIXELSPROC)load("glDrawPixels");
++ glad_glGetClipPlane = (PFNGLGETCLIPPLANEPROC)load("glGetClipPlane");
++ glad_glGetLightfv = (PFNGLGETLIGHTFVPROC)load("glGetLightfv");
++ glad_glGetLightiv = (PFNGLGETLIGHTIVPROC)load("glGetLightiv");
++ glad_glGetMapdv = (PFNGLGETMAPDVPROC)load("glGetMapdv");
++ glad_glGetMapfv = (PFNGLGETMAPFVPROC)load("glGetMapfv");
++ glad_glGetMapiv = (PFNGLGETMAPIVPROC)load("glGetMapiv");
++ glad_glGetMaterialfv = (PFNGLGETMATERIALFVPROC)load("glGetMaterialfv");
++ glad_glGetMaterialiv = (PFNGLGETMATERIALIVPROC)load("glGetMaterialiv");
++ glad_glGetPixelMapfv = (PFNGLGETPIXELMAPFVPROC)load("glGetPixelMapfv");
++ glad_glGetPixelMapuiv = (PFNGLGETPIXELMAPUIVPROC)load("glGetPixelMapuiv");
++ glad_glGetPixelMapusv = (PFNGLGETPIXELMAPUSVPROC)load("glGetPixelMapusv");
++ glad_glGetPolygonStipple = (PFNGLGETPOLYGONSTIPPLEPROC)load("glGetPolygonStipple");
++ glad_glGetTexEnvfv = (PFNGLGETTEXENVFVPROC)load("glGetTexEnvfv");
++ glad_glGetTexEnviv = (PFNGLGETTEXENVIVPROC)load("glGetTexEnviv");
++ glad_glGetTexGendv = (PFNGLGETTEXGENDVPROC)load("glGetTexGendv");
++ glad_glGetTexGenfv = (PFNGLGETTEXGENFVPROC)load("glGetTexGenfv");
++ glad_glGetTexGeniv = (PFNGLGETTEXGENIVPROC)load("glGetTexGeniv");
++ glad_glIsList = (PFNGLISLISTPROC)load("glIsList");
++ glad_glFrustum = (PFNGLFRUSTUMPROC)load("glFrustum");
++ glad_glLoadIdentity = (PFNGLLOADIDENTITYPROC)load("glLoadIdentity");
++ glad_glLoadMatrixf = (PFNGLLOADMATRIXFPROC)load("glLoadMatrixf");
++ glad_glLoadMatrixd = (PFNGLLOADMATRIXDPROC)load("glLoadMatrixd");
++ glad_glMatrixMode = (PFNGLMATRIXMODEPROC)load("glMatrixMode");
++ glad_glMultMatrixf = (PFNGLMULTMATRIXFPROC)load("glMultMatrixf");
++ glad_glMultMatrixd = (PFNGLMULTMATRIXDPROC)load("glMultMatrixd");
++ glad_glOrtho = (PFNGLORTHOPROC)load("glOrtho");
++ glad_glPopMatrix = (PFNGLPOPMATRIXPROC)load("glPopMatrix");
++ glad_glPushMatrix = (PFNGLPUSHMATRIXPROC)load("glPushMatrix");
++ glad_glRotated = (PFNGLROTATEDPROC)load("glRotated");
++ glad_glRotatef = (PFNGLROTATEFPROC)load("glRotatef");
++ glad_glScaled = (PFNGLSCALEDPROC)load("glScaled");
++ glad_glScalef = (PFNGLSCALEFPROC)load("glScalef");
++ glad_glTranslated = (PFNGLTRANSLATEDPROC)load("glTranslated");
++ glad_glTranslatef = (PFNGLTRANSLATEFPROC)load("glTranslatef");
++}
++static void load_GL_VERSION_1_1(GLADloadproc load) {
++ if (!GLAD_GL_VERSION_1_1) return;
++ glad_glDrawArrays = (PFNGLDRAWARRAYSPROC)load("glDrawArrays");
++ glad_glDrawElements = (PFNGLDRAWELEMENTSPROC)load("glDrawElements");
++ glad_glGetPointerv = (PFNGLGETPOINTERVPROC)load("glGetPointerv");
++ glad_glPolygonOffset = (PFNGLPOLYGONOFFSETPROC)load("glPolygonOffset");
++ glad_glCopyTexImage1D = (PFNGLCOPYTEXIMAGE1DPROC)load("glCopyTexImage1D");
++ glad_glCopyTexImage2D = (PFNGLCOPYTEXIMAGE2DPROC)load("glCopyTexImage2D");
++ glad_glCopyTexSubImage1D = (PFNGLCOPYTEXSUBIMAGE1DPROC)load("glCopyTexSubImage1D");
++ glad_glCopyTexSubImage2D = (PFNGLCOPYTEXSUBIMAGE2DPROC)load("glCopyTexSubImage2D");
++ glad_glTexSubImage1D = (PFNGLTEXSUBIMAGE1DPROC)load("glTexSubImage1D");
++ glad_glTexSubImage2D = (PFNGLTEXSUBIMAGE2DPROC)load("glTexSubImage2D");
++ glad_glBindTexture = (PFNGLBINDTEXTUREPROC)load("glBindTexture");
++ glad_glDeleteTextures = (PFNGLDELETETEXTURESPROC)load("glDeleteTextures");
++ glad_glGenTextures = (PFNGLGENTEXTURESPROC)load("glGenTextures");
++ glad_glIsTexture = (PFNGLISTEXTUREPROC)load("glIsTexture");
++ glad_glArrayElement = (PFNGLARRAYELEMENTPROC)load("glArrayElement");
++ glad_glColorPointer = (PFNGLCOLORPOINTERPROC)load("glColorPointer");
++ glad_glDisableClientState = (PFNGLDISABLECLIENTSTATEPROC)load("glDisableClientState");
++ glad_glEdgeFlagPointer = (PFNGLEDGEFLAGPOINTERPROC)load("glEdgeFlagPointer");
++ glad_glEnableClientState = (PFNGLENABLECLIENTSTATEPROC)load("glEnableClientState");
++ glad_glIndexPointer = (PFNGLINDEXPOINTERPROC)load("glIndexPointer");
++ glad_glInterleavedArrays = (PFNGLINTERLEAVEDARRAYSPROC)load("glInterleavedArrays");
++ glad_glNormalPointer = (PFNGLNORMALPOINTERPROC)load("glNormalPointer");
++ glad_glTexCoordPointer = (PFNGLTEXCOORDPOINTERPROC)load("glTexCoordPointer");
++ glad_glVertexPointer = (PFNGLVERTEXPOINTERPROC)load("glVertexPointer");
++ glad_glAreTexturesResident = (PFNGLARETEXTURESRESIDENTPROC)load("glAreTexturesResident");
++ glad_glPrioritizeTextures = (PFNGLPRIORITIZETEXTURESPROC)load("glPrioritizeTextures");
++ glad_glIndexub = (PFNGLINDEXUBPROC)load("glIndexub");
++ glad_glIndexubv = (PFNGLINDEXUBVPROC)load("glIndexubv");
++ glad_glPopClientAttrib = (PFNGLPOPCLIENTATTRIBPROC)load("glPopClientAttrib");
++ glad_glPushClientAttrib = (PFNGLPUSHCLIENTATTRIBPROC)load("glPushClientAttrib");
++}
++static void load_GL_VERSION_1_2(GLADloadproc load) {
++ if (!GLAD_GL_VERSION_1_2) return;
++ glad_glDrawRangeElements = (PFNGLDRAWRANGEELEMENTSPROC)load("glDrawRangeElements");
++ glad_glTexImage3D = (PFNGLTEXIMAGE3DPROC)load("glTexImage3D");
++ glad_glTexSubImage3D = (PFNGLTEXSUBIMAGE3DPROC)load("glTexSubImage3D");
++ glad_glCopyTexSubImage3D = (PFNGLCOPYTEXSUBIMAGE3DPROC)load("glCopyTexSubImage3D");
++}
++static void load_GL_VERSION_1_3(GLADloadproc load) {
++ if (!GLAD_GL_VERSION_1_3) return;
++ glad_glActiveTexture = (PFNGLACTIVETEXTUREPROC)load("glActiveTexture");
++ glad_glSampleCoverage = (PFNGLSAMPLECOVERAGEPROC)load("glSampleCoverage");
++ glad_glCompressedTexImage3D = (PFNGLCOMPRESSEDTEXIMAGE3DPROC)load("glCompressedTexImage3D");
++ glad_glCompressedTexImage2D = (PFNGLCOMPRESSEDTEXIMAGE2DPROC)load("glCompressedTexImage2D");
++ glad_glCompressedTexImage1D = (PFNGLCOMPRESSEDTEXIMAGE1DPROC)load("glCompressedTexImage1D");
++ glad_glCompressedTexSubImage3D = (PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC)load("glCompressedTexSubImage3D");
++ glad_glCompressedTexSubImage2D = (PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC)load("glCompressedTexSubImage2D");
++ glad_glCompressedTexSubImage1D = (PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC)load("glCompressedTexSubImage1D");
++ glad_glGetCompressedTexImage = (PFNGLGETCOMPRESSEDTEXIMAGEPROC)load("glGetCompressedTexImage");
++ glad_glClientActiveTexture = (PFNGLCLIENTACTIVETEXTUREPROC)load("glClientActiveTexture");
++ glad_glMultiTexCoord1d = (PFNGLMULTITEXCOORD1DPROC)load("glMultiTexCoord1d");
++ glad_glMultiTexCoord1dv = (PFNGLMULTITEXCOORD1DVPROC)load("glMultiTexCoord1dv");
++ glad_glMultiTexCoord1f = (PFNGLMULTITEXCOORD1FPROC)load("glMultiTexCoord1f");
++ glad_glMultiTexCoord1fv = (PFNGLMULTITEXCOORD1FVPROC)load("glMultiTexCoord1fv");
++ glad_glMultiTexCoord1i = (PFNGLMULTITEXCOORD1IPROC)load("glMultiTexCoord1i");
++ glad_glMultiTexCoord1iv = (PFNGLMULTITEXCOORD1IVPROC)load("glMultiTexCoord1iv");
++ glad_glMultiTexCoord1s = (PFNGLMULTITEXCOORD1SPROC)load("glMultiTexCoord1s");
++ glad_glMultiTexCoord1sv = (PFNGLMULTITEXCOORD1SVPROC)load("glMultiTexCoord1sv");
++ glad_glMultiTexCoord2d = (PFNGLMULTITEXCOORD2DPROC)load("glMultiTexCoord2d");
++ glad_glMultiTexCoord2dv = (PFNGLMULTITEXCOORD2DVPROC)load("glMultiTexCoord2dv");
++ glad_glMultiTexCoord2f = (PFNGLMULTITEXCOORD2FPROC)load("glMultiTexCoord2f");
++ glad_glMultiTexCoord2fv = (PFNGLMULTITEXCOORD2FVPROC)load("glMultiTexCoord2fv");
++ glad_glMultiTexCoord2i = (PFNGLMULTITEXCOORD2IPROC)load("glMultiTexCoord2i");
++ glad_glMultiTexCoord2iv = (PFNGLMULTITEXCOORD2IVPROC)load("glMultiTexCoord2iv");
++ glad_glMultiTexCoord2s = (PFNGLMULTITEXCOORD2SPROC)load("glMultiTexCoord2s");
++ glad_glMultiTexCoord2sv = (PFNGLMULTITEXCOORD2SVPROC)load("glMultiTexCoord2sv");
++ glad_glMultiTexCoord3d = (PFNGLMULTITEXCOORD3DPROC)load("glMultiTexCoord3d");
++ glad_glMultiTexCoord3dv = (PFNGLMULTITEXCOORD3DVPROC)load("glMultiTexCoord3dv");
++ glad_glMultiTexCoord3f = (PFNGLMULTITEXCOORD3FPROC)load("glMultiTexCoord3f");
++ glad_glMultiTexCoord3fv = (PFNGLMULTITEXCOORD3FVPROC)load("glMultiTexCoord3fv");
++ glad_glMultiTexCoord3i = (PFNGLMULTITEXCOORD3IPROC)load("glMultiTexCoord3i");
++ glad_glMultiTexCoord3iv = (PFNGLMULTITEXCOORD3IVPROC)load("glMultiTexCoord3iv");
++ glad_glMultiTexCoord3s = (PFNGLMULTITEXCOORD3SPROC)load("glMultiTexCoord3s");
++ glad_glMultiTexCoord3sv = (PFNGLMULTITEXCOORD3SVPROC)load("glMultiTexCoord3sv");
++ glad_glMultiTexCoord4d = (PFNGLMULTITEXCOORD4DPROC)load("glMultiTexCoord4d");
++ glad_glMultiTexCoord4dv = (PFNGLMULTITEXCOORD4DVPROC)load("glMultiTexCoord4dv");
++ glad_glMultiTexCoord4f = (PFNGLMULTITEXCOORD4FPROC)load("glMultiTexCoord4f");
++ glad_glMultiTexCoord4fv = (PFNGLMULTITEXCOORD4FVPROC)load("glMultiTexCoord4fv");
++ glad_glMultiTexCoord4i = (PFNGLMULTITEXCOORD4IPROC)load("glMultiTexCoord4i");
++ glad_glMultiTexCoord4iv = (PFNGLMULTITEXCOORD4IVPROC)load("glMultiTexCoord4iv");
++ glad_glMultiTexCoord4s = (PFNGLMULTITEXCOORD4SPROC)load("glMultiTexCoord4s");
++ glad_glMultiTexCoord4sv = (PFNGLMULTITEXCOORD4SVPROC)load("glMultiTexCoord4sv");
++ glad_glLoadTransposeMatrixf = (PFNGLLOADTRANSPOSEMATRIXFPROC)load("glLoadTransposeMatrixf");
++ glad_glLoadTransposeMatrixd = (PFNGLLOADTRANSPOSEMATRIXDPROC)load("glLoadTransposeMatrixd");
++ glad_glMultTransposeMatrixf = (PFNGLMULTTRANSPOSEMATRIXFPROC)load("glMultTransposeMatrixf");
++ glad_glMultTransposeMatrixd = (PFNGLMULTTRANSPOSEMATRIXDPROC)load("glMultTransposeMatrixd");
++}
++static void load_GL_VERSION_1_4(GLADloadproc load) {
++ if (!GLAD_GL_VERSION_1_4) return;
++ glad_glBlendFuncSeparate = (PFNGLBLENDFUNCSEPARATEPROC)load("glBlendFuncSeparate");
++ glad_glMultiDrawArrays = (PFNGLMULTIDRAWARRAYSPROC)load("glMultiDrawArrays");
++ glad_glMultiDrawElements = (PFNGLMULTIDRAWELEMENTSPROC)load("glMultiDrawElements");
++ glad_glPointParameterf = (PFNGLPOINTPARAMETERFPROC)load("glPointParameterf");
++ glad_glPointParameterfv = (PFNGLPOINTPARAMETERFVPROC)load("glPointParameterfv");
++ glad_glPointParameteri = (PFNGLPOINTPARAMETERIPROC)load("glPointParameteri");
++ glad_glPointParameteriv = (PFNGLPOINTPARAMETERIVPROC)load("glPointParameteriv");
++ glad_glFogCoordf = (PFNGLFOGCOORDFPROC)load("glFogCoordf");
++ glad_glFogCoordfv = (PFNGLFOGCOORDFVPROC)load("glFogCoordfv");
++ glad_glFogCoordd = (PFNGLFOGCOORDDPROC)load("glFogCoordd");
++ glad_glFogCoorddv = (PFNGLFOGCOORDDVPROC)load("glFogCoorddv");
++ glad_glFogCoordPointer = (PFNGLFOGCOORDPOINTERPROC)load("glFogCoordPointer");
++ glad_glSecondaryColor3b = (PFNGLSECONDARYCOLOR3BPROC)load("glSecondaryColor3b");
++ glad_glSecondaryColor3bv = (PFNGLSECONDARYCOLOR3BVPROC)load("glSecondaryColor3bv");
++ glad_glSecondaryColor3d = (PFNGLSECONDARYCOLOR3DPROC)load("glSecondaryColor3d");
++ glad_glSecondaryColor3dv = (PFNGLSECONDARYCOLOR3DVPROC)load("glSecondaryColor3dv");
++ glad_glSecondaryColor3f = (PFNGLSECONDARYCOLOR3FPROC)load("glSecondaryColor3f");
++ glad_glSecondaryColor3fv = (PFNGLSECONDARYCOLOR3FVPROC)load("glSecondaryColor3fv");
++ glad_glSecondaryColor3i = (PFNGLSECONDARYCOLOR3IPROC)load("glSecondaryColor3i");
++ glad_glSecondaryColor3iv = (PFNGLSECONDARYCOLOR3IVPROC)load("glSecondaryColor3iv");
++ glad_glSecondaryColor3s = (PFNGLSECONDARYCOLOR3SPROC)load("glSecondaryColor3s");
++ glad_glSecondaryColor3sv = (PFNGLSECONDARYCOLOR3SVPROC)load("glSecondaryColor3sv");
++ glad_glSecondaryColor3ub = (PFNGLSECONDARYCOLOR3UBPROC)load("glSecondaryColor3ub");
++ glad_glSecondaryColor3ubv = (PFNGLSECONDARYCOLOR3UBVPROC)load("glSecondaryColor3ubv");
++ glad_glSecondaryColor3ui = (PFNGLSECONDARYCOLOR3UIPROC)load("glSecondaryColor3ui");
++ glad_glSecondaryColor3uiv = (PFNGLSECONDARYCOLOR3UIVPROC)load("glSecondaryColor3uiv");
++ glad_glSecondaryColor3us = (PFNGLSECONDARYCOLOR3USPROC)load("glSecondaryColor3us");
++ glad_glSecondaryColor3usv = (PFNGLSECONDARYCOLOR3USVPROC)load("glSecondaryColor3usv");
++ glad_glSecondaryColorPointer = (PFNGLSECONDARYCOLORPOINTERPROC)load("glSecondaryColorPointer");
++ glad_glWindowPos2d = (PFNGLWINDOWPOS2DPROC)load("glWindowPos2d");
++ glad_glWindowPos2dv = (PFNGLWINDOWPOS2DVPROC)load("glWindowPos2dv");
++ glad_glWindowPos2f = (PFNGLWINDOWPOS2FPROC)load("glWindowPos2f");
++ glad_glWindowPos2fv = (PFNGLWINDOWPOS2FVPROC)load("glWindowPos2fv");
++ glad_glWindowPos2i = (PFNGLWINDOWPOS2IPROC)load("glWindowPos2i");
++ glad_glWindowPos2iv = (PFNGLWINDOWPOS2IVPROC)load("glWindowPos2iv");
++ glad_glWindowPos2s = (PFNGLWINDOWPOS2SPROC)load("glWindowPos2s");
++ glad_glWindowPos2sv = (PFNGLWINDOWPOS2SVPROC)load("glWindowPos2sv");
++ glad_glWindowPos3d = (PFNGLWINDOWPOS3DPROC)load("glWindowPos3d");
++ glad_glWindowPos3dv = (PFNGLWINDOWPOS3DVPROC)load("glWindowPos3dv");
++ glad_glWindowPos3f = (PFNGLWINDOWPOS3FPROC)load("glWindowPos3f");
++ glad_glWindowPos3fv = (PFNGLWINDOWPOS3FVPROC)load("glWindowPos3fv");
++ glad_glWindowPos3i = (PFNGLWINDOWPOS3IPROC)load("glWindowPos3i");
++ glad_glWindowPos3iv = (PFNGLWINDOWPOS3IVPROC)load("glWindowPos3iv");
++ glad_glWindowPos3s = (PFNGLWINDOWPOS3SPROC)load("glWindowPos3s");
++ glad_glWindowPos3sv = (PFNGLWINDOWPOS3SVPROC)load("glWindowPos3sv");
++ glad_glBlendColor = (PFNGLBLENDCOLORPROC)load("glBlendColor");
++ glad_glBlendEquation = (PFNGLBLENDEQUATIONPROC)load("glBlendEquation");
++}
++static void load_GL_VERSION_1_5(GLADloadproc load) {
++ if (!GLAD_GL_VERSION_1_5) return;
++ glad_glGenQueries = (PFNGLGENQUERIESPROC)load("glGenQueries");
++ glad_glDeleteQueries = (PFNGLDELETEQUERIESPROC)load("glDeleteQueries");
++ glad_glIsQuery = (PFNGLISQUERYPROC)load("glIsQuery");
++ glad_glBeginQuery = (PFNGLBEGINQUERYPROC)load("glBeginQuery");
++ glad_glEndQuery = (PFNGLENDQUERYPROC)load("glEndQuery");
++ glad_glGetQueryiv = (PFNGLGETQUERYIVPROC)load("glGetQueryiv");
++ glad_glGetQueryObjectiv = (PFNGLGETQUERYOBJECTIVPROC)load("glGetQueryObjectiv");
++ glad_glGetQueryObjectuiv = (PFNGLGETQUERYOBJECTUIVPROC)load("glGetQueryObjectuiv");
++ glad_glBindBuffer = (PFNGLBINDBUFFERPROC)load("glBindBuffer");
++ glad_glDeleteBuffers = (PFNGLDELETEBUFFERSPROC)load("glDeleteBuffers");
++ glad_glGenBuffers = (PFNGLGENBUFFERSPROC)load("glGenBuffers");
++ glad_glIsBuffer = (PFNGLISBUFFERPROC)load("glIsBuffer");
++ glad_glBufferData = (PFNGLBUFFERDATAPROC)load("glBufferData");
++ glad_glBufferSubData = (PFNGLBUFFERSUBDATAPROC)load("glBufferSubData");
++ glad_glGetBufferSubData = (PFNGLGETBUFFERSUBDATAPROC)load("glGetBufferSubData");
++ glad_glMapBuffer = (PFNGLMAPBUFFERPROC)load("glMapBuffer");
++ glad_glUnmapBuffer = (PFNGLUNMAPBUFFERPROC)load("glUnmapBuffer");
++ glad_glGetBufferParameteriv = (PFNGLGETBUFFERPARAMETERIVPROC)load("glGetBufferParameteriv");
++ glad_glGetBufferPointerv = (PFNGLGETBUFFERPOINTERVPROC)load("glGetBufferPointerv");
++}
++static void load_GL_VERSION_2_0(GLADloadproc load) {
++ if (!GLAD_GL_VERSION_2_0) return;
++ glad_glBlendEquationSeparate = (PFNGLBLENDEQUATIONSEPARATEPROC)load("glBlendEquationSeparate");
++ glad_glDrawBuffers = (PFNGLDRAWBUFFERSPROC)load("glDrawBuffers");
++ glad_glStencilOpSeparate = (PFNGLSTENCILOPSEPARATEPROC)load("glStencilOpSeparate");
++ glad_glStencilFuncSeparate = (PFNGLSTENCILFUNCSEPARATEPROC)load("glStencilFuncSeparate");
++ glad_glStencilMaskSeparate = (PFNGLSTENCILMASKSEPARATEPROC)load("glStencilMaskSeparate");
++ glad_glAttachShader = (PFNGLATTACHSHADERPROC)load("glAttachShader");
++ glad_glBindAttribLocation = (PFNGLBINDATTRIBLOCATIONPROC)load("glBindAttribLocation");
++ glad_glCompileShader = (PFNGLCOMPILESHADERPROC)load("glCompileShader");
++ glad_glCreateProgram = (PFNGLCREATEPROGRAMPROC)load("glCreateProgram");
++ glad_glCreateShader = (PFNGLCREATESHADERPROC)load("glCreateShader");
++ glad_glDeleteProgram = (PFNGLDELETEPROGRAMPROC)load("glDeleteProgram");
++ glad_glDeleteShader = (PFNGLDELETESHADERPROC)load("glDeleteShader");
++ glad_glDetachShader = (PFNGLDETACHSHADERPROC)load("glDetachShader");
++ glad_glDisableVertexAttribArray = (PFNGLDISABLEVERTEXATTRIBARRAYPROC)load("glDisableVertexAttribArray");
++ glad_glEnableVertexAttribArray = (PFNGLENABLEVERTEXATTRIBARRAYPROC)load("glEnableVertexAttribArray");
++ glad_glGetActiveAttrib = (PFNGLGETACTIVEATTRIBPROC)load("glGetActiveAttrib");
++ glad_glGetActiveUniform = (PFNGLGETACTIVEUNIFORMPROC)load("glGetActiveUniform");
++ glad_glGetAttachedShaders = (PFNGLGETATTACHEDSHADERSPROC)load("glGetAttachedShaders");
++ glad_glGetAttribLocation = (PFNGLGETATTRIBLOCATIONPROC)load("glGetAttribLocation");
++ glad_glGetProgramiv = (PFNGLGETPROGRAMIVPROC)load("glGetProgramiv");
++ glad_glGetProgramInfoLog = (PFNGLGETPROGRAMINFOLOGPROC)load("glGetProgramInfoLog");
++ glad_glGetShaderiv = (PFNGLGETSHADERIVPROC)load("glGetShaderiv");
++ glad_glGetShaderInfoLog = (PFNGLGETSHADERINFOLOGPROC)load("glGetShaderInfoLog");
++ glad_glGetShaderSource = (PFNGLGETSHADERSOURCEPROC)load("glGetShaderSource");
++ glad_glGetUniformLocation = (PFNGLGETUNIFORMLOCATIONPROC)load("glGetUniformLocation");
++ glad_glGetUniformfv = (PFNGLGETUNIFORMFVPROC)load("glGetUniformfv");
++ glad_glGetUniformiv = (PFNGLGETUNIFORMIVPROC)load("glGetUniformiv");
++ glad_glGetVertexAttribdv = (PFNGLGETVERTEXATTRIBDVPROC)load("glGetVertexAttribdv");
++ glad_glGetVertexAttribfv = (PFNGLGETVERTEXATTRIBFVPROC)load("glGetVertexAttribfv");
++ glad_glGetVertexAttribiv = (PFNGLGETVERTEXATTRIBIVPROC)load("glGetVertexAttribiv");
++ glad_glGetVertexAttribPointerv = (PFNGLGETVERTEXATTRIBPOINTERVPROC)load("glGetVertexAttribPointerv");
++ glad_glIsProgram = (PFNGLISPROGRAMPROC)load("glIsProgram");
++ glad_glIsShader = (PFNGLISSHADERPROC)load("glIsShader");
++ glad_glLinkProgram = (PFNGLLINKPROGRAMPROC)load("glLinkProgram");
++ glad_glShaderSource = (PFNGLSHADERSOURCEPROC)load("glShaderSource");
++ glad_glUseProgram = (PFNGLUSEPROGRAMPROC)load("glUseProgram");
++ glad_glUniform1f = (PFNGLUNIFORM1FPROC)load("glUniform1f");
++ glad_glUniform2f = (PFNGLUNIFORM2FPROC)load("glUniform2f");
++ glad_glUniform3f = (PFNGLUNIFORM3FPROC)load("glUniform3f");
++ glad_glUniform4f = (PFNGLUNIFORM4FPROC)load("glUniform4f");
++ glad_glUniform1i = (PFNGLUNIFORM1IPROC)load("glUniform1i");
++ glad_glUniform2i = (PFNGLUNIFORM2IPROC)load("glUniform2i");
++ glad_glUniform3i = (PFNGLUNIFORM3IPROC)load("glUniform3i");
++ glad_glUniform4i = (PFNGLUNIFORM4IPROC)load("glUniform4i");
++ glad_glUniform1fv = (PFNGLUNIFORM1FVPROC)load("glUniform1fv");
++ glad_glUniform2fv = (PFNGLUNIFORM2FVPROC)load("glUniform2fv");
++ glad_glUniform3fv = (PFNGLUNIFORM3FVPROC)load("glUniform3fv");
++ glad_glUniform4fv = (PFNGLUNIFORM4FVPROC)load("glUniform4fv");
++ glad_glUniform1iv = (PFNGLUNIFORM1IVPROC)load("glUniform1iv");
++ glad_glUniform2iv = (PFNGLUNIFORM2IVPROC)load("glUniform2iv");
++ glad_glUniform3iv = (PFNGLUNIFORM3IVPROC)load("glUniform3iv");
++ glad_glUniform4iv = (PFNGLUNIFORM4IVPROC)load("glUniform4iv");
++ glad_glUniformMatrix2fv = (PFNGLUNIFORMMATRIX2FVPROC)load("glUniformMatrix2fv");
++ glad_glUniformMatrix3fv = (PFNGLUNIFORMMATRIX3FVPROC)load("glUniformMatrix3fv");
++ glad_glUniformMatrix4fv = (PFNGLUNIFORMMATRIX4FVPROC)load("glUniformMatrix4fv");
++ glad_glValidateProgram = (PFNGLVALIDATEPROGRAMPROC)load("glValidateProgram");
++ glad_glVertexAttrib1d = (PFNGLVERTEXATTRIB1DPROC)load("glVertexAttrib1d");
++ glad_glVertexAttrib1dv = (PFNGLVERTEXATTRIB1DVPROC)load("glVertexAttrib1dv");
++ glad_glVertexAttrib1f = (PFNGLVERTEXATTRIB1FPROC)load("glVertexAttrib1f");
++ glad_glVertexAttrib1fv = (PFNGLVERTEXATTRIB1FVPROC)load("glVertexAttrib1fv");
++ glad_glVertexAttrib1s = (PFNGLVERTEXATTRIB1SPROC)load("glVertexAttrib1s");
++ glad_glVertexAttrib1sv = (PFNGLVERTEXATTRIB1SVPROC)load("glVertexAttrib1sv");
++ glad_glVertexAttrib2d = (PFNGLVERTEXATTRIB2DPROC)load("glVertexAttrib2d");
++ glad_glVertexAttrib2dv = (PFNGLVERTEXATTRIB2DVPROC)load("glVertexAttrib2dv");
++ glad_glVertexAttrib2f = (PFNGLVERTEXATTRIB2FPROC)load("glVertexAttrib2f");
++ glad_glVertexAttrib2fv = (PFNGLVERTEXATTRIB2FVPROC)load("glVertexAttrib2fv");
++ glad_glVertexAttrib2s = (PFNGLVERTEXATTRIB2SPROC)load("glVertexAttrib2s");
++ glad_glVertexAttrib2sv = (PFNGLVERTEXATTRIB2SVPROC)load("glVertexAttrib2sv");
++ glad_glVertexAttrib3d = (PFNGLVERTEXATTRIB3DPROC)load("glVertexAttrib3d");
++ glad_glVertexAttrib3dv = (PFNGLVERTEXATTRIB3DVPROC)load("glVertexAttrib3dv");
++ glad_glVertexAttrib3f = (PFNGLVERTEXATTRIB3FPROC)load("glVertexAttrib3f");
++ glad_glVertexAttrib3fv = (PFNGLVERTEXATTRIB3FVPROC)load("glVertexAttrib3fv");
++ glad_glVertexAttrib3s = (PFNGLVERTEXATTRIB3SPROC)load("glVertexAttrib3s");
++ glad_glVertexAttrib3sv = (PFNGLVERTEXATTRIB3SVPROC)load("glVertexAttrib3sv");
++ glad_glVertexAttrib4Nbv = (PFNGLVERTEXATTRIB4NBVPROC)load("glVertexAttrib4Nbv");
++ glad_glVertexAttrib4Niv = (PFNGLVERTEXATTRIB4NIVPROC)load("glVertexAttrib4Niv");
++ glad_glVertexAttrib4Nsv = (PFNGLVERTEXATTRIB4NSVPROC)load("glVertexAttrib4Nsv");
++ glad_glVertexAttrib4Nub = (PFNGLVERTEXATTRIB4NUBPROC)load("glVertexAttrib4Nub");
++ glad_glVertexAttrib4Nubv = (PFNGLVERTEXATTRIB4NUBVPROC)load("glVertexAttrib4Nubv");
++ glad_glVertexAttrib4Nuiv = (PFNGLVERTEXATTRIB4NUIVPROC)load("glVertexAttrib4Nuiv");
++ glad_glVertexAttrib4Nusv = (PFNGLVERTEXATTRIB4NUSVPROC)load("glVertexAttrib4Nusv");
++ glad_glVertexAttrib4bv = (PFNGLVERTEXATTRIB4BVPROC)load("glVertexAttrib4bv");
++ glad_glVertexAttrib4d = (PFNGLVERTEXATTRIB4DPROC)load("glVertexAttrib4d");
++ glad_glVertexAttrib4dv = (PFNGLVERTEXATTRIB4DVPROC)load("glVertexAttrib4dv");
++ glad_glVertexAttrib4f = (PFNGLVERTEXATTRIB4FPROC)load("glVertexAttrib4f");
++ glad_glVertexAttrib4fv = (PFNGLVERTEXATTRIB4FVPROC)load("glVertexAttrib4fv");
++ glad_glVertexAttrib4iv = (PFNGLVERTEXATTRIB4IVPROC)load("glVertexAttrib4iv");
++ glad_glVertexAttrib4s = (PFNGLVERTEXATTRIB4SPROC)load("glVertexAttrib4s");
++ glad_glVertexAttrib4sv = (PFNGLVERTEXATTRIB4SVPROC)load("glVertexAttrib4sv");
++ glad_glVertexAttrib4ubv = (PFNGLVERTEXATTRIB4UBVPROC)load("glVertexAttrib4ubv");
++ glad_glVertexAttrib4uiv = (PFNGLVERTEXATTRIB4UIVPROC)load("glVertexAttrib4uiv");
++ glad_glVertexAttrib4usv = (PFNGLVERTEXATTRIB4USVPROC)load("glVertexAttrib4usv");
++ glad_glVertexAttribPointer = (PFNGLVERTEXATTRIBPOINTERPROC)load("glVertexAttribPointer");
++}
++static void load_GL_VERSION_2_1(GLADloadproc load) {
++ if (!GLAD_GL_VERSION_2_1) return;
++ glad_glUniformMatrix2x3fv = (PFNGLUNIFORMMATRIX2X3FVPROC)load("glUniformMatrix2x3fv");
++ glad_glUniformMatrix3x2fv = (PFNGLUNIFORMMATRIX3X2FVPROC)load("glUniformMatrix3x2fv");
++ glad_glUniformMatrix2x4fv = (PFNGLUNIFORMMATRIX2X4FVPROC)load("glUniformMatrix2x4fv");
++ glad_glUniformMatrix4x2fv = (PFNGLUNIFORMMATRIX4X2FVPROC)load("glUniformMatrix4x2fv");
++ glad_glUniformMatrix3x4fv = (PFNGLUNIFORMMATRIX3X4FVPROC)load("glUniformMatrix3x4fv");
++ glad_glUniformMatrix4x3fv = (PFNGLUNIFORMMATRIX4X3FVPROC)load("glUniformMatrix4x3fv");
++}
++static void load_GL_VERSION_3_0(GLADloadproc load) {
++ if (!GLAD_GL_VERSION_3_0) return;
++ glad_glColorMaski = (PFNGLCOLORMASKIPROC)load("glColorMaski");
++ glad_glGetBooleani_v = (PFNGLGETBOOLEANI_VPROC)load("glGetBooleani_v");
++ glad_glGetIntegeri_v = (PFNGLGETINTEGERI_VPROC)load("glGetIntegeri_v");
++ glad_glEnablei = (PFNGLENABLEIPROC)load("glEnablei");
++ glad_glDisablei = (PFNGLDISABLEIPROC)load("glDisablei");
++ glad_glIsEnabledi = (PFNGLISENABLEDIPROC)load("glIsEnabledi");
++ glad_glBeginTransformFeedback = (PFNGLBEGINTRANSFORMFEEDBACKPROC)load("glBeginTransformFeedback");
++ glad_glEndTransformFeedback = (PFNGLENDTRANSFORMFEEDBACKPROC)load("glEndTransformFeedback");
++ glad_glBindBufferRange = (PFNGLBINDBUFFERRANGEPROC)load("glBindBufferRange");
++ glad_glBindBufferBase = (PFNGLBINDBUFFERBASEPROC)load("glBindBufferBase");
++ glad_glTransformFeedbackVaryings = (PFNGLTRANSFORMFEEDBACKVARYINGSPROC)load("glTransformFeedbackVaryings");
++ glad_glGetTransformFeedbackVarying = (PFNGLGETTRANSFORMFEEDBACKVARYINGPROC)load("glGetTransformFeedbackVarying");
++ glad_glClampColor = (PFNGLCLAMPCOLORPROC)load("glClampColor");
++ glad_glBeginConditionalRender = (PFNGLBEGINCONDITIONALRENDERPROC)load("glBeginConditionalRender");
++ glad_glEndConditionalRender = (PFNGLENDCONDITIONALRENDERPROC)load("glEndConditionalRender");
++ glad_glVertexAttribIPointer = (PFNGLVERTEXATTRIBIPOINTERPROC)load("glVertexAttribIPointer");
++ glad_glGetVertexAttribIiv = (PFNGLGETVERTEXATTRIBIIVPROC)load("glGetVertexAttribIiv");
++ glad_glGetVertexAttribIuiv = (PFNGLGETVERTEXATTRIBIUIVPROC)load("glGetVertexAttribIuiv");
++ glad_glVertexAttribI1i = (PFNGLVERTEXATTRIBI1IPROC)load("glVertexAttribI1i");
++ glad_glVertexAttribI2i = (PFNGLVERTEXATTRIBI2IPROC)load("glVertexAttribI2i");
++ glad_glVertexAttribI3i = (PFNGLVERTEXATTRIBI3IPROC)load("glVertexAttribI3i");
++ glad_glVertexAttribI4i = (PFNGLVERTEXATTRIBI4IPROC)load("glVertexAttribI4i");
++ glad_glVertexAttribI1ui = (PFNGLVERTEXATTRIBI1UIPROC)load("glVertexAttribI1ui");
++ glad_glVertexAttribI2ui = (PFNGLVERTEXATTRIBI2UIPROC)load("glVertexAttribI2ui");
++ glad_glVertexAttribI3ui = (PFNGLVERTEXATTRIBI3UIPROC)load("glVertexAttribI3ui");
++ glad_glVertexAttribI4ui = (PFNGLVERTEXATTRIBI4UIPROC)load("glVertexAttribI4ui");
++ glad_glVertexAttribI1iv = (PFNGLVERTEXATTRIBI1IVPROC)load("glVertexAttribI1iv");
++ glad_glVertexAttribI2iv = (PFNGLVERTEXATTRIBI2IVPROC)load("glVertexAttribI2iv");
++ glad_glVertexAttribI3iv = (PFNGLVERTEXATTRIBI3IVPROC)load("glVertexAttribI3iv");
++ glad_glVertexAttribI4iv = (PFNGLVERTEXATTRIBI4IVPROC)load("glVertexAttribI4iv");
++ glad_glVertexAttribI1uiv = (PFNGLVERTEXATTRIBI1UIVPROC)load("glVertexAttribI1uiv");
++ glad_glVertexAttribI2uiv = (PFNGLVERTEXATTRIBI2UIVPROC)load("glVertexAttribI2uiv");
++ glad_glVertexAttribI3uiv = (PFNGLVERTEXATTRIBI3UIVPROC)load("glVertexAttribI3uiv");
++ glad_glVertexAttribI4uiv = (PFNGLVERTEXATTRIBI4UIVPROC)load("glVertexAttribI4uiv");
++ glad_glVertexAttribI4bv = (PFNGLVERTEXATTRIBI4BVPROC)load("glVertexAttribI4bv");
++ glad_glVertexAttribI4sv = (PFNGLVERTEXATTRIBI4SVPROC)load("glVertexAttribI4sv");
++ glad_glVertexAttribI4ubv = (PFNGLVERTEXATTRIBI4UBVPROC)load("glVertexAttribI4ubv");
++ glad_glVertexAttribI4usv = (PFNGLVERTEXATTRIBI4USVPROC)load("glVertexAttribI4usv");
++ glad_glGetUniformuiv = (PFNGLGETUNIFORMUIVPROC)load("glGetUniformuiv");
++ glad_glBindFragDataLocation = (PFNGLBINDFRAGDATALOCATIONPROC)load("glBindFragDataLocation");
++ glad_glGetFragDataLocation = (PFNGLGETFRAGDATALOCATIONPROC)load("glGetFragDataLocation");
++ glad_glUniform1ui = (PFNGLUNIFORM1UIPROC)load("glUniform1ui");
++ glad_glUniform2ui = (PFNGLUNIFORM2UIPROC)load("glUniform2ui");
++ glad_glUniform3ui = (PFNGLUNIFORM3UIPROC)load("glUniform3ui");
++ glad_glUniform4ui = (PFNGLUNIFORM4UIPROC)load("glUniform4ui");
++ glad_glUniform1uiv = (PFNGLUNIFORM1UIVPROC)load("glUniform1uiv");
++ glad_glUniform2uiv = (PFNGLUNIFORM2UIVPROC)load("glUniform2uiv");
++ glad_glUniform3uiv = (PFNGLUNIFORM3UIVPROC)load("glUniform3uiv");
++ glad_glUniform4uiv = (PFNGLUNIFORM4UIVPROC)load("glUniform4uiv");
++ glad_glTexParameterIiv = (PFNGLTEXPARAMETERIIVPROC)load("glTexParameterIiv");
++ glad_glTexParameterIuiv = (PFNGLTEXPARAMETERIUIVPROC)load("glTexParameterIuiv");
++ glad_glGetTexParameterIiv = (PFNGLGETTEXPARAMETERIIVPROC)load("glGetTexParameterIiv");
++ glad_glGetTexParameterIuiv = (PFNGLGETTEXPARAMETERIUIVPROC)load("glGetTexParameterIuiv");
++ glad_glClearBufferiv = (PFNGLCLEARBUFFERIVPROC)load("glClearBufferiv");
++ glad_glClearBufferuiv = (PFNGLCLEARBUFFERUIVPROC)load("glClearBufferuiv");
++ glad_glClearBufferfv = (PFNGLCLEARBUFFERFVPROC)load("glClearBufferfv");
++ glad_glClearBufferfi = (PFNGLCLEARBUFFERFIPROC)load("glClearBufferfi");
++ glad_glGetStringi = (PFNGLGETSTRINGIPROC)load("glGetStringi");
++ glad_glIsRenderbuffer = (PFNGLISRENDERBUFFERPROC)load("glIsRenderbuffer");
++ glad_glBindRenderbuffer = (PFNGLBINDRENDERBUFFERPROC)load("glBindRenderbuffer");
++ glad_glDeleteRenderbuffers = (PFNGLDELETERENDERBUFFERSPROC)load("glDeleteRenderbuffers");
++ glad_glGenRenderbuffers = (PFNGLGENRENDERBUFFERSPROC)load("glGenRenderbuffers");
++ glad_glRenderbufferStorage = (PFNGLRENDERBUFFERSTORAGEPROC)load("glRenderbufferStorage");
++ glad_glGetRenderbufferParameteriv = (PFNGLGETRENDERBUFFERPARAMETERIVPROC)load("glGetRenderbufferParameteriv");
++ glad_glIsFramebuffer = (PFNGLISFRAMEBUFFERPROC)load("glIsFramebuffer");
++ glad_glBindFramebuffer = (PFNGLBINDFRAMEBUFFERPROC)load("glBindFramebuffer");
++ glad_glDeleteFramebuffers = (PFNGLDELETEFRAMEBUFFERSPROC)load("glDeleteFramebuffers");
++ glad_glGenFramebuffers = (PFNGLGENFRAMEBUFFERSPROC)load("glGenFramebuffers");
++ glad_glCheckFramebufferStatus = (PFNGLCHECKFRAMEBUFFERSTATUSPROC)load("glCheckFramebufferStatus");
++ glad_glFramebufferTexture1D = (PFNGLFRAMEBUFFERTEXTURE1DPROC)load("glFramebufferTexture1D");
++ glad_glFramebufferTexture2D = (PFNGLFRAMEBUFFERTEXTURE2DPROC)load("glFramebufferTexture2D");
++ glad_glFramebufferTexture3D = (PFNGLFRAMEBUFFERTEXTURE3DPROC)load("glFramebufferTexture3D");
++ glad_glFramebufferRenderbuffer = (PFNGLFRAMEBUFFERRENDERBUFFERPROC)load("glFramebufferRenderbuffer");
++ glad_glGetFramebufferAttachmentParameteriv = (PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC)load("glGetFramebufferAttachmentParameteriv");
++ glad_glGenerateMipmap = (PFNGLGENERATEMIPMAPPROC)load("glGenerateMipmap");
++ glad_glBlitFramebuffer = (PFNGLBLITFRAMEBUFFERPROC)load("glBlitFramebuffer");
++ glad_glRenderbufferStorageMultisample = (PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC)load("glRenderbufferStorageMultisample");
++ glad_glFramebufferTextureLayer = (PFNGLFRAMEBUFFERTEXTURELAYERPROC)load("glFramebufferTextureLayer");
++ glad_glMapBufferRange = (PFNGLMAPBUFFERRANGEPROC)load("glMapBufferRange");
++ glad_glFlushMappedBufferRange = (PFNGLFLUSHMAPPEDBUFFERRANGEPROC)load("glFlushMappedBufferRange");
++ glad_glBindVertexArray = (PFNGLBINDVERTEXARRAYPROC)load("glBindVertexArray");
++ glad_glDeleteVertexArrays = (PFNGLDELETEVERTEXARRAYSPROC)load("glDeleteVertexArrays");
++ glad_glGenVertexArrays = (PFNGLGENVERTEXARRAYSPROC)load("glGenVertexArrays");
++ glad_glIsVertexArray = (PFNGLISVERTEXARRAYPROC)load("glIsVertexArray");
++}
++static void load_GL_VERSION_3_1(GLADloadproc load) {
++ if (!GLAD_GL_VERSION_3_1) return;
++ glad_glDrawArraysInstanced = (PFNGLDRAWARRAYSINSTANCEDPROC)load("glDrawArraysInstanced");
++ glad_glDrawElementsInstanced = (PFNGLDRAWELEMENTSINSTANCEDPROC)load("glDrawElementsInstanced");
++ glad_glTexBuffer = (PFNGLTEXBUFFERPROC)load("glTexBuffer");
++ glad_glPrimitiveRestartIndex = (PFNGLPRIMITIVERESTARTINDEXPROC)load("glPrimitiveRestartIndex");
++ glad_glCopyBufferSubData = (PFNGLCOPYBUFFERSUBDATAPROC)load("glCopyBufferSubData");
++ glad_glGetUniformIndices = (PFNGLGETUNIFORMINDICESPROC)load("glGetUniformIndices");
++ glad_glGetActiveUniformsiv = (PFNGLGETACTIVEUNIFORMSIVPROC)load("glGetActiveUniformsiv");
++ glad_glGetActiveUniformName = (PFNGLGETACTIVEUNIFORMNAMEPROC)load("glGetActiveUniformName");
++ glad_glGetUniformBlockIndex = (PFNGLGETUNIFORMBLOCKINDEXPROC)load("glGetUniformBlockIndex");
++ glad_glGetActiveUniformBlockiv = (PFNGLGETACTIVEUNIFORMBLOCKIVPROC)load("glGetActiveUniformBlockiv");
++ glad_glGetActiveUniformBlockName = (PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC)load("glGetActiveUniformBlockName");
++ glad_glUniformBlockBinding = (PFNGLUNIFORMBLOCKBINDINGPROC)load("glUniformBlockBinding");
++ glad_glBindBufferRange = (PFNGLBINDBUFFERRANGEPROC)load("glBindBufferRange");
++ glad_glBindBufferBase = (PFNGLBINDBUFFERBASEPROC)load("glBindBufferBase");
++ glad_glGetIntegeri_v = (PFNGLGETINTEGERI_VPROC)load("glGetIntegeri_v");
++}
++static void load_GL_VERSION_3_2(GLADloadproc load) {
++ if (!GLAD_GL_VERSION_3_2) return;
++ glad_glDrawElementsBaseVertex = (PFNGLDRAWELEMENTSBASEVERTEXPROC)load("glDrawElementsBaseVertex");
++ glad_glDrawRangeElementsBaseVertex = (PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC)load("glDrawRangeElementsBaseVertex");
++ glad_glDrawElementsInstancedBaseVertex = (PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC)load("glDrawElementsInstancedBaseVertex");
++ glad_glMultiDrawElementsBaseVertex = (PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC)load("glMultiDrawElementsBaseVertex");
++ glad_glProvokingVertex = (PFNGLPROVOKINGVERTEXPROC)load("glProvokingVertex");
++ glad_glFenceSync = (PFNGLFENCESYNCPROC)load("glFenceSync");
++ glad_glIsSync = (PFNGLISSYNCPROC)load("glIsSync");
++ glad_glDeleteSync = (PFNGLDELETESYNCPROC)load("glDeleteSync");
++ glad_glClientWaitSync = (PFNGLCLIENTWAITSYNCPROC)load("glClientWaitSync");
++ glad_glWaitSync = (PFNGLWAITSYNCPROC)load("glWaitSync");
++ glad_glGetInteger64v = (PFNGLGETINTEGER64VPROC)load("glGetInteger64v");
++ glad_glGetSynciv = (PFNGLGETSYNCIVPROC)load("glGetSynciv");
++ glad_glGetInteger64i_v = (PFNGLGETINTEGER64I_VPROC)load("glGetInteger64i_v");
++ glad_glGetBufferParameteri64v = (PFNGLGETBUFFERPARAMETERI64VPROC)load("glGetBufferParameteri64v");
++ glad_glFramebufferTexture = (PFNGLFRAMEBUFFERTEXTUREPROC)load("glFramebufferTexture");
++ glad_glTexImage2DMultisample = (PFNGLTEXIMAGE2DMULTISAMPLEPROC)load("glTexImage2DMultisample");
++ glad_glTexImage3DMultisample = (PFNGLTEXIMAGE3DMULTISAMPLEPROC)load("glTexImage3DMultisample");
++ glad_glGetMultisamplefv = (PFNGLGETMULTISAMPLEFVPROC)load("glGetMultisamplefv");
++ glad_glSampleMaski = (PFNGLSAMPLEMASKIPROC)load("glSampleMaski");
++}
++static void load_GL_VERSION_3_3(GLADloadproc load) {
++ if (!GLAD_GL_VERSION_3_3) return;
++ glad_glBindFragDataLocationIndexed = (PFNGLBINDFRAGDATALOCATIONINDEXEDPROC)load("glBindFragDataLocationIndexed");
++ glad_glGetFragDataIndex = (PFNGLGETFRAGDATAINDEXPROC)load("glGetFragDataIndex");
++ glad_glGenSamplers = (PFNGLGENSAMPLERSPROC)load("glGenSamplers");
++ glad_glDeleteSamplers = (PFNGLDELETESAMPLERSPROC)load("glDeleteSamplers");
++ glad_glIsSampler = (PFNGLISSAMPLERPROC)load("glIsSampler");
++ glad_glBindSampler = (PFNGLBINDSAMPLERPROC)load("glBindSampler");
++ glad_glSamplerParameteri = (PFNGLSAMPLERPARAMETERIPROC)load("glSamplerParameteri");
++ glad_glSamplerParameteriv = (PFNGLSAMPLERPARAMETERIVPROC)load("glSamplerParameteriv");
++ glad_glSamplerParameterf = (PFNGLSAMPLERPARAMETERFPROC)load("glSamplerParameterf");
++ glad_glSamplerParameterfv = (PFNGLSAMPLERPARAMETERFVPROC)load("glSamplerParameterfv");
++ glad_glSamplerParameterIiv = (PFNGLSAMPLERPARAMETERIIVPROC)load("glSamplerParameterIiv");
++ glad_glSamplerParameterIuiv = (PFNGLSAMPLERPARAMETERIUIVPROC)load("glSamplerParameterIuiv");
++ glad_glGetSamplerParameteriv = (PFNGLGETSAMPLERPARAMETERIVPROC)load("glGetSamplerParameteriv");
++ glad_glGetSamplerParameterIiv = (PFNGLGETSAMPLERPARAMETERIIVPROC)load("glGetSamplerParameterIiv");
++ glad_glGetSamplerParameterfv = (PFNGLGETSAMPLERPARAMETERFVPROC)load("glGetSamplerParameterfv");
++ glad_glGetSamplerParameterIuiv = (PFNGLGETSAMPLERPARAMETERIUIVPROC)load("glGetSamplerParameterIuiv");
++ glad_glQueryCounter = (PFNGLQUERYCOUNTERPROC)load("glQueryCounter");
++ glad_glGetQueryObjecti64v = (PFNGLGETQUERYOBJECTI64VPROC)load("glGetQueryObjecti64v");
++ glad_glGetQueryObjectui64v = (PFNGLGETQUERYOBJECTUI64VPROC)load("glGetQueryObjectui64v");
++ glad_glVertexAttribDivisor = (PFNGLVERTEXATTRIBDIVISORPROC)load("glVertexAttribDivisor");
++ glad_glVertexAttribP1ui = (PFNGLVERTEXATTRIBP1UIPROC)load("glVertexAttribP1ui");
++ glad_glVertexAttribP1uiv = (PFNGLVERTEXATTRIBP1UIVPROC)load("glVertexAttribP1uiv");
++ glad_glVertexAttribP2ui = (PFNGLVERTEXATTRIBP2UIPROC)load("glVertexAttribP2ui");
++ glad_glVertexAttribP2uiv = (PFNGLVERTEXATTRIBP2UIVPROC)load("glVertexAttribP2uiv");
++ glad_glVertexAttribP3ui = (PFNGLVERTEXATTRIBP3UIPROC)load("glVertexAttribP3ui");
++ glad_glVertexAttribP3uiv = (PFNGLVERTEXATTRIBP3UIVPROC)load("glVertexAttribP3uiv");
++ glad_glVertexAttribP4ui = (PFNGLVERTEXATTRIBP4UIPROC)load("glVertexAttribP4ui");
++ glad_glVertexAttribP4uiv = (PFNGLVERTEXATTRIBP4UIVPROC)load("glVertexAttribP4uiv");
++ glad_glVertexP2ui = (PFNGLVERTEXP2UIPROC)load("glVertexP2ui");
++ glad_glVertexP2uiv = (PFNGLVERTEXP2UIVPROC)load("glVertexP2uiv");
++ glad_glVertexP3ui = (PFNGLVERTEXP3UIPROC)load("glVertexP3ui");
++ glad_glVertexP3uiv = (PFNGLVERTEXP3UIVPROC)load("glVertexP3uiv");
++ glad_glVertexP4ui = (PFNGLVERTEXP4UIPROC)load("glVertexP4ui");
++ glad_glVertexP4uiv = (PFNGLVERTEXP4UIVPROC)load("glVertexP4uiv");
++ glad_glTexCoordP1ui = (PFNGLTEXCOORDP1UIPROC)load("glTexCoordP1ui");
++ glad_glTexCoordP1uiv = (PFNGLTEXCOORDP1UIVPROC)load("glTexCoordP1uiv");
++ glad_glTexCoordP2ui = (PFNGLTEXCOORDP2UIPROC)load("glTexCoordP2ui");
++ glad_glTexCoordP2uiv = (PFNGLTEXCOORDP2UIVPROC)load("glTexCoordP2uiv");
++ glad_glTexCoordP3ui = (PFNGLTEXCOORDP3UIPROC)load("glTexCoordP3ui");
++ glad_glTexCoordP3uiv = (PFNGLTEXCOORDP3UIVPROC)load("glTexCoordP3uiv");
++ glad_glTexCoordP4ui = (PFNGLTEXCOORDP4UIPROC)load("glTexCoordP4ui");
++ glad_glTexCoordP4uiv = (PFNGLTEXCOORDP4UIVPROC)load("glTexCoordP4uiv");
++ glad_glMultiTexCoordP1ui = (PFNGLMULTITEXCOORDP1UIPROC)load("glMultiTexCoordP1ui");
++ glad_glMultiTexCoordP1uiv = (PFNGLMULTITEXCOORDP1UIVPROC)load("glMultiTexCoordP1uiv");
++ glad_glMultiTexCoordP2ui = (PFNGLMULTITEXCOORDP2UIPROC)load("glMultiTexCoordP2ui");
++ glad_glMultiTexCoordP2uiv = (PFNGLMULTITEXCOORDP2UIVPROC)load("glMultiTexCoordP2uiv");
++ glad_glMultiTexCoordP3ui = (PFNGLMULTITEXCOORDP3UIPROC)load("glMultiTexCoordP3ui");
++ glad_glMultiTexCoordP3uiv = (PFNGLMULTITEXCOORDP3UIVPROC)load("glMultiTexCoordP3uiv");
++ glad_glMultiTexCoordP4ui = (PFNGLMULTITEXCOORDP4UIPROC)load("glMultiTexCoordP4ui");
++ glad_glMultiTexCoordP4uiv = (PFNGLMULTITEXCOORDP4UIVPROC)load("glMultiTexCoordP4uiv");
++ glad_glNormalP3ui = (PFNGLNORMALP3UIPROC)load("glNormalP3ui");
++ glad_glNormalP3uiv = (PFNGLNORMALP3UIVPROC)load("glNormalP3uiv");
++ glad_glColorP3ui = (PFNGLCOLORP3UIPROC)load("glColorP3ui");
++ glad_glColorP3uiv = (PFNGLCOLORP3UIVPROC)load("glColorP3uiv");
++ glad_glColorP4ui = (PFNGLCOLORP4UIPROC)load("glColorP4ui");
++ glad_glColorP4uiv = (PFNGLCOLORP4UIVPROC)load("glColorP4uiv");
++ glad_glSecondaryColorP3ui = (PFNGLSECONDARYCOLORP3UIPROC)load("glSecondaryColorP3ui");
++ glad_glSecondaryColorP3uiv = (PFNGLSECONDARYCOLORP3UIVPROC)load("glSecondaryColorP3uiv");
++}
++static int find_extensionsGL(void) {
++ if (!get_exts()) return 0;
++ GLAD_GL_ARB_pixel_buffer_object = has_ext("GL_ARB_pixel_buffer_object");
++ GLAD_GL_ARB_texture_non_power_of_two = has_ext("GL_ARB_texture_non_power_of_two");
++ free_exts();
++ return 1;
++}
++
++static void find_coreGL(void) {
++
++ /* Thank you @elmindreda
++ * https://github.com/elmindreda/greg/blob/master/templates/greg.c.in#L176
++ * https://github.com/glfw/glfw/blob/master/src/context.c#L36
++ */
++ int i, major, minor;
++
++ const char *version;
++ const char *prefixes[] = {
++ "OpenGL ES-CM ",
++ "OpenGL ES-CL ",
++ "OpenGL ES ",
++ NULL
++ };
++
++ version = (const char *) glGetString(GL_VERSION);
++ if (!version) return;
++
++ for (i = 0; prefixes[i]; i++) {
++ const size_t length = strlen(prefixes[i]);
++ if (strncmp(version, prefixes[i], length) == 0) {
++ version += length;
++ break;
++ }
++ }
++
++ /* PR #18 */
++#ifdef _MSC_VER
++ sscanf_s(version, "%d.%d", &major, &minor);
++#else
++ sscanf(version, "%d.%d", &major, &minor);
++#endif
++
++ GLVersion.major = major;
++ GLVersion.minor = minor;
++ max_loaded_major = major;
++ max_loaded_minor = minor;
++ GLAD_GL_VERSION_1_0 = (major == 1 && minor >= 0) || major > 1;
++ GLAD_GL_VERSION_1_1 = (major == 1 && minor >= 1) || major > 1;
++ GLAD_GL_VERSION_1_2 = (major == 1 && minor >= 2) || major > 1;
++ GLAD_GL_VERSION_1_3 = (major == 1 && minor >= 3) || major > 1;
++ GLAD_GL_VERSION_1_4 = (major == 1 && minor >= 4) || major > 1;
++ GLAD_GL_VERSION_1_5 = (major == 1 && minor >= 5) || major > 1;
++ GLAD_GL_VERSION_2_0 = (major == 2 && minor >= 0) || major > 2;
++ GLAD_GL_VERSION_2_1 = (major == 2 && minor >= 1) || major > 2;
++ GLAD_GL_VERSION_3_0 = (major == 3 && minor >= 0) || major > 3;
++ GLAD_GL_VERSION_3_1 = (major == 3 && minor >= 1) || major > 3;
++ GLAD_GL_VERSION_3_2 = (major == 3 && minor >= 2) || major > 3;
++ GLAD_GL_VERSION_3_3 = (major == 3 && minor >= 3) || major > 3;
++ if (GLVersion.major > 3 || (GLVersion.major >= 3 && GLVersion.minor >= 3)) {
++ max_loaded_major = 3;
++ max_loaded_minor = 3;
++ }
++}
++
++int gladLoadGLLoader(GLADloadproc load) {
++ GLVersion.major = 0;
++ GLVersion.minor = 0;
++ glGetString = (PFNGLGETSTRINGPROC)load("glGetString");
++ if (glGetString == NULL) return 0;
++ if (glGetString(GL_VERSION) == NULL) return 0;
++ find_coreGL();
++ load_GL_VERSION_1_0(load);
++ load_GL_VERSION_1_1(load);
++ load_GL_VERSION_1_2(load);
++ load_GL_VERSION_1_3(load);
++ load_GL_VERSION_1_4(load);
++ load_GL_VERSION_1_5(load);
++ load_GL_VERSION_2_0(load);
++ load_GL_VERSION_2_1(load);
++ load_GL_VERSION_3_0(load);
++ load_GL_VERSION_3_1(load);
++ load_GL_VERSION_3_2(load);
++ load_GL_VERSION_3_3(load);
++
++ if (!find_extensionsGL()) return 0;
++ return GLVersion.major != 0 || GLVersion.minor != 0;
++}
++
+Index: lives-plugins/plugins/playback/video/glad.h
+===================================================================
+--- lives-plugins/plugins/playback/video/glad.h (nonexistent)
++++ lives-plugins/plugins/playback/video/glad.h (revision 2620)
+@@ -0,0 +1,3714 @@
++/*
++
++ OpenGL loader generated by glad 0.1.13a0 on Sat Apr 29 18:34:46 2017.
++
++ Language/Generator: C/C++
++ Specification: gl
++ APIs: gl=3.3
++ Profile: compatibility
++ Extensions:
++ GL_ARB_pixel_buffer_object,
++ GL_ARB_texture_non_power_of_two
++ Loader: True
++ Local files: False
++ Omit khrplatform: False
++
++ Commandline:
++ --profile="compatibility" --api="gl=3.3" --generator="c" --spec="gl" --extensions="GL_ARB_pixel_buffer_object,GL_ARB_texture_non_power_of_two"
++ Online:
++ http://glad.dav1d.de/#profile=compatibility&language=c&specification=gl&l...
++*/
++
++
++#ifndef __glad_h_
++#define __glad_h_
++
++#ifdef __gl_h_
++#error OpenGL header already included, remove this include, glad already provides it
++#endif
++#define __gl_h_
++
++#if defined(_WIN32) && !defined(APIENTRY) && !defined(__CYGWIN__) && !defined(__SCITECH_SNAP__)
++#ifndef WIN32_LEAN_AND_MEAN
++#define WIN32_LEAN_AND_MEAN 1
++#endif
++#include <windows.h>
++#endif
++
++#ifndef APIENTRY
++#define APIENTRY
++#endif
++#ifndef APIENTRYP
++#define APIENTRYP APIENTRY *
++#endif
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++struct gladGLversionStruct {
++ int major;
++ int minor;
++};
++
++typedef void *(* GLADloadproc)(const char *name);
++
++#ifndef GLAPI
++# if defined(GLAD_GLAPI_EXPORT)
++# if defined(WIN32) || defined(__CYGWIN__)
++# if defined(GLAD_GLAPI_EXPORT_BUILD)
++# if defined(__GNUC__)
++# define GLAPI __attribute__ ((dllexport)) extern
++# else
++# define GLAPI __declspec(dllexport) extern
++# endif
++# else
++# if defined(__GNUC__)
++# define GLAPI __attribute__ ((dllimport)) extern
++# else
++# define GLAPI __declspec(dllimport) extern
++# endif
++# endif
++# elif defined(__GNUC__) && defined(GLAD_GLAPI_EXPORT_BUILD)
++# define GLAPI __attribute__ ((visibility ("default"))) extern
++# else
++# define GLAPI extern
++# endif
++# else
++# define GLAPI extern
++# endif
++#endif
++
++GLAPI struct gladGLversionStruct GLVersion;
++
++GLAPI int gladLoadGL(void);
++
++GLAPI int gladLoadGLLoader(GLADloadproc);
++
++#include <stddef.h>
++#include <KHR/khrplatform.h>
++#ifndef GLEXT_64_TYPES_DEFINED
++/* This code block is duplicated in glxext.h, so must be protected */
++#define GLEXT_64_TYPES_DEFINED
++/* Define int32_t, int64_t, and uint64_t types for UST/MSC */
++/* (as used in the GL_EXT_timer_query extension). */
++#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
++#include <inttypes.h>
++#elif defined(__sun__) || defined(__digital__)
++#include <inttypes.h>
++#if defined(__STDC__)
++#if defined(__arch64__) || defined(_LP64)
++typedef long int int64_t;
++typedef unsigned long int uint64_t;
++#else
++typedef long long int int64_t;
++typedef unsigned long long int uint64_t;
++#endif /* __arch64__ */
++#endif /* __STDC__ */
++#elif defined( __VMS ) || defined(__sgi)
++#include <inttypes.h>
++#elif defined(__SCO__) || defined(__USLC__)
++#include <stdint.h>
++#elif defined(__UNIXOS2__) || defined(__SOL64__)
++typedef long int int32_t;
++typedef long long int int64_t;
++typedef unsigned long long int uint64_t;
++#elif defined(_WIN32) && defined(__GNUC__)
++#include <stdint.h>
++#elif defined(_WIN32)
++typedef __int32 int32_t;
++typedef __int64 int64_t;
++typedef unsigned __int64 uint64_t;
++#else
++/* Fallback if nothing above works */
++#include <inttypes.h>
++#endif
++#endif
++typedef unsigned int GLenum;
++typedef unsigned char GLboolean;
++typedef unsigned int GLbitfield;
++typedef void GLvoid;
++typedef signed char GLbyte;
++typedef short GLshort;
++typedef int GLint;
++typedef int GLclampx;
++typedef unsigned char GLubyte;
++typedef unsigned short GLushort;
++typedef unsigned int GLuint;
++typedef int GLsizei;
++typedef float GLfloat;
++typedef float GLclampf;
++typedef double GLdouble;
++typedef double GLclampd;
++typedef void *GLeglImageOES;
++typedef char GLchar;
++typedef char GLcharARB;
++#ifdef __APPLE__
++typedef void *GLhandleARB;
++#else
++typedef unsigned int GLhandleARB;
++#endif
++typedef unsigned short GLhalfARB;
++typedef unsigned short GLhalf;
++typedef GLint GLfixed;
++#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && (__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ > 1060)
++typedef long GLintptr;
++#else
++typedef ptrdiff_t GLintptr;
++#endif
++#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && (__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ > 1060)
++typedef long GLsizeiptr;
++#else
++typedef ptrdiff_t GLsizeiptr;
++#endif
++typedef int64_t GLint64;
++typedef uint64_t GLuint64;
++#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && (__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ > 1060)
++typedef long GLintptrARB;
++#else
++typedef ptrdiff_t GLintptrARB;
++#endif
++#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && (__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ > 1060)
++typedef long GLsizeiptrARB;
++#else
++typedef ptrdiff_t GLsizeiptrARB;
++#endif
++typedef int64_t GLint64EXT;
++typedef uint64_t GLuint64EXT;
++typedef struct __GLsync *GLsync;
++struct _cl_context;
++struct _cl_event;
++typedef void (APIENTRY *GLDEBUGPROC)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,
++ const void *userParam);
++typedef void (APIENTRY *GLDEBUGPROCARB)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,
++ const void *userParam);
++typedef void (APIENTRY *GLDEBUGPROCKHR)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,
++ const void *userParam);
++typedef void (APIENTRY *GLDEBUGPROCAMD)(GLuint id,GLenum category,GLenum severity,GLsizei length,const GLchar *message,void *userParam);
++typedef unsigned short GLhalfNV;
++typedef GLintptr GLvdpauSurfaceNV;
++#define GL_DEPTH_BUFFER_BIT 0x00000100
++#define GL_STENCIL_BUFFER_BIT 0x00000400
++#define GL_COLOR_BUFFER_BIT 0x00004000
++#define GL_FALSE 0
++#define GL_TRUE 1
++#define GL_POINTS 0x0000
++#define GL_LINES 0x0001
++#define GL_LINE_LOOP 0x0002
++#define GL_LINE_STRIP 0x0003
++#define GL_TRIANGLES 0x0004
++#define GL_TRIANGLE_STRIP 0x0005
++#define GL_TRIANGLE_FAN 0x0006
++#define GL_QUADS 0x0007
++#define GL_NEVER 0x0200
++#define GL_LESS 0x0201
++#define GL_EQUAL 0x0202
++#define GL_LEQUAL 0x0203
++#define GL_GREATER 0x0204
++#define GL_NOTEQUAL 0x0205
++#define GL_GEQUAL 0x0206
++#define GL_ALWAYS 0x0207
++#define GL_ZERO 0
++#define GL_ONE 1
++#define GL_SRC_COLOR 0x0300
++#define GL_ONE_MINUS_SRC_COLOR 0x0301
++#define GL_SRC_ALPHA 0x0302
++#define GL_ONE_MINUS_SRC_ALPHA 0x0303
++#define GL_DST_ALPHA 0x0304
++#define GL_ONE_MINUS_DST_ALPHA 0x0305
++#define GL_DST_COLOR 0x0306
++#define GL_ONE_MINUS_DST_COLOR 0x0307
++#define GL_SRC_ALPHA_SATURATE 0x0308
++#define GL_NONE 0
++#define GL_FRONT_LEFT 0x0400
++#define GL_FRONT_RIGHT 0x0401
++#define GL_BACK_LEFT 0x0402
++#define GL_BACK_RIGHT 0x0403
++#define GL_FRONT 0x0404
++#define GL_BACK 0x0405
++#define GL_LEFT 0x0406
++#define GL_RIGHT 0x0407
++#define GL_FRONT_AND_BACK 0x0408
++#define GL_NO_ERROR 0
++#define GL_INVALID_ENUM 0x0500
++#define GL_INVALID_VALUE 0x0501
++#define GL_INVALID_OPERATION 0x0502
++#define GL_OUT_OF_MEMORY 0x0505
++#define GL_CW 0x0900
++#define GL_CCW 0x0901
++#define GL_POINT_SIZE 0x0B11
++#define GL_POINT_SIZE_RANGE 0x0B12
++#define GL_POINT_SIZE_GRANULARITY 0x0B13
++#define GL_LINE_SMOOTH 0x0B20
++#define GL_LINE_WIDTH 0x0B21
++#define GL_LINE_WIDTH_RANGE 0x0B22
++#define GL_LINE_WIDTH_GRANULARITY 0x0B23
++#define GL_POLYGON_MODE 0x0B40
++#define GL_POLYGON_SMOOTH 0x0B41
++#define GL_CULL_FACE 0x0B44
++#define GL_CULL_FACE_MODE 0x0B45
++#define GL_FRONT_FACE 0x0B46
++#define GL_DEPTH_RANGE 0x0B70
++#define GL_DEPTH_TEST 0x0B71
++#define GL_DEPTH_WRITEMASK 0x0B72
++#define GL_DEPTH_CLEAR_VALUE 0x0B73
++#define GL_DEPTH_FUNC 0x0B74
++#define GL_STENCIL_TEST 0x0B90
++#define GL_STENCIL_CLEAR_VALUE 0x0B91
++#define GL_STENCIL_FUNC 0x0B92
++#define GL_STENCIL_VALUE_MASK 0x0B93
++#define GL_STENCIL_FAIL 0x0B94
++#define GL_STENCIL_PASS_DEPTH_FAIL 0x0B95
++#define GL_STENCIL_PASS_DEPTH_PASS 0x0B96
++#define GL_STENCIL_REF 0x0B97
++#define GL_STENCIL_WRITEMASK 0x0B98
++#define GL_VIEWPORT 0x0BA2
++#define GL_DITHER 0x0BD0
++#define GL_BLEND_DST 0x0BE0
++#define GL_BLEND_SRC 0x0BE1
++#define GL_BLEND 0x0BE2
++#define GL_LOGIC_OP_MODE 0x0BF0
++#define GL_COLOR_LOGIC_OP 0x0BF2
++#define GL_DRAW_BUFFER 0x0C01
++#define GL_READ_BUFFER 0x0C02
++#define GL_SCISSOR_BOX 0x0C10
++#define GL_SCISSOR_TEST 0x0C11
++#define GL_COLOR_CLEAR_VALUE 0x0C22
++#define GL_COLOR_WRITEMASK 0x0C23
++#define GL_DOUBLEBUFFER 0x0C32
++#define GL_STEREO 0x0C33
++#define GL_LINE_SMOOTH_HINT 0x0C52
++#define GL_POLYGON_SMOOTH_HINT 0x0C53
++#define GL_UNPACK_SWAP_BYTES 0x0CF0
++#define GL_UNPACK_LSB_FIRST 0x0CF1
++#define GL_UNPACK_ROW_LENGTH 0x0CF2
++#define GL_UNPACK_SKIP_ROWS 0x0CF3
++#define GL_UNPACK_SKIP_PIXELS 0x0CF4
++#define GL_UNPACK_ALIGNMENT 0x0CF5
++#define GL_PACK_SWAP_BYTES 0x0D00
++#define GL_PACK_LSB_FIRST 0x0D01
++#define GL_PACK_ROW_LENGTH 0x0D02
++#define GL_PACK_SKIP_ROWS 0x0D03
++#define GL_PACK_SKIP_PIXELS 0x0D04
++#define GL_PACK_ALIGNMENT 0x0D05
++#define GL_MAX_TEXTURE_SIZE 0x0D33
++#define GL_MAX_VIEWPORT_DIMS 0x0D3A
++#define GL_SUBPIXEL_BITS 0x0D50
++#define GL_TEXTURE_1D 0x0DE0
++#define GL_TEXTURE_2D 0x0DE1
++#define GL_POLYGON_OFFSET_UNITS 0x2A00
++#define GL_POLYGON_OFFSET_POINT 0x2A01
++#define GL_POLYGON_OFFSET_LINE 0x2A02
++#define GL_POLYGON_OFFSET_FILL 0x8037
++#define GL_POLYGON_OFFSET_FACTOR 0x8038
++#define GL_TEXTURE_BINDING_1D 0x8068
++#define GL_TEXTURE_BINDING_2D 0x8069
++#define GL_TEXTURE_WIDTH 0x1000
++#define GL_TEXTURE_HEIGHT 0x1001
++#define GL_TEXTURE_INTERNAL_FORMAT 0x1003
++#define GL_TEXTURE_BORDER_COLOR 0x1004
++#define GL_TEXTURE_RED_SIZE 0x805C
++#define GL_TEXTURE_GREEN_SIZE 0x805D
++#define GL_TEXTURE_BLUE_SIZE 0x805E
++#define GL_TEXTURE_ALPHA_SIZE 0x805F
++#define GL_DONT_CARE 0x1100
++#define GL_FASTEST 0x1101
++#define GL_NICEST 0x1102
++#define GL_BYTE 0x1400
++#define GL_UNSIGNED_BYTE 0x1401
++#define GL_SHORT 0x1402
++#define GL_UNSIGNED_SHORT 0x1403
++#define GL_INT 0x1404
++#define GL_UNSIGNED_INT 0x1405
++#define GL_FLOAT 0x1406
++#define GL_DOUBLE 0x140A
++#define GL_STACK_OVERFLOW 0x0503
++#define GL_STACK_UNDERFLOW 0x0504
++#define GL_CLEAR 0x1500
++#define GL_AND 0x1501
++#define GL_AND_REVERSE 0x1502
++#define GL_COPY 0x1503
++#define GL_AND_INVERTED 0x1504
++#define GL_NOOP 0x1505
++#define GL_XOR 0x1506
++#define GL_OR 0x1507
++#define GL_NOR 0x1508
++#define GL_EQUIV 0x1509
++#define GL_INVERT 0x150A
++#define GL_OR_REVERSE 0x150B
++#define GL_COPY_INVERTED 0x150C
++#define GL_OR_INVERTED 0x150D
++#define GL_NAND 0x150E
++#define GL_SET 0x150F
++#define GL_TEXTURE 0x1702
++#define GL_COLOR 0x1800
++#define GL_DEPTH 0x1801
++#define GL_STENCIL 0x1802
++#define GL_STENCIL_INDEX 0x1901
++#define GL_DEPTH_COMPONENT 0x1902
++#define GL_RED 0x1903
++#define GL_GREEN 0x1904
++#define GL_BLUE 0x1905
++#define GL_ALPHA 0x1906
++#define GL_RGB 0x1907
++#define GL_RGBA 0x1908
++#define GL_POINT 0x1B00
++#define GL_LINE 0x1B01
++#define GL_FILL 0x1B02
++#define GL_KEEP 0x1E00
++#define GL_REPLACE 0x1E01
++#define GL_INCR 0x1E02
++#define GL_DECR 0x1E03
++#define GL_VENDOR 0x1F00
++#define GL_RENDERER 0x1F01
++#define GL_VERSION 0x1F02
++#define GL_EXTENSIONS 0x1F03
++#define GL_NEAREST 0x2600
++#define GL_LINEAR 0x2601
++#define GL_NEAREST_MIPMAP_NEAREST 0x2700
++#define GL_LINEAR_MIPMAP_NEAREST 0x2701
++#define GL_NEAREST_MIPMAP_LINEAR 0x2702
++#define GL_LINEAR_MIPMAP_LINEAR 0x2703
++#define GL_TEXTURE_MAG_FILTER 0x2800
++#define GL_TEXTURE_MIN_FILTER 0x2801
++#define GL_TEXTURE_WRAP_S 0x2802
++#define GL_TEXTURE_WRAP_T 0x2803
++#define GL_PROXY_TEXTURE_1D 0x8063
++#define GL_PROXY_TEXTURE_2D 0x8064
++#define GL_REPEAT 0x2901
++#define GL_R3_G3_B2 0x2A10
++#define GL_RGB4 0x804F
++#define GL_RGB5 0x8050
++#define GL_RGB8 0x8051
++#define GL_RGB10 0x8052
++#define GL_RGB12 0x8053
++#define GL_RGB16 0x8054
++#define GL_RGBA2 0x8055
++#define GL_RGBA4 0x8056
++#define GL_RGB5_A1 0x8057
++#define GL_RGBA8 0x8058
++#define GL_RGB10_A2 0x8059
++#define GL_RGBA12 0x805A
++#define GL_RGBA16 0x805B
++#define GL_CURRENT_BIT 0x00000001
++#define GL_POINT_BIT 0x00000002
++#define GL_LINE_BIT 0x00000004
++#define GL_POLYGON_BIT 0x00000008
++#define GL_POLYGON_STIPPLE_BIT 0x00000010
++#define GL_PIXEL_MODE_BIT 0x00000020
++#define GL_LIGHTING_BIT 0x00000040
++#define GL_FOG_BIT 0x00000080
++#define GL_ACCUM_BUFFER_BIT 0x00000200
++#define GL_VIEWPORT_BIT 0x00000800
++#define GL_TRANSFORM_BIT 0x00001000
++#define GL_ENABLE_BIT 0x00002000
++#define GL_HINT_BIT 0x00008000
++#define GL_EVAL_BIT 0x00010000
++#define GL_LIST_BIT 0x00020000
++#define GL_TEXTURE_BIT 0x00040000
++#define GL_SCISSOR_BIT 0x00080000
++#define GL_ALL_ATTRIB_BITS 0xFFFFFFFF
++#define GL_CLIENT_PIXEL_STORE_BIT 0x00000001
++#define GL_CLIENT_VERTEX_ARRAY_BIT 0x00000002
++#define GL_CLIENT_ALL_ATTRIB_BITS 0xFFFFFFFF
++#define GL_QUAD_STRIP 0x0008
++#define GL_POLYGON 0x0009
++#define GL_ACCUM 0x0100
++#define GL_LOAD 0x0101
++#define GL_RETURN 0x0102
++#define GL_MULT 0x0103
++#define GL_ADD 0x0104
++#define GL_AUX0 0x0409
++#define GL_AUX1 0x040A
++#define GL_AUX2 0x040B
++#define GL_AUX3 0x040C
++#define GL_2D 0x0600
++#define GL_3D 0x0601
++#define GL_3D_COLOR 0x0602
++#define GL_3D_COLOR_TEXTURE 0x0603
++#define GL_4D_COLOR_TEXTURE 0x0604
++#define GL_PASS_THROUGH_TOKEN 0x0700
++#define GL_POINT_TOKEN 0x0701
++#define GL_LINE_TOKEN 0x0702
++#define GL_POLYGON_TOKEN 0x0703
++#define GL_BITMAP_TOKEN 0x0704
++#define GL_DRAW_PIXEL_TOKEN 0x0705
++#define GL_COPY_PIXEL_TOKEN 0x0706
++#define GL_LINE_RESET_TOKEN 0x0707
++#define GL_EXP 0x0800
++#define GL_EXP2 0x0801
++#define GL_COEFF 0x0A00
++#define GL_ORDER 0x0A01
++#define GL_DOMAIN 0x0A02
++#define GL_PIXEL_MAP_I_TO_I 0x0C70
++#define GL_PIXEL_MAP_S_TO_S 0x0C71
++#define GL_PIXEL_MAP_I_TO_R 0x0C72
++#define GL_PIXEL_MAP_I_TO_G 0x0C73
++#define GL_PIXEL_MAP_I_TO_B 0x0C74
++#define GL_PIXEL_MAP_I_TO_A 0x0C75
++#define GL_PIXEL_MAP_R_TO_R 0x0C76
++#define GL_PIXEL_MAP_G_TO_G 0x0C77
++#define GL_PIXEL_MAP_B_TO_B 0x0C78
++#define GL_PIXEL_MAP_A_TO_A 0x0C79
++#define GL_VERTEX_ARRAY_POINTER 0x808E
++#define GL_NORMAL_ARRAY_POINTER 0x808F
++#define GL_COLOR_ARRAY_POINTER 0x8090
++#define GL_INDEX_ARRAY_POINTER 0x8091
++#define GL_TEXTURE_COORD_ARRAY_POINTER 0x8092
++#define GL_EDGE_FLAG_ARRAY_POINTER 0x8093
++#define GL_FEEDBACK_BUFFER_POINTER 0x0DF0
++#define GL_SELECTION_BUFFER_POINTER 0x0DF3
++#define GL_CURRENT_COLOR 0x0B00
++#define GL_CURRENT_INDEX 0x0B01
++#define GL_CURRENT_NORMAL 0x0B02
++#define GL_CURRENT_TEXTURE_COORDS 0x0B03
++#define GL_CURRENT_RASTER_COLOR 0x0B04
++#define GL_CURRENT_RASTER_INDEX 0x0B05
++#define GL_CURRENT_RASTER_TEXTURE_COORDS 0x0B06
++#define GL_CURRENT_RASTER_POSITION 0x0B07
++#define GL_CURRENT_RASTER_POSITION_VALID 0x0B08
++#define GL_CURRENT_RASTER_DISTANCE 0x0B09
++#define GL_POINT_SMOOTH 0x0B10
++#define GL_LINE_STIPPLE 0x0B24
++#define GL_LINE_STIPPLE_PATTERN 0x0B25
++#define GL_LINE_STIPPLE_REPEAT 0x0B26
++#define GL_LIST_MODE 0x0B30
++#define GL_MAX_LIST_NESTING 0x0B31
++#define GL_LIST_BASE 0x0B32
++#define GL_LIST_INDEX 0x0B33
++#define GL_POLYGON_STIPPLE 0x0B42
++#define GL_EDGE_FLAG 0x0B43
++#define GL_LIGHTING 0x0B50
++#define GL_LIGHT_MODEL_LOCAL_VIEWER 0x0B51
++#define GL_LIGHT_MODEL_TWO_SIDE 0x0B52
++#define GL_LIGHT_MODEL_AMBIENT 0x0B53
++#define GL_SHADE_MODEL 0x0B54
++#define GL_COLOR_MATERIAL_FACE 0x0B55
++#define GL_COLOR_MATERIAL_PARAMETER 0x0B56
++#define GL_COLOR_MATERIAL 0x0B57
++#define GL_FOG 0x0B60
++#define GL_FOG_INDEX 0x0B61
++#define GL_FOG_DENSITY 0x0B62
++#define GL_FOG_START 0x0B63
++#define GL_FOG_END 0x0B64
++#define GL_FOG_MODE 0x0B65
++#define GL_FOG_COLOR 0x0B66
++#define GL_ACCUM_CLEAR_VALUE 0x0B80
++#define GL_MATRIX_MODE 0x0BA0
++#define GL_NORMALIZE 0x0BA1
++#define GL_MODELVIEW_STACK_DEPTH 0x0BA3
++#define GL_PROJECTION_STACK_DEPTH 0x0BA4
++#define GL_TEXTURE_STACK_DEPTH 0x0BA5
++#define GL_MODELVIEW_MATRIX 0x0BA6
++#define GL_PROJECTION_MATRIX 0x0BA7
++#define GL_TEXTURE_MATRIX 0x0BA8
++#define GL_ATTRIB_STACK_DEPTH 0x0BB0
++#define GL_CLIENT_ATTRIB_STACK_DEPTH 0x0BB1
++#define GL_ALPHA_TEST 0x0BC0
++#define GL_ALPHA_TEST_FUNC 0x0BC1
++#define GL_ALPHA_TEST_REF 0x0BC2
++#define GL_INDEX_LOGIC_OP 0x0BF1
++#define GL_LOGIC_OP 0x0BF1
++#define GL_AUX_BUFFERS 0x0C00
++#define GL_INDEX_CLEAR_VALUE 0x0C20
++#define GL_INDEX_WRITEMASK 0x0C21
++#define GL_INDEX_MODE 0x0C30
++#define GL_RGBA_MODE 0x0C31
++#define GL_RENDER_MODE 0x0C40
++#define GL_PERSPECTIVE_CORRECTION_HINT 0x0C50
++#define GL_POINT_SMOOTH_HINT 0x0C51
++#define GL_FOG_HINT 0x0C54
++#define GL_TEXTURE_GEN_S 0x0C60
++#define GL_TEXTURE_GEN_T 0x0C61
++#define GL_TEXTURE_GEN_R 0x0C62
++#define GL_TEXTURE_GEN_Q 0x0C63
++#define GL_PIXEL_MAP_I_TO_I_SIZE 0x0CB0
++#define GL_PIXEL_MAP_S_TO_S_SIZE 0x0CB1
++#define GL_PIXEL_MAP_I_TO_R_SIZE 0x0CB2
++#define GL_PIXEL_MAP_I_TO_G_SIZE 0x0CB3
++#define GL_PIXEL_MAP_I_TO_B_SIZE 0x0CB4
++#define GL_PIXEL_MAP_I_TO_A_SIZE 0x0CB5
++#define GL_PIXEL_MAP_R_TO_R_SIZE 0x0CB6
++#define GL_PIXEL_MAP_G_TO_G_SIZE 0x0CB7
++#define GL_PIXEL_MAP_B_TO_B_SIZE 0x0CB8
++#define GL_PIXEL_MAP_A_TO_A_SIZE 0x0CB9
++#define GL_MAP_COLOR 0x0D10
++#define GL_MAP_STENCIL 0x0D11
++#define GL_INDEX_SHIFT 0x0D12
++#define GL_INDEX_OFFSET 0x0D13
++#define GL_RED_SCALE 0x0D14
++#define GL_RED_BIAS 0x0D15
++#define GL_ZOOM_X 0x0D16
++#define GL_ZOOM_Y 0x0D17
++#define GL_GREEN_SCALE 0x0D18
++#define GL_GREEN_BIAS 0x0D19
++#define GL_BLUE_SCALE 0x0D1A
++#define GL_BLUE_BIAS 0x0D1B
++#define GL_ALPHA_SCALE 0x0D1C
++#define GL_ALPHA_BIAS 0x0D1D
++#define GL_DEPTH_SCALE 0x0D1E
++#define GL_DEPTH_BIAS 0x0D1F
++#define GL_MAX_EVAL_ORDER 0x0D30
++#define GL_MAX_LIGHTS 0x0D31
++#define GL_MAX_CLIP_PLANES 0x0D32
++#define GL_MAX_PIXEL_MAP_TABLE 0x0D34
++#define GL_MAX_ATTRIB_STACK_DEPTH 0x0D35
++#define GL_MAX_MODELVIEW_STACK_DEPTH 0x0D36
++#define GL_MAX_NAME_STACK_DEPTH 0x0D37
++#define GL_MAX_PROJECTION_STACK_DEPTH 0x0D38
++#define GL_MAX_TEXTURE_STACK_DEPTH 0x0D39
++#define GL_MAX_CLIENT_ATTRIB_STACK_DEPTH 0x0D3B
++#define GL_INDEX_BITS 0x0D51
++#define GL_RED_BITS 0x0D52
++#define GL_GREEN_BITS 0x0D53
++#define GL_BLUE_BITS 0x0D54
++#define GL_ALPHA_BITS 0x0D55
++#define GL_DEPTH_BITS 0x0D56
++#define GL_STENCIL_BITS 0x0D57
++#define GL_ACCUM_RED_BITS 0x0D58
++#define GL_ACCUM_GREEN_BITS 0x0D59
++#define GL_ACCUM_BLUE_BITS 0x0D5A
++#define GL_ACCUM_ALPHA_BITS 0x0D5B
++#define GL_NAME_STACK_DEPTH 0x0D70
++#define GL_AUTO_NORMAL 0x0D80
++#define GL_MAP1_COLOR_4 0x0D90
++#define GL_MAP1_INDEX 0x0D91
++#define GL_MAP1_NORMAL 0x0D92
++#define GL_MAP1_TEXTURE_COORD_1 0x0D93
++#define GL_MAP1_TEXTURE_COORD_2 0x0D94
++#define GL_MAP1_TEXTURE_COORD_3 0x0D95
++#define GL_MAP1_TEXTURE_COORD_4 0x0D96
++#define GL_MAP1_VERTEX_3 0x0D97
++#define GL_MAP1_VERTEX_4 0x0D98
++#define GL_MAP2_COLOR_4 0x0DB0
++#define GL_MAP2_INDEX 0x0DB1
++#define GL_MAP2_NORMAL 0x0DB2
++#define GL_MAP2_TEXTURE_COORD_1 0x0DB3
++#define GL_MAP2_TEXTURE_COORD_2 0x0DB4
++#define GL_MAP2_TEXTURE_COORD_3 0x0DB5
++#define GL_MAP2_TEXTURE_COORD_4 0x0DB6
++#define GL_MAP2_VERTEX_3 0x0DB7
++#define GL_MAP2_VERTEX_4 0x0DB8
++#define GL_MAP1_GRID_DOMAIN 0x0DD0
++#define GL_MAP1_GRID_SEGMENTS 0x0DD1
++#define GL_MAP2_GRID_DOMAIN 0x0DD2
++#define GL_MAP2_GRID_SEGMENTS 0x0DD3
++#define GL_FEEDBACK_BUFFER_SIZE 0x0DF1
++#define GL_FEEDBACK_BUFFER_TYPE 0x0DF2
++#define GL_SELECTION_BUFFER_SIZE 0x0DF4
++#define GL_VERTEX_ARRAY 0x8074
++#define GL_NORMAL_ARRAY 0x8075
++#define GL_COLOR_ARRAY 0x8076
++#define GL_INDEX_ARRAY 0x8077
++#define GL_TEXTURE_COORD_ARRAY 0x8078
++#define GL_EDGE_FLAG_ARRAY 0x8079
++#define GL_VERTEX_ARRAY_SIZE 0x807A
++#define GL_VERTEX_ARRAY_TYPE 0x807B
++#define GL_VERTEX_ARRAY_STRIDE 0x807C
++#define GL_NORMAL_ARRAY_TYPE 0x807E
++#define GL_NORMAL_ARRAY_STRIDE 0x807F
++#define GL_COLOR_ARRAY_SIZE 0x8081
++#define GL_COLOR_ARRAY_TYPE 0x8082
++#define GL_COLOR_ARRAY_STRIDE 0x8083
++#define GL_INDEX_ARRAY_TYPE 0x8085
++#define GL_INDEX_ARRAY_STRIDE 0x8086
++#define GL_TEXTURE_COORD_ARRAY_SIZE 0x8088
++#define GL_TEXTURE_COORD_ARRAY_TYPE 0x8089
++#define GL_TEXTURE_COORD_ARRAY_STRIDE 0x808A
++#define GL_EDGE_FLAG_ARRAY_STRIDE 0x808C
++#define GL_TEXTURE_COMPONENTS 0x1003
++#define GL_TEXTURE_BORDER 0x1005
++#define GL_TEXTURE_LUMINANCE_SIZE 0x8060
++#define GL_TEXTURE_INTENSITY_SIZE 0x8061
++#define GL_TEXTURE_PRIORITY 0x8066
++#define GL_TEXTURE_RESIDENT 0x8067
++#define GL_AMBIENT 0x1200
++#define GL_DIFFUSE 0x1201
++#define GL_SPECULAR 0x1202
++#define GL_POSITION 0x1203
++#define GL_SPOT_DIRECTION 0x1204
++#define GL_SPOT_EXPONENT 0x1205
++#define GL_SPOT_CUTOFF 0x1206
++#define GL_CONSTANT_ATTENUATION 0x1207
++#define GL_LINEAR_ATTENUATION 0x1208
++#define GL_QUADRATIC_ATTENUATION 0x1209
++#define GL_COMPILE 0x1300
++#define GL_COMPILE_AND_EXECUTE 0x1301
++#define GL_2_BYTES 0x1407
++#define GL_3_BYTES 0x1408
++#define GL_4_BYTES 0x1409
++#define GL_EMISSION 0x1600
++#define GL_SHININESS 0x1601
++#define GL_AMBIENT_AND_DIFFUSE 0x1602
++#define GL_COLOR_INDEXES 0x1603
++#define GL_MODELVIEW 0x1700
++#define GL_PROJECTION 0x1701
++#define GL_COLOR_INDEX 0x1900
++#define GL_LUMINANCE 0x1909
++#define GL_LUMINANCE_ALPHA 0x190A
++#define GL_BITMAP 0x1A00
++#define GL_RENDER 0x1C00
++#define GL_FEEDBACK 0x1C01
++#define GL_SELECT 0x1C02
++#define GL_FLAT 0x1D00
++#define GL_SMOOTH 0x1D01
++#define GL_S 0x2000
++#define GL_T 0x2001
++#define GL_R 0x2002
++#define GL_Q 0x2003
++#define GL_MODULATE 0x2100
++#define GL_DECAL 0x2101
++#define GL_TEXTURE_ENV_MODE 0x2200
++#define GL_TEXTURE_ENV_COLOR 0x2201
++#define GL_TEXTURE_ENV 0x2300
++#define GL_EYE_LINEAR 0x2400
++#define GL_OBJECT_LINEAR 0x2401
++#define GL_SPHERE_MAP 0x2402
++#define GL_TEXTURE_GEN_MODE 0x2500
++#define GL_OBJECT_PLANE 0x2501
++#define GL_EYE_PLANE 0x2502
++#define GL_CLAMP 0x2900
++#define GL_ALPHA4 0x803B
++#define GL_ALPHA8 0x803C
++#define GL_ALPHA12 0x803D
++#define GL_ALPHA16 0x803E
++#define GL_LUMINANCE4 0x803F
++#define GL_LUMINANCE8 0x8040
++#define GL_LUMINANCE12 0x8041
++#define GL_LUMINANCE16 0x8042
++#define GL_LUMINANCE4_ALPHA4 0x8043
++#define GL_LUMINANCE6_ALPHA2 0x8044
++#define GL_LUMINANCE8_ALPHA8 0x8045
++#define GL_LUMINANCE12_ALPHA4 0x8046
++#define GL_LUMINANCE12_ALPHA12 0x8047
++#define GL_LUMINANCE16_ALPHA16 0x8048
++#define GL_INTENSITY 0x8049
++#define GL_INTENSITY4 0x804A
++#define GL_INTENSITY8 0x804B
++#define GL_INTENSITY12 0x804C
++#define GL_INTENSITY16 0x804D
++#define GL_V2F 0x2A20
++#define GL_V3F 0x2A21
++#define GL_C4UB_V2F 0x2A22
++#define GL_C4UB_V3F 0x2A23
++#define GL_C3F_V3F 0x2A24
++#define GL_N3F_V3F 0x2A25
++#define GL_C4F_N3F_V3F 0x2A26
++#define GL_T2F_V3F 0x2A27
++#define GL_T4F_V4F 0x2A28
++#define GL_T2F_C4UB_V3F 0x2A29
++#define GL_T2F_C3F_V3F 0x2A2A
++#define GL_T2F_N3F_V3F 0x2A2B
++#define GL_T2F_C4F_N3F_V3F 0x2A2C
++#define GL_T4F_C4F_N3F_V4F 0x2A2D
++#define GL_CLIP_PLANE0 0x3000
++#define GL_CLIP_PLANE1 0x3001
++#define GL_CLIP_PLANE2 0x3002
++#define GL_CLIP_PLANE3 0x3003
++#define GL_CLIP_PLANE4 0x3004
++#define GL_CLIP_PLANE5 0x3005
++#define GL_LIGHT0 0x4000
++#define GL_LIGHT1 0x4001
++#define GL_LIGHT2 0x4002
++#define GL_LIGHT3 0x4003
++#define GL_LIGHT4 0x4004
++#define GL_LIGHT5 0x4005
++#define GL_LIGHT6 0x4006
++#define GL_LIGHT7 0x4007
++#define GL_UNSIGNED_BYTE_3_3_2 0x8032
++#define GL_UNSIGNED_SHORT_4_4_4_4 0x8033
++#define GL_UNSIGNED_SHORT_5_5_5_1 0x8034
++#define GL_UNSIGNED_INT_8_8_8_8 0x8035
++#define GL_UNSIGNED_INT_10_10_10_2 0x8036
++#define GL_TEXTURE_BINDING_3D 0x806A
++#define GL_PACK_SKIP_IMAGES 0x806B
++#define GL_PACK_IMAGE_HEIGHT 0x806C
++#define GL_UNPACK_SKIP_IMAGES 0x806D
++#define GL_UNPACK_IMAGE_HEIGHT 0x806E
++#define GL_TEXTURE_3D 0x806F
++#define GL_PROXY_TEXTURE_3D 0x8070
++#define GL_TEXTURE_DEPTH 0x8071
++#define GL_TEXTURE_WRAP_R 0x8072
++#define GL_MAX_3D_TEXTURE_SIZE 0x8073
++#define GL_UNSIGNED_BYTE_2_3_3_REV 0x8362
++#define GL_UNSIGNED_SHORT_5_6_5 0x8363
++#define GL_UNSIGNED_SHORT_5_6_5_REV 0x8364
++#define GL_UNSIGNED_SHORT_4_4_4_4_REV 0x8365
++#define GL_UNSIGNED_SHORT_1_5_5_5_REV 0x8366
++#define GL_UNSIGNED_INT_8_8_8_8_REV 0x8367
++#define GL_UNSIGNED_INT_2_10_10_10_REV 0x8368
++#define GL_BGR 0x80E0
++#define GL_BGRA 0x80E1
++#define GL_MAX_ELEMENTS_VERTICES 0x80E8
++#define GL_MAX_ELEMENTS_INDICES 0x80E9
++#define GL_CLAMP_TO_EDGE 0x812F
++#define GL_TEXTURE_MIN_LOD 0x813A
++#define GL_TEXTURE_MAX_LOD 0x813B
++#define GL_TEXTURE_BASE_LEVEL 0x813C
++#define GL_TEXTURE_MAX_LEVEL 0x813D
++#define GL_SMOOTH_POINT_SIZE_RANGE 0x0B12
++#define GL_SMOOTH_POINT_SIZE_GRANULARITY 0x0B13
++#define GL_SMOOTH_LINE_WIDTH_RANGE 0x0B22
++#define GL_SMOOTH_LINE_WIDTH_GRANULARITY 0x0B23
++#define GL_ALIASED_LINE_WIDTH_RANGE 0x846E
++#define GL_RESCALE_NORMAL 0x803A
++#define GL_LIGHT_MODEL_COLOR_CONTROL 0x81F8
++#define GL_SINGLE_COLOR 0x81F9
++#define GL_SEPARATE_SPECULAR_COLOR 0x81FA
++#define GL_ALIASED_POINT_SIZE_RANGE 0x846D
++#define GL_TEXTURE0 0x84C0
++#define GL_TEXTURE1 0x84C1
++#define GL_TEXTURE2 0x84C2
++#define GL_TEXTURE3 0x84C3
++#define GL_TEXTURE4 0x84C4
++#define GL_TEXTURE5 0x84C5
++#define GL_TEXTURE6 0x84C6
++#define GL_TEXTURE7 0x84C7
++#define GL_TEXTURE8 0x84C8
++#define GL_TEXTURE9 0x84C9
++#define GL_TEXTURE10 0x84CA
++#define GL_TEXTURE11 0x84CB
++#define GL_TEXTURE12 0x84CC
++#define GL_TEXTURE13 0x84CD
++#define GL_TEXTURE14 0x84CE
++#define GL_TEXTURE15 0x84CF
++#define GL_TEXTURE16 0x84D0
++#define GL_TEXTURE17 0x84D1
++#define GL_TEXTURE18 0x84D2
++#define GL_TEXTURE19 0x84D3
++#define GL_TEXTURE20 0x84D4
++#define GL_TEXTURE21 0x84D5
++#define GL_TEXTURE22 0x84D6
++#define GL_TEXTURE23 0x84D7
++#define GL_TEXTURE24 0x84D8
++#define GL_TEXTURE25 0x84D9
++#define GL_TEXTURE26 0x84DA
++#define GL_TEXTURE27 0x84DB
++#define GL_TEXTURE28 0x84DC
++#define GL_TEXTURE29 0x84DD
++#define GL_TEXTURE30 0x84DE
++#define GL_TEXTURE31 0x84DF
++#define GL_ACTIVE_TEXTURE 0x84E0
++#define GL_MULTISAMPLE 0x809D
++#define GL_SAMPLE_ALPHA_TO_COVERAGE 0x809E
++#define GL_SAMPLE_ALPHA_TO_ONE 0x809F
++#define GL_SAMPLE_COVERAGE 0x80A0
++#define GL_SAMPLE_BUFFERS 0x80A8
++#define GL_SAMPLES 0x80A9
++#define GL_SAMPLE_COVERAGE_VALUE 0x80AA
++#define GL_SAMPLE_COVERAGE_INVERT 0x80AB
++#define GL_TEXTURE_CUBE_MAP 0x8513
++#define GL_TEXTURE_BINDING_CUBE_MAP 0x8514
++#define GL_TEXTURE_CUBE_MAP_POSITIVE_X 0x8515
++#define GL_TEXTURE_CUBE_MAP_NEGATIVE_X 0x8516
++#define GL_TEXTURE_CUBE_MAP_POSITIVE_Y 0x8517
++#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y 0x8518
++#define GL_TEXTURE_CUBE_MAP_POSITIVE_Z 0x8519
++#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z 0x851A
++#define GL_PROXY_TEXTURE_CUBE_MAP 0x851B
++#define GL_MAX_CUBE_MAP_TEXTURE_SIZE 0x851C
++#define GL_COMPRESSED_RGB 0x84ED
++#define GL_COMPRESSED_RGBA 0x84EE
++#define GL_TEXTURE_COMPRESSION_HINT 0x84EF
++#define GL_TEXTURE_COMPRESSED_IMAGE_SIZE 0x86A0
++#define GL_TEXTURE_COMPRESSED 0x86A1
++#define GL_NUM_COMPRESSED_TEXTURE_FORMATS 0x86A2
++#define GL_COMPRESSED_TEXTURE_FORMATS 0x86A3
++#define GL_CLAMP_TO_BORDER 0x812D
++#define GL_CLIENT_ACTIVE_TEXTURE 0x84E1
++#define GL_MAX_TEXTURE_UNITS 0x84E2
++#define GL_TRANSPOSE_MODELVIEW_MATRIX 0x84E3
++#define GL_TRANSPOSE_PROJECTION_MATRIX 0x84E4
++#define GL_TRANSPOSE_TEXTURE_MATRIX 0x84E5
++#define GL_TRANSPOSE_COLOR_MATRIX 0x84E6
++#define GL_MULTISAMPLE_BIT 0x20000000
++#define GL_NORMAL_MAP 0x8511
++#define GL_REFLECTION_MAP 0x8512
++#define GL_COMPRESSED_ALPHA 0x84E9
++#define GL_COMPRESSED_LUMINANCE 0x84EA
++#define GL_COMPRESSED_LUMINANCE_ALPHA 0x84EB
++#define GL_COMPRESSED_INTENSITY 0x84EC
++#define GL_COMBINE 0x8570
++#define GL_COMBINE_RGB 0x8571
++#define GL_COMBINE_ALPHA 0x8572
++#define GL_SOURCE0_RGB 0x8580
++#define GL_SOURCE1_RGB 0x8581
++#define GL_SOURCE2_RGB 0x8582
++#define GL_SOURCE0_ALPHA 0x8588
++#define GL_SOURCE1_ALPHA 0x8589
++#define GL_SOURCE2_ALPHA 0x858A
++#define GL_OPERAND0_RGB 0x8590
++#define GL_OPERAND1_RGB 0x8591
++#define GL_OPERAND2_RGB 0x8592
++#define GL_OPERAND0_ALPHA 0x8598
++#define GL_OPERAND1_ALPHA 0x8599
++#define GL_OPERAND2_ALPHA 0x859A
++#define GL_RGB_SCALE 0x8573
++#define GL_ADD_SIGNED 0x8574
++#define GL_INTERPOLATE 0x8575
++#define GL_SUBTRACT 0x84E7
++#define GL_CONSTANT 0x8576
++#define GL_PRIMARY_COLOR 0x8577
++#define GL_PREVIOUS 0x8578
++#define GL_DOT3_RGB 0x86AE
++#define GL_DOT3_RGBA 0x86AF
++#define GL_BLEND_DST_RGB 0x80C8
++#define GL_BLEND_SRC_RGB 0x80C9
++#define GL_BLEND_DST_ALPHA 0x80CA
++#define GL_BLEND_SRC_ALPHA 0x80CB
++#define GL_POINT_FADE_THRESHOLD_SIZE 0x8128
++#define GL_DEPTH_COMPONENT16 0x81A5
++#define GL_DEPTH_COMPONENT24 0x81A6
++#define GL_DEPTH_COMPONENT32 0x81A7
++#define GL_MIRRORED_REPEAT 0x8370
++#define GL_MAX_TEXTURE_LOD_BIAS 0x84FD
++#define GL_TEXTURE_LOD_BIAS 0x8501
++#define GL_INCR_WRAP 0x8507
++#define GL_DECR_WRAP 0x8508
++#define GL_TEXTURE_DEPTH_SIZE 0x884A
++#define GL_TEXTURE_COMPARE_MODE 0x884C
++#define GL_TEXTURE_COMPARE_FUNC 0x884D
++#define GL_POINT_SIZE_MIN 0x8126
++#define GL_POINT_SIZE_MAX 0x8127
++#define GL_POINT_DISTANCE_ATTENUATION 0x8129
++#define GL_GENERATE_MIPMAP 0x8191
++#define GL_GENERATE_MIPMAP_HINT 0x8192
++#define GL_FOG_COORDINATE_SOURCE 0x8450
++#define GL_FOG_COORDINATE 0x8451
++#define GL_FRAGMENT_DEPTH 0x8452
++#define GL_CURRENT_FOG_COORDINATE 0x8453
++#define GL_FOG_COORDINATE_ARRAY_TYPE 0x8454
++#define GL_FOG_COORDINATE_ARRAY_STRIDE 0x8455
++#define GL_FOG_COORDINATE_ARRAY_POINTER 0x8456
++#define GL_FOG_COORDINATE_ARRAY 0x8457
++#define GL_COLOR_SUM 0x8458
++#define GL_CURRENT_SECONDARY_COLOR 0x8459
++#define GL_SECONDARY_COLOR_ARRAY_SIZE 0x845A
++#define GL_SECONDARY_COLOR_ARRAY_TYPE 0x845B
++#define GL_SECONDARY_COLOR_ARRAY_STRIDE 0x845C
++#define GL_SECONDARY_COLOR_ARRAY_POINTER 0x845D
++#define GL_SECONDARY_COLOR_ARRAY 0x845E
++#define GL_TEXTURE_FILTER_CONTROL 0x8500
++#define GL_DEPTH_TEXTURE_MODE 0x884B
++#define GL_COMPARE_R_TO_TEXTURE 0x884E
++#define GL_FUNC_ADD 0x8006
++#define GL_FUNC_SUBTRACT 0x800A
++#define GL_FUNC_REVERSE_SUBTRACT 0x800B
++#define GL_MIN 0x8007
++#define GL_MAX 0x8008
++#define GL_CONSTANT_COLOR 0x8001
++#define GL_ONE_MINUS_CONSTANT_COLOR 0x8002
++#define GL_CONSTANT_ALPHA 0x8003
++#define GL_ONE_MINUS_CONSTANT_ALPHA 0x8004
++#define GL_BUFFER_SIZE 0x8764
++#define GL_BUFFER_USAGE 0x8765
++#define GL_QUERY_COUNTER_BITS 0x8864
++#define GL_CURRENT_QUERY 0x8865
++#define GL_QUERY_RESULT 0x8866
++#define GL_QUERY_RESULT_AVAILABLE 0x8867
++#define GL_ARRAY_BUFFER 0x8892
++#define GL_ELEMENT_ARRAY_BUFFER 0x8893
++#define GL_ARRAY_BUFFER_BINDING 0x8894
++#define GL_ELEMENT_ARRAY_BUFFER_BINDING 0x8895
++#define GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING 0x889F
++#define GL_READ_ONLY 0x88B8
++#define GL_WRITE_ONLY 0x88B9
++#define GL_READ_WRITE 0x88BA
++#define GL_BUFFER_ACCESS 0x88BB
++#define GL_BUFFER_MAPPED 0x88BC
++#define GL_BUFFER_MAP_POINTER 0x88BD
++#define GL_STREAM_DRAW 0x88E0
++#define GL_STREAM_READ 0x88E1
++#define GL_STREAM_COPY 0x88E2
++#define GL_STATIC_DRAW 0x88E4
++#define GL_STATIC_READ 0x88E5
++#define GL_STATIC_COPY 0x88E6
++#define GL_DYNAMIC_DRAW 0x88E8
++#define GL_DYNAMIC_READ 0x88E9
++#define GL_DYNAMIC_COPY 0x88EA
++#define GL_SAMPLES_PASSED 0x8914
++#define GL_SRC1_ALPHA 0x8589
++#define GL_VERTEX_ARRAY_BUFFER_BINDING 0x8896
++#define GL_NORMAL_ARRAY_BUFFER_BINDING 0x8897
++#define GL_COLOR_ARRAY_BUFFER_BINDING 0x8898
++#define GL_INDEX_ARRAY_BUFFER_BINDING 0x8899
++#define GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING 0x889A
++#define GL_EDGE_FLAG_ARRAY_BUFFER_BINDING 0x889B
++#define GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING 0x889C
++#define GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING 0x889D
++#define GL_WEIGHT_ARRAY_BUFFER_BINDING 0x889E
++#define GL_FOG_COORD_SRC 0x8450
++#define GL_FOG_COORD 0x8451
++#define GL_CURRENT_FOG_COORD 0x8453
++#define GL_FOG_COORD_ARRAY_TYPE 0x8454
++#define GL_FOG_COORD_ARRAY_STRIDE 0x8455
++#define GL_FOG_COORD_ARRAY_POINTER 0x8456
++#define GL_FOG_COORD_ARRAY 0x8457
++#define GL_FOG_COORD_ARRAY_BUFFER_BINDING 0x889D
++#define GL_SRC0_RGB 0x8580
++#define GL_SRC1_RGB 0x8581
++#define GL_SRC2_RGB 0x8582
++#define GL_SRC0_ALPHA 0x8588
++#define GL_SRC2_ALPHA 0x858A
++#define GL_BLEND_EQUATION_RGB 0x8009
++#define GL_VERTEX_ATTRIB_ARRAY_ENABLED 0x8622
++#define GL_VERTEX_ATTRIB_ARRAY_SIZE 0x8623
++#define GL_VERTEX_ATTRIB_ARRAY_STRIDE 0x8624
++#define GL_VERTEX_ATTRIB_ARRAY_TYPE 0x8625
++#define GL_CURRENT_VERTEX_ATTRIB 0x8626
++#define GL_VERTEX_PROGRAM_POINT_SIZE 0x8642
++#define GL_VERTEX_ATTRIB_ARRAY_POINTER 0x8645
++#define GL_STENCIL_BACK_FUNC 0x8800
++#define GL_STENCIL_BACK_FAIL 0x8801
++#define GL_STENCIL_BACK_PASS_DEPTH_FAIL 0x8802
++#define GL_STENCIL_BACK_PASS_DEPTH_PASS 0x8803
++#define GL_MAX_DRAW_BUFFERS 0x8824
++#define GL_DRAW_BUFFER0 0x8825
++#define GL_DRAW_BUFFER1 0x8826
++#define GL_DRAW_BUFFER2 0x8827
++#define GL_DRAW_BUFFER3 0x8828
++#define GL_DRAW_BUFFER4 0x8829
++#define GL_DRAW_BUFFER5 0x882A
++#define GL_DRAW_BUFFER6 0x882B
++#define GL_DRAW_BUFFER7 0x882C
++#define GL_DRAW_BUFFER8 0x882D
++#define GL_DRAW_BUFFER9 0x882E
++#define GL_DRAW_BUFFER10 0x882F
++#define GL_DRAW_BUFFER11 0x8830
++#define GL_DRAW_BUFFER12 0x8831
++#define GL_DRAW_BUFFER13 0x8832
++#define GL_DRAW_BUFFER14 0x8833
++#define GL_DRAW_BUFFER15 0x8834
++#define GL_BLEND_EQUATION_ALPHA 0x883D
++#define GL_MAX_VERTEX_ATTRIBS 0x8869
++#define GL_VERTEX_ATTRIB_ARRAY_NORMALIZED 0x886A
++#define GL_MAX_TEXTURE_IMAGE_UNITS 0x8872
++#define GL_FRAGMENT_SHADER 0x8B30
++#define GL_VERTEX_SHADER 0x8B31
++#define GL_MAX_FRAGMENT_UNIFORM_COMPONENTS 0x8B49
++#define GL_MAX_VERTEX_UNIFORM_COMPONENTS 0x8B4A
++#define GL_MAX_VARYING_FLOATS 0x8B4B
++#define GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS 0x8B4C
++#define GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS 0x8B4D
++#define GL_SHADER_TYPE 0x8B4F
++#define GL_FLOAT_VEC2 0x8B50
++#define GL_FLOAT_VEC3 0x8B51
++#define GL_FLOAT_VEC4 0x8B52
++#define GL_INT_VEC2 0x8B53
++#define GL_INT_VEC3 0x8B54
++#define GL_INT_VEC4 0x8B55
++#define GL_BOOL 0x8B56
++#define GL_BOOL_VEC2 0x8B57
++#define GL_BOOL_VEC3 0x8B58
++#define GL_BOOL_VEC4 0x8B59
++#define GL_FLOAT_MAT2 0x8B5A
++#define GL_FLOAT_MAT3 0x8B5B
++#define GL_FLOAT_MAT4 0x8B5C
++#define GL_SAMPLER_1D 0x8B5D
++#define GL_SAMPLER_2D 0x8B5E
++#define GL_SAMPLER_3D 0x8B5F
++#define GL_SAMPLER_CUBE 0x8B60
++#define GL_SAMPLER_1D_SHADOW 0x8B61
++#define GL_SAMPLER_2D_SHADOW 0x8B62
++#define GL_DELETE_STATUS 0x8B80
++#define GL_COMPILE_STATUS 0x8B81
++#define GL_LINK_STATUS 0x8B82
++#define GL_VALIDATE_STATUS 0x8B83
++#define GL_INFO_LOG_LENGTH 0x8B84
++#define GL_ATTACHED_SHADERS 0x8B85
++#define GL_ACTIVE_UNIFORMS 0x8B86
++#define GL_ACTIVE_UNIFORM_MAX_LENGTH 0x8B87
++#define GL_SHADER_SOURCE_LENGTH 0x8B88
++#define GL_ACTIVE_ATTRIBUTES 0x8B89
++#define GL_ACTIVE_ATTRIBUTE_MAX_LENGTH 0x8B8A
++#define GL_FRAGMENT_SHADER_DERIVATIVE_HINT 0x8B8B
++#define GL_SHADING_LANGUAGE_VERSION 0x8B8C
++#define GL_CURRENT_PROGRAM 0x8B8D
++#define GL_POINT_SPRITE_COORD_ORIGIN 0x8CA0
++#define GL_LOWER_LEFT 0x8CA1
++#define GL_UPPER_LEFT 0x8CA2
++#define GL_STENCIL_BACK_REF 0x8CA3
++#define GL_STENCIL_BACK_VALUE_MASK 0x8CA4
++#define GL_STENCIL_BACK_WRITEMASK 0x8CA5
++#define GL_VERTEX_PROGRAM_TWO_SIDE 0x8643
++#define GL_POINT_SPRITE 0x8861
++#define GL_COORD_REPLACE 0x8862
++#define GL_MAX_TEXTURE_COORDS 0x8871
++#define GL_PIXEL_PACK_BUFFER 0x88EB
++#define GL_PIXEL_UNPACK_BUFFER 0x88EC
++#define GL_PIXEL_PACK_BUFFER_BINDING 0x88ED
++#define GL_PIXEL_UNPACK_BUFFER_BINDING 0x88EF
++#define GL_FLOAT_MAT2x3 0x8B65
++#define GL_FLOAT_MAT2x4 0x8B66
++#define GL_FLOAT_MAT3x2 0x8B67
++#define GL_FLOAT_MAT3x4 0x8B68
++#define GL_FLOAT_MAT4x2 0x8B69
++#define GL_FLOAT_MAT4x3 0x8B6A
++#define GL_SRGB 0x8C40
++#define GL_SRGB8 0x8C41
++#define GL_SRGB_ALPHA 0x8C42
++#define GL_SRGB8_ALPHA8 0x8C43
++#define GL_COMPRESSED_SRGB 0x8C48
++#define GL_COMPRESSED_SRGB_ALPHA 0x8C49
++#define GL_CURRENT_RASTER_SECONDARY_COLOR 0x845F
++#define GL_SLUMINANCE_ALPHA 0x8C44
++#define GL_SLUMINANCE8_ALPHA8 0x8C45
++#define GL_SLUMINANCE 0x8C46
++#define GL_SLUMINANCE8 0x8C47
++#define GL_COMPRESSED_SLUMINANCE 0x8C4A
++#define GL_COMPRESSED_SLUMINANCE_ALPHA 0x8C4B
++#define GL_COMPARE_REF_TO_TEXTURE 0x884E
++#define GL_CLIP_DISTANCE0 0x3000
++#define GL_CLIP_DISTANCE1 0x3001
++#define GL_CLIP_DISTANCE2 0x3002
++#define GL_CLIP_DISTANCE3 0x3003
++#define GL_CLIP_DISTANCE4 0x3004
++#define GL_CLIP_DISTANCE5 0x3005
++#define GL_CLIP_DISTANCE6 0x3006
++#define GL_CLIP_DISTANCE7 0x3007
++#define GL_MAX_CLIP_DISTANCES 0x0D32
++#define GL_MAJOR_VERSION 0x821B
++#define GL_MINOR_VERSION 0x821C
++#define GL_NUM_EXTENSIONS 0x821D
++#define GL_CONTEXT_FLAGS 0x821E
++#define GL_COMPRESSED_RED 0x8225
++#define GL_COMPRESSED_RG 0x8226
++#define GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT 0x00000001
++#define GL_RGBA32F 0x8814
++#define GL_RGB32F 0x8815
++#define GL_RGBA16F 0x881A
++#define GL_RGB16F 0x881B
++#define GL_VERTEX_ATTRIB_ARRAY_INTEGER 0x88FD
++#define GL_MAX_ARRAY_TEXTURE_LAYERS 0x88FF
++#define GL_MIN_PROGRAM_TEXEL_OFFSET 0x8904
++#define GL_MAX_PROGRAM_TEXEL_OFFSET 0x8905
++#define GL_CLAMP_READ_COLOR 0x891C
++#define GL_FIXED_ONLY 0x891D
++#define GL_MAX_VARYING_COMPONENTS 0x8B4B
++#define GL_TEXTURE_1D_ARRAY 0x8C18
++#define GL_PROXY_TEXTURE_1D_ARRAY 0x8C19
++#define GL_TEXTURE_2D_ARRAY 0x8C1A
++#define GL_PROXY_TEXTURE_2D_ARRAY 0x8C1B
++#define GL_TEXTURE_BINDING_1D_ARRAY 0x8C1C
++#define GL_TEXTURE_BINDING_2D_ARRAY 0x8C1D
++#define GL_R11F_G11F_B10F 0x8C3A
++#define GL_UNSIGNED_INT_10F_11F_11F_REV 0x8C3B
++#define GL_RGB9_E5 0x8C3D
++#define GL_UNSIGNED_INT_5_9_9_9_REV 0x8C3E
++#define GL_TEXTURE_SHARED_SIZE 0x8C3F
++#define GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH 0x8C76
++#define GL_TRANSFORM_FEEDBACK_BUFFER_MODE 0x8C7F
++#define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS 0x8C80
++#define GL_TRANSFORM_FEEDBACK_VARYINGS 0x8C83
++#define GL_TRANSFORM_FEEDBACK_BUFFER_START 0x8C84
++#define GL_TRANSFORM_FEEDBACK_BUFFER_SIZE 0x8C85
++#define GL_PRIMITIVES_GENERATED 0x8C87
++#define GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN 0x8C88
++#define GL_RASTERIZER_DISCARD 0x8C89
++#define GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS 0x8C8A
++#define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS 0x8C8B
++#define GL_INTERLEAVED_ATTRIBS 0x8C8C
++#define GL_SEPARATE_ATTRIBS 0x8C8D
++#define GL_TRANSFORM_FEEDBACK_BUFFER 0x8C8E
++#define GL_TRANSFORM_FEEDBACK_BUFFER_BINDING 0x8C8F
++#define GL_RGBA32UI 0x8D70
++#define GL_RGB32UI 0x8D71
++#define GL_RGBA16UI 0x8D76
++#define GL_RGB16UI 0x8D77
++#define GL_RGBA8UI 0x8D7C
++#define GL_RGB8UI 0x8D7D
++#define GL_RGBA32I 0x8D82
++#define GL_RGB32I 0x8D83
++#define GL_RGBA16I 0x8D88
++#define GL_RGB16I 0x8D89
++#define GL_RGBA8I 0x8D8E
++#define GL_RGB8I 0x8D8F
++#define GL_RED_INTEGER 0x8D94
++#define GL_GREEN_INTEGER 0x8D95
++#define GL_BLUE_INTEGER 0x8D96
++#define GL_RGB_INTEGER 0x8D98
++#define GL_RGBA_INTEGER 0x8D99
++#define GL_BGR_INTEGER 0x8D9A
++#define GL_BGRA_INTEGER 0x8D9B
++#define GL_SAMPLER_1D_ARRAY 0x8DC0
++#define GL_SAMPLER_2D_ARRAY 0x8DC1
++#define GL_SAMPLER_1D_ARRAY_SHADOW 0x8DC3
++#define GL_SAMPLER_2D_ARRAY_SHADOW 0x8DC4
++#define GL_SAMPLER_CUBE_SHADOW 0x8DC5
++#define GL_UNSIGNED_INT_VEC2 0x8DC6
++#define GL_UNSIGNED_INT_VEC3 0x8DC7
++#define GL_UNSIGNED_INT_VEC4 0x8DC8
++#define GL_INT_SAMPLER_1D 0x8DC9
++#define GL_INT_SAMPLER_2D 0x8DCA
++#define GL_INT_SAMPLER_3D 0x8DCB
++#define GL_INT_SAMPLER_CUBE 0x8DCC
++#define GL_INT_SAMPLER_1D_ARRAY 0x8DCE
++#define GL_INT_SAMPLER_2D_ARRAY 0x8DCF
++#define GL_UNSIGNED_INT_SAMPLER_1D 0x8DD1
++#define GL_UNSIGNED_INT_SAMPLER_2D 0x8DD2
++#define GL_UNSIGNED_INT_SAMPLER_3D 0x8DD3
++#define GL_UNSIGNED_INT_SAMPLER_CUBE 0x8DD4
++#define GL_UNSIGNED_INT_SAMPLER_1D_ARRAY 0x8DD6
++#define GL_UNSIGNED_INT_SAMPLER_2D_ARRAY 0x8DD7
++#define GL_QUERY_WAIT 0x8E13
++#define GL_QUERY_NO_WAIT 0x8E14
++#define GL_QUERY_BY_REGION_WAIT 0x8E15
++#define GL_QUERY_BY_REGION_NO_WAIT 0x8E16
++#define GL_BUFFER_ACCESS_FLAGS 0x911F
++#define GL_BUFFER_MAP_LENGTH 0x9120
++#define GL_BUFFER_MAP_OFFSET 0x9121
++#define GL_DEPTH_COMPONENT32F 0x8CAC
++#define GL_DEPTH32F_STENCIL8 0x8CAD
++#define GL_FLOAT_32_UNSIGNED_INT_24_8_REV 0x8DAD
++#define GL_INVALID_FRAMEBUFFER_OPERATION 0x0506
++#define GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING 0x8210
++#define GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE 0x8211
++#define GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE 0x8212
++#define GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE 0x8213
++#define GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE 0x8214
++#define GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE 0x8215
++#define GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE 0x8216
++#define GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE 0x8217
++#define GL_FRAMEBUFFER_DEFAULT 0x8218
++#define GL_FRAMEBUFFER_UNDEFINED 0x8219
++#define GL_DEPTH_STENCIL_ATTACHMENT 0x821A
++#define GL_MAX_RENDERBUFFER_SIZE 0x84E8
++#define GL_DEPTH_STENCIL 0x84F9
++#define GL_UNSIGNED_INT_24_8 0x84FA
++#define GL_DEPTH24_STENCIL8 0x88F0
++#define GL_TEXTURE_STENCIL_SIZE 0x88F1
++#define GL_TEXTURE_RED_TYPE 0x8C10
++#define GL_TEXTURE_GREEN_TYPE 0x8C11
++#define GL_TEXTURE_BLUE_TYPE 0x8C12
++#define GL_TEXTURE_ALPHA_TYPE 0x8C13
++#define GL_TEXTURE_DEPTH_TYPE 0x8C16
++#define GL_UNSIGNED_NORMALIZED 0x8C17
++#define GL_FRAMEBUFFER_BINDING 0x8CA6
++#define GL_DRAW_FRAMEBUFFER_BINDING 0x8CA6
++#define GL_RENDERBUFFER_BINDING 0x8CA7
++#define GL_READ_FRAMEBUFFER 0x8CA8
++#define GL_DRAW_FRAMEBUFFER 0x8CA9
++#define GL_READ_FRAMEBUFFER_BINDING 0x8CAA
++#define GL_RENDERBUFFER_SAMPLES 0x8CAB
++#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE 0x8CD0
++#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME 0x8CD1
++#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL 0x8CD2
++#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE 0x8CD3
++#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER 0x8CD4
++#define GL_FRAMEBUFFER_COMPLETE 0x8CD5
++#define GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT 0x8CD6
++#define GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT 0x8CD7
++#define GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER 0x8CDB
++#define GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER 0x8CDC
++#define GL_FRAMEBUFFER_UNSUPPORTED 0x8CDD
++#define GL_MAX_COLOR_ATTACHMENTS 0x8CDF
++#define GL_COLOR_ATTACHMENT0 0x8CE0
++#define GL_COLOR_ATTACHMENT1 0x8CE1
++#define GL_COLOR_ATTACHMENT2 0x8CE2
++#define GL_COLOR_ATTACHMENT3 0x8CE3
++#define GL_COLOR_ATTACHMENT4 0x8CE4
++#define GL_COLOR_ATTACHMENT5 0x8CE5
++#define GL_COLOR_ATTACHMENT6 0x8CE6
++#define GL_COLOR_ATTACHMENT7 0x8CE7
++#define GL_COLOR_ATTACHMENT8 0x8CE8
++#define GL_COLOR_ATTACHMENT9 0x8CE9
++#define GL_COLOR_ATTACHMENT10 0x8CEA
++#define GL_COLOR_ATTACHMENT11 0x8CEB
++#define GL_COLOR_ATTACHMENT12 0x8CEC
++#define GL_COLOR_ATTACHMENT13 0x8CED
++#define GL_COLOR_ATTACHMENT14 0x8CEE
++#define GL_COLOR_ATTACHMENT15 0x8CEF
++#define GL_COLOR_ATTACHMENT16 0x8CF0
++#define GL_COLOR_ATTACHMENT17 0x8CF1
++#define GL_COLOR_ATTACHMENT18 0x8CF2
++#define GL_COLOR_ATTACHMENT19 0x8CF3
++#define GL_COLOR_ATTACHMENT20 0x8CF4
++#define GL_COLOR_ATTACHMENT21 0x8CF5
++#define GL_COLOR_ATTACHMENT22 0x8CF6
++#define GL_COLOR_ATTACHMENT23 0x8CF7
++#define GL_COLOR_ATTACHMENT24 0x8CF8
++#define GL_COLOR_ATTACHMENT25 0x8CF9
++#define GL_COLOR_ATTACHMENT26 0x8CFA
++#define GL_COLOR_ATTACHMENT27 0x8CFB
++#define GL_COLOR_ATTACHMENT28 0x8CFC
++#define GL_COLOR_ATTACHMENT29 0x8CFD
++#define GL_COLOR_ATTACHMENT30 0x8CFE
++#define GL_COLOR_ATTACHMENT31 0x8CFF
++#define GL_DEPTH_ATTACHMENT 0x8D00
++#define GL_STENCIL_ATTACHMENT 0x8D20
++#define GL_FRAMEBUFFER 0x8D40
++#define GL_RENDERBUFFER 0x8D41
++#define GL_RENDERBUFFER_WIDTH 0x8D42
++#define GL_RENDERBUFFER_HEIGHT 0x8D43
++#define GL_RENDERBUFFER_INTERNAL_FORMAT 0x8D44
++#define GL_STENCIL_INDEX1 0x8D46
++#define GL_STENCIL_INDEX4 0x8D47
++#define GL_STENCIL_INDEX8 0x8D48
++#define GL_STENCIL_INDEX16 0x8D49
++#define GL_RENDERBUFFER_RED_SIZE 0x8D50
++#define GL_RENDERBUFFER_GREEN_SIZE 0x8D51
++#define GL_RENDERBUFFER_BLUE_SIZE 0x8D52
++#define GL_RENDERBUFFER_ALPHA_SIZE 0x8D53
++#define GL_RENDERBUFFER_DEPTH_SIZE 0x8D54
++#define GL_RENDERBUFFER_STENCIL_SIZE 0x8D55
++#define GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE 0x8D56
++#define GL_MAX_SAMPLES 0x8D57
++#define GL_INDEX 0x8222
++#define GL_TEXTURE_LUMINANCE_TYPE 0x8C14
++#define GL_TEXTURE_INTENSITY_TYPE 0x8C15
++#define GL_FRAMEBUFFER_SRGB 0x8DB9
++#define GL_HALF_FLOAT 0x140B
++#define GL_MAP_READ_BIT 0x0001
++#define GL_MAP_WRITE_BIT 0x0002
++#define GL_MAP_INVALIDATE_RANGE_BIT 0x0004
++#define GL_MAP_INVALIDATE_BUFFER_BIT 0x0008
++#define GL_MAP_FLUSH_EXPLICIT_BIT 0x0010
++#define GL_MAP_UNSYNCHRONIZED_BIT 0x0020
++#define GL_COMPRESSED_RED_RGTC1 0x8DBB
++#define GL_COMPRESSED_SIGNED_RED_RGTC1 0x8DBC
++#define GL_COMPRESSED_RG_RGTC2 0x8DBD
++#define GL_COMPRESSED_SIGNED_RG_RGTC2 0x8DBE
++#define GL_RG 0x8227
++#define GL_RG_INTEGER 0x8228
++#define GL_R8 0x8229
++#define GL_R16 0x822A
++#define GL_RG8 0x822B
++#define GL_RG16 0x822C
++#define GL_R16F 0x822D
++#define GL_R32F 0x822E
++#define GL_RG16F 0x822F
++#define GL_RG32F 0x8230
++#define GL_R8I 0x8231
++#define GL_R8UI 0x8232
++#define GL_R16I 0x8233
++#define GL_R16UI 0x8234
++#define GL_R32I 0x8235
++#define GL_R32UI 0x8236
++#define GL_RG8I 0x8237
++#define GL_RG8UI 0x8238
++#define GL_RG16I 0x8239
++#define GL_RG16UI 0x823A
++#define GL_RG32I 0x823B
++#define GL_RG32UI 0x823C
++#define GL_VERTEX_ARRAY_BINDING 0x85B5
++#define GL_CLAMP_VERTEX_COLOR 0x891A
++#define GL_CLAMP_FRAGMENT_COLOR 0x891B
++#define GL_ALPHA_INTEGER 0x8D97
++#define GL_SAMPLER_2D_RECT 0x8B63
++#define GL_SAMPLER_2D_RECT_SHADOW 0x8B64
++#define GL_SAMPLER_BUFFER 0x8DC2
++#define GL_INT_SAMPLER_2D_RECT 0x8DCD
++#define GL_INT_SAMPLER_BUFFER 0x8DD0
++#define GL_UNSIGNED_INT_SAMPLER_2D_RECT 0x8DD5
++#define GL_UNSIGNED_INT_SAMPLER_BUFFER 0x8DD8
++#define GL_TEXTURE_BUFFER 0x8C2A
++#define GL_MAX_TEXTURE_BUFFER_SIZE 0x8C2B
++#define GL_TEXTURE_BINDING_BUFFER 0x8C2C
++#define GL_TEXTURE_BUFFER_DATA_STORE_BINDING 0x8C2D
++#define GL_TEXTURE_RECTANGLE 0x84F5
++#define GL_TEXTURE_BINDING_RECTANGLE 0x84F6
++#define GL_PROXY_TEXTURE_RECTANGLE 0x84F7
++#define GL_MAX_RECTANGLE_TEXTURE_SIZE 0x84F8
++#define GL_R8_SNORM 0x8F94
++#define GL_RG8_SNORM 0x8F95
++#define GL_RGB8_SNORM 0x8F96
++#define GL_RGBA8_SNORM 0x8F97
++#define GL_R16_SNORM 0x8F98
++#define GL_RG16_SNORM 0x8F99
++#define GL_RGB16_SNORM 0x8F9A
++#define GL_RGBA16_SNORM 0x8F9B
++#define GL_SIGNED_NORMALIZED 0x8F9C
++#define GL_PRIMITIVE_RESTART 0x8F9D
++#define GL_PRIMITIVE_RESTART_INDEX 0x8F9E
++#define GL_COPY_READ_BUFFER 0x8F36
++#define GL_COPY_WRITE_BUFFER 0x8F37
++#define GL_UNIFORM_BUFFER 0x8A11
++#define GL_UNIFORM_BUFFER_BINDING 0x8A28
++#define GL_UNIFORM_BUFFER_START 0x8A29
++#define GL_UNIFORM_BUFFER_SIZE 0x8A2A
++#define GL_MAX_VERTEX_UNIFORM_BLOCKS 0x8A2B
++#define GL_MAX_GEOMETRY_UNIFORM_BLOCKS 0x8A2C
++#define GL_MAX_FRAGMENT_UNIFORM_BLOCKS 0x8A2D
++#define GL_MAX_COMBINED_UNIFORM_BLOCKS 0x8A2E
++#define GL_MAX_UNIFORM_BUFFER_BINDINGS 0x8A2F
++#define GL_MAX_UNIFORM_BLOCK_SIZE 0x8A30
++#define GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS 0x8A31
++#define GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS 0x8A32
++#define GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS 0x8A33
++#define GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT 0x8A34
++#define GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH 0x8A35
++#define GL_ACTIVE_UNIFORM_BLOCKS 0x8A36
++#define GL_UNIFORM_TYPE 0x8A37
++#define GL_UNIFORM_SIZE 0x8A38
++#define GL_UNIFORM_NAME_LENGTH 0x8A39
++#define GL_UNIFORM_BLOCK_INDEX 0x8A3A
++#define GL_UNIFORM_OFFSET 0x8A3B
++#define GL_UNIFORM_ARRAY_STRIDE 0x8A3C
++#define GL_UNIFORM_MATRIX_STRIDE 0x8A3D
++#define GL_UNIFORM_IS_ROW_MAJOR 0x8A3E
++#define GL_UNIFORM_BLOCK_BINDING 0x8A3F
++#define GL_UNIFORM_BLOCK_DATA_SIZE 0x8A40
++#define GL_UNIFORM_BLOCK_NAME_LENGTH 0x8A41
++#define GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS 0x8A42
++#define GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES 0x8A43
++#define GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER 0x8A44
++#define GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER 0x8A45
++#define GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER 0x8A46
++#define GL_INVALID_INDEX 0xFFFFFFFF
++#define GL_CONTEXT_CORE_PROFILE_BIT 0x00000001
++#define GL_CONTEXT_COMPATIBILITY_PROFILE_BIT 0x00000002
++#define GL_LINES_ADJACENCY 0x000A
++#define GL_LINE_STRIP_ADJACENCY 0x000B
++#define GL_TRIANGLES_ADJACENCY 0x000C
++#define GL_TRIANGLE_STRIP_ADJACENCY 0x000D
++#define GL_PROGRAM_POINT_SIZE 0x8642
++#define GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS 0x8C29
++#define GL_FRAMEBUFFER_ATTACHMENT_LAYERED 0x8DA7
++#define GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS 0x8DA8
++#define GL_GEOMETRY_SHADER 0x8DD9
++#define GL_GEOMETRY_VERTICES_OUT 0x8916
++#define GL_GEOMETRY_INPUT_TYPE 0x8917
++#define GL_GEOMETRY_OUTPUT_TYPE 0x8918
++#define GL_MAX_GEOMETRY_UNIFORM_COMPONENTS 0x8DDF
++#define GL_MAX_GEOMETRY_OUTPUT_VERTICES 0x8DE0
++#define GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS 0x8DE1
++#define GL_MAX_VERTEX_OUTPUT_COMPONENTS 0x9122
++#define GL_MAX_GEOMETRY_INPUT_COMPONENTS 0x9123
++#define GL_MAX_GEOMETRY_OUTPUT_COMPONENTS 0x9124
++#define GL_MAX_FRAGMENT_INPUT_COMPONENTS 0x9125
++#define GL_CONTEXT_PROFILE_MASK 0x9126
++#define GL_DEPTH_CLAMP 0x864F
++#define GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION 0x8E4C
++#define GL_FIRST_VERTEX_CONVENTION 0x8E4D
++#define GL_LAST_VERTEX_CONVENTION 0x8E4E
++#define GL_PROVOKING_VERTEX 0x8E4F
++#define GL_TEXTURE_CUBE_MAP_SEAMLESS 0x884F
++#define GL_MAX_SERVER_WAIT_TIMEOUT 0x9111
++#define GL_OBJECT_TYPE 0x9112
++#define GL_SYNC_CONDITION 0x9113
++#define GL_SYNC_STATUS 0x9114
++#define GL_SYNC_FLAGS 0x9115
++#define GL_SYNC_FENCE 0x9116
++#define GL_SYNC_GPU_COMMANDS_COMPLETE 0x9117
++#define GL_UNSIGNALED 0x9118
++#define GL_SIGNALED 0x9119
++#define GL_ALREADY_SIGNALED 0x911A
++#define GL_TIMEOUT_EXPIRED 0x911B
++#define GL_CONDITION_SATISFIED 0x911C
++#define GL_WAIT_FAILED 0x911D
++#define GL_TIMEOUT_IGNORED 0xFFFFFFFFFFFFFFFF
++#define GL_SYNC_FLUSH_COMMANDS_BIT 0x00000001
++#define GL_SAMPLE_POSITION 0x8E50
++#define GL_SAMPLE_MASK 0x8E51
++#define GL_SAMPLE_MASK_VALUE 0x8E52
++#define GL_MAX_SAMPLE_MASK_WORDS 0x8E59
++#define GL_TEXTURE_2D_MULTISAMPLE 0x9100
++#define GL_PROXY_TEXTURE_2D_MULTISAMPLE 0x9101
++#define GL_TEXTURE_2D_MULTISAMPLE_ARRAY 0x9102
++#define GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY 0x9103
++#define GL_TEXTURE_BINDING_2D_MULTISAMPLE 0x9104
++#define GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY 0x9105
++#define GL_TEXTURE_SAMPLES 0x9106
++#define GL_TEXTURE_FIXED_SAMPLE_LOCATIONS 0x9107
++#define GL_SAMPLER_2D_MULTISAMPLE 0x9108
++#define GL_INT_SAMPLER_2D_MULTISAMPLE 0x9109
++#define GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE 0x910A
++#define GL_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910B
++#define GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910C
++#define GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910D
++#define GL_MAX_COLOR_TEXTURE_SAMPLES 0x910E
++#define GL_MAX_DEPTH_TEXTURE_SAMPLES 0x910F
++#define GL_MAX_INTEGER_SAMPLES 0x9110
++#define GL_VERTEX_ATTRIB_ARRAY_DIVISOR 0x88FE
++#define GL_SRC1_COLOR 0x88F9
++#define GL_ONE_MINUS_SRC1_COLOR 0x88FA
++#define GL_ONE_MINUS_SRC1_ALPHA 0x88FB
++#define GL_MAX_DUAL_SOURCE_DRAW_BUFFERS 0x88FC
++#define GL_ANY_SAMPLES_PASSED 0x8C2F
++#define GL_SAMPLER_BINDING 0x8919
++#define GL_RGB10_A2UI 0x906F
++#define GL_TEXTURE_SWIZZLE_R 0x8E42
++#define GL_TEXTURE_SWIZZLE_G 0x8E43
++#define GL_TEXTURE_SWIZZLE_B 0x8E44
++#define GL_TEXTURE_SWIZZLE_A 0x8E45
++#define GL_TEXTURE_SWIZZLE_RGBA 0x8E46
++#define GL_TIME_ELAPSED 0x88BF
++#define GL_TIMESTAMP 0x8E28
++#define GL_INT_2_10_10_10_REV 0x8D9F
++#ifndef GL_VERSION_1_0
++#define GL_VERSION_1_0 1
++GLAPI int GLAD_GL_VERSION_1_0;
++typedef void (APIENTRYP PFNGLCULLFACEPROC)(GLenum mode);
++GLAPI PFNGLCULLFACEPROC glad_glCullFace;
++#define glCullFace glad_glCullFace
++typedef void (APIENTRYP PFNGLFRONTFACEPROC)(GLenum mode);
++GLAPI PFNGLFRONTFACEPROC glad_glFrontFace;
++#define glFrontFace glad_glFrontFace
++typedef void (APIENTRYP PFNGLHINTPROC)(GLenum target, GLenum mode);
++GLAPI PFNGLHINTPROC glad_glHint;
++#define glHint glad_glHint
++typedef void (APIENTRYP PFNGLLINEWIDTHPROC)(GLfloat width);
++GLAPI PFNGLLINEWIDTHPROC glad_glLineWidth;
++#define glLineWidth glad_glLineWidth
++typedef void (APIENTRYP PFNGLPOINTSIZEPROC)(GLfloat size);
++GLAPI PFNGLPOINTSIZEPROC glad_glPointSize;
++#define glPointSize glad_glPointSize
++typedef void (APIENTRYP PFNGLPOLYGONMODEPROC)(GLenum face, GLenum mode);
++GLAPI PFNGLPOLYGONMODEPROC glad_glPolygonMode;
++#define glPolygonMode glad_glPolygonMode
++typedef void (APIENTRYP PFNGLSCISSORPROC)(GLint x, GLint y, GLsizei width, GLsizei height);
++GLAPI PFNGLSCISSORPROC glad_glScissor;
++#define glScissor glad_glScissor
++typedef void (APIENTRYP PFNGLTEXPARAMETERFPROC)(GLenum target, GLenum pname, GLfloat param);
++GLAPI PFNGLTEXPARAMETERFPROC glad_glTexParameterf;
++#define glTexParameterf glad_glTexParameterf
++typedef void (APIENTRYP PFNGLTEXPARAMETERFVPROC)(GLenum target, GLenum pname, const GLfloat *params);
++GLAPI PFNGLTEXPARAMETERFVPROC glad_glTexParameterfv;
++#define glTexParameterfv glad_glTexParameterfv
++typedef void (APIENTRYP PFNGLTEXPARAMETERIPROC)(GLenum target, GLenum pname, GLint param);
++GLAPI PFNGLTEXPARAMETERIPROC glad_glTexParameteri;
++#define glTexParameteri glad_glTexParameteri
++typedef void (APIENTRYP PFNGLTEXPARAMETERIVPROC)(GLenum target, GLenum pname, const GLint *params);
++GLAPI PFNGLTEXPARAMETERIVPROC glad_glTexParameteriv;
++#define glTexParameteriv glad_glTexParameteriv
++typedef void (APIENTRYP PFNGLTEXIMAGE1DPROC)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format,
++ GLenum type, const void *pixels);
++GLAPI PFNGLTEXIMAGE1DPROC glad_glTexImage1D;
++#define glTexImage1D glad_glTexImage1D
++typedef void (APIENTRYP PFNGLTEXIMAGE2DPROC)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border,
++ GLenum format, GLenum type, const void *pixels);
++GLAPI PFNGLTEXIMAGE2DPROC glad_glTexImage2D;
++#define glTexImage2D glad_glTexImage2D
++typedef void (APIENTRYP PFNGLDRAWBUFFERPROC)(GLenum buf);
++GLAPI PFNGLDRAWBUFFERPROC glad_glDrawBuffer;
++#define glDrawBuffer glad_glDrawBuffer
++typedef void (APIENTRYP PFNGLCLEARPROC)(GLbitfield mask);
++GLAPI PFNGLCLEARPROC glad_glClear;
++#define glClear glad_glClear
++typedef void (APIENTRYP PFNGLCLEARCOLORPROC)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
++GLAPI PFNGLCLEARCOLORPROC glad_glClearColor;
++#define glClearColor glad_glClearColor
++typedef void (APIENTRYP PFNGLCLEARSTENCILPROC)(GLint s);
++GLAPI PFNGLCLEARSTENCILPROC glad_glClearStencil;
++#define glClearStencil glad_glClearStencil
++typedef void (APIENTRYP PFNGLCLEARDEPTHPROC)(GLdouble depth);
++GLAPI PFNGLCLEARDEPTHPROC glad_glClearDepth;
++#define glClearDepth glad_glClearDepth
++typedef void (APIENTRYP PFNGLSTENCILMASKPROC)(GLuint mask);
++GLAPI PFNGLSTENCILMASKPROC glad_glStencilMask;
++#define glStencilMask glad_glStencilMask
++typedef void (APIENTRYP PFNGLCOLORMASKPROC)(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
++GLAPI PFNGLCOLORMASKPROC glad_glColorMask;
++#define glColorMask glad_glColorMask
++typedef void (APIENTRYP PFNGLDEPTHMASKPROC)(GLboolean flag);
++GLAPI PFNGLDEPTHMASKPROC glad_glDepthMask;
++#define glDepthMask glad_glDepthMask
++typedef void (APIENTRYP PFNGLDISABLEPROC)(GLenum cap);
++GLAPI PFNGLDISABLEPROC glad_glDisable;
++#define glDisable glad_glDisable
++typedef void (APIENTRYP PFNGLENABLEPROC)(GLenum cap);
++GLAPI PFNGLENABLEPROC glad_glEnable;
++#define glEnable glad_glEnable
++typedef void (APIENTRYP PFNGLFINISHPROC)();
++GLAPI PFNGLFINISHPROC glad_glFinish;
++#define glFinish glad_glFinish
++typedef void (APIENTRYP PFNGLFLUSHPROC)();
++GLAPI PFNGLFLUSHPROC glad_glFlush;
++#define glFlush glad_glFlush
++typedef void (APIENTRYP PFNGLBLENDFUNCPROC)(GLenum sfactor, GLenum dfactor);
++GLAPI PFNGLBLENDFUNCPROC glad_glBlendFunc;
++#define glBlendFunc glad_glBlendFunc
++typedef void (APIENTRYP PFNGLLOGICOPPROC)(GLenum opcode);
++GLAPI PFNGLLOGICOPPROC glad_glLogicOp;
++#define glLogicOp glad_glLogicOp
++typedef void (APIENTRYP PFNGLSTENCILFUNCPROC)(GLenum func, GLint ref, GLuint mask);
++GLAPI PFNGLSTENCILFUNCPROC glad_glStencilFunc;
++#define glStencilFunc glad_glStencilFunc
++typedef void (APIENTRYP PFNGLSTENCILOPPROC)(GLenum fail, GLenum zfail, GLenum zpass);
++GLAPI PFNGLSTENCILOPPROC glad_glStencilOp;
++#define glStencilOp glad_glStencilOp
++typedef void (APIENTRYP PFNGLDEPTHFUNCPROC)(GLenum func);
++GLAPI PFNGLDEPTHFUNCPROC glad_glDepthFunc;
++#define glDepthFunc glad_glDepthFunc
++typedef void (APIENTRYP PFNGLPIXELSTOREFPROC)(GLenum pname, GLfloat param);
++GLAPI PFNGLPIXELSTOREFPROC glad_glPixelStoref;
++#define glPixelStoref glad_glPixelStoref
++typedef void (APIENTRYP PFNGLPIXELSTOREIPROC)(GLenum pname, GLint param);
++GLAPI PFNGLPIXELSTOREIPROC glad_glPixelStorei;
++#define glPixelStorei glad_glPixelStorei
++typedef void (APIENTRYP PFNGLREADBUFFERPROC)(GLenum src);
++GLAPI PFNGLREADBUFFERPROC glad_glReadBuffer;
++#define glReadBuffer glad_glReadBuffer
++typedef void (APIENTRYP PFNGLREADPIXELSPROC)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *pixels);
++GLAPI PFNGLREADPIXELSPROC glad_glReadPixels;
++#define glReadPixels glad_glReadPixels
++typedef void (APIENTRYP PFNGLGETBOOLEANVPROC)(GLenum pname, GLboolean *data);
++GLAPI PFNGLGETBOOLEANVPROC glad_glGetBooleanv;
++#define glGetBooleanv glad_glGetBooleanv
++typedef void (APIENTRYP PFNGLGETDOUBLEVPROC)(GLenum pname, GLdouble *data);
++GLAPI PFNGLGETDOUBLEVPROC glad_glGetDoublev;
++#define glGetDoublev glad_glGetDoublev
++typedef GLenum(APIENTRYP PFNGLGETERRORPROC)();
++GLAPI PFNGLGETERRORPROC glad_glGetError;
++#define glGetError glad_glGetError
++typedef void (APIENTRYP PFNGLGETFLOATVPROC)(GLenum pname, GLfloat *data);
++GLAPI PFNGLGETFLOATVPROC glad_glGetFloatv;
++#define glGetFloatv glad_glGetFloatv
++typedef void (APIENTRYP PFNGLGETINTEGERVPROC)(GLenum pname, GLint *data);
++GLAPI PFNGLGETINTEGERVPROC glad_glGetIntegerv;
++#define glGetIntegerv glad_glGetIntegerv
++typedef const GLubyte *(APIENTRYP PFNGLGETSTRINGPROC)(GLenum name);
++GLAPI PFNGLGETSTRINGPROC glad_glGetString;
++#define glGetString glad_glGetString
++typedef void (APIENTRYP PFNGLGETTEXIMAGEPROC)(GLenum target, GLint level, GLenum format, GLenum type, void *pixels);
++GLAPI PFNGLGETTEXIMAGEPROC glad_glGetTexImage;
++#define glGetTexImage glad_glGetTexImage
++typedef void (APIENTRYP PFNGLGETTEXPARAMETERFVPROC)(GLenum target, GLenum pname, GLfloat *params);
++GLAPI PFNGLGETTEXPARAMETERFVPROC glad_glGetTexParameterfv;
++#define glGetTexParameterfv glad_glGetTexParameterfv
++typedef void (APIENTRYP PFNGLGETTEXPARAMETERIVPROC)(GLenum target, GLenum pname, GLint *params);
++GLAPI PFNGLGETTEXPARAMETERIVPROC glad_glGetTexParameteriv;
++#define glGetTexParameteriv glad_glGetTexParameteriv
++typedef void (APIENTRYP PFNGLGETTEXLEVELPARAMETERFVPROC)(GLenum target, GLint level, GLenum pname, GLfloat *params);
++GLAPI PFNGLGETTEXLEVELPARAMETERFVPROC glad_glGetTexLevelParameterfv;
++#define glGetTexLevelParameterfv glad_glGetTexLevelParameterfv
++typedef void (APIENTRYP PFNGLGETTEXLEVELPARAMETERIVPROC)(GLenum target, GLint level, GLenum pname, GLint *params);
++GLAPI PFNGLGETTEXLEVELPARAMETERIVPROC glad_glGetTexLevelParameteriv;
++#define glGetTexLevelParameteriv glad_glGetTexLevelParameteriv
++typedef GLboolean(APIENTRYP PFNGLISENABLEDPROC)(GLenum cap);
++GLAPI PFNGLISENABLEDPROC glad_glIsEnabled;
++#define glIsEnabled glad_glIsEnabled
++typedef void (APIENTRYP PFNGLDEPTHRANGEPROC)(GLdouble near, GLdouble far);
++GLAPI PFNGLDEPTHRANGEPROC glad_glDepthRange;
++#define glDepthRange glad_glDepthRange
++typedef void (APIENTRYP PFNGLVIEWPORTPROC)(GLint x, GLint y, GLsizei width, GLsizei height);
++GLAPI PFNGLVIEWPORTPROC glad_glViewport;
++#define glViewport glad_glViewport
++typedef void (APIENTRYP PFNGLNEWLISTPROC)(GLuint list, GLenum mode);
++GLAPI PFNGLNEWLISTPROC glad_glNewList;
++#define glNewList glad_glNewList
++typedef void (APIENTRYP PFNGLENDLISTPROC)();
++GLAPI PFNGLENDLISTPROC glad_glEndList;
++#define glEndList glad_glEndList
++typedef void (APIENTRYP PFNGLCALLLISTPROC)(GLuint list);
++GLAPI PFNGLCALLLISTPROC glad_glCallList;
++#define glCallList glad_glCallList
++typedef void (APIENTRYP PFNGLCALLLISTSPROC)(GLsizei n, GLenum type, const void *lists);
++GLAPI PFNGLCALLLISTSPROC glad_glCallLists;
++#define glCallLists glad_glCallLists
++typedef void (APIENTRYP PFNGLDELETELISTSPROC)(GLuint list, GLsizei range);
++GLAPI PFNGLDELETELISTSPROC glad_glDeleteLists;
++#define glDeleteLists glad_glDeleteLists
++typedef GLuint(APIENTRYP PFNGLGENLISTSPROC)(GLsizei range);
++GLAPI PFNGLGENLISTSPROC glad_glGenLists;
++#define glGenLists glad_glGenLists
++typedef void (APIENTRYP PFNGLLISTBASEPROC)(GLuint base);
++GLAPI PFNGLLISTBASEPROC glad_glListBase;
++#define glListBase glad_glListBase
++typedef void (APIENTRYP PFNGLBEGINPROC)(GLenum mode);
++GLAPI PFNGLBEGINPROC glad_glBegin;
++#define glBegin glad_glBegin
++typedef void (APIENTRYP PFNGLBITMAPPROC)(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove,
++ const GLubyte *bitmap);
++GLAPI PFNGLBITMAPPROC glad_glBitmap;
++#define glBitmap glad_glBitmap
++typedef void (APIENTRYP PFNGLCOLOR3BPROC)(GLbyte red, GLbyte green, GLbyte blue);
++GLAPI PFNGLCOLOR3BPROC glad_glColor3b;
++#define glColor3b glad_glColor3b
++typedef void (APIENTRYP PFNGLCOLOR3BVPROC)(const GLbyte *v);
++GLAPI PFNGLCOLOR3BVPROC glad_glColor3bv;
++#define glColor3bv glad_glColor3bv
++typedef void (APIENTRYP PFNGLCOLOR3DPROC)(GLdouble red, GLdouble green, GLdouble blue);
++GLAPI PFNGLCOLOR3DPROC glad_glColor3d;
++#define glColor3d glad_glColor3d
++typedef void (APIENTRYP PFNGLCOLOR3DVPROC)(const GLdouble *v);
++GLAPI PFNGLCOLOR3DVPROC glad_glColor3dv;
++#define glColor3dv glad_glColor3dv
++typedef void (APIENTRYP PFNGLCOLOR3FPROC)(GLfloat red, GLfloat green, GLfloat blue);
++GLAPI PFNGLCOLOR3FPROC glad_glColor3f;
++#define glColor3f glad_glColor3f
++typedef void (APIENTRYP PFNGLCOLOR3FVPROC)(const GLfloat *v);
++GLAPI PFNGLCOLOR3FVPROC glad_glColor3fv;
++#define glColor3fv glad_glColor3fv
++typedef void (APIENTRYP PFNGLCOLOR3IPROC)(GLint red, GLint green, GLint blue);
++GLAPI PFNGLCOLOR3IPROC glad_glColor3i;
++#define glColor3i glad_glColor3i
++typedef void (APIENTRYP PFNGLCOLOR3IVPROC)(const GLint *v);
++GLAPI PFNGLCOLOR3IVPROC glad_glColor3iv;
++#define glColor3iv glad_glColor3iv
++typedef void (APIENTRYP PFNGLCOLOR3SPROC)(GLshort red, GLshort green, GLshort blue);
++GLAPI PFNGLCOLOR3SPROC glad_glColor3s;
++#define glColor3s glad_glColor3s
++typedef void (APIENTRYP PFNGLCOLOR3SVPROC)(const GLshort *v);
++GLAPI PFNGLCOLOR3SVPROC glad_glColor3sv;
++#define glColor3sv glad_glColor3sv
++typedef void (APIENTRYP PFNGLCOLOR3UBPROC)(GLubyte red, GLubyte green, GLubyte blue);
++GLAPI PFNGLCOLOR3UBPROC glad_glColor3ub;
++#define glColor3ub glad_glColor3ub
++typedef void (APIENTRYP PFNGLCOLOR3UBVPROC)(const GLubyte *v);
++GLAPI PFNGLCOLOR3UBVPROC glad_glColor3ubv;
++#define glColor3ubv glad_glColor3ubv
++typedef void (APIENTRYP PFNGLCOLOR3UIPROC)(GLuint red, GLuint green, GLuint blue);
++GLAPI PFNGLCOLOR3UIPROC glad_glColor3ui;
++#define glColor3ui glad_glColor3ui
++typedef void (APIENTRYP PFNGLCOLOR3UIVPROC)(const GLuint *v);
++GLAPI PFNGLCOLOR3UIVPROC glad_glColor3uiv;
++#define glColor3uiv glad_glColor3uiv
++typedef void (APIENTRYP PFNGLCOLOR3USPROC)(GLushort red, GLushort green, GLushort blue);
++GLAPI PFNGLCOLOR3USPROC glad_glColor3us;
++#define glColor3us glad_glColor3us
++typedef void (APIENTRYP PFNGLCOLOR3USVPROC)(const GLushort *v);
++GLAPI PFNGLCOLOR3USVPROC glad_glColor3usv;
++#define glColor3usv glad_glColor3usv
++typedef void (APIENTRYP PFNGLCOLOR4BPROC)(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha);
++GLAPI PFNGLCOLOR4BPROC glad_glColor4b;
++#define glColor4b glad_glColor4b
++typedef void (APIENTRYP PFNGLCOLOR4BVPROC)(const GLbyte *v);
++GLAPI PFNGLCOLOR4BVPROC glad_glColor4bv;
++#define glColor4bv glad_glColor4bv
++typedef void (APIENTRYP PFNGLCOLOR4DPROC)(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha);
++GLAPI PFNGLCOLOR4DPROC glad_glColor4d;
++#define glColor4d glad_glColor4d
++typedef void (APIENTRYP PFNGLCOLOR4DVPROC)(const GLdouble *v);
++GLAPI PFNGLCOLOR4DVPROC glad_glColor4dv;
++#define glColor4dv glad_glColor4dv
++typedef void (APIENTRYP PFNGLCOLOR4FPROC)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
++GLAPI PFNGLCOLOR4FPROC glad_glColor4f;
++#define glColor4f glad_glColor4f
++typedef void (APIENTRYP PFNGLCOLOR4FVPROC)(const GLfloat *v);
++GLAPI PFNGLCOLOR4FVPROC glad_glColor4fv;
++#define glColor4fv glad_glColor4fv
++typedef void (APIENTRYP PFNGLCOLOR4IPROC)(GLint red, GLint green, GLint blue, GLint alpha);
++GLAPI PFNGLCOLOR4IPROC glad_glColor4i;
++#define glColor4i glad_glColor4i
++typedef void (APIENTRYP PFNGLCOLOR4IVPROC)(const GLint *v);
++GLAPI PFNGLCOLOR4IVPROC glad_glColor4iv;
++#define glColor4iv glad_glColor4iv
++typedef void (APIENTRYP PFNGLCOLOR4SPROC)(GLshort red, GLshort green, GLshort blue, GLshort alpha);
++GLAPI PFNGLCOLOR4SPROC glad_glColor4s;
++#define glColor4s glad_glColor4s
++typedef void (APIENTRYP PFNGLCOLOR4SVPROC)(const GLshort *v);
++GLAPI PFNGLCOLOR4SVPROC glad_glColor4sv;
++#define glColor4sv glad_glColor4sv
++typedef void (APIENTRYP PFNGLCOLOR4UBPROC)(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha);
++GLAPI PFNGLCOLOR4UBPROC glad_glColor4ub;
++#define glColor4ub glad_glColor4ub
++typedef void (APIENTRYP PFNGLCOLOR4UBVPROC)(const GLubyte *v);
++GLAPI PFNGLCOLOR4UBVPROC glad_glColor4ubv;
++#define glColor4ubv glad_glColor4ubv
++typedef void (APIENTRYP PFNGLCOLOR4UIPROC)(GLuint red, GLuint green, GLuint blue, GLuint alpha);
++GLAPI PFNGLCOLOR4UIPROC glad_glColor4ui;
++#define glColor4ui glad_glColor4ui
++typedef void (APIENTRYP PFNGLCOLOR4UIVPROC)(const GLuint *v);
++GLAPI PFNGLCOLOR4UIVPROC glad_glColor4uiv;
++#define glColor4uiv glad_glColor4uiv
++typedef void (APIENTRYP PFNGLCOLOR4USPROC)(GLushort red, GLushort green, GLushort blue, GLushort alpha);
++GLAPI PFNGLCOLOR4USPROC glad_glColor4us;
++#define glColor4us glad_glColor4us
++typedef void (APIENTRYP PFNGLCOLOR4USVPROC)(const GLushort *v);
++GLAPI PFNGLCOLOR4USVPROC glad_glColor4usv;
++#define glColor4usv glad_glColor4usv
++typedef void (APIENTRYP PFNGLEDGEFLAGPROC)(GLboolean flag);
++GLAPI PFNGLEDGEFLAGPROC glad_glEdgeFlag;
++#define glEdgeFlag glad_glEdgeFlag
++typedef void (APIENTRYP PFNGLEDGEFLAGVPROC)(const GLboolean *flag);
++GLAPI PFNGLEDGEFLAGVPROC glad_glEdgeFlagv;
++#define glEdgeFlagv glad_glEdgeFlagv
++typedef void (APIENTRYP PFNGLENDPROC)();
++GLAPI PFNGLENDPROC glad_glEnd;
++#define glEnd glad_glEnd
++typedef void (APIENTRYP PFNGLINDEXDPROC)(GLdouble c);
++GLAPI PFNGLINDEXDPROC glad_glIndexd;
++#define glIndexd glad_glIndexd
++typedef void (APIENTRYP PFNGLINDEXDVPROC)(const GLdouble *c);
++GLAPI PFNGLINDEXDVPROC glad_glIndexdv;
++#define glIndexdv glad_glIndexdv
++typedef void (APIENTRYP PFNGLINDEXFPROC)(GLfloat c);
++GLAPI PFNGLINDEXFPROC glad_glIndexf;
++#define glIndexf glad_glIndexf
++typedef void (APIENTRYP PFNGLINDEXFVPROC)(const GLfloat *c);
++GLAPI PFNGLINDEXFVPROC glad_glIndexfv;
++#define glIndexfv glad_glIndexfv
++typedef void (APIENTRYP PFNGLINDEXIPROC)(GLint c);
++GLAPI PFNGLINDEXIPROC glad_glIndexi;
++#define glIndexi glad_glIndexi
++typedef void (APIENTRYP PFNGLINDEXIVPROC)(const GLint *c);
++GLAPI PFNGLINDEXIVPROC glad_glIndexiv;
++#define glIndexiv glad_glIndexiv
++typedef void (APIENTRYP PFNGLINDEXSPROC)(GLshort c);
++GLAPI PFNGLINDEXSPROC glad_glIndexs;
++#define glIndexs glad_glIndexs
++typedef void (APIENTRYP PFNGLINDEXSVPROC)(const GLshort *c);
++GLAPI PFNGLINDEXSVPROC glad_glIndexsv;
++#define glIndexsv glad_glIndexsv
++typedef void (APIENTRYP PFNGLNORMAL3BPROC)(GLbyte nx, GLbyte ny, GLbyte nz);
++GLAPI PFNGLNORMAL3BPROC glad_glNormal3b;
++#define glNormal3b glad_glNormal3b
++typedef void (APIENTRYP PFNGLNORMAL3BVPROC)(const GLbyte *v);
++GLAPI PFNGLNORMAL3BVPROC glad_glNormal3bv;
++#define glNormal3bv glad_glNormal3bv
++typedef void (APIENTRYP PFNGLNORMAL3DPROC)(GLdouble nx, GLdouble ny, GLdouble nz);
++GLAPI PFNGLNORMAL3DPROC glad_glNormal3d;
++#define glNormal3d glad_glNormal3d
++typedef void (APIENTRYP PFNGLNORMAL3DVPROC)(const GLdouble *v);
++GLAPI PFNGLNORMAL3DVPROC glad_glNormal3dv;
++#define glNormal3dv glad_glNormal3dv
++typedef void (APIENTRYP PFNGLNORMAL3FPROC)(GLfloat nx, GLfloat ny, GLfloat nz);
++GLAPI PFNGLNORMAL3FPROC glad_glNormal3f;
++#define glNormal3f glad_glNormal3f
++typedef void (APIENTRYP PFNGLNORMAL3FVPROC)(const GLfloat *v);
++GLAPI PFNGLNORMAL3FVPROC glad_glNormal3fv;
++#define glNormal3fv glad_glNormal3fv
++typedef void (APIENTRYP PFNGLNORMAL3IPROC)(GLint nx, GLint ny, GLint nz);
++GLAPI PFNGLNORMAL3IPROC glad_glNormal3i;
++#define glNormal3i glad_glNormal3i
++typedef void (APIENTRYP PFNGLNORMAL3IVPROC)(const GLint *v);
++GLAPI PFNGLNORMAL3IVPROC glad_glNormal3iv;
++#define glNormal3iv glad_glNormal3iv
++typedef void (APIENTRYP PFNGLNORMAL3SPROC)(GLshort nx, GLshort ny, GLshort nz);
++GLAPI PFNGLNORMAL3SPROC glad_glNormal3s;
++#define glNormal3s glad_glNormal3s
++typedef void (APIENTRYP PFNGLNORMAL3SVPROC)(const GLshort *v);
++GLAPI PFNGLNORMAL3SVPROC glad_glNormal3sv;
++#define glNormal3sv glad_glNormal3sv
++typedef void (APIENTRYP PFNGLRASTERPOS2DPROC)(GLdouble x, GLdouble y);
++GLAPI PFNGLRASTERPOS2DPROC glad_glRasterPos2d;
++#define glRasterPos2d glad_glRasterPos2d
++typedef void (APIENTRYP PFNGLRASTERPOS2DVPROC)(const GLdouble *v);
++GLAPI PFNGLRASTERPOS2DVPROC glad_glRasterPos2dv;
++#define glRasterPos2dv glad_glRasterPos2dv
++typedef void (APIENTRYP PFNGLRASTERPOS2FPROC)(GLfloat x, GLfloat y);
++GLAPI PFNGLRASTERPOS2FPROC glad_glRasterPos2f;
++#define glRasterPos2f glad_glRasterPos2f
++typedef void (APIENTRYP PFNGLRASTERPOS2FVPROC)(const GLfloat *v);
++GLAPI PFNGLRASTERPOS2FVPROC glad_glRasterPos2fv;
++#define glRasterPos2fv glad_glRasterPos2fv
++typedef void (APIENTRYP PFNGLRASTERPOS2IPROC)(GLint x, GLint y);
++GLAPI PFNGLRASTERPOS2IPROC glad_glRasterPos2i;
++#define glRasterPos2i glad_glRasterPos2i
++typedef void (APIENTRYP PFNGLRASTERPOS2IVPROC)(const GLint *v);
++GLAPI PFNGLRASTERPOS2IVPROC glad_glRasterPos2iv;
++#define glRasterPos2iv glad_glRasterPos2iv
++typedef void (APIENTRYP PFNGLRASTERPOS2SPROC)(GLshort x, GLshort y);
++GLAPI PFNGLRASTERPOS2SPROC glad_glRasterPos2s;
++#define glRasterPos2s glad_glRasterPos2s
++typedef void (APIENTRYP PFNGLRASTERPOS2SVPROC)(const GLshort *v);
++GLAPI PFNGLRASTERPOS2SVPROC glad_glRasterPos2sv;
++#define glRasterPos2sv glad_glRasterPos2sv
++typedef void (APIENTRYP PFNGLRASTERPOS3DPROC)(GLdouble x, GLdouble y, GLdouble z);
++GLAPI PFNGLRASTERPOS3DPROC glad_glRasterPos3d;
++#define glRasterPos3d glad_glRasterPos3d
++typedef void (APIENTRYP PFNGLRASTERPOS3DVPROC)(const GLdouble *v);
++GLAPI PFNGLRASTERPOS3DVPROC glad_glRasterPos3dv;
++#define glRasterPos3dv glad_glRasterPos3dv
++typedef void (APIENTRYP PFNGLRASTERPOS3FPROC)(GLfloat x, GLfloat y, GLfloat z);
++GLAPI PFNGLRASTERPOS3FPROC glad_glRasterPos3f;
++#define glRasterPos3f glad_glRasterPos3f
++typedef void (APIENTRYP PFNGLRASTERPOS3FVPROC)(const GLfloat *v);
++GLAPI PFNGLRASTERPOS3FVPROC glad_glRasterPos3fv;
++#define glRasterPos3fv glad_glRasterPos3fv
++typedef void (APIENTRYP PFNGLRASTERPOS3IPROC)(GLint x, GLint y, GLint z);
++GLAPI PFNGLRASTERPOS3IPROC glad_glRasterPos3i;
++#define glRasterPos3i glad_glRasterPos3i
++typedef void (APIENTRYP PFNGLRASTERPOS3IVPROC)(const GLint *v);
++GLAPI PFNGLRASTERPOS3IVPROC glad_glRasterPos3iv;
++#define glRasterPos3iv glad_glRasterPos3iv
++typedef void (APIENTRYP PFNGLRASTERPOS3SPROC)(GLshort x, GLshort y, GLshort z);
++GLAPI PFNGLRASTERPOS3SPROC glad_glRasterPos3s;
++#define glRasterPos3s glad_glRasterPos3s
++typedef void (APIENTRYP PFNGLRASTERPOS3SVPROC)(const GLshort *v);
++GLAPI PFNGLRASTERPOS3SVPROC glad_glRasterPos3sv;
++#define glRasterPos3sv glad_glRasterPos3sv
++typedef void (APIENTRYP PFNGLRASTERPOS4DPROC)(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
++GLAPI PFNGLRASTERPOS4DPROC glad_glRasterPos4d;
++#define glRasterPos4d glad_glRasterPos4d
++typedef void (APIENTRYP PFNGLRASTERPOS4DVPROC)(const GLdouble *v);
++GLAPI PFNGLRASTERPOS4DVPROC glad_glRasterPos4dv;
++#define glRasterPos4dv glad_glRasterPos4dv
++typedef void (APIENTRYP PFNGLRASTERPOS4FPROC)(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
++GLAPI PFNGLRASTERPOS4FPROC glad_glRasterPos4f;
++#define glRasterPos4f glad_glRasterPos4f
++typedef void (APIENTRYP PFNGLRASTERPOS4FVPROC)(const GLfloat *v);
++GLAPI PFNGLRASTERPOS4FVPROC glad_glRasterPos4fv;
++#define glRasterPos4fv glad_glRasterPos4fv
++typedef void (APIENTRYP PFNGLRASTERPOS4IPROC)(GLint x, GLint y, GLint z, GLint w);
++GLAPI PFNGLRASTERPOS4IPROC glad_glRasterPos4i;
++#define glRasterPos4i glad_glRasterPos4i
++typedef void (APIENTRYP PFNGLRASTERPOS4IVPROC)(const GLint *v);
++GLAPI PFNGLRASTERPOS4IVPROC glad_glRasterPos4iv;
++#define glRasterPos4iv glad_glRasterPos4iv
++typedef void (APIENTRYP PFNGLRASTERPOS4SPROC)(GLshort x, GLshort y, GLshort z, GLshort w);
++GLAPI PFNGLRASTERPOS4SPROC glad_glRasterPos4s;
++#define glRasterPos4s glad_glRasterPos4s
++typedef void (APIENTRYP PFNGLRASTERPOS4SVPROC)(const GLshort *v);
++GLAPI PFNGLRASTERPOS4SVPROC glad_glRasterPos4sv;
++#define glRasterPos4sv glad_glRasterPos4sv
++typedef void (APIENTRYP PFNGLRECTDPROC)(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2);
++GLAPI PFNGLRECTDPROC glad_glRectd;
++#define glRectd glad_glRectd
++typedef void (APIENTRYP PFNGLRECTDVPROC)(const GLdouble *v1, const GLdouble *v2);
++GLAPI PFNGLRECTDVPROC glad_glRectdv;
++#define glRectdv glad_glRectdv
++typedef void (APIENTRYP PFNGLRECTFPROC)(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2);
++GLAPI PFNGLRECTFPROC glad_glRectf;
++#define glRectf glad_glRectf
++typedef void (APIENTRYP PFNGLRECTFVPROC)(const GLfloat *v1, const GLfloat *v2);
++GLAPI PFNGLRECTFVPROC glad_glRectfv;
++#define glRectfv glad_glRectfv
++typedef void (APIENTRYP PFNGLRECTIPROC)(GLint x1, GLint y1, GLint x2, GLint y2);
++GLAPI PFNGLRECTIPROC glad_glRecti;
++#define glRecti glad_glRecti
++typedef void (APIENTRYP PFNGLRECTIVPROC)(const GLint *v1, const GLint *v2);
++GLAPI PFNGLRECTIVPROC glad_glRectiv;
++#define glRectiv glad_glRectiv
++typedef void (APIENTRYP PFNGLRECTSPROC)(GLshort x1, GLshort y1, GLshort x2, GLshort y2);
++GLAPI PFNGLRECTSPROC glad_glRects;
++#define glRects glad_glRects
++typedef void (APIENTRYP PFNGLRECTSVPROC)(const GLshort *v1, const GLshort *v2);
++GLAPI PFNGLRECTSVPROC glad_glRectsv;
++#define glRectsv glad_glRectsv
++typedef void (APIENTRYP PFNGLTEXCOORD1DPROC)(GLdouble s);
++GLAPI PFNGLTEXCOORD1DPROC glad_glTexCoord1d;
++#define glTexCoord1d glad_glTexCoord1d
++typedef void (APIENTRYP PFNGLTEXCOORD1DVPROC)(const GLdouble *v);
++GLAPI PFNGLTEXCOORD1DVPROC glad_glTexCoord1dv;
++#define glTexCoord1dv glad_glTexCoord1dv
++typedef void (APIENTRYP PFNGLTEXCOORD1FPROC)(GLfloat s);
++GLAPI PFNGLTEXCOORD1FPROC glad_glTexCoord1f;
++#define glTexCoord1f glad_glTexCoord1f
++typedef void (APIENTRYP PFNGLTEXCOORD1FVPROC)(const GLfloat *v);
++GLAPI PFNGLTEXCOORD1FVPROC glad_glTexCoord1fv;
++#define glTexCoord1fv glad_glTexCoord1fv
++typedef void (APIENTRYP PFNGLTEXCOORD1IPROC)(GLint s);
++GLAPI PFNGLTEXCOORD1IPROC glad_glTexCoord1i;
++#define glTexCoord1i glad_glTexCoord1i
++typedef void (APIENTRYP PFNGLTEXCOORD1IVPROC)(const GLint *v);
++GLAPI PFNGLTEXCOORD1IVPROC glad_glTexCoord1iv;
++#define glTexCoord1iv glad_glTexCoord1iv
++typedef void (APIENTRYP PFNGLTEXCOORD1SPROC)(GLshort s);
++GLAPI PFNGLTEXCOORD1SPROC glad_glTexCoord1s;
++#define glTexCoord1s glad_glTexCoord1s
++typedef void (APIENTRYP PFNGLTEXCOORD1SVPROC)(const GLshort *v);
++GLAPI PFNGLTEXCOORD1SVPROC glad_glTexCoord1sv;
++#define glTexCoord1sv glad_glTexCoord1sv
++typedef void (APIENTRYP PFNGLTEXCOORD2DPROC)(GLdouble s, GLdouble t);
++GLAPI PFNGLTEXCOORD2DPROC glad_glTexCoord2d;
++#define glTexCoord2d glad_glTexCoord2d
++typedef void (APIENTRYP PFNGLTEXCOORD2DVPROC)(const GLdouble *v);
++GLAPI PFNGLTEXCOORD2DVPROC glad_glTexCoord2dv;
++#define glTexCoord2dv glad_glTexCoord2dv
++typedef void (APIENTRYP PFNGLTEXCOORD2FPROC)(GLfloat s, GLfloat t);
++GLAPI PFNGLTEXCOORD2FPROC glad_glTexCoord2f;
++#define glTexCoord2f glad_glTexCoord2f
++typedef void (APIENTRYP PFNGLTEXCOORD2FVPROC)(const GLfloat *v);
++GLAPI PFNGLTEXCOORD2FVPROC glad_glTexCoord2fv;
++#define glTexCoord2fv glad_glTexCoord2fv
++typedef void (APIENTRYP PFNGLTEXCOORD2IPROC)(GLint s, GLint t);
++GLAPI PFNGLTEXCOORD2IPROC glad_glTexCoord2i;
++#define glTexCoord2i glad_glTexCoord2i
++typedef void (APIENTRYP PFNGLTEXCOORD2IVPROC)(const GLint *v);
++GLAPI PFNGLTEXCOORD2IVPROC glad_glTexCoord2iv;
++#define glTexCoord2iv glad_glTexCoord2iv
++typedef void (APIENTRYP PFNGLTEXCOORD2SPROC)(GLshort s, GLshort t);
++GLAPI PFNGLTEXCOORD2SPROC glad_glTexCoord2s;
++#define glTexCoord2s glad_glTexCoord2s
++typedef void (APIENTRYP PFNGLTEXCOORD2SVPROC)(const GLshort *v);
++GLAPI PFNGLTEXCOORD2SVPROC glad_glTexCoord2sv;
++#define glTexCoord2sv glad_glTexCoord2sv
++typedef void (APIENTRYP PFNGLTEXCOORD3DPROC)(GLdouble s, GLdouble t, GLdouble r);
++GLAPI PFNGLTEXCOORD3DPROC glad_glTexCoord3d;
++#define glTexCoord3d glad_glTexCoord3d
++typedef void (APIENTRYP PFNGLTEXCOORD3DVPROC)(const GLdouble *v);
++GLAPI PFNGLTEXCOORD3DVPROC glad_glTexCoord3dv;
++#define glTexCoord3dv glad_glTexCoord3dv
++typedef void (APIENTRYP PFNGLTEXCOORD3FPROC)(GLfloat s, GLfloat t, GLfloat r);
++GLAPI PFNGLTEXCOORD3FPROC glad_glTexCoord3f;
++#define glTexCoord3f glad_glTexCoord3f
++typedef void (APIENTRYP PFNGLTEXCOORD3FVPROC)(const GLfloat *v);
++GLAPI PFNGLTEXCOORD3FVPROC glad_glTexCoord3fv;
++#define glTexCoord3fv glad_glTexCoord3fv
++typedef void (APIENTRYP PFNGLTEXCOORD3IPROC)(GLint s, GLint t, GLint r);
++GLAPI PFNGLTEXCOORD3IPROC glad_glTexCoord3i;
++#define glTexCoord3i glad_glTexCoord3i
++typedef void (APIENTRYP PFNGLTEXCOORD3IVPROC)(const GLint *v);
++GLAPI PFNGLTEXCOORD3IVPROC glad_glTexCoord3iv;
++#define glTexCoord3iv glad_glTexCoord3iv
++typedef void (APIENTRYP PFNGLTEXCOORD3SPROC)(GLshort s, GLshort t, GLshort r);
++GLAPI PFNGLTEXCOORD3SPROC glad_glTexCoord3s;
++#define glTexCoord3s glad_glTexCoord3s
++typedef void (APIENTRYP PFNGLTEXCOORD3SVPROC)(const GLshort *v);
++GLAPI PFNGLTEXCOORD3SVPROC glad_glTexCoord3sv;
++#define glTexCoord3sv glad_glTexCoord3sv
++typedef void (APIENTRYP PFNGLTEXCOORD4DPROC)(GLdouble s, GLdouble t, GLdouble r, GLdouble q);
++GLAPI PFNGLTEXCOORD4DPROC glad_glTexCoord4d;
++#define glTexCoord4d glad_glTexCoord4d
++typedef void (APIENTRYP PFNGLTEXCOORD4DVPROC)(const GLdouble *v);
++GLAPI PFNGLTEXCOORD4DVPROC glad_glTexCoord4dv;
++#define glTexCoord4dv glad_glTexCoord4dv
++typedef void (APIENTRYP PFNGLTEXCOORD4FPROC)(GLfloat s, GLfloat t, GLfloat r, GLfloat q);
++GLAPI PFNGLTEXCOORD4FPROC glad_glTexCoord4f;
++#define glTexCoord4f glad_glTexCoord4f
++typedef void (APIENTRYP PFNGLTEXCOORD4FVPROC)(const GLfloat *v);
++GLAPI PFNGLTEXCOORD4FVPROC glad_glTexCoord4fv;
++#define glTexCoord4fv glad_glTexCoord4fv
++typedef void (APIENTRYP PFNGLTEXCOORD4IPROC)(GLint s, GLint t, GLint r, GLint q);
++GLAPI PFNGLTEXCOORD4IPROC glad_glTexCoord4i;
++#define glTexCoord4i glad_glTexCoord4i
++typedef void (APIENTRYP PFNGLTEXCOORD4IVPROC)(const GLint *v);
++GLAPI PFNGLTEXCOORD4IVPROC glad_glTexCoord4iv;
++#define glTexCoord4iv glad_glTexCoord4iv
++typedef void (APIENTRYP PFNGLTEXCOORD4SPROC)(GLshort s, GLshort t, GLshort r, GLshort q);
++GLAPI PFNGLTEXCOORD4SPROC glad_glTexCoord4s;
++#define glTexCoord4s glad_glTexCoord4s
++typedef void (APIENTRYP PFNGLTEXCOORD4SVPROC)(const GLshort *v);
++GLAPI PFNGLTEXCOORD4SVPROC glad_glTexCoord4sv;
++#define glTexCoord4sv glad_glTexCoord4sv
++typedef void (APIENTRYP PFNGLVERTEX2DPROC)(GLdouble x, GLdouble y);
++GLAPI PFNGLVERTEX2DPROC glad_glVertex2d;
++#define glVertex2d glad_glVertex2d
++typedef void (APIENTRYP PFNGLVERTEX2DVPROC)(const GLdouble *v);
++GLAPI PFNGLVERTEX2DVPROC glad_glVertex2dv;
++#define glVertex2dv glad_glVertex2dv
++typedef void (APIENTRYP PFNGLVERTEX2FPROC)(GLfloat x, GLfloat y);
++GLAPI PFNGLVERTEX2FPROC glad_glVertex2f;
++#define glVertex2f glad_glVertex2f
++typedef void (APIENTRYP PFNGLVERTEX2FVPROC)(const GLfloat *v);
++GLAPI PFNGLVERTEX2FVPROC glad_glVertex2fv;
++#define glVertex2fv glad_glVertex2fv
++typedef void (APIENTRYP PFNGLVERTEX2IPROC)(GLint x, GLint y);
++GLAPI PFNGLVERTEX2IPROC glad_glVertex2i;
++#define glVertex2i glad_glVertex2i
++typedef void (APIENTRYP PFNGLVERTEX2IVPROC)(const GLint *v);
++GLAPI PFNGLVERTEX2IVPROC glad_glVertex2iv;
++#define glVertex2iv glad_glVertex2iv
++typedef void (APIENTRYP PFNGLVERTEX2SPROC)(GLshort x, GLshort y);
++GLAPI PFNGLVERTEX2SPROC glad_glVertex2s;
++#define glVertex2s glad_glVertex2s
++typedef void (APIENTRYP PFNGLVERTEX2SVPROC)(const GLshort *v);
++GLAPI PFNGLVERTEX2SVPROC glad_glVertex2sv;
++#define glVertex2sv glad_glVertex2sv
++typedef void (APIENTRYP PFNGLVERTEX3DPROC)(GLdouble x, GLdouble y, GLdouble z);
++GLAPI PFNGLVERTEX3DPROC glad_glVertex3d;
++#define glVertex3d glad_glVertex3d
++typedef void (APIENTRYP PFNGLVERTEX3DVPROC)(const GLdouble *v);
++GLAPI PFNGLVERTEX3DVPROC glad_glVertex3dv;
++#define glVertex3dv glad_glVertex3dv
++typedef void (APIENTRYP PFNGLVERTEX3FPROC)(GLfloat x, GLfloat y, GLfloat z);
++GLAPI PFNGLVERTEX3FPROC glad_glVertex3f;
++#define glVertex3f glad_glVertex3f
++typedef void (APIENTRYP PFNGLVERTEX3FVPROC)(const GLfloat *v);
++GLAPI PFNGLVERTEX3FVPROC glad_glVertex3fv;
++#define glVertex3fv glad_glVertex3fv
++typedef void (APIENTRYP PFNGLVERTEX3IPROC)(GLint x, GLint y, GLint z);
++GLAPI PFNGLVERTEX3IPROC glad_glVertex3i;
++#define glVertex3i glad_glVertex3i
++typedef void (APIENTRYP PFNGLVERTEX3IVPROC)(const GLint *v);
++GLAPI PFNGLVERTEX3IVPROC glad_glVertex3iv;
++#define glVertex3iv glad_glVertex3iv
++typedef void (APIENTRYP PFNGLVERTEX3SPROC)(GLshort x, GLshort y, GLshort z);
++GLAPI PFNGLVERTEX3SPROC glad_glVertex3s;
++#define glVertex3s glad_glVertex3s
++typedef void (APIENTRYP PFNGLVERTEX3SVPROC)(const GLshort *v);
++GLAPI PFNGLVERTEX3SVPROC glad_glVertex3sv;
++#define glVertex3sv glad_glVertex3sv
++typedef void (APIENTRYP PFNGLVERTEX4DPROC)(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
++GLAPI PFNGLVERTEX4DPROC glad_glVertex4d;
++#define glVertex4d glad_glVertex4d
++typedef void (APIENTRYP PFNGLVERTEX4DVPROC)(const GLdouble *v);
++GLAPI PFNGLVERTEX4DVPROC glad_glVertex4dv;
++#define glVertex4dv glad_glVertex4dv
++typedef void (APIENTRYP PFNGLVERTEX4FPROC)(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
++GLAPI PFNGLVERTEX4FPROC glad_glVertex4f;
++#define glVertex4f glad_glVertex4f
++typedef void (APIENTRYP PFNGLVERTEX4FVPROC)(const GLfloat *v);
++GLAPI PFNGLVERTEX4FVPROC glad_glVertex4fv;
++#define glVertex4fv glad_glVertex4fv
++typedef void (APIENTRYP PFNGLVERTEX4IPROC)(GLint x, GLint y, GLint z, GLint w);
++GLAPI PFNGLVERTEX4IPROC glad_glVertex4i;
++#define glVertex4i glad_glVertex4i
++typedef void (APIENTRYP PFNGLVERTEX4IVPROC)(const GLint *v);
++GLAPI PFNGLVERTEX4IVPROC glad_glVertex4iv;
++#define glVertex4iv glad_glVertex4iv
++typedef void (APIENTRYP PFNGLVERTEX4SPROC)(GLshort x, GLshort y, GLshort z, GLshort w);
++GLAPI PFNGLVERTEX4SPROC glad_glVertex4s;
++#define glVertex4s glad_glVertex4s
++typedef void (APIENTRYP PFNGLVERTEX4SVPROC)(const GLshort *v);
++GLAPI PFNGLVERTEX4SVPROC glad_glVertex4sv;
++#define glVertex4sv glad_glVertex4sv
++typedef void (APIENTRYP PFNGLCLIPPLANEPROC)(GLenum plane, const GLdouble *equation);
++GLAPI PFNGLCLIPPLANEPROC glad_glClipPlane;
++#define glClipPlane glad_glClipPlane
++typedef void (APIENTRYP PFNGLCOLORMATERIALPROC)(GLenum face, GLenum mode);
++GLAPI PFNGLCOLORMATERIALPROC glad_glColorMaterial;
++#define glColorMaterial glad_glColorMaterial
++typedef void (APIENTRYP PFNGLFOGFPROC)(GLenum pname, GLfloat param);
++GLAPI PFNGLFOGFPROC glad_glFogf;
++#define glFogf glad_glFogf
++typedef void (APIENTRYP PFNGLFOGFVPROC)(GLenum pname, const GLfloat *params);
++GLAPI PFNGLFOGFVPROC glad_glFogfv;
++#define glFogfv glad_glFogfv
++typedef void (APIENTRYP PFNGLFOGIPROC)(GLenum pname, GLint param);
++GLAPI PFNGLFOGIPROC glad_glFogi;
++#define glFogi glad_glFogi
++typedef void (APIENTRYP PFNGLFOGIVPROC)(GLenum pname, const GLint *params);
++GLAPI PFNGLFOGIVPROC glad_glFogiv;
++#define glFogiv glad_glFogiv
++typedef void (APIENTRYP PFNGLLIGHTFPROC)(GLenum light, GLenum pname, GLfloat param);
++GLAPI PFNGLLIGHTFPROC glad_glLightf;
++#define glLightf glad_glLightf
++typedef void (APIENTRYP PFNGLLIGHTFVPROC)(GLenum light, GLenum pname, const GLfloat *params);
++GLAPI PFNGLLIGHTFVPROC glad_glLightfv;
++#define glLightfv glad_glLightfv
++typedef void (APIENTRYP PFNGLLIGHTIPROC)(GLenum light, GLenum pname, GLint param);
++GLAPI PFNGLLIGHTIPROC glad_glLighti;
++#define glLighti glad_glLighti
++typedef void (APIENTRYP PFNGLLIGHTIVPROC)(GLenum light, GLenum pname, const GLint *params);
++GLAPI PFNGLLIGHTIVPROC glad_glLightiv;
++#define glLightiv glad_glLightiv
++typedef void (APIENTRYP PFNGLLIGHTMODELFPROC)(GLenum pname, GLfloat param);
++GLAPI PFNGLLIGHTMODELFPROC glad_glLightModelf;
++#define glLightModelf glad_glLightModelf
++typedef void (APIENTRYP PFNGLLIGHTMODELFVPROC)(GLenum pname, const GLfloat *params);
++GLAPI PFNGLLIGHTMODELFVPROC glad_glLightModelfv;
++#define glLightModelfv glad_glLightModelfv
++typedef void (APIENTRYP PFNGLLIGHTMODELIPROC)(GLenum pname, GLint param);
++GLAPI PFNGLLIGHTMODELIPROC glad_glLightModeli;
++#define glLightModeli glad_glLightModeli
++typedef void (APIENTRYP PFNGLLIGHTMODELIVPROC)(GLenum pname, const GLint *params);
++GLAPI PFNGLLIGHTMODELIVPROC glad_glLightModeliv;
++#define glLightModeliv glad_glLightModeliv
++typedef void (APIENTRYP PFNGLLINESTIPPLEPROC)(GLint factor, GLushort pattern);
++GLAPI PFNGLLINESTIPPLEPROC glad_glLineStipple;
++#define glLineStipple glad_glLineStipple
++typedef void (APIENTRYP PFNGLMATERIALFPROC)(GLenum face, GLenum pname, GLfloat param);
++GLAPI PFNGLMATERIALFPROC glad_glMaterialf;
++#define glMaterialf glad_glMaterialf
++typedef void (APIENTRYP PFNGLMATERIALFVPROC)(GLenum face, GLenum pname, const GLfloat *params);
++GLAPI PFNGLMATERIALFVPROC glad_glMaterialfv;
++#define glMaterialfv glad_glMaterialfv
++typedef void (APIENTRYP PFNGLMATERIALIPROC)(GLenum face, GLenum pname, GLint param);
++GLAPI PFNGLMATERIALIPROC glad_glMateriali;
++#define glMateriali glad_glMateriali
++typedef void (APIENTRYP PFNGLMATERIALIVPROC)(GLenum face, GLenum pname, const GLint *params);
++GLAPI PFNGLMATERIALIVPROC glad_glMaterialiv;
++#define glMaterialiv glad_glMaterialiv
++typedef void (APIENTRYP PFNGLPOLYGONSTIPPLEPROC)(const GLubyte *mask);
++GLAPI PFNGLPOLYGONSTIPPLEPROC glad_glPolygonStipple;
++#define glPolygonStipple glad_glPolygonStipple
++typedef void (APIENTRYP PFNGLSHADEMODELPROC)(GLenum mode);
++GLAPI PFNGLSHADEMODELPROC glad_glShadeModel;
++#define glShadeModel glad_glShadeModel
++typedef void (APIENTRYP PFNGLTEXENVFPROC)(GLenum target, GLenum pname, GLfloat param);
++GLAPI PFNGLTEXENVFPROC glad_glTexEnvf;
++#define glTexEnvf glad_glTexEnvf
++typedef void (APIENTRYP PFNGLTEXENVFVPROC)(GLenum target, GLenum pname, const GLfloat *params);
++GLAPI PFNGLTEXENVFVPROC glad_glTexEnvfv;
++#define glTexEnvfv glad_glTexEnvfv
++typedef void (APIENTRYP PFNGLTEXENVIPROC)(GLenum target, GLenum pname, GLint param);
++GLAPI PFNGLTEXENVIPROC glad_glTexEnvi;
++#define glTexEnvi glad_glTexEnvi
++typedef void (APIENTRYP PFNGLTEXENVIVPROC)(GLenum target, GLenum pname, const GLint *params);
++GLAPI PFNGLTEXENVIVPROC glad_glTexEnviv;
++#define glTexEnviv glad_glTexEnviv
++typedef void (APIENTRYP PFNGLTEXGENDPROC)(GLenum coord, GLenum pname, GLdouble param);
++GLAPI PFNGLTEXGENDPROC glad_glTexGend;
++#define glTexGend glad_glTexGend
++typedef void (APIENTRYP PFNGLTEXGENDVPROC)(GLenum coord, GLenum pname, const GLdouble *params);
++GLAPI PFNGLTEXGENDVPROC glad_glTexGendv;
++#define glTexGendv glad_glTexGendv
++typedef void (APIENTRYP PFNGLTEXGENFPROC)(GLenum coord, GLenum pname, GLfloat param);
++GLAPI PFNGLTEXGENFPROC glad_glTexGenf;
++#define glTexGenf glad_glTexGenf
++typedef void (APIENTRYP PFNGLTEXGENFVPROC)(GLenum coord, GLenum pname, const GLfloat *params);
++GLAPI PFNGLTEXGENFVPROC glad_glTexGenfv;
++#define glTexGenfv glad_glTexGenfv
++typedef void (APIENTRYP PFNGLTEXGENIPROC)(GLenum coord, GLenum pname, GLint param);
++GLAPI PFNGLTEXGENIPROC glad_glTexGeni;
++#define glTexGeni glad_glTexGeni
++typedef void (APIENTRYP PFNGLTEXGENIVPROC)(GLenum coord, GLenum pname, const GLint *params);
++GLAPI PFNGLTEXGENIVPROC glad_glTexGeniv;
++#define glTexGeniv glad_glTexGeniv
++typedef void (APIENTRYP PFNGLFEEDBACKBUFFERPROC)(GLsizei size, GLenum type, GLfloat *buffer);
++GLAPI PFNGLFEEDBACKBUFFERPROC glad_glFeedbackBuffer;
++#define glFeedbackBuffer glad_glFeedbackBuffer
++typedef void (APIENTRYP PFNGLSELECTBUFFERPROC)(GLsizei size, GLuint *buffer);
++GLAPI PFNGLSELECTBUFFERPROC glad_glSelectBuffer;
++#define glSelectBuffer glad_glSelectBuffer
++typedef GLint(APIENTRYP PFNGLRENDERMODEPROC)(GLenum mode);
++GLAPI PFNGLRENDERMODEPROC glad_glRenderMode;
++#define glRenderMode glad_glRenderMode
++typedef void (APIENTRYP PFNGLINITNAMESPROC)();
++GLAPI PFNGLINITNAMESPROC glad_glInitNames;
++#define glInitNames glad_glInitNames
++typedef void (APIENTRYP PFNGLLOADNAMEPROC)(GLuint name);
++GLAPI PFNGLLOADNAMEPROC glad_glLoadName;
++#define glLoadName glad_glLoadName
++typedef void (APIENTRYP PFNGLPASSTHROUGHPROC)(GLfloat token);
++GLAPI PFNGLPASSTHROUGHPROC glad_glPassThrough;
++#define glPassThrough glad_glPassThrough
++typedef void (APIENTRYP PFNGLPOPNAMEPROC)();
++GLAPI PFNGLPOPNAMEPROC glad_glPopName;
++#define glPopName glad_glPopName
++typedef void (APIENTRYP PFNGLPUSHNAMEPROC)(GLuint name);
++GLAPI PFNGLPUSHNAMEPROC glad_glPushName;
++#define glPushName glad_glPushName
++typedef void (APIENTRYP PFNGLCLEARACCUMPROC)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
++GLAPI PFNGLCLEARACCUMPROC glad_glClearAccum;
++#define glClearAccum glad_glClearAccum
++typedef void (APIENTRYP PFNGLCLEARINDEXPROC)(GLfloat c);
++GLAPI PFNGLCLEARINDEXPROC glad_glClearIndex;
++#define glClearIndex glad_glClearIndex
++typedef void (APIENTRYP PFNGLINDEXMASKPROC)(GLuint mask);
++GLAPI PFNGLINDEXMASKPROC glad_glIndexMask;
++#define glIndexMask glad_glIndexMask
++typedef void (APIENTRYP PFNGLACCUMPROC)(GLenum op, GLfloat value);
++GLAPI PFNGLACCUMPROC glad_glAccum;
++#define glAccum glad_glAccum
++typedef void (APIENTRYP PFNGLPOPATTRIBPROC)();
++GLAPI PFNGLPOPATTRIBPROC glad_glPopAttrib;
++#define glPopAttrib glad_glPopAttrib
++typedef void (APIENTRYP PFNGLPUSHATTRIBPROC)(GLbitfield mask);
++GLAPI PFNGLPUSHATTRIBPROC glad_glPushAttrib;
++#define glPushAttrib glad_glPushAttrib
++typedef void (APIENTRYP PFNGLMAP1DPROC)(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points);
++GLAPI PFNGLMAP1DPROC glad_glMap1d;
++#define glMap1d glad_glMap1d
++typedef void (APIENTRYP PFNGLMAP1FPROC)(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points);
++GLAPI PFNGLMAP1FPROC glad_glMap1f;
++#define glMap1f glad_glMap1f
++typedef void (APIENTRYP PFNGLMAP2DPROC)(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2,
++ GLint vstride, GLint vorder, const GLdouble *points);
++GLAPI PFNGLMAP2DPROC glad_glMap2d;
++#define glMap2d glad_glMap2d
++typedef void (APIENTRYP PFNGLMAP2FPROC)(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2,
++ GLint vstride, GLint vorder, const GLfloat *points);
++GLAPI PFNGLMAP2FPROC glad_glMap2f;
++#define glMap2f glad_glMap2f
++typedef void (APIENTRYP PFNGLMAPGRID1DPROC)(GLint un, GLdouble u1, GLdouble u2);
++GLAPI PFNGLMAPGRID1DPROC glad_glMapGrid1d;
++#define glMapGrid1d glad_glMapGrid1d
++typedef void (APIENTRYP PFNGLMAPGRID1FPROC)(GLint un, GLfloat u1, GLfloat u2);
++GLAPI PFNGLMAPGRID1FPROC glad_glMapGrid1f;
++#define glMapGrid1f glad_glMapGrid1f
++typedef void (APIENTRYP PFNGLMAPGRID2DPROC)(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2);
++GLAPI PFNGLMAPGRID2DPROC glad_glMapGrid2d;
++#define glMapGrid2d glad_glMapGrid2d
++typedef void (APIENTRYP PFNGLMAPGRID2FPROC)(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2);
++GLAPI PFNGLMAPGRID2FPROC glad_glMapGrid2f;
++#define glMapGrid2f glad_glMapGrid2f
++typedef void (APIENTRYP PFNGLEVALCOORD1DPROC)(GLdouble u);
++GLAPI PFNGLEVALCOORD1DPROC glad_glEvalCoord1d;
++#define glEvalCoord1d glad_glEvalCoord1d
++typedef void (APIENTRYP PFNGLEVALCOORD1DVPROC)(const GLdouble *u);
++GLAPI PFNGLEVALCOORD1DVPROC glad_glEvalCoord1dv;
++#define glEvalCoord1dv glad_glEvalCoord1dv
++typedef void (APIENTRYP PFNGLEVALCOORD1FPROC)(GLfloat u);
++GLAPI PFNGLEVALCOORD1FPROC glad_glEvalCoord1f;
++#define glEvalCoord1f glad_glEvalCoord1f
++typedef void (APIENTRYP PFNGLEVALCOORD1FVPROC)(const GLfloat *u);
++GLAPI PFNGLEVALCOORD1FVPROC glad_glEvalCoord1fv;
++#define glEvalCoord1fv glad_glEvalCoord1fv
++typedef void (APIENTRYP PFNGLEVALCOORD2DPROC)(GLdouble u, GLdouble v);
++GLAPI PFNGLEVALCOORD2DPROC glad_glEvalCoord2d;
++#define glEvalCoord2d glad_glEvalCoord2d
++typedef void (APIENTRYP PFNGLEVALCOORD2DVPROC)(const GLdouble *u);
++GLAPI PFNGLEVALCOORD2DVPROC glad_glEvalCoord2dv;
++#define glEvalCoord2dv glad_glEvalCoord2dv
++typedef void (APIENTRYP PFNGLEVALCOORD2FPROC)(GLfloat u, GLfloat v);
++GLAPI PFNGLEVALCOORD2FPROC glad_glEvalCoord2f;
++#define glEvalCoord2f glad_glEvalCoord2f
++typedef void (APIENTRYP PFNGLEVALCOORD2FVPROC)(const GLfloat *u);
++GLAPI PFNGLEVALCOORD2FVPROC glad_glEvalCoord2fv;
++#define glEvalCoord2fv glad_glEvalCoord2fv
++typedef void (APIENTRYP PFNGLEVALMESH1PROC)(GLenum mode, GLint i1, GLint i2);
++GLAPI PFNGLEVALMESH1PROC glad_glEvalMesh1;
++#define glEvalMesh1 glad_glEvalMesh1
++typedef void (APIENTRYP PFNGLEVALPOINT1PROC)(GLint i);
++GLAPI PFNGLEVALPOINT1PROC glad_glEvalPoint1;
++#define glEvalPoint1 glad_glEvalPoint1
++typedef void (APIENTRYP PFNGLEVALMESH2PROC)(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2);
++GLAPI PFNGLEVALMESH2PROC glad_glEvalMesh2;
++#define glEvalMesh2 glad_glEvalMesh2
++typedef void (APIENTRYP PFNGLEVALPOINT2PROC)(GLint i, GLint j);
++GLAPI PFNGLEVALPOINT2PROC glad_glEvalPoint2;
++#define glEvalPoint2 glad_glEvalPoint2
++typedef void (APIENTRYP PFNGLALPHAFUNCPROC)(GLenum func, GLfloat ref);
++GLAPI PFNGLALPHAFUNCPROC glad_glAlphaFunc;
++#define glAlphaFunc glad_glAlphaFunc
++typedef void (APIENTRYP PFNGLPIXELZOOMPROC)(GLfloat xfactor, GLfloat yfactor);
++GLAPI PFNGLPIXELZOOMPROC glad_glPixelZoom;
++#define glPixelZoom glad_glPixelZoom
++typedef void (APIENTRYP PFNGLPIXELTRANSFERFPROC)(GLenum pname, GLfloat param);
++GLAPI PFNGLPIXELTRANSFERFPROC glad_glPixelTransferf;
++#define glPixelTransferf glad_glPixelTransferf
++typedef void (APIENTRYP PFNGLPIXELTRANSFERIPROC)(GLenum pname, GLint param);
++GLAPI PFNGLPIXELTRANSFERIPROC glad_glPixelTransferi;
++#define glPixelTransferi glad_glPixelTransferi
++typedef void (APIENTRYP PFNGLPIXELMAPFVPROC)(GLenum map, GLsizei mapsize, const GLfloat *values);
++GLAPI PFNGLPIXELMAPFVPROC glad_glPixelMapfv;
++#define glPixelMapfv glad_glPixelMapfv
++typedef void (APIENTRYP PFNGLPIXELMAPUIVPROC)(GLenum map, GLsizei mapsize, const GLuint *values);
++GLAPI PFNGLPIXELMAPUIVPROC glad_glPixelMapuiv;
++#define glPixelMapuiv glad_glPixelMapuiv
++typedef void (APIENTRYP PFNGLPIXELMAPUSVPROC)(GLenum map, GLsizei mapsize, const GLushort *values);
++GLAPI PFNGLPIXELMAPUSVPROC glad_glPixelMapusv;
++#define glPixelMapusv glad_glPixelMapusv
++typedef void (APIENTRYP PFNGLCOPYPIXELSPROC)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type);
++GLAPI PFNGLCOPYPIXELSPROC glad_glCopyPixels;
++#define glCopyPixels glad_glCopyPixels
++typedef void (APIENTRYP PFNGLDRAWPIXELSPROC)(GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels);
++GLAPI PFNGLDRAWPIXELSPROC glad_glDrawPixels;
++#define glDrawPixels glad_glDrawPixels
++typedef void (APIENTRYP PFNGLGETCLIPPLANEPROC)(GLenum plane, GLdouble *equation);
++GLAPI PFNGLGETCLIPPLANEPROC glad_glGetClipPlane;
++#define glGetClipPlane glad_glGetClipPlane
++typedef void (APIENTRYP PFNGLGETLIGHTFVPROC)(GLenum light, GLenum pname, GLfloat *params);
++GLAPI PFNGLGETLIGHTFVPROC glad_glGetLightfv;
++#define glGetLightfv glad_glGetLightfv
++typedef void (APIENTRYP PFNGLGETLIGHTIVPROC)(GLenum light, GLenum pname, GLint *params);
++GLAPI PFNGLGETLIGHTIVPROC glad_glGetLightiv;
++#define glGetLightiv glad_glGetLightiv
++typedef void (APIENTRYP PFNGLGETMAPDVPROC)(GLenum target, GLenum query, GLdouble *v);
++GLAPI PFNGLGETMAPDVPROC glad_glGetMapdv;
++#define glGetMapdv glad_glGetMapdv
++typedef void (APIENTRYP PFNGLGETMAPFVPROC)(GLenum target, GLenum query, GLfloat *v);
++GLAPI PFNGLGETMAPFVPROC glad_glGetMapfv;
++#define glGetMapfv glad_glGetMapfv
++typedef void (APIENTRYP PFNGLGETMAPIVPROC)(GLenum target, GLenum query, GLint *v);
++GLAPI PFNGLGETMAPIVPROC glad_glGetMapiv;
++#define glGetMapiv glad_glGetMapiv
++typedef void (APIENTRYP PFNGLGETMATERIALFVPROC)(GLenum face, GLenum pname, GLfloat *params);
++GLAPI PFNGLGETMATERIALFVPROC glad_glGetMaterialfv;
++#define glGetMaterialfv glad_glGetMaterialfv
++typedef void (APIENTRYP PFNGLGETMATERIALIVPROC)(GLenum face, GLenum pname, GLint *params);
++GLAPI PFNGLGETMATERIALIVPROC glad_glGetMaterialiv;
++#define glGetMaterialiv glad_glGetMaterialiv
++typedef void (APIENTRYP PFNGLGETPIXELMAPFVPROC)(GLenum map, GLfloat *values);
++GLAPI PFNGLGETPIXELMAPFVPROC glad_glGetPixelMapfv;
++#define glGetPixelMapfv glad_glGetPixelMapfv
++typedef void (APIENTRYP PFNGLGETPIXELMAPUIVPROC)(GLenum map, GLuint *values);
++GLAPI PFNGLGETPIXELMAPUIVPROC glad_glGetPixelMapuiv;
++#define glGetPixelMapuiv glad_glGetPixelMapuiv
++typedef void (APIENTRYP PFNGLGETPIXELMAPUSVPROC)(GLenum map, GLushort *values);
++GLAPI PFNGLGETPIXELMAPUSVPROC glad_glGetPixelMapusv;
++#define glGetPixelMapusv glad_glGetPixelMapusv
++typedef void (APIENTRYP PFNGLGETPOLYGONSTIPPLEPROC)(GLubyte *mask);
++GLAPI PFNGLGETPOLYGONSTIPPLEPROC glad_glGetPolygonStipple;
++#define glGetPolygonStipple glad_glGetPolygonStipple
++typedef void (APIENTRYP PFNGLGETTEXENVFVPROC)(GLenum target, GLenum pname, GLfloat *params);
++GLAPI PFNGLGETTEXENVFVPROC glad_glGetTexEnvfv;
++#define glGetTexEnvfv glad_glGetTexEnvfv
++typedef void (APIENTRYP PFNGLGETTEXENVIVPROC)(GLenum target, GLenum pname, GLint *params);
++GLAPI PFNGLGETTEXENVIVPROC glad_glGetTexEnviv;
++#define glGetTexEnviv glad_glGetTexEnviv
++typedef void (APIENTRYP PFNGLGETTEXGENDVPROC)(GLenum coord, GLenum pname, GLdouble *params);
++GLAPI PFNGLGETTEXGENDVPROC glad_glGetTexGendv;
++#define glGetTexGendv glad_glGetTexGendv
++typedef void (APIENTRYP PFNGLGETTEXGENFVPROC)(GLenum coord, GLenum pname, GLfloat *params);
++GLAPI PFNGLGETTEXGENFVPROC glad_glGetTexGenfv;
++#define glGetTexGenfv glad_glGetTexGenfv
++typedef void (APIENTRYP PFNGLGETTEXGENIVPROC)(GLenum coord, GLenum pname, GLint *params);
++GLAPI PFNGLGETTEXGENIVPROC glad_glGetTexGeniv;
++#define glGetTexGeniv glad_glGetTexGeniv
++typedef GLboolean(APIENTRYP PFNGLISLISTPROC)(GLuint list);
++GLAPI PFNGLISLISTPROC glad_glIsList;
++#define glIsList glad_glIsList
++typedef void (APIENTRYP PFNGLFRUSTUMPROC)(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
++GLAPI PFNGLFRUSTUMPROC glad_glFrustum;
++#define glFrustum glad_glFrustum
++typedef void (APIENTRYP PFNGLLOADIDENTITYPROC)();
++GLAPI PFNGLLOADIDENTITYPROC glad_glLoadIdentity;
++#define glLoadIdentity glad_glLoadIdentity
++typedef void (APIENTRYP PFNGLLOADMATRIXFPROC)(const GLfloat *m);
++GLAPI PFNGLLOADMATRIXFPROC glad_glLoadMatrixf;
++#define glLoadMatrixf glad_glLoadMatrixf
++typedef void (APIENTRYP PFNGLLOADMATRIXDPROC)(const GLdouble *m);
++GLAPI PFNGLLOADMATRIXDPROC glad_glLoadMatrixd;
++#define glLoadMatrixd glad_glLoadMatrixd
++typedef void (APIENTRYP PFNGLMATRIXMODEPROC)(GLenum mode);
++GLAPI PFNGLMATRIXMODEPROC glad_glMatrixMode;
++#define glMatrixMode glad_glMatrixMode
++typedef void (APIENTRYP PFNGLMULTMATRIXFPROC)(const GLfloat *m);
++GLAPI PFNGLMULTMATRIXFPROC glad_glMultMatrixf;
++#define glMultMatrixf glad_glMultMatrixf
++typedef void (APIENTRYP PFNGLMULTMATRIXDPROC)(const GLdouble *m);
++GLAPI PFNGLMULTMATRIXDPROC glad_glMultMatrixd;
++#define glMultMatrixd glad_glMultMatrixd
++typedef void (APIENTRYP PFNGLORTHOPROC)(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
++GLAPI PFNGLORTHOPROC glad_glOrtho;
++#define glOrtho glad_glOrtho
++typedef void (APIENTRYP PFNGLPOPMATRIXPROC)();
++GLAPI PFNGLPOPMATRIXPROC glad_glPopMatrix;
++#define glPopMatrix glad_glPopMatrix
++typedef void (APIENTRYP PFNGLPUSHMATRIXPROC)();
++GLAPI PFNGLPUSHMATRIXPROC glad_glPushMatrix;
++#define glPushMatrix glad_glPushMatrix
++typedef void (APIENTRYP PFNGLROTATEDPROC)(GLdouble angle, GLdouble x, GLdouble y, GLdouble z);
++GLAPI PFNGLROTATEDPROC glad_glRotated;
++#define glRotated glad_glRotated
++typedef void (APIENTRYP PFNGLROTATEFPROC)(GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
++GLAPI PFNGLROTATEFPROC glad_glRotatef;
++#define glRotatef glad_glRotatef
++typedef void (APIENTRYP PFNGLSCALEDPROC)(GLdouble x, GLdouble y, GLdouble z);
++GLAPI PFNGLSCALEDPROC glad_glScaled;
++#define glScaled glad_glScaled
++typedef void (APIENTRYP PFNGLSCALEFPROC)(GLfloat x, GLfloat y, GLfloat z);
++GLAPI PFNGLSCALEFPROC glad_glScalef;
++#define glScalef glad_glScalef
++typedef void (APIENTRYP PFNGLTRANSLATEDPROC)(GLdouble x, GLdouble y, GLdouble z);
++GLAPI PFNGLTRANSLATEDPROC glad_glTranslated;
++#define glTranslated glad_glTranslated
++typedef void (APIENTRYP PFNGLTRANSLATEFPROC)(GLfloat x, GLfloat y, GLfloat z);
++GLAPI PFNGLTRANSLATEFPROC glad_glTranslatef;
++#define glTranslatef glad_glTranslatef
++#endif
++#ifndef GL_VERSION_1_1
++#define GL_VERSION_1_1 1
++GLAPI int GLAD_GL_VERSION_1_1;
++typedef void (APIENTRYP PFNGLDRAWARRAYSPROC)(GLenum mode, GLint first, GLsizei count);
++GLAPI PFNGLDRAWARRAYSPROC glad_glDrawArrays;
++#define glDrawArrays glad_glDrawArrays
++typedef void (APIENTRYP PFNGLDRAWELEMENTSPROC)(GLenum mode, GLsizei count, GLenum type, const void *indices);
++GLAPI PFNGLDRAWELEMENTSPROC glad_glDrawElements;
++#define glDrawElements glad_glDrawElements
++typedef void (APIENTRYP PFNGLGETPOINTERVPROC)(GLenum pname, void **params);
++GLAPI PFNGLGETPOINTERVPROC glad_glGetPointerv;
++#define glGetPointerv glad_glGetPointerv
++typedef void (APIENTRYP PFNGLPOLYGONOFFSETPROC)(GLfloat factor, GLfloat units);
++GLAPI PFNGLPOLYGONOFFSETPROC glad_glPolygonOffset;
++#define glPolygonOffset glad_glPolygonOffset
++typedef void (APIENTRYP PFNGLCOPYTEXIMAGE1DPROC)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width,
++ GLint border);
++GLAPI PFNGLCOPYTEXIMAGE1DPROC glad_glCopyTexImage1D;
++#define glCopyTexImage1D glad_glCopyTexImage1D
++typedef void (APIENTRYP PFNGLCOPYTEXIMAGE2DPROC)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width,
++ GLsizei height, GLint border);
++GLAPI PFNGLCOPYTEXIMAGE2DPROC glad_glCopyTexImage2D;
++#define glCopyTexImage2D glad_glCopyTexImage2D
++typedef void (APIENTRYP PFNGLCOPYTEXSUBIMAGE1DPROC)(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
++GLAPI PFNGLCOPYTEXSUBIMAGE1DPROC glad_glCopyTexSubImage1D;
++#define glCopyTexSubImage1D glad_glCopyTexSubImage1D
++typedef void (APIENTRYP PFNGLCOPYTEXSUBIMAGE2DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y,
++ GLsizei width, GLsizei height);
++GLAPI PFNGLCOPYTEXSUBIMAGE2DPROC glad_glCopyTexSubImage2D;
++#define glCopyTexSubImage2D glad_glCopyTexSubImage2D
++typedef void (APIENTRYP PFNGLTEXSUBIMAGE1DPROC)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type,
++ const void *pixels);
++GLAPI PFNGLTEXSUBIMAGE1DPROC glad_glTexSubImage1D;
++#define glTexSubImage1D glad_glTexSubImage1D
++typedef void (APIENTRYP PFNGLTEXSUBIMAGE2DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height,
++ GLenum format, GLenum type, const void *pixels);
++GLAPI PFNGLTEXSUBIMAGE2DPROC glad_glTexSubImage2D;
++#define glTexSubImage2D glad_glTexSubImage2D
++typedef void (APIENTRYP PFNGLBINDTEXTUREPROC)(GLenum target, GLuint texture);
++GLAPI PFNGLBINDTEXTUREPROC glad_glBindTexture;
++#define glBindTexture glad_glBindTexture
++typedef void (APIENTRYP PFNGLDELETETEXTURESPROC)(GLsizei n, const GLuint *textures);
++GLAPI PFNGLDELETETEXTURESPROC glad_glDeleteTextures;
++#define glDeleteTextures glad_glDeleteTextures
++typedef void (APIENTRYP PFNGLGENTEXTURESPROC)(GLsizei n, GLuint *textures);
++GLAPI PFNGLGENTEXTURESPROC glad_glGenTextures;
++#define glGenTextures glad_glGenTextures
++typedef GLboolean(APIENTRYP PFNGLISTEXTUREPROC)(GLuint texture);
++GLAPI PFNGLISTEXTUREPROC glad_glIsTexture;
++#define glIsTexture glad_glIsTexture
++typedef void (APIENTRYP PFNGLARRAYELEMENTPROC)(GLint i);
++GLAPI PFNGLARRAYELEMENTPROC glad_glArrayElement;
++#define glArrayElement glad_glArrayElement
++typedef void (APIENTRYP PFNGLCOLORPOINTERPROC)(GLint size, GLenum type, GLsizei stride, const void *pointer);
++GLAPI PFNGLCOLORPOINTERPROC glad_glColorPointer;
++#define glColorPointer glad_glColorPointer
++typedef void (APIENTRYP PFNGLDISABLECLIENTSTATEPROC)(GLenum array);
++GLAPI PFNGLDISABLECLIENTSTATEPROC glad_glDisableClientState;
++#define glDisableClientState glad_glDisableClientState
++typedef void (APIENTRYP PFNGLEDGEFLAGPOINTERPROC)(GLsizei stride, const void *pointer);
++GLAPI PFNGLEDGEFLAGPOINTERPROC glad_glEdgeFlagPointer;
++#define glEdgeFlagPointer glad_glEdgeFlagPointer
++typedef void (APIENTRYP PFNGLENABLECLIENTSTATEPROC)(GLenum array);
++GLAPI PFNGLENABLECLIENTSTATEPROC glad_glEnableClientState;
++#define glEnableClientState glad_glEnableClientState
++typedef void (APIENTRYP PFNGLINDEXPOINTERPROC)(GLenum type, GLsizei stride, const void *pointer);
++GLAPI PFNGLINDEXPOINTERPROC glad_glIndexPointer;
++#define glIndexPointer glad_glIndexPointer
++typedef void (APIENTRYP PFNGLINTERLEAVEDARRAYSPROC)(GLenum format, GLsizei stride, const void *pointer);
++GLAPI PFNGLINTERLEAVEDARRAYSPROC glad_glInterleavedArrays;
++#define glInterleavedArrays glad_glInterleavedArrays
++typedef void (APIENTRYP PFNGLNORMALPOINTERPROC)(GLenum type, GLsizei stride, const void *pointer);
++GLAPI PFNGLNORMALPOINTERPROC glad_glNormalPointer;
++#define glNormalPointer glad_glNormalPointer
++typedef void (APIENTRYP PFNGLTEXCOORDPOINTERPROC)(GLint size, GLenum type, GLsizei stride, const void *pointer);
++GLAPI PFNGLTEXCOORDPOINTERPROC glad_glTexCoordPointer;
++#define glTexCoordPointer glad_glTexCoordPointer
++typedef void (APIENTRYP PFNGLVERTEXPOINTERPROC)(GLint size, GLenum type, GLsizei stride, const void *pointer);
++GLAPI PFNGLVERTEXPOINTERPROC glad_glVertexPointer;
++#define glVertexPointer glad_glVertexPointer
++typedef GLboolean(APIENTRYP PFNGLARETEXTURESRESIDENTPROC)(GLsizei n, const GLuint *textures, GLboolean *residences);
++GLAPI PFNGLARETEXTURESRESIDENTPROC glad_glAreTexturesResident;
++#define glAreTexturesResident glad_glAreTexturesResident
++typedef void (APIENTRYP PFNGLPRIORITIZETEXTURESPROC)(GLsizei n, const GLuint *textures, const GLfloat *priorities);
++GLAPI PFNGLPRIORITIZETEXTURESPROC glad_glPrioritizeTextures;
++#define glPrioritizeTextures glad_glPrioritizeTextures
++typedef void (APIENTRYP PFNGLINDEXUBPROC)(GLubyte c);
++GLAPI PFNGLINDEXUBPROC glad_glIndexub;
++#define glIndexub glad_glIndexub
++typedef void (APIENTRYP PFNGLINDEXUBVPROC)(const GLubyte *c);
++GLAPI PFNGLINDEXUBVPROC glad_glIndexubv;
++#define glIndexubv glad_glIndexubv
++typedef void (APIENTRYP PFNGLPOPCLIENTATTRIBPROC)();
++GLAPI PFNGLPOPCLIENTATTRIBPROC glad_glPopClientAttrib;
++#define glPopClientAttrib glad_glPopClientAttrib
++typedef void (APIENTRYP PFNGLPUSHCLIENTATTRIBPROC)(GLbitfield mask);
++GLAPI PFNGLPUSHCLIENTATTRIBPROC glad_glPushClientAttrib;
++#define glPushClientAttrib glad_glPushClientAttrib
++#endif
++#ifndef GL_VERSION_1_2
++#define GL_VERSION_1_2 1
++GLAPI int GLAD_GL_VERSION_1_2;
++typedef void (APIENTRYP PFNGLDRAWRANGEELEMENTSPROC)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices);
++GLAPI PFNGLDRAWRANGEELEMENTSPROC glad_glDrawRangeElements;
++#define glDrawRangeElements glad_glDrawRangeElements
++typedef void (APIENTRYP PFNGLTEXIMAGE3DPROC)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth,
++ GLint border, GLenum format, GLenum type, const void *pixels);
++GLAPI PFNGLTEXIMAGE3DPROC glad_glTexImage3D;
++#define glTexImage3D glad_glTexImage3D
++typedef void (APIENTRYP PFNGLTEXSUBIMAGE3DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width,
++ GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels);
++GLAPI PFNGLTEXSUBIMAGE3DPROC glad_glTexSubImage3D;
++#define glTexSubImage3D glad_glTexSubImage3D
++typedef void (APIENTRYP PFNGLCOPYTEXSUBIMAGE3DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x,
++ GLint y, GLsizei width, GLsizei height);
++GLAPI PFNGLCOPYTEXSUBIMAGE3DPROC glad_glCopyTexSubImage3D;
++#define glCopyTexSubImage3D glad_glCopyTexSubImage3D
++#endif
++#ifndef GL_VERSION_1_3
++#define GL_VERSION_1_3 1
++GLAPI int GLAD_GL_VERSION_1_3;
++typedef void (APIENTRYP PFNGLACTIVETEXTUREPROC)(GLenum texture);
++GLAPI PFNGLACTIVETEXTUREPROC glad_glActiveTexture;
++#define glActiveTexture glad_glActiveTexture
++typedef void (APIENTRYP PFNGLSAMPLECOVERAGEPROC)(GLfloat value, GLboolean invert);
++GLAPI PFNGLSAMPLECOVERAGEPROC glad_glSampleCoverage;
++#define glSampleCoverage glad_glSampleCoverage
++typedef void (APIENTRYP PFNGLCOMPRESSEDTEXIMAGE3DPROC)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height,
++ GLsizei depth, GLint border, GLsizei imageSize, const void *data);
++GLAPI PFNGLCOMPRESSEDTEXIMAGE3DPROC glad_glCompressedTexImage3D;
++#define glCompressedTexImage3D glad_glCompressedTexImage3D
++typedef void (APIENTRYP PFNGLCOMPRESSEDTEXIMAGE2DPROC)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height,
++ GLint border, GLsizei imageSize, const void *data);
++GLAPI PFNGLCOMPRESSEDTEXIMAGE2DPROC glad_glCompressedTexImage2D;
++#define glCompressedTexImage2D glad_glCompressedTexImage2D
++typedef void (APIENTRYP PFNGLCOMPRESSEDTEXIMAGE1DPROC)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border,
++ GLsizei imageSize, const void *data);
++GLAPI PFNGLCOMPRESSEDTEXIMAGE1DPROC glad_glCompressedTexImage1D;
++#define glCompressedTexImage1D glad_glCompressedTexImage1D
++typedef void (APIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset,
++ GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data);
++GLAPI PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC glad_glCompressedTexSubImage3D;
++#define glCompressedTexSubImage3D glad_glCompressedTexSubImage3D
++typedef void (APIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width,
++ GLsizei height, GLenum format, GLsizei imageSize, const void *data);
++GLAPI PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC glad_glCompressedTexSubImage2D;
++#define glCompressedTexSubImage2D glad_glCompressedTexSubImage2D
++typedef void (APIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format,
++ GLsizei imageSize, const void *data);
++GLAPI PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC glad_glCompressedTexSubImage1D;
++#define glCompressedTexSubImage1D glad_glCompressedTexSubImage1D
++typedef void (APIENTRYP PFNGLGETCOMPRESSEDTEXIMAGEPROC)(GLenum target, GLint level, void *img);
++GLAPI PFNGLGETCOMPRESSEDTEXIMAGEPROC glad_glGetCompressedTexImage;
++#define glGetCompressedTexImage glad_glGetCompressedTexImage
++typedef void (APIENTRYP PFNGLCLIENTACTIVETEXTUREPROC)(GLenum texture);
++GLAPI PFNGLCLIENTACTIVETEXTUREPROC glad_glClientActiveTexture;
++#define glClientActiveTexture glad_glClientActiveTexture
++typedef void (APIENTRYP PFNGLMULTITEXCOORD1DPROC)(GLenum target, GLdouble s);
++GLAPI PFNGLMULTITEXCOORD1DPROC glad_glMultiTexCoord1d;
++#define glMultiTexCoord1d glad_glMultiTexCoord1d
++typedef void (APIENTRYP PFNGLMULTITEXCOORD1DVPROC)(GLenum target, const GLdouble *v);
++GLAPI PFNGLMULTITEXCOORD1DVPROC glad_glMultiTexCoord1dv;
++#define glMultiTexCoord1dv glad_glMultiTexCoord1dv
++typedef void (APIENTRYP PFNGLMULTITEXCOORD1FPROC)(GLenum target, GLfloat s);
++GLAPI PFNGLMULTITEXCOORD1FPROC glad_glMultiTexCoord1f;
++#define glMultiTexCoord1f glad_glMultiTexCoord1f
++typedef void (APIENTRYP PFNGLMULTITEXCOORD1FVPROC)(GLenum target, const GLfloat *v);
++GLAPI PFNGLMULTITEXCOORD1FVPROC glad_glMultiTexCoord1fv;
++#define glMultiTexCoord1fv glad_glMultiTexCoord1fv
++typedef void (APIENTRYP PFNGLMULTITEXCOORD1IPROC)(GLenum target, GLint s);
++GLAPI PFNGLMULTITEXCOORD1IPROC glad_glMultiTexCoord1i;
++#define glMultiTexCoord1i glad_glMultiTexCoord1i
++typedef void (APIENTRYP PFNGLMULTITEXCOORD1IVPROC)(GLenum target, const GLint *v);
++GLAPI PFNGLMULTITEXCOORD1IVPROC glad_glMultiTexCoord1iv;
++#define glMultiTexCoord1iv glad_glMultiTexCoord1iv
++typedef void (APIENTRYP PFNGLMULTITEXCOORD1SPROC)(GLenum target, GLshort s);
++GLAPI PFNGLMULTITEXCOORD1SPROC glad_glMultiTexCoord1s;
++#define glMultiTexCoord1s glad_glMultiTexCoord1s
++typedef void (APIENTRYP PFNGLMULTITEXCOORD1SVPROC)(GLenum target, const GLshort *v);
++GLAPI PFNGLMULTITEXCOORD1SVPROC glad_glMultiTexCoord1sv;
++#define glMultiTexCoord1sv glad_glMultiTexCoord1sv
++typedef void (APIENTRYP PFNGLMULTITEXCOORD2DPROC)(GLenum target, GLdouble s, GLdouble t);
++GLAPI PFNGLMULTITEXCOORD2DPROC glad_glMultiTexCoord2d;
++#define glMultiTexCoord2d glad_glMultiTexCoord2d
++typedef void (APIENTRYP PFNGLMULTITEXCOORD2DVPROC)(GLenum target, const GLdouble *v);
++GLAPI PFNGLMULTITEXCOORD2DVPROC glad_glMultiTexCoord2dv;
++#define glMultiTexCoord2dv glad_glMultiTexCoord2dv
++typedef void (APIENTRYP PFNGLMULTITEXCOORD2FPROC)(GLenum target, GLfloat s, GLfloat t);
++GLAPI PFNGLMULTITEXCOORD2FPROC glad_glMultiTexCoord2f;
++#define glMultiTexCoord2f glad_glMultiTexCoord2f
++typedef void (APIENTRYP PFNGLMULTITEXCOORD2FVPROC)(GLenum target, const GLfloat *v);
++GLAPI PFNGLMULTITEXCOORD2FVPROC glad_glMultiTexCoord2fv;
++#define glMultiTexCoord2fv glad_glMultiTexCoord2fv
++typedef void (APIENTRYP PFNGLMULTITEXCOORD2IPROC)(GLenum target, GLint s, GLint t);
++GLAPI PFNGLMULTITEXCOORD2IPROC glad_glMultiTexCoord2i;
++#define glMultiTexCoord2i glad_glMultiTexCoord2i
++typedef void (APIENTRYP PFNGLMULTITEXCOORD2IVPROC)(GLenum target, const GLint *v);
++GLAPI PFNGLMULTITEXCOORD2IVPROC glad_glMultiTexCoord2iv;
++#define glMultiTexCoord2iv glad_glMultiTexCoord2iv
++typedef void (APIENTRYP PFNGLMULTITEXCOORD2SPROC)(GLenum target, GLshort s, GLshort t);
++GLAPI PFNGLMULTITEXCOORD2SPROC glad_glMultiTexCoord2s;
++#define glMultiTexCoord2s glad_glMultiTexCoord2s
++typedef void (APIENTRYP PFNGLMULTITEXCOORD2SVPROC)(GLenum target, const GLshort *v);
++GLAPI PFNGLMULTITEXCOORD2SVPROC glad_glMultiTexCoord2sv;
++#define glMultiTexCoord2sv glad_glMultiTexCoord2sv
++typedef void (APIENTRYP PFNGLMULTITEXCOORD3DPROC)(GLenum target, GLdouble s, GLdouble t, GLdouble r);
++GLAPI PFNGLMULTITEXCOORD3DPROC glad_glMultiTexCoord3d;
++#define glMultiTexCoord3d glad_glMultiTexCoord3d
++typedef void (APIENTRYP PFNGLMULTITEXCOORD3DVPROC)(GLenum target, const GLdouble *v);
++GLAPI PFNGLMULTITEXCOORD3DVPROC glad_glMultiTexCoord3dv;
++#define glMultiTexCoord3dv glad_glMultiTexCoord3dv
++typedef void (APIENTRYP PFNGLMULTITEXCOORD3FPROC)(GLenum target, GLfloat s, GLfloat t, GLfloat r);
++GLAPI PFNGLMULTITEXCOORD3FPROC glad_glMultiTexCoord3f;
++#define glMultiTexCoord3f glad_glMultiTexCoord3f
++typedef void (APIENTRYP PFNGLMULTITEXCOORD3FVPROC)(GLenum target, const GLfloat *v);
++GLAPI PFNGLMULTITEXCOORD3FVPROC glad_glMultiTexCoord3fv;
++#define glMultiTexCoord3fv glad_glMultiTexCoord3fv
++typedef void (APIENTRYP PFNGLMULTITEXCOORD3IPROC)(GLenum target, GLint s, GLint t, GLint r);
++GLAPI PFNGLMULTITEXCOORD3IPROC glad_glMultiTexCoord3i;
++#define glMultiTexCoord3i glad_glMultiTexCoord3i
++typedef void (APIENTRYP PFNGLMULTITEXCOORD3IVPROC)(GLenum target, const GLint *v);
++GLAPI PFNGLMULTITEXCOORD3IVPROC glad_glMultiTexCoord3iv;
++#define glMultiTexCoord3iv glad_glMultiTexCoord3iv
++typedef void (APIENTRYP PFNGLMULTITEXCOORD3SPROC)(GLenum target, GLshort s, GLshort t, GLshort r);
++GLAPI PFNGLMULTITEXCOORD3SPROC glad_glMultiTexCoord3s;
++#define glMultiTexCoord3s glad_glMultiTexCoord3s
++typedef void (APIENTRYP PFNGLMULTITEXCOORD3SVPROC)(GLenum target, const GLshort *v);
++GLAPI PFNGLMULTITEXCOORD3SVPROC glad_glMultiTexCoord3sv;
++#define glMultiTexCoord3sv glad_glMultiTexCoord3sv
++typedef void (APIENTRYP PFNGLMULTITEXCOORD4DPROC)(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q);
++GLAPI PFNGLMULTITEXCOORD4DPROC glad_glMultiTexCoord4d;
++#define glMultiTexCoord4d glad_glMultiTexCoord4d
++typedef void (APIENTRYP PFNGLMULTITEXCOORD4DVPROC)(GLenum target, const GLdouble *v);
++GLAPI PFNGLMULTITEXCOORD4DVPROC glad_glMultiTexCoord4dv;
++#define glMultiTexCoord4dv glad_glMultiTexCoord4dv
++typedef void (APIENTRYP PFNGLMULTITEXCOORD4FPROC)(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q);
++GLAPI PFNGLMULTITEXCOORD4FPROC glad_glMultiTexCoord4f;
++#define glMultiTexCoord4f glad_glMultiTexCoord4f
++typedef void (APIENTRYP PFNGLMULTITEXCOORD4FVPROC)(GLenum target, const GLfloat *v);
++GLAPI PFNGLMULTITEXCOORD4FVPROC glad_glMultiTexCoord4fv;
++#define glMultiTexCoord4fv glad_glMultiTexCoord4fv
++typedef void (APIENTRYP PFNGLMULTITEXCOORD4IPROC)(GLenum target, GLint s, GLint t, GLint r, GLint q);
++GLAPI PFNGLMULTITEXCOORD4IPROC glad_glMultiTexCoord4i;
++#define glMultiTexCoord4i glad_glMultiTexCoord4i
++typedef void (APIENTRYP PFNGLMULTITEXCOORD4IVPROC)(GLenum target, const GLint *v);
++GLAPI PFNGLMULTITEXCOORD4IVPROC glad_glMultiTexCoord4iv;
++#define glMultiTexCoord4iv glad_glMultiTexCoord4iv
++typedef void (APIENTRYP PFNGLMULTITEXCOORD4SPROC)(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q);
++GLAPI PFNGLMULTITEXCOORD4SPROC glad_glMultiTexCoord4s;
++#define glMultiTexCoord4s glad_glMultiTexCoord4s
++typedef void (APIENTRYP PFNGLMULTITEXCOORD4SVPROC)(GLenum target, const GLshort *v);
++GLAPI PFNGLMULTITEXCOORD4SVPROC glad_glMultiTexCoord4sv;
++#define glMultiTexCoord4sv glad_glMultiTexCoord4sv
++typedef void (APIENTRYP PFNGLLOADTRANSPOSEMATRIXFPROC)(const GLfloat *m);
++GLAPI PFNGLLOADTRANSPOSEMATRIXFPROC glad_glLoadTransposeMatrixf;
++#define glLoadTransposeMatrixf glad_glLoadTransposeMatrixf
++typedef void (APIENTRYP PFNGLLOADTRANSPOSEMATRIXDPROC)(const GLdouble *m);
++GLAPI PFNGLLOADTRANSPOSEMATRIXDPROC glad_glLoadTransposeMatrixd;
++#define glLoadTransposeMatrixd glad_glLoadTransposeMatrixd
++typedef void (APIENTRYP PFNGLMULTTRANSPOSEMATRIXFPROC)(const GLfloat *m);
++GLAPI PFNGLMULTTRANSPOSEMATRIXFPROC glad_glMultTransposeMatrixf;
++#define glMultTransposeMatrixf glad_glMultTransposeMatrixf
++typedef void (APIENTRYP PFNGLMULTTRANSPOSEMATRIXDPROC)(const GLdouble *m);
++GLAPI PFNGLMULTTRANSPOSEMATRIXDPROC glad_glMultTransposeMatrixd;
++#define glMultTransposeMatrixd glad_glMultTransposeMatrixd
++#endif
++#ifndef GL_VERSION_1_4
++#define GL_VERSION_1_4 1
++GLAPI int GLAD_GL_VERSION_1_4;
++typedef void (APIENTRYP PFNGLBLENDFUNCSEPARATEPROC)(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
++GLAPI PFNGLBLENDFUNCSEPARATEPROC glad_glBlendFuncSeparate;
++#define glBlendFuncSeparate glad_glBlendFuncSeparate
++typedef void (APIENTRYP PFNGLMULTIDRAWARRAYSPROC)(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount);
++GLAPI PFNGLMULTIDRAWARRAYSPROC glad_glMultiDrawArrays;
++#define glMultiDrawArrays glad_glMultiDrawArrays
++typedef void (APIENTRYP PFNGLMULTIDRAWELEMENTSPROC)(GLenum mode, const GLsizei *count, GLenum type, const void *const *indices,
++ GLsizei drawcount);
++GLAPI PFNGLMULTIDRAWELEMENTSPROC glad_glMultiDrawElements;
++#define glMultiDrawElements glad_glMultiDrawElements
++typedef void (APIENTRYP PFNGLPOINTPARAMETERFPROC)(GLenum pname, GLfloat param);
++GLAPI PFNGLPOINTPARAMETERFPROC glad_glPointParameterf;
++#define glPointParameterf glad_glPointParameterf
++typedef void (APIENTRYP PFNGLPOINTPARAMETERFVPROC)(GLenum pname, const GLfloat *params);
++GLAPI PFNGLPOINTPARAMETERFVPROC glad_glPointParameterfv;
++#define glPointParameterfv glad_glPointParameterfv
++typedef void (APIENTRYP PFNGLPOINTPARAMETERIPROC)(GLenum pname, GLint param);
++GLAPI PFNGLPOINTPARAMETERIPROC glad_glPointParameteri;
++#define glPointParameteri glad_glPointParameteri
++typedef void (APIENTRYP PFNGLPOINTPARAMETERIVPROC)(GLenum pname, const GLint *params);
++GLAPI PFNGLPOINTPARAMETERIVPROC glad_glPointParameteriv;
++#define glPointParameteriv glad_glPointParameteriv
++typedef void (APIENTRYP PFNGLFOGCOORDFPROC)(GLfloat coord);
++GLAPI PFNGLFOGCOORDFPROC glad_glFogCoordf;
++#define glFogCoordf glad_glFogCoordf
++typedef void (APIENTRYP PFNGLFOGCOORDFVPROC)(const GLfloat *coord);
++GLAPI PFNGLFOGCOORDFVPROC glad_glFogCoordfv;
++#define glFogCoordfv glad_glFogCoordfv
++typedef void (APIENTRYP PFNGLFOGCOORDDPROC)(GLdouble coord);
++GLAPI PFNGLFOGCOORDDPROC glad_glFogCoordd;
++#define glFogCoordd glad_glFogCoordd
++typedef void (APIENTRYP PFNGLFOGCOORDDVPROC)(const GLdouble *coord);
++GLAPI PFNGLFOGCOORDDVPROC glad_glFogCoorddv;
++#define glFogCoorddv glad_glFogCoorddv
++typedef void (APIENTRYP PFNGLFOGCOORDPOINTERPROC)(GLenum type, GLsizei stride, const void *pointer);
++GLAPI PFNGLFOGCOORDPOINTERPROC glad_glFogCoordPointer;
++#define glFogCoordPointer glad_glFogCoordPointer
++typedef void (APIENTRYP PFNGLSECONDARYCOLOR3BPROC)(GLbyte red, GLbyte green, GLbyte blue);
++GLAPI PFNGLSECONDARYCOLOR3BPROC glad_glSecondaryColor3b;
++#define glSecondaryColor3b glad_glSecondaryColor3b
++typedef void (APIENTRYP PFNGLSECONDARYCOLOR3BVPROC)(const GLbyte *v);
++GLAPI PFNGLSECONDARYCOLOR3BVPROC glad_glSecondaryColor3bv;
++#define glSecondaryColor3bv glad_glSecondaryColor3bv
++typedef void (APIENTRYP PFNGLSECONDARYCOLOR3DPROC)(GLdouble red, GLdouble green, GLdouble blue);
++GLAPI PFNGLSECONDARYCOLOR3DPROC glad_glSecondaryColor3d;
++#define glSecondaryColor3d glad_glSecondaryColor3d
++typedef void (APIENTRYP PFNGLSECONDARYCOLOR3DVPROC)(const GLdouble *v);
++GLAPI PFNGLSECONDARYCOLOR3DVPROC glad_glSecondaryColor3dv;
++#define glSecondaryColor3dv glad_glSecondaryColor3dv
++typedef void (APIENTRYP PFNGLSECONDARYCOLOR3FPROC)(GLfloat red, GLfloat green, GLfloat blue);
++GLAPI PFNGLSECONDARYCOLOR3FPROC glad_glSecondaryColor3f;
++#define glSecondaryColor3f glad_glSecondaryColor3f
++typedef void (APIENTRYP PFNGLSECONDARYCOLOR3FVPROC)(const GLfloat *v);
++GLAPI PFNGLSECONDARYCOLOR3FVPROC glad_glSecondaryColor3fv;
++#define glSecondaryColor3fv glad_glSecondaryColor3fv
++typedef void (APIENTRYP PFNGLSECONDARYCOLOR3IPROC)(GLint red, GLint green, GLint blue);
++GLAPI PFNGLSECONDARYCOLOR3IPROC glad_glSecondaryColor3i;
++#define glSecondaryColor3i glad_glSecondaryColor3i
++typedef void (APIENTRYP PFNGLSECONDARYCOLOR3IVPROC)(const GLint *v);
++GLAPI PFNGLSECONDARYCOLOR3IVPROC glad_glSecondaryColor3iv;
++#define glSecondaryColor3iv glad_glSecondaryColor3iv
++typedef void (APIENTRYP PFNGLSECONDARYCOLOR3SPROC)(GLshort red, GLshort green, GLshort blue);
++GLAPI PFNGLSECONDARYCOLOR3SPROC glad_glSecondaryColor3s;
++#define glSecondaryColor3s glad_glSecondaryColor3s
++typedef void (APIENTRYP PFNGLSECONDARYCOLOR3SVPROC)(const GLshort *v);
++GLAPI PFNGLSECONDARYCOLOR3SVPROC glad_glSecondaryColor3sv;
++#define glSecondaryColor3sv glad_glSecondaryColor3sv
++typedef void (APIENTRYP PFNGLSECONDARYCOLOR3UBPROC)(GLubyte red, GLubyte green, GLubyte blue);
++GLAPI PFNGLSECONDARYCOLOR3UBPROC glad_glSecondaryColor3ub;
++#define glSecondaryColor3ub glad_glSecondaryColor3ub
++typedef void (APIENTRYP PFNGLSECONDARYCOLOR3UBVPROC)(const GLubyte *v);
++GLAPI PFNGLSECONDARYCOLOR3UBVPROC glad_glSecondaryColor3ubv;
++#define glSecondaryColor3ubv glad_glSecondaryColor3ubv
++typedef void (APIENTRYP PFNGLSECONDARYCOLOR3UIPROC)(GLuint red, GLuint green, GLuint blue);
++GLAPI PFNGLSECONDARYCOLOR3UIPROC glad_glSecondaryColor3ui;
++#define glSecondaryColor3ui glad_glSecondaryColor3ui
++typedef void (APIENTRYP PFNGLSECONDARYCOLOR3UIVPROC)(const GLuint *v);
++GLAPI PFNGLSECONDARYCOLOR3UIVPROC glad_glSecondaryColor3uiv;
++#define glSecondaryColor3uiv glad_glSecondaryColor3uiv
++typedef void (APIENTRYP PFNGLSECONDARYCOLOR3USPROC)(GLushort red, GLushort green, GLushort blue);
++GLAPI PFNGLSECONDARYCOLOR3USPROC glad_glSecondaryColor3us;
++#define glSecondaryColor3us glad_glSecondaryColor3us
++typedef void (APIENTRYP PFNGLSECONDARYCOLOR3USVPROC)(const GLushort *v);
++GLAPI PFNGLSECONDARYCOLOR3USVPROC glad_glSecondaryColor3usv;
++#define glSecondaryColor3usv glad_glSecondaryColor3usv
++typedef void (APIENTRYP PFNGLSECONDARYCOLORPOINTERPROC)(GLint size, GLenum type, GLsizei stride, const void *pointer);
++GLAPI PFNGLSECONDARYCOLORPOINTERPROC glad_glSecondaryColorPointer;
++#define glSecondaryColorPointer glad_glSecondaryColorPointer
++typedef void (APIENTRYP PFNGLWINDOWPOS2DPROC)(GLdouble x, GLdouble y);
++GLAPI PFNGLWINDOWPOS2DPROC glad_glWindowPos2d;
++#define glWindowPos2d glad_glWindowPos2d
++typedef void (APIENTRYP PFNGLWINDOWPOS2DVPROC)(const GLdouble *v);
++GLAPI PFNGLWINDOWPOS2DVPROC glad_glWindowPos2dv;
++#define glWindowPos2dv glad_glWindowPos2dv
++typedef void (APIENTRYP PFNGLWINDOWPOS2FPROC)(GLfloat x, GLfloat y);
++GLAPI PFNGLWINDOWPOS2FPROC glad_glWindowPos2f;
++#define glWindowPos2f glad_glWindowPos2f
++typedef void (APIENTRYP PFNGLWINDOWPOS2FVPROC)(const GLfloat *v);
++GLAPI PFNGLWINDOWPOS2FVPROC glad_glWindowPos2fv;
++#define glWindowPos2fv glad_glWindowPos2fv
++typedef void (APIENTRYP PFNGLWINDOWPOS2IPROC)(GLint x, GLint y);
++GLAPI PFNGLWINDOWPOS2IPROC glad_glWindowPos2i;
++#define glWindowPos2i glad_glWindowPos2i
++typedef void (APIENTRYP PFNGLWINDOWPOS2IVPROC)(const GLint *v);
++GLAPI PFNGLWINDOWPOS2IVPROC glad_glWindowPos2iv;
++#define glWindowPos2iv glad_glWindowPos2iv
++typedef void (APIENTRYP PFNGLWINDOWPOS2SPROC)(GLshort x, GLshort y);
++GLAPI PFNGLWINDOWPOS2SPROC glad_glWindowPos2s;
++#define glWindowPos2s glad_glWindowPos2s
++typedef void (APIENTRYP PFNGLWINDOWPOS2SVPROC)(const GLshort *v);
++GLAPI PFNGLWINDOWPOS2SVPROC glad_glWindowPos2sv;
++#define glWindowPos2sv glad_glWindowPos2sv
++typedef void (APIENTRYP PFNGLWINDOWPOS3DPROC)(GLdouble x, GLdouble y, GLdouble z);
++GLAPI PFNGLWINDOWPOS3DPROC glad_glWindowPos3d;
++#define glWindowPos3d glad_glWindowPos3d
++typedef void (APIENTRYP PFNGLWINDOWPOS3DVPROC)(const GLdouble *v);
++GLAPI PFNGLWINDOWPOS3DVPROC glad_glWindowPos3dv;
++#define glWindowPos3dv glad_glWindowPos3dv
++typedef void (APIENTRYP PFNGLWINDOWPOS3FPROC)(GLfloat x, GLfloat y, GLfloat z);
++GLAPI PFNGLWINDOWPOS3FPROC glad_glWindowPos3f;
++#define glWindowPos3f glad_glWindowPos3f
++typedef void (APIENTRYP PFNGLWINDOWPOS3FVPROC)(const GLfloat *v);
++GLAPI PFNGLWINDOWPOS3FVPROC glad_glWindowPos3fv;
++#define glWindowPos3fv glad_glWindowPos3fv
++typedef void (APIENTRYP PFNGLWINDOWPOS3IPROC)(GLint x, GLint y, GLint z);
++GLAPI PFNGLWINDOWPOS3IPROC glad_glWindowPos3i;
++#define glWindowPos3i glad_glWindowPos3i
++typedef void (APIENTRYP PFNGLWINDOWPOS3IVPROC)(const GLint *v);
++GLAPI PFNGLWINDOWPOS3IVPROC glad_glWindowPos3iv;
++#define glWindowPos3iv glad_glWindowPos3iv
++typedef void (APIENTRYP PFNGLWINDOWPOS3SPROC)(GLshort x, GLshort y, GLshort z);
++GLAPI PFNGLWINDOWPOS3SPROC glad_glWindowPos3s;
++#define glWindowPos3s glad_glWindowPos3s
++typedef void (APIENTRYP PFNGLWINDOWPOS3SVPROC)(const GLshort *v);
++GLAPI PFNGLWINDOWPOS3SVPROC glad_glWindowPos3sv;
++#define glWindowPos3sv glad_glWindowPos3sv
++typedef void (APIENTRYP PFNGLBLENDCOLORPROC)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
++GLAPI PFNGLBLENDCOLORPROC glad_glBlendColor;
++#define glBlendColor glad_glBlendColor
++typedef void (APIENTRYP PFNGLBLENDEQUATIONPROC)(GLenum mode);
++GLAPI PFNGLBLENDEQUATIONPROC glad_glBlendEquation;
++#define glBlendEquation glad_glBlendEquation
++#endif
++#ifndef GL_VERSION_1_5
++#define GL_VERSION_1_5 1
++GLAPI int GLAD_GL_VERSION_1_5;
++typedef void (APIENTRYP PFNGLGENQUERIESPROC)(GLsizei n, GLuint *ids);
++GLAPI PFNGLGENQUERIESPROC glad_glGenQueries;
++#define glGenQueries glad_glGenQueries
++typedef void (APIENTRYP PFNGLDELETEQUERIESPROC)(GLsizei n, const GLuint *ids);
++GLAPI PFNGLDELETEQUERIESPROC glad_glDeleteQueries;
++#define glDeleteQueries glad_glDeleteQueries
++typedef GLboolean(APIENTRYP PFNGLISQUERYPROC)(GLuint id);
++GLAPI PFNGLISQUERYPROC glad_glIsQuery;
++#define glIsQuery glad_glIsQuery
++typedef void (APIENTRYP PFNGLBEGINQUERYPROC)(GLenum target, GLuint id);
++GLAPI PFNGLBEGINQUERYPROC glad_glBeginQuery;
++#define glBeginQuery glad_glBeginQuery
++typedef void (APIENTRYP PFNGLENDQUERYPROC)(GLenum target);
++GLAPI PFNGLENDQUERYPROC glad_glEndQuery;
++#define glEndQuery glad_glEndQuery
++typedef void (APIENTRYP PFNGLGETQUERYIVPROC)(GLenum target, GLenum pname, GLint *params);
++GLAPI PFNGLGETQUERYIVPROC glad_glGetQueryiv;
++#define glGetQueryiv glad_glGetQueryiv
++typedef void (APIENTRYP PFNGLGETQUERYOBJECTIVPROC)(GLuint id, GLenum pname, GLint *params);
++GLAPI PFNGLGETQUERYOBJECTIVPROC glad_glGetQueryObjectiv;
++#define glGetQueryObjectiv glad_glGetQueryObjectiv
++typedef void (APIENTRYP PFNGLGETQUERYOBJECTUIVPROC)(GLuint id, GLenum pname, GLuint *params);
++GLAPI PFNGLGETQUERYOBJECTUIVPROC glad_glGetQueryObjectuiv;
++#define glGetQueryObjectuiv glad_glGetQueryObjectuiv
++typedef void (APIENTRYP PFNGLBINDBUFFERPROC)(GLenum target, GLuint buffer);
++GLAPI PFNGLBINDBUFFERPROC glad_glBindBuffer;
++#define glBindBuffer glad_glBindBuffer
++typedef void (APIENTRYP PFNGLDELETEBUFFERSPROC)(GLsizei n, const GLuint *buffers);
++GLAPI PFNGLDELETEBUFFERSPROC glad_glDeleteBuffers;
++#define glDeleteBuffers glad_glDeleteBuffers
++typedef void (APIENTRYP PFNGLGENBUFFERSPROC)(GLsizei n, GLuint *buffers);
++GLAPI PFNGLGENBUFFERSPROC glad_glGenBuffers;
++#define glGenBuffers glad_glGenBuffers
++typedef GLboolean(APIENTRYP PFNGLISBUFFERPROC)(GLuint buffer);
++GLAPI PFNGLISBUFFERPROC glad_glIsBuffer;
++#define glIsBuffer glad_glIsBuffer
++typedef void (APIENTRYP PFNGLBUFFERDATAPROC)(GLenum target, GLsizeiptr size, const void *data, GLenum usage);
++GLAPI PFNGLBUFFERDATAPROC glad_glBufferData;
++#define glBufferData glad_glBufferData
++typedef void (APIENTRYP PFNGLBUFFERSUBDATAPROC)(GLenum target, GLintptr offset, GLsizeiptr size, const void *data);
++GLAPI PFNGLBUFFERSUBDATAPROC glad_glBufferSubData;
++#define glBufferSubData glad_glBufferSubData
++typedef void (APIENTRYP PFNGLGETBUFFERSUBDATAPROC)(GLenum target, GLintptr offset, GLsizeiptr size, void *data);
++GLAPI PFNGLGETBUFFERSUBDATAPROC glad_glGetBufferSubData;
++#define glGetBufferSubData glad_glGetBufferSubData
++typedef void *(APIENTRYP PFNGLMAPBUFFERPROC)(GLenum target, GLenum access);
++GLAPI PFNGLMAPBUFFERPROC glad_glMapBuffer;
++#define glMapBuffer glad_glMapBuffer
++typedef GLboolean(APIENTRYP PFNGLUNMAPBUFFERPROC)(GLenum target);
++GLAPI PFNGLUNMAPBUFFERPROC glad_glUnmapBuffer;
++#define glUnmapBuffer glad_glUnmapBuffer
++typedef void (APIENTRYP PFNGLGETBUFFERPARAMETERIVPROC)(GLenum target, GLenum pname, GLint *params);
++GLAPI PFNGLGETBUFFERPARAMETERIVPROC glad_glGetBufferParameteriv;
++#define glGetBufferParameteriv glad_glGetBufferParameteriv
++typedef void (APIENTRYP PFNGLGETBUFFERPOINTERVPROC)(GLenum target, GLenum pname, void **params);
++GLAPI PFNGLGETBUFFERPOINTERVPROC glad_glGetBufferPointerv;
++#define glGetBufferPointerv glad_glGetBufferPointerv
++#endif
++#ifndef GL_VERSION_2_0
++#define GL_VERSION_2_0 1
++GLAPI int GLAD_GL_VERSION_2_0;
++typedef void (APIENTRYP PFNGLBLENDEQUATIONSEPARATEPROC)(GLenum modeRGB, GLenum modeAlpha);
++GLAPI PFNGLBLENDEQUATIONSEPARATEPROC glad_glBlendEquationSeparate;
++#define glBlendEquationSeparate glad_glBlendEquationSeparate
++typedef void (APIENTRYP PFNGLDRAWBUFFERSPROC)(GLsizei n, const GLenum *bufs);
++GLAPI PFNGLDRAWBUFFERSPROC glad_glDrawBuffers;
++#define glDrawBuffers glad_glDrawBuffers
++typedef void (APIENTRYP PFNGLSTENCILOPSEPARATEPROC)(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass);
++GLAPI PFNGLSTENCILOPSEPARATEPROC glad_glStencilOpSeparate;
++#define glStencilOpSeparate glad_glStencilOpSeparate
++typedef void (APIENTRYP PFNGLSTENCILFUNCSEPARATEPROC)(GLenum face, GLenum func, GLint ref, GLuint mask);
++GLAPI PFNGLSTENCILFUNCSEPARATEPROC glad_glStencilFuncSeparate;
++#define glStencilFuncSeparate glad_glStencilFuncSeparate
++typedef void (APIENTRYP PFNGLSTENCILMASKSEPARATEPROC)(GLenum face, GLuint mask);
++GLAPI PFNGLSTENCILMASKSEPARATEPROC glad_glStencilMaskSeparate;
++#define glStencilMaskSeparate glad_glStencilMaskSeparate
++typedef void (APIENTRYP PFNGLATTACHSHADERPROC)(GLuint program, GLuint shader);
++GLAPI PFNGLATTACHSHADERPROC glad_glAttachShader;
++#define glAttachShader glad_glAttachShader
++typedef void (APIENTRYP PFNGLBINDATTRIBLOCATIONPROC)(GLuint program, GLuint index, const GLchar *name);
++GLAPI PFNGLBINDATTRIBLOCATIONPROC glad_glBindAttribLocation;
++#define glBindAttribLocation glad_glBindAttribLocation
++typedef void (APIENTRYP PFNGLCOMPILESHADERPROC)(GLuint shader);
++GLAPI PFNGLCOMPILESHADERPROC glad_glCompileShader;
++#define glCompileShader glad_glCompileShader
++typedef GLuint(APIENTRYP PFNGLCREATEPROGRAMPROC)();
++GLAPI PFNGLCREATEPROGRAMPROC glad_glCreateProgram;
++#define glCreateProgram glad_glCreateProgram
++typedef GLuint(APIENTRYP PFNGLCREATESHADERPROC)(GLenum type);
++GLAPI PFNGLCREATESHADERPROC glad_glCreateShader;
++#define glCreateShader glad_glCreateShader
++typedef void (APIENTRYP PFNGLDELETEPROGRAMPROC)(GLuint program);
++GLAPI PFNGLDELETEPROGRAMPROC glad_glDeleteProgram;
++#define glDeleteProgram glad_glDeleteProgram
++typedef void (APIENTRYP PFNGLDELETESHADERPROC)(GLuint shader);
++GLAPI PFNGLDELETESHADERPROC glad_glDeleteShader;
++#define glDeleteShader glad_glDeleteShader
++typedef void (APIENTRYP PFNGLDETACHSHADERPROC)(GLuint program, GLuint shader);
++GLAPI PFNGLDETACHSHADERPROC glad_glDetachShader;
++#define glDetachShader glad_glDetachShader
++typedef void (APIENTRYP PFNGLDISABLEVERTEXATTRIBARRAYPROC)(GLuint index);
++GLAPI PFNGLDISABLEVERTEXATTRIBARRAYPROC glad_glDisableVertexAttribArray;
++#define glDisableVertexAttribArray glad_glDisableVertexAttribArray
++typedef void (APIENTRYP PFNGLENABLEVERTEXATTRIBARRAYPROC)(GLuint index);
++GLAPI PFNGLENABLEVERTEXATTRIBARRAYPROC glad_glEnableVertexAttribArray;
++#define glEnableVertexAttribArray glad_glEnableVertexAttribArray
++typedef void (APIENTRYP PFNGLGETACTIVEATTRIBPROC)(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type,
++ GLchar *name);
++GLAPI PFNGLGETACTIVEATTRIBPROC glad_glGetActiveAttrib;
++#define glGetActiveAttrib glad_glGetActiveAttrib
++typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMPROC)(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size,
++ GLenum *type, GLchar *name);
++GLAPI PFNGLGETACTIVEUNIFORMPROC glad_glGetActiveUniform;
++#define glGetActiveUniform glad_glGetActiveUniform
++typedef void (APIENTRYP PFNGLGETATTACHEDSHADERSPROC)(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *shaders);
++GLAPI PFNGLGETATTACHEDSHADERSPROC glad_glGetAttachedShaders;
++#define glGetAttachedShaders glad_glGetAttachedShaders
++typedef GLint(APIENTRYP PFNGLGETATTRIBLOCATIONPROC)(GLuint program, const GLchar *name);
++GLAPI PFNGLGETATTRIBLOCATIONPROC glad_glGetAttribLocation;
++#define glGetAttribLocation glad_glGetAttribLocation
++typedef void (APIENTRYP PFNGLGETPROGRAMIVPROC)(GLuint program, GLenum pname, GLint *params);
++GLAPI PFNGLGETPROGRAMIVPROC glad_glGetProgramiv;
++#define glGetProgramiv glad_glGetProgramiv
++typedef void (APIENTRYP PFNGLGETPROGRAMINFOLOGPROC)(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
++GLAPI PFNGLGETPROGRAMINFOLOGPROC glad_glGetProgramInfoLog;
++#define glGetProgramInfoLog glad_glGetProgramInfoLog
++typedef void (APIENTRYP PFNGLGETSHADERIVPROC)(GLuint shader, GLenum pname, GLint *params);
++GLAPI PFNGLGETSHADERIVPROC glad_glGetShaderiv;
++#define glGetShaderiv glad_glGetShaderiv
++typedef void (APIENTRYP PFNGLGETSHADERINFOLOGPROC)(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
++GLAPI PFNGLGETSHADERINFOLOGPROC glad_glGetShaderInfoLog;
++#define glGetShaderInfoLog glad_glGetShaderInfoLog
++typedef void (APIENTRYP PFNGLGETSHADERSOURCEPROC)(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source);
++GLAPI PFNGLGETSHADERSOURCEPROC glad_glGetShaderSource;
++#define glGetShaderSource glad_glGetShaderSource
++typedef GLint(APIENTRYP PFNGLGETUNIFORMLOCATIONPROC)(GLuint program, const GLchar *name);
++GLAPI PFNGLGETUNIFORMLOCATIONPROC glad_glGetUniformLocation;
++#define glGetUniformLocation glad_glGetUniformLocation
++typedef void (APIENTRYP PFNGLGETUNIFORMFVPROC)(GLuint program, GLint location, GLfloat *params);
++GLAPI PFNGLGETUNIFORMFVPROC glad_glGetUniformfv;
++#define glGetUniformfv glad_glGetUniformfv
++typedef void (APIENTRYP PFNGLGETUNIFORMIVPROC)(GLuint program, GLint location, GLint *params);
++GLAPI PFNGLGETUNIFORMIVPROC glad_glGetUniformiv;
++#define glGetUniformiv glad_glGetUniformiv
++typedef void (APIENTRYP PFNGLGETVERTEXATTRIBDVPROC)(GLuint index, GLenum pname, GLdouble *params);
++GLAPI PFNGLGETVERTEXATTRIBDVPROC glad_glGetVertexAttribdv;
++#define glGetVertexAttribdv glad_glGetVertexAttribdv
++typedef void (APIENTRYP PFNGLGETVERTEXATTRIBFVPROC)(GLuint index, GLenum pname, GLfloat *params);
++GLAPI PFNGLGETVERTEXATTRIBFVPROC glad_glGetVertexAttribfv;
++#define glGetVertexAttribfv glad_glGetVertexAttribfv
++typedef void (APIENTRYP PFNGLGETVERTEXATTRIBIVPROC)(GLuint index, GLenum pname, GLint *params);
++GLAPI PFNGLGETVERTEXATTRIBIVPROC glad_glGetVertexAttribiv;
++#define glGetVertexAttribiv glad_glGetVertexAttribiv
++typedef void (APIENTRYP PFNGLGETVERTEXATTRIBPOINTERVPROC)(GLuint index, GLenum pname, void **pointer);
++GLAPI PFNGLGETVERTEXATTRIBPOINTERVPROC glad_glGetVertexAttribPointerv;
++#define glGetVertexAttribPointerv glad_glGetVertexAttribPointerv
++typedef GLboolean(APIENTRYP PFNGLISPROGRAMPROC)(GLuint program);
++GLAPI PFNGLISPROGRAMPROC glad_glIsProgram;
++#define glIsProgram glad_glIsProgram
++typedef GLboolean(APIENTRYP PFNGLISSHADERPROC)(GLuint shader);
++GLAPI PFNGLISSHADERPROC glad_glIsShader;
++#define glIsShader glad_glIsShader
++typedef void (APIENTRYP PFNGLLINKPROGRAMPROC)(GLuint program);
++GLAPI PFNGLLINKPROGRAMPROC glad_glLinkProgram;
++#define glLinkProgram glad_glLinkProgram
++typedef void (APIENTRYP PFNGLSHADERSOURCEPROC)(GLuint shader, GLsizei count, const GLchar *const *string, const GLint *length);
++GLAPI PFNGLSHADERSOURCEPROC glad_glShaderSource;
++#define glShaderSource glad_glShaderSource
++typedef void (APIENTRYP PFNGLUSEPROGRAMPROC)(GLuint program);
++GLAPI PFNGLUSEPROGRAMPROC glad_glUseProgram;
++#define glUseProgram glad_glUseProgram
++typedef void (APIENTRYP PFNGLUNIFORM1FPROC)(GLint location, GLfloat v0);
++GLAPI PFNGLUNIFORM1FPROC glad_glUniform1f;
++#define glUniform1f glad_glUniform1f
++typedef void (APIENTRYP PFNGLUNIFORM2FPROC)(GLint location, GLfloat v0, GLfloat v1);
++GLAPI PFNGLUNIFORM2FPROC glad_glUniform2f;
++#define glUniform2f glad_glUniform2f
++typedef void (APIENTRYP PFNGLUNIFORM3FPROC)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
++GLAPI PFNGLUNIFORM3FPROC glad_glUniform3f;
++#define glUniform3f glad_glUniform3f
++typedef void (APIENTRYP PFNGLUNIFORM4FPROC)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
++GLAPI PFNGLUNIFORM4FPROC glad_glUniform4f;
++#define glUniform4f glad_glUniform4f
++typedef void (APIENTRYP PFNGLUNIFORM1IPROC)(GLint location, GLint v0);
++GLAPI PFNGLUNIFORM1IPROC glad_glUniform1i;
++#define glUniform1i glad_glUniform1i
++typedef void (APIENTRYP PFNGLUNIFORM2IPROC)(GLint location, GLint v0, GLint v1);
++GLAPI PFNGLUNIFORM2IPROC glad_glUniform2i;
++#define glUniform2i glad_glUniform2i
++typedef void (APIENTRYP PFNGLUNIFORM3IPROC)(GLint location, GLint v0, GLint v1, GLint v2);
++GLAPI PFNGLUNIFORM3IPROC glad_glUniform3i;
++#define glUniform3i glad_glUniform3i
++typedef void (APIENTRYP PFNGLUNIFORM4IPROC)(GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
++GLAPI PFNGLUNIFORM4IPROC glad_glUniform4i;
++#define glUniform4i glad_glUniform4i
++typedef void (APIENTRYP PFNGLUNIFORM1FVPROC)(GLint location, GLsizei count, const GLfloat *value);
++GLAPI PFNGLUNIFORM1FVPROC glad_glUniform1fv;
++#define glUniform1fv glad_glUniform1fv
++typedef void (APIENTRYP PFNGLUNIFORM2FVPROC)(GLint location, GLsizei count, const GLfloat *value);
++GLAPI PFNGLUNIFORM2FVPROC glad_glUniform2fv;
++#define glUniform2fv glad_glUniform2fv
++typedef void (APIENTRYP PFNGLUNIFORM3FVPROC)(GLint location, GLsizei count, const GLfloat *value);
++GLAPI PFNGLUNIFORM3FVPROC glad_glUniform3fv;
++#define glUniform3fv glad_glUniform3fv
++typedef void (APIENTRYP PFNGLUNIFORM4FVPROC)(GLint location, GLsizei count, const GLfloat *value);
++GLAPI PFNGLUNIFORM4FVPROC glad_glUniform4fv;
++#define glUniform4fv glad_glUniform4fv
++typedef void (APIENTRYP PFNGLUNIFORM1IVPROC)(GLint location, GLsizei count, const GLint *value);
++GLAPI PFNGLUNIFORM1IVPROC glad_glUniform1iv;
++#define glUniform1iv glad_glUniform1iv
++typedef void (APIENTRYP PFNGLUNIFORM2IVPROC)(GLint location, GLsizei count, const GLint *value);
++GLAPI PFNGLUNIFORM2IVPROC glad_glUniform2iv;
++#define glUniform2iv glad_glUniform2iv
++typedef void (APIENTRYP PFNGLUNIFORM3IVPROC)(GLint location, GLsizei count, const GLint *value);
++GLAPI PFNGLUNIFORM3IVPROC glad_glUniform3iv;
++#define glUniform3iv glad_glUniform3iv
++typedef void (APIENTRYP PFNGLUNIFORM4IVPROC)(GLint location, GLsizei count, const GLint *value);
++GLAPI PFNGLUNIFORM4IVPROC glad_glUniform4iv;
++#define glUniform4iv glad_glUniform4iv
++typedef void (APIENTRYP PFNGLUNIFORMMATRIX2FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
++GLAPI PFNGLUNIFORMMATRIX2FVPROC glad_glUniformMatrix2fv;
++#define glUniformMatrix2fv glad_glUniformMatrix2fv
++typedef void (APIENTRYP PFNGLUNIFORMMATRIX3FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
++GLAPI PFNGLUNIFORMMATRIX3FVPROC glad_glUniformMatrix3fv;
++#define glUniformMatrix3fv glad_glUniformMatrix3fv
++typedef void (APIENTRYP PFNGLUNIFORMMATRIX4FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
++GLAPI PFNGLUNIFORMMATRIX4FVPROC glad_glUniformMatrix4fv;
++#define glUniformMatrix4fv glad_glUniformMatrix4fv
++typedef void (APIENTRYP PFNGLVALIDATEPROGRAMPROC)(GLuint program);
++GLAPI PFNGLVALIDATEPROGRAMPROC glad_glValidateProgram;
++#define glValidateProgram glad_glValidateProgram
++typedef void (APIENTRYP PFNGLVERTEXATTRIB1DPROC)(GLuint index, GLdouble x);
++GLAPI PFNGLVERTEXATTRIB1DPROC glad_glVertexAttrib1d;
++#define glVertexAttrib1d glad_glVertexAttrib1d
++typedef void (APIENTRYP PFNGLVERTEXATTRIB1DVPROC)(GLuint index, const GLdouble *v);
++GLAPI PFNGLVERTEXATTRIB1DVPROC glad_glVertexAttrib1dv;
++#define glVertexAttrib1dv glad_glVertexAttrib1dv
++typedef void (APIENTRYP PFNGLVERTEXATTRIB1FPROC)(GLuint index, GLfloat x);
++GLAPI PFNGLVERTEXATTRIB1FPROC glad_glVertexAttrib1f;
++#define glVertexAttrib1f glad_glVertexAttrib1f
++typedef void (APIENTRYP PFNGLVERTEXATTRIB1FVPROC)(GLuint index, const GLfloat *v);
++GLAPI PFNGLVERTEXATTRIB1FVPROC glad_glVertexAttrib1fv;
++#define glVertexAttrib1fv glad_glVertexAttrib1fv
++typedef void (APIENTRYP PFNGLVERTEXATTRIB1SPROC)(GLuint index, GLshort x);
++GLAPI PFNGLVERTEXATTRIB1SPROC glad_glVertexAttrib1s;
++#define glVertexAttrib1s glad_glVertexAttrib1s
++typedef void (APIENTRYP PFNGLVERTEXATTRIB1SVPROC)(GLuint index, const GLshort *v);
++GLAPI PFNGLVERTEXATTRIB1SVPROC glad_glVertexAttrib1sv;
++#define glVertexAttrib1sv glad_glVertexAttrib1sv
++typedef void (APIENTRYP PFNGLVERTEXATTRIB2DPROC)(GLuint index, GLdouble x, GLdouble y);
++GLAPI PFNGLVERTEXATTRIB2DPROC glad_glVertexAttrib2d;
++#define glVertexAttrib2d glad_glVertexAttrib2d
++typedef void (APIENTRYP PFNGLVERTEXATTRIB2DVPROC)(GLuint index, const GLdouble *v);
++GLAPI PFNGLVERTEXATTRIB2DVPROC glad_glVertexAttrib2dv;
++#define glVertexAttrib2dv glad_glVertexAttrib2dv
++typedef void (APIENTRYP PFNGLVERTEXATTRIB2FPROC)(GLuint index, GLfloat x, GLfloat y);
++GLAPI PFNGLVERTEXATTRIB2FPROC glad_glVertexAttrib2f;
++#define glVertexAttrib2f glad_glVertexAttrib2f
++typedef void (APIENTRYP PFNGLVERTEXATTRIB2FVPROC)(GLuint index, const GLfloat *v);
++GLAPI PFNGLVERTEXATTRIB2FVPROC glad_glVertexAttrib2fv;
++#define glVertexAttrib2fv glad_glVertexAttrib2fv
++typedef void (APIENTRYP PFNGLVERTEXATTRIB2SPROC)(GLuint index, GLshort x, GLshort y);
++GLAPI PFNGLVERTEXATTRIB2SPROC glad_glVertexAttrib2s;
++#define glVertexAttrib2s glad_glVertexAttrib2s
++typedef void (APIENTRYP PFNGLVERTEXATTRIB2SVPROC)(GLuint index, const GLshort *v);
++GLAPI PFNGLVERTEXATTRIB2SVPROC glad_glVertexAttrib2sv;
++#define glVertexAttrib2sv glad_glVertexAttrib2sv
++typedef void (APIENTRYP PFNGLVERTEXATTRIB3DPROC)(GLuint index, GLdouble x, GLdouble y, GLdouble z);
++GLAPI PFNGLVERTEXATTRIB3DPROC glad_glVertexAttrib3d;
++#define glVertexAttrib3d glad_glVertexAttrib3d
++typedef void (APIENTRYP PFNGLVERTEXATTRIB3DVPROC)(GLuint index, const GLdouble *v);
++GLAPI PFNGLVERTEXATTRIB3DVPROC glad_glVertexAttrib3dv;
++#define glVertexAttrib3dv glad_glVertexAttrib3dv
++typedef void (APIENTRYP PFNGLVERTEXATTRIB3FPROC)(GLuint index, GLfloat x, GLfloat y, GLfloat z);
++GLAPI PFNGLVERTEXATTRIB3FPROC glad_glVertexAttrib3f;
++#define glVertexAttrib3f glad_glVertexAttrib3f
++typedef void (APIENTRYP PFNGLVERTEXATTRIB3FVPROC)(GLuint index, const GLfloat *v);
++GLAPI PFNGLVERTEXATTRIB3FVPROC glad_glVertexAttrib3fv;
++#define glVertexAttrib3fv glad_glVertexAttrib3fv
++typedef void (APIENTRYP PFNGLVERTEXATTRIB3SPROC)(GLuint index, GLshort x, GLshort y, GLshort z);
++GLAPI PFNGLVERTEXATTRIB3SPROC glad_glVertexAttrib3s;
++#define glVertexAttrib3s glad_glVertexAttrib3s
++typedef void (APIENTRYP PFNGLVERTEXATTRIB3SVPROC)(GLuint index, const GLshort *v);
++GLAPI PFNGLVERTEXATTRIB3SVPROC glad_glVertexAttrib3sv;
++#define glVertexAttrib3sv glad_glVertexAttrib3sv
++typedef void (APIENTRYP PFNGLVERTEXATTRIB4NBVPROC)(GLuint index, const GLbyte *v);
++GLAPI PFNGLVERTEXATTRIB4NBVPROC glad_glVertexAttrib4Nbv;
++#define glVertexAttrib4Nbv glad_glVertexAttrib4Nbv
++typedef void (APIENTRYP PFNGLVERTEXATTRIB4NIVPROC)(GLuint index, const GLint *v);
++GLAPI PFNGLVERTEXATTRIB4NIVPROC glad_glVertexAttrib4Niv;
++#define glVertexAttrib4Niv glad_glVertexAttrib4Niv
++typedef void (APIENTRYP PFNGLVERTEXATTRIB4NSVPROC)(GLuint index, const GLshort *v);
++GLAPI PFNGLVERTEXATTRIB4NSVPROC glad_glVertexAttrib4Nsv;
++#define glVertexAttrib4Nsv glad_glVertexAttrib4Nsv
++typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUBPROC)(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w);
++GLAPI PFNGLVERTEXATTRIB4NUBPROC glad_glVertexAttrib4Nub;
++#define glVertexAttrib4Nub glad_glVertexAttrib4Nub
++typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUBVPROC)(GLuint index, const GLubyte *v);
++GLAPI PFNGLVERTEXATTRIB4NUBVPROC glad_glVertexAttrib4Nubv;
++#define glVertexAttrib4Nubv glad_glVertexAttrib4Nubv
++typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUIVPROC)(GLuint index, const GLuint *v);
++GLAPI PFNGLVERTEXATTRIB4NUIVPROC glad_glVertexAttrib4Nuiv;
++#define glVertexAttrib4Nuiv glad_glVertexAttrib4Nuiv
++typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUSVPROC)(GLuint index, const GLushort *v);
++GLAPI PFNGLVERTEXATTRIB4NUSVPROC glad_glVertexAttrib4Nusv;
++#define glVertexAttrib4Nusv glad_glVertexAttrib4Nusv
++typedef void (APIENTRYP PFNGLVERTEXATTRIB4BVPROC)(GLuint index, const GLbyte *v);
++GLAPI PFNGLVERTEXATTRIB4BVPROC glad_glVertexAttrib4bv;
++#define glVertexAttrib4bv glad_glVertexAttrib4bv
++typedef void (APIENTRYP PFNGLVERTEXATTRIB4DPROC)(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
++GLAPI PFNGLVERTEXATTRIB4DPROC glad_glVertexAttrib4d;
++#define glVertexAttrib4d glad_glVertexAttrib4d
++typedef void (APIENTRYP PFNGLVERTEXATTRIB4DVPROC)(GLuint index, const GLdouble *v);
++GLAPI PFNGLVERTEXATTRIB4DVPROC glad_glVertexAttrib4dv;
++#define glVertexAttrib4dv glad_glVertexAttrib4dv
++typedef void (APIENTRYP PFNGLVERTEXATTRIB4FPROC)(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
++GLAPI PFNGLVERTEXATTRIB4FPROC glad_glVertexAttrib4f;
++#define glVertexAttrib4f glad_glVertexAttrib4f
++typedef void (APIENTRYP PFNGLVERTEXATTRIB4FVPROC)(GLuint index, const GLfloat *v);
++GLAPI PFNGLVERTEXATTRIB4FVPROC glad_glVertexAttrib4fv;
++#define glVertexAttrib4fv glad_glVertexAttrib4fv
++typedef void (APIENTRYP PFNGLVERTEXATTRIB4IVPROC)(GLuint index, const GLint *v);
++GLAPI PFNGLVERTEXATTRIB4IVPROC glad_glVertexAttrib4iv;
++#define glVertexAttrib4iv glad_glVertexAttrib4iv
++typedef void (APIENTRYP PFNGLVERTEXATTRIB4SPROC)(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w);
++GLAPI PFNGLVERTEXATTRIB4SPROC glad_glVertexAttrib4s;
++#define glVertexAttrib4s glad_glVertexAttrib4s
++typedef void (APIENTRYP PFNGLVERTEXATTRIB4SVPROC)(GLuint index, const GLshort *v);
++GLAPI PFNGLVERTEXATTRIB4SVPROC glad_glVertexAttrib4sv;
++#define glVertexAttrib4sv glad_glVertexAttrib4sv
++typedef void (APIENTRYP PFNGLVERTEXATTRIB4UBVPROC)(GLuint index, const GLubyte *v);
++GLAPI PFNGLVERTEXATTRIB4UBVPROC glad_glVertexAttrib4ubv;
++#define glVertexAttrib4ubv glad_glVertexAttrib4ubv
++typedef void (APIENTRYP PFNGLVERTEXATTRIB4UIVPROC)(GLuint index, const GLuint *v);
++GLAPI PFNGLVERTEXATTRIB4UIVPROC glad_glVertexAttrib4uiv;
++#define glVertexAttrib4uiv glad_glVertexAttrib4uiv
++typedef void (APIENTRYP PFNGLVERTEXATTRIB4USVPROC)(GLuint index, const GLushort *v);
++GLAPI PFNGLVERTEXATTRIB4USVPROC glad_glVertexAttrib4usv;
++#define glVertexAttrib4usv glad_glVertexAttrib4usv
++typedef void (APIENTRYP PFNGLVERTEXATTRIBPOINTERPROC)(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride,
++ const void *pointer);
++GLAPI PFNGLVERTEXATTRIBPOINTERPROC glad_glVertexAttribPointer;
++#define glVertexAttribPointer glad_glVertexAttribPointer
++#endif
++#ifndef GL_VERSION_2_1
++#define GL_VERSION_2_1 1
++GLAPI int GLAD_GL_VERSION_2_1;
++typedef void (APIENTRYP PFNGLUNIFORMMATRIX2X3FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
++GLAPI PFNGLUNIFORMMATRIX2X3FVPROC glad_glUniformMatrix2x3fv;
++#define glUniformMatrix2x3fv glad_glUniformMatrix2x3fv
++typedef void (APIENTRYP PFNGLUNIFORMMATRIX3X2FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
++GLAPI PFNGLUNIFORMMATRIX3X2FVPROC glad_glUniformMatrix3x2fv;
++#define glUniformMatrix3x2fv glad_glUniformMatrix3x2fv
++typedef void (APIENTRYP PFNGLUNIFORMMATRIX2X4FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
++GLAPI PFNGLUNIFORMMATRIX2X4FVPROC glad_glUniformMatrix2x4fv;
++#define glUniformMatrix2x4fv glad_glUniformMatrix2x4fv
++typedef void (APIENTRYP PFNGLUNIFORMMATRIX4X2FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
++GLAPI PFNGLUNIFORMMATRIX4X2FVPROC glad_glUniformMatrix4x2fv;
++#define glUniformMatrix4x2fv glad_glUniformMatrix4x2fv
++typedef void (APIENTRYP PFNGLUNIFORMMATRIX3X4FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
++GLAPI PFNGLUNIFORMMATRIX3X4FVPROC glad_glUniformMatrix3x4fv;
++#define glUniformMatrix3x4fv glad_glUniformMatrix3x4fv
++typedef void (APIENTRYP PFNGLUNIFORMMATRIX4X3FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
++GLAPI PFNGLUNIFORMMATRIX4X3FVPROC glad_glUniformMatrix4x3fv;
++#define glUniformMatrix4x3fv glad_glUniformMatrix4x3fv
++#endif
++#ifndef GL_VERSION_3_0
++#define GL_VERSION_3_0 1
++GLAPI int GLAD_GL_VERSION_3_0;
++typedef void (APIENTRYP PFNGLCOLORMASKIPROC)(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a);
++GLAPI PFNGLCOLORMASKIPROC glad_glColorMaski;
++#define glColorMaski glad_glColorMaski
++typedef void (APIENTRYP PFNGLGETBOOLEANI_VPROC)(GLenum target, GLuint index, GLboolean *data);
++GLAPI PFNGLGETBOOLEANI_VPROC glad_glGetBooleani_v;
++#define glGetBooleani_v glad_glGetBooleani_v
++typedef void (APIENTRYP PFNGLGETINTEGERI_VPROC)(GLenum target, GLuint index, GLint *data);
++GLAPI PFNGLGETINTEGERI_VPROC glad_glGetIntegeri_v;
++#define glGetIntegeri_v glad_glGetIntegeri_v
++typedef void (APIENTRYP PFNGLENABLEIPROC)(GLenum target, GLuint index);
++GLAPI PFNGLENABLEIPROC glad_glEnablei;
++#define glEnablei glad_glEnablei
++typedef void (APIENTRYP PFNGLDISABLEIPROC)(GLenum target, GLuint index);
++GLAPI PFNGLDISABLEIPROC glad_glDisablei;
++#define glDisablei glad_glDisablei
++typedef GLboolean(APIENTRYP PFNGLISENABLEDIPROC)(GLenum target, GLuint index);
++GLAPI PFNGLISENABLEDIPROC glad_glIsEnabledi;
++#define glIsEnabledi glad_glIsEnabledi
++typedef void (APIENTRYP PFNGLBEGINTRANSFORMFEEDBACKPROC)(GLenum primitiveMode);
++GLAPI PFNGLBEGINTRANSFORMFEEDBACKPROC glad_glBeginTransformFeedback;
++#define glBeginTransformFeedback glad_glBeginTransformFeedback
++typedef void (APIENTRYP PFNGLENDTRANSFORMFEEDBACKPROC)();
++GLAPI PFNGLENDTRANSFORMFEEDBACKPROC glad_glEndTransformFeedback;
++#define glEndTransformFeedback glad_glEndTransformFeedback
++typedef void (APIENTRYP PFNGLBINDBUFFERRANGEPROC)(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size);
++GLAPI PFNGLBINDBUFFERRANGEPROC glad_glBindBufferRange;
++#define glBindBufferRange glad_glBindBufferRange
++typedef void (APIENTRYP PFNGLBINDBUFFERBASEPROC)(GLenum target, GLuint index, GLuint buffer);
++GLAPI PFNGLBINDBUFFERBASEPROC glad_glBindBufferBase;
++#define glBindBufferBase glad_glBindBufferBase
++typedef void (APIENTRYP PFNGLTRANSFORMFEEDBACKVARYINGSPROC)(GLuint program, GLsizei count, const GLchar *const *varyings,
++ GLenum bufferMode);
++GLAPI PFNGLTRANSFORMFEEDBACKVARYINGSPROC glad_glTransformFeedbackVaryings;
++#define glTransformFeedbackVaryings glad_glTransformFeedbackVaryings
++typedef void (APIENTRYP PFNGLGETTRANSFORMFEEDBACKVARYINGPROC)(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size,
++ GLenum *type, GLchar *name);
++GLAPI PFNGLGETTRANSFORMFEEDBACKVARYINGPROC glad_glGetTransformFeedbackVarying;
++#define glGetTransformFeedbackVarying glad_glGetTransformFeedbackVarying
++typedef void (APIENTRYP PFNGLCLAMPCOLORPROC)(GLenum target, GLenum clamp);
++GLAPI PFNGLCLAMPCOLORPROC glad_glClampColor;
++#define glClampColor glad_glClampColor
++typedef void (APIENTRYP PFNGLBEGINCONDITIONALRENDERPROC)(GLuint id, GLenum mode);
++GLAPI PFNGLBEGINCONDITIONALRENDERPROC glad_glBeginConditionalRender;
++#define glBeginConditionalRender glad_glBeginConditionalRender
++typedef void (APIENTRYP PFNGLENDCONDITIONALRENDERPROC)();
++GLAPI PFNGLENDCONDITIONALRENDERPROC glad_glEndConditionalRender;
++#define glEndConditionalRender glad_glEndConditionalRender
++typedef void (APIENTRYP PFNGLVERTEXATTRIBIPOINTERPROC)(GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer);
++GLAPI PFNGLVERTEXATTRIBIPOINTERPROC glad_glVertexAttribIPointer;
++#define glVertexAttribIPointer glad_glVertexAttribIPointer
++typedef void (APIENTRYP PFNGLGETVERTEXATTRIBIIVPROC)(GLuint index, GLenum pname, GLint *params);
++GLAPI PFNGLGETVERTEXATTRIBIIVPROC glad_glGetVertexAttribIiv;
++#define glGetVertexAttribIiv glad_glGetVertexAttribIiv
++typedef void (APIENTRYP PFNGLGETVERTEXATTRIBIUIVPROC)(GLuint index, GLenum pname, GLuint *params);
++GLAPI PFNGLGETVERTEXATTRIBIUIVPROC glad_glGetVertexAttribIuiv;
++#define glGetVertexAttribIuiv glad_glGetVertexAttribIuiv
++typedef void (APIENTRYP PFNGLVERTEXATTRIBI1IPROC)(GLuint index, GLint x);
++GLAPI PFNGLVERTEXATTRIBI1IPROC glad_glVertexAttribI1i;
++#define glVertexAttribI1i glad_glVertexAttribI1i
++typedef void (APIENTRYP PFNGLVERTEXATTRIBI2IPROC)(GLuint index, GLint x, GLint y);
++GLAPI PFNGLVERTEXATTRIBI2IPROC glad_glVertexAttribI2i;
++#define glVertexAttribI2i glad_glVertexAttribI2i
++typedef void (APIENTRYP PFNGLVERTEXATTRIBI3IPROC)(GLuint index, GLint x, GLint y, GLint z);
++GLAPI PFNGLVERTEXATTRIBI3IPROC glad_glVertexAttribI3i;
++#define glVertexAttribI3i glad_glVertexAttribI3i
++typedef void (APIENTRYP PFNGLVERTEXATTRIBI4IPROC)(GLuint index, GLint x, GLint y, GLint z, GLint w);
++GLAPI PFNGLVERTEXATTRIBI4IPROC glad_glVertexAttribI4i;
++#define glVertexAttribI4i glad_glVertexAttribI4i
++typedef void (APIENTRYP PFNGLVERTEXATTRIBI1UIPROC)(GLuint index, GLuint x);
++GLAPI PFNGLVERTEXATTRIBI1UIPROC glad_glVertexAttribI1ui;
++#define glVertexAttribI1ui glad_glVertexAttribI1ui
++typedef void (APIENTRYP PFNGLVERTEXATTRIBI2UIPROC)(GLuint index, GLuint x, GLuint y);
++GLAPI PFNGLVERTEXATTRIBI2UIPROC glad_glVertexAttribI2ui;
++#define glVertexAttribI2ui glad_glVertexAttribI2ui
++typedef void (APIENTRYP PFNGLVERTEXATTRIBI3UIPROC)(GLuint index, GLuint x, GLuint y, GLuint z);
++GLAPI PFNGLVERTEXATTRIBI3UIPROC glad_glVertexAttribI3ui;
++#define glVertexAttribI3ui glad_glVertexAttribI3ui
++typedef void (APIENTRYP PFNGLVERTEXATTRIBI4UIPROC)(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w);
++GLAPI PFNGLVERTEXATTRIBI4UIPROC glad_glVertexAttribI4ui;
++#define glVertexAttribI4ui glad_glVertexAttribI4ui
++typedef void (APIENTRYP PFNGLVERTEXATTRIBI1IVPROC)(GLuint index, const GLint *v);
++GLAPI PFNGLVERTEXATTRIBI1IVPROC glad_glVertexAttribI1iv;
++#define glVertexAttribI1iv glad_glVertexAttribI1iv
++typedef void (APIENTRYP PFNGLVERTEXATTRIBI2IVPROC)(GLuint index, const GLint *v);
++GLAPI PFNGLVERTEXATTRIBI2IVPROC glad_glVertexAttribI2iv;
++#define glVertexAttribI2iv glad_glVertexAttribI2iv
++typedef void (APIENTRYP PFNGLVERTEXATTRIBI3IVPROC)(GLuint index, const GLint *v);
++GLAPI PFNGLVERTEXATTRIBI3IVPROC glad_glVertexAttribI3iv;
++#define glVertexAttribI3iv glad_glVertexAttribI3iv
++typedef void (APIENTRYP PFNGLVERTEXATTRIBI4IVPROC)(GLuint index, const GLint *v);
++GLAPI PFNGLVERTEXATTRIBI4IVPROC glad_glVertexAttribI4iv;
++#define glVertexAttribI4iv glad_glVertexAttribI4iv
++typedef void (APIENTRYP PFNGLVERTEXATTRIBI1UIVPROC)(GLuint index, const GLuint *v);
++GLAPI PFNGLVERTEXATTRIBI1UIVPROC glad_glVertexAttribI1uiv;
++#define glVertexAttribI1uiv glad_glVertexAttribI1uiv
++typedef void (APIENTRYP PFNGLVERTEXATTRIBI2UIVPROC)(GLuint index, const GLuint *v);
++GLAPI PFNGLVERTEXATTRIBI2UIVPROC glad_glVertexAttribI2uiv;
++#define glVertexAttribI2uiv glad_glVertexAttribI2uiv
++typedef void (APIENTRYP PFNGLVERTEXATTRIBI3UIVPROC)(GLuint index, const GLuint *v);
++GLAPI PFNGLVERTEXATTRIBI3UIVPROC glad_glVertexAttribI3uiv;
++#define glVertexAttribI3uiv glad_glVertexAttribI3uiv
++typedef void (APIENTRYP PFNGLVERTEXATTRIBI4UIVPROC)(GLuint index, const GLuint *v);
++GLAPI PFNGLVERTEXATTRIBI4UIVPROC glad_glVertexAttribI4uiv;
++#define glVertexAttribI4uiv glad_glVertexAttribI4uiv
++typedef void (APIENTRYP PFNGLVERTEXATTRIBI4BVPROC)(GLuint index, const GLbyte *v);
++GLAPI PFNGLVERTEXATTRIBI4BVPROC glad_glVertexAttribI4bv;
++#define glVertexAttribI4bv glad_glVertexAttribI4bv
++typedef void (APIENTRYP PFNGLVERTEXATTRIBI4SVPROC)(GLuint index, const GLshort *v);
++GLAPI PFNGLVERTEXATTRIBI4SVPROC glad_glVertexAttribI4sv;
++#define glVertexAttribI4sv glad_glVertexAttribI4sv
++typedef void (APIENTRYP PFNGLVERTEXATTRIBI4UBVPROC)(GLuint index, const GLubyte *v);
++GLAPI PFNGLVERTEXATTRIBI4UBVPROC glad_glVertexAttribI4ubv;
++#define glVertexAttribI4ubv glad_glVertexAttribI4ubv
++typedef void (APIENTRYP PFNGLVERTEXATTRIBI4USVPROC)(GLuint index, const GLushort *v);
++GLAPI PFNGLVERTEXATTRIBI4USVPROC glad_glVertexAttribI4usv;
++#define glVertexAttribI4usv glad_glVertexAttribI4usv
++typedef void (APIENTRYP PFNGLGETUNIFORMUIVPROC)(GLuint program, GLint location, GLuint *params);
++GLAPI PFNGLGETUNIFORMUIVPROC glad_glGetUniformuiv;
++#define glGetUniformuiv glad_glGetUniformuiv
++typedef void (APIENTRYP PFNGLBINDFRAGDATALOCATIONPROC)(GLuint program, GLuint color, const GLchar *name);
++GLAPI PFNGLBINDFRAGDATALOCATIONPROC glad_glBindFragDataLocation;
++#define glBindFragDataLocation glad_glBindFragDataLocation
++typedef GLint(APIENTRYP PFNGLGETFRAGDATALOCATIONPROC)(GLuint program, const GLchar *name);
++GLAPI PFNGLGETFRAGDATALOCATIONPROC glad_glGetFragDataLocation;
++#define glGetFragDataLocation glad_glGetFragDataLocation
++typedef void (APIENTRYP PFNGLUNIFORM1UIPROC)(GLint location, GLuint v0);
++GLAPI PFNGLUNIFORM1UIPROC glad_glUniform1ui;
++#define glUniform1ui glad_glUniform1ui
++typedef void (APIENTRYP PFNGLUNIFORM2UIPROC)(GLint location, GLuint v0, GLuint v1);
++GLAPI PFNGLUNIFORM2UIPROC glad_glUniform2ui;
++#define glUniform2ui glad_glUniform2ui
++typedef void (APIENTRYP PFNGLUNIFORM3UIPROC)(GLint location, GLuint v0, GLuint v1, GLuint v2);
++GLAPI PFNGLUNIFORM3UIPROC glad_glUniform3ui;
++#define glUniform3ui glad_glUniform3ui
++typedef void (APIENTRYP PFNGLUNIFORM4UIPROC)(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
++GLAPI PFNGLUNIFORM4UIPROC glad_glUniform4ui;
++#define glUniform4ui glad_glUniform4ui
++typedef void (APIENTRYP PFNGLUNIFORM1UIVPROC)(GLint location, GLsizei count, const GLuint *value);
++GLAPI PFNGLUNIFORM1UIVPROC glad_glUniform1uiv;
++#define glUniform1uiv glad_glUniform1uiv
++typedef void (APIENTRYP PFNGLUNIFORM2UIVPROC)(GLint location, GLsizei count, const GLuint *value);
++GLAPI PFNGLUNIFORM2UIVPROC glad_glUniform2uiv;
++#define glUniform2uiv glad_glUniform2uiv
++typedef void (APIENTRYP PFNGLUNIFORM3UIVPROC)(GLint location, GLsizei count, const GLuint *value);
++GLAPI PFNGLUNIFORM3UIVPROC glad_glUniform3uiv;
++#define glUniform3uiv glad_glUniform3uiv
++typedef void (APIENTRYP PFNGLUNIFORM4UIVPROC)(GLint location, GLsizei count, const GLuint *value);
++GLAPI PFNGLUNIFORM4UIVPROC glad_glUniform4uiv;
++#define glUniform4uiv glad_glUniform4uiv
++typedef void (APIENTRYP PFNGLTEXPARAMETERIIVPROC)(GLenum target, GLenum pname, const GLint *params);
++GLAPI PFNGLTEXPARAMETERIIVPROC glad_glTexParameterIiv;
++#define glTexParameterIiv glad_glTexParameterIiv
++typedef void (APIENTRYP PFNGLTEXPARAMETERIUIVPROC)(GLenum target, GLenum pname, const GLuint *params);
++GLAPI PFNGLTEXPARAMETERIUIVPROC glad_glTexParameterIuiv;
++#define glTexParameterIuiv glad_glTexParameterIuiv
++typedef void (APIENTRYP PFNGLGETTEXPARAMETERIIVPROC)(GLenum target, GLenum pname, GLint *params);
++GLAPI PFNGLGETTEXPARAMETERIIVPROC glad_glGetTexParameterIiv;
++#define glGetTexParameterIiv glad_glGetTexParameterIiv
++typedef void (APIENTRYP PFNGLGETTEXPARAMETERIUIVPROC)(GLenum target, GLenum pname, GLuint *params);
++GLAPI PFNGLGETTEXPARAMETERIUIVPROC glad_glGetTexParameterIuiv;
++#define glGetTexParameterIuiv glad_glGetTexParameterIuiv
++typedef void (APIENTRYP PFNGLCLEARBUFFERIVPROC)(GLenum buffer, GLint drawbuffer, const GLint *value);
++GLAPI PFNGLCLEARBUFFERIVPROC glad_glClearBufferiv;
++#define glClearBufferiv glad_glClearBufferiv
++typedef void (APIENTRYP PFNGLCLEARBUFFERUIVPROC)(GLenum buffer, GLint drawbuffer, const GLuint *value);
++GLAPI PFNGLCLEARBUFFERUIVPROC glad_glClearBufferuiv;
++#define glClearBufferuiv glad_glClearBufferuiv
++typedef void (APIENTRYP PFNGLCLEARBUFFERFVPROC)(GLenum buffer, GLint drawbuffer, const GLfloat *value);
++GLAPI PFNGLCLEARBUFFERFVPROC glad_glClearBufferfv;
++#define glClearBufferfv glad_glClearBufferfv
++typedef void (APIENTRYP PFNGLCLEARBUFFERFIPROC)(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil);
++GLAPI PFNGLCLEARBUFFERFIPROC glad_glClearBufferfi;
++#define glClearBufferfi glad_glClearBufferfi
++typedef const GLubyte *(APIENTRYP PFNGLGETSTRINGIPROC)(GLenum name, GLuint index);
++GLAPI PFNGLGETSTRINGIPROC glad_glGetStringi;
++#define glGetStringi glad_glGetStringi
++typedef GLboolean(APIENTRYP PFNGLISRENDERBUFFERPROC)(GLuint renderbuffer);
++GLAPI PFNGLISRENDERBUFFERPROC glad_glIsRenderbuffer;
++#define glIsRenderbuffer glad_glIsRenderbuffer
++typedef void (APIENTRYP PFNGLBINDRENDERBUFFERPROC)(GLenum target, GLuint renderbuffer);
++GLAPI PFNGLBINDRENDERBUFFERPROC glad_glBindRenderbuffer;
++#define glBindRenderbuffer glad_glBindRenderbuffer
++typedef void (APIENTRYP PFNGLDELETERENDERBUFFERSPROC)(GLsizei n, const GLuint *renderbuffers);
++GLAPI PFNGLDELETERENDERBUFFERSPROC glad_glDeleteRenderbuffers;
++#define glDeleteRenderbuffers glad_glDeleteRenderbuffers
++typedef void (APIENTRYP PFNGLGENRENDERBUFFERSPROC)(GLsizei n, GLuint *renderbuffers);
++GLAPI PFNGLGENRENDERBUFFERSPROC glad_glGenRenderbuffers;
++#define glGenRenderbuffers glad_glGenRenderbuffers
++typedef void (APIENTRYP PFNGLRENDERBUFFERSTORAGEPROC)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
++GLAPI PFNGLRENDERBUFFERSTORAGEPROC glad_glRenderbufferStorage;
++#define glRenderbufferStorage glad_glRenderbufferStorage
++typedef void (APIENTRYP PFNGLGETRENDERBUFFERPARAMETERIVPROC)(GLenum target, GLenum pname, GLint *params);
++GLAPI PFNGLGETRENDERBUFFERPARAMETERIVPROC glad_glGetRenderbufferParameteriv;
++#define glGetRenderbufferParameteriv glad_glGetRenderbufferParameteriv
++typedef GLboolean(APIENTRYP PFNGLISFRAMEBUFFERPROC)(GLuint framebuffer);
++GLAPI PFNGLISFRAMEBUFFERPROC glad_glIsFramebuffer;
++#define glIsFramebuffer glad_glIsFramebuffer
++typedef void (APIENTRYP PFNGLBINDFRAMEBUFFERPROC)(GLenum target, GLuint framebuffer);
++GLAPI PFNGLBINDFRAMEBUFFERPROC glad_glBindFramebuffer;
++#define glBindFramebuffer glad_glBindFramebuffer
++typedef void (APIENTRYP PFNGLDELETEFRAMEBUFFERSPROC)(GLsizei n, const GLuint *framebuffers);
++GLAPI PFNGLDELETEFRAMEBUFFERSPROC glad_glDeleteFramebuffers;
++#define glDeleteFramebuffers glad_glDeleteFramebuffers
++typedef void (APIENTRYP PFNGLGENFRAMEBUFFERSPROC)(GLsizei n, GLuint *framebuffers);
++GLAPI PFNGLGENFRAMEBUFFERSPROC glad_glGenFramebuffers;
++#define glGenFramebuffers glad_glGenFramebuffers
++typedef GLenum(APIENTRYP PFNGLCHECKFRAMEBUFFERSTATUSPROC)(GLenum target);
++GLAPI PFNGLCHECKFRAMEBUFFERSTATUSPROC glad_glCheckFramebufferStatus;
++#define glCheckFramebufferStatus glad_glCheckFramebufferStatus
++typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURE1DPROC)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
++GLAPI PFNGLFRAMEBUFFERTEXTURE1DPROC glad_glFramebufferTexture1D;
++#define glFramebufferTexture1D glad_glFramebufferTexture1D
++typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURE2DPROC)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
++GLAPI PFNGLFRAMEBUFFERTEXTURE2DPROC glad_glFramebufferTexture2D;
++#define glFramebufferTexture2D glad_glFramebufferTexture2D
++typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURE3DPROC)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level,
++ GLint zoffset);
++GLAPI PFNGLFRAMEBUFFERTEXTURE3DPROC glad_glFramebufferTexture3D;
++#define glFramebufferTexture3D glad_glFramebufferTexture3D
++typedef void (APIENTRYP PFNGLFRAMEBUFFERRENDERBUFFERPROC)(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
++GLAPI PFNGLFRAMEBUFFERRENDERBUFFERPROC glad_glFramebufferRenderbuffer;
++#define glFramebufferRenderbuffer glad_glFramebufferRenderbuffer
++typedef void (APIENTRYP PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC)(GLenum target, GLenum attachment, GLenum pname, GLint *params);
++GLAPI PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC glad_glGetFramebufferAttachmentParameteriv;
++#define glGetFramebufferAttachmentParameteriv glad_glGetFramebufferAttachmentParameteriv
++typedef void (APIENTRYP PFNGLGENERATEMIPMAPPROC)(GLenum target);
++GLAPI PFNGLGENERATEMIPMAPPROC glad_glGenerateMipmap;
++#define glGenerateMipmap glad_glGenerateMipmap
++typedef void (APIENTRYP PFNGLBLITFRAMEBUFFERPROC)(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1,
++ GLint dstY1, GLbitfield mask, GLenum filter);
++GLAPI PFNGLBLITFRAMEBUFFERPROC glad_glBlitFramebuffer;
++#define glBlitFramebuffer glad_glBlitFramebuffer
++typedef void (APIENTRYP PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width,
++ GLsizei height);
++GLAPI PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC glad_glRenderbufferStorageMultisample;
++#define glRenderbufferStorageMultisample glad_glRenderbufferStorageMultisample
++typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURELAYERPROC)(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer);
++GLAPI PFNGLFRAMEBUFFERTEXTURELAYERPROC glad_glFramebufferTextureLayer;
++#define glFramebufferTextureLayer glad_glFramebufferTextureLayer
++typedef void *(APIENTRYP PFNGLMAPBUFFERRANGEPROC)(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access);
++GLAPI PFNGLMAPBUFFERRANGEPROC glad_glMapBufferRange;
++#define glMapBufferRange glad_glMapBufferRange
++typedef void (APIENTRYP PFNGLFLUSHMAPPEDBUFFERRANGEPROC)(GLenum target, GLintptr offset, GLsizeiptr length);
++GLAPI PFNGLFLUSHMAPPEDBUFFERRANGEPROC glad_glFlushMappedBufferRange;
++#define glFlushMappedBufferRange glad_glFlushMappedBufferRange
++typedef void (APIENTRYP PFNGLBINDVERTEXARRAYPROC)(GLuint array);
++GLAPI PFNGLBINDVERTEXARRAYPROC glad_glBindVertexArray;
++#define glBindVertexArray glad_glBindVertexArray
++typedef void (APIENTRYP PFNGLDELETEVERTEXARRAYSPROC)(GLsizei n, const GLuint *arrays);
++GLAPI PFNGLDELETEVERTEXARRAYSPROC glad_glDeleteVertexArrays;
++#define glDeleteVertexArrays glad_glDeleteVertexArrays
++typedef void (APIENTRYP PFNGLGENVERTEXARRAYSPROC)(GLsizei n, GLuint *arrays);
++GLAPI PFNGLGENVERTEXARRAYSPROC glad_glGenVertexArrays;
++#define glGenVertexArrays glad_glGenVertexArrays
++typedef GLboolean(APIENTRYP PFNGLISVERTEXARRAYPROC)(GLuint array);
++GLAPI PFNGLISVERTEXARRAYPROC glad_glIsVertexArray;
++#define glIsVertexArray glad_glIsVertexArray
++#endif
++#ifndef GL_VERSION_3_1
++#define GL_VERSION_3_1 1
++GLAPI int GLAD_GL_VERSION_3_1;
++typedef void (APIENTRYP PFNGLDRAWARRAYSINSTANCEDPROC)(GLenum mode, GLint first, GLsizei count, GLsizei instancecount);
++GLAPI PFNGLDRAWARRAYSINSTANCEDPROC glad_glDrawArraysInstanced;
++#define glDrawArraysInstanced glad_glDrawArraysInstanced
++typedef void (APIENTRYP PFNGLDRAWELEMENTSINSTANCEDPROC)(GLenum mode, GLsizei count, GLenum type, const void *indices,
++ GLsizei instancecount);
++GLAPI PFNGLDRAWELEMENTSINSTANCEDPROC glad_glDrawElementsInstanced;
++#define glDrawElementsInstanced glad_glDrawElementsInstanced
++typedef void (APIENTRYP PFNGLTEXBUFFERPROC)(GLenum target, GLenum internalformat, GLuint buffer);
++GLAPI PFNGLTEXBUFFERPROC glad_glTexBuffer;
++#define glTexBuffer glad_glTexBuffer
++typedef void (APIENTRYP PFNGLPRIMITIVERESTARTINDEXPROC)(GLuint index);
++GLAPI PFNGLPRIMITIVERESTARTINDEXPROC glad_glPrimitiveRestartIndex;
++#define glPrimitiveRestartIndex glad_glPrimitiveRestartIndex
++typedef void (APIENTRYP PFNGLCOPYBUFFERSUBDATAPROC)(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset,
++ GLsizeiptr size);
++GLAPI PFNGLCOPYBUFFERSUBDATAPROC glad_glCopyBufferSubData;
++#define glCopyBufferSubData glad_glCopyBufferSubData
++typedef void (APIENTRYP PFNGLGETUNIFORMINDICESPROC)(GLuint program, GLsizei uniformCount, const GLchar *const *uniformNames,
++ GLuint *uniformIndices);
++GLAPI PFNGLGETUNIFORMINDICESPROC glad_glGetUniformIndices;
++#define glGetUniformIndices glad_glGetUniformIndices
++typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMSIVPROC)(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname,
++ GLint *params);
++GLAPI PFNGLGETACTIVEUNIFORMSIVPROC glad_glGetActiveUniformsiv;
++#define glGetActiveUniformsiv glad_glGetActiveUniformsiv
++typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMNAMEPROC)(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length,
++ GLchar *uniformName);
++GLAPI PFNGLGETACTIVEUNIFORMNAMEPROC glad_glGetActiveUniformName;
++#define glGetActiveUniformName glad_glGetActiveUniformName
++typedef GLuint(APIENTRYP PFNGLGETUNIFORMBLOCKINDEXPROC)(GLuint program, const GLchar *uniformBlockName);
++GLAPI PFNGLGETUNIFORMBLOCKINDEXPROC glad_glGetUniformBlockIndex;
++#define glGetUniformBlockIndex glad_glGetUniformBlockIndex
++typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMBLOCKIVPROC)(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params);
++GLAPI PFNGLGETACTIVEUNIFORMBLOCKIVPROC glad_glGetActiveUniformBlockiv;
++#define glGetActiveUniformBlockiv glad_glGetActiveUniformBlockiv
++typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC)(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length,
++ GLchar *uniformBlockName);
++GLAPI PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC glad_glGetActiveUniformBlockName;
++#define glGetActiveUniformBlockName glad_glGetActiveUniformBlockName
++typedef void (APIENTRYP PFNGLUNIFORMBLOCKBINDINGPROC)(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding);
++GLAPI PFNGLUNIFORMBLOCKBINDINGPROC glad_glUniformBlockBinding;
++#define glUniformBlockBinding glad_glUniformBlockBinding
++#endif
++#ifndef GL_VERSION_3_2
++#define GL_VERSION_3_2 1
++GLAPI int GLAD_GL_VERSION_3_2;
++typedef void (APIENTRYP PFNGLDRAWELEMENTSBASEVERTEXPROC)(GLenum mode, GLsizei count, GLenum type, const void *indices, GLint basevertex);
++GLAPI PFNGLDRAWELEMENTSBASEVERTEXPROC glad_glDrawElementsBaseVertex;
++#define glDrawElementsBaseVertex glad_glDrawElementsBaseVertex
++typedef void (APIENTRYP PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type,
++ const void *indices, GLint basevertex);
++GLAPI PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC glad_glDrawRangeElementsBaseVertex;
++#define glDrawRangeElementsBaseVertex glad_glDrawRangeElementsBaseVertex
++typedef void (APIENTRYP PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC)(GLenum mode, GLsizei count, GLenum type, const void *indices,
++ GLsizei instancecount, GLint basevertex);
++GLAPI PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC glad_glDrawElementsInstancedBaseVertex;
++#define glDrawElementsInstancedBaseVertex glad_glDrawElementsInstancedBaseVertex
++typedef void (APIENTRYP PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC)(GLenum mode, const GLsizei *count, GLenum type, const void *const *indices,
++ GLsizei drawcount, const GLint *basevertex);
++GLAPI PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC glad_glMultiDrawElementsBaseVertex;
++#define glMultiDrawElementsBaseVertex glad_glMultiDrawElementsBaseVertex
++typedef void (APIENTRYP PFNGLPROVOKINGVERTEXPROC)(GLenum mode);
++GLAPI PFNGLPROVOKINGVERTEXPROC glad_glProvokingVertex;
++#define glProvokingVertex glad_glProvokingVertex
++typedef GLsync(APIENTRYP PFNGLFENCESYNCPROC)(GLenum condition, GLbitfield flags);
++GLAPI PFNGLFENCESYNCPROC glad_glFenceSync;
++#define glFenceSync glad_glFenceSync
++typedef GLboolean(APIENTRYP PFNGLISSYNCPROC)(GLsync sync);
++GLAPI PFNGLISSYNCPROC glad_glIsSync;
++#define glIsSync glad_glIsSync
++typedef void (APIENTRYP PFNGLDELETESYNCPROC)(GLsync sync);
++GLAPI PFNGLDELETESYNCPROC glad_glDeleteSync;
++#define glDeleteSync glad_glDeleteSync
++typedef GLenum(APIENTRYP PFNGLCLIENTWAITSYNCPROC)(GLsync sync, GLbitfield flags, GLuint64 timeout);
++GLAPI PFNGLCLIENTWAITSYNCPROC glad_glClientWaitSync;
++#define glClientWaitSync glad_glClientWaitSync
++typedef void (APIENTRYP PFNGLWAITSYNCPROC)(GLsync sync, GLbitfield flags, GLuint64 timeout);
++GLAPI PFNGLWAITSYNCPROC glad_glWaitSync;
++#define glWaitSync glad_glWaitSync
++typedef void (APIENTRYP PFNGLGETINTEGER64VPROC)(GLenum pname, GLint64 *data);
++GLAPI PFNGLGETINTEGER64VPROC glad_glGetInteger64v;
++#define glGetInteger64v glad_glGetInteger64v
++typedef void (APIENTRYP PFNGLGETSYNCIVPROC)(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values);
++GLAPI PFNGLGETSYNCIVPROC glad_glGetSynciv;
++#define glGetSynciv glad_glGetSynciv
++typedef void (APIENTRYP PFNGLGETINTEGER64I_VPROC)(GLenum target, GLuint index, GLint64 *data);
++GLAPI PFNGLGETINTEGER64I_VPROC glad_glGetInteger64i_v;
++#define glGetInteger64i_v glad_glGetInteger64i_v
++typedef void (APIENTRYP PFNGLGETBUFFERPARAMETERI64VPROC)(GLenum target, GLenum pname, GLint64 *params);
++GLAPI PFNGLGETBUFFERPARAMETERI64VPROC glad_glGetBufferParameteri64v;
++#define glGetBufferParameteri64v glad_glGetBufferParameteri64v
++typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTUREPROC)(GLenum target, GLenum attachment, GLuint texture, GLint level);
++GLAPI PFNGLFRAMEBUFFERTEXTUREPROC glad_glFramebufferTexture;
++#define glFramebufferTexture glad_glFramebufferTexture
++typedef void (APIENTRYP PFNGLTEXIMAGE2DMULTISAMPLEPROC)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width,
++ GLsizei height, GLboolean fixedsamplelocations);
++GLAPI PFNGLTEXIMAGE2DMULTISAMPLEPROC glad_glTexImage2DMultisample;
++#define glTexImage2DMultisample glad_glTexImage2DMultisample
++typedef void (APIENTRYP PFNGLTEXIMAGE3DMULTISAMPLEPROC)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width,
++ GLsizei height, GLsizei depth, GLboolean fixedsamplelocations);
++GLAPI PFNGLTEXIMAGE3DMULTISAMPLEPROC glad_glTexImage3DMultisample;
++#define glTexImage3DMultisample glad_glTexImage3DMultisample
++typedef void (APIENTRYP PFNGLGETMULTISAMPLEFVPROC)(GLenum pname, GLuint index, GLfloat *val);
++GLAPI PFNGLGETMULTISAMPLEFVPROC glad_glGetMultisamplefv;
++#define glGetMultisamplefv glad_glGetMultisamplefv
++typedef void (APIENTRYP PFNGLSAMPLEMASKIPROC)(GLuint maskNumber, GLbitfield mask);
++GLAPI PFNGLSAMPLEMASKIPROC glad_glSampleMaski;
++#define glSampleMaski glad_glSampleMaski
++#endif
++#ifndef GL_VERSION_3_3
++#define GL_VERSION_3_3 1
++GLAPI int GLAD_GL_VERSION_3_3;
++typedef void (APIENTRYP PFNGLBINDFRAGDATALOCATIONINDEXEDPROC)(GLuint program, GLuint colorNumber, GLuint index, const GLchar *name);
++GLAPI PFNGLBINDFRAGDATALOCATIONINDEXEDPROC glad_glBindFragDataLocationIndexed;
++#define glBindFragDataLocationIndexed glad_glBindFragDataLocationIndexed
++typedef GLint(APIENTRYP PFNGLGETFRAGDATAINDEXPROC)(GLuint program, const GLchar *name);
++GLAPI PFNGLGETFRAGDATAINDEXPROC glad_glGetFragDataIndex;
++#define glGetFragDataIndex glad_glGetFragDataIndex
++typedef void (APIENTRYP PFNGLGENSAMPLERSPROC)(GLsizei count, GLuint *samplers);
++GLAPI PFNGLGENSAMPLERSPROC glad_glGenSamplers;
++#define glGenSamplers glad_glGenSamplers
++typedef void (APIENTRYP PFNGLDELETESAMPLERSPROC)(GLsizei count, const GLuint *samplers);
++GLAPI PFNGLDELETESAMPLERSPROC glad_glDeleteSamplers;
++#define glDeleteSamplers glad_glDeleteSamplers
++typedef GLboolean(APIENTRYP PFNGLISSAMPLERPROC)(GLuint sampler);
++GLAPI PFNGLISSAMPLERPROC glad_glIsSampler;
++#define glIsSampler glad_glIsSampler
++typedef void (APIENTRYP PFNGLBINDSAMPLERPROC)(GLuint unit, GLuint sampler);
++GLAPI PFNGLBINDSAMPLERPROC glad_glBindSampler;
++#define glBindSampler glad_glBindSampler
++typedef void (APIENTRYP PFNGLSAMPLERPARAMETERIPROC)(GLuint sampler, GLenum pname, GLint param);
++GLAPI PFNGLSAMPLERPARAMETERIPROC glad_glSamplerParameteri;
++#define glSamplerParameteri glad_glSamplerParameteri
++typedef void (APIENTRYP PFNGLSAMPLERPARAMETERIVPROC)(GLuint sampler, GLenum pname, const GLint *param);
++GLAPI PFNGLSAMPLERPARAMETERIVPROC glad_glSamplerParameteriv;
++#define glSamplerParameteriv glad_glSamplerParameteriv
++typedef void (APIENTRYP PFNGLSAMPLERPARAMETERFPROC)(GLuint sampler, GLenum pname, GLfloat param);
++GLAPI PFNGLSAMPLERPARAMETERFPROC glad_glSamplerParameterf;
++#define glSamplerParameterf glad_glSamplerParameterf
++typedef void (APIENTRYP PFNGLSAMPLERPARAMETERFVPROC)(GLuint sampler, GLenum pname, const GLfloat *param);
++GLAPI PFNGLSAMPLERPARAMETERFVPROC glad_glSamplerParameterfv;
++#define glSamplerParameterfv glad_glSamplerParameterfv
++typedef void (APIENTRYP PFNGLSAMPLERPARAMETERIIVPROC)(GLuint sampler, GLenum pname, const GLint *param);
++GLAPI PFNGLSAMPLERPARAMETERIIVPROC glad_glSamplerParameterIiv;
++#define glSamplerParameterIiv glad_glSamplerParameterIiv
++typedef void (APIENTRYP PFNGLSAMPLERPARAMETERIUIVPROC)(GLuint sampler, GLenum pname, const GLuint *param);
++GLAPI PFNGLSAMPLERPARAMETERIUIVPROC glad_glSamplerParameterIuiv;
++#define glSamplerParameterIuiv glad_glSamplerParameterIuiv
++typedef void (APIENTRYP PFNGLGETSAMPLERPARAMETERIVPROC)(GLuint sampler, GLenum pname, GLint *params);
++GLAPI PFNGLGETSAMPLERPARAMETERIVPROC glad_glGetSamplerParameteriv;
++#define glGetSamplerParameteriv glad_glGetSamplerParameteriv
++typedef void (APIENTRYP PFNGLGETSAMPLERPARAMETERIIVPROC)(GLuint sampler, GLenum pname, GLint *params);
++GLAPI PFNGLGETSAMPLERPARAMETERIIVPROC glad_glGetSamplerParameterIiv;
++#define glGetSamplerParameterIiv glad_glGetSamplerParameterIiv
++typedef void (APIENTRYP PFNGLGETSAMPLERPARAMETERFVPROC)(GLuint sampler, GLenum pname, GLfloat *params);
++GLAPI PFNGLGETSAMPLERPARAMETERFVPROC glad_glGetSamplerParameterfv;
++#define glGetSamplerParameterfv glad_glGetSamplerParameterfv
++typedef void (APIENTRYP PFNGLGETSAMPLERPARAMETERIUIVPROC)(GLuint sampler, GLenum pname, GLuint *params);
++GLAPI PFNGLGETSAMPLERPARAMETERIUIVPROC glad_glGetSamplerParameterIuiv;
++#define glGetSamplerParameterIuiv glad_glGetSamplerParameterIuiv
++typedef void (APIENTRYP PFNGLQUERYCOUNTERPROC)(GLuint id, GLenum target);
++GLAPI PFNGLQUERYCOUNTERPROC glad_glQueryCounter;
++#define glQueryCounter glad_glQueryCounter
++typedef void (APIENTRYP PFNGLGETQUERYOBJECTI64VPROC)(GLuint id, GLenum pname, GLint64 *params);
++GLAPI PFNGLGETQUERYOBJECTI64VPROC glad_glGetQueryObjecti64v;
++#define glGetQueryObjecti64v glad_glGetQueryObjecti64v
++typedef void (APIENTRYP PFNGLGETQUERYOBJECTUI64VPROC)(GLuint id, GLenum pname, GLuint64 *params);
++GLAPI PFNGLGETQUERYOBJECTUI64VPROC glad_glGetQueryObjectui64v;
++#define glGetQueryObjectui64v glad_glGetQueryObjectui64v
++typedef void (APIENTRYP PFNGLVERTEXATTRIBDIVISORPROC)(GLuint index, GLuint divisor);
++GLAPI PFNGLVERTEXATTRIBDIVISORPROC glad_glVertexAttribDivisor;
++#define glVertexAttribDivisor glad_glVertexAttribDivisor
++typedef void (APIENTRYP PFNGLVERTEXATTRIBP1UIPROC)(GLuint index, GLenum type, GLboolean normalized, GLuint value);
++GLAPI PFNGLVERTEXATTRIBP1UIPROC glad_glVertexAttribP1ui;
++#define glVertexAttribP1ui glad_glVertexAttribP1ui
++typedef void (APIENTRYP PFNGLVERTEXATTRIBP1UIVPROC)(GLuint index, GLenum type, GLboolean normalized, const GLuint *value);
++GLAPI PFNGLVERTEXATTRIBP1UIVPROC glad_glVertexAttribP1uiv;
++#define glVertexAttribP1uiv glad_glVertexAttribP1uiv
++typedef void (APIENTRYP PFNGLVERTEXATTRIBP2UIPROC)(GLuint index, GLenum type, GLboolean normalized, GLuint value);
++GLAPI PFNGLVERTEXATTRIBP2UIPROC glad_glVertexAttribP2ui;
++#define glVertexAttribP2ui glad_glVertexAttribP2ui
++typedef void (APIENTRYP PFNGLVERTEXATTRIBP2UIVPROC)(GLuint index, GLenum type, GLboolean normalized, const GLuint *value);
++GLAPI PFNGLVERTEXATTRIBP2UIVPROC glad_glVertexAttribP2uiv;
++#define glVertexAttribP2uiv glad_glVertexAttribP2uiv
++typedef void (APIENTRYP PFNGLVERTEXATTRIBP3UIPROC)(GLuint index, GLenum type, GLboolean normalized, GLuint value);
++GLAPI PFNGLVERTEXATTRIBP3UIPROC glad_glVertexAttribP3ui;
++#define glVertexAttribP3ui glad_glVertexAttribP3ui
++typedef void (APIENTRYP PFNGLVERTEXATTRIBP3UIVPROC)(GLuint index, GLenum type, GLboolean normalized, const GLuint *value);
++GLAPI PFNGLVERTEXATTRIBP3UIVPROC glad_glVertexAttribP3uiv;
++#define glVertexAttribP3uiv glad_glVertexAttribP3uiv
++typedef void (APIENTRYP PFNGLVERTEXATTRIBP4UIPROC)(GLuint index, GLenum type, GLboolean normalized, GLuint value);
++GLAPI PFNGLVERTEXATTRIBP4UIPROC glad_glVertexAttribP4ui;
++#define glVertexAttribP4ui glad_glVertexAttribP4ui
++typedef void (APIENTRYP PFNGLVERTEXATTRIBP4UIVPROC)(GLuint index, GLenum type, GLboolean normalized, const GLuint *value);
++GLAPI PFNGLVERTEXATTRIBP4UIVPROC glad_glVertexAttribP4uiv;
++#define glVertexAttribP4uiv glad_glVertexAttribP4uiv
++typedef void (APIENTRYP PFNGLVERTEXP2UIPROC)(GLenum type, GLuint value);
++GLAPI PFNGLVERTEXP2UIPROC glad_glVertexP2ui;
++#define glVertexP2ui glad_glVertexP2ui
++typedef void (APIENTRYP PFNGLVERTEXP2UIVPROC)(GLenum type, const GLuint *value);
++GLAPI PFNGLVERTEXP2UIVPROC glad_glVertexP2uiv;
++#define glVertexP2uiv glad_glVertexP2uiv
++typedef void (APIENTRYP PFNGLVERTEXP3UIPROC)(GLenum type, GLuint value);
++GLAPI PFNGLVERTEXP3UIPROC glad_glVertexP3ui;
++#define glVertexP3ui glad_glVertexP3ui
++typedef void (APIENTRYP PFNGLVERTEXP3UIVPROC)(GLenum type, const GLuint *value);
++GLAPI PFNGLVERTEXP3UIVPROC glad_glVertexP3uiv;
++#define glVertexP3uiv glad_glVertexP3uiv
++typedef void (APIENTRYP PFNGLVERTEXP4UIPROC)(GLenum type, GLuint value);
++GLAPI PFNGLVERTEXP4UIPROC glad_glVertexP4ui;
++#define glVertexP4ui glad_glVertexP4ui
++typedef void (APIENTRYP PFNGLVERTEXP4UIVPROC)(GLenum type, const GLuint *value);
++GLAPI PFNGLVERTEXP4UIVPROC glad_glVertexP4uiv;
++#define glVertexP4uiv glad_glVertexP4uiv
++typedef void (APIENTRYP PFNGLTEXCOORDP1UIPROC)(GLenum type, GLuint coords);
++GLAPI PFNGLTEXCOORDP1UIPROC glad_glTexCoordP1ui;
++#define glTexCoordP1ui glad_glTexCoordP1ui
++typedef void (APIENTRYP PFNGLTEXCOORDP1UIVPROC)(GLenum type, const GLuint *coords);
++GLAPI PFNGLTEXCOORDP1UIVPROC glad_glTexCoordP1uiv;
++#define glTexCoordP1uiv glad_glTexCoordP1uiv
++typedef void (APIENTRYP PFNGLTEXCOORDP2UIPROC)(GLenum type, GLuint coords);
++GLAPI PFNGLTEXCOORDP2UIPROC glad_glTexCoordP2ui;
++#define glTexCoordP2ui glad_glTexCoordP2ui
++typedef void (APIENTRYP PFNGLTEXCOORDP2UIVPROC)(GLenum type, const GLuint *coords);
++GLAPI PFNGLTEXCOORDP2UIVPROC glad_glTexCoordP2uiv;
++#define glTexCoordP2uiv glad_glTexCoordP2uiv
++typedef void (APIENTRYP PFNGLTEXCOORDP3UIPROC)(GLenum type, GLuint coords);
++GLAPI PFNGLTEXCOORDP3UIPROC glad_glTexCoordP3ui;
++#define glTexCoordP3ui glad_glTexCoordP3ui
++typedef void (APIENTRYP PFNGLTEXCOORDP3UIVPROC)(GLenum type, const GLuint *coords);
++GLAPI PFNGLTEXCOORDP3UIVPROC glad_glTexCoordP3uiv;
++#define glTexCoordP3uiv glad_glTexCoordP3uiv
++typedef void (APIENTRYP PFNGLTEXCOORDP4UIPROC)(GLenum type, GLuint coords);
++GLAPI PFNGLTEXCOORDP4UIPROC glad_glTexCoordP4ui;
++#define glTexCoordP4ui glad_glTexCoordP4ui
++typedef void (APIENTRYP PFNGLTEXCOORDP4UIVPROC)(GLenum type, const GLuint *coords);
++GLAPI PFNGLTEXCOORDP4UIVPROC glad_glTexCoordP4uiv;
++#define glTexCoordP4uiv glad_glTexCoordP4uiv
++typedef void (APIENTRYP PFNGLMULTITEXCOORDP1UIPROC)(GLenum texture, GLenum type, GLuint coords);
++GLAPI PFNGLMULTITEXCOORDP1UIPROC glad_glMultiTexCoordP1ui;
++#define glMultiTexCoordP1ui glad_glMultiTexCoordP1ui
++typedef void (APIENTRYP PFNGLMULTITEXCOORDP1UIVPROC)(GLenum texture, GLenum type, const GLuint *coords);
++GLAPI PFNGLMULTITEXCOORDP1UIVPROC glad_glMultiTexCoordP1uiv;
++#define glMultiTexCoordP1uiv glad_glMultiTexCoordP1uiv
++typedef void (APIENTRYP PFNGLMULTITEXCOORDP2UIPROC)(GLenum texture, GLenum type, GLuint coords);
++GLAPI PFNGLMULTITEXCOORDP2UIPROC glad_glMultiTexCoordP2ui;
++#define glMultiTexCoordP2ui glad_glMultiTexCoordP2ui
++typedef void (APIENTRYP PFNGLMULTITEXCOORDP2UIVPROC)(GLenum texture, GLenum type, const GLuint *coords);
++GLAPI PFNGLMULTITEXCOORDP2UIVPROC glad_glMultiTexCoordP2uiv;
++#define glMultiTexCoordP2uiv glad_glMultiTexCoordP2uiv
++typedef void (APIENTRYP PFNGLMULTITEXCOORDP3UIPROC)(GLenum texture, GLenum type, GLuint coords);
++GLAPI PFNGLMULTITEXCOORDP3UIPROC glad_glMultiTexCoordP3ui;
++#define glMultiTexCoordP3ui glad_glMultiTexCoordP3ui
++typedef void (APIENTRYP PFNGLMULTITEXCOORDP3UIVPROC)(GLenum texture, GLenum type, const GLuint *coords);
++GLAPI PFNGLMULTITEXCOORDP3UIVPROC glad_glMultiTexCoordP3uiv;
++#define glMultiTexCoordP3uiv glad_glMultiTexCoordP3uiv
++typedef void (APIENTRYP PFNGLMULTITEXCOORDP4UIPROC)(GLenum texture, GLenum type, GLuint coords);
++GLAPI PFNGLMULTITEXCOORDP4UIPROC glad_glMultiTexCoordP4ui;
++#define glMultiTexCoordP4ui glad_glMultiTexCoordP4ui
++typedef void (APIENTRYP PFNGLMULTITEXCOORDP4UIVPROC)(GLenum texture, GLenum type, const GLuint *coords);
++GLAPI PFNGLMULTITEXCOORDP4UIVPROC glad_glMultiTexCoordP4uiv;
++#define glMultiTexCoordP4uiv glad_glMultiTexCoordP4uiv
++typedef void (APIENTRYP PFNGLNORMALP3UIPROC)(GLenum type, GLuint coords);
++GLAPI PFNGLNORMALP3UIPROC glad_glNormalP3ui;
++#define glNormalP3ui glad_glNormalP3ui
++typedef void (APIENTRYP PFNGLNORMALP3UIVPROC)(GLenum type, const GLuint *coords);
++GLAPI PFNGLNORMALP3UIVPROC glad_glNormalP3uiv;
++#define glNormalP3uiv glad_glNormalP3uiv
++typedef void (APIENTRYP PFNGLCOLORP3UIPROC)(GLenum type, GLuint color);
++GLAPI PFNGLCOLORP3UIPROC glad_glColorP3ui;
++#define glColorP3ui glad_glColorP3ui
++typedef void (APIENTRYP PFNGLCOLORP3UIVPROC)(GLenum type, const GLuint *color);
++GLAPI PFNGLCOLORP3UIVPROC glad_glColorP3uiv;
++#define glColorP3uiv glad_glColorP3uiv
++typedef void (APIENTRYP PFNGLCOLORP4UIPROC)(GLenum type, GLuint color);
++GLAPI PFNGLCOLORP4UIPROC glad_glColorP4ui;
++#define glColorP4ui glad_glColorP4ui
++typedef void (APIENTRYP PFNGLCOLORP4UIVPROC)(GLenum type, const GLuint *color);
++GLAPI PFNGLCOLORP4UIVPROC glad_glColorP4uiv;
++#define glColorP4uiv glad_glColorP4uiv
++typedef void (APIENTRYP PFNGLSECONDARYCOLORP3UIPROC)(GLenum type, GLuint color);
++GLAPI PFNGLSECONDARYCOLORP3UIPROC glad_glSecondaryColorP3ui;
++#define glSecondaryColorP3ui glad_glSecondaryColorP3ui
++typedef void (APIENTRYP PFNGLSECONDARYCOLORP3UIVPROC)(GLenum type, const GLuint *color);
++GLAPI PFNGLSECONDARYCOLORP3UIVPROC glad_glSecondaryColorP3uiv;
++#define glSecondaryColorP3uiv glad_glSecondaryColorP3uiv
++#endif
++#define GL_PIXEL_PACK_BUFFER_ARB 0x88EB
++#define GL_PIXEL_UNPACK_BUFFER_ARB 0x88EC
++#define GL_PIXEL_PACK_BUFFER_BINDING_ARB 0x88ED
++#define GL_PIXEL_UNPACK_BUFFER_BINDING_ARB 0x88EF
++#ifndef GL_ARB_pixel_buffer_object
++#define GL_ARB_pixel_buffer_object 1
++GLAPI int GLAD_GL_ARB_pixel_buffer_object;
++#endif
++#ifndef GL_ARB_texture_non_power_of_two
++#define GL_ARB_texture_non_power_of_two 1
++GLAPI int GLAD_GL_ARB_texture_non_power_of_two;
++#endif
++
++#ifdef __cplusplus
++}
++#endif
++
++#endif
+Index: lives-plugins/plugins/playback/video/glad_glx.cpp
+===================================================================
+--- lives-plugins/plugins/playback/video/glad_glx.cpp (nonexistent)
++++ lives-plugins/plugins/playback/video/glad_glx.cpp (revision 2620)
+@@ -0,0 +1,312 @@
++/*
++
++ GLX loader generated by glad 0.1.13a0 on Sat Apr 29 18:30:41 2017.
++
++ Language/Generator: C/C++
++ Specification: glx
++ APIs: glx=1.4
++ Profile: -
++ Extensions:
++
++ Loader: True
++ Local files: False
++ Omit khrplatform: False
++
++ Commandline:
++ --api="glx=1.4" --generator="c" --spec="glx" --extensions=""
++ Online:
++ http://glad.dav1d.de/#language=c&specification=glx&loader=on&api=glx%3D1.4
++*/
++
++#include <stdio.h>
++#include <stdlib.h>
++#include <string.h>
++#include "glad_glx.h"
++
++static void *get_proc(const char *namez);
++
++#ifdef _WIN32
++#include <windows.h>
++static HMODULE libGL;
++
++typedef void *(APIENTRYP PFNWGLGETPROCADDRESSPROC_PRIVATE)(const char *);
++static PFNWGLGETPROCADDRESSPROC_PRIVATE gladGetProcAddressPtr;
++
++static
++int open_gl(void) {
++ libGL = LoadLibraryW(L"opengl32.dll");
++ if (libGL != NULL) {
++ gladGetProcAddressPtr = (PFNWGLGETPROCADDRESSPROC_PRIVATE)GetProcAddress(
++ libGL, "wglGetProcAddress");
++ return gladGetProcAddressPtr != NULL;
++ }
++
++ return 0;
++}
++
++static
++void close_gl(void) {
++ if (libGL != NULL) {
++ FreeLibrary(libGL);
++ libGL = NULL;
++ }
++}
++#else
++#include <dlfcn.h>
++static void *libGL;
++
++#ifndef __APPLE__
++typedef void *(APIENTRYP PFNGLXGETPROCADDRESSPROC_PRIVATE)(const char *);
++static PFNGLXGETPROCADDRESSPROC_PRIVATE gladGetProcAddressPtr;
++#endif
++
++static
++int open_gl(void) {
++#ifdef __APPLE__
++ static const char *NAMES[] = {
++ "../Frameworks/OpenGL.framework/OpenGL",
++ "/Library/Frameworks/OpenGL.framework/OpenGL",
++ "/System/Library/Frameworks/OpenGL.framework/OpenGL",
++ "/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL"
++ };
++#else
++ static const char *NAMES[] = {"libGL.so.1", "libGL.so"};
++#endif
++
++ unsigned int index = 0;
++ for (index = 0; index < (sizeof(NAMES) / sizeof(NAMES[0])); index++) {
++ libGL = dlopen(NAMES[index], RTLD_NOW | RTLD_GLOBAL);
++
++ if (libGL != NULL) {
++#ifdef __APPLE__
++ return 1;
++#else
++ gladGetProcAddressPtr = (PFNGLXGETPROCADDRESSPROC_PRIVATE)dlsym(libGL,
++ "glXGetProcAddressARB");
++ return gladGetProcAddressPtr != NULL;
++#endif
++ }
++ }
++
++ return 0;
++}
++
++static
++void close_gl() {
++ if (libGL != NULL) {
++ dlclose(libGL);
++ libGL = NULL;
++ }
++}
++#endif
++
++static
++void *get_proc(const char *namez) {
++ void *result = NULL;
++ if (libGL == NULL) return NULL;
++
++#ifndef __APPLE__
++ if (gladGetProcAddressPtr != NULL) {
++ result = gladGetProcAddressPtr(namez);
++ }
++#endif
++ if (result == NULL) {
++#ifdef _WIN32
++ result = (void *)GetProcAddress(libGL, namez);
++#else
++ result = dlsym(libGL, namez);
++#endif
++ }
++
++ return result;
++}
++
++int gladLoadGLX(Display *dpy, int screen) {
++ int status = 0;
++
++ if (open_gl()) {
++ status = gladLoadGLXLoader((GLADloadproc)get_proc, dpy, screen);
++ close_gl();
++ }
++
++ return status;
++}
++
++static Display *GLADGLXDisplay = 0;
++static int GLADGLXscreen = 0;
++
++static int get_exts(void) {
++ return 1;
++}
++
++static void free_exts(void) {
++ return;
++}
++
++static int has_ext(const char *ext) {
++ const char *terminator;
++ const char *loc;
++ const char *extensions;
++
++ if (!GLAD_GLX_VERSION_1_1)
++ return 0;
++
++ extensions = glXQueryExtensionsString(GLADGLXDisplay, GLADGLXscreen);
++
++ if (extensions == NULL || ext == NULL)
++ return 0;
++
++ while (1) {
++ loc = strstr(extensions, ext);
++ if (loc == NULL)
++ break;
++
++ terminator = loc + strlen(ext);
++ if ((loc == extensions || *(loc - 1) == ' ') &&
++ (*terminator == ' ' || *terminator == '\0')) {
++ return 1;
++ }
++ extensions = terminator;
++ }
++
++ return 0;
++}
++
++int GLAD_GLX_VERSION_1_0;
++int GLAD_GLX_VERSION_1_1;
++int GLAD_GLX_VERSION_1_2;
++int GLAD_GLX_VERSION_1_3;
++int GLAD_GLX_VERSION_1_4;
++PFNGLXGETSELECTEDEVENTPROC glad_glXGetSelectedEvent;
++PFNGLXQUERYEXTENSIONPROC glad_glXQueryExtension;
++PFNGLXMAKECURRENTPROC glad_glXMakeCurrent;
++PFNGLXSELECTEVENTPROC glad_glXSelectEvent;
++PFNGLXCREATECONTEXTPROC glad_glXCreateContext;
++PFNGLXCREATEGLXPIXMAPPROC glad_glXCreateGLXPixmap;
++PFNGLXQUERYVERSIONPROC glad_glXQueryVersion;
++PFNGLXGETCURRENTREADDRAWABLEPROC glad_glXGetCurrentReadDrawable;
++PFNGLXDESTROYPIXMAPPROC glad_glXDestroyPixmap;
++PFNGLXGETCURRENTCONTEXTPROC glad_glXGetCurrentContext;
++PFNGLXGETPROCADDRESSPROC glad_glXGetProcAddress;
++PFNGLXWAITGLPROC glad_glXWaitGL;
++PFNGLXISDIRECTPROC glad_glXIsDirect;
++PFNGLXDESTROYWINDOWPROC glad_glXDestroyWindow;
++PFNGLXCREATEWINDOWPROC glad_glXCreateWindow;
++PFNGLXCOPYCONTEXTPROC glad_glXCopyContext;
++PFNGLXCREATEPBUFFERPROC glad_glXCreatePbuffer;
++PFNGLXSWAPBUFFERSPROC glad_glXSwapBuffers;
++PFNGLXGETCURRENTDISPLAYPROC glad_glXGetCurrentDisplay;
++PFNGLXGETCURRENTDRAWABLEPROC glad_glXGetCurrentDrawable;
++PFNGLXQUERYCONTEXTPROC glad_glXQueryContext;
++PFNGLXCHOOSEVISUALPROC glad_glXChooseVisual;
++PFNGLXQUERYSERVERSTRINGPROC glad_glXQueryServerString;
++PFNGLXDESTROYCONTEXTPROC glad_glXDestroyContext;
++PFNGLXDESTROYGLXPIXMAPPROC glad_glXDestroyGLXPixmap;
++PFNGLXGETFBCONFIGATTRIBPROC glad_glXGetFBConfigAttrib;
++PFNGLXUSEXFONTPROC glad_glXUseXFont;
++PFNGLXDESTROYPBUFFERPROC glad_glXDestroyPbuffer;
++PFNGLXCHOOSEFBCONFIGPROC glad_glXChooseFBConfig;
++PFNGLXCREATENEWCONTEXTPROC glad_glXCreateNewContext;
++PFNGLXMAKECONTEXTCURRENTPROC glad_glXMakeContextCurrent;
++PFNGLXGETCONFIGPROC glad_glXGetConfig;
++PFNGLXGETFBCONFIGSPROC glad_glXGetFBConfigs;
++PFNGLXCREATEPIXMAPPROC glad_glXCreatePixmap;
++PFNGLXWAITXPROC glad_glXWaitX;
++PFNGLXGETVISUALFROMFBCONFIGPROC glad_glXGetVisualFromFBConfig;
++PFNGLXQUERYDRAWABLEPROC glad_glXQueryDrawable;
++PFNGLXQUERYEXTENSIONSSTRINGPROC glad_glXQueryExtensionsString;
++PFNGLXGETCLIENTSTRINGPROC glad_glXGetClientString;
++static void load_GLX_VERSION_1_0(GLADloadproc load) {
++ if (!GLAD_GLX_VERSION_1_0) return;
++ glad_glXChooseVisual = (PFNGLXCHOOSEVISUALPROC)load("glXChooseVisual");
++ glad_glXCreateContext = (PFNGLXCREATECONTEXTPROC)load("glXCreateContext");
++ glad_glXDestroyContext = (PFNGLXDESTROYCONTEXTPROC)load("glXDestroyContext");
++ glad_glXMakeCurrent = (PFNGLXMAKECURRENTPROC)load("glXMakeCurrent");
++ glad_glXCopyContext = (PFNGLXCOPYCONTEXTPROC)load("glXCopyContext");
++ glad_glXSwapBuffers = (PFNGLXSWAPBUFFERSPROC)load("glXSwapBuffers");
++ glad_glXCreateGLXPixmap = (PFNGLXCREATEGLXPIXMAPPROC)load("glXCreateGLXPixmap");
++ glad_glXDestroyGLXPixmap = (PFNGLXDESTROYGLXPIXMAPPROC)load("glXDestroyGLXPixmap");
++ glad_glXQueryExtension = (PFNGLXQUERYEXTENSIONPROC)load("glXQueryExtension");
++ glad_glXQueryVersion = (PFNGLXQUERYVERSIONPROC)load("glXQueryVersion");
++ glad_glXIsDirect = (PFNGLXISDIRECTPROC)load("glXIsDirect");
++ glad_glXGetConfig = (PFNGLXGETCONFIGPROC)load("glXGetConfig");
++ glad_glXGetCurrentContext = (PFNGLXGETCURRENTCONTEXTPROC)load("glXGetCurrentContext");
++ glad_glXGetCurrentDrawable = (PFNGLXGETCURRENTDRAWABLEPROC)load("glXGetCurrentDrawable");
++ glad_glXWaitGL = (PFNGLXWAITGLPROC)load("glXWaitGL");
++ glad_glXWaitX = (PFNGLXWAITXPROC)load("glXWaitX");
++ glad_glXUseXFont = (PFNGLXUSEXFONTPROC)load("glXUseXFont");
++}
++static void load_GLX_VERSION_1_1(GLADloadproc load) {
++ if (!GLAD_GLX_VERSION_1_1) return;
++ glad_glXQueryExtensionsString = (PFNGLXQUERYEXTENSIONSSTRINGPROC)load("glXQueryExtensionsString");
++ glad_glXQueryServerString = (PFNGLXQUERYSERVERSTRINGPROC)load("glXQueryServerString");
++ glad_glXGetClientString = (PFNGLXGETCLIENTSTRINGPROC)load("glXGetClientString");
++}
++static void load_GLX_VERSION_1_2(GLADloadproc load) {
++ if (!GLAD_GLX_VERSION_1_2) return;
++ glad_glXGetCurrentDisplay = (PFNGLXGETCURRENTDISPLAYPROC)load("glXGetCurrentDisplay");
++}
++static void load_GLX_VERSION_1_3(GLADloadproc load) {
++ if (!GLAD_GLX_VERSION_1_3) return;
++ glad_glXGetFBConfigs = (PFNGLXGETFBCONFIGSPROC)load("glXGetFBConfigs");
++ glad_glXChooseFBConfig = (PFNGLXCHOOSEFBCONFIGPROC)load("glXChooseFBConfig");
++ glad_glXGetFBConfigAttrib = (PFNGLXGETFBCONFIGATTRIBPROC)load("glXGetFBConfigAttrib");
++ glad_glXGetVisualFromFBConfig = (PFNGLXGETVISUALFROMFBCONFIGPROC)load("glXGetVisualFromFBConfig");
++ glad_glXCreateWindow = (PFNGLXCREATEWINDOWPROC)load("glXCreateWindow");
++ glad_glXDestroyWindow = (PFNGLXDESTROYWINDOWPROC)load("glXDestroyWindow");
++ glad_glXCreatePixmap = (PFNGLXCREATEPIXMAPPROC)load("glXCreatePixmap");
++ glad_glXDestroyPixmap = (PFNGLXDESTROYPIXMAPPROC)load("glXDestroyPixmap");
++ glad_glXCreatePbuffer = (PFNGLXCREATEPBUFFERPROC)load("glXCreatePbuffer");
++ glad_glXDestroyPbuffer = (PFNGLXDESTROYPBUFFERPROC)load("glXDestroyPbuffer");
++ glad_glXQueryDrawable = (PFNGLXQUERYDRAWABLEPROC)load("glXQueryDrawable");
++ glad_glXCreateNewContext = (PFNGLXCREATENEWCONTEXTPROC)load("glXCreateNewContext");
++ glad_glXMakeContextCurrent = (PFNGLXMAKECONTEXTCURRENTPROC)load("glXMakeContextCurrent");
++ glad_glXGetCurrentReadDrawable = (PFNGLXGETCURRENTREADDRAWABLEPROC)load("glXGetCurrentReadDrawable");
++ glad_glXQueryContext = (PFNGLXQUERYCONTEXTPROC)load("glXQueryContext");
++ glad_glXSelectEvent = (PFNGLXSELECTEVENTPROC)load("glXSelectEvent");
++ glad_glXGetSelectedEvent = (PFNGLXGETSELECTEDEVENTPROC)load("glXGetSelectedEvent");
++}
++static void load_GLX_VERSION_1_4(GLADloadproc load) {
++ if (!GLAD_GLX_VERSION_1_4) return;
++ glad_glXGetProcAddress = (PFNGLXGETPROCADDRESSPROC)load("glXGetProcAddress");
++}
++static int find_extensionsGLX(void) {
++ if (!get_exts()) return 0;
++ (void)&has_ext;
++ free_exts();
++ return 1;
++}
++
++static void find_coreGLX(Display *dpy, int screen) {
++ int major = 0, minor = 0;
++ if (dpy == 0 && GLADGLXDisplay == 0) {
++ dpy = XOpenDisplay(0);
++ screen = XScreenNumberOfScreen(XDefaultScreenOfDisplay(dpy));
++ } else if (dpy == 0) {
++ dpy = GLADGLXDisplay;
++ screen = GLADGLXscreen;
++ }
++ glXQueryVersion(dpy, &major, &minor);
++ GLADGLXDisplay = dpy;
++ GLADGLXscreen = screen;
++ GLAD_GLX_VERSION_1_0 = (major == 1 && minor >= 0) || major > 1;
++ GLAD_GLX_VERSION_1_1 = (major == 1 && minor >= 1) || major > 1;
++ GLAD_GLX_VERSION_1_2 = (major == 1 && minor >= 2) || major > 1;
++ GLAD_GLX_VERSION_1_3 = (major == 1 && minor >= 3) || major > 1;
++ GLAD_GLX_VERSION_1_4 = (major == 1 && minor >= 4) || major > 1;
++}
++
++int gladLoadGLXLoader(GLADloadproc load, Display *dpy, int screen) {
++ glXQueryVersion = (PFNGLXQUERYVERSIONPROC)load("glXQueryVersion");
++ if (glXQueryVersion == NULL) return 0;
++ find_coreGLX(dpy, screen);
++ load_GLX_VERSION_1_0(load);
++ load_GLX_VERSION_1_1(load);
++ load_GLX_VERSION_1_2(load);
++ load_GLX_VERSION_1_3(load);
++ load_GLX_VERSION_1_4(load);
++
++ if (!find_extensionsGLX()) return 0;
++ return 1;
++}
++
+Index: lives-plugins/plugins/playback/video/glad_glx.h
+===================================================================
+--- lives-plugins/plugins/playback/video/glad_glx.h (nonexistent)
++++ lives-plugins/plugins/playback/video/glad_glx.h (revision 2620)
+@@ -0,0 +1,440 @@
++/*
++
++ GLX loader generated by glad 0.1.13a0 on Sat Apr 29 18:30:41 2017.
++
++ Language/Generator: C/C++
++ Specification: glx
++ APIs: glx=1.4
++ Profile: -
++ Extensions:
++
++ Loader: True
++ Local files: False
++ Omit khrplatform: False
++
++ Commandline:
++ --api="glx=1.4" --generator="c" --spec="glx" --extensions=""
++ Online:
++ http://glad.dav1d.de/#language=c&specification=glx&loader=on&api=glx%3D1.4
++*/
++
++
++#include <X11/X.h>
++#include <X11/Xlib.h>
++#include <X11/Xutil.h>
++#include "glad.h"
++
++#ifndef __glad_glxext_h_
++
++#ifdef __glxext_h_
++#error GLX header already included, remove this include, glad already provides it
++#endif
++
++#define __glad_glxext_h_
++#define __glxext_h_
++
++#ifndef APIENTRY
++#define APIENTRY
++#endif
++#ifndef APIENTRYP
++#define APIENTRYP APIENTRY *
++#endif
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++typedef void *(* GLADloadproc)(const char *name);
++
++#ifndef GLAPI
++# if defined(GLAD_GLAPI_EXPORT)
++# if defined(WIN32) || defined(__CYGWIN__)
++# if defined(GLAD_GLAPI_EXPORT_BUILD)
++# if defined(__GNUC__)
++# define GLAPI __attribute__ ((dllexport)) extern
++# else
++# define GLAPI __declspec(dllexport) extern
++# endif
++# else
++# if defined(__GNUC__)
++# define GLAPI __attribute__ ((dllimport)) extern
++# else
++# define GLAPI __declspec(dllimport) extern
++# endif
++# endif
++# elif defined(__GNUC__) && defined(GLAD_GLAPI_EXPORT_BUILD)
++# define GLAPI __attribute__ ((visibility ("default"))) extern
++# else
++# define GLAPI extern
++# endif
++# else
++# define GLAPI extern
++# endif
++#endif
++
++GLAPI int gladLoadGLX(Display *dpy, int screen);
++
++GLAPI int gladLoadGLXLoader(GLADloadproc, Display *dpy, int screen);
++
++#ifndef GLEXT_64_TYPES_DEFINED
++/* This code block is duplicated in glext.h, so must be protected */
++#define GLEXT_64_TYPES_DEFINED
++/* Define int32_t, int64_t, and uint64_t types for UST/MSC */
++/* (as used in the GLX_OML_sync_control extension). */
++#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
++#include <inttypes.h>
++#elif defined(__sun__) || defined(__digital__)
++#include <inttypes.h>
++#if defined(__STDC__)
++#if defined(__arch64__) || defined(_LP64)
++typedef long int int64_t;
++typedef unsigned long int uint64_t;
++#else
++typedef long long int int64_t;
++typedef unsigned long long int uint64_t;
++#endif /* __arch64__ */
++#endif /* __STDC__ */
++#elif defined( __VMS ) || defined(__sgi)
++#include <inttypes.h>
++#elif defined(__SCO__) || defined(__USLC__)
++#include <stdint.h>
++#elif defined(__UNIXOS2__) || defined(__SOL64__)
++typedef long int int32_t;
++typedef long long int int64_t;
++typedef unsigned long long int uint64_t;
++#elif defined(_WIN32) && defined(__GNUC__)
++#include <stdint.h>
++#elif defined(_WIN32)
++typedef __int32 int32_t;
++typedef __int64 int64_t;
++typedef unsigned __int64 uint64_t;
++#else
++/* Fallback if nothing above works */
++#include <inttypes.h>
++#endif
++#endif
++#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && (__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ > 1060)
++#else
++#endif
++#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && (__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ > 1060)
++#else
++#endif
++typedef XID GLXFBConfigID;
++typedef struct __GLXFBConfigRec *GLXFBConfig;
++typedef XID GLXContextID;
++typedef struct __GLXcontextRec *GLXContext;
++typedef XID GLXPixmap;
++typedef XID GLXDrawable;
++typedef XID GLXWindow;
++typedef XID GLXPbuffer;
++typedef void (APIENTRY *__GLXextFuncPtr)(void);
++typedef XID GLXVideoCaptureDeviceNV;
++typedef unsigned int GLXVideoDeviceNV;
++typedef XID GLXVideoSourceSGIX;
++typedef XID GLXFBConfigIDSGIX;
++typedef struct __GLXFBConfigRec *GLXFBConfigSGIX;
++typedef XID GLXPbufferSGIX;
++typedef struct {
++ int event_type; /* GLX_DAMAGED or GLX_SAVED */
++ int draw_type; /* GLX_WINDOW or GLX_PBUFFER */
++ unsigned long serial; /* # of last request processed by server */
++ Bool send_event; /* true if this came for SendEvent request */
++ Display *display; /* display the event was read from */
++ GLXDrawable drawable; /* XID of Drawable */
++ unsigned int buffer_mask; /* mask indicating which buffers are affected */
++ unsigned int aux_buffer; /* which aux buffer was affected */
++ int x, y;
++ int width, height;
++ int count; /* if nonzero, at least this many more */
++} GLXPbufferClobberEvent;
++typedef struct {
++ int type;
++ unsigned long serial; /* # of last request processed by server */
++ Bool send_event; /* true if this came from a SendEvent request */
++ Display *display; /* Display the event was read from */
++ GLXDrawable drawable; /* drawable on which event was requested in event mask */
++ int event_type;
++ int64_t ust;
++ int64_t msc;
++ int64_t sbc;
++} GLXBufferSwapComplete;
++typedef union __GLXEvent {
++ GLXPbufferClobberEvent glxpbufferclobber;
++ GLXBufferSwapComplete glxbufferswapcomplete;
++ long pad[24];
++} GLXEvent;
++typedef struct {
++ int type;
++ unsigned long serial;
++ Bool send_event;
++ Display *display;
++ int extension;
++ int evtype;
++ GLXDrawable window;
++ Bool stereo_tree;
++} GLXStereoNotifyEventEXT;
++typedef struct {
++ int type;
++ unsigned long serial; /* # of last request processed by server */
++ Bool send_event; /* true if this came for SendEvent request */
++ Display *display; /* display the event was read from */
++ GLXDrawable drawable; /* i.d. of Drawable */
++ int event_type; /* GLX_DAMAGED_SGIX or GLX_SAVED_SGIX */
++ int draw_type; /* GLX_WINDOW_SGIX or GLX_PBUFFER_SGIX */
++ unsigned int mask; /* mask indicating which buffers are affected*/
++ int x, y;
++ int width, height;
++ int count; /* if nonzero, at least this many more */
++} GLXBufferClobberEventSGIX;
++typedef struct {
++ char pipeName[80]; /* Should be [GLX_HYPERPIPE_PIPE_NAME_LENGTH_SGIX] */
++ int networkId;
++} GLXHyperpipeNetworkSGIX;
++typedef struct {
++ char pipeName[80]; /* Should be [GLX_HYPERPIPE_PIPE_NAME_LENGTH_SGIX] */
++ int channel;
++ unsigned int participationType;
++ int timeSlice;
++} GLXHyperpipeConfigSGIX;
++typedef struct {
++ char pipeName[80]; /* Should be [GLX_HYPERPIPE_PIPE_NAME_LENGTH_SGIX] */
++ int srcXOrigin, srcYOrigin, srcWidth, srcHeight;
++ int destXOrigin, destYOrigin, destWidth, destHeight;
++} GLXPipeRect;
++typedef struct {
++ char pipeName[80]; /* Should be [GLX_HYPERPIPE_PIPE_NAME_LENGTH_SGIX] */
++ int XOrigin, YOrigin, maxHeight, maxWidth;
++} GLXPipeRectLimits;
++#define GLX_EXTENSION_NAME "GLX"
++#define GLX_PbufferClobber 0
++#define GLX_BufferSwapComplete 1
++#define __GLX_NUMBER_EVENTS 17
++#define GLX_BAD_SCREEN 1
++#define GLX_BAD_ATTRIBUTE 2
++#define GLX_NO_EXTENSION 3
++#define GLX_BAD_VISUAL 4
++#define GLX_BAD_CONTEXT 5
++#define GLX_BAD_VALUE 6
++#define GLX_BAD_ENUM 7
++#define GLX_USE_GL 1
++#define GLX_BUFFER_SIZE 2
++#define GLX_LEVEL 3
++#define GLX_RGBA 4
++#define GLX_DOUBLEBUFFER 5
++#define GLX_STEREO 6
++#define GLX_AUX_BUFFERS 7
++#define GLX_RED_SIZE 8
++#define GLX_GREEN_SIZE 9
++#define GLX_BLUE_SIZE 10
++#define GLX_ALPHA_SIZE 11
++#define GLX_DEPTH_SIZE 12
++#define GLX_STENCIL_SIZE 13
++#define GLX_ACCUM_RED_SIZE 14
++#define GLX_ACCUM_GREEN_SIZE 15
++#define GLX_ACCUM_BLUE_SIZE 16
++#define GLX_ACCUM_ALPHA_SIZE 17
++#define GLX_VENDOR 0x1
++#define GLX_VERSION 0x2
++#define GLX_EXTENSIONS 0x3
++#define GLX_WINDOW_BIT 0x00000001
++#define GLX_PIXMAP_BIT 0x00000002
++#define GLX_PBUFFER_BIT 0x00000004
++#define GLX_RGBA_BIT 0x00000001
++#define GLX_COLOR_INDEX_BIT 0x00000002
++#define GLX_PBUFFER_CLOBBER_MASK 0x08000000
++#define GLX_FRONT_LEFT_BUFFER_BIT 0x00000001
++#define GLX_FRONT_RIGHT_BUFFER_BIT 0x00000002
++#define GLX_BACK_LEFT_BUFFER_BIT 0x00000004
++#define GLX_BACK_RIGHT_BUFFER_BIT 0x00000008
++#define GLX_AUX_BUFFERS_BIT 0x00000010
++#define GLX_DEPTH_BUFFER_BIT 0x00000020
++#define GLX_STENCIL_BUFFER_BIT 0x00000040
++#define GLX_ACCUM_BUFFER_BIT 0x00000080
++#define GLX_CONFIG_CAVEAT 0x20
++#define GLX_X_VISUAL_TYPE 0x22
++#define GLX_TRANSPARENT_TYPE 0x23
++#define GLX_TRANSPARENT_INDEX_VALUE 0x24
++#define GLX_TRANSPARENT_RED_VALUE 0x25
++#define GLX_TRANSPARENT_GREEN_VALUE 0x26
++#define GLX_TRANSPARENT_BLUE_VALUE 0x27
++#define GLX_TRANSPARENT_ALPHA_VALUE 0x28
++#define GLX_DONT_CARE 0xFFFFFFFF
++#define GLX_NONE 0x8000
++#define GLX_SLOW_CONFIG 0x8001
++#define GLX_TRUE_COLOR 0x8002
++#define GLX_DIRECT_COLOR 0x8003
++#define GLX_PSEUDO_COLOR 0x8004
++#define GLX_STATIC_COLOR 0x8005
++#define GLX_GRAY_SCALE 0x8006
++#define GLX_STATIC_GRAY 0x8007
++#define GLX_TRANSPARENT_RGB 0x8008
++#define GLX_TRANSPARENT_INDEX 0x8009
++#define GLX_VISUAL_ID 0x800B
++#define GLX_SCREEN 0x800C
++#define GLX_NON_CONFORMANT_CONFIG 0x800D
++#define GLX_DRAWABLE_TYPE 0x8010
++#define GLX_RENDER_TYPE 0x8011
++#define GLX_X_RENDERABLE 0x8012
++#define GLX_FBCONFIG_ID 0x8013
++#define GLX_RGBA_TYPE 0x8014
++#define GLX_COLOR_INDEX_TYPE 0x8015
++#define GLX_MAX_PBUFFER_WIDTH 0x8016
++#define GLX_MAX_PBUFFER_HEIGHT 0x8017
++#define GLX_MAX_PBUFFER_PIXELS 0x8018
++#define GLX_PRESERVED_CONTENTS 0x801B
++#define GLX_LARGEST_PBUFFER 0x801C
++#define GLX_WIDTH 0x801D
++#define GLX_HEIGHT 0x801E
++#define GLX_EVENT_MASK 0x801F
++#define GLX_DAMAGED 0x8020
++#define GLX_SAVED 0x8021
++#define GLX_WINDOW 0x8022
++#define GLX_PBUFFER 0x8023
++#define GLX_PBUFFER_HEIGHT 0x8040
++#define GLX_PBUFFER_WIDTH 0x8041
++#define GLX_SAMPLE_BUFFERS 100000
++#define GLX_SAMPLES 100001
++#ifndef GLX_VERSION_1_0
++#define GLX_VERSION_1_0 1
++GLAPI int GLAD_GLX_VERSION_1_0;
++typedef XVisualInfo *(APIENTRYP PFNGLXCHOOSEVISUALPROC)(Display *dpy, int screen, int *attribList);
++GLAPI PFNGLXCHOOSEVISUALPROC glad_glXChooseVisual;
++#define glXChooseVisual glad_glXChooseVisual
++typedef GLXContext(APIENTRYP PFNGLXCREATECONTEXTPROC)(Display *dpy, XVisualInfo *vis, GLXContext shareList, Bool direct);
++GLAPI PFNGLXCREATECONTEXTPROC glad_glXCreateContext;
++#define glXCreateContext glad_glXCreateContext
++typedef void (APIENTRYP PFNGLXDESTROYCONTEXTPROC)(Display *dpy, GLXContext ctx);
++GLAPI PFNGLXDESTROYCONTEXTPROC glad_glXDestroyContext;
++#define glXDestroyContext glad_glXDestroyContext
++typedef Bool(APIENTRYP PFNGLXMAKECURRENTPROC)(Display *dpy, GLXDrawable drawable, GLXContext ctx);
++GLAPI PFNGLXMAKECURRENTPROC glad_glXMakeCurrent;
++#define glXMakeCurrent glad_glXMakeCurrent
++typedef void (APIENTRYP PFNGLXCOPYCONTEXTPROC)(Display *dpy, GLXContext src, GLXContext dst, unsigned long mask);
++GLAPI PFNGLXCOPYCONTEXTPROC glad_glXCopyContext;
++#define glXCopyContext glad_glXCopyContext
++typedef void (APIENTRYP PFNGLXSWAPBUFFERSPROC)(Display *dpy, GLXDrawable drawable);
++GLAPI PFNGLXSWAPBUFFERSPROC glad_glXSwapBuffers;
++#define glXSwapBuffers glad_glXSwapBuffers
++typedef GLXPixmap(APIENTRYP PFNGLXCREATEGLXPIXMAPPROC)(Display *dpy, XVisualInfo *visual, Pixmap pixmap);
++GLAPI PFNGLXCREATEGLXPIXMAPPROC glad_glXCreateGLXPixmap;
++#define glXCreateGLXPixmap glad_glXCreateGLXPixmap
++typedef void (APIENTRYP PFNGLXDESTROYGLXPIXMAPPROC)(Display *dpy, GLXPixmap pixmap);
++GLAPI PFNGLXDESTROYGLXPIXMAPPROC glad_glXDestroyGLXPixmap;
++#define glXDestroyGLXPixmap glad_glXDestroyGLXPixmap
++typedef Bool(APIENTRYP PFNGLXQUERYEXTENSIONPROC)(Display *dpy, int *errorb, int *event);
++GLAPI PFNGLXQUERYEXTENSIONPROC glad_glXQueryExtension;
++#define glXQueryExtension glad_glXQueryExtension
++typedef Bool(APIENTRYP PFNGLXQUERYVERSIONPROC)(Display *dpy, int *maj, int *min);
++GLAPI PFNGLXQUERYVERSIONPROC glad_glXQueryVersion;
++#define glXQueryVersion glad_glXQueryVersion
++typedef Bool(APIENTRYP PFNGLXISDIRECTPROC)(Display *dpy, GLXContext ctx);
++GLAPI PFNGLXISDIRECTPROC glad_glXIsDirect;
++#define glXIsDirect glad_glXIsDirect
++typedef int (APIENTRYP PFNGLXGETCONFIGPROC)(Display *dpy, XVisualInfo *visual, int attrib, int *value);
++GLAPI PFNGLXGETCONFIGPROC glad_glXGetConfig;
++#define glXGetConfig glad_glXGetConfig
++typedef GLXContext(APIENTRYP PFNGLXGETCURRENTCONTEXTPROC)();
++GLAPI PFNGLXGETCURRENTCONTEXTPROC glad_glXGetCurrentContext;
++#define glXGetCurrentContext glad_glXGetCurrentContext
++typedef GLXDrawable(APIENTRYP PFNGLXGETCURRENTDRAWABLEPROC)();
++GLAPI PFNGLXGETCURRENTDRAWABLEPROC glad_glXGetCurrentDrawable;
++#define glXGetCurrentDrawable glad_glXGetCurrentDrawable
++typedef void (APIENTRYP PFNGLXWAITGLPROC)();
++GLAPI PFNGLXWAITGLPROC glad_glXWaitGL;
++#define glXWaitGL glad_glXWaitGL
++typedef void (APIENTRYP PFNGLXWAITXPROC)();
++GLAPI PFNGLXWAITXPROC glad_glXWaitX;
++#define glXWaitX glad_glXWaitX
++typedef void (APIENTRYP PFNGLXUSEXFONTPROC)(Font font, int first, int count, int list);
++GLAPI PFNGLXUSEXFONTPROC glad_glXUseXFont;
++#define glXUseXFont glad_glXUseXFont
++#endif
++#ifndef GLX_VERSION_1_1
++#define GLX_VERSION_1_1 1
++GLAPI int GLAD_GLX_VERSION_1_1;
++typedef const char *(APIENTRYP PFNGLXQUERYEXTENSIONSSTRINGPROC)(Display *dpy, int screen);
++GLAPI PFNGLXQUERYEXTENSIONSSTRINGPROC glad_glXQueryExtensionsString;
++#define glXQueryExtensionsString glad_glXQueryExtensionsString
++typedef const char *(APIENTRYP PFNGLXQUERYSERVERSTRINGPROC)(Display *dpy, int screen, int name);
++GLAPI PFNGLXQUERYSERVERSTRINGPROC glad_glXQueryServerString;
++#define glXQueryServerString glad_glXQueryServerString
++typedef const char *(APIENTRYP PFNGLXGETCLIENTSTRINGPROC)(Display *dpy, int name);
++GLAPI PFNGLXGETCLIENTSTRINGPROC glad_glXGetClientString;
++#define glXGetClientString glad_glXGetClientString
++#endif
++#ifndef GLX_VERSION_1_2
++#define GLX_VERSION_1_2 1
++GLAPI int GLAD_GLX_VERSION_1_2;
++typedef Display *(APIENTRYP PFNGLXGETCURRENTDISPLAYPROC)();
++GLAPI PFNGLXGETCURRENTDISPLAYPROC glad_glXGetCurrentDisplay;
++#define glXGetCurrentDisplay glad_glXGetCurrentDisplay
++#endif
++#ifndef GLX_VERSION_1_3
++#define GLX_VERSION_1_3 1
++GLAPI int GLAD_GLX_VERSION_1_3;
++typedef GLXFBConfig *(APIENTRYP PFNGLXGETFBCONFIGSPROC)(Display *dpy, int screen, int *nelements);
++GLAPI PFNGLXGETFBCONFIGSPROC glad_glXGetFBConfigs;
++#define glXGetFBConfigs glad_glXGetFBConfigs
++typedef GLXFBConfig *(APIENTRYP PFNGLXCHOOSEFBCONFIGPROC)(Display *dpy, int screen, const int *attrib_list, int *nelements);
++GLAPI PFNGLXCHOOSEFBCONFIGPROC glad_glXChooseFBConfig;
++#define glXChooseFBConfig glad_glXChooseFBConfig
++typedef int (APIENTRYP PFNGLXGETFBCONFIGATTRIBPROC)(Display *dpy, GLXFBConfig config, int attribute, int *value);
++GLAPI PFNGLXGETFBCONFIGATTRIBPROC glad_glXGetFBConfigAttrib;
++#define glXGetFBConfigAttrib glad_glXGetFBConfigAttrib
++typedef XVisualInfo *(APIENTRYP PFNGLXGETVISUALFROMFBCONFIGPROC)(Display *dpy, GLXFBConfig config);
++GLAPI PFNGLXGETVISUALFROMFBCONFIGPROC glad_glXGetVisualFromFBConfig;
++#define glXGetVisualFromFBConfig glad_glXGetVisualFromFBConfig
++typedef GLXWindow(APIENTRYP PFNGLXCREATEWINDOWPROC)(Display *dpy, GLXFBConfig config, Window win, const int *attrib_list);
++GLAPI PFNGLXCREATEWINDOWPROC glad_glXCreateWindow;
++#define glXCreateWindow glad_glXCreateWindow
++typedef void (APIENTRYP PFNGLXDESTROYWINDOWPROC)(Display *dpy, GLXWindow win);
++GLAPI PFNGLXDESTROYWINDOWPROC glad_glXDestroyWindow;
++#define glXDestroyWindow glad_glXDestroyWindow
++typedef GLXPixmap(APIENTRYP PFNGLXCREATEPIXMAPPROC)(Display *dpy, GLXFBConfig config, Pixmap pixmap, const int *attrib_list);
++GLAPI PFNGLXCREATEPIXMAPPROC glad_glXCreatePixmap;
++#define glXCreatePixmap glad_glXCreatePixmap
++typedef void (APIENTRYP PFNGLXDESTROYPIXMAPPROC)(Display *dpy, GLXPixmap pixmap);
++GLAPI PFNGLXDESTROYPIXMAPPROC glad_glXDestroyPixmap;
++#define glXDestroyPixmap glad_glXDestroyPixmap
++typedef GLXPbuffer(APIENTRYP PFNGLXCREATEPBUFFERPROC)(Display *dpy, GLXFBConfig config, const int *attrib_list);
++GLAPI PFNGLXCREATEPBUFFERPROC glad_glXCreatePbuffer;
++#define glXCreatePbuffer glad_glXCreatePbuffer
++typedef void (APIENTRYP PFNGLXDESTROYPBUFFERPROC)(Display *dpy, GLXPbuffer pbuf);
++GLAPI PFNGLXDESTROYPBUFFERPROC glad_glXDestroyPbuffer;
++#define glXDestroyPbuffer glad_glXDestroyPbuffer
++typedef void (APIENTRYP PFNGLXQUERYDRAWABLEPROC)(Display *dpy, GLXDrawable draw, int attribute, unsigned int *value);
++GLAPI PFNGLXQUERYDRAWABLEPROC glad_glXQueryDrawable;
++#define glXQueryDrawable glad_glXQueryDrawable
++typedef GLXContext(APIENTRYP PFNGLXCREATENEWCONTEXTPROC)(Display *dpy, GLXFBConfig config, int render_type, GLXContext share_list,
++ Bool direct);
++GLAPI PFNGLXCREATENEWCONTEXTPROC glad_glXCreateNewContext;
++#define glXCreateNewContext glad_glXCreateNewContext
++typedef Bool(APIENTRYP PFNGLXMAKECONTEXTCURRENTPROC)(Display *dpy, GLXDrawable draw, GLXDrawable read, GLXContext ctx);
++GLAPI PFNGLXMAKECONTEXTCURRENTPROC glad_glXMakeContextCurrent;
++#define glXMakeContextCurrent glad_glXMakeContextCurrent
++typedef GLXDrawable(APIENTRYP PFNGLXGETCURRENTREADDRAWABLEPROC)();
++GLAPI PFNGLXGETCURRENTREADDRAWABLEPROC glad_glXGetCurrentReadDrawable;
++#define glXGetCurrentReadDrawable glad_glXGetCurrentReadDrawable
++typedef int (APIENTRYP PFNGLXQUERYCONTEXTPROC)(Display *dpy, GLXContext ctx, int attribute, int *value);
++GLAPI PFNGLXQUERYCONTEXTPROC glad_glXQueryContext;
++#define glXQueryContext glad_glXQueryContext
++typedef void (APIENTRYP PFNGLXSELECTEVENTPROC)(Display *dpy, GLXDrawable draw, unsigned long event_mask);
++GLAPI PFNGLXSELECTEVENTPROC glad_glXSelectEvent;
++#define glXSelectEvent glad_glXSelectEvent
++typedef void (APIENTRYP PFNGLXGETSELECTEDEVENTPROC)(Display *dpy, GLXDrawable draw, unsigned long *event_mask);
++GLAPI PFNGLXGETSELECTEDEVENTPROC glad_glXGetSelectedEvent;
++#define glXGetSelectedEvent glad_glXGetSelectedEvent
++#endif
++#ifndef GLX_VERSION_1_4
++#define GLX_VERSION_1_4 1
++GLAPI int GLAD_GLX_VERSION_1_4;
++typedef __GLXextFuncPtr(APIENTRYP PFNGLXGETPROCADDRESSPROC)(const GLubyte *procName);
++GLAPI PFNGLXGETPROCADDRESSPROC glad_glXGetProcAddress;
++#define glXGetProcAddress glad_glXGetProcAddress
++#endif
++
++#ifdef __cplusplus
++}
++#endif
++
++#endif
+Index: lives-plugins/plugins/playback/video/openGL.cpp
+===================================================================
+--- lives-plugins/plugins/playback/video/openGL.cpp (revision 2619)
++++ lives-plugins/plugins/playback/video/openGL.cpp (revision 2620)
+@@ -38,13 +38,15 @@
+ static char plugin_version[64]="LiVES openGL playback engine version 1.1";
+ static char error[256];
+
+-static boolean (*render_fn)(int hsize, int vsize, void **pixel_data, void **return_data);
+-static boolean render_frame_rgba (int hsize, int vsize, void **pixel_data, void **return_data);
+-static boolean render_frame_unknown (int hsize, int vsize, void **pixel_data, void **return_data);
++static boolean(*render_fn)(int hsize, int vsize, void **pixel_data, void **return_data);
++static boolean render_frame_rgba(int hsize, int vsize, void **pixel_data, void **return_data);
++static boolean render_frame_unknown(int hsize, int vsize, void **pixel_data, void **return_data);
+
+ static int palette_list[5];
+ static int mypalette;
+
++static boolean inited;
++
+ #include <math.h> // for sin and cos
+
+ #include <sys/time.h> // added to sync to ticks! -AS
+@@ -55,12 +57,9 @@
+ /////////////////////////////////////////////
+ #include <X11/extensions/Xrender.h>
+ #include <X11/Xatom.h>
+-#include <X11/Xlib.h>
+
+-#include <GLee.h>
++#include "glad_glx.h"
+
+-#include <GL/gl.h>
+-#include <GL/glx.h>
+ #include <GL/glu.h>
+
+ typedef struct {
+@@ -126,7 +125,7 @@
+
+ static void *render_thread_func(void *data);
+
+-static boolean WaitForNotify( Display *dpy, XEvent *event, XPointer arg ) {
++static boolean WaitForNotify(Display *dpy, XEvent *event, XPointer arg) {
+ return (event->type == MapNotify) && (event->xmap.window == (Window) arg);
+ }
+
+@@ -135,7 +134,7 @@
+ static float tfps;
+
+ static int num_versions=2; // number of different weed api versions supported
+-static int api_versions[]={131}; // array of weed api versions supported in plugin
++static int api_versions[]= {131}; // array of weed api versions supported in plugin
+ static weed_plant_t *plugin_info;
+
+ static weed_plant_t *params[7];
+@@ -178,7 +177,7 @@
+ tnum=ctexture-1-tnum;
+ if (tnum<0) tnum+=nbuf;
+ assert(tnum>=0);
+- if (do_assert) assert (tnum<ntextures);
++ if (do_assert) assert(tnum<ntextures);
+ return tnum;
+ }
+
+@@ -215,13 +214,13 @@
+ ///////////////////////////////////////////////
+
+ const char *module_check_init(void) {
+- if( !GL_ARB_texture_non_power_of_two) {
+- snprintf (error,256,"\n\nGL_ARB_texture_non_power_of_two unavailable.\nCannot use plugin.\n");
++ if (!GL_ARB_texture_non_power_of_two) {
++ snprintf(error,256,"\n\nGL_ARB_texture_non_power_of_two unavailable.\nCannot use plugin.\n");
+ return error;
+ }
+
+ XInitThreads();
+-
++
+ pbo_available=FALSE;
+
+ if (GL_ARB_pixel_buffer_object) {
+@@ -231,22 +230,8 @@
+
+ render_fn=&render_frame_unknown;
+
+- glShadeModel(GL_SMOOTH);
++ inited = false;
+
+- glClearDepth( 1.0f );
+- glEnable( GL_DEPTH_TEST );
+-
+- glDepthFunc( GL_LEQUAL );
+- glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
+-
+- glPixelStorei( GL_PACK_ALIGNMENT, 1 );
+- glPixelStorei( GL_UNPACK_ALIGNMENT, 1 );
+- glClearColor( 0.0, 0.0, 0.0, 0.0 );
+- glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+-
+- texID=(GLuint *)malloc(nbuf * sizeof(GLuint));
+- glGenTextures(nbuf, texID);
+-
+ mypalette=WEED_PALETTE_END;
+
+ zsubtitles=NULL;
+@@ -257,21 +242,21 @@
+
+
+
+-const char *version (void) {
++const char *version(void) {
+ return plugin_version;
+ }
+
+-const char *get_description (void) {
++const char *get_description(void) {
+ return "The openGL plugin allows faster playback.\n";
+ }
+
+-uint64_t get_capabilities (int palette) {
++uint64_t get_capabilities(int palette) {
+ return VPP_CAN_RESIZE|VPP_CAN_RETURN|VPP_LOCAL_DISPLAY;
+ }
+
+-const char *get_init_rfx (void) {
++const char *get_init_rfx(void) {
+ return \
+- "<define>\\n\
++ "<define>\\n\
+ |1.7\\n\
+ </define>\\n\
+ <language_code>\\n\
+@@ -292,7 +277,7 @@
+ }
+
+
+-const void **get_play_params (func_ptr weed_bootd) {
++const void **get_play_params(func_ptr weed_bootd) {
+ weed_bootstrap_f weed_boot=(weed_bootstrap_f)weed_bootd;
+
+ //weed_plant_t *gui;
+@@ -303,22 +288,22 @@
+ plugin_info=weed_plugin_info_init(weed_boot,num_versions,api_versions);
+
+ // play params
+- params[0]=weed_integer_init ("mode", "Playback _mode", -1, -1, 10);
++ params[0]=weed_integer_init("mode", "Playback _mode", -1, -1, 10);
+ weed_set_int_value(weed_parameter_template_get_gui(params[0]),"hidden",WEED_TRUE);
+
+- params[1]=weed_float_init ("fft0", "fft value 0", -1., 0., 1.);
++ params[1]=weed_float_init("fft0", "fft value 0", -1., 0., 1.);
+ weed_set_int_value(weed_parameter_template_get_gui(params[1]),"hidden",WEED_TRUE);
+
+- params[2]=weed_float_init ("fft1", "fft value 1", -1., 0., 1.);
++ params[2]=weed_float_init("fft1", "fft value 1", -1., 0., 1.);
+ weed_set_int_value(weed_parameter_template_get_gui(params[2]),"hidden",WEED_TRUE);
+
+- params[3]=weed_float_init ("fft2", "fft value 2", -1., 0., 1.);
++ params[3]=weed_float_init("fft2", "fft value 2", -1., 0., 1.);
+ weed_set_int_value(weed_parameter_template_get_gui(params[3]),"hidden",WEED_TRUE);
+
+- params[4]=weed_float_init ("fft3", "fft value 3", -1., 0., 1.);
++ params[4]=weed_float_init("fft3", "fft value 3", -1., 0., 1.);
+ weed_set_int_value(weed_parameter_template_get_gui(params[4]),"hidden",WEED_TRUE);
+
+- params[5]=weed_text_init ("subtitles", "_Subtitles", "");
++ params[5]=weed_text_init("subtitles", "_Subtitles", "");
+ weed_set_int_value(weed_parameter_template_get_gui(params[5]),"hidden",WEED_TRUE);
+
+ params[6]=NULL;
+@@ -331,15 +316,13 @@
+ const int *get_palette_list(void) {
+ // return palettes in order of preference, ending with WEED_PALETTE_END
+ palette_list[0]=WEED_PALETTE_RGB24;
+- palette_list[1]=WEED_PALETTE_BGR24;
+- palette_list[2]=WEED_PALETTE_RGBA32;
+- palette_list[3]=WEED_PALETTE_BGRA32;
+- palette_list[4]=WEED_PALETTE_END;
++ palette_list[1]=WEED_PALETTE_RGBA32;
++ palette_list[2]=WEED_PALETTE_END;
+ return palette_list;
+ }
+
+
+-boolean set_palette (int palette) {
++boolean set_palette(int palette) {
+ if (palette==WEED_PALETTE_RGBA32||palette==WEED_PALETTE_RGB24||
+ palette==WEED_PALETTE_BGR24||palette==WEED_PALETTE_BGRA32) {
+ render_fn=&render_frame_rgba;
+@@ -353,7 +336,7 @@
+
+
+ static void setWindowDecorations(void) {
+- unsigned char* pucData;
++ unsigned char *pucData;
+ int iFormat;
+ unsigned long ulItems;
+ unsigned long ulBytesAfter;
+@@ -366,18 +349,18 @@
+ WM_HINTS = XInternAtom(dpy, "_MOTIF_WM_HINTS", True);
+ if (WM_HINTS != None) {
+
+- XGetWindowProperty (dpy, xWin, WM_HINTS, 0,
+- sizeof (MotifWmHints) / sizeof (long),
+- False, AnyPropertyType, &typeAtom,
+- &iFormat, &ulItems, &ulBytesAfter, &pucData);
+-
++ XGetWindowProperty(dpy, xWin, WM_HINTS, 0,
++ sizeof(MotifWmHints) / sizeof(long),
++ False, AnyPropertyType, &typeAtom,
++ &iFormat, &ulItems, &ulBytesAfter, &pucData);
++
+ newHints.flags = MWM_HINTS_DECORATIONS;
+ newHints.decorations = 0;
+-
+- XChangeProperty (dpy, xWin, WM_HINTS, WM_HINTS,
+- 32, PropModeReplace, (unsigned char *) &newHints,
+- sizeof (MotifWmHints) / sizeof (long));
+
++ XChangeProperty(dpy, xWin, WM_HINTS, WM_HINTS,
++ 32, PropModeReplace, (unsigned char *) &newHints,
++ sizeof(MotifWmHints) / sizeof(long));
++
+ set = TRUE;
+ }
+
+@@ -387,9 +370,9 @@
+ long KWMHints = 0;
+
+ XChangeProperty(dpy, xWin, WM_HINTS, WM_HINTS, 32,
+- PropModeReplace,
+- (unsigned char *) &KWMHints,
+- sizeof(KWMHints) / 4);
++ PropModeReplace,
++ (unsigned char *) &KWMHints,
++ sizeof(KWMHints) / 4);
+ set = TRUE;
+ }
+ /* Now try to set GNOME hints */
+@@ -398,9 +381,9 @@
+ long GNOMEHints = 0;
+
+ XChangeProperty(dpy, xWin, WM_HINTS, WM_HINTS, 32,
+- PropModeReplace,
+- (unsigned char *) &GNOMEHints,
+- sizeof(GNOMEHints) / 4);
++ PropModeReplace,
++ (unsigned char *) &GNOMEHints,
++ sizeof(GNOMEHints) / 4);
+ set = TRUE;
+ }
+ /* Finally set the transient hints if necessary */
+@@ -411,19 +394,10 @@
+ }
+
+
+-static void toggleVSync() {
+- if( GLX_SGI_swap_control ) {
+- if (1)
+- glXSwapIntervalSGI(1);
+- else
+- glXSwapIntervalSGI(2);
+- }
+-}
+
+-
+ static void alwaysOnTop() {
+ long propvalue = 12;
+- XChangeProperty( dpy, xWin, XA_WIN_LAYER, XA_CARDINAL, 32, PropModeReplace, (unsigned char *)&propvalue, 1 );
++ XChangeProperty(dpy, xWin, XA_WIN_LAYER, XA_CARDINAL, 32, PropModeReplace, (unsigned char *)&propvalue, 1);
+ XRaiseWindow(dpy, xWin);
+ }
+
+@@ -446,7 +420,7 @@
+ static void setFullScreen(void) {
+ XWindowChanges changes;
+ unsigned int valueMask = CWX | CWY | CWWidth | CWHeight;
+-
++
+ setWindowDecorations();
+
+ XA_NET_WM_STATE = XInternAtom(dpy, "_NET_WM_STATE", False);
+@@ -455,13 +429,13 @@
+ XA_NET_WM_STATE_MAXIMIZED_VERT = XInternAtom(dpy, "_NET_WM_STATE_MAXIMIZED_VERT",False);
+ XA_NET_WM_STATE_MAXIMIZED_HORZ = XInternAtom(dpy,"_NET_WM_STATE_MAXIMIZED_HORZ",False);
+ XA_NET_WM_STATE_FULLSCREEN = XInternAtom(dpy,"_NET_WM_STATE_FULLSCREEN",False);
+-
+
++
+ if (isWindowMapped()) {
+ XEvent e;
+
+ memset(&e,0,sizeof(e));
+- e.xany.type = ClientMessage;
++ e.xany.type = ClientMessage;
+ e.xclient.message_type = XA_NET_WM_STATE;
+ e.xclient.format = 32;
+ e.xclient.window = xWin;
+@@ -470,7 +444,7 @@
+ e.xclient.data.l[3] = 0l;
+
+ XSendEvent(dpy, RootWindow(dpy, 0), 0,
+- SubstructureNotifyMask | SubstructureRedirectMask, &e);
++ SubstructureNotifyMask | SubstructureRedirectMask, &e);
+ } else {
+ int count = 0;
+ Atom atoms[3];
+@@ -479,7 +453,7 @@
+ atoms[count++] = XA_NET_WM_STATE_MAXIMIZED_VERT;
+ atoms[count++] = XA_NET_WM_STATE_MAXIMIZED_HORZ;
+ XChangeProperty(dpy, xWin, XA_NET_WM_STATE, XA_ATOM, 32,
+- PropModeReplace, (unsigned char *)atoms, count);
++ PropModeReplace, (unsigned char *)atoms, count);
+ }
+
+ changes.x = 0;
+@@ -488,7 +462,7 @@
+ changes.height = m_HeightFS;
+ changes.stack_mode = Above;
+ valueMask |= CWStackMode;
+-
++
+ XMapRaised(dpy, xWin);
+ XConfigureWindow(dpy, xWin, valueMask, &changes);
+ XResizeWindow(dpy, xWin, m_WidthFS, m_HeightFS);
+@@ -513,20 +487,10 @@
+ }
+ }
+
+-static GLint binding;
+
+ static volatile uint8_t *buffer_free(volatile uint8_t *retbuf) {
+ if (retbuf==NULL) return NULL;
+- if (use_pbo) {
+- //GLint binding;
+- //glGetIntegerv(GL_PIXEL_PACK_BUFFER_BINDING_ARB, &binding);
+- //glBindBuffer(GL_PIXEL_PACK_BUFFER_ARB, video_pbo);
+- glUnmapBuffer(GL_PIXEL_PACK_BUFFER_ARB);
+- glBindBuffer(GL_PIXEL_PACK_BUFFER_ARB, binding);
+- }
+- else {
+- free((void *)retbuf);
+- }
++ free((void *)retbuf);
+ return NULL;
+ }
+
+@@ -550,7 +514,7 @@
+ glReadBuffer(swapFlag?GL_BACK:GL_FRONT);
+ glPixelStorei(GL_PACK_ALIGNMENT, 1);
+ glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+-
++
+ if (!use_pbo) {
+ xretbuf=(uint8_t *)malloc(window_width*window_height*get_size_for_type(type));
+ if (!xretbuf) {
+@@ -560,21 +524,7 @@
+ }
+ glReadPixels(0, 0, window_width, window_height, type, GL_UNSIGNED_BYTE, xretbuf);
+ }
+- else {
+
+- glGetIntegerv(GL_PIXEL_PACK_BUFFER_BINDING_ARB, &binding);
+- glBindBuffer(GL_PIXEL_PACK_BUFFER_ARB, video_pbo);
+-
+- // read pixels into pbo buffer
+- glReadPixels(0, 0, window_width, window_height, type, GL_UNSIGNED_BYTE, NULL);
+-
+- // map pbo to main memory
+- xretbuf = (uint8_t *)glMapBuffer(GL_PIXEL_PACK_BUFFER_ARB, GL_READ_ONLY);
+-
+- //glUnmapBuffer(GL_PIXEL_PACK_BUFFER_ARB);
+- //glBindBuffer(GL_PIXEL_PACK_BUFFER_ARB, binding);
+- }
+-
+ return xretbuf;
+ }
+
+@@ -584,21 +534,22 @@
+ static void render_to_gpumem_inner(int tnum, int width, int height, int type, int typesize, volatile uint8_t *texturebuf) {
+ int mipMapLevel=0;
+ int texID=get_texture_texID(tnum);
+-
+- glEnable( m_TexTarget );
+-
+- glBindTexture( m_TexTarget, texID );
+-
+- glTexImage2D( m_TexTarget, mipMapLevel, type, width, height, 0, type, GL_UNSIGNED_BYTE, (const GLvoid*)texturebuf );
++
++ glEnable(m_TexTarget);
++
++ glBindTexture(m_TexTarget, texID);
++
++ glTexImage2D(m_TexTarget, mipMapLevel, type, width, height, 0, type, GL_UNSIGNED_BYTE, (const GLvoid *)texturebuf);
++
+ glGenerateMipmap(m_TexTarget);
+-
+- glDisable( m_TexTarget );
+-
++
++ glDisable(m_TexTarget);
++
+ tnum=get_real_tnum(tnum,FALSE);
+
+ textures[tnum].width=width;
+ textures[tnum].height=height;
+-
++
+ textures[tnum].type=type;
+ textures[tnum].typesize=typesize;
+
+@@ -615,7 +566,7 @@
+ */
+
+
+-boolean init_screen (int width, int height, boolean fullscreen, uint64_t window_id, int argc, char **argv) {
++boolean init_screen(int width, int height, boolean fullscreen, uint64_t window_id, int argc, char **argv) {
+ _xparms xparms;
+
+ register int i;
+@@ -643,16 +594,20 @@
+ if (argc>1) {
+ tfps=atof(argv[1]);
+ if (argc>2) {
+- nbuf=atoi(argv[2]);
+- if (argc>3) {
+- dblbuf=atoi(argv[3]);
+- if (argc>4) {
+- fsover=atoi(argv[4]);
+- }}}}}
++ nbuf=atoi(argv[2]);
++ if (argc>3) {
++ dblbuf=atoi(argv[3]);
++ if (argc>4) {
++ fsover=atoi(argv[4]);
++ }
++ }
++ }
++ }
++ }
+
+ textures=(_texture *)malloc(nbuf*sizeof(_texture));
+
+- for (i=0;i<nbuf;i++) {
++ for (i=0; i<nbuf; i++) {
+ textures[i].width=textures[i].height=0;
+ }
+
+@@ -681,7 +636,7 @@
+
+
+
+-static boolean init_screen_inner (int width, int height, boolean fullscreen, uint64_t window_id, int argc, char **argv) {
++static boolean init_screen_inner(int width, int height, boolean fullscreen, uint64_t window_id, int argc, char **argv) {
+
+ // screen size is in RGB pixels
+
+@@ -703,7 +658,7 @@
+ GLX_ALPHA_SIZE, 1,
+ None
+ };
+-
++
+ int doubleBufferAttributes[] = {
+ GLX_DRAWABLE_TYPE, GLX_WINDOW_BIT,
+ GLX_RENDER_TYPE, GLX_RGBA_BIT,
+@@ -725,10 +680,10 @@
+ if (fsover) fullscreen=FALSE;
+
+ /* Open a connection to the X server */
+- dpy = XOpenDisplay( NULL );
++ dpy = XOpenDisplay(NULL);
+
+- if ( dpy == NULL ) {
+- fprintf(stderr, "Unable to open a connection to the X server\n" );
++ if (dpy == NULL) {
++ fprintf(stderr, "Unable to open a connection to the X server\n");
+ return FALSE;
+ }
+
+@@ -737,14 +692,15 @@
+
+ XA_WIN_LAYER = XInternAtom(dpy, "_WIN_LAYER", False);
+
+- if( !XRenderQueryExtension( dpy, &renderEventBase, &renderErrorBase ) ) {
+- fprintf(stderr, "No RENDER extension found!" );
++ if (!XRenderQueryExtension(dpy, &renderEventBase, &renderErrorBase)) {
++ fprintf(stderr, "No RENDER extension found!");
+ return FALSE;
+ }
+
+ swa.event_mask = StructureNotifyMask | ButtonPressMask | KeyPressMask | KeyReleaseMask;
+
+-
++ if (!inited) gladLoadGLX(dpy,DefaultScreen(dpy));
++
+ if (window_id) {
+ XVisualInfo *xvis;
+ XVisualInfo xvtmpl;
+@@ -764,7 +720,7 @@
+ return FALSE;
+ }
+
+- context = glXCreateContext ( dpy, &xvis[0], 0, GL_TRUE);
++ context = glXCreateContext(dpy, &xvis[0], 0, GL_TRUE);
+
+ width=window_width=attr.width;
+ height=window_height=attr.height;
+@@ -772,132 +728,131 @@
+ glXGetConfig(dpy, xvis, GLX_DOUBLEBUFFER, &swapFlag);
+ XFree(xvis);
+ is_ext=TRUE;
+- }
+- else {
++ } else {
+ width=window_width=fullscreen?m_WidthFS:width;
+- height=window_height=fullscreen?m_HeightFS:height;
++ height=window_height=fullscreen?m_HeightFS:height;
+
+ if (dblbuf) {
+- /* Request a suitable framebuffer configuration - try for a double
++ /* Request a suitable framebuffer configuration - try for a double
+ ** buffered configuration first */
+- fbConfigs = glXChooseFBConfig( dpy, DefaultScreen(dpy),
+- doubleBufferAttributes, &numReturned );
++ fbConfigs = glXChooseFBConfig(dpy, DefaultScreen(dpy),
++ doubleBufferAttributes, &numReturned);
+ }
+-
+- if ( fbConfigs == NULL ) { /* no double buffered configs available */
+- fbConfigs = glXChooseFBConfig( dpy, DefaultScreen(dpy),
+- singleBufferAttributess, &numReturned );
++
++ if (fbConfigs == NULL) { /* no double buffered configs available */
++ fbConfigs = glXChooseFBConfig(dpy, DefaultScreen(dpy),
++ singleBufferAttributess, &numReturned);
+ swapFlag = FALSE;
+ }
+-
++
+ if (!fbConfigs) {
+ fprintf(stderr,"openGL plugin error: No config could be set !\n");
+ return FALSE;
+ }
+-
++
+ /* Create an X colormap and window with a visual matching the first
+ ** returned framebuffer config */
+- vInfo = glXGetVisualFromFBConfig( dpy, fbConfigs[0] );
+-
++ vInfo = glXGetVisualFromFBConfig(dpy, fbConfigs[0]);
++
+ if (!vInfo) {
+ fprintf(stderr,"openGL plugin error: No vInfo could be got !\n");
+ return FALSE;
+ }
+
+- swa.colormap = XCreateColormap( dpy, RootWindow(dpy, vInfo->screen),
+- vInfo->visual, AllocNone );
+-
++ swa.colormap = XCreateColormap(dpy, RootWindow(dpy, vInfo->screen),
++ vInfo->visual, AllocNone);
++
+ if (!swa.colormap) {
+ fprintf(stderr,"openGL plugin error: No colormap could be set !\n");
+- XFree (vInfo);
++ XFree(vInfo);
+ return FALSE;
+ }
+-
++
+ swaMask = CWBorderPixel | CWColormap | CWEventMask;
+-
++
+ swa.border_pixel = 0;
+
+- xWin = XCreateWindow( dpy, RootWindow(dpy, vInfo->screen), 0, 0,
+- width,height,
+- 0, vInfo->depth, InputOutput, vInfo->visual,
+- swaMask, &swa );
++ xWin = XCreateWindow(dpy, RootWindow(dpy, vInfo->screen), 0, 0,
++ width,height,
++ 0, vInfo->depth, InputOutput, vInfo->visual,
++ swaMask, &swa);
+
+ XFreeColormap(dpy,swa.colormap);
+
+ if (fullscreen) setFullScreen();
+
+- XMapRaised( dpy, xWin );
+- if (fullscreen) XIfEvent( dpy, &event, WaitForNotify, (XPointer) xWin );
++ XMapRaised(dpy, xWin);
++ if (fullscreen) XIfEvent(dpy, &event, WaitForNotify, (XPointer) xWin);
+
+ if (fullscreen) setFullScreen();
+
+ /* Create a GLX context for OpenGL rendering */
+- context = glXCreateNewContext( dpy, fbConfigs[0], GLX_RGBA_TYPE,
+- NULL, True );
++ context = glXCreateNewContext(dpy, fbConfigs[0], GLX_RGBA_TYPE,
++ NULL, True);
+
+ /* Create a GLX window to associate the frame buffer configuration
+ ** with the created X window */
+- glxWin = glXCreateWindow( dpy, fbConfigs[0], xWin, NULL );
+-
+- XFree (vInfo);
++ glxWin = glXCreateWindow(dpy, fbConfigs[0], xWin, NULL);
+
++ XFree(vInfo);
++
+ black.red = black.green = black.blue = 0;
+-
+- bitmapNoData = XCreateBitmapFromData( dpy, xWin, noData, 8, 8 );
+- invisibleCursor = XCreatePixmapCursor( dpy, bitmapNoData, bitmapNoData,
+- &black, &black, 0, 0 );
+- XDefineCursor( dpy, xWin, invisibleCursor );
+- XFreeCursor( dpy, invisibleCursor );
+
++ bitmapNoData = XCreateBitmapFromData(dpy, xWin, noData, 8, 8);
++ invisibleCursor = XCreatePixmapCursor(dpy, bitmapNoData, bitmapNoData,
++ &black, &black, 0, 0);
++ XDefineCursor(dpy, xWin, invisibleCursor);
++ XFreeCursor(dpy, invisibleCursor);
++
+ is_ext=FALSE;
+ }
+
+- glXMakeCurrent( dpy, glxWin, context );
++ glXMakeCurrent(dpy, glxWin, context);
+
+- toggleVSync();
++ if (!inited) gladLoadGL();
+
+ error = glGetError();
+- if( error != GL_NO_ERROR ) {
++ if (error != GL_NO_ERROR) {
+ char const *msg;
++ if (error == GL_INVALID_ENUM) msg = "GL_INVALID_ENUM";
++ else if (error == GL_INVALID_VALUE) msg = "GL_INVALID_VALUE";
++ else if (error == GL_INVALID_OPERATION) msg = "GL_INVALID_OPERATION";
++ else if (error == GL_STACK_OVERFLOW) msg = "GL_STACK_OVERFLOW";
++ else if (error == GL_STACK_UNDERFLOW) msg = "GL_STACK_UNDERFLOW";
++ else if (error == GL_OUT_OF_MEMORY) msg = "GL_OUT_OF_MEMORY";
++ //else if( error == GL_INVALID_FRAMEBUFFER_OPERATION_EXT) msg = "GL_INVALID_FRAMEBUFFER_OPERATION_EXT";
++ else msg = "Unrecognized OpenGL error";
+
+-
+- if( error == GL_INVALID_ENUM ) msg = "GL_INVALID_ENUM";
+- else if( error == GL_INVALID_VALUE ) msg = "GL_INVALID_VALUE";
+- else if( error == GL_INVALID_OPERATION) msg = "GL_INVALID_OPERATION";
+- else if( error == GL_STACK_OVERFLOW) msg = "GL_STACK_OVERFLOW";
+- else if( error == GL_STACK_UNDERFLOW) msg = "GL_STACK_UNDERFLOW";
+- else if( error == GL_OUT_OF_MEMORY) msg = "GL_OUT_OF_MEMORY";
+- else if( error == GL_INVALID_FRAMEBUFFER_OPERATION_EXT) msg = "GL_INVALID_FRAMEBUFFER_OPERATION_EXT";
+- else msg = "Unrecognized OpenGL error";
+-
+- fprintf(stderr, "%s in %s(%d)", msg, __FILE__, __LINE__ );
++ fprintf(stderr, "%s in %s(%d)", msg, __FILE__, __LINE__);
+ return FALSE;
+ }
+
++ if (!inited) {
++ glShadeModel(GL_SMOOTH);
+
+- /* OpenGL rendering ... */
+- glClearColor( 0.0, 0.0, 0.0, 0.0 );
+- glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
++ glClearDepth(1.0f);
++ glEnable(GL_DEPTH_TEST);
+
++ glDepthFunc(GL_LEQUAL);
++ glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
+
+- if (use_pbo) {
+- GLint binding;
+- glGetIntegerv(GL_PIXEL_PACK_BUFFER_BINDING_ARB, &binding);
+- glPushAttrib(GL_ALL_ATTRIB_BITS);
+-
+- glGenBuffers(1, &video_pbo);
++ glPixelStorei(GL_PACK_ALIGNMENT, 1);
++ glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
++ glClearColor(0.0, 0.0, 0.0, 0.0);
++ glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+- glBindBuffer(GL_PIXEL_PACK_BUFFER_ARB, video_pbo);
+-
+- // create a buffer the size of the window
+- glBufferData(GL_PIXEL_PACK_BUFFER_ARB, window_width * window_height * 4, NULL, GL_DYNAMIC_READ );
+-
+- glPopAttrib();
+- glBindBuffer(GL_PIXEL_PACK_BUFFER_ARB, binding);
++ texID=(GLuint *)malloc(nbuf * sizeof(GLuint));
++ glGenTextures(nbuf, texID);
+ }
+
++ inited = true;
++
++ /* OpenGL rendering ... */
++ glClearColor(0.0, 0.0, 0.0, 0.0);
++ glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
++
+ glFlush();
+- if ( swapFlag ) glXSwapBuffers( dpy, glxWin );
++ if (swapFlag) glXSwapBuffers(dpy, glxWin);
+
+ type=GL_RGBA;
+ if (mypalette==WEED_PALETTE_RGB24) type=GL_RGB;
+@@ -906,10 +861,9 @@
+
+ typesize=get_size_for_type(type);
+
+-
+ rquad=0.;
+
+- if (glXIsDirect(dpy, context))
++ if (glXIsDirect(dpy, context))
+ is_direct=TRUE;
+ else
+ is_direct=FALSE;
+@@ -935,11 +889,11 @@
+
+ register int i;
+
+- for (i=0;i<nbuf;i++) {
++ for (i=0; i<nbuf; i++) {
+ prios[i]=0.;
+ }
+
+- for (i=0;i<nbuf;i++) {
++ for (i=0; i<nbuf; i++) {
+ prios[idx]=pri;
+ idx--;
+ if (idx<0) idx+=nbuf;
+@@ -949,7 +903,7 @@
+ }
+
+ glPrioritizeTextures(nbuf,texID,prios);
+-
++
+ free(prios);
+
+ }
+@@ -977,7 +931,7 @@
+ memcpy(dst,ptr+xj*typesize,typesize);
+ dst+=typesize;
+ }
+-
++
+ }
+ }
+ */
+@@ -1003,7 +957,7 @@
+ has_new_texture=FALSE;
+
+ render_to_gpumem_inner(0,width,height,type,typesize,texturebuf);
+-
++
+ set_priorities();
+
+ }
+@@ -1026,232 +980,228 @@
+ window_height=attr.height;
+
+ switch (mode) {
+- case 0:
+- {
+- // flat:
+- glClear(GL_COLOR_BUFFER_BIT);
+- glClear(GL_DEPTH_BUFFER_BIT);
++ case 0: {
++ // flat:
++ glClear(GL_COLOR_BUFFER_BIT);
++ glClear(GL_DEPTH_BUFFER_BIT);
+
+- glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
++ glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+- glViewport(0, 0, window_width, window_height);
++ glViewport(0, 0, window_width, window_height);
+
+- glMatrixMode(GL_PROJECTION);
+- glLoadIdentity();
+- glFrustum(-1, 1, -1, 1, 2, 10);
++ glMatrixMode(GL_PROJECTION);
++ glLoadIdentity();
++ glFrustum(-1, 1, -1, 1, 2, 10);
+
+- glEnable(GL_DEPTH_TEST);
++ glEnable(GL_DEPTH_TEST);
+
+- glMatrixMode(GL_MODELVIEW);
+- glLoadIdentity();
++ glMatrixMode(GL_MODELVIEW);
++ glLoadIdentity();
+
+- glTranslatef(.0, .0, -2);
++ glTranslatef(.0, .0, -2);
+
+- glEnable(m_TexTarget);
+- glMatrixMode(GL_TEXTURE);
+- glLoadIdentity();
++ glEnable(m_TexTarget);
++ glMatrixMode(GL_TEXTURE);
++ glLoadIdentity();
+
+- /* glTexParameteri( m_TexTarget, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE );
+- glTexParameteri( m_TexTarget, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );
+-
+- glTexParameteri( m_TexTarget, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
+- glTexParameteri( m_TexTarget, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
+-
+- glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);*/
++ /* glTexParameteri( m_TexTarget, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE );
++ glTexParameteri( m_TexTarget, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );
+
+- glBindTexture(m_TexTarget, texID);
+- glColor4d(1.0, 1.0, 1.0, 1.0);
++ glTexParameteri( m_TexTarget, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
++ glTexParameteri( m_TexTarget, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
+
+- glBegin(GL_QUADS);
+- glTexCoord2d(0, 1);
+- glVertex3d(-1, -1, 0);
+- glTexCoord2d(0, 0);
+- glVertex3d(-1, 1, 0);
+- glTexCoord2d(1, 0);
+- glVertex3d(1, 1, 0);
+- glTexCoord2d(1, 1);
+- glVertex3d(1, -1, 0);
+- glEnd();
++ glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);*/
+
+- glDisable(m_TexTarget);
++ glBindTexture(m_TexTarget, texID);
++ glColor4d(1.0, 1.0, 1.0, 1.0);
+
+- glMatrixMode(GL_MODELVIEW);
+- glDisable(GL_DEPTH_TEST);
++ glBegin(GL_QUADS);
++ glTexCoord2d(0, 1);
++ glVertex3d(-1, -1, 0);
++ glTexCoord2d(0, 0);
++ glVertex3d(-1, 1, 0);
++ glTexCoord2d(1, 0);
++ glVertex3d(1, 1, 0);
++ glTexCoord2d(1, 1);
++ glVertex3d(1, -1, 0);
++ glEnd();
+
++ glDisable(m_TexTarget);
+
+- }
+- break;
++ glMatrixMode(GL_MODELVIEW);
++ glDisable(GL_DEPTH_TEST);
+
+- case 1:
+- {
+- glClear(GL_COLOR_BUFFER_BIT);
+- glClear(GL_DEPTH_BUFFER_BIT);
+
+- glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
++ }
++ break;
+
+- glViewport(0, 0, window_width, window_height);
++ case 1: {
++ glClear(GL_COLOR_BUFFER_BIT);
++ glClear(GL_DEPTH_BUFFER_BIT);
+
+- glMatrixMode(GL_PROJECTION);
+- glLoadIdentity();
++ glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+- glEnable(GL_DEPTH_TEST);
++ glViewport(0, 0, window_width, window_height);
+
+- glMatrixMode(GL_MODELVIEW);
+- glLoadIdentity();
++ glMatrixMode(GL_PROJECTION);
++ glLoadIdentity();
+
+- glTranslatef(.0, .0, -1);
++ glEnable(GL_DEPTH_TEST);
+
+- glEnable(m_TexTarget);
+- glMatrixMode(GL_TEXTURE);
+- glLoadIdentity();
++ glMatrixMode(GL_MODELVIEW);
++ glLoadIdentity();
+
+- glTexParameteri( m_TexTarget, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE );
+- glTexParameteri( m_TexTarget, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );
+-
+- glTexParameteri( m_TexTarget, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
+- glTexParameteri( m_TexTarget, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
+-
+- glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
++ glTranslatef(.0, .0, -1);
+
+- glBindTexture(m_TexTarget, texID);
+- glColor4d(1.0, 1.0, 1.0, 1.0);
++ glEnable(m_TexTarget);
++ glMatrixMode(GL_TEXTURE);
++ glLoadIdentity();
+
++ glTexParameteri(m_TexTarget, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
++ glTexParameteri(m_TexTarget, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+
+- glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
++ glTexParameteri(m_TexTarget, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
++ glTexParameteri(m_TexTarget, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+
+- glBegin(GL_TRIANGLES); // Drawing Using Triangles
++ glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
+
+- glTexCoord2f (0.5, 0.0);
+- glVertex3f( 0.0f, 1.0f, 0.0f); // Top
+-
+- glTexCoord2f (0.0, 1.0);
+- glVertex3f(-1.0f,-1.0f, 0.0f); // Bottom Left
+-
+- glTexCoord2f (1.0, 1.0);
+- glVertex3f( 1.0f,-1.0f, 0.0f); // Bottom Right
+- glEnd();
+-
+- glTranslatef(-1.5f,0.0f,-6.0f);
+- glEnd();
++ glBindTexture(m_TexTarget, texID);
++ glColor4d(1.0, 1.0, 1.0, 1.0);
+
+- glDisable(m_TexTarget);
+
+- glMatrixMode(GL_MODELVIEW);
+- glDisable(GL_DEPTH_TEST);
++ glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
++ glBegin(GL_TRIANGLES); // Drawing Using Triangles
+
+- }
+- break;
++ glTexCoord2f(0.5, 0.0);
++ glVertex3f(0.0f, 1.0f, 0.0f); // Top
+
+- case 2:
+- {
+- glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
++ glTexCoord2f(0.0, 1.0);
++ glVertex3f(-1.0f,-1.0f, 0.0f); // Bottom Left
+
+- glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
++ glTexCoord2f(1.0, 1.0);
++ glVertex3f(1.0f,-1.0f, 0.0f); // Bottom Right
++ glEnd();
+
+- glViewport(0, 0, window_width, window_height);
++ glTranslatef(-1.5f,0.0f,-6.0f);
++ glEnd();
+
+- glMatrixMode (GL_MODELVIEW);
+- glLoadIdentity ();
+- glTranslatef(0.0,0.0,-1.);
++ glDisable(m_TexTarget);
+
+- // rotations
+- glMatrixMode(GL_PROJECTION); // Select The Projection Matrix
+- //glLoadIdentity();
+- //gluPerspective(45.0f,(GLfloat)window_width/(GLfloat)window_height,0.1f,100.0f);
+-
+- glRotatef(rquad,0.0f,0.0f,1.0f); // Rotate The Quad On The Z axis
+-
+- glTexParameteri( m_TexTarget, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE );
+- glTexParameteri( m_TexTarget, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );
+-
+- glTexParameteri( m_TexTarget, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
+- glTexParameteri( m_TexTarget, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
+-
+- glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
+-
+- glBindTexture( m_TexTarget, texID );
+-
+- glEnable( m_TexTarget );
+-
+- glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
++ glMatrixMode(GL_MODELVIEW);
++ glDisable(GL_DEPTH_TEST);
+
+- rquad-=0.5f; // Decrease The Rotation Variable For The Quad
+
+- glBegin (GL_QUADS);
+-
+- glTexCoord2f (0.0, 0.0);
+- glVertex3f (-1.0, 1.1, 0.0);
+-
+- glTexCoord2f (1.0, 0.0);
+- glVertex3f (1.0, 1.1, 0.0);
+-
+- glTexCoord2f (1.0, 1.0);
+- glVertex3f (1.0, -1.0, 0.0);
+-
+- glTexCoord2f (0.0, 1.0);
+- glVertex3f (-1.0, -1.0, 0.0);
+-
+- glEnd ();
+-
+- glDisable( m_TexTarget );
+- }
+- break;
++ }
++ break;
+
+- case 3:
+- {
+- // wobbler:
++ case 2: {
++ glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+- // sync to the clock with the clock_gettime function
+- struct timespec now;
+- int ticks;
++ glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+- float vx=-1.0,vy=1.0;
+- float tx=0.0,ty;
++ glViewport(0, 0, window_width, window_height);
+
+- float vz;
++ glMatrixMode(GL_MODELVIEW);
++ glLoadIdentity();
++ glTranslatef(0.0,0.0,-1.);
+
+- clock_gettime(CLOCK_MONOTONIC,&now);
+- ticks=now.tv_sec*1000+now.tv_nsec/1000000;
+- ty=sin(ticks*0.001)*0.2;
++ // rotations
++ glMatrixMode(GL_PROJECTION); // Select The Projection Matrix
++ glLoadIdentity();
++ gluPerspective(45.0f,(GLfloat)window_width/(GLfloat)window_height,0.1f,100.0f);
+
+- glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
++ glRotatef(rquad,0.0f,0.0f,1.0f); // Rotate The Quad On The Z axis
+
+- glViewport(0, 0, window_width, window_height);
++ glTexParameteri(m_TexTarget, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
++ glTexParameteri(m_TexTarget, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+
+- glMatrixMode (GL_PROJECTION); // use the projection mode
+- glLoadIdentity ();
+- gluPerspective(60.0, (float)imgWidth/(float)imgHeight, 0.01, 1135.0);
++ glTexParameteri(m_TexTarget, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
++ glTexParameteri(m_TexTarget, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+
+- glMatrixMode (GL_MODELVIEW);
+- glLoadIdentity ();
+- glTranslatef(0.0,0.0,-1.1);
++ glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
+
+- glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
+- glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
+-
+- glTexParameteri( m_TexTarget, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
+- glTexParameteri( m_TexTarget, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
+-
+- glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
+-
+- glBindTexture( m_TexTarget, texID );
+-
+- glEnable( m_TexTarget );
++ glBindTexture(m_TexTarget, texID);
+
+- glEnable(GL_DEPTH_TEST);
++ glEnable(m_TexTarget);
+
+- // parameters of the wobbler grid: the larger the width and height, the more detailed the effect is
++ glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
++
++ rquad-=0.5f; // Decrease The Rotation Variable For The Quad
++
++ glBegin(GL_QUADS);
++
++ glTexCoord2f(0.0, 0.0);
++ glVertex3f(-1.0, 1.1, 0.0);
++
++ glTexCoord2f(1.0, 0.0);
++ glVertex3f(1.0, 1.1, 0.0);
++
++ glTexCoord2f(1.0, 1.0);
++ glVertex3f(1.0, -1.0, 0.0);
++
++ glTexCoord2f(0.0, 1.0);
++ glVertex3f(-1.0, -1.0, 0.0);
++
++ glEnd();
++
++ glDisable(m_TexTarget);
++ }
++ break;
++
++ case 3: {
++ // wobbler:
++
++ // sync to the clock with the clock_gettime function
++ struct timespec now;
++ int ticks;
++
++ float vx=-1.0,vy=1.0;
++ float tx=0.0,ty;
++
++ float vz;
++
++ clock_gettime(CLOCK_MONOTONIC,&now);
++ ticks=now.tv_sec*1000+now.tv_nsec/1000000;
++ ty=sin(ticks*0.001)*0.2;
++
++ glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
++
++ glViewport(0, 0, window_width, window_height);
++
++ glMatrixMode(GL_PROJECTION); // use the projection mode
++ glLoadIdentity();
++ gluPerspective(60.0, (float)imgWidth/(float)imgHeight, 0.01, 1135.0);
++
++ glMatrixMode(GL_MODELVIEW);
++ glLoadIdentity();
++ glTranslatef(0.0,0.0,-1.1);
++
++ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
++ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
++
++ glTexParameteri(m_TexTarget, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
++ glTexParameteri(m_TexTarget, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
++
++ glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
++
++ glBindTexture(m_TexTarget, texID);
++
++ glEnable(m_TexTarget);
++
++ glEnable(GL_DEPTH_TEST);
++
++ // parameters of the wobbler grid: the larger the width and height, the more detailed the effect is
+ #define WX 160 // grid width
+ #define WY 160 // grid height
+-
+- // precalculate the gaps between grid points
++
++ // precalculate the gaps between grid points
+ #define VX_PLUS (2.0/WX)
+ #define VY_PLUS (2.0/WY)
+ #define TX_PLUS (1.0/WX)
+ #define TY_PLUS (1.0/WY)
+
+- // parameters for the sin waves
++ // parameters for the sin waves
+ #define TSPD1 0.003 // speed (in msec)
+ #define XSPD1 0.01 // speed (along grid X)
+ #define YSPD1 0.2 // speed (along grid Y)
+@@ -1263,106 +1213,106 @@
+ #define A2 0.04 // amplitude
+
+
+- for (int j=0; j<WY; j++) {
+- vx=-1.0; tx=0.0;
+- for (int i=0; i<WX; i++) {
+- float col=1.0-sin(i*0.05+j*0.06)*1.0;
++ for (int j=0; j<WY; j++) {
++ vx=-1.0;
++ tx=0.0;
++ for (int i=0; i<WX; i++) {
++ float col=1.0-sin(i*0.05+j*0.06)*1.0;
+
+- glBegin (GL_QUADS);
+-
+- glColor3f(col,col,col);
++ glBegin(GL_QUADS);
+
+- vz=sin(ticks*TSPD1+i*XSPD1+j*YSPD1)*A1+cos(ticks*TSPD2+i*XSPD2+j*YSPD2)*A2;
+- glTexCoord2f (tx,ty);
+- glVertex3f (vx,vy, vz);
+-
+- vz=sin(ticks*TSPD1+(i+1)*XSPD1+j*YSPD1)*A1+cos(ticks*TSPD2+(i+1)*XSPD2+j*YSPD2)*A2;
+- col=1.0-sin((i+1)*0.05+j*0.06)*1.0;
+- glColor3f(col,col,col);
++ glColor3f(col,col,col);
+
+- glTexCoord2f (tx+TX_PLUS, ty);
+- glVertex3f (vx+VX_PLUS, vy, vz);
+-
+- vz=sin(ticks*TSPD1+(i+1)*XSPD1+(j+1)*YSPD1)*A1+cos(ticks*TSPD2+(i+1)*XSPD2+(j+1)*YSPD2)*A2;
+- col=1.0-sin((i+1)*0.05+(j+1)*0.06)*1.0;
+- glColor3f(col,col,col);
++ vz=sin(ticks*TSPD1+i*XSPD1+j*YSPD1)*A1+cos(ticks*TSPD2+i*XSPD2+j*YSPD2)*A2;
++ glTexCoord2f(tx,ty);
++ glVertex3f(vx,vy, vz);
+
+- glTexCoord2f (tx+TX_PLUS, ty+TY_PLUS);
+- glVertex3f (vx+VX_PLUS, vy-VY_PLUS, vz);
+-
+- vz=sin(ticks*TSPD1+i*XSPD1+(j+1)*YSPD1)*A1+cos(ticks*TSPD2+i*XSPD2+(j+1)*YSPD2)*A2;
+- col=1.0-sin(i*0.05+(j+1)*0.06)*1.0;
+- glColor3f(col,col,col);
++ vz=sin(ticks*TSPD1+(i+1)*XSPD1+j*YSPD1)*A1+cos(ticks*TSPD2+(i+1)*XSPD2+j*YSPD2)*A2;
++ col=1.0-sin((i+1)*0.05+j*0.06)*1.0;
++ glColor3f(col,col,col);
+
+- glTexCoord2f (tx, ty+TY_PLUS);
+- glVertex3f (vx, vy-VY_PLUS, vz);
+-
+- glEnd ();
++ glTexCoord2f(tx+TX_PLUS, ty);
++ glVertex3f(vx+VX_PLUS, vy, vz);
+
+- vx+=VX_PLUS;
+- tx+=TX_PLUS;
++ vz=sin(ticks*TSPD1+(i+1)*XSPD1+(j+1)*YSPD1)*A1+cos(ticks*TSPD2+(i+1)*XSPD2+(j+1)*YSPD2)*A2;
++ col=1.0-sin((i+1)*0.05+(j+1)*0.06)*1.0;
++ glColor3f(col,col,col);
+
+- }
+- vy-=VY_PLUS;
+- ty+=TY_PLUS;
++ glTexCoord2f(tx+TX_PLUS, ty+TY_PLUS);
++ glVertex3f(vx+VX_PLUS, vy-VY_PLUS, vz);
+
++ vz=sin(ticks*TSPD1+i*XSPD1+(j+1)*YSPD1)*A1+cos(ticks*TSPD2+i*XSPD2+(j+1)*YSPD2)*A2;
++ col=1.0-sin(i*0.05+(j+1)*0.06)*1.0;
++ glColor3f(col,col,col);
++
++ glTexCoord2f(tx, ty+TY_PLUS);
++ glVertex3f(vx, vy-VY_PLUS, vz);
++
++ glEnd();
++
++ vx+=VX_PLUS;
++ tx+=TX_PLUS;
++
+ }
+- glDisable( m_TexTarget );
++ vy-=VY_PLUS;
++ ty+=TY_PLUS;
++
+ }
+- break;
++ glDisable(m_TexTarget);
++ }
++ break;
+
+- case 4:
+- {
+- // landscape:
++ case 4: {
++ // landscape:
+
+- // time sync
+- struct timespec now;
+- clock_gettime(CLOCK_MONOTONIC,&now);
+- int ticks=now.tv_sec*1000+now.tv_nsec/1000000;
++ // time sync
++ struct timespec now;
++ clock_gettime(CLOCK_MONOTONIC,&now);
++ int ticks=now.tv_sec*1000+now.tv_nsec/1000000;
+
+- glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+- glViewport(0, 0, window_width, window_height);
++ glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
++ glViewport(0, 0, window_width, window_height);
+
+- glMatrixMode (GL_PROJECTION); // use the projection mode
+- glLoadIdentity ();
+- gluPerspective(60.0, (float)imgWidth/(float)imgHeight, 0.01, 1135.0);
++ glMatrixMode(GL_PROJECTION); // use the projection mode
++ glLoadIdentity();
++ gluPerspective(60.0, (float)imgWidth/(float)imgHeight, 0.01, 1135.0);
+
+- glMatrixMode (GL_MODELVIEW);
+- glLoadIdentity ();
+- glTranslatef(0.0,0.0,-1.1);
++ glMatrixMode(GL_MODELVIEW);
++ glLoadIdentity();
++ glTranslatef(0.0,0.0,-1.1);
+
+- // tilt the texture to look like a landscape
+- glRotatef(-60,1,0,0);
+- // add a little bit of rotating movement
+- glRotatef(sin(ticks*0.001)*15,0,1,1);
++ // tilt the texture to look like a landscape
++ glRotatef(-60,1,0,0);
++ // add a little bit of rotating movement
++ glRotatef(sin(ticks*0.001)*15,0,1,1);
+
+- glScalef(1.3,1.0,1.0); // make the landscape wide!
++ glScalef(1.3,1.0,1.0); // make the landscape wide!
+
+- glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
+- glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
+-
+- glTexParameteri( m_TexTarget, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
+- glTexParameteri( m_TexTarget, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
+-
+- glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
+-
+- glBindTexture( m_TexTarget, texID );
+-
+- glEnable( m_TexTarget );
++ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
++ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
+
+- glEnable(GL_DEPTH_TEST);
++ glTexParameteri(m_TexTarget, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
++ glTexParameteri(m_TexTarget, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+
+- // parameters of the landscape grid: the larger the width and height, the more detailed the effect is
++ glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
++
++ glBindTexture(m_TexTarget, texID);
++
++ glEnable(m_TexTarget);
++
++ glEnable(GL_DEPTH_TEST);
++
++ // parameters of the landscape grid: the larger the width and height, the more detailed the effect is
+ #define WX 160 // grid width
+ #define WY 160 // grid height
+-
+- // precalculate the gaps between grid points
++
++ // precalculate the gaps between grid points
+ #define VX_PLUS (2.0/WX)
+ #define VY_PLUS (2.0/WY)
+ #define TX_PLUS (1.0/WX)
+ #define TY_PLUS (1.0/WY)
+
+- // sin wave parameters
++ // sin wave parameters
+ #define TSPD1 0.003 // speed (in msecs)
+ #define XSPD1 0.01 // speed (along grid X)
+ #define YSPD1 0.2 // speed (along grid Y)
+@@ -1374,643 +1324,638 @@
+ #define A22 0.05 // amplitude
+
+
+- float vx=-1.0,vy=1.0;
+- float tx=0.0,ty=-(ticks % 4000)*0.00025;
+- float vz;
++ float vx=-1.0,vy=1.0;
++ float tx=0.0,ty=-(ticks % 4000)*0.00025;
++ float vz;
+
+- for (int j=0; j<WY; j++) {
+- vx=-1.0; tx=0.0;
+- for (int i=0; i<WX; i++) {
+- float col=1.0-sin(i*0.05+j*0.06)*1.0;
++ for (int j=0; j<WY; j++) {
++ vx=-1.0;
++ tx=0.0;
++ for (int i=0; i<WX; i++) {
++ float col=1.0-sin(i*0.05+j*0.06)*1.0;
+
+- glBegin (GL_QUADS);
+-
+- glColor3f(col,col,col);
++ glBegin(GL_QUADS);
+
+- vz=sin(ticks*TSPD1+i*XSPD1+j*YSPD1)*A12+cos(ticks*TSPD2+i*XSPD2+j*YSPD2)*A22;
+- glTexCoord2f (tx,ty);
+- glVertex3f (vx,vy, vz);
+-
+- vz=sin(ticks*TSPD1+(i+1)*XSPD1+j*YSPD1)*A12+cos(ticks*TSPD2+(i+1)*XSPD2+j*YSPD2)*A22;
+- col=1.0-sin((i+1)*0.05+j*0.06)*1.0;
+- glColor3f(col,col,col);
++ glColor3f(col,col,col);
+
+- glTexCoord2f (tx+TX_PLUS, ty);
+- glVertex3f (vx+VX_PLUS, vy, vz);
+-
+- vz=sin(ticks*TSPD1+(i+1)*XSPD1+(j+1)*YSPD1)*A12+cos(ticks*TSPD2+(i+1)*XSPD2+(j+1)*YSPD2)*A22;
+- col=1.0-sin((i+1)*0.05+(j+1)*0.06)*1.0;
+- glColor3f(col,col,col);
++ vz=sin(ticks*TSPD1+i*XSPD1+j*YSPD1)*A12+cos(ticks*TSPD2+i*XSPD2+j*YSPD2)*A22;
++ glTexCoord2f(tx,ty);
++ glVertex3f(vx,vy, vz);
+
+- glTexCoord2f (tx+TX_PLUS, ty+TY_PLUS);
+- glVertex3f (vx+VX_PLUS, vy-VY_PLUS, vz);
+-
+- vz=sin(ticks*TSPD1+i*XSPD1+(j+1)*YSPD1)*A12+cos(ticks*TSPD2+i*XSPD2+(j+1)*YSPD2)*A22;
+- col=1.0-sin(i*0.05+(j+1)*0.06)*1.0;
+- glColor3f(col,col,col);
++ vz=sin(ticks*TSPD1+(i+1)*XSPD1+j*YSPD1)*A12+cos(ticks*TSPD2+(i+1)*XSPD2+j*YSPD2)*A22;
++ col=1.0-sin((i+1)*0.05+j*0.06)*1.0;
++ glColor3f(col,col,col);
+
+- glTexCoord2f (tx, ty+TY_PLUS);
+- glVertex3f (vx, vy-VY_PLUS, vz);
+-
+- glEnd ();
++ glTexCoord2f(tx+TX_PLUS, ty);
++ glVertex3f(vx+VX_PLUS, vy, vz);
+
+- vx+=VX_PLUS;
+- tx+=TX_PLUS;
++ vz=sin(ticks*TSPD1+(i+1)*XSPD1+(j+1)*YSPD1)*A12+cos(ticks*TSPD2+(i+1)*XSPD2+(j+1)*YSPD2)*A22;
++ col=1.0-sin((i+1)*0.05+(j+1)*0.06)*1.0;
++ glColor3f(col,col,col);
+
+- }
+- vy-=VY_PLUS;
+- ty+=TY_PLUS;
++ glTexCoord2f(tx+TX_PLUS, ty+TY_PLUS);
++ glVertex3f(vx+VX_PLUS, vy-VY_PLUS, vz);
+
++ vz=sin(ticks*TSPD1+i*XSPD1+(j+1)*YSPD1)*A12+cos(ticks*TSPD2+i*XSPD2+(j+1)*YSPD2)*A22;
++ col=1.0-sin(i*0.05+(j+1)*0.06)*1.0;
++ glColor3f(col,col,col);
++
++ glTexCoord2f(tx, ty+TY_PLUS);
++ glVertex3f(vx, vy-VY_PLUS, vz);
++
++ glEnd();
++
++ vx+=VX_PLUS;
++ tx+=TX_PLUS;
++
+ }
+- glDisable( m_TexTarget );
++ vy-=VY_PLUS;
++ ty+=TY_PLUS;
++
+ }
++ glDisable(m_TexTarget);
++ }
+
+- break;
++ break;
+
+- case 5:
+- {
+- // insider:
++ case 5: {
++ // insider:
+
+- // time sync
+- struct timespec now;
+- int ticks;
++ // time sync
++ struct timespec now;
++ int ticks;
+
+- clock_gettime(CLOCK_MONOTONIC,&now);
+- ticks=now.tv_sec*1000+now.tv_nsec/1000000;
++ clock_gettime(CLOCK_MONOTONIC,&now);
++ ticks=now.tv_sec*1000+now.tv_nsec/1000000;
+
+- glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+- glViewport(0, 0, window_width, window_height);
++ glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
++ glViewport(0, 0, window_width, window_height);
+
+- glMatrixMode (GL_PROJECTION); // use the projection mode
+- glLoadIdentity ();
+- gluPerspective(60.0, (float)imgWidth/(float)imgHeight, 0.01, 1135.0);
++ glMatrixMode(GL_PROJECTION); // use the projection mode
++ glLoadIdentity();
++ gluPerspective(60.0, (float)imgWidth/(float)imgHeight, 0.01, 1135.0);
+
+- glMatrixMode (GL_MODELVIEW);
+- glLoadIdentity ();
++ glMatrixMode(GL_MODELVIEW);
++ glLoadIdentity();
++ glTranslatef(0.0,0.0,-1.0);
++
++ // turn the cube
++ glRotatef(ticks*0.07,0,1,0);
++ glRotatef(ticks*0.08,0,0,1);
++ glRotatef(ticks*0.035,1,0,0);
++
++ glTexParameteri(m_TexTarget, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
++ glTexParameteri(m_TexTarget, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
++
++ glTexParameteri(m_TexTarget, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
++ glTexParameteri(m_TexTarget, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
++
++ glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
++
++ glBindTexture(m_TexTarget, texID);
++
++ glEnable(m_TexTarget);
++
++ glEnable(GL_DEPTH_TEST);
++
++ // draw the cube with the texture
++ for (int i=0; i<6; i++) {
++ glBegin(GL_QUADS);
++
++ glTexCoord2f(0.0, 0.0);
++ glVertex3f(-1.0, 1.0, 1.0);
++
++ glTexCoord2f(1.0, 0.0);
++ glVertex3f(1.0, 1.0, 1.0);
++
++ glTexCoord2f(1.0, 1.0);
++ glVertex3f(1.0, -1.0, 1.0);
++
++ glTexCoord2f(0.0, 1.0);
++ glVertex3f(-1.0, -1.0, 1.0);
++
++ glEnd();
++ if (i<3) glRotatef(90,0,1,0);
++ else if (i==3) glRotatef(90,1,0,0);
++ else if (i==4) glRotatef(180,1,0,0);
++ }
++
++ glDisable(m_TexTarget);
++ }
++
++ break;
++
++ case 6: {
++ // cube:
++
++ // time sync
++ struct timespec now;
++ int ticks;
++
++ clock_gettime(CLOCK_MONOTONIC,&now);
++ ticks=now.tv_sec*1000+now.tv_nsec/1000000;
++
++ glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
++ glViewport(0, 0, window_width, window_height);
++
++ glMatrixMode(GL_PROJECTION); // use the projection mode
++ glLoadIdentity();
++ gluPerspective(60.0, (float)imgWidth/(float)imgHeight, 0.01, 1135.0);
++
++ glMatrixMode(GL_MODELVIEW);
++ glLoadIdentity();
++
++ glTexParameteri(m_TexTarget, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
++ glTexParameteri(m_TexTarget, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
++
++ glTexParameteri(m_TexTarget, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
++ glTexParameteri(m_TexTarget, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
++
++ glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
++
++ glBindTexture(m_TexTarget, texID);
++
++ glEnable(m_TexTarget);
++
++ glEnable(GL_DEPTH_TEST);
++
++ // inner + outer cube
++ for (int k=0; k<2; k++) {
++
++ glPushMatrix();
+ glTranslatef(0.0,0.0,-1.0);
+
+ // turn the cube
+- glRotatef(ticks*0.07,0,1,0);
+- glRotatef(ticks*0.08,0,0,1);
+- glRotatef(ticks*0.035,1,0,0);
++ glRotatef(ticks*0.036,0,1,0);
++ glRotatef(ticks*0.07,0,0,1);
++ glRotatef(ticks*0.08,1,0,0);
+
+- glTexParameteri( m_TexTarget, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE );
+- glTexParameteri( m_TexTarget, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );
+-
+- glTexParameteri( m_TexTarget, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
+- glTexParameteri( m_TexTarget, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
+-
+- glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
+-
+- glBindTexture( m_TexTarget, texID );
+-
+- glEnable( m_TexTarget );
+-
+- glEnable(GL_DEPTH_TEST);
++ glScalef(1.0-k*0.75,1.0-k*0.75,1.0-k*0.75);
+
+ // draw the cube with the texture
+ for (int i=0; i<6; i++) {
+- glBegin (GL_QUADS);
+-
+- glTexCoord2f (0.0, 0.0);
+- glVertex3f (-1.0, 1.0, 1.0);
+-
+- glTexCoord2f (1.0, 0.0);
+- glVertex3f (1.0, 1.0, 1.0);
+-
+- glTexCoord2f (1.0, 1.0);
+- glVertex3f (1.0, -1.0, 1.0);
+-
+- glTexCoord2f (0.0, 1.0);
+- glVertex3f (-1.0, -1.0, 1.0);
+-
+- glEnd ();
+- if (i<3) glRotatef(90,0,1,0);
+- else if (i==3) glRotatef(90,1,0,0);
+- else if (i==4) glRotatef(180,1,0,0);
++ glBegin(GL_QUADS);
++
++ glTexCoord2f(0.0, 0.0);
++ glVertex3f(-1.0, 1.0, 1.0);
++
++ glTexCoord2f(1.0, 0.0);
++ glVertex3f(1.0, 1.0, 1.0);
++
++ glTexCoord2f(1.0, 1.0);
++ glVertex3f(1.0, -1.0, 1.0);
++
++ glTexCoord2f(0.0, 1.0);
++ glVertex3f(-1.0, -1.0, 1.0);
++
++ glEnd();
++ if (i<3) glRotatef(90,0,1,0);
++ else if (i==3) glRotatef(90,1,0,0);
++ else if (i==4) glRotatef(180,1,0,0);
+ }
+
+- glDisable( m_TexTarget );
++ glPopMatrix();
+ }
++ glDisable(m_TexTarget);
++ }
+
+- break;
++ break;
+
+- case 6:
+- {
+- // cube:
++ case 7: {
++ // turning:
+
+- // time sync
+- struct timespec now;
+- int ticks;
++ // time sync
++ struct timespec now;
++ int ticks;
++ clock_gettime(CLOCK_MONOTONIC,&now);
++ ticks=now.tv_sec*1000+now.tv_nsec/1000000;
+
+- clock_gettime(CLOCK_MONOTONIC,&now);
+- ticks=now.tv_sec*1000+now.tv_nsec/1000000;
++ glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
++ glViewport(0, 0, window_width, window_height);
+
+- glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+- glViewport(0, 0, window_width, window_height);
++ glMatrixMode(GL_PROJECTION); // use the projection mode
++ glLoadIdentity();
++ gluPerspective(60.0, (float)imgWidth/(float)imgHeight, 0.01, 1135.0);
+
+- glMatrixMode (GL_PROJECTION); // use the projection mode
+- glLoadIdentity ();
+- gluPerspective(60.0, (float)imgWidth/(float)imgHeight, 0.01, 1135.0);
++ glMatrixMode(GL_MODELVIEW);
++ glLoadIdentity();
++ glTranslatef(0.0,0.0,-2.3);
+
+- glMatrixMode (GL_MODELVIEW);
+- glLoadIdentity ();
++ // turn the cube
++ glRotatef(cos((ticks % 5000)*M_PI/5000.0)*45+45,0,1,0);
+
+- glTexParameteri( m_TexTarget, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE );
+- glTexParameteri( m_TexTarget, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );
+-
+- glTexParameteri( m_TexTarget, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
+- glTexParameteri( m_TexTarget, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
+-
+- glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
+-
+- glBindTexture( m_TexTarget, texID );
+-
+- glEnable( m_TexTarget );
+-
+- glEnable(GL_DEPTH_TEST);
++ glTexParameteri(m_TexTarget, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
++ glTexParameteri(m_TexTarget, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+
+- // inner + outer cube
+- for (int k=0; k<2; k++) {
++ glTexParameteri(m_TexTarget, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
++ glTexParameteri(m_TexTarget, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+
+- glPushMatrix();
+- glTranslatef(0.0,0.0,-1.0);
++ glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
+
+- // turn the cube
+- glRotatef(ticks*0.036,0,1,0);
+- glRotatef(ticks*0.07,0,0,1);
+- glRotatef(ticks*0.08,1,0,0);
++ glBindTexture(m_TexTarget, texID);
+
+- glScalef(1.0-k*0.75,1.0-k*0.75,1.0-k*0.75);
++ glEnable(m_TexTarget);
+
+- // draw the cube with the texture
+- for (int i=0; i<6; i++) {
+- glBegin (GL_QUADS);
+-
+- glTexCoord2f (0.0, 0.0);
+- glVertex3f (-1.0, 1.0, 1.0);
+-
+- glTexCoord2f (1.0, 0.0);
+- glVertex3f (1.0, 1.0, 1.0);
+-
+- glTexCoord2f (1.0, 1.0);
+- glVertex3f (1.0, -1.0, 1.0);
+-
+- glTexCoord2f (0.0, 1.0);
+- glVertex3f (-1.0, -1.0, 1.0);
+-
+- glEnd ();
+- if (i<3) glRotatef(90,0,1,0);
+- else if (i==3) glRotatef(90,1,0,0);
+- else if (i==4) glRotatef(180,1,0,0);
+- }
++ glEnable(GL_DEPTH_TEST);
+
+- glPopMatrix();
+- }
+- glDisable( m_TexTarget );
+- }
++ // draw the cube with the texture
++ for (int i=0; i<6; i++) {
++ glBegin(GL_QUADS);
+
+- break;
++ glTexCoord2f(0.0, 0.0);
++ glVertex3f(-1.0, 1.0, 1.0);
+
+- case 7:
+- {
+- // turning:
++ glTexCoord2f(1.0, 0.0);
++ glVertex3f(1.0, 1.0, 1.0);
+
+- // time sync
+- struct timespec now;
+- int ticks;
+- clock_gettime(CLOCK_MONOTONIC,&now);
+- ticks=now.tv_sec*1000+now.tv_nsec/1000000;
++ glTexCoord2f(1.0, 1.0);
++ glVertex3f(1.0, -1.0, 1.0);
+
+- glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+- glViewport(0, 0, window_width, window_height);
++ glTexCoord2f(0.0, 1.0);
++ glVertex3f(-1.0, -1.0, 1.0);
+
+- glMatrixMode (GL_PROJECTION); // use the projection mode
+- glLoadIdentity ();
+- gluPerspective(60.0, (float)imgWidth/(float)imgHeight, 0.01, 1135.0);
++ glEnd();
++ if (i<3) glRotatef(90,0,1,0);
++ else if (i==3) glRotatef(90,1,0,0);
++ else if (i==4) glRotatef(180,1,0,0);
++ }
+
+- glMatrixMode (GL_MODELVIEW);
+- glLoadIdentity ();
+- glTranslatef(0.0,0.0,-2.3);
++ glDisable(m_TexTarget);
++ }
+
+- // turn the cube
+- glRotatef(cos((ticks % 5000)*M_PI/5000.0)*45+45,0,1,0);
++ break;
+
+- glTexParameteri( m_TexTarget, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE );
+- glTexParameteri( m_TexTarget, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );
+-
+- glTexParameteri( m_TexTarget, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
+- glTexParameteri( m_TexTarget, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
+-
+- glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
+-
+- glBindTexture( m_TexTarget, texID );
+-
+- glEnable( m_TexTarget );
+-
+- glEnable(GL_DEPTH_TEST);
++ case 8: {
++ // tunnel:
+
+- // draw the cube with the texture
+- for (int i=0; i<6; i++) {
+- glBegin (GL_QUADS);
+-
+- glTexCoord2f (0.0, 0.0);
+- glVertex3f (-1.0, 1.0, 1.0);
+-
+- glTexCoord2f (1.0, 0.0);
+- glVertex3f (1.0, 1.0, 1.0);
+-
+- glTexCoord2f (1.0, 1.0);
+- glVertex3f (1.0, -1.0, 1.0);
+-
+- glTexCoord2f (0.0, 1.0);
+- glVertex3f (-1.0, -1.0, 1.0);
+-
+- glEnd ();
+- if (i<3) glRotatef(90,0,1,0);
+- else if (i==3) glRotatef(90,1,0,0);
+- else if (i==4) glRotatef(180,1,0,0);
+- }
++ // sync to the clock
++ struct timespec now;
++ int ticks;
++ float tx=0.0,ty;
+
+- glDisable( m_TexTarget );
+- }
++ clock_gettime(CLOCK_MONOTONIC,&now);
++ ticks=now.tv_sec*1000+now.tv_nsec/1000000;
++ ty=(ticks % 2000)*0.0005;
+
+- break;
++ glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
++ glViewport(0, 0, window_width, window_height);
+
+- case 8:
+- {
+- // tunnel:
++ glMatrixMode(GL_PROJECTION); // use the projection mode
++ glLoadIdentity();
++ gluPerspective(60.0, (float)imgWidth/(float)imgHeight, 0.01, 1135.0);
+
+- // sync to the clock
+- struct timespec now;
+- int ticks;
+- float tx=0.0,ty;
++ glMatrixMode(GL_MODELVIEW);
++ glLoadIdentity();
++ glTranslatef(0.0,0.0,-1.0);
+
+- clock_gettime(CLOCK_MONOTONIC,&now);
+- ticks=now.tv_sec*1000+now.tv_nsec/1000000;
+- ty=(ticks % 2000)*0.0005;
++ glRotatef(5,0,1,0);
++ glRotatef(ticks*0.05,0,0,1);
++ glRotatef(7,1,0,0);
+
+- glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+- glViewport(0, 0, window_width, window_height);
++ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
++ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
+
+- glMatrixMode (GL_PROJECTION); // use the projection mode
+- glLoadIdentity ();
+- gluPerspective(60.0, (float)imgWidth/(float)imgHeight, 0.01, 1135.0);
++ glTexParameteri(m_TexTarget, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
++ glTexParameteri(m_TexTarget, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+
+- glMatrixMode (GL_MODELVIEW);
+- glLoadIdentity ();
+- glTranslatef(0.0,0.0,-1.0);
++ glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
+
+- glRotatef(5,0,1,0);
+- glRotatef(ticks*0.05,0,0,1);
+- glRotatef(7,1,0,0);
++ glBindTexture(m_TexTarget, texID);
+
+- glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
+- glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
+-
+- glTexParameteri( m_TexTarget, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
+- glTexParameteri( m_TexTarget, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
+-
+- glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
+-
+- glBindTexture( m_TexTarget, texID );
+-
+- glEnable( m_TexTarget );
+-
+- glEnable(GL_DEPTH_TEST);
++ glEnable(m_TexTarget);
+
+- // parameters of the tunnel grid: the larger the width and height, the more detailed the effect is
++ glEnable(GL_DEPTH_TEST);
++
++ // parameters of the tunnel grid: the larger the width and height, the more detailed the effect is
+ #define TR 160 // tunnel radius
+ #define TD 160 // tunnel depth
+-
+- // size on screen
++
++ // size on screen
+ #define SR 2.0 // radius
+ #define SD 0.4 // depth factor
+
+- // precalculate the gaps between grid points
++ // precalculate the gaps between grid points
+ #define TX_PLUS2 (1.0/WX)
+ #define TY_PLUS2 (1.0/160)
+
+
+
+- for (int j=0; j<TD; j++) {
+- tx=0.0;
+- for (int i=0; i<TR; i++) {
+- float vx=cos(i*2*M_PI/TR)*SR;
+- float vy=sin(i*2*M_PI/TR)*SR;
+- float vz=-j*SD;
++ for (int j=0; j<TD; j++) {
++ tx=0.0;
++ for (int i=0; i<TR; i++) {
++ float vx=cos(i*2*M_PI/TR)*SR;
++ float vy=sin(i*2*M_PI/TR)*SR;
++ float vz=-j*SD;
+
+- float col=2.0-2.0*(float)j/TD;
++ float col=2.0-2.0*(float)j/TD;
+
+- glColor3f(col,col*0.92,col*0.93);
+- glBegin (GL_QUADS);
++ glColor3f(col,col*0.92,col*0.93);
++ glBegin(GL_QUADS);
+
+- glTexCoord2f (tx,ty);
+- glVertex3f (vx,vy,vz);
+-
+- vx=cos((i+1)*2*M_PI/TR)*SR;
+- vy=sin((i+1)*2*M_PI/TR)*SR;
+- vz=-j*SD;
+- glTexCoord2f (tx+TX_PLUS2, ty);
+- glVertex3f (vx, vy, vz);
+-
+- vx=cos((i+1)*2*M_PI/TR)*SR;
+- vy=sin((i+1)*2*M_PI/TR)*SR;
+- vz=-(j+1)*SD;
+- glTexCoord2f (tx+TX_PLUS2, ty+TY_PLUS2);
+- glVertex3f (vx, vy, vz);
+-
+- vx=cos(i*2*M_PI/TR)*SR;
+- vy=sin(i*2*M_PI/TR)*SR;
+- vz=-(j+1)*SD;
+- glTexCoord2f (tx, ty+TY_PLUS2);
+- glVertex3f (vx, vy, vz);
+-
+- glEnd ();
++ glTexCoord2f(tx,ty);
++ glVertex3f(vx,vy,vz);
+
+- tx+=TX_PLUS2;
++ vx=cos((i+1)*2*M_PI/TR)*SR;
++ vy=sin((i+1)*2*M_PI/TR)*SR;
++ vz=-j*SD;
++ glTexCoord2f(tx+TX_PLUS2, ty);
++ glVertex3f(vx, vy, vz);
+
+- }
+- ty+=TY_PLUS2;
++ vx=cos((i+1)*2*M_PI/TR)*SR;
++ vy=sin((i+1)*2*M_PI/TR)*SR;
++ vz=-(j+1)*SD;
++ glTexCoord2f(tx+TX_PLUS2, ty+TY_PLUS2);
++ glVertex3f(vx, vy, vz);
+
++ vx=cos(i*2*M_PI/TR)*SR;
++ vy=sin(i*2*M_PI/TR)*SR;
++ vz=-(j+1)*SD;
++ glTexCoord2f(tx, ty+TY_PLUS2);
++ glVertex3f(vx, vy, vz);
++
++ glEnd();
++
++ tx+=TX_PLUS2;
++
+ }
+- glDisable( m_TexTarget );
++ ty+=TY_PLUS2;
++
+ }
+- break;
+- case 9:
+- {
+- // particles:
++ glDisable(m_TexTarget);
++ }
++ break;
++ case 9: {
++ // particles:
+
+- typedef struct {
+- float x,y,z; // position coordinate
+- float sx,sy; // size of the particle square
+- float vx,vy,vz; // speed
+- float tx1,ty1,tx2,ty2; // texture position (color)
+- int start_time; // when was created (tick)
+- int end_time; // when will disappear (tick)
+- } PARTICLE;
++ typedef struct {
++ float x,y,z; // position coordinate
++ float sx,sy; // size of the particle square
++ float vx,vy,vz; // speed
++ float tx1,ty1,tx2,ty2; // texture position (color)
++ int start_time; // when was created (tick)
++ int end_time; // when will disappear (tick)
++ } PARTICLE;
+
+ #define NOT_CREATED -1 // a flag for a particle that was not created
+ #define NOF_PARTS 10000 // the number of particles
+ #define PIXEL_SIZE 1.0 // size of the particle pixels (1.0 = a pixel)
+
+- static PARTICLE parts[NOF_PARTS]; // particle array
++ static PARTICLE parts[NOF_PARTS]; // particle array
+
+- static int parts_init=FALSE; // have been inited?
++ static int parts_init=FALSE; // have been inited?
+
+- if (!parts_init) {
+- for (int i=0; i<NOF_PARTS; i++) parts[i].start_time=NOT_CREATED;
+- parts_init=TRUE;
+- }
+- // time sync
+- struct timespec now;
+- int ticks;
++ if (!parts_init) {
++ for (int i=0; i<NOF_PARTS; i++) parts[i].start_time=NOT_CREATED;
++ parts_init=TRUE;
++ }
++ // time sync
++ struct timespec now;
++ int ticks;
+
+- clock_gettime(CLOCK_MONOTONIC,&now);
+- ticks=now.tv_sec*1000+now.tv_nsec/1000000;
++ clock_gettime(CLOCK_MONOTONIC,&now);
++ ticks=now.tv_sec*1000+now.tv_nsec/1000000;
+
+- glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+- glViewport(0, 0, window_width, window_height);
++ glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
++ glViewport(0, 0, window_width, window_height);
+
+- glMatrixMode (GL_PROJECTION); // use the projection mode
+- glLoadIdentity ();
+- gluPerspective(60.0, (float)imgWidth/(float)imgHeight, 0.01, 1135.0);
++ glMatrixMode(GL_PROJECTION); // use the projection mode
++ glLoadIdentity();
++ gluPerspective(60.0, (float)imgWidth/(float)imgHeight, 0.01, 1135.0);
+
+- glMatrixMode (GL_MODELVIEW);
+- glLoadIdentity ();
+- glTranslatef(0.0,0.0,-2.3);
++ glMatrixMode(GL_MODELVIEW);
++ glLoadIdentity();
++ glTranslatef(0.0,0.0,-2.3);
+
+- // turn the place
+- float rotx=sin(ticks*M_PI/5000.0)*5-15;
+- float roty=sin(ticks*M_PI/5000.0)*5+45;
+- float rotz=sin(ticks*M_PI/5000.0)*5;
++ // turn the place
++ float rotx=sin(ticks*M_PI/5000.0)*5-15;
++ float roty=sin(ticks*M_PI/5000.0)*5+45;
++ float rotz=sin(ticks*M_PI/5000.0)*5;
+
+- glRotatef(rotx,1,0,0);
+- glRotatef(roty,0,1,0);
+- glRotatef(rotz,0,0,1);
++ glRotatef(rotx,1,0,0);
++ glRotatef(roty,0,1,0);
++ glRotatef(rotz,0,0,1);
+
+- glTexParameteri( m_TexTarget, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE );
+- glTexParameteri( m_TexTarget, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );
+-
+- glTexParameteri( m_TexTarget, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
+- glTexParameteri( m_TexTarget, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
+-
+- glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
+-
+- glBindTexture( m_TexTarget, texID );
+-
+- glEnable( m_TexTarget );
+-
+- glEnable(GL_DEPTH_TEST);
++ glTexParameteri(m_TexTarget, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
++ glTexParameteri(m_TexTarget, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+
+- // draw the emitter with the texture
++ glTexParameteri(m_TexTarget, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
++ glTexParameteri(m_TexTarget, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+
+- glBegin (GL_QUADS);
+- glColor3f(1,1,1);
+- glTexCoord2f (0.0, 0.0);
+- glVertex3f (-1.0, 1.0, 0.0);
+-
+- glTexCoord2f (1.0, 0.0);
+- glVertex3f (1.0, 1.0, 0.0);
+-
+- glTexCoord2f (1.0, 1.0);
+- glVertex3f (1.0, -1.0, 0.0);
+-
+- glTexCoord2f (0.0, 1.0);
+- glVertex3f (-1.0, -1.0, 0.0);
++ glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
+
+- glEnd ();
++ glBindTexture(m_TexTarget, texID);
+
+- // draw the particles
++ glEnable(m_TexTarget);
+
+- for (int i=0; i<NOF_PARTS; i++) {
++ glEnable(GL_DEPTH_TEST);
+
+- //int pos;
+- if ((parts[i].start_time==NOT_CREATED) || (ticks>=parts[i].end_time)) {
+- parts[i].start_time=ticks;
+- parts[i].x=(rand() % 2000)/1000.0-1.0;
+- parts[i].y=(rand() % 2000)/1000.0-1.0;
+- parts[i].z=0.0;
+- parts[i].vx=0.001*((rand() % 2000)/1000.0-1.0);
+- parts[i].vy=0.0;
+- parts[i].vz=0.01;
+- parts[i].end_time=4000+parts[i].start_time+rand() % 500;
++ // draw the emitter with the texture
+
+- parts[i].sx=PIXEL_SIZE*2.0/imgWidth;
+- parts[i].sy=PIXEL_SIZE*2.0/imgHeight;
++ glBegin(GL_QUADS);
++ glColor3f(1,1,1);
++ glTexCoord2f(0.0, 0.0);
++ glVertex3f(-1.0, 1.0, 0.0);
+
+- parts[i].tx1=((parts[i].x+1.0)/2.0);
+- parts[i].ty1=(1.0-(parts[i].y+1.0)/2.0);
+- parts[i].tx2=parts[i].tx1+parts[i].sx/2.0;
+- parts[i].ty2=parts[i].ty1+parts[i].sy/2.0;
+- }
+- glBegin(GL_QUADS);
++ glTexCoord2f(1.0, 0.0);
++ glVertex3f(1.0, 1.0, 0.0);
+
+- glTexCoord2f (parts[i].tx1, parts[i].ty1);
+- glVertex3f(parts[i].x,parts[i].y,parts[i].z);
++ glTexCoord2f(1.0, 1.0);
++ glVertex3f(1.0, -1.0, 0.0);
+
+- glTexCoord2f (parts[i].tx2, parts[i].ty1);
+- glVertex3f(parts[i].x+parts[i].sx,parts[i].y,parts[i].z);
++ glTexCoord2f(0.0, 1.0);
++ glVertex3f(-1.0, -1.0, 0.0);
+
+- glTexCoord2f (parts[i].tx2, parts[i].ty2);
+- glVertex3f(parts[i].x+parts[i].sx,parts[i].y-parts[i].sy,parts[i].z);
++ glEnd();
+
+- glTexCoord2f (parts[i].tx1, parts[i].ty2);
+- glVertex3f(parts[i].x,parts[i].y-parts[i].sy,parts[i].z);
+- glEnd();
+-
+- parts[i].x+=parts[i].vx;
+- parts[i].y+=parts[i].vy;
+- parts[i].z+=parts[i].vz;
+- parts[i].vy-=0.0001; // adds a small gravity
++ // draw the particles
+
++ for (int i=0; i<NOF_PARTS; i++) {
+
++ //int pos;
++ if ((parts[i].start_time==NOT_CREATED) || (ticks>=parts[i].end_time)) {
++ parts[i].start_time=ticks;
++ parts[i].x=(rand() % 2000)/1000.0-1.0;
++ parts[i].y=(rand() % 2000)/1000.0-1.0;
++ parts[i].z=0.0;
++ parts[i].vx=0.001*((rand() % 2000)/1000.0-1.0);
++ parts[i].vy=0.0;
++ parts[i].vz=0.01;
++ parts[i].end_time=4000+parts[i].start_time+rand() % 500;
++
++ parts[i].sx=PIXEL_SIZE*2.0/imgWidth;
++ parts[i].sy=PIXEL_SIZE*2.0/imgHeight;
++
++ parts[i].tx1=((parts[i].x+1.0)/2.0);
++ parts[i].ty1=(1.0-(parts[i].y+1.0)/2.0);
++ parts[i].tx2=parts[i].tx1+parts[i].sx/2.0;
++ parts[i].ty2=parts[i].ty1+parts[i].sy/2.0;
+ }
+- glDisable( m_TexTarget );
++ glBegin(GL_QUADS);
+
++ glTexCoord2f(parts[i].tx1, parts[i].ty1);
++ glVertex3f(parts[i].x,parts[i].y,parts[i].z);
++
++ glTexCoord2f(parts[i].tx2, parts[i].ty1);
++ glVertex3f(parts[i].x+parts[i].sx,parts[i].y,parts[i].z);
++
++ glTexCoord2f(parts[i].tx2, parts[i].ty2);
++ glVertex3f(parts[i].x+parts[i].sx,parts[i].y-parts[i].sy,parts[i].z);
++
++ glTexCoord2f(parts[i].tx1, parts[i].ty2);
++ glVertex3f(parts[i].x,parts[i].y-parts[i].sy,parts[i].z);
++ glEnd();
++
++ parts[i].x+=parts[i].vx;
++ parts[i].y+=parts[i].vy;
++ parts[i].z+=parts[i].vz;
++ parts[i].vy-=0.0001; // adds a small gravity
++
++
+ }
++ glDisable(m_TexTarget);
+
+- break;
++ }
+
+- case 10:
+- {
+- // dissolve:
++ break;
+
+- typedef struct {
+- float x,y,z; // position coordinate
+- float sx,sy; // size of the particle square
+- float vx,vy,vz; // speed
+- float tx1,ty1,tx2,ty2; // texture position (color)
+- int start_time; // when was created (tick)
+- int end_time; // when will disappear (tick)
+- } PARTICLE;
++ case 10: {
++ // dissolve:
+
++ typedef struct {
++ float x,y,z; // position coordinate
++ float sx,sy; // size of the particle square
++ float vx,vy,vz; // speed
++ float tx1,ty1,tx2,ty2; // texture position (color)
++ int start_time; // when was created (tick)
++ int end_time; // when will disappear (tick)
++ } PARTICLE;
++
+ #define NOT_CREATED -1 // a flag for a particle that was not created
+ #define NOF_PARTS2 20000 // the number of particles
+ #define PIXEL_SIZE2 4.0 // size of the particle pixels (1.0 = a pixel)
+
+- static PARTICLE parts[NOF_PARTS2]; // particle array
++ static PARTICLE parts[NOF_PARTS2]; // particle array
+
+- static int parts_init=FALSE; // have been inited?
++ static int parts_init=FALSE; // have been inited?
+
+- if (!parts_init) {
+- for (int i=0; i<NOF_PARTS2; i++) parts[i].start_time=NOT_CREATED;
+- parts_init=TRUE;
+- }
+- // time sync
+- struct timespec now;
+- float rotx,roty,rotz;
+- int ticks;
+- clock_gettime(CLOCK_MONOTONIC,&now);
+- ticks=now.tv_sec*1000+now.tv_nsec/1000000;
++ if (!parts_init) {
++ for (int i=0; i<NOF_PARTS2; i++) parts[i].start_time=NOT_CREATED;
++ parts_init=TRUE;
++ }
++ // time sync
++ struct timespec now;
++ float rotx,roty,rotz;
++ int ticks;
++ clock_gettime(CLOCK_MONOTONIC,&now);
++ ticks=now.tv_sec*1000+now.tv_nsec/1000000;
+
+- glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+- glViewport(0, 0, window_width, window_height);
++ glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
++ glViewport(0, 0, window_width, window_height);
+
+- glMatrixMode (GL_PROJECTION); // use the projection mode
+- glLoadIdentity ();
+- gluPerspective(60.0, (float)imgWidth/(float)imgHeight, 0.01, 1135.0);
++ glMatrixMode(GL_PROJECTION); // use the projection mode
++ glLoadIdentity();
++ gluPerspective(60.0, (float)imgWidth/(float)imgHeight, 0.01, 1135.0);
+
+- glMatrixMode (GL_MODELVIEW);
+- glLoadIdentity ();
+- glTranslatef(0.0,0.0,-2.3);
++ glMatrixMode(GL_MODELVIEW);
++ glLoadIdentity();
++ glTranslatef(0.0,0.0,-2.3);
+
+- // turn the place
+- rotx=sin(ticks*M_PI/5000.0)*5+15;
+- roty=sin(ticks*M_PI/5000.0)*15+15;
+- rotz=sin(ticks*M_PI/5000.0)*5;
++ // turn the place
++ rotx=sin(ticks*M_PI/5000.0)*5+15;
++ roty=sin(ticks*M_PI/5000.0)*15+15;
++ rotz=sin(ticks*M_PI/5000.0)*5;
+
+- glRotatef(rotx,1,0,0);
+- glRotatef(roty,0,1,0);
+- glRotatef(rotz,0,0,1);
++ glRotatef(rotx,1,0,0);
++ glRotatef(roty,0,1,0);
++ glRotatef(rotz,0,0,1);
+
+- glTexParameteri( m_TexTarget, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE );
+- glTexParameteri( m_TexTarget, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );
+-
+- glTexParameteri( m_TexTarget, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
+- glTexParameteri( m_TexTarget, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
+-
+- glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
+-
+- glBindTexture( m_TexTarget, texID );
+-
+- glEnable( m_TexTarget );
+-
+- glEnable(GL_DEPTH_TEST);
++ glTexParameteri(m_TexTarget, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
++ glTexParameteri(m_TexTarget, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+
+- // draw the emitter with the texture
+- /*
+- glBegin (GL_QUADS);
+- glColor3f(1,1,1);
+- glTexCoord2f (0.0, 0.0);
+- glVertex3f (-1.0, 1.0, 0.0);
+-
+- glTexCoord2f (1.0, 0.0);
+- glVertex3f (1.0, 1.0, 0.0);
+-
+- glTexCoord2f (1.0, 1.0);
+- glVertex3f (1.0, -1.0, 0.0);
+-
+- glTexCoord2f (0.0, 1.0);
+- glVertex3f (-1.0, -1.0, 0.0);
++ glTexParameteri(m_TexTarget, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
++ glTexParameteri(m_TexTarget, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+
+- glEnd ();
+- */
+- // draw the squares
++ glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
+
+- glEnable(GL_BLEND);
+- glBlendFunc ( GL_SRC_ALPHA , GL_ONE_MINUS_SRC_ALPHA );
+-
+- for (int i=0; i<NOF_PARTS2; i++) {
++ glBindTexture(m_TexTarget, texID);
+
+- if ((parts[i].start_time==NOT_CREATED) || (ticks>=parts[i].end_time)) {
+- parts[i].start_time=ticks;
+- parts[i].x=(rand() % 2000)/1000.0-1.0;
+- parts[i].y=(rand() % 2000)/1000.0-1.0;
+- parts[i].z=0.0;
+- parts[i].vx=0.001*((rand() % 2000)/1000.0-1.0);
+- parts[i].vy=0.001*((rand() % 2000)/1000.0-1.0);
+- parts[i].vz=0.01;
+- parts[i].end_time=parts[i].start_time+500+rand() % 500;
++ glEnable(m_TexTarget);
+
+- parts[i].sx=PIXEL_SIZE2*2.0/imgWidth;
+- parts[i].sy=PIXEL_SIZE2*2.0/imgHeight;
++ glEnable(GL_DEPTH_TEST);
+
+- parts[i].tx1=((parts[i].x+1.0)/2.0);
+- parts[i].ty1=(1.0-(parts[i].y+1.0)/2.0);
+- parts[i].tx2=parts[i].tx1+parts[i].sx/2.0;
+- parts[i].ty2=parts[i].ty1+parts[i].sy/2.0;
+- }
+- glColor4f(1.0,1.0,1.0,0.5+(float)(parts[i].end_time-ticks)/(parts[i].end_time-parts[i].start_time));
+- glBegin(GL_QUADS);
++ // draw the emitter with the texture
++ /*
++ glBegin (GL_QUADS);
++ glColor3f(1,1,1);
++ glTexCoord2f (0.0, 0.0);
++ glVertex3f (-1.0, 1.0, 0.0);
+
+- glTexCoord2f (parts[i].tx1, parts[i].ty1);
+- glVertex3f(parts[i].x,parts[i].y,parts[i].z);
++ glTexCoord2f (1.0, 0.0);
++ glVertex3f (1.0, 1.0, 0.0);
+
+- glTexCoord2f (parts[i].tx2, parts[i].ty1);
+- glVertex3f(parts[i].x+parts[i].sx,parts[i].y,parts[i].z);
++ glTexCoord2f (1.0, 1.0);
++ glVertex3f (1.0, -1.0, 0.0);
+
+- glTexCoord2f (parts[i].tx2, parts[i].ty2);
+- glVertex3f(parts[i].x+parts[i].sx,parts[i].y-parts[i].sy,parts[i].z);
++ glTexCoord2f (0.0, 1.0);
++ glVertex3f (-1.0, -1.0, 0.0);
+
+- glTexCoord2f (parts[i].tx1, parts[i].ty2);
+- glVertex3f(parts[i].x,parts[i].y-parts[i].sy,parts[i].z);
+- glEnd();
+-
+- parts[i].x+=parts[i].vx;
+- parts[i].y+=parts[i].vy;
+- parts[i].z+=parts[i].vz;
+- parts[i].vy+=0.0004; // adds a small pull up
++ glEnd ();
++ */
++ // draw the squares
+
++ glEnable(GL_BLEND);
++ glBlendFunc(GL_SRC_ALPHA , GL_ONE_MINUS_SRC_ALPHA);
+
++ for (int i=0; i<NOF_PARTS2; i++) {
++
++ if ((parts[i].start_time==NOT_CREATED) || (ticks>=parts[i].end_time)) {
++ parts[i].start_time=ticks;
++ parts[i].x=(rand() % 2000)/1000.0-1.0;
++ parts[i].y=(rand() % 2000)/1000.0-1.0;
++ parts[i].z=0.0;
++ parts[i].vx=0.001*((rand() % 2000)/1000.0-1.0);
++ parts[i].vy=0.001*((rand() % 2000)/1000.0-1.0);
++ parts[i].vz=0.01;
++ parts[i].end_time=parts[i].start_time+500+rand() % 500;
++
++ parts[i].sx=PIXEL_SIZE2*2.0/imgWidth;
++ parts[i].sy=PIXEL_SIZE2*2.0/imgHeight;
++
++ parts[i].tx1=((parts[i].x+1.0)/2.0);
++ parts[i].ty1=(1.0-(parts[i].y+1.0)/2.0);
++ parts[i].tx2=parts[i].tx1+parts[i].sx/2.0;
++ parts[i].ty2=parts[i].ty1+parts[i].sy/2.0;
+ }
+- glDisable( m_TexTarget );
+- glDisable(GL_BLEND);
++ glColor4f(1.0,1.0,1.0,0.5+(float)(parts[i].end_time-ticks)/(parts[i].end_time-parts[i].start_time));
++ glBegin(GL_QUADS);
+
++ glTexCoord2f(parts[i].tx1, parts[i].ty1);
++ glVertex3f(parts[i].x,parts[i].y,parts[i].z);
++
++ glTexCoord2f(parts[i].tx2, parts[i].ty1);
++ glVertex3f(parts[i].x+parts[i].sx,parts[i].y,parts[i].z);
++
++ glTexCoord2f(parts[i].tx2, parts[i].ty2);
++ glVertex3f(parts[i].x+parts[i].sx,parts[i].y-parts[i].sy,parts[i].z);
++
++ glTexCoord2f(parts[i].tx1, parts[i].ty2);
++ glVertex3f(parts[i].x,parts[i].y-parts[i].sy,parts[i].z);
++ glEnd();
++
++ parts[i].x+=parts[i].vx;
++ parts[i].y+=parts[i].vy;
++ parts[i].z+=parts[i].vz;
++ parts[i].vy+=0.0004; // adds a small pull up
++
++
+ }
++ glDisable(m_TexTarget);
++ glDisable(GL_BLEND);
+
+- break;
++ }
+
++ break;
++
+ }
+
+ if (retdata!=NULL) {
+@@ -2024,7 +1969,7 @@
+ return_ready=TRUE;
+ }
+
+- if (swapFlag) glXSwapBuffers( dpy, glxWin );
++ if (swapFlag) glXSwapBuffers(dpy, glxWin);
+
+ return TRUE;
+ }
+@@ -2035,7 +1980,7 @@
+
+ retbuf=NULL;
+
+- init_screen_inner (xparms->width, xparms->height, xparms->fullscreen, xparms->window_id, xparms->argc, xparms->argv);
++ init_screen_inner(xparms->width, xparms->height, xparms->fullscreen, xparms->window_id, xparms->argc, xparms->argv);
+
+ rthread_ready=TRUE;
+
+@@ -2044,8 +1989,7 @@
+ pthread_mutex_lock(&rthread_mutex);
+ if (has_texture&&playing) {
+ Upload(imgWidth,imgHeight);
+- }
+- else pthread_mutex_unlock(&rthread_mutex);
++ } else pthread_mutex_unlock(&rthread_mutex);
+ }
+
+ if (retbuf!=NULL) {
+@@ -2060,7 +2004,7 @@
+
+
+
+-boolean render_frame_rgba (int hsize, int vsize, void **pixel_data, void **return_data) {
++boolean render_frame_rgba(int hsize, int vsize, void **pixel_data, void **return_data) {
+
+ pthread_mutex_lock(&rthread_mutex); // wait for lockout of render thread
+
+@@ -2097,21 +2041,20 @@
+ src=(uint8_t *)retbuf+(window_height-1)*twidth;
+
+ // texture is upside-down compared to image
+- for (i=0;i<window_height;i++) {
++ for (i=0; i<window_height; i++) {
+ memcpy(dst,src,twidth);
+ dst+=twidth;
+ src-=twidth;
+ }
+
+- }
+- else {
++ } else {
+ if (hsize!=imgWidth || vsize!=imgHeight || texturebuf==NULL) {
+ if (texturebuf!=NULL) {
+- free((void *)texturebuf);
++ free((void *)texturebuf);
+ }
+ texturebuf=(uint8_t *)malloc(hsize*vsize*typesize);
+ }
+-
++
+ memcpy((void *)texturebuf,pixel_data[0],hsize*vsize*typesize);
+
+ imgWidth=hsize;
+@@ -2129,7 +2072,7 @@
+
+
+
+-boolean render_frame_unknown (int hsize, int vsize, void **pixel_data, void **return_data) {
++boolean render_frame_unknown(int hsize, int vsize, void **pixel_data, void **return_data) {
+ fprintf(stderr,"openGL plugin error: No palette was set !\n");
+ return FALSE;
+ }
+@@ -2151,7 +2094,7 @@
+
+ if (pparams==NULL) return;
+ while (pparams[i]!=NULL) {
+-
++
+ type=weed_get_int_value(pparams[i],"type",&error);
+
+
+@@ -2158,24 +2101,21 @@
+ if (type==WEED_PLANT_PARAMETER) {
+ ptmpl=weed_get_plantptr_value(pparams[i],"template",&error);
+ pname=weed_get_string_value(ptmpl,"name",&error);
+-
++
+ if (!strcmp(pname,"mode")) {
+- zmode=weed_get_int_value(pparams[i],"value",&error);
++ zmode=weed_get_int_value(pparams[i],"value",&error);
++ } else if (!strcmp(pname,"fft0")) {
++ zfft0=(float)weed_get_double_value(pparams[i],"value",&error);
++ } else if (!strcmp(pname,"subtitles")) {
++ zsubtitles=weed_get_string_value(pparams[i],"value",&error);
+ }
+- else if (!strcmp(pname,"fft0")) {
+- zfft0=(float)weed_get_double_value(pparams[i],"value",&error);
+- }
+- else if (!strcmp(pname,"subtitles")) {
+- zsubtitles=weed_get_string_value(pparams[i],"value",&error);
+- }
+-
++
+ weed_free(pname);
+- }
+- else {
++ } else {
+ // must be an alpha channel
+
+-
+-
++
++
+ }
+ i++;
+ }
+@@ -2184,7 +2124,7 @@
+ }
+
+
+-boolean render_frame (int hsize, int vsize, int64_t tc, void **pixel_data, void **return_data, void **pp) {
++boolean render_frame(int hsize, int vsize, int64_t tc, void **pixel_data, void **return_data, void **pp) {
+ // call the function which was set in set_palette
+ weed_plant_t **pparams=(weed_plant_t **)pp;
+
+@@ -2192,11 +2132,11 @@
+ decode_pparams(pparams);
+ }
+
+- return render_fn (hsize,vsize,pixel_data,return_data);
++ return render_fn(hsize,vsize,pixel_data,return_data);
+ }
+
+
+-void exit_screen (int16_t mouse_x, int16_t mouse_y) {
++void exit_screen(int16_t mouse_x, int16_t mouse_y) {
+ playing=FALSE;
+
+ pthread_join(rthread,NULL);
+@@ -2205,13 +2145,11 @@
+ free((void *)texturebuf);
+ }
+
+- if (use_pbo) glDeleteBuffers(1, &video_pbo);
+-
+ free(textures);
+
+ if (!is_ext) {
+- XUnmapWindow (dpy, xWin);
+- XDestroyWindow (dpy, xWin);
++ XUnmapWindow(dpy, xWin);
++ XDestroyWindow(dpy, xWin);
+ }
+
+ XFlush(dpy);
+@@ -2219,7 +2157,7 @@
+ pthread_mutex_lock(&dpy_mutex);
+ glXMakeContextCurrent(dpy, 0, 0, 0);
+ glXDestroyContext(dpy, context);
+- XCloseDisplay (dpy);
++ XCloseDisplay(dpy);
+ dpy=NULL;
+ pthread_mutex_unlock(&dpy_mutex);
+
diff --git a/lives.spec b/lives.spec
index 4feccc9..040ec57 100644
--- a/lives.spec
+++ b/lives.spec
@@ -13,7 +13,7 @@
Name: lives
Version: 2.8.5
-Release: 1%{?dist}
+Release: 2%{?dist}
Summary: Video editor and VJ tool
License: GPLv3+ and LGPLv3+
URL: http://lives-video.com
@@ -21,6 +21,9 @@ Source0: http://lives-video.com/releases/LiVES-%{version}.tar.gz
## Appdata file
Source1: LiVES.appdata.xml
+## Remove GLee
+Patch0: %{name}-2620.patch
+
BuildRequires: pkgconfig(jack)
BuildRequires: pkgconfig(sdl)
BuildRequires: pkgconfig(libpulse)
@@ -44,9 +47,6 @@ BuildRequires: pkgconfig(fftw3)
BuildRequires: pkgconfig(libmatroska)
BuildRequires: pkgconfig(mjpegtools)
BuildRequires: ladspa-devel
-
-#Retired on fedora
-#BuildRequires: GLee-devel
BuildRequires: x264-libs
BuildRequires: gettext-devel
BuildRequires: doxygen
@@ -97,6 +97,8 @@ It is small in size, yet it has many advanced features.
%prep
%setup -q -n lives-%{version}
+%patch0 -p0
+
##Remove spurious executable permissions
for i in `find . -type f \( -name "*.c" -o -name "*.h" -o -name "*.txt" \)`; do
chmod a-x $i
@@ -188,6 +190,9 @@ appstream-util validate-relax --nonet %{buildroot}%{_datadir}/appdata/*.appdata.
%{_datadir}/appdata/LiVES.appdata.xml
%changelog
+* Sun Apr 30 2017 Antonio Trande <sagitterATfedoraproject.org> - 2.8.5-2
+- Add patch for removing GLee dependency
+
* Sat Apr 29 2017 Antonio Trande <sagitterATfedoraproject.org> - 2.8.5-1
- Update to the release 2.8.5
- GLee support dropped (retired on Fedora)
7 years, 7 months
[gstreamer1-plugins-bad-freeworld] Rebuild for x265 update
by Leigh Scott
commit 4a96cc997b5401a7653c02ebe392884386b72010
Author: leigh123linux <leigh123linux(a)googlemail.com>
Date: Sun Apr 30 10:32:53 2017 +0100
Rebuild for x265 update
gstreamer1-plugins-bad-freeworld.spec | 5 ++++-
1 file changed, 4 insertions(+), 1 deletion(-)
---
diff --git a/gstreamer1-plugins-bad-freeworld.spec b/gstreamer1-plugins-bad-freeworld.spec
index e1e3b07..825891b 100644
--- a/gstreamer1-plugins-bad-freeworld.spec
+++ b/gstreamer1-plugins-bad-freeworld.spec
@@ -5,7 +5,7 @@
Summary: GStreamer 1.0 streaming media framework "bad" plug-ins
Name: gstreamer1-plugins-bad-freeworld
Version: 1.11.90
-Release: 1%{?dist}
+Release: 2%{?dist}
License: LGPLv2+
Group: Applications/Multimedia
URL: http://gstreamer.freedesktop.org/
@@ -93,6 +93,9 @@ rm %{buildroot}%{_libdir}/gstreamer-1.0/*.la
%changelog
+* Sun Apr 30 2017 Leigh Scott <leigh123linux(a)googlemail.com> - 1.11.90-2
+- Rebuild for x265 update
+
* Tue Apr 18 2017 Leigh Scott <leigh123linux(a)googlemail.com> - 1.11.90-1
- Update to 1.11.90
7 years, 7 months