add glfw library

1 files changed, 650 insertions, 0 deletions

diff --git a/libs/glfw-3.3.8/tests/events.c b/libs/glfw-3.3.8/tests/events.c
new file mode 100644
index 0000000..f29dfbb
--- /dev/null
+++ b/libs/glfw-3.3.8/tests/events.c
@@ -0,0 +1,650 @@
+//========================================================================
+// Event linter (event spewer)
+// Copyright (c) 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.
+//
+//========================================================================
+//
+// This test hooks every available callback and outputs their arguments
+//
+// Log messages go to stdout, error messages to stderr
+//
+// Every event also gets a (sequential) number to aid discussion of logs
+//
+//========================================================================
+
+#include <glad/gl.h>
+#define GLFW_INCLUDE_NONE
+#include <GLFW/glfw3.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <string.h>
+#include <locale.h>
+
+#include "getopt.h"
+
+// Event index
+static unsigned int counter = 0;
+
+typedef struct
+{
+    GLFWwindow* window;
+    int number;
+    int closeable;
+} Slot;
+
+static void usage(void)
+{
+    printf("Usage: events [-f] [-h] [-n WINDOWS]\n");
+    printf("Options:\n");
+    printf("  -f use full screen\n");
+    printf("  -h show this help\n");
+    printf("  -n the number of windows to create\n");
+}
+
+static const char* get_key_name(int key)
+{
+    switch (key)
+    {
+        // Printable keys
+        case GLFW_KEY_A:            return "A";
+        case GLFW_KEY_B:            return "B";
+        case GLFW_KEY_C:            return "C";
+        case GLFW_KEY_D:            return "D";
+        case GLFW_KEY_E:            return "E";
+        case GLFW_KEY_F:            return "F";
+        case GLFW_KEY_G:            return "G";
+        case GLFW_KEY_H:            return "H";
+        case GLFW_KEY_I:            return "I";
+        case GLFW_KEY_J:            return "J";
+        case GLFW_KEY_K:            return "K";
+        case GLFW_KEY_L:            return "L";
+        case GLFW_KEY_M:            return "M";
+        case GLFW_KEY_N:            return "N";
+        case GLFW_KEY_O:            return "O";
+        case GLFW_KEY_P:            return "P";
+        case GLFW_KEY_Q:            return "Q";
+        case GLFW_KEY_R:            return "R";
+        case GLFW_KEY_S:            return "S";
+        case GLFW_KEY_T:            return "T";
+        case GLFW_KEY_U:            return "U";
+        case GLFW_KEY_V:            return "V";
+        case GLFW_KEY_W:            return "W";
+        case GLFW_KEY_X:            return "X";
+        case GLFW_KEY_Y:            return "Y";
+        case GLFW_KEY_Z:            return "Z";
+        case GLFW_KEY_1:            return "1";
+        case GLFW_KEY_2:            return "2";
+        case GLFW_KEY_3:            return "3";
+        case GLFW_KEY_4:            return "4";
+        case GLFW_KEY_5:            return "5";
+        case GLFW_KEY_6:            return "6";
+        case GLFW_KEY_7:            return "7";
+        case GLFW_KEY_8:            return "8";
+        case GLFW_KEY_9:            return "9";
+        case GLFW_KEY_0:            return "0";
+        case GLFW_KEY_SPACE:        return "SPACE";
+        case GLFW_KEY_MINUS:        return "MINUS";
+        case GLFW_KEY_EQUAL:        return "EQUAL";
+        case GLFW_KEY_LEFT_BRACKET: return "LEFT BRACKET";
+        case GLFW_KEY_RIGHT_BRACKET: return "RIGHT BRACKET";
+        case GLFW_KEY_BACKSLASH:    return "BACKSLASH";
+        case GLFW_KEY_SEMICOLON:    return "SEMICOLON";
+        case GLFW_KEY_APOSTROPHE:   return "APOSTROPHE";
+        case GLFW_KEY_GRAVE_ACCENT: return "GRAVE ACCENT";
+        case GLFW_KEY_COMMA:        return "COMMA";
+        case GLFW_KEY_PERIOD:       return "PERIOD";
+        case GLFW_KEY_SLASH:        return "SLASH";
+        case GLFW_KEY_WORLD_1:      return "WORLD 1";
+        case GLFW_KEY_WORLD_2:      return "WORLD 2";
+
+        // Function keys
+        case GLFW_KEY_ESCAPE:       return "ESCAPE";
+        case GLFW_KEY_F1:           return "F1";
+        case GLFW_KEY_F2:           return "F2";
+        case GLFW_KEY_F3:           return "F3";
+        case GLFW_KEY_F4:           return "F4";
+        case GLFW_KEY_F5:           return "F5";
+        case GLFW_KEY_F6:           return "F6";
+        case GLFW_KEY_F7:           return "F7";
+        case GLFW_KEY_F8:           return "F8";
+        case GLFW_KEY_F9:           return "F9";
+        case GLFW_KEY_F10:          return "F10";
+        case GLFW_KEY_F11:          return "F11";
+        case GLFW_KEY_F12:          return "F12";
+        case GLFW_KEY_F13:          return "F13";
+        case GLFW_KEY_F14:          return "F14";
+        case GLFW_KEY_F15:          return "F15";
+        case GLFW_KEY_F16:          return "F16";
+        case GLFW_KEY_F17:          return "F17";
+        case GLFW_KEY_F18:          return "F18";
+        case GLFW_KEY_F19:          return "F19";
+        case GLFW_KEY_F20:          return "F20";
+        case GLFW_KEY_F21:          return "F21";
+        case GLFW_KEY_F22:          return "F22";
+        case GLFW_KEY_F23:          return "F23";
+        case GLFW_KEY_F24:          return "F24";
+        case GLFW_KEY_F25:          return "F25";
+        case GLFW_KEY_UP:           return "UP";
+        case GLFW_KEY_DOWN:         return "DOWN";
+        case GLFW_KEY_LEFT:         return "LEFT";
+        case GLFW_KEY_RIGHT:        return "RIGHT";
+        case GLFW_KEY_LEFT_SHIFT:   return "LEFT SHIFT";
+        case GLFW_KEY_RIGHT_SHIFT:  return "RIGHT SHIFT";
+        case GLFW_KEY_LEFT_CONTROL: return "LEFT CONTROL";
+        case GLFW_KEY_RIGHT_CONTROL: return "RIGHT CONTROL";
+        case GLFW_KEY_LEFT_ALT:     return "LEFT ALT";
+        case GLFW_KEY_RIGHT_ALT:    return "RIGHT ALT";
+        case GLFW_KEY_TAB:          return "TAB";
+        case GLFW_KEY_ENTER:        return "ENTER";
+        case GLFW_KEY_BACKSPACE:    return "BACKSPACE";
+        case GLFW_KEY_INSERT:       return "INSERT";
+        case GLFW_KEY_DELETE:       return "DELETE";
+        case GLFW_KEY_PAGE_UP:      return "PAGE UP";
+        case GLFW_KEY_PAGE_DOWN:    return "PAGE DOWN";
+        case GLFW_KEY_HOME:         return "HOME";
+        case GLFW_KEY_END:          return "END";
+        case GLFW_KEY_KP_0:         return "KEYPAD 0";
+        case GLFW_KEY_KP_1:         return "KEYPAD 1";
+        case GLFW_KEY_KP_2:         return "KEYPAD 2";
+        case GLFW_KEY_KP_3:         return "KEYPAD 3";
+        case GLFW_KEY_KP_4:         return "KEYPAD 4";
+        case GLFW_KEY_KP_5:         return "KEYPAD 5";
+        case GLFW_KEY_KP_6:         return "KEYPAD 6";
+        case GLFW_KEY_KP_7:         return "KEYPAD 7";
+        case GLFW_KEY_KP_8:         return "KEYPAD 8";
+        case GLFW_KEY_KP_9:         return "KEYPAD 9";
+        case GLFW_KEY_KP_DIVIDE:    return "KEYPAD DIVIDE";
+        case GLFW_KEY_KP_MULTIPLY:  return "KEYPAD MULTIPLY";
+        case GLFW_KEY_KP_SUBTRACT:  return "KEYPAD SUBTRACT";
+        case GLFW_KEY_KP_ADD:       return "KEYPAD ADD";
+        case GLFW_KEY_KP_DECIMAL:   return "KEYPAD DECIMAL";
+        case GLFW_KEY_KP_EQUAL:     return "KEYPAD EQUAL";
+        case GLFW_KEY_KP_ENTER:     return "KEYPAD ENTER";
+        case GLFW_KEY_PRINT_SCREEN: return "PRINT SCREEN";
+        case GLFW_KEY_NUM_LOCK:     return "NUM LOCK";
+        case GLFW_KEY_CAPS_LOCK:    return "CAPS LOCK";
+        case GLFW_KEY_SCROLL_LOCK:  return "SCROLL LOCK";
+        case GLFW_KEY_PAUSE:        return "PAUSE";
+        case GLFW_KEY_LEFT_SUPER:   return "LEFT SUPER";
+        case GLFW_KEY_RIGHT_SUPER:  return "RIGHT SUPER";
+        case GLFW_KEY_MENU:         return "MENU";
+
+        default:                    return "UNKNOWN";
+    }
+}
+
+static const char* get_action_name(int action)
+{
+    switch (action)
+    {
+        case GLFW_PRESS:
+            return "pressed";
+        case GLFW_RELEASE:
+            return "released";
+        case GLFW_REPEAT:
+            return "repeated";
+    }
+
+    return "caused unknown action";
+}
+
+static const char* get_button_name(int button)
+{
+    switch (button)
+    {
+        case GLFW_MOUSE_BUTTON_LEFT:
+            return "left";
+        case GLFW_MOUSE_BUTTON_RIGHT:
+            return "right";
+        case GLFW_MOUSE_BUTTON_MIDDLE:
+            return "middle";
+        default:
+        {
+            static char name[16];
+            snprintf(name, sizeof(name), "%i", button);
+            return name;
+        }
+    }
+}
+
+static const char* get_mods_name(int mods)
+{
+    static char name[512];
+
+    if (mods == 0)
+        return " no mods";
+
+    name[0] = '\0';
+
+    if (mods & GLFW_MOD_SHIFT)
+        strcat(name, " shift");
+    if (mods & GLFW_MOD_CONTROL)
+        strcat(name, " control");
+    if (mods & GLFW_MOD_ALT)
+        strcat(name, " alt");
+    if (mods & GLFW_MOD_SUPER)
+        strcat(name, " super");
+    if (mods & GLFW_MOD_CAPS_LOCK)
+        strcat(name, " capslock-on");
+    if (mods & GLFW_MOD_NUM_LOCK)
+        strcat(name, " numlock-on");
+
+    return name;
+}
+
+static size_t encode_utf8(char* s, unsigned int ch)
+{
+    size_t count = 0;
+
+    if (ch < 0x80)
+        s[count++] = (char) ch;
+    else if (ch < 0x800)
+    {
+        s[count++] = (ch >> 6) | 0xc0;
+        s[count++] = (ch & 0x3f) | 0x80;
+    }
+    else if (ch < 0x10000)
+    {
+        s[count++] = (ch >> 12) | 0xe0;
+        s[count++] = ((ch >> 6) & 0x3f) | 0x80;
+        s[count++] = (ch & 0x3f) | 0x80;
+    }
+    else if (ch < 0x110000)
+    {
+        s[count++] = (ch >> 18) | 0xf0;
+        s[count++] = ((ch >> 12) & 0x3f) | 0x80;
+        s[count++] = ((ch >> 6) & 0x3f) | 0x80;
+        s[count++] = (ch & 0x3f) | 0x80;
+    }
+
+    return count;
+}
+
+static void error_callback(int error, const char* description)
+{
+    fprintf(stderr, "Error: %s\n", description);
+}
+
+static void window_pos_callback(GLFWwindow* window, int x, int y)
+{
+    Slot* slot = glfwGetWindowUserPointer(window);
+    printf("%08x to %i at %0.3f: Window position: %i %i\n",
+           counter++, slot->number, glfwGetTime(), x, y);
+}
+
+static void window_size_callback(GLFWwindow* window, int width, int height)
+{
+    Slot* slot = glfwGetWindowUserPointer(window);
+    printf("%08x to %i at %0.3f: Window size: %i %i\n",
+           counter++, slot->number, glfwGetTime(), width, height);
+}
+
+static void framebuffer_size_callback(GLFWwindow* window, int width, int height)
+{
+    Slot* slot = glfwGetWindowUserPointer(window);
+    printf("%08x to %i at %0.3f: Framebuffer size: %i %i\n",
+           counter++, slot->number, glfwGetTime(), width, height);
+}
+
+static void window_content_scale_callback(GLFWwindow* window, float xscale, float yscale)
+{
+    Slot* slot = glfwGetWindowUserPointer(window);
+    printf("%08x to %i at %0.3f: Window content scale: %0.3f %0.3f\n",
+           counter++, slot->number, glfwGetTime(), xscale, yscale);
+}
+
+static void window_close_callback(GLFWwindow* window)
+{
+    Slot* slot = glfwGetWindowUserPointer(window);
+    printf("%08x to %i at %0.3f: Window close\n",
+           counter++, slot->number, glfwGetTime());
+
+    glfwSetWindowShouldClose(window, slot->closeable);
+}
+
+static void window_refresh_callback(GLFWwindow* window)
+{
+    Slot* slot = glfwGetWindowUserPointer(window);
+    printf("%08x to %i at %0.3f: Window refresh\n",
+           counter++, slot->number, glfwGetTime());
+
+    glfwMakeContextCurrent(window);
+    glClear(GL_COLOR_BUFFER_BIT);
+    glfwSwapBuffers(window);
+}
+
+static void window_focus_callback(GLFWwindow* window, int focused)
+{
+    Slot* slot = glfwGetWindowUserPointer(window);
+    printf("%08x to %i at %0.3f: Window %s\n",
+           counter++, slot->number, glfwGetTime(),
+           focused ? "focused" : "defocused");
+}
+
+static void window_iconify_callback(GLFWwindow* window, int iconified)
+{
+    Slot* slot = glfwGetWindowUserPointer(window);
+    printf("%08x to %i at %0.3f: Window was %s\n",
+           counter++, slot->number, glfwGetTime(),
+           iconified ? "iconified" : "uniconified");
+}
+
+static void window_maximize_callback(GLFWwindow* window, int maximized)
+{
+    Slot* slot = glfwGetWindowUserPointer(window);
+    printf("%08x to %i at %0.3f: Window was %s\n",
+           counter++, slot->number, glfwGetTime(),
+           maximized ? "maximized" : "unmaximized");
+}
+
+static void mouse_button_callback(GLFWwindow* window, int button, int action, int mods)
+{
+    Slot* slot = glfwGetWindowUserPointer(window);
+    printf("%08x to %i at %0.3f: Mouse button %i (%s) (with%s) was %s\n",
+           counter++, slot->number, glfwGetTime(), button,
+           get_button_name(button),
+           get_mods_name(mods),
+           get_action_name(action));
+}
+
+static void cursor_position_callback(GLFWwindow* window, double x, double y)
+{
+    Slot* slot = glfwGetWindowUserPointer(window);
+    printf("%08x to %i at %0.3f: Cursor position: %f %f\n",
+           counter++, slot->number, glfwGetTime(), x, y);
+}
+
+static void cursor_enter_callback(GLFWwindow* window, int entered)
+{
+    Slot* slot = glfwGetWindowUserPointer(window);
+    printf("%08x to %i at %0.3f: Cursor %s window\n",
+           counter++, slot->number, glfwGetTime(),
+           entered ? "entered" : "left");
+}
+
+static void scroll_callback(GLFWwindow* window, double x, double y)
+{
+    Slot* slot = glfwGetWindowUserPointer(window);
+    printf("%08x to %i at %0.3f: Scroll: %0.3f %0.3f\n",
+           counter++, slot->number, glfwGetTime(), x, y);
+}
+
+static void key_callback(GLFWwindow* window, int key, int scancode, int action, int mods)
+{
+    Slot* slot = glfwGetWindowUserPointer(window);
+    const char* name = glfwGetKeyName(key, scancode);
+
+    if (name)
+    {
+        printf("%08x to %i at %0.3f: Key 0x%04x Scancode 0x%04x (%s) (%s) (with%s) was %s\n",
+               counter++, slot->number, glfwGetTime(), key, scancode,
+               get_key_name(key),
+               name,
+               get_mods_name(mods),
+               get_action_name(action));
+    }
+    else
+    {
+        printf("%08x to %i at %0.3f: Key 0x%04x Scancode 0x%04x (%s) (with%s) was %s\n",
+               counter++, slot->number, glfwGetTime(), key, scancode,
+               get_key_name(key),
+               get_mods_name(mods),
+               get_action_name(action));
+    }
+
+    if (action != GLFW_PRESS)
+        return;
+
+    switch (key)
+    {
+        case GLFW_KEY_C:
+        {
+            slot->closeable = !slot->closeable;
+
+            printf("(( closing %s ))\n", slot->closeable ? "enabled" : "disabled");
+            break;
+        }
+
+        case GLFW_KEY_L:
+        {
+            const int state = glfwGetInputMode(window, GLFW_LOCK_KEY_MODS);
+            glfwSetInputMode(window, GLFW_LOCK_KEY_MODS, !state);
+
+            printf("(( lock key mods %s ))\n", !state ? "enabled" : "disabled");
+            break;
+        }
+    }
+}
+
+static void char_callback(GLFWwindow* window, unsigned int codepoint)
+{
+    Slot* slot = glfwGetWindowUserPointer(window);
+    char string[5] = "";
+
+    encode_utf8(string, codepoint);
+    printf("%08x to %i at %0.3f: Character 0x%08x (%s) input\n",
+           counter++, slot->number, glfwGetTime(), codepoint, string);
+}
+
+static void drop_callback(GLFWwindow* window, int count, const char* paths[])
+{
+    int i;
+    Slot* slot = glfwGetWindowUserPointer(window);
+
+    printf("%08x to %i at %0.3f: Drop input\n",
+           counter++, slot->number, glfwGetTime());
+
+    for (i = 0;  i < count;  i++)
+        printf("  %i: \"%s\"\n", i, paths[i]);
+}
+
+static void monitor_callback(GLFWmonitor* monitor, int event)
+{
+    if (event == GLFW_CONNECTED)
+    {
+        int x, y, widthMM, heightMM;
+        const GLFWvidmode* mode = glfwGetVideoMode(monitor);
+
+        glfwGetMonitorPos(monitor, &x, &y);
+        glfwGetMonitorPhysicalSize(monitor, &widthMM, &heightMM);
+
+        printf("%08x at %0.3f: Monitor %s (%ix%i at %ix%i, %ix%i mm) was connected\n",
+               counter++,
+               glfwGetTime(),
+               glfwGetMonitorName(monitor),
+               mode->width, mode->height,
+               x, y,
+               widthMM, heightMM);
+    }
+    else if (event == GLFW_DISCONNECTED)
+    {
+        printf("%08x at %0.3f: Monitor %s was disconnected\n",
+               counter++,
+               glfwGetTime(),
+               glfwGetMonitorName(monitor));
+    }
+}
+
+static void joystick_callback(int jid, int event)
+{
+    if (event == GLFW_CONNECTED)
+    {
+        int axisCount, buttonCount, hatCount;
+
+        glfwGetJoystickAxes(jid, &axisCount);
+        glfwGetJoystickButtons(jid, &buttonCount);
+        glfwGetJoystickHats(jid, &hatCount);
+
+        printf("%08x at %0.3f: Joystick %i (%s) was connected with %i axes, %i buttons, and %i hats\n",
+               counter++, glfwGetTime(),
+               jid,
+               glfwGetJoystickName(jid),
+               axisCount,
+               buttonCount,
+               hatCount);
+    }
+    else
+    {
+        printf("%08x at %0.3f: Joystick %i was disconnected\n",
+               counter++, glfwGetTime(), jid);
+    }
+}
+
+int main(int argc, char** argv)
+{
+    Slot* slots;
+    GLFWmonitor* monitor = NULL;
+    int ch, i, width, height, count = 1;
+
+    glfwSetErrorCallback(error_callback);
+
+    if (!glfwInit())
+        exit(EXIT_FAILURE);
+
+    printf("Library initialized\n");
+
+    glfwSetMonitorCallback(monitor_callback);
+    glfwSetJoystickCallback(joystick_callback);
+
+    while ((ch = getopt(argc, argv, "hfn:")) != -1)
+    {
+        switch (ch)
+        {
+            case 'h':
+                usage();
+                exit(EXIT_SUCCESS);
+
+            case 'f':
+                monitor = glfwGetPrimaryMonitor();
+                break;
+
+            case 'n':
+                count = (int) strtoul(optarg, NULL, 10);
+                break;
+
+            default:
+                usage();
+                exit(EXIT_FAILURE);
+        }
+    }
+
+    if (monitor)
+    {
+        const GLFWvidmode* mode = glfwGetVideoMode(monitor);
+
+        glfwWindowHint(GLFW_REFRESH_RATE, mode->refreshRate);
+        glfwWindowHint(GLFW_RED_BITS, mode->redBits);
+        glfwWindowHint(GLFW_GREEN_BITS, mode->greenBits);
+        glfwWindowHint(GLFW_BLUE_BITS, mode->blueBits);
+
+        width = mode->width;
+        height = mode->height;
+    }
+    else
+    {
+        width  = 640;
+        height = 480;
+    }
+
+    slots = calloc(count, sizeof(Slot));
+
+    for (i = 0;  i < count;  i++)
+    {
+        char title[128];
+
+        slots[i].closeable = GLFW_TRUE;
+        slots[i].number = i + 1;
+
+        snprintf(title, sizeof(title), "Event Linter (Window %i)", slots[i].number);
+
+        if (monitor)
+        {
+            printf("Creating full screen window %i (%ix%i on %s)\n",
+                   slots[i].number,
+                   width, height,
+                   glfwGetMonitorName(monitor));
+        }
+        else
+        {
+            printf("Creating windowed mode window %i (%ix%i)\n",
+                   slots[i].number,
+                   width, height);
+        }
+
+        slots[i].window = glfwCreateWindow(width, height, title, monitor, NULL);
+        if (!slots[i].window)
+        {
+            free(slots);
+            glfwTerminate();
+            exit(EXIT_FAILURE);
+        }
+
+        glfwSetWindowUserPointer(slots[i].window, slots + i);
+
+        glfwSetWindowPosCallback(slots[i].window, window_pos_callback);
+        glfwSetWindowSizeCallback(slots[i].window, window_size_callback);
+        glfwSetFramebufferSizeCallback(slots[i].window, framebuffer_size_callback);
+        glfwSetWindowContentScaleCallback(slots[i].window, window_content_scale_callback);
+        glfwSetWindowCloseCallback(slots[i].window, window_close_callback);
+        glfwSetWindowRefreshCallback(slots[i].window, window_refresh_callback);
+        glfwSetWindowFocusCallback(slots[i].window, window_focus_callback);
+        glfwSetWindowIconifyCallback(slots[i].window, window_iconify_callback);
+        glfwSetWindowMaximizeCallback(slots[i].window, window_maximize_callback);
+        glfwSetMouseButtonCallback(slots[i].window, mouse_button_callback);
+        glfwSetCursorPosCallback(slots[i].window, cursor_position_callback);
+        glfwSetCursorEnterCallback(slots[i].window, cursor_enter_callback);
+        glfwSetScrollCallback(slots[i].window, scroll_callback);
+        glfwSetKeyCallback(slots[i].window, key_callback);
+        glfwSetCharCallback(slots[i].window, char_callback);
+        glfwSetDropCallback(slots[i].window, drop_callback);
+
+        glfwMakeContextCurrent(slots[i].window);
+        gladLoadGL(glfwGetProcAddress);
+        glfwSwapInterval(1);
+    }
+
+    printf("Main loop starting\n");
+
+    for (;;)
+    {
+        for (i = 0;  i < count;  i++)
+        {
+            if (glfwWindowShouldClose(slots[i].window))
+                break;
+        }
+
+        if (i < count)
+            break;
+
+        glfwWaitEvents();
+
+        // Workaround for an issue with msvcrt and mintty
+        fflush(stdout);
+    }
+
+    free(slots);
+    glfwTerminate();
+    exit(EXIT_SUCCESS);
+}
+