Merge pull request #65 from BtbN/glad

Move from glLoadGen to GLAD
2026-01-23 21:58:41 -05:00 · 2014-04-16 12:51:32 -07:00
parent 8e3d2ebbdd a712e631b4
commit 2fc810fd09
26 changed files with 24463 additions and 24603 deletions
--- a/deps/CMakeLists.txt
+++ b/deps/CMakeLists.txt
@@ -3,6 +3,8 @@ if(WIN32)
 	add_subdirectory(w32-pthreads)
 endif()

+add_subdirectory(glad)
+
 set(BUILD_DOCS FALSE CACHE INTERNAL "" FORCE)
 set(STATIC_CRT TRUE CACHE INTERNAL "" FORCE)
 set(BUILD_SHARED_LIBS FALSE CACHE INTERNAL "" FORCE)
--- a/deps/glad/CMakeLists.txt
+++ b/deps/glad/CMakeLists.txt
@@ -0,0 +1,48 @@
+project(glad)
+
+find_package(OpenGL)
+
+if(NOT WIN32 AND NOT APPLE)
+	find_package(X11)
+endif()
+
+set(glad_SOURCES
+	src/glad.c)
+
+if(WIN32)
+	set(glad_PLATFORM_SOURCES
+		src/glad_wgl.c)
+elseif(NOT APPLE)
+	set(glad_PLATFORM_SOURCES
+		src/glad_glx.c)
+endif()
+
+add_library(glad SHARED
+	${glad_SOURCES}
+	${glad_PLATFORM_SOURCES})
+set_target_properties(glad PROPERTIES
+	OUTPUT_NAME obsglad
+	VERSION "0"
+	SOVERSION "0")
+target_include_directories(glad
+	PUBLIC include
+	PRIVATE ${X11_X11_INCLUDE_PATH} ${OPENGL_INCLUDE_DIR})
+target_compile_definitions(glad
+	PRIVATE GLAD_GLAPI_EXPORT_BUILD)
+
+if(NOT WIN32)
+	target_compile_options(glad
+		PRIVATE -DPIC -fPIC -fvisibility=hidden)
+endif()
+
+if(NOT WIN32 AND NOT APPLE)
+	set(glad_PLATFORM_DEPS
+		-ldl
+		${X11_X11_LIB})
+endif()
+
+target_link_libraries(glad
+	${glad_PLATFORM_DEPS}
+	${OPENGL_gl_LIBRARY})
+
+install_obs_core(glad)
--- a/deps/glad/include/KHR/khrplatform.h
+++ b/deps/glad/include/KHR/khrplatform.h
@@ -0,0 +1,282 @@
+#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: 23298 $ on $Date: 2013-09-30 17:07:13 -0700 (Mon, 30 Sep 2013) $
+ *
+ * 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
+#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_ */
--- a/deps/glad/include/glad/glad.h
+++ b/deps/glad/include/glad/glad.h
--- a/deps/glad/include/glad/glad_glx.h
+++ b/deps/glad/include/glad/glad_glx.h
--- a/deps/glad/include/glad/glad_wgl.h
+++ b/deps/glad/include/glad/glad_wgl.h
@@ -0,0 +1,903 @@
+
+#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);
+
+#define GLAD_GLAPI_EXPORT
+
+#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 void 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_COVERAGE_SAMPLES_NV 0x2042
+#define WGL_COLOR_SAMPLES_NV 0x20B9
+#define WGL_IMAGE_BUFFER_MIN_ACCESS_I3D 0x00000001
+#define WGL_IMAGE_BUFFER_LOCK_I3D 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 WGL_TYPE_RGBA_FLOAT_ARB 0x21A0
+#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 ERROR_INCOMPATIBLE_AFFINITY_MASKS_NV 0x20D0
+#define ERROR_MISSING_AFFINITY_MASK_NV 0x20D1
+#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_UNIQUE_ID_NV 0x20CE
+#define WGL_NUM_VIDEO_CAPTURE_SLOTS_NV 0x20CF
+#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_CONTEXT_ES_PROFILE_BIT_EXT 0x00000004
+#define WGL_CONTEXT_RESET_ISOLATION_BIT_ARB 0x00000008
+#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_DEPTH_FLOAT_EXT 0x2040
+#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_SAMPLE_BUFFERS_ARB 0x2041
+#define WGL_SAMPLES_ARB 0x2042
+#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_ACCESS_READ_ONLY_NV 0x00000000
+#define WGL_ACCESS_READ_WRITE_NV 0x00000001
+#define WGL_ACCESS_WRITE_DISCARD_NV 0x00000002
+#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_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_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
+#define WGL_SAMPLE_BUFFERS_3DFX 0x2060
+#define WGL_SAMPLES_3DFX 0x2061
+#define WGL_GAMMA_TABLE_SIZE_I3D 0x204E
+#define WGL_GAMMA_EXCLUDE_DESKTOP_I3D 0x204F
+#define WGL_FRAMEBUFFER_SRGB_CAPABLE_ARB 0x20A9
+#define WGL_FRAMEBUFFER_SRGB_CAPABLE_EXT 0x20A9
+#define WGL_NUM_VIDEO_SLOTS_NV 0x20F0
+#define WGL_CONTEXT_ES2_PROFILE_BIT_EXT 0x00000004
+#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 ERROR_INVALID_PIXEL_TYPE_ARB 0x2043
+#define ERROR_INCOMPATIBLE_DEVICE_CONTEXTS_ARB 0x2054
+#define WGL_SAMPLE_BUFFERS_EXT 0x2041
+#define WGL_SAMPLES_EXT 0x2042
+#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_TYPE_RGBA_FLOAT_ATI 0x21A0
+#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_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_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_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_TYPE_RGBA_UNSIGNED_FLOAT_EXT 0x20A8
+#define ERROR_INVALID_PIXEL_TYPE_EXT 0x2043
+#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
+#ifndef WGL_NV_multisample_coverage
+#define WGL_NV_multisample_coverage 1
+GLAPI int GLAD_WGL_NV_multisample_coverage;
+#endif
+#ifndef WGL_I3D_image_buffer
+#define WGL_I3D_image_buffer 1
+GLAPI int GLAD_WGL_I3D_image_buffer;
+typedef LPVOID (APIENTRYP PFNWGLCREATEIMAGEBUFFERI3DPROC)(HDC, DWORD, UINT);
+GLAPI PFNWGLCREATEIMAGEBUFFERI3DPROC glad_wglCreateImageBufferI3D;
+#define wglCreateImageBufferI3D glad_wglCreateImageBufferI3D
+typedef BOOL (APIENTRYP PFNWGLDESTROYIMAGEBUFFERI3DPROC)(HDC, LPVOID);
+GLAPI PFNWGLDESTROYIMAGEBUFFERI3DPROC glad_wglDestroyImageBufferI3D;
+#define wglDestroyImageBufferI3D glad_wglDestroyImageBufferI3D
+typedef BOOL (APIENTRYP PFNWGLASSOCIATEIMAGEBUFFEREVENTSI3DPROC)(HDC, const HANDLE*, const LPVOID*, const DWORD*, UINT);
+GLAPI PFNWGLASSOCIATEIMAGEBUFFEREVENTSI3DPROC glad_wglAssociateImageBufferEventsI3D;
+#define wglAssociateImageBufferEventsI3D glad_wglAssociateImageBufferEventsI3D
+typedef BOOL (APIENTRYP PFNWGLRELEASEIMAGEBUFFEREVENTSI3DPROC)(HDC, const LPVOID*, UINT);
+GLAPI PFNWGLRELEASEIMAGEBUFFEREVENTSI3DPROC glad_wglReleaseImageBufferEventsI3D;
+#define wglReleaseImageBufferEventsI3D glad_wglReleaseImageBufferEventsI3D
+#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*);
+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*, DWORD*, float*);
+GLAPI PFNWGLQUERYFRAMETRACKINGI3DPROC glad_wglQueryFrameTrackingI3D;
+#define wglQueryFrameTrackingI3D glad_wglQueryFrameTrackingI3D
+#endif
+#ifndef WGL_NV_DX_interop2
+#define WGL_NV_DX_interop2 1
+GLAPI int GLAD_WGL_NV_DX_interop2;
+#endif
+#ifndef WGL_NV_float_buffer
+#define WGL_NV_float_buffer 1
+GLAPI int GLAD_WGL_NV_float_buffer;
+#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, GLfloat);
+GLAPI PFNWGLDELAYBEFORESWAPNVPROC glad_wglDelayBeforeSwapNV;
+#define wglDelayBeforeSwapNV glad_wglDelayBeforeSwapNV
+#endif
+#ifndef WGL_OML_sync_control
+#define WGL_OML_sync_control 1
+GLAPI int GLAD_WGL_OML_sync_control;
+typedef BOOL (APIENTRYP PFNWGLGETSYNCVALUESOMLPROC)(HDC, INT64*, INT64*, INT64*);
+GLAPI PFNWGLGETSYNCVALUESOMLPROC glad_wglGetSyncValuesOML;
+#define wglGetSyncValuesOML glad_wglGetSyncValuesOML
+typedef BOOL (APIENTRYP PFNWGLGETMSCRATEOMLPROC)(HDC, INT32*, INT32*);
+GLAPI PFNWGLGETMSCRATEOMLPROC glad_wglGetMscRateOML;
+#define wglGetMscRateOML glad_wglGetMscRateOML
+typedef INT64 (APIENTRYP PFNWGLSWAPBUFFERSMSCOMLPROC)(HDC, INT64, INT64, INT64);
+GLAPI PFNWGLSWAPBUFFERSMSCOMLPROC glad_wglSwapBuffersMscOML;
+#define wglSwapBuffersMscOML glad_wglSwapBuffersMscOML
+typedef INT64 (APIENTRYP PFNWGLSWAPLAYERBUFFERSMSCOMLPROC)(HDC, int, INT64, INT64, INT64);
+GLAPI PFNWGLSWAPLAYERBUFFERSMSCOMLPROC glad_wglSwapLayerBuffersMscOML;
+#define wglSwapLayerBuffersMscOML glad_wglSwapLayerBuffersMscOML
+typedef BOOL (APIENTRYP PFNWGLWAITFORMSCOMLPROC)(HDC, INT64, INT64, INT64, INT64*, INT64*, INT64*);
+GLAPI PFNWGLWAITFORMSCOMLPROC glad_wglWaitForMscOML;
+#define wglWaitForMscOML glad_wglWaitForMscOML
+typedef BOOL (APIENTRYP PFNWGLWAITFORSBCOMLPROC)(HDC, INT64, INT64*, INT64*, INT64*);
+GLAPI PFNWGLWAITFORSBCOMLPROC glad_wglWaitForSbcOML;
+#define wglWaitForSbcOML glad_wglWaitForSbcOML
+#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_create_context
+#define WGL_ARB_create_context 1
+GLAPI int GLAD_WGL_ARB_create_context;
+typedef HGLRC (APIENTRYP PFNWGLCREATECONTEXTATTRIBSARBPROC)(HDC, HGLRC, const int*);
+GLAPI PFNWGLCREATECONTEXTATTRIBSARBPROC glad_wglCreateContextAttribsARB;
+#define wglCreateContextAttribsARB glad_wglCreateContextAttribsARB
+#endif
+#ifndef WGL_NV_swap_group
+#define WGL_NV_swap_group 1
+GLAPI int GLAD_WGL_NV_swap_group;
+typedef BOOL (APIENTRYP PFNWGLJOINSWAPGROUPNVPROC)(HDC, GLuint);
+GLAPI PFNWGLJOINSWAPGROUPNVPROC glad_wglJoinSwapGroupNV;
+#define wglJoinSwapGroupNV glad_wglJoinSwapGroupNV
+typedef BOOL (APIENTRYP PFNWGLBINDSWAPBARRIERNVPROC)(GLuint, GLuint);
+GLAPI PFNWGLBINDSWAPBARRIERNVPROC glad_wglBindSwapBarrierNV;
+#define wglBindSwapBarrierNV glad_wglBindSwapBarrierNV
+typedef BOOL (APIENTRYP PFNWGLQUERYSWAPGROUPNVPROC)(HDC, GLuint*, GLuint*);
+GLAPI PFNWGLQUERYSWAPGROUPNVPROC glad_wglQuerySwapGroupNV;
+#define wglQuerySwapGroupNV glad_wglQuerySwapGroupNV
+typedef BOOL (APIENTRYP PFNWGLQUERYMAXSWAPGROUPSNVPROC)(HDC, GLuint*, GLuint*);
+GLAPI PFNWGLQUERYMAXSWAPGROUPSNVPROC glad_wglQueryMaxSwapGroupsNV;
+#define wglQueryMaxSwapGroupsNV glad_wglQueryMaxSwapGroupsNV
+typedef BOOL (APIENTRYP PFNWGLQUERYFRAMECOUNTNVPROC)(HDC, GLuint*);
+GLAPI PFNWGLQUERYFRAMECOUNTNVPROC glad_wglQueryFrameCountNV;
+#define wglQueryFrameCountNV glad_wglQueryFrameCountNV
+typedef BOOL (APIENTRYP PFNWGLRESETFRAMECOUNTNVPROC)(HDC);
+GLAPI PFNWGLRESETFRAMECOUNTNVPROC glad_wglResetFrameCountNV;
+#define wglResetFrameCountNV glad_wglResetFrameCountNV
+#endif
+#ifndef WGL_NV_gpu_affinity
+#define WGL_NV_gpu_affinity 1
+GLAPI int GLAD_WGL_NV_gpu_affinity;
+typedef BOOL (APIENTRYP PFNWGLENUMGPUSNVPROC)(UINT, HGPUNV*);
+GLAPI PFNWGLENUMGPUSNVPROC glad_wglEnumGpusNV;
+#define wglEnumGpusNV glad_wglEnumGpusNV
+typedef BOOL (APIENTRYP PFNWGLENUMGPUDEVICESNVPROC)(HGPUNV, UINT, PGPU_DEVICE);
+GLAPI PFNWGLENUMGPUDEVICESNVPROC glad_wglEnumGpuDevicesNV;
+#define wglEnumGpuDevicesNV glad_wglEnumGpuDevicesNV
+typedef HDC (APIENTRYP PFNWGLCREATEAFFINITYDCNVPROC)(const HGPUNV*);
+GLAPI PFNWGLCREATEAFFINITYDCNVPROC glad_wglCreateAffinityDCNV;
+#define wglCreateAffinityDCNV glad_wglCreateAffinityDCNV
+typedef BOOL (APIENTRYP PFNWGLENUMGPUSFROMAFFINITYDCNVPROC)(HDC, UINT, HGPUNV*);
+GLAPI PFNWGLENUMGPUSFROMAFFINITYDCNVPROC glad_wglEnumGpusFromAffinityDCNV;
+#define wglEnumGpusFromAffinityDCNV glad_wglEnumGpusFromAffinityDCNV
+typedef BOOL (APIENTRYP PFNWGLDELETEDCNVPROC)(HDC);
+GLAPI PFNWGLDELETEDCNVPROC glad_wglDeleteDCNV;
+#define wglDeleteDCNV glad_wglDeleteDCNV
+#endif
+#ifndef WGL_EXT_pixel_format
+#define WGL_EXT_pixel_format 1
+GLAPI int GLAD_WGL_EXT_pixel_format;
+typedef BOOL (APIENTRYP PFNWGLGETPIXELFORMATATTRIBIVEXTPROC)(HDC, int, int, UINT, int*, int*);
+GLAPI PFNWGLGETPIXELFORMATATTRIBIVEXTPROC glad_wglGetPixelFormatAttribivEXT;
+#define wglGetPixelFormatAttribivEXT glad_wglGetPixelFormatAttribivEXT
+typedef BOOL (APIENTRYP PFNWGLGETPIXELFORMATATTRIBFVEXTPROC)(HDC, int, int, UINT, int*, FLOAT*);
+GLAPI PFNWGLGETPIXELFORMATATTRIBFVEXTPROC glad_wglGetPixelFormatAttribfvEXT;
+#define wglGetPixelFormatAttribfvEXT glad_wglGetPixelFormatAttribfvEXT
+typedef BOOL (APIENTRYP PFNWGLCHOOSEPIXELFORMATEXTPROC)(HDC, const int*, const FLOAT*, UINT, int*, UINT*);
+GLAPI PFNWGLCHOOSEPIXELFORMATEXTPROC glad_wglChoosePixelFormatEXT;
+#define wglChoosePixelFormatEXT glad_wglChoosePixelFormatEXT
+#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);
+GLAPI PFNWGLGETEXTENSIONSSTRINGARBPROC glad_wglGetExtensionsStringARB;
+#define wglGetExtensionsStringARB glad_wglGetExtensionsStringARB
+#endif
+#ifndef WGL_NV_video_capture
+#define WGL_NV_video_capture 1
+GLAPI int GLAD_WGL_NV_video_capture;
+typedef BOOL (APIENTRYP PFNWGLBINDVIDEOCAPTUREDEVICENVPROC)(UINT, HVIDEOINPUTDEVICENV);
+GLAPI PFNWGLBINDVIDEOCAPTUREDEVICENVPROC glad_wglBindVideoCaptureDeviceNV;
+#define wglBindVideoCaptureDeviceNV glad_wglBindVideoCaptureDeviceNV
+typedef UINT (APIENTRYP PFNWGLENUMERATEVIDEOCAPTUREDEVICESNVPROC)(HDC, HVIDEOINPUTDEVICENV*);
+GLAPI PFNWGLENUMERATEVIDEOCAPTUREDEVICESNVPROC glad_wglEnumerateVideoCaptureDevicesNV;
+#define wglEnumerateVideoCaptureDevicesNV glad_wglEnumerateVideoCaptureDevicesNV
+typedef BOOL (APIENTRYP PFNWGLLOCKVIDEOCAPTUREDEVICENVPROC)(HDC, HVIDEOINPUTDEVICENV);
+GLAPI PFNWGLLOCKVIDEOCAPTUREDEVICENVPROC glad_wglLockVideoCaptureDeviceNV;
+#define wglLockVideoCaptureDeviceNV glad_wglLockVideoCaptureDeviceNV
+typedef BOOL (APIENTRYP PFNWGLQUERYVIDEOCAPTUREDEVICENVPROC)(HDC, HVIDEOINPUTDEVICENV, int, int*);
+GLAPI PFNWGLQUERYVIDEOCAPTUREDEVICENVPROC glad_wglQueryVideoCaptureDeviceNV;
+#define wglQueryVideoCaptureDeviceNV glad_wglQueryVideoCaptureDeviceNV
+typedef BOOL (APIENTRYP PFNWGLRELEASEVIDEOCAPTUREDEVICENVPROC)(HDC, HVIDEOINPUTDEVICENV);
+GLAPI PFNWGLRELEASEVIDEOCAPTUREDEVICENVPROC glad_wglReleaseVideoCaptureDeviceNV;
+#define wglReleaseVideoCaptureDeviceNV glad_wglReleaseVideoCaptureDeviceNV
+#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_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_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_ARB_render_texture
+#define WGL_ARB_render_texture 1
+GLAPI int GLAD_WGL_ARB_render_texture;
+typedef BOOL (APIENTRYP PFNWGLBINDTEXIMAGEARBPROC)(HPBUFFERARB, int);
+GLAPI PFNWGLBINDTEXIMAGEARBPROC glad_wglBindTexImageARB;
+#define wglBindTexImageARB glad_wglBindTexImageARB
+typedef BOOL (APIENTRYP PFNWGLRELEASETEXIMAGEARBPROC)(HPBUFFERARB, int);
+GLAPI PFNWGLRELEASETEXIMAGEARBPROC glad_wglReleaseTexImageARB;
+#define wglReleaseTexImageARB glad_wglReleaseTexImageARB
+typedef BOOL (APIENTRYP PFNWGLSETPBUFFERATTRIBARBPROC)(HPBUFFERARB, const int*);
+GLAPI PFNWGLSETPBUFFERATTRIBARBPROC glad_wglSetPbufferAttribARB;
+#define wglSetPbufferAttribARB glad_wglSetPbufferAttribARB
+#endif
+#ifndef WGL_EXT_depth_float
+#define WGL_EXT_depth_float 1
+GLAPI int GLAD_WGL_EXT_depth_float;
+#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_ARB_pixel_format
+#define WGL_ARB_pixel_format 1
+GLAPI int GLAD_WGL_ARB_pixel_format;
+typedef BOOL (APIENTRYP PFNWGLGETPIXELFORMATATTRIBIVARBPROC)(HDC, int, int, UINT, const int*, int*);
+GLAPI PFNWGLGETPIXELFORMATATTRIBIVARBPROC glad_wglGetPixelFormatAttribivARB;
+#define wglGetPixelFormatAttribivARB glad_wglGetPixelFormatAttribivARB
+typedef BOOL (APIENTRYP PFNWGLGETPIXELFORMATATTRIBFVARBPROC)(HDC, int, int, UINT, const int*, FLOAT*);
+GLAPI PFNWGLGETPIXELFORMATATTRIBFVARBPROC glad_wglGetPixelFormatAttribfvARB;
+#define wglGetPixelFormatAttribfvARB glad_wglGetPixelFormatAttribfvARB
+typedef BOOL (APIENTRYP PFNWGLCHOOSEPIXELFORMATARBPROC)(HDC, const int*, const FLOAT*, UINT, int*, UINT*);
+GLAPI PFNWGLCHOOSEPIXELFORMATARBPROC glad_wglChoosePixelFormatARB;
+#define wglChoosePixelFormatARB glad_wglChoosePixelFormatARB
+#endif
+#ifndef WGL_ARB_multisample
+#define WGL_ARB_multisample 1
+GLAPI int GLAD_WGL_ARB_multisample;
+#endif
+#ifndef WGL_I3D_genlock
+#define WGL_I3D_genlock 1
+GLAPI int GLAD_WGL_I3D_genlock;
+typedef BOOL (APIENTRYP PFNWGLENABLEGENLOCKI3DPROC)(HDC);
+GLAPI PFNWGLENABLEGENLOCKI3DPROC glad_wglEnableGenlockI3D;
+#define wglEnableGenlockI3D glad_wglEnableGenlockI3D
+typedef BOOL (APIENTRYP PFNWGLDISABLEGENLOCKI3DPROC)(HDC);
+GLAPI PFNWGLDISABLEGENLOCKI3DPROC glad_wglDisableGenlockI3D;
+#define wglDisableGenlockI3D glad_wglDisableGenlockI3D
+typedef BOOL (APIENTRYP PFNWGLISENABLEDGENLOCKI3DPROC)(HDC, BOOL*);
+GLAPI PFNWGLISENABLEDGENLOCKI3DPROC glad_wglIsEnabledGenlockI3D;
+#define wglIsEnabledGenlockI3D glad_wglIsEnabledGenlockI3D
+typedef BOOL (APIENTRYP PFNWGLGENLOCKSOURCEI3DPROC)(HDC, UINT);
+GLAPI PFNWGLGENLOCKSOURCEI3DPROC glad_wglGenlockSourceI3D;
+#define wglGenlockSourceI3D glad_wglGenlockSourceI3D
+typedef BOOL (APIENTRYP PFNWGLGETGENLOCKSOURCEI3DPROC)(HDC, UINT*);
+GLAPI PFNWGLGETGENLOCKSOURCEI3DPROC glad_wglGetGenlockSourceI3D;
+#define wglGetGenlockSourceI3D glad_wglGetGenlockSourceI3D
+typedef BOOL (APIENTRYP PFNWGLGENLOCKSOURCEEDGEI3DPROC)(HDC, UINT);
+GLAPI PFNWGLGENLOCKSOURCEEDGEI3DPROC glad_wglGenlockSourceEdgeI3D;
+#define wglGenlockSourceEdgeI3D glad_wglGenlockSourceEdgeI3D
+typedef BOOL (APIENTRYP PFNWGLGETGENLOCKSOURCEEDGEI3DPROC)(HDC, UINT*);
+GLAPI PFNWGLGETGENLOCKSOURCEEDGEI3DPROC glad_wglGetGenlockSourceEdgeI3D;
+#define wglGetGenlockSourceEdgeI3D glad_wglGetGenlockSourceEdgeI3D
+typedef BOOL (APIENTRYP PFNWGLGENLOCKSAMPLERATEI3DPROC)(HDC, UINT);
+GLAPI PFNWGLGENLOCKSAMPLERATEI3DPROC glad_wglGenlockSampleRateI3D;
+#define wglGenlockSampleRateI3D glad_wglGenlockSampleRateI3D
+typedef BOOL (APIENTRYP PFNWGLGETGENLOCKSAMPLERATEI3DPROC)(HDC, UINT*);
+GLAPI PFNWGLGETGENLOCKSAMPLERATEI3DPROC glad_wglGetGenlockSampleRateI3D;
+#define wglGetGenlockSampleRateI3D glad_wglGetGenlockSampleRateI3D
+typedef BOOL (APIENTRYP PFNWGLGENLOCKSOURCEDELAYI3DPROC)(HDC, UINT);
+GLAPI PFNWGLGENLOCKSOURCEDELAYI3DPROC glad_wglGenlockSourceDelayI3D;
+#define wglGenlockSourceDelayI3D glad_wglGenlockSourceDelayI3D
+typedef BOOL (APIENTRYP PFNWGLGETGENLOCKSOURCEDELAYI3DPROC)(HDC, UINT*);
+GLAPI PFNWGLGETGENLOCKSOURCEDELAYI3DPROC glad_wglGetGenlockSourceDelayI3D;
+#define wglGetGenlockSourceDelayI3D glad_wglGetGenlockSourceDelayI3D
+typedef BOOL (APIENTRYP PFNWGLQUERYGENLOCKMAXSOURCEDELAYI3DPROC)(HDC, UINT*, UINT*);
+GLAPI PFNWGLQUERYGENLOCKMAXSOURCEDELAYI3DPROC glad_wglQueryGenlockMaxSourceDelayI3D;
+#define wglQueryGenlockMaxSourceDelayI3D glad_wglQueryGenlockMaxSourceDelayI3D
+#endif
+#ifndef WGL_NV_DX_interop
+#define WGL_NV_DX_interop 1
+GLAPI int GLAD_WGL_NV_DX_interop;
+typedef BOOL (APIENTRYP PFNWGLDXSETRESOURCESHAREHANDLENVPROC)(void*, HANDLE);
+GLAPI PFNWGLDXSETRESOURCESHAREHANDLENVPROC glad_wglDXSetResourceShareHandleNV;
+#define wglDXSetResourceShareHandleNV glad_wglDXSetResourceShareHandleNV
+typedef HANDLE (APIENTRYP PFNWGLDXOPENDEVICENVPROC)(void*);
+GLAPI PFNWGLDXOPENDEVICENVPROC glad_wglDXOpenDeviceNV;
+#define wglDXOpenDeviceNV glad_wglDXOpenDeviceNV
+typedef BOOL (APIENTRYP PFNWGLDXCLOSEDEVICENVPROC)(HANDLE);
+GLAPI PFNWGLDXCLOSEDEVICENVPROC glad_wglDXCloseDeviceNV;
+#define wglDXCloseDeviceNV glad_wglDXCloseDeviceNV
+typedef HANDLE (APIENTRYP PFNWGLDXREGISTEROBJECTNVPROC)(HANDLE, void*, GLuint, GLenum, GLenum);
+GLAPI PFNWGLDXREGISTEROBJECTNVPROC glad_wglDXRegisterObjectNV;
+#define wglDXRegisterObjectNV glad_wglDXRegisterObjectNV
+typedef BOOL (APIENTRYP PFNWGLDXUNREGISTEROBJECTNVPROC)(HANDLE, HANDLE);
+GLAPI PFNWGLDXUNREGISTEROBJECTNVPROC glad_wglDXUnregisterObjectNV;
+#define wglDXUnregisterObjectNV glad_wglDXUnregisterObjectNV
+typedef BOOL (APIENTRYP PFNWGLDXOBJECTACCESSNVPROC)(HANDLE, GLenum);
+GLAPI PFNWGLDXOBJECTACCESSNVPROC glad_wglDXObjectAccessNV;
+#define wglDXObjectAccessNV glad_wglDXObjectAccessNV
+typedef BOOL (APIENTRYP PFNWGLDXLOCKOBJECTSNVPROC)(HANDLE, GLint, HANDLE*);
+GLAPI PFNWGLDXLOCKOBJECTSNVPROC glad_wglDXLockObjectsNV;
+#define wglDXLockObjectsNV glad_wglDXLockObjectsNV
+typedef BOOL (APIENTRYP PFNWGLDXUNLOCKOBJECTSNVPROC)(HANDLE, GLint, HANDLE*);
+GLAPI PFNWGLDXUNLOCKOBJECTSNVPROC glad_wglDXUnlockObjectsNV;
+#define wglDXUnlockObjectsNV glad_wglDXUnlockObjectsNV
+#endif
+#ifndef WGL_3DL_stereo_control
+#define WGL_3DL_stereo_control 1
+GLAPI int GLAD_WGL_3DL_stereo_control;
+typedef BOOL (APIENTRYP PFNWGLSETSTEREOEMITTERSTATE3DLPROC)(HDC, UINT);
+GLAPI PFNWGLSETSTEREOEMITTERSTATE3DLPROC glad_wglSetStereoEmitterState3DL;
+#define wglSetStereoEmitterState3DL glad_wglSetStereoEmitterState3DL
+#endif
+#ifndef WGL_EXT_pbuffer
+#define WGL_EXT_pbuffer 1
+GLAPI int GLAD_WGL_EXT_pbuffer;
+typedef HPBUFFEREXT (APIENTRYP PFNWGLCREATEPBUFFEREXTPROC)(HDC, int, int, int, const int*);
+GLAPI PFNWGLCREATEPBUFFEREXTPROC glad_wglCreatePbufferEXT;
+#define wglCreatePbufferEXT glad_wglCreatePbufferEXT
+typedef HDC (APIENTRYP PFNWGLGETPBUFFERDCEXTPROC)(HPBUFFEREXT);
+GLAPI PFNWGLGETPBUFFERDCEXTPROC glad_wglGetPbufferDCEXT;
+#define wglGetPbufferDCEXT glad_wglGetPbufferDCEXT
+typedef int (APIENTRYP PFNWGLRELEASEPBUFFERDCEXTPROC)(HPBUFFEREXT, HDC);
+GLAPI PFNWGLRELEASEPBUFFERDCEXTPROC glad_wglReleasePbufferDCEXT;
+#define wglReleasePbufferDCEXT glad_wglReleasePbufferDCEXT
+typedef BOOL (APIENTRYP PFNWGLDESTROYPBUFFEREXTPROC)(HPBUFFEREXT);
+GLAPI PFNWGLDESTROYPBUFFEREXTPROC glad_wglDestroyPbufferEXT;
+#define wglDestroyPbufferEXT glad_wglDestroyPbufferEXT
+typedef BOOL (APIENTRYP PFNWGLQUERYPBUFFEREXTPROC)(HPBUFFEREXT, int, int*);
+GLAPI PFNWGLQUERYPBUFFEREXTPROC glad_wglQueryPbufferEXT;
+#define wglQueryPbufferEXT glad_wglQueryPbufferEXT
+#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);
+GLAPI PFNWGLCREATEDISPLAYCOLORTABLEEXTPROC glad_wglCreateDisplayColorTableEXT;
+#define wglCreateDisplayColorTableEXT glad_wglCreateDisplayColorTableEXT
+typedef GLboolean (APIENTRYP PFNWGLLOADDISPLAYCOLORTABLEEXTPROC)(const GLushort*, GLuint);
+GLAPI PFNWGLLOADDISPLAYCOLORTABLEEXTPROC glad_wglLoadDisplayColorTableEXT;
+#define wglLoadDisplayColorTableEXT glad_wglLoadDisplayColorTableEXT
+typedef GLboolean (APIENTRYP PFNWGLBINDDISPLAYCOLORTABLEEXTPROC)(GLushort);
+GLAPI PFNWGLBINDDISPLAYCOLORTABLEEXTPROC glad_wglBindDisplayColorTableEXT;
+#define wglBindDisplayColorTableEXT glad_wglBindDisplayColorTableEXT
+typedef VOID (APIENTRYP PFNWGLDESTROYDISPLAYCOLORTABLEEXTPROC)(GLushort);
+GLAPI PFNWGLDESTROYDISPLAYCOLORTABLEEXTPROC glad_wglDestroyDisplayColorTableEXT;
+#define wglDestroyDisplayColorTableEXT glad_wglDestroyDisplayColorTableEXT
+#endif
+#ifndef WGL_NV_video_output
+#define WGL_NV_video_output 1
+GLAPI int GLAD_WGL_NV_video_output;
+typedef BOOL (APIENTRYP PFNWGLGETVIDEODEVICENVPROC)(HDC, int, HPVIDEODEV*);
+GLAPI PFNWGLGETVIDEODEVICENVPROC glad_wglGetVideoDeviceNV;
+#define wglGetVideoDeviceNV glad_wglGetVideoDeviceNV
+typedef BOOL (APIENTRYP PFNWGLRELEASEVIDEODEVICENVPROC)(HPVIDEODEV);
+GLAPI PFNWGLRELEASEVIDEODEVICENVPROC glad_wglReleaseVideoDeviceNV;
+#define wglReleaseVideoDeviceNV glad_wglReleaseVideoDeviceNV
+typedef BOOL (APIENTRYP PFNWGLBINDVIDEOIMAGENVPROC)(HPVIDEODEV, HPBUFFERARB, int);
+GLAPI PFNWGLBINDVIDEOIMAGENVPROC glad_wglBindVideoImageNV;
+#define wglBindVideoImageNV glad_wglBindVideoImageNV
+typedef BOOL (APIENTRYP PFNWGLRELEASEVIDEOIMAGENVPROC)(HPBUFFERARB, int);
+GLAPI PFNWGLRELEASEVIDEOIMAGENVPROC glad_wglReleaseVideoImageNV;
+#define wglReleaseVideoImageNV glad_wglReleaseVideoImageNV
+typedef BOOL (APIENTRYP PFNWGLSENDPBUFFERTOVIDEONVPROC)(HPBUFFERARB, int, unsigned long*, BOOL);
+GLAPI PFNWGLSENDPBUFFERTOVIDEONVPROC glad_wglSendPbufferToVideoNV;
+#define wglSendPbufferToVideoNV glad_wglSendPbufferToVideoNV
+typedef BOOL (APIENTRYP PFNWGLGETVIDEOINFONVPROC)(HPVIDEODEV, unsigned long*, unsigned long*);
+GLAPI PFNWGLGETVIDEOINFONVPROC glad_wglGetVideoInfoNV;
+#define wglGetVideoInfoNV glad_wglGetVideoInfoNV
+#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_3DFX_multisample
+#define WGL_3DFX_multisample 1
+GLAPI int GLAD_WGL_3DFX_multisample;
+#endif
+#ifndef WGL_I3D_gamma
+#define WGL_I3D_gamma 1
+GLAPI int GLAD_WGL_I3D_gamma;
+typedef BOOL (APIENTRYP PFNWGLGETGAMMATABLEPARAMETERSI3DPROC)(HDC, int, int*);
+GLAPI PFNWGLGETGAMMATABLEPARAMETERSI3DPROC glad_wglGetGammaTableParametersI3D;
+#define wglGetGammaTableParametersI3D glad_wglGetGammaTableParametersI3D
+typedef BOOL (APIENTRYP PFNWGLSETGAMMATABLEPARAMETERSI3DPROC)(HDC, int, const int*);
+GLAPI PFNWGLSETGAMMATABLEPARAMETERSI3DPROC glad_wglSetGammaTableParametersI3D;
+#define wglSetGammaTableParametersI3D glad_wglSetGammaTableParametersI3D
+typedef BOOL (APIENTRYP PFNWGLGETGAMMATABLEI3DPROC)(HDC, int, USHORT*, USHORT*, USHORT*);
+GLAPI PFNWGLGETGAMMATABLEI3DPROC glad_wglGetGammaTableI3D;
+#define wglGetGammaTableI3D glad_wglGetGammaTableI3D
+typedef BOOL (APIENTRYP PFNWGLSETGAMMATABLEI3DPROC)(HDC, int, const USHORT*, const USHORT*, const USHORT*);
+GLAPI PFNWGLSETGAMMATABLEI3DPROC glad_wglSetGammaTableI3D;
+#define wglSetGammaTableI3D glad_wglSetGammaTableI3D
+#endif
+#ifndef WGL_ARB_framebuffer_sRGB
+#define WGL_ARB_framebuffer_sRGB 1
+GLAPI int GLAD_WGL_ARB_framebuffer_sRGB;
+#endif
+#ifndef WGL_NV_copy_image
+#define WGL_NV_copy_image 1
+GLAPI int GLAD_WGL_NV_copy_image;
+typedef BOOL (APIENTRYP PFNWGLCOPYIMAGESUBDATANVPROC)(HGLRC, GLuint, GLenum, GLint, GLint, GLint, GLint, HGLRC, GLuint, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei);
+GLAPI PFNWGLCOPYIMAGESUBDATANVPROC glad_wglCopyImageSubDataNV;
+#define wglCopyImageSubDataNV glad_wglCopyImageSubDataNV
+#endif
+#ifndef WGL_EXT_framebuffer_sRGB
+#define WGL_EXT_framebuffer_sRGB 1
+GLAPI int GLAD_WGL_EXT_framebuffer_sRGB;
+#endif
+#ifndef WGL_NV_present_video
+#define WGL_NV_present_video 1
+GLAPI int GLAD_WGL_NV_present_video;
+typedef int (APIENTRYP PFNWGLENUMERATEVIDEODEVICESNVPROC)(HDC, HVIDEOOUTPUTDEVICENV*);
+GLAPI PFNWGLENUMERATEVIDEODEVICESNVPROC glad_wglEnumerateVideoDevicesNV;
+#define wglEnumerateVideoDevicesNV glad_wglEnumerateVideoDevicesNV
+typedef BOOL (APIENTRYP PFNWGLBINDVIDEODEVICENVPROC)(HDC, unsigned int, HVIDEOOUTPUTDEVICENV, const int*);
+GLAPI PFNWGLBINDVIDEODEVICENVPROC glad_wglBindVideoDeviceNV;
+#define wglBindVideoDeviceNV glad_wglBindVideoDeviceNV
+typedef BOOL (APIENTRYP PFNWGLQUERYCURRENTCONTEXTNVPROC)(int, int*);
+GLAPI PFNWGLQUERYCURRENTCONTEXTNVPROC glad_wglQueryCurrentContextNV;
+#define wglQueryCurrentContextNV glad_wglQueryCurrentContextNV
+#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_ARB_create_context_robustness
+#define WGL_ARB_create_context_robustness 1
+GLAPI int GLAD_WGL_ARB_create_context_robustness;
+#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, HDC, HGLRC);
+GLAPI PFNWGLMAKECONTEXTCURRENTARBPROC glad_wglMakeContextCurrentARB;
+#define wglMakeContextCurrentARB glad_wglMakeContextCurrentARB
+typedef HDC (APIENTRYP PFNWGLGETCURRENTREADDCARBPROC)();
+GLAPI PFNWGLGETCURRENTREADDCARBPROC glad_wglGetCurrentReadDCARB;
+#define wglGetCurrentReadDCARB glad_wglGetCurrentReadDCARB
+#endif
+#ifndef WGL_EXT_multisample
+#define WGL_EXT_multisample 1
+GLAPI int GLAD_WGL_EXT_multisample;
+#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_NV_render_depth_texture
+#define WGL_NV_render_depth_texture 1
+GLAPI int GLAD_WGL_NV_render_depth_texture;
+#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_ARB_create_context_profile
+#define WGL_ARB_create_context_profile 1
+GLAPI int GLAD_WGL_ARB_create_context_profile;
+#endif
+#ifndef WGL_EXT_swap_control
+#define WGL_EXT_swap_control 1
+GLAPI int GLAD_WGL_EXT_swap_control;
+typedef BOOL (APIENTRYP PFNWGLSWAPINTERVALEXTPROC)(int);
+GLAPI PFNWGLSWAPINTERVALEXTPROC glad_wglSwapIntervalEXT;
+#define wglSwapIntervalEXT glad_wglSwapIntervalEXT
+typedef int (APIENTRYP PFNWGLGETSWAPINTERVALEXTPROC)();
+GLAPI PFNWGLGETSWAPINTERVALEXTPROC glad_wglGetSwapIntervalEXT;
+#define wglGetSwapIntervalEXT glad_wglGetSwapIntervalEXT
+#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, int, int*);
+GLAPI PFNWGLGETDIGITALVIDEOPARAMETERSI3DPROC glad_wglGetDigitalVideoParametersI3D;
+#define wglGetDigitalVideoParametersI3D glad_wglGetDigitalVideoParametersI3D
+typedef BOOL (APIENTRYP PFNWGLSETDIGITALVIDEOPARAMETERSI3DPROC)(HDC, int, const int*);
+GLAPI PFNWGLSETDIGITALVIDEOPARAMETERSI3DPROC glad_wglSetDigitalVideoParametersI3D;
+#define wglSetDigitalVideoParametersI3D glad_wglSetDigitalVideoParametersI3D
+#endif
+#ifndef WGL_ARB_pbuffer
+#define WGL_ARB_pbuffer 1
+GLAPI int GLAD_WGL_ARB_pbuffer;
+typedef HPBUFFERARB (APIENTRYP PFNWGLCREATEPBUFFERARBPROC)(HDC, int, int, int, const int*);
+GLAPI PFNWGLCREATEPBUFFERARBPROC glad_wglCreatePbufferARB;
+#define wglCreatePbufferARB glad_wglCreatePbufferARB
+typedef HDC (APIENTRYP PFNWGLGETPBUFFERDCARBPROC)(HPBUFFERARB);
+GLAPI PFNWGLGETPBUFFERDCARBPROC glad_wglGetPbufferDCARB;
+#define wglGetPbufferDCARB glad_wglGetPbufferDCARB
+typedef int (APIENTRYP PFNWGLRELEASEPBUFFERDCARBPROC)(HPBUFFERARB, HDC);
+GLAPI PFNWGLRELEASEPBUFFERDCARBPROC glad_wglReleasePbufferDCARB;
+#define wglReleasePbufferDCARB glad_wglReleasePbufferDCARB
+typedef BOOL (APIENTRYP PFNWGLDESTROYPBUFFERARBPROC)(HPBUFFERARB);
+GLAPI PFNWGLDESTROYPBUFFERARBPROC glad_wglDestroyPbufferARB;
+#define wglDestroyPbufferARB glad_wglDestroyPbufferARB
+typedef BOOL (APIENTRYP PFNWGLQUERYPBUFFERARBPROC)(HPBUFFERARB, int, int*);
+GLAPI PFNWGLQUERYPBUFFERARBPROC glad_wglQueryPbufferARB;
+#define wglQueryPbufferARB glad_wglQueryPbufferARB
+#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, GLfloat, GLfloat, GLfloat);
+GLAPI PFNWGLALLOCATEMEMORYNVPROC glad_wglAllocateMemoryNV;
+#define wglAllocateMemoryNV glad_wglAllocateMemoryNV
+typedef void (APIENTRYP PFNWGLFREEMEMORYNVPROC)(void*);
+GLAPI PFNWGLFREEMEMORYNVPROC glad_wglFreeMemoryNV;
+#define wglFreeMemoryNV glad_wglFreeMemoryNV
+#endif
+#ifndef WGL_AMD_gpu_association
+#define WGL_AMD_gpu_association 1
+GLAPI int GLAD_WGL_AMD_gpu_association;
+typedef UINT (APIENTRYP PFNWGLGETGPUIDSAMDPROC)(UINT, UINT*);
+GLAPI PFNWGLGETGPUIDSAMDPROC glad_wglGetGPUIDsAMD;
+#define wglGetGPUIDsAMD glad_wglGetGPUIDsAMD
+typedef INT (APIENTRYP PFNWGLGETGPUINFOAMDPROC)(UINT, int, GLenum, UINT, void*);
+GLAPI PFNWGLGETGPUINFOAMDPROC glad_wglGetGPUInfoAMD;
+#define wglGetGPUInfoAMD glad_wglGetGPUInfoAMD
+typedef UINT (APIENTRYP PFNWGLGETCONTEXTGPUIDAMDPROC)(HGLRC);
+GLAPI PFNWGLGETCONTEXTGPUIDAMDPROC glad_wglGetContextGPUIDAMD;
+#define wglGetContextGPUIDAMD glad_wglGetContextGPUIDAMD
+typedef HGLRC (APIENTRYP PFNWGLCREATEASSOCIATEDCONTEXTAMDPROC)(UINT);
+GLAPI PFNWGLCREATEASSOCIATEDCONTEXTAMDPROC glad_wglCreateAssociatedContextAMD;
+#define wglCreateAssociatedContextAMD glad_wglCreateAssociatedContextAMD
+typedef HGLRC (APIENTRYP PFNWGLCREATEASSOCIATEDCONTEXTATTRIBSAMDPROC)(UINT, HGLRC, const int*);
+GLAPI PFNWGLCREATEASSOCIATEDCONTEXTATTRIBSAMDPROC glad_wglCreateAssociatedContextAttribsAMD;
+#define wglCreateAssociatedContextAttribsAMD glad_wglCreateAssociatedContextAttribsAMD
+typedef BOOL (APIENTRYP PFNWGLDELETEASSOCIATEDCONTEXTAMDPROC)(HGLRC);
+GLAPI PFNWGLDELETEASSOCIATEDCONTEXTAMDPROC glad_wglDeleteAssociatedContextAMD;
+#define wglDeleteAssociatedContextAMD glad_wglDeleteAssociatedContextAMD
+typedef BOOL (APIENTRYP PFNWGLMAKEASSOCIATEDCONTEXTCURRENTAMDPROC)(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, GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLbitfield, GLenum);
+GLAPI PFNWGLBLITCONTEXTFRAMEBUFFERAMDPROC glad_wglBlitContextFramebufferAMD;
+#define wglBlitContextFramebufferAMD glad_wglBlitContextFramebufferAMD
+#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_make_current_read
+#define WGL_EXT_make_current_read 1
+GLAPI int GLAD_WGL_EXT_make_current_read;
+typedef BOOL (APIENTRYP PFNWGLMAKECONTEXTCURRENTEXTPROC)(HDC, HDC, HGLRC);
+GLAPI PFNWGLMAKECONTEXTCURRENTEXTPROC glad_wglMakeContextCurrentEXT;
+#define wglMakeContextCurrentEXT glad_wglMakeContextCurrentEXT
+typedef HDC (APIENTRYP PFNWGLGETCURRENTREADDCEXTPROC)();
+GLAPI PFNWGLGETCURRENTREADDCEXTPROC glad_wglGetCurrentReadDCEXT;
+#define wglGetCurrentReadDCEXT glad_wglGetCurrentReadDCEXT
+#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*);
+GLAPI PFNWGLISENABLEDFRAMELOCKI3DPROC glad_wglIsEnabledFrameLockI3D;
+#define wglIsEnabledFrameLockI3D glad_wglIsEnabledFrameLockI3D
+typedef BOOL (APIENTRYP PFNWGLQUERYFRAMELOCKMASTERI3DPROC)(BOOL*);
+GLAPI PFNWGLQUERYFRAMELOCKMASTERI3DPROC glad_wglQueryFrameLockMasterI3D;
+#define wglQueryFrameLockMasterI3D glad_wglQueryFrameLockMasterI3D
+#endif
+#ifndef WGL_ARB_buffer_region
+#define WGL_ARB_buffer_region 1
+GLAPI int GLAD_WGL_ARB_buffer_region;
+typedef HANDLE (APIENTRYP PFNWGLCREATEBUFFERREGIONARBPROC)(HDC, int, UINT);
+GLAPI PFNWGLCREATEBUFFERREGIONARBPROC glad_wglCreateBufferRegionARB;
+#define wglCreateBufferRegionARB glad_wglCreateBufferRegionARB
+typedef VOID (APIENTRYP PFNWGLDELETEBUFFERREGIONARBPROC)(HANDLE);
+GLAPI PFNWGLDELETEBUFFERREGIONARBPROC glad_wglDeleteBufferRegionARB;
+#define wglDeleteBufferRegionARB glad_wglDeleteBufferRegionARB
+typedef BOOL (APIENTRYP PFNWGLSAVEBUFFERREGIONARBPROC)(HANDLE, int, int, int, int);
+GLAPI PFNWGLSAVEBUFFERREGIONARBPROC glad_wglSaveBufferRegionARB;
+#define wglSaveBufferRegionARB glad_wglSaveBufferRegionARB
+typedef BOOL (APIENTRYP PFNWGLRESTOREBUFFERREGIONARBPROC)(HANDLE, int, int, int, int, int, int);
+GLAPI PFNWGLRESTOREBUFFERREGIONARBPROC glad_wglRestoreBufferRegionARB;
+#define wglRestoreBufferRegionARB glad_wglRestoreBufferRegionARB
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
--- a/deps/glad/src/glad.c
+++ b/deps/glad/src/glad.c
--- a/deps/glad/src/glad_glx.c
+++ b/deps/glad/src/glad_glx.c
@@ -0,0 +1,693 @@
+#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 = LoadLibraryA("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) {
+    if(open_gl()) {
+        gladLoadGLXLoader((GLADloadproc)get_proc, dpy, screen);
+        close_gl();
+        return 1;
+    }
+
+    return 0;
+}
+
+static Display *GLADGLXDisplay = 0;
+static int GLADGLXscreen = 0;
+
+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_NV_multisample_coverage;
+int GLAD_GLX_SGIS_shared_multisample;
+int GLAD_GLX_SGIX_pbuffer;
+int GLAD_GLX_NV_swap_group;
+int GLAD_GLX_ARB_fbconfig_float;
+int GLAD_GLX_SGIX_hyperpipe;
+int GLAD_GLX_ARB_robustness_share_group_isolation;
+int GLAD_GLX_INTEL_swap_event;
+int GLAD_GLX_SGIX_video_resize;
+int GLAD_GLX_EXT_create_context_es2_profile;
+int GLAD_GLX_ARB_robustness_application_isolation;
+int GLAD_GLX_NV_copy_image;
+int GLAD_GLX_OML_sync_control;
+int GLAD_GLX_EXT_framebuffer_sRGB;
+int GLAD_GLX_SGI_make_current_read;
+int GLAD_GLX_SGI_swap_control;
+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_MESA_agp_offset;
+int GLAD_GLX_SGIS_multisample;
+int GLAD_GLX_MESA_set_3dfx_mode;
+int GLAD_GLX_EXT_texture_from_pixmap;
+int GLAD_GLX_NV_video_capture;
+int GLAD_GLX_ARB_multisample;
+int GLAD_GLX_NV_delay_before_swap;
+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_ARB_create_context;
+int GLAD_GLX_EXT_create_context_es_profile;
+int GLAD_GLX_SGIX_fbconfig;
+int GLAD_GLX_MESA_pixmap_colormap;
+int GLAD_GLX_SGIX_visual_select_group;
+int GLAD_GLX_NV_video_output;
+int GLAD_GLX_SGIS_blended_overlay;
+int GLAD_GLX_SGIX_dmbuffer;
+int GLAD_GLX_ARB_create_context_robustness;
+int GLAD_GLX_SGIX_swap_barrier;
+int GLAD_GLX_EXT_swap_control_tear;
+int GLAD_GLX_MESA_release_buffers;
+int GLAD_GLX_EXT_visual_rating;
+int GLAD_GLX_MESA_copy_sub_buffer;
+int GLAD_GLX_SGI_cushion;
+int GLAD_GLX_NV_float_buffer;
+int GLAD_GLX_OML_swap_method;
+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_ARB_get_proc_address;
+int GLAD_GLX_ARB_vertex_buffer_object;
+PFNGLXGETCURRENTDISPLAYEXTPROC glad_glXGetCurrentDisplayEXT;
+PFNGLXQUERYCONTEXTINFOEXTPROC glad_glXQueryContextInfoEXT;
+PFNGLXGETCONTEXTIDEXTPROC glad_glXGetContextIDEXT;
+PFNGLXIMPORTCONTEXTEXTPROC glad_glXImportContextEXT;
+PFNGLXFREECONTEXTEXTPROC glad_glXFreeContextEXT;
+PFNGLXCREATEGLXPBUFFERSGIXPROC glad_glXCreateGLXPbufferSGIX;
+PFNGLXDESTROYGLXPBUFFERSGIXPROC glad_glXDestroyGLXPbufferSGIX;
+PFNGLXQUERYGLXPBUFFERSGIXPROC glad_glXQueryGLXPbufferSGIX;
+PFNGLXSELECTEVENTSGIXPROC glad_glXSelectEventSGIX;
+PFNGLXGETSELECTEDEVENTSGIXPROC glad_glXGetSelectedEventSGIX;
+PFNGLXJOINSWAPGROUPNVPROC glad_glXJoinSwapGroupNV;
+PFNGLXBINDSWAPBARRIERNVPROC glad_glXBindSwapBarrierNV;
+PFNGLXQUERYSWAPGROUPNVPROC glad_glXQuerySwapGroupNV;
+PFNGLXQUERYMAXSWAPGROUPSNVPROC glad_glXQueryMaxSwapGroupsNV;
+PFNGLXQUERYFRAMECOUNTNVPROC glad_glXQueryFrameCountNV;
+PFNGLXRESETFRAMECOUNTNVPROC glad_glXResetFrameCountNV;
+PFNGLXQUERYHYPERPIPENETWORKSGIXPROC glad_glXQueryHyperpipeNetworkSGIX;
+PFNGLXHYPERPIPECONFIGSGIXPROC glad_glXHyperpipeConfigSGIX;
+PFNGLXQUERYHYPERPIPECONFIGSGIXPROC glad_glXQueryHyperpipeConfigSGIX;
+PFNGLXDESTROYHYPERPIPECONFIGSGIXPROC glad_glXDestroyHyperpipeConfigSGIX;
+PFNGLXBINDHYPERPIPESGIXPROC glad_glXBindHyperpipeSGIX;
+PFNGLXQUERYHYPERPIPEBESTATTRIBSGIXPROC glad_glXQueryHyperpipeBestAttribSGIX;
+PFNGLXHYPERPIPEATTRIBSGIXPROC glad_glXHyperpipeAttribSGIX;
+PFNGLXQUERYHYPERPIPEATTRIBSGIXPROC glad_glXQueryHyperpipeAttribSGIX;
+PFNGLXBINDCHANNELTOWINDOWSGIXPROC glad_glXBindChannelToWindowSGIX;
+PFNGLXCHANNELRECTSGIXPROC glad_glXChannelRectSGIX;
+PFNGLXQUERYCHANNELRECTSGIXPROC glad_glXQueryChannelRectSGIX;
+PFNGLXQUERYCHANNELDELTASSGIXPROC glad_glXQueryChannelDeltasSGIX;
+PFNGLXCHANNELRECTSYNCSGIXPROC glad_glXChannelRectSyncSGIX;
+PFNGLXCOPYIMAGESUBDATANVPROC glad_glXCopyImageSubDataNV;
+PFNGLXGETSYNCVALUESOMLPROC glad_glXGetSyncValuesOML;
+PFNGLXGETMSCRATEOMLPROC glad_glXGetMscRateOML;
+PFNGLXSWAPBUFFERSMSCOMLPROC glad_glXSwapBuffersMscOML;
+PFNGLXWAITFORMSCOMLPROC glad_glXWaitForMscOML;
+PFNGLXWAITFORSBCOMLPROC glad_glXWaitForSbcOML;
+PFNGLXMAKECURRENTREADSGIPROC glad_glXMakeCurrentReadSGI;
+PFNGLXGETCURRENTREADDRAWABLESGIPROC glad_glXGetCurrentReadDrawableSGI;
+PFNGLXSWAPINTERVALSGIPROC glad_glXSwapIntervalSGI;
+PFNGLXGETVIDEOSYNCSGIPROC glad_glXGetVideoSyncSGI;
+PFNGLXWAITVIDEOSYNCSGIPROC glad_glXWaitVideoSyncSGI;
+PFNGLXGETAGPOFFSETMESAPROC glad_glXGetAGPOffsetMESA;
+PFNGLXSET3DFXMODEMESAPROC glad_glXSet3DfxModeMESA;
+PFNGLXBINDTEXIMAGEEXTPROC glad_glXBindTexImageEXT;
+PFNGLXRELEASETEXIMAGEEXTPROC glad_glXReleaseTexImageEXT;
+PFNGLXBINDVIDEOCAPTUREDEVICENVPROC glad_glXBindVideoCaptureDeviceNV;
+PFNGLXENUMERATEVIDEOCAPTUREDEVICESNVPROC glad_glXEnumerateVideoCaptureDevicesNV;
+PFNGLXLOCKVIDEOCAPTUREDEVICENVPROC glad_glXLockVideoCaptureDeviceNV;
+PFNGLXQUERYVIDEOCAPTUREDEVICENVPROC glad_glXQueryVideoCaptureDeviceNV;
+PFNGLXRELEASEVIDEOCAPTUREDEVICENVPROC glad_glXReleaseVideoCaptureDeviceNV;
+PFNGLXDELAYBEFORESWAPNVPROC glad_glXDelayBeforeSwapNV;
+PFNGLXJOINSWAPGROUPSGIXPROC glad_glXJoinSwapGroupSGIX;
+PFNGLXSWAPINTERVALEXTPROC glad_glXSwapIntervalEXT;
+#ifdef _VL_H_
+PFNGLXCREATEGLXVIDEOSOURCESGIXPROC glad_glXCreateGLXVideoSourceSGIX;
+PFNGLXDESTROYGLXVIDEOSOURCESGIXPROC glad_glXDestroyGLXVideoSourceSGIX;
+#endif
+PFNGLXQUERYCURRENTRENDERERINTEGERMESAPROC glad_glXQueryCurrentRendererIntegerMESA;
+PFNGLXQUERYCURRENTRENDERERSTRINGMESAPROC glad_glXQueryCurrentRendererStringMESA;
+PFNGLXQUERYRENDERERINTEGERMESAPROC glad_glXQueryRendererIntegerMESA;
+PFNGLXQUERYRENDERERSTRINGMESAPROC glad_glXQueryRendererStringMESA;
+PFNGLXCREATECONTEXTATTRIBSARBPROC glad_glXCreateContextAttribsARB;
+PFNGLXGETFBCONFIGATTRIBSGIXPROC glad_glXGetFBConfigAttribSGIX;
+PFNGLXCHOOSEFBCONFIGSGIXPROC glad_glXChooseFBConfigSGIX;
+PFNGLXCREATEGLXPIXMAPWITHCONFIGSGIXPROC glad_glXCreateGLXPixmapWithConfigSGIX;
+PFNGLXCREATECONTEXTWITHCONFIGSGIXPROC glad_glXCreateContextWithConfigSGIX;
+PFNGLXGETVISUALFROMFBCONFIGSGIXPROC glad_glXGetVisualFromFBConfigSGIX;
+PFNGLXGETFBCONFIGFROMVISUALSGIXPROC glad_glXGetFBConfigFromVisualSGIX;
+PFNGLXCREATEGLXPIXMAPMESAPROC glad_glXCreateGLXPixmapMESA;
+PFNGLXGETVIDEODEVICENVPROC glad_glXGetVideoDeviceNV;
+PFNGLXRELEASEVIDEODEVICENVPROC glad_glXReleaseVideoDeviceNV;
+PFNGLXBINDVIDEOIMAGENVPROC glad_glXBindVideoImageNV;
+PFNGLXRELEASEVIDEOIMAGENVPROC glad_glXReleaseVideoImageNV;
+PFNGLXSENDPBUFFERTOVIDEONVPROC glad_glXSendPbufferToVideoNV;
+PFNGLXGETVIDEOINFONVPROC glad_glXGetVideoInfoNV;
+#ifdef _DM_BUFFER_H_
+PFNGLXASSOCIATEDMPBUFFERSGIXPROC glad_glXAssociateDMPbufferSGIX;
+#endif
+PFNGLXBINDSWAPBARRIERSGIXPROC glad_glXBindSwapBarrierSGIX;
+PFNGLXQUERYMAXSWAPBARRIERSSGIXPROC glad_glXQueryMaxSwapBarriersSGIX;
+PFNGLXRELEASEBUFFERSMESAPROC glad_glXReleaseBuffersMESA;
+PFNGLXCOPYSUBBUFFERMESAPROC glad_glXCopySubBufferMESA;
+PFNGLXCUSHIONSGIPROC glad_glXCushionSGI;
+PFNGLXENUMERATEVIDEODEVICESNVPROC glad_glXEnumerateVideoDevicesNV;
+PFNGLXBINDVIDEODEVICENVPROC glad_glXBindVideoDeviceNV;
+PFNGLXGETTRANSPARENTINDEXSUNPROC glad_glXGetTransparentIndexSUN;
+PFNGLXGETPROCADDRESSARBPROC glad_glXGetProcAddressARB;
+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_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_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_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_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_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_NV_copy_image(GLADloadproc load) {
+	if(!GLAD_GLX_NV_copy_image) return;
+	glad_glXCopyImageSubDataNV = (PFNGLXCOPYIMAGESUBDATANVPROC)load("glXCopyImageSubDataNV");
+}
+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_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_MESA_agp_offset(GLADloadproc load) {
+	if(!GLAD_GLX_MESA_agp_offset) return;
+	glad_glXGetAGPOffsetMESA = (PFNGLXGETAGPOFFSETMESAPROC)load("glXGetAGPOffsetMESA");
+}
+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_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_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_delay_before_swap(GLADloadproc load) {
+	if(!GLAD_GLX_NV_delay_before_swap) return;
+	glad_glXDelayBeforeSwapNV = (PFNGLXDELAYBEFORESWAPNVPROC)load("glXDelayBeforeSwapNV");
+}
+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_EXT_swap_control(GLADloadproc load) {
+	if(!GLAD_GLX_EXT_swap_control) return;
+	glad_glXSwapIntervalEXT = (PFNGLXSWAPINTERVALEXTPROC)load("glXSwapIntervalEXT");
+}
+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_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_ARB_create_context(GLADloadproc load) {
+	if(!GLAD_GLX_ARB_create_context) return;
+	glad_glXCreateContextAttribsARB = (PFNGLXCREATECONTEXTATTRIBSARBPROC)load("glXCreateContextAttribsARB");
+}
+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_MESA_pixmap_colormap(GLADloadproc load) {
+	if(!GLAD_GLX_MESA_pixmap_colormap) return;
+	glad_glXCreateGLXPixmapMESA = (PFNGLXCREATEGLXPIXMAPMESAPROC)load("glXCreateGLXPixmapMESA");
+}
+static void load_GLX_NV_video_output(GLADloadproc load) {
+	if(!GLAD_GLX_NV_video_output) 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_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_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_MESA_release_buffers(GLADloadproc load) {
+	if(!GLAD_GLX_MESA_release_buffers) return;
+	glad_glXReleaseBuffersMESA = (PFNGLXRELEASEBUFFERSMESAPROC)load("glXReleaseBuffersMESA");
+}
+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_SGI_cushion(GLADloadproc load) {
+	if(!GLAD_GLX_SGI_cushion) return;
+	glad_glXCushionSGI = (PFNGLXCUSHIONSGIPROC)load("glXCushionSGI");
+}
+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_SUN_get_transparent_index(GLADloadproc load) {
+	if(!GLAD_GLX_SUN_get_transparent_index) return;
+	glad_glXGetTransparentIndexSUN = (PFNGLXGETTRANSPARENTINDEXSUNPROC)load("glXGetTransparentIndexSUN");
+}
+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 find_extensionsGLX(void) {
+	GLAD_GLX_ARB_framebuffer_sRGB = has_ext("GLX_ARB_framebuffer_sRGB");
+	GLAD_GLX_EXT_import_context = has_ext("GLX_EXT_import_context");
+	GLAD_GLX_NV_multisample_coverage = has_ext("GLX_NV_multisample_coverage");
+	GLAD_GLX_SGIS_shared_multisample = has_ext("GLX_SGIS_shared_multisample");
+	GLAD_GLX_SGIX_pbuffer = has_ext("GLX_SGIX_pbuffer");
+	GLAD_GLX_NV_swap_group = has_ext("GLX_NV_swap_group");
+	GLAD_GLX_ARB_fbconfig_float = has_ext("GLX_ARB_fbconfig_float");
+	GLAD_GLX_SGIX_hyperpipe = has_ext("GLX_SGIX_hyperpipe");
+	GLAD_GLX_ARB_robustness_share_group_isolation = has_ext("GLX_ARB_robustness_share_group_isolation");
+	GLAD_GLX_INTEL_swap_event = has_ext("GLX_INTEL_swap_event");
+	GLAD_GLX_SGIX_video_resize = has_ext("GLX_SGIX_video_resize");
+	GLAD_GLX_EXT_create_context_es2_profile = has_ext("GLX_EXT_create_context_es2_profile");
+	GLAD_GLX_ARB_robustness_application_isolation = has_ext("GLX_ARB_robustness_application_isolation");
+	GLAD_GLX_NV_copy_image = has_ext("GLX_NV_copy_image");
+	GLAD_GLX_OML_sync_control = has_ext("GLX_OML_sync_control");
+	GLAD_GLX_EXT_framebuffer_sRGB = has_ext("GLX_EXT_framebuffer_sRGB");
+	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_EXT_fbconfig_packed_float = has_ext("GLX_EXT_fbconfig_packed_float");
+	GLAD_GLX_EXT_buffer_age = has_ext("GLX_EXT_buffer_age");
+	GLAD_GLX_3DFX_multisample = has_ext("GLX_3DFX_multisample");
+	GLAD_GLX_EXT_visual_info = has_ext("GLX_EXT_visual_info");
+	GLAD_GLX_SGI_video_sync = has_ext("GLX_SGI_video_sync");
+	GLAD_GLX_MESA_agp_offset = has_ext("GLX_MESA_agp_offset");
+	GLAD_GLX_SGIS_multisample = has_ext("GLX_SGIS_multisample");
+	GLAD_GLX_MESA_set_3dfx_mode = has_ext("GLX_MESA_set_3dfx_mode");
+	GLAD_GLX_EXT_texture_from_pixmap = has_ext("GLX_EXT_texture_from_pixmap");
+	GLAD_GLX_NV_video_capture = has_ext("GLX_NV_video_capture");
+	GLAD_GLX_ARB_multisample = has_ext("GLX_ARB_multisample");
+	GLAD_GLX_NV_delay_before_swap = has_ext("GLX_NV_delay_before_swap");
+	GLAD_GLX_SGIX_swap_group = has_ext("GLX_SGIX_swap_group");
+	GLAD_GLX_EXT_swap_control = has_ext("GLX_EXT_swap_control");
+	GLAD_GLX_SGIX_video_source = has_ext("GLX_SGIX_video_source");
+	GLAD_GLX_MESA_query_renderer = has_ext("GLX_MESA_query_renderer");
+	GLAD_GLX_ARB_create_context = has_ext("GLX_ARB_create_context");
+	GLAD_GLX_EXT_create_context_es_profile = has_ext("GLX_EXT_create_context_es_profile");
+	GLAD_GLX_SGIX_fbconfig = has_ext("GLX_SGIX_fbconfig");
+	GLAD_GLX_MESA_pixmap_colormap = has_ext("GLX_MESA_pixmap_colormap");
+	GLAD_GLX_SGIX_visual_select_group = has_ext("GLX_SGIX_visual_select_group");
+	GLAD_GLX_NV_video_output = has_ext("GLX_NV_video_output");
+	GLAD_GLX_SGIS_blended_overlay = has_ext("GLX_SGIS_blended_overlay");
+	GLAD_GLX_SGIX_dmbuffer = has_ext("GLX_SGIX_dmbuffer");
+	GLAD_GLX_ARB_create_context_robustness = has_ext("GLX_ARB_create_context_robustness");
+	GLAD_GLX_SGIX_swap_barrier = has_ext("GLX_SGIX_swap_barrier");
+	GLAD_GLX_EXT_swap_control_tear = has_ext("GLX_EXT_swap_control_tear");
+	GLAD_GLX_MESA_release_buffers = has_ext("GLX_MESA_release_buffers");
+	GLAD_GLX_EXT_visual_rating = has_ext("GLX_EXT_visual_rating");
+	GLAD_GLX_MESA_copy_sub_buffer = has_ext("GLX_MESA_copy_sub_buffer");
+	GLAD_GLX_SGI_cushion = has_ext("GLX_SGI_cushion");
+	GLAD_GLX_NV_float_buffer = has_ext("GLX_NV_float_buffer");
+	GLAD_GLX_OML_swap_method = has_ext("GLX_OML_swap_method");
+	GLAD_GLX_NV_present_video = has_ext("GLX_NV_present_video");
+	GLAD_GLX_SUN_get_transparent_index = has_ext("GLX_SUN_get_transparent_index");
+	GLAD_GLX_AMD_gpu_association = has_ext("GLX_AMD_gpu_association");
+	GLAD_GLX_ARB_create_context_profile = has_ext("GLX_ARB_create_context_profile");
+	GLAD_GLX_ARB_get_proc_address = has_ext("GLX_ARB_get_proc_address");
+	GLAD_GLX_ARB_vertex_buffer_object = has_ext("GLX_ARB_vertex_buffer_object");
+}
+
+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;
+}
+
+void gladLoadGLXLoader(GLADloadproc load, Display *dpy, int screen) {
+	glXQueryVersion = (PFNGLXQUERYVERSIONPROC)load("glXQueryVersion");
+	if(glXQueryVersion == NULL) return;
+	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);
+
+	find_extensionsGLX();
+	load_GLX_EXT_import_context(load);
+	load_GLX_SGIX_pbuffer(load);
+	load_GLX_NV_swap_group(load);
+	load_GLX_SGIX_hyperpipe(load);
+	load_GLX_SGIX_video_resize(load);
+	load_GLX_NV_copy_image(load);
+	load_GLX_OML_sync_control(load);
+	load_GLX_SGI_make_current_read(load);
+	load_GLX_SGI_swap_control(load);
+	load_GLX_SGI_video_sync(load);
+	load_GLX_MESA_agp_offset(load);
+	load_GLX_MESA_set_3dfx_mode(load);
+	load_GLX_EXT_texture_from_pixmap(load);
+	load_GLX_NV_video_capture(load);
+	load_GLX_NV_delay_before_swap(load);
+	load_GLX_SGIX_swap_group(load);
+	load_GLX_EXT_swap_control(load);
+	load_GLX_SGIX_video_source(load);
+	load_GLX_MESA_query_renderer(load);
+	load_GLX_ARB_create_context(load);
+	load_GLX_SGIX_fbconfig(load);
+	load_GLX_MESA_pixmap_colormap(load);
+	load_GLX_NV_video_output(load);
+	load_GLX_SGIX_dmbuffer(load);
+	load_GLX_SGIX_swap_barrier(load);
+	load_GLX_MESA_release_buffers(load);
+	load_GLX_MESA_copy_sub_buffer(load);
+	load_GLX_SGI_cushion(load);
+	load_GLX_NV_present_video(load);
+	load_GLX_SUN_get_transparent_index(load);
+	load_GLX_ARB_get_proc_address(load);
+
+	return;
+}
+
--- a/deps/glad/src/glad_wgl.c
+++ b/deps/glad/src/glad_wgl.c
@@ -0,0 +1,632 @@
+#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 = LoadLibraryA("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) {
+    if(open_gl()) {
+        gladLoadWGLLoader((GLADloadproc)get_proc, hdc);
+        close_gl();
+        return 1;
+    }
+
+    return 0;
+}
+
+static HDC GLADWGLhdc = INVALID_HANDLE_VALUE;
+
+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_NV_float_buffer;
+int GLAD_WGL_NV_delay_before_swap;
+int GLAD_WGL_OML_sync_control;
+int GLAD_WGL_ARB_pixel_format_float;
+int GLAD_WGL_ARB_create_context;
+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_video_capture;
+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_render_texture;
+int GLAD_WGL_EXT_depth_float;
+int GLAD_WGL_EXT_swap_control_tear;
+int GLAD_WGL_ARB_pixel_format;
+int GLAD_WGL_ARB_multisample;
+int GLAD_WGL_I3D_genlock;
+int GLAD_WGL_NV_DX_interop;
+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_create_context_robustness;
+int GLAD_WGL_ARB_make_current_read;
+int GLAD_WGL_EXT_multisample;
+int GLAD_WGL_EXT_extensions_string;
+int GLAD_WGL_NV_render_depth_texture;
+int GLAD_WGL_ATI_pixel_format_float;
+int GLAD_WGL_ARB_create_context_profile;
+int GLAD_WGL_EXT_swap_control;
+int GLAD_WGL_I3D_digital_video_control;
+int GLAD_WGL_ARB_pbuffer;
+int GLAD_WGL_NV_vertex_array_range;
+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;
+PFNWGLCREATEIMAGEBUFFERI3DPROC glad_wglCreateImageBufferI3D;
+PFNWGLDESTROYIMAGEBUFFERI3DPROC glad_wglDestroyImageBufferI3D;
+PFNWGLASSOCIATEIMAGEBUFFEREVENTSI3DPROC glad_wglAssociateImageBufferEventsI3D;
+PFNWGLRELEASEIMAGEBUFFEREVENTSI3DPROC glad_wglReleaseImageBufferEventsI3D;
+PFNWGLGETFRAMEUSAGEI3DPROC glad_wglGetFrameUsageI3D;
+PFNWGLBEGINFRAMETRACKINGI3DPROC glad_wglBeginFrameTrackingI3D;
+PFNWGLENDFRAMETRACKINGI3DPROC glad_wglEndFrameTrackingI3D;
+PFNWGLQUERYFRAMETRACKINGI3DPROC glad_wglQueryFrameTrackingI3D;
+PFNWGLDELAYBEFORESWAPNVPROC glad_wglDelayBeforeSwapNV;
+PFNWGLGETSYNCVALUESOMLPROC glad_wglGetSyncValuesOML;
+PFNWGLGETMSCRATEOMLPROC glad_wglGetMscRateOML;
+PFNWGLSWAPBUFFERSMSCOMLPROC glad_wglSwapBuffersMscOML;
+PFNWGLSWAPLAYERBUFFERSMSCOMLPROC glad_wglSwapLayerBuffersMscOML;
+PFNWGLWAITFORMSCOMLPROC glad_wglWaitForMscOML;
+PFNWGLWAITFORSBCOMLPROC glad_wglWaitForSbcOML;
+PFNWGLCREATECONTEXTATTRIBSARBPROC glad_wglCreateContextAttribsARB;
+PFNWGLJOINSWAPGROUPNVPROC glad_wglJoinSwapGroupNV;
+PFNWGLBINDSWAPBARRIERNVPROC glad_wglBindSwapBarrierNV;
+PFNWGLQUERYSWAPGROUPNVPROC glad_wglQuerySwapGroupNV;
+PFNWGLQUERYMAXSWAPGROUPSNVPROC glad_wglQueryMaxSwapGroupsNV;
+PFNWGLQUERYFRAMECOUNTNVPROC glad_wglQueryFrameCountNV;
+PFNWGLRESETFRAMECOUNTNVPROC glad_wglResetFrameCountNV;
+PFNWGLENUMGPUSNVPROC glad_wglEnumGpusNV;
+PFNWGLENUMGPUDEVICESNVPROC glad_wglEnumGpuDevicesNV;
+PFNWGLCREATEAFFINITYDCNVPROC glad_wglCreateAffinityDCNV;
+PFNWGLENUMGPUSFROMAFFINITYDCNVPROC glad_wglEnumGpusFromAffinityDCNV;
+PFNWGLDELETEDCNVPROC glad_wglDeleteDCNV;
+PFNWGLGETPIXELFORMATATTRIBIVEXTPROC glad_wglGetPixelFormatAttribivEXT;
+PFNWGLGETPIXELFORMATATTRIBFVEXTPROC glad_wglGetPixelFormatAttribfvEXT;
+PFNWGLCHOOSEPIXELFORMATEXTPROC glad_wglChoosePixelFormatEXT;
+PFNWGLGETEXTENSIONSSTRINGARBPROC glad_wglGetExtensionsStringARB;
+PFNWGLBINDVIDEOCAPTUREDEVICENVPROC glad_wglBindVideoCaptureDeviceNV;
+PFNWGLENUMERATEVIDEOCAPTUREDEVICESNVPROC glad_wglEnumerateVideoCaptureDevicesNV;
+PFNWGLLOCKVIDEOCAPTUREDEVICENVPROC glad_wglLockVideoCaptureDeviceNV;
+PFNWGLQUERYVIDEOCAPTUREDEVICENVPROC glad_wglQueryVideoCaptureDeviceNV;
+PFNWGLRELEASEVIDEOCAPTUREDEVICENVPROC glad_wglReleaseVideoCaptureDeviceNV;
+PFNWGLBINDTEXIMAGEARBPROC glad_wglBindTexImageARB;
+PFNWGLRELEASETEXIMAGEARBPROC glad_wglReleaseTexImageARB;
+PFNWGLSETPBUFFERATTRIBARBPROC glad_wglSetPbufferAttribARB;
+PFNWGLGETPIXELFORMATATTRIBIVARBPROC glad_wglGetPixelFormatAttribivARB;
+PFNWGLGETPIXELFORMATATTRIBFVARBPROC glad_wglGetPixelFormatAttribfvARB;
+PFNWGLCHOOSEPIXELFORMATARBPROC glad_wglChoosePixelFormatARB;
+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;
+PFNWGLDXSETRESOURCESHAREHANDLENVPROC glad_wglDXSetResourceShareHandleNV;
+PFNWGLDXOPENDEVICENVPROC glad_wglDXOpenDeviceNV;
+PFNWGLDXCLOSEDEVICENVPROC glad_wglDXCloseDeviceNV;
+PFNWGLDXREGISTEROBJECTNVPROC glad_wglDXRegisterObjectNV;
+PFNWGLDXUNREGISTEROBJECTNVPROC glad_wglDXUnregisterObjectNV;
+PFNWGLDXOBJECTACCESSNVPROC glad_wglDXObjectAccessNV;
+PFNWGLDXLOCKOBJECTSNVPROC glad_wglDXLockObjectsNV;
+PFNWGLDXUNLOCKOBJECTSNVPROC glad_wglDXUnlockObjectsNV;
+PFNWGLSETSTEREOEMITTERSTATE3DLPROC glad_wglSetStereoEmitterState3DL;
+PFNWGLCREATEPBUFFEREXTPROC glad_wglCreatePbufferEXT;
+PFNWGLGETPBUFFERDCEXTPROC glad_wglGetPbufferDCEXT;
+PFNWGLRELEASEPBUFFERDCEXTPROC glad_wglReleasePbufferDCEXT;
+PFNWGLDESTROYPBUFFEREXTPROC glad_wglDestroyPbufferEXT;
+PFNWGLQUERYPBUFFEREXTPROC glad_wglQueryPbufferEXT;
+PFNWGLCREATEDISPLAYCOLORTABLEEXTPROC glad_wglCreateDisplayColorTableEXT;
+PFNWGLLOADDISPLAYCOLORTABLEEXTPROC glad_wglLoadDisplayColorTableEXT;
+PFNWGLBINDDISPLAYCOLORTABLEEXTPROC glad_wglBindDisplayColorTableEXT;
+PFNWGLDESTROYDISPLAYCOLORTABLEEXTPROC glad_wglDestroyDisplayColorTableEXT;
+PFNWGLGETVIDEODEVICENVPROC glad_wglGetVideoDeviceNV;
+PFNWGLRELEASEVIDEODEVICENVPROC glad_wglReleaseVideoDeviceNV;
+PFNWGLBINDVIDEOIMAGENVPROC glad_wglBindVideoImageNV;
+PFNWGLRELEASEVIDEOIMAGENVPROC glad_wglReleaseVideoImageNV;
+PFNWGLSENDPBUFFERTOVIDEONVPROC glad_wglSendPbufferToVideoNV;
+PFNWGLGETVIDEOINFONVPROC glad_wglGetVideoInfoNV;
+PFNWGLGETGAMMATABLEPARAMETERSI3DPROC glad_wglGetGammaTableParametersI3D;
+PFNWGLSETGAMMATABLEPARAMETERSI3DPROC glad_wglSetGammaTableParametersI3D;
+PFNWGLGETGAMMATABLEI3DPROC glad_wglGetGammaTableI3D;
+PFNWGLSETGAMMATABLEI3DPROC glad_wglSetGammaTableI3D;
+PFNWGLCOPYIMAGESUBDATANVPROC glad_wglCopyImageSubDataNV;
+PFNWGLENUMERATEVIDEODEVICESNVPROC glad_wglEnumerateVideoDevicesNV;
+PFNWGLBINDVIDEODEVICENVPROC glad_wglBindVideoDeviceNV;
+PFNWGLQUERYCURRENTCONTEXTNVPROC glad_wglQueryCurrentContextNV;
+PFNWGLMAKECONTEXTCURRENTARBPROC glad_wglMakeContextCurrentARB;
+PFNWGLGETCURRENTREADDCARBPROC glad_wglGetCurrentReadDCARB;
+PFNWGLGETEXTENSIONSSTRINGEXTPROC glad_wglGetExtensionsStringEXT;
+PFNWGLSWAPINTERVALEXTPROC glad_wglSwapIntervalEXT;
+PFNWGLGETSWAPINTERVALEXTPROC glad_wglGetSwapIntervalEXT;
+PFNWGLGETDIGITALVIDEOPARAMETERSI3DPROC glad_wglGetDigitalVideoParametersI3D;
+PFNWGLSETDIGITALVIDEOPARAMETERSI3DPROC glad_wglSetDigitalVideoParametersI3D;
+PFNWGLCREATEPBUFFERARBPROC glad_wglCreatePbufferARB;
+PFNWGLGETPBUFFERDCARBPROC glad_wglGetPbufferDCARB;
+PFNWGLRELEASEPBUFFERDCARBPROC glad_wglReleasePbufferDCARB;
+PFNWGLDESTROYPBUFFERARBPROC glad_wglDestroyPbufferARB;
+PFNWGLQUERYPBUFFERARBPROC glad_wglQueryPbufferARB;
+PFNWGLALLOCATEMEMORYNVPROC glad_wglAllocateMemoryNV;
+PFNWGLFREEMEMORYNVPROC glad_wglFreeMemoryNV;
+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;
+PFNWGLMAKECONTEXTCURRENTEXTPROC glad_wglMakeContextCurrentEXT;
+PFNWGLGETCURRENTREADDCEXTPROC glad_wglGetCurrentReadDCEXT;
+PFNWGLENABLEFRAMELOCKI3DPROC glad_wglEnableFrameLockI3D;
+PFNWGLDISABLEFRAMELOCKI3DPROC glad_wglDisableFrameLockI3D;
+PFNWGLISENABLEDFRAMELOCKI3DPROC glad_wglIsEnabledFrameLockI3D;
+PFNWGLQUERYFRAMELOCKMASTERI3DPROC glad_wglQueryFrameLockMasterI3D;
+PFNWGLCREATEBUFFERREGIONARBPROC glad_wglCreateBufferRegionARB;
+PFNWGLDELETEBUFFERREGIONARBPROC glad_wglDeleteBufferRegionARB;
+PFNWGLSAVEBUFFERREGIONARBPROC glad_wglSaveBufferRegionARB;
+PFNWGLRESTOREBUFFERREGIONARBPROC glad_wglRestoreBufferRegionARB;
+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_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_delay_before_swap(GLADloadproc load) {
+	if(!GLAD_WGL_NV_delay_before_swap) return;
+	glad_wglDelayBeforeSwapNV = (PFNWGLDELAYBEFORESWAPNVPROC)load("wglDelayBeforeSwapNV");
+}
+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 void load_WGL_ARB_create_context(GLADloadproc load) {
+	if(!GLAD_WGL_ARB_create_context) return;
+	glad_wglCreateContextAttribsARB = (PFNWGLCREATECONTEXTATTRIBSARBPROC)load("wglCreateContextAttribsARB");
+}
+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_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_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_ARB_extensions_string(GLADloadproc load) {
+	if(!GLAD_WGL_ARB_extensions_string) return;
+	glad_wglGetExtensionsStringARB = (PFNWGLGETEXTENSIONSSTRINGARBPROC)load("wglGetExtensionsStringARB");
+}
+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_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_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_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_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_3DL_stereo_control(GLADloadproc load) {
+	if(!GLAD_WGL_3DL_stereo_control) return;
+	glad_wglSetStereoEmitterState3DL = (PFNWGLSETSTEREOEMITTERSTATE3DLPROC)load("wglSetStereoEmitterState3DL");
+}
+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_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_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_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_NV_copy_image(GLADloadproc load) {
+	if(!GLAD_WGL_NV_copy_image) return;
+	glad_wglCopyImageSubDataNV = (PFNWGLCOPYIMAGESUBDATANVPROC)load("wglCopyImageSubDataNV");
+}
+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_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_EXT_extensions_string(GLADloadproc load) {
+	if(!GLAD_WGL_EXT_extensions_string) return;
+	glad_wglGetExtensionsStringEXT = (PFNWGLGETEXTENSIONSSTRINGEXTPROC)load("wglGetExtensionsStringEXT");
+}
+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_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_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_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_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_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_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 find_extensionsWGL(void) {
+	GLAD_WGL_NV_multisample_coverage = has_ext("WGL_NV_multisample_coverage");
+	GLAD_WGL_I3D_image_buffer = has_ext("WGL_I3D_image_buffer");
+	GLAD_WGL_I3D_swap_frame_usage = has_ext("WGL_I3D_swap_frame_usage");
+	GLAD_WGL_NV_DX_interop2 = has_ext("WGL_NV_DX_interop2");
+	GLAD_WGL_NV_float_buffer = has_ext("WGL_NV_float_buffer");
+	GLAD_WGL_NV_delay_before_swap = has_ext("WGL_NV_delay_before_swap");
+	GLAD_WGL_OML_sync_control = has_ext("WGL_OML_sync_control");
+	GLAD_WGL_ARB_pixel_format_float = has_ext("WGL_ARB_pixel_format_float");
+	GLAD_WGL_ARB_create_context = has_ext("WGL_ARB_create_context");
+	GLAD_WGL_NV_swap_group = has_ext("WGL_NV_swap_group");
+	GLAD_WGL_NV_gpu_affinity = has_ext("WGL_NV_gpu_affinity");
+	GLAD_WGL_EXT_pixel_format = has_ext("WGL_EXT_pixel_format");
+	GLAD_WGL_ARB_extensions_string = has_ext("WGL_ARB_extensions_string");
+	GLAD_WGL_NV_video_capture = has_ext("WGL_NV_video_capture");
+	GLAD_WGL_NV_render_texture_rectangle = has_ext("WGL_NV_render_texture_rectangle");
+	GLAD_WGL_EXT_create_context_es_profile = has_ext("WGL_EXT_create_context_es_profile");
+	GLAD_WGL_ARB_robustness_share_group_isolation = has_ext("WGL_ARB_robustness_share_group_isolation");
+	GLAD_WGL_ARB_render_texture = has_ext("WGL_ARB_render_texture");
+	GLAD_WGL_EXT_depth_float = has_ext("WGL_EXT_depth_float");
+	GLAD_WGL_EXT_swap_control_tear = has_ext("WGL_EXT_swap_control_tear");
+	GLAD_WGL_ARB_pixel_format = has_ext("WGL_ARB_pixel_format");
+	GLAD_WGL_ARB_multisample = has_ext("WGL_ARB_multisample");
+	GLAD_WGL_I3D_genlock = has_ext("WGL_I3D_genlock");
+	GLAD_WGL_NV_DX_interop = has_ext("WGL_NV_DX_interop");
+	GLAD_WGL_3DL_stereo_control = has_ext("WGL_3DL_stereo_control");
+	GLAD_WGL_EXT_pbuffer = has_ext("WGL_EXT_pbuffer");
+	GLAD_WGL_EXT_display_color_table = has_ext("WGL_EXT_display_color_table");
+	GLAD_WGL_NV_video_output = has_ext("WGL_NV_video_output");
+	GLAD_WGL_ARB_robustness_application_isolation = has_ext("WGL_ARB_robustness_application_isolation");
+	GLAD_WGL_3DFX_multisample = has_ext("WGL_3DFX_multisample");
+	GLAD_WGL_I3D_gamma = has_ext("WGL_I3D_gamma");
+	GLAD_WGL_ARB_framebuffer_sRGB = has_ext("WGL_ARB_framebuffer_sRGB");
+	GLAD_WGL_NV_copy_image = has_ext("WGL_NV_copy_image");
+	GLAD_WGL_EXT_framebuffer_sRGB = has_ext("WGL_EXT_framebuffer_sRGB");
+	GLAD_WGL_NV_present_video = has_ext("WGL_NV_present_video");
+	GLAD_WGL_EXT_create_context_es2_profile = has_ext("WGL_EXT_create_context_es2_profile");
+	GLAD_WGL_ARB_create_context_robustness = has_ext("WGL_ARB_create_context_robustness");
+	GLAD_WGL_ARB_make_current_read = has_ext("WGL_ARB_make_current_read");
+	GLAD_WGL_EXT_multisample = has_ext("WGL_EXT_multisample");
+	GLAD_WGL_EXT_extensions_string = has_ext("WGL_EXT_extensions_string");
+	GLAD_WGL_NV_render_depth_texture = has_ext("WGL_NV_render_depth_texture");
+	GLAD_WGL_ATI_pixel_format_float = has_ext("WGL_ATI_pixel_format_float");
+	GLAD_WGL_ARB_create_context_profile = has_ext("WGL_ARB_create_context_profile");
+	GLAD_WGL_EXT_swap_control = has_ext("WGL_EXT_swap_control");
+	GLAD_WGL_I3D_digital_video_control = has_ext("WGL_I3D_digital_video_control");
+	GLAD_WGL_ARB_pbuffer = has_ext("WGL_ARB_pbuffer");
+	GLAD_WGL_NV_vertex_array_range = has_ext("WGL_NV_vertex_array_range");
+	GLAD_WGL_AMD_gpu_association = has_ext("WGL_AMD_gpu_association");
+	GLAD_WGL_EXT_pixel_format_packed_float = has_ext("WGL_EXT_pixel_format_packed_float");
+	GLAD_WGL_EXT_make_current_read = has_ext("WGL_EXT_make_current_read");
+	GLAD_WGL_I3D_swap_frame_lock = has_ext("WGL_I3D_swap_frame_lock");
+	GLAD_WGL_ARB_buffer_region = has_ext("WGL_ARB_buffer_region");
+}
+
+static void find_coreWGL(HDC hdc) {
+	int major = 9;
+	int minor = 9;
+	GLADWGLhdc = hdc;
+}
+
+void gladLoadWGLLoader(GLADloadproc load, HDC hdc) {
+	wglGetExtensionsStringARB = (PFNWGLGETEXTENSIONSSTRINGARBPROC)load("wglGetExtensionsStringARB");
+	wglGetExtensionsStringEXT = (PFNWGLGETEXTENSIONSSTRINGEXTPROC)load("wglGetExtensionsStringEXT");
+	if(wglGetExtensionsStringARB == NULL && wglGetExtensionsStringEXT == NULL) return;
+	find_coreWGL(hdc);
+
+	find_extensionsWGL();
+	load_WGL_I3D_image_buffer(load);
+	load_WGL_I3D_swap_frame_usage(load);
+	load_WGL_NV_delay_before_swap(load);
+	load_WGL_OML_sync_control(load);
+	load_WGL_ARB_create_context(load);
+	load_WGL_NV_swap_group(load);
+	load_WGL_NV_gpu_affinity(load);
+	load_WGL_EXT_pixel_format(load);
+	load_WGL_ARB_extensions_string(load);
+	load_WGL_NV_video_capture(load);
+	load_WGL_ARB_render_texture(load);
+	load_WGL_ARB_pixel_format(load);
+	load_WGL_I3D_genlock(load);
+	load_WGL_NV_DX_interop(load);
+	load_WGL_3DL_stereo_control(load);
+	load_WGL_EXT_pbuffer(load);
+	load_WGL_EXT_display_color_table(load);
+	load_WGL_NV_video_output(load);
+	load_WGL_I3D_gamma(load);
+	load_WGL_NV_copy_image(load);
+	load_WGL_NV_present_video(load);
+	load_WGL_ARB_make_current_read(load);
+	load_WGL_EXT_extensions_string(load);
+	load_WGL_EXT_swap_control(load);
+	load_WGL_I3D_digital_video_control(load);
+	load_WGL_ARB_pbuffer(load);
+	load_WGL_NV_vertex_array_range(load);
+	load_WGL_AMD_gpu_association(load);
+	load_WGL_EXT_make_current_read(load);
+	load_WGL_I3D_swap_frame_lock(load);
+	load_WGL_ARB_buffer_region(load);
+
+	return;
+}
+
--- a/libobs-opengl/CMakeLists.txt
+++ b/libobs-opengl/CMakeLists.txt
@@ -8,8 +8,6 @@ include_directories(${OPENGL_INCLUDE_DIR})
 add_definitions(-DLIBOBS_EXPORTS)

 if(WIN32)
