add glad

Engine/lib/glad/include/KHR/khrplatform.h

@@ -0,0 +1,285 @@
+#ifndef __khrplatform_h_
+#define __khrplatform_h_
+
+/*
+** Copyright (c) 2008-2009 The Khronos Group Inc.
+**
+** Permission is hereby granted, free of charge, to any person obtaining a
+** copy of this software and/or associated documentation files (the
+** "Materials"), to deal in the Materials without restriction, including
+** without limitation the rights to use, copy, modify, merge, publish,
+** distribute, sublicense, and/or sell copies of the Materials, and to
+** permit persons to whom the Materials are furnished to do so, subject to
+** the following conditions:
+**
+** The above copyright notice and this permission notice shall be included
+** in all copies or substantial portions of the Materials.
+**
+** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
+*/
+
+/* Khronos platform-specific types and definitions.
+ *
+ * $Revision: 32517 $ on $Date: 2016-03-11 02:41:19 -0800 (Fri, 11 Mar 2016) $
+ *
+ * Adopters may modify this file to suit their platform. Adopters are
+ * encouraged to submit platform specific modifications to the Khronos
+ * group so that they can be included in future versions of this file.
+ * Please submit changes by sending them to the public Khronos Bugzilla
+ * (http://khronos.org/bugzilla) by filing a bug against product
+ * "Khronos (general)" component "Registry".
+ *
+ * A predefined template which fills in some of the bug fields can be
+ * reached using http://tinyurl.com/khrplatform-h-bugreport, but you
+ * must create a Bugzilla login first.
+ *
+ *
+ * See the Implementer's Guidelines for information about where this file
+ * should be located on your system and for more details of its use:
+ *    http://www.khronos.org/registry/implementers_guide.pdf
+ *
+ * This file should be included as
+ *        #include <KHR/khrplatform.h>
+ * by Khronos client API header files that use its types and defines.
+ *
+ * The types in khrplatform.h should only be used to define API-specific types.
+ *
+ * Types defined in khrplatform.h:
+ *    khronos_int8_t              signed   8  bit
+ *    khronos_uint8_t             unsigned 8  bit
+ *    khronos_int16_t             signed   16 bit
+ *    khronos_uint16_t            unsigned 16 bit
+ *    khronos_int32_t             signed   32 bit
+ *    khronos_uint32_t            unsigned 32 bit
+ *    khronos_int64_t             signed   64 bit
+ *    khronos_uint64_t            unsigned 64 bit
+ *    khronos_intptr_t            signed   same number of bits as a pointer
+ *    khronos_uintptr_t           unsigned same number of bits as a pointer
+ *    khronos_ssize_t             signed   size
+ *    khronos_usize_t             unsigned size
+ *    khronos_float_t             signed   32 bit floating point
+ *    khronos_time_ns_t           unsigned 64 bit time in nanoseconds
+ *    khronos_utime_nanoseconds_t unsigned time interval or absolute time in
+ *                                         nanoseconds
+ *    khronos_stime_nanoseconds_t signed time interval in nanoseconds
+ *    khronos_boolean_enum_t      enumerated boolean type. This should
+ *      only be used as a base type when a client API's boolean type is
+ *      an enum. Client APIs which use an integer or other type for
+ *      booleans cannot use this as the base type for their boolean.
+ *
+ * Tokens defined in khrplatform.h:
+ *
+ *    KHRONOS_FALSE, KHRONOS_TRUE Enumerated boolean false/true values.
+ *
+ *    KHRONOS_SUPPORT_INT64 is 1 if 64 bit integers are supported; otherwise 0.
+ *    KHRONOS_SUPPORT_FLOAT is 1 if floats are supported; otherwise 0.
+ *
+ * Calling convention macros defined in this file:
+ *    KHRONOS_APICALL
+ *    KHRONOS_APIENTRY
+ *    KHRONOS_APIATTRIBUTES
+ *
+ * These may be used in function prototypes as:
+ *
+ *      KHRONOS_APICALL void KHRONOS_APIENTRY funcname(
+ *                                  int arg1,
+ *                                  int arg2) KHRONOS_APIATTRIBUTES;
+ */
+
+/*-------------------------------------------------------------------------
+ * Definition of KHRONOS_APICALL
+ *-------------------------------------------------------------------------
+ * This precedes the return type of the function in the function prototype.
+ */
+#if defined(_WIN32) && !defined(__SCITECH_SNAP__)
+#   define KHRONOS_APICALL __declspec(dllimport)
+#elif defined (__SYMBIAN32__)
+#   define KHRONOS_APICALL IMPORT_C
+#elif defined(__ANDROID__)
+#   include <sys/cdefs.h>
+#   define KHRONOS_APICALL __attribute__((visibility("default"))) __NDK_FPABI__
+#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 <stdint.h>
+ */
+#include <stdint.h>
+typedef int32_t                 khronos_int32_t;
+typedef uint32_t                khronos_uint32_t;
+typedef int64_t                 khronos_int64_t;
+typedef uint64_t                khronos_uint64_t;
+#define KHRONOS_SUPPORT_INT64   1
+#define KHRONOS_SUPPORT_FLOAT   1
+
+#elif defined(__VMS ) || defined(__sgi)
+
+/*
+ * Using <inttypes.h>
+ */
+#include <inttypes.h>
+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 <stdint.h>
+typedef int32_t                 khronos_int32_t;
+typedef uint32_t                khronos_uint32_t;
+typedef int64_t                 khronos_int64_t;
+typedef uint64_t                khronos_uint64_t;
+#define KHRONOS_SUPPORT_INT64   1
+#define KHRONOS_SUPPORT_FLOAT   1
+
+#endif
+
+
+/*
+ * Types that are (so far) the same on all platforms
+ */
+typedef signed   char          khronos_int8_t;
+typedef unsigned char          khronos_uint8_t;
+typedef signed   short int     khronos_int16_t;
+typedef unsigned short int     khronos_uint16_t;
+
+/*
+ * Types that differ between LLP64 and LP64 architectures - in LLP64,
+ * pointers are 64 bits, but 'long' is still 32 bits. Win64 appears
+ * to be the only LLP64 architecture in current use.
+ */
+#ifdef _WIN64
+typedef signed   long long int khronos_intptr_t;
+typedef unsigned long long int khronos_uintptr_t;
+typedef signed   long long int khronos_ssize_t;
+typedef unsigned long long int khronos_usize_t;
+#else
+typedef signed   long  int     khronos_intptr_t;
+typedef unsigned long  int     khronos_uintptr_t;
+typedef signed   long  int     khronos_ssize_t;
+typedef unsigned long  int     khronos_usize_t;
+#endif
+
+#if KHRONOS_SUPPORT_FLOAT
+/*
+ * Float type
+ */
+typedef          float         khronos_float_t;
+#endif
+
+#if KHRONOS_SUPPORT_INT64
+/* Time types
+ *
+ * These types can be used to represent a time interval in nanoseconds or
+ * an absolute Unadjusted System Time.  Unadjusted System Time is the number
+ * of nanoseconds since some arbitrary system event (e.g. since the last
+ * time the system booted).  The Unadjusted System Time is an unsigned
+ * 64 bit value that wraps back to 0 every 584 years.  Time intervals
+ * may be either signed or unsigned.
+ */
+typedef khronos_uint64_t       khronos_utime_nanoseconds_t;
+typedef khronos_int64_t        khronos_stime_nanoseconds_t;
+#endif
+
+/*
+ * Dummy value used to pad enum types to 32 bits.
+ */
+#ifndef KHRONOS_MAX_ENUM
+#define KHRONOS_MAX_ENUM 0x7FFFFFFF
+#endif
+
+/*
+ * Enumerated boolean type
+ *
+ * Values other than zero should be considered to be true.  Therefore
+ * comparisons should not be made against KHRONOS_TRUE.
+ */
+typedef enum {
+    KHRONOS_FALSE = 0,
+    KHRONOS_TRUE  = 1,
+    KHRONOS_BOOLEAN_ENUM_FORCE_SIZE = KHRONOS_MAX_ENUM
+} khronos_boolean_enum_t;
+
+#endif /* __khrplatform_h_ */

Engine/lib/glad/include/glad/glad_glx.h

