Update GLFW sources

raylib/external/glfw/deps/glad.c

@@ -1,3 +1,25 @@
+/*
+
+    OpenGL loader generated by glad 0.1.12a0 on Fri Sep 23 13:36:15 2016.
+
+    Language/Generator: C/C++
+    Specification: gl
+    APIs: gl=3.2
+    Profile: compatibility
+    Extensions:
+        GL_ARB_multisample,
+        GL_ARB_robustness,
+        GL_KHR_debug
+    Loader: False
+    Local files: False
+    Omit khrplatform: False
+
+    Commandline:
+        --profile="compatibility" --api="gl=3.2" --generator="c" --spec="gl" --no-loader --extensions="GL_ARB_multisample,GL_ARB_robustness,GL_KHR_debug"
+    Online:
+        http://glad.dav1d.de/#profile=compatibility&language=c&specification=gl&api=gl%3D3.2&extensions=GL_ARB_multisample&extensions=GL_ARB_robustness&extensions=GL_KHR_debug
+*/
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -5,14 +27,59 @@
 
 struct gladGLversionStruct GLVersion;
 
+#if defined(GL_ES_VERSION_3_0) || defined(GL_VERSION_3_0)
+#define _GLAD_IS_SOME_NEW_VERSION 1
+#endif
+
+static int max_loaded_major;
+static int max_loaded_minor;
+
+static const char *exts = NULL;
+static int num_exts_i = 0;
+static const char **exts_i = NULL;
+
+static int get_exts(void) {
+#ifdef _GLAD_IS_SOME_NEW_VERSION
+    if(max_loaded_major < 3) {
+#endif
+        exts = (const char *)glGetString(GL_EXTENSIONS);
+#ifdef _GLAD_IS_SOME_NEW_VERSION
+    } else {
+        int index;
+
+        num_exts_i = 0;
+        glGetIntegerv(GL_NUM_EXTENSIONS, &num_exts_i);
+        if (num_exts_i > 0) {
+            exts_i = (const char **)realloc((void *)exts_i, num_exts_i * sizeof *exts_i);
+        }
+
+        if (exts_i == NULL) {
+            return 0;
+        }
+
+        for(index = 0; index < num_exts_i; index++) {
+            exts_i[index] = (const char*)glGetStringi(GL_EXTENSIONS, index);
+        }
+    }
+#endif
+    return 1;
+}
+
+static void free_exts(void) {
+    if (exts_i != NULL) {
+        free((char **)exts_i);
+        exts_i = NULL;
+    }
+}
+
 static int has_ext(const char *ext) {
-#if defined(GL_VERSION_3_0) || defined(GL_ES_VERSION_3_0)
+#ifdef _GLAD_IS_SOME_NEW_VERSION
-    if(GLVersion.major < 3 || glGetStringi == NULL) {
+    if(max_loaded_major < 3) {
 #endif
         const char *extensions;
         const char *loc;
         const char *terminator;
-        extensions = (const char*) glGetString(GL_EXTENSIONS);
+        extensions = exts;
         if(extensions == NULL || ext == NULL) {
             return 0;
         }
@@ -30,13 +97,14 @@ static int has_ext(const char *ext) {
             }
             extensions = terminator;
         }
-#if defined(GL_VERSION_3_0) || defined(GL_ES_VERSION_3_0)
+#ifdef _GLAD_IS_SOME_NEW_VERSION
     } else {
-        GLint num_exts, index;
+        int index;
 
-        glGetIntegerv(GL_NUM_EXTENSIONS, &num_exts);
+        for(index = 0; index < num_exts_i; index++) {
-        for(index = 0; index < num_exts; index++) {
+            const char *e = exts_i[index];
-            if(strcmp((const char*) glGetStringi(GL_EXTENSIONS, index), ext) == 0) {
+
+            if(strcmp(e, ext) == 0) {
                 return 1;
             }
         }
@@ -316,7 +384,7 @@ PFNGLRASTERPOS3FPROC glad_glRasterPos3f;
 PFNGLCOMPRESSEDTEXIMAGE3DPROC glad_glCompressedTexImage3D;
 PFNGLTEXCOORD3FPROC glad_glTexCoord3f;
 PFNGLDELETESYNCPROC glad_glDeleteSync;
-PFNGLTEXCOORD3DPROC glad_glTexCoord3d;
+PFNGLCOPYTEXSUBIMAGE3DPROC glad_glCopyTexSubImage3D;
 PFNGLTEXIMAGE2DMULTISAMPLEPROC glad_glTexImage2DMultisample;
 PFNGLGETVERTEXATTRIBIVPROC glad_glGetVertexAttribiv;
 PFNGLMULTIDRAWELEMENTSPROC glad_glMultiDrawElements;
@@ -363,7 +431,7 @@ PFNGLVIEWPORTPROC glad_glViewport;
 PFNGLUNIFORM1UIVPROC glad_glUniform1uiv;
 PFNGLTRANSFORMFEEDBACKVARYINGSPROC glad_glTransformFeedbackVaryings;
 PFNGLINDEXDVPROC glad_glIndexdv;
-PFNGLCOPYTEXSUBIMAGE3DPROC glad_glCopyTexSubImage3D;
+PFNGLTEXCOORD3DPROC glad_glTexCoord3d;
 PFNGLTEXCOORD3IVPROC glad_glTexCoord3iv;
 PFNGLVERTEXATTRIBI3IPROC glad_glVertexAttribI3i;
 PFNGLCLEARDEPTHPROC glad_glClearDepth;
@@ -722,9 +790,9 @@ PFNGLCOLORPOINTERPROC glad_glColorPointer;
 PFNGLFRONTFACEPROC glad_glFrontFace;
 PFNGLGETBOOLEANI_VPROC glad_glGetBooleani_v;
 PFNGLCLEARBUFFERUIVPROC glad_glClearBufferuiv;
+int GLAD_GL_KHR_debug;
 int GLAD_GL_ARB_robustness;
 int GLAD_GL_ARB_multisample;
-int GLAD_GL_EXT_separate_specular_color;
 PFNGLSAMPLECOVERAGEARBPROC glad_glSampleCoverageARB;
 PFNGLGETGRAPHICSRESETSTATUSARBPROC glad_glGetGraphicsResetStatusARB;
 PFNGLGETNTEXIMAGEARBPROC glad_glGetnTexImageARB;
@@ -746,6 +814,27 @@ PFNGLGETNCONVOLUTIONFILTERARBPROC glad_glGetnConvolutionFilterARB;
 PFNGLGETNSEPARABLEFILTERARBPROC glad_glGetnSeparableFilterARB;
 PFNGLGETNHISTOGRAMARBPROC glad_glGetnHistogramARB;
 PFNGLGETNMINMAXARBPROC glad_glGetnMinmaxARB;
+PFNGLDEBUGMESSAGECONTROLPROC glad_glDebugMessageControl;
+PFNGLDEBUGMESSAGEINSERTPROC glad_glDebugMessageInsert;
+PFNGLDEBUGMESSAGECALLBACKPROC glad_glDebugMessageCallback;
+PFNGLGETDEBUGMESSAGELOGPROC glad_glGetDebugMessageLog;
+PFNGLPUSHDEBUGGROUPPROC glad_glPushDebugGroup;
+PFNGLPOPDEBUGGROUPPROC glad_glPopDebugGroup;
+PFNGLOBJECTLABELPROC glad_glObjectLabel;
+PFNGLGETOBJECTLABELPROC glad_glGetObjectLabel;
+PFNGLOBJECTPTRLABELPROC glad_glObjectPtrLabel;
+PFNGLGETOBJECTPTRLABELPROC glad_glGetObjectPtrLabel;
+PFNGLDEBUGMESSAGECONTROLKHRPROC glad_glDebugMessageControlKHR;
+PFNGLDEBUGMESSAGEINSERTKHRPROC glad_glDebugMessageInsertKHR;
+PFNGLDEBUGMESSAGECALLBACKKHRPROC glad_glDebugMessageCallbackKHR;
+PFNGLGETDEBUGMESSAGELOGKHRPROC glad_glGetDebugMessageLogKHR;
+PFNGLPUSHDEBUGGROUPKHRPROC glad_glPushDebugGroupKHR;
+PFNGLPOPDEBUGGROUPKHRPROC glad_glPopDebugGroupKHR;
+PFNGLOBJECTLABELKHRPROC glad_glObjectLabelKHR;
+PFNGLGETOBJECTLABELKHRPROC glad_glGetObjectLabelKHR;
+PFNGLOBJECTPTRLABELKHRPROC glad_glObjectPtrLabelKHR;
+PFNGLGETOBJECTPTRLABELKHRPROC glad_glGetObjectPtrLabelKHR;
+PFNGLGETPOINTERVKHRPROC glad_glGetPointervKHR;
 static void load_GL_VERSION_1_0(GLADloadproc load) {
 	if(!GLAD_GL_VERSION_1_0) return;
 	glad_glCullFace = (PFNGLCULLFACEPROC)load("glCullFace");
@@ -1475,10 +1564,38 @@ static void load_GL_ARB_robustness(GLADloadproc load) {
 	glad_glGetnHistogramARB = (PFNGLGETNHISTOGRAMARBPROC)load("glGetnHistogramARB");
 	glad_glGetnMinmaxARB = (PFNGLGETNMINMAXARBPROC)load("glGetnMinmaxARB");
 }
-static void find_extensionsGL(void) {
+static void load_GL_KHR_debug(GLADloadproc load) {
-	GLAD_GL_EXT_separate_specular_color = has_ext("GL_EXT_separate_specular_color");
+	if(!GLAD_GL_KHR_debug) return;
+	glad_glDebugMessageControl = (PFNGLDEBUGMESSAGECONTROLPROC)load("glDebugMessageControl");
+	glad_glDebugMessageInsert = (PFNGLDEBUGMESSAGEINSERTPROC)load("glDebugMessageInsert");
+	glad_glDebugMessageCallback = (PFNGLDEBUGMESSAGECALLBACKPROC)load("glDebugMessageCallback");
+	glad_glGetDebugMessageLog = (PFNGLGETDEBUGMESSAGELOGPROC)load("glGetDebugMessageLog");
+	glad_glPushDebugGroup = (PFNGLPUSHDEBUGGROUPPROC)load("glPushDebugGroup");
+	glad_glPopDebugGroup = (PFNGLPOPDEBUGGROUPPROC)load("glPopDebugGroup");
+	glad_glObjectLabel = (PFNGLOBJECTLABELPROC)load("glObjectLabel");
+	glad_glGetObjectLabel = (PFNGLGETOBJECTLABELPROC)load("glGetObjectLabel");
+	glad_glObjectPtrLabel = (PFNGLOBJECTPTRLABELPROC)load("glObjectPtrLabel");
+	glad_glGetObjectPtrLabel = (PFNGLGETOBJECTPTRLABELPROC)load("glGetObjectPtrLabel");
+	glad_glGetPointerv = (PFNGLGETPOINTERVPROC)load("glGetPointerv");
+	glad_glDebugMessageControlKHR = (PFNGLDEBUGMESSAGECONTROLKHRPROC)load("glDebugMessageControlKHR");
+	glad_glDebugMessageInsertKHR = (PFNGLDEBUGMESSAGEINSERTKHRPROC)load("glDebugMessageInsertKHR");
+	glad_glDebugMessageCallbackKHR = (PFNGLDEBUGMESSAGECALLBACKKHRPROC)load("glDebugMessageCallbackKHR");
+	glad_glGetDebugMessageLogKHR = (PFNGLGETDEBUGMESSAGELOGKHRPROC)load("glGetDebugMessageLogKHR");
+	glad_glPushDebugGroupKHR = (PFNGLPUSHDEBUGGROUPKHRPROC)load("glPushDebugGroupKHR");
+	glad_glPopDebugGroupKHR = (PFNGLPOPDEBUGGROUPKHRPROC)load("glPopDebugGroupKHR");
+	glad_glObjectLabelKHR = (PFNGLOBJECTLABELKHRPROC)load("glObjectLabelKHR");
+	glad_glGetObjectLabelKHR = (PFNGLGETOBJECTLABELKHRPROC)load("glGetObjectLabelKHR");
+	glad_glObjectPtrLabelKHR = (PFNGLOBJECTPTRLABELKHRPROC)load("glObjectPtrLabelKHR");
+	glad_glGetObjectPtrLabelKHR = (PFNGLGETOBJECTPTRLABELKHRPROC)load("glGetObjectPtrLabelKHR");
+	glad_glGetPointervKHR = (PFNGLGETPOINTERVKHRPROC)load("glGetPointervKHR");
+}
+static int find_extensionsGL(void) {
+	if (!get_exts()) return 0;
 	GLAD_GL_ARB_multisample = has_ext("GL_ARB_multisample");
 	GLAD_GL_ARB_robustness = has_ext("GL_ARB_robustness");
+	GLAD_GL_KHR_debug = has_ext("GL_KHR_debug");
+	free_exts();
+	return 1;
 }
 
 static void find_coreGL(void) {
@@ -1516,6 +1633,7 @@ static void find_coreGL(void) {
 #endif
 
     GLVersion.major = major; GLVersion.minor = minor;
+    max_loaded_major = major; max_loaded_minor = minor;
 	GLAD_GL_VERSION_1_0 = (major == 1 && minor >= 0) || major > 1;
 	GLAD_GL_VERSION_1_1 = (major == 1 && minor >= 1) || major > 1;
 	GLAD_GL_VERSION_1_2 = (major == 1 && minor >= 2) || major > 1;
@@ -1527,6 +1645,10 @@ static void find_coreGL(void) {
 	GLAD_GL_VERSION_3_0 = (major == 3 && minor >= 0) || major > 3;
 	GLAD_GL_VERSION_3_1 = (major == 3 && minor >= 1) || major > 3;
 	GLAD_GL_VERSION_3_2 = (major == 3 && minor >= 2) || major > 3;
+	if (GLVersion.major > 3 || (GLVersion.major >= 3 && GLVersion.minor >= 2)) {
+		max_loaded_major = 3;
+		max_loaded_minor = 2;
+	}
 }
 
 int gladLoadGLLoader(GLADloadproc load) {
@@ -1547,9 +1669,10 @@ int gladLoadGLLoader(GLADloadproc load) {
 	load_GL_VERSION_3_1(load);
 	load_GL_VERSION_3_2(load);
 
-	find_extensionsGL();
+	if (!find_extensionsGL()) return 0;
 	load_GL_ARB_multisample(load);
 	load_GL_ARB_robustness(load);
+	load_GL_KHR_debug(load);
 	return GLVersion.major != 0 || GLVersion.minor != 0;
 }
 

raylib/external/glfw/deps/linmath.h

@@ -192,7 +192,7 @@ static inline void mat4x4_rotate(mat4x4 R, mat4x4 M, float x, float y, float z,
 	vec3 u = {x, y, z};
 
 	if(vec3_len(u) > 1e-4) {
-		mat4x4 T, C, S;
+		mat4x4 T, C, S = {{0}};
 
 		vec3_norm(u, u);
 		mat4x4_from_vec3_mul_outer(T, u, u);

raylib/external/glfw/deps/nuklear_glfw_gl2.h

@@ -0,0 +1,372 @@
+/*
+ * Nuklear - v1.32.0 - public domain
+ * no warrenty implied; use at your own risk.
+ * authored from 2015-2017 by Micha Mettke
+ */
+/*
+ * ==============================================================
+ *
+ *                              API
+ *
+ * ===============================================================
+ */
+#ifndef NK_GLFW_GL2_H_
+#define NK_GLFW_GL2_H_
+
+#include <GLFW/glfw3.h>
+
+enum nk_glfw_init_state{
+    NK_GLFW3_DEFAULT = 0,
+    NK_GLFW3_INSTALL_CALLBACKS
+};
+NK_API struct nk_context*   nk_glfw3_init(GLFWwindow *win, enum nk_glfw_init_state);
+NK_API void                 nk_glfw3_font_stash_begin(struct nk_font_atlas **atlas);
+NK_API void                 nk_glfw3_font_stash_end(void);
+
+NK_API void                 nk_glfw3_new_frame(void);
+NK_API void                 nk_glfw3_render(enum nk_anti_aliasing);
+NK_API void                 nk_glfw3_shutdown(void);
+
+NK_API void                 nk_glfw3_char_callback(GLFWwindow *win, unsigned int codepoint);
+NK_API void                 nk_gflw3_scroll_callback(GLFWwindow *win, double xoff, double yoff);
+
+#endif
+
+/*
+ * ==============================================================
+ *
+ *                          IMPLEMENTATION
+ *
+ * ===============================================================
+ */
+#ifdef NK_GLFW_GL2_IMPLEMENTATION
+
+#ifndef NK_GLFW_TEXT_MAX
+#define NK_GLFW_TEXT_MAX 256
+#endif
+#ifndef NK_GLFW_DOUBLE_CLICK_LO
+#define NK_GLFW_DOUBLE_CLICK_LO 0.02
+#endif
+#ifndef NK_GLFW_DOUBLE_CLICK_HI
+#define NK_GLFW_DOUBLE_CLICK_HI 0.2
+#endif
+
+struct nk_glfw_device {
+    struct nk_buffer cmds;
+    struct nk_draw_null_texture null;
+    GLuint font_tex;
+};
+
+struct nk_glfw_vertex {
+    float position[2];
+    float uv[2];
+    nk_byte col[4];
+};
+
+static struct nk_glfw {
+    GLFWwindow *win;
+    int width, height;
+    int display_width, display_height;
+    struct nk_glfw_device ogl;
+    struct nk_context ctx;
+    struct nk_font_atlas atlas;
+    struct nk_vec2 fb_scale;
+    unsigned int text[NK_GLFW_TEXT_MAX];
+    int text_len;
+    struct nk_vec2 scroll;
+    double last_button_click;
+} glfw;
+
+NK_INTERN void
+nk_glfw3_device_upload_atlas(const void *image, int width, int height)
+{
+    struct nk_glfw_device *dev = &glfw.ogl;
+    glGenTextures(1, &dev->font_tex);
+    glBindTexture(GL_TEXTURE_2D, dev->font_tex);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, (GLsizei)width, (GLsizei)height, 0,
+                GL_RGBA, GL_UNSIGNED_BYTE, image);
+}
+
+NK_API void
+nk_glfw3_render(enum nk_anti_aliasing AA)
+{
+    /* setup global state */
+    struct nk_glfw_device *dev = &glfw.ogl;
+    glPushAttrib(GL_ENABLE_BIT|GL_COLOR_BUFFER_BIT|GL_TRANSFORM_BIT);
+    glDisable(GL_CULL_FACE);
+    glDisable(GL_DEPTH_TEST);
+    glEnable(GL_SCISSOR_TEST);
+    glEnable(GL_BLEND);
+    glEnable(GL_TEXTURE_2D);
+    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+    /* setup viewport/project */
+    glViewport(0,0,(GLsizei)glfw.display_width,(GLsizei)glfw.display_height);
+    glMatrixMode(GL_PROJECTION);
+    glPushMatrix();
+    glLoadIdentity();
+    glOrtho(0.0f, glfw.width, glfw.height, 0.0f, -1.0f, 1.0f);
+    glMatrixMode(GL_MODELVIEW);
+    glPushMatrix();
+    glLoadIdentity();
+
+    glEnableClientState(GL_VERTEX_ARRAY);
+    glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+    glEnableClientState(GL_COLOR_ARRAY);
+    {
+        GLsizei vs = sizeof(struct nk_glfw_vertex);
+        size_t vp = offsetof(struct nk_glfw_vertex, position);
+        size_t vt = offsetof(struct nk_glfw_vertex, uv);
+        size_t vc = offsetof(struct nk_glfw_vertex, col);
+
+        /* convert from command queue into draw list and draw to screen */
+        const struct nk_draw_command *cmd;
+        const nk_draw_index *offset = NULL;
+        struct nk_buffer vbuf, ebuf;
+
+        /* fill convert configuration */
+        struct nk_convert_config config;
+        static const struct nk_draw_vertex_layout_element vertex_layout[] = {
+            {NK_VERTEX_POSITION, NK_FORMAT_FLOAT, NK_OFFSETOF(struct nk_glfw_vertex, position)},
+            {NK_VERTEX_TEXCOORD, NK_FORMAT_FLOAT, NK_OFFSETOF(struct nk_glfw_vertex, uv)},
+            {NK_VERTEX_COLOR, NK_FORMAT_R8G8B8A8, NK_OFFSETOF(struct nk_glfw_vertex, col)},
+            {NK_VERTEX_LAYOUT_END}
+        };
+        NK_MEMSET(&config, 0, sizeof(config));
+        config.vertex_layout = vertex_layout;
+        config.vertex_size = sizeof(struct nk_glfw_vertex);
+        config.vertex_alignment = NK_ALIGNOF(struct nk_glfw_vertex);
+        config.null = dev->null;
+        config.circle_segment_count = 22;
+        config.curve_segment_count = 22;
+        config.arc_segment_count = 22;
+        config.global_alpha = 1.0f;
+        config.shape_AA = AA;
+        config.line_AA = AA;
+
+        /* convert shapes into vertexes */
+        nk_buffer_init_default(&vbuf);
+        nk_buffer_init_default(&ebuf);
+        nk_convert(&glfw.ctx, &dev->cmds, &vbuf, &ebuf, &config);
+
+        /* setup vertex buffer pointer */
+        {const void *vertices = nk_buffer_memory_const(&vbuf);
+        glVertexPointer(2, GL_FLOAT, vs, (const void*)((const nk_byte*)vertices + vp));
+        glTexCoordPointer(2, GL_FLOAT, vs, (const void*)((const nk_byte*)vertices + vt));
+        glColorPointer(4, GL_UNSIGNED_BYTE, vs, (const void*)((const nk_byte*)vertices + vc));}
+
+        /* iterate over and execute each draw command */
+        offset = (const nk_draw_index*)nk_buffer_memory_const(&ebuf);
+        nk_draw_foreach(cmd, &glfw.ctx, &dev->cmds)
+        {
+            if (!cmd->elem_count) continue;
+            glBindTexture(GL_TEXTURE_2D, (GLuint)cmd->texture.id);
+            glScissor(
+                (GLint)(cmd->clip_rect.x * glfw.fb_scale.x),
+                (GLint)((glfw.height - (GLint)(cmd->clip_rect.y + cmd->clip_rect.h)) * glfw.fb_scale.y),
+                (GLint)(cmd->clip_rect.w * glfw.fb_scale.x),
+                (GLint)(cmd->clip_rect.h * glfw.fb_scale.y));
+            glDrawElements(GL_TRIANGLES, (GLsizei)cmd->elem_count, GL_UNSIGNED_SHORT, offset);
+            offset += cmd->elem_count;
+        }
+        nk_clear(&glfw.ctx);
+        nk_buffer_free(&vbuf);
+        nk_buffer_free(&ebuf);
+    }
+
+    /* default OpenGL state */
+    glDisableClientState(GL_VERTEX_ARRAY);
+    glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+    glDisableClientState(GL_COLOR_ARRAY);
+
+    glDisable(GL_CULL_FACE);
+    glDisable(GL_DEPTH_TEST);
+    glDisable(GL_SCISSOR_TEST);
+    glDisable(GL_BLEND);
+    glDisable(GL_TEXTURE_2D);
+
+    glBindTexture(GL_TEXTURE_2D, 0);
+    glMatrixMode(GL_MODELVIEW);
+    glPopMatrix();
+    glMatrixMode(GL_PROJECTION);
+    glPopMatrix();
+    glPopAttrib();
+}
+
+NK_API void
+nk_glfw3_char_callback(GLFWwindow *win, unsigned int codepoint)
+{
+    (void)win;
+    if (glfw.text_len < NK_GLFW_TEXT_MAX)
+        glfw.text[glfw.text_len++] = codepoint;
+}
+
+NK_API void
+nk_gflw3_scroll_callback(GLFWwindow *win, double xoff, double yoff)
+{
+    (void)win; (void)xoff;
+    glfw.scroll.x += (float)xoff;
+    glfw.scroll.y += (float)yoff;
+}
+
+NK_API void
+nk_glfw3_mouse_button_callback(GLFWwindow* window, int button, int action, int mods)
+{
+    double x, y;
+    if (button != GLFW_MOUSE_BUTTON_LEFT) return;
+    glfwGetCursorPos(window, &x, &y);
+    if (action == GLFW_PRESS)  {
+        double dt = glfwGetTime() - glfw.last_button_click;
+        if (dt > NK_GLFW_DOUBLE_CLICK_LO && dt < NK_GLFW_DOUBLE_CLICK_HI)
+            nk_input_button(&glfw.ctx, NK_BUTTON_DOUBLE, (int)x, (int)y, nk_true);
+        glfw.last_button_click = glfwGetTime();
+    } else nk_input_button(&glfw.ctx, NK_BUTTON_DOUBLE, (int)x, (int)y, nk_false);
+}
+
+NK_INTERN void
+nk_glfw3_clipbard_paste(nk_handle usr, struct nk_text_edit *edit)
+{
+    const char *text = glfwGetClipboardString(glfw.win);
+    if (text) nk_textedit_paste(edit, text, nk_strlen(text));
+    (void)usr;
+}
+
+NK_INTERN void
+nk_glfw3_clipbard_copy(nk_handle usr, const char *text, int len)
+{
+    char *str = 0;
+    (void)usr;
+    if (!len) return;
+    str = (char*)malloc((size_t)len+1);
+    if (!str) return;
+    NK_MEMCPY(str, text, (size_t)len);
+    str[len] = '\0';
+    glfwSetClipboardString(glfw.win, str);
+    free(str);
+}
+
+NK_API struct nk_context*
+nk_glfw3_init(GLFWwindow *win, enum nk_glfw_init_state init_state)
+{
+    glfw.win = win;
+    if (init_state == NK_GLFW3_INSTALL_CALLBACKS) {
+        glfwSetScrollCallback(win, nk_gflw3_scroll_callback);
+        glfwSetCharCallback(win, nk_glfw3_char_callback);
+        glfwSetMouseButtonCallback(win, nk_glfw3_mouse_button_callback);
+    }
+    nk_init_default(&glfw.ctx, 0);
+    glfw.ctx.clip.copy = nk_glfw3_clipbard_copy;
+    glfw.ctx.clip.paste = nk_glfw3_clipbard_paste;
+    glfw.ctx.clip.userdata = nk_handle_ptr(0);
+    nk_buffer_init_default(&glfw.ogl.cmds);
+    return &glfw.ctx;
+}
+
+NK_API void
+nk_glfw3_font_stash_begin(struct nk_font_atlas **atlas)
+{
+    nk_font_atlas_init_default(&glfw.atlas);
+    nk_font_atlas_begin(&glfw.atlas);
+    *atlas = &glfw.atlas;
+}
+
+NK_API void
+nk_glfw3_font_stash_end(void)
+{
+    const void *image; int w, h;
+    image = nk_font_atlas_bake(&glfw.atlas, &w, &h, NK_FONT_ATLAS_RGBA32);
+    nk_glfw3_device_upload_atlas(image, w, h);
+    nk_font_atlas_end(&glfw.atlas, nk_handle_id((int)glfw.ogl.font_tex), &glfw.ogl.null);
+    if (glfw.atlas.default_font)
+        nk_style_set_font(&glfw.ctx, &glfw.atlas.default_font->handle);
+}
+
+NK_API void
+nk_glfw3_new_frame(void)
+{
+    int i;
+    double x, y;
+    struct nk_context *ctx = &glfw.ctx;
+    struct GLFWwindow *win = glfw.win;
+
+    glfwGetWindowSize(win, &glfw.width, &glfw.height);
+    glfwGetFramebufferSize(win, &glfw.display_width, &glfw.display_height);
+    glfw.fb_scale.x = (float)glfw.display_width/(float)glfw.width;
+    glfw.fb_scale.y = (float)glfw.display_height/(float)glfw.height;
+
+    nk_input_begin(ctx);
+    for (i = 0; i < glfw.text_len; ++i)
+        nk_input_unicode(ctx, glfw.text[i]);
+
+    /* optional grabbing behavior */
+    if (ctx->input.mouse.grab)
+        glfwSetInputMode(glfw.win, GLFW_CURSOR, GLFW_CURSOR_HIDDEN);
+    else if (ctx->input.mouse.ungrab)
+        glfwSetInputMode(glfw.win, GLFW_CURSOR, GLFW_CURSOR_NORMAL);
+
+    nk_input_key(ctx, NK_KEY_DEL, glfwGetKey(win, GLFW_KEY_DELETE) == GLFW_PRESS);
+    nk_input_key(ctx, NK_KEY_ENTER, glfwGetKey(win, GLFW_KEY_ENTER) == GLFW_PRESS);
+    nk_input_key(ctx, NK_KEY_TAB, glfwGetKey(win, GLFW_KEY_TAB) == GLFW_PRESS);
+    nk_input_key(ctx, NK_KEY_BACKSPACE, glfwGetKey(win, GLFW_KEY_BACKSPACE) == GLFW_PRESS);
+    nk_input_key(ctx, NK_KEY_UP, glfwGetKey(win, GLFW_KEY_UP) == GLFW_PRESS);
+    nk_input_key(ctx, NK_KEY_DOWN, glfwGetKey(win, GLFW_KEY_DOWN) == GLFW_PRESS);
+    nk_input_key(ctx, NK_KEY_TEXT_START, glfwGetKey(win, GLFW_KEY_HOME) == GLFW_PRESS);
+    nk_input_key(ctx, NK_KEY_TEXT_END, glfwGetKey(win, GLFW_KEY_END) == GLFW_PRESS);
+    nk_input_key(ctx, NK_KEY_SCROLL_START, glfwGetKey(win, GLFW_KEY_HOME) == GLFW_PRESS);
+    nk_input_key(ctx, NK_KEY_SCROLL_END, glfwGetKey(win, GLFW_KEY_END) == GLFW_PRESS);
+    nk_input_key(ctx, NK_KEY_SCROLL_DOWN, glfwGetKey(win, GLFW_KEY_PAGE_DOWN) == GLFW_PRESS);
+    nk_input_key(ctx, NK_KEY_SCROLL_UP, glfwGetKey(win, GLFW_KEY_PAGE_UP) == GLFW_PRESS);
+    nk_input_key(ctx, NK_KEY_SHIFT, glfwGetKey(win, GLFW_KEY_LEFT_SHIFT) == GLFW_PRESS||
+                                    glfwGetKey(win, GLFW_KEY_RIGHT_SHIFT) == GLFW_PRESS);
+
+    if (glfwGetKey(win, GLFW_KEY_LEFT_CONTROL) == GLFW_PRESS ||
+        glfwGetKey(win, GLFW_KEY_RIGHT_CONTROL) == GLFW_PRESS) {
+        nk_input_key(ctx, NK_KEY_COPY, glfwGetKey(win, GLFW_KEY_C) == GLFW_PRESS);
+        nk_input_key(ctx, NK_KEY_PASTE, glfwGetKey(win, GLFW_KEY_V) == GLFW_PRESS);
+        nk_input_key(ctx, NK_KEY_CUT, glfwGetKey(win, GLFW_KEY_X) == GLFW_PRESS);
+        nk_input_key(ctx, NK_KEY_TEXT_UNDO, glfwGetKey(win, GLFW_KEY_Z) == GLFW_PRESS);
+        nk_input_key(ctx, NK_KEY_TEXT_REDO, glfwGetKey(win, GLFW_KEY_R) == GLFW_PRESS);
+        nk_input_key(ctx, NK_KEY_TEXT_WORD_LEFT, glfwGetKey(win, GLFW_KEY_LEFT) == GLFW_PRESS);
+        nk_input_key(ctx, NK_KEY_TEXT_WORD_RIGHT, glfwGetKey(win, GLFW_KEY_RIGHT) == GLFW_PRESS);
+        nk_input_key(ctx, NK_KEY_TEXT_LINE_START, glfwGetKey(win, GLFW_KEY_B) == GLFW_PRESS);
+        nk_input_key(ctx, NK_KEY_TEXT_LINE_END, glfwGetKey(win, GLFW_KEY_E) == GLFW_PRESS);
+    } else {
+        nk_input_key(ctx, NK_KEY_LEFT, glfwGetKey(win, GLFW_KEY_LEFT) == GLFW_PRESS);
+        nk_input_key(ctx, NK_KEY_RIGHT, glfwGetKey(win, GLFW_KEY_RIGHT) == GLFW_PRESS);
+        nk_input_key(ctx, NK_KEY_COPY, 0);
+        nk_input_key(ctx, NK_KEY_PASTE, 0);
+        nk_input_key(ctx, NK_KEY_CUT, 0);
+        nk_input_key(ctx, NK_KEY_SHIFT, 0);
+    }
+
+    glfwGetCursorPos(win, &x, &y);
+    nk_input_motion(ctx, (int)x, (int)y);
+    if (ctx->input.mouse.grabbed) {
+        glfwSetCursorPos(glfw.win, ctx->input.mouse.prev.x, ctx->input.mouse.prev.y);
+        ctx->input.mouse.pos.x = ctx->input.mouse.prev.x;
+        ctx->input.mouse.pos.y = ctx->input.mouse.prev.y;
+    }
+
+    nk_input_button(ctx, NK_BUTTON_LEFT, (int)x, (int)y, glfwGetMouseButton(win, GLFW_MOUSE_BUTTON_LEFT) == GLFW_PRESS);
+    nk_input_button(ctx, NK_BUTTON_MIDDLE, (int)x, (int)y, glfwGetMouseButton(win, GLFW_MOUSE_BUTTON_MIDDLE) == GLFW_PRESS);
+    nk_input_button(ctx, NK_BUTTON_RIGHT, (int)x, (int)y, glfwGetMouseButton(win, GLFW_MOUSE_BUTTON_RIGHT) == GLFW_PRESS);
+    nk_input_scroll(ctx, glfw.scroll);
+    nk_input_end(&glfw.ctx);
+    glfw.text_len = 0;
+    glfw.scroll = nk_vec2(0,0);
+}
+
+NK_API
+void nk_glfw3_shutdown(void)
+{
+    struct nk_glfw_device *dev = &glfw.ogl;
+    nk_font_atlas_clear(&glfw.atlas);
+    nk_free(&glfw.ctx);
+    glDeleteTextures(1, &dev->font_tex);
+    nk_buffer_free(&dev->cmds);
+    NK_MEMSET(&glfw, 0, sizeof(glfw));
+}
+
+#endif

raylib/external/glfw/deps/tinycthread.c

@@ -21,7 +21,7 @@ freely, subject to the following restrictions:
     distribution.
 */
 
-/* 2013-01-06 Camilla Berglund <elmindreda@glfw.org>
+/* 2013-01-06 Camilla Löwy <elmindreda@glfw.org>
  *
  * Added casts from time_t to DWORD to avoid warnings on VC++.
  * Fixed time retrieval on POSIX systems.

raylib/external/glfw/deps/tinycthread.h

@@ -123,7 +123,9 @@ typedef int _tthread_clockid_t;
 /* Emulate clock_gettime */
 int _tthread_clock_gettime(clockid_t clk_id, struct timespec *ts);
 #define clock_gettime _tthread_clock_gettime
-#define CLOCK_REALTIME 0
+#ifndef CLOCK_REALTIME
+  #define CLOCK_REALTIME 0
+#endif
 #endif
 
 

raylib/external/glfw/deps/vs2008/stdint.h

@@ -0,0 +1,247 @@
+// ISO C9x  compliant stdint.h for Microsoft Visual Studio
+// Based on ISO/IEC 9899:TC2 Committee draft (May 6, 2005) WG14/N1124 
+// 
+//  Copyright (c) 2006-2008 Alexander Chemeris
+// 
+// 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 above copyright notice,
+//      this list of conditions and the following disclaimer.
+// 
+//   2. Redistributions in binary form must reproduce the above 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 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.
+// 
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef _MSC_VER // [
+#error "Use this header only with Microsoft Visual C++ compilers!"
+#endif // _MSC_VER ]
+
+#ifndef _MSC_STDINT_H_ // [
+#define _MSC_STDINT_H_
+
+#if _MSC_VER > 1000
+#pragma once
+#endif
+
+#include <limits.h>
+
+// For Visual Studio 6 in C++ mode and for many Visual Studio versions when
+// compiling for ARM we should wrap <wchar.h> include with 'extern "C++" {}'
+// or compiler give many errors like this:
+//   error C2733: second C linkage of overloaded function 'wmemchr' not allowed
+#ifdef __cplusplus
+extern "C" {
+#endif
+#  include <wchar.h>
+#ifdef __cplusplus
+}
+#endif
+
+// Define _W64 macros to mark types changing their size, like intptr_t.
+#ifndef _W64
+#  if !defined(__midl) && (defined(_X86_) || defined(_M_IX86)) && _MSC_VER >= 1300
+#     define _W64 __w64
+#  else
+#     define _W64
+#  endif
+#endif
+
+
+// 7.18.1 Integer types
+
+// 7.18.1.1 Exact-width integer types
+
+// Visual Studio 6 and Embedded Visual C++ 4 doesn't
+// realize that, e.g. char has the same size as __int8
+// so we give up on __intX for them.
+#if (_MSC_VER < 1300)
+   typedef signed char       int8_t;
+   typedef signed short      int16_t;
+   typedef signed int        int32_t;
+   typedef unsigned char     uint8_t;
+   typedef unsigned short    uint16_t;
+   typedef unsigned int      uint32_t;
+#else
+   typedef signed __int8     int8_t;
+   typedef signed __int16    int16_t;
+   typedef signed __int32    int32_t;
+   typedef unsigned __int8   uint8_t;
+   typedef unsigned __int16  uint16_t;
+   typedef unsigned __int32  uint32_t;
+#endif
+typedef signed __int64       int64_t;
+typedef unsigned __int64     uint64_t;
+
+
+// 7.18.1.2 Minimum-width integer types
+typedef int8_t    int_least8_t;
+typedef int16_t   int_least16_t;
+typedef int32_t   int_least32_t;
+typedef int64_t   int_least64_t;
+typedef uint8_t   uint_least8_t;
+typedef uint16_t  uint_least16_t;
+typedef uint32_t  uint_least32_t;
+typedef uint64_t  uint_least64_t;
+
+// 7.18.1.3 Fastest minimum-width integer types
+typedef int8_t    int_fast8_t;
+typedef int16_t   int_fast16_t;
+typedef int32_t   int_fast32_t;
+typedef int64_t   int_fast64_t;
+typedef uint8_t   uint_fast8_t;
+typedef uint16_t  uint_fast16_t;
+typedef uint32_t  uint_fast32_t;
+typedef uint64_t  uint_fast64_t;
+
+// 7.18.1.4 Integer types capable of holding object pointers
+#ifdef _WIN64 // [
+   typedef signed __int64    intptr_t;
+   typedef unsigned __int64  uintptr_t;
+#else // _WIN64 ][
+   typedef _W64 signed int   intptr_t;
+   typedef _W64 unsigned int uintptr_t;
+#endif // _WIN64 ]
+
+// 7.18.1.5 Greatest-width integer types
+typedef int64_t   intmax_t;
+typedef uint64_t  uintmax_t;
+
+
+// 7.18.2 Limits of specified-width integer types
+
+#if !defined(__cplusplus) || defined(__STDC_LIMIT_MACROS) // [   See footnote 220 at page 257 and footnote 221 at page 259
+
+// 7.18.2.1 Limits of exact-width integer types
+#define INT8_MIN     ((int8_t)_I8_MIN)
+#define INT8_MAX     _I8_MAX
+#define INT16_MIN    ((int16_t)_I16_MIN)
+#define INT16_MAX    _I16_MAX
+#define INT32_MIN    ((int32_t)_I32_MIN)
+#define INT32_MAX    _I32_MAX
+#define INT64_MIN    ((int64_t)_I64_MIN)
+#define INT64_MAX    _I64_MAX
+#define UINT8_MAX    _UI8_MAX
+#define UINT16_MAX   _UI16_MAX
+#define UINT32_MAX   _UI32_MAX
+#define UINT64_MAX   _UI64_MAX
+
+// 7.18.2.2 Limits of minimum-width integer types
+#define INT_LEAST8_MIN    INT8_MIN
+#define INT_LEAST8_MAX    INT8_MAX
+#define INT_LEAST16_MIN   INT16_MIN
+#define INT_LEAST16_MAX   INT16_MAX
+#define INT_LEAST32_MIN   INT32_MIN
+#define INT_LEAST32_MAX   INT32_MAX
+#define INT_LEAST64_MIN   INT64_MIN
+#define INT_LEAST64_MAX   INT64_MAX
+#define UINT_LEAST8_MAX   UINT8_MAX
+#define UINT_LEAST16_MAX  UINT16_MAX
+#define UINT_LEAST32_MAX  UINT32_MAX
+#define UINT_LEAST64_MAX  UINT64_MAX
+
+// 7.18.2.3 Limits of fastest minimum-width integer types
+#define INT_FAST8_MIN    INT8_MIN
+#define INT_FAST8_MAX    INT8_MAX
+#define INT_FAST16_MIN   INT16_MIN
+#define INT_FAST16_MAX   INT16_MAX
+#define INT_FAST32_MIN   INT32_MIN
+#define INT_FAST32_MAX   INT32_MAX
+#define INT_FAST64_MIN   INT64_MIN
+#define INT_FAST64_MAX   INT64_MAX
+#define UINT_FAST8_MAX   UINT8_MAX
+#define UINT_FAST16_MAX  UINT16_MAX
+#define UINT_FAST32_MAX  UINT32_MAX
+#define UINT_FAST64_MAX  UINT64_MAX
+
+// 7.18.2.4 Limits of integer types capable of holding object pointers
+#ifdef _WIN64 // [
+#  define INTPTR_MIN   INT64_MIN
+#  define INTPTR_MAX   INT64_MAX
+#  define UINTPTR_MAX  UINT64_MAX
+#else // _WIN64 ][
+#  define INTPTR_MIN   INT32_MIN
+#  define INTPTR_MAX   INT32_MAX
+#  define UINTPTR_MAX  UINT32_MAX
+#endif // _WIN64 ]
+
+// 7.18.2.5 Limits of greatest-width integer types
+#define INTMAX_MIN   INT64_MIN
+#define INTMAX_MAX   INT64_MAX
+#define UINTMAX_MAX  UINT64_MAX
+
+// 7.18.3 Limits of other integer types
+
+#ifdef _WIN64 // [
+#  define PTRDIFF_MIN  _I64_MIN
+#  define PTRDIFF_MAX  _I64_MAX
+#else  // _WIN64 ][
+#  define PTRDIFF_MIN  _I32_MIN
+#  define PTRDIFF_MAX  _I32_MAX
+#endif  // _WIN64 ]
+
+#define SIG_ATOMIC_MIN  INT_MIN
+#define SIG_ATOMIC_MAX  INT_MAX
+
+#ifndef SIZE_MAX // [
+#  ifdef _WIN64 // [
+#     define SIZE_MAX  _UI64_MAX
+#  else // _WIN64 ][
+#     define SIZE_MAX  _UI32_MAX
+#  endif // _WIN64 ]
+#endif // SIZE_MAX ]
+
+// WCHAR_MIN and WCHAR_MAX are also defined in <wchar.h>
+#ifndef WCHAR_MIN // [
+#  define WCHAR_MIN  0
+#endif  // WCHAR_MIN ]
+#ifndef WCHAR_MAX // [
+#  define WCHAR_MAX  _UI16_MAX
+#endif  // WCHAR_MAX ]
+
+#define WINT_MIN  0
+#define WINT_MAX  _UI16_MAX
+
+#endif // __STDC_LIMIT_MACROS ]
+
+
+// 7.18.4 Limits of other integer types
+
+#if !defined(__cplusplus) || defined(__STDC_CONSTANT_MACROS) // [   See footnote 224 at page 260
+
+// 7.18.4.1 Macros for minimum-width integer constants
+
+#define INT8_C(val)  val##i8
+#define INT16_C(val) val##i16
+#define INT32_C(val) val##i32
+#define INT64_C(val) val##i64
+
+#define UINT8_C(val)  val##ui8
+#define UINT16_C(val) val##ui16
+#define UINT32_C(val) val##ui32
+#define UINT64_C(val) val##ui64
+
+// 7.18.4.2 Macros for greatest-width integer constants
+#define INTMAX_C   INT64_C
+#define UINTMAX_C  UINT64_C
+
+#endif // __STDC_CONSTANT_MACROS ]
+
+
+#endif // _MSC_STDINT_H_ ]

raylib/external/glfw/deps/vulkan/vk_platform.h

@@ -51,13 +51,13 @@ extern "C"
     #define VKAPI_ATTR
     #define VKAPI_CALL __stdcall
     #define VKAPI_PTR  VKAPI_CALL
-#elif defined(__ANDROID__) && defined(__ARM_EABI__) && !defined(__ARM_ARCH_7A__)
+#elif defined(__ANDROID__) && defined(__ARM_ARCH) && __ARM_ARCH < 7
-    // Android does not support Vulkan in native code using the "armeabi" ABI.
+    #error "Vulkan isn't supported for the 'armeabi' NDK ABI"
-    #error "Vulkan requires the 'armeabi-v7a' or 'armeabi-v7a-hard' ABI on 32-bit ARM CPUs"
+#elif defined(__ANDROID__) && defined(__ARM_ARCH) && __ARM_ARCH >= 7 && defined(__ARM_32BIT_STATE)
-#elif defined(__ANDROID__) && defined(__ARM_ARCH_7A__)
+    // On Android 32-bit ARM targets, Vulkan functions use the "hardfloat"
-    // On Android/ARMv7a, Vulkan functions use the armeabi-v7a-hard calling
+    // calling convention, i.e. float parameters are passed in registers. This
-    // convention, even if the application's native code is compiled with the
+    // is true even if the rest of the application passes floats on the stack,
-    // armeabi-v7a calling convention.
+    // as it does by default when compiling for the armeabi-v7a NDK ABI.
     #define VKAPI_ATTR __attribute__((pcs("aapcs-vfp")))
     #define VKAPI_CALL
     #define VKAPI_PTR  VKAPI_ATTR

raylib/external/glfw/include/GLFW/glfw3native.h

@@ -1,9 +1,9 @@
 /*************************************************************************
- * GLFW 3.2 - www.glfw.org
+ * GLFW 3.3 - www.glfw.org
  * A library for OpenGL, window and input
  *------------------------------------------------------------------------
  * Copyright (c) 2002-2006 Marcus Geelnard
- * Copyright (c) 2006-2016 Camilla Berglund <elmindreda@glfw.org>
+ * Copyright (c) 2006-2016 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
@@ -45,12 +45,13 @@ extern "C" {
  *  more information.
  */
 /*! @defgroup native Native access
+ *  @brief Functions related to accessing native handles.
  *
  *  **By using the native access functions you assert that you know what you're
  *  doing and how to fix problems caused by using them.  If you don't, you
  *  shouldn't be using them.**
  *
- *  Before the inclusion of @ref glfw3native.h, you may define exactly one
+ *  Before the inclusion of @ref glfw3native.h, you may define zero or more
  *  window system API macro and zero or more context creation API macros.
  *
  *  The chosen backends must match those the library was compiled for.  Failure
@@ -68,6 +69,7 @@ extern "C" {
  *  * `GLFW_EXPOSE_NATIVE_NSGL`
  *  * `GLFW_EXPOSE_NATIVE_GLX`
  *  * `GLFW_EXPOSE_NATIVE_EGL`
+ *  * `GLFW_EXPOSE_NATIVE_OSMESA`
  *
  *  These macros select which of the native access functions that are declared
  *  and which platform-specific headers to include.  It is then up your (by
@@ -84,7 +86,10 @@ extern "C" {
  // This is a workaround for the fact that glfw3.h needs to export APIENTRY (for
  // example to allow applications to correctly declare a GL_ARB_debug_output
  // callback) but windows.h assumes no one will define APIENTRY before it does
- #undef APIENTRY
+ #if defined(GLFW_APIENTRY_DEFINED)
+  #undef APIENTRY
+  #undef GLFW_APIENTRY_DEFINED
+ #endif
  #include <windows.h>
 #elif defined(GLFW_EXPOSE_NATIVE_COCOA)
  #include <ApplicationServices/ApplicationServices.h>
@@ -114,6 +119,9 @@ extern "C" {
 #if defined(GLFW_EXPOSE_NATIVE_EGL)
  #include <EGL/egl.h>
 #endif
+#if defined(GLFW_EXPOSE_NATIVE_OSMESA)
+ #include <GL/osmesa.h>
+#endif
 
 
 /*************************************************************************
@@ -284,6 +292,56 @@ GLFWAPI RROutput glfwGetX11Monitor(GLFWmonitor* monitor);
  *  @ingroup native
  */
 GLFWAPI Window glfwGetX11Window(GLFWwindow* window);
+
+/*! @brief Sets the current primary selection to the specified string.
+ *
+ *  @param[in] string A UTF-8 encoded string.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_PLATFORM_ERROR.
+ *
+ *  @pointer_lifetime The specified string is copied before this function
+ *  returns.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref clipboard
+ *  @sa glfwGetX11SelectionString
+ *  @sa glfwSetClipboardString
+ *
+ *  @since Added in version 3.3.
+ *
+ *  @ingroup native
+ */
+GLFWAPI void glfwSetX11SelectionString(const char* string);
+
+/*! @brief Returns the contents of the current primary selection as a string.
+ *
+ *  If the selection is empty or if its contents cannot be converted, `NULL`
+ *  is returned and a @ref GLFW_FORMAT_UNAVAILABLE error is generated.
+ *
+ *  @return The contents of the selection as a UTF-8 encoded string, or `NULL`
+ *  if an [error](@ref error_handling) occurred.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_PLATFORM_ERROR.
+ *
+ *  @pointer_lifetime The returned string is allocated and freed by GLFW. You
+ *  should not free it yourself. It is valid until the next call to @ref
+ *  glfwGetX11SelectionString or @ref glfwSetX11SelectionString, or until the
+ *  library is terminated.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref clipboard
+ *  @sa glfwSetX11SelectionString
+ *  @sa glfwGetClipboardString
+ *
+ *  @since Added in version 3.3.
+ *
+ *  @ingroup native
+ */
+GLFWAPI const char* glfwGetX11SelectionString(void);
 #endif
 
 #if defined(GLFW_EXPOSE_NATIVE_GLX)
@@ -389,9 +447,9 @@ GLFWAPI MirConnection* glfwGetMirDisplay(void);
  */
 GLFWAPI int glfwGetMirMonitor(GLFWmonitor* monitor);
 
-/*! @brief Returns the `MirSurface*` of the specified window.
+/*! @brief Returns the `MirWindow*` of the specified window.
  *
- *  @return The `MirSurface*` of the specified window, or `NULL` if an
+ *  @return The `MirWindow*` of the specified window, or `NULL` if an
  *  [error](@ref error_handling) occurred.
  *
  *  @thread_safety This function may be called from any thread.  Access is not
@@ -401,7 +459,7 @@ GLFWAPI int glfwGetMirMonitor(GLFWmonitor* monitor);
  *
  *  @ingroup native
  */
-GLFWAPI MirSurface* glfwGetMirWindow(GLFWwindow* window);
+GLFWAPI MirWindow* glfwGetMirWindow(GLFWwindow* window);
 #endif
 
 #if defined(GLFW_EXPOSE_NATIVE_EGL)
@@ -448,6 +506,64 @@ GLFWAPI EGLContext glfwGetEGLContext(GLFWwindow* window);
 GLFWAPI EGLSurface glfwGetEGLSurface(GLFWwindow* window);
 #endif
 
+#if defined(GLFW_EXPOSE_NATIVE_OSMESA)
+/*! @brief Retrieves the color buffer associated with the specified window.
+ *
+ *  @param[in] window The window whose color buffer to retrieve.
+ *  @param[out] width Where to store the width of the color buffer, or `NULL`.
+ *  @param[out] height Where to store the height of the color buffer, or `NULL`.
+ *  @param[out] format Where to store the OSMesa pixel format of the color
+ *  buffer, or `NULL`.
+ *  @param[out] buffer Where to store the address of the color buffer, or
+ *  `NULL`.
+ *  @return `GLFW_TRUE` if successful, or `GLFW_FALSE` if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @since Added in version 3.3.
+ *
+ *  @ingroup native
+ */
+GLFWAPI int glfwGetOSMesaColorBuffer(GLFWwindow* window, int* width, int* height, int* format, void** buffer);
+
+/*! @brief Retrieves the depth buffer associated with the specified window.
+ *
+ *  @param[in] window The window whose depth buffer to retrieve.
+ *  @param[out] width Where to store the width of the depth buffer, or `NULL`.
+ *  @param[out] height Where to store the height of the depth buffer, or `NULL`.
+ *  @param[out] bytesPerValue Where to store the number of bytes per depth
+ *  buffer element, or `NULL`.
+ *  @param[out] buffer Where to store the address of the depth buffer, or
+ *  `NULL`.
+ *  @return `GLFW_TRUE` if successful, or `GLFW_FALSE` if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @since Added in version 3.3.
+ *
+ *  @ingroup native
+ */
+GLFWAPI int glfwGetOSMesaDepthBuffer(GLFWwindow* window, int* width, int* height, int* bytesPerValue, void** buffer);
+
+/*! @brief Returns the `OSMesaContext` of the specified window.
+ *
+ *  @return The `OSMesaContext` of the specified window, or `NULL` if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @since Added in version 3.3.
+ *
+ *  @ingroup native
+ */
+GLFWAPI OSMesaContext glfwGetOSMesaContext(GLFWwindow* window);
+#endif
+
 #ifdef __cplusplus
 }
 #endif

raylib/external/glfw/src/cocoa_init.m

@@ -1,7 +1,7 @@
 //========================================================================
-// GLFW 3.2 OS X - www.glfw.org
+// GLFW 3.3 macOS - www.glfw.org
 //------------------------------------------------------------------------
-// Copyright (c) 2009-2016 Camilla Berglund <elmindreda@glfw.org>
+// Copyright (c) 2009-2016 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
@@ -28,8 +28,6 @@
 #include <sys/param.h> // For MAXPATHLEN
 
 
-#if defined(_GLFW_USE_CHDIR)
-
 // Change to our application bundle's resources directory, if present
 //
 static void changeToResourcesDirectory(void)
@@ -66,137 +64,135 @@ static void changeToResourcesDirectory(void)
     chdir(resourcesPath);
 }
 
-#endif /* _GLFW_USE_CHDIR */
-
 // Create key code translation tables
 //
 static void createKeyTables(void)
 {
     int scancode;
 
-    memset(_glfw.ns.publicKeys, -1, sizeof(_glfw.ns.publicKeys));
+    memset(_glfw.ns.keycodes, -1, sizeof(_glfw.ns.keycodes));
-    memset(_glfw.ns.nativeKeys, -1, sizeof(_glfw.ns.nativeKeys));
+    memset(_glfw.ns.scancodes, -1, sizeof(_glfw.ns.scancodes));
 
-    _glfw.ns.publicKeys[0x1D] = GLFW_KEY_0;
+    _glfw.ns.keycodes[0x1D] = GLFW_KEY_0;
-    _glfw.ns.publicKeys[0x12] = GLFW_KEY_1;
+    _glfw.ns.keycodes[0x12] = GLFW_KEY_1;
-    _glfw.ns.publicKeys[0x13] = GLFW_KEY_2;
+    _glfw.ns.keycodes[0x13] = GLFW_KEY_2;
-    _glfw.ns.publicKeys[0x14] = GLFW_KEY_3;
+    _glfw.ns.keycodes[0x14] = GLFW_KEY_3;
-    _glfw.ns.publicKeys[0x15] = GLFW_KEY_4;
+    _glfw.ns.keycodes[0x15] = GLFW_KEY_4;
-    _glfw.ns.publicKeys[0x17] = GLFW_KEY_5;
+    _glfw.ns.keycodes[0x17] = GLFW_KEY_5;
-    _glfw.ns.publicKeys[0x16] = GLFW_KEY_6;
+    _glfw.ns.keycodes[0x16] = GLFW_KEY_6;
-    _glfw.ns.publicKeys[0x1A] = GLFW_KEY_7;
+    _glfw.ns.keycodes[0x1A] = GLFW_KEY_7;
-    _glfw.ns.publicKeys[0x1C] = GLFW_KEY_8;
+    _glfw.ns.keycodes[0x1C] = GLFW_KEY_8;
-    _glfw.ns.publicKeys[0x19] = GLFW_KEY_9;
+    _glfw.ns.keycodes[0x19] = GLFW_KEY_9;
-    _glfw.ns.publicKeys[0x00] = GLFW_KEY_A;
+    _glfw.ns.keycodes[0x00] = GLFW_KEY_A;
-    _glfw.ns.publicKeys[0x0B] = GLFW_KEY_B;
+    _glfw.ns.keycodes[0x0B] = GLFW_KEY_B;
-    _glfw.ns.publicKeys[0x08] = GLFW_KEY_C;
+    _glfw.ns.keycodes[0x08] = GLFW_KEY_C;
-    _glfw.ns.publicKeys[0x02] = GLFW_KEY_D;
+    _glfw.ns.keycodes[0x02] = GLFW_KEY_D;
-    _glfw.ns.publicKeys[0x0E] = GLFW_KEY_E;
+    _glfw.ns.keycodes[0x0E] = GLFW_KEY_E;
-    _glfw.ns.publicKeys[0x03] = GLFW_KEY_F;
+    _glfw.ns.keycodes[0x03] = GLFW_KEY_F;
-    _glfw.ns.publicKeys[0x05] = GLFW_KEY_G;
+    _glfw.ns.keycodes[0x05] = GLFW_KEY_G;
-    _glfw.ns.publicKeys[0x04] = GLFW_KEY_H;
+    _glfw.ns.keycodes[0x04] = GLFW_KEY_H;
-    _glfw.ns.publicKeys[0x22] = GLFW_KEY_I;
+    _glfw.ns.keycodes[0x22] = GLFW_KEY_I;
-    _glfw.ns.publicKeys[0x26] = GLFW_KEY_J;
+    _glfw.ns.keycodes[0x26] = GLFW_KEY_J;
-    _glfw.ns.publicKeys[0x28] = GLFW_KEY_K;
+    _glfw.ns.keycodes[0x28] = GLFW_KEY_K;
-    _glfw.ns.publicKeys[0x25] = GLFW_KEY_L;
+    _glfw.ns.keycodes[0x25] = GLFW_KEY_L;
-    _glfw.ns.publicKeys[0x2E] = GLFW_KEY_M;
+    _glfw.ns.keycodes[0x2E] = GLFW_KEY_M;
-    _glfw.ns.publicKeys[0x2D] = GLFW_KEY_N;
+    _glfw.ns.keycodes[0x2D] = GLFW_KEY_N;
-    _glfw.ns.publicKeys[0x1F] = GLFW_KEY_O;
+    _glfw.ns.keycodes[0x1F] = GLFW_KEY_O;
-    _glfw.ns.publicKeys[0x23] = GLFW_KEY_P;
+    _glfw.ns.keycodes[0x23] = GLFW_KEY_P;
-    _glfw.ns.publicKeys[0x0C] = GLFW_KEY_Q;
+    _glfw.ns.keycodes[0x0C] = GLFW_KEY_Q;
-    _glfw.ns.publicKeys[0x0F] = GLFW_KEY_R;
+    _glfw.ns.keycodes[0x0F] = GLFW_KEY_R;
-    _glfw.ns.publicKeys[0x01] = GLFW_KEY_S;
+    _glfw.ns.keycodes[0x01] = GLFW_KEY_S;
-    _glfw.ns.publicKeys[0x11] = GLFW_KEY_T;
+    _glfw.ns.keycodes[0x11] = GLFW_KEY_T;
-    _glfw.ns.publicKeys[0x20] = GLFW_KEY_U;
+    _glfw.ns.keycodes[0x20] = GLFW_KEY_U;
-    _glfw.ns.publicKeys[0x09] = GLFW_KEY_V;
+    _glfw.ns.keycodes[0x09] = GLFW_KEY_V;
-    _glfw.ns.publicKeys[0x0D] = GLFW_KEY_W;
+    _glfw.ns.keycodes[0x0D] = GLFW_KEY_W;
-    _glfw.ns.publicKeys[0x07] = GLFW_KEY_X;
+    _glfw.ns.keycodes[0x07] = GLFW_KEY_X;
-    _glfw.ns.publicKeys[0x10] = GLFW_KEY_Y;
+    _glfw.ns.keycodes[0x10] = GLFW_KEY_Y;
-    _glfw.ns.publicKeys[0x06] = GLFW_KEY_Z;
+    _glfw.ns.keycodes[0x06] = GLFW_KEY_Z;
 
-    _glfw.ns.publicKeys[0x27] = GLFW_KEY_APOSTROPHE;
+    _glfw.ns.keycodes[0x27] = GLFW_KEY_APOSTROPHE;
-    _glfw.ns.publicKeys[0x2A] = GLFW_KEY_BACKSLASH;
+    _glfw.ns.keycodes[0x2A] = GLFW_KEY_BACKSLASH;
-    _glfw.ns.publicKeys[0x2B] = GLFW_KEY_COMMA;
+    _glfw.ns.keycodes[0x2B] = GLFW_KEY_COMMA;
-    _glfw.ns.publicKeys[0x18] = GLFW_KEY_EQUAL;
+    _glfw.ns.keycodes[0x18] = GLFW_KEY_EQUAL;
-    _glfw.ns.publicKeys[0x32] = GLFW_KEY_GRAVE_ACCENT;
+    _glfw.ns.keycodes[0x32] = GLFW_KEY_GRAVE_ACCENT;
-    _glfw.ns.publicKeys[0x21] = GLFW_KEY_LEFT_BRACKET;
+    _glfw.ns.keycodes[0x21] = GLFW_KEY_LEFT_BRACKET;
-    _glfw.ns.publicKeys[0x1B] = GLFW_KEY_MINUS;
+    _glfw.ns.keycodes[0x1B] = GLFW_KEY_MINUS;
-    _glfw.ns.publicKeys[0x2F] = GLFW_KEY_PERIOD;
+    _glfw.ns.keycodes[0x2F] = GLFW_KEY_PERIOD;
-    _glfw.ns.publicKeys[0x1E] = GLFW_KEY_RIGHT_BRACKET;
+    _glfw.ns.keycodes[0x1E] = GLFW_KEY_RIGHT_BRACKET;
-    _glfw.ns.publicKeys[0x29] = GLFW_KEY_SEMICOLON;
+    _glfw.ns.keycodes[0x29] = GLFW_KEY_SEMICOLON;
-    _glfw.ns.publicKeys[0x2C] = GLFW_KEY_SLASH;
+    _glfw.ns.keycodes[0x2C] = GLFW_KEY_SLASH;
-    _glfw.ns.publicKeys[0x0A] = GLFW_KEY_WORLD_1;
+    _glfw.ns.keycodes[0x0A] = GLFW_KEY_WORLD_1;
 
-    _glfw.ns.publicKeys[0x33] = GLFW_KEY_BACKSPACE;
+    _glfw.ns.keycodes[0x33] = GLFW_KEY_BACKSPACE;
-    _glfw.ns.publicKeys[0x39] = GLFW_KEY_CAPS_LOCK;
+    _glfw.ns.keycodes[0x39] = GLFW_KEY_CAPS_LOCK;
-    _glfw.ns.publicKeys[0x75] = GLFW_KEY_DELETE;
+    _glfw.ns.keycodes[0x75] = GLFW_KEY_DELETE;
-    _glfw.ns.publicKeys[0x7D] = GLFW_KEY_DOWN;
+    _glfw.ns.keycodes[0x7D] = GLFW_KEY_DOWN;
-    _glfw.ns.publicKeys[0x77] = GLFW_KEY_END;
+    _glfw.ns.keycodes[0x77] = GLFW_KEY_END;
-    _glfw.ns.publicKeys[0x24] = GLFW_KEY_ENTER;
+    _glfw.ns.keycodes[0x24] = GLFW_KEY_ENTER;
-    _glfw.ns.publicKeys[0x35] = GLFW_KEY_ESCAPE;
+    _glfw.ns.keycodes[0x35] = GLFW_KEY_ESCAPE;
-    _glfw.ns.publicKeys[0x7A] = GLFW_KEY_F1;
+    _glfw.ns.keycodes[0x7A] = GLFW_KEY_F1;
-    _glfw.ns.publicKeys[0x78] = GLFW_KEY_F2;
+    _glfw.ns.keycodes[0x78] = GLFW_KEY_F2;
-    _glfw.ns.publicKeys[0x63] = GLFW_KEY_F3;
+    _glfw.ns.keycodes[0x63] = GLFW_KEY_F3;
-    _glfw.ns.publicKeys[0x76] = GLFW_KEY_F4;
+    _glfw.ns.keycodes[0x76] = GLFW_KEY_F4;
-    _glfw.ns.publicKeys[0x60] = GLFW_KEY_F5;
+    _glfw.ns.keycodes[0x60] = GLFW_KEY_F5;
-    _glfw.ns.publicKeys[0x61] = GLFW_KEY_F6;
+    _glfw.ns.keycodes[0x61] = GLFW_KEY_F6;
-    _glfw.ns.publicKeys[0x62] = GLFW_KEY_F7;
+    _glfw.ns.keycodes[0x62] = GLFW_KEY_F7;
-    _glfw.ns.publicKeys[0x64] = GLFW_KEY_F8;
+    _glfw.ns.keycodes[0x64] = GLFW_KEY_F8;
-    _glfw.ns.publicKeys[0x65] = GLFW_KEY_F9;
+    _glfw.ns.keycodes[0x65] = GLFW_KEY_F9;
-    _glfw.ns.publicKeys[0x6D] = GLFW_KEY_F10;
+    _glfw.ns.keycodes[0x6D] = GLFW_KEY_F10;
-    _glfw.ns.publicKeys[0x67] = GLFW_KEY_F11;
+    _glfw.ns.keycodes[0x67] = GLFW_KEY_F11;
-    _glfw.ns.publicKeys[0x6F] = GLFW_KEY_F12;
+    _glfw.ns.keycodes[0x6F] = GLFW_KEY_F12;
-    _glfw.ns.publicKeys[0x69] = GLFW_KEY_F13;
+    _glfw.ns.keycodes[0x69] = GLFW_KEY_F13;
-    _glfw.ns.publicKeys[0x6B] = GLFW_KEY_F14;
+    _glfw.ns.keycodes[0x6B] = GLFW_KEY_F14;
-    _glfw.ns.publicKeys[0x71] = GLFW_KEY_F15;
+    _glfw.ns.keycodes[0x71] = GLFW_KEY_F15;
-    _glfw.ns.publicKeys[0x6A] = GLFW_KEY_F16;
+    _glfw.ns.keycodes[0x6A] = GLFW_KEY_F16;
-    _glfw.ns.publicKeys[0x40] = GLFW_KEY_F17;
+    _glfw.ns.keycodes[0x40] = GLFW_KEY_F17;
-    _glfw.ns.publicKeys[0x4F] = GLFW_KEY_F18;
+    _glfw.ns.keycodes[0x4F] = GLFW_KEY_F18;
-    _glfw.ns.publicKeys[0x50] = GLFW_KEY_F19;
+    _glfw.ns.keycodes[0x50] = GLFW_KEY_F19;
-    _glfw.ns.publicKeys[0x5A] = GLFW_KEY_F20;
+    _glfw.ns.keycodes[0x5A] = GLFW_KEY_F20;
-    _glfw.ns.publicKeys[0x73] = GLFW_KEY_HOME;
+    _glfw.ns.keycodes[0x73] = GLFW_KEY_HOME;
-    _glfw.ns.publicKeys[0x72] = GLFW_KEY_INSERT;
+    _glfw.ns.keycodes[0x72] = GLFW_KEY_INSERT;
-    _glfw.ns.publicKeys[0x7B] = GLFW_KEY_LEFT;
+    _glfw.ns.keycodes[0x7B] = GLFW_KEY_LEFT;
-    _glfw.ns.publicKeys[0x3A] = GLFW_KEY_LEFT_ALT;
+    _glfw.ns.keycodes[0x3A] = GLFW_KEY_LEFT_ALT;
-    _glfw.ns.publicKeys[0x3B] = GLFW_KEY_LEFT_CONTROL;
+    _glfw.ns.keycodes[0x3B] = GLFW_KEY_LEFT_CONTROL;
-    _glfw.ns.publicKeys[0x38] = GLFW_KEY_LEFT_SHIFT;
+    _glfw.ns.keycodes[0x38] = GLFW_KEY_LEFT_SHIFT;
-    _glfw.ns.publicKeys[0x37] = GLFW_KEY_LEFT_SUPER;
+    _glfw.ns.keycodes[0x37] = GLFW_KEY_LEFT_SUPER;
-    _glfw.ns.publicKeys[0x6E] = GLFW_KEY_MENU;
+    _glfw.ns.keycodes[0x6E] = GLFW_KEY_MENU;
-    _glfw.ns.publicKeys[0x47] = GLFW_KEY_NUM_LOCK;
+    _glfw.ns.keycodes[0x47] = GLFW_KEY_NUM_LOCK;
-    _glfw.ns.publicKeys[0x79] = GLFW_KEY_PAGE_DOWN;
+    _glfw.ns.keycodes[0x79] = GLFW_KEY_PAGE_DOWN;
-    _glfw.ns.publicKeys[0x74] = GLFW_KEY_PAGE_UP;
+    _glfw.ns.keycodes[0x74] = GLFW_KEY_PAGE_UP;
-    _glfw.ns.publicKeys[0x7C] = GLFW_KEY_RIGHT;
+    _glfw.ns.keycodes[0x7C] = GLFW_KEY_RIGHT;
-    _glfw.ns.publicKeys[0x3D] = GLFW_KEY_RIGHT_ALT;
+    _glfw.ns.keycodes[0x3D] = GLFW_KEY_RIGHT_ALT;
-    _glfw.ns.publicKeys[0x3E] = GLFW_KEY_RIGHT_CONTROL;
+    _glfw.ns.keycodes[0x3E] = GLFW_KEY_RIGHT_CONTROL;
-    _glfw.ns.publicKeys[0x3C] = GLFW_KEY_RIGHT_SHIFT;
+    _glfw.ns.keycodes[0x3C] = GLFW_KEY_RIGHT_SHIFT;
-    _glfw.ns.publicKeys[0x36] = GLFW_KEY_RIGHT_SUPER;
+    _glfw.ns.keycodes[0x36] = GLFW_KEY_RIGHT_SUPER;
-    _glfw.ns.publicKeys[0x31] = GLFW_KEY_SPACE;
+    _glfw.ns.keycodes[0x31] = GLFW_KEY_SPACE;
-    _glfw.ns.publicKeys[0x30] = GLFW_KEY_TAB;
+    _glfw.ns.keycodes[0x30] = GLFW_KEY_TAB;
-    _glfw.ns.publicKeys[0x7E] = GLFW_KEY_UP;
+    _glfw.ns.keycodes[0x7E] = GLFW_KEY_UP;
 
-    _glfw.ns.publicKeys[0x52] = GLFW_KEY_KP_0;
+    _glfw.ns.keycodes[0x52] = GLFW_KEY_KP_0;
-    _glfw.ns.publicKeys[0x53] = GLFW_KEY_KP_1;
+    _glfw.ns.keycodes[0x53] = GLFW_KEY_KP_1;
-    _glfw.ns.publicKeys[0x54] = GLFW_KEY_KP_2;
+    _glfw.ns.keycodes[0x54] = GLFW_KEY_KP_2;
-    _glfw.ns.publicKeys[0x55] = GLFW_KEY_KP_3;
+    _glfw.ns.keycodes[0x55] = GLFW_KEY_KP_3;
-    _glfw.ns.publicKeys[0x56] = GLFW_KEY_KP_4;
+    _glfw.ns.keycodes[0x56] = GLFW_KEY_KP_4;
-    _glfw.ns.publicKeys[0x57] = GLFW_KEY_KP_5;
+    _glfw.ns.keycodes[0x57] = GLFW_KEY_KP_5;
-    _glfw.ns.publicKeys[0x58] = GLFW_KEY_KP_6;
+    _glfw.ns.keycodes[0x58] = GLFW_KEY_KP_6;
-    _glfw.ns.publicKeys[0x59] = GLFW_KEY_KP_7;
+    _glfw.ns.keycodes[0x59] = GLFW_KEY_KP_7;
-    _glfw.ns.publicKeys[0x5B] = GLFW_KEY_KP_8;
+    _glfw.ns.keycodes[0x5B] = GLFW_KEY_KP_8;
-    _glfw.ns.publicKeys[0x5C] = GLFW_KEY_KP_9;
+    _glfw.ns.keycodes[0x5C] = GLFW_KEY_KP_9;
-    _glfw.ns.publicKeys[0x45] = GLFW_KEY_KP_ADD;
+    _glfw.ns.keycodes[0x45] = GLFW_KEY_KP_ADD;
-    _glfw.ns.publicKeys[0x41] = GLFW_KEY_KP_DECIMAL;
+    _glfw.ns.keycodes[0x41] = GLFW_KEY_KP_DECIMAL;
-    _glfw.ns.publicKeys[0x4B] = GLFW_KEY_KP_DIVIDE;
+    _glfw.ns.keycodes[0x4B] = GLFW_KEY_KP_DIVIDE;
-    _glfw.ns.publicKeys[0x4C] = GLFW_KEY_KP_ENTER;
+    _glfw.ns.keycodes[0x4C] = GLFW_KEY_KP_ENTER;
-    _glfw.ns.publicKeys[0x51] = GLFW_KEY_KP_EQUAL;
+    _glfw.ns.keycodes[0x51] = GLFW_KEY_KP_EQUAL;
-    _glfw.ns.publicKeys[0x43] = GLFW_KEY_KP_MULTIPLY;
+    _glfw.ns.keycodes[0x43] = GLFW_KEY_KP_MULTIPLY;
-    _glfw.ns.publicKeys[0x4E] = GLFW_KEY_KP_SUBTRACT;
+    _glfw.ns.keycodes[0x4E] = GLFW_KEY_KP_SUBTRACT;
 
     for (scancode = 0;  scancode < 256;  scancode++)
     {
         // Store the reverse translation for faster key name lookup
-        if (_glfw.ns.publicKeys[scancode] >= 0)
+        if (_glfw.ns.keycodes[scancode] >= 0)
-            _glfw.ns.nativeKeys[_glfw.ns.publicKeys[scancode]] = scancode;
+            _glfw.ns.scancodes[_glfw.ns.keycodes[scancode]] = scancode;
     }
 }
 
@@ -219,8 +215,9 @@ static GLFWbool updateUnicodeDataNS(void)
         return GLFW_FALSE;
     }
 
-    _glfw.ns.unicodeData = TISGetInputSourceProperty(_glfw.ns.inputSource,
+    _glfw.ns.unicodeData =
-                                                     kTISPropertyUnicodeKeyLayoutData);
+        TISGetInputSourceProperty(_glfw.ns.inputSource,
+                                  kTISPropertyUnicodeKeyLayoutData);
     if (!_glfw.ns.unicodeData)
     {
         _glfwInputError(GLFW_PLATFORM_ERROR,
@@ -236,7 +233,8 @@ static GLFWbool updateUnicodeDataNS(void)
 static GLFWbool initializeTIS(void)
 {
     // This works only because Cocoa has already loaded it properly
-    _glfw.ns.tis.bundle = CFBundleGetBundleWithIdentifier(CFSTR("com.apple.HIToolbox"));
+    _glfw.ns.tis.bundle =
+        CFBundleGetBundleWithIdentifier(CFSTR("com.apple.HIToolbox"));
     if (!_glfw.ns.tis.bundle)
     {
         _glfwInputError(GLFW_PLATFORM_ERROR,
@@ -247,9 +245,6 @@ static GLFWbool initializeTIS(void)
     CFStringRef* kPropertyUnicodeKeyLayoutData =
         CFBundleGetDataPointerForName(_glfw.ns.tis.bundle,
                                       CFSTR("kTISPropertyUnicodeKeyLayoutData"));
-    CFStringRef* kNotifySelectedKeyboardInputSourceChanged =
-        CFBundleGetDataPointerForName(_glfw.ns.tis.bundle,
-                                      CFSTR("kTISNotifySelectedKeyboardInputSourceChanged"));
     _glfw.ns.tis.CopyCurrentKeyboardLayoutInputSource =
         CFBundleGetFunctionPointerForName(_glfw.ns.tis.bundle,
                                           CFSTR("TISCopyCurrentKeyboardLayoutInputSource"));
@@ -261,7 +256,6 @@ static GLFWbool initializeTIS(void)
                                           CFSTR("LMGetKbdType"));
 
     if (!kPropertyUnicodeKeyLayoutData ||
-        !kNotifySelectedKeyboardInputSourceChanged ||
         !TISCopyCurrentKeyboardLayoutInputSource ||
         !TISGetInputSourceProperty ||
         !LMGetKbdType)
@@ -273,8 +267,6 @@ static GLFWbool initializeTIS(void)
 
     _glfw.ns.tis.kPropertyUnicodeKeyLayoutData =
         *kPropertyUnicodeKeyLayoutData;
-    _glfw.ns.tis.kNotifySelectedKeyboardInputSourceChanged =
-        *kNotifySelectedKeyboardInputSourceChanged;
 
     return updateUnicodeDataNS();
 }
@@ -300,17 +292,16 @@ int _glfwPlatformInit(void)
 {
     _glfw.ns.autoreleasePool = [[NSAutoreleasePool alloc] init];
 
+    if (_glfw.hints.init.ns.chdir)
+        changeToResourcesDirectory();
+
     _glfw.ns.listener = [[GLFWLayoutListener alloc] init];
-    [[NSDistributedNotificationCenter defaultCenter]
+    [[NSNotificationCenter defaultCenter]
         addObserver:_glfw.ns.listener
            selector:@selector(selectedKeyboardInputSourceChanged:)
-               name:(__bridge NSString*)kTISNotifySelectedKeyboardInputSourceChanged
+               name:NSTextInputContextKeyboardSelectionDidChangeNotification
              object:nil];
 
-#if defined(_GLFW_USE_CHDIR)
-    changeToResourcesDirectory();
-#endif
-
     createKeyTables();
 
     _glfw.ns.eventSource = CGEventSourceCreate(kCGEventSourceStateHIDSystemState);
@@ -322,12 +313,10 @@ int _glfwPlatformInit(void)
     if (!initializeTIS())
         return GLFW_FALSE;
 
-    if (!_glfwInitThreadLocalStoragePOSIX())
-        return GLFW_FALSE;
-
     _glfwInitTimerNS();
     _glfwInitJoysticksNS();
 
+    _glfwPollMonitorsNS();
     return GLFW_TRUE;
 }
 
@@ -355,24 +344,20 @@ void _glfwPlatformTerminate(void)
 
     if (_glfw.ns.listener)
     {
-        [[NSDistributedNotificationCenter defaultCenter]
+        [[NSNotificationCenter defaultCenter]
             removeObserver:_glfw.ns.listener
-                      name:(__bridge NSString*)kTISNotifySelectedKeyboardInputSourceChanged
+                      name:NSTextInputContextKeyboardSelectionDidChangeNotification
                     object:nil];
-        [[NSDistributedNotificationCenter defaultCenter]
+        [[NSNotificationCenter defaultCenter]
             removeObserver:_glfw.ns.listener];
         [_glfw.ns.listener release];
         _glfw.ns.listener = nil;
     }
 
-    [_glfw.ns.cursor release];
-    _glfw.ns.cursor = nil;
-
     free(_glfw.ns.clipboardString);
 
     _glfwTerminateNSGL();
     _glfwTerminateJoysticksNS();
-    _glfwTerminateThreadLocalStoragePOSIX();
 
     [_glfw.ns.autoreleasePool release];
     _glfw.ns.autoreleasePool = nil;
@@ -381,15 +366,6 @@ void _glfwPlatformTerminate(void)
 const char* _glfwPlatformGetVersionString(void)
 {
     return _GLFW_VERSION_NUMBER " Cocoa NSGL"
-#if defined(_GLFW_USE_CHDIR)
-        " chdir"
-#endif
-#if defined(_GLFW_USE_MENUBAR)
-        " menubar"
-#endif
-#if defined(_GLFW_USE_RETINA)
-        " retina"
-#endif
 #if defined(_GLFW_BUILD_DLL)
         " dynamic"
 #endif

raylib/external/glfw/src/cocoa_joystick.h

@@ -1,7 +1,7 @@
 //========================================================================
-// GLFW 3.2 Cocoa - www.glfw.org
+// GLFW 3.3 Cocoa - www.glfw.org
 //------------------------------------------------------------------------
-// Copyright (c) 2006-2016 Camilla Berglund <elmindreda@glfw.org>
+// Copyright (c) 2006-2016 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
@@ -24,37 +24,27 @@
 //
 //========================================================================
 
-#ifndef _glfw3_cocoa_joystick_h_
-#define _glfw3_cocoa_joystick_h_
-
 #include <IOKit/IOKitLib.h>
 #include <IOKit/IOCFPlugIn.h>
 #include <IOKit/hid/IOHIDLib.h>
 #include <IOKit/hid/IOHIDKeys.h>
 
-#define _GLFW_PLATFORM_LIBRARY_JOYSTICK_STATE \
+#define _GLFW_PLATFORM_JOYSTICK_STATE         _GLFWjoystickNS ns
-    _GLFWjoystickNS ns_js[GLFW_JOYSTICK_LAST + 1]
+#define _GLFW_PLATFORM_LIBRARY_JOYSTICK_STATE
 
+#define _GLFW_PLATFORM_MAPPING_NAME "Mac OS X"
 
 // Cocoa-specific per-joystick data
 //
 typedef struct _GLFWjoystickNS
 {
-    GLFWbool        present;
+    IOHIDDeviceRef      device;
-    char            name[256];
+    CFMutableArrayRef   axes;
-
+    CFMutableArrayRef   buttons;
-    IOHIDDeviceRef deviceRef;
+    CFMutableArrayRef   hats;
-
-    CFMutableArrayRef axisElements;
-    CFMutableArrayRef buttonElements;
-    CFMutableArrayRef hatElements;
-
-    float*          axes;
-    unsigned char*  buttons;
 } _GLFWjoystickNS;
 
 
 void _glfwInitJoysticksNS(void);
 void _glfwTerminateJoysticksNS(void);
 
-#endif // _glfw3_cocoa_joystick_h_

raylib/external/glfw/src/cocoa_joystick.m

@@ -1,7 +1,7 @@
 //========================================================================
-// GLFW 3.2 Cocoa - www.glfw.org
+// GLFW 3.3 Cocoa - www.glfw.org
 //------------------------------------------------------------------------
-// Copyright (c) 2009-2016 Camilla Berglund <elmindreda@glfw.org>
+// Copyright (c) 2009-2016 Camilla Löwy <elmindreda@glfw.org>
 // Copyright (c) 2012 Torsten Walluhn <tw@mad-cad.net>
 //
 // This software is provided 'as-is', without any express or implied
@@ -42,42 +42,167 @@
 //
 typedef struct _GLFWjoyelementNS
 {
-    IOHIDElementRef elementRef;
+    IOHIDElementRef native;
-
+    uint32_t        usage;
-    long min;
+    int             index;
-    long max;
+    long            minimum;
-
+    long            maximum;
-    long minReport;
-    long maxReport;
 
 } _GLFWjoyelementNS;
 
 
-static void getElementsCFArrayHandler(const void* value, void* parameter);
+// Returns the value of the specified element of the specified joystick
-
-// Adds an element to the specified joystick
 //
-static void addJoystickElement(_GLFWjoystickNS* js,
+static long getElementValue(_GLFWjoystick* js, _GLFWjoyelementNS* element)
-                               IOHIDElementRef elementRef)
 {
-    IOHIDElementType elementType;
+    IOHIDValueRef valueRef;
-    long usagePage, usage;
+    long value = 0;
-    CFMutableArrayRef elementsArray = NULL;
 
-    elementType = IOHIDElementGetType(elementRef);
+    if (js->ns.device)
-    usagePage = IOHIDElementGetUsagePage(elementRef);
-    usage = IOHIDElementGetUsage(elementRef);
-
-    if ((elementType != kIOHIDElementTypeInput_Axis) &&
-        (elementType != kIOHIDElementTypeInput_Button) &&
-        (elementType != kIOHIDElementTypeInput_Misc))
     {
-        return;
+        if (IOHIDDeviceGetValue(js->ns.device,
+                                element->native,
+                                &valueRef) == kIOReturnSuccess)
+        {
+            value = IOHIDValueGetIntegerValue(valueRef);
+        }
     }
 
-    switch (usagePage)
+    return value;
+}
+
+// Comparison function for matching the SDL element order
+//
+static CFComparisonResult compareElements(const void* fp,
+                                          const void* sp,
+                                          void* user)
+{
+    const _GLFWjoyelementNS* fe = fp;
+    const _GLFWjoyelementNS* se = sp;
+    if (fe->usage < se->usage)
+        return kCFCompareLessThan;
+    if (fe->usage > se->usage)
+        return kCFCompareGreaterThan;
+    if (fe->index < se->index)
+        return kCFCompareLessThan;
+    if (fe->index > se->index)
+        return kCFCompareGreaterThan;
+    return kCFCompareEqualTo;
+}
+
+// Removes the specified joystick
+//
+static void closeJoystick(_GLFWjoystick* js)
+{
+    int i;
+
+    if (!js->present)
+        return;
+
+    for (i = 0;  i < CFArrayGetCount(js->ns.axes);  i++)
+        free((void*) CFArrayGetValueAtIndex(js->ns.axes, i));
+    CFRelease(js->ns.axes);
+
+    for (i = 0;  i < CFArrayGetCount(js->ns.buttons);  i++)
+        free((void*) CFArrayGetValueAtIndex(js->ns.buttons, i));
+    CFRelease(js->ns.buttons);
+
+    for (i = 0;  i < CFArrayGetCount(js->ns.hats);  i++)
+        free((void*) CFArrayGetValueAtIndex(js->ns.hats, i));
+    CFRelease(js->ns.hats);
+
+    _glfwFreeJoystick(js);
+    _glfwInputJoystick(js, GLFW_DISCONNECTED);
+}
+
+// Callback for user-initiated joystick addition
+//
+static void matchCallback(void* context,
+                          IOReturn result,
+                          void* sender,
+                          IOHIDDeviceRef device)
+{
+    int jid;
+    char name[256];
+    char guid[33];
+    CFIndex i;
+    CFTypeRef property;
+    uint32_t vendor = 0, product = 0, version = 0;
+    _GLFWjoystick* js;
+    CFMutableArrayRef axes, buttons, hats;
+
+    for (jid = 0;  jid <= GLFW_JOYSTICK_LAST;  jid++)
     {
-        case kHIDPage_GenericDesktop:
+        if (_glfw.joysticks[jid].ns.device == device)
+            return;
+    }
+
+    axes    = CFArrayCreateMutable(NULL, 0, NULL);
+    buttons = CFArrayCreateMutable(NULL, 0, NULL);
+    hats    = CFArrayCreateMutable(NULL, 0, NULL);
+
+    property = IOHIDDeviceGetProperty(device, CFSTR(kIOHIDProductKey));
+    if (property)
+    {
+        CFStringGetCString(property,
+                           name,
+                           sizeof(name),
+                           kCFStringEncodingUTF8);
+    }
+    else
+        strncpy(name, "Unknown", sizeof(name));
+
+    property = IOHIDDeviceGetProperty(device, CFSTR(kIOHIDVendorIDKey));
+    if (property)
+        CFNumberGetValue(property, kCFNumberSInt32Type, &vendor);
+
+    property = IOHIDDeviceGetProperty(device, CFSTR(kIOHIDProductIDKey));
+    if (property)
+        CFNumberGetValue(property, kCFNumberSInt32Type, &product);
+
+    property = IOHIDDeviceGetProperty(device, CFSTR(kIOHIDVersionNumberKey));
+    if (property)
+        CFNumberGetValue(property, kCFNumberSInt32Type, &version);
+
+    // Generate a joystick GUID that matches the SDL 2.0.5+ one
+    if (vendor && product)
+    {
+        sprintf(guid, "03000000%02x%02x0000%02x%02x0000%02x%02x0000",
+                (uint8_t) vendor, (uint8_t) (vendor >> 8),
+                (uint8_t) product, (uint8_t) (product >> 8),
+                (uint8_t) version, (uint8_t) (version >> 8));
+    }
+    else
+    {
+        sprintf(guid, "05000000%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x00",
+                name[0], name[1], name[2], name[3],
+                name[4], name[5], name[6], name[7],
+                name[8], name[9], name[10]);
+    }
+
+    CFArrayRef elements =
+        IOHIDDeviceCopyMatchingElements(device, NULL, kIOHIDOptionsTypeNone);
+
+    for (i = 0;  i < CFArrayGetCount(elements);  i++)
+    {
+        IOHIDElementRef native = (IOHIDElementRef)
+            CFArrayGetValueAtIndex(elements, i);
+        if (CFGetTypeID(native) != IOHIDElementGetTypeID())
+            continue;
+
+        const IOHIDElementType type = IOHIDElementGetType(native);
+        if ((type != kIOHIDElementTypeInput_Axis) &&
+            (type != kIOHIDElementTypeInput_Button) &&
+            (type != kIOHIDElementTypeInput_Misc))
+        {
+            continue;
+        }
+
+        CFMutableArrayRef target = NULL;
+
+        const uint32_t usage = IOHIDElementGetUsage(native);
+        const uint32_t page = IOHIDElementGetUsagePage(native);
+        if (page == kHIDPage_GenericDesktop)
         {
             switch (usage)
             {
@@ -90,241 +215,48 @@ static void addJoystickElement(_GLFWjoystickNS* js,
                 case kHIDUsage_GD_Slider:
                 case kHIDUsage_GD_Dial:
                 case kHIDUsage_GD_Wheel:
-                    elementsArray = js->axisElements;
+                    target = axes;
                     break;
                 case kHIDUsage_GD_Hatswitch:
-                    elementsArray = js->hatElements;
+                    target = hats;
                     break;
             }
-
-            break;
         }
+        else if (page == kHIDPage_Button)
+            target = buttons;
 
-        case kHIDPage_Button:
+        if (target)
-            elementsArray = js->buttonElements;
-            break;
-        default:
-            break;
-    }
-
-    if (elementsArray)
-    {
-        _GLFWjoyelementNS* element = calloc(1, sizeof(_GLFWjoyelementNS));
-
-        CFArrayAppendValue(elementsArray, element);
-
-        element->elementRef = elementRef;
-
-        element->minReport = IOHIDElementGetLogicalMin(elementRef);
-        element->maxReport = IOHIDElementGetLogicalMax(elementRef);
-    }
-}
-
-// Adds an element to the specified joystick
-//
-static void getElementsCFArrayHandler(const void* value, void* parameter)
-{
-    if (CFGetTypeID(value) == IOHIDElementGetTypeID())
-    {
-        addJoystickElement((_GLFWjoystickNS*) parameter,
-                           (IOHIDElementRef) value);
-    }
-}
-
-// Returns the value of the specified element of the specified joystick
-//
-static long getElementValue(_GLFWjoystickNS* js, _GLFWjoyelementNS* element)
-{
-    IOReturn result = kIOReturnSuccess;
-    IOHIDValueRef valueRef;
-    long value = 0;
-
-    if (js && element && js->deviceRef)
-    {
-        result = IOHIDDeviceGetValue(js->deviceRef,
-                                     element->elementRef,
-                                     &valueRef);
-
-        if (kIOReturnSuccess == result)
         {
-            value = IOHIDValueGetIntegerValue(valueRef);
+            _GLFWjoyelementNS* element = calloc(1, sizeof(_GLFWjoyelementNS));
-
+            element->native  = native;
-            // Record min and max for auto calibration
+            element->usage   = usage;
-            if (value < element->minReport)
+            element->index   = (int) CFArrayGetCount(target);
-                element->minReport = value;
+            element->minimum = IOHIDElementGetLogicalMin(native);
-            if (value > element->maxReport)
+            element->maximum = IOHIDElementGetLogicalMax(native);
-                element->maxReport = value;
+            CFArrayAppendValue(target, element);
         }
     }
 
-    // Auto user scale
+    CFRelease(elements);
-    return value;
-}
 
-// Removes the specified joystick
+    CFArraySortValues(axes, CFRangeMake(0, CFArrayGetCount(axes)),
-//
+                      compareElements, NULL);
-static void removeJoystick(_GLFWjoystickNS* js)
+    CFArraySortValues(buttons, CFRangeMake(0, CFArrayGetCount(buttons)),
-{
+                      compareElements, NULL);
-    int i;
+    CFArraySortValues(hats, CFRangeMake(0, CFArrayGetCount(hats)),
+                      compareElements, NULL);
 
-    if (!js->present)
+    js = _glfwAllocJoystick(name, guid,
-        return;
+                            (int) CFArrayGetCount(axes),
+                            (int) CFArrayGetCount(buttons),
+                            (int) CFArrayGetCount(hats));
 
-    for (i = 0;  i < CFArrayGetCount(js->axisElements);  i++)
+    js->ns.device  = device;
-        free((void*) CFArrayGetValueAtIndex(js->axisElements, i));
+    js->ns.axes    = axes;
-    CFArrayRemoveAllValues(js->axisElements);
+    js->ns.buttons = buttons;
-    CFRelease(js->axisElements);
+    js->ns.hats    = hats;
 
-    for (i = 0;  i < CFArrayGetCount(js->buttonElements);  i++)
+    _glfwInputJoystick(js, GLFW_CONNECTED);
-        free((void*) CFArrayGetValueAtIndex(js->buttonElements, i));
-    CFArrayRemoveAllValues(js->buttonElements);
-    CFRelease(js->buttonElements);
-
-    for (i = 0;  i < CFArrayGetCount(js->hatElements);  i++)
-        free((void*) CFArrayGetValueAtIndex(js->hatElements, i));
-    CFArrayRemoveAllValues(js->hatElements);
-    CFRelease(js->hatElements);
-
-    free(js->axes);
-    free(js->buttons);
-
-    memset(js, 0, sizeof(_GLFWjoystickNS));
-
-    _glfwInputJoystickChange(js - _glfw.ns_js, GLFW_DISCONNECTED);
-}
-
-// Polls for joystick axis events and updates GLFW state
-//
-static GLFWbool pollJoystickAxisEvents(_GLFWjoystickNS* js)
-{
-    CFIndex i;
-
-    if (!js->present)
-        return GLFW_FALSE;
-
-    for (i = 0;  i < CFArrayGetCount(js->axisElements);  i++)
-    {
-        _GLFWjoyelementNS* axis = (_GLFWjoyelementNS*)
-            CFArrayGetValueAtIndex(js->axisElements, i);
-
-        long value = getElementValue(js, axis);
-        long readScale = axis->maxReport - axis->minReport;
-
-        if (readScale == 0)
-            js->axes[i] = value;
-        else
-            js->axes[i] = (2.f * (value - axis->minReport) / readScale) - 1.f;
-    }
-
-    return GLFW_TRUE;
-}
-
-// Polls for joystick button events and updates GLFW state
-//
-static GLFWbool pollJoystickButtonEvents(_GLFWjoystickNS* js)
-{
-    CFIndex i;
-    int buttonIndex = 0;
-
-    if (!js->present)
-        return GLFW_FALSE;
-
-    for (i = 0;  i < CFArrayGetCount(js->buttonElements);  i++)
-    {
-        _GLFWjoyelementNS* button = (_GLFWjoyelementNS*)
-            CFArrayGetValueAtIndex(js->buttonElements, i);
-
-        if (getElementValue(js, button))
-            js->buttons[buttonIndex++] = GLFW_PRESS;
-        else
-            js->buttons[buttonIndex++] = GLFW_RELEASE;
-    }
-
-    for (i = 0;  i < CFArrayGetCount(js->hatElements);  i++)
-    {
-        _GLFWjoyelementNS* hat = (_GLFWjoyelementNS*)
-            CFArrayGetValueAtIndex(js->hatElements, i);
-
-        // Bit fields of button presses for each direction, including nil
-        const int directions[9] = { 1, 3, 2, 6, 4, 12, 8, 9, 0 };
-
-        long j, value = getElementValue(js, hat);
-        if (value < 0 || value > 8)
-            value = 8;
-
-        for (j = 0;  j < 4;  j++)
-        {
-            if (directions[value] & (1 << j))
-                js->buttons[buttonIndex++] = GLFW_PRESS;
-            else
-                js->buttons[buttonIndex++] = GLFW_RELEASE;
-        }
-    }
-
-    return GLFW_TRUE;
-}
-
-// Callback for user-initiated joystick addition
-//
-static void matchCallback(void* context,
-                          IOReturn result,
-                          void* sender,
-                          IOHIDDeviceRef deviceRef)
-{
-    _GLFWjoystickNS* js;
-    int joy;
-
-    for (joy = GLFW_JOYSTICK_1;  joy <= GLFW_JOYSTICK_LAST;  joy++)
-    {
-        if (_glfw.ns_js[joy].present && _glfw.ns_js[joy].deviceRef == deviceRef)
-            return;
-    }
-
-    for (joy = GLFW_JOYSTICK_1;  joy <= GLFW_JOYSTICK_LAST;  joy++)
-    {
-        if (!_glfw.ns_js[joy].present)
-            break;
-    }
-
-    if (joy > GLFW_JOYSTICK_LAST)
-        return;
-
-    js = _glfw.ns_js + joy;
-    js->present = GLFW_TRUE;
-    js->deviceRef = deviceRef;
-
-    CFStringRef name = IOHIDDeviceGetProperty(deviceRef,
-                                              CFSTR(kIOHIDProductKey));
-    if (name)
-    {
-        CFStringGetCString(name,
-                           js->name,
-                           sizeof(js->name),
-                           kCFStringEncodingUTF8);
-    }
-    else
-        strncpy(js->name, "Unknown", sizeof(js->name));
-
-    js->axisElements = CFArrayCreateMutable(NULL, 0, NULL);
-    js->buttonElements = CFArrayCreateMutable(NULL, 0, NULL);
-    js->hatElements = CFArrayCreateMutable(NULL, 0, NULL);
-
-    CFArrayRef arrayRef = IOHIDDeviceCopyMatchingElements(deviceRef,
-                                                          NULL,
-                                                          kIOHIDOptionsTypeNone);
-    CFRange range = { 0, CFArrayGetCount(arrayRef) };
-    CFArrayApplyFunction(arrayRef,
-                         range,
-                         getElementsCFArrayHandler,
-                         (void*) js);
-
-    CFRelease(arrayRef);
-
-    js->axes = calloc(CFArrayGetCount(js->axisElements), sizeof(float));
-    js->buttons = calloc(CFArrayGetCount(js->buttonElements) +
-                         CFArrayGetCount(js->hatElements) * 4, 1);
-
-    _glfwInputJoystickChange(joy, GLFW_CONNECTED);
 }
 
 // Callback for user-initiated joystick removal
@@ -332,60 +264,20 @@ static void matchCallback(void* context,
 static void removeCallback(void* context,
                            IOReturn result,
                            void* sender,
-                           IOHIDDeviceRef deviceRef)
+                           IOHIDDeviceRef device)
 {
-    int joy;
+    int jid;
 
-    for (joy = GLFW_JOYSTICK_1;  joy <= GLFW_JOYSTICK_LAST;  joy++)
+    for (jid = 0;  jid <= GLFW_JOYSTICK_LAST;  jid++)
     {
-        if (_glfw.ns_js[joy].deviceRef == deviceRef)
+        if (_glfw.joysticks[jid].ns.device == device)
         {
-            removeJoystick(_glfw.ns_js + joy);
+            closeJoystick(_glfw.joysticks + jid);
             break;
         }
     }
 }
 
-// Creates a dictionary to match against devices with the specified usage page
-// and usage
-//
-static CFMutableDictionaryRef createMatchingDictionary(long usagePage,
-                                                       long usage)
-{
-    CFMutableDictionaryRef result =
-        CFDictionaryCreateMutable(kCFAllocatorDefault,
-                                  0,
-                                  &kCFTypeDictionaryKeyCallBacks,
-                                  &kCFTypeDictionaryValueCallBacks);
-
-    if (result)
-    {
-        CFNumberRef pageRef = CFNumberCreate(kCFAllocatorDefault,
-                                             kCFNumberLongType,
-                                             &usagePage);
-        if (pageRef)
-        {
-            CFDictionarySetValue(result,
-                                 CFSTR(kIOHIDDeviceUsagePageKey),
-                                 pageRef);
-            CFRelease(pageRef);
-
-            CFNumberRef usageRef = CFNumberCreate(kCFAllocatorDefault,
-                                                  kCFNumberLongType,
-                                                  &usage);
-            if (usageRef)
-            {
-                CFDictionarySetValue(result,
-                                     CFSTR(kIOHIDDeviceUsageKey),
-                                     usageRef);
-                CFRelease(usageRef);
-            }
-        }
-    }
-
-    return result;
-}
-
 
 //////////////////////////////////////////////////////////////////////////
 //////                       GLFW internal API                      //////
@@ -395,56 +287,73 @@ static CFMutableDictionaryRef createMatchingDictionary(long usagePage,
 //
 void _glfwInitJoysticksNS(void)
 {
-    CFMutableArrayRef matchingCFArrayRef;
+    CFMutableArrayRef matching;
+    const long usages[] =
+    {
+        kHIDUsage_GD_Joystick,
+        kHIDUsage_GD_GamePad,
+        kHIDUsage_GD_MultiAxisController
+    };
 
     _glfw.ns.hidManager = IOHIDManagerCreate(kCFAllocatorDefault,
                                              kIOHIDOptionsTypeNone);
 
-    matchingCFArrayRef = CFArrayCreateMutable(kCFAllocatorDefault,
+    matching = CFArrayCreateMutable(kCFAllocatorDefault,
-                                              0,
+                                    0,
-                                              &kCFTypeArrayCallBacks);
+                                    &kCFTypeArrayCallBacks);
-    if (matchingCFArrayRef)
+    if (!matching)
     {
-        CFDictionaryRef matchingCFDictRef =
+        _glfwInputError(GLFW_PLATFORM_ERROR, "Cocoa: Failed to create array");
-            createMatchingDictionary(kHIDPage_GenericDesktop,
+        return;
-                                     kHIDUsage_GD_Joystick);
-        if (matchingCFDictRef)
-        {
-            CFArrayAppendValue(matchingCFArrayRef, matchingCFDictRef);
-            CFRelease(matchingCFDictRef);
-        }
-
-        matchingCFDictRef = createMatchingDictionary(kHIDPage_GenericDesktop,
-                                                     kHIDUsage_GD_GamePad);
-        if (matchingCFDictRef)
-        {
-            CFArrayAppendValue(matchingCFArrayRef, matchingCFDictRef);
-            CFRelease(matchingCFDictRef);
-        }
-
-        matchingCFDictRef =
-            createMatchingDictionary(kHIDPage_GenericDesktop,
-                                     kHIDUsage_GD_MultiAxisController);
-        if (matchingCFDictRef)
-        {
-            CFArrayAppendValue(matchingCFArrayRef, matchingCFDictRef);
-            CFRelease(matchingCFDictRef);
-        }
-
-        IOHIDManagerSetDeviceMatchingMultiple(_glfw.ns.hidManager,
-                                              matchingCFArrayRef);
-        CFRelease(matchingCFArrayRef);
     }
 
+    for (int i = 0;  i < sizeof(usages) / sizeof(long);  i++)
+    {
+        const long page = kHIDPage_GenericDesktop;
+
+        CFMutableDictionaryRef dict =
+            CFDictionaryCreateMutable(kCFAllocatorDefault,
+                                      0,
+                                      &kCFTypeDictionaryKeyCallBacks,
+                                      &kCFTypeDictionaryValueCallBacks);
+        if (!dict)
+            continue;
+
+        CFNumberRef pageRef = CFNumberCreate(kCFAllocatorDefault,
+                                             kCFNumberLongType,
+                                             &page);
+        CFNumberRef usageRef = CFNumberCreate(kCFAllocatorDefault,
+                                              kCFNumberLongType,
+                                              &usages[i]);
+        if (pageRef && usageRef)
+        {
+            CFDictionarySetValue(dict,
+                                 CFSTR(kIOHIDDeviceUsagePageKey),
+                                 pageRef);
+            CFDictionarySetValue(dict,
+                                 CFSTR(kIOHIDDeviceUsageKey),
+                                 usageRef);
+            CFArrayAppendValue(matching, dict);
+        }
+
+        if (pageRef)
+            CFRelease(pageRef);
+        if (usageRef)
+            CFRelease(usageRef);
+
+        CFRelease(dict);
+    }
+
+    IOHIDManagerSetDeviceMatchingMultiple(_glfw.ns.hidManager, matching);
+    CFRelease(matching);
+
     IOHIDManagerRegisterDeviceMatchingCallback(_glfw.ns.hidManager,
                                                &matchCallback, NULL);
     IOHIDManagerRegisterDeviceRemovalCallback(_glfw.ns.hidManager,
                                               &removeCallback, NULL);
-
     IOHIDManagerScheduleWithRunLoop(_glfw.ns.hidManager,
                                     CFRunLoopGetMain(),
                                     kCFRunLoopDefaultMode);
-
     IOHIDManagerOpen(_glfw.ns.hidManager, kIOHIDOptionsTypeNone);
 
     // Execute the run loop once in order to register any initially-attached
@@ -456,13 +365,10 @@ void _glfwInitJoysticksNS(void)
 //
 void _glfwTerminateJoysticksNS(void)
 {
-    int joy;
+    int jid;
 
-    for (joy = GLFW_JOYSTICK_1;  joy <= GLFW_JOYSTICK_LAST;  joy++)
+    for (jid = 0;  jid <= GLFW_JOYSTICK_LAST;  jid++)
-    {
+        closeJoystick(_glfw.joysticks + jid);
-        _GLFWjoystickNS* js = _glfw.ns_js + joy;
-        removeJoystick(js);
-    }
 
     CFRelease(_glfw.ns.hidManager);
     _glfw.ns.hidManager = NULL;
@@ -473,39 +379,84 @@ void _glfwTerminateJoysticksNS(void)
 //////                       GLFW platform API                      //////
 //////////////////////////////////////////////////////////////////////////
 
-int _glfwPlatformJoystickPresent(int joy)
+int _glfwPlatformPollJoystick(_GLFWjoystick* js, int mode)
 {
-    _GLFWjoystickNS* js = _glfw.ns_js + joy;
+    if (mode & _GLFW_POLL_AXES)
+    {
+        CFIndex i;
+
+        for (i = 0;  i < CFArrayGetCount(js->ns.axes);  i++)
+        {
+            _GLFWjoyelementNS* axis = (_GLFWjoyelementNS*)
+                CFArrayGetValueAtIndex(js->ns.axes, i);
+
+            const long raw = getElementValue(js, axis);
+            // Perform auto calibration
+            if (raw < axis->minimum)
+                axis->minimum = raw;
+            if (raw > axis->maximum)
+                axis->maximum = raw;
+
+            const long delta = axis->maximum - axis->minimum;
+            if (delta == 0)
+                _glfwInputJoystickAxis(js, (int) i, 0.f);
+            else
+            {
+                const float value = (2.f * (raw - axis->minimum) / delta) - 1.f;
+                _glfwInputJoystickAxis(js, (int) i, value);
+            }
+        }
+    }
+
+    if (mode & _GLFW_POLL_BUTTONS)
+    {
+        CFIndex i;
+
+        for (i = 0;  i < CFArrayGetCount(js->ns.buttons);  i++)
+        {
+            _GLFWjoyelementNS* button = (_GLFWjoyelementNS*)
+                CFArrayGetValueAtIndex(js->ns.buttons, i);
+            const char value = getElementValue(js, button) - button->minimum;
+            _glfwInputJoystickButton(js, (int) i, value);
+        }
+
+        for (i = 0;  i < CFArrayGetCount(js->ns.hats);  i++)
+        {
+            const int states[9] =
+            {
+                GLFW_HAT_UP,
+                GLFW_HAT_RIGHT_UP,
+                GLFW_HAT_RIGHT,
+                GLFW_HAT_RIGHT_DOWN,
+                GLFW_HAT_DOWN,
+                GLFW_HAT_LEFT_DOWN,
+                GLFW_HAT_LEFT,
+                GLFW_HAT_LEFT_UP,
+                GLFW_HAT_CENTERED
+            };
+
+            _GLFWjoyelementNS* hat = (_GLFWjoyelementNS*)
+                CFArrayGetValueAtIndex(js->ns.hats, i);
+            long state = getElementValue(js, hat) - hat->minimum;
+            if (state < 0 || state > 8)
+                state = 8;
+
+            _glfwInputJoystickHat(js, (int) i, states[state]);
+        }
+    }
+
     return js->present;
 }
 
-const float* _glfwPlatformGetJoystickAxes(int joy, int* count)
+void _glfwPlatformUpdateGamepadGUID(char* guid)
 {
-    _GLFWjoystickNS* js = _glfw.ns_js + joy;
+    if ((strncmp(guid + 4, "000000000000", 12) == 0) &&
-    if (!pollJoystickAxisEvents(js))
+        (strncmp(guid + 20, "000000000000", 12) == 0))
-        return NULL;
+    {
-
+        char original[33];
-    *count = (int) CFArrayGetCount(js->axisElements);
+        strcpy(original, guid);
-    return js->axes;
+        sprintf(guid, "03000000%.4s0000%.4s000000000000",
-}
+                original, original + 16);
-
+    }
-const unsigned char* _glfwPlatformGetJoystickButtons(int joy, int* count)
-{
-    _GLFWjoystickNS* js = _glfw.ns_js + joy;
-    if (!pollJoystickButtonEvents(js))
-        return NULL;
-
-    *count = (int) CFArrayGetCount(js->buttonElements) +
-             (int) CFArrayGetCount(js->hatElements) * 4;
-    return js->buttons;
-}
-
-const char* _glfwPlatformGetJoystickName(int joy)
-{
-    _GLFWjoystickNS* js = _glfw.ns_js + joy;
-    if (!js->present)
-        return NULL;
-
-    return js->name;
 }
 

raylib/external/glfw/src/cocoa_monitor.m

@@ -1,8 +1,8 @@
 //========================================================================
-// GLFW 3.2 OS X - www.glfw.org
+// GLFW 3.3 macOS - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-2016 Camilla Berglund <elmindreda@glfw.org>
+// Copyright (c) 2006-2016 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
@@ -36,39 +36,80 @@
 #include <ApplicationServices/ApplicationServices.h>
 
 
-// Get the name of the specified display
+// Get the name of the specified display, or NULL
 //
 static char* getDisplayName(CGDirectDisplayID displayID)
 {
-    char* name;
+    io_iterator_t it;
-    CFDictionaryRef info, names;
+    io_service_t service;
-    CFStringRef value;
+    CFDictionaryRef info;
-    CFIndex size;
 
-    // NOTE: This uses a deprecated function because Apple has
+    if (IOServiceGetMatchingServices(kIOMasterPortDefault,
-    //       (as of January 2015) not provided any alternative
+                                     IOServiceMatching("IODisplayConnect"),
-    info = IODisplayCreateInfoDictionary(CGDisplayIOServicePort(displayID),
+                                     &it) != 0)
-                                         kIODisplayOnlyPreferredName);
-    names = CFDictionaryGetValue(info, CFSTR(kDisplayProductName));
-
-    if (!names || !CFDictionaryGetValueIfPresent(names, CFSTR("en_US"),
-                                                 (const void**) &value))
     {
         // This may happen if a desktop Mac is running headless
-        _glfwInputError(GLFW_PLATFORM_ERROR,
+        return NULL;
-                        "Cocoa: Failed to retrieve display name");
-
-        CFRelease(info);
-        return strdup("Unknown");
     }
 
-    size = CFStringGetMaximumSizeForEncoding(CFStringGetLength(value),
+    while ((service = IOIteratorNext(it)) != 0)
-                                             kCFStringEncodingUTF8);
+    {
-    name = calloc(size + 1, 1);
+        info = IODisplayCreateInfoDictionary(service,
-    CFStringGetCString(value, name, size, kCFStringEncodingUTF8);
+                                             kIODisplayOnlyPreferredName);
+
+        CFNumberRef vendorIDRef =
+            CFDictionaryGetValue(info, CFSTR(kDisplayVendorID));
+        CFNumberRef productIDRef =
+            CFDictionaryGetValue(info, CFSTR(kDisplayProductID));
+        if (!vendorIDRef || !productIDRef)
+        {
+            CFRelease(info);
+            continue;
+        }
+
+        unsigned int vendorID, productID;
+        CFNumberGetValue(vendorIDRef, kCFNumberIntType, &vendorID);
+        CFNumberGetValue(productIDRef, kCFNumberIntType, &productID);
+
+        if (CGDisplayVendorNumber(displayID) == vendorID &&
+            CGDisplayModelNumber(displayID) == productID)
+        {
+            // Info dictionary is used and freed below
+            break;
+        }
+
+        CFRelease(info);
+    }
+
+    IOObjectRelease(it);
+
+    if (!service)
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "Cocoa: Failed to find service port for display");
+        return NULL;
+    }
+
+    CFDictionaryRef names =
+        CFDictionaryGetValue(info, CFSTR(kDisplayProductName));
+
+    CFStringRef nameRef;
+
+    if (!names || !CFDictionaryGetValueIfPresent(names, CFSTR("en_US"),
+                                                 (const void**) &nameRef))
+    {
+        // This may happen if a desktop Mac is running headless
+        CFRelease(info);
+        return NULL;
+    }
+
+    const CFIndex size =
+        CFStringGetMaximumSizeForEncoding(CFStringGetLength(nameRef),
+                                          kCFStringEncodingUTF8);
+    char* name = calloc(size + 1, 1);
+    CFStringGetCString(nameRef, name, size, kCFStringEncodingUTF8);
 
     CFRelease(info);
-
     return name;
 }
 
@@ -77,15 +118,15 @@ static char* getDisplayName(CGDirectDisplayID displayID)
 static GLFWbool modeIsGood(CGDisplayModeRef mode)
 {
     uint32_t flags = CGDisplayModeGetIOFlags(mode);
+
     if (!(flags & kDisplayModeValidFlag) || !(flags & kDisplayModeSafeFlag))
         return GLFW_FALSE;
-
     if (flags & kDisplayModeInterlacedFlag)
         return GLFW_FALSE;
-
     if (flags & kDisplayModeStretchedFlag)
         return GLFW_FALSE;
 
+#if MAC_OS_X_VERSION_MAX_ALLOWED <= 101100
     CFStringRef format = CGDisplayModeCopyPixelEncoding(mode);
     if (CFStringCompare(format, CFSTR(IO16BitDirectPixels), 0) &&
         CFStringCompare(format, CFSTR(IO32BitDirectPixels), 0))
@@ -95,6 +136,7 @@ static GLFWbool modeIsGood(CGDisplayModeRef mode)
     }
 
     CFRelease(format);
+#endif /* MAC_OS_X_VERSION_MAX_ALLOWED */
     return GLFW_TRUE;
 }
 
@@ -115,8 +157,8 @@ static GLFWvidmode vidmodeFromCGDisplayMode(CGDisplayModeRef mode,
             result.refreshRate = (int) (time.timeScale / (double) time.timeValue);
     }
 
+#if MAC_OS_X_VERSION_MAX_ALLOWED <= 101100
     CFStringRef format = CGDisplayModeCopyPixelEncoding(mode);
-
     if (CFStringCompare(format, CFSTR(IO16BitDirectPixels), 0) == 0)
     {
         result.redBits = 5;
@@ -124,13 +166,16 @@ static GLFWvidmode vidmodeFromCGDisplayMode(CGDisplayModeRef mode,
         result.blueBits = 5;
     }
     else
+#endif /* MAC_OS_X_VERSION_MAX_ALLOWED */
     {
         result.redBits = 8;
         result.greenBits = 8;
         result.blueBits = 8;
     }
 
+#if MAC_OS_X_VERSION_MAX_ALLOWED <= 101100
     CFRelease(format);
+#endif /* MAC_OS_X_VERSION_MAX_ALLOWED */
     return result;
 }
 
@@ -141,7 +186,13 @@ static CGDisplayFadeReservationToken beginFadeReservation(void)
     CGDisplayFadeReservationToken token = kCGDisplayFadeReservationInvalidToken;
 
     if (CGAcquireDisplayFadeReservation(5, &token) == kCGErrorSuccess)
-        CGDisplayFade(token, 0.3, kCGDisplayBlendNormal, kCGDisplayBlendSolidColor, 0.0, 0.0, 0.0, TRUE);
+    {
+        CGDisplayFade(token, 0.3,
+                      kCGDisplayBlendNormal,
+                      kCGDisplayBlendSolidColor,
+                      0.0, 0.0, 0.0,
+                      TRUE);
+    }
 
     return token;
 }
@@ -152,7 +203,11 @@ static void endFadeReservation(CGDisplayFadeReservationToken token)
 {
     if (token != kCGDisplayFadeReservationInvalidToken)
     {
-        CGDisplayFade(token, 0.5, kCGDisplayBlendSolidColor, kCGDisplayBlendNormal, 0.0, 0.0, 0.0, FALSE);
+        CGDisplayFade(token, 0.5,
+                      kCGDisplayBlendSolidColor,
+                      kCGDisplayBlendNormal,
+                      0.0, 0.0, 0.0,
+                      FALSE);
         CGReleaseDisplayFadeReservation(token);
     }
 }
@@ -162,6 +217,74 @@ static void endFadeReservation(CGDisplayFadeReservationToken token)
 //////                       GLFW internal API                      //////
 //////////////////////////////////////////////////////////////////////////
 
+// Poll for changes in the set of connected monitors
+//
+void _glfwPollMonitorsNS(void)
+{
+    uint32_t i, j, displayCount, disconnectedCount;
+    CGDirectDisplayID* displays;
+    _GLFWmonitor** disconnected = NULL;
+
+    CGGetOnlineDisplayList(0, NULL, &displayCount);
+    displays = calloc(displayCount, sizeof(CGDirectDisplayID));
+    CGGetOnlineDisplayList(displayCount, displays, &displayCount);
+
+    for (i = 0;  i < _glfw.monitorCount;  i++)
+        _glfw.monitors[i]->ns.screen = nil;
+
+    disconnectedCount = _glfw.monitorCount;
+    if (disconnectedCount)
+    {
+        disconnected = calloc(_glfw.monitorCount, sizeof(_GLFWmonitor*));
+        memcpy(disconnected,
+               _glfw.monitors,
+               _glfw.monitorCount * sizeof(_GLFWmonitor*));
+    }
+
+    for (i = 0;  i < displayCount;  i++)
+    {
+        _GLFWmonitor* monitor;
+        const uint32_t unitNumber = CGDisplayUnitNumber(displays[i]);
+
+        if (CGDisplayIsAsleep(displays[i]))
+            continue;
+
+        for (j = 0;  j < disconnectedCount;  j++)
+        {
+            // HACK: Compare unit numbers instead of display IDs to work around
+            //       display replacement on machines with automatic graphics
+            //       switching
+            if (disconnected[j] && disconnected[j]->ns.unitNumber == unitNumber)
+            {
+                disconnected[j] = NULL;
+                break;
+            }
+        }
+
+        const CGSize size = CGDisplayScreenSize(displays[i]);
+        char* name = getDisplayName(displays[i]);
+        if (!name)
+            name = strdup("Unknown");
+
+        monitor = _glfwAllocMonitor(name, size.width, size.height);
+        monitor->ns.displayID  = displays[i];
+        monitor->ns.unitNumber = unitNumber;
+
+        free(name);
+
+        _glfwInputMonitor(monitor, GLFW_CONNECTED, _GLFW_INSERT_LAST);
+    }
+
+    for (i = 0;  i < disconnectedCount;  i++)
+    {
+        if (disconnected[i])
+            _glfwInputMonitor(disconnected[i], GLFW_DISCONNECTED, 0);
+    }
+
+    free(disconnected);
+    free(displays);
+}
+
 // Change the current video mode
 //
 GLFWbool _glfwSetVideoModeNS(_GLFWmonitor* monitor, const GLFWvidmode* desired)
@@ -241,53 +364,6 @@ void _glfwRestoreVideoModeNS(_GLFWmonitor* monitor)
 //////                       GLFW platform API                      //////
 //////////////////////////////////////////////////////////////////////////
 
-_GLFWmonitor** _glfwPlatformGetMonitors(int* count)
-{
-    uint32_t i, found = 0, displayCount;
-    _GLFWmonitor** monitors;
-    CGDirectDisplayID* displays;
-
-    *count = 0;
-
-    CGGetOnlineDisplayList(0, NULL, &displayCount);
-    displays = calloc(displayCount, sizeof(CGDirectDisplayID));
-    monitors = calloc(displayCount, sizeof(_GLFWmonitor*));
-
-    CGGetOnlineDisplayList(displayCount, displays, &displayCount);
-
-    for (i = 0;  i < displayCount;  i++)
-    {
-        _GLFWmonitor* monitor;
-
-        if (CGDisplayIsAsleep(displays[i]))
-            continue;
-
-        const CGSize size = CGDisplayScreenSize(displays[i]);
-        char* name = getDisplayName(displays[i]);
-
-        monitor = _glfwAllocMonitor(name, size.width, size.height);
-        monitor->ns.displayID  = displays[i];
-        monitor->ns.unitNumber = CGDisplayUnitNumber(displays[i]);
-
-        free(name);
-
-        found++;
-        monitors[found - 1] = monitor;
-    }
-
-    free(displays);
-
-    *count = found;
-    return monitors;
-}
-
-GLFWbool _glfwPlatformIsSameMonitor(_GLFWmonitor* first, _GLFWmonitor* second)
-{
-    // HACK: Compare unit numbers instead of display IDs to work around display
-    //       replacement on machines with automatic graphics switching
-    return first->ns.unitNumber == second->ns.unitNumber;
-}
-
 void _glfwPlatformGetMonitorPos(_GLFWmonitor* monitor, int* xpos, int* ypos)
 {
     const CGRect bounds = CGDisplayBounds(monitor->ns.displayID);
@@ -298,6 +374,48 @@ void _glfwPlatformGetMonitorPos(_GLFWmonitor* monitor, int* xpos, int* ypos)
         *ypos = (int) bounds.origin.y;
 }
 
+void _glfwPlatformGetMonitorContentScale(_GLFWmonitor* monitor,
+                                         float* xscale, float* yscale)
+{
+    if (!monitor->ns.screen)
+    {
+        NSUInteger i;
+        NSArray* screens = [NSScreen screens];
+
+        for (i = 0;  i < [screens count];  i++)
+        {
+            NSScreen* screen = [screens objectAtIndex:i];
+            NSNumber* displayID =
+                [[screen deviceDescription] objectForKey:@"NSScreenNumber"];
+
+            // HACK: Compare unit numbers instead of display IDs to work around
+            //       display replacement on machines with automatic graphics
+            //       switching
+            if (monitor->ns.unitNumber ==
+                CGDisplayUnitNumber([displayID unsignedIntValue]))
+            {
+                monitor->ns.screen = screen;
+                break;
+            }
+        }
+
+        if (i == [screens count])
+        {
+            _glfwInputError(GLFW_PLATFORM_ERROR,
+                            "Cocoa: Failed to find a screen for monitor");
+            return;
+        }
+    }
+
+    const NSRect points = [monitor->ns.screen frame];
+    const NSRect pixels = [monitor->ns.screen convertRectToBacking:points];
+
+    if (xscale)
+        *xscale = (float) (pixels.size.width / points.size.width);
+    if (yscale)
+        *yscale = (float) (pixels.size.height / points.size.height);
+}
+
 GLFWvidmode* _glfwPlatformGetVideoModes(_GLFWmonitor* monitor, int* count)
 {
     CFArrayRef modes;

raylib/external/glfw/src/cocoa_platform.h

@@ -1,7 +1,7 @@
 //========================================================================
-// GLFW 3.2 OS X - www.glfw.org
+// GLFW 3.3 macOS - www.glfw.org
 //------------------------------------------------------------------------
-// Copyright (c) 2009-2016 Camilla Berglund <elmindreda@glfw.org>
+// Copyright (c) 2009-2016 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
@@ -24,9 +24,6 @@
 //
 //========================================================================
 
-#ifndef _glfw3_cocoa_platform_h_
-#define _glfw3_cocoa_platform_h_
-
 #include <stdint.h>
 #include <dlfcn.h>
 
@@ -39,26 +36,39 @@
 typedef void* id;
 #endif
 
-#include "posix_tls.h"
+typedef VkFlags VkMacOSSurfaceCreateFlagsMVK;
+
+typedef struct VkMacOSSurfaceCreateInfoMVK
+{
+    VkStructureType                 sType;
+    const void*                     pNext;
+    VkMacOSSurfaceCreateFlagsMVK    flags;
+    const void*                     pView;
+} VkMacOSSurfaceCreateInfoMVK;
+
+typedef VkResult (APIENTRY *PFN_vkCreateMacOSSurfaceMVK)(VkInstance,const VkMacOSSurfaceCreateInfoMVK*,const VkAllocationCallbacks*,VkSurfaceKHR*);
+
+#include "posix_thread.h"
 #include "cocoa_joystick.h"
 #include "nsgl_context.h"
+#include "egl_context.h"
+#include "osmesa_context.h"
 
 #define _glfw_dlopen(name) dlopen(name, RTLD_LAZY | RTLD_LOCAL)
 #define _glfw_dlclose(handle) dlclose(handle)
 #define _glfw_dlsym(handle, name) dlsym(handle, name)
 
+#define _GLFW_EGL_NATIVE_WINDOW  ((EGLNativeWindowType) window->ns.view)
+#define _GLFW_EGL_NATIVE_DISPLAY EGL_DEFAULT_DISPLAY
+
 #define _GLFW_PLATFORM_WINDOW_STATE         _GLFWwindowNS  ns
 #define _GLFW_PLATFORM_LIBRARY_WINDOW_STATE _GLFWlibraryNS ns
-#define _GLFW_PLATFORM_LIBRARY_TIME_STATE   _GLFWtimeNS    ns_time
+#define _GLFW_PLATFORM_LIBRARY_TIMER_STATE  _GLFWtimerNS   ns
 #define _GLFW_PLATFORM_MONITOR_STATE        _GLFWmonitorNS ns
 #define _GLFW_PLATFORM_CURSOR_STATE         _GLFWcursorNS  ns
 
-#define _GLFW_EGL_CONTEXT_STATE
-#define _GLFW_EGL_LIBRARY_CONTEXT_STATE
-
 // HIToolbox.framework pointer typedefs
 #define kTISPropertyUnicodeKeyLayoutData _glfw.ns.tis.kPropertyUnicodeKeyLayoutData
-#define kTISNotifySelectedKeyboardInputSourceChanged _glfw.ns.tis.kNotifySelectedKeyboardInputSourceChanged
 typedef TISInputSourceRef (*PFN_TISCopyCurrentKeyboardLayoutInputSource)(void);
 #define TISCopyCurrentKeyboardLayoutInputSource _glfw.ns.tis.CopyCurrentKeyboardLayoutInputSource
 typedef void* (*PFN_TISGetInputSourceProperty)(TISInputSourceRef,CFStringRef);
@@ -74,6 +84,13 @@ typedef struct _GLFWwindowNS
     id              object;
     id              delegate;
     id              view;
+    id              layer;
+
+    GLFWbool        maximized;
+
+    // Cached window and framebuffer sizes used to filter out duplicate events
+    int             width, height;
+    int             fbWidth, fbHeight;
 
     // The total sum of the distances the cursor has been warped
     // since the last cursor motion event was processed
@@ -89,16 +106,17 @@ typedef struct _GLFWlibraryNS
     CGEventSourceRef    eventSource;
     id                  delegate;
     id                  autoreleasePool;
-    id                  cursor;
+    GLFWbool            cursorHidden;
     TISInputSourceRef   inputSource;
     IOHIDManagerRef     hidManager;
     id                  unicodeData;
     id                  listener;
 
     char                keyName[64];
-    short int           publicKeys[256];
+    short int           keycodes[256];
-    short int           nativeKeys[GLFW_KEY_LAST + 1];
+    short int           scancodes[GLFW_KEY_LAST + 1];
     char*               clipboardString;
+    CGPoint             cascadePoint;
     // Where to place the cursor when re-enabled
     double              restoreCursorPosX, restoreCursorPosY;
     // The window whose disabled cursor mode is active
@@ -110,7 +128,6 @@ typedef struct _GLFWlibraryNS
         PFN_TISGetInputSourceProperty GetInputSourceProperty;
         PFN_LMGetKbdType GetKbdType;
         CFStringRef     kPropertyUnicodeKeyLayoutData;
-        CFStringRef     kNotifySelectedKeyboardInputSourceChanged;
     } tis;
 
 } _GLFWlibraryNS;
@@ -122,6 +139,7 @@ typedef struct _GLFWmonitorNS
     CGDirectDisplayID   displayID;
     CGDisplayModeRef    previousMode;
     uint32_t            unitNumber;
+    id                  screen;
 
 } _GLFWmonitorNS;
 
@@ -135,16 +153,16 @@ typedef struct _GLFWcursorNS
 
 // Cocoa-specific global timer data
 //
-typedef struct _GLFWtimeNS
+typedef struct _GLFWtimerNS
 {
     uint64_t        frequency;
 
-} _GLFWtimeNS;
+} _GLFWtimerNS;
 
 
 void _glfwInitTimerNS(void);
 
+void _glfwPollMonitorsNS(void);
 GLFWbool _glfwSetVideoModeNS(_GLFWmonitor* monitor, const GLFWvidmode* desired);
 void _glfwRestoreVideoModeNS(_GLFWmonitor* monitor);
 
-#endif // _glfw3_cocoa_platform_h_

raylib/external/glfw/src/cocoa_time.c

@@ -1,7 +1,7 @@
 //========================================================================
-// GLFW 3.2 OS X - www.glfw.org
+// GLFW 3.3 macOS - www.glfw.org
 //------------------------------------------------------------------------
-// Copyright (c) 2009-2016 Camilla Berglund <elmindreda@glfw.org>
+// Copyright (c) 2009-2016 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
@@ -40,7 +40,7 @@ void _glfwInitTimerNS(void)
     mach_timebase_info_data_t info;
     mach_timebase_info(&info);
 
-    _glfw.ns_time.frequency = (info.denom * 1e9) / info.numer;
+    _glfw.timer.ns.frequency = (info.denom * 1e9) / info.numer;
 }
 
 
@@ -55,6 +55,6 @@ uint64_t _glfwPlatformGetTimerValue(void)
 
 uint64_t _glfwPlatformGetTimerFrequency(void)
 {
-    return _glfw.ns_time.frequency;
+    return _glfw.timer.ns.frequency;
 }
 

raylib/external/glfw/src/cocoa_window.m

@@ -1,7 +1,7 @@
 //========================================================================
-// GLFW 3.2 OS X - www.glfw.org
+// GLFW 3.3 macOS - www.glfw.org
 //------------------------------------------------------------------------
-// Copyright (c) 2009-2016 Camilla Berglund <elmindreda@glfw.org>
+// Copyright (c) 2009-2016 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
@@ -32,29 +32,23 @@
 // Needed for _NSGetProgname
 #include <crt_externs.h>
 
+// HACK: The 10.12 SDK adds new symbols and immediately deprecates the old ones
+#if MAC_OS_X_VERSION_MAX_ALLOWED < 101200
+ #define NSWindowStyleMaskBorderless NSBorderlessWindowMask
+ #define NSWindowStyleMaskClosable NSClosableWindowMask
+ #define NSWindowStyleMaskMiniaturizable NSMiniaturizableWindowMask
+ #define NSWindowStyleMaskResizable NSResizableWindowMask
+ #define NSWindowStyleMaskTitled NSTitledWindowMask
+ #define NSEventModifierFlagCommand NSCommandKeyMask
+ #define NSEventModifierFlagControl NSControlKeyMask
+ #define NSEventModifierFlagOption NSAlternateKeyMask
+ #define NSEventModifierFlagShift NSShiftKeyMask
+ #define NSEventModifierFlagDeviceIndependentFlagsMask NSDeviceIndependentModifierFlagsMask
+ #define NSEventMaskAny NSAnyEventMask
+ #define NSEventTypeApplicationDefined NSApplicationDefined
+ #define NSEventTypeKeyUp NSKeyUp
+#endif
 
-// Returns the specified standard cursor
-//
-static NSCursor* getStandardCursor(int shape)
-{
-    switch (shape)
-    {
-        case GLFW_ARROW_CURSOR:
-            return [NSCursor arrowCursor];
-        case GLFW_IBEAM_CURSOR:
-            return [NSCursor IBeamCursor];
-        case GLFW_CROSSHAIR_CURSOR:
-            return [NSCursor crosshairCursor];
-        case GLFW_HAND_CURSOR:
-            return [NSCursor pointingHandCursor];
-        case GLFW_HRESIZE_CURSOR:
-            return [NSCursor resizeLeftRightCursor];
-        case GLFW_VRESIZE_CURSOR:
-            return [NSCursor resizeUpDownCursor];
-    }
-
-    return nil;
-}
 
 // Returns the style mask corresponding to the window settings
 //
@@ -63,14 +57,15 @@ static NSUInteger getStyleMask(_GLFWwindow* window)
     NSUInteger styleMask = 0;
 
     if (window->monitor || !window->decorated)
-        styleMask |= NSBorderlessWindowMask;
+        styleMask |= NSWindowStyleMaskBorderless;
     else
     {
-        styleMask |= NSTitledWindowMask | NSClosableWindowMask |
+        styleMask |= NSWindowStyleMaskTitled |
-                     NSMiniaturizableWindowMask;
+                     NSWindowStyleMaskClosable |
+                     NSWindowStyleMaskMiniaturizable;
 
         if (window->resizable)
-            styleMask |= NSResizableWindowMask;
+            styleMask |= NSWindowStyleMaskResizable;
     }
 
     return styleMask;
@@ -93,19 +88,43 @@ static GLFWbool cursorInClientArea(_GLFWwindow* window)
     return [window->ns.view mouse:pos inRect:[window->ns.view frame]];
 }
 
+// Hides the cursor if not already hidden
+//
+static void hideCursor(_GLFWwindow* window)
+{
+    if (!_glfw.ns.cursorHidden)
+    {
+        [NSCursor hide];
+        _glfw.ns.cursorHidden = GLFW_TRUE;
+    }
+}
+
+// Shows the cursor if not already shown
+//
+static void showCursor(_GLFWwindow* window)
+{
+    if (_glfw.ns.cursorHidden)
+    {
+        [NSCursor unhide];
+        _glfw.ns.cursorHidden = GLFW_FALSE;
+    }
+}
+
 // Updates the cursor image according to its cursor mode
 //
 static void updateCursorImage(_GLFWwindow* window)
 {
     if (window->cursorMode == GLFW_CURSOR_NORMAL)
     {
+        showCursor(window);
+
         if (window->cursor)
             [(NSCursor*) window->cursor->ns.object set];
         else
             [[NSCursor arrowCursor] set];
     }
     else
-        [(NSCursor*) _glfw.ns.cursor set];
+        hideCursor(window);
 }
 
 // Transforms the specified y-coordinate between the CG display and NS screen
@@ -129,7 +148,7 @@ static GLFWbool acquireMonitor(_GLFWwindow* window)
 
     [window->ns.object setFrame:frame display:YES];
 
-    _glfwInputMonitorWindowChange(window->monitor, window);
+    _glfwInputMonitorWindow(window->monitor, window);
     return status;
 }
 
@@ -140,36 +159,36 @@ static void releaseMonitor(_GLFWwindow* window)
     if (window->monitor->window != window)
         return;
 
-    _glfwInputMonitorWindowChange(window->monitor, NULL);
+    _glfwInputMonitorWindow(window->monitor, NULL);
     _glfwRestoreVideoModeNS(window->monitor);
 }
 
-// Translates OS X key modifiers into GLFW ones
+// Translates macOS key modifiers into GLFW ones
 //
 static int translateFlags(NSUInteger flags)
 {
     int mods = 0;
 
-    if (flags & NSShiftKeyMask)
+    if (flags & NSEventModifierFlagShift)
         mods |= GLFW_MOD_SHIFT;
-    if (flags & NSControlKeyMask)
+    if (flags & NSEventModifierFlagControl)
         mods |= GLFW_MOD_CONTROL;
-    if (flags & NSAlternateKeyMask)
+    if (flags & NSEventModifierFlagOption)
         mods |= GLFW_MOD_ALT;
-    if (flags & NSCommandKeyMask)
+    if (flags & NSEventModifierFlagCommand)
         mods |= GLFW_MOD_SUPER;
 
     return mods;
 }
 
-// Translates a OS X keycode to a GLFW keycode
+// Translates a macOS keycode to a GLFW keycode
 //
 static int translateKey(unsigned int key)
 {
-    if (key >= sizeof(_glfw.ns.publicKeys) / sizeof(_glfw.ns.publicKeys[0]))
+    if (key >= sizeof(_glfw.ns.keycodes) / sizeof(_glfw.ns.keycodes[0]))
         return GLFW_KEY_UNKNOWN;
 
-    return _glfw.ns.publicKeys[key];
+    return _glfw.ns.keycodes[key];
 }
 
 // Translate a GLFW keycode to a Cocoa modifier flag
@@ -180,16 +199,16 @@ static NSUInteger translateKeyToModifierFlag(int key)
     {
         case GLFW_KEY_LEFT_SHIFT:
         case GLFW_KEY_RIGHT_SHIFT:
-            return NSShiftKeyMask;
+            return NSEventModifierFlagShift;
         case GLFW_KEY_LEFT_CONTROL:
         case GLFW_KEY_RIGHT_CONTROL:
-            return NSControlKeyMask;
+            return NSEventModifierFlagControl;
         case GLFW_KEY_LEFT_ALT:
         case GLFW_KEY_RIGHT_ALT:
-            return NSAlternateKeyMask;
+            return NSEventModifierFlagOption;
         case GLFW_KEY_LEFT_SUPER:
         case GLFW_KEY_RIGHT_SUPER:
-            return NSCommandKeyMask;
+            return NSEventModifierFlagCommand;
     }
 
     return 0;
@@ -209,13 +228,13 @@ static const NSRange kEmptyRange = { NSNotFound, 0 };
     _GLFWwindow* window;
 }
 
-- (id)initWithGlfwWindow:(_GLFWwindow *)initWindow;
+- (instancetype)initWithGlfwWindow:(_GLFWwindow *)initWindow;
 
 @end
 
 @implementation GLFWWindowDelegate
 
-- (id)initWithGlfwWindow:(_GLFWwindow *)initWindow
+- (instancetype)initWithGlfwWindow:(_GLFWwindow *)initWindow
 {
     self = [super init];
     if (self != nil)
@@ -238,11 +257,31 @@ static const NSRange kEmptyRange = { NSNotFound, 0 };
     if (_glfw.ns.disabledCursorWindow == window)
         centerCursor(window);
 
+    const int maximized = [window->ns.object isZoomed];
+    if (window->ns.maximized != maximized)
+    {
+        window->ns.maximized = maximized;
+        _glfwInputWindowMaximize(window, maximized);
+    }
+
     const NSRect contentRect = [window->ns.view frame];
     const NSRect fbRect = [window->ns.view convertRectToBacking:contentRect];
 
-    _glfwInputFramebufferSize(window, fbRect.size.width, fbRect.size.height);
+    if (fbRect.size.width != window->ns.fbWidth ||
-    _glfwInputWindowSize(window, contentRect.size.width, contentRect.size.height);
+        fbRect.size.height != window->ns.fbHeight)
+    {
+        window->ns.fbWidth  = fbRect.size.width;
+        window->ns.fbHeight = fbRect.size.height;
+        _glfwInputFramebufferSize(window, fbRect.size.width, fbRect.size.height);
+    }
+
+    if (contentRect.size.width != window->ns.width ||
+        contentRect.size.height != window->ns.height)
+    {
+        window->ns.width  = contentRect.size.width;
+        window->ns.height = contentRect.size.height;
+        _glfwInputWindowSize(window, contentRect.size.width, contentRect.size.height);
+    }
 }
 
 - (void)windowDidMove:(NSNotification *)notification
@@ -315,7 +354,15 @@ static const NSRange kEmptyRange = { NSNotFound, 0 };
 
 - (void)applicationDidChangeScreenParameters:(NSNotification *) notification
 {
-    _glfwInputMonitorChange();
+    _GLFWwindow* window;
+
+    for (window = _glfw.windowListHead;  window;  window = window->next)
+    {
+        if (window->context.client != GLFW_NO_API)
+            [window->context.nsgl.object update];
+    }
+
+    _glfwPollMonitorsNS();
 }
 
 - (void)applicationDidFinishLaunching:(NSNotification *)notification
@@ -347,27 +394,13 @@ static const NSRange kEmptyRange = { NSNotFound, 0 };
     NSMutableAttributedString* markedText;
 }
 
-- (id)initWithGlfwWindow:(_GLFWwindow *)initWindow;
+- (instancetype)initWithGlfwWindow:(_GLFWwindow *)initWindow;
 
 @end
 
 @implementation GLFWContentView
 
-+ (void)initialize
+- (instancetype)initWithGlfwWindow:(_GLFWwindow *)initWindow
-{
-    if (self == [GLFWContentView class])
-    {
-        if (_glfw.ns.cursor == nil)
-        {
-            NSImage* data = [[NSImage alloc] initWithSize:NSMakeSize(16, 16)];
-            _glfw.ns.cursor = [[NSCursor alloc] initWithImage:data
-                                                      hotSpot:NSZeroPoint];
-            [data release];
-        }
-    }
-}
-
-- (id)initWithGlfwWindow:(_GLFWwindow *)initWindow
 {
     self = [super init];
     if (self != nil)
@@ -393,7 +426,7 @@ static const NSRange kEmptyRange = { NSNotFound, 0 };
 
 - (BOOL)isOpaque
 {
-    return YES;
+    return [window->ns.object isOpaque];
 }
 
 - (BOOL)canBecomeKeyView
@@ -406,6 +439,19 @@ static const NSRange kEmptyRange = { NSNotFound, 0 };
     return YES;
 }
 
+- (BOOL)wantsUpdateLayer
+{
+    return YES;
+}
+
+- (id)makeBackingLayer
+{
+    if (window->ns.layer)
+        return window->ns.layer;
+
+    return [super makeBackingLayer];
+}
+
 - (void)cursorUpdate:(NSEvent *)event
 {
     updateCursorImage(window);
@@ -499,11 +545,17 @@ static const NSRange kEmptyRange = { NSNotFound, 0 };
 
 - (void)mouseExited:(NSEvent *)event
 {
+    if (window->cursorMode == GLFW_CURSOR_HIDDEN)
+        showCursor(window);
+
     _glfwInputCursorEnter(window, GLFW_FALSE);
 }
 
 - (void)mouseEntered:(NSEvent *)event
 {
+    if (window->cursorMode == GLFW_CURSOR_HIDDEN)
+        hideCursor(window);
+
     _glfwInputCursorEnter(window, GLFW_TRUE);
 }
 
@@ -512,7 +564,13 @@ static const NSRange kEmptyRange = { NSNotFound, 0 };
     const NSRect contentRect = [window->ns.view frame];
     const NSRect fbRect = [window->ns.view convertRectToBacking:contentRect];
 
-    _glfwInputFramebufferSize(window, fbRect.size.width, fbRect.size.height);
+    if (fbRect.size.width != window->ns.fbWidth ||
+        fbRect.size.height != window->ns.fbHeight)
+    {
+        window->ns.fbWidth  = fbRect.size.width;
+        window->ns.fbHeight = fbRect.size.height;
+        _glfwInputFramebufferSize(window, fbRect.size.width, fbRect.size.height);
+    }
 }
 
 - (void)drawRect:(NSRect)rect
@@ -558,7 +616,7 @@ static const NSRange kEmptyRange = { NSNotFound, 0 };
 {
     int action;
     const unsigned int modifierFlags =
-        [event modifierFlags] & NSDeviceIndependentModifierFlagsMask;
+        [event modifierFlags] & NSEventModifierFlagDeviceIndependentFlagsMask;
     const int key = translateKey([event keyCode]);
     const int mods = translateFlags(modifierFlags);
     const NSUInteger keyFlag = translateKeyToModifierFlag(key);
@@ -628,17 +686,17 @@ static const NSRange kEmptyRange = { NSNotFound, 0 };
                         [sender draggingLocation].x,
                         contentRect.size.height - [sender draggingLocation].y);
 
-    const int count = [files count];
+    const NSUInteger count = [files count];
     if (count)
     {
         NSEnumerator* e = [files objectEnumerator];
         char** paths = calloc(count, sizeof(char*));
-        int i;
+        NSUInteger i;
 
         for (i = 0;  i < count;  i++)
             paths[i] = strdup([[e nextObject] UTF8String]);
 
-        _glfwInputDrop(window, count, (const char**) paths);
+        _glfwInputDrop(window, (int) count, (const char**) paths);
 
         for (i = 0;  i < count;  i++)
             free(paths[i]);
@@ -675,10 +733,11 @@ static const NSRange kEmptyRange = { NSNotFound, 0 };
         selectedRange:(NSRange)selectedRange
      replacementRange:(NSRange)replacementRange
 {
+    [markedText release];
     if ([string isKindOfClass:[NSAttributedString class]])
-        [markedText initWithAttributedString:string];
+        markedText = [[NSMutableAttributedString alloc] initWithAttributedString:string];
     else
-        [markedText initWithString:string];
+        markedText = [[NSMutableAttributedString alloc] initWithString:string];
 }
 
 - (void)unmarkText
@@ -753,7 +812,12 @@ static const NSRange kEmptyRange = { NSNotFound, 0 };
 
 - (BOOL)canBecomeKeyWindow
 {
-    // Required for NSBorderlessWindowMask windows
+    // Required for NSWindowStyleMaskBorderless windows
+    return YES;
+}
+
+- (BOOL)canBecomeMainWindow
+{
     return YES;
 }
 
@@ -765,6 +829,10 @@ static const NSRange kEmptyRange = { NSNotFound, 0 };
 //------------------------------------------------------------------------
 
 @interface GLFWApplication : NSApplication
+{
+    NSArray* nibObjects;
+}
+
 @end
 
 @implementation GLFWApplication
@@ -774,8 +842,11 @@ static const NSRange kEmptyRange = { NSNotFound, 0 };
 // down the command key don't get sent to the key window.
 - (void)sendEvent:(NSEvent *)event
 {
-    if ([event type] == NSKeyUp && ([event modifierFlags] & NSCommandKeyMask))
+    if ([event type] == NSEventTypeKeyUp &&
+        ([event modifierFlags] & NSEventModifierFlagCommand))
+    {
         [[self keyWindow] sendEvent:event];
+    }
     else
         [super sendEvent:event];
 }
@@ -786,53 +857,58 @@ static const NSRange kEmptyRange = { NSNotFound, 0 };
 - (void)doNothing:(id)object
 {
 }
+
+- (void)loadMainMenu
+{
+#if MAC_OS_X_VERSION_MAX_ALLOWED >= 100800
+    [[NSBundle mainBundle] loadNibNamed:@"MainMenu"
+                                  owner:NSApp
+                        topLevelObjects:&nibObjects];
+#else
+    [[NSBundle mainBundle] loadNibNamed:@"MainMenu" owner:NSApp];
+#endif
+}
 @end
 
-#if defined(_GLFW_USE_MENUBAR)
+// Set up the menu bar (manually)
-
+// This is nasty, nasty stuff -- calls to undocumented semi-private APIs that
-// Try to figure out what the calling application is called
+// could go away at any moment, lots of stuff that really should be
+// localize(d|able), etc.  Add a nib to save us this horror.
 //
-static NSString* findAppName(void)
+static void createMenuBar(void)
 {
     size_t i;
-    NSDictionary* infoDictionary = [[NSBundle mainBundle] infoDictionary];
+    NSString* appName = nil;
-
+    NSDictionary* bundleInfo = [[NSBundle mainBundle] infoDictionary];
-    // Keys to search for as potential application names
+    NSString* nameKeys[] =
-    NSString* GLFWNameKeys[] =
     {
         @"CFBundleDisplayName",
         @"CFBundleName",
         @"CFBundleExecutable",
     };
 
-    for (i = 0;  i < sizeof(GLFWNameKeys) / sizeof(GLFWNameKeys[0]);  i++)
+    // Try to figure out what the calling application is called
+
+    for (i = 0;  i < sizeof(nameKeys) / sizeof(nameKeys[0]);  i++)
     {
-        id name = [infoDictionary objectForKey:GLFWNameKeys[i]];
+        id name = [bundleInfo objectForKey:nameKeys[i]];
         if (name &&
             [name isKindOfClass:[NSString class]] &&
             ![name isEqualToString:@""])
         {
-            return name;
+            appName = name;
+            break;
         }
     }
 
-    char** progname = _NSGetProgname();
+    if (!appName)
-    if (progname && *progname)
+    {
-        return [NSString stringWithUTF8String:*progname];
+        char** progname = _NSGetProgname();
-
+        if (progname && *progname)
-    // Really shouldn't get here
+            appName = [NSString stringWithUTF8String:*progname];
-    return @"GLFW Application";
+        else
-}
+            appName = @"GLFW Application";
-
+    }
-// Set up the menu bar (manually)
-// This is nasty, nasty stuff -- calls to undocumented semi-private APIs that
-// could go away at any moment, lots of stuff that really should be
-// localize(d|able), etc.  Loading a nib would save us this horror, but that
-// doesn't seem like a good thing to require of GLFW users.
-//
-static void createMenuBar(void)
-{
-    NSString* appName = findAppName();
 
     NSMenu* bar = [[NSMenu alloc] init];
     [NSApp setMainMenu:bar];
@@ -859,7 +935,7 @@ static void createMenuBar(void)
     [[appMenu addItemWithTitle:@"Hide Others"
                        action:@selector(hideOtherApplications:)
                 keyEquivalent:@"h"]
-        setKeyEquivalentModifierMask:NSAlternateKeyMask | NSCommandKeyMask];
+        setKeyEquivalentModifierMask:NSEventModifierFlagOption | NSEventModifierFlagCommand];
     [appMenu addItemWithTitle:@"Show All"
                        action:@selector(unhideAllApplications:)
                 keyEquivalent:@""];
@@ -891,7 +967,7 @@ static void createMenuBar(void)
     [[windowMenu addItemWithTitle:@"Enter Full Screen"
                            action:@selector(toggleFullScreen:)
                     keyEquivalent:@"f"]
-     setKeyEquivalentModifierMask:NSControlKeyMask | NSCommandKeyMask];
+     setKeyEquivalentModifierMask:NSEventModifierFlagControl | NSEventModifierFlagCommand];
 
     // Prior to Snow Leopard, we need to use this oddly-named semi-private API
     // to get the application menu working properly.
@@ -899,8 +975,6 @@ static void createMenuBar(void)
     [NSApp performSelector:setAppleMenuSelector withObject:appMenu];
 }
 
-#endif /* _GLFW_USE_MENUBAR */
-
 // Initialize the Cocoa Application Kit
 //
 static GLFWbool initializeAppKit(void)
@@ -916,15 +990,20 @@ static GLFWbool initializeAppKit(void)
                              toTarget:NSApp
                            withObject:nil];
 
-    // In case we are unbundled, make us a proper UI application
+    if (_glfw.hints.init.ns.menubar)
-    [NSApp setActivationPolicy:NSApplicationActivationPolicyRegular];
+    {
+        // In case we are unbundled, make us a proper UI application
+        [NSApp setActivationPolicy:NSApplicationActivationPolicyRegular];
 
-#if defined(_GLFW_USE_MENUBAR)
+        // Menu bar setup must go between sharedApplication above and
-    // Menu bar setup must go between sharedApplication above and
+        // finishLaunching below, in order to properly emulate the behavior
-    // finishLaunching below, in order to properly emulate the behavior
+        // of NSApplicationMain
-    // of NSApplicationMain
+
-    createMenuBar();
+        if ([[NSBundle mainBundle] pathForResource:@"MainMenu" ofType:@"nib"])
-#endif
+            [NSApp loadMainMenu];
+        else
+            createMenuBar();
+    }
 
     // There can only be one application delegate, but we allocate it the
     // first time a window is created to keep all window code in this file
@@ -939,13 +1018,21 @@ static GLFWbool initializeAppKit(void)
     [NSApp setDelegate:_glfw.ns.delegate];
     [NSApp run];
 
+    // Press and Hold prevents some keys from emitting repeated characters
+    NSDictionary* defaults =
+        [NSDictionary dictionaryWithObjectsAndKeys:[NSNumber numberWithBool:NO],
+                                                   @"ApplePressAndHoldEnabled",
+                                                   nil];
+    [[NSUserDefaults standardUserDefaults] registerDefaults:defaults];
+
     return GLFW_TRUE;
 }
 
 // Create the Cocoa window
 //
 static GLFWbool createNativeWindow(_GLFWwindow* window,
-                                   const _GLFWwndconfig* wndconfig)
+                                   const _GLFWwndconfig* wndconfig,
+                                   const _GLFWfbconfig* fbconfig)
 {
     window->ns.delegate = [[GLFWWindowDelegate alloc] initWithGlfwWindow:window];
     if (window->ns.delegate == nil)
@@ -987,9 +1074,17 @@ static GLFWbool createNativeWindow(_GLFWwindow* window,
     else
     {
         [window->ns.object center];
+        _glfw.ns.cascadePoint =
+            NSPointToCGPoint([window->ns.object cascadeTopLeftFromPoint:
+                              NSPointFromCGPoint(_glfw.ns.cascadePoint)]);
 
         if (wndconfig->resizable)
-            [window->ns.object setCollectionBehavior:NSWindowCollectionBehaviorFullScreenPrimary];
+        {
+            const NSWindowCollectionBehavior behavior =
+                NSWindowCollectionBehaviorFullScreenPrimary |
+                NSWindowCollectionBehaviorManaged;
+            [window->ns.object setCollectionBehavior:behavior];
+        }
 
         if (wndconfig->floating)
             [window->ns.object setLevel:NSFloatingWindowLevel];
@@ -998,19 +1093,30 @@ static GLFWbool createNativeWindow(_GLFWwindow* window,
             [window->ns.object zoom:nil];
     }
 
+    if (wndconfig->ns.frame)
+        [window->ns.object setFrameAutosaveName:[NSString stringWithUTF8String:wndconfig->title]];
+
     window->ns.view = [[GLFWContentView alloc] initWithGlfwWindow:window];
 
-#if defined(_GLFW_USE_RETINA)
+    if (wndconfig->ns.retina)
-    [window->ns.view setWantsBestResolutionOpenGLSurface:YES];
+        [window->ns.view setWantsBestResolutionOpenGLSurface:YES];
-#endif /*_GLFW_USE_RETINA*/
 
+    if (fbconfig->transparent)
+    {
+        [window->ns.object setOpaque:NO];
+        [window->ns.object setBackgroundColor:[NSColor clearColor]];
+    }
+
+    [window->ns.object setContentView:window->ns.view];
     [window->ns.object makeFirstResponder:window->ns.view];
     [window->ns.object setTitle:[NSString stringWithUTF8String:wndconfig->title]];
     [window->ns.object setDelegate:window->ns.delegate];
     [window->ns.object setAcceptsMouseMovedEvents:YES];
-    [window->ns.object setContentView:window->ns.view];
     [window->ns.object setRestorable:NO];
 
+    _glfwPlatformGetWindowSize(window, &window->ns.width, &window->ns.height);
+    _glfwPlatformGetFramebufferSize(window, &window->ns.fbWidth, &window->ns.fbHeight);
+
     return GLFW_TRUE;
 }
 
@@ -1027,7 +1133,7 @@ int _glfwPlatformCreateWindow(_GLFWwindow* window,
     if (!initializeAppKit())
         return GLFW_FALSE;
 
-    if (!createNativeWindow(window, wndconfig))
+    if (!createNativeWindow(window, wndconfig, fbconfig))
         return GLFW_FALSE;
 
     if (ctxconfig->client != GLFW_NO_API)
@@ -1039,10 +1145,19 @@ int _glfwPlatformCreateWindow(_GLFWwindow* window,
             if (!_glfwCreateContextNSGL(window, ctxconfig, fbconfig))
                 return GLFW_FALSE;
         }
-        else
+        else if (ctxconfig->source == GLFW_EGL_CONTEXT_API)
         {
-            _glfwInputError(GLFW_API_UNAVAILABLE, "Cocoa: EGL not available");
+            if (!_glfwInitEGL())
-            return GLFW_FALSE;
+                return GLFW_FALSE;
+            if (!_glfwCreateContextEGL(window, ctxconfig, fbconfig))
+                return GLFW_FALSE;
+        }
+        else if (ctxconfig->source == GLFW_OSMESA_CONTEXT_API)
+        {
+            if (!_glfwInitOSMesa())
+                return GLFW_FALSE;
+            if (!_glfwCreateContextOSMesa(window, ctxconfig, fbconfig))
+                return GLFW_FALSE;
         }
     }
 
@@ -1053,7 +1168,8 @@ int _glfwPlatformCreateWindow(_GLFWwindow* window,
         if (!acquireMonitor(window))
             return GLFW_FALSE;
 
-        centerCursor(window);
+        if (wndconfig->centerCursor)
+            centerCursor(window);
     }
 
     return GLFW_TRUE;
@@ -1088,7 +1204,11 @@ void _glfwPlatformDestroyWindow(_GLFWwindow* window)
 
 void _glfwPlatformSetWindowTitle(_GLFWwindow* window, const char *title)
 {
-    [window->ns.object setTitle:[NSString stringWithUTF8String:title]];
+    NSString* string = [NSString stringWithUTF8String:title];
+    [window->ns.object setTitle:string];
+    // HACK: Set the miniwindow title explicitly as setTitle: doesn't update it
+    //       if the window lacks NSWindowStyleMaskTitled
+    [window->ns.object setMiniwindowTitle:string];
 }
 
 void _glfwPlatformSetWindowIcon(_GLFWwindow* window,
@@ -1155,7 +1275,7 @@ void _glfwPlatformSetWindowSizeLimits(_GLFWwindow* window,
 void _glfwPlatformSetWindowAspectRatio(_GLFWwindow* window, int numer, int denom)
 {
     if (numer == GLFW_DONT_CARE || denom == GLFW_DONT_CARE)
-        [window->ns.object setContentAspectRatio:NSMakeSize(0, 0)];
+        [window->ns.object setResizeIncrements:NSMakeSize(1.0, 1.0)];
     else
         [window->ns.object setContentAspectRatio:NSMakeSize(numer, denom)];
 }
@@ -1190,6 +1310,18 @@ void _glfwPlatformGetWindowFrameSize(_GLFWwindow* window,
         *bottom = contentRect.origin.y - frameRect.origin.y;
 }
 
+void _glfwPlatformGetWindowContentScale(_GLFWwindow* window,
+                                        float* xscale, float* yscale)
+{
+    const NSRect points = [window->ns.view frame];
+    const NSRect pixels = [window->ns.view convertRectToBacking:points];
+
+    if (xscale)
+        *xscale = (float) (pixels.size.width / points.size.width);
+    if (yscale)
+        *yscale = (float) (pixels.size.height / points.size.height);
+}
+
 void _glfwPlatformIconifyWindow(_GLFWwindow* window)
 {
     [window->ns.object miniaturize:nil];
@@ -1219,6 +1351,11 @@ void _glfwPlatformHideWindow(_GLFWwindow* window)
     [window->ns.object orderOut:nil];
 }
 
+void _glfwPlatformRequestWindowAttention(_GLFWwindow* window)
+{
+    [NSApp requestUserAttention:NSInformationalRequest];
+}
+
 void _glfwPlatformFocusWindow(_GLFWwindow* window)
 {
     // Make us the active application
@@ -1260,34 +1397,16 @@ void _glfwPlatformSetWindowMonitor(_GLFWwindow* window,
     if (window->monitor)
         releaseMonitor(window);
 
-    _glfwInputWindowMonitorChange(window, monitor);
+    _glfwInputWindowMonitor(window, monitor);
+
+    // HACK: Allow the state cached in Cocoa to catch up to reality
+    // TODO: Solve this in a less terrible way
+    _glfwPlatformPollEvents();
 
     const NSUInteger styleMask = getStyleMask(window);
     [window->ns.object setStyleMask:styleMask];
     [window->ns.object makeFirstResponder:window->ns.view];
 
-    NSRect contentRect;
-
-    if (monitor)
-    {
-        GLFWvidmode mode;
-
-        _glfwPlatformGetVideoMode(window->monitor, &mode);
-        _glfwPlatformGetMonitorPos(window->monitor, &xpos, &ypos);
-
-        contentRect = NSMakeRect(xpos, transformY(ypos + mode.height),
-                                    mode.width, mode.height);
-    }
-    else
-    {
-        contentRect = NSMakeRect(xpos, transformY(ypos + height),
-                                    width, height);
-    }
-
-    NSRect frameRect = [window->ns.object frameRectForContentRect:contentRect
-                                                        styleMask:styleMask];
-    [window->ns.object setFrame:frameRect display:YES];
-
     if (monitor)
     {
         [window->ns.object setLevel:NSMainMenuWindowLevel + 1];
@@ -1297,6 +1416,12 @@ void _glfwPlatformSetWindowMonitor(_GLFWwindow* window,
     }
     else
     {
+        NSRect contentRect = NSMakeRect(xpos, transformY(ypos + height),
+                                        width, height);
+        NSRect frameRect = [window->ns.object frameRectForContentRect:contentRect
+                                                            styleMask:styleMask];
+        [window->ns.object setFrame:frameRect display:YES];
+
         if (window->numer != GLFW_DONT_CARE &&
             window->denom != GLFW_DONT_CARE)
         {
@@ -1324,6 +1449,9 @@ void _glfwPlatformSetWindowMonitor(_GLFWwindow* window,
             [window->ns.object setLevel:NSNormalWindowLevel];
 
         [window->ns.object setHasShadow:YES];
+        // HACK: Clearing NSWindowStyleMaskTitled resets and disables the window
+        //       title property but the miniwindow title property is unaffected
+        [window->ns.object setTitle:[window->ns.object miniwindowTitle]];
     }
 }
 
@@ -1347,11 +1475,45 @@ int _glfwPlatformWindowMaximized(_GLFWwindow* window)
     return [window->ns.object isZoomed];
 }
 
+int _glfwPlatformFramebufferTransparent(_GLFWwindow* window)
+{
+    return ![window->ns.object isOpaque] && ![window->ns.view isOpaque];
+}
+
+void _glfwPlatformSetWindowResizable(_GLFWwindow* window, GLFWbool enabled)
+{
+    [window->ns.object setStyleMask:getStyleMask(window)];
+}
+
+void _glfwPlatformSetWindowDecorated(_GLFWwindow* window, GLFWbool enabled)
+{
+    [window->ns.object setStyleMask:getStyleMask(window)];
+    [window->ns.object makeFirstResponder:window->ns.view];
+}
+
+void _glfwPlatformSetWindowFloating(_GLFWwindow* window, GLFWbool enabled)
+{
+    if (enabled)
+        [window->ns.object setLevel:NSFloatingWindowLevel];
+    else
+        [window->ns.object setLevel:NSNormalWindowLevel];
+}
+
+float _glfwPlatformGetWindowOpacity(_GLFWwindow* window)
+{
+    return (float) [window->ns.object alphaValue];
+}
+
+void _glfwPlatformSetWindowOpacity(_GLFWwindow* window, float opacity)
+{
+    [window->ns.object setAlphaValue:opacity];
+}
+
 void _glfwPlatformPollEvents(void)
 {
     for (;;)
     {
-        NSEvent* event = [NSApp nextEventMatchingMask:NSAnyEventMask
+        NSEvent* event = [NSApp nextEventMatchingMask:NSEventMaskAny
                                             untilDate:[NSDate distantPast]
                                                inMode:NSDefaultRunLoopMode
                                               dequeue:YES];
@@ -1370,7 +1532,7 @@ void _glfwPlatformWaitEvents(void)
     // I wanted to pass NO to dequeue:, and rely on PollEvents to
     // dequeue and send.  For reasons not at all clear to me, passing
     // NO to dequeue: causes this method never to return.
-    NSEvent *event = [NSApp nextEventMatchingMask:NSAnyEventMask
+    NSEvent *event = [NSApp nextEventMatchingMask:NSEventMaskAny
                                         untilDate:[NSDate distantFuture]
                                            inMode:NSDefaultRunLoopMode
                                           dequeue:YES];
@@ -1382,7 +1544,7 @@ void _glfwPlatformWaitEvents(void)
 void _glfwPlatformWaitEventsTimeout(double timeout)
 {
     NSDate* date = [NSDate dateWithTimeIntervalSinceNow:timeout];
-    NSEvent* event = [NSApp nextEventMatchingMask:NSAnyEventMask
+    NSEvent* event = [NSApp nextEventMatchingMask:NSEventMaskAny
                                         untilDate:date
                                            inMode:NSDefaultRunLoopMode
                                           dequeue:YES];
@@ -1395,7 +1557,7 @@ void _glfwPlatformWaitEventsTimeout(double timeout)
 void _glfwPlatformPostEmptyEvent(void)
 {
     NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
-    NSEvent* event = [NSEvent otherEventWithType:NSApplicationDefined
+    NSEvent* event = [NSEvent otherEventWithType:NSEventTypeApplicationDefined
                                         location:NSMakePoint(0, 0)
                                    modifierFlags:0
                                        timestamp:0
@@ -1469,14 +1631,8 @@ void _glfwPlatformSetCursorMode(_GLFWwindow* window, int mode)
         updateCursorImage(window);
 }
 
-const char* _glfwPlatformGetKeyName(int key, int scancode)
+const char* _glfwPlatformGetScancodeName(int scancode)
 {
-    if (key != GLFW_KEY_UNKNOWN)
-        scancode = _glfw.ns.nativeKeys[key];
-
-    if (!_glfwIsPrintable(_glfw.ns.publicKeys[scancode]))
-        return NULL;
-
     UInt32 deadKeyState = 0;
     UniChar characters[8];
     UniCharCount characterCount = 0;
@@ -1511,6 +1667,11 @@ const char* _glfwPlatformGetKeyName(int key, int scancode)
     return _glfw.ns.keyName;
 }
 
+int _glfwPlatformGetKeyScancode(int key)
+{
+    return _glfw.ns.scancodes[key];
+}
+
 int _glfwPlatformCreateCursor(_GLFWcursor* cursor,
                               const GLFWimage* image,
                               int xhot, int yhot)
@@ -1559,7 +1720,19 @@ int _glfwPlatformCreateStandardCursor(_GLFWcursor* cursor, int shape)
     if (!initializeAppKit())
         return GLFW_FALSE;
 
-    cursor->ns.object = getStandardCursor(shape);
+    if (shape == GLFW_ARROW_CURSOR)
+        cursor->ns.object = [NSCursor arrowCursor];
+    else if (shape == GLFW_IBEAM_CURSOR)
+        cursor->ns.object = [NSCursor IBeamCursor];
+    else if (shape == GLFW_CROSSHAIR_CURSOR)
+        cursor->ns.object = [NSCursor crosshairCursor];
+    else if (shape == GLFW_HAND_CURSOR)
+        cursor->ns.object = [NSCursor pointingHandCursor];
+    else if (shape == GLFW_HRESIZE_CURSOR)
+        cursor->ns.object = [NSCursor resizeLeftRightCursor];
+    else if (shape == GLFW_VRESIZE_CURSOR)
+        cursor->ns.object = [NSCursor resizeUpDownCursor];
+
     if (!cursor->ns.object)
     {
         _glfwInputError(GLFW_PLATFORM_ERROR,
@@ -1583,7 +1756,7 @@ void _glfwPlatformSetCursor(_GLFWwindow* window, _GLFWcursor* cursor)
         updateCursorImage(window);
 }
 
-void _glfwPlatformSetClipboardString(_GLFWwindow* window, const char* string)
+void _glfwPlatformSetClipboardString(const char* string)
 {
     NSArray* types = [NSArray arrayWithObjects:NSStringPboardType, nil];
 
@@ -1593,7 +1766,7 @@ void _glfwPlatformSetClipboardString(_GLFWwindow* window, const char* string)
                   forType:NSStringPboardType];
 }
 
-const char* _glfwPlatformGetClipboardString(_GLFWwindow* window)
+const char* _glfwPlatformGetClipboardString(void)
 {
     NSPasteboard* pasteboard = [NSPasteboard generalPasteboard];
 
@@ -1618,17 +1791,20 @@ const char* _glfwPlatformGetClipboardString(_GLFWwindow* window)
     return _glfw.ns.clipboardString;
 }
 
-char** _glfwPlatformGetRequiredInstanceExtensions(uint32_t* count)
+void _glfwPlatformGetRequiredInstanceExtensions(char** extensions)
 {
-    *count = 0;
+    if (!_glfw.vk.KHR_surface || !_glfw.vk.MVK_macos_surface)
-    return NULL;
+        return;
+
+    extensions[0] = "VK_KHR_surface";
+    extensions[1] = "VK_MVK_macos_surface";
 }
 
 int _glfwPlatformGetPhysicalDevicePresentationSupport(VkInstance instance,
                                                       VkPhysicalDevice device,
                                                       uint32_t queuefamily)
 {
-    return GLFW_FALSE;
+    return GLFW_TRUE;
 }
 
 VkResult _glfwPlatformCreateWindowSurface(VkInstance instance,
@@ -1636,7 +1812,57 @@ VkResult _glfwPlatformCreateWindowSurface(VkInstance instance,
                                           const VkAllocationCallbacks* allocator,
                                           VkSurfaceKHR* surface)
 {
+#if MAC_OS_X_VERSION_MAX_ALLOWED >= 101100
+    VkResult err;
+    VkMacOSSurfaceCreateInfoMVK sci;
+    PFN_vkCreateMacOSSurfaceMVK vkCreateMacOSSurfaceMVK;
+
+    vkCreateMacOSSurfaceMVK = (PFN_vkCreateMacOSSurfaceMVK)
+        vkGetInstanceProcAddr(instance, "vkCreateMacOSSurfaceMVK");
+    if (!vkCreateMacOSSurfaceMVK)
+    {
+        _glfwInputError(GLFW_API_UNAVAILABLE,
+                        "Cocoa: Vulkan instance missing VK_MVK_macos_surface extension");
+        return VK_ERROR_EXTENSION_NOT_PRESENT;
+    }
+
+    // HACK: Dynamically load Core Animation to avoid adding an extra
+    //       dependency for the majority who don't use MoltenVK
+    NSBundle* bundle = [NSBundle bundleWithPath:@"/System/Library/Frameworks/QuartzCore.framework"];
+    if (!bundle)
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "Cocoa: Failed to find QuartzCore.framework");
+        return VK_ERROR_EXTENSION_NOT_PRESENT;
+    }
+
+    // NOTE: Create the layer here as makeBackingLayer should not return nil
+    window->ns.layer = [[bundle classNamed:@"CAMetalLayer"] layer];
+    if (!window->ns.layer)
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "Cocoa: Failed to create layer for view");
+        return VK_ERROR_EXTENSION_NOT_PRESENT;
+    }
+
+    [window->ns.view setWantsLayer:YES];
+
+    memset(&sci, 0, sizeof(sci));
+    sci.sType = VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK;
+    sci.pView = window->ns.view;
+
+    err = vkCreateMacOSSurfaceMVK(instance, &sci, allocator, surface);
+    if (err)
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "Cocoa: Failed to create Vulkan surface: %s",
+                        _glfwGetVulkanResultString(err));
+    }
+
+    return err;
+#else
     return VK_ERROR_EXTENSION_NOT_PRESENT;
+#endif
 }
 
 

raylib/external/glfw/src/context.c

@@ -1,8 +1,8 @@
 //========================================================================
-// GLFW 3.2 - www.glfw.org
+// GLFW 3.3 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-2016 Camilla Berglund <elmindreda@glfw.org>
+// Copyright (c) 2006-2016 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
@@ -41,10 +41,11 @@
 GLFWbool _glfwIsValidContextConfig(const _GLFWctxconfig* ctxconfig)
 {
     if (ctxconfig->source != GLFW_NATIVE_CONTEXT_API &&
-        ctxconfig->source != GLFW_EGL_CONTEXT_API)
+        ctxconfig->source != GLFW_EGL_CONTEXT_API &&
+        ctxconfig->source != GLFW_OSMESA_CONTEXT_API)
     {
         _glfwInputError(GLFW_INVALID_ENUM,
-                        "Invalid context creation API %i",
+                        "Invalid context creation API 0x%08X",
                         ctxconfig->source);
         return GLFW_FALSE;
     }
@@ -54,7 +55,7 @@ GLFWbool _glfwIsValidContextConfig(const _GLFWctxconfig* ctxconfig)
         ctxconfig->client != GLFW_OPENGL_ES_API)
     {
         _glfwInputError(GLFW_INVALID_ENUM,
-                        "Invalid client API %i",
+                        "Invalid client API 0x%08X",
                         ctxconfig->client);
         return GLFW_FALSE;
     }
@@ -84,7 +85,7 @@ GLFWbool _glfwIsValidContextConfig(const _GLFWctxconfig* ctxconfig)
                 ctxconfig->profile != GLFW_OPENGL_COMPAT_PROFILE)
             {
                 _glfwInputError(GLFW_INVALID_ENUM,
-                                "Invalid OpenGL profile %i",
+                                "Invalid OpenGL profile 0x%08X",
                                 ctxconfig->profile);
                 return GLFW_FALSE;
             }
@@ -133,7 +134,7 @@ GLFWbool _glfwIsValidContextConfig(const _GLFWctxconfig* ctxconfig)
             ctxconfig->robustness != GLFW_LOSE_CONTEXT_ON_RESET)
         {
             _glfwInputError(GLFW_INVALID_ENUM,
-                            "Invalid context robustness mode %i",
+                            "Invalid context robustness mode 0x%08X",
                             ctxconfig->robustness);
             return GLFW_FALSE;
         }
@@ -145,7 +146,7 @@ GLFWbool _glfwIsValidContextConfig(const _GLFWctxconfig* ctxconfig)
             ctxconfig->release != GLFW_RELEASE_BEHAVIOR_FLUSH)
         {
             _glfwInputError(GLFW_INVALID_ENUM,
-                            "Invalid context release behavior %i",
+                            "Invalid context release behavior 0x%08X",
                             ctxconfig->release);
             return GLFW_FALSE;
         }
@@ -207,6 +208,9 @@ const _GLFWfbconfig* _glfwChooseFBConfig(const _GLFWfbconfig* desired,
                 // not important to us here, so we count them as one
                 missing++;
             }
+
+            if (desired->transparent != current->transparent)
+                missing++;
         }
 
         // These polynomials make many small channel size differences matter
@@ -330,7 +334,7 @@ GLFWbool _glfwRefreshContextAttribs(const _GLFWctxconfig* ctxconfig)
         NULL
     };
 
-    window = _glfwPlatformGetCurrentContext();
+    window = _glfwPlatformGetTls(&_glfw.contextSlot);
 
     window->context.source = ctxconfig->source;
     window->context.client = GLFW_OPENGL_API;
@@ -577,7 +581,7 @@ GLFWbool _glfwStringInExtensionString(const char* string, const char* extensions
 GLFWAPI void glfwMakeContextCurrent(GLFWwindow* handle)
 {
     _GLFWwindow* window = (_GLFWwindow*) handle;
-    _GLFWwindow* previous = _glfwPlatformGetCurrentContext();
+    _GLFWwindow* previous = _glfwPlatformGetTls(&_glfw.contextSlot);
 
     _GLFW_REQUIRE_INIT();
 
@@ -600,7 +604,7 @@ GLFWAPI void glfwMakeContextCurrent(GLFWwindow* handle)
 GLFWAPI GLFWwindow* glfwGetCurrentContext(void)
 {
     _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
-    return (GLFWwindow*) _glfwPlatformGetCurrentContext();
+    return _glfwPlatformGetTls(&_glfw.contextSlot);
 }
 
 GLFWAPI void glfwSwapBuffers(GLFWwindow* handle)
@@ -625,7 +629,7 @@ GLFWAPI void glfwSwapInterval(int interval)
 
     _GLFW_REQUIRE_INIT();
 
-    window = _glfwPlatformGetCurrentContext();
+    window = _glfwPlatformGetTls(&_glfw.contextSlot);
     if (!window)
     {
         _glfwInputError(GLFW_NO_CURRENT_CONTEXT, NULL);
@@ -638,12 +642,11 @@ GLFWAPI void glfwSwapInterval(int interval)
 GLFWAPI int glfwExtensionSupported(const char* extension)
 {
     _GLFWwindow* window;
-
     assert(extension != NULL);
 
     _GLFW_REQUIRE_INIT_OR_RETURN(GLFW_FALSE);
 
-    window = _glfwPlatformGetCurrentContext();
+    window = _glfwPlatformGetTls(&_glfw.contextSlot);
     if (!window)
     {
         _glfwInputError(GLFW_NO_CURRENT_CONTEXT, NULL);
@@ -708,7 +711,7 @@ GLFWAPI GLFWglproc glfwGetProcAddress(const char* procname)
 
     _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
 
-    window = _glfwPlatformGetCurrentContext();
+    window = _glfwPlatformGetTls(&_glfw.contextSlot);
     if (!window)
     {
         _glfwInputError(GLFW_NO_CURRENT_CONTEXT, NULL);

raylib/external/glfw/src/egl_context.c

@@ -1,8 +1,8 @@
 //========================================================================
-// GLFW 3.2 EGL - www.glfw.org
+// GLFW 3.3 EGL - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-2016 Camilla Berglund <elmindreda@glfw.org>
+// Copyright (c) 2006-2016 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
@@ -113,7 +113,7 @@ static GLFWbool chooseEGLConfig(const _GLFWctxconfig* ctxconfig,
         _GLFWfbconfig* u = usableConfigs + usableCount;
 
         // Only consider RGB(A) EGLConfigs
-        if (!(getEGLConfigAttrib(n, EGL_COLOR_BUFFER_TYPE) & EGL_RGB_BUFFER))
+        if (getEGLConfigAttrib(n, EGL_COLOR_BUFFER_TYPE) != EGL_RGB_BUFFER)
             continue;
 
         // Only consider window EGLConfigs
@@ -121,9 +121,25 @@ static GLFWbool chooseEGLConfig(const _GLFWctxconfig* ctxconfig,
             continue;
 
 #if defined(_GLFW_X11)
+        XVisualInfo vi = {0};
+
         // Only consider EGLConfigs with associated Visuals
-        if (!getEGLConfigAttrib(n, EGL_NATIVE_VISUAL_ID))
+        vi.visualid = getEGLConfigAttrib(n, EGL_NATIVE_VISUAL_ID);
+        if (!vi.visualid)
             continue;
+
+        if (desired->transparent)
+        {
+            int count;
+            XVisualInfo* vis = XGetVisualInfo(_glfw.x11.display,
+                                              VisualIDMask, &vi,
+                                              &count);
+            if (vis)
+            {
+                u->transparent = _glfwIsVisualTransparentX11(vis[0].visual);
+                XFree(vis);
+            }
+        }
 #endif // _GLFW_X11
 
         if (ctxconfig->client == GLFW_OPENGL_ES_API)
@@ -199,12 +215,12 @@ static void makeContextCurrentEGL(_GLFWwindow* window)
         }
     }
 
-    _glfwPlatformSetCurrentContext(window);
+    _glfwPlatformSetTls(&_glfw.contextSlot, window);
 }
 
 static void swapBuffersEGL(_GLFWwindow* window)
 {
-    if (window != _glfwPlatformGetCurrentContext())
+    if (window != _glfwPlatformGetTls(&_glfw.contextSlot))
     {
         _glfwInputError(GLFW_PLATFORM_ERROR,
                         "EGL: The context must be current on the calling thread when swapping buffers");
@@ -233,7 +249,7 @@ static int extensionSupportedEGL(const char* extension)
 
 static GLFWglproc getProcAddressEGL(const char* procname)
 {
-    _GLFWwindow* window = _glfwPlatformGetCurrentContext();
+    _GLFWwindow* window = _glfwPlatformGetTls(&_glfw.contextSlot);
 
     if (window->context.egl.client)
     {
@@ -286,11 +302,15 @@ GLFWbool _glfwInitEGL(void)
     int i;
     const char* sonames[] =
     {
-#if defined(_GLFW_WIN32)
+#if defined(_GLFW_EGL_LIBRARY)
+        _GLFW_EGL_LIBRARY,
+#elif defined(_GLFW_WIN32)
         "libEGL.dll",
         "EGL.dll",
 #elif defined(_GLFW_COCOA)
         "libEGL.dylib",
+#elif defined(__CYGWIN__)
+        "libEGL-1.so",
 #else
         "libEGL.so.1",
 #endif
@@ -315,37 +335,37 @@ GLFWbool _glfwInitEGL(void)
 
     _glfw.egl.prefix = (strncmp(sonames[i], "lib", 3) == 0);
 
-    _glfw.egl.GetConfigAttrib = (PFNEGLGETCONFIGATTRIBPROC)
+    _glfw.egl.GetConfigAttrib = (PFN_eglGetConfigAttrib)
         _glfw_dlsym(_glfw.egl.handle, "eglGetConfigAttrib");
-    _glfw.egl.GetConfigs = (PFNEGLGETCONFIGSPROC)
+    _glfw.egl.GetConfigs = (PFN_eglGetConfigs)
         _glfw_dlsym(_glfw.egl.handle, "eglGetConfigs");
-    _glfw.egl.GetDisplay = (PFNEGLGETDISPLAYPROC)
+    _glfw.egl.GetDisplay = (PFN_eglGetDisplay)
         _glfw_dlsym(_glfw.egl.handle, "eglGetDisplay");
-    _glfw.egl.GetError = (PFNEGLGETERRORPROC)
+    _glfw.egl.GetError = (PFN_eglGetError)
         _glfw_dlsym(_glfw.egl.handle, "eglGetError");
-    _glfw.egl.Initialize = (PFNEGLINITIALIZEPROC)
+    _glfw.egl.Initialize = (PFN_eglInitialize)
         _glfw_dlsym(_glfw.egl.handle, "eglInitialize");
-    _glfw.egl.Terminate = (PFNEGLTERMINATEPROC)
+    _glfw.egl.Terminate = (PFN_eglTerminate)
         _glfw_dlsym(_glfw.egl.handle, "eglTerminate");
-    _glfw.egl.BindAPI = (PFNEGLBINDAPIPROC)
+    _glfw.egl.BindAPI = (PFN_eglBindAPI)
         _glfw_dlsym(_glfw.egl.handle, "eglBindAPI");
-    _glfw.egl.CreateContext = (PFNEGLCREATECONTEXTPROC)
+    _glfw.egl.CreateContext = (PFN_eglCreateContext)
         _glfw_dlsym(_glfw.egl.handle, "eglCreateContext");
-    _glfw.egl.DestroySurface = (PFNEGLDESTROYSURFACEPROC)
+    _glfw.egl.DestroySurface = (PFN_eglDestroySurface)
         _glfw_dlsym(_glfw.egl.handle, "eglDestroySurface");
-    _glfw.egl.DestroyContext = (PFNEGLDESTROYCONTEXTPROC)
+    _glfw.egl.DestroyContext = (PFN_eglDestroyContext)
         _glfw_dlsym(_glfw.egl.handle, "eglDestroyContext");
-    _glfw.egl.CreateWindowSurface = (PFNEGLCREATEWINDOWSURFACEPROC)
+    _glfw.egl.CreateWindowSurface = (PFN_eglCreateWindowSurface)
         _glfw_dlsym(_glfw.egl.handle, "eglCreateWindowSurface");
-    _glfw.egl.MakeCurrent = (PFNEGLMAKECURRENTPROC)
+    _glfw.egl.MakeCurrent = (PFN_eglMakeCurrent)
         _glfw_dlsym(_glfw.egl.handle, "eglMakeCurrent");
-    _glfw.egl.SwapBuffers = (PFNEGLSWAPBUFFERSPROC)
+    _glfw.egl.SwapBuffers = (PFN_eglSwapBuffers)
         _glfw_dlsym(_glfw.egl.handle, "eglSwapBuffers");
-    _glfw.egl.SwapInterval = (PFNEGLSWAPINTERVALPROC)
+    _glfw.egl.SwapInterval = (PFN_eglSwapInterval)
         _glfw_dlsym(_glfw.egl.handle, "eglSwapInterval");
-    _glfw.egl.QueryString = (PFNEGLQUERYSTRINGPROC)
+    _glfw.egl.QueryString = (PFN_eglQueryString)
         _glfw_dlsym(_glfw.egl.handle, "eglQueryString");
-    _glfw.egl.GetProcAddress = (PFNEGLGETPROCADDRESSPROC)
+    _glfw.egl.GetProcAddress = (PFN_eglGetProcAddress)
         _glfw_dlsym(_glfw.egl.handle, "eglGetProcAddress");
 
     if (!_glfw.egl.GetConfigAttrib ||
@@ -399,6 +419,10 @@ GLFWbool _glfwInitEGL(void)
         extensionSupportedEGL("EGL_KHR_create_context_no_error");
     _glfw.egl.KHR_gl_colorspace =
         extensionSupportedEGL("EGL_KHR_gl_colorspace");
+    _glfw.egl.KHR_get_all_proc_addresses =
+        extensionSupportedEGL("EGL_KHR_get_all_proc_addresses");
+    _glfw.egl.KHR_context_flush_control =
+        extensionSupportedEGL("EGL_KHR_context_flush_control");
 
     return GLFW_TRUE;
 }
@@ -420,11 +444,11 @@ void _glfwTerminateEGL(void)
     }
 }
 
-#define setEGLattrib(attribName, attribValue) \
+#define setAttrib(a, v) \
 { \
-    attribs[index++] = attribName; \
+    assert((size_t) (index + 1) < sizeof(attribs) / sizeof(attribs[0])); \
-    attribs[index++] = attribValue; \
+    attribs[index++] = a; \
-    assert((size_t) index < sizeof(attribs) / sizeof(attribs[0])); \
+    attribs[index++] = v; \
 }
 
 // Create the OpenGL or OpenGL ES context
@@ -436,6 +460,7 @@ GLFWbool _glfwCreateContextEGL(_GLFWwindow* window,
     EGLint attribs[40];
     EGLConfig config;
     EGLContext share = NULL;
+    int index = 0;
 
     if (!_glfw.egl.display)
     {
@@ -476,7 +501,7 @@ GLFWbool _glfwCreateContextEGL(_GLFWwindow* window,
 
     if (_glfw.egl.KHR_create_context)
     {
-        int index = 0, mask = 0, flags = 0;
+        int mask = 0, flags = 0;
 
         if (ctxconfig->client == GLFW_OPENGL_API)
         {
@@ -487,12 +512,6 @@ GLFWbool _glfwCreateContextEGL(_GLFWwindow* window,
                 mask |= EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT_KHR;
             else if (ctxconfig->profile == GLFW_OPENGL_COMPAT_PROFILE)
                 mask |= EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT_KHR;
-
-            if (_glfw.egl.KHR_create_context_no_error)
-            {
-                if (ctxconfig->noerror)
-                    flags |= EGL_CONTEXT_OPENGL_NO_ERROR_KHR;
-            }
         }
 
         if (ctxconfig->debug)
@@ -502,44 +521,57 @@ GLFWbool _glfwCreateContextEGL(_GLFWwindow* window,
         {
             if (ctxconfig->robustness == GLFW_NO_RESET_NOTIFICATION)
             {
-                setEGLattrib(EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_KHR,
+                setAttrib(EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_KHR,
-                             EGL_NO_RESET_NOTIFICATION_KHR);
+                          EGL_NO_RESET_NOTIFICATION_KHR);
             }
             else if (ctxconfig->robustness == GLFW_LOSE_CONTEXT_ON_RESET)
             {
-                setEGLattrib(EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_KHR,
+                setAttrib(EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_KHR,
-                             EGL_LOSE_CONTEXT_ON_RESET_KHR);
+                          EGL_LOSE_CONTEXT_ON_RESET_KHR);
             }
 
             flags |= EGL_CONTEXT_OPENGL_ROBUST_ACCESS_BIT_KHR;
         }
 
+        if (ctxconfig->noerror)
+        {
+            if (_glfw.egl.KHR_create_context_no_error)
+                setAttrib(EGL_CONTEXT_OPENGL_NO_ERROR_KHR, GLFW_TRUE);
+        }
+
         if (ctxconfig->major != 1 || ctxconfig->minor != 0)
         {
-            setEGLattrib(EGL_CONTEXT_MAJOR_VERSION_KHR, ctxconfig->major);
+            setAttrib(EGL_CONTEXT_MAJOR_VERSION_KHR, ctxconfig->major);
-            setEGLattrib(EGL_CONTEXT_MINOR_VERSION_KHR, ctxconfig->minor);
+            setAttrib(EGL_CONTEXT_MINOR_VERSION_KHR, ctxconfig->minor);
         }
 
         if (mask)
-            setEGLattrib(EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR, mask);
+            setAttrib(EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR, mask);
 
         if (flags)
-            setEGLattrib(EGL_CONTEXT_FLAGS_KHR, flags);
+            setAttrib(EGL_CONTEXT_FLAGS_KHR, flags);
-
-        setEGLattrib(EGL_NONE, EGL_NONE);
     }
     else
     {
-        int index = 0;
-
         if (ctxconfig->client == GLFW_OPENGL_ES_API)
-            setEGLattrib(EGL_CONTEXT_CLIENT_VERSION, ctxconfig->major);
+            setAttrib(EGL_CONTEXT_CLIENT_VERSION, ctxconfig->major);
-
-        setEGLattrib(EGL_NONE, EGL_NONE);
     }
 
-    // Context release behaviors (GL_KHR_context_flush_control) are not yet
+    if (_glfw.egl.KHR_context_flush_control)
-    // supported on EGL but are not a hard constraint, so ignore and continue
+    {
+        if (ctxconfig->release == GLFW_RELEASE_BEHAVIOR_NONE)
+        {
+            setAttrib(EGL_CONTEXT_RELEASE_BEHAVIOR_KHR,
+                      EGL_CONTEXT_RELEASE_BEHAVIOR_NONE_KHR);
+        }
+        else if (ctxconfig->release == GLFW_RELEASE_BEHAVIOR_FLUSH)
+        {
+            setAttrib(EGL_CONTEXT_RELEASE_BEHAVIOR_KHR,
+                      EGL_CONTEXT_RELEASE_BEHAVIOR_FLUSH_KHR);
+        }
+    }
+
+    setAttrib(EGL_NONE, EGL_NONE);
 
     window->context.egl.handle = eglCreateContext(_glfw.egl.display,
                                                   config, share, attribs);
@@ -559,12 +591,10 @@ GLFWbool _glfwCreateContextEGL(_GLFWwindow* window,
         if (fbconfig->sRGB)
         {
             if (_glfw.egl.KHR_gl_colorspace)
-            {
+                setAttrib(EGL_GL_COLORSPACE_KHR, EGL_GL_COLORSPACE_SRGB_KHR);
-                setEGLattrib(EGL_GL_COLORSPACE_KHR, EGL_GL_COLORSPACE_SRGB_KHR);
-            }
         }
 
-        setEGLattrib(EGL_NONE, EGL_NONE);
+        setAttrib(EGL_NONE, EGL_NONE);
     }
 
     window->context.egl.surface =
@@ -583,12 +613,15 @@ GLFWbool _glfwCreateContextEGL(_GLFWwindow* window,
     window->context.egl.config = config;
 
     // Load the appropriate client library
+    if (!_glfw.egl.KHR_get_all_proc_addresses)
     {
         int i;
         const char** sonames;
         const char* es1sonames[] =
         {
-#if defined(_GLFW_WIN32)
+#if defined(_GLFW_GLESV1_LIBRARY)
+            _GLFW_GLESV1_LIBRARY,
+#elif defined(_GLFW_WIN32)
             "GLESv1_CM.dll",
             "libGLES_CM.dll",
 #elif defined(_GLFW_COCOA)
@@ -601,11 +634,15 @@ GLFWbool _glfwCreateContextEGL(_GLFWwindow* window,
         };
         const char* es2sonames[] =
         {
-#if defined(_GLFW_WIN32)
+#if defined(_GLFW_GLESV2_LIBRARY)
+            _GLFW_GLESV2_LIBRARY,
+#elif defined(_GLFW_WIN32)
             "GLESv2.dll",
             "libGLESv2.dll",
 #elif defined(_GLFW_COCOA)
             "libGLESv2.dylib",
+#elif defined(__CYGWIN__)
+            "libGLESv2-2.so",
 #else
             "libGLESv2.so.2",
 #endif
@@ -613,7 +650,9 @@ GLFWbool _glfwCreateContextEGL(_GLFWwindow* window,
         };
         const char* glsonames[] =
         {
-#if defined(_GLFW_WIN32)
+#if defined(_GLFW_OPENGL_LIBRARY)
+            _GLFW_OPENGL_LIBRARY,
+#elif defined(_GLFW_WIN32)
 #elif defined(_GLFW_COCOA)
 #else
             "libGL.so.1",
@@ -661,12 +700,13 @@ GLFWbool _glfwCreateContextEGL(_GLFWwindow* window,
     return GLFW_TRUE;
 }
 
-#undef setEGLattrib
+#undef setAttrib
 
 // Returns the Visual and depth of the chosen EGLConfig
 //
 #if defined(_GLFW_X11)
-GLFWbool _glfwChooseVisualEGL(const _GLFWctxconfig* ctxconfig,
+GLFWbool _glfwChooseVisualEGL(const _GLFWwndconfig* wndconfig,
+                              const _GLFWctxconfig* ctxconfig,
                               const _GLFWfbconfig* fbconfig,
                               Visual** visual, int* depth)
 {

raylib/external/glfw/src/egl_context.h

@@ -1,8 +1,8 @@
 //========================================================================
-// GLFW 3.2 EGL - www.glfw.org
+// GLFW 3.3 EGL - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-2016 Camilla Berglund <elmindreda@glfw.org>
+// Copyright (c) 2006-2016 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
@@ -25,15 +25,16 @@
 //
 //========================================================================
 
-#ifndef _glfw3_egl_context_h_
-#define _glfw3_egl_context_h_
-
 #if defined(_GLFW_USE_EGLPLATFORM_H)
  #include <EGL/eglplatform.h>
 #elif defined(_GLFW_WIN32)
  #define EGLAPIENTRY __stdcall
 typedef HDC EGLNativeDisplayType;
 typedef HWND EGLNativeWindowType;
+#elif defined(_GLFW_COCOA)
+ #define EGLAPIENTRY
+typedef void* EGLNativeDisplayType;
+typedef id EGLNativeWindowType;
 #elif defined(_GLFW_X11)
  #define EGLAPIENTRY
 typedef Display* EGLNativeDisplayType;
@@ -106,6 +107,9 @@ typedef MirEGLNativeWindowType EGLNativeWindowType;
 #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
 
 typedef int EGLint;
 typedef unsigned int EGLBoolean;
@@ -116,22 +120,22 @@ typedef void* EGLDisplay;
 typedef void* EGLSurface;
 
 // EGL function pointer typedefs
-typedef EGLBoolean (EGLAPIENTRY * PFNEGLGETCONFIGATTRIBPROC)(EGLDisplay,EGLConfig,EGLint,EGLint*);
+typedef EGLBoolean (EGLAPIENTRY * PFN_eglGetConfigAttrib)(EGLDisplay,EGLConfig,EGLint,EGLint*);
-typedef EGLBoolean (EGLAPIENTRY * PFNEGLGETCONFIGSPROC)(EGLDisplay,EGLConfig*,EGLint,EGLint*);
+typedef EGLBoolean (EGLAPIENTRY * PFN_eglGetConfigs)(EGLDisplay,EGLConfig*,EGLint,EGLint*);
-typedef EGLDisplay (EGLAPIENTRY * PFNEGLGETDISPLAYPROC)(EGLNativeDisplayType);
+typedef EGLDisplay (EGLAPIENTRY * PFN_eglGetDisplay)(EGLNativeDisplayType);
-typedef EGLint (EGLAPIENTRY * PFNEGLGETERRORPROC)(void);
+typedef EGLint (EGLAPIENTRY * PFN_eglGetError)(void);
-typedef EGLBoolean (EGLAPIENTRY * PFNEGLINITIALIZEPROC)(EGLDisplay,EGLint*,EGLint*);
+typedef EGLBoolean (EGLAPIENTRY * PFN_eglInitialize)(EGLDisplay,EGLint*,EGLint*);
-typedef EGLBoolean (EGLAPIENTRY * PFNEGLTERMINATEPROC)(EGLDisplay);
+typedef EGLBoolean (EGLAPIENTRY * PFN_eglTerminate)(EGLDisplay);
-typedef EGLBoolean (EGLAPIENTRY * PFNEGLBINDAPIPROC)(EGLenum);
+typedef EGLBoolean (EGLAPIENTRY * PFN_eglBindAPI)(EGLenum);
-typedef EGLContext (EGLAPIENTRY * PFNEGLCREATECONTEXTPROC)(EGLDisplay,EGLConfig,EGLContext,const EGLint*);
+typedef EGLContext (EGLAPIENTRY * PFN_eglCreateContext)(EGLDisplay,EGLConfig,EGLContext,const EGLint*);
-typedef EGLBoolean (EGLAPIENTRY * PFNEGLDESTROYSURFACEPROC)(EGLDisplay,EGLSurface);
+typedef EGLBoolean (EGLAPIENTRY * PFN_eglDestroySurface)(EGLDisplay,EGLSurface);
-typedef EGLBoolean (EGLAPIENTRY * PFNEGLDESTROYCONTEXTPROC)(EGLDisplay,EGLContext);
+typedef EGLBoolean (EGLAPIENTRY * PFN_eglDestroyContext)(EGLDisplay,EGLContext);
-typedef EGLSurface (EGLAPIENTRY * PFNEGLCREATEWINDOWSURFACEPROC)(EGLDisplay,EGLConfig,EGLNativeWindowType,const EGLint*);
+typedef EGLSurface (EGLAPIENTRY * PFN_eglCreateWindowSurface)(EGLDisplay,EGLConfig,EGLNativeWindowType,const EGLint*);
-typedef EGLBoolean (EGLAPIENTRY * PFNEGLMAKECURRENTPROC)(EGLDisplay,EGLSurface,EGLSurface,EGLContext);
+typedef EGLBoolean (EGLAPIENTRY * PFN_eglMakeCurrent)(EGLDisplay,EGLSurface,EGLSurface,EGLContext);
-typedef EGLBoolean (EGLAPIENTRY * PFNEGLSWAPBUFFERSPROC)(EGLDisplay,EGLSurface);
+typedef EGLBoolean (EGLAPIENTRY * PFN_eglSwapBuffers)(EGLDisplay,EGLSurface);
-typedef EGLBoolean (EGLAPIENTRY * PFNEGLSWAPINTERVALPROC)(EGLDisplay,EGLint);
+typedef EGLBoolean (EGLAPIENTRY * PFN_eglSwapInterval)(EGLDisplay,EGLint);
-typedef const char* (EGLAPIENTRY * PFNEGLQUERYSTRINGPROC)(EGLDisplay,EGLint);
+typedef const char* (EGLAPIENTRY * PFN_eglQueryString)(EGLDisplay,EGLint);
-typedef GLFWglproc (EGLAPIENTRY * PFNEGLGETPROCADDRESSPROC)(const char*);
+typedef GLFWglproc (EGLAPIENTRY * PFN_eglGetProcAddress)(const char*);
 #define eglGetConfigAttrib _glfw.egl.GetConfigAttrib
 #define eglGetConfigs _glfw.egl.GetConfigs
 #define eglGetDisplay _glfw.egl.GetDisplay
@@ -176,25 +180,27 @@ typedef struct _GLFWlibraryEGL
     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;
 
     void*           handle;
 
-    PFNEGLGETCONFIGATTRIBPROC       GetConfigAttrib;
+    PFN_eglGetConfigAttrib      GetConfigAttrib;
-    PFNEGLGETCONFIGSPROC            GetConfigs;
+    PFN_eglGetConfigs           GetConfigs;
-    PFNEGLGETDISPLAYPROC            GetDisplay;
+    PFN_eglGetDisplay           GetDisplay;
-    PFNEGLGETERRORPROC              GetError;
+    PFN_eglGetError             GetError;
-    PFNEGLINITIALIZEPROC            Initialize;
+    PFN_eglInitialize           Initialize;
-    PFNEGLTERMINATEPROC             Terminate;
+    PFN_eglTerminate            Terminate;
-    PFNEGLBINDAPIPROC               BindAPI;
+    PFN_eglBindAPI              BindAPI;
-    PFNEGLCREATECONTEXTPROC         CreateContext;
+    PFN_eglCreateContext        CreateContext;
-    PFNEGLDESTROYSURFACEPROC        DestroySurface;
+    PFN_eglDestroySurface       DestroySurface;
-    PFNEGLDESTROYCONTEXTPROC        DestroyContext;
+    PFN_eglDestroyContext       DestroyContext;
-    PFNEGLCREATEWINDOWSURFACEPROC   CreateWindowSurface;
+    PFN_eglCreateWindowSurface  CreateWindowSurface;
-    PFNEGLMAKECURRENTPROC           MakeCurrent;
+    PFN_eglMakeCurrent          MakeCurrent;
-    PFNEGLSWAPBUFFERSPROC           SwapBuffers;
+    PFN_eglSwapBuffers          SwapBuffers;
-    PFNEGLSWAPINTERVALPROC          SwapInterval;
+    PFN_eglSwapInterval         SwapInterval;
-    PFNEGLQUERYSTRINGPROC           QueryString;
+    PFN_eglQueryString          QueryString;
-    PFNEGLGETPROCADDRESSPROC        GetProcAddress;
+    PFN_eglGetProcAddress       GetProcAddress;
 
 } _GLFWlibraryEGL;
 
@@ -205,9 +211,9 @@ GLFWbool _glfwCreateContextEGL(_GLFWwindow* window,
                                const _GLFWctxconfig* ctxconfig,
                                const _GLFWfbconfig* fbconfig);
 #if defined(_GLFW_X11)
-GLFWbool _glfwChooseVisualEGL(const _GLFWctxconfig* ctxconfig,
+GLFWbool _glfwChooseVisualEGL(const _GLFWwndconfig* wndconfig,
+                              const _GLFWctxconfig* ctxconfig,
                               const _GLFWfbconfig* fbconfig,
                               Visual** visual, int* depth);
 #endif /*_GLFW_X11*/
 
-#endif // _glfw3_egl_context_h_

raylib/external/glfw/src/glx_context.c

@@ -1,8 +1,8 @@
 //========================================================================
-// GLFW 3.2 GLX - www.glfw.org
+// GLFW 3.3 GLX - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-2016 Camilla Berglund <elmindreda@glfw.org>
+// Copyright (c) 2006-2016 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
@@ -47,7 +47,8 @@ static int getGLXFBConfigAttrib(GLXFBConfig fbconfig, int attrib)
 
 // Return the GLXFBConfig most closely matching the specified hints
 //
-static GLFWbool chooseGLXFBConfig(const _GLFWfbconfig* desired, GLXFBConfig* result)
+static GLFWbool chooseGLXFBConfig(const _GLFWfbconfig* desired,
+                                  GLXFBConfig* result)
 {
     GLXFBConfig* nativeConfigs;
     _GLFWfbconfig* usableConfigs;
@@ -59,12 +60,12 @@ static GLFWbool chooseGLXFBConfig(const _GLFWfbconfig* desired, GLXFBConfig* res
     // HACK: This is a (hopefully temporary) workaround for Chromium
     //       (VirtualBox GL) not setting the window bit on any GLXFBConfigs
     vendor = glXGetClientString(_glfw.x11.display, GLX_VENDOR);
-    if (strcmp(vendor, "Chromium") == 0)
+    if (vendor && strcmp(vendor, "Chromium") == 0)
         trustWindowBit = GLFW_FALSE;
 
     nativeConfigs =
         glXGetFBConfigs(_glfw.x11.display, _glfw.x11.screen, &nativeCount);
-    if (!nativeCount)
+    if (!nativeConfigs || !nativeCount)
     {
         _glfwInputError(GLFW_API_UNAVAILABLE, "GLX: No GLXFBConfigs returned");
         return GLFW_FALSE;
@@ -89,6 +90,16 @@ static GLFWbool chooseGLXFBConfig(const _GLFWfbconfig* desired, GLXFBConfig* res
                 continue;
         }
 
+        if (desired->transparent)
+        {
+            XVisualInfo* vi = glXGetVisualFromFBConfig(_glfw.x11.display, n);
+            if (vi)
+            {
+                u->transparent = _glfwIsVisualTransparentX11(vi->visual);
+                XFree(vi);
+            }
+        }
+
         u->redBits = getGLXFBConfigAttrib(n, GLX_RED_SIZE);
         u->greenBits = getGLXFBConfigAttrib(n, GLX_GREEN_SIZE);
         u->blueBits = getGLXFBConfigAttrib(n, GLX_BLUE_SIZE);
@@ -165,7 +176,7 @@ static void makeContextCurrentGLX(_GLFWwindow* window)
         }
     }
 
-    _glfwPlatformSetCurrentContext(window);
+    _glfwPlatformSetTls(&_glfw.contextSlot, window);
 }
 
 static void swapBuffersGLX(_GLFWwindow* window)
@@ -175,7 +186,7 @@ static void swapBuffersGLX(_GLFWwindow* window)
 
 static void swapIntervalGLX(int interval)
 {
-    _GLFWwindow* window = _glfwPlatformGetCurrentContext();
+    _GLFWwindow* window = _glfwPlatformGetTls(&_glfw.contextSlot);
 
     if (_glfw.glx.EXT_swap_control)
     {
@@ -244,7 +255,9 @@ GLFWbool _glfwInitGLX(void)
     int i;
     const char* sonames[] =
     {
-#if defined(__CYGWIN__)
+#if defined(_GLFW_GLX_LIBRARY)
+        _GLFW_GLX_LIBRARY,
+#elif defined(__CYGWIN__)
         "libGL-1.so",
 #else
         "libGL.so.1",
@@ -397,6 +410,9 @@ GLFWbool _glfwInitGLX(void)
     if (extensionSupportedGLX("GLX_EXT_create_context_es2_profile"))
         _glfw.glx.EXT_create_context_es2_profile = GLFW_TRUE;
 
+    if (extensionSupportedGLX("GLX_ARB_create_context_no_error"))
+        _glfw.glx.ARB_create_context_no_error = GLFW_TRUE;
+
     if (extensionSupportedGLX("GLX_ARB_context_flush_control"))
         _glfw.glx.ARB_context_flush_control = GLFW_TRUE;
 
@@ -417,11 +433,11 @@ void _glfwTerminateGLX(void)
     }
 }
 
-#define setGLXattrib(attribName, attribValue) \
+#define setAttrib(a, v) \
 { \
-    attribs[index++] = attribName; \
+    assert((size_t) (index + 1) < sizeof(attribs) / sizeof(attribs[0])); \
-    attribs[index++] = attribValue; \
+    attribs[index++] = a; \
-    assert((size_t) index < sizeof(attribs) / sizeof(attribs[0])); \
+    attribs[index++] = v; \
 }
 
 // Create the OpenGL or OpenGL ES context
@@ -498,8 +514,6 @@ GLFWbool _glfwCreateContextGLX(_GLFWwindow* window,
 
         if (ctxconfig->debug)
             flags |= GLX_CONTEXT_DEBUG_BIT_ARB;
-        if (ctxconfig->noerror)
-            flags |= GL_CONTEXT_FLAG_NO_ERROR_BIT_KHR;
 
         if (ctxconfig->robustness)
         {
@@ -507,13 +521,13 @@ GLFWbool _glfwCreateContextGLX(_GLFWwindow* window,
             {
                 if (ctxconfig->robustness == GLFW_NO_RESET_NOTIFICATION)
                 {
-                    setGLXattrib(GLX_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB,
+                    setAttrib(GLX_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB,
-                                 GLX_NO_RESET_NOTIFICATION_ARB);
+                              GLX_NO_RESET_NOTIFICATION_ARB);
                 }
                 else if (ctxconfig->robustness == GLFW_LOSE_CONTEXT_ON_RESET)
                 {
-                    setGLXattrib(GLX_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB,
+                    setAttrib(GLX_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB,
-                                 GLX_LOSE_CONTEXT_ON_RESET_ARB);
+                              GLX_LOSE_CONTEXT_ON_RESET_ARB);
                 }
 
                 flags |= GLX_CONTEXT_ROBUST_ACCESS_BIT_ARB;
@@ -526,33 +540,39 @@ GLFWbool _glfwCreateContextGLX(_GLFWwindow* window,
             {
                 if (ctxconfig->release == GLFW_RELEASE_BEHAVIOR_NONE)
                 {
-                    setGLXattrib(GLX_CONTEXT_RELEASE_BEHAVIOR_ARB,
+                    setAttrib(GLX_CONTEXT_RELEASE_BEHAVIOR_ARB,
-                                 GLX_CONTEXT_RELEASE_BEHAVIOR_NONE_ARB);
+                              GLX_CONTEXT_RELEASE_BEHAVIOR_NONE_ARB);
                 }
                 else if (ctxconfig->release == GLFW_RELEASE_BEHAVIOR_FLUSH)
                 {
-                    setGLXattrib(GLX_CONTEXT_RELEASE_BEHAVIOR_ARB,
+                    setAttrib(GLX_CONTEXT_RELEASE_BEHAVIOR_ARB,
-                                 GLX_CONTEXT_RELEASE_BEHAVIOR_FLUSH_ARB);
+                              GLX_CONTEXT_RELEASE_BEHAVIOR_FLUSH_ARB);
                 }
             }
         }
 
+        if (ctxconfig->noerror)
+        {
+            if (_glfw.glx.ARB_create_context_no_error)
+                setAttrib(GLX_CONTEXT_OPENGL_NO_ERROR_ARB, GLFW_TRUE);
+        }
+
         // NOTE: Only request an explicitly versioned context when necessary, as
         //       explicitly requesting version 1.0 does not always return the
         //       highest version supported by the driver
         if (ctxconfig->major != 1 || ctxconfig->minor != 0)
         {
-            setGLXattrib(GLX_CONTEXT_MAJOR_VERSION_ARB, ctxconfig->major);
+            setAttrib(GLX_CONTEXT_MAJOR_VERSION_ARB, ctxconfig->major);
-            setGLXattrib(GLX_CONTEXT_MINOR_VERSION_ARB, ctxconfig->minor);
+            setAttrib(GLX_CONTEXT_MINOR_VERSION_ARB, ctxconfig->minor);
         }
 
         if (mask)
-            setGLXattrib(GLX_CONTEXT_PROFILE_MASK_ARB, mask);
+            setAttrib(GLX_CONTEXT_PROFILE_MASK_ARB, mask);
 
         if (flags)
-            setGLXattrib(GLX_CONTEXT_FLAGS_ARB, flags);
+            setAttrib(GLX_CONTEXT_FLAGS_ARB, flags);
 
-        setGLXattrib(None, None);
+        setAttrib(None, None);
 
         window->context.glx.handle =
             _glfw.glx.CreateContextAttribsARB(_glfw.x11.display,
@@ -609,11 +629,12 @@ GLFWbool _glfwCreateContextGLX(_GLFWwindow* window,
     return GLFW_TRUE;
 }
 
-#undef setGLXattrib
+#undef setAttrib
 
 // Returns the Visual and depth of the chosen GLXFBConfig
 //
-GLFWbool _glfwChooseVisualGLX(const _GLFWctxconfig* ctxconfig,
+GLFWbool _glfwChooseVisualGLX(const _GLFWwndconfig* wndconfig,
+                              const _GLFWctxconfig* ctxconfig,
                               const _GLFWfbconfig* fbconfig,
                               Visual** visual, int* depth)
 {
@@ -636,7 +657,7 @@ GLFWbool _glfwChooseVisualGLX(const _GLFWctxconfig* ctxconfig,
     }
 
     *visual = result->visual;
-    *depth = result->depth;
+    *depth  = result->depth;
 
     XFree(result);
     return GLFW_TRUE;

raylib/external/glfw/src/glx_context.h

@@ -1,8 +1,8 @@
 //========================================================================
-// GLFW 3.2 GLX - www.glfw.org
+// GLFW 3.3 GLX - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-2016 Camilla Berglund <elmindreda@glfw.org>
+// Copyright (c) 2006-2016 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
@@ -25,9 +25,6 @@
 //
 //========================================================================
 
-#ifndef _glfw3_glx_context_h_
-#define _glfw3_glx_context_h_
-
 #define GLX_VENDOR 1
 #define GLX_RGBA_BIT 0x00000001
 #define GLX_WINDOW_BIT 0x00000001
@@ -67,6 +64,7 @@
 #define GLX_CONTEXT_RELEASE_BEHAVIOR_ARB 0x2097
 #define GLX_CONTEXT_RELEASE_BEHAVIOR_NONE_ARB 0
 #define GLX_CONTEXT_RELEASE_BEHAVIOR_FLUSH_ARB 0x2098
+#define GLX_CONTEXT_OPENGL_NO_ERROR_ARB 0x31b3
 
 typedef XID GLXWindow;
 typedef XID GLXDrawable;
@@ -85,14 +83,15 @@ typedef const char* (*PFNGLXQUERYEXTENSIONSSTRINGPROC)(Display*,int);
 typedef GLXFBConfig* (*PFNGLXGETFBCONFIGSPROC)(Display*,int,int*);
 typedef GLXContext (*PFNGLXCREATENEWCONTEXTPROC)(Display*,GLXFBConfig,int,GLXContext,Bool);
 typedef __GLXextproc (* PFNGLXGETPROCADDRESSPROC)(const GLubyte *procName);
-typedef int (*PFNGLXSWAPINTERVALMESAPROC)(int);
-typedef int (*PFNGLXSWAPINTERVALSGIPROC)(int);
 typedef void (*PFNGLXSWAPINTERVALEXTPROC)(Display*,GLXDrawable,int);
-typedef GLXContext (*PFNGLXCREATECONTEXTATTRIBSARBPROC)(Display*,GLXFBConfig,GLXContext,Bool,const int*);
 typedef XVisualInfo* (*PFNGLXGETVISUALFROMFBCONFIGPROC)(Display*,GLXFBConfig);
 typedef GLXWindow (*PFNGLXCREATEWINDOWPROC)(Display*,GLXFBConfig,Window,const int*);
 typedef void (*PFNGLXDESTROYWINDOWPROC)(Display*,GLXWindow);
 
+typedef int (*PFNGLXSWAPINTERVALMESAPROC)(int);
+typedef int (*PFNGLXSWAPINTERVALSGIPROC)(int);
+typedef GLXContext (*PFNGLXCREATECONTEXTATTRIBSARBPROC)(Display*,GLXFBConfig,GLXContext,Bool,const int*);
+
 // libGL.so function pointer typedefs
 #define glXGetFBConfigs _glfw.glx.GetFBConfigs
 #define glXGetFBConfigAttrib _glfw.glx.GetFBConfigAttrib
@@ -164,19 +163,19 @@ typedef struct _GLFWlibraryGLX
     GLFWbool        ARB_create_context_profile;
     GLFWbool        ARB_create_context_robustness;
     GLFWbool        EXT_create_context_es2_profile;
+    GLFWbool        ARB_create_context_no_error;
     GLFWbool        ARB_context_flush_control;
 
 } _GLFWlibraryGLX;
 
-
 GLFWbool _glfwInitGLX(void);
 void _glfwTerminateGLX(void);
 GLFWbool _glfwCreateContextGLX(_GLFWwindow* window,
                                const _GLFWctxconfig* ctxconfig,
                                const _GLFWfbconfig* fbconfig);
 void _glfwDestroyContextGLX(_GLFWwindow* window);
-GLFWbool _glfwChooseVisualGLX(const _GLFWctxconfig* ctxconfig,
+GLFWbool _glfwChooseVisualGLX(const _GLFWwndconfig* wndconfig,
+                              const _GLFWctxconfig* ctxconfig,
                               const _GLFWfbconfig* fbconfig,
                               Visual** visual, int* depth);
 
-#endif // _glfw3_glx_context_h_

raylib/external/glfw/src/init.c

@@ -1,8 +1,8 @@
 //========================================================================
-// GLFW 3.2 - www.glfw.org
+// GLFW 3.3 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-2016 Camilla Berglund <elmindreda@glfw.org>
+// Copyright (c) 2006-2016 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
@@ -26,33 +26,45 @@
 //========================================================================
 
 #include "internal.h"
+#include "mappings.h"
 
 #include <string.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
 
 
-// The three global variables below comprise all global data in GLFW.
+// The global variables below comprise all global data in GLFW.
 // Any other global variable is a bug.
 
 // Global state shared between compilation units of GLFW
-// These are documented in internal.h
 //
-GLFWbool _glfwInitialized = GLFW_FALSE;
+_GLFWlibrary _glfw = { GLFW_FALSE };
-_GLFWlibrary _glfw;
 
-// This is outside of _glfw so it can be initialized and usable before
+// These are outside of _glfw so they can be used before initialization and
-// glfwInit is called, which lets that function report errors
+// after termination
 //
-static GLFWerrorfun _glfwErrorCallback = NULL;
+static _GLFWerror _glfwMainThreadError;
-
+static GLFWerrorfun _glfwErrorCallback;
+static _GLFWinitconfig _glfwInitHints =
+{
+    GLFW_TRUE,      // hat buttons
+    {
+        GLFW_TRUE,  // macOS menu bar
+        GLFW_TRUE   // macOS bundle chdir
+    },
+    {
+        "",         // X11 WM_CLASS name
+        ""          // X11 WM_CLASS class
+    }
+};
 
 // Returns a generic string representation of the specified error
 //
-static const char* getErrorString(int error)
+static const char* getErrorString(int code)
 {
-    switch (error)
+    switch (code)
     {
         case GLFW_NOT_INITIALIZED:
             return "The GLFW library is not initialized";
@@ -69,7 +81,7 @@ static const char* getErrorString(int error)
         case GLFW_VERSION_UNAVAILABLE:
             return "The requested API version is unavailable";
         case GLFW_PLATFORM_ERROR:
-            return "A platform-specific error occurred";
+            return "An undocumented platform-specific error occurred";
         case GLFW_FORMAT_UNAVAILABLE:
             return "The requested format is unavailable";
         case GLFW_NO_WINDOW_CONTEXT:
@@ -79,75 +91,12 @@ static const char* getErrorString(int error)
     }
 }
 
-
+// Terminate the library
-//////////////////////////////////////////////////////////////////////////
+//
-//////                         GLFW event API                       //////
+static void terminate(void)
-//////////////////////////////////////////////////////////////////////////
-
-void _glfwInputError(int error, const char* format, ...)
-{
-    if (_glfwErrorCallback)
-    {
-        char buffer[8192];
-        const char* description;
-
-        if (format)
-        {
-            int count;
-            va_list vl;
-
-            va_start(vl, format);
-            count = vsnprintf(buffer, sizeof(buffer), format, vl);
-            va_end(vl);
-
-            if (count < 0)
-                buffer[sizeof(buffer) - 1] = '\0';
-
-            description = buffer;
-        }
-        else
-            description = getErrorString(error);
-
-        _glfwErrorCallback(error, description);
-    }
-}
-
-
-//////////////////////////////////////////////////////////////////////////
-//////                        GLFW public API                       //////
-//////////////////////////////////////////////////////////////////////////
-
-GLFWAPI int glfwInit(void)
-{
-    if (_glfwInitialized)
-        return GLFW_TRUE;
-
-    memset(&_glfw, 0, sizeof(_glfw));
-
-    if (!_glfwPlatformInit())
-    {
-        _glfwPlatformTerminate();
-        return GLFW_FALSE;
-    }
-
-    _glfw.monitors = _glfwPlatformGetMonitors(&_glfw.monitorCount);
-    _glfwInitialized = GLFW_TRUE;
-
-    _glfw.timerOffset = _glfwPlatformGetTimerValue();
-
-    // Not all window hints have zero as their default value
-    glfwDefaultWindowHints();
-
-    return GLFW_TRUE;
-}
-
-GLFWAPI void glfwTerminate(void)
 {
     int i;
 
-    if (!_glfwInitialized)
-        return;
-
     memset(&_glfw.callbacks, 0, sizeof(_glfw.callbacks));
 
     while (_glfw.windowListHead)
@@ -161,28 +110,185 @@ GLFWAPI void glfwTerminate(void)
         _GLFWmonitor* monitor = _glfw.monitors[i];
         if (monitor->originalRamp.size)
             _glfwPlatformSetGammaRamp(monitor, &monitor->originalRamp);
+        _glfwFreeMonitor(monitor);
     }
 
-    _glfwTerminateVulkan();
+    free(_glfw.monitors);
-
-    _glfwFreeMonitors(_glfw.monitors, _glfw.monitorCount);
     _glfw.monitors = NULL;
     _glfw.monitorCount = 0;
 
+    free(_glfw.mappings);
+    _glfw.mappings = NULL;
+    _glfw.mappingCount = 0;
+
+    _glfwTerminateVulkan();
     _glfwPlatformTerminate();
 
+    _glfw.initialized = GLFW_FALSE;
+
+    while (_glfw.errorListHead)
+    {
+        _GLFWerror* error = _glfw.errorListHead;
+        _glfw.errorListHead = error->next;
+        free(error);
+    }
+
+    _glfwPlatformDestroyTls(&_glfw.contextSlot);
+    _glfwPlatformDestroyTls(&_glfw.errorSlot);
+    _glfwPlatformDestroyMutex(&_glfw.errorLock);
+
     memset(&_glfw, 0, sizeof(_glfw));
-    _glfwInitialized = GLFW_FALSE;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                         GLFW event API                       //////
+//////////////////////////////////////////////////////////////////////////
+
+void _glfwInputError(int code, const char* format, ...)
+{
+    _GLFWerror* error;
+    char description[_GLFW_MESSAGE_SIZE];
+
+    if (format)
+    {
+        va_list vl;
+
+        va_start(vl, format);
+        vsnprintf(description, sizeof(description), format, vl);
+        va_end(vl);
+
+        description[sizeof(description) - 1] = '\0';
+    }
+    else
+        strcpy(description, getErrorString(code));
+
+    if (_glfw.initialized)
+    {
+        error = _glfwPlatformGetTls(&_glfw.errorSlot);
+        if (!error)
+        {
+            error = calloc(1, sizeof(_GLFWerror));
+            _glfwPlatformSetTls(&_glfw.errorSlot, error);
+            _glfwPlatformLockMutex(&_glfw.errorLock);
+            error->next = _glfw.errorListHead;
+            _glfw.errorListHead = error;
+            _glfwPlatformUnlockMutex(&_glfw.errorLock);
+        }
+    }
+    else
+        error = &_glfwMainThreadError;
+
+    error->code = code;
+    strcpy(error->description, description);
+
+    if (_glfwErrorCallback)
+        _glfwErrorCallback(code, description);
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                        GLFW public API                       //////
+//////////////////////////////////////////////////////////////////////////
+
+GLFWAPI int glfwInit(void)
+{
+    if (_glfw.initialized)
+        return GLFW_TRUE;
+
+    memset(&_glfw, 0, sizeof(_glfw));
+    _glfw.hints.init = _glfwInitHints;
+
+    if (!_glfwPlatformInit())
+    {
+        terminate();
+        return GLFW_FALSE;
+    }
+
+    if (!_glfwPlatformCreateMutex(&_glfw.errorLock) ||
+        !_glfwPlatformCreateTls(&_glfw.errorSlot) ||
+        !_glfwPlatformCreateTls(&_glfw.contextSlot))
+    {
+        terminate();
+        return GLFW_FALSE;
+    }
+
+    _glfwPlatformSetTls(&_glfw.errorSlot, &_glfwMainThreadError);
+
+    _glfw.initialized = GLFW_TRUE;
+    _glfw.timer.offset = _glfwPlatformGetTimerValue();
+
+    glfwDefaultWindowHints();
+
+    {
+        int i;
+
+        for (i = 0;  _glfwDefaultMappings[i];  i++)
+        {
+            if (!glfwUpdateGamepadMappings(_glfwDefaultMappings[i]))
+            {
+                terminate();
+                return GLFW_FALSE;
+            }
+        }
+    }
+
+    return GLFW_TRUE;
+}
+
+GLFWAPI void glfwTerminate(void)
+{
+    if (!_glfw.initialized)
+        return;
+
+    terminate();
+}
+
+GLFWAPI void glfwInitHint(int hint, int value)
+{
+    switch (hint)
+    {
+        case GLFW_JOYSTICK_HAT_BUTTONS:
+            _glfwInitHints.hatButtons = value;
+            return;
+        case GLFW_COCOA_CHDIR_RESOURCES:
+            _glfwInitHints.ns.chdir = value;
+            return;
+        case GLFW_COCOA_MENUBAR:
+            _glfwInitHints.ns.menubar = value;
+            return;
+    }
+
+    _glfwInputError(GLFW_INVALID_ENUM,
+                    "Invalid integer type init hint 0x%08X", hint);
+}
+
+GLFWAPI void glfwInitHintString(int hint, const char* value)
+{
+    assert(value != NULL);
+
+    switch (hint)
+    {
+        case GLFW_X11_WM_CLASS_NAME:
+            strncpy(_glfwInitHints.x11.className, value,
+                    sizeof(_glfwInitHints.x11.className) - 1);
+            return;
+        case GLFW_X11_WM_CLASS_CLASS:
+            strncpy(_glfwInitHints.x11.classClass, value,
+                    sizeof(_glfwInitHints.x11.classClass) - 1);
+            return;
+    }
+
+    _glfwInputError(GLFW_INVALID_ENUM,
+                    "Invalid string type init hint 0x%08X", hint);
 }
 
 GLFWAPI void glfwGetVersion(int* major, int* minor, int* rev)
 {
     if (major != NULL)
         *major = GLFW_VERSION_MAJOR;
-
     if (minor != NULL)
         *minor = GLFW_VERSION_MINOR;
-
     if (rev != NULL)
         *rev = GLFW_VERSION_REVISION;
 }
@@ -192,6 +298,30 @@ GLFWAPI const char* glfwGetVersionString(void)
     return _glfwPlatformGetVersionString();
 }
 
+GLFWAPI int glfwGetError(const char** description)
+{
+    _GLFWerror* error;
+    int code = GLFW_NO_ERROR;
+
+    if (description)
+        *description = NULL;
+
+    if (_glfw.initialized)
+        error = _glfwPlatformGetTls(&_glfw.errorSlot);
+    else
+        error = &_glfwMainThreadError;
+
+    if (error)
+    {
+        code = error->code;
+        error->code = GLFW_NO_ERROR;
+        if (description && code)
+            *description = error->description;
+    }
+
+    return code;
+}
+
 GLFWAPI GLFWerrorfun glfwSetErrorCallback(GLFWerrorfun cbfun)
 {
     _GLFW_SWAP_POINTERS(_glfwErrorCallback, cbfun);

raylib/external/glfw/src/input.c

@@ -1,8 +1,8 @@
 //========================================================================
-// GLFW 3.2 - www.glfw.org
+// GLFW 3.3 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-2016 Camilla Berglund <elmindreda@glfw.org>
+// Copyright (c) 2006-2016 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
@@ -29,11 +29,144 @@
 
 #include <assert.h>
 #include <float.h>
+#include <math.h>
 #include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
 
 // Internal key state used for sticky keys
 #define _GLFW_STICK 3
 
+// Internal constants for gamepad mapping source types
+#define _GLFW_JOYSTICK_AXIS     1
+#define _GLFW_JOYSTICK_BUTTON   2
+#define _GLFW_JOYSTICK_HATBIT   3
+
+// Finds a mapping based on joystick GUID
+//
+static _GLFWmapping* findMapping(const char* guid)
+{
+    int i;
+
+    for (i = 0;  i < _glfw.mappingCount;  i++)
+    {
+        if (strcmp(_glfw.mappings[i].guid, guid) == 0)
+            return _glfw.mappings + i;
+    }
+
+    return NULL;
+}
+
+// Parses an SDL_GameControllerDB line and adds it to the mapping list
+//
+static GLFWbool parseMapping(_GLFWmapping* mapping, const char* string)
+{
+    const char* c = string;
+    size_t i, length;
+    struct
+    {
+        const char* name;
+        _GLFWmapelement* element;
+    } fields[] =
+    {
+        { "platform",      NULL },
+        { "a",             mapping->buttons + GLFW_GAMEPAD_BUTTON_A },
+        { "b",             mapping->buttons + GLFW_GAMEPAD_BUTTON_B },
+        { "x",             mapping->buttons + GLFW_GAMEPAD_BUTTON_X },
+        { "y",             mapping->buttons + GLFW_GAMEPAD_BUTTON_Y },
+        { "back",          mapping->buttons + GLFW_GAMEPAD_BUTTON_BACK },
+        { "start",         mapping->buttons + GLFW_GAMEPAD_BUTTON_START },
+        { "guide",         mapping->buttons + GLFW_GAMEPAD_BUTTON_GUIDE },
+        { "leftshoulder",  mapping->buttons + GLFW_GAMEPAD_BUTTON_LEFT_BUMPER },
+        { "rightshoulder", mapping->buttons + GLFW_GAMEPAD_BUTTON_RIGHT_BUMPER },
+        { "leftstick",     mapping->buttons + GLFW_GAMEPAD_BUTTON_LEFT_THUMB },
+        { "rightstick",    mapping->buttons + GLFW_GAMEPAD_BUTTON_RIGHT_THUMB },
+        { "dpup",          mapping->buttons + GLFW_GAMEPAD_BUTTON_DPAD_UP },
+        { "dpright",       mapping->buttons + GLFW_GAMEPAD_BUTTON_DPAD_RIGHT },
+        { "dpdown",        mapping->buttons + GLFW_GAMEPAD_BUTTON_DPAD_DOWN },
+        { "dpleft",        mapping->buttons + GLFW_GAMEPAD_BUTTON_DPAD_LEFT },
+        { "lefttrigger",   mapping->axes + GLFW_GAMEPAD_AXIS_LEFT_TRIGGER },
+        { "righttrigger",  mapping->axes + GLFW_GAMEPAD_AXIS_RIGHT_TRIGGER },
+        { "leftx",         mapping->axes + GLFW_GAMEPAD_AXIS_LEFT_X },
+        { "lefty",         mapping->axes + GLFW_GAMEPAD_AXIS_LEFT_Y },
+        { "rightx",        mapping->axes + GLFW_GAMEPAD_AXIS_RIGHT_X },
+        { "righty",        mapping->axes + GLFW_GAMEPAD_AXIS_RIGHT_Y }
+    };
+
+    length = strcspn(c, ",");
+    if (length != 32 || c[length] != ',')
+    {
+        _glfwInputError(GLFW_INVALID_VALUE, NULL);
+        return GLFW_FALSE;
+    }
+
+    memcpy(mapping->guid, c, length);
+    c += length + 1;
+
+    length = strcspn(c, ",");
+    if (length >= sizeof(mapping->name) || c[length] != ',')
+    {
+        _glfwInputError(GLFW_INVALID_VALUE, NULL);
+        return GLFW_FALSE;
+    }
+
+    memcpy(mapping->name, c, length);
+    c += length + 1;
+
+    while (*c)
+    {
+        for (i = 0;  i < sizeof(fields) / sizeof(fields[0]);  i++)
+        {
+            length = strlen(fields[i].name);
+            if (strncmp(c, fields[i].name, length) != 0 || c[length] != ':')
+                continue;
+
+            c += length + 1;
+
+            if (fields[i].element)
+            {
+                if (*c == 'a')
+                    fields[i].element->type = _GLFW_JOYSTICK_AXIS;
+                else if (*c == 'b')
+                    fields[i].element->type = _GLFW_JOYSTICK_BUTTON;
+                else if (*c == 'h')
+                    fields[i].element->type = _GLFW_JOYSTICK_HATBIT;
+                else
+                    break;
+
+                if (fields[i].element->type == _GLFW_JOYSTICK_HATBIT)
+                {
+                    const unsigned long hat = strtoul(c + 1, (char**) &c, 10);
+                    const unsigned long bit = strtoul(c + 1, (char**) &c, 10);
+                    fields[i].element->value = (uint8_t) ((hat << 4) | bit);
+                }
+                else
+                    fields[i].element->value = (uint8_t) strtoul(c + 1, (char**) &c, 10);
+            }
+            else
+            {
+                length = strlen(_GLFW_PLATFORM_MAPPING_NAME);
+                if (strncmp(c, _GLFW_PLATFORM_MAPPING_NAME, length) != 0)
+                    return GLFW_FALSE;
+            }
+
+            break;
+        }
+
+        c += strcspn(c, ",");
+        c += strspn(c, ",");
+    }
+
+    for (i = 0;  i < 32;  i++)
+    {
+        if (mapping->guid[i] >= 'A' && mapping->guid[i] <= 'F')
+            mapping->guid[i] += 'a' - 'A';
+    }
+
+    _glfwPlatformUpdateGamepadGUID(mapping->guid);
+    return GLFW_TRUE;
+}
+
 
 //////////////////////////////////////////////////////////////////////////
 //////                         GLFW event API                       //////
@@ -90,7 +223,6 @@ void _glfwInputMouseClick(_GLFWwindow* window, int button, int action, int mods)
     if (button < 0 || button > GLFW_MOUSE_BUTTON_LAST)
         return;
 
-    // Register mouse button action
     if (action == GLFW_RELEASE && window->stickyMouseButtons)
         window->mouseButtons[button] = _GLFW_STICK;
     else
@@ -124,10 +256,34 @@ void _glfwInputDrop(_GLFWwindow* window, int count, const char** paths)
         window->callbacks.drop((GLFWwindow*) window, count, paths);
 }
 
-void _glfwInputJoystickChange(int joy, int event)
+void _glfwInputJoystick(_GLFWjoystick* js, int event)
 {
+    const int jid = (int) (js - _glfw.joysticks);
+
     if (_glfw.callbacks.joystick)
-        _glfw.callbacks.joystick(joy, event);
+        _glfw.callbacks.joystick(jid, event);
+}
+
+void _glfwInputJoystickAxis(_GLFWjoystick* js, int axis, float value)
+{
+    js->axes[axis] = value;
+}
+
+void _glfwInputJoystickButton(_GLFWjoystick* js, int button, char value)
+{
+    js->buttons[button] = value;
+}
+
+void _glfwInputJoystickHat(_GLFWjoystick* js, int hat, char value)
+{
+    const int base = js->buttonCount + hat * 4;
+
+    js->buttons[base + 0] = (value & 0x01) ? GLFW_PRESS : GLFW_RELEASE;
+    js->buttons[base + 1] = (value & 0x02) ? GLFW_PRESS : GLFW_RELEASE;
+    js->buttons[base + 2] = (value & 0x04) ? GLFW_PRESS : GLFW_RELEASE;
+    js->buttons[base + 3] = (value & 0x08) ? GLFW_PRESS : GLFW_RELEASE;
+
+    js->hats[hat] = value;
 }
 
 
@@ -135,11 +291,47 @@ void _glfwInputJoystickChange(int joy, int event)
 //////                       GLFW internal API                      //////
 //////////////////////////////////////////////////////////////////////////
 
-GLFWbool _glfwIsPrintable(int key)
+_GLFWjoystick* _glfwAllocJoystick(const char* name,
+                                  const char* guid,
+                                  int axisCount,
+                                  int buttonCount,
+                                  int hatCount)
 {
-    return (key >= GLFW_KEY_APOSTROPHE && key <= GLFW_KEY_WORLD_2) ||
+    int jid;
-           (key >= GLFW_KEY_KP_0 && key <= GLFW_KEY_KP_ADD) ||
+    _GLFWjoystick* js;
-           key == GLFW_KEY_KP_EQUAL;
+
+    for (jid = 0;  jid <= GLFW_JOYSTICK_LAST;  jid++)
+    {
+        if (!_glfw.joysticks[jid].present)
+            break;
+    }
+
+    if (jid > GLFW_JOYSTICK_LAST)
+        return NULL;
+
+    js = _glfw.joysticks + jid;
+    js->present     = GLFW_TRUE;
+    js->name        = strdup(name);
+    js->axes        = calloc(axisCount, sizeof(float));
+    js->buttons     = calloc(buttonCount + hatCount * 4, 1);
+    js->hats        = calloc(hatCount, 1);
+    js->axisCount   = axisCount;
+    js->buttonCount = buttonCount;
+    js->hatCount    = hatCount;
+    js->mapping     = findMapping(guid);
+
+    strcpy(js->guid, guid);
+
+    return js;
+}
+
+void _glfwFreeJoystick(_GLFWjoystick* js)
+{
+    free(js->name);
+    free(js->axes);
+    free(js->buttons);
+    free(js->hats);
+    memset(js, 0, sizeof(_GLFWjoystick));
 }
 
 
@@ -162,10 +354,10 @@ GLFWAPI int glfwGetInputMode(GLFWwindow* handle, int mode)
             return window->stickyKeys;
         case GLFW_STICKY_MOUSE_BUTTONS:
             return window->stickyMouseButtons;
-        default:
-            _glfwInputError(GLFW_INVALID_ENUM, "Invalid input mode %i", mode);
-            return 0;
     }
+
+    _glfwInputError(GLFW_INVALID_ENUM, "Invalid input mode 0x%08X", mode);
+    return 0;
 }
 
 GLFWAPI void glfwSetInputMode(GLFWwindow* handle, int mode, int value)
@@ -175,85 +367,104 @@ GLFWAPI void glfwSetInputMode(GLFWwindow* handle, int mode, int value)
 
     _GLFW_REQUIRE_INIT();
 
-    switch (mode)
+    if (mode == GLFW_CURSOR)
     {
-        case GLFW_CURSOR:
+        if (value != GLFW_CURSOR_NORMAL &&
+            value != GLFW_CURSOR_HIDDEN &&
+            value != GLFW_CURSOR_DISABLED)
         {
-            if (value != GLFW_CURSOR_NORMAL &&
+            _glfwInputError(GLFW_INVALID_ENUM,
-                value != GLFW_CURSOR_HIDDEN &&
+                            "Invalid cursor mode 0x%08X",
-                value != GLFW_CURSOR_DISABLED)
+                            value);
-            {
-                _glfwInputError(GLFW_INVALID_ENUM,
-                                "Invalid cursor mode %i",
-                                value);
-                return;
-            }
-
-            if (window->cursorMode == value)
-                return;
-
-            window->cursorMode = value;
-
-            _glfwPlatformGetCursorPos(window,
-                                      &window->virtualCursorPosX,
-                                      &window->virtualCursorPosY);
-
-            if (_glfwPlatformWindowFocused(window))
-                _glfwPlatformSetCursorMode(window, value);
-
             return;
         }
 
-        case GLFW_STICKY_KEYS:
+        if (window->cursorMode == value)
-        {
-            if (window->stickyKeys == value)
-                return;
-
-            if (!value)
-            {
-                int i;
-
-                // Release all sticky keys
-                for (i = 0;  i <= GLFW_KEY_LAST;  i++)
-                {
-                    if (window->keys[i] == _GLFW_STICK)
-                        window->keys[i] = GLFW_RELEASE;
-                }
-            }
-
-            window->stickyKeys = value ? GLFW_TRUE : GLFW_FALSE;
             return;
-        }
 
-        case GLFW_STICKY_MOUSE_BUTTONS:
+        window->cursorMode = value;
-        {
-            if (window->stickyMouseButtons == value)
-                return;
 
-            if (!value)
+        _glfwPlatformGetCursorPos(window,
-            {
+                                  &window->virtualCursorPosX,
-                int i;
+                                  &window->virtualCursorPosY);
 
-                // Release all sticky mouse buttons
+        if (_glfwPlatformWindowFocused(window))
-                for (i = 0;  i <= GLFW_MOUSE_BUTTON_LAST;  i++)
+            _glfwPlatformSetCursorMode(window, value);
-                {
-                    if (window->mouseButtons[i] == _GLFW_STICK)
-                        window->mouseButtons[i] = GLFW_RELEASE;
-                }
-            }
-
-            window->stickyMouseButtons = value ? GLFW_TRUE : GLFW_FALSE;
-            return;
-        }
     }
+    else if (mode == GLFW_STICKY_KEYS)
+    {
+        value = value ? GLFW_TRUE : GLFW_FALSE;
+        if (window->stickyKeys == value)
+            return;
 
-    _glfwInputError(GLFW_INVALID_ENUM, "Invalid input mode %i", mode);
+        if (!value)
+        {
+            int i;
+
+            // Release all sticky keys
+            for (i = 0;  i <= GLFW_KEY_LAST;  i++)
+            {
+                if (window->keys[i] == _GLFW_STICK)
+                    window->keys[i] = GLFW_RELEASE;
+            }
+        }
+
+        window->stickyKeys = value ? GLFW_TRUE : GLFW_FALSE;
+    }
+    else if (mode == GLFW_STICKY_MOUSE_BUTTONS)
+    {
+        value = value ? GLFW_TRUE : GLFW_FALSE;
+        if (window->stickyMouseButtons == value)
+            return;
+
+        if (!value)
+        {
+            int i;
+
+            // Release all sticky mouse buttons
+            for (i = 0;  i <= GLFW_MOUSE_BUTTON_LAST;  i++)
+            {
+                if (window->mouseButtons[i] == _GLFW_STICK)
+                    window->mouseButtons[i] = GLFW_RELEASE;
+            }
+        }
+
+        window->stickyMouseButtons = value ? GLFW_TRUE : GLFW_FALSE;
+    }
+    else
+        _glfwInputError(GLFW_INVALID_ENUM, "Invalid input mode 0x%08X", mode);
 }
 
 GLFWAPI const char* glfwGetKeyName(int key, int scancode)
 {
     _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
-    return _glfwPlatformGetKeyName(key, scancode);
+
+    if (key != GLFW_KEY_UNKNOWN)
+    {
+        if (key != GLFW_KEY_KP_EQUAL &&
+            (key < GLFW_KEY_KP_0 || key > GLFW_KEY_KP_ADD) &&
+            (key < GLFW_KEY_APOSTROPHE || key > GLFW_KEY_WORLD_2))
+        {
+            return NULL;
+        }
+
+        scancode = _glfwPlatformGetKeyScancode(key);
+    }
+
+    return _glfwPlatformGetScancodeName(scancode);
+}
+
+GLFWAPI int glfwGetKeyScancode(int key)
+{
+    _GLFW_REQUIRE_INIT_OR_RETURN(-1);
+
+    if (key < GLFW_KEY_SPACE || key > GLFW_KEY_LAST)
+    {
+        _glfwInputError(GLFW_INVALID_ENUM, "Invalid key %i", key);
+        return GLFW_RELEASE;
+    }
+
+    return _glfwPlatformGetKeyScancode(key);
 }
 
 GLFWAPI int glfwGetKey(GLFWwindow* handle, int key)
@@ -391,7 +602,7 @@ GLFWAPI GLFWcursor* glfwCreateStandardCursor(int shape)
         shape != GLFW_HRESIZE_CURSOR &&
         shape != GLFW_VRESIZE_CURSOR)
     {
-        _glfwInputError(GLFW_INVALID_ENUM, "Invalid standard cursor %i", shape);
+        _glfwInputError(GLFW_INVALID_ENUM, "Invalid standard cursor 0x%08X", shape);
         return NULL;
     }
 
@@ -540,62 +751,167 @@ GLFWAPI GLFWdropfun glfwSetDropCallback(GLFWwindow* handle, GLFWdropfun cbfun)
     return cbfun;
 }
 
-GLFWAPI int glfwJoystickPresent(int joy)
+GLFWAPI int glfwJoystickPresent(int jid)
 {
-    _GLFW_REQUIRE_INIT_OR_RETURN(0);
+    _GLFWjoystick* js;
 
-    if (joy < 0 || joy > GLFW_JOYSTICK_LAST)
+    assert(jid >= GLFW_JOYSTICK_1);
+    assert(jid <= GLFW_JOYSTICK_LAST);
+
+    _GLFW_REQUIRE_INIT_OR_RETURN(GLFW_FALSE);
+
+    if (jid < 0 || jid > GLFW_JOYSTICK_LAST)
     {
-        _glfwInputError(GLFW_INVALID_ENUM, "Invalid joystick %i", joy);
+        _glfwInputError(GLFW_INVALID_ENUM, "Invalid joystick ID %i", jid);
-        return 0;
+        return GLFW_FALSE;
     }
 
-    return _glfwPlatformJoystickPresent(joy);
+    js = _glfw.joysticks + jid;
+    if (!js->present)
+        return GLFW_FALSE;
+
+    return _glfwPlatformPollJoystick(js, _GLFW_POLL_PRESENCE);
 }
 
-GLFWAPI const float* glfwGetJoystickAxes(int joy, int* count)
+GLFWAPI const float* glfwGetJoystickAxes(int jid, int* count)
 {
+    _GLFWjoystick* js;
+
+    assert(jid >= GLFW_JOYSTICK_1);
+    assert(jid <= GLFW_JOYSTICK_LAST);
     assert(count != NULL);
+
     *count = 0;
 
     _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
 
-    if (joy < 0 || joy > GLFW_JOYSTICK_LAST)
+    if (jid < 0 || jid > GLFW_JOYSTICK_LAST)
     {
-        _glfwInputError(GLFW_INVALID_ENUM, "Invalid joystick %i", joy);
+        _glfwInputError(GLFW_INVALID_ENUM, "Invalid joystick ID %i", jid);
         return NULL;
     }
 
-    return _glfwPlatformGetJoystickAxes(joy, count);
+    js = _glfw.joysticks + jid;
+    if (!js->present)
+        return NULL;
+
+    if (!_glfwPlatformPollJoystick(js, _GLFW_POLL_AXES))
+        return NULL;
+
+    *count = js->axisCount;
+    return js->axes;
 }
 
-GLFWAPI const unsigned char* glfwGetJoystickButtons(int joy, int* count)
+GLFWAPI const unsigned char* glfwGetJoystickButtons(int jid, int* count)
 {
+    _GLFWjoystick* js;
+
+    assert(jid >= GLFW_JOYSTICK_1);
+    assert(jid <= GLFW_JOYSTICK_LAST);
     assert(count != NULL);
+
     *count = 0;
 
     _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
 
-    if (joy < 0 || joy > GLFW_JOYSTICK_LAST)
+    if (jid < 0 || jid > GLFW_JOYSTICK_LAST)
     {
-        _glfwInputError(GLFW_INVALID_ENUM, "Invalid joystick %i", joy);
+        _glfwInputError(GLFW_INVALID_ENUM, "Invalid joystick ID %i", jid);
         return NULL;
     }
 
-    return _glfwPlatformGetJoystickButtons(joy, count);
+    js = _glfw.joysticks + jid;
+    if (!js->present)
+        return NULL;
+
+    if (!_glfwPlatformPollJoystick(js, _GLFW_POLL_BUTTONS))
+        return NULL;
+
+    if (_glfw.hints.init.hatButtons)
+        *count = js->buttonCount + js->hatCount * 4;
+    else
+        *count = js->buttonCount;
+
+    return js->buttons;
 }
 
-GLFWAPI const char* glfwGetJoystickName(int joy)
+GLFWAPI const unsigned char* glfwGetJoystickHats(int jid, int* count)
 {
+    _GLFWjoystick* js;
+
+    assert(jid >= GLFW_JOYSTICK_1);
+    assert(jid <= GLFW_JOYSTICK_LAST);
+    assert(count != NULL);
+
+    *count = 0;
+
     _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
 
-    if (joy < 0 || joy > GLFW_JOYSTICK_LAST)
+    if (jid < 0 || jid > GLFW_JOYSTICK_LAST)
     {
-        _glfwInputError(GLFW_INVALID_ENUM, "Invalid joystick %i", joy);
+        _glfwInputError(GLFW_INVALID_ENUM, "Invalid joystick ID %i", jid);
         return NULL;
     }
 
-    return _glfwPlatformGetJoystickName(joy);
+    js = _glfw.joysticks + jid;
+    if (!js->present)
+        return NULL;
+
+    if (!_glfwPlatformPollJoystick(js, _GLFW_POLL_BUTTONS))
+        return NULL;
+
+    *count = js->hatCount;
+    return js->hats;
+}
+
+GLFWAPI const char* glfwGetJoystickName(int jid)
+{
+    _GLFWjoystick* js;
+
+    assert(jid >= GLFW_JOYSTICK_1);
+    assert(jid <= GLFW_JOYSTICK_LAST);
+
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+
+    if (jid < 0 || jid > GLFW_JOYSTICK_LAST)
+    {
+        _glfwInputError(GLFW_INVALID_ENUM, "Invalid joystick ID %i", jid);
+        return NULL;
+    }
+
+    js = _glfw.joysticks + jid;
+    if (!js->present)
+        return NULL;
+
+    if (!_glfwPlatformPollJoystick(js, _GLFW_POLL_PRESENCE))
+        return NULL;
+
+    return js->name;
+}
+
+GLFWAPI const char* glfwGetJoystickGUID(int jid)
+{
+    _GLFWjoystick* js;
+
+    assert(jid >= GLFW_JOYSTICK_1);
+    assert(jid <= GLFW_JOYSTICK_LAST);
+
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+
+    if (jid < 0 || jid > GLFW_JOYSTICK_LAST)
+    {
+        _glfwInputError(GLFW_INVALID_ENUM, "Invalid joystick ID %i", jid);
+        return NULL;
+    }
+
+    js = _glfw.joysticks + jid;
+    if (!js->present)
+        return NULL;
+
+    if (!_glfwPlatformPollJoystick(js, _GLFW_POLL_PRESENCE))
+        return NULL;
+
+    return js->guid;
 }
 
 GLFWAPI GLFWjoystickfun glfwSetJoystickCallback(GLFWjoystickfun cbfun)
@@ -605,29 +921,200 @@ GLFWAPI GLFWjoystickfun glfwSetJoystickCallback(GLFWjoystickfun cbfun)
     return cbfun;
 }
 
+GLFWAPI int glfwUpdateGamepadMappings(const char* string)
+{
+    int jid;
+    const char* c = string;
+
+    assert(string != NULL);
+
+    _GLFW_REQUIRE_INIT_OR_RETURN(GLFW_FALSE);
+
+    while (*c)
+    {
+        if (isxdigit(*c))
+        {
+            char line[1024];
+
+            const size_t length = strcspn(c, "\r\n");
+            if (length < sizeof(line))
+            {
+                _GLFWmapping mapping = {{0}};
+
+                memcpy(line, c, length);
+                line[length] = '\0';
+
+                if (parseMapping(&mapping, line))
+                {
+                    _GLFWmapping* previous = findMapping(mapping.guid);
+                    if (previous)
+                        *previous = mapping;
+                    else
+                    {
+                        _glfw.mappingCount++;
+                        _glfw.mappings =
+                            realloc(_glfw.mappings,
+                                    sizeof(_GLFWmapping) * _glfw.mappingCount);
+                        _glfw.mappings[_glfw.mappingCount - 1] = mapping;
+                    }
+                }
+            }
+
+            c += length;
+        }
+        else
+        {
+            c += strcspn(c, "\r\n");
+            c += strspn(c, "\r\n");
+        }
+    }
+
+    for (jid = 0;  jid <= GLFW_JOYSTICK_LAST;  jid++)
+    {
+        _GLFWjoystick* js = _glfw.joysticks + jid;
+        if (js->present)
+            js->mapping = findMapping(js->guid);
+    }
+
+    return GLFW_TRUE;
+}
+
+GLFWAPI int glfwJoystickIsGamepad(int jid)
+{
+    _GLFWjoystick* js;
+
+    assert(jid >= GLFW_JOYSTICK_1);
+    assert(jid <= GLFW_JOYSTICK_LAST);
+
+    _GLFW_REQUIRE_INIT_OR_RETURN(GLFW_FALSE);
+
+    if (jid < 0 || jid > GLFW_JOYSTICK_LAST)
+    {
+        _glfwInputError(GLFW_INVALID_ENUM, "Invalid joystick ID %i", jid);
+        return GLFW_FALSE;
+    }
+
+    js = _glfw.joysticks + jid;
+    if (!js->present)
+        return GLFW_FALSE;
+
+    if (!_glfwPlatformPollJoystick(js, _GLFW_POLL_PRESENCE))
+        return GLFW_FALSE;
+
+    return js->mapping != NULL;
+}
+
+GLFWAPI const char* glfwGetGamepadName(int jid)
+{
+    _GLFWjoystick* js;
+
+    assert(jid >= GLFW_JOYSTICK_1);
+    assert(jid <= GLFW_JOYSTICK_LAST);
+
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+
+    if (jid < 0 || jid > GLFW_JOYSTICK_LAST)
+    {
+        _glfwInputError(GLFW_INVALID_ENUM, "Invalid joystick ID %i", jid);
+        return NULL;
+    }
+
+    js = _glfw.joysticks + jid;
+    if (!js->present)
+        return NULL;
+
+    if (!_glfwPlatformPollJoystick(js, _GLFW_POLL_PRESENCE))
+        return NULL;
+
+    if (!js->mapping)
+        return NULL;
+
+    return js->mapping->name;
+}
+
+GLFWAPI int glfwGetGamepadState(int jid, GLFWgamepadstate* state)
+{
+    int i;
+    _GLFWjoystick* js;
+
+    assert(jid >= GLFW_JOYSTICK_1);
+    assert(jid <= GLFW_JOYSTICK_LAST);
+    assert(state != NULL);
+
+    memset(state, 0, sizeof(GLFWgamepadstate));
+
+    _GLFW_REQUIRE_INIT_OR_RETURN(GLFW_FALSE);
+
+    if (jid < 0 || jid > GLFW_JOYSTICK_LAST)
+    {
+        _glfwInputError(GLFW_INVALID_ENUM, "Invalid joystick ID %i", jid);
+        return GLFW_FALSE;
+    }
+
+    js = _glfw.joysticks + jid;
+    if (!js->present)
+        return GLFW_FALSE;
+
+    if (!_glfwPlatformPollJoystick(js, _GLFW_POLL_ALL))
+        return GLFW_FALSE;
+
+    if (!js->mapping)
+        return GLFW_FALSE;
+
+    for (i = 0;  i <= GLFW_GAMEPAD_BUTTON_LAST;  i++)
+    {
+        if (js->mapping->buttons[i].type == _GLFW_JOYSTICK_AXIS)
+        {
+            if (fabs(js->axes[js->mapping->buttons[i].value]) > 0.5)
+                state->buttons[i] = GLFW_PRESS;
+        }
+        else if (js->mapping->buttons[i].type == _GLFW_JOYSTICK_HATBIT)
+        {
+            const unsigned int hat = js->mapping->buttons[i].value >> 4;
+            const unsigned int bit = js->mapping->buttons[i].value & 0xf;
+            if (js->hats[hat] & bit)
+                state->buttons[i] = GLFW_PRESS;
+        }
+        else if (js->mapping->buttons[i].type == _GLFW_JOYSTICK_BUTTON)
+            state->buttons[i] = js->buttons[js->mapping->buttons[i].value];
+    }
+
+    for (i = 0;  i <= GLFW_GAMEPAD_AXIS_LAST;  i++)
+    {
+        if (js->mapping->axes[i].type == _GLFW_JOYSTICK_AXIS)
+            state->axes[i] = js->axes[js->mapping->axes[i].value];
+        else if (js->mapping->buttons[i].type == _GLFW_JOYSTICK_HATBIT)
+        {
+            const unsigned int hat = js->mapping->buttons[i].value >> 4;
+            const unsigned int bit = js->mapping->buttons[i].value & 0xf;
+            if (js->hats[hat] & bit)
+                state->axes[i] = 1.f;
+        }
+        else if (js->mapping->buttons[i].type == _GLFW_JOYSTICK_BUTTON)
+            state->axes[i] = (float) js->buttons[js->mapping->axes[i].value];
+    }
+
+    return GLFW_TRUE;
+}
+
 GLFWAPI void glfwSetClipboardString(GLFWwindow* handle, const char* string)
 {
-    _GLFWwindow* window = (_GLFWwindow*) handle;
-    assert(window != NULL);
     assert(string != NULL);
 
     _GLFW_REQUIRE_INIT();
-    _glfwPlatformSetClipboardString(window, string);
+    _glfwPlatformSetClipboardString(string);
 }
 
 GLFWAPI const char* glfwGetClipboardString(GLFWwindow* handle)
 {
-    _GLFWwindow* window = (_GLFWwindow*) handle;
-    assert(window != NULL);
-
     _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
-    return _glfwPlatformGetClipboardString(window);
+    return _glfwPlatformGetClipboardString();
 }
 
 GLFWAPI double glfwGetTime(void)
 {
     _GLFW_REQUIRE_INIT_OR_RETURN(0.0);
-    return (double) (_glfwPlatformGetTimerValue() - _glfw.timerOffset) /
+    return (double) (_glfwPlatformGetTimerValue() - _glfw.timer.offset) /
         _glfwPlatformGetTimerFrequency();
 }
 
@@ -641,7 +1128,7 @@ GLFWAPI void glfwSetTime(double time)
         return;
     }
 
-    _glfw.timerOffset = _glfwPlatformGetTimerValue() -
+    _glfw.timer.offset = _glfwPlatformGetTimerValue() -
         (uint64_t) (time * _glfwPlatformGetTimerFrequency());
 }
 

raylib/external/glfw/src/internal.h

@@ -1,8 +1,8 @@
 //========================================================================
-// GLFW 3.2 - www.glfw.org
+// GLFW 3.3 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-2016 Camilla Berglund <elmindreda@glfw.org>
+// Copyright (c) 2006-2016 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
@@ -25,9 +25,7 @@
 //
 //========================================================================
 
-#ifndef _glfw3_internal_h_
+#pragma once
-#define _glfw3_internal_h_
-
 
 #if defined(_GLFW_USE_CONFIG_H)
  #include "glfw_config.h"
@@ -37,6 +35,8 @@
     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)       || \
@@ -48,8 +48,20 @@
 #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 struct _GLFWerror       _GLFWerror;
+typedef struct _GLFWinitconfig  _GLFWinitconfig;
 typedef struct _GLFWwndconfig   _GLFWwndconfig;
 typedef struct _GLFWctxconfig   _GLFWctxconfig;
 typedef struct _GLFWfbconfig    _GLFWfbconfig;
@@ -58,6 +70,11 @@ typedef struct _GLFWwindow      _GLFWwindow;
 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;
 
 typedef void (* _GLFWmakecontextcurrentfun)(_GLFWwindow*);
 typedef void (* _GLFWswapbuffersfun)(_GLFWwindow*);
@@ -69,6 +86,7 @@ typedef void (* _GLFWdestroycontextfun)(_GLFWwindow*);
 #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
@@ -110,6 +128,7 @@ typedef enum VkStructureType
     VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR = 1000006000,
     VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR = 1000007000,
     VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR = 1000009000,
+    VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK = 1000053000,
     VK_STRUCTURE_TYPE_MAX_ENUM = 0x7FFFFFFF
 } VkStructureType;
 
@@ -171,6 +190,8 @@ typedef void (APIENTRY * PFN_vkVoidFunction)(void);
  #include "wl_platform.h"
 #elif defined(_GLFW_MIR)
  #include "mir_platform.h"
+#elif defined(_GLFW_OSMESA)
+ #include "null_platform.h"
 #else
  #error "No supported window creation API selected"
 #endif
@@ -216,13 +237,13 @@ typedef void (APIENTRY * PFN_vkVoidFunction)(void);
 
 // Checks for whether the library has been initialized
 #define _GLFW_REQUIRE_INIT()                         \
-    if (!_glfwInitialized)                           \
+    if (!_glfw.initialized)                          \
     {                                                \
         _glfwInputError(GLFW_NOT_INITIALIZED, NULL); \
         return;                                      \
     }
 #define _GLFW_REQUIRE_INIT_OR_RETURN(x)              \
-    if (!_glfwInitialized)                           \
+    if (!_glfw.initialized)                          \
     {                                                \
         _glfwInputError(GLFW_NOT_INITIALIZED, NULL); \
         return x;                                    \
@@ -242,6 +263,30 @@ typedef void (APIENTRY * PFN_vkVoidFunction)(void);
 // Platform-independent structures
 //========================================================================
 
+struct _GLFWerror
+{
+    _GLFWerror*     next;
+    int             code;
+    char            description[_GLFW_MESSAGE_SIZE];
+};
+
+/*! @brief Initialization configuration.
+ *
+ *  Parameters relating to the initialization of the library.
+ */
+struct _GLFWinitconfig
+{
+    GLFWbool      hatButtons;
+    struct {
+        GLFWbool  menubar;
+        GLFWbool  chdir;
+    } ns;
+    struct {
+        char      className[256];
+        char      classClass[256];
+    } x11;
+};
+
 /*! @brief Window configuration.
  *
  *  Parameters relating to the creation of the window but not directly related
@@ -260,6 +305,11 @@ struct _GLFWwndconfig
     GLFWbool      autoIconify;
     GLFWbool      floating;
     GLFWbool      maximized;
+    GLFWbool      centerCursor;
+    struct {
+        GLFWbool  retina;
+        GLFWbool  frame;
+    } ns;
 };
 
 /*! @brief Context configuration.
@@ -281,6 +331,9 @@ struct _GLFWctxconfig
     int           robustness;
     int           release;
     _GLFWwindow*  share;
+    struct {
+        GLFWbool  offline;
+    } nsgl;
 };
 
 /*! @brief Framebuffer configuration.
@@ -308,6 +361,7 @@ struct _GLFWfbconfig
     int         samples;
     GLFWbool    sRGB;
     GLFWbool    doublebuffer;
+    GLFWbool    transparent;
     uintptr_t   handle;
 };
 
@@ -338,6 +392,8 @@ struct _GLFWcontext
     _GLFW_PLATFORM_CONTEXT_STATE;
     // This is defined in egl_context.h
     _GLFW_EGL_CONTEXT_STATE;
+    // This is defined in osmesa_context.h
+    _GLFW_OSMESA_CONTEXT_STATE;
 };
 
 /*! @brief Window and context structure.
@@ -351,7 +407,7 @@ struct _GLFWwindow
     GLFWbool            decorated;
     GLFWbool            autoIconify;
     GLFWbool            floating;
-    GLFWbool            closed;
+    GLFWbool            shouldClose;
     void*               userPointer;
     GLFWvidmode         videoMode;
     _GLFWmonitor*       monitor;
@@ -378,6 +434,7 @@ struct _GLFWwindow
         GLFWwindowrefreshfun    refresh;
         GLFWwindowfocusfun      focus;
         GLFWwindowiconifyfun    iconify;
+        GLFWwindowmaximizefun   maximize;
         GLFWframebuffersizefun  fbsize;
         GLFWmousebuttonfun      mouseButton;
         GLFWcursorposfun        cursorPos;
@@ -426,41 +483,115 @@ struct _GLFWcursor
     _GLFW_PLATFORM_CURSOR_STATE;
 };
 
+/*! @brief Gamepad mapping element structure
+ */
+struct _GLFWmapelement
+{
+    uint8_t         type;
+    uint8_t         value;
+};
+
+/*! @brief Gamepad mapping structure
+ */
+struct _GLFWmapping
+{
+    char            name[128];
+    char            guid[33];
+    _GLFWmapelement buttons[15];
+    _GLFWmapelement axes[6];
+};
+
+/*! @brief Joystick structure
+ */
+struct _GLFWjoystick
+{
+    GLFWbool        present;
+    float*          axes;
+    int             axisCount;
+    unsigned char*  buttons;
+    int             buttonCount;
+    unsigned char*  hats;
+    int             hatCount;
+    char*           name;
+    char            guid[33];
+    _GLFWmapping*   mapping;
+
+    // This is defined in the joystick API's joystick.h
+    _GLFW_PLATFORM_JOYSTICK_STATE;
+};
+
+/*! @brief Thread local storage structure.
+ */
+struct _GLFWtls
+{
+    // This is defined in the platform's thread.h
+    _GLFW_PLATFORM_TLS_STATE;
+};
+
+/*! @brief Mutex structure.
+ */
+struct _GLFWmutex
+{
+    // This is defined in the platform's thread.h
+    _GLFW_PLATFORM_MUTEX_STATE;
+};
+
 /*! @brief Library global data.
  */
 struct _GLFWlibrary
 {
+    GLFWbool            initialized;
+
     struct {
+        _GLFWinitconfig init;
         _GLFWfbconfig   framebuffer;
         _GLFWwndconfig  window;
         _GLFWctxconfig  context;
         int             refreshRate;
     } hints;
 
+    _GLFWerror*         errorListHead;
     _GLFWcursor*        cursorListHead;
-
     _GLFWwindow*        windowListHead;
 
     _GLFWmonitor**      monitors;
     int                 monitorCount;
 
-    uint64_t            timerOffset;
+    _GLFWjoystick       joysticks[GLFW_JOYSTICK_LAST + 1];
+    _GLFWmapping*       mappings;
+    int                 mappingCount;
+
+    _GLFWtls            errorSlot;
+    _GLFWtls            contextSlot;
+    _GLFWmutex          errorLock;
+
+    struct {
+        uint64_t        offset;
+        // This is defined in the platform's time.h
+        _GLFW_PLATFORM_LIBRARY_TIMER_STATE;
+    } timer;
 
     struct {
         GLFWbool        available;
         void*           handle;
-        char**          extensions;
+        char*           extensions[2];
-        uint32_t        extensionCount;
 #if !defined(_GLFW_VULKAN_STATIC)
         PFN_vkEnumerateInstanceExtensionProperties EnumerateInstanceExtensionProperties;
         PFN_vkGetInstanceProcAddr GetInstanceProcAddr;
 #endif
         GLFWbool        KHR_surface;
+#if defined(_GLFW_WIN32)
         GLFWbool        KHR_win32_surface;
+#elif defined(_GLFW_COCOA)
+        GLFWbool        MVK_macos_surface;
+#elif defined(_GLFW_X11)
         GLFWbool        KHR_xlib_surface;
         GLFWbool        KHR_xcb_surface;
+#elif defined(_GLFW_WAYLAND)
         GLFWbool        KHR_wayland_surface;
+#elif defined(_GLFW_MIR)
         GLFWbool        KHR_mir_surface;
+#endif
     } vk;
 
     struct {
@@ -472,14 +603,12 @@ struct _GLFWlibrary
     _GLFW_PLATFORM_LIBRARY_WINDOW_STATE;
     // This is defined in the context API's context.h
     _GLFW_PLATFORM_LIBRARY_CONTEXT_STATE;
-    // This is defined in the platform's time.h
-    _GLFW_PLATFORM_LIBRARY_TIME_STATE;
     // This is defined in the platform's joystick.h
     _GLFW_PLATFORM_LIBRARY_JOYSTICK_STATE;
-    // This is defined in the platform's tls.h
-    _GLFW_PLATFORM_LIBRARY_TLS_STATE;
     // This is defined in egl_context.h
     _GLFW_EGL_LIBRARY_CONTEXT_STATE;
+    // This is defined in osmesa_context.h
+    _GLFW_OSMESA_LIBRARY_CONTEXT_STATE;
 };
 
 
@@ -487,13 +616,7 @@ struct _GLFWlibrary
 // Global state shared between compilation units of GLFW
 //========================================================================
 
-/*! @brief Flag indicating whether GLFW has been successfully initialized.
+/*! @brief All global data shared between compilation units.
- */
-extern GLFWbool _glfwInitialized;
-
-/*! @brief All global data protected by @ref _glfwInitialized.
- *  This should only be touched after a call to @ref glfwInit that has not been
- *  followed by a call to @ref glfwTerminate.
  */
 extern _GLFWlibrary _glfw;
 
@@ -502,312 +625,101 @@ extern _GLFWlibrary _glfw;
 // Platform API functions
 //========================================================================
 
-/*! @brief Initializes the platform-specific part of the library.
+/*! @addtogroup platform @{ */
- *  @return `GLFW_TRUE` if successful, or `GLFW_FALSE` if an error occurred.
+
- *  @ingroup platform
- */
 int _glfwPlatformInit(void);
-
-/*! @brief Terminates the platform-specific part of the library.
- *  @ingroup platform
- */
 void _glfwPlatformTerminate(void);
-
-/*! @copydoc glfwGetVersionString
- *  @ingroup platform
- *
- *  @note The returned string must be available for the duration of the program.
- *
- *  @note The returned string must not change for the duration of the program.
- */
 const char* _glfwPlatformGetVersionString(void);
 
-/*! @copydoc glfwGetCursorPos
- *  @ingroup platform
- */
 void _glfwPlatformGetCursorPos(_GLFWwindow* window, double* xpos, double* ypos);
-
-/*! @copydoc glfwSetCursorPos
- *  @ingroup platform
- */
 void _glfwPlatformSetCursorPos(_GLFWwindow* window, double xpos, double ypos);
-
-/*! @brief Sets the specified cursor mode of the specified window.
- *  @param[in] window The window whose cursor mode to set.
- *  @ingroup platform
- */
 void _glfwPlatformSetCursorMode(_GLFWwindow* window, int mode);
+int _glfwPlatformCreateCursor(_GLFWcursor* cursor, const GLFWimage* image, int xhot, int yhot);
+int _glfwPlatformCreateStandardCursor(_GLFWcursor* cursor, int shape);
+void _glfwPlatformDestroyCursor(_GLFWcursor* cursor);
+void _glfwPlatformSetCursor(_GLFWwindow* window, _GLFWcursor* cursor);
 
-/*! @copydoc glfwGetKeyName
+const char* _glfwPlatformGetScancodeName(int scancode);
- *  @ingroup platform
+int _glfwPlatformGetKeyScancode(int key);
- */
-const char* _glfwPlatformGetKeyName(int key, int scancode);
 
-/*! @copydoc glfwGetMonitors
- *  @ingroup platform
- */
-_GLFWmonitor** _glfwPlatformGetMonitors(int* count);
-
-/*! @brief Checks whether two monitor objects represent the same monitor.
- *
- *  @param[in] first The first monitor.
- *  @param[in] second The second monitor.
- *  @return @c GLFW_TRUE if the monitor objects represent the same monitor, or
- *  @c GLFW_FALSE otherwise.
- *  @ingroup platform
- */
-GLFWbool _glfwPlatformIsSameMonitor(_GLFWmonitor* first, _GLFWmonitor* second);
-
-/*! @copydoc glfwGetMonitorPos
- *  @ingroup platform
- */
 void _glfwPlatformGetMonitorPos(_GLFWmonitor* monitor, int* xpos, int* ypos);
-
+void _glfwPlatformGetMonitorContentScale(_GLFWmonitor* monitor, float* xscale, float* yscale);
-/*! @copydoc glfwGetVideoModes
- *  @ingroup platform
- */
 GLFWvidmode* _glfwPlatformGetVideoModes(_GLFWmonitor* monitor, int* count);
-
-/*! @ingroup platform
- */
 void _glfwPlatformGetVideoMode(_GLFWmonitor* monitor, GLFWvidmode* mode);
-
-/*! @copydoc glfwGetGammaRamp
- *  @ingroup platform
- */
 void _glfwPlatformGetGammaRamp(_GLFWmonitor* monitor, GLFWgammaramp* ramp);
-
-/*! @copydoc glfwSetGammaRamp
- *  @ingroup platform
- */
 void _glfwPlatformSetGammaRamp(_GLFWmonitor* monitor, const GLFWgammaramp* ramp);
 
-/*! @copydoc glfwSetClipboardString
+void _glfwPlatformSetClipboardString(const char* string);
- *  @ingroup platform
+const char* _glfwPlatformGetClipboardString(void);
- */
-void _glfwPlatformSetClipboardString(_GLFWwindow* window, const char* string);
 
-/*! @copydoc glfwGetClipboardString
+int _glfwPlatformPollJoystick(_GLFWjoystick* js, int mode);
- *  @ingroup platform
+void _glfwPlatformUpdateGamepadGUID(char* guid);
- *
- *  @note The returned string must be valid until the next call to @ref
- *  _glfwPlatformGetClipboardString or @ref _glfwPlatformSetClipboardString.
- */
-const char* _glfwPlatformGetClipboardString(_GLFWwindow* window);
 
-/*! @copydoc glfwJoystickPresent
- *  @ingroup platform
- */
-int _glfwPlatformJoystickPresent(int joy);
-
-/*! @copydoc glfwGetJoystickAxes
- *  @ingroup platform
- */
-const float* _glfwPlatformGetJoystickAxes(int joy, int* count);
-
-/*! @copydoc glfwGetJoystickButtons
- *  @ingroup platform
- */
-const unsigned char* _glfwPlatformGetJoystickButtons(int joy, int* count);
-
-/*! @copydoc glfwGetJoystickName
- *  @ingroup platform
- */
-const char* _glfwPlatformGetJoystickName(int joy);
-
-/*! @copydoc glfwGetTimerValue
- *  @ingroup platform
- */
 uint64_t _glfwPlatformGetTimerValue(void);
-
-/*! @copydoc glfwGetTimerFrequency
- *  @ingroup platform
- */
 uint64_t _glfwPlatformGetTimerFrequency(void);
 
-/*! @ingroup platform
- */
 int _glfwPlatformCreateWindow(_GLFWwindow* window,
                               const _GLFWwndconfig* wndconfig,
                               const _GLFWctxconfig* ctxconfig,
                               const _GLFWfbconfig* fbconfig);
-
-/*! @ingroup platform
- */
 void _glfwPlatformDestroyWindow(_GLFWwindow* window);
-
-/*! @copydoc glfwSetWindowTitle
- *  @ingroup platform
- */
 void _glfwPlatformSetWindowTitle(_GLFWwindow* window, const char* title);
-
-/*! @copydoc glfwSetWindowIcon
- *  @ingroup platform
- */
 void _glfwPlatformSetWindowIcon(_GLFWwindow* window, int count, const GLFWimage* images);
-
-/*! @copydoc glfwGetWindowPos
- *  @ingroup platform
- */
 void _glfwPlatformGetWindowPos(_GLFWwindow* window, int* xpos, int* ypos);
-
-/*! @copydoc glfwSetWindowPos
- *  @ingroup platform
- */
 void _glfwPlatformSetWindowPos(_GLFWwindow* window, int xpos, int ypos);
-
-/*! @copydoc glfwGetWindowSize
- *  @ingroup platform
- */
 void _glfwPlatformGetWindowSize(_GLFWwindow* window, int* width, int* height);
-
-/*! @copydoc glfwSetWindowSize
- *  @ingroup platform
- */
 void _glfwPlatformSetWindowSize(_GLFWwindow* window, int width, int height);
-
-/*! @copydoc glfwSetWindowSizeLimits
- *  @ingroup platform
- */
 void _glfwPlatformSetWindowSizeLimits(_GLFWwindow* window, int minwidth, int minheight, int maxwidth, int maxheight);
-
-/*! @copydoc glfwSetWindowAspectRatio
- *  @ingroup platform
- */
 void _glfwPlatformSetWindowAspectRatio(_GLFWwindow* window, int numer, int denom);
-
-/*! @copydoc glfwGetFramebufferSize
- *  @ingroup platform
- */
 void _glfwPlatformGetFramebufferSize(_GLFWwindow* window, int* width, int* height);
-
-/*! @copydoc glfwGetWindowFrameSize
- *  @ingroup platform
- */
 void _glfwPlatformGetWindowFrameSize(_GLFWwindow* window, int* left, int* top, int* right, int* bottom);
-
+void _glfwPlatformGetWindowContentScale(_GLFWwindow* window, float* xscale, float* yscale);
-/*! @copydoc glfwIconifyWindow
- *  @ingroup platform
- */
 void _glfwPlatformIconifyWindow(_GLFWwindow* window);
-
-/*! @copydoc glfwRestoreWindow
- *  @ingroup platform
- */
 void _glfwPlatformRestoreWindow(_GLFWwindow* window);
-
-/*! @copydoc glfwMaximizeWindow
- *  @ingroup platform
- */
 void _glfwPlatformMaximizeWindow(_GLFWwindow* window);
-
-/*! @copydoc glfwShowWindow
- *  @ingroup platform
- */
 void _glfwPlatformShowWindow(_GLFWwindow* window);
-
-/*! @copydoc glfwHideWindow
- *  @ingroup platform
- */
 void _glfwPlatformHideWindow(_GLFWwindow* window);
-
+void _glfwPlatformRequestWindowAttention(_GLFWwindow* window);
-/*! @copydoc glfwFocusWindow
- *  @ingroup platform
- */
 void _glfwPlatformFocusWindow(_GLFWwindow* window);
-
-/*! @copydoc glfwSetWindowMonitor
- *  @ingroup platform
- */
 void _glfwPlatformSetWindowMonitor(_GLFWwindow* window, _GLFWmonitor* monitor, int xpos, int ypos, int width, int height, int refreshRate);
-
-/*! @brief Returns whether the window is focused.
- *  @ingroup platform
- */
 int _glfwPlatformWindowFocused(_GLFWwindow* window);
-
-/*! @brief Returns whether the window is iconified.
- *  @ingroup platform
- */
 int _glfwPlatformWindowIconified(_GLFWwindow* window);
-
-/*! @brief Returns whether the window is visible.
- *  @ingroup platform
- */
 int _glfwPlatformWindowVisible(_GLFWwindow* window);
-
-/*! @brief Returns whether the window is maximized.
- *  @ingroup platform
- */
 int _glfwPlatformWindowMaximized(_GLFWwindow* window);
+int _glfwPlatformFramebufferTransparent(_GLFWwindow* window);
+float _glfwPlatformGetWindowOpacity(_GLFWwindow* window);
+void _glfwPlatformSetWindowResizable(_GLFWwindow* window, GLFWbool enabled);
+void _glfwPlatformSetWindowDecorated(_GLFWwindow* window, GLFWbool enabled);
+void _glfwPlatformSetWindowFloating(_GLFWwindow* window, GLFWbool enabled);
+void _glfwPlatformSetWindowOpacity(_GLFWwindow* window, float opacity);
 
-/*! @copydoc glfwPollEvents
- *  @ingroup platform
- */
 void _glfwPlatformPollEvents(void);
-
-/*! @copydoc glfwWaitEvents
- *  @ingroup platform
- */
 void _glfwPlatformWaitEvents(void);
-
-/*! @copydoc glfwWaitEventsTimeout
- *  @ingroup platform
- */
 void _glfwPlatformWaitEventsTimeout(double timeout);
-
-/*! @copydoc glfwPostEmptyEvent
- *  @ingroup platform
- */
 void _glfwPlatformPostEmptyEvent(void);
 
-/*! @ingroup platform
+void _glfwPlatformGetRequiredInstanceExtensions(char** extensions);
- */
-void _glfwPlatformSetCurrentContext(_GLFWwindow* context);
-
-/*! @copydoc glfwGetCurrentContext
- *  @ingroup platform
- */
-_GLFWwindow* _glfwPlatformGetCurrentContext(void);
-
-/*! @copydoc glfwCreateCursor
- *  @ingroup platform
- */
-int _glfwPlatformCreateCursor(_GLFWcursor* cursor, const GLFWimage* image, int xhot, int yhot);
-
-/*! @copydoc glfwCreateStandardCursor
- *  @ingroup platform
- */
-int _glfwPlatformCreateStandardCursor(_GLFWcursor* cursor, int shape);
-
-/*! @copydoc glfwDestroyCursor
- *  @ingroup platform
- */
-void _glfwPlatformDestroyCursor(_GLFWcursor* cursor);
-
-/*! @copydoc glfwSetCursor
- *  @ingroup platform
- */
-void _glfwPlatformSetCursor(_GLFWwindow* window, _GLFWcursor* cursor);
-
-/*! @ingroup platform
- */
-char** _glfwPlatformGetRequiredInstanceExtensions(uint32_t* count);
-
-/*! @ingroup platform
- */
 int _glfwPlatformGetPhysicalDevicePresentationSupport(VkInstance instance, VkPhysicalDevice device, uint32_t queuefamily);
-
-/*! @ingroup platform
- */
 VkResult _glfwPlatformCreateWindowSurface(VkInstance instance, _GLFWwindow* window, const VkAllocationCallbacks* allocator, VkSurfaceKHR* surface);
 
+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);
+
+/*! @} */
+
 
 //========================================================================
 // Event API functions
 //========================================================================
 
-/*! @brief Notifies shared code of a window focus event.
+/*! @brief Notifies shared code that a window has lost or received input focus.
  *  @param[in] window The window that received the event.
  *  @param[in] focused `GLFW_TRUE` if the window received focus, or `GLFW_FALSE`
  *  if it lost focus.
@@ -815,7 +727,7 @@ VkResult _glfwPlatformCreateWindowSurface(VkInstance instance, _GLFWwindow* wind
  */
 void _glfwInputWindowFocus(_GLFWwindow* window, GLFWbool focused);
 
-/*! @brief Notifies shared code of a window movement event.
+/*! @brief Notifies shared code that a window has moved.
  *  @param[in] window The window that received the event.
  *  @param[in] xpos The new x-coordinate of the client area of the window.
  *  @param[in] ypos The new y-coordinate of the client area of the window.
@@ -823,7 +735,7 @@ void _glfwInputWindowFocus(_GLFWwindow* window, GLFWbool focused);
  */
 void _glfwInputWindowPos(_GLFWwindow* window, int xpos, int ypos);
 
-/*! @brief Notifies shared code of a window resize event.
+/*! @brief Notifies shared code that a window has been resized.
  *  @param[in] window The window that received the event.
  *  @param[in] width The new width of the client area of the window.
  *  @param[in] height The new height of the client area of the window.
@@ -831,7 +743,7 @@ void _glfwInputWindowPos(_GLFWwindow* window, int xpos, int ypos);
  */
 void _glfwInputWindowSize(_GLFWwindow* window, int width, int height);
 
-/*! @brief Notifies shared code of a framebuffer resize event.
+/*! @brief Notifies shared code that a window framebuffer has been resized.
  *  @param[in] window The window that received the event.
  *  @param[in] width The new width, in pixels, of the framebuffer.
  *  @param[in] height The new height, in pixels, of the framebuffer.
@@ -839,7 +751,7 @@ void _glfwInputWindowSize(_GLFWwindow* window, int width, int height);
  */
 void _glfwInputFramebufferSize(_GLFWwindow* window, int width, int height);
 
-/*! @brief Notifies shared code of a window iconification event.
+/*! @brief Notifies shared code that a window has been iconified or restored.
  *  @param[in] window The window that received the event.
  *  @param[in] iconified `GLFW_TRUE` if the window was iconified, or
  *  `GLFW_FALSE` if it was restored.
@@ -847,18 +759,31 @@ void _glfwInputFramebufferSize(_GLFWwindow* window, int width, int height);
  */
 void _glfwInputWindowIconify(_GLFWwindow* window, GLFWbool iconified);
 
-/*! @brief Notifies shared code of a window damage event.
+/*! @brief Notifies shared code that a window has been maximized or restored.
+ *  @param[in] window The window that received the event.
+ *  @param[in] maximized `GLFW_TRUE` if the window was maximized, or
+ *  `GLFW_FALSE` if it was restored.
+ *  @ingroup event
+ */
+void _glfwInputWindowMaximize(_GLFWwindow* window, GLFWbool maximized);
+
+/*! @brief Notifies shared code that a window's contents needs updating.
  *  @param[in] window The window that received the event.
  */
 void _glfwInputWindowDamage(_GLFWwindow* window);
 
-/*! @brief Notifies shared code of a window close request event
+/*! @brief Notifies shared code that the user wishes to close a window.
  *  @param[in] window The window that received the event.
  *  @ingroup event
  */
 void _glfwInputWindowCloseRequest(_GLFWwindow* window);
 
-void _glfwInputWindowMonitorChange(_GLFWwindow* window, _GLFWmonitor* monitor);
+/*! @brief Notifies shared code that a window has changed its desired monitor.
+ *  @param[in] window The window that received the event.
+ *  @param[in] monitor The new desired monitor, or `NULL`.
+ *  @ingroup event
+ */
+void _glfwInputWindowMonitor(_GLFWwindow* window, _GLFWmonitor* monitor);
 
 /*! @brief Notifies shared code of a physical key event.
  *  @param[in] window The window that received the event.
@@ -892,6 +817,7 @@ void _glfwInputScroll(_GLFWwindow* window, double xoffset, double yoffset);
  *  @param[in] window The window that received the event.
  *  @param[in] button The button that was pressed or released.
  *  @param[in] action @ref GLFW_PRESS or @ref GLFW_RELEASE.
+ *  @param[in] mods The modifiers pressed when the event was generated.
  *  @ingroup event
  */
 void _glfwInputMouseClick(_GLFWwindow* window, int button, int action, int mods);
@@ -914,27 +840,35 @@ void _glfwInputCursorPos(_GLFWwindow* window, double xpos, double ypos);
  */
 void _glfwInputCursorEnter(_GLFWwindow* window, GLFWbool entered);
 
-/*! @ingroup event
+/*! @brief Notifies shared code of a monitor connection or disconnection.
+ *  @param[in] monitor The monitor that was connected or disconnected.
+ *  @param[in] action One of `GLFW_CONNECTED` or `GLFW_DISCONNECTED`.
+ *  @param[in] placement `_GLFW_INSERT_FIRST` or `_GLFW_INSERT_LAST`.
+ *  @ingroup event
  */
-void _glfwInputMonitorChange(void);
+void _glfwInputMonitor(_GLFWmonitor* monitor, int action, int placement);
 
-/*! @ingroup event
+/*! @brief Notifies shared code that a full screen window has acquired or
+ *  released a monitor.
+ *  @param[in] monitor The monitor that was acquired or released.
+ *  @param[in] window The window that acquired the monitor, or `NULL`.
+ *  @ingroup event
  */
-void _glfwInputMonitorWindowChange(_GLFWmonitor* monitor, _GLFWwindow* window);
+void _glfwInputMonitorWindow(_GLFWmonitor* monitor, _GLFWwindow* window);
 
 /*! @brief Notifies shared code of an error.
- *  @param[in] error The error code most suitable for the error.
+ *  @param[in] code The error code most suitable for the error.
  *  @param[in] format The `printf` style format string of the error
  *  description.
  *  @ingroup event
  */
 #if defined(__GNUC__)
-void _glfwInputError(int error, const char* format, ...) __attribute__((format(printf, 2, 3)));
+void _glfwInputError(int code, const char* format, ...) __attribute__((format(printf, 2, 3)));
 #else
-void _glfwInputError(int error, const char* format, ...);
+void _glfwInputError(int code, const char* format, ...);
 #endif
 
-/*! @brief Notifies dropped object over window.
+/*! @brief Notifies shared code of files or directories dropped on a window.
  *  @param[in] window The window that received the event.
  *  @param[in] count The number of dropped objects.
  *  @param[in] names The names of the dropped objects.
@@ -942,19 +876,41 @@ void _glfwInputError(int error, const char* format, ...);
  */
 void _glfwInputDrop(_GLFWwindow* window, int count, const char** names);
 
-/*! @brief Notifies shared code of a joystick connection/disconnection event.
+/*! @brief Notifies shared code of a joystick connection or disconnection.
- *  @param[in] joy The joystick that was connected or disconnected.
+ *  @param[in] js The joystick that was connected or disconnected.
  *  @param[in] event One of `GLFW_CONNECTED` or `GLFW_DISCONNECTED`.
  *  @ingroup event
  */
-void _glfwInputJoystickChange(int joy, int event);
+void _glfwInputJoystick(_GLFWjoystick* js, int event);
+
+/*! @brief Notifies shared code of the new value of a joystick axis.
+ *  @param[in] js The joystick whose axis to update.
+ *  @param[in] axis The index of the axis to update.
+ *  @param[in] value The new value of the axis.
+ */
+void _glfwInputJoystickAxis(_GLFWjoystick* js, int axis, float value);
+
+/*! @brief Notifies shared code of the new value of a joystick button.
+ *  @param[in] js The joystick whose button to update.
+ *  @param[in] button The index of the button to update.
+ *  @param[in] value The new value of the button.
+ */
+void _glfwInputJoystickButton(_GLFWjoystick* js, int button, char value);
+
+/*! @brief Notifies shared code of the new value of a joystick hat.
+ *  @param[in] js The joystick whose hat to update.
+ *  @param[in] button The index of the hat to update.
+ *  @param[in] value The new value of the hat.
+ */
+void _glfwInputJoystickHat(_GLFWjoystick* js, int hat, char value);
 
 
 //========================================================================
 // Utility functions
 //========================================================================
 
-/*! @ingroup utility
+/*! @brief Chooses the video mode most closely matching the desired one.
+ *  @ingroup utility
  */
 const GLFWvidmode* _glfwChooseVideoMode(_GLFWmonitor* monitor,
                                         const GLFWvidmode* desired);
@@ -1009,11 +965,13 @@ GLFWbool _glfwRefreshContextAttribs(const _GLFWctxconfig* ctxconfig);
  */
 GLFWbool _glfwIsValidContextConfig(const _GLFWctxconfig* ctxconfig);
 
-/*! @ingroup utility
+/*! @brief Allocates red, green and blue value arrays of the specified size.
+ *  @ingroup utility
  */
 void _glfwAllocGammaArrays(GLFWgammaramp* ramp, unsigned int size);
 
-/*! @ingroup utility
+/*! @brief Frees the red, green and blue value arrays and clears the struct.
+ *  @ingroup utility
  */
 void _glfwFreeGammaArrays(GLFWgammaramp* ramp);
 
@@ -1032,17 +990,23 @@ _GLFWmonitor* _glfwAllocMonitor(const char* name, int widthMM, int heightMM);
   */
 void _glfwFreeMonitor(_GLFWmonitor* monitor);
 
-/*! @ingroup utility
+/*! @brief Returns an available joystick object with arrays and name allocated.
+ *  @ingroup utility
   */
-void _glfwFreeMonitors(_GLFWmonitor** monitors, int count);
+_GLFWjoystick* _glfwAllocJoystick(const char* name,
+                                  const char* guid,
+                                  int axisCount,
+                                  int buttonCount,
+                                  int hatCount);
+
+/*! @brief Frees arrays and name and flags the joystick object as unused.
+ *  @ingroup utility
+  */
+void _glfwFreeJoystick(_GLFWjoystick* js);
 
 /*! @ingroup utility
  */
-GLFWbool _glfwIsPrintable(int key);
+GLFWbool _glfwInitVulkan(int mode);
-
-/*! @ingroup utility
- */
-GLFWbool _glfwInitVulkan(void);
 
 /*! @ingroup utility
  */
@@ -1052,4 +1016,3 @@ void _glfwTerminateVulkan(void);
  */
 const char* _glfwGetVulkanResultString(VkResult result);
 
-#endif // _glfw3_internal_h_

raylib/external/glfw/src/linux_joystick.c

@@ -1,8 +1,8 @@
 //========================================================================
-// GLFW 3.2 Linux - www.glfw.org
+// GLFW 3.3 Linux - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-2016 Camilla Berglund <elmindreda@glfw.org>
+// Copyright (c) 2006-2016 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
@@ -27,9 +27,6 @@
 
 #include "internal.h"
 
-#if defined(__linux__)
-#include <linux/joystick.h>
-
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <sys/inotify.h>
@@ -40,129 +37,220 @@
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
-#endif // __linux__
 
+// Apply an EV_KEY event to the specified joystick
+//
+static void handleKeyEvent(_GLFWjoystick* js, int code, int value)
+{
+    _glfwInputJoystickButton(js,
+                             js->linjs.keyMap[code - BTN_MISC],
+                             value ? GLFW_PRESS : GLFW_RELEASE);
+}
+
+// Apply an EV_ABS event to the specified joystick
+//
+static void handleAbsEvent(_GLFWjoystick* js, int code, int value)
+{
+    const int index = js->linjs.absMap[code];
+
+    if (code >= ABS_HAT0X && code <= ABS_HAT3Y)
+    {
+        static const char stateMap[3][3] =
+        {
+            { GLFW_HAT_CENTERED, GLFW_HAT_UP,       GLFW_HAT_DOWN },
+            { GLFW_HAT_LEFT,     GLFW_HAT_LEFT_UP,  GLFW_HAT_LEFT_DOWN },
+            { GLFW_HAT_RIGHT,    GLFW_HAT_RIGHT_UP, GLFW_HAT_RIGHT_DOWN },
+        };
+
+        const int hat = (code - ABS_HAT0X) / 2;
+        const int axis = (code - ABS_HAT0X) % 2;
+        int* state = js->linjs.hats[hat];
+
+        // NOTE: Looking at several input drivers, it seems all hat events use
+        //       -1 for left / up, 0 for centered and 1 for right / down
+        if (value == 0)
+            state[axis] = 0;
+        else if (value < 0)
+            state[axis] = 1;
+        else if (value > 0)
+            state[axis] = 2;
+
+        _glfwInputJoystickHat(js, index, stateMap[state[0]][state[1]]);
+    }
+    else
+    {
+        const struct input_absinfo* info = &js->linjs.absInfo[code];
+        float normalized = value;
+
+        const int range = info->maximum - info->minimum;
+        if (range)
+        {
+            // Normalize to 0.0 -> 1.0
+            normalized = (normalized - info->minimum) / range;
+            // Normalize to -1.0 -> 1.0
+            normalized = normalized * 2.0f - 1.0f;
+        }
+
+        _glfwInputJoystickAxis(js, index, normalized);
+    }
+}
+
+// Poll state of absolute axes
+//
+static void pollAbsState(_GLFWjoystick* js)
+{
+    int code;
+
+    for (code = 0;  code < ABS_CNT;  code++)
+    {
+        if (js->linjs.absMap[code] < 0)
+            continue;
+
+        struct input_absinfo* info = &js->linjs.absInfo[code];
+
+        if (ioctl(js->linjs.fd, EVIOCGABS(code), info) < 0)
+            continue;
+
+        handleAbsEvent(js, code, info->value);
+    }
+}
+
+#define isBitSet(bit, arr) (arr[(bit) / 8] & (1 << ((bit) % 8)))
 
 // Attempt to open the specified joystick device
 //
-#if defined(__linux__)
 static GLFWbool openJoystickDevice(const char* path)
 {
-    char axisCount, buttonCount;
+    int jid, code;
     char name[256] = "";
-    int joy, fd, version;
+    char guid[33] = "";
-    _GLFWjoystickLinux* js;
+    char evBits[(EV_CNT + 7) / 8] = {0};
+    char keyBits[(KEY_CNT + 7) / 8] = {0};
+    char absBits[(ABS_CNT + 7) / 8] = {0};
+    int axisCount = 0, buttonCount = 0, hatCount = 0;
+    struct input_id id;
+    _GLFWjoystickLinux linjs = {0};
+    _GLFWjoystick* js = NULL;
 
-    for (joy = GLFW_JOYSTICK_1;  joy <= GLFW_JOYSTICK_LAST;  joy++)
+    for (jid = 0;  jid <= GLFW_JOYSTICK_LAST;  jid++)
     {
-        if (!_glfw.linux_js.js[joy].present)
+        if (!_glfw.joysticks[jid].present)
             continue;
-
+        if (strcmp(_glfw.joysticks[jid].linjs.path, path) == 0)
-        if (strcmp(_glfw.linux_js.js[joy].path, path) == 0)
             return GLFW_FALSE;
     }
 
-    for (joy = GLFW_JOYSTICK_1;  joy <= GLFW_JOYSTICK_LAST;  joy++)
+    linjs.fd = open(path, O_RDONLY | O_NONBLOCK);
-    {
+    if (linjs.fd == -1)
-        if (!_glfw.linux_js.js[joy].present)
-            break;
-    }
-
-    if (joy > GLFW_JOYSTICK_LAST)
         return GLFW_FALSE;
 
-    fd = open(path, O_RDONLY | O_NONBLOCK);
+    if (ioctl(linjs.fd, EVIOCGBIT(0, sizeof(evBits)), evBits) < 0 ||
-    if (fd == -1)
+        ioctl(linjs.fd, EVIOCGBIT(EV_KEY, sizeof(keyBits)), keyBits) < 0 ||
-        return GLFW_FALSE;
+        ioctl(linjs.fd, EVIOCGBIT(EV_ABS, sizeof(absBits)), absBits) < 0 ||
-
+        ioctl(linjs.fd, EVIOCGID, &id) < 0)
-    // Verify that the joystick driver version is at least 1.0
-    ioctl(fd, JSIOCGVERSION, &version);
-    if (version < 0x010000)
     {
-        // It's an old 0.x interface (we don't support it)
+        _glfwInputError(GLFW_PLATFORM_ERROR,
-        close(fd);
+                        "Linux: Failed to query input device: %s",
+                        strerror(errno));
+        close(linjs.fd);
         return GLFW_FALSE;
     }
 
-    if (ioctl(fd, JSIOCGNAME(sizeof(name)), name) < 0)
+    // Ensure this device supports the events expected of a joystick
+    if (!isBitSet(EV_KEY, evBits) || !isBitSet(EV_ABS, evBits))
+    {
+        close(linjs.fd);
+        return GLFW_FALSE;
+    }
+
+    if (ioctl(linjs.fd, EVIOCGNAME(sizeof(name)), name) < 0)
         strncpy(name, "Unknown", sizeof(name));
 
-    js = _glfw.linux_js.js + joy;
+    // Generate a joystick GUID that matches the SDL 2.0.5+ one
-    js->present = GLFW_TRUE;
+    if (id.vendor && id.product && id.version)
-    js->name = strdup(name);
+    {
-    js->path = strdup(path);
+        sprintf(guid, "%02x%02x0000%02x%02x0000%02x%02x0000%02x%02x0000",
-    js->fd = fd;
+                id.bustype & 0xff, id.bustype >> 8,
+                id.vendor & 0xff,  id.vendor >> 8,
+                id.product & 0xff, id.product >> 8,
+                id.version & 0xff, id.version >> 8);
+    }
+    else
+    {
+        sprintf(guid, "%02x%02x0000%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x00",
+                id.bustype & 0xff, id.bustype >> 8,
+                name[0], name[1], name[2], name[3],
+                name[4], name[5], name[6], name[7],
+                name[8], name[9], name[10]);
+    }
 
-    ioctl(fd, JSIOCGAXES, &axisCount);
+    for (code = BTN_MISC;  code < KEY_CNT;  code++)
-    js->axisCount = (int) axisCount;
+    {
-    js->axes = calloc(axisCount, sizeof(float));
+        if (!isBitSet(code, keyBits))
+            continue;
 
-    ioctl(fd, JSIOCGBUTTONS, &buttonCount);
+        linjs.keyMap[code - BTN_MISC] = buttonCount;
-    js->buttonCount = (int) buttonCount;
+        buttonCount++;
-    js->buttons = calloc(buttonCount, 1);
+    }
 
-    _glfwInputJoystickChange(joy, GLFW_CONNECTED);
+    for (code = 0;  code < ABS_CNT;  code++)
+    {
+        linjs.absMap[code] = -1;
+        if (!isBitSet(code, absBits))
+            continue;
+
+        if (code >= ABS_HAT0X && code <= ABS_HAT3Y)
+        {
+            linjs.absMap[code] = hatCount;
+            hatCount++;
+            // Skip the Y axis
+            code++;
+        }
+        else
+        {
+            if (ioctl(linjs.fd, EVIOCGABS(code), &linjs.absInfo[code]) < 0)
+                continue;
+
+            linjs.absMap[code] = axisCount;
+            axisCount++;
+        }
+    }
+
+    js = _glfwAllocJoystick(name, guid, axisCount, buttonCount, hatCount);
+    if (!js)
+    {
+        close(linjs.fd);
+        return GLFW_FALSE;
+    }
+
+    strncpy(linjs.path, path, sizeof(linjs.path));
+    memcpy(&js->linjs, &linjs, sizeof(linjs));
+
+    pollAbsState(js);
+
+    _glfwInputJoystick(js, GLFW_CONNECTED);
     return GLFW_TRUE;
 }
-#endif // __linux__
 
-// Polls for and processes events the specified joystick
+#undef isBitSet
+
+// Frees all resources associated with the specified joystick
 //
-static GLFWbool pollJoystickEvents(_GLFWjoystickLinux* js)
+static void closeJoystick(_GLFWjoystick* js)
 {
-#if defined(__linux__)
+    close(js->linjs.fd);
-    _glfwPollJoystickEvents();
+    _glfwFreeJoystick(js);
-
+    _glfwInputJoystick(js, GLFW_DISCONNECTED);
-    if (!js->present)
-        return GLFW_FALSE;
-
-    // Read all queued events (non-blocking)
-    for (;;)
-    {
-        struct js_event e;
-
-        errno = 0;
-        if (read(js->fd, &e, sizeof(e)) < 0)
-        {
-            // Reset the joystick slot if the device was disconnected
-            if (errno == ENODEV)
-            {
-                free(js->axes);
-                free(js->buttons);
-                free(js->name);
-                free(js->path);
-
-                memset(js, 0, sizeof(_GLFWjoystickLinux));
-
-                _glfwInputJoystickChange(js - _glfw.linux_js.js,
-                                         GLFW_DISCONNECTED);
-            }
-
-            break;
-        }
-
-        // Clear the initial-state bit
-        e.type &= ~JS_EVENT_INIT;
-
-        if (e.type == JS_EVENT_AXIS)
-            js->axes[e.number] = (float) e.value / 32767.0f;
-        else if (e.type == JS_EVENT_BUTTON)
-            js->buttons[e.number] = e.value ? GLFW_PRESS : GLFW_RELEASE;
-    }
-#endif // __linux__
-    return js->present;
 }
 
 // Lexically compare joysticks by name; used by qsort
 //
-#if defined(__linux__)
 static int compareJoysticks(const void* fp, const void* sp)
 {
-    const _GLFWjoystickLinux* fj = fp;
+    const _GLFWjoystick* fj = fp;
-    const _GLFWjoystickLinux* sj = sp;
+    const _GLFWjoystick* sj = sp;
-    return strcmp(fj->path, sj->path);
+    return strcmp(fj->linjs.path, sj->linjs.path);
 }
-#endif // __linux__
 
 
 //////////////////////////////////////////////////////////////////////////
@@ -173,36 +261,24 @@ static int compareJoysticks(const void* fp, const void* sp)
 //
 GLFWbool _glfwInitJoysticksLinux(void)
 {
-#if defined(__linux__)
     DIR* dir;
     int count = 0;
     const char* dirname = "/dev/input";
 
-    _glfw.linux_js.inotify = inotify_init1(IN_NONBLOCK | IN_CLOEXEC);
+    _glfw.linjs.inotify = inotify_init1(IN_NONBLOCK | IN_CLOEXEC);
-    if (_glfw.linux_js.inotify == -1)
+    if (_glfw.linjs.inotify > 0)
     {
-        _glfwInputError(GLFW_PLATFORM_ERROR,
+        // HACK: Register for IN_ATTRIB to get notified when udev is done
-                        "Linux: Failed to initialize inotify: %s",
+        //       This works well in practice but the true way is libudev
-                        strerror(errno));
+
-        return GLFW_FALSE;
+        _glfw.linjs.watch = inotify_add_watch(_glfw.linjs.inotify,
+                                              dirname,
+                                              IN_CREATE | IN_ATTRIB | IN_DELETE);
     }
 
-    // HACK: Register for IN_ATTRIB as well to get notified when udev is done
+    // Continue without device connection notifications if inotify fails
-    //       This works well in practice but the true way is libudev
 
-    _glfw.linux_js.watch = inotify_add_watch(_glfw.linux_js.inotify,
+    if (regcomp(&_glfw.linjs.regex, "^event[0-9]\\+$", 0) != 0)
-                                             dirname,
-                                             IN_CREATE | IN_ATTRIB);
-    if (_glfw.linux_js.watch == -1)
-    {
-        _glfwInputError(GLFW_PLATFORM_ERROR,
-                        "Linux: Failed to watch for joystick connections in %s: %s",
-                        dirname,
-                        strerror(errno));
-        // Continue without device connection notifications
-    }
-
-    if (regcomp(&_glfw.linux_js.regex, "^js[0-9]\\+$", 0) != 0)
     {
         _glfwInputError(GLFW_PLATFORM_ERROR, "Linux: Failed to compile regex");
         return GLFW_FALSE;
@@ -215,31 +291,25 @@ GLFWbool _glfwInitJoysticksLinux(void)
 
         while ((entry = readdir(dir)))
         {
-            char path[20];
             regmatch_t match;
 
-            if (regexec(&_glfw.linux_js.regex, entry->d_name, 1, &match, 0) != 0)
+            if (regexec(&_glfw.linjs.regex, entry->d_name, 1, &match, 0) != 0)
                 continue;
 
+            char path[PATH_MAX];
+
             snprintf(path, sizeof(path), "%s/%s", dirname, entry->d_name);
+
             if (openJoystickDevice(path))
                 count++;
         }
 
         closedir(dir);
     }
-    else
-    {
-        _glfwInputError(GLFW_PLATFORM_ERROR,
-                        "Linux: Failed to open joystick device directory %s: %s",
-                        dirname,
-                        strerror(errno));
-        // Continue with no joysticks detected
-    }
 
-    qsort(_glfw.linux_js.js, count, sizeof(_GLFWjoystickLinux), compareJoysticks);
+    // Continue with no joysticks if enumeration fails
-#endif // __linux__
 
+    qsort(_glfw.joysticks, count, sizeof(_GLFWjoystick), compareJoysticks);
     return GLFW_TRUE;
 }
 
@@ -247,56 +317,65 @@ GLFWbool _glfwInitJoysticksLinux(void)
 //
 void _glfwTerminateJoysticksLinux(void)
 {
-#if defined(__linux__)
+    int jid;
-    int i;
 
-    for (i = 0;  i <= GLFW_JOYSTICK_LAST;  i++)
+    for (jid = 0;  jid <= GLFW_JOYSTICK_LAST;  jid++)
     {
-        if (_glfw.linux_js.js[i].present)
+        _GLFWjoystick* js = _glfw.joysticks + jid;
-        {
+        if (js->present)
-            close(_glfw.linux_js.js[i].fd);
+            closeJoystick(js);
-            free(_glfw.linux_js.js[i].axes);
-            free(_glfw.linux_js.js[i].buttons);
-            free(_glfw.linux_js.js[i].name);
-            free(_glfw.linux_js.js[i].path);
-        }
     }
 
-    regfree(&_glfw.linux_js.regex);
+    regfree(&_glfw.linjs.regex);
 
-    if (_glfw.linux_js.inotify > 0)
+    if (_glfw.linjs.inotify > 0)
     {
-        if (_glfw.linux_js.watch > 0)
+        if (_glfw.linjs.watch > 0)
-            inotify_rm_watch(_glfw.linux_js.inotify, _glfw.linux_js.watch);
+            inotify_rm_watch(_glfw.linjs.inotify, _glfw.linjs.watch);
 
-        close(_glfw.linux_js.inotify);
+        close(_glfw.linjs.inotify);
     }
-#endif // __linux__
 }
 
-void _glfwPollJoystickEvents(void)
+void _glfwDetectJoystickConnectionLinux(void)
 {
-#if defined(__linux__)
     ssize_t offset = 0;
     char buffer[16384];
 
-    const ssize_t size = read(_glfw.linux_js.inotify, buffer, sizeof(buffer));
+    if (_glfw.linjs.inotify <= 0)
+        return;
+
+    const ssize_t size = read(_glfw.linjs.inotify, buffer, sizeof(buffer));
 
     while (size > offset)
     {
         regmatch_t match;
         const struct inotify_event* e = (struct inotify_event*) (buffer + offset);
 
-        if (regexec(&_glfw.linux_js.regex, e->name, 1, &match, 0) == 0)
-        {
-            char path[20];
-            snprintf(path, sizeof(path), "/dev/input/%s", e->name);
-            openJoystickDevice(path);
-        }
-
         offset += sizeof(struct inotify_event) + e->len;
+
+        if (regexec(&_glfw.linjs.regex, e->name, 1, &match, 0) != 0)
+            continue;
+
+        char path[PATH_MAX];
+        snprintf(path, sizeof(path), "/dev/input/%s", e->name);
+
+        if (e->mask & (IN_CREATE | IN_ATTRIB))
+            openJoystickDevice(path);
+        else if (e->mask & IN_DELETE)
+        {
+            int jid;
+
+            for (jid = 0;  jid <= GLFW_JOYSTICK_LAST;  jid++)
+            {
+                if (strcmp(_glfw.joysticks[jid].linjs.path, path) == 0)
+                {
+                    closeJoystick(_glfw.joysticks + jid);
+                    break;
+                }
+            }
+        }
     }
-#endif
 }
 
 
@@ -304,38 +383,47 @@ void _glfwPollJoystickEvents(void)
 //////                       GLFW platform API                      //////
 //////////////////////////////////////////////////////////////////////////
 
-int _glfwPlatformJoystickPresent(int joy)
+int _glfwPlatformPollJoystick(_GLFWjoystick* js, int mode)
 {
-    _GLFWjoystickLinux* js = _glfw.linux_js.js + joy;
+    // Read all queued events (non-blocking)
-    return pollJoystickEvents(js);
+    for (;;)
+    {
+        struct input_event e;
+
+        errno = 0;
+        if (read(js->linjs.fd, &e, sizeof(e)) < 0)
+        {
+            // Reset the joystick slot if the device was disconnected
+            if (errno == ENODEV)
+                closeJoystick(js);
+
+            break;
+        }
+
+        if (e.type == EV_SYN)
+        {
+            if (e.code == SYN_DROPPED)
+                _glfw.linjs.dropped = GLFW_TRUE;
+            else if (e.code == SYN_REPORT)
+            {
+                _glfw.linjs.dropped = GLFW_FALSE;
+                pollAbsState(js);
+            }
+        }
+
+        if (_glfw.linjs.dropped)
+            continue;
+
+        if (e.type == EV_KEY)
+            handleKeyEvent(js, e.code, e.value);
+        else if (e.type == EV_ABS)
+            handleAbsEvent(js, e.code, e.value);
+    }
+
+    return js->present;
 }
 
-const float* _glfwPlatformGetJoystickAxes(int joy, int* count)
+void _glfwPlatformUpdateGamepadGUID(char* guid)
 {
-    _GLFWjoystickLinux* js = _glfw.linux_js.js + joy;
-    if (!pollJoystickEvents(js))
-        return NULL;
-
-    *count = js->axisCount;
-    return js->axes;
-}
-
-const unsigned char* _glfwPlatformGetJoystickButtons(int joy, int* count)
-{
-    _GLFWjoystickLinux* js = _glfw.linux_js.js + joy;
-    if (!pollJoystickEvents(js))
-        return NULL;
-
-    *count = js->buttonCount;
-    return js->buttons;
-}
-
-const char* _glfwPlatformGetJoystickName(int joy)
-{
-    _GLFWjoystickLinux* js = _glfw.linux_js.js + joy;
-    if (!pollJoystickEvents(js))
-        return NULL;
-
-    return js->name;
 }
 

raylib/external/glfw/src/linux_joystick.h

@@ -1,5 +1,5 @@
 //========================================================================
-// GLFW 3.2 Linux - www.glfw.org
+// GLFW 3.3 Linux - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2014 Jonas Ådahl <jadahl@gmail.com>
 //
@@ -24,45 +24,39 @@
 //
 //========================================================================
 
-#ifndef _glfw3_linux_joystick_h_
+#include <linux/input.h>
-#define _glfw3_linux_joystick_h_
+#include <linux/limits.h>
-
 #include <regex.h>
 
-#define _GLFW_PLATFORM_LIBRARY_JOYSTICK_STATE _GLFWjoylistLinux linux_js
+#define _GLFW_PLATFORM_JOYSTICK_STATE         _GLFWjoystickLinux linjs
+#define _GLFW_PLATFORM_LIBRARY_JOYSTICK_STATE _GLFWlibraryLinux  linjs
 
+#define _GLFW_PLATFORM_MAPPING_NAME "Linux"
 
 // Linux-specific joystick data
 //
 typedef struct _GLFWjoystickLinux
 {
-    GLFWbool        present;
+    int                     fd;
-    int             fd;
+    char                    path[PATH_MAX];
-    float*          axes;
+    int                     keyMap[KEY_CNT - BTN_MISC];
-    int             axisCount;
+    int                     absMap[ABS_CNT];
-    unsigned char*  buttons;
+    struct input_absinfo    absInfo[ABS_CNT];
-    int             buttonCount;
+    int                     hats[4][2];
-    char*           name;
-    char*           path;
 } _GLFWjoystickLinux;
 
 // Linux-specific joystick API data
 //
-typedef struct _GLFWjoylistLinux
+typedef struct _GLFWlibraryLinux
 {
-    _GLFWjoystickLinux js[GLFW_JOYSTICK_LAST + 1];
+    int                     inotify;
-
+    int                     watch;
-#if defined(__linux__)
+    regex_t                 regex;
-    int             inotify;
+    GLFWbool                dropped;
-    int             watch;
+} _GLFWlibraryLinux;
-    regex_t         regex;
-#endif /*__linux__*/
-} _GLFWjoylistLinux;
 
 
 GLFWbool _glfwInitJoysticksLinux(void);
 void _glfwTerminateJoysticksLinux(void);
+void _glfwDetectJoystickConnectionLinux(void);
 
-void _glfwPollJoystickEvents(void);
-
-#endif // _glfw3_linux_joystick_h_

raylib/external/glfw/src/mappings.h

@@ -0,0 +1,310 @@
+//========================================================================
+// GLFW 3.3 - www.glfw.org
+//------------------------------------------------------------------------
+// Copyright (c) 2006-2016 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.
+//
+//========================================================================
+// As mappings.h.in, this file is used by CMake to produce the mappings.h
+// header file.  If you are adding a GLFW specific gamepad mapping, this is
+// where to put it.
+//========================================================================
+// As mappings.h, this provides all pre-defined gamepad mappings, including
+// all available in SDL_GameControllerDB.  Do not edit this file.  Any gamepad
+// mappings not specific to GLFW should be submitted to SDL_GameControllerDB.
+// This file can be re-generated from mappings.h.in and the upstream
+// gamecontrollerdb.txt with the GenerateMappings.cmake script.
+//========================================================================
+
+// All gamepad mappings not labeled GLFW are copied from the
+// SDL_GameControllerDB project under the following license:
+//
+// Simple DirectMedia Layer
+// Copyright (C) 1997-2013 Sam Lantinga <slouken@libsdl.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.
+
+const char* _glfwDefaultMappings[] =
+{
+"02200090000000000000504944564944,8Bitdo NES30 PRO USB,platform:Windows,a:b0,b:b1,x:b3,y:b4,leftshoulder:b6,rightshoulder:b7,lefttrigger:b8,righttrigger:b9,back:b10,start:b11,leftstick:b13,rightstick:b14,leftx:a0,lefty:a1,rightx:a3,righty:a4,dpup:h0.1,dpright:h0.2,dpdown:h0.4,dpleft:h0.8,",
+"20380900000000000000504944564944,8Bitdo NES30 PRO Wireless,platform:Windows,a:b0,b:b1,x:b3,y:b4,leftshoulder:b6,rightshoulder:b7,lefttrigger:b8,righttrigger:b9,back:b10,start:b11,leftstick:b13,rightstick:b14,leftx:a0,lefty:a1,rightx:a3,righty:a4,dpup:h0.1,dpright:h0.2,dpdown:h0.4,dpleft:h0.8,",
+"10280900000000000000504944564944,8Bitdo SFC30 GamePad,a:b1,b:b0,y:b3,x:b4,start:b11,back:b10,leftshoulder:b6,leftx:a0,lefty:a1,rightshoulder:b7,platform:Windows,",
+"8f0e1200000000000000504944564944,Acme,platform:Windows,x:b2,a:b0,b:b1,y:b3,back:b8,start:b9,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b5,rightshoulder:b6,righttrigger:b7,leftstick:b10,rightstick:b11,leftx:a0,lefty:a1,rightx:a3,righty:a2,",
+"341a3608000000000000504944564944,Afterglow PS3 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
+"c0111352000000000000504944564944,Battalife Joystick,platform:Windows,x:b4,a:b6,b:b7,y:b5,back:b2,start:b3,leftshoulder:b0,rightshoulder:b1,leftx:a0,lefty:a1,",
+"d81d0b00000000000000504944564944,BUFFALO BSGP1601 Series ,platform:Windows,x:b4,a:b5,b:b3,y:b2,back:b12,start:b13,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,dpup:h0.1,leftshoulder:b8,lefttrigger:b6,rightshoulder:b9,righttrigger:b7,leftstick:b10,rightstick:b11,leftx:a0,lefty:a1,rightx:a2,righty:a3,",
+"5e048e02000000000000504944564944,Controller (XBOX 360 For Windows),platform:Windows,x:b2,a:b0,b:b1,y:b3,back:b6,start:b7,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,dpup:h0.1,leftshoulder:b4,rightshoulder:b5,righttrigger:a2,leftstick:b8,rightstick:b9,leftx:a0,lefty:a1,rightx:a3,righty:a4,",
+"4f0423b3000000000000504944564944,Dual Trigger 3-in-1,a:b1,b:b2,x:b0,y:b3,back:b8,start:b9,leftstick:b10,rightstick:b11,leftshoulder:b4,rightshoulder:b5,dpup:h0.1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,leftx:a0,lefty:a1,rightx:a2,righty:a5,lefttrigger:b6,righttrigger:b7,platform:Windows,",
+"341a0108000000000000504944564944,EXEQ RF USB Gamepad 8206,a:b0,b:b1,x:b2,y:b3,leftshoulder:b4,rightshoulder:b5,leftstick:b8,rightstick:b7,back:b8,start:b9,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftx:a0,lefty:a1,rightx:a2,righty:a3,platform:Windows,",
+"0d0f8500000000000000504944564944,Fighting Commander 2016 PS3,a:b1,b:b2,x:b0,y:b3,back:b8,guide:b12,start:b9,leftstick:b10,rightstick:b11,leftshoulder:b4,rightshoulder:b5,dpup:h0.1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,leftx:a0,lefty:a1,rightx:a2,righty:a3,lefttrigger:b6,righttrigger:b7,platform:Windows,",
+"0d0f5f00000000000000504944564944,Fighting Commander 4,a:b1,b:b2,x:b0,y:b3,back:b8,guide:b12,start:b9,leftstick:b10,rightstick:b11,leftshoulder:b4,rightshoulder:b5,dpup:h0.1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,leftx:a0,lefty:a1,rightx:a2,righty:a3,lefttrigger:b6,righttrigger:b7,platform:Windows,",
+"0d0f5e00000000000000504944564944,Fighting Commander 4,a:b1,b:b2,x:b0,y:b3,back:b8,guide:b12,start:b9,leftstick:b10,rightstick:b11,leftshoulder:b5,rightshoulder:b4,dpup:h0.1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,leftx:a0,lefty:a1,rightx:a2,righty:a5,lefttrigger:a4,righttrigger:a3,platform:Windows,",
+"0d0f8400000000000000504944564944,Fighting Commander 5,a:b1,b:b2,x:b0,y:b3,back:b8,guide:b12,start:b9,leftstick:b10,rightstick:b11,leftshoulder:b4,rightshoulder:b5,dpup:h0.1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,leftx:a0,lefty:a1,rightx:a2,righty:a5,lefttrigger:b6,righttrigger:b7,platform:Windows,",
+"0d0f8700000000000000504944564944,Fighting Stick mini 4,a:b1,b:b2,x:b0,y:b3,back:b8,guide:b12,start:b9,leftshoulder:b4,rightshoulder:b5,dpup:h0.1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,lefttrigger:b6,righttrigger:b7,platform:Windows,",
+"0d0f8800000000000000504944564944,Fighting Stick mini 4,a:b1,b:b2,x:b0,y:b3,back:b9,guide:b12,start:b8,leftshoulder:b4,rightshoulder:b5,dpup:h0.1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,lefttrigger:b6,righttrigger:b7,platform:Windows,",
+"0d0f2700000000000000504944564944,FIGHTING STICK V3,a:b1,b:b2,x:b0,y:b3,back:b8,guide:b12,start:b9,leftshoulder:b4,rightshoulder:b5,dpup:h0.1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,lefttrigger:b6,righttrigger:b7,platform:Windows,",
+"79000600000000000000504944564944,G-Shark GS-GP702,a:b2,b:b1,x:b3,y:b0,back:b8,start:b9,leftstick:b10,rightstick:b11,leftshoulder:b4,rightshoulder:b5,dpup:h0.1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,leftx:a0,lefty:a1,rightx:a2,righty:a4,lefttrigger:b6,righttrigger:b7,platform:Windows,",
+"28040140000000000000504944564944,GamePad Pro USB,platform:Windows,a:b1,b:b2,x:b0,y:b3,back:b8,start:b9,leftshoulder:b4,rightshoulder:b5,leftx:a0,lefty:a1,lefttrigger:b6,righttrigger:b7,",
+"ffff0000000000000000504944564944,GameStop Gamepad,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b2,y:b3,platform:Windows,",
+"6d0416c2000000000000504944564944,Generic DirectInput Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
+"45130010000000000000504944564944,Generic USB Joystick,a:b0,b:b1,x:b2,y:b3,back:b8,start:b9,leftstick:b10,rightstick:b11,leftshoulder:b4,rightshoulder:b5,dpup:h0.1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,leftx:a0,lefty:a1,rightx:a2,righty:a3,lefttrigger:b6,righttrigger:b7,platform:Windows,",
+"0d0f4900000000000000504944564944,Hatsune Miku Sho Controller,a:b1,b:b2,x:b0,y:b3,back:b8,guide:b12,start:b9,leftstick:b10,rightstick:b11,leftshoulder:b4,rightshoulder:b5,dpup:h0.1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,leftx:a0,lefty:a1,rightx:a2,righty:a3,lefttrigger:b6,righttrigger:b7,platform:Windows,",
+"d8140862000000000000504944564944,HitBox Edition Cthulhu+,a:b1,b:b2,x:b0,y:b3,back:b8,guide:b12,start:b9,leftshoulder:b5,rightshoulder:b7,dpup:h0.1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,lefttrigger:b4,righttrigger:b6,platform:Windows,",
+"0d0f4000000000000000504944564944,Hori Fighting Stick Mini 3,a:b1,b:b2,x:b0,y:b3,back:b8,guide:b12,start:b9,leftshoulder:b5,rightshoulder:b7,dpup:h0.1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,lefttrigger:b4,righttrigger:b6,platform:Windows,",
+"0d0f6e00000000000000504944564944,HORIPAD 4,a:b1,b:b2,y:b3,x:b0,start:b9,guide:b12,back:b8,leftstick:b10,rightstick:b11,leftshoulder:b4,rightshoulder:b5,dpup:h0.1,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,leftx:a0,lefty:a1,rightx:a2,righty:a3,lefttrigger:b6,righttrigger:b7,platform:Windows,",
+"0d0f4d00000000000000504944564944,HORIPAD3 A,a:b1,b:b2,x:b0,y:b3,back:b8,guide:b12,start:b9,leftstick:b10,rightstick:b11,leftshoulder:b4,rightshoulder:b5,dpup:h0.1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,leftx:a0,lefty:a1,rightx:a2,righty:a3,lefttrigger:b6,righttrigger:b7,platform:Windows,",
+"25090017000000000000504944564944,HRAP2 on PS/SS/N64 Joypad to USB BOX,a:b2,b:b1,x:b3,y:b0,back:b9,start:b8,leftshoulder:b5,rightshoulder:b7,leftx:a0,lefty:a1,lefttrigger:b4,righttrigger:b6,platform:Windows,",
+"d81d0f00000000000000504944564944,iBUFFALO BSGP1204 Series,platform:Windows,x:b3,a:b2,b:b1,y:b0,back:b8,start:b9,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,dpup:h0.1,leftshoulder:b6,lefttrigger:b4,rightshoulder:b7,righttrigger:b5,leftstick:b10,rightstick:b11,leftx:a0,lefty:a1,rightx:a2,righty:a3,",
+"d81d1000000000000000504944564944,iBUFFALO BSGP1204P Series,platform:Windows,x:b3,a:b2,b:b1,y:b0,back:b8,start:b9,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,dpup:h0.1,leftshoulder:b6,lefttrigger:b4,rightshoulder:b7,righttrigger:b5,leftstick:b10,rightstick:b11,leftx:a0,lefty:a1,rightx:a2,righty:a3,",
+"83056020000000000000504944564944,iBuffalo USB 2-axis 8-button Gamepad,a:b1,b:b0,y:b2,x:b3,start:b7,back:b6,leftshoulder:b4,rightshoulder:b5,leftx:a0,lefty:a1,platform:Windows,",
+"6f0e2401000000000000504944564944,INJUSTICE FightStick for PS3,a:b1,b:b2,x:b0,y:b3,back:b8,guide:b12,start:b9,leftshoulder:b4,rightshoulder:b5,lefttrigger:b6,righttrigger:b7,dpup:h0.1,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,platform:Windows",
+"49190204000000000000504944564944,Ipega PG-9023,a:b0,b:b1,x:b3,y:b4,back:b10,start:b11,leftstick:b13,rightstick:b14,leftshoulder:b6,rightshoulder:b7,dpup:h0.1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,leftx:a0,lefty:a1,rightx:a3,righty:a4,lefttrigger:b8,righttrigger:b9,platform:Windows,",
+"6d0419c2000000000000504944564944,Logitech F710 Gamepad,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
+"6d0418c2000000000000504944564944,Logitech RumblePad 2 USB,platform:Windows,x:b0,a:b1,b:b2,y:b3,back:b8,start:b9,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,leftstick:b10,rightstick:b11,leftx:a0,lefty:a1,rightx:a2,righty:a3,",
+"38075032000000000000504944564944,Mad Catz FightPad PRO PS3,platform:Windows,x:b0,a:b1,b:b2,y:b3,back:b8,guide:b12,start:b9,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,leftstick:b10,rightstick:b11,leftx:a0,lefty:a1,rightx:a2,righty:a3,",
+"38075082000000000000504944564944,Mad Catz FightPad PRO PS4,platform:Windows,x:b0,a:b1,b:b2,y:b3,back:b13,guide:b12,start:b9,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:a3,rightshoulder:b5,righttrigger:a4,leftstick:b10,rightstick:b11,leftx:a0,lefty:a1,rightx:a2,righty:a5,",
+"38078433000000000000504944564944,Mad Catz FightStick TE S+ PS3,a:b1,b:b2,x:b0,y:b3,back:b8,guide:b12,start:b9,leftshoulder:b4,rightshoulder:b5,dpup:h0.1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,lefttrigger:b6,righttrigger:b7,platform:Windows,",
+"38078483000000000000504944564944,Mad Catz FightStick TE S+ PS4,a:b1,b:b2,x:b0,y:b3,back:b8,guide:b12,start:b9,leftstick:b10,rightstick:b11,leftshoulder:b4,rightshoulder:b5,dpup:h0.1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,leftx:a0,lefty:a1,rightx:a2,righty:a5,lefttrigger:a3,righttrigger:b6,platform:Windows,",
+"38078134000000000000504944564944,Mad Catz FightStick TE2+ PS3,a:b1,b:b2,x:b0,y:b3,back:b8,guide:b12,start:b9,leftstick:b10,rightstick:b11,leftshoulder:b7,rightshoulder:b5,dpup:h0.1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,leftx:a0,lefty:a1,rightx:a2,righty:a3,lefttrigger:b6,righttrigger:b4,platform:Windows,",
+"38078184000000000000504944564944,Mad Catz FightStick TE2+ PS4,a:b1,b:b2,x:b0,y:b3,back:b8,guide:b12,start:b9,leftstick:b10,rightstick:b11,leftshoulder:b5,rightshoulder:b4,dpup:h0.1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,leftx:a0,lefty:a1,rightx:a2,righty:a5,lefttrigger:a4,righttrigger:b7,platform:Windows,",
+"38078034000000000000504944564944,Mad Catz TE2 PS3 Fightstick,a:b1,b:b2,x:b0,y:b3,back:b8,guide:b12,start:b9,leftshoulder:b4,rightshoulder:b5,dpup:h0.1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,leftx:a0,lefty:a1,rightx:a2,righty:a3,lefttrigger:b6,righttrigger:b7,platform:Windows,",
+"38078084000000000000504944564944,Mad Catz TE2 PS4 Fightstick,a:b1,b:b2,x:b0,y:b3,back:b8,guide:b12,start:b9,leftshoulder:b4,rightshoulder:b5,dpup:h0.1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,leftx:a0,lefty:a1,rightx:a2,righty:a5,lefttrigger:a3,righttrigger:a4,platform:Windows,",
+"38078532000000000000504944564944,Madcatz Arcade Fightstick TE S PS3,a:b1,b:b2,x:b0,y:b3,back:b8,guide:b12,start:b9,leftshoulder:b4,rightshoulder:b5,dpup:h0.1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,leftx:a0,lefty:a1,rightx:a2,righty:a3,lefttrigger:b6,righttrigger:b7,platform:Windows,",
+"38073888000000000000504944564944,Madcatz Arcade Fightstick TE S+ PS3,a:b1,b:b2,x:b0,y:b3,back:b8,guide:b12,start:b9,leftshoulder:b4,rightshoulder:b5,dpup:h0.1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,leftx:a0,lefty:a1,rightx:a2,righty:a3,lefttrigger:b6,righttrigger:b7,platform:Windows,",
+"38071888000000000000504944564944,MadCatz SFIV FightStick PS3,a:b0,b:b1,x:b2,y:b3,back:b8,guide:b12,start:b9,leftshoulder:b5,rightshoulder:b4,dpup:h0.1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,leftx:a0,lefty:a1,rightx:a2,righty:a3,lefttrigger:b7,righttrigger:b6,platform:Windows,",
+"03000000380700008081000000000000,MADCATZ SFV Arcade FightStick Alpha PS4,a:b1,b:b2,y:b3,x:b0,start:b9,guide:b12,back:b8,leftshoulder:b4,rightshoulder:b5,dpup:h0.1,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,leftx:a0,lefty:a1,rightx:a2,righty:a5,lefttrigger:b6,righttrigger:b7,platform:Windows,",
+"25090128000000000000504944564944,Mayflash Arcade Stick,a:b1,b:b2,x:b5,y:b6,back:b8,start:b9,leftshoulder:b0,rightshoulder:b3,leftx:a0,lefty:a1,rightx:h0.4,righty:h0.0,lefttrigger:b4,righttrigger:b7,platform:Windows,",
+"79004318000000000000504944564944,Mayflash GameCube Controller Adapter,platform:Windows,a:b1,b:b2,x:b0,y:b3,back:b0,start:b9,guide:b0,leftshoulder:b4,rightshoulder:b7,leftstick:b0,rightstick:b0,leftx:a0,lefty:a1,rightx:a5,righty:a2,lefttrigger:a3,righttrigger:a4,dpup:h0.1,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,",
+"8f0e1030000000000000504944564944,Mayflash USB Adapter for original Sega Saturn controller,a:b0,b:b1,x:b3,y:b4,start:b9,leftshoulder:b6,rightshoulder:b2,dpup:h0.1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,lefttrigger:b5,righttrigger:b7,platform:Windows,",
+"2509e803000000000000504944564944,Mayflash Wii Classic Controller,a:b1,b:b0,x:b3,y:b2,back:b8,guide:b10,start:b9,leftshoulder:b4,rightshoulder:b5,dpup:h0.1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:b11,dpdown:b13,dpleft:b12,dpright:b14,leftx:a0,lefty:a1,rightx:a2,righty:a3,lefttrigger:b6,righttrigger:b7,platform:Windows,",
+"79000018000000000000504944564944,Mayflash WiiU Pro Game Controller Adapter (DInput),a:b1,b:b2,x:b0,y:b3,back:b8,start:b9,leftstick:b10,rightstick:b11,leftshoulder:b4,rightshoulder:b5,dpup:h0.1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,leftx:a0,lefty:a1,rightx:a2,righty:a3,lefttrigger:b6,righttrigger:b7,platform:Windows,",
+"8f0e0d31000000000000504944564944,Multilaser JS071 USB,platform:Windows,a:b1,b:b2,y:b3,x:b0,start:b9,back:b8,leftstick:b10,rightstick:b11,leftshoulder:b4,rightshoulder:b5,dpup:h0.1,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,leftx:a0,lefty:a1,rightx:a2,righty:a3,lefttrigger:b6,righttrigger:b7,",
+"100801e5000000000000504944564944,NEXT Classic USB Game Controller,a:b0,b:b1,back:b8,start:b9,rightx:a2,righty:a3,leftx:a0,lefty:a1,platform:Windows,",
+"bd1215d0000000000000504944564944,Nintendo Retrolink USB Super SNES Classic Controller,y:b0,b:b1,a:b2,x:b3,leftshoulder:b4,rightshoulder:b5,start:b9,back:b8,leftx:a0,lefty:a1,platform:Windows,",
+"4b12014d000000000000504944564944,NYKO AIRFLO,a:b0,b:b1,x:b2,y:b3,back:b8,guide:b10,start:b9,leftstick:a0,rightstick:a2,leftshoulder:a3,rightshoulder:b5,dpup:h0.1,dpdown:h0.0,dpleft:h0.8,dpright:h0.2,leftx:h0.6,lefty:h0.12,rightx:h0.9,righty:h0.4,lefttrigger:b6,righttrigger:b7,platform:Windows,",
+"36280100000000000000504944564944,OUYA Controller,platform:Windows,a:b0,b:b3,y:b2,x:b1,start:b14,guide:b15,leftstick:b6,rightstick:b7,leftshoulder:b4,rightshoulder:b5,dpup:b8,dpleft:b10,dpdown:b9,dpright:b11,leftx:a0,lefty:a1,rightx:a3,righty:a4,lefttrigger:b12,righttrigger:b13,",
+"120cf60e000000000000504944564944,P4 Wired Gamepad,a:b1,b:b2,x:b0,y:b3,back:b12,guide:b8,start:b9,leftshoulder:b5,rightshoulder:b4,dpup:h0.1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,leftx:h0.0,lefttrigger:b7,righttrigger:b6,platform:Windows,",
+"8f0e0300000000000000504944564944,Piranha xtreme,platform:Windows,x:b3,a:b2,b:b1,y:b0,back:b8,start:b9,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,dpup:h0.1,leftshoulder:b6,lefttrigger:b4,rightshoulder:b7,righttrigger:b5,leftstick:b10,rightstick:b11,leftx:a0,lefty:a1,rightx:a3,righty:a2,",
+"d6206dca000000000000504944564944,PowerA Pro Ex,a:b1,b:b2,x:b0,y:b3,back:b8,guide:b12,start:b9,leftstick:b10,rightstick:b11,leftshoulder:b4,rightshoulder:b5,dpup:h0.1,dpdown:h0.0,dpleft:h0.8,dpright:h0.2,leftx:a0,lefty:a1,rightx:a2,righty:a3,lefttrigger:b6,righttrigger:b7,platform:Windows,",
+"10080100000000000000504944564944,PS1 USB,platform:Windows,a:b2,b:b1,x:b3,y:b0,back:b8,start:b9,leftshoulder:b6,rightshoulder:b7,leftstick:b10,rightstick:b11,leftx:a0,lefty:a1,rightx:a3,righty:a2,lefttrigger:b4,righttrigger:b5,dpup:h0.1,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,",
+"10080300000000000000504944564944,PS2 USB,platform:Windows,a:b2,b:b1,y:b0,x:b3,start:b9,back:b8,leftstick:b10,rightstick:b11,leftshoulder:b6,rightshoulder:b7,dpup:h0.1,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,leftx:a0,lefty:a1,rightx:a4,righty:a2,lefttrigger:b4,righttrigger:b5,",
+"88880803000000000000504944564944,PS3 Controller,a:b2,b:b1,back:b8,dpdown:h0.8,dpleft:h0.4,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b9,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:b7,rightx:a3,righty:a4,start:b11,x:b0,y:b3,platform:Windows,",
+"4c056802000000000000504944564944,PS3 Controller,a:b14,b:b13,back:b0,dpdown:b6,dpleft:b7,dpright:b5,dpup:b4,guide:b16,leftshoulder:b10,leftstick:b1,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b11,rightstick:b2,righttrigger:b9,rightx:a2,righty:a3,start:b3,x:b15,y:b12,platform:Windows,",
+"25090500000000000000504944564944,PS3 DualShock,a:b2,b:b1,back:b9,dpdown:h0.8,dpleft:h0.4,dpright:h0.2,dpup:h0.1,guide:,leftshoulder:b6,leftstick:b10,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b11,righttrigger:b5,rightx:a2,righty:a3,start:b8,x:b0,y:b3,platform:Windows,",
+"10008200000000000000504944564944,PS360+ v1.66,a:b1,b:b2,x:b0,y:b3,back:b8,guide:b12,start:b9,leftshoulder:b4,rightshoulder:b5,dpup:h0.1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,leftx:h0.4,lefttrigger:b6,righttrigger:b7,platform:Windows,",
+"4c05c405000000000000504944564944,PS4 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,",
+"300f0011000000000000504944564944,QanBa Arcade JoyStick 1008,platform:Windows,x:b0,a:b1,b:b2,y:b3,back:b8,start:b10,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,leftx:a0,lefty:a1,",
+"300f1611000000000000504944564944,QanBa Arcade JoyStick 4018,a:b1,b:b2,x:b0,y:b3,back:b10,guide:b9,start:b8,leftshoulder:b4,rightshoulder:b5,dpup:h0.1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,lefttrigger:b6,righttrigger:b7,platform:Windows,",
+"222c0020000000000000504944564944,QANBA DRONE ARCADE JOYSTICK,a:b1,b:b2,x:b0,y:b3,back:b8,guide:b12,start:b9,leftshoulder:b4,rightshoulder:b5,dpup:h0.1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,lefttrigger:a3,righttrigger:a4,platform:Windows,",
+"300f1210000000000000504944564944,QanBa Joystick Plus,a:b0,b:b1,x:b2,y:b3,start:b9,leftshoulder:b4,rightshoulder:b5,dpup:h0.1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,platform:Windows,",
+"341a0104000000000000504944564944,QanBa Joystick Q4RAF,a:b5,b:b6,x:b1,y:b2,back:b8,guide:b10,start:b9,leftshoulder:b0,rightshoulder:b3,dpup:h0.1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,leftx:a0,lefty:a1,lefttrigger:b4,righttrigger:b7,platform:Windows,",
+"222c0223000000000000504944564944,Qanba Obsidian Arcade Joystick PS3 Mode,a:b1,b:b2,x:b0,y:b3,back:b8,guide:b12,start:b9,leftstick:b10,rightstick:b11,leftshoulder:b4,rightshoulder:b5,dpup:h0.1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,leftx:a0,lefty:a1,rightx:a2,righty:a3,lefttrigger:b6,righttrigger:b7,platform:Windows,",
+"222c0023000000000000504944564944,Qanba Obsidian Arcade Joystick PS4 Mode,a:b1,b:b2,x:b0,y:b3,back:b13,guide:b12,start:b9,leftstick:b10,rightstick:b11,leftshoulder:b4,rightshoulder:b5,dpup:h0.1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,leftx:a0,lefty:a1,rightx:a2,righty:a5,lefttrigger:a3,righttrigger:a4,platform:Windows,",
+"0d0f1100000000000000504944564944,REAL ARCADE PRO.3,a:b1,b:b2,x:b0,y:b3,back:b8,guide:b12,start:b9,leftstick:b10,rightstick:b11,leftshoulder:b4,rightshoulder:b5,dpup:h0.1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,lefttrigger:b6,righttrigger:b7,platform:Windows,",
+"0d0f8b00000000000000504944564944,Real Arcade Pro.4,platform:Windows,x:b0,a:b1,b:b2,y:b3,back:b8,guide:b12,start:b9,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,leftstick:b10,rightstick:b11,leftx:a0,lefty:a1,rightx:a2,righty:a3,",
+"0d0f8a00000000000000504944564944,Real Arcade Pro.4,platform:Windows,x:b0,a:b1,b:b2,y:b3,back:b8,guide:b12,start:b9,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:a3,rightshoulder:b5,righttrigger:a4,leftstick:b10,rightstick:b11,leftx:a0,lefty:a1,rightx:a2,righty:a5,",
+"0d0f6b00000000000000504944564944,Real Arcade Pro.4,platform:Windows,x:b0,a:b1,b:b2,y:b3,back:b8,guide:b12,start:b9,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,leftstick:b10,rightstick:b11,leftx:a0,lefty:a1,rightx:a2,righty:a3,",
+"0d0f6a00000000000000504944564944,Real Arcade Pro.4,platform:Windows,x:b0,a:b1,b:b2,y:b3,back:b8,guide:b12,start:b9,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:a3,rightshoulder:b5,righttrigger:a4,leftstick:b10,rightstick:b11,leftx:a0,lefty:a1,rightx:a2,righty:a5,",
+"0d0f7000000000000000504944564944,REAL ARCADE PRO.4 VLX,a:b1,b:b2,x:b0,y:b3,back:b8,guide:b12,start:b9,leftstick:b10,rightstick:b11,leftshoulder:b4,rightshoulder:b5,dpup:h0.1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,lefttrigger:b6,righttrigger:b7,platform:Windows,",
+"0d0f2200000000000000504944564944,REAL ARCADE Pro.V3,platform:Windows,x:b0,a:b1,b:b2,y:b3,back:b8,guide:b12,start:b9,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,leftx:a0,lefty:a1,rightx:a2,righty:a3,",
+"00f00300000000000000504944564944,RetroUSB.com RetroPad,a:b1,b:b5,x:b0,y:b4,back:b2,start:b3,leftshoulder:b6,rightshoulder:b7,leftx:a0,lefty:a1,platform:Windows,",
+"00f0f100000000000000504944564944,RetroUSB.com Super RetroPort,a:b1,b:b5,x:b0,y:b4,back:b2,start:b3,leftshoulder:b6,rightshoulder:b7,leftx:a0,lefty:a1,platform:Windows,",
+"6f0e1e01000000000000504944564944,Rock Candy Gamepad for PS3,platform:Windows,a:b1,b:b2,x:b0,y:b3,back:b8,start:b9,guide:b12,leftshoulder:b4,rightshoulder:b5,leftstick:b10,rightstick:b11,leftx:a0,lefty:a1,rightx:a2,righty:a3,lefttrigger:b6,righttrigger:b7,dpup:h0.1,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,",
+"300f1201000000000000504944564944,Saitek Dual Analog Pad,a:b2,b:b3,x:b0,y:b1,back:b8,start:b9,leftstick:b10,rightstick:b11,leftshoulder:b4,rightshoulder:b6,dpup:h0.1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,leftx:a0,lefty:a1,rightx:a3,righty:a2,lefttrigger:b5,righttrigger:b7,platform:Windows,",
+"a3060cff000000000000504944564944,Saitek P2500,a:b2,b:b3,y:b1,x:b0,start:b4,guide:b10,back:b5,leftstick:b8,rightstick:b9,leftshoulder:b6,rightshoulder:b7,dpup:h0.1,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,leftx:a0,lefty:a1,rightx:a2,righty:a3,platform:Windows,",
+"300f1001000000000000504944564944,Saitek P480 Rumble Pad,a:b2,b:b3,x:b0,y:b1,back:b8,start:b9,leftstick:b10,rightstick:b11,leftshoulder:b4,rightshoulder:b6,dpup:h0.1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,leftx:a0,lefty:a1,rightx:a3,righty:a2,lefttrigger:b5,righttrigger:b7,platform:Windows,",
+"9b280500000000000000504944564944,Saturn_Adapter_2.0,a:b1,b:b2,x:b0,y:b3,start:b9,leftshoulder:b6,rightshoulder:b7,leftx:a0,lefty:a1,lefttrigger:b4,righttrigger:b5,platform:Windows,",
+"79001100000000000000504944564944,Sega Saturn Gamepad,a:b1,b:b2,x:b4,y:b5,start:b8,leftshoulder:b6,rightshoulder:b7,leftx:a0,lefty:a4,lefttrigger:b3,righttrigger:b0,platform:Windows,",
+"4c05cc09000000000000504944564944,Sony DualShock 4,a:b1,b:b2,y:b3,x:b0,start:b9,guide:b12,back:b13,leftstick:b10,rightstick:b11,leftshoulder:b4,rightshoulder:b5,dpup:h0.1,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,leftx:a0,lefty:a1,rightx:a2,righty:a5,lefttrigger:a3,righttrigger:a4,platform:Windows,",
+"4c05a00b000000000000504944564944,Sony DualShock 4 Wireless Adaptor,a:b1,b:b2,y:b3,x:b0,start:b9,guide:b12,back:b13,leftstick:b10,rightstick:b11,leftshoulder:b4,rightshoulder:b5,dpup:h0.1,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,leftx:a0,lefty:a1,rightx:a2,righty:a5,lefttrigger:a3,righttrigger:a4,platform:Windows,",
+"ff113133000000000000504944564944,SVEN X-PAD,platform:Windows,a:b2,b:b3,y:b1,x:b0,start:b5,back:b4,leftshoulder:b6,rightshoulder:b7,dpup:h0.1,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,leftx:a0,lefty:a1,rightx:a2,righty:a4,lefttrigger:b8,righttrigger:b9,",
+"4f0415b3000000000000504944564944,Thrustmaster Dual Analog 3.2,platform:Windows,x:b1,a:b0,b:b2,y:b3,back:b8,start:b9,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b5,rightshoulder:b6,righttrigger:b7,leftstick:b10,rightstick:b11,leftx:a0,lefty:a1,rightx:a2,righty:a3,",
+"4f0400b3000000000000504944564944,Thrustmaster Firestorm Dual Power,a:b0,b:b2,y:b3,x:b1,start:b10,guide:b8,back:b9,leftstick:b11,rightstick:b12,leftshoulder:b4,rightshoulder:b6,dpup:h0.1,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,leftx:a0,lefty:a1,rightx:a2,righty:a3,lefttrigger:b5,righttrigger:b7,platform:Windows,",
+"66660488000000000000504944564944,TigerGame PS/PS2 Game Controller Adapter,a:b2,b:b1,x:b3,y:b0,back:b9,start:b8,leftstick:b10,rightstick:b11,leftshoulder:b6,rightshoulder:b7,dpup:b12,dpdown:b14,dpleft:b15,dpright:b13,leftx:a0,lefty:a1,rightx:a2,righty:a3,lefttrigger:b4,righttrigger:b5,platform:Windows,",
+"38076652000000000000504944564944,UnKnown,platform:Windows,x:b0,a:b1,b:b2,y:b3,back:b8,guide:b12,start:b9,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,leftstick:b10,rightstick:b11,leftx:a0,lefty:a1,rightx:a3,righty:a4,",
+"63252305000000000000504944564944,USB Vibration Joystick (BM),platform:Windows,x:b3,a:b2,b:b1,y:b0,back:b8,start:b9,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,leftstick:b10,rightstick:b11,leftx:a0,lefty:a1,rightx:a2,righty:a3,",
+"79001b18000000000000504944564944,Venom Arcade Joystick,a:b1,b:b2,x:b0,y:b3,back:b8,guide:b12,start:b9,leftshoulder:b4,rightshoulder:b5,dpup:h0.1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,lefttrigger:b6,righttrigger:b7,platform:Windows,",
+"10280000000000000900000000000000,8Bitdo SFC30 GamePad,a:b1,b:b0,x:b4,y:b3,back:b10,start:b11,leftshoulder:b6,rightshoulder:b7,leftx:a0,lefty:a1,platform:Mac OS X,",
+"79000000000000000600000000000000,G-Shark GP-702,a:b2,b:b1,x:b3,y:b0,back:b8,start:b9,leftstick:b10,rightstick:b11,leftshoulder:b4,rightshoulder:b5,dpup:h0.1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,leftx:a0,lefty:a1,rightx:a3,righty:a4,lefttrigger:b6,righttrigger:b7,platform:Mac OS X,",
+"AD1B00000000000001F9000000000000,Gamestop BB-070 X360 Controller,a:b0,b:b1,back:b9,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,guide:b10,leftshoulder:b4,leftstick:b6,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b7,righttrigger:a5,rightx:a3,righty:a4,start:b8,x:b2,y:b3,platform:Mac OS X,",
+"0500000047532047616d657061640000,GameStop Gamepad,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b2,y:b3,platform:Mac OS X,",
+"0d0f0000000000004d00000000000000,HORI Gem Pad 3,platform:Mac OS X,a:b1,b:b2,y:b3,x:b0,start:b9,guide:b12,back:b8,leftstick:b10,rightstick:b11,leftshoulder:b4,rightshoulder:b5,dpup:h0.1,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,leftx:a0,lefty:a1,rightx:a2,righty:a3,lefttrigger:b6,righttrigger:b7,",
+"0d0f0000000000006600000000000000,HORIPAD FPS PLUS 4,platform:Mac OS X,a:b1,b:b2,y:b3,x:b0,start:b9,guide:b12,back:b8,leftstick:b10,rightstick:b11,leftshoulder:b4,rightshoulder:b5,dpup:h0.1,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,leftx:a0,lefty:a1,rightx:a2,righty:a5,lefttrigger:b6,righttrigger:a4,",
+"83050000000000006020000000000000,iBuffalo USB 2-axis 8-button Gamepad,a:b1,b:b0,x:b3,y:b2,back:b6,start:b7,leftshoulder:b4,rightshoulder:b5,leftx:a0,lefty:a1,platform:Mac OS X,",
+"6d0400000000000016c2000000000000,Logitech F310 Gamepad (DInput),a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Mac OS X,",
+"6d0400000000000018c2000000000000,Logitech F510 Gamepad (DInput),a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Mac OS X,",
+"6d040000000000001fc2000000000000,Logitech F710 Gamepad (XInput),a:b0,b:b1,back:b9,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,guide:b10,leftshoulder:b4,leftstick:b6,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b7,righttrigger:a5,rightx:a3,righty:a4,start:b8,x:b2,y:b3,platform:Mac OS X,",
+"6d0400000000000019c2000000000000,Logitech Wireless Gamepad (DInput),a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Mac OS X,",
+"2509000000000000e803000000000000,Mayflash Wii Classic Controller,a:b1,b:b0,x:b3,y:b2,back:b8,guide:b10,start:b9,leftshoulder:b4,rightshoulder:b5,dpup:h0.1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:b11,dpdown:b13,dpleft:b12,dpright:b14,leftx:a0,lefty:a1,rightx:a2,righty:a3,lefttrigger:b6,righttrigger:b7,platform:Mac OS X,",
+"79000000000000000018000000000000,Mayflash WiiU Pro Game Controller Adapter (DInput),a:b4,b:b8,x:b0,y:b12,back:b32,start:b36,leftstick:b40,rightstick:b44,leftshoulder:b16,rightshoulder:b20,dpup:h0.1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,leftx:a0,lefty:a4,rightx:a8,righty:a12,lefttrigger:b24,righttrigger:b28,platform:Mac OS X,",
+"d814000000000000cecf000000000000,MC Cthulhu,platform:Mac OS X,leftx:,lefty:,rightx:,righty:,lefttrigger:b6,a:b1,b:b2,y:b3,x:b0,start:b9,back:b8,leftshoulder:b4,rightshoulder:b5,dpup:h0.1,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,righttrigger:b7,",
+"8f0e0000000000000300000000000000,Piranha xtreme,platform:Mac OS X,x:b3,a:b2,b:b1,y:b0,back:b8,start:b9,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,dpup:h0.1,leftshoulder:b6,lefttrigger:b4,rightshoulder:b7,righttrigger:b5,leftstick:b10,rightstick:b11,leftx:a0,lefty:a1,rightx:a3,righty:a2,",
+"4c050000000000006802000000000000,PS3 Controller,a:b14,b:b13,back:b0,dpdown:b6,dpleft:b7,dpright:b5,dpup:b4,guide:b16,leftshoulder:b10,leftstick:b1,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b11,rightstick:b2,righttrigger:b9,rightx:a2,righty:a3,start:b3,x:b15,y:b12,platform:Mac OS X,",
+"4c05000000000000c405000000000000,PS4 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Mac OS X,",
+"891600000000000000fd000000000000,Razer Onza Tournament,a:b0,b:b1,y:b3,x:b2,start:b8,guide:b10,back:b9,leftstick:b6,rightstick:b7,leftshoulder:b4,rightshoulder:b5,dpup:b11,dpleft:b13,dpdown:b12,dpright:b14,leftx:a0,lefty:a1,rightx:a3,righty:a4,lefttrigger:a2,righttrigger:a5,platform:Mac OS X,",
+"79000000000000001100000000000000,Retrolink Classic Controller,x:b3,a:b2,b:b1,y:b0,back:b8,start:b9,leftshoulder:b4,rightshoulder:b5,leftx:a3,lefty:a4,platform:Mac OS X,",
+"81170000000000007e05000000000000,Sega Saturn,x:b0,a:b2,b:b4,y:b6,start:b13,dpleft:b15,dpdown:b16,dpright:b14,dpup:b17,leftshoulder:b8,lefttrigger:a5,lefttrigger:b10,rightshoulder:b9,righttrigger:a4,righttrigger:b11,leftx:a0,lefty:a2,platform:Mac OS X,",
+"b4040000000000000a01000000000000,Sega Saturn USB Gamepad,a:b0,b:b1,x:b3,y:b4,back:b5,guide:b2,start:b8,leftshoulder:b6,rightshoulder:b7,leftx:a0,lefty:a1,platform:Mac OS X,",
+"351200000000000021ab000000000000,SFC30 Joystick,a:b1,b:b0,x:b4,y:b3,back:b10,start:b11,leftshoulder:b6,rightshoulder:b7,leftx:a0,lefty:a1,platform:Mac OS X,",
+"4c05000000000000cc09000000000000,Sony DualShock 4 V2,a:b1,b:b2,y:b3,x:b0,start:b9,guide:b12,back:b13,leftstick:b10,rightstick:b11,leftshoulder:b4,rightshoulder:b5,dpup:h0.1,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,leftx:a0,lefty:a1,rightx:a2,righty:a5,lefttrigger:a3,righttrigger:a4,platform:Mac OS X,",
+"4c05000000000000a00b000000000000,Sony DualShock 4 Wireless Adaptor,a:b1,b:b2,y:b3,x:b0,start:b9,guide:b12,back:b13,leftstick:b10,rightstick:b11,leftshoulder:b4,rightshoulder:b5,dpup:h0.1,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,leftx:a0,lefty:a1,rightx:a2,righty:a5,lefttrigger:a3,righttrigger:a4,platform:Mac OS X,",
+"4f0400000000000015b3000000000000,Thrustmaster Dual Analog 3.2,platform:Mac OS X,x:b1,a:b0,b:b2,y:b3,back:b8,start:b9,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b5,rightshoulder:b6,righttrigger:b7,leftstick:b10,rightstick:b11,leftx:a0,lefty:a1,rightx:a2,righty:a3,",
+"4f0400000000000000b3000000000000,Thrustmaster Firestorm Dual Power,a:b0,b:b2,y:b3,x:b1,start:b10,guide:b8,back:b9,leftstick:b11,rightstick:,leftshoulder:b4,rightshoulder:b6,dpup:h0.1,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,leftx:a0,lefty:a1,rightx:a2,righty:a3,lefttrigger:b5,righttrigger:b7,platform:Mac OS X,",
+"bd1200000000000015d0000000000000,Tomee SNES USB Controller,x:b3,a:b2,b:b1,y:b0,back:b8,start:b9,leftshoulder:b4,rightshoulder:b5,leftx:a0,lefty:a1,platform:Mac OS X,",
+"10080000000000000100000000000000,Twin USB Joystick,a:b4,b:b2,x:b6,y:b0,back:b16,start:b18,leftstick:b20,rightstick:b22,leftshoulder:b12,rightshoulder:b14,dpup:h0.1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,leftx:a0,lefty:a2,rightx:a6,righty:a4,lefttrigger:b8,righttrigger:b10,platform:Mac OS X,",
+"050000005769696d6f74652028303000,Wii Remote,a:b4,b:b5,y:b9,x:b10,start:b6,guide:b8,back:b7,dpup:b2,dpleft:b0,dpdown:b3,dpright:b1,leftx:a0,lefty:a1,lefttrigger:b12,righttrigger:,leftshoulder:b11,platform:Mac OS X,",
+"050000005769696d6f74652028313800,Wii U Pro Controller,a:b16,b:b15,x:b18,y:b17,back:b7,guide:b8,start:b6,leftstick:b23,rightstick:b24,leftshoulder:b19,rightshoulder:b20,dpup:b11,dpdown:b12,dpleft:b13,dpright:b14,leftx:a0,lefty:a1,rightx:a2,righty:a3,lefttrigger:b21,righttrigger:b22,platform:Mac OS X,",
+"5e040000000000008e02000000000000,X360 Controller,a:b0,b:b1,back:b9,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,guide:b10,leftshoulder:b4,leftstick:b6,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b7,righttrigger:a5,rightx:a3,righty:a4,start:b8,x:b2,y:b3,platform:Mac OS X,",
+"5e04000000000000dd02000000000000,Xbox One Wired Controller,platform:Mac OS X,x:b2,a:b0,b:b1,y:b3,back:b9,guide:b10,start:b8,dpleft:b13,dpdown:b12,dpright:b14,dpup:b11,leftshoulder:b4,lefttrigger:a2,rightshoulder:b5,righttrigger:a5,leftstick:b6,rightstick:b7,leftx:a0,lefty:a1,rightx:a3,righty:a4,",
+"5e04000000000000ea02000000000000,Xbox Wireless Controller,platform:Mac OS X,x:b2,a:b0,b:b1,y:b3,back:b9,guide:b10,start:b8,dpleft:b13,dpdown:b12,dpright:b14,dpup:b11,leftshoulder:b4,lefttrigger:a2,rightshoulder:b5,righttrigger:a5,leftstick:b6,rightstick:b7,leftx:a0,lefty:a1,rightx:a3,righty:a4,",
+"5e04000000000000e002000000000000,Xbox Wireless Controller,platform:Mac OS X,x:b2,a:b0,b:b1,y:b3,back:b6,guide:b10,start:b7,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:a2,rightshoulder:b5,righttrigger:a5,leftstick:b8,rightstick:b9,leftx:a0,lefty:a1,rightx:a3,righty:a4,",
+"05000000102800000900000000010000,8Bitdo SFC30 GamePad,platform:Linux,x:b4,a:b1,b:b0,y:b3,back:b10,start:b11,leftshoulder:b6,rightshoulder:b7,leftx:a0,lefty:a1,",
+"05000000a00500003232000001000000,8Bitdo Zero GamePad,platform:Linux,a:b0,b:b1,x:b3,y:b4,back:b10,start:b11,leftshoulder:b6,rightshoulder:b7,leftx:a0,lefty:a1,",
+"030000006f0e00003901000020060000,Afterglow Wired Controller for Xbox One,x:b2,a:b0,b:b1,y:b3,back:b6,guide:b8,start:b7,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:a2,rightshoulder:b5,righttrigger:a5,leftstick:b9,rightstick:b10,leftx:a0,lefty:a1,rightx:a3,righty:a4,platform:Linux,",
+"03000000790000000600000010010000,DragonRise Inc.   Generic   USB  Joystick  ,platform:Linux,x:b3,a:b2,b:b1,y:b0,back:b8,start:b9,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,leftstick:b10,rightstick:b11,leftx:a0,lefty:a1,rightx:a3,righty:a4,",
+"030000006f0e00003001000001010000,EA Sports PS3 Controller,platform:Linux,a:b1,b:b2,y:b3,x:b0,start:b9,guide:b12,back:b8,leftstick:b10,rightstick:b11,leftshoulder:b4,rightshoulder:b5,dpup:h0.1,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,leftx:a0,lefty:a1,rightx:a2,righty:a3,lefttrigger:b6,righttrigger:b7,",
+"03000000341a000005f7000010010000,GameCube {HuiJia USB box},a:b1,b:b2,y:b3,x:b0,start:b9,guide:,back:,leftstick:,rightstick:,leftshoulder:,dpleft:b15,dpdown:b14,dpright:b13,leftx:a0,lefty:a1,rightx:a5,righty:a2,lefttrigger:a3,righttrigger:a4,rightshoulder:b7,dpup:b12,platform:Linux,",
+"03000000260900008888000000010000,GameCube {WiseGroup USB box},a:b0,b:b2,y:b3,x:b1,start:b7,leftshoulder:,rightshoulder:b6,dpup:h0.1,dpleft:h0.8,rightstick:,dpdown:h0.4,dpright:h0.2,leftx:a0,lefty:a1,rightx:a2,righty:a3,lefttrigger:a4,righttrigger:a5,platform:Linux,",
+"0500000047532047616d657061640000,GameStop Gamepad,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b2,y:b3,platform:Linux,",
+"030000006f0e00001f01000000010000,Generic X-Box pad,platform:Linux,x:b2,a:b0,b:b1,y:b3,back:b6,guide:b8,start:b7,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:a2,rightshoulder:b5,righttrigger:a5,leftstick:b9,rightstick:b10,leftx:a0,lefty:a1,rightx:a3,righty:a4,",
+"030000006f0e00001304000000010000,Generic X-Box pad,platform:Linux,x:b2,a:b0,b:b1,y:b3,back:b6,guide:b8,start:b7,dpleft:h0.8,dpdown:h0.0,dpdown:h0.4,dpright:h0.0,dpright:h0.2,dpup:h0.0,dpup:h0.1,leftshoulder:h0.0,leftshoulder:b4,lefttrigger:a2,rightshoulder:b5,righttrigger:a5,leftstick:a0,rightstick:a3,leftstick:b9,rightstick:b10,leftx:a0,lefty:a1,rightx:a3,righty:a4,",
+"03000000f0250000c183000010010000,Goodbetterbest Ltd USB Controller,platform:Linux,x:b0,a:b1,b:b2,y:b3,back:b8,guide:b12,start:b9,dpleft:h0.8,dpdown:h0.0,dpdown:h0.4,dpright:h0.0,dpright:h0.2,dpup:h0.0,dpup:h0.1,leftshoulder:h0.0,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,leftstick:b10,rightstick:b11,leftx:a0,lefty:a1,rightx:a2,righty:a3,",
+"03000000280400000140000000010000,Gravis GamePad Pro USB ,platform:Linux,x:b0,a:b1,b:b2,y:b3,back:b8,start:b9,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,leftx:a0,lefty:a1,",
+"030000008f0e00001200000010010000,GreenAsia Inc.      USB  Joystick  ,platform:Linux,x:b2,a:b0,b:b1,y:b3,back:b8,start:b9,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b5,rightshoulder:b6,righttrigger:b7,leftstick:b10,rightstick:b11,leftx:a0,lefty:a1,rightx:a3,righty:a2,",
+"030000008f0e00000300000010010000,GreenAsia Inc.    USB Joystick     ,platform:Linux,x:b3,a:b2,b:b1,y:b0,back:b8,start:b9,dpleft:h0.8,dpdown:h0.0,dpdown:h0.4,dpright:h0.0,dpright:h0.2,dpup:h0.0,dpup:h0.1,leftshoulder:h0.0,leftshoulder:b6,lefttrigger:b4,rightshoulder:b7,righttrigger:b5,leftstick:b10,rightstick:b11,leftx:a0,lefty:a1,rightx:a3,righty:a2,",
+"03000000ff1100004133000010010000,GreenAsia Inc.USB Joystick,platform:Linux,x:b3,a:b2,b:b1,y:b0,back:b8,start:b9,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,dpup:h0.1,leftshoulder:b6,lefttrigger:b4,rightshoulder:b7,righttrigger:b5,leftstick:b10,rightstick:b11,leftx:a0,lefty:a1,rightx:a3,righty:a2,",
+"06000000adde0000efbe000002010000,Hidromancer Game Controller,platform:Linux,x:b2,a:b0,b:b1,y:b3,back:b6,guide:b8,start:b7,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:a2,rightshoulder:b5,righttrigger:a5,leftstick:b9,rightstick:b10,leftx:a0,lefty:a1,rightx:a3,righty:a4,",
+"03000000d81400000862000011010000,HitBox (PS3/PC) Analog Mode,platform:Linux,a:b1,b:b2,y:b3,x:b0,start:b12,guide:b9,back:b8,leftshoulder:b4,rightshoulder:b5,lefttrigger:b6,righttrigger:b7,leftx:a0,lefty:a1,",
+"03000000c9110000f055000011010000,HJC Game GAMEPAD,leftx:a0,lefty:a1,dpdown:h0.4,rightstick:b11,rightshoulder:b5,rightx:a2,start:b9,righty:a3,dpleft:h0.8,lefttrigger:b6,x:b2,dpup:h0.1,back:b8,leftstick:b10,leftshoulder:b4,y:b3,a:b0,dpright:h0.2,righttrigger:b7,b:b1,platform:Linux,",
+"030000000d0f00000d00000000010000,hori,platform:Linux,a:b0,b:b6,y:b2,x:b1,dpup:h0.1,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,start:b9,guide:b10,back:b8,leftshoulder:b3,rightshoulder:b7,leftx:b4,lefty:b5,",
+"030000000d0f00001000000011010000,HORI CO. LTD. FIGHTING STICK 3,platform:Linux,x:b0,a:b1,b:b2,y:b3,back:b8,guide:b12,start:b9,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7",
+"030000000d0f00002200000011010000,HORI CO. LTD. REAL ARCADE Pro.V3,platform:Linux,x:b0,a:b1,b:b2,y:b3,back:b8,guide:b12,start:b9,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,dpup:h0.1,",
+"03000000ad1b000001f5000033050000,Hori Pad EX Turbo 2,a:b0,b:b1,y:b3,x:b2,start:b7,guide:b8,back:b6,leftstick:b9,rightstick:b10,leftshoulder:b4,rightshoulder:b5,dpup:h0.1,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,leftx:a0,lefty:a1,rightx:a3,righty:a4,lefttrigger:a2,righttrigger:a5,platform:Linux,",
+"03000000830500006020000010010000,iBuffalo USB 2-axis 8-button Gamepad,a:b1,b:b0,x:b3,y:b2,back:b6,start:b7,leftshoulder:b4,rightshoulder:b5,leftx:a0,lefty:a1,platform:Linux,",
+"03000000fd0500000030000000010000,InterAct GoPad I-73000 (Fighting Game Layout),platform:Linux,a:b3,b:b4,y:b1,x:b0,start:b7,back:b6,leftx:a0,lefty:a1,rightshoulder:b2,righttrigger:b5,",
+"030000006e0500000320000010010000,JC-U3613M - DirectInput Mode,platform:Linux,x:b0,a:b2,b:b3,y:b1,back:b10,guide:b12,start:b11,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,leftstick:b8,rightstick:b9,leftx:a0,lefty:a1,rightx:a2,righty:a3,",
+"03000000300f00001001000010010000,Jess Tech Dual Analog Rumble Pad,platform:Linux,x:b0,a:b2,b:b3,y:b1,back:b8,start:b9,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b5,rightshoulder:b6,righttrigger:b7,leftstick:b10,rightstick:b11,leftx:a0,lefty:a1,rightx:a3,righty:a2,",
+"03000000ba2200002010000001010000,Jess Technology USB Game Controller,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b7,rightx:a3,righty:a2,start:b9,x:b3,y:b0,platform:Linux,",
+"030000006f0e00000103000000020000,Logic3 Controller,platform:Linux,x:b2,a:b0,b:b1,y:b3,back:b6,guide:b8,start:b7,dpleft:h0.8,dpdown:h0.0,dpdown:h0.4,dpright:h0.0,dpright:h0.2,dpup:h0.0,dpup:h0.1,leftshoulder:h0.0,leftshoulder:b4,lefttrigger:a2,rightshoulder:b5,righttrigger:a5,leftstick:b9,rightstick:b10,leftx:a0,lefty:a1,rightx:a3,righty:a4,",
+"030000006d04000019c2000010010000,Logitech Cordless RumblePad 2,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
+"030000006d04000016c2000011010000,Logitech F310 Gamepad (DInput),x:b0,a:b1,b:b2,y:b3,back:b8,start:b9,dpleft:h0.8,dpdown:h0.0,dpdown:h0.4,dpright:h0.0,dpright:h0.2,dpup:h0.0,dpup:h0.1,leftshoulder:h0.0,dpup:h0.1,leftshoulder:h0.0,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,leftstick:b10,rightstick:b11,leftx:a0,lefty:a1,rightx:a2,righty:a3,platform:Linux,",
+"030000006d0400001dc2000014400000,Logitech F310 Gamepad (XInput),a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"030000006d0400001ec2000020200000,Logitech F510 Gamepad (XInput),a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"030000006d04000019c2000011010000,Logitech F710 Gamepad (DInput),a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
+"030000006d0400001fc2000005030000,Logitech F710 Gamepad (XInput),a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"030000006d04000016c2000010010000,Logitech Logitech Dual Action,platform:Linux,x:b0,a:b1,b:b2,y:b3,back:b8,start:b9,dpleft:h0.8,dpdown:h0.0,dpdown:h0.4,dpright:h0.0,dpright:h0.2,dpup:h0.0,dpup:h0.1,leftshoulder:h0.0,dpup:h0.1,leftshoulder:h0.0,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,leftstick:b10,rightstick:b11,leftx:a0,lefty:a1,rightx:a2,righty:a3,",
+"030000006d04000018c2000010010000,Logitech Logitech RumblePad 2 USB,platform:Linux,x:b0,a:b1,b:b2,y:b3,back:b8,start:b9,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,leftstick:b10,rightstick:b11,leftx:a0,lefty:a1,rightx:a2,righty:a3,",
+"030000006d04000011c2000010010000,Logitech WingMan Cordless RumblePad,a:b0,b:b1,y:b4,x:b3,start:b8,guide:b5,back:b2,leftshoulder:b6,rightshoulder:b7,dpup:h0.1,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,leftx:a0,lefty:a1,rightx:a3,righty:a4,lefttrigger:b9,righttrigger:b10,platform:Linux,",
+"05000000380700006652000025010000,Mad Catz C.T.R.L.R ,platform:Linux,x:b0,a:b1,b:b2,y:b3,back:b8,guide:b12,start:b9,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,leftstick:b10,rightstick:b11,leftx:a0,lefty:a1,rightx:a2,righty:a3,",
+"03000000ad1b00002ef0000090040000,Mad Catz Fightpad SFxT,platform:Linux,a:b0,b:b1,y:b3,x:b2,start:b7,guide:b8,back:b6,leftshoulder:b4,rightshoulder:b5,dpup:h0.1,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,lefttrigger:a2,righttrigger:a5,",
+"03000000380700001647000010040000,Mad Catz Wired Xbox 360 Controller,platform:Linux,x:b2,a:b0,b:b1,y:b3,back:b6,guide:b8,start:b7,dpleft:h0.8,dpdown:h0.0,dpdown:h0.4,dpright:h0.0,dpright:h0.2,dpup:h0.0,dpup:h0.1,leftshoulder:h0.0,leftshoulder:b4,lefttrigger:a2,rightshoulder:b5,righttrigger:a5,leftstick:b9,rightstick:b10,leftx:a0,lefty:a1,rightx:a3,righty:a4,",
+"03000000ad1b000016f0000090040000,Mad Catz Xbox 360 Controller,platform:Linux,a:b0,b:b1,y:b3,x:b2,start:b7,guide:b8,back:b6,leftstick:b9,rightstick:b10,leftshoulder:b4,rightshoulder:b5,dpup:h0.1,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,leftx:a0,lefty:a1,rightx:a3,righty:a4,lefttrigger:a2,righttrigger:a5,",
+"03000000780000000600000010010000,Microntek USB Joystick,platform:Linux,x:b3,a:b2,b:b1,y:b0,back:b8,start:b9,leftshoulder:b6,lefttrigger:b4,rightshoulder:b7,righttrigger:b5,leftx:a0,lefty:a1,",
+"030000005e0400008e02000004010000,Microsoft X-Box 360 pad,platform:Linux,a:b0,b:b1,x:b2,y:b3,back:b6,start:b7,guide:b8,leftshoulder:b4,rightshoulder:b5,leftstick:b9,rightstick:b10,leftx:a0,lefty:a1,rightx:a3,righty:a4,lefttrigger:a2,righttrigger:a5,dpup:h0.1,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,",
+"030000005e0400008e02000062230000,Microsoft X-Box 360 pad,platform:Linux,x:b2,a:b0,b:b1,y:b3,back:b6,guide:b8,start:b7,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:a2,rightshoulder:b5,righttrigger:a5,leftstick:b9,rightstick:b10,leftx:a0,lefty:a1,rightx:a3,righty:a4,",
+"030000005e040000d102000001010000,Microsoft X-Box One pad,platform:Linux,x:b2,a:b0,b:b1,y:b3,back:b6,guide:b8,start:b7,dpleft:h0.8,dpdown:h0.0,dpdown:h0.4,dpright:h0.0,dpright:h0.2,dpup:h0.0,dpup:h0.1,leftshoulder:h0.0,leftshoulder:b4,lefttrigger:a2,rightshoulder:b5,righttrigger:a5,leftstick:b9,rightstick:b10,leftx:a0,lefty:a1,rightx:a3,righty:a4,",
+"030000005e040000dd02000003020000,Microsoft X-Box One pad v2,x:b2,a:b0,b:b1,y:b3,back:b6,guide:b8,start:b7,dpleft:h0.8,dpdown:h0.0,dpdown:h0.4,dpright:h0.0,dpright:h0.2,dpup:h0.0,dpup:h0.1,leftshoulder:h0.0,leftshoulder:b4,lefttrigger:a2,rightshoulder:b5,righttrigger:a5,leftstick:b9,rightstick:b10,leftx:a0,lefty:a1,rightx:a3,righty:a4,platform:Linux,",
+"030000005e0400008502000000010000,Microsoft X-Box pad (Japan),platform:Linux,x:b3,a:b0,b:b1,y:b4,back:b6,start:b7,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,dpup:h0.1,leftshoulder:b5,lefttrigger:a2,rightshoulder:b2,righttrigger:a5,leftstick:b8,rightstick:b9,leftx:a0,lefty:a1,rightx:a3,righty:a4,",
+"030000005e0400008902000021010000,Microsoft X-Box pad v2 (US),platform:Linux,x:b3,a:b0,b:b1,y:b4,back:b6,start:b7,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,dpup:h0.1,leftshoulder:b5,lefttrigger:a2,rightshoulder:b2,righttrigger:a5,leftstick:b8,rightstick:b9,leftx:a0,lefty:a1,rightx:a3,righty:a4,",
+"05000000d6200000ad0d000001000000,Moga Pro,platform:Linux,a:b0,b:b1,y:b3,x:b2,start:b6,leftstick:b7,rightstick:b8,leftshoulder:b4,rightshoulder:b5,dpup:h0.1,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,leftx:a0,lefty:a1,rightx:a2,righty:a3,lefttrigger:a5,righttrigger:a4,",
+"030000001008000001e5000010010000,NEXT Classic USB Game Controller,a:b0,b:b1,back:b8,start:b9,rightx:a2,righty:a3,leftx:a0,lefty:a1,platform:Linux,",
+"050000007e0500003003000001000000,Nintendo Wii U Pro Controller,platform:Linux,a:b0,b:b1,x:b3,y:b2,back:b8,start:b9,guide:b10,leftshoulder:b4,rightshoulder:b5,leftstick:b11,rightstick:b12,leftx:a0,lefty:a1,rightx:a2,righty:a3,lefttrigger:b6,righttrigger:b7,dpup:b13,dpleft:b15,dpdown:b14,dpright:b16,",
+"05000000010000000100000003000000,Nintendo Wiimote,platform:Linux,a:b0,b:b1,y:b3,x:b2,start:b9,guide:b10,back:b8,leftstick:b11,rightstick:b12,leftshoulder:b4,rightshoulder:b5,dpup:h0.1,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,leftx:a0,lefty:a1,rightx:a2,righty:a3,lefttrigger:b6,righttrigger:b7,",
+"03000000451300000830000010010000,NYKO CORE,a:b1,b:b2,y:b3,x:b0,start:b9,guide:b12,back:b8,leftstick:b10,rightstick:b11,leftshoulder:b4,rightshoulder:b5,dpup:h0.1,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,leftx:a0,lefty:a1,rightx:a2,righty:a5,lefttrigger:b6,righttrigger:b7,platform:Linux,",
+"05000000362800000100000002010000,OUYA Game Controller,a:b0,b:b3,dpdown:b9,dpleft:b10,dpright:b11,dpup:b8,guide:b14,leftshoulder:b4,leftstick:b6,lefttrigger:a2,leftx:a0,lefty:a1,platform:Linux,rightshoulder:b5,rightstick:b7,righttrigger:a5,rightx:a3,righty:a4,x:b1,y:b2,",
+"05000000362800000100000003010000,OUYA Game Controller,a:b0,b:b3,dpdown:b9,dpleft:b10,dpright:b11,dpup:b8,guide:b14,leftshoulder:b4,leftstick:b6,lefttrigger:a2,leftx:a0,lefty:a1,platform:Linux,rightshoulder:b5,rightstick:b7,righttrigger:a5,rightx:a3,righty:a4,x:b1,y:b2,",
+"03000000ff1100003133000010010000,PC Game Controller,a:b2,b:b1,y:b0,x:b3,start:b9,back:b8,leftstick:b10,rightstick:b11,leftshoulder:b4,rightshoulder:b5,dpup:h0.1,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,leftx:a0,lefty:a1,rightx:a2,righty:a3,lefttrigger:b6,righttrigger:b7,platform:Linux,",
+"030000004c0500006802000011010000,PS3 Controller,a:b14,b:b13,back:b0,dpdown:b6,dpleft:b7,dpright:b5,dpup:b4,guide:b16,leftshoulder:b10,leftstick:b1,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b11,rightstick:b2,righttrigger:b9,rightx:a2,righty:a3,start:b3,x:b15,y:b12,platform:Linux,",
+"060000004c0500006802000000010000,PS3 Controller (Bluetooth),a:b14,b:b13,y:b12,x:b15,start:b3,guide:b16,back:b0,leftstick:b1,rightstick:b2,leftshoulder:b10,rightshoulder:b11,dpup:b4,dpleft:b7,dpdown:b6,dpright:b5,leftx:a0,lefty:a1,rightx:a2,righty:a3,lefttrigger:b8,righttrigger:b9,platform:Linux,",
+"050000004c0500006802000000010000,PS3 Controller (Bluetooth),a:b14,b:b13,y:b12,x:b15,start:b3,guide:b16,back:b0,leftstick:b1,rightstick:b2,leftshoulder:b10,rightshoulder:b11,dpup:b4,dpleft:b7,dpdown:b6,dpright:b5,leftx:a0,lefty:a1,rightx:a2,righty:a3,lefttrigger:b8,righttrigger:b9,platform:Linux,",
+"05000000504c415953544154494f4e00,PS3 Controller (Bluetooth),a:b14,b:b13,y:b12,x:b15,start:b3,guide:b16,back:b0,leftstick:b1,rightstick:b2,leftshoulder:b10,rightshoulder:b11,dpup:b4,dpleft:b7,dpdown:b6,dpright:b5,leftx:a0,lefty:a1,rightx:a2,righty:a3,lefttrigger:b8,righttrigger:b9,platform:Linux,",
+"030000009b2800000300000001010000,raphnet.net 4nes4snes v1.5,platform:Linux,x:b1,a:b0,b:b4,y:b5,back:b2,start:b3,leftshoulder:b6,rightshoulder:b7,leftx:a0,lefty:a1,",
+"030000008916000001fd000024010000,Razer Onza Classic Edition,platform:Linux,x:b2,a:b0,b:b1,y:b3,back:b6,guide:b8,start:b7,dpleft:b11,dpdown:b14,dpright:b12,dpup:b13,leftshoulder:b4,lefttrigger:a2,rightshoulder:b5,righttrigger:a5,leftstick:b9,rightstick:b10,leftx:a0,lefty:a1,rightx:a3,righty:a4,",
+"030000008916000000fd000024010000,Razer Onza Tournament,a:b0,b:b1,y:b3,x:b2,start:b7,guide:b8,back:b6,leftstick:b9,rightstick:b10,leftshoulder:b4,rightshoulder:b5,dpup:b13,dpleft:b11,dpdown:b14,dpright:b12,leftx:a0,lefty:a1,rightx:a3,righty:a4,lefttrigger:a2,righttrigger:a5,platform:Linux,",
+"03000000790000001100000010010000,RetroLink Saturn Classic Controller,platform:Linux,x:b3,a:b0,b:b1,y:b4,back:b5,guide:b2,start:b8,leftshoulder:b6,rightshoulder:b7,leftx:a0,lefty:a1,",
+"0300000000f000000300000000010000,RetroUSB.com RetroPad,a:b1,b:b5,x:b0,y:b4,back:b2,start:b3,leftshoulder:b6,rightshoulder:b7,leftx:a0,lefty:a1,platform:Linux,",
+"0300000000f00000f100000000010000,RetroUSB.com Super RetroPort,a:b1,b:b5,x:b0,y:b4,back:b2,start:b3,leftshoulder:b6,rightshoulder:b7,leftx:a0,lefty:a1,platform:Linux,",
+"030000006f0e00001e01000011010000,Rock Candy Gamepad for PS3,platform:Linux,a:b1,b:b2,x:b0,y:b3,back:b8,start:b9,guide:b12,leftshoulder:b4,rightshoulder:b5,leftstick:b10,rightstick:b11,leftx:a0,lefty:a1,rightx:a2,righty:a3,lefttrigger:b6,righttrigger:b7,dpup:h0.1,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,",
+"030000006f0e00004601000001010000,Rock Candy Wired Controller for Xbox One,platform:Linux,a:b0,b:b1,x:b2,y:b3,leftshoulder:b4,rightshoulder:b5,back:b6,start:b7,guide:b8,leftstick:b9,rightstick:b10,lefttrigger:a2,righttrigger:a5,leftx:a0,lefty:a1,rightx:a3,righty:a4,",
+"03000000a306000023f6000011010000,Saitek Cyborg V.1 Game Pad,a:b1,b:b2,y:b3,x:b0,start:b9,guide:b12,back:b8,leftstick:b10,rightstick:b11,leftshoulder:b4,rightshoulder:b5,dpup:h0.1,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,leftx:a0,lefty:a1,rightx:a2,righty:a4,lefttrigger:b6,righttrigger:b7,platform:Linux,",
+"03000000a30600000c04000011010000,Saitek P2900 Wireless Pad,a:b1,b:b2,y:b3,x:b0,start:b12,guide:b9,back:b8,leftstick:b10,rightstick:b11,leftshoulder:b6,rightshoulder:b7,dpup:h0.1,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,leftx:a0,lefty:a1,rightx:a3,righty:a2,lefttrigger:b4,righttrigger:b5,platform:Linux,",
+"03000000a30600000901000000010000,Saitek P880,a:b2,b:b3,y:b1,x:b0,leftstick:b8,rightstick:b9,leftshoulder:b4,rightshoulder:b5,dpup:h0.1,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,leftx:a0,lefty:a1,rightx:a3,righty:a2,lefttrigger:b6,righttrigger:b7,platform:Linux,",
+"03000000a306000018f5000010010000,Saitek PLC Saitek P3200 Rumble Pad,platform:Linux,x:b0,a:b1,b:b2,y:b3,back:b8,start:b9,dpleft:h0.8,dpdown:h0.0,dpdown:h0.4,dpright:h0.0,dpright:h0.2,dpup:h0.0,dpup:h0.1,leftshoulder:h0.0,leftshoulder:b4,lefttrigger:a2,rightshoulder:b6,rightshoulder:b5,righttrigger:b7,leftstick:b10,rightstick:b11,leftx:a0,lefty:a1,rightx:a3,righty:a4,",
+"03000000c01600008704000011010000,Serial/Keyboard/Mouse/Joystick,platform:Linux,a:b12,b:b10,x:b13,y:b11,back:b4,start:b5,leftstick:b14,rightstick:b15,leftshoulder:b9,rightshoulder:b8,dpup:b0,dpdown:b2,dpleft:b3,dpright:b1,leftx:a1,lefty:a0,rightx:a2,righty:a3,lefttrigger:b6,righttrigger:b7,",
+"030000004c050000c405000011810000,Sony DualShock 4,a:b0,b:b1,y:b2,x:b3,start:b9,guide:b10,back:b8,leftstick:b11,rightstick:b12,leftshoulder:b4,rightshoulder:b5,dpup:h0.1,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,leftx:a0,lefty:a1,rightx:a3,righty:a4,lefttrigger:a2,righttrigger:a5,platform:Linux,",
+"030000004c050000c405000011010000,Sony DualShock 4,a:b1,b:b2,y:b3,x:b0,start:b9,guide:b12,back:b8,leftstick:b10,rightstick:b11,leftshoulder:b4,rightshoulder:b5,dpup:h0.1,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,leftx:a0,lefty:a1,rightx:a2,righty:a5,lefttrigger:b6,righttrigger:b7,platform:Linux,",
+"050000004c050000cc09000000810000,Sony DualShock 4 (CUH-ZCT2U) (Bluetooth),platform:Linux,a:b0,b:b1,y:b2,x:b3,leftshoulder:b4,rightshoulder:b5,back:b8,start:b9,guide:b10,leftstick:b11,rightstick:b12,leftx:a0,lefty:a1,lefttrigger:a2,rightx:a3,righty:a4,righttrigger:a5,dpup:h0.1,dpright:h0.2,dpdown:h0.4,dpleft:h0.8,",
+"030000004c050000cc09000011810000,Sony DualShock 4 (CUH-ZCT2U) (USB),platform:Linux,a:b0,b:b1,y:b2,x:b3,leftshoulder:b4,rightshoulder:b5,back:b8,start:b9,guide:b10,leftstick:b11,rightstick:b12,leftx:a0,lefty:a1,lefttrigger:a2,rightx:a3,righty:a4,righttrigger:a5,dpup:h0.1,dpright:h0.2,dpdown:h0.4,dpleft:h0.8,",
+"050000004c050000c405000000010000,Sony DualShock 4 BT,a:b1,b:b2,back:b13,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Linux,",
+"030000004c050000cc09000011010000,Sony DualShock 4 V2,a:b1,b:b2,y:b3,x:b0,start:b9,guide:b12,back:b13,leftstick:b10,rightstick:b11,leftshoulder:b4,rightshoulder:b5,dpup:h0.1,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,leftx:a0,lefty:a1,rightx:a2,righty:a5,lefttrigger:a3,righttrigger:a4,platform:Linux,",
+"050000004c050000cc09000000010000,Sony DualShock 4 V2 BT,a:b1,b:b2,y:b3,x:b0,start:b9,guide:b12,back:b13,leftstick:b10,rightstick:b11,leftshoulder:b4,rightshoulder:b5,dpup:h0.1,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,leftx:a0,lefty:a1,rightx:a2,righty:a5,lefttrigger:a3,righttrigger:a4,platform:Linux,",
+"030000004c050000a00b000011010000,Sony DualShock 4 Wireless Adaptor,a:b1,b:b2,y:b3,x:b0,start:b9,guide:b12,back:b13,leftstick:b10,rightstick:b11,leftshoulder:b4,rightshoulder:b5,dpup:h0.1,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,leftx:a0,lefty:a1,rightx:a2,righty:a5,lefttrigger:a3,righttrigger:a4,platform:Linux,",
+"03000000250900000500000000010000,Sony PS2 pad with SmartJoy adapter,platform:Linux,a:b2,b:b1,y:b0,x:b3,start:b8,back:b9,leftstick:b10,rightstick:b11,leftshoulder:b6,rightshoulder:b7,dpup:h0.1,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,leftx:a0,lefty:a1,rightx:a2,righty:a3,lefttrigger:b4,righttrigger:b5,",
+"030000005e0400008e02000073050000,Speedlink TORID Wireless Gamepad,platform:Linux,x:b2,a:b0,b:b1,y:b3,back:b6,guide:b8,start:b7,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:a2,rightshoulder:b5,righttrigger:a5,leftstick:b9,rightstick:b10,leftx:a0,lefty:a1,rightx:a3,righty:a4,",
+"030000005e0400008e02000020200000,SpeedLink XEOX Pro Analog Gamepad pad,platform:Linux,x:b2,a:b0,b:b1,y:b3,back:b6,guide:b8,start:b7,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:a2,rightshoulder:b5,righttrigger:a5,leftstick:b9,rightstick:b10,leftx:a0,lefty:a1,rightx:a3,righty:a4,",
+"03000000666600000488000000010000,Super Joy Box 5 Pro,platform:Linux,a:b2,b:b1,x:b3,y:b0,back:b9,start:b8,leftshoulder:b6,rightshoulder:b7,leftstick:b10,rightstick:b11,leftx:a0,lefty:a1,rightx:a2,righty:a3,lefttrigger:b4,righttrigger:b5,dpup:b12,dpleft:b15,dpdown:b14,dpright:b13,",
+"030000004f04000020b3000010010000,Thrustmaster 2 in 1 DT,a:b0,b:b2,y:b3,x:b1,start:b9,guide:,back:b8,leftstick:b10,rightstick:b11,leftshoulder:b4,rightshoulder:b6,dpup:h0.1,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,leftx:a0,lefty:a1,rightx:a2,righty:a3,lefttrigger:b5,righttrigger:b7,platform:Linux,",
+"030000004f04000015b3000010010000,Thrustmaster Dual Analog 4,platform:Linux,a:b0,b:b2,x:b1,y:b3,start:b9,back:b8,leftstick:b10,rightstick:b11,leftshoulder:b4,rightshoulder:b6,dpup:h0.1,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,leftx:a0,lefty:a1,rightx:a2,righty:a3,lefttrigger:b5,righttrigger:b7,",
+"030000004f04000023b3000000010000,Thrustmaster Dual Trigger 3-in-1,platform:Linux,x:b0,a:b1,b:b2,y:b3,back:b8,start:b9,dpleft:h0.8,dpdown:h0.0,dpdown:h0.4,dpright:h0.0,dpright:h0.2,dpup:h0.0,dpup:h0.1,leftshoulder:h0.0,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,leftstick:b10,rightstick:b11,leftx:a0,lefty:a1,rightx:a2,righty:a5,",
+"030000004f04000000b3000010010000,Thrustmaster Firestorm Dual Power,a:b0,b:b2,y:b3,x:b1,start:b10,guide:b8,back:b9,leftstick:b11,rightstick:b12,leftshoulder:b4,rightshoulder:b6,dpup:h0.1,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,leftx:a0,lefty:a1,rightx:a2,righty:a3,lefttrigger:b5,righttrigger:b7,platform:Linux,",
+"030000004f04000008d0000000010000,Thrustmaster Run N Drive  Wireless,platform:Linux,a:b1,b:b2,x:b0,y:b3,start:b9,back:b8,leftstick:b10,rightstick:b11,leftshoulder:b4,rightshoulder:b5,dpup:h0.1,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,leftx:a0,lefty:a1,rightx:a2,righty:a5,lefttrigger:b6,righttrigger:b7,",
+"030000004f04000009d0000000010000,Thrustmaster Run N Drive Wireless PS3,platform:Linux,a:b1,b:b2,x:b0,y:b3,start:b9,guide:b12,back:b8,leftstick:b10,rightstick:b11,leftshoulder:b4,rightshoulder:b5,dpup:h0.1,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,leftx:a0,lefty:a1,rightx:a2,righty:a3,lefttrigger:b6,righttrigger:b7,",
+"03000000bd12000015d0000010010000,Tomee SNES USB Controller,x:b3,a:b2,b:b1,y:b0,back:b8,start:b9,leftshoulder:b4,rightshoulder:b5,leftx:a0,lefty:a1,platform:Linux,",
+"03000000d814000007cd000011010000,Toodles 2008 Chimp PC/PS3,platform:Linux,a:b0,b:b1,y:b2,x:b3,start:b9,back:b8,leftshoulder:b4,rightshoulder:b5,leftx:a0,lefty:a1,lefttrigger:b6,righttrigger:b7,",
+"03000000100800000100000010010000,Twin USB PS2 Adapter,a:b2,b:b1,y:b0,x:b3,start:b9,guide:,back:b8,leftstick:b10,rightstick:b11,leftshoulder:b6,rightshoulder:b7,dpup:h0.1,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,leftx:a0,lefty:a1,rightx:a3,righty:a2,lefttrigger:b4,righttrigger:b5,platform:Linux,",
+"03000000100800000300000010010000,USB Gamepad,platform:Linux,a:b2,b:b1,x:b3,y:b0,start:b9,back:b8,leftstick:b10,rightstick:b11,leftshoulder:b6,rightshoulder:b7,dpup:h0.1,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,leftx:a0,lefty:a1,rightx:a3,righty:a2,lefttrigger:b4,righttrigger:b5,",
+"03000000de280000ff11000001000000,Valve Streaming Gamepad,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"05000000ac0500003232000001000000,VR-BOX,platform:Linux,a:b0,b:b1,x:b2,y:b3,start:b9,back:b8,leftstick:b10,rightstick:b11,leftshoulder:b6,rightshoulder:b7,dpup:h0.1,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,leftx:a0,lefty:a1,rightx:a3,righty:a2,lefttrigger:b4,righttrigger:b5,",
+"030000005e0400008e02000014010000,X360 Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"030000005e0400008e02000010010000,X360 Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"030000005e0400001907000000010000,X360 Wireless Controller,a:b0,b:b1,back:b6,dpdown:b14,dpleft:b11,dpright:b12,dpup:b13,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"030000005e0400009102000007010000,X360 Wireless Controller,a:b0,b:b1,y:b3,x:b2,start:b7,guide:b8,back:b6,leftstick:b9,rightstick:b10,leftshoulder:b4,rightshoulder:b5,dpup:b13,dpleft:b11,dpdown:b14,dpright:b12,leftx:a0,lefty:a1,rightx:a3,righty:a4,lefttrigger:a2,righttrigger:a5,platform:Linux,",
+"030000005e040000a102000000010000,X360 Wireless Controller,platform:Linux,a:b0,b:b1,back:b6,dpdown:b14,dpleft:b11,dpright:b12,dpup:b13,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,",
+"0000000058626f782047616d65706100,Xbox Gamepad (userspace driver),platform:Linux,a:b0,b:b1,x:b2,y:b3,start:b7,back:b6,guide:b8,dpup:h0.1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,leftshoulder:b4,rightshoulder:b5,lefttrigger:a5,righttrigger:a4,leftstick:b9,rightstick:b10,leftx:a0,lefty:a1,rightx:a2,righty:a3,",
+"050000005e040000e002000003090000,Xbox One Wireless Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:b4,leftstick:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"03000000c0160000e105000001010000,Xin-Mo Xin-Mo Dual Arcade,platform:Linux,y:b0,x:b1,b:b3,a:b4,leftshoulder:b2,rightshoulder:b5,back:b6,start:b7,guide:b9,dpleft:b13,dpdown:b12,dpright:b14,dpup:b11,leftx:a0,lefty:a1,",
+
+"78696e70757401000000000000000000,XInput Gamepad (GLFW),platform:Windows,a:b0,b:b1,x:b2,y:b3,leftshoulder:b4,rightshoulder:b5,back:b6,start:b7,leftstick:b8,rightstick:b9,leftx:a0,lefty:a1,rightx:a2,righty:a3,lefttrigger:a4,righttrigger:a5,dpup:h0.1,dpright:h0.2,dpdown:h0.4,dpleft:h0.8,",
+"78696e70757402000000000000000000,XInput Wheel (GLFW),platform:Windows,a:b0,b:b1,x:b2,y:b3,leftshoulder:b4,rightshoulder:b5,back:b6,start:b7,leftstick:b8,rightstick:b9,leftx:a0,lefty:a1,rightx:a2,righty:a3,lefttrigger:a4,righttrigger:a5,dpup:h0.1,dpright:h0.2,dpdown:h0.4,dpleft:h0.8,",
+"78696e70757403000000000000000000,XInput Arcade Stick (GLFW),platform:Windows,a:b0,b:b1,x:b2,y:b3,leftshoulder:b4,rightshoulder:b5,back:b6,start:b7,leftstick:b8,rightstick:b9,leftx:a0,lefty:a1,rightx:a2,righty:a3,lefttrigger:a4,righttrigger:a5,dpup:h0.1,dpright:h0.2,dpdown:h0.4,dpleft:h0.8,",
+"78696e70757404000000000000000000,XInput Flight Stick (GLFW),platform:Windows,a:b0,b:b1,x:b2,y:b3,leftshoulder:b4,rightshoulder:b5,back:b6,start:b7,leftstick:b8,rightstick:b9,leftx:a0,lefty:a1,rightx:a2,righty:a3,lefttrigger:a4,righttrigger:a5,dpup:h0.1,dpright:h0.2,dpdown:h0.4,dpleft:h0.8,",
+"78696e70757405000000000000000000,XInput Dance Pad (GLFW),platform:Windows,a:b0,b:b1,x:b2,y:b3,leftshoulder:b4,rightshoulder:b5,back:b6,start:b7,leftstick:b8,rightstick:b9,leftx:a0,lefty:a1,rightx:a2,righty:a3,lefttrigger:a4,righttrigger:a5,dpup:h0.1,dpright:h0.2,dpdown:h0.4,dpleft:h0.8,",
+"78696e70757406000000000000000000,XInput Guitar (GLFW),platform:Windows,a:b0,b:b1,x:b2,y:b3,leftshoulder:b4,rightshoulder:b5,back:b6,start:b7,leftstick:b8,rightstick:b9,leftx:a0,lefty:a1,rightx:a2,righty:a3,lefttrigger:a4,righttrigger:a5,dpup:h0.1,dpright:h0.2,dpdown:h0.4,dpleft:h0.8,",
+"78696e70757408000000000000000000,XInput Drum Kit (GLFW),platform:Windows,a:b0,b:b1,x:b2,y:b3,leftshoulder:b4,rightshoulder:b5,back:b6,start:b7,leftstick:b8,rightstick:b9,leftx:a0,lefty:a1,rightx:a2,righty:a3,lefttrigger:a4,righttrigger:a5,dpup:h0.1,dpright:h0.2,dpdown:h0.4,dpleft:h0.8,",
+NULL
+};
+

raylib/external/glfw/src/mir_init.c

@@ -1,7 +1,7 @@
 //========================================================================
-// GLFW 3.2 Mir - www.glfw.org
+// GLFW 3.3 Mir - www.glfw.org
 //------------------------------------------------------------------------
-// Copyright (c) 2014-2015 Brandon Schaefer <brandon.schaefer@canonical.com>
+// Copyright (c) 2014-2017 Brandon Schaefer <brandon.schaefer@canonical.com>
 //
 // This software is provided 'as-is', without any express or implied
 // warranty. In no event will the authors be held liable for any damages
@@ -35,124 +35,134 @@
 //
 static void createKeyTables(void)
 {
-    memset(_glfw.mir.publicKeys, -1, sizeof(_glfw.mir.publicKeys));
+    int scancode;
 
-    _glfw.mir.publicKeys[KEY_GRAVE]      = GLFW_KEY_GRAVE_ACCENT;
+    memset(_glfw.mir.keycodes, -1, sizeof(_glfw.mir.keycodes));
-    _glfw.mir.publicKeys[KEY_1]          = GLFW_KEY_1;
+    memset(_glfw.mir.scancodes, -1, sizeof(_glfw.mir.scancodes));
-    _glfw.mir.publicKeys[KEY_2]          = GLFW_KEY_2;
+
-    _glfw.mir.publicKeys[KEY_3]          = GLFW_KEY_3;
+    _glfw.mir.keycodes[KEY_GRAVE]      = GLFW_KEY_GRAVE_ACCENT;
-    _glfw.mir.publicKeys[KEY_4]          = GLFW_KEY_4;
+    _glfw.mir.keycodes[KEY_1]          = GLFW_KEY_1;
-    _glfw.mir.publicKeys[KEY_5]          = GLFW_KEY_5;
+    _glfw.mir.keycodes[KEY_2]          = GLFW_KEY_2;
-    _glfw.mir.publicKeys[KEY_6]          = GLFW_KEY_6;
+    _glfw.mir.keycodes[KEY_3]          = GLFW_KEY_3;
-    _glfw.mir.publicKeys[KEY_7]          = GLFW_KEY_7;
+    _glfw.mir.keycodes[KEY_4]          = GLFW_KEY_4;
-    _glfw.mir.publicKeys[KEY_8]          = GLFW_KEY_8;
+    _glfw.mir.keycodes[KEY_5]          = GLFW_KEY_5;
-    _glfw.mir.publicKeys[KEY_9]          = GLFW_KEY_9;
+    _glfw.mir.keycodes[KEY_6]          = GLFW_KEY_6;
-    _glfw.mir.publicKeys[KEY_0]          = GLFW_KEY_0;
+    _glfw.mir.keycodes[KEY_7]          = GLFW_KEY_7;
-    _glfw.mir.publicKeys[KEY_MINUS]      = GLFW_KEY_MINUS;
+    _glfw.mir.keycodes[KEY_8]          = GLFW_KEY_8;
-    _glfw.mir.publicKeys[KEY_EQUAL]      = GLFW_KEY_EQUAL;
+    _glfw.mir.keycodes[KEY_9]          = GLFW_KEY_9;
-    _glfw.mir.publicKeys[KEY_Q]          = GLFW_KEY_Q;
+    _glfw.mir.keycodes[KEY_0]          = GLFW_KEY_0;
-    _glfw.mir.publicKeys[KEY_W]          = GLFW_KEY_W;
+    _glfw.mir.keycodes[KEY_SPACE]      = GLFW_KEY_SPACE;
-    _glfw.mir.publicKeys[KEY_E]          = GLFW_KEY_E;
+    _glfw.mir.keycodes[KEY_MINUS]      = GLFW_KEY_MINUS;
-    _glfw.mir.publicKeys[KEY_R]          = GLFW_KEY_R;
+    _glfw.mir.keycodes[KEY_EQUAL]      = GLFW_KEY_EQUAL;
-    _glfw.mir.publicKeys[KEY_T]          = GLFW_KEY_T;
+    _glfw.mir.keycodes[KEY_Q]          = GLFW_KEY_Q;
-    _glfw.mir.publicKeys[KEY_Y]          = GLFW_KEY_Y;
+    _glfw.mir.keycodes[KEY_W]          = GLFW_KEY_W;
-    _glfw.mir.publicKeys[KEY_U]          = GLFW_KEY_U;
+    _glfw.mir.keycodes[KEY_E]          = GLFW_KEY_E;
-    _glfw.mir.publicKeys[KEY_I]          = GLFW_KEY_I;
+    _glfw.mir.keycodes[KEY_R]          = GLFW_KEY_R;
-    _glfw.mir.publicKeys[KEY_O]          = GLFW_KEY_O;
+    _glfw.mir.keycodes[KEY_T]          = GLFW_KEY_T;
-    _glfw.mir.publicKeys[KEY_P]          = GLFW_KEY_P;
+    _glfw.mir.keycodes[KEY_Y]          = GLFW_KEY_Y;
-    _glfw.mir.publicKeys[KEY_LEFTBRACE]  = GLFW_KEY_LEFT_BRACKET;
+    _glfw.mir.keycodes[KEY_U]          = GLFW_KEY_U;
-    _glfw.mir.publicKeys[KEY_RIGHTBRACE] = GLFW_KEY_RIGHT_BRACKET;
+    _glfw.mir.keycodes[KEY_I]          = GLFW_KEY_I;
-    _glfw.mir.publicKeys[KEY_A]          = GLFW_KEY_A;
+    _glfw.mir.keycodes[KEY_O]          = GLFW_KEY_O;
-    _glfw.mir.publicKeys[KEY_S]          = GLFW_KEY_S;
+    _glfw.mir.keycodes[KEY_P]          = GLFW_KEY_P;
-    _glfw.mir.publicKeys[KEY_D]          = GLFW_KEY_D;
+    _glfw.mir.keycodes[KEY_LEFTBRACE]  = GLFW_KEY_LEFT_BRACKET;
-    _glfw.mir.publicKeys[KEY_F]          = GLFW_KEY_F;
+    _glfw.mir.keycodes[KEY_RIGHTBRACE] = GLFW_KEY_RIGHT_BRACKET;
-    _glfw.mir.publicKeys[KEY_G]          = GLFW_KEY_G;
+    _glfw.mir.keycodes[KEY_A]          = GLFW_KEY_A;
-    _glfw.mir.publicKeys[KEY_H]          = GLFW_KEY_H;
+    _glfw.mir.keycodes[KEY_S]          = GLFW_KEY_S;
-    _glfw.mir.publicKeys[KEY_J]          = GLFW_KEY_J;
+    _glfw.mir.keycodes[KEY_D]          = GLFW_KEY_D;
-    _glfw.mir.publicKeys[KEY_K]          = GLFW_KEY_K;
+    _glfw.mir.keycodes[KEY_F]          = GLFW_KEY_F;
-    _glfw.mir.publicKeys[KEY_L]          = GLFW_KEY_L;
+    _glfw.mir.keycodes[KEY_G]          = GLFW_KEY_G;
-    _glfw.mir.publicKeys[KEY_SEMICOLON]  = GLFW_KEY_SEMICOLON;
+    _glfw.mir.keycodes[KEY_H]          = GLFW_KEY_H;
-    _glfw.mir.publicKeys[KEY_APOSTROPHE] = GLFW_KEY_APOSTROPHE;
+    _glfw.mir.keycodes[KEY_J]          = GLFW_KEY_J;
-    _glfw.mir.publicKeys[KEY_Z]          = GLFW_KEY_Z;
+    _glfw.mir.keycodes[KEY_K]          = GLFW_KEY_K;
-    _glfw.mir.publicKeys[KEY_X]          = GLFW_KEY_X;
+    _glfw.mir.keycodes[KEY_L]          = GLFW_KEY_L;
-    _glfw.mir.publicKeys[KEY_C]          = GLFW_KEY_C;
+    _glfw.mir.keycodes[KEY_SEMICOLON]  = GLFW_KEY_SEMICOLON;
-    _glfw.mir.publicKeys[KEY_V]          = GLFW_KEY_V;
+    _glfw.mir.keycodes[KEY_APOSTROPHE] = GLFW_KEY_APOSTROPHE;
-    _glfw.mir.publicKeys[KEY_B]          = GLFW_KEY_B;
+    _glfw.mir.keycodes[KEY_Z]          = GLFW_KEY_Z;
-    _glfw.mir.publicKeys[KEY_N]          = GLFW_KEY_N;
+    _glfw.mir.keycodes[KEY_X]          = GLFW_KEY_X;
-    _glfw.mir.publicKeys[KEY_M]          = GLFW_KEY_M;
+    _glfw.mir.keycodes[KEY_C]          = GLFW_KEY_C;
-    _glfw.mir.publicKeys[KEY_COMMA]      = GLFW_KEY_COMMA;
+    _glfw.mir.keycodes[KEY_V]          = GLFW_KEY_V;
-    _glfw.mir.publicKeys[KEY_DOT]        = GLFW_KEY_PERIOD;
+    _glfw.mir.keycodes[KEY_B]          = GLFW_KEY_B;
-    _glfw.mir.publicKeys[KEY_SLASH]      = GLFW_KEY_SLASH;
+    _glfw.mir.keycodes[KEY_N]          = GLFW_KEY_N;
-    _glfw.mir.publicKeys[KEY_BACKSLASH]  = GLFW_KEY_BACKSLASH;
+    _glfw.mir.keycodes[KEY_M]          = GLFW_KEY_M;
-    _glfw.mir.publicKeys[KEY_ESC]        = GLFW_KEY_ESCAPE;
+    _glfw.mir.keycodes[KEY_COMMA]      = GLFW_KEY_COMMA;
-    _glfw.mir.publicKeys[KEY_TAB]        = GLFW_KEY_TAB;
+    _glfw.mir.keycodes[KEY_DOT]        = GLFW_KEY_PERIOD;
-    _glfw.mir.publicKeys[KEY_LEFTSHIFT]  = GLFW_KEY_LEFT_SHIFT;
+    _glfw.mir.keycodes[KEY_SLASH]      = GLFW_KEY_SLASH;
-    _glfw.mir.publicKeys[KEY_RIGHTSHIFT] = GLFW_KEY_RIGHT_SHIFT;
+    _glfw.mir.keycodes[KEY_BACKSLASH]  = GLFW_KEY_BACKSLASH;
-    _glfw.mir.publicKeys[KEY_LEFTCTRL]   = GLFW_KEY_LEFT_CONTROL;
+    _glfw.mir.keycodes[KEY_ESC]        = GLFW_KEY_ESCAPE;
-    _glfw.mir.publicKeys[KEY_RIGHTCTRL]  = GLFW_KEY_RIGHT_CONTROL;
+    _glfw.mir.keycodes[KEY_TAB]        = GLFW_KEY_TAB;
-    _glfw.mir.publicKeys[KEY_LEFTALT]    = GLFW_KEY_LEFT_ALT;
+    _glfw.mir.keycodes[KEY_LEFTSHIFT]  = GLFW_KEY_LEFT_SHIFT;
-    _glfw.mir.publicKeys[KEY_RIGHTALT]   = GLFW_KEY_RIGHT_ALT;
+    _glfw.mir.keycodes[KEY_RIGHTSHIFT] = GLFW_KEY_RIGHT_SHIFT;
-    _glfw.mir.publicKeys[KEY_LEFTMETA]   = GLFW_KEY_LEFT_SUPER;
+    _glfw.mir.keycodes[KEY_LEFTCTRL]   = GLFW_KEY_LEFT_CONTROL;
-    _glfw.mir.publicKeys[KEY_RIGHTMETA]  = GLFW_KEY_RIGHT_SUPER;
+    _glfw.mir.keycodes[KEY_RIGHTCTRL]  = GLFW_KEY_RIGHT_CONTROL;
-    _glfw.mir.publicKeys[KEY_MENU]       = GLFW_KEY_MENU;
+    _glfw.mir.keycodes[KEY_LEFTALT]    = GLFW_KEY_LEFT_ALT;
-    _glfw.mir.publicKeys[KEY_NUMLOCK]    = GLFW_KEY_NUM_LOCK;
+    _glfw.mir.keycodes[KEY_RIGHTALT]   = GLFW_KEY_RIGHT_ALT;
-    _glfw.mir.publicKeys[KEY_CAPSLOCK]   = GLFW_KEY_CAPS_LOCK;
+    _glfw.mir.keycodes[KEY_LEFTMETA]   = GLFW_KEY_LEFT_SUPER;
-    _glfw.mir.publicKeys[KEY_PRINT]      = GLFW_KEY_PRINT_SCREEN;
+    _glfw.mir.keycodes[KEY_RIGHTMETA]  = GLFW_KEY_RIGHT_SUPER;
-    _glfw.mir.publicKeys[KEY_SCROLLLOCK] = GLFW_KEY_SCROLL_LOCK;
+    _glfw.mir.keycodes[KEY_MENU]       = GLFW_KEY_MENU;
-    _glfw.mir.publicKeys[KEY_PAUSE]      = GLFW_KEY_PAUSE;
+    _glfw.mir.keycodes[KEY_NUMLOCK]    = GLFW_KEY_NUM_LOCK;
-    _glfw.mir.publicKeys[KEY_DELETE]     = GLFW_KEY_DELETE;
+    _glfw.mir.keycodes[KEY_CAPSLOCK]   = GLFW_KEY_CAPS_LOCK;
-    _glfw.mir.publicKeys[KEY_BACKSPACE]  = GLFW_KEY_BACKSPACE;
+    _glfw.mir.keycodes[KEY_PRINT]      = GLFW_KEY_PRINT_SCREEN;
-    _glfw.mir.publicKeys[KEY_ENTER]      = GLFW_KEY_ENTER;
+    _glfw.mir.keycodes[KEY_SCROLLLOCK] = GLFW_KEY_SCROLL_LOCK;
-    _glfw.mir.publicKeys[KEY_HOME]       = GLFW_KEY_HOME;
+    _glfw.mir.keycodes[KEY_PAUSE]      = GLFW_KEY_PAUSE;
-    _glfw.mir.publicKeys[KEY_END]        = GLFW_KEY_END;
+    _glfw.mir.keycodes[KEY_DELETE]     = GLFW_KEY_DELETE;
-    _glfw.mir.publicKeys[KEY_PAGEUP]     = GLFW_KEY_PAGE_UP;
+    _glfw.mir.keycodes[KEY_BACKSPACE]  = GLFW_KEY_BACKSPACE;
-    _glfw.mir.publicKeys[KEY_PAGEDOWN]   = GLFW_KEY_PAGE_DOWN;
+    _glfw.mir.keycodes[KEY_ENTER]      = GLFW_KEY_ENTER;
-    _glfw.mir.publicKeys[KEY_INSERT]     = GLFW_KEY_INSERT;
+    _glfw.mir.keycodes[KEY_HOME]       = GLFW_KEY_HOME;
-    _glfw.mir.publicKeys[KEY_LEFT]       = GLFW_KEY_LEFT;
+    _glfw.mir.keycodes[KEY_END]        = GLFW_KEY_END;
-    _glfw.mir.publicKeys[KEY_RIGHT]      = GLFW_KEY_RIGHT;
+    _glfw.mir.keycodes[KEY_PAGEUP]     = GLFW_KEY_PAGE_UP;
-    _glfw.mir.publicKeys[KEY_DOWN]       = GLFW_KEY_DOWN;
+    _glfw.mir.keycodes[KEY_PAGEDOWN]   = GLFW_KEY_PAGE_DOWN;
-    _glfw.mir.publicKeys[KEY_UP]         = GLFW_KEY_UP;
+    _glfw.mir.keycodes[KEY_INSERT]     = GLFW_KEY_INSERT;
-    _glfw.mir.publicKeys[KEY_F1]         = GLFW_KEY_F1;
+    _glfw.mir.keycodes[KEY_LEFT]       = GLFW_KEY_LEFT;
-    _glfw.mir.publicKeys[KEY_F2]         = GLFW_KEY_F2;
+    _glfw.mir.keycodes[KEY_RIGHT]      = GLFW_KEY_RIGHT;
-    _glfw.mir.publicKeys[KEY_F3]         = GLFW_KEY_F3;
+    _glfw.mir.keycodes[KEY_DOWN]       = GLFW_KEY_DOWN;
-    _glfw.mir.publicKeys[KEY_F4]         = GLFW_KEY_F4;
+    _glfw.mir.keycodes[KEY_UP]         = GLFW_KEY_UP;
-    _glfw.mir.publicKeys[KEY_F5]         = GLFW_KEY_F5;
+    _glfw.mir.keycodes[KEY_F1]         = GLFW_KEY_F1;
-    _glfw.mir.publicKeys[KEY_F6]         = GLFW_KEY_F6;
+    _glfw.mir.keycodes[KEY_F2]         = GLFW_KEY_F2;
-    _glfw.mir.publicKeys[KEY_F7]         = GLFW_KEY_F7;
+    _glfw.mir.keycodes[KEY_F3]         = GLFW_KEY_F3;
-    _glfw.mir.publicKeys[KEY_F8]         = GLFW_KEY_F8;
+    _glfw.mir.keycodes[KEY_F4]         = GLFW_KEY_F4;
-    _glfw.mir.publicKeys[KEY_F9]         = GLFW_KEY_F9;
+    _glfw.mir.keycodes[KEY_F5]         = GLFW_KEY_F5;
-    _glfw.mir.publicKeys[KEY_F10]        = GLFW_KEY_F10;
+    _glfw.mir.keycodes[KEY_F6]         = GLFW_KEY_F6;
-    _glfw.mir.publicKeys[KEY_F11]        = GLFW_KEY_F11;
+    _glfw.mir.keycodes[KEY_F7]         = GLFW_KEY_F7;
-    _glfw.mir.publicKeys[KEY_F12]        = GLFW_KEY_F12;
+    _glfw.mir.keycodes[KEY_F8]         = GLFW_KEY_F8;
-    _glfw.mir.publicKeys[KEY_F13]        = GLFW_KEY_F13;
+    _glfw.mir.keycodes[KEY_F9]         = GLFW_KEY_F9;
-    _glfw.mir.publicKeys[KEY_F14]        = GLFW_KEY_F14;
+    _glfw.mir.keycodes[KEY_F10]        = GLFW_KEY_F10;
-    _glfw.mir.publicKeys[KEY_F15]        = GLFW_KEY_F15;
+    _glfw.mir.keycodes[KEY_F11]        = GLFW_KEY_F11;
-    _glfw.mir.publicKeys[KEY_F16]        = GLFW_KEY_F16;
+    _glfw.mir.keycodes[KEY_F12]        = GLFW_KEY_F12;
-    _glfw.mir.publicKeys[KEY_F17]        = GLFW_KEY_F17;
+    _glfw.mir.keycodes[KEY_F13]        = GLFW_KEY_F13;
-    _glfw.mir.publicKeys[KEY_F18]        = GLFW_KEY_F18;
+    _glfw.mir.keycodes[KEY_F14]        = GLFW_KEY_F14;
-    _glfw.mir.publicKeys[KEY_F19]        = GLFW_KEY_F19;
+    _glfw.mir.keycodes[KEY_F15]        = GLFW_KEY_F15;
-    _glfw.mir.publicKeys[KEY_F20]        = GLFW_KEY_F20;
+    _glfw.mir.keycodes[KEY_F16]        = GLFW_KEY_F16;
-    _glfw.mir.publicKeys[KEY_F21]        = GLFW_KEY_F21;
+    _glfw.mir.keycodes[KEY_F17]        = GLFW_KEY_F17;
-    _glfw.mir.publicKeys[KEY_F22]        = GLFW_KEY_F22;
+    _glfw.mir.keycodes[KEY_F18]        = GLFW_KEY_F18;
-    _glfw.mir.publicKeys[KEY_F23]        = GLFW_KEY_F23;
+    _glfw.mir.keycodes[KEY_F19]        = GLFW_KEY_F19;
-    _glfw.mir.publicKeys[KEY_F24]        = GLFW_KEY_F24;
+    _glfw.mir.keycodes[KEY_F20]        = GLFW_KEY_F20;
-    _glfw.mir.publicKeys[KEY_KPSLASH]    = GLFW_KEY_KP_DIVIDE;
+    _glfw.mir.keycodes[KEY_F21]        = GLFW_KEY_F21;
-    _glfw.mir.publicKeys[KEY_KPDOT]      = GLFW_KEY_KP_MULTIPLY;
+    _glfw.mir.keycodes[KEY_F22]        = GLFW_KEY_F22;
-    _glfw.mir.publicKeys[KEY_KPMINUS]    = GLFW_KEY_KP_SUBTRACT;
+    _glfw.mir.keycodes[KEY_F23]        = GLFW_KEY_F23;
-    _glfw.mir.publicKeys[KEY_KPPLUS]     = GLFW_KEY_KP_ADD;
+    _glfw.mir.keycodes[KEY_F24]        = GLFW_KEY_F24;
-    _glfw.mir.publicKeys[KEY_KP0]        = GLFW_KEY_KP_0;
+    _glfw.mir.keycodes[KEY_KPSLASH]    = GLFW_KEY_KP_DIVIDE;
-    _glfw.mir.publicKeys[KEY_KP1]        = GLFW_KEY_KP_1;
+    _glfw.mir.keycodes[KEY_KPDOT]      = GLFW_KEY_KP_MULTIPLY;
-    _glfw.mir.publicKeys[KEY_KP2]        = GLFW_KEY_KP_2;
+    _glfw.mir.keycodes[KEY_KPMINUS]    = GLFW_KEY_KP_SUBTRACT;
-    _glfw.mir.publicKeys[KEY_KP3]        = GLFW_KEY_KP_3;
+    _glfw.mir.keycodes[KEY_KPPLUS]     = GLFW_KEY_KP_ADD;
-    _glfw.mir.publicKeys[KEY_KP4]        = GLFW_KEY_KP_4;
+    _glfw.mir.keycodes[KEY_KP0]        = GLFW_KEY_KP_0;
-    _glfw.mir.publicKeys[KEY_KP5]        = GLFW_KEY_KP_5;
+    _glfw.mir.keycodes[KEY_KP1]        = GLFW_KEY_KP_1;
-    _glfw.mir.publicKeys[KEY_KP6]        = GLFW_KEY_KP_6;
+    _glfw.mir.keycodes[KEY_KP2]        = GLFW_KEY_KP_2;
-    _glfw.mir.publicKeys[KEY_KP7]        = GLFW_KEY_KP_7;
+    _glfw.mir.keycodes[KEY_KP3]        = GLFW_KEY_KP_3;
-    _glfw.mir.publicKeys[KEY_KP8]        = GLFW_KEY_KP_8;
+    _glfw.mir.keycodes[KEY_KP4]        = GLFW_KEY_KP_4;
-    _glfw.mir.publicKeys[KEY_KP9]        = GLFW_KEY_KP_9;
+    _glfw.mir.keycodes[KEY_KP5]        = GLFW_KEY_KP_5;
-    _glfw.mir.publicKeys[KEY_KPCOMMA]    = GLFW_KEY_KP_DECIMAL;
+    _glfw.mir.keycodes[KEY_KP6]        = GLFW_KEY_KP_6;
-    _glfw.mir.publicKeys[KEY_KPEQUAL]    = GLFW_KEY_KP_EQUAL;
+    _glfw.mir.keycodes[KEY_KP7]        = GLFW_KEY_KP_7;
-    _glfw.mir.publicKeys[KEY_KPENTER]    = GLFW_KEY_KP_ENTER;
+    _glfw.mir.keycodes[KEY_KP8]        = GLFW_KEY_KP_8;
+    _glfw.mir.keycodes[KEY_KP9]        = GLFW_KEY_KP_9;
+    _glfw.mir.keycodes[KEY_KPCOMMA]    = GLFW_KEY_KP_DECIMAL;
+    _glfw.mir.keycodes[KEY_KPEQUAL]    = GLFW_KEY_KP_EQUAL;
+    _glfw.mir.keycodes[KEY_KPENTER]    = GLFW_KEY_KP_ENTER;
+
+    for (scancode = 0;  scancode < 256;  scancode++)
+    {
+        if (_glfw.mir.keycodes[scancode] > 0)
+            _glfw.mir.scancodes[_glfw.mir.keycodes[scancode]] = scancode;
+    }
 }
 
 
@@ -180,21 +190,15 @@ int _glfwPlatformInit(void)
 
     createKeyTables();
 
-    if (!_glfwInitThreadLocalStoragePOSIX())
-        return GLFW_FALSE;
-
     if (!_glfwInitJoysticksLinux())
         return GLFW_FALSE;
 
     _glfwInitTimerPOSIX();
 
-    // Need the default conf for when we set a NULL cursor
+    _glfw.mir.eventQueue = calloc(1, sizeof(EventQueue));
-    _glfw.mir.default_conf = mir_cursor_configuration_from_name(mir_arrow_cursor_name);
+    _glfwInitEventQueueMir(_glfw.mir.eventQueue);
 
-    _glfw.mir.event_queue = calloc(1, sizeof(EventQueue));
+    error = pthread_mutex_init(&_glfw.mir.eventMutex, NULL);
-    _glfwInitEventQueueMir(_glfw.mir.event_queue);
-
-    error = pthread_mutex_init(&_glfw.mir.event_mutex, NULL);
     if (error)
     {
         _glfwInputError(GLFW_PLATFORM_ERROR,
@@ -203,6 +207,7 @@ int _glfwPlatformInit(void)
         return GLFW_FALSE;
     }
 
+    _glfwPollMonitorsMir();
     return GLFW_TRUE;
 }
 
@@ -210,11 +215,10 @@ void _glfwPlatformTerminate(void)
 {
     _glfwTerminateEGL();
     _glfwTerminateJoysticksLinux();
-    _glfwTerminateThreadLocalStoragePOSIX();
 
-    _glfwDeleteEventQueueMir(_glfw.mir.event_queue);
+    _glfwDeleteEventQueueMir(_glfw.mir.eventQueue);
 
-    pthread_mutex_destroy(&_glfw.mir.event_mutex);
+    pthread_mutex_destroy(&_glfw.mir.eventMutex);
 
     mir_connection_release(_glfw.mir.connection);
 }
@@ -227,9 +231,7 @@ const char* _glfwPlatformGetVersionString(void)
 #else
         " gettimeofday"
 #endif
-#if defined(__linux__)
+        " evdev"
-        " /dev/js"
-#endif
 #if defined(_GLFW_BUILD_DLL)
         " shared"
 #endif

raylib/external/glfw/src/mir_monitor.c

@@ -1,7 +1,7 @@
 //========================================================================
-// GLFW 3.2 Mir - www.glfw.org
+// GLFW 3.3 Mir - www.glfw.org
 //------------------------------------------------------------------------
-// Copyright (c) 2014-2015 Brandon Schaefer <brandon.schaefer@canonical.com>
+// Copyright (c) 2014-2017 Brandon Schaefer <brandon.schaefer@canonical.com>
 //
 // This software is provided 'as-is', without any express or implied
 // warranty. In no event will the authors be held liable for any damages
@@ -30,53 +30,55 @@
 
 
 //////////////////////////////////////////////////////////////////////////
-//////                       GLFW platform API                      //////
+//////                       GLFW internal API                      //////
 //////////////////////////////////////////////////////////////////////////
 
-_GLFWmonitor** _glfwPlatformGetMonitors(int* count)
+// Poll for changes in the set of connected monitors
+//
+void _glfwPollMonitorsMir(void)
 {
-    int i, found = 0;
+    int i;
-    _GLFWmonitor** monitors = NULL;
+    MirDisplayConfig* displayConfig =
-    MirDisplayConfiguration* displayConfig =
+        mir_connection_create_display_configuration(_glfw.mir.connection);
-        mir_connection_create_display_config(_glfw.mir.connection);
 
-    *count = 0;
+    int numOutputs = mir_display_config_get_num_outputs(displayConfig);
 
-    for (i = 0;  i < displayConfig->num_outputs;  i++)
+    for (i = 0;  i < numOutputs;  i++)
     {
-        const MirDisplayOutput* out = displayConfig->outputs + i;
+        const MirOutput* output        = mir_display_config_get_output(displayConfig, i);
+        MirOutputConnectionState state = mir_output_get_connection_state(output);
+        bool enabled = mir_output_is_enabled(output);
 
-        if (out->used &&
+        if (enabled && state == mir_output_connection_state_connected)
-            out->connected &&
-            out->num_modes &&
-            out->current_mode < out->num_modes)
         {
-            found++;
+            int widthMM  = mir_output_get_physical_width_mm(output);
-            monitors        = realloc(monitors, sizeof(_GLFWmonitor*) * found);
+            int heightMM = mir_output_get_physical_height_mm(output);
-            monitors[i]     = _glfwAllocMonitor("Unknown",
+            int x  = mir_output_get_position_x(output);
-                                                out->physical_width_mm,
+            int y  = mir_output_get_position_y(output);
-                                                out->physical_height_mm);
+            int id = mir_output_get_id(output);
+            size_t currentMode = mir_output_get_current_mode_index(output);
+            const char* name   = mir_output_type_name(mir_output_get_type(output));
 
-            monitors[i]->mir.x         = out->position_x;
+            _GLFWmonitor* monitor = _glfwAllocMonitor(name,
-            monitors[i]->mir.y         = out->position_y;
+                                                      widthMM,
-            monitors[i]->mir.output_id = out->output_id;
+                                                      heightMM);
-            monitors[i]->mir.cur_mode  = out->current_mode;
+            monitor->mir.x        = x;
+            monitor->mir.y        = y;
+            monitor->mir.outputId = id;
+            monitor->mir.curMode  = currentMode;
+            monitor->modes = _glfwPlatformGetVideoModes(monitor, &monitor->modeCount);
 
-            monitors[i]->modes = _glfwPlatformGetVideoModes(monitors[i],
+            _glfwInputMonitor(monitor, GLFW_CONNECTED, _GLFW_INSERT_LAST);
-                                                            &monitors[i]->modeCount);
         }
     }
 
-    mir_display_config_destroy(displayConfig);
+    mir_display_config_release(displayConfig);
-
-    *count = found;
-    return monitors;
 }
 
-GLFWbool _glfwPlatformIsSameMonitor(_GLFWmonitor* first, _GLFWmonitor* second)
+
-{
+//////////////////////////////////////////////////////////////////////////
-    return first->mir.output_id == second->mir.output_id;
+//////                       GLFW platform API                      //////
-}
+//////////////////////////////////////////////////////////////////////////
 
 void _glfwPlatformGetMonitorPos(_GLFWmonitor* monitor, int* xpos, int* ypos)
 {
@@ -86,7 +88,16 @@ void _glfwPlatformGetMonitorPos(_GLFWmonitor* monitor, int* xpos, int* ypos)
         *ypos = monitor->mir.y;
 }
 
-void FillInRGBBitsFromPixelFormat(GLFWvidmode* mode, const MirPixelFormat pf)
+void _glfwPlatformGetMonitorContentScale(_GLFWmonitor* monitor,
+                                         float* xscale, float* yscale)
+{
+    if (xscale)
+        *xscale = 1.f;
+    if (yscale)
+        *yscale = 1.f;
+}
+
+static void FillInRGBBitsFromPixelFormat(GLFWvidmode* mode, const MirPixelFormat pf)
 {
     switch (pf)
     {
@@ -123,37 +134,59 @@ GLFWvidmode* _glfwPlatformGetVideoModes(_GLFWmonitor* monitor, int* found)
 {
     int i;
     GLFWvidmode* modes = NULL;
-    MirDisplayConfiguration* displayConfig =
+    MirDisplayConfig* displayConfig =
-        mir_connection_create_display_config(_glfw.mir.connection);
+        mir_connection_create_display_configuration(_glfw.mir.connection);
 
-    for (i = 0;  i < displayConfig->num_outputs;  i++)
+    int numOutputs = mir_display_config_get_num_outputs(displayConfig);
+
+    for (i = 0;  i < numOutputs;  i++)
     {
-        const MirDisplayOutput* out = displayConfig->outputs + i;
+        const MirOutput* output = mir_display_config_get_output(displayConfig, i);
-        if (out->output_id != monitor->mir.output_id)
+        int id = mir_output_get_id(output);
+
+        if (id != monitor->mir.outputId)
             continue;
 
-        modes = calloc(out->num_modes, sizeof(GLFWvidmode));
+        MirOutputConnectionState state = mir_output_get_connection_state(output);
+        bool enabled = mir_output_is_enabled(output);
 
-        for (*found = 0;  *found < out->num_modes;  (*found)++)
+        // We must have been disconnected
+        if (!enabled || state != mir_output_connection_state_connected)
         {
-            modes[*found].width  = out->modes[*found].horizontal_resolution;
+            _glfwInputError(GLFW_PLATFORM_ERROR,
-            modes[*found].height = out->modes[*found].vertical_resolution;
+                            "Mir: Monitor no longer connected");
-            modes[*found].refreshRate = out->modes[*found].refresh_rate;
+            return NULL;
+        }
 
-            FillInRGBBitsFromPixelFormat(&modes[*found], out->output_formats[*found]);
+        int numModes = mir_output_get_num_modes(output);
+        modes = calloc(numModes, sizeof(GLFWvidmode));
+
+        for (*found = 0;  *found < numModes;  (*found)++)
+        {
+            const MirOutputMode* mode = mir_output_get_mode(output, *found);
+            int width  = mir_output_mode_get_width(mode);
+            int height = mir_output_mode_get_height(mode);
+            double refreshRate = mir_output_mode_get_refresh_rate(mode);
+            MirPixelFormat currentFormat = mir_output_get_current_pixel_format(output);
+
+            modes[*found].width  = width;
+            modes[*found].height = height;
+            modes[*found].refreshRate = refreshRate;
+
+            FillInRGBBitsFromPixelFormat(&modes[*found], currentFormat);
         }
 
         break;
     }
 
-    mir_display_config_destroy(displayConfig);
+    mir_display_config_release(displayConfig);
 
     return modes;
 }
 
 void _glfwPlatformGetVideoMode(_GLFWmonitor* monitor, GLFWvidmode* mode)
 {
-    *mode = monitor->modes[monitor->mir.cur_mode];
+    *mode = monitor->modes[monitor->mir.curMode];
 }
 
 void _glfwPlatformGetGammaRamp(_GLFWmonitor* monitor, GLFWgammaramp* ramp)
@@ -177,6 +210,5 @@ GLFWAPI int glfwGetMirMonitor(GLFWmonitor* handle)
 {
     _GLFWmonitor* monitor = (_GLFWmonitor*) handle;
     _GLFW_REQUIRE_INIT_OR_RETURN(0);
-    return monitor->mir.output_id;
+    return monitor->mir.outputId;
 }
-

raylib/external/glfw/src/mir_platform.h

@@ -1,7 +1,7 @@
 //========================================================================
-// GLFW 3.2 Mir - www.glfw.org
+// GLFW 3.3 Mir - www.glfw.org
 //------------------------------------------------------------------------
-// Copyright (c) 2014-2015 Brandon Schaefer <brandon.schaefer@canonical.com>
+// Copyright (c) 2014-2017 Brandon Schaefer <brandon.schaefer@canonical.com>
 //
 // This software is provided 'as-is', without any express or implied
 // warranty. In no event will the authors be held liable for any damages
@@ -24,40 +24,38 @@
 //
 //========================================================================
 
-#ifndef _glfw3_mir_platform_h_
-#define _glfw3_mir_platform_h_
-
 #include <sys/queue.h>
 #include <pthread.h>
 #include <dlfcn.h>
 
 #include <mir_toolkit/mir_client_library.h>
 
-typedef VkFlags VkMirSurfaceCreateFlagsKHR;
+typedef VkFlags VkMirWindowCreateFlagsKHR;
 
-typedef struct VkMirSurfaceCreateInfoKHR
+typedef struct VkMirWindowCreateInfoKHR
 {
     VkStructureType             sType;
     const void*                 pNext;
-    VkMirSurfaceCreateFlagsKHR  flags;
+    VkMirWindowCreateFlagsKHR   flags;
     MirConnection*              connection;
-    MirSurface*                 mirSurface;
+    MirWindow*                  mirWindow;
-} VkMirSurfaceCreateInfoKHR;
+} VkMirWindowCreateInfoKHR;
 
-typedef VkResult (APIENTRY *PFN_vkCreateMirSurfaceKHR)(VkInstance,const VkMirSurfaceCreateInfoKHR*,const VkAllocationCallbacks*,VkSurfaceKHR*);
+typedef VkResult (APIENTRY *PFN_vkCreateMirWindowKHR)(VkInstance,const VkMirWindowCreateInfoKHR*,const VkAllocationCallbacks*,VkSurfaceKHR*);
 typedef VkBool32 (APIENTRY *PFN_vkGetPhysicalDeviceMirPresentationSupportKHR)(VkPhysicalDevice,uint32_t,MirConnection*);
 
-#include "posix_tls.h"
+#include "posix_thread.h"
 #include "posix_time.h"
 #include "linux_joystick.h"
 #include "xkb_unicode.h"
 #include "egl_context.h"
+#include "osmesa_context.h"
 
 #define _glfw_dlopen(name) dlopen(name, RTLD_LAZY | RTLD_LOCAL)
 #define _glfw_dlclose(handle) dlclose(handle)
 #define _glfw_dlsym(handle, name) dlsym(handle, name)
 
-#define _GLFW_EGL_NATIVE_WINDOW  ((EGLNativeWindowType) window->mir.window)
+#define _GLFW_EGL_NATIVE_WINDOW  ((EGLNativeWindowType) window->mir.nativeWindow)
 #define _GLFW_EGL_NATIVE_DISPLAY ((EGLNativeDisplayType) _glfw.mir.display)
 
 #define _GLFW_PLATFORM_WINDOW_STATE         _GLFWwindowMir  mir
@@ -80,10 +78,11 @@ typedef struct EventQueue
 //
 typedef struct _GLFWwindowMir
 {
-    MirSurface*             surface;
+    MirWindow*              window;
     int                     width;
     int                     height;
-    MirEGLNativeWindowType  window;
+    MirEGLNativeWindowType  nativeWindow;
+    _GLFWcursor*            currentCursor;
 
 } _GLFWwindowMir;
 
@@ -91,8 +90,8 @@ typedef struct _GLFWwindowMir
 //
 typedef struct _GLFWmonitorMir
 {
-    int cur_mode;
+    int curMode;
-    int output_id;
+    int outputId;
     int x;
     int y;
 
@@ -104,13 +103,16 @@ typedef struct _GLFWlibraryMir
 {
     MirConnection*          connection;
     MirEGLNativeDisplayType display;
-    MirCursorConfiguration* default_conf;
+    EventQueue* eventQueue;
-    EventQueue* event_queue;
 
-    short int       publicKeys[256];
+    short int keycodes[256];
+    short int scancodes[GLFW_KEY_LAST + 1];
 
-    pthread_mutex_t event_mutex;
+    pthread_mutex_t eventMutex;
-    pthread_cond_t  event_cond;
+    pthread_cond_t  eventCond;
+
+    // The window whose disabled cursor mode is active
+    _GLFWwindow* disabledCursorWindow;
 
 } _GLFWlibraryMir;
 
@@ -120,11 +122,12 @@ typedef struct _GLFWlibraryMir
 typedef struct _GLFWcursorMir
 {
     MirCursorConfiguration* conf;
-    MirBufferStream*        custom_cursor;
+    MirBufferStream*        customCursor;
+    char const*             cursorName; // only needed for system cursors
 } _GLFWcursorMir;
 
 
+extern void _glfwPollMonitorsMir(void);
 extern void _glfwInitEventQueueMir(EventQueue* queue);
 extern void _glfwDeleteEventQueueMir(EventQueue* queue);
 
-#endif // _glfw3_mir_platform_h_

raylib/external/glfw/src/mir_window.c

@@ -1,7 +1,7 @@
 //========================================================================
-// GLFW 3.2 Mir - www.glfw.org
+// GLFW 3.3 Mir - www.glfw.org
 //------------------------------------------------------------------------
-// Copyright (c) 2014-2015 Brandon Schaefer <brandon.schaefer@canonical.com>
+// Copyright (c) 2014-2017 Brandon Schaefer <brandon.schaefer@canonical.com>
 //
 // This software is provided 'as-is', without any express or implied
 // warranty. In no event will the authors be held liable for any damages
@@ -54,44 +54,41 @@ static GLFWbool emptyEventQueue(EventQueue* queue)
 //      for single threaded event handling.
 static EventNode* newEventNode(const MirEvent* event, _GLFWwindow* context)
 {
-    EventNode* new_node = calloc(1, sizeof(EventNode));
+    EventNode* newNode = calloc(1, sizeof(EventNode));
-    new_node->event     = mir_event_ref(event);
+    newNode->event     = mir_event_ref(event);
-    new_node->window    = context;
+    newNode->window    = context;
 
-    return new_node;
+    return newNode;
 }
 
 static void enqueueEvent(const MirEvent* event, _GLFWwindow* context)
 {
-    pthread_mutex_lock(&_glfw.mir.event_mutex);
+    pthread_mutex_lock(&_glfw.mir.eventMutex);
 
-    EventNode* new_node = newEventNode(event, context);
+    EventNode* newNode = newEventNode(event, context);
-    TAILQ_INSERT_TAIL(&_glfw.mir.event_queue->head, new_node, entries);
+    TAILQ_INSERT_TAIL(&_glfw.mir.eventQueue->head, newNode, entries);
 
-    pthread_cond_signal(&_glfw.mir.event_cond);
+    pthread_cond_signal(&_glfw.mir.eventCond);
 
-    pthread_mutex_unlock(&_glfw.mir.event_mutex);
+    pthread_mutex_unlock(&_glfw.mir.eventMutex);
 }
 
 static EventNode* dequeueEvent(EventQueue* queue)
 {
     EventNode* node = NULL;
 
-    pthread_mutex_lock(&_glfw.mir.event_mutex);
+    pthread_mutex_lock(&_glfw.mir.eventMutex);
 
     node = queue->head.tqh_first;
 
     if (node)
         TAILQ_REMOVE(&queue->head, node, entries);
 
-    pthread_mutex_unlock(&_glfw.mir.event_mutex);
+    pthread_mutex_unlock(&_glfw.mir.eventMutex);
 
     return node;
 }
 
-/* FIXME Soon to be changed upstream mir! So we can use an egl config to figure out
-         the best pixel format!
-*/
 static MirPixelFormat findValidPixelFormat(void)
 {
     unsigned int i, validFormats, mirPixelFormats = 32;
@@ -132,8 +129,8 @@ static int mirModToGLFWMod(uint32_t mods)
 
 static int toGLFWKeyCode(uint32_t key)
 {
-    if (key < sizeof(_glfw.mir.publicKeys) / sizeof(_glfw.mir.publicKeys[0]))
+    if (key < sizeof(_glfw.mir.keycodes) / sizeof(_glfw.mir.keycodes[0]))
-        return _glfw.mir.publicKeys[key];
+        return _glfw.mir.keycodes[key];
 
     return GLFW_KEY_UNKNOWN;
 }
@@ -201,16 +198,31 @@ static void handlePointerButton(_GLFWwindow* window,
 static void handlePointerMotion(_GLFWwindow* window,
                                 const MirPointerEvent* pointer_event)
 {
-    int current_x = window->virtualCursorPosX;
+    const int hscroll = mir_pointer_event_axis_value(pointer_event, mir_pointer_axis_hscroll);
-    int current_y = window->virtualCursorPosY;
+    const int vscroll = mir_pointer_event_axis_value(pointer_event, mir_pointer_axis_vscroll);
-    int x  = mir_pointer_event_axis_value(pointer_event, mir_pointer_axis_x);
-    int y  = mir_pointer_event_axis_value(pointer_event, mir_pointer_axis_y);
-    int dx = mir_pointer_event_axis_value(pointer_event, mir_pointer_axis_hscroll);
-    int dy = mir_pointer_event_axis_value(pointer_event, mir_pointer_axis_vscroll);
 
-    _glfwInputCursorPos(window, x, y);
+    if (window->cursorMode == GLFW_CURSOR_DISABLED)
-    if (dx != 0 || dy != 0)
+    {
-      _glfwInputScroll(window, dx, dy);
+        if (_glfw.mir.disabledCursorWindow != window)
+            return;
+
+        const int dx = mir_pointer_event_axis_value(pointer_event, mir_pointer_axis_relative_x);
+        const int dy = mir_pointer_event_axis_value(pointer_event, mir_pointer_axis_relative_y);
+        const int current_x = window->virtualCursorPosX;
+        const int current_y = window->virtualCursorPosY;
+
+        _glfwInputCursorPos(window, dx + current_x, dy + current_y);
+    }
+    else
+    {
+        const int x = mir_pointer_event_axis_value(pointer_event, mir_pointer_axis_x);
+        const int y = mir_pointer_event_axis_value(pointer_event, mir_pointer_axis_y);
+
+        _glfwInputCursorPos(window, x, y);
+    }
+
+    if (hscroll != 0 || vscroll != 0)
+      _glfwInputScroll(window, hscroll, vscroll);
 }
 
 static void handlePointerEvent(const MirPointerEvent* pointer_event,
@@ -234,7 +246,6 @@ static void handlePointerEvent(const MirPointerEvent* pointer_event,
               break;
           default:
               break;
-
     }
 }
 
@@ -269,14 +280,14 @@ static void handleEvent(const MirEvent* event, _GLFWwindow* window)
     }
 }
 
-static void addNewEvent(MirSurface* surface, const MirEvent* event, void* context)
+static void addNewEvent(MirWindow* window, const MirEvent* event, void* context)
 {
     enqueueEvent(event, context);
 }
 
-static GLFWbool createSurface(_GLFWwindow* window)
+static GLFWbool createWindow(_GLFWwindow* window)
 {
-    MirSurfaceSpec* spec;
+    MirWindowSpec* spec;
     MirBufferUsage buffer_usage = mir_buffer_usage_hardware;
     MirPixelFormat pixel_format = findValidPixelFormat();
 
@@ -286,32 +297,42 @@ static GLFWbool createSurface(_GLFWwindow* window)
                         "Mir: Unable to find a correct pixel format");
         return GLFW_FALSE;
     }
- 
-    spec = mir_connection_create_spec_for_normal_surface(_glfw.mir.connection,
-                                                         window->mir.width,
-                                                         window->mir.height,
-                                                         pixel_format);
 
-    mir_surface_spec_set_buffer_usage(spec, buffer_usage);
+    spec = mir_create_normal_window_spec(_glfw.mir.connection,
-    mir_surface_spec_set_name(spec, "MirSurface");
+                                         window->mir.width,
+                                         window->mir.height);
 
-    window->mir.surface = mir_surface_create_sync(spec);
+    mir_window_spec_set_pixel_format(spec, pixel_format);
-    mir_surface_spec_release(spec);
+    mir_window_spec_set_buffer_usage(spec, buffer_usage);
 
-    if (!mir_surface_is_valid(window->mir.surface))
+    window->mir.window = mir_create_window_sync(spec);
+    mir_window_spec_release(spec);
+
+    if (!mir_window_is_valid(window->mir.window))
     {
         _glfwInputError(GLFW_PLATFORM_ERROR,
-                        "Mir: Unable to create surface: %s",
+                        "Mir: Unable to create window: %s",
-                        mir_surface_get_error_message(window->mir.surface));
+                        mir_window_get_error_message(window->mir.window));
 
         return GLFW_FALSE;
     }
 
-    mir_surface_set_event_handler(window->mir.surface, addNewEvent, window);
+    mir_window_set_event_handler(window->mir.window, addNewEvent, window);
 
     return GLFW_TRUE;
 }
 
+static void setWindowConfinement(_GLFWwindow* window, MirPointerConfinementState state)
+{
+    MirWindowSpec* spec;
+
+    spec = mir_create_window_spec(_glfw.mir.connection);
+    mir_window_spec_set_pointer_confinement(spec, state);
+
+    mir_window_apply_spec(window->mir.window, spec);
+    mir_window_spec_release(spec);
+}
+
 //////////////////////////////////////////////////////////////////////////
 //////                       GLFW internal API                      //////
 //////////////////////////////////////////////////////////////////////////
@@ -356,12 +377,12 @@ int _glfwPlatformCreateWindow(_GLFWwindow* window,
         GLFWvidmode mode;
         _glfwPlatformGetVideoMode(window->monitor, &mode);
 
-        mir_surface_set_state(window->mir.surface, mir_surface_state_fullscreen);
+        mir_window_set_state(window->mir.window, mir_window_state_fullscreen);
 
         if (wndconfig->width > mode.width || wndconfig->height > mode.height)
         {
             _glfwInputError(GLFW_PLATFORM_ERROR,
-                            "Mir: Requested surface size too large: %ix%i",
+                            "Mir: Requested window size too large: %ix%i",
                             wndconfig->width, wndconfig->height);
 
             return GLFW_FALSE;
@@ -370,19 +391,31 @@ int _glfwPlatformCreateWindow(_GLFWwindow* window,
 
     window->mir.width  = wndconfig->width;
     window->mir.height = wndconfig->height;
+    window->mir.currentCursor = NULL;
 
-    if (!createSurface(window))
+    if (!createWindow(window))
         return GLFW_FALSE;
 
-    window->mir.window = mir_buffer_stream_get_egl_native_window(
+    window->mir.nativeWindow = mir_buffer_stream_get_egl_native_window(
-                                   mir_surface_get_buffer_stream(window->mir.surface));
+        mir_window_get_buffer_stream(window->mir.window));
 
     if (ctxconfig->client != GLFW_NO_API)
     {
-        if (!_glfwInitEGL())
+        if (ctxconfig->source == GLFW_EGL_CONTEXT_API ||
-            return GLFW_FALSE;
+            ctxconfig->source == GLFW_NATIVE_CONTEXT_API)
-        if (!_glfwCreateContextEGL(window, ctxconfig, fbconfig))
+        {
-            return GLFW_FALSE;
+            if (!_glfwInitEGL())
+                return GLFW_FALSE;
+            if (!_glfwCreateContextEGL(window, ctxconfig, fbconfig))
+                return GLFW_FALSE;
+        }
+        else if (ctxconfig->source == GLFW_OSMESA_CONTEXT_API)
+        {
+            if (!_glfwInitOSMesa())
+                return GLFW_FALSE;
+            if (!_glfwCreateContextOSMesa(window, ctxconfig, fbconfig))
+                return GLFW_FALSE;
+        }
     }
 
     return GLFW_TRUE;
@@ -390,10 +423,13 @@ int _glfwPlatformCreateWindow(_GLFWwindow* window,
 
 void _glfwPlatformDestroyWindow(_GLFWwindow* window)
 {
-    if (mir_surface_is_valid(window->mir.surface))
+    if (_glfw.mir.disabledCursorWindow == window)
+        _glfw.mir.disabledCursorWindow = NULL;
+
+    if (mir_window_is_valid(window->mir.window))
     {
-        mir_surface_release_sync(window->mir.surface);
+        mir_window_release_sync(window->mir.window);
-        window->mir.surface = NULL;
+        window->mir.window= NULL;
     }
 
     if (window->context.destroy)
@@ -402,14 +438,12 @@ void _glfwPlatformDestroyWindow(_GLFWwindow* window)
 
 void _glfwPlatformSetWindowTitle(_GLFWwindow* window, const char* title)
 {
-    MirSurfaceSpec* spec;
+    MirWindowSpec* spec;
-    const char* e_title = title ? title : "";
 
-    spec = mir_connection_create_spec_for_changes(_glfw.mir.connection);
+    spec = mir_create_window_spec(_glfw.mir.connection);
-    mir_surface_spec_set_name(spec, e_title);
+    mir_window_spec_set_name(spec, title);
-
+    mir_window_apply_spec(window->mir.window, spec);
-    mir_surface_apply_spec(window->mir.surface, spec);
+    mir_window_spec_release(spec);
-    mir_surface_spec_release(spec);
 }
 
 void _glfwPlatformSetWindowIcon(_GLFWwindow* window,
@@ -421,22 +455,30 @@ void _glfwPlatformSetWindowIcon(_GLFWwindow* window,
 
 void _glfwPlatformSetWindowSize(_GLFWwindow* window, int width, int height)
 {
-    MirSurfaceSpec* spec;
+    MirWindowSpec* spec;
 
-    spec = mir_connection_create_spec_for_changes(_glfw.mir.connection);
+    spec = mir_create_window_spec(_glfw.mir.connection);
-    mir_surface_spec_set_width (spec, width);
+    mir_window_spec_set_width (spec, width);
-    mir_surface_spec_set_height(spec, height);
+    mir_window_spec_set_height(spec, height);
 
-    mir_surface_apply_spec(window->mir.surface, spec);
+    mir_window_apply_spec(window->mir.window, spec);
-    mir_surface_spec_release(spec);
+    mir_window_spec_release(spec);
 }
 
 void _glfwPlatformSetWindowSizeLimits(_GLFWwindow* window,
                                       int minwidth, int minheight,
                                       int maxwidth, int maxheight)
 {
-    _glfwInputError(GLFW_PLATFORM_ERROR,
+    MirWindowSpec* spec;
-                    "Mir: Unsupported function %s", __PRETTY_FUNCTION__);
+
+    spec = mir_create_window_spec(_glfw.mir.connection);
+    mir_window_spec_set_max_width (spec, maxwidth);
+    mir_window_spec_set_max_height(spec, maxheight);
+    mir_window_spec_set_min_width (spec, minwidth);
+    mir_window_spec_set_min_height(spec, minheight);
+
+    mir_window_apply_spec(window->mir.window, spec);
+    mir_window_spec_release(spec);
 }
 
 void _glfwPlatformSetWindowAspectRatio(_GLFWwindow* window, int numer, int denom)
@@ -473,42 +515,74 @@ void _glfwPlatformGetWindowSize(_GLFWwindow* window, int* width, int* height)
         *height = window->mir.height;
 }
 
+void _glfwPlatformGetWindowContentScale(_GLFWwindow* window,
+                                        float* xscale, float* yscale)
+{
+    if (xscale)
+        *xscale = 1.f;
+    if (yscale)
+        *yscale = 1.f;
+}
+
 void _glfwPlatformIconifyWindow(_GLFWwindow* window)
 {
-    mir_surface_set_state(window->mir.surface, mir_surface_state_minimized);
+    MirWindowSpec* spec;
+
+    spec = mir_create_window_spec(_glfw.mir.connection);
+    mir_window_spec_set_state(spec, mir_window_state_minimized);
+
+    mir_window_apply_spec(window->mir.window, spec);
+    mir_window_spec_release(spec);
 }
 
 void _glfwPlatformRestoreWindow(_GLFWwindow* window)
 {
-    mir_surface_set_state(window->mir.surface, mir_surface_state_restored);
+    MirWindowSpec* spec;
+
+    spec = mir_create_window_spec(_glfw.mir.connection);
+    mir_window_spec_set_state(spec, mir_window_state_restored);
+
+    mir_window_apply_spec(window->mir.window, spec);
+    mir_window_spec_release(spec);
 }
 
 void _glfwPlatformMaximizeWindow(_GLFWwindow* window)
 {
-    _glfwInputError(GLFW_PLATFORM_ERROR,
+    MirWindowSpec* spec;
-                    "Mir: Unsupported function %s", __PRETTY_FUNCTION__);
+
+    spec = mir_create_window_spec(_glfw.mir.connection);
+    mir_window_spec_set_state(spec, mir_window_state_maximized);
+
+    mir_window_apply_spec(window->mir.window, spec);
+    mir_window_spec_release(spec);
 }
 
 void _glfwPlatformHideWindow(_GLFWwindow* window)
 {
-    MirSurfaceSpec* spec;
+    MirWindowSpec* spec;
 
-    spec = mir_connection_create_spec_for_changes(_glfw.mir.connection);
+    spec = mir_create_window_spec(_glfw.mir.connection);
-    mir_surface_spec_set_state(spec, mir_surface_state_hidden);
+    mir_window_spec_set_state(spec, mir_window_state_hidden);
 
-    mir_surface_apply_spec(window->mir.surface, spec);
+    mir_window_apply_spec(window->mir.window, spec);
-    mir_surface_spec_release(spec);
+    mir_window_spec_release(spec);
 }
 
 void _glfwPlatformShowWindow(_GLFWwindow* window)
 {
-    MirSurfaceSpec* spec;
+    MirWindowSpec* spec;
 
-    spec = mir_connection_create_spec_for_changes(_glfw.mir.connection);
+    spec = mir_create_window_spec(_glfw.mir.connection);
-    mir_surface_spec_set_state(spec, mir_surface_state_restored);
+    mir_window_spec_set_state(spec, mir_window_state_restored);
 
-    mir_surface_apply_spec(window->mir.surface, spec);
+    mir_window_apply_spec(window->mir.window, spec);
-    mir_surface_spec_release(spec);
+    mir_window_spec_release(spec);
+}
+
+void _glfwPlatformRequestWindowAttention(_GLFWwindow* window)
+{
+    _glfwInputError(GLFW_PLATFORM_ERROR,
+                    "Mir: Unsupported function %s", __PRETTY_FUNCTION__);
 }
 
 void _glfwPlatformFocusWindow(_GLFWwindow* window)
@@ -529,9 +603,7 @@ void _glfwPlatformSetWindowMonitor(_GLFWwindow* window,
 
 int _glfwPlatformWindowFocused(_GLFWwindow* window)
 {
-    _glfwInputError(GLFW_PLATFORM_ERROR,
+    return mir_window_get_focus_state(window->mir.window) == mir_window_focus_state_focused;
-                    "Mir: Unsupported function %s", __PRETTY_FUNCTION__);
-    return GLFW_FALSE;
 }
 
 int _glfwPlatformWindowIconified(_GLFWwindow* window)
@@ -543,53 +615,85 @@ int _glfwPlatformWindowIconified(_GLFWwindow* window)
 
 int _glfwPlatformWindowVisible(_GLFWwindow* window)
 {
-    return mir_surface_get_visibility(window->mir.surface) == mir_surface_visibility_exposed;
+    return mir_window_get_visibility(window->mir.window) == mir_window_visibility_exposed;
 }
 
 int _glfwPlatformWindowMaximized(_GLFWwindow* window)
+{
+    return mir_window_get_state(window->mir.window) == mir_window_state_maximized;
+}
+
+int _glfwPlatformFramebufferTransparent(_GLFWwindow* window)
 {
     _glfwInputError(GLFW_PLATFORM_ERROR,
                     "Mir: Unsupported function %s", __PRETTY_FUNCTION__);
     return GLFW_FALSE;
 }
 
+void _glfwPlatformSetWindowResizable(_GLFWwindow* window, GLFWbool enabled)
+{
+    _glfwInputError(GLFW_PLATFORM_ERROR,
+                    "Mir: Unsupported function %s", __PRETTY_FUNCTION__);
+}
+
+void _glfwPlatformSetWindowDecorated(_GLFWwindow* window, GLFWbool enabled)
+{
+    _glfwInputError(GLFW_PLATFORM_ERROR,
+                    "Mir: Unsupported function %s", __PRETTY_FUNCTION__);
+}
+
+void _glfwPlatformSetWindowFloating(_GLFWwindow* window, GLFWbool enabled)
+{
+    _glfwInputError(GLFW_PLATFORM_ERROR,
+                    "Mir: Unsupported function %s", __PRETTY_FUNCTION__);
+}
+
+float _glfwPlatformGetWindowOpacity(_GLFWwindow* window)
+{
+    return 1.f;
+}
+
+void _glfwPlatformSetWindowOpacity(_GLFWwindow* window, float opacity)
+{
+}
+
 void _glfwPlatformPollEvents(void)
 {
     EventNode* node = NULL;
 
-    while ((node = dequeueEvent(_glfw.mir.event_queue)))
+    while ((node = dequeueEvent(_glfw.mir.eventQueue)))
     {
         handleEvent(node->event, node->window);
-        deleteNode(_glfw.mir.event_queue, node);
+        deleteNode(_glfw.mir.eventQueue, node);
     }
 }
 
 void _glfwPlatformWaitEvents(void)
 {
-    pthread_mutex_lock(&_glfw.mir.event_mutex);
+    pthread_mutex_lock(&_glfw.mir.eventMutex);
 
-    if (emptyEventQueue(_glfw.mir.event_queue))
+    while (emptyEventQueue(_glfw.mir.eventQueue))
-        pthread_cond_wait(&_glfw.mir.event_cond, &_glfw.mir.event_mutex);
+        pthread_cond_wait(&_glfw.mir.eventCond, &_glfw.mir.eventMutex);
 
-    pthread_mutex_unlock(&_glfw.mir.event_mutex);
+    pthread_mutex_unlock(&_glfw.mir.eventMutex);
 
     _glfwPlatformPollEvents();
 }
 
 void _glfwPlatformWaitEventsTimeout(double timeout)
 {
-    pthread_mutex_lock(&_glfw.mir.event_mutex);
+    pthread_mutex_lock(&_glfw.mir.eventMutex);
 
-    if (emptyEventQueue(_glfw.mir.event_queue))
+    if (emptyEventQueue(_glfw.mir.eventQueue))
     {
         struct timespec time;
         clock_gettime(CLOCK_REALTIME, &time);
         time.tv_sec += (long) timeout;
         time.tv_nsec += (long) ((timeout - (long) timeout) * 1e9);
-        pthread_cond_timedwait(&_glfw.mir.event_cond, &_glfw.mir.event_mutex, &time);
+        pthread_cond_timedwait(&_glfw.mir.eventCond, &_glfw.mir.eventMutex, &time);
     }
 
-    pthread_mutex_unlock(&_glfw.mir.event_mutex);
+    pthread_mutex_unlock(&_glfw.mir.eventMutex);
 
     _glfwPlatformPollEvents();
 }
@@ -606,60 +710,45 @@ void _glfwPlatformGetFramebufferSize(_GLFWwindow* window, int* width, int* heigh
         *height = window->mir.height;
 }
 
-// FIXME implement
 int _glfwPlatformCreateCursor(_GLFWcursor* cursor,
                               const GLFWimage* image,
                               int xhot, int yhot)
 {
     MirBufferStream* stream;
-    MirPixelFormat pixel_format = findValidPixelFormat();
 
     int i_w = image->width;
     int i_h = image->height;
 
-    if (pixel_format == mir_pixel_format_invalid)
-    {
-        _glfwInputError(GLFW_PLATFORM_ERROR,
-                        "Mir: Unable to find a correct pixel format");
-        return GLFW_FALSE;
-    }
-
     stream = mir_connection_create_buffer_stream_sync(_glfw.mir.connection,
                                                       i_w, i_h,
-                                                      pixel_format,
+                                                      mir_pixel_format_argb_8888,
                                                       mir_buffer_usage_software);
 
     cursor->mir.conf = mir_cursor_configuration_from_buffer_stream(stream, xhot, yhot);
 
-    char* dest;
-    unsigned char *pixels;
-    int i, r_stride, bytes_per_pixel, bytes_per_row;
-
     MirGraphicsRegion region;
     mir_buffer_stream_get_graphics_region(stream, &region);
 
-    // FIXME Figure this out based on the current_pf
+    unsigned char* pixels = image->pixels;
-    bytes_per_pixel = 4;
+    char* dest = region.vaddr;
-    bytes_per_row   = bytes_per_pixel * i_w;
+    int i;
 
-    dest   = region.vaddr;
+    for (i = 0; i < i_w * i_h; i++, pixels += 4)
-    pixels = image->pixels;
-
-    r_stride = region.stride;
-
-    for (i = 0; i < i_h; i++)
     {
-        memcpy(dest, pixels, bytes_per_row);
+        unsigned int alpha = pixels[3];
-        dest   += r_stride;
+        *dest++ = (char)(pixels[2] * alpha / 255);
-        pixels += r_stride;
+        *dest++ = (char)(pixels[1] * alpha / 255);
+        *dest++ = (char)(pixels[0] * alpha / 255);
+        *dest++ = (char)alpha;
     }
 
-    cursor->mir.custom_cursor = stream;
+    mir_buffer_stream_swap_buffers_sync(stream);
+    cursor->mir.customCursor = stream;
 
     return GLFW_TRUE;
 }
 
-const char* getSystemCursorName(int shape)
+static const char* getSystemCursorName(int shape)
 {
     switch (shape)
     {
@@ -682,40 +771,47 @@ const char* getSystemCursorName(int shape)
 
 int _glfwPlatformCreateStandardCursor(_GLFWcursor* cursor, int shape)
 {
-    const char* cursor_name = getSystemCursorName(shape);
+    cursor->mir.conf         = NULL;
+    cursor->mir.customCursor = NULL;
+    cursor->mir.cursorName   = getSystemCursorName(shape);
 
-    if (cursor_name)
+    return cursor->mir.cursorName != NULL;
-    {
-        cursor->mir.conf          = mir_cursor_configuration_from_name(cursor_name);
-        cursor->mir.custom_cursor = NULL;
-
-        return GLFW_TRUE;
-    }
-
-    return GLFW_FALSE;
 }
 
 void _glfwPlatformDestroyCursor(_GLFWcursor* cursor)
 {
     if (cursor->mir.conf)
         mir_cursor_configuration_destroy(cursor->mir.conf);
-    if (cursor->mir.custom_cursor)
+    if (cursor->mir.customCursor)
-        mir_buffer_stream_release_sync(cursor->mir.custom_cursor);
+        mir_buffer_stream_release_sync(cursor->mir.customCursor);
+}
+
+static void setCursorNameForWindow(MirWindow* window, char const* name)
+{
+    MirWindowSpec* spec = mir_create_window_spec(_glfw.mir.connection);
+    mir_window_spec_set_cursor_name(spec, name);
+    mir_window_apply_spec(window, spec);
+    mir_window_spec_release(spec);
 }
 
 void _glfwPlatformSetCursor(_GLFWwindow* window, _GLFWcursor* cursor)
 {
-    if (cursor && cursor->mir.conf)
+    if (cursor)
     {
-        mir_wait_for(mir_surface_configure_cursor(window->mir.surface, cursor->mir.conf));
+        window->mir.currentCursor = cursor;
-        if (cursor->mir.custom_cursor)
+
+        if (cursor->mir.cursorName)
         {
-            mir_buffer_stream_swap_buffers_sync(cursor->mir.custom_cursor);
+            setCursorNameForWindow(window->mir.window, cursor->mir.cursorName);
+        }
+        else if (cursor->mir.conf)
+        {
+            mir_window_configure_cursor(window->mir.window, cursor->mir.conf);
         }
     }
     else
     {
-        mir_wait_for(mir_surface_configure_cursor(window->mir.surface, _glfw.mir.default_conf));
+        setCursorNameForWindow(window->mir.window, mir_default_cursor_name);
     }
 }
 
@@ -733,24 +829,51 @@ void _glfwPlatformSetCursorPos(_GLFWwindow* window, double xpos, double ypos)
 
 void _glfwPlatformSetCursorMode(_GLFWwindow* window, int mode)
 {
-    _glfwInputError(GLFW_PLATFORM_ERROR,
+    if (mode == GLFW_CURSOR_DISABLED)
-                    "Mir: Unsupported function %s", __PRETTY_FUNCTION__);
+    {
+        _glfw.mir.disabledCursorWindow = window;
+        setWindowConfinement(window, mir_pointer_confined_to_window);
+        setCursorNameForWindow(window->mir.window, mir_disabled_cursor_name);
+    }
+    else
+    {
+        // If we were disabled before lets undo that!
+        if (_glfw.mir.disabledCursorWindow == window)
+        {
+            _glfw.mir.disabledCursorWindow = NULL;
+            setWindowConfinement(window, mir_pointer_unconfined);
+        }
+
+        if (window->cursorMode == GLFW_CURSOR_NORMAL)
+        {
+            _glfwPlatformSetCursor(window, window->mir.currentCursor);
+        }
+        else if (window->cursorMode == GLFW_CURSOR_HIDDEN)
+        {
+            setCursorNameForWindow(window->mir.window, mir_disabled_cursor_name);
+        }
+    }
 }
 
-const char* _glfwPlatformGetKeyName(int key, int scancode)
+const char* _glfwPlatformGetScancodeName(int scancode)
 {
     _glfwInputError(GLFW_PLATFORM_ERROR,
                     "Mir: Unsupported function %s", __PRETTY_FUNCTION__);
     return NULL;
 }
 
-void _glfwPlatformSetClipboardString(_GLFWwindow* window, const char* string)
+int _glfwPlatformGetKeyScancode(int key)
+{
+    return _glfw.mir.scancodes[key];
+}
+
+void _glfwPlatformSetClipboardString(const char* string)
 {
     _glfwInputError(GLFW_PLATFORM_ERROR,
                     "Mir: Unsupported function %s", __PRETTY_FUNCTION__);
 }
 
-const char* _glfwPlatformGetClipboardString(_GLFWwindow* window)
+const char* _glfwPlatformGetClipboardString(void)
 {
     _glfwInputError(GLFW_PLATFORM_ERROR,
                     "Mir: Unsupported function %s", __PRETTY_FUNCTION__);
@@ -758,28 +881,21 @@ const char* _glfwPlatformGetClipboardString(_GLFWwindow* window)
     return NULL;
 }
 
-char** _glfwPlatformGetRequiredInstanceExtensions(uint32_t* count)
+void _glfwPlatformGetRequiredInstanceExtensions(char** extensions)
 {
-    char** extensions;
+    if (!_glfw.vk.KHR_surface || !_glfw.vk.KHR_mir_surface)
+        return;
 
-    *count = 0;
+    extensions[0] = "VK_KHR_surface";
-
+    extensions[1] = "VK_KHR_mir_surface";
-    if (!_glfw.vk.KHR_mir_surface)
-        return NULL;
-
-    extensions = calloc(2, sizeof(char*));
-    extensions[0] = strdup("VK_KHR_surface");
-    extensions[1] = strdup("VK_KHR_mir_surface");
-
-    *count = 2;
-    return extensions;
 }
 
 int _glfwPlatformGetPhysicalDevicePresentationSupport(VkInstance instance,
                                                       VkPhysicalDevice device,
                                                       uint32_t queuefamily)
 {
-    PFN_vkGetPhysicalDeviceMirPresentationSupportKHR vkGetPhysicalDeviceMirPresentationSupportKHR =
+    PFN_vkGetPhysicalDeviceMirPresentationSupportKHR
+        vkGetPhysicalDeviceMirPresentationSupportKHR =
         (PFN_vkGetPhysicalDeviceMirPresentationSupportKHR)
         vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceMirPresentationSupportKHR");
     if (!vkGetPhysicalDeviceMirPresentationSupportKHR)
@@ -800,12 +916,12 @@ VkResult _glfwPlatformCreateWindowSurface(VkInstance instance,
                                           VkSurfaceKHR* surface)
 {
     VkResult err;
-    VkMirSurfaceCreateInfoKHR sci;
+    VkMirWindowCreateInfoKHR sci;
-    PFN_vkCreateMirSurfaceKHR vkCreateMirSurfaceKHR;
+    PFN_vkCreateMirWindowKHR vkCreateMirWindowKHR;
 
-    vkCreateMirSurfaceKHR = (PFN_vkCreateMirSurfaceKHR)
+    vkCreateMirWindowKHR = (PFN_vkCreateMirWindowKHR)
-        vkGetInstanceProcAddr(instance, "vkCreateMirSurfaceKHR");
+        vkGetInstanceProcAddr(instance, "vkCreateMirWindowKHR");
-    if (!vkCreateMirSurfaceKHR)
+    if (!vkCreateMirWindowKHR)
     {
         _glfwInputError(GLFW_API_UNAVAILABLE,
                         "Mir: Vulkan instance missing VK_KHR_mir_surface extension");
@@ -815,9 +931,9 @@ VkResult _glfwPlatformCreateWindowSurface(VkInstance instance,
     memset(&sci, 0, sizeof(sci));
     sci.sType = VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR;
     sci.connection = _glfw.mir.connection;
-    sci.mirSurface = window->mir.surface;
+    sci.mirWindow  = window->mir.window;
 
-    err = vkCreateMirSurfaceKHR(instance, &sci, allocator, surface);
+    err = vkCreateMirWindowKHR(instance, &sci, allocator, surface);
     if (err)
     {
         _glfwInputError(GLFW_PLATFORM_ERROR,
@@ -839,10 +955,10 @@ GLFWAPI MirConnection* glfwGetMirDisplay(void)
     return _glfw.mir.connection;
 }
 
-GLFWAPI MirSurface* glfwGetMirWindow(GLFWwindow* handle)
+GLFWAPI MirWindow* glfwGetMirWindow(GLFWwindow* handle)
 {
     _GLFWwindow* window = (_GLFWwindow*) handle;
     _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
-    return window->mir.surface;
+    return window->mir.window;
 }
 

raylib/external/glfw/src/monitor.c

@@ -1,8 +1,8 @@
 //========================================================================
-// GLFW 3.2 - www.glfw.org
+// GLFW 3.3 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-2016 Camilla Berglund <elmindreda@glfw.org>
+// Copyright (c) 2006-2016 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
@@ -86,83 +86,62 @@ static GLFWbool refreshVideoModes(_GLFWmonitor* monitor)
 //////                         GLFW event API                       //////
 //////////////////////////////////////////////////////////////////////////
 
-void _glfwInputMonitorChange(void)
+void _glfwInputMonitor(_GLFWmonitor* monitor, int action, int placement)
 {
-    int i, j, monitorCount = _glfw.monitorCount;
+    if (action == GLFW_CONNECTED)
-    _GLFWmonitor** monitors = _glfw.monitors;
-
-    _glfw.monitors = _glfwPlatformGetMonitors(&_glfw.monitorCount);
-
-    // Re-use still connected monitor objects
-
-    for (i = 0;  i < _glfw.monitorCount;  i++)
     {
-        for (j = 0;  j < monitorCount;  j++)
+        _glfw.monitorCount++;
+        _glfw.monitors =
+            realloc(_glfw.monitors, sizeof(_GLFWmonitor*) * _glfw.monitorCount);
+
+        if (placement == _GLFW_INSERT_FIRST)
         {
-            if (_glfwPlatformIsSameMonitor(_glfw.monitors[i], monitors[j]))
+            memmove(_glfw.monitors + 1,
-            {
+                    _glfw.monitors,
-                _glfwFreeMonitor(_glfw.monitors[i]);
+                    (_glfw.monitorCount - 1) * sizeof(_GLFWmonitor*));
-                _glfw.monitors[i] = monitors[j];
+            _glfw.monitors[0] = monitor;
-                break;
-            }
         }
+        else
+            _glfw.monitors[_glfw.monitorCount - 1] = monitor;
     }
-
+    else if (action == GLFW_DISCONNECTED)
-    // Find and report disconnected monitors (not in the new list)
-
-    for (i = 0;  i < monitorCount;  i++)
     {
+        int i;
         _GLFWwindow* window;
 
-        for (j = 0;  j < _glfw.monitorCount;  j++)
-        {
-            if (monitors[i] == _glfw.monitors[j])
-                break;
-        }
-
-        if (j < _glfw.monitorCount)
-            continue;
-
         for (window = _glfw.windowListHead;  window;  window = window->next)
         {
-            if (window->monitor == monitors[i])
+            if (window->monitor == monitor)
             {
-                int width, height;
+                int width, height, xoff, yoff;
                 _glfwPlatformGetWindowSize(window, &width, &height);
                 _glfwPlatformSetWindowMonitor(window, NULL, 0, 0, width, height, 0);
+                _glfwPlatformGetWindowFrameSize(window, &xoff, &yoff, NULL, NULL);
+                _glfwPlatformSetWindowPos(window, xoff, yoff);
             }
         }
 
-        if (_glfw.callbacks.monitor)
+        for (i = 0;  i < _glfw.monitorCount;  i++)
-            _glfw.callbacks.monitor((GLFWmonitor*) monitors[i], GLFW_DISCONNECTED);
-    }
-
-    // Find and report newly connected monitors (not in the old list)
-    // Re-used monitor objects are then removed from the old list to avoid
-    // having them destroyed at the end of this function
-
-    for (i = 0;  i < _glfw.monitorCount;  i++)
-    {
-        for (j = 0;  j < monitorCount;  j++)
         {
-            if (_glfw.monitors[i] == monitors[j])
+            if (_glfw.monitors[i] == monitor)
             {
-                monitors[j] = NULL;
+                _glfw.monitorCount--;
+                memmove(_glfw.monitors + i,
+                        _glfw.monitors + i + 1,
+                        (_glfw.monitorCount - i) * sizeof(_GLFWmonitor*));
                 break;
             }
         }
-
-        if (j < monitorCount)
-            continue;
-
-        if (_glfw.callbacks.monitor)
-            _glfw.callbacks.monitor((GLFWmonitor*) _glfw.monitors[i], GLFW_CONNECTED);
     }
 
-    _glfwFreeMonitors(monitors, monitorCount);
+    if (_glfw.callbacks.monitor)
+        _glfw.callbacks.monitor((GLFWmonitor*) monitor, action);
+
+    if (action == GLFW_DISCONNECTED)
+        _glfwFreeMonitor(monitor);
 }
 
-void _glfwInputMonitorWindowChange(_GLFWmonitor* monitor, _GLFWwindow* window)
+void _glfwInputMonitorWindow(_GLFWmonitor* monitor, _GLFWwindow* window)
 {
     monitor->window = window;
 }
@@ -175,10 +154,12 @@ void _glfwInputMonitorWindowChange(_GLFWmonitor* monitor, _GLFWwindow* window)
 _GLFWmonitor* _glfwAllocMonitor(const char* name, int widthMM, int heightMM)
 {
     _GLFWmonitor* monitor = calloc(1, sizeof(_GLFWmonitor));
-    monitor->name = strdup(name);
     monitor->widthMM = widthMM;
     monitor->heightMM = heightMM;
 
+    if (name)
+        monitor->name = strdup(name);
+
     return monitor;
 }
 
@@ -212,16 +193,6 @@ void _glfwFreeGammaArrays(GLFWgammaramp* ramp)
     memset(ramp, 0, sizeof(GLFWgammaramp));
 }
 
-void _glfwFreeMonitors(_GLFWmonitor** monitors, int count)
-{
-    int i;
-
-    for (i = 0;  i < count;  i++)
-        _glfwFreeMonitor(monitors[i]);
-
-    free(monitors);
-}
-
 const GLFWvidmode* _glfwChooseVideoMode(_GLFWmonitor* monitor,
                                         const GLFWvidmode* desired)
 {
@@ -304,6 +275,7 @@ void _glfwSplitBPP(int bpp, int* red, int* green, int* blue)
 GLFWAPI GLFWmonitor** glfwGetMonitors(int* count)
 {
     assert(count != NULL);
+
     *count = 0;
 
     _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
@@ -355,6 +327,21 @@ GLFWAPI void glfwGetMonitorPhysicalSize(GLFWmonitor* handle, int* widthMM, int*
         *heightMM = monitor->heightMM;
 }
 
+GLFWAPI void glfwGetMonitorContentScale(GLFWmonitor* handle,
+                                        float* xscale, float* yscale)
+{
+    _GLFWmonitor* monitor = (_GLFWmonitor*) handle;
+    assert(monitor != NULL);
+
+    if (xscale)
+        *xscale = 0.f;
+    if (yscale)
+        *yscale = 0.f;
+
+    _GLFW_REQUIRE_INIT();
+    _glfwPlatformGetMonitorContentScale(monitor, xscale, yscale);
+}
+
 GLFWAPI const char* glfwGetMonitorName(GLFWmonitor* handle)
 {
     _GLFWmonitor* monitor = (_GLFWmonitor*) handle;
@@ -404,6 +391,10 @@ GLFWAPI void glfwSetGamma(GLFWmonitor* handle, float gamma)
     int i;
     unsigned short values[256];
     GLFWgammaramp ramp;
+    assert(handle != NULL);
+    assert(gamma == gamma);
+    assert(gamma >= 0.f);
+    assert(gamma <= FLT_MAX);
 
     _GLFW_REQUIRE_INIT();
 
@@ -455,6 +446,7 @@ GLFWAPI void glfwSetGammaRamp(GLFWmonitor* handle, const GLFWgammaramp* ramp)
     _GLFWmonitor* monitor = (_GLFWmonitor*) handle;
     assert(monitor != NULL);
     assert(ramp != NULL);
+    assert(ramp->size > 0);
     assert(ramp->red != NULL);
     assert(ramp->green != NULL);
     assert(ramp->blue != NULL);

raylib/external/glfw/src/nsgl_context.h

@@ -1,7 +1,7 @@
 //========================================================================
-// GLFW 3.2 OS X - www.glfw.org
+// GLFW 3.3 macOS - www.glfw.org
 //------------------------------------------------------------------------
-// Copyright (c) 2009-2016 Camilla Berglund <elmindreda@glfw.org>
+// Copyright (c) 2009-2016 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
@@ -24,9 +24,6 @@
 //
 //========================================================================
 
-#ifndef _glfw3_nsgl_context_h_
-#define _glfw3_nsgl_context_h_
-
 #define _GLFW_PLATFORM_CONTEXT_STATE            _GLFWcontextNSGL nsgl
 #define _GLFW_PLATFORM_LIBRARY_CONTEXT_STATE    _GLFWlibraryNSGL nsgl
 
@@ -57,4 +54,3 @@ GLFWbool _glfwCreateContextNSGL(_GLFWwindow* window,
                                 const _GLFWfbconfig* fbconfig);
 void _glfwDestroyContextNSGL(_GLFWwindow* window);
 
-#endif // _glfw3_nsgl_context_h_

raylib/external/glfw/src/nsgl_context.m

@@ -1,7 +1,7 @@
 //========================================================================
-// GLFW 3.2 OS X - www.glfw.org
+// GLFW 3.3 macOS - www.glfw.org
 //------------------------------------------------------------------------
-// Copyright (c) 2009-2016 Camilla Berglund <elmindreda@glfw.org>
+// Copyright (c) 2009-2016 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
@@ -34,7 +34,7 @@ static void makeContextCurrentNSGL(_GLFWwindow* window)
     else
         [NSOpenGLContext clearCurrentContext];
 
-    _glfwPlatformSetCurrentContext(window);
+    _glfwPlatformSetTls(&_glfw.contextSlot, window);
 }
 
 static void swapBuffersNSGL(_GLFWwindow* window)
@@ -45,7 +45,7 @@ static void swapBuffersNSGL(_GLFWwindow* window)
 
 static void swapIntervalNSGL(int interval)
 {
-    _GLFWwindow* window = _glfwPlatformGetCurrentContext();
+    _GLFWwindow* window = _glfwPlatformGetTls(&_glfw.contextSlot);
 
     GLint sync = interval;
     [window->context.nsgl.object setValues:&sync
@@ -119,70 +119,83 @@ GLFWbool _glfwCreateContextNSGL(_GLFWwindow* window,
                                 const _GLFWctxconfig* ctxconfig,
                                 const _GLFWfbconfig* fbconfig)
 {
-    unsigned int attributeCount = 0;
-
     if (ctxconfig->client == GLFW_OPENGL_ES_API)
     {
         _glfwInputError(GLFW_API_UNAVAILABLE,
-                        "NSGL: OpenGL ES is not available on OS X");
+                        "NSGL: OpenGL ES is not available on macOS");
-        return GLFW_FALSE;
-    }
-
-    if (ctxconfig->major == 3 && ctxconfig->minor < 2)
-    {
-        _glfwInputError(GLFW_VERSION_UNAVAILABLE,
-                        "NSGL: The targeted version of OS X does not support OpenGL 3.0 or 3.1");
         return GLFW_FALSE;
     }
 
     if (ctxconfig->major > 2)
     {
-        if (!ctxconfig->forward)
+        if (ctxconfig->major == 3 && ctxconfig->minor < 2)
         {
             _glfwInputError(GLFW_VERSION_UNAVAILABLE,
-                            "NSGL: The targeted version of OS X only supports forward-compatible contexts for OpenGL 3.2 and above");
+                            "NSGL: The targeted version of macOS does not support OpenGL 3.0 or 3.1 but may support 3.2 and above");
             return GLFW_FALSE;
         }
 
-        if (ctxconfig->profile != GLFW_OPENGL_CORE_PROFILE)
+        if (!ctxconfig->forward || ctxconfig->profile != GLFW_OPENGL_CORE_PROFILE)
         {
             _glfwInputError(GLFW_VERSION_UNAVAILABLE,
-                            "NSGL: The targeted version of OS X only supports core profile contexts for OpenGL 3.2 and above");
+                            "NSGL: The targeted version of macOS only supports forward-compatible core profile contexts for OpenGL 3.2 and above");
             return GLFW_FALSE;
         }
     }
 
-    // Context robustness modes (GL_KHR_robustness) are not yet supported on
+    // Context robustness modes (GL_KHR_robustness) are not yet supported by
-    // OS X but are not a hard constraint, so ignore and continue
+    // macOS but are not a hard constraint, so ignore and continue
 
     // Context release behaviors (GL_KHR_context_flush_control) are not yet
-    // supported on OS X but are not a hard constraint, so ignore and continue
+    // supported by macOS but are not a hard constraint, so ignore and continue
 
-#define ADD_ATTR(x) { attributes[attributeCount++] = x; }
+    // Debug contexts (GL_KHR_debug) are not yet supported by macOS but are not
-#define ADD_ATTR2(x, y) { ADD_ATTR(x); ADD_ATTR(y); }
+    // a hard constraint, so ignore and continue
 
-    // Arbitrary array size here
+    // No-error contexts (GL_KHR_no_error) are not yet supported by macOS but
-    NSOpenGLPixelFormatAttribute attributes[40];
+    // are not a hard constraint, so ignore and continue
 
-    ADD_ATTR(NSOpenGLPFAAccelerated);
+#define addAttrib(a) \
-    ADD_ATTR(NSOpenGLPFAClosestPolicy);
+{ \
+    assert((size_t) index < sizeof(attribs) / sizeof(attribs[0])); \
+    attribs[index++] = a; \
+}
+#define setAttrib(a, v) { addAttrib(a); addAttrib(v); }
+
+    NSOpenGLPixelFormatAttribute attribs[40];
+    int index = 0;
+
+    addAttrib(NSOpenGLPFAAccelerated);
+    addAttrib(NSOpenGLPFAClosestPolicy);
+
+    if (ctxconfig->nsgl.offline)
+    {
+        addAttrib(NSOpenGLPFAAllowOfflineRenderers);
+        // NOTE: This replaces the NSSupportsAutomaticGraphicsSwitching key in
+        //       Info.plist for unbundled applications
+        // HACK: This assumes that NSOpenGLPixelFormat will remain
+        //       a straightforward wrapper of its CGL counterpart
+#if MAC_OS_X_VERSION_MAX_ALLOWED >= 100800
+        addAttrib(kCGLPFASupportsAutomaticGraphicsSwitching);
+#endif /*MAC_OS_X_VERSION_MAX_ALLOWED*/
+    }
 
 #if MAC_OS_X_VERSION_MAX_ALLOWED >= 101000
     if (ctxconfig->major >= 4)
     {
-        ADD_ATTR2(NSOpenGLPFAOpenGLProfile, NSOpenGLProfileVersion4_1Core);
+        setAttrib(NSOpenGLPFAOpenGLProfile, NSOpenGLProfileVersion4_1Core);
     }
     else
 #endif /*MAC_OS_X_VERSION_MAX_ALLOWED*/
     if (ctxconfig->major >= 3)
     {
-        ADD_ATTR2(NSOpenGLPFAOpenGLProfile, NSOpenGLProfileVersion3_2Core);
+        setAttrib(NSOpenGLPFAOpenGLProfile, NSOpenGLProfileVersion3_2Core);
     }
 
     if (ctxconfig->major <= 2)
     {
         if (fbconfig->auxBuffers != GLFW_DONT_CARE)
-            ADD_ATTR2(NSOpenGLPFAAuxBuffers, fbconfig->auxBuffers);
+            setAttrib(NSOpenGLPFAAuxBuffers, fbconfig->auxBuffers);
 
         if (fbconfig->accumRedBits != GLFW_DONT_CARE &&
             fbconfig->accumGreenBits != GLFW_DONT_CARE &&
@@ -194,7 +207,7 @@ GLFWbool _glfwCreateContextNSGL(_GLFWwindow* window,
                                   fbconfig->accumBlueBits +
                                   fbconfig->accumAlphaBits;
 
-            ADD_ATTR2(NSOpenGLPFAAccumSize, accumBits);
+            setAttrib(NSOpenGLPFAAccumSize, accumBits);
         }
     }
 
@@ -206,53 +219,61 @@ GLFWbool _glfwCreateContextNSGL(_GLFWwindow* window,
                         fbconfig->greenBits +
                         fbconfig->blueBits;
 
-        // OS X needs non-zero color size, so set reasonable values
+        // macOS needs non-zero color size, so set reasonable values
         if (colorBits == 0)
             colorBits = 24;
         else if (colorBits < 15)
             colorBits = 15;
 
-        ADD_ATTR2(NSOpenGLPFAColorSize, colorBits);
+        setAttrib(NSOpenGLPFAColorSize, colorBits);
     }
 
     if (fbconfig->alphaBits != GLFW_DONT_CARE)
-        ADD_ATTR2(NSOpenGLPFAAlphaSize, fbconfig->alphaBits);
+        setAttrib(NSOpenGLPFAAlphaSize, fbconfig->alphaBits);
 
     if (fbconfig->depthBits != GLFW_DONT_CARE)
-        ADD_ATTR2(NSOpenGLPFADepthSize, fbconfig->depthBits);
+        setAttrib(NSOpenGLPFADepthSize, fbconfig->depthBits);
 
     if (fbconfig->stencilBits != GLFW_DONT_CARE)
-        ADD_ATTR2(NSOpenGLPFAStencilSize, fbconfig->stencilBits);
+        setAttrib(NSOpenGLPFAStencilSize, fbconfig->stencilBits);
 
     if (fbconfig->stereo)
-        ADD_ATTR(NSOpenGLPFAStereo);
+    {
+#if MAC_OS_X_VERSION_MAX_ALLOWED >= 101200
+        _glfwInputError(GLFW_FORMAT_UNAVAILABLE,
+                        "NSGL: Stereo rendering is deprecated");
+        return GLFW_FALSE;
+#else
+        addAttrib(NSOpenGLPFAStereo);
+#endif
+    }
 
     if (fbconfig->doublebuffer)
-        ADD_ATTR(NSOpenGLPFADoubleBuffer);
+        addAttrib(NSOpenGLPFADoubleBuffer);
 
     if (fbconfig->samples != GLFW_DONT_CARE)
     {
         if (fbconfig->samples == 0)
         {
-            ADD_ATTR2(NSOpenGLPFASampleBuffers, 0);
+            setAttrib(NSOpenGLPFASampleBuffers, 0);
         }
         else
         {
-            ADD_ATTR2(NSOpenGLPFASampleBuffers, 1);
+            setAttrib(NSOpenGLPFASampleBuffers, 1);
-            ADD_ATTR2(NSOpenGLPFASamples, fbconfig->samples);
+            setAttrib(NSOpenGLPFASamples, fbconfig->samples);
         }
     }
 
     // NOTE: All NSOpenGLPixelFormats on the relevant cards support sRGB
     //       framebuffer, so there's no need (and no way) to request it
 
-    ADD_ATTR(0);
+    addAttrib(0);
 
-#undef ADD_ATTR
+#undef addAttrib
-#undef ADD_ATTR2
+#undef setAttrib
 
     window->context.nsgl.pixelFormat =
-        [[NSOpenGLPixelFormat alloc] initWithAttributes:attributes];
+        [[NSOpenGLPixelFormat alloc] initWithAttributes:attribs];
     if (window->context.nsgl.pixelFormat == nil)
     {
         _glfwInputError(GLFW_FORMAT_UNAVAILABLE,
@@ -275,6 +296,12 @@ GLFWbool _glfwCreateContextNSGL(_GLFWwindow* window,
         return GLFW_FALSE;
     }
 
+    if (fbconfig->transparent)
+    {
+        GLint opaque = 0;
+        [window->context.nsgl.object setValues:&opaque forParameter:NSOpenGLCPSurfaceOpacity];
+    }
+
     [window->context.nsgl.object setView:window->ns.view];
 
     window->context.makeCurrent = makeContextCurrentNSGL;

raylib/external/glfw/src/null_init.c

@@ -1,8 +1,8 @@
 //========================================================================
-// GLFW 3.2 POSIX - www.glfw.org
+// GLFW 3.3 - www.glfw.org
 //------------------------------------------------------------------------
-// Copyright (c) 2002-2006 Marcus Geelnard
+// Copyright (c) 2016 Google Inc.
-// Copyright (c) 2006-2016 Camilla Berglund <elmindreda@glfw.org>
+// Copyright (c) 2006-2016 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
@@ -28,41 +28,23 @@
 #include "internal.h"
 
 
-//////////////////////////////////////////////////////////////////////////
-//////                       GLFW internal API                      //////
-//////////////////////////////////////////////////////////////////////////
-
-GLFWbool _glfwInitThreadLocalStoragePOSIX(void)
-{
-    if (pthread_key_create(&_glfw.posix_tls.context, NULL) != 0)
-    {
-        _glfwInputError(GLFW_PLATFORM_ERROR,
-                        "POSIX: Failed to create context TLS");
-        return GLFW_FALSE;
-    }
-
-    _glfw.posix_tls.allocated = GLFW_TRUE;
-    return GLFW_TRUE;
-}
-
-void _glfwTerminateThreadLocalStoragePOSIX(void)
-{
-    if (_glfw.posix_tls.allocated)
-        pthread_key_delete(_glfw.posix_tls.context);
-}
-
-
 //////////////////////////////////////////////////////////////////////////
 //////                       GLFW platform API                      //////
 //////////////////////////////////////////////////////////////////////////
 
-void _glfwPlatformSetCurrentContext(_GLFWwindow* context)
+int _glfwPlatformInit(void)
 {
-    pthread_setspecific(_glfw.posix_tls.context, context);
+    _glfwInitTimerPOSIX();
+    return GLFW_TRUE;
 }
 
-_GLFWwindow* _glfwPlatformGetCurrentContext(void)
+void _glfwPlatformTerminate(void)
 {
-    return pthread_getspecific(_glfw.posix_tls.context);
+    _glfwTerminateOSMesa();
+}
+
+const char* _glfwPlatformGetVersionString(void)
+{
+    return _GLFW_VERSION_NUMBER " null OSMesa";
 }
 

raylib/external/glfw/src/null_joystick.c

@@ -0,0 +1,42 @@
+//========================================================================
+// GLFW 3.3 - www.glfw.org
+//------------------------------------------------------------------------
+// Copyright (c) 2006-2016 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.
+//
+//========================================================================
+
+#include "internal.h"
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW platform API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+int _glfwPlatformPollJoystick(_GLFWjoystick* js, int mode)
+{
+    return GLFW_FALSE;
+}
+
+void _glfwPlatformUpdateGamepadGUID(char* guid)
+{
+}
+

raylib/external/glfw/src/null_joystick.h

@@ -0,0 +1,31 @@
+//========================================================================
+// GLFW 3.3 - www.glfw.org
+//------------------------------------------------------------------------
+// Copyright (c) 2006-2016 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.
+//
+//========================================================================
+
+#define _GLFW_PLATFORM_JOYSTICK_STATE         int nulljs
+#define _GLFW_PLATFORM_LIBRARY_JOYSTICK_STATE int nulljs
+
+#define _GLFW_PLATFORM_MAPPING_NAME ""
+

raylib/external/glfw/src/null_monitor.c

@@ -1,8 +1,8 @@
 //========================================================================
-// GLFW 3.2 Win32 - www.glfw.org
+// GLFW 3.3 - www.glfw.org
 //------------------------------------------------------------------------
-// Copyright (c) 2002-2006 Marcus Geelnard
+// Copyright (c) 2016 Google Inc.
-// Copyright (c) 2006-2016 Camilla Berglund <elmindreda@glfw.org>
+// Copyright (c) 2006-2016 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
@@ -28,42 +28,37 @@
 #include "internal.h"
 
 
-//////////////////////////////////////////////////////////////////////////
-//////                       GLFW internal API                      //////
-//////////////////////////////////////////////////////////////////////////
-
-GLFWbool _glfwInitThreadLocalStorageWin32(void)
-{
-    _glfw.win32_tls.context = TlsAlloc();
-    if (_glfw.win32_tls.context == TLS_OUT_OF_INDEXES)
-    {
-        _glfwInputError(GLFW_PLATFORM_ERROR,
-                        "Win32: Failed to allocate TLS index");
-        return GLFW_FALSE;
-    }
-
-    _glfw.win32_tls.allocated = GLFW_TRUE;
-    return GLFW_TRUE;
-}
-
-void _glfwTerminateThreadLocalStorageWin32(void)
-{
-    if (_glfw.win32_tls.allocated)
-        TlsFree(_glfw.win32_tls.context);
-}
-
-
 //////////////////////////////////////////////////////////////////////////
 //////                       GLFW platform API                      //////
 //////////////////////////////////////////////////////////////////////////
 
-void _glfwPlatformSetCurrentContext(_GLFWwindow* context)
+void _glfwPlatformGetMonitorPos(_GLFWmonitor* monitor, int* xpos, int* ypos)
 {
-    TlsSetValue(_glfw.win32_tls.context, context);
 }
 
-_GLFWwindow* _glfwPlatformGetCurrentContext(void)
+void _glfwPlatformGetMonitorContentScale(_GLFWmonitor* monitor,
+                                         float* xscale, float* yscale)
+{
+    if (xscale)
+        *xscale = 1.f;
+    if (yscale)
+        *yscale = 1.f;
+}
+
+GLFWvidmode* _glfwPlatformGetVideoModes(_GLFWmonitor* monitor, int* found)
+{
+    return NULL;
+}
+
+void _glfwPlatformGetVideoMode(_GLFWmonitor* monitor, GLFWvidmode* mode)
+{
+}
+
+void _glfwPlatformGetGammaRamp(_GLFWmonitor* monitor, GLFWgammaramp* ramp)
+{
+}
+
+void _glfwPlatformSetGammaRamp(_GLFWmonitor* monitor, const GLFWgammaramp* ramp)
 {
-    return TlsGetValue(_glfw.win32_tls.context);
 }
 

raylib/external/glfw/src/null_platform.h

@@ -0,0 +1,62 @@
+//========================================================================
+// GLFW 3.3 - www.glfw.org
+//------------------------------------------------------------------------
+// Copyright (c) 2016 Google Inc.
+// Copyright (c) 2006-2016 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.
+//
+//========================================================================
+
+#include <dlfcn.h>
+
+#define _GLFW_PLATFORM_WINDOW_STATE _GLFWwindowNull null
+
+#define _GLFW_PLATFORM_CONTEXT_STATE
+#define _GLFW_PLATFORM_MONITOR_STATE
+#define _GLFW_PLATFORM_CURSOR_STATE
+#define _GLFW_PLATFORM_LIBRARY_WINDOW_STATE
+#define _GLFW_PLATFORM_LIBRARY_CONTEXT_STATE
+#define _GLFW_EGL_CONTEXT_STATE
+#define _GLFW_EGL_LIBRARY_CONTEXT_STATE
+
+#include "osmesa_context.h"
+#include "posix_time.h"
+#include "posix_thread.h"
+#include "null_joystick.h"
+
+#if defined(_GLFW_WIN32)
+ #define _glfw_dlopen(name) LoadLibraryA(name)
+ #define _glfw_dlclose(handle) FreeLibrary((HMODULE) handle)
+ #define _glfw_dlsym(handle, name) GetProcAddress((HMODULE) handle, name)
+#else
+ #define _glfw_dlopen(name) dlopen(name, RTLD_LAZY | RTLD_LOCAL)
+ #define _glfw_dlclose(handle) dlclose(handle)
+ #define _glfw_dlsym(handle, name) dlsym(handle, name)
+#endif
+
+// Null-specific per-window data
+//
+typedef struct _GLFWwindowNull
+{
+    int width;
+    int height;
+} _GLFWwindowNull;
+

raylib/external/glfw/src/null_window.c

@@ -0,0 +1,316 @@
+//========================================================================
+// GLFW 3.3 - www.glfw.org
+//------------------------------------------------------------------------
+// Copyright (c) 2016 Google Inc.
+// Copyright (c) 2006-2016 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.
+//
+//========================================================================
+
+#include "internal.h"
+
+
+static int createNativeWindow(_GLFWwindow* window,
+                              const _GLFWwndconfig* wndconfig)
+{
+    window->null.width = wndconfig->width;
+    window->null.height = wndconfig->height;
+
+    return GLFW_TRUE;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW platform API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+int _glfwPlatformCreateWindow(_GLFWwindow* window,
+                              const _GLFWwndconfig* wndconfig,
+                              const _GLFWctxconfig* ctxconfig,
+                              const _GLFWfbconfig* fbconfig)
+{
+    if (!createNativeWindow(window, wndconfig))
+        return GLFW_FALSE;
+
+    if (ctxconfig->client != GLFW_NO_API)
+    {
+        if (ctxconfig->source == GLFW_NATIVE_CONTEXT_API ||
+            ctxconfig->source == GLFW_OSMESA_CONTEXT_API)
+        {
+            if (!_glfwInitOSMesa())
+                return GLFW_FALSE;
+            if (!_glfwCreateContextOSMesa(window, ctxconfig, fbconfig))
+                return GLFW_FALSE;
+        }
+        else
+        {
+            _glfwInputError(GLFW_API_UNAVAILABLE, "Null: EGL not available");
+            return GLFW_FALSE;
+        }
+    }
+
+    return GLFW_TRUE;
+}
+
+void _glfwPlatformDestroyWindow(_GLFWwindow* window)
+{
+    if (window->context.destroy)
+        window->context.destroy(window);
+}
+
+void _glfwPlatformSetWindowTitle(_GLFWwindow* window, const char* title)
+{
+}
+
+void _glfwPlatformSetWindowIcon(_GLFWwindow* window, int count,
+                                const GLFWimage* images)
+{
+}
+
+void _glfwPlatformSetWindowMonitor(_GLFWwindow* window,
+                                   _GLFWmonitor* monitor,
+                                   int xpos, int ypos,
+                                   int width, int height,
+                                   int refreshRate)
+{
+}
+
+void _glfwPlatformGetWindowPos(_GLFWwindow* window, int* xpos, int* ypos)
+{
+}
+
+void _glfwPlatformSetWindowPos(_GLFWwindow* window, int xpos, int ypos)
+{
+}
+
+void _glfwPlatformGetWindowSize(_GLFWwindow* window, int* width, int* height)
+{
+    if (width)
+        *width = window->null.width;
+    if (height)
+        *height = window->null.height;
+}
+
+void _glfwPlatformSetWindowSize(_GLFWwindow* window, int width, int height)
+{
+    window->null.width = width;
+    window->null.height = height;
+}
+
+void _glfwPlatformSetWindowSizeLimits(_GLFWwindow* window,
+                                      int minwidth, int minheight,
+                                      int maxwidth, int maxheight)
+{
+}
+
+void _glfwPlatformSetWindowAspectRatio(_GLFWwindow* window, int n, int d)
+{
+}
+
+void _glfwPlatformGetFramebufferSize(_GLFWwindow* window, int* width, int* height)
+{
+    if (width)
+        *width = window->null.width;
+    if (height)
+        *height = window->null.height;
+}
+
+void _glfwPlatformGetWindowFrameSize(_GLFWwindow* window,
+                                     int* left, int* top,
+                                     int* right, int* bottom)
+{
+}
+
+void _glfwPlatformGetWindowContentScale(_GLFWwindow* window,
+                                        float* xscale, float* yscale)
+{
+    if (xscale)
+        *xscale = 1.f;
+    if (yscale)
+        *yscale = 1.f;
+}
+
+void _glfwPlatformIconifyWindow(_GLFWwindow* window)
+{
+}
+
+void _glfwPlatformRestoreWindow(_GLFWwindow* window)
+{
+}
+
+void _glfwPlatformMaximizeWindow(_GLFWwindow* window)
+{
+}
+
+int _glfwPlatformWindowMaximized(_GLFWwindow* window)
+{
+    return GLFW_FALSE;
+}
+
+int _glfwPlatformFramebufferTransparent(_GLFWwindow* window)
+{
+    return GLFW_FALSE;
+}
+
+void _glfwPlatformSetWindowResizable(_GLFWwindow* window, GLFWbool enabled)
+{
+}
+
+void _glfwPlatformSetWindowDecorated(_GLFWwindow* window, GLFWbool enabled)
+{
+}
+
+void _glfwPlatformSetWindowFloating(_GLFWwindow* window, GLFWbool enabled)
+{
+}
+
+float _glfwPlatformGetWindowOpacity(_GLFWwindow* window)
+{
+    return 1.f;
+}
+
+void _glfwPlatformSetWindowOpacity(_GLFWwindow* window, float opacity)
+{
+}
+
+void _glfwPlatformShowWindow(_GLFWwindow* window)
+{
+}
+
+
+void _glfwPlatformRequestWindowAttention(_GLFWwindow* window)
+{
+}
+
+void _glfwPlatformUnhideWindow(_GLFWwindow* window)
+{
+}
+
+void _glfwPlatformHideWindow(_GLFWwindow* window)
+{
+}
+
+void _glfwPlatformFocusWindow(_GLFWwindow* window)
+{
+}
+
+int _glfwPlatformWindowFocused(_GLFWwindow* window)
+{
+    return GLFW_FALSE;
+}
+
+int _glfwPlatformWindowIconified(_GLFWwindow* window)
+{
+    return GLFW_FALSE;
+}
+
+int _glfwPlatformWindowVisible(_GLFWwindow* window)
+{
+    return GLFW_FALSE;
+}
+
+void _glfwPlatformPollEvents(void)
+{
+}
+
+void _glfwPlatformWaitEvents(void)
+{
+}
+
+void _glfwPlatformWaitEventsTimeout(double timeout)
+{
+}
+
+void _glfwPlatformPostEmptyEvent(void)
+{
+}
+
+void _glfwPlatformGetCursorPos(_GLFWwindow* window, double* xpos, double* ypos)
+{
+}
+
+void _glfwPlatformSetCursorPos(_GLFWwindow* window, double x, double y)
+{
+}
+
+void _glfwPlatformSetCursorMode(_GLFWwindow* window, int mode)
+{
+}
+
+int _glfwPlatformCreateCursor(_GLFWcursor* cursor,
+                              const GLFWimage* image,
+                              int xhot, int yhot)
+{
+    return GLFW_TRUE;
+}
+
+int _glfwPlatformCreateStandardCursor(_GLFWcursor* cursor, int shape)
+{
+    return GLFW_TRUE;
+}
+
+void _glfwPlatformDestroyCursor(_GLFWcursor* cursor)
+{
+}
+
+void _glfwPlatformSetCursor(_GLFWwindow* window, _GLFWcursor* cursor)
+{
+}
+
+void _glfwPlatformSetClipboardString(const char* string)
+{
+}
+
+const char* _glfwPlatformGetClipboardString(void)
+{
+    return NULL;
+}
+
+const char* _glfwPlatformGetScancodeName(int scancode)
+{
+    return "";
+}
+
+int _glfwPlatformGetKeyScancode(int key)
+{
+    return -1;
+}
+
+void _glfwPlatformGetRequiredInstanceExtensions(char** extensions)
+{
+}
+
+int _glfwPlatformGetPhysicalDevicePresentationSupport(VkInstance instance,
+                                                      VkPhysicalDevice device,
+                                                      uint32_t queuefamily)
+{
+    return GLFW_FALSE;
+}
+
+VkResult _glfwPlatformCreateWindowSurface(VkInstance instance,
+                                          _GLFWwindow* window,
+                                          const VkAllocationCallbacks* allocator,
+                                          VkSurfaceKHR* surface)
+{
+    // This seems like the most appropriate error to return here
+    return VK_ERROR_INITIALIZATION_FAILED;
+}
+

raylib/external/glfw/src/osmesa_context.c

@@ -0,0 +1,370 @@
+//========================================================================
+// GLFW 3.3 OSMesa - www.glfw.org
+//------------------------------------------------------------------------
+// Copyright (c) 2016 Google Inc.
+// Copyright (c) 2006-2016 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.
+//
+//========================================================================
+
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+
+#include "internal.h"
+
+
+static void makeContextCurrentOSMesa(_GLFWwindow* window)
+{
+    if (window)
+    {
+        int width, height;
+        _glfwPlatformGetFramebufferSize(window, &width, &height);
+
+        // Check to see if we need to allocate a new buffer
+        if ((window->context.osmesa.buffer == NULL) ||
+            (width != window->context.osmesa.width) ||
+            (height != window->context.osmesa.height))
+        {
+            free(window->context.osmesa.buffer);
+
+            // Allocate the new buffer (width * height * 8-bit RGBA)
+            window->context.osmesa.buffer = calloc(4, width * height);
+            window->context.osmesa.width  = width;
+            window->context.osmesa.height = height;
+        }
+
+        if (!OSMesaMakeCurrent(window->context.osmesa.handle,
+                               window->context.osmesa.buffer,
+                               GL_UNSIGNED_BYTE,
+                               width, height))
+        {
+            _glfwInputError(GLFW_PLATFORM_ERROR,
+                            "OSMesa: Failed to make context current");
+            return;
+        }
+    }
+
+    _glfwPlatformSetTls(&_glfw.contextSlot, window);
+}
+
+static GLFWglproc getProcAddressOSMesa(const char* procname)
+{
+    return (GLFWglproc) OSMesaGetProcAddress(procname);
+}
+
+static void destroyContextOSMesa(_GLFWwindow* window)
+{
+    if (window->context.osmesa.handle)
+    {
+        OSMesaDestroyContext(window->context.osmesa.handle);
+        window->context.osmesa.handle = NULL;
+    }
+
+    if (window->context.osmesa.buffer)
+    {
+        free(window->context.osmesa.buffer);
+        window->context.osmesa.width = 0;
+        window->context.osmesa.height = 0;
+    }
+}
+
+static void swapBuffersOSMesa(_GLFWwindow* window)
+{
+    // No double buffering on OSMesa
+}
+
+static void swapIntervalOSMesa(int interval)
+{
+    // No swap interval on OSMesa
+}
+
+static int extensionSupportedOSMesa(const char* extension)
+{
+    // OSMesa does not have extensions
+    return GLFW_FALSE;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW internal API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+GLFWbool _glfwInitOSMesa(void)
+{
+    int i;
+    const char* sonames[] =
+    {
+#if defined(_GLFW_OSMESA_LIBRARY)
+        _GLFW_OSMESA_LIBRARY,
+#elif defined(_WIN32)
+        "libOSMesa.dll",
+        "OSMesa.dll",
+#elif defined(__APPLE__)
+        "libOSMesa.8.dylib",
+#elif defined(__CYGWIN__)
+        "libOSMesa-8.so",
+#else
+        "libOSMesa.so.8",
+        "libOSMesa.so.6",
+#endif
+        NULL
+    };
+
+    if (_glfw.osmesa.handle)
+        return GLFW_TRUE;
+
+    for (i = 0;  sonames[i];  i++)
+    {
+        _glfw.osmesa.handle = _glfw_dlopen(sonames[i]);
+        if (_glfw.osmesa.handle)
+            break;
+    }
+
+    if (!_glfw.osmesa.handle)
+    {
+        _glfwInputError(GLFW_API_UNAVAILABLE, "OSMesa: Library not found");
+        return GLFW_FALSE;
+    }
+
+    _glfw.osmesa.CreateContextExt = (PFN_OSMesaCreateContextExt)
+        _glfw_dlsym(_glfw.osmesa.handle, "OSMesaCreateContextExt");
+    _glfw.osmesa.CreateContextAttribs = (PFN_OSMesaCreateContextAttribs)
+        _glfw_dlsym(_glfw.osmesa.handle, "OSMesaCreateContextAttribs");
+    _glfw.osmesa.DestroyContext = (PFN_OSMesaDestroyContext)
+        _glfw_dlsym(_glfw.osmesa.handle, "OSMesaDestroyContext");
+    _glfw.osmesa.MakeCurrent = (PFN_OSMesaMakeCurrent)
+        _glfw_dlsym(_glfw.osmesa.handle, "OSMesaMakeCurrent");
+    _glfw.osmesa.GetColorBuffer = (PFN_OSMesaGetColorBuffer)
+        _glfw_dlsym(_glfw.osmesa.handle, "OSMesaGetColorBuffer");
+    _glfw.osmesa.GetDepthBuffer = (PFN_OSMesaGetDepthBuffer)
+        _glfw_dlsym(_glfw.osmesa.handle, "OSMesaGetDepthBuffer");
+    _glfw.osmesa.GetProcAddress = (PFN_OSMesaGetProcAddress)
+        _glfw_dlsym(_glfw.osmesa.handle, "OSMesaGetProcAddress");
+
+    if (!_glfw.osmesa.CreateContextExt ||
+        !_glfw.osmesa.DestroyContext ||
+        !_glfw.osmesa.MakeCurrent ||
+        !_glfw.osmesa.GetColorBuffer ||
+        !_glfw.osmesa.GetDepthBuffer ||
+        !_glfw.osmesa.GetProcAddress)
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "OSMesa: Failed to load required entry points");
+
+        _glfwTerminateOSMesa();
+        return GLFW_FALSE;
+    }
+
+    return GLFW_TRUE;
+}
+
+void _glfwTerminateOSMesa(void)
+{
+    if (_glfw.osmesa.handle)
+    {
+        _glfw_dlclose(_glfw.osmesa.handle);
+        _glfw.osmesa.handle = NULL;
+    }
+}
+
+#define setAttrib(a, v) \
+{ \
+    assert((size_t) (index + 1) < sizeof(attribs) / sizeof(attribs[0])); \
+    attribs[index++] = a; \
+    attribs[index++] = v; \
+}
+
+GLFWbool _glfwCreateContextOSMesa(_GLFWwindow* window,
+                                  const _GLFWctxconfig* ctxconfig,
+                                  const _GLFWfbconfig* fbconfig)
+{
+    OSMesaContext share = NULL;
+    const int accumBits = fbconfig->accumRedBits +
+                          fbconfig->accumGreenBits +
+                          fbconfig->accumBlueBits +
+                          fbconfig->accumAlphaBits;
+
+    if (ctxconfig->client == GLFW_OPENGL_ES_API)
+    {
+        _glfwInputError(GLFW_API_UNAVAILABLE,
+                        "OSMesa: OpenGL ES is not available on OSMesa");
+        return GLFW_FALSE;
+    }
+
+    if (ctxconfig->share)
+        share = ctxconfig->share->context.osmesa.handle;
+
+    if (OSMesaCreateContextAttribs)
+    {
+        int index = 0, attribs[40];
+
+        setAttrib(OSMESA_FORMAT, OSMESA_RGBA);
+        setAttrib(OSMESA_DEPTH_BITS, fbconfig->depthBits);
+        setAttrib(OSMESA_STENCIL_BITS, fbconfig->stencilBits);
+        setAttrib(OSMESA_ACCUM_BITS, accumBits);
+
+        if (ctxconfig->profile == GLFW_OPENGL_CORE_PROFILE)
+        {
+            setAttrib(OSMESA_PROFILE, OSMESA_CORE_PROFILE);
+        }
+        else if (ctxconfig->profile == GLFW_OPENGL_COMPAT_PROFILE)
+        {
+            setAttrib(OSMESA_PROFILE, OSMESA_COMPAT_PROFILE);
+        }
+
+        if (ctxconfig->major != 1 || ctxconfig->minor != 0)
+        {
+            setAttrib(OSMESA_CONTEXT_MAJOR_VERSION, ctxconfig->major);
+            setAttrib(OSMESA_CONTEXT_MINOR_VERSION, ctxconfig->minor);
+        }
+
+        if (ctxconfig->forward)
+        {
+            _glfwInputError(GLFW_VERSION_UNAVAILABLE,
+                            "OSMesa: Foward-compatible contexts not supported");
+            return GLFW_FALSE;
+        }
+
+        setAttrib(0, 0);
+
+        window->context.osmesa.handle =
+            OSMesaCreateContextAttribs(attribs, share);
+    }
+    else
+    {
+        if (ctxconfig->profile)
+        {
+            _glfwInputError(GLFW_VERSION_UNAVAILABLE,
+                            "OSMesa: OpenGL profiles unavailable");
+            return GLFW_FALSE;
+        }
+
+        window->context.osmesa.handle =
+            OSMesaCreateContextExt(OSMESA_RGBA,
+                                   fbconfig->depthBits,
+                                   fbconfig->stencilBits,
+                                   accumBits,
+                                   share);
+    }
+
+    if (window->context.osmesa.handle == NULL)
+    {
+        _glfwInputError(GLFW_VERSION_UNAVAILABLE,
+                        "OSMesa: Failed to create context");
+        return GLFW_FALSE;
+    }
+
+    window->context.makeCurrent = makeContextCurrentOSMesa;
+    window->context.swapBuffers = swapBuffersOSMesa;
+    window->context.swapInterval = swapIntervalOSMesa;
+    window->context.extensionSupported = extensionSupportedOSMesa;
+    window->context.getProcAddress = getProcAddressOSMesa;
+    window->context.destroy = destroyContextOSMesa;
+
+    return GLFW_TRUE;
+}
+
+#undef setAttrib
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                        GLFW native API                       //////
+//////////////////////////////////////////////////////////////////////////
+
+GLFWAPI int glfwGetOSMesaColorBuffer(GLFWwindow* handle, int* width,
+                                     int* height, int* format, void** buffer)
+{
+    void* mesaBuffer;
+    GLint mesaWidth, mesaHeight, mesaFormat;
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    assert(window != NULL);
+
+    _GLFW_REQUIRE_INIT_OR_RETURN(GLFW_FALSE);
+
+    if (!OSMesaGetColorBuffer(window->context.osmesa.handle,
+                              &mesaWidth, &mesaHeight,
+                              &mesaFormat, &mesaBuffer))
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "OSMesa: Failed to retrieve color buffer");
+        return GLFW_FALSE;
+    }
+
+    if (width)
+        *width = mesaWidth;
+    if (height)
+        *height = mesaHeight;
+    if (format)
+        *format = mesaFormat;
+    if (buffer)
+        *buffer = mesaBuffer;
+
+    return GLFW_TRUE;
+}
+
+GLFWAPI int glfwGetOSMesaDepthBuffer(GLFWwindow* handle,
+                                     int* width, int* height,
+                                     int* bytesPerValue,
+                                     void** buffer)
+{
+    void* mesaBuffer;
+    GLint mesaWidth, mesaHeight, mesaBytes;
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    assert(window != NULL);
+
+    _GLFW_REQUIRE_INIT_OR_RETURN(GLFW_FALSE);
+
+    if (!OSMesaGetDepthBuffer(window->context.osmesa.handle,
+                              &mesaWidth, &mesaHeight,
+                              &mesaBytes, &mesaBuffer))
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "OSMesa: Failed to retrieve depth buffer");
+        return GLFW_FALSE;
+    }
+
+    if (width)
+        *width = mesaWidth;
+    if (height)
+        *height = mesaHeight;
+    if (bytesPerValue)
+        *bytesPerValue = mesaBytes;
+    if (buffer)
+        *buffer = mesaBuffer;
+
+    return GLFW_TRUE;
+}
+
+GLFWAPI OSMesaContext glfwGetOSMesaContext(GLFWwindow* handle)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+
+    if (window->context.client == GLFW_NO_API)
+    {
+        _glfwInputError(GLFW_NO_WINDOW_CONTEXT, NULL);
+        return NULL;
+    }
+
+    return window->context.osmesa.handle;
+}
+

raylib/external/glfw/src/osmesa_context.h

@@ -0,0 +1,94 @@
+//========================================================================
+// GLFW 3.3 OSMesa - www.glfw.org
+//------------------------------------------------------------------------
+// Copyright (c) 2016 Google Inc.
+// Copyright (c) 2006-2016 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.
+//
+//========================================================================
+
+#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 _GLFW_OSMESA_CONTEXT_STATE              _GLFWcontextOSMesa osmesa
+#define _GLFW_OSMESA_LIBRARY_CONTEXT_STATE      _GLFWlibraryOSMesa osmesa
+
+
+// OSMesa-specific per-context data
+//
+typedef struct _GLFWcontextOSMesa
+{
+    OSMesaContext       handle;
+    int                 width;
+    int                 height;
+    void*               buffer;
+
+} _GLFWcontextOSMesa;
+
+// OSMesa-specific global data
+//
+typedef struct _GLFWlibraryOSMesa
+{
+    void*           handle;
+
+    PFN_OSMesaCreateContextExt      CreateContextExt;
+    PFN_OSMesaCreateContextAttribs  CreateContextAttribs;
+    PFN_OSMesaDestroyContext        DestroyContext;
+    PFN_OSMesaMakeCurrent           MakeCurrent;
+    PFN_OSMesaGetColorBuffer        GetColorBuffer;
+    PFN_OSMesaGetDepthBuffer        GetDepthBuffer;
+    PFN_OSMesaGetProcAddress        GetProcAddress;
+
+} _GLFWlibraryOSMesa;
+
+
+GLFWbool _glfwInitOSMesa(void);
+void _glfwTerminateOSMesa(void);
+GLFWbool _glfwCreateContextOSMesa(_GLFWwindow* window,
+                                  const _GLFWctxconfig* ctxconfig,
+                                  const _GLFWfbconfig* fbconfig);
+

raylib/external/glfw/src/posix_thread.c

@@ -0,0 +1,103 @@
+//========================================================================
+// GLFW 3.3 POSIX - www.glfw.org
+//------------------------------------------------------------------------
+// Copyright (c) 2002-2006 Marcus Geelnard
+// Copyright (c) 2006-2016 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.
+//
+//========================================================================
+
+#include "internal.h"
+
+#include <assert.h>
+#include <string.h>
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW platform API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+GLFWbool _glfwPlatformCreateTls(_GLFWtls* tls)
+{
+    assert(tls->posix.allocated == GLFW_FALSE);
+
+    if (pthread_key_create(&tls->posix.key, NULL) != 0)
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "POSIX: Failed to create context TLS");
+        return GLFW_FALSE;
+    }
+
+    tls->posix.allocated = GLFW_TRUE;
+    return GLFW_TRUE;
+}
+
+void _glfwPlatformDestroyTls(_GLFWtls* tls)
+{
+    if (tls->posix.allocated)
+        pthread_key_delete(tls->posix.key);
+    memset(tls, 0, sizeof(_GLFWtls));
+}
+
+void* _glfwPlatformGetTls(_GLFWtls* tls)
+{
+    assert(tls->posix.allocated == GLFW_TRUE);
+    return pthread_getspecific(tls->posix.key);
+}
+
+void _glfwPlatformSetTls(_GLFWtls* tls, void* value)
+{
+    assert(tls->posix.allocated == GLFW_TRUE);
+    pthread_setspecific(tls->posix.key, value);
+}
+
+GLFWbool _glfwPlatformCreateMutex(_GLFWmutex* mutex)
+{
+    assert(mutex->posix.allocated == GLFW_FALSE);
+
+    if (pthread_mutex_init(&mutex->posix.handle, NULL) != 0)
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR, "POSIX: Failed to create mutex");
+        return GLFW_FALSE;
+    }
+
+    return mutex->posix.allocated = GLFW_TRUE;
+}
+
+void _glfwPlatformDestroyMutex(_GLFWmutex* mutex)
+{
+    if (mutex->posix.allocated)
+        pthread_mutex_destroy(&mutex->posix.handle);
+    memset(mutex, 0, sizeof(_GLFWmutex));
+}
+
+void _glfwPlatformLockMutex(_GLFWmutex* mutex)
+{
+    assert(mutex->posix.allocated == GLFW_TRUE);
+    pthread_mutex_lock(&mutex->posix.handle);
+}
+
+void _glfwPlatformUnlockMutex(_GLFWmutex* mutex)
+{
+    assert(mutex->posix.allocated == GLFW_TRUE);
+    pthread_mutex_unlock(&mutex->posix.handle);
+}
+

raylib/external/glfw/src/posix_thread.h

@@ -1,8 +1,8 @@
 //========================================================================
-// GLFW 3.2 POSIX - www.glfw.org
+// GLFW 3.3 POSIX - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-2016 Camilla Berglund <elmindreda@glfw.org>
+// Copyright (c) 2006-2016 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
@@ -25,25 +25,27 @@
 //
 //========================================================================
 
-#ifndef _glfw3_posix_tls_h_
-#define _glfw3_posix_tls_h_
-
 #include <pthread.h>
 
-#define _GLFW_PLATFORM_LIBRARY_TLS_STATE _GLFWtlsPOSIX posix_tls
+#define _GLFW_PLATFORM_TLS_STATE    _GLFWtlsPOSIX   posix
+#define _GLFW_PLATFORM_MUTEX_STATE  _GLFWmutexPOSIX posix
 
 
-// POSIX-specific global TLS data
+// POSIX-specific thread local storage data
 //
 typedef struct _GLFWtlsPOSIX
 {
     GLFWbool        allocated;
-    pthread_key_t   context;
+    pthread_key_t   key;
 
 } _GLFWtlsPOSIX;
 
+// POSIX-specific mutex data
+//
+typedef struct _GLFWmutexPOSIX
+{
+    GLFWbool        allocated;
+    pthread_mutex_t handle;
 
-GLFWbool _glfwInitThreadLocalStoragePOSIX(void);
+} _GLFWmutexPOSIX;
-void _glfwTerminateThreadLocalStoragePOSIX(void);
 
-#endif // _glfw3_posix_tls_h_

raylib/external/glfw/src/posix_time.c

@@ -1,8 +1,8 @@
 //========================================================================
-// GLFW 3.2 POSIX - www.glfw.org
+// GLFW 3.3 POSIX - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-2016 Camilla Berglund <elmindreda@glfw.org>
+// Copyright (c) 2006-2016 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
@@ -44,14 +44,14 @@ void _glfwInitTimerPOSIX(void)
 
     if (clock_gettime(CLOCK_MONOTONIC, &ts) == 0)
     {
-        _glfw.posix_time.monotonic = GLFW_TRUE;
+        _glfw.timer.posix.monotonic = GLFW_TRUE;
-        _glfw.posix_time.frequency = 1000000000;
+        _glfw.timer.posix.frequency = 1000000000;
     }
     else
 #endif
     {
-        _glfw.posix_time.monotonic = GLFW_FALSE;
+        _glfw.timer.posix.monotonic = GLFW_FALSE;
-        _glfw.posix_time.frequency = 1000000;
+        _glfw.timer.posix.frequency = 1000000;
     }
 }
 
@@ -63,7 +63,7 @@ void _glfwInitTimerPOSIX(void)
 uint64_t _glfwPlatformGetTimerValue(void)
 {
 #if defined(CLOCK_MONOTONIC)
-    if (_glfw.posix_time.monotonic)
+    if (_glfw.timer.posix.monotonic)
     {
         struct timespec ts;
         clock_gettime(CLOCK_MONOTONIC, &ts);
@@ -80,6 +80,6 @@ uint64_t _glfwPlatformGetTimerValue(void)
 
 uint64_t _glfwPlatformGetTimerFrequency(void)
 {
-    return _glfw.posix_time.frequency;
+    return _glfw.timer.posix.frequency;
 }
 

raylib/external/glfw/src/posix_time.h

@@ -1,8 +1,8 @@
 //========================================================================
-// GLFW 3.2 POSIX - www.glfw.org
+// GLFW 3.3 POSIX - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-2016 Camilla Berglund <elmindreda@glfw.org>
+// Copyright (c) 2006-2016 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
@@ -25,24 +25,20 @@
 //
 //========================================================================
 
-#ifndef _glfw3_posix_time_h_
+#define _GLFW_PLATFORM_LIBRARY_TIMER_STATE _GLFWtimerPOSIX posix
-#define _glfw3_posix_time_h_
-
-#define _GLFW_PLATFORM_LIBRARY_TIME_STATE _GLFWtimePOSIX posix_time
 
 #include <stdint.h>
 
 
 // POSIX-specific global timer data
 //
-typedef struct _GLFWtimePOSIX
+typedef struct _GLFWtimerPOSIX
 {
     GLFWbool    monotonic;
     uint64_t    frequency;
 
-} _GLFWtimePOSIX;
+} _GLFWtimerPOSIX;
 
 
 void _glfwInitTimerPOSIX(void);
 
-#endif // _glfw3_posix_time_h_

raylib/external/glfw/src/vulkan.c

@@ -1,8 +1,8 @@
 //========================================================================
-// GLFW 3.2 - www.glfw.org
+// GLFW 3.3 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-2016 Camilla Berglund <elmindreda@glfw.org>
+// Copyright (c) 2006-2016 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
@@ -31,30 +31,40 @@
 #include <string.h>
 #include <stdlib.h>
 
+#define _GLFW_FIND_LOADER    1
+#define _GLFW_REQUIRE_LOADER 2
+
 
 //////////////////////////////////////////////////////////////////////////
 //////                       GLFW internal API                      //////
 //////////////////////////////////////////////////////////////////////////
 
-GLFWbool _glfwInitVulkan(void)
+GLFWbool _glfwInitVulkan(int mode)
 {
     VkResult err;
     VkExtensionProperties* ep;
     uint32_t i, count;
 
-#if !defined(_GLFW_VULKAN_STATIC)
-#if defined(_GLFW_WIN32)
-    const char* name = "vulkan-1.dll";
-#else
-    const char* name = "libvulkan.so.1";
-#endif
-
     if (_glfw.vk.available)
         return GLFW_TRUE;
 
-    _glfw.vk.handle = _glfw_dlopen(name);
+#if !defined(_GLFW_VULKAN_STATIC)
+#if defined(_GLFW_VULKAN_LIBRARY)
+    _glfw.vk.handle = _glfw_dlopen(_GLFW_VULKAN_LIBRARY);
+#elif defined(_GLFW_WIN32)
+    _glfw.vk.handle = _glfw_dlopen("vulkan-1.dll");
+#elif defined(_GLFW_COCOA)
+    _glfw.vk.handle = _glfw_dlopen("libMoltenVK.dylib");
+#else
+    _glfw.vk.handle = _glfw_dlopen("libvulkan.so.1");
+#endif
     if (!_glfw.vk.handle)
+    {
+        if (mode == _GLFW_REQUIRE_LOADER)
+            _glfwInputError(GLFW_API_UNAVAILABLE, "Vulkan: Loader not found");
+
         return GLFW_FALSE;
+    }
 
     _glfw.vk.GetInstanceProcAddr = (PFN_vkGetInstanceProcAddr)
         _glfw_dlsym(_glfw.vk.handle, "vkGetInstanceProcAddr");
@@ -82,9 +92,13 @@ GLFWbool _glfwInitVulkan(void)
     err = vkEnumerateInstanceExtensionProperties(NULL, &count, NULL);
     if (err)
     {
-        _glfwInputError(GLFW_PLATFORM_ERROR,
+        // NOTE: This happens on systems with a loader but without any Vulkan ICD
-                        "Vulkan: Failed to query instance extension count: %s",
+        if (mode == _GLFW_REQUIRE_LOADER)
-                        _glfwGetVulkanResultString(err));
+        {
+            _glfwInputError(GLFW_API_UNAVAILABLE,
+                            "Vulkan: Failed to query instance extension count: %s",
+                            _glfwGetVulkanResultString(err));
+        }
 
         _glfwTerminateVulkan();
         return GLFW_FALSE;
@@ -95,7 +109,7 @@ GLFWbool _glfwInitVulkan(void)
     err = vkEnumerateInstanceExtensionProperties(NULL, &count, ep);
     if (err)
     {
-        _glfwInputError(GLFW_PLATFORM_ERROR,
+        _glfwInputError(GLFW_API_UNAVAILABLE,
                         "Vulkan: Failed to query instance extensions: %s",
                         _glfwGetVulkanResultString(err));
 
@@ -108,41 +122,41 @@ GLFWbool _glfwInitVulkan(void)
     {
         if (strcmp(ep[i].extensionName, "VK_KHR_surface") == 0)
             _glfw.vk.KHR_surface = GLFW_TRUE;
-        if (strcmp(ep[i].extensionName, "VK_KHR_win32_surface") == 0)
+#if defined(_GLFW_WIN32)
+        else if (strcmp(ep[i].extensionName, "VK_KHR_win32_surface") == 0)
             _glfw.vk.KHR_win32_surface = GLFW_TRUE;
-        if (strcmp(ep[i].extensionName, "VK_KHR_xlib_surface") == 0)
+#elif defined(_GLFW_COCOA)
+        else if (strcmp(ep[i].extensionName, "VK_MVK_macos_surface") == 0)
+            _glfw.vk.MVK_macos_surface = GLFW_TRUE;
+#elif defined(_GLFW_X11)
+        else if (strcmp(ep[i].extensionName, "VK_KHR_xlib_surface") == 0)
             _glfw.vk.KHR_xlib_surface = GLFW_TRUE;
-        if (strcmp(ep[i].extensionName, "VK_KHR_xcb_surface") == 0)
+        else if (strcmp(ep[i].extensionName, "VK_KHR_xcb_surface") == 0)
             _glfw.vk.KHR_xcb_surface = GLFW_TRUE;
-        if (strcmp(ep[i].extensionName, "VK_KHR_wayland_surface") == 0)
+#elif defined(_GLFW_WAYLAND)
+        else if (strcmp(ep[i].extensionName, "VK_KHR_wayland_surface") == 0)
             _glfw.vk.KHR_wayland_surface = GLFW_TRUE;
-        if (strcmp(ep[i].extensionName, "VK_KHR_mir_surface") == 0)
+#elif defined(_GLFW_MIR)
+        else if (strcmp(ep[i].extensionName, "VK_KHR_mir_surface") == 0)
             _glfw.vk.KHR_mir_surface = GLFW_TRUE;
+#endif
     }
 
     free(ep);
 
     _glfw.vk.available = GLFW_TRUE;
 
-    if (_glfw.vk.KHR_surface)
+    _glfwPlatformGetRequiredInstanceExtensions(_glfw.vk.extensions);
-    {
-        _glfw.vk.extensions =
-            _glfwPlatformGetRequiredInstanceExtensions(&_glfw.vk.extensionCount);
-    }
 
     return GLFW_TRUE;
 }
 
 void _glfwTerminateVulkan(void)
 {
-    uint32_t i;
+#if !defined(_GLFW_VULKAN_STATIC)
-
-    for (i = 0;  i < _glfw.vk.extensionCount;  i++)
-        free(_glfw.vk.extensions[i]);
-    free(_glfw.vk.extensions);
-
     if (_glfw.vk.handle)
         _glfw_dlclose(_glfw.vk.handle);
+#endif
 }
 
 const char* _glfwGetVulkanResultString(VkResult result)
@@ -208,22 +222,24 @@ const char* _glfwGetVulkanResultString(VkResult result)
 GLFWAPI int glfwVulkanSupported(void)
 {
     _GLFW_REQUIRE_INIT_OR_RETURN(GLFW_FALSE);
-    return _glfwInitVulkan();
+    return _glfwInitVulkan(_GLFW_FIND_LOADER);
 }
 
 GLFWAPI const char** glfwGetRequiredInstanceExtensions(uint32_t* count)
 {
+    assert(count != NULL);
+
     *count = 0;
 
     _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
 
-    if (!_glfwInitVulkan())
+    if (!_glfwInitVulkan(_GLFW_REQUIRE_LOADER))
-    {
-        _glfwInputError(GLFW_API_UNAVAILABLE, "Vulkan: API not available");
         return NULL;
-    }
 
-    *count = _glfw.vk.extensionCount;
+    if (!_glfw.vk.extensions[0])
+        return NULL;
+
+    *count = 2;
     return (const char**) _glfw.vk.extensions;
 }
 
@@ -231,18 +247,24 @@ GLFWAPI GLFWvkproc glfwGetInstanceProcAddress(VkInstance instance,
                                               const char* procname)
 {
     GLFWvkproc proc;
+    assert(procname != NULL);
 
     _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
 
-    if (!_glfwInitVulkan())
+    if (!_glfwInitVulkan(_GLFW_REQUIRE_LOADER))
-    {
-        _glfwInputError(GLFW_API_UNAVAILABLE, "Vulkan: API not available");
         return NULL;
-    }
 
     proc = (GLFWvkproc) vkGetInstanceProcAddr(instance, procname);
+#if defined(_GLFW_VULKAN_STATIC)
+    if (!proc)
+    {
+        if (strcmp(procname, "vkGetInstanceProcAddr") == 0)
+            return (GLFWvkproc) vkGetInstanceProcAddr;
+    }
+#else
     if (!proc)
         proc = (GLFWvkproc) _glfw_dlsym(_glfw.vk.handle, procname);
+#endif
 
     return proc;
 }
@@ -251,15 +273,15 @@ GLFWAPI int glfwGetPhysicalDevicePresentationSupport(VkInstance instance,
                                                      VkPhysicalDevice device,
                                                      uint32_t queuefamily)
 {
+    assert(instance != VK_NULL_HANDLE);
+    assert(device != VK_NULL_HANDLE);
+
     _GLFW_REQUIRE_INIT_OR_RETURN(GLFW_FALSE);
 
-    if (!_glfwInitVulkan())
+    if (!_glfwInitVulkan(_GLFW_REQUIRE_LOADER))
-    {
-        _glfwInputError(GLFW_API_UNAVAILABLE, "Vulkan: API not available");
         return GLFW_FALSE;
-    }
 
-    if (!_glfw.vk.extensions)
+    if (!_glfw.vk.extensions[0])
     {
         _glfwInputError(GLFW_API_UNAVAILABLE,
                         "Vulkan: Window surface creation extensions not found");
@@ -277,6 +299,7 @@ GLFWAPI VkResult glfwCreateWindowSurface(VkInstance instance,
                                          VkSurfaceKHR* surface)
 {
     _GLFWwindow* window = (_GLFWwindow*) handle;
+    assert(instance != VK_NULL_HANDLE);
     assert(window != NULL);
     assert(surface != NULL);
 
@@ -284,13 +307,10 @@ GLFWAPI VkResult glfwCreateWindowSurface(VkInstance instance,
 
     _GLFW_REQUIRE_INIT_OR_RETURN(VK_ERROR_INITIALIZATION_FAILED);
 
-    if (!_glfwInitVulkan())
+    if (!_glfwInitVulkan(_GLFW_REQUIRE_LOADER))
-    {
-        _glfwInputError(GLFW_API_UNAVAILABLE, "Vulkan: API not available");
         return VK_ERROR_INITIALIZATION_FAILED;
-    }
 
-    if (!_glfw.vk.extensions)
+    if (!_glfw.vk.extensions[0])
     {
         _glfwInputError(GLFW_API_UNAVAILABLE,
                         "Vulkan: Window surface creation extensions not found");

raylib/external/glfw/src/wgl_context.c

@@ -1,8 +1,8 @@
 //========================================================================
-// GLFW 3.2 WGL - www.glfw.org
+// GLFW 3.3 WGL - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-2016 Camilla Berglund <elmindreda@glfw.org>
+// Copyright (c) 2006-2016 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
@@ -44,9 +44,8 @@ static int getPixelFormatAttrib(_GLFWwindow* window, int pixelFormat, int attrib
                                              pixelFormat,
                                              0, 1, &attrib, &value))
     {
-        _glfwInputError(GLFW_PLATFORM_ERROR,
+        _glfwInputErrorWin32(GLFW_PLATFORM_ERROR,
-                        "WGL: Failed to retrieve pixel format attribute %i",
+                             "WGL: Failed to retrieve pixel format attribute");
-                        attrib);
         return 0;
     }
 
@@ -55,7 +54,9 @@ static int getPixelFormatAttrib(_GLFWwindow* window, int pixelFormat, int attrib
 
 // Return a list of available and usable framebuffer configs
 //
-static int choosePixelFormat(_GLFWwindow* window, const _GLFWfbconfig* desired)
+static int choosePixelFormat(_GLFWwindow* window,
+                             const _GLFWctxconfig* ctxconfig,
+                             const _GLFWfbconfig* fbconfig)
 {
     _GLFWfbconfig* usableConfigs;
     const _GLFWfbconfig* closest;
@@ -128,19 +129,33 @@ static int choosePixelFormat(_GLFWwindow* window, const _GLFWfbconfig* desired)
             if (_glfw.wgl.ARB_multisample)
                 u->samples = getPixelFormatAttrib(window, n, WGL_SAMPLES_ARB);
 
-            if (_glfw.wgl.ARB_framebuffer_sRGB ||
+            if (ctxconfig->client == GLFW_OPENGL_API)
-                _glfw.wgl.EXT_framebuffer_sRGB)
             {
-                if (getPixelFormatAttrib(window, n, WGL_FRAMEBUFFER_SRGB_CAPABLE_ARB))
+                if (_glfw.wgl.ARB_framebuffer_sRGB ||
-                    u->sRGB = GLFW_TRUE;
+                    _glfw.wgl.EXT_framebuffer_sRGB)
+                {
+                    if (getPixelFormatAttrib(window, n, WGL_FRAMEBUFFER_SRGB_CAPABLE_ARB))
+                        u->sRGB = GLFW_TRUE;
+                }
+            }
+            else
+            {
+                if (_glfw.wgl.EXT_colorspace)
+                {
+                    if (getPixelFormatAttrib(window, n, WGL_COLORSPACE_EXT) ==
+                        WGL_COLORSPACE_SRGB_EXT)
+                    {
+                        u->sRGB = GLFW_TRUE;
+                    }
+                }
             }
         }
         else
         {
-            PIXELFORMATDESCRIPTOR pfd;
-
             // Get pixel format attributes through legacy PFDs
 
+            PIXELFORMATDESCRIPTOR pfd;
+
             if (!DescribePixelFormat(window->context.wgl.dc,
                                      n,
                                      sizeof(PIXELFORMATDESCRIPTOR),
@@ -198,7 +213,7 @@ static int choosePixelFormat(_GLFWwindow* window, const _GLFWfbconfig* desired)
         return 0;
     }
 
-    closest = _glfwChooseFBConfig(desired, usableConfigs, usableCount);
+    closest = _glfwChooseFBConfig(fbconfig, usableConfigs, usableCount);
     if (!closest)
     {
         _glfwInputError(GLFW_FORMAT_UNAVAILABLE,
@@ -214,54 +229,39 @@ static int choosePixelFormat(_GLFWwindow* window, const _GLFWfbconfig* desired)
     return pixelFormat;
 }
 
-// Returns whether desktop compositing is enabled
-//
-static GLFWbool isCompositionEnabled(void)
-{
-    BOOL enabled;
-
-    if (!_glfw_DwmIsCompositionEnabled)
-        return FALSE;
-
-    if (_glfw_DwmIsCompositionEnabled(&enabled) != S_OK)
-        return FALSE;
-
-    return enabled;
-}
-
 static void makeContextCurrentWGL(_GLFWwindow* window)
 {
     if (window)
     {
         if (wglMakeCurrent(window->context.wgl.dc, window->context.wgl.handle))
-            _glfwPlatformSetCurrentContext(window);
+            _glfwPlatformSetTls(&_glfw.contextSlot, window);
         else
         {
-            _glfwInputError(GLFW_PLATFORM_ERROR,
+            _glfwInputErrorWin32(GLFW_PLATFORM_ERROR,
-                            "WGL: Failed to make context current");
+                                 "WGL: Failed to make context current");
-            _glfwPlatformSetCurrentContext(NULL);
+            _glfwPlatformSetTls(&_glfw.contextSlot, NULL);
         }
     }
     else
     {
         if (!wglMakeCurrent(NULL, NULL))
         {
-            _glfwInputError(GLFW_PLATFORM_ERROR,
+            _glfwInputErrorWin32(GLFW_PLATFORM_ERROR,
-                            "WGL: Failed to clear current context");
+                                 "WGL: Failed to clear current context");
         }
 
-        _glfwPlatformSetCurrentContext(NULL);
+        _glfwPlatformSetTls(&_glfw.contextSlot, NULL);
     }
 }
 
 static void swapBuffersWGL(_GLFWwindow* window)
 {
     // HACK: Use DwmFlush when desktop composition is enabled
-    if (isCompositionEnabled() && !window->monitor)
+    if (_glfwIsCompositionEnabledWin32() && !window->monitor)
     {
         int count = abs(window->context.wgl.interval);
         while (count--)
-            _glfw_DwmFlush();
+            DwmFlush();
     }
 
     SwapBuffers(window->context.wgl.dc);
@@ -269,13 +269,13 @@ static void swapBuffersWGL(_GLFWwindow* window)
 
 static void swapIntervalWGL(int interval)
 {
-    _GLFWwindow* window = _glfwPlatformGetCurrentContext();
+    _GLFWwindow* window = _glfwPlatformGetTls(&_glfw.contextSlot);
 
     window->context.wgl.interval = interval;
 
     // HACK: Disable WGL swap interval when desktop composition is enabled to
     //       avoid interfering with DWM vsync
-    if (isCompositionEnabled() && !window->monitor)
+    if (_glfwIsCompositionEnabledWin32() && !window->monitor)
         interval = 0;
 
     if (_glfw.wgl.EXT_swap_control)
@@ -353,25 +353,24 @@ static void loadWGLExtensions(void)
 
     if (!SetPixelFormat(dc, ChoosePixelFormat(dc, &pfd), &pfd))
     {
-        _glfwInputError(GLFW_PLATFORM_ERROR,
+        _glfwInputErrorWin32(GLFW_PLATFORM_ERROR,
-                        "WGL: Failed to set pixel format for dummy context");
+                             "WGL: Failed to set pixel format for dummy context");
         return;
     }
 
     rc = wglCreateContext(dc);
     if (!rc)
     {
-        _glfwInputError(GLFW_PLATFORM_ERROR,
+        _glfwInputErrorWin32(GLFW_PLATFORM_ERROR,
-                        "WGL: Failed to create dummy context");
+                             "WGL: Failed to create dummy context");
         return;
     }
 
     if (!wglMakeCurrent(dc, rc))
     {
+        _glfwInputErrorWin32(GLFW_PLATFORM_ERROR,
+                             "WGL: Failed to make dummy context current");
         wglDeleteContext(rc);
-
-        _glfwInputError(GLFW_PLATFORM_ERROR,
-                        "WGL: Failed to make dummy context current");
         return;
     }
 
@@ -404,8 +403,12 @@ static void loadWGLExtensions(void)
         extensionSupportedWGL("WGL_EXT_create_context_es2_profile");
     _glfw.wgl.ARB_create_context_robustness =
         extensionSupportedWGL("WGL_ARB_create_context_robustness");
+    _glfw.wgl.ARB_create_context_no_error =
+        extensionSupportedWGL("WGL_ARB_create_context_no_error");
     _glfw.wgl.EXT_swap_control =
         extensionSupportedWGL("WGL_EXT_swap_control");
+    _glfw.wgl.EXT_colorspace =
+        extensionSupportedWGL("WGL_EXT_colorspace");
     _glfw.wgl.ARB_pixel_format =
         extensionSupportedWGL("WGL_ARB_pixel_format");
     _glfw.wgl.ARB_context_flush_control =
@@ -430,21 +433,22 @@ GLFWbool _glfwInitWGL(void)
     _glfw.wgl.instance = LoadLibraryA("opengl32.dll");
     if (!_glfw.wgl.instance)
     {
-        _glfwInputError(GLFW_PLATFORM_ERROR, "WGL: Failed to load opengl32.dll");
+        _glfwInputErrorWin32(GLFW_PLATFORM_ERROR,
+                             "WGL: Failed to load opengl32.dll");
         return GLFW_FALSE;
     }
 
-    _glfw.wgl.CreateContext = (WGLCREATECONTEXT_T)
+    _glfw.wgl.CreateContext = (PFN_wglCreateContext)
         GetProcAddress(_glfw.wgl.instance, "wglCreateContext");
-    _glfw.wgl.DeleteContext = (WGLDELETECONTEXT_T)
+    _glfw.wgl.DeleteContext = (PFN_wglDeleteContext)
         GetProcAddress(_glfw.wgl.instance, "wglDeleteContext");
-    _glfw.wgl.GetProcAddress = (WGLGETPROCADDRESS_T)
+    _glfw.wgl.GetProcAddress = (PFN_wglGetProcAddress)
         GetProcAddress(_glfw.wgl.instance, "wglGetProcAddress");
-    _glfw.wgl.GetCurrentDC = (WGLGETCURRENTDC_T)
+    _glfw.wgl.GetCurrentDC = (PFN_wglGetCurrentDC)
         GetProcAddress(_glfw.wgl.instance, "wglGetCurrentDC");
-    _glfw.wgl.MakeCurrent = (WGLMAKECURRENT_T)
+    _glfw.wgl.MakeCurrent = (PFN_wglMakeCurrent)
         GetProcAddress(_glfw.wgl.instance, "wglMakeCurrent");
-    _glfw.wgl.ShareLists = (WGLSHARELISTS_T)
+    _glfw.wgl.ShareLists = (PFN_wglShareLists)
         GetProcAddress(_glfw.wgl.instance, "wglShareLists");
 
     return GLFW_TRUE;
@@ -458,11 +462,11 @@ void _glfwTerminateWGL(void)
         FreeLibrary(_glfw.wgl.instance);
 }
 
-#define setWGLattrib(attribName, attribValue) \
+#define setAttrib(a, v) \
 { \
-    attribs[index++] = attribName; \
+    assert((size_t) (index + 1) < sizeof(attribs) / sizeof(attribs[0])); \
-    attribs[index++] = attribValue; \
+    attribs[index++] = a; \
-    assert((size_t) index < sizeof(attribs) / sizeof(attribs[0])); \
+    attribs[index++] = v; \
 }
 
 // Create the OpenGL or OpenGL ES context
@@ -490,22 +494,22 @@ GLFWbool _glfwCreateContextWGL(_GLFWwindow* window,
         return GLFW_FALSE;
     }
 
-    pixelFormat = choosePixelFormat(window, fbconfig);
+    pixelFormat = choosePixelFormat(window, ctxconfig, fbconfig);
     if (!pixelFormat)
         return GLFW_FALSE;
 
     if (!DescribePixelFormat(window->context.wgl.dc,
                              pixelFormat, sizeof(pfd), &pfd))
     {
-        _glfwInputError(GLFW_PLATFORM_ERROR,
+        _glfwInputErrorWin32(GLFW_PLATFORM_ERROR,
-                        "WGL: Failed to retrieve PFD for selected pixel format");
+                             "WGL: Failed to retrieve PFD for selected pixel format");
         return GLFW_FALSE;
     }
 
     if (!SetPixelFormat(window->context.wgl.dc, pixelFormat, &pfd))
     {
-        _glfwInputError(GLFW_PLATFORM_ERROR,
+        _glfwInputErrorWin32(GLFW_PLATFORM_ERROR,
-                        "WGL: Failed to set selected pixel format");
+                             "WGL: Failed to set selected pixel format");
         return GLFW_FALSE;
     }
 
@@ -562,8 +566,6 @@ GLFWbool _glfwCreateContextWGL(_GLFWwindow* window,
 
         if (ctxconfig->debug)
             flags |= WGL_CONTEXT_DEBUG_BIT_ARB;
-        if (ctxconfig->noerror)
-            flags |= GL_CONTEXT_FLAG_NO_ERROR_BIT_KHR;
 
         if (ctxconfig->robustness)
         {
@@ -571,13 +573,13 @@ GLFWbool _glfwCreateContextWGL(_GLFWwindow* window,
             {
                 if (ctxconfig->robustness == GLFW_NO_RESET_NOTIFICATION)
                 {
-                    setWGLattrib(WGL_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB,
+                    setAttrib(WGL_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB,
-                                 WGL_NO_RESET_NOTIFICATION_ARB);
+                              WGL_NO_RESET_NOTIFICATION_ARB);
                 }
                 else if (ctxconfig->robustness == GLFW_LOSE_CONTEXT_ON_RESET)
                 {
-                    setWGLattrib(WGL_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB,
+                    setAttrib(WGL_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB,
-                                 WGL_LOSE_CONTEXT_ON_RESET_ARB);
+                              WGL_LOSE_CONTEXT_ON_RESET_ARB);
                 }
 
                 flags |= WGL_CONTEXT_ROBUST_ACCESS_BIT_ARB;
@@ -590,33 +592,39 @@ GLFWbool _glfwCreateContextWGL(_GLFWwindow* window,
             {
                 if (ctxconfig->release == GLFW_RELEASE_BEHAVIOR_NONE)
                 {
-                    setWGLattrib(WGL_CONTEXT_RELEASE_BEHAVIOR_ARB,
+                    setAttrib(WGL_CONTEXT_RELEASE_BEHAVIOR_ARB,
-                                 WGL_CONTEXT_RELEASE_BEHAVIOR_NONE_ARB);
+                              WGL_CONTEXT_RELEASE_BEHAVIOR_NONE_ARB);
                 }
                 else if (ctxconfig->release == GLFW_RELEASE_BEHAVIOR_FLUSH)
                 {
-                    setWGLattrib(WGL_CONTEXT_RELEASE_BEHAVIOR_ARB,
+                    setAttrib(WGL_CONTEXT_RELEASE_BEHAVIOR_ARB,
-                                 WGL_CONTEXT_RELEASE_BEHAVIOR_FLUSH_ARB);
+                              WGL_CONTEXT_RELEASE_BEHAVIOR_FLUSH_ARB);
                 }
             }
         }
 
+        if (ctxconfig->noerror)
+        {
+            if (_glfw.wgl.ARB_create_context_no_error)
+                setAttrib(WGL_CONTEXT_OPENGL_NO_ERROR_ARB, GLFW_TRUE);
+        }
+
         // NOTE: Only request an explicitly versioned context when necessary, as
         //       explicitly requesting version 1.0 does not always return the
         //       highest version supported by the driver
         if (ctxconfig->major != 1 || ctxconfig->minor != 0)
         {
-            setWGLattrib(WGL_CONTEXT_MAJOR_VERSION_ARB, ctxconfig->major);
+            setAttrib(WGL_CONTEXT_MAJOR_VERSION_ARB, ctxconfig->major);
-            setWGLattrib(WGL_CONTEXT_MINOR_VERSION_ARB, ctxconfig->minor);
+            setAttrib(WGL_CONTEXT_MINOR_VERSION_ARB, ctxconfig->minor);
         }
 
         if (flags)
-            setWGLattrib(WGL_CONTEXT_FLAGS_ARB, flags);
+            setAttrib(WGL_CONTEXT_FLAGS_ARB, flags);
 
         if (mask)
-            setWGLattrib(WGL_CONTEXT_PROFILE_MASK_ARB, mask);
+            setAttrib(WGL_CONTEXT_PROFILE_MASK_ARB, mask);
 
-        setWGLattrib(0, 0);
+        setAttrib(0, 0);
 
         window->context.wgl.handle =
             _glfw.wgl.CreateContextAttribsARB(window->context.wgl.dc,
@@ -647,6 +655,11 @@ GLFWbool _glfwCreateContextWGL(_GLFWwindow* window,
                 _glfwInputError(GLFW_VERSION_UNAVAILABLE,
                                 "WGL: Driver does not support the requested OpenGL profile");
             }
+            else if (error == (0xc0070000 | ERROR_INCOMPATIBLE_DEVICE_CONTEXTS_ARB))
+            {
+                _glfwInputError(GLFW_INVALID_VALUE,
+                                "WGL: The share context is not compatible with the requested context");
+            }
             else
             {
                 if (ctxconfig->client == GLFW_OPENGL_API)
@@ -669,8 +682,8 @@ GLFWbool _glfwCreateContextWGL(_GLFWwindow* window,
         window->context.wgl.handle = wglCreateContext(window->context.wgl.dc);
         if (!window->context.wgl.handle)
         {
-            _glfwInputError(GLFW_VERSION_UNAVAILABLE,
+            _glfwInputErrorWin32(GLFW_VERSION_UNAVAILABLE,
-                            "WGL: Failed to create OpenGL context");
+                                 "WGL: Failed to create OpenGL context");
             return GLFW_FALSE;
         }
 
@@ -678,8 +691,8 @@ GLFWbool _glfwCreateContextWGL(_GLFWwindow* window,
         {
             if (!wglShareLists(share, window->context.wgl.handle))
             {
-                _glfwInputError(GLFW_PLATFORM_ERROR,
+                _glfwInputErrorWin32(GLFW_PLATFORM_ERROR,
-                                "WGL: Failed to enable sharing with specified OpenGL context");
+                                     "WGL: Failed to enable sharing with specified OpenGL context");
                 return GLFW_FALSE;
             }
         }
@@ -695,7 +708,7 @@ GLFWbool _glfwCreateContextWGL(_GLFWwindow* window,
     return GLFW_TRUE;
 }
 
-#undef setWGLattrib
+#undef setAttrib
 
 
 //////////////////////////////////////////////////////////////////////////

raylib/external/glfw/src/wgl_context.h

@@ -1,8 +1,8 @@
 //========================================================================
-// GLFW 3.2 WGL - www.glfw.org
+// GLFW 3.3 WGL - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-2016 Camilla Berglund <elmindreda@glfw.org>
+// Copyright (c) 2006-2016 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
@@ -25,10 +25,6 @@
 //
 //========================================================================
 
-#ifndef _glfw3_wgl_context_h_
-#define _glfw3_wgl_context_h_
-
-
 #define WGL_NUMBER_PIXEL_FORMATS_ARB 0x2000
 #define WGL_SUPPORT_OPENGL_ARB 0x2010
 #define WGL_DRAW_TO_WINDOW_ARB 0x2001
@@ -72,9 +68,13 @@
 #define WGL_CONTEXT_RELEASE_BEHAVIOR_ARB 0x2097
 #define WGL_CONTEXT_RELEASE_BEHAVIOR_NONE_ARB 0
 #define WGL_CONTEXT_RELEASE_BEHAVIOR_FLUSH_ARB 0x2098
+#define WGL_CONTEXT_OPENGL_NO_ERROR_ARB 0x31b3
+#define WGL_COLORSPACE_EXT 0x309d
+#define WGL_COLORSPACE_SRGB_EXT 0x3089
 
 #define ERROR_INVALID_VERSION_ARB 0x2095
 #define ERROR_INVALID_PROFILE_ARB 0x2096
+#define ERROR_INCOMPATIBLE_DEVICE_CONTEXTS_ARB 0x2054
 
 typedef BOOL (WINAPI * PFNWGLSWAPINTERVALEXTPROC)(int);
 typedef BOOL (WINAPI * PFNWGLGETPIXELFORMATATTRIBIVARBPROC)(HDC,int,int,UINT,const int*,int*);
@@ -82,12 +82,12 @@ typedef const char* (WINAPI * PFNWGLGETEXTENSIONSSTRINGEXTPROC)(void);
 typedef const char* (WINAPI * PFNWGLGETEXTENSIONSSTRINGARBPROC)(HDC);
 typedef HGLRC (WINAPI * PFNWGLCREATECONTEXTATTRIBSARBPROC)(HDC,HGLRC,const int*);
 
-typedef HGLRC (WINAPI * WGLCREATECONTEXT_T)(HDC);
+typedef HGLRC (WINAPI * PFN_wglCreateContext)(HDC);
-typedef BOOL (WINAPI * WGLDELETECONTEXT_T)(HGLRC);
+typedef BOOL (WINAPI * PFN_wglDeleteContext)(HGLRC);
-typedef PROC (WINAPI * WGLGETPROCADDRESS_T)(LPCSTR);
+typedef PROC (WINAPI * PFN_wglGetProcAddress)(LPCSTR);
-typedef HDC (WINAPI * WGLGETCURRENTDC_T)(void);
+typedef HDC (WINAPI * PFN_wglGetCurrentDC)(void);
-typedef BOOL (WINAPI * WGLMAKECURRENT_T)(HDC,HGLRC);
+typedef BOOL (WINAPI * PFN_wglMakeCurrent)(HDC,HGLRC);
-typedef BOOL (WINAPI * WGLSHARELISTS_T)(HGLRC,HGLRC);
+typedef BOOL (WINAPI * PFN_wglShareLists)(HGLRC,HGLRC);
 
 // opengl32.dll function pointer typedefs
 #define wglCreateContext _glfw.wgl.CreateContext
@@ -120,12 +120,12 @@ typedef struct _GLFWcontextWGL
 typedef struct _GLFWlibraryWGL
 {
     HINSTANCE                           instance;
-    WGLCREATECONTEXT_T                  CreateContext;
+    PFN_wglCreateContext                CreateContext;
-    WGLDELETECONTEXT_T                  DeleteContext;
+    PFN_wglDeleteContext                DeleteContext;
-    WGLGETPROCADDRESS_T                 GetProcAddress;
+    PFN_wglGetProcAddress               GetProcAddress;
-    WGLGETCURRENTDC_T                   GetCurrentDC;
+    PFN_wglGetCurrentDC                 GetCurrentDC;
-    WGLMAKECURRENT_T                    MakeCurrent;
+    PFN_wglMakeCurrent                  MakeCurrent;
-    WGLSHARELISTS_T                     ShareLists;
+    PFN_wglShareLists                   ShareLists;
 
     GLFWbool                            extensionsLoaded;
 
@@ -135,6 +135,7 @@ typedef struct _GLFWlibraryWGL
     PFNWGLGETEXTENSIONSSTRINGARBPROC    GetExtensionsStringARB;
     PFNWGLCREATECONTEXTATTRIBSARBPROC   CreateContextAttribsARB;
     GLFWbool                            EXT_swap_control;
+    GLFWbool                            EXT_colorspace;
     GLFWbool                            ARB_multisample;
     GLFWbool                            ARB_framebuffer_sRGB;
     GLFWbool                            EXT_framebuffer_sRGB;
@@ -143,6 +144,7 @@ typedef struct _GLFWlibraryWGL
     GLFWbool                            ARB_create_context_profile;
     GLFWbool                            EXT_create_context_es2_profile;
     GLFWbool                            ARB_create_context_robustness;
+    GLFWbool                            ARB_create_context_no_error;
     GLFWbool                            ARB_context_flush_control;
 
 } _GLFWlibraryWGL;
@@ -154,4 +156,3 @@ GLFWbool _glfwCreateContextWGL(_GLFWwindow* window,
                                const _GLFWctxconfig* ctxconfig,
                                const _GLFWfbconfig* fbconfig);
 
-#endif // _glfw3_wgl_context_h_

raylib/external/glfw/src/win32_init.c

@@ -1,8 +1,8 @@
 //========================================================================
-// GLFW 3.2 Win32 - www.glfw.org
+// GLFW 3.3 Win32 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-2016 Camilla Berglund <elmindreda@glfw.org>
+// Copyright (c) 2006-2016 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
@@ -30,20 +30,22 @@
 #include <stdlib.h>
 #include <malloc.h>
 
-#include <initguid.h>
+static const GUID _glfw_GUID_DEVINTERFACE_HID =
-DEFINE_GUID(GUID_DEVINTERFACE_HID,0x4d1e55b2,0xf16f,0x11cf,0x88,0xcb,0x00,0x11,0x11,0x00,0x00,0x30);
+    {0x4d1e55b2,0xf16f,0x11cf,{0x88,0xcb,0x00,0x11,0x11,0x00,0x00,0x30}};
+
+#define GUID_DEVINTERFACE_HID _glfw_GUID_DEVINTERFACE_HID
 
 #if defined(_GLFW_USE_HYBRID_HPG) || defined(_GLFW_USE_OPTIMUS_HPG)
 
-// Applications exporting this symbol with this value will be automatically
+// Executables (but not DLLs) exporting this symbol with this value will be
-// directed to the high-performance GPU on Nvidia Optimus systems with
+// automatically directed to the high-performance GPU on Nvidia Optimus systems
-// up-to-date drivers
+// with up-to-date drivers
 //
 __declspec(dllexport) DWORD NvOptimusEnablement = 1;
 
-// Applications exporting this symbol with this value will be automatically
+// Executables (but not DLLs) exporting this symbol with this value will be
-// directed to the high-performance GPU on AMD PowerXpress systems with
+// automatically directed to the high-performance GPU on AMD PowerXpress systems
-// up-to-date drivers
+// with up-to-date drivers
 //
 __declspec(dllexport) int AmdPowerXpressRequestHighPerformance = 1;
 
@@ -60,6 +62,17 @@ BOOL WINAPI DllMain(HINSTANCE instance, DWORD reason, LPVOID reserved)
 
 #endif // _GLFW_BUILD_DLL
 
+// HACK: Define versionhelpers.h functions manually as MinGW lacks the header
+BOOL IsWindowsVersionOrGreater(WORD major, WORD minor, WORD sp)
+{
+    OSVERSIONINFOEXW osvi = { sizeof(osvi), major, minor, 0, 0, {0}, sp };
+    DWORD mask = VER_MAJORVERSION | VER_MINORVERSION | VER_SERVICEPACKMAJOR;
+    ULONGLONG cond = VerSetConditionMask(0, VER_MAJORVERSION, VER_GREATER_EQUAL);
+    cond = VerSetConditionMask(cond, VER_MINORVERSION, VER_GREATER_EQUAL);
+    cond = VerSetConditionMask(cond, VER_SERVICEPACKMAJOR, VER_GREATER_EQUAL);
+    return VerifyVersionInfoW(&osvi, mask, cond);
+}
+
 // Load necessary libraries (DLLs)
 //
 static GLFWbool loadLibraries(void)
@@ -67,29 +80,31 @@ static GLFWbool loadLibraries(void)
     _glfw.win32.winmm.instance = LoadLibraryA("winmm.dll");
     if (!_glfw.win32.winmm.instance)
     {
-        _glfwInputError(GLFW_PLATFORM_ERROR, "Win32: Failed to load winmm.dll");
+        _glfwInputErrorWin32(GLFW_PLATFORM_ERROR,
+                             "Win32: Failed to load winmm.dll");
         return GLFW_FALSE;
     }
 
-    _glfw.win32.winmm.timeGetTime = (TIMEGETTIME_T)
+    _glfw.win32.winmm.GetTime = (PFN_timeGetTime)
         GetProcAddress(_glfw.win32.winmm.instance, "timeGetTime");
 
     _glfw.win32.user32.instance = LoadLibraryA("user32.dll");
     if (!_glfw.win32.user32.instance)
     {
-        _glfwInputError(GLFW_PLATFORM_ERROR, "Win32: Failed to load user32.dll");
+        _glfwInputErrorWin32(GLFW_PLATFORM_ERROR,
+                             "Win32: Failed to load user32.dll");
         return GLFW_FALSE;
     }
 
-    _glfw.win32.user32.SetProcessDPIAware = (SETPROCESSDPIAWARE_T)
+    _glfw.win32.user32.SetProcessDPIAware_ = (PFN_SetProcessDPIAware)
         GetProcAddress(_glfw.win32.user32.instance, "SetProcessDPIAware");
-    _glfw.win32.user32.ChangeWindowMessageFilterEx = (CHANGEWINDOWMESSAGEFILTEREX_T)
+    _glfw.win32.user32.ChangeWindowMessageFilterEx_ = (PFN_ChangeWindowMessageFilterEx)
         GetProcAddress(_glfw.win32.user32.instance, "ChangeWindowMessageFilterEx");
 
     _glfw.win32.dinput8.instance = LoadLibraryA("dinput8.dll");
     if (_glfw.win32.dinput8.instance)
     {
-        _glfw.win32.dinput8.DirectInput8Create = (DIRECTINPUT8CREATE_T)
+        _glfw.win32.dinput8.Create = (PFN_DirectInput8Create)
             GetProcAddress(_glfw.win32.dinput8.instance, "DirectInput8Create");
     }
 
@@ -110,9 +125,9 @@ static GLFWbool loadLibraries(void)
             _glfw.win32.xinput.instance = LoadLibraryA(names[i]);
             if (_glfw.win32.xinput.instance)
             {
-                _glfw.win32.xinput.XInputGetCapabilities = (XINPUTGETCAPABILITIES_T)
+                _glfw.win32.xinput.GetCapabilities = (PFN_XInputGetCapabilities)
                     GetProcAddress(_glfw.win32.xinput.instance, "XInputGetCapabilities");
-                _glfw.win32.xinput.XInputGetState = (XINPUTGETSTATE_T)
+                _glfw.win32.xinput.GetState = (PFN_XInputGetState)
                     GetProcAddress(_glfw.win32.xinput.instance, "XInputGetState");
 
                 break;
@@ -123,17 +138,21 @@ static GLFWbool loadLibraries(void)
     _glfw.win32.dwmapi.instance = LoadLibraryA("dwmapi.dll");
     if (_glfw.win32.dwmapi.instance)
     {
-        _glfw.win32.dwmapi.DwmIsCompositionEnabled = (DWMISCOMPOSITIONENABLED_T)
+        _glfw.win32.dwmapi.IsCompositionEnabled = (PFN_DwmIsCompositionEnabled)
             GetProcAddress(_glfw.win32.dwmapi.instance, "DwmIsCompositionEnabled");
-        _glfw.win32.dwmapi.DwmFlush = (DWMFLUSH_T)
+        _glfw.win32.dwmapi.Flush = (PFN_DwmFlush)
             GetProcAddress(_glfw.win32.dwmapi.instance, "DwmFlush");
+        _glfw.win32.dwmapi.EnableBlurBehindWindow = (PFN_DwmEnableBlurBehindWindow)
+            GetProcAddress(_glfw.win32.dwmapi.instance, "DwmEnableBlurBehindWindow");
     }
 
     _glfw.win32.shcore.instance = LoadLibraryA("shcore.dll");
     if (_glfw.win32.shcore.instance)
     {
-        _glfw.win32.shcore.SetProcessDpiAwareness = (SETPROCESSDPIAWARENESS_T)
+        _glfw.win32.shcore.SetProcessDpiAwareness_ = (PFN_SetProcessDpiAwareness)
             GetProcAddress(_glfw.win32.shcore.instance, "SetProcessDpiAwareness");
+        _glfw.win32.shcore.GetDpiForMonitor_ = (PFN_GetDpiForMonitor)
+            GetProcAddress(_glfw.win32.shcore.instance, "GetDpiForMonitor");
     }
 
     return GLFW_TRUE;
@@ -168,135 +187,135 @@ static void createKeyTables(void)
 {
     int scancode;
 
-    memset(_glfw.win32.publicKeys, -1, sizeof(_glfw.win32.publicKeys));
+    memset(_glfw.win32.keycodes, -1, sizeof(_glfw.win32.keycodes));
-    memset(_glfw.win32.nativeKeys, -1, sizeof(_glfw.win32.nativeKeys));
+    memset(_glfw.win32.scancodes, -1, sizeof(_glfw.win32.scancodes));
 
-    _glfw.win32.publicKeys[0x00B] = GLFW_KEY_0;
+    _glfw.win32.keycodes[0x00B] = GLFW_KEY_0;
-    _glfw.win32.publicKeys[0x002] = GLFW_KEY_1;
+    _glfw.win32.keycodes[0x002] = GLFW_KEY_1;
-    _glfw.win32.publicKeys[0x003] = GLFW_KEY_2;
+    _glfw.win32.keycodes[0x003] = GLFW_KEY_2;
-    _glfw.win32.publicKeys[0x004] = GLFW_KEY_3;
+    _glfw.win32.keycodes[0x004] = GLFW_KEY_3;
-    _glfw.win32.publicKeys[0x005] = GLFW_KEY_4;
+    _glfw.win32.keycodes[0x005] = GLFW_KEY_4;
-    _glfw.win32.publicKeys[0x006] = GLFW_KEY_5;
+    _glfw.win32.keycodes[0x006] = GLFW_KEY_5;
-    _glfw.win32.publicKeys[0x007] = GLFW_KEY_6;
+    _glfw.win32.keycodes[0x007] = GLFW_KEY_6;
-    _glfw.win32.publicKeys[0x008] = GLFW_KEY_7;
+    _glfw.win32.keycodes[0x008] = GLFW_KEY_7;
-    _glfw.win32.publicKeys[0x009] = GLFW_KEY_8;
+    _glfw.win32.keycodes[0x009] = GLFW_KEY_8;
-    _glfw.win32.publicKeys[0x00A] = GLFW_KEY_9;
+    _glfw.win32.keycodes[0x00A] = GLFW_KEY_9;
-    _glfw.win32.publicKeys[0x01E] = GLFW_KEY_A;
+    _glfw.win32.keycodes[0x01E] = GLFW_KEY_A;
-    _glfw.win32.publicKeys[0x030] = GLFW_KEY_B;
+    _glfw.win32.keycodes[0x030] = GLFW_KEY_B;
-    _glfw.win32.publicKeys[0x02E] = GLFW_KEY_C;
+    _glfw.win32.keycodes[0x02E] = GLFW_KEY_C;
-    _glfw.win32.publicKeys[0x020] = GLFW_KEY_D;
+    _glfw.win32.keycodes[0x020] = GLFW_KEY_D;
-    _glfw.win32.publicKeys[0x012] = GLFW_KEY_E;
+    _glfw.win32.keycodes[0x012] = GLFW_KEY_E;
-    _glfw.win32.publicKeys[0x021] = GLFW_KEY_F;
+    _glfw.win32.keycodes[0x021] = GLFW_KEY_F;
-    _glfw.win32.publicKeys[0x022] = GLFW_KEY_G;
+    _glfw.win32.keycodes[0x022] = GLFW_KEY_G;
-    _glfw.win32.publicKeys[0x023] = GLFW_KEY_H;
+    _glfw.win32.keycodes[0x023] = GLFW_KEY_H;
-    _glfw.win32.publicKeys[0x017] = GLFW_KEY_I;
+    _glfw.win32.keycodes[0x017] = GLFW_KEY_I;
-    _glfw.win32.publicKeys[0x024] = GLFW_KEY_J;
+    _glfw.win32.keycodes[0x024] = GLFW_KEY_J;
-    _glfw.win32.publicKeys[0x025] = GLFW_KEY_K;
+    _glfw.win32.keycodes[0x025] = GLFW_KEY_K;
-    _glfw.win32.publicKeys[0x026] = GLFW_KEY_L;
+    _glfw.win32.keycodes[0x026] = GLFW_KEY_L;
-    _glfw.win32.publicKeys[0x032] = GLFW_KEY_M;
+    _glfw.win32.keycodes[0x032] = GLFW_KEY_M;
-    _glfw.win32.publicKeys[0x031] = GLFW_KEY_N;
+    _glfw.win32.keycodes[0x031] = GLFW_KEY_N;
-    _glfw.win32.publicKeys[0x018] = GLFW_KEY_O;
+    _glfw.win32.keycodes[0x018] = GLFW_KEY_O;
-    _glfw.win32.publicKeys[0x019] = GLFW_KEY_P;
+    _glfw.win32.keycodes[0x019] = GLFW_KEY_P;
-    _glfw.win32.publicKeys[0x010] = GLFW_KEY_Q;
+    _glfw.win32.keycodes[0x010] = GLFW_KEY_Q;
-    _glfw.win32.publicKeys[0x013] = GLFW_KEY_R;
+    _glfw.win32.keycodes[0x013] = GLFW_KEY_R;
-    _glfw.win32.publicKeys[0x01F] = GLFW_KEY_S;
+    _glfw.win32.keycodes[0x01F] = GLFW_KEY_S;
-    _glfw.win32.publicKeys[0x014] = GLFW_KEY_T;
+    _glfw.win32.keycodes[0x014] = GLFW_KEY_T;
-    _glfw.win32.publicKeys[0x016] = GLFW_KEY_U;
+    _glfw.win32.keycodes[0x016] = GLFW_KEY_U;
-    _glfw.win32.publicKeys[0x02F] = GLFW_KEY_V;
+    _glfw.win32.keycodes[0x02F] = GLFW_KEY_V;
-    _glfw.win32.publicKeys[0x011] = GLFW_KEY_W;
+    _glfw.win32.keycodes[0x011] = GLFW_KEY_W;
-    _glfw.win32.publicKeys[0x02D] = GLFW_KEY_X;
+    _glfw.win32.keycodes[0x02D] = GLFW_KEY_X;
-    _glfw.win32.publicKeys[0x015] = GLFW_KEY_Y;
+    _glfw.win32.keycodes[0x015] = GLFW_KEY_Y;
-    _glfw.win32.publicKeys[0x02C] = GLFW_KEY_Z;
+    _glfw.win32.keycodes[0x02C] = GLFW_KEY_Z;
 
-    _glfw.win32.publicKeys[0x028] = GLFW_KEY_APOSTROPHE;
+    _glfw.win32.keycodes[0x028] = GLFW_KEY_APOSTROPHE;
-    _glfw.win32.publicKeys[0x02B] = GLFW_KEY_BACKSLASH;
+    _glfw.win32.keycodes[0x02B] = GLFW_KEY_BACKSLASH;
-    _glfw.win32.publicKeys[0x033] = GLFW_KEY_COMMA;
+    _glfw.win32.keycodes[0x033] = GLFW_KEY_COMMA;
-    _glfw.win32.publicKeys[0x00D] = GLFW_KEY_EQUAL;
+    _glfw.win32.keycodes[0x00D] = GLFW_KEY_EQUAL;
-    _glfw.win32.publicKeys[0x029] = GLFW_KEY_GRAVE_ACCENT;
+    _glfw.win32.keycodes[0x029] = GLFW_KEY_GRAVE_ACCENT;
-    _glfw.win32.publicKeys[0x01A] = GLFW_KEY_LEFT_BRACKET;
+    _glfw.win32.keycodes[0x01A] = GLFW_KEY_LEFT_BRACKET;
-    _glfw.win32.publicKeys[0x00C] = GLFW_KEY_MINUS;
+    _glfw.win32.keycodes[0x00C] = GLFW_KEY_MINUS;
-    _glfw.win32.publicKeys[0x034] = GLFW_KEY_PERIOD;
+    _glfw.win32.keycodes[0x034] = GLFW_KEY_PERIOD;
-    _glfw.win32.publicKeys[0x01B] = GLFW_KEY_RIGHT_BRACKET;
+    _glfw.win32.keycodes[0x01B] = GLFW_KEY_RIGHT_BRACKET;
-    _glfw.win32.publicKeys[0x027] = GLFW_KEY_SEMICOLON;
+    _glfw.win32.keycodes[0x027] = GLFW_KEY_SEMICOLON;
-    _glfw.win32.publicKeys[0x035] = GLFW_KEY_SLASH;
+    _glfw.win32.keycodes[0x035] = GLFW_KEY_SLASH;
-    _glfw.win32.publicKeys[0x056] = GLFW_KEY_WORLD_2;
+    _glfw.win32.keycodes[0x056] = GLFW_KEY_WORLD_2;
 
-    _glfw.win32.publicKeys[0x00E] = GLFW_KEY_BACKSPACE;
+    _glfw.win32.keycodes[0x00E] = GLFW_KEY_BACKSPACE;
-    _glfw.win32.publicKeys[0x153] = GLFW_KEY_DELETE;
+    _glfw.win32.keycodes[0x153] = GLFW_KEY_DELETE;
-    _glfw.win32.publicKeys[0x14F] = GLFW_KEY_END;
+    _glfw.win32.keycodes[0x14F] = GLFW_KEY_END;
-    _glfw.win32.publicKeys[0x01C] = GLFW_KEY_ENTER;
+    _glfw.win32.keycodes[0x01C] = GLFW_KEY_ENTER;
-    _glfw.win32.publicKeys[0x001] = GLFW_KEY_ESCAPE;
+    _glfw.win32.keycodes[0x001] = GLFW_KEY_ESCAPE;
-    _glfw.win32.publicKeys[0x147] = GLFW_KEY_HOME;
+    _glfw.win32.keycodes[0x147] = GLFW_KEY_HOME;
-    _glfw.win32.publicKeys[0x152] = GLFW_KEY_INSERT;
+    _glfw.win32.keycodes[0x152] = GLFW_KEY_INSERT;
-    _glfw.win32.publicKeys[0x15D] = GLFW_KEY_MENU;
+    _glfw.win32.keycodes[0x15D] = GLFW_KEY_MENU;
-    _glfw.win32.publicKeys[0x151] = GLFW_KEY_PAGE_DOWN;
+    _glfw.win32.keycodes[0x151] = GLFW_KEY_PAGE_DOWN;
-    _glfw.win32.publicKeys[0x149] = GLFW_KEY_PAGE_UP;
+    _glfw.win32.keycodes[0x149] = GLFW_KEY_PAGE_UP;
-    _glfw.win32.publicKeys[0x045] = GLFW_KEY_PAUSE;
+    _glfw.win32.keycodes[0x045] = GLFW_KEY_PAUSE;
-    _glfw.win32.publicKeys[0x146] = GLFW_KEY_PAUSE;
+    _glfw.win32.keycodes[0x146] = GLFW_KEY_PAUSE;
-    _glfw.win32.publicKeys[0x039] = GLFW_KEY_SPACE;
+    _glfw.win32.keycodes[0x039] = GLFW_KEY_SPACE;
-    _glfw.win32.publicKeys[0x00F] = GLFW_KEY_TAB;
+    _glfw.win32.keycodes[0x00F] = GLFW_KEY_TAB;
-    _glfw.win32.publicKeys[0x03A] = GLFW_KEY_CAPS_LOCK;
+    _glfw.win32.keycodes[0x03A] = GLFW_KEY_CAPS_LOCK;
-    _glfw.win32.publicKeys[0x145] = GLFW_KEY_NUM_LOCK;
+    _glfw.win32.keycodes[0x145] = GLFW_KEY_NUM_LOCK;
-    _glfw.win32.publicKeys[0x046] = GLFW_KEY_SCROLL_LOCK;
+    _glfw.win32.keycodes[0x046] = GLFW_KEY_SCROLL_LOCK;
-    _glfw.win32.publicKeys[0x03B] = GLFW_KEY_F1;
+    _glfw.win32.keycodes[0x03B] = GLFW_KEY_F1;
-    _glfw.win32.publicKeys[0x03C] = GLFW_KEY_F2;
+    _glfw.win32.keycodes[0x03C] = GLFW_KEY_F2;
-    _glfw.win32.publicKeys[0x03D] = GLFW_KEY_F3;
+    _glfw.win32.keycodes[0x03D] = GLFW_KEY_F3;
-    _glfw.win32.publicKeys[0x03E] = GLFW_KEY_F4;
+    _glfw.win32.keycodes[0x03E] = GLFW_KEY_F4;
-    _glfw.win32.publicKeys[0x03F] = GLFW_KEY_F5;
+    _glfw.win32.keycodes[0x03F] = GLFW_KEY_F5;
-    _glfw.win32.publicKeys[0x040] = GLFW_KEY_F6;
+    _glfw.win32.keycodes[0x040] = GLFW_KEY_F6;
-    _glfw.win32.publicKeys[0x041] = GLFW_KEY_F7;
+    _glfw.win32.keycodes[0x041] = GLFW_KEY_F7;
-    _glfw.win32.publicKeys[0x042] = GLFW_KEY_F8;
+    _glfw.win32.keycodes[0x042] = GLFW_KEY_F8;
-    _glfw.win32.publicKeys[0x043] = GLFW_KEY_F9;
+    _glfw.win32.keycodes[0x043] = GLFW_KEY_F9;
-    _glfw.win32.publicKeys[0x044] = GLFW_KEY_F10;
+    _glfw.win32.keycodes[0x044] = GLFW_KEY_F10;
-    _glfw.win32.publicKeys[0x057] = GLFW_KEY_F11;
+    _glfw.win32.keycodes[0x057] = GLFW_KEY_F11;
-    _glfw.win32.publicKeys[0x058] = GLFW_KEY_F12;
+    _glfw.win32.keycodes[0x058] = GLFW_KEY_F12;
-    _glfw.win32.publicKeys[0x064] = GLFW_KEY_F13;
+    _glfw.win32.keycodes[0x064] = GLFW_KEY_F13;
-    _glfw.win32.publicKeys[0x065] = GLFW_KEY_F14;
+    _glfw.win32.keycodes[0x065] = GLFW_KEY_F14;
-    _glfw.win32.publicKeys[0x066] = GLFW_KEY_F15;
+    _glfw.win32.keycodes[0x066] = GLFW_KEY_F15;
-    _glfw.win32.publicKeys[0x067] = GLFW_KEY_F16;
+    _glfw.win32.keycodes[0x067] = GLFW_KEY_F16;
-    _glfw.win32.publicKeys[0x068] = GLFW_KEY_F17;
+    _glfw.win32.keycodes[0x068] = GLFW_KEY_F17;
-    _glfw.win32.publicKeys[0x069] = GLFW_KEY_F18;
+    _glfw.win32.keycodes[0x069] = GLFW_KEY_F18;
-    _glfw.win32.publicKeys[0x06A] = GLFW_KEY_F19;
+    _glfw.win32.keycodes[0x06A] = GLFW_KEY_F19;
-    _glfw.win32.publicKeys[0x06B] = GLFW_KEY_F20;
+    _glfw.win32.keycodes[0x06B] = GLFW_KEY_F20;
-    _glfw.win32.publicKeys[0x06C] = GLFW_KEY_F21;
+    _glfw.win32.keycodes[0x06C] = GLFW_KEY_F21;
-    _glfw.win32.publicKeys[0x06D] = GLFW_KEY_F22;
+    _glfw.win32.keycodes[0x06D] = GLFW_KEY_F22;
-    _glfw.win32.publicKeys[0x06E] = GLFW_KEY_F23;
+    _glfw.win32.keycodes[0x06E] = GLFW_KEY_F23;
-    _glfw.win32.publicKeys[0x076] = GLFW_KEY_F24;
+    _glfw.win32.keycodes[0x076] = GLFW_KEY_F24;
-    _glfw.win32.publicKeys[0x038] = GLFW_KEY_LEFT_ALT;
+    _glfw.win32.keycodes[0x038] = GLFW_KEY_LEFT_ALT;
-    _glfw.win32.publicKeys[0x01D] = GLFW_KEY_LEFT_CONTROL;
+    _glfw.win32.keycodes[0x01D] = GLFW_KEY_LEFT_CONTROL;
-    _glfw.win32.publicKeys[0x02A] = GLFW_KEY_LEFT_SHIFT;
+    _glfw.win32.keycodes[0x02A] = GLFW_KEY_LEFT_SHIFT;
-    _glfw.win32.publicKeys[0x15B] = GLFW_KEY_LEFT_SUPER;
+    _glfw.win32.keycodes[0x15B] = GLFW_KEY_LEFT_SUPER;
-    _glfw.win32.publicKeys[0x137] = GLFW_KEY_PRINT_SCREEN;
+    _glfw.win32.keycodes[0x137] = GLFW_KEY_PRINT_SCREEN;
-    _glfw.win32.publicKeys[0x138] = GLFW_KEY_RIGHT_ALT;
+    _glfw.win32.keycodes[0x138] = GLFW_KEY_RIGHT_ALT;
-    _glfw.win32.publicKeys[0x11D] = GLFW_KEY_RIGHT_CONTROL;
+    _glfw.win32.keycodes[0x11D] = GLFW_KEY_RIGHT_CONTROL;
-    _glfw.win32.publicKeys[0x036] = GLFW_KEY_RIGHT_SHIFT;
+    _glfw.win32.keycodes[0x036] = GLFW_KEY_RIGHT_SHIFT;
-    _glfw.win32.publicKeys[0x15C] = GLFW_KEY_RIGHT_SUPER;
+    _glfw.win32.keycodes[0x15C] = GLFW_KEY_RIGHT_SUPER;
-    _glfw.win32.publicKeys[0x150] = GLFW_KEY_DOWN;
+    _glfw.win32.keycodes[0x150] = GLFW_KEY_DOWN;
-    _glfw.win32.publicKeys[0x14B] = GLFW_KEY_LEFT;
+    _glfw.win32.keycodes[0x14B] = GLFW_KEY_LEFT;
-    _glfw.win32.publicKeys[0x14D] = GLFW_KEY_RIGHT;
+    _glfw.win32.keycodes[0x14D] = GLFW_KEY_RIGHT;
-    _glfw.win32.publicKeys[0x148] = GLFW_KEY_UP;
+    _glfw.win32.keycodes[0x148] = GLFW_KEY_UP;
 
-    _glfw.win32.publicKeys[0x052] = GLFW_KEY_KP_0;
+    _glfw.win32.keycodes[0x052] = GLFW_KEY_KP_0;
-    _glfw.win32.publicKeys[0x04F] = GLFW_KEY_KP_1;
+    _glfw.win32.keycodes[0x04F] = GLFW_KEY_KP_1;
-    _glfw.win32.publicKeys[0x050] = GLFW_KEY_KP_2;
+    _glfw.win32.keycodes[0x050] = GLFW_KEY_KP_2;
-    _glfw.win32.publicKeys[0x051] = GLFW_KEY_KP_3;
+    _glfw.win32.keycodes[0x051] = GLFW_KEY_KP_3;
-    _glfw.win32.publicKeys[0x04B] = GLFW_KEY_KP_4;
+    _glfw.win32.keycodes[0x04B] = GLFW_KEY_KP_4;
-    _glfw.win32.publicKeys[0x04C] = GLFW_KEY_KP_5;
+    _glfw.win32.keycodes[0x04C] = GLFW_KEY_KP_5;
-    _glfw.win32.publicKeys[0x04D] = GLFW_KEY_KP_6;
+    _glfw.win32.keycodes[0x04D] = GLFW_KEY_KP_6;
-    _glfw.win32.publicKeys[0x047] = GLFW_KEY_KP_7;
+    _glfw.win32.keycodes[0x047] = GLFW_KEY_KP_7;
-    _glfw.win32.publicKeys[0x048] = GLFW_KEY_KP_8;
+    _glfw.win32.keycodes[0x048] = GLFW_KEY_KP_8;
-    _glfw.win32.publicKeys[0x049] = GLFW_KEY_KP_9;
+    _glfw.win32.keycodes[0x049] = GLFW_KEY_KP_9;
-    _glfw.win32.publicKeys[0x04E] = GLFW_KEY_KP_ADD;
+    _glfw.win32.keycodes[0x04E] = GLFW_KEY_KP_ADD;
-    _glfw.win32.publicKeys[0x053] = GLFW_KEY_KP_DECIMAL;
+    _glfw.win32.keycodes[0x053] = GLFW_KEY_KP_DECIMAL;
-    _glfw.win32.publicKeys[0x135] = GLFW_KEY_KP_DIVIDE;
+    _glfw.win32.keycodes[0x135] = GLFW_KEY_KP_DIVIDE;
-    _glfw.win32.publicKeys[0x11C] = GLFW_KEY_KP_ENTER;
+    _glfw.win32.keycodes[0x11C] = GLFW_KEY_KP_ENTER;
-    _glfw.win32.publicKeys[0x037] = GLFW_KEY_KP_MULTIPLY;
+    _glfw.win32.keycodes[0x037] = GLFW_KEY_KP_MULTIPLY;
-    _glfw.win32.publicKeys[0x04A] = GLFW_KEY_KP_SUBTRACT;
+    _glfw.win32.keycodes[0x04A] = GLFW_KEY_KP_SUBTRACT;
 
     for (scancode = 0;  scancode < 512;  scancode++)
     {
-        if (_glfw.win32.publicKeys[scancode] > 0)
+        if (_glfw.win32.keycodes[scancode] > 0)
-            _glfw.win32.nativeKeys[_glfw.win32.publicKeys[scancode]] = scancode;
+            _glfw.win32.scancodes[_glfw.win32.keycodes[scancode]] = scancode;
     }
 }
 
@@ -304,18 +323,19 @@ static void createKeyTables(void)
 //
 static HWND createHelperWindow(void)
 {
+    MSG msg;
     HWND window = CreateWindowExW(WS_EX_OVERLAPPEDWINDOW,
                                   _GLFW_WNDCLASSNAME,
-                                  L"GLFW helper window",
+                                  L"GLFW message window",
                                   WS_CLIPSIBLINGS | WS_CLIPCHILDREN,
                                   0, 0, 1, 1,
-                                  HWND_MESSAGE, NULL,
+                                  NULL, NULL,
                                   GetModuleHandleW(NULL),
                                   NULL);
     if (!window)
     {
-        _glfwInputError(GLFW_PLATFORM_ERROR,
+        _glfwInputErrorWin32(GLFW_PLATFORM_ERROR,
-                        "Win32: Failed to create helper window");
+                             "Win32: Failed to create helper window");
         return NULL;
     }
 
@@ -336,6 +356,12 @@ static HWND createHelperWindow(void)
                                     DEVICE_NOTIFY_WINDOW_HANDLE);
     }
 
+    while (PeekMessageW(&msg, _glfw.win32.helperWindowHandle, 0, 0, PM_REMOVE))
+    {
+        TranslateMessage(&msg);
+        DispatchMessageW(&msg);
+    }
+
    return window;
 }
 
@@ -349,16 +375,22 @@ static HWND createHelperWindow(void)
 WCHAR* _glfwCreateWideStringFromUTF8Win32(const char* source)
 {
     WCHAR* target;
-    int length;
+    int count;
 
-    length = MultiByteToWideChar(CP_UTF8, 0, source, -1, NULL, 0);
+    count = MultiByteToWideChar(CP_UTF8, 0, source, -1, NULL, 0);
-    if (!length)
+    if (!count)
-        return NULL;
-
-    target = calloc(length, sizeof(WCHAR));
-
-    if (!MultiByteToWideChar(CP_UTF8, 0, source, -1, target, length))
     {
+        _glfwInputErrorWin32(GLFW_PLATFORM_ERROR,
+                             "Win32: Failed to convert string from UTF-8");
+        return NULL;
+    }
+
+    target = calloc(count, sizeof(WCHAR));
+
+    if (!MultiByteToWideChar(CP_UTF8, 0, source, -1, target, count))
+    {
+        _glfwInputErrorWin32(GLFW_PLATFORM_ERROR,
+                             "Win32: Failed to convert string from UTF-8");
         free(target);
         return NULL;
     }
@@ -371,16 +403,22 @@ WCHAR* _glfwCreateWideStringFromUTF8Win32(const char* source)
 char* _glfwCreateUTF8FromWideStringWin32(const WCHAR* source)
 {
     char* target;
-    int length;
+    int size;
 
-    length = WideCharToMultiByte(CP_UTF8, 0, source, -1, NULL, 0, NULL, NULL);
+    size = WideCharToMultiByte(CP_UTF8, 0, source, -1, NULL, 0, NULL, NULL);
-    if (!length)
+    if (!size)
-        return NULL;
-
-    target = calloc(length, 1);
-
-    if (!WideCharToMultiByte(CP_UTF8, 0, source, -1, target, length, NULL, NULL))
     {
+        _glfwInputErrorWin32(GLFW_PLATFORM_ERROR,
+                             "Win32: Failed to convert string to UTF-8");
+        return NULL;
+    }
+
+    target = calloc(size, 1);
+
+    if (!WideCharToMultiByte(CP_UTF8, 0, source, -1, target, size, NULL, NULL))
+    {
+        _glfwInputErrorWin32(GLFW_PLATFORM_ERROR,
+                             "Win32: Failed to convert string to UTF-8");
         free(target);
         return NULL;
     }
@@ -388,6 +426,81 @@ char* _glfwCreateUTF8FromWideStringWin32(const WCHAR* source)
     return target;
 }
 
+// Reports the specified error, appending information about the last Win32 error
+//
+void _glfwInputErrorWin32(int error, const char* description)
+{
+    WCHAR buffer[_GLFW_MESSAGE_SIZE] = L"";
+    char message[_GLFW_MESSAGE_SIZE] = "";
+
+    FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM |
+                       FORMAT_MESSAGE_IGNORE_INSERTS |
+                       FORMAT_MESSAGE_MAX_WIDTH_MASK,
+                   NULL,
+                   GetLastError() & 0xffff,
+                   MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+                   buffer,
+                   sizeof(buffer),
+                   NULL);
+    WideCharToMultiByte(CP_UTF8, 0, buffer, -1, message, sizeof(message), NULL, NULL);
+
+    _glfwInputError(error, "%s: %s", description, message);
+}
+
+// Updates key names according to the current keyboard layout
+//
+void _glfwUpdateKeyNamesWin32(void)
+{
+    int key;
+    BYTE state[256] = {0};
+
+    memset(_glfw.win32.keynames, 0, sizeof(_glfw.win32.keynames));
+
+    for (key = GLFW_KEY_SPACE;  key <= GLFW_KEY_LAST;  key++)
+    {
+        UINT vk;
+        int scancode, length;
+        WCHAR chars[16];
+
+        scancode = _glfw.win32.scancodes[key];
+        if (scancode == -1)
+            continue;
+
+        if (key >= GLFW_KEY_KP_0 && key <= GLFW_KEY_KP_ADD)
+        {
+            const UINT vks[] = {
+                VK_NUMPAD0,  VK_NUMPAD1,  VK_NUMPAD2, VK_NUMPAD3,
+                VK_NUMPAD4,  VK_NUMPAD5,  VK_NUMPAD6, VK_NUMPAD7,
+                VK_NUMPAD8,  VK_NUMPAD9,  VK_DECIMAL, VK_DIVIDE,
+                VK_MULTIPLY, VK_SUBTRACT, VK_ADD
+            };
+
+            vk = vks[key - GLFW_KEY_KP_0];
+        }
+        else
+            vk = MapVirtualKey(scancode, MAPVK_VSC_TO_VK);
+
+        length = ToUnicode(vk, scancode, state,
+                           chars, sizeof(chars) / sizeof(WCHAR),
+                           0);
+
+        if (length == -1)
+        {
+            length = ToUnicode(vk, scancode, state,
+                               chars, sizeof(chars) / sizeof(WCHAR),
+                               0);
+        }
+
+        if (length < 1)
+            continue;
+
+        WideCharToMultiByte(CP_UTF8, 0, chars, 1,
+                            _glfw.win32.keynames[key],
+                            sizeof(_glfw.win32.keynames[key]),
+                            NULL, NULL);
+    }
+}
+
 
 //////////////////////////////////////////////////////////////////////////
 //////                       GLFW platform API                      //////
@@ -395,9 +508,6 @@ char* _glfwCreateUTF8FromWideStringWin32(const WCHAR* source)
 
 int _glfwPlatformInit(void)
 {
-    if (!_glfwInitThreadLocalStorageWin32())
-        return GLFW_FALSE;
-
     // To make SetForegroundWindow work as we want, we need to fiddle
     // with the FOREGROUNDLOCKTIMEOUT system setting (we do this as early
     // as possible in the hope of still being the foreground process)
@@ -410,11 +520,12 @@ int _glfwPlatformInit(void)
         return GLFW_FALSE;
 
     createKeyTables();
+    _glfwUpdateKeyNamesWin32();
 
-    if (_glfw_SetProcessDpiAwareness)
+    if (IsWindows8Point1OrGreater())
-        _glfw_SetProcessDpiAwareness(PROCESS_PER_MONITOR_DPI_AWARE);
+        SetProcessDpiAwareness(PROCESS_PER_MONITOR_DPI_AWARE);
-    else if (_glfw_SetProcessDPIAware)
+    else if (IsWindowsVistaOrGreater())
-        _glfw_SetProcessDPIAware();
+        SetProcessDPIAware();
 
     if (!_glfwRegisterWindowClassWin32())
         return GLFW_FALSE;
@@ -423,11 +534,10 @@ int _glfwPlatformInit(void)
     if (!_glfw.win32.helperWindowHandle)
         return GLFW_FALSE;
 
-    _glfwPlatformPollEvents();
-
     _glfwInitTimerWin32();
     _glfwInitJoysticksWin32();
 
+    _glfwPollMonitorsWin32();
     return GLFW_TRUE;
 }
 
@@ -444,12 +554,12 @@ void _glfwPlatformTerminate(void)
                           SPIF_SENDCHANGE);
 
     free(_glfw.win32.clipboardString);
+    free(_glfw.win32.rawInput);
 
     _glfwTerminateWGL();
     _glfwTerminateEGL();
 
     _glfwTerminateJoysticksWin32();
-    _glfwTerminateThreadLocalStorageWin32();
 
     freeLibraries();
 }

raylib/external/glfw/src/win32_joystick.c

@@ -1,8 +1,8 @@
 //========================================================================
-// GLFW 3.1 Win32 - www.glfw.org
+// GLFW 3.3 Win32 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-2016 Camilla Berglund <elmindreda@glfw.org>
+// Copyright (c) 2006-2016 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
@@ -27,13 +27,9 @@
 
 #include "internal.h"
 
+#include <stdio.h>
 #include <math.h>
 
-#include <initguid.h>
-
-#define _GLFW_PRESENCE_ONLY 1
-#define _GLFW_UPDATE_STATE  2
-
 #define _GLFW_TYPE_AXIS     0
 #define _GLFW_TYPE_SLIDER   1
 #define _GLFW_TYPE_BUTTON   2
@@ -52,18 +48,36 @@ typedef struct _GLFWobjenumWin32
     int                     povCount;
 } _GLFWobjenumWin32;
 
-// Define only the necessary GUIDs (it's bad enough that we're exporting these)
+// Define local copies of the necessary GUIDs
 //
-DEFINE_GUID(IID_IDirectInput8W,0xbf798031,0x483a,0x4da2,0xaa,0x99,0x5d,0x64,0xed,0x36,0x97,0x00);
+static const GUID _glfw_IID_IDirectInput8W =
-DEFINE_GUID(GUID_XAxis,0xa36d02e0,0xc9f3,0x11cf,0xbf,0xc7,0x44,0x45,0x53,0x54,0x00,0x00);
+    {0xbf798031,0x483a,0x4da2,{0xaa,0x99,0x5d,0x64,0xed,0x36,0x97,0x00}};
-DEFINE_GUID(GUID_YAxis,0xa36d02e1,0xc9f3,0x11cf,0xbf,0xc7,0x44,0x45,0x53,0x54,0x00,0x00);
+static const GUID _glfw_GUID_XAxis =
-DEFINE_GUID(GUID_ZAxis,0xa36d02e2,0xc9f3,0x11cf,0xbf,0xc7,0x44,0x45,0x53,0x54,0x00,0x00);
+    {0xa36d02e0,0xc9f3,0x11cf,{0xbf,0xc7,0x44,0x45,0x53,0x54,0x00,0x00}};
-DEFINE_GUID(GUID_RxAxis,0xa36d02f4,0xc9f3,0x11cf,0xbf,0xc7,0x44,0x45,0x53,0x54,0x00,0x00);
+static const GUID _glfw_GUID_YAxis =
-DEFINE_GUID(GUID_RyAxis,0xa36d02f5,0xc9f3,0x11cf,0xbf,0xc7,0x44,0x45,0x53,0x54,0x00,0x00);
+    {0xa36d02e1,0xc9f3,0x11cf,{0xbf,0xc7,0x44,0x45,0x53,0x54,0x00,0x00}};
-DEFINE_GUID(GUID_RzAxis,0xa36d02e3,0xc9f3,0x11cf,0xbf,0xc7,0x44,0x45,0x53,0x54,0x00,0x00);
+static const GUID _glfw_GUID_ZAxis =
-DEFINE_GUID(GUID_Slider,0xa36d02e4,0xc9f3,0x11cf,0xbf,0xc7,0x44,0x45,0x53,0x54,0x00,0x00);
+    {0xa36d02e2,0xc9f3,0x11cf,{0xbf,0xc7,0x44,0x45,0x53,0x54,0x00,0x00}};
-DEFINE_GUID(GUID_Button,0xa36d02f0,0xc9f3,0x11cf,0xbf,0xc7,0x44,0x45,0x53,0x54,0x00,0x00);
+static const GUID _glfw_GUID_RxAxis =
-DEFINE_GUID(GUID_POV,0xa36d02f2,0xc9f3,0x11cf,0xbf,0xc7,0x44,0x45,0x53,0x54,0x00,0x00);
+    {0xa36d02f4,0xc9f3,0x11cf,{0xbf,0xc7,0x44,0x45,0x53,0x54,0x00,0x00}};
+static const GUID _glfw_GUID_RyAxis =
+    {0xa36d02f5,0xc9f3,0x11cf,{0xbf,0xc7,0x44,0x45,0x53,0x54,0x00,0x00}};
+static const GUID _glfw_GUID_RzAxis =
+    {0xa36d02e3,0xc9f3,0x11cf,{0xbf,0xc7,0x44,0x45,0x53,0x54,0x00,0x00}};
+static const GUID _glfw_GUID_Slider =
+    {0xa36d02e4,0xc9f3,0x11cf,{0xbf,0xc7,0x44,0x45,0x53,0x54,0x00,0x00}};
+static const GUID _glfw_GUID_POV =
+    {0xa36d02f2,0xc9f3,0x11cf,{0xbf,0xc7,0x44,0x45,0x53,0x54,0x00,0x00}};
+
+#define IID_IDirectInput8W _glfw_IID_IDirectInput8W
+#define GUID_XAxis _glfw_GUID_XAxis
+#define GUID_YAxis _glfw_GUID_YAxis
+#define GUID_ZAxis _glfw_GUID_ZAxis
+#define GUID_RxAxis _glfw_GUID_RxAxis
+#define GUID_RyAxis _glfw_GUID_RyAxis
+#define GUID_RzAxis _glfw_GUID_RzAxis
+#define GUID_Slider _glfw_GUID_Slider
+#define GUID_POV _glfw_GUID_POV
 
 // Object data array for our clone of c_dfDIJoystick
 // Generated with https://github.com/elmindreda/c_dfDIJoystick2
@@ -149,9 +163,9 @@ static const char* getDeviceDescription(const XINPUT_CAPABILITIES* xic)
         case XINPUT_DEVSUBTYPE_GAMEPAD:
         {
             if (xic->Flags & XINPUT_CAPS_WIRELESS)
-                return "Wireless Xbox 360 Controller";
+                return "Wireless Xbox Controller";
             else
-                return "Xbox 360 Controller";
+                return "Xbox Controller";
         }
     }
 
@@ -238,25 +252,20 @@ static GLFWbool supportsXInput(const GUID* guid)
 
 // Frees all resources associated with the specified joystick
 //
-static void closeJoystick(_GLFWjoystickWin32* js)
+static void closeJoystick(_GLFWjoystick* js)
 {
-    if (js->device)
+    if (js->win32.device)
     {
-        IDirectInputDevice8_Unacquire(js->device);
+        IDirectInputDevice8_Unacquire(js->win32.device);
-        IDirectInputDevice8_Release(js->device);
+        IDirectInputDevice8_Release(js->win32.device);
     }
 
-    free(js->name);
+    _glfwFreeJoystick(js);
-    free(js->axes);
+    _glfwInputJoystick(js, GLFW_DISCONNECTED);
-    free(js->buttons);
-    free(js->objects);
-    memset(js, 0, sizeof(_GLFWjoystickWin32));
-
-    _glfwInputJoystickChange((int) (js - _glfw.win32_js), GLFW_DISCONNECTED);
 }
 
 // DirectInput device object enumeration callback
-// Insights gleaned from SDL2
+// Insights gleaned from SDL
 //
 static BOOL CALLBACK deviceObjectCallback(const DIDEVICEOBJECTINSTANCEW* doi,
                                           void* user)
@@ -332,28 +341,25 @@ static BOOL CALLBACK deviceObjectCallback(const DIDEVICEOBJECTINSTANCEW* doi,
 //
 static BOOL CALLBACK deviceCallback(const DIDEVICEINSTANCE* di, void* user)
 {
-    int joy = 0;
+    int jid = 0;
     DIDEVCAPS dc;
     DIPROPDWORD dipd;
     IDirectInputDevice8* device;
     _GLFWobjenumWin32 data;
-    _GLFWjoystickWin32* js;
+    _GLFWjoystick* js;
+    char guid[33];
+    char name[256];
 
-    for (joy = GLFW_JOYSTICK_1;  joy <= GLFW_JOYSTICK_LAST;  joy++)
+    for (jid = 0;  jid <= GLFW_JOYSTICK_LAST;  jid++)
     {
-        if (memcmp(&_glfw.win32_js[joy].guid, &di->guidInstance, sizeof(GUID)) == 0)
+        _GLFWjoystick* js = _glfw.joysticks + jid;
-            return DIENUM_CONTINUE;
+        if (js->present)
+        {
+            if (memcmp(&js->win32.guid, &di->guidInstance, sizeof(GUID)) == 0)
+                return DIENUM_CONTINUE;
+        }
     }
 
-    for (joy = GLFW_JOYSTICK_1;  joy <= GLFW_JOYSTICK_LAST;  joy++)
-    {
-        if (!_glfw.win32_js[joy].present)
-            break;
-    }
-
-    if (joy > GLFW_JOYSTICK_LAST)
-        return DIENUM_STOP;
-
     if (supportsXInput(&di->guidProduct))
         return DIENUM_CONTINUE;
 
@@ -362,14 +368,14 @@ static BOOL CALLBACK deviceCallback(const DIDEVICEINSTANCE* di, void* user)
                                           &device,
                                           NULL)))
     {
-        _glfwInputError(GLFW_PLATFORM_ERROR, "DI: Failed to create device");
+        _glfwInputError(GLFW_PLATFORM_ERROR, "Win32: Failed to create device");
         return DIENUM_CONTINUE;
     }
 
     if (FAILED(IDirectInputDevice8_SetDataFormat(device, &_glfwDataFormat)))
     {
         _glfwInputError(GLFW_PLATFORM_ERROR,
-                        "DI: Failed to set device data format");
+                        "Win32: Failed to set device data format");
 
         IDirectInputDevice8_Release(device);
         return DIENUM_CONTINUE;
@@ -381,7 +387,7 @@ static BOOL CALLBACK deviceCallback(const DIDEVICEINSTANCE* di, void* user)
     if (FAILED(IDirectInputDevice8_GetCapabilities(device, &dc)))
     {
         _glfwInputError(GLFW_PLATFORM_ERROR,
-                        "DI: Failed to query device capabilities");
+                        "Win32: Failed to query device capabilities");
 
         IDirectInputDevice8_Release(device);
         return DIENUM_CONTINUE;
@@ -398,7 +404,7 @@ static BOOL CALLBACK deviceCallback(const DIDEVICEINSTANCE* di, void* user)
                                                &dipd.diph)))
     {
         _glfwInputError(GLFW_PLATFORM_ERROR,
-                        "DI: Failed to set device axis mode");
+                        "Win32: Failed to set device axis mode");
 
         IDirectInputDevice8_Release(device);
         return DIENUM_CONTINUE;
@@ -415,7 +421,7 @@ static BOOL CALLBACK deviceCallback(const DIDEVICEINSTANCE* di, void* user)
                                                DIDFT_AXIS | DIDFT_BUTTON | DIDFT_POV)))
     {
         _glfwInputError(GLFW_PLATFORM_ERROR,
-                        "DI: Failed to enumerate device objects");
+                        "Win32: Failed to enumerate device objects");
 
         IDirectInputDevice8_Release(device);
         free(data.objects);
@@ -426,224 +432,54 @@ static BOOL CALLBACK deviceCallback(const DIDEVICEINSTANCE* di, void* user)
           sizeof(_GLFWjoyobjectWin32),
           compareJoystickObjects);
 
-    js = _glfw.win32_js + joy;
+    if (!WideCharToMultiByte(CP_UTF8, 0,
-    js->device = device;
+                             di->tszInstanceName, -1,
-    js->guid = di->guidInstance;
+                             name, sizeof(name),
-    js->axisCount = data.axisCount + data.sliderCount;
+                             NULL, NULL))
-    js->axes = calloc(js->axisCount, sizeof(float));
-    js->buttonCount += data.buttonCount + data.povCount * 4;
-    js->buttons = calloc(js->buttonCount, 1);
-    js->objects = data.objects;
-    js->objectCount = data.objectCount;
-    js->name = _glfwCreateUTF8FromWideStringWin32(di->tszInstanceName);
-    js->present = GLFW_TRUE;
-
-    _glfwInputJoystickChange(joy, GLFW_CONNECTED);
-    return DIENUM_CONTINUE;
-}
-
-// Attempt to open the specified joystick device
-// TODO: Pack state arrays for non-gamepad devices
-//
-static GLFWbool openXinputDevice(DWORD index)
-{
-    int joy;
-    XINPUT_CAPABILITIES xic;
-    _GLFWjoystickWin32* js;
-
-    for (joy = GLFW_JOYSTICK_1;  joy <= GLFW_JOYSTICK_LAST;  joy++)
     {
-        if (_glfw.win32_js[joy].present &&
+        _glfwInputError(GLFW_PLATFORM_ERROR,
-            _glfw.win32_js[joy].device == NULL &&
+                        "Win32: Failed to convert joystick name to UTF-8");
-            _glfw.win32_js[joy].index == index)
+
-        {
+        IDirectInputDevice8_Release(device);
-            return GLFW_FALSE;
+        free(data.objects);
-        }
+        return DIENUM_STOP;
     }
 
-    for (joy = GLFW_JOYSTICK_1;  joy <= GLFW_JOYSTICK_LAST;  joy++)
+    // Generate a joystick GUID that matches the SDL 2.0.5+ one
+    if (memcmp(&di->guidProduct.Data4[2], "PIDVID", 6) == 0)
     {
-        if (!_glfw.win32_js[joy].present)
+        sprintf(guid, "03000000%02x%02x0000%02x%02x000000000000",
-            break;
+                (uint8_t) di->guidProduct.Data1,
-    }
+                (uint8_t) (di->guidProduct.Data1 >> 8),
-
+                (uint8_t) (di->guidProduct.Data1 >> 16),
-    if (joy > GLFW_JOYSTICK_LAST)
+                (uint8_t) (di->guidProduct.Data1 >> 24));
-        return GLFW_FALSE;
-
-    if (_glfw_XInputGetCapabilities(index, 0, &xic) != ERROR_SUCCESS)
-        return GLFW_FALSE;
-
-    js = _glfw.win32_js + joy;
-    js->axisCount = 6;
-    js->axes = calloc(js->axisCount, sizeof(float));
-    js->buttonCount = 14;
-    js->buttons = calloc(js->buttonCount, 1);
-    js->present = GLFW_TRUE;
-    js->name = strdup(getDeviceDescription(&xic));
-    js->index = index;
-
-    _glfwInputJoystickChange(joy, GLFW_CONNECTED);
-
-    return GLFW_TRUE;
-}
-
-// Polls for and processes events the specified joystick
-//
-static GLFWbool pollJoystickState(_GLFWjoystickWin32* js, int mode)
-{
-    if (!js->present)
-        return GLFW_FALSE;
-
-    if (js->device)
-    {
-        int i, j, ai = 0, bi = 0;
-        HRESULT result;
-        DIJOYSTATE state;
-
-        IDirectInputDevice8_Poll(js->device);
-        result = IDirectInputDevice8_GetDeviceState(js->device,
-                                                    sizeof(state),
-                                                    &state);
-        if (result == DIERR_NOTACQUIRED || result == DIERR_INPUTLOST)
-        {
-            IDirectInputDevice8_Acquire(js->device);
-            IDirectInputDevice8_Poll(js->device);
-            result = IDirectInputDevice8_GetDeviceState(js->device,
-                                                        sizeof(state),
-                                                        &state);
-        }
-
-        if (FAILED(result))
-        {
-            closeJoystick(js);
-            return GLFW_FALSE;
-        }
-
-        if (mode == _GLFW_PRESENCE_ONLY)
-            return GLFW_TRUE;
-
-        for (i = 0;  i < js->objectCount;  i++)
-        {
-            const void* data = (char*) &state + js->objects[i].offset;
-
-            switch (js->objects[i].type)
-            {
-                case _GLFW_TYPE_AXIS:
-                case _GLFW_TYPE_SLIDER:
-                {
-                    js->axes[ai++] = (*((LONG*) data) + 0.5f) / 32767.5f;
-                    break;
-                }
-
-                case _GLFW_TYPE_BUTTON:
-                {
-                    if (*((BYTE*) data) & 0x80)
-                        js->buttons[bi++] = GLFW_PRESS;
-                    else
-                        js->buttons[bi++] = GLFW_RELEASE;
-
-                    break;
-                }
-
-                case _GLFW_TYPE_POV:
-                {
-                    const int directions[9] = { 1, 3, 2, 6, 4, 12, 8, 9, 0 };
-                    // Screams of horror are appropriate at this point
-                    int value = LOWORD(*(DWORD*) data) / (45 * DI_DEGREES);
-                    if (value < 0 || value > 8)
-                        value = 8;
-
-                    for (j = 0;  j < 4;  j++)
-                    {
-                        if (directions[value] & (1 << j))
-                            js->buttons[bi++] = GLFW_PRESS;
-                        else
-                            js->buttons[bi++] = GLFW_RELEASE;
-                    }
-
-                    break;
-                }
-            }
-        }
-
-        return GLFW_TRUE;
     }
     else
     {
-        int i;
+        sprintf(guid, "05000000%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x00",
-        DWORD result;
+                name[0], name[1], name[2], name[3],
-        XINPUT_STATE xis;
+                name[4], name[5], name[6], name[7],
-        const WORD buttons[14] =
+                name[8], name[9], name[10]);
-        {
-            XINPUT_GAMEPAD_A,
-            XINPUT_GAMEPAD_B,
-            XINPUT_GAMEPAD_X,
-            XINPUT_GAMEPAD_Y,
-            XINPUT_GAMEPAD_LEFT_SHOULDER,
-            XINPUT_GAMEPAD_RIGHT_SHOULDER,
-            XINPUT_GAMEPAD_BACK,
-            XINPUT_GAMEPAD_START,
-            XINPUT_GAMEPAD_LEFT_THUMB,
-            XINPUT_GAMEPAD_RIGHT_THUMB,
-            XINPUT_GAMEPAD_DPAD_UP,
-            XINPUT_GAMEPAD_DPAD_RIGHT,
-            XINPUT_GAMEPAD_DPAD_DOWN,
-            XINPUT_GAMEPAD_DPAD_LEFT
-        };
-
-        result = _glfw_XInputGetState(js->index, &xis);
-        if (result != ERROR_SUCCESS)
-        {
-            if (result == ERROR_DEVICE_NOT_CONNECTED)
-                closeJoystick(js);
-
-            return GLFW_FALSE;
-        }
-
-        if (mode == _GLFW_PRESENCE_ONLY)
-            return GLFW_TRUE;
-
-        if (sqrt((double) (xis.Gamepad.sThumbLX * xis.Gamepad.sThumbLX +
-                           xis.Gamepad.sThumbLY * xis.Gamepad.sThumbLY)) >
-            (double) XINPUT_GAMEPAD_LEFT_THUMB_DEADZONE)
-        {
-            js->axes[0] = (xis.Gamepad.sThumbLX + 0.5f) / 32767.f;
-            js->axes[1] = (xis.Gamepad.sThumbLY + 0.5f) / 32767.f;
-        }
-        else
-        {
-            js->axes[0] = 0.f;
-            js->axes[1] = 0.f;
-        }
-
-        if (sqrt((double) (xis.Gamepad.sThumbRX * xis.Gamepad.sThumbRX +
-                           xis.Gamepad.sThumbRY * xis.Gamepad.sThumbRY)) >
-            (double) XINPUT_GAMEPAD_RIGHT_THUMB_DEADZONE)
-        {
-            js->axes[2] = (xis.Gamepad.sThumbRX + 0.5f) / 32767.f;
-            js->axes[3] = (xis.Gamepad.sThumbRY + 0.5f) / 32767.f;
-        }
-        else
-        {
-            js->axes[2] = 0.f;
-            js->axes[3] = 0.f;
-        }
-
-        if (xis.Gamepad.bLeftTrigger > XINPUT_GAMEPAD_TRIGGER_THRESHOLD)
-            js->axes[4] = xis.Gamepad.bLeftTrigger / 127.5f - 1.f;
-        else
-            js->axes[4] = -1.f;
-
-        if (xis.Gamepad.bRightTrigger > XINPUT_GAMEPAD_TRIGGER_THRESHOLD)
-            js->axes[5] = xis.Gamepad.bRightTrigger / 127.5f - 1.f;
-        else
-            js->axes[5] = -1.f;
-
-        for (i = 0;  i < 14;  i++)
-            js->buttons[i] = (xis.Gamepad.wButtons & buttons[i]) ? 1 : 0;
-
-        return GLFW_TRUE;
     }
+
+    js = _glfwAllocJoystick(name, guid,
+                            data.axisCount + data.sliderCount,
+                            data.buttonCount,
+                            data.povCount);
+    if (!js)
+    {
+        IDirectInputDevice8_Release(device);
+        free(data.objects);
+        return DIENUM_STOP;
+    }
+
+    js->win32.device = device;
+    js->win32.guid = di->guidInstance;
+    js->win32.objects = data.objects;
+    js->win32.objectCount = data.objectCount;
+
+    _glfwInputJoystick(js, GLFW_CONNECTED);
+    return DIENUM_CONTINUE;
 }
 
 
@@ -657,14 +493,14 @@ void _glfwInitJoysticksWin32(void)
 {
     if (_glfw.win32.dinput8.instance)
     {
-        if (FAILED(_glfw_DirectInput8Create(GetModuleHandle(NULL),
+        if (FAILED(DirectInput8Create(GetModuleHandle(NULL),
-                                            DIRECTINPUT_VERSION,
+                                      DIRECTINPUT_VERSION,
-                                            &IID_IDirectInput8W,
+                                      &IID_IDirectInput8W,
-                                            (void**) &_glfw.win32.dinput8.api,
+                                      (void**) &_glfw.win32.dinput8.api,
-                                            NULL)))
+                                      NULL)))
         {
             _glfwInputError(GLFW_PLATFORM_ERROR,
-                            "DI: Failed to create interface");
+                            "Win32: Failed to create interface");
         }
     }
 
@@ -675,10 +511,10 @@ void _glfwInitJoysticksWin32(void)
 //
 void _glfwTerminateJoysticksWin32(void)
 {
-    int joy;
+    int jid;
 
-    for (joy = GLFW_JOYSTICK_1;  joy <= GLFW_JOYSTICK_LAST;  joy++)
+    for (jid = GLFW_JOYSTICK_1;  jid <= GLFW_JOYSTICK_LAST;  jid++)
-        closeJoystick(_glfw.win32_js + joy);
+        closeJoystick(_glfw.joysticks + jid);
 
     if (_glfw.win32.dinput8.api)
         IDirectInput8_Release(_glfw.win32.dinput8.api);
@@ -690,10 +526,43 @@ void _glfwDetectJoystickConnectionWin32(void)
 {
     if (_glfw.win32.xinput.instance)
     {
-        DWORD i;
+        DWORD index;
 
-        for (i = 0;  i < XUSER_MAX_COUNT;  i++)
+        for (index = 0;  index < XUSER_MAX_COUNT;  index++)
-            openXinputDevice(i);
+        {
+            int jid;
+            char guid[33];
+            XINPUT_CAPABILITIES xic;
+            _GLFWjoystick* js;
+
+            for (jid = 0;  jid <= GLFW_JOYSTICK_LAST;  jid++)
+            {
+                if (_glfw.joysticks[jid].present &&
+                    _glfw.joysticks[jid].win32.device == NULL &&
+                    _glfw.joysticks[jid].win32.index == index)
+                {
+                    break;
+                }
+            }
+
+            if (jid <= GLFW_JOYSTICK_LAST)
+                continue;
+
+            if (XInputGetCapabilities(index, 0, &xic) != ERROR_SUCCESS)
+                continue;
+
+            // Generate a joystick GUID that matches the SDL 2.0.5+ one
+            sprintf(guid, "78696e707574%02x000000000000000000",
+                    xic.SubType & 0xff);
+
+            js = _glfwAllocJoystick(getDeviceDescription(&xic), guid, 6, 10, 1);
+            if (!js)
+                continue;
+
+            js->win32.index = index;
+
+            _glfwInputJoystick(js, GLFW_CONNECTED);
+        }
     }
 
     if (_glfw.win32.dinput8.api)
@@ -715,10 +584,14 @@ void _glfwDetectJoystickConnectionWin32(void)
 //
 void _glfwDetectJoystickDisconnectionWin32(void)
 {
-    int joy;
+    int jid;
 
-    for (joy = GLFW_JOYSTICK_1;  joy <= GLFW_JOYSTICK_LAST;  joy++)
+    for (jid = 0;  jid <= GLFW_JOYSTICK_LAST;  jid++)
-        pollJoystickState(_glfw.win32_js + joy, _GLFW_PRESENCE_ONLY);
+    {
+        _GLFWjoystick* js = _glfw.joysticks + jid;
+        if (js->present)
+            _glfwPlatformPollJoystick(js, _GLFW_POLL_PRESENCE);
+    }
 }
 
 
@@ -726,38 +599,153 @@ void _glfwDetectJoystickDisconnectionWin32(void)
 //////                       GLFW platform API                      //////
 //////////////////////////////////////////////////////////////////////////
 
-int _glfwPlatformJoystickPresent(int joy)
+int _glfwPlatformPollJoystick(_GLFWjoystick* js, int mode)
 {
-    _GLFWjoystickWin32* js = _glfw.win32_js + joy;
+    if (js->win32.device)
-    return pollJoystickState(js, _GLFW_PRESENCE_ONLY);
+    {
+        int i, ai = 0, bi = 0, pi = 0;
+        HRESULT result;
+        DIJOYSTATE state;
+
+        IDirectInputDevice8_Poll(js->win32.device);
+        result = IDirectInputDevice8_GetDeviceState(js->win32.device,
+                                                    sizeof(state),
+                                                    &state);
+        if (result == DIERR_NOTACQUIRED || result == DIERR_INPUTLOST)
+        {
+            IDirectInputDevice8_Acquire(js->win32.device);
+            IDirectInputDevice8_Poll(js->win32.device);
+            result = IDirectInputDevice8_GetDeviceState(js->win32.device,
+                                                        sizeof(state),
+                                                        &state);
+        }
+
+        if (FAILED(result))
+        {
+            closeJoystick(js);
+            return GLFW_FALSE;
+        }
+
+        if (mode == _GLFW_POLL_PRESENCE)
+            return GLFW_TRUE;
+
+        for (i = 0;  i < js->win32.objectCount;  i++)
+        {
+            const void* data = (char*) &state + js->win32.objects[i].offset;
+
+            switch (js->win32.objects[i].type)
+            {
+                case _GLFW_TYPE_AXIS:
+                case _GLFW_TYPE_SLIDER:
+                {
+                    const float value = (*((LONG*) data) + 0.5f) / 32767.5f;
+                    _glfwInputJoystickAxis(js, ai, value);
+                    ai++;
+                    break;
+                }
+
+                case _GLFW_TYPE_BUTTON:
+                {
+                    const char value = (*((BYTE*) data) & 0x80) != 0;
+                    _glfwInputJoystickButton(js, bi, value);
+                    bi++;
+                    break;
+                }
+
+                case _GLFW_TYPE_POV:
+                {
+                    const int states[9] =
+                    {
+                        GLFW_HAT_UP,
+                        GLFW_HAT_RIGHT_UP,
+                        GLFW_HAT_RIGHT,
+                        GLFW_HAT_RIGHT_DOWN,
+                        GLFW_HAT_DOWN,
+                        GLFW_HAT_LEFT_DOWN,
+                        GLFW_HAT_LEFT,
+                        GLFW_HAT_LEFT_UP,
+                        GLFW_HAT_CENTERED
+                    };
+
+                    // Screams of horror are appropriate at this point
+                    int state = LOWORD(*(DWORD*) data) / (45 * DI_DEGREES);
+                    if (state < 0 || state > 8)
+                        state = 8;
+
+                    _glfwInputJoystickHat(js, pi, states[state]);
+                    pi++;
+                    break;
+                }
+            }
+        }
+    }
+    else
+    {
+        int i, dpad = 0;
+        DWORD result;
+        XINPUT_STATE xis;
+        const WORD buttons[10] =
+        {
+            XINPUT_GAMEPAD_A,
+            XINPUT_GAMEPAD_B,
+            XINPUT_GAMEPAD_X,
+            XINPUT_GAMEPAD_Y,
+            XINPUT_GAMEPAD_LEFT_SHOULDER,
+            XINPUT_GAMEPAD_RIGHT_SHOULDER,
+            XINPUT_GAMEPAD_BACK,
+            XINPUT_GAMEPAD_START,
+            XINPUT_GAMEPAD_LEFT_THUMB,
+            XINPUT_GAMEPAD_RIGHT_THUMB
+        };
+
+        result = XInputGetState(js->win32.index, &xis);
+        if (result != ERROR_SUCCESS)
+        {
+            if (result == ERROR_DEVICE_NOT_CONNECTED)
+                closeJoystick(js);
+
+            return GLFW_FALSE;
+        }
+
+        if (mode == _GLFW_POLL_PRESENCE)
+            return GLFW_TRUE;
+
+        _glfwInputJoystickAxis(js, 0, (xis.Gamepad.sThumbLX + 0.5f) / 32767.5f);
+        _glfwInputJoystickAxis(js, 1, -(xis.Gamepad.sThumbLY + 0.5f) / 32767.5f);
+        _glfwInputJoystickAxis(js, 2, (xis.Gamepad.sThumbRX + 0.5f) / 32767.5f);
+        _glfwInputJoystickAxis(js, 3, -(xis.Gamepad.sThumbRY + 0.5f) / 32767.5f);
+        _glfwInputJoystickAxis(js, 4, xis.Gamepad.bLeftTrigger / 127.5f - 1.f);
+        _glfwInputJoystickAxis(js, 5, xis.Gamepad.bRightTrigger / 127.5f - 1.f);
+
+        for (i = 0;  i < 10;  i++)
+        {
+            const char value = (xis.Gamepad.wButtons & buttons[i]) ? 1 : 0;
+            _glfwInputJoystickButton(js, i, value);
+        }
+
+        if (xis.Gamepad.wButtons & XINPUT_GAMEPAD_DPAD_UP)
+            dpad |= GLFW_HAT_UP;
+        if (xis.Gamepad.wButtons & XINPUT_GAMEPAD_DPAD_RIGHT)
+            dpad |= GLFW_HAT_RIGHT;
+        if (xis.Gamepad.wButtons & XINPUT_GAMEPAD_DPAD_DOWN)
+            dpad |= GLFW_HAT_DOWN;
+        if (xis.Gamepad.wButtons & XINPUT_GAMEPAD_DPAD_LEFT)
+            dpad |= GLFW_HAT_LEFT;
+
+        _glfwInputJoystickHat(js, 0, dpad);
+    }
+
+    return GLFW_TRUE;
 }
 
-const float* _glfwPlatformGetJoystickAxes(int joy, int* count)
+void _glfwPlatformUpdateGamepadGUID(char* guid)
 {
-    _GLFWjoystickWin32* js = _glfw.win32_js + joy;
+    if (strcmp(guid + 20, "504944564944") == 0)
-    if (!pollJoystickState(js, _GLFW_UPDATE_STATE))
+    {
-        return NULL;
+        char original[33];
-
+        strcpy(original, guid);
-    *count = js->axisCount;
+        sprintf(guid, "03000000%.4s0000%.4s000000000000",
-    return js->axes;
+                original, original + 4);
-}
+    }
-
-const unsigned char* _glfwPlatformGetJoystickButtons(int joy, int* count)
-{
-    _GLFWjoystickWin32* js = _glfw.win32_js + joy;
-    if (!pollJoystickState(js, _GLFW_UPDATE_STATE))
-        return NULL;
-
-    *count = js->buttonCount;
-    return js->buttons;
-}
-
-const char* _glfwPlatformGetJoystickName(int joy)
-{
-    _GLFWjoystickWin32* js = _glfw.win32_js + joy;
-    if (!pollJoystickState(js, _GLFW_PRESENCE_ONLY))
-        return NULL;
-
-    return js->name;
 }
 

raylib/external/glfw/src/win32_joystick.h

@@ -1,7 +1,7 @@
 //========================================================================
-// GLFW 3.2 Win32 - www.glfw.org
+// GLFW 3.3 Win32 - www.glfw.org
 //------------------------------------------------------------------------
-// Copyright (c) 2006-2016 Camilla Berglund <elmindreda@glfw.org>
+// Copyright (c) 2006-2016 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
@@ -24,11 +24,10 @@
 //
 //========================================================================
 
-#ifndef _glfw3_win32_joystick_h_
+#define _GLFW_PLATFORM_JOYSTICK_STATE         _GLFWjoystickWin32 win32
-#define _glfw3_win32_joystick_h_
+#define _GLFW_PLATFORM_LIBRARY_JOYSTICK_STATE int dummy
 
-#define _GLFW_PLATFORM_LIBRARY_JOYSTICK_STATE \
+#define _GLFW_PLATFORM_MAPPING_NAME "Windows"
-    _GLFWjoystickWin32 win32_js[GLFW_JOYSTICK_LAST + 1]
 
 // Joystick element (axis, button or slider)
 //
@@ -42,14 +41,8 @@ typedef struct _GLFWjoyobjectWin32
 //
 typedef struct _GLFWjoystickWin32
 {
-    GLFWbool                present;
-    float*                  axes;
-    int                     axisCount;
-    unsigned char*          buttons;
-    int                     buttonCount;
     _GLFWjoyobjectWin32*    objects;
     int                     objectCount;
-    char*                   name;
     IDirectInputDevice8W*   device;
     DWORD                   index;
     GUID                    guid;
@@ -61,4 +54,3 @@ void _glfwTerminateJoysticksWin32(void);
 void _glfwDetectJoystickConnectionWin32(void);
 void _glfwDetectJoystickDisconnectionWin32(void);
 
-#endif // _glfw3_win32_joystick_h_

raylib/external/glfw/src/win32_monitor.c

@@ -1,8 +1,8 @@
 //========================================================================
-// GLFW 3.2 Win32 - www.glfw.org
+// GLFW 3.3 Win32 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-2016 Camilla Berglund <elmindreda@glfw.org>
+// Copyright (c) 2006-2016 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
@@ -33,33 +33,66 @@
 #include <malloc.h>
 
 
+// Callback for EnumDisplayMonitors in createMonitor
+//
+static BOOL CALLBACK monitorCallback(HMONITOR handle,
+                                     HDC dc,
+                                     RECT* rect,
+                                     LPARAM data)
+{
+    MONITORINFOEXW mi;
+    ZeroMemory(&mi, sizeof(mi));
+    mi.cbSize = sizeof(mi);
+
+    if (GetMonitorInfoW(handle, (MONITORINFO*) &mi))
+    {
+        _GLFWmonitor* monitor = (_GLFWmonitor*) data;
+        if (wcscmp(mi.szDevice, monitor->win32.adapterName) == 0)
+            monitor->win32.handle = handle;
+    }
+
+    return TRUE;
+}
+
 // Create monitor from an adapter and (optionally) a display
 //
 static _GLFWmonitor* createMonitor(DISPLAY_DEVICEW* adapter,
                                    DISPLAY_DEVICEW* display)
 {
     _GLFWmonitor* monitor;
+    int widthMM, heightMM;
     char* name;
     HDC dc;
+    DEVMODEW dm;
+    RECT rect;
 
     if (display)
         name = _glfwCreateUTF8FromWideStringWin32(display->DeviceString);
     else
         name = _glfwCreateUTF8FromWideStringWin32(adapter->DeviceString);
     if (!name)
-    {
-        _glfwInputError(GLFW_PLATFORM_ERROR,
-                        "Win32: Failed to convert string to UTF-8");
         return NULL;
-    }
+
+    ZeroMemory(&dm, sizeof(dm));
+    dm.dmSize = sizeof(dm);
+    EnumDisplaySettingsW(adapter->DeviceName, ENUM_CURRENT_SETTINGS, &dm);
 
     dc = CreateDCW(L"DISPLAY", adapter->DeviceName, NULL, NULL);
 
-    monitor = _glfwAllocMonitor(name,
+    if (IsWindows8Point1OrGreater())
-                                GetDeviceCaps(dc, HORZSIZE),
+    {
-                                GetDeviceCaps(dc, VERTSIZE));
+        widthMM  = GetDeviceCaps(dc, HORZSIZE);
+        heightMM = GetDeviceCaps(dc, VERTSIZE);
+    }
+    else
+    {
+        widthMM  = (int) (dm.dmPelsWidth * 25.4f / GetDeviceCaps(dc, LOGPIXELSX));
+        heightMM = (int) (dm.dmPelsHeight * 25.4f / GetDeviceCaps(dc, LOGPIXELSY));
+    }
 
     DeleteDC(dc);
+
+    monitor = _glfwAllocMonitor(name, widthMM, heightMM);
     free(name);
 
     if (adapter->StateFlags & DISPLAY_DEVICE_MODESPRUNED)
@@ -82,6 +115,12 @@ static _GLFWmonitor* createMonitor(DISPLAY_DEVICEW* adapter,
                             NULL, NULL);
     }
 
+    rect.left   = dm.dmPosition.x;
+    rect.top    = dm.dmPosition.y;
+    rect.right  = dm.dmPosition.x + dm.dmPelsWidth;
+    rect.bottom = dm.dmPosition.y + dm.dmPelsHeight;
+
+    EnumDisplayMonitors(NULL, &rect, monitorCallback, (LPARAM) monitor);
     return monitor;
 }
 
@@ -90,6 +129,116 @@ static _GLFWmonitor* createMonitor(DISPLAY_DEVICEW* adapter,
 //////                       GLFW internal API                      //////
 //////////////////////////////////////////////////////////////////////////
 
+// Poll for changes in the set of connected monitors
+//
+void _glfwPollMonitorsWin32(void)
+{
+    int i, disconnectedCount;
+    _GLFWmonitor** disconnected = NULL;
+    DWORD adapterIndex, displayIndex;
+    DISPLAY_DEVICEW adapter, display;
+    _GLFWmonitor* monitor;
+
+    disconnectedCount = _glfw.monitorCount;
+    if (disconnectedCount)
+    {
+        disconnected = calloc(_glfw.monitorCount, sizeof(_GLFWmonitor*));
+        memcpy(disconnected,
+               _glfw.monitors,
+               _glfw.monitorCount * sizeof(_GLFWmonitor*));
+    }
+
+    for (adapterIndex = 0;  ;  adapterIndex++)
+    {
+        int type = _GLFW_INSERT_LAST;
+
+        ZeroMemory(&adapter, sizeof(adapter));
+        adapter.cb = sizeof(adapter);
+
+        if (!EnumDisplayDevicesW(NULL, adapterIndex, &adapter, 0))
+            break;
+
+        if (!(adapter.StateFlags & DISPLAY_DEVICE_ACTIVE))
+            continue;
+
+        if (adapter.StateFlags & DISPLAY_DEVICE_PRIMARY_DEVICE)
+            type = _GLFW_INSERT_FIRST;
+
+        for (displayIndex = 0;  ;  displayIndex++)
+        {
+            ZeroMemory(&display, sizeof(display));
+            display.cb = sizeof(display);
+
+            if (!EnumDisplayDevicesW(adapter.DeviceName, displayIndex, &display, 0))
+                break;
+
+            if (!(display.StateFlags & DISPLAY_DEVICE_ACTIVE))
+                continue;
+
+            for (i = 0;  i < disconnectedCount;  i++)
+            {
+                if (disconnected[i] &&
+                    wcscmp(disconnected[i]->win32.displayName,
+                           display.DeviceName) == 0)
+                {
+                    disconnected[i] = NULL;
+                    break;
+                }
+            }
+
+            if (i < disconnectedCount)
+                continue;
+
+            monitor = createMonitor(&adapter, &display);
+            if (!monitor)
+            {
+                free(disconnected);
+                return;
+            }
+
+            _glfwInputMonitor(monitor, GLFW_CONNECTED, type);
+
+            type = _GLFW_INSERT_LAST;
+        }
+
+        // HACK: If an active adapter does not have any display devices
+        //       (as sometimes happens), add it directly as a monitor
+        if (displayIndex == 0)
+        {
+            for (i = 0;  i < disconnectedCount;  i++)
+            {
+                if (disconnected[i] &&
+                    wcscmp(disconnected[i]->win32.adapterName,
+                           adapter.DeviceName) == 0)
+                {
+                    disconnected[i] = NULL;
+                    break;
+                }
+            }
+
+            if (i < disconnectedCount)
+                continue;
+
+            monitor = createMonitor(&adapter, NULL);
+            if (!monitor)
+            {
+                free(disconnected);
+                return;
+            }
+
+            _glfwInputMonitor(monitor, GLFW_CONNECTED, type);
+        }
+    }
+
+    for (i = 0;  i < disconnectedCount;  i++)
+    {
+        if (disconnected[i])
+            _glfwInputMonitor(disconnected[i], GLFW_DISCONNECTED, 0);
+    }
+
+    free(disconnected);
+}
+
 // Change the current video mode
 //
 GLFWbool _glfwSetVideoModeWin32(_GLFWmonitor* monitor, const GLFWvidmode* desired)
@@ -97,6 +246,7 @@ GLFWbool _glfwSetVideoModeWin32(_GLFWmonitor* monitor, const GLFWvidmode* desire
     GLFWvidmode current;
     const GLFWvidmode* best;
     DEVMODEW dm;
+    LONG result;
 
     best = _glfwChooseVideoMode(monitor, desired);
     _glfwPlatformGetVideoMode(monitor, &current);
@@ -104,7 +254,7 @@ GLFWbool _glfwSetVideoModeWin32(_GLFWmonitor* monitor, const GLFWvidmode* desire
         return GLFW_TRUE;
 
     ZeroMemory(&dm, sizeof(dm));
-    dm.dmSize = sizeof(DEVMODEW);
+    dm.dmSize = sizeof(dm);
     dm.dmFields           = DM_PELSWIDTH | DM_PELSHEIGHT | DM_BITSPERPEL |
                             DM_DISPLAYFREQUENCY;
     dm.dmPelsWidth        = best->width;
@@ -115,13 +265,34 @@ GLFWbool _glfwSetVideoModeWin32(_GLFWmonitor* monitor, const GLFWvidmode* desire
     if (dm.dmBitsPerPel < 15 || dm.dmBitsPerPel >= 24)
         dm.dmBitsPerPel = 32;
 
-    if (ChangeDisplaySettingsExW(monitor->win32.adapterName,
+    result = ChangeDisplaySettingsExW(monitor->win32.adapterName,
-                                 &dm,
+                                      &dm,
-                                 NULL,
+                                      NULL,
-                                 CDS_FULLSCREEN,
+                                      CDS_FULLSCREEN,
-                                 NULL) != DISP_CHANGE_SUCCESSFUL)
+                                      NULL);
+    if (result != DISP_CHANGE_SUCCESSFUL)
     {
-        _glfwInputError(GLFW_PLATFORM_ERROR, "Win32: Failed to set video mode");
+        const char* description = "Unknown error";
+
+        if (result == DISP_CHANGE_BADDUALVIEW)
+            description = "The system uses DualView";
+        else if (result == DISP_CHANGE_BADFLAGS)
+            description = "Invalid flags";
+        else if (result == DISP_CHANGE_BADMODE)
+            description = "Graphics mode not supported";
+        else if (result == DISP_CHANGE_BADPARAM)
+            description = "Invalid parameter";
+        else if (result == DISP_CHANGE_FAILED)
+            description = "Graphics mode failed";
+        else if (result == DISP_CHANGE_NOTUPDATED)
+            description = "Failed to write to registry";
+        else if (result == DISP_CHANGE_RESTART)
+            description = "Computer restart required";
+
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "Win32: Failed to set video mode: %s",
+                        description);
+
         return GLFW_FALSE;
     }
 
@@ -141,111 +312,52 @@ void _glfwRestoreVideoModeWin32(_GLFWmonitor* monitor)
     }
 }
 
+void _glfwGetMonitorContentScaleWin32(HMONITOR handle, float* xscale, float* yscale)
+{
+    UINT xdpi, ydpi;
+
+    if (IsWindows8Point1OrGreater())
+        GetDpiForMonitor(handle, MDT_EFFECTIVE_DPI, &xdpi, &ydpi);
+    else
+    {
+        const HDC dc = GetDC(NULL);
+        xdpi = GetDeviceCaps(dc, LOGPIXELSX);
+        ydpi = GetDeviceCaps(dc, LOGPIXELSY);
+        ReleaseDC(NULL, dc);
+    }
+
+    if (xscale)
+        *xscale = xdpi / 96.f;
+    if (yscale)
+        *yscale = ydpi / 96.f;
+}
+
 
 //////////////////////////////////////////////////////////////////////////
 //////                       GLFW platform API                      //////
 //////////////////////////////////////////////////////////////////////////
 
-_GLFWmonitor** _glfwPlatformGetMonitors(int* count)
-{
-    int found = 0;
-    DWORD adapterIndex, displayIndex, primaryIndex = 0;
-    DISPLAY_DEVICEW adapter, display;
-    GLFWbool hasDisplays = GLFW_FALSE;
-    _GLFWmonitor** monitors = NULL;
-
-    *count = 0;
-
-    // HACK: Check if any active adapters have connected displays
-    //       If not, this is a headless system or a VMware guest
-
-    for (adapterIndex = 0;  ;  adapterIndex++)
-    {
-        ZeroMemory(&adapter, sizeof(DISPLAY_DEVICEW));
-        adapter.cb = sizeof(DISPLAY_DEVICEW);
-
-        if (!EnumDisplayDevicesW(NULL, adapterIndex, &adapter, 0))
-            break;
-
-        if (!(adapter.StateFlags & DISPLAY_DEVICE_ACTIVE))
-            continue;
-
-        ZeroMemory(&display, sizeof(DISPLAY_DEVICEW));
-        display.cb = sizeof(DISPLAY_DEVICEW);
-
-        if (EnumDisplayDevicesW(adapter.DeviceName, 0, &display, 0))
-        {
-            hasDisplays = GLFW_TRUE;
-            break;
-        }
-    }
-
-    for (adapterIndex = 0;  ;  adapterIndex++)
-    {
-        ZeroMemory(&adapter, sizeof(DISPLAY_DEVICEW));
-        adapter.cb = sizeof(DISPLAY_DEVICEW);
-
-        if (!EnumDisplayDevicesW(NULL, adapterIndex, &adapter, 0))
-            break;
-
-        if (!(adapter.StateFlags & DISPLAY_DEVICE_ACTIVE))
-            continue;
-
-        if (adapter.StateFlags & DISPLAY_DEVICE_PRIMARY_DEVICE)
-            primaryIndex = found;
-
-        if (hasDisplays)
-        {
-            for (displayIndex = 0;  ;  displayIndex++)
-            {
-                ZeroMemory(&display, sizeof(DISPLAY_DEVICEW));
-                display.cb = sizeof(DISPLAY_DEVICEW);
-
-                if (!EnumDisplayDevicesW(adapter.DeviceName, displayIndex, &display, 0))
-                    break;
-
-                found++;
-                monitors = realloc(monitors, sizeof(_GLFWmonitor*) * found);
-                monitors[found - 1] = createMonitor(&adapter, &display);
-            }
-        }
-        else
-        {
-            found++;
-            monitors = realloc(monitors, sizeof(_GLFWmonitor*) * found);
-            monitors[found - 1] = createMonitor(&adapter, NULL);
-        }
-    }
-
-    _GLFW_SWAP_POINTERS(monitors[0], monitors[primaryIndex]);
-
-    *count = found;
-    return monitors;
-}
-
-GLFWbool _glfwPlatformIsSameMonitor(_GLFWmonitor* first, _GLFWmonitor* second)
-{
-    if (wcslen(first->win32.displayName))
-        return wcscmp(first->win32.displayName, second->win32.displayName) == 0;
-    else
-        return wcscmp(first->win32.adapterName, second->win32.adapterName) == 0;
-}
-
 void _glfwPlatformGetMonitorPos(_GLFWmonitor* monitor, int* xpos, int* ypos)
 {
-    DEVMODEW settings;
+    DEVMODEW dm;
-    ZeroMemory(&settings, sizeof(DEVMODEW));
+    ZeroMemory(&dm, sizeof(dm));
-    settings.dmSize = sizeof(DEVMODEW);
+    dm.dmSize = sizeof(dm);
 
     EnumDisplaySettingsExW(monitor->win32.adapterName,
                            ENUM_CURRENT_SETTINGS,
-                           &settings,
+                           &dm,
                            EDS_ROTATEDMODE);
 
     if (xpos)
-        *xpos = settings.dmPosition.x;
+        *xpos = dm.dmPosition.x;
     if (ypos)
-        *ypos = settings.dmPosition.y;
+        *ypos = dm.dmPosition.y;
+}
+
+void _glfwPlatformGetMonitorContentScale(_GLFWmonitor* monitor,
+                                         float* xscale, float* yscale)
+{
+    _glfwGetMonitorContentScaleWin32(monitor->win32.handle, xscale, yscale);
 }
 
 GLFWvidmode* _glfwPlatformGetVideoModes(_GLFWmonitor* monitor, int* count)
@@ -261,8 +373,8 @@ GLFWvidmode* _glfwPlatformGetVideoModes(_GLFWmonitor* monitor, int* count)
         GLFWvidmode mode;
         DEVMODEW dm;
 
-        ZeroMemory(&dm, sizeof(DEVMODEW));
+        ZeroMemory(&dm, sizeof(dm));
-        dm.dmSize = sizeof(DEVMODEW);
+        dm.dmSize = sizeof(dm);
 
         if (!EnumDisplaySettingsW(monitor->win32.adapterName, modeIndex, &dm))
             break;
@@ -328,9 +440,8 @@ GLFWvidmode* _glfwPlatformGetVideoModes(_GLFWmonitor* monitor, int* count)
 void _glfwPlatformGetVideoMode(_GLFWmonitor* monitor, GLFWvidmode* mode)
 {
     DEVMODEW dm;
-
+    ZeroMemory(&dm, sizeof(dm));
-    ZeroMemory(&dm, sizeof(DEVMODEW));
+    dm.dmSize = sizeof(dm);
-    dm.dmSize = sizeof(DEVMODEW);
 
     EnumDisplaySettingsW(monitor->win32.adapterName, ENUM_CURRENT_SETTINGS, &dm);
 

raylib/external/glfw/src/win32_platform.h

@@ -1,8 +1,8 @@
 //========================================================================
-// GLFW 3.2 Win32 - www.glfw.org
+// GLFW 3.3 Win32 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-2016 Camilla Berglund <elmindreda@glfw.org>
+// Copyright (c) 2006-2016 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
@@ -25,9 +25,6 @@
 //
 //========================================================================
 
-#ifndef _glfw3_win32_platform_h_
-#define _glfw3_win32_platform_h_
-
 // We don't need all the fancy stuff
 #ifndef NOMINMAX
  #define NOMINMAX
@@ -66,7 +63,6 @@
 
 #include <wctype.h>
 #include <windows.h>
-#include <mmsystem.h>
 #include <dinput.h>
 #include <xinput.h>
 #include <dbt.h>
@@ -104,6 +100,9 @@
 #ifndef DISPLAY_DEVICE_ACTIVE
  #define DISPLAY_DEVICE_ACTIVE 0x00000001
 #endif
+#ifndef _WIN32_WINNT_WINBLUE
+ #define _WIN32_WINNT_WINBLUE 0x0602
+#endif
 
 #if WINVER < 0x0601
 typedef struct tagCHANGEFILTERSTRUCT
@@ -117,6 +116,18 @@ typedef struct tagCHANGEFILTERSTRUCT
 #endif
 #endif /*Windows 7*/
 
+#if WINVER < 0x0600
+#define DWM_BB_ENABLE 0x00000001
+#define DWM_BB_BLURREGION 0x00000002
+typedef struct
+{
+    DWORD dwFlags;
+    BOOL fEnable;
+    HRGN hRgnBlur;
+    BOOL fTransitionOnMaximized;
+} DWM_BLURBEHIND;
+#endif /*Windows Vista*/
+
 #ifndef DPI_ENUMS_DECLARED
 typedef enum PROCESS_DPI_AWARENESS
 {
@@ -124,8 +135,30 @@ typedef enum PROCESS_DPI_AWARENESS
     PROCESS_SYSTEM_DPI_AWARE = 1,
     PROCESS_PER_MONITOR_DPI_AWARE = 2
 } PROCESS_DPI_AWARENESS;
+typedef enum MONITOR_DPI_TYPE
+{
+    MDT_EFFECTIVE_DPI = 0,
+    MDT_ANGULAR_DPI = 1,
+    MDT_RAW_DPI = 2,
+    MDT_DEFAULT = MDT_EFFECTIVE_DPI
+} MONITOR_DPI_TYPE;
 #endif /*DPI_ENUMS_DECLARED*/
 
+// HACK: Define versionhelpers.h functions manually as MinGW lacks the header
+BOOL IsWindowsVersionOrGreater(WORD major, WORD minor, WORD sp);
+#define IsWindowsVistaOrGreater()                              \
+    IsWindowsVersionOrGreater(HIBYTE(_WIN32_WINNT_VISTA),      \
+                              LOBYTE(_WIN32_WINNT_VISTA), 0)
+#define IsWindows7OrGreater()                                  \
+    IsWindowsVersionOrGreater(HIBYTE(_WIN32_WINNT_WIN7),       \
+                              LOBYTE(_WIN32_WINNT_WIN7), 0)
+#define IsWindows8OrGreater()                                  \
+    IsWindowsVersionOrGreater(HIBYTE(_WIN32_WINNT_WIN8),       \
+                              LOBYTE(_WIN32_WINNT_WIN8), 0)
+#define IsWindows8Point1OrGreater()                            \
+    IsWindowsVersionOrGreater(HIBYTE(_WIN32_WINNT_WINBLUE),    \
+                              LOBYTE(_WIN32_WINNT_WINBLUE), 0)
+
 // HACK: Define macros that some xinput.h variants don't
 #ifndef XINPUT_CAPS_WIRELESS
  #define XINPUT_CAPS_WIRELESS 0x0002
@@ -161,34 +194,38 @@ typedef enum PROCESS_DPI_AWARENESS
 #endif
 
 // winmm.dll function pointer typedefs
-typedef DWORD (WINAPI * TIMEGETTIME_T)(void);
+typedef DWORD (WINAPI * PFN_timeGetTime)(void);
-#define _glfw_timeGetTime _glfw.win32.winmm.timeGetTime
+#define timeGetTime _glfw.win32.winmm.GetTime
 
 // xinput.dll function pointer typedefs
-typedef DWORD (WINAPI * XINPUTGETCAPABILITIES_T)(DWORD,DWORD,XINPUT_CAPABILITIES*);
+typedef DWORD (WINAPI * PFN_XInputGetCapabilities)(DWORD,DWORD,XINPUT_CAPABILITIES*);
-typedef DWORD (WINAPI * XINPUTGETSTATE_T)(DWORD,XINPUT_STATE*);
+typedef DWORD (WINAPI * PFN_XInputGetState)(DWORD,XINPUT_STATE*);
-#define _glfw_XInputGetCapabilities _glfw.win32.xinput.XInputGetCapabilities
+#define XInputGetCapabilities _glfw.win32.xinput.GetCapabilities
-#define _glfw_XInputGetState _glfw.win32.xinput.XInputGetState
+#define XInputGetState _glfw.win32.xinput.GetState
 
 // dinput8.dll function pointer typedefs
-typedef HRESULT (WINAPI * DIRECTINPUT8CREATE_T)(HINSTANCE,DWORD,REFIID,LPVOID*,LPUNKNOWN);
+typedef HRESULT (WINAPI * PFN_DirectInput8Create)(HINSTANCE,DWORD,REFIID,LPVOID*,LPUNKNOWN);
-#define _glfw_DirectInput8Create _glfw.win32.dinput8.DirectInput8Create
+#define DirectInput8Create _glfw.win32.dinput8.Create
 
 // user32.dll function pointer typedefs
-typedef BOOL (WINAPI * SETPROCESSDPIAWARE_T)(void);
+typedef BOOL (WINAPI * PFN_SetProcessDPIAware)(void);
-typedef BOOL (WINAPI * CHANGEWINDOWMESSAGEFILTEREX_T)(HWND,UINT,DWORD,PCHANGEFILTERSTRUCT);
+typedef BOOL (WINAPI * PFN_ChangeWindowMessageFilterEx)(HWND,UINT,DWORD,PCHANGEFILTERSTRUCT);
-#define _glfw_SetProcessDPIAware _glfw.win32.user32.SetProcessDPIAware
+#define SetProcessDPIAware _glfw.win32.user32.SetProcessDPIAware_
-#define _glfw_ChangeWindowMessageFilterEx _glfw.win32.user32.ChangeWindowMessageFilterEx
+#define ChangeWindowMessageFilterEx _glfw.win32.user32.ChangeWindowMessageFilterEx_
 
 // dwmapi.dll function pointer typedefs
-typedef HRESULT (WINAPI * DWMISCOMPOSITIONENABLED_T)(BOOL*);
+typedef HRESULT (WINAPI * PFN_DwmIsCompositionEnabled)(BOOL*);
-typedef HRESULT (WINAPI * DWMFLUSH_T)(VOID);
+typedef HRESULT (WINAPI * PFN_DwmFlush)(VOID);
-#define _glfw_DwmIsCompositionEnabled _glfw.win32.dwmapi.DwmIsCompositionEnabled
+typedef HRESULT(WINAPI * PFN_DwmEnableBlurBehindWindow)(HWND,const DWM_BLURBEHIND*);
-#define _glfw_DwmFlush _glfw.win32.dwmapi.DwmFlush
+#define DwmIsCompositionEnabled _glfw.win32.dwmapi.IsCompositionEnabled
+#define DwmFlush _glfw.win32.dwmapi.Flush
+#define DwmEnableBlurBehindWindow _glfw.win32.dwmapi.EnableBlurBehindWindow
 
 // shcore.dll function pointer typedefs
-typedef HRESULT (WINAPI * SETPROCESSDPIAWARENESS_T)(PROCESS_DPI_AWARENESS);
+typedef HRESULT (WINAPI * PFN_SetProcessDpiAwareness)(PROCESS_DPI_AWARENESS);
-#define _glfw_SetProcessDpiAwareness _glfw.win32.shcore.SetProcessDpiAwareness
+typedef HRESULT (WINAPI * PFN_GetDpiForMonitor)(HMONITOR,MONITOR_DPI_TYPE,UINT*,UINT*);
+#define SetProcessDpiAwareness _glfw.win32.shcore.SetProcessDpiAwareness_
+#define GetDpiForMonitor _glfw.win32.shcore.GetDpiForMonitor_
 
 typedef VkFlags VkWin32SurfaceCreateFlagsKHR;
 
@@ -207,6 +244,7 @@ typedef VkBool32 (APIENTRY *PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR)(
 #include "win32_joystick.h"
 #include "wgl_context.h"
 #include "egl_context.h"
+#include "osmesa_context.h"
 
 #define _GLFW_WNDCLASSNAME L"GLFW30"
 
@@ -219,10 +257,11 @@ typedef VkBool32 (APIENTRY *PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR)(
 
 #define _GLFW_PLATFORM_WINDOW_STATE         _GLFWwindowWin32  win32
 #define _GLFW_PLATFORM_LIBRARY_WINDOW_STATE _GLFWlibraryWin32 win32
-#define _GLFW_PLATFORM_LIBRARY_TIME_STATE   _GLFWtimeWin32    win32_time
+#define _GLFW_PLATFORM_LIBRARY_TIMER_STATE  _GLFWtimerWin32   win32
-#define _GLFW_PLATFORM_LIBRARY_TLS_STATE    _GLFWtlsWin32     win32_tls
 #define _GLFW_PLATFORM_MONITOR_STATE        _GLFWmonitorWin32 win32
 #define _GLFW_PLATFORM_CURSOR_STATE         _GLFWcursorWin32  win32
+#define _GLFW_PLATFORM_TLS_STATE            _GLFWtlsWin32     win32
+#define _GLFW_PLATFORM_MUTEX_STATE          _GLFWmutexWin32   win32
 
 
 // Win32-specific per-window data
@@ -234,7 +273,11 @@ typedef struct _GLFWwindowWin32
     HICON               smallIcon;
 
     GLFWbool            cursorTracked;
+    GLFWbool            frameAction;
     GLFWbool            iconified;
+    GLFWbool            maximized;
+    // Whether to enable framebuffer transparency on DWM
+    GLFWbool            transparent;
 
     // The last received cursor position, regardless of source
     int                 lastCursorPosX, lastCursorPosY;
@@ -247,47 +290,52 @@ typedef struct _GLFWlibraryWin32
 {
     HWND                helperWindowHandle;
     DWORD               foregroundLockTimeout;
+    int                 acquiredMonitorCount;
     char*               clipboardString;
-    char                keyName[64];
+    short int           keycodes[512];
-    short int           publicKeys[512];
+    short int           scancodes[GLFW_KEY_LAST + 1];
-    short int           nativeKeys[GLFW_KEY_LAST + 1];
+    char                keynames[GLFW_KEY_LAST + 1][5];
     // Where to place the cursor when re-enabled
     double              restoreCursorPosX, restoreCursorPosY;
     // The window whose disabled cursor mode is active
     _GLFWwindow*        disabledCursorWindow;
+    RAWINPUT*           rawInput;
+    int                 rawInputSize;
 
     struct {
-        HINSTANCE       instance;
+        HINSTANCE                       instance;
-        TIMEGETTIME_T   timeGetTime;
+        PFN_timeGetTime                 GetTime;
     } winmm;
 
     struct {
-        HINSTANCE            instance;
+        HINSTANCE                       instance;
-        DIRECTINPUT8CREATE_T DirectInput8Create;
+        PFN_DirectInput8Create          Create;
-        IDirectInput8W*      api;
+        IDirectInput8W*                 api;
     } dinput8;
 
     struct {
-        HINSTANCE               instance;
+        HINSTANCE                       instance;
-        XINPUTGETCAPABILITIES_T XInputGetCapabilities;
+        PFN_XInputGetCapabilities       GetCapabilities;
-        XINPUTGETSTATE_T        XInputGetState;
+        PFN_XInputGetState              GetState;
     } xinput;
 
     struct {
-        HINSTANCE                     instance;
+        HINSTANCE                       instance;
-        SETPROCESSDPIAWARE_T          SetProcessDPIAware;
+        PFN_SetProcessDPIAware          SetProcessDPIAware_;
-        CHANGEWINDOWMESSAGEFILTEREX_T ChangeWindowMessageFilterEx;
+        PFN_ChangeWindowMessageFilterEx ChangeWindowMessageFilterEx_;
     } user32;
 
     struct {
-        HINSTANCE       instance;
+        HINSTANCE                       instance;
-        DWMISCOMPOSITIONENABLED_T DwmIsCompositionEnabled;
+        PFN_DwmIsCompositionEnabled     IsCompositionEnabled;
-        DWMFLUSH_T      DwmFlush;
+        PFN_DwmFlush                    Flush;
+        PFN_DwmEnableBlurBehindWindow   EnableBlurBehindWindow;
     } dwmapi;
 
     struct {
-        HINSTANCE       instance;
+        HINSTANCE                       instance;
-        SETPROCESSDPIAWARENESS_T SetProcessDpiAwareness;
+        PFN_SetProcessDpiAwareness      SetProcessDpiAwareness_;
+        PFN_GetDpiForMonitor            GetDpiForMonitor_;
     } shcore;
 
 } _GLFWlibraryWin32;
@@ -296,11 +344,12 @@ typedef struct _GLFWlibraryWin32
 //
 typedef struct _GLFWmonitorWin32
 {
+    HMONITOR            handle;
     // This size matches the static size of DISPLAY_DEVICE.DeviceName
     WCHAR               adapterName[32];
     WCHAR               displayName[32];
-    char                publicAdapterName[64];
+    char                publicAdapterName[32];
-    char                publicDisplayName[64];
+    char                publicDisplayName[32];
     GLFWbool            modesPruned;
     GLFWbool            modeChanged;
 
@@ -310,41 +359,51 @@ typedef struct _GLFWmonitorWin32
 //
 typedef struct _GLFWcursorWin32
 {
-    HCURSOR handle;
+    HCURSOR             handle;
 
 } _GLFWcursorWin32;
 
 // Win32-specific global timer data
 //
-typedef struct _GLFWtimeWin32
+typedef struct _GLFWtimerWin32
 {
     GLFWbool            hasPC;
     uint64_t            frequency;
 
-} _GLFWtimeWin32;
+} _GLFWtimerWin32;
 
-// Win32-specific global TLS data
+// Win32-specific thread local storage data
 //
 typedef struct _GLFWtlsWin32
 {
-    GLFWbool        allocated;
+    GLFWbool            allocated;
-    DWORD           context;
+    DWORD               index;
 
 } _GLFWtlsWin32;
 
+// Win32-specific mutex data
+//
+typedef struct _GLFWmutexWin32
+{
+    GLFWbool            allocated;
+    CRITICAL_SECTION    section;
+
+} _GLFWmutexWin32;
+
 
 GLFWbool _glfwRegisterWindowClassWin32(void);
 void _glfwUnregisterWindowClassWin32(void);
-
+GLFWbool _glfwIsCompositionEnabledWin32(void);
-GLFWbool _glfwInitThreadLocalStorageWin32(void);
-void _glfwTerminateThreadLocalStorageWin32(void);
 
 WCHAR* _glfwCreateWideStringFromUTF8Win32(const char* source);
 char* _glfwCreateUTF8FromWideStringWin32(const WCHAR* source);
+void _glfwInputErrorWin32(int error, const char* description);
+void _glfwUpdateKeyNamesWin32(void);
 
 void _glfwInitTimerWin32(void);
 
+void _glfwPollMonitorsWin32(void);
 GLFWbool _glfwSetVideoModeWin32(_GLFWmonitor* monitor, const GLFWvidmode* desired);
 void _glfwRestoreVideoModeWin32(_GLFWmonitor* monitor);
+void _glfwGetMonitorContentScaleWin32(HMONITOR handle, float* xscale, float* yscale);
 
-#endif // _glfw3_win32_platform_h_

raylib/external/glfw/src/win32_thread.c

@@ -0,0 +1,97 @@
+//========================================================================
+// GLFW 3.3 Win32 - www.glfw.org
+//------------------------------------------------------------------------
+// Copyright (c) 2002-2006 Marcus Geelnard
+// Copyright (c) 2006-2016 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.
+//
+//========================================================================
+
+#include "internal.h"
+
+#include <assert.h>
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW platform API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+GLFWbool _glfwPlatformCreateTls(_GLFWtls* tls)
+{
+    assert(tls->win32.allocated == GLFW_FALSE);
+
+    tls->win32.index = TlsAlloc();
+    if (tls->win32.index == TLS_OUT_OF_INDEXES)
+    {
+        _glfwInputErrorWin32(GLFW_PLATFORM_ERROR,
+                             "Win32: Failed to allocate TLS index");
+        return GLFW_FALSE;
+    }
+
+    tls->win32.allocated = GLFW_TRUE;
+    return GLFW_TRUE;
+}
+
+void _glfwPlatformDestroyTls(_GLFWtls* tls)
+{
+    if (tls->win32.allocated)
+        TlsFree(tls->win32.index);
+    memset(tls, 0, sizeof(_GLFWtls));
+}
+
+void* _glfwPlatformGetTls(_GLFWtls* tls)
+{
+    assert(tls->win32.allocated == GLFW_TRUE);
+    return TlsGetValue(tls->win32.index);
+}
+
+void _glfwPlatformSetTls(_GLFWtls* tls, void* value)
+{
+    assert(tls->win32.allocated == GLFW_TRUE);
+    TlsSetValue(tls->win32.index, value);
+}
+
+GLFWbool _glfwPlatformCreateMutex(_GLFWmutex* mutex)
+{
+    assert(mutex->win32.allocated == GLFW_FALSE);
+    InitializeCriticalSection(&mutex->win32.section);
+    return mutex->win32.allocated = GLFW_TRUE;
+}
+
+void _glfwPlatformDestroyMutex(_GLFWmutex* mutex)
+{
+    if (mutex->win32.allocated)
+        DeleteCriticalSection(&mutex->win32.section);
+    memset(mutex, 0, sizeof(_GLFWmutex));
+}
+
+void _glfwPlatformLockMutex(_GLFWmutex* mutex)
+{
+    assert(mutex->win32.allocated == GLFW_TRUE);
+    EnterCriticalSection(&mutex->win32.section);
+}
+
+void _glfwPlatformUnlockMutex(_GLFWmutex* mutex)
+{
+    assert(mutex->win32.allocated == GLFW_TRUE);
+    LeaveCriticalSection(&mutex->win32.section);
+}
+

raylib/external/glfw/src/win32_time.c

@@ -1,8 +1,8 @@
 //========================================================================
-// GLFW 3.2 Win32 - www.glfw.org
+// GLFW 3.3 Win32 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-2016 Camilla Berglund <elmindreda@glfw.org>
+// Copyright (c) 2006-2016 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
@@ -40,13 +40,13 @@ void _glfwInitTimerWin32(void)
 
     if (QueryPerformanceFrequency((LARGE_INTEGER*) &frequency))
     {
-        _glfw.win32_time.hasPC = GLFW_TRUE;
+        _glfw.timer.win32.hasPC = GLFW_TRUE;
-        _glfw.win32_time.frequency = frequency;
+        _glfw.timer.win32.frequency = frequency;
     }
     else
     {
-        _glfw.win32_time.hasPC = GLFW_FALSE;
+        _glfw.timer.win32.hasPC = GLFW_FALSE;
-        _glfw.win32_time.frequency = 1000;
+        _glfw.timer.win32.frequency = 1000;
     }
 }
 
@@ -57,18 +57,18 @@ void _glfwInitTimerWin32(void)
 
 uint64_t _glfwPlatformGetTimerValue(void)
 {
-    if (_glfw.win32_time.hasPC)
+    if (_glfw.timer.win32.hasPC)
     {
         uint64_t value;
         QueryPerformanceCounter((LARGE_INTEGER*) &value);
         return value;
     }
     else
-        return (uint64_t) _glfw_timeGetTime();
+        return (uint64_t) timeGetTime();
 }
 
 uint64_t _glfwPlatformGetTimerFrequency(void)
 {
-    return _glfw.win32_time.frequency;
+    return _glfw.timer.win32.frequency;
 }
 

raylib/external/glfw/src/window.c

@@ -1,8 +1,8 @@
 //========================================================================
-// GLFW 3.2 - www.glfw.org
+// GLFW 3.3 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-2016 Camilla Berglund <elmindreda@glfw.org>
+// Copyright (c) 2006-2016 Camilla Löwy <elmindreda@glfw.org>
 // Copyright (c) 2012 Torsten Walluhn <tw@mad-cad.net>
 //
 // This software is provided 'as-is', without any express or implied
@@ -40,30 +40,26 @@
 
 void _glfwInputWindowFocus(_GLFWwindow* window, GLFWbool focused)
 {
-    if (focused)
+    if (window->callbacks.focus)
-    {
+        window->callbacks.focus((GLFWwindow*) window, focused);
-        if (window->callbacks.focus)
-            window->callbacks.focus((GLFWwindow*) window, focused);
-    }
-    else
-    {
-        int i;
 
-        if (window->callbacks.focus)
+    if (!focused)
-            window->callbacks.focus((GLFWwindow*) window, focused);
+    {
+        int key, button;
 
-        // Release all pressed keyboard keys
+        for (key = 0;  key <= GLFW_KEY_LAST;  key++)
-        for (i = 0;  i <= GLFW_KEY_LAST;  i++)
         {
-            if (window->keys[i] == GLFW_PRESS)
+            if (window->keys[key] == GLFW_PRESS)
-                _glfwInputKey(window, i, 0, GLFW_RELEASE, 0);
+            {
+                const int scancode = _glfwPlatformGetKeyScancode(key);
+                _glfwInputKey(window, key, scancode, GLFW_RELEASE, 0);
+            }
         }
 
-        // Release all pressed mouse buttons
+        for (button = 0;  button <= GLFW_MOUSE_BUTTON_LAST;  button++)
-        for (i = 0;  i <= GLFW_MOUSE_BUTTON_LAST;  i++)
         {
-            if (window->mouseButtons[i] == GLFW_PRESS)
+            if (window->mouseButtons[button] == GLFW_PRESS)
-                _glfwInputMouseClick(window, i, GLFW_RELEASE, 0);
+                _glfwInputMouseClick(window, button, GLFW_RELEASE, 0);
         }
     }
 }
@@ -86,6 +82,12 @@ void _glfwInputWindowIconify(_GLFWwindow* window, GLFWbool iconified)
         window->callbacks.iconify((GLFWwindow*) window, iconified);
 }
 
+void _glfwInputWindowMaximize(_GLFWwindow* window, GLFWbool maximized)
+{
+    if (window->callbacks.maximize)
+        window->callbacks.maximize((GLFWwindow*) window, maximized);
+}
+
 void _glfwInputFramebufferSize(_GLFWwindow* window, int width, int height)
 {
     if (window->callbacks.fbsize)
@@ -100,13 +102,13 @@ void _glfwInputWindowDamage(_GLFWwindow* window)
 
 void _glfwInputWindowCloseRequest(_GLFWwindow* window)
 {
-    window->closed = GLFW_TRUE;
+    window->shouldClose = GLFW_TRUE;
 
     if (window->callbacks.close)
         window->callbacks.close((GLFWwindow*) window);
 }
 
-void _glfwInputWindowMonitorChange(_GLFWwindow* window, _GLFWmonitor* monitor)
+void _glfwInputWindowMonitor(_GLFWwindow* window, _GLFWmonitor* monitor)
 {
     window->monitor = monitor;
 }
@@ -128,6 +130,8 @@ GLFWAPI GLFWwindow* glfwCreateWindow(int width, int height,
     _GLFWwindow* previous;
 
     assert(title != NULL);
+    assert(width >= 0);
+    assert(height >= 0);
 
     _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
 
@@ -188,7 +192,7 @@ GLFWAPI GLFWwindow* glfwCreateWindow(int width, int height,
     window->denom       = GLFW_DONT_CARE;
 
     // Save the currently current context so it can be restored later
-    previous = _glfwPlatformGetCurrentContext();
+    previous = _glfwPlatformGetTls(&_glfw.contextSlot);
     if (ctxconfig.client != GLFW_NO_API)
         glfwMakeContextCurrent(NULL);
 
@@ -233,23 +237,25 @@ void glfwDefaultWindowHints(void)
 {
     _GLFW_REQUIRE_INIT();
 
-    memset(&_glfw.hints, 0, sizeof(_glfw.hints));
-
     // The default is OpenGL with minimum version 1.0
+    memset(&_glfw.hints.context, 0, sizeof(_glfw.hints.context));
     _glfw.hints.context.client = GLFW_OPENGL_API;
     _glfw.hints.context.source = GLFW_NATIVE_CONTEXT_API;
     _glfw.hints.context.major  = 1;
     _glfw.hints.context.minor  = 0;
 
     // The default is a focused, visible, resizable window with decorations
-    _glfw.hints.window.resizable   = GLFW_TRUE;
+    memset(&_glfw.hints.window, 0, sizeof(_glfw.hints.window));
-    _glfw.hints.window.visible     = GLFW_TRUE;
+    _glfw.hints.window.resizable    = GLFW_TRUE;
-    _glfw.hints.window.decorated   = GLFW_TRUE;
+    _glfw.hints.window.visible      = GLFW_TRUE;
-    _glfw.hints.window.focused     = GLFW_TRUE;
+    _glfw.hints.window.decorated    = GLFW_TRUE;
-    _glfw.hints.window.autoIconify = GLFW_TRUE;
+    _glfw.hints.window.focused      = GLFW_TRUE;
+    _glfw.hints.window.autoIconify  = GLFW_TRUE;
+    _glfw.hints.window.centerCursor = GLFW_TRUE;
 
     // The default is 24 bits of color, 24 bits of depth and 8 bits of stencil,
     // double buffered
+    memset(&_glfw.hints.framebuffer, 0, sizeof(_glfw.hints.framebuffer));
     _glfw.hints.framebuffer.redBits      = 8;
     _glfw.hints.framebuffer.greenBits    = 8;
     _glfw.hints.framebuffer.blueBits     = 8;
@@ -260,6 +266,9 @@ void glfwDefaultWindowHints(void)
 
     // The default is to select the highest available refresh rate
     _glfw.hints.refreshRate = GLFW_DONT_CARE;
+
+    // The default is to use full Retina resolution framebuffers
+    _glfw.hints.window.ns.retina = GLFW_TRUE;
 }
 
 GLFWAPI void glfwWindowHint(int hint, int value)
@@ -270,107 +279,121 @@ GLFWAPI void glfwWindowHint(int hint, int value)
     {
         case GLFW_RED_BITS:
             _glfw.hints.framebuffer.redBits = value;
-            break;
+            return;
         case GLFW_GREEN_BITS:
             _glfw.hints.framebuffer.greenBits = value;
-            break;
+            return;
         case GLFW_BLUE_BITS:
             _glfw.hints.framebuffer.blueBits = value;
-            break;
+            return;
         case GLFW_ALPHA_BITS:
             _glfw.hints.framebuffer.alphaBits = value;
-            break;
+            return;
         case GLFW_DEPTH_BITS:
             _glfw.hints.framebuffer.depthBits = value;
-            break;
+            return;
         case GLFW_STENCIL_BITS:
             _glfw.hints.framebuffer.stencilBits = value;
-            break;
+            return;
         case GLFW_ACCUM_RED_BITS:
             _glfw.hints.framebuffer.accumRedBits = value;
-            break;
+            return;
         case GLFW_ACCUM_GREEN_BITS:
             _glfw.hints.framebuffer.accumGreenBits = value;
-            break;
+            return;
         case GLFW_ACCUM_BLUE_BITS:
             _glfw.hints.framebuffer.accumBlueBits = value;
-            break;
+            return;
         case GLFW_ACCUM_ALPHA_BITS:
             _glfw.hints.framebuffer.accumAlphaBits = value;
-            break;
+            return;
         case GLFW_AUX_BUFFERS:
             _glfw.hints.framebuffer.auxBuffers = value;
-            break;
+            return;
         case GLFW_STEREO:
             _glfw.hints.framebuffer.stereo = value ? GLFW_TRUE : GLFW_FALSE;
-            break;
+            return;
         case GLFW_DOUBLEBUFFER:
             _glfw.hints.framebuffer.doublebuffer = value ? GLFW_TRUE : GLFW_FALSE;
-            break;
+            return;
+        case GLFW_TRANSPARENT_FRAMEBUFFER:
+            _glfw.hints.framebuffer.transparent = value ? GLFW_TRUE : GLFW_FALSE;
+            return;
         case GLFW_SAMPLES:
             _glfw.hints.framebuffer.samples = value;
-            break;
+            return;
         case GLFW_SRGB_CAPABLE:
             _glfw.hints.framebuffer.sRGB = value ? GLFW_TRUE : GLFW_FALSE;
-            break;
+            return;
         case GLFW_RESIZABLE:
             _glfw.hints.window.resizable = value ? GLFW_TRUE : GLFW_FALSE;
-            break;
+            return;
         case GLFW_DECORATED:
             _glfw.hints.window.decorated = value ? GLFW_TRUE : GLFW_FALSE;
-            break;
+            return;
         case GLFW_FOCUSED:
             _glfw.hints.window.focused = value ? GLFW_TRUE : GLFW_FALSE;
-            break;
+            return;
         case GLFW_AUTO_ICONIFY:
             _glfw.hints.window.autoIconify = value ? GLFW_TRUE : GLFW_FALSE;
-            break;
+            return;
         case GLFW_FLOATING:
             _glfw.hints.window.floating = value ? GLFW_TRUE : GLFW_FALSE;
-            break;
+            return;
         case GLFW_MAXIMIZED:
             _glfw.hints.window.maximized = value ? GLFW_TRUE : GLFW_FALSE;
-            break;
+            return;
         case GLFW_VISIBLE:
             _glfw.hints.window.visible = value ? GLFW_TRUE : GLFW_FALSE;
-            break;
+            return;
+        case GLFW_COCOA_RETINA_FRAMEBUFFER:
+            _glfw.hints.window.ns.retina = value ? GLFW_TRUE : GLFW_FALSE;
+            return;
+        case GLFW_COCOA_FRAME_AUTOSAVE:
+            _glfw.hints.window.ns.frame = value ? GLFW_TRUE : GLFW_FALSE;
+            return;
+        case GLFW_COCOA_GRAPHICS_SWITCHING:
+            _glfw.hints.context.nsgl.offline = value ? GLFW_TRUE : GLFW_FALSE;
+            return;
+        case GLFW_CENTER_CURSOR:
+            _glfw.hints.window.centerCursor = value ? GLFW_TRUE : GLFW_FALSE;
+            return;
         case GLFW_CLIENT_API:
             _glfw.hints.context.client = value;
-            break;
+            return;
         case GLFW_CONTEXT_CREATION_API:
             _glfw.hints.context.source = value;
-            break;
+            return;
         case GLFW_CONTEXT_VERSION_MAJOR:
             _glfw.hints.context.major = value;
-            break;
+            return;
         case GLFW_CONTEXT_VERSION_MINOR:
             _glfw.hints.context.minor = value;
-            break;
+            return;
         case GLFW_CONTEXT_ROBUSTNESS:
             _glfw.hints.context.robustness = value;
-            break;
+            return;
         case GLFW_OPENGL_FORWARD_COMPAT:
             _glfw.hints.context.forward = value ? GLFW_TRUE : GLFW_FALSE;
-            break;
+            return;
         case GLFW_OPENGL_DEBUG_CONTEXT:
             _glfw.hints.context.debug = value ? GLFW_TRUE : GLFW_FALSE;
-            break;
+            return;
         case GLFW_CONTEXT_NO_ERROR:
             _glfw.hints.context.noerror = value ? GLFW_TRUE : GLFW_FALSE;
-            break;
+            return;
         case GLFW_OPENGL_PROFILE:
             _glfw.hints.context.profile = value;
-            break;
+            return;
         case GLFW_CONTEXT_RELEASE_BEHAVIOR:
             _glfw.hints.context.release = value;
-            break;
+            return;
         case GLFW_REFRESH_RATE:
             _glfw.hints.refreshRate = value;
-            break;
+            return;
-        default:
-            _glfwInputError(GLFW_INVALID_ENUM, "Invalid window hint %i", hint);
-            break;
     }
+
+    _glfwInputError(GLFW_INVALID_ENUM, "Invalid window hint 0x%08X", hint);
 }
 
 GLFWAPI void glfwDestroyWindow(GLFWwindow* handle)
@@ -388,7 +411,7 @@ GLFWAPI void glfwDestroyWindow(GLFWwindow* handle)
 
     // The window's context must not be current on another thread when the
     // window is destroyed
-    if (window == _glfwPlatformGetCurrentContext())
+    if (window == _glfwPlatformGetTls(&_glfw.contextSlot))
         glfwMakeContextCurrent(NULL);
 
     _glfwPlatformDestroyWindow(window);
@@ -412,7 +435,7 @@ GLFWAPI int glfwWindowShouldClose(GLFWwindow* handle)
     assert(window != NULL);
 
     _GLFW_REQUIRE_INIT_OR_RETURN(0);
-    return window->closed;
+    return window->shouldClose;
 }
 
 GLFWAPI void glfwSetWindowShouldClose(GLFWwindow* handle, int value)
@@ -421,14 +444,13 @@ GLFWAPI void glfwSetWindowShouldClose(GLFWwindow* handle, int value)
     assert(window != NULL);
 
     _GLFW_REQUIRE_INIT();
-    window->closed = value;
+    window->shouldClose = value;
 }
 
 GLFWAPI void glfwSetWindowTitle(GLFWwindow* handle, const char* title)
 {
     _GLFWwindow* window = (_GLFWwindow*) handle;
     assert(window != NULL);
-
     assert(title != NULL);
 
     _GLFW_REQUIRE_INIT();
@@ -492,6 +514,8 @@ GLFWAPI void glfwSetWindowSize(GLFWwindow* handle, int width, int height)
 {
     _GLFWwindow* window = (_GLFWwindow*) handle;
     assert(window != NULL);
+    assert(width >= 0);
+    assert(height >= 0);
 
     _GLFW_REQUIRE_INIT();
 
@@ -550,6 +574,8 @@ GLFWAPI void glfwSetWindowAspectRatio(GLFWwindow* handle, int numer, int denom)
 {
     _GLFWwindow* window = (_GLFWwindow*) handle;
     assert(window != NULL);
+    assert(numer != 0);
+    assert(denom != 0);
 
     _GLFW_REQUIRE_INIT();
 
@@ -607,6 +633,49 @@ GLFWAPI void glfwGetWindowFrameSize(GLFWwindow* handle,
     _glfwPlatformGetWindowFrameSize(window, left, top, right, bottom);
 }
 
+GLFWAPI void glfwGetWindowContentScale(GLFWwindow* handle,
+                                       float* xscale, float* yscale)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    assert(window != NULL);
+
+    if (xscale)
+        *xscale = 0.f;
+    if (yscale)
+        *yscale = 0.f;
+
+    _GLFW_REQUIRE_INIT();
+    _glfwPlatformGetWindowContentScale(window, xscale, yscale);
+}
+
+GLFWAPI float glfwGetWindowOpacity(GLFWwindow* handle)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    assert(window != NULL);
+
+    _GLFW_REQUIRE_INIT_OR_RETURN(1.f);
+    return _glfwPlatformGetWindowOpacity(window);
+}
+
+GLFWAPI void glfwSetWindowOpacity(GLFWwindow* handle, float opacity)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    assert(window != NULL);
+    assert(opacity == opacity);
+    assert(opacity >= 0.f);
+    assert(opacity <= 1.f);
+
+    _GLFW_REQUIRE_INIT();
+
+    if (opacity != opacity || opacity < 0.f || opacity > 1.f)
+    {
+        _glfwInputError(GLFW_INVALID_VALUE, "Invalid window opacity %f", opacity);
+        return;
+    }
+
+    _glfwPlatformSetWindowOpacity(window, opacity);
+}
+
 GLFWAPI void glfwIconifyWindow(GLFWwindow* handle)
 {
     _GLFWwindow* window = (_GLFWwindow*) handle;
@@ -631,6 +700,10 @@ GLFWAPI void glfwMaximizeWindow(GLFWwindow* handle)
     assert(window != NULL);
 
     _GLFW_REQUIRE_INIT();
+
+    if (window->monitor)
+        return;
+
     _glfwPlatformMaximizeWindow(window);
 }
 
@@ -648,6 +721,16 @@ GLFWAPI void glfwShowWindow(GLFWwindow* handle)
     _glfwPlatformFocusWindow(window);
 }
 
+GLFWAPI void glfwRequestWindowAttention(GLFWwindow* handle)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    assert(window != NULL);
+
+    _GLFW_REQUIRE_INIT();
+
+    _glfwPlatformRequestWindowAttention(window);
+}
+
 GLFWAPI void glfwHideWindow(GLFWwindow* handle)
 {
     _GLFWwindow* window = (_GLFWwindow*) handle;
@@ -688,12 +771,16 @@ GLFWAPI int glfwGetWindowAttrib(GLFWwindow* handle, int attrib)
             return _glfwPlatformWindowVisible(window);
         case GLFW_MAXIMIZED:
             return _glfwPlatformWindowMaximized(window);
+        case GLFW_TRANSPARENT_FRAMEBUFFER:
+            return _glfwPlatformFramebufferTransparent(window);
         case GLFW_RESIZABLE:
             return window->resizable;
         case GLFW_DECORATED:
             return window->decorated;
         case GLFW_FLOATING:
             return window->floating;
+        case GLFW_AUTO_ICONIFY:
+            return window->autoIconify;
         case GLFW_CLIENT_API:
             return window->context.client;
         case GLFW_CONTEXT_CREATION_API:
@@ -718,10 +805,52 @@ GLFWAPI int glfwGetWindowAttrib(GLFWwindow* handle, int attrib)
             return window->context.noerror;
     }
 
-    _glfwInputError(GLFW_INVALID_ENUM, "Invalid window attribute %i", attrib);
+    _glfwInputError(GLFW_INVALID_ENUM, "Invalid window attribute 0x%08X", attrib);
     return 0;
 }
 
+GLFWAPI void glfwSetWindowAttrib(GLFWwindow* handle, int attrib, int value)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    assert(window != NULL);
+
+    _GLFW_REQUIRE_INIT();
+
+    value = value ? GLFW_TRUE : GLFW_FALSE;
+
+    if (attrib == GLFW_AUTO_ICONIFY)
+        window->autoIconify = value;
+    else if (attrib == GLFW_RESIZABLE)
+    {
+        if (window->resizable == value)
+            return;
+
+        window->resizable = value;
+        if (!window->monitor)
+            _glfwPlatformSetWindowResizable(window, value);
+    }
+    else if (attrib == GLFW_DECORATED)
+    {
+        if (window->decorated == value)
+            return;
+
+        window->decorated = value;
+        if (!window->monitor)
+            _glfwPlatformSetWindowDecorated(window, value);
+    }
+    else if (attrib == GLFW_FLOATING)
+    {
+        if (window->floating == value)
+            return;
+
+        window->floating = value;
+        if (!window->monitor)
+            _glfwPlatformSetWindowFloating(window, value);
+    }
+    else
+        _glfwInputError(GLFW_INVALID_ENUM, "Invalid window attribute 0x%08X", attrib);
+}
+
 GLFWAPI GLFWmonitor* glfwGetWindowMonitor(GLFWwindow* handle)
 {
     _GLFWwindow* window = (_GLFWwindow*) handle;
@@ -740,6 +869,8 @@ GLFWAPI void glfwSetWindowMonitor(GLFWwindow* wh,
     _GLFWwindow* window = (_GLFWwindow*) wh;
     _GLFWmonitor* monitor = (_GLFWmonitor*) mh;
     assert(window != NULL);
+    assert(width >= 0);
+    assert(height >= 0);
 
     _GLFW_REQUIRE_INIT();
 
@@ -852,6 +983,17 @@ GLFWAPI GLFWwindowiconifyfun glfwSetWindowIconifyCallback(GLFWwindow* handle,
     return cbfun;
 }
 
+GLFWAPI GLFWwindowmaximizefun glfwSetWindowMaximizeCallback(GLFWwindow* handle,
+                                                            GLFWwindowmaximizefun cbfun)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    assert(window != NULL);
+
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+    _GLFW_SWAP_POINTERS(window->callbacks.maximize, cbfun);
+    return cbfun;
+}
+
 GLFWAPI GLFWframebuffersizefun glfwSetFramebufferSizeCallback(GLFWwindow* handle,
                                                               GLFWframebuffersizefun cbfun)
 {
@@ -882,6 +1024,9 @@ GLFWAPI void glfwWaitEvents(void)
 GLFWAPI void glfwWaitEventsTimeout(double timeout)
 {
     _GLFW_REQUIRE_INIT();
+    assert(timeout == timeout);
+    assert(timeout >= 0.0);
+    assert(timeout <= DBL_MAX);
 
     if (timeout != timeout || timeout < 0.0 || timeout > DBL_MAX)
     {

raylib/external/glfw/src/wl_init.c

@@ -1,5 +1,5 @@
 //========================================================================
-// GLFW 3.2 Wayland - www.glfw.org
+// GLFW 3.3 Wayland - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2014 Jonas Ådahl <jadahl@gmail.com>
 //
@@ -26,6 +26,7 @@
 
 #include "internal.h"
 
+#include <assert.h>
 #include <linux/input.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -109,6 +110,8 @@ static void pointerHandleButton(void* data,
     if (!window)
         return;
 
+    _glfw.wl.pointerSerial = serial;
+
     /* Makes left, right and middle 0, 1 and 2. Overall order follows evdev
      * codes. */
     glfwButton = button - BTN_LEFT;
@@ -128,7 +131,7 @@ static void pointerHandleAxis(void* data,
                               wl_fixed_t value)
 {
     _GLFWwindow* window = _glfw.wl.pointerFocus;
-    double scroll_factor;
+    double scrollFactor;
     double x, y;
 
     if (!window)
@@ -137,19 +140,20 @@ static void pointerHandleAxis(void* data,
     /* Wayland scroll events are in pointer motion coordinate space (think
      * two finger scroll). The factor 10 is commonly used to convert to
      * "scroll step means 1.0. */
-    scroll_factor = 1.0/10.0;
+    scrollFactor = 1.0/10.0;
 
     switch (axis)
     {
         case WL_POINTER_AXIS_HORIZONTAL_SCROLL:
-            x = wl_fixed_to_double(value) * scroll_factor;
+            x = wl_fixed_to_double(value) * scrollFactor;
             y = 0.0;
             break;
         case WL_POINTER_AXIS_VERTICAL_SCROLL:
             x = 0.0;
-            y = wl_fixed_to_double(value) * scroll_factor;
+            y = wl_fixed_to_double(value) * scrollFactor;
             break;
         default:
+            assert(GLFW_FALSE);
             break;
     }
 
@@ -172,7 +176,14 @@ static void keyboardHandleKeymap(void* data,
 {
     struct xkb_keymap* keymap;
     struct xkb_state* state;
+
+#ifdef HAVE_XKBCOMMON_COMPOSE_H
+    struct xkb_compose_table* composeTable;
+    struct xkb_compose_state* composeState;
+#endif
+
     char* mapStr;
+    const char* locale;
 
     if (format != WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1)
     {
@@ -186,10 +197,10 @@ static void keyboardHandleKeymap(void* data,
         return;
     }
 
-    keymap = xkb_map_new_from_string(_glfw.wl.xkb.context,
+    keymap = xkb_keymap_new_from_string(_glfw.wl.xkb.context,
-                                     mapStr,
+                                        mapStr,
-                                     XKB_KEYMAP_FORMAT_TEXT_V1,
+                                        XKB_KEYMAP_FORMAT_TEXT_V1,
-                                     0);
+                                        0);
     munmap(mapStr, size);
     close(fd);
 
@@ -205,23 +216,54 @@ static void keyboardHandleKeymap(void* data,
     {
         _glfwInputError(GLFW_PLATFORM_ERROR,
                         "Wayland: Failed to create XKB state");
-        xkb_map_unref(keymap);
+        xkb_keymap_unref(keymap);
         return;
     }
 
+    // Look up the preferred locale, falling back to "C" as default.
+    locale = getenv("LC_ALL");
+    if (!locale)
+        locale = getenv("LC_CTYPE");
+    if (!locale)
+        locale = getenv("LANG");
+    if (!locale)
+        locale = "C";
+
+#ifdef HAVE_XKBCOMMON_COMPOSE_H
+    composeTable =
+        xkb_compose_table_new_from_locale(_glfw.wl.xkb.context, locale,
+                                          XKB_COMPOSE_COMPILE_NO_FLAGS);
+    if (composeTable)
+    {
+        composeState =
+            xkb_compose_state_new(composeTable, XKB_COMPOSE_STATE_NO_FLAGS);
+        xkb_compose_table_unref(composeTable);
+        if (composeState)
+            _glfw.wl.xkb.composeState = composeState;
+        else
+            _glfwInputError(GLFW_PLATFORM_ERROR,
+                            "Wayland: Failed to create XKB compose state");
+    }
+    else
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "Wayland: Failed to create XKB compose table");
+    }
+#endif
+
     xkb_keymap_unref(_glfw.wl.xkb.keymap);
     xkb_state_unref(_glfw.wl.xkb.state);
     _glfw.wl.xkb.keymap = keymap;
     _glfw.wl.xkb.state = state;
 
-    _glfw.wl.xkb.control_mask =
+    _glfw.wl.xkb.controlMask =
-        1 << xkb_map_mod_get_index(_glfw.wl.xkb.keymap, "Control");
+        1 << xkb_keymap_mod_get_index(_glfw.wl.xkb.keymap, "Control");
-    _glfw.wl.xkb.alt_mask =
+    _glfw.wl.xkb.altMask =
-        1 << xkb_map_mod_get_index(_glfw.wl.xkb.keymap, "Mod1");
+        1 << xkb_keymap_mod_get_index(_glfw.wl.xkb.keymap, "Mod1");
-    _glfw.wl.xkb.shift_mask =
+    _glfw.wl.xkb.shiftMask =
-        1 << xkb_map_mod_get_index(_glfw.wl.xkb.keymap, "Shift");
+        1 << xkb_keymap_mod_get_index(_glfw.wl.xkb.keymap, "Shift");
-    _glfw.wl.xkb.super_mask =
+    _glfw.wl.xkb.superMask =
-        1 << xkb_map_mod_get_index(_glfw.wl.xkb.keymap, "Mod4");
+        1 << xkb_keymap_mod_get_index(_glfw.wl.xkb.keymap, "Mod4");
 }
 
 static void keyboardHandleEnter(void* data,
@@ -252,12 +294,61 @@ static void keyboardHandleLeave(void* data,
 
 static int toGLFWKeyCode(uint32_t key)
 {
-    if (key < sizeof(_glfw.wl.publicKeys) / sizeof(_glfw.wl.publicKeys[0]))
+    if (key < sizeof(_glfw.wl.keycodes) / sizeof(_glfw.wl.keycodes[0]))
-        return _glfw.wl.publicKeys[key];
+        return _glfw.wl.keycodes[key];
 
     return GLFW_KEY_UNKNOWN;
 }
 
+#ifdef HAVE_XKBCOMMON_COMPOSE_H
+static xkb_keysym_t composeSymbol(xkb_keysym_t sym)
+{
+    if (sym == XKB_KEY_NoSymbol || !_glfw.wl.xkb.composeState)
+        return sym;
+    if (xkb_compose_state_feed(_glfw.wl.xkb.composeState, sym)
+            != XKB_COMPOSE_FEED_ACCEPTED)
+        return sym;
+    switch (xkb_compose_state_get_status(_glfw.wl.xkb.composeState))
+    {
+        case XKB_COMPOSE_COMPOSED:
+            return xkb_compose_state_get_one_sym(_glfw.wl.xkb.composeState);
+        case XKB_COMPOSE_COMPOSING:
+        case XKB_COMPOSE_CANCELLED:
+            return XKB_KEY_NoSymbol;
+        case XKB_COMPOSE_NOTHING:
+        default:
+            return sym;
+    }
+}
+#endif
+
+static void inputChar(_GLFWwindow* window, uint32_t key)
+{
+    uint32_t code, numSyms;
+    long cp;
+    const xkb_keysym_t *syms;
+    xkb_keysym_t sym;
+
+    code = key + 8;
+    numSyms = xkb_state_key_get_syms(_glfw.wl.xkb.state, code, &syms);
+
+    if (numSyms == 1)
+    {
+#ifdef HAVE_XKBCOMMON_COMPOSE_H
+        sym = composeSymbol(syms[0]);
+#else
+        sym = syms[0];
+#endif
+        cp = _glfwKeySym2Unicode(sym);
+        if (cp != -1)
+        {
+            const int mods = _glfw.wl.xkb.modifiers;
+            const int plain = !(mods & (GLFW_MOD_CONTROL | GLFW_MOD_ALT));
+            _glfwInputChar(window, cp, mods, plain);
+        }
+    }
+}
+
 static void keyboardHandleKey(void* data,
                               struct wl_keyboard* keyboard,
                               uint32_t serial,
@@ -265,11 +356,8 @@ static void keyboardHandleKey(void* data,
                               uint32_t key,
                               uint32_t state)
 {
-    uint32_t code, num_syms;
-    long cp;
     int keyCode;
     int action;
-    const xkb_keysym_t *syms;
     _GLFWwindow* window = _glfw.wl.keyboardFocus;
 
     if (!window)
@@ -282,19 +370,8 @@ static void keyboardHandleKey(void* data,
     _glfwInputKey(window, keyCode, key, action,
                   _glfw.wl.xkb.modifiers);
 
-    code = key + 8;
+    if (action == GLFW_PRESS)
-    num_syms = xkb_key_get_syms(_glfw.wl.xkb.state, code, &syms);
+        inputChar(window, key);
-
-    if (num_syms == 1)
-    {
-        cp = _glfwKeySym2Unicode(syms[0]);
-        if (cp != -1)
-        {
-            const int mods = _glfw.wl.xkb.modifiers;
-            const int plain = !(mods & (GLFW_MOD_CONTROL | GLFW_MOD_ALT));
-            _glfwInputChar(window, cp, mods, plain);
-        }
-    }
 }
 
 static void keyboardHandleModifiers(void* data,
@@ -320,15 +397,17 @@ static void keyboardHandleModifiers(void* data,
                           group);
 
     mask = xkb_state_serialize_mods(_glfw.wl.xkb.state,
-                                    XKB_STATE_DEPRESSED |
+                                    XKB_STATE_MODS_DEPRESSED |
-                                    XKB_STATE_LATCHED);
+                                    XKB_STATE_LAYOUT_DEPRESSED |
-    if (mask & _glfw.wl.xkb.control_mask)
+                                    XKB_STATE_MODS_LATCHED |
+                                    XKB_STATE_LAYOUT_LATCHED);
+    if (mask & _glfw.wl.xkb.controlMask)
         modifiers |= GLFW_MOD_CONTROL;
-    if (mask & _glfw.wl.xkb.alt_mask)
+    if (mask & _glfw.wl.xkb.altMask)
         modifiers |= GLFW_MOD_ALT;
-    if (mask & _glfw.wl.xkb.shift_mask)
+    if (mask & _glfw.wl.xkb.shiftMask)
         modifiers |= GLFW_MOD_SHIFT;
-    if (mask & _glfw.wl.xkb.super_mask)
+    if (mask & _glfw.wl.xkb.superMask)
         modifiers |= GLFW_MOD_SUPER;
     _glfw.wl.xkb.modifiers = modifiers;
 }
@@ -380,10 +459,10 @@ static void registryHandleGlobal(void* data,
 {
     if (strcmp(interface, "wl_compositor") == 0)
     {
-        _glfw.wl.wl_compositor_version = min(3, version);
+        _glfw.wl.compositorVersion = min(3, version);
         _glfw.wl.compositor =
             wl_registry_bind(registry, name, &wl_compositor_interface,
-                             _glfw.wl.wl_compositor_version);
+                             _glfw.wl.compositorVersion);
     }
     else if (strcmp(interface, "wl_shm") == 0)
     {
@@ -422,6 +501,13 @@ static void registryHandleGlobal(void* data,
                              &zwp_pointer_constraints_v1_interface,
                              1);
     }
+    else if (strcmp(interface, "zwp_idle_inhibit_manager_v1") == 0)
+    {
+        _glfw.wl.idleInhibitManager =
+            wl_registry_bind(registry, name,
+                             &zwp_idle_inhibit_manager_v1_interface,
+                             1);
+    }
 }
 
 static void registryHandleGlobalRemove(void *data,
@@ -440,124 +526,134 @@ static const struct wl_registry_listener registryListener = {
 //
 static void createKeyTables(void)
 {
-    memset(_glfw.wl.publicKeys, -1, sizeof(_glfw.wl.publicKeys));
+    int scancode;
 
-    _glfw.wl.publicKeys[KEY_GRAVE]      = GLFW_KEY_GRAVE_ACCENT;
+    memset(_glfw.wl.keycodes, -1, sizeof(_glfw.wl.keycodes));
-    _glfw.wl.publicKeys[KEY_1]          = GLFW_KEY_1;
+    memset(_glfw.wl.scancodes, -1, sizeof(_glfw.wl.scancodes));
-    _glfw.wl.publicKeys[KEY_2]          = GLFW_KEY_2;
+
-    _glfw.wl.publicKeys[KEY_3]          = GLFW_KEY_3;
+    _glfw.wl.keycodes[KEY_GRAVE]      = GLFW_KEY_GRAVE_ACCENT;
-    _glfw.wl.publicKeys[KEY_4]          = GLFW_KEY_4;
+    _glfw.wl.keycodes[KEY_1]          = GLFW_KEY_1;
-    _glfw.wl.publicKeys[KEY_5]          = GLFW_KEY_5;
+    _glfw.wl.keycodes[KEY_2]          = GLFW_KEY_2;
-    _glfw.wl.publicKeys[KEY_6]          = GLFW_KEY_6;
+    _glfw.wl.keycodes[KEY_3]          = GLFW_KEY_3;
-    _glfw.wl.publicKeys[KEY_7]          = GLFW_KEY_7;
+    _glfw.wl.keycodes[KEY_4]          = GLFW_KEY_4;
-    _glfw.wl.publicKeys[KEY_8]          = GLFW_KEY_8;
+    _glfw.wl.keycodes[KEY_5]          = GLFW_KEY_5;
-    _glfw.wl.publicKeys[KEY_9]          = GLFW_KEY_9;
+    _glfw.wl.keycodes[KEY_6]          = GLFW_KEY_6;
-    _glfw.wl.publicKeys[KEY_0]          = GLFW_KEY_0;
+    _glfw.wl.keycodes[KEY_7]          = GLFW_KEY_7;
-    _glfw.wl.publicKeys[KEY_MINUS]      = GLFW_KEY_MINUS;
+    _glfw.wl.keycodes[KEY_8]          = GLFW_KEY_8;
-    _glfw.wl.publicKeys[KEY_EQUAL]      = GLFW_KEY_EQUAL;
+    _glfw.wl.keycodes[KEY_9]          = GLFW_KEY_9;
-    _glfw.wl.publicKeys[KEY_Q]          = GLFW_KEY_Q;
+    _glfw.wl.keycodes[KEY_0]          = GLFW_KEY_0;
-    _glfw.wl.publicKeys[KEY_W]          = GLFW_KEY_W;
+    _glfw.wl.keycodes[KEY_SPACE]      = GLFW_KEY_SPACE;
-    _glfw.wl.publicKeys[KEY_E]          = GLFW_KEY_E;
+    _glfw.wl.keycodes[KEY_MINUS]      = GLFW_KEY_MINUS;
-    _glfw.wl.publicKeys[KEY_R]          = GLFW_KEY_R;
+    _glfw.wl.keycodes[KEY_EQUAL]      = GLFW_KEY_EQUAL;
-    _glfw.wl.publicKeys[KEY_T]          = GLFW_KEY_T;
+    _glfw.wl.keycodes[KEY_Q]          = GLFW_KEY_Q;
-    _glfw.wl.publicKeys[KEY_Y]          = GLFW_KEY_Y;
+    _glfw.wl.keycodes[KEY_W]          = GLFW_KEY_W;
-    _glfw.wl.publicKeys[KEY_U]          = GLFW_KEY_U;
+    _glfw.wl.keycodes[KEY_E]          = GLFW_KEY_E;
-    _glfw.wl.publicKeys[KEY_I]          = GLFW_KEY_I;
+    _glfw.wl.keycodes[KEY_R]          = GLFW_KEY_R;
-    _glfw.wl.publicKeys[KEY_O]          = GLFW_KEY_O;
+    _glfw.wl.keycodes[KEY_T]          = GLFW_KEY_T;
-    _glfw.wl.publicKeys[KEY_P]          = GLFW_KEY_P;
+    _glfw.wl.keycodes[KEY_Y]          = GLFW_KEY_Y;
-    _glfw.wl.publicKeys[KEY_LEFTBRACE]  = GLFW_KEY_LEFT_BRACKET;
+    _glfw.wl.keycodes[KEY_U]          = GLFW_KEY_U;
-    _glfw.wl.publicKeys[KEY_RIGHTBRACE] = GLFW_KEY_RIGHT_BRACKET;
+    _glfw.wl.keycodes[KEY_I]          = GLFW_KEY_I;
-    _glfw.wl.publicKeys[KEY_A]          = GLFW_KEY_A;
+    _glfw.wl.keycodes[KEY_O]          = GLFW_KEY_O;
-    _glfw.wl.publicKeys[KEY_S]          = GLFW_KEY_S;
+    _glfw.wl.keycodes[KEY_P]          = GLFW_KEY_P;
-    _glfw.wl.publicKeys[KEY_D]          = GLFW_KEY_D;
+    _glfw.wl.keycodes[KEY_LEFTBRACE]  = GLFW_KEY_LEFT_BRACKET;
-    _glfw.wl.publicKeys[KEY_F]          = GLFW_KEY_F;
+    _glfw.wl.keycodes[KEY_RIGHTBRACE] = GLFW_KEY_RIGHT_BRACKET;
-    _glfw.wl.publicKeys[KEY_G]          = GLFW_KEY_G;
+    _glfw.wl.keycodes[KEY_A]          = GLFW_KEY_A;
-    _glfw.wl.publicKeys[KEY_H]          = GLFW_KEY_H;
+    _glfw.wl.keycodes[KEY_S]          = GLFW_KEY_S;
-    _glfw.wl.publicKeys[KEY_J]          = GLFW_KEY_J;
+    _glfw.wl.keycodes[KEY_D]          = GLFW_KEY_D;
-    _glfw.wl.publicKeys[KEY_K]          = GLFW_KEY_K;
+    _glfw.wl.keycodes[KEY_F]          = GLFW_KEY_F;
-    _glfw.wl.publicKeys[KEY_L]          = GLFW_KEY_L;
+    _glfw.wl.keycodes[KEY_G]          = GLFW_KEY_G;
-    _glfw.wl.publicKeys[KEY_SEMICOLON]  = GLFW_KEY_SEMICOLON;
+    _glfw.wl.keycodes[KEY_H]          = GLFW_KEY_H;
-    _glfw.wl.publicKeys[KEY_APOSTROPHE] = GLFW_KEY_APOSTROPHE;
+    _glfw.wl.keycodes[KEY_J]          = GLFW_KEY_J;
-    _glfw.wl.publicKeys[KEY_Z]          = GLFW_KEY_Z;
+    _glfw.wl.keycodes[KEY_K]          = GLFW_KEY_K;
-    _glfw.wl.publicKeys[KEY_X]          = GLFW_KEY_X;
+    _glfw.wl.keycodes[KEY_L]          = GLFW_KEY_L;
-    _glfw.wl.publicKeys[KEY_C]          = GLFW_KEY_C;
+    _glfw.wl.keycodes[KEY_SEMICOLON]  = GLFW_KEY_SEMICOLON;
-    _glfw.wl.publicKeys[KEY_V]          = GLFW_KEY_V;
+    _glfw.wl.keycodes[KEY_APOSTROPHE] = GLFW_KEY_APOSTROPHE;
-    _glfw.wl.publicKeys[KEY_B]          = GLFW_KEY_B;
+    _glfw.wl.keycodes[KEY_Z]          = GLFW_KEY_Z;
-    _glfw.wl.publicKeys[KEY_N]          = GLFW_KEY_N;
+    _glfw.wl.keycodes[KEY_X]          = GLFW_KEY_X;
-    _glfw.wl.publicKeys[KEY_M]          = GLFW_KEY_M;
+    _glfw.wl.keycodes[KEY_C]          = GLFW_KEY_C;
-    _glfw.wl.publicKeys[KEY_COMMA]      = GLFW_KEY_COMMA;
+    _glfw.wl.keycodes[KEY_V]          = GLFW_KEY_V;
-    _glfw.wl.publicKeys[KEY_DOT]        = GLFW_KEY_PERIOD;
+    _glfw.wl.keycodes[KEY_B]          = GLFW_KEY_B;
-    _glfw.wl.publicKeys[KEY_SLASH]      = GLFW_KEY_SLASH;
+    _glfw.wl.keycodes[KEY_N]          = GLFW_KEY_N;
-    _glfw.wl.publicKeys[KEY_BACKSLASH]  = GLFW_KEY_BACKSLASH;
+    _glfw.wl.keycodes[KEY_M]          = GLFW_KEY_M;
-    _glfw.wl.publicKeys[KEY_ESC]        = GLFW_KEY_ESCAPE;
+    _glfw.wl.keycodes[KEY_COMMA]      = GLFW_KEY_COMMA;
-    _glfw.wl.publicKeys[KEY_TAB]        = GLFW_KEY_TAB;
+    _glfw.wl.keycodes[KEY_DOT]        = GLFW_KEY_PERIOD;
-    _glfw.wl.publicKeys[KEY_LEFTSHIFT]  = GLFW_KEY_LEFT_SHIFT;
+    _glfw.wl.keycodes[KEY_SLASH]      = GLFW_KEY_SLASH;
-    _glfw.wl.publicKeys[KEY_RIGHTSHIFT] = GLFW_KEY_RIGHT_SHIFT;
+    _glfw.wl.keycodes[KEY_BACKSLASH]  = GLFW_KEY_BACKSLASH;
-    _glfw.wl.publicKeys[KEY_LEFTCTRL]   = GLFW_KEY_LEFT_CONTROL;
+    _glfw.wl.keycodes[KEY_ESC]        = GLFW_KEY_ESCAPE;
-    _glfw.wl.publicKeys[KEY_RIGHTCTRL]  = GLFW_KEY_RIGHT_CONTROL;
+    _glfw.wl.keycodes[KEY_TAB]        = GLFW_KEY_TAB;
-    _glfw.wl.publicKeys[KEY_LEFTALT]    = GLFW_KEY_LEFT_ALT;
+    _glfw.wl.keycodes[KEY_LEFTSHIFT]  = GLFW_KEY_LEFT_SHIFT;
-    _glfw.wl.publicKeys[KEY_RIGHTALT]   = GLFW_KEY_RIGHT_ALT;
+    _glfw.wl.keycodes[KEY_RIGHTSHIFT] = GLFW_KEY_RIGHT_SHIFT;
-    _glfw.wl.publicKeys[KEY_LEFTMETA]   = GLFW_KEY_LEFT_SUPER;
+    _glfw.wl.keycodes[KEY_LEFTCTRL]   = GLFW_KEY_LEFT_CONTROL;
-    _glfw.wl.publicKeys[KEY_RIGHTMETA]  = GLFW_KEY_RIGHT_SUPER;
+    _glfw.wl.keycodes[KEY_RIGHTCTRL]  = GLFW_KEY_RIGHT_CONTROL;
-    _glfw.wl.publicKeys[KEY_MENU]       = GLFW_KEY_MENU;
+    _glfw.wl.keycodes[KEY_LEFTALT]    = GLFW_KEY_LEFT_ALT;
-    _glfw.wl.publicKeys[KEY_NUMLOCK]    = GLFW_KEY_NUM_LOCK;
+    _glfw.wl.keycodes[KEY_RIGHTALT]   = GLFW_KEY_RIGHT_ALT;
-    _glfw.wl.publicKeys[KEY_CAPSLOCK]   = GLFW_KEY_CAPS_LOCK;
+    _glfw.wl.keycodes[KEY_LEFTMETA]   = GLFW_KEY_LEFT_SUPER;
-    _glfw.wl.publicKeys[KEY_PRINT]      = GLFW_KEY_PRINT_SCREEN;
+    _glfw.wl.keycodes[KEY_RIGHTMETA]  = GLFW_KEY_RIGHT_SUPER;
-    _glfw.wl.publicKeys[KEY_SCROLLLOCK] = GLFW_KEY_SCROLL_LOCK;
+    _glfw.wl.keycodes[KEY_MENU]       = GLFW_KEY_MENU;
-    _glfw.wl.publicKeys[KEY_PAUSE]      = GLFW_KEY_PAUSE;
+    _glfw.wl.keycodes[KEY_NUMLOCK]    = GLFW_KEY_NUM_LOCK;
-    _glfw.wl.publicKeys[KEY_DELETE]     = GLFW_KEY_DELETE;
+    _glfw.wl.keycodes[KEY_CAPSLOCK]   = GLFW_KEY_CAPS_LOCK;
-    _glfw.wl.publicKeys[KEY_BACKSPACE]  = GLFW_KEY_BACKSPACE;
+    _glfw.wl.keycodes[KEY_PRINT]      = GLFW_KEY_PRINT_SCREEN;
-    _glfw.wl.publicKeys[KEY_ENTER]      = GLFW_KEY_ENTER;
+    _glfw.wl.keycodes[KEY_SCROLLLOCK] = GLFW_KEY_SCROLL_LOCK;
-    _glfw.wl.publicKeys[KEY_HOME]       = GLFW_KEY_HOME;
+    _glfw.wl.keycodes[KEY_PAUSE]      = GLFW_KEY_PAUSE;
-    _glfw.wl.publicKeys[KEY_END]        = GLFW_KEY_END;
+    _glfw.wl.keycodes[KEY_DELETE]     = GLFW_KEY_DELETE;
-    _glfw.wl.publicKeys[KEY_PAGEUP]     = GLFW_KEY_PAGE_UP;
+    _glfw.wl.keycodes[KEY_BACKSPACE]  = GLFW_KEY_BACKSPACE;
-    _glfw.wl.publicKeys[KEY_PAGEDOWN]   = GLFW_KEY_PAGE_DOWN;
+    _glfw.wl.keycodes[KEY_ENTER]      = GLFW_KEY_ENTER;
-    _glfw.wl.publicKeys[KEY_INSERT]     = GLFW_KEY_INSERT;
+    _glfw.wl.keycodes[KEY_HOME]       = GLFW_KEY_HOME;
-    _glfw.wl.publicKeys[KEY_LEFT]       = GLFW_KEY_LEFT;
+    _glfw.wl.keycodes[KEY_END]        = GLFW_KEY_END;
-    _glfw.wl.publicKeys[KEY_RIGHT]      = GLFW_KEY_RIGHT;
+    _glfw.wl.keycodes[KEY_PAGEUP]     = GLFW_KEY_PAGE_UP;
-    _glfw.wl.publicKeys[KEY_DOWN]       = GLFW_KEY_DOWN;
+    _glfw.wl.keycodes[KEY_PAGEDOWN]   = GLFW_KEY_PAGE_DOWN;
-    _glfw.wl.publicKeys[KEY_UP]         = GLFW_KEY_UP;
+    _glfw.wl.keycodes[KEY_INSERT]     = GLFW_KEY_INSERT;
-    _glfw.wl.publicKeys[KEY_F1]         = GLFW_KEY_F1;
+    _glfw.wl.keycodes[KEY_LEFT]       = GLFW_KEY_LEFT;
-    _glfw.wl.publicKeys[KEY_F2]         = GLFW_KEY_F2;
+    _glfw.wl.keycodes[KEY_RIGHT]      = GLFW_KEY_RIGHT;
-    _glfw.wl.publicKeys[KEY_F3]         = GLFW_KEY_F3;
+    _glfw.wl.keycodes[KEY_DOWN]       = GLFW_KEY_DOWN;
-    _glfw.wl.publicKeys[KEY_F4]         = GLFW_KEY_F4;
+    _glfw.wl.keycodes[KEY_UP]         = GLFW_KEY_UP;
-    _glfw.wl.publicKeys[KEY_F5]         = GLFW_KEY_F5;
+    _glfw.wl.keycodes[KEY_F1]         = GLFW_KEY_F1;
-    _glfw.wl.publicKeys[KEY_F6]         = GLFW_KEY_F6;
+    _glfw.wl.keycodes[KEY_F2]         = GLFW_KEY_F2;
-    _glfw.wl.publicKeys[KEY_F7]         = GLFW_KEY_F7;
+    _glfw.wl.keycodes[KEY_F3]         = GLFW_KEY_F3;
-    _glfw.wl.publicKeys[KEY_F8]         = GLFW_KEY_F8;
+    _glfw.wl.keycodes[KEY_F4]         = GLFW_KEY_F4;
-    _glfw.wl.publicKeys[KEY_F9]         = GLFW_KEY_F9;
+    _glfw.wl.keycodes[KEY_F5]         = GLFW_KEY_F5;
-    _glfw.wl.publicKeys[KEY_F10]        = GLFW_KEY_F10;
+    _glfw.wl.keycodes[KEY_F6]         = GLFW_KEY_F6;
-    _glfw.wl.publicKeys[KEY_F11]        = GLFW_KEY_F11;
+    _glfw.wl.keycodes[KEY_F7]         = GLFW_KEY_F7;
-    _glfw.wl.publicKeys[KEY_F12]        = GLFW_KEY_F12;
+    _glfw.wl.keycodes[KEY_F8]         = GLFW_KEY_F8;
-    _glfw.wl.publicKeys[KEY_F13]        = GLFW_KEY_F13;
+    _glfw.wl.keycodes[KEY_F9]         = GLFW_KEY_F9;
-    _glfw.wl.publicKeys[KEY_F14]        = GLFW_KEY_F14;
+    _glfw.wl.keycodes[KEY_F10]        = GLFW_KEY_F10;
-    _glfw.wl.publicKeys[KEY_F15]        = GLFW_KEY_F15;
+    _glfw.wl.keycodes[KEY_F11]        = GLFW_KEY_F11;
-    _glfw.wl.publicKeys[KEY_F16]        = GLFW_KEY_F16;
+    _glfw.wl.keycodes[KEY_F12]        = GLFW_KEY_F12;
-    _glfw.wl.publicKeys[KEY_F17]        = GLFW_KEY_F17;
+    _glfw.wl.keycodes[KEY_F13]        = GLFW_KEY_F13;
-    _glfw.wl.publicKeys[KEY_F18]        = GLFW_KEY_F18;
+    _glfw.wl.keycodes[KEY_F14]        = GLFW_KEY_F14;
-    _glfw.wl.publicKeys[KEY_F19]        = GLFW_KEY_F19;
+    _glfw.wl.keycodes[KEY_F15]        = GLFW_KEY_F15;
-    _glfw.wl.publicKeys[KEY_F20]        = GLFW_KEY_F20;
+    _glfw.wl.keycodes[KEY_F16]        = GLFW_KEY_F16;
-    _glfw.wl.publicKeys[KEY_F21]        = GLFW_KEY_F21;
+    _glfw.wl.keycodes[KEY_F17]        = GLFW_KEY_F17;
-    _glfw.wl.publicKeys[KEY_F22]        = GLFW_KEY_F22;
+    _glfw.wl.keycodes[KEY_F18]        = GLFW_KEY_F18;
-    _glfw.wl.publicKeys[KEY_F23]        = GLFW_KEY_F23;
+    _glfw.wl.keycodes[KEY_F19]        = GLFW_KEY_F19;
-    _glfw.wl.publicKeys[KEY_F24]        = GLFW_KEY_F24;
+    _glfw.wl.keycodes[KEY_F20]        = GLFW_KEY_F20;
-    _glfw.wl.publicKeys[KEY_KPSLASH]    = GLFW_KEY_KP_DIVIDE;
+    _glfw.wl.keycodes[KEY_F21]        = GLFW_KEY_F21;
-    _glfw.wl.publicKeys[KEY_KPDOT]      = GLFW_KEY_KP_MULTIPLY;
+    _glfw.wl.keycodes[KEY_F22]        = GLFW_KEY_F22;
-    _glfw.wl.publicKeys[KEY_KPMINUS]    = GLFW_KEY_KP_SUBTRACT;
+    _glfw.wl.keycodes[KEY_F23]        = GLFW_KEY_F23;
-    _glfw.wl.publicKeys[KEY_KPPLUS]     = GLFW_KEY_KP_ADD;
+    _glfw.wl.keycodes[KEY_F24]        = GLFW_KEY_F24;
-    _glfw.wl.publicKeys[KEY_KP0]        = GLFW_KEY_KP_0;
+    _glfw.wl.keycodes[KEY_KPSLASH]    = GLFW_KEY_KP_DIVIDE;
-    _glfw.wl.publicKeys[KEY_KP1]        = GLFW_KEY_KP_1;
+    _glfw.wl.keycodes[KEY_KPDOT]      = GLFW_KEY_KP_MULTIPLY;
-    _glfw.wl.publicKeys[KEY_KP2]        = GLFW_KEY_KP_2;
+    _glfw.wl.keycodes[KEY_KPMINUS]    = GLFW_KEY_KP_SUBTRACT;
-    _glfw.wl.publicKeys[KEY_KP3]        = GLFW_KEY_KP_3;
+    _glfw.wl.keycodes[KEY_KPPLUS]     = GLFW_KEY_KP_ADD;
-    _glfw.wl.publicKeys[KEY_KP4]        = GLFW_KEY_KP_4;
+    _glfw.wl.keycodes[KEY_KP0]        = GLFW_KEY_KP_0;
-    _glfw.wl.publicKeys[KEY_KP5]        = GLFW_KEY_KP_5;
+    _glfw.wl.keycodes[KEY_KP1]        = GLFW_KEY_KP_1;
-    _glfw.wl.publicKeys[KEY_KP6]        = GLFW_KEY_KP_6;
+    _glfw.wl.keycodes[KEY_KP2]        = GLFW_KEY_KP_2;
-    _glfw.wl.publicKeys[KEY_KP7]        = GLFW_KEY_KP_7;
+    _glfw.wl.keycodes[KEY_KP3]        = GLFW_KEY_KP_3;
-    _glfw.wl.publicKeys[KEY_KP8]        = GLFW_KEY_KP_8;
+    _glfw.wl.keycodes[KEY_KP4]        = GLFW_KEY_KP_4;
-    _glfw.wl.publicKeys[KEY_KP9]        = GLFW_KEY_KP_9;
+    _glfw.wl.keycodes[KEY_KP5]        = GLFW_KEY_KP_5;
-    _glfw.wl.publicKeys[KEY_KPCOMMA]    = GLFW_KEY_KP_DECIMAL;
+    _glfw.wl.keycodes[KEY_KP6]        = GLFW_KEY_KP_6;
-    _glfw.wl.publicKeys[KEY_KPEQUAL]    = GLFW_KEY_KP_EQUAL;
+    _glfw.wl.keycodes[KEY_KP7]        = GLFW_KEY_KP_7;
-    _glfw.wl.publicKeys[KEY_KPENTER]    = GLFW_KEY_KP_ENTER;
+    _glfw.wl.keycodes[KEY_KP8]        = GLFW_KEY_KP_8;
+    _glfw.wl.keycodes[KEY_KP9]        = GLFW_KEY_KP_9;
+    _glfw.wl.keycodes[KEY_KPCOMMA]    = GLFW_KEY_KP_DECIMAL;
+    _glfw.wl.keycodes[KEY_KPEQUAL]    = GLFW_KEY_KP_EQUAL;
+    _glfw.wl.keycodes[KEY_KPENTER]    = GLFW_KEY_KP_ENTER;
+
+    for (scancode = 0;  scancode < 256;  scancode++)
+    {
+        if (_glfw.wl.keycodes[scancode] > 0)
+            _glfw.wl.scancodes[_glfw.wl.keycodes[scancode]] = scancode;
+    }
 }
 
 
@@ -567,6 +663,52 @@ static void createKeyTables(void)
 
 int _glfwPlatformInit(void)
 {
+    _glfw.wl.xkb.handle = dlopen("libxkbcommon.so.0", RTLD_LAZY | RTLD_GLOBAL);
+    if (!_glfw.wl.xkb.handle)
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "Wayland: Failed to open libxkbcommon.");
+        return GLFW_FALSE;
+    }
+
+    _glfw.wl.xkb.context_new = (PFN_xkb_context_new)
+        dlsym(_glfw.wl.xkb.handle, "xkb_context_new");
+    _glfw.wl.xkb.context_unref = (PFN_xkb_context_unref)
+        dlsym(_glfw.wl.xkb.handle, "xkb_context_unref");
+    _glfw.wl.xkb.keymap_new_from_string = (PFN_xkb_keymap_new_from_string)
+        dlsym(_glfw.wl.xkb.handle, "xkb_keymap_new_from_string");
+    _glfw.wl.xkb.keymap_unref = (PFN_xkb_keymap_unref)
+        dlsym(_glfw.wl.xkb.handle, "xkb_keymap_unref");
+    _glfw.wl.xkb.keymap_mod_get_index = (PFN_xkb_keymap_mod_get_index)
+        dlsym(_glfw.wl.xkb.handle, "xkb_keymap_mod_get_index");
+    _glfw.wl.xkb.state_new = (PFN_xkb_state_new)
+        dlsym(_glfw.wl.xkb.handle, "xkb_state_new");
+    _glfw.wl.xkb.state_unref = (PFN_xkb_state_unref)
+        dlsym(_glfw.wl.xkb.handle, "xkb_state_unref");
+    _glfw.wl.xkb.state_key_get_syms = (PFN_xkb_state_key_get_syms)
+        dlsym(_glfw.wl.xkb.handle, "xkb_state_key_get_syms");
+    _glfw.wl.xkb.state_update_mask = (PFN_xkb_state_update_mask)
+        dlsym(_glfw.wl.xkb.handle, "xkb_state_update_mask");
+    _glfw.wl.xkb.state_serialize_mods = (PFN_xkb_state_serialize_mods)
+        dlsym(_glfw.wl.xkb.handle, "xkb_state_serialize_mods");
+
+#ifdef HAVE_XKBCOMMON_COMPOSE_H
+    _glfw.wl.xkb.compose_table_new_from_locale = (PFN_xkb_compose_table_new_from_locale)
+        dlsym(_glfw.wl.xkb.handle, "xkb_compose_table_new_from_locale");
+    _glfw.wl.xkb.compose_table_unref = (PFN_xkb_compose_table_unref)
+        dlsym(_glfw.wl.xkb.handle, "xkb_compose_table_unref");
+    _glfw.wl.xkb.compose_state_new = (PFN_xkb_compose_state_new)
+        dlsym(_glfw.wl.xkb.handle, "xkb_compose_state_new");
+    _glfw.wl.xkb.compose_state_unref = (PFN_xkb_compose_state_unref)
+        dlsym(_glfw.wl.xkb.handle, "xkb_compose_state_unref");
+    _glfw.wl.xkb.compose_state_feed = (PFN_xkb_compose_state_feed)
+        dlsym(_glfw.wl.xkb.handle, "xkb_compose_state_feed");
+    _glfw.wl.xkb.compose_state_get_status = (PFN_xkb_compose_state_get_status)
+        dlsym(_glfw.wl.xkb.handle, "xkb_compose_state_get_status");
+    _glfw.wl.xkb.compose_state_get_one_sym = (PFN_xkb_compose_state_get_one_sym)
+        dlsym(_glfw.wl.xkb.handle, "xkb_compose_state_get_one_sym");
+#endif
+
     _glfw.wl.display = wl_display_connect(NULL);
     if (!_glfw.wl.display)
     {
@@ -578,9 +720,6 @@ int _glfwPlatformInit(void)
     _glfw.wl.registry = wl_display_get_registry(_glfw.wl.display);
     wl_registry_add_listener(_glfw.wl.registry, &registryListener, NULL);
 
-    _glfw.wl.monitors = calloc(4, sizeof(_GLFWmonitor*));
-    _glfw.wl.monitorsSize = 4;
-
     createKeyTables();
 
     _glfw.wl.xkb.context = xkb_context_new(0);
@@ -597,9 +736,6 @@ int _glfwPlatformInit(void)
     // Sync so we got all initial output events
     wl_display_roundtrip(_glfw.wl.display);
 
-    if (!_glfwInitThreadLocalStoragePOSIX())
-        return GLFW_FALSE;
-
     if (!_glfwInitJoysticksLinux())
         return GLFW_FALSE;
 
@@ -625,18 +761,47 @@ void _glfwPlatformTerminate(void)
 {
     _glfwTerminateEGL();
     _glfwTerminateJoysticksLinux();
-    _glfwTerminateThreadLocalStoragePOSIX();
+
+#ifdef HAVE_XKBCOMMON_COMPOSE_H
+    xkb_compose_state_unref(_glfw.wl.xkb.composeState);
+#endif
+
+    xkb_keymap_unref(_glfw.wl.xkb.keymap);
+    xkb_state_unref(_glfw.wl.xkb.state);
+    xkb_context_unref(_glfw.wl.xkb.context);
+
+    dlclose(_glfw.wl.xkb.handle);
+    _glfw.wl.xkb.handle = NULL;
 
     if (_glfw.wl.cursorTheme)
         wl_cursor_theme_destroy(_glfw.wl.cursorTheme);
     if (_glfw.wl.cursorSurface)
         wl_surface_destroy(_glfw.wl.cursorSurface);
+    if (_glfw.wl.compositor)
+        wl_compositor_destroy(_glfw.wl.compositor);
+    if (_glfw.wl.shm)
+        wl_shm_destroy(_glfw.wl.shm);
+    if (_glfw.wl.shell)
+        wl_shell_destroy(_glfw.wl.shell);
+    if (_glfw.wl.pointer)
+        wl_pointer_destroy(_glfw.wl.pointer);
+    if (_glfw.wl.keyboard)
+        wl_keyboard_destroy(_glfw.wl.keyboard);
+    if (_glfw.wl.seat)
+        wl_seat_destroy(_glfw.wl.seat);
+    if (_glfw.wl.relativePointerManager)
+        zwp_relative_pointer_manager_v1_destroy(_glfw.wl.relativePointerManager);
+    if (_glfw.wl.pointerConstraints)
+        zwp_pointer_constraints_v1_destroy(_glfw.wl.pointerConstraints);
+    if (_glfw.wl.idleInhibitManager)
+        zwp_idle_inhibit_manager_v1_destroy(_glfw.wl.idleInhibitManager);
     if (_glfw.wl.registry)
         wl_registry_destroy(_glfw.wl.registry);
     if (_glfw.wl.display)
+    {
         wl_display_flush(_glfw.wl.display);
-    if (_glfw.wl.display)
         wl_display_disconnect(_glfw.wl.display);
+    }
 }
 
 const char* _glfwPlatformGetVersionString(void)
@@ -647,9 +812,7 @@ const char* _glfwPlatformGetVersionString(void)
 #else
         " gettimeofday"
 #endif
-#if defined(__linux__)
+        " evdev"
-        " /dev/js"
-#endif
 #if defined(_GLFW_BUILD_DLL)
         " shared"
 #endif

raylib/external/glfw/src/wl_monitor.c

@@ -1,5 +1,5 @@
 //========================================================================
-// GLFW 3.2 Wayland - www.glfw.org
+// GLFW 3.3 Wayland - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2014 Jonas Ådahl <jadahl@gmail.com>
 //
@@ -32,12 +32,6 @@
 #include <errno.h>
 
 
-struct _GLFWvidmodeWayland
-{
-    GLFWvidmode         base;
-    uint32_t            flags;
-};
-
 static void geometry(void* data,
                      struct wl_output* output,
                      int32_t x,
@@ -50,11 +44,15 @@ static void geometry(void* data,
                      int32_t transform)
 {
     struct _GLFWmonitor *monitor = data;
+    char name[1024];
 
     monitor->wl.x = x;
     monitor->wl.y = y;
     monitor->widthMM = physicalWidth;
     monitor->heightMM = physicalHeight;
+
+    snprintf(name, sizeof(name), "%s %s", make, model);
+    monitor->name = strdup(name);
 }
 
 static void mode(void* data,
@@ -65,32 +63,29 @@ static void mode(void* data,
                  int32_t refresh)
 {
     struct _GLFWmonitor *monitor = data;
-    _GLFWvidmodeWayland mode = { { 0 }, };
+    GLFWvidmode mode;
 
-    mode.base.width = width;
+    mode.width = width;
-    mode.base.height = height;
+    mode.height = height;
-    mode.base.refreshRate = refresh / 1000;
+    mode.redBits = 8;
-    mode.flags = flags;
+    mode.greenBits = 8;
+    mode.blueBits = 8;
+    mode.refreshRate = refresh / 1000;
 
-    if (monitor->wl.modesCount + 1 >= monitor->wl.modesSize)
+    monitor->modeCount++;
-    {
+    monitor->modes =
-        int size = monitor->wl.modesSize * 2;
+        realloc(monitor->modes, monitor->modeCount * sizeof(GLFWvidmode));
-        _GLFWvidmodeWayland* modes =
+    monitor->modes[monitor->modeCount - 1] = mode;
-            realloc(monitor->wl.modes,
-                    size * sizeof(_GLFWvidmodeWayland));
-        monitor->wl.modes = modes;
-        monitor->wl.modesSize = size;
-    }
 
-    monitor->wl.modes[monitor->wl.modesCount++] = mode;
+    if (flags & WL_OUTPUT_MODE_CURRENT)
+        monitor->wl.currentMode = monitor->modeCount - 1;
 }
 
-static void done(void* data,
+static void done(void* data, struct wl_output* output)
-                 struct wl_output* output)
 {
     struct _GLFWmonitor *monitor = data;
 
-    monitor->wl.done = GLFW_TRUE;
+    _glfwInputMonitor(monitor, GLFW_CONNECTED, _GLFW_INSERT_LAST);
 }
 
 static void scale(void* data,
@@ -102,7 +97,7 @@ static void scale(void* data,
     monitor->wl.scale = factor;
 }
 
-static const struct wl_output_listener output_listener = {
+static const struct wl_output_listener outputListener = {
     geometry,
     mode,
     done,
@@ -118,10 +113,6 @@ void _glfwAddOutputWayland(uint32_t name, uint32_t version)
 {
     _GLFWmonitor *monitor;
     struct wl_output *output;
-    char name_str[80];
-
-    memset(name_str, 0, sizeof(name_str));
-    snprintf(name_str, 79, "wl_output@%u", name);
 
     if (version < 2)
     {
@@ -130,7 +121,8 @@ void _glfwAddOutputWayland(uint32_t name, uint32_t version)
         return;
     }
 
-    monitor = _glfwAllocMonitor(name_str, 0, 0);
+    // The actual name of this output will be set in the geometry handler.
+    monitor = _glfwAllocMonitor(NULL, 0, 0);
 
     output = wl_registry_bind(_glfw.wl.registry,
                               name,
@@ -142,26 +134,10 @@ void _glfwAddOutputWayland(uint32_t name, uint32_t version)
         return;
     }
 
-    monitor->wl.modes = calloc(4, sizeof(_GLFWvidmodeWayland));
-    monitor->wl.modesSize = 4;
-
     monitor->wl.scale = 1;
-
     monitor->wl.output = output;
-    wl_output_add_listener(output, &output_listener, monitor);
 
-    if (_glfw.wl.monitorsCount + 1 >= _glfw.wl.monitorsSize)
+    wl_output_add_listener(output, &outputListener, monitor);
-    {
-        _GLFWmonitor** monitors = _glfw.wl.monitors;
-        int size = _glfw.wl.monitorsSize * 2;
-
-        monitors = realloc(monitors, size * sizeof(_GLFWmonitor*));
-
-        _glfw.wl.monitors = monitors;
-        _glfw.wl.monitorsSize = size;
-    }
-
-    _glfw.wl.monitors[_glfw.wl.monitorsCount++] = monitor;
 }
 
 
@@ -169,42 +145,6 @@ void _glfwAddOutputWayland(uint32_t name, uint32_t version)
 //////                       GLFW platform API                      //////
 //////////////////////////////////////////////////////////////////////////
 
-_GLFWmonitor** _glfwPlatformGetMonitors(int* count)
-{
-    _GLFWmonitor** monitors;
-    _GLFWmonitor* monitor;
-    int i, monitorsCount = _glfw.wl.monitorsCount;
-
-    if (_glfw.wl.monitorsCount == 0)
-        goto err;
-
-    monitors = calloc(monitorsCount, sizeof(_GLFWmonitor*));
-
-    for (i = 0; i < monitorsCount; i++)
-    {
-        _GLFWmonitor* origMonitor = _glfw.wl.monitors[i];
-        monitor = calloc(1, sizeof(_GLFWmonitor));
-
-        monitor->modes =
-            _glfwPlatformGetVideoModes(origMonitor,
-                                       &origMonitor->wl.modesCount);
-        *monitor = *_glfw.wl.monitors[i];
-        monitors[i] = monitor;
-    }
-
-    *count = monitorsCount;
-    return monitors;
-
-err:
-    *count = 0;
-    return NULL;
-}
-
-GLFWbool _glfwPlatformIsSameMonitor(_GLFWmonitor* first, _GLFWmonitor* second)
-{
-    return first->wl.output == second->wl.output;
-}
-
 void _glfwPlatformGetMonitorPos(_GLFWmonitor* monitor, int* xpos, int* ypos)
 {
     if (xpos)
@@ -213,32 +153,24 @@ void _glfwPlatformGetMonitorPos(_GLFWmonitor* monitor, int* xpos, int* ypos)
         *ypos = monitor->wl.y;
 }
 
+void _glfwPlatformGetMonitorContentScale(_GLFWmonitor* monitor,
+                                         float* xscale, float* yscale)
+{
+    if (xscale)
+        *xscale = (float) monitor->wl.scale;
+    if (yscale)
+        *yscale = (float) monitor->wl.scale;
+}
+
 GLFWvidmode* _glfwPlatformGetVideoModes(_GLFWmonitor* monitor, int* found)
 {
-    GLFWvidmode *modes;
+    *found = monitor->modeCount;
-    int i, modesCount = monitor->wl.modesCount;
+    return monitor->modes;
-
-    modes = calloc(modesCount, sizeof(GLFWvidmode));
-
-    for (i = 0;  i < modesCount;  i++)
-        modes[i] = monitor->wl.modes[i].base;
-
-    *found = modesCount;
-    return modes;
 }
 
 void _glfwPlatformGetVideoMode(_GLFWmonitor* monitor, GLFWvidmode* mode)
 {
-    int i;
+    *mode = monitor->modes[monitor->wl.currentMode];
-
-    for (i = 0;  i < monitor->wl.modesCount;  i++)
-    {
-        if (monitor->wl.modes[i].flags & WL_OUTPUT_MODE_CURRENT)
-        {
-            *mode = monitor->wl.modes[i].base;
-            return;
-        }
-    }
 }
 
 void _glfwPlatformGetGammaRamp(_GLFWmonitor* monitor, GLFWgammaramp* ramp)

raylib/external/glfw/src/wl_platform.h

@@ -1,5 +1,5 @@
 //========================================================================
-// GLFW 3.2 Wayland - www.glfw.org
+// GLFW 3.3 Wayland - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2014 Jonas Ådahl <jadahl@gmail.com>
 //
@@ -24,11 +24,11 @@
 //
 //========================================================================
 
-#ifndef _glfw3_wayland_platform_h_
-#define _glfw3_wayland_platform_h_
-
 #include <wayland-client.h>
 #include <xkbcommon/xkbcommon.h>
+#ifdef HAVE_XKBCOMMON_COMPOSE_H
+#include <xkbcommon/xkbcommon-compose.h>
+#endif
 #include <dlfcn.h>
 
 typedef VkFlags VkWaylandSurfaceCreateFlagsKHR;
@@ -45,14 +45,16 @@ typedef struct VkWaylandSurfaceCreateInfoKHR
 typedef VkResult (APIENTRY *PFN_vkCreateWaylandSurfaceKHR)(VkInstance,const VkWaylandSurfaceCreateInfoKHR*,const VkAllocationCallbacks*,VkSurfaceKHR*);
 typedef VkBool32 (APIENTRY *PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR)(VkPhysicalDevice,uint32_t,struct wl_display*);
 
-#include "posix_tls.h"
+#include "posix_thread.h"
 #include "posix_time.h"
 #include "linux_joystick.h"
 #include "xkb_unicode.h"
 #include "egl_context.h"
+#include "osmesa_context.h"
 
 #include "wayland-relative-pointer-unstable-v1-client-protocol.h"
 #include "wayland-pointer-constraints-unstable-v1-client-protocol.h"
+#include "wayland-idle-inhibit-unstable-v1-client-protocol.h"
 
 #define _glfw_dlopen(name) dlopen(name, RTLD_LAZY | RTLD_LOCAL)
 #define _glfw_dlclose(handle) dlclose(handle)
@@ -69,10 +71,44 @@ typedef VkBool32 (APIENTRY *PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR
 #define _GLFW_PLATFORM_CONTEXT_STATE
 #define _GLFW_PLATFORM_LIBRARY_CONTEXT_STATE
 
+typedef struct xkb_context* (* PFN_xkb_context_new)(enum xkb_context_flags);
+typedef void (* PFN_xkb_context_unref)(struct xkb_context*);
+typedef struct xkb_keymap* (* PFN_xkb_keymap_new_from_string)(struct xkb_context*, const char*, enum xkb_keymap_format, enum xkb_keymap_compile_flags);
+typedef void (* PFN_xkb_keymap_unref)(struct xkb_keymap*);
+typedef xkb_mod_index_t (* PFN_xkb_keymap_mod_get_index)(struct xkb_keymap*, const char*);
+typedef struct xkb_state* (* PFN_xkb_state_new)(struct xkb_keymap*);
+typedef void (* PFN_xkb_state_unref)(struct xkb_state*);
+typedef int (* PFN_xkb_state_key_get_syms)(struct xkb_state*, xkb_keycode_t, const xkb_keysym_t**);
+typedef enum xkb_state_component (* PFN_xkb_state_update_mask)(struct xkb_state*, xkb_mod_mask_t, xkb_mod_mask_t, xkb_mod_mask_t, xkb_layout_index_t, xkb_layout_index_t, xkb_layout_index_t);
+typedef xkb_mod_mask_t (* PFN_xkb_state_serialize_mods)(struct xkb_state*, enum xkb_state_component);
+#define xkb_context_new _glfw.wl.xkb.context_new
+#define xkb_context_unref _glfw.wl.xkb.context_unref
+#define xkb_keymap_new_from_string _glfw.wl.xkb.keymap_new_from_string
+#define xkb_keymap_unref _glfw.wl.xkb.keymap_unref
+#define xkb_keymap_mod_get_index _glfw.wl.xkb.keymap_mod_get_index
+#define xkb_state_new _glfw.wl.xkb.state_new
+#define xkb_state_unref _glfw.wl.xkb.state_unref
+#define xkb_state_key_get_syms _glfw.wl.xkb.state_key_get_syms
+#define xkb_state_update_mask _glfw.wl.xkb.state_update_mask
+#define xkb_state_serialize_mods _glfw.wl.xkb.state_serialize_mods
+
+#ifdef HAVE_XKBCOMMON_COMPOSE_H
+typedef struct xkb_compose_table* (* PFN_xkb_compose_table_new_from_locale)(struct xkb_context*, const char*, enum xkb_compose_compile_flags);
+typedef void (* PFN_xkb_compose_table_unref)(struct xkb_compose_table*);
+typedef struct xkb_compose_state* (* PFN_xkb_compose_state_new)(struct xkb_compose_table*, enum xkb_compose_state_flags);
+typedef void (* PFN_xkb_compose_state_unref)(struct xkb_compose_state*);
+typedef enum xkb_compose_feed_result (* PFN_xkb_compose_state_feed)(struct xkb_compose_state*, xkb_keysym_t);
+typedef enum xkb_compose_status (* PFN_xkb_compose_state_get_status)(struct xkb_compose_state*);
+typedef xkb_keysym_t (* PFN_xkb_compose_state_get_one_sym)(struct xkb_compose_state*);
+#define xkb_compose_table_new_from_locale _glfw.wl.xkb.compose_table_new_from_locale
+#define xkb_compose_table_unref _glfw.wl.xkb.compose_table_unref
+#define xkb_compose_state_new _glfw.wl.xkb.compose_state_new
+#define xkb_compose_state_unref _glfw.wl.xkb.compose_state_unref
+#define xkb_compose_state_feed _glfw.wl.xkb.compose_state_feed
+#define xkb_compose_state_get_status _glfw.wl.xkb.compose_state_get_status
+#define xkb_compose_state_get_one_sym _glfw.wl.xkb.compose_state_get_one_sym
+#endif
 
-// Wayland-specific video mode data
-//
-typedef struct _GLFWvidmodeWayland _GLFWvidmodeWayland;
 
 // Wayland-specific per-window data
 //
@@ -81,9 +117,10 @@ typedef struct _GLFWwindowWayland
     int                         width, height;
     GLFWbool                    visible;
     GLFWbool                    maximized;
+    GLFWbool                    transparent;
     struct wl_surface*          surface;
     struct wl_egl_window*       native;
-    struct wl_shell_surface*    shell_surface;
+    struct wl_shell_surface*    shellSurface;
     struct wl_callback*         callback;
 
     _GLFWcursor*                currentCursor;
@@ -102,6 +139,9 @@ typedef struct _GLFWwindowWayland
         struct zwp_relative_pointer_v1*    relativePointer;
         struct zwp_locked_pointer_v1*      lockedPointer;
     } pointerLock;
+
+    struct zwp_idle_inhibitor_v1*          idleInhibitor;
+
 } _GLFWwindowWayland;
 
 // Wayland-specific global data
@@ -118,28 +158,53 @@ typedef struct _GLFWlibraryWayland
     struct wl_keyboard*         keyboard;
     struct zwp_relative_pointer_manager_v1* relativePointerManager;
     struct zwp_pointer_constraints_v1*      pointerConstraints;
+    struct zwp_idle_inhibit_manager_v1*     idleInhibitManager;
 
-    int                         wl_compositor_version;
+    int                         compositorVersion;
 
     struct wl_cursor_theme*     cursorTheme;
     struct wl_surface*          cursorSurface;
     uint32_t                    pointerSerial;
 
-    _GLFWmonitor**              monitors;
+    short int                   keycodes[256];
-    int                         monitorsCount;
+    short int                   scancodes[GLFW_KEY_LAST + 1];
-    int                         monitorsSize;
-
-    short int                   publicKeys[256];
 
     struct {
+        void*                   handle;
         struct xkb_context*     context;
         struct xkb_keymap*      keymap;
         struct xkb_state*       state;
-        xkb_mod_mask_t          control_mask;
+
-        xkb_mod_mask_t          alt_mask;
+#ifdef HAVE_XKBCOMMON_COMPOSE_H
-        xkb_mod_mask_t          shift_mask;
+        struct xkb_compose_state* composeState;
-        xkb_mod_mask_t          super_mask;
+#endif
+
+        xkb_mod_mask_t          controlMask;
+        xkb_mod_mask_t          altMask;
+        xkb_mod_mask_t          shiftMask;
+        xkb_mod_mask_t          superMask;
         unsigned int            modifiers;
+
+        PFN_xkb_context_new context_new;
+        PFN_xkb_context_unref context_unref;
+        PFN_xkb_keymap_new_from_string keymap_new_from_string;
+        PFN_xkb_keymap_unref keymap_unref;
+        PFN_xkb_keymap_mod_get_index keymap_mod_get_index;
+        PFN_xkb_state_new state_new;
+        PFN_xkb_state_unref state_unref;
+        PFN_xkb_state_key_get_syms state_key_get_syms;
+        PFN_xkb_state_update_mask state_update_mask;
+        PFN_xkb_state_serialize_mods state_serialize_mods;
+
+#ifdef HAVE_XKBCOMMON_COMPOSE_H
+        PFN_xkb_compose_table_new_from_locale compose_table_new_from_locale;
+        PFN_xkb_compose_table_unref compose_table_unref;
+        PFN_xkb_compose_state_new compose_state_new;
+        PFN_xkb_compose_state_unref compose_state_unref;
+        PFN_xkb_compose_state_feed compose_state_feed;
+        PFN_xkb_compose_state_get_status compose_state_get_status;
+        PFN_xkb_compose_state_get_one_sym compose_state_get_one_sym;
+#endif
     } xkb;
 
     _GLFWwindow*                pointerFocus;
@@ -152,15 +217,12 @@ typedef struct _GLFWlibraryWayland
 typedef struct _GLFWmonitorWayland
 {
     struct wl_output*           output;
-
+    int                         currentMode;
-    _GLFWvidmodeWayland*        modes;
-    int                         modesCount;
-    int                         modesSize;
-    GLFWbool                    done;
 
     int                         x;
     int                         y;
     int                         scale;
+
 } _GLFWmonitorWayland;
 
 // Wayland-specific per-cursor data
@@ -176,4 +238,3 @@ typedef struct _GLFWcursorWayland
 
 void _glfwAddOutputWayland(uint32_t name, uint32_t version);
 
-#endif // _glfw3_wayland_platform_h_

raylib/external/glfw/src/wl_window.c

@@ -1,5 +1,5 @@
 //========================================================================
-// GLFW 3.2 Wayland - www.glfw.org
+// GLFW 3.3 Wayland - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2014 Jonas Ådahl <jadahl@gmail.com>
 //
@@ -105,7 +105,7 @@ static void checkScaleChange(_GLFWwindow* window)
     int monitorScale;
 
     // Check if we will be able to set the buffer scale or not.
-    if (_glfw.wl.wl_compositor_version < 3)
+    if (_glfw.wl.compositorVersion < 3)
         return;
 
     // Get the scale factor from the highest scale monitor.
@@ -189,6 +189,24 @@ static void setOpaqueRegion(_GLFWwindow* window)
     wl_region_destroy(region);
 }
 
+static void setIdleInhibitor(_GLFWwindow* window, GLFWbool enable)
+{
+    if (enable && !window->wl.idleInhibitor && _glfw.wl.idleInhibitManager)
+    {
+        window->wl.idleInhibitor =
+            zwp_idle_inhibit_manager_v1_create_inhibitor(
+                _glfw.wl.idleInhibitManager, window->wl.surface);
+        if (!window->wl.idleInhibitor)
+            _glfwInputError(GLFW_PLATFORM_ERROR,
+                            "Wayland: Idle inhibitor creation failed");
+    }
+    else if (!enable && window->wl.idleInhibitor)
+    {
+        zwp_idle_inhibitor_v1_destroy(window->wl.idleInhibitor);
+        window->wl.idleInhibitor = NULL;
+    }
+}
+
 static GLFWbool createSurface(_GLFWwindow* window,
                               const _GLFWwndconfig* wndconfig)
 {
@@ -212,43 +230,48 @@ static GLFWbool createSurface(_GLFWwindow* window,
     window->wl.height = wndconfig->height;
     window->wl.scale = 1;
 
-    // TODO: make this optional once issue #197 is fixed.
+    if (!window->wl.transparent)
-    setOpaqueRegion(window);
+        setOpaqueRegion(window);
 
     return GLFW_TRUE;
 }
 
 static GLFWbool createShellSurface(_GLFWwindow* window)
 {
-    window->wl.shell_surface = wl_shell_get_shell_surface(_glfw.wl.shell,
+    window->wl.shellSurface = wl_shell_get_shell_surface(_glfw.wl.shell,
-                                                          window->wl.surface);
+                                                         window->wl.surface);
-    if (!window->wl.shell_surface)
+    if (!window->wl.shellSurface)
         return GLFW_FALSE;
 
-    wl_shell_surface_add_listener(window->wl.shell_surface,
+    wl_shell_surface_add_listener(window->wl.shellSurface,
                                   &shellSurfaceListener,
                                   window);
 
     if (window->wl.title)
-        wl_shell_surface_set_title(window->wl.shell_surface, window->wl.title);
+        wl_shell_surface_set_title(window->wl.shellSurface, window->wl.title);
 
     if (window->monitor)
     {
         wl_shell_surface_set_fullscreen(
-            window->wl.shell_surface,
+            window->wl.shellSurface,
             WL_SHELL_SURFACE_FULLSCREEN_METHOD_DEFAULT,
             0,
             window->monitor->wl.output);
+        setIdleInhibitor(window, GLFW_TRUE);
     }
     else if (window->wl.maximized)
     {
-        wl_shell_surface_set_maximized(window->wl.shell_surface, NULL);
+        wl_shell_surface_set_maximized(window->wl.shellSurface, NULL);
+        setIdleInhibitor(window, GLFW_FALSE);
     }
     else
     {
-        wl_shell_surface_set_toplevel(window->wl.shell_surface);
+        wl_shell_surface_set_toplevel(window->wl.shellSurface);
+        setIdleInhibitor(window, GLFW_FALSE);
     }
 
+    wl_surface_commit(window->wl.surface);
+
     return GLFW_TRUE;
 }
 
@@ -388,15 +411,28 @@ int _glfwPlatformCreateWindow(_GLFWwindow* window,
                               const _GLFWctxconfig* ctxconfig,
                               const _GLFWfbconfig* fbconfig)
 {
+    window->wl.transparent = fbconfig->transparent;
+
     if (!createSurface(window, wndconfig))
         return GLFW_FALSE;
 
     if (ctxconfig->client != GLFW_NO_API)
     {
-        if (!_glfwInitEGL())
+        if (ctxconfig->source == GLFW_EGL_CONTEXT_API ||
-            return GLFW_FALSE;
+            ctxconfig->source == GLFW_NATIVE_CONTEXT_API)
-        if (!_glfwCreateContextEGL(window, ctxconfig, fbconfig))
+        {
-            return GLFW_FALSE;
+            if (!_glfwInitEGL())
+                return GLFW_FALSE;
+            if (!_glfwCreateContextEGL(window, ctxconfig, fbconfig))
+                return GLFW_FALSE;
+        }
+        else if (ctxconfig->source == GLFW_OSMESA_CONTEXT_API)
+        {
+            if (!_glfwInitOSMesa())
+                return GLFW_FALSE;
+            if (!_glfwCreateContextOSMesa(window, ctxconfig, fbconfig))
+                return GLFW_FALSE;
+        }
     }
 
     if (wndconfig->title)
@@ -411,7 +447,7 @@ int _glfwPlatformCreateWindow(_GLFWwindow* window,
     }
     else
     {
-        window->wl.shell_surface = NULL;
+        window->wl.shellSurface = NULL;
         window->wl.visible = GLFW_FALSE;
     }
 
@@ -437,14 +473,17 @@ void _glfwPlatformDestroyWindow(_GLFWwindow* window)
         _glfwInputWindowFocus(window, GLFW_FALSE);
     }
 
+    if (window->wl.idleInhibitor)
+        zwp_idle_inhibitor_v1_destroy(window->wl.idleInhibitor);
+
     if (window->context.destroy)
         window->context.destroy(window);
 
     if (window->wl.native)
         wl_egl_window_destroy(window->wl.native);
 
-    if (window->wl.shell_surface)
+    if (window->wl.shellSurface)
-        wl_shell_surface_destroy(window->wl.shell_surface);
+        wl_shell_surface_destroy(window->wl.shellSurface);
 
     if (window->wl.surface)
         wl_surface_destroy(window->wl.surface);
@@ -458,8 +497,8 @@ void _glfwPlatformSetWindowTitle(_GLFWwindow* window, const char* title)
     if (window->wl.title)
         free(window->wl.title);
     window->wl.title = strdup(title);
-    if (window->wl.shell_surface)
+    if (window->wl.shellSurface)
-        wl_shell_surface_set_title(window->wl.shell_surface, title);
+        wl_shell_surface_set_title(window->wl.shellSurface, title);
 }
 
 void _glfwPlatformSetWindowIcon(_GLFWwindow* window,
@@ -501,7 +540,8 @@ void _glfwPlatformSetWindowSize(_GLFWwindow* window, int width, int height)
     window->wl.width = width;
     window->wl.height = height;
     wl_egl_window_resize(window->wl.native, scaledWidth, scaledHeight, 0, 0);
-    setOpaqueRegion(window);
+    if (!window->wl.transparent)
+        setOpaqueRegion(window);
     _glfwInputFramebufferSize(window, scaledWidth, scaledHeight);
 }
 
@@ -534,6 +574,15 @@ void _glfwPlatformGetWindowFrameSize(_GLFWwindow* window,
     // implemented, but for now just leave everything as 0.
 }
 
+void _glfwPlatformGetWindowContentScale(_GLFWwindow* window,
+                                        float* xscale, float* yscale)
+{
+    if (xscale)
+        *xscale = (float) window->wl.scale;
+    if (yscale)
+        *yscale = (float) window->wl.scale;
+}
+
 void _glfwPlatformIconifyWindow(_GLFWwindow* window)
 {
     // TODO: move to xdg_shell instead of wl_shell.
@@ -546,8 +595,8 @@ void _glfwPlatformRestoreWindow(_GLFWwindow* window)
     // TODO: also do the same for iconified.
     if (window->monitor || window->wl.maximized)
     {
-        if (window->wl.shell_surface)
+        if (window->wl.shellSurface)
-            wl_shell_surface_set_toplevel(window->wl.shell_surface);
+            wl_shell_surface_set_toplevel(window->wl.shellSurface);
 
         window->wl.maximized = GLFW_FALSE;
     }
@@ -557,10 +606,10 @@ void _glfwPlatformMaximizeWindow(_GLFWwindow* window)
 {
     if (!window->monitor && !window->wl.maximized)
     {
-        if (window->wl.shell_surface)
+        if (window->wl.shellSurface)
         {
             // Let the compositor select the best output.
-            wl_shell_surface_set_maximized(window->wl.shell_surface, NULL);
+            wl_shell_surface_set_maximized(window->wl.shellSurface, NULL);
         }
         window->wl.maximized = GLFW_TRUE;
     }
@@ -570,7 +619,7 @@ void _glfwPlatformShowWindow(_GLFWwindow* window)
 {
     if (!window->monitor)
     {
-        if (!window->wl.shell_surface)
+        if (!window->wl.shellSurface)
             createShellSurface(window);
         window->wl.visible = GLFW_TRUE;
     }
@@ -580,12 +629,19 @@ void _glfwPlatformHideWindow(_GLFWwindow* window)
 {
     if (!window->monitor)
     {
-        if (window->wl.shell_surface)
+        if (window->wl.shellSurface)
-            wl_shell_surface_destroy(window->wl.shell_surface);
+            wl_shell_surface_destroy(window->wl.shellSurface);
         window->wl.visible = GLFW_FALSE;
     }
 }
 
+void _glfwPlatformRequestWindowAttention(_GLFWwindow* window)
+{
+    // TODO
+    _glfwInputError(GLFW_PLATFORM_ERROR,
+                    "Wayland: Window attention request not implemented yet");
+}
+
 void _glfwPlatformFocusWindow(_GLFWwindow* window)
 {
     _glfwInputError(GLFW_PLATFORM_ERROR,
@@ -601,16 +657,18 @@ void _glfwPlatformSetWindowMonitor(_GLFWwindow* window,
     if (monitor)
     {
         wl_shell_surface_set_fullscreen(
-            window->wl.shell_surface,
+            window->wl.shellSurface,
             WL_SHELL_SURFACE_FULLSCREEN_METHOD_DEFAULT,
             refreshRate * 1000, // Convert Hz to mHz.
             monitor->wl.output);
+        setIdleInhibitor(window, GLFW_TRUE);
     }
     else
     {
-        wl_shell_surface_set_toplevel(window->wl.shell_surface);
+        wl_shell_surface_set_toplevel(window->wl.shellSurface);
+        setIdleInhibitor(window, GLFW_FALSE);
     }
-    _glfwInputWindowMonitorChange(window, monitor);
+    _glfwInputWindowMonitor(window, monitor);
 }
 
 int _glfwPlatformWindowFocused(_GLFWwindow* window)
@@ -634,6 +692,41 @@ int _glfwPlatformWindowMaximized(_GLFWwindow* window)
     return window->wl.maximized;
 }
 
+int _glfwPlatformFramebufferTransparent(_GLFWwindow* window)
+{
+    return window->wl.transparent;
+}
+
+void _glfwPlatformSetWindowResizable(_GLFWwindow* window, GLFWbool enabled)
+{
+    // TODO
+    _glfwInputError(GLFW_PLATFORM_ERROR,
+                    "Wayland: Window attribute setting not implemented yet");
+}
+
+void _glfwPlatformSetWindowDecorated(_GLFWwindow* window, GLFWbool enabled)
+{
+    // TODO
+    _glfwInputError(GLFW_PLATFORM_ERROR,
+                    "Wayland: Window attribute setting not implemented yet");
+}
+
+void _glfwPlatformSetWindowFloating(_GLFWwindow* window, GLFWbool enabled)
+{
+    // TODO
+    _glfwInputError(GLFW_PLATFORM_ERROR,
+                    "Wayland: Window attribute setting not implemented yet");
+}
+
+float _glfwPlatformGetWindowOpacity(_GLFWwindow* window)
+{
+    return 1.f;
+}
+
+void _glfwPlatformSetWindowOpacity(_GLFWwindow* window, float opacity)
+{
+}
+
 void _glfwPlatformPollEvents(void)
 {
     handleEvents(0);
@@ -680,12 +773,17 @@ void _glfwPlatformSetCursorMode(_GLFWwindow* window, int mode)
     _glfwPlatformSetCursor(window, window->wl.currentCursor);
 }
 
-const char* _glfwPlatformGetKeyName(int key, int scancode)
+const char* _glfwPlatformGetScancodeName(int scancode)
 {
     // TODO
     return NULL;
 }
 
+int _glfwPlatformGetKeyScancode(int key)
+{
+    return _glfw.wl.scancodes[key];
+}
+
 int _glfwPlatformCreateCursor(_GLFWcursor* cursor,
                               const GLFWimage* image,
                               int xhot, int yhot)
@@ -945,14 +1043,14 @@ void _glfwPlatformSetCursor(_GLFWwindow* window, _GLFWcursor* cursor)
     }
 }
 
-void _glfwPlatformSetClipboardString(_GLFWwindow* window, const char* string)
+void _glfwPlatformSetClipboardString(const char* string)
 {
     // TODO
     _glfwInputError(GLFW_PLATFORM_ERROR,
                     "Wayland: Clipboard setting not implemented yet");
 }
 
-const char* _glfwPlatformGetClipboardString(_GLFWwindow* window)
+const char* _glfwPlatformGetClipboardString(void)
 {
     // TODO
     _glfwInputError(GLFW_PLATFORM_ERROR,
@@ -960,28 +1058,21 @@ const char* _glfwPlatformGetClipboardString(_GLFWwindow* window)
     return NULL;
 }
 
-char** _glfwPlatformGetRequiredInstanceExtensions(uint32_t* count)
+void _glfwPlatformGetRequiredInstanceExtensions(char** extensions)
 {
-    char** extensions;
+    if (!_glfw.vk.KHR_surface || !_glfw.vk.KHR_wayland_surface)
+        return;
 
-    *count = 0;
+    extensions[0] = "VK_KHR_surface";
-
+    extensions[1] = "VK_KHR_wayland_surface";
-    if (!_glfw.vk.KHR_wayland_surface)
-        return NULL;
-
-    extensions = calloc(2, sizeof(char*));
-    extensions[0] = strdup("VK_KHR_surface");
-    extensions[1] = strdup("VK_KHR_wayland_surface");
-
-    *count = 2;
-    return extensions;
 }
 
 int _glfwPlatformGetPhysicalDevicePresentationSupport(VkInstance instance,
                                                       VkPhysicalDevice device,
                                                       uint32_t queuefamily)
 {
-    PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR vkGetPhysicalDeviceWaylandPresentationSupportKHR =
+    PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR
+        vkGetPhysicalDeviceWaylandPresentationSupportKHR =
         (PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR)
         vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceWaylandPresentationSupportKHR");
     if (!vkGetPhysicalDeviceWaylandPresentationSupportKHR)

raylib/external/glfw/src/x11_init.c

@@ -1,8 +1,8 @@
 //========================================================================
-// GLFW 3.2 X11 - www.glfw.org
+// GLFW 3.3 X11 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-2016 Camilla Berglund <elmindreda@glfw.org>
+// Copyright (c) 2006-2016 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
@@ -232,13 +232,13 @@ static void createKeyTables(void)
 {
     int scancode, key;
 
-    memset(_glfw.x11.publicKeys, -1, sizeof(_glfw.x11.publicKeys));
+    memset(_glfw.x11.keycodes, -1, sizeof(_glfw.x11.keycodes));
-    memset(_glfw.x11.nativeKeys, -1, sizeof(_glfw.x11.nativeKeys));
+    memset(_glfw.x11.scancodes, -1, sizeof(_glfw.x11.scancodes));
 
     if (_glfw.x11.xkb.available)
     {
-        // Use XKB to determine physical key locations independently of the current
+        // Use XKB to determine physical key locations independently of the
-        // keyboard layout
+        // current keyboard layout
 
         char name[XkbKeyNameLength + 1];
         XkbDescPtr desc = XkbGetMap(_glfw.x11.display, 0, XkbUseCoreKbd);
@@ -305,7 +305,7 @@ static void createKeyTables(void)
             else key = GLFW_KEY_UNKNOWN;
 
             if ((scancode >= 0) && (scancode < 256))
-                _glfw.x11.publicKeys[scancode] = key;
+                _glfw.x11.keycodes[scancode] = key;
         }
 
         XkbFreeNames(desc, XkbKeyNamesMask, True);
@@ -316,12 +316,12 @@ static void createKeyTables(void)
     {
         // Translate the un-translated key codes using traditional X11 KeySym
         // lookups
-        if (_glfw.x11.publicKeys[scancode] < 0)
+        if (_glfw.x11.keycodes[scancode] < 0)
-            _glfw.x11.publicKeys[scancode] = translateKeyCode(scancode);
+            _glfw.x11.keycodes[scancode] = translateKeyCode(scancode);
 
         // Store the reverse translation for faster key name lookup
-        if (_glfw.x11.publicKeys[scancode] > 0)
+        if (_glfw.x11.keycodes[scancode] > 0)
-            _glfw.x11.nativeKeys[_glfw.x11.publicKeys[scancode]] = scancode;
+            _glfw.x11.scancodes[_glfw.x11.keycodes[scancode]] = scancode;
     }
 }
 
@@ -381,13 +381,11 @@ static void detectEWMH(void)
         XInternAtom(_glfw.x11.display, "_NET_SUPPORTED", False);
 
     // Then we look for the _NET_SUPPORTING_WM_CHECK property of the root window
-    if (_glfwGetWindowPropertyX11(_glfw.x11.root,
+    if (!_glfwGetWindowPropertyX11(_glfw.x11.root,
-                                  supportingWmCheck,
+                                   supportingWmCheck,
-                                  XA_WINDOW,
+                                   XA_WINDOW,
-                                  (unsigned char**) &windowFromRoot) != 1)
+                                   (unsigned char**) &windowFromRoot))
     {
-        if (windowFromRoot)
-            XFree(windowFromRoot);
         return;
     }
 
@@ -395,14 +393,12 @@ static void detectEWMH(void)
 
     // It should be the ID of a child window (of the root)
     // Then we look for the same property on the child window
-    if (_glfwGetWindowPropertyX11(*windowFromRoot,
+    if (!_glfwGetWindowPropertyX11(*windowFromRoot,
-                                  supportingWmCheck,
+                                   supportingWmCheck,
-                                  XA_WINDOW,
+                                   XA_WINDOW,
-                                  (unsigned char**) &windowFromChild) != 1)
+                                   (unsigned char**) &windowFromChild))
     {
         XFree(windowFromRoot);
-        if (windowFromChild)
-            XFree(windowFromChild);
         return;
     }
 
@@ -442,6 +438,8 @@ static void detectEWMH(void)
         getSupportedAtom(supportedAtoms, atomCount, "_NET_WM_STATE_MAXIMIZED_VERT");
     _glfw.x11.NET_WM_STATE_MAXIMIZED_HORZ =
         getSupportedAtom(supportedAtoms, atomCount, "_NET_WM_STATE_MAXIMIZED_HORZ");
+    _glfw.x11.NET_WM_STATE_DEMANDS_ATTENTION =
+        getSupportedAtom(supportedAtoms, atomCount, "_NET_WM_STATE_DEMANDS_ATTENTION");
     _glfw.x11.NET_WM_FULLSCREEN_MONITORS =
         getSupportedAtom(supportedAtoms, atomCount, "_NET_WM_FULLSCREEN_MONITORS");
     _glfw.x11.NET_WM_WINDOW_TYPE =
@@ -455,72 +453,176 @@ static void detectEWMH(void)
     _glfw.x11.NET_REQUEST_FRAME_EXTENTS =
         getSupportedAtom(supportedAtoms, atomCount, "_NET_REQUEST_FRAME_EXTENTS");
 
-    XFree(supportedAtoms);
+    if (supportedAtoms)
+        XFree(supportedAtoms);
 }
 
-// Initialize X11 display and look for supported X11 extensions
+// Look for and initialize supported X11 extensions
 //
 static GLFWbool initExtensions(void)
 {
-#if defined(_GLFW_HAS_XF86VM)
+    _glfw.x11.vidmode.handle = dlopen("libXxf86vm.so.1", RTLD_LAZY | RTLD_GLOBAL);
-    // Check for XF86VidMode extension
+    if (_glfw.x11.vidmode.handle)
-    _glfw.x11.vidmode.available =
-        XF86VidModeQueryExtension(_glfw.x11.display,
-                                  &_glfw.x11.vidmode.eventBase,
-                                  &_glfw.x11.vidmode.errorBase);
-#endif /*_GLFW_HAS_XF86VM*/
-
-    // Check for RandR extension
-    if (XRRQueryExtension(_glfw.x11.display,
-                          &_glfw.x11.randr.eventBase,
-                          &_glfw.x11.randr.errorBase))
     {
-        if (XRRQueryVersion(_glfw.x11.display,
+        _glfw.x11.vidmode.QueryExtension = (PFN_XF86VidModeQueryExtension)
-                            &_glfw.x11.randr.major,
+            dlsym(_glfw.x11.vidmode.handle, "XF86VidModeQueryExtension");
-                            &_glfw.x11.randr.minor))
+        _glfw.x11.vidmode.GetGammaRamp = (PFN_XF86VidModeGetGammaRamp)
+            dlsym(_glfw.x11.vidmode.handle, "XF86VidModeGetGammaRamp");
+        _glfw.x11.vidmode.SetGammaRamp = (PFN_XF86VidModeSetGammaRamp)
+            dlsym(_glfw.x11.vidmode.handle, "XF86VidModeSetGammaRamp");
+        _glfw.x11.vidmode.GetGammaRampSize = (PFN_XF86VidModeGetGammaRampSize)
+            dlsym(_glfw.x11.vidmode.handle, "XF86VidModeGetGammaRampSize");
+
+        _glfw.x11.vidmode.available =
+            XF86VidModeQueryExtension(_glfw.x11.display,
+                                      &_glfw.x11.vidmode.eventBase,
+                                      &_glfw.x11.vidmode.errorBase);
+    }
+
+    _glfw.x11.xi.handle = dlopen("libXi.so.6", RTLD_LAZY | RTLD_GLOBAL);
+    if (_glfw.x11.xi.handle)
+    {
+        _glfw.x11.xi.QueryVersion = (PFN_XIQueryVersion)
+            dlsym(_glfw.x11.xi.handle, "XIQueryVersion");
+        _glfw.x11.xi.SelectEvents = (PFN_XISelectEvents)
+            dlsym(_glfw.x11.xi.handle, "XISelectEvents");
+
+        if (XQueryExtension(_glfw.x11.display,
+                            "XInputExtension",
+                            &_glfw.x11.xi.majorOpcode,
+                            &_glfw.x11.xi.eventBase,
+                            &_glfw.x11.xi.errorBase))
         {
-            // The GLFW RandR path requires at least version 1.3
+            _glfw.x11.xi.major = 2;
-            if (_glfw.x11.randr.major > 1 || _glfw.x11.randr.minor >= 3)
+            _glfw.x11.xi.minor = 0;
-                _glfw.x11.randr.available = GLFW_TRUE;
+
+            if (XIQueryVersion(_glfw.x11.display,
+                               &_glfw.x11.xi.major,
+                               &_glfw.x11.xi.minor) == Success)
+            {
+                _glfw.x11.xi.available = GLFW_TRUE;
+            }
         }
-        else
+    }
+
+    _glfw.x11.randr.handle = dlopen("libXrandr.so.2", RTLD_LAZY | RTLD_GLOBAL);
+    if (_glfw.x11.randr.handle)
+    {
+        _glfw.x11.randr.AllocGamma = (PFN_XRRAllocGamma)
+            dlsym(_glfw.x11.randr.handle, "XRRAllocGamma");
+        _glfw.x11.randr.FreeGamma = (PFN_XRRFreeGamma)
+            dlsym(_glfw.x11.randr.handle, "XRRFreeGamma");
+        _glfw.x11.randr.FreeCrtcInfo = (PFN_XRRFreeCrtcInfo)
+            dlsym(_glfw.x11.randr.handle, "XRRFreeCrtcInfo");
+        _glfw.x11.randr.FreeGamma = (PFN_XRRFreeGamma)
+            dlsym(_glfw.x11.randr.handle, "XRRFreeGamma");
+        _glfw.x11.randr.FreeOutputInfo = (PFN_XRRFreeOutputInfo)
+            dlsym(_glfw.x11.randr.handle, "XRRFreeOutputInfo");
+        _glfw.x11.randr.FreeScreenResources = (PFN_XRRFreeScreenResources)
+            dlsym(_glfw.x11.randr.handle, "XRRFreeScreenResources");
+        _glfw.x11.randr.GetCrtcGamma = (PFN_XRRGetCrtcGamma)
+            dlsym(_glfw.x11.randr.handle, "XRRGetCrtcGamma");
+        _glfw.x11.randr.GetCrtcGammaSize = (PFN_XRRGetCrtcGammaSize)
+            dlsym(_glfw.x11.randr.handle, "XRRGetCrtcGammaSize");
+        _glfw.x11.randr.GetCrtcInfo = (PFN_XRRGetCrtcInfo)
+            dlsym(_glfw.x11.randr.handle, "XRRGetCrtcInfo");
+        _glfw.x11.randr.GetOutputInfo = (PFN_XRRGetOutputInfo)
+            dlsym(_glfw.x11.randr.handle, "XRRGetOutputInfo");
+        _glfw.x11.randr.GetOutputPrimary = (PFN_XRRGetOutputPrimary)
+            dlsym(_glfw.x11.randr.handle, "XRRGetOutputPrimary");
+        _glfw.x11.randr.GetScreenResourcesCurrent = (PFN_XRRGetScreenResourcesCurrent)
+            dlsym(_glfw.x11.randr.handle, "XRRGetScreenResourcesCurrent");
+        _glfw.x11.randr.QueryExtension = (PFN_XRRQueryExtension)
+            dlsym(_glfw.x11.randr.handle, "XRRQueryExtension");
+        _glfw.x11.randr.QueryVersion = (PFN_XRRQueryVersion)
+            dlsym(_glfw.x11.randr.handle, "XRRQueryVersion");
+        _glfw.x11.randr.SelectInput = (PFN_XRRSelectInput)
+            dlsym(_glfw.x11.randr.handle, "XRRSelectInput");
+        _glfw.x11.randr.SetCrtcConfig = (PFN_XRRSetCrtcConfig)
+            dlsym(_glfw.x11.randr.handle, "XRRSetCrtcConfig");
+        _glfw.x11.randr.SetCrtcGamma = (PFN_XRRSetCrtcGamma)
+            dlsym(_glfw.x11.randr.handle, "XRRSetCrtcGamma");
+        _glfw.x11.randr.UpdateConfiguration = (PFN_XRRUpdateConfiguration)
+            dlsym(_glfw.x11.randr.handle, "XRRUpdateConfiguration");
+
+        if (XRRQueryExtension(_glfw.x11.display,
+                              &_glfw.x11.randr.eventBase,
+                              &_glfw.x11.randr.errorBase))
         {
-            _glfwInputError(GLFW_PLATFORM_ERROR,
+            if (XRRQueryVersion(_glfw.x11.display,
-                            "X11: Failed to query RandR version");
+                                &_glfw.x11.randr.major,
+                                &_glfw.x11.randr.minor))
+            {
+                // The GLFW RandR path requires at least version 1.3
+                if (_glfw.x11.randr.major > 1 || _glfw.x11.randr.minor >= 3)
+                    _glfw.x11.randr.available = GLFW_TRUE;
+            }
+            else
+            {
+                _glfwInputError(GLFW_PLATFORM_ERROR,
+                                "X11: Failed to query RandR version");
+            }
         }
     }
 
     if (_glfw.x11.randr.available)
     {
-        XRRScreenResources* sr = XRRGetScreenResources(_glfw.x11.display,
+        XRRScreenResources* sr = XRRGetScreenResourcesCurrent(_glfw.x11.display,
-                                                       _glfw.x11.root);
+                                                              _glfw.x11.root);
 
         if (!sr->ncrtc || !XRRGetCrtcGammaSize(_glfw.x11.display, sr->crtcs[0]))
         {
-            // This is either a headless system or an older Nvidia binary driver
+            // This is likely an older Nvidia driver with broken gamma support
-            // with broken gamma support
+            // Flag it as useless and fall back to xf86vm gamma, if available
-            // Flag it as useless and fall back to Xf86VidMode gamma, if
-            // available
-            _glfwInputError(GLFW_PLATFORM_ERROR,
-                            "X11: RandR gamma ramp support seems broken");
             _glfw.x11.randr.gammaBroken = GLFW_TRUE;
         }
 
-        XRRFreeScreenResources(sr);
+        if (!sr->ncrtc)
+        {
+            // A system without CRTCs is likely a system with broken RandR
+            // Disable the RandR monitor path and fall back to core functions
+            _glfw.x11.randr.monitorBroken = GLFW_TRUE;
+        }
 
+        XRRFreeScreenResources(sr);
+    }
+
+    if (_glfw.x11.randr.available && !_glfw.x11.randr.monitorBroken)
+    {
         XRRSelectInput(_glfw.x11.display, _glfw.x11.root,
                        RROutputChangeNotifyMask);
     }
 
-    if (XineramaQueryExtension(_glfw.x11.display,
+    _glfw.x11.xcursor.handle = dlopen("libXcursor.so.1", RTLD_LAZY | RTLD_GLOBAL);
-                               &_glfw.x11.xinerama.major,
+    if (_glfw.x11.xcursor.handle)
-                               &_glfw.x11.xinerama.minor))
     {
-        if (XineramaIsActive(_glfw.x11.display))
+        _glfw.x11.xcursor.ImageCreate = (PFN_XcursorImageCreate)
-            _glfw.x11.xinerama.available = GLFW_TRUE;
+            dlsym(_glfw.x11.xcursor.handle, "XcursorImageCreate");
+        _glfw.x11.xcursor.ImageDestroy = (PFN_XcursorImageDestroy)
+            dlsym(_glfw.x11.xcursor.handle, "XcursorImageDestroy");
+        _glfw.x11.xcursor.ImageLoadCursor = (PFN_XcursorImageLoadCursor)
+            dlsym(_glfw.x11.xcursor.handle, "XcursorImageLoadCursor");
+    }
+
+    _glfw.x11.xinerama.handle = dlopen("libXinerama.so.1", RTLD_LAZY | RTLD_GLOBAL);
+    if (_glfw.x11.xinerama.handle)
+    {
+        _glfw.x11.xinerama.IsActive = (PFN_XineramaIsActive)
+            dlsym(_glfw.x11.xinerama.handle, "XineramaIsActive");
+        _glfw.x11.xinerama.QueryExtension = (PFN_XineramaQueryExtension)
+            dlsym(_glfw.x11.xinerama.handle, "XineramaQueryExtension");
+        _glfw.x11.xinerama.QueryScreens = (PFN_XineramaQueryScreens)
+            dlsym(_glfw.x11.xinerama.handle, "XineramaQueryScreens");
+
+        if (XineramaQueryExtension(_glfw.x11.display,
+                                   &_glfw.x11.xinerama.major,
+                                   &_glfw.x11.xinerama.minor))
+        {
+            if (XineramaIsActive(_glfw.x11.display))
+                _glfw.x11.xinerama.available = GLFW_TRUE;
+        }
     }
 
-    // Check if Xkb is supported on this display
     _glfw.x11.xkb.major = 1;
     _glfw.x11.xkb.minor = 0;
     _glfw.x11.xkb.available =
@@ -542,13 +644,36 @@ static GLFWbool initExtensions(void)
         }
     }
 
-    _glfw.x11.x11xcb.handle = dlopen("libX11-xcb.so", RTLD_LAZY | RTLD_GLOBAL);
+    _glfw.x11.x11xcb.handle = dlopen("libX11-xcb.so.1", RTLD_LAZY | RTLD_GLOBAL);
     if (_glfw.x11.x11xcb.handle)
     {
-        _glfw.x11.x11xcb.XGetXCBConnection = (XGETXCBCONNECTION_T)
+        _glfw.x11.x11xcb.GetXCBConnection = (PFN_XGetXCBConnection)
             dlsym(_glfw.x11.x11xcb.handle, "XGetXCBConnection");
     }
 
+    _glfw.x11.xrender.handle = dlopen("libXrender.so.1", RTLD_LAZY | RTLD_GLOBAL);
+    if (_glfw.x11.xrender.handle)
+    {
+        _glfw.x11.xrender.QueryExtension = (PFN_XRenderQueryExtension)
+            dlsym(_glfw.x11.xrender.handle, "XRenderQueryExtension");
+        _glfw.x11.xrender.QueryVersion = (PFN_XRenderQueryVersion)
+            dlsym(_glfw.x11.xrender.handle, "XRenderQueryVersion");
+        _glfw.x11.xrender.FindVisualFormat = (PFN_XRenderFindVisualFormat)
+            dlsym(_glfw.x11.xrender.handle, "XRenderFindVisualFormat");
+
+        if (XRenderQueryExtension(_glfw.x11.display,
+                                  &_glfw.x11.xrender.errorBase,
+                                  &_glfw.x11.xrender.eventBase))
+        {
+            if (XRenderQueryVersion(_glfw.x11.display,
+                                    &_glfw.x11.xrender.major,
+                                    &_glfw.x11.xrender.minor))
+            {
+                _glfw.x11.xrender.available = GLFW_TRUE;
+            }
+        }
+    }
+
     // Update the key code LUT
     // FIXME: We should listen to XkbMapNotify events to track changes to
     // the keyboard mapping.
@@ -559,10 +684,7 @@ static GLFWbool initExtensions(void)
 
     // String format atoms
     _glfw.x11.NULL_ = XInternAtom(_glfw.x11.display, "NULL", False);
-    _glfw.x11.UTF8_STRING =
+    _glfw.x11.UTF8_STRING = XInternAtom(_glfw.x11.display, "UTF8_STRING", False);
-        XInternAtom(_glfw.x11.display, "UTF8_STRING", False);
-    _glfw.x11.COMPOUND_STRING =
-        XInternAtom(_glfw.x11.display, "COMPOUND_STRING", False);
     _glfw.x11.ATOM_PAIR = XInternAtom(_glfw.x11.display, "ATOM_PAIR", False);
 
     // Custom selection property atom
@@ -572,6 +694,8 @@ static GLFWbool initExtensions(void)
     // ICCCM standard clipboard atoms
     _glfw.x11.TARGETS = XInternAtom(_glfw.x11.display, "TARGETS", False);
     _glfw.x11.MULTIPLE = XInternAtom(_glfw.x11.display, "MULTIPLE", False);
+    _glfw.x11.PRIMARY = XInternAtom(_glfw.x11.display, "PRIMARY", False);
+    _glfw.x11.INCR = XInternAtom(_glfw.x11.display, "INCR", False);
     _glfw.x11.CLIPBOARD = XInternAtom(_glfw.x11.display, "CLIPBOARD", False);
 
     // Clipboard manager atoms
@@ -587,9 +711,10 @@ static GLFWbool initExtensions(void)
     _glfw.x11.XdndStatus = XInternAtom(_glfw.x11.display, "XdndStatus", False);
     _glfw.x11.XdndActionCopy = XInternAtom(_glfw.x11.display, "XdndActionCopy", False);
     _glfw.x11.XdndDrop = XInternAtom(_glfw.x11.display, "XdndDrop", False);
-    _glfw.x11.XdndLeave = XInternAtom(_glfw.x11.display, "XdndLeave", False);
     _glfw.x11.XdndFinished = XInternAtom(_glfw.x11.display, "XdndFinished", False);
     _glfw.x11.XdndSelection = XInternAtom(_glfw.x11.display, "XdndSelection", False);
+    _glfw.x11.XdndTypeList = XInternAtom(_glfw.x11.display, "XdndTypeList", False);
+    _glfw.x11.text_uri_list = XInternAtom(_glfw.x11.display, "text/uri-list", False);
 
     // ICCCM, EWMH and Motif window property atoms
     // These can be set safely even without WM support
@@ -612,24 +737,81 @@ static GLFWbool initExtensions(void)
         XInternAtom(_glfw.x11.display, "_NET_WM_ICON_NAME", False);
     _glfw.x11.NET_WM_BYPASS_COMPOSITOR =
         XInternAtom(_glfw.x11.display, "_NET_WM_BYPASS_COMPOSITOR", False);
+    _glfw.x11.NET_WM_WINDOW_OPACITY =
+        XInternAtom(_glfw.x11.display, "_NET_WM_WINDOW_OPACITY", False);
     _glfw.x11.MOTIF_WM_HINTS =
         XInternAtom(_glfw.x11.display, "_MOTIF_WM_HINTS", False);
 
+    // The compositing manager selection name contains the screen number
+    {
+        char name[32];
+        snprintf(name, sizeof(name), "_NET_WM_CM_S%u", _glfw.x11.screen);
+        _glfw.x11.NET_WM_CM_Sx = XInternAtom(_glfw.x11.display, name, False);
+    }
+
     return GLFW_TRUE;
 }
 
+// Retrieve system content scale via folklore heuristics
+//
+static void getSystemContentScale(float* xscale, float* yscale)
+{
+    // NOTE: Default to the display-wide DPI as we don't currently have a policy
+    //       for which monitor a window is considered to be on
+    float xdpi = DisplayWidth(_glfw.x11.display, _glfw.x11.screen) *
+        25.4f / DisplayWidthMM(_glfw.x11.display, _glfw.x11.screen);
+    float ydpi = DisplayHeight(_glfw.x11.display, _glfw.x11.screen) *
+        25.4f / DisplayHeightMM(_glfw.x11.display, _glfw.x11.screen);
+
+    // NOTE: Basing the scale on Xft.dpi where available should provide the most
+    //       consistent user experience (matches Qt, Gtk, etc), although not
+    //       always the most accurate one
+    char* rms = XResourceManagerString(_glfw.x11.display);
+    if (rms)
+    {
+        XrmDatabase db = XrmGetStringDatabase(rms);
+        if (db)
+        {
+            XrmValue value;
+            char* type = NULL;
+
+            if (XrmGetResource(db, "Xft.dpi", "Xft.Dpi", &type, &value))
+            {
+                if (type && strcmp(type, "String") == 0)
+                    xdpi = ydpi = atof(value.addr);
+            }
+
+            XrmDestroyDatabase(db);
+        }
+    }
+
+    *xscale = xdpi / 96.f;
+    *yscale = ydpi / 96.f;
+}
+
 // Create a blank cursor for hidden and disabled cursor modes
 //
 static Cursor createHiddenCursor(void)
 {
-    unsigned char pixels[16 * 16 * 4];
+    unsigned char pixels[16 * 16 * 4] = { 0 };
     GLFWimage image = { 16, 16, pixels };
-
-    memset(pixels, 0, sizeof(pixels));
-
     return _glfwCreateCursorX11(&image, 0, 0);
 }
 
+// Create a helper window for IPC
+//
+static Window createHelperWindow(void)
+{
+    XSetWindowAttributes wa;
+    wa.event_mask = PropertyChangeMask;
+
+    return XCreateWindow(_glfw.x11.display, _glfw.x11.root,
+                         0, 0, 1, 1, 0, 0,
+                         InputOnly,
+                         DefaultVisual(_glfw.x11.display, _glfw.x11.screen),
+                         CWEventMask, &wa);
+}
+
 // X error handler
 //
 static int errorHandler(Display *display, XErrorEvent* event)
@@ -664,7 +846,7 @@ void _glfwReleaseErrorHandlerX11(void)
 //
 void _glfwInputErrorX11(int error, const char* message)
 {
-    char buffer[8192];
+    char buffer[_GLFW_MESSAGE_SIZE];
     XGetErrorText(_glfw.x11.display, _glfw.x11.errorCode,
                   buffer, sizeof(buffer));
 
@@ -678,6 +860,9 @@ Cursor _glfwCreateCursorX11(const GLFWimage* image, int xhot, int yhot)
     int i;
     Cursor cursor;
 
+    if (!_glfw.x11.xcursor.handle)
+        return None;
+
     XcursorImage* native = XcursorImageCreate(image->width, image->height);
     if (native == NULL)
         return None;
@@ -712,13 +897,17 @@ Cursor _glfwCreateCursorX11(const GLFWimage* image, int xhot, int yhot)
 int _glfwPlatformInit(void)
 {
 #if !defined(X_HAVE_UTF8_STRING)
-    // HACK: If the current locale is C, apply the environment's locale
+    // HACK: If the current locale is "C" and the Xlib UTF-8 functions are
-    //       This is done because the C locale breaks wide character input
+    //       unavailable, apply the environment's locale in the hope that it's
+    //       both available and not "C"
+    //       This is done because the "C" locale breaks wide character input,
+    //       which is what we fall back on when UTF-8 support is missing
     if (strcmp(setlocale(LC_CTYPE, NULL), "C") == 0)
         setlocale(LC_CTYPE, "");
 #endif
 
     XInitThreads();
+    XrmInitialize();
 
     _glfw.x11.display = XOpenDisplay(NULL);
     if (!_glfw.x11.display)
@@ -742,10 +931,13 @@ int _glfwPlatformInit(void)
     _glfw.x11.root = RootWindow(_glfw.x11.display, _glfw.x11.screen);
     _glfw.x11.context = XUniqueContext();
 
+    getSystemContentScale(&_glfw.x11.contentScaleX, &_glfw.x11.contentScaleY);
+
     if (!initExtensions())
         return GLFW_FALSE;
 
-    _glfw.x11.cursor = createHiddenCursor();
+    _glfw.x11.helperWindowHandle = createHelperWindow();
+    _glfw.x11.hiddenCursorHandle = createHiddenCursor();
 
     if (XSupportsLocale())
     {
@@ -762,31 +954,38 @@ int _glfwPlatformInit(void)
         }
     }
 
-    if (!_glfwInitThreadLocalStoragePOSIX())
+#if defined(__linux__)
-        return GLFW_FALSE;
-
     if (!_glfwInitJoysticksLinux())
         return GLFW_FALSE;
+#endif
 
     _glfwInitTimerPOSIX();
 
+    _glfwPollMonitorsX11();
     return GLFW_TRUE;
 }
 
 void _glfwPlatformTerminate(void)
 {
-    if (_glfw.x11.x11xcb.handle)
+    if (_glfw.x11.helperWindowHandle)
     {
-        dlclose(_glfw.x11.x11xcb.handle);
+        if (XGetSelectionOwner(_glfw.x11.display, _glfw.x11.CLIPBOARD) ==
-        _glfw.x11.x11xcb.handle = NULL;
+            _glfw.x11.helperWindowHandle)
+        {
+            _glfwPushSelectionToManagerX11();
+        }
+
+        XDestroyWindow(_glfw.x11.display, _glfw.x11.helperWindowHandle);
+        _glfw.x11.helperWindowHandle = None;
     }
 
-    if (_glfw.x11.cursor)
+    if (_glfw.x11.hiddenCursorHandle)
     {
-        XFreeCursor(_glfw.x11.display, _glfw.x11.cursor);
+        XFreeCursor(_glfw.x11.display, _glfw.x11.hiddenCursorHandle);
-        _glfw.x11.cursor = (Cursor) 0;
+        _glfw.x11.hiddenCursorHandle = (Cursor) 0;
     }
 
+    free(_glfw.x11.primarySelectionString);
     free(_glfw.x11.clipboardString);
 
     if (_glfw.x11.im)
@@ -803,12 +1002,37 @@ void _glfwPlatformTerminate(void)
         _glfw.x11.display = NULL;
     }
 
+    if (_glfw.x11.x11xcb.handle)
+    {
+        dlclose(_glfw.x11.x11xcb.handle);
+        _glfw.x11.x11xcb.handle = NULL;
+    }
+
+    if (_glfw.x11.xcursor.handle)
+    {
+        dlclose(_glfw.x11.xcursor.handle);
+        _glfw.x11.xcursor.handle = NULL;
+    }
+
+    if (_glfw.x11.randr.handle)
+    {
+        dlclose(_glfw.x11.randr.handle);
+        _glfw.x11.randr.handle = NULL;
+    }
+
+    if (_glfw.x11.xinerama.handle)
+    {
+        dlclose(_glfw.x11.xinerama.handle);
+        _glfw.x11.xinerama.handle = NULL;
+    }
+
     // NOTE: This needs to be done after XCloseDisplay, as libGL registers
     //       cleanup callbacks that get called by it
     _glfwTerminateGLX();
 
+#if defined(__linux__)
     _glfwTerminateJoysticksLinux();
-    _glfwTerminateThreadLocalStoragePOSIX();
+#endif
 }
 
 const char* _glfwPlatformGetVersionString(void)
@@ -820,10 +1044,7 @@ const char* _glfwPlatformGetVersionString(void)
         " gettimeofday"
 #endif
 #if defined(__linux__)
-        " /dev/js"
+        " evdev"
-#endif
-#if defined(_GLFW_HAS_XF86VM)
-        " Xf86vm"
 #endif
 #if defined(_GLFW_BUILD_DLL)
         " shared"

raylib/external/glfw/src/x11_monitor.c

@@ -1,8 +1,8 @@
 //========================================================================
-// GLFW 3.2 X11 - www.glfw.org
+// GLFW 3.3 X11 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-2016 Camilla Berglund <elmindreda@glfw.org>
+// Copyright (c) 2006-2016 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
@@ -95,6 +95,126 @@ static GLFWvidmode vidmodeFromModeInfo(const XRRModeInfo* mi,
 //////                       GLFW internal API                      //////
 //////////////////////////////////////////////////////////////////////////
 
+// Poll for changes in the set of connected monitors
+//
+void _glfwPollMonitorsX11(void)
+{
+    if (_glfw.x11.randr.available && !_glfw.x11.randr.monitorBroken)
+    {
+        int i, j, disconnectedCount, screenCount = 0;
+        _GLFWmonitor** disconnected = NULL;
+        XineramaScreenInfo* screens = NULL;
+        XRRScreenResources* sr = XRRGetScreenResourcesCurrent(_glfw.x11.display,
+                                                              _glfw.x11.root);
+        RROutput primary = XRRGetOutputPrimary(_glfw.x11.display,
+                                               _glfw.x11.root);
+
+        if (_glfw.x11.xinerama.available)
+            screens = XineramaQueryScreens(_glfw.x11.display, &screenCount);
+
+        disconnectedCount = _glfw.monitorCount;
+        if (disconnectedCount)
+        {
+            disconnected = calloc(_glfw.monitorCount, sizeof(_GLFWmonitor*));
+            memcpy(disconnected,
+                   _glfw.monitors,
+                   _glfw.monitorCount * sizeof(_GLFWmonitor*));
+        }
+
+        for (i = 0;  i < sr->noutput;  i++)
+        {
+            int type, widthMM, heightMM;
+            XRROutputInfo* oi;
+            XRRCrtcInfo* ci;
+            _GLFWmonitor* monitor;
+
+            oi = XRRGetOutputInfo(_glfw.x11.display, sr, sr->outputs[i]);
+            if (oi->connection != RR_Connected || oi->crtc == None)
+            {
+                XRRFreeOutputInfo(oi);
+                continue;
+            }
+
+            for (j = 0;  j < disconnectedCount;  j++)
+            {
+                if (disconnected[j] &&
+                    disconnected[j]->x11.output == sr->outputs[i])
+                {
+                    disconnected[j] = NULL;
+                    break;
+                }
+            }
+
+            if (j < disconnectedCount)
+            {
+                XRRFreeOutputInfo(oi);
+                continue;
+            }
+
+            ci = XRRGetCrtcInfo(_glfw.x11.display, sr, oi->crtc);
+            if (ci->rotation == RR_Rotate_90 || ci->rotation == RR_Rotate_270)
+            {
+                widthMM  = oi->mm_height;
+                heightMM = oi->mm_width;
+            }
+            else
+            {
+                widthMM  = oi->mm_width;
+                heightMM = oi->mm_height;
+            }
+
+            monitor = _glfwAllocMonitor(oi->name, widthMM, heightMM);
+            monitor->x11.output = sr->outputs[i];
+            monitor->x11.crtc   = oi->crtc;
+
+            for (j = 0;  j < screenCount;  j++)
+            {
+                if (screens[j].x_org == ci->x &&
+                    screens[j].y_org == ci->y &&
+                    screens[j].width == ci->width &&
+                    screens[j].height == ci->height)
+                {
+                    monitor->x11.index = j;
+                    break;
+                }
+            }
+
+            if (monitor->x11.output == primary)
+                type = _GLFW_INSERT_FIRST;
+            else
+                type = _GLFW_INSERT_LAST;
+
+            _glfwInputMonitor(monitor, GLFW_CONNECTED, type);
+
+            XRRFreeOutputInfo(oi);
+            XRRFreeCrtcInfo(ci);
+        }
+
+        XRRFreeScreenResources(sr);
+
+        if (screens)
+            XFree(screens);
+
+        for (i = 0;  i < disconnectedCount;  i++)
+        {
+            if (disconnected[i])
+                _glfwInputMonitor(disconnected[i], GLFW_DISCONNECTED, 0);
+        }
+
+        free(disconnected);
+    }
+
+    if (!_glfw.monitorCount)
+    {
+        const int widthMM = DisplayWidthMM(_glfw.x11.display, _glfw.x11.screen);
+        const int heightMM = DisplayHeightMM(_glfw.x11.display, _glfw.x11.screen);
+
+        _glfwInputMonitor(_glfwAllocMonitor("Display", widthMM, heightMM),
+                          GLFW_CONNECTED,
+                          _GLFW_INSERT_FIRST);
+    }
+}
+
 // Set the current video mode for the specified monitor
 //
 GLFWbool _glfwSetVideoModeX11(_GLFWmonitor* monitor, const GLFWvidmode* desired)
@@ -114,7 +234,7 @@ GLFWbool _glfwSetVideoModeX11(_GLFWmonitor* monitor, const GLFWvidmode* desired)
         if (_glfwCompareVideoModes(&current, best) == 0)
             return GLFW_TRUE;
 
-        sr = XRRGetScreenResources(_glfw.x11.display, _glfw.x11.root);
+        sr = XRRGetScreenResourcesCurrent(_glfw.x11.display, _glfw.x11.root);
         ci = XRRGetCrtcInfo(_glfw.x11.display, sr, monitor->x11.crtc);
         oi = XRRGetOutputInfo(_glfw.x11.display, sr, monitor->x11.output);
 
@@ -174,7 +294,7 @@ void _glfwRestoreVideoModeX11(_GLFWmonitor* monitor)
         if (monitor->x11.oldMode == None)
             return;
 
-        sr = XRRGetScreenResources(_glfw.x11.display, _glfw.x11.root);
+        sr = XRRGetScreenResourcesCurrent(_glfw.x11.display, _glfw.x11.root);
         ci = XRRGetCrtcInfo(_glfw.x11.display, sr, monitor->x11.crtc);
 
         XRRSetCrtcConfig(_glfw.x11.display,
@@ -198,119 +318,6 @@ void _glfwRestoreVideoModeX11(_GLFWmonitor* monitor)
 //////                       GLFW platform API                      //////
 //////////////////////////////////////////////////////////////////////////
 
-_GLFWmonitor** _glfwPlatformGetMonitors(int* count)
-{
-    int i, j, k, found = 0;
-    _GLFWmonitor** monitors = NULL;
-
-    *count = 0;
-
-    if (_glfw.x11.randr.available)
-    {
-        int screenCount = 0;
-        XineramaScreenInfo* screens = NULL;
-        XRRScreenResources* sr = XRRGetScreenResources(_glfw.x11.display,
-                                                       _glfw.x11.root);
-        RROutput primary = XRRGetOutputPrimary(_glfw.x11.display,
-                                               _glfw.x11.root);
-
-        monitors = calloc(sr->noutput, sizeof(_GLFWmonitor*));
-
-        if (_glfw.x11.xinerama.available)
-            screens = XineramaQueryScreens(_glfw.x11.display, &screenCount);
-
-        for (i = 0;  i < sr->ncrtc;  i++)
-        {
-            XRRCrtcInfo* ci = XRRGetCrtcInfo(_glfw.x11.display,
-                                             sr, sr->crtcs[i]);
-
-            for (j = 0;  j < ci->noutput;  j++)
-            {
-                int widthMM, heightMM;
-                _GLFWmonitor* monitor;
-                XRROutputInfo* oi = XRRGetOutputInfo(_glfw.x11.display,
-                                                     sr, ci->outputs[j]);
-                if (oi->connection != RR_Connected)
-                {
-                    XRRFreeOutputInfo(oi);
-                    continue;
-                }
-
-                if (ci->rotation == RR_Rotate_90 || ci->rotation == RR_Rotate_270)
-                {
-                    widthMM  = oi->mm_height;
-                    heightMM = oi->mm_width;
-                }
-                else
-                {
-                    widthMM  = oi->mm_width;
-                    heightMM = oi->mm_height;
-                }
-
-                monitor = _glfwAllocMonitor(oi->name, widthMM, heightMM);
-                monitor->x11.output = ci->outputs[j];
-                monitor->x11.crtc   = oi->crtc;
-
-                for (k = 0;  k < screenCount;  k++)
-                {
-                    if (screens[k].x_org == ci->x &&
-                        screens[k].y_org == ci->y &&
-                        screens[k].width == ci->width &&
-                        screens[k].height == ci->height)
-                    {
-                        monitor->x11.index = k;
-                        break;
-                    }
-                }
-
-                XRRFreeOutputInfo(oi);
-
-                found++;
-                monitors[found - 1] = monitor;
-
-                if (ci->outputs[j] == primary)
-                    _GLFW_SWAP_POINTERS(monitors[0], monitors[found - 1]);
-            }
-
-            XRRFreeCrtcInfo(ci);
-        }
-
-        XRRFreeScreenResources(sr);
-
-        if (screens)
-            XFree(screens);
-
-        if (found == 0)
-        {
-            _glfwInputError(GLFW_PLATFORM_ERROR,
-                            "X11: RandR monitor support seems broken");
-
-            _glfw.x11.randr.monitorBroken = GLFW_TRUE;
-            free(monitors);
-            monitors = NULL;
-        }
-    }
-
-    if (!monitors)
-    {
-        monitors = calloc(1, sizeof(_GLFWmonitor*));
-        monitors[0] = _glfwAllocMonitor("Display",
-                                        DisplayWidthMM(_glfw.x11.display,
-                                                       _glfw.x11.screen),
-                                        DisplayHeightMM(_glfw.x11.display,
-                                                        _glfw.x11.screen));
-        found = 1;
-    }
-
-    *count = found;
-    return monitors;
-}
-
-GLFWbool _glfwPlatformIsSameMonitor(_GLFWmonitor* first, _GLFWmonitor* second)
-{
-    return first->x11.crtc == second->x11.crtc;
-}
-
 void _glfwPlatformGetMonitorPos(_GLFWmonitor* monitor, int* xpos, int* ypos)
 {
     if (_glfw.x11.randr.available && !_glfw.x11.randr.monitorBroken)
@@ -331,6 +338,15 @@ void _glfwPlatformGetMonitorPos(_GLFWmonitor* monitor, int* xpos, int* ypos)
     }
 }
 
+void _glfwPlatformGetMonitorContentScale(_GLFWmonitor* monitor,
+                                         float* xscale, float* yscale)
+{
+    if (xscale)
+        *xscale = _glfw.x11.contentScaleX;
+    if (yscale)
+        *yscale = _glfw.x11.contentScaleY;
+}
+
 GLFWvidmode* _glfwPlatformGetVideoModes(_GLFWmonitor* monitor, int* count)
 {
     GLFWvidmode* result;
@@ -423,13 +439,12 @@ void _glfwPlatformGetGammaRamp(_GLFWmonitor* monitor, GLFWgammaramp* ramp)
 
         _glfwAllocGammaArrays(ramp, size);
 
-        memcpy(ramp->red, gamma->red, size * sizeof(unsigned short));
+        memcpy(ramp->red,   gamma->red,   size * sizeof(unsigned short));
         memcpy(ramp->green, gamma->green, size * sizeof(unsigned short));
-        memcpy(ramp->blue, gamma->blue, size * sizeof(unsigned short));
+        memcpy(ramp->blue,  gamma->blue,  size * sizeof(unsigned short));
 
         XRRFreeGamma(gamma);
     }
-#if defined(_GLFW_HAS_XF86VM)
     else if (_glfw.x11.vidmode.available)
     {
         int size;
@@ -441,23 +456,28 @@ void _glfwPlatformGetGammaRamp(_GLFWmonitor* monitor, GLFWgammaramp* ramp)
                                 _glfw.x11.screen,
                                 ramp->size, ramp->red, ramp->green, ramp->blue);
     }
-#endif /*_GLFW_HAS_XF86VM*/
 }
 
 void _glfwPlatformSetGammaRamp(_GLFWmonitor* monitor, const GLFWgammaramp* ramp)
 {
     if (_glfw.x11.randr.available && !_glfw.x11.randr.gammaBroken)
     {
+        if (XRRGetCrtcGammaSize(_glfw.x11.display, monitor->x11.crtc) != ramp->size)
+        {
+            _glfwInputError(GLFW_PLATFORM_ERROR,
+                            "X11: Gamma ramp size must match current ramp size");
+            return;
+        }
+
         XRRCrtcGamma* gamma = XRRAllocGamma(ramp->size);
 
-        memcpy(gamma->red, ramp->red, ramp->size * sizeof(unsigned short));
+        memcpy(gamma->red,   ramp->red,   ramp->size * sizeof(unsigned short));
         memcpy(gamma->green, ramp->green, ramp->size * sizeof(unsigned short));
-        memcpy(gamma->blue, ramp->blue, ramp->size * sizeof(unsigned short));
+        memcpy(gamma->blue,  ramp->blue,  ramp->size * sizeof(unsigned short));
 
         XRRSetCrtcGamma(_glfw.x11.display, monitor->x11.crtc, gamma);
         XRRFreeGamma(gamma);
     }
-#if defined(_GLFW_HAS_XF86VM)
     else if (_glfw.x11.vidmode.available)
     {
         XF86VidModeSetGammaRamp(_glfw.x11.display,
@@ -467,7 +487,6 @@ void _glfwPlatformSetGammaRamp(_GLFWmonitor* monitor, const GLFWgammaramp* ramp)
                                 (unsigned short*) ramp->green,
                                 (unsigned short*) ramp->blue);
     }
-#endif /*_GLFW_HAS_XF86VM*/
 }
 
 

raylib/external/glfw/src/x11_platform.h

@@ -1,8 +1,8 @@
 //========================================================================
-// GLFW 3.2 X11 - www.glfw.org
+// GLFW 3.3 X11 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-2016 Camilla Berglund <elmindreda@glfw.org>
+// Copyright (c) 2006-2016 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
@@ -25,9 +25,6 @@
 //
 //========================================================================
 
-#ifndef _glfw3_x11_platform_h_
-#define _glfw3_x11_platform_h_
-
 #include <unistd.h>
 #include <signal.h>
 #include <stdint.h>
@@ -47,15 +44,84 @@
 // The Xinerama extension provides legacy monitor indices
 #include <X11/extensions/Xinerama.h>
 
-#if defined(_GLFW_HAS_XF86VM)
+// The XInput extension provides raw mouse motion input
- // The Xf86VidMode extension provides fallback gamma control
+#include <X11/extensions/XInput2.h>
- #include <X11/extensions/xf86vmode.h>
+
-#endif
+typedef XRRCrtcGamma* (* PFN_XRRAllocGamma)(int);
+typedef void (* PFN_XRRFreeCrtcInfo)(XRRCrtcInfo*);
+typedef void (* PFN_XRRFreeGamma)(XRRCrtcGamma*);
+typedef void (* PFN_XRRFreeOutputInfo)(XRROutputInfo*);
+typedef void (* PFN_XRRFreeScreenResources)(XRRScreenResources*);
+typedef XRRCrtcGamma* (* PFN_XRRGetCrtcGamma)(Display*,RRCrtc);
+typedef int (* PFN_XRRGetCrtcGammaSize)(Display*,RRCrtc);
+typedef XRRCrtcInfo* (* PFN_XRRGetCrtcInfo) (Display*,XRRScreenResources*,RRCrtc);
+typedef XRROutputInfo* (* PFN_XRRGetOutputInfo)(Display*,XRRScreenResources*,RROutput);
+typedef RROutput (* PFN_XRRGetOutputPrimary)(Display*,Window);
+typedef XRRScreenResources* (* PFN_XRRGetScreenResourcesCurrent)(Display*,Window);
+typedef Bool (* PFN_XRRQueryExtension)(Display*,int*,int*);
+typedef Status (* PFN_XRRQueryVersion)(Display*,int*,int*);
+typedef void (* PFN_XRRSelectInput)(Display*,Window,int);
+typedef Status (* PFN_XRRSetCrtcConfig)(Display*,XRRScreenResources*,RRCrtc,Time,int,int,RRMode,Rotation,RROutput*,int);
+typedef void (* PFN_XRRSetCrtcGamma)(Display*,RRCrtc,XRRCrtcGamma*);
+typedef int (* PFN_XRRUpdateConfiguration)(XEvent*);
+#define XRRAllocGamma _glfw.x11.randr.AllocGamma
+#define XRRFreeCrtcInfo _glfw.x11.randr.FreeCrtcInfo
+#define XRRFreeGamma _glfw.x11.randr.FreeGamma
+#define XRRFreeOutputInfo _glfw.x11.randr.FreeOutputInfo
+#define XRRFreeScreenResources _glfw.x11.randr.FreeScreenResources
+#define XRRGetCrtcGamma _glfw.x11.randr.GetCrtcGamma
+#define XRRGetCrtcGammaSize _glfw.x11.randr.GetCrtcGammaSize
+#define XRRGetCrtcInfo _glfw.x11.randr.GetCrtcInfo
+#define XRRGetOutputInfo _glfw.x11.randr.GetOutputInfo
+#define XRRGetOutputPrimary _glfw.x11.randr.GetOutputPrimary
+#define XRRGetScreenResourcesCurrent _glfw.x11.randr.GetScreenResourcesCurrent
+#define XRRQueryExtension _glfw.x11.randr.QueryExtension
+#define XRRQueryVersion _glfw.x11.randr.QueryVersion
+#define XRRSelectInput _glfw.x11.randr.SelectInput
+#define XRRSetCrtcConfig _glfw.x11.randr.SetCrtcConfig
+#define XRRSetCrtcGamma _glfw.x11.randr.SetCrtcGamma
+#define XRRUpdateConfiguration _glfw.x11.randr.UpdateConfiguration
+
+typedef XcursorImage* (* PFN_XcursorImageCreate)(int,int);
+typedef void (* PFN_XcursorImageDestroy)(XcursorImage*);
+typedef Cursor (* PFN_XcursorImageLoadCursor)(Display*,const XcursorImage*);
+#define XcursorImageCreate _glfw.x11.xcursor.ImageCreate
+#define XcursorImageDestroy _glfw.x11.xcursor.ImageDestroy
+#define XcursorImageLoadCursor _glfw.x11.xcursor.ImageLoadCursor
+
+typedef Bool (* PFN_XineramaIsActive)(Display*);
+typedef Bool (* PFN_XineramaQueryExtension)(Display*,int*,int*);
+typedef XineramaScreenInfo* (* PFN_XineramaQueryScreens)(Display*,int*);
+#define XineramaIsActive _glfw.x11.xinerama.IsActive
+#define XineramaQueryExtension _glfw.x11.xinerama.QueryExtension
+#define XineramaQueryScreens _glfw.x11.xinerama.QueryScreens
 
 typedef XID xcb_window_t;
 typedef XID xcb_visualid_t;
 typedef struct xcb_connection_t xcb_connection_t;
-typedef xcb_connection_t* (* XGETXCBCONNECTION_T)(Display*);
+typedef xcb_connection_t* (* PFN_XGetXCBConnection)(Display*);
+#define XGetXCBConnection _glfw.x11.x11xcb.GetXCBConnection
+
+typedef Bool (* PFN_XF86VidModeQueryExtension)(Display*,int*,int*);
+typedef Bool (* PFN_XF86VidModeGetGammaRamp)(Display*,int,int,unsigned short*,unsigned short*,unsigned short*);
+typedef Bool (* PFN_XF86VidModeSetGammaRamp)(Display*,int,int,unsigned short*,unsigned short*,unsigned short*);
+typedef Bool (* PFN_XF86VidModeGetGammaRampSize)(Display*,int,int*);
+#define XF86VidModeQueryExtension _glfw.x11.vidmode.QueryExtension
+#define XF86VidModeGetGammaRamp _glfw.x11.vidmode.GetGammaRamp
+#define XF86VidModeSetGammaRamp _glfw.x11.vidmode.SetGammaRamp
+#define XF86VidModeGetGammaRampSize _glfw.x11.vidmode.GetGammaRampSize
+
+typedef Status (* PFN_XIQueryVersion)(Display*,int*,int*);
+typedef int (* PFN_XISelectEvents)(Display*,Window,XIEventMask*,int);
+#define XIQueryVersion _glfw.x11.xi.QueryVersion
+#define XISelectEvents _glfw.x11.xi.SelectEvents
+
+typedef Bool (* PFN_XRenderQueryExtension)(Display*,int*,int*);
+typedef Status (* PFN_XRenderQueryVersion)(Display*dpy,int*,int*);
+typedef XRenderPictFormat* (* PFN_XRenderFindVisualFormat)(Display*,Visual const*);
+#define XRenderQueryExtension _glfw.x11.xrender.QueryExtension
+#define XRenderQueryVersion _glfw.x11.xrender.QueryVersion
+#define XRenderFindVisualFormat _glfw.x11.xrender.FindVisualFormat
 
 typedef VkFlags VkXlibSurfaceCreateFlagsKHR;
 typedef VkFlags VkXcbSurfaceCreateFlagsKHR;
@@ -83,12 +149,17 @@ typedef VkBool32 (APIENTRY *PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR)(V
 typedef VkResult (APIENTRY *PFN_vkCreateXcbSurfaceKHR)(VkInstance,const VkXcbSurfaceCreateInfoKHR*,const VkAllocationCallbacks*,VkSurfaceKHR*);
 typedef VkBool32 (APIENTRY *PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR)(VkPhysicalDevice,uint32_t,xcb_connection_t*,xcb_visualid_t);
 
-#include "posix_tls.h"
+#include "posix_thread.h"
 #include "posix_time.h"
-#include "linux_joystick.h"
 #include "xkb_unicode.h"
 #include "glx_context.h"
 #include "egl_context.h"
+#include "osmesa_context.h"
+#if defined(__linux__)
+#include "linux_joystick.h"
+#else
+#include "null_joystick.h"
+#endif
 
 #define _glfw_dlopen(name) dlopen(name, RTLD_LAZY | RTLD_LOCAL)
 #define _glfw_dlclose(handle) dlclose(handle)
@@ -112,6 +183,11 @@ typedef struct _GLFWwindowX11
     XIC             ic;
 
     GLFWbool        overrideRedirect;
+    GLFWbool        iconified;
+    GLFWbool        maximized;
+
+    // Whether the visual supports framebuffer transparency
+    GLFWbool        transparent;
 
     // Cached position and size used to filter out duplicate events
     int             width, height;
@@ -122,8 +198,7 @@ typedef struct _GLFWwindowX11
     // The last position the cursor was warped to by GLFW
     int             warpCursorPosX, warpCursorPosY;
 
-    // The information from the last KeyPress event
+    // The time of the last KeyPress event
-    unsigned int    lastKeyCode;
     Time            lastKeyTime;
 
 } _GLFWwindowX11;
@@ -136,22 +211,28 @@ typedef struct _GLFWlibraryX11
     int             screen;
     Window          root;
 
+    // System content scale
+    float           contentScaleX, contentScaleY;
+    // Helper window for IPC
+    Window          helperWindowHandle;
     // Invisible cursor for hidden cursor mode
-    Cursor          cursor;
+    Cursor          hiddenCursorHandle;
     // Context for mapping window XIDs to _GLFWwindow pointers
     XContext        context;
     // XIM input method
     XIM             im;
     // Most recent error code received by X error handler
     int             errorCode;
+    // Primary selection string (while the primary selection is owned)
+    char*           primarySelectionString;
     // Clipboard string (while the selection is owned)
     char*           clipboardString;
     // Key name string
-    char            keyName[64];
+    char            keyName[5];
     // X11 keycode to GLFW key LUT
-    short int       publicKeys[256];
+    short int       keycodes[256];
     // GLFW key to X11 keycode LUT
-    short int       nativeKeys[GLFW_KEY_LAST + 1];
+    short int       scancodes[GLFW_KEY_LAST + 1];
     // Where to place the cursor when re-enabled
     double          restoreCursorPosX, restoreCursorPosY;
     // The window whose disabled cursor mode is active
@@ -173,8 +254,11 @@ typedef struct _GLFWlibraryX11
     Atom            NET_WM_STATE_FULLSCREEN;
     Atom            NET_WM_STATE_MAXIMIZED_VERT;
     Atom            NET_WM_STATE_MAXIMIZED_HORZ;
+    Atom            NET_WM_STATE_DEMANDS_ATTENTION;
     Atom            NET_WM_BYPASS_COMPOSITOR;
     Atom            NET_WM_FULLSCREEN_MONITORS;
+    Atom            NET_WM_WINDOW_OPACITY;
+    Atom            NET_WM_CM_Sx;
     Atom            NET_ACTIVE_WINDOW;
     Atom            NET_FRAME_EXTENTS;
     Atom            NET_REQUEST_FRAME_EXTENTS;
@@ -187,14 +271,17 @@ typedef struct _GLFWlibraryX11
     Atom            XdndStatus;
     Atom            XdndActionCopy;
     Atom            XdndDrop;
-    Atom            XdndLeave;
     Atom            XdndFinished;
     Atom            XdndSelection;
+    Atom            XdndTypeList;
+    Atom            text_uri_list;
 
     // Selection (clipboard) atoms
     Atom            TARGETS;
     Atom            MULTIPLE;
+    Atom            INCR;
     Atom            CLIPBOARD;
+    Atom            PRIMARY;
     Atom            CLIPBOARD_MANAGER;
     Atom            SAVE_TARGETS;
     Atom            NULL_;
@@ -205,12 +292,30 @@ typedef struct _GLFWlibraryX11
 
     struct {
         GLFWbool    available;
+        void*       handle;
         int         eventBase;
         int         errorBase;
         int         major;
         int         minor;
         GLFWbool    gammaBroken;
         GLFWbool    monitorBroken;
+        PFN_XRRAllocGamma AllocGamma;
+        PFN_XRRFreeCrtcInfo FreeCrtcInfo;
+        PFN_XRRFreeGamma FreeGamma;
+        PFN_XRRFreeOutputInfo FreeOutputInfo;
+        PFN_XRRFreeScreenResources FreeScreenResources;
+        PFN_XRRGetCrtcGamma GetCrtcGamma;
+        PFN_XRRGetCrtcGammaSize GetCrtcGammaSize;
+        PFN_XRRGetCrtcInfo GetCrtcInfo;
+        PFN_XRRGetOutputInfo GetOutputInfo;
+        PFN_XRRGetOutputPrimary GetOutputPrimary;
+        PFN_XRRGetScreenResourcesCurrent GetScreenResourcesCurrent;
+        PFN_XRRQueryExtension QueryExtension;
+        PFN_XRRQueryVersion QueryVersion;
+        PFN_XRRSelectInput SelectInput;
+        PFN_XRRSetCrtcConfig SetCrtcConfig;
+        PFN_XRRSetCrtcGamma SetCrtcGamma;
+        PFN_XRRUpdateConfiguration UpdateConfiguration;
     } randr;
 
     struct {
@@ -232,27 +337,67 @@ typedef struct _GLFWlibraryX11
     } saver;
 
     struct {
+        int         version;
         Window      source;
+        Atom        format;
     } xdnd;
 
+    struct {
+        void*       handle;
+        PFN_XcursorImageCreate ImageCreate;
+        PFN_XcursorImageDestroy ImageDestroy;
+        PFN_XcursorImageLoadCursor ImageLoadCursor;
+    } xcursor;
+
     struct {
         GLFWbool    available;
+        void*       handle;
         int         major;
         int         minor;
+        PFN_XineramaIsActive IsActive;
+        PFN_XineramaQueryExtension QueryExtension;
+        PFN_XineramaQueryScreens QueryScreens;
     } xinerama;
 
     struct {
         void*       handle;
-        XGETXCBCONNECTION_T XGetXCBConnection;
+        PFN_XGetXCBConnection GetXCBConnection;
     } x11xcb;
 
-#if defined(_GLFW_HAS_XF86VM)
     struct {
         GLFWbool    available;
+        void*       handle;
         int         eventBase;
         int         errorBase;
+        PFN_XF86VidModeQueryExtension QueryExtension;
+        PFN_XF86VidModeGetGammaRamp GetGammaRamp;
+        PFN_XF86VidModeSetGammaRamp SetGammaRamp;
+        PFN_XF86VidModeGetGammaRampSize GetGammaRampSize;
     } vidmode;
-#endif /*_GLFW_HAS_XF86VM*/
+
+    struct {
+        GLFWbool    available;
+        void*       handle;
+        int         majorOpcode;
+        int         eventBase;
+        int         errorBase;
+        int         major;
+        int         minor;
+        PFN_XIQueryVersion QueryVersion;
+        PFN_XISelectEvents SelectEvents;
+    } xi;
+
+    struct {
+        GLFWbool    available;
+        void*       handle;
+        int         major;
+        int         minor;
+        int         eventBase;
+        int         errorBase;
+        PFN_XRenderQueryExtension QueryExtension;
+        PFN_XRenderQueryVersion QueryVersion;
+        PFN_XRenderFindVisualFormat FindVisualFormat;
+    } xrender;
 
 } _GLFWlibraryX11;
 
@@ -279,6 +424,7 @@ typedef struct _GLFWcursorX11
 } _GLFWcursorX11;
 
 
+void _glfwPollMonitorsX11(void);
 GLFWbool _glfwSetVideoModeX11(_GLFWmonitor* monitor, const GLFWvidmode* desired);
 void _glfwRestoreVideoModeX11(_GLFWmonitor* monitor);
 
@@ -288,9 +434,11 @@ unsigned long _glfwGetWindowPropertyX11(Window window,
                                         Atom property,
                                         Atom type,
                                         unsigned char** value);
+GLFWbool _glfwIsVisualTransparentX11(Visual* visual);
 
 void _glfwGrabErrorHandlerX11(void);
 void _glfwReleaseErrorHandlerX11(void);
 void _glfwInputErrorX11(int error, const char* message);
 
-#endif // _glfw3_x11_platform_h_
+void _glfwPushSelectionToManagerX11(void);
+

raylib/external/glfw/src/xkb_unicode.c

@@ -1,8 +1,8 @@
 //========================================================================
-// GLFW 3.2 X11 - www.glfw.org
+// GLFW 3.3 X11 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-2016 Camilla Berglund <elmindreda@glfw.org>
+// Copyright (c) 2006-2016 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
@@ -826,9 +826,59 @@ static const struct codepair {
   { 0x13bd, 0x0153 },
   { 0x13be, 0x0178 },
   { 0x20ac, 0x20ac },
-  // Numeric keypad with numlock on
+  { 0xfe50,    '`' },
+  { 0xfe51, 0x00b4 },
+  { 0xfe52,    '^' },
+  { 0xfe53,    '~' },
+  { 0xfe54, 0x00af },
+  { 0xfe55, 0x02d8 },
+  { 0xfe56, 0x02d9 },
+  { 0xfe57, 0x00a8 },
+  { 0xfe58, 0x02da },
+  { 0xfe59, 0x02dd },
+  { 0xfe5a, 0x02c7 },
+  { 0xfe5b, 0x00b8 },
+  { 0xfe5c, 0x02db },
+  { 0xfe5d, 0x037a },
+  { 0xfe5e, 0x309b },
+  { 0xfe5f, 0x309c },
+  { 0xfe63,    '/' },
+  { 0xfe64, 0x02bc },
+  { 0xfe65, 0x02bd },
+  { 0xfe66, 0x02f5 },
+  { 0xfe67, 0x02f3 },
+  { 0xfe68, 0x02cd },
+  { 0xfe69, 0xa788 },
+  { 0xfe6a, 0x02f7 },
+  { 0xfe6e,    ',' },
+  { 0xfe6f, 0x00a4 },
+  { 0xfe80,    'a' }, // XK_dead_a
+  { 0xfe81,    'A' }, // XK_dead_A
+  { 0xfe82,    'e' }, // XK_dead_e
+  { 0xfe83,    'E' }, // XK_dead_E
+  { 0xfe84,    'i' }, // XK_dead_i
+  { 0xfe85,    'I' }, // XK_dead_I
+  { 0xfe86,    'o' }, // XK_dead_o
+  { 0xfe87,    'O' }, // XK_dead_O
+  { 0xfe88,    'u' }, // XK_dead_u
+  { 0xfe89,    'U' }, // XK_dead_U
+  { 0xfe8a, 0x0259 },
+  { 0xfe8b, 0x018f },
+  { 0xfe8c, 0x00b5 },
+  { 0xfe90,    '_' },
+  { 0xfe91, 0x02c8 },
+  { 0xfe92, 0x02cc },
   { 0xff80 /*XKB_KEY_KP_Space*/,     ' ' },
-  { 0xffbd /*XKB_KEY_KP_Equal*/,     '=' },
+  { 0xff95 /*XKB_KEY_KP_7*/, 0x0037 },
+  { 0xff96 /*XKB_KEY_KP_4*/, 0x0034 },
+  { 0xff97 /*XKB_KEY_KP_8*/, 0x0038 },
+  { 0xff98 /*XKB_KEY_KP_6*/, 0x0036 },
+  { 0xff99 /*XKB_KEY_KP_2*/, 0x0032 },
+  { 0xff9a /*XKB_KEY_KP_9*/, 0x0039 },
+  { 0xff9b /*XKB_KEY_KP_3*/, 0x0033 },
+  { 0xff9c /*XKB_KEY_KP_1*/, 0x0031 },
+  { 0xff9d /*XKB_KEY_KP_5*/, 0x0035 },
+  { 0xff9e /*XKB_KEY_KP_0*/, 0x0030 },
   { 0xffaa /*XKB_KEY_KP_Multiply*/,  '*' },
   { 0xffab /*XKB_KEY_KP_Add*/,       '+' },
   { 0xffac /*XKB_KEY_KP_Separator*/, ',' },
@@ -844,7 +894,8 @@ static const struct codepair {
   { 0xffb6 /*XKB_KEY_KP_6*/, 0x0036 },
   { 0xffb7 /*XKB_KEY_KP_7*/, 0x0037 },
   { 0xffb8 /*XKB_KEY_KP_8*/, 0x0038 },
-  { 0xffb9 /*XKB_KEY_KP_9*/, 0x0039 }
+  { 0xffb9 /*XKB_KEY_KP_9*/, 0x0039 },
+  { 0xffbd /*XKB_KEY_KP_Equal*/,     '=' }
 };
 
 

raylib/external/glfw/src/xkb_unicode.h

@@ -1,5 +1,5 @@
 //========================================================================
-// GLFW 3.2 Linux - www.glfw.org
+// GLFW 3.3 Linux - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2014 Jonas Ådahl <jadahl@gmail.com>
 //
@@ -24,10 +24,5 @@
 //
 //========================================================================
 
-#ifndef _glfw3_xkb_unicode_h_
-#define _glfw3_xkb_unicode_h_
-
-
 long _glfwKeySym2Unicode(unsigned int keysym);
 
-#endif // _glfw3_xkb_unicode_h_