dep/glad: Update to v2.0.5

CMakeLists.txt

@@ -46,7 +46,6 @@ endif()
 
 # Everything except Windows/Mac use EGL.
 if(ENABLE_OPENGL AND (LINUX OR FREEBSD OR ANDROID))
-  find_package(EGL REQUIRED)
   set(ENABLE_EGL TRUE)
 endif()
 

CMakeModules/FindEGL.cmake

@@ -1,172 +0,0 @@
-#.rst:
-# FindEGL
-# -------
-#
-# Try to find EGL.
-#
-# This will define the following variables:
-#
-# ``EGL_FOUND``
-#     True if (the requested version of) EGL is available
-# ``EGL_VERSION``
-#     The version of EGL; note that this is the API version defined in the
-#     headers, rather than the version of the implementation (eg: Mesa)
-# ``EGL_LIBRARIES``
-#     This can be passed to target_link_libraries() instead of the ``EGL::EGL``
-#     target
-# ``EGL_INCLUDE_DIRS``
-#     This should be passed to target_include_directories() if the target is not
-#     used for linking
-# ``EGL_DEFINITIONS``
-#     This should be passed to target_compile_options() if the target is not
-#     used for linking
-#
-# If ``EGL_FOUND`` is TRUE, it will also define the following imported target:
-#
-# ``EGL::EGL``
-#     The EGL library
-#
-# In general we recommend using the imported target, as it is easier to use.
-# Bear in mind, however, that if the target is in the link interface of an
-# exported library, it must be made available by the package config file.
-#
-# Since pre-1.0.0.
-
-#=============================================================================
-# Copyright 2014 Alex Merry <alex.merry@kde.org>
-# Copyright 2014 Martin Gräßlin <mgraesslin@kde.org>
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions
-# are met:
-#
-# 1. Redistributions of source code must retain the copyright
-#    notice, this list of conditions and the following disclaimer.
-# 2. Redistributions in binary form must reproduce the copyright
-#    notice, this list of conditions and the following disclaimer in the
-#    documentation and/or other materials provided with the distribution.
-# 3. The name of the author may not be used to endorse or promote products
-#    derived from this software without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
-# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
-# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
-# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
-# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
-# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-#=============================================================================
-
-include(${CMAKE_CURRENT_LIST_DIR}/ECMFindModuleHelpersStub.cmake)
-include(CheckCXXSourceCompiles)
-include(CMakePushCheckState)
-
-ecm_find_package_version_check(EGL)
-
-# Use pkg-config to get the directories and then use these values
-# in the FIND_PATH() and FIND_LIBRARY() calls
-find_package(PkgConfig)
-pkg_check_modules(PKG_EGL QUIET egl)
-
-set(EGL_DEFINITIONS ${PKG_EGL_CFLAGS_OTHER})
-
-find_path(EGL_INCLUDE_DIR
-    NAMES
-        EGL/egl.h
-    HINTS
-        ${PKG_EGL_INCLUDE_DIRS}
-)
-find_library(EGL_LIBRARY
-    NAMES
-        EGL
-    HINTS
-        ${PKG_EGL_LIBRARY_DIRS}
-)
-
-# NB: We do *not* use the version information from pkg-config, as that
-#     is the implementation version (eg: the Mesa version)
-if(EGL_INCLUDE_DIR)
-    # egl.h has defines of the form EGL_VERSION_x_y for each supported
-    # version; so the header for EGL 1.1 will define EGL_VERSION_1_0 and
-    # EGL_VERSION_1_1.  Finding the highest supported version involves
-    # finding all these defines and selecting the highest numbered.
-    file(READ "${EGL_INCLUDE_DIR}/EGL/egl.h" _EGL_header_contents)
-    string(REGEX MATCHALL
-        "[ \t]EGL_VERSION_[0-9_]+"
-        _EGL_version_lines
-        "${_EGL_header_contents}"
-    )
-    unset(_EGL_header_contents)
-    foreach(_EGL_version_line ${_EGL_version_lines})
-        string(REGEX REPLACE
-            "[ \t]EGL_VERSION_([0-9_]+)"
-            "\\1"
-            _version_candidate
-            "${_EGL_version_line}"
-        )
-        string(REPLACE "_" "." _version_candidate "${_version_candidate}")
-        if(NOT DEFINED EGL_VERSION OR EGL_VERSION VERSION_LESS _version_candidate)
-            set(EGL_VERSION "${_version_candidate}")
-        endif()
-    endforeach()
-    unset(_EGL_version_lines)
-endif()
-
-cmake_push_check_state(RESET)
-list(APPEND CMAKE_REQUIRED_LIBRARIES "${EGL_LIBRARY}")
-list(APPEND CMAKE_REQUIRED_INCLUDES "${EGL_INCLUDE_DIR}")
-
-check_cxx_source_compiles("
-#include <EGL/egl.h>
-
-int main(int argc, char *argv[]) {
-    EGLint x = 0; EGLDisplay dpy = 0; EGLContext ctx = 0;
-    eglDestroyContext(dpy, ctx);
-}" HAVE_EGL)
-
-cmake_pop_check_state()
-
-set(required_vars EGL_INCLUDE_DIR HAVE_EGL)
-if(NOT EMSCRIPTEN)
-    list(APPEND required_vars EGL_LIBRARY)
-endif()
-
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(EGL
-    FOUND_VAR
-        EGL_FOUND
-    REQUIRED_VARS
-        ${required_vars}
-    VERSION_VAR
-        EGL_VERSION
-)
-
-if(EGL_FOUND AND NOT TARGET EGL::EGL)
-    if (EMSCRIPTEN)
-        add_library(EGL::EGL INTERFACE IMPORTED)
-        # Nothing further to be done, system include paths have headers and linkage is implicit.
-    else()
-        add_library(EGL::EGL UNKNOWN IMPORTED)
-        set_target_properties(EGL::EGL PROPERTIES
-            IMPORTED_LOCATION "${EGL_LIBRARY}"
-            INTERFACE_COMPILE_OPTIONS "${EGL_DEFINITIONS}"
-            INTERFACE_INCLUDE_DIRECTORIES "${EGL_INCLUDE_DIR}"
-        )
-    endif()
-endif()
-
-mark_as_advanced(EGL_LIBRARY EGL_INCLUDE_DIR HAVE_EGL)
-
-# compatibility variables
-set(EGL_LIBRARIES ${EGL_LIBRARY})
-set(EGL_INCLUDE_DIRS ${EGL_INCLUDE_DIR})
-set(EGL_VERSION_STRING ${EGL_VERSION})
-
-include(FeatureSummary)
-set_package_properties(EGL PROPERTIES
-    URL "https://www.khronos.org/egl/"
-    DESCRIPTION "A platform-agnostic mechanism for creating rendering surfaces for use with other graphics libraries, such as OpenGL|ES and OpenVG."
-)

dep/glad/CMakeLists.txt

@@ -1,5 +1,7 @@
 set(SRCS
-    src/glad.c
+  include/glad/gl.h
+  include/KHR/khrplatform.h
+  src/gl.c
 )
 
 # Linking as a static library breaks on macOS, see https://github.com/libigl/libigl/issues/751
@@ -9,18 +11,20 @@ else()
   add_library(glad ${SRCS})
 endif()
 
-target_include_directories(glad PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/include")
+target_include_directories(glad PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/include")
-target_include_directories(glad INTERFACE "${CMAKE_CURRENT_SOURCE_DIR}/include")
 target_link_libraries(glad PRIVATE Threads::Threads "${CMAKE_DL_LIBS}")
 
 if(WIN32)
-  target_sources(glad PRIVATE src/glad_wgl.c)
+  target_sources(glad PRIVATE
+    include/glad/wgl.h
+    src/wgl.c
+  )
 else()
   if(ENABLE_EGL)
-    target_sources(glad PRIVATE src/glad_egl.c)
+    target_sources(glad PRIVATE
-    target_link_libraries(glad PRIVATE EGL::EGL)
+      include/EGL/eglplatform.h
-  endif()
+      include/glad/egl.h
-  if(ENABLE_X11)
+      src/egl.c
-    target_sources(glad PRIVATE src/glad_glx.c)
+    )
   endif()
 endif()

dep/glad/glad.vcxproj

@@ -1,29 +1,33 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <Import Project="..\msvc\vsprops\Configurations.props" />
-
-  <ItemGroup>
-    <ClCompile Include="src\glad.c" />
-    <ClCompile Include="src\glad_wgl.c" />
-  </ItemGroup>
-  <ItemGroup>
-    <ClInclude Include="include\glad.h" />
-    <ClInclude Include="include\glad_wgl.h" />
-    <ClInclude Include="include\khrplatform.h" />
-  </ItemGroup>
-
   <PropertyGroup Label="Globals">
     <ProjectGuid>{43540154-9E1E-409C-834F-B84BE5621388}</ProjectGuid>
   </PropertyGroup>
-
+  <ItemGroup>
+    <ClCompile Include="src\egl.c">
+      <ExcludedFromBuild>true</ExcludedFromBuild>
+    </ClCompile>
+    <ClCompile Include="src\gl.c" />
+    <ClCompile Include="src\wgl.c" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="include\EGL\eglplatform.h">
+      <ExcludedFromBuild>true</ExcludedFromBuild>
+    </ClInclude>
+    <ClInclude Include="include\glad\egl.h">
+      <ExcludedFromBuild>true</ExcludedFromBuild>
+    </ClInclude>
+    <ClInclude Include="include\glad\gl.h" />
+    <ClInclude Include="include\glad\wgl.h" />
+    <ClInclude Include="include\KHR\khrplatform.h" />
+  </ItemGroup>
   <Import Project="..\msvc\vsprops\StaticLibrary.props" />
-
   <ItemDefinitionGroup>
     <ClCompile>
       <WarningLevel>TurnOffAllWarnings</WarningLevel>
       <AdditionalIncludeDirectories>$(ProjectDir)include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
     </ClCompile>
   </ItemDefinitionGroup>
-
   <Import Project="..\msvc\vsprops\Targets.props" />
 </Project>

dep/glad/glad.vcxproj.filters

@@ -1,12 +1,15 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <ItemGroup>
-    <ClCompile Include="src\glad.c" />
+    <ClCompile Include="src\gl.c" />
-    <ClCompile Include="src\glad_wgl.c" />
+    <ClCompile Include="src\wgl.c" />
+    <ClCompile Include="src\egl.c" />
   </ItemGroup>
   <ItemGroup>
-    <ClInclude Include="include\khrplatform.h" />
+    <ClInclude Include="include\EGL\eglplatform.h" />
-    <ClInclude Include="include\glad.h" />
+    <ClInclude Include="include\glad\wgl.h" />
-    <ClInclude Include="include\glad_wgl.h" />
+    <ClInclude Include="include\glad\egl.h" />
+    <ClInclude Include="include\glad\gl.h" />
+    <ClInclude Include="include\KHR\khrplatform.h" />
   </ItemGroup>
 </Project>

dep/glad/include/EGL/eglplatform.h

@@ -0,0 +1,175 @@
+#ifndef __eglplatform_h_
+#define __eglplatform_h_
+
+/*
+** Copyright 2007-2020 The Khronos Group Inc.
+** SPDX-License-Identifier: Apache-2.0
+*/
+
+/* Platform-specific types and definitions for egl.h
+ *
+ * Adopters may modify khrplatform.h and this file to suit their platform.
+ * You are encouraged to submit all modifications to the Khronos group so that
+ * they can be included in future versions of this file.  Please submit changes
+ * by filing an issue or pull request on the public Khronos EGL Registry, at
+ * https://www.github.com/KhronosGroup/EGL-Registry/
+ */
+
+#include <KHR/khrplatform.h>
+
+/* Macros used in EGL function prototype declarations.
+ *
+ * EGL functions should be prototyped as:
+ *
+ * EGLAPI return-type EGLAPIENTRY eglFunction(arguments);
+ * typedef return-type (EXPAPIENTRYP PFNEGLFUNCTIONPROC) (arguments);
+ *
+ * KHRONOS_APICALL and KHRONOS_APIENTRY are defined in KHR/khrplatform.h
+ */
+
+#ifndef EGLAPI
+#define EGLAPI KHRONOS_APICALL
+#endif
+
+#ifndef EGLAPIENTRY
+#define EGLAPIENTRY  KHRONOS_APIENTRY
+#endif
+#define EGLAPIENTRYP EGLAPIENTRY*
+
+/* The types NativeDisplayType, NativeWindowType, and NativePixmapType
+ * are aliases of window-system-dependent types, such as X Display * or
+ * Windows Device Context. They must be defined in platform-specific
+ * code below. The EGL-prefixed versions of Native*Type are the same
+ * types, renamed in EGL 1.3 so all types in the API start with "EGL".
+ *
+ * Khronos STRONGLY RECOMMENDS that you use the default definitions
+ * provided below, since these changes affect both binary and source
+ * portability of applications using EGL running on different EGL
+ * implementations.
+ */
+
+#if defined(EGL_NO_PLATFORM_SPECIFIC_TYPES)
+
+typedef void *EGLNativeDisplayType;
+typedef void *EGLNativePixmapType;
+typedef void *EGLNativeWindowType;
+
+#elif defined(_WIN32) || defined(__VC32__) && !defined(__CYGWIN__) && !defined(__SCITECH_SNAP__) /* Win32 and WinCE */
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN 1
+#endif
+#include <windows.h>
+
+typedef HDC     EGLNativeDisplayType;
+typedef HBITMAP EGLNativePixmapType;
+typedef HWND    EGLNativeWindowType;
+
+#elif defined(__QNX__)
+
+typedef khronos_uintptr_t      EGLNativeDisplayType;
+typedef struct _screen_pixmap* EGLNativePixmapType;  /* screen_pixmap_t */
+typedef struct _screen_window* EGLNativeWindowType;  /* screen_window_t */
+
+#elif defined(__EMSCRIPTEN__)
+
+typedef int EGLNativeDisplayType;
+typedef int EGLNativePixmapType;
+typedef int EGLNativeWindowType;
+
+#elif defined(__WINSCW__) || defined(__SYMBIAN32__)  /* Symbian */
+
+typedef int   EGLNativeDisplayType;
+typedef void *EGLNativePixmapType;
+typedef void *EGLNativeWindowType;
+
+#elif defined(WL_EGL_PLATFORM)
+
+typedef struct wl_display     *EGLNativeDisplayType;
+typedef struct wl_egl_pixmap  *EGLNativePixmapType;
+typedef struct wl_egl_window  *EGLNativeWindowType;
+
+#elif defined(__GBM__)
+
+typedef struct gbm_device  *EGLNativeDisplayType;
+typedef struct gbm_bo      *EGLNativePixmapType;
+typedef void               *EGLNativeWindowType;
+
+#elif defined(__ANDROID__) || defined(ANDROID)
+
+struct ANativeWindow;
+struct egl_native_pixmap_t;
+
+typedef void*                           EGLNativeDisplayType;
+typedef struct egl_native_pixmap_t*     EGLNativePixmapType;
+typedef struct ANativeWindow*           EGLNativeWindowType;
+
+#elif defined(USE_OZONE)
+
+typedef intptr_t EGLNativeDisplayType;
+typedef intptr_t EGLNativePixmapType;
+typedef intptr_t EGLNativeWindowType;
+
+#elif defined(USE_X11)
+
+/* X11 (tentative)  */
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+
+typedef Display *EGLNativeDisplayType;
+typedef Pixmap   EGLNativePixmapType;
+typedef Window   EGLNativeWindowType;
+
+#elif defined(__unix__)
+
+typedef void             *EGLNativeDisplayType;
+typedef khronos_uintptr_t EGLNativePixmapType;
+typedef khronos_uintptr_t EGLNativeWindowType;
+
+#elif defined(__APPLE__)
+
+typedef int   EGLNativeDisplayType;
+typedef void *EGLNativePixmapType;
+typedef void *EGLNativeWindowType;
+
+#elif defined(__HAIKU__)
+
+#include <kernel/image.h>
+
+typedef void              *EGLNativeDisplayType;
+typedef khronos_uintptr_t  EGLNativePixmapType;
+typedef khronos_uintptr_t  EGLNativeWindowType;
+
+#elif defined(__Fuchsia__)
+
+typedef void              *EGLNativeDisplayType;
+typedef khronos_uintptr_t  EGLNativePixmapType;
+typedef khronos_uintptr_t  EGLNativeWindowType;
+
+#else
+#error "Platform not recognized"
+#endif
+
+/* EGL 1.2 types, renamed for consistency in EGL 1.3 */
+typedef EGLNativeDisplayType NativeDisplayType;
+typedef EGLNativePixmapType  NativePixmapType;
+typedef EGLNativeWindowType  NativeWindowType;
+
+
+/* Define EGLint. This must be a signed integral type large enough to contain
+ * all legal attribute names and values passed into and out of EGL, whether
+ * their type is boolean, bitmask, enumerant (symbolic constant), integer,
+ * handle, or other.  While in general a 32-bit integer will suffice, if
+ * handles are 64 bit types, then EGLint should be defined as a signed 64-bit
+ * integer type.
+ */
+typedef khronos_int32_t EGLint;
+
+
+/* C++ / C typecast macros for special EGL handle values */
+#if defined(__cplusplus)
+#define EGL_CAST(type, value) (static_cast<type>(value))
+#else
+#define EGL_CAST(type, value) ((type) (value))
+#endif
+
+#endif /* __eglplatform_h */

dep/glad/include/KHR/khrplatform.h

@@ -90,12 +90,20 @@
  *                                  int arg2) KHRONOS_APIATTRIBUTES;
  */
 
+#if defined(__SCITECH_SNAP__) && !defined(KHRONOS_STATIC)
+#   define KHRONOS_STATIC 1
+#endif
+
 /*-------------------------------------------------------------------------
  * Definition of KHRONOS_APICALL
  *-------------------------------------------------------------------------
  * This precedes the return type of the function in the function prototype.
  */
-#if defined(_WIN32) && !defined(__SCITECH_SNAP__)
+#if defined(KHRONOS_STATIC)
+    /* If the preprocessor constant KHRONOS_STATIC is defined, make the
+     * header compatible with static linking. */
+#   define KHRONOS_APICALL
+#elif defined(_WIN32)
 #   define KHRONOS_APICALL __declspec(dllimport)
 #elif defined (__SYMBIAN32__)
 #   define KHRONOS_APICALL IMPORT_C
@@ -145,6 +153,20 @@ typedef int64_t                 khronos_int64_t;
 typedef uint64_t                khronos_uint64_t;
 #define KHRONOS_SUPPORT_INT64   1
 #define KHRONOS_SUPPORT_FLOAT   1
+/*
+ * To support platform where unsigned long cannot be used interchangeably with
+ * inptr_t (e.g. CHERI-extended ISAs), we can use the stdint.h intptr_t.
+ * Ideally, we could just use (u)intptr_t everywhere, but this could result in
+ * ABI breakage if khronos_uintptr_t is changed from unsigned long to
+ * unsigned long long or similar (this results in different C++ name mangling).
+ * To avoid changes for existing platforms, we restrict usage of intptr_t to
+ * platforms where the size of a pointer is larger than the size of long.
+ */
+#if defined(__SIZEOF_LONG__) && defined(__SIZEOF_POINTER__)
+#if __SIZEOF_POINTER__ > __SIZEOF_LONG__
+#define KHRONOS_USE_INTPTR_T
+#endif
+#endif
 
 #elif defined(__VMS ) || defined(__sgi)
 
@@ -227,14 +249,21 @@ typedef unsigned short int     khronos_uint16_t;
  * pointers are 64 bits, but 'long' is still 32 bits. Win64 appears
  * to be the only LLP64 architecture in current use.
  */
-#ifdef _WIN64
+#ifdef KHRONOS_USE_INTPTR_T
+typedef intptr_t               khronos_intptr_t;
+typedef uintptr_t              khronos_uintptr_t;
+#elif defined(_WIN64)
 typedef signed   long long int khronos_intptr_t;
 typedef unsigned long long int khronos_uintptr_t;
-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;
+#endif
+
+#if defined(_WIN64)
+typedef signed   long long int khronos_ssize_t;
+typedef unsigned long long int khronos_usize_t;
+#else
 typedef signed   long  int     khronos_ssize_t;
 typedef unsigned long  int     khronos_usize_t;
 #endif

dep/glad/src/glad_egl.c

@@ -1,576 +0,0 @@
-/*
-
-    EGL loader generated by glad 0.1.33 on Sun May  3 16:34:53 2020.
-
-    Language/Generator: C/C++
-    Specification: egl
-    APIs: egl=1.5
-    Profile: -
-    Extensions:
-        EGL_ANDROID_GLES_layers,
-        EGL_ANDROID_blob_cache,
-        EGL_ANDROID_create_native_client_buffer,
-        EGL_ANDROID_framebuffer_target,
-        EGL_ANDROID_front_buffer_auto_refresh,
-        EGL_ANDROID_get_frame_timestamps,
-        EGL_ANDROID_get_native_client_buffer,
-        EGL_ANDROID_image_native_buffer,
-        EGL_ANDROID_native_fence_sync,
-        EGL_ANDROID_presentation_time,
-        EGL_ANDROID_recordable,
-        EGL_ANGLE_d3d_share_handle_client_buffer,
-        EGL_ANGLE_device_d3d,
-        EGL_ANGLE_query_surface_pointer,
-        EGL_ANGLE_surface_d3d_texture_2d_share_handle,
-        EGL_ANGLE_window_fixed_size,
-        EGL_ARM_image_format,
-        EGL_ARM_implicit_external_sync,
-        EGL_ARM_pixmap_multisample_discard,
-        EGL_EXT_bind_to_front,
-        EGL_EXT_buffer_age,
-        EGL_EXT_client_extensions,
-        EGL_EXT_client_sync,
-        EGL_EXT_compositor,
-        EGL_EXT_create_context_robustness,
-        EGL_EXT_device_base,
-        EGL_EXT_device_drm,
-        EGL_EXT_device_enumeration,
-        EGL_EXT_device_openwf,
-        EGL_EXT_device_query,
-        EGL_EXT_gl_colorspace_bt2020_linear,
-        EGL_EXT_gl_colorspace_bt2020_pq,
-        EGL_EXT_gl_colorspace_display_p3,
-        EGL_EXT_gl_colorspace_display_p3_linear,
-        EGL_EXT_gl_colorspace_display_p3_passthrough,
-        EGL_EXT_gl_colorspace_scrgb,
-        EGL_EXT_gl_colorspace_scrgb_linear,
-        EGL_EXT_image_dma_buf_import,
-        EGL_EXT_image_dma_buf_import_modifiers,
-        EGL_EXT_image_gl_colorspace,
-        EGL_EXT_image_implicit_sync_control,
-        EGL_EXT_multiview_window,
-        EGL_EXT_output_base,
-        EGL_EXT_output_drm,
-        EGL_EXT_output_openwf,
-        EGL_EXT_pixel_format_float,
-        EGL_EXT_platform_base,
-        EGL_EXT_platform_device,
-        EGL_EXT_platform_wayland,
-        EGL_EXT_platform_x11,
-        EGL_EXT_protected_content,
-        EGL_EXT_protected_surface,
-        EGL_EXT_stream_consumer_egloutput,
-        EGL_EXT_surface_CTA861_3_metadata,
-        EGL_EXT_surface_SMPTE2086_metadata,
-        EGL_EXT_swap_buffers_with_damage,
-        EGL_EXT_sync_reuse,
-        EGL_EXT_yuv_surface,
-        EGL_HI_clientpixmap,
-        EGL_HI_colorformats,
-        EGL_IMG_context_priority,
-        EGL_IMG_image_plane_attribs,
-        EGL_KHR_cl_event,
-        EGL_KHR_cl_event2,
-        EGL_KHR_client_get_all_proc_addresses,
-        EGL_KHR_config_attribs,
-        EGL_KHR_context_flush_control,
-        EGL_KHR_create_context,
-        EGL_KHR_create_context_no_error,
-        EGL_KHR_debug,
-        EGL_KHR_display_reference,
-        EGL_KHR_fence_sync,
-        EGL_KHR_get_all_proc_addresses,
-        EGL_KHR_gl_colorspace,
-        EGL_KHR_gl_renderbuffer_image,
-        EGL_KHR_gl_texture_2D_image,
-        EGL_KHR_gl_texture_3D_image,
-        EGL_KHR_gl_texture_cubemap_image,
-        EGL_KHR_image,
-        EGL_KHR_image_base,
-        EGL_KHR_image_pixmap,
-        EGL_KHR_lock_surface,
-        EGL_KHR_lock_surface2,
-        EGL_KHR_lock_surface3,
-        EGL_KHR_mutable_render_buffer,
-        EGL_KHR_no_config_context,
-        EGL_KHR_partial_update,
-        EGL_KHR_platform_android,
-        EGL_KHR_platform_gbm,
-        EGL_KHR_platform_wayland,
-        EGL_KHR_platform_x11,
-        EGL_KHR_reusable_sync,
-        EGL_KHR_stream,
-        EGL_KHR_stream_attrib,
-        EGL_KHR_stream_consumer_gltexture,
-        EGL_KHR_stream_cross_process_fd,
-        EGL_KHR_stream_fifo,
-        EGL_KHR_stream_producer_aldatalocator,
-        EGL_KHR_stream_producer_eglsurface,
-        EGL_KHR_surfaceless_context,
-        EGL_KHR_swap_buffers_with_damage,
-        EGL_KHR_vg_parent_image,
-        EGL_KHR_wait_sync,
-        EGL_MESA_drm_image,
-        EGL_MESA_image_dma_buf_export,
-        EGL_MESA_platform_gbm,
-        EGL_MESA_platform_surfaceless,
-        EGL_MESA_query_driver,
-        EGL_NOK_swap_region,
-        EGL_NOK_swap_region2,
-        EGL_NOK_texture_from_pixmap,
-        EGL_NV_3dvision_surface,
-        EGL_NV_context_priority_realtime,
-        EGL_NV_coverage_sample,
-        EGL_NV_coverage_sample_resolve,
-        EGL_NV_cuda_event,
-        EGL_NV_depth_nonlinear,
-        EGL_NV_device_cuda,
-        EGL_NV_native_query,
-        EGL_NV_post_convert_rounding,
-        EGL_NV_post_sub_buffer,
-        EGL_NV_quadruple_buffer,
-        EGL_NV_robustness_video_memory_purge,
-        EGL_NV_stream_consumer_gltexture_yuv,
-        EGL_NV_stream_cross_display,
-        EGL_NV_stream_cross_object,
-        EGL_NV_stream_cross_partition,
-        EGL_NV_stream_cross_process,
-        EGL_NV_stream_cross_system,
-        EGL_NV_stream_dma,
-        EGL_NV_stream_fifo_next,
-        EGL_NV_stream_fifo_synchronous,
-        EGL_NV_stream_flush,
-        EGL_NV_stream_frame_limits,
-        EGL_NV_stream_metadata,
-        EGL_NV_stream_origin,
-        EGL_NV_stream_remote,
-        EGL_NV_stream_reset,
-        EGL_NV_stream_socket,
-        EGL_NV_stream_socket_inet,
-        EGL_NV_stream_socket_unix,
-        EGL_NV_stream_sync,
-        EGL_NV_sync,
-        EGL_NV_system_time,
-        EGL_NV_triple_buffer,
-        EGL_TIZEN_image_native_buffer,
-        EGL_TIZEN_image_native_surface,
-        EGL_WL_bind_wayland_display,
-        EGL_WL_create_wayland_buffer_from_image
-    Loader: True
-    Local files: False
-    Omit khrplatform: False
-    Reproducible: False
-
-    Commandline:
-        --api="egl=1.5" --generator="c" --spec="egl" --extensions="EGL_ANDROID_GLES_layers,EGL_ANDROID_blob_cache,EGL_ANDROID_create_native_client_buffer,EGL_ANDROID_framebuffer_target,EGL_ANDROID_front_buffer_auto_refresh,EGL_ANDROID_get_frame_timestamps,EGL_ANDROID_get_native_client_buffer,EGL_ANDROID_image_native_buffer,EGL_ANDROID_native_fence_sync,EGL_ANDROID_presentation_time,EGL_ANDROID_recordable,EGL_ANGLE_d3d_share_handle_client_buffer,EGL_ANGLE_device_d3d,EGL_ANGLE_query_surface_pointer,EGL_ANGLE_surface_d3d_texture_2d_share_handle,EGL_ANGLE_window_fixed_size,EGL_ARM_image_format,EGL_ARM_implicit_external_sync,EGL_ARM_pixmap_multisample_discard,EGL_EXT_bind_to_front,EGL_EXT_buffer_age,EGL_EXT_client_extensions,EGL_EXT_client_sync,EGL_EXT_compositor,EGL_EXT_create_context_robustness,EGL_EXT_device_base,EGL_EXT_device_drm,EGL_EXT_device_enumeration,EGL_EXT_device_openwf,EGL_EXT_device_query,EGL_EXT_gl_colorspace_bt2020_linear,EGL_EXT_gl_colorspace_bt2020_pq,EGL_EXT_gl_colorspace_display_p3,EGL_EXT_gl_colorspace_display_p3_linear,EGL_EXT_gl_colorspace_display_p3_passthrough,EGL_EXT_gl_colorspace_scrgb,EGL_EXT_gl_colorspace_scrgb_linear,EGL_EXT_image_dma_buf_import,EGL_EXT_image_dma_buf_import_modifiers,EGL_EXT_image_gl_colorspace,EGL_EXT_image_implicit_sync_control,EGL_EXT_multiview_window,EGL_EXT_output_base,EGL_EXT_output_drm,EGL_EXT_output_openwf,EGL_EXT_pixel_format_float,EGL_EXT_platform_base,EGL_EXT_platform_device,EGL_EXT_platform_wayland,EGL_EXT_platform_x11,EGL_EXT_protected_content,EGL_EXT_protected_surface,EGL_EXT_stream_consumer_egloutput,EGL_EXT_surface_CTA861_3_metadata,EGL_EXT_surface_SMPTE2086_metadata,EGL_EXT_swap_buffers_with_damage,EGL_EXT_sync_reuse,EGL_EXT_yuv_surface,EGL_HI_clientpixmap,EGL_HI_colorformats,EGL_IMG_context_priority,EGL_IMG_image_plane_attribs,EGL_KHR_cl_event,EGL_KHR_cl_event2,EGL_KHR_client_get_all_proc_addresses,EGL_KHR_config_attribs,EGL_KHR_context_flush_control,EGL_KHR_create_context,EGL_KHR_create_context_no_error,EGL_KHR_debug,EGL_KHR_display_reference,EGL_KHR_fence_sync,EGL_KHR_get_all_proc_addresses,EGL_KHR_gl_colorspace,EGL_KHR_gl_renderbuffer_image,EGL_KHR_gl_texture_2D_image,EGL_KHR_gl_texture_3D_image,EGL_KHR_gl_texture_cubemap_image,EGL_KHR_image,EGL_KHR_image_base,EGL_KHR_image_pixmap,EGL_KHR_lock_surface,EGL_KHR_lock_surface2,EGL_KHR_lock_surface3,EGL_KHR_mutable_render_buffer,EGL_KHR_no_config_context,EGL_KHR_partial_update,EGL_KHR_platform_android,EGL_KHR_platform_gbm,EGL_KHR_platform_wayland,EGL_KHR_platform_x11,EGL_KHR_reusable_sync,EGL_KHR_stream,EGL_KHR_stream_attrib,EGL_KHR_stream_consumer_gltexture,EGL_KHR_stream_cross_process_fd,EGL_KHR_stream_fifo,EGL_KHR_stream_producer_aldatalocator,EGL_KHR_stream_producer_eglsurface,EGL_KHR_surfaceless_context,EGL_KHR_swap_buffers_with_damage,EGL_KHR_vg_parent_image,EGL_KHR_wait_sync,EGL_MESA_drm_image,EGL_MESA_image_dma_buf_export,EGL_MESA_platform_gbm,EGL_MESA_platform_surfaceless,EGL_MESA_query_driver,EGL_NOK_swap_region,EGL_NOK_swap_region2,EGL_NOK_texture_from_pixmap,EGL_NV_3dvision_surface,EGL_NV_context_priority_realtime,EGL_NV_coverage_sample,EGL_NV_coverage_sample_resolve,EGL_NV_cuda_event,EGL_NV_depth_nonlinear,EGL_NV_device_cuda,EGL_NV_native_query,EGL_NV_post_convert_rounding,EGL_NV_post_sub_buffer,EGL_NV_quadruple_buffer,EGL_NV_robustness_video_memory_purge,EGL_NV_stream_consumer_gltexture_yuv,EGL_NV_stream_cross_display,EGL_NV_stream_cross_object,EGL_NV_stream_cross_partition,EGL_NV_stream_cross_process,EGL_NV_stream_cross_system,EGL_NV_stream_dma,EGL_NV_stream_fifo_next,EGL_NV_stream_fifo_synchronous,EGL_NV_stream_flush,EGL_NV_stream_frame_limits,EGL_NV_stream_metadata,EGL_NV_stream_origin,EGL_NV_stream_remote,EGL_NV_stream_reset,EGL_NV_stream_socket,EGL_NV_stream_socket_inet,EGL_NV_stream_socket_unix,EGL_NV_stream_sync,EGL_NV_sync,EGL_NV_system_time,EGL_NV_triple_buffer,EGL_TIZEN_image_native_buffer,EGL_TIZEN_image_native_surface,EGL_WL_bind_wayland_display,EGL_WL_create_wayland_buffer_from_image"
-    Online:
-        Too many extensions
-*/
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include "glad_egl.h"
-
-int gladLoadEGL(void) {
-    return gladLoadEGLLoader((GLADloadproc)eglGetProcAddress);
-}
-
-PFNEGLSETBLOBCACHEFUNCSANDROIDPROC glad_eglSetBlobCacheFuncsANDROID = NULL;
-PFNEGLCREATENATIVECLIENTBUFFERANDROIDPROC glad_eglCreateNativeClientBufferANDROID = NULL;
-PFNEGLGETCOMPOSITORTIMINGSUPPORTEDANDROIDPROC glad_eglGetCompositorTimingSupportedANDROID = NULL;
-PFNEGLGETCOMPOSITORTIMINGANDROIDPROC glad_eglGetCompositorTimingANDROID = NULL;
-PFNEGLGETNEXTFRAMEIDANDROIDPROC glad_eglGetNextFrameIdANDROID = NULL;
-PFNEGLGETFRAMETIMESTAMPSUPPORTEDANDROIDPROC glad_eglGetFrameTimestampSupportedANDROID = NULL;
-PFNEGLGETFRAMETIMESTAMPSANDROIDPROC glad_eglGetFrameTimestampsANDROID = NULL;
-PFNEGLGETNATIVECLIENTBUFFERANDROIDPROC glad_eglGetNativeClientBufferANDROID = NULL;
-PFNEGLDUPNATIVEFENCEFDANDROIDPROC glad_eglDupNativeFenceFDANDROID = NULL;
-PFNEGLPRESENTATIONTIMEANDROIDPROC glad_eglPresentationTimeANDROID = NULL;
-PFNEGLQUERYSURFACEPOINTERANGLEPROC glad_eglQuerySurfacePointerANGLE = NULL;
-PFNEGLCLIENTSIGNALSYNCEXTPROC glad_eglClientSignalSyncEXT = NULL;
-PFNEGLCOMPOSITORSETCONTEXTLISTEXTPROC glad_eglCompositorSetContextListEXT = NULL;
-PFNEGLCOMPOSITORSETCONTEXTATTRIBUTESEXTPROC glad_eglCompositorSetContextAttributesEXT = NULL;
-PFNEGLCOMPOSITORSETWINDOWLISTEXTPROC glad_eglCompositorSetWindowListEXT = NULL;
-PFNEGLCOMPOSITORSETWINDOWATTRIBUTESEXTPROC glad_eglCompositorSetWindowAttributesEXT = NULL;
-PFNEGLCOMPOSITORBINDTEXWINDOWEXTPROC glad_eglCompositorBindTexWindowEXT = NULL;
-PFNEGLCOMPOSITORSETSIZEEXTPROC glad_eglCompositorSetSizeEXT = NULL;
-PFNEGLCOMPOSITORSWAPPOLICYEXTPROC glad_eglCompositorSwapPolicyEXT = NULL;
-PFNEGLQUERYDEVICEATTRIBEXTPROC glad_eglQueryDeviceAttribEXT = NULL;
-PFNEGLQUERYDEVICESTRINGEXTPROC glad_eglQueryDeviceStringEXT = NULL;
-PFNEGLQUERYDEVICESEXTPROC glad_eglQueryDevicesEXT = NULL;
-PFNEGLQUERYDISPLAYATTRIBEXTPROC glad_eglQueryDisplayAttribEXT = NULL;
-PFNEGLQUERYDMABUFFORMATSEXTPROC glad_eglQueryDmaBufFormatsEXT = NULL;
-PFNEGLQUERYDMABUFMODIFIERSEXTPROC glad_eglQueryDmaBufModifiersEXT = NULL;
-PFNEGLGETOUTPUTLAYERSEXTPROC glad_eglGetOutputLayersEXT = NULL;
-PFNEGLGETOUTPUTPORTSEXTPROC glad_eglGetOutputPortsEXT = NULL;
-PFNEGLOUTPUTLAYERATTRIBEXTPROC glad_eglOutputLayerAttribEXT = NULL;
-PFNEGLQUERYOUTPUTLAYERATTRIBEXTPROC glad_eglQueryOutputLayerAttribEXT = NULL;
-PFNEGLQUERYOUTPUTLAYERSTRINGEXTPROC glad_eglQueryOutputLayerStringEXT = NULL;
-PFNEGLOUTPUTPORTATTRIBEXTPROC glad_eglOutputPortAttribEXT = NULL;
-PFNEGLQUERYOUTPUTPORTATTRIBEXTPROC glad_eglQueryOutputPortAttribEXT = NULL;
-PFNEGLQUERYOUTPUTPORTSTRINGEXTPROC glad_eglQueryOutputPortStringEXT = NULL;
-PFNEGLGETPLATFORMDISPLAYEXTPROC glad_eglGetPlatformDisplayEXT = NULL;
-PFNEGLCREATEPLATFORMWINDOWSURFACEEXTPROC glad_eglCreatePlatformWindowSurfaceEXT = NULL;
-PFNEGLCREATEPLATFORMPIXMAPSURFACEEXTPROC glad_eglCreatePlatformPixmapSurfaceEXT = NULL;
-PFNEGLSTREAMCONSUMEROUTPUTEXTPROC glad_eglStreamConsumerOutputEXT = NULL;
-PFNEGLSWAPBUFFERSWITHDAMAGEEXTPROC glad_eglSwapBuffersWithDamageEXT = NULL;
-PFNEGLUNSIGNALSYNCEXTPROC glad_eglUnsignalSyncEXT = NULL;
-PFNEGLCREATEPIXMAPSURFACEHIPROC glad_eglCreatePixmapSurfaceHI = NULL;
-PFNEGLCREATESYNC64KHRPROC glad_eglCreateSync64KHR = NULL;
-PFNEGLDEBUGMESSAGECONTROLKHRPROC glad_eglDebugMessageControlKHR = NULL;
-PFNEGLQUERYDEBUGKHRPROC glad_eglQueryDebugKHR = NULL;
-PFNEGLLABELOBJECTKHRPROC glad_eglLabelObjectKHR = NULL;
-PFNEGLQUERYDISPLAYATTRIBKHRPROC glad_eglQueryDisplayAttribKHR = NULL;
-PFNEGLCREATESYNCKHRPROC glad_eglCreateSyncKHR = NULL;
-PFNEGLDESTROYSYNCKHRPROC glad_eglDestroySyncKHR = NULL;
-PFNEGLCLIENTWAITSYNCKHRPROC glad_eglClientWaitSyncKHR = NULL;
-PFNEGLGETSYNCATTRIBKHRPROC glad_eglGetSyncAttribKHR = NULL;
-PFNEGLCREATEIMAGEKHRPROC glad_eglCreateImageKHR = NULL;
-PFNEGLDESTROYIMAGEKHRPROC glad_eglDestroyImageKHR = NULL;
-PFNEGLLOCKSURFACEKHRPROC glad_eglLockSurfaceKHR = NULL;
-PFNEGLUNLOCKSURFACEKHRPROC glad_eglUnlockSurfaceKHR = NULL;
-PFNEGLQUERYSURFACE64KHRPROC glad_eglQuerySurface64KHR = NULL;
-PFNEGLSETDAMAGEREGIONKHRPROC glad_eglSetDamageRegionKHR = NULL;
-PFNEGLSIGNALSYNCKHRPROC glad_eglSignalSyncKHR = NULL;
-PFNEGLCREATESTREAMKHRPROC glad_eglCreateStreamKHR = NULL;
-PFNEGLDESTROYSTREAMKHRPROC glad_eglDestroyStreamKHR = NULL;
-PFNEGLSTREAMATTRIBKHRPROC glad_eglStreamAttribKHR = NULL;
-PFNEGLQUERYSTREAMKHRPROC glad_eglQueryStreamKHR = NULL;
-PFNEGLQUERYSTREAMU64KHRPROC glad_eglQueryStreamu64KHR = NULL;
-PFNEGLCREATESTREAMATTRIBKHRPROC glad_eglCreateStreamAttribKHR = NULL;
-PFNEGLSETSTREAMATTRIBKHRPROC glad_eglSetStreamAttribKHR = NULL;
-PFNEGLQUERYSTREAMATTRIBKHRPROC glad_eglQueryStreamAttribKHR = NULL;
-PFNEGLSTREAMCONSUMERACQUIREATTRIBKHRPROC glad_eglStreamConsumerAcquireAttribKHR = NULL;
-PFNEGLSTREAMCONSUMERRELEASEATTRIBKHRPROC glad_eglStreamConsumerReleaseAttribKHR = NULL;
-PFNEGLSTREAMCONSUMERGLTEXTUREEXTERNALKHRPROC glad_eglStreamConsumerGLTextureExternalKHR = NULL;
-PFNEGLSTREAMCONSUMERACQUIREKHRPROC glad_eglStreamConsumerAcquireKHR = NULL;
-PFNEGLSTREAMCONSUMERRELEASEKHRPROC glad_eglStreamConsumerReleaseKHR = NULL;
-PFNEGLGETSTREAMFILEDESCRIPTORKHRPROC glad_eglGetStreamFileDescriptorKHR = NULL;
-PFNEGLCREATESTREAMFROMFILEDESCRIPTORKHRPROC glad_eglCreateStreamFromFileDescriptorKHR = NULL;
-PFNEGLQUERYSTREAMTIMEKHRPROC glad_eglQueryStreamTimeKHR = NULL;
-PFNEGLCREATESTREAMPRODUCERSURFACEKHRPROC glad_eglCreateStreamProducerSurfaceKHR = NULL;
-PFNEGLSWAPBUFFERSWITHDAMAGEKHRPROC glad_eglSwapBuffersWithDamageKHR = NULL;
-PFNEGLWAITSYNCKHRPROC glad_eglWaitSyncKHR = NULL;
-PFNEGLCREATEDRMIMAGEMESAPROC glad_eglCreateDRMImageMESA = NULL;
-PFNEGLEXPORTDRMIMAGEMESAPROC glad_eglExportDRMImageMESA = NULL;
-PFNEGLEXPORTDMABUFIMAGEQUERYMESAPROC glad_eglExportDMABUFImageQueryMESA = NULL;
-PFNEGLEXPORTDMABUFIMAGEMESAPROC glad_eglExportDMABUFImageMESA = NULL;
-PFNEGLGETDISPLAYDRIVERCONFIGPROC glad_eglGetDisplayDriverConfig = NULL;
-PFNEGLGETDISPLAYDRIVERNAMEPROC glad_eglGetDisplayDriverName = NULL;
-PFNEGLSWAPBUFFERSREGIONNOKPROC glad_eglSwapBuffersRegionNOK = NULL;
-PFNEGLSWAPBUFFERSREGION2NOKPROC glad_eglSwapBuffersRegion2NOK = NULL;
-PFNEGLQUERYNATIVEDISPLAYNVPROC glad_eglQueryNativeDisplayNV = NULL;
-PFNEGLQUERYNATIVEWINDOWNVPROC glad_eglQueryNativeWindowNV = NULL;
-PFNEGLQUERYNATIVEPIXMAPNVPROC glad_eglQueryNativePixmapNV = NULL;
-PFNEGLPOSTSUBBUFFERNVPROC glad_eglPostSubBufferNV = NULL;
-PFNEGLSTREAMCONSUMERGLTEXTUREEXTERNALATTRIBSNVPROC glad_eglStreamConsumerGLTextureExternalAttribsNV = NULL;
-PFNEGLSTREAMFLUSHNVPROC glad_eglStreamFlushNV = NULL;
-PFNEGLQUERYDISPLAYATTRIBNVPROC glad_eglQueryDisplayAttribNV = NULL;
-PFNEGLSETSTREAMMETADATANVPROC glad_eglSetStreamMetadataNV = NULL;
-PFNEGLQUERYSTREAMMETADATANVPROC glad_eglQueryStreamMetadataNV = NULL;
-PFNEGLRESETSTREAMNVPROC glad_eglResetStreamNV = NULL;
-PFNEGLCREATESTREAMSYNCNVPROC glad_eglCreateStreamSyncNV = NULL;
-PFNEGLCREATEFENCESYNCNVPROC glad_eglCreateFenceSyncNV = NULL;
-PFNEGLDESTROYSYNCNVPROC glad_eglDestroySyncNV = NULL;
-PFNEGLFENCENVPROC glad_eglFenceNV = NULL;
-PFNEGLCLIENTWAITSYNCNVPROC glad_eglClientWaitSyncNV = NULL;
-PFNEGLSIGNALSYNCNVPROC glad_eglSignalSyncNV = NULL;
-PFNEGLGETSYNCATTRIBNVPROC glad_eglGetSyncAttribNV = NULL;
-PFNEGLGETSYSTEMTIMEFREQUENCYNVPROC glad_eglGetSystemTimeFrequencyNV = NULL;
-PFNEGLGETSYSTEMTIMENVPROC glad_eglGetSystemTimeNV = NULL;
-PFNEGLBINDWAYLANDDISPLAYWLPROC glad_eglBindWaylandDisplayWL = NULL;
-PFNEGLUNBINDWAYLANDDISPLAYWLPROC glad_eglUnbindWaylandDisplayWL = NULL;
-PFNEGLQUERYWAYLANDBUFFERWLPROC glad_eglQueryWaylandBufferWL = NULL;
-PFNEGLCREATEWAYLANDBUFFERFROMIMAGEWLPROC glad_eglCreateWaylandBufferFromImageWL = NULL;
-static void load_EGL_ANDROID_blob_cache(GLADloadproc load) {
-	glad_eglSetBlobCacheFuncsANDROID = (PFNEGLSETBLOBCACHEFUNCSANDROIDPROC)load("eglSetBlobCacheFuncsANDROID");
-}
-static void load_EGL_ANDROID_create_native_client_buffer(GLADloadproc load) {
-	glad_eglCreateNativeClientBufferANDROID = (PFNEGLCREATENATIVECLIENTBUFFERANDROIDPROC)load("eglCreateNativeClientBufferANDROID");
-}
-static void load_EGL_ANDROID_get_frame_timestamps(GLADloadproc load) {
-	glad_eglGetCompositorTimingSupportedANDROID = (PFNEGLGETCOMPOSITORTIMINGSUPPORTEDANDROIDPROC)load("eglGetCompositorTimingSupportedANDROID");
-	glad_eglGetCompositorTimingANDROID = (PFNEGLGETCOMPOSITORTIMINGANDROIDPROC)load("eglGetCompositorTimingANDROID");
-	glad_eglGetNextFrameIdANDROID = (PFNEGLGETNEXTFRAMEIDANDROIDPROC)load("eglGetNextFrameIdANDROID");
-	glad_eglGetFrameTimestampSupportedANDROID = (PFNEGLGETFRAMETIMESTAMPSUPPORTEDANDROIDPROC)load("eglGetFrameTimestampSupportedANDROID");
-	glad_eglGetFrameTimestampsANDROID = (PFNEGLGETFRAMETIMESTAMPSANDROIDPROC)load("eglGetFrameTimestampsANDROID");
-}
-static void load_EGL_ANDROID_get_native_client_buffer(GLADloadproc load) {
-	glad_eglGetNativeClientBufferANDROID = (PFNEGLGETNATIVECLIENTBUFFERANDROIDPROC)load("eglGetNativeClientBufferANDROID");
-}
-static void load_EGL_ANDROID_native_fence_sync(GLADloadproc load) {
-	glad_eglDupNativeFenceFDANDROID = (PFNEGLDUPNATIVEFENCEFDANDROIDPROC)load("eglDupNativeFenceFDANDROID");
-}
-static void load_EGL_ANDROID_presentation_time(GLADloadproc load) {
-	glad_eglPresentationTimeANDROID = (PFNEGLPRESENTATIONTIMEANDROIDPROC)load("eglPresentationTimeANDROID");
-}
-static void load_EGL_ANGLE_query_surface_pointer(GLADloadproc load) {
-	glad_eglQuerySurfacePointerANGLE = (PFNEGLQUERYSURFACEPOINTERANGLEPROC)load("eglQuerySurfacePointerANGLE");
-}
-static void load_EGL_EXT_client_sync(GLADloadproc load) {
-	glad_eglClientSignalSyncEXT = (PFNEGLCLIENTSIGNALSYNCEXTPROC)load("eglClientSignalSyncEXT");
-}
-static void load_EGL_EXT_compositor(GLADloadproc load) {
-	glad_eglCompositorSetContextListEXT = (PFNEGLCOMPOSITORSETCONTEXTLISTEXTPROC)load("eglCompositorSetContextListEXT");
-	glad_eglCompositorSetContextAttributesEXT = (PFNEGLCOMPOSITORSETCONTEXTATTRIBUTESEXTPROC)load("eglCompositorSetContextAttributesEXT");
-	glad_eglCompositorSetWindowListEXT = (PFNEGLCOMPOSITORSETWINDOWLISTEXTPROC)load("eglCompositorSetWindowListEXT");
-	glad_eglCompositorSetWindowAttributesEXT = (PFNEGLCOMPOSITORSETWINDOWATTRIBUTESEXTPROC)load("eglCompositorSetWindowAttributesEXT");
-	glad_eglCompositorBindTexWindowEXT = (PFNEGLCOMPOSITORBINDTEXWINDOWEXTPROC)load("eglCompositorBindTexWindowEXT");
-	glad_eglCompositorSetSizeEXT = (PFNEGLCOMPOSITORSETSIZEEXTPROC)load("eglCompositorSetSizeEXT");
-	glad_eglCompositorSwapPolicyEXT = (PFNEGLCOMPOSITORSWAPPOLICYEXTPROC)load("eglCompositorSwapPolicyEXT");
-}
-static void load_EGL_EXT_device_base(GLADloadproc load) {
-	glad_eglQueryDeviceAttribEXT = (PFNEGLQUERYDEVICEATTRIBEXTPROC)load("eglQueryDeviceAttribEXT");
-	glad_eglQueryDeviceStringEXT = (PFNEGLQUERYDEVICESTRINGEXTPROC)load("eglQueryDeviceStringEXT");
-	glad_eglQueryDevicesEXT = (PFNEGLQUERYDEVICESEXTPROC)load("eglQueryDevicesEXT");
-	glad_eglQueryDisplayAttribEXT = (PFNEGLQUERYDISPLAYATTRIBEXTPROC)load("eglQueryDisplayAttribEXT");
-}
-static void load_EGL_EXT_device_enumeration(GLADloadproc load) {
-	glad_eglQueryDevicesEXT = (PFNEGLQUERYDEVICESEXTPROC)load("eglQueryDevicesEXT");
-}
-static void load_EGL_EXT_device_query(GLADloadproc load) {
-	glad_eglQueryDeviceAttribEXT = (PFNEGLQUERYDEVICEATTRIBEXTPROC)load("eglQueryDeviceAttribEXT");
-	glad_eglQueryDeviceStringEXT = (PFNEGLQUERYDEVICESTRINGEXTPROC)load("eglQueryDeviceStringEXT");
-	glad_eglQueryDisplayAttribEXT = (PFNEGLQUERYDISPLAYATTRIBEXTPROC)load("eglQueryDisplayAttribEXT");
-}
-static void load_EGL_EXT_image_dma_buf_import_modifiers(GLADloadproc load) {
-	glad_eglQueryDmaBufFormatsEXT = (PFNEGLQUERYDMABUFFORMATSEXTPROC)load("eglQueryDmaBufFormatsEXT");
-	glad_eglQueryDmaBufModifiersEXT = (PFNEGLQUERYDMABUFMODIFIERSEXTPROC)load("eglQueryDmaBufModifiersEXT");
-}
-static void load_EGL_EXT_output_base(GLADloadproc load) {
-	glad_eglGetOutputLayersEXT = (PFNEGLGETOUTPUTLAYERSEXTPROC)load("eglGetOutputLayersEXT");
-	glad_eglGetOutputPortsEXT = (PFNEGLGETOUTPUTPORTSEXTPROC)load("eglGetOutputPortsEXT");
-	glad_eglOutputLayerAttribEXT = (PFNEGLOUTPUTLAYERATTRIBEXTPROC)load("eglOutputLayerAttribEXT");
-	glad_eglQueryOutputLayerAttribEXT = (PFNEGLQUERYOUTPUTLAYERATTRIBEXTPROC)load("eglQueryOutputLayerAttribEXT");
-	glad_eglQueryOutputLayerStringEXT = (PFNEGLQUERYOUTPUTLAYERSTRINGEXTPROC)load("eglQueryOutputLayerStringEXT");
-	glad_eglOutputPortAttribEXT = (PFNEGLOUTPUTPORTATTRIBEXTPROC)load("eglOutputPortAttribEXT");
-	glad_eglQueryOutputPortAttribEXT = (PFNEGLQUERYOUTPUTPORTATTRIBEXTPROC)load("eglQueryOutputPortAttribEXT");
-	glad_eglQueryOutputPortStringEXT = (PFNEGLQUERYOUTPUTPORTSTRINGEXTPROC)load("eglQueryOutputPortStringEXT");
-}
-static void load_EGL_EXT_platform_base(GLADloadproc load) {
-	glad_eglGetPlatformDisplayEXT = (PFNEGLGETPLATFORMDISPLAYEXTPROC)load("eglGetPlatformDisplayEXT");
-	glad_eglCreatePlatformWindowSurfaceEXT = (PFNEGLCREATEPLATFORMWINDOWSURFACEEXTPROC)load("eglCreatePlatformWindowSurfaceEXT");
-	glad_eglCreatePlatformPixmapSurfaceEXT = (PFNEGLCREATEPLATFORMPIXMAPSURFACEEXTPROC)load("eglCreatePlatformPixmapSurfaceEXT");
-}
-static void load_EGL_EXT_stream_consumer_egloutput(GLADloadproc load) {
-	glad_eglStreamConsumerOutputEXT = (PFNEGLSTREAMCONSUMEROUTPUTEXTPROC)load("eglStreamConsumerOutputEXT");
-}
-static void load_EGL_EXT_swap_buffers_with_damage(GLADloadproc load) {
-	glad_eglSwapBuffersWithDamageEXT = (PFNEGLSWAPBUFFERSWITHDAMAGEEXTPROC)load("eglSwapBuffersWithDamageEXT");
-}
-static void load_EGL_EXT_sync_reuse(GLADloadproc load) {
-	glad_eglUnsignalSyncEXT = (PFNEGLUNSIGNALSYNCEXTPROC)load("eglUnsignalSyncEXT");
-}
-static void load_EGL_HI_clientpixmap(GLADloadproc load) {
-	glad_eglCreatePixmapSurfaceHI = (PFNEGLCREATEPIXMAPSURFACEHIPROC)load("eglCreatePixmapSurfaceHI");
-}
-static void load_EGL_KHR_cl_event2(GLADloadproc load) {
-	glad_eglCreateSync64KHR = (PFNEGLCREATESYNC64KHRPROC)load("eglCreateSync64KHR");
-}
-static void load_EGL_KHR_debug(GLADloadproc load) {
-	glad_eglDebugMessageControlKHR = (PFNEGLDEBUGMESSAGECONTROLKHRPROC)load("eglDebugMessageControlKHR");
-	glad_eglQueryDebugKHR = (PFNEGLQUERYDEBUGKHRPROC)load("eglQueryDebugKHR");
-	glad_eglLabelObjectKHR = (PFNEGLLABELOBJECTKHRPROC)load("eglLabelObjectKHR");
-}
-static void load_EGL_KHR_display_reference(GLADloadproc load) {
-	glad_eglQueryDisplayAttribKHR = (PFNEGLQUERYDISPLAYATTRIBKHRPROC)load("eglQueryDisplayAttribKHR");
-}
-static void load_EGL_KHR_fence_sync(GLADloadproc load) {
-	glad_eglCreateSyncKHR = (PFNEGLCREATESYNCKHRPROC)load("eglCreateSyncKHR");
-	glad_eglDestroySyncKHR = (PFNEGLDESTROYSYNCKHRPROC)load("eglDestroySyncKHR");
-	glad_eglClientWaitSyncKHR = (PFNEGLCLIENTWAITSYNCKHRPROC)load("eglClientWaitSyncKHR");
-	glad_eglGetSyncAttribKHR = (PFNEGLGETSYNCATTRIBKHRPROC)load("eglGetSyncAttribKHR");
-}
-static void load_EGL_KHR_image(GLADloadproc load) {
-	glad_eglCreateImageKHR = (PFNEGLCREATEIMAGEKHRPROC)load("eglCreateImageKHR");
-	glad_eglDestroyImageKHR = (PFNEGLDESTROYIMAGEKHRPROC)load("eglDestroyImageKHR");
-}
-static void load_EGL_KHR_image_base(GLADloadproc load) {
-	glad_eglCreateImageKHR = (PFNEGLCREATEIMAGEKHRPROC)load("eglCreateImageKHR");
-	glad_eglDestroyImageKHR = (PFNEGLDESTROYIMAGEKHRPROC)load("eglDestroyImageKHR");
-}
-static void load_EGL_KHR_lock_surface(GLADloadproc load) {
-	glad_eglLockSurfaceKHR = (PFNEGLLOCKSURFACEKHRPROC)load("eglLockSurfaceKHR");
-	glad_eglUnlockSurfaceKHR = (PFNEGLUNLOCKSURFACEKHRPROC)load("eglUnlockSurfaceKHR");
-}
-static void load_EGL_KHR_lock_surface3(GLADloadproc load) {
-	glad_eglLockSurfaceKHR = (PFNEGLLOCKSURFACEKHRPROC)load("eglLockSurfaceKHR");
-	glad_eglUnlockSurfaceKHR = (PFNEGLUNLOCKSURFACEKHRPROC)load("eglUnlockSurfaceKHR");
-	glad_eglQuerySurface64KHR = (PFNEGLQUERYSURFACE64KHRPROC)load("eglQuerySurface64KHR");
-}
-static void load_EGL_KHR_partial_update(GLADloadproc load) {
-	glad_eglSetDamageRegionKHR = (PFNEGLSETDAMAGEREGIONKHRPROC)load("eglSetDamageRegionKHR");
-}
-static void load_EGL_KHR_reusable_sync(GLADloadproc load) {
-	glad_eglCreateSyncKHR = (PFNEGLCREATESYNCKHRPROC)load("eglCreateSyncKHR");
-	glad_eglDestroySyncKHR = (PFNEGLDESTROYSYNCKHRPROC)load("eglDestroySyncKHR");
-	glad_eglClientWaitSyncKHR = (PFNEGLCLIENTWAITSYNCKHRPROC)load("eglClientWaitSyncKHR");
-	glad_eglSignalSyncKHR = (PFNEGLSIGNALSYNCKHRPROC)load("eglSignalSyncKHR");
-	glad_eglGetSyncAttribKHR = (PFNEGLGETSYNCATTRIBKHRPROC)load("eglGetSyncAttribKHR");
-}
-static void load_EGL_KHR_stream(GLADloadproc load) {
-	glad_eglCreateStreamKHR = (PFNEGLCREATESTREAMKHRPROC)load("eglCreateStreamKHR");
-	glad_eglDestroyStreamKHR = (PFNEGLDESTROYSTREAMKHRPROC)load("eglDestroyStreamKHR");
-	glad_eglStreamAttribKHR = (PFNEGLSTREAMATTRIBKHRPROC)load("eglStreamAttribKHR");
-	glad_eglQueryStreamKHR = (PFNEGLQUERYSTREAMKHRPROC)load("eglQueryStreamKHR");
-	glad_eglQueryStreamu64KHR = (PFNEGLQUERYSTREAMU64KHRPROC)load("eglQueryStreamu64KHR");
-}
-static void load_EGL_KHR_stream_attrib(GLADloadproc load) {
-	glad_eglCreateStreamAttribKHR = (PFNEGLCREATESTREAMATTRIBKHRPROC)load("eglCreateStreamAttribKHR");
-	glad_eglSetStreamAttribKHR = (PFNEGLSETSTREAMATTRIBKHRPROC)load("eglSetStreamAttribKHR");
-	glad_eglQueryStreamAttribKHR = (PFNEGLQUERYSTREAMATTRIBKHRPROC)load("eglQueryStreamAttribKHR");
-	glad_eglStreamConsumerAcquireAttribKHR = (PFNEGLSTREAMCONSUMERACQUIREATTRIBKHRPROC)load("eglStreamConsumerAcquireAttribKHR");
-	glad_eglStreamConsumerReleaseAttribKHR = (PFNEGLSTREAMCONSUMERRELEASEATTRIBKHRPROC)load("eglStreamConsumerReleaseAttribKHR");
-}
-static void load_EGL_KHR_stream_consumer_gltexture(GLADloadproc load) {
-	glad_eglStreamConsumerGLTextureExternalKHR = (PFNEGLSTREAMCONSUMERGLTEXTUREEXTERNALKHRPROC)load("eglStreamConsumerGLTextureExternalKHR");
-	glad_eglStreamConsumerAcquireKHR = (PFNEGLSTREAMCONSUMERACQUIREKHRPROC)load("eglStreamConsumerAcquireKHR");
-	glad_eglStreamConsumerReleaseKHR = (PFNEGLSTREAMCONSUMERRELEASEKHRPROC)load("eglStreamConsumerReleaseKHR");
-}
-static void load_EGL_KHR_stream_cross_process_fd(GLADloadproc load) {
-	glad_eglGetStreamFileDescriptorKHR = (PFNEGLGETSTREAMFILEDESCRIPTORKHRPROC)load("eglGetStreamFileDescriptorKHR");
-	glad_eglCreateStreamFromFileDescriptorKHR = (PFNEGLCREATESTREAMFROMFILEDESCRIPTORKHRPROC)load("eglCreateStreamFromFileDescriptorKHR");
-}
-static void load_EGL_KHR_stream_fifo(GLADloadproc load) {
-	glad_eglQueryStreamTimeKHR = (PFNEGLQUERYSTREAMTIMEKHRPROC)load("eglQueryStreamTimeKHR");
-}
-static void load_EGL_KHR_stream_producer_eglsurface(GLADloadproc load) {
-	glad_eglCreateStreamProducerSurfaceKHR = (PFNEGLCREATESTREAMPRODUCERSURFACEKHRPROC)load("eglCreateStreamProducerSurfaceKHR");
-}
-static void load_EGL_KHR_swap_buffers_with_damage(GLADloadproc load) {
-	glad_eglSwapBuffersWithDamageKHR = (PFNEGLSWAPBUFFERSWITHDAMAGEKHRPROC)load("eglSwapBuffersWithDamageKHR");
-}
-static void load_EGL_KHR_wait_sync(GLADloadproc load) {
-	glad_eglWaitSyncKHR = (PFNEGLWAITSYNCKHRPROC)load("eglWaitSyncKHR");
-}
-static void load_EGL_MESA_drm_image(GLADloadproc load) {
-	glad_eglCreateDRMImageMESA = (PFNEGLCREATEDRMIMAGEMESAPROC)load("eglCreateDRMImageMESA");
-	glad_eglExportDRMImageMESA = (PFNEGLEXPORTDRMIMAGEMESAPROC)load("eglExportDRMImageMESA");
-}
-static void load_EGL_MESA_image_dma_buf_export(GLADloadproc load) {
-	glad_eglExportDMABUFImageQueryMESA = (PFNEGLEXPORTDMABUFIMAGEQUERYMESAPROC)load("eglExportDMABUFImageQueryMESA");
-	glad_eglExportDMABUFImageMESA = (PFNEGLEXPORTDMABUFIMAGEMESAPROC)load("eglExportDMABUFImageMESA");
-}
-static void load_EGL_MESA_query_driver(GLADloadproc load) {
-	glad_eglGetDisplayDriverConfig = (PFNEGLGETDISPLAYDRIVERCONFIGPROC)load("eglGetDisplayDriverConfig");
-	glad_eglGetDisplayDriverName = (PFNEGLGETDISPLAYDRIVERNAMEPROC)load("eglGetDisplayDriverName");
-}
-static void load_EGL_NOK_swap_region(GLADloadproc load) {
-	glad_eglSwapBuffersRegionNOK = (PFNEGLSWAPBUFFERSREGIONNOKPROC)load("eglSwapBuffersRegionNOK");
-}
-static void load_EGL_NOK_swap_region2(GLADloadproc load) {
-	glad_eglSwapBuffersRegion2NOK = (PFNEGLSWAPBUFFERSREGION2NOKPROC)load("eglSwapBuffersRegion2NOK");
-}
-static void load_EGL_NV_native_query(GLADloadproc load) {
-	glad_eglQueryNativeDisplayNV = (PFNEGLQUERYNATIVEDISPLAYNVPROC)load("eglQueryNativeDisplayNV");
-	glad_eglQueryNativeWindowNV = (PFNEGLQUERYNATIVEWINDOWNVPROC)load("eglQueryNativeWindowNV");
-	glad_eglQueryNativePixmapNV = (PFNEGLQUERYNATIVEPIXMAPNVPROC)load("eglQueryNativePixmapNV");
-}
-static void load_EGL_NV_post_sub_buffer(GLADloadproc load) {
-	glad_eglPostSubBufferNV = (PFNEGLPOSTSUBBUFFERNVPROC)load("eglPostSubBufferNV");
-}
-static void load_EGL_NV_stream_consumer_gltexture_yuv(GLADloadproc load) {
-	glad_eglStreamConsumerGLTextureExternalAttribsNV = (PFNEGLSTREAMCONSUMERGLTEXTUREEXTERNALATTRIBSNVPROC)load("eglStreamConsumerGLTextureExternalAttribsNV");
-}
-static void load_EGL_NV_stream_flush(GLADloadproc load) {
-	glad_eglStreamFlushNV = (PFNEGLSTREAMFLUSHNVPROC)load("eglStreamFlushNV");
-}
-static void load_EGL_NV_stream_metadata(GLADloadproc load) {
-	glad_eglQueryDisplayAttribNV = (PFNEGLQUERYDISPLAYATTRIBNVPROC)load("eglQueryDisplayAttribNV");
-	glad_eglSetStreamMetadataNV = (PFNEGLSETSTREAMMETADATANVPROC)load("eglSetStreamMetadataNV");
-	glad_eglQueryStreamMetadataNV = (PFNEGLQUERYSTREAMMETADATANVPROC)load("eglQueryStreamMetadataNV");
-}
-static void load_EGL_NV_stream_reset(GLADloadproc load) {
-	glad_eglResetStreamNV = (PFNEGLRESETSTREAMNVPROC)load("eglResetStreamNV");
-}
-static void load_EGL_NV_stream_sync(GLADloadproc load) {
-	glad_eglCreateStreamSyncNV = (PFNEGLCREATESTREAMSYNCNVPROC)load("eglCreateStreamSyncNV");
-}
-static void load_EGL_NV_sync(GLADloadproc load) {
-	glad_eglCreateFenceSyncNV = (PFNEGLCREATEFENCESYNCNVPROC)load("eglCreateFenceSyncNV");
-	glad_eglDestroySyncNV = (PFNEGLDESTROYSYNCNVPROC)load("eglDestroySyncNV");
-	glad_eglFenceNV = (PFNEGLFENCENVPROC)load("eglFenceNV");
-	glad_eglClientWaitSyncNV = (PFNEGLCLIENTWAITSYNCNVPROC)load("eglClientWaitSyncNV");
-	glad_eglSignalSyncNV = (PFNEGLSIGNALSYNCNVPROC)load("eglSignalSyncNV");
-	glad_eglGetSyncAttribNV = (PFNEGLGETSYNCATTRIBNVPROC)load("eglGetSyncAttribNV");
-}
-static void load_EGL_NV_system_time(GLADloadproc load) {
-	glad_eglGetSystemTimeFrequencyNV = (PFNEGLGETSYSTEMTIMEFREQUENCYNVPROC)load("eglGetSystemTimeFrequencyNV");
-	glad_eglGetSystemTimeNV = (PFNEGLGETSYSTEMTIMENVPROC)load("eglGetSystemTimeNV");
-}
-static void load_EGL_WL_bind_wayland_display(GLADloadproc load) {
-	glad_eglBindWaylandDisplayWL = (PFNEGLBINDWAYLANDDISPLAYWLPROC)load("eglBindWaylandDisplayWL");
-	glad_eglUnbindWaylandDisplayWL = (PFNEGLUNBINDWAYLANDDISPLAYWLPROC)load("eglUnbindWaylandDisplayWL");
-	glad_eglQueryWaylandBufferWL = (PFNEGLQUERYWAYLANDBUFFERWLPROC)load("eglQueryWaylandBufferWL");
-}
-static void load_EGL_WL_create_wayland_buffer_from_image(GLADloadproc load) {
-	glad_eglCreateWaylandBufferFromImageWL = (PFNEGLCREATEWAYLANDBUFFERFROMIMAGEWLPROC)load("eglCreateWaylandBufferFromImageWL");
-}
-static int find_extensionsEGL(void) {
-	return 1;
-}
-
-static void find_coreEGL(void) {
-}
-
-int gladLoadEGLLoader(GLADloadproc load) {
-	(void) load;
-	find_coreEGL();
-
-	if (!find_extensionsEGL()) return 0;
-	load_EGL_ANDROID_blob_cache(load);
-	load_EGL_ANDROID_create_native_client_buffer(load);
-	load_EGL_ANDROID_get_frame_timestamps(load);
-	load_EGL_ANDROID_get_native_client_buffer(load);
-	load_EGL_ANDROID_native_fence_sync(load);
-	load_EGL_ANDROID_presentation_time(load);
-	load_EGL_ANGLE_query_surface_pointer(load);
-	load_EGL_EXT_client_sync(load);
-	load_EGL_EXT_compositor(load);
-	load_EGL_EXT_device_base(load);
-	load_EGL_EXT_device_enumeration(load);
-	load_EGL_EXT_device_query(load);
-	load_EGL_EXT_image_dma_buf_import_modifiers(load);
-	load_EGL_EXT_output_base(load);
-	load_EGL_EXT_platform_base(load);
-	load_EGL_EXT_stream_consumer_egloutput(load);
-	load_EGL_EXT_swap_buffers_with_damage(load);
-	load_EGL_EXT_sync_reuse(load);
-	load_EGL_HI_clientpixmap(load);
-	load_EGL_KHR_cl_event2(load);
-	load_EGL_KHR_debug(load);
-	load_EGL_KHR_display_reference(load);
-	load_EGL_KHR_fence_sync(load);
-	load_EGL_KHR_image(load);
-	load_EGL_KHR_image_base(load);
-	load_EGL_KHR_lock_surface(load);
-	load_EGL_KHR_lock_surface3(load);
-	load_EGL_KHR_partial_update(load);
-	load_EGL_KHR_reusable_sync(load);
-	load_EGL_KHR_stream(load);
-	load_EGL_KHR_stream_attrib(load);
-	load_EGL_KHR_stream_consumer_gltexture(load);
-	load_EGL_KHR_stream_cross_process_fd(load);
-	load_EGL_KHR_stream_fifo(load);
-	load_EGL_KHR_stream_producer_eglsurface(load);
-	load_EGL_KHR_swap_buffers_with_damage(load);
-	load_EGL_KHR_wait_sync(load);
-	load_EGL_MESA_drm_image(load);
-	load_EGL_MESA_image_dma_buf_export(load);
-	load_EGL_MESA_query_driver(load);
-	load_EGL_NOK_swap_region(load);
-	load_EGL_NOK_swap_region2(load);
-	load_EGL_NV_native_query(load);
-	load_EGL_NV_post_sub_buffer(load);
-	load_EGL_NV_stream_consumer_gltexture_yuv(load);
-	load_EGL_NV_stream_flush(load);
-	load_EGL_NV_stream_metadata(load);
-	load_EGL_NV_stream_reset(load);
-	load_EGL_NV_stream_sync(load);
-	load_EGL_NV_sync(load);
-	load_EGL_NV_system_time(load);
-	load_EGL_WL_bind_wayland_display(load);
-	load_EGL_WL_create_wayland_buffer_from_image(load);
-	return 1;
-}
-

dep/glad/src/glad_glx.c

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

dep/glad/src/glad_wgl.c

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

dep/glad/src/wgl.c

@@ -0,0 +1,580 @@
+/**
+ * SPDX-License-Identifier: (WTFPL OR CC0-1.0) AND Apache-2.0
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <glad/wgl.h>
+
+#ifndef GLAD_IMPL_UTIL_C_
+#define GLAD_IMPL_UTIL_C_
+
+#ifdef _MSC_VER
+#define GLAD_IMPL_UTIL_SSCANF sscanf_s
+#else
+#define GLAD_IMPL_UTIL_SSCANF sscanf
+#endif
+
+#endif /* GLAD_IMPL_UTIL_C_ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+
+int GLAD_WGL_VERSION_1_0 = 0;
+int GLAD_WGL_3DFX_multisample = 0;
+int GLAD_WGL_3DL_stereo_control = 0;
+int GLAD_WGL_AMD_gpu_association = 0;
+int GLAD_WGL_ARB_buffer_region = 0;
+int GLAD_WGL_ARB_context_flush_control = 0;
+int GLAD_WGL_ARB_create_context = 0;
+int GLAD_WGL_ARB_create_context_no_error = 0;
+int GLAD_WGL_ARB_create_context_profile = 0;
+int GLAD_WGL_ARB_create_context_robustness = 0;
+int GLAD_WGL_ARB_extensions_string = 0;
+int GLAD_WGL_ARB_framebuffer_sRGB = 0;
+int GLAD_WGL_ARB_make_current_read = 0;
+int GLAD_WGL_ARB_multisample = 0;
+int GLAD_WGL_ARB_pbuffer = 0;
+int GLAD_WGL_ARB_pixel_format = 0;
+int GLAD_WGL_ARB_pixel_format_float = 0;
+int GLAD_WGL_ARB_render_texture = 0;
+int GLAD_WGL_ARB_robustness_application_isolation = 0;
+int GLAD_WGL_ARB_robustness_share_group_isolation = 0;
+int GLAD_WGL_ATI_pixel_format_float = 0;
+int GLAD_WGL_ATI_render_texture_rectangle = 0;
+int GLAD_WGL_EXT_colorspace = 0;
+int GLAD_WGL_EXT_create_context_es2_profile = 0;
+int GLAD_WGL_EXT_create_context_es_profile = 0;
+int GLAD_WGL_EXT_depth_float = 0;
+int GLAD_WGL_EXT_display_color_table = 0;
+int GLAD_WGL_EXT_extensions_string = 0;
+int GLAD_WGL_EXT_framebuffer_sRGB = 0;
+int GLAD_WGL_EXT_make_current_read = 0;
+int GLAD_WGL_EXT_multisample = 0;
+int GLAD_WGL_EXT_pbuffer = 0;
+int GLAD_WGL_EXT_pixel_format = 0;
+int GLAD_WGL_EXT_pixel_format_packed_float = 0;
+int GLAD_WGL_EXT_swap_control = 0;
+int GLAD_WGL_EXT_swap_control_tear = 0;
+int GLAD_WGL_I3D_digital_video_control = 0;
+int GLAD_WGL_I3D_gamma = 0;
+int GLAD_WGL_I3D_genlock = 0;
+int GLAD_WGL_I3D_image_buffer = 0;
+int GLAD_WGL_I3D_swap_frame_lock = 0;
+int GLAD_WGL_I3D_swap_frame_usage = 0;
+int GLAD_WGL_NV_DX_interop = 0;
+int GLAD_WGL_NV_DX_interop2 = 0;
+int GLAD_WGL_NV_copy_image = 0;
+int GLAD_WGL_NV_delay_before_swap = 0;
+int GLAD_WGL_NV_float_buffer = 0;
+int GLAD_WGL_NV_gpu_affinity = 0;
+int GLAD_WGL_NV_multigpu_context = 0;
+int GLAD_WGL_NV_multisample_coverage = 0;
+int GLAD_WGL_NV_present_video = 0;
+int GLAD_WGL_NV_render_depth_texture = 0;
+int GLAD_WGL_NV_render_texture_rectangle = 0;
+int GLAD_WGL_NV_swap_group = 0;
+int GLAD_WGL_NV_vertex_array_range = 0;
+int GLAD_WGL_NV_video_capture = 0;
+int GLAD_WGL_NV_video_output = 0;
+int GLAD_WGL_OML_sync_control = 0;
+
+
+
+PFNWGLALLOCATEMEMORYNVPROC glad_wglAllocateMemoryNV = NULL;
+PFNWGLASSOCIATEIMAGEBUFFEREVENTSI3DPROC glad_wglAssociateImageBufferEventsI3D = NULL;
+PFNWGLBEGINFRAMETRACKINGI3DPROC glad_wglBeginFrameTrackingI3D = NULL;
+PFNWGLBINDDISPLAYCOLORTABLEEXTPROC glad_wglBindDisplayColorTableEXT = NULL;
+PFNWGLBINDSWAPBARRIERNVPROC glad_wglBindSwapBarrierNV = NULL;
+PFNWGLBINDTEXIMAGEARBPROC glad_wglBindTexImageARB = NULL;
+PFNWGLBINDVIDEOCAPTUREDEVICENVPROC glad_wglBindVideoCaptureDeviceNV = NULL;
+PFNWGLBINDVIDEODEVICENVPROC glad_wglBindVideoDeviceNV = NULL;
+PFNWGLBINDVIDEOIMAGENVPROC glad_wglBindVideoImageNV = NULL;
+PFNWGLBLITCONTEXTFRAMEBUFFERAMDPROC glad_wglBlitContextFramebufferAMD = NULL;
+PFNWGLCHOOSEPIXELFORMATARBPROC glad_wglChoosePixelFormatARB = NULL;
+PFNWGLCHOOSEPIXELFORMATEXTPROC glad_wglChoosePixelFormatEXT = NULL;
+PFNWGLCOPYIMAGESUBDATANVPROC glad_wglCopyImageSubDataNV = NULL;
+PFNWGLCREATEAFFINITYDCNVPROC glad_wglCreateAffinityDCNV = NULL;
+PFNWGLCREATEASSOCIATEDCONTEXTAMDPROC glad_wglCreateAssociatedContextAMD = NULL;
+PFNWGLCREATEASSOCIATEDCONTEXTATTRIBSAMDPROC glad_wglCreateAssociatedContextAttribsAMD = NULL;
+PFNWGLCREATEBUFFERREGIONARBPROC glad_wglCreateBufferRegionARB = NULL;
+PFNWGLCREATECONTEXTATTRIBSARBPROC glad_wglCreateContextAttribsARB = NULL;
+PFNWGLCREATEDISPLAYCOLORTABLEEXTPROC glad_wglCreateDisplayColorTableEXT = NULL;
+PFNWGLCREATEIMAGEBUFFERI3DPROC glad_wglCreateImageBufferI3D = NULL;
+PFNWGLCREATEPBUFFERARBPROC glad_wglCreatePbufferARB = NULL;
+PFNWGLCREATEPBUFFEREXTPROC glad_wglCreatePbufferEXT = NULL;
+PFNWGLDXCLOSEDEVICENVPROC glad_wglDXCloseDeviceNV = NULL;
+PFNWGLDXLOCKOBJECTSNVPROC glad_wglDXLockObjectsNV = NULL;
+PFNWGLDXOBJECTACCESSNVPROC glad_wglDXObjectAccessNV = NULL;
+PFNWGLDXOPENDEVICENVPROC glad_wglDXOpenDeviceNV = NULL;
+PFNWGLDXREGISTEROBJECTNVPROC glad_wglDXRegisterObjectNV = NULL;
+PFNWGLDXSETRESOURCESHAREHANDLENVPROC glad_wglDXSetResourceShareHandleNV = NULL;
+PFNWGLDXUNLOCKOBJECTSNVPROC glad_wglDXUnlockObjectsNV = NULL;
+PFNWGLDXUNREGISTEROBJECTNVPROC glad_wglDXUnregisterObjectNV = NULL;
+PFNWGLDELAYBEFORESWAPNVPROC glad_wglDelayBeforeSwapNV = NULL;
+PFNWGLDELETEASSOCIATEDCONTEXTAMDPROC glad_wglDeleteAssociatedContextAMD = NULL;
+PFNWGLDELETEBUFFERREGIONARBPROC glad_wglDeleteBufferRegionARB = NULL;
+PFNWGLDELETEDCNVPROC glad_wglDeleteDCNV = NULL;
+PFNWGLDESTROYDISPLAYCOLORTABLEEXTPROC glad_wglDestroyDisplayColorTableEXT = NULL;
+PFNWGLDESTROYIMAGEBUFFERI3DPROC glad_wglDestroyImageBufferI3D = NULL;
+PFNWGLDESTROYPBUFFERARBPROC glad_wglDestroyPbufferARB = NULL;
+PFNWGLDESTROYPBUFFEREXTPROC glad_wglDestroyPbufferEXT = NULL;
+PFNWGLDISABLEFRAMELOCKI3DPROC glad_wglDisableFrameLockI3D = NULL;
+PFNWGLDISABLEGENLOCKI3DPROC glad_wglDisableGenlockI3D = NULL;
+PFNWGLENABLEFRAMELOCKI3DPROC glad_wglEnableFrameLockI3D = NULL;
+PFNWGLENABLEGENLOCKI3DPROC glad_wglEnableGenlockI3D = NULL;
+PFNWGLENDFRAMETRACKINGI3DPROC glad_wglEndFrameTrackingI3D = NULL;
+PFNWGLENUMGPUDEVICESNVPROC glad_wglEnumGpuDevicesNV = NULL;
+PFNWGLENUMGPUSFROMAFFINITYDCNVPROC glad_wglEnumGpusFromAffinityDCNV = NULL;
+PFNWGLENUMGPUSNVPROC glad_wglEnumGpusNV = NULL;
+PFNWGLENUMERATEVIDEOCAPTUREDEVICESNVPROC glad_wglEnumerateVideoCaptureDevicesNV = NULL;
+PFNWGLENUMERATEVIDEODEVICESNVPROC glad_wglEnumerateVideoDevicesNV = NULL;
+PFNWGLFREEMEMORYNVPROC glad_wglFreeMemoryNV = NULL;
+PFNWGLGENLOCKSAMPLERATEI3DPROC glad_wglGenlockSampleRateI3D = NULL;
+PFNWGLGENLOCKSOURCEDELAYI3DPROC glad_wglGenlockSourceDelayI3D = NULL;
+PFNWGLGENLOCKSOURCEEDGEI3DPROC glad_wglGenlockSourceEdgeI3D = NULL;
+PFNWGLGENLOCKSOURCEI3DPROC glad_wglGenlockSourceI3D = NULL;
+PFNWGLGETCONTEXTGPUIDAMDPROC glad_wglGetContextGPUIDAMD = NULL;
+PFNWGLGETCURRENTASSOCIATEDCONTEXTAMDPROC glad_wglGetCurrentAssociatedContextAMD = NULL;
+PFNWGLGETCURRENTREADDCARBPROC glad_wglGetCurrentReadDCARB = NULL;
+PFNWGLGETCURRENTREADDCEXTPROC glad_wglGetCurrentReadDCEXT = NULL;
+PFNWGLGETDIGITALVIDEOPARAMETERSI3DPROC glad_wglGetDigitalVideoParametersI3D = NULL;
+PFNWGLGETEXTENSIONSSTRINGARBPROC glad_wglGetExtensionsStringARB = NULL;
+PFNWGLGETEXTENSIONSSTRINGEXTPROC glad_wglGetExtensionsStringEXT = NULL;
+PFNWGLGETFRAMEUSAGEI3DPROC glad_wglGetFrameUsageI3D = NULL;
+PFNWGLGETGPUIDSAMDPROC glad_wglGetGPUIDsAMD = NULL;
+PFNWGLGETGPUINFOAMDPROC glad_wglGetGPUInfoAMD = NULL;
+PFNWGLGETGAMMATABLEI3DPROC glad_wglGetGammaTableI3D = NULL;
+PFNWGLGETGAMMATABLEPARAMETERSI3DPROC glad_wglGetGammaTableParametersI3D = NULL;
+PFNWGLGETGENLOCKSAMPLERATEI3DPROC glad_wglGetGenlockSampleRateI3D = NULL;
+PFNWGLGETGENLOCKSOURCEDELAYI3DPROC glad_wglGetGenlockSourceDelayI3D = NULL;
+PFNWGLGETGENLOCKSOURCEEDGEI3DPROC glad_wglGetGenlockSourceEdgeI3D = NULL;
+PFNWGLGETGENLOCKSOURCEI3DPROC glad_wglGetGenlockSourceI3D = NULL;
+PFNWGLGETMSCRATEOMLPROC glad_wglGetMscRateOML = NULL;
+PFNWGLGETPBUFFERDCARBPROC glad_wglGetPbufferDCARB = NULL;
+PFNWGLGETPBUFFERDCEXTPROC glad_wglGetPbufferDCEXT = NULL;
+PFNWGLGETPIXELFORMATATTRIBFVARBPROC glad_wglGetPixelFormatAttribfvARB = NULL;
+PFNWGLGETPIXELFORMATATTRIBFVEXTPROC glad_wglGetPixelFormatAttribfvEXT = NULL;
+PFNWGLGETPIXELFORMATATTRIBIVARBPROC glad_wglGetPixelFormatAttribivARB = NULL;
+PFNWGLGETPIXELFORMATATTRIBIVEXTPROC glad_wglGetPixelFormatAttribivEXT = NULL;
+PFNWGLGETSWAPINTERVALEXTPROC glad_wglGetSwapIntervalEXT = NULL;
+PFNWGLGETSYNCVALUESOMLPROC glad_wglGetSyncValuesOML = NULL;
+PFNWGLGETVIDEODEVICENVPROC glad_wglGetVideoDeviceNV = NULL;
+PFNWGLGETVIDEOINFONVPROC glad_wglGetVideoInfoNV = NULL;
+PFNWGLISENABLEDFRAMELOCKI3DPROC glad_wglIsEnabledFrameLockI3D = NULL;
+PFNWGLISENABLEDGENLOCKI3DPROC glad_wglIsEnabledGenlockI3D = NULL;
+PFNWGLJOINSWAPGROUPNVPROC glad_wglJoinSwapGroupNV = NULL;
+PFNWGLLOADDISPLAYCOLORTABLEEXTPROC glad_wglLoadDisplayColorTableEXT = NULL;
+PFNWGLLOCKVIDEOCAPTUREDEVICENVPROC glad_wglLockVideoCaptureDeviceNV = NULL;
+PFNWGLMAKEASSOCIATEDCONTEXTCURRENTAMDPROC glad_wglMakeAssociatedContextCurrentAMD = NULL;
+PFNWGLMAKECONTEXTCURRENTARBPROC glad_wglMakeContextCurrentARB = NULL;
+PFNWGLMAKECONTEXTCURRENTEXTPROC glad_wglMakeContextCurrentEXT = NULL;
+PFNWGLQUERYCURRENTCONTEXTNVPROC glad_wglQueryCurrentContextNV = NULL;
+PFNWGLQUERYFRAMECOUNTNVPROC glad_wglQueryFrameCountNV = NULL;
+PFNWGLQUERYFRAMELOCKMASTERI3DPROC glad_wglQueryFrameLockMasterI3D = NULL;
+PFNWGLQUERYFRAMETRACKINGI3DPROC glad_wglQueryFrameTrackingI3D = NULL;
+PFNWGLQUERYGENLOCKMAXSOURCEDELAYI3DPROC glad_wglQueryGenlockMaxSourceDelayI3D = NULL;
+PFNWGLQUERYMAXSWAPGROUPSNVPROC glad_wglQueryMaxSwapGroupsNV = NULL;
+PFNWGLQUERYPBUFFERARBPROC glad_wglQueryPbufferARB = NULL;
+PFNWGLQUERYPBUFFEREXTPROC glad_wglQueryPbufferEXT = NULL;
+PFNWGLQUERYSWAPGROUPNVPROC glad_wglQuerySwapGroupNV = NULL;
+PFNWGLQUERYVIDEOCAPTUREDEVICENVPROC glad_wglQueryVideoCaptureDeviceNV = NULL;
+PFNWGLRELEASEIMAGEBUFFEREVENTSI3DPROC glad_wglReleaseImageBufferEventsI3D = NULL;
+PFNWGLRELEASEPBUFFERDCARBPROC glad_wglReleasePbufferDCARB = NULL;
+PFNWGLRELEASEPBUFFERDCEXTPROC glad_wglReleasePbufferDCEXT = NULL;
+PFNWGLRELEASETEXIMAGEARBPROC glad_wglReleaseTexImageARB = NULL;
+PFNWGLRELEASEVIDEOCAPTUREDEVICENVPROC glad_wglReleaseVideoCaptureDeviceNV = NULL;
+PFNWGLRELEASEVIDEODEVICENVPROC glad_wglReleaseVideoDeviceNV = NULL;
+PFNWGLRELEASEVIDEOIMAGENVPROC glad_wglReleaseVideoImageNV = NULL;
+PFNWGLRESETFRAMECOUNTNVPROC glad_wglResetFrameCountNV = NULL;
+PFNWGLRESTOREBUFFERREGIONARBPROC glad_wglRestoreBufferRegionARB = NULL;
+PFNWGLSAVEBUFFERREGIONARBPROC glad_wglSaveBufferRegionARB = NULL;
+PFNWGLSENDPBUFFERTOVIDEONVPROC glad_wglSendPbufferToVideoNV = NULL;
+PFNWGLSETDIGITALVIDEOPARAMETERSI3DPROC glad_wglSetDigitalVideoParametersI3D = NULL;
+PFNWGLSETGAMMATABLEI3DPROC glad_wglSetGammaTableI3D = NULL;
+PFNWGLSETGAMMATABLEPARAMETERSI3DPROC glad_wglSetGammaTableParametersI3D = NULL;
+PFNWGLSETPBUFFERATTRIBARBPROC glad_wglSetPbufferAttribARB = NULL;
+PFNWGLSETSTEREOEMITTERSTATE3DLPROC glad_wglSetStereoEmitterState3DL = NULL;
+PFNWGLSWAPBUFFERSMSCOMLPROC glad_wglSwapBuffersMscOML = NULL;
+PFNWGLSWAPINTERVALEXTPROC glad_wglSwapIntervalEXT = NULL;
+PFNWGLSWAPLAYERBUFFERSMSCOMLPROC glad_wglSwapLayerBuffersMscOML = NULL;
+PFNWGLWAITFORMSCOMLPROC glad_wglWaitForMscOML = NULL;
+PFNWGLWAITFORSBCOMLPROC glad_wglWaitForSbcOML = NULL;
+
+
+static void glad_wgl_load_WGL_3DL_stereo_control(GLADuserptrloadfunc load, void *userptr) {
+    if(!GLAD_WGL_3DL_stereo_control) return;
+    glad_wglSetStereoEmitterState3DL = (PFNWGLSETSTEREOEMITTERSTATE3DLPROC) load(userptr, "wglSetStereoEmitterState3DL");
+}
+static void glad_wgl_load_WGL_AMD_gpu_association(GLADuserptrloadfunc load, void *userptr) {
+    if(!GLAD_WGL_AMD_gpu_association) return;
+    glad_wglBlitContextFramebufferAMD = (PFNWGLBLITCONTEXTFRAMEBUFFERAMDPROC) load(userptr, "wglBlitContextFramebufferAMD");
+    glad_wglCreateAssociatedContextAMD = (PFNWGLCREATEASSOCIATEDCONTEXTAMDPROC) load(userptr, "wglCreateAssociatedContextAMD");
+    glad_wglCreateAssociatedContextAttribsAMD = (PFNWGLCREATEASSOCIATEDCONTEXTATTRIBSAMDPROC) load(userptr, "wglCreateAssociatedContextAttribsAMD");
+    glad_wglDeleteAssociatedContextAMD = (PFNWGLDELETEASSOCIATEDCONTEXTAMDPROC) load(userptr, "wglDeleteAssociatedContextAMD");
+    glad_wglGetContextGPUIDAMD = (PFNWGLGETCONTEXTGPUIDAMDPROC) load(userptr, "wglGetContextGPUIDAMD");
+    glad_wglGetCurrentAssociatedContextAMD = (PFNWGLGETCURRENTASSOCIATEDCONTEXTAMDPROC) load(userptr, "wglGetCurrentAssociatedContextAMD");
+    glad_wglGetGPUIDsAMD = (PFNWGLGETGPUIDSAMDPROC) load(userptr, "wglGetGPUIDsAMD");
+    glad_wglGetGPUInfoAMD = (PFNWGLGETGPUINFOAMDPROC) load(userptr, "wglGetGPUInfoAMD");
+    glad_wglMakeAssociatedContextCurrentAMD = (PFNWGLMAKEASSOCIATEDCONTEXTCURRENTAMDPROC) load(userptr, "wglMakeAssociatedContextCurrentAMD");
+}
+static void glad_wgl_load_WGL_ARB_buffer_region(GLADuserptrloadfunc load, void *userptr) {
+    if(!GLAD_WGL_ARB_buffer_region) return;
+    glad_wglCreateBufferRegionARB = (PFNWGLCREATEBUFFERREGIONARBPROC) load(userptr, "wglCreateBufferRegionARB");
+    glad_wglDeleteBufferRegionARB = (PFNWGLDELETEBUFFERREGIONARBPROC) load(userptr, "wglDeleteBufferRegionARB");
+    glad_wglRestoreBufferRegionARB = (PFNWGLRESTOREBUFFERREGIONARBPROC) load(userptr, "wglRestoreBufferRegionARB");
+    glad_wglSaveBufferRegionARB = (PFNWGLSAVEBUFFERREGIONARBPROC) load(userptr, "wglSaveBufferRegionARB");
+}
+static void glad_wgl_load_WGL_ARB_create_context(GLADuserptrloadfunc load, void *userptr) {
+    if(!GLAD_WGL_ARB_create_context) return;
+    glad_wglCreateContextAttribsARB = (PFNWGLCREATECONTEXTATTRIBSARBPROC) load(userptr, "wglCreateContextAttribsARB");
+}
+static void glad_wgl_load_WGL_ARB_extensions_string(GLADuserptrloadfunc load, void *userptr) {
+    if(!GLAD_WGL_ARB_extensions_string) return;
+    glad_wglGetExtensionsStringARB = (PFNWGLGETEXTENSIONSSTRINGARBPROC) load(userptr, "wglGetExtensionsStringARB");
+}
+static void glad_wgl_load_WGL_ARB_make_current_read(GLADuserptrloadfunc load, void *userptr) {
+    if(!GLAD_WGL_ARB_make_current_read) return;
+    glad_wglGetCurrentReadDCARB = (PFNWGLGETCURRENTREADDCARBPROC) load(userptr, "wglGetCurrentReadDCARB");
+    glad_wglMakeContextCurrentARB = (PFNWGLMAKECONTEXTCURRENTARBPROC) load(userptr, "wglMakeContextCurrentARB");
+}
+static void glad_wgl_load_WGL_ARB_pbuffer(GLADuserptrloadfunc load, void *userptr) {
+    if(!GLAD_WGL_ARB_pbuffer) return;
+    glad_wglCreatePbufferARB = (PFNWGLCREATEPBUFFERARBPROC) load(userptr, "wglCreatePbufferARB");
+    glad_wglDestroyPbufferARB = (PFNWGLDESTROYPBUFFERARBPROC) load(userptr, "wglDestroyPbufferARB");
+    glad_wglGetPbufferDCARB = (PFNWGLGETPBUFFERDCARBPROC) load(userptr, "wglGetPbufferDCARB");
+    glad_wglQueryPbufferARB = (PFNWGLQUERYPBUFFERARBPROC) load(userptr, "wglQueryPbufferARB");
+    glad_wglReleasePbufferDCARB = (PFNWGLRELEASEPBUFFERDCARBPROC) load(userptr, "wglReleasePbufferDCARB");
+}
+static void glad_wgl_load_WGL_ARB_pixel_format(GLADuserptrloadfunc load, void *userptr) {
+    if(!GLAD_WGL_ARB_pixel_format) return;
+    glad_wglChoosePixelFormatARB = (PFNWGLCHOOSEPIXELFORMATARBPROC) load(userptr, "wglChoosePixelFormatARB");
+    glad_wglGetPixelFormatAttribfvARB = (PFNWGLGETPIXELFORMATATTRIBFVARBPROC) load(userptr, "wglGetPixelFormatAttribfvARB");
+    glad_wglGetPixelFormatAttribivARB = (PFNWGLGETPIXELFORMATATTRIBIVARBPROC) load(userptr, "wglGetPixelFormatAttribivARB");
+}
+static void glad_wgl_load_WGL_ARB_render_texture(GLADuserptrloadfunc load, void *userptr) {
+    if(!GLAD_WGL_ARB_render_texture) return;
+    glad_wglBindTexImageARB = (PFNWGLBINDTEXIMAGEARBPROC) load(userptr, "wglBindTexImageARB");
+    glad_wglReleaseTexImageARB = (PFNWGLRELEASETEXIMAGEARBPROC) load(userptr, "wglReleaseTexImageARB");
+    glad_wglSetPbufferAttribARB = (PFNWGLSETPBUFFERATTRIBARBPROC) load(userptr, "wglSetPbufferAttribARB");
+}
+static void glad_wgl_load_WGL_EXT_display_color_table(GLADuserptrloadfunc load, void *userptr) {
+    if(!GLAD_WGL_EXT_display_color_table) return;
+    glad_wglBindDisplayColorTableEXT = (PFNWGLBINDDISPLAYCOLORTABLEEXTPROC) load(userptr, "wglBindDisplayColorTableEXT");
+    glad_wglCreateDisplayColorTableEXT = (PFNWGLCREATEDISPLAYCOLORTABLEEXTPROC) load(userptr, "wglCreateDisplayColorTableEXT");
+    glad_wglDestroyDisplayColorTableEXT = (PFNWGLDESTROYDISPLAYCOLORTABLEEXTPROC) load(userptr, "wglDestroyDisplayColorTableEXT");
+    glad_wglLoadDisplayColorTableEXT = (PFNWGLLOADDISPLAYCOLORTABLEEXTPROC) load(userptr, "wglLoadDisplayColorTableEXT");
+}
+static void glad_wgl_load_WGL_EXT_extensions_string(GLADuserptrloadfunc load, void *userptr) {
+    if(!GLAD_WGL_EXT_extensions_string) return;
+    glad_wglGetExtensionsStringEXT = (PFNWGLGETEXTENSIONSSTRINGEXTPROC) load(userptr, "wglGetExtensionsStringEXT");
+}
+static void glad_wgl_load_WGL_EXT_make_current_read(GLADuserptrloadfunc load, void *userptr) {
+    if(!GLAD_WGL_EXT_make_current_read) return;
+    glad_wglGetCurrentReadDCEXT = (PFNWGLGETCURRENTREADDCEXTPROC) load(userptr, "wglGetCurrentReadDCEXT");
+    glad_wglMakeContextCurrentEXT = (PFNWGLMAKECONTEXTCURRENTEXTPROC) load(userptr, "wglMakeContextCurrentEXT");
+}
+static void glad_wgl_load_WGL_EXT_pbuffer(GLADuserptrloadfunc load, void *userptr) {
+    if(!GLAD_WGL_EXT_pbuffer) return;
+    glad_wglCreatePbufferEXT = (PFNWGLCREATEPBUFFEREXTPROC) load(userptr, "wglCreatePbufferEXT");
+    glad_wglDestroyPbufferEXT = (PFNWGLDESTROYPBUFFEREXTPROC) load(userptr, "wglDestroyPbufferEXT");
+    glad_wglGetPbufferDCEXT = (PFNWGLGETPBUFFERDCEXTPROC) load(userptr, "wglGetPbufferDCEXT");
+    glad_wglQueryPbufferEXT = (PFNWGLQUERYPBUFFEREXTPROC) load(userptr, "wglQueryPbufferEXT");
+    glad_wglReleasePbufferDCEXT = (PFNWGLRELEASEPBUFFERDCEXTPROC) load(userptr, "wglReleasePbufferDCEXT");
+}
+static void glad_wgl_load_WGL_EXT_pixel_format(GLADuserptrloadfunc load, void *userptr) {
+    if(!GLAD_WGL_EXT_pixel_format) return;
+    glad_wglChoosePixelFormatEXT = (PFNWGLCHOOSEPIXELFORMATEXTPROC) load(userptr, "wglChoosePixelFormatEXT");
+    glad_wglGetPixelFormatAttribfvEXT = (PFNWGLGETPIXELFORMATATTRIBFVEXTPROC) load(userptr, "wglGetPixelFormatAttribfvEXT");
+    glad_wglGetPixelFormatAttribivEXT = (PFNWGLGETPIXELFORMATATTRIBIVEXTPROC) load(userptr, "wglGetPixelFormatAttribivEXT");
+}
+static void glad_wgl_load_WGL_EXT_swap_control(GLADuserptrloadfunc load, void *userptr) {
+    if(!GLAD_WGL_EXT_swap_control) return;
+    glad_wglGetSwapIntervalEXT = (PFNWGLGETSWAPINTERVALEXTPROC) load(userptr, "wglGetSwapIntervalEXT");
+    glad_wglSwapIntervalEXT = (PFNWGLSWAPINTERVALEXTPROC) load(userptr, "wglSwapIntervalEXT");
+}
+static void glad_wgl_load_WGL_I3D_digital_video_control(GLADuserptrloadfunc load, void *userptr) {
+    if(!GLAD_WGL_I3D_digital_video_control) return;
+    glad_wglGetDigitalVideoParametersI3D = (PFNWGLGETDIGITALVIDEOPARAMETERSI3DPROC) load(userptr, "wglGetDigitalVideoParametersI3D");
+    glad_wglSetDigitalVideoParametersI3D = (PFNWGLSETDIGITALVIDEOPARAMETERSI3DPROC) load(userptr, "wglSetDigitalVideoParametersI3D");
+}
+static void glad_wgl_load_WGL_I3D_gamma(GLADuserptrloadfunc load, void *userptr) {
+    if(!GLAD_WGL_I3D_gamma) return;
+    glad_wglGetGammaTableI3D = (PFNWGLGETGAMMATABLEI3DPROC) load(userptr, "wglGetGammaTableI3D");
+    glad_wglGetGammaTableParametersI3D = (PFNWGLGETGAMMATABLEPARAMETERSI3DPROC) load(userptr, "wglGetGammaTableParametersI3D");
+    glad_wglSetGammaTableI3D = (PFNWGLSETGAMMATABLEI3DPROC) load(userptr, "wglSetGammaTableI3D");
+    glad_wglSetGammaTableParametersI3D = (PFNWGLSETGAMMATABLEPARAMETERSI3DPROC) load(userptr, "wglSetGammaTableParametersI3D");
+}
+static void glad_wgl_load_WGL_I3D_genlock(GLADuserptrloadfunc load, void *userptr) {
+    if(!GLAD_WGL_I3D_genlock) return;
+    glad_wglDisableGenlockI3D = (PFNWGLDISABLEGENLOCKI3DPROC) load(userptr, "wglDisableGenlockI3D");
+    glad_wglEnableGenlockI3D = (PFNWGLENABLEGENLOCKI3DPROC) load(userptr, "wglEnableGenlockI3D");
+    glad_wglGenlockSampleRateI3D = (PFNWGLGENLOCKSAMPLERATEI3DPROC) load(userptr, "wglGenlockSampleRateI3D");
+    glad_wglGenlockSourceDelayI3D = (PFNWGLGENLOCKSOURCEDELAYI3DPROC) load(userptr, "wglGenlockSourceDelayI3D");
+    glad_wglGenlockSourceEdgeI3D = (PFNWGLGENLOCKSOURCEEDGEI3DPROC) load(userptr, "wglGenlockSourceEdgeI3D");
+    glad_wglGenlockSourceI3D = (PFNWGLGENLOCKSOURCEI3DPROC) load(userptr, "wglGenlockSourceI3D");
+    glad_wglGetGenlockSampleRateI3D = (PFNWGLGETGENLOCKSAMPLERATEI3DPROC) load(userptr, "wglGetGenlockSampleRateI3D");
+    glad_wglGetGenlockSourceDelayI3D = (PFNWGLGETGENLOCKSOURCEDELAYI3DPROC) load(userptr, "wglGetGenlockSourceDelayI3D");
+    glad_wglGetGenlockSourceEdgeI3D = (PFNWGLGETGENLOCKSOURCEEDGEI3DPROC) load(userptr, "wglGetGenlockSourceEdgeI3D");
+    glad_wglGetGenlockSourceI3D = (PFNWGLGETGENLOCKSOURCEI3DPROC) load(userptr, "wglGetGenlockSourceI3D");
+    glad_wglIsEnabledGenlockI3D = (PFNWGLISENABLEDGENLOCKI3DPROC) load(userptr, "wglIsEnabledGenlockI3D");
+    glad_wglQueryGenlockMaxSourceDelayI3D = (PFNWGLQUERYGENLOCKMAXSOURCEDELAYI3DPROC) load(userptr, "wglQueryGenlockMaxSourceDelayI3D");
+}
+static void glad_wgl_load_WGL_I3D_image_buffer(GLADuserptrloadfunc load, void *userptr) {
+    if(!GLAD_WGL_I3D_image_buffer) return;
+    glad_wglAssociateImageBufferEventsI3D = (PFNWGLASSOCIATEIMAGEBUFFEREVENTSI3DPROC) load(userptr, "wglAssociateImageBufferEventsI3D");
+    glad_wglCreateImageBufferI3D = (PFNWGLCREATEIMAGEBUFFERI3DPROC) load(userptr, "wglCreateImageBufferI3D");
+    glad_wglDestroyImageBufferI3D = (PFNWGLDESTROYIMAGEBUFFERI3DPROC) load(userptr, "wglDestroyImageBufferI3D");
+    glad_wglReleaseImageBufferEventsI3D = (PFNWGLRELEASEIMAGEBUFFEREVENTSI3DPROC) load(userptr, "wglReleaseImageBufferEventsI3D");
+}
+static void glad_wgl_load_WGL_I3D_swap_frame_lock(GLADuserptrloadfunc load, void *userptr) {
+    if(!GLAD_WGL_I3D_swap_frame_lock) return;
+    glad_wglDisableFrameLockI3D = (PFNWGLDISABLEFRAMELOCKI3DPROC) load(userptr, "wglDisableFrameLockI3D");
+    glad_wglEnableFrameLockI3D = (PFNWGLENABLEFRAMELOCKI3DPROC) load(userptr, "wglEnableFrameLockI3D");
+    glad_wglIsEnabledFrameLockI3D = (PFNWGLISENABLEDFRAMELOCKI3DPROC) load(userptr, "wglIsEnabledFrameLockI3D");
+    glad_wglQueryFrameLockMasterI3D = (PFNWGLQUERYFRAMELOCKMASTERI3DPROC) load(userptr, "wglQueryFrameLockMasterI3D");
+}
+static void glad_wgl_load_WGL_I3D_swap_frame_usage(GLADuserptrloadfunc load, void *userptr) {
+    if(!GLAD_WGL_I3D_swap_frame_usage) return;
+    glad_wglBeginFrameTrackingI3D = (PFNWGLBEGINFRAMETRACKINGI3DPROC) load(userptr, "wglBeginFrameTrackingI3D");
+    glad_wglEndFrameTrackingI3D = (PFNWGLENDFRAMETRACKINGI3DPROC) load(userptr, "wglEndFrameTrackingI3D");
+    glad_wglGetFrameUsageI3D = (PFNWGLGETFRAMEUSAGEI3DPROC) load(userptr, "wglGetFrameUsageI3D");
+    glad_wglQueryFrameTrackingI3D = (PFNWGLQUERYFRAMETRACKINGI3DPROC) load(userptr, "wglQueryFrameTrackingI3D");
+}
+static void glad_wgl_load_WGL_NV_DX_interop(GLADuserptrloadfunc load, void *userptr) {
+    if(!GLAD_WGL_NV_DX_interop) return;
+    glad_wglDXCloseDeviceNV = (PFNWGLDXCLOSEDEVICENVPROC) load(userptr, "wglDXCloseDeviceNV");
+    glad_wglDXLockObjectsNV = (PFNWGLDXLOCKOBJECTSNVPROC) load(userptr, "wglDXLockObjectsNV");
+    glad_wglDXObjectAccessNV = (PFNWGLDXOBJECTACCESSNVPROC) load(userptr, "wglDXObjectAccessNV");
+    glad_wglDXOpenDeviceNV = (PFNWGLDXOPENDEVICENVPROC) load(userptr, "wglDXOpenDeviceNV");
+    glad_wglDXRegisterObjectNV = (PFNWGLDXREGISTEROBJECTNVPROC) load(userptr, "wglDXRegisterObjectNV");
+    glad_wglDXSetResourceShareHandleNV = (PFNWGLDXSETRESOURCESHAREHANDLENVPROC) load(userptr, "wglDXSetResourceShareHandleNV");
+    glad_wglDXUnlockObjectsNV = (PFNWGLDXUNLOCKOBJECTSNVPROC) load(userptr, "wglDXUnlockObjectsNV");
+    glad_wglDXUnregisterObjectNV = (PFNWGLDXUNREGISTEROBJECTNVPROC) load(userptr, "wglDXUnregisterObjectNV");
+}
+static void glad_wgl_load_WGL_NV_copy_image(GLADuserptrloadfunc load, void *userptr) {
+    if(!GLAD_WGL_NV_copy_image) return;
+    glad_wglCopyImageSubDataNV = (PFNWGLCOPYIMAGESUBDATANVPROC) load(userptr, "wglCopyImageSubDataNV");
+}
+static void glad_wgl_load_WGL_NV_delay_before_swap(GLADuserptrloadfunc load, void *userptr) {
+    if(!GLAD_WGL_NV_delay_before_swap) return;
+    glad_wglDelayBeforeSwapNV = (PFNWGLDELAYBEFORESWAPNVPROC) load(userptr, "wglDelayBeforeSwapNV");
+}
+static void glad_wgl_load_WGL_NV_gpu_affinity(GLADuserptrloadfunc load, void *userptr) {
+    if(!GLAD_WGL_NV_gpu_affinity) return;
+    glad_wglCreateAffinityDCNV = (PFNWGLCREATEAFFINITYDCNVPROC) load(userptr, "wglCreateAffinityDCNV");
+    glad_wglDeleteDCNV = (PFNWGLDELETEDCNVPROC) load(userptr, "wglDeleteDCNV");
+    glad_wglEnumGpuDevicesNV = (PFNWGLENUMGPUDEVICESNVPROC) load(userptr, "wglEnumGpuDevicesNV");
+    glad_wglEnumGpusFromAffinityDCNV = (PFNWGLENUMGPUSFROMAFFINITYDCNVPROC) load(userptr, "wglEnumGpusFromAffinityDCNV");
+    glad_wglEnumGpusNV = (PFNWGLENUMGPUSNVPROC) load(userptr, "wglEnumGpusNV");
+}
+static void glad_wgl_load_WGL_NV_present_video(GLADuserptrloadfunc load, void *userptr) {
+    if(!GLAD_WGL_NV_present_video) return;
+    glad_wglBindVideoDeviceNV = (PFNWGLBINDVIDEODEVICENVPROC) load(userptr, "wglBindVideoDeviceNV");
+    glad_wglEnumerateVideoDevicesNV = (PFNWGLENUMERATEVIDEODEVICESNVPROC) load(userptr, "wglEnumerateVideoDevicesNV");
+    glad_wglQueryCurrentContextNV = (PFNWGLQUERYCURRENTCONTEXTNVPROC) load(userptr, "wglQueryCurrentContextNV");
+}
+static void glad_wgl_load_WGL_NV_swap_group(GLADuserptrloadfunc load, void *userptr) {
+    if(!GLAD_WGL_NV_swap_group) return;
+    glad_wglBindSwapBarrierNV = (PFNWGLBINDSWAPBARRIERNVPROC) load(userptr, "wglBindSwapBarrierNV");
+    glad_wglJoinSwapGroupNV = (PFNWGLJOINSWAPGROUPNVPROC) load(userptr, "wglJoinSwapGroupNV");
+    glad_wglQueryFrameCountNV = (PFNWGLQUERYFRAMECOUNTNVPROC) load(userptr, "wglQueryFrameCountNV");
+    glad_wglQueryMaxSwapGroupsNV = (PFNWGLQUERYMAXSWAPGROUPSNVPROC) load(userptr, "wglQueryMaxSwapGroupsNV");
+    glad_wglQuerySwapGroupNV = (PFNWGLQUERYSWAPGROUPNVPROC) load(userptr, "wglQuerySwapGroupNV");
+    glad_wglResetFrameCountNV = (PFNWGLRESETFRAMECOUNTNVPROC) load(userptr, "wglResetFrameCountNV");
+}
+static void glad_wgl_load_WGL_NV_vertex_array_range(GLADuserptrloadfunc load, void *userptr) {
+    if(!GLAD_WGL_NV_vertex_array_range) return;
+    glad_wglAllocateMemoryNV = (PFNWGLALLOCATEMEMORYNVPROC) load(userptr, "wglAllocateMemoryNV");
+    glad_wglFreeMemoryNV = (PFNWGLFREEMEMORYNVPROC) load(userptr, "wglFreeMemoryNV");
+}
+static void glad_wgl_load_WGL_NV_video_capture(GLADuserptrloadfunc load, void *userptr) {
+    if(!GLAD_WGL_NV_video_capture) return;
+    glad_wglBindVideoCaptureDeviceNV = (PFNWGLBINDVIDEOCAPTUREDEVICENVPROC) load(userptr, "wglBindVideoCaptureDeviceNV");
+    glad_wglEnumerateVideoCaptureDevicesNV = (PFNWGLENUMERATEVIDEOCAPTUREDEVICESNVPROC) load(userptr, "wglEnumerateVideoCaptureDevicesNV");
+    glad_wglLockVideoCaptureDeviceNV = (PFNWGLLOCKVIDEOCAPTUREDEVICENVPROC) load(userptr, "wglLockVideoCaptureDeviceNV");
+    glad_wglQueryVideoCaptureDeviceNV = (PFNWGLQUERYVIDEOCAPTUREDEVICENVPROC) load(userptr, "wglQueryVideoCaptureDeviceNV");
+    glad_wglReleaseVideoCaptureDeviceNV = (PFNWGLRELEASEVIDEOCAPTUREDEVICENVPROC) load(userptr, "wglReleaseVideoCaptureDeviceNV");
+}
+static void glad_wgl_load_WGL_NV_video_output(GLADuserptrloadfunc load, void *userptr) {
+    if(!GLAD_WGL_NV_video_output) return;
+    glad_wglBindVideoImageNV = (PFNWGLBINDVIDEOIMAGENVPROC) load(userptr, "wglBindVideoImageNV");
+    glad_wglGetVideoDeviceNV = (PFNWGLGETVIDEODEVICENVPROC) load(userptr, "wglGetVideoDeviceNV");
+    glad_wglGetVideoInfoNV = (PFNWGLGETVIDEOINFONVPROC) load(userptr, "wglGetVideoInfoNV");
+    glad_wglReleaseVideoDeviceNV = (PFNWGLRELEASEVIDEODEVICENVPROC) load(userptr, "wglReleaseVideoDeviceNV");
+    glad_wglReleaseVideoImageNV = (PFNWGLRELEASEVIDEOIMAGENVPROC) load(userptr, "wglReleaseVideoImageNV");
+    glad_wglSendPbufferToVideoNV = (PFNWGLSENDPBUFFERTOVIDEONVPROC) load(userptr, "wglSendPbufferToVideoNV");
+}
+static void glad_wgl_load_WGL_OML_sync_control(GLADuserptrloadfunc load, void *userptr) {
+    if(!GLAD_WGL_OML_sync_control) return;
+    glad_wglGetMscRateOML = (PFNWGLGETMSCRATEOMLPROC) load(userptr, "wglGetMscRateOML");
+    glad_wglGetSyncValuesOML = (PFNWGLGETSYNCVALUESOMLPROC) load(userptr, "wglGetSyncValuesOML");
+    glad_wglSwapBuffersMscOML = (PFNWGLSWAPBUFFERSMSCOMLPROC) load(userptr, "wglSwapBuffersMscOML");
+    glad_wglSwapLayerBuffersMscOML = (PFNWGLSWAPLAYERBUFFERSMSCOMLPROC) load(userptr, "wglSwapLayerBuffersMscOML");
+    glad_wglWaitForMscOML = (PFNWGLWAITFORMSCOMLPROC) load(userptr, "wglWaitForMscOML");
+    glad_wglWaitForSbcOML = (PFNWGLWAITFORSBCOMLPROC) load(userptr, "wglWaitForSbcOML");
+}
+
+
+
+static int glad_wgl_has_extension(HDC hdc, const char *ext) {
+    const char *terminator;
+    const char *loc;
+    const char *extensions;
+
+    if(wglGetExtensionsStringEXT == NULL && wglGetExtensionsStringARB == NULL)
+        return 0;
+
+    if(wglGetExtensionsStringARB == NULL || hdc == INVALID_HANDLE_VALUE)
+        extensions = wglGetExtensionsStringEXT();
+    else
+        extensions = wglGetExtensionsStringARB(hdc);
+
+    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;
+}
+
+static GLADapiproc glad_wgl_get_proc_from_userptr(void *userptr, const char* name) {
+    return (GLAD_GNUC_EXTENSION (GLADapiproc (*)(const char *name)) userptr)(name);
+}
+
+static int glad_wgl_find_extensions_wgl(HDC hdc) {
+    GLAD_WGL_3DFX_multisample = glad_wgl_has_extension(hdc, "WGL_3DFX_multisample");
+    GLAD_WGL_3DL_stereo_control = glad_wgl_has_extension(hdc, "WGL_3DL_stereo_control");
+    GLAD_WGL_AMD_gpu_association = glad_wgl_has_extension(hdc, "WGL_AMD_gpu_association");
+    GLAD_WGL_ARB_buffer_region = glad_wgl_has_extension(hdc, "WGL_ARB_buffer_region");
+    GLAD_WGL_ARB_context_flush_control = glad_wgl_has_extension(hdc, "WGL_ARB_context_flush_control");
+    GLAD_WGL_ARB_create_context = glad_wgl_has_extension(hdc, "WGL_ARB_create_context");
+    GLAD_WGL_ARB_create_context_no_error = glad_wgl_has_extension(hdc, "WGL_ARB_create_context_no_error");
+    GLAD_WGL_ARB_create_context_profile = glad_wgl_has_extension(hdc, "WGL_ARB_create_context_profile");
+    GLAD_WGL_ARB_create_context_robustness = glad_wgl_has_extension(hdc, "WGL_ARB_create_context_robustness");
+    GLAD_WGL_ARB_extensions_string = glad_wgl_has_extension(hdc, "WGL_ARB_extensions_string");
+    GLAD_WGL_ARB_framebuffer_sRGB = glad_wgl_has_extension(hdc, "WGL_ARB_framebuffer_sRGB");
+    GLAD_WGL_ARB_make_current_read = glad_wgl_has_extension(hdc, "WGL_ARB_make_current_read");
+    GLAD_WGL_ARB_multisample = glad_wgl_has_extension(hdc, "WGL_ARB_multisample");
+    GLAD_WGL_ARB_pbuffer = glad_wgl_has_extension(hdc, "WGL_ARB_pbuffer");
+    GLAD_WGL_ARB_pixel_format = glad_wgl_has_extension(hdc, "WGL_ARB_pixel_format");
+    GLAD_WGL_ARB_pixel_format_float = glad_wgl_has_extension(hdc, "WGL_ARB_pixel_format_float");
+    GLAD_WGL_ARB_render_texture = glad_wgl_has_extension(hdc, "WGL_ARB_render_texture");
+    GLAD_WGL_ARB_robustness_application_isolation = glad_wgl_has_extension(hdc, "WGL_ARB_robustness_application_isolation");
+    GLAD_WGL_ARB_robustness_share_group_isolation = glad_wgl_has_extension(hdc, "WGL_ARB_robustness_share_group_isolation");
+    GLAD_WGL_ATI_pixel_format_float = glad_wgl_has_extension(hdc, "WGL_ATI_pixel_format_float");
+    GLAD_WGL_ATI_render_texture_rectangle = glad_wgl_has_extension(hdc, "WGL_ATI_render_texture_rectangle");
+    GLAD_WGL_EXT_colorspace = glad_wgl_has_extension(hdc, "WGL_EXT_colorspace");
+    GLAD_WGL_EXT_create_context_es2_profile = glad_wgl_has_extension(hdc, "WGL_EXT_create_context_es2_profile");
+    GLAD_WGL_EXT_create_context_es_profile = glad_wgl_has_extension(hdc, "WGL_EXT_create_context_es_profile");
+    GLAD_WGL_EXT_depth_float = glad_wgl_has_extension(hdc, "WGL_EXT_depth_float");
+    GLAD_WGL_EXT_display_color_table = glad_wgl_has_extension(hdc, "WGL_EXT_display_color_table");
+    GLAD_WGL_EXT_extensions_string = glad_wgl_has_extension(hdc, "WGL_EXT_extensions_string");
+    GLAD_WGL_EXT_framebuffer_sRGB = glad_wgl_has_extension(hdc, "WGL_EXT_framebuffer_sRGB");
+    GLAD_WGL_EXT_make_current_read = glad_wgl_has_extension(hdc, "WGL_EXT_make_current_read");
+    GLAD_WGL_EXT_multisample = glad_wgl_has_extension(hdc, "WGL_EXT_multisample");
+    GLAD_WGL_EXT_pbuffer = glad_wgl_has_extension(hdc, "WGL_EXT_pbuffer");
+    GLAD_WGL_EXT_pixel_format = glad_wgl_has_extension(hdc, "WGL_EXT_pixel_format");
+    GLAD_WGL_EXT_pixel_format_packed_float = glad_wgl_has_extension(hdc, "WGL_EXT_pixel_format_packed_float");
+    GLAD_WGL_EXT_swap_control = glad_wgl_has_extension(hdc, "WGL_EXT_swap_control");
+    GLAD_WGL_EXT_swap_control_tear = glad_wgl_has_extension(hdc, "WGL_EXT_swap_control_tear");
+    GLAD_WGL_I3D_digital_video_control = glad_wgl_has_extension(hdc, "WGL_I3D_digital_video_control");
+    GLAD_WGL_I3D_gamma = glad_wgl_has_extension(hdc, "WGL_I3D_gamma");
+    GLAD_WGL_I3D_genlock = glad_wgl_has_extension(hdc, "WGL_I3D_genlock");
+    GLAD_WGL_I3D_image_buffer = glad_wgl_has_extension(hdc, "WGL_I3D_image_buffer");
+    GLAD_WGL_I3D_swap_frame_lock = glad_wgl_has_extension(hdc, "WGL_I3D_swap_frame_lock");
+    GLAD_WGL_I3D_swap_frame_usage = glad_wgl_has_extension(hdc, "WGL_I3D_swap_frame_usage");
+    GLAD_WGL_NV_DX_interop = glad_wgl_has_extension(hdc, "WGL_NV_DX_interop");
+    GLAD_WGL_NV_DX_interop2 = glad_wgl_has_extension(hdc, "WGL_NV_DX_interop2");
+    GLAD_WGL_NV_copy_image = glad_wgl_has_extension(hdc, "WGL_NV_copy_image");
+    GLAD_WGL_NV_delay_before_swap = glad_wgl_has_extension(hdc, "WGL_NV_delay_before_swap");
+    GLAD_WGL_NV_float_buffer = glad_wgl_has_extension(hdc, "WGL_NV_float_buffer");
+    GLAD_WGL_NV_gpu_affinity = glad_wgl_has_extension(hdc, "WGL_NV_gpu_affinity");
+    GLAD_WGL_NV_multigpu_context = glad_wgl_has_extension(hdc, "WGL_NV_multigpu_context");
+    GLAD_WGL_NV_multisample_coverage = glad_wgl_has_extension(hdc, "WGL_NV_multisample_coverage");
+    GLAD_WGL_NV_present_video = glad_wgl_has_extension(hdc, "WGL_NV_present_video");
+    GLAD_WGL_NV_render_depth_texture = glad_wgl_has_extension(hdc, "WGL_NV_render_depth_texture");
+    GLAD_WGL_NV_render_texture_rectangle = glad_wgl_has_extension(hdc, "WGL_NV_render_texture_rectangle");
+    GLAD_WGL_NV_swap_group = glad_wgl_has_extension(hdc, "WGL_NV_swap_group");
+    GLAD_WGL_NV_vertex_array_range = glad_wgl_has_extension(hdc, "WGL_NV_vertex_array_range");
+    GLAD_WGL_NV_video_capture = glad_wgl_has_extension(hdc, "WGL_NV_video_capture");
+    GLAD_WGL_NV_video_output = glad_wgl_has_extension(hdc, "WGL_NV_video_output");
+    GLAD_WGL_OML_sync_control = glad_wgl_has_extension(hdc, "WGL_OML_sync_control");
+    return 1;
+}
+
+static int glad_wgl_find_core_wgl(void) {
+    int major = 1, minor = 0;
+    GLAD_WGL_VERSION_1_0 = (major == 1 && minor >= 0) || major > 1;
+    return GLAD_MAKE_VERSION(major, minor);
+}
+
+int gladLoadWGLUserPtr(HDC hdc, GLADuserptrloadfunc load, void *userptr) {
+    int version;
+    wglGetExtensionsStringARB = (PFNWGLGETEXTENSIONSSTRINGARBPROC) load(userptr, "wglGetExtensionsStringARB");
+    wglGetExtensionsStringEXT = (PFNWGLGETEXTENSIONSSTRINGEXTPROC) load(userptr, "wglGetExtensionsStringEXT");
+    if(wglGetExtensionsStringARB == NULL && wglGetExtensionsStringEXT == NULL) return 0;
+    version = glad_wgl_find_core_wgl();
+
+
+    if (!glad_wgl_find_extensions_wgl(hdc)) return 0;
+    glad_wgl_load_WGL_3DL_stereo_control(load, userptr);
+    glad_wgl_load_WGL_AMD_gpu_association(load, userptr);
+    glad_wgl_load_WGL_ARB_buffer_region(load, userptr);
+    glad_wgl_load_WGL_ARB_create_context(load, userptr);
+    glad_wgl_load_WGL_ARB_extensions_string(load, userptr);
+    glad_wgl_load_WGL_ARB_make_current_read(load, userptr);
+    glad_wgl_load_WGL_ARB_pbuffer(load, userptr);
+    glad_wgl_load_WGL_ARB_pixel_format(load, userptr);
+    glad_wgl_load_WGL_ARB_render_texture(load, userptr);
+    glad_wgl_load_WGL_EXT_display_color_table(load, userptr);
+    glad_wgl_load_WGL_EXT_extensions_string(load, userptr);
+    glad_wgl_load_WGL_EXT_make_current_read(load, userptr);
+    glad_wgl_load_WGL_EXT_pbuffer(load, userptr);
+    glad_wgl_load_WGL_EXT_pixel_format(load, userptr);
+    glad_wgl_load_WGL_EXT_swap_control(load, userptr);
+    glad_wgl_load_WGL_I3D_digital_video_control(load, userptr);
+    glad_wgl_load_WGL_I3D_gamma(load, userptr);
+    glad_wgl_load_WGL_I3D_genlock(load, userptr);
+    glad_wgl_load_WGL_I3D_image_buffer(load, userptr);
+    glad_wgl_load_WGL_I3D_swap_frame_lock(load, userptr);
+    glad_wgl_load_WGL_I3D_swap_frame_usage(load, userptr);
+    glad_wgl_load_WGL_NV_DX_interop(load, userptr);
+    glad_wgl_load_WGL_NV_copy_image(load, userptr);
+    glad_wgl_load_WGL_NV_delay_before_swap(load, userptr);
+    glad_wgl_load_WGL_NV_gpu_affinity(load, userptr);
+    glad_wgl_load_WGL_NV_present_video(load, userptr);
+    glad_wgl_load_WGL_NV_swap_group(load, userptr);
+    glad_wgl_load_WGL_NV_vertex_array_range(load, userptr);
+    glad_wgl_load_WGL_NV_video_capture(load, userptr);
+    glad_wgl_load_WGL_NV_video_output(load, userptr);
+    glad_wgl_load_WGL_OML_sync_control(load, userptr);
+
+
+    return version;
+}
+
+int gladLoadWGL(HDC hdc, GLADloadfunc load) {
+    return gladLoadWGLUserPtr(hdc, glad_wgl_get_proc_from_userptr, GLAD_GNUC_EXTENSION (void*) load);
+}
+ 
+
+
+#ifdef __cplusplus
+}
+#endif

src/util/CMakeLists.txt

@@ -130,11 +130,6 @@ if(ENABLE_OPENGL)
         gl/context_egl_x11.cpp
         gl/context_egl_x11.h
       )
-
-      # We set EGL_NO_X11 because otherwise X comes in with its macros and breaks
-      # a bunch of files from compiling, if we include the EGL headers. This just
-      # makes the data types opaque, we can still use it with X11 if needed.
-      target_compile_definitions(util PRIVATE "-DEGL_NO_X11=1")
     endif()
     if(ENABLE_WAYLAND)
       target_sources(util PRIVATE

src/util/gl/context.cpp

@@ -186,7 +186,7 @@ std::unique_ptr<GL::Context> Context::Create(const WindowInfo& wi, Error* error)
   // load up glad
   if (!context->IsGLES())
   {
-    if (!gladLoadGLLoader([](const char* name) { return context_being_created->GetProcAddress(name); }))
+    if (!gladLoadGL([](const char* name) { return (GLADapiproc)context_being_created->GetProcAddress(name); }))
     {
       Error::SetStringView(error, "Failed to load GL functions for GLAD");
       return nullptr;
@@ -194,7 +194,7 @@ std::unique_ptr<GL::Context> Context::Create(const WindowInfo& wi, Error* error)
   }
   else
   {
-    if (!gladLoadGLES2Loader([](const char* name) { return context_being_created->GetProcAddress(name); }))
+    if (!gladLoadGLES2([](const char* name) { return (GLADapiproc)context_being_created->GetProcAddress(name); }))
     {
       Error::SetStringView(error, "Failed to load GLES functions for GLAD");
       return nullptr;

src/util/gl/context.h

@@ -55,7 +55,7 @@ public:
   virtual bool MakeCurrent() = 0;
   virtual bool DoneCurrent() = 0;
   virtual bool SetSwapInterval(s32 interval) = 0;
-  virtual std::unique_ptr<Context> CreateSharedContext(const WindowInfo& wi) = 0;
+  virtual std::unique_ptr<Context> CreateSharedContext(const WindowInfo& wi, Error* error) = 0;
 
   virtual std::vector<FullscreenModeInfo> EnumerateFullscreenModes();
 

src/util/gl/context_agl.h

@@ -2,8 +2,8 @@
 // SPDX-License-Identifier: (GPL-3.0 OR CC-BY-NC-ND-4.0)
 
 #pragma once
-#include "context.h"
 #include "../opengl_loader.h"
+#include "context.h"
 
 #if defined(__APPLE__) && defined(__OBJC__)
 #import <AppKit/AppKit.h>
@@ -32,7 +32,7 @@ public:
   bool MakeCurrent() override;
   bool DoneCurrent() override;
   bool SetSwapInterval(s32 interval) override;
-  std::unique_ptr<Context> CreateSharedContext(const WindowInfo& wi) override;
+  std::unique_ptr<Context> CreateSharedContext(const WindowInfo& wi, Error* error) override;
 
 private:
   ALWAYS_INLINE NSView* GetView() const { return static_cast<NSView*>((__bridge NSView*)m_wi.window_handle); }

src/util/gl/context_agl.mm

@@ -3,6 +3,7 @@
 
 #include "context_agl.h"
 #include "common/assert.h"
+#include "common/error.h"
 #include "common/log.h"
 #include <dlfcn.h>
 Log_SetChannel(GL::Context);
@@ -53,10 +54,11 @@ bool ContextAGL::Initialize(const std::span<const Version> versions_to_try)
     {
       if (cv.major_version > 4 || cv.minor_version > 1)
         continue;
-      
+
-      const NSOpenGLPixelFormatAttribute profile = (cv.major_version > 3 || cv.minor_version > 2) ? NSOpenGLProfileVersion4_1Core : NSOpenGLProfileVersion3_2Core;
+      const NSOpenGLPixelFormatAttribute profile =
+        (cv.major_version > 3 || cv.minor_version > 2) ? NSOpenGLProfileVersion4_1Core : NSOpenGLProfileVersion3_2Core;
       if (CreateContext(nullptr, static_cast<int>(profile), true))
-      {        
+      {
         m_version = cv;
         return true;
       }
@@ -142,13 +144,16 @@ bool ContextAGL::SetSwapInterval(s32 interval)
   return true;
 }
 
-std::unique_ptr<Context> ContextAGL::CreateSharedContext(const WindowInfo& wi)
+std::unique_ptr<Context> ContextAGL::CreateSharedContext(const WindowInfo& wi, Error* error)
 {
   std::unique_ptr<ContextAGL> context = std::make_unique<ContextAGL>(wi);
 
   context->m_context = [[NSOpenGLContext alloc] initWithFormat:m_pixel_format shareContext:m_context];
   if (context->m_context == nil)
+  {
+    Error::SetStringView(error, "NSOpenGLContext initWithFormat failed");
     return nullptr;
+  }
 
   context->m_version = m_version;
   context->m_pixel_format = m_pixel_format;
@@ -156,7 +161,7 @@ std::unique_ptr<Context> ContextAGL::CreateSharedContext(const WindowInfo& wi)
 
   if (wi.type == WindowInfo::Type::MacOS)
     context->BindContextToView();
-  
+
   return context;
 }
 
@@ -171,12 +176,9 @@ bool ContextAGL::CreateContext(NSOpenGLContext* share_context, int profile, bool
   if (m_pixel_format)
     [m_pixel_format release];
 
-  const std::array<NSOpenGLPixelFormatAttribute, 5> attribs = {{
+  const std::array<NSOpenGLPixelFormatAttribute, 5> attribs = {{NSOpenGLPFADoubleBuffer, NSOpenGLPFAOpenGLProfile,
-      NSOpenGLPFADoubleBuffer,
+                                                                static_cast<NSOpenGLPixelFormatAttribute>(profile),
-      NSOpenGLPFAOpenGLProfile,
+                                                                NSOpenGLPFAAccelerated, 0}};
-      static_cast<NSOpenGLPixelFormatAttribute>(profile),
-      NSOpenGLPFAAccelerated,
-      0}};
   m_pixel_format = [[NSOpenGLPixelFormat alloc] initWithAttributes:attribs.data()];
   if (m_pixel_format == nil)
   {

src/util/gl/context_egl.cpp

@@ -4,26 +4,74 @@
 #include "context_egl.h"
 
 #include "common/assert.h"
-#include "common/log.h"
+#include "common/dynamic_library.h"
 #include "common/error.h"
+#include "common/log.h"
 
+#include <atomic>
 #include <optional>
 #include <vector>
 
 Log_SetChannel(GL::Context);
 
+static DynamicLibrary s_egl_library;
+static std::atomic_uint32_t s_egl_refcount = 0;
+
+static bool LoadEGL()
+{
+  // We're not going to be calling this from multiple threads concurrently.
+  // So, not wrapping this in a mutex should be fine.
+  if (s_egl_refcount.fetch_add(1, std::memory_order_acq_rel) == 0)
+  {
+    DebugAssert(!s_egl_library.IsOpen());
+
+    const std::string egl_libname = DynamicLibrary::GetVersionedFilename("libEGL");
+    Log_InfoFmt("Loading EGL from {}...", egl_libname);
+
+    Error error;
+    if (!s_egl_library.Open(egl_libname.c_str(), &error))
+      Log_ErrorFmt("Failed to load EGL: {}", error.GetDescription());
+  }
+
+  return s_egl_library.IsOpen();
+}
+
+static void UnloadEGL()
+{
+  DebugAssert(s_egl_refcount.load(std::memory_order_acquire) > 0);
+  if (s_egl_refcount.fetch_sub(1, std::memory_order_acq_rel) == 1)
+  {
+    Log_InfoPrint("Unloading EGL.");
+    s_egl_library.Close();
+  }
+}
+
+static bool LoadGLADEGL(EGLDisplay display, Error* error)
+{
+  if (!gladLoadEGL(display, [](const char* name) { return (GLADapiproc)s_egl_library.GetSymbolAddress(name); }))
+  {
+    Error::SetStringView(error, "Loading GLAD EGL functions failed");
+    return false;
+  }
+
+  return true;
+}
+
 namespace GL {
 ContextEGL::ContextEGL(const WindowInfo& wi) : Context(wi)
 {
+  LoadEGL();
 }
 
 ContextEGL::~ContextEGL()
 {
   DestroySurface();
   DestroyContext();
+  UnloadEGL();
 }
 
-std::unique_ptr<Context> ContextEGL::Create(const WindowInfo& wi, std::span<const Version> versions_to_try, Error* error)
+std::unique_ptr<Context> ContextEGL::Create(const WindowInfo& wi, std::span<const Version> versions_to_try,
+                                            Error* error)
 {
   std::unique_ptr<ContextEGL> context = std::make_unique<ContextEGL>(wi);
   if (!context->Initialize(versions_to_try, error))
@@ -34,30 +82,29 @@ std::unique_ptr<Context> ContextEGL::Create(const WindowInfo& wi, std::span<cons
 
 bool ContextEGL::Initialize(std::span<const Version> versions_to_try, Error* error)
 {
-  if (!gladLoadEGL())
+  if (!LoadGLADEGL(EGL_NO_DISPLAY, error))
-  {
-    Log_ErrorPrint("Loading GLAD EGL functions failed");
-    Error::SetStringView(error, "Loading GLAD EGL functions failed");
     return false;
-  }
 
   if (!SetDisplay())
     return false;
 
+  // Re-initialize GLAD.
+  if (!LoadGLADEGL(m_display, error))
+    return false;
+
   int egl_major, egl_minor;
   if (!eglInitialize(m_display, &egl_major, &egl_minor))
   {
     const int gerror = static_cast<int>(eglGetError());
-    Log_ErrorFmt("eglInitialize() failed: {} (0x{:X})", gerror, gerror);
     Error::SetStringFmt(error, "eglInitialize() failed: {} (0x{:X})", gerror, gerror);
     return false;
   }
-  Log_InfoPrintf("EGL Version: %d.%d", egl_major, egl_minor);
+  Log_InfoFmt("EGL Version: {}.{}", egl_major, egl_minor);
 
   const char* extensions = eglQueryString(m_display, EGL_EXTENSIONS);
   if (extensions)
   {
-    Log_InfoPrintf("EGL Extensions: %s", extensions);
+    Log_DebugFmt("EGL Extensions: {}", extensions);
     m_supports_surfaceless = std::strstr(extensions, "EGL_KHR_surfaceless_context") != nullptr;
   }
   if (!m_supports_surfaceless)
@@ -168,14 +215,17 @@ bool ContextEGL::SetSwapInterval(s32 interval)
   return eglSwapInterval(m_display, interval);
 }
 
-std::unique_ptr<Context> ContextEGL::CreateSharedContext(const WindowInfo& wi)
+std::unique_ptr<Context> ContextEGL::CreateSharedContext(const WindowInfo& wi, Error* error)
 {
   std::unique_ptr<ContextEGL> context = std::make_unique<ContextEGL>(wi);
   context->m_display = m_display;
   context->m_supports_surfaceless = m_supports_surfaceless;
 
   if (!context->CreateContextAndSurface(m_version, m_context, false))
+  {
+    Error::SetStringView(error, "Failed to create context/surface");
     return nullptr;
+  }
 
   return context;
 }

src/util/gl/context_egl.h

@@ -5,7 +5,7 @@
 
 #include "context.h"
 
-#include "glad_egl.h"
+#include "glad/egl.h"
 
 namespace GL {
 
@@ -25,7 +25,7 @@ public:
   bool MakeCurrent() override;
   bool DoneCurrent() override;
   bool SetSwapInterval(s32 interval) override;
-  virtual std::unique_ptr<Context> CreateSharedContext(const WindowInfo& wi) override;
+  virtual std::unique_ptr<Context> CreateSharedContext(const WindowInfo& wi, Error* error) override;
 
 protected:
   virtual bool SetDisplay();

src/util/gl/context_egl_wayland.cpp

@@ -33,7 +33,7 @@ std::unique_ptr<Context> ContextEGLWayland::Create(const WindowInfo& wi, std::sp
   return context;
 }
 
-std::unique_ptr<Context> ContextEGLWayland::CreateSharedContext(const WindowInfo& wi)
+std::unique_ptr<Context> ContextEGLWayland::CreateSharedContext(const WindowInfo& wi, Error* error)
 {
   std::unique_ptr<ContextEGLWayland> context = std::make_unique<ContextEGLWayland>(wi);
   context->m_display = m_display;

src/util/gl/context_egl_wayland.h

@@ -15,7 +15,7 @@ public:
 
   static std::unique_ptr<Context> Create(const WindowInfo& wi, std::span<const Version> versions_to_try, Error* error);
 
-  std::unique_ptr<Context> CreateSharedContext(const WindowInfo& wi) override;
+  std::unique_ptr<Context> CreateSharedContext(const WindowInfo& wi, Error* error) override;
   void ResizeSurface(u32 new_surface_width = 0, u32 new_surface_height = 0) override;
 
 protected:

src/util/gl/context_egl_x11.cpp

@@ -19,7 +19,7 @@ std::unique_ptr<Context> ContextEGLX11::Create(const WindowInfo& wi, std::span<c
   return context;
 }
 
-std::unique_ptr<Context> ContextEGLX11::CreateSharedContext(const WindowInfo& wi)
+std::unique_ptr<Context> ContextEGLX11::CreateSharedContext(const WindowInfo& wi, Error* error)
 {
   std::unique_ptr<ContextEGLX11> context = std::make_unique<ContextEGLX11>(wi);
   context->m_display = m_display;

src/util/gl/context_egl_x11.h

@@ -14,7 +14,7 @@ public:
 
   static std::unique_ptr<Context> Create(const WindowInfo& wi, std::span<const Version> versions_to_try, Error* error);
 
-  std::unique_ptr<Context> CreateSharedContext(const WindowInfo& wi) override;
+  std::unique_ptr<Context> CreateSharedContext(const WindowInfo& wi, Error* error) override;
   void ResizeSurface(u32 new_surface_width = 0, u32 new_surface_height = 0) override;
 
 protected:

src/util/gl/context_wgl.cpp

@@ -27,7 +27,7 @@ static void* GetProcAddressCallback(const char* name)
 
 static bool ReloadWGL(HDC dc)
 {
-  if (!gladLoadWGLLoader([](const char* name) -> void* { return wglGetProcAddress(name); }, dc))
+  if (!gladLoadWGL(dc, [](const char* name) { return (GLADapiproc)wglGetProcAddress(name); }))
   {
     Log_ErrorPrint("Loading GLAD WGL functions failed");
     return false;
@@ -66,27 +66,18 @@ bool ContextWGL::Initialize(std::span<const Version> versions_to_try, Error* err
 {
   if (m_wi.type == WindowInfo::Type::Win32)
   {
-    if (!InitializeDC())
+    if (!InitializeDC(error))
-    {
-      Error::SetStringView(error, "Failed to create DC.");
       return false;
-    }
   }
   else
   {
-    if (!CreatePBuffer())
+    if (!CreatePBuffer(error))
-    {
-      Error::SetStringView(error, "Failed to create PBuffer");
       return false;
-    }
   }
 
   // Everything including core/ES requires a dummy profile to load the WGL extensions.
-  if (!CreateAnyContext(nullptr, true))
+  if (!CreateAnyContext(nullptr, true, error))
-  {
-    Error::SetStringView(error, "Failed to create dummy context.");
     return false;
-  }
 
   for (const Version& cv : versions_to_try)
   {
@@ -96,7 +87,7 @@ bool ContextWGL::Initialize(std::span<const Version> versions_to_try, Error* err
       m_version = cv;
       return true;
     }
-    else if (CreateVersionContext(cv, nullptr, true))
+    else if (CreateVersionContext(cv, nullptr, true, error))
     {
       m_version = cv;
       return true;
@@ -115,16 +106,21 @@ void* ContextWGL::GetProcAddress(const char* name)
 bool ContextWGL::ChangeSurface(const WindowInfo& new_wi)
 {
   const bool was_current = (wglGetCurrentContext() == m_rc);
+  Error error;
 
   ReleaseDC();
 
   m_wi = new_wi;
-  if (!InitializeDC())
+  if (!InitializeDC(&error))
+  {
+    Log_ErrorFmt("Failed to change surface: {}", error.GetDescription());
     return false;
+  }
 
   if (was_current && !wglMakeCurrent(m_dc, m_rc))
   {
-    Log_ErrorPrintf("Failed to make context current again after surface change: 0x%08X", GetLastError());
+    error.SetWin32(GetLastError());
+    Log_ErrorFmt("Failed to make context current again after surface change: {}", error.GetDescription());
     return false;
   }
 
@@ -153,7 +149,7 @@ bool ContextWGL::MakeCurrent()
 {
   if (!wglMakeCurrent(m_dc, m_rc))
   {
-    Log_ErrorPrintf("wglMakeCurrent() failed: 0x%08X", GetLastError());
+    Log_ErrorFmt("wglMakeCurrent() failed: {}", GetLastError());
     return false;
   }
 
@@ -173,28 +169,28 @@ bool ContextWGL::SetSwapInterval(s32 interval)
   return wglSwapIntervalEXT(interval);
 }
 
-std::unique_ptr<Context> ContextWGL::CreateSharedContext(const WindowInfo& wi)
+std::unique_ptr<Context> ContextWGL::CreateSharedContext(const WindowInfo& wi, Error* error)
 {
   std::unique_ptr<ContextWGL> context = std::make_unique<ContextWGL>(wi);
   if (wi.type == WindowInfo::Type::Win32)
   {
-    if (!context->InitializeDC())
+    if (!context->InitializeDC(error))
       return nullptr;
   }
   else
   {
-    if (!context->CreatePBuffer())
+    if (!context->CreatePBuffer(error))
       return nullptr;
   }
 
   if (m_version.profile == Profile::NoProfile)
   {
-    if (!context->CreateAnyContext(m_rc, false))
+    if (!context->CreateAnyContext(m_rc, false, error))
       return nullptr;
   }
   else
   {
-    if (!context->CreateVersionContext(m_version, m_rc, false))
+    if (!context->CreateVersionContext(m_version, m_rc, false, error))
       return nullptr;
   }
 
@@ -202,7 +198,7 @@ std::unique_ptr<Context> ContextWGL::CreateSharedContext(const WindowInfo& wi)
   return context;
 }
 
-HDC ContextWGL::GetDCAndSetPixelFormat(HWND hwnd)
+HDC ContextWGL::GetDCAndSetPixelFormat(HWND hwnd, Error* error)
 {
   PIXELFORMATDESCRIPTOR pfd = {};
   pfd.nSize = sizeof(pfd);
@@ -218,7 +214,7 @@ HDC ContextWGL::GetDCAndSetPixelFormat(HWND hwnd)
   HDC hDC = ::GetDC(hwnd);
   if (!hDC)
   {
-    Log_ErrorPrintf("GetDC() failed: 0x%08X", GetLastError());
+    Error::SetWin32(error, "GetDC() failed: ", GetLastError());
     return {};
   }
 
@@ -227,7 +223,7 @@ HDC ContextWGL::GetDCAndSetPixelFormat(HWND hwnd)
     const int pf = ChoosePixelFormat(hDC, &pfd);
     if (pf == 0)
     {
-      Log_ErrorPrintf("ChoosePixelFormat() failed: 0x%08X", GetLastError());
+      Error::SetWin32(error, "ChoosePixelFormat() failed: ", GetLastError());
       ::ReleaseDC(hwnd, hDC);
       return {};
     }
@@ -237,7 +233,7 @@ HDC ContextWGL::GetDCAndSetPixelFormat(HWND hwnd)
 
   if (!SetPixelFormat(hDC, m_pixel_format.value(), &pfd))
   {
-    Log_ErrorPrintf("SetPixelFormat() failed: 0x%08X", GetLastError());
+    Error::SetWin32(error, "SetPixelFormat() failed: ", GetLastError());
     ::ReleaseDC(hwnd, hDC);
     return {};
   }
@@ -246,26 +242,23 @@ HDC ContextWGL::GetDCAndSetPixelFormat(HWND hwnd)
   return hDC;
 }
 
-bool ContextWGL::InitializeDC()
+bool ContextWGL::InitializeDC(Error* error)
 {
   if (m_wi.type == WindowInfo::Type::Win32)
   {
-    m_dc = GetDCAndSetPixelFormat(GetHWND());
+    m_dc = GetDCAndSetPixelFormat(GetHWND(), error);
     if (!m_dc)
-    {
-      Log_ErrorPrint("Failed to get DC for window");
       return false;
-    }
 
     return true;
   }
   else if (m_wi.type == WindowInfo::Type::Surfaceless)
   {
-    return CreatePBuffer();
+    return CreatePBuffer(error);
   }
   else
   {
-    Log_ErrorPrintf("Unknown window info type %u", static_cast<unsigned>(m_wi.type));
+    Error::SetStringFmt(error, "Unknown window info type {}", static_cast<unsigned>(m_wi.type));
     return false;
   }
 }
@@ -293,7 +286,7 @@ void ContextWGL::ReleaseDC()
   }
 }
 
-bool ContextWGL::CreatePBuffer()
+bool ContextWGL::CreatePBuffer(Error* error)
 {
   static bool window_class_registered = false;
   static const wchar_t* window_class_name = L"ContextWGLPBuffer";
@@ -316,7 +309,7 @@ bool ContextWGL::CreatePBuffer()
 
     if (!RegisterClassExW(&wc))
     {
-      Log_ErrorPrint("(ContextWGL::CreatePBuffer) RegisterClassExW() failed");
+      Error::SetStringView(error, "(ContextWGL::CreatePBuffer) RegisterClassExW() failed");
       return false;
     }
 
@@ -326,13 +319,13 @@ bool ContextWGL::CreatePBuffer()
   HWND hwnd = CreateWindowExW(0, window_class_name, window_class_name, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL);
   if (!hwnd)
   {
-    Log_ErrorPrint("(ContextWGL::CreatePBuffer) CreateWindowEx() failed");
+    Error::SetStringView(error, "(ContextWGL::CreatePBuffer) CreateWindowEx() failed");
     return false;
   }
 
   ScopedGuard hwnd_guard([hwnd]() { DestroyWindow(hwnd); });
 
-  HDC hdc = GetDCAndSetPixelFormat(hwnd);
+  HDC hdc = GetDCAndSetPixelFormat(hwnd, error);
   if (!hdc)
     return false;
 
@@ -355,13 +348,13 @@ bool ContextWGL::CreatePBuffer()
     temp_rc = wglCreateContext(hdc);
     if (!temp_rc || !wglMakeCurrent(hdc, temp_rc))
     {
-      Log_ErrorPrint("Failed to create temporary context to load WGL for pbuffer.");
+      Error::SetStringView(error, "Failed to create temporary context to load WGL for pbuffer.");
       return false;
     }
 
     if (!ReloadWGL(hdc) || !GLAD_WGL_ARB_pbuffer)
     {
-      Log_ErrorPrint("Missing WGL_ARB_pbuffer");
+      Error::SetStringView(error, "Missing WGL_ARB_pbuffer");
       return false;
     }
   }
@@ -370,7 +363,7 @@ bool ContextWGL::CreatePBuffer()
   HPBUFFERARB pbuffer = wglCreatePbufferARB(hdc, m_pixel_format.value(), 1, 1, pb_attribs);
   if (!pbuffer)
   {
-    Log_ErrorPrintf("(ContextWGL::CreatePBuffer) wglCreatePbufferARB() failed");
+    Error::SetStringView(error, "(ContextWGL::CreatePBuffer) wglCreatePbufferARB() failed");
     return false;
   }
 
@@ -379,7 +372,7 @@ bool ContextWGL::CreatePBuffer()
   m_dc = wglGetPbufferDCARB(pbuffer);
   if (!m_dc)
   {
-    Log_ErrorPrintf("(ContextWGL::CreatePbuffer) wglGetPbufferDCARB() failed");
+    Error::SetStringView(error, "(ContextWGL::CreatePbuffer) wglGetPbufferDCARB() failed");
     return false;
   }
 
@@ -394,12 +387,12 @@ bool ContextWGL::CreatePBuffer()
   return true;
 }
 
-bool ContextWGL::CreateAnyContext(HGLRC share_context, bool make_current)
+bool ContextWGL::CreateAnyContext(HGLRC share_context, bool make_current, Error* error)
 {
   m_rc = wglCreateContext(m_dc);
   if (!m_rc)
   {
-    Log_ErrorPrintf("wglCreateContext() failed: 0x%08X", GetLastError());
+    Error::SetWin32(error, "wglCreateContext() failed: ", GetLastError());
     return false;
   }
 
@@ -407,33 +400,33 @@ bool ContextWGL::CreateAnyContext(HGLRC share_context, bool make_current)
   {
     if (!wglMakeCurrent(m_dc, m_rc))
     {
-      Log_ErrorPrintf("wglMakeCurrent() failed: 0x%08X", GetLastError());
+      Error::SetWin32(error, "wglMakeCurrent() failed: ", GetLastError());
       return false;
     }
 
     // re-init glad-wgl
-    if (!gladLoadWGLLoader([](const char* name) -> void* { return wglGetProcAddress(name); }, m_dc))
+    if (!gladLoadWGL(m_dc, [](const char* name) { return (GLADapiproc)wglGetProcAddress(name); }))
     {
-      Log_ErrorPrint("Loading GLAD WGL functions failed");
+      Error::SetStringView(error, "Loading GLAD WGL functions failed");
       return false;
     }
   }
 
   if (share_context && !wglShareLists(share_context, m_rc))
   {
-    Log_ErrorPrintf("wglShareLists() failed: 0x%08X", GetLastError());
+    Error::SetWin32(error, "wglShareLists() failed: ", GetLastError());
     return false;
   }
 
   return true;
 }
 
-bool ContextWGL::CreateVersionContext(const Version& version, HGLRC share_context, bool make_current)
+bool ContextWGL::CreateVersionContext(const Version& version, HGLRC share_context, bool make_current, Error* error)
 {
   // we need create context attribs
   if (!GLAD_WGL_ARB_create_context)
   {
-    Log_ErrorPrint("Missing GLAD_WGL_ARB_create_context.");
+    Error::SetStringView(error, "Missing GLAD_WGL_ARB_create_context.");
     return false;
   }
 
@@ -463,7 +456,7 @@ bool ContextWGL::CreateVersionContext(const Version& version, HGLRC share_contex
     if ((version.major_version >= 2 && !GLAD_WGL_EXT_create_context_es2_profile) ||
         (version.major_version < 2 && !GLAD_WGL_EXT_create_context_es_profile))
     {
-      Log_ErrorPrintf("WGL_EXT_create_context_es_profile not supported");
+      Error::SetStringView(error, "WGL_EXT_create_context_es_profile not supported");
       return false;
     }
 
@@ -481,7 +474,7 @@ bool ContextWGL::CreateVersionContext(const Version& version, HGLRC share_contex
   }
   else
   {
-    Log_ErrorPrint("Unknown profile");
+    Error::SetStringView(error, "Unknown profile");
     return false;
   }
 
@@ -493,7 +486,7 @@ bool ContextWGL::CreateVersionContext(const Version& version, HGLRC share_contex
   {
     if (!wglMakeCurrent(m_dc, make_current ? new_rc : nullptr))
     {
-      Log_ErrorPrintf("wglMakeCurrent() failed: 0x%08X", GetLastError());
+      Error::SetWin32(error, "wglMakeCurrent() failed: ", GetLastError());
       wglDeleteContext(new_rc);
       return false;
     }

src/util/gl/context_wgl.h

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: 2019-2023 Connor McLaughlin <stenzek@gmail.com>
+// SPDX-FileCopyrightText: 2019-2024 Connor McLaughlin <stenzek@gmail.com>
 // SPDX-License-Identifier: (GPL-3.0 OR CC-BY-NC-ND-4.0)
 
 #pragma once
@@ -8,7 +8,7 @@
 
 #include "common/windows_headers.h"
 
-#include "glad_wgl.h"
+#include "glad/wgl.h"
 
 #include <optional>
 
@@ -30,19 +30,19 @@ public:
   bool MakeCurrent() override;
   bool DoneCurrent() override;
   bool SetSwapInterval(s32 interval) override;
-  std::unique_ptr<Context> CreateSharedContext(const WindowInfo& wi) override;
+  std::unique_ptr<Context> CreateSharedContext(const WindowInfo& wi, Error* error) override;
 
 private:
   ALWAYS_INLINE HWND GetHWND() const { return static_cast<HWND>(m_wi.window_handle); }
 
-  HDC GetDCAndSetPixelFormat(HWND hwnd);
+  HDC GetDCAndSetPixelFormat(HWND hwnd, Error* error);
 
   bool Initialize(std::span<const Version> versions_to_try, Error* error);
-  bool InitializeDC();
+  bool InitializeDC(Error* error);
   void ReleaseDC();
-  bool CreatePBuffer();
+  bool CreatePBuffer(Error* error);
-  bool CreateAnyContext(HGLRC share_context, bool make_current);
+  bool CreateAnyContext(HGLRC share_context, bool make_current, Error* error);
-  bool CreateVersionContext(const Version& version, HGLRC share_context, bool make_current);
+  bool CreateVersionContext(const Version& version, HGLRC share_context, bool make_current, Error* error);
 
   HDC m_dc = {};
   HGLRC m_rc = {};

src/util/opengl_device.cpp

@@ -287,8 +287,8 @@ void OpenGLDevice::SetVSync(bool enabled)
   SetSwapInterval();
 }
 
-static void APIENTRY GLDebugCallback(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length,
+static void GLAD_API_PTR GLDebugCallback(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length,
-                                     const GLchar* message, const void* userParam)
+                                         const GLchar* message, const void* userParam)
 {
   switch (severity)
   {

src/util/opengl_loader.h

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: 2019-2022 Connor McLaughlin <stenzek@gmail.com>
+// SPDX-FileCopyrightText: 2019-2024 Connor McLaughlin <stenzek@gmail.com>
 // SPDX-License-Identifier: (GPL-3.0 OR CC-BY-NC-ND-4.0)
 
 #pragma once
@@ -8,4 +8,4 @@
 #include "common/windows_headers.h"
 #endif
 
-#include "glad.h"
+#include "glad/gl.h"