@@ -0,0 +1,1221 @@
+/*
+
+    GLX loader generated by glad 0.1.12a0 on Mon Sep 12 03:11:58 2016.
+
+    Language/Generator: C/C++
+    Specification: glx
+    APIs: glx=1.4
+    Profile: -
+    Extensions:
+        GLX_3DFX_multisample,
+        GLX_AMD_gpu_association,
+        GLX_ARB_context_flush_control,
+        GLX_ARB_create_context,
+        GLX_ARB_create_context_profile,
+        GLX_ARB_create_context_robustness,
+        GLX_ARB_fbconfig_float,
+        GLX_ARB_framebuffer_sRGB,
+        GLX_ARB_get_proc_address,
+        GLX_ARB_multisample,
+        GLX_ARB_robustness_application_isolation,
+        GLX_ARB_robustness_share_group_isolation,
+        GLX_ARB_vertex_buffer_object,
+        GLX_EXT_buffer_age,
+        GLX_EXT_create_context_es2_profile,
+        GLX_EXT_create_context_es_profile,
+        GLX_EXT_fbconfig_packed_float,
+        GLX_EXT_framebuffer_sRGB,
+        GLX_EXT_import_context,
+        GLX_EXT_libglvnd,
+        GLX_EXT_stereo_tree,
+        GLX_EXT_swap_control,
+        GLX_EXT_swap_control_tear,
+        GLX_EXT_texture_from_pixmap,
+        GLX_EXT_visual_info,
+        GLX_EXT_visual_rating,
+        GLX_INTEL_swap_event,
+        GLX_MESA_agp_offset,
+        GLX_MESA_copy_sub_buffer,
+        GLX_MESA_pixmap_colormap,
+        GLX_MESA_query_renderer,
+        GLX_MESA_release_buffers,
+        GLX_MESA_set_3dfx_mode,
+        GLX_NV_copy_buffer,
+        GLX_NV_copy_image,
+        GLX_NV_delay_before_swap,
+        GLX_NV_float_buffer,
+        GLX_NV_multisample_coverage,
+        GLX_NV_present_video,
+        GLX_NV_robustness_video_memory_purge,
+        GLX_NV_swap_group,
+        GLX_NV_video_capture,
+        GLX_NV_video_out,
+        GLX_OML_swap_method,
+        GLX_OML_sync_control,
+        GLX_SGIS_blended_overlay,
+        GLX_SGIS_multisample,
+        GLX_SGIS_shared_multisample,
+        GLX_SGIX_dmbuffer,
+        GLX_SGIX_fbconfig,
+        GLX_SGIX_hyperpipe,
+        GLX_SGIX_pbuffer,
+        GLX_SGIX_swap_barrier,
+        GLX_SGIX_swap_group,
+        GLX_SGIX_video_resize,
+        GLX_SGIX_video_source,
+        GLX_SGIX_visual_select_group,
+        GLX_SGI_cushion,
+        GLX_SGI_make_current_read,
+        GLX_SGI_swap_control,
+        GLX_SGI_video_sync,
+        GLX_SUN_get_transparent_index
+    Loader: True
+    Local files: False
+    Omit khrplatform: False
+
+    Commandline:
+        --api="glx=1.4" --generator="c" --spec="glx" --extensions="GLX_3DFX_multisample,GLX_AMD_gpu_association,GLX_ARB_context_flush_control,GLX_ARB_create_context,GLX_ARB_create_context_profile,GLX_ARB_create_context_robustness,GLX_ARB_fbconfig_float,GLX_ARB_framebuffer_sRGB,GLX_ARB_get_proc_address,GLX_ARB_multisample,GLX_ARB_robustness_application_isolation,GLX_ARB_robustness_share_group_isolation,GLX_ARB_vertex_buffer_object,GLX_EXT_buffer_age,GLX_EXT_create_context_es2_profile,GLX_EXT_create_context_es_profile,GLX_EXT_fbconfig_packed_float,GLX_EXT_framebuffer_sRGB,GLX_EXT_import_context,GLX_EXT_libglvnd,GLX_EXT_stereo_tree,GLX_EXT_swap_control,GLX_EXT_swap_control_tear,GLX_EXT_texture_from_pixmap,GLX_EXT_visual_info,GLX_EXT_visual_rating,GLX_INTEL_swap_event,GLX_MESA_agp_offset,GLX_MESA_copy_sub_buffer,GLX_MESA_pixmap_colormap,GLX_MESA_query_renderer,GLX_MESA_release_buffers,GLX_MESA_set_3dfx_mode,GLX_NV_copy_buffer,GLX_NV_copy_image,GLX_NV_delay_before_swap,GLX_NV_float_buffer,GLX_NV_multisample_coverage,GLX_NV_present_video,GLX_NV_robustness_video_memory_purge,GLX_NV_swap_group,GLX_NV_video_capture,GLX_NV_video_out,GLX_OML_swap_method,GLX_OML_sync_control,GLX_SGIS_blended_overlay,GLX_SGIS_multisample,GLX_SGIS_shared_multisample,GLX_SGIX_dmbuffer,GLX_SGIX_fbconfig,GLX_SGIX_hyperpipe,GLX_SGIX_pbuffer,GLX_SGIX_swap_barrier,GLX_SGIX_swap_group,GLX_SGIX_video_resize,GLX_SGIX_video_source,GLX_SGIX_visual_select_group,GLX_SGI_cushion,GLX_SGI_make_current_read,GLX_SGI_swap_control,GLX_SGI_video_sync,GLX_SUN_get_transparent_index"
+    Online:
+        Too many extensions
+*/
+
+
+#include <X11/X.h>
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <glad/glad.h>
+
+#ifndef __glad_glxext_h_
+
+#ifdef __glxext_h_
+#error GLX header already included, remove this include, glad already provides it
+#endif
+
+#define __glad_glxext_h_
+#define __glxext_h_
+
+#ifndef APIENTRY
+#define APIENTRY
+#endif
+#ifndef APIENTRYP
+#define APIENTRYP APIENTRY *
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef void* (* GLADloadproc)(const char *name);
+
+#ifndef GLAPI
+# if defined(GLAD_GLAPI_EXPORT)
+#  if defined(WIN32) || defined(__CYGWIN__)
+#   if defined(GLAD_GLAPI_EXPORT_BUILD)
+#    if defined(__GNUC__)
+#     define GLAPI __attribute__ ((dllexport)) extern
+#    else
+#     define GLAPI __declspec(dllexport) extern
+#    endif
+#   else
+#    if defined(__GNUC__)
+#     define GLAPI __attribute__ ((dllimport)) extern
+#    else
+#     define GLAPI __declspec(dllimport) extern
+#    endif
+#   endif
+#  elif defined(__GNUC__) && defined(GLAD_GLAPI_EXPORT_BUILD)
+#   define GLAPI __attribute__ ((visibility ("default"))) extern
+#  else
+#   define GLAPI extern
+#  endif
+# else
+#  define GLAPI extern
+# endif
+#endif
+
+GLAPI int gladLoadGLX(Display *dpy, int screen);
+
+GLAPI int gladLoadGLXLoader(GLADloadproc, Display *dpy, int screen);
+
+#ifndef GLEXT_64_TYPES_DEFINED
+/* This code block is duplicated in glext.h, so must be protected */
+#define GLEXT_64_TYPES_DEFINED
+/* Define int32_t, int64_t, and uint64_t types for UST/MSC */
+/* (as used in the GLX_OML_sync_control extension). */
+#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
+#include <inttypes.h>
+#elif defined(__sun__) || defined(__digital__)
+#include <inttypes.h>
+#if defined(__STDC__)
+#if defined(__arch64__) || defined(_LP64)
+typedef long int int64_t;
+typedef unsigned long int uint64_t;
+#else
+typedef long long int int64_t;
+typedef unsigned long long int uint64_t;
+#endif /* __arch64__ */
+#endif /* __STDC__ */
+#elif defined( __VMS ) || defined(__sgi)
+#include <inttypes.h>
+#elif defined(__SCO__) || defined(__USLC__)
+#include <stdint.h>
+#elif defined(__UNIXOS2__) || defined(__SOL64__)
+typedef long int int32_t;
+typedef long long int int64_t;
+typedef unsigned long long int uint64_t;
+#elif defined(_WIN32) && defined(__GNUC__)
+#include <stdint.h>
+#elif defined(_WIN32)
+typedef __int32 int32_t;
+typedef __int64 int64_t;
+typedef unsigned __int64 uint64_t;
+#else
+/* Fallback if nothing above works */
+#include <inttypes.h>
+#endif
+#endif
+typedef XID GLXFBConfigID;
+typedef struct __GLXFBConfigRec *GLXFBConfig;
+typedef XID GLXContextID;
+typedef struct __GLXcontextRec *GLXContext;
+typedef XID GLXPixmap;
+typedef XID GLXDrawable;
+typedef XID GLXWindow;
+typedef XID GLXPbuffer;
+typedef void (APIENTRY *__GLXextFuncPtr)(void);
+typedef XID GLXVideoCaptureDeviceNV;
+typedef unsigned int GLXVideoDeviceNV;
+typedef XID GLXVideoSourceSGIX;
+typedef XID GLXFBConfigIDSGIX;
+typedef struct __GLXFBConfigRec *GLXFBConfigSGIX;
+typedef XID GLXPbufferSGIX;
+typedef struct {
+    int event_type;      /* GLX_DAMAGED or GLX_SAVED */
+    int draw_type;       /* GLX_WINDOW or GLX_PBUFFER */
+    unsigned long serial;       /* # of last request processed by server */
+    Bool send_event;     /* true if this came for SendEvent request */
+    Display *display;    /* display the event was read from */
+    GLXDrawable drawable;       /* XID of Drawable */
+    unsigned int buffer_mask;   /* mask indicating which buffers are affected */
+    unsigned int aux_buffer;    /* which aux buffer was affected */
+    int x, y;
+    int width, height;
+    int count;    /* if nonzero, at least this many more */
+} GLXPbufferClobberEvent;
+typedef struct {
+    int type;
+    unsigned long serial;       /* # of last request processed by server */
+    Bool send_event;     /* true if this came from a SendEvent request */
+    Display *display;    /* Display the event was read from */
+    GLXDrawable drawable;       /* drawable on which event was requested in event mask */
+    int event_type;
+    int64_t ust;
+    int64_t msc;
+    int64_t sbc;
+} GLXBufferSwapComplete;
+typedef union __GLXEvent {
+    GLXPbufferClobberEvent glxpbufferclobber;
+    GLXBufferSwapComplete glxbufferswapcomplete;
+    long pad[24];
+} GLXEvent;
+typedef struct {
+    int type;
+    unsigned long serial;
+    Bool send_event;
+    Display *display;
+    int extension;
+    int evtype;
+    GLXDrawable window;
+    Bool stereo_tree;
+} GLXStereoNotifyEventEXT;
+typedef struct {
+    int type;
+    unsigned long serial;   /* # of last request processed by server */
+    Bool send_event; /* true if this came for SendEvent request */
+    Display *display;       /* display the event was read from */
+    GLXDrawable drawable;   /* i.d. of Drawable */
+    int event_type;  /* GLX_DAMAGED_SGIX or GLX_SAVED_SGIX */
+    int draw_type;   /* GLX_WINDOW_SGIX or GLX_PBUFFER_SGIX */
+    unsigned int mask;      /* mask indicating which buffers are affected*/
+    int x, y;
+    int width, height;
+    int count;       /* if nonzero, at least this many more */
+} GLXBufferClobberEventSGIX;
+typedef struct {
+    char    pipeName[80]; /* Should be [GLX_HYPERPIPE_PIPE_NAME_LENGTH_SGIX] */
+    int     networkId;
+} GLXHyperpipeNetworkSGIX;
+typedef struct {
+    char    pipeName[80]; /* Should be [GLX_HYPERPIPE_PIPE_NAME_LENGTH_SGIX] */
+    int     channel;
+    unsigned int participationType;
+    int     timeSlice;
+} GLXHyperpipeConfigSGIX;
+typedef struct {
+    char pipeName[80]; /* Should be [GLX_HYPERPIPE_PIPE_NAME_LENGTH_SGIX] */
+    int srcXOrigin, srcYOrigin, srcWidth, srcHeight;
+    int destXOrigin, destYOrigin, destWidth, destHeight;
+} GLXPipeRect;
+typedef struct {
+    char pipeName[80]; /* Should be [GLX_HYPERPIPE_PIPE_NAME_LENGTH_SGIX] */
+    int XOrigin, YOrigin, maxHeight, maxWidth;
+} GLXPipeRectLimits;
+#define GLX_EXTENSION_NAME "GLX"
+#define GLX_PbufferClobber 0
+#define GLX_BufferSwapComplete 1
+#define __GLX_NUMBER_EVENTS 17
+#define GLX_BAD_SCREEN 1
+#define GLX_BAD_ATTRIBUTE 2
+#define GLX_NO_EXTENSION 3
+#define GLX_BAD_VISUAL 4
+#define GLX_BAD_CONTEXT 5
+#define GLX_BAD_VALUE 6
+#define GLX_BAD_ENUM 7
+#define GLX_USE_GL 1
+#define GLX_BUFFER_SIZE 2
+#define GLX_LEVEL 3
+#define GLX_RGBA 4
+#define GLX_DOUBLEBUFFER 5
+#define GLX_STEREO 6
+#define GLX_AUX_BUFFERS 7
+#define GLX_RED_SIZE 8
+#define GLX_GREEN_SIZE 9
+#define GLX_BLUE_SIZE 10
+#define GLX_ALPHA_SIZE 11
+#define GLX_DEPTH_SIZE 12
+#define GLX_STENCIL_SIZE 13
+#define GLX_ACCUM_RED_SIZE 14
+#define GLX_ACCUM_GREEN_SIZE 15
+#define GLX_ACCUM_BLUE_SIZE 16
+#define GLX_ACCUM_ALPHA_SIZE 17
+#define GLX_VENDOR 0x1
+#define GLX_VERSION 0x2
+#define GLX_EXTENSIONS 0x3
+#define GLX_WINDOW_BIT 0x00000001
+#define GLX_PIXMAP_BIT 0x00000002
+#define GLX_PBUFFER_BIT 0x00000004
+#define GLX_RGBA_BIT 0x00000001
+#define GLX_COLOR_INDEX_BIT 0x00000002
+#define GLX_PBUFFER_CLOBBER_MASK 0x08000000
+#define GLX_FRONT_LEFT_BUFFER_BIT 0x00000001
+#define GLX_FRONT_RIGHT_BUFFER_BIT 0x00000002
+#define GLX_BACK_LEFT_BUFFER_BIT 0x00000004
+#define GLX_BACK_RIGHT_BUFFER_BIT 0x00000008
+#define GLX_AUX_BUFFERS_BIT 0x00000010
+#define GLX_DEPTH_BUFFER_BIT 0x00000020
+#define GLX_STENCIL_BUFFER_BIT 0x00000040
+#define GLX_ACCUM_BUFFER_BIT 0x00000080
+#define GLX_CONFIG_CAVEAT 0x20
+#define GLX_X_VISUAL_TYPE 0x22
+#define GLX_TRANSPARENT_TYPE 0x23
+#define GLX_TRANSPARENT_INDEX_VALUE 0x24
+#define GLX_TRANSPARENT_RED_VALUE 0x25
+#define GLX_TRANSPARENT_GREEN_VALUE 0x26
+#define GLX_TRANSPARENT_BLUE_VALUE 0x27
+#define GLX_TRANSPARENT_ALPHA_VALUE 0x28
+#define GLX_DONT_CARE 0xFFFFFFFF
+#define GLX_NONE 0x8000
+#define GLX_SLOW_CONFIG 0x8001
+#define GLX_TRUE_COLOR 0x8002
+#define GLX_DIRECT_COLOR 0x8003
+#define GLX_PSEUDO_COLOR 0x8004
+#define GLX_STATIC_COLOR 0x8005
+#define GLX_GRAY_SCALE 0x8006
+#define GLX_STATIC_GRAY 0x8007
+#define GLX_TRANSPARENT_RGB 0x8008
+#define GLX_TRANSPARENT_INDEX 0x8009
+#define GLX_VISUAL_ID 0x800B
+#define GLX_SCREEN 0x800C
+#define GLX_NON_CONFORMANT_CONFIG 0x800D
+#define GLX_DRAWABLE_TYPE 0x8010
+#define GLX_RENDER_TYPE 0x8011
+#define GLX_X_RENDERABLE 0x8012
+#define GLX_FBCONFIG_ID 0x8013
+#define GLX_RGBA_TYPE 0x8014
+#define GLX_COLOR_INDEX_TYPE 0x8015
+#define GLX_MAX_PBUFFER_WIDTH 0x8016
+#define GLX_MAX_PBUFFER_HEIGHT 0x8017
+#define GLX_MAX_PBUFFER_PIXELS 0x8018
+#define GLX_PRESERVED_CONTENTS 0x801B
+#define GLX_LARGEST_PBUFFER 0x801C
+#define GLX_WIDTH 0x801D
+#define GLX_HEIGHT 0x801E
+#define GLX_EVENT_MASK 0x801F
+#define GLX_DAMAGED 0x8020
+#define GLX_SAVED 0x8021
+#define GLX_WINDOW 0x8022
+#define GLX_PBUFFER 0x8023
+#define GLX_PBUFFER_HEIGHT 0x8040
+#define GLX_PBUFFER_WIDTH 0x8041
+#define GLX_SAMPLE_BUFFERS 100000
+#define GLX_SAMPLES 100001
+#ifndef GLX_VERSION_1_0
+#define GLX_VERSION_1_0 1
+GLAPI int GLAD_GLX_VERSION_1_0;
+typedef XVisualInfo * (APIENTRYP PFNGLXCHOOSEVISUALPROC)(Display *dpy, int screen, int *attribList);
+GLAPI PFNGLXCHOOSEVISUALPROC glad_glXChooseVisual;
+#define glXChooseVisual glad_glXChooseVisual
+typedef GLXContext (APIENTRYP PFNGLXCREATECONTEXTPROC)(Display *dpy, XVisualInfo *vis, GLXContext shareList, Bool direct);
+GLAPI PFNGLXCREATECONTEXTPROC glad_glXCreateContext;
+#define glXCreateContext glad_glXCreateContext
+typedef void (APIENTRYP PFNGLXDESTROYCONTEXTPROC)(Display *dpy, GLXContext ctx);
+GLAPI PFNGLXDESTROYCONTEXTPROC glad_glXDestroyContext;
+#define glXDestroyContext glad_glXDestroyContext
+typedef Bool (APIENTRYP PFNGLXMAKECURRENTPROC)(Display *dpy, GLXDrawable drawable, GLXContext ctx);
+GLAPI PFNGLXMAKECURRENTPROC glad_glXMakeCurrent;
+#define glXMakeCurrent glad_glXMakeCurrent
+typedef void (APIENTRYP PFNGLXCOPYCONTEXTPROC)(Display *dpy, GLXContext src, GLXContext dst, unsigned long mask);
+GLAPI PFNGLXCOPYCONTEXTPROC glad_glXCopyContext;
+#define glXCopyContext glad_glXCopyContext
+typedef void (APIENTRYP PFNGLXSWAPBUFFERSPROC)(Display *dpy, GLXDrawable drawable);
+GLAPI PFNGLXSWAPBUFFERSPROC glad_glXSwapBuffers;
+#define glXSwapBuffers glad_glXSwapBuffers
+typedef GLXPixmap (APIENTRYP PFNGLXCREATEGLXPIXMAPPROC)(Display *dpy, XVisualInfo *visual, Pixmap pixmap);
+GLAPI PFNGLXCREATEGLXPIXMAPPROC glad_glXCreateGLXPixmap;
+#define glXCreateGLXPixmap glad_glXCreateGLXPixmap
+typedef void (APIENTRYP PFNGLXDESTROYGLXPIXMAPPROC)(Display *dpy, GLXPixmap pixmap);
+GLAPI PFNGLXDESTROYGLXPIXMAPPROC glad_glXDestroyGLXPixmap;
+#define glXDestroyGLXPixmap glad_glXDestroyGLXPixmap
+typedef Bool (APIENTRYP PFNGLXQUERYEXTENSIONPROC)(Display *dpy, int *errorb, int *event);
+GLAPI PFNGLXQUERYEXTENSIONPROC glad_glXQueryExtension;
+#define glXQueryExtension glad_glXQueryExtension
+typedef Bool (APIENTRYP PFNGLXQUERYVERSIONPROC)(Display *dpy, int *maj, int *min);
+GLAPI PFNGLXQUERYVERSIONPROC glad_glXQueryVersion;
+#define glXQueryVersion glad_glXQueryVersion
+typedef Bool (APIENTRYP PFNGLXISDIRECTPROC)(Display *dpy, GLXContext ctx);
+GLAPI PFNGLXISDIRECTPROC glad_glXIsDirect;
+#define glXIsDirect glad_glXIsDirect
+typedef int (APIENTRYP PFNGLXGETCONFIGPROC)(Display *dpy, XVisualInfo *visual, int attrib, int *value);
+GLAPI PFNGLXGETCONFIGPROC glad_glXGetConfig;
+#define glXGetConfig glad_glXGetConfig
+typedef GLXContext (APIENTRYP PFNGLXGETCURRENTCONTEXTPROC)();
+GLAPI PFNGLXGETCURRENTCONTEXTPROC glad_glXGetCurrentContext;
+#define glXGetCurrentContext glad_glXGetCurrentContext
+typedef GLXDrawable (APIENTRYP PFNGLXGETCURRENTDRAWABLEPROC)();
+GLAPI PFNGLXGETCURRENTDRAWABLEPROC glad_glXGetCurrentDrawable;
+#define glXGetCurrentDrawable glad_glXGetCurrentDrawable
+typedef void (APIENTRYP PFNGLXWAITGLPROC)();
+GLAPI PFNGLXWAITGLPROC glad_glXWaitGL;
+#define glXWaitGL glad_glXWaitGL
+typedef void (APIENTRYP PFNGLXWAITXPROC)();
+GLAPI PFNGLXWAITXPROC glad_glXWaitX;
+#define glXWaitX glad_glXWaitX
+typedef void (APIENTRYP PFNGLXUSEXFONTPROC)(Font font, int first, int count, int list);
+GLAPI PFNGLXUSEXFONTPROC glad_glXUseXFont;
+#define glXUseXFont glad_glXUseXFont
+#endif
+#ifndef GLX_VERSION_1_1
+#define GLX_VERSION_1_1 1
+GLAPI int GLAD_GLX_VERSION_1_1;
+typedef const char * (APIENTRYP PFNGLXQUERYEXTENSIONSSTRINGPROC)(Display *dpy, int screen);
+GLAPI PFNGLXQUERYEXTENSIONSSTRINGPROC glad_glXQueryExtensionsString;
+#define glXQueryExtensionsString glad_glXQueryExtensionsString
+typedef const char * (APIENTRYP PFNGLXQUERYSERVERSTRINGPROC)(Display *dpy, int screen, int name);
+GLAPI PFNGLXQUERYSERVERSTRINGPROC glad_glXQueryServerString;
+#define glXQueryServerString glad_glXQueryServerString
+typedef const char * (APIENTRYP PFNGLXGETCLIENTSTRINGPROC)(Display *dpy, int name);
+GLAPI PFNGLXGETCLIENTSTRINGPROC glad_glXGetClientString;
+#define glXGetClientString glad_glXGetClientString
+#endif
+#ifndef GLX_VERSION_1_2
+#define GLX_VERSION_1_2 1
+GLAPI int GLAD_GLX_VERSION_1_2;
+typedef Display * (APIENTRYP PFNGLXGETCURRENTDISPLAYPROC)();
+GLAPI PFNGLXGETCURRENTDISPLAYPROC glad_glXGetCurrentDisplay;
+#define glXGetCurrentDisplay glad_glXGetCurrentDisplay
+#endif
+#ifndef GLX_VERSION_1_3
+#define GLX_VERSION_1_3 1
+GLAPI int GLAD_GLX_VERSION_1_3;
+typedef GLXFBConfig * (APIENTRYP PFNGLXGETFBCONFIGSPROC)(Display *dpy, int screen, int *nelements);
+GLAPI PFNGLXGETFBCONFIGSPROC glad_glXGetFBConfigs;
+#define glXGetFBConfigs glad_glXGetFBConfigs
+typedef GLXFBConfig * (APIENTRYP PFNGLXCHOOSEFBCONFIGPROC)(Display *dpy, int screen, const int *attrib_list, int *nelements);
+GLAPI PFNGLXCHOOSEFBCONFIGPROC glad_glXChooseFBConfig;
+#define glXChooseFBConfig glad_glXChooseFBConfig
+typedef int (APIENTRYP PFNGLXGETFBCONFIGATTRIBPROC)(Display *dpy, GLXFBConfig config, int attribute, int *value);
+GLAPI PFNGLXGETFBCONFIGATTRIBPROC glad_glXGetFBConfigAttrib;
+#define glXGetFBConfigAttrib glad_glXGetFBConfigAttrib
+typedef XVisualInfo * (APIENTRYP PFNGLXGETVISUALFROMFBCONFIGPROC)(Display *dpy, GLXFBConfig config);
+GLAPI PFNGLXGETVISUALFROMFBCONFIGPROC glad_glXGetVisualFromFBConfig;
+#define glXGetVisualFromFBConfig glad_glXGetVisualFromFBConfig
+typedef GLXWindow (APIENTRYP PFNGLXCREATEWINDOWPROC)(Display *dpy, GLXFBConfig config, Window win, const int *attrib_list);
+GLAPI PFNGLXCREATEWINDOWPROC glad_glXCreateWindow;
+#define glXCreateWindow glad_glXCreateWindow
+typedef void (APIENTRYP PFNGLXDESTROYWINDOWPROC)(Display *dpy, GLXWindow win);
+GLAPI PFNGLXDESTROYWINDOWPROC glad_glXDestroyWindow;
+#define glXDestroyWindow glad_glXDestroyWindow
+typedef GLXPixmap (APIENTRYP PFNGLXCREATEPIXMAPPROC)(Display *dpy, GLXFBConfig config, Pixmap pixmap, const int *attrib_list);
+GLAPI PFNGLXCREATEPIXMAPPROC glad_glXCreatePixmap;
+#define glXCreatePixmap glad_glXCreatePixmap
+typedef void (APIENTRYP PFNGLXDESTROYPIXMAPPROC)(Display *dpy, GLXPixmap pixmap);
+GLAPI PFNGLXDESTROYPIXMAPPROC glad_glXDestroyPixmap;
+#define glXDestroyPixmap glad_glXDestroyPixmap
+typedef GLXPbuffer (APIENTRYP PFNGLXCREATEPBUFFERPROC)(Display *dpy, GLXFBConfig config, const int *attrib_list);
+GLAPI PFNGLXCREATEPBUFFERPROC glad_glXCreatePbuffer;
+#define glXCreatePbuffer glad_glXCreatePbuffer
+typedef void (APIENTRYP PFNGLXDESTROYPBUFFERPROC)(Display *dpy, GLXPbuffer pbuf);
+GLAPI PFNGLXDESTROYPBUFFERPROC glad_glXDestroyPbuffer;
+#define glXDestroyPbuffer glad_glXDestroyPbuffer
+typedef void (APIENTRYP PFNGLXQUERYDRAWABLEPROC)(Display *dpy, GLXDrawable draw, int attribute, unsigned int *value);
+GLAPI PFNGLXQUERYDRAWABLEPROC glad_glXQueryDrawable;
+#define glXQueryDrawable glad_glXQueryDrawable
+typedef GLXContext (APIENTRYP PFNGLXCREATENEWCONTEXTPROC)(Display *dpy, GLXFBConfig config, int render_type, GLXContext share_list, Bool direct);
+GLAPI PFNGLXCREATENEWCONTEXTPROC glad_glXCreateNewContext;
+#define glXCreateNewContext glad_glXCreateNewContext
+typedef Bool (APIENTRYP PFNGLXMAKECONTEXTCURRENTPROC)(Display *dpy, GLXDrawable draw, GLXDrawable read, GLXContext ctx);
+GLAPI PFNGLXMAKECONTEXTCURRENTPROC glad_glXMakeContextCurrent;
+#define glXMakeContextCurrent glad_glXMakeContextCurrent
+typedef GLXDrawable (APIENTRYP PFNGLXGETCURRENTREADDRAWABLEPROC)();
+GLAPI PFNGLXGETCURRENTREADDRAWABLEPROC glad_glXGetCurrentReadDrawable;
+#define glXGetCurrentReadDrawable glad_glXGetCurrentReadDrawable
+typedef int (APIENTRYP PFNGLXQUERYCONTEXTPROC)(Display *dpy, GLXContext ctx, int attribute, int *value);
+GLAPI PFNGLXQUERYCONTEXTPROC glad_glXQueryContext;
+#define glXQueryContext glad_glXQueryContext
+typedef void (APIENTRYP PFNGLXSELECTEVENTPROC)(Display *dpy, GLXDrawable draw, unsigned long event_mask);
+GLAPI PFNGLXSELECTEVENTPROC glad_glXSelectEvent;
+#define glXSelectEvent glad_glXSelectEvent
+typedef void (APIENTRYP PFNGLXGETSELECTEDEVENTPROC)(Display *dpy, GLXDrawable draw, unsigned long *event_mask);
+GLAPI PFNGLXGETSELECTEDEVENTPROC glad_glXGetSelectedEvent;
+#define glXGetSelectedEvent glad_glXGetSelectedEvent
+#endif
+#ifndef GLX_VERSION_1_4
+#define GLX_VERSION_1_4 1
+GLAPI int GLAD_GLX_VERSION_1_4;
+typedef __GLXextFuncPtr (APIENTRYP PFNGLXGETPROCADDRESSPROC)(const GLubyte *procName);
+GLAPI PFNGLXGETPROCADDRESSPROC glad_glXGetProcAddress;
+#define glXGetProcAddress glad_glXGetProcAddress
+#endif
+#define GLX_SAMPLE_BUFFERS_3DFX 0x8050
+#define GLX_SAMPLES_3DFX 0x8051
+#define GLX_GPU_VENDOR_AMD 0x1F00
+#define GLX_GPU_RENDERER_STRING_AMD 0x1F01
+#define GLX_GPU_OPENGL_VERSION_STRING_AMD 0x1F02
+#define GLX_GPU_FASTEST_TARGET_GPUS_AMD 0x21A2
+#define GLX_GPU_RAM_AMD 0x21A3
+#define GLX_GPU_CLOCK_AMD 0x21A4
+#define GLX_GPU_NUM_PIPES_AMD 0x21A5
+#define GLX_GPU_NUM_SIMD_AMD 0x21A6
+#define GLX_GPU_NUM_RB_AMD 0x21A7
+#define GLX_GPU_NUM_SPI_AMD 0x21A8
+#define GLX_CONTEXT_RELEASE_BEHAVIOR_ARB 0x2097
+#define GLX_CONTEXT_RELEASE_BEHAVIOR_NONE_ARB 0
+#define GLX_CONTEXT_RELEASE_BEHAVIOR_FLUSH_ARB 0x2098
+#define GLX_CONTEXT_DEBUG_BIT_ARB 0x00000001
+#define GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB 0x00000002
+#define GLX_CONTEXT_MAJOR_VERSION_ARB 0x2091
+#define GLX_CONTEXT_MINOR_VERSION_ARB 0x2092
+#define GLX_CONTEXT_FLAGS_ARB 0x2094
+#define GLX_CONTEXT_CORE_PROFILE_BIT_ARB 0x00000001
+#define GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB 0x00000002
+#define GLX_CONTEXT_PROFILE_MASK_ARB 0x9126
+#define GLX_CONTEXT_ROBUST_ACCESS_BIT_ARB 0x00000004
+#define GLX_LOSE_CONTEXT_ON_RESET_ARB 0x8252
+#define GLX_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB 0x8256
+#define GLX_NO_RESET_NOTIFICATION_ARB 0x8261
+#define GLX_RGBA_FLOAT_TYPE_ARB 0x20B9
+#define GLX_RGBA_FLOAT_BIT_ARB 0x00000004
+#define GLX_FRAMEBUFFER_SRGB_CAPABLE_ARB 0x20B2
+#define GLX_SAMPLE_BUFFERS_ARB 100000
+#define GLX_SAMPLES_ARB 100001
+#define GLX_CONTEXT_RESET_ISOLATION_BIT_ARB 0x00000008
+#define GLX_CONTEXT_ALLOW_BUFFER_BYTE_ORDER_MISMATCH_ARB 0x2095
+#define GLX_BACK_BUFFER_AGE_EXT 0x20F4
+#define GLX_CONTEXT_ES2_PROFILE_BIT_EXT 0x00000004
+#define GLX_CONTEXT_ES_PROFILE_BIT_EXT 0x00000004
+#define GLX_RGBA_UNSIGNED_FLOAT_TYPE_EXT 0x20B1
+#define GLX_RGBA_UNSIGNED_FLOAT_BIT_EXT 0x00000008
+#define GLX_FRAMEBUFFER_SRGB_CAPABLE_EXT 0x20B2
+#define GLX_SHARE_CONTEXT_EXT 0x800A
+#define GLX_VISUAL_ID_EXT 0x800B
+#define GLX_SCREEN_EXT 0x800C
+#define GLX_VENDOR_NAMES_EXT 0x20F6
+#define GLX_STEREO_TREE_EXT 0x20F5
+#define GLX_STEREO_NOTIFY_MASK_EXT 0x00000001
+#define GLX_STEREO_NOTIFY_EXT 0x00000000
+#define GLX_SWAP_INTERVAL_EXT 0x20F1
+#define GLX_MAX_SWAP_INTERVAL_EXT 0x20F2
+#define GLX_LATE_SWAPS_TEAR_EXT 0x20F3
+#define GLX_TEXTURE_1D_BIT_EXT 0x00000001
+#define GLX_TEXTURE_2D_BIT_EXT 0x00000002
+#define GLX_TEXTURE_RECTANGLE_BIT_EXT 0x00000004
+#define GLX_BIND_TO_TEXTURE_RGB_EXT 0x20D0
+#define GLX_BIND_TO_TEXTURE_RGBA_EXT 0x20D1
+#define GLX_BIND_TO_MIPMAP_TEXTURE_EXT 0x20D2
+#define GLX_BIND_TO_TEXTURE_TARGETS_EXT 0x20D3
+#define GLX_Y_INVERTED_EXT 0x20D4
+#define GLX_TEXTURE_FORMAT_EXT 0x20D5
+#define GLX_TEXTURE_TARGET_EXT 0x20D6
+#define GLX_MIPMAP_TEXTURE_EXT 0x20D7
+#define GLX_TEXTURE_FORMAT_NONE_EXT 0x20D8
+#define GLX_TEXTURE_FORMAT_RGB_EXT 0x20D9
+#define GLX_TEXTURE_FORMAT_RGBA_EXT 0x20DA
+#define GLX_TEXTURE_1D_EXT 0x20DB
+#define GLX_TEXTURE_2D_EXT 0x20DC
+#define GLX_TEXTURE_RECTANGLE_EXT 0x20DD
+#define GLX_FRONT_LEFT_EXT 0x20DE
+#define GLX_FRONT_RIGHT_EXT 0x20DF
+#define GLX_BACK_LEFT_EXT 0x20E0
+#define GLX_BACK_RIGHT_EXT 0x20E1
+#define GLX_FRONT_EXT 0x20DE
+#define GLX_BACK_EXT 0x20E0
+#define GLX_AUX0_EXT 0x20E2
+#define GLX_AUX1_EXT 0x20E3
+#define GLX_AUX2_EXT 0x20E4
+#define GLX_AUX3_EXT 0x20E5
+#define GLX_AUX4_EXT 0x20E6
+#define GLX_AUX5_EXT 0x20E7
+#define GLX_AUX6_EXT 0x20E8
+#define GLX_AUX7_EXT 0x20E9
+#define GLX_AUX8_EXT 0x20EA
+#define GLX_AUX9_EXT 0x20EB
+#define GLX_X_VISUAL_TYPE_EXT 0x22
+#define GLX_TRANSPARENT_TYPE_EXT 0x23
+#define GLX_TRANSPARENT_INDEX_VALUE_EXT 0x24
+#define GLX_TRANSPARENT_RED_VALUE_EXT 0x25
+#define GLX_TRANSPARENT_GREEN_VALUE_EXT 0x26
+#define GLX_TRANSPARENT_BLUE_VALUE_EXT 0x27
+#define GLX_TRANSPARENT_ALPHA_VALUE_EXT 0x28
+#define GLX_NONE_EXT 0x8000
+#define GLX_TRUE_COLOR_EXT 0x8002
+#define GLX_DIRECT_COLOR_EXT 0x8003
+#define GLX_PSEUDO_COLOR_EXT 0x8004
+#define GLX_STATIC_COLOR_EXT 0x8005
+#define GLX_GRAY_SCALE_EXT 0x8006
+#define GLX_STATIC_GRAY_EXT 0x8007
+#define GLX_TRANSPARENT_RGB_EXT 0x8008
+#define GLX_TRANSPARENT_INDEX_EXT 0x8009
+#define GLX_VISUAL_CAVEAT_EXT 0x20
+#define GLX_SLOW_VISUAL_EXT 0x8001
+#define GLX_NON_CONFORMANT_VISUAL_EXT 0x800D
+#define GLX_BUFFER_SWAP_COMPLETE_INTEL_MASK 0x04000000
+#define GLX_EXCHANGE_COMPLETE_INTEL 0x8180
+#define GLX_COPY_COMPLETE_INTEL 0x8181
+#define GLX_FLIP_COMPLETE_INTEL 0x8182
+#define GLX_RENDERER_VENDOR_ID_MESA 0x8183
+#define GLX_RENDERER_DEVICE_ID_MESA 0x8184
+#define GLX_RENDERER_VERSION_MESA 0x8185
+#define GLX_RENDERER_ACCELERATED_MESA 0x8186
+#define GLX_RENDERER_VIDEO_MEMORY_MESA 0x8187
+#define GLX_RENDERER_UNIFIED_MEMORY_ARCHITECTURE_MESA 0x8188
+#define GLX_RENDERER_PREFERRED_PROFILE_MESA 0x8189
+#define GLX_RENDERER_OPENGL_CORE_PROFILE_VERSION_MESA 0x818A
+#define GLX_RENDERER_OPENGL_COMPATIBILITY_PROFILE_VERSION_MESA 0x818B
+#define GLX_RENDERER_OPENGL_ES_PROFILE_VERSION_MESA 0x818C
+#define GLX_RENDERER_OPENGL_ES2_PROFILE_VERSION_MESA 0x818D
+#define GLX_RENDERER_ID_MESA 0x818E
+#define GLX_3DFX_WINDOW_MODE_MESA 0x1
+#define GLX_3DFX_FULLSCREEN_MODE_MESA 0x2
+#define GLX_FLOAT_COMPONENTS_NV 0x20B0
+#define GLX_COVERAGE_SAMPLES_NV 100001
+#define GLX_COLOR_SAMPLES_NV 0x20B3
+#define GLX_NUM_VIDEO_SLOTS_NV 0x20F0
+#define GLX_GENERATE_RESET_ON_VIDEO_MEMORY_PURGE_NV 0x20F7
+#define GLX_DEVICE_ID_NV 0x20CD
+#define GLX_UNIQUE_ID_NV 0x20CE
+#define GLX_NUM_VIDEO_CAPTURE_SLOTS_NV 0x20CF
+#define GLX_VIDEO_OUT_COLOR_NV 0x20C3
+#define GLX_VIDEO_OUT_ALPHA_NV 0x20C4
+#define GLX_VIDEO_OUT_DEPTH_NV 0x20C5
+#define GLX_VIDEO_OUT_COLOR_AND_ALPHA_NV 0x20C6
+#define GLX_VIDEO_OUT_COLOR_AND_DEPTH_NV 0x20C7
+#define GLX_VIDEO_OUT_FRAME_NV 0x20C8
+#define GLX_VIDEO_OUT_FIELD_1_NV 0x20C9
+#define GLX_VIDEO_OUT_FIELD_2_NV 0x20CA
+#define GLX_VIDEO_OUT_STACKED_FIELDS_1_2_NV 0x20CB
+#define GLX_VIDEO_OUT_STACKED_FIELDS_2_1_NV 0x20CC
+#define GLX_SWAP_METHOD_OML 0x8060
+#define GLX_SWAP_EXCHANGE_OML 0x8061
+#define GLX_SWAP_COPY_OML 0x8062
+#define GLX_SWAP_UNDEFINED_OML 0x8063
+#define GLX_BLENDED_RGBA_SGIS 0x8025
+#define GLX_SAMPLE_BUFFERS_SGIS 100000
+#define GLX_SAMPLES_SGIS 100001
+#define GLX_MULTISAMPLE_SUB_RECT_WIDTH_SGIS 0x8026
+#define GLX_MULTISAMPLE_SUB_RECT_HEIGHT_SGIS 0x8027
+#define GLX_DIGITAL_MEDIA_PBUFFER_SGIX 0x8024
+#define GLX_WINDOW_BIT_SGIX 0x00000001
+#define GLX_PIXMAP_BIT_SGIX 0x00000002
+#define GLX_RGBA_BIT_SGIX 0x00000001
+#define GLX_COLOR_INDEX_BIT_SGIX 0x00000002
+#define GLX_DRAWABLE_TYPE_SGIX 0x8010
+#define GLX_RENDER_TYPE_SGIX 0x8011
+#define GLX_X_RENDERABLE_SGIX 0x8012
+#define GLX_FBCONFIG_ID_SGIX 0x8013
+#define GLX_RGBA_TYPE_SGIX 0x8014
+#define GLX_COLOR_INDEX_TYPE_SGIX 0x8015
+#define GLX_HYPERPIPE_PIPE_NAME_LENGTH_SGIX 80
+#define GLX_BAD_HYPERPIPE_CONFIG_SGIX 91
+#define GLX_BAD_HYPERPIPE_SGIX 92
+#define GLX_HYPERPIPE_DISPLAY_PIPE_SGIX 0x00000001
+#define GLX_HYPERPIPE_RENDER_PIPE_SGIX 0x00000002
+#define GLX_PIPE_RECT_SGIX 0x00000001
+#define GLX_PIPE_RECT_LIMITS_SGIX 0x00000002
+#define GLX_HYPERPIPE_STEREO_SGIX 0x00000003
+#define GLX_HYPERPIPE_PIXEL_AVERAGE_SGIX 0x00000004
+#define GLX_HYPERPIPE_ID_SGIX 0x8030
+#define GLX_PBUFFER_BIT_SGIX 0x00000004
+#define GLX_BUFFER_CLOBBER_MASK_SGIX 0x08000000
+#define GLX_FRONT_LEFT_BUFFER_BIT_SGIX 0x00000001
+#define GLX_FRONT_RIGHT_BUFFER_BIT_SGIX 0x00000002
+#define GLX_BACK_LEFT_BUFFER_BIT_SGIX 0x00000004
+#define GLX_BACK_RIGHT_BUFFER_BIT_SGIX 0x00000008
+#define GLX_AUX_BUFFERS_BIT_SGIX 0x00000010
+#define GLX_DEPTH_BUFFER_BIT_SGIX 0x00000020
+#define GLX_STENCIL_BUFFER_BIT_SGIX 0x00000040
+#define GLX_ACCUM_BUFFER_BIT_SGIX 0x00000080
+#define GLX_SAMPLE_BUFFERS_BIT_SGIX 0x00000100
+#define GLX_MAX_PBUFFER_WIDTH_SGIX 0x8016
+#define GLX_MAX_PBUFFER_HEIGHT_SGIX 0x8017
+#define GLX_MAX_PBUFFER_PIXELS_SGIX 0x8018
+#define GLX_OPTIMAL_PBUFFER_WIDTH_SGIX 0x8019
+#define GLX_OPTIMAL_PBUFFER_HEIGHT_SGIX 0x801A
+#define GLX_PRESERVED_CONTENTS_SGIX 0x801B
+#define GLX_LARGEST_PBUFFER_SGIX 0x801C
+#define GLX_WIDTH_SGIX 0x801D
+#define GLX_HEIGHT_SGIX 0x801E
+#define GLX_EVENT_MASK_SGIX 0x801F
+#define GLX_DAMAGED_SGIX 0x8020
+#define GLX_SAVED_SGIX 0x8021
+#define GLX_WINDOW_SGIX 0x8022
+#define GLX_PBUFFER_SGIX 0x8023
+#define GLX_SYNC_FRAME_SGIX 0x00000000
+#define GLX_SYNC_SWAP_SGIX 0x00000001
+#define GLX_VISUAL_SELECT_GROUP_SGIX 0x8028
+#ifndef GLX_3DFX_multisample
+#define GLX_3DFX_multisample 1
+GLAPI int GLAD_GLX_3DFX_multisample;
+#endif
+#ifndef GLX_AMD_gpu_association
+#define GLX_AMD_gpu_association 1
+GLAPI int GLAD_GLX_AMD_gpu_association;
+typedef unsigned int (APIENTRYP PFNGLXGETGPUIDSAMDPROC)(unsigned int maxCount, unsigned int *ids);
+GLAPI PFNGLXGETGPUIDSAMDPROC glad_glXGetGPUIDsAMD;
+#define glXGetGPUIDsAMD glad_glXGetGPUIDsAMD
+typedef int (APIENTRYP PFNGLXGETGPUINFOAMDPROC)(unsigned int id, int property, GLenum dataType, unsigned int size, void *data);
+GLAPI PFNGLXGETGPUINFOAMDPROC glad_glXGetGPUInfoAMD;
+#define glXGetGPUInfoAMD glad_glXGetGPUInfoAMD
+typedef unsigned int (APIENTRYP PFNGLXGETCONTEXTGPUIDAMDPROC)(GLXContext ctx);
+GLAPI PFNGLXGETCONTEXTGPUIDAMDPROC glad_glXGetContextGPUIDAMD;
+#define glXGetContextGPUIDAMD glad_glXGetContextGPUIDAMD
+typedef GLXContext (APIENTRYP PFNGLXCREATEASSOCIATEDCONTEXTAMDPROC)(unsigned int id, GLXContext share_list);
+GLAPI PFNGLXCREATEASSOCIATEDCONTEXTAMDPROC glad_glXCreateAssociatedContextAMD;
+#define glXCreateAssociatedContextAMD glad_glXCreateAssociatedContextAMD
+typedef GLXContext (APIENTRYP PFNGLXCREATEASSOCIATEDCONTEXTATTRIBSAMDPROC)(unsigned int id, GLXContext share_context, const int *attribList);
+GLAPI PFNGLXCREATEASSOCIATEDCONTEXTATTRIBSAMDPROC glad_glXCreateAssociatedContextAttribsAMD;
+#define glXCreateAssociatedContextAttribsAMD glad_glXCreateAssociatedContextAttribsAMD
+typedef Bool (APIENTRYP PFNGLXDELETEASSOCIATEDCONTEXTAMDPROC)(GLXContext ctx);
+GLAPI PFNGLXDELETEASSOCIATEDCONTEXTAMDPROC glad_glXDeleteAssociatedContextAMD;
+#define glXDeleteAssociatedContextAMD glad_glXDeleteAssociatedContextAMD
+typedef Bool (APIENTRYP PFNGLXMAKEASSOCIATEDCONTEXTCURRENTAMDPROC)(GLXContext ctx);
+GLAPI PFNGLXMAKEASSOCIATEDCONTEXTCURRENTAMDPROC glad_glXMakeAssociatedContextCurrentAMD;
+#define glXMakeAssociatedContextCurrentAMD glad_glXMakeAssociatedContextCurrentAMD
+typedef GLXContext (APIENTRYP PFNGLXGETCURRENTASSOCIATEDCONTEXTAMDPROC)();
+GLAPI PFNGLXGETCURRENTASSOCIATEDCONTEXTAMDPROC glad_glXGetCurrentAssociatedContextAMD;
+#define glXGetCurrentAssociatedContextAMD glad_glXGetCurrentAssociatedContextAMD
+typedef void (APIENTRYP PFNGLXBLITCONTEXTFRAMEBUFFERAMDPROC)(GLXContext dstCtx, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
+GLAPI PFNGLXBLITCONTEXTFRAMEBUFFERAMDPROC glad_glXBlitContextFramebufferAMD;
+#define glXBlitContextFramebufferAMD glad_glXBlitContextFramebufferAMD
+#endif
+#ifndef GLX_ARB_context_flush_control
+#define GLX_ARB_context_flush_control 1
+GLAPI int GLAD_GLX_ARB_context_flush_control;
+#endif
+#ifndef GLX_ARB_create_context
+#define GLX_ARB_create_context 1
+GLAPI int GLAD_GLX_ARB_create_context;
+typedef GLXContext (APIENTRYP PFNGLXCREATECONTEXTATTRIBSARBPROC)(Display *dpy, GLXFBConfig config, GLXContext share_context, Bool direct, const int *attrib_list);
+GLAPI PFNGLXCREATECONTEXTATTRIBSARBPROC glad_glXCreateContextAttribsARB;
+#define glXCreateContextAttribsARB glad_glXCreateContextAttribsARB
+#endif
+#ifndef GLX_ARB_create_context_profile
+#define GLX_ARB_create_context_profile 1
+GLAPI int GLAD_GLX_ARB_create_context_profile;
+#endif
+#ifndef GLX_ARB_create_context_robustness
+#define GLX_ARB_create_context_robustness 1
+GLAPI int GLAD_GLX_ARB_create_context_robustness;
+#endif
+#ifndef GLX_ARB_fbconfig_float
+#define GLX_ARB_fbconfig_float 1
+GLAPI int GLAD_GLX_ARB_fbconfig_float;
+#endif
+#ifndef GLX_ARB_framebuffer_sRGB
+#define GLX_ARB_framebuffer_sRGB 1
+GLAPI int GLAD_GLX_ARB_framebuffer_sRGB;
+#endif
+#ifndef GLX_ARB_get_proc_address
+#define GLX_ARB_get_proc_address 1
+GLAPI int GLAD_GLX_ARB_get_proc_address;
+typedef __GLXextFuncPtr (APIENTRYP PFNGLXGETPROCADDRESSARBPROC)(const GLubyte *procName);
+GLAPI PFNGLXGETPROCADDRESSARBPROC glad_glXGetProcAddressARB;
+#define glXGetProcAddressARB glad_glXGetProcAddressARB
+#endif
+#ifndef GLX_ARB_multisample
+#define GLX_ARB_multisample 1
+GLAPI int GLAD_GLX_ARB_multisample;
+#endif
+#ifndef GLX_ARB_robustness_application_isolation
+#define GLX_ARB_robustness_application_isolation 1
+GLAPI int GLAD_GLX_ARB_robustness_application_isolation;
+#endif
+#ifndef GLX_ARB_robustness_share_group_isolation
+#define GLX_ARB_robustness_share_group_isolation 1
+GLAPI int GLAD_GLX_ARB_robustness_share_group_isolation;
+#endif
+#ifndef GLX_ARB_vertex_buffer_object
+#define GLX_ARB_vertex_buffer_object 1
+GLAPI int GLAD_GLX_ARB_vertex_buffer_object;
+#endif
+#ifndef GLX_EXT_buffer_age
+#define GLX_EXT_buffer_age 1
+GLAPI int GLAD_GLX_EXT_buffer_age;
+#endif
+#ifndef GLX_EXT_create_context_es2_profile
+#define GLX_EXT_create_context_es2_profile 1
+GLAPI int GLAD_GLX_EXT_create_context_es2_profile;
+#endif
+#ifndef GLX_EXT_create_context_es_profile
+#define GLX_EXT_create_context_es_profile 1
+GLAPI int GLAD_GLX_EXT_create_context_es_profile;
+#endif
+#ifndef GLX_EXT_fbconfig_packed_float
+#define GLX_EXT_fbconfig_packed_float 1
+GLAPI int GLAD_GLX_EXT_fbconfig_packed_float;
+#endif
+#ifndef GLX_EXT_framebuffer_sRGB
+#define GLX_EXT_framebuffer_sRGB 1
+GLAPI int GLAD_GLX_EXT_framebuffer_sRGB;
+#endif
+#ifndef GLX_EXT_import_context
+#define GLX_EXT_import_context 1
+GLAPI int GLAD_GLX_EXT_import_context;
+typedef Display * (APIENTRYP PFNGLXGETCURRENTDISPLAYEXTPROC)();
+GLAPI PFNGLXGETCURRENTDISPLAYEXTPROC glad_glXGetCurrentDisplayEXT;
+#define glXGetCurrentDisplayEXT glad_glXGetCurrentDisplayEXT
+typedef int (APIENTRYP PFNGLXQUERYCONTEXTINFOEXTPROC)(Display *dpy, GLXContext context, int attribute, int *value);
+GLAPI PFNGLXQUERYCONTEXTINFOEXTPROC glad_glXQueryContextInfoEXT;
+#define glXQueryContextInfoEXT glad_glXQueryContextInfoEXT
+typedef GLXContextID (APIENTRYP PFNGLXGETCONTEXTIDEXTPROC)(const GLXContext context);
+GLAPI PFNGLXGETCONTEXTIDEXTPROC glad_glXGetContextIDEXT;
+#define glXGetContextIDEXT glad_glXGetContextIDEXT
+typedef GLXContext (APIENTRYP PFNGLXIMPORTCONTEXTEXTPROC)(Display *dpy, GLXContextID contextID);
+GLAPI PFNGLXIMPORTCONTEXTEXTPROC glad_glXImportContextEXT;
+#define glXImportContextEXT glad_glXImportContextEXT
+typedef void (APIENTRYP PFNGLXFREECONTEXTEXTPROC)(Display *dpy, GLXContext context);
+GLAPI PFNGLXFREECONTEXTEXTPROC glad_glXFreeContextEXT;
+#define glXFreeContextEXT glad_glXFreeContextEXT
+#endif
+#ifndef GLX_EXT_libglvnd
+#define GLX_EXT_libglvnd 1
+GLAPI int GLAD_GLX_EXT_libglvnd;
+#endif
+#ifndef GLX_EXT_stereo_tree
+#define GLX_EXT_stereo_tree 1
+GLAPI int GLAD_GLX_EXT_stereo_tree;
+#endif
+#ifndef GLX_EXT_swap_control
+#define GLX_EXT_swap_control 1
+GLAPI int GLAD_GLX_EXT_swap_control;
+typedef void (APIENTRYP PFNGLXSWAPINTERVALEXTPROC)(Display *dpy, GLXDrawable drawable, int interval);
+GLAPI PFNGLXSWAPINTERVALEXTPROC glad_glXSwapIntervalEXT;
+#define glXSwapIntervalEXT glad_glXSwapIntervalEXT
+#endif
+#ifndef GLX_EXT_swap_control_tear
+#define GLX_EXT_swap_control_tear 1
+GLAPI int GLAD_GLX_EXT_swap_control_tear;
+#endif
+#ifndef GLX_EXT_texture_from_pixmap
+#define GLX_EXT_texture_from_pixmap 1
+GLAPI int GLAD_GLX_EXT_texture_from_pixmap;
+typedef void (APIENTRYP PFNGLXBINDTEXIMAGEEXTPROC)(Display *dpy, GLXDrawable drawable, int buffer, const int *attrib_list);
+GLAPI PFNGLXBINDTEXIMAGEEXTPROC glad_glXBindTexImageEXT;
+#define glXBindTexImageEXT glad_glXBindTexImageEXT
+typedef void (APIENTRYP PFNGLXRELEASETEXIMAGEEXTPROC)(Display *dpy, GLXDrawable drawable, int buffer);
+GLAPI PFNGLXRELEASETEXIMAGEEXTPROC glad_glXReleaseTexImageEXT;
+#define glXReleaseTexImageEXT glad_glXReleaseTexImageEXT
+#endif
+#ifndef GLX_EXT_visual_info
+#define GLX_EXT_visual_info 1
+GLAPI int GLAD_GLX_EXT_visual_info;
+#endif
+#ifndef GLX_EXT_visual_rating
+#define GLX_EXT_visual_rating 1
+GLAPI int GLAD_GLX_EXT_visual_rating;
+#endif
+#ifndef GLX_INTEL_swap_event
+#define GLX_INTEL_swap_event 1
+GLAPI int GLAD_GLX_INTEL_swap_event;
+#endif
+#ifndef GLX_MESA_agp_offset
+#define GLX_MESA_agp_offset 1
+GLAPI int GLAD_GLX_MESA_agp_offset;
+typedef unsigned int (APIENTRYP PFNGLXGETAGPOFFSETMESAPROC)(const void *pointer);
+GLAPI PFNGLXGETAGPOFFSETMESAPROC glad_glXGetAGPOffsetMESA;
+#define glXGetAGPOffsetMESA glad_glXGetAGPOffsetMESA
+#endif
+#ifndef GLX_MESA_copy_sub_buffer
+#define GLX_MESA_copy_sub_buffer 1
+GLAPI int GLAD_GLX_MESA_copy_sub_buffer;
+typedef void (APIENTRYP PFNGLXCOPYSUBBUFFERMESAPROC)(Display *dpy, GLXDrawable drawable, int x, int y, int width, int height);
+GLAPI PFNGLXCOPYSUBBUFFERMESAPROC glad_glXCopySubBufferMESA;
+#define glXCopySubBufferMESA glad_glXCopySubBufferMESA
+#endif
+#ifndef GLX_MESA_pixmap_colormap
+#define GLX_MESA_pixmap_colormap 1
+GLAPI int GLAD_GLX_MESA_pixmap_colormap;
+typedef GLXPixmap (APIENTRYP PFNGLXCREATEGLXPIXMAPMESAPROC)(Display *dpy, XVisualInfo *visual, Pixmap pixmap, Colormap cmap);
+GLAPI PFNGLXCREATEGLXPIXMAPMESAPROC glad_glXCreateGLXPixmapMESA;
+#define glXCreateGLXPixmapMESA glad_glXCreateGLXPixmapMESA
+#endif
+#ifndef GLX_MESA_query_renderer
+#define GLX_MESA_query_renderer 1
+GLAPI int GLAD_GLX_MESA_query_renderer;
+typedef Bool (APIENTRYP PFNGLXQUERYCURRENTRENDERERINTEGERMESAPROC)(int attribute, unsigned int *value);
+GLAPI PFNGLXQUERYCURRENTRENDERERINTEGERMESAPROC glad_glXQueryCurrentRendererIntegerMESA;
+#define glXQueryCurrentRendererIntegerMESA glad_glXQueryCurrentRendererIntegerMESA
+typedef const char * (APIENTRYP PFNGLXQUERYCURRENTRENDERERSTRINGMESAPROC)(int attribute);
+GLAPI PFNGLXQUERYCURRENTRENDERERSTRINGMESAPROC glad_glXQueryCurrentRendererStringMESA;
+#define glXQueryCurrentRendererStringMESA glad_glXQueryCurrentRendererStringMESA
+typedef Bool (APIENTRYP PFNGLXQUERYRENDERERINTEGERMESAPROC)(Display *dpy, int screen, int renderer, int attribute, unsigned int *value);
+GLAPI PFNGLXQUERYRENDERERINTEGERMESAPROC glad_glXQueryRendererIntegerMESA;
+#define glXQueryRendererIntegerMESA glad_glXQueryRendererIntegerMESA
+typedef const char * (APIENTRYP PFNGLXQUERYRENDERERSTRINGMESAPROC)(Display *dpy, int screen, int renderer, int attribute);
+GLAPI PFNGLXQUERYRENDERERSTRINGMESAPROC glad_glXQueryRendererStringMESA;
+#define glXQueryRendererStringMESA glad_glXQueryRendererStringMESA
+#endif
+#ifndef GLX_MESA_release_buffers
+#define GLX_MESA_release_buffers 1
+GLAPI int GLAD_GLX_MESA_release_buffers;
+typedef Bool (APIENTRYP PFNGLXRELEASEBUFFERSMESAPROC)(Display *dpy, GLXDrawable drawable);
+GLAPI PFNGLXRELEASEBUFFERSMESAPROC glad_glXReleaseBuffersMESA;
+#define glXReleaseBuffersMESA glad_glXReleaseBuffersMESA
+#endif
+#ifndef GLX_MESA_set_3dfx_mode
+#define GLX_MESA_set_3dfx_mode 1
+GLAPI int GLAD_GLX_MESA_set_3dfx_mode;
+typedef Bool (APIENTRYP PFNGLXSET3DFXMODEMESAPROC)(int mode);
+GLAPI PFNGLXSET3DFXMODEMESAPROC glad_glXSet3DfxModeMESA;
+#define glXSet3DfxModeMESA glad_glXSet3DfxModeMESA
+#endif
+#ifndef GLX_NV_copy_buffer
+#define GLX_NV_copy_buffer 1
+GLAPI int GLAD_GLX_NV_copy_buffer;
+typedef void (APIENTRYP PFNGLXCOPYBUFFERSUBDATANVPROC)(Display *dpy, GLXContext readCtx, GLXContext writeCtx, GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size);
+GLAPI PFNGLXCOPYBUFFERSUBDATANVPROC glad_glXCopyBufferSubDataNV;
+#define glXCopyBufferSubDataNV glad_glXCopyBufferSubDataNV
+typedef void (APIENTRYP PFNGLXNAMEDCOPYBUFFERSUBDATANVPROC)(Display *dpy, GLXContext readCtx, GLXContext writeCtx, GLuint readBuffer, GLuint writeBuffer, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size);
+GLAPI PFNGLXNAMEDCOPYBUFFERSUBDATANVPROC glad_glXNamedCopyBufferSubDataNV;
+#define glXNamedCopyBufferSubDataNV glad_glXNamedCopyBufferSubDataNV
+#endif
+#ifndef GLX_NV_copy_image
+#define GLX_NV_copy_image 1
+GLAPI int GLAD_GLX_NV_copy_image;
+typedef void (APIENTRYP PFNGLXCOPYIMAGESUBDATANVPROC)(Display *dpy, GLXContext srcCtx, GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLXContext dstCtx, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei width, GLsizei height, GLsizei depth);
+GLAPI PFNGLXCOPYIMAGESUBDATANVPROC glad_glXCopyImageSubDataNV;
+#define glXCopyImageSubDataNV glad_glXCopyImageSubDataNV
+#endif
+#ifndef GLX_NV_delay_before_swap
+#define GLX_NV_delay_before_swap 1
+GLAPI int GLAD_GLX_NV_delay_before_swap;
+typedef Bool (APIENTRYP PFNGLXDELAYBEFORESWAPNVPROC)(Display *dpy, GLXDrawable drawable, GLfloat seconds);
+GLAPI PFNGLXDELAYBEFORESWAPNVPROC glad_glXDelayBeforeSwapNV;
+#define glXDelayBeforeSwapNV glad_glXDelayBeforeSwapNV
+#endif
+#ifndef GLX_NV_float_buffer
+#define GLX_NV_float_buffer 1
+GLAPI int GLAD_GLX_NV_float_buffer;
+#endif
+#ifndef GLX_NV_multisample_coverage
+#define GLX_NV_multisample_coverage 1
+GLAPI int GLAD_GLX_NV_multisample_coverage;
+#endif
+#ifndef GLX_NV_present_video
+#define GLX_NV_present_video 1
+GLAPI int GLAD_GLX_NV_present_video;
+typedef unsigned int * (APIENTRYP PFNGLXENUMERATEVIDEODEVICESNVPROC)(Display *dpy, int screen, int *nelements);
+GLAPI PFNGLXENUMERATEVIDEODEVICESNVPROC glad_glXEnumerateVideoDevicesNV;
+#define glXEnumerateVideoDevicesNV glad_glXEnumerateVideoDevicesNV
+typedef int (APIENTRYP PFNGLXBINDVIDEODEVICENVPROC)(Display *dpy, unsigned int video_slot, unsigned int video_device, const int *attrib_list);
+GLAPI PFNGLXBINDVIDEODEVICENVPROC glad_glXBindVideoDeviceNV;
+#define glXBindVideoDeviceNV glad_glXBindVideoDeviceNV
+#endif
+#ifndef GLX_NV_robustness_video_memory_purge
+#define GLX_NV_robustness_video_memory_purge 1
+GLAPI int GLAD_GLX_NV_robustness_video_memory_purge;
+#endif
+#ifndef GLX_NV_swap_group
+#define GLX_NV_swap_group 1
+GLAPI int GLAD_GLX_NV_swap_group;
+typedef Bool (APIENTRYP PFNGLXJOINSWAPGROUPNVPROC)(Display *dpy, GLXDrawable drawable, GLuint group);
+GLAPI PFNGLXJOINSWAPGROUPNVPROC glad_glXJoinSwapGroupNV;
+#define glXJoinSwapGroupNV glad_glXJoinSwapGroupNV
+typedef Bool (APIENTRYP PFNGLXBINDSWAPBARRIERNVPROC)(Display *dpy, GLuint group, GLuint barrier);
+GLAPI PFNGLXBINDSWAPBARRIERNVPROC glad_glXBindSwapBarrierNV;
+#define glXBindSwapBarrierNV glad_glXBindSwapBarrierNV
+typedef Bool (APIENTRYP PFNGLXQUERYSWAPGROUPNVPROC)(Display *dpy, GLXDrawable drawable, GLuint *group, GLuint *barrier);
+GLAPI PFNGLXQUERYSWAPGROUPNVPROC glad_glXQuerySwapGroupNV;
+#define glXQuerySwapGroupNV glad_glXQuerySwapGroupNV
+typedef Bool (APIENTRYP PFNGLXQUERYMAXSWAPGROUPSNVPROC)(Display *dpy, int screen, GLuint *maxGroups, GLuint *maxBarriers);
+GLAPI PFNGLXQUERYMAXSWAPGROUPSNVPROC glad_glXQueryMaxSwapGroupsNV;
+#define glXQueryMaxSwapGroupsNV glad_glXQueryMaxSwapGroupsNV
+typedef Bool (APIENTRYP PFNGLXQUERYFRAMECOUNTNVPROC)(Display *dpy, int screen, GLuint *count);
+GLAPI PFNGLXQUERYFRAMECOUNTNVPROC glad_glXQueryFrameCountNV;
+#define glXQueryFrameCountNV glad_glXQueryFrameCountNV
+typedef Bool (APIENTRYP PFNGLXRESETFRAMECOUNTNVPROC)(Display *dpy, int screen);
+GLAPI PFNGLXRESETFRAMECOUNTNVPROC glad_glXResetFrameCountNV;
+#define glXResetFrameCountNV glad_glXResetFrameCountNV
+#endif
+#ifndef GLX_NV_video_capture
+#define GLX_NV_video_capture 1
+GLAPI int GLAD_GLX_NV_video_capture;
+typedef int (APIENTRYP PFNGLXBINDVIDEOCAPTUREDEVICENVPROC)(Display *dpy, unsigned int video_capture_slot, GLXVideoCaptureDeviceNV device);
+GLAPI PFNGLXBINDVIDEOCAPTUREDEVICENVPROC glad_glXBindVideoCaptureDeviceNV;
+#define glXBindVideoCaptureDeviceNV glad_glXBindVideoCaptureDeviceNV
+typedef GLXVideoCaptureDeviceNV * (APIENTRYP PFNGLXENUMERATEVIDEOCAPTUREDEVICESNVPROC)(Display *dpy, int screen, int *nelements);
+GLAPI PFNGLXENUMERATEVIDEOCAPTUREDEVICESNVPROC glad_glXEnumerateVideoCaptureDevicesNV;
+#define glXEnumerateVideoCaptureDevicesNV glad_glXEnumerateVideoCaptureDevicesNV
+typedef void (APIENTRYP PFNGLXLOCKVIDEOCAPTUREDEVICENVPROC)(Display *dpy, GLXVideoCaptureDeviceNV device);
+GLAPI PFNGLXLOCKVIDEOCAPTUREDEVICENVPROC glad_glXLockVideoCaptureDeviceNV;
+#define glXLockVideoCaptureDeviceNV glad_glXLockVideoCaptureDeviceNV
+typedef int (APIENTRYP PFNGLXQUERYVIDEOCAPTUREDEVICENVPROC)(Display *dpy, GLXVideoCaptureDeviceNV device, int attribute, int *value);
+GLAPI PFNGLXQUERYVIDEOCAPTUREDEVICENVPROC glad_glXQueryVideoCaptureDeviceNV;
+#define glXQueryVideoCaptureDeviceNV glad_glXQueryVideoCaptureDeviceNV
+typedef void (APIENTRYP PFNGLXRELEASEVIDEOCAPTUREDEVICENVPROC)(Display *dpy, GLXVideoCaptureDeviceNV device);
+GLAPI PFNGLXRELEASEVIDEOCAPTUREDEVICENVPROC glad_glXReleaseVideoCaptureDeviceNV;
+#define glXReleaseVideoCaptureDeviceNV glad_glXReleaseVideoCaptureDeviceNV
+#endif
+#ifndef GLX_NV_video_out
+#define GLX_NV_video_out 1
+GLAPI int GLAD_GLX_NV_video_out;
+typedef int (APIENTRYP PFNGLXGETVIDEODEVICENVPROC)(Display *dpy, int screen, int numVideoDevices, GLXVideoDeviceNV *pVideoDevice);
+GLAPI PFNGLXGETVIDEODEVICENVPROC glad_glXGetVideoDeviceNV;
+#define glXGetVideoDeviceNV glad_glXGetVideoDeviceNV
+typedef int (APIENTRYP PFNGLXRELEASEVIDEODEVICENVPROC)(Display *dpy, int screen, GLXVideoDeviceNV VideoDevice);
+GLAPI PFNGLXRELEASEVIDEODEVICENVPROC glad_glXReleaseVideoDeviceNV;
+#define glXReleaseVideoDeviceNV glad_glXReleaseVideoDeviceNV
+typedef int (APIENTRYP PFNGLXBINDVIDEOIMAGENVPROC)(Display *dpy, GLXVideoDeviceNV VideoDevice, GLXPbuffer pbuf, int iVideoBuffer);
+GLAPI PFNGLXBINDVIDEOIMAGENVPROC glad_glXBindVideoImageNV;
+#define glXBindVideoImageNV glad_glXBindVideoImageNV
+typedef int (APIENTRYP PFNGLXRELEASEVIDEOIMAGENVPROC)(Display *dpy, GLXPbuffer pbuf);
+GLAPI PFNGLXRELEASEVIDEOIMAGENVPROC glad_glXReleaseVideoImageNV;
+#define glXReleaseVideoImageNV glad_glXReleaseVideoImageNV
+typedef int (APIENTRYP PFNGLXSENDPBUFFERTOVIDEONVPROC)(Display *dpy, GLXPbuffer pbuf, int iBufferType, unsigned long *pulCounterPbuffer, GLboolean bBlock);
+GLAPI PFNGLXSENDPBUFFERTOVIDEONVPROC glad_glXSendPbufferToVideoNV;
+#define glXSendPbufferToVideoNV glad_glXSendPbufferToVideoNV
+typedef int (APIENTRYP PFNGLXGETVIDEOINFONVPROC)(Display *dpy, int screen, GLXVideoDeviceNV VideoDevice, unsigned long *pulCounterOutputPbuffer, unsigned long *pulCounterOutputVideo);
+GLAPI PFNGLXGETVIDEOINFONVPROC glad_glXGetVideoInfoNV;
+#define glXGetVideoInfoNV glad_glXGetVideoInfoNV
+#endif
+#ifndef GLX_OML_swap_method
+#define GLX_OML_swap_method 1
+GLAPI int GLAD_GLX_OML_swap_method;
+#endif
+#ifndef GLX_OML_sync_control
+#define GLX_OML_sync_control 1
+GLAPI int GLAD_GLX_OML_sync_control;
+typedef Bool (APIENTRYP PFNGLXGETSYNCVALUESOMLPROC)(Display *dpy, GLXDrawable drawable, int64_t *ust, int64_t *msc, int64_t *sbc);
+GLAPI PFNGLXGETSYNCVALUESOMLPROC glad_glXGetSyncValuesOML;
+#define glXGetSyncValuesOML glad_glXGetSyncValuesOML
+typedef Bool (APIENTRYP PFNGLXGETMSCRATEOMLPROC)(Display *dpy, GLXDrawable drawable, int32_t *numerator, int32_t *denominator);
+GLAPI PFNGLXGETMSCRATEOMLPROC glad_glXGetMscRateOML;
+#define glXGetMscRateOML glad_glXGetMscRateOML
+typedef int64_t (APIENTRYP PFNGLXSWAPBUFFERSMSCOMLPROC)(Display *dpy, GLXDrawable drawable, int64_t target_msc, int64_t divisor, int64_t remainder);
+GLAPI PFNGLXSWAPBUFFERSMSCOMLPROC glad_glXSwapBuffersMscOML;
+#define glXSwapBuffersMscOML glad_glXSwapBuffersMscOML
+typedef Bool (APIENTRYP PFNGLXWAITFORMSCOMLPROC)(Display *dpy, GLXDrawable drawable, int64_t target_msc, int64_t divisor, int64_t remainder, int64_t *ust, int64_t *msc, int64_t *sbc);
+GLAPI PFNGLXWAITFORMSCOMLPROC glad_glXWaitForMscOML;
+#define glXWaitForMscOML glad_glXWaitForMscOML
+typedef Bool (APIENTRYP PFNGLXWAITFORSBCOMLPROC)(Display *dpy, GLXDrawable drawable, int64_t target_sbc, int64_t *ust, int64_t *msc, int64_t *sbc);
+GLAPI PFNGLXWAITFORSBCOMLPROC glad_glXWaitForSbcOML;
+#define glXWaitForSbcOML glad_glXWaitForSbcOML
+#endif
+#ifndef GLX_SGIS_blended_overlay
+#define GLX_SGIS_blended_overlay 1
+GLAPI int GLAD_GLX_SGIS_blended_overlay;
+#endif
+#ifndef GLX_SGIS_multisample
+#define GLX_SGIS_multisample 1
+GLAPI int GLAD_GLX_SGIS_multisample;
+#endif
+#ifndef GLX_SGIS_shared_multisample
+#define GLX_SGIS_shared_multisample 1
+GLAPI int GLAD_GLX_SGIS_shared_multisample;
+#endif
+#ifndef GLX_SGIX_dmbuffer
+#define GLX_SGIX_dmbuffer 1
+GLAPI int GLAD_GLX_SGIX_dmbuffer;
+#ifdef _DM_BUFFER_H_
+typedef Bool (APIENTRYP PFNGLXASSOCIATEDMPBUFFERSGIXPROC)(Display *dpy, GLXPbufferSGIX pbuffer, DMparams *params, DMbuffer dmbuffer);
+GLAPI PFNGLXASSOCIATEDMPBUFFERSGIXPROC glad_glXAssociateDMPbufferSGIX;
+#define glXAssociateDMPbufferSGIX glad_glXAssociateDMPbufferSGIX
+#endif
+#endif
+#ifndef GLX_SGIX_fbconfig
+#define GLX_SGIX_fbconfig 1
+GLAPI int GLAD_GLX_SGIX_fbconfig;
+typedef int (APIENTRYP PFNGLXGETFBCONFIGATTRIBSGIXPROC)(Display *dpy, GLXFBConfigSGIX config, int attribute, int *value);
+GLAPI PFNGLXGETFBCONFIGATTRIBSGIXPROC glad_glXGetFBConfigAttribSGIX;
+#define glXGetFBConfigAttribSGIX glad_glXGetFBConfigAttribSGIX
+typedef GLXFBConfigSGIX * (APIENTRYP PFNGLXCHOOSEFBCONFIGSGIXPROC)(Display *dpy, int screen, int *attrib_list, int *nelements);
+GLAPI PFNGLXCHOOSEFBCONFIGSGIXPROC glad_glXChooseFBConfigSGIX;
+#define glXChooseFBConfigSGIX glad_glXChooseFBConfigSGIX
+typedef GLXPixmap (APIENTRYP PFNGLXCREATEGLXPIXMAPWITHCONFIGSGIXPROC)(Display *dpy, GLXFBConfigSGIX config, Pixmap pixmap);
+GLAPI PFNGLXCREATEGLXPIXMAPWITHCONFIGSGIXPROC glad_glXCreateGLXPixmapWithConfigSGIX;
+#define glXCreateGLXPixmapWithConfigSGIX glad_glXCreateGLXPixmapWithConfigSGIX
+typedef GLXContext (APIENTRYP PFNGLXCREATECONTEXTWITHCONFIGSGIXPROC)(Display *dpy, GLXFBConfigSGIX config, int render_type, GLXContext share_list, Bool direct);
+GLAPI PFNGLXCREATECONTEXTWITHCONFIGSGIXPROC glad_glXCreateContextWithConfigSGIX;
+#define glXCreateContextWithConfigSGIX glad_glXCreateContextWithConfigSGIX
+typedef XVisualInfo * (APIENTRYP PFNGLXGETVISUALFROMFBCONFIGSGIXPROC)(Display *dpy, GLXFBConfigSGIX config);
+GLAPI PFNGLXGETVISUALFROMFBCONFIGSGIXPROC glad_glXGetVisualFromFBConfigSGIX;
+#define glXGetVisualFromFBConfigSGIX glad_glXGetVisualFromFBConfigSGIX
+typedef GLXFBConfigSGIX (APIENTRYP PFNGLXGETFBCONFIGFROMVISUALSGIXPROC)(Display *dpy, XVisualInfo *vis);
+GLAPI PFNGLXGETFBCONFIGFROMVISUALSGIXPROC glad_glXGetFBConfigFromVisualSGIX;
+#define glXGetFBConfigFromVisualSGIX glad_glXGetFBConfigFromVisualSGIX
+#endif
+#ifndef GLX_SGIX_hyperpipe
+#define GLX_SGIX_hyperpipe 1
+GLAPI int GLAD_GLX_SGIX_hyperpipe;
+typedef GLXHyperpipeNetworkSGIX * (APIENTRYP PFNGLXQUERYHYPERPIPENETWORKSGIXPROC)(Display *dpy, int *npipes);
+GLAPI PFNGLXQUERYHYPERPIPENETWORKSGIXPROC glad_glXQueryHyperpipeNetworkSGIX;
+#define glXQueryHyperpipeNetworkSGIX glad_glXQueryHyperpipeNetworkSGIX
+typedef int (APIENTRYP PFNGLXHYPERPIPECONFIGSGIXPROC)(Display *dpy, int networkId, int npipes, GLXHyperpipeConfigSGIX *cfg, int *hpId);
+GLAPI PFNGLXHYPERPIPECONFIGSGIXPROC glad_glXHyperpipeConfigSGIX;
+#define glXHyperpipeConfigSGIX glad_glXHyperpipeConfigSGIX
+typedef GLXHyperpipeConfigSGIX * (APIENTRYP PFNGLXQUERYHYPERPIPECONFIGSGIXPROC)(Display *dpy, int hpId, int *npipes);
+GLAPI PFNGLXQUERYHYPERPIPECONFIGSGIXPROC glad_glXQueryHyperpipeConfigSGIX;
+#define glXQueryHyperpipeConfigSGIX glad_glXQueryHyperpipeConfigSGIX
+typedef int (APIENTRYP PFNGLXDESTROYHYPERPIPECONFIGSGIXPROC)(Display *dpy, int hpId);
+GLAPI PFNGLXDESTROYHYPERPIPECONFIGSGIXPROC glad_glXDestroyHyperpipeConfigSGIX;
+#define glXDestroyHyperpipeConfigSGIX glad_glXDestroyHyperpipeConfigSGIX
+typedef int (APIENTRYP PFNGLXBINDHYPERPIPESGIXPROC)(Display *dpy, int hpId);
+GLAPI PFNGLXBINDHYPERPIPESGIXPROC glad_glXBindHyperpipeSGIX;
+#define glXBindHyperpipeSGIX glad_glXBindHyperpipeSGIX
+typedef int (APIENTRYP PFNGLXQUERYHYPERPIPEBESTATTRIBSGIXPROC)(Display *dpy, int timeSlice, int attrib, int size, void *attribList, void *returnAttribList);
+GLAPI PFNGLXQUERYHYPERPIPEBESTATTRIBSGIXPROC glad_glXQueryHyperpipeBestAttribSGIX;
+#define glXQueryHyperpipeBestAttribSGIX glad_glXQueryHyperpipeBestAttribSGIX
+typedef int (APIENTRYP PFNGLXHYPERPIPEATTRIBSGIXPROC)(Display *dpy, int timeSlice, int attrib, int size, void *attribList);
+GLAPI PFNGLXHYPERPIPEATTRIBSGIXPROC glad_glXHyperpipeAttribSGIX;
+#define glXHyperpipeAttribSGIX glad_glXHyperpipeAttribSGIX
+typedef int (APIENTRYP PFNGLXQUERYHYPERPIPEATTRIBSGIXPROC)(Display *dpy, int timeSlice, int attrib, int size, void *returnAttribList);
+GLAPI PFNGLXQUERYHYPERPIPEATTRIBSGIXPROC glad_glXQueryHyperpipeAttribSGIX;
+#define glXQueryHyperpipeAttribSGIX glad_glXQueryHyperpipeAttribSGIX
+#endif
+#ifndef GLX_SGIX_pbuffer
+#define GLX_SGIX_pbuffer 1
+GLAPI int GLAD_GLX_SGIX_pbuffer;
+typedef GLXPbufferSGIX (APIENTRYP PFNGLXCREATEGLXPBUFFERSGIXPROC)(Display *dpy, GLXFBConfigSGIX config, unsigned int width, unsigned int height, int *attrib_list);
+GLAPI PFNGLXCREATEGLXPBUFFERSGIXPROC glad_glXCreateGLXPbufferSGIX;
+#define glXCreateGLXPbufferSGIX glad_glXCreateGLXPbufferSGIX
+typedef void (APIENTRYP PFNGLXDESTROYGLXPBUFFERSGIXPROC)(Display *dpy, GLXPbufferSGIX pbuf);
+GLAPI PFNGLXDESTROYGLXPBUFFERSGIXPROC glad_glXDestroyGLXPbufferSGIX;
+#define glXDestroyGLXPbufferSGIX glad_glXDestroyGLXPbufferSGIX
+typedef int (APIENTRYP PFNGLXQUERYGLXPBUFFERSGIXPROC)(Display *dpy, GLXPbufferSGIX pbuf, int attribute, unsigned int *value);
+GLAPI PFNGLXQUERYGLXPBUFFERSGIXPROC glad_glXQueryGLXPbufferSGIX;
+#define glXQueryGLXPbufferSGIX glad_glXQueryGLXPbufferSGIX
+typedef void (APIENTRYP PFNGLXSELECTEVENTSGIXPROC)(Display *dpy, GLXDrawable drawable, unsigned long mask);
+GLAPI PFNGLXSELECTEVENTSGIXPROC glad_glXSelectEventSGIX;
+#define glXSelectEventSGIX glad_glXSelectEventSGIX
+typedef void (APIENTRYP PFNGLXGETSELECTEDEVENTSGIXPROC)(Display *dpy, GLXDrawable drawable, unsigned long *mask);
+GLAPI PFNGLXGETSELECTEDEVENTSGIXPROC glad_glXGetSelectedEventSGIX;
+#define glXGetSelectedEventSGIX glad_glXGetSelectedEventSGIX
+#endif
+#ifndef GLX_SGIX_swap_barrier
+#define GLX_SGIX_swap_barrier 1
+GLAPI int GLAD_GLX_SGIX_swap_barrier;
+typedef void (APIENTRYP PFNGLXBINDSWAPBARRIERSGIXPROC)(Display *dpy, GLXDrawable drawable, int barrier);
+GLAPI PFNGLXBINDSWAPBARRIERSGIXPROC glad_glXBindSwapBarrierSGIX;
+#define glXBindSwapBarrierSGIX glad_glXBindSwapBarrierSGIX
+typedef Bool (APIENTRYP PFNGLXQUERYMAXSWAPBARRIERSSGIXPROC)(Display *dpy, int screen, int *max);
+GLAPI PFNGLXQUERYMAXSWAPBARRIERSSGIXPROC glad_glXQueryMaxSwapBarriersSGIX;
+#define glXQueryMaxSwapBarriersSGIX glad_glXQueryMaxSwapBarriersSGIX
+#endif
+#ifndef GLX_SGIX_swap_group
+#define GLX_SGIX_swap_group 1
+GLAPI int GLAD_GLX_SGIX_swap_group;
+typedef void (APIENTRYP PFNGLXJOINSWAPGROUPSGIXPROC)(Display *dpy, GLXDrawable drawable, GLXDrawable member);
+GLAPI PFNGLXJOINSWAPGROUPSGIXPROC glad_glXJoinSwapGroupSGIX;
+#define glXJoinSwapGroupSGIX glad_glXJoinSwapGroupSGIX
+#endif
+#ifndef GLX_SGIX_video_resize
+#define GLX_SGIX_video_resize 1
+GLAPI int GLAD_GLX_SGIX_video_resize;
+typedef int (APIENTRYP PFNGLXBINDCHANNELTOWINDOWSGIXPROC)(Display *display, int screen, int channel, Window window);
+GLAPI PFNGLXBINDCHANNELTOWINDOWSGIXPROC glad_glXBindChannelToWindowSGIX;
+#define glXBindChannelToWindowSGIX glad_glXBindChannelToWindowSGIX
+typedef int (APIENTRYP PFNGLXCHANNELRECTSGIXPROC)(Display *display, int screen, int channel, int x, int y, int w, int h);
+GLAPI PFNGLXCHANNELRECTSGIXPROC glad_glXChannelRectSGIX;
+#define glXChannelRectSGIX glad_glXChannelRectSGIX
+typedef int (APIENTRYP PFNGLXQUERYCHANNELRECTSGIXPROC)(Display *display, int screen, int channel, int *dx, int *dy, int *dw, int *dh);
+GLAPI PFNGLXQUERYCHANNELRECTSGIXPROC glad_glXQueryChannelRectSGIX;
+#define glXQueryChannelRectSGIX glad_glXQueryChannelRectSGIX
+typedef int (APIENTRYP PFNGLXQUERYCHANNELDELTASSGIXPROC)(Display *display, int screen, int channel, int *x, int *y, int *w, int *h);
+GLAPI PFNGLXQUERYCHANNELDELTASSGIXPROC glad_glXQueryChannelDeltasSGIX;
+#define glXQueryChannelDeltasSGIX glad_glXQueryChannelDeltasSGIX
+typedef int (APIENTRYP PFNGLXCHANNELRECTSYNCSGIXPROC)(Display *display, int screen, int channel, GLenum synctype);
+GLAPI PFNGLXCHANNELRECTSYNCSGIXPROC glad_glXChannelRectSyncSGIX;
+#define glXChannelRectSyncSGIX glad_glXChannelRectSyncSGIX
+#endif
+#ifndef GLX_SGIX_video_source
+#define GLX_SGIX_video_source 1
+GLAPI int GLAD_GLX_SGIX_video_source;
+#ifdef _VL_H_
+typedef GLXVideoSourceSGIX (APIENTRYP PFNGLXCREATEGLXVIDEOSOURCESGIXPROC)(Display *display, int screen, VLServer server, VLPath path, int nodeClass, VLNode drainNode);
+GLAPI PFNGLXCREATEGLXVIDEOSOURCESGIXPROC glad_glXCreateGLXVideoSourceSGIX;
+#define glXCreateGLXVideoSourceSGIX glad_glXCreateGLXVideoSourceSGIX
+typedef void (APIENTRYP PFNGLXDESTROYGLXVIDEOSOURCESGIXPROC)(Display *dpy, GLXVideoSourceSGIX glxvideosource);
+GLAPI PFNGLXDESTROYGLXVIDEOSOURCESGIXPROC glad_glXDestroyGLXVideoSourceSGIX;
+#define glXDestroyGLXVideoSourceSGIX glad_glXDestroyGLXVideoSourceSGIX
+#endif
+#endif
+#ifndef GLX_SGIX_visual_select_group
+#define GLX_SGIX_visual_select_group 1
+GLAPI int GLAD_GLX_SGIX_visual_select_group;
+#endif
+#ifndef GLX_SGI_cushion
+#define GLX_SGI_cushion 1
+GLAPI int GLAD_GLX_SGI_cushion;
+typedef void (APIENTRYP PFNGLXCUSHIONSGIPROC)(Display *dpy, Window window, float cushion);
+GLAPI PFNGLXCUSHIONSGIPROC glad_glXCushionSGI;
+#define glXCushionSGI glad_glXCushionSGI
+#endif
+#ifndef GLX_SGI_make_current_read
+#define GLX_SGI_make_current_read 1
+GLAPI int GLAD_GLX_SGI_make_current_read;
+typedef Bool (APIENTRYP PFNGLXMAKECURRENTREADSGIPROC)(Display *dpy, GLXDrawable draw, GLXDrawable read, GLXContext ctx);
+GLAPI PFNGLXMAKECURRENTREADSGIPROC glad_glXMakeCurrentReadSGI;
+#define glXMakeCurrentReadSGI glad_glXMakeCurrentReadSGI
+typedef GLXDrawable (APIENTRYP PFNGLXGETCURRENTREADDRAWABLESGIPROC)();
+GLAPI PFNGLXGETCURRENTREADDRAWABLESGIPROC glad_glXGetCurrentReadDrawableSGI;
+#define glXGetCurrentReadDrawableSGI glad_glXGetCurrentReadDrawableSGI
+#endif
+#ifndef GLX_SGI_swap_control
+#define GLX_SGI_swap_control 1
+GLAPI int GLAD_GLX_SGI_swap_control;
+typedef int (APIENTRYP PFNGLXSWAPINTERVALSGIPROC)(int interval);
+GLAPI PFNGLXSWAPINTERVALSGIPROC glad_glXSwapIntervalSGI;
+#define glXSwapIntervalSGI glad_glXSwapIntervalSGI
+#endif
+#ifndef GLX_SGI_video_sync
+#define GLX_SGI_video_sync 1
+GLAPI int GLAD_GLX_SGI_video_sync;
+typedef int (APIENTRYP PFNGLXGETVIDEOSYNCSGIPROC)(unsigned int *count);
+GLAPI PFNGLXGETVIDEOSYNCSGIPROC glad_glXGetVideoSyncSGI;
+#define glXGetVideoSyncSGI glad_glXGetVideoSyncSGI
+typedef int (APIENTRYP PFNGLXWAITVIDEOSYNCSGIPROC)(int divisor, int remainder, unsigned int *count);
+GLAPI PFNGLXWAITVIDEOSYNCSGIPROC glad_glXWaitVideoSyncSGI;
+#define glXWaitVideoSyncSGI glad_glXWaitVideoSyncSGI
+#endif
+#ifndef GLX_SUN_get_transparent_index
+#define GLX_SUN_get_transparent_index 1
+GLAPI int GLAD_GLX_SUN_get_transparent_index;
+typedef Status (APIENTRYP PFNGLXGETTRANSPARENTINDEXSUNPROC)(Display *dpy, Window overlay, Window underlay, long *pTransparentIndex);
+GLAPI PFNGLXGETTRANSPARENTINDEXSUNPROC glad_glXGetTransparentIndexSUN;
+#define glXGetTransparentIndexSUN glad_glXGetTransparentIndexSUN
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

Engine/lib/glad/include/glad/glad_wgl.h

@@ -0,0 +1,980 @@
+/*
+
+    WGL loader generated by glad 0.1.12a0 on Mon Sep 12 03:11:07 2016.
+
+    Language/Generator: C/C++
+    Specification: wgl
+    APIs: wgl=1.0
+    Profile: -
+    Extensions:
+        WGL_3DFX_multisample,
+        WGL_3DL_stereo_control,
+        WGL_AMD_gpu_association,
+        WGL_ARB_buffer_region,
+        WGL_ARB_context_flush_control,
+        WGL_ARB_create_context,
+        WGL_ARB_create_context_profile,
+        WGL_ARB_create_context_robustness,
+        WGL_ARB_extensions_string,
+        WGL_ARB_framebuffer_sRGB,
+        WGL_ARB_make_current_read,
+        WGL_ARB_multisample,
+        WGL_ARB_pbuffer,
+        WGL_ARB_pixel_format,
+        WGL_ARB_pixel_format_float,
+        WGL_ARB_render_texture,
+        WGL_ARB_robustness_application_isolation,
+        WGL_ARB_robustness_share_group_isolation,
+        WGL_ATI_pixel_format_float,
+        WGL_EXT_create_context_es2_profile,
+        WGL_EXT_create_context_es_profile,
+        WGL_EXT_depth_float,
+        WGL_EXT_display_color_table,
+        WGL_EXT_extensions_string,
+        WGL_EXT_framebuffer_sRGB,
+        WGL_EXT_make_current_read,
+        WGL_EXT_multisample,
+        WGL_EXT_pbuffer,
+        WGL_EXT_pixel_format,
+        WGL_EXT_pixel_format_packed_float,
+        WGL_EXT_swap_control,
+        WGL_EXT_swap_control_tear,
+        WGL_I3D_digital_video_control,
+        WGL_I3D_gamma,
+        WGL_I3D_genlock,
+        WGL_I3D_image_buffer,
+        WGL_I3D_swap_frame_lock,
+        WGL_I3D_swap_frame_usage,
+        WGL_NV_DX_interop,
+        WGL_NV_DX_interop2,
+        WGL_NV_copy_image,
+        WGL_NV_delay_before_swap,
+        WGL_NV_float_buffer,
+        WGL_NV_gpu_affinity,
+        WGL_NV_multisample_coverage,
+        WGL_NV_present_video,
+        WGL_NV_render_depth_texture,
+        WGL_NV_render_texture_rectangle,
+        WGL_NV_swap_group,
+        WGL_NV_vertex_array_range,
+        WGL_NV_video_capture,
+        WGL_NV_video_output,
+        WGL_OML_sync_control
+    Loader: True
+    Local files: False
+    Omit khrplatform: False
+
+    Commandline:
+        --api="wgl=1.0" --generator="c" --spec="wgl" --extensions="WGL_3DFX_multisample,WGL_3DL_stereo_control,WGL_AMD_gpu_association,WGL_ARB_buffer_region,WGL_ARB_context_flush_control,WGL_ARB_create_context,WGL_ARB_create_context_profile,WGL_ARB_create_context_robustness,WGL_ARB_extensions_string,WGL_ARB_framebuffer_sRGB,WGL_ARB_make_current_read,WGL_ARB_multisample,WGL_ARB_pbuffer,WGL_ARB_pixel_format,WGL_ARB_pixel_format_float,WGL_ARB_render_texture,WGL_ARB_robustness_application_isolation,WGL_ARB_robustness_share_group_isolation,WGL_ATI_pixel_format_float,WGL_EXT_create_context_es2_profile,WGL_EXT_create_context_es_profile,WGL_EXT_depth_float,WGL_EXT_display_color_table,WGL_EXT_extensions_string,WGL_EXT_framebuffer_sRGB,WGL_EXT_make_current_read,WGL_EXT_multisample,WGL_EXT_pbuffer,WGL_EXT_pixel_format,WGL_EXT_pixel_format_packed_float,WGL_EXT_swap_control,WGL_EXT_swap_control_tear,WGL_I3D_digital_video_control,WGL_I3D_gamma,WGL_I3D_genlock,WGL_I3D_image_buffer,WGL_I3D_swap_frame_lock,WGL_I3D_swap_frame_usage,WGL_NV_DX_interop,WGL_NV_DX_interop2,WGL_NV_copy_image,WGL_NV_delay_before_swap,WGL_NV_float_buffer,WGL_NV_gpu_affinity,WGL_NV_multisample_coverage,WGL_NV_present_video,WGL_NV_render_depth_texture,WGL_NV_render_texture_rectangle,WGL_NV_swap_group,WGL_NV_vertex_array_range,WGL_NV_video_capture,WGL_NV_video_output,WGL_OML_sync_control"
+    Online:
+        http://glad.dav1d.de/#language=c&specification=wgl&loader=on&api=wgl%3D1.0&extensions=WGL_3DFX_multisample&extensions=WGL_3DL_stereo_control&extensions=WGL_AMD_gpu_association&extensions=WGL_ARB_buffer_region&extensions=WGL_ARB_context_flush_control&extensions=WGL_ARB_create_context&extensions=WGL_ARB_create_context_profile&extensions=WGL_ARB_create_context_robustness&extensions=WGL_ARB_extensions_string&extensions=WGL_ARB_framebuffer_sRGB&extensions=WGL_ARB_make_current_read&extensions=WGL_ARB_multisample&extensions=WGL_ARB_pbuffer&extensions=WGL_ARB_pixel_format&extensions=WGL_ARB_pixel_format_float&extensions=WGL_ARB_render_texture&extensions=WGL_ARB_robustness_application_isolation&extensions=WGL_ARB_robustness_share_group_isolation&extensions=WGL_ATI_pixel_format_float&extensions=WGL_EXT_create_context_es2_profile&extensions=WGL_EXT_create_context_es_profile&extensions=WGL_EXT_depth_float&extensions=WGL_EXT_display_color_table&extensions=WGL_EXT_extensions_string&extensions=WGL_EXT_framebuffer_sRGB&extensions=WGL_EXT_make_current_read&extensions=WGL_EXT_multisample&extensions=WGL_EXT_pbuffer&extensions=WGL_EXT_pixel_format&extensions=WGL_EXT_pixel_format_packed_float&extensions=WGL_EXT_swap_control&extensions=WGL_EXT_swap_control_tear&extensions=WGL_I3D_digital_video_control&extensions=WGL_I3D_gamma&extensions=WGL_I3D_genlock&extensions=WGL_I3D_image_buffer&extensions=WGL_I3D_swap_frame_lock&extensions=WGL_I3D_swap_frame_usage&extensions=WGL_NV_DX_interop&extensions=WGL_NV_DX_interop2&extensions=WGL_NV_copy_image&extensions=WGL_NV_delay_before_swap&extensions=WGL_NV_float_buffer&extensions=WGL_NV_gpu_affinity&extensions=WGL_NV_multisample_coverage&extensions=WGL_NV_present_video&extensions=WGL_NV_render_depth_texture&extensions=WGL_NV_render_texture_rectangle&extensions=WGL_NV_swap_group&extensions=WGL_NV_vertex_array_range&extensions=WGL_NV_video_capture&extensions=WGL_NV_video_output&extensions=WGL_OML_sync_control
+*/
+
+
+#ifndef WINAPI
+# ifndef WIN32_LEAN_AND_MEAN
+#  define WIN32_LEAN_AND_MEAN 1
+# endif
+# include <windows.h>
+#endif
+
+#include <glad/glad.h>
+
+#ifndef __glad_wglext_h_
+
+#ifdef __wglext_h_
+#error WGL header already included, remove this include, glad already provides it
+#endif
+
+#define __glad_wglext_h_
+#define __wglext_h_
+
+#ifndef APIENTRY
+#define APIENTRY
+#endif
+#ifndef APIENTRYP
+#define APIENTRYP APIENTRY *
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef void* (* GLADloadproc)(const char *name);
+
+#ifndef GLAPI
+# if defined(GLAD_GLAPI_EXPORT)
+#  if defined(WIN32) || defined(__CYGWIN__)
+#   if defined(GLAD_GLAPI_EXPORT_BUILD)
+#    if defined(__GNUC__)
+#     define GLAPI __attribute__ ((dllexport)) extern
+#    else
+#     define GLAPI __declspec(dllexport) extern
+#    endif
+#   else
+#    if defined(__GNUC__)
+#     define GLAPI __attribute__ ((dllimport)) extern
+#    else
+#     define GLAPI __declspec(dllimport) extern
+#    endif
+#   endif
+#  elif defined(__GNUC__) && defined(GLAD_GLAPI_EXPORT_BUILD)
+#   define GLAPI __attribute__ ((visibility ("default"))) extern
+#  else
+#   define GLAPI extern
+#  endif
+# else
+#  define GLAPI extern
+# endif
+#endif
+
+GLAPI int gladLoadWGL(HDC hdc);
+
+GLAPI int gladLoadWGLLoader(GLADloadproc, HDC hdc);
+
+struct _GPU_DEVICE {
+    DWORD  cb;
+    CHAR   DeviceName[32];
+    CHAR   DeviceString[128];
+    DWORD  Flags;
+    RECT   rcVirtualScreen;
+};
+DECLARE_HANDLE(HPBUFFERARB);
+DECLARE_HANDLE(HPBUFFEREXT);
+DECLARE_HANDLE(HVIDEOOUTPUTDEVICENV);
+DECLARE_HANDLE(HPVIDEODEV);
+DECLARE_HANDLE(HPGPUNV);
+DECLARE_HANDLE(HGPUNV);
+DECLARE_HANDLE(HVIDEOINPUTDEVICENV);
+typedef struct _GPU_DEVICE GPU_DEVICE;
+typedef struct _GPU_DEVICE *PGPU_DEVICE;
+#define WGL_SAMPLE_BUFFERS_3DFX 0x2060
+#define WGL_SAMPLES_3DFX 0x2061
+#define WGL_STEREO_EMITTER_ENABLE_3DL 0x2055
+#define WGL_STEREO_EMITTER_DISABLE_3DL 0x2056
+#define WGL_STEREO_POLARITY_NORMAL_3DL 0x2057
+#define WGL_STEREO_POLARITY_INVERT_3DL 0x2058
+#define WGL_GPU_VENDOR_AMD 0x1F00
+#define WGL_GPU_RENDERER_STRING_AMD 0x1F01
+#define WGL_GPU_OPENGL_VERSION_STRING_AMD 0x1F02
+#define WGL_GPU_FASTEST_TARGET_GPUS_AMD 0x21A2
+#define WGL_GPU_RAM_AMD 0x21A3
+#define WGL_GPU_CLOCK_AMD 0x21A4
+#define WGL_GPU_NUM_PIPES_AMD 0x21A5
+#define WGL_GPU_NUM_SIMD_AMD 0x21A6
+#define WGL_GPU_NUM_RB_AMD 0x21A7
+#define WGL_GPU_NUM_SPI_AMD 0x21A8
+#define WGL_FRONT_COLOR_BUFFER_BIT_ARB 0x00000001
+#define WGL_BACK_COLOR_BUFFER_BIT_ARB 0x00000002
+#define WGL_DEPTH_BUFFER_BIT_ARB 0x00000004
+#define WGL_STENCIL_BUFFER_BIT_ARB 0x00000008
+#define WGL_CONTEXT_RELEASE_BEHAVIOR_ARB 0x2097
+#define WGL_CONTEXT_RELEASE_BEHAVIOR_NONE_ARB 0
+#define WGL_CONTEXT_RELEASE_BEHAVIOR_FLUSH_ARB 0x2098
+#define WGL_CONTEXT_DEBUG_BIT_ARB 0x00000001
+#define WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB 0x00000002
+#define WGL_CONTEXT_MAJOR_VERSION_ARB 0x2091
+#define WGL_CONTEXT_MINOR_VERSION_ARB 0x2092
+#define WGL_CONTEXT_LAYER_PLANE_ARB 0x2093
+#define WGL_CONTEXT_FLAGS_ARB 0x2094
+#define ERROR_INVALID_VERSION_ARB 0x2095
+#define WGL_CONTEXT_PROFILE_MASK_ARB 0x9126
+#define WGL_CONTEXT_CORE_PROFILE_BIT_ARB 0x00000001
+#define WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB 0x00000002
+#define ERROR_INVALID_PROFILE_ARB 0x2096
+#define WGL_CONTEXT_ROBUST_ACCESS_BIT_ARB 0x00000004
+#define WGL_LOSE_CONTEXT_ON_RESET_ARB 0x8252
+#define WGL_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB 0x8256
+#define WGL_NO_RESET_NOTIFICATION_ARB 0x8261
+#define WGL_FRAMEBUFFER_SRGB_CAPABLE_ARB 0x20A9
+#define ERROR_INVALID_PIXEL_TYPE_ARB 0x2043
+#define ERROR_INCOMPATIBLE_DEVICE_CONTEXTS_ARB 0x2054
+#define WGL_SAMPLE_BUFFERS_ARB 0x2041
+#define WGL_SAMPLES_ARB 0x2042
+#define WGL_DRAW_TO_PBUFFER_ARB 0x202D
+#define WGL_MAX_PBUFFER_PIXELS_ARB 0x202E
+#define WGL_MAX_PBUFFER_WIDTH_ARB 0x202F
+#define WGL_MAX_PBUFFER_HEIGHT_ARB 0x2030
+#define WGL_PBUFFER_LARGEST_ARB 0x2033
+#define WGL_PBUFFER_WIDTH_ARB 0x2034
+#define WGL_PBUFFER_HEIGHT_ARB 0x2035
+#define WGL_PBUFFER_LOST_ARB 0x2036
+#define WGL_NUMBER_PIXEL_FORMATS_ARB 0x2000
+#define WGL_DRAW_TO_WINDOW_ARB 0x2001
+#define WGL_DRAW_TO_BITMAP_ARB 0x2002
+#define WGL_ACCELERATION_ARB 0x2003
+#define WGL_NEED_PALETTE_ARB 0x2004
+#define WGL_NEED_SYSTEM_PALETTE_ARB 0x2005
+#define WGL_SWAP_LAYER_BUFFERS_ARB 0x2006
+#define WGL_SWAP_METHOD_ARB 0x2007
+#define WGL_NUMBER_OVERLAYS_ARB 0x2008
+#define WGL_NUMBER_UNDERLAYS_ARB 0x2009
+#define WGL_TRANSPARENT_ARB 0x200A
+#define WGL_TRANSPARENT_RED_VALUE_ARB 0x2037
+#define WGL_TRANSPARENT_GREEN_VALUE_ARB 0x2038
+#define WGL_TRANSPARENT_BLUE_VALUE_ARB 0x2039
+#define WGL_TRANSPARENT_ALPHA_VALUE_ARB 0x203A
+#define WGL_TRANSPARENT_INDEX_VALUE_ARB 0x203B
+#define WGL_SHARE_DEPTH_ARB 0x200C
+#define WGL_SHARE_STENCIL_ARB 0x200D
+#define WGL_SHARE_ACCUM_ARB 0x200E
+#define WGL_SUPPORT_GDI_ARB 0x200F
+#define WGL_SUPPORT_OPENGL_ARB 0x2010
+#define WGL_DOUBLE_BUFFER_ARB 0x2011
+#define WGL_STEREO_ARB 0x2012
+#define WGL_PIXEL_TYPE_ARB 0x2013
+#define WGL_COLOR_BITS_ARB 0x2014
+#define WGL_RED_BITS_ARB 0x2015
+#define WGL_RED_SHIFT_ARB 0x2016
+#define WGL_GREEN_BITS_ARB 0x2017
+#define WGL_GREEN_SHIFT_ARB 0x2018
+#define WGL_BLUE_BITS_ARB 0x2019
+#define WGL_BLUE_SHIFT_ARB 0x201A
+#define WGL_ALPHA_BITS_ARB 0x201B
+#define WGL_ALPHA_SHIFT_ARB 0x201C
+#define WGL_ACCUM_BITS_ARB 0x201D
+#define WGL_ACCUM_RED_BITS_ARB 0x201E
+#define WGL_ACCUM_GREEN_BITS_ARB 0x201F
+#define WGL_ACCUM_BLUE_BITS_ARB 0x2020
+#define WGL_ACCUM_ALPHA_BITS_ARB 0x2021
+#define WGL_DEPTH_BITS_ARB 0x2022
+#define WGL_STENCIL_BITS_ARB 0x2023
+#define WGL_AUX_BUFFERS_ARB 0x2024
+#define WGL_NO_ACCELERATION_ARB 0x2025
+#define WGL_GENERIC_ACCELERATION_ARB 0x2026
+#define WGL_FULL_ACCELERATION_ARB 0x2027
+#define WGL_SWAP_EXCHANGE_ARB 0x2028
+#define WGL_SWAP_COPY_ARB 0x2029
+#define WGL_SWAP_UNDEFINED_ARB 0x202A
+#define WGL_TYPE_RGBA_ARB 0x202B
+#define WGL_TYPE_COLORINDEX_ARB 0x202C
+#define WGL_TYPE_RGBA_FLOAT_ARB 0x21A0
+#define WGL_BIND_TO_TEXTURE_RGB_ARB 0x2070
+#define WGL_BIND_TO_TEXTURE_RGBA_ARB 0x2071
+#define WGL_TEXTURE_FORMAT_ARB 0x2072
+#define WGL_TEXTURE_TARGET_ARB 0x2073
+#define WGL_MIPMAP_TEXTURE_ARB 0x2074
+#define WGL_TEXTURE_RGB_ARB 0x2075
+#define WGL_TEXTURE_RGBA_ARB 0x2076
+#define WGL_NO_TEXTURE_ARB 0x2077
+#define WGL_TEXTURE_CUBE_MAP_ARB 0x2078
+#define WGL_TEXTURE_1D_ARB 0x2079
+#define WGL_TEXTURE_2D_ARB 0x207A
+#define WGL_MIPMAP_LEVEL_ARB 0x207B
+#define WGL_CUBE_MAP_FACE_ARB 0x207C
+#define WGL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB 0x207D
+#define WGL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB 0x207E
+#define WGL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB 0x207F
+#define WGL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB 0x2080
+#define WGL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB 0x2081
+#define WGL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB 0x2082
+#define WGL_FRONT_LEFT_ARB 0x2083
+#define WGL_FRONT_RIGHT_ARB 0x2084
+#define WGL_BACK_LEFT_ARB 0x2085
+#define WGL_BACK_RIGHT_ARB 0x2086
+#define WGL_AUX0_ARB 0x2087
+#define WGL_AUX1_ARB 0x2088
+#define WGL_AUX2_ARB 0x2089
+#define WGL_AUX3_ARB 0x208A
+#define WGL_AUX4_ARB 0x208B
+#define WGL_AUX5_ARB 0x208C
+#define WGL_AUX6_ARB 0x208D
+#define WGL_AUX7_ARB 0x208E
+#define WGL_AUX8_ARB 0x208F
+#define WGL_AUX9_ARB 0x2090
+#define WGL_CONTEXT_RESET_ISOLATION_BIT_ARB 0x00000008
+#define WGL_TYPE_RGBA_FLOAT_ATI 0x21A0
+#define WGL_CONTEXT_ES2_PROFILE_BIT_EXT 0x00000004
+#define WGL_CONTEXT_ES_PROFILE_BIT_EXT 0x00000004
+#define WGL_DEPTH_FLOAT_EXT 0x2040
+#define WGL_FRAMEBUFFER_SRGB_CAPABLE_EXT 0x20A9
+#define ERROR_INVALID_PIXEL_TYPE_EXT 0x2043
+#define WGL_SAMPLE_BUFFERS_EXT 0x2041
+#define WGL_SAMPLES_EXT 0x2042
+#define WGL_DRAW_TO_PBUFFER_EXT 0x202D
+#define WGL_MAX_PBUFFER_PIXELS_EXT 0x202E
+#define WGL_MAX_PBUFFER_WIDTH_EXT 0x202F
+#define WGL_MAX_PBUFFER_HEIGHT_EXT 0x2030
+#define WGL_OPTIMAL_PBUFFER_WIDTH_EXT 0x2031
+#define WGL_OPTIMAL_PBUFFER_HEIGHT_EXT 0x2032
+#define WGL_PBUFFER_LARGEST_EXT 0x2033
+#define WGL_PBUFFER_WIDTH_EXT 0x2034
+#define WGL_PBUFFER_HEIGHT_EXT 0x2035
+#define WGL_NUMBER_PIXEL_FORMATS_EXT 0x2000
+#define WGL_DRAW_TO_WINDOW_EXT 0x2001
+#define WGL_DRAW_TO_BITMAP_EXT 0x2002
+#define WGL_ACCELERATION_EXT 0x2003
+#define WGL_NEED_PALETTE_EXT 0x2004
+#define WGL_NEED_SYSTEM_PALETTE_EXT 0x2005
+#define WGL_SWAP_LAYER_BUFFERS_EXT 0x2006
+#define WGL_SWAP_METHOD_EXT 0x2007
+#define WGL_NUMBER_OVERLAYS_EXT 0x2008
+#define WGL_NUMBER_UNDERLAYS_EXT 0x2009
+#define WGL_TRANSPARENT_EXT 0x200A
+#define WGL_TRANSPARENT_VALUE_EXT 0x200B
+#define WGL_SHARE_DEPTH_EXT 0x200C
+#define WGL_SHARE_STENCIL_EXT 0x200D
+#define WGL_SHARE_ACCUM_EXT 0x200E
+#define WGL_SUPPORT_GDI_EXT 0x200F
+#define WGL_SUPPORT_OPENGL_EXT 0x2010
+#define WGL_DOUBLE_BUFFER_EXT 0x2011
+#define WGL_STEREO_EXT 0x2012
+#define WGL_PIXEL_TYPE_EXT 0x2013
+#define WGL_COLOR_BITS_EXT 0x2014
+#define WGL_RED_BITS_EXT 0x2015
+#define WGL_RED_SHIFT_EXT 0x2016
+#define WGL_GREEN_BITS_EXT 0x2017
+#define WGL_GREEN_SHIFT_EXT 0x2018
+#define WGL_BLUE_BITS_EXT 0x2019
+#define WGL_BLUE_SHIFT_EXT 0x201A
+#define WGL_ALPHA_BITS_EXT 0x201B
+#define WGL_ALPHA_SHIFT_EXT 0x201C
+#define WGL_ACCUM_BITS_EXT 0x201D
+#define WGL_ACCUM_RED_BITS_EXT 0x201E
+#define WGL_ACCUM_GREEN_BITS_EXT 0x201F
+#define WGL_ACCUM_BLUE_BITS_EXT 0x2020
+#define WGL_ACCUM_ALPHA_BITS_EXT 0x2021
+#define WGL_DEPTH_BITS_EXT 0x2022
+#define WGL_STENCIL_BITS_EXT 0x2023
+#define WGL_AUX_BUFFERS_EXT 0x2024
+#define WGL_NO_ACCELERATION_EXT 0x2025
+#define WGL_GENERIC_ACCELERATION_EXT 0x2026
+#define WGL_FULL_ACCELERATION_EXT 0x2027
+#define WGL_SWAP_EXCHANGE_EXT 0x2028
+#define WGL_SWAP_COPY_EXT 0x2029
+#define WGL_SWAP_UNDEFINED_EXT 0x202A
+#define WGL_TYPE_RGBA_EXT 0x202B
+#define WGL_TYPE_COLORINDEX_EXT 0x202C
+#define WGL_TYPE_RGBA_UNSIGNED_FLOAT_EXT 0x20A8
+#define WGL_DIGITAL_VIDEO_CURSOR_ALPHA_FRAMEBUFFER_I3D 0x2050
+#define WGL_DIGITAL_VIDEO_CURSOR_ALPHA_VALUE_I3D 0x2051
+#define WGL_DIGITAL_VIDEO_CURSOR_INCLUDED_I3D 0x2052
+#define WGL_DIGITAL_VIDEO_GAMMA_CORRECTED_I3D 0x2053
+#define WGL_GAMMA_TABLE_SIZE_I3D 0x204E
+#define WGL_GAMMA_EXCLUDE_DESKTOP_I3D 0x204F
+#define WGL_GENLOCK_SOURCE_MULTIVIEW_I3D 0x2044
+#define WGL_GENLOCK_SOURCE_EXTERNAL_SYNC_I3D 0x2045
+#define WGL_GENLOCK_SOURCE_EXTERNAL_FIELD_I3D 0x2046
+#define WGL_GENLOCK_SOURCE_EXTERNAL_TTL_I3D 0x2047
+#define WGL_GENLOCK_SOURCE_DIGITAL_SYNC_I3D 0x2048
+#define WGL_GENLOCK_SOURCE_DIGITAL_FIELD_I3D 0x2049
+#define WGL_GENLOCK_SOURCE_EDGE_FALLING_I3D 0x204A
+#define WGL_GENLOCK_SOURCE_EDGE_RISING_I3D 0x204B
+#define WGL_GENLOCK_SOURCE_EDGE_BOTH_I3D 0x204C
+#define WGL_IMAGE_BUFFER_MIN_ACCESS_I3D 0x00000001
+#define WGL_IMAGE_BUFFER_LOCK_I3D 0x00000002
+#define WGL_ACCESS_READ_ONLY_NV 0x00000000
+#define WGL_ACCESS_READ_WRITE_NV 0x00000001
+#define WGL_ACCESS_WRITE_DISCARD_NV 0x00000002
+#define WGL_FLOAT_COMPONENTS_NV 0x20B0
+#define WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_R_NV 0x20B1
+#define WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RG_NV 0x20B2
+#define WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGB_NV 0x20B3
+#define WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGBA_NV 0x20B4
+#define WGL_TEXTURE_FLOAT_R_NV 0x20B5
+#define WGL_TEXTURE_FLOAT_RG_NV 0x20B6
+#define WGL_TEXTURE_FLOAT_RGB_NV 0x20B7
+#define WGL_TEXTURE_FLOAT_RGBA_NV 0x20B8
+#define ERROR_INCOMPATIBLE_AFFINITY_MASKS_NV 0x20D0
+#define ERROR_MISSING_AFFINITY_MASK_NV 0x20D1
+#define WGL_COVERAGE_SAMPLES_NV 0x2042
+#define WGL_COLOR_SAMPLES_NV 0x20B9
+#define WGL_NUM_VIDEO_SLOTS_NV 0x20F0
+#define WGL_BIND_TO_TEXTURE_DEPTH_NV 0x20A3
+#define WGL_BIND_TO_TEXTURE_RECTANGLE_DEPTH_NV 0x20A4
+#define WGL_DEPTH_TEXTURE_FORMAT_NV 0x20A5
+#define WGL_TEXTURE_DEPTH_COMPONENT_NV 0x20A6
+#define WGL_DEPTH_COMPONENT_NV 0x20A7
+#define WGL_BIND_TO_TEXTURE_RECTANGLE_RGB_NV 0x20A0
+#define WGL_BIND_TO_TEXTURE_RECTANGLE_RGBA_NV 0x20A1
+#define WGL_TEXTURE_RECTANGLE_NV 0x20A2
+#define WGL_UNIQUE_ID_NV 0x20CE
+#define WGL_NUM_VIDEO_CAPTURE_SLOTS_NV 0x20CF
+#define WGL_BIND_TO_VIDEO_RGB_NV 0x20C0
+#define WGL_BIND_TO_VIDEO_RGBA_NV 0x20C1
+#define WGL_BIND_TO_VIDEO_RGB_AND_DEPTH_NV 0x20C2
+#define WGL_VIDEO_OUT_COLOR_NV 0x20C3
+#define WGL_VIDEO_OUT_ALPHA_NV 0x20C4
+#define WGL_VIDEO_OUT_DEPTH_NV 0x20C5
+#define WGL_VIDEO_OUT_COLOR_AND_ALPHA_NV 0x20C6
+#define WGL_VIDEO_OUT_COLOR_AND_DEPTH_NV 0x20C7
+#define WGL_VIDEO_OUT_FRAME 0x20C8
+#define WGL_VIDEO_OUT_FIELD_1 0x20C9
+#define WGL_VIDEO_OUT_FIELD_2 0x20CA
+#define WGL_VIDEO_OUT_STACKED_FIELDS_1_2 0x20CB
+#define WGL_VIDEO_OUT_STACKED_FIELDS_2_1 0x20CC
+#ifndef WGL_3DFX_multisample
+#define WGL_3DFX_multisample 1
+GLAPI int GLAD_WGL_3DFX_multisample;
+#endif
+#ifndef WGL_3DL_stereo_control
+#define WGL_3DL_stereo_control 1
+GLAPI int GLAD_WGL_3DL_stereo_control;
+typedef BOOL (APIENTRYP PFNWGLSETSTEREOEMITTERSTATE3DLPROC)(HDC hDC, UINT uState);
+GLAPI PFNWGLSETSTEREOEMITTERSTATE3DLPROC glad_wglSetStereoEmitterState3DL;
+#define wglSetStereoEmitterState3DL glad_wglSetStereoEmitterState3DL
+#endif
+#ifndef WGL_AMD_gpu_association
+#define WGL_AMD_gpu_association 1
+GLAPI int GLAD_WGL_AMD_gpu_association;
+typedef UINT (APIENTRYP PFNWGLGETGPUIDSAMDPROC)(UINT maxCount, UINT *ids);
+GLAPI PFNWGLGETGPUIDSAMDPROC glad_wglGetGPUIDsAMD;
+#define wglGetGPUIDsAMD glad_wglGetGPUIDsAMD
+typedef INT (APIENTRYP PFNWGLGETGPUINFOAMDPROC)(UINT id, int property, GLenum dataType, UINT size, void *data);
+GLAPI PFNWGLGETGPUINFOAMDPROC glad_wglGetGPUInfoAMD;
+#define wglGetGPUInfoAMD glad_wglGetGPUInfoAMD
+typedef UINT (APIENTRYP PFNWGLGETCONTEXTGPUIDAMDPROC)(HGLRC hglrc);
+GLAPI PFNWGLGETCONTEXTGPUIDAMDPROC glad_wglGetContextGPUIDAMD;
+#define wglGetContextGPUIDAMD glad_wglGetContextGPUIDAMD
+typedef HGLRC (APIENTRYP PFNWGLCREATEASSOCIATEDCONTEXTAMDPROC)(UINT id);
+GLAPI PFNWGLCREATEASSOCIATEDCONTEXTAMDPROC glad_wglCreateAssociatedContextAMD;
+#define wglCreateAssociatedContextAMD glad_wglCreateAssociatedContextAMD
+typedef HGLRC (APIENTRYP PFNWGLCREATEASSOCIATEDCONTEXTATTRIBSAMDPROC)(UINT id, HGLRC hShareContext, const int *attribList);
+GLAPI PFNWGLCREATEASSOCIATEDCONTEXTATTRIBSAMDPROC glad_wglCreateAssociatedContextAttribsAMD;
+#define wglCreateAssociatedContextAttribsAMD glad_wglCreateAssociatedContextAttribsAMD
+typedef BOOL (APIENTRYP PFNWGLDELETEASSOCIATEDCONTEXTAMDPROC)(HGLRC hglrc);
+GLAPI PFNWGLDELETEASSOCIATEDCONTEXTAMDPROC glad_wglDeleteAssociatedContextAMD;
+#define wglDeleteAssociatedContextAMD glad_wglDeleteAssociatedContextAMD
+typedef BOOL (APIENTRYP PFNWGLMAKEASSOCIATEDCONTEXTCURRENTAMDPROC)(HGLRC hglrc);
+GLAPI PFNWGLMAKEASSOCIATEDCONTEXTCURRENTAMDPROC glad_wglMakeAssociatedContextCurrentAMD;
+#define wglMakeAssociatedContextCurrentAMD glad_wglMakeAssociatedContextCurrentAMD
+typedef HGLRC (APIENTRYP PFNWGLGETCURRENTASSOCIATEDCONTEXTAMDPROC)();
+GLAPI PFNWGLGETCURRENTASSOCIATEDCONTEXTAMDPROC glad_wglGetCurrentAssociatedContextAMD;
+#define wglGetCurrentAssociatedContextAMD glad_wglGetCurrentAssociatedContextAMD
+typedef VOID (APIENTRYP PFNWGLBLITCONTEXTFRAMEBUFFERAMDPROC)(HGLRC dstCtx, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
+GLAPI PFNWGLBLITCONTEXTFRAMEBUFFERAMDPROC glad_wglBlitContextFramebufferAMD;
+#define wglBlitContextFramebufferAMD glad_wglBlitContextFramebufferAMD
+#endif
+#ifndef WGL_ARB_buffer_region
+#define WGL_ARB_buffer_region 1
+GLAPI int GLAD_WGL_ARB_buffer_region;
+typedef HANDLE (APIENTRYP PFNWGLCREATEBUFFERREGIONARBPROC)(HDC hDC, int iLayerPlane, UINT uType);
+GLAPI PFNWGLCREATEBUFFERREGIONARBPROC glad_wglCreateBufferRegionARB;
+#define wglCreateBufferRegionARB glad_wglCreateBufferRegionARB
+typedef VOID (APIENTRYP PFNWGLDELETEBUFFERREGIONARBPROC)(HANDLE hRegion);
+GLAPI PFNWGLDELETEBUFFERREGIONARBPROC glad_wglDeleteBufferRegionARB;
+#define wglDeleteBufferRegionARB glad_wglDeleteBufferRegionARB
+typedef BOOL (APIENTRYP PFNWGLSAVEBUFFERREGIONARBPROC)(HANDLE hRegion, int x, int y, int width, int height);
+GLAPI PFNWGLSAVEBUFFERREGIONARBPROC glad_wglSaveBufferRegionARB;
+#define wglSaveBufferRegionARB glad_wglSaveBufferRegionARB
+typedef BOOL (APIENTRYP PFNWGLRESTOREBUFFERREGIONARBPROC)(HANDLE hRegion, int x, int y, int width, int height, int xSrc, int ySrc);
+GLAPI PFNWGLRESTOREBUFFERREGIONARBPROC glad_wglRestoreBufferRegionARB;
+#define wglRestoreBufferRegionARB glad_wglRestoreBufferRegionARB
+#endif
+#ifndef WGL_ARB_context_flush_control
+#define WGL_ARB_context_flush_control 1
+GLAPI int GLAD_WGL_ARB_context_flush_control;
+#endif
+#ifndef WGL_ARB_create_context
+#define WGL_ARB_create_context 1
+GLAPI int GLAD_WGL_ARB_create_context;
+typedef HGLRC (APIENTRYP PFNWGLCREATECONTEXTATTRIBSARBPROC)(HDC hDC, HGLRC hShareContext, const int *attribList);
+GLAPI PFNWGLCREATECONTEXTATTRIBSARBPROC glad_wglCreateContextAttribsARB;
+#define wglCreateContextAttribsARB glad_wglCreateContextAttribsARB
+#endif
+#ifndef WGL_ARB_create_context_profile
+#define WGL_ARB_create_context_profile 1
+GLAPI int GLAD_WGL_ARB_create_context_profile;
+#endif
+#ifndef WGL_ARB_create_context_robustness
+#define WGL_ARB_create_context_robustness 1
+GLAPI int GLAD_WGL_ARB_create_context_robustness;
+#endif
+#ifndef WGL_ARB_extensions_string
+#define WGL_ARB_extensions_string 1
+GLAPI int GLAD_WGL_ARB_extensions_string;
+typedef const char * (APIENTRYP PFNWGLGETEXTENSIONSSTRINGARBPROC)(HDC hdc);
+GLAPI PFNWGLGETEXTENSIONSSTRINGARBPROC glad_wglGetExtensionsStringARB;
+#define wglGetExtensionsStringARB glad_wglGetExtensionsStringARB
+#endif
+#ifndef WGL_ARB_framebuffer_sRGB
+#define WGL_ARB_framebuffer_sRGB 1
+GLAPI int GLAD_WGL_ARB_framebuffer_sRGB;
+#endif
+#ifndef WGL_ARB_make_current_read
+#define WGL_ARB_make_current_read 1
+GLAPI int GLAD_WGL_ARB_make_current_read;
+typedef BOOL (APIENTRYP PFNWGLMAKECONTEXTCURRENTARBPROC)(HDC hDrawDC, HDC hReadDC, HGLRC hglrc);
+GLAPI PFNWGLMAKECONTEXTCURRENTARBPROC glad_wglMakeContextCurrentARB;
+#define wglMakeContextCurrentARB glad_wglMakeContextCurrentARB
+typedef HDC (APIENTRYP PFNWGLGETCURRENTREADDCARBPROC)();
+GLAPI PFNWGLGETCURRENTREADDCARBPROC glad_wglGetCurrentReadDCARB;
+#define wglGetCurrentReadDCARB glad_wglGetCurrentReadDCARB
+#endif
+#ifndef WGL_ARB_multisample
+#define WGL_ARB_multisample 1
+GLAPI int GLAD_WGL_ARB_multisample;
+#endif
+#ifndef WGL_ARB_pbuffer
+#define WGL_ARB_pbuffer 1
+GLAPI int GLAD_WGL_ARB_pbuffer;
+typedef HPBUFFERARB (APIENTRYP PFNWGLCREATEPBUFFERARBPROC)(HDC hDC, int iPixelFormat, int iWidth, int iHeight, const int *piAttribList);
+GLAPI PFNWGLCREATEPBUFFERARBPROC glad_wglCreatePbufferARB;
+#define wglCreatePbufferARB glad_wglCreatePbufferARB
+typedef HDC (APIENTRYP PFNWGLGETPBUFFERDCARBPROC)(HPBUFFERARB hPbuffer);
+GLAPI PFNWGLGETPBUFFERDCARBPROC glad_wglGetPbufferDCARB;
+#define wglGetPbufferDCARB glad_wglGetPbufferDCARB
+typedef int (APIENTRYP PFNWGLRELEASEPBUFFERDCARBPROC)(HPBUFFERARB hPbuffer, HDC hDC);
+GLAPI PFNWGLRELEASEPBUFFERDCARBPROC glad_wglReleasePbufferDCARB;
+#define wglReleasePbufferDCARB glad_wglReleasePbufferDCARB
+typedef BOOL (APIENTRYP PFNWGLDESTROYPBUFFERARBPROC)(HPBUFFERARB hPbuffer);
+GLAPI PFNWGLDESTROYPBUFFERARBPROC glad_wglDestroyPbufferARB;
+#define wglDestroyPbufferARB glad_wglDestroyPbufferARB
+typedef BOOL (APIENTRYP PFNWGLQUERYPBUFFERARBPROC)(HPBUFFERARB hPbuffer, int iAttribute, int *piValue);
+GLAPI PFNWGLQUERYPBUFFERARBPROC glad_wglQueryPbufferARB;
+#define wglQueryPbufferARB glad_wglQueryPbufferARB
+#endif
+#ifndef WGL_ARB_pixel_format
+#define WGL_ARB_pixel_format 1
+GLAPI int GLAD_WGL_ARB_pixel_format;
+typedef BOOL (APIENTRYP PFNWGLGETPIXELFORMATATTRIBIVARBPROC)(HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, const int *piAttributes, int *piValues);
+GLAPI PFNWGLGETPIXELFORMATATTRIBIVARBPROC glad_wglGetPixelFormatAttribivARB;
+#define wglGetPixelFormatAttribivARB glad_wglGetPixelFormatAttribivARB
+typedef BOOL (APIENTRYP PFNWGLGETPIXELFORMATATTRIBFVARBPROC)(HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, const int *piAttributes, FLOAT *pfValues);
+GLAPI PFNWGLGETPIXELFORMATATTRIBFVARBPROC glad_wglGetPixelFormatAttribfvARB;
+#define wglGetPixelFormatAttribfvARB glad_wglGetPixelFormatAttribfvARB
+typedef BOOL (APIENTRYP PFNWGLCHOOSEPIXELFORMATARBPROC)(HDC hdc, const int *piAttribIList, const FLOAT *pfAttribFList, UINT nMaxFormats, int *piFormats, UINT *nNumFormats);
+GLAPI PFNWGLCHOOSEPIXELFORMATARBPROC glad_wglChoosePixelFormatARB;
+#define wglChoosePixelFormatARB glad_wglChoosePixelFormatARB
+#endif
+#ifndef WGL_ARB_pixel_format_float
+#define WGL_ARB_pixel_format_float 1
+GLAPI int GLAD_WGL_ARB_pixel_format_float;
+#endif
+#ifndef WGL_ARB_render_texture
+#define WGL_ARB_render_texture 1
+GLAPI int GLAD_WGL_ARB_render_texture;
+typedef BOOL (APIENTRYP PFNWGLBINDTEXIMAGEARBPROC)(HPBUFFERARB hPbuffer, int iBuffer);
+GLAPI PFNWGLBINDTEXIMAGEARBPROC glad_wglBindTexImageARB;
+#define wglBindTexImageARB glad_wglBindTexImageARB
+typedef BOOL (APIENTRYP PFNWGLRELEASETEXIMAGEARBPROC)(HPBUFFERARB hPbuffer, int iBuffer);
+GLAPI PFNWGLRELEASETEXIMAGEARBPROC glad_wglReleaseTexImageARB;
+#define wglReleaseTexImageARB glad_wglReleaseTexImageARB
+typedef BOOL (APIENTRYP PFNWGLSETPBUFFERATTRIBARBPROC)(HPBUFFERARB hPbuffer, const int *piAttribList);
+GLAPI PFNWGLSETPBUFFERATTRIBARBPROC glad_wglSetPbufferAttribARB;
+#define wglSetPbufferAttribARB glad_wglSetPbufferAttribARB
+#endif
+#ifndef WGL_ARB_robustness_application_isolation
+#define WGL_ARB_robustness_application_isolation 1
+GLAPI int GLAD_WGL_ARB_robustness_application_isolation;
+#endif
+#ifndef WGL_ARB_robustness_share_group_isolation
+#define WGL_ARB_robustness_share_group_isolation 1
+GLAPI int GLAD_WGL_ARB_robustness_share_group_isolation;
+#endif
+#ifndef WGL_ATI_pixel_format_float
+#define WGL_ATI_pixel_format_float 1
+GLAPI int GLAD_WGL_ATI_pixel_format_float;
+#endif
+#ifndef WGL_EXT_create_context_es2_profile
+#define WGL_EXT_create_context_es2_profile 1
+GLAPI int GLAD_WGL_EXT_create_context_es2_profile;
+#endif
+#ifndef WGL_EXT_create_context_es_profile
+#define WGL_EXT_create_context_es_profile 1
+GLAPI int GLAD_WGL_EXT_create_context_es_profile;
+#endif
+#ifndef WGL_EXT_depth_float
+#define WGL_EXT_depth_float 1
+GLAPI int GLAD_WGL_EXT_depth_float;
+#endif
+#ifndef WGL_EXT_display_color_table
+#define WGL_EXT_display_color_table 1
+GLAPI int GLAD_WGL_EXT_display_color_table;
+typedef GLboolean (APIENTRYP PFNWGLCREATEDISPLAYCOLORTABLEEXTPROC)(GLushort id);
+GLAPI PFNWGLCREATEDISPLAYCOLORTABLEEXTPROC glad_wglCreateDisplayColorTableEXT;
+#define wglCreateDisplayColorTableEXT glad_wglCreateDisplayColorTableEXT
+typedef GLboolean (APIENTRYP PFNWGLLOADDISPLAYCOLORTABLEEXTPROC)(const GLushort *table, GLuint length);
+GLAPI PFNWGLLOADDISPLAYCOLORTABLEEXTPROC glad_wglLoadDisplayColorTableEXT;
+#define wglLoadDisplayColorTableEXT glad_wglLoadDisplayColorTableEXT
+typedef GLboolean (APIENTRYP PFNWGLBINDDISPLAYCOLORTABLEEXTPROC)(GLushort id);
+GLAPI PFNWGLBINDDISPLAYCOLORTABLEEXTPROC glad_wglBindDisplayColorTableEXT;
+#define wglBindDisplayColorTableEXT glad_wglBindDisplayColorTableEXT
+typedef VOID (APIENTRYP PFNWGLDESTROYDISPLAYCOLORTABLEEXTPROC)(GLushort id);
+GLAPI PFNWGLDESTROYDISPLAYCOLORTABLEEXTPROC glad_wglDestroyDisplayColorTableEXT;
+#define wglDestroyDisplayColorTableEXT glad_wglDestroyDisplayColorTableEXT
+#endif
+#ifndef WGL_EXT_extensions_string
+#define WGL_EXT_extensions_string 1
+GLAPI int GLAD_WGL_EXT_extensions_string;
+typedef const char * (APIENTRYP PFNWGLGETEXTENSIONSSTRINGEXTPROC)();
+GLAPI PFNWGLGETEXTENSIONSSTRINGEXTPROC glad_wglGetExtensionsStringEXT;
+#define wglGetExtensionsStringEXT glad_wglGetExtensionsStringEXT
+#endif
+#ifndef WGL_EXT_framebuffer_sRGB
+#define WGL_EXT_framebuffer_sRGB 1
+GLAPI int GLAD_WGL_EXT_framebuffer_sRGB;
+#endif
+#ifndef WGL_EXT_make_current_read
+#define WGL_EXT_make_current_read 1
+GLAPI int GLAD_WGL_EXT_make_current_read;
+typedef BOOL (APIENTRYP PFNWGLMAKECONTEXTCURRENTEXTPROC)(HDC hDrawDC, HDC hReadDC, HGLRC hglrc);
+GLAPI PFNWGLMAKECONTEXTCURRENTEXTPROC glad_wglMakeContextCurrentEXT;
+#define wglMakeContextCurrentEXT glad_wglMakeContextCurrentEXT
+typedef HDC (APIENTRYP PFNWGLGETCURRENTREADDCEXTPROC)();
+GLAPI PFNWGLGETCURRENTREADDCEXTPROC glad_wglGetCurrentReadDCEXT;
+#define wglGetCurrentReadDCEXT glad_wglGetCurrentReadDCEXT
+#endif
+#ifndef WGL_EXT_multisample
+#define WGL_EXT_multisample 1
+GLAPI int GLAD_WGL_EXT_multisample;
+#endif
+#ifndef WGL_EXT_pbuffer
+#define WGL_EXT_pbuffer 1
+GLAPI int GLAD_WGL_EXT_pbuffer;
+typedef HPBUFFEREXT (APIENTRYP PFNWGLCREATEPBUFFEREXTPROC)(HDC hDC, int iPixelFormat, int iWidth, int iHeight, const int *piAttribList);
+GLAPI PFNWGLCREATEPBUFFEREXTPROC glad_wglCreatePbufferEXT;
+#define wglCreatePbufferEXT glad_wglCreatePbufferEXT
+typedef HDC (APIENTRYP PFNWGLGETPBUFFERDCEXTPROC)(HPBUFFEREXT hPbuffer);
+GLAPI PFNWGLGETPBUFFERDCEXTPROC glad_wglGetPbufferDCEXT;
+#define wglGetPbufferDCEXT glad_wglGetPbufferDCEXT
+typedef int (APIENTRYP PFNWGLRELEASEPBUFFERDCEXTPROC)(HPBUFFEREXT hPbuffer, HDC hDC);
+GLAPI PFNWGLRELEASEPBUFFERDCEXTPROC glad_wglReleasePbufferDCEXT;
+#define wglReleasePbufferDCEXT glad_wglReleasePbufferDCEXT
+typedef BOOL (APIENTRYP PFNWGLDESTROYPBUFFEREXTPROC)(HPBUFFEREXT hPbuffer);
+GLAPI PFNWGLDESTROYPBUFFEREXTPROC glad_wglDestroyPbufferEXT;
+#define wglDestroyPbufferEXT glad_wglDestroyPbufferEXT
+typedef BOOL (APIENTRYP PFNWGLQUERYPBUFFEREXTPROC)(HPBUFFEREXT hPbuffer, int iAttribute, int *piValue);
+GLAPI PFNWGLQUERYPBUFFEREXTPROC glad_wglQueryPbufferEXT;
+#define wglQueryPbufferEXT glad_wglQueryPbufferEXT
+#endif
+#ifndef WGL_EXT_pixel_format
+#define WGL_EXT_pixel_format 1
+GLAPI int GLAD_WGL_EXT_pixel_format;
+typedef BOOL (APIENTRYP PFNWGLGETPIXELFORMATATTRIBIVEXTPROC)(HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, int *piAttributes, int *piValues);
+GLAPI PFNWGLGETPIXELFORMATATTRIBIVEXTPROC glad_wglGetPixelFormatAttribivEXT;
+#define wglGetPixelFormatAttribivEXT glad_wglGetPixelFormatAttribivEXT
+typedef BOOL (APIENTRYP PFNWGLGETPIXELFORMATATTRIBFVEXTPROC)(HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, int *piAttributes, FLOAT *pfValues);
+GLAPI PFNWGLGETPIXELFORMATATTRIBFVEXTPROC glad_wglGetPixelFormatAttribfvEXT;
+#define wglGetPixelFormatAttribfvEXT glad_wglGetPixelFormatAttribfvEXT
+typedef BOOL (APIENTRYP PFNWGLCHOOSEPIXELFORMATEXTPROC)(HDC hdc, const int *piAttribIList, const FLOAT *pfAttribFList, UINT nMaxFormats, int *piFormats, UINT *nNumFormats);
+GLAPI PFNWGLCHOOSEPIXELFORMATEXTPROC glad_wglChoosePixelFormatEXT;
+#define wglChoosePixelFormatEXT glad_wglChoosePixelFormatEXT
+#endif
+#ifndef WGL_EXT_pixel_format_packed_float
+#define WGL_EXT_pixel_format_packed_float 1
+GLAPI int GLAD_WGL_EXT_pixel_format_packed_float;
+#endif
+#ifndef WGL_EXT_swap_control
+#define WGL_EXT_swap_control 1
+GLAPI int GLAD_WGL_EXT_swap_control;
+typedef BOOL (APIENTRYP PFNWGLSWAPINTERVALEXTPROC)(int interval);
+GLAPI PFNWGLSWAPINTERVALEXTPROC glad_wglSwapIntervalEXT;
+#define wglSwapIntervalEXT glad_wglSwapIntervalEXT
+typedef int (APIENTRYP PFNWGLGETSWAPINTERVALEXTPROC)();
+GLAPI PFNWGLGETSWAPINTERVALEXTPROC glad_wglGetSwapIntervalEXT;
+#define wglGetSwapIntervalEXT glad_wglGetSwapIntervalEXT
+#endif
+#ifndef WGL_EXT_swap_control_tear
+#define WGL_EXT_swap_control_tear 1
+GLAPI int GLAD_WGL_EXT_swap_control_tear;
+#endif
+#ifndef WGL_I3D_digital_video_control
+#define WGL_I3D_digital_video_control 1
+GLAPI int GLAD_WGL_I3D_digital_video_control;
+typedef BOOL (APIENTRYP PFNWGLGETDIGITALVIDEOPARAMETERSI3DPROC)(HDC hDC, int iAttribute, int *piValue);
+GLAPI PFNWGLGETDIGITALVIDEOPARAMETERSI3DPROC glad_wglGetDigitalVideoParametersI3D;
+#define wglGetDigitalVideoParametersI3D glad_wglGetDigitalVideoParametersI3D
+typedef BOOL (APIENTRYP PFNWGLSETDIGITALVIDEOPARAMETERSI3DPROC)(HDC hDC, int iAttribute, const int *piValue);
+GLAPI PFNWGLSETDIGITALVIDEOPARAMETERSI3DPROC glad_wglSetDigitalVideoParametersI3D;
+#define wglSetDigitalVideoParametersI3D glad_wglSetDigitalVideoParametersI3D
+#endif
+#ifndef WGL_I3D_gamma
+#define WGL_I3D_gamma 1
+GLAPI int GLAD_WGL_I3D_gamma;
+typedef BOOL (APIENTRYP PFNWGLGETGAMMATABLEPARAMETERSI3DPROC)(HDC hDC, int iAttribute, int *piValue);
+GLAPI PFNWGLGETGAMMATABLEPARAMETERSI3DPROC glad_wglGetGammaTableParametersI3D;
+#define wglGetGammaTableParametersI3D glad_wglGetGammaTableParametersI3D
+typedef BOOL (APIENTRYP PFNWGLSETGAMMATABLEPARAMETERSI3DPROC)(HDC hDC, int iAttribute, const int *piValue);
+GLAPI PFNWGLSETGAMMATABLEPARAMETERSI3DPROC glad_wglSetGammaTableParametersI3D;
+#define wglSetGammaTableParametersI3D glad_wglSetGammaTableParametersI3D
+typedef BOOL (APIENTRYP PFNWGLGETGAMMATABLEI3DPROC)(HDC hDC, int iEntries, USHORT *puRed, USHORT *puGreen, USHORT *puBlue);
+GLAPI PFNWGLGETGAMMATABLEI3DPROC glad_wglGetGammaTableI3D;
+#define wglGetGammaTableI3D glad_wglGetGammaTableI3D
+typedef BOOL (APIENTRYP PFNWGLSETGAMMATABLEI3DPROC)(HDC hDC, int iEntries, const USHORT *puRed, const USHORT *puGreen, const USHORT *puBlue);
+GLAPI PFNWGLSETGAMMATABLEI3DPROC glad_wglSetGammaTableI3D;
+#define wglSetGammaTableI3D glad_wglSetGammaTableI3D
+#endif
+#ifndef WGL_I3D_genlock
+#define WGL_I3D_genlock 1
+GLAPI int GLAD_WGL_I3D_genlock;
+typedef BOOL (APIENTRYP PFNWGLENABLEGENLOCKI3DPROC)(HDC hDC);
+GLAPI PFNWGLENABLEGENLOCKI3DPROC glad_wglEnableGenlockI3D;
+#define wglEnableGenlockI3D glad_wglEnableGenlockI3D
+typedef BOOL (APIENTRYP PFNWGLDISABLEGENLOCKI3DPROC)(HDC hDC);
+GLAPI PFNWGLDISABLEGENLOCKI3DPROC glad_wglDisableGenlockI3D;
+#define wglDisableGenlockI3D glad_wglDisableGenlockI3D
+typedef BOOL (APIENTRYP PFNWGLISENABLEDGENLOCKI3DPROC)(HDC hDC, BOOL *pFlag);
+GLAPI PFNWGLISENABLEDGENLOCKI3DPROC glad_wglIsEnabledGenlockI3D;
+#define wglIsEnabledGenlockI3D glad_wglIsEnabledGenlockI3D
+typedef BOOL (APIENTRYP PFNWGLGENLOCKSOURCEI3DPROC)(HDC hDC, UINT uSource);
+GLAPI PFNWGLGENLOCKSOURCEI3DPROC glad_wglGenlockSourceI3D;
+#define wglGenlockSourceI3D glad_wglGenlockSourceI3D
+typedef BOOL (APIENTRYP PFNWGLGETGENLOCKSOURCEI3DPROC)(HDC hDC, UINT *uSource);
+GLAPI PFNWGLGETGENLOCKSOURCEI3DPROC glad_wglGetGenlockSourceI3D;
+#define wglGetGenlockSourceI3D glad_wglGetGenlockSourceI3D
+typedef BOOL (APIENTRYP PFNWGLGENLOCKSOURCEEDGEI3DPROC)(HDC hDC, UINT uEdge);
+GLAPI PFNWGLGENLOCKSOURCEEDGEI3DPROC glad_wglGenlockSourceEdgeI3D;
+#define wglGenlockSourceEdgeI3D glad_wglGenlockSourceEdgeI3D
+typedef BOOL (APIENTRYP PFNWGLGETGENLOCKSOURCEEDGEI3DPROC)(HDC hDC, UINT *uEdge);
+GLAPI PFNWGLGETGENLOCKSOURCEEDGEI3DPROC glad_wglGetGenlockSourceEdgeI3D;
+#define wglGetGenlockSourceEdgeI3D glad_wglGetGenlockSourceEdgeI3D
+typedef BOOL (APIENTRYP PFNWGLGENLOCKSAMPLERATEI3DPROC)(HDC hDC, UINT uRate);
+GLAPI PFNWGLGENLOCKSAMPLERATEI3DPROC glad_wglGenlockSampleRateI3D;
+#define wglGenlockSampleRateI3D glad_wglGenlockSampleRateI3D
+typedef BOOL (APIENTRYP PFNWGLGETGENLOCKSAMPLERATEI3DPROC)(HDC hDC, UINT *uRate);
+GLAPI PFNWGLGETGENLOCKSAMPLERATEI3DPROC glad_wglGetGenlockSampleRateI3D;
+#define wglGetGenlockSampleRateI3D glad_wglGetGenlockSampleRateI3D
+typedef BOOL (APIENTRYP PFNWGLGENLOCKSOURCEDELAYI3DPROC)(HDC hDC, UINT uDelay);
+GLAPI PFNWGLGENLOCKSOURCEDELAYI3DPROC glad_wglGenlockSourceDelayI3D;
+#define wglGenlockSourceDelayI3D glad_wglGenlockSourceDelayI3D
+typedef BOOL (APIENTRYP PFNWGLGETGENLOCKSOURCEDELAYI3DPROC)(HDC hDC, UINT *uDelay);
+GLAPI PFNWGLGETGENLOCKSOURCEDELAYI3DPROC glad_wglGetGenlockSourceDelayI3D;
+#define wglGetGenlockSourceDelayI3D glad_wglGetGenlockSourceDelayI3D
+typedef BOOL (APIENTRYP PFNWGLQUERYGENLOCKMAXSOURCEDELAYI3DPROC)(HDC hDC, UINT *uMaxLineDelay, UINT *uMaxPixelDelay);
+GLAPI PFNWGLQUERYGENLOCKMAXSOURCEDELAYI3DPROC glad_wglQueryGenlockMaxSourceDelayI3D;
+#define wglQueryGenlockMaxSourceDelayI3D glad_wglQueryGenlockMaxSourceDelayI3D
+#endif
+#ifndef WGL_I3D_image_buffer
+#define WGL_I3D_image_buffer 1
+GLAPI int GLAD_WGL_I3D_image_buffer;
+typedef LPVOID (APIENTRYP PFNWGLCREATEIMAGEBUFFERI3DPROC)(HDC hDC, DWORD dwSize, UINT uFlags);
+GLAPI PFNWGLCREATEIMAGEBUFFERI3DPROC glad_wglCreateImageBufferI3D;
+#define wglCreateImageBufferI3D glad_wglCreateImageBufferI3D
+typedef BOOL (APIENTRYP PFNWGLDESTROYIMAGEBUFFERI3DPROC)(HDC hDC, LPVOID pAddress);
+GLAPI PFNWGLDESTROYIMAGEBUFFERI3DPROC glad_wglDestroyImageBufferI3D;
+#define wglDestroyImageBufferI3D glad_wglDestroyImageBufferI3D
+typedef BOOL (APIENTRYP PFNWGLASSOCIATEIMAGEBUFFEREVENTSI3DPROC)(HDC hDC, const HANDLE *pEvent, const LPVOID *pAddress, const DWORD *pSize, UINT count);
+GLAPI PFNWGLASSOCIATEIMAGEBUFFEREVENTSI3DPROC glad_wglAssociateImageBufferEventsI3D;
+#define wglAssociateImageBufferEventsI3D glad_wglAssociateImageBufferEventsI3D
+typedef BOOL (APIENTRYP PFNWGLRELEASEIMAGEBUFFEREVENTSI3DPROC)(HDC hDC, const LPVOID *pAddress, UINT count);
+GLAPI PFNWGLRELEASEIMAGEBUFFEREVENTSI3DPROC glad_wglReleaseImageBufferEventsI3D;
+#define wglReleaseImageBufferEventsI3D glad_wglReleaseImageBufferEventsI3D
+#endif
+#ifndef WGL_I3D_swap_frame_lock
+#define WGL_I3D_swap_frame_lock 1
+GLAPI int GLAD_WGL_I3D_swap_frame_lock;
+typedef BOOL (APIENTRYP PFNWGLENABLEFRAMELOCKI3DPROC)();
+GLAPI PFNWGLENABLEFRAMELOCKI3DPROC glad_wglEnableFrameLockI3D;
+#define wglEnableFrameLockI3D glad_wglEnableFrameLockI3D
+typedef BOOL (APIENTRYP PFNWGLDISABLEFRAMELOCKI3DPROC)();
+GLAPI PFNWGLDISABLEFRAMELOCKI3DPROC glad_wglDisableFrameLockI3D;
+#define wglDisableFrameLockI3D glad_wglDisableFrameLockI3D
+typedef BOOL (APIENTRYP PFNWGLISENABLEDFRAMELOCKI3DPROC)(BOOL *pFlag);
+GLAPI PFNWGLISENABLEDFRAMELOCKI3DPROC glad_wglIsEnabledFrameLockI3D;
+#define wglIsEnabledFrameLockI3D glad_wglIsEnabledFrameLockI3D
+typedef BOOL (APIENTRYP PFNWGLQUERYFRAMELOCKMASTERI3DPROC)(BOOL *pFlag);
+GLAPI PFNWGLQUERYFRAMELOCKMASTERI3DPROC glad_wglQueryFrameLockMasterI3D;
+#define wglQueryFrameLockMasterI3D glad_wglQueryFrameLockMasterI3D
+#endif
+#ifndef WGL_I3D_swap_frame_usage
+#define WGL_I3D_swap_frame_usage 1
+GLAPI int GLAD_WGL_I3D_swap_frame_usage;
+typedef BOOL (APIENTRYP PFNWGLGETFRAMEUSAGEI3DPROC)(float *pUsage);
+GLAPI PFNWGLGETFRAMEUSAGEI3DPROC glad_wglGetFrameUsageI3D;
+#define wglGetFrameUsageI3D glad_wglGetFrameUsageI3D
+typedef BOOL (APIENTRYP PFNWGLBEGINFRAMETRACKINGI3DPROC)();
+GLAPI PFNWGLBEGINFRAMETRACKINGI3DPROC glad_wglBeginFrameTrackingI3D;
+#define wglBeginFrameTrackingI3D glad_wglBeginFrameTrackingI3D
+typedef BOOL (APIENTRYP PFNWGLENDFRAMETRACKINGI3DPROC)();
+GLAPI PFNWGLENDFRAMETRACKINGI3DPROC glad_wglEndFrameTrackingI3D;
+#define wglEndFrameTrackingI3D glad_wglEndFrameTrackingI3D
+typedef BOOL (APIENTRYP PFNWGLQUERYFRAMETRACKINGI3DPROC)(DWORD *pFrameCount, DWORD *pMissedFrames, float *pLastMissedUsage);
+GLAPI PFNWGLQUERYFRAMETRACKINGI3DPROC glad_wglQueryFrameTrackingI3D;
+#define wglQueryFrameTrackingI3D glad_wglQueryFrameTrackingI3D
+#endif
+#ifndef WGL_NV_DX_interop
+#define WGL_NV_DX_interop 1
+GLAPI int GLAD_WGL_NV_DX_interop;
+typedef BOOL (APIENTRYP PFNWGLDXSETRESOURCESHAREHANDLENVPROC)(void *dxObject, HANDLE shareHandle);
+GLAPI PFNWGLDXSETRESOURCESHAREHANDLENVPROC glad_wglDXSetResourceShareHandleNV;
+#define wglDXSetResourceShareHandleNV glad_wglDXSetResourceShareHandleNV
+typedef HANDLE (APIENTRYP PFNWGLDXOPENDEVICENVPROC)(void *dxDevice);
+GLAPI PFNWGLDXOPENDEVICENVPROC glad_wglDXOpenDeviceNV;
+#define wglDXOpenDeviceNV glad_wglDXOpenDeviceNV
+typedef BOOL (APIENTRYP PFNWGLDXCLOSEDEVICENVPROC)(HANDLE hDevice);
+GLAPI PFNWGLDXCLOSEDEVICENVPROC glad_wglDXCloseDeviceNV;
+#define wglDXCloseDeviceNV glad_wglDXCloseDeviceNV
+typedef HANDLE (APIENTRYP PFNWGLDXREGISTEROBJECTNVPROC)(HANDLE hDevice, void *dxObject, GLuint name, GLenum type, GLenum access);
+GLAPI PFNWGLDXREGISTEROBJECTNVPROC glad_wglDXRegisterObjectNV;
+#define wglDXRegisterObjectNV glad_wglDXRegisterObjectNV
+typedef BOOL (APIENTRYP PFNWGLDXUNREGISTEROBJECTNVPROC)(HANDLE hDevice, HANDLE hObject);
+GLAPI PFNWGLDXUNREGISTEROBJECTNVPROC glad_wglDXUnregisterObjectNV;
+#define wglDXUnregisterObjectNV glad_wglDXUnregisterObjectNV
+typedef BOOL (APIENTRYP PFNWGLDXOBJECTACCESSNVPROC)(HANDLE hObject, GLenum access);
+GLAPI PFNWGLDXOBJECTACCESSNVPROC glad_wglDXObjectAccessNV;
+#define wglDXObjectAccessNV glad_wglDXObjectAccessNV
+typedef BOOL (APIENTRYP PFNWGLDXLOCKOBJECTSNVPROC)(HANDLE hDevice, GLint count, HANDLE *hObjects);
+GLAPI PFNWGLDXLOCKOBJECTSNVPROC glad_wglDXLockObjectsNV;
+#define wglDXLockObjectsNV glad_wglDXLockObjectsNV
+typedef BOOL (APIENTRYP PFNWGLDXUNLOCKOBJECTSNVPROC)(HANDLE hDevice, GLint count, HANDLE *hObjects);
+GLAPI PFNWGLDXUNLOCKOBJECTSNVPROC glad_wglDXUnlockObjectsNV;
+#define wglDXUnlockObjectsNV glad_wglDXUnlockObjectsNV
+#endif
+#ifndef WGL_NV_DX_interop2
+#define WGL_NV_DX_interop2 1
+GLAPI int GLAD_WGL_NV_DX_interop2;
+#endif
+#ifndef WGL_NV_copy_image
+#define WGL_NV_copy_image 1
+GLAPI int GLAD_WGL_NV_copy_image;
+typedef BOOL (APIENTRYP PFNWGLCOPYIMAGESUBDATANVPROC)(HGLRC hSrcRC, GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, HGLRC hDstRC, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei width, GLsizei height, GLsizei depth);
+GLAPI PFNWGLCOPYIMAGESUBDATANVPROC glad_wglCopyImageSubDataNV;
+#define wglCopyImageSubDataNV glad_wglCopyImageSubDataNV
+#endif
+#ifndef WGL_NV_delay_before_swap
+#define WGL_NV_delay_before_swap 1
+GLAPI int GLAD_WGL_NV_delay_before_swap;
+typedef BOOL (APIENTRYP PFNWGLDELAYBEFORESWAPNVPROC)(HDC hDC, GLfloat seconds);
+GLAPI PFNWGLDELAYBEFORESWAPNVPROC glad_wglDelayBeforeSwapNV;
+#define wglDelayBeforeSwapNV glad_wglDelayBeforeSwapNV
+#endif
+#ifndef WGL_NV_float_buffer
+#define WGL_NV_float_buffer 1
+GLAPI int GLAD_WGL_NV_float_buffer;
+#endif
+#ifndef WGL_NV_gpu_affinity
+#define WGL_NV_gpu_affinity 1
+GLAPI int GLAD_WGL_NV_gpu_affinity;
+typedef BOOL (APIENTRYP PFNWGLENUMGPUSNVPROC)(UINT iGpuIndex, HGPUNV *phGpu);
+GLAPI PFNWGLENUMGPUSNVPROC glad_wglEnumGpusNV;
+#define wglEnumGpusNV glad_wglEnumGpusNV
+typedef BOOL (APIENTRYP PFNWGLENUMGPUDEVICESNVPROC)(HGPUNV hGpu, UINT iDeviceIndex, PGPU_DEVICE lpGpuDevice);
+GLAPI PFNWGLENUMGPUDEVICESNVPROC glad_wglEnumGpuDevicesNV;
+#define wglEnumGpuDevicesNV glad_wglEnumGpuDevicesNV
+typedef HDC (APIENTRYP PFNWGLCREATEAFFINITYDCNVPROC)(const HGPUNV *phGpuList);
+GLAPI PFNWGLCREATEAFFINITYDCNVPROC glad_wglCreateAffinityDCNV;
+#define wglCreateAffinityDCNV glad_wglCreateAffinityDCNV
+typedef BOOL (APIENTRYP PFNWGLENUMGPUSFROMAFFINITYDCNVPROC)(HDC hAffinityDC, UINT iGpuIndex, HGPUNV *hGpu);
+GLAPI PFNWGLENUMGPUSFROMAFFINITYDCNVPROC glad_wglEnumGpusFromAffinityDCNV;
+#define wglEnumGpusFromAffinityDCNV glad_wglEnumGpusFromAffinityDCNV
+typedef BOOL (APIENTRYP PFNWGLDELETEDCNVPROC)(HDC hdc);
+GLAPI PFNWGLDELETEDCNVPROC glad_wglDeleteDCNV;
+#define wglDeleteDCNV glad_wglDeleteDCNV
+#endif
+#ifndef WGL_NV_multisample_coverage
+#define WGL_NV_multisample_coverage 1
+GLAPI int GLAD_WGL_NV_multisample_coverage;
+#endif
+#ifndef WGL_NV_present_video
+#define WGL_NV_present_video 1
+GLAPI int GLAD_WGL_NV_present_video;
+typedef int (APIENTRYP PFNWGLENUMERATEVIDEODEVICESNVPROC)(HDC hDC, HVIDEOOUTPUTDEVICENV *phDeviceList);
+GLAPI PFNWGLENUMERATEVIDEODEVICESNVPROC glad_wglEnumerateVideoDevicesNV;
+#define wglEnumerateVideoDevicesNV glad_wglEnumerateVideoDevicesNV
+typedef BOOL (APIENTRYP PFNWGLBINDVIDEODEVICENVPROC)(HDC hDC, unsigned int uVideoSlot, HVIDEOOUTPUTDEVICENV hVideoDevice, const int *piAttribList);
+GLAPI PFNWGLBINDVIDEODEVICENVPROC glad_wglBindVideoDeviceNV;
+#define wglBindVideoDeviceNV glad_wglBindVideoDeviceNV
+typedef BOOL (APIENTRYP PFNWGLQUERYCURRENTCONTEXTNVPROC)(int iAttribute, int *piValue);
+GLAPI PFNWGLQUERYCURRENTCONTEXTNVPROC glad_wglQueryCurrentContextNV;
+#define wglQueryCurrentContextNV glad_wglQueryCurrentContextNV
+#endif
+#ifndef WGL_NV_render_depth_texture
+#define WGL_NV_render_depth_texture 1
+GLAPI int GLAD_WGL_NV_render_depth_texture;
+#endif
+#ifndef WGL_NV_render_texture_rectangle
+#define WGL_NV_render_texture_rectangle 1
+GLAPI int GLAD_WGL_NV_render_texture_rectangle;
+#endif
+#ifndef WGL_NV_swap_group
+#define WGL_NV_swap_group 1
+GLAPI int GLAD_WGL_NV_swap_group;
+typedef BOOL (APIENTRYP PFNWGLJOINSWAPGROUPNVPROC)(HDC hDC, GLuint group);
+GLAPI PFNWGLJOINSWAPGROUPNVPROC glad_wglJoinSwapGroupNV;
+#define wglJoinSwapGroupNV glad_wglJoinSwapGroupNV
+typedef BOOL (APIENTRYP PFNWGLBINDSWAPBARRIERNVPROC)(GLuint group, GLuint barrier);
+GLAPI PFNWGLBINDSWAPBARRIERNVPROC glad_wglBindSwapBarrierNV;
+#define wglBindSwapBarrierNV glad_wglBindSwapBarrierNV
+typedef BOOL (APIENTRYP PFNWGLQUERYSWAPGROUPNVPROC)(HDC hDC, GLuint *group, GLuint *barrier);
+GLAPI PFNWGLQUERYSWAPGROUPNVPROC glad_wglQuerySwapGroupNV;
+#define wglQuerySwapGroupNV glad_wglQuerySwapGroupNV
+typedef BOOL (APIENTRYP PFNWGLQUERYMAXSWAPGROUPSNVPROC)(HDC hDC, GLuint *maxGroups, GLuint *maxBarriers);
+GLAPI PFNWGLQUERYMAXSWAPGROUPSNVPROC glad_wglQueryMaxSwapGroupsNV;
+#define wglQueryMaxSwapGroupsNV glad_wglQueryMaxSwapGroupsNV
+typedef BOOL (APIENTRYP PFNWGLQUERYFRAMECOUNTNVPROC)(HDC hDC, GLuint *count);
+GLAPI PFNWGLQUERYFRAMECOUNTNVPROC glad_wglQueryFrameCountNV;
+#define wglQueryFrameCountNV glad_wglQueryFrameCountNV
+typedef BOOL (APIENTRYP PFNWGLRESETFRAMECOUNTNVPROC)(HDC hDC);
+GLAPI PFNWGLRESETFRAMECOUNTNVPROC glad_wglResetFrameCountNV;
+#define wglResetFrameCountNV glad_wglResetFrameCountNV
+#endif
+#ifndef WGL_NV_vertex_array_range
+#define WGL_NV_vertex_array_range 1
+GLAPI int GLAD_WGL_NV_vertex_array_range;
+typedef void * (APIENTRYP PFNWGLALLOCATEMEMORYNVPROC)(GLsizei size, GLfloat readfreq, GLfloat writefreq, GLfloat priority);
+GLAPI PFNWGLALLOCATEMEMORYNVPROC glad_wglAllocateMemoryNV;
+#define wglAllocateMemoryNV glad_wglAllocateMemoryNV
+typedef void (APIENTRYP PFNWGLFREEMEMORYNVPROC)(void *pointer);
+GLAPI PFNWGLFREEMEMORYNVPROC glad_wglFreeMemoryNV;
+#define wglFreeMemoryNV glad_wglFreeMemoryNV
+#endif
+#ifndef WGL_NV_video_capture
+#define WGL_NV_video_capture 1
+GLAPI int GLAD_WGL_NV_video_capture;
+typedef BOOL (APIENTRYP PFNWGLBINDVIDEOCAPTUREDEVICENVPROC)(UINT uVideoSlot, HVIDEOINPUTDEVICENV hDevice);
+GLAPI PFNWGLBINDVIDEOCAPTUREDEVICENVPROC glad_wglBindVideoCaptureDeviceNV;
+#define wglBindVideoCaptureDeviceNV glad_wglBindVideoCaptureDeviceNV
+typedef UINT (APIENTRYP PFNWGLENUMERATEVIDEOCAPTUREDEVICESNVPROC)(HDC hDc, HVIDEOINPUTDEVICENV *phDeviceList);
+GLAPI PFNWGLENUMERATEVIDEOCAPTUREDEVICESNVPROC glad_wglEnumerateVideoCaptureDevicesNV;
+#define wglEnumerateVideoCaptureDevicesNV glad_wglEnumerateVideoCaptureDevicesNV
+typedef BOOL (APIENTRYP PFNWGLLOCKVIDEOCAPTUREDEVICENVPROC)(HDC hDc, HVIDEOINPUTDEVICENV hDevice);
+GLAPI PFNWGLLOCKVIDEOCAPTUREDEVICENVPROC glad_wglLockVideoCaptureDeviceNV;
+#define wglLockVideoCaptureDeviceNV glad_wglLockVideoCaptureDeviceNV
+typedef BOOL (APIENTRYP PFNWGLQUERYVIDEOCAPTUREDEVICENVPROC)(HDC hDc, HVIDEOINPUTDEVICENV hDevice, int iAttribute, int *piValue);
+GLAPI PFNWGLQUERYVIDEOCAPTUREDEVICENVPROC glad_wglQueryVideoCaptureDeviceNV;
+#define wglQueryVideoCaptureDeviceNV glad_wglQueryVideoCaptureDeviceNV
+typedef BOOL (APIENTRYP PFNWGLRELEASEVIDEOCAPTUREDEVICENVPROC)(HDC hDc, HVIDEOINPUTDEVICENV hDevice);
+GLAPI PFNWGLRELEASEVIDEOCAPTUREDEVICENVPROC glad_wglReleaseVideoCaptureDeviceNV;
+#define wglReleaseVideoCaptureDeviceNV glad_wglReleaseVideoCaptureDeviceNV
+#endif
+#ifndef WGL_NV_video_output
+#define WGL_NV_video_output 1
+GLAPI int GLAD_WGL_NV_video_output;
+typedef BOOL (APIENTRYP PFNWGLGETVIDEODEVICENVPROC)(HDC hDC, int numDevices, HPVIDEODEV *hVideoDevice);
+GLAPI PFNWGLGETVIDEODEVICENVPROC glad_wglGetVideoDeviceNV;
+#define wglGetVideoDeviceNV glad_wglGetVideoDeviceNV
+typedef BOOL (APIENTRYP PFNWGLRELEASEVIDEODEVICENVPROC)(HPVIDEODEV hVideoDevice);
+GLAPI PFNWGLRELEASEVIDEODEVICENVPROC glad_wglReleaseVideoDeviceNV;
+#define wglReleaseVideoDeviceNV glad_wglReleaseVideoDeviceNV
+typedef BOOL (APIENTRYP PFNWGLBINDVIDEOIMAGENVPROC)(HPVIDEODEV hVideoDevice, HPBUFFERARB hPbuffer, int iVideoBuffer);
+GLAPI PFNWGLBINDVIDEOIMAGENVPROC glad_wglBindVideoImageNV;
+#define wglBindVideoImageNV glad_wglBindVideoImageNV
+typedef BOOL (APIENTRYP PFNWGLRELEASEVIDEOIMAGENVPROC)(HPBUFFERARB hPbuffer, int iVideoBuffer);
+GLAPI PFNWGLRELEASEVIDEOIMAGENVPROC glad_wglReleaseVideoImageNV;
+#define wglReleaseVideoImageNV glad_wglReleaseVideoImageNV
+typedef BOOL (APIENTRYP PFNWGLSENDPBUFFERTOVIDEONVPROC)(HPBUFFERARB hPbuffer, int iBufferType, unsigned long *pulCounterPbuffer, BOOL bBlock);
+GLAPI PFNWGLSENDPBUFFERTOVIDEONVPROC glad_wglSendPbufferToVideoNV;
+#define wglSendPbufferToVideoNV glad_wglSendPbufferToVideoNV
+typedef BOOL (APIENTRYP PFNWGLGETVIDEOINFONVPROC)(HPVIDEODEV hpVideoDevice, unsigned long *pulCounterOutputPbuffer, unsigned long *pulCounterOutputVideo);
+GLAPI PFNWGLGETVIDEOINFONVPROC glad_wglGetVideoInfoNV;
+#define wglGetVideoInfoNV glad_wglGetVideoInfoNV
+#endif
+#ifndef WGL_OML_sync_control
+#define WGL_OML_sync_control 1
+GLAPI int GLAD_WGL_OML_sync_control;
+typedef BOOL (APIENTRYP PFNWGLGETSYNCVALUESOMLPROC)(HDC hdc, INT64 *ust, INT64 *msc, INT64 *sbc);
+GLAPI PFNWGLGETSYNCVALUESOMLPROC glad_wglGetSyncValuesOML;
+#define wglGetSyncValuesOML glad_wglGetSyncValuesOML
+typedef BOOL (APIENTRYP PFNWGLGETMSCRATEOMLPROC)(HDC hdc, INT32 *numerator, INT32 *denominator);
+GLAPI PFNWGLGETMSCRATEOMLPROC glad_wglGetMscRateOML;
+#define wglGetMscRateOML glad_wglGetMscRateOML
+typedef INT64 (APIENTRYP PFNWGLSWAPBUFFERSMSCOMLPROC)(HDC hdc, INT64 target_msc, INT64 divisor, INT64 remainder);
+GLAPI PFNWGLSWAPBUFFERSMSCOMLPROC glad_wglSwapBuffersMscOML;
+#define wglSwapBuffersMscOML glad_wglSwapBuffersMscOML
+typedef INT64 (APIENTRYP PFNWGLSWAPLAYERBUFFERSMSCOMLPROC)(HDC hdc, int fuPlanes, INT64 target_msc, INT64 divisor, INT64 remainder);
+GLAPI PFNWGLSWAPLAYERBUFFERSMSCOMLPROC glad_wglSwapLayerBuffersMscOML;
+#define wglSwapLayerBuffersMscOML glad_wglSwapLayerBuffersMscOML
+typedef BOOL (APIENTRYP PFNWGLWAITFORMSCOMLPROC)(HDC hdc, INT64 target_msc, INT64 divisor, INT64 remainder, INT64 *ust, INT64 *msc, INT64 *sbc);
+GLAPI PFNWGLWAITFORMSCOMLPROC glad_wglWaitForMscOML;
+#define wglWaitForMscOML glad_wglWaitForMscOML
+typedef BOOL (APIENTRYP PFNWGLWAITFORSBCOMLPROC)(HDC hdc, INT64 target_sbc, INT64 *ust, INT64 *msc, INT64 *sbc);
+GLAPI PFNWGLWAITFORSBCOMLPROC glad_wglWaitForSbcOML;
+#define wglWaitForSbcOML glad_wglWaitForSbcOML
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

Engine/lib/glad/src/glx/glad_glx.c

@@ -0,0 +1,827 @@
+/*
+
+    GLX loader generated by glad 0.1.12a0 on Mon Sep 12 03:11:58 2016.
+
+    Language/Generator: C/C++
+    Specification: glx
+    APIs: glx=1.4
+    Profile: -
+    Extensions:
+        GLX_3DFX_multisample,
+        GLX_AMD_gpu_association,
+        GLX_ARB_context_flush_control,
+        GLX_ARB_create_context,
+        GLX_ARB_create_context_profile,
+        GLX_ARB_create_context_robustness,
+        GLX_ARB_fbconfig_float,
+        GLX_ARB_framebuffer_sRGB,
+        GLX_ARB_get_proc_address,
+        GLX_ARB_multisample,
+        GLX_ARB_robustness_application_isolation,
+        GLX_ARB_robustness_share_group_isolation,
+        GLX_ARB_vertex_buffer_object,
+        GLX_EXT_buffer_age,
+        GLX_EXT_create_context_es2_profile,
+        GLX_EXT_create_context_es_profile,
+        GLX_EXT_fbconfig_packed_float,
+        GLX_EXT_framebuffer_sRGB,
+        GLX_EXT_import_context,
+        GLX_EXT_libglvnd,
+        GLX_EXT_stereo_tree,
+        GLX_EXT_swap_control,
+        GLX_EXT_swap_control_tear,
+        GLX_EXT_texture_from_pixmap,
+        GLX_EXT_visual_info,
+        GLX_EXT_visual_rating,
+        GLX_INTEL_swap_event,
+        GLX_MESA_agp_offset,
+        GLX_MESA_copy_sub_buffer,
+        GLX_MESA_pixmap_colormap,
+        GLX_MESA_query_renderer,
+        GLX_MESA_release_buffers,
+        GLX_MESA_set_3dfx_mode,
+        GLX_NV_copy_buffer,
+        GLX_NV_copy_image,
+        GLX_NV_delay_before_swap,
+        GLX_NV_float_buffer,
+        GLX_NV_multisample_coverage,
+        GLX_NV_present_video,
+        GLX_NV_robustness_video_memory_purge,
+        GLX_NV_swap_group,
+        GLX_NV_video_capture,
+        GLX_NV_video_out,
+        GLX_OML_swap_method,
+        GLX_OML_sync_control,
+        GLX_SGIS_blended_overlay,
+        GLX_SGIS_multisample,
+        GLX_SGIS_shared_multisample,
+        GLX_SGIX_dmbuffer,
+        GLX_SGIX_fbconfig,
+        GLX_SGIX_hyperpipe,
+        GLX_SGIX_pbuffer,
+        GLX_SGIX_swap_barrier,
+        GLX_SGIX_swap_group,
+        GLX_SGIX_video_resize,
+        GLX_SGIX_video_source,
+        GLX_SGIX_visual_select_group,
+        GLX_SGI_cushion,
+        GLX_SGI_make_current_read,
+        GLX_SGI_swap_control,
+        GLX_SGI_video_sync,
+        GLX_SUN_get_transparent_index
+    Loader: True
+    Local files: False
+    Omit khrplatform: False
+
+    Commandline:
+        --api="glx=1.4" --generator="c" --spec="glx" --extensions="GLX_3DFX_multisample,GLX_AMD_gpu_association,GLX_ARB_context_flush_control,GLX_ARB_create_context,GLX_ARB_create_context_profile,GLX_ARB_create_context_robustness,GLX_ARB_fbconfig_float,GLX_ARB_framebuffer_sRGB,GLX_ARB_get_proc_address,GLX_ARB_multisample,GLX_ARB_robustness_application_isolation,GLX_ARB_robustness_share_group_isolation,GLX_ARB_vertex_buffer_object,GLX_EXT_buffer_age,GLX_EXT_create_context_es2_profile,GLX_EXT_create_context_es_profile,GLX_EXT_fbconfig_packed_float,GLX_EXT_framebuffer_sRGB,GLX_EXT_import_context,GLX_EXT_libglvnd,GLX_EXT_stereo_tree,GLX_EXT_swap_control,GLX_EXT_swap_control_tear,GLX_EXT_texture_from_pixmap,GLX_EXT_visual_info,GLX_EXT_visual_rating,GLX_INTEL_swap_event,GLX_MESA_agp_offset,GLX_MESA_copy_sub_buffer,GLX_MESA_pixmap_colormap,GLX_MESA_query_renderer,GLX_MESA_release_buffers,GLX_MESA_set_3dfx_mode,GLX_NV_copy_buffer,GLX_NV_copy_image,GLX_NV_delay_before_swap,GLX_NV_float_buffer,GLX_NV_multisample_coverage,GLX_NV_present_video,GLX_NV_robustness_video_memory_purge,GLX_NV_swap_group,GLX_NV_video_capture,GLX_NV_video_out,GLX_OML_swap_method,GLX_OML_sync_control,GLX_SGIS_blended_overlay,GLX_SGIS_multisample,GLX_SGIS_shared_multisample,GLX_SGIX_dmbuffer,GLX_SGIX_fbconfig,GLX_SGIX_hyperpipe,GLX_SGIX_pbuffer,GLX_SGIX_swap_barrier,GLX_SGIX_swap_group,GLX_SGIX_video_resize,GLX_SGIX_video_source,GLX_SGIX_visual_select_group,GLX_SGI_cushion,GLX_SGI_make_current_read,GLX_SGI_swap_control,GLX_SGI_video_sync,GLX_SUN_get_transparent_index"
+    Online:
+        Too many extensions
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <glad/glad_glx.h>
+
+static void* get_proc(const char *namez);
+
+#ifdef _WIN32
+#include <windows.h>
+static HMODULE libGL;
+
+typedef void* (APIENTRYP PFNWGLGETPROCADDRESSPROC_PRIVATE)(const char*);
+PFNWGLGETPROCADDRESSPROC_PRIVATE gladGetProcAddressPtr;
+
+static
+int open_gl(void) {
+    libGL = LoadLibraryW(L"opengl32.dll");
+    if(libGL != NULL) {
+        gladGetProcAddressPtr = (PFNWGLGETPROCADDRESSPROC_PRIVATE)GetProcAddress(
+                libGL, "wglGetProcAddress");
+        return gladGetProcAddressPtr != NULL;
+    }
+
+    return 0;
+}
+
+static
+void close_gl(void) {
+    if(libGL != NULL) {
+        FreeLibrary(libGL);
+        libGL = NULL;
+    }
+}
+#else
+#include <dlfcn.h>
+static void* libGL;
+
+#ifndef __APPLE__
+typedef void* (APIENTRYP PFNGLXGETPROCADDRESSPROC_PRIVATE)(const char*);
+PFNGLXGETPROCADDRESSPROC_PRIVATE gladGetProcAddressPtr;
+#endif
+
+static
+int open_gl(void) {
+#ifdef __APPLE__
+    static const char *NAMES[] = {
+        "../Frameworks/OpenGL.framework/OpenGL",
+        "/Library/Frameworks/OpenGL.framework/OpenGL",
+        "/System/Library/Frameworks/OpenGL.framework/OpenGL",
+        "/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL"
+    };
+#else
+    static const char *NAMES[] = {"libGL.so.1", "libGL.so"};
+#endif
+
+    unsigned int index = 0;
+    for(index = 0; index < (sizeof(NAMES) / sizeof(NAMES[0])); index++) {
+        libGL = dlopen(NAMES[index], RTLD_NOW | RTLD_GLOBAL);
+
+        if(libGL != NULL) {
+#ifdef __APPLE__
+            return 1;
+#else
+            gladGetProcAddressPtr = (PFNGLXGETPROCADDRESSPROC_PRIVATE)dlsym(libGL,
+                "glXGetProcAddressARB");
+            return gladGetProcAddressPtr != NULL;
+#endif
+        }
+    }
+
+    return 0;
+}
+
+static
+void close_gl() {
+    if(libGL != NULL) {
+        dlclose(libGL);
+        libGL = NULL;
+    }
+}
+#endif
+
+static
+void* get_proc(const char *namez) {
+    void* result = NULL;
+    if(libGL == NULL) return NULL;
+
+#ifndef __APPLE__
+    if(gladGetProcAddressPtr != NULL) {
+        result = gladGetProcAddressPtr(namez);
+    }
+#endif
+    if(result == NULL) {
+#ifdef _WIN32
+        result = (void*)GetProcAddress(libGL, namez);
+#else
+        result = dlsym(libGL, namez);
+#endif
+    }
+
+    return result;
+}
+
+int gladLoadGLX(Display *dpy, int screen) {
+    int status = 0;
+
+    if(open_gl()) {
+        status = gladLoadGLXLoader((GLADloadproc)get_proc, dpy, screen);
+        close_gl();
+    }
+
+    return status;
+}
+
+static Display *GLADGLXDisplay = 0;
+static int GLADGLXscreen = 0;
+
+static int get_exts(void) {
+    return 1;
+}
+
+static void free_exts(void) {
+    return;
+}
+
+static int has_ext(const char *ext) {
+    const char *terminator;
+    const char *loc;
+    const char *extensions;
+
+    if(!GLAD_GLX_VERSION_1_1)
+        return 0;
+
+    extensions = glXQueryExtensionsString(GLADGLXDisplay, GLADGLXscreen);
+
+    if(extensions == NULL || ext == NULL)
+        return 0;
+
+    while(1) {
+        loc = strstr(extensions, ext);
+        if(loc == NULL)
+            break;
+
+        terminator = loc + strlen(ext);
+        if((loc == extensions || *(loc - 1) == ' ') &&
+            (*terminator == ' ' || *terminator == '\0'))
+        {
+            return 1;
+        }
+        extensions = terminator;
+    }
+
+    return 0;
+}
+
+int GLAD_GLX_VERSION_1_0;
+int GLAD_GLX_VERSION_1_1;
+int GLAD_GLX_VERSION_1_2;
+int GLAD_GLX_VERSION_1_3;
+int GLAD_GLX_VERSION_1_4;
+PFNGLXGETSELECTEDEVENTPROC glad_glXGetSelectedEvent;
+PFNGLXQUERYEXTENSIONPROC glad_glXQueryExtension;
+PFNGLXMAKECURRENTPROC glad_glXMakeCurrent;
+PFNGLXSELECTEVENTPROC glad_glXSelectEvent;
+PFNGLXCREATECONTEXTPROC glad_glXCreateContext;
+PFNGLXCREATEGLXPIXMAPPROC glad_glXCreateGLXPixmap;
+PFNGLXQUERYVERSIONPROC glad_glXQueryVersion;
+PFNGLXGETCURRENTREADDRAWABLEPROC glad_glXGetCurrentReadDrawable;
+PFNGLXDESTROYPIXMAPPROC glad_glXDestroyPixmap;
+PFNGLXGETCURRENTCONTEXTPROC glad_glXGetCurrentContext;
+PFNGLXGETPROCADDRESSPROC glad_glXGetProcAddress;
+PFNGLXWAITGLPROC glad_glXWaitGL;
+PFNGLXISDIRECTPROC glad_glXIsDirect;
+PFNGLXDESTROYWINDOWPROC glad_glXDestroyWindow;
+PFNGLXCREATEWINDOWPROC glad_glXCreateWindow;
+PFNGLXCOPYCONTEXTPROC glad_glXCopyContext;
+PFNGLXCREATEPBUFFERPROC glad_glXCreatePbuffer;
+PFNGLXSWAPBUFFERSPROC glad_glXSwapBuffers;
+PFNGLXGETCURRENTDISPLAYPROC glad_glXGetCurrentDisplay;
+PFNGLXGETCURRENTDRAWABLEPROC glad_glXGetCurrentDrawable;
+PFNGLXQUERYCONTEXTPROC glad_glXQueryContext;
+PFNGLXCHOOSEVISUALPROC glad_glXChooseVisual;
+PFNGLXQUERYSERVERSTRINGPROC glad_glXQueryServerString;
+PFNGLXDESTROYCONTEXTPROC glad_glXDestroyContext;
+PFNGLXDESTROYGLXPIXMAPPROC glad_glXDestroyGLXPixmap;
+PFNGLXGETFBCONFIGATTRIBPROC glad_glXGetFBConfigAttrib;
+PFNGLXUSEXFONTPROC glad_glXUseXFont;
+PFNGLXDESTROYPBUFFERPROC glad_glXDestroyPbuffer;
+PFNGLXCHOOSEFBCONFIGPROC glad_glXChooseFBConfig;
+PFNGLXCREATENEWCONTEXTPROC glad_glXCreateNewContext;
+PFNGLXMAKECONTEXTCURRENTPROC glad_glXMakeContextCurrent;
+PFNGLXGETCONFIGPROC glad_glXGetConfig;
+PFNGLXGETFBCONFIGSPROC glad_glXGetFBConfigs;
+PFNGLXCREATEPIXMAPPROC glad_glXCreatePixmap;
+PFNGLXWAITXPROC glad_glXWaitX;
+PFNGLXGETVISUALFROMFBCONFIGPROC glad_glXGetVisualFromFBConfig;
+PFNGLXQUERYDRAWABLEPROC glad_glXQueryDrawable;
+PFNGLXQUERYEXTENSIONSSTRINGPROC glad_glXQueryExtensionsString;
+PFNGLXGETCLIENTSTRINGPROC glad_glXGetClientString;
+int GLAD_GLX_ARB_framebuffer_sRGB;
+int GLAD_GLX_EXT_import_context;
+int GLAD_GLX_EXT_libglvnd;
+int GLAD_GLX_SGIS_shared_multisample;
+int GLAD_GLX_SGIX_pbuffer;
+int GLAD_GLX_EXT_swap_control_tear;
+int GLAD_GLX_ARB_fbconfig_float;
+int GLAD_GLX_SGIX_hyperpipe;
+int GLAD_GLX_MESA_set_3dfx_mode;
+int GLAD_GLX_INTEL_swap_event;
+int GLAD_GLX_SGIX_video_resize;
+int GLAD_GLX_MESA_pixmap_colormap;
+int GLAD_GLX_EXT_create_context_es2_profile;
+int GLAD_GLX_ARB_robustness_application_isolation;
+int GLAD_GLX_NV_copy_image;
+int GLAD_GLX_NV_swap_group;
+int GLAD_GLX_OML_sync_control;
+int GLAD_GLX_EXT_framebuffer_sRGB;
+int GLAD_GLX_ARB_create_context_robustness;
+int GLAD_GLX_OML_swap_method;
+int GLAD_GLX_EXT_fbconfig_packed_float;
+int GLAD_GLX_EXT_buffer_age;
+int GLAD_GLX_3DFX_multisample;
+int GLAD_GLX_EXT_visual_info;
+int GLAD_GLX_SGI_video_sync;
+int GLAD_GLX_NV_video_capture;
+int GLAD_GLX_SGIS_multisample;
+int GLAD_GLX_EXT_texture_from_pixmap;
+int GLAD_GLX_NV_video_out;
+int GLAD_GLX_ARB_multisample;
+int GLAD_GLX_NV_delay_before_swap;
+int GLAD_GLX_SGI_make_current_read;
+int GLAD_GLX_SGIX_swap_group;
+int GLAD_GLX_EXT_swap_control;
+int GLAD_GLX_SGIX_video_source;
+int GLAD_GLX_MESA_query_renderer;
+int GLAD_GLX_NV_robustness_video_memory_purge;
+int GLAD_GLX_ARB_create_context;
+int GLAD_GLX_ARB_context_flush_control;
+int GLAD_GLX_ARB_robustness_share_group_isolation;
+int GLAD_GLX_EXT_stereo_tree;
+int GLAD_GLX_SGI_swap_control;
+int GLAD_GLX_SGIX_dmbuffer;
+int GLAD_GLX_SGIX_visual_select_group;
+int GLAD_GLX_SGIS_blended_overlay;
+int GLAD_GLX_NV_multisample_coverage;
+int GLAD_GLX_EXT_create_context_es_profile;
+int GLAD_GLX_SGIX_fbconfig;
+int GLAD_GLX_NV_float_buffer;
+int GLAD_GLX_SGI_cushion;
+int GLAD_GLX_MESA_release_buffers;
+int GLAD_GLX_EXT_visual_rating;
+int GLAD_GLX_MESA_copy_sub_buffer;
+int GLAD_GLX_MESA_agp_offset;
+int GLAD_GLX_NV_copy_buffer;
+int GLAD_GLX_NV_present_video;
+int GLAD_GLX_SUN_get_transparent_index;
+int GLAD_GLX_AMD_gpu_association;
+int GLAD_GLX_ARB_create_context_profile;
+int GLAD_GLX_SGIX_swap_barrier;
+int GLAD_GLX_ARB_get_proc_address;
+int GLAD_GLX_ARB_vertex_buffer_object;
+PFNGLXGETGPUIDSAMDPROC glad_glXGetGPUIDsAMD;
+PFNGLXGETGPUINFOAMDPROC glad_glXGetGPUInfoAMD;
+PFNGLXGETCONTEXTGPUIDAMDPROC glad_glXGetContextGPUIDAMD;
+PFNGLXCREATEASSOCIATEDCONTEXTAMDPROC glad_glXCreateAssociatedContextAMD;
+PFNGLXCREATEASSOCIATEDCONTEXTATTRIBSAMDPROC glad_glXCreateAssociatedContextAttribsAMD;
+PFNGLXDELETEASSOCIATEDCONTEXTAMDPROC glad_glXDeleteAssociatedContextAMD;
+PFNGLXMAKEASSOCIATEDCONTEXTCURRENTAMDPROC glad_glXMakeAssociatedContextCurrentAMD;
+PFNGLXGETCURRENTASSOCIATEDCONTEXTAMDPROC glad_glXGetCurrentAssociatedContextAMD;
+PFNGLXBLITCONTEXTFRAMEBUFFERAMDPROC glad_glXBlitContextFramebufferAMD;
+PFNGLXCREATECONTEXTATTRIBSARBPROC glad_glXCreateContextAttribsARB;
+PFNGLXGETPROCADDRESSARBPROC glad_glXGetProcAddressARB;
+PFNGLXGETCURRENTDISPLAYEXTPROC glad_glXGetCurrentDisplayEXT;
+PFNGLXQUERYCONTEXTINFOEXTPROC glad_glXQueryContextInfoEXT;
+PFNGLXGETCONTEXTIDEXTPROC glad_glXGetContextIDEXT;
+PFNGLXIMPORTCONTEXTEXTPROC glad_glXImportContextEXT;
+PFNGLXFREECONTEXTEXTPROC glad_glXFreeContextEXT;
+PFNGLXSWAPINTERVALEXTPROC glad_glXSwapIntervalEXT;
+PFNGLXBINDTEXIMAGEEXTPROC glad_glXBindTexImageEXT;
+PFNGLXRELEASETEXIMAGEEXTPROC glad_glXReleaseTexImageEXT;
+PFNGLXGETAGPOFFSETMESAPROC glad_glXGetAGPOffsetMESA;
+PFNGLXCOPYSUBBUFFERMESAPROC glad_glXCopySubBufferMESA;
+PFNGLXCREATEGLXPIXMAPMESAPROC glad_glXCreateGLXPixmapMESA;
+PFNGLXQUERYCURRENTRENDERERINTEGERMESAPROC glad_glXQueryCurrentRendererIntegerMESA;
+PFNGLXQUERYCURRENTRENDERERSTRINGMESAPROC glad_glXQueryCurrentRendererStringMESA;
+PFNGLXQUERYRENDERERINTEGERMESAPROC glad_glXQueryRendererIntegerMESA;
+PFNGLXQUERYRENDERERSTRINGMESAPROC glad_glXQueryRendererStringMESA;
+PFNGLXRELEASEBUFFERSMESAPROC glad_glXReleaseBuffersMESA;
+PFNGLXSET3DFXMODEMESAPROC glad_glXSet3DfxModeMESA;
+PFNGLXCOPYBUFFERSUBDATANVPROC glad_glXCopyBufferSubDataNV;
+PFNGLXNAMEDCOPYBUFFERSUBDATANVPROC glad_glXNamedCopyBufferSubDataNV;
+PFNGLXCOPYIMAGESUBDATANVPROC glad_glXCopyImageSubDataNV;
+PFNGLXDELAYBEFORESWAPNVPROC glad_glXDelayBeforeSwapNV;
+PFNGLXENUMERATEVIDEODEVICESNVPROC glad_glXEnumerateVideoDevicesNV;
+PFNGLXBINDVIDEODEVICENVPROC glad_glXBindVideoDeviceNV;
+PFNGLXJOINSWAPGROUPNVPROC glad_glXJoinSwapGroupNV;
+PFNGLXBINDSWAPBARRIERNVPROC glad_glXBindSwapBarrierNV;
+PFNGLXQUERYSWAPGROUPNVPROC glad_glXQuerySwapGroupNV;
+PFNGLXQUERYMAXSWAPGROUPSNVPROC glad_glXQueryMaxSwapGroupsNV;
+PFNGLXQUERYFRAMECOUNTNVPROC glad_glXQueryFrameCountNV;
+PFNGLXRESETFRAMECOUNTNVPROC glad_glXResetFrameCountNV;
+PFNGLXBINDVIDEOCAPTUREDEVICENVPROC glad_glXBindVideoCaptureDeviceNV;
+PFNGLXENUMERATEVIDEOCAPTUREDEVICESNVPROC glad_glXEnumerateVideoCaptureDevicesNV;
+PFNGLXLOCKVIDEOCAPTUREDEVICENVPROC glad_glXLockVideoCaptureDeviceNV;
+PFNGLXQUERYVIDEOCAPTUREDEVICENVPROC glad_glXQueryVideoCaptureDeviceNV;
+PFNGLXRELEASEVIDEOCAPTUREDEVICENVPROC glad_glXReleaseVideoCaptureDeviceNV;
+PFNGLXGETVIDEODEVICENVPROC glad_glXGetVideoDeviceNV;
+PFNGLXRELEASEVIDEODEVICENVPROC glad_glXReleaseVideoDeviceNV;
+PFNGLXBINDVIDEOIMAGENVPROC glad_glXBindVideoImageNV;
+PFNGLXRELEASEVIDEOIMAGENVPROC glad_glXReleaseVideoImageNV;
+PFNGLXSENDPBUFFERTOVIDEONVPROC glad_glXSendPbufferToVideoNV;
+PFNGLXGETVIDEOINFONVPROC glad_glXGetVideoInfoNV;
+PFNGLXGETSYNCVALUESOMLPROC glad_glXGetSyncValuesOML;
+PFNGLXGETMSCRATEOMLPROC glad_glXGetMscRateOML;
+PFNGLXSWAPBUFFERSMSCOMLPROC glad_glXSwapBuffersMscOML;
+PFNGLXWAITFORMSCOMLPROC glad_glXWaitForMscOML;
+PFNGLXWAITFORSBCOMLPROC glad_glXWaitForSbcOML;
+#ifdef _DM_BUFFER_H_
+PFNGLXASSOCIATEDMPBUFFERSGIXPROC glad_glXAssociateDMPbufferSGIX;
+#endif
+PFNGLXGETFBCONFIGATTRIBSGIXPROC glad_glXGetFBConfigAttribSGIX;
+PFNGLXCHOOSEFBCONFIGSGIXPROC glad_glXChooseFBConfigSGIX;
+PFNGLXCREATEGLXPIXMAPWITHCONFIGSGIXPROC glad_glXCreateGLXPixmapWithConfigSGIX;
+PFNGLXCREATECONTEXTWITHCONFIGSGIXPROC glad_glXCreateContextWithConfigSGIX;
+PFNGLXGETVISUALFROMFBCONFIGSGIXPROC glad_glXGetVisualFromFBConfigSGIX;
+PFNGLXGETFBCONFIGFROMVISUALSGIXPROC glad_glXGetFBConfigFromVisualSGIX;
+PFNGLXQUERYHYPERPIPENETWORKSGIXPROC glad_glXQueryHyperpipeNetworkSGIX;
+PFNGLXHYPERPIPECONFIGSGIXPROC glad_glXHyperpipeConfigSGIX;
+PFNGLXQUERYHYPERPIPECONFIGSGIXPROC glad_glXQueryHyperpipeConfigSGIX;
+PFNGLXDESTROYHYPERPIPECONFIGSGIXPROC glad_glXDestroyHyperpipeConfigSGIX;
+PFNGLXBINDHYPERPIPESGIXPROC glad_glXBindHyperpipeSGIX;
+PFNGLXQUERYHYPERPIPEBESTATTRIBSGIXPROC glad_glXQueryHyperpipeBestAttribSGIX;
+PFNGLXHYPERPIPEATTRIBSGIXPROC glad_glXHyperpipeAttribSGIX;
+PFNGLXQUERYHYPERPIPEATTRIBSGIXPROC glad_glXQueryHyperpipeAttribSGIX;
+PFNGLXCREATEGLXPBUFFERSGIXPROC glad_glXCreateGLXPbufferSGIX;
+PFNGLXDESTROYGLXPBUFFERSGIXPROC glad_glXDestroyGLXPbufferSGIX;
+PFNGLXQUERYGLXPBUFFERSGIXPROC glad_glXQueryGLXPbufferSGIX;
+PFNGLXSELECTEVENTSGIXPROC glad_glXSelectEventSGIX;
+PFNGLXGETSELECTEDEVENTSGIXPROC glad_glXGetSelectedEventSGIX;
+PFNGLXBINDSWAPBARRIERSGIXPROC glad_glXBindSwapBarrierSGIX;
+PFNGLXQUERYMAXSWAPBARRIERSSGIXPROC glad_glXQueryMaxSwapBarriersSGIX;
+PFNGLXJOINSWAPGROUPSGIXPROC glad_glXJoinSwapGroupSGIX;
+PFNGLXBINDCHANNELTOWINDOWSGIXPROC glad_glXBindChannelToWindowSGIX;
+PFNGLXCHANNELRECTSGIXPROC glad_glXChannelRectSGIX;
+PFNGLXQUERYCHANNELRECTSGIXPROC glad_glXQueryChannelRectSGIX;
+PFNGLXQUERYCHANNELDELTASSGIXPROC glad_glXQueryChannelDeltasSGIX;
+PFNGLXCHANNELRECTSYNCSGIXPROC glad_glXChannelRectSyncSGIX;
+#ifdef _VL_H_
+PFNGLXCREATEGLXVIDEOSOURCESGIXPROC glad_glXCreateGLXVideoSourceSGIX;
+PFNGLXDESTROYGLXVIDEOSOURCESGIXPROC glad_glXDestroyGLXVideoSourceSGIX;
+#endif
+PFNGLXCUSHIONSGIPROC glad_glXCushionSGI;
+PFNGLXMAKECURRENTREADSGIPROC glad_glXMakeCurrentReadSGI;
+PFNGLXGETCURRENTREADDRAWABLESGIPROC glad_glXGetCurrentReadDrawableSGI;
+PFNGLXSWAPINTERVALSGIPROC glad_glXSwapIntervalSGI;
+PFNGLXGETVIDEOSYNCSGIPROC glad_glXGetVideoSyncSGI;
+PFNGLXWAITVIDEOSYNCSGIPROC glad_glXWaitVideoSyncSGI;
+PFNGLXGETTRANSPARENTINDEXSUNPROC glad_glXGetTransparentIndexSUN;
+static void load_GLX_VERSION_1_0(GLADloadproc load) {
+	if(!GLAD_GLX_VERSION_1_0) return;
+	glad_glXChooseVisual = (PFNGLXCHOOSEVISUALPROC)load("glXChooseVisual");
+	glad_glXCreateContext = (PFNGLXCREATECONTEXTPROC)load("glXCreateContext");
+	glad_glXDestroyContext = (PFNGLXDESTROYCONTEXTPROC)load("glXDestroyContext");
+	glad_glXMakeCurrent = (PFNGLXMAKECURRENTPROC)load("glXMakeCurrent");
+	glad_glXCopyContext = (PFNGLXCOPYCONTEXTPROC)load("glXCopyContext");
+	glad_glXSwapBuffers = (PFNGLXSWAPBUFFERSPROC)load("glXSwapBuffers");
+	glad_glXCreateGLXPixmap = (PFNGLXCREATEGLXPIXMAPPROC)load("glXCreateGLXPixmap");
+	glad_glXDestroyGLXPixmap = (PFNGLXDESTROYGLXPIXMAPPROC)load("glXDestroyGLXPixmap");
+	glad_glXQueryExtension = (PFNGLXQUERYEXTENSIONPROC)load("glXQueryExtension");
+	glad_glXQueryVersion = (PFNGLXQUERYVERSIONPROC)load("glXQueryVersion");
+	glad_glXIsDirect = (PFNGLXISDIRECTPROC)load("glXIsDirect");
+	glad_glXGetConfig = (PFNGLXGETCONFIGPROC)load("glXGetConfig");
+	glad_glXGetCurrentContext = (PFNGLXGETCURRENTCONTEXTPROC)load("glXGetCurrentContext");
+	glad_glXGetCurrentDrawable = (PFNGLXGETCURRENTDRAWABLEPROC)load("glXGetCurrentDrawable");
+	glad_glXWaitGL = (PFNGLXWAITGLPROC)load("glXWaitGL");
+	glad_glXWaitX = (PFNGLXWAITXPROC)load("glXWaitX");
+	glad_glXUseXFont = (PFNGLXUSEXFONTPROC)load("glXUseXFont");
+}
+static void load_GLX_VERSION_1_1(GLADloadproc load) {
+	if(!GLAD_GLX_VERSION_1_1) return;
+	glad_glXQueryExtensionsString = (PFNGLXQUERYEXTENSIONSSTRINGPROC)load("glXQueryExtensionsString");
+	glad_glXQueryServerString = (PFNGLXQUERYSERVERSTRINGPROC)load("glXQueryServerString");
+	glad_glXGetClientString = (PFNGLXGETCLIENTSTRINGPROC)load("glXGetClientString");
+}
+static void load_GLX_VERSION_1_2(GLADloadproc load) {
+	if(!GLAD_GLX_VERSION_1_2) return;
+	glad_glXGetCurrentDisplay = (PFNGLXGETCURRENTDISPLAYPROC)load("glXGetCurrentDisplay");
+}
+static void load_GLX_VERSION_1_3(GLADloadproc load) {
+	if(!GLAD_GLX_VERSION_1_3) return;
+	glad_glXGetFBConfigs = (PFNGLXGETFBCONFIGSPROC)load("glXGetFBConfigs");
+	glad_glXChooseFBConfig = (PFNGLXCHOOSEFBCONFIGPROC)load("glXChooseFBConfig");
+	glad_glXGetFBConfigAttrib = (PFNGLXGETFBCONFIGATTRIBPROC)load("glXGetFBConfigAttrib");
+	glad_glXGetVisualFromFBConfig = (PFNGLXGETVISUALFROMFBCONFIGPROC)load("glXGetVisualFromFBConfig");
+	glad_glXCreateWindow = (PFNGLXCREATEWINDOWPROC)load("glXCreateWindow");
+	glad_glXDestroyWindow = (PFNGLXDESTROYWINDOWPROC)load("glXDestroyWindow");
+	glad_glXCreatePixmap = (PFNGLXCREATEPIXMAPPROC)load("glXCreatePixmap");
+	glad_glXDestroyPixmap = (PFNGLXDESTROYPIXMAPPROC)load("glXDestroyPixmap");
+	glad_glXCreatePbuffer = (PFNGLXCREATEPBUFFERPROC)load("glXCreatePbuffer");
+	glad_glXDestroyPbuffer = (PFNGLXDESTROYPBUFFERPROC)load("glXDestroyPbuffer");
+	glad_glXQueryDrawable = (PFNGLXQUERYDRAWABLEPROC)load("glXQueryDrawable");
+	glad_glXCreateNewContext = (PFNGLXCREATENEWCONTEXTPROC)load("glXCreateNewContext");
+	glad_glXMakeContextCurrent = (PFNGLXMAKECONTEXTCURRENTPROC)load("glXMakeContextCurrent");
+	glad_glXGetCurrentReadDrawable = (PFNGLXGETCURRENTREADDRAWABLEPROC)load("glXGetCurrentReadDrawable");
+	glad_glXQueryContext = (PFNGLXQUERYCONTEXTPROC)load("glXQueryContext");
+	glad_glXSelectEvent = (PFNGLXSELECTEVENTPROC)load("glXSelectEvent");
+	glad_glXGetSelectedEvent = (PFNGLXGETSELECTEDEVENTPROC)load("glXGetSelectedEvent");
+}
+static void load_GLX_VERSION_1_4(GLADloadproc load) {
+	if(!GLAD_GLX_VERSION_1_4) return;
+	glad_glXGetProcAddress = (PFNGLXGETPROCADDRESSPROC)load("glXGetProcAddress");
+}
+static void load_GLX_AMD_gpu_association(GLADloadproc load) {
+	if(!GLAD_GLX_AMD_gpu_association) return;
+	glad_glXGetGPUIDsAMD = (PFNGLXGETGPUIDSAMDPROC)load("glXGetGPUIDsAMD");
+	glad_glXGetGPUInfoAMD = (PFNGLXGETGPUINFOAMDPROC)load("glXGetGPUInfoAMD");
+	glad_glXGetContextGPUIDAMD = (PFNGLXGETCONTEXTGPUIDAMDPROC)load("glXGetContextGPUIDAMD");
+	glad_glXCreateAssociatedContextAMD = (PFNGLXCREATEASSOCIATEDCONTEXTAMDPROC)load("glXCreateAssociatedContextAMD");
+	glad_glXCreateAssociatedContextAttribsAMD = (PFNGLXCREATEASSOCIATEDCONTEXTATTRIBSAMDPROC)load("glXCreateAssociatedContextAttribsAMD");
+	glad_glXDeleteAssociatedContextAMD = (PFNGLXDELETEASSOCIATEDCONTEXTAMDPROC)load("glXDeleteAssociatedContextAMD");
+	glad_glXMakeAssociatedContextCurrentAMD = (PFNGLXMAKEASSOCIATEDCONTEXTCURRENTAMDPROC)load("glXMakeAssociatedContextCurrentAMD");
+	glad_glXGetCurrentAssociatedContextAMD = (PFNGLXGETCURRENTASSOCIATEDCONTEXTAMDPROC)load("glXGetCurrentAssociatedContextAMD");
+	glad_glXBlitContextFramebufferAMD = (PFNGLXBLITCONTEXTFRAMEBUFFERAMDPROC)load("glXBlitContextFramebufferAMD");
+}
+static void load_GLX_ARB_create_context(GLADloadproc load) {
+	if(!GLAD_GLX_ARB_create_context) return;
+	glad_glXCreateContextAttribsARB = (PFNGLXCREATECONTEXTATTRIBSARBPROC)load("glXCreateContextAttribsARB");
+}
+static void load_GLX_ARB_get_proc_address(GLADloadproc load) {
+	if(!GLAD_GLX_ARB_get_proc_address) return;
+	glad_glXGetProcAddressARB = (PFNGLXGETPROCADDRESSARBPROC)load("glXGetProcAddressARB");
+}
+static void load_GLX_EXT_import_context(GLADloadproc load) {
+	if(!GLAD_GLX_EXT_import_context) return;
+	glad_glXGetCurrentDisplayEXT = (PFNGLXGETCURRENTDISPLAYEXTPROC)load("glXGetCurrentDisplayEXT");
+	glad_glXQueryContextInfoEXT = (PFNGLXQUERYCONTEXTINFOEXTPROC)load("glXQueryContextInfoEXT");
+	glad_glXGetContextIDEXT = (PFNGLXGETCONTEXTIDEXTPROC)load("glXGetContextIDEXT");
+	glad_glXImportContextEXT = (PFNGLXIMPORTCONTEXTEXTPROC)load("glXImportContextEXT");
+	glad_glXFreeContextEXT = (PFNGLXFREECONTEXTEXTPROC)load("glXFreeContextEXT");
+}
+static void load_GLX_EXT_swap_control(GLADloadproc load) {
+	if(!GLAD_GLX_EXT_swap_control) return;
+	glad_glXSwapIntervalEXT = (PFNGLXSWAPINTERVALEXTPROC)load("glXSwapIntervalEXT");
+}
+static void load_GLX_EXT_texture_from_pixmap(GLADloadproc load) {
+	if(!GLAD_GLX_EXT_texture_from_pixmap) return;
+	glad_glXBindTexImageEXT = (PFNGLXBINDTEXIMAGEEXTPROC)load("glXBindTexImageEXT");
+	glad_glXReleaseTexImageEXT = (PFNGLXRELEASETEXIMAGEEXTPROC)load("glXReleaseTexImageEXT");
+}
+static void load_GLX_MESA_agp_offset(GLADloadproc load) {
+	if(!GLAD_GLX_MESA_agp_offset) return;
+	glad_glXGetAGPOffsetMESA = (PFNGLXGETAGPOFFSETMESAPROC)load("glXGetAGPOffsetMESA");
+}
+static void load_GLX_MESA_copy_sub_buffer(GLADloadproc load) {
+	if(!GLAD_GLX_MESA_copy_sub_buffer) return;
+	glad_glXCopySubBufferMESA = (PFNGLXCOPYSUBBUFFERMESAPROC)load("glXCopySubBufferMESA");
+}
+static void load_GLX_MESA_pixmap_colormap(GLADloadproc load) {
+	if(!GLAD_GLX_MESA_pixmap_colormap) return;
+	glad_glXCreateGLXPixmapMESA = (PFNGLXCREATEGLXPIXMAPMESAPROC)load("glXCreateGLXPixmapMESA");
+}
+static void load_GLX_MESA_query_renderer(GLADloadproc load) {
+	if(!GLAD_GLX_MESA_query_renderer) return;
+	glad_glXQueryCurrentRendererIntegerMESA = (PFNGLXQUERYCURRENTRENDERERINTEGERMESAPROC)load("glXQueryCurrentRendererIntegerMESA");
+	glad_glXQueryCurrentRendererStringMESA = (PFNGLXQUERYCURRENTRENDERERSTRINGMESAPROC)load("glXQueryCurrentRendererStringMESA");
+	glad_glXQueryRendererIntegerMESA = (PFNGLXQUERYRENDERERINTEGERMESAPROC)load("glXQueryRendererIntegerMESA");
+	glad_glXQueryRendererStringMESA = (PFNGLXQUERYRENDERERSTRINGMESAPROC)load("glXQueryRendererStringMESA");
+}
+static void load_GLX_MESA_release_buffers(GLADloadproc load) {
+	if(!GLAD_GLX_MESA_release_buffers) return;
+	glad_glXReleaseBuffersMESA = (PFNGLXRELEASEBUFFERSMESAPROC)load("glXReleaseBuffersMESA");
+}
+static void load_GLX_MESA_set_3dfx_mode(GLADloadproc load) {
+	if(!GLAD_GLX_MESA_set_3dfx_mode) return;
+	glad_glXSet3DfxModeMESA = (PFNGLXSET3DFXMODEMESAPROC)load("glXSet3DfxModeMESA");
+}
+static void load_GLX_NV_copy_buffer(GLADloadproc load) {
+	if(!GLAD_GLX_NV_copy_buffer) return;
+	glad_glXCopyBufferSubDataNV = (PFNGLXCOPYBUFFERSUBDATANVPROC)load("glXCopyBufferSubDataNV");
+	glad_glXNamedCopyBufferSubDataNV = (PFNGLXNAMEDCOPYBUFFERSUBDATANVPROC)load("glXNamedCopyBufferSubDataNV");
+}
+static void load_GLX_NV_copy_image(GLADloadproc load) {
+	if(!GLAD_GLX_NV_copy_image) return;
+	glad_glXCopyImageSubDataNV = (PFNGLXCOPYIMAGESUBDATANVPROC)load("glXCopyImageSubDataNV");
+}
+static void load_GLX_NV_delay_before_swap(GLADloadproc load) {
+	if(!GLAD_GLX_NV_delay_before_swap) return;
+	glad_glXDelayBeforeSwapNV = (PFNGLXDELAYBEFORESWAPNVPROC)load("glXDelayBeforeSwapNV");
+}
+static void load_GLX_NV_present_video(GLADloadproc load) {
+	if(!GLAD_GLX_NV_present_video) return;
+	glad_glXEnumerateVideoDevicesNV = (PFNGLXENUMERATEVIDEODEVICESNVPROC)load("glXEnumerateVideoDevicesNV");
+	glad_glXBindVideoDeviceNV = (PFNGLXBINDVIDEODEVICENVPROC)load("glXBindVideoDeviceNV");
+}
+static void load_GLX_NV_swap_group(GLADloadproc load) {
+	if(!GLAD_GLX_NV_swap_group) return;
+	glad_glXJoinSwapGroupNV = (PFNGLXJOINSWAPGROUPNVPROC)load("glXJoinSwapGroupNV");
+	glad_glXBindSwapBarrierNV = (PFNGLXBINDSWAPBARRIERNVPROC)load("glXBindSwapBarrierNV");
+	glad_glXQuerySwapGroupNV = (PFNGLXQUERYSWAPGROUPNVPROC)load("glXQuerySwapGroupNV");
+	glad_glXQueryMaxSwapGroupsNV = (PFNGLXQUERYMAXSWAPGROUPSNVPROC)load("glXQueryMaxSwapGroupsNV");
+	glad_glXQueryFrameCountNV = (PFNGLXQUERYFRAMECOUNTNVPROC)load("glXQueryFrameCountNV");
+	glad_glXResetFrameCountNV = (PFNGLXRESETFRAMECOUNTNVPROC)load("glXResetFrameCountNV");
+}
+static void load_GLX_NV_video_capture(GLADloadproc load) {
+	if(!GLAD_GLX_NV_video_capture) return;
+	glad_glXBindVideoCaptureDeviceNV = (PFNGLXBINDVIDEOCAPTUREDEVICENVPROC)load("glXBindVideoCaptureDeviceNV");
+	glad_glXEnumerateVideoCaptureDevicesNV = (PFNGLXENUMERATEVIDEOCAPTUREDEVICESNVPROC)load("glXEnumerateVideoCaptureDevicesNV");
+	glad_glXLockVideoCaptureDeviceNV = (PFNGLXLOCKVIDEOCAPTUREDEVICENVPROC)load("glXLockVideoCaptureDeviceNV");
+	glad_glXQueryVideoCaptureDeviceNV = (PFNGLXQUERYVIDEOCAPTUREDEVICENVPROC)load("glXQueryVideoCaptureDeviceNV");
+	glad_glXReleaseVideoCaptureDeviceNV = (PFNGLXRELEASEVIDEOCAPTUREDEVICENVPROC)load("glXReleaseVideoCaptureDeviceNV");
+}
+static void load_GLX_NV_video_out(GLADloadproc load) {
+	if(!GLAD_GLX_NV_video_out) return;
+	glad_glXGetVideoDeviceNV = (PFNGLXGETVIDEODEVICENVPROC)load("glXGetVideoDeviceNV");
+	glad_glXReleaseVideoDeviceNV = (PFNGLXRELEASEVIDEODEVICENVPROC)load("glXReleaseVideoDeviceNV");
+	glad_glXBindVideoImageNV = (PFNGLXBINDVIDEOIMAGENVPROC)load("glXBindVideoImageNV");
+	glad_glXReleaseVideoImageNV = (PFNGLXRELEASEVIDEOIMAGENVPROC)load("glXReleaseVideoImageNV");
+	glad_glXSendPbufferToVideoNV = (PFNGLXSENDPBUFFERTOVIDEONVPROC)load("glXSendPbufferToVideoNV");
+	glad_glXGetVideoInfoNV = (PFNGLXGETVIDEOINFONVPROC)load("glXGetVideoInfoNV");
+}
+static void load_GLX_OML_sync_control(GLADloadproc load) {
+	if(!GLAD_GLX_OML_sync_control) return;
+	glad_glXGetSyncValuesOML = (PFNGLXGETSYNCVALUESOMLPROC)load("glXGetSyncValuesOML");
+	glad_glXGetMscRateOML = (PFNGLXGETMSCRATEOMLPROC)load("glXGetMscRateOML");
+	glad_glXSwapBuffersMscOML = (PFNGLXSWAPBUFFERSMSCOMLPROC)load("glXSwapBuffersMscOML");
+	glad_glXWaitForMscOML = (PFNGLXWAITFORMSCOMLPROC)load("glXWaitForMscOML");
+	glad_glXWaitForSbcOML = (PFNGLXWAITFORSBCOMLPROC)load("glXWaitForSbcOML");
+}
+static void load_GLX_SGIX_dmbuffer(GLADloadproc load) {
+	if(!GLAD_GLX_SGIX_dmbuffer) return;
+#ifdef _DM_BUFFER_H_
+	glad_glXAssociateDMPbufferSGIX = (PFNGLXASSOCIATEDMPBUFFERSGIXPROC)load("glXAssociateDMPbufferSGIX");
+#else
+	(void)load;
+#endif
+}
+static void load_GLX_SGIX_fbconfig(GLADloadproc load) {
+	if(!GLAD_GLX_SGIX_fbconfig) return;
+	glad_glXGetFBConfigAttribSGIX = (PFNGLXGETFBCONFIGATTRIBSGIXPROC)load("glXGetFBConfigAttribSGIX");
+	glad_glXChooseFBConfigSGIX = (PFNGLXCHOOSEFBCONFIGSGIXPROC)load("glXChooseFBConfigSGIX");
+	glad_glXCreateGLXPixmapWithConfigSGIX = (PFNGLXCREATEGLXPIXMAPWITHCONFIGSGIXPROC)load("glXCreateGLXPixmapWithConfigSGIX");
+	glad_glXCreateContextWithConfigSGIX = (PFNGLXCREATECONTEXTWITHCONFIGSGIXPROC)load("glXCreateContextWithConfigSGIX");
+	glad_glXGetVisualFromFBConfigSGIX = (PFNGLXGETVISUALFROMFBCONFIGSGIXPROC)load("glXGetVisualFromFBConfigSGIX");
+	glad_glXGetFBConfigFromVisualSGIX = (PFNGLXGETFBCONFIGFROMVISUALSGIXPROC)load("glXGetFBConfigFromVisualSGIX");
+}
+static void load_GLX_SGIX_hyperpipe(GLADloadproc load) {
+	if(!GLAD_GLX_SGIX_hyperpipe) return;
+	glad_glXQueryHyperpipeNetworkSGIX = (PFNGLXQUERYHYPERPIPENETWORKSGIXPROC)load("glXQueryHyperpipeNetworkSGIX");
+	glad_glXHyperpipeConfigSGIX = (PFNGLXHYPERPIPECONFIGSGIXPROC)load("glXHyperpipeConfigSGIX");
+	glad_glXQueryHyperpipeConfigSGIX = (PFNGLXQUERYHYPERPIPECONFIGSGIXPROC)load("glXQueryHyperpipeConfigSGIX");
+	glad_glXDestroyHyperpipeConfigSGIX = (PFNGLXDESTROYHYPERPIPECONFIGSGIXPROC)load("glXDestroyHyperpipeConfigSGIX");
+	glad_glXBindHyperpipeSGIX = (PFNGLXBINDHYPERPIPESGIXPROC)load("glXBindHyperpipeSGIX");
+	glad_glXQueryHyperpipeBestAttribSGIX = (PFNGLXQUERYHYPERPIPEBESTATTRIBSGIXPROC)load("glXQueryHyperpipeBestAttribSGIX");
+	glad_glXHyperpipeAttribSGIX = (PFNGLXHYPERPIPEATTRIBSGIXPROC)load("glXHyperpipeAttribSGIX");
+	glad_glXQueryHyperpipeAttribSGIX = (PFNGLXQUERYHYPERPIPEATTRIBSGIXPROC)load("glXQueryHyperpipeAttribSGIX");
+}
+static void load_GLX_SGIX_pbuffer(GLADloadproc load) {
+	if(!GLAD_GLX_SGIX_pbuffer) return;
+	glad_glXCreateGLXPbufferSGIX = (PFNGLXCREATEGLXPBUFFERSGIXPROC)load("glXCreateGLXPbufferSGIX");
+	glad_glXDestroyGLXPbufferSGIX = (PFNGLXDESTROYGLXPBUFFERSGIXPROC)load("glXDestroyGLXPbufferSGIX");
+	glad_glXQueryGLXPbufferSGIX = (PFNGLXQUERYGLXPBUFFERSGIXPROC)load("glXQueryGLXPbufferSGIX");
+	glad_glXSelectEventSGIX = (PFNGLXSELECTEVENTSGIXPROC)load("glXSelectEventSGIX");
+	glad_glXGetSelectedEventSGIX = (PFNGLXGETSELECTEDEVENTSGIXPROC)load("glXGetSelectedEventSGIX");
+}
+static void load_GLX_SGIX_swap_barrier(GLADloadproc load) {
+	if(!GLAD_GLX_SGIX_swap_barrier) return;
+	glad_glXBindSwapBarrierSGIX = (PFNGLXBINDSWAPBARRIERSGIXPROC)load("glXBindSwapBarrierSGIX");
+	glad_glXQueryMaxSwapBarriersSGIX = (PFNGLXQUERYMAXSWAPBARRIERSSGIXPROC)load("glXQueryMaxSwapBarriersSGIX");
+}
+static void load_GLX_SGIX_swap_group(GLADloadproc load) {
+	if(!GLAD_GLX_SGIX_swap_group) return;
+	glad_glXJoinSwapGroupSGIX = (PFNGLXJOINSWAPGROUPSGIXPROC)load("glXJoinSwapGroupSGIX");
+}
+static void load_GLX_SGIX_video_resize(GLADloadproc load) {
+	if(!GLAD_GLX_SGIX_video_resize) return;
+	glad_glXBindChannelToWindowSGIX = (PFNGLXBINDCHANNELTOWINDOWSGIXPROC)load("glXBindChannelToWindowSGIX");
+	glad_glXChannelRectSGIX = (PFNGLXCHANNELRECTSGIXPROC)load("glXChannelRectSGIX");
+	glad_glXQueryChannelRectSGIX = (PFNGLXQUERYCHANNELRECTSGIXPROC)load("glXQueryChannelRectSGIX");
+	glad_glXQueryChannelDeltasSGIX = (PFNGLXQUERYCHANNELDELTASSGIXPROC)load("glXQueryChannelDeltasSGIX");
+	glad_glXChannelRectSyncSGIX = (PFNGLXCHANNELRECTSYNCSGIXPROC)load("glXChannelRectSyncSGIX");
+}
+static void load_GLX_SGIX_video_source(GLADloadproc load) {
+	if(!GLAD_GLX_SGIX_video_source) return;
+#ifdef _VL_H_
+	glad_glXCreateGLXVideoSourceSGIX = (PFNGLXCREATEGLXVIDEOSOURCESGIXPROC)load("glXCreateGLXVideoSourceSGIX");
+	glad_glXDestroyGLXVideoSourceSGIX = (PFNGLXDESTROYGLXVIDEOSOURCESGIXPROC)load("glXDestroyGLXVideoSourceSGIX");
+#else
+	(void)load;
+#endif
+}
+static void load_GLX_SGI_cushion(GLADloadproc load) {
+	if(!GLAD_GLX_SGI_cushion) return;
+	glad_glXCushionSGI = (PFNGLXCUSHIONSGIPROC)load("glXCushionSGI");
+}
+static void load_GLX_SGI_make_current_read(GLADloadproc load) {
+	if(!GLAD_GLX_SGI_make_current_read) return;
+	glad_glXMakeCurrentReadSGI = (PFNGLXMAKECURRENTREADSGIPROC)load("glXMakeCurrentReadSGI");
+	glad_glXGetCurrentReadDrawableSGI = (PFNGLXGETCURRENTREADDRAWABLESGIPROC)load("glXGetCurrentReadDrawableSGI");
+}
+static void load_GLX_SGI_swap_control(GLADloadproc load) {
+	if(!GLAD_GLX_SGI_swap_control) return;
+	glad_glXSwapIntervalSGI = (PFNGLXSWAPINTERVALSGIPROC)load("glXSwapIntervalSGI");
+}
+static void load_GLX_SGI_video_sync(GLADloadproc load) {
+	if(!GLAD_GLX_SGI_video_sync) return;
+	glad_glXGetVideoSyncSGI = (PFNGLXGETVIDEOSYNCSGIPROC)load("glXGetVideoSyncSGI");
+	glad_glXWaitVideoSyncSGI = (PFNGLXWAITVIDEOSYNCSGIPROC)load("glXWaitVideoSyncSGI");
+}
+static void load_GLX_SUN_get_transparent_index(GLADloadproc load) {
+	if(!GLAD_GLX_SUN_get_transparent_index) return;
+	glad_glXGetTransparentIndexSUN = (PFNGLXGETTRANSPARENTINDEXSUNPROC)load("glXGetTransparentIndexSUN");
+}
+static int find_extensionsGLX(void) {
+	if (!get_exts()) return 0;
+	GLAD_GLX_3DFX_multisample = has_ext("GLX_3DFX_multisample");
+	GLAD_GLX_AMD_gpu_association = has_ext("GLX_AMD_gpu_association");
+	GLAD_GLX_ARB_context_flush_control = has_ext("GLX_ARB_context_flush_control");
+	GLAD_GLX_ARB_create_context = has_ext("GLX_ARB_create_context");
+	GLAD_GLX_ARB_create_context_profile = has_ext("GLX_ARB_create_context_profile");
+	GLAD_GLX_ARB_create_context_robustness = has_ext("GLX_ARB_create_context_robustness");
+	GLAD_GLX_ARB_fbconfig_float = has_ext("GLX_ARB_fbconfig_float");
+	GLAD_GLX_ARB_framebuffer_sRGB = has_ext("GLX_ARB_framebuffer_sRGB");
+	GLAD_GLX_ARB_get_proc_address = has_ext("GLX_ARB_get_proc_address");
+	GLAD_GLX_ARB_multisample = has_ext("GLX_ARB_multisample");
+	GLAD_GLX_ARB_robustness_application_isolation = has_ext("GLX_ARB_robustness_application_isolation");
+	GLAD_GLX_ARB_robustness_share_group_isolation = has_ext("GLX_ARB_robustness_share_group_isolation");
+	GLAD_GLX_ARB_vertex_buffer_object = has_ext("GLX_ARB_vertex_buffer_object");
+	GLAD_GLX_EXT_buffer_age = has_ext("GLX_EXT_buffer_age");
+	GLAD_GLX_EXT_create_context_es2_profile = has_ext("GLX_EXT_create_context_es2_profile");
+	GLAD_GLX_EXT_create_context_es_profile = has_ext("GLX_EXT_create_context_es_profile");
+	GLAD_GLX_EXT_fbconfig_packed_float = has_ext("GLX_EXT_fbconfig_packed_float");
+	GLAD_GLX_EXT_framebuffer_sRGB = has_ext("GLX_EXT_framebuffer_sRGB");
+	GLAD_GLX_EXT_import_context = has_ext("GLX_EXT_import_context");
+	GLAD_GLX_EXT_libglvnd = has_ext("GLX_EXT_libglvnd");
+	GLAD_GLX_EXT_stereo_tree = has_ext("GLX_EXT_stereo_tree");
+	GLAD_GLX_EXT_swap_control = has_ext("GLX_EXT_swap_control");
+	GLAD_GLX_EXT_swap_control_tear = has_ext("GLX_EXT_swap_control_tear");
+	GLAD_GLX_EXT_texture_from_pixmap = has_ext("GLX_EXT_texture_from_pixmap");
+	GLAD_GLX_EXT_visual_info = has_ext("GLX_EXT_visual_info");
+	GLAD_GLX_EXT_visual_rating = has_ext("GLX_EXT_visual_rating");
+	GLAD_GLX_INTEL_swap_event = has_ext("GLX_INTEL_swap_event");
+	GLAD_GLX_MESA_agp_offset = has_ext("GLX_MESA_agp_offset");
+	GLAD_GLX_MESA_copy_sub_buffer = has_ext("GLX_MESA_copy_sub_buffer");
+	GLAD_GLX_MESA_pixmap_colormap = has_ext("GLX_MESA_pixmap_colormap");
+	GLAD_GLX_MESA_query_renderer = has_ext("GLX_MESA_query_renderer");
+	GLAD_GLX_MESA_release_buffers = has_ext("GLX_MESA_release_buffers");
+	GLAD_GLX_MESA_set_3dfx_mode = has_ext("GLX_MESA_set_3dfx_mode");
+	GLAD_GLX_NV_copy_buffer = has_ext("GLX_NV_copy_buffer");
+	GLAD_GLX_NV_copy_image = has_ext("GLX_NV_copy_image");
+	GLAD_GLX_NV_delay_before_swap = has_ext("GLX_NV_delay_before_swap");
+	GLAD_GLX_NV_float_buffer = has_ext("GLX_NV_float_buffer");
+	GLAD_GLX_NV_multisample_coverage = has_ext("GLX_NV_multisample_coverage");
+	GLAD_GLX_NV_present_video = has_ext("GLX_NV_present_video");
+	GLAD_GLX_NV_robustness_video_memory_purge = has_ext("GLX_NV_robustness_video_memory_purge");
+	GLAD_GLX_NV_swap_group = has_ext("GLX_NV_swap_group");
+	GLAD_GLX_NV_video_capture = has_ext("GLX_NV_video_capture");
+	GLAD_GLX_NV_video_out = has_ext("GLX_NV_video_out");
+	GLAD_GLX_OML_swap_method = has_ext("GLX_OML_swap_method");
+	GLAD_GLX_OML_sync_control = has_ext("GLX_OML_sync_control");
+	GLAD_GLX_SGIS_blended_overlay = has_ext("GLX_SGIS_blended_overlay");
+	GLAD_GLX_SGIS_multisample = has_ext("GLX_SGIS_multisample");
+	GLAD_GLX_SGIS_shared_multisample = has_ext("GLX_SGIS_shared_multisample");
+	GLAD_GLX_SGIX_dmbuffer = has_ext("GLX_SGIX_dmbuffer");
+	GLAD_GLX_SGIX_fbconfig = has_ext("GLX_SGIX_fbconfig");
+	GLAD_GLX_SGIX_hyperpipe = has_ext("GLX_SGIX_hyperpipe");
+	GLAD_GLX_SGIX_pbuffer = has_ext("GLX_SGIX_pbuffer");
+	GLAD_GLX_SGIX_swap_barrier = has_ext("GLX_SGIX_swap_barrier");
+	GLAD_GLX_SGIX_swap_group = has_ext("GLX_SGIX_swap_group");
+	GLAD_GLX_SGIX_video_resize = has_ext("GLX_SGIX_video_resize");
+	GLAD_GLX_SGIX_video_source = has_ext("GLX_SGIX_video_source");
+	GLAD_GLX_SGIX_visual_select_group = has_ext("GLX_SGIX_visual_select_group");
+	GLAD_GLX_SGI_cushion = has_ext("GLX_SGI_cushion");
+	GLAD_GLX_SGI_make_current_read = has_ext("GLX_SGI_make_current_read");
+	GLAD_GLX_SGI_swap_control = has_ext("GLX_SGI_swap_control");
+	GLAD_GLX_SGI_video_sync = has_ext("GLX_SGI_video_sync");
+	GLAD_GLX_SUN_get_transparent_index = has_ext("GLX_SUN_get_transparent_index");
+	free_exts();
+	return 1;
+}
+
+static void find_coreGLX(Display *dpy, int screen) {
+	int major = 0, minor = 0;
+	if(dpy == 0 && GLADGLXDisplay == 0) {
+		dpy = XOpenDisplay(0);
+		screen = XScreenNumberOfScreen(XDefaultScreenOfDisplay(dpy));
+	} else if(dpy == 0) {
+		dpy = GLADGLXDisplay;
+		screen = GLADGLXscreen;
+	}
+	glXQueryVersion(dpy, &major, &minor);
+	GLADGLXDisplay = dpy;
+	GLADGLXscreen = screen;
+	GLAD_GLX_VERSION_1_0 = (major == 1 && minor >= 0) || major > 1;
+	GLAD_GLX_VERSION_1_1 = (major == 1 && minor >= 1) || major > 1;
+	GLAD_GLX_VERSION_1_2 = (major == 1 && minor >= 2) || major > 1;
+	GLAD_GLX_VERSION_1_3 = (major == 1 && minor >= 3) || major > 1;
+	GLAD_GLX_VERSION_1_4 = (major == 1 && minor >= 4) || major > 1;
+}
+
+int gladLoadGLXLoader(GLADloadproc load, Display *dpy, int screen) {
+	glXQueryVersion = (PFNGLXQUERYVERSIONPROC)load("glXQueryVersion");
+	if(glXQueryVersion == NULL) return 0;
+	find_coreGLX(dpy, screen);
+	load_GLX_VERSION_1_0(load);
+	load_GLX_VERSION_1_1(load);
+	load_GLX_VERSION_1_2(load);
+	load_GLX_VERSION_1_3(load);
+	load_GLX_VERSION_1_4(load);
+
+	if (!find_extensionsGLX()) return 0;
+	load_GLX_AMD_gpu_association(load);
+	load_GLX_ARB_create_context(load);
+	load_GLX_ARB_get_proc_address(load);
+	load_GLX_EXT_import_context(load);
+	load_GLX_EXT_swap_control(load);
+	load_GLX_EXT_texture_from_pixmap(load);
+	load_GLX_MESA_agp_offset(load);
+	load_GLX_MESA_copy_sub_buffer(load);
+	load_GLX_MESA_pixmap_colormap(load);
+	load_GLX_MESA_query_renderer(load);
+	load_GLX_MESA_release_buffers(load);
+	load_GLX_MESA_set_3dfx_mode(load);
+	load_GLX_NV_copy_buffer(load);
+	load_GLX_NV_copy_image(load);
+	load_GLX_NV_delay_before_swap(load);
+	load_GLX_NV_present_video(load);
+	load_GLX_NV_swap_group(load);
+	load_GLX_NV_video_capture(load);
+	load_GLX_NV_video_out(load);
+	load_GLX_OML_sync_control(load);
+	load_GLX_SGIX_dmbuffer(load);
+	load_GLX_SGIX_fbconfig(load);
+	load_GLX_SGIX_hyperpipe(load);
+	load_GLX_SGIX_pbuffer(load);
+	load_GLX_SGIX_swap_barrier(load);
+	load_GLX_SGIX_swap_group(load);
+	load_GLX_SGIX_video_resize(load);
+	load_GLX_SGIX_video_source(load);
+	load_GLX_SGI_cushion(load);
+	load_GLX_SGI_make_current_read(load);
+	load_GLX_SGI_swap_control(load);
+	load_GLX_SGI_video_sync(load);
+	load_GLX_SUN_get_transparent_index(load);
+	return 1;
+}
+

Engine/lib/glad/src/wgl/glad_wgl.c

@@ -0,0 +1,717 @@
+/*
+
+    WGL loader generated by glad 0.1.12a0 on Mon Sep 12 03:11:07 2016.
+
+    Language/Generator: C/C++
+    Specification: wgl
+    APIs: wgl=1.0
+    Profile: -
+    Extensions:
+        WGL_3DFX_multisample,
+        WGL_3DL_stereo_control,
+        WGL_AMD_gpu_association,
+        WGL_ARB_buffer_region,
+        WGL_ARB_context_flush_control,
+        WGL_ARB_create_context,
+        WGL_ARB_create_context_profile,
+        WGL_ARB_create_context_robustness,
+        WGL_ARB_extensions_string,
+        WGL_ARB_framebuffer_sRGB,
+        WGL_ARB_make_current_read,
+        WGL_ARB_multisample,
+        WGL_ARB_pbuffer,
+        WGL_ARB_pixel_format,
+        WGL_ARB_pixel_format_float,
+        WGL_ARB_render_texture,
+        WGL_ARB_robustness_application_isolation,
+        WGL_ARB_robustness_share_group_isolation,
+        WGL_ATI_pixel_format_float,
+        WGL_EXT_create_context_es2_profile,
+        WGL_EXT_create_context_es_profile,
+        WGL_EXT_depth_float,
+        WGL_EXT_display_color_table,
+        WGL_EXT_extensions_string,
+        WGL_EXT_framebuffer_sRGB,
+        WGL_EXT_make_current_read,
+        WGL_EXT_multisample,
+        WGL_EXT_pbuffer,
+        WGL_EXT_pixel_format,
+        WGL_EXT_pixel_format_packed_float,
+        WGL_EXT_swap_control,
+        WGL_EXT_swap_control_tear,
+        WGL_I3D_digital_video_control,
+        WGL_I3D_gamma,
+        WGL_I3D_genlock,
+        WGL_I3D_image_buffer,
+        WGL_I3D_swap_frame_lock,
+        WGL_I3D_swap_frame_usage,
+        WGL_NV_DX_interop,
+        WGL_NV_DX_interop2,
+        WGL_NV_copy_image,
+        WGL_NV_delay_before_swap,
+        WGL_NV_float_buffer,
+        WGL_NV_gpu_affinity,
+        WGL_NV_multisample_coverage,
+        WGL_NV_present_video,
+        WGL_NV_render_depth_texture,
+        WGL_NV_render_texture_rectangle,
+        WGL_NV_swap_group,
+        WGL_NV_vertex_array_range,
+        WGL_NV_video_capture,
+        WGL_NV_video_output,
+        WGL_OML_sync_control
+    Loader: True
+    Local files: False
+    Omit khrplatform: False
+
+    Commandline:
+        --api="wgl=1.0" --generator="c" --spec="wgl" --extensions="WGL_3DFX_multisample,WGL_3DL_stereo_control,WGL_AMD_gpu_association,WGL_ARB_buffer_region,WGL_ARB_context_flush_control,WGL_ARB_create_context,WGL_ARB_create_context_profile,WGL_ARB_create_context_robustness,WGL_ARB_extensions_string,WGL_ARB_framebuffer_sRGB,WGL_ARB_make_current_read,WGL_ARB_multisample,WGL_ARB_pbuffer,WGL_ARB_pixel_format,WGL_ARB_pixel_format_float,WGL_ARB_render_texture,WGL_ARB_robustness_application_isolation,WGL_ARB_robustness_share_group_isolation,WGL_ATI_pixel_format_float,WGL_EXT_create_context_es2_profile,WGL_EXT_create_context_es_profile,WGL_EXT_depth_float,WGL_EXT_display_color_table,WGL_EXT_extensions_string,WGL_EXT_framebuffer_sRGB,WGL_EXT_make_current_read,WGL_EXT_multisample,WGL_EXT_pbuffer,WGL_EXT_pixel_format,WGL_EXT_pixel_format_packed_float,WGL_EXT_swap_control,WGL_EXT_swap_control_tear,WGL_I3D_digital_video_control,WGL_I3D_gamma,WGL_I3D_genlock,WGL_I3D_image_buffer,WGL_I3D_swap_frame_lock,WGL_I3D_swap_frame_usage,WGL_NV_DX_interop,WGL_NV_DX_interop2,WGL_NV_copy_image,WGL_NV_delay_before_swap,WGL_NV_float_buffer,WGL_NV_gpu_affinity,WGL_NV_multisample_coverage,WGL_NV_present_video,WGL_NV_render_depth_texture,WGL_NV_render_texture_rectangle,WGL_NV_swap_group,WGL_NV_vertex_array_range,WGL_NV_video_capture,WGL_NV_video_output,WGL_OML_sync_control"
+    Online:
+        http://glad.dav1d.de/#language=c&specification=wgl&loader=on&api=wgl%3D1.0&extensions=WGL_3DFX_multisample&extensions=WGL_3DL_stereo_control&extensions=WGL_AMD_gpu_association&extensions=WGL_ARB_buffer_region&extensions=WGL_ARB_context_flush_control&extensions=WGL_ARB_create_context&extensions=WGL_ARB_create_context_profile&extensions=WGL_ARB_create_context_robustness&extensions=WGL_ARB_extensions_string&extensions=WGL_ARB_framebuffer_sRGB&extensions=WGL_ARB_make_current_read&extensions=WGL_ARB_multisample&extensions=WGL_ARB_pbuffer&extensions=WGL_ARB_pixel_format&extensions=WGL_ARB_pixel_format_float&extensions=WGL_ARB_render_texture&extensions=WGL_ARB_robustness_application_isolation&extensions=WGL_ARB_robustness_share_group_isolation&extensions=WGL_ATI_pixel_format_float&extensions=WGL_EXT_create_context_es2_profile&extensions=WGL_EXT_create_context_es_profile&extensions=WGL_EXT_depth_float&extensions=WGL_EXT_display_color_table&extensions=WGL_EXT_extensions_string&extensions=WGL_EXT_framebuffer_sRGB&extensions=WGL_EXT_make_current_read&extensions=WGL_EXT_multisample&extensions=WGL_EXT_pbuffer&extensions=WGL_EXT_pixel_format&extensions=WGL_EXT_pixel_format_packed_float&extensions=WGL_EXT_swap_control&extensions=WGL_EXT_swap_control_tear&extensions=WGL_I3D_digital_video_control&extensions=WGL_I3D_gamma&extensions=WGL_I3D_genlock&extensions=WGL_I3D_image_buffer&extensions=WGL_I3D_swap_frame_lock&extensions=WGL_I3D_swap_frame_usage&extensions=WGL_NV_DX_interop&extensions=WGL_NV_DX_interop2&extensions=WGL_NV_copy_image&extensions=WGL_NV_delay_before_swap&extensions=WGL_NV_float_buffer&extensions=WGL_NV_gpu_affinity&extensions=WGL_NV_multisample_coverage&extensions=WGL_NV_present_video&extensions=WGL_NV_render_depth_texture&extensions=WGL_NV_render_texture_rectangle&extensions=WGL_NV_swap_group&extensions=WGL_NV_vertex_array_range&extensions=WGL_NV_video_capture&extensions=WGL_NV_video_output&extensions=WGL_OML_sync_control
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <glad/glad_wgl.h>
+
+static void* get_proc(const char *namez);
+
+#ifdef _WIN32
+#include <windows.h>
+static HMODULE libGL;
+
+typedef void* (APIENTRYP PFNWGLGETPROCADDRESSPROC_PRIVATE)(const char*);
+PFNWGLGETPROCADDRESSPROC_PRIVATE gladGetProcAddressPtr;
+
+static
+int open_gl(void) {
+    libGL = LoadLibraryW(L"opengl32.dll");
+    if(libGL != NULL) {
+        gladGetProcAddressPtr = (PFNWGLGETPROCADDRESSPROC_PRIVATE)GetProcAddress(
+                libGL, "wglGetProcAddress");
+        return gladGetProcAddressPtr != NULL;
+    }
+
+    return 0;
+}
+
+static
+void close_gl(void) {
+    if(libGL != NULL) {
+        FreeLibrary(libGL);
+        libGL = NULL;
+    }
+}
+#else
+#include <dlfcn.h>
+static void* libGL;
+
+#ifndef __APPLE__
+typedef void* (APIENTRYP PFNGLXGETPROCADDRESSPROC_PRIVATE)(const char*);
+PFNGLXGETPROCADDRESSPROC_PRIVATE gladGetProcAddressPtr;
+#endif
+
+static
+int open_gl(void) {
+#ifdef __APPLE__
+    static const char *NAMES[] = {
+        "../Frameworks/OpenGL.framework/OpenGL",
+        "/Library/Frameworks/OpenGL.framework/OpenGL",
+        "/System/Library/Frameworks/OpenGL.framework/OpenGL",
+        "/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL"
+    };
+#else
+    static const char *NAMES[] = {"libGL.so.1", "libGL.so"};
+#endif
+
+    unsigned int index = 0;
+    for(index = 0; index < (sizeof(NAMES) / sizeof(NAMES[0])); index++) {
+        libGL = dlopen(NAMES[index], RTLD_NOW | RTLD_GLOBAL);
+
+        if(libGL != NULL) {
+#ifdef __APPLE__
+            return 1;
+#else
+            gladGetProcAddressPtr = (PFNGLXGETPROCADDRESSPROC_PRIVATE)dlsym(libGL,
+                "glXGetProcAddressARB");
+            return gladGetProcAddressPtr != NULL;
+#endif
+        }
+    }
+
+    return 0;
+}
+
+static
+void close_gl() {
+    if(libGL != NULL) {
+        dlclose(libGL);
+        libGL = NULL;
+    }
+}
+#endif
+
+static
+void* get_proc(const char *namez) {
+    void* result = NULL;
+    if(libGL == NULL) return NULL;
+
+#ifndef __APPLE__
+    if(gladGetProcAddressPtr != NULL) {
+        result = gladGetProcAddressPtr(namez);
+    }
+#endif
+    if(result == NULL) {
+#ifdef _WIN32
+        result = (void*)GetProcAddress(libGL, namez);
+#else
+        result = dlsym(libGL, namez);
+#endif
+    }
+
+    return result;
+}
+
+int gladLoadWGL(HDC hdc) {
+    int status = 0;
+
+    if(open_gl()) {
+        status = gladLoadWGLLoader((GLADloadproc)get_proc, hdc);
+        close_gl();
+    }
+
+    return status;
+}
+
+static HDC GLADWGLhdc = (HDC)INVALID_HANDLE_VALUE;
+
+static int get_exts(void) {
+    return 1;
+}
+
+static void free_exts(void) {
+    return;
+}
+
+static int has_ext(const char *ext) {
+    const char *terminator;
+    const char *loc;
+    const char *extensions;
+
+    if(wglGetExtensionsStringEXT == NULL && wglGetExtensionsStringARB == NULL)
+        return 0;
+
+    if(wglGetExtensionsStringARB == NULL || GLADWGLhdc == INVALID_HANDLE_VALUE)
+        extensions = wglGetExtensionsStringEXT();
+    else
+        extensions = wglGetExtensionsStringARB(GLADWGLhdc);
+
+    if(extensions == NULL || ext == NULL)
+        return 0;
+
+    while(1) {
+        loc = strstr(extensions, ext);
+        if(loc == NULL)
+            break;
+
+        terminator = loc + strlen(ext);
+        if((loc == extensions || *(loc - 1) == ' ') &&
+            (*terminator == ' ' || *terminator == '\0'))
+        {
+            return 1;
+        }
+        extensions = terminator;
+    }
+
+    return 0;
+}
+int GLAD_WGL_VERSION_1_0;
+int GLAD_WGL_NV_multisample_coverage;
+int GLAD_WGL_I3D_image_buffer;
+int GLAD_WGL_I3D_swap_frame_usage;
+int GLAD_WGL_NV_DX_interop2;
+int GLAD_WGL_OML_sync_control;
+int GLAD_WGL_NV_float_buffer;
+int GLAD_WGL_NV_delay_before_swap;
+int GLAD_WGL_NV_video_capture;
+int GLAD_WGL_ARB_pixel_format_float;
+int GLAD_WGL_ARB_create_context_profile;
+int GLAD_WGL_NV_swap_group;
+int GLAD_WGL_NV_gpu_affinity;
+int GLAD_WGL_EXT_pixel_format;
+int GLAD_WGL_ARB_extensions_string;
+int GLAD_WGL_NV_render_texture_rectangle;
+int GLAD_WGL_EXT_create_context_es_profile;
+int GLAD_WGL_ARB_robustness_share_group_isolation;
+int GLAD_WGL_ARB_create_context_robustness;
+int GLAD_WGL_EXT_depth_float;
+int GLAD_WGL_EXT_swap_control_tear;
+int GLAD_WGL_ARB_context_flush_control;
+int GLAD_WGL_ARB_pixel_format;
+int GLAD_WGL_ARB_multisample;
+int GLAD_WGL_I3D_genlock;
+int GLAD_WGL_NV_vertex_array_range;
+int GLAD_WGL_3DL_stereo_control;
+int GLAD_WGL_EXT_pbuffer;
+int GLAD_WGL_EXT_display_color_table;
+int GLAD_WGL_NV_video_output;
+int GLAD_WGL_ARB_robustness_application_isolation;
+int GLAD_WGL_3DFX_multisample;
+int GLAD_WGL_I3D_gamma;
+int GLAD_WGL_ARB_framebuffer_sRGB;
+int GLAD_WGL_NV_copy_image;
+int GLAD_WGL_EXT_framebuffer_sRGB;
+int GLAD_WGL_NV_present_video;
+int GLAD_WGL_EXT_create_context_es2_profile;
+int GLAD_WGL_ARB_render_texture;
+int GLAD_WGL_ARB_make_current_read;
+int GLAD_WGL_EXT_multisample;
+int GLAD_WGL_ARB_create_context;
+int GLAD_WGL_EXT_extensions_string;
+int GLAD_WGL_NV_render_depth_texture;
+int GLAD_WGL_ATI_pixel_format_float;
+int GLAD_WGL_EXT_swap_control;
+int GLAD_WGL_I3D_digital_video_control;
+int GLAD_WGL_ARB_pbuffer;
+int GLAD_WGL_NV_DX_interop;
+int GLAD_WGL_AMD_gpu_association;
+int GLAD_WGL_EXT_pixel_format_packed_float;
+int GLAD_WGL_EXT_make_current_read;
+int GLAD_WGL_I3D_swap_frame_lock;
+int GLAD_WGL_ARB_buffer_region;
+PFNWGLSETSTEREOEMITTERSTATE3DLPROC glad_wglSetStereoEmitterState3DL;
+PFNWGLGETGPUIDSAMDPROC glad_wglGetGPUIDsAMD;
+PFNWGLGETGPUINFOAMDPROC glad_wglGetGPUInfoAMD;
+PFNWGLGETCONTEXTGPUIDAMDPROC glad_wglGetContextGPUIDAMD;
+PFNWGLCREATEASSOCIATEDCONTEXTAMDPROC glad_wglCreateAssociatedContextAMD;
+PFNWGLCREATEASSOCIATEDCONTEXTATTRIBSAMDPROC glad_wglCreateAssociatedContextAttribsAMD;
+PFNWGLDELETEASSOCIATEDCONTEXTAMDPROC glad_wglDeleteAssociatedContextAMD;
+PFNWGLMAKEASSOCIATEDCONTEXTCURRENTAMDPROC glad_wglMakeAssociatedContextCurrentAMD;
+PFNWGLGETCURRENTASSOCIATEDCONTEXTAMDPROC glad_wglGetCurrentAssociatedContextAMD;
+PFNWGLBLITCONTEXTFRAMEBUFFERAMDPROC glad_wglBlitContextFramebufferAMD;
+PFNWGLCREATEBUFFERREGIONARBPROC glad_wglCreateBufferRegionARB;
+PFNWGLDELETEBUFFERREGIONARBPROC glad_wglDeleteBufferRegionARB;
+PFNWGLSAVEBUFFERREGIONARBPROC glad_wglSaveBufferRegionARB;
+PFNWGLRESTOREBUFFERREGIONARBPROC glad_wglRestoreBufferRegionARB;
+PFNWGLCREATECONTEXTATTRIBSARBPROC glad_wglCreateContextAttribsARB;
+PFNWGLGETEXTENSIONSSTRINGARBPROC glad_wglGetExtensionsStringARB;
+PFNWGLMAKECONTEXTCURRENTARBPROC glad_wglMakeContextCurrentARB;
+PFNWGLGETCURRENTREADDCARBPROC glad_wglGetCurrentReadDCARB;
+PFNWGLCREATEPBUFFERARBPROC glad_wglCreatePbufferARB;
+PFNWGLGETPBUFFERDCARBPROC glad_wglGetPbufferDCARB;
+PFNWGLRELEASEPBUFFERDCARBPROC glad_wglReleasePbufferDCARB;
+PFNWGLDESTROYPBUFFERARBPROC glad_wglDestroyPbufferARB;
+PFNWGLQUERYPBUFFERARBPROC glad_wglQueryPbufferARB;
+PFNWGLGETPIXELFORMATATTRIBIVARBPROC glad_wglGetPixelFormatAttribivARB;
+PFNWGLGETPIXELFORMATATTRIBFVARBPROC glad_wglGetPixelFormatAttribfvARB;
+PFNWGLCHOOSEPIXELFORMATARBPROC glad_wglChoosePixelFormatARB;
+PFNWGLBINDTEXIMAGEARBPROC glad_wglBindTexImageARB;
+PFNWGLRELEASETEXIMAGEARBPROC glad_wglReleaseTexImageARB;
+PFNWGLSETPBUFFERATTRIBARBPROC glad_wglSetPbufferAttribARB;
+PFNWGLCREATEDISPLAYCOLORTABLEEXTPROC glad_wglCreateDisplayColorTableEXT;
+PFNWGLLOADDISPLAYCOLORTABLEEXTPROC glad_wglLoadDisplayColorTableEXT;
+PFNWGLBINDDISPLAYCOLORTABLEEXTPROC glad_wglBindDisplayColorTableEXT;
+PFNWGLDESTROYDISPLAYCOLORTABLEEXTPROC glad_wglDestroyDisplayColorTableEXT;
+PFNWGLGETEXTENSIONSSTRINGEXTPROC glad_wglGetExtensionsStringEXT;
+PFNWGLMAKECONTEXTCURRENTEXTPROC glad_wglMakeContextCurrentEXT;
+PFNWGLGETCURRENTREADDCEXTPROC glad_wglGetCurrentReadDCEXT;
+PFNWGLCREATEPBUFFEREXTPROC glad_wglCreatePbufferEXT;
+PFNWGLGETPBUFFERDCEXTPROC glad_wglGetPbufferDCEXT;
+PFNWGLRELEASEPBUFFERDCEXTPROC glad_wglReleasePbufferDCEXT;
+PFNWGLDESTROYPBUFFEREXTPROC glad_wglDestroyPbufferEXT;
+PFNWGLQUERYPBUFFEREXTPROC glad_wglQueryPbufferEXT;
+PFNWGLGETPIXELFORMATATTRIBIVEXTPROC glad_wglGetPixelFormatAttribivEXT;
+PFNWGLGETPIXELFORMATATTRIBFVEXTPROC glad_wglGetPixelFormatAttribfvEXT;
+PFNWGLCHOOSEPIXELFORMATEXTPROC glad_wglChoosePixelFormatEXT;
+PFNWGLSWAPINTERVALEXTPROC glad_wglSwapIntervalEXT;
+PFNWGLGETSWAPINTERVALEXTPROC glad_wglGetSwapIntervalEXT;
+PFNWGLGETDIGITALVIDEOPARAMETERSI3DPROC glad_wglGetDigitalVideoParametersI3D;
+PFNWGLSETDIGITALVIDEOPARAMETERSI3DPROC glad_wglSetDigitalVideoParametersI3D;
+PFNWGLGETGAMMATABLEPARAMETERSI3DPROC glad_wglGetGammaTableParametersI3D;
+PFNWGLSETGAMMATABLEPARAMETERSI3DPROC glad_wglSetGammaTableParametersI3D;
+PFNWGLGETGAMMATABLEI3DPROC glad_wglGetGammaTableI3D;
+PFNWGLSETGAMMATABLEI3DPROC glad_wglSetGammaTableI3D;
+PFNWGLENABLEGENLOCKI3DPROC glad_wglEnableGenlockI3D;
+PFNWGLDISABLEGENLOCKI3DPROC glad_wglDisableGenlockI3D;
+PFNWGLISENABLEDGENLOCKI3DPROC glad_wglIsEnabledGenlockI3D;
+PFNWGLGENLOCKSOURCEI3DPROC glad_wglGenlockSourceI3D;
+PFNWGLGETGENLOCKSOURCEI3DPROC glad_wglGetGenlockSourceI3D;
+PFNWGLGENLOCKSOURCEEDGEI3DPROC glad_wglGenlockSourceEdgeI3D;
+PFNWGLGETGENLOCKSOURCEEDGEI3DPROC glad_wglGetGenlockSourceEdgeI3D;
+PFNWGLGENLOCKSAMPLERATEI3DPROC glad_wglGenlockSampleRateI3D;
+PFNWGLGETGENLOCKSAMPLERATEI3DPROC glad_wglGetGenlockSampleRateI3D;
+PFNWGLGENLOCKSOURCEDELAYI3DPROC glad_wglGenlockSourceDelayI3D;
+PFNWGLGETGENLOCKSOURCEDELAYI3DPROC glad_wglGetGenlockSourceDelayI3D;
+PFNWGLQUERYGENLOCKMAXSOURCEDELAYI3DPROC glad_wglQueryGenlockMaxSourceDelayI3D;
+PFNWGLCREATEIMAGEBUFFERI3DPROC glad_wglCreateImageBufferI3D;
+PFNWGLDESTROYIMAGEBUFFERI3DPROC glad_wglDestroyImageBufferI3D;
+PFNWGLASSOCIATEIMAGEBUFFEREVENTSI3DPROC glad_wglAssociateImageBufferEventsI3D;
+PFNWGLRELEASEIMAGEBUFFEREVENTSI3DPROC glad_wglReleaseImageBufferEventsI3D;
+PFNWGLENABLEFRAMELOCKI3DPROC glad_wglEnableFrameLockI3D;
+PFNWGLDISABLEFRAMELOCKI3DPROC glad_wglDisableFrameLockI3D;
+PFNWGLISENABLEDFRAMELOCKI3DPROC glad_wglIsEnabledFrameLockI3D;
+PFNWGLQUERYFRAMELOCKMASTERI3DPROC glad_wglQueryFrameLockMasterI3D;
+PFNWGLGETFRAMEUSAGEI3DPROC glad_wglGetFrameUsageI3D;
+PFNWGLBEGINFRAMETRACKINGI3DPROC glad_wglBeginFrameTrackingI3D;
+PFNWGLENDFRAMETRACKINGI3DPROC glad_wglEndFrameTrackingI3D;
+PFNWGLQUERYFRAMETRACKINGI3DPROC glad_wglQueryFrameTrackingI3D;
+PFNWGLDXSETRESOURCESHAREHANDLENVPROC glad_wglDXSetResourceShareHandleNV;
+PFNWGLDXOPENDEVICENVPROC glad_wglDXOpenDeviceNV;
+PFNWGLDXCLOSEDEVICENVPROC glad_wglDXCloseDeviceNV;
+PFNWGLDXREGISTEROBJECTNVPROC glad_wglDXRegisterObjectNV;
+PFNWGLDXUNREGISTEROBJECTNVPROC glad_wglDXUnregisterObjectNV;
+PFNWGLDXOBJECTACCESSNVPROC glad_wglDXObjectAccessNV;
+PFNWGLDXLOCKOBJECTSNVPROC glad_wglDXLockObjectsNV;
+PFNWGLDXUNLOCKOBJECTSNVPROC glad_wglDXUnlockObjectsNV;
+PFNWGLCOPYIMAGESUBDATANVPROC glad_wglCopyImageSubDataNV;
+PFNWGLDELAYBEFORESWAPNVPROC glad_wglDelayBeforeSwapNV;
+PFNWGLENUMGPUSNVPROC glad_wglEnumGpusNV;
+PFNWGLENUMGPUDEVICESNVPROC glad_wglEnumGpuDevicesNV;
+PFNWGLCREATEAFFINITYDCNVPROC glad_wglCreateAffinityDCNV;
+PFNWGLENUMGPUSFROMAFFINITYDCNVPROC glad_wglEnumGpusFromAffinityDCNV;
+PFNWGLDELETEDCNVPROC glad_wglDeleteDCNV;
+PFNWGLENUMERATEVIDEODEVICESNVPROC glad_wglEnumerateVideoDevicesNV;
+PFNWGLBINDVIDEODEVICENVPROC glad_wglBindVideoDeviceNV;
+PFNWGLQUERYCURRENTCONTEXTNVPROC glad_wglQueryCurrentContextNV;
+PFNWGLJOINSWAPGROUPNVPROC glad_wglJoinSwapGroupNV;
+PFNWGLBINDSWAPBARRIERNVPROC glad_wglBindSwapBarrierNV;
+PFNWGLQUERYSWAPGROUPNVPROC glad_wglQuerySwapGroupNV;
+PFNWGLQUERYMAXSWAPGROUPSNVPROC glad_wglQueryMaxSwapGroupsNV;
+PFNWGLQUERYFRAMECOUNTNVPROC glad_wglQueryFrameCountNV;
+PFNWGLRESETFRAMECOUNTNVPROC glad_wglResetFrameCountNV;
+PFNWGLALLOCATEMEMORYNVPROC glad_wglAllocateMemoryNV;
+PFNWGLFREEMEMORYNVPROC glad_wglFreeMemoryNV;
+PFNWGLBINDVIDEOCAPTUREDEVICENVPROC glad_wglBindVideoCaptureDeviceNV;
+PFNWGLENUMERATEVIDEOCAPTUREDEVICESNVPROC glad_wglEnumerateVideoCaptureDevicesNV;
+PFNWGLLOCKVIDEOCAPTUREDEVICENVPROC glad_wglLockVideoCaptureDeviceNV;
+PFNWGLQUERYVIDEOCAPTUREDEVICENVPROC glad_wglQueryVideoCaptureDeviceNV;
+PFNWGLRELEASEVIDEOCAPTUREDEVICENVPROC glad_wglReleaseVideoCaptureDeviceNV;
+PFNWGLGETVIDEODEVICENVPROC glad_wglGetVideoDeviceNV;
+PFNWGLRELEASEVIDEODEVICENVPROC glad_wglReleaseVideoDeviceNV;
+PFNWGLBINDVIDEOIMAGENVPROC glad_wglBindVideoImageNV;
+PFNWGLRELEASEVIDEOIMAGENVPROC glad_wglReleaseVideoImageNV;
+PFNWGLSENDPBUFFERTOVIDEONVPROC glad_wglSendPbufferToVideoNV;
+PFNWGLGETVIDEOINFONVPROC glad_wglGetVideoInfoNV;
+PFNWGLGETSYNCVALUESOMLPROC glad_wglGetSyncValuesOML;
+PFNWGLGETMSCRATEOMLPROC glad_wglGetMscRateOML;
+PFNWGLSWAPBUFFERSMSCOMLPROC glad_wglSwapBuffersMscOML;
+PFNWGLSWAPLAYERBUFFERSMSCOMLPROC glad_wglSwapLayerBuffersMscOML;
+PFNWGLWAITFORMSCOMLPROC glad_wglWaitForMscOML;
+PFNWGLWAITFORSBCOMLPROC glad_wglWaitForSbcOML;
+static void load_WGL_3DL_stereo_control(GLADloadproc load) {
+	if(!GLAD_WGL_3DL_stereo_control) return;
+	glad_wglSetStereoEmitterState3DL = (PFNWGLSETSTEREOEMITTERSTATE3DLPROC)load("wglSetStereoEmitterState3DL");
+}
+static void load_WGL_AMD_gpu_association(GLADloadproc load) {
+	if(!GLAD_WGL_AMD_gpu_association) return;
+	glad_wglGetGPUIDsAMD = (PFNWGLGETGPUIDSAMDPROC)load("wglGetGPUIDsAMD");
+	glad_wglGetGPUInfoAMD = (PFNWGLGETGPUINFOAMDPROC)load("wglGetGPUInfoAMD");
+	glad_wglGetContextGPUIDAMD = (PFNWGLGETCONTEXTGPUIDAMDPROC)load("wglGetContextGPUIDAMD");
+	glad_wglCreateAssociatedContextAMD = (PFNWGLCREATEASSOCIATEDCONTEXTAMDPROC)load("wglCreateAssociatedContextAMD");
+	glad_wglCreateAssociatedContextAttribsAMD = (PFNWGLCREATEASSOCIATEDCONTEXTATTRIBSAMDPROC)load("wglCreateAssociatedContextAttribsAMD");
+	glad_wglDeleteAssociatedContextAMD = (PFNWGLDELETEASSOCIATEDCONTEXTAMDPROC)load("wglDeleteAssociatedContextAMD");
+	glad_wglMakeAssociatedContextCurrentAMD = (PFNWGLMAKEASSOCIATEDCONTEXTCURRENTAMDPROC)load("wglMakeAssociatedContextCurrentAMD");
+	glad_wglGetCurrentAssociatedContextAMD = (PFNWGLGETCURRENTASSOCIATEDCONTEXTAMDPROC)load("wglGetCurrentAssociatedContextAMD");
+	glad_wglBlitContextFramebufferAMD = (PFNWGLBLITCONTEXTFRAMEBUFFERAMDPROC)load("wglBlitContextFramebufferAMD");
+}
+static void load_WGL_ARB_buffer_region(GLADloadproc load) {
+	if(!GLAD_WGL_ARB_buffer_region) return;
+	glad_wglCreateBufferRegionARB = (PFNWGLCREATEBUFFERREGIONARBPROC)load("wglCreateBufferRegionARB");
+	glad_wglDeleteBufferRegionARB = (PFNWGLDELETEBUFFERREGIONARBPROC)load("wglDeleteBufferRegionARB");
+	glad_wglSaveBufferRegionARB = (PFNWGLSAVEBUFFERREGIONARBPROC)load("wglSaveBufferRegionARB");
+	glad_wglRestoreBufferRegionARB = (PFNWGLRESTOREBUFFERREGIONARBPROC)load("wglRestoreBufferRegionARB");
+}
+static void load_WGL_ARB_create_context(GLADloadproc load) {
+	if(!GLAD_WGL_ARB_create_context) return;
+	glad_wglCreateContextAttribsARB = (PFNWGLCREATECONTEXTATTRIBSARBPROC)load("wglCreateContextAttribsARB");
+}
+static void load_WGL_ARB_extensions_string(GLADloadproc load) {
+	if(!GLAD_WGL_ARB_extensions_string) return;
+	glad_wglGetExtensionsStringARB = (PFNWGLGETEXTENSIONSSTRINGARBPROC)load("wglGetExtensionsStringARB");
+}
+static void load_WGL_ARB_make_current_read(GLADloadproc load) {
+	if(!GLAD_WGL_ARB_make_current_read) return;
+	glad_wglMakeContextCurrentARB = (PFNWGLMAKECONTEXTCURRENTARBPROC)load("wglMakeContextCurrentARB");
+	glad_wglGetCurrentReadDCARB = (PFNWGLGETCURRENTREADDCARBPROC)load("wglGetCurrentReadDCARB");
+}
+static void load_WGL_ARB_pbuffer(GLADloadproc load) {
+	if(!GLAD_WGL_ARB_pbuffer) return;
+	glad_wglCreatePbufferARB = (PFNWGLCREATEPBUFFERARBPROC)load("wglCreatePbufferARB");
+	glad_wglGetPbufferDCARB = (PFNWGLGETPBUFFERDCARBPROC)load("wglGetPbufferDCARB");
+	glad_wglReleasePbufferDCARB = (PFNWGLRELEASEPBUFFERDCARBPROC)load("wglReleasePbufferDCARB");
+	glad_wglDestroyPbufferARB = (PFNWGLDESTROYPBUFFERARBPROC)load("wglDestroyPbufferARB");
+	glad_wglQueryPbufferARB = (PFNWGLQUERYPBUFFERARBPROC)load("wglQueryPbufferARB");
+}
+static void load_WGL_ARB_pixel_format(GLADloadproc load) {
+	if(!GLAD_WGL_ARB_pixel_format) return;
+	glad_wglGetPixelFormatAttribivARB = (PFNWGLGETPIXELFORMATATTRIBIVARBPROC)load("wglGetPixelFormatAttribivARB");
+	glad_wglGetPixelFormatAttribfvARB = (PFNWGLGETPIXELFORMATATTRIBFVARBPROC)load("wglGetPixelFormatAttribfvARB");
+	glad_wglChoosePixelFormatARB = (PFNWGLCHOOSEPIXELFORMATARBPROC)load("wglChoosePixelFormatARB");
+}
+static void load_WGL_ARB_render_texture(GLADloadproc load) {
+	if(!GLAD_WGL_ARB_render_texture) return;
+	glad_wglBindTexImageARB = (PFNWGLBINDTEXIMAGEARBPROC)load("wglBindTexImageARB");
+	glad_wglReleaseTexImageARB = (PFNWGLRELEASETEXIMAGEARBPROC)load("wglReleaseTexImageARB");
+	glad_wglSetPbufferAttribARB = (PFNWGLSETPBUFFERATTRIBARBPROC)load("wglSetPbufferAttribARB");
+}
+static void load_WGL_EXT_display_color_table(GLADloadproc load) {
+	if(!GLAD_WGL_EXT_display_color_table) return;
+	glad_wglCreateDisplayColorTableEXT = (PFNWGLCREATEDISPLAYCOLORTABLEEXTPROC)load("wglCreateDisplayColorTableEXT");
+	glad_wglLoadDisplayColorTableEXT = (PFNWGLLOADDISPLAYCOLORTABLEEXTPROC)load("wglLoadDisplayColorTableEXT");
+	glad_wglBindDisplayColorTableEXT = (PFNWGLBINDDISPLAYCOLORTABLEEXTPROC)load("wglBindDisplayColorTableEXT");
+	glad_wglDestroyDisplayColorTableEXT = (PFNWGLDESTROYDISPLAYCOLORTABLEEXTPROC)load("wglDestroyDisplayColorTableEXT");
+}
+static void load_WGL_EXT_extensions_string(GLADloadproc load) {
+	if(!GLAD_WGL_EXT_extensions_string) return;
+	glad_wglGetExtensionsStringEXT = (PFNWGLGETEXTENSIONSSTRINGEXTPROC)load("wglGetExtensionsStringEXT");
+}
+static void load_WGL_EXT_make_current_read(GLADloadproc load) {
+	if(!GLAD_WGL_EXT_make_current_read) return;
+	glad_wglMakeContextCurrentEXT = (PFNWGLMAKECONTEXTCURRENTEXTPROC)load("wglMakeContextCurrentEXT");
+	glad_wglGetCurrentReadDCEXT = (PFNWGLGETCURRENTREADDCEXTPROC)load("wglGetCurrentReadDCEXT");
+}
+static void load_WGL_EXT_pbuffer(GLADloadproc load) {
+	if(!GLAD_WGL_EXT_pbuffer) return;
+	glad_wglCreatePbufferEXT = (PFNWGLCREATEPBUFFEREXTPROC)load("wglCreatePbufferEXT");
+	glad_wglGetPbufferDCEXT = (PFNWGLGETPBUFFERDCEXTPROC)load("wglGetPbufferDCEXT");
+	glad_wglReleasePbufferDCEXT = (PFNWGLRELEASEPBUFFERDCEXTPROC)load("wglReleasePbufferDCEXT");
+	glad_wglDestroyPbufferEXT = (PFNWGLDESTROYPBUFFEREXTPROC)load("wglDestroyPbufferEXT");
+	glad_wglQueryPbufferEXT = (PFNWGLQUERYPBUFFEREXTPROC)load("wglQueryPbufferEXT");
+}
+static void load_WGL_EXT_pixel_format(GLADloadproc load) {
+	if(!GLAD_WGL_EXT_pixel_format) return;
+	glad_wglGetPixelFormatAttribivEXT = (PFNWGLGETPIXELFORMATATTRIBIVEXTPROC)load("wglGetPixelFormatAttribivEXT");
+	glad_wglGetPixelFormatAttribfvEXT = (PFNWGLGETPIXELFORMATATTRIBFVEXTPROC)load("wglGetPixelFormatAttribfvEXT");
+	glad_wglChoosePixelFormatEXT = (PFNWGLCHOOSEPIXELFORMATEXTPROC)load("wglChoosePixelFormatEXT");
+}
+static void load_WGL_EXT_swap_control(GLADloadproc load) {
+	if(!GLAD_WGL_EXT_swap_control) return;
+	glad_wglSwapIntervalEXT = (PFNWGLSWAPINTERVALEXTPROC)load("wglSwapIntervalEXT");
+	glad_wglGetSwapIntervalEXT = (PFNWGLGETSWAPINTERVALEXTPROC)load("wglGetSwapIntervalEXT");
+}
+static void load_WGL_I3D_digital_video_control(GLADloadproc load) {
+	if(!GLAD_WGL_I3D_digital_video_control) return;
+	glad_wglGetDigitalVideoParametersI3D = (PFNWGLGETDIGITALVIDEOPARAMETERSI3DPROC)load("wglGetDigitalVideoParametersI3D");
+	glad_wglSetDigitalVideoParametersI3D = (PFNWGLSETDIGITALVIDEOPARAMETERSI3DPROC)load("wglSetDigitalVideoParametersI3D");
+}
+static void load_WGL_I3D_gamma(GLADloadproc load) {
+	if(!GLAD_WGL_I3D_gamma) return;
+	glad_wglGetGammaTableParametersI3D = (PFNWGLGETGAMMATABLEPARAMETERSI3DPROC)load("wglGetGammaTableParametersI3D");
+	glad_wglSetGammaTableParametersI3D = (PFNWGLSETGAMMATABLEPARAMETERSI3DPROC)load("wglSetGammaTableParametersI3D");
+	glad_wglGetGammaTableI3D = (PFNWGLGETGAMMATABLEI3DPROC)load("wglGetGammaTableI3D");
+	glad_wglSetGammaTableI3D = (PFNWGLSETGAMMATABLEI3DPROC)load("wglSetGammaTableI3D");
+}
+static void load_WGL_I3D_genlock(GLADloadproc load) {
+	if(!GLAD_WGL_I3D_genlock) return;
+	glad_wglEnableGenlockI3D = (PFNWGLENABLEGENLOCKI3DPROC)load("wglEnableGenlockI3D");
+	glad_wglDisableGenlockI3D = (PFNWGLDISABLEGENLOCKI3DPROC)load("wglDisableGenlockI3D");
+	glad_wglIsEnabledGenlockI3D = (PFNWGLISENABLEDGENLOCKI3DPROC)load("wglIsEnabledGenlockI3D");
+	glad_wglGenlockSourceI3D = (PFNWGLGENLOCKSOURCEI3DPROC)load("wglGenlockSourceI3D");
+	glad_wglGetGenlockSourceI3D = (PFNWGLGETGENLOCKSOURCEI3DPROC)load("wglGetGenlockSourceI3D");
+	glad_wglGenlockSourceEdgeI3D = (PFNWGLGENLOCKSOURCEEDGEI3DPROC)load("wglGenlockSourceEdgeI3D");
+	glad_wglGetGenlockSourceEdgeI3D = (PFNWGLGETGENLOCKSOURCEEDGEI3DPROC)load("wglGetGenlockSourceEdgeI3D");
+	glad_wglGenlockSampleRateI3D = (PFNWGLGENLOCKSAMPLERATEI3DPROC)load("wglGenlockSampleRateI3D");
+	glad_wglGetGenlockSampleRateI3D = (PFNWGLGETGENLOCKSAMPLERATEI3DPROC)load("wglGetGenlockSampleRateI3D");
+	glad_wglGenlockSourceDelayI3D = (PFNWGLGENLOCKSOURCEDELAYI3DPROC)load("wglGenlockSourceDelayI3D");
+	glad_wglGetGenlockSourceDelayI3D = (PFNWGLGETGENLOCKSOURCEDELAYI3DPROC)load("wglGetGenlockSourceDelayI3D");
+	glad_wglQueryGenlockMaxSourceDelayI3D = (PFNWGLQUERYGENLOCKMAXSOURCEDELAYI3DPROC)load("wglQueryGenlockMaxSourceDelayI3D");
+}
+static void load_WGL_I3D_image_buffer(GLADloadproc load) {
+	if(!GLAD_WGL_I3D_image_buffer) return;
+	glad_wglCreateImageBufferI3D = (PFNWGLCREATEIMAGEBUFFERI3DPROC)load("wglCreateImageBufferI3D");
+	glad_wglDestroyImageBufferI3D = (PFNWGLDESTROYIMAGEBUFFERI3DPROC)load("wglDestroyImageBufferI3D");
+	glad_wglAssociateImageBufferEventsI3D = (PFNWGLASSOCIATEIMAGEBUFFEREVENTSI3DPROC)load("wglAssociateImageBufferEventsI3D");
+	glad_wglReleaseImageBufferEventsI3D = (PFNWGLRELEASEIMAGEBUFFEREVENTSI3DPROC)load("wglReleaseImageBufferEventsI3D");
+}
+static void load_WGL_I3D_swap_frame_lock(GLADloadproc load) {
+	if(!GLAD_WGL_I3D_swap_frame_lock) return;
+	glad_wglEnableFrameLockI3D = (PFNWGLENABLEFRAMELOCKI3DPROC)load("wglEnableFrameLockI3D");
+	glad_wglDisableFrameLockI3D = (PFNWGLDISABLEFRAMELOCKI3DPROC)load("wglDisableFrameLockI3D");
+	glad_wglIsEnabledFrameLockI3D = (PFNWGLISENABLEDFRAMELOCKI3DPROC)load("wglIsEnabledFrameLockI3D");
+	glad_wglQueryFrameLockMasterI3D = (PFNWGLQUERYFRAMELOCKMASTERI3DPROC)load("wglQueryFrameLockMasterI3D");
+}
+static void load_WGL_I3D_swap_frame_usage(GLADloadproc load) {
+	if(!GLAD_WGL_I3D_swap_frame_usage) return;
+	glad_wglGetFrameUsageI3D = (PFNWGLGETFRAMEUSAGEI3DPROC)load("wglGetFrameUsageI3D");
+	glad_wglBeginFrameTrackingI3D = (PFNWGLBEGINFRAMETRACKINGI3DPROC)load("wglBeginFrameTrackingI3D");
+	glad_wglEndFrameTrackingI3D = (PFNWGLENDFRAMETRACKINGI3DPROC)load("wglEndFrameTrackingI3D");
+	glad_wglQueryFrameTrackingI3D = (PFNWGLQUERYFRAMETRACKINGI3DPROC)load("wglQueryFrameTrackingI3D");
+}
+static void load_WGL_NV_DX_interop(GLADloadproc load) {
+	if(!GLAD_WGL_NV_DX_interop) return;
+	glad_wglDXSetResourceShareHandleNV = (PFNWGLDXSETRESOURCESHAREHANDLENVPROC)load("wglDXSetResourceShareHandleNV");
+	glad_wglDXOpenDeviceNV = (PFNWGLDXOPENDEVICENVPROC)load("wglDXOpenDeviceNV");
+	glad_wglDXCloseDeviceNV = (PFNWGLDXCLOSEDEVICENVPROC)load("wglDXCloseDeviceNV");
+	glad_wglDXRegisterObjectNV = (PFNWGLDXREGISTEROBJECTNVPROC)load("wglDXRegisterObjectNV");
+	glad_wglDXUnregisterObjectNV = (PFNWGLDXUNREGISTEROBJECTNVPROC)load("wglDXUnregisterObjectNV");
+	glad_wglDXObjectAccessNV = (PFNWGLDXOBJECTACCESSNVPROC)load("wglDXObjectAccessNV");
+	glad_wglDXLockObjectsNV = (PFNWGLDXLOCKOBJECTSNVPROC)load("wglDXLockObjectsNV");
+	glad_wglDXUnlockObjectsNV = (PFNWGLDXUNLOCKOBJECTSNVPROC)load("wglDXUnlockObjectsNV");
+}
+static void load_WGL_NV_copy_image(GLADloadproc load) {
+	if(!GLAD_WGL_NV_copy_image) return;
+	glad_wglCopyImageSubDataNV = (PFNWGLCOPYIMAGESUBDATANVPROC)load("wglCopyImageSubDataNV");
+}
+static void load_WGL_NV_delay_before_swap(GLADloadproc load) {
+	if(!GLAD_WGL_NV_delay_before_swap) return;
+	glad_wglDelayBeforeSwapNV = (PFNWGLDELAYBEFORESWAPNVPROC)load("wglDelayBeforeSwapNV");
+}
+static void load_WGL_NV_gpu_affinity(GLADloadproc load) {
+	if(!GLAD_WGL_NV_gpu_affinity) return;
+	glad_wglEnumGpusNV = (PFNWGLENUMGPUSNVPROC)load("wglEnumGpusNV");
+	glad_wglEnumGpuDevicesNV = (PFNWGLENUMGPUDEVICESNVPROC)load("wglEnumGpuDevicesNV");
+	glad_wglCreateAffinityDCNV = (PFNWGLCREATEAFFINITYDCNVPROC)load("wglCreateAffinityDCNV");
+	glad_wglEnumGpusFromAffinityDCNV = (PFNWGLENUMGPUSFROMAFFINITYDCNVPROC)load("wglEnumGpusFromAffinityDCNV");
+	glad_wglDeleteDCNV = (PFNWGLDELETEDCNVPROC)load("wglDeleteDCNV");
+}
+static void load_WGL_NV_present_video(GLADloadproc load) {
+	if(!GLAD_WGL_NV_present_video) return;
+	glad_wglEnumerateVideoDevicesNV = (PFNWGLENUMERATEVIDEODEVICESNVPROC)load("wglEnumerateVideoDevicesNV");
+	glad_wglBindVideoDeviceNV = (PFNWGLBINDVIDEODEVICENVPROC)load("wglBindVideoDeviceNV");
+	glad_wglQueryCurrentContextNV = (PFNWGLQUERYCURRENTCONTEXTNVPROC)load("wglQueryCurrentContextNV");
+}
+static void load_WGL_NV_swap_group(GLADloadproc load) {
+	if(!GLAD_WGL_NV_swap_group) return;
+	glad_wglJoinSwapGroupNV = (PFNWGLJOINSWAPGROUPNVPROC)load("wglJoinSwapGroupNV");
+	glad_wglBindSwapBarrierNV = (PFNWGLBINDSWAPBARRIERNVPROC)load("wglBindSwapBarrierNV");
+	glad_wglQuerySwapGroupNV = (PFNWGLQUERYSWAPGROUPNVPROC)load("wglQuerySwapGroupNV");
+	glad_wglQueryMaxSwapGroupsNV = (PFNWGLQUERYMAXSWAPGROUPSNVPROC)load("wglQueryMaxSwapGroupsNV");
+	glad_wglQueryFrameCountNV = (PFNWGLQUERYFRAMECOUNTNVPROC)load("wglQueryFrameCountNV");
+	glad_wglResetFrameCountNV = (PFNWGLRESETFRAMECOUNTNVPROC)load("wglResetFrameCountNV");
+}
+static void load_WGL_NV_vertex_array_range(GLADloadproc load) {
+	if(!GLAD_WGL_NV_vertex_array_range) return;
+	glad_wglAllocateMemoryNV = (PFNWGLALLOCATEMEMORYNVPROC)load("wglAllocateMemoryNV");
+	glad_wglFreeMemoryNV = (PFNWGLFREEMEMORYNVPROC)load("wglFreeMemoryNV");
+}
+static void load_WGL_NV_video_capture(GLADloadproc load) {
+	if(!GLAD_WGL_NV_video_capture) return;
+	glad_wglBindVideoCaptureDeviceNV = (PFNWGLBINDVIDEOCAPTUREDEVICENVPROC)load("wglBindVideoCaptureDeviceNV");
+	glad_wglEnumerateVideoCaptureDevicesNV = (PFNWGLENUMERATEVIDEOCAPTUREDEVICESNVPROC)load("wglEnumerateVideoCaptureDevicesNV");
+	glad_wglLockVideoCaptureDeviceNV = (PFNWGLLOCKVIDEOCAPTUREDEVICENVPROC)load("wglLockVideoCaptureDeviceNV");
+	glad_wglQueryVideoCaptureDeviceNV = (PFNWGLQUERYVIDEOCAPTUREDEVICENVPROC)load("wglQueryVideoCaptureDeviceNV");
+	glad_wglReleaseVideoCaptureDeviceNV = (PFNWGLRELEASEVIDEOCAPTUREDEVICENVPROC)load("wglReleaseVideoCaptureDeviceNV");
+}
+static void load_WGL_NV_video_output(GLADloadproc load) {
+	if(!GLAD_WGL_NV_video_output) return;
+	glad_wglGetVideoDeviceNV = (PFNWGLGETVIDEODEVICENVPROC)load("wglGetVideoDeviceNV");
+	glad_wglReleaseVideoDeviceNV = (PFNWGLRELEASEVIDEODEVICENVPROC)load("wglReleaseVideoDeviceNV");
+	glad_wglBindVideoImageNV = (PFNWGLBINDVIDEOIMAGENVPROC)load("wglBindVideoImageNV");
+	glad_wglReleaseVideoImageNV = (PFNWGLRELEASEVIDEOIMAGENVPROC)load("wglReleaseVideoImageNV");
+	glad_wglSendPbufferToVideoNV = (PFNWGLSENDPBUFFERTOVIDEONVPROC)load("wglSendPbufferToVideoNV");
+	glad_wglGetVideoInfoNV = (PFNWGLGETVIDEOINFONVPROC)load("wglGetVideoInfoNV");
+}
+static void load_WGL_OML_sync_control(GLADloadproc load) {
+	if(!GLAD_WGL_OML_sync_control) return;
+	glad_wglGetSyncValuesOML = (PFNWGLGETSYNCVALUESOMLPROC)load("wglGetSyncValuesOML");
+	glad_wglGetMscRateOML = (PFNWGLGETMSCRATEOMLPROC)load("wglGetMscRateOML");
+	glad_wglSwapBuffersMscOML = (PFNWGLSWAPBUFFERSMSCOMLPROC)load("wglSwapBuffersMscOML");
+	glad_wglSwapLayerBuffersMscOML = (PFNWGLSWAPLAYERBUFFERSMSCOMLPROC)load("wglSwapLayerBuffersMscOML");
+	glad_wglWaitForMscOML = (PFNWGLWAITFORMSCOMLPROC)load("wglWaitForMscOML");
+	glad_wglWaitForSbcOML = (PFNWGLWAITFORSBCOMLPROC)load("wglWaitForSbcOML");
+}
+static int find_extensionsWGL(void) {
+	if (!get_exts()) return 0;
+	GLAD_WGL_3DFX_multisample = has_ext("WGL_3DFX_multisample");
+	GLAD_WGL_3DL_stereo_control = has_ext("WGL_3DL_stereo_control");
+	GLAD_WGL_AMD_gpu_association = has_ext("WGL_AMD_gpu_association");
+	GLAD_WGL_ARB_buffer_region = has_ext("WGL_ARB_buffer_region");
+	GLAD_WGL_ARB_context_flush_control = has_ext("WGL_ARB_context_flush_control");
+	GLAD_WGL_ARB_create_context = has_ext("WGL_ARB_create_context");
+	GLAD_WGL_ARB_create_context_profile = has_ext("WGL_ARB_create_context_profile");
+	GLAD_WGL_ARB_create_context_robustness = has_ext("WGL_ARB_create_context_robustness");
+	GLAD_WGL_ARB_extensions_string = has_ext("WGL_ARB_extensions_string");
+	GLAD_WGL_ARB_framebuffer_sRGB = has_ext("WGL_ARB_framebuffer_sRGB");
+	GLAD_WGL_ARB_make_current_read = has_ext("WGL_ARB_make_current_read");
+	GLAD_WGL_ARB_multisample = has_ext("WGL_ARB_multisample");
+	GLAD_WGL_ARB_pbuffer = has_ext("WGL_ARB_pbuffer");
+	GLAD_WGL_ARB_pixel_format = has_ext("WGL_ARB_pixel_format");
+	GLAD_WGL_ARB_pixel_format_float = has_ext("WGL_ARB_pixel_format_float");
+	GLAD_WGL_ARB_render_texture = has_ext("WGL_ARB_render_texture");
+	GLAD_WGL_ARB_robustness_application_isolation = has_ext("WGL_ARB_robustness_application_isolation");
+	GLAD_WGL_ARB_robustness_share_group_isolation = has_ext("WGL_ARB_robustness_share_group_isolation");
+	GLAD_WGL_ATI_pixel_format_float = has_ext("WGL_ATI_pixel_format_float");
+	GLAD_WGL_EXT_create_context_es2_profile = has_ext("WGL_EXT_create_context_es2_profile");
+	GLAD_WGL_EXT_create_context_es_profile = has_ext("WGL_EXT_create_context_es_profile");
+	GLAD_WGL_EXT_depth_float = has_ext("WGL_EXT_depth_float");
+	GLAD_WGL_EXT_display_color_table = has_ext("WGL_EXT_display_color_table");
+	GLAD_WGL_EXT_extensions_string = has_ext("WGL_EXT_extensions_string");
+	GLAD_WGL_EXT_framebuffer_sRGB = has_ext("WGL_EXT_framebuffer_sRGB");
+	GLAD_WGL_EXT_make_current_read = has_ext("WGL_EXT_make_current_read");
+	GLAD_WGL_EXT_multisample = has_ext("WGL_EXT_multisample");
+	GLAD_WGL_EXT_pbuffer = has_ext("WGL_EXT_pbuffer");
+	GLAD_WGL_EXT_pixel_format = has_ext("WGL_EXT_pixel_format");
+	GLAD_WGL_EXT_pixel_format_packed_float = has_ext("WGL_EXT_pixel_format_packed_float");
+	GLAD_WGL_EXT_swap_control = has_ext("WGL_EXT_swap_control");
+	GLAD_WGL_EXT_swap_control_tear = has_ext("WGL_EXT_swap_control_tear");
+	GLAD_WGL_I3D_digital_video_control = has_ext("WGL_I3D_digital_video_control");
+	GLAD_WGL_I3D_gamma = has_ext("WGL_I3D_gamma");
+	GLAD_WGL_I3D_genlock = has_ext("WGL_I3D_genlock");
+	GLAD_WGL_I3D_image_buffer = has_ext("WGL_I3D_image_buffer");
+	GLAD_WGL_I3D_swap_frame_lock = has_ext("WGL_I3D_swap_frame_lock");
+	GLAD_WGL_I3D_swap_frame_usage = has_ext("WGL_I3D_swap_frame_usage");
+	GLAD_WGL_NV_DX_interop = has_ext("WGL_NV_DX_interop");
+	GLAD_WGL_NV_DX_interop2 = has_ext("WGL_NV_DX_interop2");
+	GLAD_WGL_NV_copy_image = has_ext("WGL_NV_copy_image");
+	GLAD_WGL_NV_delay_before_swap = has_ext("WGL_NV_delay_before_swap");
+	GLAD_WGL_NV_float_buffer = has_ext("WGL_NV_float_buffer");
+	GLAD_WGL_NV_gpu_affinity = has_ext("WGL_NV_gpu_affinity");
+	GLAD_WGL_NV_multisample_coverage = has_ext("WGL_NV_multisample_coverage");
+	GLAD_WGL_NV_present_video = has_ext("WGL_NV_present_video");
+	GLAD_WGL_NV_render_depth_texture = has_ext("WGL_NV_render_depth_texture");
+	GLAD_WGL_NV_render_texture_rectangle = has_ext("WGL_NV_render_texture_rectangle");
+	GLAD_WGL_NV_swap_group = has_ext("WGL_NV_swap_group");
+	GLAD_WGL_NV_vertex_array_range = has_ext("WGL_NV_vertex_array_range");
+	GLAD_WGL_NV_video_capture = has_ext("WGL_NV_video_capture");
+	GLAD_WGL_NV_video_output = has_ext("WGL_NV_video_output");
+	GLAD_WGL_OML_sync_control = has_ext("WGL_OML_sync_control");
+	free_exts();
+	return 1;
+}
+
+static void find_coreWGL(HDC hdc) {
+	GLADWGLhdc = hdc;
+}
+
+int gladLoadWGLLoader(GLADloadproc load, HDC hdc) {
+	wglGetExtensionsStringARB = (PFNWGLGETEXTENSIONSSTRINGARBPROC)load("wglGetExtensionsStringARB");
+	wglGetExtensionsStringEXT = (PFNWGLGETEXTENSIONSSTRINGEXTPROC)load("wglGetExtensionsStringEXT");
+	if(wglGetExtensionsStringARB == NULL && wglGetExtensionsStringEXT == NULL) return 0;
+	find_coreWGL(hdc);
+
+	if (!find_extensionsWGL()) return 0;
+	load_WGL_3DL_stereo_control(load);
+	load_WGL_AMD_gpu_association(load);
+	load_WGL_ARB_buffer_region(load);
+	load_WGL_ARB_create_context(load);
+	load_WGL_ARB_extensions_string(load);
+	load_WGL_ARB_make_current_read(load);
+	load_WGL_ARB_pbuffer(load);
+	load_WGL_ARB_pixel_format(load);
+	load_WGL_ARB_render_texture(load);
+	load_WGL_EXT_display_color_table(load);
+	load_WGL_EXT_extensions_string(load);
+	load_WGL_EXT_make_current_read(load);
+	load_WGL_EXT_pbuffer(load);
+	load_WGL_EXT_pixel_format(load);
+	load_WGL_EXT_swap_control(load);
+	load_WGL_I3D_digital_video_control(load);
+	load_WGL_I3D_gamma(load);
+	load_WGL_I3D_genlock(load);
+	load_WGL_I3D_image_buffer(load);
+	load_WGL_I3D_swap_frame_lock(load);
+	load_WGL_I3D_swap_frame_usage(load);
+	load_WGL_NV_DX_interop(load);
+	load_WGL_NV_copy_image(load);
+	load_WGL_NV_delay_before_swap(load);
+	load_WGL_NV_gpu_affinity(load);
+	load_WGL_NV_present_video(load);
+	load_WGL_NV_swap_group(load);
+	load_WGL_NV_vertex_array_range(load);
+	load_WGL_NV_video_capture(load);
+	load_WGL_NV_video_output(load);
+	load_WGL_OML_sync_control(load);
+	return 1;
+}
+