From a03099eb234ea716da78e27ab21c3c1d49c48876 Mon Sep 17 00:00:00 2001 From: Krzysztof Rudnicki Date: Sat, 27 Aug 2022 21:43:58 +0200 Subject: [PATCH] chore: synchronize desktop/laptop --- .gitignore | 10 + .vscode/c_cpp_properties.json | 2 +- .vscode/settings.json | 4 +- .vscode/tasks.json | 13 +- Engine/engine/glad.c | 1140 +++++++++++++ Engine/engine/match | Bin 38288 -> 39336 bytes Engine/engine/match.cpp | 38 +- Thesis/Thesis.pdf | Bin 846358 -> 846060 bytes dependencies/include/KHR/khrplatform.h | 311 ++++ dependencies/include/glad/glad.h | 2129 ++++++++++++++++++++++++ 10 files changed, 3637 insertions(+), 10 deletions(-) create mode 100644 Engine/engine/glad.c create mode 100644 dependencies/include/KHR/khrplatform.h create mode 100644 dependencies/include/glad/glad.h diff --git a/.gitignore b/.gitignore index 61c167d..9463db6 100644 --- a/.gitignore +++ b/.gitignore @@ -12,3 +12,13 @@ Thesis/Thesis.toc Thesis/Thesis.out learnopengl.pdf Engine/glfw-3.3.8 +Thesis/missfont.log +.gitignore +Thesis/4_2022_zał 1_ Zarz_wymogi edytorskie_.pdf +.gitignore +Thesis/Thesis.synctex(busy) +Thesis/4_2022_załącznik nr 4.pdf +Thesis/Fonty +dependencies/include/GLFW/glfw3.h +dependencies/include/GLFW/glfw3native.h +dependencies/library/libglfw3.a diff --git a/.vscode/c_cpp_properties.json b/.vscode/c_cpp_properties.json index 9989a10..dab2f43 100644 --- a/.vscode/c_cpp_properties.json +++ b/.vscode/c_cpp_properties.json @@ -5,7 +5,7 @@ "includePath": [ "${workspaceFolder}/**" ], - "compilerPath": "/usr/bin/core_perl/gcc", + "compilerPath": "/usr/bin/gcc", "cStandard": "${default}", "cppStandard": "${default}", "intelliSenseMode": "linux-gcc-x64", diff --git a/.vscode/settings.json b/.vscode/settings.json index 88c1ae7..1d435f0 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -1,6 +1,6 @@ { - "C_Cpp_Runner.cCompilerPath": "/usr/bin/core_perl/gcc", - "C_Cpp_Runner.cppCompilerPath": "/usr/bin/core_perl/g++", + "C_Cpp_Runner.cCompilerPath": "/usr/bin/gcc", + "C_Cpp_Runner.cppCompilerPath": "/usr/bin/g++", "C_Cpp_Runner.cStandard": "", "C_Cpp_Runner.cppStandard": "", "C_Cpp_Runner.msvcBatchPath": "", diff --git a/.vscode/tasks.json b/.vscode/tasks.json index 1bb0796..fccb237 100644 --- a/.vscode/tasks.json +++ b/.vscode/tasks.json @@ -3,13 +3,20 @@ { "type": "cppbuild", "label": "C/C++: g++-11 build active file", - "command": "/home/linuxbrew/.linuxbrew/bin/g++-11", + "command": "/usr/bin/g++", "args": [ + "-lGL", "-lm", + "-lX11", "-lpthread", "-lXi", "-lXrandr", "-ldl", + "-std=c++17", "-fdiagnostics-color=always", + "-Wall", "-g", - "${file}", + "-I${workspaceFolder}/dependencies/include", + "-LI${workspaceFolder}/dependencies/library", + "${workspaceFolder}/dependencies/library/libglfw3.a", + "${workspaceFolder}/Engine/engine/*.cpp", "-o", - "${fileDirname}/${fileBasenameNoExtension}" + "${workspaceFolder}/app", ], "options": { "cwd": "${fileDirname}" diff --git a/Engine/engine/glad.c b/Engine/engine/glad.c new file mode 100644 index 0000000..a2aa28c --- /dev/null +++ b/Engine/engine/glad.c @@ -0,0 +1,1140 @@ +/* + + OpenGL loader generated by glad 0.1.36 on Sat Aug 27 19:06:27 2022. + + Language/Generator: C/C++ + Specification: gl + APIs: gl=3.3 + Profile: core + Extensions: + + Loader: True + Local files: False + Omit khrplatform: False + Reproducible: False + + Commandline: + --profile="core" --api="gl=3.3" --generator="c" --spec="gl" --extensions="" + Online: + https://glad.dav1d.de/#profile=core&language=c&specification=gl&loader=on&api=gl%3D3.3 +*/ + +#include +#include +#include +#include + +static void* get_proc(const char *namez); + +#if defined(_WIN32) || defined(__CYGWIN__) +#ifndef _WINDOWS_ +#undef APIENTRY +#endif +#include +static HMODULE libGL; + +typedef void* (APIENTRYP PFNWGLGETPROCADDRESSPROC_PRIVATE)(const char*); +static PFNWGLGETPROCADDRESSPROC_PRIVATE gladGetProcAddressPtr; + +#ifdef _MSC_VER +#ifdef __has_include + #if __has_include() + #define HAVE_WINAPIFAMILY 1 + #endif +#elif _MSC_VER >= 1700 && !_USING_V110_SDK71_ + #define HAVE_WINAPIFAMILY 1 +#endif +#endif + +#ifdef HAVE_WINAPIFAMILY + #include + #if !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) && WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) + #define IS_UWP 1 + #endif +#endif + +static +int open_gl(void) { +#ifndef IS_UWP + libGL = LoadLibraryW(L"opengl32.dll"); + if(libGL != NULL) { + void (* tmp)(void); + tmp = (void(*)(void)) GetProcAddress(libGL, "wglGetProcAddress"); + gladGetProcAddressPtr = (PFNWGLGETPROCADDRESSPROC_PRIVATE) tmp; + return gladGetProcAddressPtr != NULL; + } +#endif + + return 0; +} + +static +void close_gl(void) { + if(libGL != NULL) { + FreeLibrary((HMODULE) libGL); + libGL = NULL; + } +} +#else +#include +static void* libGL; + +#if !defined(__APPLE__) && !defined(__HAIKU__) +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) { +#if defined(__APPLE__) || defined(__HAIKU__) + return 1; +#else + gladGetProcAddressPtr = (PFNGLXGETPROCADDRESSPROC_PRIVATE)dlsym(libGL, + "glXGetProcAddressARB"); + return gladGetProcAddressPtr != NULL; +#endif + } + } + + return 0; +} + +static +void close_gl(void) { + if(libGL != NULL) { + dlclose(libGL); + libGL = NULL; + } +} +#endif + +static +void* get_proc(const char *namez) { + void* result = NULL; + if(libGL == NULL) return NULL; + +#if !defined(__APPLE__) && !defined(__HAIKU__) + if(gladGetProcAddressPtr != NULL) { + result = gladGetProcAddressPtr(namez); + } +#endif + if(result == NULL) { +#if defined(_WIN32) || defined(__CYGWIN__) + result = (void*)GetProcAddress((HMODULE) 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 = { 0, 0 }; + +#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 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 = (char **)malloc((size_t)num_exts_i * (sizeof *exts_i)); + } + + if (exts_i == NULL) { + return 0; + } + + for(index = 0; index < (unsigned)num_exts_i; index++) { + const char *gl_str_tmp = (const char*)glGetStringi(GL_EXTENSIONS, index); + size_t len = strlen(gl_str_tmp); + + char *local_str = (char*)malloc((len+1) * sizeof(char)); + if(local_str != NULL) { + memcpy(local_str, gl_str_tmp, (len+1) * sizeof(char)); + } + exts_i[index] = local_str; + } + } +#endif + return 1; +} + +static void free_exts(void) { + if (exts_i != NULL) { + int index; + for(index = 0; index < num_exts_i; index++) { + free((char *)exts_i[index]); + } + free((void *)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; + if(exts_i == NULL) return 0; + for(index = 0; index < num_exts_i; index++) { + const char *e = exts_i[index]; + + if(exts_i[index] != NULL && strcmp(e, ext) == 0) { + return 1; + } + } + } +#endif + + return 0; +} +int GLAD_GL_VERSION_1_0 = 0; +int GLAD_GL_VERSION_1_1 = 0; +int GLAD_GL_VERSION_1_2 = 0; +int GLAD_GL_VERSION_1_3 = 0; +int GLAD_GL_VERSION_1_4 = 0; +int GLAD_GL_VERSION_1_5 = 0; +int GLAD_GL_VERSION_2_0 = 0; +int GLAD_GL_VERSION_2_1 = 0; +int GLAD_GL_VERSION_3_0 = 0; +int GLAD_GL_VERSION_3_1 = 0; +int GLAD_GL_VERSION_3_2 = 0; +int GLAD_GL_VERSION_3_3 = 0; +PFNGLACTIVETEXTUREPROC glad_glActiveTexture = NULL; +PFNGLATTACHSHADERPROC glad_glAttachShader = NULL; +PFNGLBEGINCONDITIONALRENDERPROC glad_glBeginConditionalRender = NULL; +PFNGLBEGINQUERYPROC glad_glBeginQuery = NULL; +PFNGLBEGINTRANSFORMFEEDBACKPROC glad_glBeginTransformFeedback = NULL; +PFNGLBINDATTRIBLOCATIONPROC glad_glBindAttribLocation = NULL; +PFNGLBINDBUFFERPROC glad_glBindBuffer = NULL; +PFNGLBINDBUFFERBASEPROC glad_glBindBufferBase = NULL; +PFNGLBINDBUFFERRANGEPROC glad_glBindBufferRange = NULL; +PFNGLBINDFRAGDATALOCATIONPROC glad_glBindFragDataLocation = NULL; +PFNGLBINDFRAGDATALOCATIONINDEXEDPROC glad_glBindFragDataLocationIndexed = NULL; +PFNGLBINDFRAMEBUFFERPROC glad_glBindFramebuffer = NULL; +PFNGLBINDRENDERBUFFERPROC glad_glBindRenderbuffer = NULL; +PFNGLBINDSAMPLERPROC glad_glBindSampler = NULL; +PFNGLBINDTEXTUREPROC glad_glBindTexture = NULL; +PFNGLBINDVERTEXARRAYPROC glad_glBindVertexArray = NULL; +PFNGLBLENDCOLORPROC glad_glBlendColor = NULL; +PFNGLBLENDEQUATIONPROC glad_glBlendEquation = NULL; +PFNGLBLENDEQUATIONSEPARATEPROC glad_glBlendEquationSeparate = NULL; +PFNGLBLENDFUNCPROC glad_glBlendFunc = NULL; +PFNGLBLENDFUNCSEPARATEPROC glad_glBlendFuncSeparate = NULL; +PFNGLBLITFRAMEBUFFERPROC glad_glBlitFramebuffer = NULL; +PFNGLBUFFERDATAPROC glad_glBufferData = NULL; +PFNGLBUFFERSUBDATAPROC glad_glBufferSubData = NULL; +PFNGLCHECKFRAMEBUFFERSTATUSPROC glad_glCheckFramebufferStatus = NULL; +PFNGLCLAMPCOLORPROC glad_glClampColor = NULL; +PFNGLCLEARPROC glad_glClear = NULL; +PFNGLCLEARBUFFERFIPROC glad_glClearBufferfi = NULL; +PFNGLCLEARBUFFERFVPROC glad_glClearBufferfv = NULL; +PFNGLCLEARBUFFERIVPROC glad_glClearBufferiv = NULL; +PFNGLCLEARBUFFERUIVPROC glad_glClearBufferuiv = NULL; +PFNGLCLEARCOLORPROC glad_glClearColor = NULL; +PFNGLCLEARDEPTHPROC glad_glClearDepth = NULL; +PFNGLCLEARSTENCILPROC glad_glClearStencil = NULL; +PFNGLCLIENTWAITSYNCPROC glad_glClientWaitSync = NULL; +PFNGLCOLORMASKPROC glad_glColorMask = NULL; +PFNGLCOLORMASKIPROC glad_glColorMaski = NULL; +PFNGLCOLORP3UIPROC glad_glColorP3ui = NULL; +PFNGLCOLORP3UIVPROC glad_glColorP3uiv = NULL; +PFNGLCOLORP4UIPROC glad_glColorP4ui = NULL; +PFNGLCOLORP4UIVPROC glad_glColorP4uiv = NULL; +PFNGLCOMPILESHADERPROC glad_glCompileShader = NULL; +PFNGLCOMPRESSEDTEXIMAGE1DPROC glad_glCompressedTexImage1D = NULL; +PFNGLCOMPRESSEDTEXIMAGE2DPROC glad_glCompressedTexImage2D = NULL; +PFNGLCOMPRESSEDTEXIMAGE3DPROC glad_glCompressedTexImage3D = NULL; +PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC glad_glCompressedTexSubImage1D = NULL; +PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC glad_glCompressedTexSubImage2D = NULL; +PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC glad_glCompressedTexSubImage3D = NULL; +PFNGLCOPYBUFFERSUBDATAPROC glad_glCopyBufferSubData = NULL; +PFNGLCOPYTEXIMAGE1DPROC glad_glCopyTexImage1D = NULL; +PFNGLCOPYTEXIMAGE2DPROC glad_glCopyTexImage2D = NULL; +PFNGLCOPYTEXSUBIMAGE1DPROC glad_glCopyTexSubImage1D = NULL; +PFNGLCOPYTEXSUBIMAGE2DPROC glad_glCopyTexSubImage2D = NULL; +PFNGLCOPYTEXSUBIMAGE3DPROC glad_glCopyTexSubImage3D = NULL; +PFNGLCREATEPROGRAMPROC glad_glCreateProgram = NULL; +PFNGLCREATESHADERPROC glad_glCreateShader = NULL; +PFNGLCULLFACEPROC glad_glCullFace = NULL; +PFNGLDELETEBUFFERSPROC glad_glDeleteBuffers = NULL; +PFNGLDELETEFRAMEBUFFERSPROC glad_glDeleteFramebuffers = NULL; +PFNGLDELETEPROGRAMPROC glad_glDeleteProgram = NULL; +PFNGLDELETEQUERIESPROC glad_glDeleteQueries = NULL; +PFNGLDELETERENDERBUFFERSPROC glad_glDeleteRenderbuffers = NULL; +PFNGLDELETESAMPLERSPROC glad_glDeleteSamplers = NULL; +PFNGLDELETESHADERPROC glad_glDeleteShader = NULL; +PFNGLDELETESYNCPROC glad_glDeleteSync = NULL; +PFNGLDELETETEXTURESPROC glad_glDeleteTextures = NULL; +PFNGLDELETEVERTEXARRAYSPROC glad_glDeleteVertexArrays = NULL; +PFNGLDEPTHFUNCPROC glad_glDepthFunc = NULL; +PFNGLDEPTHMASKPROC glad_glDepthMask = NULL; +PFNGLDEPTHRANGEPROC glad_glDepthRange = NULL; +PFNGLDETACHSHADERPROC glad_glDetachShader = NULL; +PFNGLDISABLEPROC glad_glDisable = NULL; +PFNGLDISABLEVERTEXATTRIBARRAYPROC glad_glDisableVertexAttribArray = NULL; +PFNGLDISABLEIPROC glad_glDisablei = NULL; +PFNGLDRAWARRAYSPROC glad_glDrawArrays = NULL; +PFNGLDRAWARRAYSINSTANCEDPROC glad_glDrawArraysInstanced = NULL; +PFNGLDRAWBUFFERPROC glad_glDrawBuffer = NULL; +PFNGLDRAWBUFFERSPROC glad_glDrawBuffers = NULL; +PFNGLDRAWELEMENTSPROC glad_glDrawElements = NULL; +PFNGLDRAWELEMENTSBASEVERTEXPROC glad_glDrawElementsBaseVertex = NULL; +PFNGLDRAWELEMENTSINSTANCEDPROC glad_glDrawElementsInstanced = NULL; +PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC glad_glDrawElementsInstancedBaseVertex = NULL; +PFNGLDRAWRANGEELEMENTSPROC glad_glDrawRangeElements = NULL; +PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC glad_glDrawRangeElementsBaseVertex = NULL; +PFNGLENABLEPROC glad_glEnable = NULL; +PFNGLENABLEVERTEXATTRIBARRAYPROC glad_glEnableVertexAttribArray = NULL; +PFNGLENABLEIPROC glad_glEnablei = NULL; +PFNGLENDCONDITIONALRENDERPROC glad_glEndConditionalRender = NULL; +PFNGLENDQUERYPROC glad_glEndQuery = NULL; +PFNGLENDTRANSFORMFEEDBACKPROC glad_glEndTransformFeedback = NULL; +PFNGLFENCESYNCPROC glad_glFenceSync = NULL; +PFNGLFINISHPROC glad_glFinish = NULL; +PFNGLFLUSHPROC glad_glFlush = NULL; +PFNGLFLUSHMAPPEDBUFFERRANGEPROC glad_glFlushMappedBufferRange = NULL; +PFNGLFRAMEBUFFERRENDERBUFFERPROC glad_glFramebufferRenderbuffer = NULL; +PFNGLFRAMEBUFFERTEXTUREPROC glad_glFramebufferTexture = NULL; +PFNGLFRAMEBUFFERTEXTURE1DPROC glad_glFramebufferTexture1D = NULL; +PFNGLFRAMEBUFFERTEXTURE2DPROC glad_glFramebufferTexture2D = NULL; +PFNGLFRAMEBUFFERTEXTURE3DPROC glad_glFramebufferTexture3D = NULL; +PFNGLFRAMEBUFFERTEXTURELAYERPROC glad_glFramebufferTextureLayer = NULL; +PFNGLFRONTFACEPROC glad_glFrontFace = NULL; +PFNGLGENBUFFERSPROC glad_glGenBuffers = NULL; +PFNGLGENFRAMEBUFFERSPROC glad_glGenFramebuffers = NULL; +PFNGLGENQUERIESPROC glad_glGenQueries = NULL; +PFNGLGENRENDERBUFFERSPROC glad_glGenRenderbuffers = NULL; +PFNGLGENSAMPLERSPROC glad_glGenSamplers = NULL; +PFNGLGENTEXTURESPROC glad_glGenTextures = NULL; +PFNGLGENVERTEXARRAYSPROC glad_glGenVertexArrays = NULL; +PFNGLGENERATEMIPMAPPROC glad_glGenerateMipmap = NULL; +PFNGLGETACTIVEATTRIBPROC glad_glGetActiveAttrib = NULL; +PFNGLGETACTIVEUNIFORMPROC glad_glGetActiveUniform = NULL; +PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC glad_glGetActiveUniformBlockName = NULL; +PFNGLGETACTIVEUNIFORMBLOCKIVPROC glad_glGetActiveUniformBlockiv = NULL; +PFNGLGETACTIVEUNIFORMNAMEPROC glad_glGetActiveUniformName = NULL; +PFNGLGETACTIVEUNIFORMSIVPROC glad_glGetActiveUniformsiv = NULL; +PFNGLGETATTACHEDSHADERSPROC glad_glGetAttachedShaders = NULL; +PFNGLGETATTRIBLOCATIONPROC glad_glGetAttribLocation = NULL; +PFNGLGETBOOLEANI_VPROC glad_glGetBooleani_v = NULL; +PFNGLGETBOOLEANVPROC glad_glGetBooleanv = NULL; +PFNGLGETBUFFERPARAMETERI64VPROC glad_glGetBufferParameteri64v = NULL; +PFNGLGETBUFFERPARAMETERIVPROC glad_glGetBufferParameteriv = NULL; +PFNGLGETBUFFERPOINTERVPROC glad_glGetBufferPointerv = NULL; +PFNGLGETBUFFERSUBDATAPROC glad_glGetBufferSubData = NULL; +PFNGLGETCOMPRESSEDTEXIMAGEPROC glad_glGetCompressedTexImage = NULL; +PFNGLGETDOUBLEVPROC glad_glGetDoublev = NULL; +PFNGLGETERRORPROC glad_glGetError = NULL; +PFNGLGETFLOATVPROC glad_glGetFloatv = NULL; +PFNGLGETFRAGDATAINDEXPROC glad_glGetFragDataIndex = NULL; +PFNGLGETFRAGDATALOCATIONPROC glad_glGetFragDataLocation = NULL; +PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC glad_glGetFramebufferAttachmentParameteriv = NULL; +PFNGLGETINTEGER64I_VPROC glad_glGetInteger64i_v = NULL; +PFNGLGETINTEGER64VPROC glad_glGetInteger64v = NULL; +PFNGLGETINTEGERI_VPROC glad_glGetIntegeri_v = NULL; +PFNGLGETINTEGERVPROC glad_glGetIntegerv = NULL; +PFNGLGETMULTISAMPLEFVPROC glad_glGetMultisamplefv = NULL; +PFNGLGETPROGRAMINFOLOGPROC glad_glGetProgramInfoLog = NULL; +PFNGLGETPROGRAMIVPROC glad_glGetProgramiv = NULL; +PFNGLGETQUERYOBJECTI64VPROC glad_glGetQueryObjecti64v = NULL; +PFNGLGETQUERYOBJECTIVPROC glad_glGetQueryObjectiv = NULL; +PFNGLGETQUERYOBJECTUI64VPROC glad_glGetQueryObjectui64v = NULL; +PFNGLGETQUERYOBJECTUIVPROC glad_glGetQueryObjectuiv = NULL; +PFNGLGETQUERYIVPROC glad_glGetQueryiv = NULL; +PFNGLGETRENDERBUFFERPARAMETERIVPROC glad_glGetRenderbufferParameteriv = NULL; +PFNGLGETSAMPLERPARAMETERIIVPROC glad_glGetSamplerParameterIiv = NULL; +PFNGLGETSAMPLERPARAMETERIUIVPROC glad_glGetSamplerParameterIuiv = NULL; +PFNGLGETSAMPLERPARAMETERFVPROC glad_glGetSamplerParameterfv = NULL; +PFNGLGETSAMPLERPARAMETERIVPROC glad_glGetSamplerParameteriv = NULL; +PFNGLGETSHADERINFOLOGPROC glad_glGetShaderInfoLog = NULL; +PFNGLGETSHADERSOURCEPROC glad_glGetShaderSource = NULL; +PFNGLGETSHADERIVPROC glad_glGetShaderiv = NULL; +PFNGLGETSTRINGPROC glad_glGetString = NULL; +PFNGLGETSTRINGIPROC glad_glGetStringi = NULL; +PFNGLGETSYNCIVPROC glad_glGetSynciv = NULL; +PFNGLGETTEXIMAGEPROC glad_glGetTexImage = NULL; +PFNGLGETTEXLEVELPARAMETERFVPROC glad_glGetTexLevelParameterfv = NULL; +PFNGLGETTEXLEVELPARAMETERIVPROC glad_glGetTexLevelParameteriv = NULL; +PFNGLGETTEXPARAMETERIIVPROC glad_glGetTexParameterIiv = NULL; +PFNGLGETTEXPARAMETERIUIVPROC glad_glGetTexParameterIuiv = NULL; +PFNGLGETTEXPARAMETERFVPROC glad_glGetTexParameterfv = NULL; +PFNGLGETTEXPARAMETERIVPROC glad_glGetTexParameteriv = NULL; +PFNGLGETTRANSFORMFEEDBACKVARYINGPROC glad_glGetTransformFeedbackVarying = NULL; +PFNGLGETUNIFORMBLOCKINDEXPROC glad_glGetUniformBlockIndex = NULL; +PFNGLGETUNIFORMINDICESPROC glad_glGetUniformIndices = NULL; +PFNGLGETUNIFORMLOCATIONPROC glad_glGetUniformLocation = NULL; +PFNGLGETUNIFORMFVPROC glad_glGetUniformfv = NULL; +PFNGLGETUNIFORMIVPROC glad_glGetUniformiv = NULL; +PFNGLGETUNIFORMUIVPROC glad_glGetUniformuiv = NULL; +PFNGLGETVERTEXATTRIBIIVPROC glad_glGetVertexAttribIiv = NULL; +PFNGLGETVERTEXATTRIBIUIVPROC glad_glGetVertexAttribIuiv = NULL; +PFNGLGETVERTEXATTRIBPOINTERVPROC glad_glGetVertexAttribPointerv = NULL; +PFNGLGETVERTEXATTRIBDVPROC glad_glGetVertexAttribdv = NULL; +PFNGLGETVERTEXATTRIBFVPROC glad_glGetVertexAttribfv = NULL; +PFNGLGETVERTEXATTRIBIVPROC glad_glGetVertexAttribiv = NULL; +PFNGLHINTPROC glad_glHint = NULL; +PFNGLISBUFFERPROC glad_glIsBuffer = NULL; +PFNGLISENABLEDPROC glad_glIsEnabled = NULL; +PFNGLISENABLEDIPROC glad_glIsEnabledi = NULL; +PFNGLISFRAMEBUFFERPROC glad_glIsFramebuffer = NULL; +PFNGLISPROGRAMPROC glad_glIsProgram = NULL; +PFNGLISQUERYPROC glad_glIsQuery = NULL; +PFNGLISRENDERBUFFERPROC glad_glIsRenderbuffer = NULL; +PFNGLISSAMPLERPROC glad_glIsSampler = NULL; +PFNGLISSHADERPROC glad_glIsShader = NULL; +PFNGLISSYNCPROC glad_glIsSync = NULL; +PFNGLISTEXTUREPROC glad_glIsTexture = NULL; +PFNGLISVERTEXARRAYPROC glad_glIsVertexArray = NULL; +PFNGLLINEWIDTHPROC glad_glLineWidth = NULL; +PFNGLLINKPROGRAMPROC glad_glLinkProgram = NULL; +PFNGLLOGICOPPROC glad_glLogicOp = NULL; +PFNGLMAPBUFFERPROC glad_glMapBuffer = NULL; +PFNGLMAPBUFFERRANGEPROC glad_glMapBufferRange = NULL; +PFNGLMULTIDRAWARRAYSPROC glad_glMultiDrawArrays = NULL; +PFNGLMULTIDRAWELEMENTSPROC glad_glMultiDrawElements = NULL; +PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC glad_glMultiDrawElementsBaseVertex = NULL; +PFNGLMULTITEXCOORDP1UIPROC glad_glMultiTexCoordP1ui = NULL; +PFNGLMULTITEXCOORDP1UIVPROC glad_glMultiTexCoordP1uiv = NULL; +PFNGLMULTITEXCOORDP2UIPROC glad_glMultiTexCoordP2ui = NULL; +PFNGLMULTITEXCOORDP2UIVPROC glad_glMultiTexCoordP2uiv = NULL; +PFNGLMULTITEXCOORDP3UIPROC glad_glMultiTexCoordP3ui = NULL; +PFNGLMULTITEXCOORDP3UIVPROC glad_glMultiTexCoordP3uiv = NULL; +PFNGLMULTITEXCOORDP4UIPROC glad_glMultiTexCoordP4ui = NULL; +PFNGLMULTITEXCOORDP4UIVPROC glad_glMultiTexCoordP4uiv = NULL; +PFNGLNORMALP3UIPROC glad_glNormalP3ui = NULL; +PFNGLNORMALP3UIVPROC glad_glNormalP3uiv = NULL; +PFNGLPIXELSTOREFPROC glad_glPixelStoref = NULL; +PFNGLPIXELSTOREIPROC glad_glPixelStorei = NULL; +PFNGLPOINTPARAMETERFPROC glad_glPointParameterf = NULL; +PFNGLPOINTPARAMETERFVPROC glad_glPointParameterfv = NULL; +PFNGLPOINTPARAMETERIPROC glad_glPointParameteri = NULL; +PFNGLPOINTPARAMETERIVPROC glad_glPointParameteriv = NULL; +PFNGLPOINTSIZEPROC glad_glPointSize = NULL; +PFNGLPOLYGONMODEPROC glad_glPolygonMode = NULL; +PFNGLPOLYGONOFFSETPROC glad_glPolygonOffset = NULL; +PFNGLPRIMITIVERESTARTINDEXPROC glad_glPrimitiveRestartIndex = NULL; +PFNGLPROVOKINGVERTEXPROC glad_glProvokingVertex = NULL; +PFNGLQUERYCOUNTERPROC glad_glQueryCounter = NULL; +PFNGLREADBUFFERPROC glad_glReadBuffer = NULL; +PFNGLREADPIXELSPROC glad_glReadPixels = NULL; +PFNGLRENDERBUFFERSTORAGEPROC glad_glRenderbufferStorage = NULL; +PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC glad_glRenderbufferStorageMultisample = NULL; +PFNGLSAMPLECOVERAGEPROC glad_glSampleCoverage = NULL; +PFNGLSAMPLEMASKIPROC glad_glSampleMaski = NULL; +PFNGLSAMPLERPARAMETERIIVPROC glad_glSamplerParameterIiv = NULL; +PFNGLSAMPLERPARAMETERIUIVPROC glad_glSamplerParameterIuiv = NULL; +PFNGLSAMPLERPARAMETERFPROC glad_glSamplerParameterf = NULL; +PFNGLSAMPLERPARAMETERFVPROC glad_glSamplerParameterfv = NULL; +PFNGLSAMPLERPARAMETERIPROC glad_glSamplerParameteri = NULL; +PFNGLSAMPLERPARAMETERIVPROC glad_glSamplerParameteriv = NULL; +PFNGLSCISSORPROC glad_glScissor = NULL; +PFNGLSECONDARYCOLORP3UIPROC glad_glSecondaryColorP3ui = NULL; +PFNGLSECONDARYCOLORP3UIVPROC glad_glSecondaryColorP3uiv = NULL; +PFNGLSHADERSOURCEPROC glad_glShaderSource = NULL; +PFNGLSTENCILFUNCPROC glad_glStencilFunc = NULL; +PFNGLSTENCILFUNCSEPARATEPROC glad_glStencilFuncSeparate = NULL; +PFNGLSTENCILMASKPROC glad_glStencilMask = NULL; +PFNGLSTENCILMASKSEPARATEPROC glad_glStencilMaskSeparate = NULL; +PFNGLSTENCILOPPROC glad_glStencilOp = NULL; +PFNGLSTENCILOPSEPARATEPROC glad_glStencilOpSeparate = NULL; +PFNGLTEXBUFFERPROC glad_glTexBuffer = NULL; +PFNGLTEXCOORDP1UIPROC glad_glTexCoordP1ui = NULL; +PFNGLTEXCOORDP1UIVPROC glad_glTexCoordP1uiv = NULL; +PFNGLTEXCOORDP2UIPROC glad_glTexCoordP2ui = NULL; +PFNGLTEXCOORDP2UIVPROC glad_glTexCoordP2uiv = NULL; +PFNGLTEXCOORDP3UIPROC glad_glTexCoordP3ui = NULL; +PFNGLTEXCOORDP3UIVPROC glad_glTexCoordP3uiv = NULL; +PFNGLTEXCOORDP4UIPROC glad_glTexCoordP4ui = NULL; +PFNGLTEXCOORDP4UIVPROC glad_glTexCoordP4uiv = NULL; +PFNGLTEXIMAGE1DPROC glad_glTexImage1D = NULL; +PFNGLTEXIMAGE2DPROC glad_glTexImage2D = NULL; +PFNGLTEXIMAGE2DMULTISAMPLEPROC glad_glTexImage2DMultisample = NULL; +PFNGLTEXIMAGE3DPROC glad_glTexImage3D = NULL; +PFNGLTEXIMAGE3DMULTISAMPLEPROC glad_glTexImage3DMultisample = NULL; +PFNGLTEXPARAMETERIIVPROC glad_glTexParameterIiv = NULL; +PFNGLTEXPARAMETERIUIVPROC glad_glTexParameterIuiv = NULL; +PFNGLTEXPARAMETERFPROC glad_glTexParameterf = NULL; +PFNGLTEXPARAMETERFVPROC glad_glTexParameterfv = NULL; +PFNGLTEXPARAMETERIPROC glad_glTexParameteri = NULL; +PFNGLTEXPARAMETERIVPROC glad_glTexParameteriv = NULL; +PFNGLTEXSUBIMAGE1DPROC glad_glTexSubImage1D = NULL; +PFNGLTEXSUBIMAGE2DPROC glad_glTexSubImage2D = NULL; +PFNGLTEXSUBIMAGE3DPROC glad_glTexSubImage3D = NULL; +PFNGLTRANSFORMFEEDBACKVARYINGSPROC glad_glTransformFeedbackVaryings = NULL; +PFNGLUNIFORM1FPROC glad_glUniform1f = NULL; +PFNGLUNIFORM1FVPROC glad_glUniform1fv = NULL; +PFNGLUNIFORM1IPROC glad_glUniform1i = NULL; +PFNGLUNIFORM1IVPROC glad_glUniform1iv = NULL; +PFNGLUNIFORM1UIPROC glad_glUniform1ui = NULL; +PFNGLUNIFORM1UIVPROC glad_glUniform1uiv = NULL; +PFNGLUNIFORM2FPROC glad_glUniform2f = NULL; +PFNGLUNIFORM2FVPROC glad_glUniform2fv = NULL; +PFNGLUNIFORM2IPROC glad_glUniform2i = NULL; +PFNGLUNIFORM2IVPROC glad_glUniform2iv = NULL; +PFNGLUNIFORM2UIPROC glad_glUniform2ui = NULL; +PFNGLUNIFORM2UIVPROC glad_glUniform2uiv = NULL; +PFNGLUNIFORM3FPROC glad_glUniform3f = NULL; +PFNGLUNIFORM3FVPROC glad_glUniform3fv = NULL; +PFNGLUNIFORM3IPROC glad_glUniform3i = NULL; +PFNGLUNIFORM3IVPROC glad_glUniform3iv = NULL; +PFNGLUNIFORM3UIPROC glad_glUniform3ui = NULL; +PFNGLUNIFORM3UIVPROC glad_glUniform3uiv = NULL; +PFNGLUNIFORM4FPROC glad_glUniform4f = NULL; +PFNGLUNIFORM4FVPROC glad_glUniform4fv = NULL; +PFNGLUNIFORM4IPROC glad_glUniform4i = NULL; +PFNGLUNIFORM4IVPROC glad_glUniform4iv = NULL; +PFNGLUNIFORM4UIPROC glad_glUniform4ui = NULL; +PFNGLUNIFORM4UIVPROC glad_glUniform4uiv = NULL; +PFNGLUNIFORMBLOCKBINDINGPROC glad_glUniformBlockBinding = NULL; +PFNGLUNIFORMMATRIX2FVPROC glad_glUniformMatrix2fv = NULL; +PFNGLUNIFORMMATRIX2X3FVPROC glad_glUniformMatrix2x3fv = NULL; +PFNGLUNIFORMMATRIX2X4FVPROC glad_glUniformMatrix2x4fv = NULL; +PFNGLUNIFORMMATRIX3FVPROC glad_glUniformMatrix3fv = NULL; +PFNGLUNIFORMMATRIX3X2FVPROC glad_glUniformMatrix3x2fv = NULL; +PFNGLUNIFORMMATRIX3X4FVPROC glad_glUniformMatrix3x4fv = NULL; +PFNGLUNIFORMMATRIX4FVPROC glad_glUniformMatrix4fv = NULL; +PFNGLUNIFORMMATRIX4X2FVPROC glad_glUniformMatrix4x2fv = NULL; +PFNGLUNIFORMMATRIX4X3FVPROC glad_glUniformMatrix4x3fv = NULL; +PFNGLUNMAPBUFFERPROC glad_glUnmapBuffer = NULL; +PFNGLUSEPROGRAMPROC glad_glUseProgram = NULL; +PFNGLVALIDATEPROGRAMPROC glad_glValidateProgram = NULL; +PFNGLVERTEXATTRIB1DPROC glad_glVertexAttrib1d = NULL; +PFNGLVERTEXATTRIB1DVPROC glad_glVertexAttrib1dv = NULL; +PFNGLVERTEXATTRIB1FPROC glad_glVertexAttrib1f = NULL; +PFNGLVERTEXATTRIB1FVPROC glad_glVertexAttrib1fv = NULL; +PFNGLVERTEXATTRIB1SPROC glad_glVertexAttrib1s = NULL; +PFNGLVERTEXATTRIB1SVPROC glad_glVertexAttrib1sv = NULL; +PFNGLVERTEXATTRIB2DPROC glad_glVertexAttrib2d = NULL; +PFNGLVERTEXATTRIB2DVPROC glad_glVertexAttrib2dv = NULL; +PFNGLVERTEXATTRIB2FPROC glad_glVertexAttrib2f = NULL; +PFNGLVERTEXATTRIB2FVPROC glad_glVertexAttrib2fv = NULL; +PFNGLVERTEXATTRIB2SPROC glad_glVertexAttrib2s = NULL; +PFNGLVERTEXATTRIB2SVPROC glad_glVertexAttrib2sv = NULL; +PFNGLVERTEXATTRIB3DPROC glad_glVertexAttrib3d = NULL; +PFNGLVERTEXATTRIB3DVPROC glad_glVertexAttrib3dv = NULL; +PFNGLVERTEXATTRIB3FPROC glad_glVertexAttrib3f = NULL; +PFNGLVERTEXATTRIB3FVPROC glad_glVertexAttrib3fv = NULL; +PFNGLVERTEXATTRIB3SPROC glad_glVertexAttrib3s = NULL; +PFNGLVERTEXATTRIB3SVPROC glad_glVertexAttrib3sv = NULL; +PFNGLVERTEXATTRIB4NBVPROC glad_glVertexAttrib4Nbv = NULL; +PFNGLVERTEXATTRIB4NIVPROC glad_glVertexAttrib4Niv = NULL; +PFNGLVERTEXATTRIB4NSVPROC glad_glVertexAttrib4Nsv = NULL; +PFNGLVERTEXATTRIB4NUBPROC glad_glVertexAttrib4Nub = NULL; +PFNGLVERTEXATTRIB4NUBVPROC glad_glVertexAttrib4Nubv = NULL; +PFNGLVERTEXATTRIB4NUIVPROC glad_glVertexAttrib4Nuiv = NULL; +PFNGLVERTEXATTRIB4NUSVPROC glad_glVertexAttrib4Nusv = NULL; +PFNGLVERTEXATTRIB4BVPROC glad_glVertexAttrib4bv = NULL; +PFNGLVERTEXATTRIB4DPROC glad_glVertexAttrib4d = NULL; +PFNGLVERTEXATTRIB4DVPROC glad_glVertexAttrib4dv = NULL; +PFNGLVERTEXATTRIB4FPROC glad_glVertexAttrib4f = NULL; +PFNGLVERTEXATTRIB4FVPROC glad_glVertexAttrib4fv = NULL; +PFNGLVERTEXATTRIB4IVPROC glad_glVertexAttrib4iv = NULL; +PFNGLVERTEXATTRIB4SPROC glad_glVertexAttrib4s = NULL; +PFNGLVERTEXATTRIB4SVPROC glad_glVertexAttrib4sv = NULL; +PFNGLVERTEXATTRIB4UBVPROC glad_glVertexAttrib4ubv = NULL; +PFNGLVERTEXATTRIB4UIVPROC glad_glVertexAttrib4uiv = NULL; +PFNGLVERTEXATTRIB4USVPROC glad_glVertexAttrib4usv = NULL; +PFNGLVERTEXATTRIBDIVISORPROC glad_glVertexAttribDivisor = NULL; +PFNGLVERTEXATTRIBI1IPROC glad_glVertexAttribI1i = NULL; +PFNGLVERTEXATTRIBI1IVPROC glad_glVertexAttribI1iv = NULL; +PFNGLVERTEXATTRIBI1UIPROC glad_glVertexAttribI1ui = NULL; +PFNGLVERTEXATTRIBI1UIVPROC glad_glVertexAttribI1uiv = NULL; +PFNGLVERTEXATTRIBI2IPROC glad_glVertexAttribI2i = NULL; +PFNGLVERTEXATTRIBI2IVPROC glad_glVertexAttribI2iv = NULL; +PFNGLVERTEXATTRIBI2UIPROC glad_glVertexAttribI2ui = NULL; +PFNGLVERTEXATTRIBI2UIVPROC glad_glVertexAttribI2uiv = NULL; +PFNGLVERTEXATTRIBI3IPROC glad_glVertexAttribI3i = NULL; +PFNGLVERTEXATTRIBI3IVPROC glad_glVertexAttribI3iv = NULL; +PFNGLVERTEXATTRIBI3UIPROC glad_glVertexAttribI3ui = NULL; +PFNGLVERTEXATTRIBI3UIVPROC glad_glVertexAttribI3uiv = NULL; +PFNGLVERTEXATTRIBI4BVPROC glad_glVertexAttribI4bv = NULL; +PFNGLVERTEXATTRIBI4IPROC glad_glVertexAttribI4i = NULL; +PFNGLVERTEXATTRIBI4IVPROC glad_glVertexAttribI4iv = NULL; +PFNGLVERTEXATTRIBI4SVPROC glad_glVertexAttribI4sv = NULL; +PFNGLVERTEXATTRIBI4UBVPROC glad_glVertexAttribI4ubv = NULL; +PFNGLVERTEXATTRIBI4UIPROC glad_glVertexAttribI4ui = NULL; +PFNGLVERTEXATTRIBI4UIVPROC glad_glVertexAttribI4uiv = NULL; +PFNGLVERTEXATTRIBI4USVPROC glad_glVertexAttribI4usv = NULL; +PFNGLVERTEXATTRIBIPOINTERPROC glad_glVertexAttribIPointer = NULL; +PFNGLVERTEXATTRIBP1UIPROC glad_glVertexAttribP1ui = NULL; +PFNGLVERTEXATTRIBP1UIVPROC glad_glVertexAttribP1uiv = NULL; +PFNGLVERTEXATTRIBP2UIPROC glad_glVertexAttribP2ui = NULL; +PFNGLVERTEXATTRIBP2UIVPROC glad_glVertexAttribP2uiv = NULL; +PFNGLVERTEXATTRIBP3UIPROC glad_glVertexAttribP3ui = NULL; +PFNGLVERTEXATTRIBP3UIVPROC glad_glVertexAttribP3uiv = NULL; +PFNGLVERTEXATTRIBP4UIPROC glad_glVertexAttribP4ui = NULL; +PFNGLVERTEXATTRIBP4UIVPROC glad_glVertexAttribP4uiv = NULL; +PFNGLVERTEXATTRIBPOINTERPROC glad_glVertexAttribPointer = NULL; +PFNGLVERTEXP2UIPROC glad_glVertexP2ui = NULL; +PFNGLVERTEXP2UIVPROC glad_glVertexP2uiv = NULL; +PFNGLVERTEXP3UIPROC glad_glVertexP3ui = NULL; +PFNGLVERTEXP3UIVPROC glad_glVertexP3uiv = NULL; +PFNGLVERTEXP4UIPROC glad_glVertexP4ui = NULL; +PFNGLVERTEXP4UIVPROC glad_glVertexP4uiv = NULL; +PFNGLVIEWPORTPROC glad_glViewport = NULL; +PFNGLWAITSYNCPROC glad_glWaitSync = NULL; +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"); +} +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_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"); +} +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"); +} +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_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; + (void)&has_ext; + 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; +} + diff --git a/Engine/engine/match b/Engine/engine/match index 6daa3bde080bf450adb38627d041e1aeb354119a..33c6100de31804fbd1976f72db3d7c240fa7754a 100755 GIT binary patch literal 39336 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 diff --git a/Engine/engine/match.cpp b/Engine/engine/match.cpp index f324c8e..01c510d 100644 --- a/Engine/engine/match.cpp +++ b/Engine/engine/match.cpp @@ -1,7 +1,37 @@ -#include +#include -int main() +int main(void) { - std::cout << "hello world 2"; - return 0; + GLFWwindow* window; + + /* Initialize the library */ + if (!glfwInit()) + return -1; + + /* Create a windowed mode window and its OpenGL context */ + window = glfwCreateWindow(640, 480, "Hello World", NULL, NULL); + if (!window) + { + glfwTerminate(); + return -1; + } + + /* Make the window's context current */ + glfwMakeContextCurrent(window); + + /* Loop until the user closes the window */ + while (!glfwWindowShouldClose(window)) + { + /* Render here */ + glClear(GL_COLOR_BUFFER_BIT); + + /* Swap front and back buffers */ + glfwSwapBuffers(window); + + /* Poll for and process events */ + glfwPollEvents(); + } + + glfwTerminate(); + return 0; } \ No newline at end of file diff --git a/Thesis/Thesis.pdf b/Thesis/Thesis.pdf index ca64df246d205586c735b812995c28b396b2d4d6..d9d44be3c4ae0ebcf00e83192ff96f4a3f7bbcbf 100644 GIT binary patch delta 25009 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 jO^UJMI}e(72rgsrTwBNi~PR;5qo2z delta 25357 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 diff --git a/dependencies/include/KHR/khrplatform.h b/dependencies/include/KHR/khrplatform.h new file mode 100644 index 0000000..0164644 --- /dev/null +++ b/dependencies/include/KHR/khrplatform.h @@ -0,0 +1,311 @@ +#ifndef __khrplatform_h_ +#define __khrplatform_h_ + +/* +** Copyright (c) 2008-2018 The Khronos Group Inc. +** +** Permission is hereby granted, free of charge, to any person obtaining a +** copy of this software and/or associated documentation files (the +** "Materials"), to deal in the Materials without restriction, including +** without limitation the rights to use, copy, modify, merge, publish, +** distribute, sublicense, and/or sell copies of the Materials, and to +** permit persons to whom the Materials are furnished to do so, subject to +** the following conditions: +** +** The above copyright notice and this permission notice shall be included +** in all copies or substantial portions of the Materials. +** +** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. +*/ + +/* Khronos platform-specific types and definitions. + * + * The master copy of khrplatform.h is maintained in the Khronos EGL + * Registry repository at https://github.com/KhronosGroup/EGL-Registry + * The last semantic modification to khrplatform.h was at commit ID: + * 67a3e0864c2d75ea5287b9f3d2eb74a745936692 + * + * Adopters may modify this file to suit their platform. Adopters are + * encouraged to submit platform specific modifications to the Khronos + * group so that they can be included in future versions of this file. + * Please submit changes by filing pull requests or issues on + * the EGL Registry repository linked above. + * + * + * See the Implementer's Guidelines for information about where this file + * should be located on your system and for more details of its use: + * http://www.khronos.org/registry/implementers_guide.pdf + * + * This file should be included as + * #include + * by Khronos client API header files that use its types and defines. + * + * The types in khrplatform.h should only be used to define API-specific types. + * + * Types defined in khrplatform.h: + * khronos_int8_t signed 8 bit + * khronos_uint8_t unsigned 8 bit + * khronos_int16_t signed 16 bit + * khronos_uint16_t unsigned 16 bit + * khronos_int32_t signed 32 bit + * khronos_uint32_t unsigned 32 bit + * khronos_int64_t signed 64 bit + * khronos_uint64_t unsigned 64 bit + * khronos_intptr_t signed same number of bits as a pointer + * khronos_uintptr_t unsigned same number of bits as a pointer + * khronos_ssize_t signed size + * khronos_usize_t unsigned size + * khronos_float_t signed 32 bit floating point + * khronos_time_ns_t unsigned 64 bit time in nanoseconds + * khronos_utime_nanoseconds_t unsigned time interval or absolute time in + * nanoseconds + * khronos_stime_nanoseconds_t signed time interval in nanoseconds + * khronos_boolean_enum_t enumerated boolean type. This should + * only be used as a base type when a client API's boolean type is + * an enum. Client APIs which use an integer or other type for + * booleans cannot use this as the base type for their boolean. + * + * Tokens defined in khrplatform.h: + * + * KHRONOS_FALSE, KHRONOS_TRUE Enumerated boolean false/true values. + * + * KHRONOS_SUPPORT_INT64 is 1 if 64 bit integers are supported; otherwise 0. + * KHRONOS_SUPPORT_FLOAT is 1 if floats are supported; otherwise 0. + * + * Calling convention macros defined in this file: + * KHRONOS_APICALL + * KHRONOS_APIENTRY + * KHRONOS_APIATTRIBUTES + * + * These may be used in function prototypes as: + * + * KHRONOS_APICALL void KHRONOS_APIENTRY funcname( + * int arg1, + * int arg2) KHRONOS_APIATTRIBUTES; + */ + +#if defined(__SCITECH_SNAP__) && !defined(KHRONOS_STATIC) +# define KHRONOS_STATIC 1 +#endif + +/*------------------------------------------------------------------------- + * Definition of KHRONOS_APICALL + *------------------------------------------------------------------------- + * This precedes the return type of the function in the function prototype. + */ +#if defined(KHRONOS_STATIC) + /* If the preprocessor constant KHRONOS_STATIC is defined, make the + * header compatible with static linking. */ +# define KHRONOS_APICALL +#elif defined(_WIN32) +# define KHRONOS_APICALL __declspec(dllimport) +#elif defined (__SYMBIAN32__) +# define KHRONOS_APICALL IMPORT_C +#elif defined(__ANDROID__) +# define KHRONOS_APICALL __attribute__((visibility("default"))) +#else +# define KHRONOS_APICALL +#endif + +/*------------------------------------------------------------------------- + * Definition of KHRONOS_APIENTRY + *------------------------------------------------------------------------- + * This follows the return type of the function and precedes the function + * name in the function prototype. + */ +#if defined(_WIN32) && !defined(_WIN32_WCE) && !defined(__SCITECH_SNAP__) + /* Win32 but not WinCE */ +# define KHRONOS_APIENTRY __stdcall +#else +# define KHRONOS_APIENTRY +#endif + +/*------------------------------------------------------------------------- + * Definition of KHRONOS_APIATTRIBUTES + *------------------------------------------------------------------------- + * This follows the closing parenthesis of the function prototype arguments. + */ +#if defined (__ARMCC_2__) +#define KHRONOS_APIATTRIBUTES __softfp +#else +#define KHRONOS_APIATTRIBUTES +#endif + +/*------------------------------------------------------------------------- + * basic type definitions + *-----------------------------------------------------------------------*/ +#if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) || defined(__GNUC__) || defined(__SCO__) || defined(__USLC__) + + +/* + * Using + */ +#include +typedef int32_t khronos_int32_t; +typedef uint32_t khronos_uint32_t; +typedef int64_t khronos_int64_t; +typedef uint64_t khronos_uint64_t; +#define KHRONOS_SUPPORT_INT64 1 +#define KHRONOS_SUPPORT_FLOAT 1 +/* + * To support platform where unsigned long cannot be used interchangeably with + * inptr_t (e.g. CHERI-extended ISAs), we can use the stdint.h intptr_t. + * Ideally, we could just use (u)intptr_t everywhere, but this could result in + * ABI breakage if khronos_uintptr_t is changed from unsigned long to + * unsigned long long or similar (this results in different C++ name mangling). + * To avoid changes for existing platforms, we restrict usage of intptr_t to + * platforms where the size of a pointer is larger than the size of long. + */ +#if defined(__SIZEOF_LONG__) && defined(__SIZEOF_POINTER__) +#if __SIZEOF_POINTER__ > __SIZEOF_LONG__ +#define KHRONOS_USE_INTPTR_T +#endif +#endif + +#elif defined(__VMS ) || defined(__sgi) + +/* + * Using + */ +#include +typedef int32_t khronos_int32_t; +typedef uint32_t khronos_uint32_t; +typedef int64_t khronos_int64_t; +typedef uint64_t khronos_uint64_t; +#define KHRONOS_SUPPORT_INT64 1 +#define KHRONOS_SUPPORT_FLOAT 1 + +#elif defined(_WIN32) && !defined(__SCITECH_SNAP__) + +/* + * Win32 + */ +typedef __int32 khronos_int32_t; +typedef unsigned __int32 khronos_uint32_t; +typedef __int64 khronos_int64_t; +typedef unsigned __int64 khronos_uint64_t; +#define KHRONOS_SUPPORT_INT64 1 +#define KHRONOS_SUPPORT_FLOAT 1 + +#elif defined(__sun__) || defined(__digital__) + +/* + * Sun or Digital + */ +typedef int khronos_int32_t; +typedef unsigned int khronos_uint32_t; +#if defined(__arch64__) || defined(_LP64) +typedef long int khronos_int64_t; +typedef unsigned long int khronos_uint64_t; +#else +typedef long long int khronos_int64_t; +typedef unsigned long long int khronos_uint64_t; +#endif /* __arch64__ */ +#define KHRONOS_SUPPORT_INT64 1 +#define KHRONOS_SUPPORT_FLOAT 1 + +#elif 0 + +/* + * Hypothetical platform with no float or int64 support + */ +typedef int khronos_int32_t; +typedef unsigned int khronos_uint32_t; +#define KHRONOS_SUPPORT_INT64 0 +#define KHRONOS_SUPPORT_FLOAT 0 + +#else + +/* + * Generic fallback + */ +#include +typedef int32_t khronos_int32_t; +typedef uint32_t khronos_uint32_t; +typedef int64_t khronos_int64_t; +typedef uint64_t khronos_uint64_t; +#define KHRONOS_SUPPORT_INT64 1 +#define KHRONOS_SUPPORT_FLOAT 1 + +#endif + + +/* + * Types that are (so far) the same on all platforms + */ +typedef signed char khronos_int8_t; +typedef unsigned char khronos_uint8_t; +typedef signed short int khronos_int16_t; +typedef unsigned short int khronos_uint16_t; + +/* + * Types that differ between LLP64 and LP64 architectures - in LLP64, + * pointers are 64 bits, but 'long' is still 32 bits. Win64 appears + * to be the only LLP64 architecture in current use. + */ +#ifdef KHRONOS_USE_INTPTR_T +typedef intptr_t khronos_intptr_t; +typedef uintptr_t khronos_uintptr_t; +#elif defined(_WIN64) +typedef signed long long int khronos_intptr_t; +typedef unsigned long long int khronos_uintptr_t; +#else +typedef signed long int khronos_intptr_t; +typedef unsigned long int khronos_uintptr_t; +#endif + +#if defined(_WIN64) +typedef signed long long int khronos_ssize_t; +typedef unsigned long long int khronos_usize_t; +#else +typedef signed long int khronos_ssize_t; +typedef unsigned long int khronos_usize_t; +#endif + +#if KHRONOS_SUPPORT_FLOAT +/* + * Float type + */ +typedef float khronos_float_t; +#endif + +#if KHRONOS_SUPPORT_INT64 +/* Time types + * + * These types can be used to represent a time interval in nanoseconds or + * an absolute Unadjusted System Time. Unadjusted System Time is the number + * of nanoseconds since some arbitrary system event (e.g. since the last + * time the system booted). The Unadjusted System Time is an unsigned + * 64 bit value that wraps back to 0 every 584 years. Time intervals + * may be either signed or unsigned. + */ +typedef khronos_uint64_t khronos_utime_nanoseconds_t; +typedef khronos_int64_t khronos_stime_nanoseconds_t; +#endif + +/* + * Dummy value used to pad enum types to 32 bits. + */ +#ifndef KHRONOS_MAX_ENUM +#define KHRONOS_MAX_ENUM 0x7FFFFFFF +#endif + +/* + * Enumerated boolean type + * + * Values other than zero should be considered to be true. Therefore + * comparisons should not be made against KHRONOS_TRUE. + */ +typedef enum { + KHRONOS_FALSE = 0, + KHRONOS_TRUE = 1, + KHRONOS_BOOLEAN_ENUM_FORCE_SIZE = KHRONOS_MAX_ENUM +} khronos_boolean_enum_t; + +#endif /* __khrplatform_h_ */ diff --git a/dependencies/include/glad/glad.h b/dependencies/include/glad/glad.h new file mode 100644 index 0000000..8ca8e92 --- /dev/null +++ b/dependencies/include/glad/glad.h @@ -0,0 +1,2129 @@ +/* + + OpenGL loader generated by glad 0.1.36 on Sat Aug 27 19:06:27 2022. + + Language/Generator: C/C++ + Specification: gl + APIs: gl=3.3 + Profile: core + Extensions: + + Loader: True + Local files: False + Omit khrplatform: False + Reproducible: False + + Commandline: + --profile="core" --api="gl=3.3" --generator="c" --spec="gl" --extensions="" + Online: + https://glad.dav1d.de/#profile=core&language=c&specification=gl&loader=on&api=gl%3D3.3 +*/ + + +#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__) +#define APIENTRY __stdcall +#endif + +#ifndef APIENTRY +#define APIENTRY +#endif +#ifndef APIENTRYP +#define APIENTRYP APIENTRY * +#endif + +#ifndef GLAPIENTRY +#define GLAPIENTRY 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 +typedef unsigned int GLenum; +typedef unsigned char GLboolean; +typedef unsigned int GLbitfield; +typedef void GLvoid; +typedef khronos_int8_t GLbyte; +typedef khronos_uint8_t GLubyte; +typedef khronos_int16_t GLshort; +typedef khronos_uint16_t GLushort; +typedef int GLint; +typedef unsigned int GLuint; +typedef khronos_int32_t GLclampx; +typedef int GLsizei; +typedef khronos_float_t GLfloat; +typedef khronos_float_t GLclampf; +typedef double GLdouble; +typedef double GLclampd; +typedef void *GLeglClientBufferEXT; +typedef void *GLeglImageOES; +typedef char GLchar; +typedef char GLcharARB; +#ifdef __APPLE__ +typedef void *GLhandleARB; +#else +typedef unsigned int GLhandleARB; +#endif +typedef khronos_uint16_t GLhalf; +typedef khronos_uint16_t GLhalfARB; +typedef khronos_int32_t GLfixed; +typedef khronos_intptr_t GLintptr; +typedef khronos_intptr_t GLintptrARB; +typedef khronos_ssize_t GLsizeiptr; +typedef khronos_ssize_t GLsizeiptrARB; +typedef khronos_int64_t GLint64; +typedef khronos_int64_t GLint64EXT; +typedef khronos_uint64_t GLuint64; +typedef khronos_uint64_t GLuint64EXT; +typedef struct __GLsync *GLsync; +struct _cl_context; +struct _cl_event; +typedef void (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; +typedef void (APIENTRY *GLVULKANPROCNV)(void); +#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_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_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_TEXTURE_WIDTH 0x1000 +#define GL_TEXTURE_HEIGHT 0x1001 +#define GL_TEXTURE_BORDER_COLOR 0x1004 +#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_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_REPEAT 0x2901 +#define GL_COLOR_LOGIC_OP 0x0BF2 +#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_INTERNAL_FORMAT 0x1003 +#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_DOUBLE 0x140A +#define GL_PROXY_TEXTURE_1D 0x8063 +#define GL_PROXY_TEXTURE_2D 0x8064 +#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_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_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_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_BLEND_COLOR 0x8005 +#define GL_BLEND_EQUATION 0x8009 +#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_FUNC_ADD 0x8006 +#define GL_FUNC_REVERSE_SUBTRACT 0x800B +#define GL_FUNC_SUBTRACT 0x800A +#define GL_MIN 0x8007 +#define GL_MAX 0x8008 +#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_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_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_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_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_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)(void); +GLAPI PFNGLFINISHPROC glad_glFinish; +#define glFinish glad_glFinish +typedef void (APIENTRYP PFNGLFLUSHPROC)(void); +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)(void); +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 n, GLdouble f); +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 +#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 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 +#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 +#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 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)(void); +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)(void); +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)(void); +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 count, 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 + +#ifdef __cplusplus +} +#endif + +#endif