1 //========================================================================
2 // GLFW 3.3 - www.glfw.org
3 //------------------------------------------------------------------------
4 // Copyright (c) 2002-2006 Marcus Geelnard
5 // Copyright (c) 2006-2016 Camilla Löwy <elmindreda@glfw.org>
6 //
7 // This software is provided 'as-is', without any express or implied
8 // warranty. In no event will the authors be held liable for any damages
9 // arising from the use of this software.
10 //
11 // Permission is granted to anyone to use this software for any purpose,
12 // including commercial applications, and to alter it and redistribute it
13 // freely, subject to the following restrictions:
14 //
15 // 1. The origin of this software must not be misrepresented; you must not
16 //    claim that you wrote the original software. If you use this software
17 //    in a product, an acknowledgment in the product documentation would
18 //    be appreciated but is not required.
19 //
20 // 2. Altered source versions must be plainly marked as such, and must not
21 //    be misrepresented as being the original software.
22 //
23 // 3. This notice may not be removed or altered from any source
24 //    distribution.
25 //
26 //========================================================================
27 
28 #pragma once
29 
30 // MODIFIED_ERIN
31 //#if defined(_GLFW_USE_CONFIG_H)
32  #include "glfw_config.h"
33 //#endif
34 
35 #if defined(GLFW_INCLUDE_GLCOREARB) || \
36     defined(GLFW_INCLUDE_ES1)       || \
37     defined(GLFW_INCLUDE_ES2)       || \
38     defined(GLFW_INCLUDE_ES3)       || \
39     defined(GLFW_INCLUDE_ES31)      || \
40     defined(GLFW_INCLUDE_ES32)      || \
41     defined(GLFW_INCLUDE_NONE)      || \
42     defined(GLFW_INCLUDE_GLEXT)     || \
43     defined(GLFW_INCLUDE_GLU)       || \
44     defined(GLFW_INCLUDE_VULKAN)    || \
45     defined(GLFW_DLL)
46  #error "You must not define any header option macros when compiling GLFW"
47 #endif
48 
49 #define GLFW_INCLUDE_NONE
50 #include "../include/GLFW/glfw3.h"
51 
52 #define _GLFW_INSERT_FIRST      0
53 #define _GLFW_INSERT_LAST       1
54 
55 #define _GLFW_POLL_PRESENCE     0
56 #define _GLFW_POLL_AXES         1
57 #define _GLFW_POLL_BUTTONS      2
58 #define _GLFW_POLL_ALL          (_GLFW_POLL_AXES | _GLFW_POLL_BUTTONS)
59 
60 #define _GLFW_MESSAGE_SIZE      1024
61 
62 typedef int GLFWbool;
63 
64 typedef struct _GLFWerror       _GLFWerror;
65 typedef struct _GLFWinitconfig  _GLFWinitconfig;
66 typedef struct _GLFWwndconfig   _GLFWwndconfig;
67 typedef struct _GLFWctxconfig   _GLFWctxconfig;
68 typedef struct _GLFWfbconfig    _GLFWfbconfig;
69 typedef struct _GLFWcontext     _GLFWcontext;
70 typedef struct _GLFWwindow      _GLFWwindow;
71 typedef struct _GLFWlibrary     _GLFWlibrary;
72 typedef struct _GLFWmonitor     _GLFWmonitor;
73 typedef struct _GLFWcursor      _GLFWcursor;
74 typedef struct _GLFWmapelement  _GLFWmapelement;
75 typedef struct _GLFWmapping     _GLFWmapping;
76 typedef struct _GLFWjoystick    _GLFWjoystick;
77 typedef struct _GLFWtls         _GLFWtls;
78 typedef struct _GLFWmutex       _GLFWmutex;
79 
80 typedef void (* _GLFWmakecontextcurrentfun)(_GLFWwindow*);
81 typedef void (* _GLFWswapbuffersfun)(_GLFWwindow*);
82 typedef void (* _GLFWswapintervalfun)(int);
83 typedef int (* _GLFWextensionsupportedfun)(const char*);
84 typedef GLFWglproc (* _GLFWgetprocaddressfun)(const char*);
85 typedef void (* _GLFWdestroycontextfun)(_GLFWwindow*);
86 
87 #define GL_VERSION 0x1f02
88 #define GL_NONE	0
89 #define GL_COLOR_BUFFER_BIT	0x00004000
90 #define GL_UNSIGNED_BYTE 0x1401
91 #define GL_EXTENSIONS 0x1f03
92 #define GL_NUM_EXTENSIONS 0x821d
93 #define GL_CONTEXT_FLAGS 0x821e
94 #define GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT 0x00000001
95 #define GL_CONTEXT_FLAG_DEBUG_BIT 0x00000002
96 #define GL_CONTEXT_PROFILE_MASK 0x9126
97 #define GL_CONTEXT_COMPATIBILITY_PROFILE_BIT 0x00000002
98 #define GL_CONTEXT_CORE_PROFILE_BIT 0x00000001
99 #define GL_RESET_NOTIFICATION_STRATEGY_ARB 0x8256
100 #define GL_LOSE_CONTEXT_ON_RESET_ARB 0x8252
101 #define GL_NO_RESET_NOTIFICATION_ARB 0x8261
102 #define GL_CONTEXT_RELEASE_BEHAVIOR 0x82fb
103 #define GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH 0x82fc
104 #define GL_CONTEXT_FLAG_NO_ERROR_BIT_KHR 0x00000008
105 
106 typedef int	GLint;
107 typedef unsigned int GLuint;
108 typedef unsigned int GLenum;
109 typedef unsigned int GLbitfield;
110 typedef unsigned char GLubyte;
111 
112 typedef void (APIENTRY * PFNGLCLEARPROC)(GLbitfield);
113 typedef const GLubyte* (APIENTRY * PFNGLGETSTRINGPROC)(GLenum);
114 typedef void (APIENTRY * PFNGLGETINTEGERVPROC)(GLenum,GLint*);
115 typedef const GLubyte* (APIENTRY * PFNGLGETSTRINGIPROC)(GLenum,GLuint);
116 
117 #define VK_NULL_HANDLE 0
118 
119 typedef void* VkInstance;
120 typedef void* VkPhysicalDevice;
121 typedef uint64_t VkSurfaceKHR;
122 typedef uint32_t VkFlags;
123 typedef uint32_t VkBool32;
124 
125 typedef enum VkStructureType
126 {
127     VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR = 1000004000,
128     VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR = 1000005000,
129     VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR = 1000006000,
130     VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR = 1000009000,
131     VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK = 1000123000,
132     VK_STRUCTURE_TYPE_MAX_ENUM = 0x7FFFFFFF
133 } VkStructureType;
134 
135 typedef enum VkResult
136 {
137     VK_SUCCESS = 0,
138     VK_NOT_READY = 1,
139     VK_TIMEOUT = 2,
140     VK_EVENT_SET = 3,
141     VK_EVENT_RESET = 4,
142     VK_INCOMPLETE = 5,
143     VK_ERROR_OUT_OF_HOST_MEMORY = -1,
144     VK_ERROR_OUT_OF_DEVICE_MEMORY = -2,
145     VK_ERROR_INITIALIZATION_FAILED = -3,
146     VK_ERROR_DEVICE_LOST = -4,
147     VK_ERROR_MEMORY_MAP_FAILED = -5,
148     VK_ERROR_LAYER_NOT_PRESENT = -6,
149     VK_ERROR_EXTENSION_NOT_PRESENT = -7,
150     VK_ERROR_FEATURE_NOT_PRESENT = -8,
151     VK_ERROR_INCOMPATIBLE_DRIVER = -9,
152     VK_ERROR_TOO_MANY_OBJECTS = -10,
153     VK_ERROR_FORMAT_NOT_SUPPORTED = -11,
154     VK_ERROR_SURFACE_LOST_KHR = -1000000000,
155     VK_SUBOPTIMAL_KHR = 1000001003,
156     VK_ERROR_OUT_OF_DATE_KHR = -1000001004,
157     VK_ERROR_INCOMPATIBLE_DISPLAY_KHR = -1000003001,
158     VK_ERROR_NATIVE_WINDOW_IN_USE_KHR = -1000000001,
159     VK_ERROR_VALIDATION_FAILED_EXT = -1000011001,
160     VK_RESULT_MAX_ENUM = 0x7FFFFFFF
161 } VkResult;
162 
163 typedef struct VkAllocationCallbacks VkAllocationCallbacks;
164 
165 typedef struct VkExtensionProperties
166 {
167     char            extensionName[256];
168     uint32_t        specVersion;
169 } VkExtensionProperties;
170 
171 typedef void (APIENTRY * PFN_vkVoidFunction)(void);
172 
173 #if defined(_GLFW_VULKAN_STATIC)
174   PFN_vkVoidFunction vkGetInstanceProcAddr(VkInstance,const char*);
175   VkResult vkEnumerateInstanceExtensionProperties(const char*,uint32_t*,VkExtensionProperties*);
176 #else
177   typedef PFN_vkVoidFunction (APIENTRY * PFN_vkGetInstanceProcAddr)(VkInstance,const char*);
178   typedef VkResult (APIENTRY * PFN_vkEnumerateInstanceExtensionProperties)(const char*,uint32_t*,VkExtensionProperties*);
179   #define vkEnumerateInstanceExtensionProperties _glfw.vk.EnumerateInstanceExtensionProperties
180   #define vkGetInstanceProcAddr _glfw.vk.GetInstanceProcAddr
181 #endif
182 
183 #if defined(_GLFW_COCOA)
184  #include "cocoa_platform.h"
185 #elif defined(_GLFW_WIN32)
186  #include "win32_platform.h"
187 #elif defined(_GLFW_X11)
188  #include "x11_platform.h"
189 #elif defined(_GLFW_WAYLAND)
190  #include "wl_platform.h"
191 #elif defined(_GLFW_OSMESA)
192  #include "null_platform.h"
193 #else
194  #error "No supported window creation API selected"
195 #endif
196 
197 // Constructs a version number string from the public header macros
198 #define _GLFW_CONCAT_VERSION(m, n, r) #m "." #n "." #r
199 #define _GLFW_MAKE_VERSION(m, n, r) _GLFW_CONCAT_VERSION(m, n, r)
200 #define _GLFW_VERSION_NUMBER _GLFW_MAKE_VERSION(GLFW_VERSION_MAJOR, \
201                                                 GLFW_VERSION_MINOR, \
202                                                 GLFW_VERSION_REVISION)
203 
204 // Checks for whether the library has been initialized
205 #define _GLFW_REQUIRE_INIT()                         \
206     if (!_glfw.initialized)                          \
207     {                                                \
208         _glfwInputError(GLFW_NOT_INITIALIZED, NULL); \
209         return;                                      \
210     }
211 #define _GLFW_REQUIRE_INIT_OR_RETURN(x)              \
212     if (!_glfw.initialized)                          \
213     {                                                \
214         _glfwInputError(GLFW_NOT_INITIALIZED, NULL); \
215         return x;                                    \
216     }
217 
218 // Swaps the provided pointers
219 #define _GLFW_SWAP_POINTERS(x, y) \
220     {                             \
221         void* t;                  \
222         t = x;                    \
223         x = y;                    \
224         y = t;                    \
225     }
226 
227 // Per-thread error structure
228 //
229 struct _GLFWerror
230 {
231     _GLFWerror*     next;
232     int             code;
233     char            description[_GLFW_MESSAGE_SIZE];
234 };
235 
236 // Initialization configuration
237 //
238 // Parameters relating to the initialization of the library
239 //
240 struct _GLFWinitconfig
241 {
242     GLFWbool      hatButtons;
243     struct {
244         GLFWbool  menubar;
245         GLFWbool  chdir;
246     } ns;
247 };
248 
249 // Window configuration
250 //
251 // Parameters relating to the creation of the window but not directly related
252 // to the framebuffer.  This is used to pass window creation parameters from
253 // shared code to the platform API.
254 //
255 struct _GLFWwndconfig
256 {
257     int           width;
258     int           height;
259     const char*   title;
260     GLFWbool      resizable;
261     GLFWbool      visible;
262     GLFWbool      decorated;
263     GLFWbool      focused;
264     GLFWbool      autoIconify;
265     GLFWbool      floating;
266     GLFWbool      maximized;
267     GLFWbool      centerCursor;
268     GLFWbool      focusOnShow;
269     GLFWbool      scaleToMonitor;
270     struct {
271         GLFWbool  retina;
272         char      frameName[256];
273     } ns;
274     struct {
275         char      className[256];
276         char      instanceName[256];
277     } x11;
278 };
279 
280 // Context configuration
281 //
282 // Parameters relating to the creation of the context but not directly related
283 // to the framebuffer.  This is used to pass context creation parameters from
284 // shared code to the platform API.
285 //
286 struct _GLFWctxconfig
287 {
288     int           client;
289     int           source;
290     int           major;
291     int           minor;
292     GLFWbool      forward;
293     GLFWbool      debug;
294     GLFWbool      noerror;
295     int           profile;
296     int           robustness;
297     int           release;
298     _GLFWwindow*  share;
299     struct {
300         GLFWbool  offline;
301     } nsgl;
302 };
303 
304 // Framebuffer configuration
305 //
306 // This describes buffers and their sizes.  It also contains
307 // a platform-specific ID used to map back to the backend API object.
308 //
309 // It is used to pass framebuffer parameters from shared code to the platform
310 // API and also to enumerate and select available framebuffer configs.
311 //
312 struct _GLFWfbconfig
313 {
314     int         redBits;
315     int         greenBits;
316     int         blueBits;
317     int         alphaBits;
318     int         depthBits;
319     int         stencilBits;
320     int         accumRedBits;
321     int         accumGreenBits;
322     int         accumBlueBits;
323     int         accumAlphaBits;
324     int         auxBuffers;
325     GLFWbool    stereo;
326     int         samples;
327     GLFWbool    sRGB;
328     GLFWbool    doublebuffer;
329     GLFWbool    transparent;
330     uintptr_t   handle;
331 };
332 
333 // Context structure
334 //
335 struct _GLFWcontext
336 {
337     int                 client;
338     int                 source;
339     int                 major, minor, revision;
340     GLFWbool            forward, debug, noerror;
341     int                 profile;
342     int                 robustness;
343     int                 release;
344 
345     PFNGLGETSTRINGIPROC GetStringi;
346     PFNGLGETINTEGERVPROC GetIntegerv;
347     PFNGLGETSTRINGPROC  GetString;
348 
349     _GLFWmakecontextcurrentfun  makeCurrent;
350     _GLFWswapbuffersfun         swapBuffers;
351     _GLFWswapintervalfun        swapInterval;
352     _GLFWextensionsupportedfun  extensionSupported;
353     _GLFWgetprocaddressfun      getProcAddress;
354     _GLFWdestroycontextfun      destroy;
355 
356     // This is defined in the context API's context.h
357     _GLFW_PLATFORM_CONTEXT_STATE;
358     // This is defined in egl_context.h
359     _GLFW_EGL_CONTEXT_STATE;
360     // This is defined in osmesa_context.h
361     _GLFW_OSMESA_CONTEXT_STATE;
362 };
363 
364 // Window and context structure
365 //
366 struct _GLFWwindow
367 {
368     struct _GLFWwindow* next;
369 
370     // Window settings and state
371     GLFWbool            resizable;
372     GLFWbool            decorated;
373     GLFWbool            autoIconify;
374     GLFWbool            floating;
375     GLFWbool            focusOnShow;
376     GLFWbool            shouldClose;
377     void*               userPointer;
378     GLFWvidmode         videoMode;
379     _GLFWmonitor*       monitor;
380     _GLFWcursor*        cursor;
381 
382     int                 minwidth, minheight;
383     int                 maxwidth, maxheight;
384     int                 numer, denom;
385 
386     GLFWbool            stickyKeys;
387     GLFWbool            stickyMouseButtons;
388     GLFWbool            lockKeyMods;
389     int                 cursorMode;
390     char                mouseButtons[GLFW_MOUSE_BUTTON_LAST + 1];
391     char                keys[GLFW_KEY_LAST + 1];
392     // Virtual cursor position when cursor is disabled
393     double              virtualCursorPosX, virtualCursorPosY;
394 
395     _GLFWcontext        context;
396 
397     struct {
398         GLFWwindowposfun        pos;
399         GLFWwindowsizefun       size;
400         GLFWwindowclosefun      close;
401         GLFWwindowrefreshfun    refresh;
402         GLFWwindowfocusfun      focus;
403         GLFWwindowiconifyfun    iconify;
404         GLFWwindowmaximizefun   maximize;
405         GLFWframebuffersizefun  fbsize;
406         GLFWwindowcontentscalefun scale;
407         GLFWmousebuttonfun      mouseButton;
408         GLFWcursorposfun        cursorPos;
409         GLFWcursorenterfun      cursorEnter;
410         GLFWscrollfun           scroll;
411         GLFWkeyfun              key;
412         GLFWcharfun             character;
413         GLFWcharmodsfun         charmods;
414         GLFWdropfun             drop;
415     } callbacks;
416 
417     // This is defined in the window API's platform.h
418     _GLFW_PLATFORM_WINDOW_STATE;
419 };
420 
421 // Monitor structure
422 //
423 struct _GLFWmonitor
424 {
425     char*           name;
426     void*           userPointer;
427 
428     // Physical dimensions in millimeters.
429     int             widthMM, heightMM;
430 
431     // The window whose video mode is current on this monitor
432     _GLFWwindow*    window;
433 
434     GLFWvidmode*    modes;
435     int             modeCount;
436     GLFWvidmode     currentMode;
437 
438     GLFWgammaramp   originalRamp;
439     GLFWgammaramp   currentRamp;
440 
441     // This is defined in the window API's platform.h
442     _GLFW_PLATFORM_MONITOR_STATE;
443 };
444 
445 // Cursor structure
446 //
447 struct _GLFWcursor
448 {
449     _GLFWcursor*    next;
450 
451     // This is defined in the window API's platform.h
452     _GLFW_PLATFORM_CURSOR_STATE;
453 };
454 
455 // Gamepad mapping element structure
456 //
457 struct _GLFWmapelement
458 {
459     uint8_t         type;
460     uint8_t         index;
461     int8_t          axisScale;
462     int8_t          axisOffset;
463 };
464 
465 // Gamepad mapping structure
466 //
467 struct _GLFWmapping
468 {
469     char            name[128];
470     char            guid[33];
471     _GLFWmapelement buttons[15];
472     _GLFWmapelement axes[6];
473 };
474 
475 // Joystick structure
476 //
477 struct _GLFWjoystick
478 {
479     GLFWbool        present;
480     float*          axes;
481     int             axisCount;
482     unsigned char*  buttons;
483     int             buttonCount;
484     unsigned char*  hats;
485     int             hatCount;
486     char*           name;
487     void*           userPointer;
488     char            guid[33];
489     _GLFWmapping*   mapping;
490 
491     // This is defined in the joystick API's joystick.h
492     _GLFW_PLATFORM_JOYSTICK_STATE;
493 };
494 
495 // Thread local storage structure
496 //
497 struct _GLFWtls
498 {
499     // This is defined in the platform's thread.h
500     _GLFW_PLATFORM_TLS_STATE;
501 };
502 
503 // Mutex structure
504 //
505 struct _GLFWmutex
506 {
507     // This is defined in the platform's thread.h
508     _GLFW_PLATFORM_MUTEX_STATE;
509 };
510 
511 // Library global data
512 //
513 struct _GLFWlibrary
514 {
515     GLFWbool            initialized;
516 
517     struct {
518         _GLFWinitconfig init;
519         _GLFWfbconfig   framebuffer;
520         _GLFWwndconfig  window;
521         _GLFWctxconfig  context;
522         int             refreshRate;
523     } hints;
524 
525     _GLFWerror*         errorListHead;
526     _GLFWcursor*        cursorListHead;
527     _GLFWwindow*        windowListHead;
528 
529     _GLFWmonitor**      monitors;
530     int                 monitorCount;
531 
532     _GLFWjoystick       joysticks[GLFW_JOYSTICK_LAST + 1];
533     _GLFWmapping*       mappings;
534     int                 mappingCount;
535 
536     _GLFWtls            errorSlot;
537     _GLFWtls            contextSlot;
538     _GLFWmutex          errorLock;
539 
540     struct {
541         uint64_t        offset;
542         // This is defined in the platform's time.h
543         _GLFW_PLATFORM_LIBRARY_TIMER_STATE;
544     } timer;
545 
546     struct {
547         GLFWbool        available;
548         void*           handle;
549         char*           extensions[2];
550 #if !defined(_GLFW_VULKAN_STATIC)
551         PFN_vkEnumerateInstanceExtensionProperties EnumerateInstanceExtensionProperties;
552         PFN_vkGetInstanceProcAddr GetInstanceProcAddr;
553 #endif
554         GLFWbool        KHR_surface;
555 #if defined(_GLFW_WIN32)
556         GLFWbool        KHR_win32_surface;
557 #elif defined(_GLFW_COCOA)
558         GLFWbool        MVK_macos_surface;
559 #elif defined(_GLFW_X11)
560         GLFWbool        KHR_xlib_surface;
561         GLFWbool        KHR_xcb_surface;
562 #elif defined(_GLFW_WAYLAND)
563         GLFWbool        KHR_wayland_surface;
564 #endif
565     } vk;
566 
567     struct {
568         GLFWmonitorfun  monitor;
569         GLFWjoystickfun joystick;
570     } callbacks;
571 
572     // This is defined in the window API's platform.h
573     _GLFW_PLATFORM_LIBRARY_WINDOW_STATE;
574     // This is defined in the context API's context.h
575     _GLFW_PLATFORM_LIBRARY_CONTEXT_STATE;
576     // This is defined in the platform's joystick.h
577     _GLFW_PLATFORM_LIBRARY_JOYSTICK_STATE;
578     // This is defined in egl_context.h
579     _GLFW_EGL_LIBRARY_CONTEXT_STATE;
580     // This is defined in osmesa_context.h
581     _GLFW_OSMESA_LIBRARY_CONTEXT_STATE;
582 };
583 
584 // Global state shared between compilation units of GLFW
585 //
586 extern _GLFWlibrary _glfw;
587 
588 
589 //////////////////////////////////////////////////////////////////////////
590 //////                       GLFW platform API                      //////
591 //////////////////////////////////////////////////////////////////////////
592 
593 int _glfwPlatformInit(void);
594 void _glfwPlatformTerminate(void);
595 const char* _glfwPlatformGetVersionString(void);
596 
597 void _glfwPlatformGetCursorPos(_GLFWwindow* window, double* xpos, double* ypos);
598 void _glfwPlatformSetCursorPos(_GLFWwindow* window, double xpos, double ypos);
599 void _glfwPlatformSetCursorMode(_GLFWwindow* window, int mode);
600 int _glfwPlatformCreateCursor(_GLFWcursor* cursor,
601                               const GLFWimage* image, int xhot, int yhot);
602 int _glfwPlatformCreateStandardCursor(_GLFWcursor* cursor, int shape);
603 void _glfwPlatformDestroyCursor(_GLFWcursor* cursor);
604 void _glfwPlatformSetCursor(_GLFWwindow* window, _GLFWcursor* cursor);
605 
606 const char* _glfwPlatformGetScancodeName(int scancode);
607 int _glfwPlatformGetKeyScancode(int key);
608 
609 void _glfwPlatformFreeMonitor(_GLFWmonitor* monitor);
610 void _glfwPlatformGetMonitorPos(_GLFWmonitor* monitor, int* xpos, int* ypos);
611 void _glfwPlatformGetMonitorContentScale(_GLFWmonitor* monitor,
612                                          float* xscale, float* yscale);
613 GLFWvidmode* _glfwPlatformGetVideoModes(_GLFWmonitor* monitor, int* count);
614 void _glfwPlatformGetVideoMode(_GLFWmonitor* monitor, GLFWvidmode* mode);
615 GLFWbool _glfwPlatformGetGammaRamp(_GLFWmonitor* monitor, GLFWgammaramp* ramp);
616 void _glfwPlatformSetGammaRamp(_GLFWmonitor* monitor, const GLFWgammaramp* ramp);
617 
618 void _glfwPlatformSetClipboardString(const char* string);
619 const char* _glfwPlatformGetClipboardString(void);
620 
621 int _glfwPlatformPollJoystick(_GLFWjoystick* js, int mode);
622 void _glfwPlatformUpdateGamepadGUID(char* guid);
623 
624 uint64_t _glfwPlatformGetTimerValue(void);
625 uint64_t _glfwPlatformGetTimerFrequency(void);
626 
627 int _glfwPlatformCreateWindow(_GLFWwindow* window,
628                               const _GLFWwndconfig* wndconfig,
629                               const _GLFWctxconfig* ctxconfig,
630                               const _GLFWfbconfig* fbconfig);
631 void _glfwPlatformDestroyWindow(_GLFWwindow* window);
632 void _glfwPlatformSetWindowTitle(_GLFWwindow* window, const char* title);
633 void _glfwPlatformSetWindowIcon(_GLFWwindow* window,
634                                 int count, const GLFWimage* images);
635 void _glfwPlatformGetWindowPos(_GLFWwindow* window, int* xpos, int* ypos);
636 void _glfwPlatformSetWindowPos(_GLFWwindow* window, int xpos, int ypos);
637 void _glfwPlatformGetWindowSize(_GLFWwindow* window, int* width, int* height);
638 void _glfwPlatformSetWindowSize(_GLFWwindow* window, int width, int height);
639 void _glfwPlatformSetWindowSizeLimits(_GLFWwindow* window,
640                                       int minwidth, int minheight,
641                                       int maxwidth, int maxheight);
642 void _glfwPlatformSetWindowAspectRatio(_GLFWwindow* window, int numer, int denom);
643 void _glfwPlatformGetFramebufferSize(_GLFWwindow* window, int* width, int* height);
644 void _glfwPlatformGetWindowFrameSize(_GLFWwindow* window,
645                                      int* left, int* top,
646                                      int* right, int* bottom);
647 void _glfwPlatformGetWindowContentScale(_GLFWwindow* window,
648                                         float* xscale, float* yscale);
649 void _glfwPlatformIconifyWindow(_GLFWwindow* window);
650 void _glfwPlatformRestoreWindow(_GLFWwindow* window);
651 void _glfwPlatformMaximizeWindow(_GLFWwindow* window);
652 void _glfwPlatformShowWindow(_GLFWwindow* window);
653 void _glfwPlatformHideWindow(_GLFWwindow* window);
654 void _glfwPlatformRequestWindowAttention(_GLFWwindow* window);
655 void _glfwPlatformFocusWindow(_GLFWwindow* window);
656 void _glfwPlatformSetWindowMonitor(_GLFWwindow* window, _GLFWmonitor* monitor,
657                                    int xpos, int ypos, int width, int height,
658                                    int refreshRate);
659 int _glfwPlatformWindowFocused(_GLFWwindow* window);
660 int _glfwPlatformWindowIconified(_GLFWwindow* window);
661 int _glfwPlatformWindowVisible(_GLFWwindow* window);
662 int _glfwPlatformWindowMaximized(_GLFWwindow* window);
663 int _glfwPlatformWindowHovered(_GLFWwindow* window);
664 int _glfwPlatformFramebufferTransparent(_GLFWwindow* window);
665 float _glfwPlatformGetWindowOpacity(_GLFWwindow* window);
666 void _glfwPlatformSetWindowResizable(_GLFWwindow* window, GLFWbool enabled);
667 void _glfwPlatformSetWindowDecorated(_GLFWwindow* window, GLFWbool enabled);
668 void _glfwPlatformSetWindowFloating(_GLFWwindow* window, GLFWbool enabled);
669 void _glfwPlatformSetWindowOpacity(_GLFWwindow* window, float opacity);
670 
671 void _glfwPlatformPollEvents(void);
672 void _glfwPlatformWaitEvents(void);
673 void _glfwPlatformWaitEventsTimeout(double timeout);
674 void _glfwPlatformPostEmptyEvent(void);
675 
676 void _glfwPlatformGetRequiredInstanceExtensions(char** extensions);
677 int _glfwPlatformGetPhysicalDevicePresentationSupport(VkInstance instance,
678                                                       VkPhysicalDevice device,
679                                                       uint32_t queuefamily);
680 VkResult _glfwPlatformCreateWindowSurface(VkInstance instance,
681                                           _GLFWwindow* window,
682                                           const VkAllocationCallbacks* allocator,
683                                           VkSurfaceKHR* surface);
684 
685 GLFWbool _glfwPlatformCreateTls(_GLFWtls* tls);
686 void _glfwPlatformDestroyTls(_GLFWtls* tls);
687 void* _glfwPlatformGetTls(_GLFWtls* tls);
688 void _glfwPlatformSetTls(_GLFWtls* tls, void* value);
689 
690 GLFWbool _glfwPlatformCreateMutex(_GLFWmutex* mutex);
691 void _glfwPlatformDestroyMutex(_GLFWmutex* mutex);
692 void _glfwPlatformLockMutex(_GLFWmutex* mutex);
693 void _glfwPlatformUnlockMutex(_GLFWmutex* mutex);
694 
695 
696 //////////////////////////////////////////////////////////////////////////
697 //////                         GLFW event API                       //////
698 //////////////////////////////////////////////////////////////////////////
699 
700 void _glfwInputWindowFocus(_GLFWwindow* window, GLFWbool focused);
701 void _glfwInputWindowPos(_GLFWwindow* window, int xpos, int ypos);
702 void _glfwInputWindowSize(_GLFWwindow* window, int width, int height);
703 void _glfwInputFramebufferSize(_GLFWwindow* window, int width, int height);
704 void _glfwInputWindowContentScale(_GLFWwindow* window,
705                                   float xscale, float yscale);
706 void _glfwInputWindowIconify(_GLFWwindow* window, GLFWbool iconified);
707 void _glfwInputWindowMaximize(_GLFWwindow* window, GLFWbool maximized);
708 void _glfwInputWindowDamage(_GLFWwindow* window);
709 void _glfwInputWindowCloseRequest(_GLFWwindow* window);
710 void _glfwInputWindowMonitor(_GLFWwindow* window, _GLFWmonitor* monitor);
711 
712 void _glfwInputKey(_GLFWwindow* window,
713                    int key, int scancode, int action, int mods);
714 void _glfwInputChar(_GLFWwindow* window,
715                     unsigned int codepoint, int mods, GLFWbool plain);
716 void _glfwInputScroll(_GLFWwindow* window, double xoffset, double yoffset);
717 void _glfwInputMouseClick(_GLFWwindow* window, int button, int action, int mods);
718 void _glfwInputCursorPos(_GLFWwindow* window, double xpos, double ypos);
719 void _glfwInputCursorEnter(_GLFWwindow* window, GLFWbool entered);
720 void _glfwInputDrop(_GLFWwindow* window, int count, const char** names);
721 void _glfwInputJoystick(_GLFWjoystick* js, int event);
722 void _glfwInputJoystickAxis(_GLFWjoystick* js, int axis, float value);
723 void _glfwInputJoystickButton(_GLFWjoystick* js, int button, char value);
724 void _glfwInputJoystickHat(_GLFWjoystick* js, int hat, char value);
725 
726 void _glfwInputMonitor(_GLFWmonitor* monitor, int action, int placement);
727 void _glfwInputMonitorWindow(_GLFWmonitor* monitor, _GLFWwindow* window);
728 
729 #if defined(__GNUC__)
730 void _glfwInputError(int code, const char* format, ...)
731     __attribute__((format(printf, 2, 3)));
732 #else
733 void _glfwInputError(int code, const char* format, ...);
734 #endif
735 
736 
737 //////////////////////////////////////////////////////////////////////////
738 //////                       GLFW internal API                      //////
739 //////////////////////////////////////////////////////////////////////////
740 
741 GLFWbool _glfwStringInExtensionString(const char* string, const char* extensions);
742 const _GLFWfbconfig* _glfwChooseFBConfig(const _GLFWfbconfig* desired,
743                                          const _GLFWfbconfig* alternatives,
744                                          unsigned int count);
745 GLFWbool _glfwRefreshContextAttribs(_GLFWwindow* window,
746                                     const _GLFWctxconfig* ctxconfig);
747 GLFWbool _glfwIsValidContextConfig(const _GLFWctxconfig* ctxconfig);
748 
749 const GLFWvidmode* _glfwChooseVideoMode(_GLFWmonitor* monitor,
750                                         const GLFWvidmode* desired);
751 int _glfwCompareVideoModes(const GLFWvidmode* first, const GLFWvidmode* second);
752 _GLFWmonitor* _glfwAllocMonitor(const char* name, int widthMM, int heightMM);
753 void _glfwFreeMonitor(_GLFWmonitor* monitor);
754 void _glfwAllocGammaArrays(GLFWgammaramp* ramp, unsigned int size);
755 void _glfwFreeGammaArrays(GLFWgammaramp* ramp);
756 void _glfwSplitBPP(int bpp, int* red, int* green, int* blue);
757 
758 _GLFWjoystick* _glfwAllocJoystick(const char* name,
759                                   const char* guid,
760                                   int axisCount,
761                                   int buttonCount,
762                                   int hatCount);
763 void _glfwFreeJoystick(_GLFWjoystick* js);
764 
765 GLFWbool _glfwInitVulkan(int mode);
766 void _glfwTerminateVulkan(void);
767 const char* _glfwGetVulkanResultString(VkResult result);
768 
769 char* _glfw_strdup(const char* source);
770 float _glfw_fminf(float a, float b);
771 float _glfw_fmaxf(float a, float b);
772 
773