text: //========================================================================
  // GLFW 3.4 - www.glfw.org
  //------------------------------------------------------------------------
  // Copyright (c) 2002-2006 Marcus Geelnard
  // Copyright (c) 2006-2019 Camilla Löwy <elmindreda@glfw.org>
  //
  // This software is provided 'as-is', without any express or implied
  // warranty. In no event will the authors be held liable for any damages
  // arising from the use of this software.
  //
  // Permission is granted to anyone to use this software for any purpose,
  // including commercial applications, and to alter it and redistribute it
  // freely, subject to the following restrictions:
  //
  // 1. The origin of this software must not be misrepresented; you must not
  //    claim that you wrote the original software. If you use this software
  //    in a product, an acknowledgment in the product documentation would
  //    be appreciated but is not required.
  //
  // 2. Altered source versions must be plainly marked as such, and must not
  //    be misrepresented as being the original software.
  //
  // 3. This notice may not be removed or altered from any source
  //    distribution.
  //
  //========================================================================
  
  #pragma once
  
  #if defined(_GLFW_USE_CONFIG_H)
   #include "glfw_config.h"
  #endif
  
  #if defined(GLFW_INCLUDE_GLCOREARB) || \
      defined(GLFW_INCLUDE_ES1)       || \
      defined(GLFW_INCLUDE_ES2)       || \
      defined(GLFW_INCLUDE_ES3)       || \
      defined(GLFW_INCLUDE_ES31)      || \
      defined(GLFW_INCLUDE_ES32)      || \
      defined(GLFW_INCLUDE_NONE)      || \
      defined(GLFW_INCLUDE_GLEXT)     || \
      defined(GLFW_INCLUDE_GLU)       || \
      defined(GLFW_INCLUDE_VULKAN)    || \
      defined(GLFW_DLL)
   #error "You must not define any header option macros when compiling GLFW"
  #endif
  
  #define GLFW_INCLUDE_NONE
  #include "../include/GLFW/glfw3.h"
  
  #define _GLFW_INSERT_FIRST      0
  #define _GLFW_INSERT_LAST       1
  
  #define _GLFW_POLL_PRESENCE     0
  #define _GLFW_POLL_AXES         1
  #define _GLFW_POLL_BUTTONS      2
  #define _GLFW_POLL_ALL          (_GLFW_POLL_AXES | _GLFW_POLL_BUTTONS)
  
  #define _GLFW_MESSAGE_SIZE      1024
  
  typedef int GLFWbool;
  typedef void (*GLFWproc)(void);
  
  typedef struct _GLFWerror       _GLFWerror;
  typedef struct _GLFWinitconfig  _GLFWinitconfig;
  typedef struct _GLFWwndconfig   _GLFWwndconfig;
  typedef struct _GLFWctxconfig   _GLFWctxconfig;
  typedef struct _GLFWfbconfig    _GLFWfbconfig;
  typedef struct _GLFWcontext     _GLFWcontext;
  typedef struct _GLFWwindow      _GLFWwindow;
  typedef struct _GLFWplatform    _GLFWplatform;
  typedef struct _GLFWlibrary     _GLFWlibrary;
  typedef struct _GLFWmonitor     _GLFWmonitor;
  typedef struct _GLFWcursor      _GLFWcursor;
  typedef struct _GLFWmapelement  _GLFWmapelement;
  typedef struct _GLFWmapping     _GLFWmapping;
  typedef struct _GLFWjoystick    _GLFWjoystick;
  typedef struct _GLFWtls         _GLFWtls;
  typedef struct _GLFWmutex       _GLFWmutex;
  
  #define GL_VERSION 0x1f02
  #define GL_NONE 0
  #define GL_COLOR_BUFFER_BIT 0x00004000
  #define GL_UNSIGNED_BYTE 0x1401
  #define GL_EXTENSIONS 0x1f03
  #define GL_NUM_EXTENSIONS 0x821d
  #define GL_CONTEXT_FLAGS 0x821e
  #define GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT 0x00000001
  #define GL_CONTEXT_FLAG_DEBUG_BIT 0x00000002
  #define GL_CONTEXT_PROFILE_MASK 0x9126
  #define GL_CONTEXT_COMPATIBILITY_PROFILE_BIT 0x00000002
  #define GL_CONTEXT_CORE_PROFILE_BIT 0x00000001
  #define GL_RESET_NOTIFICATION_STRATEGY_ARB 0x8256
  #define GL_LOSE_CONTEXT_ON_RESET_ARB 0x8252
  #define GL_NO_RESET_NOTIFICATION_ARB 0x8261
  #define GL_CONTEXT_RELEASE_BEHAVIOR 0x82fb
  #define GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH 0x82fc
  #define GL_CONTEXT_FLAG_NO_ERROR_BIT_KHR 0x00000008
  
  typedef int GLint;
  typedef unsigned int GLuint;
  typedef unsigned int GLenum;
  typedef unsigned int GLbitfield;
  typedef unsigned char GLubyte;
  
  typedef void (APIENTRY * PFNGLCLEARPROC)(GLbitfield);
  typedef const GLubyte* (APIENTRY * PFNGLGETSTRINGPROC)(GLenum);
  typedef void (APIENTRY * PFNGLGETINTEGERVPROC)(GLenum,GLint*);
  typedef const GLubyte* (APIENTRY * PFNGLGETSTRINGIPROC)(GLenum,GLuint);
  
  #if defined(_GLFW_WIN32)
   #define EGLAPIENTRY __stdcall
  #else
   #define EGLAPIENTRY
  #endif
  
  #define EGL_SUCCESS 0x3000
  #define EGL_NOT_INITIALIZED 0x3001
  #define EGL_BAD_ACCESS 0x3002
  #define EGL_BAD_ALLOC 0x3003
  #define EGL_BAD_ATTRIBUTE 0x3004
  #define EGL_BAD_CONFIG 0x3005
  #define EGL_BAD_CONTEXT 0x3006
  #define EGL_BAD_CURRENT_SURFACE 0x3007
  #define EGL_BAD_DISPLAY 0x3008
  #define EGL_BAD_MATCH 0x3009
  #define EGL_BAD_NATIVE_PIXMAP 0x300a
  #define EGL_BAD_NATIVE_WINDOW 0x300b
  #define EGL_BAD_PARAMETER 0x300c
  #define EGL_BAD_SURFACE 0x300d
  #define EGL_CONTEXT_LOST 0x300e
  #define EGL_COLOR_BUFFER_TYPE 0x303f
  #define EGL_RGB_BUFFER 0x308e
  #define EGL_SURFACE_TYPE 0x3033
  #define EGL_WINDOW_BIT 0x0004
  #define EGL_RENDERABLE_TYPE 0x3040
  #define EGL_OPENGL_ES_BIT 0x0001
  #define EGL_OPENGL_ES2_BIT 0x0004
  #define EGL_OPENGL_BIT 0x0008
  #define EGL_ALPHA_SIZE 0x3021
  #define EGL_BLUE_SIZE 0x3022
  #define EGL_GREEN_SIZE 0x3023
  #define EGL_RED_SIZE 0x3024
  #define EGL_DEPTH_SIZE 0x3025
  #define EGL_STENCIL_SIZE 0x3026
  #define EGL_SAMPLES 0x3031
  #define EGL_OPENGL_ES_API 0x30a0
  #define EGL_OPENGL_API 0x30a2
  #define EGL_NONE 0x3038
  #define EGL_RENDER_BUFFER 0x3086
  #define EGL_SINGLE_BUFFER 0x3085
  #define EGL_EXTENSIONS 0x3055
  #define EGL_CONTEXT_CLIENT_VERSION 0x3098
  #define EGL_NATIVE_VISUAL_ID 0x302e
  #define EGL_NO_SURFACE ((EGLSurface) 0)
  #define EGL_NO_DISPLAY ((EGLDisplay) 0)
  #define EGL_NO_CONTEXT ((EGLContext) 0)
  #define EGL_DEFAULT_DISPLAY ((EGLNativeDisplayType) 0)
  
  #define EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE_BIT_KHR 0x00000002
  #define EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT_KHR 0x00000001
  #define EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT_KHR 0x00000002
  #define EGL_CONTEXT_OPENGL_DEBUG_BIT_KHR 0x00000001
  #define EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_KHR 0x31bd
  #define EGL_NO_RESET_NOTIFICATION_KHR 0x31be
  #define EGL_LOSE_CONTEXT_ON_RESET_KHR 0x31bf
  #define EGL_CONTEXT_OPENGL_ROBUST_ACCESS_BIT_KHR 0x00000004
  #define EGL_CONTEXT_MAJOR_VERSION_KHR 0x3098
  #define EGL_CONTEXT_MINOR_VERSION_KHR 0x30fb
  #define EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR 0x30fd
  #define EGL_CONTEXT_FLAGS_KHR 0x30fc
  #define EGL_CONTEXT_OPENGL_NO_ERROR_KHR 0x31b3
  #define EGL_GL_COLORSPACE_KHR 0x309d
  #define EGL_GL_COLORSPACE_SRGB_KHR 0x3089
  #define EGL_CONTEXT_RELEASE_BEHAVIOR_KHR 0x2097
  #define EGL_CONTEXT_RELEASE_BEHAVIOR_NONE_KHR 0
  #define EGL_CONTEXT_RELEASE_BEHAVIOR_FLUSH_KHR 0x2098
  #define EGL_PLATFORM_X11_EXT 0x31d5
  #define EGL_PLATFORM_WAYLAND_EXT 0x31d8
  #define EGL_PRESENT_OPAQUE_EXT 0x31df
  #define EGL_PLATFORM_ANGLE_ANGLE 0x3202
  #define EGL_PLATFORM_ANGLE_TYPE_ANGLE 0x3203
  #define EGL_PLATFORM_ANGLE_TYPE_OPENGL_ANGLE 0x320d
  #define EGL_PLATFORM_ANGLE_TYPE_OPENGLES_ANGLE 0x320e
  #define EGL_PLATFORM_ANGLE_TYPE_D3D9_ANGLE 0x3207
  #define EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE 0x3208
  #define EGL_PLATFORM_ANGLE_TYPE_VULKAN_ANGLE 0x3450
  #define EGL_PLATFORM_ANGLE_TYPE_METAL_ANGLE 0x3489
  #define EGL_PLATFORM_ANGLE_NATIVE_PLATFORM_TYPE_ANGLE 0x348f
  
  typedef int EGLint;
  typedef unsigned int EGLBoolean;
  typedef unsigned int EGLenum;
  typedef void* EGLConfig;
  typedef void* EGLContext;
  typedef void* EGLDisplay;
  typedef void* EGLSurface;
  
  typedef void* EGLNativeDisplayType;
  typedef void* EGLNativeWindowType;
  
  // EGL function pointer typedefs
  typedef EGLBoolean (EGLAPIENTRY * PFN_eglGetConfigAttrib)(EGLDisplay,EGLConfig,EGLint,EGLint*);
  typedef EGLBoolean (EGLAPIENTRY * PFN_eglGetConfigs)(EGLDisplay,EGLConfig*,EGLint,EGLint*);
  typedef EGLDisplay (EGLAPIENTRY * PFN_eglGetDisplay)(EGLNativeDisplayType);
  typedef EGLint (EGLAPIENTRY * PFN_eglGetError)(void);
  typedef EGLBoolean (EGLAPIENTRY * PFN_eglInitialize)(EGLDisplay,EGLint*,EGLint*);
  typedef EGLBoolean (EGLAPIENTRY * PFN_eglTerminate)(EGLDisplay);
  typedef EGLBoolean (EGLAPIENTRY * PFN_eglBindAPI)(EGLenum);
  typedef EGLContext (EGLAPIENTRY * PFN_eglCreateContext)(EGLDisplay,EGLConfig,EGLContext,const EGLint*);
  typedef EGLBoolean (EGLAPIENTRY * PFN_eglDestroySurface)(EGLDisplay,EGLSurface);
  typedef EGLBoolean (EGLAPIENTRY * PFN_eglDestroyContext)(EGLDisplay,EGLContext);
  typedef EGLSurface (EGLAPIENTRY * PFN_eglCreateWindowSurface)(EGLDisplay,EGLConfig,EGLNativeWindowType,const EGLint*);
  typedef EGLBoolean (EGLAPIENTRY * PFN_eglMakeCurrent)(EGLDisplay,EGLSurface,EGLSurface,EGLContext);
  typedef EGLBoolean (EGLAPIENTRY * PFN_eglSwapBuffers)(EGLDisplay,EGLSurface);
  typedef EGLBoolean (EGLAPIENTRY * PFN_eglSwapInterval)(EGLDisplay,EGLint);
  typedef const char* (EGLAPIENTRY * PFN_eglQueryString)(EGLDisplay,EGLint);
  typedef GLFWglproc (EGLAPIENTRY * PFN_eglGetProcAddress)(const char*);
  #define eglGetConfigAttrib _glfw.egl.GetConfigAttrib
  #define eglGetConfigs _glfw.egl.GetConfigs
  #define eglGetDisplay _glfw.egl.GetDisplay
  #define eglGetError _glfw.egl.GetError
  #define eglInitialize _glfw.egl.Initialize
  #define eglTerminate _glfw.egl.Terminate
  #define eglBindAPI _glfw.egl.BindAPI
  #define eglCreateContext _glfw.egl.CreateContext
  #define eglDestroySurface _glfw.egl.DestroySurface
  #define eglDestroyContext _glfw.egl.DestroyContext
  #define eglCreateWindowSurface _glfw.egl.CreateWindowSurface
  #define eglMakeCurrent _glfw.egl.MakeCurrent
  #define eglSwapBuffers _glfw.egl.SwapBuffers
  #define eglSwapInterval _glfw.egl.SwapInterval
  #define eglQueryString _glfw.egl.QueryString
  #define eglGetProcAddress _glfw.egl.GetProcAddress
  
  typedef EGLDisplay (EGLAPIENTRY * PFNEGLGETPLATFORMDISPLAYEXTPROC)(EGLenum,void*,const EGLint*);
  typedef EGLSurface (EGLAPIENTRY * PFNEGLCREATEPLATFORMWINDOWSURFACEEXTPROC)(EGLDisplay,EGLConfig,void*,const EGLint*);
  #define eglGetPlatformDisplayEXT _glfw.egl.GetPlatformDisplayEXT
  #define eglCreatePlatformWindowSurfaceEXT _glfw.egl.CreatePlatformWindowSurfaceEXT
  
  #define OSMESA_RGBA 0x1908
  #define OSMESA_FORMAT 0x22
  #define OSMESA_DEPTH_BITS 0x30
  #define OSMESA_STENCIL_BITS 0x31
  #define OSMESA_ACCUM_BITS 0x32
  #define OSMESA_PROFILE 0x33
  #define OSMESA_CORE_PROFILE 0x34
  #define OSMESA_COMPAT_PROFILE 0x35
  #define OSMESA_CONTEXT_MAJOR_VERSION 0x36
  #define OSMESA_CONTEXT_MINOR_VERSION 0x37
  
  typedef void* OSMesaContext;
  typedef void (*OSMESAproc)(void);
  
  typedef OSMesaContext (GLAPIENTRY * PFN_OSMesaCreateContextExt)(GLenum,GLint,GLint,GLint,OSMesaContext);
  typedef OSMesaContext (GLAPIENTRY * PFN_OSMesaCreateContextAttribs)(const int*,OSMesaContext);
  typedef void (GLAPIENTRY * PFN_OSMesaDestroyContext)(OSMesaContext);
  typedef int (GLAPIENTRY * PFN_OSMesaMakeCurrent)(OSMesaContext,void*,int,int,int);
  typedef int (GLAPIENTRY * PFN_OSMesaGetColorBuffer)(OSMesaContext,int*,int*,int*,void**);
  typedef int (GLAPIENTRY * PFN_OSMesaGetDepthBuffer)(OSMesaContext,int*,int*,int*,void**);
  typedef GLFWglproc (GLAPIENTRY * PFN_OSMesaGetProcAddress)(const char*);
  #define OSMesaCreateContextExt _glfw.osmesa.CreateContextExt
  #define OSMesaCreateContextAttribs _glfw.osmesa.CreateContextAttribs
  #define OSMesaDestroyContext _glfw.osmesa.DestroyContext
  #define OSMesaMakeCurrent _glfw.osmesa.MakeCurrent
  #define OSMesaGetColorBuffer _glfw.osmesa.GetColorBuffer
  #define OSMesaGetDepthBuffer _glfw.osmesa.GetDepthBuffer
  #define OSMesaGetProcAddress _glfw.osmesa.GetProcAddress
  
  #define VK_NULL_HANDLE 0
  
  typedef void* VkInstance;
  typedef void* VkPhysicalDevice;
  typedef uint64_t VkSurfaceKHR;
  typedef uint32_t VkFlags;
  typedef uint32_t VkBool32;
  
  typedef enum VkStructureType
  {
      VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR = 1000004000,
      VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR = 1000005000,
      VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR = 1000006000,
      VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR = 1000009000,
      VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK = 1000123000,
      VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT = 1000217000,
      VK_STRUCTURE_TYPE_MAX_ENUM = 0x7FFFFFFF
  } VkStructureType;
  
  typedef enum VkResult
  {
      VK_SUCCESS = 0,
      VK_NOT_READY = 1,
      VK_TIMEOUT = 2,
      VK_EVENT_SET = 3,
      VK_EVENT_RESET = 4,
      VK_INCOMPLETE = 5,
      VK_ERROR_OUT_OF_HOST_MEMORY = -1,
      VK_ERROR_OUT_OF_DEVICE_MEMORY = -2,
      VK_ERROR_INITIALIZATION_FAILED = -3,
      VK_ERROR_DEVICE_LOST = -4,
      VK_ERROR_MEMORY_MAP_FAILED = -5,
      VK_ERROR_LAYER_NOT_PRESENT = -6,
      VK_ERROR_EXTENSION_NOT_PRESENT = -7,
      VK_ERROR_FEATURE_NOT_PRESENT = -8,
      VK_ERROR_INCOMPATIBLE_DRIVER = -9,
      VK_ERROR_TOO_MANY_OBJECTS = -10,
      VK_ERROR_FORMAT_NOT_SUPPORTED = -11,
      VK_ERROR_SURFACE_LOST_KHR = -1000000000,
      VK_SUBOPTIMAL_KHR = 1000001003,
      VK_ERROR_OUT_OF_DATE_KHR = -1000001004,
      VK_ERROR_INCOMPATIBLE_DISPLAY_KHR = -1000003001,
      VK_ERROR_NATIVE_WINDOW_IN_USE_KHR = -1000000001,
      VK_ERROR_VALIDATION_FAILED_EXT = -1000011001,
      VK_RESULT_MAX_ENUM = 0x7FFFFFFF
  } VkResult;
  
  typedef struct VkAllocationCallbacks VkAllocationCallbacks;
  
  typedef struct VkExtensionProperties
  {
      char            extensionName[256];
      uint32_t        specVersion;
  } VkExtensionProperties;
  
  typedef void (APIENTRY * PFN_vkVoidFunction)(void);
  
  typedef PFN_vkVoidFunction (APIENTRY * PFN_vkGetInstanceProcAddr)(VkInstance,const char*);
  typedef VkResult (APIENTRY * PFN_vkEnumerateInstanceExtensionProperties)(const char*,uint32_t*,VkExtensionProperties*);
  #define vkGetInstanceProcAddr _glfw.vk.GetInstanceProcAddr
  
  #include "platform.h"
  
  // Constructs a version number string from the public header macros
  #define _GLFW_CONCAT_VERSION(m, n, r) #m "." #n "." #r
  #define _GLFW_MAKE_VERSION(m, n, r) _GLFW_CONCAT_VERSION(m, n, r)
  #define _GLFW_VERSION_NUMBER _GLFW_MAKE_VERSION(GLFW_VERSION_MAJOR, \
                                                  GLFW_VERSION_MINOR, \
                                                  GLFW_VERSION_REVISION)
  
  // Checks for whether the library has been initialized
  #define _GLFW_REQUIRE_INIT()                         \
      if (!_glfw.initialized)                          \
      {                                                \
          _glfwInputError(GLFW_NOT_INITIALIZED, NULL); \
          return;                                      \
      }
  #define _GLFW_REQUIRE_INIT_OR_RETURN(x)              \
      if (!_glfw.initialized)                          \
      {                                                \
          _glfwInputError(GLFW_NOT_INITIALIZED, NULL); \
          return x;                                    \
      }
  
  // Swaps the provided pointers
  #define _GLFW_SWAP(type, x, y) \
      {                          \
          type t;                \
          t = x;                 \
          x = y;                 \
          y = t;                 \
      }
  
  // Per-thread error structure
  //
  struct _GLFWerror
  {
      _GLFWerror*     next;
      int             code;
      char            description[_GLFW_MESSAGE_SIZE];
  };
  
  // Initialization configuration
  //
  // Parameters relating to the initialization of the library
  //
  struct _GLFWinitconfig
  {
      GLFWbool      hatButtons;
      int           angleType;
      int           platformID;
      PFN_vkGetInstanceProcAddr vulkanLoader;
      struct {
          GLFWbool  menubar;
          GLFWbool  chdir;
      } ns;
      struct {
          GLFWbool  xcbVulkanSurface;
      } x11;
  };
  
  // Window configuration
  //
  // Parameters relating to the creation of the window but not directly related
  // to the framebuffer.  This is used to pass window creation parameters from
  // shared code to the platform API.
  //
  struct _GLFWwndconfig
  {
      int           width;
      int           height;
      const char*   title;
      GLFWbool      resizable;
      GLFWbool      visible;
      GLFWbool      decorated;
      GLFWbool      focused;
      GLFWbool      autoIconify;
      GLFWbool      floating;
      GLFWbool      maximized;
      GLFWbool      centerCursor;
      GLFWbool      focusOnShow;
      GLFWbool      mousePassthrough;
      GLFWbool      scaleToMonitor;
      struct {
          GLFWbool  retina;
          char      frameName[256];
      } ns;
      struct {
          char      className[256];
          char      instanceName[256];
      } x11;
      struct {
          GLFWbool  keymenu;
      } win32;
  };
  
  // Context configuration
  //
  // Parameters relating to the creation of the context but not directly related
  // to the framebuffer.  This is used to pass context creation parameters from
  // shared code to the platform API.
  //
  struct _GLFWctxconfig
  {
      int           client;
      int           source;
      int           major;
      int           minor;
      GLFWbool      forward;
      GLFWbool      debug;
      GLFWbool      noerror;
      int           profile;
      int           robustness;
      int           release;
      _GLFWwindow*  share;
      struct {
          GLFWbool  offline;
      } nsgl;
  };
  
  // Framebuffer configuration
  //
  // This describes buffers and their sizes.  It also contains
  // a platform-specific ID used to map back to the backend API object.
  //
  // It is used to pass framebuffer parameters from shared code to the platform
  // API and also to enumerate and select available framebuffer configs.
  //
  struct _GLFWfbconfig
  {
      int         redBits;
      int         greenBits;
      int         blueBits;
      int         alphaBits;
      int         depthBits;
      int         stencilBits;
      int         accumRedBits;
      int         accumGreenBits;
      int         accumBlueBits;
      int         accumAlphaBits;
      int         auxBuffers;
      GLFWbool    stereo;
      int         samples;
      GLFWbool    sRGB;
      GLFWbool    doublebuffer;
      GLFWbool    transparent;
      uintptr_t   handle;
  };
  
  // Context structure
  //
  struct _GLFWcontext
  {
      int                 client;
      int                 source;
      int                 major, minor, revision;
      GLFWbool            forward, debug, noerror;
      int                 profile;
      int                 robustness;
      int                 release;
  
      PFNGLGETSTRINGIPROC  GetStringi;
      PFNGLGETINTEGERVPROC GetIntegerv;
      PFNGLGETSTRINGPROC   GetString;
  
      void (*makeCurrent)(_GLFWwindow*);
      void (*swapBuffers)(_GLFWwindow*);
      void (*swapInterval)(int);
      int (*extensionSupported)(const char*);
      GLFWglproc (*getProcAddress)(const char*);
      void (*destroy)(_GLFWwindow*);
  
      struct {
          EGLConfig       config;
          EGLContext      handle;
          EGLSurface      surface;
          void*           client;
      } egl;
  
      struct {
          OSMesaContext   handle;
          int             width;
          int             height;
          void*           buffer;
      } osmesa;
  
      // This is defined in platform.h
      GLFW_PLATFORM_CONTEXT_STATE
  };
  
  // Window and context structure
  //
  struct _GLFWwindow
  {
      struct _GLFWwindow* next;
  
      // Window settings and state
      GLFWbool            resizable;
      GLFWbool            decorated;
      GLFWbool            autoIconify;
      GLFWbool            floating;
      GLFWbool            focusOnShow;
      GLFWbool            mousePassthrough;
      GLFWbool            shouldClose;
      void*               userPointer;
      GLFWbool            doublebuffer;
      GLFWvidmode         videoMode;
      _GLFWmonitor*       monitor;
      _GLFWcursor*        cursor;
  
      int                 minwidth, minheight;
      int                 maxwidth, maxheight;
      int                 numer, denom;
  
      GLFWbool            stickyKeys;
      GLFWbool            stickyMouseButtons;
      GLFWbool            lockKeyMods;
      int                 cursorMode;
      char                mouseButtons[GLFW_MOUSE_BUTTON_LAST + 1];
      char                keys[GLFW_KEY_LAST + 1];
      // Virtual cursor position when cursor is disabled
      double              virtualCursorPosX, virtualCursorPosY;
      GLFWbool            rawMouseMotion;
  
      _GLFWcontext        context;
  
      struct {
          GLFWwindowposfun          pos;
          GLFWwindowsizefun         size;
          GLFWwindowclosefun        close;
          GLFWwindowrefreshfun      refresh;
          GLFWwindowfocusfun        focus;
          GLFWwindowiconifyfun      iconify;
          GLFWwindowmaximizefun     maximize;
          GLFWframebuffersizefun    fbsize;
          GLFWwindowcontentscalefun scale;
          GLFWmousebuttonfun        mouseButton;
          GLFWcursorposfun          cursorPos;
          GLFWcursorenterfun        cursorEnter;
          GLFWscrollfun             scroll;
          GLFWkeyfun                key;
          GLFWcharfun               character;
          GLFWcharmodsfun           charmods;
          GLFWdropfun               drop;
      } callbacks;
  
      // This is defined in platform.h
      GLFW_PLATFORM_WINDOW_STATE
  };
  
  // Monitor structure
  //
  struct _GLFWmonitor
  {
      char            name[128];
      void*           userPointer;
  
      // Physical dimensions in millimeters.
      int             widthMM, heightMM;
  
      // The window whose video mode is current on this monitor
      _GLFWwindow*    window;
  
      GLFWvidmode*    modes;
      int             modeCount;
      GLFWvidmode     currentMode;
  
      GLFWgammaramp   originalRamp;
      GLFWgammaramp   currentRamp;
  
      // This is defined in platform.h
      GLFW_PLATFORM_MONITOR_STATE
  };
  
  // Cursor structure
  //
  struct _GLFWcursor
  {
      _GLFWcursor*    next;
      // This is defined in platform.h
      GLFW_PLATFORM_CURSOR_STATE
  };
  
  // Gamepad mapping element structure
  //
  struct _GLFWmapelement
  {
      uint8_t         type;
      uint8_t         index;
      int8_t          axisScale;
      int8_t          axisOffset;
  };
  
  // Gamepad mapping structure
  //
  struct _GLFWmapping
  {
      char            name[128];
      char            guid[33];
      _GLFWmapelement buttons[15];
      _GLFWmapelement axes[6];
  };
  
  // Joystick structure
  //
  struct _GLFWjoystick
  {
      GLFWbool        present;
      float*          axes;
      int             axisCount;
      unsigned char*  buttons;
      int             buttonCount;
      unsigned char*  hats;
      int             hatCount;
      char            name[128];
      void*           userPointer;
      char            guid[33];
      _GLFWmapping*   mapping;
  
      // This is defined in platform.h
      GLFW_PLATFORM_JOYSTICK_STATE
  };
  
  // Thread local storage structure
  //
  struct _GLFWtls
  {
      // This is defined in platform.h
      GLFW_PLATFORM_TLS_STATE
  };
  
  // Mutex structure
  //
  struct _GLFWmutex
  {
      // This is defined in platform.h
      GLFW_PLATFORM_MUTEX_STATE
  };
  
  // Platform API structure
  //
  struct _GLFWplatform
  {
      int platformID;
      // init
      GLFWbool (*init)(void);
      void (*terminate)(void);
      // input
      void (*getCursorPos)(_GLFWwindow*,double*,double*);
      void (*setCursorPos)(_GLFWwindow*,double,double);
      void (*setCursorMode)(_GLFWwindow*,int);
      void (*setRawMouseMotion)(_GLFWwindow*,GLFWbool);
      GLFWbool (*rawMouseMotionSupported)(void);
      int (*createCursor)(_GLFWcursor*,const GLFWimage*,int,int);
      int (*createStandardCursor)(_GLFWcursor*,int);
      void (*destroyCursor)(_GLFWcursor*);
      void (*setCursor)(_GLFWwindow*,_GLFWcursor*);
      const char* (*getScancodeName)(int);
      int (*getKeyScancode)(int);
      void (*setClipboardString)(const char*);
      const char* (*getClipboardString)(void);
      GLFWbool (*initJoysticks)(void);
      void (*terminateJoysticks)(void);
      int (*pollJoystick)(_GLFWjoystick*,int);
      const char* (*getMappingName)(void);
      void (*updateGamepadGUID)(char*);
      // monitor
      void (*freeMonitor)(_GLFWmonitor*);
      void (*getMonitorPos)(_GLFWmonitor*,int*,int*);
      void (*getMonitorContentScale)(_GLFWmonitor*,float*,float*);
      void (*getMonitorWorkarea)(_GLFWmonitor*,int*,int*,int*,int*);
      GLFWvidmode* (*getVideoModes)(_GLFWmonitor*,int*);
      void (*getVideoMode)(_GLFWmonitor*,GLFWvidmode*);
      GLFWbool (*getGammaRamp)(_GLFWmonitor*,GLFWgammaramp*);
      void (*setGammaRamp)(_GLFWmonitor*,const GLFWgammaramp*);
      // window
      int (*createWindow)(_GLFWwindow*,const _GLFWwndconfig*,const _GLFWctxconfig*,const _GLFWfbconfig*);
      void (*destroyWindow)(_GLFWwindow*);
      void (*setWindowTitle)(_GLFWwindow*,const char*);
      void (*setWindowIcon)(_GLFWwindow*,int,const GLFWimage*);
      void (*getWindowPos)(_GLFWwindow*,int*,int*);
      void (*setWindowPos)(_GLFWwindow*,int,int);
      void (*getWindowSize)(_GLFWwindow*,int*,int*);
      void (*setWindowSize)(_GLFWwindow*,int,int);
      void (*setWindowSizeLimits)(_GLFWwindow*,int,int,int,int);
      void (*setWindowAspectRatio)(_GLFWwindow*,int,int);
      void (*getFramebufferSize)(_GLFWwindow*,int*,int*);
      void (*getWindowFrameSize)(_GLFWwindow*,int*,int*,int*,int*);
      void (*getWindowContentScale)(_GLFWwindow*,float*,float*);
      void (*iconifyWindow)(_GLFWwindow*);
      void (*restoreWindow)(_GLFWwindow*);
      void (*maximizeWindow)(_GLFWwindow*);
      void (*showWindow)(_GLFWwindow*);
      void (*hideWindow)(_GLFWwindow*);
      void (*requestWindowAttention)(_GLFWwindow*);
      void (*focusWindow)(_GLFWwindow*);
      void (*setWindowMonitor)(_GLFWwindow*,_GLFWmonitor*,int,int,int,int,int);
      int (*windowFocused)(_GLFWwindow*);
      int (*windowIconified)(_GLFWwindow*);
      int (*windowVisible)(_GLFWwindow*);
      int (*windowMaximized)(_GLFWwindow*);
      int (*windowHovered)(_GLFWwindow*);
      int (*framebufferTransparent)(_GLFWwindow*);
      float (*getWindowOpacity)(_GLFWwindow*);
      void (*setWindowResizable)(_GLFWwindow*,GLFWbool);
      void (*setWindowDecorated)(_GLFWwindow*,GLFWbool);
      void (*setWindowFloating)(_GLFWwindow*,GLFWbool);
      void (*setWindowOpacity)(_GLFWwindow*,float);
      void (*setWindowMousePassthrough)(_GLFWwindow*,GLFWbool);
      void (*pollEvents)(void);
      void (*waitEvents)(void);
      void (*waitEventsTimeout)(double);
      void (*postEmptyEvent)(void);
      // EGL
      EGLenum (*getEGLPlatform)(EGLint**);
      EGLNativeDisplayType (*getEGLNativeDisplay)(void);
      EGLNativeWindowType (*getEGLNativeWindow)(_GLFWwindow*);
      // vulkan
      void (*getRequiredInstanceExtensions)(char**);
      int (*getPhysicalDevicePresentationSupport)(VkInstance,VkPhysicalDevice,uint32_t);
      VkResult (*createWindowSurface)(VkInstance,_GLFWwindow*,const VkAllocationCallbacks*,VkSurfaceKHR*);
  };
  
  // Library global data
  //
  struct _GLFWlibrary
  {
      GLFWbool            initialized;
      GLFWallocator       allocator;
  
      _GLFWplatform       platform;
  
      struct {
          _GLFWinitconfig init;
          _GLFWfbconfig   framebuffer;
          _GLFWwndconfig  window;
          _GLFWctxconfig  context;
          int             refreshRate;
      } hints;
  
      _GLFWerror*         errorListHead;
      _GLFWcursor*        cursorListHead;
      _GLFWwindow*        windowListHead;
  
      _GLFWmonitor**      monitors;
      int                 monitorCount;
  
      GLFWbool            joysticksInitialized;
      _GLFWjoystick       joysticks[GLFW_JOYSTICK_LAST + 1];
      _GLFWmapping*       mappings;
      int                 mappingCount;
  
      _GLFWtls            errorSlot;
      _GLFWtls            contextSlot;
      _GLFWmutex          errorLock;
  
      struct {
          uint64_t        offset;
          // This is defined in platform.h
          GLFW_PLATFORM_LIBRARY_TIMER_STATE
      } timer;
  
      struct {
          EGLenum         platform;
          EGLDisplay      display;
          EGLint          major, minor;
          GLFWbool        prefix;
  
          GLFWbool        KHR_create_context;
          GLFWbool        KHR_create_context_no_error;
          GLFWbool        KHR_gl_colorspace;
          GLFWbool        KHR_get_all_proc_addresses;
          GLFWbool        KHR_context_flush_control;
          GLFWbool        EXT_client_extensions;
          GLFWbool        EXT_platform_base;
          GLFWbool        EXT_platform_x11;
          GLFWbool        EXT_platform_wayland;
          GLFWbool        EXT_present_opaque;
          GLFWbool        ANGLE_platform_angle;
          GLFWbool        ANGLE_platform_angle_opengl;
          GLFWbool        ANGLE_platform_angle_d3d;
          GLFWbool        ANGLE_platform_angle_vulkan;
          GLFWbool        ANGLE_platform_angle_metal;
  
          void*           handle;
  
          PFN_eglGetConfigAttrib      GetConfigAttrib;
          PFN_eglGetConfigs           GetConfigs;
          PFN_eglGetDisplay           GetDisplay;
          PFN_eglGetError             GetError;
          PFN_eglInitialize           Initialize;
          PFN_eglTerminate            Terminate;
          PFN_eglBindAPI              BindAPI;
          PFN_eglCreateContext        CreateContext;
          PFN_eglDestroySurface       DestroySurface;
          PFN_eglDestroyContext       DestroyContext;
          PFN_eglCreateWindowSurface  CreateWindowSurface;
          PFN_eglMakeCurrent          MakeCurrent;
          PFN_eglSwapBuffers          SwapBuffers;
          PFN_eglSwapInterval         SwapInterval;
          PFN_eglQueryString          QueryString;
          PFN_eglGetProcAddress       GetProcAddress;
  
          PFNEGLGETPLATFORMDISPLAYEXTPROC GetPlatformDisplayEXT;
          PFNEGLCREATEPLATFORMWINDOWSURFACEEXTPROC CreatePlatformWindowSurfaceEXT;
      } egl;
  
      struct {
          void*           handle;
  
          PFN_OSMesaCreateContextExt      CreateContextExt;
          PFN_OSMesaCreateContextAttribs  CreateContextAttribs;
          PFN_OSMesaDestroyContext        DestroyContext;
          PFN_OSMesaMakeCurrent           MakeCurrent;
          PFN_OSMesaGetColorBuffer        GetColorBuffer;
          PFN_OSMesaGetDepthBuffer        GetDepthBuffer;
          PFN_OSMesaGetProcAddress        GetProcAddress;
  
      } osmesa;
  
      struct {
          GLFWbool        available;
          void*           handle;
          char*           extensions[2];
          PFN_vkGetInstanceProcAddr GetInstanceProcAddr;
          GLFWbool        KHR_surface;
          GLFWbool        KHR_win32_surface;
          GLFWbool        MVK_macos_surface;
          GLFWbool        EXT_metal_surface;
          GLFWbool        KHR_xlib_surface;
          GLFWbool        KHR_xcb_surface;
          GLFWbool        KHR_wayland_surface;
      } vk;
  
      struct {
          GLFWmonitorfun  monitor;
          GLFWjoystickfun joystick;
      } callbacks;
  
      // These are defined in platform.h
      GLFW_PLATFORM_LIBRARY_WINDOW_STATE
      GLFW_PLATFORM_LIBRARY_CONTEXT_STATE
      GLFW_PLATFORM_LIBRARY_JOYSTICK_STATE
  };
  
  // Global state shared between compilation units of GLFW
  //
  extern _GLFWlibrary _glfw;
  
  
  //////////////////////////////////////////////////////////////////////////
  //////                       GLFW platform API                      //////
  //////////////////////////////////////////////////////////////////////////
  
  void _glfwPlatformInitTimer(void);
  uint64_t _glfwPlatformGetTimerValue(void);
  uint64_t _glfwPlatformGetTimerFrequency(void);
  
  GLFWbool _glfwPlatformCreateTls(_GLFWtls* tls);
  void _glfwPlatformDestroyTls(_GLFWtls* tls);
  void* _glfwPlatformGetTls(_GLFWtls* tls);
  void _glfwPlatformSetTls(_GLFWtls* tls, void* value);
  
  GLFWbool _glfwPlatformCreateMutex(_GLFWmutex* mutex);
  void _glfwPlatformDestroyMutex(_GLFWmutex* mutex);
  void _glfwPlatformLockMutex(_GLFWmutex* mutex);
  void _glfwPlatformUnlockMutex(_GLFWmutex* mutex);
  
  void* _glfwPlatformLoadModule(const char* path);
  void _glfwPlatformFreeModule(void* module);
  GLFWproc _glfwPlatformGetModuleSymbol(void* module, const char* name);
  
  
  //////////////////////////////////////////////////////////////////////////
  //////                         GLFW event API                       //////
  //////////////////////////////////////////////////////////////////////////
  
  void _glfwInputWindowFocus(_GLFWwindow* window, GLFWbool focused);
  void _glfwInputWindowPos(_GLFWwindow* window, int xpos, int ypos);
  void _glfwInputWindowSize(_GLFWwindow* window, int width, int height);
  void _glfwInputFramebufferSize(_GLFWwindow* window, int width, int height);
  void _glfwInputWindowContentScale(_GLFWwindow* window,
                                    float xscale, float yscale);
  void _glfwInputWindowIconify(_GLFWwindow* window, GLFWbool iconified);
  void _glfwInputWindowMaximize(_GLFWwindow* window, GLFWbool maximized);
  void _glfwInputWindowDamage(_GLFWwindow* window);
  void _glfwInputWindowCloseRequest(_GLFWwindow* window);
  void _glfwInputWindowMonitor(_GLFWwindow* window, _GLFWmonitor* monitor);
  
  void _glfwInputKey(_GLFWwindow* window,
                     int key, int scancode, int action, int mods);
  void _glfwInputChar(_GLFWwindow* window,
                      uint32_t codepoint, int mods, GLFWbool plain);
  void _glfwInputScroll(_GLFWwindow* window, double xoffset, double yoffset);
  void _glfwInputMouseClick(_GLFWwindow* window, int button, int action, int mods);
  void _glfwInputCursorPos(_GLFWwindow* window, double xpos, double ypos);
  void _glfwInputCursorEnter(_GLFWwindow* window, GLFWbool entered);
  void _glfwInputDrop(_GLFWwindow* window, int count, const char** names);
  void _glfwInputJoystick(_GLFWjoystick* js, int event);
  void _glfwInputJoystickAxis(_GLFWjoystick* js, int axis, float value);
  void _glfwInputJoystickButton(_GLFWjoystick* js, int button, char value);
  void _glfwInputJoystickHat(_GLFWjoystick* js, int hat, char value);
  
  void _glfwInputMonitor(_GLFWmonitor* monitor, int action, int placement);
  void _glfwInputMonitorWindow(_GLFWmonitor* monitor, _GLFWwindow* window);
  
  #if defined(__GNUC__)
  void _glfwInputError(int code, const char* format, ...)
      __attribute__((format(printf, 2, 3)));
  #else
  void _glfwInputError(int code, const char* format, ...);
  #endif
  
  
  //////////////////////////////////////////////////////////////////////////
  //////                       GLFW internal API                      //////
  //////////////////////////////////////////////////////////////////////////
  
  GLFWbool _glfwSelectPlatform(int platformID, _GLFWplatform* platform);
  
  GLFWbool _glfwStringInExtensionString(const char* string, const char* extensions);
  const _GLFWfbconfig* _glfwChooseFBConfig(const _GLFWfbconfig* desired,
                                           const _GLFWfbconfig* alternatives,
                                           unsigned int count);
  GLFWbool _glfwRefreshContextAttribs(_GLFWwindow* window,
                                      const _GLFWctxconfig* ctxconfig);
  GLFWbool _glfwIsValidContextConfig(const _GLFWctxconfig* ctxconfig);
  
  const GLFWvidmode* _glfwChooseVideoMode(_GLFWmonitor* monitor,
                                          const GLFWvidmode* desired);
  int _glfwCompareVideoModes(const GLFWvidmode* first, const GLFWvidmode* second);
  _GLFWmonitor* _glfwAllocMonitor(const char* name, int widthMM, int heightMM);
  void _glfwFreeMonitor(_GLFWmonitor* monitor);
  void _glfwAllocGammaArrays(GLFWgammaramp* ramp, unsigned int size);
  void _glfwFreeGammaArrays(GLFWgammaramp* ramp);
  void _glfwSplitBPP(int bpp, int* red, int* green, int* blue);
  
  void _glfwInitGamepadMappings(void);
  _GLFWjoystick* _glfwAllocJoystick(const char* name,
                                    const char* guid,
                                    int axisCount,
                                    int buttonCount,
                                    int hatCount);
  void _glfwFreeJoystick(_GLFWjoystick* js);
  void _glfwCenterCursorInContentArea(_GLFWwindow* window);
  
  GLFWbool _glfwInitEGL(void);
  void _glfwTerminateEGL(void);
  GLFWbool _glfwCreateContextEGL(_GLFWwindow* window,
                                 const _GLFWctxconfig* ctxconfig,
                                 const _GLFWfbconfig* fbconfig);
  #if defined(_GLFW_X11)
  GLFWbool _glfwChooseVisualEGL(const _GLFWwndconfig* wndconfig,
                                const _GLFWctxconfig* ctxconfig,
                                const _GLFWfbconfig* fbconfig,
                                Visual** visual, int* depth);
  #endif /*_GLFW_X11*/
  
  GLFWbool _glfwInitOSMesa(void);
  void _glfwTerminateOSMesa(void);
  GLFWbool _glfwCreateContextOSMesa(_GLFWwindow* window,
                                    const _GLFWctxconfig* ctxconfig,
                                    const _GLFWfbconfig* fbconfig);
  
  GLFWbool _glfwInitVulkan(int mode);
  void _glfwTerminateVulkan(void);
  const char* _glfwGetVulkanResultString(VkResult result);
  
  size_t _glfwEncodeUTF8(char* s, uint32_t codepoint);
  
  char* _glfw_strdup(const char* source);
  int _glfw_min(int a, int b);
  int _glfw_max(int a, int b);
  float _glfw_fminf(float a, float b);
  float _glfw_fmaxf(float a, float b);
  
  void* _glfw_calloc(size_t count, size_t size);
  void* _glfw_realloc(void* pointer, size_t size);
  void _glfw_free(void* pointer);
  
  