From cab2d2fe383d7343a69692587a7c08a2f262b8a9 Mon Sep 17 00:00:00 2001 From: Ben Date: Sat, 14 Aug 2021 22:47:15 +0100 Subject: [PATCH] WindOWIng AnD OpEnGl --- Aeon/Aeon.cpp | 22 +- Aeon/Aeon.hpp | 25 +- Aeon/Assert.hpp | 18 + Aeon/Core/Display.cpp | 71 +- Aeon/Core/Display.hpp | 37 +- Aeon/Core/EngineEvents.hpp | 6 - Aeon/ThirdParty/glad.c | 1838 +++++++++++++++++ Aeon/ThirdParty/glad.h | 3617 +++++++++++++++++++++++++++++++++ Aeon/ThirdParty/khrplatform.h | 282 +++ CMakeLists.txt | 67 +- CMakeModules/FindSDL2.cmake | 197 ++ CMakeSettings.json | 6 +- Game/ExampleGame.cpp | 9 +- SDL2.dll | Bin 0 -> 1609728 bytes 14 files changed, 6121 insertions(+), 74 deletions(-) create mode 100644 Aeon/Assert.hpp create mode 100644 Aeon/ThirdParty/glad.c create mode 100644 Aeon/ThirdParty/glad.h create mode 100644 Aeon/ThirdParty/khrplatform.h create mode 100644 CMakeModules/FindSDL2.cmake create mode 100644 SDL2.dll diff --git a/Aeon/Aeon.cpp b/Aeon/Aeon.cpp index 42eea14..4aaf3a8 100644 --- a/Aeon/Aeon.cpp +++ b/Aeon/Aeon.cpp @@ -1,13 +1,25 @@ #include "Aeon/Aeon.hpp" -Aeon::Core::App::App(const AppProperties& props) -{ +using Aeon::Core::App; +using Aeon::Core::Display; +using Aeon::Core::DisplayProperties; - Aeon::Core::Display::GetInstance(); +App::App( const DisplayProperties& props ) + : mDisplay() +{ + mDisplay.Create( props ); } -const Aeon::Core::Display& Aeon::Core::App::GetDisplay() +void App::Run() { - return Aeon::Core::Display::GetInstance(); + while ( !mSIGTERM ) + { + + } +} + +const Display& App::GetDisplay() +{ + return mDisplay; } diff --git a/Aeon/Aeon.hpp b/Aeon/Aeon.hpp index eeb04ab..2a463ce 100644 --- a/Aeon/Aeon.hpp +++ b/Aeon/Aeon.hpp @@ -7,33 +7,24 @@ namespace Aeon::Core { -class AppProperties -{ -public: - std::string Name; - int Width, Height; - bool VSync; - - AppProperties(std::string name, int width = 1200, int height = 900, bool vSync = true) - : Name(name), - Width(width), - Height(height), - VSync(vSync) { } -}; - class App { public: - App(const AppProperties& props); - virtual ~App(); + App( const DisplayProperties& props ); + void Run(); + void PushLayer(); + void PopLayer(); const Display& GetDisplay(); +private: + Display mDisplay; + + bool mSIGTERM = false; }; } #endif - \ No newline at end of file diff --git a/Aeon/Assert.hpp b/Aeon/Assert.hpp new file mode 100644 index 0000000..cd2aea8 --- /dev/null +++ b/Aeon/Assert.hpp @@ -0,0 +1,18 @@ +#ifndef AEON_ASSERT_H_ +#define AEON_ASSERT_H_ + +#include + +#define AEON_ASSERT(x, m) \ + if (! (x)) { \ + std::cerr << "Assertion `" #x "` failed in " << __FILE__ \ + << " line " << __LINE__ << ": " << m << std::endl; \ + std::terminate(); \ + } +#define AEON_ASSERT_NO_BRK(x) \ + if (! (x)) { \ + std::cerr << "Assertion `" #x "` failed in " << __FILE__ \ + << " line " << __LINE__ << ": " << m << std::endl; \ + } + +#endif diff --git a/Aeon/Core/Display.cpp b/Aeon/Core/Display.cpp index b7a1136..f94e002 100644 --- a/Aeon/Core/Display.cpp +++ b/Aeon/Core/Display.cpp @@ -2,7 +2,74 @@ #include -Aeon::Core::Display::Display() +#include "Aeon/Assert.hpp" + +using Aeon::Core::Display; + +Display::Display() + : mWindow( nullptr ), + mContext( NULL ) { - std::cout << "bruh" << std::endl; + +} + +bool Display::Create( const DisplayProperties& properties ) +{ + SDL_Init( SDL_INIT_VIDEO ); + + SDL_GL_SetAttribute( SDL_GL_RED_SIZE, 8 ); + SDL_GL_SetAttribute( SDL_GL_GREEN_SIZE, 8 ); + SDL_GL_SetAttribute( SDL_GL_BLUE_SIZE, 8 ); + SDL_GL_SetAttribute( SDL_GL_ALPHA_SIZE, 8 ); + SDL_GL_SetAttribute( SDL_GL_BUFFER_SIZE, 32 ); + SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 ); + + SDL_GL_SetAttribute( SDL_GL_MULTISAMPLEBUFFERS, 1 ); + SDL_GL_SetAttribute( SDL_GL_MULTISAMPLESAMPLES, 4 ); + + SDL_GL_SetAttribute( SDL_GL_CONTEXT_MAJOR_VERSION, 4 ); + SDL_GL_SetAttribute( SDL_GL_CONTEXT_MINOR_VERSION, 5 ); + + mWindow = SDL_CreateWindow( properties.Name.c_str(), + SDL_WINDOWPOS_CENTERED, + SDL_WINDOWPOS_CENTERED, properties.Width, properties.Height, + SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE ); + + AEON_ASSERT( mWindow, "Can't initialise window" ); + + mContext = SDL_GL_CreateContext( mWindow ); + + AEON_ASSERT( mContext, "Can't initialise context" ); + + SDL_GL_SetSwapInterval( static_cast(!properties.VSync) ); + + gladLoadGLLoader( SDL_GL_GetProcAddress ); + glEnable( GL_MULTISAMPLE ); + glCullFace( GL_BACK ); + glEnable( GL_DEPTH_TEST ); + + mWidth = properties.Width; + mHeight = properties.Height; + + return true; +} + +Display::~Display() +{ + +} + +unsigned int Display::GetWidth() +{ + return mWidth; +} + +unsigned int Display::GetHeight() +{ + return mHeight; +} + +void Display::Destroy() +{ + } diff --git a/Aeon/Core/Display.hpp b/Aeon/Core/Display.hpp index 23ae526..5fdef50 100644 --- a/Aeon/Core/Display.hpp +++ b/Aeon/Core/Display.hpp @@ -1,18 +1,45 @@ #ifndef AEON_CORE_DISPLAY_H_ #define AEON_CORE_DISPLAY_H_ +#include + +#include +#include + namespace Aeon::Core { +class DisplayProperties +{ +public: + std::string Name; + int Width, Height; + bool VSync; + + DisplayProperties( std::string name, int width = 1200, int height = 900, bool vSync = true ) + : Name( name ), + Width( width ), + Height( height ), + VSync( vSync ) { } +}; + class Display { public: Display(); + ~Display(); - static inline Display& GetInstance() - { - static Display instance; - return instance; - } + bool Create( const DisplayProperties& properties ); + + unsigned int GetWidth(); + unsigned int GetHeight(); + + void Destroy(); + +private: + SDL_Window* mWindow; + SDL_GLContext mContext; + + unsigned int mWidth, mHeight; private: Display( Display const& ) = delete; diff --git a/Aeon/Core/EngineEvents.hpp b/Aeon/Core/EngineEvents.hpp index 9f01c7a..4028430 100644 --- a/Aeon/Core/EngineEvents.hpp +++ b/Aeon/Core/EngineEvents.hpp @@ -14,12 +14,6 @@ namespace Aeon::Core { - -enum EventSystem -{ - -}; - class GenericEvent { diff --git a/Aeon/ThirdParty/glad.c b/Aeon/ThirdParty/glad.c new file mode 100644 index 0000000..bf1b7a1 --- /dev/null +++ b/Aeon/ThirdParty/glad.c @@ -0,0 +1,1838 @@ +/* + OpenGL loader generated by glad 0.1.28 on Tue Jan 15 14:49:19 2019. + Language/Generator: C/C++ + Specification: gl + APIs: gl=3.3 + Profile: compatibility + Extensions: + Loader: True + Local files: False + Omit khrplatform: False + Reproducible: False + Commandline: + --profile="compatibility" --api="gl=3.3" --generator="c" --spec="gl" --extensions="" + Online: + https://glad.dav1d.de/#profile=compatibility&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__) +#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 ) { + char** tmp_exts_i = (char**)realloc( (void*)exts_i, (size_t)num_exts_i * (sizeof * exts_i) ); + if ( tmp_exts_i == NULL ) { + return 0; + } + exts_i = tmp_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; +PFNGLACCUMPROC glad_glAccum = NULL; +PFNGLACTIVETEXTUREPROC glad_glActiveTexture = NULL; +PFNGLALPHAFUNCPROC glad_glAlphaFunc = NULL; +PFNGLARETEXTURESRESIDENTPROC glad_glAreTexturesResident = NULL; +PFNGLARRAYELEMENTPROC glad_glArrayElement = NULL; +PFNGLATTACHSHADERPROC glad_glAttachShader = NULL; +PFNGLBEGINPROC glad_glBegin = 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; +PFNGLBITMAPPROC glad_glBitmap = 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; +PFNGLCALLLISTPROC glad_glCallList = NULL; +PFNGLCALLLISTSPROC glad_glCallLists = NULL; +PFNGLCHECKFRAMEBUFFERSTATUSPROC glad_glCheckFramebufferStatus = NULL; +PFNGLCLAMPCOLORPROC glad_glClampColor = NULL; +PFNGLCLEARPROC glad_glClear = NULL; +PFNGLCLEARACCUMPROC glad_glClearAccum = 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; +PFNGLCLEARINDEXPROC glad_glClearIndex = NULL; +PFNGLCLEARSTENCILPROC glad_glClearStencil = NULL; +PFNGLCLIENTACTIVETEXTUREPROC glad_glClientActiveTexture = NULL; +PFNGLCLIENTWAITSYNCPROC glad_glClientWaitSync = NULL; +PFNGLCLIPPLANEPROC glad_glClipPlane = NULL; +PFNGLCOLOR3BPROC glad_glColor3b = NULL; +PFNGLCOLOR3BVPROC glad_glColor3bv = NULL; +PFNGLCOLOR3DPROC glad_glColor3d = NULL; +PFNGLCOLOR3DVPROC glad_glColor3dv = NULL; +PFNGLCOLOR3FPROC glad_glColor3f = NULL; +PFNGLCOLOR3FVPROC glad_glColor3fv = NULL; +PFNGLCOLOR3IPROC glad_glColor3i = NULL; +PFNGLCOLOR3IVPROC glad_glColor3iv = NULL; +PFNGLCOLOR3SPROC glad_glColor3s = NULL; +PFNGLCOLOR3SVPROC glad_glColor3sv = NULL; +PFNGLCOLOR3UBPROC glad_glColor3ub = NULL; +PFNGLCOLOR3UBVPROC glad_glColor3ubv = NULL; +PFNGLCOLOR3UIPROC glad_glColor3ui = NULL; +PFNGLCOLOR3UIVPROC glad_glColor3uiv = NULL; +PFNGLCOLOR3USPROC glad_glColor3us = NULL; +PFNGLCOLOR3USVPROC glad_glColor3usv = NULL; +PFNGLCOLOR4BPROC glad_glColor4b = NULL; +PFNGLCOLOR4BVPROC glad_glColor4bv = NULL; +PFNGLCOLOR4DPROC glad_glColor4d = NULL; +PFNGLCOLOR4DVPROC glad_glColor4dv = NULL; +PFNGLCOLOR4FPROC glad_glColor4f = NULL; +PFNGLCOLOR4FVPROC glad_glColor4fv = NULL; +PFNGLCOLOR4IPROC glad_glColor4i = NULL; +PFNGLCOLOR4IVPROC glad_glColor4iv = NULL; +PFNGLCOLOR4SPROC glad_glColor4s = NULL; +PFNGLCOLOR4SVPROC glad_glColor4sv = NULL; +PFNGLCOLOR4UBPROC glad_glColor4ub = NULL; +PFNGLCOLOR4UBVPROC glad_glColor4ubv = NULL; +PFNGLCOLOR4UIPROC glad_glColor4ui = NULL; +PFNGLCOLOR4UIVPROC glad_glColor4uiv = NULL; +PFNGLCOLOR4USPROC glad_glColor4us = NULL; +PFNGLCOLOR4USVPROC glad_glColor4usv = NULL; +PFNGLCOLORMASKPROC glad_glColorMask = NULL; +PFNGLCOLORMASKIPROC glad_glColorMaski = NULL; +PFNGLCOLORMATERIALPROC glad_glColorMaterial = NULL; +PFNGLCOLORP3UIPROC glad_glColorP3ui = NULL; +PFNGLCOLORP3UIVPROC glad_glColorP3uiv = NULL; +PFNGLCOLORP4UIPROC glad_glColorP4ui = NULL; +PFNGLCOLORP4UIVPROC glad_glColorP4uiv = NULL; +PFNGLCOLORPOINTERPROC glad_glColorPointer = 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; +PFNGLCOPYPIXELSPROC glad_glCopyPixels = 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; +PFNGLDELETELISTSPROC glad_glDeleteLists = 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; +PFNGLDISABLECLIENTSTATEPROC glad_glDisableClientState = 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; +PFNGLDRAWPIXELSPROC glad_glDrawPixels = NULL; +PFNGLDRAWRANGEELEMENTSPROC glad_glDrawRangeElements = NULL; +PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC glad_glDrawRangeElementsBaseVertex = NULL; +PFNGLEDGEFLAGPROC glad_glEdgeFlag = NULL; +PFNGLEDGEFLAGPOINTERPROC glad_glEdgeFlagPointer = NULL; +PFNGLEDGEFLAGVPROC glad_glEdgeFlagv = NULL; +PFNGLENABLEPROC glad_glEnable = NULL; +PFNGLENABLECLIENTSTATEPROC glad_glEnableClientState = NULL; +PFNGLENABLEVERTEXATTRIBARRAYPROC glad_glEnableVertexAttribArray = NULL; +PFNGLENABLEIPROC glad_glEnablei = NULL; +PFNGLENDPROC glad_glEnd = NULL; +PFNGLENDCONDITIONALRENDERPROC glad_glEndConditionalRender = NULL; +PFNGLENDLISTPROC glad_glEndList = NULL; +PFNGLENDQUERYPROC glad_glEndQuery = NULL; +PFNGLENDTRANSFORMFEEDBACKPROC glad_glEndTransformFeedback = NULL; +PFNGLEVALCOORD1DPROC glad_glEvalCoord1d = NULL; +PFNGLEVALCOORD1DVPROC glad_glEvalCoord1dv = NULL; +PFNGLEVALCOORD1FPROC glad_glEvalCoord1f = NULL; +PFNGLEVALCOORD1FVPROC glad_glEvalCoord1fv = NULL; +PFNGLEVALCOORD2DPROC glad_glEvalCoord2d = NULL; +PFNGLEVALCOORD2DVPROC glad_glEvalCoord2dv = NULL; +PFNGLEVALCOORD2FPROC glad_glEvalCoord2f = NULL; +PFNGLEVALCOORD2FVPROC glad_glEvalCoord2fv = NULL; +PFNGLEVALMESH1PROC glad_glEvalMesh1 = NULL; +PFNGLEVALMESH2PROC glad_glEvalMesh2 = NULL; +PFNGLEVALPOINT1PROC glad_glEvalPoint1 = NULL; +PFNGLEVALPOINT2PROC glad_glEvalPoint2 = NULL; +PFNGLFEEDBACKBUFFERPROC glad_glFeedbackBuffer = NULL; +PFNGLFENCESYNCPROC glad_glFenceSync = NULL; +PFNGLFINISHPROC glad_glFinish = NULL; +PFNGLFLUSHPROC glad_glFlush = NULL; +PFNGLFLUSHMAPPEDBUFFERRANGEPROC glad_glFlushMappedBufferRange = NULL; +PFNGLFOGCOORDPOINTERPROC glad_glFogCoordPointer = NULL; +PFNGLFOGCOORDDPROC glad_glFogCoordd = NULL; +PFNGLFOGCOORDDVPROC glad_glFogCoorddv = NULL; +PFNGLFOGCOORDFPROC glad_glFogCoordf = NULL; +PFNGLFOGCOORDFVPROC glad_glFogCoordfv = NULL; +PFNGLFOGFPROC glad_glFogf = NULL; +PFNGLFOGFVPROC glad_glFogfv = NULL; +PFNGLFOGIPROC glad_glFogi = NULL; +PFNGLFOGIVPROC glad_glFogiv = 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; +PFNGLFRUSTUMPROC glad_glFrustum = NULL; +PFNGLGENBUFFERSPROC glad_glGenBuffers = NULL; +PFNGLGENFRAMEBUFFERSPROC glad_glGenFramebuffers = NULL; +PFNGLGENLISTSPROC glad_glGenLists = 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; +PFNGLGETCLIPPLANEPROC glad_glGetClipPlane = 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; +PFNGLGETLIGHTFVPROC glad_glGetLightfv = NULL; +PFNGLGETLIGHTIVPROC glad_glGetLightiv = NULL; +PFNGLGETMAPDVPROC glad_glGetMapdv = NULL; +PFNGLGETMAPFVPROC glad_glGetMapfv = NULL; +PFNGLGETMAPIVPROC glad_glGetMapiv = NULL; +PFNGLGETMATERIALFVPROC glad_glGetMaterialfv = NULL; +PFNGLGETMATERIALIVPROC glad_glGetMaterialiv = NULL; +PFNGLGETMULTISAMPLEFVPROC glad_glGetMultisamplefv = NULL; +PFNGLGETPIXELMAPFVPROC glad_glGetPixelMapfv = NULL; +PFNGLGETPIXELMAPUIVPROC glad_glGetPixelMapuiv = NULL; +PFNGLGETPIXELMAPUSVPROC glad_glGetPixelMapusv = NULL; +PFNGLGETPOINTERVPROC glad_glGetPointerv = NULL; +PFNGLGETPOLYGONSTIPPLEPROC glad_glGetPolygonStipple = 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; +PFNGLGETTEXENVFVPROC glad_glGetTexEnvfv = NULL; +PFNGLGETTEXENVIVPROC glad_glGetTexEnviv = NULL; +PFNGLGETTEXGENDVPROC glad_glGetTexGendv = NULL; +PFNGLGETTEXGENFVPROC glad_glGetTexGenfv = NULL; +PFNGLGETTEXGENIVPROC glad_glGetTexGeniv = 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; +PFNGLINDEXMASKPROC glad_glIndexMask = NULL; +PFNGLINDEXPOINTERPROC glad_glIndexPointer = NULL; +PFNGLINDEXDPROC glad_glIndexd = NULL; +PFNGLINDEXDVPROC glad_glIndexdv = NULL; +PFNGLINDEXFPROC glad_glIndexf = NULL; +PFNGLINDEXFVPROC glad_glIndexfv = NULL; +PFNGLINDEXIPROC glad_glIndexi = NULL; +PFNGLINDEXIVPROC glad_glIndexiv = NULL; +PFNGLINDEXSPROC glad_glIndexs = NULL; +PFNGLINDEXSVPROC glad_glIndexsv = NULL; +PFNGLINDEXUBPROC glad_glIndexub = NULL; +PFNGLINDEXUBVPROC glad_glIndexubv = NULL; +PFNGLINITNAMESPROC glad_glInitNames = NULL; +PFNGLINTERLEAVEDARRAYSPROC glad_glInterleavedArrays = NULL; +PFNGLISBUFFERPROC glad_glIsBuffer = NULL; +PFNGLISENABLEDPROC glad_glIsEnabled = NULL; +PFNGLISENABLEDIPROC glad_glIsEnabledi = NULL; +PFNGLISFRAMEBUFFERPROC glad_glIsFramebuffer = NULL; +PFNGLISLISTPROC glad_glIsList = 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; +PFNGLLIGHTMODELFPROC glad_glLightModelf = NULL; +PFNGLLIGHTMODELFVPROC glad_glLightModelfv = NULL; +PFNGLLIGHTMODELIPROC glad_glLightModeli = NULL; +PFNGLLIGHTMODELIVPROC glad_glLightModeliv = NULL; +PFNGLLIGHTFPROC glad_glLightf = NULL; +PFNGLLIGHTFVPROC glad_glLightfv = NULL; +PFNGLLIGHTIPROC glad_glLighti = NULL; +PFNGLLIGHTIVPROC glad_glLightiv = NULL; +PFNGLLINESTIPPLEPROC glad_glLineStipple = NULL; +PFNGLLINEWIDTHPROC glad_glLineWidth = NULL; +PFNGLLINKPROGRAMPROC glad_glLinkProgram = NULL; +PFNGLLISTBASEPROC glad_glListBase = NULL; +PFNGLLOADIDENTITYPROC glad_glLoadIdentity = NULL; +PFNGLLOADMATRIXDPROC glad_glLoadMatrixd = NULL; +PFNGLLOADMATRIXFPROC glad_glLoadMatrixf = NULL; +PFNGLLOADNAMEPROC glad_glLoadName = NULL; +PFNGLLOADTRANSPOSEMATRIXDPROC glad_glLoadTransposeMatrixd = NULL; +PFNGLLOADTRANSPOSEMATRIXFPROC glad_glLoadTransposeMatrixf = NULL; +PFNGLLOGICOPPROC glad_glLogicOp = NULL; +PFNGLMAP1DPROC glad_glMap1d = NULL; +PFNGLMAP1FPROC glad_glMap1f = NULL; +PFNGLMAP2DPROC glad_glMap2d = NULL; +PFNGLMAP2FPROC glad_glMap2f = NULL; +PFNGLMAPBUFFERPROC glad_glMapBuffer = NULL; +PFNGLMAPBUFFERRANGEPROC glad_glMapBufferRange = NULL; +PFNGLMAPGRID1DPROC glad_glMapGrid1d = NULL; +PFNGLMAPGRID1FPROC glad_glMapGrid1f = NULL; +PFNGLMAPGRID2DPROC glad_glMapGrid2d = NULL; +PFNGLMAPGRID2FPROC glad_glMapGrid2f = NULL; +PFNGLMATERIALFPROC glad_glMaterialf = NULL; +PFNGLMATERIALFVPROC glad_glMaterialfv = NULL; +PFNGLMATERIALIPROC glad_glMateriali = NULL; +PFNGLMATERIALIVPROC glad_glMaterialiv = NULL; +PFNGLMATRIXMODEPROC glad_glMatrixMode = NULL; +PFNGLMULTMATRIXDPROC glad_glMultMatrixd = NULL; +PFNGLMULTMATRIXFPROC glad_glMultMatrixf = NULL; +PFNGLMULTTRANSPOSEMATRIXDPROC glad_glMultTransposeMatrixd = NULL; +PFNGLMULTTRANSPOSEMATRIXFPROC glad_glMultTransposeMatrixf = NULL; +PFNGLMULTIDRAWARRAYSPROC glad_glMultiDrawArrays = NULL; +PFNGLMULTIDRAWELEMENTSPROC glad_glMultiDrawElements = NULL; +PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC glad_glMultiDrawElementsBaseVertex = NULL; +PFNGLMULTITEXCOORD1DPROC glad_glMultiTexCoord1d = NULL; +PFNGLMULTITEXCOORD1DVPROC glad_glMultiTexCoord1dv = NULL; +PFNGLMULTITEXCOORD1FPROC glad_glMultiTexCoord1f = NULL; +PFNGLMULTITEXCOORD1FVPROC glad_glMultiTexCoord1fv = NULL; +PFNGLMULTITEXCOORD1IPROC glad_glMultiTexCoord1i = NULL; +PFNGLMULTITEXCOORD1IVPROC glad_glMultiTexCoord1iv = NULL; +PFNGLMULTITEXCOORD1SPROC glad_glMultiTexCoord1s = NULL; +PFNGLMULTITEXCOORD1SVPROC glad_glMultiTexCoord1sv = NULL; +PFNGLMULTITEXCOORD2DPROC glad_glMultiTexCoord2d = NULL; +PFNGLMULTITEXCOORD2DVPROC glad_glMultiTexCoord2dv = NULL; +PFNGLMULTITEXCOORD2FPROC glad_glMultiTexCoord2f = NULL; +PFNGLMULTITEXCOORD2FVPROC glad_glMultiTexCoord2fv = NULL; +PFNGLMULTITEXCOORD2IPROC glad_glMultiTexCoord2i = NULL; +PFNGLMULTITEXCOORD2IVPROC glad_glMultiTexCoord2iv = NULL; +PFNGLMULTITEXCOORD2SPROC glad_glMultiTexCoord2s = NULL; +PFNGLMULTITEXCOORD2SVPROC glad_glMultiTexCoord2sv = NULL; +PFNGLMULTITEXCOORD3DPROC glad_glMultiTexCoord3d = NULL; +PFNGLMULTITEXCOORD3DVPROC glad_glMultiTexCoord3dv = NULL; +PFNGLMULTITEXCOORD3FPROC glad_glMultiTexCoord3f = NULL; +PFNGLMULTITEXCOORD3FVPROC glad_glMultiTexCoord3fv = NULL; +PFNGLMULTITEXCOORD3IPROC glad_glMultiTexCoord3i = NULL; +PFNGLMULTITEXCOORD3IVPROC glad_glMultiTexCoord3iv = NULL; +PFNGLMULTITEXCOORD3SPROC glad_glMultiTexCoord3s = NULL; +PFNGLMULTITEXCOORD3SVPROC glad_glMultiTexCoord3sv = NULL; +PFNGLMULTITEXCOORD4DPROC glad_glMultiTexCoord4d = NULL; +PFNGLMULTITEXCOORD4DVPROC glad_glMultiTexCoord4dv = NULL; +PFNGLMULTITEXCOORD4FPROC glad_glMultiTexCoord4f = NULL; +PFNGLMULTITEXCOORD4FVPROC glad_glMultiTexCoord4fv = NULL; +PFNGLMULTITEXCOORD4IPROC glad_glMultiTexCoord4i = NULL; +PFNGLMULTITEXCOORD4IVPROC glad_glMultiTexCoord4iv = NULL; +PFNGLMULTITEXCOORD4SPROC glad_glMultiTexCoord4s = NULL; +PFNGLMULTITEXCOORD4SVPROC glad_glMultiTexCoord4sv = 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; +PFNGLNEWLISTPROC glad_glNewList = NULL; +PFNGLNORMAL3BPROC glad_glNormal3b = NULL; +PFNGLNORMAL3BVPROC glad_glNormal3bv = NULL; +PFNGLNORMAL3DPROC glad_glNormal3d = NULL; +PFNGLNORMAL3DVPROC glad_glNormal3dv = NULL; +PFNGLNORMAL3FPROC glad_glNormal3f = NULL; +PFNGLNORMAL3FVPROC glad_glNormal3fv = NULL; +PFNGLNORMAL3IPROC glad_glNormal3i = NULL; +PFNGLNORMAL3IVPROC glad_glNormal3iv = NULL; +PFNGLNORMAL3SPROC glad_glNormal3s = NULL; +PFNGLNORMAL3SVPROC glad_glNormal3sv = NULL; +PFNGLNORMALP3UIPROC glad_glNormalP3ui = NULL; +PFNGLNORMALP3UIVPROC glad_glNormalP3uiv = NULL; +PFNGLNORMALPOINTERPROC glad_glNormalPointer = NULL; +PFNGLORTHOPROC glad_glOrtho = NULL; +PFNGLPASSTHROUGHPROC glad_glPassThrough = NULL; +PFNGLPIXELMAPFVPROC glad_glPixelMapfv = NULL; +PFNGLPIXELMAPUIVPROC glad_glPixelMapuiv = NULL; +PFNGLPIXELMAPUSVPROC glad_glPixelMapusv = NULL; +PFNGLPIXELSTOREFPROC glad_glPixelStoref = NULL; +PFNGLPIXELSTOREIPROC glad_glPixelStorei = NULL; +PFNGLPIXELTRANSFERFPROC glad_glPixelTransferf = NULL; +PFNGLPIXELTRANSFERIPROC glad_glPixelTransferi = NULL; +PFNGLPIXELZOOMPROC glad_glPixelZoom = 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; +PFNGLPOLYGONSTIPPLEPROC glad_glPolygonStipple = NULL; +PFNGLPOPATTRIBPROC glad_glPopAttrib = NULL; +PFNGLPOPCLIENTATTRIBPROC glad_glPopClientAttrib = NULL; +PFNGLPOPMATRIXPROC glad_glPopMatrix = NULL; +PFNGLPOPNAMEPROC glad_glPopName = NULL; +PFNGLPRIMITIVERESTARTINDEXPROC glad_glPrimitiveRestartIndex = NULL; +PFNGLPRIORITIZETEXTURESPROC glad_glPrioritizeTextures = NULL; +PFNGLPROVOKINGVERTEXPROC glad_glProvokingVertex = NULL; +PFNGLPUSHATTRIBPROC glad_glPushAttrib = NULL; +PFNGLPUSHCLIENTATTRIBPROC glad_glPushClientAttrib = NULL; +PFNGLPUSHMATRIXPROC glad_glPushMatrix = NULL; +PFNGLPUSHNAMEPROC glad_glPushName = NULL; +PFNGLQUERYCOUNTERPROC glad_glQueryCounter = NULL; +PFNGLRASTERPOS2DPROC glad_glRasterPos2d = NULL; +PFNGLRASTERPOS2DVPROC glad_glRasterPos2dv = NULL; +PFNGLRASTERPOS2FPROC glad_glRasterPos2f = NULL; +PFNGLRASTERPOS2FVPROC glad_glRasterPos2fv = NULL; +PFNGLRASTERPOS2IPROC glad_glRasterPos2i = NULL; +PFNGLRASTERPOS2IVPROC glad_glRasterPos2iv = NULL; +PFNGLRASTERPOS2SPROC glad_glRasterPos2s = NULL; +PFNGLRASTERPOS2SVPROC glad_glRasterPos2sv = NULL; +PFNGLRASTERPOS3DPROC glad_glRasterPos3d = NULL; +PFNGLRASTERPOS3DVPROC glad_glRasterPos3dv = NULL; +PFNGLRASTERPOS3FPROC glad_glRasterPos3f = NULL; +PFNGLRASTERPOS3FVPROC glad_glRasterPos3fv = NULL; +PFNGLRASTERPOS3IPROC glad_glRasterPos3i = NULL; +PFNGLRASTERPOS3IVPROC glad_glRasterPos3iv = NULL; +PFNGLRASTERPOS3SPROC glad_glRasterPos3s = NULL; +PFNGLRASTERPOS3SVPROC glad_glRasterPos3sv = NULL; +PFNGLRASTERPOS4DPROC glad_glRasterPos4d = NULL; +PFNGLRASTERPOS4DVPROC glad_glRasterPos4dv = NULL; +PFNGLRASTERPOS4FPROC glad_glRasterPos4f = NULL; +PFNGLRASTERPOS4FVPROC glad_glRasterPos4fv = NULL; +PFNGLRASTERPOS4IPROC glad_glRasterPos4i = NULL; +PFNGLRASTERPOS4IVPROC glad_glRasterPos4iv = NULL; +PFNGLRASTERPOS4SPROC glad_glRasterPos4s = NULL; +PFNGLRASTERPOS4SVPROC glad_glRasterPos4sv = NULL; +PFNGLREADBUFFERPROC glad_glReadBuffer = NULL; +PFNGLREADPIXELSPROC glad_glReadPixels = NULL; +PFNGLRECTDPROC glad_glRectd = NULL; +PFNGLRECTDVPROC glad_glRectdv = NULL; +PFNGLRECTFPROC glad_glRectf = NULL; +PFNGLRECTFVPROC glad_glRectfv = NULL; +PFNGLRECTIPROC glad_glRecti = NULL; +PFNGLRECTIVPROC glad_glRectiv = NULL; +PFNGLRECTSPROC glad_glRects = NULL; +PFNGLRECTSVPROC glad_glRectsv = NULL; +PFNGLRENDERMODEPROC glad_glRenderMode = NULL; +PFNGLRENDERBUFFERSTORAGEPROC glad_glRenderbufferStorage = NULL; +PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC glad_glRenderbufferStorageMultisample = NULL; +PFNGLROTATEDPROC glad_glRotated = NULL; +PFNGLROTATEFPROC glad_glRotatef = 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; +PFNGLSCALEDPROC glad_glScaled = NULL; +PFNGLSCALEFPROC glad_glScalef = NULL; +PFNGLSCISSORPROC glad_glScissor = NULL; +PFNGLSECONDARYCOLOR3BPROC glad_glSecondaryColor3b = NULL; +PFNGLSECONDARYCOLOR3BVPROC glad_glSecondaryColor3bv = NULL; +PFNGLSECONDARYCOLOR3DPROC glad_glSecondaryColor3d = NULL; +PFNGLSECONDARYCOLOR3DVPROC glad_glSecondaryColor3dv = NULL; +PFNGLSECONDARYCOLOR3FPROC glad_glSecondaryColor3f = NULL; +PFNGLSECONDARYCOLOR3FVPROC glad_glSecondaryColor3fv = NULL; +PFNGLSECONDARYCOLOR3IPROC glad_glSecondaryColor3i = NULL; +PFNGLSECONDARYCOLOR3IVPROC glad_glSecondaryColor3iv = NULL; +PFNGLSECONDARYCOLOR3SPROC glad_glSecondaryColor3s = NULL; +PFNGLSECONDARYCOLOR3SVPROC glad_glSecondaryColor3sv = NULL; +PFNGLSECONDARYCOLOR3UBPROC glad_glSecondaryColor3ub = NULL; +PFNGLSECONDARYCOLOR3UBVPROC glad_glSecondaryColor3ubv = NULL; +PFNGLSECONDARYCOLOR3UIPROC glad_glSecondaryColor3ui = NULL; +PFNGLSECONDARYCOLOR3UIVPROC glad_glSecondaryColor3uiv = NULL; +PFNGLSECONDARYCOLOR3USPROC glad_glSecondaryColor3us = NULL; +PFNGLSECONDARYCOLOR3USVPROC glad_glSecondaryColor3usv = NULL; +PFNGLSECONDARYCOLORP3UIPROC glad_glSecondaryColorP3ui = NULL; +PFNGLSECONDARYCOLORP3UIVPROC glad_glSecondaryColorP3uiv = NULL; +PFNGLSECONDARYCOLORPOINTERPROC glad_glSecondaryColorPointer = NULL; +PFNGLSELECTBUFFERPROC glad_glSelectBuffer = NULL; +PFNGLSHADEMODELPROC glad_glShadeModel = 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; +PFNGLTEXCOORD1DPROC glad_glTexCoord1d = NULL; +PFNGLTEXCOORD1DVPROC glad_glTexCoord1dv = NULL; +PFNGLTEXCOORD1FPROC glad_glTexCoord1f = NULL; +PFNGLTEXCOORD1FVPROC glad_glTexCoord1fv = NULL; +PFNGLTEXCOORD1IPROC glad_glTexCoord1i = NULL; +PFNGLTEXCOORD1IVPROC glad_glTexCoord1iv = NULL; +PFNGLTEXCOORD1SPROC glad_glTexCoord1s = NULL; +PFNGLTEXCOORD1SVPROC glad_glTexCoord1sv = NULL; +PFNGLTEXCOORD2DPROC glad_glTexCoord2d = NULL; +PFNGLTEXCOORD2DVPROC glad_glTexCoord2dv = NULL; +PFNGLTEXCOORD2FPROC glad_glTexCoord2f = NULL; +PFNGLTEXCOORD2FVPROC glad_glTexCoord2fv = NULL; +PFNGLTEXCOORD2IPROC glad_glTexCoord2i = NULL; +PFNGLTEXCOORD2IVPROC glad_glTexCoord2iv = NULL; +PFNGLTEXCOORD2SPROC glad_glTexCoord2s = NULL; +PFNGLTEXCOORD2SVPROC glad_glTexCoord2sv = NULL; +PFNGLTEXCOORD3DPROC glad_glTexCoord3d = NULL; +PFNGLTEXCOORD3DVPROC glad_glTexCoord3dv = NULL; +PFNGLTEXCOORD3FPROC glad_glTexCoord3f = NULL; +PFNGLTEXCOORD3FVPROC glad_glTexCoord3fv = NULL; +PFNGLTEXCOORD3IPROC glad_glTexCoord3i = NULL; +PFNGLTEXCOORD3IVPROC glad_glTexCoord3iv = NULL; +PFNGLTEXCOORD3SPROC glad_glTexCoord3s = NULL; +PFNGLTEXCOORD3SVPROC glad_glTexCoord3sv = NULL; +PFNGLTEXCOORD4DPROC glad_glTexCoord4d = NULL; +PFNGLTEXCOORD4DVPROC glad_glTexCoord4dv = NULL; +PFNGLTEXCOORD4FPROC glad_glTexCoord4f = NULL; +PFNGLTEXCOORD4FVPROC glad_glTexCoord4fv = NULL; +PFNGLTEXCOORD4IPROC glad_glTexCoord4i = NULL; +PFNGLTEXCOORD4IVPROC glad_glTexCoord4iv = NULL; +PFNGLTEXCOORD4SPROC glad_glTexCoord4s = NULL; +PFNGLTEXCOORD4SVPROC glad_glTexCoord4sv = 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; +PFNGLTEXCOORDPOINTERPROC glad_glTexCoordPointer = NULL; +PFNGLTEXENVFPROC glad_glTexEnvf = NULL; +PFNGLTEXENVFVPROC glad_glTexEnvfv = NULL; +PFNGLTEXENVIPROC glad_glTexEnvi = NULL; +PFNGLTEXENVIVPROC glad_glTexEnviv = NULL; +PFNGLTEXGENDPROC glad_glTexGend = NULL; +PFNGLTEXGENDVPROC glad_glTexGendv = NULL; +PFNGLTEXGENFPROC glad_glTexGenf = NULL; +PFNGLTEXGENFVPROC glad_glTexGenfv = NULL; +PFNGLTEXGENIPROC glad_glTexGeni = NULL; +PFNGLTEXGENIVPROC glad_glTexGeniv = 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; +PFNGLTRANSLATEDPROC glad_glTranslated = NULL; +PFNGLTRANSLATEFPROC glad_glTranslatef = 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; +PFNGLVERTEX2DPROC glad_glVertex2d = NULL; +PFNGLVERTEX2DVPROC glad_glVertex2dv = NULL; +PFNGLVERTEX2FPROC glad_glVertex2f = NULL; +PFNGLVERTEX2FVPROC glad_glVertex2fv = NULL; +PFNGLVERTEX2IPROC glad_glVertex2i = NULL; +PFNGLVERTEX2IVPROC glad_glVertex2iv = NULL; +PFNGLVERTEX2SPROC glad_glVertex2s = NULL; +PFNGLVERTEX2SVPROC glad_glVertex2sv = NULL; +PFNGLVERTEX3DPROC glad_glVertex3d = NULL; +PFNGLVERTEX3DVPROC glad_glVertex3dv = NULL; +PFNGLVERTEX3FPROC glad_glVertex3f = NULL; +PFNGLVERTEX3FVPROC glad_glVertex3fv = NULL; +PFNGLVERTEX3IPROC glad_glVertex3i = NULL; +PFNGLVERTEX3IVPROC glad_glVertex3iv = NULL; +PFNGLVERTEX3SPROC glad_glVertex3s = NULL; +PFNGLVERTEX3SVPROC glad_glVertex3sv = NULL; +PFNGLVERTEX4DPROC glad_glVertex4d = NULL; +PFNGLVERTEX4DVPROC glad_glVertex4dv = NULL; +PFNGLVERTEX4FPROC glad_glVertex4f = NULL; +PFNGLVERTEX4FVPROC glad_glVertex4fv = NULL; +PFNGLVERTEX4IPROC glad_glVertex4i = NULL; +PFNGLVERTEX4IVPROC glad_glVertex4iv = NULL; +PFNGLVERTEX4SPROC glad_glVertex4s = NULL; +PFNGLVERTEX4SVPROC glad_glVertex4sv = 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; +PFNGLVERTEXPOINTERPROC glad_glVertexPointer = NULL; +PFNGLVIEWPORTPROC glad_glViewport = NULL; +PFNGLWAITSYNCPROC glad_glWaitSync = NULL; +PFNGLWINDOWPOS2DPROC glad_glWindowPos2d = NULL; +PFNGLWINDOWPOS2DVPROC glad_glWindowPos2dv = NULL; +PFNGLWINDOWPOS2FPROC glad_glWindowPos2f = NULL; +PFNGLWINDOWPOS2FVPROC glad_glWindowPos2fv = NULL; +PFNGLWINDOWPOS2IPROC glad_glWindowPos2i = NULL; +PFNGLWINDOWPOS2IVPROC glad_glWindowPos2iv = NULL; +PFNGLWINDOWPOS2SPROC glad_glWindowPos2s = NULL; +PFNGLWINDOWPOS2SVPROC glad_glWindowPos2sv = NULL; +PFNGLWINDOWPOS3DPROC glad_glWindowPos3d = NULL; +PFNGLWINDOWPOS3DVPROC glad_glWindowPos3dv = NULL; +PFNGLWINDOWPOS3FPROC glad_glWindowPos3f = NULL; +PFNGLWINDOWPOS3FVPROC glad_glWindowPos3fv = NULL; +PFNGLWINDOWPOS3IPROC glad_glWindowPos3i = NULL; +PFNGLWINDOWPOS3IVPROC glad_glWindowPos3iv = NULL; +PFNGLWINDOWPOS3SPROC glad_glWindowPos3s = NULL; +PFNGLWINDOWPOS3SVPROC glad_glWindowPos3sv = 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" ); + glad_glNewList = (PFNGLNEWLISTPROC)load( "glNewList" ); + glad_glEndList = (PFNGLENDLISTPROC)load( "glEndList" ); + glad_glCallList = (PFNGLCALLLISTPROC)load( "glCallList" ); + glad_glCallLists = (PFNGLCALLLISTSPROC)load( "glCallLists" ); + glad_glDeleteLists = (PFNGLDELETELISTSPROC)load( "glDeleteLists" ); + glad_glGenLists = (PFNGLGENLISTSPROC)load( "glGenLists" ); + glad_glListBase = (PFNGLLISTBASEPROC)load( "glListBase" ); + glad_glBegin = (PFNGLBEGINPROC)load( "glBegin" ); + glad_glBitmap = (PFNGLBITMAPPROC)load( "glBitmap" ); + glad_glColor3b = (PFNGLCOLOR3BPROC)load( "glColor3b" ); + glad_glColor3bv = (PFNGLCOLOR3BVPROC)load( "glColor3bv" ); + glad_glColor3d = (PFNGLCOLOR3DPROC)load( "glColor3d" ); + glad_glColor3dv = (PFNGLCOLOR3DVPROC)load( "glColor3dv" ); + glad_glColor3f = (PFNGLCOLOR3FPROC)load( "glColor3f" ); + glad_glColor3fv = (PFNGLCOLOR3FVPROC)load( "glColor3fv" ); + glad_glColor3i = (PFNGLCOLOR3IPROC)load( "glColor3i" ); + glad_glColor3iv = (PFNGLCOLOR3IVPROC)load( "glColor3iv" ); + glad_glColor3s = (PFNGLCOLOR3SPROC)load( "glColor3s" ); + glad_glColor3sv = (PFNGLCOLOR3SVPROC)load( "glColor3sv" ); + glad_glColor3ub = (PFNGLCOLOR3UBPROC)load( "glColor3ub" ); + glad_glColor3ubv = (PFNGLCOLOR3UBVPROC)load( "glColor3ubv" ); + glad_glColor3ui = (PFNGLCOLOR3UIPROC)load( "glColor3ui" ); + glad_glColor3uiv = (PFNGLCOLOR3UIVPROC)load( "glColor3uiv" ); + glad_glColor3us = (PFNGLCOLOR3USPROC)load( "glColor3us" ); + glad_glColor3usv = (PFNGLCOLOR3USVPROC)load( "glColor3usv" ); + glad_glColor4b = (PFNGLCOLOR4BPROC)load( "glColor4b" ); + glad_glColor4bv = (PFNGLCOLOR4BVPROC)load( "glColor4bv" ); + glad_glColor4d = (PFNGLCOLOR4DPROC)load( "glColor4d" ); + glad_glColor4dv = (PFNGLCOLOR4DVPROC)load( "glColor4dv" ); + glad_glColor4f = (PFNGLCOLOR4FPROC)load( "glColor4f" ); + glad_glColor4fv = (PFNGLCOLOR4FVPROC)load( "glColor4fv" ); + glad_glColor4i = (PFNGLCOLOR4IPROC)load( "glColor4i" ); + glad_glColor4iv = (PFNGLCOLOR4IVPROC)load( "glColor4iv" ); + glad_glColor4s = (PFNGLCOLOR4SPROC)load( "glColor4s" ); + glad_glColor4sv = (PFNGLCOLOR4SVPROC)load( "glColor4sv" ); + glad_glColor4ub = (PFNGLCOLOR4UBPROC)load( "glColor4ub" ); + glad_glColor4ubv = (PFNGLCOLOR4UBVPROC)load( "glColor4ubv" ); + glad_glColor4ui = (PFNGLCOLOR4UIPROC)load( "glColor4ui" ); + glad_glColor4uiv = (PFNGLCOLOR4UIVPROC)load( "glColor4uiv" ); + glad_glColor4us = (PFNGLCOLOR4USPROC)load( "glColor4us" ); + glad_glColor4usv = (PFNGLCOLOR4USVPROC)load( "glColor4usv" ); + glad_glEdgeFlag = (PFNGLEDGEFLAGPROC)load( "glEdgeFlag" ); + glad_glEdgeFlagv = (PFNGLEDGEFLAGVPROC)load( "glEdgeFlagv" ); + glad_glEnd = (PFNGLENDPROC)load( "glEnd" ); + glad_glIndexd = (PFNGLINDEXDPROC)load( "glIndexd" ); + glad_glIndexdv = (PFNGLINDEXDVPROC)load( "glIndexdv" ); + glad_glIndexf = (PFNGLINDEXFPROC)load( "glIndexf" ); + glad_glIndexfv = (PFNGLINDEXFVPROC)load( "glIndexfv" ); + glad_glIndexi = (PFNGLINDEXIPROC)load( "glIndexi" ); + glad_glIndexiv = (PFNGLINDEXIVPROC)load( "glIndexiv" ); + glad_glIndexs = (PFNGLINDEXSPROC)load( "glIndexs" ); + glad_glIndexsv = (PFNGLINDEXSVPROC)load( "glIndexsv" ); + glad_glNormal3b = (PFNGLNORMAL3BPROC)load( "glNormal3b" ); + glad_glNormal3bv = (PFNGLNORMAL3BVPROC)load( "glNormal3bv" ); + glad_glNormal3d = (PFNGLNORMAL3DPROC)load( "glNormal3d" ); + glad_glNormal3dv = (PFNGLNORMAL3DVPROC)load( "glNormal3dv" ); + glad_glNormal3f = (PFNGLNORMAL3FPROC)load( "glNormal3f" ); + glad_glNormal3fv = (PFNGLNORMAL3FVPROC)load( "glNormal3fv" ); + glad_glNormal3i = (PFNGLNORMAL3IPROC)load( "glNormal3i" ); + glad_glNormal3iv = (PFNGLNORMAL3IVPROC)load( "glNormal3iv" ); + glad_glNormal3s = (PFNGLNORMAL3SPROC)load( "glNormal3s" ); + glad_glNormal3sv = (PFNGLNORMAL3SVPROC)load( "glNormal3sv" ); + glad_glRasterPos2d = (PFNGLRASTERPOS2DPROC)load( "glRasterPos2d" ); + glad_glRasterPos2dv = (PFNGLRASTERPOS2DVPROC)load( "glRasterPos2dv" ); + glad_glRasterPos2f = (PFNGLRASTERPOS2FPROC)load( "glRasterPos2f" ); + glad_glRasterPos2fv = (PFNGLRASTERPOS2FVPROC)load( "glRasterPos2fv" ); + glad_glRasterPos2i = (PFNGLRASTERPOS2IPROC)load( "glRasterPos2i" ); + glad_glRasterPos2iv = (PFNGLRASTERPOS2IVPROC)load( "glRasterPos2iv" ); + glad_glRasterPos2s = (PFNGLRASTERPOS2SPROC)load( "glRasterPos2s" ); + glad_glRasterPos2sv = (PFNGLRASTERPOS2SVPROC)load( "glRasterPos2sv" ); + glad_glRasterPos3d = (PFNGLRASTERPOS3DPROC)load( "glRasterPos3d" ); + glad_glRasterPos3dv = (PFNGLRASTERPOS3DVPROC)load( "glRasterPos3dv" ); + glad_glRasterPos3f = (PFNGLRASTERPOS3FPROC)load( "glRasterPos3f" ); + glad_glRasterPos3fv = (PFNGLRASTERPOS3FVPROC)load( "glRasterPos3fv" ); + glad_glRasterPos3i = (PFNGLRASTERPOS3IPROC)load( "glRasterPos3i" ); + glad_glRasterPos3iv = (PFNGLRASTERPOS3IVPROC)load( "glRasterPos3iv" ); + glad_glRasterPos3s = (PFNGLRASTERPOS3SPROC)load( "glRasterPos3s" ); + glad_glRasterPos3sv = (PFNGLRASTERPOS3SVPROC)load( "glRasterPos3sv" ); + glad_glRasterPos4d = (PFNGLRASTERPOS4DPROC)load( "glRasterPos4d" ); + glad_glRasterPos4dv = (PFNGLRASTERPOS4DVPROC)load( "glRasterPos4dv" ); + glad_glRasterPos4f = (PFNGLRASTERPOS4FPROC)load( "glRasterPos4f" ); + glad_glRasterPos4fv = (PFNGLRASTERPOS4FVPROC)load( "glRasterPos4fv" ); + glad_glRasterPos4i = (PFNGLRASTERPOS4IPROC)load( "glRasterPos4i" ); + glad_glRasterPos4iv = (PFNGLRASTERPOS4IVPROC)load( "glRasterPos4iv" ); + glad_glRasterPos4s = (PFNGLRASTERPOS4SPROC)load( "glRasterPos4s" ); + glad_glRasterPos4sv = (PFNGLRASTERPOS4SVPROC)load( "glRasterPos4sv" ); + glad_glRectd = (PFNGLRECTDPROC)load( "glRectd" ); + glad_glRectdv = (PFNGLRECTDVPROC)load( "glRectdv" ); + glad_glRectf = (PFNGLRECTFPROC)load( "glRectf" ); + glad_glRectfv = (PFNGLRECTFVPROC)load( "glRectfv" ); + glad_glRecti = (PFNGLRECTIPROC)load( "glRecti" ); + glad_glRectiv = (PFNGLRECTIVPROC)load( "glRectiv" ); + glad_glRects = (PFNGLRECTSPROC)load( "glRects" ); + glad_glRectsv = (PFNGLRECTSVPROC)load( "glRectsv" ); + glad_glTexCoord1d = (PFNGLTEXCOORD1DPROC)load( "glTexCoord1d" ); + glad_glTexCoord1dv = (PFNGLTEXCOORD1DVPROC)load( "glTexCoord1dv" ); + glad_glTexCoord1f = (PFNGLTEXCOORD1FPROC)load( "glTexCoord1f" ); + glad_glTexCoord1fv = (PFNGLTEXCOORD1FVPROC)load( "glTexCoord1fv" ); + glad_glTexCoord1i = (PFNGLTEXCOORD1IPROC)load( "glTexCoord1i" ); + glad_glTexCoord1iv = (PFNGLTEXCOORD1IVPROC)load( "glTexCoord1iv" ); + glad_glTexCoord1s = (PFNGLTEXCOORD1SPROC)load( "glTexCoord1s" ); + glad_glTexCoord1sv = (PFNGLTEXCOORD1SVPROC)load( "glTexCoord1sv" ); + glad_glTexCoord2d = (PFNGLTEXCOORD2DPROC)load( "glTexCoord2d" ); + glad_glTexCoord2dv = (PFNGLTEXCOORD2DVPROC)load( "glTexCoord2dv" ); + glad_glTexCoord2f = (PFNGLTEXCOORD2FPROC)load( "glTexCoord2f" ); + glad_glTexCoord2fv = (PFNGLTEXCOORD2FVPROC)load( "glTexCoord2fv" ); + glad_glTexCoord2i = (PFNGLTEXCOORD2IPROC)load( "glTexCoord2i" ); + glad_glTexCoord2iv = (PFNGLTEXCOORD2IVPROC)load( "glTexCoord2iv" ); + glad_glTexCoord2s = (PFNGLTEXCOORD2SPROC)load( "glTexCoord2s" ); + glad_glTexCoord2sv = (PFNGLTEXCOORD2SVPROC)load( "glTexCoord2sv" ); + glad_glTexCoord3d = (PFNGLTEXCOORD3DPROC)load( "glTexCoord3d" ); + glad_glTexCoord3dv = (PFNGLTEXCOORD3DVPROC)load( "glTexCoord3dv" ); + glad_glTexCoord3f = (PFNGLTEXCOORD3FPROC)load( "glTexCoord3f" ); + glad_glTexCoord3fv = (PFNGLTEXCOORD3FVPROC)load( "glTexCoord3fv" ); + glad_glTexCoord3i = (PFNGLTEXCOORD3IPROC)load( "glTexCoord3i" ); + glad_glTexCoord3iv = (PFNGLTEXCOORD3IVPROC)load( "glTexCoord3iv" ); + glad_glTexCoord3s = (PFNGLTEXCOORD3SPROC)load( "glTexCoord3s" ); + glad_glTexCoord3sv = (PFNGLTEXCOORD3SVPROC)load( "glTexCoord3sv" ); + glad_glTexCoord4d = (PFNGLTEXCOORD4DPROC)load( "glTexCoord4d" ); + glad_glTexCoord4dv = (PFNGLTEXCOORD4DVPROC)load( "glTexCoord4dv" ); + glad_glTexCoord4f = (PFNGLTEXCOORD4FPROC)load( "glTexCoord4f" ); + glad_glTexCoord4fv = (PFNGLTEXCOORD4FVPROC)load( "glTexCoord4fv" ); + glad_glTexCoord4i = (PFNGLTEXCOORD4IPROC)load( "glTexCoord4i" ); + glad_glTexCoord4iv = (PFNGLTEXCOORD4IVPROC)load( "glTexCoord4iv" ); + glad_glTexCoord4s = (PFNGLTEXCOORD4SPROC)load( "glTexCoord4s" ); + glad_glTexCoord4sv = (PFNGLTEXCOORD4SVPROC)load( "glTexCoord4sv" ); + glad_glVertex2d = (PFNGLVERTEX2DPROC)load( "glVertex2d" ); + glad_glVertex2dv = (PFNGLVERTEX2DVPROC)load( "glVertex2dv" ); + glad_glVertex2f = (PFNGLVERTEX2FPROC)load( "glVertex2f" ); + glad_glVertex2fv = (PFNGLVERTEX2FVPROC)load( "glVertex2fv" ); + glad_glVertex2i = (PFNGLVERTEX2IPROC)load( "glVertex2i" ); + glad_glVertex2iv = (PFNGLVERTEX2IVPROC)load( "glVertex2iv" ); + glad_glVertex2s = (PFNGLVERTEX2SPROC)load( "glVertex2s" ); + glad_glVertex2sv = (PFNGLVERTEX2SVPROC)load( "glVertex2sv" ); + glad_glVertex3d = (PFNGLVERTEX3DPROC)load( "glVertex3d" ); + glad_glVertex3dv = (PFNGLVERTEX3DVPROC)load( "glVertex3dv" ); + glad_glVertex3f = (PFNGLVERTEX3FPROC)load( "glVertex3f" ); + glad_glVertex3fv = (PFNGLVERTEX3FVPROC)load( "glVertex3fv" ); + glad_glVertex3i = (PFNGLVERTEX3IPROC)load( "glVertex3i" ); + glad_glVertex3iv = (PFNGLVERTEX3IVPROC)load( "glVertex3iv" ); + glad_glVertex3s = (PFNGLVERTEX3SPROC)load( "glVertex3s" ); + glad_glVertex3sv = (PFNGLVERTEX3SVPROC)load( "glVertex3sv" ); + glad_glVertex4d = (PFNGLVERTEX4DPROC)load( "glVertex4d" ); + glad_glVertex4dv = (PFNGLVERTEX4DVPROC)load( "glVertex4dv" ); + glad_glVertex4f = (PFNGLVERTEX4FPROC)load( "glVertex4f" ); + glad_glVertex4fv = (PFNGLVERTEX4FVPROC)load( "glVertex4fv" ); + glad_glVertex4i = (PFNGLVERTEX4IPROC)load( "glVertex4i" ); + glad_glVertex4iv = (PFNGLVERTEX4IVPROC)load( "glVertex4iv" ); + glad_glVertex4s = (PFNGLVERTEX4SPROC)load( "glVertex4s" ); + glad_glVertex4sv = (PFNGLVERTEX4SVPROC)load( "glVertex4sv" ); + glad_glClipPlane = (PFNGLCLIPPLANEPROC)load( "glClipPlane" ); + glad_glColorMaterial = (PFNGLCOLORMATERIALPROC)load( "glColorMaterial" ); + glad_glFogf = (PFNGLFOGFPROC)load( "glFogf" ); + glad_glFogfv = (PFNGLFOGFVPROC)load( "glFogfv" ); + glad_glFogi = (PFNGLFOGIPROC)load( "glFogi" ); + glad_glFogiv = (PFNGLFOGIVPROC)load( "glFogiv" ); + glad_glLightf = (PFNGLLIGHTFPROC)load( "glLightf" ); + glad_glLightfv = (PFNGLLIGHTFVPROC)load( "glLightfv" ); + glad_glLighti = (PFNGLLIGHTIPROC)load( "glLighti" ); + glad_glLightiv = (PFNGLLIGHTIVPROC)load( "glLightiv" ); + glad_glLightModelf = (PFNGLLIGHTMODELFPROC)load( "glLightModelf" ); + glad_glLightModelfv = (PFNGLLIGHTMODELFVPROC)load( "glLightModelfv" ); + glad_glLightModeli = (PFNGLLIGHTMODELIPROC)load( "glLightModeli" ); + glad_glLightModeliv = (PFNGLLIGHTMODELIVPROC)load( "glLightModeliv" ); + glad_glLineStipple = (PFNGLLINESTIPPLEPROC)load( "glLineStipple" ); + glad_glMaterialf = (PFNGLMATERIALFPROC)load( "glMaterialf" ); + glad_glMaterialfv = (PFNGLMATERIALFVPROC)load( "glMaterialfv" ); + glad_glMateriali = (PFNGLMATERIALIPROC)load( "glMateriali" ); + glad_glMaterialiv = (PFNGLMATERIALIVPROC)load( "glMaterialiv" ); + glad_glPolygonStipple = (PFNGLPOLYGONSTIPPLEPROC)load( "glPolygonStipple" ); + glad_glShadeModel = (PFNGLSHADEMODELPROC)load( "glShadeModel" ); + glad_glTexEnvf = (PFNGLTEXENVFPROC)load( "glTexEnvf" ); + glad_glTexEnvfv = (PFNGLTEXENVFVPROC)load( "glTexEnvfv" ); + glad_glTexEnvi = (PFNGLTEXENVIPROC)load( "glTexEnvi" ); + glad_glTexEnviv = (PFNGLTEXENVIVPROC)load( "glTexEnviv" ); + glad_glTexGend = (PFNGLTEXGENDPROC)load( "glTexGend" ); + glad_glTexGendv = (PFNGLTEXGENDVPROC)load( "glTexGendv" ); + glad_glTexGenf = (PFNGLTEXGENFPROC)load( "glTexGenf" ); + glad_glTexGenfv = (PFNGLTEXGENFVPROC)load( "glTexGenfv" ); + glad_glTexGeni = (PFNGLTEXGENIPROC)load( "glTexGeni" ); + glad_glTexGeniv = (PFNGLTEXGENIVPROC)load( "glTexGeniv" ); + glad_glFeedbackBuffer = (PFNGLFEEDBACKBUFFERPROC)load( "glFeedbackBuffer" ); + glad_glSelectBuffer = (PFNGLSELECTBUFFERPROC)load( "glSelectBuffer" ); + glad_glRenderMode = (PFNGLRENDERMODEPROC)load( "glRenderMode" ); + glad_glInitNames = (PFNGLINITNAMESPROC)load( "glInitNames" ); + glad_glLoadName = (PFNGLLOADNAMEPROC)load( "glLoadName" ); + glad_glPassThrough = (PFNGLPASSTHROUGHPROC)load( "glPassThrough" ); + glad_glPopName = (PFNGLPOPNAMEPROC)load( "glPopName" ); + glad_glPushName = (PFNGLPUSHNAMEPROC)load( "glPushName" ); + glad_glClearAccum = (PFNGLCLEARACCUMPROC)load( "glClearAccum" ); + glad_glClearIndex = (PFNGLCLEARINDEXPROC)load( "glClearIndex" ); + glad_glIndexMask = (PFNGLINDEXMASKPROC)load( "glIndexMask" ); + glad_glAccum = (PFNGLACCUMPROC)load( "glAccum" ); + glad_glPopAttrib = (PFNGLPOPATTRIBPROC)load( "glPopAttrib" ); + glad_glPushAttrib = (PFNGLPUSHATTRIBPROC)load( "glPushAttrib" ); + glad_glMap1d = (PFNGLMAP1DPROC)load( "glMap1d" ); + glad_glMap1f = (PFNGLMAP1FPROC)load( "glMap1f" ); + glad_glMap2d = (PFNGLMAP2DPROC)load( "glMap2d" ); + glad_glMap2f = (PFNGLMAP2FPROC)load( "glMap2f" ); + glad_glMapGrid1d = (PFNGLMAPGRID1DPROC)load( "glMapGrid1d" ); + glad_glMapGrid1f = (PFNGLMAPGRID1FPROC)load( "glMapGrid1f" ); + glad_glMapGrid2d = (PFNGLMAPGRID2DPROC)load( "glMapGrid2d" ); + glad_glMapGrid2f = (PFNGLMAPGRID2FPROC)load( "glMapGrid2f" ); + glad_glEvalCoord1d = (PFNGLEVALCOORD1DPROC)load( "glEvalCoord1d" ); + glad_glEvalCoord1dv = (PFNGLEVALCOORD1DVPROC)load( "glEvalCoord1dv" ); + glad_glEvalCoord1f = (PFNGLEVALCOORD1FPROC)load( "glEvalCoord1f" ); + glad_glEvalCoord1fv = (PFNGLEVALCOORD1FVPROC)load( "glEvalCoord1fv" ); + glad_glEvalCoord2d = (PFNGLEVALCOORD2DPROC)load( "glEvalCoord2d" ); + glad_glEvalCoord2dv = (PFNGLEVALCOORD2DVPROC)load( "glEvalCoord2dv" ); + glad_glEvalCoord2f = (PFNGLEVALCOORD2FPROC)load( "glEvalCoord2f" ); + glad_glEvalCoord2fv = (PFNGLEVALCOORD2FVPROC)load( "glEvalCoord2fv" ); + glad_glEvalMesh1 = (PFNGLEVALMESH1PROC)load( "glEvalMesh1" ); + glad_glEvalPoint1 = (PFNGLEVALPOINT1PROC)load( "glEvalPoint1" ); + glad_glEvalMesh2 = (PFNGLEVALMESH2PROC)load( "glEvalMesh2" ); + glad_glEvalPoint2 = (PFNGLEVALPOINT2PROC)load( "glEvalPoint2" ); + glad_glAlphaFunc = (PFNGLALPHAFUNCPROC)load( "glAlphaFunc" ); + glad_glPixelZoom = (PFNGLPIXELZOOMPROC)load( "glPixelZoom" ); + glad_glPixelTransferf = (PFNGLPIXELTRANSFERFPROC)load( "glPixelTransferf" ); + glad_glPixelTransferi = (PFNGLPIXELTRANSFERIPROC)load( "glPixelTransferi" ); + glad_glPixelMapfv = (PFNGLPIXELMAPFVPROC)load( "glPixelMapfv" ); + glad_glPixelMapuiv = (PFNGLPIXELMAPUIVPROC)load( "glPixelMapuiv" ); + glad_glPixelMapusv = (PFNGLPIXELMAPUSVPROC)load( "glPixelMapusv" ); + glad_glCopyPixels = (PFNGLCOPYPIXELSPROC)load( "glCopyPixels" ); + glad_glDrawPixels = (PFNGLDRAWPIXELSPROC)load( "glDrawPixels" ); + glad_glGetClipPlane = (PFNGLGETCLIPPLANEPROC)load( "glGetClipPlane" ); + glad_glGetLightfv = (PFNGLGETLIGHTFVPROC)load( "glGetLightfv" ); + glad_glGetLightiv = (PFNGLGETLIGHTIVPROC)load( "glGetLightiv" ); + glad_glGetMapdv = (PFNGLGETMAPDVPROC)load( "glGetMapdv" ); + glad_glGetMapfv = (PFNGLGETMAPFVPROC)load( "glGetMapfv" ); + glad_glGetMapiv = (PFNGLGETMAPIVPROC)load( "glGetMapiv" ); + glad_glGetMaterialfv = (PFNGLGETMATERIALFVPROC)load( "glGetMaterialfv" ); + glad_glGetMaterialiv = (PFNGLGETMATERIALIVPROC)load( "glGetMaterialiv" ); + glad_glGetPixelMapfv = (PFNGLGETPIXELMAPFVPROC)load( "glGetPixelMapfv" ); + glad_glGetPixelMapuiv = (PFNGLGETPIXELMAPUIVPROC)load( "glGetPixelMapuiv" ); + glad_glGetPixelMapusv = (PFNGLGETPIXELMAPUSVPROC)load( "glGetPixelMapusv" ); + glad_glGetPolygonStipple = (PFNGLGETPOLYGONSTIPPLEPROC)load( "glGetPolygonStipple" ); + glad_glGetTexEnvfv = (PFNGLGETTEXENVFVPROC)load( "glGetTexEnvfv" ); + glad_glGetTexEnviv = (PFNGLGETTEXENVIVPROC)load( "glGetTexEnviv" ); + glad_glGetTexGendv = (PFNGLGETTEXGENDVPROC)load( "glGetTexGendv" ); + glad_glGetTexGenfv = (PFNGLGETTEXGENFVPROC)load( "glGetTexGenfv" ); + glad_glGetTexGeniv = (PFNGLGETTEXGENIVPROC)load( "glGetTexGeniv" ); + glad_glIsList = (PFNGLISLISTPROC)load( "glIsList" ); + glad_glFrustum = (PFNGLFRUSTUMPROC)load( "glFrustum" ); + glad_glLoadIdentity = (PFNGLLOADIDENTITYPROC)load( "glLoadIdentity" ); + glad_glLoadMatrixf = (PFNGLLOADMATRIXFPROC)load( "glLoadMatrixf" ); + glad_glLoadMatrixd = (PFNGLLOADMATRIXDPROC)load( "glLoadMatrixd" ); + glad_glMatrixMode = (PFNGLMATRIXMODEPROC)load( "glMatrixMode" ); + glad_glMultMatrixf = (PFNGLMULTMATRIXFPROC)load( "glMultMatrixf" ); + glad_glMultMatrixd = (PFNGLMULTMATRIXDPROC)load( "glMultMatrixd" ); + glad_glOrtho = (PFNGLORTHOPROC)load( "glOrtho" ); + glad_glPopMatrix = (PFNGLPOPMATRIXPROC)load( "glPopMatrix" ); + glad_glPushMatrix = (PFNGLPUSHMATRIXPROC)load( "glPushMatrix" ); + glad_glRotated = (PFNGLROTATEDPROC)load( "glRotated" ); + glad_glRotatef = (PFNGLROTATEFPROC)load( "glRotatef" ); + glad_glScaled = (PFNGLSCALEDPROC)load( "glScaled" ); + glad_glScalef = (PFNGLSCALEFPROC)load( "glScalef" ); + glad_glTranslated = (PFNGLTRANSLATEDPROC)load( "glTranslated" ); + glad_glTranslatef = (PFNGLTRANSLATEFPROC)load( "glTranslatef" ); +} +static void load_GL_VERSION_1_1( GLADloadproc load ) { + if ( !GLAD_GL_VERSION_1_1 ) return; + glad_glDrawArrays = (PFNGLDRAWARRAYSPROC)load( "glDrawArrays" ); + glad_glDrawElements = (PFNGLDRAWELEMENTSPROC)load( "glDrawElements" ); + glad_glGetPointerv = (PFNGLGETPOINTERVPROC)load( "glGetPointerv" ); + glad_glPolygonOffset = (PFNGLPOLYGONOFFSETPROC)load( "glPolygonOffset" ); + glad_glCopyTexImage1D = (PFNGLCOPYTEXIMAGE1DPROC)load( "glCopyTexImage1D" ); + glad_glCopyTexImage2D = (PFNGLCOPYTEXIMAGE2DPROC)load( "glCopyTexImage2D" ); + glad_glCopyTexSubImage1D = (PFNGLCOPYTEXSUBIMAGE1DPROC)load( "glCopyTexSubImage1D" ); + glad_glCopyTexSubImage2D = (PFNGLCOPYTEXSUBIMAGE2DPROC)load( "glCopyTexSubImage2D" ); + glad_glTexSubImage1D = (PFNGLTEXSUBIMAGE1DPROC)load( "glTexSubImage1D" ); + glad_glTexSubImage2D = (PFNGLTEXSUBIMAGE2DPROC)load( "glTexSubImage2D" ); + glad_glBindTexture = (PFNGLBINDTEXTUREPROC)load( "glBindTexture" ); + glad_glDeleteTextures = (PFNGLDELETETEXTURESPROC)load( "glDeleteTextures" ); + glad_glGenTextures = (PFNGLGENTEXTURESPROC)load( "glGenTextures" ); + glad_glIsTexture = (PFNGLISTEXTUREPROC)load( "glIsTexture" ); + glad_glArrayElement = (PFNGLARRAYELEMENTPROC)load( "glArrayElement" ); + glad_glColorPointer = (PFNGLCOLORPOINTERPROC)load( "glColorPointer" ); + glad_glDisableClientState = (PFNGLDISABLECLIENTSTATEPROC)load( "glDisableClientState" ); + glad_glEdgeFlagPointer = (PFNGLEDGEFLAGPOINTERPROC)load( "glEdgeFlagPointer" ); + glad_glEnableClientState = (PFNGLENABLECLIENTSTATEPROC)load( "glEnableClientState" ); + glad_glIndexPointer = (PFNGLINDEXPOINTERPROC)load( "glIndexPointer" ); + glad_glInterleavedArrays = (PFNGLINTERLEAVEDARRAYSPROC)load( "glInterleavedArrays" ); + glad_glNormalPointer = (PFNGLNORMALPOINTERPROC)load( "glNormalPointer" ); + glad_glTexCoordPointer = (PFNGLTEXCOORDPOINTERPROC)load( "glTexCoordPointer" ); + glad_glVertexPointer = (PFNGLVERTEXPOINTERPROC)load( "glVertexPointer" ); + glad_glAreTexturesResident = (PFNGLARETEXTURESRESIDENTPROC)load( "glAreTexturesResident" ); + glad_glPrioritizeTextures = (PFNGLPRIORITIZETEXTURESPROC)load( "glPrioritizeTextures" ); + glad_glIndexub = (PFNGLINDEXUBPROC)load( "glIndexub" ); + glad_glIndexubv = (PFNGLINDEXUBVPROC)load( "glIndexubv" ); + glad_glPopClientAttrib = (PFNGLPOPCLIENTATTRIBPROC)load( "glPopClientAttrib" ); + glad_glPushClientAttrib = (PFNGLPUSHCLIENTATTRIBPROC)load( "glPushClientAttrib" ); +} +static void load_GL_VERSION_1_2( GLADloadproc load ) { + if ( !GLAD_GL_VERSION_1_2 ) return; + glad_glDrawRangeElements = (PFNGLDRAWRANGEELEMENTSPROC)load( "glDrawRangeElements" ); + glad_glTexImage3D = (PFNGLTEXIMAGE3DPROC)load( "glTexImage3D" ); + glad_glTexSubImage3D = (PFNGLTEXSUBIMAGE3DPROC)load( "glTexSubImage3D" ); + glad_glCopyTexSubImage3D = (PFNGLCOPYTEXSUBIMAGE3DPROC)load( "glCopyTexSubImage3D" ); +} +static void load_GL_VERSION_1_3( GLADloadproc load ) { + if ( !GLAD_GL_VERSION_1_3 ) return; + glad_glActiveTexture = (PFNGLACTIVETEXTUREPROC)load( "glActiveTexture" ); + glad_glSampleCoverage = (PFNGLSAMPLECOVERAGEPROC)load( "glSampleCoverage" ); + glad_glCompressedTexImage3D = (PFNGLCOMPRESSEDTEXIMAGE3DPROC)load( "glCompressedTexImage3D" ); + glad_glCompressedTexImage2D = (PFNGLCOMPRESSEDTEXIMAGE2DPROC)load( "glCompressedTexImage2D" ); + glad_glCompressedTexImage1D = (PFNGLCOMPRESSEDTEXIMAGE1DPROC)load( "glCompressedTexImage1D" ); + glad_glCompressedTexSubImage3D = (PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC)load( "glCompressedTexSubImage3D" ); + glad_glCompressedTexSubImage2D = (PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC)load( "glCompressedTexSubImage2D" ); + glad_glCompressedTexSubImage1D = (PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC)load( "glCompressedTexSubImage1D" ); + glad_glGetCompressedTexImage = (PFNGLGETCOMPRESSEDTEXIMAGEPROC)load( "glGetCompressedTexImage" ); + glad_glClientActiveTexture = (PFNGLCLIENTACTIVETEXTUREPROC)load( "glClientActiveTexture" ); + glad_glMultiTexCoord1d = (PFNGLMULTITEXCOORD1DPROC)load( "glMultiTexCoord1d" ); + glad_glMultiTexCoord1dv = (PFNGLMULTITEXCOORD1DVPROC)load( "glMultiTexCoord1dv" ); + glad_glMultiTexCoord1f = (PFNGLMULTITEXCOORD1FPROC)load( "glMultiTexCoord1f" ); + glad_glMultiTexCoord1fv = (PFNGLMULTITEXCOORD1FVPROC)load( "glMultiTexCoord1fv" ); + glad_glMultiTexCoord1i = (PFNGLMULTITEXCOORD1IPROC)load( "glMultiTexCoord1i" ); + glad_glMultiTexCoord1iv = (PFNGLMULTITEXCOORD1IVPROC)load( "glMultiTexCoord1iv" ); + glad_glMultiTexCoord1s = (PFNGLMULTITEXCOORD1SPROC)load( "glMultiTexCoord1s" ); + glad_glMultiTexCoord1sv = (PFNGLMULTITEXCOORD1SVPROC)load( "glMultiTexCoord1sv" ); + glad_glMultiTexCoord2d = (PFNGLMULTITEXCOORD2DPROC)load( "glMultiTexCoord2d" ); + glad_glMultiTexCoord2dv = (PFNGLMULTITEXCOORD2DVPROC)load( "glMultiTexCoord2dv" ); + glad_glMultiTexCoord2f = (PFNGLMULTITEXCOORD2FPROC)load( "glMultiTexCoord2f" ); + glad_glMultiTexCoord2fv = (PFNGLMULTITEXCOORD2FVPROC)load( "glMultiTexCoord2fv" ); + glad_glMultiTexCoord2i = (PFNGLMULTITEXCOORD2IPROC)load( "glMultiTexCoord2i" ); + glad_glMultiTexCoord2iv = (PFNGLMULTITEXCOORD2IVPROC)load( "glMultiTexCoord2iv" ); + glad_glMultiTexCoord2s = (PFNGLMULTITEXCOORD2SPROC)load( "glMultiTexCoord2s" ); + glad_glMultiTexCoord2sv = (PFNGLMULTITEXCOORD2SVPROC)load( "glMultiTexCoord2sv" ); + glad_glMultiTexCoord3d = (PFNGLMULTITEXCOORD3DPROC)load( "glMultiTexCoord3d" ); + glad_glMultiTexCoord3dv = (PFNGLMULTITEXCOORD3DVPROC)load( "glMultiTexCoord3dv" ); + glad_glMultiTexCoord3f = (PFNGLMULTITEXCOORD3FPROC)load( "glMultiTexCoord3f" ); + glad_glMultiTexCoord3fv = (PFNGLMULTITEXCOORD3FVPROC)load( "glMultiTexCoord3fv" ); + glad_glMultiTexCoord3i = (PFNGLMULTITEXCOORD3IPROC)load( "glMultiTexCoord3i" ); + glad_glMultiTexCoord3iv = (PFNGLMULTITEXCOORD3IVPROC)load( "glMultiTexCoord3iv" ); + glad_glMultiTexCoord3s = (PFNGLMULTITEXCOORD3SPROC)load( "glMultiTexCoord3s" ); + glad_glMultiTexCoord3sv = (PFNGLMULTITEXCOORD3SVPROC)load( "glMultiTexCoord3sv" ); + glad_glMultiTexCoord4d = (PFNGLMULTITEXCOORD4DPROC)load( "glMultiTexCoord4d" ); + glad_glMultiTexCoord4dv = (PFNGLMULTITEXCOORD4DVPROC)load( "glMultiTexCoord4dv" ); + glad_glMultiTexCoord4f = (PFNGLMULTITEXCOORD4FPROC)load( "glMultiTexCoord4f" ); + glad_glMultiTexCoord4fv = (PFNGLMULTITEXCOORD4FVPROC)load( "glMultiTexCoord4fv" ); + glad_glMultiTexCoord4i = (PFNGLMULTITEXCOORD4IPROC)load( "glMultiTexCoord4i" ); + glad_glMultiTexCoord4iv = (PFNGLMULTITEXCOORD4IVPROC)load( "glMultiTexCoord4iv" ); + glad_glMultiTexCoord4s = (PFNGLMULTITEXCOORD4SPROC)load( "glMultiTexCoord4s" ); + glad_glMultiTexCoord4sv = (PFNGLMULTITEXCOORD4SVPROC)load( "glMultiTexCoord4sv" ); + glad_glLoadTransposeMatrixf = (PFNGLLOADTRANSPOSEMATRIXFPROC)load( "glLoadTransposeMatrixf" ); + glad_glLoadTransposeMatrixd = (PFNGLLOADTRANSPOSEMATRIXDPROC)load( "glLoadTransposeMatrixd" ); + glad_glMultTransposeMatrixf = (PFNGLMULTTRANSPOSEMATRIXFPROC)load( "glMultTransposeMatrixf" ); + glad_glMultTransposeMatrixd = (PFNGLMULTTRANSPOSEMATRIXDPROC)load( "glMultTransposeMatrixd" ); +} +static void load_GL_VERSION_1_4( GLADloadproc load ) { + if ( !GLAD_GL_VERSION_1_4 ) return; + glad_glBlendFuncSeparate = (PFNGLBLENDFUNCSEPARATEPROC)load( "glBlendFuncSeparate" ); + glad_glMultiDrawArrays = (PFNGLMULTIDRAWARRAYSPROC)load( "glMultiDrawArrays" ); + glad_glMultiDrawElements = (PFNGLMULTIDRAWELEMENTSPROC)load( "glMultiDrawElements" ); + glad_glPointParameterf = (PFNGLPOINTPARAMETERFPROC)load( "glPointParameterf" ); + glad_glPointParameterfv = (PFNGLPOINTPARAMETERFVPROC)load( "glPointParameterfv" ); + glad_glPointParameteri = (PFNGLPOINTPARAMETERIPROC)load( "glPointParameteri" ); + glad_glPointParameteriv = (PFNGLPOINTPARAMETERIVPROC)load( "glPointParameteriv" ); + glad_glFogCoordf = (PFNGLFOGCOORDFPROC)load( "glFogCoordf" ); + glad_glFogCoordfv = (PFNGLFOGCOORDFVPROC)load( "glFogCoordfv" ); + glad_glFogCoordd = (PFNGLFOGCOORDDPROC)load( "glFogCoordd" ); + glad_glFogCoorddv = (PFNGLFOGCOORDDVPROC)load( "glFogCoorddv" ); + glad_glFogCoordPointer = (PFNGLFOGCOORDPOINTERPROC)load( "glFogCoordPointer" ); + glad_glSecondaryColor3b = (PFNGLSECONDARYCOLOR3BPROC)load( "glSecondaryColor3b" ); + glad_glSecondaryColor3bv = (PFNGLSECONDARYCOLOR3BVPROC)load( "glSecondaryColor3bv" ); + glad_glSecondaryColor3d = (PFNGLSECONDARYCOLOR3DPROC)load( "glSecondaryColor3d" ); + glad_glSecondaryColor3dv = (PFNGLSECONDARYCOLOR3DVPROC)load( "glSecondaryColor3dv" ); + glad_glSecondaryColor3f = (PFNGLSECONDARYCOLOR3FPROC)load( "glSecondaryColor3f" ); + glad_glSecondaryColor3fv = (PFNGLSECONDARYCOLOR3FVPROC)load( "glSecondaryColor3fv" ); + glad_glSecondaryColor3i = (PFNGLSECONDARYCOLOR3IPROC)load( "glSecondaryColor3i" ); + glad_glSecondaryColor3iv = (PFNGLSECONDARYCOLOR3IVPROC)load( "glSecondaryColor3iv" ); + glad_glSecondaryColor3s = (PFNGLSECONDARYCOLOR3SPROC)load( "glSecondaryColor3s" ); + glad_glSecondaryColor3sv = (PFNGLSECONDARYCOLOR3SVPROC)load( "glSecondaryColor3sv" ); + glad_glSecondaryColor3ub = (PFNGLSECONDARYCOLOR3UBPROC)load( "glSecondaryColor3ub" ); + glad_glSecondaryColor3ubv = (PFNGLSECONDARYCOLOR3UBVPROC)load( "glSecondaryColor3ubv" ); + glad_glSecondaryColor3ui = (PFNGLSECONDARYCOLOR3UIPROC)load( "glSecondaryColor3ui" ); + glad_glSecondaryColor3uiv = (PFNGLSECONDARYCOLOR3UIVPROC)load( "glSecondaryColor3uiv" ); + glad_glSecondaryColor3us = (PFNGLSECONDARYCOLOR3USPROC)load( "glSecondaryColor3us" ); + glad_glSecondaryColor3usv = (PFNGLSECONDARYCOLOR3USVPROC)load( "glSecondaryColor3usv" ); + glad_glSecondaryColorPointer = (PFNGLSECONDARYCOLORPOINTERPROC)load( "glSecondaryColorPointer" ); + glad_glWindowPos2d = (PFNGLWINDOWPOS2DPROC)load( "glWindowPos2d" ); + glad_glWindowPos2dv = (PFNGLWINDOWPOS2DVPROC)load( "glWindowPos2dv" ); + glad_glWindowPos2f = (PFNGLWINDOWPOS2FPROC)load( "glWindowPos2f" ); + glad_glWindowPos2fv = (PFNGLWINDOWPOS2FVPROC)load( "glWindowPos2fv" ); + glad_glWindowPos2i = (PFNGLWINDOWPOS2IPROC)load( "glWindowPos2i" ); + glad_glWindowPos2iv = (PFNGLWINDOWPOS2IVPROC)load( "glWindowPos2iv" ); + glad_glWindowPos2s = (PFNGLWINDOWPOS2SPROC)load( "glWindowPos2s" ); + glad_glWindowPos2sv = (PFNGLWINDOWPOS2SVPROC)load( "glWindowPos2sv" ); + glad_glWindowPos3d = (PFNGLWINDOWPOS3DPROC)load( "glWindowPos3d" ); + glad_glWindowPos3dv = (PFNGLWINDOWPOS3DVPROC)load( "glWindowPos3dv" ); + glad_glWindowPos3f = (PFNGLWINDOWPOS3FPROC)load( "glWindowPos3f" ); + glad_glWindowPos3fv = (PFNGLWINDOWPOS3FVPROC)load( "glWindowPos3fv" ); + glad_glWindowPos3i = (PFNGLWINDOWPOS3IPROC)load( "glWindowPos3i" ); + glad_glWindowPos3iv = (PFNGLWINDOWPOS3IVPROC)load( "glWindowPos3iv" ); + glad_glWindowPos3s = (PFNGLWINDOWPOS3SPROC)load( "glWindowPos3s" ); + glad_glWindowPos3sv = (PFNGLWINDOWPOS3SVPROC)load( "glWindowPos3sv" ); + glad_glBlendColor = (PFNGLBLENDCOLORPROC)load( "glBlendColor" ); + glad_glBlendEquation = (PFNGLBLENDEQUATIONPROC)load( "glBlendEquation" ); +} +static void load_GL_VERSION_1_5( GLADloadproc load ) { + if ( !GLAD_GL_VERSION_1_5 ) return; + glad_glGenQueries = (PFNGLGENQUERIESPROC)load( "glGenQueries" ); + glad_glDeleteQueries = (PFNGLDELETEQUERIESPROC)load( "glDeleteQueries" ); + glad_glIsQuery = (PFNGLISQUERYPROC)load( "glIsQuery" ); + glad_glBeginQuery = (PFNGLBEGINQUERYPROC)load( "glBeginQuery" ); + glad_glEndQuery = (PFNGLENDQUERYPROC)load( "glEndQuery" ); + glad_glGetQueryiv = (PFNGLGETQUERYIVPROC)load( "glGetQueryiv" ); + glad_glGetQueryObjectiv = (PFNGLGETQUERYOBJECTIVPROC)load( "glGetQueryObjectiv" ); + glad_glGetQueryObjectuiv = (PFNGLGETQUERYOBJECTUIVPROC)load( "glGetQueryObjectuiv" ); + glad_glBindBuffer = (PFNGLBINDBUFFERPROC)load( "glBindBuffer" ); + glad_glDeleteBuffers = (PFNGLDELETEBUFFERSPROC)load( "glDeleteBuffers" ); + glad_glGenBuffers = (PFNGLGENBUFFERSPROC)load( "glGenBuffers" ); + glad_glIsBuffer = (PFNGLISBUFFERPROC)load( "glIsBuffer" ); + glad_glBufferData = (PFNGLBUFFERDATAPROC)load( "glBufferData" ); + glad_glBufferSubData = (PFNGLBUFFERSUBDATAPROC)load( "glBufferSubData" ); + glad_glGetBufferSubData = (PFNGLGETBUFFERSUBDATAPROC)load( "glGetBufferSubData" ); + glad_glMapBuffer = (PFNGLMAPBUFFERPROC)load( "glMapBuffer" ); + glad_glUnmapBuffer = (PFNGLUNMAPBUFFERPROC)load( "glUnmapBuffer" ); + glad_glGetBufferParameteriv = (PFNGLGETBUFFERPARAMETERIVPROC)load( "glGetBufferParameteriv" ); + glad_glGetBufferPointerv = (PFNGLGETBUFFERPOINTERVPROC)load( "glGetBufferPointerv" ); +} +static void load_GL_VERSION_2_0( GLADloadproc load ) { + if ( !GLAD_GL_VERSION_2_0 ) return; + glad_glBlendEquationSeparate = (PFNGLBLENDEQUATIONSEPARATEPROC)load( "glBlendEquationSeparate" ); + glad_glDrawBuffers = (PFNGLDRAWBUFFERSPROC)load( "glDrawBuffers" ); + glad_glStencilOpSeparate = (PFNGLSTENCILOPSEPARATEPROC)load( "glStencilOpSeparate" ); + glad_glStencilFuncSeparate = (PFNGLSTENCILFUNCSEPARATEPROC)load( "glStencilFuncSeparate" ); + glad_glStencilMaskSeparate = (PFNGLSTENCILMASKSEPARATEPROC)load( "glStencilMaskSeparate" ); + glad_glAttachShader = (PFNGLATTACHSHADERPROC)load( "glAttachShader" ); + glad_glBindAttribLocation = (PFNGLBINDATTRIBLOCATIONPROC)load( "glBindAttribLocation" ); + glad_glCompileShader = (PFNGLCOMPILESHADERPROC)load( "glCompileShader" ); + glad_glCreateProgram = (PFNGLCREATEPROGRAMPROC)load( "glCreateProgram" ); + glad_glCreateShader = (PFNGLCREATESHADERPROC)load( "glCreateShader" ); + glad_glDeleteProgram = (PFNGLDELETEPROGRAMPROC)load( "glDeleteProgram" ); + glad_glDeleteShader = (PFNGLDELETESHADERPROC)load( "glDeleteShader" ); + glad_glDetachShader = (PFNGLDETACHSHADERPROC)load( "glDetachShader" ); + glad_glDisableVertexAttribArray = (PFNGLDISABLEVERTEXATTRIBARRAYPROC)load( "glDisableVertexAttribArray" ); + glad_glEnableVertexAttribArray = (PFNGLENABLEVERTEXATTRIBARRAYPROC)load( "glEnableVertexAttribArray" ); + glad_glGetActiveAttrib = (PFNGLGETACTIVEATTRIBPROC)load( "glGetActiveAttrib" ); + glad_glGetActiveUniform = (PFNGLGETACTIVEUNIFORMPROC)load( "glGetActiveUniform" ); + glad_glGetAttachedShaders = (PFNGLGETATTACHEDSHADERSPROC)load( "glGetAttachedShaders" ); + glad_glGetAttribLocation = (PFNGLGETATTRIBLOCATIONPROC)load( "glGetAttribLocation" ); + glad_glGetProgramiv = (PFNGLGETPROGRAMIVPROC)load( "glGetProgramiv" ); + glad_glGetProgramInfoLog = (PFNGLGETPROGRAMINFOLOGPROC)load( "glGetProgramInfoLog" ); + glad_glGetShaderiv = (PFNGLGETSHADERIVPROC)load( "glGetShaderiv" ); + glad_glGetShaderInfoLog = (PFNGLGETSHADERINFOLOGPROC)load( "glGetShaderInfoLog" ); + glad_glGetShaderSource = (PFNGLGETSHADERSOURCEPROC)load( "glGetShaderSource" ); + glad_glGetUniformLocation = (PFNGLGETUNIFORMLOCATIONPROC)load( "glGetUniformLocation" ); + glad_glGetUniformfv = (PFNGLGETUNIFORMFVPROC)load( "glGetUniformfv" ); + glad_glGetUniformiv = (PFNGLGETUNIFORMIVPROC)load( "glGetUniformiv" ); + glad_glGetVertexAttribdv = (PFNGLGETVERTEXATTRIBDVPROC)load( "glGetVertexAttribdv" ); + glad_glGetVertexAttribfv = (PFNGLGETVERTEXATTRIBFVPROC)load( "glGetVertexAttribfv" ); + glad_glGetVertexAttribiv = (PFNGLGETVERTEXATTRIBIVPROC)load( "glGetVertexAttribiv" ); + glad_glGetVertexAttribPointerv = (PFNGLGETVERTEXATTRIBPOINTERVPROC)load( "glGetVertexAttribPointerv" ); + glad_glIsProgram = (PFNGLISPROGRAMPROC)load( "glIsProgram" ); + glad_glIsShader = (PFNGLISSHADERPROC)load( "glIsShader" ); + glad_glLinkProgram = (PFNGLLINKPROGRAMPROC)load( "glLinkProgram" ); + glad_glShaderSource = (PFNGLSHADERSOURCEPROC)load( "glShaderSource" ); + glad_glUseProgram = (PFNGLUSEPROGRAMPROC)load( "glUseProgram" ); + glad_glUniform1f = (PFNGLUNIFORM1FPROC)load( "glUniform1f" ); + glad_glUniform2f = (PFNGLUNIFORM2FPROC)load( "glUniform2f" ); + glad_glUniform3f = (PFNGLUNIFORM3FPROC)load( "glUniform3f" ); + glad_glUniform4f = (PFNGLUNIFORM4FPROC)load( "glUniform4f" ); + glad_glUniform1i = (PFNGLUNIFORM1IPROC)load( "glUniform1i" ); + glad_glUniform2i = (PFNGLUNIFORM2IPROC)load( "glUniform2i" ); + glad_glUniform3i = (PFNGLUNIFORM3IPROC)load( "glUniform3i" ); + glad_glUniform4i = (PFNGLUNIFORM4IPROC)load( "glUniform4i" ); + glad_glUniform1fv = (PFNGLUNIFORM1FVPROC)load( "glUniform1fv" ); + glad_glUniform2fv = (PFNGLUNIFORM2FVPROC)load( "glUniform2fv" ); + glad_glUniform3fv = (PFNGLUNIFORM3FVPROC)load( "glUniform3fv" ); + glad_glUniform4fv = (PFNGLUNIFORM4FVPROC)load( "glUniform4fv" ); + glad_glUniform1iv = (PFNGLUNIFORM1IVPROC)load( "glUniform1iv" ); + glad_glUniform2iv = (PFNGLUNIFORM2IVPROC)load( "glUniform2iv" ); + glad_glUniform3iv = (PFNGLUNIFORM3IVPROC)load( "glUniform3iv" ); + glad_glUniform4iv = (PFNGLUNIFORM4IVPROC)load( "glUniform4iv" ); + glad_glUniformMatrix2fv = (PFNGLUNIFORMMATRIX2FVPROC)load( "glUniformMatrix2fv" ); + glad_glUniformMatrix3fv = (PFNGLUNIFORMMATRIX3FVPROC)load( "glUniformMatrix3fv" ); + glad_glUniformMatrix4fv = (PFNGLUNIFORMMATRIX4FVPROC)load( "glUniformMatrix4fv" ); + glad_glValidateProgram = (PFNGLVALIDATEPROGRAMPROC)load( "glValidateProgram" ); + glad_glVertexAttrib1d = (PFNGLVERTEXATTRIB1DPROC)load( "glVertexAttrib1d" ); + glad_glVertexAttrib1dv = (PFNGLVERTEXATTRIB1DVPROC)load( "glVertexAttrib1dv" ); + glad_glVertexAttrib1f = (PFNGLVERTEXATTRIB1FPROC)load( "glVertexAttrib1f" ); + glad_glVertexAttrib1fv = (PFNGLVERTEXATTRIB1FVPROC)load( "glVertexAttrib1fv" ); + glad_glVertexAttrib1s = (PFNGLVERTEXATTRIB1SPROC)load( "glVertexAttrib1s" ); + glad_glVertexAttrib1sv = (PFNGLVERTEXATTRIB1SVPROC)load( "glVertexAttrib1sv" ); + glad_glVertexAttrib2d = (PFNGLVERTEXATTRIB2DPROC)load( "glVertexAttrib2d" ); + glad_glVertexAttrib2dv = (PFNGLVERTEXATTRIB2DVPROC)load( "glVertexAttrib2dv" ); + glad_glVertexAttrib2f = (PFNGLVERTEXATTRIB2FPROC)load( "glVertexAttrib2f" ); + glad_glVertexAttrib2fv = (PFNGLVERTEXATTRIB2FVPROC)load( "glVertexAttrib2fv" ); + glad_glVertexAttrib2s = (PFNGLVERTEXATTRIB2SPROC)load( "glVertexAttrib2s" ); + glad_glVertexAttrib2sv = (PFNGLVERTEXATTRIB2SVPROC)load( "glVertexAttrib2sv" ); + glad_glVertexAttrib3d = (PFNGLVERTEXATTRIB3DPROC)load( "glVertexAttrib3d" ); + glad_glVertexAttrib3dv = (PFNGLVERTEXATTRIB3DVPROC)load( "glVertexAttrib3dv" ); + glad_glVertexAttrib3f = (PFNGLVERTEXATTRIB3FPROC)load( "glVertexAttrib3f" ); + glad_glVertexAttrib3fv = (PFNGLVERTEXATTRIB3FVPROC)load( "glVertexAttrib3fv" ); + glad_glVertexAttrib3s = (PFNGLVERTEXATTRIB3SPROC)load( "glVertexAttrib3s" ); + glad_glVertexAttrib3sv = (PFNGLVERTEXATTRIB3SVPROC)load( "glVertexAttrib3sv" ); + glad_glVertexAttrib4Nbv = (PFNGLVERTEXATTRIB4NBVPROC)load( "glVertexAttrib4Nbv" ); + glad_glVertexAttrib4Niv = (PFNGLVERTEXATTRIB4NIVPROC)load( "glVertexAttrib4Niv" ); + glad_glVertexAttrib4Nsv = (PFNGLVERTEXATTRIB4NSVPROC)load( "glVertexAttrib4Nsv" ); + glad_glVertexAttrib4Nub = (PFNGLVERTEXATTRIB4NUBPROC)load( "glVertexAttrib4Nub" ); + glad_glVertexAttrib4Nubv = (PFNGLVERTEXATTRIB4NUBVPROC)load( "glVertexAttrib4Nubv" ); + glad_glVertexAttrib4Nuiv = (PFNGLVERTEXATTRIB4NUIVPROC)load( "glVertexAttrib4Nuiv" ); + glad_glVertexAttrib4Nusv = (PFNGLVERTEXATTRIB4NUSVPROC)load( "glVertexAttrib4Nusv" ); + glad_glVertexAttrib4bv = (PFNGLVERTEXATTRIB4BVPROC)load( "glVertexAttrib4bv" ); + glad_glVertexAttrib4d = (PFNGLVERTEXATTRIB4DPROC)load( "glVertexAttrib4d" ); + glad_glVertexAttrib4dv = (PFNGLVERTEXATTRIB4DVPROC)load( "glVertexAttrib4dv" ); + glad_glVertexAttrib4f = (PFNGLVERTEXATTRIB4FPROC)load( "glVertexAttrib4f" ); + glad_glVertexAttrib4fv = (PFNGLVERTEXATTRIB4FVPROC)load( "glVertexAttrib4fv" ); + glad_glVertexAttrib4iv = (PFNGLVERTEXATTRIB4IVPROC)load( "glVertexAttrib4iv" ); + glad_glVertexAttrib4s = (PFNGLVERTEXATTRIB4SPROC)load( "glVertexAttrib4s" ); + glad_glVertexAttrib4sv = (PFNGLVERTEXATTRIB4SVPROC)load( "glVertexAttrib4sv" ); + glad_glVertexAttrib4ubv = (PFNGLVERTEXATTRIB4UBVPROC)load( "glVertexAttrib4ubv" ); + glad_glVertexAttrib4uiv = (PFNGLVERTEXATTRIB4UIVPROC)load( "glVertexAttrib4uiv" ); + glad_glVertexAttrib4usv = (PFNGLVERTEXATTRIB4USVPROC)load( "glVertexAttrib4usv" ); + glad_glVertexAttribPointer = (PFNGLVERTEXATTRIBPOINTERPROC)load( "glVertexAttribPointer" ); +} +static void load_GL_VERSION_2_1( GLADloadproc load ) { + if ( !GLAD_GL_VERSION_2_1 ) return; + glad_glUniformMatrix2x3fv = (PFNGLUNIFORMMATRIX2X3FVPROC)load( "glUniformMatrix2x3fv" ); + glad_glUniformMatrix3x2fv = (PFNGLUNIFORMMATRIX3X2FVPROC)load( "glUniformMatrix3x2fv" ); + glad_glUniformMatrix2x4fv = (PFNGLUNIFORMMATRIX2X4FVPROC)load( "glUniformMatrix2x4fv" ); + glad_glUniformMatrix4x2fv = (PFNGLUNIFORMMATRIX4X2FVPROC)load( "glUniformMatrix4x2fv" ); + glad_glUniformMatrix3x4fv = (PFNGLUNIFORMMATRIX3X4FVPROC)load( "glUniformMatrix3x4fv" ); + glad_glUniformMatrix4x3fv = (PFNGLUNIFORMMATRIX4X3FVPROC)load( "glUniformMatrix4x3fv" ); +} +static void load_GL_VERSION_3_0( GLADloadproc load ) { + if ( !GLAD_GL_VERSION_3_0 ) return; + glad_glColorMaski = (PFNGLCOLORMASKIPROC)load( "glColorMaski" ); + glad_glGetBooleani_v = (PFNGLGETBOOLEANI_VPROC)load( "glGetBooleani_v" ); + glad_glGetIntegeri_v = (PFNGLGETINTEGERI_VPROC)load( "glGetIntegeri_v" ); + glad_glEnablei = (PFNGLENABLEIPROC)load( "glEnablei" ); + glad_glDisablei = (PFNGLDISABLEIPROC)load( "glDisablei" ); + glad_glIsEnabledi = (PFNGLISENABLEDIPROC)load( "glIsEnabledi" ); + glad_glBeginTransformFeedback = (PFNGLBEGINTRANSFORMFEEDBACKPROC)load( "glBeginTransformFeedback" ); + glad_glEndTransformFeedback = (PFNGLENDTRANSFORMFEEDBACKPROC)load( "glEndTransformFeedback" ); + glad_glBindBufferRange = (PFNGLBINDBUFFERRANGEPROC)load( "glBindBufferRange" ); + glad_glBindBufferBase = (PFNGLBINDBUFFERBASEPROC)load( "glBindBufferBase" ); + glad_glTransformFeedbackVaryings = (PFNGLTRANSFORMFEEDBACKVARYINGSPROC)load( "glTransformFeedbackVaryings" ); + glad_glGetTransformFeedbackVarying = (PFNGLGETTRANSFORMFEEDBACKVARYINGPROC)load( "glGetTransformFeedbackVarying" ); + glad_glClampColor = (PFNGLCLAMPCOLORPROC)load( "glClampColor" ); + glad_glBeginConditionalRender = (PFNGLBEGINCONDITIONALRENDERPROC)load( "glBeginConditionalRender" ); + glad_glEndConditionalRender = (PFNGLENDCONDITIONALRENDERPROC)load( "glEndConditionalRender" ); + glad_glVertexAttribIPointer = (PFNGLVERTEXATTRIBIPOINTERPROC)load( "glVertexAttribIPointer" ); + glad_glGetVertexAttribIiv = (PFNGLGETVERTEXATTRIBIIVPROC)load( "glGetVertexAttribIiv" ); + glad_glGetVertexAttribIuiv = (PFNGLGETVERTEXATTRIBIUIVPROC)load( "glGetVertexAttribIuiv" ); + glad_glVertexAttribI1i = (PFNGLVERTEXATTRIBI1IPROC)load( "glVertexAttribI1i" ); + glad_glVertexAttribI2i = (PFNGLVERTEXATTRIBI2IPROC)load( "glVertexAttribI2i" ); + glad_glVertexAttribI3i = (PFNGLVERTEXATTRIBI3IPROC)load( "glVertexAttribI3i" ); + glad_glVertexAttribI4i = (PFNGLVERTEXATTRIBI4IPROC)load( "glVertexAttribI4i" ); + glad_glVertexAttribI1ui = (PFNGLVERTEXATTRIBI1UIPROC)load( "glVertexAttribI1ui" ); + glad_glVertexAttribI2ui = (PFNGLVERTEXATTRIBI2UIPROC)load( "glVertexAttribI2ui" ); + glad_glVertexAttribI3ui = (PFNGLVERTEXATTRIBI3UIPROC)load( "glVertexAttribI3ui" ); + glad_glVertexAttribI4ui = (PFNGLVERTEXATTRIBI4UIPROC)load( "glVertexAttribI4ui" ); + glad_glVertexAttribI1iv = (PFNGLVERTEXATTRIBI1IVPROC)load( "glVertexAttribI1iv" ); + glad_glVertexAttribI2iv = (PFNGLVERTEXATTRIBI2IVPROC)load( "glVertexAttribI2iv" ); + glad_glVertexAttribI3iv = (PFNGLVERTEXATTRIBI3IVPROC)load( "glVertexAttribI3iv" ); + glad_glVertexAttribI4iv = (PFNGLVERTEXATTRIBI4IVPROC)load( "glVertexAttribI4iv" ); + glad_glVertexAttribI1uiv = (PFNGLVERTEXATTRIBI1UIVPROC)load( "glVertexAttribI1uiv" ); + glad_glVertexAttribI2uiv = (PFNGLVERTEXATTRIBI2UIVPROC)load( "glVertexAttribI2uiv" ); + glad_glVertexAttribI3uiv = (PFNGLVERTEXATTRIBI3UIVPROC)load( "glVertexAttribI3uiv" ); + glad_glVertexAttribI4uiv = (PFNGLVERTEXATTRIBI4UIVPROC)load( "glVertexAttribI4uiv" ); + glad_glVertexAttribI4bv = (PFNGLVERTEXATTRIBI4BVPROC)load( "glVertexAttribI4bv" ); + glad_glVertexAttribI4sv = (PFNGLVERTEXATTRIBI4SVPROC)load( "glVertexAttribI4sv" ); + glad_glVertexAttribI4ubv = (PFNGLVERTEXATTRIBI4UBVPROC)load( "glVertexAttribI4ubv" ); + glad_glVertexAttribI4usv = (PFNGLVERTEXATTRIBI4USVPROC)load( "glVertexAttribI4usv" ); + glad_glGetUniformuiv = (PFNGLGETUNIFORMUIVPROC)load( "glGetUniformuiv" ); + glad_glBindFragDataLocation = (PFNGLBINDFRAGDATALOCATIONPROC)load( "glBindFragDataLocation" ); + glad_glGetFragDataLocation = (PFNGLGETFRAGDATALOCATIONPROC)load( "glGetFragDataLocation" ); + glad_glUniform1ui = (PFNGLUNIFORM1UIPROC)load( "glUniform1ui" ); + glad_glUniform2ui = (PFNGLUNIFORM2UIPROC)load( "glUniform2ui" ); + glad_glUniform3ui = (PFNGLUNIFORM3UIPROC)load( "glUniform3ui" ); + glad_glUniform4ui = (PFNGLUNIFORM4UIPROC)load( "glUniform4ui" ); + glad_glUniform1uiv = (PFNGLUNIFORM1UIVPROC)load( "glUniform1uiv" ); + glad_glUniform2uiv = (PFNGLUNIFORM2UIVPROC)load( "glUniform2uiv" ); + glad_glUniform3uiv = (PFNGLUNIFORM3UIVPROC)load( "glUniform3uiv" ); + glad_glUniform4uiv = (PFNGLUNIFORM4UIVPROC)load( "glUniform4uiv" ); + glad_glTexParameterIiv = (PFNGLTEXPARAMETERIIVPROC)load( "glTexParameterIiv" ); + glad_glTexParameterIuiv = (PFNGLTEXPARAMETERIUIVPROC)load( "glTexParameterIuiv" ); + glad_glGetTexParameterIiv = (PFNGLGETTEXPARAMETERIIVPROC)load( "glGetTexParameterIiv" ); + glad_glGetTexParameterIuiv = (PFNGLGETTEXPARAMETERIUIVPROC)load( "glGetTexParameterIuiv" ); + glad_glClearBufferiv = (PFNGLCLEARBUFFERIVPROC)load( "glClearBufferiv" ); + glad_glClearBufferuiv = (PFNGLCLEARBUFFERUIVPROC)load( "glClearBufferuiv" ); + glad_glClearBufferfv = (PFNGLCLEARBUFFERFVPROC)load( "glClearBufferfv" ); + glad_glClearBufferfi = (PFNGLCLEARBUFFERFIPROC)load( "glClearBufferfi" ); + glad_glGetStringi = (PFNGLGETSTRINGIPROC)load( "glGetStringi" ); + glad_glIsRenderbuffer = (PFNGLISRENDERBUFFERPROC)load( "glIsRenderbuffer" ); + glad_glBindRenderbuffer = (PFNGLBINDRENDERBUFFERPROC)load( "glBindRenderbuffer" ); + glad_glDeleteRenderbuffers = (PFNGLDELETERENDERBUFFERSPROC)load( "glDeleteRenderbuffers" ); + glad_glGenRenderbuffers = (PFNGLGENRENDERBUFFERSPROC)load( "glGenRenderbuffers" ); + glad_glRenderbufferStorage = (PFNGLRENDERBUFFERSTORAGEPROC)load( "glRenderbufferStorage" ); + glad_glGetRenderbufferParameteriv = (PFNGLGETRENDERBUFFERPARAMETERIVPROC)load( "glGetRenderbufferParameteriv" ); + glad_glIsFramebuffer = (PFNGLISFRAMEBUFFERPROC)load( "glIsFramebuffer" ); + glad_glBindFramebuffer = (PFNGLBINDFRAMEBUFFERPROC)load( "glBindFramebuffer" ); + glad_glDeleteFramebuffers = (PFNGLDELETEFRAMEBUFFERSPROC)load( "glDeleteFramebuffers" ); + glad_glGenFramebuffers = (PFNGLGENFRAMEBUFFERSPROC)load( "glGenFramebuffers" ); + glad_glCheckFramebufferStatus = (PFNGLCHECKFRAMEBUFFERSTATUSPROC)load( "glCheckFramebufferStatus" ); + glad_glFramebufferTexture1D = (PFNGLFRAMEBUFFERTEXTURE1DPROC)load( "glFramebufferTexture1D" ); + glad_glFramebufferTexture2D = (PFNGLFRAMEBUFFERTEXTURE2DPROC)load( "glFramebufferTexture2D" ); + glad_glFramebufferTexture3D = (PFNGLFRAMEBUFFERTEXTURE3DPROC)load( "glFramebufferTexture3D" ); + glad_glFramebufferRenderbuffer = (PFNGLFRAMEBUFFERRENDERBUFFERPROC)load( "glFramebufferRenderbuffer" ); + glad_glGetFramebufferAttachmentParameteriv = (PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC)load( "glGetFramebufferAttachmentParameteriv" ); + glad_glGenerateMipmap = (PFNGLGENERATEMIPMAPPROC)load( "glGenerateMipmap" ); + glad_glBlitFramebuffer = (PFNGLBLITFRAMEBUFFERPROC)load( "glBlitFramebuffer" ); + glad_glRenderbufferStorageMultisample = (PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC)load( "glRenderbufferStorageMultisample" ); + glad_glFramebufferTextureLayer = (PFNGLFRAMEBUFFERTEXTURELAYERPROC)load( "glFramebufferTextureLayer" ); + glad_glMapBufferRange = (PFNGLMAPBUFFERRANGEPROC)load( "glMapBufferRange" ); + glad_glFlushMappedBufferRange = (PFNGLFLUSHMAPPEDBUFFERRANGEPROC)load( "glFlushMappedBufferRange" ); + glad_glBindVertexArray = (PFNGLBINDVERTEXARRAYPROC)load( "glBindVertexArray" ); + glad_glDeleteVertexArrays = (PFNGLDELETEVERTEXARRAYSPROC)load( "glDeleteVertexArrays" ); + glad_glGenVertexArrays = (PFNGLGENVERTEXARRAYSPROC)load( "glGenVertexArrays" ); + glad_glIsVertexArray = (PFNGLISVERTEXARRAYPROC)load( "glIsVertexArray" ); +} +static void load_GL_VERSION_3_1( GLADloadproc load ) { + if ( !GLAD_GL_VERSION_3_1 ) return; + glad_glDrawArraysInstanced = (PFNGLDRAWARRAYSINSTANCEDPROC)load( "glDrawArraysInstanced" ); + glad_glDrawElementsInstanced = (PFNGLDRAWELEMENTSINSTANCEDPROC)load( "glDrawElementsInstanced" ); + glad_glTexBuffer = (PFNGLTEXBUFFERPROC)load( "glTexBuffer" ); + glad_glPrimitiveRestartIndex = (PFNGLPRIMITIVERESTARTINDEXPROC)load( "glPrimitiveRestartIndex" ); + glad_glCopyBufferSubData = (PFNGLCOPYBUFFERSUBDATAPROC)load( "glCopyBufferSubData" ); + glad_glGetUniformIndices = (PFNGLGETUNIFORMINDICESPROC)load( "glGetUniformIndices" ); + glad_glGetActiveUniformsiv = (PFNGLGETACTIVEUNIFORMSIVPROC)load( "glGetActiveUniformsiv" ); + glad_glGetActiveUniformName = (PFNGLGETACTIVEUNIFORMNAMEPROC)load( "glGetActiveUniformName" ); + glad_glGetUniformBlockIndex = (PFNGLGETUNIFORMBLOCKINDEXPROC)load( "glGetUniformBlockIndex" ); + glad_glGetActiveUniformBlockiv = (PFNGLGETACTIVEUNIFORMBLOCKIVPROC)load( "glGetActiveUniformBlockiv" ); + glad_glGetActiveUniformBlockName = (PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC)load( "glGetActiveUniformBlockName" ); + glad_glUniformBlockBinding = (PFNGLUNIFORMBLOCKBINDINGPROC)load( "glUniformBlockBinding" ); + glad_glBindBufferRange = (PFNGLBINDBUFFERRANGEPROC)load( "glBindBufferRange" ); + glad_glBindBufferBase = (PFNGLBINDBUFFERBASEPROC)load( "glBindBufferBase" ); + glad_glGetIntegeri_v = (PFNGLGETINTEGERI_VPROC)load( "glGetIntegeri_v" ); +} +static void load_GL_VERSION_3_2( GLADloadproc load ) { + if ( !GLAD_GL_VERSION_3_2 ) return; + glad_glDrawElementsBaseVertex = (PFNGLDRAWELEMENTSBASEVERTEXPROC)load( "glDrawElementsBaseVertex" ); + glad_glDrawRangeElementsBaseVertex = (PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC)load( "glDrawRangeElementsBaseVertex" ); + glad_glDrawElementsInstancedBaseVertex = (PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC)load( "glDrawElementsInstancedBaseVertex" ); + glad_glMultiDrawElementsBaseVertex = (PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC)load( "glMultiDrawElementsBaseVertex" ); + glad_glProvokingVertex = (PFNGLPROVOKINGVERTEXPROC)load( "glProvokingVertex" ); + glad_glFenceSync = (PFNGLFENCESYNCPROC)load( "glFenceSync" ); + glad_glIsSync = (PFNGLISSYNCPROC)load( "glIsSync" ); + glad_glDeleteSync = (PFNGLDELETESYNCPROC)load( "glDeleteSync" ); + glad_glClientWaitSync = (PFNGLCLIENTWAITSYNCPROC)load( "glClientWaitSync" ); + glad_glWaitSync = (PFNGLWAITSYNCPROC)load( "glWaitSync" ); + glad_glGetInteger64v = (PFNGLGETINTEGER64VPROC)load( "glGetInteger64v" ); + glad_glGetSynciv = (PFNGLGETSYNCIVPROC)load( "glGetSynciv" ); + glad_glGetInteger64i_v = (PFNGLGETINTEGER64I_VPROC)load( "glGetInteger64i_v" ); + glad_glGetBufferParameteri64v = (PFNGLGETBUFFERPARAMETERI64VPROC)load( "glGetBufferParameteri64v" ); + glad_glFramebufferTexture = (PFNGLFRAMEBUFFERTEXTUREPROC)load( "glFramebufferTexture" ); + glad_glTexImage2DMultisample = (PFNGLTEXIMAGE2DMULTISAMPLEPROC)load( "glTexImage2DMultisample" ); + glad_glTexImage3DMultisample = (PFNGLTEXIMAGE3DMULTISAMPLEPROC)load( "glTexImage3DMultisample" ); + glad_glGetMultisamplefv = (PFNGLGETMULTISAMPLEFVPROC)load( "glGetMultisamplefv" ); + glad_glSampleMaski = (PFNGLSAMPLEMASKIPROC)load( "glSampleMaski" ); +} +static void load_GL_VERSION_3_3( GLADloadproc load ) { + if ( !GLAD_GL_VERSION_3_3 ) return; + glad_glBindFragDataLocationIndexed = (PFNGLBINDFRAGDATALOCATIONINDEXEDPROC)load( "glBindFragDataLocationIndexed" ); + glad_glGetFragDataIndex = (PFNGLGETFRAGDATAINDEXPROC)load( "glGetFragDataIndex" ); + glad_glGenSamplers = (PFNGLGENSAMPLERSPROC)load( "glGenSamplers" ); + glad_glDeleteSamplers = (PFNGLDELETESAMPLERSPROC)load( "glDeleteSamplers" ); + glad_glIsSampler = (PFNGLISSAMPLERPROC)load( "glIsSampler" ); + glad_glBindSampler = (PFNGLBINDSAMPLERPROC)load( "glBindSampler" ); + glad_glSamplerParameteri = (PFNGLSAMPLERPARAMETERIPROC)load( "glSamplerParameteri" ); + glad_glSamplerParameteriv = (PFNGLSAMPLERPARAMETERIVPROC)load( "glSamplerParameteriv" ); + glad_glSamplerParameterf = (PFNGLSAMPLERPARAMETERFPROC)load( "glSamplerParameterf" ); + glad_glSamplerParameterfv = (PFNGLSAMPLERPARAMETERFVPROC)load( "glSamplerParameterfv" ); + glad_glSamplerParameterIiv = (PFNGLSAMPLERPARAMETERIIVPROC)load( "glSamplerParameterIiv" ); + glad_glSamplerParameterIuiv = (PFNGLSAMPLERPARAMETERIUIVPROC)load( "glSamplerParameterIuiv" ); + glad_glGetSamplerParameteriv = (PFNGLGETSAMPLERPARAMETERIVPROC)load( "glGetSamplerParameteriv" ); + glad_glGetSamplerParameterIiv = (PFNGLGETSAMPLERPARAMETERIIVPROC)load( "glGetSamplerParameterIiv" ); + glad_glGetSamplerParameterfv = (PFNGLGETSAMPLERPARAMETERFVPROC)load( "glGetSamplerParameterfv" ); + glad_glGetSamplerParameterIuiv = (PFNGLGETSAMPLERPARAMETERIUIVPROC)load( "glGetSamplerParameterIuiv" ); + glad_glQueryCounter = (PFNGLQUERYCOUNTERPROC)load( "glQueryCounter" ); + glad_glGetQueryObjecti64v = (PFNGLGETQUERYOBJECTI64VPROC)load( "glGetQueryObjecti64v" ); + glad_glGetQueryObjectui64v = (PFNGLGETQUERYOBJECTUI64VPROC)load( "glGetQueryObjectui64v" ); + glad_glVertexAttribDivisor = (PFNGLVERTEXATTRIBDIVISORPROC)load( "glVertexAttribDivisor" ); + glad_glVertexAttribP1ui = (PFNGLVERTEXATTRIBP1UIPROC)load( "glVertexAttribP1ui" ); + glad_glVertexAttribP1uiv = (PFNGLVERTEXATTRIBP1UIVPROC)load( "glVertexAttribP1uiv" ); + glad_glVertexAttribP2ui = (PFNGLVERTEXATTRIBP2UIPROC)load( "glVertexAttribP2ui" ); + glad_glVertexAttribP2uiv = (PFNGLVERTEXATTRIBP2UIVPROC)load( "glVertexAttribP2uiv" ); + glad_glVertexAttribP3ui = (PFNGLVERTEXATTRIBP3UIPROC)load( "glVertexAttribP3ui" ); + glad_glVertexAttribP3uiv = (PFNGLVERTEXATTRIBP3UIVPROC)load( "glVertexAttribP3uiv" ); + glad_glVertexAttribP4ui = (PFNGLVERTEXATTRIBP4UIPROC)load( "glVertexAttribP4ui" ); + glad_glVertexAttribP4uiv = (PFNGLVERTEXATTRIBP4UIVPROC)load( "glVertexAttribP4uiv" ); + glad_glVertexP2ui = (PFNGLVERTEXP2UIPROC)load( "glVertexP2ui" ); + glad_glVertexP2uiv = (PFNGLVERTEXP2UIVPROC)load( "glVertexP2uiv" ); + glad_glVertexP3ui = (PFNGLVERTEXP3UIPROC)load( "glVertexP3ui" ); + glad_glVertexP3uiv = (PFNGLVERTEXP3UIVPROC)load( "glVertexP3uiv" ); + glad_glVertexP4ui = (PFNGLVERTEXP4UIPROC)load( "glVertexP4ui" ); + glad_glVertexP4uiv = (PFNGLVERTEXP4UIVPROC)load( "glVertexP4uiv" ); + glad_glTexCoordP1ui = (PFNGLTEXCOORDP1UIPROC)load( "glTexCoordP1ui" ); + glad_glTexCoordP1uiv = (PFNGLTEXCOORDP1UIVPROC)load( "glTexCoordP1uiv" ); + glad_glTexCoordP2ui = (PFNGLTEXCOORDP2UIPROC)load( "glTexCoordP2ui" ); + glad_glTexCoordP2uiv = (PFNGLTEXCOORDP2UIVPROC)load( "glTexCoordP2uiv" ); + glad_glTexCoordP3ui = (PFNGLTEXCOORDP3UIPROC)load( "glTexCoordP3ui" ); + glad_glTexCoordP3uiv = (PFNGLTEXCOORDP3UIVPROC)load( "glTexCoordP3uiv" ); + glad_glTexCoordP4ui = (PFNGLTEXCOORDP4UIPROC)load( "glTexCoordP4ui" ); + glad_glTexCoordP4uiv = (PFNGLTEXCOORDP4UIVPROC)load( "glTexCoordP4uiv" ); + glad_glMultiTexCoordP1ui = (PFNGLMULTITEXCOORDP1UIPROC)load( "glMultiTexCoordP1ui" ); + glad_glMultiTexCoordP1uiv = (PFNGLMULTITEXCOORDP1UIVPROC)load( "glMultiTexCoordP1uiv" ); + glad_glMultiTexCoordP2ui = (PFNGLMULTITEXCOORDP2UIPROC)load( "glMultiTexCoordP2ui" ); + glad_glMultiTexCoordP2uiv = (PFNGLMULTITEXCOORDP2UIVPROC)load( "glMultiTexCoordP2uiv" ); + glad_glMultiTexCoordP3ui = (PFNGLMULTITEXCOORDP3UIPROC)load( "glMultiTexCoordP3ui" ); + glad_glMultiTexCoordP3uiv = (PFNGLMULTITEXCOORDP3UIVPROC)load( "glMultiTexCoordP3uiv" ); + glad_glMultiTexCoordP4ui = (PFNGLMULTITEXCOORDP4UIPROC)load( "glMultiTexCoordP4ui" ); + glad_glMultiTexCoordP4uiv = (PFNGLMULTITEXCOORDP4UIVPROC)load( "glMultiTexCoordP4uiv" ); + glad_glNormalP3ui = (PFNGLNORMALP3UIPROC)load( "glNormalP3ui" ); + glad_glNormalP3uiv = (PFNGLNORMALP3UIVPROC)load( "glNormalP3uiv" ); + glad_glColorP3ui = (PFNGLCOLORP3UIPROC)load( "glColorP3ui" ); + glad_glColorP3uiv = (PFNGLCOLORP3UIVPROC)load( "glColorP3uiv" ); + glad_glColorP4ui = (PFNGLCOLORP4UIPROC)load( "glColorP4ui" ); + glad_glColorP4uiv = (PFNGLCOLORP4UIVPROC)load( "glColorP4uiv" ); + glad_glSecondaryColorP3ui = (PFNGLSECONDARYCOLORP3UIPROC)load( "glSecondaryColorP3ui" ); + glad_glSecondaryColorP3uiv = (PFNGLSECONDARYCOLORP3UIVPROC)load( "glSecondaryColorP3uiv" ); +} +static int find_extensionsGL( void ) { + if ( !get_exts() ) return 0; + (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/Aeon/ThirdParty/glad.h b/Aeon/ThirdParty/glad.h new file mode 100644 index 0000000..490b14a --- /dev/null +++ b/Aeon/ThirdParty/glad.h @@ -0,0 +1,3617 @@ +/* + + OpenGL loader generated by glad 0.1.28 on Tue Jan 15 14:49:19 2019. + + Language/Generator: C/C++ + Specification: gl + APIs: gl=3.3 + Profile: compatibility + Extensions: + + Loader: True + Local files: False + Omit khrplatform: False + Reproducible: False + + Commandline: + --profile="compatibility" --api="gl=3.3" --generator="c" --spec="gl" --extensions="" + Online: + https://glad.dav1d.de/#profile=compatibility&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__) +#ifndef WIN32_LEAN_AND_MEAN +#define WIN32_LEAN_AND_MEAN 1 +#endif +#ifndef NOMINMAX +#define NOMINMAX 1 +#endif +#include +#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_QUADS 0x0007 +#define GL_NEVER 0x0200 +#define GL_LESS 0x0201 +#define GL_EQUAL 0x0202 +#define GL_LEQUAL 0x0203 +#define GL_GREATER 0x0204 +#define GL_NOTEQUAL 0x0205 +#define GL_GEQUAL 0x0206 +#define GL_ALWAYS 0x0207 +#define GL_ZERO 0 +#define GL_ONE 1 +#define GL_SRC_COLOR 0x0300 +#define GL_ONE_MINUS_SRC_COLOR 0x0301 +#define GL_SRC_ALPHA 0x0302 +#define GL_ONE_MINUS_SRC_ALPHA 0x0303 +#define GL_DST_ALPHA 0x0304 +#define GL_ONE_MINUS_DST_ALPHA 0x0305 +#define GL_DST_COLOR 0x0306 +#define GL_ONE_MINUS_DST_COLOR 0x0307 +#define GL_SRC_ALPHA_SATURATE 0x0308 +#define GL_NONE 0 +#define GL_FRONT_LEFT 0x0400 +#define GL_FRONT_RIGHT 0x0401 +#define GL_BACK_LEFT 0x0402 +#define GL_BACK_RIGHT 0x0403 +#define GL_FRONT 0x0404 +#define GL_BACK 0x0405 +#define GL_LEFT 0x0406 +#define GL_RIGHT 0x0407 +#define GL_FRONT_AND_BACK 0x0408 +#define GL_NO_ERROR 0 +#define GL_INVALID_ENUM 0x0500 +#define GL_INVALID_VALUE 0x0501 +#define GL_INVALID_OPERATION 0x0502 +#define GL_OUT_OF_MEMORY 0x0505 +#define GL_CW 0x0900 +#define GL_CCW 0x0901 +#define GL_POINT_SIZE 0x0B11 +#define GL_POINT_SIZE_RANGE 0x0B12 +#define GL_POINT_SIZE_GRANULARITY 0x0B13 +#define GL_LINE_SMOOTH 0x0B20 +#define GL_LINE_WIDTH 0x0B21 +#define GL_LINE_WIDTH_RANGE 0x0B22 +#define GL_LINE_WIDTH_GRANULARITY 0x0B23 +#define GL_POLYGON_MODE 0x0B40 +#define GL_POLYGON_SMOOTH 0x0B41 +#define GL_CULL_FACE 0x0B44 +#define GL_CULL_FACE_MODE 0x0B45 +#define GL_FRONT_FACE 0x0B46 +#define GL_DEPTH_RANGE 0x0B70 +#define GL_DEPTH_TEST 0x0B71 +#define GL_DEPTH_WRITEMASK 0x0B72 +#define GL_DEPTH_CLEAR_VALUE 0x0B73 +#define GL_DEPTH_FUNC 0x0B74 +#define GL_STENCIL_TEST 0x0B90 +#define GL_STENCIL_CLEAR_VALUE 0x0B91 +#define GL_STENCIL_FUNC 0x0B92 +#define GL_STENCIL_VALUE_MASK 0x0B93 +#define GL_STENCIL_FAIL 0x0B94 +#define GL_STENCIL_PASS_DEPTH_FAIL 0x0B95 +#define GL_STENCIL_PASS_DEPTH_PASS 0x0B96 +#define GL_STENCIL_REF 0x0B97 +#define GL_STENCIL_WRITEMASK 0x0B98 +#define GL_VIEWPORT 0x0BA2 +#define GL_DITHER 0x0BD0 +#define GL_BLEND_DST 0x0BE0 +#define GL_BLEND_SRC 0x0BE1 +#define GL_BLEND 0x0BE2 +#define GL_LOGIC_OP_MODE 0x0BF0 +#define GL_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_STACK_OVERFLOW 0x0503 +#define GL_STACK_UNDERFLOW 0x0504 +#define GL_CLEAR 0x1500 +#define GL_AND 0x1501 +#define GL_AND_REVERSE 0x1502 +#define GL_COPY 0x1503 +#define GL_AND_INVERTED 0x1504 +#define GL_NOOP 0x1505 +#define GL_XOR 0x1506 +#define GL_OR 0x1507 +#define GL_NOR 0x1508 +#define GL_EQUIV 0x1509 +#define GL_INVERT 0x150A +#define GL_OR_REVERSE 0x150B +#define GL_COPY_INVERTED 0x150C +#define GL_OR_INVERTED 0x150D +#define GL_NAND 0x150E +#define GL_SET 0x150F +#define GL_TEXTURE 0x1702 +#define GL_COLOR 0x1800 +#define GL_DEPTH 0x1801 +#define GL_STENCIL 0x1802 +#define GL_STENCIL_INDEX 0x1901 +#define GL_DEPTH_COMPONENT 0x1902 +#define GL_RED 0x1903 +#define GL_GREEN 0x1904 +#define GL_BLUE 0x1905 +#define GL_ALPHA 0x1906 +#define GL_RGB 0x1907 +#define GL_RGBA 0x1908 +#define GL_POINT 0x1B00 +#define GL_LINE 0x1B01 +#define GL_FILL 0x1B02 +#define GL_KEEP 0x1E00 +#define GL_REPLACE 0x1E01 +#define GL_INCR 0x1E02 +#define GL_DECR 0x1E03 +#define GL_VENDOR 0x1F00 +#define GL_RENDERER 0x1F01 +#define GL_VERSION 0x1F02 +#define GL_EXTENSIONS 0x1F03 +#define GL_NEAREST 0x2600 +#define GL_LINEAR 0x2601 +#define GL_NEAREST_MIPMAP_NEAREST 0x2700 +#define GL_LINEAR_MIPMAP_NEAREST 0x2701 +#define GL_NEAREST_MIPMAP_LINEAR 0x2702 +#define GL_LINEAR_MIPMAP_LINEAR 0x2703 +#define GL_TEXTURE_MAG_FILTER 0x2800 +#define GL_TEXTURE_MIN_FILTER 0x2801 +#define GL_TEXTURE_WRAP_S 0x2802 +#define GL_TEXTURE_WRAP_T 0x2803 +#define GL_REPEAT 0x2901 +#define GL_CURRENT_BIT 0x00000001 +#define GL_POINT_BIT 0x00000002 +#define GL_LINE_BIT 0x00000004 +#define GL_POLYGON_BIT 0x00000008 +#define GL_POLYGON_STIPPLE_BIT 0x00000010 +#define GL_PIXEL_MODE_BIT 0x00000020 +#define GL_LIGHTING_BIT 0x00000040 +#define GL_FOG_BIT 0x00000080 +#define GL_ACCUM_BUFFER_BIT 0x00000200 +#define GL_VIEWPORT_BIT 0x00000800 +#define GL_TRANSFORM_BIT 0x00001000 +#define GL_ENABLE_BIT 0x00002000 +#define GL_HINT_BIT 0x00008000 +#define GL_EVAL_BIT 0x00010000 +#define GL_LIST_BIT 0x00020000 +#define GL_TEXTURE_BIT 0x00040000 +#define GL_SCISSOR_BIT 0x00080000 +#define GL_ALL_ATTRIB_BITS 0xFFFFFFFF +#define GL_QUAD_STRIP 0x0008 +#define GL_POLYGON 0x0009 +#define GL_ACCUM 0x0100 +#define GL_LOAD 0x0101 +#define GL_RETURN 0x0102 +#define GL_MULT 0x0103 +#define GL_ADD 0x0104 +#define GL_AUX0 0x0409 +#define GL_AUX1 0x040A +#define GL_AUX2 0x040B +#define GL_AUX3 0x040C +#define GL_2D 0x0600 +#define GL_3D 0x0601 +#define GL_3D_COLOR 0x0602 +#define GL_3D_COLOR_TEXTURE 0x0603 +#define GL_4D_COLOR_TEXTURE 0x0604 +#define GL_PASS_THROUGH_TOKEN 0x0700 +#define GL_POINT_TOKEN 0x0701 +#define GL_LINE_TOKEN 0x0702 +#define GL_POLYGON_TOKEN 0x0703 +#define GL_BITMAP_TOKEN 0x0704 +#define GL_DRAW_PIXEL_TOKEN 0x0705 +#define GL_COPY_PIXEL_TOKEN 0x0706 +#define GL_LINE_RESET_TOKEN 0x0707 +#define GL_EXP 0x0800 +#define GL_EXP2 0x0801 +#define GL_COEFF 0x0A00 +#define GL_ORDER 0x0A01 +#define GL_DOMAIN 0x0A02 +#define GL_PIXEL_MAP_I_TO_I 0x0C70 +#define GL_PIXEL_MAP_S_TO_S 0x0C71 +#define GL_PIXEL_MAP_I_TO_R 0x0C72 +#define GL_PIXEL_MAP_I_TO_G 0x0C73 +#define GL_PIXEL_MAP_I_TO_B 0x0C74 +#define GL_PIXEL_MAP_I_TO_A 0x0C75 +#define GL_PIXEL_MAP_R_TO_R 0x0C76 +#define GL_PIXEL_MAP_G_TO_G 0x0C77 +#define GL_PIXEL_MAP_B_TO_B 0x0C78 +#define GL_PIXEL_MAP_A_TO_A 0x0C79 +#define GL_CURRENT_COLOR 0x0B00 +#define GL_CURRENT_INDEX 0x0B01 +#define GL_CURRENT_NORMAL 0x0B02 +#define GL_CURRENT_TEXTURE_COORDS 0x0B03 +#define GL_CURRENT_RASTER_COLOR 0x0B04 +#define GL_CURRENT_RASTER_INDEX 0x0B05 +#define GL_CURRENT_RASTER_TEXTURE_COORDS 0x0B06 +#define GL_CURRENT_RASTER_POSITION 0x0B07 +#define GL_CURRENT_RASTER_POSITION_VALID 0x0B08 +#define GL_CURRENT_RASTER_DISTANCE 0x0B09 +#define GL_POINT_SMOOTH 0x0B10 +#define GL_LINE_STIPPLE 0x0B24 +#define GL_LINE_STIPPLE_PATTERN 0x0B25 +#define GL_LINE_STIPPLE_REPEAT 0x0B26 +#define GL_LIST_MODE 0x0B30 +#define GL_MAX_LIST_NESTING 0x0B31 +#define GL_LIST_BASE 0x0B32 +#define GL_LIST_INDEX 0x0B33 +#define GL_POLYGON_STIPPLE 0x0B42 +#define GL_EDGE_FLAG 0x0B43 +#define GL_LIGHTING 0x0B50 +#define GL_LIGHT_MODEL_LOCAL_VIEWER 0x0B51 +#define GL_LIGHT_MODEL_TWO_SIDE 0x0B52 +#define GL_LIGHT_MODEL_AMBIENT 0x0B53 +#define GL_SHADE_MODEL 0x0B54 +#define GL_COLOR_MATERIAL_FACE 0x0B55 +#define GL_COLOR_MATERIAL_PARAMETER 0x0B56 +#define GL_COLOR_MATERIAL 0x0B57 +#define GL_FOG 0x0B60 +#define GL_FOG_INDEX 0x0B61 +#define GL_FOG_DENSITY 0x0B62 +#define GL_FOG_START 0x0B63 +#define GL_FOG_END 0x0B64 +#define GL_FOG_MODE 0x0B65 +#define GL_FOG_COLOR 0x0B66 +#define GL_ACCUM_CLEAR_VALUE 0x0B80 +#define GL_MATRIX_MODE 0x0BA0 +#define GL_NORMALIZE 0x0BA1 +#define GL_MODELVIEW_STACK_DEPTH 0x0BA3 +#define GL_PROJECTION_STACK_DEPTH 0x0BA4 +#define GL_TEXTURE_STACK_DEPTH 0x0BA5 +#define GL_MODELVIEW_MATRIX 0x0BA6 +#define GL_PROJECTION_MATRIX 0x0BA7 +#define GL_TEXTURE_MATRIX 0x0BA8 +#define GL_ATTRIB_STACK_DEPTH 0x0BB0 +#define GL_ALPHA_TEST 0x0BC0 +#define GL_ALPHA_TEST_FUNC 0x0BC1 +#define GL_ALPHA_TEST_REF 0x0BC2 +#define GL_LOGIC_OP 0x0BF1 +#define GL_AUX_BUFFERS 0x0C00 +#define GL_INDEX_CLEAR_VALUE 0x0C20 +#define GL_INDEX_WRITEMASK 0x0C21 +#define GL_INDEX_MODE 0x0C30 +#define GL_RGBA_MODE 0x0C31 +#define GL_RENDER_MODE 0x0C40 +#define GL_PERSPECTIVE_CORRECTION_HINT 0x0C50 +#define GL_POINT_SMOOTH_HINT 0x0C51 +#define GL_FOG_HINT 0x0C54 +#define GL_TEXTURE_GEN_S 0x0C60 +#define GL_TEXTURE_GEN_T 0x0C61 +#define GL_TEXTURE_GEN_R 0x0C62 +#define GL_TEXTURE_GEN_Q 0x0C63 +#define GL_PIXEL_MAP_I_TO_I_SIZE 0x0CB0 +#define GL_PIXEL_MAP_S_TO_S_SIZE 0x0CB1 +#define GL_PIXEL_MAP_I_TO_R_SIZE 0x0CB2 +#define GL_PIXEL_MAP_I_TO_G_SIZE 0x0CB3 +#define GL_PIXEL_MAP_I_TO_B_SIZE 0x0CB4 +#define GL_PIXEL_MAP_I_TO_A_SIZE 0x0CB5 +#define GL_PIXEL_MAP_R_TO_R_SIZE 0x0CB6 +#define GL_PIXEL_MAP_G_TO_G_SIZE 0x0CB7 +#define GL_PIXEL_MAP_B_TO_B_SIZE 0x0CB8 +#define GL_PIXEL_MAP_A_TO_A_SIZE 0x0CB9 +#define GL_MAP_COLOR 0x0D10 +#define GL_MAP_STENCIL 0x0D11 +#define GL_INDEX_SHIFT 0x0D12 +#define GL_INDEX_OFFSET 0x0D13 +#define GL_RED_SCALE 0x0D14 +#define GL_RED_BIAS 0x0D15 +#define GL_ZOOM_X 0x0D16 +#define GL_ZOOM_Y 0x0D17 +#define GL_GREEN_SCALE 0x0D18 +#define GL_GREEN_BIAS 0x0D19 +#define GL_BLUE_SCALE 0x0D1A +#define GL_BLUE_BIAS 0x0D1B +#define GL_ALPHA_SCALE 0x0D1C +#define GL_ALPHA_BIAS 0x0D1D +#define GL_DEPTH_SCALE 0x0D1E +#define GL_DEPTH_BIAS 0x0D1F +#define GL_MAX_EVAL_ORDER 0x0D30 +#define GL_MAX_LIGHTS 0x0D31 +#define GL_MAX_CLIP_PLANES 0x0D32 +#define GL_MAX_PIXEL_MAP_TABLE 0x0D34 +#define GL_MAX_ATTRIB_STACK_DEPTH 0x0D35 +#define GL_MAX_MODELVIEW_STACK_DEPTH 0x0D36 +#define GL_MAX_NAME_STACK_DEPTH 0x0D37 +#define GL_MAX_PROJECTION_STACK_DEPTH 0x0D38 +#define GL_MAX_TEXTURE_STACK_DEPTH 0x0D39 +#define GL_INDEX_BITS 0x0D51 +#define GL_RED_BITS 0x0D52 +#define GL_GREEN_BITS 0x0D53 +#define GL_BLUE_BITS 0x0D54 +#define GL_ALPHA_BITS 0x0D55 +#define GL_DEPTH_BITS 0x0D56 +#define GL_STENCIL_BITS 0x0D57 +#define GL_ACCUM_RED_BITS 0x0D58 +#define GL_ACCUM_GREEN_BITS 0x0D59 +#define GL_ACCUM_BLUE_BITS 0x0D5A +#define GL_ACCUM_ALPHA_BITS 0x0D5B +#define GL_NAME_STACK_DEPTH 0x0D70 +#define GL_AUTO_NORMAL 0x0D80 +#define GL_MAP1_COLOR_4 0x0D90 +#define GL_MAP1_INDEX 0x0D91 +#define GL_MAP1_NORMAL 0x0D92 +#define GL_MAP1_TEXTURE_COORD_1 0x0D93 +#define GL_MAP1_TEXTURE_COORD_2 0x0D94 +#define GL_MAP1_TEXTURE_COORD_3 0x0D95 +#define GL_MAP1_TEXTURE_COORD_4 0x0D96 +#define GL_MAP1_VERTEX_3 0x0D97 +#define GL_MAP1_VERTEX_4 0x0D98 +#define GL_MAP2_COLOR_4 0x0DB0 +#define GL_MAP2_INDEX 0x0DB1 +#define GL_MAP2_NORMAL 0x0DB2 +#define GL_MAP2_TEXTURE_COORD_1 0x0DB3 +#define GL_MAP2_TEXTURE_COORD_2 0x0DB4 +#define GL_MAP2_TEXTURE_COORD_3 0x0DB5 +#define GL_MAP2_TEXTURE_COORD_4 0x0DB6 +#define GL_MAP2_VERTEX_3 0x0DB7 +#define GL_MAP2_VERTEX_4 0x0DB8 +#define GL_MAP1_GRID_DOMAIN 0x0DD0 +#define GL_MAP1_GRID_SEGMENTS 0x0DD1 +#define GL_MAP2_GRID_DOMAIN 0x0DD2 +#define GL_MAP2_GRID_SEGMENTS 0x0DD3 +#define GL_TEXTURE_COMPONENTS 0x1003 +#define GL_TEXTURE_BORDER 0x1005 +#define GL_AMBIENT 0x1200 +#define GL_DIFFUSE 0x1201 +#define GL_SPECULAR 0x1202 +#define GL_POSITION 0x1203 +#define GL_SPOT_DIRECTION 0x1204 +#define GL_SPOT_EXPONENT 0x1205 +#define GL_SPOT_CUTOFF 0x1206 +#define GL_CONSTANT_ATTENUATION 0x1207 +#define GL_LINEAR_ATTENUATION 0x1208 +#define GL_QUADRATIC_ATTENUATION 0x1209 +#define GL_COMPILE 0x1300 +#define GL_COMPILE_AND_EXECUTE 0x1301 +#define GL_2_BYTES 0x1407 +#define GL_3_BYTES 0x1408 +#define GL_4_BYTES 0x1409 +#define GL_EMISSION 0x1600 +#define GL_SHININESS 0x1601 +#define GL_AMBIENT_AND_DIFFUSE 0x1602 +#define GL_COLOR_INDEXES 0x1603 +#define GL_MODELVIEW 0x1700 +#define GL_PROJECTION 0x1701 +#define GL_COLOR_INDEX 0x1900 +#define GL_LUMINANCE 0x1909 +#define GL_LUMINANCE_ALPHA 0x190A +#define GL_BITMAP 0x1A00 +#define GL_RENDER 0x1C00 +#define GL_FEEDBACK 0x1C01 +#define GL_SELECT 0x1C02 +#define GL_FLAT 0x1D00 +#define GL_SMOOTH 0x1D01 +#define GL_S 0x2000 +#define GL_T 0x2001 +#define GL_R 0x2002 +#define GL_Q 0x2003 +#define GL_MODULATE 0x2100 +#define GL_DECAL 0x2101 +#define GL_TEXTURE_ENV_MODE 0x2200 +#define GL_TEXTURE_ENV_COLOR 0x2201 +#define GL_TEXTURE_ENV 0x2300 +#define GL_EYE_LINEAR 0x2400 +#define GL_OBJECT_LINEAR 0x2401 +#define GL_SPHERE_MAP 0x2402 +#define GL_TEXTURE_GEN_MODE 0x2500 +#define GL_OBJECT_PLANE 0x2501 +#define GL_EYE_PLANE 0x2502 +#define GL_CLAMP 0x2900 +#define GL_CLIP_PLANE0 0x3000 +#define GL_CLIP_PLANE1 0x3001 +#define GL_CLIP_PLANE2 0x3002 +#define GL_CLIP_PLANE3 0x3003 +#define GL_CLIP_PLANE4 0x3004 +#define GL_CLIP_PLANE5 0x3005 +#define GL_LIGHT0 0x4000 +#define GL_LIGHT1 0x4001 +#define GL_LIGHT2 0x4002 +#define GL_LIGHT3 0x4003 +#define GL_LIGHT4 0x4004 +#define GL_LIGHT5 0x4005 +#define GL_LIGHT6 0x4006 +#define GL_LIGHT7 0x4007 +#define GL_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_CLIENT_PIXEL_STORE_BIT 0x00000001 +#define GL_CLIENT_VERTEX_ARRAY_BIT 0x00000002 +#define GL_CLIENT_ALL_ATTRIB_BITS 0xFFFFFFFF +#define GL_VERTEX_ARRAY_POINTER 0x808E +#define GL_NORMAL_ARRAY_POINTER 0x808F +#define GL_COLOR_ARRAY_POINTER 0x8090 +#define GL_INDEX_ARRAY_POINTER 0x8091 +#define GL_TEXTURE_COORD_ARRAY_POINTER 0x8092 +#define GL_EDGE_FLAG_ARRAY_POINTER 0x8093 +#define GL_FEEDBACK_BUFFER_POINTER 0x0DF0 +#define GL_SELECTION_BUFFER_POINTER 0x0DF3 +#define GL_CLIENT_ATTRIB_STACK_DEPTH 0x0BB1 +#define GL_INDEX_LOGIC_OP 0x0BF1 +#define GL_MAX_CLIENT_ATTRIB_STACK_DEPTH 0x0D3B +#define GL_FEEDBACK_BUFFER_SIZE 0x0DF1 +#define GL_FEEDBACK_BUFFER_TYPE 0x0DF2 +#define GL_SELECTION_BUFFER_SIZE 0x0DF4 +#define GL_VERTEX_ARRAY 0x8074 +#define GL_NORMAL_ARRAY 0x8075 +#define GL_COLOR_ARRAY 0x8076 +#define GL_INDEX_ARRAY 0x8077 +#define GL_TEXTURE_COORD_ARRAY 0x8078 +#define GL_EDGE_FLAG_ARRAY 0x8079 +#define GL_VERTEX_ARRAY_SIZE 0x807A +#define GL_VERTEX_ARRAY_TYPE 0x807B +#define GL_VERTEX_ARRAY_STRIDE 0x807C +#define GL_NORMAL_ARRAY_TYPE 0x807E +#define GL_NORMAL_ARRAY_STRIDE 0x807F +#define GL_COLOR_ARRAY_SIZE 0x8081 +#define GL_COLOR_ARRAY_TYPE 0x8082 +#define GL_COLOR_ARRAY_STRIDE 0x8083 +#define GL_INDEX_ARRAY_TYPE 0x8085 +#define GL_INDEX_ARRAY_STRIDE 0x8086 +#define GL_TEXTURE_COORD_ARRAY_SIZE 0x8088 +#define GL_TEXTURE_COORD_ARRAY_TYPE 0x8089 +#define GL_TEXTURE_COORD_ARRAY_STRIDE 0x808A +#define GL_EDGE_FLAG_ARRAY_STRIDE 0x808C +#define GL_TEXTURE_LUMINANCE_SIZE 0x8060 +#define GL_TEXTURE_INTENSITY_SIZE 0x8061 +#define GL_TEXTURE_PRIORITY 0x8066 +#define GL_TEXTURE_RESIDENT 0x8067 +#define GL_ALPHA4 0x803B +#define GL_ALPHA8 0x803C +#define GL_ALPHA12 0x803D +#define GL_ALPHA16 0x803E +#define GL_LUMINANCE4 0x803F +#define GL_LUMINANCE8 0x8040 +#define GL_LUMINANCE12 0x8041 +#define GL_LUMINANCE16 0x8042 +#define GL_LUMINANCE4_ALPHA4 0x8043 +#define GL_LUMINANCE6_ALPHA2 0x8044 +#define GL_LUMINANCE8_ALPHA8 0x8045 +#define GL_LUMINANCE12_ALPHA4 0x8046 +#define GL_LUMINANCE12_ALPHA12 0x8047 +#define GL_LUMINANCE16_ALPHA16 0x8048 +#define GL_INTENSITY 0x8049 +#define GL_INTENSITY4 0x804A +#define GL_INTENSITY8 0x804B +#define GL_INTENSITY12 0x804C +#define GL_INTENSITY16 0x804D +#define GL_V2F 0x2A20 +#define GL_V3F 0x2A21 +#define GL_C4UB_V2F 0x2A22 +#define GL_C4UB_V3F 0x2A23 +#define GL_C3F_V3F 0x2A24 +#define GL_N3F_V3F 0x2A25 +#define GL_C4F_N3F_V3F 0x2A26 +#define GL_T2F_V3F 0x2A27 +#define GL_T4F_V4F 0x2A28 +#define GL_T2F_C4UB_V3F 0x2A29 +#define GL_T2F_C3F_V3F 0x2A2A +#define GL_T2F_N3F_V3F 0x2A2B +#define GL_T2F_C4F_N3F_V3F 0x2A2C +#define GL_T4F_C4F_N3F_V4F 0x2A2D +#define GL_UNSIGNED_BYTE_3_3_2 0x8032 +#define GL_UNSIGNED_SHORT_4_4_4_4 0x8033 +#define GL_UNSIGNED_SHORT_5_5_5_1 0x8034 +#define GL_UNSIGNED_INT_8_8_8_8 0x8035 +#define GL_UNSIGNED_INT_10_10_10_2 0x8036 +#define GL_TEXTURE_BINDING_3D 0x806A +#define GL_PACK_SKIP_IMAGES 0x806B +#define GL_PACK_IMAGE_HEIGHT 0x806C +#define GL_UNPACK_SKIP_IMAGES 0x806D +#define GL_UNPACK_IMAGE_HEIGHT 0x806E +#define GL_TEXTURE_3D 0x806F +#define GL_PROXY_TEXTURE_3D 0x8070 +#define GL_TEXTURE_DEPTH 0x8071 +#define GL_TEXTURE_WRAP_R 0x8072 +#define GL_MAX_3D_TEXTURE_SIZE 0x8073 +#define GL_UNSIGNED_BYTE_2_3_3_REV 0x8362 +#define GL_UNSIGNED_SHORT_5_6_5 0x8363 +#define GL_UNSIGNED_SHORT_5_6_5_REV 0x8364 +#define GL_UNSIGNED_SHORT_4_4_4_4_REV 0x8365 +#define GL_UNSIGNED_SHORT_1_5_5_5_REV 0x8366 +#define GL_UNSIGNED_INT_8_8_8_8_REV 0x8367 +#define GL_UNSIGNED_INT_2_10_10_10_REV 0x8368 +#define GL_BGR 0x80E0 +#define GL_BGRA 0x80E1 +#define GL_MAX_ELEMENTS_VERTICES 0x80E8 +#define GL_MAX_ELEMENTS_INDICES 0x80E9 +#define GL_CLAMP_TO_EDGE 0x812F +#define GL_TEXTURE_MIN_LOD 0x813A +#define GL_TEXTURE_MAX_LOD 0x813B +#define GL_TEXTURE_BASE_LEVEL 0x813C +#define GL_TEXTURE_MAX_LEVEL 0x813D +#define GL_SMOOTH_POINT_SIZE_RANGE 0x0B12 +#define GL_SMOOTH_POINT_SIZE_GRANULARITY 0x0B13 +#define GL_SMOOTH_LINE_WIDTH_RANGE 0x0B22 +#define GL_SMOOTH_LINE_WIDTH_GRANULARITY 0x0B23 +#define GL_ALIASED_LINE_WIDTH_RANGE 0x846E +#define GL_RESCALE_NORMAL 0x803A +#define GL_LIGHT_MODEL_COLOR_CONTROL 0x81F8 +#define GL_SINGLE_COLOR 0x81F9 +#define GL_SEPARATE_SPECULAR_COLOR 0x81FA +#define GL_ALIASED_POINT_SIZE_RANGE 0x846D +#define GL_TEXTURE0 0x84C0 +#define GL_TEXTURE1 0x84C1 +#define GL_TEXTURE2 0x84C2 +#define GL_TEXTURE3 0x84C3 +#define GL_TEXTURE4 0x84C4 +#define GL_TEXTURE5 0x84C5 +#define GL_TEXTURE6 0x84C6 +#define GL_TEXTURE7 0x84C7 +#define GL_TEXTURE8 0x84C8 +#define GL_TEXTURE9 0x84C9 +#define GL_TEXTURE10 0x84CA +#define GL_TEXTURE11 0x84CB +#define GL_TEXTURE12 0x84CC +#define GL_TEXTURE13 0x84CD +#define GL_TEXTURE14 0x84CE +#define GL_TEXTURE15 0x84CF +#define GL_TEXTURE16 0x84D0 +#define GL_TEXTURE17 0x84D1 +#define GL_TEXTURE18 0x84D2 +#define GL_TEXTURE19 0x84D3 +#define GL_TEXTURE20 0x84D4 +#define GL_TEXTURE21 0x84D5 +#define GL_TEXTURE22 0x84D6 +#define GL_TEXTURE23 0x84D7 +#define GL_TEXTURE24 0x84D8 +#define GL_TEXTURE25 0x84D9 +#define GL_TEXTURE26 0x84DA +#define GL_TEXTURE27 0x84DB +#define GL_TEXTURE28 0x84DC +#define GL_TEXTURE29 0x84DD +#define GL_TEXTURE30 0x84DE +#define GL_TEXTURE31 0x84DF +#define GL_ACTIVE_TEXTURE 0x84E0 +#define GL_MULTISAMPLE 0x809D +#define GL_SAMPLE_ALPHA_TO_COVERAGE 0x809E +#define GL_SAMPLE_ALPHA_TO_ONE 0x809F +#define GL_SAMPLE_COVERAGE 0x80A0 +#define GL_SAMPLE_BUFFERS 0x80A8 +#define GL_SAMPLES 0x80A9 +#define GL_SAMPLE_COVERAGE_VALUE 0x80AA +#define GL_SAMPLE_COVERAGE_INVERT 0x80AB +#define GL_TEXTURE_CUBE_MAP 0x8513 +#define GL_TEXTURE_BINDING_CUBE_MAP 0x8514 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_X 0x8515 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_X 0x8516 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_Y 0x8517 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y 0x8518 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_Z 0x8519 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z 0x851A +#define GL_PROXY_TEXTURE_CUBE_MAP 0x851B +#define GL_MAX_CUBE_MAP_TEXTURE_SIZE 0x851C +#define GL_COMPRESSED_RGB 0x84ED +#define GL_COMPRESSED_RGBA 0x84EE +#define GL_TEXTURE_COMPRESSION_HINT 0x84EF +#define GL_TEXTURE_COMPRESSED_IMAGE_SIZE 0x86A0 +#define GL_TEXTURE_COMPRESSED 0x86A1 +#define GL_NUM_COMPRESSED_TEXTURE_FORMATS 0x86A2 +#define GL_COMPRESSED_TEXTURE_FORMATS 0x86A3 +#define GL_CLAMP_TO_BORDER 0x812D +#define GL_CLIENT_ACTIVE_TEXTURE 0x84E1 +#define GL_MAX_TEXTURE_UNITS 0x84E2 +#define GL_TRANSPOSE_MODELVIEW_MATRIX 0x84E3 +#define GL_TRANSPOSE_PROJECTION_MATRIX 0x84E4 +#define GL_TRANSPOSE_TEXTURE_MATRIX 0x84E5 +#define GL_TRANSPOSE_COLOR_MATRIX 0x84E6 +#define GL_MULTISAMPLE_BIT 0x20000000 +#define GL_NORMAL_MAP 0x8511 +#define GL_REFLECTION_MAP 0x8512 +#define GL_COMPRESSED_ALPHA 0x84E9 +#define GL_COMPRESSED_LUMINANCE 0x84EA +#define GL_COMPRESSED_LUMINANCE_ALPHA 0x84EB +#define GL_COMPRESSED_INTENSITY 0x84EC +#define GL_COMBINE 0x8570 +#define GL_COMBINE_RGB 0x8571 +#define GL_COMBINE_ALPHA 0x8572 +#define GL_SOURCE0_RGB 0x8580 +#define GL_SOURCE1_RGB 0x8581 +#define GL_SOURCE2_RGB 0x8582 +#define GL_SOURCE0_ALPHA 0x8588 +#define GL_SOURCE1_ALPHA 0x8589 +#define GL_SOURCE2_ALPHA 0x858A +#define GL_OPERAND0_RGB 0x8590 +#define GL_OPERAND1_RGB 0x8591 +#define GL_OPERAND2_RGB 0x8592 +#define GL_OPERAND0_ALPHA 0x8598 +#define GL_OPERAND1_ALPHA 0x8599 +#define GL_OPERAND2_ALPHA 0x859A +#define GL_RGB_SCALE 0x8573 +#define GL_ADD_SIGNED 0x8574 +#define GL_INTERPOLATE 0x8575 +#define GL_SUBTRACT 0x84E7 +#define GL_CONSTANT 0x8576 +#define GL_PRIMARY_COLOR 0x8577 +#define GL_PREVIOUS 0x8578 +#define GL_DOT3_RGB 0x86AE +#define GL_DOT3_RGBA 0x86AF +#define GL_BLEND_DST_RGB 0x80C8 +#define GL_BLEND_SRC_RGB 0x80C9 +#define GL_BLEND_DST_ALPHA 0x80CA +#define GL_BLEND_SRC_ALPHA 0x80CB +#define GL_POINT_FADE_THRESHOLD_SIZE 0x8128 +#define GL_DEPTH_COMPONENT16 0x81A5 +#define GL_DEPTH_COMPONENT24 0x81A6 +#define GL_DEPTH_COMPONENT32 0x81A7 +#define GL_MIRRORED_REPEAT 0x8370 +#define GL_MAX_TEXTURE_LOD_BIAS 0x84FD +#define GL_TEXTURE_LOD_BIAS 0x8501 +#define GL_INCR_WRAP 0x8507 +#define GL_DECR_WRAP 0x8508 +#define GL_TEXTURE_DEPTH_SIZE 0x884A +#define GL_TEXTURE_COMPARE_MODE 0x884C +#define GL_TEXTURE_COMPARE_FUNC 0x884D +#define GL_POINT_SIZE_MIN 0x8126 +#define GL_POINT_SIZE_MAX 0x8127 +#define GL_POINT_DISTANCE_ATTENUATION 0x8129 +#define GL_GENERATE_MIPMAP 0x8191 +#define GL_GENERATE_MIPMAP_HINT 0x8192 +#define GL_FOG_COORDINATE_SOURCE 0x8450 +#define GL_FOG_COORDINATE 0x8451 +#define GL_FRAGMENT_DEPTH 0x8452 +#define GL_CURRENT_FOG_COORDINATE 0x8453 +#define GL_FOG_COORDINATE_ARRAY_TYPE 0x8454 +#define GL_FOG_COORDINATE_ARRAY_STRIDE 0x8455 +#define GL_FOG_COORDINATE_ARRAY_POINTER 0x8456 +#define GL_FOG_COORDINATE_ARRAY 0x8457 +#define GL_COLOR_SUM 0x8458 +#define GL_CURRENT_SECONDARY_COLOR 0x8459 +#define GL_SECONDARY_COLOR_ARRAY_SIZE 0x845A +#define GL_SECONDARY_COLOR_ARRAY_TYPE 0x845B +#define GL_SECONDARY_COLOR_ARRAY_STRIDE 0x845C +#define GL_SECONDARY_COLOR_ARRAY_POINTER 0x845D +#define GL_SECONDARY_COLOR_ARRAY 0x845E +#define GL_TEXTURE_FILTER_CONTROL 0x8500 +#define GL_DEPTH_TEXTURE_MODE 0x884B +#define GL_COMPARE_R_TO_TEXTURE 0x884E +#define GL_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_VERTEX_ARRAY_BUFFER_BINDING 0x8896 +#define GL_NORMAL_ARRAY_BUFFER_BINDING 0x8897 +#define GL_COLOR_ARRAY_BUFFER_BINDING 0x8898 +#define GL_INDEX_ARRAY_BUFFER_BINDING 0x8899 +#define GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING 0x889A +#define GL_EDGE_FLAG_ARRAY_BUFFER_BINDING 0x889B +#define GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING 0x889C +#define GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING 0x889D +#define GL_WEIGHT_ARRAY_BUFFER_BINDING 0x889E +#define GL_FOG_COORD_SRC 0x8450 +#define GL_FOG_COORD 0x8451 +#define GL_CURRENT_FOG_COORD 0x8453 +#define GL_FOG_COORD_ARRAY_TYPE 0x8454 +#define GL_FOG_COORD_ARRAY_STRIDE 0x8455 +#define GL_FOG_COORD_ARRAY_POINTER 0x8456 +#define GL_FOG_COORD_ARRAY 0x8457 +#define GL_FOG_COORD_ARRAY_BUFFER_BINDING 0x889D +#define GL_SRC0_RGB 0x8580 +#define GL_SRC1_RGB 0x8581 +#define GL_SRC2_RGB 0x8582 +#define GL_SRC0_ALPHA 0x8588 +#define GL_SRC2_ALPHA 0x858A +#define GL_BLEND_EQUATION_RGB 0x8009 +#define GL_VERTEX_ATTRIB_ARRAY_ENABLED 0x8622 +#define GL_VERTEX_ATTRIB_ARRAY_SIZE 0x8623 +#define GL_VERTEX_ATTRIB_ARRAY_STRIDE 0x8624 +#define GL_VERTEX_ATTRIB_ARRAY_TYPE 0x8625 +#define GL_CURRENT_VERTEX_ATTRIB 0x8626 +#define GL_VERTEX_PROGRAM_POINT_SIZE 0x8642 +#define GL_VERTEX_ATTRIB_ARRAY_POINTER 0x8645 +#define GL_STENCIL_BACK_FUNC 0x8800 +#define GL_STENCIL_BACK_FAIL 0x8801 +#define GL_STENCIL_BACK_PASS_DEPTH_FAIL 0x8802 +#define GL_STENCIL_BACK_PASS_DEPTH_PASS 0x8803 +#define GL_MAX_DRAW_BUFFERS 0x8824 +#define GL_DRAW_BUFFER0 0x8825 +#define GL_DRAW_BUFFER1 0x8826 +#define GL_DRAW_BUFFER2 0x8827 +#define GL_DRAW_BUFFER3 0x8828 +#define GL_DRAW_BUFFER4 0x8829 +#define GL_DRAW_BUFFER5 0x882A +#define GL_DRAW_BUFFER6 0x882B +#define GL_DRAW_BUFFER7 0x882C +#define GL_DRAW_BUFFER8 0x882D +#define GL_DRAW_BUFFER9 0x882E +#define GL_DRAW_BUFFER10 0x882F +#define GL_DRAW_BUFFER11 0x8830 +#define GL_DRAW_BUFFER12 0x8831 +#define GL_DRAW_BUFFER13 0x8832 +#define GL_DRAW_BUFFER14 0x8833 +#define GL_DRAW_BUFFER15 0x8834 +#define GL_BLEND_EQUATION_ALPHA 0x883D +#define GL_MAX_VERTEX_ATTRIBS 0x8869 +#define GL_VERTEX_ATTRIB_ARRAY_NORMALIZED 0x886A +#define GL_MAX_TEXTURE_IMAGE_UNITS 0x8872 +#define GL_FRAGMENT_SHADER 0x8B30 +#define GL_VERTEX_SHADER 0x8B31 +#define GL_MAX_FRAGMENT_UNIFORM_COMPONENTS 0x8B49 +#define GL_MAX_VERTEX_UNIFORM_COMPONENTS 0x8B4A +#define GL_MAX_VARYING_FLOATS 0x8B4B +#define GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS 0x8B4C +#define GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS 0x8B4D +#define GL_SHADER_TYPE 0x8B4F +#define GL_FLOAT_VEC2 0x8B50 +#define GL_FLOAT_VEC3 0x8B51 +#define GL_FLOAT_VEC4 0x8B52 +#define GL_INT_VEC2 0x8B53 +#define GL_INT_VEC3 0x8B54 +#define GL_INT_VEC4 0x8B55 +#define GL_BOOL 0x8B56 +#define GL_BOOL_VEC2 0x8B57 +#define GL_BOOL_VEC3 0x8B58 +#define GL_BOOL_VEC4 0x8B59 +#define GL_FLOAT_MAT2 0x8B5A +#define GL_FLOAT_MAT3 0x8B5B +#define GL_FLOAT_MAT4 0x8B5C +#define GL_SAMPLER_1D 0x8B5D +#define GL_SAMPLER_2D 0x8B5E +#define GL_SAMPLER_3D 0x8B5F +#define GL_SAMPLER_CUBE 0x8B60 +#define GL_SAMPLER_1D_SHADOW 0x8B61 +#define GL_SAMPLER_2D_SHADOW 0x8B62 +#define GL_DELETE_STATUS 0x8B80 +#define GL_COMPILE_STATUS 0x8B81 +#define GL_LINK_STATUS 0x8B82 +#define GL_VALIDATE_STATUS 0x8B83 +#define GL_INFO_LOG_LENGTH 0x8B84 +#define GL_ATTACHED_SHADERS 0x8B85 +#define GL_ACTIVE_UNIFORMS 0x8B86 +#define GL_ACTIVE_UNIFORM_MAX_LENGTH 0x8B87 +#define GL_SHADER_SOURCE_LENGTH 0x8B88 +#define GL_ACTIVE_ATTRIBUTES 0x8B89 +#define GL_ACTIVE_ATTRIBUTE_MAX_LENGTH 0x8B8A +#define GL_FRAGMENT_SHADER_DERIVATIVE_HINT 0x8B8B +#define GL_SHADING_LANGUAGE_VERSION 0x8B8C +#define GL_CURRENT_PROGRAM 0x8B8D +#define GL_POINT_SPRITE_COORD_ORIGIN 0x8CA0 +#define GL_LOWER_LEFT 0x8CA1 +#define GL_UPPER_LEFT 0x8CA2 +#define GL_STENCIL_BACK_REF 0x8CA3 +#define GL_STENCIL_BACK_VALUE_MASK 0x8CA4 +#define GL_STENCIL_BACK_WRITEMASK 0x8CA5 +#define GL_VERTEX_PROGRAM_TWO_SIDE 0x8643 +#define GL_POINT_SPRITE 0x8861 +#define GL_COORD_REPLACE 0x8862 +#define GL_MAX_TEXTURE_COORDS 0x8871 +#define GL_PIXEL_PACK_BUFFER 0x88EB +#define GL_PIXEL_UNPACK_BUFFER 0x88EC +#define GL_PIXEL_PACK_BUFFER_BINDING 0x88ED +#define GL_PIXEL_UNPACK_BUFFER_BINDING 0x88EF +#define GL_FLOAT_MAT2x3 0x8B65 +#define GL_FLOAT_MAT2x4 0x8B66 +#define GL_FLOAT_MAT3x2 0x8B67 +#define GL_FLOAT_MAT3x4 0x8B68 +#define GL_FLOAT_MAT4x2 0x8B69 +#define GL_FLOAT_MAT4x3 0x8B6A +#define GL_SRGB 0x8C40 +#define GL_SRGB8 0x8C41 +#define GL_SRGB_ALPHA 0x8C42 +#define GL_SRGB8_ALPHA8 0x8C43 +#define GL_COMPRESSED_SRGB 0x8C48 +#define GL_COMPRESSED_SRGB_ALPHA 0x8C49 +#define GL_CURRENT_RASTER_SECONDARY_COLOR 0x845F +#define GL_SLUMINANCE_ALPHA 0x8C44 +#define GL_SLUMINANCE8_ALPHA8 0x8C45 +#define GL_SLUMINANCE 0x8C46 +#define GL_SLUMINANCE8 0x8C47 +#define GL_COMPRESSED_SLUMINANCE 0x8C4A +#define GL_COMPRESSED_SLUMINANCE_ALPHA 0x8C4B +#define GL_COMPARE_REF_TO_TEXTURE 0x884E +#define GL_CLIP_DISTANCE0 0x3000 +#define GL_CLIP_DISTANCE1 0x3001 +#define GL_CLIP_DISTANCE2 0x3002 +#define GL_CLIP_DISTANCE3 0x3003 +#define GL_CLIP_DISTANCE4 0x3004 +#define GL_CLIP_DISTANCE5 0x3005 +#define GL_CLIP_DISTANCE6 0x3006 +#define GL_CLIP_DISTANCE7 0x3007 +#define GL_MAX_CLIP_DISTANCES 0x0D32 +#define GL_MAJOR_VERSION 0x821B +#define GL_MINOR_VERSION 0x821C +#define GL_NUM_EXTENSIONS 0x821D +#define GL_CONTEXT_FLAGS 0x821E +#define GL_COMPRESSED_RED 0x8225 +#define GL_COMPRESSED_RG 0x8226 +#define GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT 0x00000001 +#define GL_RGBA32F 0x8814 +#define GL_RGB32F 0x8815 +#define GL_RGBA16F 0x881A +#define GL_RGB16F 0x881B +#define GL_VERTEX_ATTRIB_ARRAY_INTEGER 0x88FD +#define GL_MAX_ARRAY_TEXTURE_LAYERS 0x88FF +#define GL_MIN_PROGRAM_TEXEL_OFFSET 0x8904 +#define GL_MAX_PROGRAM_TEXEL_OFFSET 0x8905 +#define GL_CLAMP_READ_COLOR 0x891C +#define GL_FIXED_ONLY 0x891D +#define GL_MAX_VARYING_COMPONENTS 0x8B4B +#define GL_TEXTURE_1D_ARRAY 0x8C18 +#define GL_PROXY_TEXTURE_1D_ARRAY 0x8C19 +#define GL_TEXTURE_2D_ARRAY 0x8C1A +#define GL_PROXY_TEXTURE_2D_ARRAY 0x8C1B +#define GL_TEXTURE_BINDING_1D_ARRAY 0x8C1C +#define GL_TEXTURE_BINDING_2D_ARRAY 0x8C1D +#define GL_R11F_G11F_B10F 0x8C3A +#define GL_UNSIGNED_INT_10F_11F_11F_REV 0x8C3B +#define GL_RGB9_E5 0x8C3D +#define GL_UNSIGNED_INT_5_9_9_9_REV 0x8C3E +#define GL_TEXTURE_SHARED_SIZE 0x8C3F +#define GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH 0x8C76 +#define GL_TRANSFORM_FEEDBACK_BUFFER_MODE 0x8C7F +#define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS 0x8C80 +#define GL_TRANSFORM_FEEDBACK_VARYINGS 0x8C83 +#define GL_TRANSFORM_FEEDBACK_BUFFER_START 0x8C84 +#define GL_TRANSFORM_FEEDBACK_BUFFER_SIZE 0x8C85 +#define GL_PRIMITIVES_GENERATED 0x8C87 +#define GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN 0x8C88 +#define GL_RASTERIZER_DISCARD 0x8C89 +#define GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS 0x8C8A +#define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS 0x8C8B +#define GL_INTERLEAVED_ATTRIBS 0x8C8C +#define GL_SEPARATE_ATTRIBS 0x8C8D +#define GL_TRANSFORM_FEEDBACK_BUFFER 0x8C8E +#define GL_TRANSFORM_FEEDBACK_BUFFER_BINDING 0x8C8F +#define GL_RGBA32UI 0x8D70 +#define GL_RGB32UI 0x8D71 +#define GL_RGBA16UI 0x8D76 +#define GL_RGB16UI 0x8D77 +#define GL_RGBA8UI 0x8D7C +#define GL_RGB8UI 0x8D7D +#define GL_RGBA32I 0x8D82 +#define GL_RGB32I 0x8D83 +#define GL_RGBA16I 0x8D88 +#define GL_RGB16I 0x8D89 +#define GL_RGBA8I 0x8D8E +#define GL_RGB8I 0x8D8F +#define GL_RED_INTEGER 0x8D94 +#define GL_GREEN_INTEGER 0x8D95 +#define GL_BLUE_INTEGER 0x8D96 +#define GL_RGB_INTEGER 0x8D98 +#define GL_RGBA_INTEGER 0x8D99 +#define GL_BGR_INTEGER 0x8D9A +#define GL_BGRA_INTEGER 0x8D9B +#define GL_SAMPLER_1D_ARRAY 0x8DC0 +#define GL_SAMPLER_2D_ARRAY 0x8DC1 +#define GL_SAMPLER_1D_ARRAY_SHADOW 0x8DC3 +#define GL_SAMPLER_2D_ARRAY_SHADOW 0x8DC4 +#define GL_SAMPLER_CUBE_SHADOW 0x8DC5 +#define GL_UNSIGNED_INT_VEC2 0x8DC6 +#define GL_UNSIGNED_INT_VEC3 0x8DC7 +#define GL_UNSIGNED_INT_VEC4 0x8DC8 +#define GL_INT_SAMPLER_1D 0x8DC9 +#define GL_INT_SAMPLER_2D 0x8DCA +#define GL_INT_SAMPLER_3D 0x8DCB +#define GL_INT_SAMPLER_CUBE 0x8DCC +#define GL_INT_SAMPLER_1D_ARRAY 0x8DCE +#define GL_INT_SAMPLER_2D_ARRAY 0x8DCF +#define GL_UNSIGNED_INT_SAMPLER_1D 0x8DD1 +#define GL_UNSIGNED_INT_SAMPLER_2D 0x8DD2 +#define GL_UNSIGNED_INT_SAMPLER_3D 0x8DD3 +#define GL_UNSIGNED_INT_SAMPLER_CUBE 0x8DD4 +#define GL_UNSIGNED_INT_SAMPLER_1D_ARRAY 0x8DD6 +#define GL_UNSIGNED_INT_SAMPLER_2D_ARRAY 0x8DD7 +#define GL_QUERY_WAIT 0x8E13 +#define GL_QUERY_NO_WAIT 0x8E14 +#define GL_QUERY_BY_REGION_WAIT 0x8E15 +#define GL_QUERY_BY_REGION_NO_WAIT 0x8E16 +#define GL_BUFFER_ACCESS_FLAGS 0x911F +#define GL_BUFFER_MAP_LENGTH 0x9120 +#define GL_BUFFER_MAP_OFFSET 0x9121 +#define GL_DEPTH_COMPONENT32F 0x8CAC +#define GL_DEPTH32F_STENCIL8 0x8CAD +#define GL_FLOAT_32_UNSIGNED_INT_24_8_REV 0x8DAD +#define GL_INVALID_FRAMEBUFFER_OPERATION 0x0506 +#define GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING 0x8210 +#define GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE 0x8211 +#define GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE 0x8212 +#define GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE 0x8213 +#define GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE 0x8214 +#define GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE 0x8215 +#define GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE 0x8216 +#define GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE 0x8217 +#define GL_FRAMEBUFFER_DEFAULT 0x8218 +#define GL_FRAMEBUFFER_UNDEFINED 0x8219 +#define GL_DEPTH_STENCIL_ATTACHMENT 0x821A +#define GL_MAX_RENDERBUFFER_SIZE 0x84E8 +#define GL_DEPTH_STENCIL 0x84F9 +#define GL_UNSIGNED_INT_24_8 0x84FA +#define GL_DEPTH24_STENCIL8 0x88F0 +#define GL_TEXTURE_STENCIL_SIZE 0x88F1 +#define GL_TEXTURE_RED_TYPE 0x8C10 +#define GL_TEXTURE_GREEN_TYPE 0x8C11 +#define GL_TEXTURE_BLUE_TYPE 0x8C12 +#define GL_TEXTURE_ALPHA_TYPE 0x8C13 +#define GL_TEXTURE_DEPTH_TYPE 0x8C16 +#define GL_UNSIGNED_NORMALIZED 0x8C17 +#define GL_FRAMEBUFFER_BINDING 0x8CA6 +#define GL_DRAW_FRAMEBUFFER_BINDING 0x8CA6 +#define GL_RENDERBUFFER_BINDING 0x8CA7 +#define GL_READ_FRAMEBUFFER 0x8CA8 +#define GL_DRAW_FRAMEBUFFER 0x8CA9 +#define GL_READ_FRAMEBUFFER_BINDING 0x8CAA +#define GL_RENDERBUFFER_SAMPLES 0x8CAB +#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE 0x8CD0 +#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME 0x8CD1 +#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL 0x8CD2 +#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE 0x8CD3 +#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER 0x8CD4 +#define GL_FRAMEBUFFER_COMPLETE 0x8CD5 +#define GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT 0x8CD6 +#define GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT 0x8CD7 +#define GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER 0x8CDB +#define GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER 0x8CDC +#define GL_FRAMEBUFFER_UNSUPPORTED 0x8CDD +#define GL_MAX_COLOR_ATTACHMENTS 0x8CDF +#define GL_COLOR_ATTACHMENT0 0x8CE0 +#define GL_COLOR_ATTACHMENT1 0x8CE1 +#define GL_COLOR_ATTACHMENT2 0x8CE2 +#define GL_COLOR_ATTACHMENT3 0x8CE3 +#define GL_COLOR_ATTACHMENT4 0x8CE4 +#define GL_COLOR_ATTACHMENT5 0x8CE5 +#define GL_COLOR_ATTACHMENT6 0x8CE6 +#define GL_COLOR_ATTACHMENT7 0x8CE7 +#define GL_COLOR_ATTACHMENT8 0x8CE8 +#define GL_COLOR_ATTACHMENT9 0x8CE9 +#define GL_COLOR_ATTACHMENT10 0x8CEA +#define GL_COLOR_ATTACHMENT11 0x8CEB +#define GL_COLOR_ATTACHMENT12 0x8CEC +#define GL_COLOR_ATTACHMENT13 0x8CED +#define GL_COLOR_ATTACHMENT14 0x8CEE +#define GL_COLOR_ATTACHMENT15 0x8CEF +#define GL_COLOR_ATTACHMENT16 0x8CF0 +#define GL_COLOR_ATTACHMENT17 0x8CF1 +#define GL_COLOR_ATTACHMENT18 0x8CF2 +#define GL_COLOR_ATTACHMENT19 0x8CF3 +#define GL_COLOR_ATTACHMENT20 0x8CF4 +#define GL_COLOR_ATTACHMENT21 0x8CF5 +#define GL_COLOR_ATTACHMENT22 0x8CF6 +#define GL_COLOR_ATTACHMENT23 0x8CF7 +#define GL_COLOR_ATTACHMENT24 0x8CF8 +#define GL_COLOR_ATTACHMENT25 0x8CF9 +#define GL_COLOR_ATTACHMENT26 0x8CFA +#define GL_COLOR_ATTACHMENT27 0x8CFB +#define GL_COLOR_ATTACHMENT28 0x8CFC +#define GL_COLOR_ATTACHMENT29 0x8CFD +#define GL_COLOR_ATTACHMENT30 0x8CFE +#define GL_COLOR_ATTACHMENT31 0x8CFF +#define GL_DEPTH_ATTACHMENT 0x8D00 +#define GL_STENCIL_ATTACHMENT 0x8D20 +#define GL_FRAMEBUFFER 0x8D40 +#define GL_RENDERBUFFER 0x8D41 +#define GL_RENDERBUFFER_WIDTH 0x8D42 +#define GL_RENDERBUFFER_HEIGHT 0x8D43 +#define GL_RENDERBUFFER_INTERNAL_FORMAT 0x8D44 +#define GL_STENCIL_INDEX1 0x8D46 +#define GL_STENCIL_INDEX4 0x8D47 +#define GL_STENCIL_INDEX8 0x8D48 +#define GL_STENCIL_INDEX16 0x8D49 +#define GL_RENDERBUFFER_RED_SIZE 0x8D50 +#define GL_RENDERBUFFER_GREEN_SIZE 0x8D51 +#define GL_RENDERBUFFER_BLUE_SIZE 0x8D52 +#define GL_RENDERBUFFER_ALPHA_SIZE 0x8D53 +#define GL_RENDERBUFFER_DEPTH_SIZE 0x8D54 +#define GL_RENDERBUFFER_STENCIL_SIZE 0x8D55 +#define GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE 0x8D56 +#define GL_MAX_SAMPLES 0x8D57 +#define GL_INDEX 0x8222 +#define GL_TEXTURE_LUMINANCE_TYPE 0x8C14 +#define GL_TEXTURE_INTENSITY_TYPE 0x8C15 +#define GL_FRAMEBUFFER_SRGB 0x8DB9 +#define GL_HALF_FLOAT 0x140B +#define GL_MAP_READ_BIT 0x0001 +#define GL_MAP_WRITE_BIT 0x0002 +#define GL_MAP_INVALIDATE_RANGE_BIT 0x0004 +#define GL_MAP_INVALIDATE_BUFFER_BIT 0x0008 +#define GL_MAP_FLUSH_EXPLICIT_BIT 0x0010 +#define GL_MAP_UNSYNCHRONIZED_BIT 0x0020 +#define GL_COMPRESSED_RED_RGTC1 0x8DBB +#define GL_COMPRESSED_SIGNED_RED_RGTC1 0x8DBC +#define GL_COMPRESSED_RG_RGTC2 0x8DBD +#define GL_COMPRESSED_SIGNED_RG_RGTC2 0x8DBE +#define GL_RG 0x8227 +#define GL_RG_INTEGER 0x8228 +#define GL_R8 0x8229 +#define GL_R16 0x822A +#define GL_RG8 0x822B +#define GL_RG16 0x822C +#define GL_R16F 0x822D +#define GL_R32F 0x822E +#define GL_RG16F 0x822F +#define GL_RG32F 0x8230 +#define GL_R8I 0x8231 +#define GL_R8UI 0x8232 +#define GL_R16I 0x8233 +#define GL_R16UI 0x8234 +#define GL_R32I 0x8235 +#define GL_R32UI 0x8236 +#define GL_RG8I 0x8237 +#define GL_RG8UI 0x8238 +#define GL_RG16I 0x8239 +#define GL_RG16UI 0x823A +#define GL_RG32I 0x823B +#define GL_RG32UI 0x823C +#define GL_VERTEX_ARRAY_BINDING 0x85B5 +#define GL_CLAMP_VERTEX_COLOR 0x891A +#define GL_CLAMP_FRAGMENT_COLOR 0x891B +#define GL_ALPHA_INTEGER 0x8D97 +#define GL_SAMPLER_2D_RECT 0x8B63 +#define GL_SAMPLER_2D_RECT_SHADOW 0x8B64 +#define GL_SAMPLER_BUFFER 0x8DC2 +#define GL_INT_SAMPLER_2D_RECT 0x8DCD +#define GL_INT_SAMPLER_BUFFER 0x8DD0 +#define GL_UNSIGNED_INT_SAMPLER_2D_RECT 0x8DD5 +#define GL_UNSIGNED_INT_SAMPLER_BUFFER 0x8DD8 +#define GL_TEXTURE_BUFFER 0x8C2A +#define GL_MAX_TEXTURE_BUFFER_SIZE 0x8C2B +#define GL_TEXTURE_BINDING_BUFFER 0x8C2C +#define GL_TEXTURE_BUFFER_DATA_STORE_BINDING 0x8C2D +#define GL_TEXTURE_RECTANGLE 0x84F5 +#define GL_TEXTURE_BINDING_RECTANGLE 0x84F6 +#define GL_PROXY_TEXTURE_RECTANGLE 0x84F7 +#define GL_MAX_RECTANGLE_TEXTURE_SIZE 0x84F8 +#define GL_R8_SNORM 0x8F94 +#define GL_RG8_SNORM 0x8F95 +#define GL_RGB8_SNORM 0x8F96 +#define GL_RGBA8_SNORM 0x8F97 +#define GL_R16_SNORM 0x8F98 +#define GL_RG16_SNORM 0x8F99 +#define GL_RGB16_SNORM 0x8F9A +#define GL_RGBA16_SNORM 0x8F9B +#define GL_SIGNED_NORMALIZED 0x8F9C +#define GL_PRIMITIVE_RESTART 0x8F9D +#define GL_PRIMITIVE_RESTART_INDEX 0x8F9E +#define GL_COPY_READ_BUFFER 0x8F36 +#define GL_COPY_WRITE_BUFFER 0x8F37 +#define GL_UNIFORM_BUFFER 0x8A11 +#define GL_UNIFORM_BUFFER_BINDING 0x8A28 +#define GL_UNIFORM_BUFFER_START 0x8A29 +#define GL_UNIFORM_BUFFER_SIZE 0x8A2A +#define GL_MAX_VERTEX_UNIFORM_BLOCKS 0x8A2B +#define GL_MAX_GEOMETRY_UNIFORM_BLOCKS 0x8A2C +#define GL_MAX_FRAGMENT_UNIFORM_BLOCKS 0x8A2D +#define GL_MAX_COMBINED_UNIFORM_BLOCKS 0x8A2E +#define GL_MAX_UNIFORM_BUFFER_BINDINGS 0x8A2F +#define GL_MAX_UNIFORM_BLOCK_SIZE 0x8A30 +#define GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS 0x8A31 +#define GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS 0x8A32 +#define GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS 0x8A33 +#define GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT 0x8A34 +#define GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH 0x8A35 +#define GL_ACTIVE_UNIFORM_BLOCKS 0x8A36 +#define GL_UNIFORM_TYPE 0x8A37 +#define GL_UNIFORM_SIZE 0x8A38 +#define GL_UNIFORM_NAME_LENGTH 0x8A39 +#define GL_UNIFORM_BLOCK_INDEX 0x8A3A +#define GL_UNIFORM_OFFSET 0x8A3B +#define GL_UNIFORM_ARRAY_STRIDE 0x8A3C +#define GL_UNIFORM_MATRIX_STRIDE 0x8A3D +#define GL_UNIFORM_IS_ROW_MAJOR 0x8A3E +#define GL_UNIFORM_BLOCK_BINDING 0x8A3F +#define GL_UNIFORM_BLOCK_DATA_SIZE 0x8A40 +#define GL_UNIFORM_BLOCK_NAME_LENGTH 0x8A41 +#define GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS 0x8A42 +#define GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES 0x8A43 +#define GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER 0x8A44 +#define GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER 0x8A45 +#define GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER 0x8A46 +#define GL_INVALID_INDEX 0xFFFFFFFF +#define GL_CONTEXT_CORE_PROFILE_BIT 0x00000001 +#define GL_CONTEXT_COMPATIBILITY_PROFILE_BIT 0x00000002 +#define GL_LINES_ADJACENCY 0x000A +#define GL_LINE_STRIP_ADJACENCY 0x000B +#define GL_TRIANGLES_ADJACENCY 0x000C +#define GL_TRIANGLE_STRIP_ADJACENCY 0x000D +#define GL_PROGRAM_POINT_SIZE 0x8642 +#define GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS 0x8C29 +#define GL_FRAMEBUFFER_ATTACHMENT_LAYERED 0x8DA7 +#define GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS 0x8DA8 +#define GL_GEOMETRY_SHADER 0x8DD9 +#define GL_GEOMETRY_VERTICES_OUT 0x8916 +#define GL_GEOMETRY_INPUT_TYPE 0x8917 +#define GL_GEOMETRY_OUTPUT_TYPE 0x8918 +#define GL_MAX_GEOMETRY_UNIFORM_COMPONENTS 0x8DDF +#define GL_MAX_GEOMETRY_OUTPUT_VERTICES 0x8DE0 +#define GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS 0x8DE1 +#define GL_MAX_VERTEX_OUTPUT_COMPONENTS 0x9122 +#define GL_MAX_GEOMETRY_INPUT_COMPONENTS 0x9123 +#define GL_MAX_GEOMETRY_OUTPUT_COMPONENTS 0x9124 +#define GL_MAX_FRAGMENT_INPUT_COMPONENTS 0x9125 +#define GL_CONTEXT_PROFILE_MASK 0x9126 +#define GL_DEPTH_CLAMP 0x864F +#define GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION 0x8E4C +#define GL_FIRST_VERTEX_CONVENTION 0x8E4D +#define GL_LAST_VERTEX_CONVENTION 0x8E4E +#define GL_PROVOKING_VERTEX 0x8E4F +#define GL_TEXTURE_CUBE_MAP_SEAMLESS 0x884F +#define GL_MAX_SERVER_WAIT_TIMEOUT 0x9111 +#define GL_OBJECT_TYPE 0x9112 +#define GL_SYNC_CONDITION 0x9113 +#define GL_SYNC_STATUS 0x9114 +#define GL_SYNC_FLAGS 0x9115 +#define GL_SYNC_FENCE 0x9116 +#define GL_SYNC_GPU_COMMANDS_COMPLETE 0x9117 +#define GL_UNSIGNALED 0x9118 +#define GL_SIGNALED 0x9119 +#define GL_ALREADY_SIGNALED 0x911A +#define GL_TIMEOUT_EXPIRED 0x911B +#define GL_CONDITION_SATISFIED 0x911C +#define GL_WAIT_FAILED 0x911D +#define GL_TIMEOUT_IGNORED 0xFFFFFFFFFFFFFFFF +#define GL_SYNC_FLUSH_COMMANDS_BIT 0x00000001 +#define GL_SAMPLE_POSITION 0x8E50 +#define GL_SAMPLE_MASK 0x8E51 +#define GL_SAMPLE_MASK_VALUE 0x8E52 +#define GL_MAX_SAMPLE_MASK_WORDS 0x8E59 +#define GL_TEXTURE_2D_MULTISAMPLE 0x9100 +#define GL_PROXY_TEXTURE_2D_MULTISAMPLE 0x9101 +#define GL_TEXTURE_2D_MULTISAMPLE_ARRAY 0x9102 +#define GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY 0x9103 +#define GL_TEXTURE_BINDING_2D_MULTISAMPLE 0x9104 +#define GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY 0x9105 +#define GL_TEXTURE_SAMPLES 0x9106 +#define GL_TEXTURE_FIXED_SAMPLE_LOCATIONS 0x9107 +#define GL_SAMPLER_2D_MULTISAMPLE 0x9108 +#define GL_INT_SAMPLER_2D_MULTISAMPLE 0x9109 +#define GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE 0x910A +#define GL_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910B +#define GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910C +#define GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910D +#define GL_MAX_COLOR_TEXTURE_SAMPLES 0x910E +#define GL_MAX_DEPTH_TEXTURE_SAMPLES 0x910F +#define GL_MAX_INTEGER_SAMPLES 0x9110 +#define GL_VERTEX_ATTRIB_ARRAY_DIVISOR 0x88FE +#define GL_SRC1_COLOR 0x88F9 +#define GL_ONE_MINUS_SRC1_COLOR 0x88FA +#define GL_ONE_MINUS_SRC1_ALPHA 0x88FB +#define GL_MAX_DUAL_SOURCE_DRAW_BUFFERS 0x88FC +#define GL_ANY_SAMPLES_PASSED 0x8C2F +#define GL_SAMPLER_BINDING 0x8919 +#define GL_RGB10_A2UI 0x906F +#define GL_TEXTURE_SWIZZLE_R 0x8E42 +#define GL_TEXTURE_SWIZZLE_G 0x8E43 +#define GL_TEXTURE_SWIZZLE_B 0x8E44 +#define GL_TEXTURE_SWIZZLE_A 0x8E45 +#define GL_TEXTURE_SWIZZLE_RGBA 0x8E46 +#define GL_TIME_ELAPSED 0x88BF +#define GL_TIMESTAMP 0x8E28 +#define GL_INT_2_10_10_10_REV 0x8D9F +#ifndef GL_VERSION_1_0 +#define GL_VERSION_1_0 1 + GLAPI int GLAD_GL_VERSION_1_0; + typedef void (APIENTRYP PFNGLCULLFACEPROC)(GLenum mode); + GLAPI PFNGLCULLFACEPROC glad_glCullFace; +#define glCullFace glad_glCullFace + typedef void (APIENTRYP PFNGLFRONTFACEPROC)(GLenum mode); + GLAPI PFNGLFRONTFACEPROC glad_glFrontFace; +#define glFrontFace glad_glFrontFace + typedef void (APIENTRYP PFNGLHINTPROC)(GLenum target, GLenum mode); + GLAPI PFNGLHINTPROC glad_glHint; +#define glHint glad_glHint + typedef void (APIENTRYP PFNGLLINEWIDTHPROC)(GLfloat width); + GLAPI PFNGLLINEWIDTHPROC glad_glLineWidth; +#define glLineWidth glad_glLineWidth + typedef void (APIENTRYP PFNGLPOINTSIZEPROC)(GLfloat size); + GLAPI PFNGLPOINTSIZEPROC glad_glPointSize; +#define glPointSize glad_glPointSize + typedef void (APIENTRYP PFNGLPOLYGONMODEPROC)(GLenum face, GLenum mode); + GLAPI PFNGLPOLYGONMODEPROC glad_glPolygonMode; +#define glPolygonMode glad_glPolygonMode + typedef void (APIENTRYP PFNGLSCISSORPROC)(GLint x, GLint y, GLsizei width, GLsizei height); + GLAPI PFNGLSCISSORPROC glad_glScissor; +#define glScissor glad_glScissor + typedef void (APIENTRYP PFNGLTEXPARAMETERFPROC)(GLenum target, GLenum pname, GLfloat param); + GLAPI PFNGLTEXPARAMETERFPROC glad_glTexParameterf; +#define glTexParameterf glad_glTexParameterf + typedef void (APIENTRYP PFNGLTEXPARAMETERFVPROC)(GLenum target, GLenum pname, const GLfloat* params); + GLAPI PFNGLTEXPARAMETERFVPROC glad_glTexParameterfv; +#define glTexParameterfv glad_glTexParameterfv + typedef void (APIENTRYP PFNGLTEXPARAMETERIPROC)(GLenum target, GLenum pname, GLint param); + GLAPI PFNGLTEXPARAMETERIPROC glad_glTexParameteri; +#define glTexParameteri glad_glTexParameteri + typedef void (APIENTRYP PFNGLTEXPARAMETERIVPROC)(GLenum target, GLenum pname, const GLint* params); + GLAPI PFNGLTEXPARAMETERIVPROC glad_glTexParameteriv; +#define glTexParameteriv glad_glTexParameteriv + typedef void (APIENTRYP PFNGLTEXIMAGE1DPROC)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void* pixels); + GLAPI PFNGLTEXIMAGE1DPROC glad_glTexImage1D; +#define glTexImage1D glad_glTexImage1D + typedef void (APIENTRYP PFNGLTEXIMAGE2DPROC)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void* pixels); + GLAPI PFNGLTEXIMAGE2DPROC glad_glTexImage2D; +#define glTexImage2D glad_glTexImage2D + typedef void (APIENTRYP PFNGLDRAWBUFFERPROC)(GLenum buf); + GLAPI PFNGLDRAWBUFFERPROC glad_glDrawBuffer; +#define glDrawBuffer glad_glDrawBuffer + typedef void (APIENTRYP PFNGLCLEARPROC)(GLbitfield mask); + GLAPI PFNGLCLEARPROC glad_glClear; +#define glClear glad_glClear + typedef void (APIENTRYP PFNGLCLEARCOLORPROC)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); + GLAPI PFNGLCLEARCOLORPROC glad_glClearColor; +#define glClearColor glad_glClearColor + typedef void (APIENTRYP PFNGLCLEARSTENCILPROC)(GLint s); + GLAPI PFNGLCLEARSTENCILPROC glad_glClearStencil; +#define glClearStencil glad_glClearStencil + typedef void (APIENTRYP PFNGLCLEARDEPTHPROC)(GLdouble depth); + GLAPI PFNGLCLEARDEPTHPROC glad_glClearDepth; +#define glClearDepth glad_glClearDepth + typedef void (APIENTRYP PFNGLSTENCILMASKPROC)(GLuint mask); + GLAPI PFNGLSTENCILMASKPROC glad_glStencilMask; +#define glStencilMask glad_glStencilMask + typedef void (APIENTRYP PFNGLCOLORMASKPROC)(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); + GLAPI PFNGLCOLORMASKPROC glad_glColorMask; +#define glColorMask glad_glColorMask + typedef void (APIENTRYP PFNGLDEPTHMASKPROC)(GLboolean flag); + GLAPI PFNGLDEPTHMASKPROC glad_glDepthMask; +#define glDepthMask glad_glDepthMask + typedef void (APIENTRYP PFNGLDISABLEPROC)(GLenum cap); + GLAPI PFNGLDISABLEPROC glad_glDisable; +#define glDisable glad_glDisable + typedef void (APIENTRYP PFNGLENABLEPROC)(GLenum cap); + GLAPI PFNGLENABLEPROC glad_glEnable; +#define glEnable glad_glEnable + typedef void (APIENTRYP PFNGLFINISHPROC)(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 + typedef void (APIENTRYP PFNGLNEWLISTPROC)(GLuint list, GLenum mode); + GLAPI PFNGLNEWLISTPROC glad_glNewList; +#define glNewList glad_glNewList + typedef void (APIENTRYP PFNGLENDLISTPROC)(void); + GLAPI PFNGLENDLISTPROC glad_glEndList; +#define glEndList glad_glEndList + typedef void (APIENTRYP PFNGLCALLLISTPROC)(GLuint list); + GLAPI PFNGLCALLLISTPROC glad_glCallList; +#define glCallList glad_glCallList + typedef void (APIENTRYP PFNGLCALLLISTSPROC)(GLsizei n, GLenum type, const void* lists); + GLAPI PFNGLCALLLISTSPROC glad_glCallLists; +#define glCallLists glad_glCallLists + typedef void (APIENTRYP PFNGLDELETELISTSPROC)(GLuint list, GLsizei range); + GLAPI PFNGLDELETELISTSPROC glad_glDeleteLists; +#define glDeleteLists glad_glDeleteLists + typedef GLuint( APIENTRYP PFNGLGENLISTSPROC )(GLsizei range); + GLAPI PFNGLGENLISTSPROC glad_glGenLists; +#define glGenLists glad_glGenLists + typedef void (APIENTRYP PFNGLLISTBASEPROC)(GLuint base); + GLAPI PFNGLLISTBASEPROC glad_glListBase; +#define glListBase glad_glListBase + typedef void (APIENTRYP PFNGLBEGINPROC)(GLenum mode); + GLAPI PFNGLBEGINPROC glad_glBegin; +#define glBegin glad_glBegin + typedef void (APIENTRYP PFNGLBITMAPPROC)(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte* bitmap); + GLAPI PFNGLBITMAPPROC glad_glBitmap; +#define glBitmap glad_glBitmap + typedef void (APIENTRYP PFNGLCOLOR3BPROC)(GLbyte red, GLbyte green, GLbyte blue); + GLAPI PFNGLCOLOR3BPROC glad_glColor3b; +#define glColor3b glad_glColor3b + typedef void (APIENTRYP PFNGLCOLOR3BVPROC)(const GLbyte* v); + GLAPI PFNGLCOLOR3BVPROC glad_glColor3bv; +#define glColor3bv glad_glColor3bv + typedef void (APIENTRYP PFNGLCOLOR3DPROC)(GLdouble red, GLdouble green, GLdouble blue); + GLAPI PFNGLCOLOR3DPROC glad_glColor3d; +#define glColor3d glad_glColor3d + typedef void (APIENTRYP PFNGLCOLOR3DVPROC)(const GLdouble* v); + GLAPI PFNGLCOLOR3DVPROC glad_glColor3dv; +#define glColor3dv glad_glColor3dv + typedef void (APIENTRYP PFNGLCOLOR3FPROC)(GLfloat red, GLfloat green, GLfloat blue); + GLAPI PFNGLCOLOR3FPROC glad_glColor3f; +#define glColor3f glad_glColor3f + typedef void (APIENTRYP PFNGLCOLOR3FVPROC)(const GLfloat* v); + GLAPI PFNGLCOLOR3FVPROC glad_glColor3fv; +#define glColor3fv glad_glColor3fv + typedef void (APIENTRYP PFNGLCOLOR3IPROC)(GLint red, GLint green, GLint blue); + GLAPI PFNGLCOLOR3IPROC glad_glColor3i; +#define glColor3i glad_glColor3i + typedef void (APIENTRYP PFNGLCOLOR3IVPROC)(const GLint* v); + GLAPI PFNGLCOLOR3IVPROC glad_glColor3iv; +#define glColor3iv glad_glColor3iv + typedef void (APIENTRYP PFNGLCOLOR3SPROC)(GLshort red, GLshort green, GLshort blue); + GLAPI PFNGLCOLOR3SPROC glad_glColor3s; +#define glColor3s glad_glColor3s + typedef void (APIENTRYP PFNGLCOLOR3SVPROC)(const GLshort* v); + GLAPI PFNGLCOLOR3SVPROC glad_glColor3sv; +#define glColor3sv glad_glColor3sv + typedef void (APIENTRYP PFNGLCOLOR3UBPROC)(GLubyte red, GLubyte green, GLubyte blue); + GLAPI PFNGLCOLOR3UBPROC glad_glColor3ub; +#define glColor3ub glad_glColor3ub + typedef void (APIENTRYP PFNGLCOLOR3UBVPROC)(const GLubyte* v); + GLAPI PFNGLCOLOR3UBVPROC glad_glColor3ubv; +#define glColor3ubv glad_glColor3ubv + typedef void (APIENTRYP PFNGLCOLOR3UIPROC)(GLuint red, GLuint green, GLuint blue); + GLAPI PFNGLCOLOR3UIPROC glad_glColor3ui; +#define glColor3ui glad_glColor3ui + typedef void (APIENTRYP PFNGLCOLOR3UIVPROC)(const GLuint* v); + GLAPI PFNGLCOLOR3UIVPROC glad_glColor3uiv; +#define glColor3uiv glad_glColor3uiv + typedef void (APIENTRYP PFNGLCOLOR3USPROC)(GLushort red, GLushort green, GLushort blue); + GLAPI PFNGLCOLOR3USPROC glad_glColor3us; +#define glColor3us glad_glColor3us + typedef void (APIENTRYP PFNGLCOLOR3USVPROC)(const GLushort* v); + GLAPI PFNGLCOLOR3USVPROC glad_glColor3usv; +#define glColor3usv glad_glColor3usv + typedef void (APIENTRYP PFNGLCOLOR4BPROC)(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha); + GLAPI PFNGLCOLOR4BPROC glad_glColor4b; +#define glColor4b glad_glColor4b + typedef void (APIENTRYP PFNGLCOLOR4BVPROC)(const GLbyte* v); + GLAPI PFNGLCOLOR4BVPROC glad_glColor4bv; +#define glColor4bv glad_glColor4bv + typedef void (APIENTRYP PFNGLCOLOR4DPROC)(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha); + GLAPI PFNGLCOLOR4DPROC glad_glColor4d; +#define glColor4d glad_glColor4d + typedef void (APIENTRYP PFNGLCOLOR4DVPROC)(const GLdouble* v); + GLAPI PFNGLCOLOR4DVPROC glad_glColor4dv; +#define glColor4dv glad_glColor4dv + typedef void (APIENTRYP PFNGLCOLOR4FPROC)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); + GLAPI PFNGLCOLOR4FPROC glad_glColor4f; +#define glColor4f glad_glColor4f + typedef void (APIENTRYP PFNGLCOLOR4FVPROC)(const GLfloat* v); + GLAPI PFNGLCOLOR4FVPROC glad_glColor4fv; +#define glColor4fv glad_glColor4fv + typedef void (APIENTRYP PFNGLCOLOR4IPROC)(GLint red, GLint green, GLint blue, GLint alpha); + GLAPI PFNGLCOLOR4IPROC glad_glColor4i; +#define glColor4i glad_glColor4i + typedef void (APIENTRYP PFNGLCOLOR4IVPROC)(const GLint* v); + GLAPI PFNGLCOLOR4IVPROC glad_glColor4iv; +#define glColor4iv glad_glColor4iv + typedef void (APIENTRYP PFNGLCOLOR4SPROC)(GLshort red, GLshort green, GLshort blue, GLshort alpha); + GLAPI PFNGLCOLOR4SPROC glad_glColor4s; +#define glColor4s glad_glColor4s + typedef void (APIENTRYP PFNGLCOLOR4SVPROC)(const GLshort* v); + GLAPI PFNGLCOLOR4SVPROC glad_glColor4sv; +#define glColor4sv glad_glColor4sv + typedef void (APIENTRYP PFNGLCOLOR4UBPROC)(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha); + GLAPI PFNGLCOLOR4UBPROC glad_glColor4ub; +#define glColor4ub glad_glColor4ub + typedef void (APIENTRYP PFNGLCOLOR4UBVPROC)(const GLubyte* v); + GLAPI PFNGLCOLOR4UBVPROC glad_glColor4ubv; +#define glColor4ubv glad_glColor4ubv + typedef void (APIENTRYP PFNGLCOLOR4UIPROC)(GLuint red, GLuint green, GLuint blue, GLuint alpha); + GLAPI PFNGLCOLOR4UIPROC glad_glColor4ui; +#define glColor4ui glad_glColor4ui + typedef void (APIENTRYP PFNGLCOLOR4UIVPROC)(const GLuint* v); + GLAPI PFNGLCOLOR4UIVPROC glad_glColor4uiv; +#define glColor4uiv glad_glColor4uiv + typedef void (APIENTRYP PFNGLCOLOR4USPROC)(GLushort red, GLushort green, GLushort blue, GLushort alpha); + GLAPI PFNGLCOLOR4USPROC glad_glColor4us; +#define glColor4us glad_glColor4us + typedef void (APIENTRYP PFNGLCOLOR4USVPROC)(const GLushort* v); + GLAPI PFNGLCOLOR4USVPROC glad_glColor4usv; +#define glColor4usv glad_glColor4usv + typedef void (APIENTRYP PFNGLEDGEFLAGPROC)(GLboolean flag); + GLAPI PFNGLEDGEFLAGPROC glad_glEdgeFlag; +#define glEdgeFlag glad_glEdgeFlag + typedef void (APIENTRYP PFNGLEDGEFLAGVPROC)(const GLboolean* flag); + GLAPI PFNGLEDGEFLAGVPROC glad_glEdgeFlagv; +#define glEdgeFlagv glad_glEdgeFlagv + typedef void (APIENTRYP PFNGLENDPROC)(void); + GLAPI PFNGLENDPROC glad_glEnd; +#define glEnd glad_glEnd + typedef void (APIENTRYP PFNGLINDEXDPROC)(GLdouble c); + GLAPI PFNGLINDEXDPROC glad_glIndexd; +#define glIndexd glad_glIndexd + typedef void (APIENTRYP PFNGLINDEXDVPROC)(const GLdouble* c); + GLAPI PFNGLINDEXDVPROC glad_glIndexdv; +#define glIndexdv glad_glIndexdv + typedef void (APIENTRYP PFNGLINDEXFPROC)(GLfloat c); + GLAPI PFNGLINDEXFPROC glad_glIndexf; +#define glIndexf glad_glIndexf + typedef void (APIENTRYP PFNGLINDEXFVPROC)(const GLfloat* c); + GLAPI PFNGLINDEXFVPROC glad_glIndexfv; +#define glIndexfv glad_glIndexfv + typedef void (APIENTRYP PFNGLINDEXIPROC)(GLint c); + GLAPI PFNGLINDEXIPROC glad_glIndexi; +#define glIndexi glad_glIndexi + typedef void (APIENTRYP PFNGLINDEXIVPROC)(const GLint* c); + GLAPI PFNGLINDEXIVPROC glad_glIndexiv; +#define glIndexiv glad_glIndexiv + typedef void (APIENTRYP PFNGLINDEXSPROC)(GLshort c); + GLAPI PFNGLINDEXSPROC glad_glIndexs; +#define glIndexs glad_glIndexs + typedef void (APIENTRYP PFNGLINDEXSVPROC)(const GLshort* c); + GLAPI PFNGLINDEXSVPROC glad_glIndexsv; +#define glIndexsv glad_glIndexsv + typedef void (APIENTRYP PFNGLNORMAL3BPROC)(GLbyte nx, GLbyte ny, GLbyte nz); + GLAPI PFNGLNORMAL3BPROC glad_glNormal3b; +#define glNormal3b glad_glNormal3b + typedef void (APIENTRYP PFNGLNORMAL3BVPROC)(const GLbyte* v); + GLAPI PFNGLNORMAL3BVPROC glad_glNormal3bv; +#define glNormal3bv glad_glNormal3bv + typedef void (APIENTRYP PFNGLNORMAL3DPROC)(GLdouble nx, GLdouble ny, GLdouble nz); + GLAPI PFNGLNORMAL3DPROC glad_glNormal3d; +#define glNormal3d glad_glNormal3d + typedef void (APIENTRYP PFNGLNORMAL3DVPROC)(const GLdouble* v); + GLAPI PFNGLNORMAL3DVPROC glad_glNormal3dv; +#define glNormal3dv glad_glNormal3dv + typedef void (APIENTRYP PFNGLNORMAL3FPROC)(GLfloat nx, GLfloat ny, GLfloat nz); + GLAPI PFNGLNORMAL3FPROC glad_glNormal3f; +#define glNormal3f glad_glNormal3f + typedef void (APIENTRYP PFNGLNORMAL3FVPROC)(const GLfloat* v); + GLAPI PFNGLNORMAL3FVPROC glad_glNormal3fv; +#define glNormal3fv glad_glNormal3fv + typedef void (APIENTRYP PFNGLNORMAL3IPROC)(GLint nx, GLint ny, GLint nz); + GLAPI PFNGLNORMAL3IPROC glad_glNormal3i; +#define glNormal3i glad_glNormal3i + typedef void (APIENTRYP PFNGLNORMAL3IVPROC)(const GLint* v); + GLAPI PFNGLNORMAL3IVPROC glad_glNormal3iv; +#define glNormal3iv glad_glNormal3iv + typedef void (APIENTRYP PFNGLNORMAL3SPROC)(GLshort nx, GLshort ny, GLshort nz); + GLAPI PFNGLNORMAL3SPROC glad_glNormal3s; +#define glNormal3s glad_glNormal3s + typedef void (APIENTRYP PFNGLNORMAL3SVPROC)(const GLshort* v); + GLAPI PFNGLNORMAL3SVPROC glad_glNormal3sv; +#define glNormal3sv glad_glNormal3sv + typedef void (APIENTRYP PFNGLRASTERPOS2DPROC)(GLdouble x, GLdouble y); + GLAPI PFNGLRASTERPOS2DPROC glad_glRasterPos2d; +#define glRasterPos2d glad_glRasterPos2d + typedef void (APIENTRYP PFNGLRASTERPOS2DVPROC)(const GLdouble* v); + GLAPI PFNGLRASTERPOS2DVPROC glad_glRasterPos2dv; +#define glRasterPos2dv glad_glRasterPos2dv + typedef void (APIENTRYP PFNGLRASTERPOS2FPROC)(GLfloat x, GLfloat y); + GLAPI PFNGLRASTERPOS2FPROC glad_glRasterPos2f; +#define glRasterPos2f glad_glRasterPos2f + typedef void (APIENTRYP PFNGLRASTERPOS2FVPROC)(const GLfloat* v); + GLAPI PFNGLRASTERPOS2FVPROC glad_glRasterPos2fv; +#define glRasterPos2fv glad_glRasterPos2fv + typedef void (APIENTRYP PFNGLRASTERPOS2IPROC)(GLint x, GLint y); + GLAPI PFNGLRASTERPOS2IPROC glad_glRasterPos2i; +#define glRasterPos2i glad_glRasterPos2i + typedef void (APIENTRYP PFNGLRASTERPOS2IVPROC)(const GLint* v); + GLAPI PFNGLRASTERPOS2IVPROC glad_glRasterPos2iv; +#define glRasterPos2iv glad_glRasterPos2iv + typedef void (APIENTRYP PFNGLRASTERPOS2SPROC)(GLshort x, GLshort y); + GLAPI PFNGLRASTERPOS2SPROC glad_glRasterPos2s; +#define glRasterPos2s glad_glRasterPos2s + typedef void (APIENTRYP PFNGLRASTERPOS2SVPROC)(const GLshort* v); + GLAPI PFNGLRASTERPOS2SVPROC glad_glRasterPos2sv; +#define glRasterPos2sv glad_glRasterPos2sv + typedef void (APIENTRYP PFNGLRASTERPOS3DPROC)(GLdouble x, GLdouble y, GLdouble z); + GLAPI PFNGLRASTERPOS3DPROC glad_glRasterPos3d; +#define glRasterPos3d glad_glRasterPos3d + typedef void (APIENTRYP PFNGLRASTERPOS3DVPROC)(const GLdouble* v); + GLAPI PFNGLRASTERPOS3DVPROC glad_glRasterPos3dv; +#define glRasterPos3dv glad_glRasterPos3dv + typedef void (APIENTRYP PFNGLRASTERPOS3FPROC)(GLfloat x, GLfloat y, GLfloat z); + GLAPI PFNGLRASTERPOS3FPROC glad_glRasterPos3f; +#define glRasterPos3f glad_glRasterPos3f + typedef void (APIENTRYP PFNGLRASTERPOS3FVPROC)(const GLfloat* v); + GLAPI PFNGLRASTERPOS3FVPROC glad_glRasterPos3fv; +#define glRasterPos3fv glad_glRasterPos3fv + typedef void (APIENTRYP PFNGLRASTERPOS3IPROC)(GLint x, GLint y, GLint z); + GLAPI PFNGLRASTERPOS3IPROC glad_glRasterPos3i; +#define glRasterPos3i glad_glRasterPos3i + typedef void (APIENTRYP PFNGLRASTERPOS3IVPROC)(const GLint* v); + GLAPI PFNGLRASTERPOS3IVPROC glad_glRasterPos3iv; +#define glRasterPos3iv glad_glRasterPos3iv + typedef void (APIENTRYP PFNGLRASTERPOS3SPROC)(GLshort x, GLshort y, GLshort z); + GLAPI PFNGLRASTERPOS3SPROC glad_glRasterPos3s; +#define glRasterPos3s glad_glRasterPos3s + typedef void (APIENTRYP PFNGLRASTERPOS3SVPROC)(const GLshort* v); + GLAPI PFNGLRASTERPOS3SVPROC glad_glRasterPos3sv; +#define glRasterPos3sv glad_glRasterPos3sv + typedef void (APIENTRYP PFNGLRASTERPOS4DPROC)(GLdouble x, GLdouble y, GLdouble z, GLdouble w); + GLAPI PFNGLRASTERPOS4DPROC glad_glRasterPos4d; +#define glRasterPos4d glad_glRasterPos4d + typedef void (APIENTRYP PFNGLRASTERPOS4DVPROC)(const GLdouble* v); + GLAPI PFNGLRASTERPOS4DVPROC glad_glRasterPos4dv; +#define glRasterPos4dv glad_glRasterPos4dv + typedef void (APIENTRYP PFNGLRASTERPOS4FPROC)(GLfloat x, GLfloat y, GLfloat z, GLfloat w); + GLAPI PFNGLRASTERPOS4FPROC glad_glRasterPos4f; +#define glRasterPos4f glad_glRasterPos4f + typedef void (APIENTRYP PFNGLRASTERPOS4FVPROC)(const GLfloat* v); + GLAPI PFNGLRASTERPOS4FVPROC glad_glRasterPos4fv; +#define glRasterPos4fv glad_glRasterPos4fv + typedef void (APIENTRYP PFNGLRASTERPOS4IPROC)(GLint x, GLint y, GLint z, GLint w); + GLAPI PFNGLRASTERPOS4IPROC glad_glRasterPos4i; +#define glRasterPos4i glad_glRasterPos4i + typedef void (APIENTRYP PFNGLRASTERPOS4IVPROC)(const GLint* v); + GLAPI PFNGLRASTERPOS4IVPROC glad_glRasterPos4iv; +#define glRasterPos4iv glad_glRasterPos4iv + typedef void (APIENTRYP PFNGLRASTERPOS4SPROC)(GLshort x, GLshort y, GLshort z, GLshort w); + GLAPI PFNGLRASTERPOS4SPROC glad_glRasterPos4s; +#define glRasterPos4s glad_glRasterPos4s + typedef void (APIENTRYP PFNGLRASTERPOS4SVPROC)(const GLshort* v); + GLAPI PFNGLRASTERPOS4SVPROC glad_glRasterPos4sv; +#define glRasterPos4sv glad_glRasterPos4sv + typedef void (APIENTRYP PFNGLRECTDPROC)(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2); + GLAPI PFNGLRECTDPROC glad_glRectd; +#define glRectd glad_glRectd + typedef void (APIENTRYP PFNGLRECTDVPROC)(const GLdouble* v1, const GLdouble* v2); + GLAPI PFNGLRECTDVPROC glad_glRectdv; +#define glRectdv glad_glRectdv + typedef void (APIENTRYP PFNGLRECTFPROC)(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2); + GLAPI PFNGLRECTFPROC glad_glRectf; +#define glRectf glad_glRectf + typedef void (APIENTRYP PFNGLRECTFVPROC)(const GLfloat* v1, const GLfloat* v2); + GLAPI PFNGLRECTFVPROC glad_glRectfv; +#define glRectfv glad_glRectfv + typedef void (APIENTRYP PFNGLRECTIPROC)(GLint x1, GLint y1, GLint x2, GLint y2); + GLAPI PFNGLRECTIPROC glad_glRecti; +#define glRecti glad_glRecti + typedef void (APIENTRYP PFNGLRECTIVPROC)(const GLint* v1, const GLint* v2); + GLAPI PFNGLRECTIVPROC glad_glRectiv; +#define glRectiv glad_glRectiv + typedef void (APIENTRYP PFNGLRECTSPROC)(GLshort x1, GLshort y1, GLshort x2, GLshort y2); + GLAPI PFNGLRECTSPROC glad_glRects; +#define glRects glad_glRects + typedef void (APIENTRYP PFNGLRECTSVPROC)(const GLshort* v1, const GLshort* v2); + GLAPI PFNGLRECTSVPROC glad_glRectsv; +#define glRectsv glad_glRectsv + typedef void (APIENTRYP PFNGLTEXCOORD1DPROC)(GLdouble s); + GLAPI PFNGLTEXCOORD1DPROC glad_glTexCoord1d; +#define glTexCoord1d glad_glTexCoord1d + typedef void (APIENTRYP PFNGLTEXCOORD1DVPROC)(const GLdouble* v); + GLAPI PFNGLTEXCOORD1DVPROC glad_glTexCoord1dv; +#define glTexCoord1dv glad_glTexCoord1dv + typedef void (APIENTRYP PFNGLTEXCOORD1FPROC)(GLfloat s); + GLAPI PFNGLTEXCOORD1FPROC glad_glTexCoord1f; +#define glTexCoord1f glad_glTexCoord1f + typedef void (APIENTRYP PFNGLTEXCOORD1FVPROC)(const GLfloat* v); + GLAPI PFNGLTEXCOORD1FVPROC glad_glTexCoord1fv; +#define glTexCoord1fv glad_glTexCoord1fv + typedef void (APIENTRYP PFNGLTEXCOORD1IPROC)(GLint s); + GLAPI PFNGLTEXCOORD1IPROC glad_glTexCoord1i; +#define glTexCoord1i glad_glTexCoord1i + typedef void (APIENTRYP PFNGLTEXCOORD1IVPROC)(const GLint* v); + GLAPI PFNGLTEXCOORD1IVPROC glad_glTexCoord1iv; +#define glTexCoord1iv glad_glTexCoord1iv + typedef void (APIENTRYP PFNGLTEXCOORD1SPROC)(GLshort s); + GLAPI PFNGLTEXCOORD1SPROC glad_glTexCoord1s; +#define glTexCoord1s glad_glTexCoord1s + typedef void (APIENTRYP PFNGLTEXCOORD1SVPROC)(const GLshort* v); + GLAPI PFNGLTEXCOORD1SVPROC glad_glTexCoord1sv; +#define glTexCoord1sv glad_glTexCoord1sv + typedef void (APIENTRYP PFNGLTEXCOORD2DPROC)(GLdouble s, GLdouble t); + GLAPI PFNGLTEXCOORD2DPROC glad_glTexCoord2d; +#define glTexCoord2d glad_glTexCoord2d + typedef void (APIENTRYP PFNGLTEXCOORD2DVPROC)(const GLdouble* v); + GLAPI PFNGLTEXCOORD2DVPROC glad_glTexCoord2dv; +#define glTexCoord2dv glad_glTexCoord2dv + typedef void (APIENTRYP PFNGLTEXCOORD2FPROC)(GLfloat s, GLfloat t); + GLAPI PFNGLTEXCOORD2FPROC glad_glTexCoord2f; +#define glTexCoord2f glad_glTexCoord2f + typedef void (APIENTRYP PFNGLTEXCOORD2FVPROC)(const GLfloat* v); + GLAPI PFNGLTEXCOORD2FVPROC glad_glTexCoord2fv; +#define glTexCoord2fv glad_glTexCoord2fv + typedef void (APIENTRYP PFNGLTEXCOORD2IPROC)(GLint s, GLint t); + GLAPI PFNGLTEXCOORD2IPROC glad_glTexCoord2i; +#define glTexCoord2i glad_glTexCoord2i + typedef void (APIENTRYP PFNGLTEXCOORD2IVPROC)(const GLint* v); + GLAPI PFNGLTEXCOORD2IVPROC glad_glTexCoord2iv; +#define glTexCoord2iv glad_glTexCoord2iv + typedef void (APIENTRYP PFNGLTEXCOORD2SPROC)(GLshort s, GLshort t); + GLAPI PFNGLTEXCOORD2SPROC glad_glTexCoord2s; +#define glTexCoord2s glad_glTexCoord2s + typedef void (APIENTRYP PFNGLTEXCOORD2SVPROC)(const GLshort* v); + GLAPI PFNGLTEXCOORD2SVPROC glad_glTexCoord2sv; +#define glTexCoord2sv glad_glTexCoord2sv + typedef void (APIENTRYP PFNGLTEXCOORD3DPROC)(GLdouble s, GLdouble t, GLdouble r); + GLAPI PFNGLTEXCOORD3DPROC glad_glTexCoord3d; +#define glTexCoord3d glad_glTexCoord3d + typedef void (APIENTRYP PFNGLTEXCOORD3DVPROC)(const GLdouble* v); + GLAPI PFNGLTEXCOORD3DVPROC glad_glTexCoord3dv; +#define glTexCoord3dv glad_glTexCoord3dv + typedef void (APIENTRYP PFNGLTEXCOORD3FPROC)(GLfloat s, GLfloat t, GLfloat r); + GLAPI PFNGLTEXCOORD3FPROC glad_glTexCoord3f; +#define glTexCoord3f glad_glTexCoord3f + typedef void (APIENTRYP PFNGLTEXCOORD3FVPROC)(const GLfloat* v); + GLAPI PFNGLTEXCOORD3FVPROC glad_glTexCoord3fv; +#define glTexCoord3fv glad_glTexCoord3fv + typedef void (APIENTRYP PFNGLTEXCOORD3IPROC)(GLint s, GLint t, GLint r); + GLAPI PFNGLTEXCOORD3IPROC glad_glTexCoord3i; +#define glTexCoord3i glad_glTexCoord3i + typedef void (APIENTRYP PFNGLTEXCOORD3IVPROC)(const GLint* v); + GLAPI PFNGLTEXCOORD3IVPROC glad_glTexCoord3iv; +#define glTexCoord3iv glad_glTexCoord3iv + typedef void (APIENTRYP PFNGLTEXCOORD3SPROC)(GLshort s, GLshort t, GLshort r); + GLAPI PFNGLTEXCOORD3SPROC glad_glTexCoord3s; +#define glTexCoord3s glad_glTexCoord3s + typedef void (APIENTRYP PFNGLTEXCOORD3SVPROC)(const GLshort* v); + GLAPI PFNGLTEXCOORD3SVPROC glad_glTexCoord3sv; +#define glTexCoord3sv glad_glTexCoord3sv + typedef void (APIENTRYP PFNGLTEXCOORD4DPROC)(GLdouble s, GLdouble t, GLdouble r, GLdouble q); + GLAPI PFNGLTEXCOORD4DPROC glad_glTexCoord4d; +#define glTexCoord4d glad_glTexCoord4d + typedef void (APIENTRYP PFNGLTEXCOORD4DVPROC)(const GLdouble* v); + GLAPI PFNGLTEXCOORD4DVPROC glad_glTexCoord4dv; +#define glTexCoord4dv glad_glTexCoord4dv + typedef void (APIENTRYP PFNGLTEXCOORD4FPROC)(GLfloat s, GLfloat t, GLfloat r, GLfloat q); + GLAPI PFNGLTEXCOORD4FPROC glad_glTexCoord4f; +#define glTexCoord4f glad_glTexCoord4f + typedef void (APIENTRYP PFNGLTEXCOORD4FVPROC)(const GLfloat* v); + GLAPI PFNGLTEXCOORD4FVPROC glad_glTexCoord4fv; +#define glTexCoord4fv glad_glTexCoord4fv + typedef void (APIENTRYP PFNGLTEXCOORD4IPROC)(GLint s, GLint t, GLint r, GLint q); + GLAPI PFNGLTEXCOORD4IPROC glad_glTexCoord4i; +#define glTexCoord4i glad_glTexCoord4i + typedef void (APIENTRYP PFNGLTEXCOORD4IVPROC)(const GLint* v); + GLAPI PFNGLTEXCOORD4IVPROC glad_glTexCoord4iv; +#define glTexCoord4iv glad_glTexCoord4iv + typedef void (APIENTRYP PFNGLTEXCOORD4SPROC)(GLshort s, GLshort t, GLshort r, GLshort q); + GLAPI PFNGLTEXCOORD4SPROC glad_glTexCoord4s; +#define glTexCoord4s glad_glTexCoord4s + typedef void (APIENTRYP PFNGLTEXCOORD4SVPROC)(const GLshort* v); + GLAPI PFNGLTEXCOORD4SVPROC glad_glTexCoord4sv; +#define glTexCoord4sv glad_glTexCoord4sv + typedef void (APIENTRYP PFNGLVERTEX2DPROC)(GLdouble x, GLdouble y); + GLAPI PFNGLVERTEX2DPROC glad_glVertex2d; +#define glVertex2d glad_glVertex2d + typedef void (APIENTRYP PFNGLVERTEX2DVPROC)(const GLdouble* v); + GLAPI PFNGLVERTEX2DVPROC glad_glVertex2dv; +#define glVertex2dv glad_glVertex2dv + typedef void (APIENTRYP PFNGLVERTEX2FPROC)(GLfloat x, GLfloat y); + GLAPI PFNGLVERTEX2FPROC glad_glVertex2f; +#define glVertex2f glad_glVertex2f + typedef void (APIENTRYP PFNGLVERTEX2FVPROC)(const GLfloat* v); + GLAPI PFNGLVERTEX2FVPROC glad_glVertex2fv; +#define glVertex2fv glad_glVertex2fv + typedef void (APIENTRYP PFNGLVERTEX2IPROC)(GLint x, GLint y); + GLAPI PFNGLVERTEX2IPROC glad_glVertex2i; +#define glVertex2i glad_glVertex2i + typedef void (APIENTRYP PFNGLVERTEX2IVPROC)(const GLint* v); + GLAPI PFNGLVERTEX2IVPROC glad_glVertex2iv; +#define glVertex2iv glad_glVertex2iv + typedef void (APIENTRYP PFNGLVERTEX2SPROC)(GLshort x, GLshort y); + GLAPI PFNGLVERTEX2SPROC glad_glVertex2s; +#define glVertex2s glad_glVertex2s + typedef void (APIENTRYP PFNGLVERTEX2SVPROC)(const GLshort* v); + GLAPI PFNGLVERTEX2SVPROC glad_glVertex2sv; +#define glVertex2sv glad_glVertex2sv + typedef void (APIENTRYP PFNGLVERTEX3DPROC)(GLdouble x, GLdouble y, GLdouble z); + GLAPI PFNGLVERTEX3DPROC glad_glVertex3d; +#define glVertex3d glad_glVertex3d + typedef void (APIENTRYP PFNGLVERTEX3DVPROC)(const GLdouble* v); + GLAPI PFNGLVERTEX3DVPROC glad_glVertex3dv; +#define glVertex3dv glad_glVertex3dv + typedef void (APIENTRYP PFNGLVERTEX3FPROC)(GLfloat x, GLfloat y, GLfloat z); + GLAPI PFNGLVERTEX3FPROC glad_glVertex3f; +#define glVertex3f glad_glVertex3f + typedef void (APIENTRYP PFNGLVERTEX3FVPROC)(const GLfloat* v); + GLAPI PFNGLVERTEX3FVPROC glad_glVertex3fv; +#define glVertex3fv glad_glVertex3fv + typedef void (APIENTRYP PFNGLVERTEX3IPROC)(GLint x, GLint y, GLint z); + GLAPI PFNGLVERTEX3IPROC glad_glVertex3i; +#define glVertex3i glad_glVertex3i + typedef void (APIENTRYP PFNGLVERTEX3IVPROC)(const GLint* v); + GLAPI PFNGLVERTEX3IVPROC glad_glVertex3iv; +#define glVertex3iv glad_glVertex3iv + typedef void (APIENTRYP PFNGLVERTEX3SPROC)(GLshort x, GLshort y, GLshort z); + GLAPI PFNGLVERTEX3SPROC glad_glVertex3s; +#define glVertex3s glad_glVertex3s + typedef void (APIENTRYP PFNGLVERTEX3SVPROC)(const GLshort* v); + GLAPI PFNGLVERTEX3SVPROC glad_glVertex3sv; +#define glVertex3sv glad_glVertex3sv + typedef void (APIENTRYP PFNGLVERTEX4DPROC)(GLdouble x, GLdouble y, GLdouble z, GLdouble w); + GLAPI PFNGLVERTEX4DPROC glad_glVertex4d; +#define glVertex4d glad_glVertex4d + typedef void (APIENTRYP PFNGLVERTEX4DVPROC)(const GLdouble* v); + GLAPI PFNGLVERTEX4DVPROC glad_glVertex4dv; +#define glVertex4dv glad_glVertex4dv + typedef void (APIENTRYP PFNGLVERTEX4FPROC)(GLfloat x, GLfloat y, GLfloat z, GLfloat w); + GLAPI PFNGLVERTEX4FPROC glad_glVertex4f; +#define glVertex4f glad_glVertex4f + typedef void (APIENTRYP PFNGLVERTEX4FVPROC)(const GLfloat* v); + GLAPI PFNGLVERTEX4FVPROC glad_glVertex4fv; +#define glVertex4fv glad_glVertex4fv + typedef void (APIENTRYP PFNGLVERTEX4IPROC)(GLint x, GLint y, GLint z, GLint w); + GLAPI PFNGLVERTEX4IPROC glad_glVertex4i; +#define glVertex4i glad_glVertex4i + typedef void (APIENTRYP PFNGLVERTEX4IVPROC)(const GLint* v); + GLAPI PFNGLVERTEX4IVPROC glad_glVertex4iv; +#define glVertex4iv glad_glVertex4iv + typedef void (APIENTRYP PFNGLVERTEX4SPROC)(GLshort x, GLshort y, GLshort z, GLshort w); + GLAPI PFNGLVERTEX4SPROC glad_glVertex4s; +#define glVertex4s glad_glVertex4s + typedef void (APIENTRYP PFNGLVERTEX4SVPROC)(const GLshort* v); + GLAPI PFNGLVERTEX4SVPROC glad_glVertex4sv; +#define glVertex4sv glad_glVertex4sv + typedef void (APIENTRYP PFNGLCLIPPLANEPROC)(GLenum plane, const GLdouble* equation); + GLAPI PFNGLCLIPPLANEPROC glad_glClipPlane; +#define glClipPlane glad_glClipPlane + typedef void (APIENTRYP PFNGLCOLORMATERIALPROC)(GLenum face, GLenum mode); + GLAPI PFNGLCOLORMATERIALPROC glad_glColorMaterial; +#define glColorMaterial glad_glColorMaterial + typedef void (APIENTRYP PFNGLFOGFPROC)(GLenum pname, GLfloat param); + GLAPI PFNGLFOGFPROC glad_glFogf; +#define glFogf glad_glFogf + typedef void (APIENTRYP PFNGLFOGFVPROC)(GLenum pname, const GLfloat* params); + GLAPI PFNGLFOGFVPROC glad_glFogfv; +#define glFogfv glad_glFogfv + typedef void (APIENTRYP PFNGLFOGIPROC)(GLenum pname, GLint param); + GLAPI PFNGLFOGIPROC glad_glFogi; +#define glFogi glad_glFogi + typedef void (APIENTRYP PFNGLFOGIVPROC)(GLenum pname, const GLint* params); + GLAPI PFNGLFOGIVPROC glad_glFogiv; +#define glFogiv glad_glFogiv + typedef void (APIENTRYP PFNGLLIGHTFPROC)(GLenum light, GLenum pname, GLfloat param); + GLAPI PFNGLLIGHTFPROC glad_glLightf; +#define glLightf glad_glLightf + typedef void (APIENTRYP PFNGLLIGHTFVPROC)(GLenum light, GLenum pname, const GLfloat* params); + GLAPI PFNGLLIGHTFVPROC glad_glLightfv; +#define glLightfv glad_glLightfv + typedef void (APIENTRYP PFNGLLIGHTIPROC)(GLenum light, GLenum pname, GLint param); + GLAPI PFNGLLIGHTIPROC glad_glLighti; +#define glLighti glad_glLighti + typedef void (APIENTRYP PFNGLLIGHTIVPROC)(GLenum light, GLenum pname, const GLint* params); + GLAPI PFNGLLIGHTIVPROC glad_glLightiv; +#define glLightiv glad_glLightiv + typedef void (APIENTRYP PFNGLLIGHTMODELFPROC)(GLenum pname, GLfloat param); + GLAPI PFNGLLIGHTMODELFPROC glad_glLightModelf; +#define glLightModelf glad_glLightModelf + typedef void (APIENTRYP PFNGLLIGHTMODELFVPROC)(GLenum pname, const GLfloat* params); + GLAPI PFNGLLIGHTMODELFVPROC glad_glLightModelfv; +#define glLightModelfv glad_glLightModelfv + typedef void (APIENTRYP PFNGLLIGHTMODELIPROC)(GLenum pname, GLint param); + GLAPI PFNGLLIGHTMODELIPROC glad_glLightModeli; +#define glLightModeli glad_glLightModeli + typedef void (APIENTRYP PFNGLLIGHTMODELIVPROC)(GLenum pname, const GLint* params); + GLAPI PFNGLLIGHTMODELIVPROC glad_glLightModeliv; +#define glLightModeliv glad_glLightModeliv + typedef void (APIENTRYP PFNGLLINESTIPPLEPROC)(GLint factor, GLushort pattern); + GLAPI PFNGLLINESTIPPLEPROC glad_glLineStipple; +#define glLineStipple glad_glLineStipple + typedef void (APIENTRYP PFNGLMATERIALFPROC)(GLenum face, GLenum pname, GLfloat param); + GLAPI PFNGLMATERIALFPROC glad_glMaterialf; +#define glMaterialf glad_glMaterialf + typedef void (APIENTRYP PFNGLMATERIALFVPROC)(GLenum face, GLenum pname, const GLfloat* params); + GLAPI PFNGLMATERIALFVPROC glad_glMaterialfv; +#define glMaterialfv glad_glMaterialfv + typedef void (APIENTRYP PFNGLMATERIALIPROC)(GLenum face, GLenum pname, GLint param); + GLAPI PFNGLMATERIALIPROC glad_glMateriali; +#define glMateriali glad_glMateriali + typedef void (APIENTRYP PFNGLMATERIALIVPROC)(GLenum face, GLenum pname, const GLint* params); + GLAPI PFNGLMATERIALIVPROC glad_glMaterialiv; +#define glMaterialiv glad_glMaterialiv + typedef void (APIENTRYP PFNGLPOLYGONSTIPPLEPROC)(const GLubyte* mask); + GLAPI PFNGLPOLYGONSTIPPLEPROC glad_glPolygonStipple; +#define glPolygonStipple glad_glPolygonStipple + typedef void (APIENTRYP PFNGLSHADEMODELPROC)(GLenum mode); + GLAPI PFNGLSHADEMODELPROC glad_glShadeModel; +#define glShadeModel glad_glShadeModel + typedef void (APIENTRYP PFNGLTEXENVFPROC)(GLenum target, GLenum pname, GLfloat param); + GLAPI PFNGLTEXENVFPROC glad_glTexEnvf; +#define glTexEnvf glad_glTexEnvf + typedef void (APIENTRYP PFNGLTEXENVFVPROC)(GLenum target, GLenum pname, const GLfloat* params); + GLAPI PFNGLTEXENVFVPROC glad_glTexEnvfv; +#define glTexEnvfv glad_glTexEnvfv + typedef void (APIENTRYP PFNGLTEXENVIPROC)(GLenum target, GLenum pname, GLint param); + GLAPI PFNGLTEXENVIPROC glad_glTexEnvi; +#define glTexEnvi glad_glTexEnvi + typedef void (APIENTRYP PFNGLTEXENVIVPROC)(GLenum target, GLenum pname, const GLint* params); + GLAPI PFNGLTEXENVIVPROC glad_glTexEnviv; +#define glTexEnviv glad_glTexEnviv + typedef void (APIENTRYP PFNGLTEXGENDPROC)(GLenum coord, GLenum pname, GLdouble param); + GLAPI PFNGLTEXGENDPROC glad_glTexGend; +#define glTexGend glad_glTexGend + typedef void (APIENTRYP PFNGLTEXGENDVPROC)(GLenum coord, GLenum pname, const GLdouble* params); + GLAPI PFNGLTEXGENDVPROC glad_glTexGendv; +#define glTexGendv glad_glTexGendv + typedef void (APIENTRYP PFNGLTEXGENFPROC)(GLenum coord, GLenum pname, GLfloat param); + GLAPI PFNGLTEXGENFPROC glad_glTexGenf; +#define glTexGenf glad_glTexGenf + typedef void (APIENTRYP PFNGLTEXGENFVPROC)(GLenum coord, GLenum pname, const GLfloat* params); + GLAPI PFNGLTEXGENFVPROC glad_glTexGenfv; +#define glTexGenfv glad_glTexGenfv + typedef void (APIENTRYP PFNGLTEXGENIPROC)(GLenum coord, GLenum pname, GLint param); + GLAPI PFNGLTEXGENIPROC glad_glTexGeni; +#define glTexGeni glad_glTexGeni + typedef void (APIENTRYP PFNGLTEXGENIVPROC)(GLenum coord, GLenum pname, const GLint* params); + GLAPI PFNGLTEXGENIVPROC glad_glTexGeniv; +#define glTexGeniv glad_glTexGeniv + typedef void (APIENTRYP PFNGLFEEDBACKBUFFERPROC)(GLsizei size, GLenum type, GLfloat* buffer); + GLAPI PFNGLFEEDBACKBUFFERPROC glad_glFeedbackBuffer; +#define glFeedbackBuffer glad_glFeedbackBuffer + typedef void (APIENTRYP PFNGLSELECTBUFFERPROC)(GLsizei size, GLuint* buffer); + GLAPI PFNGLSELECTBUFFERPROC glad_glSelectBuffer; +#define glSelectBuffer glad_glSelectBuffer + typedef GLint( APIENTRYP PFNGLRENDERMODEPROC )(GLenum mode); + GLAPI PFNGLRENDERMODEPROC glad_glRenderMode; +#define glRenderMode glad_glRenderMode + typedef void (APIENTRYP PFNGLINITNAMESPROC)(void); + GLAPI PFNGLINITNAMESPROC glad_glInitNames; +#define glInitNames glad_glInitNames + typedef void (APIENTRYP PFNGLLOADNAMEPROC)(GLuint name); + GLAPI PFNGLLOADNAMEPROC glad_glLoadName; +#define glLoadName glad_glLoadName + typedef void (APIENTRYP PFNGLPASSTHROUGHPROC)(GLfloat token); + GLAPI PFNGLPASSTHROUGHPROC glad_glPassThrough; +#define glPassThrough glad_glPassThrough + typedef void (APIENTRYP PFNGLPOPNAMEPROC)(void); + GLAPI PFNGLPOPNAMEPROC glad_glPopName; +#define glPopName glad_glPopName + typedef void (APIENTRYP PFNGLPUSHNAMEPROC)(GLuint name); + GLAPI PFNGLPUSHNAMEPROC glad_glPushName; +#define glPushName glad_glPushName + typedef void (APIENTRYP PFNGLCLEARACCUMPROC)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); + GLAPI PFNGLCLEARACCUMPROC glad_glClearAccum; +#define glClearAccum glad_glClearAccum + typedef void (APIENTRYP PFNGLCLEARINDEXPROC)(GLfloat c); + GLAPI PFNGLCLEARINDEXPROC glad_glClearIndex; +#define glClearIndex glad_glClearIndex + typedef void (APIENTRYP PFNGLINDEXMASKPROC)(GLuint mask); + GLAPI PFNGLINDEXMASKPROC glad_glIndexMask; +#define glIndexMask glad_glIndexMask + typedef void (APIENTRYP PFNGLACCUMPROC)(GLenum op, GLfloat value); + GLAPI PFNGLACCUMPROC glad_glAccum; +#define glAccum glad_glAccum + typedef void (APIENTRYP PFNGLPOPATTRIBPROC)(void); + GLAPI PFNGLPOPATTRIBPROC glad_glPopAttrib; +#define glPopAttrib glad_glPopAttrib + typedef void (APIENTRYP PFNGLPUSHATTRIBPROC)(GLbitfield mask); + GLAPI PFNGLPUSHATTRIBPROC glad_glPushAttrib; +#define glPushAttrib glad_glPushAttrib + typedef void (APIENTRYP PFNGLMAP1DPROC)(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble* points); + GLAPI PFNGLMAP1DPROC glad_glMap1d; +#define glMap1d glad_glMap1d + typedef void (APIENTRYP PFNGLMAP1FPROC)(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat* points); + GLAPI PFNGLMAP1FPROC glad_glMap1f; +#define glMap1f glad_glMap1f + typedef void (APIENTRYP PFNGLMAP2DPROC)(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble* points); + GLAPI PFNGLMAP2DPROC glad_glMap2d; +#define glMap2d glad_glMap2d + typedef void (APIENTRYP PFNGLMAP2FPROC)(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat* points); + GLAPI PFNGLMAP2FPROC glad_glMap2f; +#define glMap2f glad_glMap2f + typedef void (APIENTRYP PFNGLMAPGRID1DPROC)(GLint un, GLdouble u1, GLdouble u2); + GLAPI PFNGLMAPGRID1DPROC glad_glMapGrid1d; +#define glMapGrid1d glad_glMapGrid1d + typedef void (APIENTRYP PFNGLMAPGRID1FPROC)(GLint un, GLfloat u1, GLfloat u2); + GLAPI PFNGLMAPGRID1FPROC glad_glMapGrid1f; +#define glMapGrid1f glad_glMapGrid1f + typedef void (APIENTRYP PFNGLMAPGRID2DPROC)(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2); + GLAPI PFNGLMAPGRID2DPROC glad_glMapGrid2d; +#define glMapGrid2d glad_glMapGrid2d + typedef void (APIENTRYP PFNGLMAPGRID2FPROC)(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2); + GLAPI PFNGLMAPGRID2FPROC glad_glMapGrid2f; +#define glMapGrid2f glad_glMapGrid2f + typedef void (APIENTRYP PFNGLEVALCOORD1DPROC)(GLdouble u); + GLAPI PFNGLEVALCOORD1DPROC glad_glEvalCoord1d; +#define glEvalCoord1d glad_glEvalCoord1d + typedef void (APIENTRYP PFNGLEVALCOORD1DVPROC)(const GLdouble* u); + GLAPI PFNGLEVALCOORD1DVPROC glad_glEvalCoord1dv; +#define glEvalCoord1dv glad_glEvalCoord1dv + typedef void (APIENTRYP PFNGLEVALCOORD1FPROC)(GLfloat u); + GLAPI PFNGLEVALCOORD1FPROC glad_glEvalCoord1f; +#define glEvalCoord1f glad_glEvalCoord1f + typedef void (APIENTRYP PFNGLEVALCOORD1FVPROC)(const GLfloat* u); + GLAPI PFNGLEVALCOORD1FVPROC glad_glEvalCoord1fv; +#define glEvalCoord1fv glad_glEvalCoord1fv + typedef void (APIENTRYP PFNGLEVALCOORD2DPROC)(GLdouble u, GLdouble v); + GLAPI PFNGLEVALCOORD2DPROC glad_glEvalCoord2d; +#define glEvalCoord2d glad_glEvalCoord2d + typedef void (APIENTRYP PFNGLEVALCOORD2DVPROC)(const GLdouble* u); + GLAPI PFNGLEVALCOORD2DVPROC glad_glEvalCoord2dv; +#define glEvalCoord2dv glad_glEvalCoord2dv + typedef void (APIENTRYP PFNGLEVALCOORD2FPROC)(GLfloat u, GLfloat v); + GLAPI PFNGLEVALCOORD2FPROC glad_glEvalCoord2f; +#define glEvalCoord2f glad_glEvalCoord2f + typedef void (APIENTRYP PFNGLEVALCOORD2FVPROC)(const GLfloat* u); + GLAPI PFNGLEVALCOORD2FVPROC glad_glEvalCoord2fv; +#define glEvalCoord2fv glad_glEvalCoord2fv + typedef void (APIENTRYP PFNGLEVALMESH1PROC)(GLenum mode, GLint i1, GLint i2); + GLAPI PFNGLEVALMESH1PROC glad_glEvalMesh1; +#define glEvalMesh1 glad_glEvalMesh1 + typedef void (APIENTRYP PFNGLEVALPOINT1PROC)(GLint i); + GLAPI PFNGLEVALPOINT1PROC glad_glEvalPoint1; +#define glEvalPoint1 glad_glEvalPoint1 + typedef void (APIENTRYP PFNGLEVALMESH2PROC)(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2); + GLAPI PFNGLEVALMESH2PROC glad_glEvalMesh2; +#define glEvalMesh2 glad_glEvalMesh2 + typedef void (APIENTRYP PFNGLEVALPOINT2PROC)(GLint i, GLint j); + GLAPI PFNGLEVALPOINT2PROC glad_glEvalPoint2; +#define glEvalPoint2 glad_glEvalPoint2 + typedef void (APIENTRYP PFNGLALPHAFUNCPROC)(GLenum func, GLfloat ref); + GLAPI PFNGLALPHAFUNCPROC glad_glAlphaFunc; +#define glAlphaFunc glad_glAlphaFunc + typedef void (APIENTRYP PFNGLPIXELZOOMPROC)(GLfloat xfactor, GLfloat yfactor); + GLAPI PFNGLPIXELZOOMPROC glad_glPixelZoom; +#define glPixelZoom glad_glPixelZoom + typedef void (APIENTRYP PFNGLPIXELTRANSFERFPROC)(GLenum pname, GLfloat param); + GLAPI PFNGLPIXELTRANSFERFPROC glad_glPixelTransferf; +#define glPixelTransferf glad_glPixelTransferf + typedef void (APIENTRYP PFNGLPIXELTRANSFERIPROC)(GLenum pname, GLint param); + GLAPI PFNGLPIXELTRANSFERIPROC glad_glPixelTransferi; +#define glPixelTransferi glad_glPixelTransferi + typedef void (APIENTRYP PFNGLPIXELMAPFVPROC)(GLenum map, GLsizei mapsize, const GLfloat* values); + GLAPI PFNGLPIXELMAPFVPROC glad_glPixelMapfv; +#define glPixelMapfv glad_glPixelMapfv + typedef void (APIENTRYP PFNGLPIXELMAPUIVPROC)(GLenum map, GLsizei mapsize, const GLuint* values); + GLAPI PFNGLPIXELMAPUIVPROC glad_glPixelMapuiv; +#define glPixelMapuiv glad_glPixelMapuiv + typedef void (APIENTRYP PFNGLPIXELMAPUSVPROC)(GLenum map, GLsizei mapsize, const GLushort* values); + GLAPI PFNGLPIXELMAPUSVPROC glad_glPixelMapusv; +#define glPixelMapusv glad_glPixelMapusv + typedef void (APIENTRYP PFNGLCOPYPIXELSPROC)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type); + GLAPI PFNGLCOPYPIXELSPROC glad_glCopyPixels; +#define glCopyPixels glad_glCopyPixels + typedef void (APIENTRYP PFNGLDRAWPIXELSPROC)(GLsizei width, GLsizei height, GLenum format, GLenum type, const void* pixels); + GLAPI PFNGLDRAWPIXELSPROC glad_glDrawPixels; +#define glDrawPixels glad_glDrawPixels + typedef void (APIENTRYP PFNGLGETCLIPPLANEPROC)(GLenum plane, GLdouble* equation); + GLAPI PFNGLGETCLIPPLANEPROC glad_glGetClipPlane; +#define glGetClipPlane glad_glGetClipPlane + typedef void (APIENTRYP PFNGLGETLIGHTFVPROC)(GLenum light, GLenum pname, GLfloat* params); + GLAPI PFNGLGETLIGHTFVPROC glad_glGetLightfv; +#define glGetLightfv glad_glGetLightfv + typedef void (APIENTRYP PFNGLGETLIGHTIVPROC)(GLenum light, GLenum pname, GLint* params); + GLAPI PFNGLGETLIGHTIVPROC glad_glGetLightiv; +#define glGetLightiv glad_glGetLightiv + typedef void (APIENTRYP PFNGLGETMAPDVPROC)(GLenum target, GLenum query, GLdouble* v); + GLAPI PFNGLGETMAPDVPROC glad_glGetMapdv; +#define glGetMapdv glad_glGetMapdv + typedef void (APIENTRYP PFNGLGETMAPFVPROC)(GLenum target, GLenum query, GLfloat* v); + GLAPI PFNGLGETMAPFVPROC glad_glGetMapfv; +#define glGetMapfv glad_glGetMapfv + typedef void (APIENTRYP PFNGLGETMAPIVPROC)(GLenum target, GLenum query, GLint* v); + GLAPI PFNGLGETMAPIVPROC glad_glGetMapiv; +#define glGetMapiv glad_glGetMapiv + typedef void (APIENTRYP PFNGLGETMATERIALFVPROC)(GLenum face, GLenum pname, GLfloat* params); + GLAPI PFNGLGETMATERIALFVPROC glad_glGetMaterialfv; +#define glGetMaterialfv glad_glGetMaterialfv + typedef void (APIENTRYP PFNGLGETMATERIALIVPROC)(GLenum face, GLenum pname, GLint* params); + GLAPI PFNGLGETMATERIALIVPROC glad_glGetMaterialiv; +#define glGetMaterialiv glad_glGetMaterialiv + typedef void (APIENTRYP PFNGLGETPIXELMAPFVPROC)(GLenum map, GLfloat* values); + GLAPI PFNGLGETPIXELMAPFVPROC glad_glGetPixelMapfv; +#define glGetPixelMapfv glad_glGetPixelMapfv + typedef void (APIENTRYP PFNGLGETPIXELMAPUIVPROC)(GLenum map, GLuint* values); + GLAPI PFNGLGETPIXELMAPUIVPROC glad_glGetPixelMapuiv; +#define glGetPixelMapuiv glad_glGetPixelMapuiv + typedef void (APIENTRYP PFNGLGETPIXELMAPUSVPROC)(GLenum map, GLushort* values); + GLAPI PFNGLGETPIXELMAPUSVPROC glad_glGetPixelMapusv; +#define glGetPixelMapusv glad_glGetPixelMapusv + typedef void (APIENTRYP PFNGLGETPOLYGONSTIPPLEPROC)(GLubyte* mask); + GLAPI PFNGLGETPOLYGONSTIPPLEPROC glad_glGetPolygonStipple; +#define glGetPolygonStipple glad_glGetPolygonStipple + typedef void (APIENTRYP PFNGLGETTEXENVFVPROC)(GLenum target, GLenum pname, GLfloat* params); + GLAPI PFNGLGETTEXENVFVPROC glad_glGetTexEnvfv; +#define glGetTexEnvfv glad_glGetTexEnvfv + typedef void (APIENTRYP PFNGLGETTEXENVIVPROC)(GLenum target, GLenum pname, GLint* params); + GLAPI PFNGLGETTEXENVIVPROC glad_glGetTexEnviv; +#define glGetTexEnviv glad_glGetTexEnviv + typedef void (APIENTRYP PFNGLGETTEXGENDVPROC)(GLenum coord, GLenum pname, GLdouble* params); + GLAPI PFNGLGETTEXGENDVPROC glad_glGetTexGendv; +#define glGetTexGendv glad_glGetTexGendv + typedef void (APIENTRYP PFNGLGETTEXGENFVPROC)(GLenum coord, GLenum pname, GLfloat* params); + GLAPI PFNGLGETTEXGENFVPROC glad_glGetTexGenfv; +#define glGetTexGenfv glad_glGetTexGenfv + typedef void (APIENTRYP PFNGLGETTEXGENIVPROC)(GLenum coord, GLenum pname, GLint* params); + GLAPI PFNGLGETTEXGENIVPROC glad_glGetTexGeniv; +#define glGetTexGeniv glad_glGetTexGeniv + typedef GLboolean( APIENTRYP PFNGLISLISTPROC )(GLuint list); + GLAPI PFNGLISLISTPROC glad_glIsList; +#define glIsList glad_glIsList + typedef void (APIENTRYP PFNGLFRUSTUMPROC)(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); + GLAPI PFNGLFRUSTUMPROC glad_glFrustum; +#define glFrustum glad_glFrustum + typedef void (APIENTRYP PFNGLLOADIDENTITYPROC)(void); + GLAPI PFNGLLOADIDENTITYPROC glad_glLoadIdentity; +#define glLoadIdentity glad_glLoadIdentity + typedef void (APIENTRYP PFNGLLOADMATRIXFPROC)(const GLfloat* m); + GLAPI PFNGLLOADMATRIXFPROC glad_glLoadMatrixf; +#define glLoadMatrixf glad_glLoadMatrixf + typedef void (APIENTRYP PFNGLLOADMATRIXDPROC)(const GLdouble* m); + GLAPI PFNGLLOADMATRIXDPROC glad_glLoadMatrixd; +#define glLoadMatrixd glad_glLoadMatrixd + typedef void (APIENTRYP PFNGLMATRIXMODEPROC)(GLenum mode); + GLAPI PFNGLMATRIXMODEPROC glad_glMatrixMode; +#define glMatrixMode glad_glMatrixMode + typedef void (APIENTRYP PFNGLMULTMATRIXFPROC)(const GLfloat* m); + GLAPI PFNGLMULTMATRIXFPROC glad_glMultMatrixf; +#define glMultMatrixf glad_glMultMatrixf + typedef void (APIENTRYP PFNGLMULTMATRIXDPROC)(const GLdouble* m); + GLAPI PFNGLMULTMATRIXDPROC glad_glMultMatrixd; +#define glMultMatrixd glad_glMultMatrixd + typedef void (APIENTRYP PFNGLORTHOPROC)(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); + GLAPI PFNGLORTHOPROC glad_glOrtho; +#define glOrtho glad_glOrtho + typedef void (APIENTRYP PFNGLPOPMATRIXPROC)(void); + GLAPI PFNGLPOPMATRIXPROC glad_glPopMatrix; +#define glPopMatrix glad_glPopMatrix + typedef void (APIENTRYP PFNGLPUSHMATRIXPROC)(void); + GLAPI PFNGLPUSHMATRIXPROC glad_glPushMatrix; +#define glPushMatrix glad_glPushMatrix + typedef void (APIENTRYP PFNGLROTATEDPROC)(GLdouble angle, GLdouble x, GLdouble y, GLdouble z); + GLAPI PFNGLROTATEDPROC glad_glRotated; +#define glRotated glad_glRotated + typedef void (APIENTRYP PFNGLROTATEFPROC)(GLfloat angle, GLfloat x, GLfloat y, GLfloat z); + GLAPI PFNGLROTATEFPROC glad_glRotatef; +#define glRotatef glad_glRotatef + typedef void (APIENTRYP PFNGLSCALEDPROC)(GLdouble x, GLdouble y, GLdouble z); + GLAPI PFNGLSCALEDPROC glad_glScaled; +#define glScaled glad_glScaled + typedef void (APIENTRYP PFNGLSCALEFPROC)(GLfloat x, GLfloat y, GLfloat z); + GLAPI PFNGLSCALEFPROC glad_glScalef; +#define glScalef glad_glScalef + typedef void (APIENTRYP PFNGLTRANSLATEDPROC)(GLdouble x, GLdouble y, GLdouble z); + GLAPI PFNGLTRANSLATEDPROC glad_glTranslated; +#define glTranslated glad_glTranslated + typedef void (APIENTRYP PFNGLTRANSLATEFPROC)(GLfloat x, GLfloat y, GLfloat z); + GLAPI PFNGLTRANSLATEFPROC glad_glTranslatef; +#define glTranslatef glad_glTranslatef +#endif +#ifndef GL_VERSION_1_1 +#define GL_VERSION_1_1 1 + GLAPI int GLAD_GL_VERSION_1_1; + typedef void (APIENTRYP PFNGLDRAWARRAYSPROC)(GLenum mode, GLint first, GLsizei count); + GLAPI PFNGLDRAWARRAYSPROC glad_glDrawArrays; +#define glDrawArrays glad_glDrawArrays + typedef void (APIENTRYP PFNGLDRAWELEMENTSPROC)(GLenum mode, GLsizei count, GLenum type, const void* indices); + GLAPI PFNGLDRAWELEMENTSPROC glad_glDrawElements; +#define glDrawElements glad_glDrawElements + typedef void (APIENTRYP PFNGLGETPOINTERVPROC)(GLenum pname, void** params); + GLAPI PFNGLGETPOINTERVPROC glad_glGetPointerv; +#define glGetPointerv glad_glGetPointerv + typedef void (APIENTRYP PFNGLPOLYGONOFFSETPROC)(GLfloat factor, GLfloat units); + GLAPI PFNGLPOLYGONOFFSETPROC glad_glPolygonOffset; +#define glPolygonOffset glad_glPolygonOffset + typedef void (APIENTRYP PFNGLCOPYTEXIMAGE1DPROC)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border); + GLAPI PFNGLCOPYTEXIMAGE1DPROC glad_glCopyTexImage1D; +#define glCopyTexImage1D glad_glCopyTexImage1D + typedef void (APIENTRYP PFNGLCOPYTEXIMAGE2DPROC)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); + GLAPI PFNGLCOPYTEXIMAGE2DPROC glad_glCopyTexImage2D; +#define glCopyTexImage2D glad_glCopyTexImage2D + typedef void (APIENTRYP PFNGLCOPYTEXSUBIMAGE1DPROC)(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width); + GLAPI PFNGLCOPYTEXSUBIMAGE1DPROC glad_glCopyTexSubImage1D; +#define glCopyTexSubImage1D glad_glCopyTexSubImage1D + typedef void (APIENTRYP PFNGLCOPYTEXSUBIMAGE2DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); + GLAPI PFNGLCOPYTEXSUBIMAGE2DPROC glad_glCopyTexSubImage2D; +#define glCopyTexSubImage2D glad_glCopyTexSubImage2D + typedef void (APIENTRYP PFNGLTEXSUBIMAGE1DPROC)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void* pixels); + GLAPI PFNGLTEXSUBIMAGE1DPROC glad_glTexSubImage1D; +#define glTexSubImage1D glad_glTexSubImage1D + typedef void (APIENTRYP PFNGLTEXSUBIMAGE2DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* pixels); + GLAPI PFNGLTEXSUBIMAGE2DPROC glad_glTexSubImage2D; +#define glTexSubImage2D glad_glTexSubImage2D + typedef void (APIENTRYP PFNGLBINDTEXTUREPROC)(GLenum target, GLuint texture); + GLAPI PFNGLBINDTEXTUREPROC glad_glBindTexture; +#define glBindTexture glad_glBindTexture + typedef void (APIENTRYP PFNGLDELETETEXTURESPROC)(GLsizei n, const GLuint* textures); + GLAPI PFNGLDELETETEXTURESPROC glad_glDeleteTextures; +#define glDeleteTextures glad_glDeleteTextures + typedef void (APIENTRYP PFNGLGENTEXTURESPROC)(GLsizei n, GLuint* textures); + GLAPI PFNGLGENTEXTURESPROC glad_glGenTextures; +#define glGenTextures glad_glGenTextures + typedef GLboolean( APIENTRYP PFNGLISTEXTUREPROC )(GLuint texture); + GLAPI PFNGLISTEXTUREPROC glad_glIsTexture; +#define glIsTexture glad_glIsTexture + typedef void (APIENTRYP PFNGLARRAYELEMENTPROC)(GLint i); + GLAPI PFNGLARRAYELEMENTPROC glad_glArrayElement; +#define glArrayElement glad_glArrayElement + typedef void (APIENTRYP PFNGLCOLORPOINTERPROC)(GLint size, GLenum type, GLsizei stride, const void* pointer); + GLAPI PFNGLCOLORPOINTERPROC glad_glColorPointer; +#define glColorPointer glad_glColorPointer + typedef void (APIENTRYP PFNGLDISABLECLIENTSTATEPROC)(GLenum array); + GLAPI PFNGLDISABLECLIENTSTATEPROC glad_glDisableClientState; +#define glDisableClientState glad_glDisableClientState + typedef void (APIENTRYP PFNGLEDGEFLAGPOINTERPROC)(GLsizei stride, const void* pointer); + GLAPI PFNGLEDGEFLAGPOINTERPROC glad_glEdgeFlagPointer; +#define glEdgeFlagPointer glad_glEdgeFlagPointer + typedef void (APIENTRYP PFNGLENABLECLIENTSTATEPROC)(GLenum array); + GLAPI PFNGLENABLECLIENTSTATEPROC glad_glEnableClientState; +#define glEnableClientState glad_glEnableClientState + typedef void (APIENTRYP PFNGLINDEXPOINTERPROC)(GLenum type, GLsizei stride, const void* pointer); + GLAPI PFNGLINDEXPOINTERPROC glad_glIndexPointer; +#define glIndexPointer glad_glIndexPointer + typedef void (APIENTRYP PFNGLINTERLEAVEDARRAYSPROC)(GLenum format, GLsizei stride, const void* pointer); + GLAPI PFNGLINTERLEAVEDARRAYSPROC glad_glInterleavedArrays; +#define glInterleavedArrays glad_glInterleavedArrays + typedef void (APIENTRYP PFNGLNORMALPOINTERPROC)(GLenum type, GLsizei stride, const void* pointer); + GLAPI PFNGLNORMALPOINTERPROC glad_glNormalPointer; +#define glNormalPointer glad_glNormalPointer + typedef void (APIENTRYP PFNGLTEXCOORDPOINTERPROC)(GLint size, GLenum type, GLsizei stride, const void* pointer); + GLAPI PFNGLTEXCOORDPOINTERPROC glad_glTexCoordPointer; +#define glTexCoordPointer glad_glTexCoordPointer + typedef void (APIENTRYP PFNGLVERTEXPOINTERPROC)(GLint size, GLenum type, GLsizei stride, const void* pointer); + GLAPI PFNGLVERTEXPOINTERPROC glad_glVertexPointer; +#define glVertexPointer glad_glVertexPointer + typedef GLboolean( APIENTRYP PFNGLARETEXTURESRESIDENTPROC )(GLsizei n, const GLuint* textures, GLboolean* residences); + GLAPI PFNGLARETEXTURESRESIDENTPROC glad_glAreTexturesResident; +#define glAreTexturesResident glad_glAreTexturesResident + typedef void (APIENTRYP PFNGLPRIORITIZETEXTURESPROC)(GLsizei n, const GLuint* textures, const GLfloat* priorities); + GLAPI PFNGLPRIORITIZETEXTURESPROC glad_glPrioritizeTextures; +#define glPrioritizeTextures glad_glPrioritizeTextures + typedef void (APIENTRYP PFNGLINDEXUBPROC)(GLubyte c); + GLAPI PFNGLINDEXUBPROC glad_glIndexub; +#define glIndexub glad_glIndexub + typedef void (APIENTRYP PFNGLINDEXUBVPROC)(const GLubyte* c); + GLAPI PFNGLINDEXUBVPROC glad_glIndexubv; +#define glIndexubv glad_glIndexubv + typedef void (APIENTRYP PFNGLPOPCLIENTATTRIBPROC)(void); + GLAPI PFNGLPOPCLIENTATTRIBPROC glad_glPopClientAttrib; +#define glPopClientAttrib glad_glPopClientAttrib + typedef void (APIENTRYP PFNGLPUSHCLIENTATTRIBPROC)(GLbitfield mask); + GLAPI PFNGLPUSHCLIENTATTRIBPROC glad_glPushClientAttrib; +#define glPushClientAttrib glad_glPushClientAttrib +#endif +#ifndef GL_VERSION_1_2 +#define GL_VERSION_1_2 1 + GLAPI int GLAD_GL_VERSION_1_2; + typedef void (APIENTRYP PFNGLDRAWRANGEELEMENTSPROC)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void* indices); + GLAPI PFNGLDRAWRANGEELEMENTSPROC glad_glDrawRangeElements; +#define glDrawRangeElements glad_glDrawRangeElements + typedef void (APIENTRYP PFNGLTEXIMAGE3DPROC)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void* pixels); + GLAPI PFNGLTEXIMAGE3DPROC glad_glTexImage3D; +#define glTexImage3D glad_glTexImage3D + typedef void (APIENTRYP PFNGLTEXSUBIMAGE3DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void* pixels); + GLAPI PFNGLTEXSUBIMAGE3DPROC glad_glTexSubImage3D; +#define glTexSubImage3D glad_glTexSubImage3D + typedef void (APIENTRYP PFNGLCOPYTEXSUBIMAGE3DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); + GLAPI PFNGLCOPYTEXSUBIMAGE3DPROC glad_glCopyTexSubImage3D; +#define glCopyTexSubImage3D glad_glCopyTexSubImage3D +#endif +#ifndef GL_VERSION_1_3 +#define GL_VERSION_1_3 1 + GLAPI int GLAD_GL_VERSION_1_3; + typedef void (APIENTRYP PFNGLACTIVETEXTUREPROC)(GLenum texture); + GLAPI PFNGLACTIVETEXTUREPROC glad_glActiveTexture; +#define glActiveTexture glad_glActiveTexture + typedef void (APIENTRYP PFNGLSAMPLECOVERAGEPROC)(GLfloat value, GLboolean invert); + GLAPI PFNGLSAMPLECOVERAGEPROC glad_glSampleCoverage; +#define glSampleCoverage glad_glSampleCoverage + typedef void (APIENTRYP PFNGLCOMPRESSEDTEXIMAGE3DPROC)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void* data); + GLAPI PFNGLCOMPRESSEDTEXIMAGE3DPROC glad_glCompressedTexImage3D; +#define glCompressedTexImage3D glad_glCompressedTexImage3D + typedef void (APIENTRYP PFNGLCOMPRESSEDTEXIMAGE2DPROC)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void* data); + GLAPI PFNGLCOMPRESSEDTEXIMAGE2DPROC glad_glCompressedTexImage2D; +#define glCompressedTexImage2D glad_glCompressedTexImage2D + typedef void (APIENTRYP PFNGLCOMPRESSEDTEXIMAGE1DPROC)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void* data); + GLAPI PFNGLCOMPRESSEDTEXIMAGE1DPROC glad_glCompressedTexImage1D; +#define glCompressedTexImage1D glad_glCompressedTexImage1D + typedef void (APIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void* data); + GLAPI PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC glad_glCompressedTexSubImage3D; +#define glCompressedTexSubImage3D glad_glCompressedTexSubImage3D + typedef void (APIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void* data); + GLAPI PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC glad_glCompressedTexSubImage2D; +#define glCompressedTexSubImage2D glad_glCompressedTexSubImage2D + typedef void (APIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void* data); + GLAPI PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC glad_glCompressedTexSubImage1D; +#define glCompressedTexSubImage1D glad_glCompressedTexSubImage1D + typedef void (APIENTRYP PFNGLGETCOMPRESSEDTEXIMAGEPROC)(GLenum target, GLint level, void* img); + GLAPI PFNGLGETCOMPRESSEDTEXIMAGEPROC glad_glGetCompressedTexImage; +#define glGetCompressedTexImage glad_glGetCompressedTexImage + typedef void (APIENTRYP PFNGLCLIENTACTIVETEXTUREPROC)(GLenum texture); + GLAPI PFNGLCLIENTACTIVETEXTUREPROC glad_glClientActiveTexture; +#define glClientActiveTexture glad_glClientActiveTexture + typedef void (APIENTRYP PFNGLMULTITEXCOORD1DPROC)(GLenum target, GLdouble s); + GLAPI PFNGLMULTITEXCOORD1DPROC glad_glMultiTexCoord1d; +#define glMultiTexCoord1d glad_glMultiTexCoord1d + typedef void (APIENTRYP PFNGLMULTITEXCOORD1DVPROC)(GLenum target, const GLdouble* v); + GLAPI PFNGLMULTITEXCOORD1DVPROC glad_glMultiTexCoord1dv; +#define glMultiTexCoord1dv glad_glMultiTexCoord1dv + typedef void (APIENTRYP PFNGLMULTITEXCOORD1FPROC)(GLenum target, GLfloat s); + GLAPI PFNGLMULTITEXCOORD1FPROC glad_glMultiTexCoord1f; +#define glMultiTexCoord1f glad_glMultiTexCoord1f + typedef void (APIENTRYP PFNGLMULTITEXCOORD1FVPROC)(GLenum target, const GLfloat* v); + GLAPI PFNGLMULTITEXCOORD1FVPROC glad_glMultiTexCoord1fv; +#define glMultiTexCoord1fv glad_glMultiTexCoord1fv + typedef void (APIENTRYP PFNGLMULTITEXCOORD1IPROC)(GLenum target, GLint s); + GLAPI PFNGLMULTITEXCOORD1IPROC glad_glMultiTexCoord1i; +#define glMultiTexCoord1i glad_glMultiTexCoord1i + typedef void (APIENTRYP PFNGLMULTITEXCOORD1IVPROC)(GLenum target, const GLint* v); + GLAPI PFNGLMULTITEXCOORD1IVPROC glad_glMultiTexCoord1iv; +#define glMultiTexCoord1iv glad_glMultiTexCoord1iv + typedef void (APIENTRYP PFNGLMULTITEXCOORD1SPROC)(GLenum target, GLshort s); + GLAPI PFNGLMULTITEXCOORD1SPROC glad_glMultiTexCoord1s; +#define glMultiTexCoord1s glad_glMultiTexCoord1s + typedef void (APIENTRYP PFNGLMULTITEXCOORD1SVPROC)(GLenum target, const GLshort* v); + GLAPI PFNGLMULTITEXCOORD1SVPROC glad_glMultiTexCoord1sv; +#define glMultiTexCoord1sv glad_glMultiTexCoord1sv + typedef void (APIENTRYP PFNGLMULTITEXCOORD2DPROC)(GLenum target, GLdouble s, GLdouble t); + GLAPI PFNGLMULTITEXCOORD2DPROC glad_glMultiTexCoord2d; +#define glMultiTexCoord2d glad_glMultiTexCoord2d + typedef void (APIENTRYP PFNGLMULTITEXCOORD2DVPROC)(GLenum target, const GLdouble* v); + GLAPI PFNGLMULTITEXCOORD2DVPROC glad_glMultiTexCoord2dv; +#define glMultiTexCoord2dv glad_glMultiTexCoord2dv + typedef void (APIENTRYP PFNGLMULTITEXCOORD2FPROC)(GLenum target, GLfloat s, GLfloat t); + GLAPI PFNGLMULTITEXCOORD2FPROC glad_glMultiTexCoord2f; +#define glMultiTexCoord2f glad_glMultiTexCoord2f + typedef void (APIENTRYP PFNGLMULTITEXCOORD2FVPROC)(GLenum target, const GLfloat* v); + GLAPI PFNGLMULTITEXCOORD2FVPROC glad_glMultiTexCoord2fv; +#define glMultiTexCoord2fv glad_glMultiTexCoord2fv + typedef void (APIENTRYP PFNGLMULTITEXCOORD2IPROC)(GLenum target, GLint s, GLint t); + GLAPI PFNGLMULTITEXCOORD2IPROC glad_glMultiTexCoord2i; +#define glMultiTexCoord2i glad_glMultiTexCoord2i + typedef void (APIENTRYP PFNGLMULTITEXCOORD2IVPROC)(GLenum target, const GLint* v); + GLAPI PFNGLMULTITEXCOORD2IVPROC glad_glMultiTexCoord2iv; +#define glMultiTexCoord2iv glad_glMultiTexCoord2iv + typedef void (APIENTRYP PFNGLMULTITEXCOORD2SPROC)(GLenum target, GLshort s, GLshort t); + GLAPI PFNGLMULTITEXCOORD2SPROC glad_glMultiTexCoord2s; +#define glMultiTexCoord2s glad_glMultiTexCoord2s + typedef void (APIENTRYP PFNGLMULTITEXCOORD2SVPROC)(GLenum target, const GLshort* v); + GLAPI PFNGLMULTITEXCOORD2SVPROC glad_glMultiTexCoord2sv; +#define glMultiTexCoord2sv glad_glMultiTexCoord2sv + typedef void (APIENTRYP PFNGLMULTITEXCOORD3DPROC)(GLenum target, GLdouble s, GLdouble t, GLdouble r); + GLAPI PFNGLMULTITEXCOORD3DPROC glad_glMultiTexCoord3d; +#define glMultiTexCoord3d glad_glMultiTexCoord3d + typedef void (APIENTRYP PFNGLMULTITEXCOORD3DVPROC)(GLenum target, const GLdouble* v); + GLAPI PFNGLMULTITEXCOORD3DVPROC glad_glMultiTexCoord3dv; +#define glMultiTexCoord3dv glad_glMultiTexCoord3dv + typedef void (APIENTRYP PFNGLMULTITEXCOORD3FPROC)(GLenum target, GLfloat s, GLfloat t, GLfloat r); + GLAPI PFNGLMULTITEXCOORD3FPROC glad_glMultiTexCoord3f; +#define glMultiTexCoord3f glad_glMultiTexCoord3f + typedef void (APIENTRYP PFNGLMULTITEXCOORD3FVPROC)(GLenum target, const GLfloat* v); + GLAPI PFNGLMULTITEXCOORD3FVPROC glad_glMultiTexCoord3fv; +#define glMultiTexCoord3fv glad_glMultiTexCoord3fv + typedef void (APIENTRYP PFNGLMULTITEXCOORD3IPROC)(GLenum target, GLint s, GLint t, GLint r); + GLAPI PFNGLMULTITEXCOORD3IPROC glad_glMultiTexCoord3i; +#define glMultiTexCoord3i glad_glMultiTexCoord3i + typedef void (APIENTRYP PFNGLMULTITEXCOORD3IVPROC)(GLenum target, const GLint* v); + GLAPI PFNGLMULTITEXCOORD3IVPROC glad_glMultiTexCoord3iv; +#define glMultiTexCoord3iv glad_glMultiTexCoord3iv + typedef void (APIENTRYP PFNGLMULTITEXCOORD3SPROC)(GLenum target, GLshort s, GLshort t, GLshort r); + GLAPI PFNGLMULTITEXCOORD3SPROC glad_glMultiTexCoord3s; +#define glMultiTexCoord3s glad_glMultiTexCoord3s + typedef void (APIENTRYP PFNGLMULTITEXCOORD3SVPROC)(GLenum target, const GLshort* v); + GLAPI PFNGLMULTITEXCOORD3SVPROC glad_glMultiTexCoord3sv; +#define glMultiTexCoord3sv glad_glMultiTexCoord3sv + typedef void (APIENTRYP PFNGLMULTITEXCOORD4DPROC)(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q); + GLAPI PFNGLMULTITEXCOORD4DPROC glad_glMultiTexCoord4d; +#define glMultiTexCoord4d glad_glMultiTexCoord4d + typedef void (APIENTRYP PFNGLMULTITEXCOORD4DVPROC)(GLenum target, const GLdouble* v); + GLAPI PFNGLMULTITEXCOORD4DVPROC glad_glMultiTexCoord4dv; +#define glMultiTexCoord4dv glad_glMultiTexCoord4dv + typedef void (APIENTRYP PFNGLMULTITEXCOORD4FPROC)(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q); + GLAPI PFNGLMULTITEXCOORD4FPROC glad_glMultiTexCoord4f; +#define glMultiTexCoord4f glad_glMultiTexCoord4f + typedef void (APIENTRYP PFNGLMULTITEXCOORD4FVPROC)(GLenum target, const GLfloat* v); + GLAPI PFNGLMULTITEXCOORD4FVPROC glad_glMultiTexCoord4fv; +#define glMultiTexCoord4fv glad_glMultiTexCoord4fv + typedef void (APIENTRYP PFNGLMULTITEXCOORD4IPROC)(GLenum target, GLint s, GLint t, GLint r, GLint q); + GLAPI PFNGLMULTITEXCOORD4IPROC glad_glMultiTexCoord4i; +#define glMultiTexCoord4i glad_glMultiTexCoord4i + typedef void (APIENTRYP PFNGLMULTITEXCOORD4IVPROC)(GLenum target, const GLint* v); + GLAPI PFNGLMULTITEXCOORD4IVPROC glad_glMultiTexCoord4iv; +#define glMultiTexCoord4iv glad_glMultiTexCoord4iv + typedef void (APIENTRYP PFNGLMULTITEXCOORD4SPROC)(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q); + GLAPI PFNGLMULTITEXCOORD4SPROC glad_glMultiTexCoord4s; +#define glMultiTexCoord4s glad_glMultiTexCoord4s + typedef void (APIENTRYP PFNGLMULTITEXCOORD4SVPROC)(GLenum target, const GLshort* v); + GLAPI PFNGLMULTITEXCOORD4SVPROC glad_glMultiTexCoord4sv; +#define glMultiTexCoord4sv glad_glMultiTexCoord4sv + typedef void (APIENTRYP PFNGLLOADTRANSPOSEMATRIXFPROC)(const GLfloat* m); + GLAPI PFNGLLOADTRANSPOSEMATRIXFPROC glad_glLoadTransposeMatrixf; +#define glLoadTransposeMatrixf glad_glLoadTransposeMatrixf + typedef void (APIENTRYP PFNGLLOADTRANSPOSEMATRIXDPROC)(const GLdouble* m); + GLAPI PFNGLLOADTRANSPOSEMATRIXDPROC glad_glLoadTransposeMatrixd; +#define glLoadTransposeMatrixd glad_glLoadTransposeMatrixd + typedef void (APIENTRYP PFNGLMULTTRANSPOSEMATRIXFPROC)(const GLfloat* m); + GLAPI PFNGLMULTTRANSPOSEMATRIXFPROC glad_glMultTransposeMatrixf; +#define glMultTransposeMatrixf glad_glMultTransposeMatrixf + typedef void (APIENTRYP PFNGLMULTTRANSPOSEMATRIXDPROC)(const GLdouble* m); + GLAPI PFNGLMULTTRANSPOSEMATRIXDPROC glad_glMultTransposeMatrixd; +#define glMultTransposeMatrixd glad_glMultTransposeMatrixd +#endif +#ifndef GL_VERSION_1_4 +#define GL_VERSION_1_4 1 + GLAPI int GLAD_GL_VERSION_1_4; + typedef void (APIENTRYP PFNGLBLENDFUNCSEPARATEPROC)(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha); + GLAPI PFNGLBLENDFUNCSEPARATEPROC glad_glBlendFuncSeparate; +#define glBlendFuncSeparate glad_glBlendFuncSeparate + typedef void (APIENTRYP PFNGLMULTIDRAWARRAYSPROC)(GLenum mode, const GLint* first, const GLsizei* count, GLsizei drawcount); + GLAPI PFNGLMULTIDRAWARRAYSPROC glad_glMultiDrawArrays; +#define glMultiDrawArrays glad_glMultiDrawArrays + typedef void (APIENTRYP PFNGLMULTIDRAWELEMENTSPROC)(GLenum mode, const GLsizei* count, GLenum type, const void* const* indices, GLsizei drawcount); + GLAPI PFNGLMULTIDRAWELEMENTSPROC glad_glMultiDrawElements; +#define glMultiDrawElements glad_glMultiDrawElements + typedef void (APIENTRYP PFNGLPOINTPARAMETERFPROC)(GLenum pname, GLfloat param); + GLAPI PFNGLPOINTPARAMETERFPROC glad_glPointParameterf; +#define glPointParameterf glad_glPointParameterf + typedef void (APIENTRYP PFNGLPOINTPARAMETERFVPROC)(GLenum pname, const GLfloat* params); + GLAPI PFNGLPOINTPARAMETERFVPROC glad_glPointParameterfv; +#define glPointParameterfv glad_glPointParameterfv + typedef void (APIENTRYP PFNGLPOINTPARAMETERIPROC)(GLenum pname, GLint param); + GLAPI PFNGLPOINTPARAMETERIPROC glad_glPointParameteri; +#define glPointParameteri glad_glPointParameteri + typedef void (APIENTRYP PFNGLPOINTPARAMETERIVPROC)(GLenum pname, const GLint* params); + GLAPI PFNGLPOINTPARAMETERIVPROC glad_glPointParameteriv; +#define glPointParameteriv glad_glPointParameteriv + typedef void (APIENTRYP PFNGLFOGCOORDFPROC)(GLfloat coord); + GLAPI PFNGLFOGCOORDFPROC glad_glFogCoordf; +#define glFogCoordf glad_glFogCoordf + typedef void (APIENTRYP PFNGLFOGCOORDFVPROC)(const GLfloat* coord); + GLAPI PFNGLFOGCOORDFVPROC glad_glFogCoordfv; +#define glFogCoordfv glad_glFogCoordfv + typedef void (APIENTRYP PFNGLFOGCOORDDPROC)(GLdouble coord); + GLAPI PFNGLFOGCOORDDPROC glad_glFogCoordd; +#define glFogCoordd glad_glFogCoordd + typedef void (APIENTRYP PFNGLFOGCOORDDVPROC)(const GLdouble* coord); + GLAPI PFNGLFOGCOORDDVPROC glad_glFogCoorddv; +#define glFogCoorddv glad_glFogCoorddv + typedef void (APIENTRYP PFNGLFOGCOORDPOINTERPROC)(GLenum type, GLsizei stride, const void* pointer); + GLAPI PFNGLFOGCOORDPOINTERPROC glad_glFogCoordPointer; +#define glFogCoordPointer glad_glFogCoordPointer + typedef void (APIENTRYP PFNGLSECONDARYCOLOR3BPROC)(GLbyte red, GLbyte green, GLbyte blue); + GLAPI PFNGLSECONDARYCOLOR3BPROC glad_glSecondaryColor3b; +#define glSecondaryColor3b glad_glSecondaryColor3b + typedef void (APIENTRYP PFNGLSECONDARYCOLOR3BVPROC)(const GLbyte* v); + GLAPI PFNGLSECONDARYCOLOR3BVPROC glad_glSecondaryColor3bv; +#define glSecondaryColor3bv glad_glSecondaryColor3bv + typedef void (APIENTRYP PFNGLSECONDARYCOLOR3DPROC)(GLdouble red, GLdouble green, GLdouble blue); + GLAPI PFNGLSECONDARYCOLOR3DPROC glad_glSecondaryColor3d; +#define glSecondaryColor3d glad_glSecondaryColor3d + typedef void (APIENTRYP PFNGLSECONDARYCOLOR3DVPROC)(const GLdouble* v); + GLAPI PFNGLSECONDARYCOLOR3DVPROC glad_glSecondaryColor3dv; +#define glSecondaryColor3dv glad_glSecondaryColor3dv + typedef void (APIENTRYP PFNGLSECONDARYCOLOR3FPROC)(GLfloat red, GLfloat green, GLfloat blue); + GLAPI PFNGLSECONDARYCOLOR3FPROC glad_glSecondaryColor3f; +#define glSecondaryColor3f glad_glSecondaryColor3f + typedef void (APIENTRYP PFNGLSECONDARYCOLOR3FVPROC)(const GLfloat* v); + GLAPI PFNGLSECONDARYCOLOR3FVPROC glad_glSecondaryColor3fv; +#define glSecondaryColor3fv glad_glSecondaryColor3fv + typedef void (APIENTRYP PFNGLSECONDARYCOLOR3IPROC)(GLint red, GLint green, GLint blue); + GLAPI PFNGLSECONDARYCOLOR3IPROC glad_glSecondaryColor3i; +#define glSecondaryColor3i glad_glSecondaryColor3i + typedef void (APIENTRYP PFNGLSECONDARYCOLOR3IVPROC)(const GLint* v); + GLAPI PFNGLSECONDARYCOLOR3IVPROC glad_glSecondaryColor3iv; +#define glSecondaryColor3iv glad_glSecondaryColor3iv + typedef void (APIENTRYP PFNGLSECONDARYCOLOR3SPROC)(GLshort red, GLshort green, GLshort blue); + GLAPI PFNGLSECONDARYCOLOR3SPROC glad_glSecondaryColor3s; +#define glSecondaryColor3s glad_glSecondaryColor3s + typedef void (APIENTRYP PFNGLSECONDARYCOLOR3SVPROC)(const GLshort* v); + GLAPI PFNGLSECONDARYCOLOR3SVPROC glad_glSecondaryColor3sv; +#define glSecondaryColor3sv glad_glSecondaryColor3sv + typedef void (APIENTRYP PFNGLSECONDARYCOLOR3UBPROC)(GLubyte red, GLubyte green, GLubyte blue); + GLAPI PFNGLSECONDARYCOLOR3UBPROC glad_glSecondaryColor3ub; +#define glSecondaryColor3ub glad_glSecondaryColor3ub + typedef void (APIENTRYP PFNGLSECONDARYCOLOR3UBVPROC)(const GLubyte* v); + GLAPI PFNGLSECONDARYCOLOR3UBVPROC glad_glSecondaryColor3ubv; +#define glSecondaryColor3ubv glad_glSecondaryColor3ubv + typedef void (APIENTRYP PFNGLSECONDARYCOLOR3UIPROC)(GLuint red, GLuint green, GLuint blue); + GLAPI PFNGLSECONDARYCOLOR3UIPROC glad_glSecondaryColor3ui; +#define glSecondaryColor3ui glad_glSecondaryColor3ui + typedef void (APIENTRYP PFNGLSECONDARYCOLOR3UIVPROC)(const GLuint* v); + GLAPI PFNGLSECONDARYCOLOR3UIVPROC glad_glSecondaryColor3uiv; +#define glSecondaryColor3uiv glad_glSecondaryColor3uiv + typedef void (APIENTRYP PFNGLSECONDARYCOLOR3USPROC)(GLushort red, GLushort green, GLushort blue); + GLAPI PFNGLSECONDARYCOLOR3USPROC glad_glSecondaryColor3us; +#define glSecondaryColor3us glad_glSecondaryColor3us + typedef void (APIENTRYP PFNGLSECONDARYCOLOR3USVPROC)(const GLushort* v); + GLAPI PFNGLSECONDARYCOLOR3USVPROC glad_glSecondaryColor3usv; +#define glSecondaryColor3usv glad_glSecondaryColor3usv + typedef void (APIENTRYP PFNGLSECONDARYCOLORPOINTERPROC)(GLint size, GLenum type, GLsizei stride, const void* pointer); + GLAPI PFNGLSECONDARYCOLORPOINTERPROC glad_glSecondaryColorPointer; +#define glSecondaryColorPointer glad_glSecondaryColorPointer + typedef void (APIENTRYP PFNGLWINDOWPOS2DPROC)(GLdouble x, GLdouble y); + GLAPI PFNGLWINDOWPOS2DPROC glad_glWindowPos2d; +#define glWindowPos2d glad_glWindowPos2d + typedef void (APIENTRYP PFNGLWINDOWPOS2DVPROC)(const GLdouble* v); + GLAPI PFNGLWINDOWPOS2DVPROC glad_glWindowPos2dv; +#define glWindowPos2dv glad_glWindowPos2dv + typedef void (APIENTRYP PFNGLWINDOWPOS2FPROC)(GLfloat x, GLfloat y); + GLAPI PFNGLWINDOWPOS2FPROC glad_glWindowPos2f; +#define glWindowPos2f glad_glWindowPos2f + typedef void (APIENTRYP PFNGLWINDOWPOS2FVPROC)(const GLfloat* v); + GLAPI PFNGLWINDOWPOS2FVPROC glad_glWindowPos2fv; +#define glWindowPos2fv glad_glWindowPos2fv + typedef void (APIENTRYP PFNGLWINDOWPOS2IPROC)(GLint x, GLint y); + GLAPI PFNGLWINDOWPOS2IPROC glad_glWindowPos2i; +#define glWindowPos2i glad_glWindowPos2i + typedef void (APIENTRYP PFNGLWINDOWPOS2IVPROC)(const GLint* v); + GLAPI PFNGLWINDOWPOS2IVPROC glad_glWindowPos2iv; +#define glWindowPos2iv glad_glWindowPos2iv + typedef void (APIENTRYP PFNGLWINDOWPOS2SPROC)(GLshort x, GLshort y); + GLAPI PFNGLWINDOWPOS2SPROC glad_glWindowPos2s; +#define glWindowPos2s glad_glWindowPos2s + typedef void (APIENTRYP PFNGLWINDOWPOS2SVPROC)(const GLshort* v); + GLAPI PFNGLWINDOWPOS2SVPROC glad_glWindowPos2sv; +#define glWindowPos2sv glad_glWindowPos2sv + typedef void (APIENTRYP PFNGLWINDOWPOS3DPROC)(GLdouble x, GLdouble y, GLdouble z); + GLAPI PFNGLWINDOWPOS3DPROC glad_glWindowPos3d; +#define glWindowPos3d glad_glWindowPos3d + typedef void (APIENTRYP PFNGLWINDOWPOS3DVPROC)(const GLdouble* v); + GLAPI PFNGLWINDOWPOS3DVPROC glad_glWindowPos3dv; +#define glWindowPos3dv glad_glWindowPos3dv + typedef void (APIENTRYP PFNGLWINDOWPOS3FPROC)(GLfloat x, GLfloat y, GLfloat z); + GLAPI PFNGLWINDOWPOS3FPROC glad_glWindowPos3f; +#define glWindowPos3f glad_glWindowPos3f + typedef void (APIENTRYP PFNGLWINDOWPOS3FVPROC)(const GLfloat* v); + GLAPI PFNGLWINDOWPOS3FVPROC glad_glWindowPos3fv; +#define glWindowPos3fv glad_glWindowPos3fv + typedef void (APIENTRYP PFNGLWINDOWPOS3IPROC)(GLint x, GLint y, GLint z); + GLAPI PFNGLWINDOWPOS3IPROC glad_glWindowPos3i; +#define glWindowPos3i glad_glWindowPos3i + typedef void (APIENTRYP PFNGLWINDOWPOS3IVPROC)(const GLint* v); + GLAPI PFNGLWINDOWPOS3IVPROC glad_glWindowPos3iv; +#define glWindowPos3iv glad_glWindowPos3iv + typedef void (APIENTRYP PFNGLWINDOWPOS3SPROC)(GLshort x, GLshort y, GLshort z); + GLAPI PFNGLWINDOWPOS3SPROC glad_glWindowPos3s; +#define glWindowPos3s glad_glWindowPos3s + typedef void (APIENTRYP PFNGLWINDOWPOS3SVPROC)(const GLshort* v); + GLAPI PFNGLWINDOWPOS3SVPROC glad_glWindowPos3sv; +#define glWindowPos3sv glad_glWindowPos3sv + typedef void (APIENTRYP PFNGLBLENDCOLORPROC)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); + GLAPI PFNGLBLENDCOLORPROC glad_glBlendColor; +#define glBlendColor glad_glBlendColor + typedef void (APIENTRYP PFNGLBLENDEQUATIONPROC)(GLenum mode); + GLAPI PFNGLBLENDEQUATIONPROC glad_glBlendEquation; +#define glBlendEquation glad_glBlendEquation +#endif +#ifndef GL_VERSION_1_5 +#define GL_VERSION_1_5 1 + GLAPI int GLAD_GL_VERSION_1_5; + typedef void (APIENTRYP PFNGLGENQUERIESPROC)(GLsizei n, GLuint* ids); + GLAPI PFNGLGENQUERIESPROC glad_glGenQueries; +#define glGenQueries glad_glGenQueries + typedef void (APIENTRYP PFNGLDELETEQUERIESPROC)(GLsizei n, const GLuint* ids); + GLAPI PFNGLDELETEQUERIESPROC glad_glDeleteQueries; +#define glDeleteQueries glad_glDeleteQueries + typedef GLboolean( APIENTRYP PFNGLISQUERYPROC )(GLuint id); + GLAPI PFNGLISQUERYPROC glad_glIsQuery; +#define glIsQuery glad_glIsQuery + typedef void (APIENTRYP PFNGLBEGINQUERYPROC)(GLenum target, GLuint id); + GLAPI PFNGLBEGINQUERYPROC glad_glBeginQuery; +#define glBeginQuery glad_glBeginQuery + typedef void (APIENTRYP PFNGLENDQUERYPROC)(GLenum target); + GLAPI PFNGLENDQUERYPROC glad_glEndQuery; +#define glEndQuery glad_glEndQuery + typedef void (APIENTRYP PFNGLGETQUERYIVPROC)(GLenum target, GLenum pname, GLint* params); + GLAPI PFNGLGETQUERYIVPROC glad_glGetQueryiv; +#define glGetQueryiv glad_glGetQueryiv + typedef void (APIENTRYP PFNGLGETQUERYOBJECTIVPROC)(GLuint id, GLenum pname, GLint* params); + GLAPI PFNGLGETQUERYOBJECTIVPROC glad_glGetQueryObjectiv; +#define glGetQueryObjectiv glad_glGetQueryObjectiv + typedef void (APIENTRYP PFNGLGETQUERYOBJECTUIVPROC)(GLuint id, GLenum pname, GLuint* params); + GLAPI PFNGLGETQUERYOBJECTUIVPROC glad_glGetQueryObjectuiv; +#define glGetQueryObjectuiv glad_glGetQueryObjectuiv + typedef void (APIENTRYP PFNGLBINDBUFFERPROC)(GLenum target, GLuint buffer); + GLAPI PFNGLBINDBUFFERPROC glad_glBindBuffer; +#define glBindBuffer glad_glBindBuffer + typedef void (APIENTRYP PFNGLDELETEBUFFERSPROC)(GLsizei n, const GLuint* buffers); + GLAPI PFNGLDELETEBUFFERSPROC glad_glDeleteBuffers; +#define glDeleteBuffers glad_glDeleteBuffers + typedef void (APIENTRYP PFNGLGENBUFFERSPROC)(GLsizei n, GLuint* buffers); + GLAPI PFNGLGENBUFFERSPROC glad_glGenBuffers; +#define glGenBuffers glad_glGenBuffers + typedef GLboolean( APIENTRYP PFNGLISBUFFERPROC )(GLuint buffer); + GLAPI PFNGLISBUFFERPROC glad_glIsBuffer; +#define glIsBuffer glad_glIsBuffer + typedef void (APIENTRYP PFNGLBUFFERDATAPROC)(GLenum target, GLsizeiptr size, const void* data, GLenum usage); + GLAPI PFNGLBUFFERDATAPROC glad_glBufferData; +#define glBufferData glad_glBufferData + typedef void (APIENTRYP PFNGLBUFFERSUBDATAPROC)(GLenum target, GLintptr offset, GLsizeiptr size, const void* data); + GLAPI PFNGLBUFFERSUBDATAPROC glad_glBufferSubData; +#define glBufferSubData glad_glBufferSubData + typedef void (APIENTRYP PFNGLGETBUFFERSUBDATAPROC)(GLenum target, GLintptr offset, GLsizeiptr size, void* data); + GLAPI PFNGLGETBUFFERSUBDATAPROC glad_glGetBufferSubData; +#define glGetBufferSubData glad_glGetBufferSubData + typedef void* (APIENTRYP PFNGLMAPBUFFERPROC)(GLenum target, GLenum access); + GLAPI PFNGLMAPBUFFERPROC glad_glMapBuffer; +#define glMapBuffer glad_glMapBuffer + typedef GLboolean( APIENTRYP PFNGLUNMAPBUFFERPROC )(GLenum target); + GLAPI PFNGLUNMAPBUFFERPROC glad_glUnmapBuffer; +#define glUnmapBuffer glad_glUnmapBuffer + typedef void (APIENTRYP PFNGLGETBUFFERPARAMETERIVPROC)(GLenum target, GLenum pname, GLint* params); + GLAPI PFNGLGETBUFFERPARAMETERIVPROC glad_glGetBufferParameteriv; +#define glGetBufferParameteriv glad_glGetBufferParameteriv + typedef void (APIENTRYP PFNGLGETBUFFERPOINTERVPROC)(GLenum target, GLenum pname, void** params); + GLAPI PFNGLGETBUFFERPOINTERVPROC glad_glGetBufferPointerv; +#define glGetBufferPointerv glad_glGetBufferPointerv +#endif +#ifndef GL_VERSION_2_0 +#define GL_VERSION_2_0 1 + GLAPI int GLAD_GL_VERSION_2_0; + typedef void (APIENTRYP PFNGLBLENDEQUATIONSEPARATEPROC)(GLenum modeRGB, GLenum modeAlpha); + GLAPI PFNGLBLENDEQUATIONSEPARATEPROC glad_glBlendEquationSeparate; +#define glBlendEquationSeparate glad_glBlendEquationSeparate + typedef void (APIENTRYP PFNGLDRAWBUFFERSPROC)(GLsizei n, const GLenum* bufs); + GLAPI PFNGLDRAWBUFFERSPROC glad_glDrawBuffers; +#define glDrawBuffers glad_glDrawBuffers + typedef void (APIENTRYP PFNGLSTENCILOPSEPARATEPROC)(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass); + GLAPI PFNGLSTENCILOPSEPARATEPROC glad_glStencilOpSeparate; +#define glStencilOpSeparate glad_glStencilOpSeparate + typedef void (APIENTRYP PFNGLSTENCILFUNCSEPARATEPROC)(GLenum face, GLenum func, GLint ref, GLuint mask); + GLAPI PFNGLSTENCILFUNCSEPARATEPROC glad_glStencilFuncSeparate; +#define glStencilFuncSeparate glad_glStencilFuncSeparate + typedef void (APIENTRYP PFNGLSTENCILMASKSEPARATEPROC)(GLenum face, GLuint mask); + GLAPI PFNGLSTENCILMASKSEPARATEPROC glad_glStencilMaskSeparate; +#define glStencilMaskSeparate glad_glStencilMaskSeparate + typedef void (APIENTRYP PFNGLATTACHSHADERPROC)(GLuint program, GLuint shader); + GLAPI PFNGLATTACHSHADERPROC glad_glAttachShader; +#define glAttachShader glad_glAttachShader + typedef void (APIENTRYP PFNGLBINDATTRIBLOCATIONPROC)(GLuint program, GLuint index, const GLchar* name); + GLAPI PFNGLBINDATTRIBLOCATIONPROC glad_glBindAttribLocation; +#define glBindAttribLocation glad_glBindAttribLocation + typedef void (APIENTRYP PFNGLCOMPILESHADERPROC)(GLuint shader); + GLAPI PFNGLCOMPILESHADERPROC glad_glCompileShader; +#define glCompileShader glad_glCompileShader + typedef GLuint( APIENTRYP PFNGLCREATEPROGRAMPROC )(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 bufSize, GLsizei* length, GLint* values); + GLAPI PFNGLGETSYNCIVPROC glad_glGetSynciv; +#define glGetSynciv glad_glGetSynciv + typedef void (APIENTRYP PFNGLGETINTEGER64I_VPROC)(GLenum target, GLuint index, GLint64* data); + GLAPI PFNGLGETINTEGER64I_VPROC glad_glGetInteger64i_v; +#define glGetInteger64i_v glad_glGetInteger64i_v + typedef void (APIENTRYP PFNGLGETBUFFERPARAMETERI64VPROC)(GLenum target, GLenum pname, GLint64* params); + GLAPI PFNGLGETBUFFERPARAMETERI64VPROC glad_glGetBufferParameteri64v; +#define glGetBufferParameteri64v glad_glGetBufferParameteri64v + typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTUREPROC)(GLenum target, GLenum attachment, GLuint texture, GLint level); + GLAPI PFNGLFRAMEBUFFERTEXTUREPROC glad_glFramebufferTexture; +#define glFramebufferTexture glad_glFramebufferTexture + typedef void (APIENTRYP PFNGLTEXIMAGE2DMULTISAMPLEPROC)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations); + GLAPI PFNGLTEXIMAGE2DMULTISAMPLEPROC glad_glTexImage2DMultisample; +#define glTexImage2DMultisample glad_glTexImage2DMultisample + typedef void (APIENTRYP PFNGLTEXIMAGE3DMULTISAMPLEPROC)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations); + GLAPI PFNGLTEXIMAGE3DMULTISAMPLEPROC glad_glTexImage3DMultisample; +#define glTexImage3DMultisample glad_glTexImage3DMultisample + typedef void (APIENTRYP PFNGLGETMULTISAMPLEFVPROC)(GLenum pname, GLuint index, GLfloat* val); + GLAPI PFNGLGETMULTISAMPLEFVPROC glad_glGetMultisamplefv; +#define glGetMultisamplefv glad_glGetMultisamplefv + typedef void (APIENTRYP PFNGLSAMPLEMASKIPROC)(GLuint maskNumber, GLbitfield mask); + GLAPI PFNGLSAMPLEMASKIPROC glad_glSampleMaski; +#define glSampleMaski glad_glSampleMaski +#endif +#ifndef GL_VERSION_3_3 +#define GL_VERSION_3_3 1 + GLAPI int GLAD_GL_VERSION_3_3; + typedef void (APIENTRYP PFNGLBINDFRAGDATALOCATIONINDEXEDPROC)(GLuint program, GLuint colorNumber, GLuint index, const GLchar* name); + GLAPI PFNGLBINDFRAGDATALOCATIONINDEXEDPROC glad_glBindFragDataLocationIndexed; +#define glBindFragDataLocationIndexed glad_glBindFragDataLocationIndexed + typedef GLint( APIENTRYP PFNGLGETFRAGDATAINDEXPROC )(GLuint program, const GLchar* name); + GLAPI PFNGLGETFRAGDATAINDEXPROC glad_glGetFragDataIndex; +#define glGetFragDataIndex glad_glGetFragDataIndex + typedef void (APIENTRYP PFNGLGENSAMPLERSPROC)(GLsizei count, GLuint* samplers); + GLAPI PFNGLGENSAMPLERSPROC glad_glGenSamplers; +#define glGenSamplers glad_glGenSamplers + typedef void (APIENTRYP PFNGLDELETESAMPLERSPROC)(GLsizei count, const GLuint* samplers); + GLAPI PFNGLDELETESAMPLERSPROC glad_glDeleteSamplers; +#define glDeleteSamplers glad_glDeleteSamplers + typedef GLboolean( APIENTRYP PFNGLISSAMPLERPROC )(GLuint sampler); + GLAPI PFNGLISSAMPLERPROC glad_glIsSampler; +#define glIsSampler glad_glIsSampler + typedef void (APIENTRYP PFNGLBINDSAMPLERPROC)(GLuint unit, GLuint sampler); + GLAPI PFNGLBINDSAMPLERPROC glad_glBindSampler; +#define glBindSampler glad_glBindSampler + typedef void (APIENTRYP PFNGLSAMPLERPARAMETERIPROC)(GLuint sampler, GLenum pname, GLint param); + GLAPI PFNGLSAMPLERPARAMETERIPROC glad_glSamplerParameteri; +#define glSamplerParameteri glad_glSamplerParameteri + typedef void (APIENTRYP PFNGLSAMPLERPARAMETERIVPROC)(GLuint sampler, GLenum pname, const GLint* param); + GLAPI PFNGLSAMPLERPARAMETERIVPROC glad_glSamplerParameteriv; +#define glSamplerParameteriv glad_glSamplerParameteriv + typedef void (APIENTRYP PFNGLSAMPLERPARAMETERFPROC)(GLuint sampler, GLenum pname, GLfloat param); + GLAPI PFNGLSAMPLERPARAMETERFPROC glad_glSamplerParameterf; +#define glSamplerParameterf glad_glSamplerParameterf + typedef void (APIENTRYP PFNGLSAMPLERPARAMETERFVPROC)(GLuint sampler, GLenum pname, const GLfloat* param); + GLAPI PFNGLSAMPLERPARAMETERFVPROC glad_glSamplerParameterfv; +#define glSamplerParameterfv glad_glSamplerParameterfv + typedef void (APIENTRYP PFNGLSAMPLERPARAMETERIIVPROC)(GLuint sampler, GLenum pname, const GLint* param); + GLAPI PFNGLSAMPLERPARAMETERIIVPROC glad_glSamplerParameterIiv; +#define glSamplerParameterIiv glad_glSamplerParameterIiv + typedef void (APIENTRYP PFNGLSAMPLERPARAMETERIUIVPROC)(GLuint sampler, GLenum pname, const GLuint* param); + GLAPI PFNGLSAMPLERPARAMETERIUIVPROC glad_glSamplerParameterIuiv; +#define glSamplerParameterIuiv glad_glSamplerParameterIuiv + typedef void (APIENTRYP PFNGLGETSAMPLERPARAMETERIVPROC)(GLuint sampler, GLenum pname, GLint* params); + GLAPI PFNGLGETSAMPLERPARAMETERIVPROC glad_glGetSamplerParameteriv; +#define glGetSamplerParameteriv glad_glGetSamplerParameteriv + typedef void (APIENTRYP PFNGLGETSAMPLERPARAMETERIIVPROC)(GLuint sampler, GLenum pname, GLint* params); + GLAPI PFNGLGETSAMPLERPARAMETERIIVPROC glad_glGetSamplerParameterIiv; +#define glGetSamplerParameterIiv glad_glGetSamplerParameterIiv + typedef void (APIENTRYP PFNGLGETSAMPLERPARAMETERFVPROC)(GLuint sampler, GLenum pname, GLfloat* params); + GLAPI PFNGLGETSAMPLERPARAMETERFVPROC glad_glGetSamplerParameterfv; +#define glGetSamplerParameterfv glad_glGetSamplerParameterfv + typedef void (APIENTRYP PFNGLGETSAMPLERPARAMETERIUIVPROC)(GLuint sampler, GLenum pname, GLuint* params); + GLAPI PFNGLGETSAMPLERPARAMETERIUIVPROC glad_glGetSamplerParameterIuiv; +#define glGetSamplerParameterIuiv glad_glGetSamplerParameterIuiv + typedef void (APIENTRYP PFNGLQUERYCOUNTERPROC)(GLuint id, GLenum target); + GLAPI PFNGLQUERYCOUNTERPROC glad_glQueryCounter; +#define glQueryCounter glad_glQueryCounter + typedef void (APIENTRYP PFNGLGETQUERYOBJECTI64VPROC)(GLuint id, GLenum pname, GLint64* params); + GLAPI PFNGLGETQUERYOBJECTI64VPROC glad_glGetQueryObjecti64v; +#define glGetQueryObjecti64v glad_glGetQueryObjecti64v + typedef void (APIENTRYP PFNGLGETQUERYOBJECTUI64VPROC)(GLuint id, GLenum pname, GLuint64* params); + GLAPI PFNGLGETQUERYOBJECTUI64VPROC glad_glGetQueryObjectui64v; +#define glGetQueryObjectui64v glad_glGetQueryObjectui64v + typedef void (APIENTRYP PFNGLVERTEXATTRIBDIVISORPROC)(GLuint index, GLuint divisor); + GLAPI PFNGLVERTEXATTRIBDIVISORPROC glad_glVertexAttribDivisor; +#define glVertexAttribDivisor glad_glVertexAttribDivisor + typedef void (APIENTRYP PFNGLVERTEXATTRIBP1UIPROC)(GLuint index, GLenum type, GLboolean normalized, GLuint value); + GLAPI PFNGLVERTEXATTRIBP1UIPROC glad_glVertexAttribP1ui; +#define glVertexAttribP1ui glad_glVertexAttribP1ui + typedef void (APIENTRYP PFNGLVERTEXATTRIBP1UIVPROC)(GLuint index, GLenum type, GLboolean normalized, const GLuint* value); + GLAPI PFNGLVERTEXATTRIBP1UIVPROC glad_glVertexAttribP1uiv; +#define glVertexAttribP1uiv glad_glVertexAttribP1uiv + typedef void (APIENTRYP PFNGLVERTEXATTRIBP2UIPROC)(GLuint index, GLenum type, GLboolean normalized, GLuint value); + GLAPI PFNGLVERTEXATTRIBP2UIPROC glad_glVertexAttribP2ui; +#define glVertexAttribP2ui glad_glVertexAttribP2ui + typedef void (APIENTRYP PFNGLVERTEXATTRIBP2UIVPROC)(GLuint index, GLenum type, GLboolean normalized, const GLuint* value); + GLAPI PFNGLVERTEXATTRIBP2UIVPROC glad_glVertexAttribP2uiv; +#define glVertexAttribP2uiv glad_glVertexAttribP2uiv + typedef void (APIENTRYP PFNGLVERTEXATTRIBP3UIPROC)(GLuint index, GLenum type, GLboolean normalized, GLuint value); + GLAPI PFNGLVERTEXATTRIBP3UIPROC glad_glVertexAttribP3ui; +#define glVertexAttribP3ui glad_glVertexAttribP3ui + typedef void (APIENTRYP PFNGLVERTEXATTRIBP3UIVPROC)(GLuint index, GLenum type, GLboolean normalized, const GLuint* value); + GLAPI PFNGLVERTEXATTRIBP3UIVPROC glad_glVertexAttribP3uiv; +#define glVertexAttribP3uiv glad_glVertexAttribP3uiv + typedef void (APIENTRYP PFNGLVERTEXATTRIBP4UIPROC)(GLuint index, GLenum type, GLboolean normalized, GLuint value); + GLAPI PFNGLVERTEXATTRIBP4UIPROC glad_glVertexAttribP4ui; +#define glVertexAttribP4ui glad_glVertexAttribP4ui + typedef void (APIENTRYP PFNGLVERTEXATTRIBP4UIVPROC)(GLuint index, GLenum type, GLboolean normalized, const GLuint* value); + GLAPI PFNGLVERTEXATTRIBP4UIVPROC glad_glVertexAttribP4uiv; +#define glVertexAttribP4uiv glad_glVertexAttribP4uiv + typedef void (APIENTRYP PFNGLVERTEXP2UIPROC)(GLenum type, GLuint value); + GLAPI PFNGLVERTEXP2UIPROC glad_glVertexP2ui; +#define glVertexP2ui glad_glVertexP2ui + typedef void (APIENTRYP PFNGLVERTEXP2UIVPROC)(GLenum type, const GLuint* value); + GLAPI PFNGLVERTEXP2UIVPROC glad_glVertexP2uiv; +#define glVertexP2uiv glad_glVertexP2uiv + typedef void (APIENTRYP PFNGLVERTEXP3UIPROC)(GLenum type, GLuint value); + GLAPI PFNGLVERTEXP3UIPROC glad_glVertexP3ui; +#define glVertexP3ui glad_glVertexP3ui + typedef void (APIENTRYP PFNGLVERTEXP3UIVPROC)(GLenum type, const GLuint* value); + GLAPI PFNGLVERTEXP3UIVPROC glad_glVertexP3uiv; +#define glVertexP3uiv glad_glVertexP3uiv + typedef void (APIENTRYP PFNGLVERTEXP4UIPROC)(GLenum type, GLuint value); + GLAPI PFNGLVERTEXP4UIPROC glad_glVertexP4ui; +#define glVertexP4ui glad_glVertexP4ui + typedef void (APIENTRYP PFNGLVERTEXP4UIVPROC)(GLenum type, const GLuint* value); + GLAPI PFNGLVERTEXP4UIVPROC glad_glVertexP4uiv; +#define glVertexP4uiv glad_glVertexP4uiv + typedef void (APIENTRYP PFNGLTEXCOORDP1UIPROC)(GLenum type, GLuint coords); + GLAPI PFNGLTEXCOORDP1UIPROC glad_glTexCoordP1ui; +#define glTexCoordP1ui glad_glTexCoordP1ui + typedef void (APIENTRYP PFNGLTEXCOORDP1UIVPROC)(GLenum type, const GLuint* coords); + GLAPI PFNGLTEXCOORDP1UIVPROC glad_glTexCoordP1uiv; +#define glTexCoordP1uiv glad_glTexCoordP1uiv + typedef void (APIENTRYP PFNGLTEXCOORDP2UIPROC)(GLenum type, GLuint coords); + GLAPI PFNGLTEXCOORDP2UIPROC glad_glTexCoordP2ui; +#define glTexCoordP2ui glad_glTexCoordP2ui + typedef void (APIENTRYP PFNGLTEXCOORDP2UIVPROC)(GLenum type, const GLuint* coords); + GLAPI PFNGLTEXCOORDP2UIVPROC glad_glTexCoordP2uiv; +#define glTexCoordP2uiv glad_glTexCoordP2uiv + typedef void (APIENTRYP PFNGLTEXCOORDP3UIPROC)(GLenum type, GLuint coords); + GLAPI PFNGLTEXCOORDP3UIPROC glad_glTexCoordP3ui; +#define glTexCoordP3ui glad_glTexCoordP3ui + typedef void (APIENTRYP PFNGLTEXCOORDP3UIVPROC)(GLenum type, const GLuint* coords); + GLAPI PFNGLTEXCOORDP3UIVPROC glad_glTexCoordP3uiv; +#define glTexCoordP3uiv glad_glTexCoordP3uiv + typedef void (APIENTRYP PFNGLTEXCOORDP4UIPROC)(GLenum type, GLuint coords); + GLAPI PFNGLTEXCOORDP4UIPROC glad_glTexCoordP4ui; +#define glTexCoordP4ui glad_glTexCoordP4ui + typedef void (APIENTRYP PFNGLTEXCOORDP4UIVPROC)(GLenum type, const GLuint* coords); + GLAPI PFNGLTEXCOORDP4UIVPROC glad_glTexCoordP4uiv; +#define glTexCoordP4uiv glad_glTexCoordP4uiv + typedef void (APIENTRYP PFNGLMULTITEXCOORDP1UIPROC)(GLenum texture, GLenum type, GLuint coords); + GLAPI PFNGLMULTITEXCOORDP1UIPROC glad_glMultiTexCoordP1ui; +#define glMultiTexCoordP1ui glad_glMultiTexCoordP1ui + typedef void (APIENTRYP PFNGLMULTITEXCOORDP1UIVPROC)(GLenum texture, GLenum type, const GLuint* coords); + GLAPI PFNGLMULTITEXCOORDP1UIVPROC glad_glMultiTexCoordP1uiv; +#define glMultiTexCoordP1uiv glad_glMultiTexCoordP1uiv + typedef void (APIENTRYP PFNGLMULTITEXCOORDP2UIPROC)(GLenum texture, GLenum type, GLuint coords); + GLAPI PFNGLMULTITEXCOORDP2UIPROC glad_glMultiTexCoordP2ui; +#define glMultiTexCoordP2ui glad_glMultiTexCoordP2ui + typedef void (APIENTRYP PFNGLMULTITEXCOORDP2UIVPROC)(GLenum texture, GLenum type, const GLuint* coords); + GLAPI PFNGLMULTITEXCOORDP2UIVPROC glad_glMultiTexCoordP2uiv; +#define glMultiTexCoordP2uiv glad_glMultiTexCoordP2uiv + typedef void (APIENTRYP PFNGLMULTITEXCOORDP3UIPROC)(GLenum texture, GLenum type, GLuint coords); + GLAPI PFNGLMULTITEXCOORDP3UIPROC glad_glMultiTexCoordP3ui; +#define glMultiTexCoordP3ui glad_glMultiTexCoordP3ui + typedef void (APIENTRYP PFNGLMULTITEXCOORDP3UIVPROC)(GLenum texture, GLenum type, const GLuint* coords); + GLAPI PFNGLMULTITEXCOORDP3UIVPROC glad_glMultiTexCoordP3uiv; +#define glMultiTexCoordP3uiv glad_glMultiTexCoordP3uiv + typedef void (APIENTRYP PFNGLMULTITEXCOORDP4UIPROC)(GLenum texture, GLenum type, GLuint coords); + GLAPI PFNGLMULTITEXCOORDP4UIPROC glad_glMultiTexCoordP4ui; +#define glMultiTexCoordP4ui glad_glMultiTexCoordP4ui + typedef void (APIENTRYP PFNGLMULTITEXCOORDP4UIVPROC)(GLenum texture, GLenum type, const GLuint* coords); + GLAPI PFNGLMULTITEXCOORDP4UIVPROC glad_glMultiTexCoordP4uiv; +#define glMultiTexCoordP4uiv glad_glMultiTexCoordP4uiv + typedef void (APIENTRYP PFNGLNORMALP3UIPROC)(GLenum type, GLuint coords); + GLAPI PFNGLNORMALP3UIPROC glad_glNormalP3ui; +#define glNormalP3ui glad_glNormalP3ui + typedef void (APIENTRYP PFNGLNORMALP3UIVPROC)(GLenum type, const GLuint* coords); + GLAPI PFNGLNORMALP3UIVPROC glad_glNormalP3uiv; +#define glNormalP3uiv glad_glNormalP3uiv + typedef void (APIENTRYP PFNGLCOLORP3UIPROC)(GLenum type, GLuint color); + GLAPI PFNGLCOLORP3UIPROC glad_glColorP3ui; +#define glColorP3ui glad_glColorP3ui + typedef void (APIENTRYP PFNGLCOLORP3UIVPROC)(GLenum type, const GLuint* color); + GLAPI PFNGLCOLORP3UIVPROC glad_glColorP3uiv; +#define glColorP3uiv glad_glColorP3uiv + typedef void (APIENTRYP PFNGLCOLORP4UIPROC)(GLenum type, GLuint color); + GLAPI PFNGLCOLORP4UIPROC glad_glColorP4ui; +#define glColorP4ui glad_glColorP4ui + typedef void (APIENTRYP PFNGLCOLORP4UIVPROC)(GLenum type, const GLuint* color); + GLAPI PFNGLCOLORP4UIVPROC glad_glColorP4uiv; +#define glColorP4uiv glad_glColorP4uiv + typedef void (APIENTRYP PFNGLSECONDARYCOLORP3UIPROC)(GLenum type, GLuint color); + GLAPI PFNGLSECONDARYCOLORP3UIPROC glad_glSecondaryColorP3ui; +#define glSecondaryColorP3ui glad_glSecondaryColorP3ui + typedef void (APIENTRYP PFNGLSECONDARYCOLORP3UIVPROC)(GLenum type, const GLuint* color); + GLAPI PFNGLSECONDARYCOLORP3UIVPROC glad_glSecondaryColorP3uiv; +#define glSecondaryColorP3uiv glad_glSecondaryColorP3uiv +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/Aeon/ThirdParty/khrplatform.h b/Aeon/ThirdParty/khrplatform.h new file mode 100644 index 0000000..97cae7f --- /dev/null +++ b/Aeon/ThirdParty/khrplatform.h @@ -0,0 +1,282 @@ +#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; + */ + + /*------------------------------------------------------------------------- + * Definition of KHRONOS_APICALL + *------------------------------------------------------------------------- + * This precedes the return type of the function in the function prototype. + */ +#if defined(_WIN32) && !defined(__SCITECH_SNAP__) +# 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 + +#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 _WIN64 +typedef signed long long int khronos_intptr_t; +typedef unsigned long long int khronos_uintptr_t; +typedef signed long long int khronos_ssize_t; +typedef unsigned long long int khronos_usize_t; +#else +typedef signed long int khronos_intptr_t; +typedef unsigned long int khronos_uintptr_t; +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_ */ \ No newline at end of file diff --git a/CMakeLists.txt b/CMakeLists.txt index 4669b82..cdf0aef 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,50 +1,53 @@ cmake_minimum_required(VERSION 3.7) -project(AEON CXX) +project(AEON) -set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} CMakeModules/) -cmake_policy(SET CMP0037 OLD) # alow for spaces in file names +set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/CMakeModules/") set(CMAKE_CXX_STANDARD 20) set(CMAKE_CXX_STANDARD_REQUIRED ON) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++20") -# set(CMAKE_BUILD_TYPE Debug) -# set(CMAKE_CXX_FLAGS "-Ofast") - -# Adds RESOURCES constant in C++ -add_definitions(-DRESOURCES="${CMAKE_SOURCE_DIR}/resources/") -message(${CMAKE_SOURCE_DIR}/resources) - -set(exe out) - -file(GLOB EngineSource - Aeon/*.cpp - Aeon/ThirdParty/*.cpp - Aeon/Maths/*.cpp -) - -#temp -file (GLOB GameSource - Game/*.cpp -) - set(THREADS_PREFER_PTHREAD_FLAD ON) find_package(Threads REQUIRED) # Find GL and GLX package find_package(OpenGL REQUIRED) +find_package(SDL2 REQUIRED) -include_directories(".") -include_directories(${WinSDK}) +# Adds RESOURCES constant in C++ +add_definitions(-DRESOURCES="${CMAKE_SOURCE_DIR}/resources/") +message(${CMAKE_SOURCE_DIR}/resources) -add_executable(Aeon - ${EngineSource} ${GameSource} +set(Aeon Aeon) + +file(GLOB EngineSource + Aeon/*.cpp + Aeon/Core/*.cpp + Aeon/Maths/*.cpp + Aeon/Profiling/*.cpp + Aeon/ThirdParty/*.cpp + Aeon/ThirdParty/*.c ) -link_libraries(${exe} - Threads::Threads - OpenGL::OpenGL - OpenGL::GL - OpenGL::GLX +#temp +file(GLOB GameSource + Game/*.cpp +) + +include_directories(${Aeon} + "." ${WinSDK} + ${SDL2_INCLUDE_DIRS} +) + +add_executable(${Aeon} + ${EngineSource} + ${GameSource} +) + +target_link_libraries(${Aeon} + ${WinSDK} + ${SDL2_LIBRARIES} + Threads::Threads + OpenGL::GL ) diff --git a/CMakeModules/FindSDL2.cmake b/CMakeModules/FindSDL2.cmake new file mode 100644 index 0000000..641d1f7 --- /dev/null +++ b/CMakeModules/FindSDL2.cmake @@ -0,0 +1,197 @@ +# Distributed under the OSI-approved BSD 3-Clause License. See accompanying +# file Copyright.txt or https://cmake.org/licensing for details. + +#.rst: +# FindSDL2 +# ------- +# +# Locate SDL2 library +# +# This module defines +# +# :: +# +# SDL2_LIBRARY, the name of the library to link against +# SDL2_FOUND, if false, do not try to link to SDL +# SDL2_INCLUDE_DIR, where to find SDL.h +# SDL2_VERSION_STRING, human-readable string containing the version of SDL +# +# +# +# This module responds to the flag: +# +# :: +# +# SDL2_BUILDING_LIBRARY +# If this is defined, then no SDL2_main will be linked in because +# only applications need main(). +# Otherwise, it is assumed you are building an application and this +# module will attempt to locate and set the proper link flags +# as part of the returned SDL2_LIBRARY variable. +# +# +# +# Don't forget to include SDLmain.h and SDLmain.m your project for the +# OS X framework based version. (Other versions link to -lSDLmain which +# this module will try to find on your behalf.) Also for OS X, this +# module will automatically add the -framework Cocoa on your behalf. +# +# +# +# Additional Note: If you see an empty SDL2_LIBRARY_TEMP in your +# configuration and no SDL2_LIBRARY, it means CMake did not find your SDL +# library (SDL.dll, libsdl.so, SDL.framework, etc). Set +# SDL2_LIBRARY_TEMP to point to your SDL library, and configure again. +# Similarly, if you see an empty SDLMAIN_LIBRARY, you should set this +# value as appropriate. These values are used to generate the final +# SDL2_LIBRARY variable, but when these values are unset, SDL2_LIBRARY +# does not get created. +# +# +# +# $SDL2DIR is an environment variable that would correspond to the +# ./configure --prefix=$SDL2DIR used in building SDL. l.e.galup 9-20-02 +# +# Modified by Eric Wing. Added code to assist with automated building +# by using environmental variables and providing a more +# controlled/consistent search behavior. Added new modifications to +# recognize OS X frameworks and additional Unix paths (FreeBSD, etc). +# Also corrected the header search path to follow "proper" SDL +# guidelines. Added a search for SDLmain which is needed by some +# platforms. Added a search for threads which is needed by some +# platforms. Added needed compile switches for MinGW. +# +# On OSX, this will prefer the Framework version (if found) over others. +# People will have to manually change the cache values of SDL2_LIBRARY to +# override this selection or set the CMake environment +# CMAKE_INCLUDE_PATH to modify the search paths. +# +# Note that the header path has changed from SDL/SDL.h to just SDL.h +# This needed to change because "proper" SDL convention is #include +# "SDL.h", not . This is done for portability reasons +# because not all systems place things in SDL/ (see FreeBSD). + +if(NOT SDL2_DIR) + set(SDL2_DIR "" CACHE PATH "SDL2 directory") +endif() + +find_path(SDL2_INCLUDE_DIR SDL.h + HINTS + ENV SDL2DIR + ${SDL2_DIR} + PATH_SUFFIXES SDL2 + # path suffixes to search inside ENV{SDL2DIR} + include/SDL2 include +) + +# AWLAYS 64 bit +set(VC_LIB_PATH_SUFFIX lib/x64) + +find_library(SDL2_LIBRARY_TEMP + NAMES SDL2 + HINTS + ENV SDL2DIR + ${SDL2_DIR} + PATH_SUFFIXES lib ${VC_LIB_PATH_SUFFIX} +) + +# Hide this cache variable from the user, it's an internal implementation +# detail. The documented library variable for the user is SDL2_LIBRARY +# which is derived from SDL2_LIBRARY_TEMP further below. +set_property(CACHE SDL2_LIBRARY_TEMP PROPERTY TYPE INTERNAL) + +if(NOT SDL2_BUILDING_LIBRARY) + if(NOT SDL2_INCLUDE_DIR MATCHES ".framework") + # Non-OS X framework versions expect you to also dynamically link to + # SDLmain. This is mainly for Windows and OS X. Other (Unix) platforms + # seem to provide SDLmain for compatibility even though they don't + # necessarily need it. + find_library(SDL2MAIN_LIBRARY + NAMES SDL2main + HINTS + ENV SDL2DIR + ${SDL2_DIR} + PATH_SUFFIXES lib ${VC_LIB_PATH_SUFFIX} + PATHS + /sw + /opt/local + /opt/csw + /opt + ) + endif() +endif() + +# SDL may require threads on your system. +# The Apple build may not need an explicit flag because one of the +# frameworks may already provide it. +# But for non-OSX systems, I will use the CMake Threads package. +if(NOT APPLE) + find_package(Threads) +endif() + +# MinGW needs an additional link flag, -mwindows +# It's total link flags should look like -lmingw32 -lSDLmain -lSDL -mwindows +if(MINGW) + set(MINGW32_LIBRARY mingw32 "-mwindows" CACHE STRING "link flags for MinGW") +endif() + +if(SDL2_LIBRARY_TEMP) + # For SDLmain + if(SDL2MAIN_LIBRARY AND NOT SDL2_BUILDING_LIBRARY) + list(FIND SDL2_LIBRARY_TEMP "${SDLMAIN_LIBRARY}" _SDL2_MAIN_INDEX) + if(_SDL2_MAIN_INDEX EQUAL -1) + set(SDL2_LIBRARY_TEMP "${SDLMAIN_LIBRARY}" ${SDL2_LIBRARY_TEMP}) + endif() + unset(_SDL2_MAIN_INDEX) + endif() + + # For OS X, SDL uses Cocoa as a backend so it must link to Cocoa. + # CMake doesn't display the -framework Cocoa string in the UI even + # though it actually is there if I modify a pre-used variable. + # I think it has something to do with the CACHE STRING. + # So I use a temporary variable until the end so I can set the + # "real" variable in one-shot. + if(APPLE) + set(SDL2_LIBRARY_TEMP ${SDL2_LIBRARY_TEMP} "-framework Cocoa") + endif() + + # For threads, as mentioned Apple doesn't need this. + # In fact, there seems to be a problem if I used the Threads package + # and try using this line, so I'm just skipping it entirely for OS X. + if(NOT APPLE) + set(SDL2_LIBRARY_TEMP ${SDL2_LIBRARY_TEMP} ${CMAKE_THREAD_LIBS_INIT}) + endif() + + # For MinGW library + if(MINGW) + set(SDL2_LIBRARY_TEMP ${MINGW32_LIBRARY} ${SDL2_LIBRARY_TEMP}) + endif() + + # Set the final string here so the GUI reflects the final state. + set(SDL2_LIBRARY ${SDL2_LIBRARY_TEMP} CACHE STRING "Where the SDL Library can be found") +endif() + +if(SDL2_INCLUDE_DIR AND EXISTS "${SDL2_INCLUDE_DIR}/SDL2_version.h") + file(STRINGS "${SDL2_INCLUDE_DIR}/SDL2_version.h" SDL2_VERSION_MAJOR_LINE REGEX "^#define[ \t]+SDL2_MAJOR_VERSION[ \t]+[0-9]+$") + file(STRINGS "${SDL2_INCLUDE_DIR}/SDL2_version.h" SDL2_VERSION_MINOR_LINE REGEX "^#define[ \t]+SDL2_MINOR_VERSION[ \t]+[0-9]+$") + file(STRINGS "${SDL2_INCLUDE_DIR}/SDL2_version.h" SDL2_VERSION_PATCH_LINE REGEX "^#define[ \t]+SDL2_PATCHLEVEL[ \t]+[0-9]+$") + string(REGEX REPLACE "^#define[ \t]+SDL2_MAJOR_VERSION[ \t]+([0-9]+)$" "\\1" SDL2_VERSION_MAJOR "${SDL2_VERSION_MAJOR_LINE}") + string(REGEX REPLACE "^#define[ \t]+SDL2_MINOR_VERSION[ \t]+([0-9]+)$" "\\1" SDL2_VERSION_MINOR "${SDL2_VERSION_MINOR_LINE}") + string(REGEX REPLACE "^#define[ \t]+SDL2_PATCHLEVEL[ \t]+([0-9]+)$" "\\1" SDL2_VERSION_PATCH "${SDL2_VERSION_PATCH_LINE}") + set(SDL2_VERSION_STRING ${SDL2_VERSION_MAJOR}.${SDL2_VERSION_MINOR}.${SDL2_VERSION_PATCH}) + unset(SDL2_VERSION_MAJOR_LINE) + unset(SDL2_VERSION_MINOR_LINE) + unset(SDL2_VERSION_PATCH_LINE) + unset(SDL2_VERSION_MAJOR) + unset(SDL2_VERSION_MINOR) + unset(SDL2_VERSION_PATCH) +endif() + +set(SDL2_LIBRARIES ${SDL2_LIBRARY} ${SDL2MAIN_LIBRARY}) +set(SDL2_INCLUDE_DIRS ${SDL2_INCLUDE_DIR}) + +include(FindPackageHandleStandardArgs) + +FIND_PACKAGE_HANDLE_STANDARD_ARGS(SDL + REQUIRED_VARS SDL2_LIBRARY SDL2_INCLUDE_DIR + VERSION_VAR SDL2_VERSION_STRING) diff --git a/CMakeSettings.json b/CMakeSettings.json index cdc79fe..f18056c 100644 --- a/CMakeSettings.json +++ b/CMakeSettings.json @@ -9,8 +9,7 @@ "installRoot": "${projectDir}\\out\\install\\${name}", "cmakeCommandArgs": "", "buildCommandArgs": "-v", - "ctestCommandArgs": "", - "variables": [] + "ctestCommandArgs": "" }, { "name": "x64-Release", @@ -21,8 +20,7 @@ "cmakeCommandArgs": "", "buildCommandArgs": "-v", "ctestCommandArgs": "", - "inheritEnvironments": [ "msvc_x64_x64" ], - "variables": [] + "inheritEnvironments": [ "msvc_x64_x64" ] } ] } \ No newline at end of file diff --git a/Game/ExampleGame.cpp b/Game/ExampleGame.cpp index 71086a8..434bcc6 100644 --- a/Game/ExampleGame.cpp +++ b/Game/ExampleGame.cpp @@ -8,13 +8,14 @@ class ExampleGame : public Aeon::Core::App public: // take command line args better (parse them first!) - ExampleGame( int argc, char** argv ) + ExampleGame() : App( { "Game with AEON!" } ) { + Run(); } - ~ExampleGame() override + ~ExampleGame() { } @@ -23,5 +24,7 @@ public: int main( int argc, char** argv ) { - ExampleGame game(argc, argv); + ExampleGame game; + + return 0; } diff --git a/SDL2.dll b/SDL2.dll new file mode 100644 index 0000000000000000000000000000000000000000..4553fa9511e39dba1a35abfdc18f38bff5635a5f GIT binary patch literal 1609728 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 !ukqxw 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

6ULiw@g?RwG&12A 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%0D9R(uz9OzrJ!)eH1t@Y|0tRC7Dz2UnN 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