-	set(obs-opengl_PLATFORM_SOURCES
-		GL/wgl_obs.c)
 	set(libobs-opengl_PLATFORM_SOURCES
 		gl-windows.c)
 elseif(APPLE)
@@ -34,13 +32,8 @@ elseif(APPLE)
 else()
 	set(libobs-opengl_PLATFORM_SOURCES
 		gl-x11.c)
-	set(obs-opengl_PLATFORM_SOURCES
-		GL/glx_obs.c)
 endif()

-set(obs-opengl_SOURCES
-	GL/gl_obs.c)
-
 set(libobs-opengl_SOURCES
 	${libobs-opengl_PLATFORM_SOURCES}
 	gl-helpers.c
@@ -59,16 +52,6 @@ set(libobs-opengl_HEADERS
 	gl-shaderparser.h
 	gl-subsystem.h)

-add_library(obs-opengl STATIC
-	${obs-opengl_SOURCES}
-	${obs-opengl_PLATFORM_SOURCES})
-if(NOT WIN32)
-	set_property(TARGET obs-opengl APPEND_STRING
-		PROPERTY COMPILE_FLAGS " -fPIC")
-endif()
-target_link_libraries(obs-opengl
-	${OPENGL_gl_LIBRARY})
-
 add_library(libobs-opengl MODULE
 	${libobs-opengl_SOURCES}
 	${libobs-opengl_HEADERS})
@@ -78,7 +61,7 @@ set_target_properties(libobs-opengl
 		PREFIX "")
 target_link_libraries(libobs-opengl
 	libobs
-	obs-opengl
+	glad
 	${libobs-opengl_PLATFORM_DEPS})

 install_obs_core(libobs-opengl)
--- a/libobs-opengl/GL/gl_obs.c
+++ b/libobs-opengl/GL/gl_obs.c
--- a/libobs-opengl/GL/gl_obs.h
+++ b/libobs-opengl/GL/gl_obs.h
--- a/libobs-opengl/GL/glx_obs.c
+++ b/libobs-opengl/GL/glx_obs.c
@@ -1,470 +0,0 @@
-/* AUTOGENERATED BY glLoadGen, DO NOT EDIT */
-#include <stdlib.h>
-#include <string.h>
-#include <stddef.h>
-#include "glx_obs.h"
-
-#if defined(__APPLE__)
-#include <dlfcn.h>
-
-static void* AppleGLGetProcAddress (const char *name)
-{
-	static void* image = NULL;
-	
-	if (NULL == image)
-		image = dlopen("/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL", RTLD_LAZY);
-
-	return (image ? dlsym(image, name) : NULL);
-}
-#define IntGetProcAddress(name) AppleGLGetProcAddress(name)
-#endif /* __APPLE__ */
-
-#if defined(_WIN32)
-
-#ifdef _MSC_VER
-#pragma warning(disable: 4055)
-#pragma warning(disable: 4054)
-#pragma warning(disable: 4996)
-#endif
-	
-static PROC WinGetProcAddress(const char *name)
-{
-	static HMODULE glMod = NULL;
-	PROC pFunc = wglGetProcAddress((LPCSTR)name);
-
-	if (pFunc) return pFunc;
-
-	if (NULL == glMod)
-		glMod = GetModuleHandleA("OpenGL32.dll");
-
-	return (PROC)GetProcAddress(glMod, (LPCSTR)name);
-}
-
-#define IntGetProcAddress(name) WinGetProcAddress(name)
-#endif
-
-/* Linux, FreeBSD, other */
-#ifndef IntGetProcAddress
-	extern void ( * glXGetProcAddressARB (const GLubyte *procName)) (void);
-
-	#define IntGetProcAddress(name) (*glXGetProcAddressARB)((const GLubyte*)name)
-#endif
-
-/* TODO: Need to eventually use eglGetProcAddress */
-
-int glx_ext_AMD_gpu_association = glx_LOAD_FAILED;
-int glx_ext_ARB_create_context = glx_LOAD_FAILED;
-int glx_ext_ARB_create_context_profile = glx_LOAD_FAILED;
-int glx_ext_ARB_create_context_robustness = glx_LOAD_FAILED;
-int glx_ext_ARB_fbconfig_float = glx_LOAD_FAILED;
-int glx_ext_ARB_framebuffer_sRGB = glx_LOAD_FAILED;
-int glx_ext_ARB_get_proc_address = glx_LOAD_FAILED;
-int glx_ext_ARB_multisample = glx_LOAD_FAILED;
-int glx_ext_ARB_robustness_application_isolation = glx_LOAD_FAILED;
-int glx_ext_ARB_robustness_share_group_isolation = glx_LOAD_FAILED;
-int glx_ext_ARB_vertex_buffer_object = glx_LOAD_FAILED;
-int glx_ext_EXT_buffer_age = glx_LOAD_FAILED;
-int glx_ext_EXT_create_context_es2_profile = glx_LOAD_FAILED;
-int glx_ext_EXT_create_context_es_profile = glx_LOAD_FAILED;
-int glx_ext_EXT_fbconfig_packed_float = glx_LOAD_FAILED;
-int glx_ext_EXT_framebuffer_sRGB = glx_LOAD_FAILED;
-int glx_ext_EXT_import_context = glx_LOAD_FAILED;
-int glx_ext_EXT_swap_control = glx_LOAD_FAILED;
-int glx_ext_EXT_swap_control_tear = glx_LOAD_FAILED;
-int glx_ext_EXT_texture_from_pixmap = glx_LOAD_FAILED;
-int glx_ext_EXT_visual_info = glx_LOAD_FAILED;
-int glx_ext_EXT_visual_rating = glx_LOAD_FAILED;
-int glx_ext_INTEL_swap_event = glx_LOAD_FAILED;
-int glx_ext_MESA_agp_offset = glx_LOAD_FAILED;
-int glx_ext_MESA_copy_sub_buffer = glx_LOAD_FAILED;
-int glx_ext_MESA_pixmap_colormap = glx_LOAD_FAILED;
-int glx_ext_MESA_release_buffers = glx_LOAD_FAILED;
-int glx_ext_MESA_set_3dfx_mode = glx_LOAD_FAILED;
-int glx_ext_NV_copy_image = glx_LOAD_FAILED;
-int glx_ext_NV_float_buffer = glx_LOAD_FAILED;
-int glx_ext_NV_multisample_coverage = glx_LOAD_FAILED;
-int glx_ext_NV_present_video = glx_LOAD_FAILED;
-int glx_ext_NV_swap_group = glx_LOAD_FAILED;
-int glx_ext_NV_video_capture = glx_LOAD_FAILED;
-int glx_ext_NV_video_output = glx_LOAD_FAILED;
-
-GLXContext (CODEGEN_FUNCPTR *_ptrc_glXCreateContextAttribsARB)(Display *, GLXFBConfig, GLXContext, Bool, const int *) = NULL;
-
-static int Load_ARB_create_context(void)
-{
-	int numFailed = 0;
-	_ptrc_glXCreateContextAttribsARB = (GLXContext (CODEGEN_FUNCPTR *)(Display *, GLXFBConfig, GLXContext, Bool, const int *))IntGetProcAddress("glXCreateContextAttribsARB");
-	if(!_ptrc_glXCreateContextAttribsARB) numFailed++;
-	return numFailed;
-}
-
-__GLXextFuncPtr (CODEGEN_FUNCPTR *_ptrc_glXGetProcAddressARB)(const GLubyte *) = NULL;
-
-static int Load_ARB_get_proc_address(void)
-{
-	int numFailed = 0;
-	_ptrc_glXGetProcAddressARB = (__GLXextFuncPtr (CODEGEN_FUNCPTR *)(const GLubyte *))IntGetProcAddress("glXGetProcAddressARB");
-	if(!_ptrc_glXGetProcAddressARB) numFailed++;
-	return numFailed;
-}
-
-void (CODEGEN_FUNCPTR *_ptrc_glXFreeContextEXT)(Display *, GLXContext) = NULL;
-GLXContextID (CODEGEN_FUNCPTR *_ptrc_glXGetContextIDEXT)(const GLXContext) = NULL;
-Display * (CODEGEN_FUNCPTR *_ptrc_glXGetCurrentDisplayEXT)(void) = NULL;
-GLXContext (CODEGEN_FUNCPTR *_ptrc_glXImportContextEXT)(Display *, GLXContextID) = NULL;
-int (CODEGEN_FUNCPTR *_ptrc_glXQueryContextInfoEXT)(Display *, GLXContext, int, int *) = NULL;
-
-static int Load_EXT_import_context(void)
-{
-	int numFailed = 0;
-	_ptrc_glXFreeContextEXT = (void (CODEGEN_FUNCPTR *)(Display *, GLXContext))IntGetProcAddress("glXFreeContextEXT");
-	if(!_ptrc_glXFreeContextEXT) numFailed++;
-	_ptrc_glXGetContextIDEXT = (GLXContextID (CODEGEN_FUNCPTR *)(const GLXContext))IntGetProcAddress("glXGetContextIDEXT");
-	if(!_ptrc_glXGetContextIDEXT) numFailed++;
-	_ptrc_glXGetCurrentDisplayEXT = (Display * (CODEGEN_FUNCPTR *)(void))IntGetProcAddress("glXGetCurrentDisplayEXT");
-	if(!_ptrc_glXGetCurrentDisplayEXT) numFailed++;
-	_ptrc_glXImportContextEXT = (GLXContext (CODEGEN_FUNCPTR *)(Display *, GLXContextID))IntGetProcAddress("glXImportContextEXT");
-	if(!_ptrc_glXImportContextEXT) numFailed++;
-	_ptrc_glXQueryContextInfoEXT = (int (CODEGEN_FUNCPTR *)(Display *, GLXContext, int, int *))IntGetProcAddress("glXQueryContextInfoEXT");
-	if(!_ptrc_glXQueryContextInfoEXT) numFailed++;
-	return numFailed;
-}
-
-void (CODEGEN_FUNCPTR *_ptrc_glXSwapIntervalEXT)(Display *, GLXDrawable, int) = NULL;
-
-static int Load_EXT_swap_control(void)
-{
-	int numFailed = 0;
-	_ptrc_glXSwapIntervalEXT = (void (CODEGEN_FUNCPTR *)(Display *, GLXDrawable, int))IntGetProcAddress("glXSwapIntervalEXT");
-	if(!_ptrc_glXSwapIntervalEXT) numFailed++;
-	return numFailed;
-}
-
-void (CODEGEN_FUNCPTR *_ptrc_glXBindTexImageEXT)(Display *, GLXDrawable, int, const int *) = NULL;
-void (CODEGEN_FUNCPTR *_ptrc_glXReleaseTexImageEXT)(Display *, GLXDrawable, int) = NULL;
-
-static int Load_EXT_texture_from_pixmap(void)
-{
-	int numFailed = 0;
-	_ptrc_glXBindTexImageEXT = (void (CODEGEN_FUNCPTR *)(Display *, GLXDrawable, int, const int *))IntGetProcAddress("glXBindTexImageEXT");
-	if(!_ptrc_glXBindTexImageEXT) numFailed++;
-	_ptrc_glXReleaseTexImageEXT = (void (CODEGEN_FUNCPTR *)(Display *, GLXDrawable, int))IntGetProcAddress("glXReleaseTexImageEXT");
-	if(!_ptrc_glXReleaseTexImageEXT) numFailed++;
-	return numFailed;
-}
-
-unsigned int (CODEGEN_FUNCPTR *_ptrc_glXGetAGPOffsetMESA)(const void *) = NULL;
-
-static int Load_MESA_agp_offset(void)
-{
-	int numFailed = 0;
-	_ptrc_glXGetAGPOffsetMESA = (unsigned int (CODEGEN_FUNCPTR *)(const void *))IntGetProcAddress("glXGetAGPOffsetMESA");
-	if(!_ptrc_glXGetAGPOffsetMESA) numFailed++;
-	return numFailed;
-}
-
-void (CODEGEN_FUNCPTR *_ptrc_glXCopySubBufferMESA)(Display *, GLXDrawable, int, int, int, int) = NULL;
-
-static int Load_MESA_copy_sub_buffer(void)
-{
-	int numFailed = 0;
-	_ptrc_glXCopySubBufferMESA = (void (CODEGEN_FUNCPTR *)(Display *, GLXDrawable, int, int, int, int))IntGetProcAddress("glXCopySubBufferMESA");
-	if(!_ptrc_glXCopySubBufferMESA) numFailed++;
-	return numFailed;
-}
-
-GLXPixmap (CODEGEN_FUNCPTR *_ptrc_glXCreateGLXPixmapMESA)(Display *, XVisualInfo *, Pixmap, Colormap) = NULL;
-
-static int Load_MESA_pixmap_colormap(void)
-{
-	int numFailed = 0;
-	_ptrc_glXCreateGLXPixmapMESA = (GLXPixmap (CODEGEN_FUNCPTR *)(Display *, XVisualInfo *, Pixmap, Colormap))IntGetProcAddress("glXCreateGLXPixmapMESA");
-	if(!_ptrc_glXCreateGLXPixmapMESA) numFailed++;
-	return numFailed;
-}
-
-Bool (CODEGEN_FUNCPTR *_ptrc_glXReleaseBuffersMESA)(Display *, GLXDrawable) = NULL;
-
-static int Load_MESA_release_buffers(void)
-{
-	int numFailed = 0;
-	_ptrc_glXReleaseBuffersMESA = (Bool (CODEGEN_FUNCPTR *)(Display *, GLXDrawable))IntGetProcAddress("glXReleaseBuffersMESA");
-	if(!_ptrc_glXReleaseBuffersMESA) numFailed++;
-	return numFailed;
-}
-
-Bool (CODEGEN_FUNCPTR *_ptrc_glXSet3DfxModeMESA)(int) = NULL;
-
-static int Load_MESA_set_3dfx_mode(void)
-{
-	int numFailed = 0;
-	_ptrc_glXSet3DfxModeMESA = (Bool (CODEGEN_FUNCPTR *)(int))IntGetProcAddress("glXSet3DfxModeMESA");
-	if(!_ptrc_glXSet3DfxModeMESA) numFailed++;
-	return numFailed;
-}
-
-void (CODEGEN_FUNCPTR *_ptrc_glXCopyImageSubDataNV)(Display *, GLXContext, GLuint, GLenum, GLint, GLint, GLint, GLint, GLXContext, GLuint, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei) = NULL;
-
-static int Load_NV_copy_image(void)
-{
-	int numFailed = 0;
-	_ptrc_glXCopyImageSubDataNV = (void (CODEGEN_FUNCPTR *)(Display *, GLXContext, GLuint, GLenum, GLint, GLint, GLint, GLint, GLXContext, GLuint, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei))IntGetProcAddress("glXCopyImageSubDataNV");
-	if(!_ptrc_glXCopyImageSubDataNV) numFailed++;
-	return numFailed;
-}
-
-int (CODEGEN_FUNCPTR *_ptrc_glXBindVideoDeviceNV)(Display *, unsigned int, unsigned int, const int *) = NULL;
-unsigned int * (CODEGEN_FUNCPTR *_ptrc_glXEnumerateVideoDevicesNV)(Display *, int, int *) = NULL;
-
-static int Load_NV_present_video(void)
-{
-	int numFailed = 0;
-	_ptrc_glXBindVideoDeviceNV = (int (CODEGEN_FUNCPTR *)(Display *, unsigned int, unsigned int, const int *))IntGetProcAddress("glXBindVideoDeviceNV");
-	if(!_ptrc_glXBindVideoDeviceNV) numFailed++;
-	_ptrc_glXEnumerateVideoDevicesNV = (unsigned int * (CODEGEN_FUNCPTR *)(Display *, int, int *))IntGetProcAddress("glXEnumerateVideoDevicesNV");
-	if(!_ptrc_glXEnumerateVideoDevicesNV) numFailed++;
-	return numFailed;
-}
-
-Bool (CODEGEN_FUNCPTR *_ptrc_glXBindSwapBarrierNV)(Display *, GLuint, GLuint) = NULL;
-Bool (CODEGEN_FUNCPTR *_ptrc_glXJoinSwapGroupNV)(Display *, GLXDrawable, GLuint) = NULL;
-Bool (CODEGEN_FUNCPTR *_ptrc_glXQueryFrameCountNV)(Display *, int, GLuint *) = NULL;
-Bool (CODEGEN_FUNCPTR *_ptrc_glXQueryMaxSwapGroupsNV)(Display *, int, GLuint *, GLuint *) = NULL;
-Bool (CODEGEN_FUNCPTR *_ptrc_glXQuerySwapGroupNV)(Display *, GLXDrawable, GLuint *, GLuint *) = NULL;
-Bool (CODEGEN_FUNCPTR *_ptrc_glXResetFrameCountNV)(Display *, int) = NULL;
-
-static int Load_NV_swap_group(void)
-{
-	int numFailed = 0;
-	_ptrc_glXBindSwapBarrierNV = (Bool (CODEGEN_FUNCPTR *)(Display *, GLuint, GLuint))IntGetProcAddress("glXBindSwapBarrierNV");
-	if(!_ptrc_glXBindSwapBarrierNV) numFailed++;
-	_ptrc_glXJoinSwapGroupNV = (Bool (CODEGEN_FUNCPTR *)(Display *, GLXDrawable, GLuint))IntGetProcAddress("glXJoinSwapGroupNV");
-	if(!_ptrc_glXJoinSwapGroupNV) numFailed++;
-	_ptrc_glXQueryFrameCountNV = (Bool (CODEGEN_FUNCPTR *)(Display *, int, GLuint *))IntGetProcAddress("glXQueryFrameCountNV");
-	if(!_ptrc_glXQueryFrameCountNV) numFailed++;
-	_ptrc_glXQueryMaxSwapGroupsNV = (Bool (CODEGEN_FUNCPTR *)(Display *, int, GLuint *, GLuint *))IntGetProcAddress("glXQueryMaxSwapGroupsNV");
-	if(!_ptrc_glXQueryMaxSwapGroupsNV) numFailed++;
-	_ptrc_glXQuerySwapGroupNV = (Bool (CODEGEN_FUNCPTR *)(Display *, GLXDrawable, GLuint *, GLuint *))IntGetProcAddress("glXQuerySwapGroupNV");
-	if(!_ptrc_glXQuerySwapGroupNV) numFailed++;
-	_ptrc_glXResetFrameCountNV = (Bool (CODEGEN_FUNCPTR *)(Display *, int))IntGetProcAddress("glXResetFrameCountNV");
-	if(!_ptrc_glXResetFrameCountNV) numFailed++;
-	return numFailed;
-}
-
-int (CODEGEN_FUNCPTR *_ptrc_glXBindVideoCaptureDeviceNV)(Display *, unsigned int, GLXVideoCaptureDeviceNV) = NULL;
-GLXVideoCaptureDeviceNV * (CODEGEN_FUNCPTR *_ptrc_glXEnumerateVideoCaptureDevicesNV)(Display *, int, int *) = NULL;
-void (CODEGEN_FUNCPTR *_ptrc_glXLockVideoCaptureDeviceNV)(Display *, GLXVideoCaptureDeviceNV) = NULL;
-int (CODEGEN_FUNCPTR *_ptrc_glXQueryVideoCaptureDeviceNV)(Display *, GLXVideoCaptureDeviceNV, int, int *) = NULL;
-void (CODEGEN_FUNCPTR *_ptrc_glXReleaseVideoCaptureDeviceNV)(Display *, GLXVideoCaptureDeviceNV) = NULL;
-
-static int Load_NV_video_capture(void)
-{
-	int numFailed = 0;
-	_ptrc_glXBindVideoCaptureDeviceNV = (int (CODEGEN_FUNCPTR *)(Display *, unsigned int, GLXVideoCaptureDeviceNV))IntGetProcAddress("glXBindVideoCaptureDeviceNV");
-	if(!_ptrc_glXBindVideoCaptureDeviceNV) numFailed++;
-	_ptrc_glXEnumerateVideoCaptureDevicesNV = (GLXVideoCaptureDeviceNV * (CODEGEN_FUNCPTR *)(Display *, int, int *))IntGetProcAddress("glXEnumerateVideoCaptureDevicesNV");
-	if(!_ptrc_glXEnumerateVideoCaptureDevicesNV) numFailed++;
-	_ptrc_glXLockVideoCaptureDeviceNV = (void (CODEGEN_FUNCPTR *)(Display *, GLXVideoCaptureDeviceNV))IntGetProcAddress("glXLockVideoCaptureDeviceNV");
-	if(!_ptrc_glXLockVideoCaptureDeviceNV) numFailed++;
-	_ptrc_glXQueryVideoCaptureDeviceNV = (int (CODEGEN_FUNCPTR *)(Display *, GLXVideoCaptureDeviceNV, int, int *))IntGetProcAddress("glXQueryVideoCaptureDeviceNV");
-	if(!_ptrc_glXQueryVideoCaptureDeviceNV) numFailed++;
-	_ptrc_glXReleaseVideoCaptureDeviceNV = (void (CODEGEN_FUNCPTR *)(Display *, GLXVideoCaptureDeviceNV))IntGetProcAddress("glXReleaseVideoCaptureDeviceNV");
-	if(!_ptrc_glXReleaseVideoCaptureDeviceNV) numFailed++;
-	return numFailed;
-}
-
-int (CODEGEN_FUNCPTR *_ptrc_glXBindVideoImageNV)(Display *, GLXVideoDeviceNV, GLXPbuffer, int) = NULL;
-int (CODEGEN_FUNCPTR *_ptrc_glXGetVideoDeviceNV)(Display *, int, int, GLXVideoDeviceNV *) = NULL;
-int (CODEGEN_FUNCPTR *_ptrc_glXGetVideoInfoNV)(Display *, int, GLXVideoDeviceNV, unsigned long *, unsigned long *) = NULL;
-int (CODEGEN_FUNCPTR *_ptrc_glXReleaseVideoDeviceNV)(Display *, int, GLXVideoDeviceNV) = NULL;
-int (CODEGEN_FUNCPTR *_ptrc_glXReleaseVideoImageNV)(Display *, GLXPbuffer) = NULL;
-int (CODEGEN_FUNCPTR *_ptrc_glXSendPbufferToVideoNV)(Display *, GLXPbuffer, int, unsigned long *, GLboolean) = NULL;
-
-static int Load_NV_video_output(void)
-{
-	int numFailed = 0;
-	_ptrc_glXBindVideoImageNV = (int (CODEGEN_FUNCPTR *)(Display *, GLXVideoDeviceNV, GLXPbuffer, int))IntGetProcAddress("glXBindVideoImageNV");
-	if(!_ptrc_glXBindVideoImageNV) numFailed++;
-	_ptrc_glXGetVideoDeviceNV = (int (CODEGEN_FUNCPTR *)(Display *, int, int, GLXVideoDeviceNV *))IntGetProcAddress("glXGetVideoDeviceNV");
-	if(!_ptrc_glXGetVideoDeviceNV) numFailed++;
-	_ptrc_glXGetVideoInfoNV = (int (CODEGEN_FUNCPTR *)(Display *, int, GLXVideoDeviceNV, unsigned long *, unsigned long *))IntGetProcAddress("glXGetVideoInfoNV");
-	if(!_ptrc_glXGetVideoInfoNV) numFailed++;
-	_ptrc_glXReleaseVideoDeviceNV = (int (CODEGEN_FUNCPTR *)(Display *, int, GLXVideoDeviceNV))IntGetProcAddress("glXReleaseVideoDeviceNV");
-	if(!_ptrc_glXReleaseVideoDeviceNV) numFailed++;
-	_ptrc_glXReleaseVideoImageNV = (int (CODEGEN_FUNCPTR *)(Display *, GLXPbuffer))IntGetProcAddress("glXReleaseVideoImageNV");
-	if(!_ptrc_glXReleaseVideoImageNV) numFailed++;
-	_ptrc_glXSendPbufferToVideoNV = (int (CODEGEN_FUNCPTR *)(Display *, GLXPbuffer, int, unsigned long *, GLboolean))IntGetProcAddress("glXSendPbufferToVideoNV");
-	if(!_ptrc_glXSendPbufferToVideoNV) numFailed++;
-	return numFailed;
-}
-
-typedef int (*PFN_LOADFUNCPOINTERS)(void);
-typedef struct glx_StrToExtMap_s
-{
-	const char *extensionName;
-	int *extensionVariable;
-	PFN_LOADFUNCPOINTERS LoadExtension;
-} glx_StrToExtMap;
-
-static glx_StrToExtMap ExtensionMap[35] = {
-	{"GLX_AMD_gpu_association", &glx_ext_AMD_gpu_association, NULL},
-	{"GLX_ARB_create_context", &glx_ext_ARB_create_context, Load_ARB_create_context},
-	{"GLX_ARB_create_context_profile", &glx_ext_ARB_create_context_profile, NULL},
-	{"GLX_ARB_create_context_robustness", &glx_ext_ARB_create_context_robustness, NULL},
-	{"GLX_ARB_fbconfig_float", &glx_ext_ARB_fbconfig_float, NULL},
-	{"GLX_ARB_framebuffer_sRGB", &glx_ext_ARB_framebuffer_sRGB, NULL},
-	{"GLX_ARB_get_proc_address", &glx_ext_ARB_get_proc_address, Load_ARB_get_proc_address},
-	{"GLX_ARB_multisample", &glx_ext_ARB_multisample, NULL},
-	{"GLX_ARB_robustness_application_isolation", &glx_ext_ARB_robustness_application_isolation, NULL},
-	{"GLX_ARB_robustness_share_group_isolation", &glx_ext_ARB_robustness_share_group_isolation, NULL},
-	{"GLX_ARB_vertex_buffer_object", &glx_ext_ARB_vertex_buffer_object, NULL},
-	{"GLX_EXT_buffer_age", &glx_ext_EXT_buffer_age, NULL},
-	{"GLX_EXT_create_context_es2_profile", &glx_ext_EXT_create_context_es2_profile, NULL},
-	{"GLX_EXT_create_context_es_profile", &glx_ext_EXT_create_context_es_profile, NULL},
-	{"GLX_EXT_fbconfig_packed_float", &glx_ext_EXT_fbconfig_packed_float, NULL},
-	{"GLX_EXT_framebuffer_sRGB", &glx_ext_EXT_framebuffer_sRGB, NULL},
-	{"GLX_EXT_import_context", &glx_ext_EXT_import_context, Load_EXT_import_context},
-	{"GLX_EXT_swap_control", &glx_ext_EXT_swap_control, Load_EXT_swap_control},
-	{"GLX_EXT_swap_control_tear", &glx_ext_EXT_swap_control_tear, NULL},
-	{"GLX_EXT_texture_from_pixmap", &glx_ext_EXT_texture_from_pixmap, Load_EXT_texture_from_pixmap},
-	{"GLX_EXT_visual_info", &glx_ext_EXT_visual_info, NULL},
-	{"GLX_EXT_visual_rating", &glx_ext_EXT_visual_rating, NULL},
-	{"GLX_INTEL_swap_event", &glx_ext_INTEL_swap_event, NULL},
-	{"GLX_MESA_agp_offset", &glx_ext_MESA_agp_offset, Load_MESA_agp_offset},
-	{"GLX_MESA_copy_sub_buffer", &glx_ext_MESA_copy_sub_buffer, Load_MESA_copy_sub_buffer},
-	{"GLX_MESA_pixmap_colormap", &glx_ext_MESA_pixmap_colormap, Load_MESA_pixmap_colormap},
-	{"GLX_MESA_release_buffers", &glx_ext_MESA_release_buffers, Load_MESA_release_buffers},
-	{"GLX_MESA_set_3dfx_mode", &glx_ext_MESA_set_3dfx_mode, Load_MESA_set_3dfx_mode},
-	{"GLX_NV_copy_image", &glx_ext_NV_copy_image, Load_NV_copy_image},
-	{"GLX_NV_float_buffer", &glx_ext_NV_float_buffer, NULL},
-	{"GLX_NV_multisample_coverage", &glx_ext_NV_multisample_coverage, NULL},
-	{"GLX_NV_present_video", &glx_ext_NV_present_video, Load_NV_present_video},
-	{"GLX_NV_swap_group", &glx_ext_NV_swap_group, Load_NV_swap_group},
-	{"GLX_NV_video_capture", &glx_ext_NV_video_capture, Load_NV_video_capture},
-	{"GLX_NV_video_output", &glx_ext_NV_video_output, Load_NV_video_output},
-};
-
-static int g_extensionMapSize = 35;
-
-static glx_StrToExtMap *FindExtEntry(const char *extensionName)
-{
-	int loop;
-	glx_StrToExtMap *currLoc = ExtensionMap;
-	for(loop = 0; loop < g_extensionMapSize; ++loop, ++currLoc)
-	{
-		if(strcmp(extensionName, currLoc->extensionName) == 0)
-			return currLoc;
-	}
-	
-	return NULL;
-}
-
-static void ClearExtensionVars(void)
-{
-	glx_ext_AMD_gpu_association = glx_LOAD_FAILED;
-	glx_ext_ARB_create_context = glx_LOAD_FAILED;
-	glx_ext_ARB_create_context_profile = glx_LOAD_FAILED;
-	glx_ext_ARB_create_context_robustness = glx_LOAD_FAILED;
-	glx_ext_ARB_fbconfig_float = glx_LOAD_FAILED;
-	glx_ext_ARB_framebuffer_sRGB = glx_LOAD_FAILED;
-	glx_ext_ARB_get_proc_address = glx_LOAD_FAILED;
-	glx_ext_ARB_multisample = glx_LOAD_FAILED;
-	glx_ext_ARB_robustness_application_isolation = glx_LOAD_FAILED;
-	glx_ext_ARB_robustness_share_group_isolation = glx_LOAD_FAILED;
-	glx_ext_ARB_vertex_buffer_object = glx_LOAD_FAILED;
-	glx_ext_EXT_buffer_age = glx_LOAD_FAILED;
-	glx_ext_EXT_create_context_es2_profile = glx_LOAD_FAILED;
-	glx_ext_EXT_create_context_es_profile = glx_LOAD_FAILED;
-	glx_ext_EXT_fbconfig_packed_float = glx_LOAD_FAILED;
-	glx_ext_EXT_framebuffer_sRGB = glx_LOAD_FAILED;
-	glx_ext_EXT_import_context = glx_LOAD_FAILED;
-	glx_ext_EXT_swap_control = glx_LOAD_FAILED;
-	glx_ext_EXT_swap_control_tear = glx_LOAD_FAILED;
-	glx_ext_EXT_texture_from_pixmap = glx_LOAD_FAILED;
-	glx_ext_EXT_visual_info = glx_LOAD_FAILED;
-	glx_ext_EXT_visual_rating = glx_LOAD_FAILED;
-	glx_ext_INTEL_swap_event = glx_LOAD_FAILED;
-	glx_ext_MESA_agp_offset = glx_LOAD_FAILED;
-	glx_ext_MESA_copy_sub_buffer = glx_LOAD_FAILED;
-	glx_ext_MESA_pixmap_colormap = glx_LOAD_FAILED;
-	glx_ext_MESA_release_buffers = glx_LOAD_FAILED;
-	glx_ext_MESA_set_3dfx_mode = glx_LOAD_FAILED;
-	glx_ext_NV_copy_image = glx_LOAD_FAILED;
-	glx_ext_NV_float_buffer = glx_LOAD_FAILED;
-	glx_ext_NV_multisample_coverage = glx_LOAD_FAILED;
-	glx_ext_NV_present_video = glx_LOAD_FAILED;
-	glx_ext_NV_swap_group = glx_LOAD_FAILED;
-	glx_ext_NV_video_capture = glx_LOAD_FAILED;
-	glx_ext_NV_video_output = glx_LOAD_FAILED;
-}
-
-
-static void LoadExtByName(const char *extensionName)
-{
-	glx_StrToExtMap *entry = NULL;
-	entry = FindExtEntry(extensionName);
-	if(entry)
-	{
-		if(entry->LoadExtension)
-		{
-			int numFailed = entry->LoadExtension();
-			if(numFailed == 0)
-			{
-				*(entry->extensionVariable) = glx_LOAD_SUCCEEDED;
-			}
-			else
-			{
-				*(entry->extensionVariable) = glx_LOAD_SUCCEEDED + numFailed;
-			}
-		}
-		else
-		{
-			*(entry->extensionVariable) = glx_LOAD_SUCCEEDED;
-		}
-	}
-}
-
-
-static void ProcExtsFromExtString(const char *strExtList)
-{
-	size_t iExtListLen = strlen(strExtList);
-	const char *strExtListEnd = strExtList + iExtListLen;
-	const char *strCurrPos = strExtList;
-	char strWorkBuff[256];
-
-	while(*strCurrPos)
-	{
-		/*Get the extension at our position.*/
-		int iStrLen = 0;
-		const char *strEndStr = strchr(strCurrPos, ' ');
-		int iStop = 0;
-		if(strEndStr == NULL)
-		{
-			strEndStr = strExtListEnd;
-			iStop = 1;
-		}
-
-		iStrLen = (int)((ptrdiff_t)strEndStr - (ptrdiff_t)strCurrPos);
-
-		if(iStrLen > 255)
-			return;
-
-		strncpy(strWorkBuff, strCurrPos, iStrLen);
-		strWorkBuff[iStrLen] = '\0';
-
-		LoadExtByName(strWorkBuff);
-
-		strCurrPos = strEndStr + 1;
-		if(iStop) break;
-	}
-}
-
-int glx_LoadFunctions(Display *display, int screen)
-{
-	ClearExtensionVars();
-	
-	
-	ProcExtsFromExtString((const char *)glXQueryExtensionsString(display, screen));
-	return glx_LOAD_SUCCEEDED;
-}
-
--- a/libobs-opengl/GL/glx_obs.h
+++ b/libobs-opengl/GL/glx_obs.h
@@ -1,467 +0,0 @@
-/* AUTOGENERATED BY glLoadGen, DO NOT EDIT */
-#ifndef POINTER_C_GENERATED_HEADER_GLXWIN_H
-#define POINTER_C_GENERATED_HEADER_GLXWIN_H
-
-#ifdef __glxext_h_
-#error Attempt to include glx_exts after including glxext.h
-#endif
-
-#define __glxext_h_
-
-#include <X11/Xlib.h>
-#include <X11/Xutil.h>
-#include <GL/glx.h>
-#ifdef CODEGEN_FUNCPTR
-#undef CODEGEN_FUNCPTR
-#endif /*CODEGEN_FUNCPTR*/
-#define CODEGEN_FUNCPTR
-
-#ifndef GL_LOAD_GEN_BASIC_OPENGL_TYPEDEFS
-#define GL_LOAD_GEN_BASIC_OPENGL_TYPEDEFS
-
-typedef unsigned int GLenum;
-typedef unsigned char GLboolean;
-typedef unsigned int GLbitfield;
-typedef signed char GLbyte;
-typedef short GLshort;
-typedef int GLint;
-typedef int GLsizei;
-typedef unsigned char GLubyte;
-typedef unsigned short GLushort;
-typedef unsigned int GLuint;
-typedef float GLfloat;
-typedef float GLclampf;
-typedef double GLdouble;
-typedef double GLclampd;
-#define GLvoid void
-
-#endif /*GL_LOAD_GEN_BASIC_OPENGL_TYPEDEFS*/
-
-
-
-#ifndef GL_LOAD_GEN_BASIC_OPENGL_TYPEDEFS
-#define GL_LOAD_GEN_BASIC_OPENGL_TYPEDEFS
-
-
-#endif /*GL_LOAD_GEN_BASIC_OPENGL_TYPEDEFS*/
-
-
-#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 struct __GLXFBConfigRec *GLXFBConfig;
-	typedef XID GLXContextID;
-	typedef struct __GLXcontextRec *GLXContext;
-	typedef XID GLXPixmap;
-	typedef XID GLXDrawable;
-	typedef XID GLXPbuffer;
-	typedef void (APIENTRY *__GLXextFuncPtr)(void);
-	typedef XID GLXVideoCaptureDeviceNV;
-	typedef unsigned int GLXVideoDeviceNV;
-	typedef XID GLXVideoSourceSGIX;
-	typedef struct __GLXFBConfigRec *GLXFBConfigSGIX;
-	typedef XID GLXPbufferSGIX;
-	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;
-
-#ifdef __cplusplus
-extern "C" {
-#endif /*__cplusplus*/
-
-extern int glx_ext_AMD_gpu_association;
-extern int glx_ext_ARB_create_context;
-extern int glx_ext_ARB_create_context_profile;
-extern int glx_ext_ARB_create_context_robustness;
-extern int glx_ext_ARB_fbconfig_float;
-extern int glx_ext_ARB_framebuffer_sRGB;
-extern int glx_ext_ARB_get_proc_address;
-extern int glx_ext_ARB_multisample;
-extern int glx_ext_ARB_robustness_application_isolation;
-extern int glx_ext_ARB_robustness_share_group_isolation;
-extern int glx_ext_ARB_vertex_buffer_object;
-extern int glx_ext_EXT_buffer_age;
-extern int glx_ext_EXT_create_context_es2_profile;
-extern int glx_ext_EXT_create_context_es_profile;
-extern int glx_ext_EXT_fbconfig_packed_float;
-extern int glx_ext_EXT_framebuffer_sRGB;
-extern int glx_ext_EXT_import_context;
-extern int glx_ext_EXT_swap_control;
-extern int glx_ext_EXT_swap_control_tear;
-extern int glx_ext_EXT_texture_from_pixmap;
-extern int glx_ext_EXT_visual_info;
-extern int glx_ext_EXT_visual_rating;
-extern int glx_ext_INTEL_swap_event;
-extern int glx_ext_MESA_agp_offset;
-extern int glx_ext_MESA_copy_sub_buffer;
-extern int glx_ext_MESA_pixmap_colormap;
-extern int glx_ext_MESA_release_buffers;
-extern int glx_ext_MESA_set_3dfx_mode;
-extern int glx_ext_NV_copy_image;
-extern int glx_ext_NV_float_buffer;
-extern int glx_ext_NV_multisample_coverage;
-extern int glx_ext_NV_present_video;
-extern int glx_ext_NV_swap_group;
-extern int glx_ext_NV_video_capture;
-extern int glx_ext_NV_video_output;
-
-#define GLX_GPU_CLOCK_AMD 0x21A4
-#define GLX_GPU_FASTEST_TARGET_GPUS_AMD 0x21A2
-#define GLX_GPU_NUM_PIPES_AMD 0x21A5
-#define GLX_GPU_NUM_RB_AMD 0x21A7
-#define GLX_GPU_NUM_SIMD_AMD 0x21A6
-#define GLX_GPU_NUM_SPI_AMD 0x21A8
-#define GLX_GPU_OPENGL_VERSION_STRING_AMD 0x1F02
-#define GLX_GPU_RAM_AMD 0x21A3
-#define GLX_GPU_RENDERER_STRING_AMD 0x1F01
-#define GLX_GPU_VENDOR_AMD 0x1F00
-
-#define GLX_CONTEXT_DEBUG_BIT_ARB 0x00000001
-#define GLX_CONTEXT_FLAGS_ARB 0x2094
-#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_COMPATIBILITY_PROFILE_BIT_ARB 0x00000002
-#define GLX_CONTEXT_CORE_PROFILE_BIT_ARB 0x00000001
-#define GLX_CONTEXT_PROFILE_MASK_ARB 0x9126
-
-#define GLX_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB 0x8256
-#define GLX_CONTEXT_ROBUST_ACCESS_BIT_ARB 0x00000004
-#define GLX_LOSE_CONTEXT_ON_RESET_ARB 0x8252
-#define GLX_NO_RESET_NOTIFICATION_ARB 0x8261
-
-#define GLX_RGBA_FLOAT_BIT_ARB 0x00000004
-#define GLX_RGBA_FLOAT_TYPE_ARB 0x20B9
-
-#define GLX_FRAMEBUFFER_SRGB_CAPABLE_ARB 0x20B2
-
-#define GLX_SAMPLES_ARB 100001
-#define GLX_SAMPLE_BUFFERS_ARB 100000
-
-#define GLX_CONTEXT_RESET_ISOLATION_BIT_ARB 0x00000008
-
-/*Copied GLX_CONTEXT_RESET_ISOLATION_BIT_ARB From: ARB_robustness_application_isolation*/
-
-#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_BIT_EXT 0x00000008
-#define GLX_RGBA_UNSIGNED_FLOAT_TYPE_EXT 0x20B1
-
-#define GLX_FRAMEBUFFER_SRGB_CAPABLE_EXT 0x20B2
-
-#define GLX_SCREEN_EXT 0x800C
-#define GLX_SHARE_CONTEXT_EXT 0x800A
-#define GLX_VISUAL_ID_EXT 0x800B
-
-#define GLX_MAX_SWAP_INTERVAL_EXT 0x20F2
-#define GLX_SWAP_INTERVAL_EXT 0x20F1
-
-#define GLX_LATE_SWAPS_TEAR_EXT 0x20F3
-
-#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_BACK_EXT 0x20E0
-#define GLX_BACK_LEFT_EXT 0x20E0
-#define GLX_BACK_RIGHT_EXT 0x20E1
-#define GLX_BIND_TO_MIPMAP_TEXTURE_EXT 0x20D2
-#define GLX_BIND_TO_TEXTURE_RGBA_EXT 0x20D1
-#define GLX_BIND_TO_TEXTURE_RGB_EXT 0x20D0
-#define GLX_BIND_TO_TEXTURE_TARGETS_EXT 0x20D3
-#define GLX_FRONT_EXT 0x20DE
-#define GLX_FRONT_LEFT_EXT 0x20DE
-#define GLX_FRONT_RIGHT_EXT 0x20DF
-#define GLX_MIPMAP_TEXTURE_EXT 0x20D7
-#define GLX_TEXTURE_1D_BIT_EXT 0x00000001
-#define GLX_TEXTURE_1D_EXT 0x20DB
-#define GLX_TEXTURE_2D_BIT_EXT 0x00000002
-#define GLX_TEXTURE_2D_EXT 0x20DC
-#define GLX_TEXTURE_FORMAT_EXT 0x20D5
-#define GLX_TEXTURE_FORMAT_NONE_EXT 0x20D8
-#define GLX_TEXTURE_FORMAT_RGBA_EXT 0x20DA
-#define GLX_TEXTURE_FORMAT_RGB_EXT 0x20D9
-#define GLX_TEXTURE_RECTANGLE_BIT_EXT 0x00000004
-#define GLX_TEXTURE_RECTANGLE_EXT 0x20DD
-#define GLX_TEXTURE_TARGET_EXT 0x20D6
-#define GLX_Y_INVERTED_EXT 0x20D4
-
-#define GLX_DIRECT_COLOR_EXT 0x8003
-#define GLX_GRAY_SCALE_EXT 0x8006
-#define GLX_NONE_EXT 0x8000
-#define GLX_PSEUDO_COLOR_EXT 0x8004
-#define GLX_STATIC_COLOR_EXT 0x8005
-#define GLX_STATIC_GRAY_EXT 0x8007
-#define GLX_TRANSPARENT_ALPHA_VALUE_EXT 0x28
-#define GLX_TRANSPARENT_BLUE_VALUE_EXT 0x27
-#define GLX_TRANSPARENT_GREEN_VALUE_EXT 0x26
-#define GLX_TRANSPARENT_INDEX_EXT 0x8009
-#define GLX_TRANSPARENT_INDEX_VALUE_EXT 0x24
-#define GLX_TRANSPARENT_RED_VALUE_EXT 0x25
-#define GLX_TRANSPARENT_RGB_EXT 0x8008
-#define GLX_TRANSPARENT_TYPE_EXT 0x23
-#define GLX_TRUE_COLOR_EXT 0x8002
-#define GLX_X_VISUAL_TYPE_EXT 0x22
-
-/*Copied GLX_NONE_EXT From: EXT_visual_info*/
-#define GLX_NON_CONFORMANT_VISUAL_EXT 0x800D
-#define GLX_SLOW_VISUAL_EXT 0x8001
-#define GLX_VISUAL_CAVEAT_EXT 0x20
-
-#define GLX_BUFFER_SWAP_COMPLETE_INTEL_MASK 0x04000000
-#define GLX_COPY_COMPLETE_INTEL 0x8181
-#define GLX_EXCHANGE_COMPLETE_INTEL 0x8180
-#define GLX_FLIP_COMPLETE_INTEL 0x8182
-
-#define GLX_3DFX_FULLSCREEN_MODE_MESA 0x2
-#define GLX_3DFX_WINDOW_MODE_MESA 0x1
-
-#define GLX_FLOAT_COMPONENTS_NV 0x20B0
-
-#define GLX_COLOR_SAMPLES_NV 0x20B3
-#define GLX_COVERAGE_SAMPLES_NV 100001
-
-#define GLX_NUM_VIDEO_SLOTS_NV 0x20F0
-
-#define GLX_DEVICE_ID_NV 0x20CD
-#define GLX_NUM_VIDEO_CAPTURE_SLOTS_NV 0x20CF
-#define GLX_UNIQUE_ID_NV 0x20CE
-
-#define GLX_VIDEO_OUT_ALPHA_NV 0x20C4
-#define GLX_VIDEO_OUT_COLOR_AND_ALPHA_NV 0x20C6
-#define GLX_VIDEO_OUT_COLOR_AND_DEPTH_NV 0x20C7
-#define GLX_VIDEO_OUT_COLOR_NV 0x20C3
-#define GLX_VIDEO_OUT_DEPTH_NV 0x20C5
-#define GLX_VIDEO_OUT_FIELD_1_NV 0x20C9
-#define GLX_VIDEO_OUT_FIELD_2_NV 0x20CA
-#define GLX_VIDEO_OUT_FRAME_NV 0x20C8
-#define GLX_VIDEO_OUT_STACKED_FIELDS_1_2_NV 0x20CB
-#define GLX_VIDEO_OUT_STACKED_FIELDS_2_1_NV 0x20CC
-
-
-#ifndef GLX_ARB_create_context
-#define GLX_ARB_create_context 1
-extern GLXContext (CODEGEN_FUNCPTR *_ptrc_glXCreateContextAttribsARB)(Display *, GLXFBConfig, GLXContext, Bool, const int *);
-#define glXCreateContextAttribsARB _ptrc_glXCreateContextAttribsARB
-#endif /*GLX_ARB_create_context*/ 
-
-
-
-
-
-#ifndef GLX_ARB_get_proc_address
-#define GLX_ARB_get_proc_address 1
-extern __GLXextFuncPtr (CODEGEN_FUNCPTR *_ptrc_glXGetProcAddressARB)(const GLubyte *);
-#define glXGetProcAddressARB _ptrc_glXGetProcAddressARB
-#endif /*GLX_ARB_get_proc_address*/ 
-
-
-
-
-
-
-
-
-
-
-#ifndef GLX_EXT_import_context
-#define GLX_EXT_import_context 1
-extern void (CODEGEN_FUNCPTR *_ptrc_glXFreeContextEXT)(Display *, GLXContext);
-#define glXFreeContextEXT _ptrc_glXFreeContextEXT
-extern GLXContextID (CODEGEN_FUNCPTR *_ptrc_glXGetContextIDEXT)(const GLXContext);
-#define glXGetContextIDEXT _ptrc_glXGetContextIDEXT
-extern Display * (CODEGEN_FUNCPTR *_ptrc_glXGetCurrentDisplayEXT)(void);
-#define glXGetCurrentDisplayEXT _ptrc_glXGetCurrentDisplayEXT
-extern GLXContext (CODEGEN_FUNCPTR *_ptrc_glXImportContextEXT)(Display *, GLXContextID);
-#define glXImportContextEXT _ptrc_glXImportContextEXT
-extern int (CODEGEN_FUNCPTR *_ptrc_glXQueryContextInfoEXT)(Display *, GLXContext, int, int *);
-#define glXQueryContextInfoEXT _ptrc_glXQueryContextInfoEXT
-#endif /*GLX_EXT_import_context*/ 
-
-#ifndef GLX_EXT_swap_control
-#define GLX_EXT_swap_control 1
-extern void (CODEGEN_FUNCPTR *_ptrc_glXSwapIntervalEXT)(Display *, GLXDrawable, int);
-#define glXSwapIntervalEXT _ptrc_glXSwapIntervalEXT
-#endif /*GLX_EXT_swap_control*/ 
-
-
-#ifndef GLX_EXT_texture_from_pixmap
-#define GLX_EXT_texture_from_pixmap 1
-extern void (CODEGEN_FUNCPTR *_ptrc_glXBindTexImageEXT)(Display *, GLXDrawable, int, const int *);
-#define glXBindTexImageEXT _ptrc_glXBindTexImageEXT
-extern void (CODEGEN_FUNCPTR *_ptrc_glXReleaseTexImageEXT)(Display *, GLXDrawable, int);
-#define glXReleaseTexImageEXT _ptrc_glXReleaseTexImageEXT
-#endif /*GLX_EXT_texture_from_pixmap*/ 
-
-
-
-
-#ifndef GLX_MESA_agp_offset
-#define GLX_MESA_agp_offset 1
-extern unsigned int (CODEGEN_FUNCPTR *_ptrc_glXGetAGPOffsetMESA)(const void *);
-#define glXGetAGPOffsetMESA _ptrc_glXGetAGPOffsetMESA
-#endif /*GLX_MESA_agp_offset*/ 
-
-#ifndef GLX_MESA_copy_sub_buffer
-#define GLX_MESA_copy_sub_buffer 1
-extern void (CODEGEN_FUNCPTR *_ptrc_glXCopySubBufferMESA)(Display *, GLXDrawable, int, int, int, int);
-#define glXCopySubBufferMESA _ptrc_glXCopySubBufferMESA
-#endif /*GLX_MESA_copy_sub_buffer*/ 
-
-#ifndef GLX_MESA_pixmap_colormap
-#define GLX_MESA_pixmap_colormap 1
-extern GLXPixmap (CODEGEN_FUNCPTR *_ptrc_glXCreateGLXPixmapMESA)(Display *, XVisualInfo *, Pixmap, Colormap);
-#define glXCreateGLXPixmapMESA _ptrc_glXCreateGLXPixmapMESA
-#endif /*GLX_MESA_pixmap_colormap*/ 
-
-#ifndef GLX_MESA_release_buffers
-#define GLX_MESA_release_buffers 1
-extern Bool (CODEGEN_FUNCPTR *_ptrc_glXReleaseBuffersMESA)(Display *, GLXDrawable);
-#define glXReleaseBuffersMESA _ptrc_glXReleaseBuffersMESA
-#endif /*GLX_MESA_release_buffers*/ 
-
-#ifndef GLX_MESA_set_3dfx_mode
-#define GLX_MESA_set_3dfx_mode 1
-extern Bool (CODEGEN_FUNCPTR *_ptrc_glXSet3DfxModeMESA)(int);
-#define glXSet3DfxModeMESA _ptrc_glXSet3DfxModeMESA
-#endif /*GLX_MESA_set_3dfx_mode*/ 
-
-#ifndef GLX_NV_copy_image
-#define GLX_NV_copy_image 1
-extern void (CODEGEN_FUNCPTR *_ptrc_glXCopyImageSubDataNV)(Display *, GLXContext, GLuint, GLenum, GLint, GLint, GLint, GLint, GLXContext, GLuint, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei);
-#define glXCopyImageSubDataNV _ptrc_glXCopyImageSubDataNV
-#endif /*GLX_NV_copy_image*/ 
-
-
-
-#ifndef GLX_NV_present_video
-#define GLX_NV_present_video 1
-extern int (CODEGEN_FUNCPTR *_ptrc_glXBindVideoDeviceNV)(Display *, unsigned int, unsigned int, const int *);
-#define glXBindVideoDeviceNV _ptrc_glXBindVideoDeviceNV
-extern unsigned int * (CODEGEN_FUNCPTR *_ptrc_glXEnumerateVideoDevicesNV)(Display *, int, int *);
-#define glXEnumerateVideoDevicesNV _ptrc_glXEnumerateVideoDevicesNV
-#endif /*GLX_NV_present_video*/ 
-
-#ifndef GLX_NV_swap_group
-#define GLX_NV_swap_group 1
-extern Bool (CODEGEN_FUNCPTR *_ptrc_glXBindSwapBarrierNV)(Display *, GLuint, GLuint);
-#define glXBindSwapBarrierNV _ptrc_glXBindSwapBarrierNV
-extern Bool (CODEGEN_FUNCPTR *_ptrc_glXJoinSwapGroupNV)(Display *, GLXDrawable, GLuint);
-#define glXJoinSwapGroupNV _ptrc_glXJoinSwapGroupNV
-extern Bool (CODEGEN_FUNCPTR *_ptrc_glXQueryFrameCountNV)(Display *, int, GLuint *);
-#define glXQueryFrameCountNV _ptrc_glXQueryFrameCountNV
-extern Bool (CODEGEN_FUNCPTR *_ptrc_glXQueryMaxSwapGroupsNV)(Display *, int, GLuint *, GLuint *);
-#define glXQueryMaxSwapGroupsNV _ptrc_glXQueryMaxSwapGroupsNV
-extern Bool (CODEGEN_FUNCPTR *_ptrc_glXQuerySwapGroupNV)(Display *, GLXDrawable, GLuint *, GLuint *);
-#define glXQuerySwapGroupNV _ptrc_glXQuerySwapGroupNV
-extern Bool (CODEGEN_FUNCPTR *_ptrc_glXResetFrameCountNV)(Display *, int);
-#define glXResetFrameCountNV _ptrc_glXResetFrameCountNV
-#endif /*GLX_NV_swap_group*/ 
-
-#ifndef GLX_NV_video_capture
-#define GLX_NV_video_capture 1
-extern int (CODEGEN_FUNCPTR *_ptrc_glXBindVideoCaptureDeviceNV)(Display *, unsigned int, GLXVideoCaptureDeviceNV);
-#define glXBindVideoCaptureDeviceNV _ptrc_glXBindVideoCaptureDeviceNV
-extern GLXVideoCaptureDeviceNV * (CODEGEN_FUNCPTR *_ptrc_glXEnumerateVideoCaptureDevicesNV)(Display *, int, int *);
-#define glXEnumerateVideoCaptureDevicesNV _ptrc_glXEnumerateVideoCaptureDevicesNV
-extern void (CODEGEN_FUNCPTR *_ptrc_glXLockVideoCaptureDeviceNV)(Display *, GLXVideoCaptureDeviceNV);
-#define glXLockVideoCaptureDeviceNV _ptrc_glXLockVideoCaptureDeviceNV
-extern int (CODEGEN_FUNCPTR *_ptrc_glXQueryVideoCaptureDeviceNV)(Display *, GLXVideoCaptureDeviceNV, int, int *);
-#define glXQueryVideoCaptureDeviceNV _ptrc_glXQueryVideoCaptureDeviceNV
-extern void (CODEGEN_FUNCPTR *_ptrc_glXReleaseVideoCaptureDeviceNV)(Display *, GLXVideoCaptureDeviceNV);
-#define glXReleaseVideoCaptureDeviceNV _ptrc_glXReleaseVideoCaptureDeviceNV
-#endif /*GLX_NV_video_capture*/ 
-
-#ifndef GLX_NV_video_output
-#define GLX_NV_video_output 1
-extern int (CODEGEN_FUNCPTR *_ptrc_glXBindVideoImageNV)(Display *, GLXVideoDeviceNV, GLXPbuffer, int);
-#define glXBindVideoImageNV _ptrc_glXBindVideoImageNV
-extern int (CODEGEN_FUNCPTR *_ptrc_glXGetVideoDeviceNV)(Display *, int, int, GLXVideoDeviceNV *);
-#define glXGetVideoDeviceNV _ptrc_glXGetVideoDeviceNV
-extern int (CODEGEN_FUNCPTR *_ptrc_glXGetVideoInfoNV)(Display *, int, GLXVideoDeviceNV, unsigned long *, unsigned long *);
-#define glXGetVideoInfoNV _ptrc_glXGetVideoInfoNV
-extern int (CODEGEN_FUNCPTR *_ptrc_glXReleaseVideoDeviceNV)(Display *, int, GLXVideoDeviceNV);
-#define glXReleaseVideoDeviceNV _ptrc_glXReleaseVideoDeviceNV
-extern int (CODEGEN_FUNCPTR *_ptrc_glXReleaseVideoImageNV)(Display *, GLXPbuffer);
-#define glXReleaseVideoImageNV _ptrc_glXReleaseVideoImageNV
-extern int (CODEGEN_FUNCPTR *_ptrc_glXSendPbufferToVideoNV)(Display *, GLXPbuffer, int, unsigned long *, GLboolean);
-#define glXSendPbufferToVideoNV _ptrc_glXSendPbufferToVideoNV
-#endif /*GLX_NV_video_output*/ 
-
-enum glx_LoadStatus
-{
-	glx_LOAD_FAILED = 0,
-	glx_LOAD_SUCCEEDED = 1
-};
-
-int glx_LoadFunctions(Display *display, int screen);
-
-
-#ifdef __cplusplus
-}
-#endif /*__cplusplus*/
-
-#endif /* POINTER_C_GENERATED_HEADER_GLXWIN_H */
--- a/libobs-opengl/GL/wgl_obs.c
+++ b/libobs-opengl/GL/wgl_obs.c
@@ -1,270 +0,0 @@
-/* AUTOGENERATED BY glLoadGen, DO NOT EDIT */
-#include <stdlib.h>
-#include <string.h>
-#include <stddef.h>
-#include "wgl_obs.h"
-
-#if defined(__APPLE__)
-#include <dlfcn.h>
-
-static void* AppleGLGetProcAddress (const char *name)
-{
-	static void* image = NULL;
-	
-	if (NULL == image)
-		image = dlopen("/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL", RTLD_LAZY);
-
-	return (image ? dlsym(image, name) : NULL);
-}
-#define IntGetProcAddress(name) AppleGLGetProcAddress(name)
-#endif /* __APPLE__ */
-
-#if defined(_WIN32)
-
-#ifdef _MSC_VER
-#pragma warning(disable: 4055)
-#pragma warning(disable: 4054)
-#pragma warning(disable: 4996)
-#endif
-	
-static PROC WinGetProcAddress(const char *name)
-{
-	static HMODULE glMod = NULL;
-	PROC pFunc = wglGetProcAddress((LPCSTR)name);
-
-	if (pFunc) return pFunc;
-
-	if (NULL == glMod)
-		glMod = GetModuleHandleA("OpenGL32.dll");
-
-	return (PROC)GetProcAddress(glMod, (LPCSTR)name);
-}
-
-#define IntGetProcAddress(name) WinGetProcAddress(name)
-#endif
-
-/* Linux, FreeBSD, other */
-#ifndef IntGetProcAddress
-	extern void ( * glXGetProcAddressARB (const GLubyte *procName)) (void);
-
-	#define IntGetProcAddress(name) (*glXGetProcAddressARB)((const GLubyte*)name)
-#endif
-
-/* TODO: Need to eventually use eglGetProcAddress */
-
-int wgl_ext_ARB_multisample = wgl_LOAD_FAILED;
-int wgl_ext_ARB_extensions_string = wgl_LOAD_FAILED;
-int wgl_ext_ARB_pixel_format = wgl_LOAD_FAILED;
-int wgl_ext_ARB_pixel_format_float = wgl_LOAD_FAILED;
-int wgl_ext_ARB_framebuffer_sRGB = wgl_LOAD_FAILED;
-int wgl_ext_ARB_create_context = wgl_LOAD_FAILED;
-int wgl_ext_ARB_create_context_profile = wgl_LOAD_FAILED;
-int wgl_ext_ARB_create_context_robustness = wgl_LOAD_FAILED;
-int wgl_ext_EXT_swap_control = wgl_LOAD_FAILED;
-int wgl_ext_EXT_pixel_format_packed_float = wgl_LOAD_FAILED;
-int wgl_ext_EXT_create_context_es2_profile = wgl_LOAD_FAILED;
-int wgl_ext_EXT_swap_control_tear = wgl_LOAD_FAILED;
-int wgl_ext_NV_swap_group = wgl_LOAD_FAILED;
-
-const char * (CODEGEN_FUNCPTR *_ptrc_wglGetExtensionsStringARB)(HDC) = NULL;
-
-static int Load_ARB_extensions_string(void)
-{
-	int numFailed = 0;
-	_ptrc_wglGetExtensionsStringARB = (const char * (CODEGEN_FUNCPTR *)(HDC))IntGetProcAddress("wglGetExtensionsStringARB");
-	if(!_ptrc_wglGetExtensionsStringARB) numFailed++;
-	return numFailed;
-}
-
-BOOL (CODEGEN_FUNCPTR *_ptrc_wglChoosePixelFormatARB)(HDC, const int *, const FLOAT *, UINT, int *, UINT *) = NULL;
-BOOL (CODEGEN_FUNCPTR *_ptrc_wglGetPixelFormatAttribfvARB)(HDC, int, int, UINT, const int *, FLOAT *) = NULL;
-BOOL (CODEGEN_FUNCPTR *_ptrc_wglGetPixelFormatAttribivARB)(HDC, int, int, UINT, const int *, int *) = NULL;
-
-static int Load_ARB_pixel_format(void)
-{
-	int numFailed = 0;
-	_ptrc_wglChoosePixelFormatARB = (BOOL (CODEGEN_FUNCPTR *)(HDC, const int *, const FLOAT *, UINT, int *, UINT *))IntGetProcAddress("wglChoosePixelFormatARB");
-	if(!_ptrc_wglChoosePixelFormatARB) numFailed++;
-	_ptrc_wglGetPixelFormatAttribfvARB = (BOOL (CODEGEN_FUNCPTR *)(HDC, int, int, UINT, const int *, FLOAT *))IntGetProcAddress("wglGetPixelFormatAttribfvARB");
-	if(!_ptrc_wglGetPixelFormatAttribfvARB) numFailed++;
-	_ptrc_wglGetPixelFormatAttribivARB = (BOOL (CODEGEN_FUNCPTR *)(HDC, int, int, UINT, const int *, int *))IntGetProcAddress("wglGetPixelFormatAttribivARB");
-	if(!_ptrc_wglGetPixelFormatAttribivARB) numFailed++;
-	return numFailed;
-}
-
-HGLRC (CODEGEN_FUNCPTR *_ptrc_wglCreateContextAttribsARB)(HDC, HGLRC, const int *) = NULL;
-
-static int Load_ARB_create_context(void)
-{
-	int numFailed = 0;
-	_ptrc_wglCreateContextAttribsARB = (HGLRC (CODEGEN_FUNCPTR *)(HDC, HGLRC, const int *))IntGetProcAddress("wglCreateContextAttribsARB");
-	if(!_ptrc_wglCreateContextAttribsARB) numFailed++;
-	return numFailed;
-}
-
-int (CODEGEN_FUNCPTR *_ptrc_wglGetSwapIntervalEXT)(void) = NULL;
-BOOL (CODEGEN_FUNCPTR *_ptrc_wglSwapIntervalEXT)(int) = NULL;
-
-static int Load_EXT_swap_control(void)
-{
-	int numFailed = 0;
-	_ptrc_wglGetSwapIntervalEXT = (int (CODEGEN_FUNCPTR *)(void))IntGetProcAddress("wglGetSwapIntervalEXT");
-	if(!_ptrc_wglGetSwapIntervalEXT) numFailed++;
-	_ptrc_wglSwapIntervalEXT = (BOOL (CODEGEN_FUNCPTR *)(int))IntGetProcAddress("wglSwapIntervalEXT");
-	if(!_ptrc_wglSwapIntervalEXT) numFailed++;
-	return numFailed;
-}
-
-BOOL (CODEGEN_FUNCPTR *_ptrc_wglBindSwapBarrierNV)(GLuint, GLuint) = NULL;
-BOOL (CODEGEN_FUNCPTR *_ptrc_wglJoinSwapGroupNV)(HDC, GLuint) = NULL;
-BOOL (CODEGEN_FUNCPTR *_ptrc_wglQueryFrameCountNV)(HDC, GLuint *) = NULL;
-BOOL (CODEGEN_FUNCPTR *_ptrc_wglQueryMaxSwapGroupsNV)(HDC, GLuint *, GLuint *) = NULL;
-BOOL (CODEGEN_FUNCPTR *_ptrc_wglQuerySwapGroupNV)(HDC, GLuint *, GLuint *) = NULL;
-BOOL (CODEGEN_FUNCPTR *_ptrc_wglResetFrameCountNV)(HDC) = NULL;
-
-static int Load_NV_swap_group(void)
-{
-	int numFailed = 0;
-	_ptrc_wglBindSwapBarrierNV = (BOOL (CODEGEN_FUNCPTR *)(GLuint, GLuint))IntGetProcAddress("wglBindSwapBarrierNV");
-	if(!_ptrc_wglBindSwapBarrierNV) numFailed++;
-	_ptrc_wglJoinSwapGroupNV = (BOOL (CODEGEN_FUNCPTR *)(HDC, GLuint))IntGetProcAddress("wglJoinSwapGroupNV");
-	if(!_ptrc_wglJoinSwapGroupNV) numFailed++;
-	_ptrc_wglQueryFrameCountNV = (BOOL (CODEGEN_FUNCPTR *)(HDC, GLuint *))IntGetProcAddress("wglQueryFrameCountNV");
-	if(!_ptrc_wglQueryFrameCountNV) numFailed++;
-	_ptrc_wglQueryMaxSwapGroupsNV = (BOOL (CODEGEN_FUNCPTR *)(HDC, GLuint *, GLuint *))IntGetProcAddress("wglQueryMaxSwapGroupsNV");
-	if(!_ptrc_wglQueryMaxSwapGroupsNV) numFailed++;
-	_ptrc_wglQuerySwapGroupNV = (BOOL (CODEGEN_FUNCPTR *)(HDC, GLuint *, GLuint *))IntGetProcAddress("wglQuerySwapGroupNV");
-	if(!_ptrc_wglQuerySwapGroupNV) numFailed++;
-	_ptrc_wglResetFrameCountNV = (BOOL (CODEGEN_FUNCPTR *)(HDC))IntGetProcAddress("wglResetFrameCountNV");
-	if(!_ptrc_wglResetFrameCountNV) numFailed++;
-	return numFailed;
-}
-
-typedef int (*PFN_LOADFUNCPOINTERS)(void);
-typedef struct wgl_StrToExtMap_s
-{
-	const char *extensionName;
-	int *extensionVariable;
-	PFN_LOADFUNCPOINTERS LoadExtension;
-} wgl_StrToExtMap;
-
-static wgl_StrToExtMap ExtensionMap[13] = {
-	{"WGL_ARB_multisample", &wgl_ext_ARB_multisample, NULL},
-	{"WGL_ARB_extensions_string", &wgl_ext_ARB_extensions_string, Load_ARB_extensions_string},
-	{"WGL_ARB_pixel_format", &wgl_ext_ARB_pixel_format, Load_ARB_pixel_format},
-	{"WGL_ARB_pixel_format_float", &wgl_ext_ARB_pixel_format_float, NULL},
-	{"WGL_ARB_framebuffer_sRGB", &wgl_ext_ARB_framebuffer_sRGB, NULL},
-	{"WGL_ARB_create_context", &wgl_ext_ARB_create_context, Load_ARB_create_context},
-	{"WGL_ARB_create_context_profile", &wgl_ext_ARB_create_context_profile, NULL},
-	{"WGL_ARB_create_context_robustness", &wgl_ext_ARB_create_context_robustness, NULL},
-	{"WGL_EXT_swap_control", &wgl_ext_EXT_swap_control, Load_EXT_swap_control},
-	{"WGL_EXT_pixel_format_packed_float", &wgl_ext_EXT_pixel_format_packed_float, NULL},
-	{"WGL_EXT_create_context_es2_profile", &wgl_ext_EXT_create_context_es2_profile, NULL},
-	{"WGL_EXT_swap_control_tear", &wgl_ext_EXT_swap_control_tear, NULL},
-	{"WGL_NV_swap_group", &wgl_ext_NV_swap_group, Load_NV_swap_group},
-};
-
-static int g_extensionMapSize = 13;
-
-static wgl_StrToExtMap *FindExtEntry(const char *extensionName)
-{
-	int loop;
-	wgl_StrToExtMap *currLoc = ExtensionMap;
-	for(loop = 0; loop < g_extensionMapSize; ++loop, ++currLoc)
-	{
-		if(strcmp(extensionName, currLoc->extensionName) == 0)
-			return currLoc;
-	}
-	
-	return NULL;
-}
-
-static void ClearExtensionVars(void)
-{
-	wgl_ext_ARB_multisample = wgl_LOAD_FAILED;
-	wgl_ext_ARB_extensions_string = wgl_LOAD_FAILED;
-	wgl_ext_ARB_pixel_format = wgl_LOAD_FAILED;
-	wgl_ext_ARB_pixel_format_float = wgl_LOAD_FAILED;
-	wgl_ext_ARB_framebuffer_sRGB = wgl_LOAD_FAILED;
-	wgl_ext_ARB_create_context = wgl_LOAD_FAILED;
-	wgl_ext_ARB_create_context_profile = wgl_LOAD_FAILED;
-	wgl_ext_ARB_create_context_robustness = wgl_LOAD_FAILED;
-	wgl_ext_EXT_swap_control = wgl_LOAD_FAILED;
-	wgl_ext_EXT_pixel_format_packed_float = wgl_LOAD_FAILED;
-	wgl_ext_EXT_create_context_es2_profile = wgl_LOAD_FAILED;
-	wgl_ext_EXT_swap_control_tear = wgl_LOAD_FAILED;
-	wgl_ext_NV_swap_group = wgl_LOAD_FAILED;
-}
-
-
-static void LoadExtByName(const char *extensionName)
-{
-	wgl_StrToExtMap *entry = NULL;
-	entry = FindExtEntry(extensionName);
-	if(entry)
-	{
-		if(entry->LoadExtension)
-		{
-			int numFailed = entry->LoadExtension();
-			if(numFailed == 0)
-			{
-				*(entry->extensionVariable) = wgl_LOAD_SUCCEEDED;
-			}
-			else
-			{
-				*(entry->extensionVariable) = wgl_LOAD_SUCCEEDED + numFailed;
-			}
-		}
-		else
-		{
-			*(entry->extensionVariable) = wgl_LOAD_SUCCEEDED;
-		}
-	}
-}
-
-
-static void ProcExtsFromExtString(const char *strExtList)
-{
-	size_t iExtListLen = strlen(strExtList);
-	const char *strExtListEnd = strExtList + iExtListLen;
-	const char *strCurrPos = strExtList;
-	char strWorkBuff[256];
-
-	while(*strCurrPos)
-	{
-		/*Get the extension at our position.*/
-		int iStrLen = 0;
-		const char *strEndStr = strchr(strCurrPos, ' ');
-		int iStop = 0;
-		if(strEndStr == NULL)
-		{
-			strEndStr = strExtListEnd;
-			iStop = 1;
-		}
-
-		iStrLen = (int)((ptrdiff_t)strEndStr - (ptrdiff_t)strCurrPos);
-
-		if(iStrLen > 255)
-			return;
-
-		strncpy(strWorkBuff, strCurrPos, iStrLen);
-		strWorkBuff[iStrLen] = '\0';
-
-		LoadExtByName(strWorkBuff);
-
-		strCurrPos = strEndStr + 1;
-		if(iStop) break;
-	}
-}
-
-int wgl_LoadFunctions(HDC hdc)
-{
-	ClearExtensionVars();
-	
-	_ptrc_wglGetExtensionsStringARB = (const char * (CODEGEN_FUNCPTR *)(HDC))IntGetProcAddress("wglGetExtensionsStringARB");
-	if(!_ptrc_wglGetExtensionsStringARB) return wgl_LOAD_FAILED;
-	
-	ProcExtsFromExtString((const char *)_ptrc_wglGetExtensionsStringARB(hdc));
-	return wgl_LOAD_SUCCEEDED;
-}
-
--- a/libobs-opengl/GL/wgl_obs.h
+++ b/libobs-opengl/GL/wgl_obs.h
@@ -1,233 +0,0 @@
-/* AUTOGENERATED BY glLoadGen, DO NOT EDIT */
-#ifndef POINTER_C_GENERATED_HEADER_WINDOWSGL_H
-#define POINTER_C_GENERATED_HEADER_WINDOWSGL_H
-
-#ifdef __wglext_h_
-#error Attempt to include auto-generated WGL header after wglext.h
-#endif
-
-#define __wglext_h_
-
-#ifndef WIN32_LEAN_AND_MEAN
-	#define WIN32_LEAN_AND_MEAN 1
-#endif
-#ifndef NOMINMAX
-	#define NOMINMAX
-#endif
-#include <windows.h>
-
-#ifdef CODEGEN_FUNCPTR
-#undef CODEGEN_FUNCPTR
-#endif /*CODEGEN_FUNCPTR*/
-#define CODEGEN_FUNCPTR WINAPI
-
-#ifndef GL_LOAD_GEN_BASIC_OPENGL_TYPEDEFS
-#define GL_LOAD_GEN_BASIC_OPENGL_TYPEDEFS
-
-typedef unsigned int GLenum;
-typedef unsigned char GLboolean;
-typedef unsigned int GLbitfield;
-typedef signed char GLbyte;
-typedef short GLshort;
-typedef int GLint;
-typedef int GLsizei;
-typedef unsigned char GLubyte;
-typedef unsigned short GLushort;
-typedef unsigned int GLuint;
-typedef float GLfloat;
-typedef float GLclampf;
-typedef double GLdouble;
-typedef double GLclampd;
-#define GLvoid void
-
-#endif /*GL_LOAD_GEN_BASIC_OPENGL_TYPEDEFS*/
-
-
-
-#ifndef GL_LOAD_GEN_BASIC_OPENGL_TYPEDEFS
-#define GL_LOAD_GEN_BASIC_OPENGL_TYPEDEFS
-
-
-#endif /*GL_LOAD_GEN_BASIC_OPENGL_TYPEDEFS*/
-
-
-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(HGPUNV);
-DECLARE_HANDLE(HVIDEOINPUTDEVICENV);
-typedef struct _GPU_DEVICE *PGPU_DEVICE;
-
-#ifdef __cplusplus
-extern "C" {
-#endif /*__cplusplus*/
-
-extern int wgl_ext_ARB_multisample;
-extern int wgl_ext_ARB_extensions_string;
-extern int wgl_ext_ARB_pixel_format;
-extern int wgl_ext_ARB_pixel_format_float;
-extern int wgl_ext_ARB_framebuffer_sRGB;
-extern int wgl_ext_ARB_create_context;
-extern int wgl_ext_ARB_create_context_profile;
-extern int wgl_ext_ARB_create_context_robustness;
-extern int wgl_ext_EXT_swap_control;
-extern int wgl_ext_EXT_pixel_format_packed_float;
-extern int wgl_ext_EXT_create_context_es2_profile;
-extern int wgl_ext_EXT_swap_control_tear;
-extern int wgl_ext_NV_swap_group;
-
-#define WGL_SAMPLES_ARB 0x2042
-#define WGL_SAMPLE_BUFFERS_ARB 0x2041
-
-#define WGL_ACCELERATION_ARB 0x2003
-#define WGL_ACCUM_ALPHA_BITS_ARB 0x2021
-#define WGL_ACCUM_BITS_ARB 0x201D
-#define WGL_ACCUM_BLUE_BITS_ARB 0x2020
-#define WGL_ACCUM_GREEN_BITS_ARB 0x201F
-#define WGL_ACCUM_RED_BITS_ARB 0x201E
-#define WGL_ALPHA_BITS_ARB 0x201B
-#define WGL_ALPHA_SHIFT_ARB 0x201C
-#define WGL_AUX_BUFFERS_ARB 0x2024
-#define WGL_BLUE_BITS_ARB 0x2019
-#define WGL_BLUE_SHIFT_ARB 0x201A
-#define WGL_COLOR_BITS_ARB 0x2014
-#define WGL_DEPTH_BITS_ARB 0x2022
-#define WGL_DOUBLE_BUFFER_ARB 0x2011
-#define WGL_DRAW_TO_BITMAP_ARB 0x2002
-#define WGL_DRAW_TO_WINDOW_ARB 0x2001
-#define WGL_FULL_ACCELERATION_ARB 0x2027
-#define WGL_GENERIC_ACCELERATION_ARB 0x2026
-#define WGL_GREEN_BITS_ARB 0x2017
-#define WGL_GREEN_SHIFT_ARB 0x2018
-#define WGL_NEED_PALETTE_ARB 0x2004
-#define WGL_NEED_SYSTEM_PALETTE_ARB 0x2005
-#define WGL_NO_ACCELERATION_ARB 0x2025
-#define WGL_NUMBER_OVERLAYS_ARB 0x2008
-#define WGL_NUMBER_PIXEL_FORMATS_ARB 0x2000
-#define WGL_NUMBER_UNDERLAYS_ARB 0x2009
-#define WGL_PIXEL_TYPE_ARB 0x2013
-#define WGL_RED_BITS_ARB 0x2015
-#define WGL_RED_SHIFT_ARB 0x2016
-#define WGL_SHARE_ACCUM_ARB 0x200E
-#define WGL_SHARE_DEPTH_ARB 0x200C
-#define WGL_SHARE_STENCIL_ARB 0x200D
-#define WGL_STENCIL_BITS_ARB 0x2023
-#define WGL_STEREO_ARB 0x2012
-#define WGL_SUPPORT_GDI_ARB 0x200F
-#define WGL_SUPPORT_OPENGL_ARB 0x2010
-#define WGL_SWAP_COPY_ARB 0x2029
-#define WGL_SWAP_EXCHANGE_ARB 0x2028
-#define WGL_SWAP_LAYER_BUFFERS_ARB 0x2006
-#define WGL_SWAP_METHOD_ARB 0x2007
-#define WGL_SWAP_UNDEFINED_ARB 0x202A
-#define WGL_TRANSPARENT_ALPHA_VALUE_ARB 0x203A
-#define WGL_TRANSPARENT_ARB 0x200A
-#define WGL_TRANSPARENT_BLUE_VALUE_ARB 0x2039
-#define WGL_TRANSPARENT_GREEN_VALUE_ARB 0x2038
-#define WGL_TRANSPARENT_INDEX_VALUE_ARB 0x203B
-#define WGL_TRANSPARENT_RED_VALUE_ARB 0x2037
-#define WGL_TYPE_COLORINDEX_ARB 0x202C
-#define WGL_TYPE_RGBA_ARB 0x202B
-
-#define WGL_TYPE_RGBA_FLOAT_ARB 0x21A0
-
-#define WGL_FRAMEBUFFER_SRGB_CAPABLE_ARB 0x20A9
-
-#define WGL_CONTEXT_DEBUG_BIT_ARB 0x00000001
-#define WGL_CONTEXT_FLAGS_ARB 0x2094
-#define WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB 0x00000002
-#define WGL_CONTEXT_LAYER_PLANE_ARB 0x2093
-#define WGL_CONTEXT_MAJOR_VERSION_ARB 0x2091
-#define WGL_CONTEXT_MINOR_VERSION_ARB 0x2092
-#define WGL_ERROR_INVALID_VERSION_ARB 0x2095
-
-#define WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB 0x00000002
-#define WGL_CONTEXT_CORE_PROFILE_BIT_ARB 0x00000001
-#define WGL_CONTEXT_PROFILE_MASK_ARB 0x9126
-#define WGL_ERROR_INVALID_PROFILE_ARB 0x2096
-
-#define WGL_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB 0x8256
-#define WGL_CONTEXT_ROBUST_ACCESS_BIT_ARB 0x00000004
-#define WGL_LOSE_CONTEXT_ON_RESET_ARB 0x8252
-#define WGL_NO_RESET_NOTIFICATION_ARB 0x8261
-
-#define WGL_TYPE_RGBA_UNSIGNED_FLOAT_EXT 0x20A8
-
-#define WGL_CONTEXT_ES2_PROFILE_BIT_EXT 0x00000004
-
-
-#ifndef WGL_ARB_extensions_string
-#define WGL_ARB_extensions_string 1
-extern const char * (CODEGEN_FUNCPTR *_ptrc_wglGetExtensionsStringARB)(HDC);
-#define wglGetExtensionsStringARB _ptrc_wglGetExtensionsStringARB
-#endif /*WGL_ARB_extensions_string*/ 
-
-#ifndef WGL_ARB_pixel_format
-#define WGL_ARB_pixel_format 1
-extern BOOL (CODEGEN_FUNCPTR *_ptrc_wglChoosePixelFormatARB)(HDC, const int *, const FLOAT *, UINT, int *, UINT *);
-#define wglChoosePixelFormatARB _ptrc_wglChoosePixelFormatARB
-extern BOOL (CODEGEN_FUNCPTR *_ptrc_wglGetPixelFormatAttribfvARB)(HDC, int, int, UINT, const int *, FLOAT *);
-#define wglGetPixelFormatAttribfvARB _ptrc_wglGetPixelFormatAttribfvARB
-extern BOOL (CODEGEN_FUNCPTR *_ptrc_wglGetPixelFormatAttribivARB)(HDC, int, int, UINT, const int *, int *);
-#define wglGetPixelFormatAttribivARB _ptrc_wglGetPixelFormatAttribivARB
-#endif /*WGL_ARB_pixel_format*/ 
-
-
-
-#ifndef WGL_ARB_create_context
-#define WGL_ARB_create_context 1
-extern HGLRC (CODEGEN_FUNCPTR *_ptrc_wglCreateContextAttribsARB)(HDC, HGLRC, const int *);
-#define wglCreateContextAttribsARB _ptrc_wglCreateContextAttribsARB
-#endif /*WGL_ARB_create_context*/ 
-
-
-
-#ifndef WGL_EXT_swap_control
-#define WGL_EXT_swap_control 1
-extern int (CODEGEN_FUNCPTR *_ptrc_wglGetSwapIntervalEXT)(void);
-#define wglGetSwapIntervalEXT _ptrc_wglGetSwapIntervalEXT
-extern BOOL (CODEGEN_FUNCPTR *_ptrc_wglSwapIntervalEXT)(int);
-#define wglSwapIntervalEXT _ptrc_wglSwapIntervalEXT
-#endif /*WGL_EXT_swap_control*/ 
-
-
-
-
-#ifndef WGL_NV_swap_group
-#define WGL_NV_swap_group 1
-extern BOOL (CODEGEN_FUNCPTR *_ptrc_wglBindSwapBarrierNV)(GLuint, GLuint);
-#define wglBindSwapBarrierNV _ptrc_wglBindSwapBarrierNV
-extern BOOL (CODEGEN_FUNCPTR *_ptrc_wglJoinSwapGroupNV)(HDC, GLuint);
-#define wglJoinSwapGroupNV _ptrc_wglJoinSwapGroupNV
-extern BOOL (CODEGEN_FUNCPTR *_ptrc_wglQueryFrameCountNV)(HDC, GLuint *);
-#define wglQueryFrameCountNV _ptrc_wglQueryFrameCountNV
-extern BOOL (CODEGEN_FUNCPTR *_ptrc_wglQueryMaxSwapGroupsNV)(HDC, GLuint *, GLuint *);
-#define wglQueryMaxSwapGroupsNV _ptrc_wglQueryMaxSwapGroupsNV
-extern BOOL (CODEGEN_FUNCPTR *_ptrc_wglQuerySwapGroupNV)(HDC, GLuint *, GLuint *);
-#define wglQuerySwapGroupNV _ptrc_wglQuerySwapGroupNV
-extern BOOL (CODEGEN_FUNCPTR *_ptrc_wglResetFrameCountNV)(HDC);
-#define wglResetFrameCountNV _ptrc_wglResetFrameCountNV
-#endif /*WGL_NV_swap_group*/ 
-
-enum wgl_LoadStatus
-{
-	wgl_LOAD_FAILED = 0,
-	wgl_LOAD_SUCCEEDED = 1
-};
-
-int wgl_LoadFunctions(HDC hdc);
-
-
-#ifdef __cplusplus
-}
-#endif /*__cplusplus*/
-
-#endif /* POINTER_C_GENERATED_HEADER_WINDOWSGL_H */
--- a/libobs-opengl/gl-cocoa.m
+++ b/libobs-opengl/gl-cocoa.m
@@ -119,7 +119,7 @@ struct gl_platform *gl_platform_create(device_t device,

 	[plat->context makeCurrentContext];

-	if (!ogl_LoadFunctions())
+	if (!gladLoadGL())
 		goto fail;

 	return plat;
--- a/libobs-opengl/gl-subsystem.c
+++ b/libobs-opengl/gl-subsystem.c
@@ -73,11 +73,10 @@ static void APIENTRY gl_debug_proc(

 static void gl_enable_debug()
 {
-	 /* Perhaps we should create GLEW contexts? */
-	if (ogl_IsVersionGEQ(4, 3)) {
+	if (GLAD_GL_VERSION_4_3) {
 		glDebugMessageCallback(gl_debug_proc, NULL);
 		gl_enable(GL_DEBUG_OUTPUT);
-	} else if (ogl_ext_ARB_debug_output) {
+	} else if (GLAD_GL_ARB_debug_output) {
 		glDebugMessageCallbackARB(gl_debug_proc, NULL);
 	} else {
 		blog(LOG_DEBUG, "Failed to set GL debug callback as it is "
@@ -90,7 +89,7 @@ static void gl_enable_debug() {}

 static bool gl_init_extensions(struct gs_device* device)
 {
-	if (!ogl_IsVersionGEQ(2, 1)) {
+	if (!GLAD_GL_VERSION_2_1) {
 		blog(LOG_ERROR, "obs-studio requires OpenGL version 2.1 or "
 		                "higher.");
 		return false;
@@ -98,25 +97,25 @@ static bool gl_init_extensions(struct gs_device* device)

 	gl_enable_debug();

-	if (!ogl_IsVersionGEQ(3, 0) && !ogl_ext_ARB_framebuffer_object) {
+	if (!GLAD_GL_VERSION_3_0 && !GLAD_GL_ARB_framebuffer_object) {
 		blog(LOG_ERROR, "OpenGL extension ARB_framebuffer_object "
 		                "is required.");
 		return false;
 	}

-	if (ogl_IsVersionGEQ(3, 2) || ogl_ext_ARB_seamless_cube_map) {
+	if (GLAD_GL_VERSION_3_2 || GLAD_GL_ARB_seamless_cube_map) {
 		gl_enable(GL_TEXTURE_CUBE_MAP_SEAMLESS);
 	}

-	if (!ogl_IsVersionGEQ(4, 1) && !ogl_ext_ARB_separate_shader_objects) {
+	if (!GLAD_GL_VERSION_4_1 && !GLAD_GL_ARB_separate_shader_objects) {
 		blog(LOG_ERROR, "OpenGL extension ARB_separate_shader_objects "
 		                "is required.");
 		return false;
 	}

-	if (ogl_IsVersionGEQ(4, 3) || ogl_ext_ARB_copy_image)
+	if (GLAD_GL_VERSION_4_3 || GLAD_GL_ARB_copy_image)
 		device->copy_type = COPY_TYPE_ARB;
-	else if (ogl_ext_NV_copy_image)
+	else if (GLAD_GL_NV_copy_image)
 		device->copy_type = COPY_TYPE_NV;
 	else
 		device->copy_type = COPY_TYPE_FBO_BLIT;
--- a/libobs-opengl/gl-subsystem.h
+++ b/libobs-opengl/gl-subsystem.h
@@ -23,7 +23,7 @@
 #include <graphics/device-exports.h>
 #include <graphics/matrix4.h>

-#include "GL/gl_obs.h"
+#include <glad/glad.h>

 #include "gl-helpers.h"

--- a/libobs-opengl/gl-windows.c
+++ b/libobs-opengl/gl-windows.c
@@ -20,7 +20,7 @@

 #include <util/darray.h>
 #include "gl-subsystem.h"
-#include "GL/wgl_obs.h"
+#include <glad/glad_wgl.h>

 /* Basically swapchain-specific information.  Fortunately for windows this is
 * super basic stuff */
@@ -165,7 +165,7 @@ static const int attribs[] =
 static inline HGLRC gl_init_context(HDC hdc)
 {
 #ifdef _DEBUG
-	if (wgl_ext_ARB_create_context) {
+	if (GLAD_WGL_ARB_create_context) {
 		HGLRC hglrc = wglCreateContextAttribsARB(hdc, 0, attribs);
 		if (!hglrc) {
 			blog(LOG_ERROR, "wglCreateContextAttribsARB failed, %u",
@@ -237,22 +237,22 @@ static inline void required_extension_error(const char *extension)

 static bool gl_init_extensions(HDC hdc)
 {
-	if (!wgl_LoadFunctions(hdc)) {
+	if (!gladLoadWGL(hdc)) {
 		blog(LOG_ERROR, "Failed to load WGL entry functions.");
 		return false;
 	}

-	if (!wgl_ext_ARB_pixel_format) {
+	if (!GLAD_WGL_ARB_pixel_format) {
 		required_extension_error("ARB_pixel_format");
 		return false;
 	}

-	if (!wgl_ext_ARB_create_context) {
+	if (!GLAD_WGL_ARB_create_context) {
 		required_extension_error("ARB_create_context");
 		return false;
 	}

-	if (!wgl_ext_ARB_create_context_profile) {
+	if (!GLAD_WGL_ARB_create_context_profile) {
 		required_extension_error("ARB_create_context_profile");
 		return false;
 	}
@@ -400,7 +400,7 @@ struct gl_platform *gl_platform_create(device_t device,
 	if (!plat->hrc)
 		goto fail;

-	if (!ogl_LoadFunctions()) {
+	if (!gladLoadGL()) {
 		blog(LOG_ERROR, "Failed to initialize OpenGL entry functions.");
 		goto fail;
 	}
--- a/libobs-opengl/gl-x11.c
+++ b/libobs-opengl/gl-x11.c
@@ -21,7 +21,7 @@

 #include "gl-subsystem.h"

-#include "GL/glx_obs.h"
+#include <glad/glad_glx.h>

 static const int fb_attribs[] = {
 	/* Hardcoded for now... */
@@ -161,7 +161,7 @@ struct gl_platform *gl_platform_create(device_t device,

 	screen = XScreenNumberOfScreen(attrs.screen);

-	if (!glx_LoadFunctions(display, screen)) {
+	if (!gladLoadGLX(display, screen)) {
 		blog(LOG_ERROR, "Unable to load GLX entry functions.");
 		goto fail0;
 	}
@@ -180,7 +180,7 @@ struct gl_platform *gl_platform_create(device_t device,
 		goto fail0;
 	}

-	if (!glx_ext_ARB_create_context) {
+	if (!GLAD_GLX_ARB_create_context) {
 		blog(LOG_ERROR, "ARB_GLX_create_context not supported!");
 		goto fail0;
 	}
@@ -238,7 +238,7 @@ struct gl_platform *gl_platform_create(device_t device,
 		goto fail2;
 	}

-	if (!ogl_LoadFunctions()) {
+	if (!gladLoadGL()) {
 		blog(LOG_ERROR, "Failed to load OpenGL entry functions.");
 		goto fail2;
 	}
--- a/vs/2013/OBS.sln
+++ b/vs/2013/OBS.sln
@@ -27,6 +27,7 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "test-input", "test-input\te
 EndProject
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "libobs-opengl", "libobs-opengl\libobs-opengl.vcxproj", "{B6EAE19B-79BF-4F7C-9E66-976D14B9DC6C}"
 	ProjectSection(ProjectDependencies) = postProject
+		{B9F9CE2C-FAC8-4528-AAFF-0BC3753C7BDA} = {B9F9CE2C-FAC8-4528-AAFF-0BC3753C7BDA}
 		{6F1AC2AE-6424-401A-AF9F-A771E6BEE026} = {6F1AC2AE-6424-401A-AF9F-A771E6BEE026}
 	EndProjectSection
 EndProject
@@ -62,6 +63,8 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "obs-outputs", "obs-outputs\
 		{6F1AC2AE-6424-401A-AF9F-A771E6BEE026} = {6F1AC2AE-6424-401A-AF9F-A771E6BEE026}
 	EndProjectSection
 EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "glad", "glad\glad.vcxproj", "{B9F9CE2C-FAC8-4528-AAFF-0BC3753C7BDA}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Mixed Platforms = Debug|Mixed Platforms
@@ -228,6 +231,18 @@ Global
 		{CDC3B5C9-2BEA-4509-A2A8-6477506010ED}.Release|Win32.Build.0 = Release|Win32
 		{CDC3B5C9-2BEA-4509-A2A8-6477506010ED}.Release|x64.ActiveCfg = Release|x64
 		{CDC3B5C9-2BEA-4509-A2A8-6477506010ED}.Release|x64.Build.0 = Release|x64
+		{B9F9CE2C-FAC8-4528-AAFF-0BC3753C7BDA}.Debug|Mixed Platforms.ActiveCfg = Debug|Win32
+		{B9F9CE2C-FAC8-4528-AAFF-0BC3753C7BDA}.Debug|Mixed Platforms.Build.0 = Debug|Win32
+		{B9F9CE2C-FAC8-4528-AAFF-0BC3753C7BDA}.Debug|Win32.ActiveCfg = Debug|Win32
+		{B9F9CE2C-FAC8-4528-AAFF-0BC3753C7BDA}.Debug|Win32.Build.0 = Debug|Win32
+		{B9F9CE2C-FAC8-4528-AAFF-0BC3753C7BDA}.Debug|x64.ActiveCfg = Debug|x64
+		{B9F9CE2C-FAC8-4528-AAFF-0BC3753C7BDA}.Debug|x64.Build.0 = Debug|x64
+		{B9F9CE2C-FAC8-4528-AAFF-0BC3753C7BDA}.Release|Mixed Platforms.ActiveCfg = Release|Win32
+		{B9F9CE2C-FAC8-4528-AAFF-0BC3753C7BDA}.Release|Mixed Platforms.Build.0 = Release|Win32
+		{B9F9CE2C-FAC8-4528-AAFF-0BC3753C7BDA}.Release|Win32.ActiveCfg = Release|Win32
+		{B9F9CE2C-FAC8-4528-AAFF-0BC3753C7BDA}.Release|Win32.Build.0 = Release|Win32
+		{B9F9CE2C-FAC8-4528-AAFF-0BC3753C7BDA}.Release|x64.ActiveCfg = Release|x64
+		{B9F9CE2C-FAC8-4528-AAFF-0BC3753C7BDA}.Release|x64.Build.0 = Release|x64
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
--- a/vs/2013/glad/glad.vcxproj
+++ b/vs/2013/glad/glad.vcxproj
@@ -0,0 +1,168 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="12.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{B9F9CE2C-FAC8-4528-AAFF-0BC3753C7BDA}</ProjectGuid>
+    <Keyword>Win32Proj</Keyword>
+    <RootNamespace>glad</RootNamespace>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v120</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v120</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v120</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v120</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <LinkIncremental>true</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <LinkIncremental>true</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <LinkIncremental>false</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <LinkIncremental>false</LinkIncremental>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>GLAD_GLAPI_EXPORT_BUILD;WIN32;_DEBUG;_WINDOWS;_USRDLL;GLAD_EXPORTS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalIncludeDirectories>../../../deps/glad/include</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+    <PostBuildEvent>
+      <Command>copy "$(OutDir)$(TargetName)$(TargetExt)" "../../../build/bin/32bit/$(TargetName)$(TargetExt)"</Command>
+    </PostBuildEvent>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <ClCompile>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>GLAD_GLAPI_EXPORT_BUILD;WIN32;_DEBUG;_WINDOWS;_USRDLL;GLAD_EXPORTS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalIncludeDirectories>../../../deps/glad/include</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+    <PostBuildEvent>
+      <Command>copy "$(OutDir)$(TargetName)$(TargetExt)" "../../../build/bin/64bit/$(TargetName)$(TargetExt)"</Command>
+    </PostBuildEvent>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <PreprocessorDefinitions>GLAD_GLAPI_EXPORT_BUILD;WIN32;NDEBUG;_WINDOWS;_USRDLL;GLAD_EXPORTS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalIncludeDirectories>../../../deps/glad/include</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+    </Link>
+    <PostBuildEvent>
+      <Command>copy "$(OutDir)$(TargetName)$(TargetExt)" "../../../build/bin/32bit/$(TargetName)$(TargetExt)"</Command>
+    </PostBuildEvent>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <PreprocessorDefinitions>GLAD_GLAPI_EXPORT_BUILD;WIN32;NDEBUG;_WINDOWS;_USRDLL;GLAD_EXPORTS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalIncludeDirectories>../../../deps/glad/include</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+    </Link>
+    <PostBuildEvent>
+      <Command>copy "$(OutDir)$(TargetName)$(TargetExt)" "../../../build/bin/64bit/$(TargetName)$(TargetExt)"</Command>
+    </PostBuildEvent>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="..\..\..\deps\glad\src\glad.c" />
+    <ClCompile Include="..\..\..\deps\glad\src\glad_wgl.c" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\..\..\deps\glad\include\glad\glad.h" />
+    <ClInclude Include="..\..\..\deps\glad\include\glad\glad_wgl.h" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>
--- a/vs/2013/glad/glad.vcxproj.filters
+++ b/vs/2013/glad/glad.vcxproj.filters
@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="Source Files">
+      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
+      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
+    </Filter>
+    <Filter Include="Header Files">
+      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
+      <Extensions>h;hh;hpp;hxx;hm;inl;inc;xsd</Extensions>
+    </Filter>
+    <Filter Include="Resource Files">
+      <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
+      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\..\..\deps\glad\src\glad_wgl.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\deps\glad\src\glad.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\..\..\deps\glad\include\glad\glad.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\deps\glad\include\glad\glad_wgl.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+  </ItemGroup>
+</Project>
--- a/vs/2013/libobs-opengl/libobs-opengl.vcxproj
+++ b/vs/2013/libobs-opengl/libobs-opengl.vcxproj
@@ -85,14 +85,14 @@
      <WarningLevel>Level3</WarningLevel>
      <Optimization>Disabled</Optimization>
      <PreprocessorDefinitions>WIN32;_DEBUG;_WINDOWS;_USRDLL;LIBOBSOPENGL_EXPORTS;GLEW_STATIC;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <AdditionalIncludeDirectories>../../../libobs</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>../../../libobs;../../../deps/glad/include</AdditionalIncludeDirectories>
      <ExceptionHandling>false</ExceptionHandling>
    </ClCompile>
    <Link>
      <SubSystem>Windows</SubSystem>
      <GenerateDebugInformation>true</GenerateDebugInformation>
      <AdditionalLibraryDirectories>$(OutDir);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
-      <AdditionalDependencies>opengl32.lib;libobs.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalDependencies>opengl32.lib;libobs.lib;glad.lib;%(AdditionalDependencies)</AdditionalDependencies>
    </Link>
    <PostBuildEvent>
      <Command>copy "$(OutDir)$(TargetName)$(TargetExt)" "../../../build/bin/32bit/$(TargetName)$(TargetExt)"</Command>
@@ -105,14 +105,14 @@
      <WarningLevel>Level3</WarningLevel>
      <Optimization>Disabled</Optimization>
      <PreprocessorDefinitions>WIN32;_DEBUG;_WINDOWS;_USRDLL;LIBOBSOPENGL_EXPORTS;GLEW_STATIC;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <AdditionalIncludeDirectories>../../../libobs</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>../../../libobs;../../../deps/glad/include</AdditionalIncludeDirectories>
      <ExceptionHandling>false</ExceptionHandling>
    </ClCompile>
    <Link>
      <SubSystem>Windows</SubSystem>
      <GenerateDebugInformation>true</GenerateDebugInformation>
      <AdditionalLibraryDirectories>$(OutDir);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
-      <AdditionalDependencies>opengl32.lib;libobs.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalDependencies>opengl32.lib;libobs.lib;glad.lib;%(AdditionalDependencies)</AdditionalDependencies>
    </Link>
    <PostBuildEvent>
      <Command>copy "$(OutDir)$(TargetName)$(TargetExt)" "../../../build/bin/64bit/$(TargetName)$(TargetExt)"</Command>
@@ -127,7 +127,7 @@
      <FunctionLevelLinking>true</FunctionLevelLinking>
      <IntrinsicFunctions>true</IntrinsicFunctions>
      <PreprocessorDefinitions>WIN32;NDEBUG;_WINDOWS;_USRDLL;LIBOBSOPENGL_EXPORTS;GLEW_STATIC;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <AdditionalIncludeDirectories>../../../libobs</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>../../../libobs;../../../deps/glad/include</AdditionalIncludeDirectories>
      <ExceptionHandling>false</ExceptionHandling>
    </ClCompile>
    <Link>
@@ -136,7 +136,7 @@
      <EnableCOMDATFolding>true</EnableCOMDATFolding>
      <OptimizeReferences>true</OptimizeReferences>
      <AdditionalLibraryDirectories>$(OutDir);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
-      <AdditionalDependencies>opengl32.lib;libobs.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalDependencies>opengl32.lib;libobs.lib;glad.lib;%(AdditionalDependencies)</AdditionalDependencies>
    </Link>
    <PostBuildEvent>
      <Command>copy "$(OutDir)$(TargetName)$(TargetExt)" "../../../build/bin/32bit/$(TargetName)$(TargetExt)"</Command>
@@ -151,7 +151,7 @@
      <FunctionLevelLinking>true</FunctionLevelLinking>
      <IntrinsicFunctions>true</IntrinsicFunctions>
      <PreprocessorDefinitions>WIN32;NDEBUG;_WINDOWS;_USRDLL;LIBOBSOPENGL_EXPORTS;GLEW_STATIC;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <AdditionalIncludeDirectories>../../../libobs</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>../../../libobs;../../../deps/glad/include</AdditionalIncludeDirectories>
      <ExceptionHandling>false</ExceptionHandling>
    </ClCompile>
    <Link>
@@ -160,14 +160,13 @@
      <EnableCOMDATFolding>true</EnableCOMDATFolding>
      <OptimizeReferences>true</OptimizeReferences>
      <AdditionalLibraryDirectories>$(OutDir);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
-      <AdditionalDependencies>opengl32.lib;libobs.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalDependencies>opengl32.lib;libobs.lib;glad.lib;%(AdditionalDependencies)</AdditionalDependencies>
    </Link>
    <PostBuildEvent>
      <Command>copy "$(OutDir)$(TargetName)$(TargetExt)" "../../../build/bin/64bit/$(TargetName)$(TargetExt)"</Command>
    </PostBuildEvent>
  </ItemDefinitionGroup>
  <ItemGroup>
-    <ClInclude Include="..\..\..\libobs-opengl\gl-exports.h" />
    <ClInclude Include="..\..\..\libobs-opengl\gl-helpers.h" />
    <ClInclude Include="..\..\..\libobs-opengl\gl-shaderparser.h" />
    <ClInclude Include="..\..\..\libobs-opengl\gl-subsystem.h" />
@@ -184,10 +183,8 @@
    <ClCompile Include="..\..\..\libobs-opengl\gl-vertexbuffer.c" />
    <ClCompile Include="..\..\..\libobs-opengl\gl-windows.c" />
    <ClCompile Include="..\..\..\libobs-opengl\gl-zstencil.c" />
-    <ClCompile Include="..\..\..\libobs-opengl\GL\gl_obs.c" />
-    <ClCompile Include="..\..\..\libobs-opengl\GL\wgl_obs.c" />
  </ItemGroup>
  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
  <ImportGroup Label="ExtensionTargets">
  </ImportGroup>
-</Project>
+</Project>
--- a/vs/2013/libobs-opengl/libobs-opengl.vcxproj.filters
+++ b/vs/2013/libobs-opengl/libobs-opengl.vcxproj.filters
@@ -18,9 +18,6 @@
    <ClInclude Include="..\..\..\libobs-opengl\gl-subsystem.h">
      <Filter>Header Files</Filter>
    </ClInclude>
-    <ClInclude Include="..\..\..\libobs-opengl\gl-exports.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
    <ClInclude Include="..\..\..\libobs-opengl\gl-helpers.h">
      <Filter>Header Files</Filter>
    </ClInclude>
@@ -62,11 +59,5 @@
    <ClCompile Include="..\..\..\libobs-opengl\gl-indexbuffer.c">
      <Filter>Source Files</Filter>
    </ClCompile>
-    <ClCompile Include="..\..\..\libobs-opengl\GL\gl_obs.c">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="..\..\..\libobs-opengl\GL\wgl_obs.c">
-      <Filter>Source Files</Filter>
-    </ClCompile>
  </ItemGroup>
-</Project>
+</Project>