[lives] Add patch for removing GLee dependency

commit 6be8063ed205afcd09557a86d69b4785ef2d20ce Author: sagitter <sagitter(a)fedoraproject.org&gt; 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&specificat... ++*/ ++ ++#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&specificat... ++*/ ++ ++ ++#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&... ++*/ ++ ++#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&... ++*/ ++ ++ ++#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)