From 90cb20135932282d5a12c73f985ce7d841233059 Mon Sep 17 00:00:00 2001 From: Shariq Shah Date: Thu, 17 May 2018 18:30:05 +1000 Subject: [PATCH] Fixed GL_CHECK macro and replaced all renderer_gl_check usage with GL_CHECK --- include/common/KHR/khrplatform.h | 284 ---- include/common/glad/glad.h | 1155 +++++-------- src/libsymmetry/framebuffer.c | 45 +- src/libsymmetry/game.c | 4 +- src/libsymmetry/game.h | 7 + src/libsymmetry/geometry.c | 20 +- src/libsymmetry/gl_load.c | 15 +- src/libsymmetry/gl_load.h | 5 +- src/libsymmetry/glad.c | 2705 +----------------------------- src/libsymmetry/renderer.c | 23 - src/libsymmetry/shader.c | 11 +- src/libsymmetry/sprite.c | 32 +- src/libsymmetry/texture.c | 89 +- 13 files changed, 506 insertions(+), 3889 deletions(-) delete mode 100644 include/common/KHR/khrplatform.h diff --git a/include/common/KHR/khrplatform.h b/include/common/KHR/khrplatform.h deleted file mode 100644 index 1ad3554..0000000 --- a/include/common/KHR/khrplatform.h +++ /dev/null @@ -1,284 +0,0 @@ -#ifndef __khrplatform_h_ -#define __khrplatform_h_ - -/* -** Copyright (c) 2008-2009 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. - * - * $Revision: 32517 $ on $Date: 2016-03-11 02:41:19 -0800 (Fri, 11 Mar 2016) $ - * - * 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 sending them to the public Khronos Bugzilla - * (http://khronos.org/bugzilla) by filing a bug against product - * "Khronos (general)" component "Registry". - * - * A predefined template which fills in some of the bug fields can be - * reached using http://tinyurl.com/khrplatform-h-bugreport, but you - * must create a Bugzilla login first. - * - * - * 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_ */ diff --git a/include/common/glad/glad.h b/include/common/glad/glad.h index d2fb5f9..8aa2374 100644 --- a/include/common/glad/glad.h +++ b/include/common/glad/glad.h @@ -1,21 +1,21 @@ /* - OpenGL loader generated by glad 0.1.14a0 on Sat Oct 28 19:45:42 2017. + OpenGL loader generated by glad 0.1.20a0 on Thu May 17 09:25:49 2018. - Language/Generator: C/C++ Debug + Language/Generator: C/C++ Specification: gl APIs: gl=3.3 Profile: core Extensions: Loader: False - Local files: False - Omit khrplatform: False + Local files: True + Omit khrplatform: True Commandline: - --profile="core" --api="gl=3.3" --generator="c-debug" --spec="gl" --no-loader --extensions="" + --profile="core" --api="gl=3.3" --generator="c" --spec="gl" --no-loader --local-files --omit-khrplatform --extensions="" Online: - http://glad.dav1d.de/#profile=core&language=c-debug&specification=gl&api=gl%3D3.3 + http://glad.dav1d.de/#profile=core&language=c&specification=gl&api=gl%3D3.3 */ @@ -84,14 +84,7 @@ typedef void* (* GLADloadproc)(const char *name); GLAPI struct gladGLversionStruct GLVersion; GLAPI int gladLoadGLLoader(GLADloadproc); - -#define GLAD_DEBUG -typedef void (* GLADcallback)(const char *name, void *funcptr, int len_args, ...); - -GLAPI void glad_set_pre_callback(GLADcallback cb); -GLAPI void glad_set_post_callback(GLADcallback cb); #include -#include #ifndef GLEXT_64_TYPES_DEFINED /* This code block is duplicated in glxext.h, so must be protected */ #define GLEXT_64_TYPES_DEFINED @@ -1015,1544 +1008,1170 @@ typedef void (APIENTRY *GLVULKANPROCNV)(void); GLAPI int GLAD_GL_VERSION_1_0; typedef void (APIENTRYP PFNGLCULLFACEPROC)(GLenum mode); GLAPI PFNGLCULLFACEPROC glad_glCullFace; -GLAPI PFNGLCULLFACEPROC glad_debug_glCullFace; -#define glCullFace glad_debug_glCullFace +#define glCullFace glad_glCullFace typedef void (APIENTRYP PFNGLFRONTFACEPROC)(GLenum mode); GLAPI PFNGLFRONTFACEPROC glad_glFrontFace; -GLAPI PFNGLFRONTFACEPROC glad_debug_glFrontFace; -#define glFrontFace glad_debug_glFrontFace +#define glFrontFace glad_glFrontFace typedef void (APIENTRYP PFNGLHINTPROC)(GLenum target, GLenum mode); GLAPI PFNGLHINTPROC glad_glHint; -GLAPI PFNGLHINTPROC glad_debug_glHint; -#define glHint glad_debug_glHint +#define glHint glad_glHint typedef void (APIENTRYP PFNGLLINEWIDTHPROC)(GLfloat width); GLAPI PFNGLLINEWIDTHPROC glad_glLineWidth; -GLAPI PFNGLLINEWIDTHPROC glad_debug_glLineWidth; -#define glLineWidth glad_debug_glLineWidth +#define glLineWidth glad_glLineWidth typedef void (APIENTRYP PFNGLPOINTSIZEPROC)(GLfloat size); GLAPI PFNGLPOINTSIZEPROC glad_glPointSize; -GLAPI PFNGLPOINTSIZEPROC glad_debug_glPointSize; -#define glPointSize glad_debug_glPointSize +#define glPointSize glad_glPointSize typedef void (APIENTRYP PFNGLPOLYGONMODEPROC)(GLenum face, GLenum mode); GLAPI PFNGLPOLYGONMODEPROC glad_glPolygonMode; -GLAPI PFNGLPOLYGONMODEPROC glad_debug_glPolygonMode; -#define glPolygonMode glad_debug_glPolygonMode +#define glPolygonMode glad_glPolygonMode typedef void (APIENTRYP PFNGLSCISSORPROC)(GLint x, GLint y, GLsizei width, GLsizei height); GLAPI PFNGLSCISSORPROC glad_glScissor; -GLAPI PFNGLSCISSORPROC glad_debug_glScissor; -#define glScissor glad_debug_glScissor +#define glScissor glad_glScissor typedef void (APIENTRYP PFNGLTEXPARAMETERFPROC)(GLenum target, GLenum pname, GLfloat param); GLAPI PFNGLTEXPARAMETERFPROC glad_glTexParameterf; -GLAPI PFNGLTEXPARAMETERFPROC glad_debug_glTexParameterf; -#define glTexParameterf glad_debug_glTexParameterf +#define glTexParameterf glad_glTexParameterf typedef void (APIENTRYP PFNGLTEXPARAMETERFVPROC)(GLenum target, GLenum pname, const GLfloat *params); GLAPI PFNGLTEXPARAMETERFVPROC glad_glTexParameterfv; -GLAPI PFNGLTEXPARAMETERFVPROC glad_debug_glTexParameterfv; -#define glTexParameterfv glad_debug_glTexParameterfv +#define glTexParameterfv glad_glTexParameterfv typedef void (APIENTRYP PFNGLTEXPARAMETERIPROC)(GLenum target, GLenum pname, GLint param); GLAPI PFNGLTEXPARAMETERIPROC glad_glTexParameteri; -GLAPI PFNGLTEXPARAMETERIPROC glad_debug_glTexParameteri; -#define glTexParameteri glad_debug_glTexParameteri +#define glTexParameteri glad_glTexParameteri typedef void (APIENTRYP PFNGLTEXPARAMETERIVPROC)(GLenum target, GLenum pname, const GLint *params); GLAPI PFNGLTEXPARAMETERIVPROC glad_glTexParameteriv; -GLAPI PFNGLTEXPARAMETERIVPROC glad_debug_glTexParameteriv; -#define glTexParameteriv glad_debug_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; -GLAPI PFNGLTEXIMAGE1DPROC glad_debug_glTexImage1D; -#define glTexImage1D glad_debug_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; -GLAPI PFNGLTEXIMAGE2DPROC glad_debug_glTexImage2D; -#define glTexImage2D glad_debug_glTexImage2D +#define glTexImage2D glad_glTexImage2D typedef void (APIENTRYP PFNGLDRAWBUFFERPROC)(GLenum buf); GLAPI PFNGLDRAWBUFFERPROC glad_glDrawBuffer; -GLAPI PFNGLDRAWBUFFERPROC glad_debug_glDrawBuffer; -#define glDrawBuffer glad_debug_glDrawBuffer +#define glDrawBuffer glad_glDrawBuffer typedef void (APIENTRYP PFNGLCLEARPROC)(GLbitfield mask); GLAPI PFNGLCLEARPROC glad_glClear; -GLAPI PFNGLCLEARPROC glad_debug_glClear; -#define glClear glad_debug_glClear +#define glClear glad_glClear typedef void (APIENTRYP PFNGLCLEARCOLORPROC)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); GLAPI PFNGLCLEARCOLORPROC glad_glClearColor; -GLAPI PFNGLCLEARCOLORPROC glad_debug_glClearColor; -#define glClearColor glad_debug_glClearColor +#define glClearColor glad_glClearColor typedef void (APIENTRYP PFNGLCLEARSTENCILPROC)(GLint s); GLAPI PFNGLCLEARSTENCILPROC glad_glClearStencil; -GLAPI PFNGLCLEARSTENCILPROC glad_debug_glClearStencil; -#define glClearStencil glad_debug_glClearStencil +#define glClearStencil glad_glClearStencil typedef void (APIENTRYP PFNGLCLEARDEPTHPROC)(GLdouble depth); GLAPI PFNGLCLEARDEPTHPROC glad_glClearDepth; -GLAPI PFNGLCLEARDEPTHPROC glad_debug_glClearDepth; -#define glClearDepth glad_debug_glClearDepth +#define glClearDepth glad_glClearDepth typedef void (APIENTRYP PFNGLSTENCILMASKPROC)(GLuint mask); GLAPI PFNGLSTENCILMASKPROC glad_glStencilMask; -GLAPI PFNGLSTENCILMASKPROC glad_debug_glStencilMask; -#define glStencilMask glad_debug_glStencilMask +#define glStencilMask glad_glStencilMask typedef void (APIENTRYP PFNGLCOLORMASKPROC)(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); GLAPI PFNGLCOLORMASKPROC glad_glColorMask; -GLAPI PFNGLCOLORMASKPROC glad_debug_glColorMask; -#define glColorMask glad_debug_glColorMask +#define glColorMask glad_glColorMask typedef void (APIENTRYP PFNGLDEPTHMASKPROC)(GLboolean flag); GLAPI PFNGLDEPTHMASKPROC glad_glDepthMask; -GLAPI PFNGLDEPTHMASKPROC glad_debug_glDepthMask; -#define glDepthMask glad_debug_glDepthMask +#define glDepthMask glad_glDepthMask typedef void (APIENTRYP PFNGLDISABLEPROC)(GLenum cap); GLAPI PFNGLDISABLEPROC glad_glDisable; -GLAPI PFNGLDISABLEPROC glad_debug_glDisable; -#define glDisable glad_debug_glDisable +#define glDisable glad_glDisable typedef void (APIENTRYP PFNGLENABLEPROC)(GLenum cap); GLAPI PFNGLENABLEPROC glad_glEnable; -GLAPI PFNGLENABLEPROC glad_debug_glEnable; -#define glEnable glad_debug_glEnable -typedef void (APIENTRYP PFNGLFINISHPROC)(); +#define glEnable glad_glEnable +typedef void (APIENTRYP PFNGLFINISHPROC)(void); GLAPI PFNGLFINISHPROC glad_glFinish; -GLAPI PFNGLFINISHPROC glad_debug_glFinish; -#define glFinish glad_debug_glFinish -typedef void (APIENTRYP PFNGLFLUSHPROC)(); +#define glFinish glad_glFinish +typedef void (APIENTRYP PFNGLFLUSHPROC)(void); GLAPI PFNGLFLUSHPROC glad_glFlush; -GLAPI PFNGLFLUSHPROC glad_debug_glFlush; -#define glFlush glad_debug_glFlush +#define glFlush glad_glFlush typedef void (APIENTRYP PFNGLBLENDFUNCPROC)(GLenum sfactor, GLenum dfactor); GLAPI PFNGLBLENDFUNCPROC glad_glBlendFunc; -GLAPI PFNGLBLENDFUNCPROC glad_debug_glBlendFunc; -#define glBlendFunc glad_debug_glBlendFunc +#define glBlendFunc glad_glBlendFunc typedef void (APIENTRYP PFNGLLOGICOPPROC)(GLenum opcode); GLAPI PFNGLLOGICOPPROC glad_glLogicOp; -GLAPI PFNGLLOGICOPPROC glad_debug_glLogicOp; -#define glLogicOp glad_debug_glLogicOp +#define glLogicOp glad_glLogicOp typedef void (APIENTRYP PFNGLSTENCILFUNCPROC)(GLenum func, GLint ref, GLuint mask); GLAPI PFNGLSTENCILFUNCPROC glad_glStencilFunc; -GLAPI PFNGLSTENCILFUNCPROC glad_debug_glStencilFunc; -#define glStencilFunc glad_debug_glStencilFunc +#define glStencilFunc glad_glStencilFunc typedef void (APIENTRYP PFNGLSTENCILOPPROC)(GLenum fail, GLenum zfail, GLenum zpass); GLAPI PFNGLSTENCILOPPROC glad_glStencilOp; -GLAPI PFNGLSTENCILOPPROC glad_debug_glStencilOp; -#define glStencilOp glad_debug_glStencilOp +#define glStencilOp glad_glStencilOp typedef void (APIENTRYP PFNGLDEPTHFUNCPROC)(GLenum func); GLAPI PFNGLDEPTHFUNCPROC glad_glDepthFunc; -GLAPI PFNGLDEPTHFUNCPROC glad_debug_glDepthFunc; -#define glDepthFunc glad_debug_glDepthFunc +#define glDepthFunc glad_glDepthFunc typedef void (APIENTRYP PFNGLPIXELSTOREFPROC)(GLenum pname, GLfloat param); GLAPI PFNGLPIXELSTOREFPROC glad_glPixelStoref; -GLAPI PFNGLPIXELSTOREFPROC glad_debug_glPixelStoref; -#define glPixelStoref glad_debug_glPixelStoref +#define glPixelStoref glad_glPixelStoref typedef void (APIENTRYP PFNGLPIXELSTOREIPROC)(GLenum pname, GLint param); GLAPI PFNGLPIXELSTOREIPROC glad_glPixelStorei; -GLAPI PFNGLPIXELSTOREIPROC glad_debug_glPixelStorei; -#define glPixelStorei glad_debug_glPixelStorei +#define glPixelStorei glad_glPixelStorei typedef void (APIENTRYP PFNGLREADBUFFERPROC)(GLenum src); GLAPI PFNGLREADBUFFERPROC glad_glReadBuffer; -GLAPI PFNGLREADBUFFERPROC glad_debug_glReadBuffer; -#define glReadBuffer glad_debug_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; -GLAPI PFNGLREADPIXELSPROC glad_debug_glReadPixels; -#define glReadPixels glad_debug_glReadPixels +#define glReadPixels glad_glReadPixels typedef void (APIENTRYP PFNGLGETBOOLEANVPROC)(GLenum pname, GLboolean *data); GLAPI PFNGLGETBOOLEANVPROC glad_glGetBooleanv; -GLAPI PFNGLGETBOOLEANVPROC glad_debug_glGetBooleanv; -#define glGetBooleanv glad_debug_glGetBooleanv +#define glGetBooleanv glad_glGetBooleanv typedef void (APIENTRYP PFNGLGETDOUBLEVPROC)(GLenum pname, GLdouble *data); GLAPI PFNGLGETDOUBLEVPROC glad_glGetDoublev; -GLAPI PFNGLGETDOUBLEVPROC glad_debug_glGetDoublev; -#define glGetDoublev glad_debug_glGetDoublev -typedef GLenum (APIENTRYP PFNGLGETERRORPROC)(); +#define glGetDoublev glad_glGetDoublev +typedef GLenum (APIENTRYP PFNGLGETERRORPROC)(void); GLAPI PFNGLGETERRORPROC glad_glGetError; -GLAPI PFNGLGETERRORPROC glad_debug_glGetError; -#define glGetError glad_debug_glGetError +#define glGetError glad_glGetError typedef void (APIENTRYP PFNGLGETFLOATVPROC)(GLenum pname, GLfloat *data); GLAPI PFNGLGETFLOATVPROC glad_glGetFloatv; -GLAPI PFNGLGETFLOATVPROC glad_debug_glGetFloatv; -#define glGetFloatv glad_debug_glGetFloatv +#define glGetFloatv glad_glGetFloatv typedef void (APIENTRYP PFNGLGETINTEGERVPROC)(GLenum pname, GLint *data); GLAPI PFNGLGETINTEGERVPROC glad_glGetIntegerv; -GLAPI PFNGLGETINTEGERVPROC glad_debug_glGetIntegerv; -#define glGetIntegerv glad_debug_glGetIntegerv +#define glGetIntegerv glad_glGetIntegerv typedef const GLubyte * (APIENTRYP PFNGLGETSTRINGPROC)(GLenum name); GLAPI PFNGLGETSTRINGPROC glad_glGetString; -GLAPI PFNGLGETSTRINGPROC glad_debug_glGetString; -#define glGetString glad_debug_glGetString +#define glGetString glad_glGetString typedef void (APIENTRYP PFNGLGETTEXIMAGEPROC)(GLenum target, GLint level, GLenum format, GLenum type, void *pixels); GLAPI PFNGLGETTEXIMAGEPROC glad_glGetTexImage; -GLAPI PFNGLGETTEXIMAGEPROC glad_debug_glGetTexImage; -#define glGetTexImage glad_debug_glGetTexImage +#define glGetTexImage glad_glGetTexImage typedef void (APIENTRYP PFNGLGETTEXPARAMETERFVPROC)(GLenum target, GLenum pname, GLfloat *params); GLAPI PFNGLGETTEXPARAMETERFVPROC glad_glGetTexParameterfv; -GLAPI PFNGLGETTEXPARAMETERFVPROC glad_debug_glGetTexParameterfv; -#define glGetTexParameterfv glad_debug_glGetTexParameterfv +#define glGetTexParameterfv glad_glGetTexParameterfv typedef void (APIENTRYP PFNGLGETTEXPARAMETERIVPROC)(GLenum target, GLenum pname, GLint *params); GLAPI PFNGLGETTEXPARAMETERIVPROC glad_glGetTexParameteriv; -GLAPI PFNGLGETTEXPARAMETERIVPROC glad_debug_glGetTexParameteriv; -#define glGetTexParameteriv glad_debug_glGetTexParameteriv +#define glGetTexParameteriv glad_glGetTexParameteriv typedef void (APIENTRYP PFNGLGETTEXLEVELPARAMETERFVPROC)(GLenum target, GLint level, GLenum pname, GLfloat *params); GLAPI PFNGLGETTEXLEVELPARAMETERFVPROC glad_glGetTexLevelParameterfv; -GLAPI PFNGLGETTEXLEVELPARAMETERFVPROC glad_debug_glGetTexLevelParameterfv; -#define glGetTexLevelParameterfv glad_debug_glGetTexLevelParameterfv +#define glGetTexLevelParameterfv glad_glGetTexLevelParameterfv typedef void (APIENTRYP PFNGLGETTEXLEVELPARAMETERIVPROC)(GLenum target, GLint level, GLenum pname, GLint *params); GLAPI PFNGLGETTEXLEVELPARAMETERIVPROC glad_glGetTexLevelParameteriv; -GLAPI PFNGLGETTEXLEVELPARAMETERIVPROC glad_debug_glGetTexLevelParameteriv; -#define glGetTexLevelParameteriv glad_debug_glGetTexLevelParameteriv +#define glGetTexLevelParameteriv glad_glGetTexLevelParameteriv typedef GLboolean (APIENTRYP PFNGLISENABLEDPROC)(GLenum cap); GLAPI PFNGLISENABLEDPROC glad_glIsEnabled; -GLAPI PFNGLISENABLEDPROC glad_debug_glIsEnabled; -#define glIsEnabled glad_debug_glIsEnabled -typedef void (APIENTRYP PFNGLDEPTHRANGEPROC)(GLdouble near, GLdouble far); +#define glIsEnabled glad_glIsEnabled +typedef void (APIENTRYP PFNGLDEPTHRANGEPROC)(GLdouble n, GLdouble f); GLAPI PFNGLDEPTHRANGEPROC glad_glDepthRange; -GLAPI PFNGLDEPTHRANGEPROC glad_debug_glDepthRange; -#define glDepthRange glad_debug_glDepthRange +#define glDepthRange glad_glDepthRange typedef void (APIENTRYP PFNGLVIEWPORTPROC)(GLint x, GLint y, GLsizei width, GLsizei height); GLAPI PFNGLVIEWPORTPROC glad_glViewport; -GLAPI PFNGLVIEWPORTPROC glad_debug_glViewport; -#define glViewport glad_debug_glViewport +#define glViewport glad_glViewport #endif #ifndef GL_VERSION_1_1 #define GL_VERSION_1_1 1 GLAPI int GLAD_GL_VERSION_1_1; typedef void (APIENTRYP PFNGLDRAWARRAYSPROC)(GLenum mode, GLint first, GLsizei count); GLAPI PFNGLDRAWARRAYSPROC glad_glDrawArrays; -GLAPI PFNGLDRAWARRAYSPROC glad_debug_glDrawArrays; -#define glDrawArrays glad_debug_glDrawArrays +#define glDrawArrays glad_glDrawArrays typedef void (APIENTRYP PFNGLDRAWELEMENTSPROC)(GLenum mode, GLsizei count, GLenum type, const void *indices); GLAPI PFNGLDRAWELEMENTSPROC glad_glDrawElements; -GLAPI PFNGLDRAWELEMENTSPROC glad_debug_glDrawElements; -#define glDrawElements glad_debug_glDrawElements +#define glDrawElements glad_glDrawElements typedef void (APIENTRYP PFNGLPOLYGONOFFSETPROC)(GLfloat factor, GLfloat units); GLAPI PFNGLPOLYGONOFFSETPROC glad_glPolygonOffset; -GLAPI PFNGLPOLYGONOFFSETPROC glad_debug_glPolygonOffset; -#define glPolygonOffset glad_debug_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; -GLAPI PFNGLCOPYTEXIMAGE1DPROC glad_debug_glCopyTexImage1D; -#define glCopyTexImage1D glad_debug_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; -GLAPI PFNGLCOPYTEXIMAGE2DPROC glad_debug_glCopyTexImage2D; -#define glCopyTexImage2D glad_debug_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; -GLAPI PFNGLCOPYTEXSUBIMAGE1DPROC glad_debug_glCopyTexSubImage1D; -#define glCopyTexSubImage1D glad_debug_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; -GLAPI PFNGLCOPYTEXSUBIMAGE2DPROC glad_debug_glCopyTexSubImage2D; -#define glCopyTexSubImage2D glad_debug_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; -GLAPI PFNGLTEXSUBIMAGE1DPROC glad_debug_glTexSubImage1D; -#define glTexSubImage1D glad_debug_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; -GLAPI PFNGLTEXSUBIMAGE2DPROC glad_debug_glTexSubImage2D; -#define glTexSubImage2D glad_debug_glTexSubImage2D +#define glTexSubImage2D glad_glTexSubImage2D typedef void (APIENTRYP PFNGLBINDTEXTUREPROC)(GLenum target, GLuint texture); GLAPI PFNGLBINDTEXTUREPROC glad_glBindTexture; -GLAPI PFNGLBINDTEXTUREPROC glad_debug_glBindTexture; -#define glBindTexture glad_debug_glBindTexture +#define glBindTexture glad_glBindTexture typedef void (APIENTRYP PFNGLDELETETEXTURESPROC)(GLsizei n, const GLuint *textures); GLAPI PFNGLDELETETEXTURESPROC glad_glDeleteTextures; -GLAPI PFNGLDELETETEXTURESPROC glad_debug_glDeleteTextures; -#define glDeleteTextures glad_debug_glDeleteTextures +#define glDeleteTextures glad_glDeleteTextures typedef void (APIENTRYP PFNGLGENTEXTURESPROC)(GLsizei n, GLuint *textures); GLAPI PFNGLGENTEXTURESPROC glad_glGenTextures; -GLAPI PFNGLGENTEXTURESPROC glad_debug_glGenTextures; -#define glGenTextures glad_debug_glGenTextures +#define glGenTextures glad_glGenTextures typedef GLboolean (APIENTRYP PFNGLISTEXTUREPROC)(GLuint texture); GLAPI PFNGLISTEXTUREPROC glad_glIsTexture; -GLAPI PFNGLISTEXTUREPROC glad_debug_glIsTexture; -#define glIsTexture glad_debug_glIsTexture +#define glIsTexture glad_glIsTexture #endif #ifndef GL_VERSION_1_2 #define GL_VERSION_1_2 1 GLAPI int GLAD_GL_VERSION_1_2; typedef void (APIENTRYP PFNGLDRAWRANGEELEMENTSPROC)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices); GLAPI PFNGLDRAWRANGEELEMENTSPROC glad_glDrawRangeElements; -GLAPI PFNGLDRAWRANGEELEMENTSPROC glad_debug_glDrawRangeElements; -#define glDrawRangeElements glad_debug_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; -GLAPI PFNGLTEXIMAGE3DPROC glad_debug_glTexImage3D; -#define glTexImage3D glad_debug_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; -GLAPI PFNGLTEXSUBIMAGE3DPROC glad_debug_glTexSubImage3D; -#define glTexSubImage3D glad_debug_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; -GLAPI PFNGLCOPYTEXSUBIMAGE3DPROC glad_debug_glCopyTexSubImage3D; -#define glCopyTexSubImage3D glad_debug_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; -GLAPI PFNGLACTIVETEXTUREPROC glad_debug_glActiveTexture; -#define glActiveTexture glad_debug_glActiveTexture +#define glActiveTexture glad_glActiveTexture typedef void (APIENTRYP PFNGLSAMPLECOVERAGEPROC)(GLfloat value, GLboolean invert); GLAPI PFNGLSAMPLECOVERAGEPROC glad_glSampleCoverage; -GLAPI PFNGLSAMPLECOVERAGEPROC glad_debug_glSampleCoverage; -#define glSampleCoverage glad_debug_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; -GLAPI PFNGLCOMPRESSEDTEXIMAGE3DPROC glad_debug_glCompressedTexImage3D; -#define glCompressedTexImage3D glad_debug_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; -GLAPI PFNGLCOMPRESSEDTEXIMAGE2DPROC glad_debug_glCompressedTexImage2D; -#define glCompressedTexImage2D glad_debug_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; -GLAPI PFNGLCOMPRESSEDTEXIMAGE1DPROC glad_debug_glCompressedTexImage1D; -#define glCompressedTexImage1D glad_debug_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; -GLAPI PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC glad_debug_glCompressedTexSubImage3D; -#define glCompressedTexSubImage3D glad_debug_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; -GLAPI PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC glad_debug_glCompressedTexSubImage2D; -#define glCompressedTexSubImage2D glad_debug_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; -GLAPI PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC glad_debug_glCompressedTexSubImage1D; -#define glCompressedTexSubImage1D glad_debug_glCompressedTexSubImage1D +#define glCompressedTexSubImage1D glad_glCompressedTexSubImage1D typedef void (APIENTRYP PFNGLGETCOMPRESSEDTEXIMAGEPROC)(GLenum target, GLint level, void *img); GLAPI PFNGLGETCOMPRESSEDTEXIMAGEPROC glad_glGetCompressedTexImage; -GLAPI PFNGLGETCOMPRESSEDTEXIMAGEPROC glad_debug_glGetCompressedTexImage; -#define glGetCompressedTexImage glad_debug_glGetCompressedTexImage +#define glGetCompressedTexImage glad_glGetCompressedTexImage #endif #ifndef GL_VERSION_1_4 #define GL_VERSION_1_4 1 GLAPI int GLAD_GL_VERSION_1_4; typedef void (APIENTRYP PFNGLBLENDFUNCSEPARATEPROC)(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha); GLAPI PFNGLBLENDFUNCSEPARATEPROC glad_glBlendFuncSeparate; -GLAPI PFNGLBLENDFUNCSEPARATEPROC glad_debug_glBlendFuncSeparate; -#define glBlendFuncSeparate glad_debug_glBlendFuncSeparate +#define glBlendFuncSeparate glad_glBlendFuncSeparate typedef void (APIENTRYP PFNGLMULTIDRAWARRAYSPROC)(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount); GLAPI PFNGLMULTIDRAWARRAYSPROC glad_glMultiDrawArrays; -GLAPI PFNGLMULTIDRAWARRAYSPROC glad_debug_glMultiDrawArrays; -#define glMultiDrawArrays glad_debug_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; -GLAPI PFNGLMULTIDRAWELEMENTSPROC glad_debug_glMultiDrawElements; -#define glMultiDrawElements glad_debug_glMultiDrawElements +#define glMultiDrawElements glad_glMultiDrawElements typedef void (APIENTRYP PFNGLPOINTPARAMETERFPROC)(GLenum pname, GLfloat param); GLAPI PFNGLPOINTPARAMETERFPROC glad_glPointParameterf; -GLAPI PFNGLPOINTPARAMETERFPROC glad_debug_glPointParameterf; -#define glPointParameterf glad_debug_glPointParameterf +#define glPointParameterf glad_glPointParameterf typedef void (APIENTRYP PFNGLPOINTPARAMETERFVPROC)(GLenum pname, const GLfloat *params); GLAPI PFNGLPOINTPARAMETERFVPROC glad_glPointParameterfv; -GLAPI PFNGLPOINTPARAMETERFVPROC glad_debug_glPointParameterfv; -#define glPointParameterfv glad_debug_glPointParameterfv +#define glPointParameterfv glad_glPointParameterfv typedef void (APIENTRYP PFNGLPOINTPARAMETERIPROC)(GLenum pname, GLint param); GLAPI PFNGLPOINTPARAMETERIPROC glad_glPointParameteri; -GLAPI PFNGLPOINTPARAMETERIPROC glad_debug_glPointParameteri; -#define glPointParameteri glad_debug_glPointParameteri +#define glPointParameteri glad_glPointParameteri typedef void (APIENTRYP PFNGLPOINTPARAMETERIVPROC)(GLenum pname, const GLint *params); GLAPI PFNGLPOINTPARAMETERIVPROC glad_glPointParameteriv; -GLAPI PFNGLPOINTPARAMETERIVPROC glad_debug_glPointParameteriv; -#define glPointParameteriv glad_debug_glPointParameteriv +#define glPointParameteriv glad_glPointParameteriv typedef void (APIENTRYP PFNGLBLENDCOLORPROC)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); GLAPI PFNGLBLENDCOLORPROC glad_glBlendColor; -GLAPI PFNGLBLENDCOLORPROC glad_debug_glBlendColor; -#define glBlendColor glad_debug_glBlendColor +#define glBlendColor glad_glBlendColor typedef void (APIENTRYP PFNGLBLENDEQUATIONPROC)(GLenum mode); GLAPI PFNGLBLENDEQUATIONPROC glad_glBlendEquation; -GLAPI PFNGLBLENDEQUATIONPROC glad_debug_glBlendEquation; -#define glBlendEquation glad_debug_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; -GLAPI PFNGLGENQUERIESPROC glad_debug_glGenQueries; -#define glGenQueries glad_debug_glGenQueries +#define glGenQueries glad_glGenQueries typedef void (APIENTRYP PFNGLDELETEQUERIESPROC)(GLsizei n, const GLuint *ids); GLAPI PFNGLDELETEQUERIESPROC glad_glDeleteQueries; -GLAPI PFNGLDELETEQUERIESPROC glad_debug_glDeleteQueries; -#define glDeleteQueries glad_debug_glDeleteQueries +#define glDeleteQueries glad_glDeleteQueries typedef GLboolean (APIENTRYP PFNGLISQUERYPROC)(GLuint id); GLAPI PFNGLISQUERYPROC glad_glIsQuery; -GLAPI PFNGLISQUERYPROC glad_debug_glIsQuery; -#define glIsQuery glad_debug_glIsQuery +#define glIsQuery glad_glIsQuery typedef void (APIENTRYP PFNGLBEGINQUERYPROC)(GLenum target, GLuint id); GLAPI PFNGLBEGINQUERYPROC glad_glBeginQuery; -GLAPI PFNGLBEGINQUERYPROC glad_debug_glBeginQuery; -#define glBeginQuery glad_debug_glBeginQuery +#define glBeginQuery glad_glBeginQuery typedef void (APIENTRYP PFNGLENDQUERYPROC)(GLenum target); GLAPI PFNGLENDQUERYPROC glad_glEndQuery; -GLAPI PFNGLENDQUERYPROC glad_debug_glEndQuery; -#define glEndQuery glad_debug_glEndQuery +#define glEndQuery glad_glEndQuery typedef void (APIENTRYP PFNGLGETQUERYIVPROC)(GLenum target, GLenum pname, GLint *params); GLAPI PFNGLGETQUERYIVPROC glad_glGetQueryiv; -GLAPI PFNGLGETQUERYIVPROC glad_debug_glGetQueryiv; -#define glGetQueryiv glad_debug_glGetQueryiv +#define glGetQueryiv glad_glGetQueryiv typedef void (APIENTRYP PFNGLGETQUERYOBJECTIVPROC)(GLuint id, GLenum pname, GLint *params); GLAPI PFNGLGETQUERYOBJECTIVPROC glad_glGetQueryObjectiv; -GLAPI PFNGLGETQUERYOBJECTIVPROC glad_debug_glGetQueryObjectiv; -#define glGetQueryObjectiv glad_debug_glGetQueryObjectiv +#define glGetQueryObjectiv glad_glGetQueryObjectiv typedef void (APIENTRYP PFNGLGETQUERYOBJECTUIVPROC)(GLuint id, GLenum pname, GLuint *params); GLAPI PFNGLGETQUERYOBJECTUIVPROC glad_glGetQueryObjectuiv; -GLAPI PFNGLGETQUERYOBJECTUIVPROC glad_debug_glGetQueryObjectuiv; -#define glGetQueryObjectuiv glad_debug_glGetQueryObjectuiv +#define glGetQueryObjectuiv glad_glGetQueryObjectuiv typedef void (APIENTRYP PFNGLBINDBUFFERPROC)(GLenum target, GLuint buffer); GLAPI PFNGLBINDBUFFERPROC glad_glBindBuffer; -GLAPI PFNGLBINDBUFFERPROC glad_debug_glBindBuffer; -#define glBindBuffer glad_debug_glBindBuffer +#define glBindBuffer glad_glBindBuffer typedef void (APIENTRYP PFNGLDELETEBUFFERSPROC)(GLsizei n, const GLuint *buffers); GLAPI PFNGLDELETEBUFFERSPROC glad_glDeleteBuffers; -GLAPI PFNGLDELETEBUFFERSPROC glad_debug_glDeleteBuffers; -#define glDeleteBuffers glad_debug_glDeleteBuffers +#define glDeleteBuffers glad_glDeleteBuffers typedef void (APIENTRYP PFNGLGENBUFFERSPROC)(GLsizei n, GLuint *buffers); GLAPI PFNGLGENBUFFERSPROC glad_glGenBuffers; -GLAPI PFNGLGENBUFFERSPROC glad_debug_glGenBuffers; -#define glGenBuffers glad_debug_glGenBuffers +#define glGenBuffers glad_glGenBuffers typedef GLboolean (APIENTRYP PFNGLISBUFFERPROC)(GLuint buffer); GLAPI PFNGLISBUFFERPROC glad_glIsBuffer; -GLAPI PFNGLISBUFFERPROC glad_debug_glIsBuffer; -#define glIsBuffer glad_debug_glIsBuffer +#define glIsBuffer glad_glIsBuffer typedef void (APIENTRYP PFNGLBUFFERDATAPROC)(GLenum target, GLsizeiptr size, const void *data, GLenum usage); GLAPI PFNGLBUFFERDATAPROC glad_glBufferData; -GLAPI PFNGLBUFFERDATAPROC glad_debug_glBufferData; -#define glBufferData glad_debug_glBufferData +#define glBufferData glad_glBufferData typedef void (APIENTRYP PFNGLBUFFERSUBDATAPROC)(GLenum target, GLintptr offset, GLsizeiptr size, const void *data); GLAPI PFNGLBUFFERSUBDATAPROC glad_glBufferSubData; -GLAPI PFNGLBUFFERSUBDATAPROC glad_debug_glBufferSubData; -#define glBufferSubData glad_debug_glBufferSubData +#define glBufferSubData glad_glBufferSubData typedef void (APIENTRYP PFNGLGETBUFFERSUBDATAPROC)(GLenum target, GLintptr offset, GLsizeiptr size, void *data); GLAPI PFNGLGETBUFFERSUBDATAPROC glad_glGetBufferSubData; -GLAPI PFNGLGETBUFFERSUBDATAPROC glad_debug_glGetBufferSubData; -#define glGetBufferSubData glad_debug_glGetBufferSubData +#define glGetBufferSubData glad_glGetBufferSubData typedef void * (APIENTRYP PFNGLMAPBUFFERPROC)(GLenum target, GLenum access); GLAPI PFNGLMAPBUFFERPROC glad_glMapBuffer; -GLAPI PFNGLMAPBUFFERPROC glad_debug_glMapBuffer; -#define glMapBuffer glad_debug_glMapBuffer +#define glMapBuffer glad_glMapBuffer typedef GLboolean (APIENTRYP PFNGLUNMAPBUFFERPROC)(GLenum target); GLAPI PFNGLUNMAPBUFFERPROC glad_glUnmapBuffer; -GLAPI PFNGLUNMAPBUFFERPROC glad_debug_glUnmapBuffer; -#define glUnmapBuffer glad_debug_glUnmapBuffer +#define glUnmapBuffer glad_glUnmapBuffer typedef void (APIENTRYP PFNGLGETBUFFERPARAMETERIVPROC)(GLenum target, GLenum pname, GLint *params); GLAPI PFNGLGETBUFFERPARAMETERIVPROC glad_glGetBufferParameteriv; -GLAPI PFNGLGETBUFFERPARAMETERIVPROC glad_debug_glGetBufferParameteriv; -#define glGetBufferParameteriv glad_debug_glGetBufferParameteriv +#define glGetBufferParameteriv glad_glGetBufferParameteriv typedef void (APIENTRYP PFNGLGETBUFFERPOINTERVPROC)(GLenum target, GLenum pname, void **params); GLAPI PFNGLGETBUFFERPOINTERVPROC glad_glGetBufferPointerv; -GLAPI PFNGLGETBUFFERPOINTERVPROC glad_debug_glGetBufferPointerv; -#define glGetBufferPointerv glad_debug_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; -GLAPI PFNGLBLENDEQUATIONSEPARATEPROC glad_debug_glBlendEquationSeparate; -#define glBlendEquationSeparate glad_debug_glBlendEquationSeparate +#define glBlendEquationSeparate glad_glBlendEquationSeparate typedef void (APIENTRYP PFNGLDRAWBUFFERSPROC)(GLsizei n, const GLenum *bufs); GLAPI PFNGLDRAWBUFFERSPROC glad_glDrawBuffers; -GLAPI PFNGLDRAWBUFFERSPROC glad_debug_glDrawBuffers; -#define glDrawBuffers glad_debug_glDrawBuffers +#define glDrawBuffers glad_glDrawBuffers typedef void (APIENTRYP PFNGLSTENCILOPSEPARATEPROC)(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass); GLAPI PFNGLSTENCILOPSEPARATEPROC glad_glStencilOpSeparate; -GLAPI PFNGLSTENCILOPSEPARATEPROC glad_debug_glStencilOpSeparate; -#define glStencilOpSeparate glad_debug_glStencilOpSeparate +#define glStencilOpSeparate glad_glStencilOpSeparate typedef void (APIENTRYP PFNGLSTENCILFUNCSEPARATEPROC)(GLenum face, GLenum func, GLint ref, GLuint mask); GLAPI PFNGLSTENCILFUNCSEPARATEPROC glad_glStencilFuncSeparate; -GLAPI PFNGLSTENCILFUNCSEPARATEPROC glad_debug_glStencilFuncSeparate; -#define glStencilFuncSeparate glad_debug_glStencilFuncSeparate +#define glStencilFuncSeparate glad_glStencilFuncSeparate typedef void (APIENTRYP PFNGLSTENCILMASKSEPARATEPROC)(GLenum face, GLuint mask); GLAPI PFNGLSTENCILMASKSEPARATEPROC glad_glStencilMaskSeparate; -GLAPI PFNGLSTENCILMASKSEPARATEPROC glad_debug_glStencilMaskSeparate; -#define glStencilMaskSeparate glad_debug_glStencilMaskSeparate +#define glStencilMaskSeparate glad_glStencilMaskSeparate typedef void (APIENTRYP PFNGLATTACHSHADERPROC)(GLuint program, GLuint shader); GLAPI PFNGLATTACHSHADERPROC glad_glAttachShader; -GLAPI PFNGLATTACHSHADERPROC glad_debug_glAttachShader; -#define glAttachShader glad_debug_glAttachShader +#define glAttachShader glad_glAttachShader typedef void (APIENTRYP PFNGLBINDATTRIBLOCATIONPROC)(GLuint program, GLuint index, const GLchar *name); GLAPI PFNGLBINDATTRIBLOCATIONPROC glad_glBindAttribLocation; -GLAPI PFNGLBINDATTRIBLOCATIONPROC glad_debug_glBindAttribLocation; -#define glBindAttribLocation glad_debug_glBindAttribLocation +#define glBindAttribLocation glad_glBindAttribLocation typedef void (APIENTRYP PFNGLCOMPILESHADERPROC)(GLuint shader); GLAPI PFNGLCOMPILESHADERPROC glad_glCompileShader; -GLAPI PFNGLCOMPILESHADERPROC glad_debug_glCompileShader; -#define glCompileShader glad_debug_glCompileShader -typedef GLuint (APIENTRYP PFNGLCREATEPROGRAMPROC)(); +#define glCompileShader glad_glCompileShader +typedef GLuint (APIENTRYP PFNGLCREATEPROGRAMPROC)(void); GLAPI PFNGLCREATEPROGRAMPROC glad_glCreateProgram; -GLAPI PFNGLCREATEPROGRAMPROC glad_debug_glCreateProgram; -#define glCreateProgram glad_debug_glCreateProgram +#define glCreateProgram glad_glCreateProgram typedef GLuint (APIENTRYP PFNGLCREATESHADERPROC)(GLenum type); GLAPI PFNGLCREATESHADERPROC glad_glCreateShader; -GLAPI PFNGLCREATESHADERPROC glad_debug_glCreateShader; -#define glCreateShader glad_debug_glCreateShader +#define glCreateShader glad_glCreateShader typedef void (APIENTRYP PFNGLDELETEPROGRAMPROC)(GLuint program); GLAPI PFNGLDELETEPROGRAMPROC glad_glDeleteProgram; -GLAPI PFNGLDELETEPROGRAMPROC glad_debug_glDeleteProgram; -#define glDeleteProgram glad_debug_glDeleteProgram +#define glDeleteProgram glad_glDeleteProgram typedef void (APIENTRYP PFNGLDELETESHADERPROC)(GLuint shader); GLAPI PFNGLDELETESHADERPROC glad_glDeleteShader; -GLAPI PFNGLDELETESHADERPROC glad_debug_glDeleteShader; -#define glDeleteShader glad_debug_glDeleteShader +#define glDeleteShader glad_glDeleteShader typedef void (APIENTRYP PFNGLDETACHSHADERPROC)(GLuint program, GLuint shader); GLAPI PFNGLDETACHSHADERPROC glad_glDetachShader; -GLAPI PFNGLDETACHSHADERPROC glad_debug_glDetachShader; -#define glDetachShader glad_debug_glDetachShader +#define glDetachShader glad_glDetachShader typedef void (APIENTRYP PFNGLDISABLEVERTEXATTRIBARRAYPROC)(GLuint index); GLAPI PFNGLDISABLEVERTEXATTRIBARRAYPROC glad_glDisableVertexAttribArray; -GLAPI PFNGLDISABLEVERTEXATTRIBARRAYPROC glad_debug_glDisableVertexAttribArray; -#define glDisableVertexAttribArray glad_debug_glDisableVertexAttribArray +#define glDisableVertexAttribArray glad_glDisableVertexAttribArray typedef void (APIENTRYP PFNGLENABLEVERTEXATTRIBARRAYPROC)(GLuint index); GLAPI PFNGLENABLEVERTEXATTRIBARRAYPROC glad_glEnableVertexAttribArray; -GLAPI PFNGLENABLEVERTEXATTRIBARRAYPROC glad_debug_glEnableVertexAttribArray; -#define glEnableVertexAttribArray glad_debug_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; -GLAPI PFNGLGETACTIVEATTRIBPROC glad_debug_glGetActiveAttrib; -#define glGetActiveAttrib glad_debug_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; -GLAPI PFNGLGETACTIVEUNIFORMPROC glad_debug_glGetActiveUniform; -#define glGetActiveUniform glad_debug_glGetActiveUniform +#define glGetActiveUniform glad_glGetActiveUniform typedef void (APIENTRYP PFNGLGETATTACHEDSHADERSPROC)(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *shaders); GLAPI PFNGLGETATTACHEDSHADERSPROC glad_glGetAttachedShaders; -GLAPI PFNGLGETATTACHEDSHADERSPROC glad_debug_glGetAttachedShaders; -#define glGetAttachedShaders glad_debug_glGetAttachedShaders +#define glGetAttachedShaders glad_glGetAttachedShaders typedef GLint (APIENTRYP PFNGLGETATTRIBLOCATIONPROC)(GLuint program, const GLchar *name); GLAPI PFNGLGETATTRIBLOCATIONPROC glad_glGetAttribLocation; -GLAPI PFNGLGETATTRIBLOCATIONPROC glad_debug_glGetAttribLocation; -#define glGetAttribLocation glad_debug_glGetAttribLocation +#define glGetAttribLocation glad_glGetAttribLocation typedef void (APIENTRYP PFNGLGETPROGRAMIVPROC)(GLuint program, GLenum pname, GLint *params); GLAPI PFNGLGETPROGRAMIVPROC glad_glGetProgramiv; -GLAPI PFNGLGETPROGRAMIVPROC glad_debug_glGetProgramiv; -#define glGetProgramiv glad_debug_glGetProgramiv +#define glGetProgramiv glad_glGetProgramiv typedef void (APIENTRYP PFNGLGETPROGRAMINFOLOGPROC)(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog); GLAPI PFNGLGETPROGRAMINFOLOGPROC glad_glGetProgramInfoLog; -GLAPI PFNGLGETPROGRAMINFOLOGPROC glad_debug_glGetProgramInfoLog; -#define glGetProgramInfoLog glad_debug_glGetProgramInfoLog +#define glGetProgramInfoLog glad_glGetProgramInfoLog typedef void (APIENTRYP PFNGLGETSHADERIVPROC)(GLuint shader, GLenum pname, GLint *params); GLAPI PFNGLGETSHADERIVPROC glad_glGetShaderiv; -GLAPI PFNGLGETSHADERIVPROC glad_debug_glGetShaderiv; -#define glGetShaderiv glad_debug_glGetShaderiv +#define glGetShaderiv glad_glGetShaderiv typedef void (APIENTRYP PFNGLGETSHADERINFOLOGPROC)(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog); GLAPI PFNGLGETSHADERINFOLOGPROC glad_glGetShaderInfoLog; -GLAPI PFNGLGETSHADERINFOLOGPROC glad_debug_glGetShaderInfoLog; -#define glGetShaderInfoLog glad_debug_glGetShaderInfoLog +#define glGetShaderInfoLog glad_glGetShaderInfoLog typedef void (APIENTRYP PFNGLGETSHADERSOURCEPROC)(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source); GLAPI PFNGLGETSHADERSOURCEPROC glad_glGetShaderSource; -GLAPI PFNGLGETSHADERSOURCEPROC glad_debug_glGetShaderSource; -#define glGetShaderSource glad_debug_glGetShaderSource +#define glGetShaderSource glad_glGetShaderSource typedef GLint (APIENTRYP PFNGLGETUNIFORMLOCATIONPROC)(GLuint program, const GLchar *name); GLAPI PFNGLGETUNIFORMLOCATIONPROC glad_glGetUniformLocation; -GLAPI PFNGLGETUNIFORMLOCATIONPROC glad_debug_glGetUniformLocation; -#define glGetUniformLocation glad_debug_glGetUniformLocation +#define glGetUniformLocation glad_glGetUniformLocation typedef void (APIENTRYP PFNGLGETUNIFORMFVPROC)(GLuint program, GLint location, GLfloat *params); GLAPI PFNGLGETUNIFORMFVPROC glad_glGetUniformfv; -GLAPI PFNGLGETUNIFORMFVPROC glad_debug_glGetUniformfv; -#define glGetUniformfv glad_debug_glGetUniformfv +#define glGetUniformfv glad_glGetUniformfv typedef void (APIENTRYP PFNGLGETUNIFORMIVPROC)(GLuint program, GLint location, GLint *params); GLAPI PFNGLGETUNIFORMIVPROC glad_glGetUniformiv; -GLAPI PFNGLGETUNIFORMIVPROC glad_debug_glGetUniformiv; -#define glGetUniformiv glad_debug_glGetUniformiv +#define glGetUniformiv glad_glGetUniformiv typedef void (APIENTRYP PFNGLGETVERTEXATTRIBDVPROC)(GLuint index, GLenum pname, GLdouble *params); GLAPI PFNGLGETVERTEXATTRIBDVPROC glad_glGetVertexAttribdv; -GLAPI PFNGLGETVERTEXATTRIBDVPROC glad_debug_glGetVertexAttribdv; -#define glGetVertexAttribdv glad_debug_glGetVertexAttribdv +#define glGetVertexAttribdv glad_glGetVertexAttribdv typedef void (APIENTRYP PFNGLGETVERTEXATTRIBFVPROC)(GLuint index, GLenum pname, GLfloat *params); GLAPI PFNGLGETVERTEXATTRIBFVPROC glad_glGetVertexAttribfv; -GLAPI PFNGLGETVERTEXATTRIBFVPROC glad_debug_glGetVertexAttribfv; -#define glGetVertexAttribfv glad_debug_glGetVertexAttribfv +#define glGetVertexAttribfv glad_glGetVertexAttribfv typedef void (APIENTRYP PFNGLGETVERTEXATTRIBIVPROC)(GLuint index, GLenum pname, GLint *params); GLAPI PFNGLGETVERTEXATTRIBIVPROC glad_glGetVertexAttribiv; -GLAPI PFNGLGETVERTEXATTRIBIVPROC glad_debug_glGetVertexAttribiv; -#define glGetVertexAttribiv glad_debug_glGetVertexAttribiv +#define glGetVertexAttribiv glad_glGetVertexAttribiv typedef void (APIENTRYP PFNGLGETVERTEXATTRIBPOINTERVPROC)(GLuint index, GLenum pname, void **pointer); GLAPI PFNGLGETVERTEXATTRIBPOINTERVPROC glad_glGetVertexAttribPointerv; -GLAPI PFNGLGETVERTEXATTRIBPOINTERVPROC glad_debug_glGetVertexAttribPointerv; -#define glGetVertexAttribPointerv glad_debug_glGetVertexAttribPointerv +#define glGetVertexAttribPointerv glad_glGetVertexAttribPointerv typedef GLboolean (APIENTRYP PFNGLISPROGRAMPROC)(GLuint program); GLAPI PFNGLISPROGRAMPROC glad_glIsProgram; -GLAPI PFNGLISPROGRAMPROC glad_debug_glIsProgram; -#define glIsProgram glad_debug_glIsProgram +#define glIsProgram glad_glIsProgram typedef GLboolean (APIENTRYP PFNGLISSHADERPROC)(GLuint shader); GLAPI PFNGLISSHADERPROC glad_glIsShader; -GLAPI PFNGLISSHADERPROC glad_debug_glIsShader; -#define glIsShader glad_debug_glIsShader +#define glIsShader glad_glIsShader typedef void (APIENTRYP PFNGLLINKPROGRAMPROC)(GLuint program); GLAPI PFNGLLINKPROGRAMPROC glad_glLinkProgram; -GLAPI PFNGLLINKPROGRAMPROC glad_debug_glLinkProgram; -#define glLinkProgram glad_debug_glLinkProgram +#define glLinkProgram glad_glLinkProgram typedef void (APIENTRYP PFNGLSHADERSOURCEPROC)(GLuint shader, GLsizei count, const GLchar *const*string, const GLint *length); GLAPI PFNGLSHADERSOURCEPROC glad_glShaderSource; -GLAPI PFNGLSHADERSOURCEPROC glad_debug_glShaderSource; -#define glShaderSource glad_debug_glShaderSource +#define glShaderSource glad_glShaderSource typedef void (APIENTRYP PFNGLUSEPROGRAMPROC)(GLuint program); GLAPI PFNGLUSEPROGRAMPROC glad_glUseProgram; -GLAPI PFNGLUSEPROGRAMPROC glad_debug_glUseProgram; -#define glUseProgram glad_debug_glUseProgram +#define glUseProgram glad_glUseProgram typedef void (APIENTRYP PFNGLUNIFORM1FPROC)(GLint location, GLfloat v0); GLAPI PFNGLUNIFORM1FPROC glad_glUniform1f; -GLAPI PFNGLUNIFORM1FPROC glad_debug_glUniform1f; -#define glUniform1f glad_debug_glUniform1f +#define glUniform1f glad_glUniform1f typedef void (APIENTRYP PFNGLUNIFORM2FPROC)(GLint location, GLfloat v0, GLfloat v1); GLAPI PFNGLUNIFORM2FPROC glad_glUniform2f; -GLAPI PFNGLUNIFORM2FPROC glad_debug_glUniform2f; -#define glUniform2f glad_debug_glUniform2f +#define glUniform2f glad_glUniform2f typedef void (APIENTRYP PFNGLUNIFORM3FPROC)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2); GLAPI PFNGLUNIFORM3FPROC glad_glUniform3f; -GLAPI PFNGLUNIFORM3FPROC glad_debug_glUniform3f; -#define glUniform3f glad_debug_glUniform3f +#define glUniform3f glad_glUniform3f typedef void (APIENTRYP PFNGLUNIFORM4FPROC)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); GLAPI PFNGLUNIFORM4FPROC glad_glUniform4f; -GLAPI PFNGLUNIFORM4FPROC glad_debug_glUniform4f; -#define glUniform4f glad_debug_glUniform4f +#define glUniform4f glad_glUniform4f typedef void (APIENTRYP PFNGLUNIFORM1IPROC)(GLint location, GLint v0); GLAPI PFNGLUNIFORM1IPROC glad_glUniform1i; -GLAPI PFNGLUNIFORM1IPROC glad_debug_glUniform1i; -#define glUniform1i glad_debug_glUniform1i +#define glUniform1i glad_glUniform1i typedef void (APIENTRYP PFNGLUNIFORM2IPROC)(GLint location, GLint v0, GLint v1); GLAPI PFNGLUNIFORM2IPROC glad_glUniform2i; -GLAPI PFNGLUNIFORM2IPROC glad_debug_glUniform2i; -#define glUniform2i glad_debug_glUniform2i +#define glUniform2i glad_glUniform2i typedef void (APIENTRYP PFNGLUNIFORM3IPROC)(GLint location, GLint v0, GLint v1, GLint v2); GLAPI PFNGLUNIFORM3IPROC glad_glUniform3i; -GLAPI PFNGLUNIFORM3IPROC glad_debug_glUniform3i; -#define glUniform3i glad_debug_glUniform3i +#define glUniform3i glad_glUniform3i typedef void (APIENTRYP PFNGLUNIFORM4IPROC)(GLint location, GLint v0, GLint v1, GLint v2, GLint v3); GLAPI PFNGLUNIFORM4IPROC glad_glUniform4i; -GLAPI PFNGLUNIFORM4IPROC glad_debug_glUniform4i; -#define glUniform4i glad_debug_glUniform4i +#define glUniform4i glad_glUniform4i typedef void (APIENTRYP PFNGLUNIFORM1FVPROC)(GLint location, GLsizei count, const GLfloat *value); GLAPI PFNGLUNIFORM1FVPROC glad_glUniform1fv; -GLAPI PFNGLUNIFORM1FVPROC glad_debug_glUniform1fv; -#define glUniform1fv glad_debug_glUniform1fv +#define glUniform1fv glad_glUniform1fv typedef void (APIENTRYP PFNGLUNIFORM2FVPROC)(GLint location, GLsizei count, const GLfloat *value); GLAPI PFNGLUNIFORM2FVPROC glad_glUniform2fv; -GLAPI PFNGLUNIFORM2FVPROC glad_debug_glUniform2fv; -#define glUniform2fv glad_debug_glUniform2fv +#define glUniform2fv glad_glUniform2fv typedef void (APIENTRYP PFNGLUNIFORM3FVPROC)(GLint location, GLsizei count, const GLfloat *value); GLAPI PFNGLUNIFORM3FVPROC glad_glUniform3fv; -GLAPI PFNGLUNIFORM3FVPROC glad_debug_glUniform3fv; -#define glUniform3fv glad_debug_glUniform3fv +#define glUniform3fv glad_glUniform3fv typedef void (APIENTRYP PFNGLUNIFORM4FVPROC)(GLint location, GLsizei count, const GLfloat *value); GLAPI PFNGLUNIFORM4FVPROC glad_glUniform4fv; -GLAPI PFNGLUNIFORM4FVPROC glad_debug_glUniform4fv; -#define glUniform4fv glad_debug_glUniform4fv +#define glUniform4fv glad_glUniform4fv typedef void (APIENTRYP PFNGLUNIFORM1IVPROC)(GLint location, GLsizei count, const GLint *value); GLAPI PFNGLUNIFORM1IVPROC glad_glUniform1iv; -GLAPI PFNGLUNIFORM1IVPROC glad_debug_glUniform1iv; -#define glUniform1iv glad_debug_glUniform1iv +#define glUniform1iv glad_glUniform1iv typedef void (APIENTRYP PFNGLUNIFORM2IVPROC)(GLint location, GLsizei count, const GLint *value); GLAPI PFNGLUNIFORM2IVPROC glad_glUniform2iv; -GLAPI PFNGLUNIFORM2IVPROC glad_debug_glUniform2iv; -#define glUniform2iv glad_debug_glUniform2iv +#define glUniform2iv glad_glUniform2iv typedef void (APIENTRYP PFNGLUNIFORM3IVPROC)(GLint location, GLsizei count, const GLint *value); GLAPI PFNGLUNIFORM3IVPROC glad_glUniform3iv; -GLAPI PFNGLUNIFORM3IVPROC glad_debug_glUniform3iv; -#define glUniform3iv glad_debug_glUniform3iv +#define glUniform3iv glad_glUniform3iv typedef void (APIENTRYP PFNGLUNIFORM4IVPROC)(GLint location, GLsizei count, const GLint *value); GLAPI PFNGLUNIFORM4IVPROC glad_glUniform4iv; -GLAPI PFNGLUNIFORM4IVPROC glad_debug_glUniform4iv; -#define glUniform4iv glad_debug_glUniform4iv +#define glUniform4iv glad_glUniform4iv typedef void (APIENTRYP PFNGLUNIFORMMATRIX2FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); GLAPI PFNGLUNIFORMMATRIX2FVPROC glad_glUniformMatrix2fv; -GLAPI PFNGLUNIFORMMATRIX2FVPROC glad_debug_glUniformMatrix2fv; -#define glUniformMatrix2fv glad_debug_glUniformMatrix2fv +#define glUniformMatrix2fv glad_glUniformMatrix2fv typedef void (APIENTRYP PFNGLUNIFORMMATRIX3FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); GLAPI PFNGLUNIFORMMATRIX3FVPROC glad_glUniformMatrix3fv; -GLAPI PFNGLUNIFORMMATRIX3FVPROC glad_debug_glUniformMatrix3fv; -#define glUniformMatrix3fv glad_debug_glUniformMatrix3fv +#define glUniformMatrix3fv glad_glUniformMatrix3fv typedef void (APIENTRYP PFNGLUNIFORMMATRIX4FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); GLAPI PFNGLUNIFORMMATRIX4FVPROC glad_glUniformMatrix4fv; -GLAPI PFNGLUNIFORMMATRIX4FVPROC glad_debug_glUniformMatrix4fv; -#define glUniformMatrix4fv glad_debug_glUniformMatrix4fv +#define glUniformMatrix4fv glad_glUniformMatrix4fv typedef void (APIENTRYP PFNGLVALIDATEPROGRAMPROC)(GLuint program); GLAPI PFNGLVALIDATEPROGRAMPROC glad_glValidateProgram; -GLAPI PFNGLVALIDATEPROGRAMPROC glad_debug_glValidateProgram; -#define glValidateProgram glad_debug_glValidateProgram +#define glValidateProgram glad_glValidateProgram typedef void (APIENTRYP PFNGLVERTEXATTRIB1DPROC)(GLuint index, GLdouble x); GLAPI PFNGLVERTEXATTRIB1DPROC glad_glVertexAttrib1d; -GLAPI PFNGLVERTEXATTRIB1DPROC glad_debug_glVertexAttrib1d; -#define glVertexAttrib1d glad_debug_glVertexAttrib1d +#define glVertexAttrib1d glad_glVertexAttrib1d typedef void (APIENTRYP PFNGLVERTEXATTRIB1DVPROC)(GLuint index, const GLdouble *v); GLAPI PFNGLVERTEXATTRIB1DVPROC glad_glVertexAttrib1dv; -GLAPI PFNGLVERTEXATTRIB1DVPROC glad_debug_glVertexAttrib1dv; -#define glVertexAttrib1dv glad_debug_glVertexAttrib1dv +#define glVertexAttrib1dv glad_glVertexAttrib1dv typedef void (APIENTRYP PFNGLVERTEXATTRIB1FPROC)(GLuint index, GLfloat x); GLAPI PFNGLVERTEXATTRIB1FPROC glad_glVertexAttrib1f; -GLAPI PFNGLVERTEXATTRIB1FPROC glad_debug_glVertexAttrib1f; -#define glVertexAttrib1f glad_debug_glVertexAttrib1f +#define glVertexAttrib1f glad_glVertexAttrib1f typedef void (APIENTRYP PFNGLVERTEXATTRIB1FVPROC)(GLuint index, const GLfloat *v); GLAPI PFNGLVERTEXATTRIB1FVPROC glad_glVertexAttrib1fv; -GLAPI PFNGLVERTEXATTRIB1FVPROC glad_debug_glVertexAttrib1fv; -#define glVertexAttrib1fv glad_debug_glVertexAttrib1fv +#define glVertexAttrib1fv glad_glVertexAttrib1fv typedef void (APIENTRYP PFNGLVERTEXATTRIB1SPROC)(GLuint index, GLshort x); GLAPI PFNGLVERTEXATTRIB1SPROC glad_glVertexAttrib1s; -GLAPI PFNGLVERTEXATTRIB1SPROC glad_debug_glVertexAttrib1s; -#define glVertexAttrib1s glad_debug_glVertexAttrib1s +#define glVertexAttrib1s glad_glVertexAttrib1s typedef void (APIENTRYP PFNGLVERTEXATTRIB1SVPROC)(GLuint index, const GLshort *v); GLAPI PFNGLVERTEXATTRIB1SVPROC glad_glVertexAttrib1sv; -GLAPI PFNGLVERTEXATTRIB1SVPROC glad_debug_glVertexAttrib1sv; -#define glVertexAttrib1sv glad_debug_glVertexAttrib1sv +#define glVertexAttrib1sv glad_glVertexAttrib1sv typedef void (APIENTRYP PFNGLVERTEXATTRIB2DPROC)(GLuint index, GLdouble x, GLdouble y); GLAPI PFNGLVERTEXATTRIB2DPROC glad_glVertexAttrib2d; -GLAPI PFNGLVERTEXATTRIB2DPROC glad_debug_glVertexAttrib2d; -#define glVertexAttrib2d glad_debug_glVertexAttrib2d +#define glVertexAttrib2d glad_glVertexAttrib2d typedef void (APIENTRYP PFNGLVERTEXATTRIB2DVPROC)(GLuint index, const GLdouble *v); GLAPI PFNGLVERTEXATTRIB2DVPROC glad_glVertexAttrib2dv; -GLAPI PFNGLVERTEXATTRIB2DVPROC glad_debug_glVertexAttrib2dv; -#define glVertexAttrib2dv glad_debug_glVertexAttrib2dv +#define glVertexAttrib2dv glad_glVertexAttrib2dv typedef void (APIENTRYP PFNGLVERTEXATTRIB2FPROC)(GLuint index, GLfloat x, GLfloat y); GLAPI PFNGLVERTEXATTRIB2FPROC glad_glVertexAttrib2f; -GLAPI PFNGLVERTEXATTRIB2FPROC glad_debug_glVertexAttrib2f; -#define glVertexAttrib2f glad_debug_glVertexAttrib2f +#define glVertexAttrib2f glad_glVertexAttrib2f typedef void (APIENTRYP PFNGLVERTEXATTRIB2FVPROC)(GLuint index, const GLfloat *v); GLAPI PFNGLVERTEXATTRIB2FVPROC glad_glVertexAttrib2fv; -GLAPI PFNGLVERTEXATTRIB2FVPROC glad_debug_glVertexAttrib2fv; -#define glVertexAttrib2fv glad_debug_glVertexAttrib2fv +#define glVertexAttrib2fv glad_glVertexAttrib2fv typedef void (APIENTRYP PFNGLVERTEXATTRIB2SPROC)(GLuint index, GLshort x, GLshort y); GLAPI PFNGLVERTEXATTRIB2SPROC glad_glVertexAttrib2s; -GLAPI PFNGLVERTEXATTRIB2SPROC glad_debug_glVertexAttrib2s; -#define glVertexAttrib2s glad_debug_glVertexAttrib2s +#define glVertexAttrib2s glad_glVertexAttrib2s typedef void (APIENTRYP PFNGLVERTEXATTRIB2SVPROC)(GLuint index, const GLshort *v); GLAPI PFNGLVERTEXATTRIB2SVPROC glad_glVertexAttrib2sv; -GLAPI PFNGLVERTEXATTRIB2SVPROC glad_debug_glVertexAttrib2sv; -#define glVertexAttrib2sv glad_debug_glVertexAttrib2sv +#define glVertexAttrib2sv glad_glVertexAttrib2sv typedef void (APIENTRYP PFNGLVERTEXATTRIB3DPROC)(GLuint index, GLdouble x, GLdouble y, GLdouble z); GLAPI PFNGLVERTEXATTRIB3DPROC glad_glVertexAttrib3d; -GLAPI PFNGLVERTEXATTRIB3DPROC glad_debug_glVertexAttrib3d; -#define glVertexAttrib3d glad_debug_glVertexAttrib3d +#define glVertexAttrib3d glad_glVertexAttrib3d typedef void (APIENTRYP PFNGLVERTEXATTRIB3DVPROC)(GLuint index, const GLdouble *v); GLAPI PFNGLVERTEXATTRIB3DVPROC glad_glVertexAttrib3dv; -GLAPI PFNGLVERTEXATTRIB3DVPROC glad_debug_glVertexAttrib3dv; -#define glVertexAttrib3dv glad_debug_glVertexAttrib3dv +#define glVertexAttrib3dv glad_glVertexAttrib3dv typedef void (APIENTRYP PFNGLVERTEXATTRIB3FPROC)(GLuint index, GLfloat x, GLfloat y, GLfloat z); GLAPI PFNGLVERTEXATTRIB3FPROC glad_glVertexAttrib3f; -GLAPI PFNGLVERTEXATTRIB3FPROC glad_debug_glVertexAttrib3f; -#define glVertexAttrib3f glad_debug_glVertexAttrib3f +#define glVertexAttrib3f glad_glVertexAttrib3f typedef void (APIENTRYP PFNGLVERTEXATTRIB3FVPROC)(GLuint index, const GLfloat *v); GLAPI PFNGLVERTEXATTRIB3FVPROC glad_glVertexAttrib3fv; -GLAPI PFNGLVERTEXATTRIB3FVPROC glad_debug_glVertexAttrib3fv; -#define glVertexAttrib3fv glad_debug_glVertexAttrib3fv +#define glVertexAttrib3fv glad_glVertexAttrib3fv typedef void (APIENTRYP PFNGLVERTEXATTRIB3SPROC)(GLuint index, GLshort x, GLshort y, GLshort z); GLAPI PFNGLVERTEXATTRIB3SPROC glad_glVertexAttrib3s; -GLAPI PFNGLVERTEXATTRIB3SPROC glad_debug_glVertexAttrib3s; -#define glVertexAttrib3s glad_debug_glVertexAttrib3s +#define glVertexAttrib3s glad_glVertexAttrib3s typedef void (APIENTRYP PFNGLVERTEXATTRIB3SVPROC)(GLuint index, const GLshort *v); GLAPI PFNGLVERTEXATTRIB3SVPROC glad_glVertexAttrib3sv; -GLAPI PFNGLVERTEXATTRIB3SVPROC glad_debug_glVertexAttrib3sv; -#define glVertexAttrib3sv glad_debug_glVertexAttrib3sv +#define glVertexAttrib3sv glad_glVertexAttrib3sv typedef void (APIENTRYP PFNGLVERTEXATTRIB4NBVPROC)(GLuint index, const GLbyte *v); GLAPI PFNGLVERTEXATTRIB4NBVPROC glad_glVertexAttrib4Nbv; -GLAPI PFNGLVERTEXATTRIB4NBVPROC glad_debug_glVertexAttrib4Nbv; -#define glVertexAttrib4Nbv glad_debug_glVertexAttrib4Nbv +#define glVertexAttrib4Nbv glad_glVertexAttrib4Nbv typedef void (APIENTRYP PFNGLVERTEXATTRIB4NIVPROC)(GLuint index, const GLint *v); GLAPI PFNGLVERTEXATTRIB4NIVPROC glad_glVertexAttrib4Niv; -GLAPI PFNGLVERTEXATTRIB4NIVPROC glad_debug_glVertexAttrib4Niv; -#define glVertexAttrib4Niv glad_debug_glVertexAttrib4Niv +#define glVertexAttrib4Niv glad_glVertexAttrib4Niv typedef void (APIENTRYP PFNGLVERTEXATTRIB4NSVPROC)(GLuint index, const GLshort *v); GLAPI PFNGLVERTEXATTRIB4NSVPROC glad_glVertexAttrib4Nsv; -GLAPI PFNGLVERTEXATTRIB4NSVPROC glad_debug_glVertexAttrib4Nsv; -#define glVertexAttrib4Nsv glad_debug_glVertexAttrib4Nsv +#define glVertexAttrib4Nsv glad_glVertexAttrib4Nsv typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUBPROC)(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w); GLAPI PFNGLVERTEXATTRIB4NUBPROC glad_glVertexAttrib4Nub; -GLAPI PFNGLVERTEXATTRIB4NUBPROC glad_debug_glVertexAttrib4Nub; -#define glVertexAttrib4Nub glad_debug_glVertexAttrib4Nub +#define glVertexAttrib4Nub glad_glVertexAttrib4Nub typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUBVPROC)(GLuint index, const GLubyte *v); GLAPI PFNGLVERTEXATTRIB4NUBVPROC glad_glVertexAttrib4Nubv; -GLAPI PFNGLVERTEXATTRIB4NUBVPROC glad_debug_glVertexAttrib4Nubv; -#define glVertexAttrib4Nubv glad_debug_glVertexAttrib4Nubv +#define glVertexAttrib4Nubv glad_glVertexAttrib4Nubv typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUIVPROC)(GLuint index, const GLuint *v); GLAPI PFNGLVERTEXATTRIB4NUIVPROC glad_glVertexAttrib4Nuiv; -GLAPI PFNGLVERTEXATTRIB4NUIVPROC glad_debug_glVertexAttrib4Nuiv; -#define glVertexAttrib4Nuiv glad_debug_glVertexAttrib4Nuiv +#define glVertexAttrib4Nuiv glad_glVertexAttrib4Nuiv typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUSVPROC)(GLuint index, const GLushort *v); GLAPI PFNGLVERTEXATTRIB4NUSVPROC glad_glVertexAttrib4Nusv; -GLAPI PFNGLVERTEXATTRIB4NUSVPROC glad_debug_glVertexAttrib4Nusv; -#define glVertexAttrib4Nusv glad_debug_glVertexAttrib4Nusv +#define glVertexAttrib4Nusv glad_glVertexAttrib4Nusv typedef void (APIENTRYP PFNGLVERTEXATTRIB4BVPROC)(GLuint index, const GLbyte *v); GLAPI PFNGLVERTEXATTRIB4BVPROC glad_glVertexAttrib4bv; -GLAPI PFNGLVERTEXATTRIB4BVPROC glad_debug_glVertexAttrib4bv; -#define glVertexAttrib4bv glad_debug_glVertexAttrib4bv +#define glVertexAttrib4bv glad_glVertexAttrib4bv typedef void (APIENTRYP PFNGLVERTEXATTRIB4DPROC)(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); GLAPI PFNGLVERTEXATTRIB4DPROC glad_glVertexAttrib4d; -GLAPI PFNGLVERTEXATTRIB4DPROC glad_debug_glVertexAttrib4d; -#define glVertexAttrib4d glad_debug_glVertexAttrib4d +#define glVertexAttrib4d glad_glVertexAttrib4d typedef void (APIENTRYP PFNGLVERTEXATTRIB4DVPROC)(GLuint index, const GLdouble *v); GLAPI PFNGLVERTEXATTRIB4DVPROC glad_glVertexAttrib4dv; -GLAPI PFNGLVERTEXATTRIB4DVPROC glad_debug_glVertexAttrib4dv; -#define glVertexAttrib4dv glad_debug_glVertexAttrib4dv +#define glVertexAttrib4dv glad_glVertexAttrib4dv typedef void (APIENTRYP PFNGLVERTEXATTRIB4FPROC)(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); GLAPI PFNGLVERTEXATTRIB4FPROC glad_glVertexAttrib4f; -GLAPI PFNGLVERTEXATTRIB4FPROC glad_debug_glVertexAttrib4f; -#define glVertexAttrib4f glad_debug_glVertexAttrib4f +#define glVertexAttrib4f glad_glVertexAttrib4f typedef void (APIENTRYP PFNGLVERTEXATTRIB4FVPROC)(GLuint index, const GLfloat *v); GLAPI PFNGLVERTEXATTRIB4FVPROC glad_glVertexAttrib4fv; -GLAPI PFNGLVERTEXATTRIB4FVPROC glad_debug_glVertexAttrib4fv; -#define glVertexAttrib4fv glad_debug_glVertexAttrib4fv +#define glVertexAttrib4fv glad_glVertexAttrib4fv typedef void (APIENTRYP PFNGLVERTEXATTRIB4IVPROC)(GLuint index, const GLint *v); GLAPI PFNGLVERTEXATTRIB4IVPROC glad_glVertexAttrib4iv; -GLAPI PFNGLVERTEXATTRIB4IVPROC glad_debug_glVertexAttrib4iv; -#define glVertexAttrib4iv glad_debug_glVertexAttrib4iv +#define glVertexAttrib4iv glad_glVertexAttrib4iv typedef void (APIENTRYP PFNGLVERTEXATTRIB4SPROC)(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w); GLAPI PFNGLVERTEXATTRIB4SPROC glad_glVertexAttrib4s; -GLAPI PFNGLVERTEXATTRIB4SPROC glad_debug_glVertexAttrib4s; -#define glVertexAttrib4s glad_debug_glVertexAttrib4s +#define glVertexAttrib4s glad_glVertexAttrib4s typedef void (APIENTRYP PFNGLVERTEXATTRIB4SVPROC)(GLuint index, const GLshort *v); GLAPI PFNGLVERTEXATTRIB4SVPROC glad_glVertexAttrib4sv; -GLAPI PFNGLVERTEXATTRIB4SVPROC glad_debug_glVertexAttrib4sv; -#define glVertexAttrib4sv glad_debug_glVertexAttrib4sv +#define glVertexAttrib4sv glad_glVertexAttrib4sv typedef void (APIENTRYP PFNGLVERTEXATTRIB4UBVPROC)(GLuint index, const GLubyte *v); GLAPI PFNGLVERTEXATTRIB4UBVPROC glad_glVertexAttrib4ubv; -GLAPI PFNGLVERTEXATTRIB4UBVPROC glad_debug_glVertexAttrib4ubv; -#define glVertexAttrib4ubv glad_debug_glVertexAttrib4ubv +#define glVertexAttrib4ubv glad_glVertexAttrib4ubv typedef void (APIENTRYP PFNGLVERTEXATTRIB4UIVPROC)(GLuint index, const GLuint *v); GLAPI PFNGLVERTEXATTRIB4UIVPROC glad_glVertexAttrib4uiv; -GLAPI PFNGLVERTEXATTRIB4UIVPROC glad_debug_glVertexAttrib4uiv; -#define glVertexAttrib4uiv glad_debug_glVertexAttrib4uiv +#define glVertexAttrib4uiv glad_glVertexAttrib4uiv typedef void (APIENTRYP PFNGLVERTEXATTRIB4USVPROC)(GLuint index, const GLushort *v); GLAPI PFNGLVERTEXATTRIB4USVPROC glad_glVertexAttrib4usv; -GLAPI PFNGLVERTEXATTRIB4USVPROC glad_debug_glVertexAttrib4usv; -#define glVertexAttrib4usv glad_debug_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; -GLAPI PFNGLVERTEXATTRIBPOINTERPROC glad_debug_glVertexAttribPointer; -#define glVertexAttribPointer glad_debug_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; -GLAPI PFNGLUNIFORMMATRIX2X3FVPROC glad_debug_glUniformMatrix2x3fv; -#define glUniformMatrix2x3fv glad_debug_glUniformMatrix2x3fv +#define glUniformMatrix2x3fv glad_glUniformMatrix2x3fv typedef void (APIENTRYP PFNGLUNIFORMMATRIX3X2FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); GLAPI PFNGLUNIFORMMATRIX3X2FVPROC glad_glUniformMatrix3x2fv; -GLAPI PFNGLUNIFORMMATRIX3X2FVPROC glad_debug_glUniformMatrix3x2fv; -#define glUniformMatrix3x2fv glad_debug_glUniformMatrix3x2fv +#define glUniformMatrix3x2fv glad_glUniformMatrix3x2fv typedef void (APIENTRYP PFNGLUNIFORMMATRIX2X4FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); GLAPI PFNGLUNIFORMMATRIX2X4FVPROC glad_glUniformMatrix2x4fv; -GLAPI PFNGLUNIFORMMATRIX2X4FVPROC glad_debug_glUniformMatrix2x4fv; -#define glUniformMatrix2x4fv glad_debug_glUniformMatrix2x4fv +#define glUniformMatrix2x4fv glad_glUniformMatrix2x4fv typedef void (APIENTRYP PFNGLUNIFORMMATRIX4X2FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); GLAPI PFNGLUNIFORMMATRIX4X2FVPROC glad_glUniformMatrix4x2fv; -GLAPI PFNGLUNIFORMMATRIX4X2FVPROC glad_debug_glUniformMatrix4x2fv; -#define glUniformMatrix4x2fv glad_debug_glUniformMatrix4x2fv +#define glUniformMatrix4x2fv glad_glUniformMatrix4x2fv typedef void (APIENTRYP PFNGLUNIFORMMATRIX3X4FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); GLAPI PFNGLUNIFORMMATRIX3X4FVPROC glad_glUniformMatrix3x4fv; -GLAPI PFNGLUNIFORMMATRIX3X4FVPROC glad_debug_glUniformMatrix3x4fv; -#define glUniformMatrix3x4fv glad_debug_glUniformMatrix3x4fv +#define glUniformMatrix3x4fv glad_glUniformMatrix3x4fv typedef void (APIENTRYP PFNGLUNIFORMMATRIX4X3FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); GLAPI PFNGLUNIFORMMATRIX4X3FVPROC glad_glUniformMatrix4x3fv; -GLAPI PFNGLUNIFORMMATRIX4X3FVPROC glad_debug_glUniformMatrix4x3fv; -#define glUniformMatrix4x3fv glad_debug_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; -GLAPI PFNGLCOLORMASKIPROC glad_debug_glColorMaski; -#define glColorMaski glad_debug_glColorMaski +#define glColorMaski glad_glColorMaski typedef void (APIENTRYP PFNGLGETBOOLEANI_VPROC)(GLenum target, GLuint index, GLboolean *data); GLAPI PFNGLGETBOOLEANI_VPROC glad_glGetBooleani_v; -GLAPI PFNGLGETBOOLEANI_VPROC glad_debug_glGetBooleani_v; -#define glGetBooleani_v glad_debug_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; -GLAPI PFNGLGETINTEGERI_VPROC glad_debug_glGetIntegeri_v; -#define glGetIntegeri_v glad_debug_glGetIntegeri_v +#define glGetIntegeri_v glad_glGetIntegeri_v typedef void (APIENTRYP PFNGLENABLEIPROC)(GLenum target, GLuint index); GLAPI PFNGLENABLEIPROC glad_glEnablei; -GLAPI PFNGLENABLEIPROC glad_debug_glEnablei; -#define glEnablei glad_debug_glEnablei +#define glEnablei glad_glEnablei typedef void (APIENTRYP PFNGLDISABLEIPROC)(GLenum target, GLuint index); GLAPI PFNGLDISABLEIPROC glad_glDisablei; -GLAPI PFNGLDISABLEIPROC glad_debug_glDisablei; -#define glDisablei glad_debug_glDisablei +#define glDisablei glad_glDisablei typedef GLboolean (APIENTRYP PFNGLISENABLEDIPROC)(GLenum target, GLuint index); GLAPI PFNGLISENABLEDIPROC glad_glIsEnabledi; -GLAPI PFNGLISENABLEDIPROC glad_debug_glIsEnabledi; -#define glIsEnabledi glad_debug_glIsEnabledi +#define glIsEnabledi glad_glIsEnabledi typedef void (APIENTRYP PFNGLBEGINTRANSFORMFEEDBACKPROC)(GLenum primitiveMode); GLAPI PFNGLBEGINTRANSFORMFEEDBACKPROC glad_glBeginTransformFeedback; -GLAPI PFNGLBEGINTRANSFORMFEEDBACKPROC glad_debug_glBeginTransformFeedback; -#define glBeginTransformFeedback glad_debug_glBeginTransformFeedback -typedef void (APIENTRYP PFNGLENDTRANSFORMFEEDBACKPROC)(); +#define glBeginTransformFeedback glad_glBeginTransformFeedback +typedef void (APIENTRYP PFNGLENDTRANSFORMFEEDBACKPROC)(void); GLAPI PFNGLENDTRANSFORMFEEDBACKPROC glad_glEndTransformFeedback; -GLAPI PFNGLENDTRANSFORMFEEDBACKPROC glad_debug_glEndTransformFeedback; -#define glEndTransformFeedback glad_debug_glEndTransformFeedback +#define glEndTransformFeedback glad_glEndTransformFeedback typedef void (APIENTRYP PFNGLBINDBUFFERRANGEPROC)(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size); GLAPI PFNGLBINDBUFFERRANGEPROC glad_glBindBufferRange; -GLAPI PFNGLBINDBUFFERRANGEPROC glad_debug_glBindBufferRange; -#define glBindBufferRange glad_debug_glBindBufferRange +#define glBindBufferRange glad_glBindBufferRange typedef void (APIENTRYP PFNGLBINDBUFFERBASEPROC)(GLenum target, GLuint index, GLuint buffer); GLAPI PFNGLBINDBUFFERBASEPROC glad_glBindBufferBase; -GLAPI PFNGLBINDBUFFERBASEPROC glad_debug_glBindBufferBase; -#define glBindBufferBase glad_debug_glBindBufferBase +#define glBindBufferBase glad_glBindBufferBase typedef void (APIENTRYP PFNGLTRANSFORMFEEDBACKVARYINGSPROC)(GLuint program, GLsizei count, const GLchar *const*varyings, GLenum bufferMode); GLAPI PFNGLTRANSFORMFEEDBACKVARYINGSPROC glad_glTransformFeedbackVaryings; -GLAPI PFNGLTRANSFORMFEEDBACKVARYINGSPROC glad_debug_glTransformFeedbackVaryings; -#define glTransformFeedbackVaryings glad_debug_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; -GLAPI PFNGLGETTRANSFORMFEEDBACKVARYINGPROC glad_debug_glGetTransformFeedbackVarying; -#define glGetTransformFeedbackVarying glad_debug_glGetTransformFeedbackVarying +#define glGetTransformFeedbackVarying glad_glGetTransformFeedbackVarying typedef void (APIENTRYP PFNGLCLAMPCOLORPROC)(GLenum target, GLenum clamp); GLAPI PFNGLCLAMPCOLORPROC glad_glClampColor; -GLAPI PFNGLCLAMPCOLORPROC glad_debug_glClampColor; -#define glClampColor glad_debug_glClampColor +#define glClampColor glad_glClampColor typedef void (APIENTRYP PFNGLBEGINCONDITIONALRENDERPROC)(GLuint id, GLenum mode); GLAPI PFNGLBEGINCONDITIONALRENDERPROC glad_glBeginConditionalRender; -GLAPI PFNGLBEGINCONDITIONALRENDERPROC glad_debug_glBeginConditionalRender; -#define glBeginConditionalRender glad_debug_glBeginConditionalRender -typedef void (APIENTRYP PFNGLENDCONDITIONALRENDERPROC)(); +#define glBeginConditionalRender glad_glBeginConditionalRender +typedef void (APIENTRYP PFNGLENDCONDITIONALRENDERPROC)(void); GLAPI PFNGLENDCONDITIONALRENDERPROC glad_glEndConditionalRender; -GLAPI PFNGLENDCONDITIONALRENDERPROC glad_debug_glEndConditionalRender; -#define glEndConditionalRender glad_debug_glEndConditionalRender +#define glEndConditionalRender glad_glEndConditionalRender typedef void (APIENTRYP PFNGLVERTEXATTRIBIPOINTERPROC)(GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer); GLAPI PFNGLVERTEXATTRIBIPOINTERPROC glad_glVertexAttribIPointer; -GLAPI PFNGLVERTEXATTRIBIPOINTERPROC glad_debug_glVertexAttribIPointer; -#define glVertexAttribIPointer glad_debug_glVertexAttribIPointer +#define glVertexAttribIPointer glad_glVertexAttribIPointer typedef void (APIENTRYP PFNGLGETVERTEXATTRIBIIVPROC)(GLuint index, GLenum pname, GLint *params); GLAPI PFNGLGETVERTEXATTRIBIIVPROC glad_glGetVertexAttribIiv; -GLAPI PFNGLGETVERTEXATTRIBIIVPROC glad_debug_glGetVertexAttribIiv; -#define glGetVertexAttribIiv glad_debug_glGetVertexAttribIiv +#define glGetVertexAttribIiv glad_glGetVertexAttribIiv typedef void (APIENTRYP PFNGLGETVERTEXATTRIBIUIVPROC)(GLuint index, GLenum pname, GLuint *params); GLAPI PFNGLGETVERTEXATTRIBIUIVPROC glad_glGetVertexAttribIuiv; -GLAPI PFNGLGETVERTEXATTRIBIUIVPROC glad_debug_glGetVertexAttribIuiv; -#define glGetVertexAttribIuiv glad_debug_glGetVertexAttribIuiv +#define glGetVertexAttribIuiv glad_glGetVertexAttribIuiv typedef void (APIENTRYP PFNGLVERTEXATTRIBI1IPROC)(GLuint index, GLint x); GLAPI PFNGLVERTEXATTRIBI1IPROC glad_glVertexAttribI1i; -GLAPI PFNGLVERTEXATTRIBI1IPROC glad_debug_glVertexAttribI1i; -#define glVertexAttribI1i glad_debug_glVertexAttribI1i +#define glVertexAttribI1i glad_glVertexAttribI1i typedef void (APIENTRYP PFNGLVERTEXATTRIBI2IPROC)(GLuint index, GLint x, GLint y); GLAPI PFNGLVERTEXATTRIBI2IPROC glad_glVertexAttribI2i; -GLAPI PFNGLVERTEXATTRIBI2IPROC glad_debug_glVertexAttribI2i; -#define glVertexAttribI2i glad_debug_glVertexAttribI2i +#define glVertexAttribI2i glad_glVertexAttribI2i typedef void (APIENTRYP PFNGLVERTEXATTRIBI3IPROC)(GLuint index, GLint x, GLint y, GLint z); GLAPI PFNGLVERTEXATTRIBI3IPROC glad_glVertexAttribI3i; -GLAPI PFNGLVERTEXATTRIBI3IPROC glad_debug_glVertexAttribI3i; -#define glVertexAttribI3i glad_debug_glVertexAttribI3i +#define glVertexAttribI3i glad_glVertexAttribI3i typedef void (APIENTRYP PFNGLVERTEXATTRIBI4IPROC)(GLuint index, GLint x, GLint y, GLint z, GLint w); GLAPI PFNGLVERTEXATTRIBI4IPROC glad_glVertexAttribI4i; -GLAPI PFNGLVERTEXATTRIBI4IPROC glad_debug_glVertexAttribI4i; -#define glVertexAttribI4i glad_debug_glVertexAttribI4i +#define glVertexAttribI4i glad_glVertexAttribI4i typedef void (APIENTRYP PFNGLVERTEXATTRIBI1UIPROC)(GLuint index, GLuint x); GLAPI PFNGLVERTEXATTRIBI1UIPROC glad_glVertexAttribI1ui; -GLAPI PFNGLVERTEXATTRIBI1UIPROC glad_debug_glVertexAttribI1ui; -#define glVertexAttribI1ui glad_debug_glVertexAttribI1ui +#define glVertexAttribI1ui glad_glVertexAttribI1ui typedef void (APIENTRYP PFNGLVERTEXATTRIBI2UIPROC)(GLuint index, GLuint x, GLuint y); GLAPI PFNGLVERTEXATTRIBI2UIPROC glad_glVertexAttribI2ui; -GLAPI PFNGLVERTEXATTRIBI2UIPROC glad_debug_glVertexAttribI2ui; -#define glVertexAttribI2ui glad_debug_glVertexAttribI2ui +#define glVertexAttribI2ui glad_glVertexAttribI2ui typedef void (APIENTRYP PFNGLVERTEXATTRIBI3UIPROC)(GLuint index, GLuint x, GLuint y, GLuint z); GLAPI PFNGLVERTEXATTRIBI3UIPROC glad_glVertexAttribI3ui; -GLAPI PFNGLVERTEXATTRIBI3UIPROC glad_debug_glVertexAttribI3ui; -#define glVertexAttribI3ui glad_debug_glVertexAttribI3ui +#define glVertexAttribI3ui glad_glVertexAttribI3ui typedef void (APIENTRYP PFNGLVERTEXATTRIBI4UIPROC)(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w); GLAPI PFNGLVERTEXATTRIBI4UIPROC glad_glVertexAttribI4ui; -GLAPI PFNGLVERTEXATTRIBI4UIPROC glad_debug_glVertexAttribI4ui; -#define glVertexAttribI4ui glad_debug_glVertexAttribI4ui +#define glVertexAttribI4ui glad_glVertexAttribI4ui typedef void (APIENTRYP PFNGLVERTEXATTRIBI1IVPROC)(GLuint index, const GLint *v); GLAPI PFNGLVERTEXATTRIBI1IVPROC glad_glVertexAttribI1iv; -GLAPI PFNGLVERTEXATTRIBI1IVPROC glad_debug_glVertexAttribI1iv; -#define glVertexAttribI1iv glad_debug_glVertexAttribI1iv +#define glVertexAttribI1iv glad_glVertexAttribI1iv typedef void (APIENTRYP PFNGLVERTEXATTRIBI2IVPROC)(GLuint index, const GLint *v); GLAPI PFNGLVERTEXATTRIBI2IVPROC glad_glVertexAttribI2iv; -GLAPI PFNGLVERTEXATTRIBI2IVPROC glad_debug_glVertexAttribI2iv; -#define glVertexAttribI2iv glad_debug_glVertexAttribI2iv +#define glVertexAttribI2iv glad_glVertexAttribI2iv typedef void (APIENTRYP PFNGLVERTEXATTRIBI3IVPROC)(GLuint index, const GLint *v); GLAPI PFNGLVERTEXATTRIBI3IVPROC glad_glVertexAttribI3iv; -GLAPI PFNGLVERTEXATTRIBI3IVPROC glad_debug_glVertexAttribI3iv; -#define glVertexAttribI3iv glad_debug_glVertexAttribI3iv +#define glVertexAttribI3iv glad_glVertexAttribI3iv typedef void (APIENTRYP PFNGLVERTEXATTRIBI4IVPROC)(GLuint index, const GLint *v); GLAPI PFNGLVERTEXATTRIBI4IVPROC glad_glVertexAttribI4iv; -GLAPI PFNGLVERTEXATTRIBI4IVPROC glad_debug_glVertexAttribI4iv; -#define glVertexAttribI4iv glad_debug_glVertexAttribI4iv +#define glVertexAttribI4iv glad_glVertexAttribI4iv typedef void (APIENTRYP PFNGLVERTEXATTRIBI1UIVPROC)(GLuint index, const GLuint *v); GLAPI PFNGLVERTEXATTRIBI1UIVPROC glad_glVertexAttribI1uiv; -GLAPI PFNGLVERTEXATTRIBI1UIVPROC glad_debug_glVertexAttribI1uiv; -#define glVertexAttribI1uiv glad_debug_glVertexAttribI1uiv +#define glVertexAttribI1uiv glad_glVertexAttribI1uiv typedef void (APIENTRYP PFNGLVERTEXATTRIBI2UIVPROC)(GLuint index, const GLuint *v); GLAPI PFNGLVERTEXATTRIBI2UIVPROC glad_glVertexAttribI2uiv; -GLAPI PFNGLVERTEXATTRIBI2UIVPROC glad_debug_glVertexAttribI2uiv; -#define glVertexAttribI2uiv glad_debug_glVertexAttribI2uiv +#define glVertexAttribI2uiv glad_glVertexAttribI2uiv typedef void (APIENTRYP PFNGLVERTEXATTRIBI3UIVPROC)(GLuint index, const GLuint *v); GLAPI PFNGLVERTEXATTRIBI3UIVPROC glad_glVertexAttribI3uiv; -GLAPI PFNGLVERTEXATTRIBI3UIVPROC glad_debug_glVertexAttribI3uiv; -#define glVertexAttribI3uiv glad_debug_glVertexAttribI3uiv +#define glVertexAttribI3uiv glad_glVertexAttribI3uiv typedef void (APIENTRYP PFNGLVERTEXATTRIBI4UIVPROC)(GLuint index, const GLuint *v); GLAPI PFNGLVERTEXATTRIBI4UIVPROC glad_glVertexAttribI4uiv; -GLAPI PFNGLVERTEXATTRIBI4UIVPROC glad_debug_glVertexAttribI4uiv; -#define glVertexAttribI4uiv glad_debug_glVertexAttribI4uiv +#define glVertexAttribI4uiv glad_glVertexAttribI4uiv typedef void (APIENTRYP PFNGLVERTEXATTRIBI4BVPROC)(GLuint index, const GLbyte *v); GLAPI PFNGLVERTEXATTRIBI4BVPROC glad_glVertexAttribI4bv; -GLAPI PFNGLVERTEXATTRIBI4BVPROC glad_debug_glVertexAttribI4bv; -#define glVertexAttribI4bv glad_debug_glVertexAttribI4bv +#define glVertexAttribI4bv glad_glVertexAttribI4bv typedef void (APIENTRYP PFNGLVERTEXATTRIBI4SVPROC)(GLuint index, const GLshort *v); GLAPI PFNGLVERTEXATTRIBI4SVPROC glad_glVertexAttribI4sv; -GLAPI PFNGLVERTEXATTRIBI4SVPROC glad_debug_glVertexAttribI4sv; -#define glVertexAttribI4sv glad_debug_glVertexAttribI4sv +#define glVertexAttribI4sv glad_glVertexAttribI4sv typedef void (APIENTRYP PFNGLVERTEXATTRIBI4UBVPROC)(GLuint index, const GLubyte *v); GLAPI PFNGLVERTEXATTRIBI4UBVPROC glad_glVertexAttribI4ubv; -GLAPI PFNGLVERTEXATTRIBI4UBVPROC glad_debug_glVertexAttribI4ubv; -#define glVertexAttribI4ubv glad_debug_glVertexAttribI4ubv +#define glVertexAttribI4ubv glad_glVertexAttribI4ubv typedef void (APIENTRYP PFNGLVERTEXATTRIBI4USVPROC)(GLuint index, const GLushort *v); GLAPI PFNGLVERTEXATTRIBI4USVPROC glad_glVertexAttribI4usv; -GLAPI PFNGLVERTEXATTRIBI4USVPROC glad_debug_glVertexAttribI4usv; -#define glVertexAttribI4usv glad_debug_glVertexAttribI4usv +#define glVertexAttribI4usv glad_glVertexAttribI4usv typedef void (APIENTRYP PFNGLGETUNIFORMUIVPROC)(GLuint program, GLint location, GLuint *params); GLAPI PFNGLGETUNIFORMUIVPROC glad_glGetUniformuiv; -GLAPI PFNGLGETUNIFORMUIVPROC glad_debug_glGetUniformuiv; -#define glGetUniformuiv glad_debug_glGetUniformuiv +#define glGetUniformuiv glad_glGetUniformuiv typedef void (APIENTRYP PFNGLBINDFRAGDATALOCATIONPROC)(GLuint program, GLuint color, const GLchar *name); GLAPI PFNGLBINDFRAGDATALOCATIONPROC glad_glBindFragDataLocation; -GLAPI PFNGLBINDFRAGDATALOCATIONPROC glad_debug_glBindFragDataLocation; -#define glBindFragDataLocation glad_debug_glBindFragDataLocation +#define glBindFragDataLocation glad_glBindFragDataLocation typedef GLint (APIENTRYP PFNGLGETFRAGDATALOCATIONPROC)(GLuint program, const GLchar *name); GLAPI PFNGLGETFRAGDATALOCATIONPROC glad_glGetFragDataLocation; -GLAPI PFNGLGETFRAGDATALOCATIONPROC glad_debug_glGetFragDataLocation; -#define glGetFragDataLocation glad_debug_glGetFragDataLocation +#define glGetFragDataLocation glad_glGetFragDataLocation typedef void (APIENTRYP PFNGLUNIFORM1UIPROC)(GLint location, GLuint v0); GLAPI PFNGLUNIFORM1UIPROC glad_glUniform1ui; -GLAPI PFNGLUNIFORM1UIPROC glad_debug_glUniform1ui; -#define glUniform1ui glad_debug_glUniform1ui +#define glUniform1ui glad_glUniform1ui typedef void (APIENTRYP PFNGLUNIFORM2UIPROC)(GLint location, GLuint v0, GLuint v1); GLAPI PFNGLUNIFORM2UIPROC glad_glUniform2ui; -GLAPI PFNGLUNIFORM2UIPROC glad_debug_glUniform2ui; -#define glUniform2ui glad_debug_glUniform2ui +#define glUniform2ui glad_glUniform2ui typedef void (APIENTRYP PFNGLUNIFORM3UIPROC)(GLint location, GLuint v0, GLuint v1, GLuint v2); GLAPI PFNGLUNIFORM3UIPROC glad_glUniform3ui; -GLAPI PFNGLUNIFORM3UIPROC glad_debug_glUniform3ui; -#define glUniform3ui glad_debug_glUniform3ui +#define glUniform3ui glad_glUniform3ui typedef void (APIENTRYP PFNGLUNIFORM4UIPROC)(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3); GLAPI PFNGLUNIFORM4UIPROC glad_glUniform4ui; -GLAPI PFNGLUNIFORM4UIPROC glad_debug_glUniform4ui; -#define glUniform4ui glad_debug_glUniform4ui +#define glUniform4ui glad_glUniform4ui typedef void (APIENTRYP PFNGLUNIFORM1UIVPROC)(GLint location, GLsizei count, const GLuint *value); GLAPI PFNGLUNIFORM1UIVPROC glad_glUniform1uiv; -GLAPI PFNGLUNIFORM1UIVPROC glad_debug_glUniform1uiv; -#define glUniform1uiv glad_debug_glUniform1uiv +#define glUniform1uiv glad_glUniform1uiv typedef void (APIENTRYP PFNGLUNIFORM2UIVPROC)(GLint location, GLsizei count, const GLuint *value); GLAPI PFNGLUNIFORM2UIVPROC glad_glUniform2uiv; -GLAPI PFNGLUNIFORM2UIVPROC glad_debug_glUniform2uiv; -#define glUniform2uiv glad_debug_glUniform2uiv +#define glUniform2uiv glad_glUniform2uiv typedef void (APIENTRYP PFNGLUNIFORM3UIVPROC)(GLint location, GLsizei count, const GLuint *value); GLAPI PFNGLUNIFORM3UIVPROC glad_glUniform3uiv; -GLAPI PFNGLUNIFORM3UIVPROC glad_debug_glUniform3uiv; -#define glUniform3uiv glad_debug_glUniform3uiv +#define glUniform3uiv glad_glUniform3uiv typedef void (APIENTRYP PFNGLUNIFORM4UIVPROC)(GLint location, GLsizei count, const GLuint *value); GLAPI PFNGLUNIFORM4UIVPROC glad_glUniform4uiv; -GLAPI PFNGLUNIFORM4UIVPROC glad_debug_glUniform4uiv; -#define glUniform4uiv glad_debug_glUniform4uiv +#define glUniform4uiv glad_glUniform4uiv typedef void (APIENTRYP PFNGLTEXPARAMETERIIVPROC)(GLenum target, GLenum pname, const GLint *params); GLAPI PFNGLTEXPARAMETERIIVPROC glad_glTexParameterIiv; -GLAPI PFNGLTEXPARAMETERIIVPROC glad_debug_glTexParameterIiv; -#define glTexParameterIiv glad_debug_glTexParameterIiv +#define glTexParameterIiv glad_glTexParameterIiv typedef void (APIENTRYP PFNGLTEXPARAMETERIUIVPROC)(GLenum target, GLenum pname, const GLuint *params); GLAPI PFNGLTEXPARAMETERIUIVPROC glad_glTexParameterIuiv; -GLAPI PFNGLTEXPARAMETERIUIVPROC glad_debug_glTexParameterIuiv; -#define glTexParameterIuiv glad_debug_glTexParameterIuiv +#define glTexParameterIuiv glad_glTexParameterIuiv typedef void (APIENTRYP PFNGLGETTEXPARAMETERIIVPROC)(GLenum target, GLenum pname, GLint *params); GLAPI PFNGLGETTEXPARAMETERIIVPROC glad_glGetTexParameterIiv; -GLAPI PFNGLGETTEXPARAMETERIIVPROC glad_debug_glGetTexParameterIiv; -#define glGetTexParameterIiv glad_debug_glGetTexParameterIiv +#define glGetTexParameterIiv glad_glGetTexParameterIiv typedef void (APIENTRYP PFNGLGETTEXPARAMETERIUIVPROC)(GLenum target, GLenum pname, GLuint *params); GLAPI PFNGLGETTEXPARAMETERIUIVPROC glad_glGetTexParameterIuiv; -GLAPI PFNGLGETTEXPARAMETERIUIVPROC glad_debug_glGetTexParameterIuiv; -#define glGetTexParameterIuiv glad_debug_glGetTexParameterIuiv +#define glGetTexParameterIuiv glad_glGetTexParameterIuiv typedef void (APIENTRYP PFNGLCLEARBUFFERIVPROC)(GLenum buffer, GLint drawbuffer, const GLint *value); GLAPI PFNGLCLEARBUFFERIVPROC glad_glClearBufferiv; -GLAPI PFNGLCLEARBUFFERIVPROC glad_debug_glClearBufferiv; -#define glClearBufferiv glad_debug_glClearBufferiv +#define glClearBufferiv glad_glClearBufferiv typedef void (APIENTRYP PFNGLCLEARBUFFERUIVPROC)(GLenum buffer, GLint drawbuffer, const GLuint *value); GLAPI PFNGLCLEARBUFFERUIVPROC glad_glClearBufferuiv; -GLAPI PFNGLCLEARBUFFERUIVPROC glad_debug_glClearBufferuiv; -#define glClearBufferuiv glad_debug_glClearBufferuiv +#define glClearBufferuiv glad_glClearBufferuiv typedef void (APIENTRYP PFNGLCLEARBUFFERFVPROC)(GLenum buffer, GLint drawbuffer, const GLfloat *value); GLAPI PFNGLCLEARBUFFERFVPROC glad_glClearBufferfv; -GLAPI PFNGLCLEARBUFFERFVPROC glad_debug_glClearBufferfv; -#define glClearBufferfv glad_debug_glClearBufferfv +#define glClearBufferfv glad_glClearBufferfv typedef void (APIENTRYP PFNGLCLEARBUFFERFIPROC)(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil); GLAPI PFNGLCLEARBUFFERFIPROC glad_glClearBufferfi; -GLAPI PFNGLCLEARBUFFERFIPROC glad_debug_glClearBufferfi; -#define glClearBufferfi glad_debug_glClearBufferfi +#define glClearBufferfi glad_glClearBufferfi typedef const GLubyte * (APIENTRYP PFNGLGETSTRINGIPROC)(GLenum name, GLuint index); GLAPI PFNGLGETSTRINGIPROC glad_glGetStringi; -GLAPI PFNGLGETSTRINGIPROC glad_debug_glGetStringi; -#define glGetStringi glad_debug_glGetStringi +#define glGetStringi glad_glGetStringi typedef GLboolean (APIENTRYP PFNGLISRENDERBUFFERPROC)(GLuint renderbuffer); GLAPI PFNGLISRENDERBUFFERPROC glad_glIsRenderbuffer; -GLAPI PFNGLISRENDERBUFFERPROC glad_debug_glIsRenderbuffer; -#define glIsRenderbuffer glad_debug_glIsRenderbuffer +#define glIsRenderbuffer glad_glIsRenderbuffer typedef void (APIENTRYP PFNGLBINDRENDERBUFFERPROC)(GLenum target, GLuint renderbuffer); GLAPI PFNGLBINDRENDERBUFFERPROC glad_glBindRenderbuffer; -GLAPI PFNGLBINDRENDERBUFFERPROC glad_debug_glBindRenderbuffer; -#define glBindRenderbuffer glad_debug_glBindRenderbuffer +#define glBindRenderbuffer glad_glBindRenderbuffer typedef void (APIENTRYP PFNGLDELETERENDERBUFFERSPROC)(GLsizei n, const GLuint *renderbuffers); GLAPI PFNGLDELETERENDERBUFFERSPROC glad_glDeleteRenderbuffers; -GLAPI PFNGLDELETERENDERBUFFERSPROC glad_debug_glDeleteRenderbuffers; -#define glDeleteRenderbuffers glad_debug_glDeleteRenderbuffers +#define glDeleteRenderbuffers glad_glDeleteRenderbuffers typedef void (APIENTRYP PFNGLGENRENDERBUFFERSPROC)(GLsizei n, GLuint *renderbuffers); GLAPI PFNGLGENRENDERBUFFERSPROC glad_glGenRenderbuffers; -GLAPI PFNGLGENRENDERBUFFERSPROC glad_debug_glGenRenderbuffers; -#define glGenRenderbuffers glad_debug_glGenRenderbuffers +#define glGenRenderbuffers glad_glGenRenderbuffers typedef void (APIENTRYP PFNGLRENDERBUFFERSTORAGEPROC)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height); GLAPI PFNGLRENDERBUFFERSTORAGEPROC glad_glRenderbufferStorage; -GLAPI PFNGLRENDERBUFFERSTORAGEPROC glad_debug_glRenderbufferStorage; -#define glRenderbufferStorage glad_debug_glRenderbufferStorage +#define glRenderbufferStorage glad_glRenderbufferStorage typedef void (APIENTRYP PFNGLGETRENDERBUFFERPARAMETERIVPROC)(GLenum target, GLenum pname, GLint *params); GLAPI PFNGLGETRENDERBUFFERPARAMETERIVPROC glad_glGetRenderbufferParameteriv; -GLAPI PFNGLGETRENDERBUFFERPARAMETERIVPROC glad_debug_glGetRenderbufferParameteriv; -#define glGetRenderbufferParameteriv glad_debug_glGetRenderbufferParameteriv +#define glGetRenderbufferParameteriv glad_glGetRenderbufferParameteriv typedef GLboolean (APIENTRYP PFNGLISFRAMEBUFFERPROC)(GLuint framebuffer); GLAPI PFNGLISFRAMEBUFFERPROC glad_glIsFramebuffer; -GLAPI PFNGLISFRAMEBUFFERPROC glad_debug_glIsFramebuffer; -#define glIsFramebuffer glad_debug_glIsFramebuffer +#define glIsFramebuffer glad_glIsFramebuffer typedef void (APIENTRYP PFNGLBINDFRAMEBUFFERPROC)(GLenum target, GLuint framebuffer); GLAPI PFNGLBINDFRAMEBUFFERPROC glad_glBindFramebuffer; -GLAPI PFNGLBINDFRAMEBUFFERPROC glad_debug_glBindFramebuffer; -#define glBindFramebuffer glad_debug_glBindFramebuffer +#define glBindFramebuffer glad_glBindFramebuffer typedef void (APIENTRYP PFNGLDELETEFRAMEBUFFERSPROC)(GLsizei n, const GLuint *framebuffers); GLAPI PFNGLDELETEFRAMEBUFFERSPROC glad_glDeleteFramebuffers; -GLAPI PFNGLDELETEFRAMEBUFFERSPROC glad_debug_glDeleteFramebuffers; -#define glDeleteFramebuffers glad_debug_glDeleteFramebuffers +#define glDeleteFramebuffers glad_glDeleteFramebuffers typedef void (APIENTRYP PFNGLGENFRAMEBUFFERSPROC)(GLsizei n, GLuint *framebuffers); GLAPI PFNGLGENFRAMEBUFFERSPROC glad_glGenFramebuffers; -GLAPI PFNGLGENFRAMEBUFFERSPROC glad_debug_glGenFramebuffers; -#define glGenFramebuffers glad_debug_glGenFramebuffers +#define glGenFramebuffers glad_glGenFramebuffers typedef GLenum (APIENTRYP PFNGLCHECKFRAMEBUFFERSTATUSPROC)(GLenum target); GLAPI PFNGLCHECKFRAMEBUFFERSTATUSPROC glad_glCheckFramebufferStatus; -GLAPI PFNGLCHECKFRAMEBUFFERSTATUSPROC glad_debug_glCheckFramebufferStatus; -#define glCheckFramebufferStatus glad_debug_glCheckFramebufferStatus +#define glCheckFramebufferStatus glad_glCheckFramebufferStatus typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURE1DPROC)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); GLAPI PFNGLFRAMEBUFFERTEXTURE1DPROC glad_glFramebufferTexture1D; -GLAPI PFNGLFRAMEBUFFERTEXTURE1DPROC glad_debug_glFramebufferTexture1D; -#define glFramebufferTexture1D glad_debug_glFramebufferTexture1D +#define glFramebufferTexture1D glad_glFramebufferTexture1D typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURE2DPROC)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); GLAPI PFNGLFRAMEBUFFERTEXTURE2DPROC glad_glFramebufferTexture2D; -GLAPI PFNGLFRAMEBUFFERTEXTURE2DPROC glad_debug_glFramebufferTexture2D; -#define glFramebufferTexture2D glad_debug_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; -GLAPI PFNGLFRAMEBUFFERTEXTURE3DPROC glad_debug_glFramebufferTexture3D; -#define glFramebufferTexture3D glad_debug_glFramebufferTexture3D +#define glFramebufferTexture3D glad_glFramebufferTexture3D typedef void (APIENTRYP PFNGLFRAMEBUFFERRENDERBUFFERPROC)(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); GLAPI PFNGLFRAMEBUFFERRENDERBUFFERPROC glad_glFramebufferRenderbuffer; -GLAPI PFNGLFRAMEBUFFERRENDERBUFFERPROC glad_debug_glFramebufferRenderbuffer; -#define glFramebufferRenderbuffer glad_debug_glFramebufferRenderbuffer +#define glFramebufferRenderbuffer glad_glFramebufferRenderbuffer typedef void (APIENTRYP PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC)(GLenum target, GLenum attachment, GLenum pname, GLint *params); GLAPI PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC glad_glGetFramebufferAttachmentParameteriv; -GLAPI PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC glad_debug_glGetFramebufferAttachmentParameteriv; -#define glGetFramebufferAttachmentParameteriv glad_debug_glGetFramebufferAttachmentParameteriv +#define glGetFramebufferAttachmentParameteriv glad_glGetFramebufferAttachmentParameteriv typedef void (APIENTRYP PFNGLGENERATEMIPMAPPROC)(GLenum target); GLAPI PFNGLGENERATEMIPMAPPROC glad_glGenerateMipmap; -GLAPI PFNGLGENERATEMIPMAPPROC glad_debug_glGenerateMipmap; -#define glGenerateMipmap glad_debug_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; -GLAPI PFNGLBLITFRAMEBUFFERPROC glad_debug_glBlitFramebuffer; -#define glBlitFramebuffer glad_debug_glBlitFramebuffer +#define glBlitFramebuffer glad_glBlitFramebuffer typedef void (APIENTRYP PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height); GLAPI PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC glad_glRenderbufferStorageMultisample; -GLAPI PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC glad_debug_glRenderbufferStorageMultisample; -#define glRenderbufferStorageMultisample glad_debug_glRenderbufferStorageMultisample +#define glRenderbufferStorageMultisample glad_glRenderbufferStorageMultisample typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURELAYERPROC)(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer); GLAPI PFNGLFRAMEBUFFERTEXTURELAYERPROC glad_glFramebufferTextureLayer; -GLAPI PFNGLFRAMEBUFFERTEXTURELAYERPROC glad_debug_glFramebufferTextureLayer; -#define glFramebufferTextureLayer glad_debug_glFramebufferTextureLayer +#define glFramebufferTextureLayer glad_glFramebufferTextureLayer typedef void * (APIENTRYP PFNGLMAPBUFFERRANGEPROC)(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access); GLAPI PFNGLMAPBUFFERRANGEPROC glad_glMapBufferRange; -GLAPI PFNGLMAPBUFFERRANGEPROC glad_debug_glMapBufferRange; -#define glMapBufferRange glad_debug_glMapBufferRange +#define glMapBufferRange glad_glMapBufferRange typedef void (APIENTRYP PFNGLFLUSHMAPPEDBUFFERRANGEPROC)(GLenum target, GLintptr offset, GLsizeiptr length); GLAPI PFNGLFLUSHMAPPEDBUFFERRANGEPROC glad_glFlushMappedBufferRange; -GLAPI PFNGLFLUSHMAPPEDBUFFERRANGEPROC glad_debug_glFlushMappedBufferRange; -#define glFlushMappedBufferRange glad_debug_glFlushMappedBufferRange +#define glFlushMappedBufferRange glad_glFlushMappedBufferRange typedef void (APIENTRYP PFNGLBINDVERTEXARRAYPROC)(GLuint array); GLAPI PFNGLBINDVERTEXARRAYPROC glad_glBindVertexArray; -GLAPI PFNGLBINDVERTEXARRAYPROC glad_debug_glBindVertexArray; -#define glBindVertexArray glad_debug_glBindVertexArray +#define glBindVertexArray glad_glBindVertexArray typedef void (APIENTRYP PFNGLDELETEVERTEXARRAYSPROC)(GLsizei n, const GLuint *arrays); GLAPI PFNGLDELETEVERTEXARRAYSPROC glad_glDeleteVertexArrays; -GLAPI PFNGLDELETEVERTEXARRAYSPROC glad_debug_glDeleteVertexArrays; -#define glDeleteVertexArrays glad_debug_glDeleteVertexArrays +#define glDeleteVertexArrays glad_glDeleteVertexArrays typedef void (APIENTRYP PFNGLGENVERTEXARRAYSPROC)(GLsizei n, GLuint *arrays); GLAPI PFNGLGENVERTEXARRAYSPROC glad_glGenVertexArrays; -GLAPI PFNGLGENVERTEXARRAYSPROC glad_debug_glGenVertexArrays; -#define glGenVertexArrays glad_debug_glGenVertexArrays +#define glGenVertexArrays glad_glGenVertexArrays typedef GLboolean (APIENTRYP PFNGLISVERTEXARRAYPROC)(GLuint array); GLAPI PFNGLISVERTEXARRAYPROC glad_glIsVertexArray; -GLAPI PFNGLISVERTEXARRAYPROC glad_debug_glIsVertexArray; -#define glIsVertexArray glad_debug_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; -GLAPI PFNGLDRAWARRAYSINSTANCEDPROC glad_debug_glDrawArraysInstanced; -#define glDrawArraysInstanced glad_debug_glDrawArraysInstanced +#define glDrawArraysInstanced glad_glDrawArraysInstanced typedef void (APIENTRYP PFNGLDRAWELEMENTSINSTANCEDPROC)(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount); GLAPI PFNGLDRAWELEMENTSINSTANCEDPROC glad_glDrawElementsInstanced; -GLAPI PFNGLDRAWELEMENTSINSTANCEDPROC glad_debug_glDrawElementsInstanced; -#define glDrawElementsInstanced glad_debug_glDrawElementsInstanced +#define glDrawElementsInstanced glad_glDrawElementsInstanced typedef void (APIENTRYP PFNGLTEXBUFFERPROC)(GLenum target, GLenum internalformat, GLuint buffer); GLAPI PFNGLTEXBUFFERPROC glad_glTexBuffer; -GLAPI PFNGLTEXBUFFERPROC glad_debug_glTexBuffer; -#define glTexBuffer glad_debug_glTexBuffer +#define glTexBuffer glad_glTexBuffer typedef void (APIENTRYP PFNGLPRIMITIVERESTARTINDEXPROC)(GLuint index); GLAPI PFNGLPRIMITIVERESTARTINDEXPROC glad_glPrimitiveRestartIndex; -GLAPI PFNGLPRIMITIVERESTARTINDEXPROC glad_debug_glPrimitiveRestartIndex; -#define glPrimitiveRestartIndex glad_debug_glPrimitiveRestartIndex +#define glPrimitiveRestartIndex glad_glPrimitiveRestartIndex typedef void (APIENTRYP PFNGLCOPYBUFFERSUBDATAPROC)(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size); GLAPI PFNGLCOPYBUFFERSUBDATAPROC glad_glCopyBufferSubData; -GLAPI PFNGLCOPYBUFFERSUBDATAPROC glad_debug_glCopyBufferSubData; -#define glCopyBufferSubData glad_debug_glCopyBufferSubData +#define glCopyBufferSubData glad_glCopyBufferSubData typedef void (APIENTRYP PFNGLGETUNIFORMINDICESPROC)(GLuint program, GLsizei uniformCount, const GLchar *const*uniformNames, GLuint *uniformIndices); GLAPI PFNGLGETUNIFORMINDICESPROC glad_glGetUniformIndices; -GLAPI PFNGLGETUNIFORMINDICESPROC glad_debug_glGetUniformIndices; -#define glGetUniformIndices glad_debug_glGetUniformIndices +#define glGetUniformIndices glad_glGetUniformIndices typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMSIVPROC)(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params); GLAPI PFNGLGETACTIVEUNIFORMSIVPROC glad_glGetActiveUniformsiv; -GLAPI PFNGLGETACTIVEUNIFORMSIVPROC glad_debug_glGetActiveUniformsiv; -#define glGetActiveUniformsiv glad_debug_glGetActiveUniformsiv +#define glGetActiveUniformsiv glad_glGetActiveUniformsiv typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMNAMEPROC)(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName); GLAPI PFNGLGETACTIVEUNIFORMNAMEPROC glad_glGetActiveUniformName; -GLAPI PFNGLGETACTIVEUNIFORMNAMEPROC glad_debug_glGetActiveUniformName; -#define glGetActiveUniformName glad_debug_glGetActiveUniformName +#define glGetActiveUniformName glad_glGetActiveUniformName typedef GLuint (APIENTRYP PFNGLGETUNIFORMBLOCKINDEXPROC)(GLuint program, const GLchar *uniformBlockName); GLAPI PFNGLGETUNIFORMBLOCKINDEXPROC glad_glGetUniformBlockIndex; -GLAPI PFNGLGETUNIFORMBLOCKINDEXPROC glad_debug_glGetUniformBlockIndex; -#define glGetUniformBlockIndex glad_debug_glGetUniformBlockIndex +#define glGetUniformBlockIndex glad_glGetUniformBlockIndex typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMBLOCKIVPROC)(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params); GLAPI PFNGLGETACTIVEUNIFORMBLOCKIVPROC glad_glGetActiveUniformBlockiv; -GLAPI PFNGLGETACTIVEUNIFORMBLOCKIVPROC glad_debug_glGetActiveUniformBlockiv; -#define glGetActiveUniformBlockiv glad_debug_glGetActiveUniformBlockiv +#define glGetActiveUniformBlockiv glad_glGetActiveUniformBlockiv typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC)(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName); GLAPI PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC glad_glGetActiveUniformBlockName; -GLAPI PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC glad_debug_glGetActiveUniformBlockName; -#define glGetActiveUniformBlockName glad_debug_glGetActiveUniformBlockName +#define glGetActiveUniformBlockName glad_glGetActiveUniformBlockName typedef void (APIENTRYP PFNGLUNIFORMBLOCKBINDINGPROC)(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding); GLAPI PFNGLUNIFORMBLOCKBINDINGPROC glad_glUniformBlockBinding; -GLAPI PFNGLUNIFORMBLOCKBINDINGPROC glad_debug_glUniformBlockBinding; -#define glUniformBlockBinding glad_debug_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; -GLAPI PFNGLDRAWELEMENTSBASEVERTEXPROC glad_debug_glDrawElementsBaseVertex; -#define glDrawElementsBaseVertex glad_debug_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; -GLAPI PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC glad_debug_glDrawRangeElementsBaseVertex; -#define glDrawRangeElementsBaseVertex glad_debug_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; -GLAPI PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC glad_debug_glDrawElementsInstancedBaseVertex; -#define glDrawElementsInstancedBaseVertex glad_debug_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; -GLAPI PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC glad_debug_glMultiDrawElementsBaseVertex; -#define glMultiDrawElementsBaseVertex glad_debug_glMultiDrawElementsBaseVertex +#define glMultiDrawElementsBaseVertex glad_glMultiDrawElementsBaseVertex typedef void (APIENTRYP PFNGLPROVOKINGVERTEXPROC)(GLenum mode); GLAPI PFNGLPROVOKINGVERTEXPROC glad_glProvokingVertex; -GLAPI PFNGLPROVOKINGVERTEXPROC glad_debug_glProvokingVertex; -#define glProvokingVertex glad_debug_glProvokingVertex +#define glProvokingVertex glad_glProvokingVertex typedef GLsync (APIENTRYP PFNGLFENCESYNCPROC)(GLenum condition, GLbitfield flags); GLAPI PFNGLFENCESYNCPROC glad_glFenceSync; -GLAPI PFNGLFENCESYNCPROC glad_debug_glFenceSync; -#define glFenceSync glad_debug_glFenceSync +#define glFenceSync glad_glFenceSync typedef GLboolean (APIENTRYP PFNGLISSYNCPROC)(GLsync sync); GLAPI PFNGLISSYNCPROC glad_glIsSync; -GLAPI PFNGLISSYNCPROC glad_debug_glIsSync; -#define glIsSync glad_debug_glIsSync +#define glIsSync glad_glIsSync typedef void (APIENTRYP PFNGLDELETESYNCPROC)(GLsync sync); GLAPI PFNGLDELETESYNCPROC glad_glDeleteSync; -GLAPI PFNGLDELETESYNCPROC glad_debug_glDeleteSync; -#define glDeleteSync glad_debug_glDeleteSync +#define glDeleteSync glad_glDeleteSync typedef GLenum (APIENTRYP PFNGLCLIENTWAITSYNCPROC)(GLsync sync, GLbitfield flags, GLuint64 timeout); GLAPI PFNGLCLIENTWAITSYNCPROC glad_glClientWaitSync; -GLAPI PFNGLCLIENTWAITSYNCPROC glad_debug_glClientWaitSync; -#define glClientWaitSync glad_debug_glClientWaitSync +#define glClientWaitSync glad_glClientWaitSync typedef void (APIENTRYP PFNGLWAITSYNCPROC)(GLsync sync, GLbitfield flags, GLuint64 timeout); GLAPI PFNGLWAITSYNCPROC glad_glWaitSync; -GLAPI PFNGLWAITSYNCPROC glad_debug_glWaitSync; -#define glWaitSync glad_debug_glWaitSync +#define glWaitSync glad_glWaitSync typedef void (APIENTRYP PFNGLGETINTEGER64VPROC)(GLenum pname, GLint64 *data); GLAPI PFNGLGETINTEGER64VPROC glad_glGetInteger64v; -GLAPI PFNGLGETINTEGER64VPROC glad_debug_glGetInteger64v; -#define glGetInteger64v glad_debug_glGetInteger64v +#define glGetInteger64v glad_glGetInteger64v typedef void (APIENTRYP PFNGLGETSYNCIVPROC)(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values); GLAPI PFNGLGETSYNCIVPROC glad_glGetSynciv; -GLAPI PFNGLGETSYNCIVPROC glad_debug_glGetSynciv; -#define glGetSynciv glad_debug_glGetSynciv +#define glGetSynciv glad_glGetSynciv typedef void (APIENTRYP PFNGLGETINTEGER64I_VPROC)(GLenum target, GLuint index, GLint64 *data); GLAPI PFNGLGETINTEGER64I_VPROC glad_glGetInteger64i_v; -GLAPI PFNGLGETINTEGER64I_VPROC glad_debug_glGetInteger64i_v; -#define glGetInteger64i_v glad_debug_glGetInteger64i_v +#define glGetInteger64i_v glad_glGetInteger64i_v typedef void (APIENTRYP PFNGLGETBUFFERPARAMETERI64VPROC)(GLenum target, GLenum pname, GLint64 *params); GLAPI PFNGLGETBUFFERPARAMETERI64VPROC glad_glGetBufferParameteri64v; -GLAPI PFNGLGETBUFFERPARAMETERI64VPROC glad_debug_glGetBufferParameteri64v; -#define glGetBufferParameteri64v glad_debug_glGetBufferParameteri64v +#define glGetBufferParameteri64v glad_glGetBufferParameteri64v typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTUREPROC)(GLenum target, GLenum attachment, GLuint texture, GLint level); GLAPI PFNGLFRAMEBUFFERTEXTUREPROC glad_glFramebufferTexture; -GLAPI PFNGLFRAMEBUFFERTEXTUREPROC glad_debug_glFramebufferTexture; -#define glFramebufferTexture glad_debug_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; -GLAPI PFNGLTEXIMAGE2DMULTISAMPLEPROC glad_debug_glTexImage2DMultisample; -#define glTexImage2DMultisample glad_debug_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; -GLAPI PFNGLTEXIMAGE3DMULTISAMPLEPROC glad_debug_glTexImage3DMultisample; -#define glTexImage3DMultisample glad_debug_glTexImage3DMultisample +#define glTexImage3DMultisample glad_glTexImage3DMultisample typedef void (APIENTRYP PFNGLGETMULTISAMPLEFVPROC)(GLenum pname, GLuint index, GLfloat *val); GLAPI PFNGLGETMULTISAMPLEFVPROC glad_glGetMultisamplefv; -GLAPI PFNGLGETMULTISAMPLEFVPROC glad_debug_glGetMultisamplefv; -#define glGetMultisamplefv glad_debug_glGetMultisamplefv +#define glGetMultisamplefv glad_glGetMultisamplefv typedef void (APIENTRYP PFNGLSAMPLEMASKIPROC)(GLuint maskNumber, GLbitfield mask); GLAPI PFNGLSAMPLEMASKIPROC glad_glSampleMaski; -GLAPI PFNGLSAMPLEMASKIPROC glad_debug_glSampleMaski; -#define glSampleMaski glad_debug_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; -GLAPI PFNGLBINDFRAGDATALOCATIONINDEXEDPROC glad_debug_glBindFragDataLocationIndexed; -#define glBindFragDataLocationIndexed glad_debug_glBindFragDataLocationIndexed +#define glBindFragDataLocationIndexed glad_glBindFragDataLocationIndexed typedef GLint (APIENTRYP PFNGLGETFRAGDATAINDEXPROC)(GLuint program, const GLchar *name); GLAPI PFNGLGETFRAGDATAINDEXPROC glad_glGetFragDataIndex; -GLAPI PFNGLGETFRAGDATAINDEXPROC glad_debug_glGetFragDataIndex; -#define glGetFragDataIndex glad_debug_glGetFragDataIndex +#define glGetFragDataIndex glad_glGetFragDataIndex typedef void (APIENTRYP PFNGLGENSAMPLERSPROC)(GLsizei count, GLuint *samplers); GLAPI PFNGLGENSAMPLERSPROC glad_glGenSamplers; -GLAPI PFNGLGENSAMPLERSPROC glad_debug_glGenSamplers; -#define glGenSamplers glad_debug_glGenSamplers +#define glGenSamplers glad_glGenSamplers typedef void (APIENTRYP PFNGLDELETESAMPLERSPROC)(GLsizei count, const GLuint *samplers); GLAPI PFNGLDELETESAMPLERSPROC glad_glDeleteSamplers; -GLAPI PFNGLDELETESAMPLERSPROC glad_debug_glDeleteSamplers; -#define glDeleteSamplers glad_debug_glDeleteSamplers +#define glDeleteSamplers glad_glDeleteSamplers typedef GLboolean (APIENTRYP PFNGLISSAMPLERPROC)(GLuint sampler); GLAPI PFNGLISSAMPLERPROC glad_glIsSampler; -GLAPI PFNGLISSAMPLERPROC glad_debug_glIsSampler; -#define glIsSampler glad_debug_glIsSampler +#define glIsSampler glad_glIsSampler typedef void (APIENTRYP PFNGLBINDSAMPLERPROC)(GLuint unit, GLuint sampler); GLAPI PFNGLBINDSAMPLERPROC glad_glBindSampler; -GLAPI PFNGLBINDSAMPLERPROC glad_debug_glBindSampler; -#define glBindSampler glad_debug_glBindSampler +#define glBindSampler glad_glBindSampler typedef void (APIENTRYP PFNGLSAMPLERPARAMETERIPROC)(GLuint sampler, GLenum pname, GLint param); GLAPI PFNGLSAMPLERPARAMETERIPROC glad_glSamplerParameteri; -GLAPI PFNGLSAMPLERPARAMETERIPROC glad_debug_glSamplerParameteri; -#define glSamplerParameteri glad_debug_glSamplerParameteri +#define glSamplerParameteri glad_glSamplerParameteri typedef void (APIENTRYP PFNGLSAMPLERPARAMETERIVPROC)(GLuint sampler, GLenum pname, const GLint *param); GLAPI PFNGLSAMPLERPARAMETERIVPROC glad_glSamplerParameteriv; -GLAPI PFNGLSAMPLERPARAMETERIVPROC glad_debug_glSamplerParameteriv; -#define glSamplerParameteriv glad_debug_glSamplerParameteriv +#define glSamplerParameteriv glad_glSamplerParameteriv typedef void (APIENTRYP PFNGLSAMPLERPARAMETERFPROC)(GLuint sampler, GLenum pname, GLfloat param); GLAPI PFNGLSAMPLERPARAMETERFPROC glad_glSamplerParameterf; -GLAPI PFNGLSAMPLERPARAMETERFPROC glad_debug_glSamplerParameterf; -#define glSamplerParameterf glad_debug_glSamplerParameterf +#define glSamplerParameterf glad_glSamplerParameterf typedef void (APIENTRYP PFNGLSAMPLERPARAMETERFVPROC)(GLuint sampler, GLenum pname, const GLfloat *param); GLAPI PFNGLSAMPLERPARAMETERFVPROC glad_glSamplerParameterfv; -GLAPI PFNGLSAMPLERPARAMETERFVPROC glad_debug_glSamplerParameterfv; -#define glSamplerParameterfv glad_debug_glSamplerParameterfv +#define glSamplerParameterfv glad_glSamplerParameterfv typedef void (APIENTRYP PFNGLSAMPLERPARAMETERIIVPROC)(GLuint sampler, GLenum pname, const GLint *param); GLAPI PFNGLSAMPLERPARAMETERIIVPROC glad_glSamplerParameterIiv; -GLAPI PFNGLSAMPLERPARAMETERIIVPROC glad_debug_glSamplerParameterIiv; -#define glSamplerParameterIiv glad_debug_glSamplerParameterIiv +#define glSamplerParameterIiv glad_glSamplerParameterIiv typedef void (APIENTRYP PFNGLSAMPLERPARAMETERIUIVPROC)(GLuint sampler, GLenum pname, const GLuint *param); GLAPI PFNGLSAMPLERPARAMETERIUIVPROC glad_glSamplerParameterIuiv; -GLAPI PFNGLSAMPLERPARAMETERIUIVPROC glad_debug_glSamplerParameterIuiv; -#define glSamplerParameterIuiv glad_debug_glSamplerParameterIuiv +#define glSamplerParameterIuiv glad_glSamplerParameterIuiv typedef void (APIENTRYP PFNGLGETSAMPLERPARAMETERIVPROC)(GLuint sampler, GLenum pname, GLint *params); GLAPI PFNGLGETSAMPLERPARAMETERIVPROC glad_glGetSamplerParameteriv; -GLAPI PFNGLGETSAMPLERPARAMETERIVPROC glad_debug_glGetSamplerParameteriv; -#define glGetSamplerParameteriv glad_debug_glGetSamplerParameteriv +#define glGetSamplerParameteriv glad_glGetSamplerParameteriv typedef void (APIENTRYP PFNGLGETSAMPLERPARAMETERIIVPROC)(GLuint sampler, GLenum pname, GLint *params); GLAPI PFNGLGETSAMPLERPARAMETERIIVPROC glad_glGetSamplerParameterIiv; -GLAPI PFNGLGETSAMPLERPARAMETERIIVPROC glad_debug_glGetSamplerParameterIiv; -#define glGetSamplerParameterIiv glad_debug_glGetSamplerParameterIiv +#define glGetSamplerParameterIiv glad_glGetSamplerParameterIiv typedef void (APIENTRYP PFNGLGETSAMPLERPARAMETERFVPROC)(GLuint sampler, GLenum pname, GLfloat *params); GLAPI PFNGLGETSAMPLERPARAMETERFVPROC glad_glGetSamplerParameterfv; -GLAPI PFNGLGETSAMPLERPARAMETERFVPROC glad_debug_glGetSamplerParameterfv; -#define glGetSamplerParameterfv glad_debug_glGetSamplerParameterfv +#define glGetSamplerParameterfv glad_glGetSamplerParameterfv typedef void (APIENTRYP PFNGLGETSAMPLERPARAMETERIUIVPROC)(GLuint sampler, GLenum pname, GLuint *params); GLAPI PFNGLGETSAMPLERPARAMETERIUIVPROC glad_glGetSamplerParameterIuiv; -GLAPI PFNGLGETSAMPLERPARAMETERIUIVPROC glad_debug_glGetSamplerParameterIuiv; -#define glGetSamplerParameterIuiv glad_debug_glGetSamplerParameterIuiv +#define glGetSamplerParameterIuiv glad_glGetSamplerParameterIuiv typedef void (APIENTRYP PFNGLQUERYCOUNTERPROC)(GLuint id, GLenum target); GLAPI PFNGLQUERYCOUNTERPROC glad_glQueryCounter; -GLAPI PFNGLQUERYCOUNTERPROC glad_debug_glQueryCounter; -#define glQueryCounter glad_debug_glQueryCounter +#define glQueryCounter glad_glQueryCounter typedef void (APIENTRYP PFNGLGETQUERYOBJECTI64VPROC)(GLuint id, GLenum pname, GLint64 *params); GLAPI PFNGLGETQUERYOBJECTI64VPROC glad_glGetQueryObjecti64v; -GLAPI PFNGLGETQUERYOBJECTI64VPROC glad_debug_glGetQueryObjecti64v; -#define glGetQueryObjecti64v glad_debug_glGetQueryObjecti64v +#define glGetQueryObjecti64v glad_glGetQueryObjecti64v typedef void (APIENTRYP PFNGLGETQUERYOBJECTUI64VPROC)(GLuint id, GLenum pname, GLuint64 *params); GLAPI PFNGLGETQUERYOBJECTUI64VPROC glad_glGetQueryObjectui64v; -GLAPI PFNGLGETQUERYOBJECTUI64VPROC glad_debug_glGetQueryObjectui64v; -#define glGetQueryObjectui64v glad_debug_glGetQueryObjectui64v +#define glGetQueryObjectui64v glad_glGetQueryObjectui64v typedef void (APIENTRYP PFNGLVERTEXATTRIBDIVISORPROC)(GLuint index, GLuint divisor); GLAPI PFNGLVERTEXATTRIBDIVISORPROC glad_glVertexAttribDivisor; -GLAPI PFNGLVERTEXATTRIBDIVISORPROC glad_debug_glVertexAttribDivisor; -#define glVertexAttribDivisor glad_debug_glVertexAttribDivisor +#define glVertexAttribDivisor glad_glVertexAttribDivisor typedef void (APIENTRYP PFNGLVERTEXATTRIBP1UIPROC)(GLuint index, GLenum type, GLboolean normalized, GLuint value); GLAPI PFNGLVERTEXATTRIBP1UIPROC glad_glVertexAttribP1ui; -GLAPI PFNGLVERTEXATTRIBP1UIPROC glad_debug_glVertexAttribP1ui; -#define glVertexAttribP1ui glad_debug_glVertexAttribP1ui +#define glVertexAttribP1ui glad_glVertexAttribP1ui typedef void (APIENTRYP PFNGLVERTEXATTRIBP1UIVPROC)(GLuint index, GLenum type, GLboolean normalized, const GLuint *value); GLAPI PFNGLVERTEXATTRIBP1UIVPROC glad_glVertexAttribP1uiv; -GLAPI PFNGLVERTEXATTRIBP1UIVPROC glad_debug_glVertexAttribP1uiv; -#define glVertexAttribP1uiv glad_debug_glVertexAttribP1uiv +#define glVertexAttribP1uiv glad_glVertexAttribP1uiv typedef void (APIENTRYP PFNGLVERTEXATTRIBP2UIPROC)(GLuint index, GLenum type, GLboolean normalized, GLuint value); GLAPI PFNGLVERTEXATTRIBP2UIPROC glad_glVertexAttribP2ui; -GLAPI PFNGLVERTEXATTRIBP2UIPROC glad_debug_glVertexAttribP2ui; -#define glVertexAttribP2ui glad_debug_glVertexAttribP2ui +#define glVertexAttribP2ui glad_glVertexAttribP2ui typedef void (APIENTRYP PFNGLVERTEXATTRIBP2UIVPROC)(GLuint index, GLenum type, GLboolean normalized, const GLuint *value); GLAPI PFNGLVERTEXATTRIBP2UIVPROC glad_glVertexAttribP2uiv; -GLAPI PFNGLVERTEXATTRIBP2UIVPROC glad_debug_glVertexAttribP2uiv; -#define glVertexAttribP2uiv glad_debug_glVertexAttribP2uiv +#define glVertexAttribP2uiv glad_glVertexAttribP2uiv typedef void (APIENTRYP PFNGLVERTEXATTRIBP3UIPROC)(GLuint index, GLenum type, GLboolean normalized, GLuint value); GLAPI PFNGLVERTEXATTRIBP3UIPROC glad_glVertexAttribP3ui; -GLAPI PFNGLVERTEXATTRIBP3UIPROC glad_debug_glVertexAttribP3ui; -#define glVertexAttribP3ui glad_debug_glVertexAttribP3ui +#define glVertexAttribP3ui glad_glVertexAttribP3ui typedef void (APIENTRYP PFNGLVERTEXATTRIBP3UIVPROC)(GLuint index, GLenum type, GLboolean normalized, const GLuint *value); GLAPI PFNGLVERTEXATTRIBP3UIVPROC glad_glVertexAttribP3uiv; -GLAPI PFNGLVERTEXATTRIBP3UIVPROC glad_debug_glVertexAttribP3uiv; -#define glVertexAttribP3uiv glad_debug_glVertexAttribP3uiv +#define glVertexAttribP3uiv glad_glVertexAttribP3uiv typedef void (APIENTRYP PFNGLVERTEXATTRIBP4UIPROC)(GLuint index, GLenum type, GLboolean normalized, GLuint value); GLAPI PFNGLVERTEXATTRIBP4UIPROC glad_glVertexAttribP4ui; -GLAPI PFNGLVERTEXATTRIBP4UIPROC glad_debug_glVertexAttribP4ui; -#define glVertexAttribP4ui glad_debug_glVertexAttribP4ui +#define glVertexAttribP4ui glad_glVertexAttribP4ui typedef void (APIENTRYP PFNGLVERTEXATTRIBP4UIVPROC)(GLuint index, GLenum type, GLboolean normalized, const GLuint *value); GLAPI PFNGLVERTEXATTRIBP4UIVPROC glad_glVertexAttribP4uiv; -GLAPI PFNGLVERTEXATTRIBP4UIVPROC glad_debug_glVertexAttribP4uiv; -#define glVertexAttribP4uiv glad_debug_glVertexAttribP4uiv +#define glVertexAttribP4uiv glad_glVertexAttribP4uiv typedef void (APIENTRYP PFNGLVERTEXP2UIPROC)(GLenum type, GLuint value); GLAPI PFNGLVERTEXP2UIPROC glad_glVertexP2ui; -GLAPI PFNGLVERTEXP2UIPROC glad_debug_glVertexP2ui; -#define glVertexP2ui glad_debug_glVertexP2ui +#define glVertexP2ui glad_glVertexP2ui typedef void (APIENTRYP PFNGLVERTEXP2UIVPROC)(GLenum type, const GLuint *value); GLAPI PFNGLVERTEXP2UIVPROC glad_glVertexP2uiv; -GLAPI PFNGLVERTEXP2UIVPROC glad_debug_glVertexP2uiv; -#define glVertexP2uiv glad_debug_glVertexP2uiv +#define glVertexP2uiv glad_glVertexP2uiv typedef void (APIENTRYP PFNGLVERTEXP3UIPROC)(GLenum type, GLuint value); GLAPI PFNGLVERTEXP3UIPROC glad_glVertexP3ui; -GLAPI PFNGLVERTEXP3UIPROC glad_debug_glVertexP3ui; -#define glVertexP3ui glad_debug_glVertexP3ui +#define glVertexP3ui glad_glVertexP3ui typedef void (APIENTRYP PFNGLVERTEXP3UIVPROC)(GLenum type, const GLuint *value); GLAPI PFNGLVERTEXP3UIVPROC glad_glVertexP3uiv; -GLAPI PFNGLVERTEXP3UIVPROC glad_debug_glVertexP3uiv; -#define glVertexP3uiv glad_debug_glVertexP3uiv +#define glVertexP3uiv glad_glVertexP3uiv typedef void (APIENTRYP PFNGLVERTEXP4UIPROC)(GLenum type, GLuint value); GLAPI PFNGLVERTEXP4UIPROC glad_glVertexP4ui; -GLAPI PFNGLVERTEXP4UIPROC glad_debug_glVertexP4ui; -#define glVertexP4ui glad_debug_glVertexP4ui +#define glVertexP4ui glad_glVertexP4ui typedef void (APIENTRYP PFNGLVERTEXP4UIVPROC)(GLenum type, const GLuint *value); GLAPI PFNGLVERTEXP4UIVPROC glad_glVertexP4uiv; -GLAPI PFNGLVERTEXP4UIVPROC glad_debug_glVertexP4uiv; -#define glVertexP4uiv glad_debug_glVertexP4uiv +#define glVertexP4uiv glad_glVertexP4uiv typedef void (APIENTRYP PFNGLTEXCOORDP1UIPROC)(GLenum type, GLuint coords); GLAPI PFNGLTEXCOORDP1UIPROC glad_glTexCoordP1ui; -GLAPI PFNGLTEXCOORDP1UIPROC glad_debug_glTexCoordP1ui; -#define glTexCoordP1ui glad_debug_glTexCoordP1ui +#define glTexCoordP1ui glad_glTexCoordP1ui typedef void (APIENTRYP PFNGLTEXCOORDP1UIVPROC)(GLenum type, const GLuint *coords); GLAPI PFNGLTEXCOORDP1UIVPROC glad_glTexCoordP1uiv; -GLAPI PFNGLTEXCOORDP1UIVPROC glad_debug_glTexCoordP1uiv; -#define glTexCoordP1uiv glad_debug_glTexCoordP1uiv +#define glTexCoordP1uiv glad_glTexCoordP1uiv typedef void (APIENTRYP PFNGLTEXCOORDP2UIPROC)(GLenum type, GLuint coords); GLAPI PFNGLTEXCOORDP2UIPROC glad_glTexCoordP2ui; -GLAPI PFNGLTEXCOORDP2UIPROC glad_debug_glTexCoordP2ui; -#define glTexCoordP2ui glad_debug_glTexCoordP2ui +#define glTexCoordP2ui glad_glTexCoordP2ui typedef void (APIENTRYP PFNGLTEXCOORDP2UIVPROC)(GLenum type, const GLuint *coords); GLAPI PFNGLTEXCOORDP2UIVPROC glad_glTexCoordP2uiv; -GLAPI PFNGLTEXCOORDP2UIVPROC glad_debug_glTexCoordP2uiv; -#define glTexCoordP2uiv glad_debug_glTexCoordP2uiv +#define glTexCoordP2uiv glad_glTexCoordP2uiv typedef void (APIENTRYP PFNGLTEXCOORDP3UIPROC)(GLenum type, GLuint coords); GLAPI PFNGLTEXCOORDP3UIPROC glad_glTexCoordP3ui; -GLAPI PFNGLTEXCOORDP3UIPROC glad_debug_glTexCoordP3ui; -#define glTexCoordP3ui glad_debug_glTexCoordP3ui +#define glTexCoordP3ui glad_glTexCoordP3ui typedef void (APIENTRYP PFNGLTEXCOORDP3UIVPROC)(GLenum type, const GLuint *coords); GLAPI PFNGLTEXCOORDP3UIVPROC glad_glTexCoordP3uiv; -GLAPI PFNGLTEXCOORDP3UIVPROC glad_debug_glTexCoordP3uiv; -#define glTexCoordP3uiv glad_debug_glTexCoordP3uiv +#define glTexCoordP3uiv glad_glTexCoordP3uiv typedef void (APIENTRYP PFNGLTEXCOORDP4UIPROC)(GLenum type, GLuint coords); GLAPI PFNGLTEXCOORDP4UIPROC glad_glTexCoordP4ui; -GLAPI PFNGLTEXCOORDP4UIPROC glad_debug_glTexCoordP4ui; -#define glTexCoordP4ui glad_debug_glTexCoordP4ui +#define glTexCoordP4ui glad_glTexCoordP4ui typedef void (APIENTRYP PFNGLTEXCOORDP4UIVPROC)(GLenum type, const GLuint *coords); GLAPI PFNGLTEXCOORDP4UIVPROC glad_glTexCoordP4uiv; -GLAPI PFNGLTEXCOORDP4UIVPROC glad_debug_glTexCoordP4uiv; -#define glTexCoordP4uiv glad_debug_glTexCoordP4uiv +#define glTexCoordP4uiv glad_glTexCoordP4uiv typedef void (APIENTRYP PFNGLMULTITEXCOORDP1UIPROC)(GLenum texture, GLenum type, GLuint coords); GLAPI PFNGLMULTITEXCOORDP1UIPROC glad_glMultiTexCoordP1ui; -GLAPI PFNGLMULTITEXCOORDP1UIPROC glad_debug_glMultiTexCoordP1ui; -#define glMultiTexCoordP1ui glad_debug_glMultiTexCoordP1ui +#define glMultiTexCoordP1ui glad_glMultiTexCoordP1ui typedef void (APIENTRYP PFNGLMULTITEXCOORDP1UIVPROC)(GLenum texture, GLenum type, const GLuint *coords); GLAPI PFNGLMULTITEXCOORDP1UIVPROC glad_glMultiTexCoordP1uiv; -GLAPI PFNGLMULTITEXCOORDP1UIVPROC glad_debug_glMultiTexCoordP1uiv; -#define glMultiTexCoordP1uiv glad_debug_glMultiTexCoordP1uiv +#define glMultiTexCoordP1uiv glad_glMultiTexCoordP1uiv typedef void (APIENTRYP PFNGLMULTITEXCOORDP2UIPROC)(GLenum texture, GLenum type, GLuint coords); GLAPI PFNGLMULTITEXCOORDP2UIPROC glad_glMultiTexCoordP2ui; -GLAPI PFNGLMULTITEXCOORDP2UIPROC glad_debug_glMultiTexCoordP2ui; -#define glMultiTexCoordP2ui glad_debug_glMultiTexCoordP2ui +#define glMultiTexCoordP2ui glad_glMultiTexCoordP2ui typedef void (APIENTRYP PFNGLMULTITEXCOORDP2UIVPROC)(GLenum texture, GLenum type, const GLuint *coords); GLAPI PFNGLMULTITEXCOORDP2UIVPROC glad_glMultiTexCoordP2uiv; -GLAPI PFNGLMULTITEXCOORDP2UIVPROC glad_debug_glMultiTexCoordP2uiv; -#define glMultiTexCoordP2uiv glad_debug_glMultiTexCoordP2uiv +#define glMultiTexCoordP2uiv glad_glMultiTexCoordP2uiv typedef void (APIENTRYP PFNGLMULTITEXCOORDP3UIPROC)(GLenum texture, GLenum type, GLuint coords); GLAPI PFNGLMULTITEXCOORDP3UIPROC glad_glMultiTexCoordP3ui; -GLAPI PFNGLMULTITEXCOORDP3UIPROC glad_debug_glMultiTexCoordP3ui; -#define glMultiTexCoordP3ui glad_debug_glMultiTexCoordP3ui +#define glMultiTexCoordP3ui glad_glMultiTexCoordP3ui typedef void (APIENTRYP PFNGLMULTITEXCOORDP3UIVPROC)(GLenum texture, GLenum type, const GLuint *coords); GLAPI PFNGLMULTITEXCOORDP3UIVPROC glad_glMultiTexCoordP3uiv; -GLAPI PFNGLMULTITEXCOORDP3UIVPROC glad_debug_glMultiTexCoordP3uiv; -#define glMultiTexCoordP3uiv glad_debug_glMultiTexCoordP3uiv +#define glMultiTexCoordP3uiv glad_glMultiTexCoordP3uiv typedef void (APIENTRYP PFNGLMULTITEXCOORDP4UIPROC)(GLenum texture, GLenum type, GLuint coords); GLAPI PFNGLMULTITEXCOORDP4UIPROC glad_glMultiTexCoordP4ui; -GLAPI PFNGLMULTITEXCOORDP4UIPROC glad_debug_glMultiTexCoordP4ui; -#define glMultiTexCoordP4ui glad_debug_glMultiTexCoordP4ui +#define glMultiTexCoordP4ui glad_glMultiTexCoordP4ui typedef void (APIENTRYP PFNGLMULTITEXCOORDP4UIVPROC)(GLenum texture, GLenum type, const GLuint *coords); GLAPI PFNGLMULTITEXCOORDP4UIVPROC glad_glMultiTexCoordP4uiv; -GLAPI PFNGLMULTITEXCOORDP4UIVPROC glad_debug_glMultiTexCoordP4uiv; -#define glMultiTexCoordP4uiv glad_debug_glMultiTexCoordP4uiv +#define glMultiTexCoordP4uiv glad_glMultiTexCoordP4uiv typedef void (APIENTRYP PFNGLNORMALP3UIPROC)(GLenum type, GLuint coords); GLAPI PFNGLNORMALP3UIPROC glad_glNormalP3ui; -GLAPI PFNGLNORMALP3UIPROC glad_debug_glNormalP3ui; -#define glNormalP3ui glad_debug_glNormalP3ui +#define glNormalP3ui glad_glNormalP3ui typedef void (APIENTRYP PFNGLNORMALP3UIVPROC)(GLenum type, const GLuint *coords); GLAPI PFNGLNORMALP3UIVPROC glad_glNormalP3uiv; -GLAPI PFNGLNORMALP3UIVPROC glad_debug_glNormalP3uiv; -#define glNormalP3uiv glad_debug_glNormalP3uiv +#define glNormalP3uiv glad_glNormalP3uiv typedef void (APIENTRYP PFNGLCOLORP3UIPROC)(GLenum type, GLuint color); GLAPI PFNGLCOLORP3UIPROC glad_glColorP3ui; -GLAPI PFNGLCOLORP3UIPROC glad_debug_glColorP3ui; -#define glColorP3ui glad_debug_glColorP3ui +#define glColorP3ui glad_glColorP3ui typedef void (APIENTRYP PFNGLCOLORP3UIVPROC)(GLenum type, const GLuint *color); GLAPI PFNGLCOLORP3UIVPROC glad_glColorP3uiv; -GLAPI PFNGLCOLORP3UIVPROC glad_debug_glColorP3uiv; -#define glColorP3uiv glad_debug_glColorP3uiv +#define glColorP3uiv glad_glColorP3uiv typedef void (APIENTRYP PFNGLCOLORP4UIPROC)(GLenum type, GLuint color); GLAPI PFNGLCOLORP4UIPROC glad_glColorP4ui; -GLAPI PFNGLCOLORP4UIPROC glad_debug_glColorP4ui; -#define glColorP4ui glad_debug_glColorP4ui +#define glColorP4ui glad_glColorP4ui typedef void (APIENTRYP PFNGLCOLORP4UIVPROC)(GLenum type, const GLuint *color); GLAPI PFNGLCOLORP4UIVPROC glad_glColorP4uiv; -GLAPI PFNGLCOLORP4UIVPROC glad_debug_glColorP4uiv; -#define glColorP4uiv glad_debug_glColorP4uiv +#define glColorP4uiv glad_glColorP4uiv typedef void (APIENTRYP PFNGLSECONDARYCOLORP3UIPROC)(GLenum type, GLuint color); GLAPI PFNGLSECONDARYCOLORP3UIPROC glad_glSecondaryColorP3ui; -GLAPI PFNGLSECONDARYCOLORP3UIPROC glad_debug_glSecondaryColorP3ui; -#define glSecondaryColorP3ui glad_debug_glSecondaryColorP3ui +#define glSecondaryColorP3ui glad_glSecondaryColorP3ui typedef void (APIENTRYP PFNGLSECONDARYCOLORP3UIVPROC)(GLenum type, const GLuint *color); GLAPI PFNGLSECONDARYCOLORP3UIVPROC glad_glSecondaryColorP3uiv; -GLAPI PFNGLSECONDARYCOLORP3UIVPROC glad_debug_glSecondaryColorP3uiv; -#define glSecondaryColorP3uiv glad_debug_glSecondaryColorP3uiv +#define glSecondaryColorP3uiv glad_glSecondaryColorP3uiv #endif #ifdef __cplusplus diff --git a/src/libsymmetry/framebuffer.c b/src/libsymmetry/framebuffer.c index 51ef4d0..5a7024c 100644 --- a/src/libsymmetry/framebuffer.c +++ b/src/libsymmetry/framebuffer.c @@ -51,16 +51,14 @@ int framebuffer_create(int width, int height, bool has_depth, bool has_color, bo { glGenRenderbuffers(1, &depth_renderbuffer); glBindRenderbuffer(GL_RENDERBUFFER, depth_renderbuffer); - glRenderbufferStorage(GL_RENDERBUFFER, + GL_CHECK(glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, width, - height); - renderer_check_glerror("framebuffer:create:depth_renderbuffer"); - glFramebufferRenderbuffer(GL_FRAMEBUFFER, + height)); + GL_CHECK(glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, - depth_renderbuffer); - renderer_check_glerror("framebuffer:create:depth_renderbuffer"); + depth_renderbuffer)); glBindRenderbuffer(GL_RENDERBUFFER, 0); } @@ -68,26 +66,22 @@ int framebuffer_create(int width, int height, bool has_depth, bool has_color, bo { glGenRenderbuffers(1, &color_renderbuffer); glBindRenderbuffer(GL_RENDERBUFFER, color_renderbuffer); - glRenderbufferStorage(GL_RENDERBUFFER, + GL_CHECK(glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA8, width, - height); - renderer_check_glerror("framebuffer:create:color_renderbuffer"); - glFramebufferRenderbuffer(GL_FRAMEBUFFER, + height)); + GL_CHECK(glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, - color_renderbuffer); - renderer_check_glerror("framebuffer:create:color_renderbuffer"); + color_renderbuffer)); glBindRenderbuffer(GL_RENDERBUFFER, 0); } - glDrawBuffer(has_color ? GL_COLOR_ATTACHMENT0 : GL_NONE); - renderer_check_glerror("framebuffer:create"); + GL_CHECK(glDrawBuffer(has_color ? GL_COLOR_ATTACHMENT0 : GL_NONE)); GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER); if(status != GL_FRAMEBUFFER_COMPLETE) { log_error("framebuffer:create", "Framebuffer not created!"); - renderer_check_glerror("framebuffer:create"); } else { @@ -188,15 +182,13 @@ void framebuffer_texture_set(int index, int texture, enum Framebuffer_Attachment if(texture == -1) return; GLint current_fbo = 0; - glGetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING, ¤t_fbo); - renderer_check_glerror("framebuffer:set_texture:glGet"); + GL_CHECK(glGetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING, ¤t_fbo)); framebuffer_bind(index); - glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, + GL_CHECK(glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, gl_attachment, GL_TEXTURE_2D, texture_get_texture_handle(texture), - 0); - renderer_check_glerror("framebuffer:set_texture:glFramebuffertexture2d"); + 0)); fbo->texture_attachments[attachment] = texture; if(attachment == FA_COLOR_ATTACHMENT0) glDrawBuffer(GL_COLOR_ATTACHMENT0); glBindFramebuffer(GL_FRAMEBUFFER, current_fbo); @@ -223,19 +215,17 @@ void framebuffer_resize(int index, int width, int height) width -= (width % 2); height -= (height % 2); GLint current_fbo = 0; - glGetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING, ¤t_fbo); - renderer_check_glerror("framebuffer:resize:glGet"); + GL_CHECK(glGetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING, ¤t_fbo)); struct FBO* fbo = &fbo_list[index]; if(!fbo->resizeable) return; framebuffer_bind(index); if(fbo->depth_renderbuffer != 0) { glBindRenderbuffer(GL_RENDERBUFFER, fbo->depth_renderbuffer); - glRenderbufferStorage(GL_RENDERBUFFER, + GL_CHECK(glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, width, - height); - renderer_check_glerror("framebuffer:resize:depth_renderbuffer"); + height)); glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, @@ -246,11 +236,10 @@ void framebuffer_resize(int index, int width, int height) if(fbo->color_renderbuffer != 0) { glBindRenderbuffer(GL_RENDERBUFFER, fbo->color_renderbuffer); - glRenderbufferStorage(GL_RENDERBUFFER, + GL_CHECK(glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA8, width, - height); - renderer_check_glerror("framebuffer:resize:color_renderbuffer"); + height)); glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, diff --git a/src/libsymmetry/game.c b/src/libsymmetry/game.c index 769b047..efd981e 100644 --- a/src/libsymmetry/game.c +++ b/src/libsymmetry/game.c @@ -103,6 +103,8 @@ bool game_init(struct Window* window, struct Platform_Api* platform_api) editor_init(); renderer_init(game_state->renderer); scene_init(game_state->scene); + + game_state->game_mode = GM_GAME; } /* Debug scene setup */ @@ -496,7 +498,7 @@ void game_update(float dt, bool* window_should_close) return; } - game_debug(dt); + //game_debug(dt); //debug_gui(dt); scene_update(game_state->scene, dt); editor_update(dt); diff --git a/src/libsymmetry/game.h b/src/libsymmetry/game.h index afc1b63..88b9674 100644 --- a/src/libsymmetry/game.h +++ b/src/libsymmetry/game.h @@ -16,9 +16,16 @@ struct Scene; struct Entity; struct Player; +enum Game_Mode +{ + GM_GAME = 0, + GM_EDITOR +}; + struct Game_State { bool is_initialized; + int game_mode; struct Window* window; struct Renderer* renderer; struct Scene* scene; diff --git a/src/libsymmetry/geometry.c b/src/libsymmetry/geometry.c index d126fd9..eb5e8c8 100644 --- a/src/libsymmetry/geometry.c +++ b/src/libsymmetry/geometry.c @@ -289,11 +289,10 @@ static void create_vao(struct Geometry* geometry) glGenBuffers(1, &geometry->vertex_vbo); glBindBuffer(GL_ARRAY_BUFFER, geometry->vertex_vbo); - glBufferData(GL_ARRAY_BUFFER, + GL_CHECK(glBufferData(GL_ARRAY_BUFFER, array_len(geometry->vertices) * sizeof(vec3), geometry->vertices, - GL_STATIC_DRAW); - renderer_check_glerror("geometry:create_vbo:vertex"); + GL_STATIC_DRAW)); glEnableVertexAttribArray(0); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0); @@ -301,11 +300,10 @@ static void create_vao(struct Geometry* geometry) { glGenBuffers(1, &geometry->normal_vbo); glBindBuffer(GL_ARRAY_BUFFER, geometry->normal_vbo); - glBufferData(GL_ARRAY_BUFFER, + GL_CHECK(glBufferData(GL_ARRAY_BUFFER, array_len(geometry->normals) * sizeof(vec3), geometry->normals, - GL_STATIC_DRAW); - renderer_check_glerror("geometry:create_vbo:normal"); + GL_STATIC_DRAW)); glEnableVertexAttribArray(1); glVertexAttribPointer(1, 3, GL_FLOAT, GL_TRUE, 0, 0); } @@ -314,11 +312,10 @@ static void create_vao(struct Geometry* geometry) { glGenBuffers(1, &geometry->uv_vbo); glBindBuffer(GL_ARRAY_BUFFER, geometry->uv_vbo); - glBufferData(GL_ARRAY_BUFFER, + GL_CHECK(glBufferData(GL_ARRAY_BUFFER, array_len(geometry->uvs) * sizeof(vec2), geometry->uvs, - GL_STATIC_DRAW); - renderer_check_glerror("geometry:create_vbo:uv"); + GL_STATIC_DRAW)); glEnableVertexAttribArray(2); glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 0, 0); } @@ -327,11 +324,10 @@ static void create_vao(struct Geometry* geometry) { glGenBuffers(1, &geometry->color_vbo); glBindBuffer(GL_ARRAY_BUFFER, geometry->color_vbo); - glBufferData(GL_ARRAY_BUFFER, + GL_CHECK(glBufferData(GL_ARRAY_BUFFER, array_len(geometry->vertex_colors) * sizeof(vec3), geometry->vertex_colors, - GL_STATIC_DRAW); - renderer_check_glerror("geometry:create_vbo:color"); + GL_STATIC_DRAW)); glEnableVertexAttribArray(3); glVertexAttribPointer(3, 3, GL_FLOAT, GL_FALSE, 0, 0); } diff --git a/src/libsymmetry/gl_load.c b/src/libsymmetry/gl_load.c index 4a94f2a..43171e4 100644 --- a/src/libsymmetry/gl_load.c +++ b/src/libsymmetry/gl_load.c @@ -30,7 +30,8 @@ bool gl_load_extentions(void) { bool success = true; #ifdef USE_GLAD - if(!gladLoadGLLoader(platform->load_function_gl)) success = false; + if(!gladLoadGLLoader(platform->load_function_gl)) + success = false; #else #define GLE(ret, name, ...) \ @@ -44,10 +45,10 @@ bool gl_load_extentions(void) #undef GLE #endif return success; -} - -void gl_check_error(const char * expression, unsigned int line, const char * file) -{ +} + +void gl_check_error(const char * expression, unsigned int line, const char * file) +{ int error = 1; GLenum error_code = glGetError(); const char* error_string = "No Error"; @@ -65,6 +66,4 @@ void gl_check_error(const char * expression, unsigned int line, const char * fil log_error("GL", "(%s:%d:%s) : %s", file, line, expression, error_string); else error = 0; - - return error; -} +} diff --git a/src/libsymmetry/gl_load.h b/src/libsymmetry/gl_load.h index 535c194..f94e4d5 100644 --- a/src/libsymmetry/gl_load.h +++ b/src/libsymmetry/gl_load.h @@ -62,11 +62,10 @@ SYMMETRY_GL_LIST #endif -#ifdef GL_DEBUG - #define GL_CHECK(expression) do { gl_check(#expression, __LINE__, __FILE__)} while(false) +#ifdef GL_DEBUG_CONTEXT + #define GL_CHECK(expression) do { expression; gl_check_error(#expression, __LINE__, __FILE__);} while(false) #else #define GL_CHECK(expression) (expression) - #endif int gl_load_library(void); diff --git a/src/libsymmetry/glad.c b/src/libsymmetry/glad.c index 4ed3442..97345dd 100644 --- a/src/libsymmetry/glad.c +++ b/src/libsymmetry/glad.c @@ -1,8 +1,8 @@ /* - OpenGL loader generated by glad 0.1.14a0 on Sat Oct 28 19:45:42 2017. + OpenGL loader generated by glad 0.1.20a0 on Thu May 17 09:30:03 2018. - Language/Generator: C/C++ Debug + Language/Generator: C/C++ Specification: gl APIs: gl=3.3 Profile: core @@ -10,12 +10,12 @@ Loader: False Local files: False - Omit khrplatform: False + Omit khrplatform: True Commandline: - --profile="core" --api="gl=3.3" --generator="c-debug" --spec="gl" --no-loader --extensions="" + --profile="core" --api="gl=3.3" --generator="c" --spec="gl" --no-loader --omit-khrplatform --extensions="" Online: - http://glad.dav1d.de/#profile=core&language=c-debug&specification=gl&api=gl%3D3.3 + http://glad.dav1d.de/#profile=core&language=c&specification=gl&api=gl%3D3.3 */ #include @@ -23,34 +23,6 @@ #include #include -void _pre_call_callback_default(const char *name, void *funcptr, int len_args, ...) { - (void) name; - (void) funcptr; - (void) len_args; -} -void _post_call_callback_default(const char *name, void *funcptr, int len_args, ...) { - GLenum error_code; - - (void) funcptr; - (void) len_args; - - error_code = glad_glGetError(); - - if (error_code != GL_NO_ERROR) { - fprintf(stderr, "ERROR %d in %s\n", error_code, name); - } -} - -static GLADcallback _pre_call_callback = _pre_call_callback_default; -void glad_set_pre_callback(GLADcallback cb) { - _pre_call_callback = cb; -} - -static GLADcallback _post_call_callback = _post_call_callback_default; -void glad_set_post_callback(GLADcallback cb) { - _post_call_callback = cb; -} - struct gladGLversionStruct GLVersion; #if defined(GL_ES_VERSION_3_0) || defined(GL_VERSION_3_0) @@ -84,7 +56,18 @@ static int get_exts(void) { } for(index = 0; index < (unsigned)num_exts_i; index++) { - exts_i[index] = (const char*)glGetStringi(GL_EXTENSIONS, 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) { +#if _MSC_VER >= 1400 + strncpy_s(local_str, len+1, gl_str_tmp, len); +#else + strncpy(local_str, gl_str_tmp, len+1); +#endif + } + exts_i[index] = local_str; } } #endif @@ -93,6 +76,10 @@ static int get_exts(void) { 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; } @@ -126,11 +113,11 @@ static int has_ext(const char *ext) { #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(strcmp(e, ext) == 0) { + if(exts_i[index] != NULL && strcmp(e, ext) == 0) { return 1; } } @@ -152,3025 +139,379 @@ int GLAD_GL_VERSION_3_1; int GLAD_GL_VERSION_3_2; int GLAD_GL_VERSION_3_3; PFNGLCOPYTEXIMAGE1DPROC glad_glCopyTexImage1D; -void APIENTRY glad_debug_impl_glCopyTexImage1D(GLenum arg0, GLint arg1, GLenum arg2, GLint arg3, GLint arg4, GLsizei arg5, GLint arg6) { - _pre_call_callback("glCopyTexImage1D", (void*)glCopyTexImage1D, 7, arg0, arg1, arg2, arg3, arg4, arg5, arg6); - glad_glCopyTexImage1D(arg0, arg1, arg2, arg3, arg4, arg5, arg6); - _post_call_callback("glCopyTexImage1D", (void*)glCopyTexImage1D, 7, arg0, arg1, arg2, arg3, arg4, arg5, arg6); - -} -PFNGLCOPYTEXIMAGE1DPROC glad_debug_glCopyTexImage1D = glad_debug_impl_glCopyTexImage1D; PFNGLVERTEXATTRIBI3UIPROC glad_glVertexAttribI3ui; -void APIENTRY glad_debug_impl_glVertexAttribI3ui(GLuint arg0, GLuint arg1, GLuint arg2, GLuint arg3) { - _pre_call_callback("glVertexAttribI3ui", (void*)glVertexAttribI3ui, 4, arg0, arg1, arg2, arg3); - glad_glVertexAttribI3ui(arg0, arg1, arg2, arg3); - _post_call_callback("glVertexAttribI3ui", (void*)glVertexAttribI3ui, 4, arg0, arg1, arg2, arg3); - -} -PFNGLVERTEXATTRIBI3UIPROC glad_debug_glVertexAttribI3ui = glad_debug_impl_glVertexAttribI3ui; PFNGLSTENCILMASKSEPARATEPROC glad_glStencilMaskSeparate; -void APIENTRY glad_debug_impl_glStencilMaskSeparate(GLenum arg0, GLuint arg1) { - _pre_call_callback("glStencilMaskSeparate", (void*)glStencilMaskSeparate, 2, arg0, arg1); - glad_glStencilMaskSeparate(arg0, arg1); - _post_call_callback("glStencilMaskSeparate", (void*)glStencilMaskSeparate, 2, arg0, arg1); - -} -PFNGLSTENCILMASKSEPARATEPROC glad_debug_glStencilMaskSeparate = glad_debug_impl_glStencilMaskSeparate; PFNGLFRAMEBUFFERRENDERBUFFERPROC glad_glFramebufferRenderbuffer; -void APIENTRY glad_debug_impl_glFramebufferRenderbuffer(GLenum arg0, GLenum arg1, GLenum arg2, GLuint arg3) { - _pre_call_callback("glFramebufferRenderbuffer", (void*)glFramebufferRenderbuffer, 4, arg0, arg1, arg2, arg3); - glad_glFramebufferRenderbuffer(arg0, arg1, arg2, arg3); - _post_call_callback("glFramebufferRenderbuffer", (void*)glFramebufferRenderbuffer, 4, arg0, arg1, arg2, arg3); - -} -PFNGLFRAMEBUFFERRENDERBUFFERPROC glad_debug_glFramebufferRenderbuffer = glad_debug_impl_glFramebufferRenderbuffer; PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC glad_glCompressedTexSubImage3D; -void APIENTRY glad_debug_impl_glCompressedTexSubImage3D(GLenum arg0, GLint arg1, GLint arg2, GLint arg3, GLint arg4, GLsizei arg5, GLsizei arg6, GLsizei arg7, GLenum arg8, GLsizei arg9, const void * arg10) { - _pre_call_callback("glCompressedTexSubImage3D", (void*)glCompressedTexSubImage3D, 11, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10); - glad_glCompressedTexSubImage3D(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10); - _post_call_callback("glCompressedTexSubImage3D", (void*)glCompressedTexSubImage3D, 11, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10); - -} -PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC glad_debug_glCompressedTexSubImage3D = glad_debug_impl_glCompressedTexSubImage3D; PFNGLTEXCOORDP3UIVPROC glad_glTexCoordP3uiv; -void APIENTRY glad_debug_impl_glTexCoordP3uiv(GLenum arg0, const GLuint * arg1) { - _pre_call_callback("glTexCoordP3uiv", (void*)glTexCoordP3uiv, 2, arg0, arg1); - glad_glTexCoordP3uiv(arg0, arg1); - _post_call_callback("glTexCoordP3uiv", (void*)glTexCoordP3uiv, 2, arg0, arg1); - -} -PFNGLTEXCOORDP3UIVPROC glad_debug_glTexCoordP3uiv = glad_debug_impl_glTexCoordP3uiv; PFNGLVERTEXATTRIB1SVPROC glad_glVertexAttrib1sv; -void APIENTRY glad_debug_impl_glVertexAttrib1sv(GLuint arg0, const GLshort * arg1) { - _pre_call_callback("glVertexAttrib1sv", (void*)glVertexAttrib1sv, 2, arg0, arg1); - glad_glVertexAttrib1sv(arg0, arg1); - _post_call_callback("glVertexAttrib1sv", (void*)glVertexAttrib1sv, 2, arg0, arg1); - -} -PFNGLVERTEXATTRIB1SVPROC glad_debug_glVertexAttrib1sv = glad_debug_impl_glVertexAttrib1sv; PFNGLBINDSAMPLERPROC glad_glBindSampler; -void APIENTRY glad_debug_impl_glBindSampler(GLuint arg0, GLuint arg1) { - _pre_call_callback("glBindSampler", (void*)glBindSampler, 2, arg0, arg1); - glad_glBindSampler(arg0, arg1); - _post_call_callback("glBindSampler", (void*)glBindSampler, 2, arg0, arg1); - -} -PFNGLBINDSAMPLERPROC glad_debug_glBindSampler = glad_debug_impl_glBindSampler; PFNGLLINEWIDTHPROC glad_glLineWidth; -void APIENTRY glad_debug_impl_glLineWidth(GLfloat arg0) { - _pre_call_callback("glLineWidth", (void*)glLineWidth, 1, arg0); - glad_glLineWidth(arg0); - _post_call_callback("glLineWidth", (void*)glLineWidth, 1, arg0); - -} -PFNGLLINEWIDTHPROC glad_debug_glLineWidth = glad_debug_impl_glLineWidth; PFNGLCOLORP3UIVPROC glad_glColorP3uiv; -void APIENTRY glad_debug_impl_glColorP3uiv(GLenum arg0, const GLuint * arg1) { - _pre_call_callback("glColorP3uiv", (void*)glColorP3uiv, 2, arg0, arg1); - glad_glColorP3uiv(arg0, arg1); - _post_call_callback("glColorP3uiv", (void*)glColorP3uiv, 2, arg0, arg1); - -} -PFNGLCOLORP3UIVPROC glad_debug_glColorP3uiv = glad_debug_impl_glColorP3uiv; PFNGLGETINTEGERI_VPROC glad_glGetIntegeri_v; -void APIENTRY glad_debug_impl_glGetIntegeri_v(GLenum arg0, GLuint arg1, GLint * arg2) { - _pre_call_callback("glGetIntegeri_v", (void*)glGetIntegeri_v, 3, arg0, arg1, arg2); - glad_glGetIntegeri_v(arg0, arg1, arg2); - _post_call_callback("glGetIntegeri_v", (void*)glGetIntegeri_v, 3, arg0, arg1, arg2); - -} -PFNGLGETINTEGERI_VPROC glad_debug_glGetIntegeri_v = glad_debug_impl_glGetIntegeri_v; PFNGLCOMPILESHADERPROC glad_glCompileShader; -void APIENTRY glad_debug_impl_glCompileShader(GLuint arg0) { - _pre_call_callback("glCompileShader", (void*)glCompileShader, 1, arg0); - glad_glCompileShader(arg0); - _post_call_callback("glCompileShader", (void*)glCompileShader, 1, arg0); - -} -PFNGLCOMPILESHADERPROC glad_debug_glCompileShader = glad_debug_impl_glCompileShader; PFNGLGETTRANSFORMFEEDBACKVARYINGPROC glad_glGetTransformFeedbackVarying; -void APIENTRY glad_debug_impl_glGetTransformFeedbackVarying(GLuint arg0, GLuint arg1, GLsizei arg2, GLsizei * arg3, GLsizei * arg4, GLenum * arg5, GLchar * arg6) { - _pre_call_callback("glGetTransformFeedbackVarying", (void*)glGetTransformFeedbackVarying, 7, arg0, arg1, arg2, arg3, arg4, arg5, arg6); - glad_glGetTransformFeedbackVarying(arg0, arg1, arg2, arg3, arg4, arg5, arg6); - _post_call_callback("glGetTransformFeedbackVarying", (void*)glGetTransformFeedbackVarying, 7, arg0, arg1, arg2, arg3, arg4, arg5, arg6); - -} -PFNGLGETTRANSFORMFEEDBACKVARYINGPROC glad_debug_glGetTransformFeedbackVarying = glad_debug_impl_glGetTransformFeedbackVarying; PFNGLVERTEXATTRIBIPOINTERPROC glad_glVertexAttribIPointer; -void APIENTRY glad_debug_impl_glVertexAttribIPointer(GLuint arg0, GLint arg1, GLenum arg2, GLsizei arg3, const void * arg4) { - _pre_call_callback("glVertexAttribIPointer", (void*)glVertexAttribIPointer, 5, arg0, arg1, arg2, arg3, arg4); - glad_glVertexAttribIPointer(arg0, arg1, arg2, arg3, arg4); - _post_call_callback("glVertexAttribIPointer", (void*)glVertexAttribIPointer, 5, arg0, arg1, arg2, arg3, arg4); - -} -PFNGLVERTEXATTRIBIPOINTERPROC glad_debug_glVertexAttribIPointer = glad_debug_impl_glVertexAttribIPointer; PFNGLMULTITEXCOORDP3UIPROC glad_glMultiTexCoordP3ui; -void APIENTRY glad_debug_impl_glMultiTexCoordP3ui(GLenum arg0, GLenum arg1, GLuint arg2) { - _pre_call_callback("glMultiTexCoordP3ui", (void*)glMultiTexCoordP3ui, 3, arg0, arg1, arg2); - glad_glMultiTexCoordP3ui(arg0, arg1, arg2); - _post_call_callback("glMultiTexCoordP3ui", (void*)glMultiTexCoordP3ui, 3, arg0, arg1, arg2); - -} -PFNGLMULTITEXCOORDP3UIPROC glad_debug_glMultiTexCoordP3ui = glad_debug_impl_glMultiTexCoordP3ui; PFNGLVERTEXP4UIPROC glad_glVertexP4ui; -void APIENTRY glad_debug_impl_glVertexP4ui(GLenum arg0, GLuint arg1) { - _pre_call_callback("glVertexP4ui", (void*)glVertexP4ui, 2, arg0, arg1); - glad_glVertexP4ui(arg0, arg1); - _post_call_callback("glVertexP4ui", (void*)glVertexP4ui, 2, arg0, arg1); - -} -PFNGLVERTEXP4UIPROC glad_debug_glVertexP4ui = glad_debug_impl_glVertexP4ui; PFNGLENABLEIPROC glad_glEnablei; -void APIENTRY glad_debug_impl_glEnablei(GLenum arg0, GLuint arg1) { - _pre_call_callback("glEnablei", (void*)glEnablei, 2, arg0, arg1); - glad_glEnablei(arg0, arg1); - _post_call_callback("glEnablei", (void*)glEnablei, 2, arg0, arg1); - -} -PFNGLENABLEIPROC glad_debug_glEnablei = glad_debug_impl_glEnablei; PFNGLVERTEXATTRIBP4UIPROC glad_glVertexAttribP4ui; -void APIENTRY glad_debug_impl_glVertexAttribP4ui(GLuint arg0, GLenum arg1, GLboolean arg2, GLuint arg3) { - _pre_call_callback("glVertexAttribP4ui", (void*)glVertexAttribP4ui, 4, arg0, arg1, arg2, arg3); - glad_glVertexAttribP4ui(arg0, arg1, arg2, arg3); - _post_call_callback("glVertexAttribP4ui", (void*)glVertexAttribP4ui, 4, arg0, arg1, arg2, arg3); - -} -PFNGLVERTEXATTRIBP4UIPROC glad_debug_glVertexAttribP4ui = glad_debug_impl_glVertexAttribP4ui; PFNGLCREATESHADERPROC glad_glCreateShader; -GLuint APIENTRY glad_debug_impl_glCreateShader(GLenum arg0) { - GLuint ret; - _pre_call_callback("glCreateShader", (void*)glCreateShader, 1, arg0); - ret = glad_glCreateShader(arg0); - _post_call_callback("glCreateShader", (void*)glCreateShader, 1, arg0); - return ret; -} -PFNGLCREATESHADERPROC glad_debug_glCreateShader = glad_debug_impl_glCreateShader; PFNGLISBUFFERPROC glad_glIsBuffer; -GLboolean APIENTRY glad_debug_impl_glIsBuffer(GLuint arg0) { - GLboolean ret; - _pre_call_callback("glIsBuffer", (void*)glIsBuffer, 1, arg0); - ret = glad_glIsBuffer(arg0); - _post_call_callback("glIsBuffer", (void*)glIsBuffer, 1, arg0); - return ret; -} -PFNGLISBUFFERPROC glad_debug_glIsBuffer = glad_debug_impl_glIsBuffer; PFNGLGETMULTISAMPLEFVPROC glad_glGetMultisamplefv; -void APIENTRY glad_debug_impl_glGetMultisamplefv(GLenum arg0, GLuint arg1, GLfloat * arg2) { - _pre_call_callback("glGetMultisamplefv", (void*)glGetMultisamplefv, 3, arg0, arg1, arg2); - glad_glGetMultisamplefv(arg0, arg1, arg2); - _post_call_callback("glGetMultisamplefv", (void*)glGetMultisamplefv, 3, arg0, arg1, arg2); - -} -PFNGLGETMULTISAMPLEFVPROC glad_debug_glGetMultisamplefv = glad_debug_impl_glGetMultisamplefv; PFNGLGENRENDERBUFFERSPROC glad_glGenRenderbuffers; -void APIENTRY glad_debug_impl_glGenRenderbuffers(GLsizei arg0, GLuint * arg1) { - _pre_call_callback("glGenRenderbuffers", (void*)glGenRenderbuffers, 2, arg0, arg1); - glad_glGenRenderbuffers(arg0, arg1); - _post_call_callback("glGenRenderbuffers", (void*)glGenRenderbuffers, 2, arg0, arg1); - -} -PFNGLGENRENDERBUFFERSPROC glad_debug_glGenRenderbuffers = glad_debug_impl_glGenRenderbuffers; PFNGLCOPYTEXSUBIMAGE2DPROC glad_glCopyTexSubImage2D; -void APIENTRY glad_debug_impl_glCopyTexSubImage2D(GLenum arg0, GLint arg1, GLint arg2, GLint arg3, GLint arg4, GLint arg5, GLsizei arg6, GLsizei arg7) { - _pre_call_callback("glCopyTexSubImage2D", (void*)glCopyTexSubImage2D, 8, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7); - glad_glCopyTexSubImage2D(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7); - _post_call_callback("glCopyTexSubImage2D", (void*)glCopyTexSubImage2D, 8, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7); - -} -PFNGLCOPYTEXSUBIMAGE2DPROC glad_debug_glCopyTexSubImage2D = glad_debug_impl_glCopyTexSubImage2D; PFNGLCOMPRESSEDTEXIMAGE2DPROC glad_glCompressedTexImage2D; -void APIENTRY glad_debug_impl_glCompressedTexImage2D(GLenum arg0, GLint arg1, GLenum arg2, GLsizei arg3, GLsizei arg4, GLint arg5, GLsizei arg6, const void * arg7) { - _pre_call_callback("glCompressedTexImage2D", (void*)glCompressedTexImage2D, 8, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7); - glad_glCompressedTexImage2D(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7); - _post_call_callback("glCompressedTexImage2D", (void*)glCompressedTexImage2D, 8, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7); - -} -PFNGLCOMPRESSEDTEXIMAGE2DPROC glad_debug_glCompressedTexImage2D = glad_debug_impl_glCompressedTexImage2D; PFNGLVERTEXATTRIB1FPROC glad_glVertexAttrib1f; -void APIENTRY glad_debug_impl_glVertexAttrib1f(GLuint arg0, GLfloat arg1) { - _pre_call_callback("glVertexAttrib1f", (void*)glVertexAttrib1f, 2, arg0, arg1); - glad_glVertexAttrib1f(arg0, arg1); - _post_call_callback("glVertexAttrib1f", (void*)glVertexAttrib1f, 2, arg0, arg1); - -} -PFNGLVERTEXATTRIB1FPROC glad_debug_glVertexAttrib1f = glad_debug_impl_glVertexAttrib1f; PFNGLBLENDFUNCSEPARATEPROC glad_glBlendFuncSeparate; -void APIENTRY glad_debug_impl_glBlendFuncSeparate(GLenum arg0, GLenum arg1, GLenum arg2, GLenum arg3) { - _pre_call_callback("glBlendFuncSeparate", (void*)glBlendFuncSeparate, 4, arg0, arg1, arg2, arg3); - glad_glBlendFuncSeparate(arg0, arg1, arg2, arg3); - _post_call_callback("glBlendFuncSeparate", (void*)glBlendFuncSeparate, 4, arg0, arg1, arg2, arg3); - -} -PFNGLBLENDFUNCSEPARATEPROC glad_debug_glBlendFuncSeparate = glad_debug_impl_glBlendFuncSeparate; PFNGLHINTPROC glad_glHint; -void APIENTRY glad_debug_impl_glHint(GLenum arg0, GLenum arg1) { - _pre_call_callback("glHint", (void*)glHint, 2, arg0, arg1); - glad_glHint(arg0, arg1); - _post_call_callback("glHint", (void*)glHint, 2, arg0, arg1); - -} -PFNGLHINTPROC glad_debug_glHint = glad_debug_impl_glHint; PFNGLVERTEXATTRIB1SPROC glad_glVertexAttrib1s; -void APIENTRY glad_debug_impl_glVertexAttrib1s(GLuint arg0, GLshort arg1) { - _pre_call_callback("glVertexAttrib1s", (void*)glVertexAttrib1s, 2, arg0, arg1); - glad_glVertexAttrib1s(arg0, arg1); - _post_call_callback("glVertexAttrib1s", (void*)glVertexAttrib1s, 2, arg0, arg1); - -} -PFNGLVERTEXATTRIB1SPROC glad_debug_glVertexAttrib1s = glad_debug_impl_glVertexAttrib1s; PFNGLSAMPLEMASKIPROC glad_glSampleMaski; -void APIENTRY glad_debug_impl_glSampleMaski(GLuint arg0, GLbitfield arg1) { - _pre_call_callback("glSampleMaski", (void*)glSampleMaski, 2, arg0, arg1); - glad_glSampleMaski(arg0, arg1); - _post_call_callback("glSampleMaski", (void*)glSampleMaski, 2, arg0, arg1); - -} -PFNGLSAMPLEMASKIPROC glad_debug_glSampleMaski = glad_debug_impl_glSampleMaski; PFNGLVERTEXP2UIPROC glad_glVertexP2ui; -void APIENTRY glad_debug_impl_glVertexP2ui(GLenum arg0, GLuint arg1) { - _pre_call_callback("glVertexP2ui", (void*)glVertexP2ui, 2, arg0, arg1); - glad_glVertexP2ui(arg0, arg1); - _post_call_callback("glVertexP2ui", (void*)glVertexP2ui, 2, arg0, arg1); - -} -PFNGLVERTEXP2UIPROC glad_debug_glVertexP2ui = glad_debug_impl_glVertexP2ui; PFNGLUNIFORMMATRIX3X2FVPROC glad_glUniformMatrix3x2fv; -void APIENTRY glad_debug_impl_glUniformMatrix3x2fv(GLint arg0, GLsizei arg1, GLboolean arg2, const GLfloat * arg3) { - _pre_call_callback("glUniformMatrix3x2fv", (void*)glUniformMatrix3x2fv, 4, arg0, arg1, arg2, arg3); - glad_glUniformMatrix3x2fv(arg0, arg1, arg2, arg3); - _post_call_callback("glUniformMatrix3x2fv", (void*)glUniformMatrix3x2fv, 4, arg0, arg1, arg2, arg3); - -} -PFNGLUNIFORMMATRIX3X2FVPROC glad_debug_glUniformMatrix3x2fv = glad_debug_impl_glUniformMatrix3x2fv; PFNGLPOINTSIZEPROC glad_glPointSize; -void APIENTRY glad_debug_impl_glPointSize(GLfloat arg0) { - _pre_call_callback("glPointSize", (void*)glPointSize, 1, arg0); - glad_glPointSize(arg0); - _post_call_callback("glPointSize", (void*)glPointSize, 1, arg0); - -} -PFNGLPOINTSIZEPROC glad_debug_glPointSize = glad_debug_impl_glPointSize; PFNGLVERTEXATTRIB2DVPROC glad_glVertexAttrib2dv; -void APIENTRY glad_debug_impl_glVertexAttrib2dv(GLuint arg0, const GLdouble * arg1) { - _pre_call_callback("glVertexAttrib2dv", (void*)glVertexAttrib2dv, 2, arg0, arg1); - glad_glVertexAttrib2dv(arg0, arg1); - _post_call_callback("glVertexAttrib2dv", (void*)glVertexAttrib2dv, 2, arg0, arg1); - -} -PFNGLVERTEXATTRIB2DVPROC glad_debug_glVertexAttrib2dv = glad_debug_impl_glVertexAttrib2dv; PFNGLDELETEPROGRAMPROC glad_glDeleteProgram; -void APIENTRY glad_debug_impl_glDeleteProgram(GLuint arg0) { - _pre_call_callback("glDeleteProgram", (void*)glDeleteProgram, 1, arg0); - glad_glDeleteProgram(arg0); - _post_call_callback("glDeleteProgram", (void*)glDeleteProgram, 1, arg0); - -} -PFNGLDELETEPROGRAMPROC glad_debug_glDeleteProgram = glad_debug_impl_glDeleteProgram; PFNGLVERTEXATTRIB4NUIVPROC glad_glVertexAttrib4Nuiv; -void APIENTRY glad_debug_impl_glVertexAttrib4Nuiv(GLuint arg0, const GLuint * arg1) { - _pre_call_callback("glVertexAttrib4Nuiv", (void*)glVertexAttrib4Nuiv, 2, arg0, arg1); - glad_glVertexAttrib4Nuiv(arg0, arg1); - _post_call_callback("glVertexAttrib4Nuiv", (void*)glVertexAttrib4Nuiv, 2, arg0, arg1); - -} -PFNGLVERTEXATTRIB4NUIVPROC glad_debug_glVertexAttrib4Nuiv = glad_debug_impl_glVertexAttrib4Nuiv; PFNGLRENDERBUFFERSTORAGEPROC glad_glRenderbufferStorage; -void APIENTRY glad_debug_impl_glRenderbufferStorage(GLenum arg0, GLenum arg1, GLsizei arg2, GLsizei arg3) { - _pre_call_callback("glRenderbufferStorage", (void*)glRenderbufferStorage, 4, arg0, arg1, arg2, arg3); - glad_glRenderbufferStorage(arg0, arg1, arg2, arg3); - _post_call_callback("glRenderbufferStorage", (void*)glRenderbufferStorage, 4, arg0, arg1, arg2, arg3); - -} -PFNGLRENDERBUFFERSTORAGEPROC glad_debug_glRenderbufferStorage = glad_debug_impl_glRenderbufferStorage; PFNGLWAITSYNCPROC glad_glWaitSync; -void APIENTRY glad_debug_impl_glWaitSync(GLsync arg0, GLbitfield arg1, GLuint64 arg2) { - _pre_call_callback("glWaitSync", (void*)glWaitSync, 3, arg0, arg1, arg2); - glad_glWaitSync(arg0, arg1, arg2); - _post_call_callback("glWaitSync", (void*)glWaitSync, 3, arg0, arg1, arg2); - -} -PFNGLWAITSYNCPROC glad_debug_glWaitSync = glad_debug_impl_glWaitSync; PFNGLUNIFORMMATRIX4X3FVPROC glad_glUniformMatrix4x3fv; -void APIENTRY glad_debug_impl_glUniformMatrix4x3fv(GLint arg0, GLsizei arg1, GLboolean arg2, const GLfloat * arg3) { - _pre_call_callback("glUniformMatrix4x3fv", (void*)glUniformMatrix4x3fv, 4, arg0, arg1, arg2, arg3); - glad_glUniformMatrix4x3fv(arg0, arg1, arg2, arg3); - _post_call_callback("glUniformMatrix4x3fv", (void*)glUniformMatrix4x3fv, 4, arg0, arg1, arg2, arg3); - -} -PFNGLUNIFORMMATRIX4X3FVPROC glad_debug_glUniformMatrix4x3fv = glad_debug_impl_glUniformMatrix4x3fv; PFNGLUNIFORM3IPROC glad_glUniform3i; -void APIENTRY glad_debug_impl_glUniform3i(GLint arg0, GLint arg1, GLint arg2, GLint arg3) { - _pre_call_callback("glUniform3i", (void*)glUniform3i, 4, arg0, arg1, arg2, arg3); - glad_glUniform3i(arg0, arg1, arg2, arg3); - _post_call_callback("glUniform3i", (void*)glUniform3i, 4, arg0, arg1, arg2, arg3); - -} -PFNGLUNIFORM3IPROC glad_debug_glUniform3i = glad_debug_impl_glUniform3i; PFNGLCLEARBUFFERFVPROC glad_glClearBufferfv; -void APIENTRY glad_debug_impl_glClearBufferfv(GLenum arg0, GLint arg1, const GLfloat * arg2) { - _pre_call_callback("glClearBufferfv", (void*)glClearBufferfv, 3, arg0, arg1, arg2); - glad_glClearBufferfv(arg0, arg1, arg2); - _post_call_callback("glClearBufferfv", (void*)glClearBufferfv, 3, arg0, arg1, arg2); - -} -PFNGLCLEARBUFFERFVPROC glad_debug_glClearBufferfv = glad_debug_impl_glClearBufferfv; PFNGLUNIFORM3FPROC glad_glUniform3f; -void APIENTRY glad_debug_impl_glUniform3f(GLint arg0, GLfloat arg1, GLfloat arg2, GLfloat arg3) { - _pre_call_callback("glUniform3f", (void*)glUniform3f, 4, arg0, arg1, arg2, arg3); - glad_glUniform3f(arg0, arg1, arg2, arg3); - _post_call_callback("glUniform3f", (void*)glUniform3f, 4, arg0, arg1, arg2, arg3); - -} -PFNGLUNIFORM3FPROC glad_debug_glUniform3f = glad_debug_impl_glUniform3f; PFNGLVERTEXATTRIB4UBVPROC glad_glVertexAttrib4ubv; -void APIENTRY glad_debug_impl_glVertexAttrib4ubv(GLuint arg0, const GLubyte * arg1) { - _pre_call_callback("glVertexAttrib4ubv", (void*)glVertexAttrib4ubv, 2, arg0, arg1); - glad_glVertexAttrib4ubv(arg0, arg1); - _post_call_callback("glVertexAttrib4ubv", (void*)glVertexAttrib4ubv, 2, arg0, arg1); - -} -PFNGLVERTEXATTRIB4UBVPROC glad_debug_glVertexAttrib4ubv = glad_debug_impl_glVertexAttrib4ubv; PFNGLGETBUFFERPARAMETERIVPROC glad_glGetBufferParameteriv; -void APIENTRY glad_debug_impl_glGetBufferParameteriv(GLenum arg0, GLenum arg1, GLint * arg2) { - _pre_call_callback("glGetBufferParameteriv", (void*)glGetBufferParameteriv, 3, arg0, arg1, arg2); - glad_glGetBufferParameteriv(arg0, arg1, arg2); - _post_call_callback("glGetBufferParameteriv", (void*)glGetBufferParameteriv, 3, arg0, arg1, arg2); - -} -PFNGLGETBUFFERPARAMETERIVPROC glad_debug_glGetBufferParameteriv = glad_debug_impl_glGetBufferParameteriv; PFNGLTEXCOORDP2UIPROC glad_glTexCoordP2ui; -void APIENTRY glad_debug_impl_glTexCoordP2ui(GLenum arg0, GLuint arg1) { - _pre_call_callback("glTexCoordP2ui", (void*)glTexCoordP2ui, 2, arg0, arg1); - glad_glTexCoordP2ui(arg0, arg1); - _post_call_callback("glTexCoordP2ui", (void*)glTexCoordP2ui, 2, arg0, arg1); - -} -PFNGLTEXCOORDP2UIPROC glad_debug_glTexCoordP2ui = glad_debug_impl_glTexCoordP2ui; PFNGLCOLORMASKIPROC glad_glColorMaski; -void APIENTRY glad_debug_impl_glColorMaski(GLuint arg0, GLboolean arg1, GLboolean arg2, GLboolean arg3, GLboolean arg4) { - _pre_call_callback("glColorMaski", (void*)glColorMaski, 5, arg0, arg1, arg2, arg3, arg4); - glad_glColorMaski(arg0, arg1, arg2, arg3, arg4); - _post_call_callback("glColorMaski", (void*)glColorMaski, 5, arg0, arg1, arg2, arg3, arg4); - -} -PFNGLCOLORMASKIPROC glad_debug_glColorMaski = glad_debug_impl_glColorMaski; PFNGLCLEARBUFFERFIPROC glad_glClearBufferfi; -void APIENTRY glad_debug_impl_glClearBufferfi(GLenum arg0, GLint arg1, GLfloat arg2, GLint arg3) { - _pre_call_callback("glClearBufferfi", (void*)glClearBufferfi, 4, arg0, arg1, arg2, arg3); - glad_glClearBufferfi(arg0, arg1, arg2, arg3); - _post_call_callback("glClearBufferfi", (void*)glClearBufferfi, 4, arg0, arg1, arg2, arg3); - -} -PFNGLCLEARBUFFERFIPROC glad_debug_glClearBufferfi = glad_debug_impl_glClearBufferfi; PFNGLGENVERTEXARRAYSPROC glad_glGenVertexArrays; -void APIENTRY glad_debug_impl_glGenVertexArrays(GLsizei arg0, GLuint * arg1) { - _pre_call_callback("glGenVertexArrays", (void*)glGenVertexArrays, 2, arg0, arg1); - glad_glGenVertexArrays(arg0, arg1); - _post_call_callback("glGenVertexArrays", (void*)glGenVertexArrays, 2, arg0, arg1); - -} -PFNGLGENVERTEXARRAYSPROC glad_debug_glGenVertexArrays = glad_debug_impl_glGenVertexArrays; PFNGLMULTITEXCOORDP2UIPROC glad_glMultiTexCoordP2ui; -void APIENTRY glad_debug_impl_glMultiTexCoordP2ui(GLenum arg0, GLenum arg1, GLuint arg2) { - _pre_call_callback("glMultiTexCoordP2ui", (void*)glMultiTexCoordP2ui, 3, arg0, arg1, arg2); - glad_glMultiTexCoordP2ui(arg0, arg1, arg2); - _post_call_callback("glMultiTexCoordP2ui", (void*)glMultiTexCoordP2ui, 3, arg0, arg1, arg2); - -} -PFNGLMULTITEXCOORDP2UIPROC glad_debug_glMultiTexCoordP2ui = glad_debug_impl_glMultiTexCoordP2ui; PFNGLGETSAMPLERPARAMETERIIVPROC glad_glGetSamplerParameterIiv; -void APIENTRY glad_debug_impl_glGetSamplerParameterIiv(GLuint arg0, GLenum arg1, GLint * arg2) { - _pre_call_callback("glGetSamplerParameterIiv", (void*)glGetSamplerParameterIiv, 3, arg0, arg1, arg2); - glad_glGetSamplerParameterIiv(arg0, arg1, arg2); - _post_call_callback("glGetSamplerParameterIiv", (void*)glGetSamplerParameterIiv, 3, arg0, arg1, arg2); - -} -PFNGLGETSAMPLERPARAMETERIIVPROC glad_debug_glGetSamplerParameterIiv = glad_debug_impl_glGetSamplerParameterIiv; PFNGLGETFRAGDATAINDEXPROC glad_glGetFragDataIndex; -GLint APIENTRY glad_debug_impl_glGetFragDataIndex(GLuint arg0, const GLchar * arg1) { - GLint ret; - _pre_call_callback("glGetFragDataIndex", (void*)glGetFragDataIndex, 2, arg0, arg1); - ret = glad_glGetFragDataIndex(arg0, arg1); - _post_call_callback("glGetFragDataIndex", (void*)glGetFragDataIndex, 2, arg0, arg1); - return ret; -} -PFNGLGETFRAGDATAINDEXPROC glad_debug_glGetFragDataIndex = glad_debug_impl_glGetFragDataIndex; PFNGLGETVERTEXATTRIBDVPROC glad_glGetVertexAttribdv; -void APIENTRY glad_debug_impl_glGetVertexAttribdv(GLuint arg0, GLenum arg1, GLdouble * arg2) { - _pre_call_callback("glGetVertexAttribdv", (void*)glGetVertexAttribdv, 3, arg0, arg1, arg2); - glad_glGetVertexAttribdv(arg0, arg1, arg2); - _post_call_callback("glGetVertexAttribdv", (void*)glGetVertexAttribdv, 3, arg0, arg1, arg2); - -} -PFNGLGETVERTEXATTRIBDVPROC glad_debug_glGetVertexAttribdv = glad_debug_impl_glGetVertexAttribdv; PFNGLUNIFORMMATRIX3X4FVPROC glad_glUniformMatrix3x4fv; -void APIENTRY glad_debug_impl_glUniformMatrix3x4fv(GLint arg0, GLsizei arg1, GLboolean arg2, const GLfloat * arg3) { - _pre_call_callback("glUniformMatrix3x4fv", (void*)glUniformMatrix3x4fv, 4, arg0, arg1, arg2, arg3); - glad_glUniformMatrix3x4fv(arg0, arg1, arg2, arg3); - _post_call_callback("glUniformMatrix3x4fv", (void*)glUniformMatrix3x4fv, 4, arg0, arg1, arg2, arg3); - -} -PFNGLUNIFORMMATRIX3X4FVPROC glad_debug_glUniformMatrix3x4fv = glad_debug_impl_glUniformMatrix3x4fv; PFNGLMULTITEXCOORDP4UIPROC glad_glMultiTexCoordP4ui; -void APIENTRY glad_debug_impl_glMultiTexCoordP4ui(GLenum arg0, GLenum arg1, GLuint arg2) { - _pre_call_callback("glMultiTexCoordP4ui", (void*)glMultiTexCoordP4ui, 3, arg0, arg1, arg2); - glad_glMultiTexCoordP4ui(arg0, arg1, arg2); - _post_call_callback("glMultiTexCoordP4ui", (void*)glMultiTexCoordP4ui, 3, arg0, arg1, arg2); - -} -PFNGLMULTITEXCOORDP4UIPROC glad_debug_glMultiTexCoordP4ui = glad_debug_impl_glMultiTexCoordP4ui; PFNGLDELETEFRAMEBUFFERSPROC glad_glDeleteFramebuffers; -void APIENTRY glad_debug_impl_glDeleteFramebuffers(GLsizei arg0, const GLuint * arg1) { - _pre_call_callback("glDeleteFramebuffers", (void*)glDeleteFramebuffers, 2, arg0, arg1); - glad_glDeleteFramebuffers(arg0, arg1); - _post_call_callback("glDeleteFramebuffers", (void*)glDeleteFramebuffers, 2, arg0, arg1); - -} -PFNGLDELETEFRAMEBUFFERSPROC glad_debug_glDeleteFramebuffers = glad_debug_impl_glDeleteFramebuffers; PFNGLDRAWARRAYSPROC glad_glDrawArrays; -void APIENTRY glad_debug_impl_glDrawArrays(GLenum arg0, GLint arg1, GLsizei arg2) { - _pre_call_callback("glDrawArrays", (void*)glDrawArrays, 3, arg0, arg1, arg2); - glad_glDrawArrays(arg0, arg1, arg2); - _post_call_callback("glDrawArrays", (void*)glDrawArrays, 3, arg0, arg1, arg2); - -} -PFNGLDRAWARRAYSPROC glad_debug_glDrawArrays = glad_debug_impl_glDrawArrays; PFNGLUNIFORM1UIPROC glad_glUniform1ui; -void APIENTRY glad_debug_impl_glUniform1ui(GLint arg0, GLuint arg1) { - _pre_call_callback("glUniform1ui", (void*)glUniform1ui, 2, arg0, arg1); - glad_glUniform1ui(arg0, arg1); - _post_call_callback("glUniform1ui", (void*)glUniform1ui, 2, arg0, arg1); - -} -PFNGLUNIFORM1UIPROC glad_debug_glUniform1ui = glad_debug_impl_glUniform1ui; PFNGLVERTEXATTRIBI2IPROC glad_glVertexAttribI2i; -void APIENTRY glad_debug_impl_glVertexAttribI2i(GLuint arg0, GLint arg1, GLint arg2) { - _pre_call_callback("glVertexAttribI2i", (void*)glVertexAttribI2i, 3, arg0, arg1, arg2); - glad_glVertexAttribI2i(arg0, arg1, arg2); - _post_call_callback("glVertexAttribI2i", (void*)glVertexAttribI2i, 3, arg0, arg1, arg2); - -} -PFNGLVERTEXATTRIBI2IPROC glad_debug_glVertexAttribI2i = glad_debug_impl_glVertexAttribI2i; PFNGLTEXCOORDP3UIPROC glad_glTexCoordP3ui; -void APIENTRY glad_debug_impl_glTexCoordP3ui(GLenum arg0, GLuint arg1) { - _pre_call_callback("glTexCoordP3ui", (void*)glTexCoordP3ui, 2, arg0, arg1); - glad_glTexCoordP3ui(arg0, arg1); - _post_call_callback("glTexCoordP3ui", (void*)glTexCoordP3ui, 2, arg0, arg1); - -} -PFNGLTEXCOORDP3UIPROC glad_debug_glTexCoordP3ui = glad_debug_impl_glTexCoordP3ui; PFNGLVERTEXATTRIB3DPROC glad_glVertexAttrib3d; -void APIENTRY glad_debug_impl_glVertexAttrib3d(GLuint arg0, GLdouble arg1, GLdouble arg2, GLdouble arg3) { - _pre_call_callback("glVertexAttrib3d", (void*)glVertexAttrib3d, 4, arg0, arg1, arg2, arg3); - glad_glVertexAttrib3d(arg0, arg1, arg2, arg3); - _post_call_callback("glVertexAttrib3d", (void*)glVertexAttrib3d, 4, arg0, arg1, arg2, arg3); - -} -PFNGLVERTEXATTRIB3DPROC glad_debug_glVertexAttrib3d = glad_debug_impl_glVertexAttrib3d; PFNGLCLEARPROC glad_glClear; -void APIENTRY glad_debug_impl_glClear(GLbitfield arg0) { - _pre_call_callback("glClear", (void*)glClear, 1, arg0); - glad_glClear(arg0); - _post_call_callback("glClear", (void*)glClear, 1, arg0); - -} -PFNGLCLEARPROC glad_debug_glClear = glad_debug_impl_glClear; PFNGLGETACTIVEUNIFORMNAMEPROC glad_glGetActiveUniformName; -void APIENTRY glad_debug_impl_glGetActiveUniformName(GLuint arg0, GLuint arg1, GLsizei arg2, GLsizei * arg3, GLchar * arg4) { - _pre_call_callback("glGetActiveUniformName", (void*)glGetActiveUniformName, 5, arg0, arg1, arg2, arg3, arg4); - glad_glGetActiveUniformName(arg0, arg1, arg2, arg3, arg4); - _post_call_callback("glGetActiveUniformName", (void*)glGetActiveUniformName, 5, arg0, arg1, arg2, arg3, arg4); - -} -PFNGLGETACTIVEUNIFORMNAMEPROC glad_debug_glGetActiveUniformName = glad_debug_impl_glGetActiveUniformName; PFNGLISENABLEDPROC glad_glIsEnabled; -GLboolean APIENTRY glad_debug_impl_glIsEnabled(GLenum arg0) { - GLboolean ret; - _pre_call_callback("glIsEnabled", (void*)glIsEnabled, 1, arg0); - ret = glad_glIsEnabled(arg0); - _post_call_callback("glIsEnabled", (void*)glIsEnabled, 1, arg0); - return ret; -} -PFNGLISENABLEDPROC glad_debug_glIsEnabled = glad_debug_impl_glIsEnabled; PFNGLSTENCILOPPROC glad_glStencilOp; -void APIENTRY glad_debug_impl_glStencilOp(GLenum arg0, GLenum arg1, GLenum arg2) { - _pre_call_callback("glStencilOp", (void*)glStencilOp, 3, arg0, arg1, arg2); - glad_glStencilOp(arg0, arg1, arg2); - _post_call_callback("glStencilOp", (void*)glStencilOp, 3, arg0, arg1, arg2); - -} -PFNGLSTENCILOPPROC glad_debug_glStencilOp = glad_debug_impl_glStencilOp; PFNGLFRAMEBUFFERTEXTURE2DPROC glad_glFramebufferTexture2D; -void APIENTRY glad_debug_impl_glFramebufferTexture2D(GLenum arg0, GLenum arg1, GLenum arg2, GLuint arg3, GLint arg4) { - _pre_call_callback("glFramebufferTexture2D", (void*)glFramebufferTexture2D, 5, arg0, arg1, arg2, arg3, arg4); - glad_glFramebufferTexture2D(arg0, arg1, arg2, arg3, arg4); - _post_call_callback("glFramebufferTexture2D", (void*)glFramebufferTexture2D, 5, arg0, arg1, arg2, arg3, arg4); - -} -PFNGLFRAMEBUFFERTEXTURE2DPROC glad_debug_glFramebufferTexture2D = glad_debug_impl_glFramebufferTexture2D; PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC glad_glGetFramebufferAttachmentParameteriv; -void APIENTRY glad_debug_impl_glGetFramebufferAttachmentParameteriv(GLenum arg0, GLenum arg1, GLenum arg2, GLint * arg3) { - _pre_call_callback("glGetFramebufferAttachmentParameteriv", (void*)glGetFramebufferAttachmentParameteriv, 4, arg0, arg1, arg2, arg3); - glad_glGetFramebufferAttachmentParameteriv(arg0, arg1, arg2, arg3); - _post_call_callback("glGetFramebufferAttachmentParameteriv", (void*)glGetFramebufferAttachmentParameteriv, 4, arg0, arg1, arg2, arg3); - -} -PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC glad_debug_glGetFramebufferAttachmentParameteriv = glad_debug_impl_glGetFramebufferAttachmentParameteriv; PFNGLVERTEXATTRIB4NUBPROC glad_glVertexAttrib4Nub; -void APIENTRY glad_debug_impl_glVertexAttrib4Nub(GLuint arg0, GLubyte arg1, GLubyte arg2, GLubyte arg3, GLubyte arg4) { - _pre_call_callback("glVertexAttrib4Nub", (void*)glVertexAttrib4Nub, 5, arg0, arg1, arg2, arg3, arg4); - glad_glVertexAttrib4Nub(arg0, arg1, arg2, arg3, arg4); - _post_call_callback("glVertexAttrib4Nub", (void*)glVertexAttrib4Nub, 5, arg0, arg1, arg2, arg3, arg4); - -} -PFNGLVERTEXATTRIB4NUBPROC glad_debug_glVertexAttrib4Nub = glad_debug_impl_glVertexAttrib4Nub; PFNGLGETFRAGDATALOCATIONPROC glad_glGetFragDataLocation; -GLint APIENTRY glad_debug_impl_glGetFragDataLocation(GLuint arg0, const GLchar * arg1) { - GLint ret; - _pre_call_callback("glGetFragDataLocation", (void*)glGetFragDataLocation, 2, arg0, arg1); - ret = glad_glGetFragDataLocation(arg0, arg1); - _post_call_callback("glGetFragDataLocation", (void*)glGetFragDataLocation, 2, arg0, arg1); - return ret; -} -PFNGLGETFRAGDATALOCATIONPROC glad_debug_glGetFragDataLocation = glad_debug_impl_glGetFragDataLocation; PFNGLTEXIMAGE1DPROC glad_glTexImage1D; -void APIENTRY glad_debug_impl_glTexImage1D(GLenum arg0, GLint arg1, GLint arg2, GLsizei arg3, GLint arg4, GLenum arg5, GLenum arg6, const void * arg7) { - _pre_call_callback("glTexImage1D", (void*)glTexImage1D, 8, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7); - glad_glTexImage1D(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7); - _post_call_callback("glTexImage1D", (void*)glTexImage1D, 8, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7); - -} -PFNGLTEXIMAGE1DPROC glad_debug_glTexImage1D = glad_debug_impl_glTexImage1D; PFNGLTEXPARAMETERIVPROC glad_glTexParameteriv; -void APIENTRY glad_debug_impl_glTexParameteriv(GLenum arg0, GLenum arg1, const GLint * arg2) { - _pre_call_callback("glTexParameteriv", (void*)glTexParameteriv, 3, arg0, arg1, arg2); - glad_glTexParameteriv(arg0, arg1, arg2); - _post_call_callback("glTexParameteriv", (void*)glTexParameteriv, 3, arg0, arg1, arg2); - -} -PFNGLTEXPARAMETERIVPROC glad_debug_glTexParameteriv = glad_debug_impl_glTexParameteriv; PFNGLGETTEXIMAGEPROC glad_glGetTexImage; -void APIENTRY glad_debug_impl_glGetTexImage(GLenum arg0, GLint arg1, GLenum arg2, GLenum arg3, void * arg4) { - _pre_call_callback("glGetTexImage", (void*)glGetTexImage, 5, arg0, arg1, arg2, arg3, arg4); - glad_glGetTexImage(arg0, arg1, arg2, arg3, arg4); - _post_call_callback("glGetTexImage", (void*)glGetTexImage, 5, arg0, arg1, arg2, arg3, arg4); - -} -PFNGLGETTEXIMAGEPROC glad_debug_glGetTexImage = glad_debug_impl_glGetTexImage; PFNGLGETQUERYOBJECTI64VPROC glad_glGetQueryObjecti64v; -void APIENTRY glad_debug_impl_glGetQueryObjecti64v(GLuint arg0, GLenum arg1, GLint64 * arg2) { - _pre_call_callback("glGetQueryObjecti64v", (void*)glGetQueryObjecti64v, 3, arg0, arg1, arg2); - glad_glGetQueryObjecti64v(arg0, arg1, arg2); - _post_call_callback("glGetQueryObjecti64v", (void*)glGetQueryObjecti64v, 3, arg0, arg1, arg2); - -} -PFNGLGETQUERYOBJECTI64VPROC glad_debug_glGetQueryObjecti64v = glad_debug_impl_glGetQueryObjecti64v; PFNGLGENFRAMEBUFFERSPROC glad_glGenFramebuffers; -void APIENTRY glad_debug_impl_glGenFramebuffers(GLsizei arg0, GLuint * arg1) { - _pre_call_callback("glGenFramebuffers", (void*)glGenFramebuffers, 2, arg0, arg1); - glad_glGenFramebuffers(arg0, arg1); - _post_call_callback("glGenFramebuffers", (void*)glGenFramebuffers, 2, arg0, arg1); - -} -PFNGLGENFRAMEBUFFERSPROC glad_debug_glGenFramebuffers = glad_debug_impl_glGenFramebuffers; PFNGLGETATTACHEDSHADERSPROC glad_glGetAttachedShaders; -void APIENTRY glad_debug_impl_glGetAttachedShaders(GLuint arg0, GLsizei arg1, GLsizei * arg2, GLuint * arg3) { - _pre_call_callback("glGetAttachedShaders", (void*)glGetAttachedShaders, 4, arg0, arg1, arg2, arg3); - glad_glGetAttachedShaders(arg0, arg1, arg2, arg3); - _post_call_callback("glGetAttachedShaders", (void*)glGetAttachedShaders, 4, arg0, arg1, arg2, arg3); - -} -PFNGLGETATTACHEDSHADERSPROC glad_debug_glGetAttachedShaders = glad_debug_impl_glGetAttachedShaders; PFNGLISRENDERBUFFERPROC glad_glIsRenderbuffer; -GLboolean APIENTRY glad_debug_impl_glIsRenderbuffer(GLuint arg0) { - GLboolean ret; - _pre_call_callback("glIsRenderbuffer", (void*)glIsRenderbuffer, 1, arg0); - ret = glad_glIsRenderbuffer(arg0); - _post_call_callback("glIsRenderbuffer", (void*)glIsRenderbuffer, 1, arg0); - return ret; -} -PFNGLISRENDERBUFFERPROC glad_debug_glIsRenderbuffer = glad_debug_impl_glIsRenderbuffer; PFNGLDELETEVERTEXARRAYSPROC glad_glDeleteVertexArrays; -void APIENTRY glad_debug_impl_glDeleteVertexArrays(GLsizei arg0, const GLuint * arg1) { - _pre_call_callback("glDeleteVertexArrays", (void*)glDeleteVertexArrays, 2, arg0, arg1); - glad_glDeleteVertexArrays(arg0, arg1); - _post_call_callback("glDeleteVertexArrays", (void*)glDeleteVertexArrays, 2, arg0, arg1); - -} -PFNGLDELETEVERTEXARRAYSPROC glad_debug_glDeleteVertexArrays = glad_debug_impl_glDeleteVertexArrays; PFNGLISVERTEXARRAYPROC glad_glIsVertexArray; -GLboolean APIENTRY glad_debug_impl_glIsVertexArray(GLuint arg0) { - GLboolean ret; - _pre_call_callback("glIsVertexArray", (void*)glIsVertexArray, 1, arg0); - ret = glad_glIsVertexArray(arg0); - _post_call_callback("glIsVertexArray", (void*)glIsVertexArray, 1, arg0); - return ret; -} -PFNGLISVERTEXARRAYPROC glad_debug_glIsVertexArray = glad_debug_impl_glIsVertexArray; PFNGLDISABLEVERTEXATTRIBARRAYPROC glad_glDisableVertexAttribArray; -void APIENTRY glad_debug_impl_glDisableVertexAttribArray(GLuint arg0) { - _pre_call_callback("glDisableVertexAttribArray", (void*)glDisableVertexAttribArray, 1, arg0); - glad_glDisableVertexAttribArray(arg0); - _post_call_callback("glDisableVertexAttribArray", (void*)glDisableVertexAttribArray, 1, arg0); - -} -PFNGLDISABLEVERTEXATTRIBARRAYPROC glad_debug_glDisableVertexAttribArray = glad_debug_impl_glDisableVertexAttribArray; PFNGLGETQUERYIVPROC glad_glGetQueryiv; -void APIENTRY glad_debug_impl_glGetQueryiv(GLenum arg0, GLenum arg1, GLint * arg2) { - _pre_call_callback("glGetQueryiv", (void*)glGetQueryiv, 3, arg0, arg1, arg2); - glad_glGetQueryiv(arg0, arg1, arg2); - _post_call_callback("glGetQueryiv", (void*)glGetQueryiv, 3, arg0, arg1, arg2); - -} -PFNGLGETQUERYIVPROC glad_debug_glGetQueryiv = glad_debug_impl_glGetQueryiv; PFNGLGETSAMPLERPARAMETERFVPROC glad_glGetSamplerParameterfv; -void APIENTRY glad_debug_impl_glGetSamplerParameterfv(GLuint arg0, GLenum arg1, GLfloat * arg2) { - _pre_call_callback("glGetSamplerParameterfv", (void*)glGetSamplerParameterfv, 3, arg0, arg1, arg2); - glad_glGetSamplerParameterfv(arg0, arg1, arg2); - _post_call_callback("glGetSamplerParameterfv", (void*)glGetSamplerParameterfv, 3, arg0, arg1, arg2); - -} -PFNGLGETSAMPLERPARAMETERFVPROC glad_debug_glGetSamplerParameterfv = glad_debug_impl_glGetSamplerParameterfv; PFNGLGETUNIFORMINDICESPROC glad_glGetUniformIndices; -void APIENTRY glad_debug_impl_glGetUniformIndices(GLuint arg0, GLsizei arg1, const GLchar *const* arg2, GLuint * arg3) { - _pre_call_callback("glGetUniformIndices", (void*)glGetUniformIndices, 4, arg0, arg1, arg2, arg3); - glad_glGetUniformIndices(arg0, arg1, arg2, arg3); - _post_call_callback("glGetUniformIndices", (void*)glGetUniformIndices, 4, arg0, arg1, arg2, arg3); - -} -PFNGLGETUNIFORMINDICESPROC glad_debug_glGetUniformIndices = glad_debug_impl_glGetUniformIndices; PFNGLISSHADERPROC glad_glIsShader; -GLboolean APIENTRY glad_debug_impl_glIsShader(GLuint arg0) { - GLboolean ret; - _pre_call_callback("glIsShader", (void*)glIsShader, 1, arg0); - ret = glad_glIsShader(arg0); - _post_call_callback("glIsShader", (void*)glIsShader, 1, arg0); - return ret; -} -PFNGLISSHADERPROC glad_debug_glIsShader = glad_debug_impl_glIsShader; PFNGLVERTEXATTRIBI4UBVPROC glad_glVertexAttribI4ubv; -void APIENTRY glad_debug_impl_glVertexAttribI4ubv(GLuint arg0, const GLubyte * arg1) { - _pre_call_callback("glVertexAttribI4ubv", (void*)glVertexAttribI4ubv, 2, arg0, arg1); - glad_glVertexAttribI4ubv(arg0, arg1); - _post_call_callback("glVertexAttribI4ubv", (void*)glVertexAttribI4ubv, 2, arg0, arg1); - -} -PFNGLVERTEXATTRIBI4UBVPROC glad_debug_glVertexAttribI4ubv = glad_debug_impl_glVertexAttribI4ubv; PFNGLPOINTPARAMETERIVPROC glad_glPointParameteriv; -void APIENTRY glad_debug_impl_glPointParameteriv(GLenum arg0, const GLint * arg1) { - _pre_call_callback("glPointParameteriv", (void*)glPointParameteriv, 2, arg0, arg1); - glad_glPointParameteriv(arg0, arg1); - _post_call_callback("glPointParameteriv", (void*)glPointParameteriv, 2, arg0, arg1); - -} -PFNGLPOINTPARAMETERIVPROC glad_debug_glPointParameteriv = glad_debug_impl_glPointParameteriv; PFNGLENABLEPROC glad_glEnable; -void APIENTRY glad_debug_impl_glEnable(GLenum arg0) { - _pre_call_callback("glEnable", (void*)glEnable, 1, arg0); - glad_glEnable(arg0); - _post_call_callback("glEnable", (void*)glEnable, 1, arg0); - -} -PFNGLENABLEPROC glad_debug_glEnable = glad_debug_impl_glEnable; PFNGLGETACTIVEUNIFORMSIVPROC glad_glGetActiveUniformsiv; -void APIENTRY glad_debug_impl_glGetActiveUniformsiv(GLuint arg0, GLsizei arg1, const GLuint * arg2, GLenum arg3, GLint * arg4) { - _pre_call_callback("glGetActiveUniformsiv", (void*)glGetActiveUniformsiv, 5, arg0, arg1, arg2, arg3, arg4); - glad_glGetActiveUniformsiv(arg0, arg1, arg2, arg3, arg4); - _post_call_callback("glGetActiveUniformsiv", (void*)glGetActiveUniformsiv, 5, arg0, arg1, arg2, arg3, arg4); - -} -PFNGLGETACTIVEUNIFORMSIVPROC glad_debug_glGetActiveUniformsiv = glad_debug_impl_glGetActiveUniformsiv; PFNGLGETATTRIBLOCATIONPROC glad_glGetAttribLocation; -GLint APIENTRY glad_debug_impl_glGetAttribLocation(GLuint arg0, const GLchar * arg1) { - GLint ret; - _pre_call_callback("glGetAttribLocation", (void*)glGetAttribLocation, 2, arg0, arg1); - ret = glad_glGetAttribLocation(arg0, arg1); - _post_call_callback("glGetAttribLocation", (void*)glGetAttribLocation, 2, arg0, arg1); - return ret; -} -PFNGLGETATTRIBLOCATIONPROC glad_debug_glGetAttribLocation = glad_debug_impl_glGetAttribLocation; PFNGLVERTEXATTRIB4DVPROC glad_glVertexAttrib4dv; -void APIENTRY glad_debug_impl_glVertexAttrib4dv(GLuint arg0, const GLdouble * arg1) { - _pre_call_callback("glVertexAttrib4dv", (void*)glVertexAttrib4dv, 2, arg0, arg1); - glad_glVertexAttrib4dv(arg0, arg1); - _post_call_callback("glVertexAttrib4dv", (void*)glVertexAttrib4dv, 2, arg0, arg1); - -} -PFNGLVERTEXATTRIB4DVPROC glad_debug_glVertexAttrib4dv = glad_debug_impl_glVertexAttrib4dv; PFNGLMULTITEXCOORDP3UIVPROC glad_glMultiTexCoordP3uiv; -void APIENTRY glad_debug_impl_glMultiTexCoordP3uiv(GLenum arg0, GLenum arg1, const GLuint * arg2) { - _pre_call_callback("glMultiTexCoordP3uiv", (void*)glMultiTexCoordP3uiv, 3, arg0, arg1, arg2); - glad_glMultiTexCoordP3uiv(arg0, arg1, arg2); - _post_call_callback("glMultiTexCoordP3uiv", (void*)glMultiTexCoordP3uiv, 3, arg0, arg1, arg2); - -} -PFNGLMULTITEXCOORDP3UIVPROC glad_debug_glMultiTexCoordP3uiv = glad_debug_impl_glMultiTexCoordP3uiv; PFNGLVERTEXATTRIBP3UIPROC glad_glVertexAttribP3ui; -void APIENTRY glad_debug_impl_glVertexAttribP3ui(GLuint arg0, GLenum arg1, GLboolean arg2, GLuint arg3) { - _pre_call_callback("glVertexAttribP3ui", (void*)glVertexAttribP3ui, 4, arg0, arg1, arg2, arg3); - glad_glVertexAttribP3ui(arg0, arg1, arg2, arg3); - _post_call_callback("glVertexAttribP3ui", (void*)glVertexAttribP3ui, 4, arg0, arg1, arg2, arg3); - -} -PFNGLVERTEXATTRIBP3UIPROC glad_debug_glVertexAttribP3ui = glad_debug_impl_glVertexAttribP3ui; PFNGLGETUNIFORMFVPROC glad_glGetUniformfv; -void APIENTRY glad_debug_impl_glGetUniformfv(GLuint arg0, GLint arg1, GLfloat * arg2) { - _pre_call_callback("glGetUniformfv", (void*)glGetUniformfv, 3, arg0, arg1, arg2); - glad_glGetUniformfv(arg0, arg1, arg2); - _post_call_callback("glGetUniformfv", (void*)glGetUniformfv, 3, arg0, arg1, arg2); - -} -PFNGLGETUNIFORMFVPROC glad_debug_glGetUniformfv = glad_debug_impl_glGetUniformfv; PFNGLGETUNIFORMUIVPROC glad_glGetUniformuiv; -void APIENTRY glad_debug_impl_glGetUniformuiv(GLuint arg0, GLint arg1, GLuint * arg2) { - _pre_call_callback("glGetUniformuiv", (void*)glGetUniformuiv, 3, arg0, arg1, arg2); - glad_glGetUniformuiv(arg0, arg1, arg2); - _post_call_callback("glGetUniformuiv", (void*)glGetUniformuiv, 3, arg0, arg1, arg2); - -} -PFNGLGETUNIFORMUIVPROC glad_debug_glGetUniformuiv = glad_debug_impl_glGetUniformuiv; PFNGLGETVERTEXATTRIBIIVPROC glad_glGetVertexAttribIiv; -void APIENTRY glad_debug_impl_glGetVertexAttribIiv(GLuint arg0, GLenum arg1, GLint * arg2) { - _pre_call_callback("glGetVertexAttribIiv", (void*)glGetVertexAttribIiv, 3, arg0, arg1, arg2); - glad_glGetVertexAttribIiv(arg0, arg1, arg2); - _post_call_callback("glGetVertexAttribIiv", (void*)glGetVertexAttribIiv, 3, arg0, arg1, arg2); - -} -PFNGLGETVERTEXATTRIBIIVPROC glad_debug_glGetVertexAttribIiv = glad_debug_impl_glGetVertexAttribIiv; PFNGLDRAWBUFFERPROC glad_glDrawBuffer; -void APIENTRY glad_debug_impl_glDrawBuffer(GLenum arg0) { - _pre_call_callback("glDrawBuffer", (void*)glDrawBuffer, 1, arg0); - glad_glDrawBuffer(arg0); - _post_call_callback("glDrawBuffer", (void*)glDrawBuffer, 1, arg0); - -} -PFNGLDRAWBUFFERPROC glad_debug_glDrawBuffer = glad_debug_impl_glDrawBuffer; PFNGLCLEARBUFFERUIVPROC glad_glClearBufferuiv; -void APIENTRY glad_debug_impl_glClearBufferuiv(GLenum arg0, GLint arg1, const GLuint * arg2) { - _pre_call_callback("glClearBufferuiv", (void*)glClearBufferuiv, 3, arg0, arg1, arg2); - glad_glClearBufferuiv(arg0, arg1, arg2); - _post_call_callback("glClearBufferuiv", (void*)glClearBufferuiv, 3, arg0, arg1, arg2); - -} -PFNGLCLEARBUFFERUIVPROC glad_debug_glClearBufferuiv = glad_debug_impl_glClearBufferuiv; PFNGLDRAWELEMENTSINSTANCEDPROC glad_glDrawElementsInstanced; -void APIENTRY glad_debug_impl_glDrawElementsInstanced(GLenum arg0, GLsizei arg1, GLenum arg2, const void * arg3, GLsizei arg4) { - _pre_call_callback("glDrawElementsInstanced", (void*)glDrawElementsInstanced, 5, arg0, arg1, arg2, arg3, arg4); - glad_glDrawElementsInstanced(arg0, arg1, arg2, arg3, arg4); - _post_call_callback("glDrawElementsInstanced", (void*)glDrawElementsInstanced, 5, arg0, arg1, arg2, arg3, arg4); - -} -PFNGLDRAWELEMENTSINSTANCEDPROC glad_debug_glDrawElementsInstanced = glad_debug_impl_glDrawElementsInstanced; PFNGLFLUSHPROC glad_glFlush; -void APIENTRY glad_debug_impl_glFlush() { - _pre_call_callback("glFlush", (void*)glFlush, 0); - glad_glFlush(); - _post_call_callback("glFlush", (void*)glFlush, 0); - -} -PFNGLFLUSHPROC glad_debug_glFlush = glad_debug_impl_glFlush; PFNGLGETRENDERBUFFERPARAMETERIVPROC glad_glGetRenderbufferParameteriv; -void APIENTRY glad_debug_impl_glGetRenderbufferParameteriv(GLenum arg0, GLenum arg1, GLint * arg2) { - _pre_call_callback("glGetRenderbufferParameteriv", (void*)glGetRenderbufferParameteriv, 3, arg0, arg1, arg2); - glad_glGetRenderbufferParameteriv(arg0, arg1, arg2); - _post_call_callback("glGetRenderbufferParameteriv", (void*)glGetRenderbufferParameteriv, 3, arg0, arg1, arg2); - -} -PFNGLGETRENDERBUFFERPARAMETERIVPROC glad_debug_glGetRenderbufferParameteriv = glad_debug_impl_glGetRenderbufferParameteriv; PFNGLGETVERTEXATTRIBPOINTERVPROC glad_glGetVertexAttribPointerv; -void APIENTRY glad_debug_impl_glGetVertexAttribPointerv(GLuint arg0, GLenum arg1, void ** arg2) { - _pre_call_callback("glGetVertexAttribPointerv", (void*)glGetVertexAttribPointerv, 3, arg0, arg1, arg2); - glad_glGetVertexAttribPointerv(arg0, arg1, arg2); - _post_call_callback("glGetVertexAttribPointerv", (void*)glGetVertexAttribPointerv, 3, arg0, arg1, arg2); - -} -PFNGLGETVERTEXATTRIBPOINTERVPROC glad_debug_glGetVertexAttribPointerv = glad_debug_impl_glGetVertexAttribPointerv; PFNGLFENCESYNCPROC glad_glFenceSync; -GLsync APIENTRY glad_debug_impl_glFenceSync(GLenum arg0, GLbitfield arg1) { - GLsync ret; - _pre_call_callback("glFenceSync", (void*)glFenceSync, 2, arg0, arg1); - ret = glad_glFenceSync(arg0, arg1); - _post_call_callback("glFenceSync", (void*)glFenceSync, 2, arg0, arg1); - return ret; -} -PFNGLFENCESYNCPROC glad_debug_glFenceSync = glad_debug_impl_glFenceSync; PFNGLCOLORP3UIPROC glad_glColorP3ui; -void APIENTRY glad_debug_impl_glColorP3ui(GLenum arg0, GLuint arg1) { - _pre_call_callback("glColorP3ui", (void*)glColorP3ui, 2, arg0, arg1); - glad_glColorP3ui(arg0, arg1); - _post_call_callback("glColorP3ui", (void*)glColorP3ui, 2, arg0, arg1); - -} -PFNGLCOLORP3UIPROC glad_debug_glColorP3ui = glad_debug_impl_glColorP3ui; PFNGLVERTEXATTRIB3SVPROC glad_glVertexAttrib3sv; -void APIENTRY glad_debug_impl_glVertexAttrib3sv(GLuint arg0, const GLshort * arg1) { - _pre_call_callback("glVertexAttrib3sv", (void*)glVertexAttrib3sv, 2, arg0, arg1); - glad_glVertexAttrib3sv(arg0, arg1); - _post_call_callback("glVertexAttrib3sv", (void*)glVertexAttrib3sv, 2, arg0, arg1); - -} -PFNGLVERTEXATTRIB3SVPROC glad_debug_glVertexAttrib3sv = glad_debug_impl_glVertexAttrib3sv; PFNGLBEGINCONDITIONALRENDERPROC glad_glBeginConditionalRender; -void APIENTRY glad_debug_impl_glBeginConditionalRender(GLuint arg0, GLenum arg1) { - _pre_call_callback("glBeginConditionalRender", (void*)glBeginConditionalRender, 2, arg0, arg1); - glad_glBeginConditionalRender(arg0, arg1); - _post_call_callback("glBeginConditionalRender", (void*)glBeginConditionalRender, 2, arg0, arg1); - -} -PFNGLBEGINCONDITIONALRENDERPROC glad_debug_glBeginConditionalRender = glad_debug_impl_glBeginConditionalRender; PFNGLGETTEXLEVELPARAMETERIVPROC glad_glGetTexLevelParameteriv; -void APIENTRY glad_debug_impl_glGetTexLevelParameteriv(GLenum arg0, GLint arg1, GLenum arg2, GLint * arg3) { - _pre_call_callback("glGetTexLevelParameteriv", (void*)glGetTexLevelParameteriv, 4, arg0, arg1, arg2, arg3); - glad_glGetTexLevelParameteriv(arg0, arg1, arg2, arg3); - _post_call_callback("glGetTexLevelParameteriv", (void*)glGetTexLevelParameteriv, 4, arg0, arg1, arg2, arg3); - -} -PFNGLGETTEXLEVELPARAMETERIVPROC glad_debug_glGetTexLevelParameteriv = glad_debug_impl_glGetTexLevelParameteriv; PFNGLMULTITEXCOORDP4UIVPROC glad_glMultiTexCoordP4uiv; -void APIENTRY glad_debug_impl_glMultiTexCoordP4uiv(GLenum arg0, GLenum arg1, const GLuint * arg2) { - _pre_call_callback("glMultiTexCoordP4uiv", (void*)glMultiTexCoordP4uiv, 3, arg0, arg1, arg2); - glad_glMultiTexCoordP4uiv(arg0, arg1, arg2); - _post_call_callback("glMultiTexCoordP4uiv", (void*)glMultiTexCoordP4uiv, 3, arg0, arg1, arg2); - -} -PFNGLMULTITEXCOORDP4UIVPROC glad_debug_glMultiTexCoordP4uiv = glad_debug_impl_glMultiTexCoordP4uiv; PFNGLSTENCILFUNCSEPARATEPROC glad_glStencilFuncSeparate; -void APIENTRY glad_debug_impl_glStencilFuncSeparate(GLenum arg0, GLenum arg1, GLint arg2, GLuint arg3) { - _pre_call_callback("glStencilFuncSeparate", (void*)glStencilFuncSeparate, 4, arg0, arg1, arg2, arg3); - glad_glStencilFuncSeparate(arg0, arg1, arg2, arg3); - _post_call_callback("glStencilFuncSeparate", (void*)glStencilFuncSeparate, 4, arg0, arg1, arg2, arg3); - -} -PFNGLSTENCILFUNCSEPARATEPROC glad_debug_glStencilFuncSeparate = glad_debug_impl_glStencilFuncSeparate; PFNGLGENSAMPLERSPROC glad_glGenSamplers; -void APIENTRY glad_debug_impl_glGenSamplers(GLsizei arg0, GLuint * arg1) { - _pre_call_callback("glGenSamplers", (void*)glGenSamplers, 2, arg0, arg1); - glad_glGenSamplers(arg0, arg1); - _post_call_callback("glGenSamplers", (void*)glGenSamplers, 2, arg0, arg1); - -} -PFNGLGENSAMPLERSPROC glad_debug_glGenSamplers = glad_debug_impl_glGenSamplers; PFNGLCLAMPCOLORPROC glad_glClampColor; -void APIENTRY glad_debug_impl_glClampColor(GLenum arg0, GLenum arg1) { - _pre_call_callback("glClampColor", (void*)glClampColor, 2, arg0, arg1); - glad_glClampColor(arg0, arg1); - _post_call_callback("glClampColor", (void*)glClampColor, 2, arg0, arg1); - -} -PFNGLCLAMPCOLORPROC glad_debug_glClampColor = glad_debug_impl_glClampColor; PFNGLUNIFORM4IVPROC glad_glUniform4iv; -void APIENTRY glad_debug_impl_glUniform4iv(GLint arg0, GLsizei arg1, const GLint * arg2) { - _pre_call_callback("glUniform4iv", (void*)glUniform4iv, 3, arg0, arg1, arg2); - glad_glUniform4iv(arg0, arg1, arg2); - _post_call_callback("glUniform4iv", (void*)glUniform4iv, 3, arg0, arg1, arg2); - -} -PFNGLUNIFORM4IVPROC glad_debug_glUniform4iv = glad_debug_impl_glUniform4iv; PFNGLCLEARSTENCILPROC glad_glClearStencil; -void APIENTRY glad_debug_impl_glClearStencil(GLint arg0) { - _pre_call_callback("glClearStencil", (void*)glClearStencil, 1, arg0); - glad_glClearStencil(arg0); - _post_call_callback("glClearStencil", (void*)glClearStencil, 1, arg0); - -} -PFNGLCLEARSTENCILPROC glad_debug_glClearStencil = glad_debug_impl_glClearStencil; PFNGLTEXCOORDP1UIVPROC glad_glTexCoordP1uiv; -void APIENTRY glad_debug_impl_glTexCoordP1uiv(GLenum arg0, const GLuint * arg1) { - _pre_call_callback("glTexCoordP1uiv", (void*)glTexCoordP1uiv, 2, arg0, arg1); - glad_glTexCoordP1uiv(arg0, arg1); - _post_call_callback("glTexCoordP1uiv", (void*)glTexCoordP1uiv, 2, arg0, arg1); - -} -PFNGLTEXCOORDP1UIVPROC glad_debug_glTexCoordP1uiv = glad_debug_impl_glTexCoordP1uiv; PFNGLGENTEXTURESPROC glad_glGenTextures; -void APIENTRY glad_debug_impl_glGenTextures(GLsizei arg0, GLuint * arg1) { - _pre_call_callback("glGenTextures", (void*)glGenTextures, 2, arg0, arg1); - glad_glGenTextures(arg0, arg1); - _post_call_callback("glGenTextures", (void*)glGenTextures, 2, arg0, arg1); - -} -PFNGLGENTEXTURESPROC glad_debug_glGenTextures = glad_debug_impl_glGenTextures; PFNGLGETTEXPARAMETERIUIVPROC glad_glGetTexParameterIuiv; -void APIENTRY glad_debug_impl_glGetTexParameterIuiv(GLenum arg0, GLenum arg1, GLuint * arg2) { - _pre_call_callback("glGetTexParameterIuiv", (void*)glGetTexParameterIuiv, 3, arg0, arg1, arg2); - glad_glGetTexParameterIuiv(arg0, arg1, arg2); - _post_call_callback("glGetTexParameterIuiv", (void*)glGetTexParameterIuiv, 3, arg0, arg1, arg2); - -} -PFNGLGETTEXPARAMETERIUIVPROC glad_debug_glGetTexParameterIuiv = glad_debug_impl_glGetTexParameterIuiv; PFNGLVERTEXATTRIB4NBVPROC glad_glVertexAttrib4Nbv; -void APIENTRY glad_debug_impl_glVertexAttrib4Nbv(GLuint arg0, const GLbyte * arg1) { - _pre_call_callback("glVertexAttrib4Nbv", (void*)glVertexAttrib4Nbv, 2, arg0, arg1); - glad_glVertexAttrib4Nbv(arg0, arg1); - _post_call_callback("glVertexAttrib4Nbv", (void*)glVertexAttrib4Nbv, 2, arg0, arg1); - -} -PFNGLVERTEXATTRIB4NBVPROC glad_debug_glVertexAttrib4Nbv = glad_debug_impl_glVertexAttrib4Nbv; PFNGLISSYNCPROC glad_glIsSync; -GLboolean APIENTRY glad_debug_impl_glIsSync(GLsync arg0) { - GLboolean ret; - _pre_call_callback("glIsSync", (void*)glIsSync, 1, arg0); - ret = glad_glIsSync(arg0); - _post_call_callback("glIsSync", (void*)glIsSync, 1, arg0); - return ret; -} -PFNGLISSYNCPROC glad_debug_glIsSync = glad_debug_impl_glIsSync; PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC glad_glGetActiveUniformBlockName; -void APIENTRY glad_debug_impl_glGetActiveUniformBlockName(GLuint arg0, GLuint arg1, GLsizei arg2, GLsizei * arg3, GLchar * arg4) { - _pre_call_callback("glGetActiveUniformBlockName", (void*)glGetActiveUniformBlockName, 5, arg0, arg1, arg2, arg3, arg4); - glad_glGetActiveUniformBlockName(arg0, arg1, arg2, arg3, arg4); - _post_call_callback("glGetActiveUniformBlockName", (void*)glGetActiveUniformBlockName, 5, arg0, arg1, arg2, arg3, arg4); - -} -PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC glad_debug_glGetActiveUniformBlockName = glad_debug_impl_glGetActiveUniformBlockName; PFNGLUNIFORM2IPROC glad_glUniform2i; -void APIENTRY glad_debug_impl_glUniform2i(GLint arg0, GLint arg1, GLint arg2) { - _pre_call_callback("glUniform2i", (void*)glUniform2i, 3, arg0, arg1, arg2); - glad_glUniform2i(arg0, arg1, arg2); - _post_call_callback("glUniform2i", (void*)glUniform2i, 3, arg0, arg1, arg2); - -} -PFNGLUNIFORM2IPROC glad_debug_glUniform2i = glad_debug_impl_glUniform2i; PFNGLUNIFORM2FPROC glad_glUniform2f; -void APIENTRY glad_debug_impl_glUniform2f(GLint arg0, GLfloat arg1, GLfloat arg2) { - _pre_call_callback("glUniform2f", (void*)glUniform2f, 3, arg0, arg1, arg2); - glad_glUniform2f(arg0, arg1, arg2); - _post_call_callback("glUniform2f", (void*)glUniform2f, 3, arg0, arg1, arg2); - -} -PFNGLUNIFORM2FPROC glad_debug_glUniform2f = glad_debug_impl_glUniform2f; PFNGLTEXCOORDP4UIPROC glad_glTexCoordP4ui; -void APIENTRY glad_debug_impl_glTexCoordP4ui(GLenum arg0, GLuint arg1) { - _pre_call_callback("glTexCoordP4ui", (void*)glTexCoordP4ui, 2, arg0, arg1); - glad_glTexCoordP4ui(arg0, arg1); - _post_call_callback("glTexCoordP4ui", (void*)glTexCoordP4ui, 2, arg0, arg1); - -} -PFNGLTEXCOORDP4UIPROC glad_debug_glTexCoordP4ui = glad_debug_impl_glTexCoordP4ui; PFNGLGETPROGRAMIVPROC glad_glGetProgramiv; -void APIENTRY glad_debug_impl_glGetProgramiv(GLuint arg0, GLenum arg1, GLint * arg2) { - _pre_call_callback("glGetProgramiv", (void*)glGetProgramiv, 3, arg0, arg1, arg2); - glad_glGetProgramiv(arg0, arg1, arg2); - _post_call_callback("glGetProgramiv", (void*)glGetProgramiv, 3, arg0, arg1, arg2); - -} -PFNGLGETPROGRAMIVPROC glad_debug_glGetProgramiv = glad_debug_impl_glGetProgramiv; PFNGLVERTEXATTRIBPOINTERPROC glad_glVertexAttribPointer; -void APIENTRY glad_debug_impl_glVertexAttribPointer(GLuint arg0, GLint arg1, GLenum arg2, GLboolean arg3, GLsizei arg4, const void * arg5) { - _pre_call_callback("glVertexAttribPointer", (void*)glVertexAttribPointer, 6, arg0, arg1, arg2, arg3, arg4, arg5); - glad_glVertexAttribPointer(arg0, arg1, arg2, arg3, arg4, arg5); - _post_call_callback("glVertexAttribPointer", (void*)glVertexAttribPointer, 6, arg0, arg1, arg2, arg3, arg4, arg5); - -} -PFNGLVERTEXATTRIBPOINTERPROC glad_debug_glVertexAttribPointer = glad_debug_impl_glVertexAttribPointer; PFNGLFRAMEBUFFERTEXTURELAYERPROC glad_glFramebufferTextureLayer; -void APIENTRY glad_debug_impl_glFramebufferTextureLayer(GLenum arg0, GLenum arg1, GLuint arg2, GLint arg3, GLint arg4) { - _pre_call_callback("glFramebufferTextureLayer", (void*)glFramebufferTextureLayer, 5, arg0, arg1, arg2, arg3, arg4); - glad_glFramebufferTextureLayer(arg0, arg1, arg2, arg3, arg4); - _post_call_callback("glFramebufferTextureLayer", (void*)glFramebufferTextureLayer, 5, arg0, arg1, arg2, arg3, arg4); - -} -PFNGLFRAMEBUFFERTEXTURELAYERPROC glad_debug_glFramebufferTextureLayer = glad_debug_impl_glFramebufferTextureLayer; PFNGLFLUSHMAPPEDBUFFERRANGEPROC glad_glFlushMappedBufferRange; -void APIENTRY glad_debug_impl_glFlushMappedBufferRange(GLenum arg0, GLintptr arg1, GLsizeiptr arg2) { - _pre_call_callback("glFlushMappedBufferRange", (void*)glFlushMappedBufferRange, 3, arg0, arg1, arg2); - glad_glFlushMappedBufferRange(arg0, arg1, arg2); - _post_call_callback("glFlushMappedBufferRange", (void*)glFlushMappedBufferRange, 3, arg0, arg1, arg2); - -} -PFNGLFLUSHMAPPEDBUFFERRANGEPROC glad_debug_glFlushMappedBufferRange = glad_debug_impl_glFlushMappedBufferRange; PFNGLGENQUERIESPROC glad_glGenQueries; -void APIENTRY glad_debug_impl_glGenQueries(GLsizei arg0, GLuint * arg1) { - _pre_call_callback("glGenQueries", (void*)glGenQueries, 2, arg0, arg1); - glad_glGenQueries(arg0, arg1); - _post_call_callback("glGenQueries", (void*)glGenQueries, 2, arg0, arg1); - -} -PFNGLGENQUERIESPROC glad_debug_glGenQueries = glad_debug_impl_glGenQueries; PFNGLVERTEXATTRIBP1UIPROC glad_glVertexAttribP1ui; -void APIENTRY glad_debug_impl_glVertexAttribP1ui(GLuint arg0, GLenum arg1, GLboolean arg2, GLuint arg3) { - _pre_call_callback("glVertexAttribP1ui", (void*)glVertexAttribP1ui, 4, arg0, arg1, arg2, arg3); - glad_glVertexAttribP1ui(arg0, arg1, arg2, arg3); - _post_call_callback("glVertexAttribP1ui", (void*)glVertexAttribP1ui, 4, arg0, arg1, arg2, arg3); - -} -PFNGLVERTEXATTRIBP1UIPROC glad_debug_glVertexAttribP1ui = glad_debug_impl_glVertexAttribP1ui; PFNGLTEXSUBIMAGE3DPROC glad_glTexSubImage3D; -void APIENTRY glad_debug_impl_glTexSubImage3D(GLenum arg0, GLint arg1, GLint arg2, GLint arg3, GLint arg4, GLsizei arg5, GLsizei arg6, GLsizei arg7, GLenum arg8, GLenum arg9, const void * arg10) { - _pre_call_callback("glTexSubImage3D", (void*)glTexSubImage3D, 11, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10); - glad_glTexSubImage3D(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10); - _post_call_callback("glTexSubImage3D", (void*)glTexSubImage3D, 11, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10); - -} -PFNGLTEXSUBIMAGE3DPROC glad_debug_glTexSubImage3D = glad_debug_impl_glTexSubImage3D; PFNGLGETINTEGER64I_VPROC glad_glGetInteger64i_v; -void APIENTRY glad_debug_impl_glGetInteger64i_v(GLenum arg0, GLuint arg1, GLint64 * arg2) { - _pre_call_callback("glGetInteger64i_v", (void*)glGetInteger64i_v, 3, arg0, arg1, arg2); - glad_glGetInteger64i_v(arg0, arg1, arg2); - _post_call_callback("glGetInteger64i_v", (void*)glGetInteger64i_v, 3, arg0, arg1, arg2); - -} -PFNGLGETINTEGER64I_VPROC glad_debug_glGetInteger64i_v = glad_debug_impl_glGetInteger64i_v; PFNGLDELETESAMPLERSPROC glad_glDeleteSamplers; -void APIENTRY glad_debug_impl_glDeleteSamplers(GLsizei arg0, const GLuint * arg1) { - _pre_call_callback("glDeleteSamplers", (void*)glDeleteSamplers, 2, arg0, arg1); - glad_glDeleteSamplers(arg0, arg1); - _post_call_callback("glDeleteSamplers", (void*)glDeleteSamplers, 2, arg0, arg1); - -} -PFNGLDELETESAMPLERSPROC glad_debug_glDeleteSamplers = glad_debug_impl_glDeleteSamplers; PFNGLCOPYTEXIMAGE2DPROC glad_glCopyTexImage2D; -void APIENTRY glad_debug_impl_glCopyTexImage2D(GLenum arg0, GLint arg1, GLenum arg2, GLint arg3, GLint arg4, GLsizei arg5, GLsizei arg6, GLint arg7) { - _pre_call_callback("glCopyTexImage2D", (void*)glCopyTexImage2D, 8, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7); - glad_glCopyTexImage2D(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7); - _post_call_callback("glCopyTexImage2D", (void*)glCopyTexImage2D, 8, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7); - -} -PFNGLCOPYTEXIMAGE2DPROC glad_debug_glCopyTexImage2D = glad_debug_impl_glCopyTexImage2D; PFNGLBLITFRAMEBUFFERPROC glad_glBlitFramebuffer; -void APIENTRY glad_debug_impl_glBlitFramebuffer(GLint arg0, GLint arg1, GLint arg2, GLint arg3, GLint arg4, GLint arg5, GLint arg6, GLint arg7, GLbitfield arg8, GLenum arg9) { - _pre_call_callback("glBlitFramebuffer", (void*)glBlitFramebuffer, 10, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9); - glad_glBlitFramebuffer(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9); - _post_call_callback("glBlitFramebuffer", (void*)glBlitFramebuffer, 10, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9); - -} -PFNGLBLITFRAMEBUFFERPROC glad_debug_glBlitFramebuffer = glad_debug_impl_glBlitFramebuffer; PFNGLISENABLEDIPROC glad_glIsEnabledi; -GLboolean APIENTRY glad_debug_impl_glIsEnabledi(GLenum arg0, GLuint arg1) { - GLboolean ret; - _pre_call_callback("glIsEnabledi", (void*)glIsEnabledi, 2, arg0, arg1); - ret = glad_glIsEnabledi(arg0, arg1); - _post_call_callback("glIsEnabledi", (void*)glIsEnabledi, 2, arg0, arg1); - return ret; -} -PFNGLISENABLEDIPROC glad_debug_glIsEnabledi = glad_debug_impl_glIsEnabledi; PFNGLSECONDARYCOLORP3UIPROC glad_glSecondaryColorP3ui; -void APIENTRY glad_debug_impl_glSecondaryColorP3ui(GLenum arg0, GLuint arg1) { - _pre_call_callback("glSecondaryColorP3ui", (void*)glSecondaryColorP3ui, 2, arg0, arg1); - glad_glSecondaryColorP3ui(arg0, arg1); - _post_call_callback("glSecondaryColorP3ui", (void*)glSecondaryColorP3ui, 2, arg0, arg1); - -} -PFNGLSECONDARYCOLORP3UIPROC glad_debug_glSecondaryColorP3ui = glad_debug_impl_glSecondaryColorP3ui; PFNGLBINDFRAGDATALOCATIONINDEXEDPROC glad_glBindFragDataLocationIndexed; -void APIENTRY glad_debug_impl_glBindFragDataLocationIndexed(GLuint arg0, GLuint arg1, GLuint arg2, const GLchar * arg3) { - _pre_call_callback("glBindFragDataLocationIndexed", (void*)glBindFragDataLocationIndexed, 4, arg0, arg1, arg2, arg3); - glad_glBindFragDataLocationIndexed(arg0, arg1, arg2, arg3); - _post_call_callback("glBindFragDataLocationIndexed", (void*)glBindFragDataLocationIndexed, 4, arg0, arg1, arg2, arg3); - -} -PFNGLBINDFRAGDATALOCATIONINDEXEDPROC glad_debug_glBindFragDataLocationIndexed = glad_debug_impl_glBindFragDataLocationIndexed; PFNGLUNIFORM2IVPROC glad_glUniform2iv; -void APIENTRY glad_debug_impl_glUniform2iv(GLint arg0, GLsizei arg1, const GLint * arg2) { - _pre_call_callback("glUniform2iv", (void*)glUniform2iv, 3, arg0, arg1, arg2); - glad_glUniform2iv(arg0, arg1, arg2); - _post_call_callback("glUniform2iv", (void*)glUniform2iv, 3, arg0, arg1, arg2); - -} -PFNGLUNIFORM2IVPROC glad_debug_glUniform2iv = glad_debug_impl_glUniform2iv; PFNGLVERTEXATTRIB1FVPROC glad_glVertexAttrib1fv; -void APIENTRY glad_debug_impl_glVertexAttrib1fv(GLuint arg0, const GLfloat * arg1) { - _pre_call_callback("glVertexAttrib1fv", (void*)glVertexAttrib1fv, 2, arg0, arg1); - glad_glVertexAttrib1fv(arg0, arg1); - _post_call_callback("glVertexAttrib1fv", (void*)glVertexAttrib1fv, 2, arg0, arg1); - -} -PFNGLVERTEXATTRIB1FVPROC glad_debug_glVertexAttrib1fv = glad_debug_impl_glVertexAttrib1fv; PFNGLUNIFORM4UIVPROC glad_glUniform4uiv; -void APIENTRY glad_debug_impl_glUniform4uiv(GLint arg0, GLsizei arg1, const GLuint * arg2) { - _pre_call_callback("glUniform4uiv", (void*)glUniform4uiv, 3, arg0, arg1, arg2); - glad_glUniform4uiv(arg0, arg1, arg2); - _post_call_callback("glUniform4uiv", (void*)glUniform4uiv, 3, arg0, arg1, arg2); - -} -PFNGLUNIFORM4UIVPROC glad_debug_glUniform4uiv = glad_debug_impl_glUniform4uiv; PFNGLFRAMEBUFFERTEXTURE1DPROC glad_glFramebufferTexture1D; -void APIENTRY glad_debug_impl_glFramebufferTexture1D(GLenum arg0, GLenum arg1, GLenum arg2, GLuint arg3, GLint arg4) { - _pre_call_callback("glFramebufferTexture1D", (void*)glFramebufferTexture1D, 5, arg0, arg1, arg2, arg3, arg4); - glad_glFramebufferTexture1D(arg0, arg1, arg2, arg3, arg4); - _post_call_callback("glFramebufferTexture1D", (void*)glFramebufferTexture1D, 5, arg0, arg1, arg2, arg3, arg4); - -} -PFNGLFRAMEBUFFERTEXTURE1DPROC glad_debug_glFramebufferTexture1D = glad_debug_impl_glFramebufferTexture1D; PFNGLGETSHADERIVPROC glad_glGetShaderiv; -void APIENTRY glad_debug_impl_glGetShaderiv(GLuint arg0, GLenum arg1, GLint * arg2) { - _pre_call_callback("glGetShaderiv", (void*)glGetShaderiv, 3, arg0, arg1, arg2); - glad_glGetShaderiv(arg0, arg1, arg2); - _post_call_callback("glGetShaderiv", (void*)glGetShaderiv, 3, arg0, arg1, arg2); - -} -PFNGLGETSHADERIVPROC glad_debug_glGetShaderiv = glad_debug_impl_glGetShaderiv; PFNGLBINDFRAGDATALOCATIONPROC glad_glBindFragDataLocation; -void APIENTRY glad_debug_impl_glBindFragDataLocation(GLuint arg0, GLuint arg1, const GLchar * arg2) { - _pre_call_callback("glBindFragDataLocation", (void*)glBindFragDataLocation, 3, arg0, arg1, arg2); - glad_glBindFragDataLocation(arg0, arg1, arg2); - _post_call_callback("glBindFragDataLocation", (void*)glBindFragDataLocation, 3, arg0, arg1, arg2); - -} -PFNGLBINDFRAGDATALOCATIONPROC glad_debug_glBindFragDataLocation = glad_debug_impl_glBindFragDataLocation; PFNGLPOLYGONOFFSETPROC glad_glPolygonOffset; -void APIENTRY glad_debug_impl_glPolygonOffset(GLfloat arg0, GLfloat arg1) { - _pre_call_callback("glPolygonOffset", (void*)glPolygonOffset, 2, arg0, arg1); - glad_glPolygonOffset(arg0, arg1); - _post_call_callback("glPolygonOffset", (void*)glPolygonOffset, 2, arg0, arg1); - -} -PFNGLPOLYGONOFFSETPROC glad_debug_glPolygonOffset = glad_debug_impl_glPolygonOffset; PFNGLGETDOUBLEVPROC glad_glGetDoublev; -void APIENTRY glad_debug_impl_glGetDoublev(GLenum arg0, GLdouble * arg1) { - _pre_call_callback("glGetDoublev", (void*)glGetDoublev, 2, arg0, arg1); - glad_glGetDoublev(arg0, arg1); - _post_call_callback("glGetDoublev", (void*)glGetDoublev, 2, arg0, arg1); - -} -PFNGLGETDOUBLEVPROC glad_debug_glGetDoublev = glad_debug_impl_glGetDoublev; PFNGLVERTEXATTRIB1DPROC glad_glVertexAttrib1d; -void APIENTRY glad_debug_impl_glVertexAttrib1d(GLuint arg0, GLdouble arg1) { - _pre_call_callback("glVertexAttrib1d", (void*)glVertexAttrib1d, 2, arg0, arg1); - glad_glVertexAttrib1d(arg0, arg1); - _post_call_callback("glVertexAttrib1d", (void*)glVertexAttrib1d, 2, arg0, arg1); - -} -PFNGLVERTEXATTRIB1DPROC glad_debug_glVertexAttrib1d = glad_debug_impl_glVertexAttrib1d; PFNGLGETUNIFORMIVPROC glad_glGetUniformiv; -void APIENTRY glad_debug_impl_glGetUniformiv(GLuint arg0, GLint arg1, GLint * arg2) { - _pre_call_callback("glGetUniformiv", (void*)glGetUniformiv, 3, arg0, arg1, arg2); - glad_glGetUniformiv(arg0, arg1, arg2); - _post_call_callback("glGetUniformiv", (void*)glGetUniformiv, 3, arg0, arg1, arg2); - -} -PFNGLGETUNIFORMIVPROC glad_debug_glGetUniformiv = glad_debug_impl_glGetUniformiv; PFNGLMULTITEXCOORDP1UIVPROC glad_glMultiTexCoordP1uiv; -void APIENTRY glad_debug_impl_glMultiTexCoordP1uiv(GLenum arg0, GLenum arg1, const GLuint * arg2) { - _pre_call_callback("glMultiTexCoordP1uiv", (void*)glMultiTexCoordP1uiv, 3, arg0, arg1, arg2); - glad_glMultiTexCoordP1uiv(arg0, arg1, arg2); - _post_call_callback("glMultiTexCoordP1uiv", (void*)glMultiTexCoordP1uiv, 3, arg0, arg1, arg2); - -} -PFNGLMULTITEXCOORDP1UIVPROC glad_debug_glMultiTexCoordP1uiv = glad_debug_impl_glMultiTexCoordP1uiv; PFNGLUNIFORM3FVPROC glad_glUniform3fv; -void APIENTRY glad_debug_impl_glUniform3fv(GLint arg0, GLsizei arg1, const GLfloat * arg2) { - _pre_call_callback("glUniform3fv", (void*)glUniform3fv, 3, arg0, arg1, arg2); - glad_glUniform3fv(arg0, arg1, arg2); - _post_call_callback("glUniform3fv", (void*)glUniform3fv, 3, arg0, arg1, arg2); - -} -PFNGLUNIFORM3FVPROC glad_debug_glUniform3fv = glad_debug_impl_glUniform3fv; PFNGLDEPTHRANGEPROC glad_glDepthRange; -void APIENTRY glad_debug_impl_glDepthRange(GLdouble arg0, GLdouble arg1) { - _pre_call_callback("glDepthRange", (void*)glDepthRange, 2, arg0, arg1); - glad_glDepthRange(arg0, arg1); - _post_call_callback("glDepthRange", (void*)glDepthRange, 2, arg0, arg1); - -} -PFNGLDEPTHRANGEPROC glad_debug_glDepthRange = glad_debug_impl_glDepthRange; PFNGLMAPBUFFERPROC glad_glMapBuffer; -void * APIENTRY glad_debug_impl_glMapBuffer(GLenum arg0, GLenum arg1) { - void * ret; - _pre_call_callback("glMapBuffer", (void*)glMapBuffer, 2, arg0, arg1); - ret = glad_glMapBuffer(arg0, arg1); - _post_call_callback("glMapBuffer", (void*)glMapBuffer, 2, arg0, arg1); - return ret; -} -PFNGLMAPBUFFERPROC glad_debug_glMapBuffer = glad_debug_impl_glMapBuffer; PFNGLCOMPRESSEDTEXIMAGE3DPROC glad_glCompressedTexImage3D; -void APIENTRY glad_debug_impl_glCompressedTexImage3D(GLenum arg0, GLint arg1, GLenum arg2, GLsizei arg3, GLsizei arg4, GLsizei arg5, GLint arg6, GLsizei arg7, const void * arg8) { - _pre_call_callback("glCompressedTexImage3D", (void*)glCompressedTexImage3D, 9, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8); - glad_glCompressedTexImage3D(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8); - _post_call_callback("glCompressedTexImage3D", (void*)glCompressedTexImage3D, 9, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8); - -} -PFNGLCOMPRESSEDTEXIMAGE3DPROC glad_debug_glCompressedTexImage3D = glad_debug_impl_glCompressedTexImage3D; PFNGLDELETESYNCPROC glad_glDeleteSync; -void APIENTRY glad_debug_impl_glDeleteSync(GLsync arg0) { - _pre_call_callback("glDeleteSync", (void*)glDeleteSync, 1, arg0); - glad_glDeleteSync(arg0); - _post_call_callback("glDeleteSync", (void*)glDeleteSync, 1, arg0); - -} -PFNGLDELETESYNCPROC glad_debug_glDeleteSync = glad_debug_impl_glDeleteSync; PFNGLCOPYTEXSUBIMAGE3DPROC glad_glCopyTexSubImage3D; -void APIENTRY glad_debug_impl_glCopyTexSubImage3D(GLenum arg0, GLint arg1, GLint arg2, GLint arg3, GLint arg4, GLint arg5, GLint arg6, GLsizei arg7, GLsizei arg8) { - _pre_call_callback("glCopyTexSubImage3D", (void*)glCopyTexSubImage3D, 9, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8); - glad_glCopyTexSubImage3D(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8); - _post_call_callback("glCopyTexSubImage3D", (void*)glCopyTexSubImage3D, 9, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8); - -} -PFNGLCOPYTEXSUBIMAGE3DPROC glad_debug_glCopyTexSubImage3D = glad_debug_impl_glCopyTexSubImage3D; PFNGLGETVERTEXATTRIBIVPROC glad_glGetVertexAttribiv; -void APIENTRY glad_debug_impl_glGetVertexAttribiv(GLuint arg0, GLenum arg1, GLint * arg2) { - _pre_call_callback("glGetVertexAttribiv", (void*)glGetVertexAttribiv, 3, arg0, arg1, arg2); - glad_glGetVertexAttribiv(arg0, arg1, arg2); - _post_call_callback("glGetVertexAttribiv", (void*)glGetVertexAttribiv, 3, arg0, arg1, arg2); - -} -PFNGLGETVERTEXATTRIBIVPROC glad_debug_glGetVertexAttribiv = glad_debug_impl_glGetVertexAttribiv; PFNGLMULTIDRAWELEMENTSPROC glad_glMultiDrawElements; -void APIENTRY glad_debug_impl_glMultiDrawElements(GLenum arg0, const GLsizei * arg1, GLenum arg2, const void *const* arg3, GLsizei arg4) { - _pre_call_callback("glMultiDrawElements", (void*)glMultiDrawElements, 5, arg0, arg1, arg2, arg3, arg4); - glad_glMultiDrawElements(arg0, arg1, arg2, arg3, arg4); - _post_call_callback("glMultiDrawElements", (void*)glMultiDrawElements, 5, arg0, arg1, arg2, arg3, arg4); - -} -PFNGLMULTIDRAWELEMENTSPROC glad_debug_glMultiDrawElements = glad_debug_impl_glMultiDrawElements; PFNGLVERTEXATTRIB3FVPROC glad_glVertexAttrib3fv; -void APIENTRY glad_debug_impl_glVertexAttrib3fv(GLuint arg0, const GLfloat * arg1) { - _pre_call_callback("glVertexAttrib3fv", (void*)glVertexAttrib3fv, 2, arg0, arg1); - glad_glVertexAttrib3fv(arg0, arg1); - _post_call_callback("glVertexAttrib3fv", (void*)glVertexAttrib3fv, 2, arg0, arg1); - -} -PFNGLVERTEXATTRIB3FVPROC glad_debug_glVertexAttrib3fv = glad_debug_impl_glVertexAttrib3fv; PFNGLUNIFORM3IVPROC glad_glUniform3iv; -void APIENTRY glad_debug_impl_glUniform3iv(GLint arg0, GLsizei arg1, const GLint * arg2) { - _pre_call_callback("glUniform3iv", (void*)glUniform3iv, 3, arg0, arg1, arg2); - glad_glUniform3iv(arg0, arg1, arg2); - _post_call_callback("glUniform3iv", (void*)glUniform3iv, 3, arg0, arg1, arg2); - -} -PFNGLUNIFORM3IVPROC glad_debug_glUniform3iv = glad_debug_impl_glUniform3iv; PFNGLPOLYGONMODEPROC glad_glPolygonMode; -void APIENTRY glad_debug_impl_glPolygonMode(GLenum arg0, GLenum arg1) { - _pre_call_callback("glPolygonMode", (void*)glPolygonMode, 2, arg0, arg1); - glad_glPolygonMode(arg0, arg1); - _post_call_callback("glPolygonMode", (void*)glPolygonMode, 2, arg0, arg1); - -} -PFNGLPOLYGONMODEPROC glad_debug_glPolygonMode = glad_debug_impl_glPolygonMode; PFNGLDRAWBUFFERSPROC glad_glDrawBuffers; -void APIENTRY glad_debug_impl_glDrawBuffers(GLsizei arg0, const GLenum * arg1) { - _pre_call_callback("glDrawBuffers", (void*)glDrawBuffers, 2, arg0, arg1); - glad_glDrawBuffers(arg0, arg1); - _post_call_callback("glDrawBuffers", (void*)glDrawBuffers, 2, arg0, arg1); - -} -PFNGLDRAWBUFFERSPROC glad_debug_glDrawBuffers = glad_debug_impl_glDrawBuffers; PFNGLGETACTIVEUNIFORMBLOCKIVPROC glad_glGetActiveUniformBlockiv; -void APIENTRY glad_debug_impl_glGetActiveUniformBlockiv(GLuint arg0, GLuint arg1, GLenum arg2, GLint * arg3) { - _pre_call_callback("glGetActiveUniformBlockiv", (void*)glGetActiveUniformBlockiv, 4, arg0, arg1, arg2, arg3); - glad_glGetActiveUniformBlockiv(arg0, arg1, arg2, arg3); - _post_call_callback("glGetActiveUniformBlockiv", (void*)glGetActiveUniformBlockiv, 4, arg0, arg1, arg2, arg3); - -} -PFNGLGETACTIVEUNIFORMBLOCKIVPROC glad_debug_glGetActiveUniformBlockiv = glad_debug_impl_glGetActiveUniformBlockiv; PFNGLUSEPROGRAMPROC glad_glUseProgram; -void APIENTRY glad_debug_impl_glUseProgram(GLuint arg0) { - _pre_call_callback("glUseProgram", (void*)glUseProgram, 1, arg0); - glad_glUseProgram(arg0); - _post_call_callback("glUseProgram", (void*)glUseProgram, 1, arg0); - -} -PFNGLUSEPROGRAMPROC glad_debug_glUseProgram = glad_debug_impl_glUseProgram; PFNGLGETPROGRAMINFOLOGPROC glad_glGetProgramInfoLog; -void APIENTRY glad_debug_impl_glGetProgramInfoLog(GLuint arg0, GLsizei arg1, GLsizei * arg2, GLchar * arg3) { - _pre_call_callback("glGetProgramInfoLog", (void*)glGetProgramInfoLog, 4, arg0, arg1, arg2, arg3); - glad_glGetProgramInfoLog(arg0, arg1, arg2, arg3); - _post_call_callback("glGetProgramInfoLog", (void*)glGetProgramInfoLog, 4, arg0, arg1, arg2, arg3); - -} -PFNGLGETPROGRAMINFOLOGPROC glad_debug_glGetProgramInfoLog = glad_debug_impl_glGetProgramInfoLog; PFNGLBINDVERTEXARRAYPROC glad_glBindVertexArray; -void APIENTRY glad_debug_impl_glBindVertexArray(GLuint arg0) { - _pre_call_callback("glBindVertexArray", (void*)glBindVertexArray, 1, arg0); - glad_glBindVertexArray(arg0); - _post_call_callback("glBindVertexArray", (void*)glBindVertexArray, 1, arg0); - -} -PFNGLBINDVERTEXARRAYPROC glad_debug_glBindVertexArray = glad_debug_impl_glBindVertexArray; PFNGLDELETEBUFFERSPROC glad_glDeleteBuffers; -void APIENTRY glad_debug_impl_glDeleteBuffers(GLsizei arg0, const GLuint * arg1) { - _pre_call_callback("glDeleteBuffers", (void*)glDeleteBuffers, 2, arg0, arg1); - glad_glDeleteBuffers(arg0, arg1); - _post_call_callback("glDeleteBuffers", (void*)glDeleteBuffers, 2, arg0, arg1); - -} -PFNGLDELETEBUFFERSPROC glad_debug_glDeleteBuffers = glad_debug_impl_glDeleteBuffers; PFNGLSAMPLERPARAMETERIIVPROC glad_glSamplerParameterIiv; -void APIENTRY glad_debug_impl_glSamplerParameterIiv(GLuint arg0, GLenum arg1, const GLint * arg2) { - _pre_call_callback("glSamplerParameterIiv", (void*)glSamplerParameterIiv, 3, arg0, arg1, arg2); - glad_glSamplerParameterIiv(arg0, arg1, arg2); - _post_call_callback("glSamplerParameterIiv", (void*)glSamplerParameterIiv, 3, arg0, arg1, arg2); - -} -PFNGLSAMPLERPARAMETERIIVPROC glad_debug_glSamplerParameterIiv = glad_debug_impl_glSamplerParameterIiv; PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC glad_glMultiDrawElementsBaseVertex; -void APIENTRY glad_debug_impl_glMultiDrawElementsBaseVertex(GLenum arg0, const GLsizei * arg1, GLenum arg2, const void *const* arg3, GLsizei arg4, const GLint * arg5) { - _pre_call_callback("glMultiDrawElementsBaseVertex", (void*)glMultiDrawElementsBaseVertex, 6, arg0, arg1, arg2, arg3, arg4, arg5); - glad_glMultiDrawElementsBaseVertex(arg0, arg1, arg2, arg3, arg4, arg5); - _post_call_callback("glMultiDrawElementsBaseVertex", (void*)glMultiDrawElementsBaseVertex, 6, arg0, arg1, arg2, arg3, arg4, arg5); - -} -PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC glad_debug_glMultiDrawElementsBaseVertex = glad_debug_impl_glMultiDrawElementsBaseVertex; PFNGLUNIFORM2UIVPROC glad_glUniform2uiv; -void APIENTRY glad_debug_impl_glUniform2uiv(GLint arg0, GLsizei arg1, const GLuint * arg2) { - _pre_call_callback("glUniform2uiv", (void*)glUniform2uiv, 3, arg0, arg1, arg2); - glad_glUniform2uiv(arg0, arg1, arg2); - _post_call_callback("glUniform2uiv", (void*)glUniform2uiv, 3, arg0, arg1, arg2); - -} -PFNGLUNIFORM2UIVPROC glad_debug_glUniform2uiv = glad_debug_impl_glUniform2uiv; PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC glad_glCompressedTexSubImage1D; -void APIENTRY glad_debug_impl_glCompressedTexSubImage1D(GLenum arg0, GLint arg1, GLint arg2, GLsizei arg3, GLenum arg4, GLsizei arg5, const void * arg6) { - _pre_call_callback("glCompressedTexSubImage1D", (void*)glCompressedTexSubImage1D, 7, arg0, arg1, arg2, arg3, arg4, arg5, arg6); - glad_glCompressedTexSubImage1D(arg0, arg1, arg2, arg3, arg4, arg5, arg6); - _post_call_callback("glCompressedTexSubImage1D", (void*)glCompressedTexSubImage1D, 7, arg0, arg1, arg2, arg3, arg4, arg5, arg6); - -} -PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC glad_debug_glCompressedTexSubImage1D = glad_debug_impl_glCompressedTexSubImage1D; PFNGLFINISHPROC glad_glFinish; -void APIENTRY glad_debug_impl_glFinish() { - _pre_call_callback("glFinish", (void*)glFinish, 0); - glad_glFinish(); - _post_call_callback("glFinish", (void*)glFinish, 0); - -} -PFNGLFINISHPROC glad_debug_glFinish = glad_debug_impl_glFinish; PFNGLDELETESHADERPROC glad_glDeleteShader; -void APIENTRY glad_debug_impl_glDeleteShader(GLuint arg0) { - _pre_call_callback("glDeleteShader", (void*)glDeleteShader, 1, arg0); - glad_glDeleteShader(arg0); - _post_call_callback("glDeleteShader", (void*)glDeleteShader, 1, arg0); - -} -PFNGLDELETESHADERPROC glad_debug_glDeleteShader = glad_debug_impl_glDeleteShader; PFNGLVERTEXATTRIB4NSVPROC glad_glVertexAttrib4Nsv; -void APIENTRY glad_debug_impl_glVertexAttrib4Nsv(GLuint arg0, const GLshort * arg1) { - _pre_call_callback("glVertexAttrib4Nsv", (void*)glVertexAttrib4Nsv, 2, arg0, arg1); - glad_glVertexAttrib4Nsv(arg0, arg1); - _post_call_callback("glVertexAttrib4Nsv", (void*)glVertexAttrib4Nsv, 2, arg0, arg1); - -} -PFNGLVERTEXATTRIB4NSVPROC glad_debug_glVertexAttrib4Nsv = glad_debug_impl_glVertexAttrib4Nsv; PFNGLVIEWPORTPROC glad_glViewport; -void APIENTRY glad_debug_impl_glViewport(GLint arg0, GLint arg1, GLsizei arg2, GLsizei arg3) { - _pre_call_callback("glViewport", (void*)glViewport, 4, arg0, arg1, arg2, arg3); - glad_glViewport(arg0, arg1, arg2, arg3); - _post_call_callback("glViewport", (void*)glViewport, 4, arg0, arg1, arg2, arg3); - -} -PFNGLVIEWPORTPROC glad_debug_glViewport = glad_debug_impl_glViewport; PFNGLUNIFORM1UIVPROC glad_glUniform1uiv; -void APIENTRY glad_debug_impl_glUniform1uiv(GLint arg0, GLsizei arg1, const GLuint * arg2) { - _pre_call_callback("glUniform1uiv", (void*)glUniform1uiv, 3, arg0, arg1, arg2); - glad_glUniform1uiv(arg0, arg1, arg2); - _post_call_callback("glUniform1uiv", (void*)glUniform1uiv, 3, arg0, arg1, arg2); - -} -PFNGLUNIFORM1UIVPROC glad_debug_glUniform1uiv = glad_debug_impl_glUniform1uiv; PFNGLTRANSFORMFEEDBACKVARYINGSPROC glad_glTransformFeedbackVaryings; -void APIENTRY glad_debug_impl_glTransformFeedbackVaryings(GLuint arg0, GLsizei arg1, const GLchar *const* arg2, GLenum arg3) { - _pre_call_callback("glTransformFeedbackVaryings", (void*)glTransformFeedbackVaryings, 4, arg0, arg1, arg2, arg3); - glad_glTransformFeedbackVaryings(arg0, arg1, arg2, arg3); - _post_call_callback("glTransformFeedbackVaryings", (void*)glTransformFeedbackVaryings, 4, arg0, arg1, arg2, arg3); - -} -PFNGLTRANSFORMFEEDBACKVARYINGSPROC glad_debug_glTransformFeedbackVaryings = glad_debug_impl_glTransformFeedbackVaryings; PFNGLUNIFORM2UIPROC glad_glUniform2ui; -void APIENTRY glad_debug_impl_glUniform2ui(GLint arg0, GLuint arg1, GLuint arg2) { - _pre_call_callback("glUniform2ui", (void*)glUniform2ui, 3, arg0, arg1, arg2); - glad_glUniform2ui(arg0, arg1, arg2); - _post_call_callback("glUniform2ui", (void*)glUniform2ui, 3, arg0, arg1, arg2); - -} -PFNGLUNIFORM2UIPROC glad_debug_glUniform2ui = glad_debug_impl_glUniform2ui; PFNGLVERTEXATTRIBI3IPROC glad_glVertexAttribI3i; -void APIENTRY glad_debug_impl_glVertexAttribI3i(GLuint arg0, GLint arg1, GLint arg2, GLint arg3) { - _pre_call_callback("glVertexAttribI3i", (void*)glVertexAttribI3i, 4, arg0, arg1, arg2, arg3); - glad_glVertexAttribI3i(arg0, arg1, arg2, arg3); - _post_call_callback("glVertexAttribI3i", (void*)glVertexAttribI3i, 4, arg0, arg1, arg2, arg3); - -} -PFNGLVERTEXATTRIBI3IPROC glad_debug_glVertexAttribI3i = glad_debug_impl_glVertexAttribI3i; PFNGLCLEARDEPTHPROC glad_glClearDepth; -void APIENTRY glad_debug_impl_glClearDepth(GLdouble arg0) { - _pre_call_callback("glClearDepth", (void*)glClearDepth, 1, arg0); - glad_glClearDepth(arg0); - _post_call_callback("glClearDepth", (void*)glClearDepth, 1, arg0); - -} -PFNGLCLEARDEPTHPROC glad_debug_glClearDepth = glad_debug_impl_glClearDepth; PFNGLVERTEXATTRIBI4USVPROC glad_glVertexAttribI4usv; -void APIENTRY glad_debug_impl_glVertexAttribI4usv(GLuint arg0, const GLushort * arg1) { - _pre_call_callback("glVertexAttribI4usv", (void*)glVertexAttribI4usv, 2, arg0, arg1); - glad_glVertexAttribI4usv(arg0, arg1); - _post_call_callback("glVertexAttribI4usv", (void*)glVertexAttribI4usv, 2, arg0, arg1); - -} -PFNGLVERTEXATTRIBI4USVPROC glad_debug_glVertexAttribI4usv = glad_debug_impl_glVertexAttribI4usv; PFNGLTEXPARAMETERFPROC glad_glTexParameterf; -void APIENTRY glad_debug_impl_glTexParameterf(GLenum arg0, GLenum arg1, GLfloat arg2) { - _pre_call_callback("glTexParameterf", (void*)glTexParameterf, 3, arg0, arg1, arg2); - glad_glTexParameterf(arg0, arg1, arg2); - _post_call_callback("glTexParameterf", (void*)glTexParameterf, 3, arg0, arg1, arg2); - -} -PFNGLTEXPARAMETERFPROC glad_debug_glTexParameterf = glad_debug_impl_glTexParameterf; PFNGLTEXPARAMETERIPROC glad_glTexParameteri; -void APIENTRY glad_debug_impl_glTexParameteri(GLenum arg0, GLenum arg1, GLint arg2) { - _pre_call_callback("glTexParameteri", (void*)glTexParameteri, 3, arg0, arg1, arg2); - glad_glTexParameteri(arg0, arg1, arg2); - _post_call_callback("glTexParameteri", (void*)glTexParameteri, 3, arg0, arg1, arg2); - -} -PFNGLTEXPARAMETERIPROC glad_debug_glTexParameteri = glad_debug_impl_glTexParameteri; PFNGLGETSHADERSOURCEPROC glad_glGetShaderSource; -void APIENTRY glad_debug_impl_glGetShaderSource(GLuint arg0, GLsizei arg1, GLsizei * arg2, GLchar * arg3) { - _pre_call_callback("glGetShaderSource", (void*)glGetShaderSource, 4, arg0, arg1, arg2, arg3); - glad_glGetShaderSource(arg0, arg1, arg2, arg3); - _post_call_callback("glGetShaderSource", (void*)glGetShaderSource, 4, arg0, arg1, arg2, arg3); - -} -PFNGLGETSHADERSOURCEPROC glad_debug_glGetShaderSource = glad_debug_impl_glGetShaderSource; PFNGLTEXBUFFERPROC glad_glTexBuffer; -void APIENTRY glad_debug_impl_glTexBuffer(GLenum arg0, GLenum arg1, GLuint arg2) { - _pre_call_callback("glTexBuffer", (void*)glTexBuffer, 3, arg0, arg1, arg2); - glad_glTexBuffer(arg0, arg1, arg2); - _post_call_callback("glTexBuffer", (void*)glTexBuffer, 3, arg0, arg1, arg2); - -} -PFNGLTEXBUFFERPROC glad_debug_glTexBuffer = glad_debug_impl_glTexBuffer; PFNGLPIXELSTOREIPROC glad_glPixelStorei; -void APIENTRY glad_debug_impl_glPixelStorei(GLenum arg0, GLint arg1) { - _pre_call_callback("glPixelStorei", (void*)glPixelStorei, 2, arg0, arg1); - glad_glPixelStorei(arg0, arg1); - _post_call_callback("glPixelStorei", (void*)glPixelStorei, 2, arg0, arg1); - -} -PFNGLPIXELSTOREIPROC glad_debug_glPixelStorei = glad_debug_impl_glPixelStorei; PFNGLVALIDATEPROGRAMPROC glad_glValidateProgram; -void APIENTRY glad_debug_impl_glValidateProgram(GLuint arg0) { - _pre_call_callback("glValidateProgram", (void*)glValidateProgram, 1, arg0); - glad_glValidateProgram(arg0); - _post_call_callback("glValidateProgram", (void*)glValidateProgram, 1, arg0); - -} -PFNGLVALIDATEPROGRAMPROC glad_debug_glValidateProgram = glad_debug_impl_glValidateProgram; PFNGLPIXELSTOREFPROC glad_glPixelStoref; -void APIENTRY glad_debug_impl_glPixelStoref(GLenum arg0, GLfloat arg1) { - _pre_call_callback("glPixelStoref", (void*)glPixelStoref, 2, arg0, arg1); - glad_glPixelStoref(arg0, arg1); - _post_call_callback("glPixelStoref", (void*)glPixelStoref, 2, arg0, arg1); - -} -PFNGLPIXELSTOREFPROC glad_debug_glPixelStoref = glad_debug_impl_glPixelStoref; PFNGLGETBOOLEANI_VPROC glad_glGetBooleani_v; -void APIENTRY glad_debug_impl_glGetBooleani_v(GLenum arg0, GLuint arg1, GLboolean * arg2) { - _pre_call_callback("glGetBooleani_v", (void*)glGetBooleani_v, 3, arg0, arg1, arg2); - glad_glGetBooleani_v(arg0, arg1, arg2); - _post_call_callback("glGetBooleani_v", (void*)glGetBooleani_v, 3, arg0, arg1, arg2); - -} -PFNGLGETBOOLEANI_VPROC glad_debug_glGetBooleani_v = glad_debug_impl_glGetBooleani_v; PFNGLMULTITEXCOORDP2UIVPROC glad_glMultiTexCoordP2uiv; -void APIENTRY glad_debug_impl_glMultiTexCoordP2uiv(GLenum arg0, GLenum arg1, const GLuint * arg2) { - _pre_call_callback("glMultiTexCoordP2uiv", (void*)glMultiTexCoordP2uiv, 3, arg0, arg1, arg2); - glad_glMultiTexCoordP2uiv(arg0, arg1, arg2); - _post_call_callback("glMultiTexCoordP2uiv", (void*)glMultiTexCoordP2uiv, 3, arg0, arg1, arg2); - -} -PFNGLMULTITEXCOORDP2UIVPROC glad_debug_glMultiTexCoordP2uiv = glad_debug_impl_glMultiTexCoordP2uiv; PFNGLVERTEXATTRIBP1UIVPROC glad_glVertexAttribP1uiv; -void APIENTRY glad_debug_impl_glVertexAttribP1uiv(GLuint arg0, GLenum arg1, GLboolean arg2, const GLuint * arg3) { - _pre_call_callback("glVertexAttribP1uiv", (void*)glVertexAttribP1uiv, 4, arg0, arg1, arg2, arg3); - glad_glVertexAttribP1uiv(arg0, arg1, arg2, arg3); - _post_call_callback("glVertexAttribP1uiv", (void*)glVertexAttribP1uiv, 4, arg0, arg1, arg2, arg3); - -} -PFNGLVERTEXATTRIBP1UIVPROC glad_debug_glVertexAttribP1uiv = glad_debug_impl_glVertexAttribP1uiv; PFNGLLINKPROGRAMPROC glad_glLinkProgram; -void APIENTRY glad_debug_impl_glLinkProgram(GLuint arg0) { - _pre_call_callback("glLinkProgram", (void*)glLinkProgram, 1, arg0); - glad_glLinkProgram(arg0); - _post_call_callback("glLinkProgram", (void*)glLinkProgram, 1, arg0); - -} -PFNGLLINKPROGRAMPROC glad_debug_glLinkProgram = glad_debug_impl_glLinkProgram; PFNGLBINDTEXTUREPROC glad_glBindTexture; -void APIENTRY glad_debug_impl_glBindTexture(GLenum arg0, GLuint arg1) { - _pre_call_callback("glBindTexture", (void*)glBindTexture, 2, arg0, arg1); - glad_glBindTexture(arg0, arg1); - _post_call_callback("glBindTexture", (void*)glBindTexture, 2, arg0, arg1); - -} -PFNGLBINDTEXTUREPROC glad_debug_glBindTexture = glad_debug_impl_glBindTexture; PFNGLGETSTRINGPROC glad_glGetString; -const GLubyte * APIENTRY glad_debug_impl_glGetString(GLenum arg0) { - const GLubyte * ret; - _pre_call_callback("glGetString", (void*)glGetString, 1, arg0); - ret = glad_glGetString(arg0); - _post_call_callback("glGetString", (void*)glGetString, 1, arg0); - return ret; -} -PFNGLGETSTRINGPROC glad_debug_glGetString = glad_debug_impl_glGetString; PFNGLVERTEXATTRIBP2UIVPROC glad_glVertexAttribP2uiv; -void APIENTRY glad_debug_impl_glVertexAttribP2uiv(GLuint arg0, GLenum arg1, GLboolean arg2, const GLuint * arg3) { - _pre_call_callback("glVertexAttribP2uiv", (void*)glVertexAttribP2uiv, 4, arg0, arg1, arg2, arg3); - glad_glVertexAttribP2uiv(arg0, arg1, arg2, arg3); - _post_call_callback("glVertexAttribP2uiv", (void*)glVertexAttribP2uiv, 4, arg0, arg1, arg2, arg3); - -} -PFNGLVERTEXATTRIBP2UIVPROC glad_debug_glVertexAttribP2uiv = glad_debug_impl_glVertexAttribP2uiv; PFNGLDETACHSHADERPROC glad_glDetachShader; -void APIENTRY glad_debug_impl_glDetachShader(GLuint arg0, GLuint arg1) { - _pre_call_callback("glDetachShader", (void*)glDetachShader, 2, arg0, arg1); - glad_glDetachShader(arg0, arg1); - _post_call_callback("glDetachShader", (void*)glDetachShader, 2, arg0, arg1); - -} -PFNGLDETACHSHADERPROC glad_debug_glDetachShader = glad_debug_impl_glDetachShader; PFNGLENDQUERYPROC glad_glEndQuery; -void APIENTRY glad_debug_impl_glEndQuery(GLenum arg0) { - _pre_call_callback("glEndQuery", (void*)glEndQuery, 1, arg0); - glad_glEndQuery(arg0); - _post_call_callback("glEndQuery", (void*)glEndQuery, 1, arg0); - -} -PFNGLENDQUERYPROC glad_debug_glEndQuery = glad_debug_impl_glEndQuery; PFNGLNORMALP3UIPROC glad_glNormalP3ui; -void APIENTRY glad_debug_impl_glNormalP3ui(GLenum arg0, GLuint arg1) { - _pre_call_callback("glNormalP3ui", (void*)glNormalP3ui, 2, arg0, arg1); - glad_glNormalP3ui(arg0, arg1); - _post_call_callback("glNormalP3ui", (void*)glNormalP3ui, 2, arg0, arg1); - -} -PFNGLNORMALP3UIPROC glad_debug_glNormalP3ui = glad_debug_impl_glNormalP3ui; PFNGLVERTEXATTRIBI2UIPROC glad_glVertexAttribI2ui; -void APIENTRY glad_debug_impl_glVertexAttribI2ui(GLuint arg0, GLuint arg1, GLuint arg2) { - _pre_call_callback("glVertexAttribI2ui", (void*)glVertexAttribI2ui, 3, arg0, arg1, arg2); - glad_glVertexAttribI2ui(arg0, arg1, arg2); - _post_call_callback("glVertexAttribI2ui", (void*)glVertexAttribI2ui, 3, arg0, arg1, arg2); - -} -PFNGLVERTEXATTRIBI2UIPROC glad_debug_glVertexAttribI2ui = glad_debug_impl_glVertexAttribI2ui; PFNGLDELETETEXTURESPROC glad_glDeleteTextures; -void APIENTRY glad_debug_impl_glDeleteTextures(GLsizei arg0, const GLuint * arg1) { - _pre_call_callback("glDeleteTextures", (void*)glDeleteTextures, 2, arg0, arg1); - glad_glDeleteTextures(arg0, arg1); - _post_call_callback("glDeleteTextures", (void*)glDeleteTextures, 2, arg0, arg1); - -} -PFNGLDELETETEXTURESPROC glad_debug_glDeleteTextures = glad_debug_impl_glDeleteTextures; PFNGLSTENCILOPSEPARATEPROC glad_glStencilOpSeparate; -void APIENTRY glad_debug_impl_glStencilOpSeparate(GLenum arg0, GLenum arg1, GLenum arg2, GLenum arg3) { - _pre_call_callback("glStencilOpSeparate", (void*)glStencilOpSeparate, 4, arg0, arg1, arg2, arg3); - glad_glStencilOpSeparate(arg0, arg1, arg2, arg3); - _post_call_callback("glStencilOpSeparate", (void*)glStencilOpSeparate, 4, arg0, arg1, arg2, arg3); - -} -PFNGLSTENCILOPSEPARATEPROC glad_debug_glStencilOpSeparate = glad_debug_impl_glStencilOpSeparate; PFNGLDELETEQUERIESPROC glad_glDeleteQueries; -void APIENTRY glad_debug_impl_glDeleteQueries(GLsizei arg0, const GLuint * arg1) { - _pre_call_callback("glDeleteQueries", (void*)glDeleteQueries, 2, arg0, arg1); - glad_glDeleteQueries(arg0, arg1); - _post_call_callback("glDeleteQueries", (void*)glDeleteQueries, 2, arg0, arg1); - -} -PFNGLDELETEQUERIESPROC glad_debug_glDeleteQueries = glad_debug_impl_glDeleteQueries; PFNGLNORMALP3UIVPROC glad_glNormalP3uiv; -void APIENTRY glad_debug_impl_glNormalP3uiv(GLenum arg0, const GLuint * arg1) { - _pre_call_callback("glNormalP3uiv", (void*)glNormalP3uiv, 2, arg0, arg1); - glad_glNormalP3uiv(arg0, arg1); - _post_call_callback("glNormalP3uiv", (void*)glNormalP3uiv, 2, arg0, arg1); - -} -PFNGLNORMALP3UIVPROC glad_debug_glNormalP3uiv = glad_debug_impl_glNormalP3uiv; PFNGLVERTEXATTRIB4FPROC glad_glVertexAttrib4f; -void APIENTRY glad_debug_impl_glVertexAttrib4f(GLuint arg0, GLfloat arg1, GLfloat arg2, GLfloat arg3, GLfloat arg4) { - _pre_call_callback("glVertexAttrib4f", (void*)glVertexAttrib4f, 5, arg0, arg1, arg2, arg3, arg4); - glad_glVertexAttrib4f(arg0, arg1, arg2, arg3, arg4); - _post_call_callback("glVertexAttrib4f", (void*)glVertexAttrib4f, 5, arg0, arg1, arg2, arg3, arg4); - -} -PFNGLVERTEXATTRIB4FPROC glad_debug_glVertexAttrib4f = glad_debug_impl_glVertexAttrib4f; PFNGLVERTEXATTRIB4DPROC glad_glVertexAttrib4d; -void APIENTRY glad_debug_impl_glVertexAttrib4d(GLuint arg0, GLdouble arg1, GLdouble arg2, GLdouble arg3, GLdouble arg4) { - _pre_call_callback("glVertexAttrib4d", (void*)glVertexAttrib4d, 5, arg0, arg1, arg2, arg3, arg4); - glad_glVertexAttrib4d(arg0, arg1, arg2, arg3, arg4); - _post_call_callback("glVertexAttrib4d", (void*)glVertexAttrib4d, 5, arg0, arg1, arg2, arg3, arg4); - -} -PFNGLVERTEXATTRIB4DPROC glad_debug_glVertexAttrib4d = glad_debug_impl_glVertexAttrib4d; PFNGLGETTEXPARAMETERIVPROC glad_glGetTexParameteriv; -void APIENTRY glad_debug_impl_glGetTexParameteriv(GLenum arg0, GLenum arg1, GLint * arg2) { - _pre_call_callback("glGetTexParameteriv", (void*)glGetTexParameteriv, 3, arg0, arg1, arg2); - glad_glGetTexParameteriv(arg0, arg1, arg2); - _post_call_callback("glGetTexParameteriv", (void*)glGetTexParameteriv, 3, arg0, arg1, arg2); - -} -PFNGLGETTEXPARAMETERIVPROC glad_debug_glGetTexParameteriv = glad_debug_impl_glGetTexParameteriv; PFNGLVERTEXATTRIB4SPROC glad_glVertexAttrib4s; -void APIENTRY glad_debug_impl_glVertexAttrib4s(GLuint arg0, GLshort arg1, GLshort arg2, GLshort arg3, GLshort arg4) { - _pre_call_callback("glVertexAttrib4s", (void*)glVertexAttrib4s, 5, arg0, arg1, arg2, arg3, arg4); - glad_glVertexAttrib4s(arg0, arg1, arg2, arg3, arg4); - _post_call_callback("glVertexAttrib4s", (void*)glVertexAttrib4s, 5, arg0, arg1, arg2, arg3, arg4); - -} -PFNGLVERTEXATTRIB4SPROC glad_debug_glVertexAttrib4s = glad_debug_impl_glVertexAttrib4s; PFNGLDRAWELEMENTSBASEVERTEXPROC glad_glDrawElementsBaseVertex; -void APIENTRY glad_debug_impl_glDrawElementsBaseVertex(GLenum arg0, GLsizei arg1, GLenum arg2, const void * arg3, GLint arg4) { - _pre_call_callback("glDrawElementsBaseVertex", (void*)glDrawElementsBaseVertex, 5, arg0, arg1, arg2, arg3, arg4); - glad_glDrawElementsBaseVertex(arg0, arg1, arg2, arg3, arg4); - _post_call_callback("glDrawElementsBaseVertex", (void*)glDrawElementsBaseVertex, 5, arg0, arg1, arg2, arg3, arg4); - -} -PFNGLDRAWELEMENTSBASEVERTEXPROC glad_debug_glDrawElementsBaseVertex = glad_debug_impl_glDrawElementsBaseVertex; PFNGLSAMPLECOVERAGEPROC glad_glSampleCoverage; -void APIENTRY glad_debug_impl_glSampleCoverage(GLfloat arg0, GLboolean arg1) { - _pre_call_callback("glSampleCoverage", (void*)glSampleCoverage, 2, arg0, arg1); - glad_glSampleCoverage(arg0, arg1); - _post_call_callback("glSampleCoverage", (void*)glSampleCoverage, 2, arg0, arg1); - -} -PFNGLSAMPLECOVERAGEPROC glad_debug_glSampleCoverage = glad_debug_impl_glSampleCoverage; PFNGLSAMPLERPARAMETERIPROC glad_glSamplerParameteri; -void APIENTRY glad_debug_impl_glSamplerParameteri(GLuint arg0, GLenum arg1, GLint arg2) { - _pre_call_callback("glSamplerParameteri", (void*)glSamplerParameteri, 3, arg0, arg1, arg2); - glad_glSamplerParameteri(arg0, arg1, arg2); - _post_call_callback("glSamplerParameteri", (void*)glSamplerParameteri, 3, arg0, arg1, arg2); - -} -PFNGLSAMPLERPARAMETERIPROC glad_debug_glSamplerParameteri = glad_debug_impl_glSamplerParameteri; PFNGLSAMPLERPARAMETERFPROC glad_glSamplerParameterf; -void APIENTRY glad_debug_impl_glSamplerParameterf(GLuint arg0, GLenum arg1, GLfloat arg2) { - _pre_call_callback("glSamplerParameterf", (void*)glSamplerParameterf, 3, arg0, arg1, arg2); - glad_glSamplerParameterf(arg0, arg1, arg2); - _post_call_callback("glSamplerParameterf", (void*)glSamplerParameterf, 3, arg0, arg1, arg2); - -} -PFNGLSAMPLERPARAMETERFPROC glad_debug_glSamplerParameterf = glad_debug_impl_glSamplerParameterf; PFNGLUNIFORM1FPROC glad_glUniform1f; -void APIENTRY glad_debug_impl_glUniform1f(GLint arg0, GLfloat arg1) { - _pre_call_callback("glUniform1f", (void*)glUniform1f, 2, arg0, arg1); - glad_glUniform1f(arg0, arg1); - _post_call_callback("glUniform1f", (void*)glUniform1f, 2, arg0, arg1); - -} -PFNGLUNIFORM1FPROC glad_debug_glUniform1f = glad_debug_impl_glUniform1f; PFNGLGETVERTEXATTRIBFVPROC glad_glGetVertexAttribfv; -void APIENTRY glad_debug_impl_glGetVertexAttribfv(GLuint arg0, GLenum arg1, GLfloat * arg2) { - _pre_call_callback("glGetVertexAttribfv", (void*)glGetVertexAttribfv, 3, arg0, arg1, arg2); - glad_glGetVertexAttribfv(arg0, arg1, arg2); - _post_call_callback("glGetVertexAttribfv", (void*)glGetVertexAttribfv, 3, arg0, arg1, arg2); - -} -PFNGLGETVERTEXATTRIBFVPROC glad_debug_glGetVertexAttribfv = glad_debug_impl_glGetVertexAttribfv; PFNGLGETCOMPRESSEDTEXIMAGEPROC glad_glGetCompressedTexImage; -void APIENTRY glad_debug_impl_glGetCompressedTexImage(GLenum arg0, GLint arg1, void * arg2) { - _pre_call_callback("glGetCompressedTexImage", (void*)glGetCompressedTexImage, 3, arg0, arg1, arg2); - glad_glGetCompressedTexImage(arg0, arg1, arg2); - _post_call_callback("glGetCompressedTexImage", (void*)glGetCompressedTexImage, 3, arg0, arg1, arg2); - -} -PFNGLGETCOMPRESSEDTEXIMAGEPROC glad_debug_glGetCompressedTexImage = glad_debug_impl_glGetCompressedTexImage; PFNGLUNIFORM1IPROC glad_glUniform1i; -void APIENTRY glad_debug_impl_glUniform1i(GLint arg0, GLint arg1) { - _pre_call_callback("glUniform1i", (void*)glUniform1i, 2, arg0, arg1); - glad_glUniform1i(arg0, arg1); - _post_call_callback("glUniform1i", (void*)glUniform1i, 2, arg0, arg1); - -} -PFNGLUNIFORM1IPROC glad_debug_glUniform1i = glad_debug_impl_glUniform1i; PFNGLGETACTIVEATTRIBPROC glad_glGetActiveAttrib; -void APIENTRY glad_debug_impl_glGetActiveAttrib(GLuint arg0, GLuint arg1, GLsizei arg2, GLsizei * arg3, GLint * arg4, GLenum * arg5, GLchar * arg6) { - _pre_call_callback("glGetActiveAttrib", (void*)glGetActiveAttrib, 7, arg0, arg1, arg2, arg3, arg4, arg5, arg6); - glad_glGetActiveAttrib(arg0, arg1, arg2, arg3, arg4, arg5, arg6); - _post_call_callback("glGetActiveAttrib", (void*)glGetActiveAttrib, 7, arg0, arg1, arg2, arg3, arg4, arg5, arg6); - -} -PFNGLGETACTIVEATTRIBPROC glad_debug_glGetActiveAttrib = glad_debug_impl_glGetActiveAttrib; PFNGLTEXSUBIMAGE2DPROC glad_glTexSubImage2D; -void APIENTRY glad_debug_impl_glTexSubImage2D(GLenum arg0, GLint arg1, GLint arg2, GLint arg3, GLsizei arg4, GLsizei arg5, GLenum arg6, GLenum arg7, const void * arg8) { - _pre_call_callback("glTexSubImage2D", (void*)glTexSubImage2D, 9, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8); - glad_glTexSubImage2D(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8); - _post_call_callback("glTexSubImage2D", (void*)glTexSubImage2D, 9, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8); - -} -PFNGLTEXSUBIMAGE2DPROC glad_debug_glTexSubImage2D = glad_debug_impl_glTexSubImage2D; PFNGLDISABLEPROC glad_glDisable; -void APIENTRY glad_debug_impl_glDisable(GLenum arg0) { - _pre_call_callback("glDisable", (void*)glDisable, 1, arg0); - glad_glDisable(arg0); - _post_call_callback("glDisable", (void*)glDisable, 1, arg0); - -} -PFNGLDISABLEPROC glad_debug_glDisable = glad_debug_impl_glDisable; PFNGLLOGICOPPROC glad_glLogicOp; -void APIENTRY glad_debug_impl_glLogicOp(GLenum arg0) { - _pre_call_callback("glLogicOp", (void*)glLogicOp, 1, arg0); - glad_glLogicOp(arg0); - _post_call_callback("glLogicOp", (void*)glLogicOp, 1, arg0); - -} -PFNGLLOGICOPPROC glad_debug_glLogicOp = glad_debug_impl_glLogicOp; PFNGLUNIFORM4UIPROC glad_glUniform4ui; -void APIENTRY glad_debug_impl_glUniform4ui(GLint arg0, GLuint arg1, GLuint arg2, GLuint arg3, GLuint arg4) { - _pre_call_callback("glUniform4ui", (void*)glUniform4ui, 5, arg0, arg1, arg2, arg3, arg4); - glad_glUniform4ui(arg0, arg1, arg2, arg3, arg4); - _post_call_callback("glUniform4ui", (void*)glUniform4ui, 5, arg0, arg1, arg2, arg3, arg4); - -} -PFNGLUNIFORM4UIPROC glad_debug_glUniform4ui = glad_debug_impl_glUniform4ui; PFNGLBINDFRAMEBUFFERPROC glad_glBindFramebuffer; -void APIENTRY glad_debug_impl_glBindFramebuffer(GLenum arg0, GLuint arg1) { - _pre_call_callback("glBindFramebuffer", (void*)glBindFramebuffer, 2, arg0, arg1); - glad_glBindFramebuffer(arg0, arg1); - _post_call_callback("glBindFramebuffer", (void*)glBindFramebuffer, 2, arg0, arg1); - -} -PFNGLBINDFRAMEBUFFERPROC glad_debug_glBindFramebuffer = glad_debug_impl_glBindFramebuffer; PFNGLCULLFACEPROC glad_glCullFace; -void APIENTRY glad_debug_impl_glCullFace(GLenum arg0) { - _pre_call_callback("glCullFace", (void*)glCullFace, 1, arg0); - glad_glCullFace(arg0); - _post_call_callback("glCullFace", (void*)glCullFace, 1, arg0); - -} -PFNGLCULLFACEPROC glad_debug_glCullFace = glad_debug_impl_glCullFace; PFNGLGETSTRINGIPROC glad_glGetStringi; -const GLubyte * APIENTRY glad_debug_impl_glGetStringi(GLenum arg0, GLuint arg1) { - const GLubyte * ret; - _pre_call_callback("glGetStringi", (void*)glGetStringi, 2, arg0, arg1); - ret = glad_glGetStringi(arg0, arg1); - _post_call_callback("glGetStringi", (void*)glGetStringi, 2, arg0, arg1); - return ret; -} -PFNGLGETSTRINGIPROC glad_debug_glGetStringi = glad_debug_impl_glGetStringi; PFNGLATTACHSHADERPROC glad_glAttachShader; -void APIENTRY glad_debug_impl_glAttachShader(GLuint arg0, GLuint arg1) { - _pre_call_callback("glAttachShader", (void*)glAttachShader, 2, arg0, arg1); - glad_glAttachShader(arg0, arg1); - _post_call_callback("glAttachShader", (void*)glAttachShader, 2, arg0, arg1); - -} -PFNGLATTACHSHADERPROC glad_debug_glAttachShader = glad_debug_impl_glAttachShader; PFNGLQUERYCOUNTERPROC glad_glQueryCounter; -void APIENTRY glad_debug_impl_glQueryCounter(GLuint arg0, GLenum arg1) { - _pre_call_callback("glQueryCounter", (void*)glQueryCounter, 2, arg0, arg1); - glad_glQueryCounter(arg0, arg1); - _post_call_callback("glQueryCounter", (void*)glQueryCounter, 2, arg0, arg1); - -} -PFNGLQUERYCOUNTERPROC glad_debug_glQueryCounter = glad_debug_impl_glQueryCounter; PFNGLPROVOKINGVERTEXPROC glad_glProvokingVertex; -void APIENTRY glad_debug_impl_glProvokingVertex(GLenum arg0) { - _pre_call_callback("glProvokingVertex", (void*)glProvokingVertex, 1, arg0); - glad_glProvokingVertex(arg0); - _post_call_callback("glProvokingVertex", (void*)glProvokingVertex, 1, arg0); - -} -PFNGLPROVOKINGVERTEXPROC glad_debug_glProvokingVertex = glad_debug_impl_glProvokingVertex; PFNGLDRAWELEMENTSPROC glad_glDrawElements; -void APIENTRY glad_debug_impl_glDrawElements(GLenum arg0, GLsizei arg1, GLenum arg2, const void * arg3) { - _pre_call_callback("glDrawElements", (void*)glDrawElements, 4, arg0, arg1, arg2, arg3); - glad_glDrawElements(arg0, arg1, arg2, arg3); - _post_call_callback("glDrawElements", (void*)glDrawElements, 4, arg0, arg1, arg2, arg3); - -} -PFNGLDRAWELEMENTSPROC glad_debug_glDrawElements = glad_debug_impl_glDrawElements; PFNGLVERTEXATTRIBI4SVPROC glad_glVertexAttribI4sv; -void APIENTRY glad_debug_impl_glVertexAttribI4sv(GLuint arg0, const GLshort * arg1) { - _pre_call_callback("glVertexAttribI4sv", (void*)glVertexAttribI4sv, 2, arg0, arg1); - glad_glVertexAttribI4sv(arg0, arg1); - _post_call_callback("glVertexAttribI4sv", (void*)glVertexAttribI4sv, 2, arg0, arg1); - -} -PFNGLVERTEXATTRIBI4SVPROC glad_debug_glVertexAttribI4sv = glad_debug_impl_glVertexAttribI4sv; PFNGLUNIFORM1IVPROC glad_glUniform1iv; -void APIENTRY glad_debug_impl_glUniform1iv(GLint arg0, GLsizei arg1, const GLint * arg2) { - _pre_call_callback("glUniform1iv", (void*)glUniform1iv, 3, arg0, arg1, arg2); - glad_glUniform1iv(arg0, arg1, arg2); - _post_call_callback("glUniform1iv", (void*)glUniform1iv, 3, arg0, arg1, arg2); - -} -PFNGLUNIFORM1IVPROC glad_debug_glUniform1iv = glad_debug_impl_glUniform1iv; PFNGLGETQUERYOBJECTIVPROC glad_glGetQueryObjectiv; -void APIENTRY glad_debug_impl_glGetQueryObjectiv(GLuint arg0, GLenum arg1, GLint * arg2) { - _pre_call_callback("glGetQueryObjectiv", (void*)glGetQueryObjectiv, 3, arg0, arg1, arg2); - glad_glGetQueryObjectiv(arg0, arg1, arg2); - _post_call_callback("glGetQueryObjectiv", (void*)glGetQueryObjectiv, 3, arg0, arg1, arg2); - -} -PFNGLGETQUERYOBJECTIVPROC glad_debug_glGetQueryObjectiv = glad_debug_impl_glGetQueryObjectiv; PFNGLREADBUFFERPROC glad_glReadBuffer; -void APIENTRY glad_debug_impl_glReadBuffer(GLenum arg0) { - _pre_call_callback("glReadBuffer", (void*)glReadBuffer, 1, arg0); - glad_glReadBuffer(arg0); - _post_call_callback("glReadBuffer", (void*)glReadBuffer, 1, arg0); - -} -PFNGLREADBUFFERPROC glad_debug_glReadBuffer = glad_debug_impl_glReadBuffer; PFNGLTEXPARAMETERIUIVPROC glad_glTexParameterIuiv; -void APIENTRY glad_debug_impl_glTexParameterIuiv(GLenum arg0, GLenum arg1, const GLuint * arg2) { - _pre_call_callback("glTexParameterIuiv", (void*)glTexParameterIuiv, 3, arg0, arg1, arg2); - glad_glTexParameterIuiv(arg0, arg1, arg2); - _post_call_callback("glTexParameterIuiv", (void*)glTexParameterIuiv, 3, arg0, arg1, arg2); - -} -PFNGLTEXPARAMETERIUIVPROC glad_debug_glTexParameterIuiv = glad_debug_impl_glTexParameterIuiv; PFNGLDRAWARRAYSINSTANCEDPROC glad_glDrawArraysInstanced; -void APIENTRY glad_debug_impl_glDrawArraysInstanced(GLenum arg0, GLint arg1, GLsizei arg2, GLsizei arg3) { - _pre_call_callback("glDrawArraysInstanced", (void*)glDrawArraysInstanced, 4, arg0, arg1, arg2, arg3); - glad_glDrawArraysInstanced(arg0, arg1, arg2, arg3); - _post_call_callback("glDrawArraysInstanced", (void*)glDrawArraysInstanced, 4, arg0, arg1, arg2, arg3); - -} -PFNGLDRAWARRAYSINSTANCEDPROC glad_debug_glDrawArraysInstanced = glad_debug_impl_glDrawArraysInstanced; PFNGLGENERATEMIPMAPPROC glad_glGenerateMipmap; -void APIENTRY glad_debug_impl_glGenerateMipmap(GLenum arg0) { - _pre_call_callback("glGenerateMipmap", (void*)glGenerateMipmap, 1, arg0); - glad_glGenerateMipmap(arg0); - _post_call_callback("glGenerateMipmap", (void*)glGenerateMipmap, 1, arg0); - -} -PFNGLGENERATEMIPMAPPROC glad_debug_glGenerateMipmap = glad_debug_impl_glGenerateMipmap; PFNGLSAMPLERPARAMETERIVPROC glad_glSamplerParameteriv; -void APIENTRY glad_debug_impl_glSamplerParameteriv(GLuint arg0, GLenum arg1, const GLint * arg2) { - _pre_call_callback("glSamplerParameteriv", (void*)glSamplerParameteriv, 3, arg0, arg1, arg2); - glad_glSamplerParameteriv(arg0, arg1, arg2); - _post_call_callback("glSamplerParameteriv", (void*)glSamplerParameteriv, 3, arg0, arg1, arg2); - -} -PFNGLSAMPLERPARAMETERIVPROC glad_debug_glSamplerParameteriv = glad_debug_impl_glSamplerParameteriv; PFNGLVERTEXATTRIB3FPROC glad_glVertexAttrib3f; -void APIENTRY glad_debug_impl_glVertexAttrib3f(GLuint arg0, GLfloat arg1, GLfloat arg2, GLfloat arg3) { - _pre_call_callback("glVertexAttrib3f", (void*)glVertexAttrib3f, 4, arg0, arg1, arg2, arg3); - glad_glVertexAttrib3f(arg0, arg1, arg2, arg3); - _post_call_callback("glVertexAttrib3f", (void*)glVertexAttrib3f, 4, arg0, arg1, arg2, arg3); - -} -PFNGLVERTEXATTRIB3FPROC glad_debug_glVertexAttrib3f = glad_debug_impl_glVertexAttrib3f; PFNGLVERTEXATTRIB4UIVPROC glad_glVertexAttrib4uiv; -void APIENTRY glad_debug_impl_glVertexAttrib4uiv(GLuint arg0, const GLuint * arg1) { - _pre_call_callback("glVertexAttrib4uiv", (void*)glVertexAttrib4uiv, 2, arg0, arg1); - glad_glVertexAttrib4uiv(arg0, arg1); - _post_call_callback("glVertexAttrib4uiv", (void*)glVertexAttrib4uiv, 2, arg0, arg1); - -} -PFNGLVERTEXATTRIB4UIVPROC glad_debug_glVertexAttrib4uiv = glad_debug_impl_glVertexAttrib4uiv; PFNGLPOINTPARAMETERIPROC glad_glPointParameteri; -void APIENTRY glad_debug_impl_glPointParameteri(GLenum arg0, GLint arg1) { - _pre_call_callback("glPointParameteri", (void*)glPointParameteri, 2, arg0, arg1); - glad_glPointParameteri(arg0, arg1); - _post_call_callback("glPointParameteri", (void*)glPointParameteri, 2, arg0, arg1); - -} -PFNGLPOINTPARAMETERIPROC glad_debug_glPointParameteri = glad_debug_impl_glPointParameteri; PFNGLBLENDCOLORPROC glad_glBlendColor; -void APIENTRY glad_debug_impl_glBlendColor(GLfloat arg0, GLfloat arg1, GLfloat arg2, GLfloat arg3) { - _pre_call_callback("glBlendColor", (void*)glBlendColor, 4, arg0, arg1, arg2, arg3); - glad_glBlendColor(arg0, arg1, arg2, arg3); - _post_call_callback("glBlendColor", (void*)glBlendColor, 4, arg0, arg1, arg2, arg3); - -} -PFNGLBLENDCOLORPROC glad_debug_glBlendColor = glad_debug_impl_glBlendColor; PFNGLSAMPLERPARAMETERIUIVPROC glad_glSamplerParameterIuiv; -void APIENTRY glad_debug_impl_glSamplerParameterIuiv(GLuint arg0, GLenum arg1, const GLuint * arg2) { - _pre_call_callback("glSamplerParameterIuiv", (void*)glSamplerParameterIuiv, 3, arg0, arg1, arg2); - glad_glSamplerParameterIuiv(arg0, arg1, arg2); - _post_call_callback("glSamplerParameterIuiv", (void*)glSamplerParameterIuiv, 3, arg0, arg1, arg2); - -} -PFNGLSAMPLERPARAMETERIUIVPROC glad_debug_glSamplerParameterIuiv = glad_debug_impl_glSamplerParameterIuiv; PFNGLUNMAPBUFFERPROC glad_glUnmapBuffer; -GLboolean APIENTRY glad_debug_impl_glUnmapBuffer(GLenum arg0) { - GLboolean ret; - _pre_call_callback("glUnmapBuffer", (void*)glUnmapBuffer, 1, arg0); - ret = glad_glUnmapBuffer(arg0); - _post_call_callback("glUnmapBuffer", (void*)glUnmapBuffer, 1, arg0); - return ret; -} -PFNGLUNMAPBUFFERPROC glad_debug_glUnmapBuffer = glad_debug_impl_glUnmapBuffer; PFNGLPOINTPARAMETERFPROC glad_glPointParameterf; -void APIENTRY glad_debug_impl_glPointParameterf(GLenum arg0, GLfloat arg1) { - _pre_call_callback("glPointParameterf", (void*)glPointParameterf, 2, arg0, arg1); - glad_glPointParameterf(arg0, arg1); - _post_call_callback("glPointParameterf", (void*)glPointParameterf, 2, arg0, arg1); - -} -PFNGLPOINTPARAMETERFPROC glad_debug_glPointParameterf = glad_debug_impl_glPointParameterf; PFNGLVERTEXATTRIB3SPROC glad_glVertexAttrib3s; -void APIENTRY glad_debug_impl_glVertexAttrib3s(GLuint arg0, GLshort arg1, GLshort arg2, GLshort arg3) { - _pre_call_callback("glVertexAttrib3s", (void*)glVertexAttrib3s, 4, arg0, arg1, arg2, arg3); - glad_glVertexAttrib3s(arg0, arg1, arg2, arg3); - _post_call_callback("glVertexAttrib3s", (void*)glVertexAttrib3s, 4, arg0, arg1, arg2, arg3); - -} -PFNGLVERTEXATTRIB3SPROC glad_debug_glVertexAttrib3s = glad_debug_impl_glVertexAttrib3s; PFNGLBINDRENDERBUFFERPROC glad_glBindRenderbuffer; -void APIENTRY glad_debug_impl_glBindRenderbuffer(GLenum arg0, GLuint arg1) { - _pre_call_callback("glBindRenderbuffer", (void*)glBindRenderbuffer, 2, arg0, arg1); - glad_glBindRenderbuffer(arg0, arg1); - _post_call_callback("glBindRenderbuffer", (void*)glBindRenderbuffer, 2, arg0, arg1); - -} -PFNGLBINDRENDERBUFFERPROC glad_debug_glBindRenderbuffer = glad_debug_impl_glBindRenderbuffer; PFNGLVERTEXATTRIBP4UIVPROC glad_glVertexAttribP4uiv; -void APIENTRY glad_debug_impl_glVertexAttribP4uiv(GLuint arg0, GLenum arg1, GLboolean arg2, const GLuint * arg3) { - _pre_call_callback("glVertexAttribP4uiv", (void*)glVertexAttribP4uiv, 4, arg0, arg1, arg2, arg3); - glad_glVertexAttribP4uiv(arg0, arg1, arg2, arg3); - _post_call_callback("glVertexAttribP4uiv", (void*)glVertexAttribP4uiv, 4, arg0, arg1, arg2, arg3); - -} -PFNGLVERTEXATTRIBP4UIVPROC glad_debug_glVertexAttribP4uiv = glad_debug_impl_glVertexAttribP4uiv; PFNGLISPROGRAMPROC glad_glIsProgram; -GLboolean APIENTRY glad_debug_impl_glIsProgram(GLuint arg0) { - GLboolean ret; - _pre_call_callback("glIsProgram", (void*)glIsProgram, 1, arg0); - ret = glad_glIsProgram(arg0); - _post_call_callback("glIsProgram", (void*)glIsProgram, 1, arg0); - return ret; -} -PFNGLISPROGRAMPROC glad_debug_glIsProgram = glad_debug_impl_glIsProgram; PFNGLVERTEXATTRIB4BVPROC glad_glVertexAttrib4bv; -void APIENTRY glad_debug_impl_glVertexAttrib4bv(GLuint arg0, const GLbyte * arg1) { - _pre_call_callback("glVertexAttrib4bv", (void*)glVertexAttrib4bv, 2, arg0, arg1); - glad_glVertexAttrib4bv(arg0, arg1); - _post_call_callback("glVertexAttrib4bv", (void*)glVertexAttrib4bv, 2, arg0, arg1); - -} -PFNGLVERTEXATTRIB4BVPROC glad_debug_glVertexAttrib4bv = glad_debug_impl_glVertexAttrib4bv; PFNGLVERTEXATTRIB4FVPROC glad_glVertexAttrib4fv; -void APIENTRY glad_debug_impl_glVertexAttrib4fv(GLuint arg0, const GLfloat * arg1) { - _pre_call_callback("glVertexAttrib4fv", (void*)glVertexAttrib4fv, 2, arg0, arg1); - glad_glVertexAttrib4fv(arg0, arg1); - _post_call_callback("glVertexAttrib4fv", (void*)glVertexAttrib4fv, 2, arg0, arg1); - -} -PFNGLVERTEXATTRIB4FVPROC glad_debug_glVertexAttrib4fv = glad_debug_impl_glVertexAttrib4fv; PFNGLUNIFORM4IPROC glad_glUniform4i; -void APIENTRY glad_debug_impl_glUniform4i(GLint arg0, GLint arg1, GLint arg2, GLint arg3, GLint arg4) { - _pre_call_callback("glUniform4i", (void*)glUniform4i, 5, arg0, arg1, arg2, arg3, arg4); - glad_glUniform4i(arg0, arg1, arg2, arg3, arg4); - _post_call_callback("glUniform4i", (void*)glUniform4i, 5, arg0, arg1, arg2, arg3, arg4); - -} -PFNGLUNIFORM4IPROC glad_debug_glUniform4i = glad_debug_impl_glUniform4i; PFNGLACTIVETEXTUREPROC glad_glActiveTexture; -void APIENTRY glad_debug_impl_glActiveTexture(GLenum arg0) { - _pre_call_callback("glActiveTexture", (void*)glActiveTexture, 1, arg0); - glad_glActiveTexture(arg0); - _post_call_callback("glActiveTexture", (void*)glActiveTexture, 1, arg0); - -} -PFNGLACTIVETEXTUREPROC glad_debug_glActiveTexture = glad_debug_impl_glActiveTexture; PFNGLENABLEVERTEXATTRIBARRAYPROC glad_glEnableVertexAttribArray; -void APIENTRY glad_debug_impl_glEnableVertexAttribArray(GLuint arg0) { - _pre_call_callback("glEnableVertexAttribArray", (void*)glEnableVertexAttribArray, 1, arg0); - glad_glEnableVertexAttribArray(arg0); - _post_call_callback("glEnableVertexAttribArray", (void*)glEnableVertexAttribArray, 1, arg0); - -} -PFNGLENABLEVERTEXATTRIBARRAYPROC glad_debug_glEnableVertexAttribArray = glad_debug_impl_glEnableVertexAttribArray; PFNGLREADPIXELSPROC glad_glReadPixels; -void APIENTRY glad_debug_impl_glReadPixels(GLint arg0, GLint arg1, GLsizei arg2, GLsizei arg3, GLenum arg4, GLenum arg5, void * arg6) { - _pre_call_callback("glReadPixels", (void*)glReadPixels, 7, arg0, arg1, arg2, arg3, arg4, arg5, arg6); - glad_glReadPixels(arg0, arg1, arg2, arg3, arg4, arg5, arg6); - _post_call_callback("glReadPixels", (void*)glReadPixels, 7, arg0, arg1, arg2, arg3, arg4, arg5, arg6); - -} -PFNGLREADPIXELSPROC glad_debug_glReadPixels = glad_debug_impl_glReadPixels; PFNGLVERTEXATTRIBI3IVPROC glad_glVertexAttribI3iv; -void APIENTRY glad_debug_impl_glVertexAttribI3iv(GLuint arg0, const GLint * arg1) { - _pre_call_callback("glVertexAttribI3iv", (void*)glVertexAttribI3iv, 2, arg0, arg1); - glad_glVertexAttribI3iv(arg0, arg1); - _post_call_callback("glVertexAttribI3iv", (void*)glVertexAttribI3iv, 2, arg0, arg1); - -} -PFNGLVERTEXATTRIBI3IVPROC glad_debug_glVertexAttribI3iv = glad_debug_impl_glVertexAttribI3iv; PFNGLUNIFORM4FPROC glad_glUniform4f; -void APIENTRY glad_debug_impl_glUniform4f(GLint arg0, GLfloat arg1, GLfloat arg2, GLfloat arg3, GLfloat arg4) { - _pre_call_callback("glUniform4f", (void*)glUniform4f, 5, arg0, arg1, arg2, arg3, arg4); - glad_glUniform4f(arg0, arg1, arg2, arg3, arg4); - _post_call_callback("glUniform4f", (void*)glUniform4f, 5, arg0, arg1, arg2, arg3, arg4); - -} -PFNGLUNIFORM4FPROC glad_debug_glUniform4f = glad_debug_impl_glUniform4f; PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC glad_glRenderbufferStorageMultisample; -void APIENTRY glad_debug_impl_glRenderbufferStorageMultisample(GLenum arg0, GLsizei arg1, GLenum arg2, GLsizei arg3, GLsizei arg4) { - _pre_call_callback("glRenderbufferStorageMultisample", (void*)glRenderbufferStorageMultisample, 5, arg0, arg1, arg2, arg3, arg4); - glad_glRenderbufferStorageMultisample(arg0, arg1, arg2, arg3, arg4); - _post_call_callback("glRenderbufferStorageMultisample", (void*)glRenderbufferStorageMultisample, 5, arg0, arg1, arg2, arg3, arg4); - -} -PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC glad_debug_glRenderbufferStorageMultisample = glad_debug_impl_glRenderbufferStorageMultisample; PFNGLUNIFORMMATRIX3FVPROC glad_glUniformMatrix3fv; -void APIENTRY glad_debug_impl_glUniformMatrix3fv(GLint arg0, GLsizei arg1, GLboolean arg2, const GLfloat * arg3) { - _pre_call_callback("glUniformMatrix3fv", (void*)glUniformMatrix3fv, 4, arg0, arg1, arg2, arg3); - glad_glUniformMatrix3fv(arg0, arg1, arg2, arg3); - _post_call_callback("glUniformMatrix3fv", (void*)glUniformMatrix3fv, 4, arg0, arg1, arg2, arg3); - -} -PFNGLUNIFORMMATRIX3FVPROC glad_debug_glUniformMatrix3fv = glad_debug_impl_glUniformMatrix3fv; PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC glad_glDrawElementsInstancedBaseVertex; -void APIENTRY glad_debug_impl_glDrawElementsInstancedBaseVertex(GLenum arg0, GLsizei arg1, GLenum arg2, const void * arg3, GLsizei arg4, GLint arg5) { - _pre_call_callback("glDrawElementsInstancedBaseVertex", (void*)glDrawElementsInstancedBaseVertex, 6, arg0, arg1, arg2, arg3, arg4, arg5); - glad_glDrawElementsInstancedBaseVertex(arg0, arg1, arg2, arg3, arg4, arg5); - _post_call_callback("glDrawElementsInstancedBaseVertex", (void*)glDrawElementsInstancedBaseVertex, 6, arg0, arg1, arg2, arg3, arg4, arg5); - -} -PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC glad_debug_glDrawElementsInstancedBaseVertex = glad_debug_impl_glDrawElementsInstancedBaseVertex; PFNGLSTENCILFUNCPROC glad_glStencilFunc; -void APIENTRY glad_debug_impl_glStencilFunc(GLenum arg0, GLint arg1, GLuint arg2) { - _pre_call_callback("glStencilFunc", (void*)glStencilFunc, 3, arg0, arg1, arg2); - glad_glStencilFunc(arg0, arg1, arg2); - _post_call_callback("glStencilFunc", (void*)glStencilFunc, 3, arg0, arg1, arg2); - -} -PFNGLSTENCILFUNCPROC glad_debug_glStencilFunc = glad_debug_impl_glStencilFunc; PFNGLUNIFORMBLOCKBINDINGPROC glad_glUniformBlockBinding; -void APIENTRY glad_debug_impl_glUniformBlockBinding(GLuint arg0, GLuint arg1, GLuint arg2) { - _pre_call_callback("glUniformBlockBinding", (void*)glUniformBlockBinding, 3, arg0, arg1, arg2); - glad_glUniformBlockBinding(arg0, arg1, arg2); - _post_call_callback("glUniformBlockBinding", (void*)glUniformBlockBinding, 3, arg0, arg1, arg2); - -} -PFNGLUNIFORMBLOCKBINDINGPROC glad_debug_glUniformBlockBinding = glad_debug_impl_glUniformBlockBinding; PFNGLCOLORP4UIPROC glad_glColorP4ui; -void APIENTRY glad_debug_impl_glColorP4ui(GLenum arg0, GLuint arg1) { - _pre_call_callback("glColorP4ui", (void*)glColorP4ui, 2, arg0, arg1); - glad_glColorP4ui(arg0, arg1); - _post_call_callback("glColorP4ui", (void*)glColorP4ui, 2, arg0, arg1); - -} -PFNGLCOLORP4UIPROC glad_debug_glColorP4ui = glad_debug_impl_glColorP4ui; PFNGLVERTEXATTRIBI4IVPROC glad_glVertexAttribI4iv; -void APIENTRY glad_debug_impl_glVertexAttribI4iv(GLuint arg0, const GLint * arg1) { - _pre_call_callback("glVertexAttribI4iv", (void*)glVertexAttribI4iv, 2, arg0, arg1); - glad_glVertexAttribI4iv(arg0, arg1); - _post_call_callback("glVertexAttribI4iv", (void*)glVertexAttribI4iv, 2, arg0, arg1); - -} -PFNGLVERTEXATTRIBI4IVPROC glad_debug_glVertexAttribI4iv = glad_debug_impl_glVertexAttribI4iv; PFNGLGETSHADERINFOLOGPROC glad_glGetShaderInfoLog; -void APIENTRY glad_debug_impl_glGetShaderInfoLog(GLuint arg0, GLsizei arg1, GLsizei * arg2, GLchar * arg3) { - _pre_call_callback("glGetShaderInfoLog", (void*)glGetShaderInfoLog, 4, arg0, arg1, arg2, arg3); - glad_glGetShaderInfoLog(arg0, arg1, arg2, arg3); - _post_call_callback("glGetShaderInfoLog", (void*)glGetShaderInfoLog, 4, arg0, arg1, arg2, arg3); - -} -PFNGLGETSHADERINFOLOGPROC glad_debug_glGetShaderInfoLog = glad_debug_impl_glGetShaderInfoLog; PFNGLVERTEXATTRIBI4IPROC glad_glVertexAttribI4i; -void APIENTRY glad_debug_impl_glVertexAttribI4i(GLuint arg0, GLint arg1, GLint arg2, GLint arg3, GLint arg4) { - _pre_call_callback("glVertexAttribI4i", (void*)glVertexAttribI4i, 5, arg0, arg1, arg2, arg3, arg4); - glad_glVertexAttribI4i(arg0, arg1, arg2, arg3, arg4); - _post_call_callback("glVertexAttribI4i", (void*)glVertexAttribI4i, 5, arg0, arg1, arg2, arg3, arg4); - -} -PFNGLVERTEXATTRIBI4IPROC glad_debug_glVertexAttribI4i = glad_debug_impl_glVertexAttribI4i; PFNGLGETBUFFERSUBDATAPROC glad_glGetBufferSubData; -void APIENTRY glad_debug_impl_glGetBufferSubData(GLenum arg0, GLintptr arg1, GLsizeiptr arg2, void * arg3) { - _pre_call_callback("glGetBufferSubData", (void*)glGetBufferSubData, 4, arg0, arg1, arg2, arg3); - glad_glGetBufferSubData(arg0, arg1, arg2, arg3); - _post_call_callback("glGetBufferSubData", (void*)glGetBufferSubData, 4, arg0, arg1, arg2, arg3); - -} -PFNGLGETBUFFERSUBDATAPROC glad_debug_glGetBufferSubData = glad_debug_impl_glGetBufferSubData; PFNGLBLENDEQUATIONSEPARATEPROC glad_glBlendEquationSeparate; -void APIENTRY glad_debug_impl_glBlendEquationSeparate(GLenum arg0, GLenum arg1) { - _pre_call_callback("glBlendEquationSeparate", (void*)glBlendEquationSeparate, 2, arg0, arg1); - glad_glBlendEquationSeparate(arg0, arg1); - _post_call_callback("glBlendEquationSeparate", (void*)glBlendEquationSeparate, 2, arg0, arg1); - -} -PFNGLBLENDEQUATIONSEPARATEPROC glad_debug_glBlendEquationSeparate = glad_debug_impl_glBlendEquationSeparate; PFNGLVERTEXATTRIBI1UIPROC glad_glVertexAttribI1ui; -void APIENTRY glad_debug_impl_glVertexAttribI1ui(GLuint arg0, GLuint arg1) { - _pre_call_callback("glVertexAttribI1ui", (void*)glVertexAttribI1ui, 2, arg0, arg1); - glad_glVertexAttribI1ui(arg0, arg1); - _post_call_callback("glVertexAttribI1ui", (void*)glVertexAttribI1ui, 2, arg0, arg1); - -} -PFNGLVERTEXATTRIBI1UIPROC glad_debug_glVertexAttribI1ui = glad_debug_impl_glVertexAttribI1ui; PFNGLGENBUFFERSPROC glad_glGenBuffers; -void APIENTRY glad_debug_impl_glGenBuffers(GLsizei arg0, GLuint * arg1) { - _pre_call_callback("glGenBuffers", (void*)glGenBuffers, 2, arg0, arg1); - glad_glGenBuffers(arg0, arg1); - _post_call_callback("glGenBuffers", (void*)glGenBuffers, 2, arg0, arg1); - -} -PFNGLGENBUFFERSPROC glad_debug_glGenBuffers = glad_debug_impl_glGenBuffers; PFNGLVERTEXATTRIB2SVPROC glad_glVertexAttrib2sv; -void APIENTRY glad_debug_impl_glVertexAttrib2sv(GLuint arg0, const GLshort * arg1) { - _pre_call_callback("glVertexAttrib2sv", (void*)glVertexAttrib2sv, 2, arg0, arg1); - glad_glVertexAttrib2sv(arg0, arg1); - _post_call_callback("glVertexAttrib2sv", (void*)glVertexAttrib2sv, 2, arg0, arg1); - -} -PFNGLVERTEXATTRIB2SVPROC glad_debug_glVertexAttrib2sv = glad_debug_impl_glVertexAttrib2sv; PFNGLBLENDFUNCPROC glad_glBlendFunc; -void APIENTRY glad_debug_impl_glBlendFunc(GLenum arg0, GLenum arg1) { - _pre_call_callback("glBlendFunc", (void*)glBlendFunc, 2, arg0, arg1); - glad_glBlendFunc(arg0, arg1); - _post_call_callback("glBlendFunc", (void*)glBlendFunc, 2, arg0, arg1); - -} -PFNGLBLENDFUNCPROC glad_debug_glBlendFunc = glad_debug_impl_glBlendFunc; PFNGLCREATEPROGRAMPROC glad_glCreateProgram; -GLuint APIENTRY glad_debug_impl_glCreateProgram() { - GLuint ret; - _pre_call_callback("glCreateProgram", (void*)glCreateProgram, 0); - ret = glad_glCreateProgram(); - _post_call_callback("glCreateProgram", (void*)glCreateProgram, 0); - return ret; -} -PFNGLCREATEPROGRAMPROC glad_debug_glCreateProgram = glad_debug_impl_glCreateProgram; PFNGLTEXIMAGE3DPROC glad_glTexImage3D; -void APIENTRY glad_debug_impl_glTexImage3D(GLenum arg0, GLint arg1, GLint arg2, GLsizei arg3, GLsizei arg4, GLsizei arg5, GLint arg6, GLenum arg7, GLenum arg8, const void * arg9) { - _pre_call_callback("glTexImage3D", (void*)glTexImage3D, 10, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9); - glad_glTexImage3D(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9); - _post_call_callback("glTexImage3D", (void*)glTexImage3D, 10, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9); - -} -PFNGLTEXIMAGE3DPROC glad_debug_glTexImage3D = glad_debug_impl_glTexImage3D; PFNGLISFRAMEBUFFERPROC glad_glIsFramebuffer; -GLboolean APIENTRY glad_debug_impl_glIsFramebuffer(GLuint arg0) { - GLboolean ret; - _pre_call_callback("glIsFramebuffer", (void*)glIsFramebuffer, 1, arg0); - ret = glad_glIsFramebuffer(arg0); - _post_call_callback("glIsFramebuffer", (void*)glIsFramebuffer, 1, arg0); - return ret; -} -PFNGLISFRAMEBUFFERPROC glad_debug_glIsFramebuffer = glad_debug_impl_glIsFramebuffer; PFNGLPRIMITIVERESTARTINDEXPROC glad_glPrimitiveRestartIndex; -void APIENTRY glad_debug_impl_glPrimitiveRestartIndex(GLuint arg0) { - _pre_call_callback("glPrimitiveRestartIndex", (void*)glPrimitiveRestartIndex, 1, arg0); - glad_glPrimitiveRestartIndex(arg0); - _post_call_callback("glPrimitiveRestartIndex", (void*)glPrimitiveRestartIndex, 1, arg0); - -} -PFNGLPRIMITIVERESTARTINDEXPROC glad_debug_glPrimitiveRestartIndex = glad_debug_impl_glPrimitiveRestartIndex; PFNGLGETINTEGER64VPROC glad_glGetInteger64v; -void APIENTRY glad_debug_impl_glGetInteger64v(GLenum arg0, GLint64 * arg1) { - _pre_call_callback("glGetInteger64v", (void*)glGetInteger64v, 2, arg0, arg1); - glad_glGetInteger64v(arg0, arg1); - _post_call_callback("glGetInteger64v", (void*)glGetInteger64v, 2, arg0, arg1); - -} -PFNGLGETINTEGER64VPROC glad_debug_glGetInteger64v = glad_debug_impl_glGetInteger64v; PFNGLSCISSORPROC glad_glScissor; -void APIENTRY glad_debug_impl_glScissor(GLint arg0, GLint arg1, GLsizei arg2, GLsizei arg3) { - _pre_call_callback("glScissor", (void*)glScissor, 4, arg0, arg1, arg2, arg3); - glad_glScissor(arg0, arg1, arg2, arg3); - _post_call_callback("glScissor", (void*)glScissor, 4, arg0, arg1, arg2, arg3); - -} -PFNGLSCISSORPROC glad_debug_glScissor = glad_debug_impl_glScissor; PFNGLTEXCOORDP4UIVPROC glad_glTexCoordP4uiv; -void APIENTRY glad_debug_impl_glTexCoordP4uiv(GLenum arg0, const GLuint * arg1) { - _pre_call_callback("glTexCoordP4uiv", (void*)glTexCoordP4uiv, 2, arg0, arg1); - glad_glTexCoordP4uiv(arg0, arg1); - _post_call_callback("glTexCoordP4uiv", (void*)glTexCoordP4uiv, 2, arg0, arg1); - -} -PFNGLTEXCOORDP4UIVPROC glad_debug_glTexCoordP4uiv = glad_debug_impl_glTexCoordP4uiv; PFNGLGETBOOLEANVPROC glad_glGetBooleanv; -void APIENTRY glad_debug_impl_glGetBooleanv(GLenum arg0, GLboolean * arg1) { - _pre_call_callback("glGetBooleanv", (void*)glGetBooleanv, 2, arg0, arg1); - glad_glGetBooleanv(arg0, arg1); - _post_call_callback("glGetBooleanv", (void*)glGetBooleanv, 2, arg0, arg1); - -} -PFNGLGETBOOLEANVPROC glad_debug_glGetBooleanv = glad_debug_impl_glGetBooleanv; PFNGLVERTEXP2UIVPROC glad_glVertexP2uiv; -void APIENTRY glad_debug_impl_glVertexP2uiv(GLenum arg0, const GLuint * arg1) { - _pre_call_callback("glVertexP2uiv", (void*)glVertexP2uiv, 2, arg0, arg1); - glad_glVertexP2uiv(arg0, arg1); - _post_call_callback("glVertexP2uiv", (void*)glVertexP2uiv, 2, arg0, arg1); - -} -PFNGLVERTEXP2UIVPROC glad_debug_glVertexP2uiv = glad_debug_impl_glVertexP2uiv; PFNGLUNIFORM3UIVPROC glad_glUniform3uiv; -void APIENTRY glad_debug_impl_glUniform3uiv(GLint arg0, GLsizei arg1, const GLuint * arg2) { - _pre_call_callback("glUniform3uiv", (void*)glUniform3uiv, 3, arg0, arg1, arg2); - glad_glUniform3uiv(arg0, arg1, arg2); - _post_call_callback("glUniform3uiv", (void*)glUniform3uiv, 3, arg0, arg1, arg2); - -} -PFNGLUNIFORM3UIVPROC glad_debug_glUniform3uiv = glad_debug_impl_glUniform3uiv; PFNGLCLEARCOLORPROC glad_glClearColor; -void APIENTRY glad_debug_impl_glClearColor(GLfloat arg0, GLfloat arg1, GLfloat arg2, GLfloat arg3) { - _pre_call_callback("glClearColor", (void*)glClearColor, 4, arg0, arg1, arg2, arg3); - glad_glClearColor(arg0, arg1, arg2, arg3); - _post_call_callback("glClearColor", (void*)glClearColor, 4, arg0, arg1, arg2, arg3); - -} -PFNGLCLEARCOLORPROC glad_debug_glClearColor = glad_debug_impl_glClearColor; PFNGLVERTEXATTRIB4NIVPROC glad_glVertexAttrib4Niv; -void APIENTRY glad_debug_impl_glVertexAttrib4Niv(GLuint arg0, const GLint * arg1) { - _pre_call_callback("glVertexAttrib4Niv", (void*)glVertexAttrib4Niv, 2, arg0, arg1); - glad_glVertexAttrib4Niv(arg0, arg1); - _post_call_callback("glVertexAttrib4Niv", (void*)glVertexAttrib4Niv, 2, arg0, arg1); - -} -PFNGLVERTEXATTRIB4NIVPROC glad_debug_glVertexAttrib4Niv = glad_debug_impl_glVertexAttrib4Niv; PFNGLCLEARBUFFERIVPROC glad_glClearBufferiv; -void APIENTRY glad_debug_impl_glClearBufferiv(GLenum arg0, GLint arg1, const GLint * arg2) { - _pre_call_callback("glClearBufferiv", (void*)glClearBufferiv, 3, arg0, arg1, arg2); - glad_glClearBufferiv(arg0, arg1, arg2); - _post_call_callback("glClearBufferiv", (void*)glClearBufferiv, 3, arg0, arg1, arg2); - -} -PFNGLCLEARBUFFERIVPROC glad_debug_glClearBufferiv = glad_debug_impl_glClearBufferiv; PFNGLGETBUFFERPARAMETERI64VPROC glad_glGetBufferParameteri64v; -void APIENTRY glad_debug_impl_glGetBufferParameteri64v(GLenum arg0, GLenum arg1, GLint64 * arg2) { - _pre_call_callback("glGetBufferParameteri64v", (void*)glGetBufferParameteri64v, 3, arg0, arg1, arg2); - glad_glGetBufferParameteri64v(arg0, arg1, arg2); - _post_call_callback("glGetBufferParameteri64v", (void*)glGetBufferParameteri64v, 3, arg0, arg1, arg2); - -} -PFNGLGETBUFFERPARAMETERI64VPROC glad_debug_glGetBufferParameteri64v = glad_debug_impl_glGetBufferParameteri64v; PFNGLCOLORP4UIVPROC glad_glColorP4uiv; -void APIENTRY glad_debug_impl_glColorP4uiv(GLenum arg0, const GLuint * arg1) { - _pre_call_callback("glColorP4uiv", (void*)glColorP4uiv, 2, arg0, arg1); - glad_glColorP4uiv(arg0, arg1); - _post_call_callback("glColorP4uiv", (void*)glColorP4uiv, 2, arg0, arg1); - -} -PFNGLCOLORP4UIVPROC glad_debug_glColorP4uiv = glad_debug_impl_glColorP4uiv; PFNGLVERTEXATTRIBI2UIVPROC glad_glVertexAttribI2uiv; -void APIENTRY glad_debug_impl_glVertexAttribI2uiv(GLuint arg0, const GLuint * arg1) { - _pre_call_callback("glVertexAttribI2uiv", (void*)glVertexAttribI2uiv, 2, arg0, arg1); - glad_glVertexAttribI2uiv(arg0, arg1); - _post_call_callback("glVertexAttribI2uiv", (void*)glVertexAttribI2uiv, 2, arg0, arg1); - -} -PFNGLVERTEXATTRIBI2UIVPROC glad_debug_glVertexAttribI2uiv = glad_debug_impl_glVertexAttribI2uiv; PFNGLUNIFORM3UIPROC glad_glUniform3ui; -void APIENTRY glad_debug_impl_glUniform3ui(GLint arg0, GLuint arg1, GLuint arg2, GLuint arg3) { - _pre_call_callback("glUniform3ui", (void*)glUniform3ui, 4, arg0, arg1, arg2, arg3); - glad_glUniform3ui(arg0, arg1, arg2, arg3); - _post_call_callback("glUniform3ui", (void*)glUniform3ui, 4, arg0, arg1, arg2, arg3); - -} -PFNGLUNIFORM3UIPROC glad_debug_glUniform3ui = glad_debug_impl_glUniform3ui; PFNGLVERTEXATTRIBI4UIVPROC glad_glVertexAttribI4uiv; -void APIENTRY glad_debug_impl_glVertexAttribI4uiv(GLuint arg0, const GLuint * arg1) { - _pre_call_callback("glVertexAttribI4uiv", (void*)glVertexAttribI4uiv, 2, arg0, arg1); - glad_glVertexAttribI4uiv(arg0, arg1); - _post_call_callback("glVertexAttribI4uiv", (void*)glVertexAttribI4uiv, 2, arg0, arg1); - -} -PFNGLVERTEXATTRIBI4UIVPROC glad_debug_glVertexAttribI4uiv = glad_debug_impl_glVertexAttribI4uiv; PFNGLPOINTPARAMETERFVPROC glad_glPointParameterfv; -void APIENTRY glad_debug_impl_glPointParameterfv(GLenum arg0, const GLfloat * arg1) { - _pre_call_callback("glPointParameterfv", (void*)glPointParameterfv, 2, arg0, arg1); - glad_glPointParameterfv(arg0, arg1); - _post_call_callback("glPointParameterfv", (void*)glPointParameterfv, 2, arg0, arg1); - -} -PFNGLPOINTPARAMETERFVPROC glad_debug_glPointParameterfv = glad_debug_impl_glPointParameterfv; PFNGLUNIFORM2FVPROC glad_glUniform2fv; -void APIENTRY glad_debug_impl_glUniform2fv(GLint arg0, GLsizei arg1, const GLfloat * arg2) { - _pre_call_callback("glUniform2fv", (void*)glUniform2fv, 3, arg0, arg1, arg2); - glad_glUniform2fv(arg0, arg1, arg2); - _post_call_callback("glUniform2fv", (void*)glUniform2fv, 3, arg0, arg1, arg2); - -} -PFNGLUNIFORM2FVPROC glad_debug_glUniform2fv = glad_debug_impl_glUniform2fv; PFNGLGETSAMPLERPARAMETERIUIVPROC glad_glGetSamplerParameterIuiv; -void APIENTRY glad_debug_impl_glGetSamplerParameterIuiv(GLuint arg0, GLenum arg1, GLuint * arg2) { - _pre_call_callback("glGetSamplerParameterIuiv", (void*)glGetSamplerParameterIuiv, 3, arg0, arg1, arg2); - glad_glGetSamplerParameterIuiv(arg0, arg1, arg2); - _post_call_callback("glGetSamplerParameterIuiv", (void*)glGetSamplerParameterIuiv, 3, arg0, arg1, arg2); - -} -PFNGLGETSAMPLERPARAMETERIUIVPROC glad_debug_glGetSamplerParameterIuiv = glad_debug_impl_glGetSamplerParameterIuiv; PFNGLBINDBUFFERRANGEPROC glad_glBindBufferRange; -void APIENTRY glad_debug_impl_glBindBufferRange(GLenum arg0, GLuint arg1, GLuint arg2, GLintptr arg3, GLsizeiptr arg4) { - _pre_call_callback("glBindBufferRange", (void*)glBindBufferRange, 5, arg0, arg1, arg2, arg3, arg4); - glad_glBindBufferRange(arg0, arg1, arg2, arg3, arg4); - _post_call_callback("glBindBufferRange", (void*)glBindBufferRange, 5, arg0, arg1, arg2, arg3, arg4); - -} -PFNGLBINDBUFFERRANGEPROC glad_debug_glBindBufferRange = glad_debug_impl_glBindBufferRange; PFNGLUNIFORMMATRIX2X3FVPROC glad_glUniformMatrix2x3fv; -void APIENTRY glad_debug_impl_glUniformMatrix2x3fv(GLint arg0, GLsizei arg1, GLboolean arg2, const GLfloat * arg3) { - _pre_call_callback("glUniformMatrix2x3fv", (void*)glUniformMatrix2x3fv, 4, arg0, arg1, arg2, arg3); - glad_glUniformMatrix2x3fv(arg0, arg1, arg2, arg3); - _post_call_callback("glUniformMatrix2x3fv", (void*)glUniformMatrix2x3fv, 4, arg0, arg1, arg2, arg3); - -} -PFNGLUNIFORMMATRIX2X3FVPROC glad_debug_glUniformMatrix2x3fv = glad_debug_impl_glUniformMatrix2x3fv; PFNGLGETVERTEXATTRIBIUIVPROC glad_glGetVertexAttribIuiv; -void APIENTRY glad_debug_impl_glGetVertexAttribIuiv(GLuint arg0, GLenum arg1, GLuint * arg2) { - _pre_call_callback("glGetVertexAttribIuiv", (void*)glGetVertexAttribIuiv, 3, arg0, arg1, arg2); - glad_glGetVertexAttribIuiv(arg0, arg1, arg2); - _post_call_callback("glGetVertexAttribIuiv", (void*)glGetVertexAttribIuiv, 3, arg0, arg1, arg2); - -} -PFNGLGETVERTEXATTRIBIUIVPROC glad_debug_glGetVertexAttribIuiv = glad_debug_impl_glGetVertexAttribIuiv; PFNGLVERTEXATTRIB4NUSVPROC glad_glVertexAttrib4Nusv; -void APIENTRY glad_debug_impl_glVertexAttrib4Nusv(GLuint arg0, const GLushort * arg1) { - _pre_call_callback("glVertexAttrib4Nusv", (void*)glVertexAttrib4Nusv, 2, arg0, arg1); - glad_glVertexAttrib4Nusv(arg0, arg1); - _post_call_callback("glVertexAttrib4Nusv", (void*)glVertexAttrib4Nusv, 2, arg0, arg1); - -} -PFNGLVERTEXATTRIB4NUSVPROC glad_debug_glVertexAttrib4Nusv = glad_debug_impl_glVertexAttrib4Nusv; PFNGLDEPTHFUNCPROC glad_glDepthFunc; -void APIENTRY glad_debug_impl_glDepthFunc(GLenum arg0) { - _pre_call_callback("glDepthFunc", (void*)glDepthFunc, 1, arg0); - glad_glDepthFunc(arg0); - _post_call_callback("glDepthFunc", (void*)glDepthFunc, 1, arg0); - -} -PFNGLDEPTHFUNCPROC glad_debug_glDepthFunc = glad_debug_impl_glDepthFunc; PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC glad_glCompressedTexSubImage2D; -void APIENTRY glad_debug_impl_glCompressedTexSubImage2D(GLenum arg0, GLint arg1, GLint arg2, GLint arg3, GLsizei arg4, GLsizei arg5, GLenum arg6, GLsizei arg7, const void * arg8) { - _pre_call_callback("glCompressedTexSubImage2D", (void*)glCompressedTexSubImage2D, 9, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8); - glad_glCompressedTexSubImage2D(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8); - _post_call_callback("glCompressedTexSubImage2D", (void*)glCompressedTexSubImage2D, 9, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8); - -} -PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC glad_debug_glCompressedTexSubImage2D = glad_debug_impl_glCompressedTexSubImage2D; PFNGLVERTEXATTRIBI4BVPROC glad_glVertexAttribI4bv; -void APIENTRY glad_debug_impl_glVertexAttribI4bv(GLuint arg0, const GLbyte * arg1) { - _pre_call_callback("glVertexAttribI4bv", (void*)glVertexAttribI4bv, 2, arg0, arg1); - glad_glVertexAttribI4bv(arg0, arg1); - _post_call_callback("glVertexAttribI4bv", (void*)glVertexAttribI4bv, 2, arg0, arg1); - -} -PFNGLVERTEXATTRIBI4BVPROC glad_debug_glVertexAttribI4bv = glad_debug_impl_glVertexAttribI4bv; PFNGLGETTEXPARAMETERFVPROC glad_glGetTexParameterfv; -void APIENTRY glad_debug_impl_glGetTexParameterfv(GLenum arg0, GLenum arg1, GLfloat * arg2) { - _pre_call_callback("glGetTexParameterfv", (void*)glGetTexParameterfv, 3, arg0, arg1, arg2); - glad_glGetTexParameterfv(arg0, arg1, arg2); - _post_call_callback("glGetTexParameterfv", (void*)glGetTexParameterfv, 3, arg0, arg1, arg2); - -} -PFNGLGETTEXPARAMETERFVPROC glad_debug_glGetTexParameterfv = glad_debug_impl_glGetTexParameterfv; PFNGLMULTITEXCOORDP1UIPROC glad_glMultiTexCoordP1ui; -void APIENTRY glad_debug_impl_glMultiTexCoordP1ui(GLenum arg0, GLenum arg1, GLuint arg2) { - _pre_call_callback("glMultiTexCoordP1ui", (void*)glMultiTexCoordP1ui, 3, arg0, arg1, arg2); - glad_glMultiTexCoordP1ui(arg0, arg1, arg2); - _post_call_callback("glMultiTexCoordP1ui", (void*)glMultiTexCoordP1ui, 3, arg0, arg1, arg2); - -} -PFNGLMULTITEXCOORDP1UIPROC glad_debug_glMultiTexCoordP1ui = glad_debug_impl_glMultiTexCoordP1ui; PFNGLCLIENTWAITSYNCPROC glad_glClientWaitSync; -GLenum APIENTRY glad_debug_impl_glClientWaitSync(GLsync arg0, GLbitfield arg1, GLuint64 arg2) { - GLenum ret; - _pre_call_callback("glClientWaitSync", (void*)glClientWaitSync, 3, arg0, arg1, arg2); - ret = glad_glClientWaitSync(arg0, arg1, arg2); - _post_call_callback("glClientWaitSync", (void*)glClientWaitSync, 3, arg0, arg1, arg2); - return ret; -} -PFNGLCLIENTWAITSYNCPROC glad_debug_glClientWaitSync = glad_debug_impl_glClientWaitSync; PFNGLVERTEXATTRIBI4UIPROC glad_glVertexAttribI4ui; -void APIENTRY glad_debug_impl_glVertexAttribI4ui(GLuint arg0, GLuint arg1, GLuint arg2, GLuint arg3, GLuint arg4) { - _pre_call_callback("glVertexAttribI4ui", (void*)glVertexAttribI4ui, 5, arg0, arg1, arg2, arg3, arg4); - glad_glVertexAttribI4ui(arg0, arg1, arg2, arg3, arg4); - _post_call_callback("glVertexAttribI4ui", (void*)glVertexAttribI4ui, 5, arg0, arg1, arg2, arg3, arg4); - -} -PFNGLVERTEXATTRIBI4UIPROC glad_debug_glVertexAttribI4ui = glad_debug_impl_glVertexAttribI4ui; PFNGLCOLORMASKPROC glad_glColorMask; -void APIENTRY glad_debug_impl_glColorMask(GLboolean arg0, GLboolean arg1, GLboolean arg2, GLboolean arg3) { - _pre_call_callback("glColorMask", (void*)glColorMask, 4, arg0, arg1, arg2, arg3); - glad_glColorMask(arg0, arg1, arg2, arg3); - _post_call_callback("glColorMask", (void*)glColorMask, 4, arg0, arg1, arg2, arg3); - -} -PFNGLCOLORMASKPROC glad_debug_glColorMask = glad_debug_impl_glColorMask; PFNGLTEXPARAMETERIIVPROC glad_glTexParameterIiv; -void APIENTRY glad_debug_impl_glTexParameterIiv(GLenum arg0, GLenum arg1, const GLint * arg2) { - _pre_call_callback("glTexParameterIiv", (void*)glTexParameterIiv, 3, arg0, arg1, arg2); - glad_glTexParameterIiv(arg0, arg1, arg2); - _post_call_callback("glTexParameterIiv", (void*)glTexParameterIiv, 3, arg0, arg1, arg2); - -} -PFNGLTEXPARAMETERIIVPROC glad_debug_glTexParameterIiv = glad_debug_impl_glTexParameterIiv; PFNGLBLENDEQUATIONPROC glad_glBlendEquation; -void APIENTRY glad_debug_impl_glBlendEquation(GLenum arg0) { - _pre_call_callback("glBlendEquation", (void*)glBlendEquation, 1, arg0); - glad_glBlendEquation(arg0); - _post_call_callback("glBlendEquation", (void*)glBlendEquation, 1, arg0); - -} -PFNGLBLENDEQUATIONPROC glad_debug_glBlendEquation = glad_debug_impl_glBlendEquation; PFNGLGETUNIFORMLOCATIONPROC glad_glGetUniformLocation; -GLint APIENTRY glad_debug_impl_glGetUniformLocation(GLuint arg0, const GLchar * arg1) { - GLint ret; - _pre_call_callback("glGetUniformLocation", (void*)glGetUniformLocation, 2, arg0, arg1); - ret = glad_glGetUniformLocation(arg0, arg1); - _post_call_callback("glGetUniformLocation", (void*)glGetUniformLocation, 2, arg0, arg1); - return ret; -} -PFNGLGETUNIFORMLOCATIONPROC glad_debug_glGetUniformLocation = glad_debug_impl_glGetUniformLocation; PFNGLENDTRANSFORMFEEDBACKPROC glad_glEndTransformFeedback; -void APIENTRY glad_debug_impl_glEndTransformFeedback() { - _pre_call_callback("glEndTransformFeedback", (void*)glEndTransformFeedback, 0); - glad_glEndTransformFeedback(); - _post_call_callback("glEndTransformFeedback", (void*)glEndTransformFeedback, 0); - -} -PFNGLENDTRANSFORMFEEDBACKPROC glad_debug_glEndTransformFeedback = glad_debug_impl_glEndTransformFeedback; PFNGLVERTEXATTRIB4USVPROC glad_glVertexAttrib4usv; -void APIENTRY glad_debug_impl_glVertexAttrib4usv(GLuint arg0, const GLushort * arg1) { - _pre_call_callback("glVertexAttrib4usv", (void*)glVertexAttrib4usv, 2, arg0, arg1); - glad_glVertexAttrib4usv(arg0, arg1); - _post_call_callback("glVertexAttrib4usv", (void*)glVertexAttrib4usv, 2, arg0, arg1); - -} -PFNGLVERTEXATTRIB4USVPROC glad_debug_glVertexAttrib4usv = glad_debug_impl_glVertexAttrib4usv; PFNGLUNIFORM4FVPROC glad_glUniform4fv; -void APIENTRY glad_debug_impl_glUniform4fv(GLint arg0, GLsizei arg1, const GLfloat * arg2) { - _pre_call_callback("glUniform4fv", (void*)glUniform4fv, 3, arg0, arg1, arg2); - glad_glUniform4fv(arg0, arg1, arg2); - _post_call_callback("glUniform4fv", (void*)glUniform4fv, 3, arg0, arg1, arg2); - -} -PFNGLUNIFORM4FVPROC glad_debug_glUniform4fv = glad_debug_impl_glUniform4fv; PFNGLBEGINTRANSFORMFEEDBACKPROC glad_glBeginTransformFeedback; -void APIENTRY glad_debug_impl_glBeginTransformFeedback(GLenum arg0) { - _pre_call_callback("glBeginTransformFeedback", (void*)glBeginTransformFeedback, 1, arg0); - glad_glBeginTransformFeedback(arg0); - _post_call_callback("glBeginTransformFeedback", (void*)glBeginTransformFeedback, 1, arg0); - -} -PFNGLBEGINTRANSFORMFEEDBACKPROC glad_debug_glBeginTransformFeedback = glad_debug_impl_glBeginTransformFeedback; PFNGLVERTEXATTRIBI1IVPROC glad_glVertexAttribI1iv; -void APIENTRY glad_debug_impl_glVertexAttribI1iv(GLuint arg0, const GLint * arg1) { - _pre_call_callback("glVertexAttribI1iv", (void*)glVertexAttribI1iv, 2, arg0, arg1); - glad_glVertexAttribI1iv(arg0, arg1); - _post_call_callback("glVertexAttribI1iv", (void*)glVertexAttribI1iv, 2, arg0, arg1); - -} -PFNGLVERTEXATTRIBI1IVPROC glad_debug_glVertexAttribI1iv = glad_debug_impl_glVertexAttribI1iv; PFNGLISSAMPLERPROC glad_glIsSampler; -GLboolean APIENTRY glad_debug_impl_glIsSampler(GLuint arg0) { - GLboolean ret; - _pre_call_callback("glIsSampler", (void*)glIsSampler, 1, arg0); - ret = glad_glIsSampler(arg0); - _post_call_callback("glIsSampler", (void*)glIsSampler, 1, arg0); - return ret; -} -PFNGLISSAMPLERPROC glad_debug_glIsSampler = glad_debug_impl_glIsSampler; PFNGLVERTEXP3UIPROC glad_glVertexP3ui; -void APIENTRY glad_debug_impl_glVertexP3ui(GLenum arg0, GLuint arg1) { - _pre_call_callback("glVertexP3ui", (void*)glVertexP3ui, 2, arg0, arg1); - glad_glVertexP3ui(arg0, arg1); - _post_call_callback("glVertexP3ui", (void*)glVertexP3ui, 2, arg0, arg1); - -} -PFNGLVERTEXP3UIPROC glad_debug_glVertexP3ui = glad_debug_impl_glVertexP3ui; PFNGLVERTEXATTRIBDIVISORPROC glad_glVertexAttribDivisor; -void APIENTRY glad_debug_impl_glVertexAttribDivisor(GLuint arg0, GLuint arg1) { - _pre_call_callback("glVertexAttribDivisor", (void*)glVertexAttribDivisor, 2, arg0, arg1); - glad_glVertexAttribDivisor(arg0, arg1); - _post_call_callback("glVertexAttribDivisor", (void*)glVertexAttribDivisor, 2, arg0, arg1); - -} -PFNGLVERTEXATTRIBDIVISORPROC glad_debug_glVertexAttribDivisor = glad_debug_impl_glVertexAttribDivisor; PFNGLCOMPRESSEDTEXIMAGE1DPROC glad_glCompressedTexImage1D; -void APIENTRY glad_debug_impl_glCompressedTexImage1D(GLenum arg0, GLint arg1, GLenum arg2, GLsizei arg3, GLint arg4, GLsizei arg5, const void * arg6) { - _pre_call_callback("glCompressedTexImage1D", (void*)glCompressedTexImage1D, 7, arg0, arg1, arg2, arg3, arg4, arg5, arg6); - glad_glCompressedTexImage1D(arg0, arg1, arg2, arg3, arg4, arg5, arg6); - _post_call_callback("glCompressedTexImage1D", (void*)glCompressedTexImage1D, 7, arg0, arg1, arg2, arg3, arg4, arg5, arg6); - -} -PFNGLCOMPRESSEDTEXIMAGE1DPROC glad_debug_glCompressedTexImage1D = glad_debug_impl_glCompressedTexImage1D; PFNGLCOPYTEXSUBIMAGE1DPROC glad_glCopyTexSubImage1D; -void APIENTRY glad_debug_impl_glCopyTexSubImage1D(GLenum arg0, GLint arg1, GLint arg2, GLint arg3, GLint arg4, GLsizei arg5) { - _pre_call_callback("glCopyTexSubImage1D", (void*)glCopyTexSubImage1D, 6, arg0, arg1, arg2, arg3, arg4, arg5); - glad_glCopyTexSubImage1D(arg0, arg1, arg2, arg3, arg4, arg5); - _post_call_callback("glCopyTexSubImage1D", (void*)glCopyTexSubImage1D, 6, arg0, arg1, arg2, arg3, arg4, arg5); - -} -PFNGLCOPYTEXSUBIMAGE1DPROC glad_debug_glCopyTexSubImage1D = glad_debug_impl_glCopyTexSubImage1D; PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC glad_glDrawRangeElementsBaseVertex; -void APIENTRY glad_debug_impl_glDrawRangeElementsBaseVertex(GLenum arg0, GLuint arg1, GLuint arg2, GLsizei arg3, GLenum arg4, const void * arg5, GLint arg6) { - _pre_call_callback("glDrawRangeElementsBaseVertex", (void*)glDrawRangeElementsBaseVertex, 7, arg0, arg1, arg2, arg3, arg4, arg5, arg6); - glad_glDrawRangeElementsBaseVertex(arg0, arg1, arg2, arg3, arg4, arg5, arg6); - _post_call_callback("glDrawRangeElementsBaseVertex", (void*)glDrawRangeElementsBaseVertex, 7, arg0, arg1, arg2, arg3, arg4, arg5, arg6); - -} -PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC glad_debug_glDrawRangeElementsBaseVertex = glad_debug_impl_glDrawRangeElementsBaseVertex; PFNGLCHECKFRAMEBUFFERSTATUSPROC glad_glCheckFramebufferStatus; -GLenum APIENTRY glad_debug_impl_glCheckFramebufferStatus(GLenum arg0) { - GLenum ret; - _pre_call_callback("glCheckFramebufferStatus", (void*)glCheckFramebufferStatus, 1, arg0); - ret = glad_glCheckFramebufferStatus(arg0); - _post_call_callback("glCheckFramebufferStatus", (void*)glCheckFramebufferStatus, 1, arg0); - return ret; -} -PFNGLCHECKFRAMEBUFFERSTATUSPROC glad_debug_glCheckFramebufferStatus = glad_debug_impl_glCheckFramebufferStatus; PFNGLENDCONDITIONALRENDERPROC glad_glEndConditionalRender; -void APIENTRY glad_debug_impl_glEndConditionalRender() { - _pre_call_callback("glEndConditionalRender", (void*)glEndConditionalRender, 0); - glad_glEndConditionalRender(); - _post_call_callback("glEndConditionalRender", (void*)glEndConditionalRender, 0); - -} -PFNGLENDCONDITIONALRENDERPROC glad_debug_glEndConditionalRender = glad_debug_impl_glEndConditionalRender; PFNGLVERTEXP3UIVPROC glad_glVertexP3uiv; -void APIENTRY glad_debug_impl_glVertexP3uiv(GLenum arg0, const GLuint * arg1) { - _pre_call_callback("glVertexP3uiv", (void*)glVertexP3uiv, 2, arg0, arg1); - glad_glVertexP3uiv(arg0, arg1); - _post_call_callback("glVertexP3uiv", (void*)glVertexP3uiv, 2, arg0, arg1); - -} -PFNGLVERTEXP3UIVPROC glad_debug_glVertexP3uiv = glad_debug_impl_glVertexP3uiv; PFNGLBINDATTRIBLOCATIONPROC glad_glBindAttribLocation; -void APIENTRY glad_debug_impl_glBindAttribLocation(GLuint arg0, GLuint arg1, const GLchar * arg2) { - _pre_call_callback("glBindAttribLocation", (void*)glBindAttribLocation, 3, arg0, arg1, arg2); - glad_glBindAttribLocation(arg0, arg1, arg2); - _post_call_callback("glBindAttribLocation", (void*)glBindAttribLocation, 3, arg0, arg1, arg2); - -} -PFNGLBINDATTRIBLOCATIONPROC glad_debug_glBindAttribLocation = glad_debug_impl_glBindAttribLocation; PFNGLUNIFORMMATRIX4X2FVPROC glad_glUniformMatrix4x2fv; -void APIENTRY glad_debug_impl_glUniformMatrix4x2fv(GLint arg0, GLsizei arg1, GLboolean arg2, const GLfloat * arg3) { - _pre_call_callback("glUniformMatrix4x2fv", (void*)glUniformMatrix4x2fv, 4, arg0, arg1, arg2, arg3); - glad_glUniformMatrix4x2fv(arg0, arg1, arg2, arg3); - _post_call_callback("glUniformMatrix4x2fv", (void*)glUniformMatrix4x2fv, 4, arg0, arg1, arg2, arg3); - -} -PFNGLUNIFORMMATRIX4X2FVPROC glad_debug_glUniformMatrix4x2fv = glad_debug_impl_glUniformMatrix4x2fv; PFNGLVERTEXATTRIB1DVPROC glad_glVertexAttrib1dv; -void APIENTRY glad_debug_impl_glVertexAttrib1dv(GLuint arg0, const GLdouble * arg1) { - _pre_call_callback("glVertexAttrib1dv", (void*)glVertexAttrib1dv, 2, arg0, arg1); - glad_glVertexAttrib1dv(arg0, arg1); - _post_call_callback("glVertexAttrib1dv", (void*)glVertexAttrib1dv, 2, arg0, arg1); - -} -PFNGLVERTEXATTRIB1DVPROC glad_debug_glVertexAttrib1dv = glad_debug_impl_glVertexAttrib1dv; PFNGLDRAWRANGEELEMENTSPROC glad_glDrawRangeElements; -void APIENTRY glad_debug_impl_glDrawRangeElements(GLenum arg0, GLuint arg1, GLuint arg2, GLsizei arg3, GLenum arg4, const void * arg5) { - _pre_call_callback("glDrawRangeElements", (void*)glDrawRangeElements, 6, arg0, arg1, arg2, arg3, arg4, arg5); - glad_glDrawRangeElements(arg0, arg1, arg2, arg3, arg4, arg5); - _post_call_callback("glDrawRangeElements", (void*)glDrawRangeElements, 6, arg0, arg1, arg2, arg3, arg4, arg5); - -} -PFNGLDRAWRANGEELEMENTSPROC glad_debug_glDrawRangeElements = glad_debug_impl_glDrawRangeElements; PFNGLGETQUERYOBJECTUIVPROC glad_glGetQueryObjectuiv; -void APIENTRY glad_debug_impl_glGetQueryObjectuiv(GLuint arg0, GLenum arg1, GLuint * arg2) { - _pre_call_callback("glGetQueryObjectuiv", (void*)glGetQueryObjectuiv, 3, arg0, arg1, arg2); - glad_glGetQueryObjectuiv(arg0, arg1, arg2); - _post_call_callback("glGetQueryObjectuiv", (void*)glGetQueryObjectuiv, 3, arg0, arg1, arg2); - -} -PFNGLGETQUERYOBJECTUIVPROC glad_debug_glGetQueryObjectuiv = glad_debug_impl_glGetQueryObjectuiv; PFNGLBINDBUFFERBASEPROC glad_glBindBufferBase; -void APIENTRY glad_debug_impl_glBindBufferBase(GLenum arg0, GLuint arg1, GLuint arg2) { - _pre_call_callback("glBindBufferBase", (void*)glBindBufferBase, 3, arg0, arg1, arg2); - glad_glBindBufferBase(arg0, arg1, arg2); - _post_call_callback("glBindBufferBase", (void*)glBindBufferBase, 3, arg0, arg1, arg2); - -} -PFNGLBINDBUFFERBASEPROC glad_debug_glBindBufferBase = glad_debug_impl_glBindBufferBase; PFNGLBUFFERSUBDATAPROC glad_glBufferSubData; -void APIENTRY glad_debug_impl_glBufferSubData(GLenum arg0, GLintptr arg1, GLsizeiptr arg2, const void * arg3) { - _pre_call_callback("glBufferSubData", (void*)glBufferSubData, 4, arg0, arg1, arg2, arg3); - glad_glBufferSubData(arg0, arg1, arg2, arg3); - _post_call_callback("glBufferSubData", (void*)glBufferSubData, 4, arg0, arg1, arg2, arg3); - -} -PFNGLBUFFERSUBDATAPROC glad_debug_glBufferSubData = glad_debug_impl_glBufferSubData; PFNGLVERTEXATTRIB4IVPROC glad_glVertexAttrib4iv; -void APIENTRY glad_debug_impl_glVertexAttrib4iv(GLuint arg0, const GLint * arg1) { - _pre_call_callback("glVertexAttrib4iv", (void*)glVertexAttrib4iv, 2, arg0, arg1); - glad_glVertexAttrib4iv(arg0, arg1); - _post_call_callback("glVertexAttrib4iv", (void*)glVertexAttrib4iv, 2, arg0, arg1); - -} -PFNGLVERTEXATTRIB4IVPROC glad_debug_glVertexAttrib4iv = glad_debug_impl_glVertexAttrib4iv; PFNGLMAPBUFFERRANGEPROC glad_glMapBufferRange; -void * APIENTRY glad_debug_impl_glMapBufferRange(GLenum arg0, GLintptr arg1, GLsizeiptr arg2, GLbitfield arg3) { - void * ret; - _pre_call_callback("glMapBufferRange", (void*)glMapBufferRange, 4, arg0, arg1, arg2, arg3); - ret = glad_glMapBufferRange(arg0, arg1, arg2, arg3); - _post_call_callback("glMapBufferRange", (void*)glMapBufferRange, 4, arg0, arg1, arg2, arg3); - return ret; -} -PFNGLMAPBUFFERRANGEPROC glad_debug_glMapBufferRange = glad_debug_impl_glMapBufferRange; PFNGLFRAMEBUFFERTEXTUREPROC glad_glFramebufferTexture; -void APIENTRY glad_debug_impl_glFramebufferTexture(GLenum arg0, GLenum arg1, GLuint arg2, GLint arg3) { - _pre_call_callback("glFramebufferTexture", (void*)glFramebufferTexture, 4, arg0, arg1, arg2, arg3); - glad_glFramebufferTexture(arg0, arg1, arg2, arg3); - _post_call_callback("glFramebufferTexture", (void*)glFramebufferTexture, 4, arg0, arg1, arg2, arg3); - -} -PFNGLFRAMEBUFFERTEXTUREPROC glad_debug_glFramebufferTexture = glad_debug_impl_glFramebufferTexture; PFNGLMULTIDRAWARRAYSPROC glad_glMultiDrawArrays; -void APIENTRY glad_debug_impl_glMultiDrawArrays(GLenum arg0, const GLint * arg1, const GLsizei * arg2, GLsizei arg3) { - _pre_call_callback("glMultiDrawArrays", (void*)glMultiDrawArrays, 4, arg0, arg1, arg2, arg3); - glad_glMultiDrawArrays(arg0, arg1, arg2, arg3); - _post_call_callback("glMultiDrawArrays", (void*)glMultiDrawArrays, 4, arg0, arg1, arg2, arg3); - -} -PFNGLMULTIDRAWARRAYSPROC glad_debug_glMultiDrawArrays = glad_debug_impl_glMultiDrawArrays; PFNGLVERTEXP4UIVPROC glad_glVertexP4uiv; -void APIENTRY glad_debug_impl_glVertexP4uiv(GLenum arg0, const GLuint * arg1) { - _pre_call_callback("glVertexP4uiv", (void*)glVertexP4uiv, 2, arg0, arg1); - glad_glVertexP4uiv(arg0, arg1); - _post_call_callback("glVertexP4uiv", (void*)glVertexP4uiv, 2, arg0, arg1); - -} -PFNGLVERTEXP4UIVPROC glad_debug_glVertexP4uiv = glad_debug_impl_glVertexP4uiv; PFNGLVERTEXATTRIBI2IVPROC glad_glVertexAttribI2iv; -void APIENTRY glad_debug_impl_glVertexAttribI2iv(GLuint arg0, const GLint * arg1) { - _pre_call_callback("glVertexAttribI2iv", (void*)glVertexAttribI2iv, 2, arg0, arg1); - glad_glVertexAttribI2iv(arg0, arg1); - _post_call_callback("glVertexAttribI2iv", (void*)glVertexAttribI2iv, 2, arg0, arg1); - -} -PFNGLVERTEXATTRIBI2IVPROC glad_debug_glVertexAttribI2iv = glad_debug_impl_glVertexAttribI2iv; PFNGLDISABLEIPROC glad_glDisablei; -void APIENTRY glad_debug_impl_glDisablei(GLenum arg0, GLuint arg1) { - _pre_call_callback("glDisablei", (void*)glDisablei, 2, arg0, arg1); - glad_glDisablei(arg0, arg1); - _post_call_callback("glDisablei", (void*)glDisablei, 2, arg0, arg1); - -} -PFNGLDISABLEIPROC glad_debug_glDisablei = glad_debug_impl_glDisablei; PFNGLSHADERSOURCEPROC glad_glShaderSource; -void APIENTRY glad_debug_impl_glShaderSource(GLuint arg0, GLsizei arg1, const GLchar *const* arg2, const GLint * arg3) { - _pre_call_callback("glShaderSource", (void*)glShaderSource, 4, arg0, arg1, arg2, arg3); - glad_glShaderSource(arg0, arg1, arg2, arg3); - _post_call_callback("glShaderSource", (void*)glShaderSource, 4, arg0, arg1, arg2, arg3); - -} -PFNGLSHADERSOURCEPROC glad_debug_glShaderSource = glad_debug_impl_glShaderSource; PFNGLDELETERENDERBUFFERSPROC glad_glDeleteRenderbuffers; -void APIENTRY glad_debug_impl_glDeleteRenderbuffers(GLsizei arg0, const GLuint * arg1) { - _pre_call_callback("glDeleteRenderbuffers", (void*)glDeleteRenderbuffers, 2, arg0, arg1); - glad_glDeleteRenderbuffers(arg0, arg1); - _post_call_callback("glDeleteRenderbuffers", (void*)glDeleteRenderbuffers, 2, arg0, arg1); - -} -PFNGLDELETERENDERBUFFERSPROC glad_debug_glDeleteRenderbuffers = glad_debug_impl_glDeleteRenderbuffers; PFNGLVERTEXATTRIBI3UIVPROC glad_glVertexAttribI3uiv; -void APIENTRY glad_debug_impl_glVertexAttribI3uiv(GLuint arg0, const GLuint * arg1) { - _pre_call_callback("glVertexAttribI3uiv", (void*)glVertexAttribI3uiv, 2, arg0, arg1); - glad_glVertexAttribI3uiv(arg0, arg1); - _post_call_callback("glVertexAttribI3uiv", (void*)glVertexAttribI3uiv, 2, arg0, arg1); - -} -PFNGLVERTEXATTRIBI3UIVPROC glad_debug_glVertexAttribI3uiv = glad_debug_impl_glVertexAttribI3uiv; PFNGLGETSYNCIVPROC glad_glGetSynciv; -void APIENTRY glad_debug_impl_glGetSynciv(GLsync arg0, GLenum arg1, GLsizei arg2, GLsizei * arg3, GLint * arg4) { - _pre_call_callback("glGetSynciv", (void*)glGetSynciv, 5, arg0, arg1, arg2, arg3, arg4); - glad_glGetSynciv(arg0, arg1, arg2, arg3, arg4); - _post_call_callback("glGetSynciv", (void*)glGetSynciv, 5, arg0, arg1, arg2, arg3, arg4); - -} -PFNGLGETSYNCIVPROC glad_debug_glGetSynciv = glad_debug_impl_glGetSynciv; PFNGLTEXCOORDP2UIVPROC glad_glTexCoordP2uiv; -void APIENTRY glad_debug_impl_glTexCoordP2uiv(GLenum arg0, const GLuint * arg1) { - _pre_call_callback("glTexCoordP2uiv", (void*)glTexCoordP2uiv, 2, arg0, arg1); - glad_glTexCoordP2uiv(arg0, arg1); - _post_call_callback("glTexCoordP2uiv", (void*)glTexCoordP2uiv, 2, arg0, arg1); - -} -PFNGLTEXCOORDP2UIVPROC glad_debug_glTexCoordP2uiv = glad_debug_impl_glTexCoordP2uiv; PFNGLBEGINQUERYPROC glad_glBeginQuery; -void APIENTRY glad_debug_impl_glBeginQuery(GLenum arg0, GLuint arg1) { - _pre_call_callback("glBeginQuery", (void*)glBeginQuery, 2, arg0, arg1); - glad_glBeginQuery(arg0, arg1); - _post_call_callback("glBeginQuery", (void*)glBeginQuery, 2, arg0, arg1); - -} -PFNGLBEGINQUERYPROC glad_debug_glBeginQuery = glad_debug_impl_glBeginQuery; PFNGLUNIFORMMATRIX4FVPROC glad_glUniformMatrix4fv; -void APIENTRY glad_debug_impl_glUniformMatrix4fv(GLint arg0, GLsizei arg1, GLboolean arg2, const GLfloat * arg3) { - _pre_call_callback("glUniformMatrix4fv", (void*)glUniformMatrix4fv, 4, arg0, arg1, arg2, arg3); - glad_glUniformMatrix4fv(arg0, arg1, arg2, arg3); - _post_call_callback("glUniformMatrix4fv", (void*)glUniformMatrix4fv, 4, arg0, arg1, arg2, arg3); - -} -PFNGLUNIFORMMATRIX4FVPROC glad_debug_glUniformMatrix4fv = glad_debug_impl_glUniformMatrix4fv; PFNGLBINDBUFFERPROC glad_glBindBuffer; -void APIENTRY glad_debug_impl_glBindBuffer(GLenum arg0, GLuint arg1) { - _pre_call_callback("glBindBuffer", (void*)glBindBuffer, 2, arg0, arg1); - glad_glBindBuffer(arg0, arg1); - _post_call_callback("glBindBuffer", (void*)glBindBuffer, 2, arg0, arg1); - -} -PFNGLBINDBUFFERPROC glad_debug_glBindBuffer = glad_debug_impl_glBindBuffer; PFNGLUNIFORMMATRIX2FVPROC glad_glUniformMatrix2fv; -void APIENTRY glad_debug_impl_glUniformMatrix2fv(GLint arg0, GLsizei arg1, GLboolean arg2, const GLfloat * arg3) { - _pre_call_callback("glUniformMatrix2fv", (void*)glUniformMatrix2fv, 4, arg0, arg1, arg2, arg3); - glad_glUniformMatrix2fv(arg0, arg1, arg2, arg3); - _post_call_callback("glUniformMatrix2fv", (void*)glUniformMatrix2fv, 4, arg0, arg1, arg2, arg3); - -} -PFNGLUNIFORMMATRIX2FVPROC glad_debug_glUniformMatrix2fv = glad_debug_impl_glUniformMatrix2fv; PFNGLUNIFORMMATRIX2X4FVPROC glad_glUniformMatrix2x4fv; -void APIENTRY glad_debug_impl_glUniformMatrix2x4fv(GLint arg0, GLsizei arg1, GLboolean arg2, const GLfloat * arg3) { - _pre_call_callback("glUniformMatrix2x4fv", (void*)glUniformMatrix2x4fv, 4, arg0, arg1, arg2, arg3); - glad_glUniformMatrix2x4fv(arg0, arg1, arg2, arg3); - _post_call_callback("glUniformMatrix2x4fv", (void*)glUniformMatrix2x4fv, 4, arg0, arg1, arg2, arg3); - -} -PFNGLUNIFORMMATRIX2X4FVPROC glad_debug_glUniformMatrix2x4fv = glad_debug_impl_glUniformMatrix2x4fv; PFNGLBUFFERDATAPROC glad_glBufferData; -void APIENTRY glad_debug_impl_glBufferData(GLenum arg0, GLsizeiptr arg1, const void * arg2, GLenum arg3) { - _pre_call_callback("glBufferData", (void*)glBufferData, 4, arg0, arg1, arg2, arg3); - glad_glBufferData(arg0, arg1, arg2, arg3); - _post_call_callback("glBufferData", (void*)glBufferData, 4, arg0, arg1, arg2, arg3); - -} -PFNGLBUFFERDATAPROC glad_debug_glBufferData = glad_debug_impl_glBufferData; PFNGLGETTEXPARAMETERIIVPROC glad_glGetTexParameterIiv; -void APIENTRY glad_debug_impl_glGetTexParameterIiv(GLenum arg0, GLenum arg1, GLint * arg2) { - _pre_call_callback("glGetTexParameterIiv", (void*)glGetTexParameterIiv, 3, arg0, arg1, arg2); - glad_glGetTexParameterIiv(arg0, arg1, arg2); - _post_call_callback("glGetTexParameterIiv", (void*)glGetTexParameterIiv, 3, arg0, arg1, arg2); - -} -PFNGLGETTEXPARAMETERIIVPROC glad_debug_glGetTexParameterIiv = glad_debug_impl_glGetTexParameterIiv; PFNGLTEXCOORDP1UIPROC glad_glTexCoordP1ui; -void APIENTRY glad_debug_impl_glTexCoordP1ui(GLenum arg0, GLuint arg1) { - _pre_call_callback("glTexCoordP1ui", (void*)glTexCoordP1ui, 2, arg0, arg1); - glad_glTexCoordP1ui(arg0, arg1); - _post_call_callback("glTexCoordP1ui", (void*)glTexCoordP1ui, 2, arg0, arg1); - -} -PFNGLTEXCOORDP1UIPROC glad_debug_glTexCoordP1ui = glad_debug_impl_glTexCoordP1ui; PFNGLGETERRORPROC glad_glGetError; -GLenum APIENTRY glad_debug_impl_glGetError() { - GLenum ret; - _pre_call_callback("glGetError", (void*)glGetError, 0); - ret = glad_glGetError(); - _post_call_callback("glGetError", (void*)glGetError, 0); - return ret; -} -PFNGLGETERRORPROC glad_debug_glGetError = glad_debug_impl_glGetError; PFNGLVERTEXATTRIBP2UIPROC glad_glVertexAttribP2ui; -void APIENTRY glad_debug_impl_glVertexAttribP2ui(GLuint arg0, GLenum arg1, GLboolean arg2, GLuint arg3) { - _pre_call_callback("glVertexAttribP2ui", (void*)glVertexAttribP2ui, 4, arg0, arg1, arg2, arg3); - glad_glVertexAttribP2ui(arg0, arg1, arg2, arg3); - _post_call_callback("glVertexAttribP2ui", (void*)glVertexAttribP2ui, 4, arg0, arg1, arg2, arg3); - -} -PFNGLVERTEXATTRIBP2UIPROC glad_debug_glVertexAttribP2ui = glad_debug_impl_glVertexAttribP2ui; PFNGLGETFLOATVPROC glad_glGetFloatv; -void APIENTRY glad_debug_impl_glGetFloatv(GLenum arg0, GLfloat * arg1) { - _pre_call_callback("glGetFloatv", (void*)glGetFloatv, 2, arg0, arg1); - glad_glGetFloatv(arg0, arg1); - _post_call_callback("glGetFloatv", (void*)glGetFloatv, 2, arg0, arg1); - -} -PFNGLGETFLOATVPROC glad_debug_glGetFloatv = glad_debug_impl_glGetFloatv; PFNGLTEXSUBIMAGE1DPROC glad_glTexSubImage1D; -void APIENTRY glad_debug_impl_glTexSubImage1D(GLenum arg0, GLint arg1, GLint arg2, GLsizei arg3, GLenum arg4, GLenum arg5, const void * arg6) { - _pre_call_callback("glTexSubImage1D", (void*)glTexSubImage1D, 7, arg0, arg1, arg2, arg3, arg4, arg5, arg6); - glad_glTexSubImage1D(arg0, arg1, arg2, arg3, arg4, arg5, arg6); - _post_call_callback("glTexSubImage1D", (void*)glTexSubImage1D, 7, arg0, arg1, arg2, arg3, arg4, arg5, arg6); - -} -PFNGLTEXSUBIMAGE1DPROC glad_debug_glTexSubImage1D = glad_debug_impl_glTexSubImage1D; PFNGLVERTEXATTRIB2FVPROC glad_glVertexAttrib2fv; -void APIENTRY glad_debug_impl_glVertexAttrib2fv(GLuint arg0, const GLfloat * arg1) { - _pre_call_callback("glVertexAttrib2fv", (void*)glVertexAttrib2fv, 2, arg0, arg1); - glad_glVertexAttrib2fv(arg0, arg1); - _post_call_callback("glVertexAttrib2fv", (void*)glVertexAttrib2fv, 2, arg0, arg1); - -} -PFNGLVERTEXATTRIB2FVPROC glad_debug_glVertexAttrib2fv = glad_debug_impl_glVertexAttrib2fv; PFNGLGETTEXLEVELPARAMETERFVPROC glad_glGetTexLevelParameterfv; -void APIENTRY glad_debug_impl_glGetTexLevelParameterfv(GLenum arg0, GLint arg1, GLenum arg2, GLfloat * arg3) { - _pre_call_callback("glGetTexLevelParameterfv", (void*)glGetTexLevelParameterfv, 4, arg0, arg1, arg2, arg3); - glad_glGetTexLevelParameterfv(arg0, arg1, arg2, arg3); - _post_call_callback("glGetTexLevelParameterfv", (void*)glGetTexLevelParameterfv, 4, arg0, arg1, arg2, arg3); - -} -PFNGLGETTEXLEVELPARAMETERFVPROC glad_debug_glGetTexLevelParameterfv = glad_debug_impl_glGetTexLevelParameterfv; PFNGLVERTEXATTRIBI1IPROC glad_glVertexAttribI1i; -void APIENTRY glad_debug_impl_glVertexAttribI1i(GLuint arg0, GLint arg1) { - _pre_call_callback("glVertexAttribI1i", (void*)glVertexAttribI1i, 2, arg0, arg1); - glad_glVertexAttribI1i(arg0, arg1); - _post_call_callback("glVertexAttribI1i", (void*)glVertexAttribI1i, 2, arg0, arg1); - -} -PFNGLVERTEXATTRIBI1IPROC glad_debug_glVertexAttribI1i = glad_debug_impl_glVertexAttribI1i; PFNGLVERTEXATTRIBP3UIVPROC glad_glVertexAttribP3uiv; -void APIENTRY glad_debug_impl_glVertexAttribP3uiv(GLuint arg0, GLenum arg1, GLboolean arg2, const GLuint * arg3) { - _pre_call_callback("glVertexAttribP3uiv", (void*)glVertexAttribP3uiv, 4, arg0, arg1, arg2, arg3); - glad_glVertexAttribP3uiv(arg0, arg1, arg2, arg3); - _post_call_callback("glVertexAttribP3uiv", (void*)glVertexAttribP3uiv, 4, arg0, arg1, arg2, arg3); - -} -PFNGLVERTEXATTRIBP3UIVPROC glad_debug_glVertexAttribP3uiv = glad_debug_impl_glVertexAttribP3uiv; PFNGLSECONDARYCOLORP3UIVPROC glad_glSecondaryColorP3uiv; -void APIENTRY glad_debug_impl_glSecondaryColorP3uiv(GLenum arg0, const GLuint * arg1) { - _pre_call_callback("glSecondaryColorP3uiv", (void*)glSecondaryColorP3uiv, 2, arg0, arg1); - glad_glSecondaryColorP3uiv(arg0, arg1); - _post_call_callback("glSecondaryColorP3uiv", (void*)glSecondaryColorP3uiv, 2, arg0, arg1); - -} -PFNGLSECONDARYCOLORP3UIVPROC glad_debug_glSecondaryColorP3uiv = glad_debug_impl_glSecondaryColorP3uiv; PFNGLGETINTEGERVPROC glad_glGetIntegerv; -void APIENTRY glad_debug_impl_glGetIntegerv(GLenum arg0, GLint * arg1) { - _pre_call_callback("glGetIntegerv", (void*)glGetIntegerv, 2, arg0, arg1); - glad_glGetIntegerv(arg0, arg1); - _post_call_callback("glGetIntegerv", (void*)glGetIntegerv, 2, arg0, arg1); - -} -PFNGLGETINTEGERVPROC glad_debug_glGetIntegerv = glad_debug_impl_glGetIntegerv; PFNGLGETBUFFERPOINTERVPROC glad_glGetBufferPointerv; -void APIENTRY glad_debug_impl_glGetBufferPointerv(GLenum arg0, GLenum arg1, void ** arg2) { - _pre_call_callback("glGetBufferPointerv", (void*)glGetBufferPointerv, 3, arg0, arg1, arg2); - glad_glGetBufferPointerv(arg0, arg1, arg2); - _post_call_callback("glGetBufferPointerv", (void*)glGetBufferPointerv, 3, arg0, arg1, arg2); - -} -PFNGLGETBUFFERPOINTERVPROC glad_debug_glGetBufferPointerv = glad_debug_impl_glGetBufferPointerv; PFNGLFRAMEBUFFERTEXTURE3DPROC glad_glFramebufferTexture3D; -void APIENTRY glad_debug_impl_glFramebufferTexture3D(GLenum arg0, GLenum arg1, GLenum arg2, GLuint arg3, GLint arg4, GLint arg5) { - _pre_call_callback("glFramebufferTexture3D", (void*)glFramebufferTexture3D, 6, arg0, arg1, arg2, arg3, arg4, arg5); - glad_glFramebufferTexture3D(arg0, arg1, arg2, arg3, arg4, arg5); - _post_call_callback("glFramebufferTexture3D", (void*)glFramebufferTexture3D, 6, arg0, arg1, arg2, arg3, arg4, arg5); - -} -PFNGLFRAMEBUFFERTEXTURE3DPROC glad_debug_glFramebufferTexture3D = glad_debug_impl_glFramebufferTexture3D; PFNGLISQUERYPROC glad_glIsQuery; -GLboolean APIENTRY glad_debug_impl_glIsQuery(GLuint arg0) { - GLboolean ret; - _pre_call_callback("glIsQuery", (void*)glIsQuery, 1, arg0); - ret = glad_glIsQuery(arg0); - _post_call_callback("glIsQuery", (void*)glIsQuery, 1, arg0); - return ret; -} -PFNGLISQUERYPROC glad_debug_glIsQuery = glad_debug_impl_glIsQuery; PFNGLVERTEXATTRIB4SVPROC glad_glVertexAttrib4sv; -void APIENTRY glad_debug_impl_glVertexAttrib4sv(GLuint arg0, const GLshort * arg1) { - _pre_call_callback("glVertexAttrib4sv", (void*)glVertexAttrib4sv, 2, arg0, arg1); - glad_glVertexAttrib4sv(arg0, arg1); - _post_call_callback("glVertexAttrib4sv", (void*)glVertexAttrib4sv, 2, arg0, arg1); - -} -PFNGLVERTEXATTRIB4SVPROC glad_debug_glVertexAttrib4sv = glad_debug_impl_glVertexAttrib4sv; PFNGLTEXIMAGE2DPROC glad_glTexImage2D; -void APIENTRY glad_debug_impl_glTexImage2D(GLenum arg0, GLint arg1, GLint arg2, GLsizei arg3, GLsizei arg4, GLint arg5, GLenum arg6, GLenum arg7, const void * arg8) { - _pre_call_callback("glTexImage2D", (void*)glTexImage2D, 9, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8); - glad_glTexImage2D(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8); - _post_call_callback("glTexImage2D", (void*)glTexImage2D, 9, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8); - -} -PFNGLTEXIMAGE2DPROC glad_debug_glTexImage2D = glad_debug_impl_glTexImage2D; PFNGLSTENCILMASKPROC glad_glStencilMask; -void APIENTRY glad_debug_impl_glStencilMask(GLuint arg0) { - _pre_call_callback("glStencilMask", (void*)glStencilMask, 1, arg0); - glad_glStencilMask(arg0); - _post_call_callback("glStencilMask", (void*)glStencilMask, 1, arg0); - -} -PFNGLSTENCILMASKPROC glad_debug_glStencilMask = glad_debug_impl_glStencilMask; PFNGLSAMPLERPARAMETERFVPROC glad_glSamplerParameterfv; -void APIENTRY glad_debug_impl_glSamplerParameterfv(GLuint arg0, GLenum arg1, const GLfloat * arg2) { - _pre_call_callback("glSamplerParameterfv", (void*)glSamplerParameterfv, 3, arg0, arg1, arg2); - glad_glSamplerParameterfv(arg0, arg1, arg2); - _post_call_callback("glSamplerParameterfv", (void*)glSamplerParameterfv, 3, arg0, arg1, arg2); - -} -PFNGLSAMPLERPARAMETERFVPROC glad_debug_glSamplerParameterfv = glad_debug_impl_glSamplerParameterfv; PFNGLISTEXTUREPROC glad_glIsTexture; -GLboolean APIENTRY glad_debug_impl_glIsTexture(GLuint arg0) { - GLboolean ret; - _pre_call_callback("glIsTexture", (void*)glIsTexture, 1, arg0); - ret = glad_glIsTexture(arg0); - _post_call_callback("glIsTexture", (void*)glIsTexture, 1, arg0); - return ret; -} -PFNGLISTEXTUREPROC glad_debug_glIsTexture = glad_debug_impl_glIsTexture; PFNGLUNIFORM1FVPROC glad_glUniform1fv; -void APIENTRY glad_debug_impl_glUniform1fv(GLint arg0, GLsizei arg1, const GLfloat * arg2) { - _pre_call_callback("glUniform1fv", (void*)glUniform1fv, 3, arg0, arg1, arg2); - glad_glUniform1fv(arg0, arg1, arg2); - _post_call_callback("glUniform1fv", (void*)glUniform1fv, 3, arg0, arg1, arg2); - -} -PFNGLUNIFORM1FVPROC glad_debug_glUniform1fv = glad_debug_impl_glUniform1fv; PFNGLVERTEXATTRIB4NUBVPROC glad_glVertexAttrib4Nubv; -void APIENTRY glad_debug_impl_glVertexAttrib4Nubv(GLuint arg0, const GLubyte * arg1) { - _pre_call_callback("glVertexAttrib4Nubv", (void*)glVertexAttrib4Nubv, 2, arg0, arg1); - glad_glVertexAttrib4Nubv(arg0, arg1); - _post_call_callback("glVertexAttrib4Nubv", (void*)glVertexAttrib4Nubv, 2, arg0, arg1); - -} -PFNGLVERTEXATTRIB4NUBVPROC glad_debug_glVertexAttrib4Nubv = glad_debug_impl_glVertexAttrib4Nubv; PFNGLTEXPARAMETERFVPROC glad_glTexParameterfv; -void APIENTRY glad_debug_impl_glTexParameterfv(GLenum arg0, GLenum arg1, const GLfloat * arg2) { - _pre_call_callback("glTexParameterfv", (void*)glTexParameterfv, 3, arg0, arg1, arg2); - glad_glTexParameterfv(arg0, arg1, arg2); - _post_call_callback("glTexParameterfv", (void*)glTexParameterfv, 3, arg0, arg1, arg2); - -} -PFNGLTEXPARAMETERFVPROC glad_debug_glTexParameterfv = glad_debug_impl_glTexParameterfv; PFNGLGETSAMPLERPARAMETERIVPROC glad_glGetSamplerParameteriv; -void APIENTRY glad_debug_impl_glGetSamplerParameteriv(GLuint arg0, GLenum arg1, GLint * arg2) { - _pre_call_callback("glGetSamplerParameteriv", (void*)glGetSamplerParameteriv, 3, arg0, arg1, arg2); - glad_glGetSamplerParameteriv(arg0, arg1, arg2); - _post_call_callback("glGetSamplerParameteriv", (void*)glGetSamplerParameteriv, 3, arg0, arg1, arg2); - -} -PFNGLGETSAMPLERPARAMETERIVPROC glad_debug_glGetSamplerParameteriv = glad_debug_impl_glGetSamplerParameteriv; PFNGLCOPYBUFFERSUBDATAPROC glad_glCopyBufferSubData; -void APIENTRY glad_debug_impl_glCopyBufferSubData(GLenum arg0, GLenum arg1, GLintptr arg2, GLintptr arg3, GLsizeiptr arg4) { - _pre_call_callback("glCopyBufferSubData", (void*)glCopyBufferSubData, 5, arg0, arg1, arg2, arg3, arg4); - glad_glCopyBufferSubData(arg0, arg1, arg2, arg3, arg4); - _post_call_callback("glCopyBufferSubData", (void*)glCopyBufferSubData, 5, arg0, arg1, arg2, arg3, arg4); - -} -PFNGLCOPYBUFFERSUBDATAPROC glad_debug_glCopyBufferSubData = glad_debug_impl_glCopyBufferSubData; PFNGLVERTEXATTRIBI1UIVPROC glad_glVertexAttribI1uiv; -void APIENTRY glad_debug_impl_glVertexAttribI1uiv(GLuint arg0, const GLuint * arg1) { - _pre_call_callback("glVertexAttribI1uiv", (void*)glVertexAttribI1uiv, 2, arg0, arg1); - glad_glVertexAttribI1uiv(arg0, arg1); - _post_call_callback("glVertexAttribI1uiv", (void*)glVertexAttribI1uiv, 2, arg0, arg1); - -} -PFNGLVERTEXATTRIBI1UIVPROC glad_debug_glVertexAttribI1uiv = glad_debug_impl_glVertexAttribI1uiv; PFNGLVERTEXATTRIB2DPROC glad_glVertexAttrib2d; -void APIENTRY glad_debug_impl_glVertexAttrib2d(GLuint arg0, GLdouble arg1, GLdouble arg2) { - _pre_call_callback("glVertexAttrib2d", (void*)glVertexAttrib2d, 3, arg0, arg1, arg2); - glad_glVertexAttrib2d(arg0, arg1, arg2); - _post_call_callback("glVertexAttrib2d", (void*)glVertexAttrib2d, 3, arg0, arg1, arg2); - -} -PFNGLVERTEXATTRIB2DPROC glad_debug_glVertexAttrib2d = glad_debug_impl_glVertexAttrib2d; PFNGLVERTEXATTRIB2FPROC glad_glVertexAttrib2f; -void APIENTRY glad_debug_impl_glVertexAttrib2f(GLuint arg0, GLfloat arg1, GLfloat arg2) { - _pre_call_callback("glVertexAttrib2f", (void*)glVertexAttrib2f, 3, arg0, arg1, arg2); - glad_glVertexAttrib2f(arg0, arg1, arg2); - _post_call_callback("glVertexAttrib2f", (void*)glVertexAttrib2f, 3, arg0, arg1, arg2); - -} -PFNGLVERTEXATTRIB2FPROC glad_debug_glVertexAttrib2f = glad_debug_impl_glVertexAttrib2f; PFNGLVERTEXATTRIB3DVPROC glad_glVertexAttrib3dv; -void APIENTRY glad_debug_impl_glVertexAttrib3dv(GLuint arg0, const GLdouble * arg1) { - _pre_call_callback("glVertexAttrib3dv", (void*)glVertexAttrib3dv, 2, arg0, arg1); - glad_glVertexAttrib3dv(arg0, arg1); - _post_call_callback("glVertexAttrib3dv", (void*)glVertexAttrib3dv, 2, arg0, arg1); - -} -PFNGLVERTEXATTRIB3DVPROC glad_debug_glVertexAttrib3dv = glad_debug_impl_glVertexAttrib3dv; PFNGLGETQUERYOBJECTUI64VPROC glad_glGetQueryObjectui64v; -void APIENTRY glad_debug_impl_glGetQueryObjectui64v(GLuint arg0, GLenum arg1, GLuint64 * arg2) { - _pre_call_callback("glGetQueryObjectui64v", (void*)glGetQueryObjectui64v, 3, arg0, arg1, arg2); - glad_glGetQueryObjectui64v(arg0, arg1, arg2); - _post_call_callback("glGetQueryObjectui64v", (void*)glGetQueryObjectui64v, 3, arg0, arg1, arg2); - -} -PFNGLGETQUERYOBJECTUI64VPROC glad_debug_glGetQueryObjectui64v = glad_debug_impl_glGetQueryObjectui64v; PFNGLDEPTHMASKPROC glad_glDepthMask; -void APIENTRY glad_debug_impl_glDepthMask(GLboolean arg0) { - _pre_call_callback("glDepthMask", (void*)glDepthMask, 1, arg0); - glad_glDepthMask(arg0); - _post_call_callback("glDepthMask", (void*)glDepthMask, 1, arg0); - -} -PFNGLDEPTHMASKPROC glad_debug_glDepthMask = glad_debug_impl_glDepthMask; PFNGLVERTEXATTRIB2SPROC glad_glVertexAttrib2s; -void APIENTRY glad_debug_impl_glVertexAttrib2s(GLuint arg0, GLshort arg1, GLshort arg2) { - _pre_call_callback("glVertexAttrib2s", (void*)glVertexAttrib2s, 3, arg0, arg1, arg2); - glad_glVertexAttrib2s(arg0, arg1, arg2); - _post_call_callback("glVertexAttrib2s", (void*)glVertexAttrib2s, 3, arg0, arg1, arg2); - -} -PFNGLVERTEXATTRIB2SPROC glad_debug_glVertexAttrib2s = glad_debug_impl_glVertexAttrib2s; PFNGLTEXIMAGE3DMULTISAMPLEPROC glad_glTexImage3DMultisample; -void APIENTRY glad_debug_impl_glTexImage3DMultisample(GLenum arg0, GLsizei arg1, GLenum arg2, GLsizei arg3, GLsizei arg4, GLsizei arg5, GLboolean arg6) { - _pre_call_callback("glTexImage3DMultisample", (void*)glTexImage3DMultisample, 7, arg0, arg1, arg2, arg3, arg4, arg5, arg6); - glad_glTexImage3DMultisample(arg0, arg1, arg2, arg3, arg4, arg5, arg6); - _post_call_callback("glTexImage3DMultisample", (void*)glTexImage3DMultisample, 7, arg0, arg1, arg2, arg3, arg4, arg5, arg6); - -} -PFNGLTEXIMAGE3DMULTISAMPLEPROC glad_debug_glTexImage3DMultisample = glad_debug_impl_glTexImage3DMultisample; PFNGLGETUNIFORMBLOCKINDEXPROC glad_glGetUniformBlockIndex; -GLuint APIENTRY glad_debug_impl_glGetUniformBlockIndex(GLuint arg0, const GLchar * arg1) { - GLuint ret; - _pre_call_callback("glGetUniformBlockIndex", (void*)glGetUniformBlockIndex, 2, arg0, arg1); - ret = glad_glGetUniformBlockIndex(arg0, arg1); - _post_call_callback("glGetUniformBlockIndex", (void*)glGetUniformBlockIndex, 2, arg0, arg1); - return ret; -} -PFNGLGETUNIFORMBLOCKINDEXPROC glad_debug_glGetUniformBlockIndex = glad_debug_impl_glGetUniformBlockIndex; PFNGLTEXIMAGE2DMULTISAMPLEPROC glad_glTexImage2DMultisample; -void APIENTRY glad_debug_impl_glTexImage2DMultisample(GLenum arg0, GLsizei arg1, GLenum arg2, GLsizei arg3, GLsizei arg4, GLboolean arg5) { - _pre_call_callback("glTexImage2DMultisample", (void*)glTexImage2DMultisample, 6, arg0, arg1, arg2, arg3, arg4, arg5); - glad_glTexImage2DMultisample(arg0, arg1, arg2, arg3, arg4, arg5); - _post_call_callback("glTexImage2DMultisample", (void*)glTexImage2DMultisample, 6, arg0, arg1, arg2, arg3, arg4, arg5); - -} -PFNGLTEXIMAGE2DMULTISAMPLEPROC glad_debug_glTexImage2DMultisample = glad_debug_impl_glTexImage2DMultisample; PFNGLGETACTIVEUNIFORMPROC glad_glGetActiveUniform; -void APIENTRY glad_debug_impl_glGetActiveUniform(GLuint arg0, GLuint arg1, GLsizei arg2, GLsizei * arg3, GLint * arg4, GLenum * arg5, GLchar * arg6) { - _pre_call_callback("glGetActiveUniform", (void*)glGetActiveUniform, 7, arg0, arg1, arg2, arg3, arg4, arg5, arg6); - glad_glGetActiveUniform(arg0, arg1, arg2, arg3, arg4, arg5, arg6); - _post_call_callback("glGetActiveUniform", (void*)glGetActiveUniform, 7, arg0, arg1, arg2, arg3, arg4, arg5, arg6); - -} -PFNGLGETACTIVEUNIFORMPROC glad_debug_glGetActiveUniform = glad_debug_impl_glGetActiveUniform; PFNGLFRONTFACEPROC glad_glFrontFace; -void APIENTRY glad_debug_impl_glFrontFace(GLenum arg0) { - _pre_call_callback("glFrontFace", (void*)glFrontFace, 1, arg0); - glad_glFrontFace(arg0); - _post_call_callback("glFrontFace", (void*)glFrontFace, 1, arg0); - -} -PFNGLFRONTFACEPROC glad_debug_glFrontFace = glad_debug_impl_glFrontFace; static void load_GL_VERSION_1_0(GLADloadproc load) { if(!GLAD_GL_VERSION_1_0) return; glad_glCullFace = (PFNGLCULLFACEPROC)load("glCullFace"); diff --git a/src/libsymmetry/renderer.c b/src/libsymmetry/renderer.c index 5e5ab25..caf0bc6 100644 --- a/src/libsymmetry/renderer.c +++ b/src/libsymmetry/renderer.c @@ -467,29 +467,6 @@ void renderer_clearcolor_set(float red, float green, float blue, float alpha) glClearColor(red, green, blue, alpha); } -int renderer_check_glerror(const char* context) -{ - int error = 1; - GLenum error_code = glGetError(); - const char* error_string = "No Error"; - switch(error_code) - { - case GL_INVALID_OPERATION: error_string = "Invalid Operation"; break; - case GL_NO_ERROR: error_string = "No Error"; break; - case GL_INVALID_ENUM: error_string = "Invalid ENUM"; break; - case GL_INVALID_VALUE: error_string = "Invalid Value"; break; - case GL_INVALID_FRAMEBUFFER_OPERATION: error_string = "Invalid FrameBuffer Operation"; break; - case GL_OUT_OF_MEMORY: error_string = "Out of Memory"; break; - } - - if(error_code != GL_NO_ERROR) - log_error(context, error_string); - else - error = 0; - - return error; -} - struct Material * renderer_material_get(int material_type) { return NULL; diff --git a/src/libsymmetry/shader.c b/src/libsymmetry/shader.c index 04d1260..6d488bc 100644 --- a/src/libsymmetry/shader.c +++ b/src/libsymmetry/shader.c @@ -152,12 +152,11 @@ int shader_create(const char* vert_shader_name, const char* frag_shader_name) glAttachShader(program, frag_shader); // Bind attribute locations - glBindAttribLocation(program, ATTRIB_LOC_POSITION, "vPosition"); - glBindAttribLocation(program, ATTRIB_LOC_NORMAL, "vNormal"); - glBindAttribLocation(program, ATRRIB_LOC_UV, "vUV"); - glBindAttribLocation(program, ATTRIB_LOC_COLOR, "vColor"); - renderer_check_glerror("shader:create"); - glLinkProgram(program); + GL_CHECK(glBindAttribLocation(program, ATTRIB_LOC_POSITION, "vPosition")); + GL_CHECK(glBindAttribLocation(program, ATTRIB_LOC_NORMAL, "vNormal")); + GL_CHECK(glBindAttribLocation(program, ATRRIB_LOC_UV, "vUV")); + GL_CHECK(glBindAttribLocation(program, ATTRIB_LOC_COLOR, "vColor")); + GL_CHECK(glLinkProgram(program)); GLint is_linked = 0; glGetProgramiv(program, GL_LINK_STATUS, &is_linked); diff --git a/src/libsymmetry/sprite.c b/src/libsymmetry/sprite.c index 89159c2..6c9f4e8 100644 --- a/src/libsymmetry/sprite.c +++ b/src/libsymmetry/sprite.c @@ -19,29 +19,22 @@ void sprite_batch_create(struct Sprite_Batch* batch, const char* texture_name, c glGenBuffers(1, &batch->vbo); glBindBuffer(GL_ARRAY_BUFFER, batch->vbo); - glBufferData(GL_ARRAY_BUFFER, + GL_CHECK(glBufferData(GL_ARRAY_BUFFER, sizeof(struct Sprite_Vertex) * MAX_SPRITE_VERTICES * SPRITE_BATCH_SIZE, NULL, - GL_STREAM_DRAW); - renderer_check_glerror("sprite_batch_create:glBufferData"); + GL_STREAM_DRAW)); // Position - glVertexAttribPointer(ATTRIB_LOC_POSITION, 2, GL_FLOAT, GL_FALSE, sizeof(struct Sprite_Vertex), 0); - renderer_check_glerror("sprite_batch_create:glVertexAttribPointer"); - glEnableVertexAttribArray(ATTRIB_LOC_POSITION); - renderer_check_glerror("sprite_batch_create:glEnableVertexAttribPointer"); + GL_CHECK(glVertexAttribPointer(ATTRIB_LOC_POSITION, 2, GL_FLOAT, GL_FALSE, sizeof(struct Sprite_Vertex), 0)); + GL_CHECK(glEnableVertexAttribArray(ATTRIB_LOC_POSITION)); // Uvs - glVertexAttribPointer(ATRRIB_LOC_UV, 2, GL_FLOAT, GL_FALSE, sizeof(struct Sprite_Vertex), sizeof(vec2)); - renderer_check_glerror("sprite_batch_create:glVertexAttribPointer"); - glEnableVertexAttribArray(ATRRIB_LOC_UV); - renderer_check_glerror("sprite_batch_create:glEnableVertexAttribPointer"); + GL_CHECK(glVertexAttribPointer(ATRRIB_LOC_UV, 2, GL_FLOAT, GL_FALSE, sizeof(struct Sprite_Vertex), sizeof(vec2))); + GL_CHECK(glEnableVertexAttribArray(ATRRIB_LOC_UV)); // Color - glVertexAttribPointer(ATTRIB_LOC_COLOR, 4, GL_FLOAT, GL_FALSE, sizeof(struct Sprite_Vertex), sizeof(vec2) + sizeof(vec2)); - renderer_check_glerror("sprite_batch_create:glVertexAttribPointer"); - glEnableVertexAttribArray(ATTRIB_LOC_COLOR); - renderer_check_glerror("sprite_batch_create:glEnableVertexAttribPointer"); + GL_CHECK(glVertexAttribPointer(ATTRIB_LOC_COLOR, 4, GL_FLOAT, GL_FALSE, sizeof(struct Sprite_Vertex), sizeof(vec2) + sizeof(vec2))); + GL_CHECK(glEnableVertexAttribArray(ATTRIB_LOC_COLOR)); //glBindBuffer(GL_ARRAY_BUFFER, 0); glBindVertexArray(0); @@ -62,6 +55,7 @@ void sprite_batch_create(struct Sprite_Batch* batch, const char* texture_name, c } batch->shader = shader; batch->draw_mode = draw_mode; + batch->current_sprite_count = 0; } void sprite_batch_remove(struct Sprite_Batch * batch) @@ -119,11 +113,10 @@ void sprite_batch_end(struct Sprite_Batch* batch) { assert(batch); glBindBuffer(GL_ARRAY_BUFFER, batch->vbo); - glBufferSubData(GL_ARRAY_BUFFER, + GL_CHECK(glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(struct Sprite_Vertex) * MAX_SPRITE_VERTICES * batch->current_sprite_count, - &batch->sprites[0]); - renderer_check_glerror("sprite_batch_end:glBufferSubData"); + &batch->sprites[0])); glBindBuffer(GL_ARRAY_BUFFER, 0); } @@ -134,8 +127,7 @@ void sprite_batch_render(struct Sprite_Batch* batch) texture_bind(batch->texture); glBindVertexArray(batch->vao); - glDrawArrays(batch->draw_mode, 0, MAX_SPRITE_VERTICES * batch->current_sprite_count); - renderer_check_glerror("sprite_batch_render:glDrawArrays"); + GL_CHECK(glDrawArrays(batch->draw_mode, 0, MAX_SPRITE_VERTICES * batch->current_sprite_count)); glBindVertexArray(0); texture_unbind(batch->texture); diff --git a/src/libsymmetry/texture.c b/src/libsymmetry/texture.c index 28c1e56..1a2efd5 100644 --- a/src/libsymmetry/texture.c +++ b/src/libsymmetry/texture.c @@ -48,7 +48,7 @@ static int* empty_indices; static int load_img(FILE* file, GLubyte** image_data, int* width, int* height, int* fmt, int* internal_format); static void debug_write_tga(struct Tga_Header* header, GLubyte* image_data); static void copy_tga_pixel(GLubyte* source, GLubyte* dest, size_t bytes_per_pixel); -static int create_gl_texture(uint* out_handle, int width, int height, int format, int internal_format, int type, const void* data); +static void create_gl_texture(uint* out_handle, int width, int height, int format, int internal_format, int type, const void* data); void texture_init(void) { @@ -311,12 +311,9 @@ void texture_set_param(int index, int parameter, int value) return; GLint curr_texture = 0; - glGetIntegerv(GL_TEXTURE_BINDING_2D, &curr_texture); - renderer_check_glerror("texture:set_param:glGetIntegerv"); - glBindTexture(GL_TEXTURE_2D, texture->handle); - renderer_check_glerror("texture:set_param:glBindTexture"); - glTexParameteri(GL_TEXTURE_2D, parameter, value); - renderer_check_glerror("texture:set_param:glTexParameteri"); + GL_CHECK(glGetIntegerv(GL_TEXTURE_BINDING_2D, &curr_texture)); + GL_CHECK(glBindTexture(GL_TEXTURE_2D, texture->handle)); + GL_CHECK(glTexParameteri(GL_TEXTURE_2D, parameter, value)); if(curr_texture != 0) glBindTexture(GL_TEXTURE_2D, curr_texture); } @@ -385,55 +382,41 @@ int texture_create(const char* name, assert(texture_unit > -1 && texture_unit <= TU_SHADOWMAP4); int index = -1; uint handle = 0; - int success = create_gl_texture(&handle, width, height, format, internal_format, type, data); - if(success) + create_gl_texture(&handle, width, height, format, internal_format, type, data); + struct Texture* new_tex = NULL; + if(array_len(empty_indices) > 0) { - struct Texture* new_tex = NULL; - if(array_len(empty_indices) > 0) - { - index = *array_get_last(empty_indices, int); - array_pop(empty_indices); - new_tex = &texture_list[index]; - } - else - { - new_tex = array_grow(texture_list, struct Texture); - index = array_len(texture_list) - 1; - } - new_tex->name = name ? str_new(name) : str_new("texture_%d", index); - new_tex->handle = handle; - new_tex->ref_count = 1; - new_tex->texture_unit = texture_unit; - new_tex->format = format; - new_tex->internal_format = internal_format; - new_tex->type = type; + index = *array_get_last(empty_indices, int); + array_pop(empty_indices); + new_tex = &texture_list[index]; + } + else + { + new_tex = array_grow(texture_list, struct Texture); + index = array_len(texture_list) - 1; } + new_tex->name = name ? str_new(name) : str_new("texture_%d", index); + new_tex->handle = handle; + new_tex->ref_count = 1; + new_tex->texture_unit = texture_unit; + new_tex->format = format; + new_tex->internal_format = internal_format; + new_tex->type = type; return index; } -int create_gl_texture(uint* out_handle, - int width, - int height, - int format, - int internal_format, - int type, - const void* data) +void create_gl_texture(uint* out_handle, + int width, + int height, + int format, + int internal_format, + int type, + const void* data) { - int success = 1; - glGenTextures(1, out_handle); - if(renderer_check_glerror("texture:create_gl_texture:glGentexture")) - { - success = 0; - } - else - { - glBindTexture(GL_TEXTURE_2D, *out_handle); - glTexImage2D(GL_TEXTURE_2D, 0, internal_format, width, height, 0, format, type, data); - if(renderer_check_glerror("texture:create_gl_texture:glTexImage2d")) - success = 0; - glBindTexture(GL_TEXTURE_2D, 0); - } - return success; + GL_CHECK(glGenTextures(1, out_handle)); + glBindTexture(GL_TEXTURE_2D, *out_handle); + GL_CHECK(glTexImage2D(GL_TEXTURE_2D, 0, internal_format, width, height, 0, format, type, data)); + glBindTexture(GL_TEXTURE_2D, 0); } void texture_resize(int index, int width, int height, const void* data) @@ -444,10 +427,8 @@ void texture_resize(int index, int width, int height, const void* data) struct Texture* texture = &texture_list[index]; GLint curr_texture = 0; - glGetIntegerv(GL_TEXTURE_BINDING_2D, &curr_texture); - renderer_check_glerror("texture:set_param:glGetIntegerv"); - glBindTexture(GL_TEXTURE_2D, texture->handle); - renderer_check_glerror("texture:set_param:glBindTexture"); + GL_CHECK(glGetIntegerv(GL_TEXTURE_BINDING_2D, &curr_texture)); + GL_CHECK(glBindTexture(GL_TEXTURE_2D, texture->handle)); glTexImage2D(GL_TEXTURE_2D, 0, texture->internal_format,