From 5eadf6016a775431bbd54a8cd27a921c09577110 Mon Sep 17 00:00:00 2001 From: Zack Buhman Date: Sun, 28 Sep 2025 13:12:36 -0500 Subject: [PATCH] draw mix texture --- .gitignore | 2 + build.sh | 9 + include/KHR/khrplatform.h | 311 +++++ include/glad/glad.h | 2698 +++++++++++++++++++++++++++++++++++++ src/glad.c | 1467 ++++++++++++++++++++ src/main.c | 314 +++++ texture/gl2-hello-1.data | Bin 0 -> 1048576 bytes texture/gl2-hello-2.data | Bin 0 -> 1048576 bytes 8 files changed, 4801 insertions(+) create mode 100644 .gitignore create mode 100644 build.sh create mode 100644 include/KHR/khrplatform.h create mode 100644 include/glad/glad.h create mode 100644 src/glad.c create mode 100644 src/main.c create mode 100644 texture/gl2-hello-1.data create mode 100644 texture/gl2-hello-2.data diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..be40e73 --- /dev/null +++ b/.gitignore @@ -0,0 +1,2 @@ +*.out +*~ \ No newline at end of file diff --git a/build.sh b/build.sh new file mode 100644 index 0000000..afc33cd --- /dev/null +++ b/build.sh @@ -0,0 +1,9 @@ +set -eux + +CFLAGS="-Wall -Werror -Wfatal-errors -g -Og -std=gnu23 -Iinclude $(pkg-config --libs --cflags glfw3) -lm" + +if [ -f src/glad.o ]; then + gcc $CFLAGS src/main.c src/glad.o +else + gcc $CFLAGS src/main.c src/glad.c +fi diff --git a/include/KHR/khrplatform.h b/include/KHR/khrplatform.h new file mode 100644 index 0000000..0164644 --- /dev/null +++ b/include/KHR/khrplatform.h @@ -0,0 +1,311 @@ +#ifndef __khrplatform_h_ +#define __khrplatform_h_ + +/* +** Copyright (c) 2008-2018 The Khronos Group Inc. +** +** Permission is hereby granted, free of charge, to any person obtaining a +** copy of this software and/or associated documentation files (the +** "Materials"), to deal in the Materials without restriction, including +** without limitation the rights to use, copy, modify, merge, publish, +** distribute, sublicense, and/or sell copies of the Materials, and to +** permit persons to whom the Materials are furnished to do so, subject to +** the following conditions: +** +** The above copyright notice and this permission notice shall be included +** in all copies or substantial portions of the Materials. +** +** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. +*/ + +/* Khronos platform-specific types and definitions. + * + * The master copy of khrplatform.h is maintained in the Khronos EGL + * Registry repository at https://github.com/KhronosGroup/EGL-Registry + * The last semantic modification to khrplatform.h was at commit ID: + * 67a3e0864c2d75ea5287b9f3d2eb74a745936692 + * + * Adopters may modify this file to suit their platform. Adopters are + * encouraged to submit platform specific modifications to the Khronos + * group so that they can be included in future versions of this file. + * Please submit changes by filing pull requests or issues on + * the EGL Registry repository linked above. + * + * + * See the Implementer's Guidelines for information about where this file + * should be located on your system and for more details of its use: + * http://www.khronos.org/registry/implementers_guide.pdf + * + * This file should be included as + * #include + * by Khronos client API header files that use its types and defines. + * + * The types in khrplatform.h should only be used to define API-specific types. + * + * Types defined in khrplatform.h: + * khronos_int8_t signed 8 bit + * khronos_uint8_t unsigned 8 bit + * khronos_int16_t signed 16 bit + * khronos_uint16_t unsigned 16 bit + * khronos_int32_t signed 32 bit + * khronos_uint32_t unsigned 32 bit + * khronos_int64_t signed 64 bit + * khronos_uint64_t unsigned 64 bit + * khronos_intptr_t signed same number of bits as a pointer + * khronos_uintptr_t unsigned same number of bits as a pointer + * khronos_ssize_t signed size + * khronos_usize_t unsigned size + * khronos_float_t signed 32 bit floating point + * khronos_time_ns_t unsigned 64 bit time in nanoseconds + * khronos_utime_nanoseconds_t unsigned time interval or absolute time in + * nanoseconds + * khronos_stime_nanoseconds_t signed time interval in nanoseconds + * khronos_boolean_enum_t enumerated boolean type. This should + * only be used as a base type when a client API's boolean type is + * an enum. Client APIs which use an integer or other type for + * booleans cannot use this as the base type for their boolean. + * + * Tokens defined in khrplatform.h: + * + * KHRONOS_FALSE, KHRONOS_TRUE Enumerated boolean false/true values. + * + * KHRONOS_SUPPORT_INT64 is 1 if 64 bit integers are supported; otherwise 0. + * KHRONOS_SUPPORT_FLOAT is 1 if floats are supported; otherwise 0. + * + * Calling convention macros defined in this file: + * KHRONOS_APICALL + * KHRONOS_APIENTRY + * KHRONOS_APIATTRIBUTES + * + * These may be used in function prototypes as: + * + * KHRONOS_APICALL void KHRONOS_APIENTRY funcname( + * int arg1, + * int arg2) KHRONOS_APIATTRIBUTES; + */ + +#if defined(__SCITECH_SNAP__) && !defined(KHRONOS_STATIC) +# define KHRONOS_STATIC 1 +#endif + +/*------------------------------------------------------------------------- + * Definition of KHRONOS_APICALL + *------------------------------------------------------------------------- + * This precedes the return type of the function in the function prototype. + */ +#if defined(KHRONOS_STATIC) + /* If the preprocessor constant KHRONOS_STATIC is defined, make the + * header compatible with static linking. */ +# define KHRONOS_APICALL +#elif defined(_WIN32) +# define KHRONOS_APICALL __declspec(dllimport) +#elif defined (__SYMBIAN32__) +# define KHRONOS_APICALL IMPORT_C +#elif defined(__ANDROID__) +# define KHRONOS_APICALL __attribute__((visibility("default"))) +#else +# define KHRONOS_APICALL +#endif + +/*------------------------------------------------------------------------- + * Definition of KHRONOS_APIENTRY + *------------------------------------------------------------------------- + * This follows the return type of the function and precedes the function + * name in the function prototype. + */ +#if defined(_WIN32) && !defined(_WIN32_WCE) && !defined(__SCITECH_SNAP__) + /* Win32 but not WinCE */ +# define KHRONOS_APIENTRY __stdcall +#else +# define KHRONOS_APIENTRY +#endif + +/*------------------------------------------------------------------------- + * Definition of KHRONOS_APIATTRIBUTES + *------------------------------------------------------------------------- + * This follows the closing parenthesis of the function prototype arguments. + */ +#if defined (__ARMCC_2__) +#define KHRONOS_APIATTRIBUTES __softfp +#else +#define KHRONOS_APIATTRIBUTES +#endif + +/*------------------------------------------------------------------------- + * basic type definitions + *-----------------------------------------------------------------------*/ +#if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) || defined(__GNUC__) || defined(__SCO__) || defined(__USLC__) + + +/* + * Using + */ +#include +typedef int32_t khronos_int32_t; +typedef uint32_t khronos_uint32_t; +typedef int64_t khronos_int64_t; +typedef uint64_t khronos_uint64_t; +#define KHRONOS_SUPPORT_INT64 1 +#define KHRONOS_SUPPORT_FLOAT 1 +/* + * To support platform where unsigned long cannot be used interchangeably with + * inptr_t (e.g. CHERI-extended ISAs), we can use the stdint.h intptr_t. + * Ideally, we could just use (u)intptr_t everywhere, but this could result in + * ABI breakage if khronos_uintptr_t is changed from unsigned long to + * unsigned long long or similar (this results in different C++ name mangling). + * To avoid changes for existing platforms, we restrict usage of intptr_t to + * platforms where the size of a pointer is larger than the size of long. + */ +#if defined(__SIZEOF_LONG__) && defined(__SIZEOF_POINTER__) +#if __SIZEOF_POINTER__ > __SIZEOF_LONG__ +#define KHRONOS_USE_INTPTR_T +#endif +#endif + +#elif defined(__VMS ) || defined(__sgi) + +/* + * Using + */ +#include +typedef int32_t khronos_int32_t; +typedef uint32_t khronos_uint32_t; +typedef int64_t khronos_int64_t; +typedef uint64_t khronos_uint64_t; +#define KHRONOS_SUPPORT_INT64 1 +#define KHRONOS_SUPPORT_FLOAT 1 + +#elif defined(_WIN32) && !defined(__SCITECH_SNAP__) + +/* + * Win32 + */ +typedef __int32 khronos_int32_t; +typedef unsigned __int32 khronos_uint32_t; +typedef __int64 khronos_int64_t; +typedef unsigned __int64 khronos_uint64_t; +#define KHRONOS_SUPPORT_INT64 1 +#define KHRONOS_SUPPORT_FLOAT 1 + +#elif defined(__sun__) || defined(__digital__) + +/* + * Sun or Digital + */ +typedef int khronos_int32_t; +typedef unsigned int khronos_uint32_t; +#if defined(__arch64__) || defined(_LP64) +typedef long int khronos_int64_t; +typedef unsigned long int khronos_uint64_t; +#else +typedef long long int khronos_int64_t; +typedef unsigned long long int khronos_uint64_t; +#endif /* __arch64__ */ +#define KHRONOS_SUPPORT_INT64 1 +#define KHRONOS_SUPPORT_FLOAT 1 + +#elif 0 + +/* + * Hypothetical platform with no float or int64 support + */ +typedef int khronos_int32_t; +typedef unsigned int khronos_uint32_t; +#define KHRONOS_SUPPORT_INT64 0 +#define KHRONOS_SUPPORT_FLOAT 0 + +#else + +/* + * Generic fallback + */ +#include +typedef int32_t khronos_int32_t; +typedef uint32_t khronos_uint32_t; +typedef int64_t khronos_int64_t; +typedef uint64_t khronos_uint64_t; +#define KHRONOS_SUPPORT_INT64 1 +#define KHRONOS_SUPPORT_FLOAT 1 + +#endif + + +/* + * Types that are (so far) the same on all platforms + */ +typedef signed char khronos_int8_t; +typedef unsigned char khronos_uint8_t; +typedef signed short int khronos_int16_t; +typedef unsigned short int khronos_uint16_t; + +/* + * Types that differ between LLP64 and LP64 architectures - in LLP64, + * pointers are 64 bits, but 'long' is still 32 bits. Win64 appears + * to be the only LLP64 architecture in current use. + */ +#ifdef KHRONOS_USE_INTPTR_T +typedef intptr_t khronos_intptr_t; +typedef uintptr_t khronos_uintptr_t; +#elif defined(_WIN64) +typedef signed long long int khronos_intptr_t; +typedef unsigned long long int khronos_uintptr_t; +#else +typedef signed long int khronos_intptr_t; +typedef unsigned long int khronos_uintptr_t; +#endif + +#if defined(_WIN64) +typedef signed long long int khronos_ssize_t; +typedef unsigned long long int khronos_usize_t; +#else +typedef signed long int khronos_ssize_t; +typedef unsigned long int khronos_usize_t; +#endif + +#if KHRONOS_SUPPORT_FLOAT +/* + * Float type + */ +typedef float khronos_float_t; +#endif + +#if KHRONOS_SUPPORT_INT64 +/* Time types + * + * These types can be used to represent a time interval in nanoseconds or + * an absolute Unadjusted System Time. Unadjusted System Time is the number + * of nanoseconds since some arbitrary system event (e.g. since the last + * time the system booted). The Unadjusted System Time is an unsigned + * 64 bit value that wraps back to 0 every 584 years. Time intervals + * may be either signed or unsigned. + */ +typedef khronos_uint64_t khronos_utime_nanoseconds_t; +typedef khronos_int64_t khronos_stime_nanoseconds_t; +#endif + +/* + * Dummy value used to pad enum types to 32 bits. + */ +#ifndef KHRONOS_MAX_ENUM +#define KHRONOS_MAX_ENUM 0x7FFFFFFF +#endif + +/* + * Enumerated boolean type + * + * Values other than zero should be considered to be true. Therefore + * comparisons should not be made against KHRONOS_TRUE. + */ +typedef enum { + KHRONOS_FALSE = 0, + KHRONOS_TRUE = 1, + KHRONOS_BOOLEAN_ENUM_FORCE_SIZE = KHRONOS_MAX_ENUM +} khronos_boolean_enum_t; + +#endif /* __khrplatform_h_ */ diff --git a/include/glad/glad.h b/include/glad/glad.h new file mode 100644 index 0000000..e870d1b --- /dev/null +++ b/include/glad/glad.h @@ -0,0 +1,2698 @@ +/* + + OpenGL loader generated by glad 0.1.36 on Fri Sep 26 00:08:37 2025. + + Language/Generator: C/C++ + Specification: gl + APIs: gl=2.1 + Profile: compatibility + Extensions: + + Loader: True + Local files: False + Omit khrplatform: False + Reproducible: False + + Commandline: + --profile="compatibility" --api="gl=2.1" --generator="c" --spec="gl" --extensions="" + Online: + https://glad.dav1d.de/#profile=compatibility&language=c&specification=gl&loader=on&api=gl%3D2.1 +*/ + + +#ifndef __glad_h_ +#define __glad_h_ + +#ifdef __gl_h_ +#error OpenGL header already included, remove this include, glad already provides it +#endif +#define __gl_h_ + +#if defined(_WIN32) && !defined(APIENTRY) && !defined(__CYGWIN__) && !defined(__SCITECH_SNAP__) +#define APIENTRY __stdcall +#endif + +#ifndef APIENTRY +#define APIENTRY +#endif +#ifndef APIENTRYP +#define APIENTRYP APIENTRY * +#endif + +#ifndef GLAPIENTRY +#define GLAPIENTRY APIENTRY +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +struct gladGLversionStruct { + int major; + int minor; +}; + +typedef void* (* GLADloadproc)(const char *name); + +#ifndef GLAPI +# if defined(GLAD_GLAPI_EXPORT) +# if defined(_WIN32) || defined(__CYGWIN__) +# if defined(GLAD_GLAPI_EXPORT_BUILD) +# if defined(__GNUC__) +# define GLAPI __attribute__ ((dllexport)) extern +# else +# define GLAPI __declspec(dllexport) extern +# endif +# else +# if defined(__GNUC__) +# define GLAPI __attribute__ ((dllimport)) extern +# else +# define GLAPI __declspec(dllimport) extern +# endif +# endif +# elif defined(__GNUC__) && defined(GLAD_GLAPI_EXPORT_BUILD) +# define GLAPI __attribute__ ((visibility ("default"))) extern +# else +# define GLAPI extern +# endif +# else +# define GLAPI extern +# endif +#endif + +GLAPI struct gladGLversionStruct GLVersion; + +GLAPI int gladLoadGL(void); + +GLAPI int gladLoadGLLoader(GLADloadproc); + +#include +typedef unsigned int GLenum; +typedef unsigned char GLboolean; +typedef unsigned int GLbitfield; +typedef void GLvoid; +typedef khronos_int8_t GLbyte; +typedef khronos_uint8_t GLubyte; +typedef khronos_int16_t GLshort; +typedef khronos_uint16_t GLushort; +typedef int GLint; +typedef unsigned int GLuint; +typedef khronos_int32_t GLclampx; +typedef int GLsizei; +typedef khronos_float_t GLfloat; +typedef khronos_float_t GLclampf; +typedef double GLdouble; +typedef double GLclampd; +typedef void *GLeglClientBufferEXT; +typedef void *GLeglImageOES; +typedef char GLchar; +typedef char GLcharARB; +#ifdef __APPLE__ +typedef void *GLhandleARB; +#else +typedef unsigned int GLhandleARB; +#endif +typedef khronos_uint16_t GLhalf; +typedef khronos_uint16_t GLhalfARB; +typedef khronos_int32_t GLfixed; +typedef khronos_intptr_t GLintptr; +typedef khronos_intptr_t GLintptrARB; +typedef khronos_ssize_t GLsizeiptr; +typedef khronos_ssize_t GLsizeiptrARB; +typedef khronos_int64_t GLint64; +typedef khronos_int64_t GLint64EXT; +typedef khronos_uint64_t GLuint64; +typedef khronos_uint64_t GLuint64EXT; +typedef struct __GLsync *GLsync; +struct _cl_context; +struct _cl_event; +typedef void (APIENTRY *GLDEBUGPROC)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam); +typedef void (APIENTRY *GLDEBUGPROCARB)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam); +typedef void (APIENTRY *GLDEBUGPROCKHR)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam); +typedef void (APIENTRY *GLDEBUGPROCAMD)(GLuint id,GLenum category,GLenum severity,GLsizei length,const GLchar *message,void *userParam); +typedef unsigned short GLhalfNV; +typedef GLintptr GLvdpauSurfaceNV; +typedef void (APIENTRY *GLVULKANPROCNV)(void); +#define GL_DEPTH_BUFFER_BIT 0x00000100 +#define GL_STENCIL_BUFFER_BIT 0x00000400 +#define GL_COLOR_BUFFER_BIT 0x00004000 +#define GL_FALSE 0 +#define GL_TRUE 1 +#define GL_POINTS 0x0000 +#define GL_LINES 0x0001 +#define GL_LINE_LOOP 0x0002 +#define GL_LINE_STRIP 0x0003 +#define GL_TRIANGLES 0x0004 +#define GL_TRIANGLE_STRIP 0x0005 +#define GL_TRIANGLE_FAN 0x0006 +#define GL_QUADS 0x0007 +#define GL_NEVER 0x0200 +#define GL_LESS 0x0201 +#define GL_EQUAL 0x0202 +#define GL_LEQUAL 0x0203 +#define GL_GREATER 0x0204 +#define GL_NOTEQUAL 0x0205 +#define GL_GEQUAL 0x0206 +#define GL_ALWAYS 0x0207 +#define GL_ZERO 0 +#define GL_ONE 1 +#define GL_SRC_COLOR 0x0300 +#define GL_ONE_MINUS_SRC_COLOR 0x0301 +#define GL_SRC_ALPHA 0x0302 +#define GL_ONE_MINUS_SRC_ALPHA 0x0303 +#define GL_DST_ALPHA 0x0304 +#define GL_ONE_MINUS_DST_ALPHA 0x0305 +#define GL_DST_COLOR 0x0306 +#define GL_ONE_MINUS_DST_COLOR 0x0307 +#define GL_SRC_ALPHA_SATURATE 0x0308 +#define GL_NONE 0 +#define GL_FRONT_LEFT 0x0400 +#define GL_FRONT_RIGHT 0x0401 +#define GL_BACK_LEFT 0x0402 +#define GL_BACK_RIGHT 0x0403 +#define GL_FRONT 0x0404 +#define GL_BACK 0x0405 +#define GL_LEFT 0x0406 +#define GL_RIGHT 0x0407 +#define GL_FRONT_AND_BACK 0x0408 +#define GL_NO_ERROR 0 +#define GL_INVALID_ENUM 0x0500 +#define GL_INVALID_VALUE 0x0501 +#define GL_INVALID_OPERATION 0x0502 +#define GL_OUT_OF_MEMORY 0x0505 +#define GL_CW 0x0900 +#define GL_CCW 0x0901 +#define GL_POINT_SIZE 0x0B11 +#define GL_POINT_SIZE_RANGE 0x0B12 +#define GL_POINT_SIZE_GRANULARITY 0x0B13 +#define GL_LINE_SMOOTH 0x0B20 +#define GL_LINE_WIDTH 0x0B21 +#define GL_LINE_WIDTH_RANGE 0x0B22 +#define GL_LINE_WIDTH_GRANULARITY 0x0B23 +#define GL_POLYGON_MODE 0x0B40 +#define GL_POLYGON_SMOOTH 0x0B41 +#define GL_CULL_FACE 0x0B44 +#define GL_CULL_FACE_MODE 0x0B45 +#define GL_FRONT_FACE 0x0B46 +#define GL_DEPTH_RANGE 0x0B70 +#define GL_DEPTH_TEST 0x0B71 +#define GL_DEPTH_WRITEMASK 0x0B72 +#define GL_DEPTH_CLEAR_VALUE 0x0B73 +#define GL_DEPTH_FUNC 0x0B74 +#define GL_STENCIL_TEST 0x0B90 +#define GL_STENCIL_CLEAR_VALUE 0x0B91 +#define GL_STENCIL_FUNC 0x0B92 +#define GL_STENCIL_VALUE_MASK 0x0B93 +#define GL_STENCIL_FAIL 0x0B94 +#define GL_STENCIL_PASS_DEPTH_FAIL 0x0B95 +#define GL_STENCIL_PASS_DEPTH_PASS 0x0B96 +#define GL_STENCIL_REF 0x0B97 +#define GL_STENCIL_WRITEMASK 0x0B98 +#define GL_VIEWPORT 0x0BA2 +#define GL_DITHER 0x0BD0 +#define GL_BLEND_DST 0x0BE0 +#define GL_BLEND_SRC 0x0BE1 +#define GL_BLEND 0x0BE2 +#define GL_LOGIC_OP_MODE 0x0BF0 +#define GL_DRAW_BUFFER 0x0C01 +#define GL_READ_BUFFER 0x0C02 +#define GL_SCISSOR_BOX 0x0C10 +#define GL_SCISSOR_TEST 0x0C11 +#define GL_COLOR_CLEAR_VALUE 0x0C22 +#define GL_COLOR_WRITEMASK 0x0C23 +#define GL_DOUBLEBUFFER 0x0C32 +#define GL_STEREO 0x0C33 +#define GL_LINE_SMOOTH_HINT 0x0C52 +#define GL_POLYGON_SMOOTH_HINT 0x0C53 +#define GL_UNPACK_SWAP_BYTES 0x0CF0 +#define GL_UNPACK_LSB_FIRST 0x0CF1 +#define GL_UNPACK_ROW_LENGTH 0x0CF2 +#define GL_UNPACK_SKIP_ROWS 0x0CF3 +#define GL_UNPACK_SKIP_PIXELS 0x0CF4 +#define GL_UNPACK_ALIGNMENT 0x0CF5 +#define GL_PACK_SWAP_BYTES 0x0D00 +#define GL_PACK_LSB_FIRST 0x0D01 +#define GL_PACK_ROW_LENGTH 0x0D02 +#define GL_PACK_SKIP_ROWS 0x0D03 +#define GL_PACK_SKIP_PIXELS 0x0D04 +#define GL_PACK_ALIGNMENT 0x0D05 +#define GL_MAX_TEXTURE_SIZE 0x0D33 +#define GL_MAX_VIEWPORT_DIMS 0x0D3A +#define GL_SUBPIXEL_BITS 0x0D50 +#define GL_TEXTURE_1D 0x0DE0 +#define GL_TEXTURE_2D 0x0DE1 +#define GL_TEXTURE_WIDTH 0x1000 +#define GL_TEXTURE_HEIGHT 0x1001 +#define GL_TEXTURE_BORDER_COLOR 0x1004 +#define GL_DONT_CARE 0x1100 +#define GL_FASTEST 0x1101 +#define GL_NICEST 0x1102 +#define GL_BYTE 0x1400 +#define GL_UNSIGNED_BYTE 0x1401 +#define GL_SHORT 0x1402 +#define GL_UNSIGNED_SHORT 0x1403 +#define GL_INT 0x1404 +#define GL_UNSIGNED_INT 0x1405 +#define GL_FLOAT 0x1406 +#define GL_STACK_OVERFLOW 0x0503 +#define GL_STACK_UNDERFLOW 0x0504 +#define GL_CLEAR 0x1500 +#define GL_AND 0x1501 +#define GL_AND_REVERSE 0x1502 +#define GL_COPY 0x1503 +#define GL_AND_INVERTED 0x1504 +#define GL_NOOP 0x1505 +#define GL_XOR 0x1506 +#define GL_OR 0x1507 +#define GL_NOR 0x1508 +#define GL_EQUIV 0x1509 +#define GL_INVERT 0x150A +#define GL_OR_REVERSE 0x150B +#define GL_COPY_INVERTED 0x150C +#define GL_OR_INVERTED 0x150D +#define GL_NAND 0x150E +#define GL_SET 0x150F +#define GL_TEXTURE 0x1702 +#define GL_COLOR 0x1800 +#define GL_DEPTH 0x1801 +#define GL_STENCIL 0x1802 +#define GL_STENCIL_INDEX 0x1901 +#define GL_DEPTH_COMPONENT 0x1902 +#define GL_RED 0x1903 +#define GL_GREEN 0x1904 +#define GL_BLUE 0x1905 +#define GL_ALPHA 0x1906 +#define GL_RGB 0x1907 +#define GL_RGBA 0x1908 +#define GL_POINT 0x1B00 +#define GL_LINE 0x1B01 +#define GL_FILL 0x1B02 +#define GL_KEEP 0x1E00 +#define GL_REPLACE 0x1E01 +#define GL_INCR 0x1E02 +#define GL_DECR 0x1E03 +#define GL_VENDOR 0x1F00 +#define GL_RENDERER 0x1F01 +#define GL_VERSION 0x1F02 +#define GL_EXTENSIONS 0x1F03 +#define GL_NEAREST 0x2600 +#define GL_LINEAR 0x2601 +#define GL_NEAREST_MIPMAP_NEAREST 0x2700 +#define GL_LINEAR_MIPMAP_NEAREST 0x2701 +#define GL_NEAREST_MIPMAP_LINEAR 0x2702 +#define GL_LINEAR_MIPMAP_LINEAR 0x2703 +#define GL_TEXTURE_MAG_FILTER 0x2800 +#define GL_TEXTURE_MIN_FILTER 0x2801 +#define GL_TEXTURE_WRAP_S 0x2802 +#define GL_TEXTURE_WRAP_T 0x2803 +#define GL_REPEAT 0x2901 +#define GL_CURRENT_BIT 0x00000001 +#define GL_POINT_BIT 0x00000002 +#define GL_LINE_BIT 0x00000004 +#define GL_POLYGON_BIT 0x00000008 +#define GL_POLYGON_STIPPLE_BIT 0x00000010 +#define GL_PIXEL_MODE_BIT 0x00000020 +#define GL_LIGHTING_BIT 0x00000040 +#define GL_FOG_BIT 0x00000080 +#define GL_ACCUM_BUFFER_BIT 0x00000200 +#define GL_VIEWPORT_BIT 0x00000800 +#define GL_TRANSFORM_BIT 0x00001000 +#define GL_ENABLE_BIT 0x00002000 +#define GL_HINT_BIT 0x00008000 +#define GL_EVAL_BIT 0x00010000 +#define GL_LIST_BIT 0x00020000 +#define GL_TEXTURE_BIT 0x00040000 +#define GL_SCISSOR_BIT 0x00080000 +#define GL_ALL_ATTRIB_BITS 0xFFFFFFFF +#define GL_QUAD_STRIP 0x0008 +#define GL_POLYGON 0x0009 +#define GL_ACCUM 0x0100 +#define GL_LOAD 0x0101 +#define GL_RETURN 0x0102 +#define GL_MULT 0x0103 +#define GL_ADD 0x0104 +#define GL_AUX0 0x0409 +#define GL_AUX1 0x040A +#define GL_AUX2 0x040B +#define GL_AUX3 0x040C +#define GL_2D 0x0600 +#define GL_3D 0x0601 +#define GL_3D_COLOR 0x0602 +#define GL_3D_COLOR_TEXTURE 0x0603 +#define GL_4D_COLOR_TEXTURE 0x0604 +#define GL_PASS_THROUGH_TOKEN 0x0700 +#define GL_POINT_TOKEN 0x0701 +#define GL_LINE_TOKEN 0x0702 +#define GL_POLYGON_TOKEN 0x0703 +#define GL_BITMAP_TOKEN 0x0704 +#define GL_DRAW_PIXEL_TOKEN 0x0705 +#define GL_COPY_PIXEL_TOKEN 0x0706 +#define GL_LINE_RESET_TOKEN 0x0707 +#define GL_EXP 0x0800 +#define GL_EXP2 0x0801 +#define GL_COEFF 0x0A00 +#define GL_ORDER 0x0A01 +#define GL_DOMAIN 0x0A02 +#define GL_PIXEL_MAP_I_TO_I 0x0C70 +#define GL_PIXEL_MAP_S_TO_S 0x0C71 +#define GL_PIXEL_MAP_I_TO_R 0x0C72 +#define GL_PIXEL_MAP_I_TO_G 0x0C73 +#define GL_PIXEL_MAP_I_TO_B 0x0C74 +#define GL_PIXEL_MAP_I_TO_A 0x0C75 +#define GL_PIXEL_MAP_R_TO_R 0x0C76 +#define GL_PIXEL_MAP_G_TO_G 0x0C77 +#define GL_PIXEL_MAP_B_TO_B 0x0C78 +#define GL_PIXEL_MAP_A_TO_A 0x0C79 +#define GL_CURRENT_COLOR 0x0B00 +#define GL_CURRENT_INDEX 0x0B01 +#define GL_CURRENT_NORMAL 0x0B02 +#define GL_CURRENT_TEXTURE_COORDS 0x0B03 +#define GL_CURRENT_RASTER_COLOR 0x0B04 +#define GL_CURRENT_RASTER_INDEX 0x0B05 +#define GL_CURRENT_RASTER_TEXTURE_COORDS 0x0B06 +#define GL_CURRENT_RASTER_POSITION 0x0B07 +#define GL_CURRENT_RASTER_POSITION_VALID 0x0B08 +#define GL_CURRENT_RASTER_DISTANCE 0x0B09 +#define GL_POINT_SMOOTH 0x0B10 +#define GL_LINE_STIPPLE 0x0B24 +#define GL_LINE_STIPPLE_PATTERN 0x0B25 +#define GL_LINE_STIPPLE_REPEAT 0x0B26 +#define GL_LIST_MODE 0x0B30 +#define GL_MAX_LIST_NESTING 0x0B31 +#define GL_LIST_BASE 0x0B32 +#define GL_LIST_INDEX 0x0B33 +#define GL_POLYGON_STIPPLE 0x0B42 +#define GL_EDGE_FLAG 0x0B43 +#define GL_LIGHTING 0x0B50 +#define GL_LIGHT_MODEL_LOCAL_VIEWER 0x0B51 +#define GL_LIGHT_MODEL_TWO_SIDE 0x0B52 +#define GL_LIGHT_MODEL_AMBIENT 0x0B53 +#define GL_SHADE_MODEL 0x0B54 +#define GL_COLOR_MATERIAL_FACE 0x0B55 +#define GL_COLOR_MATERIAL_PARAMETER 0x0B56 +#define GL_COLOR_MATERIAL 0x0B57 +#define GL_FOG 0x0B60 +#define GL_FOG_INDEX 0x0B61 +#define GL_FOG_DENSITY 0x0B62 +#define GL_FOG_START 0x0B63 +#define GL_FOG_END 0x0B64 +#define GL_FOG_MODE 0x0B65 +#define GL_FOG_COLOR 0x0B66 +#define GL_ACCUM_CLEAR_VALUE 0x0B80 +#define GL_MATRIX_MODE 0x0BA0 +#define GL_NORMALIZE 0x0BA1 +#define GL_MODELVIEW_STACK_DEPTH 0x0BA3 +#define GL_PROJECTION_STACK_DEPTH 0x0BA4 +#define GL_TEXTURE_STACK_DEPTH 0x0BA5 +#define GL_MODELVIEW_MATRIX 0x0BA6 +#define GL_PROJECTION_MATRIX 0x0BA7 +#define GL_TEXTURE_MATRIX 0x0BA8 +#define GL_ATTRIB_STACK_DEPTH 0x0BB0 +#define GL_ALPHA_TEST 0x0BC0 +#define GL_ALPHA_TEST_FUNC 0x0BC1 +#define GL_ALPHA_TEST_REF 0x0BC2 +#define GL_LOGIC_OP 0x0BF1 +#define GL_AUX_BUFFERS 0x0C00 +#define GL_INDEX_CLEAR_VALUE 0x0C20 +#define GL_INDEX_WRITEMASK 0x0C21 +#define GL_INDEX_MODE 0x0C30 +#define GL_RGBA_MODE 0x0C31 +#define GL_RENDER_MODE 0x0C40 +#define GL_PERSPECTIVE_CORRECTION_HINT 0x0C50 +#define GL_POINT_SMOOTH_HINT 0x0C51 +#define GL_FOG_HINT 0x0C54 +#define GL_TEXTURE_GEN_S 0x0C60 +#define GL_TEXTURE_GEN_T 0x0C61 +#define GL_TEXTURE_GEN_R 0x0C62 +#define GL_TEXTURE_GEN_Q 0x0C63 +#define GL_PIXEL_MAP_I_TO_I_SIZE 0x0CB0 +#define GL_PIXEL_MAP_S_TO_S_SIZE 0x0CB1 +#define GL_PIXEL_MAP_I_TO_R_SIZE 0x0CB2 +#define GL_PIXEL_MAP_I_TO_G_SIZE 0x0CB3 +#define GL_PIXEL_MAP_I_TO_B_SIZE 0x0CB4 +#define GL_PIXEL_MAP_I_TO_A_SIZE 0x0CB5 +#define GL_PIXEL_MAP_R_TO_R_SIZE 0x0CB6 +#define GL_PIXEL_MAP_G_TO_G_SIZE 0x0CB7 +#define GL_PIXEL_MAP_B_TO_B_SIZE 0x0CB8 +#define GL_PIXEL_MAP_A_TO_A_SIZE 0x0CB9 +#define GL_MAP_COLOR 0x0D10 +#define GL_MAP_STENCIL 0x0D11 +#define GL_INDEX_SHIFT 0x0D12 +#define GL_INDEX_OFFSET 0x0D13 +#define GL_RED_SCALE 0x0D14 +#define GL_RED_BIAS 0x0D15 +#define GL_ZOOM_X 0x0D16 +#define GL_ZOOM_Y 0x0D17 +#define GL_GREEN_SCALE 0x0D18 +#define GL_GREEN_BIAS 0x0D19 +#define GL_BLUE_SCALE 0x0D1A +#define GL_BLUE_BIAS 0x0D1B +#define GL_ALPHA_SCALE 0x0D1C +#define GL_ALPHA_BIAS 0x0D1D +#define GL_DEPTH_SCALE 0x0D1E +#define GL_DEPTH_BIAS 0x0D1F +#define GL_MAX_EVAL_ORDER 0x0D30 +#define GL_MAX_LIGHTS 0x0D31 +#define GL_MAX_CLIP_PLANES 0x0D32 +#define GL_MAX_PIXEL_MAP_TABLE 0x0D34 +#define GL_MAX_ATTRIB_STACK_DEPTH 0x0D35 +#define GL_MAX_MODELVIEW_STACK_DEPTH 0x0D36 +#define GL_MAX_NAME_STACK_DEPTH 0x0D37 +#define GL_MAX_PROJECTION_STACK_DEPTH 0x0D38 +#define GL_MAX_TEXTURE_STACK_DEPTH 0x0D39 +#define GL_INDEX_BITS 0x0D51 +#define GL_RED_BITS 0x0D52 +#define GL_GREEN_BITS 0x0D53 +#define GL_BLUE_BITS 0x0D54 +#define GL_ALPHA_BITS 0x0D55 +#define GL_DEPTH_BITS 0x0D56 +#define GL_STENCIL_BITS 0x0D57 +#define GL_ACCUM_RED_BITS 0x0D58 +#define GL_ACCUM_GREEN_BITS 0x0D59 +#define GL_ACCUM_BLUE_BITS 0x0D5A +#define GL_ACCUM_ALPHA_BITS 0x0D5B +#define GL_NAME_STACK_DEPTH 0x0D70 +#define GL_AUTO_NORMAL 0x0D80 +#define GL_MAP1_COLOR_4 0x0D90 +#define GL_MAP1_INDEX 0x0D91 +#define GL_MAP1_NORMAL 0x0D92 +#define GL_MAP1_TEXTURE_COORD_1 0x0D93 +#define GL_MAP1_TEXTURE_COORD_2 0x0D94 +#define GL_MAP1_TEXTURE_COORD_3 0x0D95 +#define GL_MAP1_TEXTURE_COORD_4 0x0D96 +#define GL_MAP1_VERTEX_3 0x0D97 +#define GL_MAP1_VERTEX_4 0x0D98 +#define GL_MAP2_COLOR_4 0x0DB0 +#define GL_MAP2_INDEX 0x0DB1 +#define GL_MAP2_NORMAL 0x0DB2 +#define GL_MAP2_TEXTURE_COORD_1 0x0DB3 +#define GL_MAP2_TEXTURE_COORD_2 0x0DB4 +#define GL_MAP2_TEXTURE_COORD_3 0x0DB5 +#define GL_MAP2_TEXTURE_COORD_4 0x0DB6 +#define GL_MAP2_VERTEX_3 0x0DB7 +#define GL_MAP2_VERTEX_4 0x0DB8 +#define GL_MAP1_GRID_DOMAIN 0x0DD0 +#define GL_MAP1_GRID_SEGMENTS 0x0DD1 +#define GL_MAP2_GRID_DOMAIN 0x0DD2 +#define GL_MAP2_GRID_SEGMENTS 0x0DD3 +#define GL_TEXTURE_COMPONENTS 0x1003 +#define GL_TEXTURE_BORDER 0x1005 +#define GL_AMBIENT 0x1200 +#define GL_DIFFUSE 0x1201 +#define GL_SPECULAR 0x1202 +#define GL_POSITION 0x1203 +#define GL_SPOT_DIRECTION 0x1204 +#define GL_SPOT_EXPONENT 0x1205 +#define GL_SPOT_CUTOFF 0x1206 +#define GL_CONSTANT_ATTENUATION 0x1207 +#define GL_LINEAR_ATTENUATION 0x1208 +#define GL_QUADRATIC_ATTENUATION 0x1209 +#define GL_COMPILE 0x1300 +#define GL_COMPILE_AND_EXECUTE 0x1301 +#define GL_2_BYTES 0x1407 +#define GL_3_BYTES 0x1408 +#define GL_4_BYTES 0x1409 +#define GL_EMISSION 0x1600 +#define GL_SHININESS 0x1601 +#define GL_AMBIENT_AND_DIFFUSE 0x1602 +#define GL_COLOR_INDEXES 0x1603 +#define GL_MODELVIEW 0x1700 +#define GL_PROJECTION 0x1701 +#define GL_COLOR_INDEX 0x1900 +#define GL_LUMINANCE 0x1909 +#define GL_LUMINANCE_ALPHA 0x190A +#define GL_BITMAP 0x1A00 +#define GL_RENDER 0x1C00 +#define GL_FEEDBACK 0x1C01 +#define GL_SELECT 0x1C02 +#define GL_FLAT 0x1D00 +#define GL_SMOOTH 0x1D01 +#define GL_S 0x2000 +#define GL_T 0x2001 +#define GL_R 0x2002 +#define GL_Q 0x2003 +#define GL_MODULATE 0x2100 +#define GL_DECAL 0x2101 +#define GL_TEXTURE_ENV_MODE 0x2200 +#define GL_TEXTURE_ENV_COLOR 0x2201 +#define GL_TEXTURE_ENV 0x2300 +#define GL_EYE_LINEAR 0x2400 +#define GL_OBJECT_LINEAR 0x2401 +#define GL_SPHERE_MAP 0x2402 +#define GL_TEXTURE_GEN_MODE 0x2500 +#define GL_OBJECT_PLANE 0x2501 +#define GL_EYE_PLANE 0x2502 +#define GL_CLAMP 0x2900 +#define GL_CLIP_PLANE0 0x3000 +#define GL_CLIP_PLANE1 0x3001 +#define GL_CLIP_PLANE2 0x3002 +#define GL_CLIP_PLANE3 0x3003 +#define GL_CLIP_PLANE4 0x3004 +#define GL_CLIP_PLANE5 0x3005 +#define GL_LIGHT0 0x4000 +#define GL_LIGHT1 0x4001 +#define GL_LIGHT2 0x4002 +#define GL_LIGHT3 0x4003 +#define GL_LIGHT4 0x4004 +#define GL_LIGHT5 0x4005 +#define GL_LIGHT6 0x4006 +#define GL_LIGHT7 0x4007 +#define GL_COLOR_LOGIC_OP 0x0BF2 +#define GL_POLYGON_OFFSET_UNITS 0x2A00 +#define GL_POLYGON_OFFSET_POINT 0x2A01 +#define GL_POLYGON_OFFSET_LINE 0x2A02 +#define GL_POLYGON_OFFSET_FILL 0x8037 +#define GL_POLYGON_OFFSET_FACTOR 0x8038 +#define GL_TEXTURE_BINDING_1D 0x8068 +#define GL_TEXTURE_BINDING_2D 0x8069 +#define GL_TEXTURE_INTERNAL_FORMAT 0x1003 +#define GL_TEXTURE_RED_SIZE 0x805C +#define GL_TEXTURE_GREEN_SIZE 0x805D +#define GL_TEXTURE_BLUE_SIZE 0x805E +#define GL_TEXTURE_ALPHA_SIZE 0x805F +#define GL_DOUBLE 0x140A +#define GL_PROXY_TEXTURE_1D 0x8063 +#define GL_PROXY_TEXTURE_2D 0x8064 +#define GL_R3_G3_B2 0x2A10 +#define GL_RGB4 0x804F +#define GL_RGB5 0x8050 +#define GL_RGB8 0x8051 +#define GL_RGB10 0x8052 +#define GL_RGB12 0x8053 +#define GL_RGB16 0x8054 +#define GL_RGBA2 0x8055 +#define GL_RGBA4 0x8056 +#define GL_RGB5_A1 0x8057 +#define GL_RGBA8 0x8058 +#define GL_RGB10_A2 0x8059 +#define GL_RGBA12 0x805A +#define GL_RGBA16 0x805B +#define GL_CLIENT_PIXEL_STORE_BIT 0x00000001 +#define GL_CLIENT_VERTEX_ARRAY_BIT 0x00000002 +#define GL_CLIENT_ALL_ATTRIB_BITS 0xFFFFFFFF +#define GL_VERTEX_ARRAY_POINTER 0x808E +#define GL_NORMAL_ARRAY_POINTER 0x808F +#define GL_COLOR_ARRAY_POINTER 0x8090 +#define GL_INDEX_ARRAY_POINTER 0x8091 +#define GL_TEXTURE_COORD_ARRAY_POINTER 0x8092 +#define GL_EDGE_FLAG_ARRAY_POINTER 0x8093 +#define GL_FEEDBACK_BUFFER_POINTER 0x0DF0 +#define GL_SELECTION_BUFFER_POINTER 0x0DF3 +#define GL_CLIENT_ATTRIB_STACK_DEPTH 0x0BB1 +#define GL_INDEX_LOGIC_OP 0x0BF1 +#define GL_MAX_CLIENT_ATTRIB_STACK_DEPTH 0x0D3B +#define GL_FEEDBACK_BUFFER_SIZE 0x0DF1 +#define GL_FEEDBACK_BUFFER_TYPE 0x0DF2 +#define GL_SELECTION_BUFFER_SIZE 0x0DF4 +#define GL_VERTEX_ARRAY 0x8074 +#define GL_NORMAL_ARRAY 0x8075 +#define GL_COLOR_ARRAY 0x8076 +#define GL_INDEX_ARRAY 0x8077 +#define GL_TEXTURE_COORD_ARRAY 0x8078 +#define GL_EDGE_FLAG_ARRAY 0x8079 +#define GL_VERTEX_ARRAY_SIZE 0x807A +#define GL_VERTEX_ARRAY_TYPE 0x807B +#define GL_VERTEX_ARRAY_STRIDE 0x807C +#define GL_NORMAL_ARRAY_TYPE 0x807E +#define GL_NORMAL_ARRAY_STRIDE 0x807F +#define GL_COLOR_ARRAY_SIZE 0x8081 +#define GL_COLOR_ARRAY_TYPE 0x8082 +#define GL_COLOR_ARRAY_STRIDE 0x8083 +#define GL_INDEX_ARRAY_TYPE 0x8085 +#define GL_INDEX_ARRAY_STRIDE 0x8086 +#define GL_TEXTURE_COORD_ARRAY_SIZE 0x8088 +#define GL_TEXTURE_COORD_ARRAY_TYPE 0x8089 +#define GL_TEXTURE_COORD_ARRAY_STRIDE 0x808A +#define GL_EDGE_FLAG_ARRAY_STRIDE 0x808C +#define GL_TEXTURE_LUMINANCE_SIZE 0x8060 +#define GL_TEXTURE_INTENSITY_SIZE 0x8061 +#define GL_TEXTURE_PRIORITY 0x8066 +#define GL_TEXTURE_RESIDENT 0x8067 +#define GL_ALPHA4 0x803B +#define GL_ALPHA8 0x803C +#define GL_ALPHA12 0x803D +#define GL_ALPHA16 0x803E +#define GL_LUMINANCE4 0x803F +#define GL_LUMINANCE8 0x8040 +#define GL_LUMINANCE12 0x8041 +#define GL_LUMINANCE16 0x8042 +#define GL_LUMINANCE4_ALPHA4 0x8043 +#define GL_LUMINANCE6_ALPHA2 0x8044 +#define GL_LUMINANCE8_ALPHA8 0x8045 +#define GL_LUMINANCE12_ALPHA4 0x8046 +#define GL_LUMINANCE12_ALPHA12 0x8047 +#define GL_LUMINANCE16_ALPHA16 0x8048 +#define GL_INTENSITY 0x8049 +#define GL_INTENSITY4 0x804A +#define GL_INTENSITY8 0x804B +#define GL_INTENSITY12 0x804C +#define GL_INTENSITY16 0x804D +#define GL_V2F 0x2A20 +#define GL_V3F 0x2A21 +#define GL_C4UB_V2F 0x2A22 +#define GL_C4UB_V3F 0x2A23 +#define GL_C3F_V3F 0x2A24 +#define GL_N3F_V3F 0x2A25 +#define GL_C4F_N3F_V3F 0x2A26 +#define GL_T2F_V3F 0x2A27 +#define GL_T4F_V4F 0x2A28 +#define GL_T2F_C4UB_V3F 0x2A29 +#define GL_T2F_C3F_V3F 0x2A2A +#define GL_T2F_N3F_V3F 0x2A2B +#define GL_T2F_C4F_N3F_V3F 0x2A2C +#define GL_T4F_C4F_N3F_V4F 0x2A2D +#define GL_UNSIGNED_BYTE_3_3_2 0x8032 +#define GL_UNSIGNED_SHORT_4_4_4_4 0x8033 +#define GL_UNSIGNED_SHORT_5_5_5_1 0x8034 +#define GL_UNSIGNED_INT_8_8_8_8 0x8035 +#define GL_UNSIGNED_INT_10_10_10_2 0x8036 +#define GL_TEXTURE_BINDING_3D 0x806A +#define GL_PACK_SKIP_IMAGES 0x806B +#define GL_PACK_IMAGE_HEIGHT 0x806C +#define GL_UNPACK_SKIP_IMAGES 0x806D +#define GL_UNPACK_IMAGE_HEIGHT 0x806E +#define GL_TEXTURE_3D 0x806F +#define GL_PROXY_TEXTURE_3D 0x8070 +#define GL_TEXTURE_DEPTH 0x8071 +#define GL_TEXTURE_WRAP_R 0x8072 +#define GL_MAX_3D_TEXTURE_SIZE 0x8073 +#define GL_UNSIGNED_BYTE_2_3_3_REV 0x8362 +#define GL_UNSIGNED_SHORT_5_6_5 0x8363 +#define GL_UNSIGNED_SHORT_5_6_5_REV 0x8364 +#define GL_UNSIGNED_SHORT_4_4_4_4_REV 0x8365 +#define GL_UNSIGNED_SHORT_1_5_5_5_REV 0x8366 +#define GL_UNSIGNED_INT_8_8_8_8_REV 0x8367 +#define GL_UNSIGNED_INT_2_10_10_10_REV 0x8368 +#define GL_BGR 0x80E0 +#define GL_BGRA 0x80E1 +#define GL_MAX_ELEMENTS_VERTICES 0x80E8 +#define GL_MAX_ELEMENTS_INDICES 0x80E9 +#define GL_CLAMP_TO_EDGE 0x812F +#define GL_TEXTURE_MIN_LOD 0x813A +#define GL_TEXTURE_MAX_LOD 0x813B +#define GL_TEXTURE_BASE_LEVEL 0x813C +#define GL_TEXTURE_MAX_LEVEL 0x813D +#define GL_SMOOTH_POINT_SIZE_RANGE 0x0B12 +#define GL_SMOOTH_POINT_SIZE_GRANULARITY 0x0B13 +#define GL_SMOOTH_LINE_WIDTH_RANGE 0x0B22 +#define GL_SMOOTH_LINE_WIDTH_GRANULARITY 0x0B23 +#define GL_ALIASED_LINE_WIDTH_RANGE 0x846E +#define GL_RESCALE_NORMAL 0x803A +#define GL_LIGHT_MODEL_COLOR_CONTROL 0x81F8 +#define GL_SINGLE_COLOR 0x81F9 +#define GL_SEPARATE_SPECULAR_COLOR 0x81FA +#define GL_ALIASED_POINT_SIZE_RANGE 0x846D +#define GL_TEXTURE0 0x84C0 +#define GL_TEXTURE1 0x84C1 +#define GL_TEXTURE2 0x84C2 +#define GL_TEXTURE3 0x84C3 +#define GL_TEXTURE4 0x84C4 +#define GL_TEXTURE5 0x84C5 +#define GL_TEXTURE6 0x84C6 +#define GL_TEXTURE7 0x84C7 +#define GL_TEXTURE8 0x84C8 +#define GL_TEXTURE9 0x84C9 +#define GL_TEXTURE10 0x84CA +#define GL_TEXTURE11 0x84CB +#define GL_TEXTURE12 0x84CC +#define GL_TEXTURE13 0x84CD +#define GL_TEXTURE14 0x84CE +#define GL_TEXTURE15 0x84CF +#define GL_TEXTURE16 0x84D0 +#define GL_TEXTURE17 0x84D1 +#define GL_TEXTURE18 0x84D2 +#define GL_TEXTURE19 0x84D3 +#define GL_TEXTURE20 0x84D4 +#define GL_TEXTURE21 0x84D5 +#define GL_TEXTURE22 0x84D6 +#define GL_TEXTURE23 0x84D7 +#define GL_TEXTURE24 0x84D8 +#define GL_TEXTURE25 0x84D9 +#define GL_TEXTURE26 0x84DA +#define GL_TEXTURE27 0x84DB +#define GL_TEXTURE28 0x84DC +#define GL_TEXTURE29 0x84DD +#define GL_TEXTURE30 0x84DE +#define GL_TEXTURE31 0x84DF +#define GL_ACTIVE_TEXTURE 0x84E0 +#define GL_MULTISAMPLE 0x809D +#define GL_SAMPLE_ALPHA_TO_COVERAGE 0x809E +#define GL_SAMPLE_ALPHA_TO_ONE 0x809F +#define GL_SAMPLE_COVERAGE 0x80A0 +#define GL_SAMPLE_BUFFERS 0x80A8 +#define GL_SAMPLES 0x80A9 +#define GL_SAMPLE_COVERAGE_VALUE 0x80AA +#define GL_SAMPLE_COVERAGE_INVERT 0x80AB +#define GL_TEXTURE_CUBE_MAP 0x8513 +#define GL_TEXTURE_BINDING_CUBE_MAP 0x8514 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_X 0x8515 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_X 0x8516 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_Y 0x8517 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y 0x8518 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_Z 0x8519 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z 0x851A +#define GL_PROXY_TEXTURE_CUBE_MAP 0x851B +#define GL_MAX_CUBE_MAP_TEXTURE_SIZE 0x851C +#define GL_COMPRESSED_RGB 0x84ED +#define GL_COMPRESSED_RGBA 0x84EE +#define GL_TEXTURE_COMPRESSION_HINT 0x84EF +#define GL_TEXTURE_COMPRESSED_IMAGE_SIZE 0x86A0 +#define GL_TEXTURE_COMPRESSED 0x86A1 +#define GL_NUM_COMPRESSED_TEXTURE_FORMATS 0x86A2 +#define GL_COMPRESSED_TEXTURE_FORMATS 0x86A3 +#define GL_CLAMP_TO_BORDER 0x812D +#define GL_CLIENT_ACTIVE_TEXTURE 0x84E1 +#define GL_MAX_TEXTURE_UNITS 0x84E2 +#define GL_TRANSPOSE_MODELVIEW_MATRIX 0x84E3 +#define GL_TRANSPOSE_PROJECTION_MATRIX 0x84E4 +#define GL_TRANSPOSE_TEXTURE_MATRIX 0x84E5 +#define GL_TRANSPOSE_COLOR_MATRIX 0x84E6 +#define GL_MULTISAMPLE_BIT 0x20000000 +#define GL_NORMAL_MAP 0x8511 +#define GL_REFLECTION_MAP 0x8512 +#define GL_COMPRESSED_ALPHA 0x84E9 +#define GL_COMPRESSED_LUMINANCE 0x84EA +#define GL_COMPRESSED_LUMINANCE_ALPHA 0x84EB +#define GL_COMPRESSED_INTENSITY 0x84EC +#define GL_COMBINE 0x8570 +#define GL_COMBINE_RGB 0x8571 +#define GL_COMBINE_ALPHA 0x8572 +#define GL_SOURCE0_RGB 0x8580 +#define GL_SOURCE1_RGB 0x8581 +#define GL_SOURCE2_RGB 0x8582 +#define GL_SOURCE0_ALPHA 0x8588 +#define GL_SOURCE1_ALPHA 0x8589 +#define GL_SOURCE2_ALPHA 0x858A +#define GL_OPERAND0_RGB 0x8590 +#define GL_OPERAND1_RGB 0x8591 +#define GL_OPERAND2_RGB 0x8592 +#define GL_OPERAND0_ALPHA 0x8598 +#define GL_OPERAND1_ALPHA 0x8599 +#define GL_OPERAND2_ALPHA 0x859A +#define GL_RGB_SCALE 0x8573 +#define GL_ADD_SIGNED 0x8574 +#define GL_INTERPOLATE 0x8575 +#define GL_SUBTRACT 0x84E7 +#define GL_CONSTANT 0x8576 +#define GL_PRIMARY_COLOR 0x8577 +#define GL_PREVIOUS 0x8578 +#define GL_DOT3_RGB 0x86AE +#define GL_DOT3_RGBA 0x86AF +#define GL_BLEND_DST_RGB 0x80C8 +#define GL_BLEND_SRC_RGB 0x80C9 +#define GL_BLEND_DST_ALPHA 0x80CA +#define GL_BLEND_SRC_ALPHA 0x80CB +#define GL_POINT_FADE_THRESHOLD_SIZE 0x8128 +#define GL_DEPTH_COMPONENT16 0x81A5 +#define GL_DEPTH_COMPONENT24 0x81A6 +#define GL_DEPTH_COMPONENT32 0x81A7 +#define GL_MIRRORED_REPEAT 0x8370 +#define GL_MAX_TEXTURE_LOD_BIAS 0x84FD +#define GL_TEXTURE_LOD_BIAS 0x8501 +#define GL_INCR_WRAP 0x8507 +#define GL_DECR_WRAP 0x8508 +#define GL_TEXTURE_DEPTH_SIZE 0x884A +#define GL_TEXTURE_COMPARE_MODE 0x884C +#define GL_TEXTURE_COMPARE_FUNC 0x884D +#define GL_POINT_SIZE_MIN 0x8126 +#define GL_POINT_SIZE_MAX 0x8127 +#define GL_POINT_DISTANCE_ATTENUATION 0x8129 +#define GL_GENERATE_MIPMAP 0x8191 +#define GL_GENERATE_MIPMAP_HINT 0x8192 +#define GL_FOG_COORDINATE_SOURCE 0x8450 +#define GL_FOG_COORDINATE 0x8451 +#define GL_FRAGMENT_DEPTH 0x8452 +#define GL_CURRENT_FOG_COORDINATE 0x8453 +#define GL_FOG_COORDINATE_ARRAY_TYPE 0x8454 +#define GL_FOG_COORDINATE_ARRAY_STRIDE 0x8455 +#define GL_FOG_COORDINATE_ARRAY_POINTER 0x8456 +#define GL_FOG_COORDINATE_ARRAY 0x8457 +#define GL_COLOR_SUM 0x8458 +#define GL_CURRENT_SECONDARY_COLOR 0x8459 +#define GL_SECONDARY_COLOR_ARRAY_SIZE 0x845A +#define GL_SECONDARY_COLOR_ARRAY_TYPE 0x845B +#define GL_SECONDARY_COLOR_ARRAY_STRIDE 0x845C +#define GL_SECONDARY_COLOR_ARRAY_POINTER 0x845D +#define GL_SECONDARY_COLOR_ARRAY 0x845E +#define GL_TEXTURE_FILTER_CONTROL 0x8500 +#define GL_DEPTH_TEXTURE_MODE 0x884B +#define GL_COMPARE_R_TO_TEXTURE 0x884E +#define GL_BLEND_COLOR 0x8005 +#define GL_BLEND_EQUATION 0x8009 +#define GL_CONSTANT_COLOR 0x8001 +#define GL_ONE_MINUS_CONSTANT_COLOR 0x8002 +#define GL_CONSTANT_ALPHA 0x8003 +#define GL_ONE_MINUS_CONSTANT_ALPHA 0x8004 +#define GL_FUNC_ADD 0x8006 +#define GL_FUNC_REVERSE_SUBTRACT 0x800B +#define GL_FUNC_SUBTRACT 0x800A +#define GL_MIN 0x8007 +#define GL_MAX 0x8008 +#define GL_BUFFER_SIZE 0x8764 +#define GL_BUFFER_USAGE 0x8765 +#define GL_QUERY_COUNTER_BITS 0x8864 +#define GL_CURRENT_QUERY 0x8865 +#define GL_QUERY_RESULT 0x8866 +#define GL_QUERY_RESULT_AVAILABLE 0x8867 +#define GL_ARRAY_BUFFER 0x8892 +#define GL_ELEMENT_ARRAY_BUFFER 0x8893 +#define GL_ARRAY_BUFFER_BINDING 0x8894 +#define GL_ELEMENT_ARRAY_BUFFER_BINDING 0x8895 +#define GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING 0x889F +#define GL_READ_ONLY 0x88B8 +#define GL_WRITE_ONLY 0x88B9 +#define GL_READ_WRITE 0x88BA +#define GL_BUFFER_ACCESS 0x88BB +#define GL_BUFFER_MAPPED 0x88BC +#define GL_BUFFER_MAP_POINTER 0x88BD +#define GL_STREAM_DRAW 0x88E0 +#define GL_STREAM_READ 0x88E1 +#define GL_STREAM_COPY 0x88E2 +#define GL_STATIC_DRAW 0x88E4 +#define GL_STATIC_READ 0x88E5 +#define GL_STATIC_COPY 0x88E6 +#define GL_DYNAMIC_DRAW 0x88E8 +#define GL_DYNAMIC_READ 0x88E9 +#define GL_DYNAMIC_COPY 0x88EA +#define GL_SAMPLES_PASSED 0x8914 +#define GL_SRC1_ALPHA 0x8589 +#define GL_VERTEX_ARRAY_BUFFER_BINDING 0x8896 +#define GL_NORMAL_ARRAY_BUFFER_BINDING 0x8897 +#define GL_COLOR_ARRAY_BUFFER_BINDING 0x8898 +#define GL_INDEX_ARRAY_BUFFER_BINDING 0x8899 +#define GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING 0x889A +#define GL_EDGE_FLAG_ARRAY_BUFFER_BINDING 0x889B +#define GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING 0x889C +#define GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING 0x889D +#define GL_WEIGHT_ARRAY_BUFFER_BINDING 0x889E +#define GL_FOG_COORD_SRC 0x8450 +#define GL_FOG_COORD 0x8451 +#define GL_CURRENT_FOG_COORD 0x8453 +#define GL_FOG_COORD_ARRAY_TYPE 0x8454 +#define GL_FOG_COORD_ARRAY_STRIDE 0x8455 +#define GL_FOG_COORD_ARRAY_POINTER 0x8456 +#define GL_FOG_COORD_ARRAY 0x8457 +#define GL_FOG_COORD_ARRAY_BUFFER_BINDING 0x889D +#define GL_SRC0_RGB 0x8580 +#define GL_SRC1_RGB 0x8581 +#define GL_SRC2_RGB 0x8582 +#define GL_SRC0_ALPHA 0x8588 +#define GL_SRC2_ALPHA 0x858A +#define GL_BLEND_EQUATION_RGB 0x8009 +#define GL_VERTEX_ATTRIB_ARRAY_ENABLED 0x8622 +#define GL_VERTEX_ATTRIB_ARRAY_SIZE 0x8623 +#define GL_VERTEX_ATTRIB_ARRAY_STRIDE 0x8624 +#define GL_VERTEX_ATTRIB_ARRAY_TYPE 0x8625 +#define GL_CURRENT_VERTEX_ATTRIB 0x8626 +#define GL_VERTEX_PROGRAM_POINT_SIZE 0x8642 +#define GL_VERTEX_ATTRIB_ARRAY_POINTER 0x8645 +#define GL_STENCIL_BACK_FUNC 0x8800 +#define GL_STENCIL_BACK_FAIL 0x8801 +#define GL_STENCIL_BACK_PASS_DEPTH_FAIL 0x8802 +#define GL_STENCIL_BACK_PASS_DEPTH_PASS 0x8803 +#define GL_MAX_DRAW_BUFFERS 0x8824 +#define GL_DRAW_BUFFER0 0x8825 +#define GL_DRAW_BUFFER1 0x8826 +#define GL_DRAW_BUFFER2 0x8827 +#define GL_DRAW_BUFFER3 0x8828 +#define GL_DRAW_BUFFER4 0x8829 +#define GL_DRAW_BUFFER5 0x882A +#define GL_DRAW_BUFFER6 0x882B +#define GL_DRAW_BUFFER7 0x882C +#define GL_DRAW_BUFFER8 0x882D +#define GL_DRAW_BUFFER9 0x882E +#define GL_DRAW_BUFFER10 0x882F +#define GL_DRAW_BUFFER11 0x8830 +#define GL_DRAW_BUFFER12 0x8831 +#define GL_DRAW_BUFFER13 0x8832 +#define GL_DRAW_BUFFER14 0x8833 +#define GL_DRAW_BUFFER15 0x8834 +#define GL_BLEND_EQUATION_ALPHA 0x883D +#define GL_MAX_VERTEX_ATTRIBS 0x8869 +#define GL_VERTEX_ATTRIB_ARRAY_NORMALIZED 0x886A +#define GL_MAX_TEXTURE_IMAGE_UNITS 0x8872 +#define GL_FRAGMENT_SHADER 0x8B30 +#define GL_VERTEX_SHADER 0x8B31 +#define GL_MAX_FRAGMENT_UNIFORM_COMPONENTS 0x8B49 +#define GL_MAX_VERTEX_UNIFORM_COMPONENTS 0x8B4A +#define GL_MAX_VARYING_FLOATS 0x8B4B +#define GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS 0x8B4C +#define GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS 0x8B4D +#define GL_SHADER_TYPE 0x8B4F +#define GL_FLOAT_VEC2 0x8B50 +#define GL_FLOAT_VEC3 0x8B51 +#define GL_FLOAT_VEC4 0x8B52 +#define GL_INT_VEC2 0x8B53 +#define GL_INT_VEC3 0x8B54 +#define GL_INT_VEC4 0x8B55 +#define GL_BOOL 0x8B56 +#define GL_BOOL_VEC2 0x8B57 +#define GL_BOOL_VEC3 0x8B58 +#define GL_BOOL_VEC4 0x8B59 +#define GL_FLOAT_MAT2 0x8B5A +#define GL_FLOAT_MAT3 0x8B5B +#define GL_FLOAT_MAT4 0x8B5C +#define GL_SAMPLER_1D 0x8B5D +#define GL_SAMPLER_2D 0x8B5E +#define GL_SAMPLER_3D 0x8B5F +#define GL_SAMPLER_CUBE 0x8B60 +#define GL_SAMPLER_1D_SHADOW 0x8B61 +#define GL_SAMPLER_2D_SHADOW 0x8B62 +#define GL_DELETE_STATUS 0x8B80 +#define GL_COMPILE_STATUS 0x8B81 +#define GL_LINK_STATUS 0x8B82 +#define GL_VALIDATE_STATUS 0x8B83 +#define GL_INFO_LOG_LENGTH 0x8B84 +#define GL_ATTACHED_SHADERS 0x8B85 +#define GL_ACTIVE_UNIFORMS 0x8B86 +#define GL_ACTIVE_UNIFORM_MAX_LENGTH 0x8B87 +#define GL_SHADER_SOURCE_LENGTH 0x8B88 +#define GL_ACTIVE_ATTRIBUTES 0x8B89 +#define GL_ACTIVE_ATTRIBUTE_MAX_LENGTH 0x8B8A +#define GL_FRAGMENT_SHADER_DERIVATIVE_HINT 0x8B8B +#define GL_SHADING_LANGUAGE_VERSION 0x8B8C +#define GL_CURRENT_PROGRAM 0x8B8D +#define GL_POINT_SPRITE_COORD_ORIGIN 0x8CA0 +#define GL_LOWER_LEFT 0x8CA1 +#define GL_UPPER_LEFT 0x8CA2 +#define GL_STENCIL_BACK_REF 0x8CA3 +#define GL_STENCIL_BACK_VALUE_MASK 0x8CA4 +#define GL_STENCIL_BACK_WRITEMASK 0x8CA5 +#define GL_VERTEX_PROGRAM_TWO_SIDE 0x8643 +#define GL_POINT_SPRITE 0x8861 +#define GL_COORD_REPLACE 0x8862 +#define GL_MAX_TEXTURE_COORDS 0x8871 +#define GL_PIXEL_PACK_BUFFER 0x88EB +#define GL_PIXEL_UNPACK_BUFFER 0x88EC +#define GL_PIXEL_PACK_BUFFER_BINDING 0x88ED +#define GL_PIXEL_UNPACK_BUFFER_BINDING 0x88EF +#define GL_FLOAT_MAT2x3 0x8B65 +#define GL_FLOAT_MAT2x4 0x8B66 +#define GL_FLOAT_MAT3x2 0x8B67 +#define GL_FLOAT_MAT3x4 0x8B68 +#define GL_FLOAT_MAT4x2 0x8B69 +#define GL_FLOAT_MAT4x3 0x8B6A +#define GL_SRGB 0x8C40 +#define GL_SRGB8 0x8C41 +#define GL_SRGB_ALPHA 0x8C42 +#define GL_SRGB8_ALPHA8 0x8C43 +#define GL_COMPRESSED_SRGB 0x8C48 +#define GL_COMPRESSED_SRGB_ALPHA 0x8C49 +#define GL_CURRENT_RASTER_SECONDARY_COLOR 0x845F +#define GL_SLUMINANCE_ALPHA 0x8C44 +#define GL_SLUMINANCE8_ALPHA8 0x8C45 +#define GL_SLUMINANCE 0x8C46 +#define GL_SLUMINANCE8 0x8C47 +#define GL_COMPRESSED_SLUMINANCE 0x8C4A +#define GL_COMPRESSED_SLUMINANCE_ALPHA 0x8C4B +#ifndef GL_VERSION_1_0 +#define GL_VERSION_1_0 1 +GLAPI int GLAD_GL_VERSION_1_0; +typedef void (APIENTRYP PFNGLCULLFACEPROC)(GLenum mode); +GLAPI PFNGLCULLFACEPROC glad_glCullFace; +#define glCullFace glad_glCullFace +typedef void (APIENTRYP PFNGLFRONTFACEPROC)(GLenum mode); +GLAPI PFNGLFRONTFACEPROC glad_glFrontFace; +#define glFrontFace glad_glFrontFace +typedef void (APIENTRYP PFNGLHINTPROC)(GLenum target, GLenum mode); +GLAPI PFNGLHINTPROC glad_glHint; +#define glHint glad_glHint +typedef void (APIENTRYP PFNGLLINEWIDTHPROC)(GLfloat width); +GLAPI PFNGLLINEWIDTHPROC glad_glLineWidth; +#define glLineWidth glad_glLineWidth +typedef void (APIENTRYP PFNGLPOINTSIZEPROC)(GLfloat size); +GLAPI PFNGLPOINTSIZEPROC glad_glPointSize; +#define glPointSize glad_glPointSize +typedef void (APIENTRYP PFNGLPOLYGONMODEPROC)(GLenum face, GLenum mode); +GLAPI PFNGLPOLYGONMODEPROC glad_glPolygonMode; +#define glPolygonMode glad_glPolygonMode +typedef void (APIENTRYP PFNGLSCISSORPROC)(GLint x, GLint y, GLsizei width, GLsizei height); +GLAPI PFNGLSCISSORPROC glad_glScissor; +#define glScissor glad_glScissor +typedef void (APIENTRYP PFNGLTEXPARAMETERFPROC)(GLenum target, GLenum pname, GLfloat param); +GLAPI PFNGLTEXPARAMETERFPROC glad_glTexParameterf; +#define glTexParameterf glad_glTexParameterf +typedef void (APIENTRYP PFNGLTEXPARAMETERFVPROC)(GLenum target, GLenum pname, const GLfloat *params); +GLAPI PFNGLTEXPARAMETERFVPROC glad_glTexParameterfv; +#define glTexParameterfv glad_glTexParameterfv +typedef void (APIENTRYP PFNGLTEXPARAMETERIPROC)(GLenum target, GLenum pname, GLint param); +GLAPI PFNGLTEXPARAMETERIPROC glad_glTexParameteri; +#define glTexParameteri glad_glTexParameteri +typedef void (APIENTRYP PFNGLTEXPARAMETERIVPROC)(GLenum target, GLenum pname, const GLint *params); +GLAPI PFNGLTEXPARAMETERIVPROC glad_glTexParameteriv; +#define glTexParameteriv glad_glTexParameteriv +typedef void (APIENTRYP PFNGLTEXIMAGE1DPROC)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXIMAGE1DPROC glad_glTexImage1D; +#define glTexImage1D glad_glTexImage1D +typedef void (APIENTRYP PFNGLTEXIMAGE2DPROC)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXIMAGE2DPROC glad_glTexImage2D; +#define glTexImage2D glad_glTexImage2D +typedef void (APIENTRYP PFNGLDRAWBUFFERPROC)(GLenum buf); +GLAPI PFNGLDRAWBUFFERPROC glad_glDrawBuffer; +#define glDrawBuffer glad_glDrawBuffer +typedef void (APIENTRYP PFNGLCLEARPROC)(GLbitfield mask); +GLAPI PFNGLCLEARPROC glad_glClear; +#define glClear glad_glClear +typedef void (APIENTRYP PFNGLCLEARCOLORPROC)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +GLAPI PFNGLCLEARCOLORPROC glad_glClearColor; +#define glClearColor glad_glClearColor +typedef void (APIENTRYP PFNGLCLEARSTENCILPROC)(GLint s); +GLAPI PFNGLCLEARSTENCILPROC glad_glClearStencil; +#define glClearStencil glad_glClearStencil +typedef void (APIENTRYP PFNGLCLEARDEPTHPROC)(GLdouble depth); +GLAPI PFNGLCLEARDEPTHPROC glad_glClearDepth; +#define glClearDepth glad_glClearDepth +typedef void (APIENTRYP PFNGLSTENCILMASKPROC)(GLuint mask); +GLAPI PFNGLSTENCILMASKPROC glad_glStencilMask; +#define glStencilMask glad_glStencilMask +typedef void (APIENTRYP PFNGLCOLORMASKPROC)(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); +GLAPI PFNGLCOLORMASKPROC glad_glColorMask; +#define glColorMask glad_glColorMask +typedef void (APIENTRYP PFNGLDEPTHMASKPROC)(GLboolean flag); +GLAPI PFNGLDEPTHMASKPROC glad_glDepthMask; +#define glDepthMask glad_glDepthMask +typedef void (APIENTRYP PFNGLDISABLEPROC)(GLenum cap); +GLAPI PFNGLDISABLEPROC glad_glDisable; +#define glDisable glad_glDisable +typedef void (APIENTRYP PFNGLENABLEPROC)(GLenum cap); +GLAPI PFNGLENABLEPROC glad_glEnable; +#define glEnable glad_glEnable +typedef void (APIENTRYP PFNGLFINISHPROC)(void); +GLAPI PFNGLFINISHPROC glad_glFinish; +#define glFinish glad_glFinish +typedef void (APIENTRYP PFNGLFLUSHPROC)(void); +GLAPI PFNGLFLUSHPROC glad_glFlush; +#define glFlush glad_glFlush +typedef void (APIENTRYP PFNGLBLENDFUNCPROC)(GLenum sfactor, GLenum dfactor); +GLAPI PFNGLBLENDFUNCPROC glad_glBlendFunc; +#define glBlendFunc glad_glBlendFunc +typedef void (APIENTRYP PFNGLLOGICOPPROC)(GLenum opcode); +GLAPI PFNGLLOGICOPPROC glad_glLogicOp; +#define glLogicOp glad_glLogicOp +typedef void (APIENTRYP PFNGLSTENCILFUNCPROC)(GLenum func, GLint ref, GLuint mask); +GLAPI PFNGLSTENCILFUNCPROC glad_glStencilFunc; +#define glStencilFunc glad_glStencilFunc +typedef void (APIENTRYP PFNGLSTENCILOPPROC)(GLenum fail, GLenum zfail, GLenum zpass); +GLAPI PFNGLSTENCILOPPROC glad_glStencilOp; +#define glStencilOp glad_glStencilOp +typedef void (APIENTRYP PFNGLDEPTHFUNCPROC)(GLenum func); +GLAPI PFNGLDEPTHFUNCPROC glad_glDepthFunc; +#define glDepthFunc glad_glDepthFunc +typedef void (APIENTRYP PFNGLPIXELSTOREFPROC)(GLenum pname, GLfloat param); +GLAPI PFNGLPIXELSTOREFPROC glad_glPixelStoref; +#define glPixelStoref glad_glPixelStoref +typedef void (APIENTRYP PFNGLPIXELSTOREIPROC)(GLenum pname, GLint param); +GLAPI PFNGLPIXELSTOREIPROC glad_glPixelStorei; +#define glPixelStorei glad_glPixelStorei +typedef void (APIENTRYP PFNGLREADBUFFERPROC)(GLenum src); +GLAPI PFNGLREADBUFFERPROC glad_glReadBuffer; +#define glReadBuffer glad_glReadBuffer +typedef void (APIENTRYP PFNGLREADPIXELSPROC)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *pixels); +GLAPI PFNGLREADPIXELSPROC glad_glReadPixels; +#define glReadPixels glad_glReadPixels +typedef void (APIENTRYP PFNGLGETBOOLEANVPROC)(GLenum pname, GLboolean *data); +GLAPI PFNGLGETBOOLEANVPROC glad_glGetBooleanv; +#define glGetBooleanv glad_glGetBooleanv +typedef void (APIENTRYP PFNGLGETDOUBLEVPROC)(GLenum pname, GLdouble *data); +GLAPI PFNGLGETDOUBLEVPROC glad_glGetDoublev; +#define glGetDoublev glad_glGetDoublev +typedef GLenum (APIENTRYP PFNGLGETERRORPROC)(void); +GLAPI PFNGLGETERRORPROC glad_glGetError; +#define glGetError glad_glGetError +typedef void (APIENTRYP PFNGLGETFLOATVPROC)(GLenum pname, GLfloat *data); +GLAPI PFNGLGETFLOATVPROC glad_glGetFloatv; +#define glGetFloatv glad_glGetFloatv +typedef void (APIENTRYP PFNGLGETINTEGERVPROC)(GLenum pname, GLint *data); +GLAPI PFNGLGETINTEGERVPROC glad_glGetIntegerv; +#define glGetIntegerv glad_glGetIntegerv +typedef const GLubyte * (APIENTRYP PFNGLGETSTRINGPROC)(GLenum name); +GLAPI PFNGLGETSTRINGPROC glad_glGetString; +#define glGetString glad_glGetString +typedef void (APIENTRYP PFNGLGETTEXIMAGEPROC)(GLenum target, GLint level, GLenum format, GLenum type, void *pixels); +GLAPI PFNGLGETTEXIMAGEPROC glad_glGetTexImage; +#define glGetTexImage glad_glGetTexImage +typedef void (APIENTRYP PFNGLGETTEXPARAMETERFVPROC)(GLenum target, GLenum pname, GLfloat *params); +GLAPI PFNGLGETTEXPARAMETERFVPROC glad_glGetTexParameterfv; +#define glGetTexParameterfv glad_glGetTexParameterfv +typedef void (APIENTRYP PFNGLGETTEXPARAMETERIVPROC)(GLenum target, GLenum pname, GLint *params); +GLAPI PFNGLGETTEXPARAMETERIVPROC glad_glGetTexParameteriv; +#define glGetTexParameteriv glad_glGetTexParameteriv +typedef void (APIENTRYP PFNGLGETTEXLEVELPARAMETERFVPROC)(GLenum target, GLint level, GLenum pname, GLfloat *params); +GLAPI PFNGLGETTEXLEVELPARAMETERFVPROC glad_glGetTexLevelParameterfv; +#define glGetTexLevelParameterfv glad_glGetTexLevelParameterfv +typedef void (APIENTRYP PFNGLGETTEXLEVELPARAMETERIVPROC)(GLenum target, GLint level, GLenum pname, GLint *params); +GLAPI PFNGLGETTEXLEVELPARAMETERIVPROC glad_glGetTexLevelParameteriv; +#define glGetTexLevelParameteriv glad_glGetTexLevelParameteriv +typedef GLboolean (APIENTRYP PFNGLISENABLEDPROC)(GLenum cap); +GLAPI PFNGLISENABLEDPROC glad_glIsEnabled; +#define glIsEnabled glad_glIsEnabled +typedef void (APIENTRYP PFNGLDEPTHRANGEPROC)(GLdouble n, GLdouble f); +GLAPI PFNGLDEPTHRANGEPROC glad_glDepthRange; +#define glDepthRange glad_glDepthRange +typedef void (APIENTRYP PFNGLVIEWPORTPROC)(GLint x, GLint y, GLsizei width, GLsizei height); +GLAPI PFNGLVIEWPORTPROC glad_glViewport; +#define glViewport glad_glViewport +typedef void (APIENTRYP PFNGLNEWLISTPROC)(GLuint list, GLenum mode); +GLAPI PFNGLNEWLISTPROC glad_glNewList; +#define glNewList glad_glNewList +typedef void (APIENTRYP PFNGLENDLISTPROC)(void); +GLAPI PFNGLENDLISTPROC glad_glEndList; +#define glEndList glad_glEndList +typedef void (APIENTRYP PFNGLCALLLISTPROC)(GLuint list); +GLAPI PFNGLCALLLISTPROC glad_glCallList; +#define glCallList glad_glCallList +typedef void (APIENTRYP PFNGLCALLLISTSPROC)(GLsizei n, GLenum type, const void *lists); +GLAPI PFNGLCALLLISTSPROC glad_glCallLists; +#define glCallLists glad_glCallLists +typedef void (APIENTRYP PFNGLDELETELISTSPROC)(GLuint list, GLsizei range); +GLAPI PFNGLDELETELISTSPROC glad_glDeleteLists; +#define glDeleteLists glad_glDeleteLists +typedef GLuint (APIENTRYP PFNGLGENLISTSPROC)(GLsizei range); +GLAPI PFNGLGENLISTSPROC glad_glGenLists; +#define glGenLists glad_glGenLists +typedef void (APIENTRYP PFNGLLISTBASEPROC)(GLuint base); +GLAPI PFNGLLISTBASEPROC glad_glListBase; +#define glListBase glad_glListBase +typedef void (APIENTRYP PFNGLBEGINPROC)(GLenum mode); +GLAPI PFNGLBEGINPROC glad_glBegin; +#define glBegin glad_glBegin +typedef void (APIENTRYP PFNGLBITMAPPROC)(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap); +GLAPI PFNGLBITMAPPROC glad_glBitmap; +#define glBitmap glad_glBitmap +typedef void (APIENTRYP PFNGLCOLOR3BPROC)(GLbyte red, GLbyte green, GLbyte blue); +GLAPI PFNGLCOLOR3BPROC glad_glColor3b; +#define glColor3b glad_glColor3b +typedef void (APIENTRYP PFNGLCOLOR3BVPROC)(const GLbyte *v); +GLAPI PFNGLCOLOR3BVPROC glad_glColor3bv; +#define glColor3bv glad_glColor3bv +typedef void (APIENTRYP PFNGLCOLOR3DPROC)(GLdouble red, GLdouble green, GLdouble blue); +GLAPI PFNGLCOLOR3DPROC glad_glColor3d; +#define glColor3d glad_glColor3d +typedef void (APIENTRYP PFNGLCOLOR3DVPROC)(const GLdouble *v); +GLAPI PFNGLCOLOR3DVPROC glad_glColor3dv; +#define glColor3dv glad_glColor3dv +typedef void (APIENTRYP PFNGLCOLOR3FPROC)(GLfloat red, GLfloat green, GLfloat blue); +GLAPI PFNGLCOLOR3FPROC glad_glColor3f; +#define glColor3f glad_glColor3f +typedef void (APIENTRYP PFNGLCOLOR3FVPROC)(const GLfloat *v); +GLAPI PFNGLCOLOR3FVPROC glad_glColor3fv; +#define glColor3fv glad_glColor3fv +typedef void (APIENTRYP PFNGLCOLOR3IPROC)(GLint red, GLint green, GLint blue); +GLAPI PFNGLCOLOR3IPROC glad_glColor3i; +#define glColor3i glad_glColor3i +typedef void (APIENTRYP PFNGLCOLOR3IVPROC)(const GLint *v); +GLAPI PFNGLCOLOR3IVPROC glad_glColor3iv; +#define glColor3iv glad_glColor3iv +typedef void (APIENTRYP PFNGLCOLOR3SPROC)(GLshort red, GLshort green, GLshort blue); +GLAPI PFNGLCOLOR3SPROC glad_glColor3s; +#define glColor3s glad_glColor3s +typedef void (APIENTRYP PFNGLCOLOR3SVPROC)(const GLshort *v); +GLAPI PFNGLCOLOR3SVPROC glad_glColor3sv; +#define glColor3sv glad_glColor3sv +typedef void (APIENTRYP PFNGLCOLOR3UBPROC)(GLubyte red, GLubyte green, GLubyte blue); +GLAPI PFNGLCOLOR3UBPROC glad_glColor3ub; +#define glColor3ub glad_glColor3ub +typedef void (APIENTRYP PFNGLCOLOR3UBVPROC)(const GLubyte *v); +GLAPI PFNGLCOLOR3UBVPROC glad_glColor3ubv; +#define glColor3ubv glad_glColor3ubv +typedef void (APIENTRYP PFNGLCOLOR3UIPROC)(GLuint red, GLuint green, GLuint blue); +GLAPI PFNGLCOLOR3UIPROC glad_glColor3ui; +#define glColor3ui glad_glColor3ui +typedef void (APIENTRYP PFNGLCOLOR3UIVPROC)(const GLuint *v); +GLAPI PFNGLCOLOR3UIVPROC glad_glColor3uiv; +#define glColor3uiv glad_glColor3uiv +typedef void (APIENTRYP PFNGLCOLOR3USPROC)(GLushort red, GLushort green, GLushort blue); +GLAPI PFNGLCOLOR3USPROC glad_glColor3us; +#define glColor3us glad_glColor3us +typedef void (APIENTRYP PFNGLCOLOR3USVPROC)(const GLushort *v); +GLAPI PFNGLCOLOR3USVPROC glad_glColor3usv; +#define glColor3usv glad_glColor3usv +typedef void (APIENTRYP PFNGLCOLOR4BPROC)(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha); +GLAPI PFNGLCOLOR4BPROC glad_glColor4b; +#define glColor4b glad_glColor4b +typedef void (APIENTRYP PFNGLCOLOR4BVPROC)(const GLbyte *v); +GLAPI PFNGLCOLOR4BVPROC glad_glColor4bv; +#define glColor4bv glad_glColor4bv +typedef void (APIENTRYP PFNGLCOLOR4DPROC)(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha); +GLAPI PFNGLCOLOR4DPROC glad_glColor4d; +#define glColor4d glad_glColor4d +typedef void (APIENTRYP PFNGLCOLOR4DVPROC)(const GLdouble *v); +GLAPI PFNGLCOLOR4DVPROC glad_glColor4dv; +#define glColor4dv glad_glColor4dv +typedef void (APIENTRYP PFNGLCOLOR4FPROC)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +GLAPI PFNGLCOLOR4FPROC glad_glColor4f; +#define glColor4f glad_glColor4f +typedef void (APIENTRYP PFNGLCOLOR4FVPROC)(const GLfloat *v); +GLAPI PFNGLCOLOR4FVPROC glad_glColor4fv; +#define glColor4fv glad_glColor4fv +typedef void (APIENTRYP PFNGLCOLOR4IPROC)(GLint red, GLint green, GLint blue, GLint alpha); +GLAPI PFNGLCOLOR4IPROC glad_glColor4i; +#define glColor4i glad_glColor4i +typedef void (APIENTRYP PFNGLCOLOR4IVPROC)(const GLint *v); +GLAPI PFNGLCOLOR4IVPROC glad_glColor4iv; +#define glColor4iv glad_glColor4iv +typedef void (APIENTRYP PFNGLCOLOR4SPROC)(GLshort red, GLshort green, GLshort blue, GLshort alpha); +GLAPI PFNGLCOLOR4SPROC glad_glColor4s; +#define glColor4s glad_glColor4s +typedef void (APIENTRYP PFNGLCOLOR4SVPROC)(const GLshort *v); +GLAPI PFNGLCOLOR4SVPROC glad_glColor4sv; +#define glColor4sv glad_glColor4sv +typedef void (APIENTRYP PFNGLCOLOR4UBPROC)(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha); +GLAPI PFNGLCOLOR4UBPROC glad_glColor4ub; +#define glColor4ub glad_glColor4ub +typedef void (APIENTRYP PFNGLCOLOR4UBVPROC)(const GLubyte *v); +GLAPI PFNGLCOLOR4UBVPROC glad_glColor4ubv; +#define glColor4ubv glad_glColor4ubv +typedef void (APIENTRYP PFNGLCOLOR4UIPROC)(GLuint red, GLuint green, GLuint blue, GLuint alpha); +GLAPI PFNGLCOLOR4UIPROC glad_glColor4ui; +#define glColor4ui glad_glColor4ui +typedef void (APIENTRYP PFNGLCOLOR4UIVPROC)(const GLuint *v); +GLAPI PFNGLCOLOR4UIVPROC glad_glColor4uiv; +#define glColor4uiv glad_glColor4uiv +typedef void (APIENTRYP PFNGLCOLOR4USPROC)(GLushort red, GLushort green, GLushort blue, GLushort alpha); +GLAPI PFNGLCOLOR4USPROC glad_glColor4us; +#define glColor4us glad_glColor4us +typedef void (APIENTRYP PFNGLCOLOR4USVPROC)(const GLushort *v); +GLAPI PFNGLCOLOR4USVPROC glad_glColor4usv; +#define glColor4usv glad_glColor4usv +typedef void (APIENTRYP PFNGLEDGEFLAGPROC)(GLboolean flag); +GLAPI PFNGLEDGEFLAGPROC glad_glEdgeFlag; +#define glEdgeFlag glad_glEdgeFlag +typedef void (APIENTRYP PFNGLEDGEFLAGVPROC)(const GLboolean *flag); +GLAPI PFNGLEDGEFLAGVPROC glad_glEdgeFlagv; +#define glEdgeFlagv glad_glEdgeFlagv +typedef void (APIENTRYP PFNGLENDPROC)(void); +GLAPI PFNGLENDPROC glad_glEnd; +#define glEnd glad_glEnd +typedef void (APIENTRYP PFNGLINDEXDPROC)(GLdouble c); +GLAPI PFNGLINDEXDPROC glad_glIndexd; +#define glIndexd glad_glIndexd +typedef void (APIENTRYP PFNGLINDEXDVPROC)(const GLdouble *c); +GLAPI PFNGLINDEXDVPROC glad_glIndexdv; +#define glIndexdv glad_glIndexdv +typedef void (APIENTRYP PFNGLINDEXFPROC)(GLfloat c); +GLAPI PFNGLINDEXFPROC glad_glIndexf; +#define glIndexf glad_glIndexf +typedef void (APIENTRYP PFNGLINDEXFVPROC)(const GLfloat *c); +GLAPI PFNGLINDEXFVPROC glad_glIndexfv; +#define glIndexfv glad_glIndexfv +typedef void (APIENTRYP PFNGLINDEXIPROC)(GLint c); +GLAPI PFNGLINDEXIPROC glad_glIndexi; +#define glIndexi glad_glIndexi +typedef void (APIENTRYP PFNGLINDEXIVPROC)(const GLint *c); +GLAPI PFNGLINDEXIVPROC glad_glIndexiv; +#define glIndexiv glad_glIndexiv +typedef void (APIENTRYP PFNGLINDEXSPROC)(GLshort c); +GLAPI PFNGLINDEXSPROC glad_glIndexs; +#define glIndexs glad_glIndexs +typedef void (APIENTRYP PFNGLINDEXSVPROC)(const GLshort *c); +GLAPI PFNGLINDEXSVPROC glad_glIndexsv; +#define glIndexsv glad_glIndexsv +typedef void (APIENTRYP PFNGLNORMAL3BPROC)(GLbyte nx, GLbyte ny, GLbyte nz); +GLAPI PFNGLNORMAL3BPROC glad_glNormal3b; +#define glNormal3b glad_glNormal3b +typedef void (APIENTRYP PFNGLNORMAL3BVPROC)(const GLbyte *v); +GLAPI PFNGLNORMAL3BVPROC glad_glNormal3bv; +#define glNormal3bv glad_glNormal3bv +typedef void (APIENTRYP PFNGLNORMAL3DPROC)(GLdouble nx, GLdouble ny, GLdouble nz); +GLAPI PFNGLNORMAL3DPROC glad_glNormal3d; +#define glNormal3d glad_glNormal3d +typedef void (APIENTRYP PFNGLNORMAL3DVPROC)(const GLdouble *v); +GLAPI PFNGLNORMAL3DVPROC glad_glNormal3dv; +#define glNormal3dv glad_glNormal3dv +typedef void (APIENTRYP PFNGLNORMAL3FPROC)(GLfloat nx, GLfloat ny, GLfloat nz); +GLAPI PFNGLNORMAL3FPROC glad_glNormal3f; +#define glNormal3f glad_glNormal3f +typedef void (APIENTRYP PFNGLNORMAL3FVPROC)(const GLfloat *v); +GLAPI PFNGLNORMAL3FVPROC glad_glNormal3fv; +#define glNormal3fv glad_glNormal3fv +typedef void (APIENTRYP PFNGLNORMAL3IPROC)(GLint nx, GLint ny, GLint nz); +GLAPI PFNGLNORMAL3IPROC glad_glNormal3i; +#define glNormal3i glad_glNormal3i +typedef void (APIENTRYP PFNGLNORMAL3IVPROC)(const GLint *v); +GLAPI PFNGLNORMAL3IVPROC glad_glNormal3iv; +#define glNormal3iv glad_glNormal3iv +typedef void (APIENTRYP PFNGLNORMAL3SPROC)(GLshort nx, GLshort ny, GLshort nz); +GLAPI PFNGLNORMAL3SPROC glad_glNormal3s; +#define glNormal3s glad_glNormal3s +typedef void (APIENTRYP PFNGLNORMAL3SVPROC)(const GLshort *v); +GLAPI PFNGLNORMAL3SVPROC glad_glNormal3sv; +#define glNormal3sv glad_glNormal3sv +typedef void (APIENTRYP PFNGLRASTERPOS2DPROC)(GLdouble x, GLdouble y); +GLAPI PFNGLRASTERPOS2DPROC glad_glRasterPos2d; +#define glRasterPos2d glad_glRasterPos2d +typedef void (APIENTRYP PFNGLRASTERPOS2DVPROC)(const GLdouble *v); +GLAPI PFNGLRASTERPOS2DVPROC glad_glRasterPos2dv; +#define glRasterPos2dv glad_glRasterPos2dv +typedef void (APIENTRYP PFNGLRASTERPOS2FPROC)(GLfloat x, GLfloat y); +GLAPI PFNGLRASTERPOS2FPROC glad_glRasterPos2f; +#define glRasterPos2f glad_glRasterPos2f +typedef void (APIENTRYP PFNGLRASTERPOS2FVPROC)(const GLfloat *v); +GLAPI PFNGLRASTERPOS2FVPROC glad_glRasterPos2fv; +#define glRasterPos2fv glad_glRasterPos2fv +typedef void (APIENTRYP PFNGLRASTERPOS2IPROC)(GLint x, GLint y); +GLAPI PFNGLRASTERPOS2IPROC glad_glRasterPos2i; +#define glRasterPos2i glad_glRasterPos2i +typedef void (APIENTRYP PFNGLRASTERPOS2IVPROC)(const GLint *v); +GLAPI PFNGLRASTERPOS2IVPROC glad_glRasterPos2iv; +#define glRasterPos2iv glad_glRasterPos2iv +typedef void (APIENTRYP PFNGLRASTERPOS2SPROC)(GLshort x, GLshort y); +GLAPI PFNGLRASTERPOS2SPROC glad_glRasterPos2s; +#define glRasterPos2s glad_glRasterPos2s +typedef void (APIENTRYP PFNGLRASTERPOS2SVPROC)(const GLshort *v); +GLAPI PFNGLRASTERPOS2SVPROC glad_glRasterPos2sv; +#define glRasterPos2sv glad_glRasterPos2sv +typedef void (APIENTRYP PFNGLRASTERPOS3DPROC)(GLdouble x, GLdouble y, GLdouble z); +GLAPI PFNGLRASTERPOS3DPROC glad_glRasterPos3d; +#define glRasterPos3d glad_glRasterPos3d +typedef void (APIENTRYP PFNGLRASTERPOS3DVPROC)(const GLdouble *v); +GLAPI PFNGLRASTERPOS3DVPROC glad_glRasterPos3dv; +#define glRasterPos3dv glad_glRasterPos3dv +typedef void (APIENTRYP PFNGLRASTERPOS3FPROC)(GLfloat x, GLfloat y, GLfloat z); +GLAPI PFNGLRASTERPOS3FPROC glad_glRasterPos3f; +#define glRasterPos3f glad_glRasterPos3f +typedef void (APIENTRYP PFNGLRASTERPOS3FVPROC)(const GLfloat *v); +GLAPI PFNGLRASTERPOS3FVPROC glad_glRasterPos3fv; +#define glRasterPos3fv glad_glRasterPos3fv +typedef void (APIENTRYP PFNGLRASTERPOS3IPROC)(GLint x, GLint y, GLint z); +GLAPI PFNGLRASTERPOS3IPROC glad_glRasterPos3i; +#define glRasterPos3i glad_glRasterPos3i +typedef void (APIENTRYP PFNGLRASTERPOS3IVPROC)(const GLint *v); +GLAPI PFNGLRASTERPOS3IVPROC glad_glRasterPos3iv; +#define glRasterPos3iv glad_glRasterPos3iv +typedef void (APIENTRYP PFNGLRASTERPOS3SPROC)(GLshort x, GLshort y, GLshort z); +GLAPI PFNGLRASTERPOS3SPROC glad_glRasterPos3s; +#define glRasterPos3s glad_glRasterPos3s +typedef void (APIENTRYP PFNGLRASTERPOS3SVPROC)(const GLshort *v); +GLAPI PFNGLRASTERPOS3SVPROC glad_glRasterPos3sv; +#define glRasterPos3sv glad_glRasterPos3sv +typedef void (APIENTRYP PFNGLRASTERPOS4DPROC)(GLdouble x, GLdouble y, GLdouble z, GLdouble w); +GLAPI PFNGLRASTERPOS4DPROC glad_glRasterPos4d; +#define glRasterPos4d glad_glRasterPos4d +typedef void (APIENTRYP PFNGLRASTERPOS4DVPROC)(const GLdouble *v); +GLAPI PFNGLRASTERPOS4DVPROC glad_glRasterPos4dv; +#define glRasterPos4dv glad_glRasterPos4dv +typedef void (APIENTRYP PFNGLRASTERPOS4FPROC)(GLfloat x, GLfloat y, GLfloat z, GLfloat w); +GLAPI PFNGLRASTERPOS4FPROC glad_glRasterPos4f; +#define glRasterPos4f glad_glRasterPos4f +typedef void (APIENTRYP PFNGLRASTERPOS4FVPROC)(const GLfloat *v); +GLAPI PFNGLRASTERPOS4FVPROC glad_glRasterPos4fv; +#define glRasterPos4fv glad_glRasterPos4fv +typedef void (APIENTRYP PFNGLRASTERPOS4IPROC)(GLint x, GLint y, GLint z, GLint w); +GLAPI PFNGLRASTERPOS4IPROC glad_glRasterPos4i; +#define glRasterPos4i glad_glRasterPos4i +typedef void (APIENTRYP PFNGLRASTERPOS4IVPROC)(const GLint *v); +GLAPI PFNGLRASTERPOS4IVPROC glad_glRasterPos4iv; +#define glRasterPos4iv glad_glRasterPos4iv +typedef void (APIENTRYP PFNGLRASTERPOS4SPROC)(GLshort x, GLshort y, GLshort z, GLshort w); +GLAPI PFNGLRASTERPOS4SPROC glad_glRasterPos4s; +#define glRasterPos4s glad_glRasterPos4s +typedef void (APIENTRYP PFNGLRASTERPOS4SVPROC)(const GLshort *v); +GLAPI PFNGLRASTERPOS4SVPROC glad_glRasterPos4sv; +#define glRasterPos4sv glad_glRasterPos4sv +typedef void (APIENTRYP PFNGLRECTDPROC)(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2); +GLAPI PFNGLRECTDPROC glad_glRectd; +#define glRectd glad_glRectd +typedef void (APIENTRYP PFNGLRECTDVPROC)(const GLdouble *v1, const GLdouble *v2); +GLAPI PFNGLRECTDVPROC glad_glRectdv; +#define glRectdv glad_glRectdv +typedef void (APIENTRYP PFNGLRECTFPROC)(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2); +GLAPI PFNGLRECTFPROC glad_glRectf; +#define glRectf glad_glRectf +typedef void (APIENTRYP PFNGLRECTFVPROC)(const GLfloat *v1, const GLfloat *v2); +GLAPI PFNGLRECTFVPROC glad_glRectfv; +#define glRectfv glad_glRectfv +typedef void (APIENTRYP PFNGLRECTIPROC)(GLint x1, GLint y1, GLint x2, GLint y2); +GLAPI PFNGLRECTIPROC glad_glRecti; +#define glRecti glad_glRecti +typedef void (APIENTRYP PFNGLRECTIVPROC)(const GLint *v1, const GLint *v2); +GLAPI PFNGLRECTIVPROC glad_glRectiv; +#define glRectiv glad_glRectiv +typedef void (APIENTRYP PFNGLRECTSPROC)(GLshort x1, GLshort y1, GLshort x2, GLshort y2); +GLAPI PFNGLRECTSPROC glad_glRects; +#define glRects glad_glRects +typedef void (APIENTRYP PFNGLRECTSVPROC)(const GLshort *v1, const GLshort *v2); +GLAPI PFNGLRECTSVPROC glad_glRectsv; +#define glRectsv glad_glRectsv +typedef void (APIENTRYP PFNGLTEXCOORD1DPROC)(GLdouble s); +GLAPI PFNGLTEXCOORD1DPROC glad_glTexCoord1d; +#define glTexCoord1d glad_glTexCoord1d +typedef void (APIENTRYP PFNGLTEXCOORD1DVPROC)(const GLdouble *v); +GLAPI PFNGLTEXCOORD1DVPROC glad_glTexCoord1dv; +#define glTexCoord1dv glad_glTexCoord1dv +typedef void (APIENTRYP PFNGLTEXCOORD1FPROC)(GLfloat s); +GLAPI PFNGLTEXCOORD1FPROC glad_glTexCoord1f; +#define glTexCoord1f glad_glTexCoord1f +typedef void (APIENTRYP PFNGLTEXCOORD1FVPROC)(const GLfloat *v); +GLAPI PFNGLTEXCOORD1FVPROC glad_glTexCoord1fv; +#define glTexCoord1fv glad_glTexCoord1fv +typedef void (APIENTRYP PFNGLTEXCOORD1IPROC)(GLint s); +GLAPI PFNGLTEXCOORD1IPROC glad_glTexCoord1i; +#define glTexCoord1i glad_glTexCoord1i +typedef void (APIENTRYP PFNGLTEXCOORD1IVPROC)(const GLint *v); +GLAPI PFNGLTEXCOORD1IVPROC glad_glTexCoord1iv; +#define glTexCoord1iv glad_glTexCoord1iv +typedef void (APIENTRYP PFNGLTEXCOORD1SPROC)(GLshort s); +GLAPI PFNGLTEXCOORD1SPROC glad_glTexCoord1s; +#define glTexCoord1s glad_glTexCoord1s +typedef void (APIENTRYP PFNGLTEXCOORD1SVPROC)(const GLshort *v); +GLAPI PFNGLTEXCOORD1SVPROC glad_glTexCoord1sv; +#define glTexCoord1sv glad_glTexCoord1sv +typedef void (APIENTRYP PFNGLTEXCOORD2DPROC)(GLdouble s, GLdouble t); +GLAPI PFNGLTEXCOORD2DPROC glad_glTexCoord2d; +#define glTexCoord2d glad_glTexCoord2d +typedef void (APIENTRYP PFNGLTEXCOORD2DVPROC)(const GLdouble *v); +GLAPI PFNGLTEXCOORD2DVPROC glad_glTexCoord2dv; +#define glTexCoord2dv glad_glTexCoord2dv +typedef void (APIENTRYP PFNGLTEXCOORD2FPROC)(GLfloat s, GLfloat t); +GLAPI PFNGLTEXCOORD2FPROC glad_glTexCoord2f; +#define glTexCoord2f glad_glTexCoord2f +typedef void (APIENTRYP PFNGLTEXCOORD2FVPROC)(const GLfloat *v); +GLAPI PFNGLTEXCOORD2FVPROC glad_glTexCoord2fv; +#define glTexCoord2fv glad_glTexCoord2fv +typedef void (APIENTRYP PFNGLTEXCOORD2IPROC)(GLint s, GLint t); +GLAPI PFNGLTEXCOORD2IPROC glad_glTexCoord2i; +#define glTexCoord2i glad_glTexCoord2i +typedef void (APIENTRYP PFNGLTEXCOORD2IVPROC)(const GLint *v); +GLAPI PFNGLTEXCOORD2IVPROC glad_glTexCoord2iv; +#define glTexCoord2iv glad_glTexCoord2iv +typedef void (APIENTRYP PFNGLTEXCOORD2SPROC)(GLshort s, GLshort t); +GLAPI PFNGLTEXCOORD2SPROC glad_glTexCoord2s; +#define glTexCoord2s glad_glTexCoord2s +typedef void (APIENTRYP PFNGLTEXCOORD2SVPROC)(const GLshort *v); +GLAPI PFNGLTEXCOORD2SVPROC glad_glTexCoord2sv; +#define glTexCoord2sv glad_glTexCoord2sv +typedef void (APIENTRYP PFNGLTEXCOORD3DPROC)(GLdouble s, GLdouble t, GLdouble r); +GLAPI PFNGLTEXCOORD3DPROC glad_glTexCoord3d; +#define glTexCoord3d glad_glTexCoord3d +typedef void (APIENTRYP PFNGLTEXCOORD3DVPROC)(const GLdouble *v); +GLAPI PFNGLTEXCOORD3DVPROC glad_glTexCoord3dv; +#define glTexCoord3dv glad_glTexCoord3dv +typedef void (APIENTRYP PFNGLTEXCOORD3FPROC)(GLfloat s, GLfloat t, GLfloat r); +GLAPI PFNGLTEXCOORD3FPROC glad_glTexCoord3f; +#define glTexCoord3f glad_glTexCoord3f +typedef void (APIENTRYP PFNGLTEXCOORD3FVPROC)(const GLfloat *v); +GLAPI PFNGLTEXCOORD3FVPROC glad_glTexCoord3fv; +#define glTexCoord3fv glad_glTexCoord3fv +typedef void (APIENTRYP PFNGLTEXCOORD3IPROC)(GLint s, GLint t, GLint r); +GLAPI PFNGLTEXCOORD3IPROC glad_glTexCoord3i; +#define glTexCoord3i glad_glTexCoord3i +typedef void (APIENTRYP PFNGLTEXCOORD3IVPROC)(const GLint *v); +GLAPI PFNGLTEXCOORD3IVPROC glad_glTexCoord3iv; +#define glTexCoord3iv glad_glTexCoord3iv +typedef void (APIENTRYP PFNGLTEXCOORD3SPROC)(GLshort s, GLshort t, GLshort r); +GLAPI PFNGLTEXCOORD3SPROC glad_glTexCoord3s; +#define glTexCoord3s glad_glTexCoord3s +typedef void (APIENTRYP PFNGLTEXCOORD3SVPROC)(const GLshort *v); +GLAPI PFNGLTEXCOORD3SVPROC glad_glTexCoord3sv; +#define glTexCoord3sv glad_glTexCoord3sv +typedef void (APIENTRYP PFNGLTEXCOORD4DPROC)(GLdouble s, GLdouble t, GLdouble r, GLdouble q); +GLAPI PFNGLTEXCOORD4DPROC glad_glTexCoord4d; +#define glTexCoord4d glad_glTexCoord4d +typedef void (APIENTRYP PFNGLTEXCOORD4DVPROC)(const GLdouble *v); +GLAPI PFNGLTEXCOORD4DVPROC glad_glTexCoord4dv; +#define glTexCoord4dv glad_glTexCoord4dv +typedef void (APIENTRYP PFNGLTEXCOORD4FPROC)(GLfloat s, GLfloat t, GLfloat r, GLfloat q); +GLAPI PFNGLTEXCOORD4FPROC glad_glTexCoord4f; +#define glTexCoord4f glad_glTexCoord4f +typedef void (APIENTRYP PFNGLTEXCOORD4FVPROC)(const GLfloat *v); +GLAPI PFNGLTEXCOORD4FVPROC glad_glTexCoord4fv; +#define glTexCoord4fv glad_glTexCoord4fv +typedef void (APIENTRYP PFNGLTEXCOORD4IPROC)(GLint s, GLint t, GLint r, GLint q); +GLAPI PFNGLTEXCOORD4IPROC glad_glTexCoord4i; +#define glTexCoord4i glad_glTexCoord4i +typedef void (APIENTRYP PFNGLTEXCOORD4IVPROC)(const GLint *v); +GLAPI PFNGLTEXCOORD4IVPROC glad_glTexCoord4iv; +#define glTexCoord4iv glad_glTexCoord4iv +typedef void (APIENTRYP PFNGLTEXCOORD4SPROC)(GLshort s, GLshort t, GLshort r, GLshort q); +GLAPI PFNGLTEXCOORD4SPROC glad_glTexCoord4s; +#define glTexCoord4s glad_glTexCoord4s +typedef void (APIENTRYP PFNGLTEXCOORD4SVPROC)(const GLshort *v); +GLAPI PFNGLTEXCOORD4SVPROC glad_glTexCoord4sv; +#define glTexCoord4sv glad_glTexCoord4sv +typedef void (APIENTRYP PFNGLVERTEX2DPROC)(GLdouble x, GLdouble y); +GLAPI PFNGLVERTEX2DPROC glad_glVertex2d; +#define glVertex2d glad_glVertex2d +typedef void (APIENTRYP PFNGLVERTEX2DVPROC)(const GLdouble *v); +GLAPI PFNGLVERTEX2DVPROC glad_glVertex2dv; +#define glVertex2dv glad_glVertex2dv +typedef void (APIENTRYP PFNGLVERTEX2FPROC)(GLfloat x, GLfloat y); +GLAPI PFNGLVERTEX2FPROC glad_glVertex2f; +#define glVertex2f glad_glVertex2f +typedef void (APIENTRYP PFNGLVERTEX2FVPROC)(const GLfloat *v); +GLAPI PFNGLVERTEX2FVPROC glad_glVertex2fv; +#define glVertex2fv glad_glVertex2fv +typedef void (APIENTRYP PFNGLVERTEX2IPROC)(GLint x, GLint y); +GLAPI PFNGLVERTEX2IPROC glad_glVertex2i; +#define glVertex2i glad_glVertex2i +typedef void (APIENTRYP PFNGLVERTEX2IVPROC)(const GLint *v); +GLAPI PFNGLVERTEX2IVPROC glad_glVertex2iv; +#define glVertex2iv glad_glVertex2iv +typedef void (APIENTRYP PFNGLVERTEX2SPROC)(GLshort x, GLshort y); +GLAPI PFNGLVERTEX2SPROC glad_glVertex2s; +#define glVertex2s glad_glVertex2s +typedef void (APIENTRYP PFNGLVERTEX2SVPROC)(const GLshort *v); +GLAPI PFNGLVERTEX2SVPROC glad_glVertex2sv; +#define glVertex2sv glad_glVertex2sv +typedef void (APIENTRYP PFNGLVERTEX3DPROC)(GLdouble x, GLdouble y, GLdouble z); +GLAPI PFNGLVERTEX3DPROC glad_glVertex3d; +#define glVertex3d glad_glVertex3d +typedef void (APIENTRYP PFNGLVERTEX3DVPROC)(const GLdouble *v); +GLAPI PFNGLVERTEX3DVPROC glad_glVertex3dv; +#define glVertex3dv glad_glVertex3dv +typedef void (APIENTRYP PFNGLVERTEX3FPROC)(GLfloat x, GLfloat y, GLfloat z); +GLAPI PFNGLVERTEX3FPROC glad_glVertex3f; +#define glVertex3f glad_glVertex3f +typedef void (APIENTRYP PFNGLVERTEX3FVPROC)(const GLfloat *v); +GLAPI PFNGLVERTEX3FVPROC glad_glVertex3fv; +#define glVertex3fv glad_glVertex3fv +typedef void (APIENTRYP PFNGLVERTEX3IPROC)(GLint x, GLint y, GLint z); +GLAPI PFNGLVERTEX3IPROC glad_glVertex3i; +#define glVertex3i glad_glVertex3i +typedef void (APIENTRYP PFNGLVERTEX3IVPROC)(const GLint *v); +GLAPI PFNGLVERTEX3IVPROC glad_glVertex3iv; +#define glVertex3iv glad_glVertex3iv +typedef void (APIENTRYP PFNGLVERTEX3SPROC)(GLshort x, GLshort y, GLshort z); +GLAPI PFNGLVERTEX3SPROC glad_glVertex3s; +#define glVertex3s glad_glVertex3s +typedef void (APIENTRYP PFNGLVERTEX3SVPROC)(const GLshort *v); +GLAPI PFNGLVERTEX3SVPROC glad_glVertex3sv; +#define glVertex3sv glad_glVertex3sv +typedef void (APIENTRYP PFNGLVERTEX4DPROC)(GLdouble x, GLdouble y, GLdouble z, GLdouble w); +GLAPI PFNGLVERTEX4DPROC glad_glVertex4d; +#define glVertex4d glad_glVertex4d +typedef void (APIENTRYP PFNGLVERTEX4DVPROC)(const GLdouble *v); +GLAPI PFNGLVERTEX4DVPROC glad_glVertex4dv; +#define glVertex4dv glad_glVertex4dv +typedef void (APIENTRYP PFNGLVERTEX4FPROC)(GLfloat x, GLfloat y, GLfloat z, GLfloat w); +GLAPI PFNGLVERTEX4FPROC glad_glVertex4f; +#define glVertex4f glad_glVertex4f +typedef void (APIENTRYP PFNGLVERTEX4FVPROC)(const GLfloat *v); +GLAPI PFNGLVERTEX4FVPROC glad_glVertex4fv; +#define glVertex4fv glad_glVertex4fv +typedef void (APIENTRYP PFNGLVERTEX4IPROC)(GLint x, GLint y, GLint z, GLint w); +GLAPI PFNGLVERTEX4IPROC glad_glVertex4i; +#define glVertex4i glad_glVertex4i +typedef void (APIENTRYP PFNGLVERTEX4IVPROC)(const GLint *v); +GLAPI PFNGLVERTEX4IVPROC glad_glVertex4iv; +#define glVertex4iv glad_glVertex4iv +typedef void (APIENTRYP PFNGLVERTEX4SPROC)(GLshort x, GLshort y, GLshort z, GLshort w); +GLAPI PFNGLVERTEX4SPROC glad_glVertex4s; +#define glVertex4s glad_glVertex4s +typedef void (APIENTRYP PFNGLVERTEX4SVPROC)(const GLshort *v); +GLAPI PFNGLVERTEX4SVPROC glad_glVertex4sv; +#define glVertex4sv glad_glVertex4sv +typedef void (APIENTRYP PFNGLCLIPPLANEPROC)(GLenum plane, const GLdouble *equation); +GLAPI PFNGLCLIPPLANEPROC glad_glClipPlane; +#define glClipPlane glad_glClipPlane +typedef void (APIENTRYP PFNGLCOLORMATERIALPROC)(GLenum face, GLenum mode); +GLAPI PFNGLCOLORMATERIALPROC glad_glColorMaterial; +#define glColorMaterial glad_glColorMaterial +typedef void (APIENTRYP PFNGLFOGFPROC)(GLenum pname, GLfloat param); +GLAPI PFNGLFOGFPROC glad_glFogf; +#define glFogf glad_glFogf +typedef void (APIENTRYP PFNGLFOGFVPROC)(GLenum pname, const GLfloat *params); +GLAPI PFNGLFOGFVPROC glad_glFogfv; +#define glFogfv glad_glFogfv +typedef void (APIENTRYP PFNGLFOGIPROC)(GLenum pname, GLint param); +GLAPI PFNGLFOGIPROC glad_glFogi; +#define glFogi glad_glFogi +typedef void (APIENTRYP PFNGLFOGIVPROC)(GLenum pname, const GLint *params); +GLAPI PFNGLFOGIVPROC glad_glFogiv; +#define glFogiv glad_glFogiv +typedef void (APIENTRYP PFNGLLIGHTFPROC)(GLenum light, GLenum pname, GLfloat param); +GLAPI PFNGLLIGHTFPROC glad_glLightf; +#define glLightf glad_glLightf +typedef void (APIENTRYP PFNGLLIGHTFVPROC)(GLenum light, GLenum pname, const GLfloat *params); +GLAPI PFNGLLIGHTFVPROC glad_glLightfv; +#define glLightfv glad_glLightfv +typedef void (APIENTRYP PFNGLLIGHTIPROC)(GLenum light, GLenum pname, GLint param); +GLAPI PFNGLLIGHTIPROC glad_glLighti; +#define glLighti glad_glLighti +typedef void (APIENTRYP PFNGLLIGHTIVPROC)(GLenum light, GLenum pname, const GLint *params); +GLAPI PFNGLLIGHTIVPROC glad_glLightiv; +#define glLightiv glad_glLightiv +typedef void (APIENTRYP PFNGLLIGHTMODELFPROC)(GLenum pname, GLfloat param); +GLAPI PFNGLLIGHTMODELFPROC glad_glLightModelf; +#define glLightModelf glad_glLightModelf +typedef void (APIENTRYP PFNGLLIGHTMODELFVPROC)(GLenum pname, const GLfloat *params); +GLAPI PFNGLLIGHTMODELFVPROC glad_glLightModelfv; +#define glLightModelfv glad_glLightModelfv +typedef void (APIENTRYP PFNGLLIGHTMODELIPROC)(GLenum pname, GLint param); +GLAPI PFNGLLIGHTMODELIPROC glad_glLightModeli; +#define glLightModeli glad_glLightModeli +typedef void (APIENTRYP PFNGLLIGHTMODELIVPROC)(GLenum pname, const GLint *params); +GLAPI PFNGLLIGHTMODELIVPROC glad_glLightModeliv; +#define glLightModeliv glad_glLightModeliv +typedef void (APIENTRYP PFNGLLINESTIPPLEPROC)(GLint factor, GLushort pattern); +GLAPI PFNGLLINESTIPPLEPROC glad_glLineStipple; +#define glLineStipple glad_glLineStipple +typedef void (APIENTRYP PFNGLMATERIALFPROC)(GLenum face, GLenum pname, GLfloat param); +GLAPI PFNGLMATERIALFPROC glad_glMaterialf; +#define glMaterialf glad_glMaterialf +typedef void (APIENTRYP PFNGLMATERIALFVPROC)(GLenum face, GLenum pname, const GLfloat *params); +GLAPI PFNGLMATERIALFVPROC glad_glMaterialfv; +#define glMaterialfv glad_glMaterialfv +typedef void (APIENTRYP PFNGLMATERIALIPROC)(GLenum face, GLenum pname, GLint param); +GLAPI PFNGLMATERIALIPROC glad_glMateriali; +#define glMateriali glad_glMateriali +typedef void (APIENTRYP PFNGLMATERIALIVPROC)(GLenum face, GLenum pname, const GLint *params); +GLAPI PFNGLMATERIALIVPROC glad_glMaterialiv; +#define glMaterialiv glad_glMaterialiv +typedef void (APIENTRYP PFNGLPOLYGONSTIPPLEPROC)(const GLubyte *mask); +GLAPI PFNGLPOLYGONSTIPPLEPROC glad_glPolygonStipple; +#define glPolygonStipple glad_glPolygonStipple +typedef void (APIENTRYP PFNGLSHADEMODELPROC)(GLenum mode); +GLAPI PFNGLSHADEMODELPROC glad_glShadeModel; +#define glShadeModel glad_glShadeModel +typedef void (APIENTRYP PFNGLTEXENVFPROC)(GLenum target, GLenum pname, GLfloat param); +GLAPI PFNGLTEXENVFPROC glad_glTexEnvf; +#define glTexEnvf glad_glTexEnvf +typedef void (APIENTRYP PFNGLTEXENVFVPROC)(GLenum target, GLenum pname, const GLfloat *params); +GLAPI PFNGLTEXENVFVPROC glad_glTexEnvfv; +#define glTexEnvfv glad_glTexEnvfv +typedef void (APIENTRYP PFNGLTEXENVIPROC)(GLenum target, GLenum pname, GLint param); +GLAPI PFNGLTEXENVIPROC glad_glTexEnvi; +#define glTexEnvi glad_glTexEnvi +typedef void (APIENTRYP PFNGLTEXENVIVPROC)(GLenum target, GLenum pname, const GLint *params); +GLAPI PFNGLTEXENVIVPROC glad_glTexEnviv; +#define glTexEnviv glad_glTexEnviv +typedef void (APIENTRYP PFNGLTEXGENDPROC)(GLenum coord, GLenum pname, GLdouble param); +GLAPI PFNGLTEXGENDPROC glad_glTexGend; +#define glTexGend glad_glTexGend +typedef void (APIENTRYP PFNGLTEXGENDVPROC)(GLenum coord, GLenum pname, const GLdouble *params); +GLAPI PFNGLTEXGENDVPROC glad_glTexGendv; +#define glTexGendv glad_glTexGendv +typedef void (APIENTRYP PFNGLTEXGENFPROC)(GLenum coord, GLenum pname, GLfloat param); +GLAPI PFNGLTEXGENFPROC glad_glTexGenf; +#define glTexGenf glad_glTexGenf +typedef void (APIENTRYP PFNGLTEXGENFVPROC)(GLenum coord, GLenum pname, const GLfloat *params); +GLAPI PFNGLTEXGENFVPROC glad_glTexGenfv; +#define glTexGenfv glad_glTexGenfv +typedef void (APIENTRYP PFNGLTEXGENIPROC)(GLenum coord, GLenum pname, GLint param); +GLAPI PFNGLTEXGENIPROC glad_glTexGeni; +#define glTexGeni glad_glTexGeni +typedef void (APIENTRYP PFNGLTEXGENIVPROC)(GLenum coord, GLenum pname, const GLint *params); +GLAPI PFNGLTEXGENIVPROC glad_glTexGeniv; +#define glTexGeniv glad_glTexGeniv +typedef void (APIENTRYP PFNGLFEEDBACKBUFFERPROC)(GLsizei size, GLenum type, GLfloat *buffer); +GLAPI PFNGLFEEDBACKBUFFERPROC glad_glFeedbackBuffer; +#define glFeedbackBuffer glad_glFeedbackBuffer +typedef void (APIENTRYP PFNGLSELECTBUFFERPROC)(GLsizei size, GLuint *buffer); +GLAPI PFNGLSELECTBUFFERPROC glad_glSelectBuffer; +#define glSelectBuffer glad_glSelectBuffer +typedef GLint (APIENTRYP PFNGLRENDERMODEPROC)(GLenum mode); +GLAPI PFNGLRENDERMODEPROC glad_glRenderMode; +#define glRenderMode glad_glRenderMode +typedef void (APIENTRYP PFNGLINITNAMESPROC)(void); +GLAPI PFNGLINITNAMESPROC glad_glInitNames; +#define glInitNames glad_glInitNames +typedef void (APIENTRYP PFNGLLOADNAMEPROC)(GLuint name); +GLAPI PFNGLLOADNAMEPROC glad_glLoadName; +#define glLoadName glad_glLoadName +typedef void (APIENTRYP PFNGLPASSTHROUGHPROC)(GLfloat token); +GLAPI PFNGLPASSTHROUGHPROC glad_glPassThrough; +#define glPassThrough glad_glPassThrough +typedef void (APIENTRYP PFNGLPOPNAMEPROC)(void); +GLAPI PFNGLPOPNAMEPROC glad_glPopName; +#define glPopName glad_glPopName +typedef void (APIENTRYP PFNGLPUSHNAMEPROC)(GLuint name); +GLAPI PFNGLPUSHNAMEPROC glad_glPushName; +#define glPushName glad_glPushName +typedef void (APIENTRYP PFNGLCLEARACCUMPROC)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +GLAPI PFNGLCLEARACCUMPROC glad_glClearAccum; +#define glClearAccum glad_glClearAccum +typedef void (APIENTRYP PFNGLCLEARINDEXPROC)(GLfloat c); +GLAPI PFNGLCLEARINDEXPROC glad_glClearIndex; +#define glClearIndex glad_glClearIndex +typedef void (APIENTRYP PFNGLINDEXMASKPROC)(GLuint mask); +GLAPI PFNGLINDEXMASKPROC glad_glIndexMask; +#define glIndexMask glad_glIndexMask +typedef void (APIENTRYP PFNGLACCUMPROC)(GLenum op, GLfloat value); +GLAPI PFNGLACCUMPROC glad_glAccum; +#define glAccum glad_glAccum +typedef void (APIENTRYP PFNGLPOPATTRIBPROC)(void); +GLAPI PFNGLPOPATTRIBPROC glad_glPopAttrib; +#define glPopAttrib glad_glPopAttrib +typedef void (APIENTRYP PFNGLPUSHATTRIBPROC)(GLbitfield mask); +GLAPI PFNGLPUSHATTRIBPROC glad_glPushAttrib; +#define glPushAttrib glad_glPushAttrib +typedef void (APIENTRYP PFNGLMAP1DPROC)(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points); +GLAPI PFNGLMAP1DPROC glad_glMap1d; +#define glMap1d glad_glMap1d +typedef void (APIENTRYP PFNGLMAP1FPROC)(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points); +GLAPI PFNGLMAP1FPROC glad_glMap1f; +#define glMap1f glad_glMap1f +typedef void (APIENTRYP PFNGLMAP2DPROC)(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points); +GLAPI PFNGLMAP2DPROC glad_glMap2d; +#define glMap2d glad_glMap2d +typedef void (APIENTRYP PFNGLMAP2FPROC)(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points); +GLAPI PFNGLMAP2FPROC glad_glMap2f; +#define glMap2f glad_glMap2f +typedef void (APIENTRYP PFNGLMAPGRID1DPROC)(GLint un, GLdouble u1, GLdouble u2); +GLAPI PFNGLMAPGRID1DPROC glad_glMapGrid1d; +#define glMapGrid1d glad_glMapGrid1d +typedef void (APIENTRYP PFNGLMAPGRID1FPROC)(GLint un, GLfloat u1, GLfloat u2); +GLAPI PFNGLMAPGRID1FPROC glad_glMapGrid1f; +#define glMapGrid1f glad_glMapGrid1f +typedef void (APIENTRYP PFNGLMAPGRID2DPROC)(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2); +GLAPI PFNGLMAPGRID2DPROC glad_glMapGrid2d; +#define glMapGrid2d glad_glMapGrid2d +typedef void (APIENTRYP PFNGLMAPGRID2FPROC)(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2); +GLAPI PFNGLMAPGRID2FPROC glad_glMapGrid2f; +#define glMapGrid2f glad_glMapGrid2f +typedef void (APIENTRYP PFNGLEVALCOORD1DPROC)(GLdouble u); +GLAPI PFNGLEVALCOORD1DPROC glad_glEvalCoord1d; +#define glEvalCoord1d glad_glEvalCoord1d +typedef void (APIENTRYP PFNGLEVALCOORD1DVPROC)(const GLdouble *u); +GLAPI PFNGLEVALCOORD1DVPROC glad_glEvalCoord1dv; +#define glEvalCoord1dv glad_glEvalCoord1dv +typedef void (APIENTRYP PFNGLEVALCOORD1FPROC)(GLfloat u); +GLAPI PFNGLEVALCOORD1FPROC glad_glEvalCoord1f; +#define glEvalCoord1f glad_glEvalCoord1f +typedef void (APIENTRYP PFNGLEVALCOORD1FVPROC)(const GLfloat *u); +GLAPI PFNGLEVALCOORD1FVPROC glad_glEvalCoord1fv; +#define glEvalCoord1fv glad_glEvalCoord1fv +typedef void (APIENTRYP PFNGLEVALCOORD2DPROC)(GLdouble u, GLdouble v); +GLAPI PFNGLEVALCOORD2DPROC glad_glEvalCoord2d; +#define glEvalCoord2d glad_glEvalCoord2d +typedef void (APIENTRYP PFNGLEVALCOORD2DVPROC)(const GLdouble *u); +GLAPI PFNGLEVALCOORD2DVPROC glad_glEvalCoord2dv; +#define glEvalCoord2dv glad_glEvalCoord2dv +typedef void (APIENTRYP PFNGLEVALCOORD2FPROC)(GLfloat u, GLfloat v); +GLAPI PFNGLEVALCOORD2FPROC glad_glEvalCoord2f; +#define glEvalCoord2f glad_glEvalCoord2f +typedef void (APIENTRYP PFNGLEVALCOORD2FVPROC)(const GLfloat *u); +GLAPI PFNGLEVALCOORD2FVPROC glad_glEvalCoord2fv; +#define glEvalCoord2fv glad_glEvalCoord2fv +typedef void (APIENTRYP PFNGLEVALMESH1PROC)(GLenum mode, GLint i1, GLint i2); +GLAPI PFNGLEVALMESH1PROC glad_glEvalMesh1; +#define glEvalMesh1 glad_glEvalMesh1 +typedef void (APIENTRYP PFNGLEVALPOINT1PROC)(GLint i); +GLAPI PFNGLEVALPOINT1PROC glad_glEvalPoint1; +#define glEvalPoint1 glad_glEvalPoint1 +typedef void (APIENTRYP PFNGLEVALMESH2PROC)(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2); +GLAPI PFNGLEVALMESH2PROC glad_glEvalMesh2; +#define glEvalMesh2 glad_glEvalMesh2 +typedef void (APIENTRYP PFNGLEVALPOINT2PROC)(GLint i, GLint j); +GLAPI PFNGLEVALPOINT2PROC glad_glEvalPoint2; +#define glEvalPoint2 glad_glEvalPoint2 +typedef void (APIENTRYP PFNGLALPHAFUNCPROC)(GLenum func, GLfloat ref); +GLAPI PFNGLALPHAFUNCPROC glad_glAlphaFunc; +#define glAlphaFunc glad_glAlphaFunc +typedef void (APIENTRYP PFNGLPIXELZOOMPROC)(GLfloat xfactor, GLfloat yfactor); +GLAPI PFNGLPIXELZOOMPROC glad_glPixelZoom; +#define glPixelZoom glad_glPixelZoom +typedef void (APIENTRYP PFNGLPIXELTRANSFERFPROC)(GLenum pname, GLfloat param); +GLAPI PFNGLPIXELTRANSFERFPROC glad_glPixelTransferf; +#define glPixelTransferf glad_glPixelTransferf +typedef void (APIENTRYP PFNGLPIXELTRANSFERIPROC)(GLenum pname, GLint param); +GLAPI PFNGLPIXELTRANSFERIPROC glad_glPixelTransferi; +#define glPixelTransferi glad_glPixelTransferi +typedef void (APIENTRYP PFNGLPIXELMAPFVPROC)(GLenum map, GLsizei mapsize, const GLfloat *values); +GLAPI PFNGLPIXELMAPFVPROC glad_glPixelMapfv; +#define glPixelMapfv glad_glPixelMapfv +typedef void (APIENTRYP PFNGLPIXELMAPUIVPROC)(GLenum map, GLsizei mapsize, const GLuint *values); +GLAPI PFNGLPIXELMAPUIVPROC glad_glPixelMapuiv; +#define glPixelMapuiv glad_glPixelMapuiv +typedef void (APIENTRYP PFNGLPIXELMAPUSVPROC)(GLenum map, GLsizei mapsize, const GLushort *values); +GLAPI PFNGLPIXELMAPUSVPROC glad_glPixelMapusv; +#define glPixelMapusv glad_glPixelMapusv +typedef void (APIENTRYP PFNGLCOPYPIXELSPROC)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type); +GLAPI PFNGLCOPYPIXELSPROC glad_glCopyPixels; +#define glCopyPixels glad_glCopyPixels +typedef void (APIENTRYP PFNGLDRAWPIXELSPROC)(GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLDRAWPIXELSPROC glad_glDrawPixels; +#define glDrawPixels glad_glDrawPixels +typedef void (APIENTRYP PFNGLGETCLIPPLANEPROC)(GLenum plane, GLdouble *equation); +GLAPI PFNGLGETCLIPPLANEPROC glad_glGetClipPlane; +#define glGetClipPlane glad_glGetClipPlane +typedef void (APIENTRYP PFNGLGETLIGHTFVPROC)(GLenum light, GLenum pname, GLfloat *params); +GLAPI PFNGLGETLIGHTFVPROC glad_glGetLightfv; +#define glGetLightfv glad_glGetLightfv +typedef void (APIENTRYP PFNGLGETLIGHTIVPROC)(GLenum light, GLenum pname, GLint *params); +GLAPI PFNGLGETLIGHTIVPROC glad_glGetLightiv; +#define glGetLightiv glad_glGetLightiv +typedef void (APIENTRYP PFNGLGETMAPDVPROC)(GLenum target, GLenum query, GLdouble *v); +GLAPI PFNGLGETMAPDVPROC glad_glGetMapdv; +#define glGetMapdv glad_glGetMapdv +typedef void (APIENTRYP PFNGLGETMAPFVPROC)(GLenum target, GLenum query, GLfloat *v); +GLAPI PFNGLGETMAPFVPROC glad_glGetMapfv; +#define glGetMapfv glad_glGetMapfv +typedef void (APIENTRYP PFNGLGETMAPIVPROC)(GLenum target, GLenum query, GLint *v); +GLAPI PFNGLGETMAPIVPROC glad_glGetMapiv; +#define glGetMapiv glad_glGetMapiv +typedef void (APIENTRYP PFNGLGETMATERIALFVPROC)(GLenum face, GLenum pname, GLfloat *params); +GLAPI PFNGLGETMATERIALFVPROC glad_glGetMaterialfv; +#define glGetMaterialfv glad_glGetMaterialfv +typedef void (APIENTRYP PFNGLGETMATERIALIVPROC)(GLenum face, GLenum pname, GLint *params); +GLAPI PFNGLGETMATERIALIVPROC glad_glGetMaterialiv; +#define glGetMaterialiv glad_glGetMaterialiv +typedef void (APIENTRYP PFNGLGETPIXELMAPFVPROC)(GLenum map, GLfloat *values); +GLAPI PFNGLGETPIXELMAPFVPROC glad_glGetPixelMapfv; +#define glGetPixelMapfv glad_glGetPixelMapfv +typedef void (APIENTRYP PFNGLGETPIXELMAPUIVPROC)(GLenum map, GLuint *values); +GLAPI PFNGLGETPIXELMAPUIVPROC glad_glGetPixelMapuiv; +#define glGetPixelMapuiv glad_glGetPixelMapuiv +typedef void (APIENTRYP PFNGLGETPIXELMAPUSVPROC)(GLenum map, GLushort *values); +GLAPI PFNGLGETPIXELMAPUSVPROC glad_glGetPixelMapusv; +#define glGetPixelMapusv glad_glGetPixelMapusv +typedef void (APIENTRYP PFNGLGETPOLYGONSTIPPLEPROC)(GLubyte *mask); +GLAPI PFNGLGETPOLYGONSTIPPLEPROC glad_glGetPolygonStipple; +#define glGetPolygonStipple glad_glGetPolygonStipple +typedef void (APIENTRYP PFNGLGETTEXENVFVPROC)(GLenum target, GLenum pname, GLfloat *params); +GLAPI PFNGLGETTEXENVFVPROC glad_glGetTexEnvfv; +#define glGetTexEnvfv glad_glGetTexEnvfv +typedef void (APIENTRYP PFNGLGETTEXENVIVPROC)(GLenum target, GLenum pname, GLint *params); +GLAPI PFNGLGETTEXENVIVPROC glad_glGetTexEnviv; +#define glGetTexEnviv glad_glGetTexEnviv +typedef void (APIENTRYP PFNGLGETTEXGENDVPROC)(GLenum coord, GLenum pname, GLdouble *params); +GLAPI PFNGLGETTEXGENDVPROC glad_glGetTexGendv; +#define glGetTexGendv glad_glGetTexGendv +typedef void (APIENTRYP PFNGLGETTEXGENFVPROC)(GLenum coord, GLenum pname, GLfloat *params); +GLAPI PFNGLGETTEXGENFVPROC glad_glGetTexGenfv; +#define glGetTexGenfv glad_glGetTexGenfv +typedef void (APIENTRYP PFNGLGETTEXGENIVPROC)(GLenum coord, GLenum pname, GLint *params); +GLAPI PFNGLGETTEXGENIVPROC glad_glGetTexGeniv; +#define glGetTexGeniv glad_glGetTexGeniv +typedef GLboolean (APIENTRYP PFNGLISLISTPROC)(GLuint list); +GLAPI PFNGLISLISTPROC glad_glIsList; +#define glIsList glad_glIsList +typedef void (APIENTRYP PFNGLFRUSTUMPROC)(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); +GLAPI PFNGLFRUSTUMPROC glad_glFrustum; +#define glFrustum glad_glFrustum +typedef void (APIENTRYP PFNGLLOADIDENTITYPROC)(void); +GLAPI PFNGLLOADIDENTITYPROC glad_glLoadIdentity; +#define glLoadIdentity glad_glLoadIdentity +typedef void (APIENTRYP PFNGLLOADMATRIXFPROC)(const GLfloat *m); +GLAPI PFNGLLOADMATRIXFPROC glad_glLoadMatrixf; +#define glLoadMatrixf glad_glLoadMatrixf +typedef void (APIENTRYP PFNGLLOADMATRIXDPROC)(const GLdouble *m); +GLAPI PFNGLLOADMATRIXDPROC glad_glLoadMatrixd; +#define glLoadMatrixd glad_glLoadMatrixd +typedef void (APIENTRYP PFNGLMATRIXMODEPROC)(GLenum mode); +GLAPI PFNGLMATRIXMODEPROC glad_glMatrixMode; +#define glMatrixMode glad_glMatrixMode +typedef void (APIENTRYP PFNGLMULTMATRIXFPROC)(const GLfloat *m); +GLAPI PFNGLMULTMATRIXFPROC glad_glMultMatrixf; +#define glMultMatrixf glad_glMultMatrixf +typedef void (APIENTRYP PFNGLMULTMATRIXDPROC)(const GLdouble *m); +GLAPI PFNGLMULTMATRIXDPROC glad_glMultMatrixd; +#define glMultMatrixd glad_glMultMatrixd +typedef void (APIENTRYP PFNGLORTHOPROC)(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); +GLAPI PFNGLORTHOPROC glad_glOrtho; +#define glOrtho glad_glOrtho +typedef void (APIENTRYP PFNGLPOPMATRIXPROC)(void); +GLAPI PFNGLPOPMATRIXPROC glad_glPopMatrix; +#define glPopMatrix glad_glPopMatrix +typedef void (APIENTRYP PFNGLPUSHMATRIXPROC)(void); +GLAPI PFNGLPUSHMATRIXPROC glad_glPushMatrix; +#define glPushMatrix glad_glPushMatrix +typedef void (APIENTRYP PFNGLROTATEDPROC)(GLdouble angle, GLdouble x, GLdouble y, GLdouble z); +GLAPI PFNGLROTATEDPROC glad_glRotated; +#define glRotated glad_glRotated +typedef void (APIENTRYP PFNGLROTATEFPROC)(GLfloat angle, GLfloat x, GLfloat y, GLfloat z); +GLAPI PFNGLROTATEFPROC glad_glRotatef; +#define glRotatef glad_glRotatef +typedef void (APIENTRYP PFNGLSCALEDPROC)(GLdouble x, GLdouble y, GLdouble z); +GLAPI PFNGLSCALEDPROC glad_glScaled; +#define glScaled glad_glScaled +typedef void (APIENTRYP PFNGLSCALEFPROC)(GLfloat x, GLfloat y, GLfloat z); +GLAPI PFNGLSCALEFPROC glad_glScalef; +#define glScalef glad_glScalef +typedef void (APIENTRYP PFNGLTRANSLATEDPROC)(GLdouble x, GLdouble y, GLdouble z); +GLAPI PFNGLTRANSLATEDPROC glad_glTranslated; +#define glTranslated glad_glTranslated +typedef void (APIENTRYP PFNGLTRANSLATEFPROC)(GLfloat x, GLfloat y, GLfloat z); +GLAPI PFNGLTRANSLATEFPROC glad_glTranslatef; +#define glTranslatef glad_glTranslatef +#endif +#ifndef GL_VERSION_1_1 +#define GL_VERSION_1_1 1 +GLAPI int GLAD_GL_VERSION_1_1; +typedef void (APIENTRYP PFNGLDRAWARRAYSPROC)(GLenum mode, GLint first, GLsizei count); +GLAPI PFNGLDRAWARRAYSPROC glad_glDrawArrays; +#define glDrawArrays glad_glDrawArrays +typedef void (APIENTRYP PFNGLDRAWELEMENTSPROC)(GLenum mode, GLsizei count, GLenum type, const void *indices); +GLAPI PFNGLDRAWELEMENTSPROC glad_glDrawElements; +#define glDrawElements glad_glDrawElements +typedef void (APIENTRYP PFNGLGETPOINTERVPROC)(GLenum pname, void **params); +GLAPI PFNGLGETPOINTERVPROC glad_glGetPointerv; +#define glGetPointerv glad_glGetPointerv +typedef void (APIENTRYP PFNGLPOLYGONOFFSETPROC)(GLfloat factor, GLfloat units); +GLAPI PFNGLPOLYGONOFFSETPROC glad_glPolygonOffset; +#define glPolygonOffset glad_glPolygonOffset +typedef void (APIENTRYP PFNGLCOPYTEXIMAGE1DPROC)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border); +GLAPI PFNGLCOPYTEXIMAGE1DPROC glad_glCopyTexImage1D; +#define glCopyTexImage1D glad_glCopyTexImage1D +typedef void (APIENTRYP PFNGLCOPYTEXIMAGE2DPROC)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); +GLAPI PFNGLCOPYTEXIMAGE2DPROC glad_glCopyTexImage2D; +#define glCopyTexImage2D glad_glCopyTexImage2D +typedef void (APIENTRYP PFNGLCOPYTEXSUBIMAGE1DPROC)(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width); +GLAPI PFNGLCOPYTEXSUBIMAGE1DPROC glad_glCopyTexSubImage1D; +#define glCopyTexSubImage1D glad_glCopyTexSubImage1D +typedef void (APIENTRYP PFNGLCOPYTEXSUBIMAGE2DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); +GLAPI PFNGLCOPYTEXSUBIMAGE2DPROC glad_glCopyTexSubImage2D; +#define glCopyTexSubImage2D glad_glCopyTexSubImage2D +typedef void (APIENTRYP PFNGLTEXSUBIMAGE1DPROC)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXSUBIMAGE1DPROC glad_glTexSubImage1D; +#define glTexSubImage1D glad_glTexSubImage1D +typedef void (APIENTRYP PFNGLTEXSUBIMAGE2DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXSUBIMAGE2DPROC glad_glTexSubImage2D; +#define glTexSubImage2D glad_glTexSubImage2D +typedef void (APIENTRYP PFNGLBINDTEXTUREPROC)(GLenum target, GLuint texture); +GLAPI PFNGLBINDTEXTUREPROC glad_glBindTexture; +#define glBindTexture glad_glBindTexture +typedef void (APIENTRYP PFNGLDELETETEXTURESPROC)(GLsizei n, const GLuint *textures); +GLAPI PFNGLDELETETEXTURESPROC glad_glDeleteTextures; +#define glDeleteTextures glad_glDeleteTextures +typedef void (APIENTRYP PFNGLGENTEXTURESPROC)(GLsizei n, GLuint *textures); +GLAPI PFNGLGENTEXTURESPROC glad_glGenTextures; +#define glGenTextures glad_glGenTextures +typedef GLboolean (APIENTRYP PFNGLISTEXTUREPROC)(GLuint texture); +GLAPI PFNGLISTEXTUREPROC glad_glIsTexture; +#define glIsTexture glad_glIsTexture +typedef void (APIENTRYP PFNGLARRAYELEMENTPROC)(GLint i); +GLAPI PFNGLARRAYELEMENTPROC glad_glArrayElement; +#define glArrayElement glad_glArrayElement +typedef void (APIENTRYP PFNGLCOLORPOINTERPROC)(GLint size, GLenum type, GLsizei stride, const void *pointer); +GLAPI PFNGLCOLORPOINTERPROC glad_glColorPointer; +#define glColorPointer glad_glColorPointer +typedef void (APIENTRYP PFNGLDISABLECLIENTSTATEPROC)(GLenum array); +GLAPI PFNGLDISABLECLIENTSTATEPROC glad_glDisableClientState; +#define glDisableClientState glad_glDisableClientState +typedef void (APIENTRYP PFNGLEDGEFLAGPOINTERPROC)(GLsizei stride, const void *pointer); +GLAPI PFNGLEDGEFLAGPOINTERPROC glad_glEdgeFlagPointer; +#define glEdgeFlagPointer glad_glEdgeFlagPointer +typedef void (APIENTRYP PFNGLENABLECLIENTSTATEPROC)(GLenum array); +GLAPI PFNGLENABLECLIENTSTATEPROC glad_glEnableClientState; +#define glEnableClientState glad_glEnableClientState +typedef void (APIENTRYP PFNGLINDEXPOINTERPROC)(GLenum type, GLsizei stride, const void *pointer); +GLAPI PFNGLINDEXPOINTERPROC glad_glIndexPointer; +#define glIndexPointer glad_glIndexPointer +typedef void (APIENTRYP PFNGLINTERLEAVEDARRAYSPROC)(GLenum format, GLsizei stride, const void *pointer); +GLAPI PFNGLINTERLEAVEDARRAYSPROC glad_glInterleavedArrays; +#define glInterleavedArrays glad_glInterleavedArrays +typedef void (APIENTRYP PFNGLNORMALPOINTERPROC)(GLenum type, GLsizei stride, const void *pointer); +GLAPI PFNGLNORMALPOINTERPROC glad_glNormalPointer; +#define glNormalPointer glad_glNormalPointer +typedef void (APIENTRYP PFNGLTEXCOORDPOINTERPROC)(GLint size, GLenum type, GLsizei stride, const void *pointer); +GLAPI PFNGLTEXCOORDPOINTERPROC glad_glTexCoordPointer; +#define glTexCoordPointer glad_glTexCoordPointer +typedef void (APIENTRYP PFNGLVERTEXPOINTERPROC)(GLint size, GLenum type, GLsizei stride, const void *pointer); +GLAPI PFNGLVERTEXPOINTERPROC glad_glVertexPointer; +#define glVertexPointer glad_glVertexPointer +typedef GLboolean (APIENTRYP PFNGLARETEXTURESRESIDENTPROC)(GLsizei n, const GLuint *textures, GLboolean *residences); +GLAPI PFNGLARETEXTURESRESIDENTPROC glad_glAreTexturesResident; +#define glAreTexturesResident glad_glAreTexturesResident +typedef void (APIENTRYP PFNGLPRIORITIZETEXTURESPROC)(GLsizei n, const GLuint *textures, const GLfloat *priorities); +GLAPI PFNGLPRIORITIZETEXTURESPROC glad_glPrioritizeTextures; +#define glPrioritizeTextures glad_glPrioritizeTextures +typedef void (APIENTRYP PFNGLINDEXUBPROC)(GLubyte c); +GLAPI PFNGLINDEXUBPROC glad_glIndexub; +#define glIndexub glad_glIndexub +typedef void (APIENTRYP PFNGLINDEXUBVPROC)(const GLubyte *c); +GLAPI PFNGLINDEXUBVPROC glad_glIndexubv; +#define glIndexubv glad_glIndexubv +typedef void (APIENTRYP PFNGLPOPCLIENTATTRIBPROC)(void); +GLAPI PFNGLPOPCLIENTATTRIBPROC glad_glPopClientAttrib; +#define glPopClientAttrib glad_glPopClientAttrib +typedef void (APIENTRYP PFNGLPUSHCLIENTATTRIBPROC)(GLbitfield mask); +GLAPI PFNGLPUSHCLIENTATTRIBPROC glad_glPushClientAttrib; +#define glPushClientAttrib glad_glPushClientAttrib +#endif +#ifndef GL_VERSION_1_2 +#define GL_VERSION_1_2 1 +GLAPI int GLAD_GL_VERSION_1_2; +typedef void (APIENTRYP PFNGLDRAWRANGEELEMENTSPROC)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices); +GLAPI PFNGLDRAWRANGEELEMENTSPROC glad_glDrawRangeElements; +#define glDrawRangeElements glad_glDrawRangeElements +typedef void (APIENTRYP PFNGLTEXIMAGE3DPROC)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXIMAGE3DPROC glad_glTexImage3D; +#define glTexImage3D glad_glTexImage3D +typedef void (APIENTRYP PFNGLTEXSUBIMAGE3DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXSUBIMAGE3DPROC glad_glTexSubImage3D; +#define glTexSubImage3D glad_glTexSubImage3D +typedef void (APIENTRYP PFNGLCOPYTEXSUBIMAGE3DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); +GLAPI PFNGLCOPYTEXSUBIMAGE3DPROC glad_glCopyTexSubImage3D; +#define glCopyTexSubImage3D glad_glCopyTexSubImage3D +#endif +#ifndef GL_VERSION_1_3 +#define GL_VERSION_1_3 1 +GLAPI int GLAD_GL_VERSION_1_3; +typedef void (APIENTRYP PFNGLACTIVETEXTUREPROC)(GLenum texture); +GLAPI PFNGLACTIVETEXTUREPROC glad_glActiveTexture; +#define glActiveTexture glad_glActiveTexture +typedef void (APIENTRYP PFNGLSAMPLECOVERAGEPROC)(GLfloat value, GLboolean invert); +GLAPI PFNGLSAMPLECOVERAGEPROC glad_glSampleCoverage; +#define glSampleCoverage glad_glSampleCoverage +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXIMAGE3DPROC)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXIMAGE3DPROC glad_glCompressedTexImage3D; +#define glCompressedTexImage3D glad_glCompressedTexImage3D +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXIMAGE2DPROC)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXIMAGE2DPROC glad_glCompressedTexImage2D; +#define glCompressedTexImage2D glad_glCompressedTexImage2D +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXIMAGE1DPROC)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXIMAGE1DPROC glad_glCompressedTexImage1D; +#define glCompressedTexImage1D glad_glCompressedTexImage1D +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC glad_glCompressedTexSubImage3D; +#define glCompressedTexSubImage3D glad_glCompressedTexSubImage3D +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC glad_glCompressedTexSubImage2D; +#define glCompressedTexSubImage2D glad_glCompressedTexSubImage2D +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC glad_glCompressedTexSubImage1D; +#define glCompressedTexSubImage1D glad_glCompressedTexSubImage1D +typedef void (APIENTRYP PFNGLGETCOMPRESSEDTEXIMAGEPROC)(GLenum target, GLint level, void *img); +GLAPI PFNGLGETCOMPRESSEDTEXIMAGEPROC glad_glGetCompressedTexImage; +#define glGetCompressedTexImage glad_glGetCompressedTexImage +typedef void (APIENTRYP PFNGLCLIENTACTIVETEXTUREPROC)(GLenum texture); +GLAPI PFNGLCLIENTACTIVETEXTUREPROC glad_glClientActiveTexture; +#define glClientActiveTexture glad_glClientActiveTexture +typedef void (APIENTRYP PFNGLMULTITEXCOORD1DPROC)(GLenum target, GLdouble s); +GLAPI PFNGLMULTITEXCOORD1DPROC glad_glMultiTexCoord1d; +#define glMultiTexCoord1d glad_glMultiTexCoord1d +typedef void (APIENTRYP PFNGLMULTITEXCOORD1DVPROC)(GLenum target, const GLdouble *v); +GLAPI PFNGLMULTITEXCOORD1DVPROC glad_glMultiTexCoord1dv; +#define glMultiTexCoord1dv glad_glMultiTexCoord1dv +typedef void (APIENTRYP PFNGLMULTITEXCOORD1FPROC)(GLenum target, GLfloat s); +GLAPI PFNGLMULTITEXCOORD1FPROC glad_glMultiTexCoord1f; +#define glMultiTexCoord1f glad_glMultiTexCoord1f +typedef void (APIENTRYP PFNGLMULTITEXCOORD1FVPROC)(GLenum target, const GLfloat *v); +GLAPI PFNGLMULTITEXCOORD1FVPROC glad_glMultiTexCoord1fv; +#define glMultiTexCoord1fv glad_glMultiTexCoord1fv +typedef void (APIENTRYP PFNGLMULTITEXCOORD1IPROC)(GLenum target, GLint s); +GLAPI PFNGLMULTITEXCOORD1IPROC glad_glMultiTexCoord1i; +#define glMultiTexCoord1i glad_glMultiTexCoord1i +typedef void (APIENTRYP PFNGLMULTITEXCOORD1IVPROC)(GLenum target, const GLint *v); +GLAPI PFNGLMULTITEXCOORD1IVPROC glad_glMultiTexCoord1iv; +#define glMultiTexCoord1iv glad_glMultiTexCoord1iv +typedef void (APIENTRYP PFNGLMULTITEXCOORD1SPROC)(GLenum target, GLshort s); +GLAPI PFNGLMULTITEXCOORD1SPROC glad_glMultiTexCoord1s; +#define glMultiTexCoord1s glad_glMultiTexCoord1s +typedef void (APIENTRYP PFNGLMULTITEXCOORD1SVPROC)(GLenum target, const GLshort *v); +GLAPI PFNGLMULTITEXCOORD1SVPROC glad_glMultiTexCoord1sv; +#define glMultiTexCoord1sv glad_glMultiTexCoord1sv +typedef void (APIENTRYP PFNGLMULTITEXCOORD2DPROC)(GLenum target, GLdouble s, GLdouble t); +GLAPI PFNGLMULTITEXCOORD2DPROC glad_glMultiTexCoord2d; +#define glMultiTexCoord2d glad_glMultiTexCoord2d +typedef void (APIENTRYP PFNGLMULTITEXCOORD2DVPROC)(GLenum target, const GLdouble *v); +GLAPI PFNGLMULTITEXCOORD2DVPROC glad_glMultiTexCoord2dv; +#define glMultiTexCoord2dv glad_glMultiTexCoord2dv +typedef void (APIENTRYP PFNGLMULTITEXCOORD2FPROC)(GLenum target, GLfloat s, GLfloat t); +GLAPI PFNGLMULTITEXCOORD2FPROC glad_glMultiTexCoord2f; +#define glMultiTexCoord2f glad_glMultiTexCoord2f +typedef void (APIENTRYP PFNGLMULTITEXCOORD2FVPROC)(GLenum target, const GLfloat *v); +GLAPI PFNGLMULTITEXCOORD2FVPROC glad_glMultiTexCoord2fv; +#define glMultiTexCoord2fv glad_glMultiTexCoord2fv +typedef void (APIENTRYP PFNGLMULTITEXCOORD2IPROC)(GLenum target, GLint s, GLint t); +GLAPI PFNGLMULTITEXCOORD2IPROC glad_glMultiTexCoord2i; +#define glMultiTexCoord2i glad_glMultiTexCoord2i +typedef void (APIENTRYP PFNGLMULTITEXCOORD2IVPROC)(GLenum target, const GLint *v); +GLAPI PFNGLMULTITEXCOORD2IVPROC glad_glMultiTexCoord2iv; +#define glMultiTexCoord2iv glad_glMultiTexCoord2iv +typedef void (APIENTRYP PFNGLMULTITEXCOORD2SPROC)(GLenum target, GLshort s, GLshort t); +GLAPI PFNGLMULTITEXCOORD2SPROC glad_glMultiTexCoord2s; +#define glMultiTexCoord2s glad_glMultiTexCoord2s +typedef void (APIENTRYP PFNGLMULTITEXCOORD2SVPROC)(GLenum target, const GLshort *v); +GLAPI PFNGLMULTITEXCOORD2SVPROC glad_glMultiTexCoord2sv; +#define glMultiTexCoord2sv glad_glMultiTexCoord2sv +typedef void (APIENTRYP PFNGLMULTITEXCOORD3DPROC)(GLenum target, GLdouble s, GLdouble t, GLdouble r); +GLAPI PFNGLMULTITEXCOORD3DPROC glad_glMultiTexCoord3d; +#define glMultiTexCoord3d glad_glMultiTexCoord3d +typedef void (APIENTRYP PFNGLMULTITEXCOORD3DVPROC)(GLenum target, const GLdouble *v); +GLAPI PFNGLMULTITEXCOORD3DVPROC glad_glMultiTexCoord3dv; +#define glMultiTexCoord3dv glad_glMultiTexCoord3dv +typedef void (APIENTRYP PFNGLMULTITEXCOORD3FPROC)(GLenum target, GLfloat s, GLfloat t, GLfloat r); +GLAPI PFNGLMULTITEXCOORD3FPROC glad_glMultiTexCoord3f; +#define glMultiTexCoord3f glad_glMultiTexCoord3f +typedef void (APIENTRYP PFNGLMULTITEXCOORD3FVPROC)(GLenum target, const GLfloat *v); +GLAPI PFNGLMULTITEXCOORD3FVPROC glad_glMultiTexCoord3fv; +#define glMultiTexCoord3fv glad_glMultiTexCoord3fv +typedef void (APIENTRYP PFNGLMULTITEXCOORD3IPROC)(GLenum target, GLint s, GLint t, GLint r); +GLAPI PFNGLMULTITEXCOORD3IPROC glad_glMultiTexCoord3i; +#define glMultiTexCoord3i glad_glMultiTexCoord3i +typedef void (APIENTRYP PFNGLMULTITEXCOORD3IVPROC)(GLenum target, const GLint *v); +GLAPI PFNGLMULTITEXCOORD3IVPROC glad_glMultiTexCoord3iv; +#define glMultiTexCoord3iv glad_glMultiTexCoord3iv +typedef void (APIENTRYP PFNGLMULTITEXCOORD3SPROC)(GLenum target, GLshort s, GLshort t, GLshort r); +GLAPI PFNGLMULTITEXCOORD3SPROC glad_glMultiTexCoord3s; +#define glMultiTexCoord3s glad_glMultiTexCoord3s +typedef void (APIENTRYP PFNGLMULTITEXCOORD3SVPROC)(GLenum target, const GLshort *v); +GLAPI PFNGLMULTITEXCOORD3SVPROC glad_glMultiTexCoord3sv; +#define glMultiTexCoord3sv glad_glMultiTexCoord3sv +typedef void (APIENTRYP PFNGLMULTITEXCOORD4DPROC)(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q); +GLAPI PFNGLMULTITEXCOORD4DPROC glad_glMultiTexCoord4d; +#define glMultiTexCoord4d glad_glMultiTexCoord4d +typedef void (APIENTRYP PFNGLMULTITEXCOORD4DVPROC)(GLenum target, const GLdouble *v); +GLAPI PFNGLMULTITEXCOORD4DVPROC glad_glMultiTexCoord4dv; +#define glMultiTexCoord4dv glad_glMultiTexCoord4dv +typedef void (APIENTRYP PFNGLMULTITEXCOORD4FPROC)(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q); +GLAPI PFNGLMULTITEXCOORD4FPROC glad_glMultiTexCoord4f; +#define glMultiTexCoord4f glad_glMultiTexCoord4f +typedef void (APIENTRYP PFNGLMULTITEXCOORD4FVPROC)(GLenum target, const GLfloat *v); +GLAPI PFNGLMULTITEXCOORD4FVPROC glad_glMultiTexCoord4fv; +#define glMultiTexCoord4fv glad_glMultiTexCoord4fv +typedef void (APIENTRYP PFNGLMULTITEXCOORD4IPROC)(GLenum target, GLint s, GLint t, GLint r, GLint q); +GLAPI PFNGLMULTITEXCOORD4IPROC glad_glMultiTexCoord4i; +#define glMultiTexCoord4i glad_glMultiTexCoord4i +typedef void (APIENTRYP PFNGLMULTITEXCOORD4IVPROC)(GLenum target, const GLint *v); +GLAPI PFNGLMULTITEXCOORD4IVPROC glad_glMultiTexCoord4iv; +#define glMultiTexCoord4iv glad_glMultiTexCoord4iv +typedef void (APIENTRYP PFNGLMULTITEXCOORD4SPROC)(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q); +GLAPI PFNGLMULTITEXCOORD4SPROC glad_glMultiTexCoord4s; +#define glMultiTexCoord4s glad_glMultiTexCoord4s +typedef void (APIENTRYP PFNGLMULTITEXCOORD4SVPROC)(GLenum target, const GLshort *v); +GLAPI PFNGLMULTITEXCOORD4SVPROC glad_glMultiTexCoord4sv; +#define glMultiTexCoord4sv glad_glMultiTexCoord4sv +typedef void (APIENTRYP PFNGLLOADTRANSPOSEMATRIXFPROC)(const GLfloat *m); +GLAPI PFNGLLOADTRANSPOSEMATRIXFPROC glad_glLoadTransposeMatrixf; +#define glLoadTransposeMatrixf glad_glLoadTransposeMatrixf +typedef void (APIENTRYP PFNGLLOADTRANSPOSEMATRIXDPROC)(const GLdouble *m); +GLAPI PFNGLLOADTRANSPOSEMATRIXDPROC glad_glLoadTransposeMatrixd; +#define glLoadTransposeMatrixd glad_glLoadTransposeMatrixd +typedef void (APIENTRYP PFNGLMULTTRANSPOSEMATRIXFPROC)(const GLfloat *m); +GLAPI PFNGLMULTTRANSPOSEMATRIXFPROC glad_glMultTransposeMatrixf; +#define glMultTransposeMatrixf glad_glMultTransposeMatrixf +typedef void (APIENTRYP PFNGLMULTTRANSPOSEMATRIXDPROC)(const GLdouble *m); +GLAPI PFNGLMULTTRANSPOSEMATRIXDPROC glad_glMultTransposeMatrixd; +#define glMultTransposeMatrixd glad_glMultTransposeMatrixd +#endif +#ifndef GL_VERSION_1_4 +#define GL_VERSION_1_4 1 +GLAPI int GLAD_GL_VERSION_1_4; +typedef void (APIENTRYP PFNGLBLENDFUNCSEPARATEPROC)(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha); +GLAPI PFNGLBLENDFUNCSEPARATEPROC glad_glBlendFuncSeparate; +#define glBlendFuncSeparate glad_glBlendFuncSeparate +typedef void (APIENTRYP PFNGLMULTIDRAWARRAYSPROC)(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount); +GLAPI PFNGLMULTIDRAWARRAYSPROC glad_glMultiDrawArrays; +#define glMultiDrawArrays glad_glMultiDrawArrays +typedef void (APIENTRYP PFNGLMULTIDRAWELEMENTSPROC)(GLenum mode, const GLsizei *count, GLenum type, const void *const*indices, GLsizei drawcount); +GLAPI PFNGLMULTIDRAWELEMENTSPROC glad_glMultiDrawElements; +#define glMultiDrawElements glad_glMultiDrawElements +typedef void (APIENTRYP PFNGLPOINTPARAMETERFPROC)(GLenum pname, GLfloat param); +GLAPI PFNGLPOINTPARAMETERFPROC glad_glPointParameterf; +#define glPointParameterf glad_glPointParameterf +typedef void (APIENTRYP PFNGLPOINTPARAMETERFVPROC)(GLenum pname, const GLfloat *params); +GLAPI PFNGLPOINTPARAMETERFVPROC glad_glPointParameterfv; +#define glPointParameterfv glad_glPointParameterfv +typedef void (APIENTRYP PFNGLPOINTPARAMETERIPROC)(GLenum pname, GLint param); +GLAPI PFNGLPOINTPARAMETERIPROC glad_glPointParameteri; +#define glPointParameteri glad_glPointParameteri +typedef void (APIENTRYP PFNGLPOINTPARAMETERIVPROC)(GLenum pname, const GLint *params); +GLAPI PFNGLPOINTPARAMETERIVPROC glad_glPointParameteriv; +#define glPointParameteriv glad_glPointParameteriv +typedef void (APIENTRYP PFNGLFOGCOORDFPROC)(GLfloat coord); +GLAPI PFNGLFOGCOORDFPROC glad_glFogCoordf; +#define glFogCoordf glad_glFogCoordf +typedef void (APIENTRYP PFNGLFOGCOORDFVPROC)(const GLfloat *coord); +GLAPI PFNGLFOGCOORDFVPROC glad_glFogCoordfv; +#define glFogCoordfv glad_glFogCoordfv +typedef void (APIENTRYP PFNGLFOGCOORDDPROC)(GLdouble coord); +GLAPI PFNGLFOGCOORDDPROC glad_glFogCoordd; +#define glFogCoordd glad_glFogCoordd +typedef void (APIENTRYP PFNGLFOGCOORDDVPROC)(const GLdouble *coord); +GLAPI PFNGLFOGCOORDDVPROC glad_glFogCoorddv; +#define glFogCoorddv glad_glFogCoorddv +typedef void (APIENTRYP PFNGLFOGCOORDPOINTERPROC)(GLenum type, GLsizei stride, const void *pointer); +GLAPI PFNGLFOGCOORDPOINTERPROC glad_glFogCoordPointer; +#define glFogCoordPointer glad_glFogCoordPointer +typedef void (APIENTRYP PFNGLSECONDARYCOLOR3BPROC)(GLbyte red, GLbyte green, GLbyte blue); +GLAPI PFNGLSECONDARYCOLOR3BPROC glad_glSecondaryColor3b; +#define glSecondaryColor3b glad_glSecondaryColor3b +typedef void (APIENTRYP PFNGLSECONDARYCOLOR3BVPROC)(const GLbyte *v); +GLAPI PFNGLSECONDARYCOLOR3BVPROC glad_glSecondaryColor3bv; +#define glSecondaryColor3bv glad_glSecondaryColor3bv +typedef void (APIENTRYP PFNGLSECONDARYCOLOR3DPROC)(GLdouble red, GLdouble green, GLdouble blue); +GLAPI PFNGLSECONDARYCOLOR3DPROC glad_glSecondaryColor3d; +#define glSecondaryColor3d glad_glSecondaryColor3d +typedef void (APIENTRYP PFNGLSECONDARYCOLOR3DVPROC)(const GLdouble *v); +GLAPI PFNGLSECONDARYCOLOR3DVPROC glad_glSecondaryColor3dv; +#define glSecondaryColor3dv glad_glSecondaryColor3dv +typedef void (APIENTRYP PFNGLSECONDARYCOLOR3FPROC)(GLfloat red, GLfloat green, GLfloat blue); +GLAPI PFNGLSECONDARYCOLOR3FPROC glad_glSecondaryColor3f; +#define glSecondaryColor3f glad_glSecondaryColor3f +typedef void (APIENTRYP PFNGLSECONDARYCOLOR3FVPROC)(const GLfloat *v); +GLAPI PFNGLSECONDARYCOLOR3FVPROC glad_glSecondaryColor3fv; +#define glSecondaryColor3fv glad_glSecondaryColor3fv +typedef void (APIENTRYP PFNGLSECONDARYCOLOR3IPROC)(GLint red, GLint green, GLint blue); +GLAPI PFNGLSECONDARYCOLOR3IPROC glad_glSecondaryColor3i; +#define glSecondaryColor3i glad_glSecondaryColor3i +typedef void (APIENTRYP PFNGLSECONDARYCOLOR3IVPROC)(const GLint *v); +GLAPI PFNGLSECONDARYCOLOR3IVPROC glad_glSecondaryColor3iv; +#define glSecondaryColor3iv glad_glSecondaryColor3iv +typedef void (APIENTRYP PFNGLSECONDARYCOLOR3SPROC)(GLshort red, GLshort green, GLshort blue); +GLAPI PFNGLSECONDARYCOLOR3SPROC glad_glSecondaryColor3s; +#define glSecondaryColor3s glad_glSecondaryColor3s +typedef void (APIENTRYP PFNGLSECONDARYCOLOR3SVPROC)(const GLshort *v); +GLAPI PFNGLSECONDARYCOLOR3SVPROC glad_glSecondaryColor3sv; +#define glSecondaryColor3sv glad_glSecondaryColor3sv +typedef void (APIENTRYP PFNGLSECONDARYCOLOR3UBPROC)(GLubyte red, GLubyte green, GLubyte blue); +GLAPI PFNGLSECONDARYCOLOR3UBPROC glad_glSecondaryColor3ub; +#define glSecondaryColor3ub glad_glSecondaryColor3ub +typedef void (APIENTRYP PFNGLSECONDARYCOLOR3UBVPROC)(const GLubyte *v); +GLAPI PFNGLSECONDARYCOLOR3UBVPROC glad_glSecondaryColor3ubv; +#define glSecondaryColor3ubv glad_glSecondaryColor3ubv +typedef void (APIENTRYP PFNGLSECONDARYCOLOR3UIPROC)(GLuint red, GLuint green, GLuint blue); +GLAPI PFNGLSECONDARYCOLOR3UIPROC glad_glSecondaryColor3ui; +#define glSecondaryColor3ui glad_glSecondaryColor3ui +typedef void (APIENTRYP PFNGLSECONDARYCOLOR3UIVPROC)(const GLuint *v); +GLAPI PFNGLSECONDARYCOLOR3UIVPROC glad_glSecondaryColor3uiv; +#define glSecondaryColor3uiv glad_glSecondaryColor3uiv +typedef void (APIENTRYP PFNGLSECONDARYCOLOR3USPROC)(GLushort red, GLushort green, GLushort blue); +GLAPI PFNGLSECONDARYCOLOR3USPROC glad_glSecondaryColor3us; +#define glSecondaryColor3us glad_glSecondaryColor3us +typedef void (APIENTRYP PFNGLSECONDARYCOLOR3USVPROC)(const GLushort *v); +GLAPI PFNGLSECONDARYCOLOR3USVPROC glad_glSecondaryColor3usv; +#define glSecondaryColor3usv glad_glSecondaryColor3usv +typedef void (APIENTRYP PFNGLSECONDARYCOLORPOINTERPROC)(GLint size, GLenum type, GLsizei stride, const void *pointer); +GLAPI PFNGLSECONDARYCOLORPOINTERPROC glad_glSecondaryColorPointer; +#define glSecondaryColorPointer glad_glSecondaryColorPointer +typedef void (APIENTRYP PFNGLWINDOWPOS2DPROC)(GLdouble x, GLdouble y); +GLAPI PFNGLWINDOWPOS2DPROC glad_glWindowPos2d; +#define glWindowPos2d glad_glWindowPos2d +typedef void (APIENTRYP PFNGLWINDOWPOS2DVPROC)(const GLdouble *v); +GLAPI PFNGLWINDOWPOS2DVPROC glad_glWindowPos2dv; +#define glWindowPos2dv glad_glWindowPos2dv +typedef void (APIENTRYP PFNGLWINDOWPOS2FPROC)(GLfloat x, GLfloat y); +GLAPI PFNGLWINDOWPOS2FPROC glad_glWindowPos2f; +#define glWindowPos2f glad_glWindowPos2f +typedef void (APIENTRYP PFNGLWINDOWPOS2FVPROC)(const GLfloat *v); +GLAPI PFNGLWINDOWPOS2FVPROC glad_glWindowPos2fv; +#define glWindowPos2fv glad_glWindowPos2fv +typedef void (APIENTRYP PFNGLWINDOWPOS2IPROC)(GLint x, GLint y); +GLAPI PFNGLWINDOWPOS2IPROC glad_glWindowPos2i; +#define glWindowPos2i glad_glWindowPos2i +typedef void (APIENTRYP PFNGLWINDOWPOS2IVPROC)(const GLint *v); +GLAPI PFNGLWINDOWPOS2IVPROC glad_glWindowPos2iv; +#define glWindowPos2iv glad_glWindowPos2iv +typedef void (APIENTRYP PFNGLWINDOWPOS2SPROC)(GLshort x, GLshort y); +GLAPI PFNGLWINDOWPOS2SPROC glad_glWindowPos2s; +#define glWindowPos2s glad_glWindowPos2s +typedef void (APIENTRYP PFNGLWINDOWPOS2SVPROC)(const GLshort *v); +GLAPI PFNGLWINDOWPOS2SVPROC glad_glWindowPos2sv; +#define glWindowPos2sv glad_glWindowPos2sv +typedef void (APIENTRYP PFNGLWINDOWPOS3DPROC)(GLdouble x, GLdouble y, GLdouble z); +GLAPI PFNGLWINDOWPOS3DPROC glad_glWindowPos3d; +#define glWindowPos3d glad_glWindowPos3d +typedef void (APIENTRYP PFNGLWINDOWPOS3DVPROC)(const GLdouble *v); +GLAPI PFNGLWINDOWPOS3DVPROC glad_glWindowPos3dv; +#define glWindowPos3dv glad_glWindowPos3dv +typedef void (APIENTRYP PFNGLWINDOWPOS3FPROC)(GLfloat x, GLfloat y, GLfloat z); +GLAPI PFNGLWINDOWPOS3FPROC glad_glWindowPos3f; +#define glWindowPos3f glad_glWindowPos3f +typedef void (APIENTRYP PFNGLWINDOWPOS3FVPROC)(const GLfloat *v); +GLAPI PFNGLWINDOWPOS3FVPROC glad_glWindowPos3fv; +#define glWindowPos3fv glad_glWindowPos3fv +typedef void (APIENTRYP PFNGLWINDOWPOS3IPROC)(GLint x, GLint y, GLint z); +GLAPI PFNGLWINDOWPOS3IPROC glad_glWindowPos3i; +#define glWindowPos3i glad_glWindowPos3i +typedef void (APIENTRYP PFNGLWINDOWPOS3IVPROC)(const GLint *v); +GLAPI PFNGLWINDOWPOS3IVPROC glad_glWindowPos3iv; +#define glWindowPos3iv glad_glWindowPos3iv +typedef void (APIENTRYP PFNGLWINDOWPOS3SPROC)(GLshort x, GLshort y, GLshort z); +GLAPI PFNGLWINDOWPOS3SPROC glad_glWindowPos3s; +#define glWindowPos3s glad_glWindowPos3s +typedef void (APIENTRYP PFNGLWINDOWPOS3SVPROC)(const GLshort *v); +GLAPI PFNGLWINDOWPOS3SVPROC glad_glWindowPos3sv; +#define glWindowPos3sv glad_glWindowPos3sv +typedef void (APIENTRYP PFNGLBLENDCOLORPROC)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +GLAPI PFNGLBLENDCOLORPROC glad_glBlendColor; +#define glBlendColor glad_glBlendColor +typedef void (APIENTRYP PFNGLBLENDEQUATIONPROC)(GLenum mode); +GLAPI PFNGLBLENDEQUATIONPROC glad_glBlendEquation; +#define glBlendEquation glad_glBlendEquation +#endif +#ifndef GL_VERSION_1_5 +#define GL_VERSION_1_5 1 +GLAPI int GLAD_GL_VERSION_1_5; +typedef void (APIENTRYP PFNGLGENQUERIESPROC)(GLsizei n, GLuint *ids); +GLAPI PFNGLGENQUERIESPROC glad_glGenQueries; +#define glGenQueries glad_glGenQueries +typedef void (APIENTRYP PFNGLDELETEQUERIESPROC)(GLsizei n, const GLuint *ids); +GLAPI PFNGLDELETEQUERIESPROC glad_glDeleteQueries; +#define glDeleteQueries glad_glDeleteQueries +typedef GLboolean (APIENTRYP PFNGLISQUERYPROC)(GLuint id); +GLAPI PFNGLISQUERYPROC glad_glIsQuery; +#define glIsQuery glad_glIsQuery +typedef void (APIENTRYP PFNGLBEGINQUERYPROC)(GLenum target, GLuint id); +GLAPI PFNGLBEGINQUERYPROC glad_glBeginQuery; +#define glBeginQuery glad_glBeginQuery +typedef void (APIENTRYP PFNGLENDQUERYPROC)(GLenum target); +GLAPI PFNGLENDQUERYPROC glad_glEndQuery; +#define glEndQuery glad_glEndQuery +typedef void (APIENTRYP PFNGLGETQUERYIVPROC)(GLenum target, GLenum pname, GLint *params); +GLAPI PFNGLGETQUERYIVPROC glad_glGetQueryiv; +#define glGetQueryiv glad_glGetQueryiv +typedef void (APIENTRYP PFNGLGETQUERYOBJECTIVPROC)(GLuint id, GLenum pname, GLint *params); +GLAPI PFNGLGETQUERYOBJECTIVPROC glad_glGetQueryObjectiv; +#define glGetQueryObjectiv glad_glGetQueryObjectiv +typedef void (APIENTRYP PFNGLGETQUERYOBJECTUIVPROC)(GLuint id, GLenum pname, GLuint *params); +GLAPI PFNGLGETQUERYOBJECTUIVPROC glad_glGetQueryObjectuiv; +#define glGetQueryObjectuiv glad_glGetQueryObjectuiv +typedef void (APIENTRYP PFNGLBINDBUFFERPROC)(GLenum target, GLuint buffer); +GLAPI PFNGLBINDBUFFERPROC glad_glBindBuffer; +#define glBindBuffer glad_glBindBuffer +typedef void (APIENTRYP PFNGLDELETEBUFFERSPROC)(GLsizei n, const GLuint *buffers); +GLAPI PFNGLDELETEBUFFERSPROC glad_glDeleteBuffers; +#define glDeleteBuffers glad_glDeleteBuffers +typedef void (APIENTRYP PFNGLGENBUFFERSPROC)(GLsizei n, GLuint *buffers); +GLAPI PFNGLGENBUFFERSPROC glad_glGenBuffers; +#define glGenBuffers glad_glGenBuffers +typedef GLboolean (APIENTRYP PFNGLISBUFFERPROC)(GLuint buffer); +GLAPI PFNGLISBUFFERPROC glad_glIsBuffer; +#define glIsBuffer glad_glIsBuffer +typedef void (APIENTRYP PFNGLBUFFERDATAPROC)(GLenum target, GLsizeiptr size, const void *data, GLenum usage); +GLAPI PFNGLBUFFERDATAPROC glad_glBufferData; +#define glBufferData glad_glBufferData +typedef void (APIENTRYP PFNGLBUFFERSUBDATAPROC)(GLenum target, GLintptr offset, GLsizeiptr size, const void *data); +GLAPI PFNGLBUFFERSUBDATAPROC glad_glBufferSubData; +#define glBufferSubData glad_glBufferSubData +typedef void (APIENTRYP PFNGLGETBUFFERSUBDATAPROC)(GLenum target, GLintptr offset, GLsizeiptr size, void *data); +GLAPI PFNGLGETBUFFERSUBDATAPROC glad_glGetBufferSubData; +#define glGetBufferSubData glad_glGetBufferSubData +typedef void * (APIENTRYP PFNGLMAPBUFFERPROC)(GLenum target, GLenum access); +GLAPI PFNGLMAPBUFFERPROC glad_glMapBuffer; +#define glMapBuffer glad_glMapBuffer +typedef GLboolean (APIENTRYP PFNGLUNMAPBUFFERPROC)(GLenum target); +GLAPI PFNGLUNMAPBUFFERPROC glad_glUnmapBuffer; +#define glUnmapBuffer glad_glUnmapBuffer +typedef void (APIENTRYP PFNGLGETBUFFERPARAMETERIVPROC)(GLenum target, GLenum pname, GLint *params); +GLAPI PFNGLGETBUFFERPARAMETERIVPROC glad_glGetBufferParameteriv; +#define glGetBufferParameteriv glad_glGetBufferParameteriv +typedef void (APIENTRYP PFNGLGETBUFFERPOINTERVPROC)(GLenum target, GLenum pname, void **params); +GLAPI PFNGLGETBUFFERPOINTERVPROC glad_glGetBufferPointerv; +#define glGetBufferPointerv glad_glGetBufferPointerv +#endif +#ifndef GL_VERSION_2_0 +#define GL_VERSION_2_0 1 +GLAPI int GLAD_GL_VERSION_2_0; +typedef void (APIENTRYP PFNGLBLENDEQUATIONSEPARATEPROC)(GLenum modeRGB, GLenum modeAlpha); +GLAPI PFNGLBLENDEQUATIONSEPARATEPROC glad_glBlendEquationSeparate; +#define glBlendEquationSeparate glad_glBlendEquationSeparate +typedef void (APIENTRYP PFNGLDRAWBUFFERSPROC)(GLsizei n, const GLenum *bufs); +GLAPI PFNGLDRAWBUFFERSPROC glad_glDrawBuffers; +#define glDrawBuffers glad_glDrawBuffers +typedef void (APIENTRYP PFNGLSTENCILOPSEPARATEPROC)(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass); +GLAPI PFNGLSTENCILOPSEPARATEPROC glad_glStencilOpSeparate; +#define glStencilOpSeparate glad_glStencilOpSeparate +typedef void (APIENTRYP PFNGLSTENCILFUNCSEPARATEPROC)(GLenum face, GLenum func, GLint ref, GLuint mask); +GLAPI PFNGLSTENCILFUNCSEPARATEPROC glad_glStencilFuncSeparate; +#define glStencilFuncSeparate glad_glStencilFuncSeparate +typedef void (APIENTRYP PFNGLSTENCILMASKSEPARATEPROC)(GLenum face, GLuint mask); +GLAPI PFNGLSTENCILMASKSEPARATEPROC glad_glStencilMaskSeparate; +#define glStencilMaskSeparate glad_glStencilMaskSeparate +typedef void (APIENTRYP PFNGLATTACHSHADERPROC)(GLuint program, GLuint shader); +GLAPI PFNGLATTACHSHADERPROC glad_glAttachShader; +#define glAttachShader glad_glAttachShader +typedef void (APIENTRYP PFNGLBINDATTRIBLOCATIONPROC)(GLuint program, GLuint index, const GLchar *name); +GLAPI PFNGLBINDATTRIBLOCATIONPROC glad_glBindAttribLocation; +#define glBindAttribLocation glad_glBindAttribLocation +typedef void (APIENTRYP PFNGLCOMPILESHADERPROC)(GLuint shader); +GLAPI PFNGLCOMPILESHADERPROC glad_glCompileShader; +#define glCompileShader glad_glCompileShader +typedef GLuint (APIENTRYP PFNGLCREATEPROGRAMPROC)(void); +GLAPI PFNGLCREATEPROGRAMPROC glad_glCreateProgram; +#define glCreateProgram glad_glCreateProgram +typedef GLuint (APIENTRYP PFNGLCREATESHADERPROC)(GLenum type); +GLAPI PFNGLCREATESHADERPROC glad_glCreateShader; +#define glCreateShader glad_glCreateShader +typedef void (APIENTRYP PFNGLDELETEPROGRAMPROC)(GLuint program); +GLAPI PFNGLDELETEPROGRAMPROC glad_glDeleteProgram; +#define glDeleteProgram glad_glDeleteProgram +typedef void (APIENTRYP PFNGLDELETESHADERPROC)(GLuint shader); +GLAPI PFNGLDELETESHADERPROC glad_glDeleteShader; +#define glDeleteShader glad_glDeleteShader +typedef void (APIENTRYP PFNGLDETACHSHADERPROC)(GLuint program, GLuint shader); +GLAPI PFNGLDETACHSHADERPROC glad_glDetachShader; +#define glDetachShader glad_glDetachShader +typedef void (APIENTRYP PFNGLDISABLEVERTEXATTRIBARRAYPROC)(GLuint index); +GLAPI PFNGLDISABLEVERTEXATTRIBARRAYPROC glad_glDisableVertexAttribArray; +#define glDisableVertexAttribArray glad_glDisableVertexAttribArray +typedef void (APIENTRYP PFNGLENABLEVERTEXATTRIBARRAYPROC)(GLuint index); +GLAPI PFNGLENABLEVERTEXATTRIBARRAYPROC glad_glEnableVertexAttribArray; +#define glEnableVertexAttribArray glad_glEnableVertexAttribArray +typedef void (APIENTRYP PFNGLGETACTIVEATTRIBPROC)(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name); +GLAPI PFNGLGETACTIVEATTRIBPROC glad_glGetActiveAttrib; +#define glGetActiveAttrib glad_glGetActiveAttrib +typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMPROC)(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name); +GLAPI PFNGLGETACTIVEUNIFORMPROC glad_glGetActiveUniform; +#define glGetActiveUniform glad_glGetActiveUniform +typedef void (APIENTRYP PFNGLGETATTACHEDSHADERSPROC)(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *shaders); +GLAPI PFNGLGETATTACHEDSHADERSPROC glad_glGetAttachedShaders; +#define glGetAttachedShaders glad_glGetAttachedShaders +typedef GLint (APIENTRYP PFNGLGETATTRIBLOCATIONPROC)(GLuint program, const GLchar *name); +GLAPI PFNGLGETATTRIBLOCATIONPROC glad_glGetAttribLocation; +#define glGetAttribLocation glad_glGetAttribLocation +typedef void (APIENTRYP PFNGLGETPROGRAMIVPROC)(GLuint program, GLenum pname, GLint *params); +GLAPI PFNGLGETPROGRAMIVPROC glad_glGetProgramiv; +#define glGetProgramiv glad_glGetProgramiv +typedef void (APIENTRYP PFNGLGETPROGRAMINFOLOGPROC)(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog); +GLAPI PFNGLGETPROGRAMINFOLOGPROC glad_glGetProgramInfoLog; +#define glGetProgramInfoLog glad_glGetProgramInfoLog +typedef void (APIENTRYP PFNGLGETSHADERIVPROC)(GLuint shader, GLenum pname, GLint *params); +GLAPI PFNGLGETSHADERIVPROC glad_glGetShaderiv; +#define glGetShaderiv glad_glGetShaderiv +typedef void (APIENTRYP PFNGLGETSHADERINFOLOGPROC)(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog); +GLAPI PFNGLGETSHADERINFOLOGPROC glad_glGetShaderInfoLog; +#define glGetShaderInfoLog glad_glGetShaderInfoLog +typedef void (APIENTRYP PFNGLGETSHADERSOURCEPROC)(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source); +GLAPI PFNGLGETSHADERSOURCEPROC glad_glGetShaderSource; +#define glGetShaderSource glad_glGetShaderSource +typedef GLint (APIENTRYP PFNGLGETUNIFORMLOCATIONPROC)(GLuint program, const GLchar *name); +GLAPI PFNGLGETUNIFORMLOCATIONPROC glad_glGetUniformLocation; +#define glGetUniformLocation glad_glGetUniformLocation +typedef void (APIENTRYP PFNGLGETUNIFORMFVPROC)(GLuint program, GLint location, GLfloat *params); +GLAPI PFNGLGETUNIFORMFVPROC glad_glGetUniformfv; +#define glGetUniformfv glad_glGetUniformfv +typedef void (APIENTRYP PFNGLGETUNIFORMIVPROC)(GLuint program, GLint location, GLint *params); +GLAPI PFNGLGETUNIFORMIVPROC glad_glGetUniformiv; +#define glGetUniformiv glad_glGetUniformiv +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBDVPROC)(GLuint index, GLenum pname, GLdouble *params); +GLAPI PFNGLGETVERTEXATTRIBDVPROC glad_glGetVertexAttribdv; +#define glGetVertexAttribdv glad_glGetVertexAttribdv +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBFVPROC)(GLuint index, GLenum pname, GLfloat *params); +GLAPI PFNGLGETVERTEXATTRIBFVPROC glad_glGetVertexAttribfv; +#define glGetVertexAttribfv glad_glGetVertexAttribfv +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBIVPROC)(GLuint index, GLenum pname, GLint *params); +GLAPI PFNGLGETVERTEXATTRIBIVPROC glad_glGetVertexAttribiv; +#define glGetVertexAttribiv glad_glGetVertexAttribiv +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBPOINTERVPROC)(GLuint index, GLenum pname, void **pointer); +GLAPI PFNGLGETVERTEXATTRIBPOINTERVPROC glad_glGetVertexAttribPointerv; +#define glGetVertexAttribPointerv glad_glGetVertexAttribPointerv +typedef GLboolean (APIENTRYP PFNGLISPROGRAMPROC)(GLuint program); +GLAPI PFNGLISPROGRAMPROC glad_glIsProgram; +#define glIsProgram glad_glIsProgram +typedef GLboolean (APIENTRYP PFNGLISSHADERPROC)(GLuint shader); +GLAPI PFNGLISSHADERPROC glad_glIsShader; +#define glIsShader glad_glIsShader +typedef void (APIENTRYP PFNGLLINKPROGRAMPROC)(GLuint program); +GLAPI PFNGLLINKPROGRAMPROC glad_glLinkProgram; +#define glLinkProgram glad_glLinkProgram +typedef void (APIENTRYP PFNGLSHADERSOURCEPROC)(GLuint shader, GLsizei count, const GLchar *const*string, const GLint *length); +GLAPI PFNGLSHADERSOURCEPROC glad_glShaderSource; +#define glShaderSource glad_glShaderSource +typedef void (APIENTRYP PFNGLUSEPROGRAMPROC)(GLuint program); +GLAPI PFNGLUSEPROGRAMPROC glad_glUseProgram; +#define glUseProgram glad_glUseProgram +typedef void (APIENTRYP PFNGLUNIFORM1FPROC)(GLint location, GLfloat v0); +GLAPI PFNGLUNIFORM1FPROC glad_glUniform1f; +#define glUniform1f glad_glUniform1f +typedef void (APIENTRYP PFNGLUNIFORM2FPROC)(GLint location, GLfloat v0, GLfloat v1); +GLAPI PFNGLUNIFORM2FPROC glad_glUniform2f; +#define glUniform2f glad_glUniform2f +typedef void (APIENTRYP PFNGLUNIFORM3FPROC)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2); +GLAPI PFNGLUNIFORM3FPROC glad_glUniform3f; +#define glUniform3f glad_glUniform3f +typedef void (APIENTRYP PFNGLUNIFORM4FPROC)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); +GLAPI PFNGLUNIFORM4FPROC glad_glUniform4f; +#define glUniform4f glad_glUniform4f +typedef void (APIENTRYP PFNGLUNIFORM1IPROC)(GLint location, GLint v0); +GLAPI PFNGLUNIFORM1IPROC glad_glUniform1i; +#define glUniform1i glad_glUniform1i +typedef void (APIENTRYP PFNGLUNIFORM2IPROC)(GLint location, GLint v0, GLint v1); +GLAPI PFNGLUNIFORM2IPROC glad_glUniform2i; +#define glUniform2i glad_glUniform2i +typedef void (APIENTRYP PFNGLUNIFORM3IPROC)(GLint location, GLint v0, GLint v1, GLint v2); +GLAPI PFNGLUNIFORM3IPROC glad_glUniform3i; +#define glUniform3i glad_glUniform3i +typedef void (APIENTRYP PFNGLUNIFORM4IPROC)(GLint location, GLint v0, GLint v1, GLint v2, GLint v3); +GLAPI PFNGLUNIFORM4IPROC glad_glUniform4i; +#define glUniform4i glad_glUniform4i +typedef void (APIENTRYP PFNGLUNIFORM1FVPROC)(GLint location, GLsizei count, const GLfloat *value); +GLAPI PFNGLUNIFORM1FVPROC glad_glUniform1fv; +#define glUniform1fv glad_glUniform1fv +typedef void (APIENTRYP PFNGLUNIFORM2FVPROC)(GLint location, GLsizei count, const GLfloat *value); +GLAPI PFNGLUNIFORM2FVPROC glad_glUniform2fv; +#define glUniform2fv glad_glUniform2fv +typedef void (APIENTRYP PFNGLUNIFORM3FVPROC)(GLint location, GLsizei count, const GLfloat *value); +GLAPI PFNGLUNIFORM3FVPROC glad_glUniform3fv; +#define glUniform3fv glad_glUniform3fv +typedef void (APIENTRYP PFNGLUNIFORM4FVPROC)(GLint location, GLsizei count, const GLfloat *value); +GLAPI PFNGLUNIFORM4FVPROC glad_glUniform4fv; +#define glUniform4fv glad_glUniform4fv +typedef void (APIENTRYP PFNGLUNIFORM1IVPROC)(GLint location, GLsizei count, const GLint *value); +GLAPI PFNGLUNIFORM1IVPROC glad_glUniform1iv; +#define glUniform1iv glad_glUniform1iv +typedef void (APIENTRYP PFNGLUNIFORM2IVPROC)(GLint location, GLsizei count, const GLint *value); +GLAPI PFNGLUNIFORM2IVPROC glad_glUniform2iv; +#define glUniform2iv glad_glUniform2iv +typedef void (APIENTRYP PFNGLUNIFORM3IVPROC)(GLint location, GLsizei count, const GLint *value); +GLAPI PFNGLUNIFORM3IVPROC glad_glUniform3iv; +#define glUniform3iv glad_glUniform3iv +typedef void (APIENTRYP PFNGLUNIFORM4IVPROC)(GLint location, GLsizei count, const GLint *value); +GLAPI PFNGLUNIFORM4IVPROC glad_glUniform4iv; +#define glUniform4iv glad_glUniform4iv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX2FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX2FVPROC glad_glUniformMatrix2fv; +#define glUniformMatrix2fv glad_glUniformMatrix2fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX3FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX3FVPROC glad_glUniformMatrix3fv; +#define glUniformMatrix3fv glad_glUniformMatrix3fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX4FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX4FVPROC glad_glUniformMatrix4fv; +#define glUniformMatrix4fv glad_glUniformMatrix4fv +typedef void (APIENTRYP PFNGLVALIDATEPROGRAMPROC)(GLuint program); +GLAPI PFNGLVALIDATEPROGRAMPROC glad_glValidateProgram; +#define glValidateProgram glad_glValidateProgram +typedef void (APIENTRYP PFNGLVERTEXATTRIB1DPROC)(GLuint index, GLdouble x); +GLAPI PFNGLVERTEXATTRIB1DPROC glad_glVertexAttrib1d; +#define glVertexAttrib1d glad_glVertexAttrib1d +typedef void (APIENTRYP PFNGLVERTEXATTRIB1DVPROC)(GLuint index, const GLdouble *v); +GLAPI PFNGLVERTEXATTRIB1DVPROC glad_glVertexAttrib1dv; +#define glVertexAttrib1dv glad_glVertexAttrib1dv +typedef void (APIENTRYP PFNGLVERTEXATTRIB1FPROC)(GLuint index, GLfloat x); +GLAPI PFNGLVERTEXATTRIB1FPROC glad_glVertexAttrib1f; +#define glVertexAttrib1f glad_glVertexAttrib1f +typedef void (APIENTRYP PFNGLVERTEXATTRIB1FVPROC)(GLuint index, const GLfloat *v); +GLAPI PFNGLVERTEXATTRIB1FVPROC glad_glVertexAttrib1fv; +#define glVertexAttrib1fv glad_glVertexAttrib1fv +typedef void (APIENTRYP PFNGLVERTEXATTRIB1SPROC)(GLuint index, GLshort x); +GLAPI PFNGLVERTEXATTRIB1SPROC glad_glVertexAttrib1s; +#define glVertexAttrib1s glad_glVertexAttrib1s +typedef void (APIENTRYP PFNGLVERTEXATTRIB1SVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIB1SVPROC glad_glVertexAttrib1sv; +#define glVertexAttrib1sv glad_glVertexAttrib1sv +typedef void (APIENTRYP PFNGLVERTEXATTRIB2DPROC)(GLuint index, GLdouble x, GLdouble y); +GLAPI PFNGLVERTEXATTRIB2DPROC glad_glVertexAttrib2d; +#define glVertexAttrib2d glad_glVertexAttrib2d +typedef void (APIENTRYP PFNGLVERTEXATTRIB2DVPROC)(GLuint index, const GLdouble *v); +GLAPI PFNGLVERTEXATTRIB2DVPROC glad_glVertexAttrib2dv; +#define glVertexAttrib2dv glad_glVertexAttrib2dv +typedef void (APIENTRYP PFNGLVERTEXATTRIB2FPROC)(GLuint index, GLfloat x, GLfloat y); +GLAPI PFNGLVERTEXATTRIB2FPROC glad_glVertexAttrib2f; +#define glVertexAttrib2f glad_glVertexAttrib2f +typedef void (APIENTRYP PFNGLVERTEXATTRIB2FVPROC)(GLuint index, const GLfloat *v); +GLAPI PFNGLVERTEXATTRIB2FVPROC glad_glVertexAttrib2fv; +#define glVertexAttrib2fv glad_glVertexAttrib2fv +typedef void (APIENTRYP PFNGLVERTEXATTRIB2SPROC)(GLuint index, GLshort x, GLshort y); +GLAPI PFNGLVERTEXATTRIB2SPROC glad_glVertexAttrib2s; +#define glVertexAttrib2s glad_glVertexAttrib2s +typedef void (APIENTRYP PFNGLVERTEXATTRIB2SVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIB2SVPROC glad_glVertexAttrib2sv; +#define glVertexAttrib2sv glad_glVertexAttrib2sv +typedef void (APIENTRYP PFNGLVERTEXATTRIB3DPROC)(GLuint index, GLdouble x, GLdouble y, GLdouble z); +GLAPI PFNGLVERTEXATTRIB3DPROC glad_glVertexAttrib3d; +#define glVertexAttrib3d glad_glVertexAttrib3d +typedef void (APIENTRYP PFNGLVERTEXATTRIB3DVPROC)(GLuint index, const GLdouble *v); +GLAPI PFNGLVERTEXATTRIB3DVPROC glad_glVertexAttrib3dv; +#define glVertexAttrib3dv glad_glVertexAttrib3dv +typedef void (APIENTRYP PFNGLVERTEXATTRIB3FPROC)(GLuint index, GLfloat x, GLfloat y, GLfloat z); +GLAPI PFNGLVERTEXATTRIB3FPROC glad_glVertexAttrib3f; +#define glVertexAttrib3f glad_glVertexAttrib3f +typedef void (APIENTRYP PFNGLVERTEXATTRIB3FVPROC)(GLuint index, const GLfloat *v); +GLAPI PFNGLVERTEXATTRIB3FVPROC glad_glVertexAttrib3fv; +#define glVertexAttrib3fv glad_glVertexAttrib3fv +typedef void (APIENTRYP PFNGLVERTEXATTRIB3SPROC)(GLuint index, GLshort x, GLshort y, GLshort z); +GLAPI PFNGLVERTEXATTRIB3SPROC glad_glVertexAttrib3s; +#define glVertexAttrib3s glad_glVertexAttrib3s +typedef void (APIENTRYP PFNGLVERTEXATTRIB3SVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIB3SVPROC glad_glVertexAttrib3sv; +#define glVertexAttrib3sv glad_glVertexAttrib3sv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NBVPROC)(GLuint index, const GLbyte *v); +GLAPI PFNGLVERTEXATTRIB4NBVPROC glad_glVertexAttrib4Nbv; +#define glVertexAttrib4Nbv glad_glVertexAttrib4Nbv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NIVPROC)(GLuint index, const GLint *v); +GLAPI PFNGLVERTEXATTRIB4NIVPROC glad_glVertexAttrib4Niv; +#define glVertexAttrib4Niv glad_glVertexAttrib4Niv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NSVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIB4NSVPROC glad_glVertexAttrib4Nsv; +#define glVertexAttrib4Nsv glad_glVertexAttrib4Nsv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUBPROC)(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w); +GLAPI PFNGLVERTEXATTRIB4NUBPROC glad_glVertexAttrib4Nub; +#define glVertexAttrib4Nub glad_glVertexAttrib4Nub +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUBVPROC)(GLuint index, const GLubyte *v); +GLAPI PFNGLVERTEXATTRIB4NUBVPROC glad_glVertexAttrib4Nubv; +#define glVertexAttrib4Nubv glad_glVertexAttrib4Nubv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUIVPROC)(GLuint index, const GLuint *v); +GLAPI PFNGLVERTEXATTRIB4NUIVPROC glad_glVertexAttrib4Nuiv; +#define glVertexAttrib4Nuiv glad_glVertexAttrib4Nuiv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUSVPROC)(GLuint index, const GLushort *v); +GLAPI PFNGLVERTEXATTRIB4NUSVPROC glad_glVertexAttrib4Nusv; +#define glVertexAttrib4Nusv glad_glVertexAttrib4Nusv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4BVPROC)(GLuint index, const GLbyte *v); +GLAPI PFNGLVERTEXATTRIB4BVPROC glad_glVertexAttrib4bv; +#define glVertexAttrib4bv glad_glVertexAttrib4bv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4DPROC)(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +GLAPI PFNGLVERTEXATTRIB4DPROC glad_glVertexAttrib4d; +#define glVertexAttrib4d glad_glVertexAttrib4d +typedef void (APIENTRYP PFNGLVERTEXATTRIB4DVPROC)(GLuint index, const GLdouble *v); +GLAPI PFNGLVERTEXATTRIB4DVPROC glad_glVertexAttrib4dv; +#define glVertexAttrib4dv glad_glVertexAttrib4dv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4FPROC)(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +GLAPI PFNGLVERTEXATTRIB4FPROC glad_glVertexAttrib4f; +#define glVertexAttrib4f glad_glVertexAttrib4f +typedef void (APIENTRYP PFNGLVERTEXATTRIB4FVPROC)(GLuint index, const GLfloat *v); +GLAPI PFNGLVERTEXATTRIB4FVPROC glad_glVertexAttrib4fv; +#define glVertexAttrib4fv glad_glVertexAttrib4fv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4IVPROC)(GLuint index, const GLint *v); +GLAPI PFNGLVERTEXATTRIB4IVPROC glad_glVertexAttrib4iv; +#define glVertexAttrib4iv glad_glVertexAttrib4iv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4SPROC)(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w); +GLAPI PFNGLVERTEXATTRIB4SPROC glad_glVertexAttrib4s; +#define glVertexAttrib4s glad_glVertexAttrib4s +typedef void (APIENTRYP PFNGLVERTEXATTRIB4SVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIB4SVPROC glad_glVertexAttrib4sv; +#define glVertexAttrib4sv glad_glVertexAttrib4sv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4UBVPROC)(GLuint index, const GLubyte *v); +GLAPI PFNGLVERTEXATTRIB4UBVPROC glad_glVertexAttrib4ubv; +#define glVertexAttrib4ubv glad_glVertexAttrib4ubv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4UIVPROC)(GLuint index, const GLuint *v); +GLAPI PFNGLVERTEXATTRIB4UIVPROC glad_glVertexAttrib4uiv; +#define glVertexAttrib4uiv glad_glVertexAttrib4uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4USVPROC)(GLuint index, const GLushort *v); +GLAPI PFNGLVERTEXATTRIB4USVPROC glad_glVertexAttrib4usv; +#define glVertexAttrib4usv glad_glVertexAttrib4usv +typedef void (APIENTRYP PFNGLVERTEXATTRIBPOINTERPROC)(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer); +GLAPI PFNGLVERTEXATTRIBPOINTERPROC glad_glVertexAttribPointer; +#define glVertexAttribPointer glad_glVertexAttribPointer +#endif +#ifndef GL_VERSION_2_1 +#define GL_VERSION_2_1 1 +GLAPI int GLAD_GL_VERSION_2_1; +typedef void (APIENTRYP PFNGLUNIFORMMATRIX2X3FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX2X3FVPROC glad_glUniformMatrix2x3fv; +#define glUniformMatrix2x3fv glad_glUniformMatrix2x3fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX3X2FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX3X2FVPROC glad_glUniformMatrix3x2fv; +#define glUniformMatrix3x2fv glad_glUniformMatrix3x2fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX2X4FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX2X4FVPROC glad_glUniformMatrix2x4fv; +#define glUniformMatrix2x4fv glad_glUniformMatrix2x4fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX4X2FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX4X2FVPROC glad_glUniformMatrix4x2fv; +#define glUniformMatrix4x2fv glad_glUniformMatrix4x2fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX3X4FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX3X4FVPROC glad_glUniformMatrix3x4fv; +#define glUniformMatrix3x4fv glad_glUniformMatrix3x4fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX4X3FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX4X3FVPROC glad_glUniformMatrix4x3fv; +#define glUniformMatrix4x3fv glad_glUniformMatrix4x3fv +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/src/glad.c b/src/glad.c new file mode 100644 index 0000000..24d225f --- /dev/null +++ b/src/glad.c @@ -0,0 +1,1467 @@ +/* + + OpenGL loader generated by glad 0.1.36 on Fri Sep 26 00:08:37 2025. + + Language/Generator: C/C++ + Specification: gl + APIs: gl=2.1 + Profile: compatibility + Extensions: + + Loader: True + Local files: False + Omit khrplatform: False + Reproducible: False + + Commandline: + --profile="compatibility" --api="gl=2.1" --generator="c" --spec="gl" --extensions="" + Online: + https://glad.dav1d.de/#profile=compatibility&language=c&specification=gl&loader=on&api=gl%3D2.1 +*/ + +#include +#include +#include +#include + +static void* get_proc(const char *namez); + +#if defined(_WIN32) || defined(__CYGWIN__) +#ifndef _WINDOWS_ +#undef APIENTRY +#endif +#include +static HMODULE libGL; + +typedef void* (APIENTRYP PFNWGLGETPROCADDRESSPROC_PRIVATE)(const char*); +static PFNWGLGETPROCADDRESSPROC_PRIVATE gladGetProcAddressPtr; + +#ifdef _MSC_VER +#ifdef __has_include + #if __has_include() + #define HAVE_WINAPIFAMILY 1 + #endif +#elif _MSC_VER >= 1700 && !_USING_V110_SDK71_ + #define HAVE_WINAPIFAMILY 1 +#endif +#endif + +#ifdef HAVE_WINAPIFAMILY + #include + #if !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) && WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) + #define IS_UWP 1 + #endif +#endif + +static +int open_gl(void) { +#ifndef IS_UWP + libGL = LoadLibraryW(L"opengl32.dll"); + if(libGL != NULL) { + void (* tmp)(void); + tmp = (void(*)(void)) GetProcAddress(libGL, "wglGetProcAddress"); + gladGetProcAddressPtr = (PFNWGLGETPROCADDRESSPROC_PRIVATE) tmp; + return gladGetProcAddressPtr != NULL; + } +#endif + + return 0; +} + +static +void close_gl(void) { + if(libGL != NULL) { + FreeLibrary((HMODULE) libGL); + libGL = NULL; + } +} +#else +#include +static void* libGL; + +#if !defined(__APPLE__) && !defined(__HAIKU__) +typedef void* (APIENTRYP PFNGLXGETPROCADDRESSPROC_PRIVATE)(const char*); +static PFNGLXGETPROCADDRESSPROC_PRIVATE gladGetProcAddressPtr; +#endif + +static +int open_gl(void) { +#ifdef __APPLE__ + static const char *NAMES[] = { + "../Frameworks/OpenGL.framework/OpenGL", + "/Library/Frameworks/OpenGL.framework/OpenGL", + "/System/Library/Frameworks/OpenGL.framework/OpenGL", + "/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL" + }; +#else + static const char *NAMES[] = {"libGL.so.1", "libGL.so"}; +#endif + + unsigned int index = 0; + for(index = 0; index < (sizeof(NAMES) / sizeof(NAMES[0])); index++) { + libGL = dlopen(NAMES[index], RTLD_NOW | RTLD_GLOBAL); + + if(libGL != NULL) { +#if defined(__APPLE__) || defined(__HAIKU__) + return 1; +#else + gladGetProcAddressPtr = (PFNGLXGETPROCADDRESSPROC_PRIVATE)dlsym(libGL, + "glXGetProcAddressARB"); + return gladGetProcAddressPtr != NULL; +#endif + } + } + + return 0; +} + +static +void close_gl(void) { + if(libGL != NULL) { + dlclose(libGL); + libGL = NULL; + } +} +#endif + +static +void* get_proc(const char *namez) { + void* result = NULL; + if(libGL == NULL) return NULL; + +#if !defined(__APPLE__) && !defined(__HAIKU__) + if(gladGetProcAddressPtr != NULL) { + result = gladGetProcAddressPtr(namez); + } +#endif + if(result == NULL) { +#if defined(_WIN32) || defined(__CYGWIN__) + result = (void*)GetProcAddress((HMODULE) libGL, namez); +#else + result = dlsym(libGL, namez); +#endif + } + + return result; +} + +int gladLoadGL(void) { + int status = 0; + + if(open_gl()) { + status = gladLoadGLLoader(&get_proc); + close_gl(); + } + + return status; +} + +struct gladGLversionStruct GLVersion = { 0, 0 }; + +#if defined(GL_ES_VERSION_3_0) || defined(GL_VERSION_3_0) +#define _GLAD_IS_SOME_NEW_VERSION 1 +#endif + +static int max_loaded_major; +static int max_loaded_minor; + +static const char *exts = NULL; +static int num_exts_i = 0; +static char **exts_i = NULL; + +static int get_exts(void) { +#ifdef _GLAD_IS_SOME_NEW_VERSION + if(max_loaded_major < 3) { +#endif + exts = (const char *)glGetString(GL_EXTENSIONS); +#ifdef _GLAD_IS_SOME_NEW_VERSION + } else { + int index; + + num_exts_i = 0; + glGetIntegerv(GL_NUM_EXTENSIONS, &num_exts_i); + if (num_exts_i > 0) { + exts_i = (char **)malloc((size_t)num_exts_i * (sizeof *exts_i)); + } + + if (exts_i == NULL) { + return 0; + } + + for(index = 0; index < num_exts_i; index++) { + const char *gl_str_tmp = (const char*)glGetStringi(GL_EXTENSIONS, index); + size_t len = strlen(gl_str_tmp); + + char *local_str = (char*)malloc((len+1) * sizeof(char)); + if(local_str != NULL) { + memcpy(local_str, gl_str_tmp, (len+1) * sizeof(char)); + } + exts_i[index] = local_str; + } + } +#endif + return 1; +} + +static void free_exts(void) { + if (exts_i != NULL) { + int index; + for(index = 0; index < num_exts_i; index++) { + free((char *)exts_i[index]); + } + free((void *)exts_i); + exts_i = NULL; + } +} + +static int has_ext(const char *ext) { +#ifdef _GLAD_IS_SOME_NEW_VERSION + if(max_loaded_major < 3) { +#endif + const char *extensions; + const char *loc; + const char *terminator; + extensions = exts; + if(extensions == NULL || ext == NULL) { + return 0; + } + + while(1) { + loc = strstr(extensions, ext); + if(loc == NULL) { + return 0; + } + + terminator = loc + strlen(ext); + if((loc == extensions || *(loc - 1) == ' ') && + (*terminator == ' ' || *terminator == '\0')) { + return 1; + } + extensions = terminator; + } +#ifdef _GLAD_IS_SOME_NEW_VERSION + } else { + int index; + if(exts_i == NULL) return 0; + for(index = 0; index < num_exts_i; index++) { + const char *e = exts_i[index]; + + if(exts_i[index] != NULL && strcmp(e, ext) == 0) { + return 1; + } + } + } +#endif + + return 0; +} +int GLAD_GL_VERSION_1_0 = 0; +int GLAD_GL_VERSION_1_1 = 0; +int GLAD_GL_VERSION_1_2 = 0; +int GLAD_GL_VERSION_1_3 = 0; +int GLAD_GL_VERSION_1_4 = 0; +int GLAD_GL_VERSION_1_5 = 0; +int GLAD_GL_VERSION_2_0 = 0; +int GLAD_GL_VERSION_2_1 = 0; +PFNGLACCUMPROC glad_glAccum = NULL; +PFNGLACTIVETEXTUREPROC glad_glActiveTexture = NULL; +PFNGLALPHAFUNCPROC glad_glAlphaFunc = NULL; +PFNGLARETEXTURESRESIDENTPROC glad_glAreTexturesResident = NULL; +PFNGLARRAYELEMENTPROC glad_glArrayElement = NULL; +PFNGLATTACHSHADERPROC glad_glAttachShader = NULL; +PFNGLBEGINPROC glad_glBegin = NULL; +PFNGLBEGINQUERYPROC glad_glBeginQuery = NULL; +PFNGLBINDATTRIBLOCATIONPROC glad_glBindAttribLocation = NULL; +PFNGLBINDBUFFERPROC glad_glBindBuffer = NULL; +PFNGLBINDTEXTUREPROC glad_glBindTexture = NULL; +PFNGLBITMAPPROC glad_glBitmap = NULL; +PFNGLBLENDCOLORPROC glad_glBlendColor = NULL; +PFNGLBLENDEQUATIONPROC glad_glBlendEquation = NULL; +PFNGLBLENDEQUATIONSEPARATEPROC glad_glBlendEquationSeparate = NULL; +PFNGLBLENDFUNCPROC glad_glBlendFunc = NULL; +PFNGLBLENDFUNCSEPARATEPROC glad_glBlendFuncSeparate = NULL; +PFNGLBUFFERDATAPROC glad_glBufferData = NULL; +PFNGLBUFFERSUBDATAPROC glad_glBufferSubData = NULL; +PFNGLCALLLISTPROC glad_glCallList = NULL; +PFNGLCALLLISTSPROC glad_glCallLists = NULL; +PFNGLCLEARPROC glad_glClear = NULL; +PFNGLCLEARACCUMPROC glad_glClearAccum = NULL; +PFNGLCLEARCOLORPROC glad_glClearColor = NULL; +PFNGLCLEARDEPTHPROC glad_glClearDepth = NULL; +PFNGLCLEARINDEXPROC glad_glClearIndex = NULL; +PFNGLCLEARSTENCILPROC glad_glClearStencil = NULL; +PFNGLCLIENTACTIVETEXTUREPROC glad_glClientActiveTexture = NULL; +PFNGLCLIPPLANEPROC glad_glClipPlane = NULL; +PFNGLCOLOR3BPROC glad_glColor3b = NULL; +PFNGLCOLOR3BVPROC glad_glColor3bv = NULL; +PFNGLCOLOR3DPROC glad_glColor3d = NULL; +PFNGLCOLOR3DVPROC glad_glColor3dv = NULL; +PFNGLCOLOR3FPROC glad_glColor3f = NULL; +PFNGLCOLOR3FVPROC glad_glColor3fv = NULL; +PFNGLCOLOR3IPROC glad_glColor3i = NULL; +PFNGLCOLOR3IVPROC glad_glColor3iv = NULL; +PFNGLCOLOR3SPROC glad_glColor3s = NULL; +PFNGLCOLOR3SVPROC glad_glColor3sv = NULL; +PFNGLCOLOR3UBPROC glad_glColor3ub = NULL; +PFNGLCOLOR3UBVPROC glad_glColor3ubv = NULL; +PFNGLCOLOR3UIPROC glad_glColor3ui = NULL; +PFNGLCOLOR3UIVPROC glad_glColor3uiv = NULL; +PFNGLCOLOR3USPROC glad_glColor3us = NULL; +PFNGLCOLOR3USVPROC glad_glColor3usv = NULL; +PFNGLCOLOR4BPROC glad_glColor4b = NULL; +PFNGLCOLOR4BVPROC glad_glColor4bv = NULL; +PFNGLCOLOR4DPROC glad_glColor4d = NULL; +PFNGLCOLOR4DVPROC glad_glColor4dv = NULL; +PFNGLCOLOR4FPROC glad_glColor4f = NULL; +PFNGLCOLOR4FVPROC glad_glColor4fv = NULL; +PFNGLCOLOR4IPROC glad_glColor4i = NULL; +PFNGLCOLOR4IVPROC glad_glColor4iv = NULL; +PFNGLCOLOR4SPROC glad_glColor4s = NULL; +PFNGLCOLOR4SVPROC glad_glColor4sv = NULL; +PFNGLCOLOR4UBPROC glad_glColor4ub = NULL; +PFNGLCOLOR4UBVPROC glad_glColor4ubv = NULL; +PFNGLCOLOR4UIPROC glad_glColor4ui = NULL; +PFNGLCOLOR4UIVPROC glad_glColor4uiv = NULL; +PFNGLCOLOR4USPROC glad_glColor4us = NULL; +PFNGLCOLOR4USVPROC glad_glColor4usv = NULL; +PFNGLCOLORMASKPROC glad_glColorMask = NULL; +PFNGLCOLORMATERIALPROC glad_glColorMaterial = NULL; +PFNGLCOLORPOINTERPROC glad_glColorPointer = NULL; +PFNGLCOMPILESHADERPROC glad_glCompileShader = NULL; +PFNGLCOMPRESSEDTEXIMAGE1DPROC glad_glCompressedTexImage1D = NULL; +PFNGLCOMPRESSEDTEXIMAGE2DPROC glad_glCompressedTexImage2D = NULL; +PFNGLCOMPRESSEDTEXIMAGE3DPROC glad_glCompressedTexImage3D = NULL; +PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC glad_glCompressedTexSubImage1D = NULL; +PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC glad_glCompressedTexSubImage2D = NULL; +PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC glad_glCompressedTexSubImage3D = NULL; +PFNGLCOPYPIXELSPROC glad_glCopyPixels = NULL; +PFNGLCOPYTEXIMAGE1DPROC glad_glCopyTexImage1D = NULL; +PFNGLCOPYTEXIMAGE2DPROC glad_glCopyTexImage2D = NULL; +PFNGLCOPYTEXSUBIMAGE1DPROC glad_glCopyTexSubImage1D = NULL; +PFNGLCOPYTEXSUBIMAGE2DPROC glad_glCopyTexSubImage2D = NULL; +PFNGLCOPYTEXSUBIMAGE3DPROC glad_glCopyTexSubImage3D = NULL; +PFNGLCREATEPROGRAMPROC glad_glCreateProgram = NULL; +PFNGLCREATESHADERPROC glad_glCreateShader = NULL; +PFNGLCULLFACEPROC glad_glCullFace = NULL; +PFNGLDELETEBUFFERSPROC glad_glDeleteBuffers = NULL; +PFNGLDELETELISTSPROC glad_glDeleteLists = NULL; +PFNGLDELETEPROGRAMPROC glad_glDeleteProgram = NULL; +PFNGLDELETEQUERIESPROC glad_glDeleteQueries = NULL; +PFNGLDELETESHADERPROC glad_glDeleteShader = NULL; +PFNGLDELETETEXTURESPROC glad_glDeleteTextures = NULL; +PFNGLDEPTHFUNCPROC glad_glDepthFunc = NULL; +PFNGLDEPTHMASKPROC glad_glDepthMask = NULL; +PFNGLDEPTHRANGEPROC glad_glDepthRange = NULL; +PFNGLDETACHSHADERPROC glad_glDetachShader = NULL; +PFNGLDISABLEPROC glad_glDisable = NULL; +PFNGLDISABLECLIENTSTATEPROC glad_glDisableClientState = NULL; +PFNGLDISABLEVERTEXATTRIBARRAYPROC glad_glDisableVertexAttribArray = NULL; +PFNGLDRAWARRAYSPROC glad_glDrawArrays = NULL; +PFNGLDRAWBUFFERPROC glad_glDrawBuffer = NULL; +PFNGLDRAWBUFFERSPROC glad_glDrawBuffers = NULL; +PFNGLDRAWELEMENTSPROC glad_glDrawElements = NULL; +PFNGLDRAWPIXELSPROC glad_glDrawPixels = NULL; +PFNGLDRAWRANGEELEMENTSPROC glad_glDrawRangeElements = NULL; +PFNGLEDGEFLAGPROC glad_glEdgeFlag = NULL; +PFNGLEDGEFLAGPOINTERPROC glad_glEdgeFlagPointer = NULL; +PFNGLEDGEFLAGVPROC glad_glEdgeFlagv = NULL; +PFNGLENABLEPROC glad_glEnable = NULL; +PFNGLENABLECLIENTSTATEPROC glad_glEnableClientState = NULL; +PFNGLENABLEVERTEXATTRIBARRAYPROC glad_glEnableVertexAttribArray = NULL; +PFNGLENDPROC glad_glEnd = NULL; +PFNGLENDLISTPROC glad_glEndList = NULL; +PFNGLENDQUERYPROC glad_glEndQuery = NULL; +PFNGLEVALCOORD1DPROC glad_glEvalCoord1d = NULL; +PFNGLEVALCOORD1DVPROC glad_glEvalCoord1dv = NULL; +PFNGLEVALCOORD1FPROC glad_glEvalCoord1f = NULL; +PFNGLEVALCOORD1FVPROC glad_glEvalCoord1fv = NULL; +PFNGLEVALCOORD2DPROC glad_glEvalCoord2d = NULL; +PFNGLEVALCOORD2DVPROC glad_glEvalCoord2dv = NULL; +PFNGLEVALCOORD2FPROC glad_glEvalCoord2f = NULL; +PFNGLEVALCOORD2FVPROC glad_glEvalCoord2fv = NULL; +PFNGLEVALMESH1PROC glad_glEvalMesh1 = NULL; +PFNGLEVALMESH2PROC glad_glEvalMesh2 = NULL; +PFNGLEVALPOINT1PROC glad_glEvalPoint1 = NULL; +PFNGLEVALPOINT2PROC glad_glEvalPoint2 = NULL; +PFNGLFEEDBACKBUFFERPROC glad_glFeedbackBuffer = NULL; +PFNGLFINISHPROC glad_glFinish = NULL; +PFNGLFLUSHPROC glad_glFlush = NULL; +PFNGLFOGCOORDPOINTERPROC glad_glFogCoordPointer = NULL; +PFNGLFOGCOORDDPROC glad_glFogCoordd = NULL; +PFNGLFOGCOORDDVPROC glad_glFogCoorddv = NULL; +PFNGLFOGCOORDFPROC glad_glFogCoordf = NULL; +PFNGLFOGCOORDFVPROC glad_glFogCoordfv = NULL; +PFNGLFOGFPROC glad_glFogf = NULL; +PFNGLFOGFVPROC glad_glFogfv = NULL; +PFNGLFOGIPROC glad_glFogi = NULL; +PFNGLFOGIVPROC glad_glFogiv = NULL; +PFNGLFRONTFACEPROC glad_glFrontFace = NULL; +PFNGLFRUSTUMPROC glad_glFrustum = NULL; +PFNGLGENBUFFERSPROC glad_glGenBuffers = NULL; +PFNGLGENLISTSPROC glad_glGenLists = NULL; +PFNGLGENQUERIESPROC glad_glGenQueries = NULL; +PFNGLGENTEXTURESPROC glad_glGenTextures = NULL; +PFNGLGETACTIVEATTRIBPROC glad_glGetActiveAttrib = NULL; +PFNGLGETACTIVEUNIFORMPROC glad_glGetActiveUniform = NULL; +PFNGLGETATTACHEDSHADERSPROC glad_glGetAttachedShaders = NULL; +PFNGLGETATTRIBLOCATIONPROC glad_glGetAttribLocation = NULL; +PFNGLGETBOOLEANVPROC glad_glGetBooleanv = NULL; +PFNGLGETBUFFERPARAMETERIVPROC glad_glGetBufferParameteriv = NULL; +PFNGLGETBUFFERPOINTERVPROC glad_glGetBufferPointerv = NULL; +PFNGLGETBUFFERSUBDATAPROC glad_glGetBufferSubData = NULL; +PFNGLGETCLIPPLANEPROC glad_glGetClipPlane = NULL; +PFNGLGETCOMPRESSEDTEXIMAGEPROC glad_glGetCompressedTexImage = NULL; +PFNGLGETDOUBLEVPROC glad_glGetDoublev = NULL; +PFNGLGETERRORPROC glad_glGetError = NULL; +PFNGLGETFLOATVPROC glad_glGetFloatv = NULL; +PFNGLGETINTEGERVPROC glad_glGetIntegerv = NULL; +PFNGLGETLIGHTFVPROC glad_glGetLightfv = NULL; +PFNGLGETLIGHTIVPROC glad_glGetLightiv = NULL; +PFNGLGETMAPDVPROC glad_glGetMapdv = NULL; +PFNGLGETMAPFVPROC glad_glGetMapfv = NULL; +PFNGLGETMAPIVPROC glad_glGetMapiv = NULL; +PFNGLGETMATERIALFVPROC glad_glGetMaterialfv = NULL; +PFNGLGETMATERIALIVPROC glad_glGetMaterialiv = NULL; +PFNGLGETPIXELMAPFVPROC glad_glGetPixelMapfv = NULL; +PFNGLGETPIXELMAPUIVPROC glad_glGetPixelMapuiv = NULL; +PFNGLGETPIXELMAPUSVPROC glad_glGetPixelMapusv = NULL; +PFNGLGETPOINTERVPROC glad_glGetPointerv = NULL; +PFNGLGETPOLYGONSTIPPLEPROC glad_glGetPolygonStipple = NULL; +PFNGLGETPROGRAMINFOLOGPROC glad_glGetProgramInfoLog = NULL; +PFNGLGETPROGRAMIVPROC glad_glGetProgramiv = NULL; +PFNGLGETQUERYOBJECTIVPROC glad_glGetQueryObjectiv = NULL; +PFNGLGETQUERYOBJECTUIVPROC glad_glGetQueryObjectuiv = NULL; +PFNGLGETQUERYIVPROC glad_glGetQueryiv = NULL; +PFNGLGETSHADERINFOLOGPROC glad_glGetShaderInfoLog = NULL; +PFNGLGETSHADERSOURCEPROC glad_glGetShaderSource = NULL; +PFNGLGETSHADERIVPROC glad_glGetShaderiv = NULL; +PFNGLGETSTRINGPROC glad_glGetString = NULL; +PFNGLGETTEXENVFVPROC glad_glGetTexEnvfv = NULL; +PFNGLGETTEXENVIVPROC glad_glGetTexEnviv = NULL; +PFNGLGETTEXGENDVPROC glad_glGetTexGendv = NULL; +PFNGLGETTEXGENFVPROC glad_glGetTexGenfv = NULL; +PFNGLGETTEXGENIVPROC glad_glGetTexGeniv = NULL; +PFNGLGETTEXIMAGEPROC glad_glGetTexImage = NULL; +PFNGLGETTEXLEVELPARAMETERFVPROC glad_glGetTexLevelParameterfv = NULL; +PFNGLGETTEXLEVELPARAMETERIVPROC glad_glGetTexLevelParameteriv = NULL; +PFNGLGETTEXPARAMETERFVPROC glad_glGetTexParameterfv = NULL; +PFNGLGETTEXPARAMETERIVPROC glad_glGetTexParameteriv = NULL; +PFNGLGETUNIFORMLOCATIONPROC glad_glGetUniformLocation = NULL; +PFNGLGETUNIFORMFVPROC glad_glGetUniformfv = NULL; +PFNGLGETUNIFORMIVPROC glad_glGetUniformiv = NULL; +PFNGLGETVERTEXATTRIBPOINTERVPROC glad_glGetVertexAttribPointerv = NULL; +PFNGLGETVERTEXATTRIBDVPROC glad_glGetVertexAttribdv = NULL; +PFNGLGETVERTEXATTRIBFVPROC glad_glGetVertexAttribfv = NULL; +PFNGLGETVERTEXATTRIBIVPROC glad_glGetVertexAttribiv = NULL; +PFNGLHINTPROC glad_glHint = NULL; +PFNGLINDEXMASKPROC glad_glIndexMask = NULL; +PFNGLINDEXPOINTERPROC glad_glIndexPointer = NULL; +PFNGLINDEXDPROC glad_glIndexd = NULL; +PFNGLINDEXDVPROC glad_glIndexdv = NULL; +PFNGLINDEXFPROC glad_glIndexf = NULL; +PFNGLINDEXFVPROC glad_glIndexfv = NULL; +PFNGLINDEXIPROC glad_glIndexi = NULL; +PFNGLINDEXIVPROC glad_glIndexiv = NULL; +PFNGLINDEXSPROC glad_glIndexs = NULL; +PFNGLINDEXSVPROC glad_glIndexsv = NULL; +PFNGLINDEXUBPROC glad_glIndexub = NULL; +PFNGLINDEXUBVPROC glad_glIndexubv = NULL; +PFNGLINITNAMESPROC glad_glInitNames = NULL; +PFNGLINTERLEAVEDARRAYSPROC glad_glInterleavedArrays = NULL; +PFNGLISBUFFERPROC glad_glIsBuffer = NULL; +PFNGLISENABLEDPROC glad_glIsEnabled = NULL; +PFNGLISLISTPROC glad_glIsList = NULL; +PFNGLISPROGRAMPROC glad_glIsProgram = NULL; +PFNGLISQUERYPROC glad_glIsQuery = NULL; +PFNGLISSHADERPROC glad_glIsShader = NULL; +PFNGLISTEXTUREPROC glad_glIsTexture = NULL; +PFNGLLIGHTMODELFPROC glad_glLightModelf = NULL; +PFNGLLIGHTMODELFVPROC glad_glLightModelfv = NULL; +PFNGLLIGHTMODELIPROC glad_glLightModeli = NULL; +PFNGLLIGHTMODELIVPROC glad_glLightModeliv = NULL; +PFNGLLIGHTFPROC glad_glLightf = NULL; +PFNGLLIGHTFVPROC glad_glLightfv = NULL; +PFNGLLIGHTIPROC glad_glLighti = NULL; +PFNGLLIGHTIVPROC glad_glLightiv = NULL; +PFNGLLINESTIPPLEPROC glad_glLineStipple = NULL; +PFNGLLINEWIDTHPROC glad_glLineWidth = NULL; +PFNGLLINKPROGRAMPROC glad_glLinkProgram = NULL; +PFNGLLISTBASEPROC glad_glListBase = NULL; +PFNGLLOADIDENTITYPROC glad_glLoadIdentity = NULL; +PFNGLLOADMATRIXDPROC glad_glLoadMatrixd = NULL; +PFNGLLOADMATRIXFPROC glad_glLoadMatrixf = NULL; +PFNGLLOADNAMEPROC glad_glLoadName = NULL; +PFNGLLOADTRANSPOSEMATRIXDPROC glad_glLoadTransposeMatrixd = NULL; +PFNGLLOADTRANSPOSEMATRIXFPROC glad_glLoadTransposeMatrixf = NULL; +PFNGLLOGICOPPROC glad_glLogicOp = NULL; +PFNGLMAP1DPROC glad_glMap1d = NULL; +PFNGLMAP1FPROC glad_glMap1f = NULL; +PFNGLMAP2DPROC glad_glMap2d = NULL; +PFNGLMAP2FPROC glad_glMap2f = NULL; +PFNGLMAPBUFFERPROC glad_glMapBuffer = NULL; +PFNGLMAPGRID1DPROC glad_glMapGrid1d = NULL; +PFNGLMAPGRID1FPROC glad_glMapGrid1f = NULL; +PFNGLMAPGRID2DPROC glad_glMapGrid2d = NULL; +PFNGLMAPGRID2FPROC glad_glMapGrid2f = NULL; +PFNGLMATERIALFPROC glad_glMaterialf = NULL; +PFNGLMATERIALFVPROC glad_glMaterialfv = NULL; +PFNGLMATERIALIPROC glad_glMateriali = NULL; +PFNGLMATERIALIVPROC glad_glMaterialiv = NULL; +PFNGLMATRIXMODEPROC glad_glMatrixMode = NULL; +PFNGLMULTMATRIXDPROC glad_glMultMatrixd = NULL; +PFNGLMULTMATRIXFPROC glad_glMultMatrixf = NULL; +PFNGLMULTTRANSPOSEMATRIXDPROC glad_glMultTransposeMatrixd = NULL; +PFNGLMULTTRANSPOSEMATRIXFPROC glad_glMultTransposeMatrixf = NULL; +PFNGLMULTIDRAWARRAYSPROC glad_glMultiDrawArrays = NULL; +PFNGLMULTIDRAWELEMENTSPROC glad_glMultiDrawElements = NULL; +PFNGLMULTITEXCOORD1DPROC glad_glMultiTexCoord1d = NULL; +PFNGLMULTITEXCOORD1DVPROC glad_glMultiTexCoord1dv = NULL; +PFNGLMULTITEXCOORD1FPROC glad_glMultiTexCoord1f = NULL; +PFNGLMULTITEXCOORD1FVPROC glad_glMultiTexCoord1fv = NULL; +PFNGLMULTITEXCOORD1IPROC glad_glMultiTexCoord1i = NULL; +PFNGLMULTITEXCOORD1IVPROC glad_glMultiTexCoord1iv = NULL; +PFNGLMULTITEXCOORD1SPROC glad_glMultiTexCoord1s = NULL; +PFNGLMULTITEXCOORD1SVPROC glad_glMultiTexCoord1sv = NULL; +PFNGLMULTITEXCOORD2DPROC glad_glMultiTexCoord2d = NULL; +PFNGLMULTITEXCOORD2DVPROC glad_glMultiTexCoord2dv = NULL; +PFNGLMULTITEXCOORD2FPROC glad_glMultiTexCoord2f = NULL; +PFNGLMULTITEXCOORD2FVPROC glad_glMultiTexCoord2fv = NULL; +PFNGLMULTITEXCOORD2IPROC glad_glMultiTexCoord2i = NULL; +PFNGLMULTITEXCOORD2IVPROC glad_glMultiTexCoord2iv = NULL; +PFNGLMULTITEXCOORD2SPROC glad_glMultiTexCoord2s = NULL; +PFNGLMULTITEXCOORD2SVPROC glad_glMultiTexCoord2sv = NULL; +PFNGLMULTITEXCOORD3DPROC glad_glMultiTexCoord3d = NULL; +PFNGLMULTITEXCOORD3DVPROC glad_glMultiTexCoord3dv = NULL; +PFNGLMULTITEXCOORD3FPROC glad_glMultiTexCoord3f = NULL; +PFNGLMULTITEXCOORD3FVPROC glad_glMultiTexCoord3fv = NULL; +PFNGLMULTITEXCOORD3IPROC glad_glMultiTexCoord3i = NULL; +PFNGLMULTITEXCOORD3IVPROC glad_glMultiTexCoord3iv = NULL; +PFNGLMULTITEXCOORD3SPROC glad_glMultiTexCoord3s = NULL; +PFNGLMULTITEXCOORD3SVPROC glad_glMultiTexCoord3sv = NULL; +PFNGLMULTITEXCOORD4DPROC glad_glMultiTexCoord4d = NULL; +PFNGLMULTITEXCOORD4DVPROC glad_glMultiTexCoord4dv = NULL; +PFNGLMULTITEXCOORD4FPROC glad_glMultiTexCoord4f = NULL; +PFNGLMULTITEXCOORD4FVPROC glad_glMultiTexCoord4fv = NULL; +PFNGLMULTITEXCOORD4IPROC glad_glMultiTexCoord4i = NULL; +PFNGLMULTITEXCOORD4IVPROC glad_glMultiTexCoord4iv = NULL; +PFNGLMULTITEXCOORD4SPROC glad_glMultiTexCoord4s = NULL; +PFNGLMULTITEXCOORD4SVPROC glad_glMultiTexCoord4sv = NULL; +PFNGLNEWLISTPROC glad_glNewList = NULL; +PFNGLNORMAL3BPROC glad_glNormal3b = NULL; +PFNGLNORMAL3BVPROC glad_glNormal3bv = NULL; +PFNGLNORMAL3DPROC glad_glNormal3d = NULL; +PFNGLNORMAL3DVPROC glad_glNormal3dv = NULL; +PFNGLNORMAL3FPROC glad_glNormal3f = NULL; +PFNGLNORMAL3FVPROC glad_glNormal3fv = NULL; +PFNGLNORMAL3IPROC glad_glNormal3i = NULL; +PFNGLNORMAL3IVPROC glad_glNormal3iv = NULL; +PFNGLNORMAL3SPROC glad_glNormal3s = NULL; +PFNGLNORMAL3SVPROC glad_glNormal3sv = NULL; +PFNGLNORMALPOINTERPROC glad_glNormalPointer = NULL; +PFNGLORTHOPROC glad_glOrtho = NULL; +PFNGLPASSTHROUGHPROC glad_glPassThrough = NULL; +PFNGLPIXELMAPFVPROC glad_glPixelMapfv = NULL; +PFNGLPIXELMAPUIVPROC glad_glPixelMapuiv = NULL; +PFNGLPIXELMAPUSVPROC glad_glPixelMapusv = NULL; +PFNGLPIXELSTOREFPROC glad_glPixelStoref = NULL; +PFNGLPIXELSTOREIPROC glad_glPixelStorei = NULL; +PFNGLPIXELTRANSFERFPROC glad_glPixelTransferf = NULL; +PFNGLPIXELTRANSFERIPROC glad_glPixelTransferi = NULL; +PFNGLPIXELZOOMPROC glad_glPixelZoom = NULL; +PFNGLPOINTPARAMETERFPROC glad_glPointParameterf = NULL; +PFNGLPOINTPARAMETERFVPROC glad_glPointParameterfv = NULL; +PFNGLPOINTPARAMETERIPROC glad_glPointParameteri = NULL; +PFNGLPOINTPARAMETERIVPROC glad_glPointParameteriv = NULL; +PFNGLPOINTSIZEPROC glad_glPointSize = NULL; +PFNGLPOLYGONMODEPROC glad_glPolygonMode = NULL; +PFNGLPOLYGONOFFSETPROC glad_glPolygonOffset = NULL; +PFNGLPOLYGONSTIPPLEPROC glad_glPolygonStipple = NULL; +PFNGLPOPATTRIBPROC glad_glPopAttrib = NULL; +PFNGLPOPCLIENTATTRIBPROC glad_glPopClientAttrib = NULL; +PFNGLPOPMATRIXPROC glad_glPopMatrix = NULL; +PFNGLPOPNAMEPROC glad_glPopName = NULL; +PFNGLPRIORITIZETEXTURESPROC glad_glPrioritizeTextures = NULL; +PFNGLPUSHATTRIBPROC glad_glPushAttrib = NULL; +PFNGLPUSHCLIENTATTRIBPROC glad_glPushClientAttrib = NULL; +PFNGLPUSHMATRIXPROC glad_glPushMatrix = NULL; +PFNGLPUSHNAMEPROC glad_glPushName = NULL; +PFNGLRASTERPOS2DPROC glad_glRasterPos2d = NULL; +PFNGLRASTERPOS2DVPROC glad_glRasterPos2dv = NULL; +PFNGLRASTERPOS2FPROC glad_glRasterPos2f = NULL; +PFNGLRASTERPOS2FVPROC glad_glRasterPos2fv = NULL; +PFNGLRASTERPOS2IPROC glad_glRasterPos2i = NULL; +PFNGLRASTERPOS2IVPROC glad_glRasterPos2iv = NULL; +PFNGLRASTERPOS2SPROC glad_glRasterPos2s = NULL; +PFNGLRASTERPOS2SVPROC glad_glRasterPos2sv = NULL; +PFNGLRASTERPOS3DPROC glad_glRasterPos3d = NULL; +PFNGLRASTERPOS3DVPROC glad_glRasterPos3dv = NULL; +PFNGLRASTERPOS3FPROC glad_glRasterPos3f = NULL; +PFNGLRASTERPOS3FVPROC glad_glRasterPos3fv = NULL; +PFNGLRASTERPOS3IPROC glad_glRasterPos3i = NULL; +PFNGLRASTERPOS3IVPROC glad_glRasterPos3iv = NULL; +PFNGLRASTERPOS3SPROC glad_glRasterPos3s = NULL; +PFNGLRASTERPOS3SVPROC glad_glRasterPos3sv = NULL; +PFNGLRASTERPOS4DPROC glad_glRasterPos4d = NULL; +PFNGLRASTERPOS4DVPROC glad_glRasterPos4dv = NULL; +PFNGLRASTERPOS4FPROC glad_glRasterPos4f = NULL; +PFNGLRASTERPOS4FVPROC glad_glRasterPos4fv = NULL; +PFNGLRASTERPOS4IPROC glad_glRasterPos4i = NULL; +PFNGLRASTERPOS4IVPROC glad_glRasterPos4iv = NULL; +PFNGLRASTERPOS4SPROC glad_glRasterPos4s = NULL; +PFNGLRASTERPOS4SVPROC glad_glRasterPos4sv = NULL; +PFNGLREADBUFFERPROC glad_glReadBuffer = NULL; +PFNGLREADPIXELSPROC glad_glReadPixels = NULL; +PFNGLRECTDPROC glad_glRectd = NULL; +PFNGLRECTDVPROC glad_glRectdv = NULL; +PFNGLRECTFPROC glad_glRectf = NULL; +PFNGLRECTFVPROC glad_glRectfv = NULL; +PFNGLRECTIPROC glad_glRecti = NULL; +PFNGLRECTIVPROC glad_glRectiv = NULL; +PFNGLRECTSPROC glad_glRects = NULL; +PFNGLRECTSVPROC glad_glRectsv = NULL; +PFNGLRENDERMODEPROC glad_glRenderMode = NULL; +PFNGLROTATEDPROC glad_glRotated = NULL; +PFNGLROTATEFPROC glad_glRotatef = NULL; +PFNGLSAMPLECOVERAGEPROC glad_glSampleCoverage = NULL; +PFNGLSCALEDPROC glad_glScaled = NULL; +PFNGLSCALEFPROC glad_glScalef = NULL; +PFNGLSCISSORPROC glad_glScissor = NULL; +PFNGLSECONDARYCOLOR3BPROC glad_glSecondaryColor3b = NULL; +PFNGLSECONDARYCOLOR3BVPROC glad_glSecondaryColor3bv = NULL; +PFNGLSECONDARYCOLOR3DPROC glad_glSecondaryColor3d = NULL; +PFNGLSECONDARYCOLOR3DVPROC glad_glSecondaryColor3dv = NULL; +PFNGLSECONDARYCOLOR3FPROC glad_glSecondaryColor3f = NULL; +PFNGLSECONDARYCOLOR3FVPROC glad_glSecondaryColor3fv = NULL; +PFNGLSECONDARYCOLOR3IPROC glad_glSecondaryColor3i = NULL; +PFNGLSECONDARYCOLOR3IVPROC glad_glSecondaryColor3iv = NULL; +PFNGLSECONDARYCOLOR3SPROC glad_glSecondaryColor3s = NULL; +PFNGLSECONDARYCOLOR3SVPROC glad_glSecondaryColor3sv = NULL; +PFNGLSECONDARYCOLOR3UBPROC glad_glSecondaryColor3ub = NULL; +PFNGLSECONDARYCOLOR3UBVPROC glad_glSecondaryColor3ubv = NULL; +PFNGLSECONDARYCOLOR3UIPROC glad_glSecondaryColor3ui = NULL; +PFNGLSECONDARYCOLOR3UIVPROC glad_glSecondaryColor3uiv = NULL; +PFNGLSECONDARYCOLOR3USPROC glad_glSecondaryColor3us = NULL; +PFNGLSECONDARYCOLOR3USVPROC glad_glSecondaryColor3usv = NULL; +PFNGLSECONDARYCOLORPOINTERPROC glad_glSecondaryColorPointer = NULL; +PFNGLSELECTBUFFERPROC glad_glSelectBuffer = NULL; +PFNGLSHADEMODELPROC glad_glShadeModel = NULL; +PFNGLSHADERSOURCEPROC glad_glShaderSource = NULL; +PFNGLSTENCILFUNCPROC glad_glStencilFunc = NULL; +PFNGLSTENCILFUNCSEPARATEPROC glad_glStencilFuncSeparate = NULL; +PFNGLSTENCILMASKPROC glad_glStencilMask = NULL; +PFNGLSTENCILMASKSEPARATEPROC glad_glStencilMaskSeparate = NULL; +PFNGLSTENCILOPPROC glad_glStencilOp = NULL; +PFNGLSTENCILOPSEPARATEPROC glad_glStencilOpSeparate = NULL; +PFNGLTEXCOORD1DPROC glad_glTexCoord1d = NULL; +PFNGLTEXCOORD1DVPROC glad_glTexCoord1dv = NULL; +PFNGLTEXCOORD1FPROC glad_glTexCoord1f = NULL; +PFNGLTEXCOORD1FVPROC glad_glTexCoord1fv = NULL; +PFNGLTEXCOORD1IPROC glad_glTexCoord1i = NULL; +PFNGLTEXCOORD1IVPROC glad_glTexCoord1iv = NULL; +PFNGLTEXCOORD1SPROC glad_glTexCoord1s = NULL; +PFNGLTEXCOORD1SVPROC glad_glTexCoord1sv = NULL; +PFNGLTEXCOORD2DPROC glad_glTexCoord2d = NULL; +PFNGLTEXCOORD2DVPROC glad_glTexCoord2dv = NULL; +PFNGLTEXCOORD2FPROC glad_glTexCoord2f = NULL; +PFNGLTEXCOORD2FVPROC glad_glTexCoord2fv = NULL; +PFNGLTEXCOORD2IPROC glad_glTexCoord2i = NULL; +PFNGLTEXCOORD2IVPROC glad_glTexCoord2iv = NULL; +PFNGLTEXCOORD2SPROC glad_glTexCoord2s = NULL; +PFNGLTEXCOORD2SVPROC glad_glTexCoord2sv = NULL; +PFNGLTEXCOORD3DPROC glad_glTexCoord3d = NULL; +PFNGLTEXCOORD3DVPROC glad_glTexCoord3dv = NULL; +PFNGLTEXCOORD3FPROC glad_glTexCoord3f = NULL; +PFNGLTEXCOORD3FVPROC glad_glTexCoord3fv = NULL; +PFNGLTEXCOORD3IPROC glad_glTexCoord3i = NULL; +PFNGLTEXCOORD3IVPROC glad_glTexCoord3iv = NULL; +PFNGLTEXCOORD3SPROC glad_glTexCoord3s = NULL; +PFNGLTEXCOORD3SVPROC glad_glTexCoord3sv = NULL; +PFNGLTEXCOORD4DPROC glad_glTexCoord4d = NULL; +PFNGLTEXCOORD4DVPROC glad_glTexCoord4dv = NULL; +PFNGLTEXCOORD4FPROC glad_glTexCoord4f = NULL; +PFNGLTEXCOORD4FVPROC glad_glTexCoord4fv = NULL; +PFNGLTEXCOORD4IPROC glad_glTexCoord4i = NULL; +PFNGLTEXCOORD4IVPROC glad_glTexCoord4iv = NULL; +PFNGLTEXCOORD4SPROC glad_glTexCoord4s = NULL; +PFNGLTEXCOORD4SVPROC glad_glTexCoord4sv = NULL; +PFNGLTEXCOORDPOINTERPROC glad_glTexCoordPointer = NULL; +PFNGLTEXENVFPROC glad_glTexEnvf = NULL; +PFNGLTEXENVFVPROC glad_glTexEnvfv = NULL; +PFNGLTEXENVIPROC glad_glTexEnvi = NULL; +PFNGLTEXENVIVPROC glad_glTexEnviv = NULL; +PFNGLTEXGENDPROC glad_glTexGend = NULL; +PFNGLTEXGENDVPROC glad_glTexGendv = NULL; +PFNGLTEXGENFPROC glad_glTexGenf = NULL; +PFNGLTEXGENFVPROC glad_glTexGenfv = NULL; +PFNGLTEXGENIPROC glad_glTexGeni = NULL; +PFNGLTEXGENIVPROC glad_glTexGeniv = NULL; +PFNGLTEXIMAGE1DPROC glad_glTexImage1D = NULL; +PFNGLTEXIMAGE2DPROC glad_glTexImage2D = NULL; +PFNGLTEXIMAGE3DPROC glad_glTexImage3D = NULL; +PFNGLTEXPARAMETERFPROC glad_glTexParameterf = NULL; +PFNGLTEXPARAMETERFVPROC glad_glTexParameterfv = NULL; +PFNGLTEXPARAMETERIPROC glad_glTexParameteri = NULL; +PFNGLTEXPARAMETERIVPROC glad_glTexParameteriv = NULL; +PFNGLTEXSUBIMAGE1DPROC glad_glTexSubImage1D = NULL; +PFNGLTEXSUBIMAGE2DPROC glad_glTexSubImage2D = NULL; +PFNGLTEXSUBIMAGE3DPROC glad_glTexSubImage3D = NULL; +PFNGLTRANSLATEDPROC glad_glTranslated = NULL; +PFNGLTRANSLATEFPROC glad_glTranslatef = NULL; +PFNGLUNIFORM1FPROC glad_glUniform1f = NULL; +PFNGLUNIFORM1FVPROC glad_glUniform1fv = NULL; +PFNGLUNIFORM1IPROC glad_glUniform1i = NULL; +PFNGLUNIFORM1IVPROC glad_glUniform1iv = NULL; +PFNGLUNIFORM2FPROC glad_glUniform2f = NULL; +PFNGLUNIFORM2FVPROC glad_glUniform2fv = NULL; +PFNGLUNIFORM2IPROC glad_glUniform2i = NULL; +PFNGLUNIFORM2IVPROC glad_glUniform2iv = NULL; +PFNGLUNIFORM3FPROC glad_glUniform3f = NULL; +PFNGLUNIFORM3FVPROC glad_glUniform3fv = NULL; +PFNGLUNIFORM3IPROC glad_glUniform3i = NULL; +PFNGLUNIFORM3IVPROC glad_glUniform3iv = NULL; +PFNGLUNIFORM4FPROC glad_glUniform4f = NULL; +PFNGLUNIFORM4FVPROC glad_glUniform4fv = NULL; +PFNGLUNIFORM4IPROC glad_glUniform4i = NULL; +PFNGLUNIFORM4IVPROC glad_glUniform4iv = NULL; +PFNGLUNIFORMMATRIX2FVPROC glad_glUniformMatrix2fv = NULL; +PFNGLUNIFORMMATRIX2X3FVPROC glad_glUniformMatrix2x3fv = NULL; +PFNGLUNIFORMMATRIX2X4FVPROC glad_glUniformMatrix2x4fv = NULL; +PFNGLUNIFORMMATRIX3FVPROC glad_glUniformMatrix3fv = NULL; +PFNGLUNIFORMMATRIX3X2FVPROC glad_glUniformMatrix3x2fv = NULL; +PFNGLUNIFORMMATRIX3X4FVPROC glad_glUniformMatrix3x4fv = NULL; +PFNGLUNIFORMMATRIX4FVPROC glad_glUniformMatrix4fv = NULL; +PFNGLUNIFORMMATRIX4X2FVPROC glad_glUniformMatrix4x2fv = NULL; +PFNGLUNIFORMMATRIX4X3FVPROC glad_glUniformMatrix4x3fv = NULL; +PFNGLUNMAPBUFFERPROC glad_glUnmapBuffer = NULL; +PFNGLUSEPROGRAMPROC glad_glUseProgram = NULL; +PFNGLVALIDATEPROGRAMPROC glad_glValidateProgram = NULL; +PFNGLVERTEX2DPROC glad_glVertex2d = NULL; +PFNGLVERTEX2DVPROC glad_glVertex2dv = NULL; +PFNGLVERTEX2FPROC glad_glVertex2f = NULL; +PFNGLVERTEX2FVPROC glad_glVertex2fv = NULL; +PFNGLVERTEX2IPROC glad_glVertex2i = NULL; +PFNGLVERTEX2IVPROC glad_glVertex2iv = NULL; +PFNGLVERTEX2SPROC glad_glVertex2s = NULL; +PFNGLVERTEX2SVPROC glad_glVertex2sv = NULL; +PFNGLVERTEX3DPROC glad_glVertex3d = NULL; +PFNGLVERTEX3DVPROC glad_glVertex3dv = NULL; +PFNGLVERTEX3FPROC glad_glVertex3f = NULL; +PFNGLVERTEX3FVPROC glad_glVertex3fv = NULL; +PFNGLVERTEX3IPROC glad_glVertex3i = NULL; +PFNGLVERTEX3IVPROC glad_glVertex3iv = NULL; +PFNGLVERTEX3SPROC glad_glVertex3s = NULL; +PFNGLVERTEX3SVPROC glad_glVertex3sv = NULL; +PFNGLVERTEX4DPROC glad_glVertex4d = NULL; +PFNGLVERTEX4DVPROC glad_glVertex4dv = NULL; +PFNGLVERTEX4FPROC glad_glVertex4f = NULL; +PFNGLVERTEX4FVPROC glad_glVertex4fv = NULL; +PFNGLVERTEX4IPROC glad_glVertex4i = NULL; +PFNGLVERTEX4IVPROC glad_glVertex4iv = NULL; +PFNGLVERTEX4SPROC glad_glVertex4s = NULL; +PFNGLVERTEX4SVPROC glad_glVertex4sv = NULL; +PFNGLVERTEXATTRIB1DPROC glad_glVertexAttrib1d = NULL; +PFNGLVERTEXATTRIB1DVPROC glad_glVertexAttrib1dv = NULL; +PFNGLVERTEXATTRIB1FPROC glad_glVertexAttrib1f = NULL; +PFNGLVERTEXATTRIB1FVPROC glad_glVertexAttrib1fv = NULL; +PFNGLVERTEXATTRIB1SPROC glad_glVertexAttrib1s = NULL; +PFNGLVERTEXATTRIB1SVPROC glad_glVertexAttrib1sv = NULL; +PFNGLVERTEXATTRIB2DPROC glad_glVertexAttrib2d = NULL; +PFNGLVERTEXATTRIB2DVPROC glad_glVertexAttrib2dv = NULL; +PFNGLVERTEXATTRIB2FPROC glad_glVertexAttrib2f = NULL; +PFNGLVERTEXATTRIB2FVPROC glad_glVertexAttrib2fv = NULL; +PFNGLVERTEXATTRIB2SPROC glad_glVertexAttrib2s = NULL; +PFNGLVERTEXATTRIB2SVPROC glad_glVertexAttrib2sv = NULL; +PFNGLVERTEXATTRIB3DPROC glad_glVertexAttrib3d = NULL; +PFNGLVERTEXATTRIB3DVPROC glad_glVertexAttrib3dv = NULL; +PFNGLVERTEXATTRIB3FPROC glad_glVertexAttrib3f = NULL; +PFNGLVERTEXATTRIB3FVPROC glad_glVertexAttrib3fv = NULL; +PFNGLVERTEXATTRIB3SPROC glad_glVertexAttrib3s = NULL; +PFNGLVERTEXATTRIB3SVPROC glad_glVertexAttrib3sv = NULL; +PFNGLVERTEXATTRIB4NBVPROC glad_glVertexAttrib4Nbv = NULL; +PFNGLVERTEXATTRIB4NIVPROC glad_glVertexAttrib4Niv = NULL; +PFNGLVERTEXATTRIB4NSVPROC glad_glVertexAttrib4Nsv = NULL; +PFNGLVERTEXATTRIB4NUBPROC glad_glVertexAttrib4Nub = NULL; +PFNGLVERTEXATTRIB4NUBVPROC glad_glVertexAttrib4Nubv = NULL; +PFNGLVERTEXATTRIB4NUIVPROC glad_glVertexAttrib4Nuiv = NULL; +PFNGLVERTEXATTRIB4NUSVPROC glad_glVertexAttrib4Nusv = NULL; +PFNGLVERTEXATTRIB4BVPROC glad_glVertexAttrib4bv = NULL; +PFNGLVERTEXATTRIB4DPROC glad_glVertexAttrib4d = NULL; +PFNGLVERTEXATTRIB4DVPROC glad_glVertexAttrib4dv = NULL; +PFNGLVERTEXATTRIB4FPROC glad_glVertexAttrib4f = NULL; +PFNGLVERTEXATTRIB4FVPROC glad_glVertexAttrib4fv = NULL; +PFNGLVERTEXATTRIB4IVPROC glad_glVertexAttrib4iv = NULL; +PFNGLVERTEXATTRIB4SPROC glad_glVertexAttrib4s = NULL; +PFNGLVERTEXATTRIB4SVPROC glad_glVertexAttrib4sv = NULL; +PFNGLVERTEXATTRIB4UBVPROC glad_glVertexAttrib4ubv = NULL; +PFNGLVERTEXATTRIB4UIVPROC glad_glVertexAttrib4uiv = NULL; +PFNGLVERTEXATTRIB4USVPROC glad_glVertexAttrib4usv = NULL; +PFNGLVERTEXATTRIBPOINTERPROC glad_glVertexAttribPointer = NULL; +PFNGLVERTEXPOINTERPROC glad_glVertexPointer = NULL; +PFNGLVIEWPORTPROC glad_glViewport = NULL; +PFNGLWINDOWPOS2DPROC glad_glWindowPos2d = NULL; +PFNGLWINDOWPOS2DVPROC glad_glWindowPos2dv = NULL; +PFNGLWINDOWPOS2FPROC glad_glWindowPos2f = NULL; +PFNGLWINDOWPOS2FVPROC glad_glWindowPos2fv = NULL; +PFNGLWINDOWPOS2IPROC glad_glWindowPos2i = NULL; +PFNGLWINDOWPOS2IVPROC glad_glWindowPos2iv = NULL; +PFNGLWINDOWPOS2SPROC glad_glWindowPos2s = NULL; +PFNGLWINDOWPOS2SVPROC glad_glWindowPos2sv = NULL; +PFNGLWINDOWPOS3DPROC glad_glWindowPos3d = NULL; +PFNGLWINDOWPOS3DVPROC glad_glWindowPos3dv = NULL; +PFNGLWINDOWPOS3FPROC glad_glWindowPos3f = NULL; +PFNGLWINDOWPOS3FVPROC glad_glWindowPos3fv = NULL; +PFNGLWINDOWPOS3IPROC glad_glWindowPos3i = NULL; +PFNGLWINDOWPOS3IVPROC glad_glWindowPos3iv = NULL; +PFNGLWINDOWPOS3SPROC glad_glWindowPos3s = NULL; +PFNGLWINDOWPOS3SVPROC glad_glWindowPos3sv = NULL; +static void load_GL_VERSION_1_0(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_0) return; + glad_glCullFace = (PFNGLCULLFACEPROC)load("glCullFace"); + glad_glFrontFace = (PFNGLFRONTFACEPROC)load("glFrontFace"); + glad_glHint = (PFNGLHINTPROC)load("glHint"); + glad_glLineWidth = (PFNGLLINEWIDTHPROC)load("glLineWidth"); + glad_glPointSize = (PFNGLPOINTSIZEPROC)load("glPointSize"); + glad_glPolygonMode = (PFNGLPOLYGONMODEPROC)load("glPolygonMode"); + glad_glScissor = (PFNGLSCISSORPROC)load("glScissor"); + glad_glTexParameterf = (PFNGLTEXPARAMETERFPROC)load("glTexParameterf"); + glad_glTexParameterfv = (PFNGLTEXPARAMETERFVPROC)load("glTexParameterfv"); + glad_glTexParameteri = (PFNGLTEXPARAMETERIPROC)load("glTexParameteri"); + glad_glTexParameteriv = (PFNGLTEXPARAMETERIVPROC)load("glTexParameteriv"); + glad_glTexImage1D = (PFNGLTEXIMAGE1DPROC)load("glTexImage1D"); + glad_glTexImage2D = (PFNGLTEXIMAGE2DPROC)load("glTexImage2D"); + glad_glDrawBuffer = (PFNGLDRAWBUFFERPROC)load("glDrawBuffer"); + glad_glClear = (PFNGLCLEARPROC)load("glClear"); + glad_glClearColor = (PFNGLCLEARCOLORPROC)load("glClearColor"); + glad_glClearStencil = (PFNGLCLEARSTENCILPROC)load("glClearStencil"); + glad_glClearDepth = (PFNGLCLEARDEPTHPROC)load("glClearDepth"); + glad_glStencilMask = (PFNGLSTENCILMASKPROC)load("glStencilMask"); + glad_glColorMask = (PFNGLCOLORMASKPROC)load("glColorMask"); + glad_glDepthMask = (PFNGLDEPTHMASKPROC)load("glDepthMask"); + glad_glDisable = (PFNGLDISABLEPROC)load("glDisable"); + glad_glEnable = (PFNGLENABLEPROC)load("glEnable"); + glad_glFinish = (PFNGLFINISHPROC)load("glFinish"); + glad_glFlush = (PFNGLFLUSHPROC)load("glFlush"); + glad_glBlendFunc = (PFNGLBLENDFUNCPROC)load("glBlendFunc"); + glad_glLogicOp = (PFNGLLOGICOPPROC)load("glLogicOp"); + glad_glStencilFunc = (PFNGLSTENCILFUNCPROC)load("glStencilFunc"); + glad_glStencilOp = (PFNGLSTENCILOPPROC)load("glStencilOp"); + glad_glDepthFunc = (PFNGLDEPTHFUNCPROC)load("glDepthFunc"); + glad_glPixelStoref = (PFNGLPIXELSTOREFPROC)load("glPixelStoref"); + glad_glPixelStorei = (PFNGLPIXELSTOREIPROC)load("glPixelStorei"); + glad_glReadBuffer = (PFNGLREADBUFFERPROC)load("glReadBuffer"); + glad_glReadPixels = (PFNGLREADPIXELSPROC)load("glReadPixels"); + glad_glGetBooleanv = (PFNGLGETBOOLEANVPROC)load("glGetBooleanv"); + glad_glGetDoublev = (PFNGLGETDOUBLEVPROC)load("glGetDoublev"); + glad_glGetError = (PFNGLGETERRORPROC)load("glGetError"); + glad_glGetFloatv = (PFNGLGETFLOATVPROC)load("glGetFloatv"); + glad_glGetIntegerv = (PFNGLGETINTEGERVPROC)load("glGetIntegerv"); + glad_glGetString = (PFNGLGETSTRINGPROC)load("glGetString"); + glad_glGetTexImage = (PFNGLGETTEXIMAGEPROC)load("glGetTexImage"); + glad_glGetTexParameterfv = (PFNGLGETTEXPARAMETERFVPROC)load("glGetTexParameterfv"); + glad_glGetTexParameteriv = (PFNGLGETTEXPARAMETERIVPROC)load("glGetTexParameteriv"); + glad_glGetTexLevelParameterfv = (PFNGLGETTEXLEVELPARAMETERFVPROC)load("glGetTexLevelParameterfv"); + glad_glGetTexLevelParameteriv = (PFNGLGETTEXLEVELPARAMETERIVPROC)load("glGetTexLevelParameteriv"); + glad_glIsEnabled = (PFNGLISENABLEDPROC)load("glIsEnabled"); + glad_glDepthRange = (PFNGLDEPTHRANGEPROC)load("glDepthRange"); + glad_glViewport = (PFNGLVIEWPORTPROC)load("glViewport"); + glad_glNewList = (PFNGLNEWLISTPROC)load("glNewList"); + glad_glEndList = (PFNGLENDLISTPROC)load("glEndList"); + glad_glCallList = (PFNGLCALLLISTPROC)load("glCallList"); + glad_glCallLists = (PFNGLCALLLISTSPROC)load("glCallLists"); + glad_glDeleteLists = (PFNGLDELETELISTSPROC)load("glDeleteLists"); + glad_glGenLists = (PFNGLGENLISTSPROC)load("glGenLists"); + glad_glListBase = (PFNGLLISTBASEPROC)load("glListBase"); + glad_glBegin = (PFNGLBEGINPROC)load("glBegin"); + glad_glBitmap = (PFNGLBITMAPPROC)load("glBitmap"); + glad_glColor3b = (PFNGLCOLOR3BPROC)load("glColor3b"); + glad_glColor3bv = (PFNGLCOLOR3BVPROC)load("glColor3bv"); + glad_glColor3d = (PFNGLCOLOR3DPROC)load("glColor3d"); + glad_glColor3dv = (PFNGLCOLOR3DVPROC)load("glColor3dv"); + glad_glColor3f = (PFNGLCOLOR3FPROC)load("glColor3f"); + glad_glColor3fv = (PFNGLCOLOR3FVPROC)load("glColor3fv"); + glad_glColor3i = (PFNGLCOLOR3IPROC)load("glColor3i"); + glad_glColor3iv = (PFNGLCOLOR3IVPROC)load("glColor3iv"); + glad_glColor3s = (PFNGLCOLOR3SPROC)load("glColor3s"); + glad_glColor3sv = (PFNGLCOLOR3SVPROC)load("glColor3sv"); + glad_glColor3ub = (PFNGLCOLOR3UBPROC)load("glColor3ub"); + glad_glColor3ubv = (PFNGLCOLOR3UBVPROC)load("glColor3ubv"); + glad_glColor3ui = (PFNGLCOLOR3UIPROC)load("glColor3ui"); + glad_glColor3uiv = (PFNGLCOLOR3UIVPROC)load("glColor3uiv"); + glad_glColor3us = (PFNGLCOLOR3USPROC)load("glColor3us"); + glad_glColor3usv = (PFNGLCOLOR3USVPROC)load("glColor3usv"); + glad_glColor4b = (PFNGLCOLOR4BPROC)load("glColor4b"); + glad_glColor4bv = (PFNGLCOLOR4BVPROC)load("glColor4bv"); + glad_glColor4d = (PFNGLCOLOR4DPROC)load("glColor4d"); + glad_glColor4dv = (PFNGLCOLOR4DVPROC)load("glColor4dv"); + glad_glColor4f = (PFNGLCOLOR4FPROC)load("glColor4f"); + glad_glColor4fv = (PFNGLCOLOR4FVPROC)load("glColor4fv"); + glad_glColor4i = (PFNGLCOLOR4IPROC)load("glColor4i"); + glad_glColor4iv = (PFNGLCOLOR4IVPROC)load("glColor4iv"); + glad_glColor4s = (PFNGLCOLOR4SPROC)load("glColor4s"); + glad_glColor4sv = (PFNGLCOLOR4SVPROC)load("glColor4sv"); + glad_glColor4ub = (PFNGLCOLOR4UBPROC)load("glColor4ub"); + glad_glColor4ubv = (PFNGLCOLOR4UBVPROC)load("glColor4ubv"); + glad_glColor4ui = (PFNGLCOLOR4UIPROC)load("glColor4ui"); + glad_glColor4uiv = (PFNGLCOLOR4UIVPROC)load("glColor4uiv"); + glad_glColor4us = (PFNGLCOLOR4USPROC)load("glColor4us"); + glad_glColor4usv = (PFNGLCOLOR4USVPROC)load("glColor4usv"); + glad_glEdgeFlag = (PFNGLEDGEFLAGPROC)load("glEdgeFlag"); + glad_glEdgeFlagv = (PFNGLEDGEFLAGVPROC)load("glEdgeFlagv"); + glad_glEnd = (PFNGLENDPROC)load("glEnd"); + glad_glIndexd = (PFNGLINDEXDPROC)load("glIndexd"); + glad_glIndexdv = (PFNGLINDEXDVPROC)load("glIndexdv"); + glad_glIndexf = (PFNGLINDEXFPROC)load("glIndexf"); + glad_glIndexfv = (PFNGLINDEXFVPROC)load("glIndexfv"); + glad_glIndexi = (PFNGLINDEXIPROC)load("glIndexi"); + glad_glIndexiv = (PFNGLINDEXIVPROC)load("glIndexiv"); + glad_glIndexs = (PFNGLINDEXSPROC)load("glIndexs"); + glad_glIndexsv = (PFNGLINDEXSVPROC)load("glIndexsv"); + glad_glNormal3b = (PFNGLNORMAL3BPROC)load("glNormal3b"); + glad_glNormal3bv = (PFNGLNORMAL3BVPROC)load("glNormal3bv"); + glad_glNormal3d = (PFNGLNORMAL3DPROC)load("glNormal3d"); + glad_glNormal3dv = (PFNGLNORMAL3DVPROC)load("glNormal3dv"); + glad_glNormal3f = (PFNGLNORMAL3FPROC)load("glNormal3f"); + glad_glNormal3fv = (PFNGLNORMAL3FVPROC)load("glNormal3fv"); + glad_glNormal3i = (PFNGLNORMAL3IPROC)load("glNormal3i"); + glad_glNormal3iv = (PFNGLNORMAL3IVPROC)load("glNormal3iv"); + glad_glNormal3s = (PFNGLNORMAL3SPROC)load("glNormal3s"); + glad_glNormal3sv = (PFNGLNORMAL3SVPROC)load("glNormal3sv"); + glad_glRasterPos2d = (PFNGLRASTERPOS2DPROC)load("glRasterPos2d"); + glad_glRasterPos2dv = (PFNGLRASTERPOS2DVPROC)load("glRasterPos2dv"); + glad_glRasterPos2f = (PFNGLRASTERPOS2FPROC)load("glRasterPos2f"); + glad_glRasterPos2fv = (PFNGLRASTERPOS2FVPROC)load("glRasterPos2fv"); + glad_glRasterPos2i = (PFNGLRASTERPOS2IPROC)load("glRasterPos2i"); + glad_glRasterPos2iv = (PFNGLRASTERPOS2IVPROC)load("glRasterPos2iv"); + glad_glRasterPos2s = (PFNGLRASTERPOS2SPROC)load("glRasterPos2s"); + glad_glRasterPos2sv = (PFNGLRASTERPOS2SVPROC)load("glRasterPos2sv"); + glad_glRasterPos3d = (PFNGLRASTERPOS3DPROC)load("glRasterPos3d"); + glad_glRasterPos3dv = (PFNGLRASTERPOS3DVPROC)load("glRasterPos3dv"); + glad_glRasterPos3f = (PFNGLRASTERPOS3FPROC)load("glRasterPos3f"); + glad_glRasterPos3fv = (PFNGLRASTERPOS3FVPROC)load("glRasterPos3fv"); + glad_glRasterPos3i = (PFNGLRASTERPOS3IPROC)load("glRasterPos3i"); + glad_glRasterPos3iv = (PFNGLRASTERPOS3IVPROC)load("glRasterPos3iv"); + glad_glRasterPos3s = (PFNGLRASTERPOS3SPROC)load("glRasterPos3s"); + glad_glRasterPos3sv = (PFNGLRASTERPOS3SVPROC)load("glRasterPos3sv"); + glad_glRasterPos4d = (PFNGLRASTERPOS4DPROC)load("glRasterPos4d"); + glad_glRasterPos4dv = (PFNGLRASTERPOS4DVPROC)load("glRasterPos4dv"); + glad_glRasterPos4f = (PFNGLRASTERPOS4FPROC)load("glRasterPos4f"); + glad_glRasterPos4fv = (PFNGLRASTERPOS4FVPROC)load("glRasterPos4fv"); + glad_glRasterPos4i = (PFNGLRASTERPOS4IPROC)load("glRasterPos4i"); + glad_glRasterPos4iv = (PFNGLRASTERPOS4IVPROC)load("glRasterPos4iv"); + glad_glRasterPos4s = (PFNGLRASTERPOS4SPROC)load("glRasterPos4s"); + glad_glRasterPos4sv = (PFNGLRASTERPOS4SVPROC)load("glRasterPos4sv"); + glad_glRectd = (PFNGLRECTDPROC)load("glRectd"); + glad_glRectdv = (PFNGLRECTDVPROC)load("glRectdv"); + glad_glRectf = (PFNGLRECTFPROC)load("glRectf"); + glad_glRectfv = (PFNGLRECTFVPROC)load("glRectfv"); + glad_glRecti = (PFNGLRECTIPROC)load("glRecti"); + glad_glRectiv = (PFNGLRECTIVPROC)load("glRectiv"); + glad_glRects = (PFNGLRECTSPROC)load("glRects"); + glad_glRectsv = (PFNGLRECTSVPROC)load("glRectsv"); + glad_glTexCoord1d = (PFNGLTEXCOORD1DPROC)load("glTexCoord1d"); + glad_glTexCoord1dv = (PFNGLTEXCOORD1DVPROC)load("glTexCoord1dv"); + glad_glTexCoord1f = (PFNGLTEXCOORD1FPROC)load("glTexCoord1f"); + glad_glTexCoord1fv = (PFNGLTEXCOORD1FVPROC)load("glTexCoord1fv"); + glad_glTexCoord1i = (PFNGLTEXCOORD1IPROC)load("glTexCoord1i"); + glad_glTexCoord1iv = (PFNGLTEXCOORD1IVPROC)load("glTexCoord1iv"); + glad_glTexCoord1s = (PFNGLTEXCOORD1SPROC)load("glTexCoord1s"); + glad_glTexCoord1sv = (PFNGLTEXCOORD1SVPROC)load("glTexCoord1sv"); + glad_glTexCoord2d = (PFNGLTEXCOORD2DPROC)load("glTexCoord2d"); + glad_glTexCoord2dv = (PFNGLTEXCOORD2DVPROC)load("glTexCoord2dv"); + glad_glTexCoord2f = (PFNGLTEXCOORD2FPROC)load("glTexCoord2f"); + glad_glTexCoord2fv = (PFNGLTEXCOORD2FVPROC)load("glTexCoord2fv"); + glad_glTexCoord2i = (PFNGLTEXCOORD2IPROC)load("glTexCoord2i"); + glad_glTexCoord2iv = (PFNGLTEXCOORD2IVPROC)load("glTexCoord2iv"); + glad_glTexCoord2s = (PFNGLTEXCOORD2SPROC)load("glTexCoord2s"); + glad_glTexCoord2sv = (PFNGLTEXCOORD2SVPROC)load("glTexCoord2sv"); + glad_glTexCoord3d = (PFNGLTEXCOORD3DPROC)load("glTexCoord3d"); + glad_glTexCoord3dv = (PFNGLTEXCOORD3DVPROC)load("glTexCoord3dv"); + glad_glTexCoord3f = (PFNGLTEXCOORD3FPROC)load("glTexCoord3f"); + glad_glTexCoord3fv = (PFNGLTEXCOORD3FVPROC)load("glTexCoord3fv"); + glad_glTexCoord3i = (PFNGLTEXCOORD3IPROC)load("glTexCoord3i"); + glad_glTexCoord3iv = (PFNGLTEXCOORD3IVPROC)load("glTexCoord3iv"); + glad_glTexCoord3s = (PFNGLTEXCOORD3SPROC)load("glTexCoord3s"); + glad_glTexCoord3sv = (PFNGLTEXCOORD3SVPROC)load("glTexCoord3sv"); + glad_glTexCoord4d = (PFNGLTEXCOORD4DPROC)load("glTexCoord4d"); + glad_glTexCoord4dv = (PFNGLTEXCOORD4DVPROC)load("glTexCoord4dv"); + glad_glTexCoord4f = (PFNGLTEXCOORD4FPROC)load("glTexCoord4f"); + glad_glTexCoord4fv = (PFNGLTEXCOORD4FVPROC)load("glTexCoord4fv"); + glad_glTexCoord4i = (PFNGLTEXCOORD4IPROC)load("glTexCoord4i"); + glad_glTexCoord4iv = (PFNGLTEXCOORD4IVPROC)load("glTexCoord4iv"); + glad_glTexCoord4s = (PFNGLTEXCOORD4SPROC)load("glTexCoord4s"); + glad_glTexCoord4sv = (PFNGLTEXCOORD4SVPROC)load("glTexCoord4sv"); + glad_glVertex2d = (PFNGLVERTEX2DPROC)load("glVertex2d"); + glad_glVertex2dv = (PFNGLVERTEX2DVPROC)load("glVertex2dv"); + glad_glVertex2f = (PFNGLVERTEX2FPROC)load("glVertex2f"); + glad_glVertex2fv = (PFNGLVERTEX2FVPROC)load("glVertex2fv"); + glad_glVertex2i = (PFNGLVERTEX2IPROC)load("glVertex2i"); + glad_glVertex2iv = (PFNGLVERTEX2IVPROC)load("glVertex2iv"); + glad_glVertex2s = (PFNGLVERTEX2SPROC)load("glVertex2s"); + glad_glVertex2sv = (PFNGLVERTEX2SVPROC)load("glVertex2sv"); + glad_glVertex3d = (PFNGLVERTEX3DPROC)load("glVertex3d"); + glad_glVertex3dv = (PFNGLVERTEX3DVPROC)load("glVertex3dv"); + glad_glVertex3f = (PFNGLVERTEX3FPROC)load("glVertex3f"); + glad_glVertex3fv = (PFNGLVERTEX3FVPROC)load("glVertex3fv"); + glad_glVertex3i = (PFNGLVERTEX3IPROC)load("glVertex3i"); + glad_glVertex3iv = (PFNGLVERTEX3IVPROC)load("glVertex3iv"); + glad_glVertex3s = (PFNGLVERTEX3SPROC)load("glVertex3s"); + glad_glVertex3sv = (PFNGLVERTEX3SVPROC)load("glVertex3sv"); + glad_glVertex4d = (PFNGLVERTEX4DPROC)load("glVertex4d"); + glad_glVertex4dv = (PFNGLVERTEX4DVPROC)load("glVertex4dv"); + glad_glVertex4f = (PFNGLVERTEX4FPROC)load("glVertex4f"); + glad_glVertex4fv = (PFNGLVERTEX4FVPROC)load("glVertex4fv"); + glad_glVertex4i = (PFNGLVERTEX4IPROC)load("glVertex4i"); + glad_glVertex4iv = (PFNGLVERTEX4IVPROC)load("glVertex4iv"); + glad_glVertex4s = (PFNGLVERTEX4SPROC)load("glVertex4s"); + glad_glVertex4sv = (PFNGLVERTEX4SVPROC)load("glVertex4sv"); + glad_glClipPlane = (PFNGLCLIPPLANEPROC)load("glClipPlane"); + glad_glColorMaterial = (PFNGLCOLORMATERIALPROC)load("glColorMaterial"); + glad_glFogf = (PFNGLFOGFPROC)load("glFogf"); + glad_glFogfv = (PFNGLFOGFVPROC)load("glFogfv"); + glad_glFogi = (PFNGLFOGIPROC)load("glFogi"); + glad_glFogiv = (PFNGLFOGIVPROC)load("glFogiv"); + glad_glLightf = (PFNGLLIGHTFPROC)load("glLightf"); + glad_glLightfv = (PFNGLLIGHTFVPROC)load("glLightfv"); + glad_glLighti = (PFNGLLIGHTIPROC)load("glLighti"); + glad_glLightiv = (PFNGLLIGHTIVPROC)load("glLightiv"); + glad_glLightModelf = (PFNGLLIGHTMODELFPROC)load("glLightModelf"); + glad_glLightModelfv = (PFNGLLIGHTMODELFVPROC)load("glLightModelfv"); + glad_glLightModeli = (PFNGLLIGHTMODELIPROC)load("glLightModeli"); + glad_glLightModeliv = (PFNGLLIGHTMODELIVPROC)load("glLightModeliv"); + glad_glLineStipple = (PFNGLLINESTIPPLEPROC)load("glLineStipple"); + glad_glMaterialf = (PFNGLMATERIALFPROC)load("glMaterialf"); + glad_glMaterialfv = (PFNGLMATERIALFVPROC)load("glMaterialfv"); + glad_glMateriali = (PFNGLMATERIALIPROC)load("glMateriali"); + glad_glMaterialiv = (PFNGLMATERIALIVPROC)load("glMaterialiv"); + glad_glPolygonStipple = (PFNGLPOLYGONSTIPPLEPROC)load("glPolygonStipple"); + glad_glShadeModel = (PFNGLSHADEMODELPROC)load("glShadeModel"); + glad_glTexEnvf = (PFNGLTEXENVFPROC)load("glTexEnvf"); + glad_glTexEnvfv = (PFNGLTEXENVFVPROC)load("glTexEnvfv"); + glad_glTexEnvi = (PFNGLTEXENVIPROC)load("glTexEnvi"); + glad_glTexEnviv = (PFNGLTEXENVIVPROC)load("glTexEnviv"); + glad_glTexGend = (PFNGLTEXGENDPROC)load("glTexGend"); + glad_glTexGendv = (PFNGLTEXGENDVPROC)load("glTexGendv"); + glad_glTexGenf = (PFNGLTEXGENFPROC)load("glTexGenf"); + glad_glTexGenfv = (PFNGLTEXGENFVPROC)load("glTexGenfv"); + glad_glTexGeni = (PFNGLTEXGENIPROC)load("glTexGeni"); + glad_glTexGeniv = (PFNGLTEXGENIVPROC)load("glTexGeniv"); + glad_glFeedbackBuffer = (PFNGLFEEDBACKBUFFERPROC)load("glFeedbackBuffer"); + glad_glSelectBuffer = (PFNGLSELECTBUFFERPROC)load("glSelectBuffer"); + glad_glRenderMode = (PFNGLRENDERMODEPROC)load("glRenderMode"); + glad_glInitNames = (PFNGLINITNAMESPROC)load("glInitNames"); + glad_glLoadName = (PFNGLLOADNAMEPROC)load("glLoadName"); + glad_glPassThrough = (PFNGLPASSTHROUGHPROC)load("glPassThrough"); + glad_glPopName = (PFNGLPOPNAMEPROC)load("glPopName"); + glad_glPushName = (PFNGLPUSHNAMEPROC)load("glPushName"); + glad_glClearAccum = (PFNGLCLEARACCUMPROC)load("glClearAccum"); + glad_glClearIndex = (PFNGLCLEARINDEXPROC)load("glClearIndex"); + glad_glIndexMask = (PFNGLINDEXMASKPROC)load("glIndexMask"); + glad_glAccum = (PFNGLACCUMPROC)load("glAccum"); + glad_glPopAttrib = (PFNGLPOPATTRIBPROC)load("glPopAttrib"); + glad_glPushAttrib = (PFNGLPUSHATTRIBPROC)load("glPushAttrib"); + glad_glMap1d = (PFNGLMAP1DPROC)load("glMap1d"); + glad_glMap1f = (PFNGLMAP1FPROC)load("glMap1f"); + glad_glMap2d = (PFNGLMAP2DPROC)load("glMap2d"); + glad_glMap2f = (PFNGLMAP2FPROC)load("glMap2f"); + glad_glMapGrid1d = (PFNGLMAPGRID1DPROC)load("glMapGrid1d"); + glad_glMapGrid1f = (PFNGLMAPGRID1FPROC)load("glMapGrid1f"); + glad_glMapGrid2d = (PFNGLMAPGRID2DPROC)load("glMapGrid2d"); + glad_glMapGrid2f = (PFNGLMAPGRID2FPROC)load("glMapGrid2f"); + glad_glEvalCoord1d = (PFNGLEVALCOORD1DPROC)load("glEvalCoord1d"); + glad_glEvalCoord1dv = (PFNGLEVALCOORD1DVPROC)load("glEvalCoord1dv"); + glad_glEvalCoord1f = (PFNGLEVALCOORD1FPROC)load("glEvalCoord1f"); + glad_glEvalCoord1fv = (PFNGLEVALCOORD1FVPROC)load("glEvalCoord1fv"); + glad_glEvalCoord2d = (PFNGLEVALCOORD2DPROC)load("glEvalCoord2d"); + glad_glEvalCoord2dv = (PFNGLEVALCOORD2DVPROC)load("glEvalCoord2dv"); + glad_glEvalCoord2f = (PFNGLEVALCOORD2FPROC)load("glEvalCoord2f"); + glad_glEvalCoord2fv = (PFNGLEVALCOORD2FVPROC)load("glEvalCoord2fv"); + glad_glEvalMesh1 = (PFNGLEVALMESH1PROC)load("glEvalMesh1"); + glad_glEvalPoint1 = (PFNGLEVALPOINT1PROC)load("glEvalPoint1"); + glad_glEvalMesh2 = (PFNGLEVALMESH2PROC)load("glEvalMesh2"); + glad_glEvalPoint2 = (PFNGLEVALPOINT2PROC)load("glEvalPoint2"); + glad_glAlphaFunc = (PFNGLALPHAFUNCPROC)load("glAlphaFunc"); + glad_glPixelZoom = (PFNGLPIXELZOOMPROC)load("glPixelZoom"); + glad_glPixelTransferf = (PFNGLPIXELTRANSFERFPROC)load("glPixelTransferf"); + glad_glPixelTransferi = (PFNGLPIXELTRANSFERIPROC)load("glPixelTransferi"); + glad_glPixelMapfv = (PFNGLPIXELMAPFVPROC)load("glPixelMapfv"); + glad_glPixelMapuiv = (PFNGLPIXELMAPUIVPROC)load("glPixelMapuiv"); + glad_glPixelMapusv = (PFNGLPIXELMAPUSVPROC)load("glPixelMapusv"); + glad_glCopyPixels = (PFNGLCOPYPIXELSPROC)load("glCopyPixels"); + glad_glDrawPixels = (PFNGLDRAWPIXELSPROC)load("glDrawPixels"); + glad_glGetClipPlane = (PFNGLGETCLIPPLANEPROC)load("glGetClipPlane"); + glad_glGetLightfv = (PFNGLGETLIGHTFVPROC)load("glGetLightfv"); + glad_glGetLightiv = (PFNGLGETLIGHTIVPROC)load("glGetLightiv"); + glad_glGetMapdv = (PFNGLGETMAPDVPROC)load("glGetMapdv"); + glad_glGetMapfv = (PFNGLGETMAPFVPROC)load("glGetMapfv"); + glad_glGetMapiv = (PFNGLGETMAPIVPROC)load("glGetMapiv"); + glad_glGetMaterialfv = (PFNGLGETMATERIALFVPROC)load("glGetMaterialfv"); + glad_glGetMaterialiv = (PFNGLGETMATERIALIVPROC)load("glGetMaterialiv"); + glad_glGetPixelMapfv = (PFNGLGETPIXELMAPFVPROC)load("glGetPixelMapfv"); + glad_glGetPixelMapuiv = (PFNGLGETPIXELMAPUIVPROC)load("glGetPixelMapuiv"); + glad_glGetPixelMapusv = (PFNGLGETPIXELMAPUSVPROC)load("glGetPixelMapusv"); + glad_glGetPolygonStipple = (PFNGLGETPOLYGONSTIPPLEPROC)load("glGetPolygonStipple"); + glad_glGetTexEnvfv = (PFNGLGETTEXENVFVPROC)load("glGetTexEnvfv"); + glad_glGetTexEnviv = (PFNGLGETTEXENVIVPROC)load("glGetTexEnviv"); + glad_glGetTexGendv = (PFNGLGETTEXGENDVPROC)load("glGetTexGendv"); + glad_glGetTexGenfv = (PFNGLGETTEXGENFVPROC)load("glGetTexGenfv"); + glad_glGetTexGeniv = (PFNGLGETTEXGENIVPROC)load("glGetTexGeniv"); + glad_glIsList = (PFNGLISLISTPROC)load("glIsList"); + glad_glFrustum = (PFNGLFRUSTUMPROC)load("glFrustum"); + glad_glLoadIdentity = (PFNGLLOADIDENTITYPROC)load("glLoadIdentity"); + glad_glLoadMatrixf = (PFNGLLOADMATRIXFPROC)load("glLoadMatrixf"); + glad_glLoadMatrixd = (PFNGLLOADMATRIXDPROC)load("glLoadMatrixd"); + glad_glMatrixMode = (PFNGLMATRIXMODEPROC)load("glMatrixMode"); + glad_glMultMatrixf = (PFNGLMULTMATRIXFPROC)load("glMultMatrixf"); + glad_glMultMatrixd = (PFNGLMULTMATRIXDPROC)load("glMultMatrixd"); + glad_glOrtho = (PFNGLORTHOPROC)load("glOrtho"); + glad_glPopMatrix = (PFNGLPOPMATRIXPROC)load("glPopMatrix"); + glad_glPushMatrix = (PFNGLPUSHMATRIXPROC)load("glPushMatrix"); + glad_glRotated = (PFNGLROTATEDPROC)load("glRotated"); + glad_glRotatef = (PFNGLROTATEFPROC)load("glRotatef"); + glad_glScaled = (PFNGLSCALEDPROC)load("glScaled"); + glad_glScalef = (PFNGLSCALEFPROC)load("glScalef"); + glad_glTranslated = (PFNGLTRANSLATEDPROC)load("glTranslated"); + glad_glTranslatef = (PFNGLTRANSLATEFPROC)load("glTranslatef"); +} +static void load_GL_VERSION_1_1(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_1) return; + glad_glDrawArrays = (PFNGLDRAWARRAYSPROC)load("glDrawArrays"); + glad_glDrawElements = (PFNGLDRAWELEMENTSPROC)load("glDrawElements"); + glad_glGetPointerv = (PFNGLGETPOINTERVPROC)load("glGetPointerv"); + glad_glPolygonOffset = (PFNGLPOLYGONOFFSETPROC)load("glPolygonOffset"); + glad_glCopyTexImage1D = (PFNGLCOPYTEXIMAGE1DPROC)load("glCopyTexImage1D"); + glad_glCopyTexImage2D = (PFNGLCOPYTEXIMAGE2DPROC)load("glCopyTexImage2D"); + glad_glCopyTexSubImage1D = (PFNGLCOPYTEXSUBIMAGE1DPROC)load("glCopyTexSubImage1D"); + glad_glCopyTexSubImage2D = (PFNGLCOPYTEXSUBIMAGE2DPROC)load("glCopyTexSubImage2D"); + glad_glTexSubImage1D = (PFNGLTEXSUBIMAGE1DPROC)load("glTexSubImage1D"); + glad_glTexSubImage2D = (PFNGLTEXSUBIMAGE2DPROC)load("glTexSubImage2D"); + glad_glBindTexture = (PFNGLBINDTEXTUREPROC)load("glBindTexture"); + glad_glDeleteTextures = (PFNGLDELETETEXTURESPROC)load("glDeleteTextures"); + glad_glGenTextures = (PFNGLGENTEXTURESPROC)load("glGenTextures"); + glad_glIsTexture = (PFNGLISTEXTUREPROC)load("glIsTexture"); + glad_glArrayElement = (PFNGLARRAYELEMENTPROC)load("glArrayElement"); + glad_glColorPointer = (PFNGLCOLORPOINTERPROC)load("glColorPointer"); + glad_glDisableClientState = (PFNGLDISABLECLIENTSTATEPROC)load("glDisableClientState"); + glad_glEdgeFlagPointer = (PFNGLEDGEFLAGPOINTERPROC)load("glEdgeFlagPointer"); + glad_glEnableClientState = (PFNGLENABLECLIENTSTATEPROC)load("glEnableClientState"); + glad_glIndexPointer = (PFNGLINDEXPOINTERPROC)load("glIndexPointer"); + glad_glInterleavedArrays = (PFNGLINTERLEAVEDARRAYSPROC)load("glInterleavedArrays"); + glad_glNormalPointer = (PFNGLNORMALPOINTERPROC)load("glNormalPointer"); + glad_glTexCoordPointer = (PFNGLTEXCOORDPOINTERPROC)load("glTexCoordPointer"); + glad_glVertexPointer = (PFNGLVERTEXPOINTERPROC)load("glVertexPointer"); + glad_glAreTexturesResident = (PFNGLARETEXTURESRESIDENTPROC)load("glAreTexturesResident"); + glad_glPrioritizeTextures = (PFNGLPRIORITIZETEXTURESPROC)load("glPrioritizeTextures"); + glad_glIndexub = (PFNGLINDEXUBPROC)load("glIndexub"); + glad_glIndexubv = (PFNGLINDEXUBVPROC)load("glIndexubv"); + glad_glPopClientAttrib = (PFNGLPOPCLIENTATTRIBPROC)load("glPopClientAttrib"); + glad_glPushClientAttrib = (PFNGLPUSHCLIENTATTRIBPROC)load("glPushClientAttrib"); +} +static void load_GL_VERSION_1_2(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_2) return; + glad_glDrawRangeElements = (PFNGLDRAWRANGEELEMENTSPROC)load("glDrawRangeElements"); + glad_glTexImage3D = (PFNGLTEXIMAGE3DPROC)load("glTexImage3D"); + glad_glTexSubImage3D = (PFNGLTEXSUBIMAGE3DPROC)load("glTexSubImage3D"); + glad_glCopyTexSubImage3D = (PFNGLCOPYTEXSUBIMAGE3DPROC)load("glCopyTexSubImage3D"); +} +static void load_GL_VERSION_1_3(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_3) return; + glad_glActiveTexture = (PFNGLACTIVETEXTUREPROC)load("glActiveTexture"); + glad_glSampleCoverage = (PFNGLSAMPLECOVERAGEPROC)load("glSampleCoverage"); + glad_glCompressedTexImage3D = (PFNGLCOMPRESSEDTEXIMAGE3DPROC)load("glCompressedTexImage3D"); + glad_glCompressedTexImage2D = (PFNGLCOMPRESSEDTEXIMAGE2DPROC)load("glCompressedTexImage2D"); + glad_glCompressedTexImage1D = (PFNGLCOMPRESSEDTEXIMAGE1DPROC)load("glCompressedTexImage1D"); + glad_glCompressedTexSubImage3D = (PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC)load("glCompressedTexSubImage3D"); + glad_glCompressedTexSubImage2D = (PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC)load("glCompressedTexSubImage2D"); + glad_glCompressedTexSubImage1D = (PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC)load("glCompressedTexSubImage1D"); + glad_glGetCompressedTexImage = (PFNGLGETCOMPRESSEDTEXIMAGEPROC)load("glGetCompressedTexImage"); + glad_glClientActiveTexture = (PFNGLCLIENTACTIVETEXTUREPROC)load("glClientActiveTexture"); + glad_glMultiTexCoord1d = (PFNGLMULTITEXCOORD1DPROC)load("glMultiTexCoord1d"); + glad_glMultiTexCoord1dv = (PFNGLMULTITEXCOORD1DVPROC)load("glMultiTexCoord1dv"); + glad_glMultiTexCoord1f = (PFNGLMULTITEXCOORD1FPROC)load("glMultiTexCoord1f"); + glad_glMultiTexCoord1fv = (PFNGLMULTITEXCOORD1FVPROC)load("glMultiTexCoord1fv"); + glad_glMultiTexCoord1i = (PFNGLMULTITEXCOORD1IPROC)load("glMultiTexCoord1i"); + glad_glMultiTexCoord1iv = (PFNGLMULTITEXCOORD1IVPROC)load("glMultiTexCoord1iv"); + glad_glMultiTexCoord1s = (PFNGLMULTITEXCOORD1SPROC)load("glMultiTexCoord1s"); + glad_glMultiTexCoord1sv = (PFNGLMULTITEXCOORD1SVPROC)load("glMultiTexCoord1sv"); + glad_glMultiTexCoord2d = (PFNGLMULTITEXCOORD2DPROC)load("glMultiTexCoord2d"); + glad_glMultiTexCoord2dv = (PFNGLMULTITEXCOORD2DVPROC)load("glMultiTexCoord2dv"); + glad_glMultiTexCoord2f = (PFNGLMULTITEXCOORD2FPROC)load("glMultiTexCoord2f"); + glad_glMultiTexCoord2fv = (PFNGLMULTITEXCOORD2FVPROC)load("glMultiTexCoord2fv"); + glad_glMultiTexCoord2i = (PFNGLMULTITEXCOORD2IPROC)load("glMultiTexCoord2i"); + glad_glMultiTexCoord2iv = (PFNGLMULTITEXCOORD2IVPROC)load("glMultiTexCoord2iv"); + glad_glMultiTexCoord2s = (PFNGLMULTITEXCOORD2SPROC)load("glMultiTexCoord2s"); + glad_glMultiTexCoord2sv = (PFNGLMULTITEXCOORD2SVPROC)load("glMultiTexCoord2sv"); + glad_glMultiTexCoord3d = (PFNGLMULTITEXCOORD3DPROC)load("glMultiTexCoord3d"); + glad_glMultiTexCoord3dv = (PFNGLMULTITEXCOORD3DVPROC)load("glMultiTexCoord3dv"); + glad_glMultiTexCoord3f = (PFNGLMULTITEXCOORD3FPROC)load("glMultiTexCoord3f"); + glad_glMultiTexCoord3fv = (PFNGLMULTITEXCOORD3FVPROC)load("glMultiTexCoord3fv"); + glad_glMultiTexCoord3i = (PFNGLMULTITEXCOORD3IPROC)load("glMultiTexCoord3i"); + glad_glMultiTexCoord3iv = (PFNGLMULTITEXCOORD3IVPROC)load("glMultiTexCoord3iv"); + glad_glMultiTexCoord3s = (PFNGLMULTITEXCOORD3SPROC)load("glMultiTexCoord3s"); + glad_glMultiTexCoord3sv = (PFNGLMULTITEXCOORD3SVPROC)load("glMultiTexCoord3sv"); + glad_glMultiTexCoord4d = (PFNGLMULTITEXCOORD4DPROC)load("glMultiTexCoord4d"); + glad_glMultiTexCoord4dv = (PFNGLMULTITEXCOORD4DVPROC)load("glMultiTexCoord4dv"); + glad_glMultiTexCoord4f = (PFNGLMULTITEXCOORD4FPROC)load("glMultiTexCoord4f"); + glad_glMultiTexCoord4fv = (PFNGLMULTITEXCOORD4FVPROC)load("glMultiTexCoord4fv"); + glad_glMultiTexCoord4i = (PFNGLMULTITEXCOORD4IPROC)load("glMultiTexCoord4i"); + glad_glMultiTexCoord4iv = (PFNGLMULTITEXCOORD4IVPROC)load("glMultiTexCoord4iv"); + glad_glMultiTexCoord4s = (PFNGLMULTITEXCOORD4SPROC)load("glMultiTexCoord4s"); + glad_glMultiTexCoord4sv = (PFNGLMULTITEXCOORD4SVPROC)load("glMultiTexCoord4sv"); + glad_glLoadTransposeMatrixf = (PFNGLLOADTRANSPOSEMATRIXFPROC)load("glLoadTransposeMatrixf"); + glad_glLoadTransposeMatrixd = (PFNGLLOADTRANSPOSEMATRIXDPROC)load("glLoadTransposeMatrixd"); + glad_glMultTransposeMatrixf = (PFNGLMULTTRANSPOSEMATRIXFPROC)load("glMultTransposeMatrixf"); + glad_glMultTransposeMatrixd = (PFNGLMULTTRANSPOSEMATRIXDPROC)load("glMultTransposeMatrixd"); +} +static void load_GL_VERSION_1_4(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_4) return; + glad_glBlendFuncSeparate = (PFNGLBLENDFUNCSEPARATEPROC)load("glBlendFuncSeparate"); + glad_glMultiDrawArrays = (PFNGLMULTIDRAWARRAYSPROC)load("glMultiDrawArrays"); + glad_glMultiDrawElements = (PFNGLMULTIDRAWELEMENTSPROC)load("glMultiDrawElements"); + glad_glPointParameterf = (PFNGLPOINTPARAMETERFPROC)load("glPointParameterf"); + glad_glPointParameterfv = (PFNGLPOINTPARAMETERFVPROC)load("glPointParameterfv"); + glad_glPointParameteri = (PFNGLPOINTPARAMETERIPROC)load("glPointParameteri"); + glad_glPointParameteriv = (PFNGLPOINTPARAMETERIVPROC)load("glPointParameteriv"); + glad_glFogCoordf = (PFNGLFOGCOORDFPROC)load("glFogCoordf"); + glad_glFogCoordfv = (PFNGLFOGCOORDFVPROC)load("glFogCoordfv"); + glad_glFogCoordd = (PFNGLFOGCOORDDPROC)load("glFogCoordd"); + glad_glFogCoorddv = (PFNGLFOGCOORDDVPROC)load("glFogCoorddv"); + glad_glFogCoordPointer = (PFNGLFOGCOORDPOINTERPROC)load("glFogCoordPointer"); + glad_glSecondaryColor3b = (PFNGLSECONDARYCOLOR3BPROC)load("glSecondaryColor3b"); + glad_glSecondaryColor3bv = (PFNGLSECONDARYCOLOR3BVPROC)load("glSecondaryColor3bv"); + glad_glSecondaryColor3d = (PFNGLSECONDARYCOLOR3DPROC)load("glSecondaryColor3d"); + glad_glSecondaryColor3dv = (PFNGLSECONDARYCOLOR3DVPROC)load("glSecondaryColor3dv"); + glad_glSecondaryColor3f = (PFNGLSECONDARYCOLOR3FPROC)load("glSecondaryColor3f"); + glad_glSecondaryColor3fv = (PFNGLSECONDARYCOLOR3FVPROC)load("glSecondaryColor3fv"); + glad_glSecondaryColor3i = (PFNGLSECONDARYCOLOR3IPROC)load("glSecondaryColor3i"); + glad_glSecondaryColor3iv = (PFNGLSECONDARYCOLOR3IVPROC)load("glSecondaryColor3iv"); + glad_glSecondaryColor3s = (PFNGLSECONDARYCOLOR3SPROC)load("glSecondaryColor3s"); + glad_glSecondaryColor3sv = (PFNGLSECONDARYCOLOR3SVPROC)load("glSecondaryColor3sv"); + glad_glSecondaryColor3ub = (PFNGLSECONDARYCOLOR3UBPROC)load("glSecondaryColor3ub"); + glad_glSecondaryColor3ubv = (PFNGLSECONDARYCOLOR3UBVPROC)load("glSecondaryColor3ubv"); + glad_glSecondaryColor3ui = (PFNGLSECONDARYCOLOR3UIPROC)load("glSecondaryColor3ui"); + glad_glSecondaryColor3uiv = (PFNGLSECONDARYCOLOR3UIVPROC)load("glSecondaryColor3uiv"); + glad_glSecondaryColor3us = (PFNGLSECONDARYCOLOR3USPROC)load("glSecondaryColor3us"); + glad_glSecondaryColor3usv = (PFNGLSECONDARYCOLOR3USVPROC)load("glSecondaryColor3usv"); + glad_glSecondaryColorPointer = (PFNGLSECONDARYCOLORPOINTERPROC)load("glSecondaryColorPointer"); + glad_glWindowPos2d = (PFNGLWINDOWPOS2DPROC)load("glWindowPos2d"); + glad_glWindowPos2dv = (PFNGLWINDOWPOS2DVPROC)load("glWindowPos2dv"); + glad_glWindowPos2f = (PFNGLWINDOWPOS2FPROC)load("glWindowPos2f"); + glad_glWindowPos2fv = (PFNGLWINDOWPOS2FVPROC)load("glWindowPos2fv"); + glad_glWindowPos2i = (PFNGLWINDOWPOS2IPROC)load("glWindowPos2i"); + glad_glWindowPos2iv = (PFNGLWINDOWPOS2IVPROC)load("glWindowPos2iv"); + glad_glWindowPos2s = (PFNGLWINDOWPOS2SPROC)load("glWindowPos2s"); + glad_glWindowPos2sv = (PFNGLWINDOWPOS2SVPROC)load("glWindowPos2sv"); + glad_glWindowPos3d = (PFNGLWINDOWPOS3DPROC)load("glWindowPos3d"); + glad_glWindowPos3dv = (PFNGLWINDOWPOS3DVPROC)load("glWindowPos3dv"); + glad_glWindowPos3f = (PFNGLWINDOWPOS3FPROC)load("glWindowPos3f"); + glad_glWindowPos3fv = (PFNGLWINDOWPOS3FVPROC)load("glWindowPos3fv"); + glad_glWindowPos3i = (PFNGLWINDOWPOS3IPROC)load("glWindowPos3i"); + glad_glWindowPos3iv = (PFNGLWINDOWPOS3IVPROC)load("glWindowPos3iv"); + glad_glWindowPos3s = (PFNGLWINDOWPOS3SPROC)load("glWindowPos3s"); + glad_glWindowPos3sv = (PFNGLWINDOWPOS3SVPROC)load("glWindowPos3sv"); + glad_glBlendColor = (PFNGLBLENDCOLORPROC)load("glBlendColor"); + glad_glBlendEquation = (PFNGLBLENDEQUATIONPROC)load("glBlendEquation"); +} +static void load_GL_VERSION_1_5(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_5) return; + glad_glGenQueries = (PFNGLGENQUERIESPROC)load("glGenQueries"); + glad_glDeleteQueries = (PFNGLDELETEQUERIESPROC)load("glDeleteQueries"); + glad_glIsQuery = (PFNGLISQUERYPROC)load("glIsQuery"); + glad_glBeginQuery = (PFNGLBEGINQUERYPROC)load("glBeginQuery"); + glad_glEndQuery = (PFNGLENDQUERYPROC)load("glEndQuery"); + glad_glGetQueryiv = (PFNGLGETQUERYIVPROC)load("glGetQueryiv"); + glad_glGetQueryObjectiv = (PFNGLGETQUERYOBJECTIVPROC)load("glGetQueryObjectiv"); + glad_glGetQueryObjectuiv = (PFNGLGETQUERYOBJECTUIVPROC)load("glGetQueryObjectuiv"); + glad_glBindBuffer = (PFNGLBINDBUFFERPROC)load("glBindBuffer"); + glad_glDeleteBuffers = (PFNGLDELETEBUFFERSPROC)load("glDeleteBuffers"); + glad_glGenBuffers = (PFNGLGENBUFFERSPROC)load("glGenBuffers"); + glad_glIsBuffer = (PFNGLISBUFFERPROC)load("glIsBuffer"); + glad_glBufferData = (PFNGLBUFFERDATAPROC)load("glBufferData"); + glad_glBufferSubData = (PFNGLBUFFERSUBDATAPROC)load("glBufferSubData"); + glad_glGetBufferSubData = (PFNGLGETBUFFERSUBDATAPROC)load("glGetBufferSubData"); + glad_glMapBuffer = (PFNGLMAPBUFFERPROC)load("glMapBuffer"); + glad_glUnmapBuffer = (PFNGLUNMAPBUFFERPROC)load("glUnmapBuffer"); + glad_glGetBufferParameteriv = (PFNGLGETBUFFERPARAMETERIVPROC)load("glGetBufferParameteriv"); + glad_glGetBufferPointerv = (PFNGLGETBUFFERPOINTERVPROC)load("glGetBufferPointerv"); +} +static void load_GL_VERSION_2_0(GLADloadproc load) { + if(!GLAD_GL_VERSION_2_0) return; + glad_glBlendEquationSeparate = (PFNGLBLENDEQUATIONSEPARATEPROC)load("glBlendEquationSeparate"); + glad_glDrawBuffers = (PFNGLDRAWBUFFERSPROC)load("glDrawBuffers"); + glad_glStencilOpSeparate = (PFNGLSTENCILOPSEPARATEPROC)load("glStencilOpSeparate"); + glad_glStencilFuncSeparate = (PFNGLSTENCILFUNCSEPARATEPROC)load("glStencilFuncSeparate"); + glad_glStencilMaskSeparate = (PFNGLSTENCILMASKSEPARATEPROC)load("glStencilMaskSeparate"); + glad_glAttachShader = (PFNGLATTACHSHADERPROC)load("glAttachShader"); + glad_glBindAttribLocation = (PFNGLBINDATTRIBLOCATIONPROC)load("glBindAttribLocation"); + glad_glCompileShader = (PFNGLCOMPILESHADERPROC)load("glCompileShader"); + glad_glCreateProgram = (PFNGLCREATEPROGRAMPROC)load("glCreateProgram"); + glad_glCreateShader = (PFNGLCREATESHADERPROC)load("glCreateShader"); + glad_glDeleteProgram = (PFNGLDELETEPROGRAMPROC)load("glDeleteProgram"); + glad_glDeleteShader = (PFNGLDELETESHADERPROC)load("glDeleteShader"); + glad_glDetachShader = (PFNGLDETACHSHADERPROC)load("glDetachShader"); + glad_glDisableVertexAttribArray = (PFNGLDISABLEVERTEXATTRIBARRAYPROC)load("glDisableVertexAttribArray"); + glad_glEnableVertexAttribArray = (PFNGLENABLEVERTEXATTRIBARRAYPROC)load("glEnableVertexAttribArray"); + glad_glGetActiveAttrib = (PFNGLGETACTIVEATTRIBPROC)load("glGetActiveAttrib"); + glad_glGetActiveUniform = (PFNGLGETACTIVEUNIFORMPROC)load("glGetActiveUniform"); + glad_glGetAttachedShaders = (PFNGLGETATTACHEDSHADERSPROC)load("glGetAttachedShaders"); + glad_glGetAttribLocation = (PFNGLGETATTRIBLOCATIONPROC)load("glGetAttribLocation"); + glad_glGetProgramiv = (PFNGLGETPROGRAMIVPROC)load("glGetProgramiv"); + glad_glGetProgramInfoLog = (PFNGLGETPROGRAMINFOLOGPROC)load("glGetProgramInfoLog"); + glad_glGetShaderiv = (PFNGLGETSHADERIVPROC)load("glGetShaderiv"); + glad_glGetShaderInfoLog = (PFNGLGETSHADERINFOLOGPROC)load("glGetShaderInfoLog"); + glad_glGetShaderSource = (PFNGLGETSHADERSOURCEPROC)load("glGetShaderSource"); + glad_glGetUniformLocation = (PFNGLGETUNIFORMLOCATIONPROC)load("glGetUniformLocation"); + glad_glGetUniformfv = (PFNGLGETUNIFORMFVPROC)load("glGetUniformfv"); + glad_glGetUniformiv = (PFNGLGETUNIFORMIVPROC)load("glGetUniformiv"); + glad_glGetVertexAttribdv = (PFNGLGETVERTEXATTRIBDVPROC)load("glGetVertexAttribdv"); + glad_glGetVertexAttribfv = (PFNGLGETVERTEXATTRIBFVPROC)load("glGetVertexAttribfv"); + glad_glGetVertexAttribiv = (PFNGLGETVERTEXATTRIBIVPROC)load("glGetVertexAttribiv"); + glad_glGetVertexAttribPointerv = (PFNGLGETVERTEXATTRIBPOINTERVPROC)load("glGetVertexAttribPointerv"); + glad_glIsProgram = (PFNGLISPROGRAMPROC)load("glIsProgram"); + glad_glIsShader = (PFNGLISSHADERPROC)load("glIsShader"); + glad_glLinkProgram = (PFNGLLINKPROGRAMPROC)load("glLinkProgram"); + glad_glShaderSource = (PFNGLSHADERSOURCEPROC)load("glShaderSource"); + glad_glUseProgram = (PFNGLUSEPROGRAMPROC)load("glUseProgram"); + glad_glUniform1f = (PFNGLUNIFORM1FPROC)load("glUniform1f"); + glad_glUniform2f = (PFNGLUNIFORM2FPROC)load("glUniform2f"); + glad_glUniform3f = (PFNGLUNIFORM3FPROC)load("glUniform3f"); + glad_glUniform4f = (PFNGLUNIFORM4FPROC)load("glUniform4f"); + glad_glUniform1i = (PFNGLUNIFORM1IPROC)load("glUniform1i"); + glad_glUniform2i = (PFNGLUNIFORM2IPROC)load("glUniform2i"); + glad_glUniform3i = (PFNGLUNIFORM3IPROC)load("glUniform3i"); + glad_glUniform4i = (PFNGLUNIFORM4IPROC)load("glUniform4i"); + glad_glUniform1fv = (PFNGLUNIFORM1FVPROC)load("glUniform1fv"); + glad_glUniform2fv = (PFNGLUNIFORM2FVPROC)load("glUniform2fv"); + glad_glUniform3fv = (PFNGLUNIFORM3FVPROC)load("glUniform3fv"); + glad_glUniform4fv = (PFNGLUNIFORM4FVPROC)load("glUniform4fv"); + glad_glUniform1iv = (PFNGLUNIFORM1IVPROC)load("glUniform1iv"); + glad_glUniform2iv = (PFNGLUNIFORM2IVPROC)load("glUniform2iv"); + glad_glUniform3iv = (PFNGLUNIFORM3IVPROC)load("glUniform3iv"); + glad_glUniform4iv = (PFNGLUNIFORM4IVPROC)load("glUniform4iv"); + glad_glUniformMatrix2fv = (PFNGLUNIFORMMATRIX2FVPROC)load("glUniformMatrix2fv"); + glad_glUniformMatrix3fv = (PFNGLUNIFORMMATRIX3FVPROC)load("glUniformMatrix3fv"); + glad_glUniformMatrix4fv = (PFNGLUNIFORMMATRIX4FVPROC)load("glUniformMatrix4fv"); + glad_glValidateProgram = (PFNGLVALIDATEPROGRAMPROC)load("glValidateProgram"); + glad_glVertexAttrib1d = (PFNGLVERTEXATTRIB1DPROC)load("glVertexAttrib1d"); + glad_glVertexAttrib1dv = (PFNGLVERTEXATTRIB1DVPROC)load("glVertexAttrib1dv"); + glad_glVertexAttrib1f = (PFNGLVERTEXATTRIB1FPROC)load("glVertexAttrib1f"); + glad_glVertexAttrib1fv = (PFNGLVERTEXATTRIB1FVPROC)load("glVertexAttrib1fv"); + glad_glVertexAttrib1s = (PFNGLVERTEXATTRIB1SPROC)load("glVertexAttrib1s"); + glad_glVertexAttrib1sv = (PFNGLVERTEXATTRIB1SVPROC)load("glVertexAttrib1sv"); + glad_glVertexAttrib2d = (PFNGLVERTEXATTRIB2DPROC)load("glVertexAttrib2d"); + glad_glVertexAttrib2dv = (PFNGLVERTEXATTRIB2DVPROC)load("glVertexAttrib2dv"); + glad_glVertexAttrib2f = (PFNGLVERTEXATTRIB2FPROC)load("glVertexAttrib2f"); + glad_glVertexAttrib2fv = (PFNGLVERTEXATTRIB2FVPROC)load("glVertexAttrib2fv"); + glad_glVertexAttrib2s = (PFNGLVERTEXATTRIB2SPROC)load("glVertexAttrib2s"); + glad_glVertexAttrib2sv = (PFNGLVERTEXATTRIB2SVPROC)load("glVertexAttrib2sv"); + glad_glVertexAttrib3d = (PFNGLVERTEXATTRIB3DPROC)load("glVertexAttrib3d"); + glad_glVertexAttrib3dv = (PFNGLVERTEXATTRIB3DVPROC)load("glVertexAttrib3dv"); + glad_glVertexAttrib3f = (PFNGLVERTEXATTRIB3FPROC)load("glVertexAttrib3f"); + glad_glVertexAttrib3fv = (PFNGLVERTEXATTRIB3FVPROC)load("glVertexAttrib3fv"); + glad_glVertexAttrib3s = (PFNGLVERTEXATTRIB3SPROC)load("glVertexAttrib3s"); + glad_glVertexAttrib3sv = (PFNGLVERTEXATTRIB3SVPROC)load("glVertexAttrib3sv"); + glad_glVertexAttrib4Nbv = (PFNGLVERTEXATTRIB4NBVPROC)load("glVertexAttrib4Nbv"); + glad_glVertexAttrib4Niv = (PFNGLVERTEXATTRIB4NIVPROC)load("glVertexAttrib4Niv"); + glad_glVertexAttrib4Nsv = (PFNGLVERTEXATTRIB4NSVPROC)load("glVertexAttrib4Nsv"); + glad_glVertexAttrib4Nub = (PFNGLVERTEXATTRIB4NUBPROC)load("glVertexAttrib4Nub"); + glad_glVertexAttrib4Nubv = (PFNGLVERTEXATTRIB4NUBVPROC)load("glVertexAttrib4Nubv"); + glad_glVertexAttrib4Nuiv = (PFNGLVERTEXATTRIB4NUIVPROC)load("glVertexAttrib4Nuiv"); + glad_glVertexAttrib4Nusv = (PFNGLVERTEXATTRIB4NUSVPROC)load("glVertexAttrib4Nusv"); + glad_glVertexAttrib4bv = (PFNGLVERTEXATTRIB4BVPROC)load("glVertexAttrib4bv"); + glad_glVertexAttrib4d = (PFNGLVERTEXATTRIB4DPROC)load("glVertexAttrib4d"); + glad_glVertexAttrib4dv = (PFNGLVERTEXATTRIB4DVPROC)load("glVertexAttrib4dv"); + glad_glVertexAttrib4f = (PFNGLVERTEXATTRIB4FPROC)load("glVertexAttrib4f"); + glad_glVertexAttrib4fv = (PFNGLVERTEXATTRIB4FVPROC)load("glVertexAttrib4fv"); + glad_glVertexAttrib4iv = (PFNGLVERTEXATTRIB4IVPROC)load("glVertexAttrib4iv"); + glad_glVertexAttrib4s = (PFNGLVERTEXATTRIB4SPROC)load("glVertexAttrib4s"); + glad_glVertexAttrib4sv = (PFNGLVERTEXATTRIB4SVPROC)load("glVertexAttrib4sv"); + glad_glVertexAttrib4ubv = (PFNGLVERTEXATTRIB4UBVPROC)load("glVertexAttrib4ubv"); + glad_glVertexAttrib4uiv = (PFNGLVERTEXATTRIB4UIVPROC)load("glVertexAttrib4uiv"); + glad_glVertexAttrib4usv = (PFNGLVERTEXATTRIB4USVPROC)load("glVertexAttrib4usv"); + glad_glVertexAttribPointer = (PFNGLVERTEXATTRIBPOINTERPROC)load("glVertexAttribPointer"); +} +static void load_GL_VERSION_2_1(GLADloadproc load) { + if(!GLAD_GL_VERSION_2_1) return; + glad_glUniformMatrix2x3fv = (PFNGLUNIFORMMATRIX2X3FVPROC)load("glUniformMatrix2x3fv"); + glad_glUniformMatrix3x2fv = (PFNGLUNIFORMMATRIX3X2FVPROC)load("glUniformMatrix3x2fv"); + glad_glUniformMatrix2x4fv = (PFNGLUNIFORMMATRIX2X4FVPROC)load("glUniformMatrix2x4fv"); + glad_glUniformMatrix4x2fv = (PFNGLUNIFORMMATRIX4X2FVPROC)load("glUniformMatrix4x2fv"); + glad_glUniformMatrix3x4fv = (PFNGLUNIFORMMATRIX3X4FVPROC)load("glUniformMatrix3x4fv"); + glad_glUniformMatrix4x3fv = (PFNGLUNIFORMMATRIX4X3FVPROC)load("glUniformMatrix4x3fv"); +} +static int find_extensionsGL(void) { + if (!get_exts()) return 0; + (void)&has_ext; + free_exts(); + return 1; +} + +static void find_coreGL(void) { + + /* Thank you @elmindreda + * https://github.com/elmindreda/greg/blob/master/templates/greg.c.in#L176 + * https://github.com/glfw/glfw/blob/master/src/context.c#L36 + */ + int i, major, minor; + + const char* version; + const char* prefixes[] = { + "OpenGL ES-CM ", + "OpenGL ES-CL ", + "OpenGL ES ", + NULL + }; + + version = (const char*) glGetString(GL_VERSION); + if (!version) return; + + for (i = 0; prefixes[i]; i++) { + const size_t length = strlen(prefixes[i]); + if (strncmp(version, prefixes[i], length) == 0) { + version += length; + break; + } + } + +/* PR #18 */ +#ifdef _MSC_VER + sscanf_s(version, "%d.%d", &major, &minor); +#else + sscanf(version, "%d.%d", &major, &minor); +#endif + + GLVersion.major = major; GLVersion.minor = minor; + max_loaded_major = major; max_loaded_minor = minor; + GLAD_GL_VERSION_1_0 = (major == 1 && minor >= 0) || major > 1; + GLAD_GL_VERSION_1_1 = (major == 1 && minor >= 1) || major > 1; + GLAD_GL_VERSION_1_2 = (major == 1 && minor >= 2) || major > 1; + GLAD_GL_VERSION_1_3 = (major == 1 && minor >= 3) || major > 1; + GLAD_GL_VERSION_1_4 = (major == 1 && minor >= 4) || major > 1; + GLAD_GL_VERSION_1_5 = (major == 1 && minor >= 5) || major > 1; + GLAD_GL_VERSION_2_0 = (major == 2 && minor >= 0) || major > 2; + GLAD_GL_VERSION_2_1 = (major == 2 && minor >= 1) || major > 2; + if (GLVersion.major > 2 || (GLVersion.major >= 2 && GLVersion.minor >= 1)) { + max_loaded_major = 2; + max_loaded_minor = 1; + } +} + +int gladLoadGLLoader(GLADloadproc load) { + GLVersion.major = 0; GLVersion.minor = 0; + glGetString = (PFNGLGETSTRINGPROC)load("glGetString"); + if(glGetString == NULL) return 0; + if(glGetString(GL_VERSION) == NULL) return 0; + find_coreGL(); + load_GL_VERSION_1_0(load); + load_GL_VERSION_1_1(load); + load_GL_VERSION_1_2(load); + load_GL_VERSION_1_3(load); + load_GL_VERSION_1_4(load); + load_GL_VERSION_1_5(load); + load_GL_VERSION_2_0(load); + load_GL_VERSION_2_1(load); + + if (!find_extensionsGL()) return 0; + return GLVersion.major != 0 || GLVersion.minor != 0; +} + diff --git a/src/main.c b/src/main.c new file mode 100644 index 0000000..38ba7ac --- /dev/null +++ b/src/main.c @@ -0,0 +1,314 @@ +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +void framebuffer_size_callback(GLFWwindow* window, int width, int height) +{ + glViewport(0, 0, width, height); +} + +const char *vertexShaderSource = R"( +#version 120 + +attribute vec2 position; + +varying vec2 texcoord; + +void main() +{ + gl_Position = vec4(position, 0.0, 1.0); + + vec2 tex = position * vec2(0.5) + vec2(0.5); + + texcoord = vec2(tex.x * 400 / 512, + (1.0 - tex.y) * 300 / 512); +} + )" + ; + +const char *fragmentShaderSource = R"( +#version 120 + +uniform float fade_factor; +uniform sampler2D textures[2]; + +varying vec2 texcoord; + +void main() +{ + gl_FragColor = mix(texture2D(textures[0], texcoord), + texture2D(textures[1], texcoord), + fade_factor + ); +} + +)" +; + +unsigned int compile_shaders() +{ + unsigned int vertexShader; + vertexShader = glCreateShader(GL_VERTEX_SHADER); + glShaderSource(vertexShader, 1, &vertexShaderSource, NULL); + glCompileShader(vertexShader); + { + int success; + char infoLog[512]; + glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &success); + if(!success) { + glGetShaderInfoLog(vertexShader, 512, NULL, infoLog); + printf("vertex shader compile failed:\n%s\n", infoLog); + } + } + + unsigned int fragmentShader; + fragmentShader = glCreateShader(GL_FRAGMENT_SHADER); + glShaderSource(fragmentShader, 1, &fragmentShaderSource, NULL); + glCompileShader(fragmentShader); + { + int success; + char infoLog[512]; + glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &success); + if(!success) { + glGetShaderInfoLog(fragmentShader, 512, NULL, infoLog); + printf("fragment shader compile failed:\n%s\n", infoLog); + } + } + + unsigned int shaderProgram; + shaderProgram = glCreateProgram(); + + glAttachShader(shaderProgram, vertexShader); + glAttachShader(shaderProgram, fragmentShader); + glLinkProgram(shaderProgram); + + { + int success; + char infoLog[512]; + glGetProgramiv(shaderProgram, GL_LINK_STATUS, &success); + if(!success) { + glGetProgramInfoLog(shaderProgram, 512, NULL, infoLog); + printf("program link failed:\n%s\n", infoLog); + } + } + + glDeleteShader(vertexShader); + glDeleteShader(fragmentShader); + + return shaderProgram; +} + +static int make_buffer(unsigned int target, + const void * data, + size_t size) +{ + unsigned int buffer; + glGenBuffers(1, &buffer); + glBindBuffer(target, buffer); + glBufferData(target, size, data, GL_STATIC_DRAW); + return buffer; +} + +static const float vertex_buffer_data[] = { + -1.0f, -1.0f, + 1.0f, -1.0f, + -1.0f, 1.0f, + 1.0f, 1.0f +}; + +static const unsigned short element_buffer_data[] = { + 0, 1, 2, 3 +}; + +static void * read_file(const char * filename) +{ + int fd = open(filename, O_RDONLY); + if (fd == -1) { + fprintf(stderr, "open(%s): %s\n", filename, strerror(errno)); + return NULL; + } + + off_t size = lseek(fd, 0, SEEK_END); + if (size == (off_t)-1) { + fprintf(stderr, "lseek(%s, SEEK_END): %s\n", filename, strerror(errno)); + return NULL; + } + + off_t start = lseek(fd, 0, SEEK_SET); + if (start == (off_t)-1) { + fprintf(stderr, "lseek(%s, SEEK_SET): %s\n", filename, strerror(errno)); + return NULL; + } + + void * buf = malloc(size); + + ssize_t read_size = read(fd, buf, size); + if (read_size == -1) { + fprintf(stderr, "read(%s): %s\n", filename, strerror(errno)); + return NULL; + } + + return buf; +} + +static unsigned int make_texture(const char * filename) +{ + unsigned int texture; + int width = 512; + int height = 512; + + void * pixels = read_file(filename); + if (!pixels) + return 0; + + glGenTextures(1, &texture); + glBindTexture(GL_TEXTURE_2D, texture); + + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); + + glTexImage2D(GL_TEXTURE_2D, 0, + GL_RGBA8, + width, height, 0, + GL_RGBA, GL_UNSIGNED_BYTE, + pixels); + free(pixels); + return texture; +} + +struct location { + struct { + unsigned int fade_factor; + unsigned int textures[2]; + } uniform; + struct { + unsigned int position; + } attrib; +}; + +int main() +{ + glfwInit(); + glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 2); + glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 1); + //glfwWindowHint(GLFW_OPENGL_DEBUG_CONTEXT, GLFW_TRUE); + + GLFWwindow* window = glfwCreateWindow(800, 600, "LearnOpenGL", NULL, NULL); + if (window == NULL) { + const char* description; + glfwGetError(&description); + printf("Failed to create GLFW window: %s\n", description); + glfwTerminate(); + return -1; + } + glfwMakeContextCurrent(window); + + if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) { + printf("Failed to initialize GLAD\n"); + return -1; + } + + glViewport(0, 0, 800, 600); + glfwSetFramebufferSizeCallback(window, framebuffer_size_callback); + + unsigned int vertex_buffer = make_buffer(GL_ARRAY_BUFFER, + vertex_buffer_data, + (sizeof (vertex_buffer_data))); + + unsigned int element_buffer = make_buffer(GL_ARRAY_BUFFER, + element_buffer_data, + (sizeof (element_buffer_data))); + + unsigned int texture_0 = make_texture("texture/gl2-hello-1.data"); + unsigned int texture_1 = make_texture("texture/gl2-hello-2.data"); + + unsigned int shaderProgram = compile_shaders(); + + struct location location; + + location.uniform.fade_factor = glGetUniformLocation(shaderProgram, "fade_factor"); + location.uniform.textures[0] = glGetUniformLocation(shaderProgram, "textures[0]"); + location.uniform.textures[1] = glGetUniformLocation(shaderProgram, "textures[1]"); + + printf("uniforms:\n fade_factor: %u\n textures_0: %u\n textures_1: %u\n", + location.uniform.fade_factor, + location.uniform.textures[0], + location.uniform.textures[1]); + + location.attrib.position = glGetAttribLocation(shaderProgram, "position"); + printf("attributes:\n position %u\n", + location.attrib.position); + + float fade_factor = 0; + + struct timespec last; + struct timespec cur; + + clock_gettime(CLOCK_MONOTONIC, &last); + + while(!glfwWindowShouldClose(window)) { + if(glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS) + glfwSetWindowShouldClose(window, true); + + glClearColor(1.0f, 1.0f, 1.0f, 1.0f); + glClear(GL_COLOR_BUFFER_BIT); + + // + // render + // + glUseProgram(shaderProgram); + glUniform1f(location.uniform.fade_factor, fade_factor); + + glActiveTexture(GL_TEXTURE0); + glBindTexture(GL_TEXTURE_2D, texture_0); + glUniform1i(location.uniform.textures[0], 0); + + glActiveTexture(GL_TEXTURE1); + glBindTexture(GL_TEXTURE_2D, texture_1); + glUniform1i(location.uniform.textures[1], 1); + + glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer); + glVertexAttribPointer(location.attrib.position, + 2, + GL_FLOAT, + GL_FALSE, + (sizeof (float)) * 2, + (void*)0 + ); + glEnableVertexAttribArray(location.attrib.position); + + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, element_buffer); + glDrawElements(GL_TRIANGLE_STRIP, + 4, + GL_UNSIGNED_SHORT, + (void*)0 + ); + + glDisableVertexAttribArray(location.attrib.position); + + glfwSwapBuffers(window); + glfwPollEvents(); + + clock_gettime(CLOCK_MONOTONIC, &cur); + uint64_t last_msec = (last.tv_sec * 1000) + (last.tv_nsec * 1e-06); + uint64_t cur_msec = (cur.tv_sec * 1000) + (cur.tv_nsec * 1e-06); + uint64_t dt = cur_msec - last_msec; + fade_factor = sin(dt * 0.001f) * 0.5 + 0.5; + + //last = cur; + } + + glfwTerminate(); + + return 0; +} diff --git a/texture/gl2-hello-1.data b/texture/gl2-hello-1.data new file mode 100644 index 0000000000000000000000000000000000000000..ae5a309dc2a6fb0e7cca5170238382691b0b91c0 GIT binary patch literal 1048576 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 z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7 z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+ z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7 z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+ z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ tfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfWZ6&{y$M(^ZNh* literal 0 HcmV?d00001 diff --git a/texture/gl2-hello-2.data b/texture/gl2-hello-2.data new file mode 100644 index 0000000000000000000000000000000000000000..20d5b8b96794ee85294616e37bd723578e992604 GIT binary patch literal 1048576 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 F{{uBV2OR(a literal 0 HcmV?d00001