Fix documentation for timer thread safety

Related to #766.

.appveyor.yml

@@ -0,0 +1,22 @@
+branches:
+    only:
+        - ci
+        - master
+skip_tags: true
+environment:
+    matrix:
+        - BUILD_SHARED_LIBS: ON
+        - BUILD_SHARED_LIBS: OFF
+matrix:
+    fast_finish: true
+build_script:
+    - mkdir build
+    - cd build
+    - cmake -DBUILD_SHARED_LIBS=%BUILD_SHARED_LIBS% ..
+    - cmake --build .
+notifications:
+    - provider: Email
+      to:
+        - ci@glfw.org
+    - on_build_failure: true
+    - on_build_success: false

.github/CONTRIBUTING.md

@@ -0,0 +1,106 @@
+# Contribution Guide
+
+This file is a work in progress and you can report errors or submit patches for
+it the same as any other file.
+
+
+## Reporting a bug
+
+If GLFW is behaving unexpectedly, make sure you have set an error callback.
+GLFW will often tell you the cause of an issue via this callback.
+
+If GLFW is crashing or triggering asserts, make sure that all your object
+handles and other pointers are valid.
+
+Always include the __operating system name and version__ (i.e. `Windows
+7 64-bit` or `Ubuntu 15.10`).  If you are using an official release of GLFW,
+include the __GLFW release version__ (i.e. `3.1.2`), otherwise include the
+__GLFW commit ID__ (i.e.  `3795d78b14ef06008889cc422a1fb8d642597751`) from Git.
+If possible, please also include the __GLFW version string__ (`3.2.0 X11 EGL
+clock_gettime /dev/js XI Xf86vm`), as described
+[here](http://www.glfw.org/docs/latest/intro.html#intro_version_string).
+
+
+### Reporting a compile or link bug
+
+__Note:__ GLFW needs many system APIs to do its job.  See the [Building
+applications](http://www.glfw.org/docs/latest/build.html) guide for more
+information.
+
+In addition to the information above, always include the complete build log from
+your compiler and linker.  Issue posts are editable so it can always be
+shortened later.
+
+
+### Reporting a context creation bug
+
+__Note:__ Windows ships with graphics drivers that do not support OpenGL.  If
+GLFW says that your machine lacks support for OpenGL, it very likely does.
+Install drivers from the computer manufacturer or graphics card manufacturer
+([Nvidia](http://www.geforce.com/drivers),
+ [AMD](http://support.amd.com/en-us/download),
+ [Intel](https://www-ssl.intel.com/content/www/us/en/support/detect.html)) to
+fix this.
+
+__Note:__ AMD only supports OpenGL ES on Windows via EGL.  EGL support is not
+enabled in GLFW by default.  You need to [enable EGL when
+compiling](http://www.glfw.org/docs/latest/compile.html) GLFW to use this.
+
+The `glfwinfo` tool is included in the GLFW source tree as `tests/glfwinfo.c`
+and is built along with the library.  It lets you request any kind of context
+and framebuffer format supported by the GLFW API without having to recompile.
+If context creation fails in your application, please verify that it also fails
+with this tool before reporting it as a bug.
+
+In addition to the information above (OS and GLFW version), always include the
+__GPU model and driver version__ (i.e. `GeForce GTX660 with 352.79`) when
+reporting this kind of bug.
+
+
+### Reporting a monitor or video mode bug
+
+__Note:__ On headless systems on some platforms, no monitors are reported.  This
+causes glfwGetPrimaryMonitor to return `NULL`, which not all applications are
+prepared for.
+
+__Note:__ Some third-party tools report more video modes than those approved of
+by the OS.  For safety and compatbility, GLFW only reports video modes the OS
+wants programs to use.  This is not a bug.
+
+The `monitors` tool is included in the GLFW source tree as `tests/monitors.c`
+and is built along with the library.  lists all information about connected
+monitors made available by GLFW.
+
+In addition to the information above (OS and GLFW version), please also include
+the output of the `monitors` tool when reporting this kind of bug.  If it
+doesn't work at all, please mention this.
+
+
+### Reporting a window event bug
+
+__Note:__ While GLFW tries to provide the exact same behavior between platforms,
+the exact ordering of related window events will sometimes differ.
+
+The `events` tool is included in the GLFW source tree as `tests/events.c` and is
+built along with the library.  It prints all information provided to every
+callback supported by GLFW as events occur.  Each event is listed with the time
+and a unique number to make discussions about event logs easier.  The tool has
+command-line options for creating multiple windows and full screen windows.
+
+
+### Reporting a documentation bug
+
+If you found the error in the generated documentation then it's fine to just
+link to that webpage.  You don't need to figure out which documentation source
+file the text comes from.
+
+
+## Contributing a bug fix
+
+There should be text here, but there isn't.
+
+
+## Contributing a feature
+
+This is not (yet) the text you are looking for.
+

.gitignore

@@ -13,11 +13,13 @@ Debug
 Release
 MinSizeRel
 RelWithDebInfo
+*.xcodeproj
 
 # CMake files
 Makefile
 CMakeCache.txt
 CMakeFiles
+CMakeScripts
 cmake_install.cmake
 cmake_uninstall.cmake
 
@@ -30,20 +32,24 @@ src/glfw_config.h
 src/glfw3.pc
 src/glfw3Config.cmake
 src/glfw3ConfigVersion.cmake
+src/wayland-pointer-constraints-unstable-v1-client-protocol.h
+src/wayland-pointer-constraints-unstable-v1-protocol.c
+src/wayland-relative-pointer-unstable-v1-client-protocol.h
+src/wayland-relative-pointer-unstable-v1-protocol.c
 
 # Compiled binaries
 src/libglfw.so
 src/libglfw.so.3
-src/libglfw.so.3.0
+src/libglfw.so.3.2
 src/libglfw.dylib
 src/libglfw.dylib
 src/libglfw.3.dylib
-src/libglfw.3.0.dylib
+src/libglfw.3.2.dylib
 src/libglfw3.a
 src/glfw3.lib
 src/glfw3.dll
 src/glfw3dll.lib
-src/glfw3dll.a
+src/libglfw3dll.a
 examples/*.app
 examples/*.exe
 examples/boing
@@ -71,5 +77,6 @@ tests/tearing
 tests/threads
 tests/title
 tests/version
+tests/vulkan
 tests/windows
 

.travis.yml

@@ -0,0 +1,30 @@
+language: c
+compiler: clang
+branches:
+    only:
+        - ci
+        - master
+os:
+    - linux
+    - osx
+sudo: false
+addons:
+    apt:
+        sources:
+            - kubuntu-backports
+        packages:
+            - cmake
+env:
+    - BUILD_SHARED_LIBS=ON
+    - BUILD_SHARED_LIBS=OFF
+script:
+    - mkdir build
+    - cd build
+    - cmake -DBUILD_SHARED_LIBS=${BUILD_SHARED_LIBS} ..
+    - cmake --build .
+notifications:
+    email:
+        recipients:
+            - ci@glfw.org
+    on_success: never
+    on_failure: always

CMake/modules/FindEGL.cmake

@@ -1,16 +0,0 @@
-# Find EGL
-#
-# EGL_INCLUDE_DIR
-# EGL_LIBRARY
-# EGL_FOUND
-
-find_path(EGL_INCLUDE_DIR NAMES EGL/egl.h PATHS /opt/vc/include)
-
-set(EGL_NAMES ${EGL_NAMES} egl EGL libEGL)
-find_library(EGL_LIBRARY NAMES ${EGL_NAMES} PATHS /opt/vc/lib)
-
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(EGL DEFAULT_MSG EGL_LIBRARY EGL_INCLUDE_DIR)
-
-mark_as_advanced(EGL_INCLUDE_DIR EGL_LIBRARY)
-

CMake/modules/FindGLESv1.cmake

@@ -1,16 +0,0 @@
-# Find GLESv1
-#
-# GLESv1_INCLUDE_DIR
-# GLESv1_LIBRARY
-# GLESv1_FOUND
-
-find_path(GLESv1_INCLUDE_DIR NAMES GLES/gl.h PATHS /opt/vc/include)
-
-set(GLESv1_NAMES ${GLESv1_NAMES} GLESv1_CM libGLES_CM)
-find_library(GLESv1_LIBRARY NAMES ${GLESv1_NAMES} PATHS /opt/vc/lib)
-
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(GLESv1 DEFAULT_MSG GLESv1_LIBRARY GLESv1_INCLUDE_DIR)
-
-mark_as_advanced(GLESv1_INCLUDE_DIR GLESv1_LIBRARY)
-

CMake/modules/FindGLESv2.cmake

@@ -1,16 +0,0 @@
-# Find GLESv2
-#
-# GLESv2_INCLUDE_DIR
-# GLESv2_LIBRARY
-# GLESv2_FOUND
-
-find_path(GLESv2_INCLUDE_DIR NAMES GLES2/gl2.h PATHS /opt/vc/include)
-
-set(GLESv2_NAMES ${GLESv2_NAMES} GLESv2 libGLESv2)
-find_library(GLESv2_LIBRARY NAMES ${GLESv2_NAMES} PATHS /opt/vc/lib)
-
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(GLESv2 DEFAULT_MSG GLESv2_LIBRARY GLESv2_INCLUDE_DIR)
-
-mark_as_advanced(GLESv2_INCLUDE_DIR GLESv2_LIBRARY)
-

CMake/modules/FindVulkan.cmake

@@ -0,0 +1,31 @@
+# Find Vulkan
+#
+# VULKAN_INCLUDE_DIR
+# VULKAN_LIBRARY
+# VULKAN_FOUND
+
+if (WIN32)
+    find_path(VULKAN_INCLUDE_DIR NAMES vulkan/vulkan.h HINTS
+        "$ENV{VULKAN_SDK}/Include"
+        "$ENV{VK_SDK_PATH}/Include")
+    if (CMAKE_CL_64)
+        find_library(VULKAN_LIBRARY NAMES vulkan-1 HINTS
+            "$ENV{VULKAN_SDK}/Bin"
+            "$ENV{VK_SDK_PATH}/Bin")
+    else()
+        find_library(VULKAN_LIBRARY NAMES vulkan-1 HINTS
+            "$ENV{VULKAN_SDK}/Bin32"
+            "$ENV{VK_SDK_PATH}/Bin32")
+    endif()
+else()
+    find_path(VULKAN_INCLUDE_DIR NAMES vulkan/vulkan.h HINTS
+        "$ENV{VULKAN_SDK}/include")
+    find_library(VULKAN_LIBRARY NAMES vulkan HINTS
+        "$ENV{VULKAN_SDK}/lib")
+endif()
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(Vulkan DEFAULT_MSG VULKAN_LIBRARY VULKAN_INCLUDE_DIR)
+
+mark_as_advanced(VULKAN_INCLUDE_DIR VULKAN_LIBRARY)
+

CMake/modules/FindWayland.cmake

@@ -1,66 +0,0 @@
-# Try to find Wayland on a Unix system
-#
-# This will define:
-#
-#   WAYLAND_FOUND       - True if Wayland is found
-#   WAYLAND_LIBRARIES   - Link these to use Wayland
-#   WAYLAND_INCLUDE_DIR - Include directory for Wayland
-#   WAYLAND_DEFINITIONS - Compiler flags for using Wayland
-#
-# In addition the following more fine grained variables will be defined:
-#
-#   WAYLAND_CLIENT_FOUND  WAYLAND_CLIENT_INCLUDE_DIR  WAYLAND_CLIENT_LIBRARIES
-#   WAYLAND_SERVER_FOUND  WAYLAND_SERVER_INCLUDE_DIR  WAYLAND_SERVER_LIBRARIES
-#   WAYLAND_EGL_FOUND     WAYLAND_EGL_INCLUDE_DIR     WAYLAND_EGL_LIBRARIES
-#
-# Copyright (c) 2013 Martin Gräßlin <mgraesslin@kde.org>
-#
-# Redistribution and use is allowed according to the terms of the BSD license.
-# For details see the accompanying COPYING-CMAKE-SCRIPTS file.
-
-IF (NOT WIN32)
-  IF (WAYLAND_INCLUDE_DIR AND WAYLAND_LIBRARIES)
-    # In the cache already
-    SET(WAYLAND_FIND_QUIETLY TRUE)
-  ENDIF ()
-
-  # Use pkg-config to get the directories and then use these values
-  # in the FIND_PATH() and FIND_LIBRARY() calls
-  FIND_PACKAGE(PkgConfig)
-  PKG_CHECK_MODULES(PKG_WAYLAND QUIET wayland-client wayland-server wayland-egl wayland-cursor)
-
-  SET(WAYLAND_DEFINITIONS ${PKG_WAYLAND_CFLAGS})
-
-  FIND_PATH(WAYLAND_CLIENT_INCLUDE_DIR  NAMES wayland-client.h HINTS ${PKG_WAYLAND_INCLUDE_DIRS})
-  FIND_PATH(WAYLAND_SERVER_INCLUDE_DIR  NAMES wayland-server.h HINTS ${PKG_WAYLAND_INCLUDE_DIRS})
-  FIND_PATH(WAYLAND_EGL_INCLUDE_DIR     NAMES wayland-egl.h    HINTS ${PKG_WAYLAND_INCLUDE_DIRS})
-  FIND_PATH(WAYLAND_CURSOR_INCLUDE_DIR  NAMES wayland-cursor.h HINTS ${PKG_WAYLAND_INCLUDE_DIRS})
-
-  FIND_LIBRARY(WAYLAND_CLIENT_LIBRARIES NAMES wayland-client   HINTS ${PKG_WAYLAND_LIBRARY_DIRS})
-  FIND_LIBRARY(WAYLAND_SERVER_LIBRARIES NAMES wayland-server   HINTS ${PKG_WAYLAND_LIBRARY_DIRS})
-  FIND_LIBRARY(WAYLAND_EGL_LIBRARIES    NAMES wayland-egl      HINTS ${PKG_WAYLAND_LIBRARY_DIRS})
-  FIND_LIBRARY(WAYLAND_CURSOR_LIBRARIES NAMES wayland-cursor   HINTS ${PKG_WAYLAND_LIBRARY_DIRS})
-
-  set(WAYLAND_INCLUDE_DIR ${WAYLAND_CLIENT_INCLUDE_DIR} ${WAYLAND_SERVER_INCLUDE_DIR} ${WAYLAND_EGL_INCLUDE_DIR} ${WAYLAND_CURSOR_INCLUDE_DIR})
-
-  set(WAYLAND_LIBRARIES ${WAYLAND_CLIENT_LIBRARIES} ${WAYLAND_SERVER_LIBRARIES} ${WAYLAND_EGL_LIBRARIES} ${WAYLAND_CURSOR_LIBRARIES})
-
-  list(REMOVE_DUPLICATES WAYLAND_INCLUDE_DIR)
-
-  include(FindPackageHandleStandardArgs)
-
-  FIND_PACKAGE_HANDLE_STANDARD_ARGS(WAYLAND_CLIENT  DEFAULT_MSG  WAYLAND_CLIENT_LIBRARIES  WAYLAND_CLIENT_INCLUDE_DIR)
-  FIND_PACKAGE_HANDLE_STANDARD_ARGS(WAYLAND_SERVER  DEFAULT_MSG  WAYLAND_SERVER_LIBRARIES  WAYLAND_SERVER_INCLUDE_DIR)
-  FIND_PACKAGE_HANDLE_STANDARD_ARGS(WAYLAND_EGL     DEFAULT_MSG  WAYLAND_EGL_LIBRARIES     WAYLAND_EGL_INCLUDE_DIR)
-  FIND_PACKAGE_HANDLE_STANDARD_ARGS(WAYLAND_CURSOR  DEFAULT_MSG  WAYLAND_CURSOR_LIBRARIES  WAYLAND_CURSOR_INCLUDE_DIR)
-  FIND_PACKAGE_HANDLE_STANDARD_ARGS(WAYLAND         DEFAULT_MSG  WAYLAND_LIBRARIES         WAYLAND_INCLUDE_DIR)
-
-  MARK_AS_ADVANCED(
-        WAYLAND_INCLUDE_DIR         WAYLAND_LIBRARIES
-        WAYLAND_CLIENT_INCLUDE_DIR  WAYLAND_CLIENT_LIBRARIES
-        WAYLAND_SERVER_INCLUDE_DIR  WAYLAND_SERVER_LIBRARIES
-        WAYLAND_EGL_INCLUDE_DIR     WAYLAND_EGL_LIBRARIES
-        WAYLAND_CURSOR_INCLUDE_DIR  WAYLAND_CURSOR_LIBRARIES
-  )
-
-ENDIF ()

CMake/modules/FindWaylandProtocols.cmake

@@ -0,0 +1,26 @@
+find_package(PkgConfig)
+
+pkg_check_modules(WaylandProtocols QUIET wayland-protocols>=${WaylandProtocols_FIND_VERSION})
+
+execute_process(COMMAND ${PKG_CONFIG_EXECUTABLE} --variable=pkgdatadir wayland-protocols
+                OUTPUT_VARIABLE WaylandProtocols_PKGDATADIR
+                RESULT_VARIABLE _pkgconfig_failed)
+if (_pkgconfig_failed)
+    message(FATAL_ERROR "Missing wayland-protocols pkgdatadir")
+endif()
+
+string(REGEX REPLACE "[\r\n]" "" WaylandProtocols_PKGDATADIR "${WaylandProtocols_PKGDATADIR}")
+
+find_package_handle_standard_args(WaylandProtocols
+    FOUND_VAR
+        WaylandProtocols_FOUND
+    REQUIRED_VARS
+        WaylandProtocols_PKGDATADIR
+    VERSION_VAR
+        WaylandProtocols_VERSION
+    HANDLE_COMPONENTS
+)
+
+set(WAYLAND_PROTOCOLS_FOUND ${WaylandProtocols_FOUND})
+set(WAYLAND_PROTOCOLS_PKGDATADIR ${WaylandProtocols_PKGDATADIR})
+set(WAYLAND_PROTOCOLS_VERSION ${WaylandProtocols_VERSION})

CMakeLists.txt

@@ -1,3 +1,5 @@
+set(CMAKE_LEGACY_CYGWIN_WIN32 OFF)
+
 project(GLFW C)
 
 cmake_minimum_required(VERSION 2.8.12)
@@ -9,8 +11,8 @@ if (NOT CMAKE_VERSION VERSION_LESS "3.0")
 endif()
 
 set(GLFW_VERSION_MAJOR "3")
-set(GLFW_VERSION_MINOR "1")
-set(GLFW_VERSION_PATCH "2")
+set(GLFW_VERSION_MINOR "2")
+set(GLFW_VERSION_PATCH "0")
 set(GLFW_VERSION_EXTRA "")
 set(GLFW_VERSION "${GLFW_VERSION_MAJOR}.${GLFW_VERSION_MINOR}")
 set(GLFW_VERSION_FULL "${GLFW_VERSION}.${GLFW_VERSION_PATCH}${GLFW_VERSION_EXTRA}")
@@ -30,17 +32,14 @@ if (WIN32)
 endif()
 
 if (APPLE)
-    option(GLFW_BUILD_UNIVERSAL "Build GLFW as a Universal Binary" OFF)
     option(GLFW_USE_CHDIR "Make glfwInit chdir to Contents/Resources" ON)
     option(GLFW_USE_MENUBAR "Populate the menu bar on first window creation" ON)
     option(GLFW_USE_RETINA "Use the full resolution of Retina displays" ON)
-else()
-    option(GLFW_USE_EGL "Use EGL for context creation" OFF)
 endif()
 
 if (UNIX AND NOT APPLE)
-    option(GLFW_USE_WAYLAND "Use Wayland for context creation (implies EGL as well)" OFF)
-    option(GLFW_USE_MIR     "Use Mir for context creation (implies EGL as well)" OFF)
+    option(GLFW_USE_WAYLAND "Use Wayland for window creation" OFF)
+    option(GLFW_USE_MIR     "Use Mir for window creation" OFF)
 endif()
 
 if (MSVC)
@@ -51,78 +50,33 @@ if (BUILD_SHARED_LIBS)
     set(_GLFW_BUILD_DLL 1)
 endif()
 
-if (GLFW_USE_WAYLAND)
-    set(GLFW_USE_EGL ON)
-elseif (GLFW_USE_MIR)
-    set(GLFW_USE_EGL ON)
+if (BUILD_SHARED_LIBS AND UNIX)
+    # On Unix-like systems, shared libraries can use the soname system.
+    set(GLFW_LIB_NAME glfw)
+else()
+    set(GLFW_LIB_NAME glfw3)
 endif()
 
 set(CMAKE_MODULE_PATH "${GLFW_SOURCE_DIR}/CMake/modules")
 
-if (GLFW_USE_EGL)
-    set(GLFW_CLIENT_LIBRARY "opengl" CACHE STRING
-        "The client library to use; one of opengl, glesv1 or glesv2")
-
-    if (${GLFW_CLIENT_LIBRARY} STREQUAL "opengl")
-        set(_GLFW_USE_OPENGL 1)
-    elseif (${GLFW_CLIENT_LIBRARY} STREQUAL "glesv1")
-        set(_GLFW_USE_GLESV1 1)
-    elseif (${GLFW_CLIENT_LIBRARY} STREQUAL "glesv2")
-        set(_GLFW_USE_GLESV2 1)
-    else()
-        message(FATAL_ERROR "Unsupported client library")
-    endif()
-
-    find_package(EGL REQUIRED)
-
-    if (NOT _GLFW_USE_OPENGL)
-        set(GLFW_BUILD_EXAMPLES OFF)
-        set(GLFW_BUILD_TESTS OFF)
-        message(STATUS "NOTE: Examples and tests require OpenGL")
-    endif()
-else()
-    set(_GLFW_USE_OPENGL 1)
-endif()
-
-if (_GLFW_USE_OPENGL)
-    find_package(OpenGL REQUIRED)
-elseif (_GLFW_USE_GLESV1)
-    find_package(GLESv1 REQUIRED)
-elseif (_GLFW_USE_GLESV2)
-    find_package(GLESv2 REQUIRED)
-endif()
-
 find_package(Threads REQUIRED)
+find_package(Vulkan)
 
 if (GLFW_BUILD_DOCS)
     set(DOXYGEN_SKIP_DOT TRUE)
     find_package(Doxygen)
-
-    if (GLFW_DOCUMENT_INTERNALS)
-        set(GLFW_INTERNAL_DOCS "${GLFW_SOURCE_DIR}/src/internal.h ${GLFW_SOURCE_DIR}/docs/internal.dox")
-    endif()
 endif()
 
 #--------------------------------------------------------------------
 # Set compiler specific flags
 #--------------------------------------------------------------------
-if (UNIX)
-    add_definitions(-Wall)
-
-    if (BUILD_SHARED_LIBS)
-        add_definitions(-fvisibility=hidden)
-    endif()
-endif()
-
 if (MSVC)
-    add_definitions(-D_CRT_SECURE_NO_WARNINGS)
-
     if (NOT USE_MSVC_RUNTIME_LIBRARY_DLL)
         foreach (flag CMAKE_C_FLAGS
-                        CMAKE_C_FLAGS_DEBUG
-                        CMAKE_C_FLAGS_RELEASE
-                        CMAKE_C_FLAGS_MINSIZEREL
-                        CMAKE_C_FLAGS_RELWITHDEBINFO)
+                      CMAKE_C_FLAGS_DEBUG
+                      CMAKE_C_FLAGS_RELEASE
+                      CMAKE_C_FLAGS_MINSIZEREL
+                      CMAKE_C_FLAGS_RELWITHDEBINFO)
 
             if (${flag} MATCHES "/MD")
                 string(REGEX REPLACE "/MD" "/MT" ${flag} "${${flag}}")
@@ -136,6 +90,15 @@ if (MSVC)
 endif()
 
 if (MINGW)
+    # Workaround for legacy MinGW not providing XInput and DirectInput
+    include(CheckIncludeFile)
+
+    check_include_file(dinput.h DINPUT_H_FOUND)
+    check_include_file(xinput.h XINPUT_H_FOUND)
+    if (NOT DINPUT_H_FOUND OR NOT XINPUT_H_FOUND)
+        list(APPEND glfw_INCLUDE_DIRS "${GLFW_SOURCE_DIR}/deps/mingw")
+    endif()
+
     # Enable link-time exploit mitigation features enabled by default on MSVC
     include(CheckCCompilerFlag)
 
@@ -159,12 +122,6 @@ if (MINGW)
     if (_GLFW_HAS_64ASLR)
         set(CMAKE_SHARED_LINKER_FLAGS "-Wl,--high-entropy-va ${CMAKE_SHARED_LINKER_FLAGS}")
     endif()
-
-    # HACK: When building on MinGW, WINVER and UNICODE need to be defined before
-    # the inclusion of stddef.h (by glfw3.h), which is itself included before
-    # win32_platform.h.  We define them here until a saner solution can be found
-    # NOTE: MinGW-w64 and Visual C++ do /not/ need this hack.
-    add_definitions(-DUNICODE -DWINVER=0x0501)
 endif()
 
 #--------------------------------------------------------------------
@@ -173,19 +130,9 @@ endif()
 if (WIN32)
     set(_GLFW_WIN32 1)
     message(STATUS "Using Win32 for window creation")
-
-    if (GLFW_USE_EGL)
-        set(_GLFW_EGL 1)
-        message(STATUS "Using EGL for context creation")
-    else()
-        set(_GLFW_WGL 1)
-        message(STATUS "Using WGL for context creation")
-    endif()
 elseif (APPLE)
     set(_GLFW_COCOA 1)
     message(STATUS "Using Cocoa for window creation")
-    set(_GLFW_NSGL 1)
-    message(STATUS "Using NSGL for context creation")
 elseif (UNIX)
     if (GLFW_USE_WAYLAND)
         set(_GLFW_WAYLAND 1)
@@ -197,14 +144,6 @@ elseif (UNIX)
         set(_GLFW_X11 1)
         message(STATUS "Using X11 for window creation")
     endif()
-
-    if (GLFW_USE_EGL)
-        set(_GLFW_EGL 1)
-        message(STATUS "Using EGL for context creation")
-    else()
-        set(_GLFW_GLX 1)
-        message(STATUS "Using GLX for context creation")
-    endif()
 else()
     message(FATAL_ERROR "No supported platform was detected")
 endif()
@@ -226,6 +165,11 @@ if (UNIX AND NOT APPLE)
         list(APPEND glfw_LIBRARIES "${MATH_LIBRARY}")
         list(APPEND glfw_PKG_LIBS "-lm")
     endif()
+
+    if (CMAKE_DL_LIBS)
+        list(APPEND glfw_LIBRARIES "${CMAKE_DL_LIBS}")
+        list(APPEND glfw_PKG_LIBS "-l${CMAKE_DL_LIBS}")
+    endif()
 endif()
 
 #--------------------------------------------------------------------
@@ -240,17 +184,6 @@ if (_GLFW_WIN32)
     endif()
 endif()
 
-#--------------------------------------------------------------------
-# Use WGL for context creation
-#--------------------------------------------------------------------
-if (_GLFW_WGL)
-
-    list(APPEND glfw_PKG_LIBS "-lopengl32")
-
-    list(APPEND glfw_INCLUDE_DIRS "${OPENGL_INCLUDE_DIR}")
-    list(APPEND glfw_LIBRARIES "${OPENGL_gl_LIBRARY}")
-endif()
-
 #--------------------------------------------------------------------
 # Use X11 for window creation
 #--------------------------------------------------------------------
@@ -282,21 +215,6 @@ if (_GLFW_X11)
     list(APPEND glfw_LIBRARIES "${X11_Xinerama_LIB}")
     list(APPEND glfw_PKG_DEPS "xinerama")
 
-    # Check for XInput (high-resolution cursor motion)
-    if (X11_Xinput_FOUND)
-        list(APPEND glfw_INCLUDE_DIRS "${X11_Xinput_INCLUDE_PATH}")
-        list(APPEND glfw_PKG_DEPS "xi")
-
-        if (X11_Xinput_LIB)
-            list(APPEND glfw_LIBRARIES "${X11_Xinput_LIB}")
-        else()
-            # Backwards compatibility (bug in CMake 2.8.7)
-            list(APPEND glfw_LIBRARIES Xi)
-        endif()
-
-        set(_GLFW_HAS_XINPUT TRUE)
-    endif()
-
     # Check for Xf86VidMode (fallback gamma control)
     if (X11_xf86vmode_FOUND)
         list(APPEND glfw_INCLUDE_DIRS "${X11_xf86vmode_INCLUDE_PATH}")
@@ -334,11 +252,17 @@ endif()
 # Use Wayland for window creation
 #--------------------------------------------------------------------
 if (_GLFW_WAYLAND)
+    find_package(ECM REQUIRED NO_MODULE)
+    set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${ECM_MODULE_PATH})
+
     find_package(Wayland REQUIRED)
+    find_package(WaylandScanner REQUIRED)
+    find_package(WaylandProtocols 1.1 REQUIRED)
+
     list(APPEND glfw_PKG_DEPS "wayland-egl")
 
-    list(APPEND glfw_INCLUDE_DIRS "${WAYLAND_INCLUDE_DIR}")
-    list(APPEND glfw_LIBRARIES "${WAYLAND_LIBRARIES}" "${CMAKE_THREAD_LIBS_INIT}")
+    list(APPEND glfw_INCLUDE_DIRS "${Wayland_INCLUDE_DIR}")
+    list(APPEND glfw_LIBRARIES "${Wayland_LIBRARIES}" "${CMAKE_THREAD_LIBS_INIT}")
 
     find_package(XKBCommon REQUIRED)
     list(APPEND glfw_PKG_DEPS "xkbcommon")
@@ -362,57 +286,10 @@ if (_GLFW_MIR)
     list(APPEND glfw_LIBRARIES "${XKBCOMMON_LIBRARY}")
 endif()
 
-#--------------------------------------------------------------------
-# Use GLX for context creation
-#--------------------------------------------------------------------
-if (_GLFW_GLX)
-
-    list(APPEND glfw_INCLUDE_DIRS "${OPENGL_INCLUDE_DIR}")
-    list(APPEND glfw_LIBRARIES "${OPENGL_gl_LIBRARY}")
-
-    list(APPEND glfw_PKG_DEPS "gl")
-
-    if (CMAKE_DL_LIBS)
-        list(APPEND glfw_LIBRARIES "${CMAKE_DL_LIBS}")
-        list(APPEND glfw_PKG_LIBS "-l${CMAKE_DL_LIBS}")
-    endif()
-endif()
-
-#--------------------------------------------------------------------
-# Use EGL for context creation
-#--------------------------------------------------------------------
-if (_GLFW_EGL)
-
-    list(APPEND glfw_INCLUDE_DIRS "${EGL_INCLUDE_DIR}")
-    list(APPEND glfw_LIBRARIES "${EGL_LIBRARY}")
-
-    list(APPEND glfw_PKG_DEPS "egl")
-
-    if (_GLFW_USE_OPENGL)
-        list(APPEND glfw_LIBRARIES "${OPENGL_gl_LIBRARY}")
-        list(APPEND glfw_INCLUDE_DIRS "${OPENGL_INCLUDE_DIR}")
-        list(APPEND glfw_PKG_DEPS "gl")
-    elseif (_GLFW_USE_GLESV1)
-        list(APPEND glfw_LIBRARIES "${GLESv1_LIBRARY}")
-        list(APPEND glfw_INCLUDE_DIRS "${GLESv1_INCLUDE_DIR}")
-        list(APPEND glfw_PKG_DEPS "glesv1_cm")
-    elseif (_GLFW_USE_GLESV2)
-        list(APPEND glfw_LIBRARIES "${GLESv2_LIBRARY}")
-        list(APPEND glfw_INCLUDE_DIRS "${GLESv2_INCLUDE_DIR}")
-        list(APPEND glfw_PKG_DEPS "glesv2")
-    endif()
-
-    if (CMAKE_DL_LIBS)
-        list(APPEND glfw_LIBRARIES "${CMAKE_DL_LIBS}")
-        list(APPEND glfw_PKG_LIBS "-l${CMAKE_DL_LIBS}")
-    endif()
-
-endif()
-
 #--------------------------------------------------------------------
 # Use Cocoa for window creation and NSOpenGL for context creation
 #--------------------------------------------------------------------
-if (_GLFW_COCOA AND _GLFW_NSGL)
+if (_GLFW_COCOA)
 
     if (GLFW_USE_MENUBAR)
         set(_GLFW_USE_MENUBAR 1)
@@ -426,13 +303,6 @@ if (_GLFW_COCOA AND _GLFW_NSGL)
         set(_GLFW_USE_RETINA 1)
     endif()
 
-    if (GLFW_BUILD_UNIVERSAL)
-        message(STATUS "Building GLFW as Universal Binaries")
-        set(CMAKE_OSX_ARCHITECTURES i386;x86_64)
-    else()
-        message(STATUS "Building GLFW only for the native architecture")
-    endif()
-
     # Set up library and include paths
     find_library(COCOA_FRAMEWORK Cocoa)
     find_library(IOKIT_FRAMEWORK IOKit)
@@ -443,19 +313,17 @@ if (_GLFW_COCOA AND _GLFW_NSGL)
                      CORE_FOUNDATION_FRAMEWORK
                      CORE_VIDEO_FRAMEWORK)
     list(APPEND glfw_LIBRARIES "${COCOA_FRAMEWORK}"
-                               "${OPENGL_gl_LIBRARY}"
                                "${IOKIT_FRAMEWORK}"
                                "${CORE_FOUNDATION_FRAMEWORK}"
                                "${CORE_VIDEO_FRAMEWORK}")
 
     set(glfw_PKG_DEPS "")
-    set(glfw_PKG_LIBS "-framework Cocoa -framework OpenGL -framework IOKit -framework CoreFoundation -framework CoreVideo")
+    set(glfw_PKG_LIBS "-framework Cocoa -framework IOKit -framework CoreFoundation -framework CoreVideo")
 endif()
 
 #--------------------------------------------------------------------
 # Export GLFW library dependencies
 #--------------------------------------------------------------------
-set(GLFW_LIBRARIES ${glfw_LIBRARIES} CACHE STRING "Dependencies of GLFW")
 foreach(arg ${glfw_PKG_DEPS})
     set(GLFW_PKG_DEPS "${GLFW_PKG_DEPS} ${arg}")
 endforeach()
@@ -463,47 +331,25 @@ foreach(arg ${glfw_PKG_LIBS})
     set(GLFW_PKG_LIBS "${GLFW_PKG_LIBS} ${arg}")
 endforeach()
 
-#--------------------------------------------------------------------
-# Choose library output name
-#--------------------------------------------------------------------
-if (BUILD_SHARED_LIBS AND UNIX)
-    # On Unix-like systems, shared libraries can use the soname system.
-    set(GLFW_LIB_NAME glfw)
-else()
-    set(GLFW_LIB_NAME glfw3)
-endif()
-
 #--------------------------------------------------------------------
 # Create generated files
 #--------------------------------------------------------------------
 include(CMakePackageConfigHelpers)
 
-if (UNIX)
-    set(GLFW_CONFIG_PATH "${CMAKE_INSTALL_PREFIX}/lib/cmake/glfw3/")
-else()
-    set(GLFW_CONFIG_PATH "${CMAKE_INSTALL_PREFIX}/")
-endif()
+set(GLFW_CONFIG_PATH "lib${LIB_SUFFIX}/cmake/glfw3")
 
-configure_package_config_file("${GLFW_SOURCE_DIR}/src/glfw3Config.cmake.in"
-                              "${GLFW_BINARY_DIR}/src/glfw3Config.cmake"
+configure_package_config_file(src/glfw3Config.cmake.in
+                              src/glfw3Config.cmake
                               INSTALL_DESTINATION "${GLFW_CONFIG_PATH}"
-                              PATH_VARS CMAKE_INSTALL_PREFIX
                               NO_CHECK_REQUIRED_COMPONENTS_MACRO)
 
-write_basic_package_version_file("${GLFW_BINARY_DIR}/src/glfw3ConfigVersion.cmake" 
+write_basic_package_version_file(src/glfw3ConfigVersion.cmake
                                  VERSION ${GLFW_VERSION_FULL}
                                  COMPATIBILITY SameMajorVersion)
 
-if (GLFW_BUILD_DOCS)
-    configure_file("${GLFW_SOURCE_DIR}/docs/Doxyfile.in"
-                   "${GLFW_BINARY_DIR}/docs/Doxyfile" @ONLY)
-endif()
+configure_file(src/glfw_config.h.in src/glfw_config.h @ONLY)
 
-configure_file("${GLFW_SOURCE_DIR}/src/glfw_config.h.in"
-               "${GLFW_BINARY_DIR}/src/glfw_config.h" @ONLY)
-
-configure_file("${GLFW_SOURCE_DIR}/src/glfw3.pc.in"
-               "${GLFW_BINARY_DIR}/src/glfw3.pc" @ONLY)
+configure_file(src/glfw3.pc.in src/glfw3.pc @ONLY)
 
 #--------------------------------------------------------------------
 # Add subdirectories
@@ -532,16 +378,18 @@ if (GLFW_INSTALL)
 
     install(FILES "${GLFW_BINARY_DIR}/src/glfw3Config.cmake"
                   "${GLFW_BINARY_DIR}/src/glfw3ConfigVersion.cmake"
-            DESTINATION lib${LIB_SUFFIX}/cmake/glfw)
+            DESTINATION "${GLFW_CONFIG_PATH}")
 
-    install(EXPORT glfwTargets DESTINATION lib${LIB_SUFFIX}/cmake/glfw)
+    install(EXPORT glfwTargets FILE glfw3Targets.cmake
+            EXPORT_LINK_INTERFACE_LIBRARIES
+            DESTINATION "${GLFW_CONFIG_PATH}")
     install(FILES "${GLFW_BINARY_DIR}/src/glfw3.pc"
-            DESTINATION lib${LIB_SUFFIX}/pkgconfig)
+            DESTINATION "lib${LIB_SUFFIX}/pkgconfig")
 
     # Only generate this target if no higher-level project already has
     if (NOT TARGET uninstall)
-        configure_file("${GLFW_SOURCE_DIR}/cmake_uninstall.cmake.in"
-                       "${GLFW_BINARY_DIR}/cmake_uninstall.cmake" IMMEDIATE @ONLY)
+        configure_file(cmake_uninstall.cmake.in
+                       cmake_uninstall.cmake IMMEDIATE @ONLY)
 
         add_custom_target(uninstall
                           "${CMAKE_COMMAND}" -P

COPYING.txt

@@ -1,5 +1,5 @@
 Copyright (c) 2002-2006 Marcus Geelnard
-Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
+Copyright (c) 2006-2016 Camilla Berglund <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

README.md

@@ -1,24 +1,30 @@
 # GLFW
 
+[![Build status](https://travis-ci.org/glfw/glfw.svg?branch=master)](https://travis-ci.org/glfw/glfw)
+[![Build status](https://ci.appveyor.com/api/projects/status/0kf0ct9831i5l6sp/branch/master?svg=true)](https://ci.appveyor.com/project/elmindreda/glfw)
+
 ## Introduction
 
-GLFW is a free, Open Source, multi-platform library for OpenGL and OpenGL ES
-application development.  It provides a simple, platform-independent API for
-creating windows and contexts, reading input, handling events, etc.
+GLFW is a free, Open Source, multi-platform library for OpenGL, OpenGL ES and
+Vulkan application development.  It provides a simple, platform-independent API
+for creating windows, contexts and surfaces, reading input, handling events, etc.
 
-Version 3.1.2 adds fixes for a large number of bugs that together affect all
-supported platforms, as well as dynamic loading work that simplifies compilation
-and linking.
+Version 3.2 adds support for Vulkan surface creation, window mode switching,
+window maximization, window input focus control, window size and aspect ratio
+limits, human-readable key names, window icons, joystick connection events,
+XInput and DirectInput joystick input, event waiting with timeout, 64-bit
+integer raw timer, context-less window creation, error-less contexts via
+`GL_KHR_no_error` (where available), run-time context creation API selection,
+Windows 8.1 per-monitor DPI and the CMake config-file package system, adds
+simpler build-time configuration, improved documentation and fixes for a large
+number of bugs that together affect all supported platforms.
 
 If you are new to GLFW, you may find the
-[introductory tutorial](http://www.glfw.org/docs/latest/quick.html) for GLFW
+[tutorial](http://www.glfw.org/docs/latest/quick.html) for GLFW
 3 useful.  If you have used GLFW 2 in the past, there is a
 [transition guide](http://www.glfw.org/docs/latest/moving.html) for moving to
 the GLFW 3 API.
 
-Note that a number of source files have been added or renamed in 3.1, which may
-require you to update any custom build files you have.
-
 
 ## Compiling GLFW
 
@@ -50,10 +56,13 @@ This will help both us and other people experiencing the same bug.
 
 ## Dependencies
 
-GLFW bundles a number of dependencies in the `deps/` directory.
+GLFW itself needs only the headers and libraries for your window system.  It
+does not need the headers for any context creation API (WGL, GLX, EGL, NSGL) or
+rendering API (OpenGL, OpenGL ES, Vulkan) to enable support for them.
+
+The examples and test programs depend on a number of tiny libraries.  These are
+located in the `deps/` directory.
 
- - [Khronos extension headers](https://www.opengl.org/registry/) for API
-   extension symbols used by GLFW
  - [getopt\_port](https://github.com/kimgr/getopt_port/) for examples
    with command-line options
  - [TinyCThread](https://github.com/tinycthread/tinycthread) for threaded
@@ -62,67 +71,82 @@ GLFW bundles a number of dependencies in the `deps/` directory.
    [glad](https://github.com/Dav1dde/glad) for examples using modern OpenGL
  - [linmath.h](https://github.com/datenwolf/linmath.h) for linear algebra in
    examples
+ - [Vulkan headers](https://www.khronos.org/registry/vulkan/) for Vulkan tests
+
+The Vulkan example additionally requires the Vulkan SDK to be installed, or it
+will not be included in the build.
+
+The documentation is generated with [Doxygen](http://doxygen.org/).  If CMake
+does not find Doxygen, the documentation will not be generated.
 
 
 ## Changelog
 
- - Made all client API functions dynamically loaded
- - Changed minimum required CMake version to 2.8.12
- - Replaced GLU with [linmath.h](https://github.com/datenwolf/linmath.h) in
-   example programs
- - Merged all cursor test programs into the `cursor` program
- - Removed all mention of GLU in examples, build files and package dependencies
- - Bugfix: Initialization failed on headless systems
- - Bugfix: The cached current context could get out of sync
- - Bugfix: `glfwIconifyWindow` did not restore the original video mode for full
-           screen windows created with `GLFW_AUTO_ICONIFY`
- - [Win32] Renamed hybrid GPU override compile-time option to
-           `_GLFW_USE_HYBRID_HPG` and added support for AMD PowerXpress systems
- - [Win32] Bugfix: `glfwGetVideoModes` included unusable modes on some systems
- - [Win32] Bugfix: `glfwWaitEvents` would return directly for focused windows in
-                   disabled cursor mode
- - [Cocoa] Bugfix: The cached `NSScreen` for a monitor could get out of sync
- - [Cocoa] Bugfix: The `GLFW_AUTO_ICONIFY` window hint was ignored
- - [Cocoa] Bugfix: Resizing a window to its minimum size would segfault
- - [Cocoa] Bugfix: Creating or showing a window would make its context current
- - [Cocoa] Bugfix: Joysticks connected after `glfwInit` were not detected
- - [Cocoa] Bugfix: Cursor creation failed unless a window had been created.
- - [Cocoa] Bugfix: Window refresh events were not generated by iconification or
-                   restoration
- - [Cocoa] Bugfix: The primary monitor would get reported as disconnected when
-                   entering full screen on a dual-GPU machine with automatic
-                   graphics switching
- - [Cocoa] Bugfix: The original video modes were not restored when the
-                   application was hidden
- - [X11] Bugfix: `glfwInit` would segfault on systems without RandR
- - [X11] Bugfix: The response to `_NET_WM_PING` was sent to the wrong window
- - [X11] Bugfix: Character input via XIM did not work in many cases
- - [X11] Bugfix: No fallback existed for missing `_NET_ACTIVE_WINDOW` support
- - [X11] Bugfix: Some significant window focus events were ignored
- - [X11] Bugfix: The `GLFW_AUTO_ICONIFY` window hint was ignored
- - [X11] Bugfix: The original video mode was not restored on iconification of
-                 full screen windows
- - [X11] Bugfix: `GLFW_ARROW_CURSOR` selected the wrong cursor image
- - [X11] Bugfix: The `GLFW_DECORATED` hint was not ignored for full screen
- - [X11] Bugfix: `glfwWaitEvents` did not handle `EINTR` for `select`
- - [X11] Bugfix: `glfwWaitEvents` could return when no events were available
- - [X11] Bugfix: `XkbGetKeyboard` fails on XWayland
- - [X11] Bugfix: Character input did not work correctly for non-UTF-8 locales
- - [X11] Bugfix: Long input sequences generated by IMEs were discarded
- - [WGL] Made all WGL functions dynamically loaded
- - [WGL] Removed `GLFW_USE_DWM_SWAP_INTERVAL` compile-time option
- - [WGL] Bugfix: Swap interval was ignored when DWM was enabled
- - [WGL] Bugfix: Failure to find a pixel format was reported incorrectly
- - [GLX] Added dependency on `libdl` on systems where it provides `dlopen`
- - [GLX] Made all GLX functions dynamically loaded
- - [GLX] Removed `_GLFW_HAS_GLXGETPROCADDRESS*` and `_GLFW_HAS_DLOPEN`
-         compile-time options
- - [GLX] Bugfix: Failure to find a `GLXFBConfig` was reported incorrectly
- - [EGL] Made all EGL functions dynamically loaded
- - [EGL] Bugfix: `glfwGetProcAddress` did not return the addresses of core
-                 functions
- - [EGL] Bugfix: Failure to find an `EGLConfig` was reported incorrectly
- - [NSGL] Bugfix: Failure to find a pixel format was reported incorrectly
+ - Added `glfwVulkanSupported`, `glfwGetRequiredInstanceExtensions`,
+   `glfwGetInstanceProcAddress`, `glfwGetPhysicalDevicePresentationSupport` and
+   `glfwCreateWindowSurface` for platform independent Vulkan support
+ - Added `glfwSetWindowMonitor` for switching between windowed and full screen
+   modes and updating the monitor and desired video mode of full screen windows
+ - Added `glfwMaximizeWindow` and `GLFW_MAXIMIZED` for window maximization
+ - Added `glfwFocusWindow` for giving windows input focus
+ - Added `glfwSetWindowSizeLimits` and `glfwSetWindowAspectRatio` for setting
+   absolute and relative window size limits
+ - Added `glfwGetKeyName` for querying the layout-specific name of printable
+   keys
+ - Added `glfwWaitEventsTimeout` for waiting for events for a set amount of time
+ - Added `glfwSetWindowIcon` for setting the icon of a window
+ - Added `glfwGetTimerValue` and `glfwGetTimerFrequency` for raw timer access
+ - Added `glfwSetJoystickCallback` and `GLFWjoystickfun` for joystick connection
+   and disconnection events
+ - Added `GLFW_NO_API` for creating window without contexts
+ - Added `GLFW_INCLUDE_VULKAN` for including the Vulkan header
+ - Added `GLFW_CONTEXT_CREATION_API`, `GLFW_NATIVE_CONTEXT_API` and
+   `GLFW_EGL_CONTEXT_API` for run-time context creation API selection
+ - Added `GLFW_CONTEXT_NO_ERROR` context hint for `GL_KHR_no_error` support
+ - Added `GLFW_TRUE` and `GLFW_FALSE` as client API independent boolean values
+ - Added icons to examples on Windows and OS X
+ - Relaxed rules for native access header macros
+ - Removed dependency on external OpenGL or OpenGL ES headers
+ - Removed `_GLFW_USE_OPENGL`, `_GLFW_USE_GLESV1`, `_GLFW_USE_GLESV2`,
+   `_GLFW_WGL`, `_GLFW_NSGL`, `_GLFW_GLX` and `_GLFW_EGL` configuration macros
+ - [Win32] Added support for Windows 8.1 per-monitor DPI
+ - [Win32] Replaced winmm with XInput and DirectInput for joystick input
+ - [Win32] Bugfix: Window creation would segfault if video mode setting required
+                   the system to be restarted
+ - [Win32] Bugfix: MinGW import library lacked the `lib` prefix
+ - [Win32] Bugfix: Monitor connection and disconnection events were not reported
+                   when no windows existed
+ - [Win32] Bugfix: Activating or deactivating displays in software did not
+                   trigger monitor callback
+ - [Win32] Bugfix: No monitors were listed on headless and VMware guest systems
+ - [Win32] Bugfix: Pressing Ctrl+Pause would report `GLFW_KEY_UNKNOWN`
+ - [Win32] Bugfix: Window size events would be reported in wrong order when
+                   restoring a full screen window
+ - [Cocoa] Made joystick polling more efficient
+ - [Cocoa] Removed support for OS X 10.6
+ - [Cocoa] Bugfix: Full screen windows on secondary monitors were mispositioned
+ - [Cocoa] Bugfix: Connecting a joystick that reports no name would segfault
+ - [Cocoa] Bugfix: Modifier flags cache was not updated when window became key
+ - [Cocoa] Bugfix: Dead key character composition did not work
+ - [Cocoa] Bugfix: The CGL context was not released until the autorelease pool
+                   was drained by another function
+ - [X11] Bugfix: Monitor connection and disconnection events were not reported
+ - [X11] Bugfix: Decoding of UTF-8 text from XIM could continue past the end
+ - [X11] Bugfix: An XKB structure was leaked during `glfwInit`
+ - [X11] Bugfix: XInput2 `XI_Motion` events interfered with the Steam overlay
+ - [POSIX] Bugfix: An unrelated TLS key could be deleted by `glfwTerminate`
+ - [Linux] Made joystick polling more efficient
+ - [WGL] Changed extension loading to only be performed once
+ - [WGL] Removed dependency on external WGL headers
+ - [GLX] Added `glfwGetGLXWindow` to query the `GLXWindow` of a window
+ - [GLX] Replaced legacy drawable with `GLXWindow`
+ - [GLX] Removed dependency on external GLX headers
+ - [GLX] Bugfix: NetBSD does not provide `libGL.so.1`
+ - [EGL] Added `_GLFW_USE_EGLPLATFORM_H` configuration macro for controlling
+         whether to use an existing `EGL/eglplatform.h` header
+ - [EGL] Added and documented test for if the context is current on the calling
+         thread during buffer swap
+ - [EGL] Removed dependency on external EGL headers
 
 
 ## Contact
@@ -132,7 +156,7 @@ can find the latest version of GLFW, as well as news, documentation and other
 information about the project.
 
 If you have questions related to the use of GLFW, we have a
-[support forum](https://sourceforge.net/p/glfw/discussion/247562/), and the IRC
+[support forum](http://discourse.glfw.org/), and the IRC
 channel `#glfw` on [Freenode](http://freenode.net/).
 
 If you have a bug to report, a patch to submit or a feature you'd like to
@@ -167,6 +191,8 @@ skills.
  - Olivier Delannoy
  - Paul R. Deppe
  - Michael Dickens
+ - Роман Донченко
+ - Mario Dorn
  - Jonathan Dummer
  - Ralph Eastwood
  - Siavash Eliasi
@@ -181,12 +207,14 @@ skills.
  - heromyth
  - Lucas Hinderberger
  - Paul Holden
+ - IntellectualKitty
  - Aaron Jacobs
  - Toni Jovanoski
  - Arseny Kapoulkine
  - Osman Keskin
  - Cameron King
  - Peter Knut
+ - Christoph Kubisch
  - Eric Larson
  - Robin Leffmann
  - Glenn Lewis
@@ -196,6 +224,7 @@ skills.
  - Martins Mozeiko
  - Tristam MacDonald
  - Hans Mackowiak
+ - Zbigniew Mandziejewicz
  - Kyle McDonald
  - David Medlock
  - Bryce Mehring
@@ -215,6 +244,7 @@ skills.
  - Peoro
  - Braden Pellett
  - Arturo J. Pérez
+ - Orson Peters
  - Emmanuel Gil Peyrot
  - Cyril Pichard
  - Pieroman
@@ -228,6 +258,7 @@ skills.
  - SephiRok
  - Steve Sexton
  - Systemcluster
+ - Yoshiki Shibukawa
  - Dmitri Shuralyov
  - Daniel Skorupski
  - Bradley Smith
@@ -239,13 +270,16 @@ skills.
  - TTK-Bandit
  - Sergey Tikhomirov
  - A. Tombs
+ - Ioannis Tsakpinis
  - Samuli Tuomola
  - urraka
  - Jari Vetoniemi
  - Ricardo Vieira
+ - Nicholas Vitovitch
  - Simon Voordouw
  - Torsten Walluhn
  - Patrick Walton
+ - Xo Wang
  - Jay Weisskopf
  - Frank Wille
  - yuriks

deps/EGL/eglext.h

@@ -1,565 +0,0 @@
-#ifndef __eglext_h_
-#define __eglext_h_
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/*
-** Copyright (c) 2007-2013 The Khronos Group Inc.
-**
-** Permission is hereby granted, free of charge, to any person obtaining a
-** copy of this software and/or associated documentation files (the
-** "Materials"), to deal in the Materials without restriction, including
-** without limitation the rights to use, copy, modify, merge, publish,
-** distribute, sublicense, and/or sell copies of the Materials, and to
-** permit persons to whom the Materials are furnished to do so, subject to
-** the following conditions:
-**
-** The above copyright notice and this permission notice shall be included
-** in all copies or substantial portions of the Materials.
-**
-** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
-*/
-
-#include <EGL/eglplatform.h>
-
-/*************************************************************/
-
-/* Header file version number */
-/* Current version at http://www.khronos.org/registry/egl/ */
-/* $Revision: 20690 $ on $Date: 2013-02-22 17:15:05 -0800 (Fri, 22 Feb 2013) $ */
-#define EGL_EGLEXT_VERSION 15
-
-#ifndef EGL_KHR_config_attribs
-#define EGL_KHR_config_attribs 1
-#define EGL_CONFORMANT_KHR			0x3042	/* EGLConfig attribute */
-#define EGL_VG_COLORSPACE_LINEAR_BIT_KHR	0x0020	/* EGL_SURFACE_TYPE bitfield */
-#define EGL_VG_ALPHA_FORMAT_PRE_BIT_KHR		0x0040	/* EGL_SURFACE_TYPE bitfield */
-#endif
-
-#ifndef EGL_KHR_lock_surface
-#define EGL_KHR_lock_surface 1
-#define EGL_READ_SURFACE_BIT_KHR		0x0001	/* EGL_LOCK_USAGE_HINT_KHR bitfield */
-#define EGL_WRITE_SURFACE_BIT_KHR		0x0002	/* EGL_LOCK_USAGE_HINT_KHR bitfield */
-#define EGL_LOCK_SURFACE_BIT_KHR		0x0080	/* EGL_SURFACE_TYPE bitfield */
-#define EGL_OPTIMAL_FORMAT_BIT_KHR		0x0100	/* EGL_SURFACE_TYPE bitfield */
-#define EGL_MATCH_FORMAT_KHR			0x3043	/* EGLConfig attribute */
-#define EGL_FORMAT_RGB_565_EXACT_KHR		0x30C0	/* EGL_MATCH_FORMAT_KHR value */
-#define EGL_FORMAT_RGB_565_KHR			0x30C1	/* EGL_MATCH_FORMAT_KHR value */
-#define EGL_FORMAT_RGBA_8888_EXACT_KHR		0x30C2	/* EGL_MATCH_FORMAT_KHR value */
-#define EGL_FORMAT_RGBA_8888_KHR		0x30C3	/* EGL_MATCH_FORMAT_KHR value */
-#define EGL_MAP_PRESERVE_PIXELS_KHR		0x30C4	/* eglLockSurfaceKHR attribute */
-#define EGL_LOCK_USAGE_HINT_KHR			0x30C5	/* eglLockSurfaceKHR attribute */
-#define EGL_BITMAP_POINTER_KHR			0x30C6	/* eglQuerySurface attribute */
-#define EGL_BITMAP_PITCH_KHR			0x30C7	/* eglQuerySurface attribute */
-#define EGL_BITMAP_ORIGIN_KHR			0x30C8	/* eglQuerySurface attribute */
-#define EGL_BITMAP_PIXEL_RED_OFFSET_KHR		0x30C9	/* eglQuerySurface attribute */
-#define EGL_BITMAP_PIXEL_GREEN_OFFSET_KHR	0x30CA	/* eglQuerySurface attribute */
-#define EGL_BITMAP_PIXEL_BLUE_OFFSET_KHR	0x30CB	/* eglQuerySurface attribute */
-#define EGL_BITMAP_PIXEL_ALPHA_OFFSET_KHR	0x30CC	/* eglQuerySurface attribute */
-#define EGL_BITMAP_PIXEL_LUMINANCE_OFFSET_KHR	0x30CD	/* eglQuerySurface attribute */
-#define EGL_LOWER_LEFT_KHR			0x30CE	/* EGL_BITMAP_ORIGIN_KHR value */
-#define EGL_UPPER_LEFT_KHR			0x30CF	/* EGL_BITMAP_ORIGIN_KHR value */
-#ifdef EGL_EGLEXT_PROTOTYPES
-EGLAPI EGLBoolean EGLAPIENTRY eglLockSurfaceKHR (EGLDisplay display, EGLSurface surface, const EGLint *attrib_list);
-EGLAPI EGLBoolean EGLAPIENTRY eglUnlockSurfaceKHR (EGLDisplay display, EGLSurface surface);
-#endif /* EGL_EGLEXT_PROTOTYPES */
-typedef EGLBoolean (EGLAPIENTRYP PFNEGLLOCKSURFACEKHRPROC) (EGLDisplay display, EGLSurface surface, const EGLint *attrib_list);
-typedef EGLBoolean (EGLAPIENTRYP PFNEGLUNLOCKSURFACEKHRPROC) (EGLDisplay display, EGLSurface surface);
-#endif
-
-#ifndef EGL_KHR_image
-#define EGL_KHR_image 1
-#define EGL_NATIVE_PIXMAP_KHR			0x30B0	/* eglCreateImageKHR target */
-typedef void *EGLImageKHR;
-#define EGL_NO_IMAGE_KHR			((EGLImageKHR)0)
-#ifdef EGL_EGLEXT_PROTOTYPES
-EGLAPI EGLImageKHR EGLAPIENTRY eglCreateImageKHR (EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer, const EGLint *attrib_list);
-EGLAPI EGLBoolean EGLAPIENTRY eglDestroyImageKHR (EGLDisplay dpy, EGLImageKHR image);
-#endif /* EGL_EGLEXT_PROTOTYPES */
-typedef EGLImageKHR (EGLAPIENTRYP PFNEGLCREATEIMAGEKHRPROC) (EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer, const EGLint *attrib_list);
-typedef EGLBoolean (EGLAPIENTRYP PFNEGLDESTROYIMAGEKHRPROC) (EGLDisplay dpy, EGLImageKHR image);
-#endif
-
-#ifndef EGL_KHR_vg_parent_image
-#define EGL_KHR_vg_parent_image 1
-#define EGL_VG_PARENT_IMAGE_KHR			0x30BA	/* eglCreateImageKHR target */
-#endif
-
-#ifndef EGL_KHR_gl_texture_2D_image
-#define EGL_KHR_gl_texture_2D_image 1
-#define EGL_GL_TEXTURE_2D_KHR			0x30B1	/* eglCreateImageKHR target */
-#define EGL_GL_TEXTURE_LEVEL_KHR		0x30BC	/* eglCreateImageKHR attribute */
-#endif
-
-#ifndef EGL_KHR_gl_texture_cubemap_image
-#define EGL_KHR_gl_texture_cubemap_image 1
-#define EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_X_KHR	0x30B3	/* eglCreateImageKHR target */
-#define EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_X_KHR	0x30B4	/* eglCreateImageKHR target */
-#define EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Y_KHR	0x30B5	/* eglCreateImageKHR target */
-#define EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_KHR	0x30B6	/* eglCreateImageKHR target */
-#define EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Z_KHR	0x30B7	/* eglCreateImageKHR target */
-#define EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_KHR	0x30B8	/* eglCreateImageKHR target */
-#endif
-
-#ifndef EGL_KHR_gl_texture_3D_image
-#define EGL_KHR_gl_texture_3D_image 1
-#define EGL_GL_TEXTURE_3D_KHR			0x30B2	/* eglCreateImageKHR target */
-#define EGL_GL_TEXTURE_ZOFFSET_KHR		0x30BD	/* eglCreateImageKHR attribute */
-#endif
-
-#ifndef EGL_KHR_gl_renderbuffer_image
-#define EGL_KHR_gl_renderbuffer_image 1
-#define EGL_GL_RENDERBUFFER_KHR			0x30B9	/* eglCreateImageKHR target */
-#endif
-
-#if KHRONOS_SUPPORT_INT64   /* EGLTimeKHR requires 64-bit uint support */
-#ifndef EGL_KHR_reusable_sync
-#define EGL_KHR_reusable_sync 1
-
-typedef void* EGLSyncKHR;
-typedef khronos_utime_nanoseconds_t EGLTimeKHR;
-
-#define EGL_SYNC_STATUS_KHR			0x30F1
-#define EGL_SIGNALED_KHR			0x30F2
-#define EGL_UNSIGNALED_KHR			0x30F3
-#define EGL_TIMEOUT_EXPIRED_KHR			0x30F5
-#define EGL_CONDITION_SATISFIED_KHR		0x30F6
-#define EGL_SYNC_TYPE_KHR			0x30F7
-#define EGL_SYNC_REUSABLE_KHR			0x30FA
-#define EGL_SYNC_FLUSH_COMMANDS_BIT_KHR		0x0001	/* eglClientWaitSyncKHR <flags> bitfield */
-#define EGL_FOREVER_KHR				0xFFFFFFFFFFFFFFFFull
-#define EGL_NO_SYNC_KHR				((EGLSyncKHR)0)
-#ifdef EGL_EGLEXT_PROTOTYPES
-EGLAPI EGLSyncKHR EGLAPIENTRY eglCreateSyncKHR(EGLDisplay dpy, EGLenum type, const EGLint *attrib_list);
-EGLAPI EGLBoolean EGLAPIENTRY eglDestroySyncKHR(EGLDisplay dpy, EGLSyncKHR sync);
-EGLAPI EGLint EGLAPIENTRY eglClientWaitSyncKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint flags, EGLTimeKHR timeout);
-EGLAPI EGLBoolean EGLAPIENTRY eglSignalSyncKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLenum mode);
-EGLAPI EGLBoolean EGLAPIENTRY eglGetSyncAttribKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint attribute, EGLint *value);
-#endif /* EGL_EGLEXT_PROTOTYPES */
-typedef EGLSyncKHR (EGLAPIENTRYP PFNEGLCREATESYNCKHRPROC) (EGLDisplay dpy, EGLenum type, const EGLint *attrib_list);
-typedef EGLBoolean (EGLAPIENTRYP PFNEGLDESTROYSYNCKHRPROC) (EGLDisplay dpy, EGLSyncKHR sync);
-typedef EGLint (EGLAPIENTRYP PFNEGLCLIENTWAITSYNCKHRPROC) (EGLDisplay dpy, EGLSyncKHR sync, EGLint flags, EGLTimeKHR timeout);
-typedef EGLBoolean (EGLAPIENTRYP PFNEGLSIGNALSYNCKHRPROC) (EGLDisplay dpy, EGLSyncKHR sync, EGLenum mode);
-typedef EGLBoolean (EGLAPIENTRYP PFNEGLGETSYNCATTRIBKHRPROC) (EGLDisplay dpy, EGLSyncKHR sync, EGLint attribute, EGLint *value);
-#endif
-#endif
-
-#ifndef EGL_KHR_image_base
-#define EGL_KHR_image_base 1
-/* Most interfaces defined by EGL_KHR_image_pixmap above */
-#define EGL_IMAGE_PRESERVED_KHR			0x30D2	/* eglCreateImageKHR attribute */
-#endif
-
-#ifndef EGL_KHR_image_pixmap
-#define EGL_KHR_image_pixmap 1
-/* Interfaces defined by EGL_KHR_image above */
-#endif
-
-#ifndef EGL_IMG_context_priority
-#define EGL_IMG_context_priority 1
-#define EGL_CONTEXT_PRIORITY_LEVEL_IMG		0x3100
-#define EGL_CONTEXT_PRIORITY_HIGH_IMG		0x3101
-#define EGL_CONTEXT_PRIORITY_MEDIUM_IMG		0x3102
-#define EGL_CONTEXT_PRIORITY_LOW_IMG		0x3103
-#endif
-
-#ifndef EGL_KHR_lock_surface2
-#define EGL_KHR_lock_surface2 1
-#define EGL_BITMAP_PIXEL_SIZE_KHR		0x3110
-#endif
-
-#ifndef EGL_NV_coverage_sample
-#define EGL_NV_coverage_sample 1
-#define EGL_COVERAGE_BUFFERS_NV			0x30E0
-#define EGL_COVERAGE_SAMPLES_NV			0x30E1
-#endif
-
-#ifndef EGL_NV_depth_nonlinear
-#define EGL_NV_depth_nonlinear 1
-#define EGL_DEPTH_ENCODING_NV			0x30E2
-#define EGL_DEPTH_ENCODING_NONE_NV 0
-#define EGL_DEPTH_ENCODING_NONLINEAR_NV		0x30E3
-#endif
-
-#if KHRONOS_SUPPORT_INT64   /* EGLTimeNV requires 64-bit uint support */
-#ifndef EGL_NV_sync
-#define EGL_NV_sync 1
-#define EGL_SYNC_PRIOR_COMMANDS_COMPLETE_NV	0x30E6
-#define EGL_SYNC_STATUS_NV			0x30E7
-#define EGL_SIGNALED_NV				0x30E8
-#define EGL_UNSIGNALED_NV			0x30E9
-#define EGL_SYNC_FLUSH_COMMANDS_BIT_NV		0x0001
-#define EGL_FOREVER_NV				0xFFFFFFFFFFFFFFFFull
-#define EGL_ALREADY_SIGNALED_NV			0x30EA
-#define EGL_TIMEOUT_EXPIRED_NV			0x30EB
-#define EGL_CONDITION_SATISFIED_NV		0x30EC
-#define EGL_SYNC_TYPE_NV			0x30ED
-#define EGL_SYNC_CONDITION_NV			0x30EE
-#define EGL_SYNC_FENCE_NV			0x30EF
-#define EGL_NO_SYNC_NV				((EGLSyncNV)0)
-typedef void* EGLSyncNV;
-typedef khronos_utime_nanoseconds_t EGLTimeNV;
-#ifdef EGL_EGLEXT_PROTOTYPES
-EGLAPI EGLSyncNV EGLAPIENTRY eglCreateFenceSyncNV (EGLDisplay dpy, EGLenum condition, const EGLint *attrib_list);
-EGLAPI EGLBoolean EGLAPIENTRY eglDestroySyncNV (EGLSyncNV sync);
-EGLAPI EGLBoolean EGLAPIENTRY eglFenceNV (EGLSyncNV sync);
-EGLAPI EGLint EGLAPIENTRY eglClientWaitSyncNV (EGLSyncNV sync, EGLint flags, EGLTimeNV timeout);
-EGLAPI EGLBoolean EGLAPIENTRY eglSignalSyncNV (EGLSyncNV sync, EGLenum mode);
-EGLAPI EGLBoolean EGLAPIENTRY eglGetSyncAttribNV (EGLSyncNV sync, EGLint attribute, EGLint *value);
-#endif /* EGL_EGLEXT_PROTOTYPES */
-typedef EGLSyncNV (EGLAPIENTRYP PFNEGLCREATEFENCESYNCNVPROC) (EGLDisplay dpy, EGLenum condition, const EGLint *attrib_list);
-typedef EGLBoolean (EGLAPIENTRYP PFNEGLDESTROYSYNCNVPROC) (EGLSyncNV sync);
-typedef EGLBoolean (EGLAPIENTRYP PFNEGLFENCENVPROC) (EGLSyncNV sync);
-typedef EGLint (EGLAPIENTRYP PFNEGLCLIENTWAITSYNCNVPROC) (EGLSyncNV sync, EGLint flags, EGLTimeNV timeout);
-typedef EGLBoolean (EGLAPIENTRYP PFNEGLSIGNALSYNCNVPROC) (EGLSyncNV sync, EGLenum mode);
-typedef EGLBoolean (EGLAPIENTRYP PFNEGLGETSYNCATTRIBNVPROC) (EGLSyncNV sync, EGLint attribute, EGLint *value);
-#endif
-#endif
-
-#if KHRONOS_SUPPORT_INT64   /* Dependent on EGL_KHR_reusable_sync which requires 64-bit uint support */
-#ifndef EGL_KHR_fence_sync
-#define EGL_KHR_fence_sync 1
-/* Reuses most tokens and entry points from EGL_KHR_reusable_sync */
-#define EGL_SYNC_PRIOR_COMMANDS_COMPLETE_KHR	0x30F0
-#define EGL_SYNC_CONDITION_KHR			0x30F8
-#define EGL_SYNC_FENCE_KHR			0x30F9
-#endif
-#endif
-
-#ifndef EGL_HI_clientpixmap
-#define EGL_HI_clientpixmap 1
-
-/* Surface Attribute */
-#define EGL_CLIENT_PIXMAP_POINTER_HI		0x8F74
-/*
- * Structure representing a client pixmap
- * (pixmap's data is in client-space memory).
- */
-struct EGLClientPixmapHI
-{
-	void*		pData;
-	EGLint		iWidth;
-	EGLint		iHeight;
-	EGLint		iStride;
-};
-#ifdef EGL_EGLEXT_PROTOTYPES
-EGLAPI EGLSurface EGLAPIENTRY eglCreatePixmapSurfaceHI(EGLDisplay dpy, EGLConfig config, struct EGLClientPixmapHI* pixmap);
-#endif /* EGL_EGLEXT_PROTOTYPES */
-typedef EGLSurface (EGLAPIENTRYP PFNEGLCREATEPIXMAPSURFACEHIPROC) (EGLDisplay dpy, EGLConfig config, struct EGLClientPixmapHI* pixmap);
-#endif	/* EGL_HI_clientpixmap */
-
-#ifndef EGL_HI_colorformats
-#define EGL_HI_colorformats 1
-/* Config Attribute */
-#define EGL_COLOR_FORMAT_HI			0x8F70
-/* Color Formats */
-#define EGL_COLOR_RGB_HI			0x8F71
-#define EGL_COLOR_RGBA_HI			0x8F72
-#define EGL_COLOR_ARGB_HI			0x8F73
-#endif /* EGL_HI_colorformats */
-
-#ifndef EGL_MESA_drm_image
-#define EGL_MESA_drm_image 1
-#define EGL_DRM_BUFFER_FORMAT_MESA		0x31D0	    /* CreateDRMImageMESA attribute */
-#define EGL_DRM_BUFFER_USE_MESA			0x31D1	    /* CreateDRMImageMESA attribute */
-#define EGL_DRM_BUFFER_FORMAT_ARGB32_MESA	0x31D2	    /* EGL_IMAGE_FORMAT_MESA attribute value */
-#define EGL_DRM_BUFFER_MESA			0x31D3	    /* eglCreateImageKHR target */
-#define EGL_DRM_BUFFER_STRIDE_MESA		0x31D4
-#define EGL_DRM_BUFFER_USE_SCANOUT_MESA		0x00000001  /* EGL_DRM_BUFFER_USE_MESA bits */
-#define EGL_DRM_BUFFER_USE_SHARE_MESA		0x00000002  /* EGL_DRM_BUFFER_USE_MESA bits */
-#ifdef EGL_EGLEXT_PROTOTYPES
-EGLAPI EGLImageKHR EGLAPIENTRY eglCreateDRMImageMESA (EGLDisplay dpy, const EGLint *attrib_list);
-EGLAPI EGLBoolean EGLAPIENTRY eglExportDRMImageMESA (EGLDisplay dpy, EGLImageKHR image, EGLint *name, EGLint *handle, EGLint *stride);
-#endif /* EGL_EGLEXT_PROTOTYPES */
-typedef EGLImageKHR (EGLAPIENTRYP PFNEGLCREATEDRMIMAGEMESAPROC) (EGLDisplay dpy, const EGLint *attrib_list);
-typedef EGLBoolean (EGLAPIENTRYP PFNEGLEXPORTDRMIMAGEMESAPROC) (EGLDisplay dpy, EGLImageKHR image, EGLint *name, EGLint *handle, EGLint *stride);
-#endif
-
-#ifndef EGL_NV_post_sub_buffer
-#define EGL_NV_post_sub_buffer 1
-#define EGL_POST_SUB_BUFFER_SUPPORTED_NV	0x30BE
-#ifdef EGL_EGLEXT_PROTOTYPES
-EGLAPI EGLBoolean EGLAPIENTRY eglPostSubBufferNV (EGLDisplay dpy, EGLSurface surface, EGLint x, EGLint y, EGLint width, EGLint height);
-#endif /* EGL_EGLEXT_PROTOTYPES */
-typedef EGLBoolean (EGLAPIENTRYP PFNEGLPOSTSUBBUFFERNVPROC) (EGLDisplay dpy, EGLSurface surface, EGLint x, EGLint y, EGLint width, EGLint height);
-#endif
-
-#ifndef EGL_ANGLE_query_surface_pointer
-#define EGL_ANGLE_query_surface_pointer 1
-#ifdef EGL_EGLEXT_PROTOTYPES
-EGLAPI EGLBoolean eglQuerySurfacePointerANGLE(EGLDisplay dpy, EGLSurface surface, EGLint attribute, void **value);
-#endif
-typedef EGLBoolean (EGLAPIENTRYP PFNEGLQUERYSURFACEPOINTERANGLEPROC) (EGLDisplay dpy, EGLSurface surface, EGLint attribute, void **value);
-#endif
-
-#ifndef EGL_ANGLE_surface_d3d_texture_2d_share_handle
-#define EGL_ANGLE_surface_d3d_texture_2d_share_handle 1
-#define EGL_D3D_TEXTURE_2D_SHARE_HANDLE_ANGLE	0x3200
-#endif
-
-#ifndef EGL_NV_coverage_sample_resolve
-#define EGL_NV_coverage_sample_resolve 1
-#define EGL_COVERAGE_SAMPLE_RESOLVE_NV		0x3131
-#define EGL_COVERAGE_SAMPLE_RESOLVE_DEFAULT_NV	0x3132
-#define EGL_COVERAGE_SAMPLE_RESOLVE_NONE_NV	0x3133
-#endif
-
-#if KHRONOS_SUPPORT_INT64   /* EGLuint64NV requires 64-bit uint support */
-#ifndef EGL_NV_system_time
-#define EGL_NV_system_time 1
-typedef khronos_utime_nanoseconds_t EGLuint64NV;
-#ifdef EGL_EGLEXT_PROTOTYPES
-EGLAPI EGLuint64NV EGLAPIENTRY eglGetSystemTimeFrequencyNV(void);
-EGLAPI EGLuint64NV EGLAPIENTRY eglGetSystemTimeNV(void);
-#endif /* EGL_EGLEXT_PROTOTYPES */
-typedef EGLuint64NV (EGLAPIENTRYP PFNEGLGETSYSTEMTIMEFREQUENCYNVPROC) (void);
-typedef EGLuint64NV (EGLAPIENTRYP PFNEGLGETSYSTEMTIMENVPROC) (void);
-#endif
-#endif
-
-#if KHRONOS_SUPPORT_INT64 /* EGLuint64KHR requires 64-bit uint support */
-#ifndef EGL_KHR_stream
-#define EGL_KHR_stream 1
-typedef void* EGLStreamKHR;
-typedef khronos_uint64_t EGLuint64KHR;
-#define EGL_NO_STREAM_KHR			((EGLStreamKHR)0)
-#define EGL_CONSUMER_LATENCY_USEC_KHR		0x3210
-#define EGL_PRODUCER_FRAME_KHR			0x3212
-#define EGL_CONSUMER_FRAME_KHR			0x3213
-#define EGL_STREAM_STATE_KHR			0x3214
-#define EGL_STREAM_STATE_CREATED_KHR		0x3215
-#define EGL_STREAM_STATE_CONNECTING_KHR		0x3216
-#define EGL_STREAM_STATE_EMPTY_KHR		0x3217
-#define EGL_STREAM_STATE_NEW_FRAME_AVAILABLE_KHR    0x3218
-#define EGL_STREAM_STATE_OLD_FRAME_AVAILABLE_KHR    0x3219
-#define EGL_STREAM_STATE_DISCONNECTED_KHR	0x321A
-#define EGL_BAD_STREAM_KHR			0x321B
-#define EGL_BAD_STATE_KHR			0x321C
-#ifdef EGL_EGLEXT_PROTOTYPES
-EGLAPI EGLStreamKHR EGLAPIENTRY eglCreateStreamKHR(EGLDisplay dpy, const EGLint *attrib_list);
-EGLAPI EGLBoolean EGLAPIENTRY eglDestroyStreamKHR(EGLDisplay dpy, EGLStreamKHR stream);
-EGLAPI EGLBoolean EGLAPIENTRY eglStreamAttribKHR(EGLDisplay dpy, EGLStreamKHR stream, EGLenum attribute, EGLint value);
-EGLAPI EGLBoolean EGLAPIENTRY eglQueryStreamKHR(EGLDisplay dpy, EGLStreamKHR stream, EGLenum attribute, EGLint *value);
-EGLAPI EGLBoolean EGLAPIENTRY eglQueryStreamu64KHR(EGLDisplay dpy, EGLStreamKHR stream, EGLenum attribute, EGLuint64KHR *value);
-#endif /* EGL_EGLEXT_PROTOTYPES */
-typedef EGLStreamKHR (EGLAPIENTRYP PFNEGLCREATESTREAMKHRPROC)(EGLDisplay dpy, const EGLint *attrib_list);
-typedef EGLBoolean (EGLAPIENTRYP PFNEGLDESTROYSTREAMKHRPROC)(EGLDisplay dpy, EGLStreamKHR stream);
-typedef EGLBoolean (EGLAPIENTRYP PFNEGLSTREAMATTRIBKHRPROC)(EGLDisplay dpy, EGLStreamKHR stream, EGLenum attribute, EGLint value);
-typedef EGLBoolean (EGLAPIENTRYP PFNEGLQUERYSTREAMKHRPROC)(EGLDisplay dpy, EGLStreamKHR stream, EGLenum attribute, EGLint *value);
-typedef EGLBoolean (EGLAPIENTRYP PFNEGLQUERYSTREAMU64KHRPROC)(EGLDisplay dpy, EGLStreamKHR stream, EGLenum attribute, EGLuint64KHR *value);
-#endif
-#endif
-
-#ifdef EGL_KHR_stream /* Requires KHR_stream extension */
-#ifndef EGL_KHR_stream_consumer_gltexture
-#define EGL_KHR_stream_consumer_gltexture 1
-#define EGL_CONSUMER_ACQUIRE_TIMEOUT_USEC_KHR	0x321E
-#ifdef EGL_EGLEXT_PROTOTYPES
-EGLAPI EGLBoolean EGLAPIENTRY eglStreamConsumerGLTextureExternalKHR(EGLDisplay dpy, EGLStreamKHR stream);
-EGLAPI EGLBoolean EGLAPIENTRY eglStreamConsumerAcquireKHR(EGLDisplay dpy, EGLStreamKHR stream);
-EGLAPI EGLBoolean EGLAPIENTRY eglStreamConsumerReleaseKHR(EGLDisplay dpy, EGLStreamKHR stream);
-#endif /* EGL_EGLEXT_PROTOTYPES */
-typedef EGLBoolean (EGLAPIENTRYP PFNEGLSTREAMCONSUMERGLTEXTUREEXTERNALKHRPROC)(EGLDisplay dpy, EGLStreamKHR stream);
-typedef EGLBoolean (EGLAPIENTRYP PFNEGLSTREAMCONSUMERACQUIREKHRPROC)(EGLDisplay dpy, EGLStreamKHR stream);
-typedef EGLBoolean (EGLAPIENTRYP PFNEGLSTREAMCONSUMERRELEASEKHRPROC)(EGLDisplay dpy, EGLStreamKHR stream);
-#endif
-#endif
-
-#ifdef EGL_KHR_stream /* Requires KHR_stream extension */
-#ifndef EGL_KHR_stream_producer_eglsurface
-#define EGL_KHR_stream_producer_eglsurface 1
-#define EGL_STREAM_BIT_KHR			0x0800
-#ifdef EGL_EGLEXT_PROTOTYPES
-EGLAPI EGLSurface EGLAPIENTRY eglCreateStreamProducerSurfaceKHR(EGLDisplay dpy, EGLConfig config, EGLStreamKHR stream, const EGLint *attrib_list);
-#endif /* EGL_EGLEXT_PROTOTYPES */
-typedef EGLSurface (EGLAPIENTRYP PFNEGLCREATESTREAMPRODUCERSURFACEKHRPROC)(EGLDisplay dpy, EGLConfig config, EGLStreamKHR stream, const EGLint *attrib_list);
-#endif
-#endif
-
-#ifdef EGL_KHR_stream /* Requires KHR_stream extension */
-#ifndef EGL_KHR_stream_producer_aldatalocator
-#define EGL_KHR_stream_producer_aldatalocator 1
-#endif
-#endif
-
-#ifdef EGL_KHR_stream /* Requires KHR_stream extension */
-#ifndef EGL_KHR_stream_fifo
-#define EGL_KHR_stream_fifo 1
-/* reuse EGLTimeKHR */
-#define EGL_STREAM_FIFO_LENGTH_KHR		0x31FC
-#define EGL_STREAM_TIME_NOW_KHR			0x31FD
-#define EGL_STREAM_TIME_CONSUMER_KHR		0x31FE
-#define EGL_STREAM_TIME_PRODUCER_KHR		0x31FF
-#ifdef EGL_EGLEXT_PROTOTYPES
-EGLAPI EGLBoolean EGLAPIENTRY eglQueryStreamTimeKHR(EGLDisplay dpy, EGLStreamKHR stream, EGLenum attribute, EGLTimeKHR *value);
-#endif /* EGL_EGLEXT_PROTOTYPES */
-typedef EGLBoolean (EGLAPIENTRYP PFNEGLQUERYSTREAMTIMEKHRPROC)(EGLDisplay dpy, EGLStreamKHR stream, EGLenum attribute, EGLTimeKHR *value);
-#endif
-#endif
-
-#ifndef EGL_EXT_create_context_robustness
-#define EGL_EXT_create_context_robustness 1
-#define EGL_CONTEXT_OPENGL_ROBUST_ACCESS_EXT	0x30BF
-#define EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_EXT 0x3138
-#define EGL_NO_RESET_NOTIFICATION_EXT		0x31BE
-#define EGL_LOSE_CONTEXT_ON_RESET_EXT		0x31BF
-#endif
-
-#ifndef EGL_ANGLE_d3d_share_handle_client_buffer
-#define EGL_ANGLE_d3d_share_handle_client_buffer 1
-/* reuse EGL_D3D_TEXTURE_2D_SHARE_HANDLE_ANGLE */
-#endif
-
-#ifndef EGL_KHR_create_context
-#define EGL_KHR_create_context 1
-#define EGL_CONTEXT_MAJOR_VERSION_KHR			    EGL_CONTEXT_CLIENT_VERSION
-#define EGL_CONTEXT_MINOR_VERSION_KHR			    0x30FB
-#define EGL_CONTEXT_FLAGS_KHR				    0x30FC
-#define EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR		    0x30FD
-#define EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_KHR  0x31BD
-#define EGL_NO_RESET_NOTIFICATION_KHR			    0x31BE
-#define EGL_LOSE_CONTEXT_ON_RESET_KHR			    0x31BF
-#define EGL_CONTEXT_OPENGL_DEBUG_BIT_KHR		    0x00000001
-#define EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE_BIT_KHR	    0x00000002
-#define EGL_CONTEXT_OPENGL_ROBUST_ACCESS_BIT_KHR	    0x00000004
-#define EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT_KHR		    0x00000001
-#define EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT_KHR    0x00000002
-#define EGL_OPENGL_ES3_BIT_KHR				    0x00000040
-#endif
-
-#ifndef EGL_KHR_surfaceless_context
-#define EGL_KHR_surfaceless_context 1
-/* No tokens/entry points, just relaxes an error condition */
-#endif
-
-#ifdef EGL_KHR_stream /* Requires KHR_stream extension */
-#ifndef EGL_KHR_stream_cross_process_fd
-#define EGL_KHR_stream_cross_process_fd 1
-typedef int EGLNativeFileDescriptorKHR;
-#define EGL_NO_FILE_DESCRIPTOR_KHR		((EGLNativeFileDescriptorKHR)(-1))
-#ifdef EGL_EGLEXT_PROTOTYPES
-EGLAPI EGLNativeFileDescriptorKHR EGLAPIENTRY eglGetStreamFileDescriptorKHR(EGLDisplay dpy, EGLStreamKHR stream);
-EGLAPI EGLStreamKHR EGLAPIENTRY eglCreateStreamFromFileDescriptorKHR(EGLDisplay dpy, EGLNativeFileDescriptorKHR file_descriptor);
-#endif /* EGL_EGLEXT_PROTOTYPES */
-typedef EGLNativeFileDescriptorKHR (EGLAPIENTRYP PFNEGLGETSTREAMFILEDESCRIPTORKHRPROC)(EGLDisplay dpy, EGLStreamKHR stream);
-typedef EGLStreamKHR (EGLAPIENTRYP PFNEGLCREATESTREAMFROMFILEDESCRIPTORKHRPROC)(EGLDisplay dpy, EGLNativeFileDescriptorKHR file_descriptor);
-#endif
-#endif
-
-#ifndef EGL_EXT_multiview_window
-#define EGL_EXT_multiview_window 1
-#define EGL_MULTIVIEW_VIEW_COUNT_EXT		0x3134
-#endif
-
-#ifndef EGL_KHR_wait_sync
-#define EGL_KHR_wait_sync 1
-#ifdef EGL_EGLEXT_PROTOTYPES
-EGLAPI EGLint EGLAPIENTRY eglWaitSyncKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint flags);
-#endif /* EGL_EGLEXT_PROTOTYPES */
-typedef EGLint (EGLAPIENTRYP PFNEGLWAITSYNCKHRPROC)(EGLDisplay dpy, EGLSyncKHR sync, EGLint flags);
-#endif
-
-#ifndef EGL_NV_post_convert_rounding
-#define EGL_NV_post_convert_rounding 1
-/* No tokens or entry points, just relaxes behavior of SwapBuffers */
-#endif
-
-#ifndef EGL_NV_native_query
-#define EGL_NV_native_query 1
-#ifdef EGL_EGLEXT_PROTOTYPES
-EGLAPI EGLBoolean EGLAPIENTRY eglQueryNativeDisplayNV( EGLDisplay dpy, EGLNativeDisplayType* display_id);
-EGLAPI EGLBoolean EGLAPIENTRY eglQueryNativeWindowNV( EGLDisplay dpy, EGLSurface surf, EGLNativeWindowType* window);
-EGLAPI EGLBoolean EGLAPIENTRY eglQueryNativePixmapNV( EGLDisplay dpy, EGLSurface surf, EGLNativePixmapType* pixmap);
-#endif /* EGL_EGLEXT_PROTOTYPES */
-typedef EGLBoolean (EGLAPIENTRYP PFNEGLQUERYNATIVEDISPLAYNVPROC)(EGLDisplay dpy, EGLNativeDisplayType *display_id);
-typedef EGLBoolean (EGLAPIENTRYP PFNEGLQUERYNATIVEWINDOWNVPROC)(EGLDisplay dpy, EGLSurface surf, EGLNativeWindowType *window);
-typedef EGLBoolean (EGLAPIENTRYP PFNEGLQUERYNATIVEPIXMAPNVPROC)(EGLDisplay dpy, EGLSurface surf, EGLNativePixmapType *pixmap);
-#endif
-
-#ifndef EGL_NV_3dvision_surface
-#define EGL_NV_3dvision_surface 1
-#define EGL_AUTO_STEREO_NV			0x3136
-#endif
-
-#ifndef EGL_ANDROID_framebuffer_target
-#define EGL_ANDROID_framebuffer_target 1
-#define EGL_FRAMEBUFFER_TARGET_ANDROID		0x3147
-#endif
-
-#ifndef EGL_ANDROID_blob_cache
-#define EGL_ANDROID_blob_cache 1
-typedef khronos_ssize_t EGLsizeiANDROID;
-typedef void (*EGLSetBlobFuncANDROID) (const void *key, EGLsizeiANDROID keySize, const void *value, EGLsizeiANDROID valueSize);
-typedef EGLsizeiANDROID (*EGLGetBlobFuncANDROID) (const void *key, EGLsizeiANDROID keySize, void *value, EGLsizeiANDROID valueSize);
-#ifdef EGL_EGLEXT_PROTOTYPES
-EGLAPI void EGLAPIENTRY eglSetBlobCacheFuncsANDROID(EGLDisplay dpy, EGLSetBlobFuncANDROID set, EGLGetBlobFuncANDROID get);
-#endif /* EGL_EGLEXT_PROTOTYPES */
-typedef void (EGLAPIENTRYP PFNEGLSETBLOBCACHEFUNCSANDROIDPROC)(EGLDisplay dpy, EGLSetBlobFuncANDROID set, EGLGetBlobFuncANDROID get);
-#endif
-
-#ifndef EGL_ANDROID_image_native_buffer
-#define EGL_ANDROID_image_native_buffer 1
-#define EGL_NATIVE_BUFFER_ANDROID		0x3140
-#endif
-
-#ifndef EGL_ANDROID_native_fence_sync
-#define EGL_ANDROID_native_fence_sync 1
-#define EGL_SYNC_NATIVE_FENCE_ANDROID		0x3144
-#define EGL_SYNC_NATIVE_FENCE_FD_ANDROID	0x3145
-#define EGL_SYNC_NATIVE_FENCE_SIGNALED_ANDROID	0x3146
-#define EGL_NO_NATIVE_FENCE_FD_ANDROID		-1
-#ifdef EGL_EGLEXT_PROTOTYPES
-EGLAPI EGLint EGLAPIENTRY eglDupNativeFenceFDANDROID( EGLDisplay dpy, EGLSyncKHR);
-#endif /* EGL_EGLEXT_PROTOTYPES */
-typedef EGLint (EGLAPIENTRYP PFNEGLDUPNATIVEFENCEFDANDROIDPROC)(EGLDisplay dpy, EGLSyncKHR);
-#endif
-
-#ifndef EGL_ANDROID_recordable
-#define EGL_ANDROID_recordable 1
-#define EGL_RECORDABLE_ANDROID			0x3142
-#endif
-
-#ifndef EGL_EXT_buffer_age
-#define EGL_EXT_buffer_age 1
-#define EGL_BUFFER_AGE_EXT			0x313D
-#endif
-
-#ifndef EGL_EXT_image_dma_buf_import
-#define EGL_EXT_image_dma_buf_import 1
-#define EGL_LINUX_DMA_BUF_EXT			0x3270
-#define EGL_LINUX_DRM_FOURCC_EXT		0x3271
-#define EGL_DMA_BUF_PLANE0_FD_EXT		0x3272
-#define EGL_DMA_BUF_PLANE0_OFFSET_EXT		0x3273
-#define EGL_DMA_BUF_PLANE0_PITCH_EXT		0x3274
-#define EGL_DMA_BUF_PLANE1_FD_EXT		0x3275
-#define EGL_DMA_BUF_PLANE1_OFFSET_EXT		0x3276
-#define EGL_DMA_BUF_PLANE1_PITCH_EXT		0x3277
-#define EGL_DMA_BUF_PLANE2_FD_EXT		0x3278
-#define EGL_DMA_BUF_PLANE2_OFFSET_EXT		0x3279
-#define EGL_DMA_BUF_PLANE2_PITCH_EXT		0x327A
-#define EGL_YUV_COLOR_SPACE_HINT_EXT		0x327B
-#define EGL_SAMPLE_RANGE_HINT_EXT		0x327C
-#define EGL_YUV_CHROMA_HORIZONTAL_SITING_HINT_EXT 0x327D
-#define EGL_YUV_CHROMA_VERTICAL_SITING_HINT_EXT 0x327E
-#define EGL_ITU_REC601_EXT			0x327F
-#define EGL_ITU_REC709_EXT			0x3280
-#define EGL_ITU_REC2020_EXT			0x3281
-#define EGL_YUV_FULL_RANGE_EXT			0x3282
-#define EGL_YUV_NARROW_RANGE_EXT		0x3283
-#define EGL_YUV_CHROMA_SITING_0_EXT		0x3284
-#define EGL_YUV_CHROMA_SITING_0_5_EXT		0x3285
-#endif
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* __eglext_h_ */

deps/GL/glxext.h

@@ -1,906 +0,0 @@
-#ifndef __glxext_h_
-#define __glxext_h_ 1
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/*
-** Copyright (c) 2013-2014 The Khronos Group Inc.
-**
-** Permission is hereby granted, free of charge, to any person obtaining a
-** copy of this software and/or associated documentation files (the
-** "Materials"), to deal in the Materials without restriction, including
-** without limitation the rights to use, copy, modify, merge, publish,
-** distribute, sublicense, and/or sell copies of the Materials, and to
-** permit persons to whom the Materials are furnished to do so, subject to
-** the following conditions:
-**
-** The above copyright notice and this permission notice shall be included
-** in all copies or substantial portions of the Materials.
-**
-** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
-*/
-/*
-** This header is generated from the Khronos OpenGL / OpenGL ES XML
-** API Registry. The current version of the Registry, generator scripts
-** used to make the header, and the header can be found at
-**   http://www.opengl.org/registry/
-**
-** Khronos $Revision: 27684 $ on $Date: 2014-08-11 01:21:35 -0700 (Mon, 11 Aug 2014) $
-*/
-
-#define GLX_GLXEXT_VERSION 20140810
-
-/* Generated C header for:
- * API: glx
- * Versions considered: .*
- * Versions emitted: 1\.[3-9]
- * Default extensions included: glx
- * Additional extensions included: _nomatch_^
- * Extensions removed: _nomatch_^
- */
-
-#ifndef GLX_VERSION_1_3
-#define GLX_VERSION_1_3 1
-typedef XID GLXContextID;
-typedef struct __GLXFBConfigRec *GLXFBConfig;
-typedef XID GLXWindow;
-typedef XID GLXPbuffer;
-#define GLX_WINDOW_BIT                    0x00000001
-#define GLX_PIXMAP_BIT                    0x00000002
-#define GLX_PBUFFER_BIT                   0x00000004
-#define GLX_RGBA_BIT                      0x00000001
-#define GLX_COLOR_INDEX_BIT               0x00000002
-#define GLX_PBUFFER_CLOBBER_MASK          0x08000000
-#define GLX_FRONT_LEFT_BUFFER_BIT         0x00000001
-#define GLX_FRONT_RIGHT_BUFFER_BIT        0x00000002
-#define GLX_BACK_LEFT_BUFFER_BIT          0x00000004
-#define GLX_BACK_RIGHT_BUFFER_BIT         0x00000008
-#define GLX_AUX_BUFFERS_BIT               0x00000010
-#define GLX_DEPTH_BUFFER_BIT              0x00000020
-#define GLX_STENCIL_BUFFER_BIT            0x00000040
-#define GLX_ACCUM_BUFFER_BIT              0x00000080
-#define GLX_CONFIG_CAVEAT                 0x20
-#define GLX_X_VISUAL_TYPE                 0x22
-#define GLX_TRANSPARENT_TYPE              0x23
-#define GLX_TRANSPARENT_INDEX_VALUE       0x24
-#define GLX_TRANSPARENT_RED_VALUE         0x25
-#define GLX_TRANSPARENT_GREEN_VALUE       0x26
-#define GLX_TRANSPARENT_BLUE_VALUE        0x27
-#define GLX_TRANSPARENT_ALPHA_VALUE       0x28
-#define GLX_DONT_CARE                     0xFFFFFFFF
-#define GLX_NONE                          0x8000
-#define GLX_SLOW_CONFIG                   0x8001
-#define GLX_TRUE_COLOR                    0x8002
-#define GLX_DIRECT_COLOR                  0x8003
-#define GLX_PSEUDO_COLOR                  0x8004
-#define GLX_STATIC_COLOR                  0x8005
-#define GLX_GRAY_SCALE                    0x8006
-#define GLX_STATIC_GRAY                   0x8007
-#define GLX_TRANSPARENT_RGB               0x8008
-#define GLX_TRANSPARENT_INDEX             0x8009
-#define GLX_VISUAL_ID                     0x800B
-#define GLX_SCREEN                        0x800C
-#define GLX_NON_CONFORMANT_CONFIG         0x800D
-#define GLX_DRAWABLE_TYPE                 0x8010
-#define GLX_RENDER_TYPE                   0x8011
-#define GLX_X_RENDERABLE                  0x8012
-#define GLX_FBCONFIG_ID                   0x8013
-#define GLX_RGBA_TYPE                     0x8014
-#define GLX_COLOR_INDEX_TYPE              0x8015
-#define GLX_MAX_PBUFFER_WIDTH             0x8016
-#define GLX_MAX_PBUFFER_HEIGHT            0x8017
-#define GLX_MAX_PBUFFER_PIXELS            0x8018
-#define GLX_PRESERVED_CONTENTS            0x801B
-#define GLX_LARGEST_PBUFFER               0x801C
-#define GLX_WIDTH                         0x801D
-#define GLX_HEIGHT                        0x801E
-#define GLX_EVENT_MASK                    0x801F
-#define GLX_DAMAGED                       0x8020
-#define GLX_SAVED                         0x8021
-#define GLX_WINDOW                        0x8022
-#define GLX_PBUFFER                       0x8023
-#define GLX_PBUFFER_HEIGHT                0x8040
-#define GLX_PBUFFER_WIDTH                 0x8041
-typedef GLXFBConfig *( *PFNGLXGETFBCONFIGSPROC) (Display *dpy, int screen, int *nelements);
-typedef GLXFBConfig *( *PFNGLXCHOOSEFBCONFIGPROC) (Display *dpy, int screen, const int *attrib_list, int *nelements);
-typedef int ( *PFNGLXGETFBCONFIGATTRIBPROC) (Display *dpy, GLXFBConfig config, int attribute, int *value);
-typedef XVisualInfo *( *PFNGLXGETVISUALFROMFBCONFIGPROC) (Display *dpy, GLXFBConfig config);
-typedef GLXWindow ( *PFNGLXCREATEWINDOWPROC) (Display *dpy, GLXFBConfig config, Window win, const int *attrib_list);
-typedef void ( *PFNGLXDESTROYWINDOWPROC) (Display *dpy, GLXWindow win);
-typedef GLXPixmap ( *PFNGLXCREATEPIXMAPPROC) (Display *dpy, GLXFBConfig config, Pixmap pixmap, const int *attrib_list);
-typedef void ( *PFNGLXDESTROYPIXMAPPROC) (Display *dpy, GLXPixmap pixmap);
-typedef GLXPbuffer ( *PFNGLXCREATEPBUFFERPROC) (Display *dpy, GLXFBConfig config, const int *attrib_list);
-typedef void ( *PFNGLXDESTROYPBUFFERPROC) (Display *dpy, GLXPbuffer pbuf);
-typedef void ( *PFNGLXQUERYDRAWABLEPROC) (Display *dpy, GLXDrawable draw, int attribute, unsigned int *value);
-typedef GLXContext ( *PFNGLXCREATENEWCONTEXTPROC) (Display *dpy, GLXFBConfig config, int render_type, GLXContext share_list, Bool direct);
-typedef Bool ( *PFNGLXMAKECONTEXTCURRENTPROC) (Display *dpy, GLXDrawable draw, GLXDrawable read, GLXContext ctx);
-typedef GLXDrawable ( *PFNGLXGETCURRENTREADDRAWABLEPROC) (void);
-typedef int ( *PFNGLXQUERYCONTEXTPROC) (Display *dpy, GLXContext ctx, int attribute, int *value);
-typedef void ( *PFNGLXSELECTEVENTPROC) (Display *dpy, GLXDrawable draw, unsigned long event_mask);
-typedef void ( *PFNGLXGETSELECTEDEVENTPROC) (Display *dpy, GLXDrawable draw, unsigned long *event_mask);
-#ifdef GLX_GLXEXT_PROTOTYPES
-GLXFBConfig *glXGetFBConfigs (Display *dpy, int screen, int *nelements);
-GLXFBConfig *glXChooseFBConfig (Display *dpy, int screen, const int *attrib_list, int *nelements);
-int glXGetFBConfigAttrib (Display *dpy, GLXFBConfig config, int attribute, int *value);
-XVisualInfo *glXGetVisualFromFBConfig (Display *dpy, GLXFBConfig config);
-GLXWindow glXCreateWindow (Display *dpy, GLXFBConfig config, Window win, const int *attrib_list);
-void glXDestroyWindow (Display *dpy, GLXWindow win);
-GLXPixmap glXCreatePixmap (Display *dpy, GLXFBConfig config, Pixmap pixmap, const int *attrib_list);
-void glXDestroyPixmap (Display *dpy, GLXPixmap pixmap);
-GLXPbuffer glXCreatePbuffer (Display *dpy, GLXFBConfig config, const int *attrib_list);
-void glXDestroyPbuffer (Display *dpy, GLXPbuffer pbuf);
-void glXQueryDrawable (Display *dpy, GLXDrawable draw, int attribute, unsigned int *value);
-GLXContext glXCreateNewContext (Display *dpy, GLXFBConfig config, int render_type, GLXContext share_list, Bool direct);
-Bool glXMakeContextCurrent (Display *dpy, GLXDrawable draw, GLXDrawable read, GLXContext ctx);
-GLXDrawable glXGetCurrentReadDrawable (void);
-int glXQueryContext (Display *dpy, GLXContext ctx, int attribute, int *value);
-void glXSelectEvent (Display *dpy, GLXDrawable draw, unsigned long event_mask);
-void glXGetSelectedEvent (Display *dpy, GLXDrawable draw, unsigned long *event_mask);
-#endif
-#endif /* GLX_VERSION_1_3 */
-
-#ifndef GLX_VERSION_1_4
-#define GLX_VERSION_1_4 1
-typedef void ( *__GLXextFuncPtr)(void);
-#define GLX_SAMPLE_BUFFERS                100000
-#define GLX_SAMPLES                       100001
-typedef __GLXextFuncPtr ( *PFNGLXGETPROCADDRESSPROC) (const GLubyte *procName);
-#ifdef GLX_GLXEXT_PROTOTYPES
-__GLXextFuncPtr glXGetProcAddress (const GLubyte *procName);
-#endif
-#endif /* GLX_VERSION_1_4 */
-
-#ifndef GLX_ARB_context_flush_control
-#define GLX_ARB_context_flush_control 1
-#define GLX_CONTEXT_RELEASE_BEHAVIOR_ARB  0x2097
-#define GLX_CONTEXT_RELEASE_BEHAVIOR_NONE_ARB 0
-#define GLX_CONTEXT_RELEASE_BEHAVIOR_FLUSH_ARB 0x2098
-#endif /* GLX_ARB_context_flush_control */
-
-#ifndef GLX_ARB_create_context
-#define GLX_ARB_create_context 1
-#define GLX_CONTEXT_DEBUG_BIT_ARB         0x00000001
-#define GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB 0x00000002
-#define GLX_CONTEXT_MAJOR_VERSION_ARB     0x2091
-#define GLX_CONTEXT_MINOR_VERSION_ARB     0x2092
-#define GLX_CONTEXT_FLAGS_ARB             0x2094
-typedef GLXContext ( *PFNGLXCREATECONTEXTATTRIBSARBPROC) (Display *dpy, GLXFBConfig config, GLXContext share_context, Bool direct, const int *attrib_list);
-#ifdef GLX_GLXEXT_PROTOTYPES
-GLXContext glXCreateContextAttribsARB (Display *dpy, GLXFBConfig config, GLXContext share_context, Bool direct, const int *attrib_list);
-#endif
-#endif /* GLX_ARB_create_context */
-
-#ifndef GLX_ARB_create_context_profile
-#define GLX_ARB_create_context_profile 1
-#define GLX_CONTEXT_CORE_PROFILE_BIT_ARB  0x00000001
-#define GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB 0x00000002
-#define GLX_CONTEXT_PROFILE_MASK_ARB      0x9126
-#endif /* GLX_ARB_create_context_profile */
-
-#ifndef GLX_ARB_create_context_robustness
-#define GLX_ARB_create_context_robustness 1
-#define GLX_CONTEXT_ROBUST_ACCESS_BIT_ARB 0x00000004
-#define GLX_LOSE_CONTEXT_ON_RESET_ARB     0x8252
-#define GLX_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB 0x8256
-#define GLX_NO_RESET_NOTIFICATION_ARB     0x8261
-#endif /* GLX_ARB_create_context_robustness */
-
-#ifndef GLX_ARB_fbconfig_float
-#define GLX_ARB_fbconfig_float 1
-#define GLX_RGBA_FLOAT_TYPE_ARB           0x20B9
-#define GLX_RGBA_FLOAT_BIT_ARB            0x00000004
-#endif /* GLX_ARB_fbconfig_float */
-
-#ifndef GLX_ARB_framebuffer_sRGB
-#define GLX_ARB_framebuffer_sRGB 1
-#define GLX_FRAMEBUFFER_SRGB_CAPABLE_ARB  0x20B2
-#endif /* GLX_ARB_framebuffer_sRGB */
-
-#ifndef GLX_ARB_get_proc_address
-#define GLX_ARB_get_proc_address 1
-typedef __GLXextFuncPtr ( *PFNGLXGETPROCADDRESSARBPROC) (const GLubyte *procName);
-#ifdef GLX_GLXEXT_PROTOTYPES
-__GLXextFuncPtr glXGetProcAddressARB (const GLubyte *procName);
-#endif
-#endif /* GLX_ARB_get_proc_address */
-
-#ifndef GLX_ARB_multisample
-#define GLX_ARB_multisample 1
-#define GLX_SAMPLE_BUFFERS_ARB            100000
-#define GLX_SAMPLES_ARB                   100001
-#endif /* GLX_ARB_multisample */
-
-#ifndef GLX_ARB_robustness_application_isolation
-#define GLX_ARB_robustness_application_isolation 1
-#define GLX_CONTEXT_RESET_ISOLATION_BIT_ARB 0x00000008
-#endif /* GLX_ARB_robustness_application_isolation */
-
-#ifndef GLX_ARB_robustness_share_group_isolation
-#define GLX_ARB_robustness_share_group_isolation 1
-#endif /* GLX_ARB_robustness_share_group_isolation */
-
-#ifndef GLX_ARB_vertex_buffer_object
-#define GLX_ARB_vertex_buffer_object 1
-#define GLX_CONTEXT_ALLOW_BUFFER_BYTE_ORDER_MISMATCH_ARB 0x2095
-#endif /* GLX_ARB_vertex_buffer_object */
-
-#ifndef GLX_3DFX_multisample
-#define GLX_3DFX_multisample 1
-#define GLX_SAMPLE_BUFFERS_3DFX           0x8050
-#define GLX_SAMPLES_3DFX                  0x8051
-#endif /* GLX_3DFX_multisample */
-
-#ifndef GLX_AMD_gpu_association
-#define GLX_AMD_gpu_association 1
-#define GLX_GPU_VENDOR_AMD                0x1F00
-#define GLX_GPU_RENDERER_STRING_AMD       0x1F01
-#define GLX_GPU_OPENGL_VERSION_STRING_AMD 0x1F02
-#define GLX_GPU_FASTEST_TARGET_GPUS_AMD   0x21A2
-#define GLX_GPU_RAM_AMD                   0x21A3
-#define GLX_GPU_CLOCK_AMD                 0x21A4
-#define GLX_GPU_NUM_PIPES_AMD             0x21A5
-#define GLX_GPU_NUM_SIMD_AMD              0x21A6
-#define GLX_GPU_NUM_RB_AMD                0x21A7
-#define GLX_GPU_NUM_SPI_AMD               0x21A8
-#endif /* GLX_AMD_gpu_association */
-
-#ifndef GLX_EXT_buffer_age
-#define GLX_EXT_buffer_age 1
-#define GLX_BACK_BUFFER_AGE_EXT           0x20F4
-#endif /* GLX_EXT_buffer_age */
-
-#ifndef GLX_EXT_create_context_es2_profile
-#define GLX_EXT_create_context_es2_profile 1
-#define GLX_CONTEXT_ES2_PROFILE_BIT_EXT   0x00000004
-#endif /* GLX_EXT_create_context_es2_profile */
-
-#ifndef GLX_EXT_create_context_es_profile
-#define GLX_EXT_create_context_es_profile 1
-#define GLX_CONTEXT_ES_PROFILE_BIT_EXT    0x00000004
-#endif /* GLX_EXT_create_context_es_profile */
-
-#ifndef GLX_EXT_fbconfig_packed_float
-#define GLX_EXT_fbconfig_packed_float 1
-#define GLX_RGBA_UNSIGNED_FLOAT_TYPE_EXT  0x20B1
-#define GLX_RGBA_UNSIGNED_FLOAT_BIT_EXT   0x00000008
-#endif /* GLX_EXT_fbconfig_packed_float */
-
-#ifndef GLX_EXT_framebuffer_sRGB
-#define GLX_EXT_framebuffer_sRGB 1
-#define GLX_FRAMEBUFFER_SRGB_CAPABLE_EXT  0x20B2
-#endif /* GLX_EXT_framebuffer_sRGB */
-
-#ifndef GLX_EXT_import_context
-#define GLX_EXT_import_context 1
-#define GLX_SHARE_CONTEXT_EXT             0x800A
-#define GLX_VISUAL_ID_EXT                 0x800B
-#define GLX_SCREEN_EXT                    0x800C
-typedef Display *( *PFNGLXGETCURRENTDISPLAYEXTPROC) (void);
-typedef int ( *PFNGLXQUERYCONTEXTINFOEXTPROC) (Display *dpy, GLXContext context, int attribute, int *value);
-typedef GLXContextID ( *PFNGLXGETCONTEXTIDEXTPROC) (const GLXContext context);
-typedef GLXContext ( *PFNGLXIMPORTCONTEXTEXTPROC) (Display *dpy, GLXContextID contextID);
-typedef void ( *PFNGLXFREECONTEXTEXTPROC) (Display *dpy, GLXContext context);
-#ifdef GLX_GLXEXT_PROTOTYPES
-Display *glXGetCurrentDisplayEXT (void);
-int glXQueryContextInfoEXT (Display *dpy, GLXContext context, int attribute, int *value);
-GLXContextID glXGetContextIDEXT (const GLXContext context);
-GLXContext glXImportContextEXT (Display *dpy, GLXContextID contextID);
-void glXFreeContextEXT (Display *dpy, GLXContext context);
-#endif
-#endif /* GLX_EXT_import_context */
-
-#ifndef GLX_EXT_stereo_tree
-#define GLX_EXT_stereo_tree 1
-typedef struct {
-    int type;
-    unsigned long serial;
-    Bool send_event;
-    Display *display;
-    int extension;
-    int evtype;
-    GLXDrawable window;
-    Bool stereo_tree;
-} GLXStereoNotifyEventEXT;
-#define GLX_STEREO_TREE_EXT               0x20F5
-#define GLX_STEREO_NOTIFY_MASK_EXT        0x00000001
-#define GLX_STEREO_NOTIFY_EXT             0x00000000
-#endif /* GLX_EXT_stereo_tree */
-
-#ifndef GLX_EXT_swap_control
-#define GLX_EXT_swap_control 1
-#define GLX_SWAP_INTERVAL_EXT             0x20F1
-#define GLX_MAX_SWAP_INTERVAL_EXT         0x20F2
-typedef void ( *PFNGLXSWAPINTERVALEXTPROC) (Display *dpy, GLXDrawable drawable, int interval);
-#ifdef GLX_GLXEXT_PROTOTYPES
-void glXSwapIntervalEXT (Display *dpy, GLXDrawable drawable, int interval);
-#endif
-#endif /* GLX_EXT_swap_control */
-
-#ifndef GLX_EXT_swap_control_tear
-#define GLX_EXT_swap_control_tear 1
-#define GLX_LATE_SWAPS_TEAR_EXT           0x20F3
-#endif /* GLX_EXT_swap_control_tear */
-
-#ifndef GLX_EXT_texture_from_pixmap
-#define GLX_EXT_texture_from_pixmap 1
-#define GLX_TEXTURE_1D_BIT_EXT            0x00000001
-#define GLX_TEXTURE_2D_BIT_EXT            0x00000002
-#define GLX_TEXTURE_RECTANGLE_BIT_EXT     0x00000004
-#define GLX_BIND_TO_TEXTURE_RGB_EXT       0x20D0
-#define GLX_BIND_TO_TEXTURE_RGBA_EXT      0x20D1
-#define GLX_BIND_TO_MIPMAP_TEXTURE_EXT    0x20D2
-#define GLX_BIND_TO_TEXTURE_TARGETS_EXT   0x20D3
-#define GLX_Y_INVERTED_EXT                0x20D4
-#define GLX_TEXTURE_FORMAT_EXT            0x20D5
-#define GLX_TEXTURE_TARGET_EXT            0x20D6
-#define GLX_MIPMAP_TEXTURE_EXT            0x20D7
-#define GLX_TEXTURE_FORMAT_NONE_EXT       0x20D8
-#define GLX_TEXTURE_FORMAT_RGB_EXT        0x20D9
-#define GLX_TEXTURE_FORMAT_RGBA_EXT       0x20DA
-#define GLX_TEXTURE_1D_EXT                0x20DB
-#define GLX_TEXTURE_2D_EXT                0x20DC
-#define GLX_TEXTURE_RECTANGLE_EXT         0x20DD
-#define GLX_FRONT_LEFT_EXT                0x20DE
-#define GLX_FRONT_RIGHT_EXT               0x20DF
-#define GLX_BACK_LEFT_EXT                 0x20E0
-#define GLX_BACK_RIGHT_EXT                0x20E1
-#define GLX_FRONT_EXT                     0x20DE
-#define GLX_BACK_EXT                      0x20E0
-#define GLX_AUX0_EXT                      0x20E2
-#define GLX_AUX1_EXT                      0x20E3
-#define GLX_AUX2_EXT                      0x20E4
-#define GLX_AUX3_EXT                      0x20E5
-#define GLX_AUX4_EXT                      0x20E6
-#define GLX_AUX5_EXT                      0x20E7
-#define GLX_AUX6_EXT                      0x20E8
-#define GLX_AUX7_EXT                      0x20E9
-#define GLX_AUX8_EXT                      0x20EA
-#define GLX_AUX9_EXT                      0x20EB
-typedef void ( *PFNGLXBINDTEXIMAGEEXTPROC) (Display *dpy, GLXDrawable drawable, int buffer, const int *attrib_list);
-typedef void ( *PFNGLXRELEASETEXIMAGEEXTPROC) (Display *dpy, GLXDrawable drawable, int buffer);
-#ifdef GLX_GLXEXT_PROTOTYPES
-void glXBindTexImageEXT (Display *dpy, GLXDrawable drawable, int buffer, const int *attrib_list);
-void glXReleaseTexImageEXT (Display *dpy, GLXDrawable drawable, int buffer);
-#endif
-#endif /* GLX_EXT_texture_from_pixmap */
-
-#ifndef GLX_EXT_visual_info
-#define GLX_EXT_visual_info 1
-#define GLX_X_VISUAL_TYPE_EXT             0x22
-#define GLX_TRANSPARENT_TYPE_EXT          0x23
-#define GLX_TRANSPARENT_INDEX_VALUE_EXT   0x24
-#define GLX_TRANSPARENT_RED_VALUE_EXT     0x25
-#define GLX_TRANSPARENT_GREEN_VALUE_EXT   0x26
-#define GLX_TRANSPARENT_BLUE_VALUE_EXT    0x27
-#define GLX_TRANSPARENT_ALPHA_VALUE_EXT   0x28
-#define GLX_NONE_EXT                      0x8000
-#define GLX_TRUE_COLOR_EXT                0x8002
-#define GLX_DIRECT_COLOR_EXT              0x8003
-#define GLX_PSEUDO_COLOR_EXT              0x8004
-#define GLX_STATIC_COLOR_EXT              0x8005
-#define GLX_GRAY_SCALE_EXT                0x8006
-#define GLX_STATIC_GRAY_EXT               0x8007
-#define GLX_TRANSPARENT_RGB_EXT           0x8008
-#define GLX_TRANSPARENT_INDEX_EXT         0x8009
-#endif /* GLX_EXT_visual_info */
-
-#ifndef GLX_EXT_visual_rating
-#define GLX_EXT_visual_rating 1
-#define GLX_VISUAL_CAVEAT_EXT             0x20
-#define GLX_SLOW_VISUAL_EXT               0x8001
-#define GLX_NON_CONFORMANT_VISUAL_EXT     0x800D
-#endif /* GLX_EXT_visual_rating */
-
-#ifndef GLX_INTEL_swap_event
-#define GLX_INTEL_swap_event 1
-#define GLX_BUFFER_SWAP_COMPLETE_INTEL_MASK 0x04000000
-#define GLX_EXCHANGE_COMPLETE_INTEL       0x8180
-#define GLX_COPY_COMPLETE_INTEL           0x8181
-#define GLX_FLIP_COMPLETE_INTEL           0x8182
-#endif /* GLX_INTEL_swap_event */
-
-#ifndef GLX_MESA_agp_offset
-#define GLX_MESA_agp_offset 1
-typedef unsigned int ( *PFNGLXGETAGPOFFSETMESAPROC) (const void *pointer);
-#ifdef GLX_GLXEXT_PROTOTYPES
-unsigned int glXGetAGPOffsetMESA (const void *pointer);
-#endif
-#endif /* GLX_MESA_agp_offset */
-
-#ifndef GLX_MESA_copy_sub_buffer
-#define GLX_MESA_copy_sub_buffer 1
-typedef void ( *PFNGLXCOPYSUBBUFFERMESAPROC) (Display *dpy, GLXDrawable drawable, int x, int y, int width, int height);
-#ifdef GLX_GLXEXT_PROTOTYPES
-void glXCopySubBufferMESA (Display *dpy, GLXDrawable drawable, int x, int y, int width, int height);
-#endif
-#endif /* GLX_MESA_copy_sub_buffer */
-
-#ifndef GLX_MESA_pixmap_colormap
-#define GLX_MESA_pixmap_colormap 1
-typedef GLXPixmap ( *PFNGLXCREATEGLXPIXMAPMESAPROC) (Display *dpy, XVisualInfo *visual, Pixmap pixmap, Colormap cmap);
-#ifdef GLX_GLXEXT_PROTOTYPES
-GLXPixmap glXCreateGLXPixmapMESA (Display *dpy, XVisualInfo *visual, Pixmap pixmap, Colormap cmap);
-#endif
-#endif /* GLX_MESA_pixmap_colormap */
-
-#ifndef GLX_MESA_query_renderer
-#define GLX_MESA_query_renderer 1
-#define GLX_RENDERER_VENDOR_ID_MESA       0x8183
-#define GLX_RENDERER_DEVICE_ID_MESA       0x8184
-#define GLX_RENDERER_VERSION_MESA         0x8185
-#define GLX_RENDERER_ACCELERATED_MESA     0x8186
-#define GLX_RENDERER_VIDEO_MEMORY_MESA    0x8187
-#define GLX_RENDERER_UNIFIED_MEMORY_ARCHITECTURE_MESA 0x8188
-#define GLX_RENDERER_PREFERRED_PROFILE_MESA 0x8189
-#define GLX_RENDERER_OPENGL_CORE_PROFILE_VERSION_MESA 0x818A
-#define GLX_RENDERER_OPENGL_COMPATIBILITY_PROFILE_VERSION_MESA 0x818B
-#define GLX_RENDERER_OPENGL_ES_PROFILE_VERSION_MESA 0x818C
-#define GLX_RENDERER_OPENGL_ES2_PROFILE_VERSION_MESA 0x818D
-#define GLX_RENDERER_ID_MESA              0x818E
-typedef Bool ( *PFNGLXQUERYCURRENTRENDERERINTEGERMESAPROC) (int attribute, unsigned int *value);
-typedef const char *( *PFNGLXQUERYCURRENTRENDERERSTRINGMESAPROC) (int attribute);
-typedef Bool ( *PFNGLXQUERYRENDERERINTEGERMESAPROC) (Display *dpy, int screen, int renderer, int attribute, unsigned int *value);
-typedef const char *( *PFNGLXQUERYRENDERERSTRINGMESAPROC) (Display *dpy, int screen, int renderer, int attribute);
-#ifdef GLX_GLXEXT_PROTOTYPES
-Bool glXQueryCurrentRendererIntegerMESA (int attribute, unsigned int *value);
-const char *glXQueryCurrentRendererStringMESA (int attribute);
-Bool glXQueryRendererIntegerMESA (Display *dpy, int screen, int renderer, int attribute, unsigned int *value);
-const char *glXQueryRendererStringMESA (Display *dpy, int screen, int renderer, int attribute);
-#endif
-#endif /* GLX_MESA_query_renderer */
-
-#ifndef GLX_MESA_release_buffers
-#define GLX_MESA_release_buffers 1
-typedef Bool ( *PFNGLXRELEASEBUFFERSMESAPROC) (Display *dpy, GLXDrawable drawable);
-#ifdef GLX_GLXEXT_PROTOTYPES
-Bool glXReleaseBuffersMESA (Display *dpy, GLXDrawable drawable);
-#endif
-#endif /* GLX_MESA_release_buffers */
-
-#ifndef GLX_MESA_set_3dfx_mode
-#define GLX_MESA_set_3dfx_mode 1
-#define GLX_3DFX_WINDOW_MODE_MESA         0x1
-#define GLX_3DFX_FULLSCREEN_MODE_MESA     0x2
-typedef Bool ( *PFNGLXSET3DFXMODEMESAPROC) (int mode);
-#ifdef GLX_GLXEXT_PROTOTYPES
-Bool glXSet3DfxModeMESA (int mode);
-#endif
-#endif /* GLX_MESA_set_3dfx_mode */
-
-#ifndef GLX_NV_copy_buffer
-#define GLX_NV_copy_buffer 1
-typedef void ( *PFNGLXCOPYBUFFERSUBDATANVPROC) (Display *dpy, GLXContext readCtx, GLXContext writeCtx, GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size);
-typedef void ( *PFNGLXNAMEDCOPYBUFFERSUBDATANVPROC) (Display *dpy, GLXContext readCtx, GLXContext writeCtx, GLuint readBuffer, GLuint writeBuffer, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size);
-#ifdef GLX_GLXEXT_PROTOTYPES
-void glXCopyBufferSubDataNV (Display *dpy, GLXContext readCtx, GLXContext writeCtx, GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size);
-void glXNamedCopyBufferSubDataNV (Display *dpy, GLXContext readCtx, GLXContext writeCtx, GLuint readBuffer, GLuint writeBuffer, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size);
-#endif
-#endif /* GLX_NV_copy_buffer */
-
-#ifndef GLX_NV_copy_image
-#define GLX_NV_copy_image 1
-typedef void ( *PFNGLXCOPYIMAGESUBDATANVPROC) (Display *dpy, GLXContext srcCtx, GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLXContext dstCtx, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei width, GLsizei height, GLsizei depth);
-#ifdef GLX_GLXEXT_PROTOTYPES
-void glXCopyImageSubDataNV (Display *dpy, GLXContext srcCtx, GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLXContext dstCtx, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei width, GLsizei height, GLsizei depth);
-#endif
-#endif /* GLX_NV_copy_image */
-
-#ifndef GLX_NV_delay_before_swap
-#define GLX_NV_delay_before_swap 1
-typedef Bool ( *PFNGLXDELAYBEFORESWAPNVPROC) (Display *dpy, GLXDrawable drawable, GLfloat seconds);
-#ifdef GLX_GLXEXT_PROTOTYPES
-Bool glXDelayBeforeSwapNV (Display *dpy, GLXDrawable drawable, GLfloat seconds);
-#endif
-#endif /* GLX_NV_delay_before_swap */
-
-#ifndef GLX_NV_float_buffer
-#define GLX_NV_float_buffer 1
-#define GLX_FLOAT_COMPONENTS_NV           0x20B0
-#endif /* GLX_NV_float_buffer */
-
-#ifndef GLX_NV_multisample_coverage
-#define GLX_NV_multisample_coverage 1
-#define GLX_COVERAGE_SAMPLES_NV           100001
-#define GLX_COLOR_SAMPLES_NV              0x20B3
-#endif /* GLX_NV_multisample_coverage */
-
-#ifndef GLX_NV_present_video
-#define GLX_NV_present_video 1
-#define GLX_NUM_VIDEO_SLOTS_NV            0x20F0
-typedef unsigned int *( *PFNGLXENUMERATEVIDEODEVICESNVPROC) (Display *dpy, int screen, int *nelements);
-typedef int ( *PFNGLXBINDVIDEODEVICENVPROC) (Display *dpy, unsigned int video_slot, unsigned int video_device, const int *attrib_list);
-#ifdef GLX_GLXEXT_PROTOTYPES
-unsigned int *glXEnumerateVideoDevicesNV (Display *dpy, int screen, int *nelements);
-int glXBindVideoDeviceNV (Display *dpy, unsigned int video_slot, unsigned int video_device, const int *attrib_list);
-#endif
-#endif /* GLX_NV_present_video */
-
-#ifndef GLX_NV_swap_group
-#define GLX_NV_swap_group 1
-typedef Bool ( *PFNGLXJOINSWAPGROUPNVPROC) (Display *dpy, GLXDrawable drawable, GLuint group);
-typedef Bool ( *PFNGLXBINDSWAPBARRIERNVPROC) (Display *dpy, GLuint group, GLuint barrier);
-typedef Bool ( *PFNGLXQUERYSWAPGROUPNVPROC) (Display *dpy, GLXDrawable drawable, GLuint *group, GLuint *barrier);
-typedef Bool ( *PFNGLXQUERYMAXSWAPGROUPSNVPROC) (Display *dpy, int screen, GLuint *maxGroups, GLuint *maxBarriers);
-typedef Bool ( *PFNGLXQUERYFRAMECOUNTNVPROC) (Display *dpy, int screen, GLuint *count);
-typedef Bool ( *PFNGLXRESETFRAMECOUNTNVPROC) (Display *dpy, int screen);
-#ifdef GLX_GLXEXT_PROTOTYPES
-Bool glXJoinSwapGroupNV (Display *dpy, GLXDrawable drawable, GLuint group);
-Bool glXBindSwapBarrierNV (Display *dpy, GLuint group, GLuint barrier);
-Bool glXQuerySwapGroupNV (Display *dpy, GLXDrawable drawable, GLuint *group, GLuint *barrier);
-Bool glXQueryMaxSwapGroupsNV (Display *dpy, int screen, GLuint *maxGroups, GLuint *maxBarriers);
-Bool glXQueryFrameCountNV (Display *dpy, int screen, GLuint *count);
-Bool glXResetFrameCountNV (Display *dpy, int screen);
-#endif
-#endif /* GLX_NV_swap_group */
-
-#ifndef GLX_NV_video_capture
-#define GLX_NV_video_capture 1
-typedef XID GLXVideoCaptureDeviceNV;
-#define GLX_DEVICE_ID_NV                  0x20CD
-#define GLX_UNIQUE_ID_NV                  0x20CE
-#define GLX_NUM_VIDEO_CAPTURE_SLOTS_NV    0x20CF
-typedef int ( *PFNGLXBINDVIDEOCAPTUREDEVICENVPROC) (Display *dpy, unsigned int video_capture_slot, GLXVideoCaptureDeviceNV device);
-typedef GLXVideoCaptureDeviceNV *( *PFNGLXENUMERATEVIDEOCAPTUREDEVICESNVPROC) (Display *dpy, int screen, int *nelements);
-typedef void ( *PFNGLXLOCKVIDEOCAPTUREDEVICENVPROC) (Display *dpy, GLXVideoCaptureDeviceNV device);
-typedef int ( *PFNGLXQUERYVIDEOCAPTUREDEVICENVPROC) (Display *dpy, GLXVideoCaptureDeviceNV device, int attribute, int *value);
-typedef void ( *PFNGLXRELEASEVIDEOCAPTUREDEVICENVPROC) (Display *dpy, GLXVideoCaptureDeviceNV device);
-#ifdef GLX_GLXEXT_PROTOTYPES
-int glXBindVideoCaptureDeviceNV (Display *dpy, unsigned int video_capture_slot, GLXVideoCaptureDeviceNV device);
-GLXVideoCaptureDeviceNV *glXEnumerateVideoCaptureDevicesNV (Display *dpy, int screen, int *nelements);
-void glXLockVideoCaptureDeviceNV (Display *dpy, GLXVideoCaptureDeviceNV device);
-int glXQueryVideoCaptureDeviceNV (Display *dpy, GLXVideoCaptureDeviceNV device, int attribute, int *value);
-void glXReleaseVideoCaptureDeviceNV (Display *dpy, GLXVideoCaptureDeviceNV device);
-#endif
-#endif /* GLX_NV_video_capture */
-
-#ifndef GLX_NV_video_out
-#define GLX_NV_video_out 1
-typedef unsigned int GLXVideoDeviceNV;
-#define GLX_VIDEO_OUT_COLOR_NV            0x20C3
-#define GLX_VIDEO_OUT_ALPHA_NV            0x20C4
-#define GLX_VIDEO_OUT_DEPTH_NV            0x20C5
-#define GLX_VIDEO_OUT_COLOR_AND_ALPHA_NV  0x20C6
-#define GLX_VIDEO_OUT_COLOR_AND_DEPTH_NV  0x20C7
-#define GLX_VIDEO_OUT_FRAME_NV            0x20C8
-#define GLX_VIDEO_OUT_FIELD_1_NV          0x20C9
-#define GLX_VIDEO_OUT_FIELD_2_NV          0x20CA
-#define GLX_VIDEO_OUT_STACKED_FIELDS_1_2_NV 0x20CB
-#define GLX_VIDEO_OUT_STACKED_FIELDS_2_1_NV 0x20CC
-typedef int ( *PFNGLXGETVIDEODEVICENVPROC) (Display *dpy, int screen, int numVideoDevices, GLXVideoDeviceNV *pVideoDevice);
-typedef int ( *PFNGLXRELEASEVIDEODEVICENVPROC) (Display *dpy, int screen, GLXVideoDeviceNV VideoDevice);
-typedef int ( *PFNGLXBINDVIDEOIMAGENVPROC) (Display *dpy, GLXVideoDeviceNV VideoDevice, GLXPbuffer pbuf, int iVideoBuffer);
-typedef int ( *PFNGLXRELEASEVIDEOIMAGENVPROC) (Display *dpy, GLXPbuffer pbuf);
-typedef int ( *PFNGLXSENDPBUFFERTOVIDEONVPROC) (Display *dpy, GLXPbuffer pbuf, int iBufferType, unsigned long *pulCounterPbuffer, GLboolean bBlock);
-typedef int ( *PFNGLXGETVIDEOINFONVPROC) (Display *dpy, int screen, GLXVideoDeviceNV VideoDevice, unsigned long *pulCounterOutputPbuffer, unsigned long *pulCounterOutputVideo);
-#ifdef GLX_GLXEXT_PROTOTYPES
-int glXGetVideoDeviceNV (Display *dpy, int screen, int numVideoDevices, GLXVideoDeviceNV *pVideoDevice);
-int glXReleaseVideoDeviceNV (Display *dpy, int screen, GLXVideoDeviceNV VideoDevice);
-int glXBindVideoImageNV (Display *dpy, GLXVideoDeviceNV VideoDevice, GLXPbuffer pbuf, int iVideoBuffer);
-int glXReleaseVideoImageNV (Display *dpy, GLXPbuffer pbuf);
-int glXSendPbufferToVideoNV (Display *dpy, GLXPbuffer pbuf, int iBufferType, unsigned long *pulCounterPbuffer, GLboolean bBlock);
-int glXGetVideoInfoNV (Display *dpy, int screen, GLXVideoDeviceNV VideoDevice, unsigned long *pulCounterOutputPbuffer, unsigned long *pulCounterOutputVideo);
-#endif
-#endif /* GLX_NV_video_out */
-
-#ifndef GLX_OML_swap_method
-#define GLX_OML_swap_method 1
-#define GLX_SWAP_METHOD_OML               0x8060
-#define GLX_SWAP_EXCHANGE_OML             0x8061
-#define GLX_SWAP_COPY_OML                 0x8062
-#define GLX_SWAP_UNDEFINED_OML            0x8063
-#endif /* GLX_OML_swap_method */
-
-#ifndef GLX_OML_sync_control
-#define GLX_OML_sync_control 1
-#ifndef GLEXT_64_TYPES_DEFINED
-/* This code block is duplicated in glext.h, so must be protected */
-#define GLEXT_64_TYPES_DEFINED
-/* Define int32_t, int64_t, and uint64_t types for UST/MSC */
-/* (as used in the GLX_OML_sync_control extension). */
-#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
-#include <inttypes.h>
-#elif defined(__sun__) || defined(__digital__)
-#include <inttypes.h>
-#if defined(__STDC__)
-#if defined(__arch64__) || defined(_LP64)
-typedef long int int64_t;
-typedef unsigned long int uint64_t;
-#else
-typedef long long int int64_t;
-typedef unsigned long long int uint64_t;
-#endif /* __arch64__ */
-#endif /* __STDC__ */
-#elif defined( __VMS ) || defined(__sgi)
-#include <inttypes.h>
-#elif defined(__SCO__) || defined(__USLC__)
-#include <stdint.h>
-#elif defined(__UNIXOS2__) || defined(__SOL64__)
-typedef long int int32_t;
-typedef long long int int64_t;
-typedef unsigned long long int uint64_t;
-#elif defined(_WIN32) && defined(__GNUC__)
-#include <stdint.h>
-#elif defined(_WIN32)
-typedef __int32 int32_t;
-typedef __int64 int64_t;
-typedef unsigned __int64 uint64_t;
-#else
-/* Fallback if nothing above works */
-#include <inttypes.h>
-#endif
-#endif
-typedef Bool ( *PFNGLXGETSYNCVALUESOMLPROC) (Display *dpy, GLXDrawable drawable, int64_t *ust, int64_t *msc, int64_t *sbc);
-typedef Bool ( *PFNGLXGETMSCRATEOMLPROC) (Display *dpy, GLXDrawable drawable, int32_t *numerator, int32_t *denominator);
-typedef int64_t ( *PFNGLXSWAPBUFFERSMSCOMLPROC) (Display *dpy, GLXDrawable drawable, int64_t target_msc, int64_t divisor, int64_t remainder);
-typedef Bool ( *PFNGLXWAITFORMSCOMLPROC) (Display *dpy, GLXDrawable drawable, int64_t target_msc, int64_t divisor, int64_t remainder, int64_t *ust, int64_t *msc, int64_t *sbc);
-typedef Bool ( *PFNGLXWAITFORSBCOMLPROC) (Display *dpy, GLXDrawable drawable, int64_t target_sbc, int64_t *ust, int64_t *msc, int64_t *sbc);
-#ifdef GLX_GLXEXT_PROTOTYPES
-Bool glXGetSyncValuesOML (Display *dpy, GLXDrawable drawable, int64_t *ust, int64_t *msc, int64_t *sbc);
-Bool glXGetMscRateOML (Display *dpy, GLXDrawable drawable, int32_t *numerator, int32_t *denominator);
-int64_t glXSwapBuffersMscOML (Display *dpy, GLXDrawable drawable, int64_t target_msc, int64_t divisor, int64_t remainder);
-Bool glXWaitForMscOML (Display *dpy, GLXDrawable drawable, int64_t target_msc, int64_t divisor, int64_t remainder, int64_t *ust, int64_t *msc, int64_t *sbc);
-Bool glXWaitForSbcOML (Display *dpy, GLXDrawable drawable, int64_t target_sbc, int64_t *ust, int64_t *msc, int64_t *sbc);
-#endif
-#endif /* GLX_OML_sync_control */
-
-#ifndef GLX_SGIS_blended_overlay
-#define GLX_SGIS_blended_overlay 1
-#define GLX_BLENDED_RGBA_SGIS             0x8025
-#endif /* GLX_SGIS_blended_overlay */
-
-#ifndef GLX_SGIS_multisample
-#define GLX_SGIS_multisample 1
-#define GLX_SAMPLE_BUFFERS_SGIS           100000
-#define GLX_SAMPLES_SGIS                  100001
-#endif /* GLX_SGIS_multisample */
-
-#ifndef GLX_SGIS_shared_multisample
-#define GLX_SGIS_shared_multisample 1
-#define GLX_MULTISAMPLE_SUB_RECT_WIDTH_SGIS 0x8026
-#define GLX_MULTISAMPLE_SUB_RECT_HEIGHT_SGIS 0x8027
-#endif /* GLX_SGIS_shared_multisample */
-
-#ifndef GLX_SGIX_dmbuffer
-#define GLX_SGIX_dmbuffer 1
-typedef XID GLXPbufferSGIX;
-#ifdef _DM_BUFFER_H_
-#define GLX_DIGITAL_MEDIA_PBUFFER_SGIX    0x8024
-typedef Bool ( *PFNGLXASSOCIATEDMPBUFFERSGIXPROC) (Display *dpy, GLXPbufferSGIX pbuffer, DMparams *params, DMbuffer dmbuffer);
-#ifdef GLX_GLXEXT_PROTOTYPES
-Bool glXAssociateDMPbufferSGIX (Display *dpy, GLXPbufferSGIX pbuffer, DMparams *params, DMbuffer dmbuffer);
-#endif
-#endif /* _DM_BUFFER_H_ */
-#endif /* GLX_SGIX_dmbuffer */
-
-#ifndef GLX_SGIX_fbconfig
-#define GLX_SGIX_fbconfig 1
-typedef struct __GLXFBConfigRec *GLXFBConfigSGIX;
-#define GLX_WINDOW_BIT_SGIX               0x00000001
-#define GLX_PIXMAP_BIT_SGIX               0x00000002
-#define GLX_RGBA_BIT_SGIX                 0x00000001
-#define GLX_COLOR_INDEX_BIT_SGIX          0x00000002
-#define GLX_DRAWABLE_TYPE_SGIX            0x8010
-#define GLX_RENDER_TYPE_SGIX              0x8011
-#define GLX_X_RENDERABLE_SGIX             0x8012
-#define GLX_FBCONFIG_ID_SGIX              0x8013
-#define GLX_RGBA_TYPE_SGIX                0x8014
-#define GLX_COLOR_INDEX_TYPE_SGIX         0x8015
-typedef int ( *PFNGLXGETFBCONFIGATTRIBSGIXPROC) (Display *dpy, GLXFBConfigSGIX config, int attribute, int *value);
-typedef GLXFBConfigSGIX *( *PFNGLXCHOOSEFBCONFIGSGIXPROC) (Display *dpy, int screen, int *attrib_list, int *nelements);
-typedef GLXPixmap ( *PFNGLXCREATEGLXPIXMAPWITHCONFIGSGIXPROC) (Display *dpy, GLXFBConfigSGIX config, Pixmap pixmap);
-typedef GLXContext ( *PFNGLXCREATECONTEXTWITHCONFIGSGIXPROC) (Display *dpy, GLXFBConfigSGIX config, int render_type, GLXContext share_list, Bool direct);
-typedef XVisualInfo *( *PFNGLXGETVISUALFROMFBCONFIGSGIXPROC) (Display *dpy, GLXFBConfigSGIX config);
-typedef GLXFBConfigSGIX ( *PFNGLXGETFBCONFIGFROMVISUALSGIXPROC) (Display *dpy, XVisualInfo *vis);
-#ifdef GLX_GLXEXT_PROTOTYPES
-int glXGetFBConfigAttribSGIX (Display *dpy, GLXFBConfigSGIX config, int attribute, int *value);
-GLXFBConfigSGIX *glXChooseFBConfigSGIX (Display *dpy, int screen, int *attrib_list, int *nelements);
-GLXPixmap glXCreateGLXPixmapWithConfigSGIX (Display *dpy, GLXFBConfigSGIX config, Pixmap pixmap);
-GLXContext glXCreateContextWithConfigSGIX (Display *dpy, GLXFBConfigSGIX config, int render_type, GLXContext share_list, Bool direct);
-XVisualInfo *glXGetVisualFromFBConfigSGIX (Display *dpy, GLXFBConfigSGIX config);
-GLXFBConfigSGIX glXGetFBConfigFromVisualSGIX (Display *dpy, XVisualInfo *vis);
-#endif
-#endif /* GLX_SGIX_fbconfig */
-
-#ifndef GLX_SGIX_hyperpipe
-#define GLX_SGIX_hyperpipe 1
-typedef struct {
-    char    pipeName[80]; /* Should be [GLX_HYPERPIPE_PIPE_NAME_LENGTH_SGIX] */
-    int     networkId;
-} GLXHyperpipeNetworkSGIX;
-typedef struct {
-    char    pipeName[80]; /* Should be [GLX_HYPERPIPE_PIPE_NAME_LENGTH_SGIX] */
-    int     channel;
-    unsigned int participationType;
-    int     timeSlice;
-} GLXHyperpipeConfigSGIX;
-typedef struct {
-    char pipeName[80]; /* Should be [GLX_HYPERPIPE_PIPE_NAME_LENGTH_SGIX] */
-    int srcXOrigin, srcYOrigin, srcWidth, srcHeight;
-    int destXOrigin, destYOrigin, destWidth, destHeight;
-} GLXPipeRect;
-typedef struct {
-    char pipeName[80]; /* Should be [GLX_HYPERPIPE_PIPE_NAME_LENGTH_SGIX] */
-    int XOrigin, YOrigin, maxHeight, maxWidth;
-} GLXPipeRectLimits;
-#define GLX_HYPERPIPE_PIPE_NAME_LENGTH_SGIX 80
-#define GLX_BAD_HYPERPIPE_CONFIG_SGIX     91
-#define GLX_BAD_HYPERPIPE_SGIX            92
-#define GLX_HYPERPIPE_DISPLAY_PIPE_SGIX   0x00000001
-#define GLX_HYPERPIPE_RENDER_PIPE_SGIX    0x00000002
-#define GLX_PIPE_RECT_SGIX                0x00000001
-#define GLX_PIPE_RECT_LIMITS_SGIX         0x00000002
-#define GLX_HYPERPIPE_STEREO_SGIX         0x00000003
-#define GLX_HYPERPIPE_PIXEL_AVERAGE_SGIX  0x00000004
-#define GLX_HYPERPIPE_ID_SGIX             0x8030
-typedef GLXHyperpipeNetworkSGIX *( *PFNGLXQUERYHYPERPIPENETWORKSGIXPROC) (Display *dpy, int *npipes);
-typedef int ( *PFNGLXHYPERPIPECONFIGSGIXPROC) (Display *dpy, int networkId, int npipes, GLXHyperpipeConfigSGIX *cfg, int *hpId);
-typedef GLXHyperpipeConfigSGIX *( *PFNGLXQUERYHYPERPIPECONFIGSGIXPROC) (Display *dpy, int hpId, int *npipes);
-typedef int ( *PFNGLXDESTROYHYPERPIPECONFIGSGIXPROC) (Display *dpy, int hpId);
-typedef int ( *PFNGLXBINDHYPERPIPESGIXPROC) (Display *dpy, int hpId);
-typedef int ( *PFNGLXQUERYHYPERPIPEBESTATTRIBSGIXPROC) (Display *dpy, int timeSlice, int attrib, int size, void *attribList, void *returnAttribList);
-typedef int ( *PFNGLXHYPERPIPEATTRIBSGIXPROC) (Display *dpy, int timeSlice, int attrib, int size, void *attribList);
-typedef int ( *PFNGLXQUERYHYPERPIPEATTRIBSGIXPROC) (Display *dpy, int timeSlice, int attrib, int size, void *returnAttribList);
-#ifdef GLX_GLXEXT_PROTOTYPES
-GLXHyperpipeNetworkSGIX *glXQueryHyperpipeNetworkSGIX (Display *dpy, int *npipes);
-int glXHyperpipeConfigSGIX (Display *dpy, int networkId, int npipes, GLXHyperpipeConfigSGIX *cfg, int *hpId);
-GLXHyperpipeConfigSGIX *glXQueryHyperpipeConfigSGIX (Display *dpy, int hpId, int *npipes);
-int glXDestroyHyperpipeConfigSGIX (Display *dpy, int hpId);
-int glXBindHyperpipeSGIX (Display *dpy, int hpId);
-int glXQueryHyperpipeBestAttribSGIX (Display *dpy, int timeSlice, int attrib, int size, void *attribList, void *returnAttribList);
-int glXHyperpipeAttribSGIX (Display *dpy, int timeSlice, int attrib, int size, void *attribList);
-int glXQueryHyperpipeAttribSGIX (Display *dpy, int timeSlice, int attrib, int size, void *returnAttribList);
-#endif
-#endif /* GLX_SGIX_hyperpipe */
-
-#ifndef GLX_SGIX_pbuffer
-#define GLX_SGIX_pbuffer 1
-#define GLX_PBUFFER_BIT_SGIX              0x00000004
-#define GLX_BUFFER_CLOBBER_MASK_SGIX      0x08000000
-#define GLX_FRONT_LEFT_BUFFER_BIT_SGIX    0x00000001
-#define GLX_FRONT_RIGHT_BUFFER_BIT_SGIX   0x00000002
-#define GLX_BACK_LEFT_BUFFER_BIT_SGIX     0x00000004
-#define GLX_BACK_RIGHT_BUFFER_BIT_SGIX    0x00000008
-#define GLX_AUX_BUFFERS_BIT_SGIX          0x00000010
-#define GLX_DEPTH_BUFFER_BIT_SGIX         0x00000020
-#define GLX_STENCIL_BUFFER_BIT_SGIX       0x00000040
-#define GLX_ACCUM_BUFFER_BIT_SGIX         0x00000080
-#define GLX_SAMPLE_BUFFERS_BIT_SGIX       0x00000100
-#define GLX_MAX_PBUFFER_WIDTH_SGIX        0x8016
-#define GLX_MAX_PBUFFER_HEIGHT_SGIX       0x8017
-#define GLX_MAX_PBUFFER_PIXELS_SGIX       0x8018
-#define GLX_OPTIMAL_PBUFFER_WIDTH_SGIX    0x8019
-#define GLX_OPTIMAL_PBUFFER_HEIGHT_SGIX   0x801A
-#define GLX_PRESERVED_CONTENTS_SGIX       0x801B
-#define GLX_LARGEST_PBUFFER_SGIX          0x801C
-#define GLX_WIDTH_SGIX                    0x801D
-#define GLX_HEIGHT_SGIX                   0x801E
-#define GLX_EVENT_MASK_SGIX               0x801F
-#define GLX_DAMAGED_SGIX                  0x8020
-#define GLX_SAVED_SGIX                    0x8021
-#define GLX_WINDOW_SGIX                   0x8022
-#define GLX_PBUFFER_SGIX                  0x8023
-typedef GLXPbufferSGIX ( *PFNGLXCREATEGLXPBUFFERSGIXPROC) (Display *dpy, GLXFBConfigSGIX config, unsigned int width, unsigned int height, int *attrib_list);
-typedef void ( *PFNGLXDESTROYGLXPBUFFERSGIXPROC) (Display *dpy, GLXPbufferSGIX pbuf);
-typedef int ( *PFNGLXQUERYGLXPBUFFERSGIXPROC) (Display *dpy, GLXPbufferSGIX pbuf, int attribute, unsigned int *value);
-typedef void ( *PFNGLXSELECTEVENTSGIXPROC) (Display *dpy, GLXDrawable drawable, unsigned long mask);
-typedef void ( *PFNGLXGETSELECTEDEVENTSGIXPROC) (Display *dpy, GLXDrawable drawable, unsigned long *mask);
-#ifdef GLX_GLXEXT_PROTOTYPES
-GLXPbufferSGIX glXCreateGLXPbufferSGIX (Display *dpy, GLXFBConfigSGIX config, unsigned int width, unsigned int height, int *attrib_list);
-void glXDestroyGLXPbufferSGIX (Display *dpy, GLXPbufferSGIX pbuf);
-int glXQueryGLXPbufferSGIX (Display *dpy, GLXPbufferSGIX pbuf, int attribute, unsigned int *value);
-void glXSelectEventSGIX (Display *dpy, GLXDrawable drawable, unsigned long mask);
-void glXGetSelectedEventSGIX (Display *dpy, GLXDrawable drawable, unsigned long *mask);
-#endif
-#endif /* GLX_SGIX_pbuffer */
-
-#ifndef GLX_SGIX_swap_barrier
-#define GLX_SGIX_swap_barrier 1
-typedef void ( *PFNGLXBINDSWAPBARRIERSGIXPROC) (Display *dpy, GLXDrawable drawable, int barrier);
-typedef Bool ( *PFNGLXQUERYMAXSWAPBARRIERSSGIXPROC) (Display *dpy, int screen, int *max);
-#ifdef GLX_GLXEXT_PROTOTYPES
-void glXBindSwapBarrierSGIX (Display *dpy, GLXDrawable drawable, int barrier);
-Bool glXQueryMaxSwapBarriersSGIX (Display *dpy, int screen, int *max);
-#endif
-#endif /* GLX_SGIX_swap_barrier */
-
-#ifndef GLX_SGIX_swap_group
-#define GLX_SGIX_swap_group 1
-typedef void ( *PFNGLXJOINSWAPGROUPSGIXPROC) (Display *dpy, GLXDrawable drawable, GLXDrawable member);
-#ifdef GLX_GLXEXT_PROTOTYPES
-void glXJoinSwapGroupSGIX (Display *dpy, GLXDrawable drawable, GLXDrawable member);
-#endif
-#endif /* GLX_SGIX_swap_group */
-
-#ifndef GLX_SGIX_video_resize
-#define GLX_SGIX_video_resize 1
-#define GLX_SYNC_FRAME_SGIX               0x00000000
-#define GLX_SYNC_SWAP_SGIX                0x00000001
-typedef int ( *PFNGLXBINDCHANNELTOWINDOWSGIXPROC) (Display *display, int screen, int channel, Window window);
-typedef int ( *PFNGLXCHANNELRECTSGIXPROC) (Display *display, int screen, int channel, int x, int y, int w, int h);
-typedef int ( *PFNGLXQUERYCHANNELRECTSGIXPROC) (Display *display, int screen, int channel, int *dx, int *dy, int *dw, int *dh);
-typedef int ( *PFNGLXQUERYCHANNELDELTASSGIXPROC) (Display *display, int screen, int channel, int *x, int *y, int *w, int *h);
-typedef int ( *PFNGLXCHANNELRECTSYNCSGIXPROC) (Display *display, int screen, int channel, GLenum synctype);
-#ifdef GLX_GLXEXT_PROTOTYPES
-int glXBindChannelToWindowSGIX (Display *display, int screen, int channel, Window window);
-int glXChannelRectSGIX (Display *display, int screen, int channel, int x, int y, int w, int h);
-int glXQueryChannelRectSGIX (Display *display, int screen, int channel, int *dx, int *dy, int *dw, int *dh);
-int glXQueryChannelDeltasSGIX (Display *display, int screen, int channel, int *x, int *y, int *w, int *h);
-int glXChannelRectSyncSGIX (Display *display, int screen, int channel, GLenum synctype);
-#endif
-#endif /* GLX_SGIX_video_resize */
-
-#ifndef GLX_SGIX_video_source
-#define GLX_SGIX_video_source 1
-typedef XID GLXVideoSourceSGIX;
-#ifdef _VL_H
-typedef GLXVideoSourceSGIX ( *PFNGLXCREATEGLXVIDEOSOURCESGIXPROC) (Display *display, int screen, VLServer server, VLPath path, int nodeClass, VLNode drainNode);
-typedef void ( *PFNGLXDESTROYGLXVIDEOSOURCESGIXPROC) (Display *dpy, GLXVideoSourceSGIX glxvideosource);
-#ifdef GLX_GLXEXT_PROTOTYPES
-GLXVideoSourceSGIX glXCreateGLXVideoSourceSGIX (Display *display, int screen, VLServer server, VLPath path, int nodeClass, VLNode drainNode);
-void glXDestroyGLXVideoSourceSGIX (Display *dpy, GLXVideoSourceSGIX glxvideosource);
-#endif
-#endif /* _VL_H */
-#endif /* GLX_SGIX_video_source */
-
-#ifndef GLX_SGIX_visual_select_group
-#define GLX_SGIX_visual_select_group 1
-#define GLX_VISUAL_SELECT_GROUP_SGIX      0x8028
-#endif /* GLX_SGIX_visual_select_group */
-
-#ifndef GLX_SGI_cushion
-#define GLX_SGI_cushion 1
-typedef void ( *PFNGLXCUSHIONSGIPROC) (Display *dpy, Window window, float cushion);
-#ifdef GLX_GLXEXT_PROTOTYPES
-void glXCushionSGI (Display *dpy, Window window, float cushion);
-#endif
-#endif /* GLX_SGI_cushion */
-
-#ifndef GLX_SGI_make_current_read
-#define GLX_SGI_make_current_read 1
-typedef Bool ( *PFNGLXMAKECURRENTREADSGIPROC) (Display *dpy, GLXDrawable draw, GLXDrawable read, GLXContext ctx);
-typedef GLXDrawable ( *PFNGLXGETCURRENTREADDRAWABLESGIPROC) (void);
-#ifdef GLX_GLXEXT_PROTOTYPES
-Bool glXMakeCurrentReadSGI (Display *dpy, GLXDrawable draw, GLXDrawable read, GLXContext ctx);
-GLXDrawable glXGetCurrentReadDrawableSGI (void);
-#endif
-#endif /* GLX_SGI_make_current_read */
-
-#ifndef GLX_SGI_swap_control
-#define GLX_SGI_swap_control 1
-typedef int ( *PFNGLXSWAPINTERVALSGIPROC) (int interval);
-#ifdef GLX_GLXEXT_PROTOTYPES
-int glXSwapIntervalSGI (int interval);
-#endif
-#endif /* GLX_SGI_swap_control */
-
-#ifndef GLX_SGI_video_sync
-#define GLX_SGI_video_sync 1
-typedef int ( *PFNGLXGETVIDEOSYNCSGIPROC) (unsigned int *count);
-typedef int ( *PFNGLXWAITVIDEOSYNCSGIPROC) (int divisor, int remainder, unsigned int *count);
-#ifdef GLX_GLXEXT_PROTOTYPES
-int glXGetVideoSyncSGI (unsigned int *count);
-int glXWaitVideoSyncSGI (int divisor, int remainder, unsigned int *count);
-#endif
-#endif /* GLX_SGI_video_sync */
-
-#ifndef GLX_SUN_get_transparent_index
-#define GLX_SUN_get_transparent_index 1
-typedef Status ( *PFNGLXGETTRANSPARENTINDEXSUNPROC) (Display *dpy, Window overlay, Window underlay, long *pTransparentIndex);
-#ifdef GLX_GLXEXT_PROTOTYPES
-Status glXGetTransparentIndexSUN (Display *dpy, Window overlay, Window underlay, long *pTransparentIndex);
-#endif
-#endif /* GLX_SUN_get_transparent_index */
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif

deps/GL/wglext.h

@@ -1,840 +0,0 @@
-#ifndef __wglext_h_
-#define __wglext_h_ 1
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/*
-** Copyright (c) 2013-2014 The Khronos Group Inc.
-**
-** Permission is hereby granted, free of charge, to any person obtaining a
-** copy of this software and/or associated documentation files (the
-** "Materials"), to deal in the Materials without restriction, including
-** without limitation the rights to use, copy, modify, merge, publish,
-** distribute, sublicense, and/or sell copies of the Materials, and to
-** permit persons to whom the Materials are furnished to do so, subject to
-** the following conditions:
-**
-** The above copyright notice and this permission notice shall be included
-** in all copies or substantial portions of the Materials.
-**
-** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
-*/
-/*
-** This header is generated from the Khronos OpenGL / OpenGL ES XML
-** API Registry. The current version of the Registry, generator scripts
-** used to make the header, and the header can be found at
-**   http://www.opengl.org/registry/
-**
-** Khronos $Revision: 27684 $ on $Date: 2014-08-11 01:21:35 -0700 (Mon, 11 Aug 2014) $
-*/
-
-#if defined(_WIN32) && !defined(APIENTRY) && !defined(__CYGWIN__) && !defined(__SCITECH_SNAP__)
-#define WIN32_LEAN_AND_MEAN 1
-#include <windows.h>
-#endif
-
-#define WGL_WGLEXT_VERSION 20140810
-
-/* Generated C header for:
- * API: wgl
- * Versions considered: .*
- * Versions emitted: _nomatch_^
- * Default extensions included: wgl
- * Additional extensions included: _nomatch_^
- * Extensions removed: _nomatch_^
- */
-
-#ifndef WGL_ARB_buffer_region
-#define WGL_ARB_buffer_region 1
-#define WGL_FRONT_COLOR_BUFFER_BIT_ARB    0x00000001
-#define WGL_BACK_COLOR_BUFFER_BIT_ARB     0x00000002
-#define WGL_DEPTH_BUFFER_BIT_ARB          0x00000004
-#define WGL_STENCIL_BUFFER_BIT_ARB        0x00000008
-typedef HANDLE (WINAPI * PFNWGLCREATEBUFFERREGIONARBPROC) (HDC hDC, int iLayerPlane, UINT uType);
-typedef VOID (WINAPI * PFNWGLDELETEBUFFERREGIONARBPROC) (HANDLE hRegion);
-typedef BOOL (WINAPI * PFNWGLSAVEBUFFERREGIONARBPROC) (HANDLE hRegion, int x, int y, int width, int height);
-typedef BOOL (WINAPI * PFNWGLRESTOREBUFFERREGIONARBPROC) (HANDLE hRegion, int x, int y, int width, int height, int xSrc, int ySrc);
-#ifdef WGL_WGLEXT_PROTOTYPES
-HANDLE WINAPI wglCreateBufferRegionARB (HDC hDC, int iLayerPlane, UINT uType);
-VOID WINAPI wglDeleteBufferRegionARB (HANDLE hRegion);
-BOOL WINAPI wglSaveBufferRegionARB (HANDLE hRegion, int x, int y, int width, int height);
-BOOL WINAPI wglRestoreBufferRegionARB (HANDLE hRegion, int x, int y, int width, int height, int xSrc, int ySrc);
-#endif
-#endif /* WGL_ARB_buffer_region */
-
-#ifndef WGL_ARB_context_flush_control
-#define WGL_ARB_context_flush_control 1
-#define WGL_CONTEXT_RELEASE_BEHAVIOR_ARB  0x2097
-#define WGL_CONTEXT_RELEASE_BEHAVIOR_NONE_ARB 0
-#define WGL_CONTEXT_RELEASE_BEHAVIOR_FLUSH_ARB 0x2098
-#endif /* WGL_ARB_context_flush_control */
-
-#ifndef WGL_ARB_create_context
-#define WGL_ARB_create_context 1
-#define WGL_CONTEXT_DEBUG_BIT_ARB         0x00000001
-#define WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB 0x00000002
-#define WGL_CONTEXT_MAJOR_VERSION_ARB     0x2091
-#define WGL_CONTEXT_MINOR_VERSION_ARB     0x2092
-#define WGL_CONTEXT_LAYER_PLANE_ARB       0x2093
-#define WGL_CONTEXT_FLAGS_ARB             0x2094
-#define ERROR_INVALID_VERSION_ARB         0x2095
-typedef HGLRC (WINAPI * PFNWGLCREATECONTEXTATTRIBSARBPROC) (HDC hDC, HGLRC hShareContext, const int *attribList);
-#ifdef WGL_WGLEXT_PROTOTYPES
-HGLRC WINAPI wglCreateContextAttribsARB (HDC hDC, HGLRC hShareContext, const int *attribList);
-#endif
-#endif /* WGL_ARB_create_context */
-
-#ifndef WGL_ARB_create_context_profile
-#define WGL_ARB_create_context_profile 1
-#define WGL_CONTEXT_PROFILE_MASK_ARB      0x9126
-#define WGL_CONTEXT_CORE_PROFILE_BIT_ARB  0x00000001
-#define WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB 0x00000002
-#define ERROR_INVALID_PROFILE_ARB         0x2096
-#endif /* WGL_ARB_create_context_profile */
-
-#ifndef WGL_ARB_create_context_robustness
-#define WGL_ARB_create_context_robustness 1
-#define WGL_CONTEXT_ROBUST_ACCESS_BIT_ARB 0x00000004
-#define WGL_LOSE_CONTEXT_ON_RESET_ARB     0x8252
-#define WGL_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB 0x8256
-#define WGL_NO_RESET_NOTIFICATION_ARB     0x8261
-#endif /* WGL_ARB_create_context_robustness */
-
-#ifndef WGL_ARB_extensions_string
-#define WGL_ARB_extensions_string 1
-typedef const char *(WINAPI * PFNWGLGETEXTENSIONSSTRINGARBPROC) (HDC hdc);
-#ifdef WGL_WGLEXT_PROTOTYPES
-const char *WINAPI wglGetExtensionsStringARB (HDC hdc);
-#endif
-#endif /* WGL_ARB_extensions_string */
-
-#ifndef WGL_ARB_framebuffer_sRGB
-#define WGL_ARB_framebuffer_sRGB 1
-#define WGL_FRAMEBUFFER_SRGB_CAPABLE_ARB  0x20A9
-#endif /* WGL_ARB_framebuffer_sRGB */
-
-#ifndef WGL_ARB_make_current_read
-#define WGL_ARB_make_current_read 1
-#define ERROR_INVALID_PIXEL_TYPE_ARB      0x2043
-#define ERROR_INCOMPATIBLE_DEVICE_CONTEXTS_ARB 0x2054
-typedef BOOL (WINAPI * PFNWGLMAKECONTEXTCURRENTARBPROC) (HDC hDrawDC, HDC hReadDC, HGLRC hglrc);
-typedef HDC (WINAPI * PFNWGLGETCURRENTREADDCARBPROC) (void);
-#ifdef WGL_WGLEXT_PROTOTYPES
-BOOL WINAPI wglMakeContextCurrentARB (HDC hDrawDC, HDC hReadDC, HGLRC hglrc);
-HDC WINAPI wglGetCurrentReadDCARB (void);
-#endif
-#endif /* WGL_ARB_make_current_read */
-
-#ifndef WGL_ARB_multisample
-#define WGL_ARB_multisample 1
-#define WGL_SAMPLE_BUFFERS_ARB            0x2041
-#define WGL_SAMPLES_ARB                   0x2042
-#endif /* WGL_ARB_multisample */
-
-#ifndef WGL_ARB_pbuffer
-#define WGL_ARB_pbuffer 1
-DECLARE_HANDLE(HPBUFFERARB);
-#define WGL_DRAW_TO_PBUFFER_ARB           0x202D
-#define WGL_MAX_PBUFFER_PIXELS_ARB        0x202E
-#define WGL_MAX_PBUFFER_WIDTH_ARB         0x202F
-#define WGL_MAX_PBUFFER_HEIGHT_ARB        0x2030
-#define WGL_PBUFFER_LARGEST_ARB           0x2033
-#define WGL_PBUFFER_WIDTH_ARB             0x2034
-#define WGL_PBUFFER_HEIGHT_ARB            0x2035
-#define WGL_PBUFFER_LOST_ARB              0x2036
-typedef HPBUFFERARB (WINAPI * PFNWGLCREATEPBUFFERARBPROC) (HDC hDC, int iPixelFormat, int iWidth, int iHeight, const int *piAttribList);
-typedef HDC (WINAPI * PFNWGLGETPBUFFERDCARBPROC) (HPBUFFERARB hPbuffer);
-typedef int (WINAPI * PFNWGLRELEASEPBUFFERDCARBPROC) (HPBUFFERARB hPbuffer, HDC hDC);
-typedef BOOL (WINAPI * PFNWGLDESTROYPBUFFERARBPROC) (HPBUFFERARB hPbuffer);
-typedef BOOL (WINAPI * PFNWGLQUERYPBUFFERARBPROC) (HPBUFFERARB hPbuffer, int iAttribute, int *piValue);
-#ifdef WGL_WGLEXT_PROTOTYPES
-HPBUFFERARB WINAPI wglCreatePbufferARB (HDC hDC, int iPixelFormat, int iWidth, int iHeight, const int *piAttribList);
-HDC WINAPI wglGetPbufferDCARB (HPBUFFERARB hPbuffer);
-int WINAPI wglReleasePbufferDCARB (HPBUFFERARB hPbuffer, HDC hDC);
-BOOL WINAPI wglDestroyPbufferARB (HPBUFFERARB hPbuffer);
-BOOL WINAPI wglQueryPbufferARB (HPBUFFERARB hPbuffer, int iAttribute, int *piValue);
-#endif
-#endif /* WGL_ARB_pbuffer */
-
-#ifndef WGL_ARB_pixel_format
-#define WGL_ARB_pixel_format 1
-#define WGL_NUMBER_PIXEL_FORMATS_ARB      0x2000
-#define WGL_DRAW_TO_WINDOW_ARB            0x2001
-#define WGL_DRAW_TO_BITMAP_ARB            0x2002
-#define WGL_ACCELERATION_ARB              0x2003
-#define WGL_NEED_PALETTE_ARB              0x2004
-#define WGL_NEED_SYSTEM_PALETTE_ARB       0x2005
-#define WGL_SWAP_LAYER_BUFFERS_ARB        0x2006
-#define WGL_SWAP_METHOD_ARB               0x2007
-#define WGL_NUMBER_OVERLAYS_ARB           0x2008
-#define WGL_NUMBER_UNDERLAYS_ARB          0x2009
-#define WGL_TRANSPARENT_ARB               0x200A
-#define WGL_TRANSPARENT_RED_VALUE_ARB     0x2037
-#define WGL_TRANSPARENT_GREEN_VALUE_ARB   0x2038
-#define WGL_TRANSPARENT_BLUE_VALUE_ARB    0x2039
-#define WGL_TRANSPARENT_ALPHA_VALUE_ARB   0x203A
-#define WGL_TRANSPARENT_INDEX_VALUE_ARB   0x203B
-#define WGL_SHARE_DEPTH_ARB               0x200C
-#define WGL_SHARE_STENCIL_ARB             0x200D
-#define WGL_SHARE_ACCUM_ARB               0x200E
-#define WGL_SUPPORT_GDI_ARB               0x200F
-#define WGL_SUPPORT_OPENGL_ARB            0x2010
-#define WGL_DOUBLE_BUFFER_ARB             0x2011
-#define WGL_STEREO_ARB                    0x2012
-#define WGL_PIXEL_TYPE_ARB                0x2013
-#define WGL_COLOR_BITS_ARB                0x2014
-#define WGL_RED_BITS_ARB                  0x2015
-#define WGL_RED_SHIFT_ARB                 0x2016
-#define WGL_GREEN_BITS_ARB                0x2017
-#define WGL_GREEN_SHIFT_ARB               0x2018
-#define WGL_BLUE_BITS_ARB                 0x2019
-#define WGL_BLUE_SHIFT_ARB                0x201A
-#define WGL_ALPHA_BITS_ARB                0x201B
-#define WGL_ALPHA_SHIFT_ARB               0x201C
-#define WGL_ACCUM_BITS_ARB                0x201D
-#define WGL_ACCUM_RED_BITS_ARB            0x201E
-#define WGL_ACCUM_GREEN_BITS_ARB          0x201F
-#define WGL_ACCUM_BLUE_BITS_ARB           0x2020
-#define WGL_ACCUM_ALPHA_BITS_ARB          0x2021
-#define WGL_DEPTH_BITS_ARB                0x2022
-#define WGL_STENCIL_BITS_ARB              0x2023
-#define WGL_AUX_BUFFERS_ARB               0x2024
-#define WGL_NO_ACCELERATION_ARB           0x2025
-#define WGL_GENERIC_ACCELERATION_ARB      0x2026
-#define WGL_FULL_ACCELERATION_ARB         0x2027
-#define WGL_SWAP_EXCHANGE_ARB             0x2028
-#define WGL_SWAP_COPY_ARB                 0x2029
-#define WGL_SWAP_UNDEFINED_ARB            0x202A
-#define WGL_TYPE_RGBA_ARB                 0x202B
-#define WGL_TYPE_COLORINDEX_ARB           0x202C
-typedef BOOL (WINAPI * PFNWGLGETPIXELFORMATATTRIBIVARBPROC) (HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, const int *piAttributes, int *piValues);
-typedef BOOL (WINAPI * PFNWGLGETPIXELFORMATATTRIBFVARBPROC) (HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, const int *piAttributes, FLOAT *pfValues);
-typedef BOOL (WINAPI * PFNWGLCHOOSEPIXELFORMATARBPROC) (HDC hdc, const int *piAttribIList, const FLOAT *pfAttribFList, UINT nMaxFormats, int *piFormats, UINT *nNumFormats);
-#ifdef WGL_WGLEXT_PROTOTYPES
-BOOL WINAPI wglGetPixelFormatAttribivARB (HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, const int *piAttributes, int *piValues);
-BOOL WINAPI wglGetPixelFormatAttribfvARB (HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, const int *piAttributes, FLOAT *pfValues);
-BOOL WINAPI wglChoosePixelFormatARB (HDC hdc, const int *piAttribIList, const FLOAT *pfAttribFList, UINT nMaxFormats, int *piFormats, UINT *nNumFormats);
-#endif
-#endif /* WGL_ARB_pixel_format */
-
-#ifndef WGL_ARB_pixel_format_float
-#define WGL_ARB_pixel_format_float 1
-#define WGL_TYPE_RGBA_FLOAT_ARB           0x21A0
-#endif /* WGL_ARB_pixel_format_float */
-
-#ifndef WGL_ARB_render_texture
-#define WGL_ARB_render_texture 1
-#define WGL_BIND_TO_TEXTURE_RGB_ARB       0x2070
-#define WGL_BIND_TO_TEXTURE_RGBA_ARB      0x2071
-#define WGL_TEXTURE_FORMAT_ARB            0x2072
-#define WGL_TEXTURE_TARGET_ARB            0x2073
-#define WGL_MIPMAP_TEXTURE_ARB            0x2074
-#define WGL_TEXTURE_RGB_ARB               0x2075
-#define WGL_TEXTURE_RGBA_ARB              0x2076
-#define WGL_NO_TEXTURE_ARB                0x2077
-#define WGL_TEXTURE_CUBE_MAP_ARB          0x2078
-#define WGL_TEXTURE_1D_ARB                0x2079
-#define WGL_TEXTURE_2D_ARB                0x207A
-#define WGL_MIPMAP_LEVEL_ARB              0x207B
-#define WGL_CUBE_MAP_FACE_ARB             0x207C
-#define WGL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB 0x207D
-#define WGL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB 0x207E
-#define WGL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB 0x207F
-#define WGL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB 0x2080
-#define WGL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB 0x2081
-#define WGL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB 0x2082
-#define WGL_FRONT_LEFT_ARB                0x2083
-#define WGL_FRONT_RIGHT_ARB               0x2084
-#define WGL_BACK_LEFT_ARB                 0x2085
-#define WGL_BACK_RIGHT_ARB                0x2086
-#define WGL_AUX0_ARB                      0x2087
-#define WGL_AUX1_ARB                      0x2088
-#define WGL_AUX2_ARB                      0x2089
-#define WGL_AUX3_ARB                      0x208A
-#define WGL_AUX4_ARB                      0x208B
-#define WGL_AUX5_ARB                      0x208C
-#define WGL_AUX6_ARB                      0x208D
-#define WGL_AUX7_ARB                      0x208E
-#define WGL_AUX8_ARB                      0x208F
-#define WGL_AUX9_ARB                      0x2090
-typedef BOOL (WINAPI * PFNWGLBINDTEXIMAGEARBPROC) (HPBUFFERARB hPbuffer, int iBuffer);
-typedef BOOL (WINAPI * PFNWGLRELEASETEXIMAGEARBPROC) (HPBUFFERARB hPbuffer, int iBuffer);
-typedef BOOL (WINAPI * PFNWGLSETPBUFFERATTRIBARBPROC) (HPBUFFERARB hPbuffer, const int *piAttribList);
-#ifdef WGL_WGLEXT_PROTOTYPES
-BOOL WINAPI wglBindTexImageARB (HPBUFFERARB hPbuffer, int iBuffer);
-BOOL WINAPI wglReleaseTexImageARB (HPBUFFERARB hPbuffer, int iBuffer);
-BOOL WINAPI wglSetPbufferAttribARB (HPBUFFERARB hPbuffer, const int *piAttribList);
-#endif
-#endif /* WGL_ARB_render_texture */
-
-#ifndef WGL_ARB_robustness_application_isolation
-#define WGL_ARB_robustness_application_isolation 1
-#define WGL_CONTEXT_RESET_ISOLATION_BIT_ARB 0x00000008
-#endif /* WGL_ARB_robustness_application_isolation */
-
-#ifndef WGL_ARB_robustness_share_group_isolation
-#define WGL_ARB_robustness_share_group_isolation 1
-#endif /* WGL_ARB_robustness_share_group_isolation */
-
-#ifndef WGL_3DFX_multisample
-#define WGL_3DFX_multisample 1
-#define WGL_SAMPLE_BUFFERS_3DFX           0x2060
-#define WGL_SAMPLES_3DFX                  0x2061
-#endif /* WGL_3DFX_multisample */
-
-#ifndef WGL_3DL_stereo_control
-#define WGL_3DL_stereo_control 1
-#define WGL_STEREO_EMITTER_ENABLE_3DL     0x2055
-#define WGL_STEREO_EMITTER_DISABLE_3DL    0x2056
-#define WGL_STEREO_POLARITY_NORMAL_3DL    0x2057
-#define WGL_STEREO_POLARITY_INVERT_3DL    0x2058
-typedef BOOL (WINAPI * PFNWGLSETSTEREOEMITTERSTATE3DLPROC) (HDC hDC, UINT uState);
-#ifdef WGL_WGLEXT_PROTOTYPES
-BOOL WINAPI wglSetStereoEmitterState3DL (HDC hDC, UINT uState);
-#endif
-#endif /* WGL_3DL_stereo_control */
-
-#ifndef WGL_AMD_gpu_association
-#define WGL_AMD_gpu_association 1
-#define WGL_GPU_VENDOR_AMD                0x1F00
-#define WGL_GPU_RENDERER_STRING_AMD       0x1F01
-#define WGL_GPU_OPENGL_VERSION_STRING_AMD 0x1F02
-#define WGL_GPU_FASTEST_TARGET_GPUS_AMD   0x21A2
-#define WGL_GPU_RAM_AMD                   0x21A3
-#define WGL_GPU_CLOCK_AMD                 0x21A4
-#define WGL_GPU_NUM_PIPES_AMD             0x21A5
-#define WGL_GPU_NUM_SIMD_AMD              0x21A6
-#define WGL_GPU_NUM_RB_AMD                0x21A7
-#define WGL_GPU_NUM_SPI_AMD               0x21A8
-typedef UINT (WINAPI * PFNWGLGETGPUIDSAMDPROC) (UINT maxCount, UINT *ids);
-typedef INT (WINAPI * PFNWGLGETGPUINFOAMDPROC) (UINT id, int property, GLenum dataType, UINT size, void *data);
-typedef UINT (WINAPI * PFNWGLGETCONTEXTGPUIDAMDPROC) (HGLRC hglrc);
-typedef HGLRC (WINAPI * PFNWGLCREATEASSOCIATEDCONTEXTAMDPROC) (UINT id);
-typedef HGLRC (WINAPI * PFNWGLCREATEASSOCIATEDCONTEXTATTRIBSAMDPROC) (UINT id, HGLRC hShareContext, const int *attribList);
-typedef BOOL (WINAPI * PFNWGLDELETEASSOCIATEDCONTEXTAMDPROC) (HGLRC hglrc);
-typedef BOOL (WINAPI * PFNWGLMAKEASSOCIATEDCONTEXTCURRENTAMDPROC) (HGLRC hglrc);
-typedef HGLRC (WINAPI * PFNWGLGETCURRENTASSOCIATEDCONTEXTAMDPROC) (void);
-typedef VOID (WINAPI * PFNWGLBLITCONTEXTFRAMEBUFFERAMDPROC) (HGLRC dstCtx, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
-#ifdef WGL_WGLEXT_PROTOTYPES
-UINT WINAPI wglGetGPUIDsAMD (UINT maxCount, UINT *ids);
-INT WINAPI wglGetGPUInfoAMD (UINT id, int property, GLenum dataType, UINT size, void *data);
-UINT WINAPI wglGetContextGPUIDAMD (HGLRC hglrc);
-HGLRC WINAPI wglCreateAssociatedContextAMD (UINT id);
-HGLRC WINAPI wglCreateAssociatedContextAttribsAMD (UINT id, HGLRC hShareContext, const int *attribList);
-BOOL WINAPI wglDeleteAssociatedContextAMD (HGLRC hglrc);
-BOOL WINAPI wglMakeAssociatedContextCurrentAMD (HGLRC hglrc);
-HGLRC WINAPI wglGetCurrentAssociatedContextAMD (void);
-VOID WINAPI wglBlitContextFramebufferAMD (HGLRC dstCtx, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
-#endif
-#endif /* WGL_AMD_gpu_association */
-
-#ifndef WGL_ATI_pixel_format_float
-#define WGL_ATI_pixel_format_float 1
-#define WGL_TYPE_RGBA_FLOAT_ATI           0x21A0
-#endif /* WGL_ATI_pixel_format_float */
-
-#ifndef WGL_EXT_create_context_es2_profile
-#define WGL_EXT_create_context_es2_profile 1
-#define WGL_CONTEXT_ES2_PROFILE_BIT_EXT   0x00000004
-#endif /* WGL_EXT_create_context_es2_profile */
-
-#ifndef WGL_EXT_create_context_es_profile
-#define WGL_EXT_create_context_es_profile 1
-#define WGL_CONTEXT_ES_PROFILE_BIT_EXT    0x00000004
-#endif /* WGL_EXT_create_context_es_profile */
-
-#ifndef WGL_EXT_depth_float
-#define WGL_EXT_depth_float 1
-#define WGL_DEPTH_FLOAT_EXT               0x2040
-#endif /* WGL_EXT_depth_float */
-
-#ifndef WGL_EXT_display_color_table
-#define WGL_EXT_display_color_table 1
-typedef GLboolean (WINAPI * PFNWGLCREATEDISPLAYCOLORTABLEEXTPROC) (GLushort id);
-typedef GLboolean (WINAPI * PFNWGLLOADDISPLAYCOLORTABLEEXTPROC) (const GLushort *table, GLuint length);
-typedef GLboolean (WINAPI * PFNWGLBINDDISPLAYCOLORTABLEEXTPROC) (GLushort id);
-typedef VOID (WINAPI * PFNWGLDESTROYDISPLAYCOLORTABLEEXTPROC) (GLushort id);
-#ifdef WGL_WGLEXT_PROTOTYPES
-GLboolean WINAPI wglCreateDisplayColorTableEXT (GLushort id);
-GLboolean WINAPI wglLoadDisplayColorTableEXT (const GLushort *table, GLuint length);
-GLboolean WINAPI wglBindDisplayColorTableEXT (GLushort id);
-VOID WINAPI wglDestroyDisplayColorTableEXT (GLushort id);
-#endif
-#endif /* WGL_EXT_display_color_table */
-
-#ifndef WGL_EXT_extensions_string
-#define WGL_EXT_extensions_string 1
-typedef const char *(WINAPI * PFNWGLGETEXTENSIONSSTRINGEXTPROC) (void);
-#ifdef WGL_WGLEXT_PROTOTYPES
-const char *WINAPI wglGetExtensionsStringEXT (void);
-#endif
-#endif /* WGL_EXT_extensions_string */
-
-#ifndef WGL_EXT_framebuffer_sRGB
-#define WGL_EXT_framebuffer_sRGB 1
-#define WGL_FRAMEBUFFER_SRGB_CAPABLE_EXT  0x20A9
-#endif /* WGL_EXT_framebuffer_sRGB */
-
-#ifndef WGL_EXT_make_current_read
-#define WGL_EXT_make_current_read 1
-#define ERROR_INVALID_PIXEL_TYPE_EXT      0x2043
-typedef BOOL (WINAPI * PFNWGLMAKECONTEXTCURRENTEXTPROC) (HDC hDrawDC, HDC hReadDC, HGLRC hglrc);
-typedef HDC (WINAPI * PFNWGLGETCURRENTREADDCEXTPROC) (void);
-#ifdef WGL_WGLEXT_PROTOTYPES
-BOOL WINAPI wglMakeContextCurrentEXT (HDC hDrawDC, HDC hReadDC, HGLRC hglrc);
-HDC WINAPI wglGetCurrentReadDCEXT (void);
-#endif
-#endif /* WGL_EXT_make_current_read */
-
-#ifndef WGL_EXT_multisample
-#define WGL_EXT_multisample 1
-#define WGL_SAMPLE_BUFFERS_EXT            0x2041
-#define WGL_SAMPLES_EXT                   0x2042
-#endif /* WGL_EXT_multisample */
-
-#ifndef WGL_EXT_pbuffer
-#define WGL_EXT_pbuffer 1
-DECLARE_HANDLE(HPBUFFEREXT);
-#define WGL_DRAW_TO_PBUFFER_EXT           0x202D
-#define WGL_MAX_PBUFFER_PIXELS_EXT        0x202E
-#define WGL_MAX_PBUFFER_WIDTH_EXT         0x202F
-#define WGL_MAX_PBUFFER_HEIGHT_EXT        0x2030
-#define WGL_OPTIMAL_PBUFFER_WIDTH_EXT     0x2031
-#define WGL_OPTIMAL_PBUFFER_HEIGHT_EXT    0x2032
-#define WGL_PBUFFER_LARGEST_EXT           0x2033
-#define WGL_PBUFFER_WIDTH_EXT             0x2034
-#define WGL_PBUFFER_HEIGHT_EXT            0x2035
-typedef HPBUFFEREXT (WINAPI * PFNWGLCREATEPBUFFEREXTPROC) (HDC hDC, int iPixelFormat, int iWidth, int iHeight, const int *piAttribList);
-typedef HDC (WINAPI * PFNWGLGETPBUFFERDCEXTPROC) (HPBUFFEREXT hPbuffer);
-typedef int (WINAPI * PFNWGLRELEASEPBUFFERDCEXTPROC) (HPBUFFEREXT hPbuffer, HDC hDC);
-typedef BOOL (WINAPI * PFNWGLDESTROYPBUFFEREXTPROC) (HPBUFFEREXT hPbuffer);
-typedef BOOL (WINAPI * PFNWGLQUERYPBUFFEREXTPROC) (HPBUFFEREXT hPbuffer, int iAttribute, int *piValue);
-#ifdef WGL_WGLEXT_PROTOTYPES
-HPBUFFEREXT WINAPI wglCreatePbufferEXT (HDC hDC, int iPixelFormat, int iWidth, int iHeight, const int *piAttribList);
-HDC WINAPI wglGetPbufferDCEXT (HPBUFFEREXT hPbuffer);
-int WINAPI wglReleasePbufferDCEXT (HPBUFFEREXT hPbuffer, HDC hDC);
-BOOL WINAPI wglDestroyPbufferEXT (HPBUFFEREXT hPbuffer);
-BOOL WINAPI wglQueryPbufferEXT (HPBUFFEREXT hPbuffer, int iAttribute, int *piValue);
-#endif
-#endif /* WGL_EXT_pbuffer */
-
-#ifndef WGL_EXT_pixel_format
-#define WGL_EXT_pixel_format 1
-#define WGL_NUMBER_PIXEL_FORMATS_EXT      0x2000
-#define WGL_DRAW_TO_WINDOW_EXT            0x2001
-#define WGL_DRAW_TO_BITMAP_EXT            0x2002
-#define WGL_ACCELERATION_EXT              0x2003
-#define WGL_NEED_PALETTE_EXT              0x2004
-#define WGL_NEED_SYSTEM_PALETTE_EXT       0x2005
-#define WGL_SWAP_LAYER_BUFFERS_EXT        0x2006
-#define WGL_SWAP_METHOD_EXT               0x2007
-#define WGL_NUMBER_OVERLAYS_EXT           0x2008
-#define WGL_NUMBER_UNDERLAYS_EXT          0x2009
-#define WGL_TRANSPARENT_EXT               0x200A
-#define WGL_TRANSPARENT_VALUE_EXT         0x200B
-#define WGL_SHARE_DEPTH_EXT               0x200C
-#define WGL_SHARE_STENCIL_EXT             0x200D
-#define WGL_SHARE_ACCUM_EXT               0x200E
-#define WGL_SUPPORT_GDI_EXT               0x200F
-#define WGL_SUPPORT_OPENGL_EXT            0x2010
-#define WGL_DOUBLE_BUFFER_EXT             0x2011
-#define WGL_STEREO_EXT                    0x2012
-#define WGL_PIXEL_TYPE_EXT                0x2013
-#define WGL_COLOR_BITS_EXT                0x2014
-#define WGL_RED_BITS_EXT                  0x2015
-#define WGL_RED_SHIFT_EXT                 0x2016
-#define WGL_GREEN_BITS_EXT                0x2017
-#define WGL_GREEN_SHIFT_EXT               0x2018
-#define WGL_BLUE_BITS_EXT                 0x2019
-#define WGL_BLUE_SHIFT_EXT                0x201A
-#define WGL_ALPHA_BITS_EXT                0x201B
-#define WGL_ALPHA_SHIFT_EXT               0x201C
-#define WGL_ACCUM_BITS_EXT                0x201D
-#define WGL_ACCUM_RED_BITS_EXT            0x201E
-#define WGL_ACCUM_GREEN_BITS_EXT          0x201F
-#define WGL_ACCUM_BLUE_BITS_EXT           0x2020
-#define WGL_ACCUM_ALPHA_BITS_EXT          0x2021
-#define WGL_DEPTH_BITS_EXT                0x2022
-#define WGL_STENCIL_BITS_EXT              0x2023
-#define WGL_AUX_BUFFERS_EXT               0x2024
-#define WGL_NO_ACCELERATION_EXT           0x2025
-#define WGL_GENERIC_ACCELERATION_EXT      0x2026
-#define WGL_FULL_ACCELERATION_EXT         0x2027
-#define WGL_SWAP_EXCHANGE_EXT             0x2028
-#define WGL_SWAP_COPY_EXT                 0x2029
-#define WGL_SWAP_UNDEFINED_EXT            0x202A
-#define WGL_TYPE_RGBA_EXT                 0x202B
-#define WGL_TYPE_COLORINDEX_EXT           0x202C
-typedef BOOL (WINAPI * PFNWGLGETPIXELFORMATATTRIBIVEXTPROC) (HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, int *piAttributes, int *piValues);
-typedef BOOL (WINAPI * PFNWGLGETPIXELFORMATATTRIBFVEXTPROC) (HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, int *piAttributes, FLOAT *pfValues);
-typedef BOOL (WINAPI * PFNWGLCHOOSEPIXELFORMATEXTPROC) (HDC hdc, const int *piAttribIList, const FLOAT *pfAttribFList, UINT nMaxFormats, int *piFormats, UINT *nNumFormats);
-#ifdef WGL_WGLEXT_PROTOTYPES
-BOOL WINAPI wglGetPixelFormatAttribivEXT (HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, int *piAttributes, int *piValues);
-BOOL WINAPI wglGetPixelFormatAttribfvEXT (HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, int *piAttributes, FLOAT *pfValues);
-BOOL WINAPI wglChoosePixelFormatEXT (HDC hdc, const int *piAttribIList, const FLOAT *pfAttribFList, UINT nMaxFormats, int *piFormats, UINT *nNumFormats);
-#endif
-#endif /* WGL_EXT_pixel_format */
-
-#ifndef WGL_EXT_pixel_format_packed_float
-#define WGL_EXT_pixel_format_packed_float 1
-#define WGL_TYPE_RGBA_UNSIGNED_FLOAT_EXT  0x20A8
-#endif /* WGL_EXT_pixel_format_packed_float */
-
-#ifndef WGL_EXT_swap_control
-#define WGL_EXT_swap_control 1
-typedef BOOL (WINAPI * PFNWGLSWAPINTERVALEXTPROC) (int interval);
-typedef int (WINAPI * PFNWGLGETSWAPINTERVALEXTPROC) (void);
-#ifdef WGL_WGLEXT_PROTOTYPES
-BOOL WINAPI wglSwapIntervalEXT (int interval);
-int WINAPI wglGetSwapIntervalEXT (void);
-#endif
-#endif /* WGL_EXT_swap_control */
-
-#ifndef WGL_EXT_swap_control_tear
-#define WGL_EXT_swap_control_tear 1
-#endif /* WGL_EXT_swap_control_tear */
-
-#ifndef WGL_I3D_digital_video_control
-#define WGL_I3D_digital_video_control 1
-#define WGL_DIGITAL_VIDEO_CURSOR_ALPHA_FRAMEBUFFER_I3D 0x2050
-#define WGL_DIGITAL_VIDEO_CURSOR_ALPHA_VALUE_I3D 0x2051
-#define WGL_DIGITAL_VIDEO_CURSOR_INCLUDED_I3D 0x2052
-#define WGL_DIGITAL_VIDEO_GAMMA_CORRECTED_I3D 0x2053
-typedef BOOL (WINAPI * PFNWGLGETDIGITALVIDEOPARAMETERSI3DPROC) (HDC hDC, int iAttribute, int *piValue);
-typedef BOOL (WINAPI * PFNWGLSETDIGITALVIDEOPARAMETERSI3DPROC) (HDC hDC, int iAttribute, const int *piValue);
-#ifdef WGL_WGLEXT_PROTOTYPES
-BOOL WINAPI wglGetDigitalVideoParametersI3D (HDC hDC, int iAttribute, int *piValue);
-BOOL WINAPI wglSetDigitalVideoParametersI3D (HDC hDC, int iAttribute, const int *piValue);
-#endif
-#endif /* WGL_I3D_digital_video_control */
-
-#ifndef WGL_I3D_gamma
-#define WGL_I3D_gamma 1
-#define WGL_GAMMA_TABLE_SIZE_I3D          0x204E
-#define WGL_GAMMA_EXCLUDE_DESKTOP_I3D     0x204F
-typedef BOOL (WINAPI * PFNWGLGETGAMMATABLEPARAMETERSI3DPROC) (HDC hDC, int iAttribute, int *piValue);
-typedef BOOL (WINAPI * PFNWGLSETGAMMATABLEPARAMETERSI3DPROC) (HDC hDC, int iAttribute, const int *piValue);
-typedef BOOL (WINAPI * PFNWGLGETGAMMATABLEI3DPROC) (HDC hDC, int iEntries, USHORT *puRed, USHORT *puGreen, USHORT *puBlue);
-typedef BOOL (WINAPI * PFNWGLSETGAMMATABLEI3DPROC) (HDC hDC, int iEntries, const USHORT *puRed, const USHORT *puGreen, const USHORT *puBlue);
-#ifdef WGL_WGLEXT_PROTOTYPES
-BOOL WINAPI wglGetGammaTableParametersI3D (HDC hDC, int iAttribute, int *piValue);
-BOOL WINAPI wglSetGammaTableParametersI3D (HDC hDC, int iAttribute, const int *piValue);
-BOOL WINAPI wglGetGammaTableI3D (HDC hDC, int iEntries, USHORT *puRed, USHORT *puGreen, USHORT *puBlue);
-BOOL WINAPI wglSetGammaTableI3D (HDC hDC, int iEntries, const USHORT *puRed, const USHORT *puGreen, const USHORT *puBlue);
-#endif
-#endif /* WGL_I3D_gamma */
-
-#ifndef WGL_I3D_genlock
-#define WGL_I3D_genlock 1
-#define WGL_GENLOCK_SOURCE_MULTIVIEW_I3D  0x2044
-#define WGL_GENLOCK_SOURCE_EXTERNAL_SYNC_I3D 0x2045
-#define WGL_GENLOCK_SOURCE_EXTERNAL_FIELD_I3D 0x2046
-#define WGL_GENLOCK_SOURCE_EXTERNAL_TTL_I3D 0x2047
-#define WGL_GENLOCK_SOURCE_DIGITAL_SYNC_I3D 0x2048
-#define WGL_GENLOCK_SOURCE_DIGITAL_FIELD_I3D 0x2049
-#define WGL_GENLOCK_SOURCE_EDGE_FALLING_I3D 0x204A
-#define WGL_GENLOCK_SOURCE_EDGE_RISING_I3D 0x204B
-#define WGL_GENLOCK_SOURCE_EDGE_BOTH_I3D  0x204C
-typedef BOOL (WINAPI * PFNWGLENABLEGENLOCKI3DPROC) (HDC hDC);
-typedef BOOL (WINAPI * PFNWGLDISABLEGENLOCKI3DPROC) (HDC hDC);
-typedef BOOL (WINAPI * PFNWGLISENABLEDGENLOCKI3DPROC) (HDC hDC, BOOL *pFlag);
-typedef BOOL (WINAPI * PFNWGLGENLOCKSOURCEI3DPROC) (HDC hDC, UINT uSource);
-typedef BOOL (WINAPI * PFNWGLGETGENLOCKSOURCEI3DPROC) (HDC hDC, UINT *uSource);
-typedef BOOL (WINAPI * PFNWGLGENLOCKSOURCEEDGEI3DPROC) (HDC hDC, UINT uEdge);
-typedef BOOL (WINAPI * PFNWGLGETGENLOCKSOURCEEDGEI3DPROC) (HDC hDC, UINT *uEdge);
-typedef BOOL (WINAPI * PFNWGLGENLOCKSAMPLERATEI3DPROC) (HDC hDC, UINT uRate);
-typedef BOOL (WINAPI * PFNWGLGETGENLOCKSAMPLERATEI3DPROC) (HDC hDC, UINT *uRate);
-typedef BOOL (WINAPI * PFNWGLGENLOCKSOURCEDELAYI3DPROC) (HDC hDC, UINT uDelay);
-typedef BOOL (WINAPI * PFNWGLGETGENLOCKSOURCEDELAYI3DPROC) (HDC hDC, UINT *uDelay);
-typedef BOOL (WINAPI * PFNWGLQUERYGENLOCKMAXSOURCEDELAYI3DPROC) (HDC hDC, UINT *uMaxLineDelay, UINT *uMaxPixelDelay);
-#ifdef WGL_WGLEXT_PROTOTYPES
-BOOL WINAPI wglEnableGenlockI3D (HDC hDC);
-BOOL WINAPI wglDisableGenlockI3D (HDC hDC);
-BOOL WINAPI wglIsEnabledGenlockI3D (HDC hDC, BOOL *pFlag);
-BOOL WINAPI wglGenlockSourceI3D (HDC hDC, UINT uSource);
-BOOL WINAPI wglGetGenlockSourceI3D (HDC hDC, UINT *uSource);
-BOOL WINAPI wglGenlockSourceEdgeI3D (HDC hDC, UINT uEdge);
-BOOL WINAPI wglGetGenlockSourceEdgeI3D (HDC hDC, UINT *uEdge);
-BOOL WINAPI wglGenlockSampleRateI3D (HDC hDC, UINT uRate);
-BOOL WINAPI wglGetGenlockSampleRateI3D (HDC hDC, UINT *uRate);
-BOOL WINAPI wglGenlockSourceDelayI3D (HDC hDC, UINT uDelay);
-BOOL WINAPI wglGetGenlockSourceDelayI3D (HDC hDC, UINT *uDelay);
-BOOL WINAPI wglQueryGenlockMaxSourceDelayI3D (HDC hDC, UINT *uMaxLineDelay, UINT *uMaxPixelDelay);
-#endif
-#endif /* WGL_I3D_genlock */
-
-#ifndef WGL_I3D_image_buffer
-#define WGL_I3D_image_buffer 1
-#define WGL_IMAGE_BUFFER_MIN_ACCESS_I3D   0x00000001
-#define WGL_IMAGE_BUFFER_LOCK_I3D         0x00000002
-typedef LPVOID (WINAPI * PFNWGLCREATEIMAGEBUFFERI3DPROC) (HDC hDC, DWORD dwSize, UINT uFlags);
-typedef BOOL (WINAPI * PFNWGLDESTROYIMAGEBUFFERI3DPROC) (HDC hDC, LPVOID pAddress);
-typedef BOOL (WINAPI * PFNWGLASSOCIATEIMAGEBUFFEREVENTSI3DPROC) (HDC hDC, const HANDLE *pEvent, const LPVOID *pAddress, const DWORD *pSize, UINT count);
-typedef BOOL (WINAPI * PFNWGLRELEASEIMAGEBUFFEREVENTSI3DPROC) (HDC hDC, const LPVOID *pAddress, UINT count);
-#ifdef WGL_WGLEXT_PROTOTYPES
-LPVOID WINAPI wglCreateImageBufferI3D (HDC hDC, DWORD dwSize, UINT uFlags);
-BOOL WINAPI wglDestroyImageBufferI3D (HDC hDC, LPVOID pAddress);
-BOOL WINAPI wglAssociateImageBufferEventsI3D (HDC hDC, const HANDLE *pEvent, const LPVOID *pAddress, const DWORD *pSize, UINT count);
-BOOL WINAPI wglReleaseImageBufferEventsI3D (HDC hDC, const LPVOID *pAddress, UINT count);
-#endif
-#endif /* WGL_I3D_image_buffer */
-
-#ifndef WGL_I3D_swap_frame_lock
-#define WGL_I3D_swap_frame_lock 1
-typedef BOOL (WINAPI * PFNWGLENABLEFRAMELOCKI3DPROC) (void);
-typedef BOOL (WINAPI * PFNWGLDISABLEFRAMELOCKI3DPROC) (void);
-typedef BOOL (WINAPI * PFNWGLISENABLEDFRAMELOCKI3DPROC) (BOOL *pFlag);
-typedef BOOL (WINAPI * PFNWGLQUERYFRAMELOCKMASTERI3DPROC) (BOOL *pFlag);
-#ifdef WGL_WGLEXT_PROTOTYPES
-BOOL WINAPI wglEnableFrameLockI3D (void);
-BOOL WINAPI wglDisableFrameLockI3D (void);
-BOOL WINAPI wglIsEnabledFrameLockI3D (BOOL *pFlag);
-BOOL WINAPI wglQueryFrameLockMasterI3D (BOOL *pFlag);
-#endif
-#endif /* WGL_I3D_swap_frame_lock */
-
-#ifndef WGL_I3D_swap_frame_usage
-#define WGL_I3D_swap_frame_usage 1
-typedef BOOL (WINAPI * PFNWGLGETFRAMEUSAGEI3DPROC) (float *pUsage);
-typedef BOOL (WINAPI * PFNWGLBEGINFRAMETRACKINGI3DPROC) (void);
-typedef BOOL (WINAPI * PFNWGLENDFRAMETRACKINGI3DPROC) (void);
-typedef BOOL (WINAPI * PFNWGLQUERYFRAMETRACKINGI3DPROC) (DWORD *pFrameCount, DWORD *pMissedFrames, float *pLastMissedUsage);
-#ifdef WGL_WGLEXT_PROTOTYPES
-BOOL WINAPI wglGetFrameUsageI3D (float *pUsage);
-BOOL WINAPI wglBeginFrameTrackingI3D (void);
-BOOL WINAPI wglEndFrameTrackingI3D (void);
-BOOL WINAPI wglQueryFrameTrackingI3D (DWORD *pFrameCount, DWORD *pMissedFrames, float *pLastMissedUsage);
-#endif
-#endif /* WGL_I3D_swap_frame_usage */
-
-#ifndef WGL_NV_DX_interop
-#define WGL_NV_DX_interop 1
-#define WGL_ACCESS_READ_ONLY_NV           0x00000000
-#define WGL_ACCESS_READ_WRITE_NV          0x00000001
-#define WGL_ACCESS_WRITE_DISCARD_NV       0x00000002
-typedef BOOL (WINAPI * PFNWGLDXSETRESOURCESHAREHANDLENVPROC) (void *dxObject, HANDLE shareHandle);
-typedef HANDLE (WINAPI * PFNWGLDXOPENDEVICENVPROC) (void *dxDevice);
-typedef BOOL (WINAPI * PFNWGLDXCLOSEDEVICENVPROC) (HANDLE hDevice);
-typedef HANDLE (WINAPI * PFNWGLDXREGISTEROBJECTNVPROC) (HANDLE hDevice, void *dxObject, GLuint name, GLenum type, GLenum access);
-typedef BOOL (WINAPI * PFNWGLDXUNREGISTEROBJECTNVPROC) (HANDLE hDevice, HANDLE hObject);
-typedef BOOL (WINAPI * PFNWGLDXOBJECTACCESSNVPROC) (HANDLE hObject, GLenum access);
-typedef BOOL (WINAPI * PFNWGLDXLOCKOBJECTSNVPROC) (HANDLE hDevice, GLint count, HANDLE *hObjects);
-typedef BOOL (WINAPI * PFNWGLDXUNLOCKOBJECTSNVPROC) (HANDLE hDevice, GLint count, HANDLE *hObjects);
-#ifdef WGL_WGLEXT_PROTOTYPES
-BOOL WINAPI wglDXSetResourceShareHandleNV (void *dxObject, HANDLE shareHandle);
-HANDLE WINAPI wglDXOpenDeviceNV (void *dxDevice);
-BOOL WINAPI wglDXCloseDeviceNV (HANDLE hDevice);
-HANDLE WINAPI wglDXRegisterObjectNV (HANDLE hDevice, void *dxObject, GLuint name, GLenum type, GLenum access);
-BOOL WINAPI wglDXUnregisterObjectNV (HANDLE hDevice, HANDLE hObject);
-BOOL WINAPI wglDXObjectAccessNV (HANDLE hObject, GLenum access);
-BOOL WINAPI wglDXLockObjectsNV (HANDLE hDevice, GLint count, HANDLE *hObjects);
-BOOL WINAPI wglDXUnlockObjectsNV (HANDLE hDevice, GLint count, HANDLE *hObjects);
-#endif
-#endif /* WGL_NV_DX_interop */
-
-#ifndef WGL_NV_DX_interop2
-#define WGL_NV_DX_interop2 1
-#endif /* WGL_NV_DX_interop2 */
-
-#ifndef WGL_NV_copy_image
-#define WGL_NV_copy_image 1
-typedef BOOL (WINAPI * PFNWGLCOPYIMAGESUBDATANVPROC) (HGLRC hSrcRC, GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, HGLRC hDstRC, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei width, GLsizei height, GLsizei depth);
-#ifdef WGL_WGLEXT_PROTOTYPES
-BOOL WINAPI wglCopyImageSubDataNV (HGLRC hSrcRC, GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, HGLRC hDstRC, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei width, GLsizei height, GLsizei depth);
-#endif
-#endif /* WGL_NV_copy_image */
-
-#ifndef WGL_NV_delay_before_swap
-#define WGL_NV_delay_before_swap 1
-typedef BOOL (WINAPI * PFNWGLDELAYBEFORESWAPNVPROC) (HDC hDC, GLfloat seconds);
-#ifdef WGL_WGLEXT_PROTOTYPES
-BOOL WINAPI wglDelayBeforeSwapNV (HDC hDC, GLfloat seconds);
-#endif
-#endif /* WGL_NV_delay_before_swap */
-
-#ifndef WGL_NV_float_buffer
-#define WGL_NV_float_buffer 1
-#define WGL_FLOAT_COMPONENTS_NV           0x20B0
-#define WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_R_NV 0x20B1
-#define WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RG_NV 0x20B2
-#define WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGB_NV 0x20B3
-#define WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGBA_NV 0x20B4
-#define WGL_TEXTURE_FLOAT_R_NV            0x20B5
-#define WGL_TEXTURE_FLOAT_RG_NV           0x20B6
-#define WGL_TEXTURE_FLOAT_RGB_NV          0x20B7
-#define WGL_TEXTURE_FLOAT_RGBA_NV         0x20B8
-#endif /* WGL_NV_float_buffer */
-
-#ifndef WGL_NV_gpu_affinity
-#define WGL_NV_gpu_affinity 1
-DECLARE_HANDLE(HGPUNV);
-struct _GPU_DEVICE {
-    DWORD  cb;
-    CHAR   DeviceName[32];
-    CHAR   DeviceString[128];
-    DWORD  Flags;
-    RECT   rcVirtualScreen;
-};
-typedef struct _GPU_DEVICE *PGPU_DEVICE;
-#define ERROR_INCOMPATIBLE_AFFINITY_MASKS_NV 0x20D0
-#define ERROR_MISSING_AFFINITY_MASK_NV    0x20D1
-typedef BOOL (WINAPI * PFNWGLENUMGPUSNVPROC) (UINT iGpuIndex, HGPUNV *phGpu);
-typedef BOOL (WINAPI * PFNWGLENUMGPUDEVICESNVPROC) (HGPUNV hGpu, UINT iDeviceIndex, PGPU_DEVICE lpGpuDevice);
-typedef HDC (WINAPI * PFNWGLCREATEAFFINITYDCNVPROC) (const HGPUNV *phGpuList);
-typedef BOOL (WINAPI * PFNWGLENUMGPUSFROMAFFINITYDCNVPROC) (HDC hAffinityDC, UINT iGpuIndex, HGPUNV *hGpu);
-typedef BOOL (WINAPI * PFNWGLDELETEDCNVPROC) (HDC hdc);
-#ifdef WGL_WGLEXT_PROTOTYPES
-BOOL WINAPI wglEnumGpusNV (UINT iGpuIndex, HGPUNV *phGpu);
-BOOL WINAPI wglEnumGpuDevicesNV (HGPUNV hGpu, UINT iDeviceIndex, PGPU_DEVICE lpGpuDevice);
-HDC WINAPI wglCreateAffinityDCNV (const HGPUNV *phGpuList);
-BOOL WINAPI wglEnumGpusFromAffinityDCNV (HDC hAffinityDC, UINT iGpuIndex, HGPUNV *hGpu);
-BOOL WINAPI wglDeleteDCNV (HDC hdc);
-#endif
-#endif /* WGL_NV_gpu_affinity */
-
-#ifndef WGL_NV_multisample_coverage
-#define WGL_NV_multisample_coverage 1
-#define WGL_COVERAGE_SAMPLES_NV           0x2042
-#define WGL_COLOR_SAMPLES_NV              0x20B9
-#endif /* WGL_NV_multisample_coverage */
-
-#ifndef WGL_NV_present_video
-#define WGL_NV_present_video 1
-DECLARE_HANDLE(HVIDEOOUTPUTDEVICENV);
-#define WGL_NUM_VIDEO_SLOTS_NV            0x20F0
-typedef int (WINAPI * PFNWGLENUMERATEVIDEODEVICESNVPROC) (HDC hDC, HVIDEOOUTPUTDEVICENV *phDeviceList);
-typedef BOOL (WINAPI * PFNWGLBINDVIDEODEVICENVPROC) (HDC hDC, unsigned int uVideoSlot, HVIDEOOUTPUTDEVICENV hVideoDevice, const int *piAttribList);
-typedef BOOL (WINAPI * PFNWGLQUERYCURRENTCONTEXTNVPROC) (int iAttribute, int *piValue);
-#ifdef WGL_WGLEXT_PROTOTYPES
-int WINAPI wglEnumerateVideoDevicesNV (HDC hDC, HVIDEOOUTPUTDEVICENV *phDeviceList);
-BOOL WINAPI wglBindVideoDeviceNV (HDC hDC, unsigned int uVideoSlot, HVIDEOOUTPUTDEVICENV hVideoDevice, const int *piAttribList);
-BOOL WINAPI wglQueryCurrentContextNV (int iAttribute, int *piValue);
-#endif
-#endif /* WGL_NV_present_video */
-
-#ifndef WGL_NV_render_depth_texture
-#define WGL_NV_render_depth_texture 1
-#define WGL_BIND_TO_TEXTURE_DEPTH_NV      0x20A3
-#define WGL_BIND_TO_TEXTURE_RECTANGLE_DEPTH_NV 0x20A4
-#define WGL_DEPTH_TEXTURE_FORMAT_NV       0x20A5
-#define WGL_TEXTURE_DEPTH_COMPONENT_NV    0x20A6
-#define WGL_DEPTH_COMPONENT_NV            0x20A7
-#endif /* WGL_NV_render_depth_texture */
-
-#ifndef WGL_NV_render_texture_rectangle
-#define WGL_NV_render_texture_rectangle 1
-#define WGL_BIND_TO_TEXTURE_RECTANGLE_RGB_NV 0x20A0
-#define WGL_BIND_TO_TEXTURE_RECTANGLE_RGBA_NV 0x20A1
-#define WGL_TEXTURE_RECTANGLE_NV          0x20A2
-#endif /* WGL_NV_render_texture_rectangle */
-
-#ifndef WGL_NV_swap_group
-#define WGL_NV_swap_group 1
-typedef BOOL (WINAPI * PFNWGLJOINSWAPGROUPNVPROC) (HDC hDC, GLuint group);
-typedef BOOL (WINAPI * PFNWGLBINDSWAPBARRIERNVPROC) (GLuint group, GLuint barrier);
-typedef BOOL (WINAPI * PFNWGLQUERYSWAPGROUPNVPROC) (HDC hDC, GLuint *group, GLuint *barrier);
-typedef BOOL (WINAPI * PFNWGLQUERYMAXSWAPGROUPSNVPROC) (HDC hDC, GLuint *maxGroups, GLuint *maxBarriers);
-typedef BOOL (WINAPI * PFNWGLQUERYFRAMECOUNTNVPROC) (HDC hDC, GLuint *count);
-typedef BOOL (WINAPI * PFNWGLRESETFRAMECOUNTNVPROC) (HDC hDC);
-#ifdef WGL_WGLEXT_PROTOTYPES
-BOOL WINAPI wglJoinSwapGroupNV (HDC hDC, GLuint group);
-BOOL WINAPI wglBindSwapBarrierNV (GLuint group, GLuint barrier);
-BOOL WINAPI wglQuerySwapGroupNV (HDC hDC, GLuint *group, GLuint *barrier);
-BOOL WINAPI wglQueryMaxSwapGroupsNV (HDC hDC, GLuint *maxGroups, GLuint *maxBarriers);
-BOOL WINAPI wglQueryFrameCountNV (HDC hDC, GLuint *count);
-BOOL WINAPI wglResetFrameCountNV (HDC hDC);
-#endif
-#endif /* WGL_NV_swap_group */
-
-#ifndef WGL_NV_vertex_array_range
-#define WGL_NV_vertex_array_range 1
-typedef void *(WINAPI * PFNWGLALLOCATEMEMORYNVPROC) (GLsizei size, GLfloat readfreq, GLfloat writefreq, GLfloat priority);
-typedef void (WINAPI * PFNWGLFREEMEMORYNVPROC) (void *pointer);
-#ifdef WGL_WGLEXT_PROTOTYPES
-void *WINAPI wglAllocateMemoryNV (GLsizei size, GLfloat readfreq, GLfloat writefreq, GLfloat priority);
-void WINAPI wglFreeMemoryNV (void *pointer);
-#endif
-#endif /* WGL_NV_vertex_array_range */
-
-#ifndef WGL_NV_video_capture
-#define WGL_NV_video_capture 1
-DECLARE_HANDLE(HVIDEOINPUTDEVICENV);
-#define WGL_UNIQUE_ID_NV                  0x20CE
-#define WGL_NUM_VIDEO_CAPTURE_SLOTS_NV    0x20CF
-typedef BOOL (WINAPI * PFNWGLBINDVIDEOCAPTUREDEVICENVPROC) (UINT uVideoSlot, HVIDEOINPUTDEVICENV hDevice);
-typedef UINT (WINAPI * PFNWGLENUMERATEVIDEOCAPTUREDEVICESNVPROC) (HDC hDc, HVIDEOINPUTDEVICENV *phDeviceList);
-typedef BOOL (WINAPI * PFNWGLLOCKVIDEOCAPTUREDEVICENVPROC) (HDC hDc, HVIDEOINPUTDEVICENV hDevice);
-typedef BOOL (WINAPI * PFNWGLQUERYVIDEOCAPTUREDEVICENVPROC) (HDC hDc, HVIDEOINPUTDEVICENV hDevice, int iAttribute, int *piValue);
-typedef BOOL (WINAPI * PFNWGLRELEASEVIDEOCAPTUREDEVICENVPROC) (HDC hDc, HVIDEOINPUTDEVICENV hDevice);
-#ifdef WGL_WGLEXT_PROTOTYPES
-BOOL WINAPI wglBindVideoCaptureDeviceNV (UINT uVideoSlot, HVIDEOINPUTDEVICENV hDevice);
-UINT WINAPI wglEnumerateVideoCaptureDevicesNV (HDC hDc, HVIDEOINPUTDEVICENV *phDeviceList);
-BOOL WINAPI wglLockVideoCaptureDeviceNV (HDC hDc, HVIDEOINPUTDEVICENV hDevice);
-BOOL WINAPI wglQueryVideoCaptureDeviceNV (HDC hDc, HVIDEOINPUTDEVICENV hDevice, int iAttribute, int *piValue);
-BOOL WINAPI wglReleaseVideoCaptureDeviceNV (HDC hDc, HVIDEOINPUTDEVICENV hDevice);
-#endif
-#endif /* WGL_NV_video_capture */
-
-#ifndef WGL_NV_video_output
-#define WGL_NV_video_output 1
-DECLARE_HANDLE(HPVIDEODEV);
-#define WGL_BIND_TO_VIDEO_RGB_NV          0x20C0
-#define WGL_BIND_TO_VIDEO_RGBA_NV         0x20C1
-#define WGL_BIND_TO_VIDEO_RGB_AND_DEPTH_NV 0x20C2
-#define WGL_VIDEO_OUT_COLOR_NV            0x20C3
-#define WGL_VIDEO_OUT_ALPHA_NV            0x20C4
-#define WGL_VIDEO_OUT_DEPTH_NV            0x20C5
-#define WGL_VIDEO_OUT_COLOR_AND_ALPHA_NV  0x20C6
-#define WGL_VIDEO_OUT_COLOR_AND_DEPTH_NV  0x20C7
-#define WGL_VIDEO_OUT_FRAME               0x20C8
-#define WGL_VIDEO_OUT_FIELD_1             0x20C9
-#define WGL_VIDEO_OUT_FIELD_2             0x20CA
-#define WGL_VIDEO_OUT_STACKED_FIELDS_1_2  0x20CB
-#define WGL_VIDEO_OUT_STACKED_FIELDS_2_1  0x20CC
-typedef BOOL (WINAPI * PFNWGLGETVIDEODEVICENVPROC) (HDC hDC, int numDevices, HPVIDEODEV *hVideoDevice);
-typedef BOOL (WINAPI * PFNWGLRELEASEVIDEODEVICENVPROC) (HPVIDEODEV hVideoDevice);
-typedef BOOL (WINAPI * PFNWGLBINDVIDEOIMAGENVPROC) (HPVIDEODEV hVideoDevice, HPBUFFERARB hPbuffer, int iVideoBuffer);
-typedef BOOL (WINAPI * PFNWGLRELEASEVIDEOIMAGENVPROC) (HPBUFFERARB hPbuffer, int iVideoBuffer);
-typedef BOOL (WINAPI * PFNWGLSENDPBUFFERTOVIDEONVPROC) (HPBUFFERARB hPbuffer, int iBufferType, unsigned long *pulCounterPbuffer, BOOL bBlock);
-typedef BOOL (WINAPI * PFNWGLGETVIDEOINFONVPROC) (HPVIDEODEV hpVideoDevice, unsigned long *pulCounterOutputPbuffer, unsigned long *pulCounterOutputVideo);
-#ifdef WGL_WGLEXT_PROTOTYPES
-BOOL WINAPI wglGetVideoDeviceNV (HDC hDC, int numDevices, HPVIDEODEV *hVideoDevice);
-BOOL WINAPI wglReleaseVideoDeviceNV (HPVIDEODEV hVideoDevice);
-BOOL WINAPI wglBindVideoImageNV (HPVIDEODEV hVideoDevice, HPBUFFERARB hPbuffer, int iVideoBuffer);
-BOOL WINAPI wglReleaseVideoImageNV (HPBUFFERARB hPbuffer, int iVideoBuffer);
-BOOL WINAPI wglSendPbufferToVideoNV (HPBUFFERARB hPbuffer, int iBufferType, unsigned long *pulCounterPbuffer, BOOL bBlock);
-BOOL WINAPI wglGetVideoInfoNV (HPVIDEODEV hpVideoDevice, unsigned long *pulCounterOutputPbuffer, unsigned long *pulCounterOutputVideo);
-#endif
-#endif /* WGL_NV_video_output */
-
-#ifndef WGL_OML_sync_control
-#define WGL_OML_sync_control 1
-typedef BOOL (WINAPI * PFNWGLGETSYNCVALUESOMLPROC) (HDC hdc, INT64 *ust, INT64 *msc, INT64 *sbc);
-typedef BOOL (WINAPI * PFNWGLGETMSCRATEOMLPROC) (HDC hdc, INT32 *numerator, INT32 *denominator);
-typedef INT64 (WINAPI * PFNWGLSWAPBUFFERSMSCOMLPROC) (HDC hdc, INT64 target_msc, INT64 divisor, INT64 remainder);
-typedef INT64 (WINAPI * PFNWGLSWAPLAYERBUFFERSMSCOMLPROC) (HDC hdc, int fuPlanes, INT64 target_msc, INT64 divisor, INT64 remainder);
-typedef BOOL (WINAPI * PFNWGLWAITFORMSCOMLPROC) (HDC hdc, INT64 target_msc, INT64 divisor, INT64 remainder, INT64 *ust, INT64 *msc, INT64 *sbc);
-typedef BOOL (WINAPI * PFNWGLWAITFORSBCOMLPROC) (HDC hdc, INT64 target_sbc, INT64 *ust, INT64 *msc, INT64 *sbc);
-#ifdef WGL_WGLEXT_PROTOTYPES
-BOOL WINAPI wglGetSyncValuesOML (HDC hdc, INT64 *ust, INT64 *msc, INT64 *sbc);
-BOOL WINAPI wglGetMscRateOML (HDC hdc, INT32 *numerator, INT32 *denominator);
-INT64 WINAPI wglSwapBuffersMscOML (HDC hdc, INT64 target_msc, INT64 divisor, INT64 remainder);
-INT64 WINAPI wglSwapLayerBuffersMscOML (HDC hdc, int fuPlanes, INT64 target_msc, INT64 divisor, INT64 remainder);
-BOOL WINAPI wglWaitForMscOML (HDC hdc, INT64 target_msc, INT64 divisor, INT64 remainder, INT64 *ust, INT64 *msc, INT64 *sbc);
-BOOL WINAPI wglWaitForSbcOML (HDC hdc, INT64 target_sbc, INT64 *ust, INT64 *msc, INT64 *sbc);
-#endif
-#endif /* WGL_OML_sync_control */
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif

deps/linmath.h

@@ -37,7 +37,7 @@ static inline float vec##n##_mul_inner(vec##n const a, vec##n const b) \
 } \
 static inline float vec##n##_len(vec##n const v) \
 { \
-	return sqrtf(vec##n##_mul_inner(v,v)); \
+	return (float) sqrt(vec##n##_mul_inner(v,v)); \
 } \
 static inline void vec##n##_norm(vec##n r, vec##n const v) \
 { \
@@ -554,7 +554,7 @@ static inline void quat_from_mat4x4(quat q, mat4x4 M)
 		p = &perm[i];
 	}
 
-	r = sqrtf(1.f + M[p[0]][p[0]] - M[p[1]][p[1]] - M[p[2]][p[2]] );
+	r = (float) sqrt(1.f + M[p[0]][p[0]] - M[p[1]][p[1]] - M[p[2]][p[2]] );
 
 	if(r < 1e-6) {
 		q[0] = 1.f;

deps/mingw/_mingw_dxhelper.h

@@ -0,0 +1,117 @@
+/**
+ * This file has no copyright assigned and is placed in the Public Domain.
+ * This file is part of the mingw-w64 runtime package.
+ * No warranty is given; refer to the file DISCLAIMER within this package.
+ */
+
+#if defined(_MSC_VER) && !defined(_MSC_EXTENSIONS)
+#define NONAMELESSUNION		1
+#endif
+#if defined(NONAMELESSSTRUCT) && \
+   !defined(NONAMELESSUNION)
+#define NONAMELESSUNION		1
+#endif
+#if defined(NONAMELESSUNION)  && \
+   !defined(NONAMELESSSTRUCT)
+#define NONAMELESSSTRUCT	1
+#endif
+#if !defined(__GNU_EXTENSION)
+#if defined(__GNUC__) || defined(__GNUG__)
+#define __GNU_EXTENSION		__extension__
+#else
+#define __GNU_EXTENSION
+#endif
+#endif /* __extension__ */
+
+#ifndef __ANONYMOUS_DEFINED
+#define __ANONYMOUS_DEFINED
+#if defined(__GNUC__) || defined(__GNUG__)
+#define _ANONYMOUS_UNION	__extension__
+#define _ANONYMOUS_STRUCT	__extension__
+#else
+#define _ANONYMOUS_UNION
+#define _ANONYMOUS_STRUCT
+#endif
+#ifndef NONAMELESSUNION
+#define _UNION_NAME(x)
+#define _STRUCT_NAME(x)
+#else /* NONAMELESSUNION */
+#define _UNION_NAME(x)  x
+#define _STRUCT_NAME(x) x
+#endif
+#endif	/* __ANONYMOUS_DEFINED */
+
+#ifndef DUMMYUNIONNAME
+# ifdef NONAMELESSUNION
+#  define DUMMYUNIONNAME  u
+#  define DUMMYUNIONNAME1 u1	/* Wine uses this variant */
+#  define DUMMYUNIONNAME2 u2
+#  define DUMMYUNIONNAME3 u3
+#  define DUMMYUNIONNAME4 u4
+#  define DUMMYUNIONNAME5 u5
+#  define DUMMYUNIONNAME6 u6
+#  define DUMMYUNIONNAME7 u7
+#  define DUMMYUNIONNAME8 u8
+#  define DUMMYUNIONNAME9 u9
+# else /* NONAMELESSUNION */
+#  define DUMMYUNIONNAME
+#  define DUMMYUNIONNAME1	/* Wine uses this variant */
+#  define DUMMYUNIONNAME2
+#  define DUMMYUNIONNAME3
+#  define DUMMYUNIONNAME4
+#  define DUMMYUNIONNAME5
+#  define DUMMYUNIONNAME6
+#  define DUMMYUNIONNAME7
+#  define DUMMYUNIONNAME8
+#  define DUMMYUNIONNAME9
+# endif
+#endif	/* DUMMYUNIONNAME */
+
+#if !defined(DUMMYUNIONNAME1)	/* MinGW does not define this one */
+# ifdef NONAMELESSUNION
+#  define DUMMYUNIONNAME1 u1	/* Wine uses this variant */
+# else
+#  define DUMMYUNIONNAME1	/* Wine uses this variant */
+# endif
+#endif	/* DUMMYUNIONNAME1 */
+
+#ifndef DUMMYSTRUCTNAME
+# ifdef NONAMELESSUNION
+#  define DUMMYSTRUCTNAME  s
+#  define DUMMYSTRUCTNAME1 s1	/* Wine uses this variant */
+#  define DUMMYSTRUCTNAME2 s2
+#  define DUMMYSTRUCTNAME3 s3
+#  define DUMMYSTRUCTNAME4 s4
+#  define DUMMYSTRUCTNAME5 s5
+# else
+#  define DUMMYSTRUCTNAME
+#  define DUMMYSTRUCTNAME1	/* Wine uses this variant */
+#  define DUMMYSTRUCTNAME2
+#  define DUMMYSTRUCTNAME3
+#  define DUMMYSTRUCTNAME4
+#  define DUMMYSTRUCTNAME5
+# endif
+#endif /* DUMMYSTRUCTNAME */
+
+/* These are for compatibility with the Wine source tree */
+
+#ifndef WINELIB_NAME_AW
+# ifdef __MINGW_NAME_AW
+#   define WINELIB_NAME_AW  __MINGW_NAME_AW
+# else
+#  ifdef UNICODE
+#   define WINELIB_NAME_AW(func) func##W
+#  else
+#   define WINELIB_NAME_AW(func) func##A
+#  endif
+# endif
+#endif	/* WINELIB_NAME_AW */
+
+#ifndef DECL_WINELIB_TYPE_AW
+# ifdef __MINGW_TYPEDEF_AW
+#  define DECL_WINELIB_TYPE_AW  __MINGW_TYPEDEF_AW
+# else
+#  define DECL_WINELIB_TYPE_AW(type)  typedef WINELIB_NAME_AW(type) type;
+# endif
+#endif	/* DECL_WINELIB_TYPE_AW */
+

deps/mingw/xinput.h

@@ -0,0 +1,239 @@
+/*
+ * The Wine project - Xinput Joystick Library
+ * Copyright 2008 Andrew Fenn
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#ifndef __WINE_XINPUT_H
+#define __WINE_XINPUT_H
+
+#include <windef.h>
+
+/*
+ * Bitmasks for the joysticks buttons, determines what has
+ * been pressed on the joystick, these need to be mapped
+ * to whatever device you're using instead of an xbox 360
+ * joystick
+ */
+
+#define XINPUT_GAMEPAD_DPAD_UP          0x0001
+#define XINPUT_GAMEPAD_DPAD_DOWN        0x0002
+#define XINPUT_GAMEPAD_DPAD_LEFT        0x0004
+#define XINPUT_GAMEPAD_DPAD_RIGHT       0x0008
+#define XINPUT_GAMEPAD_START            0x0010
+#define XINPUT_GAMEPAD_BACK             0x0020
+#define XINPUT_GAMEPAD_LEFT_THUMB       0x0040
+#define XINPUT_GAMEPAD_RIGHT_THUMB      0x0080
+#define XINPUT_GAMEPAD_LEFT_SHOULDER    0x0100
+#define XINPUT_GAMEPAD_RIGHT_SHOULDER   0x0200
+#define XINPUT_GAMEPAD_A                0x1000
+#define XINPUT_GAMEPAD_B                0x2000
+#define XINPUT_GAMEPAD_X                0x4000
+#define XINPUT_GAMEPAD_Y                0x8000
+
+/*
+ * Defines the flags used to determine if the user is pushing
+ * down on a button, not holding a button, etc
+ */
+
+#define XINPUT_KEYSTROKE_KEYDOWN        0x0001
+#define XINPUT_KEYSTROKE_KEYUP          0x0002
+#define XINPUT_KEYSTROKE_REPEAT         0x0004
+
+/*
+ * Defines the codes which are returned by XInputGetKeystroke
+ */
+
+#define VK_PAD_A                        0x5800
+#define VK_PAD_B                        0x5801
+#define VK_PAD_X                        0x5802
+#define VK_PAD_Y                        0x5803
+#define VK_PAD_RSHOULDER                0x5804
+#define VK_PAD_LSHOULDER                0x5805
+#define VK_PAD_LTRIGGER                 0x5806
+#define VK_PAD_RTRIGGER                 0x5807
+#define VK_PAD_DPAD_UP                  0x5810
+#define VK_PAD_DPAD_DOWN                0x5811
+#define VK_PAD_DPAD_LEFT                0x5812
+#define VK_PAD_DPAD_RIGHT               0x5813
+#define VK_PAD_START                    0x5814
+#define VK_PAD_BACK                     0x5815
+#define VK_PAD_LTHUMB_PRESS             0x5816
+#define VK_PAD_RTHUMB_PRESS             0x5817
+#define VK_PAD_LTHUMB_UP                0x5820
+#define VK_PAD_LTHUMB_DOWN              0x5821
+#define VK_PAD_LTHUMB_RIGHT             0x5822
+#define VK_PAD_LTHUMB_LEFT              0x5823
+#define VK_PAD_LTHUMB_UPLEFT            0x5824
+#define VK_PAD_LTHUMB_UPRIGHT           0x5825
+#define VK_PAD_LTHUMB_DOWNRIGHT         0x5826
+#define VK_PAD_LTHUMB_DOWNLEFT          0x5827
+#define VK_PAD_RTHUMB_UP                0x5830
+#define VK_PAD_RTHUMB_DOWN              0x5831
+#define VK_PAD_RTHUMB_RIGHT             0x5832
+#define VK_PAD_RTHUMB_LEFT              0x5833
+#define VK_PAD_RTHUMB_UPLEFT            0x5834
+#define VK_PAD_RTHUMB_UPRIGHT           0x5835
+#define VK_PAD_RTHUMB_DOWNRIGHT         0x5836
+#define VK_PAD_RTHUMB_DOWNLEFT          0x5837
+
+/*
+ * Deadzones are for analogue joystick controls on the joypad
+ * which determine when input should be assumed to be in the
+ * middle of the pad. This is a threshold to stop a joypad
+ * controlling the game when the player isn't touching the
+ * controls.
+ */
+
+#define XINPUT_GAMEPAD_LEFT_THUMB_DEADZONE  7849
+#define XINPUT_GAMEPAD_RIGHT_THUMB_DEADZONE 8689
+#define XINPUT_GAMEPAD_TRIGGER_THRESHOLD    30
+
+
+/*
+ * Defines what type of abilities the type of joystick has
+ * DEVTYPE_GAMEPAD is available for all joysticks, however
+ * there may be more specific identifiers for other joysticks
+ * which are being used.
+ */
+
+#define XINPUT_DEVTYPE_GAMEPAD          0x01
+#define XINPUT_DEVSUBTYPE_GAMEPAD       0x01
+#define XINPUT_DEVSUBTYPE_WHEEL         0x02
+#define XINPUT_DEVSUBTYPE_ARCADE_STICK  0x03
+#define XINPUT_DEVSUBTYPE_FLIGHT_SICK   0x04
+#define XINPUT_DEVSUBTYPE_DANCE_PAD     0x05
+#define XINPUT_DEVSUBTYPE_GUITAR        0x06
+#define XINPUT_DEVSUBTYPE_DRUM_KIT      0x08
+
+/*
+ * These are used with the XInputGetCapabilities function to
+ * determine the abilities to the joystick which has been
+ * plugged in.
+ */
+
+#define XINPUT_CAPS_VOICE_SUPPORTED     0x0004
+#define XINPUT_FLAG_GAMEPAD             0x00000001
+
+/*
+ * Defines the status of the battery if one is used in the
+ * attached joystick. The first two define if the joystick
+ * supports a battery. Disconnected means that the joystick
+ * isn't connected. Wired shows that the joystick is a wired
+ * joystick.
+ */
+
+#define BATTERY_DEVTYPE_GAMEPAD         0x00
+#define BATTERY_DEVTYPE_HEADSET         0x01
+#define BATTERY_TYPE_DISCONNECTED       0x00
+#define BATTERY_TYPE_WIRED              0x01
+#define BATTERY_TYPE_ALKALINE           0x02
+#define BATTERY_TYPE_NIMH               0x03
+#define BATTERY_TYPE_UNKNOWN            0xFF
+#define BATTERY_LEVEL_EMPTY             0x00
+#define BATTERY_LEVEL_LOW               0x01
+#define BATTERY_LEVEL_MEDIUM            0x02
+#define BATTERY_LEVEL_FULL              0x03
+
+/*
+ * How many joysticks can be used with this library. Games that
+ * use the xinput library will not go over this number.
+ */
+
+#define XUSER_MAX_COUNT                 4
+#define XUSER_INDEX_ANY                 0x000000FF
+
+/*
+ * Defines the structure of an xbox 360 joystick.
+ */
+
+typedef struct _XINPUT_GAMEPAD {
+    WORD wButtons;
+    BYTE bLeftTrigger;
+    BYTE bRightTrigger;
+    SHORT sThumbLX;
+    SHORT sThumbLY;
+    SHORT sThumbRX;
+    SHORT sThumbRY;
+} XINPUT_GAMEPAD, *PXINPUT_GAMEPAD;
+
+typedef struct _XINPUT_STATE {
+    DWORD dwPacketNumber;
+    XINPUT_GAMEPAD Gamepad;
+} XINPUT_STATE, *PXINPUT_STATE;
+
+/*
+ * Defines the structure of how much vibration is set on both the
+ * right and left motors in a joystick. If you're not using a 360
+ * joystick you will have to map these to your device.
+ */
+
+typedef struct _XINPUT_VIBRATION {
+    WORD wLeftMotorSpeed;
+    WORD wRightMotorSpeed;
+} XINPUT_VIBRATION, *PXINPUT_VIBRATION;
+
+/*
+ * Defines the structure for what kind of abilities the joystick has
+ * such abilities are things such as if the joystick has the ability
+ * to send and receive audio, if the joystick is in fact a driving
+ * wheel or perhaps if the joystick is some kind of dance pad or
+ * guitar.
+ */
+
+typedef struct _XINPUT_CAPABILITIES {
+    BYTE Type;
+    BYTE SubType;
+    WORD Flags;
+    XINPUT_GAMEPAD Gamepad;
+    XINPUT_VIBRATION Vibration;
+} XINPUT_CAPABILITIES, *PXINPUT_CAPABILITIES;
+
+/*
+ * Defines the structure for a joystick input event which is
+ * retrieved using the function XInputGetKeystroke
+ */
+typedef struct _XINPUT_KEYSTROKE {
+    WORD VirtualKey;
+    WCHAR Unicode;
+    WORD Flags;
+    BYTE UserIndex;
+    BYTE HidCode;
+} XINPUT_KEYSTROKE, *PXINPUT_KEYSTROKE;
+
+typedef struct _XINPUT_BATTERY_INFORMATION
+{
+    BYTE BatteryType;
+    BYTE BatteryLevel;
+} XINPUT_BATTERY_INFORMATION, *PXINPUT_BATTERY_INFORMATION;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void WINAPI XInputEnable(WINBOOL);
+DWORD WINAPI XInputSetState(DWORD, XINPUT_VIBRATION*);
+DWORD WINAPI XInputGetState(DWORD, XINPUT_STATE*);
+DWORD WINAPI XInputGetKeystroke(DWORD, DWORD, PXINPUT_KEYSTROKE);
+DWORD WINAPI XInputGetCapabilities(DWORD, DWORD, XINPUT_CAPABILITIES*);
+DWORD WINAPI XInputGetDSoundAudioDeviceGuids(DWORD, GUID*, GUID*);
+DWORD WINAPI XInputGetBatteryInformation(DWORD, BYTE, XINPUT_BATTERY_INFORMATION*);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __WINE_XINPUT_H */

deps/tinycthread.c

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

deps/tinycthread.h

@@ -78,6 +78,7 @@ freely, subject to the following restrictions:
 
 /* Platform specific includes */
 #if defined(_TTHREAD_POSIX_)
+  #include <sys/time.h>
   #include <pthread.h>
 #elif defined(_TTHREAD_WIN32_)
   #ifndef WIN32_LEAN_AND_MEAN

deps/vulkan/vk_platform.h

@@ -0,0 +1,120 @@
+//
+// File: vk_platform.h
+//
+/*
+** Copyright (c) 2014-2015 The Khronos Group Inc.
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+**     http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+
+
+#ifndef VK_PLATFORM_H_
+#define VK_PLATFORM_H_
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif // __cplusplus
+
+/*
+***************************************************************************************************
+*   Platform-specific directives and type declarations
+***************************************************************************************************
+*/
+
+/* Platform-specific calling convention macros.
+ *
+ * Platforms should define these so that Vulkan clients call Vulkan commands
+ * with the same calling conventions that the Vulkan implementation expects.
+ *
+ * VKAPI_ATTR - Placed before the return type in function declarations.
+ *              Useful for C++11 and GCC/Clang-style function attribute syntax.
+ * VKAPI_CALL - Placed after the return type in function declarations.
+ *              Useful for MSVC-style calling convention syntax.
+ * VKAPI_PTR  - Placed between the '(' and '*' in function pointer types.
+ *
+ * Function declaration:  VKAPI_ATTR void VKAPI_CALL vkCommand(void);
+ * Function pointer type: typedef void (VKAPI_PTR *PFN_vkCommand)(void);
+ */
+#if defined(_WIN32)
+    // On Windows, Vulkan commands use the stdcall convention
+    #define VKAPI_ATTR
+    #define VKAPI_CALL __stdcall
+    #define VKAPI_PTR  VKAPI_CALL
+#elif defined(__ANDROID__) && defined(__ARM_EABI__) && !defined(__ARM_ARCH_7A__)
+    // Android does not support Vulkan in native code using the "armeabi" ABI.
+    #error "Vulkan requires the 'armeabi-v7a' or 'armeabi-v7a-hard' ABI on 32-bit ARM CPUs"
+#elif defined(__ANDROID__) && defined(__ARM_ARCH_7A__)
+    // On Android/ARMv7a, Vulkan functions use the armeabi-v7a-hard calling
+    // convention, even if the application's native code is compiled with the
+    // armeabi-v7a calling convention.
+    #define VKAPI_ATTR __attribute__((pcs("aapcs-vfp")))
+    #define VKAPI_CALL
+    #define VKAPI_PTR  VKAPI_ATTR
+#else
+    // On other platforms, use the default calling convention
+    #define VKAPI_ATTR
+    #define VKAPI_CALL
+    #define VKAPI_PTR
+#endif
+
+#include <stddef.h>
+
+#if !defined(VK_NO_STDINT_H)
+    #if defined(_MSC_VER) && (_MSC_VER < 1600)
+        typedef signed   __int8  int8_t;
+        typedef unsigned __int8  uint8_t;
+        typedef signed   __int16 int16_t;
+        typedef unsigned __int16 uint16_t;
+        typedef signed   __int32 int32_t;
+        typedef unsigned __int32 uint32_t;
+        typedef signed   __int64 int64_t;
+        typedef unsigned __int64 uint64_t;
+    #else
+        #include <stdint.h>
+    #endif
+#endif // !defined(VK_NO_STDINT_H)
+
+#ifdef __cplusplus
+} // extern "C"
+#endif // __cplusplus
+
+// Platform-specific headers required by platform window system extensions.
+// These are enabled prior to #including "vulkan.h". The same enable then
+// controls inclusion of the extension interfaces in vulkan.h.
+
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+#include <android/native_window.h>
+#endif
+
+#ifdef VK_USE_PLATFORM_MIR_KHR
+#include <mir_toolkit/client_types.h>
+#endif
+
+#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+#include <wayland-client.h>
+#endif
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+#include <windows.h>
+#endif
+
+#ifdef VK_USE_PLATFORM_XLIB_KHR
+#include <X11/Xlib.h>
+#endif
+
+#ifdef VK_USE_PLATFORM_XCB_KHR
+#include <xcb/xcb.h>
+#endif
+
+#endif

docs/CMakeLists.txt

@@ -1,5 +1,32 @@
 
-add_custom_target(docs ALL ${DOXYGEN_EXECUTABLE}
-                  WORKING_DIRECTORY ${GLFW_BINARY_DIR}/docs
+set(glfw_DOCS_SOURCES
+    "${GLFW_SOURCE_DIR}/include/GLFW/glfw3.h"
+    "${GLFW_SOURCE_DIR}/include/GLFW/glfw3native.h"
+    "${GLFW_SOURCE_DIR}/docs/main.dox"
+    "${GLFW_SOURCE_DIR}/docs/news.dox"
+    "${GLFW_SOURCE_DIR}/docs/moving.dox"
+    "${GLFW_SOURCE_DIR}/docs/quick.dox"
+    "${GLFW_SOURCE_DIR}/docs/compile.dox"
+    "${GLFW_SOURCE_DIR}/docs/build.dox"
+    "${GLFW_SOURCE_DIR}/docs/intro.dox"
+    "${GLFW_SOURCE_DIR}/docs/context.dox"
+    "${GLFW_SOURCE_DIR}/docs/monitor.dox"
+    "${GLFW_SOURCE_DIR}/docs/window.dox"
+    "${GLFW_SOURCE_DIR}/docs/input.dox"
+    "${GLFW_SOURCE_DIR}/docs/vulkan.dox"
+    "${GLFW_SOURCE_DIR}/docs/compat.dox")
+
+if (GLFW_DOCUMENT_INTERNALS)
+    list(APPEND glfw_DOCS_SOURCES "${GLFW_SOURCE_DIR}/src/internal.h")
+endif()
+
+foreach(arg ${glfw_DOCS_SOURCES})
+    set(GLFW_DOCS_SOURCES "${GLFW_DOCS_SOURCES} ${arg}")
+endforeach()
+
+configure_file(Doxyfile.in Doxyfile @ONLY)
+                     
+add_custom_target(docs ALL "${DOXYGEN_EXECUTABLE}"
+                  WORKING_DIRECTORY "${GLFW_BINARY_DIR}/docs"
                   COMMENT "Generating HTML documentation" VERBATIM)
 

docs/Doxyfile.in

@@ -195,7 +195,15 @@ TAB_SIZE               = 8
 # will result in a user-defined paragraph with heading "Side Effects:".
 # You can put \n's in the value part of an alias to insert newlines.
 
-ALIASES                =
+ALIASES                = "thread_safety=@par Thread safety\n" \
+                         "pointer_lifetime=@par Pointer lifetime\n" \
+                         "analysis=@par Analysis\n" \
+                         "reentrancy=@par Reentrancy\n" \
+                         "errors=@par Errors\n" \
+                         "glfw3=@par\n__GLFW 3:__" \
+                         "x11=__X11:__" \
+                         "win32=__Windows:__" \
+                         "osx=__OS X:__"
 
 # This tag can be used to specify a number of word-keyword mappings (TCL only).
 # A mapping has the form "name=value". For example adding
@@ -652,22 +660,7 @@ WARN_LOGFILE           = @GLFW_BINARY_DIR@/docs/warnings.txt
 # directories like "/usr/src/myproject". Separate the files or directories
 # with spaces.
 
-INPUT                  = @GLFW_INTERNAL_DOCS@                         \
-                         @GLFW_SOURCE_DIR@/include/GLFW/glfw3.h       \
-                         @GLFW_SOURCE_DIR@/include/GLFW/glfw3native.h \
-                         @GLFW_SOURCE_DIR@/docs/main.dox              \
-                         @GLFW_SOURCE_DIR@/docs/news.dox              \
-                         @GLFW_SOURCE_DIR@/docs/moving.dox            \
-                         @GLFW_SOURCE_DIR@/docs/quick.dox             \
-                         @GLFW_SOURCE_DIR@/docs/compile.dox           \
-                         @GLFW_SOURCE_DIR@/docs/build.dox             \
-                         @GLFW_SOURCE_DIR@/docs/intro.dox             \
-                         @GLFW_SOURCE_DIR@/docs/context.dox           \
-                         @GLFW_SOURCE_DIR@/docs/monitor.dox           \
-                         @GLFW_SOURCE_DIR@/docs/window.dox            \
-                         @GLFW_SOURCE_DIR@/docs/input.dox             \
-                         @GLFW_SOURCE_DIR@/docs/rift.dox              \
-                         @GLFW_SOURCE_DIR@/docs/compat.dox
+INPUT                  = @GLFW_DOCS_SOURCES@
 
 # This tag can be used to specify the character encoding of the source files
 # that doxygen parses. Internally doxygen uses the UTF-8 encoding, which is
@@ -1573,14 +1566,17 @@ INCLUDE_FILE_PATTERNS  =
 # undefined via #undef or recursively expanded use the := operator
 # instead of the = operator.
 
-PREDEFINED             = GLFWAPI=                 \
-                         GLFW_EXPOSE_NATIVE_WIN32 \
-                         GLFW_EXPOSE_NATIVE_WGL   \
-                         GLFW_EXPOSE_NATIVE_X11   \
-                         GLFW_EXPOSE_NATIVE_GLX   \
-                         GLFW_EXPOSE_NATIVE_COCOA \
-                         GLFW_EXPOSE_NATIVE_NSGL  \
-                         GLFW_EXPOSE_NATIVE_EGL
+PREDEFINED             = GLFWAPI=                   \
+                         GLFW_EXPOSE_NATIVE_WIN32   \
+                         GLFW_EXPOSE_NATIVE_WGL     \
+                         GLFW_EXPOSE_NATIVE_X11     \
+                         GLFW_EXPOSE_NATIVE_WAYLAND \
+                         GLFW_EXPOSE_NATIVE_MIR     \
+                         GLFW_EXPOSE_NATIVE_GLX     \
+                         GLFW_EXPOSE_NATIVE_COCOA   \
+                         GLFW_EXPOSE_NATIVE_NSGL    \
+                         GLFW_EXPOSE_NATIVE_EGL     \
+                         VK_VERSION_1_0
 
 # If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then
 # this tag can be used to specify a list of macro names that should be expanded.

docs/build.dox

@@ -1,13 +1,13 @@
 /*!
 
-@page build Building applications
+@page build_guide Building applications
 
 @tableofcontents
 
 This is about compiling and linking applications that use GLFW.  For information on
-how to write such applications, start with the [introductory tutorial](@ref quick).
-For information on how to compile the GLFW library itself, see the @ref compile
-guide.
+how to write such applications, start with the
+[introductory tutorial](@ref quick_guide).  For information on how to compile
+the GLFW library itself, see @ref compile_guide.
 
 This is not a tutorial on compilation or linking.  It assumes basic
 understanding of how to compile and link a C program as well as how to use the
@@ -80,6 +80,9 @@ header instead of the regular OpenGL header.
 `GLFW_INCLUDE_ES31` makes the GLFW header include the OpenGL ES 3.1 `GLES3/gl31.h`
 header instead of the regular OpenGL header.
 
+`GLFW_INCLUDE_VULKAN` makes the GLFW header include the Vulkan `vulkan/vulkan.h`
+header instead of the regular OpenGL header.
+
 `GLFW_INCLUDE_NONE` makes the GLFW header not include any OpenGL or OpenGL ES API
 header.  This is useful in combination with an extension loading library.
 
@@ -148,86 +151,97 @@ uses OpenGL and `glu32` if it uses GLU.
 
 @subsection build_link_cmake_source With CMake and GLFW source
 
+This section is about using CMake to compile and link GLFW along with your
+application.  If you want to use an installed binary instead, see @ref
+build_link_cmake_package.
+
 With just a few changes to your `CMakeLists.txt` you can have the GLFW source
 tree built along with your application.
 
-Firstly, add the root directory of the GLFW source tree to your project.  This
+When including GLFW as part of your build, you probably don't want to build the
+GLFW tests, examples and documentation.  To disable these, set the corresponding
+cache variables before adding the GLFW source tree.
+
+@code
+set(GLFW_BUILD_DOCS OFF CACHE BOOL "" FORCE)
+set(GLFW_BUILD_TESTS OFF CACHE BOOL "" FORCE)
+set(GLFW_BUILD_EXAMPLES OFF CACHE BOOL "" FORCE)
+@endcode
+
+Then add the root directory of the GLFW source tree to your project.  This
 will add the `glfw` target and the necessary cache variables to your project.
 
 @code{.cmake}
 add_subdirectory(path/to/glfw)
 @endcode
 
-To be able to include the GLFW header from your code, you need to tell the
-compiler where to find it.
+Once GLFW has been added to the project, link against it with the `glfw` target.
+This adds all link-time dependencies of GLFW as it is currently configured,
+the include directory for the GLFW header and, when applicable, the
+[GLFW_DLL](@ref build_macros) macro.
 
 @code{.cmake}
-include_directories(path/to/glfw/include)
+target_link_libraries(myapp glfw)
 @endcode
 
-Once GLFW has been added to the project, the `GLFW_LIBRARIES` cache variable
-contains all link-time dependencies of GLFW as it is currently configured.  To
-link against GLFW, link against them and the `glfw` target.
+Note that it does not include GLU, as GLFW does not use it.  If your application
+needs GLU, you can find it by requiring the OpenGL package.
 
 @code{.cmake}
-target_link_libraries(myapp glfw ${GLFW_LIBRARIES})
+find_package(OpenGL REQUIRED)
 @endcode
 
-Note that `GLFW_LIBRARIES` does not include GLU, as GLFW does not use it.  If
-your application needs GLU, you can add it to the list of dependencies with the
-`OPENGL_glu_LIBRARY` cache variable, which is implicitly created when the GLFW
-CMake files look for OpenGL.
+If GLU is found, the `OPENGL_GLU_FOUND` variable is true and the
+`OPENGL_INCLUDE_DIR` and `OPENGL_glu_LIBRARY` cache variables can be used.
 
 @code{.cmake}
-target_link_libraries(myapp glfw ${OPENGL_glu_LIBRARY} ${GLFW_LIBRARIES})
+target_include_directories(myapp ${OPENGL_INCLUDE_DIR})
+target_link_libraries(myapp ${OPENGL_glu_LIBRARY})
 @endcode
 
 
-@subsection build_link_cmake_pkgconfig With CMake on Unix and installed GLFW binaries
+@subsection build_link_cmake_package With CMake and installed GLFW binaries
 
-CMake can import settings from pkg-config, which GLFW supports.  When you
-installed GLFW, the pkg-config file `glfw3.pc` was installed along with it.
+This section is about using CMake to link GLFW after it has been built and
+installed.  If you want to build it along with your application instead, see
+@ref build_link_cmake_source.
 
-First you need to find the PkgConfig package.  If this fails, you may need to
-install the pkg-config package for your distribution.
+With just a few changes to your `CMakeLists.txt`, you can locate the package and
+target files generated when GLFW is installed.
 
 @code{.cmake}
-find_package(PkgConfig REQUIRED)
+find_package(glfw3 3.2 REQUIRED)
 @endcode
 
-This creates the CMake commands to find pkg-config packages.  Then you need to
-find the GLFW package.
+Once GLFW has been located, link against it with the `glfw` target.  This adds
+all link-time dependencies of GLFW as it is currently configured, the include
+directory for the GLFW header and, when applicable, the
+[GLFW_DLL](@ref build_macros) macro.
 
 @code{.cmake}
-pkg_search_module(GLFW REQUIRED glfw3)
+target_link_libraries(myapp glfw)
 @endcode
 
-This creates the CMake variables you need to use GLFW.  To be able to include
-the GLFW header, you need to tell your compiler where it is.
+Note that it does not include GLU, as GLFW does not use it.  If your application
+needs GLU, you can find it by requiring the OpenGL package.
 
 @code{.cmake}
-include_directories(${GLFW_INCLUDE_DIRS})
+find_package(OpenGL REQUIRED)
 @endcode
 
-You also need to link against the correct libraries.  If you are using the
-shared library version of GLFW, use the `GLFW_LIBRARIES` variable.
+If GLU is found, the `OPENGL_GLU_FOUND` variable is true and the
+`OPENGL_INCLUDE_DIR` and `OPENGL_glu_LIBRARY` cache variables can be used.
 
 @code{.cmake}
-target_link_libraries(simple ${GLFW_LIBRARIES})
-@endcode
-
-If you are using the static library version of GLFW, use the
-`GLFW_STATIC_LIBRARIES` variable instead.
-
-@code{.cmake}
-target_link_libraries(simple ${GLFW_STATIC_LIBRARIES})
+target_include_directories(myapp ${OPENGL_INCLUDE_DIR})
+target_link_libraries(myapp ${OPENGL_glu_LIBRARY})
 @endcode
 
 
-@subsection build_link_pkgconfig With pkg-config on OS X or other Unix
+@subsection build_link_pkgconfig With makefiles and pkg-config on Unix
 
 GLFW supports [pkg-config](http://www.freedesktop.org/wiki/Software/pkg-config/),
-and the `glfw3.pc` pkf-config file is generated when the GLFW library is built
+and the `glfw3.pc` pkg-config file is generated when the GLFW library is built
 and is installed along with it.  A pkg-config file describes all necessary
 compile-time and link-time flags and dependencies needed to use a library.  When
 they are updated or if they differ between systems, you will get the correct
@@ -257,7 +271,7 @@ env PKG_CONFIG_PATH=path/to/glfw/src cc `pkg-config --cflags glfw3` -o myprog my
 The dependencies do not include GLU, as GLFW does not use it.  On OS X, GLU is
 built into the OpenGL framework, so if you need GLU you don't need to do
 anything extra.  If you need GLU and are using Linux or BSD, you should add the
-`glu` pkg-config module.
+`glu` pkg-config package.
 
 @code{.sh}
 cc `pkg-config --cflags glfw3 glu` -o myprog myprog.c `pkg-config --libs glfw3 glu`

docs/compat.dox

@@ -1,6 +1,6 @@
 /*!
 
-@page compat Standards conformance
+@page compat_guide Standards conformance
 
 @tableofcontents
 
@@ -63,10 +63,6 @@ GLFW uses the
 to provide file drop events.  If the application originating the drag does not
 support this protocol, drag and drop will not work.
 
-GLFW uses the XInput 2 extension to provide sub-pixel cursor motion events.  If
-the running X server does not support this version of this extension, cursor
-motion will be snapped to the pixel grid.
-
 GLFW uses the XRandR 1.3 extension to provide multi-monitor support.  If the
 running X server does not support this version of this extension, multi-monitor
 support will not function and only a single, desktop-spanning monitor will be
@@ -103,14 +99,14 @@ creating OpenGL contexts of version 2.1 and below.  Where this extension is
 unavailable, the `GLFW_CONTEXT_VERSION_MAJOR` and `GLFW_CONTEXT_VERSION_MINOR`
 hints will only be partially supported, the `GLFW_OPENGL_DEBUG_CONTEXT` hint
 will have no effect, and setting the `GLFW_OPENGL_PROFILE` or
-`GLFW_OPENGL_FORWARD_COMPAT` hints to `GL_TRUE` will cause @ref
+`GLFW_OPENGL_FORWARD_COMPAT` hints to `GLFW_TRUE` will cause @ref
 glfwCreateWindow to fail.
 
 GLFW uses the `GLX_ARB_create_context_profile` extension to provide support for
 context profiles.  Where this extension is unavailable, setting the
 `GLFW_OPENGL_PROFILE` hint to anything but `GLFW_OPENGL_ANY_PROFILE`, or setting
-`GLFW_CLIENT_API` to anything but `GLFW_OPENGL_API` will cause @ref
-glfwCreateWindow to fail.
+`GLFW_CLIENT_API` to anything but `GLFW_OPENGL_API` or `GLFW_NO_API` will cause
+@ref glfwCreateWindow to fail.
 
 GLFW uses the `GLX_ARB_context_flush_control` extension to provide control over
 whether a context is flushed when it is released (made non-current).  Where this
@@ -146,7 +142,7 @@ creating OpenGL contexts of version 2.1 and below.  Where this extension is
 unavailable, the `GLFW_CONTEXT_VERSION_MAJOR` and `GLFW_CONTEXT_VERSION_MINOR`
 hints will only be partially supported, the `GLFW_OPENGL_DEBUG_CONTEXT` hint
 will have no effect, and setting the `GLFW_OPENGL_PROFILE` or
-`GLFW_OPENGL_FORWARD_COMPAT` hints to `GL_TRUE` will cause @ref
+`GLFW_OPENGL_FORWARD_COMPAT` hints to `GLFW_TRUE` will cause @ref
 glfwCreateWindow to fail.
 
 GLFW uses the `WGL_ARB_create_context_profile` extension to provide support for
@@ -176,7 +172,7 @@ version 2.1.
 Because of this, on OS X 10.7 and later, the `GLFW_CONTEXT_VERSION_MAJOR` and
 `GLFW_CONTEXT_VERSION_MINOR` hints will cause @ref glfwCreateWindow to fail if
 given version 3.0 or 3.1, the `GLFW_OPENGL_FORWARD_COMPAT` hint must be set to
-`GL_TRUE` and the `GLFW_OPENGL_PROFILE` hint must be set to
+`GLFW_TRUE` and the `GLFW_OPENGL_PROFILE` hint must be set to
 `GLFW_OPENGL_CORE_PROFILE` when creating OpenGL 3.2 and later contexts and the
 `GLFW_OPENGL_DEBUG_CONTEXT` hint is ignored.
 
@@ -186,4 +182,43 @@ setting the `GLFW_OPENGL_PROFILE` or `GLFW_OPENGL_FORWARD_COMPAT` hints to
 a non-default value will cause @ref glfwCreateWindow to fail and the
 `GLFW_OPENGL_DEBUG_CONTEXT` hint is ignored.
 
+
+@section compat_vulkan Vulkan loader and API
+
+GLFW uses the standard system-wside Vulkan loader to access the Vulkan API.
+This should be installed by graphics drivers and Vulkan SDKs.  If this is not
+available, @ref glfwVulkanSupported will return `GLFW_FALSE` and all other
+Vulkan-related functions will fail with an @ref GLFW_API_UNAVAILABLE error.
+
+
+@section compat_wsi Vulkan WSI extensions
+
+The Vulkan WSI extensions are used to create Vulkan surfaces for GLFW windows on
+all supported platforms.
+
+GLFW uses the `VK_KHR_surface` and `VK_KHR_win32_surface` extensions to create
+surfaces on Microsoft Windows.  If any of these extensions are not available,
+@ref glfwGetRequiredInstanceExtensions will return an empty list and window
+surface creation will fail.
+
+GLFW uses the `VK_KHR_surface` and either the `VK_KHR_xlib_surface` or
+`VK_KHR_xcb_surface` extensions to create surfaces on X11.  If `VK_KHR_surface`
+or both `VK_KHR_xlib_surface` and `VK_KHR_xcb_surface` are not available, @ref
+glfwGetRequiredInstanceExtensions will return an empty list and window surface
+creation will fail.
+
+GLFW uses the `VK_KHR_surface` and `VK_KHR_wayland_surface` extensions to create
+surfaces on Wayland.  If any of these extensions are not available, @ref
+glfwGetRequiredInstanceExtensions will return an empty list and window surface
+creation will fail.
+
+GLFW uses the `VK_KHR_surface` and `VK_KHR_mir_surface` extensions to create
+surfaces on Mir.  If any of these extensions are not available, @ref
+glfwGetRequiredInstanceExtensions will return an empty list and window surface
+creation will fail.
+
+GLFW does not support any extensions for window surface creation on OS X,
+meaning@ref glfwGetRequiredInstanceExtensions will return an empty list and
+window surface creation will fail.
+
 */

docs/compile.dox

@@ -1,11 +1,11 @@
 /*!
 
-@page compile Compiling GLFW
+@page compile_guide Compiling GLFW
 
 @tableofcontents
 
 This is about compiling the GLFW library itself.  For information on how to
-build applications that use GLFW, see the @ref build guide.
+build applications that use GLFW, see @ref build_guide.
 
 
 @section compile_cmake Using CMake
@@ -87,13 +87,10 @@ Once you have Xcode installed, move on to @ref compile_generate.
 
 @subsubsection compile_deps_x11 Dependencies for Linux and X11
 
-To compile GLFW for X11, you need to have the X11 and OpenGL header packages
-installed, as well as the basic development tools like GCC and make.  For
-example, on Ubuntu and other distributions based on Debian GNU/Linux, you need
-to install the `xorg-dev` and `libgl1-mesa-dev` packages.  The former pulls in
-all X.org header packages and the latter pulls in the Mesa OpenGL development
-packages.  Note that using header files and libraries from Mesa during
-compilation _will not_ tie your binaries to the Mesa implementation of OpenGL.
+To compile GLFW for X11, you need to have the X11 packages installed, as well as
+the basic development tools like GCC and make.  For example, on Ubuntu and other
+distributions based on Debian GNU/Linux, you need to install the `xorg-dev`
+package, which pulls in all X.org header packages.
 
 Once you have installed the necessary packages, move on to @ref
 compile_generate.
@@ -159,7 +156,7 @@ necessary to compile GLFW.  Go ahead and compile the actual GLFW library with
 these files, as you would with any other project.
 
 Once the GLFW library is compiled, you are ready to build your applications,
-linking it to the GLFW library.  See the @ref build guide for more information.
+linking it to the GLFW library.  See @ref build_guide for more information.
 
 
 @subsection compile_options CMake options
@@ -169,9 +166,17 @@ available on all supported platforms.  Some of these are de facto standards
 among projects using CMake and so have no `GLFW_` prefix.
 
 If you are using the GUI version of CMake, these are listed and can be changed
-from there.  If you are using the command-line version, use the `ccmake` tool.
-Some package systems like Ubuntu and other distributions based on Debian
-GNU/Linux have this tool in a separate `cmake-curses-gui` package.
+from there.  If you are using the command-line version of CMake you can use the
+`ccmake` ncurses GUI to set options.  Some package systems like Ubuntu and other
+distributions based on Debian GNU/Linux have this tool in a separate
+`cmake-curses-gui` package.
+
+Finally, if you don't want to use any GUI, you can set options from the `cmake`
+command-line with the `-D` flag.
+
+@code{.sh}
+cmake -DBUILD_SHARED_LIBS=ON .
+@endcode
 
 
 @subsubsection compile_options_shared Shared CMake options
@@ -183,12 +188,6 @@ library or as a DLL / shared library / dynamic library.
 is empty, it is installed to `${CMAKE_INSTALL_PREFIX}/lib`.  If it is set to
 `64`, it is installed to `${CMAKE_INSTALL_PREFIX}/lib64`.
 
-`GLFW_CLIENT_LIBRARY` determines which client API library to use.  If set to
-`opengl` the OpenGL library is used, if set to `glesv1` for the OpenGL ES 1.x
-library is used, or if set to `glesv2` the OpenGL ES 2.0 library is used.  The
-selected library and its header files must be present on the system for this to
-work.
-
 `GLFW_BUILD_EXAMPLES` determines whether the GLFW examples are built
 along with the library.
 
@@ -210,8 +209,6 @@ directory of bundled applications to the `Contents/Resources` directory.
 `GLFW_USE_RETINA` determines whether windows will use the full resolution of
 Retina displays.
 
-`GLFW_BUILD_UNIVERSAL` determines whether to build Universal Binaries.
-
 
 @subsubsection compile_options_win32 Windows specific CMake options
 
@@ -228,19 +225,13 @@ need to be exported by the EXE to be detected by the driver, so the override
 will not work if GLFW is built as a DLL.
 
 
-@subsubsection compile_options_egl EGL specific CMake options
-
-`GLFW_USE_EGL` determines whether to use EGL instead of the platform-specific
-context creation API.  Note that EGL is not yet provided on all supported
-platforms.
-
-
 @section compile_manual Compiling GLFW manually
 
 If you wish to compile GLFW without its CMake build environment then you will
 have to do at least some of the platform detection yourself.  GLFW needs
-a number of configuration macros to be defined in order to know what it's being
-compiled for and has many optional, platform-specific ones for various features.
+a configuration macro to be defined in order to know what window system it's
+being compiled for and also has optional, platform-specific ones for various
+features.
 
 When building with CMake, the `glfw_config.h` configuration header is generated
 based on the current platform and CMake options.  The GLFW CMake environment
@@ -248,10 +239,6 @@ defines `_GLFW_USE_CONFIG_H`, which causes this header to be included by
 `internal.h`.  Without this macro, GLFW will expect the necessary configuration
 macros to be defined on the command-line.
 
-Three macros _must_ be defined when compiling GLFW: one selecting the window
-creation API, one selecting the context creation API and one client library.
-Exactly one of each kind must be defined for GLFW to compile and link.
-
 The window creation API is used to create windows, handle input, monitors, gamma
 ramps and clipboard.  The options are:
 
@@ -261,38 +248,17 @@ ramps and clipboard.  The options are:
  - `_GLFW_WAYLAND` to use the Wayland API (experimental and incomplete)
  - `_GLFW_MIR` to use the Mir API (experimental and incomplete)
 
-The context creation API is used to enumerate pixel formats / framebuffer
-configurations and to create contexts.  The options are:
-
- - `_GLFW_NSGL` to use the Cocoa OpenGL framework
- - `_GLFW_WGL` to use the Win32 WGL API
- - `_GLFW_GLX` to use the X11 GLX API
- - `_GLFW_EGL` to use the EGL API
-
-Wayland and Mir both require the EGL backend.
-
-The client library is the one providing the OpenGL or OpenGL ES API, which is
-used by GLFW to probe the created context.  This is not the same thing as the
-client API, as many desktop OpenGL client libraries now expose the OpenGL ES API
-through extensions.  The options are:
-
- - `_GLFW_USE_OPENGL` for the desktop OpenGL (opengl32.dll, libGL.so or
-   OpenGL.framework)
- - `_GLFW_USE_GLESV1` for OpenGL ES 1.x (experimental)
- - `_GLFW_USE_GLESV2` for OpenGL ES 2.x (experimental)
-
-Note that `_GLFW_USE_GLESV1` and `_GLFW_USE_GLESV2` may only be used with EGL,
-as the other context creation APIs do not interface with OpenGL ES client
-libraries.
-
 If you are building GLFW as a shared library / dynamic library / DLL then you
-must also define `_GLFW_BUILD_DLL`.  Otherwise, you may not define it.
+must also define `_GLFW_BUILD_DLL`.  Otherwise, you must not define it.
+
+For the EGL context creation API, the following options are available:
+
+ - `_GLFW_USE_EGLPLATFORM_H` to use `EGL/eglplatform.h` for native handle
+   definitions (fallback)
 
 If you are using the X11 window creation API, support for the following X11
 extensions can be enabled:
 
- - `_GLFW_HAS_XINPUT` to use XInput2 for high-resolution cursor motion
- (recommended)
  - `_GLFW_HAS_XF86VM` to use Xxf86vm as a fallback when RandR gamma is broken
  (recommended)
 

docs/context.dox

@@ -1,16 +1,19 @@
 /*!
 
-@page context Context guide
+@page context_guide Context guide
 
 @tableofcontents
 
 This guide introduces the OpenGL and OpenGL ES context related functions of
-GLFW.  There are also guides for the other areas of the GLFW API.
+GLFW.  For details on a specific function, see the
+[reference documentation](@ref context).  There are also guides for the other
+areas of the GLFW API.
 
- - @ref intro
- - @ref window
- - @ref monitor
- - @ref input
+ - @ref intro_guide
+ - @ref window_guide
+ - @ref vulkan_guide
+ - @ref monitor_guide
+ - @ref input_guide
 
 
 @section context_object Context objects
@@ -26,6 +29,11 @@ as the context handle.
 To test the creation of various kinds of contexts and see their properties, run
 the `glfwinfo` test program.
 
+@note Vulkan does not have a context and the Vulkan instance is created via the
+Vulkan API itself.  If you will be using Vulkan to render to a window, disable
+context creation by setting the [GLFW_CLIENT_API](@ref window_hints_ctx) hint to
+`GLFW_NO_API`.  For more information, see the @ref vulkan_guide.
+
 
 @subsection context_hints Context creation hints
 
@@ -64,7 +72,7 @@ contexts with hidden windows can be created with the
 [GLFW_VISIBLE](@ref window_hints_wnd) window hint.
 
 @code
-glfwWindowHint(GLFW_VISIBLE, GL_FALSE);
+glfwWindowHint(GLFW_VISIBLE, GLFW_FALSE);
 
 GLFWwindow* offscreen_context = glfwCreateWindow(640, 480, "", NULL, NULL);
 @endcode
@@ -74,12 +82,23 @@ offscreen context.  Depending on the window manager, the size of a hidden
 window's framebuffer may not be usable or modifiable, so framebuffer
 objects are recommended for rendering with such contexts.
 
+You should still [process events](@ref events) as long as you have at least one
+window, even if none of them are visible.
+
 __OS X:__ The first time a window is created the menu bar is populated with
 common commands like Hide, Quit and About.  This is not desirable for example
 when writing a command-line only application.  The menu bar setup can be
 disabled with a [compile-time option](@ref compile_options_osx).
 
 
+@subsection context_less Windows without contexts
+
+You can disable context creation by setting the
+[GLFW_CLIENT_API](@ref window_hints_ctx) hint to `GLFW_NO_API`.  Windows without
+contexts must not be passed to @ref glfwMakeContextCurrent or @ref
+glfwSwapBuffers.
+
+
 @section context_current Current context
 
 Before you can make OpenGL or OpenGL ES calls, you need to have a current
@@ -115,7 +134,7 @@ Buffer swapping is part of the window and framebuffer, not the context.  See
 
 @section context_glext OpenGL and OpenGL ES extensions
 
-One of the benefits of OpenGL and OpenGL ES are their extensibility.
+One of the benefits of OpenGL and OpenGL ES is their extensibility.
 Hardware vendors may include extensions in their implementations that extend the
 API before that functionality is included in a new version of the OpenGL or
 OpenGL ES specification, and some extensions are never included and remain
@@ -158,9 +177,10 @@ python main.py --generator c --no-loader --out-path output
 @endcode
 
 The `--no-loader` option is added because GLFW already provides a function for
-loading OpenGL and OpenGL ES function pointers and glad can call this instead of
-having to implement its own.  There are several other command-line options as
-well.  See the glad documentation for details.
+loading OpenGL and OpenGL ES function pointers, one that automatically uses the
+selected context creation API, and glad can call this instead of having to
+implement its own.  There are several other command-line options as well.  See
+the glad documentation for details.
 
 Add the generated `output/src/glad.c`, `output/include/glad/glad.h` and
 `output/include/KHR/khrplatform.h` files to your build.  Then you need to
@@ -271,8 +291,8 @@ if (glfwExtensionSupported("GL_ARB_debug_output"))
 @endcode
 
 The argument is a null terminated ASCII string with the extension name.  If the
-extension is supported, @ref glfwExtensionSupported returns `GL_TRUE`, otherwise
-it returns `GL_FALSE`.
+extension is supported, @ref glfwExtensionSupported returns `GLFW_TRUE`,
+otherwise it returns `GLFW_FALSE`.
 
 
 @subsubsection context_glext_proc Fetching function pointers

docs/input.dox

@@ -1,16 +1,17 @@
 /*!
 
-@page input Input guide
+@page input_guide Input guide
  
 @tableofcontents
 
-This guide introduces the input related functions of GLFW.  There are also
-guides for the other areas of GLFW.
+This guide introduces the input related functions of GLFW.  For details on
+a specific function, see the [reference documentation](@ref input).  There are
+also guides for the other areas of GLFW.
 
- - @ref intro
- - @ref window
- - @ref context
- - @ref monitor
+ - @ref intro_guide
+ - @ref window_guide
+ - @ref context_guide
+ - @ref monitor_guide
 
 GLFW provides many kinds of input.  While some can only be polled, like time, or
 only received via callbacks, like scrolling, there are those that provide both
@@ -32,8 +33,10 @@ information.
 
 GLFW needs to communicate regularly with the window system both in order to
 receive events and to show that the application hasn't locked up.  Event
-processing must be done regularly while you have visible windows and is normally
-done each frame after [buffer swapping](@ref buffer_swap).
+processing must be done regularly while you have any windows and is normally
+done each frame after [buffer swapping](@ref buffer_swap).  Even when you have
+no windows, event polling needs to be done in order to receive monitor
+connection events.
 
 There are two functions for processing pending events.  @ref glfwPollEvents,
 processes only those events that have already been received and then returns
@@ -57,6 +60,17 @@ processes all received events.  This saves a great deal of CPU cycles and is
 useful for, for example, editing tools.  There must be at least one GLFW window
 for this function to sleep.
 
+If you want to wait for events but have UI elements that need periodic updates,
+call @ref glfwWaitEventsTimeout.
+
+@code
+glfwWaitEventsTimeout(0.7);
+@endcode
+
+It puts the thread to sleep until at least one event has been received, or until
+the specified number of seconds have elapsed.  It then processes any received
+events.
+
 If the main thread is sleeping in @ref glfwWaitEvents, you can wake it from
 another thread by posting an empty event to the event queue with @ref
 glfwPostEmptyEvent.
@@ -192,6 +206,22 @@ void charmods_callback(GLFWwindow* window, unsigned int codepoint, int mods)
 @endcode
 
 
+@subsection input_key_name Key names
+
+If you wish to refer to keys by name, you can query the keyboard layout
+dependent name of printable keys with @ref glfwGetKeyName.
+
+@code
+const char* key_name = glfwGetKeyName(GLFW_KEY_W, 0);
+show_tutorial_hint("Press %s to move forward", key_name);
+@endcode
+
+This function can handle both [keys and scancodes](@ref input_key).  If the
+specified key is `GLFW_KEY_UNKNOWN` then the scancode is used, otherwise it is
+ignored.  This matches the behavior of the key callback, meaning the callback
+arguments can always be passed unmodified to this function.
+
+
 @section input_mouse Mouse input
 
 Mouse input comes in many forms, including cursor motion, button presses and
@@ -208,8 +238,9 @@ position callback.
 glfwSetCursorPosCallback(window, cursor_pos_callback);
 @endcode
 
-The callback functions receives the cursor position.  On platforms that provide
-it, the full sub-pixel cursor position is passed on.
+The callback functions receives the cursor position, measured in screen
+coordinates but relative to the top-left corner of the window client area.  On
+platforms that provide it, the full sub-pixel cursor position is passed on.
 
 @code
 static void cursor_position_callback(GLFWwindow* window, double xpos, double ypos)
@@ -516,6 +547,33 @@ and make may have the same name.  Only the [joystick token](@ref joysticks) is
 guaranteed to be unique, and only until that joystick is disconnected.
 
 
+@subsection joystick_event Joystick configuration changes
+
+If you wish to be notified when a joystick is connected or disconnected, set
+a joystick callback.
+
+@code
+glfwSetJoystickCallback(joystick_callback);
+@endcode
+
+The callback function receives the ID of the joystick that has been connected
+and disconnected and the event that occurred.
+
+@code
+void joystick_callback(int joy, int event)
+{
+    if (event == GLFW_CONNECTED)
+    {
+        // The joystick was connected
+    }
+    else if (event == GLFW_DISCONNECTED)
+    {
+        // The joystick was disconnected
+    }
+}
+@endcode
+
+
 @section time Time input
 
 GLFW provides high-resolution time input, in seconds, with @ref glfwGetTime.
@@ -536,6 +594,21 @@ glfwSetTime(4.0);
 
 This sets the timer to the specified time, in seconds.
 
+You can also access the raw timer value, measured in 1 / frequency
+seconds, with @ref glfwGetTimerValue.
+
+@code
+uint64_t value = glfwGetTimerValue();
+@endcode
+
+The frequency of the raw timer varies depending on what time sources are
+available on the machine.  You can query its frequency, in Hz, with @ref
+glfwGetTimerFrequency.
+
+@code
+uint64_t freqency = glfwGetTimerFrequency();
+@endcode
+
 
 @section clipboard Clipboard input and output
 

docs/internal.dox

@@ -1,6 +1,6 @@
 /*!
 
-@page internals Internal structure
+@page internals_guide Internal structure
 
 @tableofcontents
 
@@ -111,6 +111,6 @@ which is generated from the `glfw_config.h.in` file by CMake.
 Configuration macros the same style as tokens in the public interface, except
 with a leading underscore.
 
-Examples: `_GLFW_HAS_GLXGETPROCADDRESS` 
+Examples: `_GLFW_HAS_XF86VM` 
 
 */

docs/intro.dox

@@ -1,18 +1,21 @@
 /*! 
 
-@page intro Introduction to the API
+@page intro_guide Introduction to the API
  
 @tableofcontents
 
-This guide introduces the basic concepts of GLFW and describes initialization,
+This guide introduces the basic concepts of GLFW and describes initialization reference
 error handling and API guarantees and limitations.  For a broad but shallow
-tutorial, see @ref quick instead.  There are also guides for the other areas of
-GLFW.
+tutorial, see @ref quick_guide instead.  For details on a specific function, see the
+[reference documentation](@ref init).
 
- - @ref window
- - @ref context
- - @ref monitor
- - @ref input
+There are also guides for the other areas of GLFW.
+
+ - @ref window_guide
+ - @ref context_guide
+ - @ref vulkan_guide
+ - @ref monitor_guide
+ - @ref input_guide
 
 
 @section intro_init Initialization and termination
@@ -37,7 +40,7 @@ GLFW_NOT_INITIALIZED error.
 
 @subsection intro_init_init Initializing GLFW
 
-The library is initialized with @ref glfwInit, which returns `GL_FALSE` if an
+The library is initialized with @ref glfwInit, which returns `GLFW_FALSE` if an
 error occurred.
 
 @code
@@ -50,7 +53,7 @@ if (!glfwInit())
 If any part of initialization fails, all remaining bits are terminated as if
 @ref glfwTerminate was called.  The library only needs to be initialized once
 and additional calls to an already initialized library will simply return
-`GL_TRUE` immediately.
+`GLFW_TRUE` immediately.
 
 Once the library has been successfully initialized, it should be terminated
 before the application exits.
@@ -184,7 +187,7 @@ releases.
 @subsection reentrancy Reentrancy
 
 GLFW event processing and object creation and destruction are not reentrant.
-This means that the following functions may not be called from any callback
+This means that the following functions must not be called from any callback
 function:
 
  - @ref glfwCreateWindow
@@ -194,6 +197,7 @@ function:
  - @ref glfwDestroyCursor
  - @ref glfwPollEvents
  - @ref glfwWaitEvents
+ - @ref glfwWaitEventsTimeout
  - @ref glfwTerminate
 
 These functions may be made reentrant in future minor or patch releases, but
@@ -202,10 +206,10 @@ functions not on this list will not be made non-reentrant.
 
 @subsection thread_safety Thread safety
 
-Most GLFW functions may only be called from the main thread, but some may be
-called from any thread.  However, no GLFW function may be called from any other
-thread until GLFW has been successfully initialized on the main thread,
-including functions that may called before initialization.
+Most GLFW functions must only be called from the main thread, but some may be
+called from any thread.  However, no GLFW function may be called from any thread
+but the main thread until GLFW has been successfully initialized, including
+functions that may called before initialization.
 
 The reference documentation for every GLFW function states whether it is limited
 to the main thread.                                                        
@@ -239,10 +243,18 @@ may be called from any thread:
  - @ref glfwExtensionSupported
  - @ref glfwGetProcAddress
 
-The timer may be accessed from any thread, but this is not synchronized by GLFW.
-The following timer related functions may be called from any thread:        
+The raw timer may be queried from any thread.  The following raw timer related
+functions may be called from any thread:
+
+ - @ref glfwGetTimerFrequency
+ - @ref glfwGetTimerValue
+
+The regular timer may be used from any thread, but the reading and writing of
+the timer offset is not synchronized by GLFW.  The following timer related
+functions may be called from any thread:
 
  - @ref glfwGetTime
+ - @ref glfwSetTime
 
 Library version information may be queried from any thread.  The following
 version related functions may be called from any thread:
@@ -250,13 +262,22 @@ version related functions may be called from any thread:
  - @ref glfwGetVersion
  - @ref glfwGetVersionString
 
+Vulkan objects may be created and information queried from any thread.  The
+following Vulkan related functions may be called from any thread:
+
+ - @ref glfwVulkanSupported
+ - @ref glfwGetRequiredInstanceExtensions
+ - @ref glfwGetInstanceProcAddress
+ - @ref glfwGetPhysicalDevicePresentationSupport
+ - @ref glfwCreateWindowSurface
+
 GLFW uses no synchronization objects internally except for thread-local storage
 to keep track of the current context for each thread.  Synchronization is left
 to the application.
 
 Functions that may currently be called from any thread will always remain so,
-but functions that are currently limited to the main may be updated to allow
-calls from any thread in future releases.
+but functions that are currently limited to the main thread may be updated to
+allow calls from any thread in future releases.
 
 
 @subsection compatibility Version compatibility

docs/main.dox

@@ -4,41 +4,41 @@
 
 @section main_intro Introduction
 
-__GLFW__ is a free, Open Source, multi-platform library for creating windows
-with OpenGL or OpenGL ES contexts and receiving many kinds of input.  It is easy
-to integrate into existing applications and does not lay claim to the main loop.
+GLFW is a free, Open Source, multi-platform library for OpenGL, OpenGL ES and
+Vulkan application development.  It provides a simple, platform-independent API
+for creating windows, contexts and surfaces, reading input, handling events, etc.
 
-See @ref news_31 for release highlights or the
+See @ref news_32 for release highlights or the
 [version history](http://www.glfw.org/changelog.html) for details.
 
-@ref quick is a guide for those new to GLFW.  It takes you through how to write
-a small but complete program.  For people coming from GLFW 2, the @ref moving
-guide explains what has changed and how to update existing code to use the new
-API.
+@ref quick_guide is a guide for users new to GLFW.  It takes you through how to
+write a small but complete program.
 
-There are guides for each of the various areas of the API.
+There are guides for each section of the API:
 
- - @ref intro – initialization, error handling and high-level design
- - @ref window – creating and working with windows and framebuffers
- - @ref context – working with OpenGL and OpenGL ES contexts
- - @ref monitor – enumerating and working with monitors and video modes
- - @ref input – receiving events, polling and processing input
+ - @ref intro_guide – initialization, error handling and high-level design
+ - @ref window_guide – creating and working with windows and framebuffers
+ - @ref context_guide – working with OpenGL and OpenGL ES contexts
+ - @ref vulkan_guide - working with Vulkan objects and extensions
+ - @ref monitor_guide – enumerating and working with monitors and video modes
+ - @ref input_guide – receiving events, polling and processing input
 
-Once you have written a program, see the @ref compile and @ref build guides.        
+Once you have written a program, see @ref compile_guide and @ref build_guide.
 
 The [reference documentation](modules.html) provides more detailed information
 about specific functions.
 
+@ref moving_guide explains what has changed and how to update existing code to
+use the new API.
+
 There is a section on @ref guarantees_limitations for pointer lifetimes,
 reentrancy, thread safety, event order and backward and forward compatibility.
 
-The @ref rift fills in the gaps for how to use LibOVR with GLFW.
-
 The [FAQ](http://www.glfw.org/faq.html) answers many common questions about the
 design, implementation and use of GLFW.
 
-Finally, the @ref compat guide explains what APIs, standards and protocols GLFW
-uses and what happens when they are not present on a given machine.
+Finally, @ref compat_guide explains what APIs, standards and protocols GLFW uses
+and what happens when they are not present on a given machine.
 
 This documentation was generated with Doxygen.  The sources for it are available
 in both the [source distribution](http://www.glfw.org/download.html) and

docs/monitor.dox

@@ -1,16 +1,17 @@
 /*!
 
-@page monitor Monitor guide
+@page monitor_guide Monitor guide
 
 @tableofcontents
 
-This guide introduces the monitor related functions of GLFW.  There are also
-guides for the other areas of GLFW.
+This guide introduces the monitor related functions of GLFW.  For details on
+a specific function, see the [reference documentation](@ref monitor).  There are
+also guides for the other areas of GLFW.
 
- - @ref intro
- - @ref window
- - @ref context
- - @ref input
+ - @ref intro_guide
+ - @ref window_guide
+ - @ref context_guide
+ - @ref input_guide
 
 
 @section monitor_object Monitor objects
@@ -67,15 +68,24 @@ glfwSetMonitorCallback(monitor_callback);
 @endcode
 
 The callback function receives the handle for the monitor that has been
-connected or disconnected and a monitor action.
+connected or disconnected and the event that occurred.
 
 @code
 void monitor_callback(GLFWmonitor* monitor, int event)
 {
+    if (event == GLFW_CONNECTED)
+    {
+        // The monitor was connected
+    }
+    else if (event == GLFW_DISCONNECTED)
+    {
+        // The monitor was disconnected
+    }
 }
 @endcode
 
-The action is one of `GLFW_CONNECTED` or `GLFW_DISCONNECTED`.
+If a monitor is disconnected, any windows that are full screen on it get forced
+into windowed mode.
 
 
 @section monitor_properties Monitor properties
@@ -88,8 +98,9 @@ a gamma ramp.
 @subsection monitor_modes Video modes
 
 GLFW generally does a good job selecting a suitable video mode when you create
-a full screen window, but it is sometimes useful to know exactly which video
-modes are supported.
+a full screen window, change its video mode or or make a windowed one full
+screen, but it is sometimes useful to know exactly which video modes are
+supported.
 
 Video modes are represented as @ref GLFWvidmode structures.  You can get an
 array of the video modes supported by a monitor with @ref glfwGetVideoModes.

docs/moving.dox

@@ -1,6 +1,6 @@
 /*!
 
-@page moving Moving from GLFW 2 to 3
+@page moving_guide Moving from GLFW 2 to 3
 
 @tableofcontents
 
@@ -53,7 +53,7 @@ TinyCThread.
 However, GLFW 3 has better support for _use from multiple threads_ than GLFW
 2 had.  Contexts can be made current on any thread, although only a single
 thread at a time, and the documentation explicitly states which functions may be
-used from any thread and which may only be used from the main thread.
+used from any thread and which must only be used from the main thread.
 
 @par Removed functions
 `glfwSleep`, `glfwCreateThread`, `glfwDestroyThread`, `glfwWaitThread`,
@@ -61,6 +61,9 @@ used from any thread and which may only be used from the main thread.
 `glfwUnlockMutex`, `glfwCreateCond`, `glfwDestroyCond`, `glfwWaitCond`,
 `glfwSignalCond`, `glfwBroadcastCond` and `glfwGetNumberOfProcessors`.
 
+@par Removed types
+`GLFWthreadfun`
+
 
 @subsection moving_image Removal of image and texture loading
 
@@ -127,7 +130,7 @@ GLFW 3 provides support for multiple monitors.  To request a full screen mode wi
 instead of passing `GLFW_FULLSCREEN` you specify which monitor you wish the
 window to use.  The @ref glfwGetPrimaryMonitor function returns the monitor that
 GLFW 2 would have selected, but there are many other
-[monitor functions](@ref monitor).  Monitor handles are pointers to the
+[monitor functions](@ref monitor_guide).  Monitor handles are pointers to the
 [opaque](https://en.wikipedia.org/wiki/Opaque_data_type) type @ref GLFWmonitor.
 
 @par Old basic full screen
@@ -216,7 +219,7 @@ glfwTerminate, the window is "open".
 A user attempting to close a window is now just an event like any other.  Unlike
 GLFW 2, windows and contexts created with GLFW 3 will never be destroyed unless
 you choose them to be.  Each window now has a close flag that is set to
-`GL_TRUE` when the user attempts to close that window.  By default, nothing else
+`GLFW_TRUE` when the user attempts to close that window.  By default, nothing else
 happens and the window stays visible.  It is then up to you to either destroy
 the window, take some other action or simply ignore the request.
 
@@ -254,7 +257,7 @@ int GLFWCALL window_close_callback(void);
 void window_close_callback(GLFWwindow* window);
 @endcode
 
-@note GLFW never clears the close flag to `GL_FALSE`, meaning you can use it
+@note GLFW never clears the close flag to `GLFW_FALSE`, meaning you can use it
 for other reasons to close the window as well, for example the user choosing
 Quit from an in-game menu.
 
@@ -416,7 +419,7 @@ these hotkeys to function even when running in full screen mode.
 
 GLFW 3 does not register @ref glfwTerminate with `atexit` at initialization,
 because `exit` calls registered functions from the calling thread and while it
-is permitted to call `exit` from any thread, @ref glfwTerminate may only be
+is permitted to call `exit` from any thread, @ref glfwTerminate must only be
 called from the main thread.
 
 To release all resources allocated by GLFW, you should call @ref glfwTerminate
@@ -467,6 +470,15 @@ defining `GLFW_INCLUDE_GLU` before the inclusion of the GLFW header.
 | `glfwGetDesktopMode`        | @ref glfwGetVideoMode         | Returns the current mode of a monitor |
 | `glfwGetJoystickParam`      | @ref glfwJoystickPresent      | The axis and button counts are provided by @ref glfwGetJoystickAxes and @ref glfwGetJoystickButtons |
 
+
+@subsection moving_renamed_types Renamed types
+
+| GLFW 2              | GLFW 3                | Notes |
+| ------------------- | --------------------- |       |
+| `GLFWmousewheelfun` | @ref GLFWscrollfun    |       |
+| `GLFWmouseposfun`   | @ref GLFWcursorposfun |       |
+
+
 @subsection moving_renamed_tokens Renamed tokens
 
 | GLFW 2                      | GLFW 3                       | Notes |

docs/news.dox

@@ -2,6 +2,97 @@
 
 @page news New features
 
+@section news_32 New features in 3.2
+
+
+@subsection news_32_vulkan Support for Vulkan
+
+GLFW now supports basic integration with Vulkan with @ref glfwVulkanSupported,
+@ref glfwGetRequiredInstanceExtensions, @ref glfwGetInstanceProcAddress, @ref
+glfwGetPhysicalDevicePresentationSupport and @ref glfwCreateWindowSurface.
+Vulkan header inclusion can be selected with
+[GLFW_INCLUDE_VULKAN](@ref build_macros).
+
+
+@subsection news_32_setwindowmonitor Window mode switching
+
+GLFW now supports switching between windowed and full screen modes and updating
+the monitor and desired resolution and refresh rate of full screen windows with
+@ref glfwSetWindowMonitor.
+
+
+@subsection news_32_maximize Window maxmimization support
+
+GLFW now supports window maximization with @ref glfwMaximizeWindow and the
+[GLFW_MAXIMIZED](@ref window_attribs_wnd) window hint and attribute.
+
+
+@subsection news_32_focus Window input focus control
+
+GLFW now supports giving windows input focus with @ref glfwFocusWindow.
+
+
+@subsection news_32_sizelimits Window size limit support
+
+GLFW now supports setting both absolute and relative window size limits with
+@ref glfwSetWindowSizeLimits and @ref glfwSetWindowAspectRatio.
+
+
+@subsection news_32_keyname Localized key names
+
+GLFW now supports querying the localized name of printable keys with @ref
+glfwGetKeyName, either by key token or by scancode.
+
+
+@subsection news_32_waittimeout Wait for events with timeout
+
+GLFW now supports waiting for events for a set amount of time with @ref
+glfwWaitEventsTimeout.
+
+
+@subsection news_32_icon Window icon support
+
+GLFW now supports setting the icon of windows with @ref glfwSetWindowIcon.
+
+
+@subsection news_32_timer Raw timer access
+
+GLFW now supports raw timer values with @ref glfwGetTimerValue and @ref
+glfwGetTimerFrequency.
+
+
+@subsection news_32_joystick Joystick connection callback
+
+GLFW now supports notifying when a joystick has been connected or disconnected
+with @ref glfwSetJoystickCallback.
+
+
+@subsection news_32_noapi Context-less windows
+
+GLFW now supports creating windows without a OpenGL or OpenGL ES context with
+[GLFW_NO_API](@ref window_hints_ctx).
+
+
+@subsection news_32_contextapi Run-time context creation API selection
+
+GLFW now supports selecting the context creation API at run-time with the
+[GLFW_CONTEXT_CREATION_API](@ref window_hints_ctx) window hint value.
+
+
+@subsection news_32_noerror Error-free context creation
+
+GLFW now supports creating OpenGL and OpenGL ES contexts that do not emit errors
+with the [GLFW_CONTEXT_NO_ERROR](@ref window_hints_ctx) window hint, provided
+the machine supports the `GL_KHR_no_error` extension.
+
+
+@subsection news_32_cmake CMake config-file package support
+
+GLFW now supports being used as a
+[config-file package](@ref build_link_cmake_package) from other projects for
+easy linking with the library and its dependencies.
+
+
 @section news_31 New features in 3.1
 
 These are the release highlights.  For a full list of changes see the
@@ -69,13 +160,6 @@ GLFW now queries the window input focus, visibility and iconification attributes
 and the cursor position directly instead of returning cached data.
 
 
-@subsection news_31_libovr Better interoperability with Oculus Rift
-
-GLFW now provides native access functions for the OS level handles corresponding
-to monitor objects, as well as a [brief guide](@ref rift).  It is also regularly
-tested for compatibility with the latest version of LibOVR (0.4.4 on release).
-
-
 @subsection news_31_charmods Character with modifiers callback
 
 GLFW now provides a callback for character events with modifier key bits.  The

docs/quick.dox

@@ -1,16 +1,16 @@
 /*!
 
-@page quick Getting started
+@page quick_guide Getting started
 
 @tableofcontents
 
 This guide takes you through writing a simple application using GLFW 3.  The
 application will create a window and OpenGL context, render a rotating triangle
-and exit when the user closes the window or presses Escape.  This guide will
+and exit when the user closes the window or presses _Escape_.  This guide will
 introduce a few of the most commonly used functions, but there are many more.
 
 This guide assumes no experience with earlier versions of GLFW.  If you
-have used GLFW 2 in the past, read the @ref moving guide, as some functions
+have used GLFW 2 in the past, read @ref moving_guide, as some functions
 behave differently in GLFW 3.
 
 
@@ -26,33 +26,32 @@ to include the GLFW 3 header file.
 @endcode
 
 This defines all the constants, types and function prototypes of the GLFW API.
-It also includes the OpenGL header, and defines all the constants and types
-necessary for it to work on your platform.
-
-For example, under Windows you are normally required to include `windows.h`
-before including `GL/gl.h`.  This would make your source file tied to Windows
-and pollute your code's namespace with the whole Win32 API.
-
-Instead, the GLFW header takes care of this for you, not by including
-`windows.h`, but rather by itself duplicating only the necessary parts of it.
-It does this only where needed, so if `windows.h` _is_ included, the GLFW header
-does not try to redefine those symbols.
+It also includes the OpenGL header from your development environment and
+defines all the constants and types necessary for it to work on your platform
+without including any platform-specific headers.
 
 In other words:
 
-- Do _not_ include the OpenGL headers yourself, as GLFW does this for you
+- Do _not_ include the OpenGL header yourself, as GLFW does this for you in
+  a platform-independent way
 - Do _not_ include `windows.h` or other platform-specific headers unless
-  you plan on using those APIs directly
-- If you _do_ need to include such headers, do it _before_ including the
-  GLFW one and it will detect this
+  you plan on using those APIs yourself
+- If you _do_ need to include such headers, include them _before_ the GLFW
+  header and it will detect this
 
-Starting with version 3.0, the GLU header `glu.h` is no longer included by
-default.  GLU is deprecated and should not be used in new code.  If you need to
-include it for legacy code, define `GLFW_INCLUDE_GLU` before the inclusion of
-the GLFW header.
+On some platforms supported by GLFW the OpenGL header and link library only
+expose older versions of OpenGL.  The most extreme case is Windows, which only
+exposes OpenGL 1.2.  The easiest way to work around this is to use an
+[extension loader library](@ref context_glext_auto).
+
+If you are using such a library then you should include its header _before_ the
+GLFW header.  This lets it replace the OpenGL header included by GLFW without
+conflicts.  This example uses
+[glad](https://github.com/Dav1dde/glad), but the same rule applies to all such
+libraries.
 
 @code
-#define GLFW_INCLUDE_GLU
+#include <glad/glad.h>
 #include <GLFW/glfw3.h>
 @endcode
 
@@ -60,14 +59,18 @@ the GLFW header.
 @subsection quick_init_term Initializing and terminating GLFW
 
 Before you can use most GLFW functions, the library must be initialized.  On
-successful initialization, `GL_TRUE` is returned.  If an error occurred,
-`GL_FALSE` is returned.
+successful initialization, `GLFW_TRUE` is returned.  If an error occurred,
+`GLFW_FALSE` is returned.
 
 @code
 if (!glfwInit())
-    exit(EXIT_FAILURE);
+{
+    // Initialization failed
+}
 @endcode
 
+Note that `GLFW_TRUE` and `GLFW_FALSE` are and will always be just one and zero.
+
 When you are done using GLFW, typically just before the application exits, you
 need to terminate GLFW.
 
@@ -95,7 +98,7 @@ description to `stderr`.
 @code
 void error_callback(int error, const char* description)
 {
-    fputs(description, stderr);
+    fprintf(stderr, "Error: %s\n", description);
 }
 @endcode
 
@@ -111,22 +114,36 @@ glfwSetErrorCallback(error_callback);
 
 @subsection quick_create_window Creating a window and context
 
-The window and its OpenGL context are created with a single call, which returns
-a handle to the created combined window and context object.  For example, this
-creates a 640 by 480 windowed mode window with an OpenGL context:
+The window and its OpenGL context are created with a single call to @ref
+glfwCreateWindow, which returns a handle to the created combined window and
+context object
 
 @code
 GLFWwindow* window = glfwCreateWindow(640, 480, "My Title", NULL, NULL);
-@endcode
-
-If window or context creation fails, `NULL` will be returned, so it is necessary
-to check the return value.
-
-@code
 if (!window)
 {
-    glfwTerminate();
-    exit(EXIT_FAILURE);
+    // Window or OpenGL context creation failed
+}
+@endcode
+
+This creates a 640 by 480 windowed mode window with an OpenGL context.  If
+window or OpenGL context creation fails, `NULL` will be returned.  You should
+always check the return value.  While window creation rarely fails, context
+creation depends on properly installed drivers and may fail even on machines
+with the necessary hardware.
+
+By default, the OpenGL context GLFW creates may have any version.  You can
+require a minimum OpenGL version by setting the `GLFW_CONTEXT_VERSION_MAJOR` and
+`GLFW_CONTEXT_VERSION_MINOR` hints _before_ creation.  If the required minimum
+version is not supported on the machine, context (and window) creation fails.
+
+@code
+glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 2);
+glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 0);
+GLFWwindow* window = glfwCreateWindow(640, 480, "My Title", NULL, NULL);
+if (!window)
+{
+    // Window or context creation failed
 }
 @endcode
 
@@ -134,7 +151,7 @@ The window handle is passed to all window related functions and is provided to
 along to all window related callbacks, so they can tell which window received
 the event.
 
-When a window is no longer needed, destroy it.
+When a window and context is no longer needed, destroy it.
 
 @code
 glfwDestroyWindow(window);
@@ -155,6 +172,16 @@ glfwMakeContextCurrent(window);
 The context will remain current until you make another context current or until
 the window owning the current context is destroyed.
 
+If you are using an [extension loader library](@ref context_glext_auto) to
+access modern OpenGL then this is when to initialize it, as the loader needs
+a current context to load from.  This example uses
+[glad](https://github.com/Dav1dde/glad), but the same rule applies to all such
+libraries. 
+
+@code
+gladLoadGLLoader((GLADloadproc) glfwGetProcAddress);
+@endcode
+
 
 @subsection quick_window_close Checking the window close flag
 
@@ -179,7 +206,7 @@ called immediately after the close flag has been set.
 
 You can also set it yourself with @ref glfwSetWindowShouldClose.  This can be
 useful if you want to interpret other kinds of input as closing the window, like
-for example pressing the escape key.
+for example pressing the _Escape_ key.
 
 
 @subsection quick_key_input Receiving input events
@@ -192,7 +219,7 @@ callback function.
 static void key_callback(GLFWwindow* window, int key, int scancode, int action, int mods)
 {
     if (key == GLFW_KEY_ESCAPE && action == GLFW_PRESS)
-        glfwSetWindowShouldClose(window, GL_TRUE);
+        glfwSetWindowShouldClose(window, GLFW_TRUE);
 }
 @endcode
 
@@ -219,7 +246,14 @@ glViewport(0, 0, width, height);
 @endcode
 
 You can also set a framebuffer size callback using @ref
-glfwSetFramebufferSizeCallback and call `glViewport` from there.
+glfwSetFramebufferSizeCallback and be notified when the size changes.
+
+Actual rendering with OpenGL is outside the scope of this tutorial, but there
+are [many](https://open.gl/) [excellent](http://learnopengl.com/)
+[tutorial](http://openglbook.com/) [sites](http://ogldev.atspace.co.uk/) that
+teach modern OpenGL.  Some of them use GLFW to create the context and window
+while others use GLUT or SDL, but remember that OpenGL itself always works the
+same.
 
 
 @subsection quick_timer Reading the timer
@@ -296,34 +330,35 @@ for example, many kinds of editing tools.
 Now that you know how to initialize GLFW, create a window and poll for
 keyboard input, it's possible to create a simple program.
 
-@snippet simple.c code
-
 This program creates a 640 by 480 windowed mode window and starts a loop that
 clears the screen, renders a triangle and processes events until the user either
-presses Escape or closes the window.
+presses _Escape_ or closes the window.
 
-This program uses only a few of the many functions GLFW provides.  There are
+@snippet simple.c code
+
+The program above can be found in the
+[source package](http://www.glfw.org/download.html) as `examples/simple.c`
+and is compiled along with all other examples when you build GLFW.  If you
+built GLFW from the source package then already have this as `simple.exe` on
+Windows, `simple` on Linux or `simple.app` on OS X.
+
+This tutorial used only a few of the many functions GLFW provides.  There are
 guides for each of the areas covered by GLFW.  Each guide will introduce all the
 functions for that category.
 
- - @ref intro
- - @ref window
- - @ref context
- - @ref monitor
- - @ref input
+ - @ref intro_guide
+ - @ref window_guide
+ - @ref context_guide
+ - @ref monitor_guide
+ - @ref input_guide
 
+You can access reference documentation for any GLFW function by clicking it and
+the reference for each function links to related functions and guide sections.
 
-@section quick_build Compiling and linking the program
-
-The complete program above can be found in the source distribution as
-`examples/simple.c` and is compiled along with all other examples when you
-build GLFW.  That is, if you have compiled GLFW then you have already built this
-as `simple.exe` on Windows, `simple` on Linux or `simple.app` on OS X.
-
-This tutorial ends here.  Once you have written a program that uses GLFW, you
+The tutorial ends here.  Once you have written a program that uses GLFW, you
 will need to compile and link it.  How to do that depends on the development
 environment you are using and is best explained by the documentation for that
 environment.  To learn about the details that are specific to GLFW, see
-@ref build.
+@ref build_guide.
 
 */

docs/rift.dox

@@ -1,199 +0,0 @@
-/*!
-
-@page rift Oculus Rift guide
- 
-@tableofcontents
-
-This guide is intended to fill in the gaps between the
-[Oculus PC SDK documentation](https://developer.oculus.com/documentation/) and
-the rest of the GLFW documentation and is not a replacement for either.  It
-requires you to use [native access](@ref native) and assumes a certain level of
-proficiency with LibOVR, platform specific APIs and your chosen development
-environment.
-
-While GLFW has no explicit support for LibOVR, it is tested with and tries to
-interoperate well with it.
-
-@note Because of the speed of development of the Oculus SDK, this guide may
-become outdated before the next release.  If this is a local copy of the
-documentation, you may want to check the GLFW website for updates.  This
-revision of the guide is written against version 0.4.4 of the SDK.
-
-
-@section rift_include Including the LibOVR and GLFW header files
-
-Both the OpenGL LibOVR header and the GLFW native header need macros telling
-them what OS you are building for.  Because LibOVR only supports three major
-desktop platforms, this can be solved with canonical predefined macros.
-
-@code
-#if defined(_WIN32)
- #define GLFW_EXPOSE_NATIVE_WIN32
- #define GLFW_EXPOSE_NATIVE_WGL
- #define OVR_OS_WIN32
-#elif defined(__APPLE__)
- #define GLFW_EXPOSE_NATIVE_COCOA
- #define GLFW_EXPOSE_NATIVE_NSGL
- #define OVR_OS_MAC
-#elif defined(__linux__)
- #define GLFW_EXPOSE_NATIVE_X11
- #define GLFW_EXPOSE_NATIVE_GLX
- #define OVR_OS_LINUX
-#endif
-
-#include <GLFW/glfw3.h>
-#include <GLFW/glfw3native.h>
-
-#include <OVR_CAPI_GL.h>
-@endcode
-
-Both the GLFW and LibOVR headers by default attempt to include the standard
-OpenGL `GL/gl.h` header (`OpenGL/gl.h` on OS X).  If you wish to use a different
-standard header or an [extension loading library](@ref context_glext_auto),
-include that header before these.
-
-
-@section rift_init Initializing LibOVR and GLFW
-
-LibOVR needs to be initialized before GLFW.  This means calling at least
-`ovr_Initialize`, `ovrHmd_Create` and `ovrHmd_ConfigureTracking` before @ref
-glfwInit.  Similarly, LibOVR must be shut down after GLFW.  This means calling
-`ovrHmd_Destroy` and `ovr_Shutdown` after @ref glfwTerminate.
-
-
-@section rift_direct Direct HMD mode
-
-Direct HMD mode is the recommended display mode for new applications, but the
-Oculus Rift runtime currently (January 2015) only supports this mode on Windows.
-In direct mode the HMD is not detectable as a GLFW monitor.
-
-
-@subsection rift_direct_create Creating a window and context
-
-If the HMD is in direct mode you can use either a full screen or a windowed mode
-window, but full screen is only recommended if there is a monitor that supports
-the resolution of the HMD.  Due to limitations in LibOVR, the size of the client
-area of the window must equal the resolution of the HMD.
-
-If the resolution of the HMD is much larger than the regular monitor, the window
-may be resized by the window manager on creation.  One way to avoid this is to
-make it undecorated with the [GLFW_DECORATED](@ref window_hints_wnd) window
-hint.
-
-
-@subsection rift_direct_attach Attaching the window to the HMD
-
-Once you have created the window and context, you need to attach the native
-handle of the GLFW window to the HMD.
-
-@code
-ovrHmd_AttachToWindow(hmd, glfwGetWin32Window(window), NULL, NULL);
-@endcode
-
-
-@section rift_extend Extend Desktop mode
-
-Extend desktop mode is a legacy display mode, but is still (January 2015) the
-only available mode on OS X and Linux, as well as on Windows machines that for
-technical reasons do not yet support direct HMD mode.
-
-
-@subsection rift_extend_detect Detecting a HMD with GLFW
-
-If the HMD is in extend desktop mode you can deduce which GLFW monitor it
-corresponds to and create a full screen window on that monitor.
-
-On Windows, the native display device name of a GLFW monitor corresponds to the
-display device name of the detected HMD as stored, in the `DisplayDeviceName`
-member of `ovrHmdDesc`.
-
-On OS X, the native display ID of a GLFW monitor corresponds to the display ID
-of the detected HMD, as stored in the `DisplayId` member of `ovrHmdDesc`.
-
-At the time of writing (January 2015), the Oculus SDK does not support detecting
-which monitor corresponds to the HMD in any sane fashion, but as long as the HMD
-is set up and rotated properly it can be found via the screen position and
-resolution provided by LibOVR.  This method may instead find another monitor
-that is mirroring the HMD, but this only matters if you intend to change its
-video mode.
-
-@code
-int i, count;
-GLFWmonitor** monitors = glfwGetMonitors(&count);
-
-for (i = 0;  i < count;  i++)
-{
-#if defined(_WIN32)
-    if (strcmp(glfwGetWin32Monitor(monitors[i]), hmd->DisplayDeviceName) == 0)
-        return monitors[i];
-#elif defined(__APPLE__)
-    if (glfwGetCocoaMonitor(monitors[i]) == hmd->DisplayId)
-        return monitors[i];
-#elif defined(__linux__)
-    int xpos, ypos;
-    const GLFWvidmode* mode = glfwGetVideoMode(monitors[i]);
-    glfwGetMonitorPos(monitors[i], &xpos, &ypos);
-
-    if (hmd->WindowsPos.x == xpos &&
-        hmd->WindowsPos.y == ypos &&
-        hmd->Resolution.w == mode->width &&
-        hmd->Resolution.h == mode->height)
-    {
-        return monitors[i];
-    }
-#endif
-}
-@endcode
-
-
-@subsection rift_extend_create Creating a window and context
-
-The window is created as a regular full screen window on the found monitor.  It
-is usually a good idea to create a
-[windowed full screen](@ref window_windowed_full_screen) window, as the HMD will
-very likely already be set to the correct video mode.  However, in extend
-desktop mode it behaves like a regular monitor and any supported video mode can
-be requested.
-
-If other monitors are mirroring the HMD and you request a different video mode,
-all monitors in the mirroring set will get the new video mode.
-
-
-@section rift_render Rendering to the HMD
-
-@subsection rift_render_sdk SDK distortion rendering
-
-If you wish to use SDK distortion rendering you will need some information from
-GLFW to configure the renderer.  Below are the parts of the `ovrGLConfig` union
-that need to be filled with from GLFW.  Note that there are other fields that
-also need to be filled for `ovrHmd_ConfigureRendering` to succeed.
-
-Before configuring SDK distortion rendering you should make your context
-current.
-
-@code
-    int width, height;
-    union ovrGLConfig config;
-
-    glfwGetFramebufferSize(window, &width, &height);
-
-    config.OGL.Header.BackBufferSize.w = width;
-    config.OGL.Header.BackBufferSize.h = height;
-#if defined(_WIN32)
-    config.OGL.Window = glfwGetWin32Window(window);
-#elif defined(__APPLE__)
-#elif defined(__linux__)
-    config.OGL.Disp = glfwGetX11Display();
-#endif
-@endcode
-
-When using SDK distortion rendering you should not swap the buffers yourself, as
-the HMD is updated by `ovrHmd_EndFrame`.
-
-
-@subsection rift_render_custom Client distortion rendering
-
-With client distortion rendering you are in full control of the contents of the
-HMD and should render and swap the buffers normally.
-
-*/

docs/vulkan.dox

@@ -0,0 +1,212 @@
+/*!
+
+@page vulkan_guide Vulkan guide
+ 
+@tableofcontents
+
+This guide is intended to fill the gaps between the [Vulkan
+documentation](https://www.khronos.org/vulkan/) and the rest of the GLFW
+documentation and is not a replacement for either.  It assumes some familiarity
+with Vulkan concepts like loaders, devices, queues and surfaces and leaves it to
+the Vulkan documentation to explain the details of Vulkan functions.
+
+To develop for Vulkan you should install an SDK for your platform, for example
+the [LunarG Vulkan SDK](https://vulkan.lunarg.com/).  Apart from the headers and
+libraries, it also provides the validation layers necessary for development.
+
+The GLFW library does not need the Vulkan SDK to enable support for Vulkan.
+However, any Vulkan-specific test and example programs are built only if the
+CMake files find a Vulkan SDK.
+
+For details on a specific function, see the
+[reference documentation](@ref vulkan).  There are also guides for the other
+areas of the GLFW API.
+
+ - @ref intro_guide
+ - @ref window_guide
+ - @ref context_guide
+ - @ref monitor_guide
+ - @ref input_guide
+
+
+@section vulkan_include Including the Vulkan and GLFW header files
+
+To include the Vulkan header, define [GLFW_INCLUDE_VULKAN](@ref build_macros)
+before including the GLFW header.
+
+@code
+#define GLFW_INCLUDE_VULKAN
+#include <GLFW/glfw3.h>
+@endcode
+
+If you want to include the Vulkan header from a custom location or use your own
+custom Vulkan header then you need to include them before the GLFW header.
+
+@code
+#include <path/to/vulkan.h>
+#include <GLFW/glfw3.h>
+@endcode
+
+Unless a Vulkan header is included, either by the GLFW header or above it, any
+GLFW functions that take or return Vulkan types will not be declared.
+
+The `VK_USE_PLATFORM_*_KHR` macros do not need to be defined for the Vulkan part
+of GLFW to work.  Define them only if you are using these extensions directly.
+
+
+@section vulkan_support Querying for Vulkan support
+
+If you are linking directly against the Vulkan loader then you can skip this
+section.  The canonical desktop loader library exports all Vulkan core and
+Khronos extension functions, allowing them to be called directly.
+
+If you are loading the Vulkan loader dynamically instead of linking directly
+against it, you can check for the availability of a loader with @ref
+glfwVulkanSupported.
+
+@code
+if (glfwVulkanSupported())
+{
+    // Vulkan is available, at least for compute
+}
+@endcode
+
+This function returns `GLFW_TRUE` if the Vulkan loader was found.  This check is
+performed by @ref glfwInit.
+
+If no loader was found, calling any other Vulkan related GLFW function will
+generate a @ref GLFW_API_UNAVAILABLE error.
+
+
+@subsection vulkan_proc Querying Vulkan function pointers
+
+To load any Vulkan core or extension function from the found loader, call @ref
+glfwGetInstanceProcAddress.  To load functions needed for instance creation,
+pass `NULL` as the instance.
+
+@code
+PFN_vkCreateInstance pfnCreateInstance = (PFN_vkCreateInstance)
+    glfwGetInstanceProcAddress(NULL, "vkCreateInstance");
+@endcode
+
+Once you have created an instance, you can load from it all other Vulkan core
+functions and functions from any instance extensions you enabled.
+
+@code
+PFN_vkCreateDevice pfnCreateDevice = (PFN_vkCreateDevice)
+    glfwGetInstanceProcAddress(instance, "vkCreateDevice");
+@endcode
+
+This function in turn calls `vkGetInstanceProcAddr`.  If that fails, the
+function falls back to a platform-specific query of the Vulkan loader (i.e.
+`dlsym` or `GetProcAddress`).  If that also fails, the function returns `NULL`.
+For more information about `vkGetInstanceProcAddr`, see the Vulkan
+documentation.
+
+Vulkan also provides `vkGetDeviceProcAddr` for loading device-specific versions
+of Vulkan function.  This function can be retrieved from an instance with @ref
+glfwGetInstanceProcAddress.
+
+@code
+PFN_vkGetDeviceProcAddr pfnGetDeviceProcAddr = (PFN_vkGetDeviceProcAddr)
+    glfwGetInstanceProcAddress(instance, "vkGetDeviceProcAddr");
+@endcode
+
+Device-specific functions may execute a little bit faster, due to not having to
+dispatch internally based on the device passed to them.  For more information
+about `vkGetDeviceProcAddr`, see the Vulkan documentation.
+
+
+@section vulkan_ext Querying required Vulkan extensions
+
+To do anything useful with Vulkan you need to create an instance.  If you want
+to use Vulkan to render to a window, you must enable the instance extensions
+GLFW requires to create Vulkan surfaces.
+
+To query the instance extensions required, call @ref
+glfwGetRequiredInstanceExtensions.
+
+@code
+uint32_t count;
+const char** extensions = glfwGetRequiredInstanceExtensions(&count);
+@endcode
+
+These extensions must all be enabled when creating instances that are going to
+be passed to @ref glfwGetPhysicalDevicePresentationSupport and @ref
+glfwCreateWindowSurface.  The set of extensions will vary depending on platform
+and may also vary depending on graphics drivers and other factors.
+
+If it fails it will return `NULL` and GLFW will not be able to create Vulkan
+window surfaces.  You can still use Vulkan for off-screen rendering and compute
+work.
+
+The returned array will always contain `VK_KHR_surface`, so if you don't
+require any additional extensions you can pass this list directly to the
+`VkInstanceCreateInfo` struct.
+
+@code
+VkInstanceCreateInfo ici;
+
+memset(&ici, 0, sizeof(ici));
+ici.enabledExtensionCount = count;
+ici.ppEnabledExtensionNames = extensions;
+...
+@endcode
+
+Additional extensions may be required by future versions of GLFW.  You should
+check whether any extensions you wish to enable are already in the returned
+array, as it is an error to specify an extension more than once in the
+`VkInstanceCreateInfo` struct. 
+
+
+@section vulkan_present Querying for Vulkan presentation support
+
+Not every queue family of every Vulkan device can present images to surfaces.
+To check whether a specific queue family of a physical device supports image
+presentation without first having to create a window and surface, call @ref
+glfwGetPhysicalDevicePresentationSupport.
+
+@code
+if (glfwGetPhysicalDevicePresentationSupport(instance, physical_device, queue_family_index))
+{
+    // Queue family supports image presentation
+}
+@endcode
+
+The `VK_KHR_surface` extension additionally provides the 
+`vkGetPhysicalDeviceSurfaceSupportKHR` function, which performs the same test on
+an existing Vulkan surface.
+
+
+@section vulkan_window Creating the window
+
+Unless you will be using OpenGL or OpenGL ES with the same window as Vulkan,
+there is no need to create a context.  You can disable context creation with the
+[GLFW_CLIENT_API](@ref window_hints_ctx) hint.
+
+@code
+glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
+GLFWwindow* window = glfwCreateWindow(640, 480, "Window Title", NULL, NULL);
+@endcode
+
+See @ref context_less for more information.
+
+
+@section vulkan_surface Creating a Vulkan window surface
+
+You can create a Vulkan surface (as defined by the `VK_KHR_surface` extension)
+for a GLFW window with @ref glfwCreateWindowSurface.
+
+@code
+VkSurfaceKHR surface;
+VkResult err = glfwCreateWindowSurface(instance, window, NULL, &surface);
+if (err)
+{
+    // Window surface creation failed
+}
+@endcode
+
+It is your responsibility to destroy the surface.  GLFW does not destroy it for
+you.  Call `vkDestroySurfaceKHR` function from the same extension to destroy it.
+
+*/

docs/window.dox

@@ -1,16 +1,17 @@
 /*!
 
-@page window Window guide
+@page window_guide Window guide
  
 @tableofcontents
 
-This guide introduces the window related functions of GLFW.  There are also
-guides for the other areas of GLFW.
+This guide introduces the window related functions of GLFW.  For details on
+a specific function, see the [reference documentation](@ref window).  There are
+also guides for the other areas of GLFW.
 
- - @ref intro
- - @ref context
- - @ref monitor
- - @ref input
+ - @ref intro_guide
+ - @ref context_guide
+ - @ref monitor_guide
+ - @ref input_guide
 
 
 @section window_object Window objects
@@ -55,6 +56,10 @@ GLFWwindow* window = glfwCreateWindow(640, 480, "My Title", glfwGetPrimaryMonito
 Full screen windows cover the entire display area of a monitor, have no border
 or decorations.
 
+Windowed mode windows can be made full screen by setting a monitor with @ref
+glfwSetWindowMonitor, and full screen ones can be made windowed by unsetting it
+with the same function.
+
 Each field of the @ref GLFWvidmode structure corresponds to a function parameter
 or window hint and combine to form the _desired video mode_ for that window.
 The supported video mode most closely matching the desired video mode will be
@@ -70,9 +75,11 @@ GLFWvidmode.greenBits   | `GLFW_GREEN_BITS` hint
 GLFWvidmode.blueBits    | `GLFW_BLUE_BITS` hint
 GLFWvidmode.refreshRate | `GLFW_REFRESH_RATE` hint
 
-Once you have a full screen window, you can change its resolution with @ref
-glfwSetWindowSize.  The new video mode will be selected and set the same way as
-the video mode chosen by @ref glfwCreateWindow.
+Once you have a full screen window, you can change its resolution, refresh rate
+and monitor with @ref glfwSetWindowMonitor.  If you just need change its
+resolution you can also call @ref glfwSetWindowSize.  In all cases, the new
+video mode will be selected the same way as the video mode chosen by @ref
+glfwCreateWindow.
 
 By default, the original video mode of the monitor will be restored and the
 window iconified if it loses input focus, to allow the user to switch back to
@@ -100,6 +107,18 @@ glfwWindowHint(GLFW_REFRESH_RATE, mode->refreshRate);
 GLFWwindow* window = glfwCreateWindow(mode->width, mode->height, "My Title", monitor, NULL);
 @endcode
 
+This also works for windowed mode windows that are made full screen.
+
+@code
+const GLFWvidmode* mode = glfwGetVideoMode(monitor);
+
+glfwSetWindowMonitor(window, monitor, 0, 0, mode->width, mode->height, mode->refreshRate);
+@endcode
+
+Note that @ref glfwGetVideoMode returns the _current_ video mode of a monitor,
+so if you already have a full screen window on that monitor that you want to
+make windowed full screen, you need to have saved the desktop resolution before.
+
 
 @subsection window_destruction Window destruction
 
@@ -140,6 +159,7 @@ The following hints are always hard constraints:
 - `GLFW_STEREO`
 - `GLFW_DOUBLEBUFFER`
 - `GLFW_CLIENT_API`
+- `GLFW_CONTEXT_CREATION_API`
 
 The following additional hints are hard constraints when requesting an OpenGL
 context, but are ignored when requesting an OpenGL ES context:
@@ -174,6 +194,9 @@ above other regular windows, also called topmost or always-on-top.  This is
 intended primarily for debugging purposes and cannot be used to implement proper
 full screen windows.  This hint is ignored for full screen windows.
 
+`GLFW_MAXIMIZED` specifies whether the windowed mode window will be maximized
+when created.  This hint is ignored for full screen windows.
+
 
 @subsubsection window_hints_fb Framebuffer related hints
 
@@ -206,8 +229,9 @@ Zero disables multisampling.  `GLFW_DONT_CARE` means the application has no
 preference.
 
 `GLFW_SRGB_CAPABLE` specifies whether the framebuffer should be sRGB capable.
-If supported, the created context will provide `GL_ARB_framebuffer_sRGB` or
-`GL_EXT_framebuffer_sRGB`.
+If supported, a created OpenGL context will support the `GL_FRAMEBUFFER_SRGB`
+enable, also called `GL_FRAMEBUFFER_SRGB_EXT`) for controlling sRGB rendering
+and a created OpenGL ES context will always have sRGB rendering enabled.
 
 `GLFW_DOUBLEBUFFER` specifies whether the framebuffer should be double buffered.
 You nearly always want to use double buffering.  This is a hard constraint.
@@ -223,18 +247,36 @@ This hint is ignored for windowed mode windows.
 @subsubsection window_hints_ctx Context related hints
 
 `GLFW_CLIENT_API` specifies which client API to create the context for.
-Possible values are `GLFW_OPENGL_API` and `GLFW_OPENGL_ES_API`.  This is a hard
-constraint.
+Possible values are `GLFW_OPENGL_API`, `GLFW_OPENGL_ES_API` and `GLFW_NO_API`.
+This is a hard constraint.
+
+`GLFW_CONTEXT_CREATION_API` specifies which context creation API to use to
+create the context.  Possible values are `GLFW_NATIVE_CONTEXT_API` and
+`GLFW_EGL_CONTEXT_API`.  This is a hard constraint.  If no client API is
+requested, this hint is ignored.
+
+@par
+__OS X:__ The EGL API is not available on this platform and requests to use it
+will fail.
+
+@par
+__Wayland, Mir:__ The EGL API _is_ the native context creation API, so this hint
+will have no effect.
+
+@note An OpenGL extension loader library that assumes it knows which context
+creation API is used on a given platform may fail if you change this hint.  This
+can be resolved by having it load via @ref glfwGetProcAddress, which always uses
+the selected API.
 
 `GLFW_CONTEXT_VERSION_MAJOR` and `GLFW_CONTEXT_VERSION_MINOR` specify the client
 API version that the created context must be compatible with.  The exact
 behavior of these hints depend on the requested client API.
 
 @par
-__OpenGL:__ `GLFW_CONTEXT_VERSION_MAJOR` and `GLFW_CONTEXT_VERSION_MINOR` are not hard
-constraints, but creation will fail if the OpenGL version of the created context
-is less than the one requested.  It is therefore perfectly safe to use the
-default of version 1.0 for legacy code and you may still get
+__OpenGL:__ `GLFW_CONTEXT_VERSION_MAJOR` and `GLFW_CONTEXT_VERSION_MINOR` are
+not hard constraints, but creation will fail if the OpenGL version of the
+created context is less than the one requested.  It is therefore perfectly safe
+to use the default of version 1.0 for legacy code and you will still get
 backwards-compatible contexts of version 3.0 and above when available.
 
 @par
@@ -243,16 +285,16 @@ version, GLFW will attempt to provide this when you ask for a version 1.0
 context, which is the default for these hints.
 
 @par
-__OpenGL ES:__ `GLFW_CONTEXT_VERSION_MAJOR` and `GLFW_CONTEXT_VERSION_MINOR` are not hard
-constraints, but creation will fail if the OpenGL ES version of the created
-context is less than the one requested.  Additionally, OpenGL ES 1.x cannot be
-returned if 2.0 or later was requested, and vice versa.  This is because OpenGL
-ES 3.x is backward compatible with 2.0, but OpenGL ES 2.0 is not backward
-compatible with 1.x.
+__OpenGL ES:__ `GLFW_CONTEXT_VERSION_MAJOR` and `GLFW_CONTEXT_VERSION_MINOR` are
+not hard constraints, but creation will fail if the OpenGL ES version of the
+created context is less than the one requested.  Additionally, OpenGL ES 1.x
+cannot be returned if 2.0 or later was requested, and vice versa.  This is
+because OpenGL ES 3.x is backward compatible with 2.0, but OpenGL ES 2.0 is not
+backward compatible with 1.x.
 
 `GLFW_OPENGL_FORWARD_COMPAT` specifies whether the OpenGL context should be
 forward-compatible, i.e. one where all functionality deprecated in the requested
-version of OpenGL is removed.  This may only be used if the requested OpenGL
+version of OpenGL is removed.  This must only be used if the requested OpenGL
 version is 3.0 or above.  If OpenGL ES is requested, this hint is ignored.
 
 @par
@@ -293,17 +335,35 @@ Context release behaviors are described in detail by the
 [GL_KHR_context_flush_control](https://www.opengl.org/registry/specs/KHR/context_flush_control.txt)
 extension.
 
+`GLFW_CONTEXT_NO_ERROR` specifies whether errors should be generated by the
+context.  If enabled, situations that would have generated errors instead cause
+undefined behavior.
+
+@par
+The no error mode for OpenGL and OpenGL ES is described in detail by the
+[GL_KHR_no_error](https://www.opengl.org/registry/specs/KHR/no_error.txt)
+extension.
+
+@note This hint is experimental in its current state.  There are currently
+(October 2015) no corresponding WGL or GLX extensions.  That makes this hint
+a [hard constraint](@ref window_hints_hard) for those backends, as creation will
+fail if unsupported context flags are requested.  Once the extensions are
+available, they will be required and creation of `GL_KHR_no_error` contexts may
+fail on early drivers where this flag is supported without those extensions
+being listed.
+
 
 @subsubsection window_hints_values Supported and default values
 
 Window hint                     | Default value               | Supported values
 ------------------------------- | --------------------------- | ----------------
-`GLFW_RESIZABLE`                | `GL_TRUE`                   | `GL_TRUE` or `GL_FALSE`
-`GLFW_VISIBLE`                  | `GL_TRUE`                   | `GL_TRUE` or `GL_FALSE`
-`GLFW_DECORATED`                | `GL_TRUE`                   | `GL_TRUE` or `GL_FALSE`
-`GLFW_FOCUSED`                  | `GL_TRUE`                   | `GL_TRUE` or `GL_FALSE`
-`GLFW_AUTO_ICONIFY`             | `GL_TRUE`                   | `GL_TRUE` or `GL_FALSE`
-`GLFW_FLOATING`                 | `GL_FALSE`                  | `GL_TRUE` or `GL_FALSE`
+`GLFW_RESIZABLE`                | `GLFW_TRUE`                 | `GLFW_TRUE` or `GLFW_FALSE`
+`GLFW_VISIBLE`                  | `GLFW_TRUE`                 | `GLFW_TRUE` or `GLFW_FALSE`
+`GLFW_DECORATED`                | `GLFW_TRUE`                 | `GLFW_TRUE` or `GLFW_FALSE`
+`GLFW_FOCUSED`                  | `GLFW_TRUE`                 | `GLFW_TRUE` or `GLFW_FALSE`
+`GLFW_AUTO_ICONIFY`             | `GLFW_TRUE`                 | `GLFW_TRUE` or `GLFW_FALSE`
+`GLFW_FLOATING`                 | `GLFW_FALSE`                | `GLFW_TRUE` or `GLFW_FALSE`
+`GLFW_MAXIMIZED`                | `GLFW_FALSE`                | `GLFW_TRUE` or `GLFW_FALSE`
 `GLFW_RED_BITS`                 | 8                           | 0 to `INT_MAX` or `GLFW_DONT_CARE`
 `GLFW_GREEN_BITS`               | 8                           | 0 to `INT_MAX` or `GLFW_DONT_CARE`
 `GLFW_BLUE_BITS`                | 8                           | 0 to `INT_MAX` or `GLFW_DONT_CARE`
@@ -317,16 +377,17 @@ Window hint                     | Default value               | Supported values
 `GLFW_AUX_BUFFERS`              | 0                           | 0 to `INT_MAX` or `GLFW_DONT_CARE`
 `GLFW_SAMPLES`                  | 0                           | 0 to `INT_MAX` or `GLFW_DONT_CARE`
 `GLFW_REFRESH_RATE`             | `GLFW_DONT_CARE`            | 0 to `INT_MAX` or `GLFW_DONT_CARE`
-`GLFW_STEREO`                   | `GL_FALSE`                  | `GL_TRUE` or `GL_FALSE`
-`GLFW_SRGB_CAPABLE`             | `GL_FALSE`                  | `GL_TRUE` or `GL_FALSE`
-`GLFW_DOUBLEBUFFER`             | `GL_TRUE`                   | `GL_TRUE` or `GL_FALSE`
-`GLFW_CLIENT_API`               | `GLFW_OPENGL_API`           | `GLFW_OPENGL_API` or `GLFW_OPENGL_ES_API`
+`GLFW_STEREO`                   | `GLFW_FALSE`                | `GLFW_TRUE` or `GLFW_FALSE`
+`GLFW_SRGB_CAPABLE`             | `GLFW_FALSE`                | `GLFW_TRUE` or `GLFW_FALSE`
+`GLFW_DOUBLEBUFFER`             | `GLFW_TRUE`                 | `GLFW_TRUE` or `GLFW_FALSE`
+`GLFW_CLIENT_API`               | `GLFW_OPENGL_API`           | `GLFW_OPENGL_API`, `GLFW_OPENGL_ES_API` or `GLFW_NO_API`
+`GLFW_CONTEXT_CREATION_API`     | `GLFW_NATIVE_CONTEXT_API`   | `GLFW_NATIVE_CONTEXT_API` or `GLFW_EGL_CONTEXT_API`
 `GLFW_CONTEXT_VERSION_MAJOR`    | 1                           | Any valid major version number of the chosen client API
 `GLFW_CONTEXT_VERSION_MINOR`    | 0                           | Any valid minor version number of the chosen client API
 `GLFW_CONTEXT_ROBUSTNESS`       | `GLFW_NO_ROBUSTNESS`        | `GLFW_NO_ROBUSTNESS`, `GLFW_NO_RESET_NOTIFICATION` or `GLFW_LOSE_CONTEXT_ON_RESET`
 `GLFW_CONTEXT_RELEASE_BEHAVIOR` | `GLFW_ANY_RELEASE_BEHAVIOR` | `GLFW_ANY_RELEASE_BEHAVIOR`, `GLFW_RELEASE_BEHAVIOR_FLUSH` or `GLFW_RELEASE_BEHAVIOR_NONE`
-`GLFW_OPENGL_FORWARD_COMPAT`    | `GL_FALSE`                  | `GL_TRUE` or `GL_FALSE`
-`GLFW_OPENGL_DEBUG_CONTEXT`     | `GL_FALSE`                  | `GL_TRUE` or `GL_FALSE`
+`GLFW_OPENGL_FORWARD_COMPAT`    | `GLFW_FALSE`                | `GLFW_TRUE` or `GLFW_FALSE`
+`GLFW_OPENGL_DEBUG_CONTEXT`     | `GLFW_FALSE`                | `GLFW_TRUE` or `GLFW_FALSE`
 `GLFW_OPENGL_PROFILE`           | `GLFW_OPENGL_ANY_PROFILE`   | `GLFW_OPENGL_ANY_PROFILE`, `GLFW_OPENGL_COMPAT_PROFILE` or `GLFW_OPENGL_CORE_PROFILE`
 
 
@@ -383,7 +444,7 @@ again unless certain conditions are met.
 void window_close_callback(GLFWwindow* window)
 {
     if (!time_to_close)
-        glfwSetWindowShouldClose(window, GL_FALSE);
+        glfwSetWindowShouldClose(window, GLFW_FALSE);
 }
 @endcode
 
@@ -400,7 +461,7 @@ glfwSetWindowSize(window, 640, 480);
 @endcode
 
 For full screen windows, the specified size becomes the new resolution of the
-window's *desired video mode*.  The video mode most closely matching the new
+window's desired video mode.  The video mode most closely matching the new
 desired video mode is set immediately.  The window is resized to fit the
 resolution of the set video mode.
 
@@ -485,6 +546,52 @@ The size of a framebuffer may change independently of the size of a window, for
 example if the window is dragged between a regular monitor and a high-DPI one.
 
 
+@subsection window_sizelimits Window size limits
+
+The minimum and maximum size of the client area of a windowed mode window can be
+enforced with @ref glfwSetWindowSizeLimits.  The user may resize the window to
+any size and aspect ratio within the specified limits, unless the aspect ratio
+is also set.
+
+@code
+glfwSetWindowSizeLimits(window, 200, 200, 400, 400);
+@endcode
+
+To specify only a minimum size or only a maximum one, set the other pair to
+`GLFW_DONT_CARE`.
+
+@code
+glfwSetWindowSizeLimits(window, 640, 480, GLFW_DONT_CARE, GLFW_DONT_CARE);
+@endcode
+
+To disable size limits for a window, set them all to `GLFW_DONT_CARE`.
+
+The aspect ratio of the client area of a windowed mode window can be enforced
+with @ref glfwSetWindowAspectRatio.  The user may resize the window freely
+unless size limits are also set, but the size will be constrained to maintain
+the aspect ratio.
+
+@code
+glfwSetWindowAspectRatio(window, 16, 9);
+@endcode
+
+The aspect ratio is specified as a numerator and denominator, corresponding to
+the width and height, respectively.  If you want a window to maintain its
+current aspect ratio, simply use its current size as the ratio.
+
+@code
+int width, height;
+glfwGetWindowSize(window, &width, &height);
+glfwSetWindowAspectRatio(window, width, height);
+@endcode
+
+To disable the aspect ratio limit for a window, set both terms to
+`GLFW_DONT_CARE`.
+
+You can have both size limits and aspect ratio set for a window, but the results
+are undefined if they conflict.
+
+
 @subsection window_pos Window position
 
 The position of a windowed-mode window can be changed with @ref
@@ -538,7 +645,33 @@ As long as your source file is encoded as UTF-8, you can use any Unicode
 characters directly in the source.
 
 @code
-glfwSetWindowTitle(window, "プラネテス");
+glfwSetWindowTitle(window, "星を追う子ども");
+@endcode
+
+If you are using C++11 or C11, you can use a UTF-8 string literal.
+
+@code
+glfwSetWindowTitle(window, u8"This is always a UTF-8 string");
+@endcode
+
+
+@subsection window_icon Window icon
+
+Decorated windows have icons on some platforms.  You can set this icon by
+specifying a list of candidate images with @ref glfwSetWindowIcon.
+
+@code
+GLFWimage images[2];
+images[0] = load_icon("my_icon.png");
+images[1] = load_icon("my_icon_small.png");
+
+glfwSetWindowIcon(window, 2, images);
+@endcode
+
+To revert to the default window icon, pass in an empty image array.
+
+@code
+glfwSetWindowIcon(window, 0, NULL);
 @endcode
 
 
@@ -553,8 +686,31 @@ GLFWmonitor* monitor = glfwGetWindowMonitor(window);
 
 This monitor handle is one of those returned by @ref glfwGetMonitors.
 
-For windowed mode windows, this function returns `NULL`.  This is the
-recommended way to tell full screen windows from windowed mode windows.
+For windowed mode windows, this function returns `NULL`.  This is how to tell
+full screen windows from windowed mode windows.
+
+You can move windows between monitors or between full screen and windowed mode
+with @ref glfwSetWindowMonitor.  When making a window full screen on the same or
+on a different monitor, specify the desired monitor, resolution and refresh
+rate.  The position arguments are ignored.
+
+@code
+const GLFWvidmode* mode = glfwGetVideoMode(monitor);
+
+glfwSetWindowMonitor(window, monitor, 0, 0, mode->width, mode->height, mode->refreshRate);
+@endcode
+
+When making the window windowed, specify the desired position and size.  The
+refresh rate argument is ignored.
+
+@code
+glfwSetWindowMonitor(window, NULL, xpos, ypos, width, height, 0);
+@endcode
+
+This restores any previous window settings such as whether it is decorated,
+floating, resizable, has size or aspect ratio limits, etc..  To restore a window
+that was originally windowed to its original size and position, save these
+before making it full screen and then pass them in as above.
 
 
 @subsection window_iconify Window iconification
@@ -640,6 +796,13 @@ int visible = glfwGetWindowAttrib(window, GLFW_VISIBLE);
 
 @subsection window_focus Window input focus
 
+Windows can be given input focus and brought to the front with @ref
+glfwFocusWindow.
+
+@code
+glfwFocusWindow(window);
+@endcode
+
 If you wish to be notified when a window gains or loses input focus, whether by
 the user, system or your own code, set a focus callback.
 
@@ -720,6 +883,9 @@ same name.
 `GLFW_ICONIFIED` indicates whether the specified window is iconified, whether by
 the user or with @ref glfwIconifyWindow.
 
+`GLFW_MAXIMIZED` indicates whether the specified window is maximized, whether by
+the user or with @ref glfwMaximizeWindow.
+
 `GLFW_VISIBLE` indicates whether the specified window is visible.  Window
 visibility can be controlled with @ref glfwShowWindow and @ref glfwHideWindow
 and initial visibility is controlled by the [window hint](@ref window_hints_wnd)
@@ -741,16 +907,20 @@ topmost or always-on-top.  This is controlled by the
 @subsubsection window_attribs_ctx Context related attributes
 
 `GLFW_CLIENT_API` indicates the client API provided by the window's context;
-either `GLFW_OPENGL_API` or `GLFW_OPENGL_ES_API`.
+either `GLFW_OPENGL_API`, `GLFW_OPENGL_ES_API` or `GLFW_NO_API`.
+
+`GLFW_CONTEXT_CREATION_API` indicates the context creation API used to create
+the window's context; either `GLFW_NATIVE_CONTEXT_API` or
+`GLFW_EGL_CONTEXT_API`.
 
 `GLFW_CONTEXT_VERSION_MAJOR`, `GLFW_CONTEXT_VERSION_MINOR` and
 `GLFW_CONTEXT_REVISION` indicate the client API version of the window's context.
 
-`GLFW_OPENGL_FORWARD_COMPAT` is `GL_TRUE` if the window's context is an OpenGL
-forward-compatible one, or `GL_FALSE` otherwise.
+`GLFW_OPENGL_FORWARD_COMPAT` is `GLFW_TRUE` if the window's context is an OpenGL
+forward-compatible one, or `GLFW_FALSE` otherwise.
 
-`GLFW_OPENGL_DEBUG_CONTEXT` is `GL_TRUE` if the window's context is an OpenGL
-debug context, or `GL_FALSE` otherwise.
+`GLFW_OPENGL_DEBUG_CONTEXT` is `GLFW_TRUE` if the window's context is an OpenGL
+debug context, or `GLFW_FALSE` otherwise.
 
 `GLFW_OPENGL_PROFILE` indicates the OpenGL profile used by the context.  This is
 `GLFW_OPENGL_CORE_PROFILE` or `GLFW_OPENGL_COMPAT_PROFILE` if the context uses
@@ -766,9 +936,9 @@ window's context supports robustness, or `GLFW_NO_ROBUSTNESS` otherwise.
 
 @subsubsection window_attribs_fb Framebuffer related attributes
 
-The attributes of the default framebuffer (i.e. the framebuffer attached to the
-window) are not provided by this function but can be queried with both OpenGL
-and OpenGL ES.
+GLFW does not expose attributes of the default framebuffer (i.e. the framebuffer
+attached to the window) as these can be queried directly with either OpenGL,
+OpenGL ES or Vulkan.
 
 If you are using version 3.0 or later of OpenGL or OpenGL ES, the
 `glGetFramebufferAttachmentParameteriv` function can be used to retrieve the
@@ -790,8 +960,8 @@ Stencil bits | `GL_STENCIL_BITS` | `GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE`
 MSAA samples | `GL_SAMPLES`      | _Not provided by this function_
 
 When calling `glGetFramebufferAttachmentParameteriv`, the red, green, blue and
-alpha sizes can be queried from the `GL_BACK_LEFT`, while the depth and stencil
-sizes can be queried from the `GL_DEPTH` and `GL_STENCIL` attachments,
+alpha sizes are queried from the `GL_BACK_LEFT`, while the depth and stencil
+sizes are queried from the `GL_DEPTH` and `GL_STENCIL` attachments,
 respectively.
 
 

examples/CMakeLists.txt

@@ -1,18 +1,24 @@
 
 link_libraries(glfw)
 
+include_directories(${glfw_INCLUDE_DIRS})
+
 if (BUILD_SHARED_LIBS)
-    add_definitions(-DGLFW_DLL)
-    link_libraries("${OPENGL_gl_LIBRARY}" "${MATH_LIBRARY}")
-else()
-    link_libraries(${glfw_LIBRARIES})
+    link_libraries("${MATH_LIBRARY}")
 endif()
 
-include_directories("${GLFW_SOURCE_DIR}/include"
-                    "${GLFW_SOURCE_DIR}/deps")
+if (MSVC)
+    add_definitions(-D_CRT_SECURE_NO_WARNINGS)
+endif()
 
-if ("${OPENGL_INCLUDE_DIR}")
-    include_directories("${OPENGL_INCLUDE_DIR}")
+include_directories("${GLFW_SOURCE_DIR}/deps")
+
+if (WIN32)
+    set(ICON glfw.rc)
+elseif (APPLE)
+    set(ICON glfw.icns)
+    set_source_files_properties(glfw.icns PROPERTIES
+        MAXOSX_PACKAGE_LOCATION "Resources")
 endif()
 
 set(GLAD "${GLFW_SOURCE_DIR}/deps/glad/glad.h"
@@ -22,13 +28,13 @@ set(GETOPT "${GLFW_SOURCE_DIR}/deps/getopt.h"
 set(TINYCTHREAD "${GLFW_SOURCE_DIR}/deps/tinycthread.h"
                 "${GLFW_SOURCE_DIR}/deps/tinycthread.c")
 
-add_executable(boing WIN32 MACOSX_BUNDLE boing.c)
-add_executable(gears WIN32 MACOSX_BUNDLE gears.c)
-add_executable(heightmap WIN32 MACOSX_BUNDLE heightmap.c ${GLAD})
-add_executable(particles WIN32 MACOSX_BUNDLE particles.c ${TINYCTHREAD} ${GETOPT})
-add_executable(simple WIN32 MACOSX_BUNDLE simple.c)
-add_executable(splitview WIN32 MACOSX_BUNDLE splitview.c)
-add_executable(wave WIN32 MACOSX_BUNDLE wave.c)
+add_executable(boing WIN32 MACOSX_BUNDLE boing.c ${ICON} ${GLAD})
+add_executable(gears WIN32 MACOSX_BUNDLE gears.c ${ICON} ${GLAD})
+add_executable(heightmap WIN32 MACOSX_BUNDLE heightmap.c ${ICON} ${GLAD})
+add_executable(particles WIN32 MACOSX_BUNDLE particles.c ${ICON} ${TINYCTHREAD} ${GETOPT} ${GLAD})
+add_executable(simple WIN32 MACOSX_BUNDLE simple.c ${ICON} ${GLAD})
+add_executable(splitview WIN32 MACOSX_BUNDLE splitview.c ${ICON} ${GLAD})
+add_executable(wave WIN32 MACOSX_BUNDLE wave.c ${ICON} ${GLAD})
 
 target_link_libraries(particles "${CMAKE_THREAD_LIBS_INIT}" "${RT_LIBRARY}")
 
@@ -48,12 +54,14 @@ if (APPLE)
     set_target_properties(heightmap PROPERTIES MACOSX_BUNDLE_BUNDLE_NAME "Heightmap")
     set_target_properties(particles PROPERTIES MACOSX_BUNDLE_BUNDLE_NAME "Particles")
     set_target_properties(simple PROPERTIES MACOSX_BUNDLE_BUNDLE_NAME "Simple")
-    set_target_properties(splitview PROPERTIES MACOSX_BUNDLE_BUNDLE_NAME "Split View")
+    set_target_properties(splitview PROPERTIES MACOSX_BUNDLE_BUNDLE_NAME "SplitView")
     set_target_properties(wave PROPERTIES MACOSX_BUNDLE_BUNDLE_NAME "Wave")
 
     set_target_properties(${WINDOWS_BINARIES} PROPERTIES
+                          RESOURCE glfw.icns
                           MACOSX_BUNDLE_SHORT_VERSION_STRING ${GLFW_VERSION}
                           MACOSX_BUNDLE_LONG_VERSION_STRING ${GLFW_VERSION_FULL}
+                          MACOSX_BUNDLE_ICON_FILE glfw.icns
                           MACOSX_BUNDLE_INFO_PLIST "${GLFW_SOURCE_DIR}/CMake/MacOSXBundleInfo.plist.in")
 endif()
 

examples/boing.c

@@ -36,6 +36,7 @@
 #include <stdlib.h>
 #include <math.h>
 
+#include <glad/glad.h>
 #include <GLFW/glfw3.h>
 
 #include <linmath.h>
@@ -88,10 +89,11 @@ typedef enum { DRAW_BALL, DRAW_BALL_SHADOW } DRAW_BALL_ENUM;
 typedef struct {float x; float y; float z;} vertex_t;
 
 /* Global vars */
+int windowed_xpos, windowed_ypos, windowed_width, windowed_height;
 int width, height;
 GLfloat deg_rot_y       = 0.f;
 GLfloat deg_rot_y_inc   = 2.f;
-GLboolean override_pos  = GL_FALSE;
+int override_pos        = GLFW_FALSE;
 GLfloat cursor_x        = 0.f;
 GLfloat cursor_y        = 0.f;
 GLfloat ball_x          = -RADIUS;
@@ -235,8 +237,32 @@ void reshape( GLFWwindow* window, int w, int h )
 
 void key_callback( GLFWwindow* window, int key, int scancode, int action, int mods )
 {
-    if (key == GLFW_KEY_ESCAPE && action == GLFW_PRESS)
-        glfwSetWindowShouldClose(window, GL_TRUE);
+    if (action != GLFW_PRESS)
+        return;
+
+    if (key == GLFW_KEY_ESCAPE && mods == 0)
+        glfwSetWindowShouldClose(window, GLFW_TRUE);
+    if ((key == GLFW_KEY_ENTER && mods == GLFW_MOD_ALT) ||
+        (key == GLFW_KEY_F11 && mods == GLFW_MOD_ALT))
+    {
+        if (glfwGetWindowMonitor(window))
+        {
+            glfwSetWindowMonitor(window, NULL,
+                                 windowed_xpos, windowed_ypos,
+                                 windowed_width, windowed_height, 0);
+        }
+        else
+        {
+            GLFWmonitor* monitor = glfwGetPrimaryMonitor();
+            if (monitor)
+            {
+                const GLFWvidmode* mode = glfwGetVideoMode(monitor);
+                glfwGetWindowPos(window, &windowed_xpos, &windowed_ypos);
+                glfwGetWindowSize(window, &windowed_width, &windowed_height);
+                glfwSetWindowMonitor(window, monitor, 0, 0, mode->width, mode->height, mode->refreshRate);
+            }
+        }
+    }
 }
 
 static void set_ball_pos ( GLfloat x, GLfloat y )
@@ -252,12 +278,12 @@ void mouse_button_callback( GLFWwindow* window, int button, int action, int mods
 
    if (action == GLFW_PRESS)
    {
-      override_pos = GL_TRUE;
+      override_pos = GLFW_TRUE;
       set_ball_pos(cursor_x, cursor_y);
    }
    else
    {
-      override_pos = GL_FALSE;
+      override_pos = GLFW_FALSE;
    }
 }
 
@@ -601,8 +627,6 @@ int main( void )
    if( !glfwInit() )
       exit( EXIT_FAILURE );
 
-   glfwWindowHint(GLFW_DEPTH_BITS, 16);
-
    window = glfwCreateWindow( 400, 400, "Boing (classic Amiga demo)", NULL, NULL );
    if (!window)
    {
@@ -610,12 +634,15 @@ int main( void )
        exit( EXIT_FAILURE );
    }
 
+   glfwSetWindowAspectRatio(window, 1, 1);
+
    glfwSetFramebufferSizeCallback(window, reshape);
    glfwSetKeyCallback(window, key_callback);
    glfwSetMouseButtonCallback(window, mouse_button_callback);
    glfwSetCursorPosCallback(window, cursor_position_callback);
 
    glfwMakeContextCurrent(window);
+   gladLoadGLLoader((GLADloadproc) glfwGetProcAddress);
    glfwSwapInterval( 1 );
 
    glfwGetFramebufferSize(window, &width, &height);

examples/gears.c

@@ -30,6 +30,8 @@
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
+
+#include <glad/glad.h>
 #include <GLFW/glfw3.h>
 
 /**
@@ -219,7 +221,7 @@ void key( GLFWwindow* window, int k, int s, int action, int mods )
       view_rotz += 5.0;
     break;
   case GLFW_KEY_ESCAPE:
-    glfwSetWindowShouldClose(window, GL_TRUE);
+    glfwSetWindowShouldClose(window, GLFW_TRUE);
     break;
   case GLFW_KEY_UP:
     view_rotx += 5.0;
@@ -323,6 +325,7 @@ int main(int argc, char *argv[])
     glfwSetKeyCallback(window, key);
 
     glfwMakeContextCurrent(window);
+    gladLoadGLLoader((GLADloadproc) glfwGetProcAddress);
     glfwSwapInterval( 1 );
 
     glfwGetFramebufferSize(window, &width, &height);

examples/glfw.rc

@@ -0,0 +1,3 @@
+
+GLFW_ICON               ICON            "glfw.ico"
+

examples/heightmap.c

@@ -319,7 +319,7 @@ static void update_map(int num_iter)
         {
             GLfloat dx = center_x - map_vertices[0][ii];
             GLfloat dz = center_z - map_vertices[2][ii];
-            GLfloat pd = (2.0f * sqrtf((dx * dx) + (dz * dz))) / circle_size;
+            GLfloat pd = (2.0f * (float) sqrt((dx * dx) + (dz * dz))) / circle_size;
             if (fabs(pd) <= 1.0f)
             {
                 /* tx,tz is within the circle */
@@ -386,7 +386,7 @@ static void key_callback(GLFWwindow* window, int key, int scancode, int action,
     {
         case GLFW_KEY_ESCAPE:
             /* Exit program on Escape */
-            glfwSetWindowShouldClose(window, GL_TRUE);
+            glfwSetWindowShouldClose(window, GLFW_TRUE);
             break;
     }
 }
@@ -406,6 +406,7 @@ int main(int argc, char** argv)
     float f;
     GLint uloc_modelview;
     GLint uloc_project;
+    int width, height;
 
     GLuint shader_program;
 
@@ -414,11 +415,11 @@ int main(int argc, char** argv)
     if (!glfwInit())
         exit(EXIT_FAILURE);
 
-    glfwWindowHint(GLFW_RESIZABLE, GL_FALSE);
+    glfwWindowHint(GLFW_RESIZABLE, GLFW_FALSE);
     glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
     glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 2);
     glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
-    glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
+    glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GLFW_TRUE);
 
     window = glfwCreateWindow(800, 600, "GLFW OpenGL3 Heightmap demo", NULL, NULL);
     if (! window )
@@ -469,7 +470,8 @@ int main(int argc, char** argv)
     /* Create the vbo to store all the information for the grid and the height */
 
     /* setup the scene ready for rendering */
-    glViewport(0, 0, 800, 600);
+    glfwGetFramebufferSize(window, &width, &height);
+    glViewport(0, 0, width, height);
     glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
 
     /* main loop */

examples/particles.c

@@ -1,7 +1,7 @@
 //========================================================================
 // A simple particle engine with threaded physics
 // Copyright (c) Marcus Geelnard
-// Copyright (c) Camilla Berglund <elmindreda@elmindreda.org>
+// Copyright (c) Camilla Berglund <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
@@ -39,6 +39,7 @@
 #include <getopt.h>
 #include <linmath.h>
 
+#include <glad/glad.h>
 #include <GLFW/glfw3.h>
 
 // Define tokens for GL_EXT_separate_specular_color if not already defined
@@ -875,7 +876,7 @@ static void key_callback(GLFWwindow* window, int key, int scancode, int action,
         switch (key)
         {
             case GLFW_KEY_ESCAPE:
-                glfwSetWindowShouldClose(window, GL_TRUE);
+                glfwSetWindowShouldClose(window, GLFW_TRUE);
                 break;
             case GLFW_KEY_W:
                 wireframe = !wireframe;
@@ -989,6 +990,7 @@ int main(int argc, char** argv)
         glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
 
     glfwMakeContextCurrent(window);
+    gladLoadGLLoader((GLADloadproc) glfwGetProcAddress);
     glfwSwapInterval(1);
 
     glfwSetFramebufferSizeCallback(window, resize_callback);

examples/simple.c

@@ -1,6 +1,6 @@
 //========================================================================
 // Simple GLFW example
-// Copyright (c) Camilla Berglund <elmindreda@elmindreda.org>
+// Copyright (c) Camilla Berglund <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,31 +24,68 @@
 //========================================================================
 //! [code]
 
+#include <glad/glad.h>
 #include <GLFW/glfw3.h>
 
+#include "linmath.h"
+
 #include <stdlib.h>
 #include <stdio.h>
 
+static const struct
+{
+    float x, y;
+    float r, g, b;
+} vertices[3] =
+{
+    { -0.6f, -0.4f, 1.f, 0.f, 0.f },
+    {  0.6f, -0.4f, 0.f, 1.f, 0.f },
+    {   0.f,  0.6f, 0.f, 0.f, 1.f }
+};
+
+static const char* vertex_shader_text =
+"uniform mat4 MVP;\n"
+"attribute vec3 vCol;\n"
+"attribute vec2 vPos;\n"
+"varying vec3 color;\n"
+"void main()\n"
+"{\n"
+"    gl_Position = MVP * vec4(vPos, 0.0, 1.0);\n"
+"    color = vCol;\n"
+"}\n";
+
+static const char* fragment_shader_text =
+"varying vec3 color;\n"
+"void main()\n"
+"{\n"
+"    gl_FragColor = vec4(color, 1.0);\n"
+"}\n";
+
 static void error_callback(int error, const char* description)
 {
-    fputs(description, stderr);
+    fprintf(stderr, "Error: %s\n", description);
 }
 
 static void key_callback(GLFWwindow* window, int key, int scancode, int action, int mods)
 {
     if (key == GLFW_KEY_ESCAPE && action == GLFW_PRESS)
-        glfwSetWindowShouldClose(window, GL_TRUE);
+        glfwSetWindowShouldClose(window, GLFW_TRUE);
 }
 
 int main(void)
 {
     GLFWwindow* window;
+    GLuint vertex_buffer, vertex_shader, fragment_shader, program;
+    GLint mvp_location, vpos_location, vcol_location;
 
     glfwSetErrorCallback(error_callback);
 
     if (!glfwInit())
         exit(EXIT_FAILURE);
 
+    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 2);
+    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 0);
+
     window = glfwCreateWindow(640, 480, "Simple example", NULL, NULL);
     if (!window)
     {
@@ -56,15 +93,47 @@ int main(void)
         exit(EXIT_FAILURE);
     }
 
+    glfwSetKeyCallback(window, key_callback);
+
     glfwMakeContextCurrent(window);
+    gladLoadGLLoader((GLADloadproc) glfwGetProcAddress);
     glfwSwapInterval(1);
 
-    glfwSetKeyCallback(window, key_callback);
+    // NOTE: OpenGL error checks have been omitted for brevity
+
+    glGenBuffers(1, &vertex_buffer);
+    glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer);
+    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
+
+    vertex_shader = glCreateShader(GL_VERTEX_SHADER);
+    glShaderSource(vertex_shader, 1, &vertex_shader_text, NULL);
+    glCompileShader(vertex_shader);
+
+    fragment_shader = glCreateShader(GL_FRAGMENT_SHADER);
+    glShaderSource(fragment_shader, 1, &fragment_shader_text, NULL);
+    glCompileShader(fragment_shader);
+
+    program = glCreateProgram();
+    glAttachShader(program, vertex_shader);
+    glAttachShader(program, fragment_shader);
+    glLinkProgram(program);
+
+    mvp_location = glGetUniformLocation(program, "MVP");
+    vpos_location = glGetAttribLocation(program, "vPos");
+    vcol_location = glGetAttribLocation(program, "vCol");
+
+    glEnableVertexAttribArray(vpos_location);
+    glVertexAttribPointer(vpos_location, 2, GL_FLOAT, GL_FALSE,
+                          sizeof(float) * 5, (void*) 0);
+    glEnableVertexAttribArray(vcol_location);
+    glVertexAttribPointer(vcol_location, 3, GL_FLOAT, GL_FALSE,
+                          sizeof(float) * 5, (void*) (sizeof(float) * 2));
 
     while (!glfwWindowShouldClose(window))
     {
         float ratio;
         int width, height;
+        mat4x4 m, p, mvp;
 
         glfwGetFramebufferSize(window, &width, &height);
         ratio = width / (float) height;
@@ -72,22 +141,14 @@ int main(void)
         glViewport(0, 0, width, height);
         glClear(GL_COLOR_BUFFER_BIT);
 
-        glMatrixMode(GL_PROJECTION);
-        glLoadIdentity();
-        glOrtho(-ratio, ratio, -1.f, 1.f, 1.f, -1.f);
-        glMatrixMode(GL_MODELVIEW);
+        mat4x4_identity(m);
+        mat4x4_rotate_Z(m, m, (float) glfwGetTime());
+        mat4x4_ortho(p, -ratio, ratio, -1.f, 1.f, 1.f, -1.f);
+        mat4x4_mul(mvp, p, m);
 
-        glLoadIdentity();
-        glRotatef((float) glfwGetTime() * 50.f, 0.f, 0.f, 1.f);
-
-        glBegin(GL_TRIANGLES);
-        glColor3f(1.f, 0.f, 0.f);
-        glVertex3f(-0.6f, -0.4f, 0.f);
-        glColor3f(0.f, 1.f, 0.f);
-        glVertex3f(0.6f, -0.4f, 0.f);
-        glColor3f(0.f, 0.f, 1.f);
-        glVertex3f(0.f, 0.6f, 0.f);
-        glEnd();
+        glUseProgram(program);
+        glUniformMatrix4fv(mvp_location, 1, GL_FALSE, (const GLfloat*) mvp);
+        glDrawArrays(GL_TRIANGLES, 0, 3);
 
         glfwSwapBuffers(window);
         glfwPollEvents();

examples/splitview.c

@@ -10,7 +10,7 @@
 //  because I am not a friend of orthogonal projections)
 //========================================================================
 
-#define GLFW_INCLUDE_GLEXT
+#include <glad/glad.h>
 #include <GLFW/glfw3.h>
 
 #if defined(_MSC_VER)
@@ -473,7 +473,7 @@ static void mouseButtonFun(GLFWwindow* window, int button, int action, int mods)
 static void key_callback(GLFWwindow* window, int key, int scancode, int action, int mods)
 {
     if (key == GLFW_KEY_ESCAPE && action == GLFW_PRESS)
-        glfwSetWindowShouldClose(window, GL_TRUE);
+        glfwSetWindowShouldClose(window, GLFW_TRUE);
 }
 
 
@@ -513,14 +513,11 @@ int main(void)
 
     // Enable vsync
     glfwMakeContextCurrent(window);
+    gladLoadGLLoader((GLADloadproc) glfwGetProcAddress);
     glfwSwapInterval(1);
 
-    if (glfwExtensionSupported("GL_ARB_multisample") ||
-        glfwGetWindowAttrib(window, GLFW_CONTEXT_VERSION_MAJOR) >= 2 ||
-        glfwGetWindowAttrib(window, GLFW_CONTEXT_VERSION_MINOR) >= 3)
-    {
+    if (GLAD_GL_ARB_multisample || GLAD_GL_VERSION_1_3)
         glEnable(GL_MULTISAMPLE_ARB);
-    }
 
     glfwGetFramebufferSize(window, &width, &height);
     framebufferSizeFun(window, width, height);

examples/wave.c

@@ -17,6 +17,7 @@
 #include <stdlib.h>
 #include <math.h>
 
+#include <glad/glad.h>
 #include <GLFW/glfw3.h>
 
 #include <linmath.h>
@@ -278,7 +279,7 @@ void key_callback(GLFWwindow* window, int key, int scancode, int action, int mod
     switch (key)
     {
         case GLFW_KEY_ESCAPE:
-            glfwSetWindowShouldClose(window, GL_TRUE);
+            glfwSetWindowShouldClose(window, GLFW_TRUE);
             break;
         case GLFW_KEY_SPACE:
             init_grid();
@@ -411,6 +412,7 @@ int main(int argc, char* argv[])
     glfwSetScrollCallback(window, scroll_callback);
 
     glfwMakeContextCurrent(window);
+    gladLoadGLLoader((GLADloadproc) glfwGetProcAddress);
     glfwSwapInterval(1);
 
     glfwGetFramebufferSize(window, &width, &height);

include/GLFW/glfw3native.h

@@ -1,9 +1,9 @@
 /*************************************************************************
- * GLFW 3.1 - www.glfw.org
+ * GLFW 3.2 - www.glfw.org
  * A library for OpenGL, window and input
  *------------------------------------------------------------------------
  * Copyright (c) 2002-2006 Marcus Geelnard
- * Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
+ * Copyright (c) 2006-2016 Camilla Berglund <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
@@ -38,20 +38,30 @@ extern "C" {
  * Doxygen documentation
  *************************************************************************/
 
+/*! @file glfw3native.h
+ *  @brief The header of the native access functions.
+ *
+ *  This is the header file of the native access functions.  See @ref native for
+ *  more information.
+ */
 /*! @defgroup native Native access
  *
  *  **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 must define exactly one
- *  window system API macro and exactly one context creation API macro.  Failure
- *  to do this will cause a compile-time error.
+ *  Before the inclusion of @ref glfw3native.h, you may define exactly one
+ *  window system API macro and zero or more context creation API macros.
+ *
+ *  The chosen backends must match those the library was compiled for.  Failure
+ *  to do this will cause a link-time error.
  *
  *  The available window API macros are:
  *  * `GLFW_EXPOSE_NATIVE_WIN32`
  *  * `GLFW_EXPOSE_NATIVE_COCOA`
  *  * `GLFW_EXPOSE_NATIVE_X11`
+ *  * `GLFW_EXPOSE_NATIVE_WAYLAND`
+ *  * `GLFW_EXPOSE_NATIVE_MIR`
  *
  *  The available context API macros are:
  *  * `GLFW_EXPOSE_NATIVE_WGL`
@@ -86,20 +96,23 @@ extern "C" {
 #elif defined(GLFW_EXPOSE_NATIVE_X11)
  #include <X11/Xlib.h>
  #include <X11/extensions/Xrandr.h>
-#else
- #error "No window API selected"
+#elif defined(GLFW_EXPOSE_NATIVE_WAYLAND)
+ #include <wayland-client.h>
+#elif defined(GLFW_EXPOSE_NATIVE_MIR)
+ #include <mir_toolkit/mir_client_library.h>
 #endif
 
 #if defined(GLFW_EXPOSE_NATIVE_WGL)
  /* WGL is declared by windows.h */
-#elif defined(GLFW_EXPOSE_NATIVE_NSGL)
+#endif
+#if defined(GLFW_EXPOSE_NATIVE_NSGL)
  /* NSGL is declared by Cocoa.h */
-#elif defined(GLFW_EXPOSE_NATIVE_GLX)
+#endif
+#if defined(GLFW_EXPOSE_NATIVE_GLX)
  #include <GL/glx.h>
-#elif defined(GLFW_EXPOSE_NATIVE_EGL)
+#endif
+#if defined(GLFW_EXPOSE_NATIVE_EGL)
  #include <EGL/egl.h>
-#else
- #error "No context API selected"
 #endif
 
 
@@ -114,11 +127,10 @@ extern "C" {
  *  of the specified monitor, or `NULL` if an [error](@ref error_handling)
  *  occurred.
  *
- *  @par Thread Safety
- *  This function may be called from any thread.  Access is not synchronized.
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
  *
- *  @par History
- *  Added in GLFW 3.1.
+ *  @since Added in version 3.1.
  *
  *  @ingroup native
  */
@@ -130,11 +142,10 @@ GLFWAPI const char* glfwGetWin32Adapter(GLFWmonitor* monitor);
  *  `\\.\DISPLAY1\Monitor0`) of the specified monitor, or `NULL` if an
  *  [error](@ref error_handling) occurred.
  *
- *  @par Thread Safety
- *  This function may be called from any thread.  Access is not synchronized.
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
  *
- *  @par History
- *  Added in GLFW 3.1.
+ *  @since Added in version 3.1.
  *
  *  @ingroup native
  */
@@ -145,11 +156,10 @@ GLFWAPI const char* glfwGetWin32Monitor(GLFWmonitor* monitor);
  *  @return The `HWND` of the specified window, or `NULL` if an
  *  [error](@ref error_handling) occurred.
  *
- *  @par Thread Safety
- *  This function may be called from any thread.  Access is not synchronized.
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
  *
- *  @par History
- *  Added in GLFW 3.0.
+ *  @since Added in version 3.0.
  *
  *  @ingroup native
  */
@@ -162,11 +172,10 @@ GLFWAPI HWND glfwGetWin32Window(GLFWwindow* window);
  *  @return The `HGLRC` of the specified window, or `NULL` if an
  *  [error](@ref error_handling) occurred.
  *
- *  @par Thread Safety
- *  This function may be called from any thread.  Access is not synchronized.
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
  *
- *  @par History
- *  Added in GLFW 3.0.
+ *  @since Added in version 3.0.
  *
  *  @ingroup native
  */
@@ -179,11 +188,10 @@ GLFWAPI HGLRC glfwGetWGLContext(GLFWwindow* window);
  *  @return The `CGDirectDisplayID` of the specified monitor, or
  *  `kCGNullDirectDisplay` if an [error](@ref error_handling) occurred.
  *
- *  @par Thread Safety
- *  This function may be called from any thread.  Access is not synchronized.
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
  *
- *  @par History
- *  Added in GLFW 3.1.
+ *  @since Added in version 3.1.
  *
  *  @ingroup native
  */
@@ -194,11 +202,10 @@ GLFWAPI CGDirectDisplayID glfwGetCocoaMonitor(GLFWmonitor* monitor);
  *  @return The `NSWindow` of the specified window, or `nil` if an
  *  [error](@ref error_handling) occurred.
  *
- *  @par Thread Safety
- *  This function may be called from any thread.  Access is not synchronized.
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
  *
- *  @par History
- *  Added in GLFW 3.0.
+ *  @since Added in version 3.0.
  *
  *  @ingroup native
  */
@@ -211,11 +218,10 @@ GLFWAPI id glfwGetCocoaWindow(GLFWwindow* window);
  *  @return The `NSOpenGLContext` of the specified window, or `nil` if an
  *  [error](@ref error_handling) occurred.
  *
- *  @par Thread Safety
- *  This function may be called from any thread.  Access is not synchronized.
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
  *
- *  @par History
- *  Added in GLFW 3.0.
+ *  @since Added in version 3.0.
  *
  *  @ingroup native
  */
@@ -228,11 +234,10 @@ GLFWAPI id glfwGetNSGLContext(GLFWwindow* window);
  *  @return The `Display` used by GLFW, or `NULL` if an
  *  [error](@ref error_handling) occurred.
  *
- *  @par Thread Safety
- *  This function may be called from any thread.  Access is not synchronized.
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
  *
- *  @par History
- *  Added in GLFW 3.0.
+ *  @since Added in version 3.0.
  *
  *  @ingroup native
  */
@@ -243,11 +248,10 @@ GLFWAPI Display* glfwGetX11Display(void);
  *  @return The `RRCrtc` of the specified monitor, or `None` if an
  *  [error](@ref error_handling) occurred.
  *
- *  @par Thread Safety
- *  This function may be called from any thread.  Access is not synchronized.
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
  *
- *  @par History
- *  Added in GLFW 3.1.
+ *  @since Added in version 3.1.
  *
  *  @ingroup native
  */
@@ -258,11 +262,10 @@ GLFWAPI RRCrtc glfwGetX11Adapter(GLFWmonitor* monitor);
  *  @return The `RROutput` of the specified monitor, or `None` if an
  *  [error](@ref error_handling) occurred.
  *
- *  @par Thread Safety
- *  This function may be called from any thread.  Access is not synchronized.
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
  *
- *  @par History
- *  Added in GLFW 3.1.
+ *  @since Added in version 3.1.
  *
  *  @ingroup native
  */
@@ -273,11 +276,10 @@ GLFWAPI RROutput glfwGetX11Monitor(GLFWmonitor* monitor);
  *  @return The `Window` of the specified window, or `None` if an
  *  [error](@ref error_handling) occurred.
  *
- *  @par Thread Safety
- *  This function may be called from any thread.  Access is not synchronized.
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
  *
- *  @par History
- *  Added in GLFW 3.0.
+ *  @since Added in version 3.0.
  *
  *  @ingroup native
  */
@@ -290,15 +292,116 @@ GLFWAPI Window glfwGetX11Window(GLFWwindow* window);
  *  @return The `GLXContext` of the specified window, or `NULL` if an
  *  [error](@ref error_handling) occurred.
  *
- *  @par Thread Safety
- *  This function may be called from any thread.  Access is not synchronized.
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
  *
- *  @par History
- *  Added in GLFW 3.0.
+ *  @since Added in version 3.0.
  *
  *  @ingroup native
  */
 GLFWAPI GLXContext glfwGetGLXContext(GLFWwindow* window);
+
+/*! @brief Returns the `GLXWindow` of the specified window.
+ *
+ *  @return The `GLXWindow` of the specified window, or `None` 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.2.
+ *
+ *  @ingroup native
+ */
+GLFWAPI GLXWindow glfwGetGLXWindow(GLFWwindow* window);
+#endif
+
+#if defined(GLFW_EXPOSE_NATIVE_WAYLAND)
+/*! @brief Returns the `struct wl_display*` used by GLFW.
+ *
+ *  @return The `struct wl_display*` used by GLFW, 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.2.
+ *
+ *  @ingroup native
+ */
+GLFWAPI struct wl_display* glfwGetWaylandDisplay(void);
+
+/*! @brief Returns the `struct wl_output*` of the specified monitor.
+ *
+ *  @return The `struct wl_output*` of the specified monitor, 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.2.
+ *
+ *  @ingroup native
+ */
+GLFWAPI struct wl_output* glfwGetWaylandMonitor(GLFWmonitor* monitor);
+
+/*! @brief Returns the main `struct wl_surface*` of the specified window.
+ *
+ *  @return The main `struct wl_surface*` 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.2.
+ *
+ *  @ingroup native
+ */
+GLFWAPI struct wl_surface* glfwGetWaylandWindow(GLFWwindow* window);
+#endif
+
+#if defined(GLFW_EXPOSE_NATIVE_MIR)
+/*! @brief Returns the `MirConnection*` used by GLFW.
+ *
+ *  @return The `MirConnection*` used by GLFW, 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.2.
+ *
+ *  @ingroup native
+ */
+GLFWAPI MirConnection* glfwGetMirDisplay(void);
+
+/*! @brief Returns the Mir output ID of the specified monitor.
+ *
+ *  @return The Mir output ID of the specified monitor, or zero 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.2.
+ *
+ *  @ingroup native
+ */
+GLFWAPI int glfwGetMirMonitor(GLFWmonitor* monitor);
+
+/*! @brief Returns the `MirSurface*` of the specified window.
+ *
+ *  @return The `MirSurface*` 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.2.
+ *
+ *  @ingroup native
+ */
+GLFWAPI MirSurface* glfwGetMirWindow(GLFWwindow* window);
 #endif
 
 #if defined(GLFW_EXPOSE_NATIVE_EGL)
@@ -307,11 +410,10 @@ GLFWAPI GLXContext glfwGetGLXContext(GLFWwindow* window);
  *  @return The `EGLDisplay` used by GLFW, or `EGL_NO_DISPLAY` if an
  *  [error](@ref error_handling) occurred.
  *
- *  @par Thread Safety
- *  This function may be called from any thread.  Access is not synchronized.
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
  *
- *  @par History
- *  Added in GLFW 3.0.
+ *  @since Added in version 3.0.
  *
  *  @ingroup native
  */
@@ -322,11 +424,10 @@ GLFWAPI EGLDisplay glfwGetEGLDisplay(void);
  *  @return The `EGLContext` of the specified window, or `EGL_NO_CONTEXT` if an
  *  [error](@ref error_handling) occurred.
  *
- *  @par Thread Safety
- *  This function may be called from any thread.  Access is not synchronized.
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
  *
- *  @par History
- *  Added in GLFW 3.0.
+ *  @since Added in version 3.0.
  *
  *  @ingroup native
  */
@@ -337,11 +438,10 @@ GLFWAPI EGLContext glfwGetEGLContext(GLFWwindow* window);
  *  @return The `EGLSurface` of the specified window, or `EGL_NO_SURFACE` if an
  *  [error](@ref error_handling) occurred.
  *
- *  @par Thread Safety
- *  This function may be called from any thread.  Access is not synchronized.
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
  *
- *  @par History
- *  Added in GLFW 3.0.
+ *  @since Added in version 3.0.
  *
  *  @ingroup native
  */

src/CMakeLists.txt

@@ -1,55 +1,50 @@
 
-include_directories("${GLFW_SOURCE_DIR}/src"
-                    "${GLFW_BINARY_DIR}/src"
-                    ${glfw_INCLUDE_DIRS})
-
-add_definitions(-D_GLFW_USE_CONFIG_H)
-
 set(common_HEADERS internal.h
                    "${GLFW_BINARY_DIR}/src/glfw_config.h"
                    "${GLFW_SOURCE_DIR}/include/GLFW/glfw3.h"
                    "${GLFW_SOURCE_DIR}/include/GLFW/glfw3native.h")
-set(common_SOURCES context.c init.c input.c monitor.c window.c)
+set(common_SOURCES context.c init.c input.c monitor.c vulkan.c window.c)
 
 if (_GLFW_COCOA)
-    set(glfw_HEADERS ${common_HEADERS} cocoa_platform.h iokit_joystick.h
-                     posix_tls.h)
-    set(glfw_SOURCES ${common_SOURCES} cocoa_init.m cocoa_monitor.m
-                     cocoa_window.m iokit_joystick.m mach_time.c posix_tls.c)
+    set(glfw_HEADERS ${common_HEADERS} cocoa_platform.h cocoa_joystick.h
+                     posix_tls.h nsgl_context.h)
+    set(glfw_SOURCES ${common_SOURCES} cocoa_init.m cocoa_joystick.m
+                     cocoa_monitor.m cocoa_window.m cocoa_time.c posix_tls.c
+                     nsgl_context.m)
 elseif (_GLFW_WIN32)
-    set(glfw_HEADERS ${common_HEADERS} win32_platform.h win32_tls.h
-                     winmm_joystick.h)
-    set(glfw_SOURCES ${common_SOURCES} win32_init.c win32_monitor.c win32_time.c
-                     win32_tls.c win32_window.c winmm_joystick.c)
+    set(glfw_HEADERS ${common_HEADERS} win32_platform.h win32_joystick.h
+                     wgl_context.h egl_context.h)
+    set(glfw_SOURCES ${common_SOURCES} win32_init.c win32_joystick.c
+                     win32_monitor.c win32_time.c win32_tls.c win32_window.c
+                     wgl_context.c egl_context.c)
 elseif (_GLFW_X11)
     set(glfw_HEADERS ${common_HEADERS} x11_platform.h xkb_unicode.h
-                     linux_joystick.h posix_time.h posix_tls.h)
+                     linux_joystick.h posix_time.h posix_tls.h glx_context.h
+                     egl_context.h)
     set(glfw_SOURCES ${common_SOURCES} x11_init.c x11_monitor.c x11_window.c
-                     xkb_unicode.c linux_joystick.c posix_time.c posix_tls.c)
+                     xkb_unicode.c linux_joystick.c posix_time.c posix_tls.c
+                     glx_context.c egl_context.c)
 elseif (_GLFW_WAYLAND)
     set(glfw_HEADERS ${common_HEADERS} wl_platform.h linux_joystick.h
-                     posix_time.h posix_tls.h xkb_unicode.h)
+                     posix_time.h posix_tls.h xkb_unicode.h egl_context.h)
     set(glfw_SOURCES ${common_SOURCES} wl_init.c wl_monitor.c wl_window.c
-                     linux_joystick.c posix_time.c posix_tls.c xkb_unicode.c)
+                     linux_joystick.c posix_time.c posix_tls.c xkb_unicode.c
+                     egl_context.c)
+
+    ecm_add_wayland_client_protocol(glfw_SOURCES
+        PROTOCOL
+        ${WAYLAND_PROTOCOLS_PKGDATADIR}/unstable/relative-pointer/relative-pointer-unstable-v1.xml
+        BASENAME relative-pointer-unstable-v1)
+    ecm_add_wayland_client_protocol(glfw_SOURCES
+        PROTOCOL
+        ${WAYLAND_PROTOCOLS_PKGDATADIR}/unstable/pointer-constraints/pointer-constraints-unstable-v1.xml
+        BASENAME pointer-constraints-unstable-v1)
 elseif (_GLFW_MIR)
     set(glfw_HEADERS ${common_HEADERS} mir_platform.h linux_joystick.h
-                     posix_time.h posix_tls.h xkb_unicode.h)
+                     posix_time.h posix_tls.h xkb_unicode.h egl_context.h)
     set(glfw_SOURCES ${common_SOURCES} mir_init.c mir_monitor.c mir_window.c
-                     linux_joystick.c posix_time.c posix_tls.c xkb_unicode.c)
-endif()
-
-if (_GLFW_EGL)
-    list(APPEND glfw_HEADERS ${common_HEADERS} egl_context.h)
-    list(APPEND glfw_SOURCES ${common_SOURCES} egl_context.c)
-elseif (_GLFW_NSGL)
-    list(APPEND glfw_HEADERS ${common_HEADERS} nsgl_context.h)
-    list(APPEND glfw_SOURCES ${common_SOURCES} nsgl_context.m)
-elseif (_GLFW_WGL)
-    list(APPEND glfw_HEADERS ${common_HEADERS} wgl_context.h)
-    list(APPEND glfw_SOURCES ${common_SOURCES} wgl_context.c)
-elseif (_GLFW_X11)
-    list(APPEND glfw_HEADERS ${common_HEADERS} glx_context.h)
-    list(APPEND glfw_SOURCES ${common_SOURCES} glx_context.c)
+                     linux_joystick.c posix_time.c posix_tls.c xkb_unicode.c
+                     egl_context.c)
 endif()
 
 if (APPLE)
@@ -59,35 +54,64 @@ endif()
 
 add_library(glfw ${glfw_SOURCES} ${glfw_HEADERS})
 set_target_properties(glfw PROPERTIES
-                      OUTPUT_NAME "${GLFW_LIB_NAME}"
+                      OUTPUT_NAME ${GLFW_LIB_NAME}
                       VERSION ${GLFW_VERSION}
                       SOVERSION ${GLFW_VERSION_MAJOR}
                       POSITION_INDEPENDENT_CODE ON
                       FOLDER "GLFW3")
 
+target_compile_definitions(glfw PRIVATE -D_GLFW_USE_CONFIG_H)
+target_include_directories(glfw PUBLIC
+                           $<BUILD_INTERFACE:${GLFW_SOURCE_DIR}/include>
+                           $<INSTALL_INTERFACE:$<INSTALL_PREFIX>/include>)
+target_include_directories(glfw PRIVATE
+                           "${GLFW_SOURCE_DIR}/src"
+                           "${GLFW_BINARY_DIR}/src"
+                           ${glfw_INCLUDE_DIRS})
+
+# HACK: When building on MinGW, WINVER and UNICODE need to be defined before
+# the inclusion of stddef.h (by glfw3.h), which is itself included before
+# win32_platform.h.  We define them here until a saner solution can be found
+# NOTE: MinGW-w64 and Visual C++ do /not/ need this hack.
+target_compile_definitions(glfw PRIVATE
+                           "$<$<BOOL:${MINGW}>:UNICODE;WINVER=0x0501>")
+
+# Enable a reasonable set of warnings (no, -Wextra is not reasonable)
+target_compile_options(glfw PRIVATE
+                       "$<$<C_COMPILER_ID:Clang>:-Wall>"
+                       "$<$<C_COMPILER_ID:GNU>:-Wall>")
+
 if (BUILD_SHARED_LIBS)
     if (WIN32)
-        # The GLFW DLL needs a special compile-time macro and import library name
-        set_target_properties(glfw PROPERTIES PREFIX "" IMPORT_PREFIX "")
-
         if (MINGW)
+            # Remove the lib prefix on the DLL (but not the import library
+            set_target_properties(glfw PROPERTIES PREFIX "")
+
+            # Add a suffix to the import library to avoid naming conflicts
             set_target_properties(glfw PROPERTIES IMPORT_SUFFIX "dll.a")
         else()
+            # Add a suffix to the import library to avoid naming conflicts
             set_target_properties(glfw PROPERTIES IMPORT_SUFFIX "dll.lib")
         endif()
     elseif (APPLE)
-        # Append -fno-common to the compile flags to work around a bug in
-        # Apple's GCC
-        get_target_property(glfw_CFLAGS glfw COMPILE_FLAGS)
-        if (NOT glfw_CFLAGS)
-            set(glfw_CFLAGS "")
-        endif()
+        # Add -fno-common to work around a bug in Apple's GCC
+        target_compile_options(glfw PRIVATE "-fno-common")
+
         set_target_properties(glfw PROPERTIES
-                              COMPILE_FLAGS "${glfw_CFLAGS} -fno-common"
-                              INSTALL_NAME_DIR "${CMAKE_INSTALL_PREFIX}/lib${LIB_SUFFIX}")
+                              INSTALL_NAME_DIR "lib${LIB_SUFFIX}")
+    elseif (UNIX)
+        # Hide symbols not explicitly tagged for export from the shared library
+        target_compile_options(glfw PRIVATE "-fvisibility=hidden")
     endif()
 
-    target_link_libraries(glfw ${glfw_LIBRARIES})
+    target_compile_definitions(glfw INTERFACE -DGLFW_DLL)
+    target_link_libraries(glfw PRIVATE ${glfw_LIBRARIES})
+else()
+    target_link_libraries(glfw INTERFACE ${glfw_LIBRARIES})
+endif()
+
+if (MSVC)
+    target_compile_definitions(glfw PRIVATE _CRT_SECURE_NO_WARNINGS)
 endif()
 
 if (GLFW_INSTALL)

src/cocoa_init.m

@@ -1,7 +1,7 @@
 //========================================================================
-// GLFW 3.1 OS X - www.glfw.org
+// GLFW 3.2 OS X - www.glfw.org
 //------------------------------------------------------------------------
-// Copyright (c) 2009-2010 Camilla Berglund <elmindreda@elmindreda.org>
+// Copyright (c) 2009-2016 Camilla Berglund <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
@@ -72,7 +72,10 @@ static void changeToResourcesDirectory(void)
 //
 static void createKeyTables(void)
 {
+    int scancode;
+
     memset(_glfw.ns.publicKeys, -1, sizeof(_glfw.ns.publicKeys));
+    memset(_glfw.ns.nativeKeys, -1, sizeof(_glfw.ns.nativeKeys));
 
     _glfw.ns.publicKeys[0x1D] = GLFW_KEY_0;
     _glfw.ns.publicKeys[0x12] = GLFW_KEY_1;
@@ -188,8 +191,106 @@ static void createKeyTables(void)
     _glfw.ns.publicKeys[0x51] = GLFW_KEY_KP_EQUAL;
     _glfw.ns.publicKeys[0x43] = GLFW_KEY_KP_MULTIPLY;
     _glfw.ns.publicKeys[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)
+            _glfw.ns.nativeKeys[_glfw.ns.publicKeys[scancode]] = scancode;
+    }
 }
 
+// Retrieve Unicode data for the current keyboard layout
+//
+static GLFWbool updateUnicodeDataNS(void)
+{
+    if (_glfw.ns.inputSource)
+    {
+        CFRelease(_glfw.ns.inputSource);
+        _glfw.ns.inputSource = NULL;
+        _glfw.ns.unicodeData = nil;
+    }
+
+    _glfw.ns.inputSource = TISCopyCurrentKeyboardLayoutInputSource();
+    if (!_glfw.ns.inputSource)
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "Cocoa: Failed to retrieve keyboard layout input source");
+        return GLFW_FALSE;
+    }
+
+    _glfw.ns.unicodeData = TISGetInputSourceProperty(_glfw.ns.inputSource,
+                                                     kTISPropertyUnicodeKeyLayoutData);
+    if (!_glfw.ns.unicodeData)
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "Cocoa: Failed to retrieve keyboard layout Unicode data");
+        return GLFW_FALSE;
+    }
+
+    return GLFW_TRUE;
+}
+
+// Load HIToolbox.framework and the TIS symbols we need from it
+//
+static GLFWbool initializeTIS(void)
+{
+    // This works only because Cocoa has already loaded it properly
+    _glfw.ns.tis.bundle = CFBundleGetBundleWithIdentifier(CFSTR("com.apple.HIToolbox"));
+    if (!_glfw.ns.tis.bundle)
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "Cocoa: Failed to load HIToolbox.framework");
+        return GLFW_FALSE;
+    }
+
+    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"));
+    _glfw.ns.tis.GetInputSourceProperty =
+        CFBundleGetFunctionPointerForName(_glfw.ns.tis.bundle,
+                                          CFSTR("TISGetInputSourceProperty"));
+    _glfw.ns.tis.GetKbdType =
+        CFBundleGetFunctionPointerForName(_glfw.ns.tis.bundle,
+                                          CFSTR("LMGetKbdType"));
+
+    if (!kPropertyUnicodeKeyLayoutData ||
+        !kNotifySelectedKeyboardInputSourceChanged ||
+        !TISCopyCurrentKeyboardLayoutInputSource ||
+        !TISGetInputSourceProperty ||
+        !LMGetKbdType)
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "Cocoa: Failed to load TIS API symbols");
+        return GLFW_FALSE;
+    }
+
+    _glfw.ns.tis.kPropertyUnicodeKeyLayoutData =
+        *kPropertyUnicodeKeyLayoutData;
+    _glfw.ns.tis.kNotifySelectedKeyboardInputSourceChanged =
+        *kNotifySelectedKeyboardInputSourceChanged;
+
+    return updateUnicodeDataNS();
+}
+
+@interface GLFWLayoutListener : NSObject
+@end
+
+@implementation GLFWLayoutListener
+
+- (void)selectedKeyboardInputSourceChanged:(NSObject* )object
+{
+    updateUnicodeDataNS();
+}
+
+@end
+
 
 //////////////////////////////////////////////////////////////////////////
 //////                       GLFW platform API                      //////
@@ -199,6 +300,13 @@ int _glfwPlatformInit(void)
 {
     _glfw.ns.autoreleasePool = [[NSAutoreleasePool alloc] init];
 
+    _glfw.ns.listener = [[GLFWLayoutListener alloc] init];
+    [[NSDistributedNotificationCenter defaultCenter]
+        addObserver:_glfw.ns.listener
+           selector:@selector(selectedKeyboardInputSourceChanged:)
+               name:(__bridge NSString*)kTISNotifySelectedKeyboardInputSourceChanged
+             object:nil];
+
 #if defined(_GLFW_USE_CHDIR)
     changeToResourcesDirectory();
 #endif
@@ -207,21 +315,34 @@ int _glfwPlatformInit(void)
 
     _glfw.ns.eventSource = CGEventSourceCreate(kCGEventSourceStateHIDSystemState);
     if (!_glfw.ns.eventSource)
-        return GL_FALSE;
+        return GLFW_FALSE;
 
     CGEventSourceSetLocalEventsSuppressionInterval(_glfw.ns.eventSource, 0.0);
 
-    if (!_glfwInitContextAPI())
-        return GL_FALSE;
+    if (!initializeTIS())
+        return GLFW_FALSE;
 
-    _glfwInitTimer();
-    _glfwInitJoysticks();
+    if (!_glfwInitThreadLocalStoragePOSIX())
+        return GLFW_FALSE;
 
-    return GL_TRUE;
+    if (!_glfwInitNSGL())
+        return GLFW_FALSE;
+
+    _glfwInitTimerNS();
+    _glfwInitJoysticksNS();
+
+    return GLFW_TRUE;
 }
 
 void _glfwPlatformTerminate(void)
 {
+    if (_glfw.ns.inputSource)
+    {
+        CFRelease(_glfw.ns.inputSource);
+        _glfw.ns.inputSource = NULL;
+        _glfw.ns.unicodeData = nil;
+    }
+
     if (_glfw.ns.eventSource)
     {
         CFRelease(_glfw.ns.eventSource);
@@ -235,24 +356,32 @@ void _glfwPlatformTerminate(void)
         _glfw.ns.delegate = nil;
     }
 
-    [_glfw.ns.autoreleasePool release];
-    _glfw.ns.autoreleasePool = nil;
+    if (_glfw.ns.listener)
+    {
+        [[NSDistributedNotificationCenter defaultCenter]
+            removeObserver:_glfw.ns.listener
+                      name:(__bridge NSString*)kTISNotifySelectedKeyboardInputSourceChanged
+                    object:nil];
+        [_glfw.ns.listener release];
+        _glfw.ns.listener = nil;
+    }
 
     [_glfw.ns.cursor release];
     _glfw.ns.cursor = nil;
 
     free(_glfw.ns.clipboardString);
 
-    _glfwTerminateJoysticks();
-    _glfwTerminateContextAPI();
+    _glfwTerminateNSGL();
+    _glfwTerminateJoysticksNS();
+    _glfwTerminateThreadLocalStoragePOSIX();
+
+    [_glfw.ns.autoreleasePool release];
+    _glfw.ns.autoreleasePool = nil;
 }
 
 const char* _glfwPlatformGetVersionString(void)
 {
-    return _GLFW_VERSION_NUMBER " Cocoa"
-#if defined(_GLFW_NSGL)
-        " NSGL"
-#endif
+    return _GLFW_VERSION_NUMBER " Cocoa NSGL"
 #if defined(_GLFW_USE_CHDIR)
         " chdir"
 #endif

src/cocoa_joystick.h

@@ -1,7 +1,7 @@
 //========================================================================
-// GLFW 3.1 IOKit - www.glfw.org
+// GLFW 3.2 Cocoa - www.glfw.org
 //------------------------------------------------------------------------
-// Copyright (c) 2006-2014 Camilla Berglund <elmindreda@elmindreda.org>
+// Copyright (c) 2006-2016 Camilla Berglund <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,23 +24,22 @@
 //
 //========================================================================
 
-#ifndef _glfw3_iokit_joystick_h_
-#define _glfw3_iokit_joystick_h_
+#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 \
-    _GLFWjoystickIOKit iokit_js
+#define _GLFW_PLATFORM_LIBRARY_JOYSTICK_STATE _GLFWjoystickNS ns_js
 
 
-// IOKit-specific per-joystick data
+// Cocoa-specific per-joystick data
 //
-typedef struct _GLFWjoydevice
+typedef struct _GLFWjoydeviceNS
 {
-    int             present;
+    GLFWbool        present;
     char            name[256];
 
     IOHIDDeviceRef deviceRef;
@@ -51,18 +50,18 @@ typedef struct _GLFWjoydevice
 
     float*          axes;
     unsigned char*  buttons;
-} _GLFWjoydevice;
+} _GLFWjoydeviceNS;
 
-// IOKit-specific joystick API data
+// Cocoa-specific joystick API data
 //
-typedef struct _GLFWjoystickIOKit
+typedef struct _GLFWjoystickNS
 {
-    _GLFWjoydevice devices[GLFW_JOYSTICK_LAST + 1];
+    _GLFWjoydeviceNS js[GLFW_JOYSTICK_LAST + 1];
 
     IOHIDManagerRef managerRef;
-} _GLFWjoystickIOKit;
+} _GLFWjoystickNS;
 
-void _glfwInitJoysticks(void);
-void _glfwTerminateJoysticks(void);
+void _glfwInitJoysticksNS(void);
+void _glfwTerminateJoysticksNS(void);
 
-#endif // _glfw3_iokit_joystick_h_
+#endif // _glfw3_cocoa_joystick_h_

src/cocoa_joystick.m

@@ -1,7 +1,7 @@
 //========================================================================
-// GLFW 3.1 IOKit - www.glfw.org
+// GLFW 3.2 Cocoa - www.glfw.org
 //------------------------------------------------------------------------
-// Copyright (c) 2009-2010 Camilla Berglund <elmindreda@elmindreda.org>
+// Copyright (c) 2009-2016 Camilla Berglund <elmindreda@glfw.org>
 // Copyright (c) 2012 Torsten Walluhn <tw@mad-cad.net>
 //
 // This software is provided 'as-is', without any express or implied
@@ -29,6 +29,7 @@
 
 #include <unistd.h>
 #include <ctype.h>
+#include <string.h>
 
 #include <mach/mach.h>
 #include <mach/mach_error.h>
@@ -37,10 +38,9 @@
 #include <Kernel/IOKit/hidsystem/IOHIDUsageTables.h>
 
 
-//------------------------------------------------------------------------
 // Joystick element information
-//------------------------------------------------------------------------
-typedef struct
+//
+typedef struct _GLFWjoyelementNS
 {
     IOHIDElementRef elementRef;
 
@@ -50,14 +50,14 @@ typedef struct
     long minReport;
     long maxReport;
 
-} _GLFWjoyelement;
+} _GLFWjoyelementNS;
 
 
 static void getElementsCFArrayHandler(const void* value, void* parameter);
 
 // Adds an element to the specified joystick
 //
-static void addJoystickElement(_GLFWjoydevice* joystick,
+static void addJoystickElement(_GLFWjoydeviceNS* js,
                                IOHIDElementRef elementRef)
 {
     IOHIDElementType elementType;
@@ -90,10 +90,10 @@ static void addJoystickElement(_GLFWjoydevice* joystick,
                 case kHIDUsage_GD_Slider:
                 case kHIDUsage_GD_Dial:
                 case kHIDUsage_GD_Wheel:
-                    elementsArray = joystick->axisElements;
+                    elementsArray = js->axisElements;
                     break;
                 case kHIDUsage_GD_Hatswitch:
-                    elementsArray = joystick->hatElements;
+                    elementsArray = js->hatElements;
                     break;
             }
 
@@ -101,7 +101,7 @@ static void addJoystickElement(_GLFWjoydevice* joystick,
         }
 
         case kHIDPage_Button:
-            elementsArray = joystick->buttonElements;
+            elementsArray = js->buttonElements;
             break;
         default:
             break;
@@ -109,7 +109,7 @@ static void addJoystickElement(_GLFWjoydevice* joystick,
 
     if (elementsArray)
     {
-        _GLFWjoyelement* element = calloc(1, sizeof(_GLFWjoyelement));
+        _GLFWjoyelementNS* element = calloc(1, sizeof(_GLFWjoyelementNS));
 
         CFArrayAppendValue(elementsArray, element);
 
@@ -126,22 +126,22 @@ static void getElementsCFArrayHandler(const void* value, void* parameter)
 {
     if (CFGetTypeID(value) == IOHIDElementGetTypeID())
     {
-        addJoystickElement((_GLFWjoydevice*) parameter,
+        addJoystickElement((_GLFWjoydeviceNS*) parameter,
                            (IOHIDElementRef) value);
     }
 }
 
 // Returns the value of the specified element of the specified joystick
 //
-static long getElementValue(_GLFWjoydevice* joystick, _GLFWjoyelement* element)
+static long getElementValue(_GLFWjoydeviceNS* js, _GLFWjoyelementNS* element)
 {
     IOReturn result = kIOReturnSuccess;
     IOHIDValueRef valueRef;
     long value = 0;
 
-    if (joystick && element && joystick->deviceRef)
+    if (js && element && js->deviceRef)
     {
-        result = IOHIDDeviceGetValue(joystick->deviceRef,
+        result = IOHIDDeviceGetValue(js->deviceRef,
                                      element->elementRef,
                                      &valueRef);
 
@@ -163,95 +163,105 @@ static long getElementValue(_GLFWjoydevice* joystick, _GLFWjoyelement* element)
 
 // Removes the specified joystick
 //
-static void removeJoystick(_GLFWjoydevice* joystick)
+static void removeJoystick(_GLFWjoydeviceNS* js)
 {
     int i;
 
-    if (!joystick->present)
+    if (!js->present)
         return;
 
-    for (i = 0;  i < CFArrayGetCount(joystick->axisElements);  i++)
-        free((void*) CFArrayGetValueAtIndex(joystick->axisElements, i));
-    CFArrayRemoveAllValues(joystick->axisElements);
-    CFRelease(joystick->axisElements);
+    for (i = 0;  i < CFArrayGetCount(js->axisElements);  i++)
+        free((void*) CFArrayGetValueAtIndex(js->axisElements, i));
+    CFArrayRemoveAllValues(js->axisElements);
+    CFRelease(js->axisElements);
 
-    for (i = 0;  i < CFArrayGetCount(joystick->buttonElements);  i++)
-        free((void*) CFArrayGetValueAtIndex(joystick->buttonElements, i));
-    CFArrayRemoveAllValues(joystick->buttonElements);
-    CFRelease(joystick->buttonElements);
+    for (i = 0;  i < CFArrayGetCount(js->buttonElements);  i++)
+        free((void*) CFArrayGetValueAtIndex(js->buttonElements, i));
+    CFArrayRemoveAllValues(js->buttonElements);
+    CFRelease(js->buttonElements);
 
-    for (i = 0;  i < CFArrayGetCount(joystick->hatElements);  i++)
-        free((void*) CFArrayGetValueAtIndex(joystick->hatElements, i));
-    CFArrayRemoveAllValues(joystick->hatElements);
-    CFRelease(joystick->hatElements);
+    for (i = 0;  i < CFArrayGetCount(js->hatElements);  i++)
+        free((void*) CFArrayGetValueAtIndex(js->hatElements, i));
+    CFArrayRemoveAllValues(js->hatElements);
+    CFRelease(js->hatElements);
 
-    free(joystick->axes);
-    free(joystick->buttons);
+    free(js->axes);
+    free(js->buttons);
 
-    memset(joystick, 0, sizeof(_GLFWjoydevice));
+    memset(js, 0, sizeof(_GLFWjoydeviceNS));
+
+    _glfwInputJoystickChange(js - _glfw.ns_js.js, GLFW_DISCONNECTED);
 }
 
-// Polls for joystick events and updates GLFW state
+// Polls for joystick axis events and updates GLFW state
 //
-static void pollJoystickEvents(void)
+static GLFWbool pollJoystickAxisEvents(_GLFWjoydeviceNS* js)
 {
-    int joy;
+    CFIndex i;
 
-    for (joy = 0;  joy <= GLFW_JOYSTICK_LAST;  joy++)
+    if (!js->present)
+        return GLFW_FALSE;
+
+    for (i = 0;  i < CFArrayGetCount(js->axisElements);  i++)
     {
-        CFIndex i;
-        int buttonIndex = 0;
-        _GLFWjoydevice* joystick = _glfw.iokit_js.devices + joy;
+        _GLFWjoyelementNS* axis = (_GLFWjoyelementNS*)
+            CFArrayGetValueAtIndex(js->axisElements, i);
 
-        if (!joystick->present)
-            continue;
+        long value = getElementValue(js, axis);
+        long readScale = axis->maxReport - axis->minReport;
 
-        for (i = 0;  i < CFArrayGetCount(joystick->buttonElements);  i++)
+        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(_GLFWjoydeviceNS* 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++)
         {
-            _GLFWjoyelement* button = (_GLFWjoyelement*)
-                CFArrayGetValueAtIndex(joystick->buttonElements, i);
-
-            if (getElementValue(joystick, button))
-                joystick->buttons[buttonIndex++] = GLFW_PRESS;
+            if (directions[value] & (1 << j))
+                js->buttons[buttonIndex++] = GLFW_PRESS;
             else
-                joystick->buttons[buttonIndex++] = GLFW_RELEASE;
-        }
-
-        for (i = 0;  i < CFArrayGetCount(joystick->axisElements);  i++)
-        {
-            _GLFWjoyelement* axis = (_GLFWjoyelement*)
-                CFArrayGetValueAtIndex(joystick->axisElements, i);
-
-            long value = getElementValue(joystick, axis);
-            long readScale = axis->maxReport - axis->minReport;
-
-            if (readScale == 0)
-                joystick->axes[i] = value;
-            else
-                joystick->axes[i] = (2.f * (value - axis->minReport) / readScale) - 1.f;
-        }
-
-        for (i = 0;  i < CFArrayGetCount(joystick->hatElements);  i++)
-        {
-            _GLFWjoyelement* hat = (_GLFWjoyelement*)
-                CFArrayGetValueAtIndex(joystick->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(joystick, hat);
-            if (value < 0 || value > 8)
-                value = 8;
-
-            for (j = 0;  j < 4;  j++)
-            {
-                if (directions[value] & (1 << j))
-                    joystick->buttons[buttonIndex++] = GLFW_PRESS;
-                else
-                    joystick->buttons[buttonIndex++] = GLFW_RELEASE;
-            }
+                js->buttons[buttonIndex++] = GLFW_RELEASE;
         }
     }
+
+    return GLFW_TRUE;
 }
 
 // Callback for user-initiated joystick addition
@@ -261,44 +271,43 @@ static void matchCallback(void* context,
                           void* sender,
                           IOHIDDeviceRef deviceRef)
 {
-    _GLFWjoydevice* joystick;
+    _GLFWjoydeviceNS* js;
     int joy;
 
     for (joy = GLFW_JOYSTICK_1;  joy <= GLFW_JOYSTICK_LAST;  joy++)
     {
-        joystick = _glfw.iokit_js.devices + joy;
-
-        if (!joystick->present)
-            continue;
-
-        if (joystick->deviceRef == deviceRef)
+        if (_glfw.ns_js.js[joy].present && _glfw.ns_js.js[joy].deviceRef == deviceRef)
             return;
     }
 
     for (joy = GLFW_JOYSTICK_1;  joy <= GLFW_JOYSTICK_LAST;  joy++)
     {
-        joystick = _glfw.iokit_js.devices + joy;
-
-        if (!joystick->present)
+        if (!_glfw.ns_js.js[joy].present)
             break;
     }
 
     if (joy > GLFW_JOYSTICK_LAST)
         return;
 
-    joystick->present = GL_TRUE;
-    joystick->deviceRef = deviceRef;
+    js = _glfw.ns_js.js + joy;
+    js->present = GLFW_TRUE;
+    js->deviceRef = deviceRef;
 
     CFStringRef name = IOHIDDeviceGetProperty(deviceRef,
                                               CFSTR(kIOHIDProductKey));
-    CFStringGetCString(name,
-                       joystick->name,
-                       sizeof(joystick->name),
-                       kCFStringEncodingUTF8);
+    if (name)
+    {
+        CFStringGetCString(name,
+                           js->name,
+                           sizeof(js->name),
+                           kCFStringEncodingUTF8);
+    }
+    else
+        strncpy(js->name, "Unknown", sizeof(js->name));
 
-    joystick->axisElements = CFArrayCreateMutable(NULL, 0, NULL);
-    joystick->buttonElements = CFArrayCreateMutable(NULL, 0, NULL);
-    joystick->hatElements = CFArrayCreateMutable(NULL, 0, NULL);
+    js->axisElements = CFArrayCreateMutable(NULL, 0, NULL);
+    js->buttonElements = CFArrayCreateMutable(NULL, 0, NULL);
+    js->hatElements = CFArrayCreateMutable(NULL, 0, NULL);
 
     CFArrayRef arrayRef = IOHIDDeviceCopyMatchingElements(deviceRef,
                                                           NULL,
@@ -307,14 +316,15 @@ static void matchCallback(void* context,
     CFArrayApplyFunction(arrayRef,
                          range,
                          getElementsCFArrayHandler,
-                         (void*) joystick);
+                         (void*) js);
 
     CFRelease(arrayRef);
 
-    joystick->axes = calloc(CFArrayGetCount(joystick->axisElements),
-                            sizeof(float));
-    joystick->buttons = calloc(CFArrayGetCount(joystick->buttonElements) +
-                               CFArrayGetCount(joystick->hatElements) * 4, 1);
+    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
@@ -328,10 +338,9 @@ static void removeCallback(void* context,
 
     for (joy = GLFW_JOYSTICK_1;  joy <= GLFW_JOYSTICK_LAST;  joy++)
     {
-        _GLFWjoydevice* joystick = _glfw.iokit_js.devices + joy;
-        if (joystick->deviceRef == deviceRef)
+        if (_glfw.ns_js.js[joy].deviceRef == deviceRef)
         {
-            removeJoystick(joystick);
+            removeJoystick(_glfw.ns_js.js + joy);
             break;
         }
     }
@@ -384,12 +393,12 @@ static CFMutableDictionaryRef createMatchingDictionary(long usagePage,
 
 // Initialize joystick interface
 //
-void _glfwInitJoysticks(void)
+void _glfwInitJoysticksNS(void)
 {
     CFMutableArrayRef matchingCFArrayRef;
 
-    _glfw.iokit_js.managerRef = IOHIDManagerCreate(kCFAllocatorDefault,
-                                                   kIOHIDOptionsTypeNone);
+    _glfw.ns_js.managerRef = IOHIDManagerCreate(kCFAllocatorDefault,
+                                                kIOHIDOptionsTypeNone);
 
     matchingCFArrayRef = CFArrayCreateMutable(kCFAllocatorDefault,
                                               0,
@@ -422,21 +431,21 @@ void _glfwInitJoysticks(void)
             CFRelease(matchingCFDictRef);
         }
 
-        IOHIDManagerSetDeviceMatchingMultiple(_glfw.iokit_js.managerRef,
+        IOHIDManagerSetDeviceMatchingMultiple(_glfw.ns_js.managerRef,
                                               matchingCFArrayRef);
         CFRelease(matchingCFArrayRef);
     }
 
-    IOHIDManagerRegisterDeviceMatchingCallback(_glfw.iokit_js.managerRef,
+    IOHIDManagerRegisterDeviceMatchingCallback(_glfw.ns_js.managerRef,
                                                &matchCallback, NULL);
-    IOHIDManagerRegisterDeviceRemovalCallback(_glfw.iokit_js.managerRef,
+    IOHIDManagerRegisterDeviceRemovalCallback(_glfw.ns_js.managerRef,
                                               &removeCallback, NULL);
 
-    IOHIDManagerScheduleWithRunLoop(_glfw.iokit_js.managerRef,
+    IOHIDManagerScheduleWithRunLoop(_glfw.ns_js.managerRef,
                                     CFRunLoopGetMain(),
                                     kCFRunLoopDefaultMode);
 
-    IOHIDManagerOpen(_glfw.iokit_js.managerRef, kIOHIDOptionsTypeNone);
+    IOHIDManagerOpen(_glfw.ns_js.managerRef, kIOHIDOptionsTypeNone);
 
     // Execute the run loop once in order to register any initially-attached
     // joysticks
@@ -445,18 +454,18 @@ void _glfwInitJoysticks(void)
 
 // Close all opened joystick handles
 //
-void _glfwTerminateJoysticks(void)
+void _glfwTerminateJoysticksNS(void)
 {
     int joy;
 
-    for (joy = 0;  joy <= GLFW_JOYSTICK_LAST;  joy++)
+    for (joy = GLFW_JOYSTICK_1;  joy <= GLFW_JOYSTICK_LAST;  joy++)
     {
-        _GLFWjoydevice* joystick = _glfw.iokit_js.devices + joy;
-        removeJoystick(joystick);
+        _GLFWjoydeviceNS* js = _glfw.ns_js.js + joy;
+        removeJoystick(js);
     }
 
-    CFRelease(_glfw.iokit_js.managerRef);
-    _glfw.iokit_js.managerRef = NULL;
+    CFRelease(_glfw.ns_js.managerRef);
+    _glfw.ns_js.managerRef = NULL;
 }
 
 
@@ -466,42 +475,37 @@ void _glfwTerminateJoysticks(void)
 
 int _glfwPlatformJoystickPresent(int joy)
 {
-    pollJoystickEvents();
-
-    return _glfw.iokit_js.devices[joy].present;
+    _GLFWjoydeviceNS* js = _glfw.ns_js.js + joy;
+    return js->present;
 }
 
 const float* _glfwPlatformGetJoystickAxes(int joy, int* count)
 {
-    _GLFWjoydevice* joystick = _glfw.iokit_js.devices + joy;
-
-    pollJoystickEvents();
-
-    if (!joystick->present)
+    _GLFWjoydeviceNS* js = _glfw.ns_js.js + joy;
+    if (!pollJoystickAxisEvents(js))
         return NULL;
 
-    *count = (int) CFArrayGetCount(joystick->axisElements);
-    return joystick->axes;
+    *count = (int) CFArrayGetCount(js->axisElements);
+    return js->axes;
 }
 
 const unsigned char* _glfwPlatformGetJoystickButtons(int joy, int* count)
 {
-    _GLFWjoydevice* joystick = _glfw.iokit_js.devices + joy;
-
-    pollJoystickEvents();
-
-    if (!joystick->present)
+    _GLFWjoydeviceNS* js = _glfw.ns_js.js + joy;
+    if (!pollJoystickButtonEvents(js))
         return NULL;
 
-    *count = (int) CFArrayGetCount(joystick->buttonElements) +
-             (int) CFArrayGetCount(joystick->hatElements) * 4;
-    return joystick->buttons;
+    *count = (int) CFArrayGetCount(js->buttonElements) +
+             (int) CFArrayGetCount(js->hatElements) * 4;
+    return js->buttons;
 }
 
 const char* _glfwPlatformGetJoystickName(int joy)
 {
-    pollJoystickEvents();
+    _GLFWjoydeviceNS* js = _glfw.ns_js.js + joy;
+    if (!js->present)
+        return NULL;
 
-    return _glfw.iokit_js.devices[joy].name;
+    return js->name;
 }
 

src/cocoa_monitor.m

@@ -1,8 +1,8 @@
 //========================================================================
-// GLFW 3.1 OS X - www.glfw.org
+// GLFW 3.2 OS X - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
+// Copyright (c) 2006-2016 Camilla Berglund <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
@@ -76,28 +76,28 @@ static char* getDisplayName(CGDirectDisplayID displayID)
 
 // Check whether the display mode should be included in enumeration
 //
-static GLboolean modeIsGood(CGDisplayModeRef mode)
+static GLFWbool modeIsGood(CGDisplayModeRef mode)
 {
     uint32_t flags = CGDisplayModeGetIOFlags(mode);
     if (!(flags & kDisplayModeValidFlag) || !(flags & kDisplayModeSafeFlag))
-        return GL_FALSE;
+        return GLFW_FALSE;
 
     if (flags & kDisplayModeInterlacedFlag)
-        return GL_FALSE;
+        return GLFW_FALSE;
 
     if (flags & kDisplayModeStretchedFlag)
-        return GL_FALSE;
+        return GLFW_FALSE;
 
     CFStringRef format = CGDisplayModeCopyPixelEncoding(mode);
     if (CFStringCompare(format, CFSTR(IO16BitDirectPixels), 0) &&
         CFStringCompare(format, CFSTR(IO32BitDirectPixels), 0))
     {
         CFRelease(format);
-        return GL_FALSE;
+        return GLFW_FALSE;
     }
 
     CFRelease(format);
-    return GL_TRUE;
+    return GLFW_TRUE;
 }
 
 // Convert Core Graphics display mode to GLFW video mode
@@ -166,7 +166,7 @@ static void endFadeReservation(CGDisplayFadeReservationToken token)
 
 // Change the current video mode
 //
-GLboolean _glfwSetVideoMode(_GLFWmonitor* monitor, const GLFWvidmode* desired)
+GLFWbool _glfwSetVideoModeNS(_GLFWmonitor* monitor, const GLFWvidmode* desired)
 {
     CFArrayRef modes;
     CFIndex count, i;
@@ -178,7 +178,7 @@ GLboolean _glfwSetVideoMode(_GLFWmonitor* monitor, const GLFWvidmode* desired)
     best = _glfwChooseVideoMode(monitor, desired);
     _glfwPlatformGetVideoMode(monitor, &current);
     if (_glfwCompareVideoModes(&current, best) == 0)
-        return GL_TRUE;
+        return GLFW_TRUE;
 
     CVDisplayLinkCreateWithCGDisplay(monitor->ns.displayID, &link);
 
@@ -216,15 +216,15 @@ GLboolean _glfwSetVideoMode(_GLFWmonitor* monitor, const GLFWvidmode* desired)
     {
         _glfwInputError(GLFW_PLATFORM_ERROR,
                         "Cocoa: Monitor mode list changed");
-        return GL_FALSE;
+        return GLFW_FALSE;
     }
 
-    return GL_TRUE;
+    return GLFW_TRUE;
 }
 
 // Restore the previously saved (original) video mode
 //
-void _glfwRestoreVideoMode(_GLFWmonitor* monitor)
+void _glfwRestoreVideoModeNS(_GLFWmonitor* monitor)
 {
     if (monitor->ns.previousMode)
     {
@@ -283,7 +283,7 @@ _GLFWmonitor** _glfwPlatformGetMonitors(int* count)
     return monitors;
 }
 
-GLboolean _glfwPlatformIsSameMonitor(_GLFWmonitor* first, _GLFWmonitor* second)
+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

src/cocoa_platform.h

@@ -1,7 +1,7 @@
 //========================================================================
-// GLFW 3.1 OS X - www.glfw.org
+// GLFW 3.2 OS X - www.glfw.org
 //------------------------------------------------------------------------
-// Copyright (c) 2009-2010 Camilla Berglund <elmindreda@elmindreda.org>
+// Copyright (c) 2009-2016 Camilla Berglund <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,22 +28,24 @@
 #define _glfw3_cocoa_platform_h_
 
 #include <stdint.h>
+#include <dlfcn.h>
 
 #if defined(__OBJC__)
+#import <Carbon/Carbon.h>
 #import <Cocoa/Cocoa.h>
 #else
+#include <Carbon/Carbon.h>
 #include <ApplicationServices/ApplicationServices.h>
 typedef void* id;
 #endif
 
 #include "posix_tls.h"
-#include "iokit_joystick.h"
+#include "cocoa_joystick.h"
+#include "nsgl_context.h"
 
-#if defined(_GLFW_NSGL)
- #include "nsgl_context.h"
-#else
- #error "The Cocoa backend depends on NSGL platform support"
-#endif
+#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_PLATFORM_WINDOW_STATE         _GLFWwindowNS  ns
 #define _GLFW_PLATFORM_LIBRARY_WINDOW_STATE _GLFWlibraryNS ns
@@ -51,6 +53,19 @@ typedef void* id;
 #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);
+#define TISGetInputSourceProperty _glfw.ns.tis.GetInputSourceProperty
+typedef UInt8 (*PFN_LMGetKbdType)(void);
+#define LMGetKbdType _glfw.ns.tis.GetKbdType
+
 
 // Cocoa-specific per-window data
 //
@@ -59,12 +74,11 @@ typedef struct _GLFWwindowNS
     id              object;
     id              delegate;
     id              view;
-    unsigned int    modifierFlags;
 
     // The total sum of the distances the cursor has been warped
     // since the last cursor motion event was processed
     // This is kept to counteract Cocoa doing the same internally
-    double          warpDeltaX, warpDeltaY;
+    double          cursorWarpDeltaX, cursorWarpDeltaY;
 
 } _GLFWwindowNS;
 
@@ -73,13 +87,31 @@ typedef struct _GLFWwindowNS
 //
 typedef struct _GLFWlibraryNS
 {
-    CGEventSourceRef eventSource;
-    id              delegate;
-    id              autoreleasePool;
-    id              cursor;
+    CGEventSourceRef    eventSource;
+    id                  delegate;
+    id                  autoreleasePool;
+    id                  cursor;
+    TISInputSourceRef   inputSource;
+    id                  unicodeData;
+    id                  listener;
 
-    short int       publicKeys[256];
-    char*           clipboardString;
+    char                keyName[64];
+    short int           publicKeys[256];
+    short int           nativeKeys[GLFW_KEY_LAST + 1];
+    char*               clipboardString;
+    // Where to place the cursor when re-enabled
+    double              restoreCursorPosX, restoreCursorPosY;
+    // The window whose disabled cursor mode is active
+    _GLFWwindow*        disabledCursorWindow;
+
+    struct {
+        CFBundleRef     bundle;
+        PFN_TISCopyCurrentKeyboardLayoutInputSource CopyCurrentKeyboardLayoutInputSource;
+        PFN_TISGetInputSourceProperty GetInputSourceProperty;
+        PFN_LMGetKbdType GetKbdType;
+        CFStringRef     kPropertyUnicodeKeyLayoutData;
+        CFStringRef     kNotifySelectedKeyboardInputSourceChanged;
+    } tis;
 
 } _GLFWlibraryNS;
 
@@ -108,15 +140,14 @@ typedef struct _GLFWcursorNS
 //
 typedef struct _GLFWtimeNS
 {
-    double          base;
-    double          resolution;
+    uint64_t        frequency;
 
 } _GLFWtimeNS;
 
 
-void _glfwInitTimer(void);
+void _glfwInitTimerNS(void);
 
-GLboolean _glfwSetVideoMode(_GLFWmonitor* monitor, const GLFWvidmode* desired);
-void _glfwRestoreVideoMode(_GLFWmonitor* monitor);
+GLFWbool _glfwSetVideoModeNS(_GLFWmonitor* monitor, const GLFWvidmode* desired);
+void _glfwRestoreVideoModeNS(_GLFWmonitor* monitor);
 
 #endif // _glfw3_cocoa_platform_h_

src/cocoa_time.c

@@ -1,7 +1,7 @@
 //========================================================================
-// GLFW 3.1 OS X - www.glfw.org
+// GLFW 3.2 OS X - www.glfw.org
 //------------------------------------------------------------------------
-// Copyright (c) 2009-2010 Camilla Berglund <elmindreda@elmindreda.org>
+// Copyright (c) 2009-2016 Camilla Berglund <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,27 +29,18 @@
 #include <mach/mach_time.h>
 
 
-// Return raw time
-//
-static uint64_t getRawTime(void)
-{
-    return mach_absolute_time();
-}
-
-
 //////////////////////////////////////////////////////////////////////////
 //////                       GLFW internal API                      //////
 //////////////////////////////////////////////////////////////////////////
 
 // Initialise timer
 //
-void _glfwInitTimer(void)
+void _glfwInitTimerNS(void)
 {
     mach_timebase_info_data_t info;
     mach_timebase_info(&info);
 
-    _glfw.ns_time.resolution = (double) info.numer / (info.denom * 1.0e9);
-    _glfw.ns_time.base = getRawTime();
+    _glfw.ns_time.frequency = (info.denom * 1e9) / info.numer;
 }
 
 
@@ -57,15 +48,13 @@ void _glfwInitTimer(void)
 //////                       GLFW platform API                      //////
 //////////////////////////////////////////////////////////////////////////
 
-double _glfwPlatformGetTime(void)
+uint64_t _glfwPlatformGetTimerValue(void)
 {
-    return (double) (getRawTime() - _glfw.ns_time.base) *
-        _glfw.ns_time.resolution;
+    return mach_absolute_time();
 }
 
-void _glfwPlatformSetTime(double time)
+uint64_t _glfwPlatformGetTimerFrequency(void)
 {
-    _glfw.ns_time.base = getRawTime() -
-        (uint64_t) (time / _glfw.ns_time.resolution);
+    return _glfw.ns_time.frequency;
 }
 

src/context.c

@@ -1,8 +1,8 @@
 //========================================================================
-// GLFW 3.1 - www.glfw.org
+// GLFW 3.2 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
+// Copyright (c) 2006-2016 Camilla Berglund <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,6 +27,7 @@
 
 #include "internal.h"
 
+#include <assert.h>
 #include <stdio.h>
 #include <string.h>
 #include <limits.h>
@@ -35,7 +36,7 @@
 
 // Parses the client API version string and extracts the version number
 //
-static GLboolean parseVersionString(int* api, int* major, int* minor, int* rev)
+static GLFWbool parseVersionString(int* api, int* major, int* minor, int* rev)
 {
     int i;
     _GLFWwindow* window;
@@ -52,12 +53,12 @@ static GLboolean parseVersionString(int* api, int* major, int* minor, int* rev)
 
     window = _glfwPlatformGetCurrentContext();
 
-    version = (const char*) window->GetString(GL_VERSION);
+    version = (const char*) window->context.GetString(GL_VERSION);
     if (!version)
     {
         _glfwInputError(GLFW_PLATFORM_ERROR,
-                        "Failed to retrieve context version string");
-        return GL_FALSE;
+                        "Client API version string retrieval is broken");
+        return GLFW_FALSE;
     }
 
     for (i = 0;  prefixes[i];  i++)
@@ -75,11 +76,11 @@ static GLboolean parseVersionString(int* api, int* major, int* minor, int* rev)
     if (!sscanf(version, "%d.%d.%d", major, minor, rev))
     {
         _glfwInputError(GLFW_PLATFORM_ERROR,
-                        "No version found in context version string");
-        return GL_FALSE;
+                        "No version found in client API version string");
+        return GLFW_FALSE;
     }
 
-    return GL_TRUE;
+    return GLFW_TRUE;
 }
 
 
@@ -87,16 +88,28 @@ static GLboolean parseVersionString(int* api, int* major, int* minor, int* rev)
 //////                       GLFW internal API                      //////
 //////////////////////////////////////////////////////////////////////////
 
-GLboolean _glfwIsValidContextConfig(const _GLFWctxconfig* ctxconfig)
+GLFWbool _glfwIsValidContextConfig(const _GLFWctxconfig* ctxconfig)
 {
-    if (ctxconfig->api != GLFW_OPENGL_API &&
-        ctxconfig->api != GLFW_OPENGL_ES_API)
+    if (ctxconfig->source != GLFW_NATIVE_CONTEXT_API &&
+        ctxconfig->source != GLFW_EGL_CONTEXT_API)
     {
-        _glfwInputError(GLFW_INVALID_ENUM, "Invalid client API");
-        return GL_FALSE;
+        _glfwInputError(GLFW_INVALID_ENUM,
+                        "Invalid context creation API %i",
+                        ctxconfig->source);
+        return GLFW_FALSE;
     }
 
-    if (ctxconfig->api == GLFW_OPENGL_API)
+    if (ctxconfig->client != GLFW_NO_API &&
+        ctxconfig->client != GLFW_OPENGL_API &&
+        ctxconfig->client != GLFW_OPENGL_ES_API)
+    {
+        _glfwInputError(GLFW_INVALID_ENUM,
+                        "Invalid client API %i",
+                        ctxconfig->client);
+        return GLFW_FALSE;
+    }
+
+    if (ctxconfig->client == GLFW_OPENGL_API)
     {
         if ((ctxconfig->major < 1 || ctxconfig->minor < 0) ||
             (ctxconfig->major == 1 && ctxconfig->minor > 5) ||
@@ -112,7 +125,7 @@ GLboolean _glfwIsValidContextConfig(const _GLFWctxconfig* ctxconfig)
             _glfwInputError(GLFW_INVALID_VALUE,
                             "Invalid OpenGL version %i.%i",
                             ctxconfig->major, ctxconfig->minor);
-            return GL_FALSE;
+            return GLFW_FALSE;
         }
 
         if (ctxconfig->profile)
@@ -121,11 +134,12 @@ GLboolean _glfwIsValidContextConfig(const _GLFWctxconfig* ctxconfig)
                 ctxconfig->profile != GLFW_OPENGL_COMPAT_PROFILE)
             {
                 _glfwInputError(GLFW_INVALID_ENUM,
-                                "Invalid OpenGL profile");
-                return GL_FALSE;
+                                "Invalid OpenGL profile %i",
+                                ctxconfig->profile);
+                return GLFW_FALSE;
             }
 
-            if (ctxconfig->major < 3 ||
+            if (ctxconfig->major <= 2 ||
                 (ctxconfig->major == 3 && ctxconfig->minor < 2))
             {
                 // Desktop OpenGL context profiles are only defined for version 3.2
@@ -133,19 +147,19 @@ GLboolean _glfwIsValidContextConfig(const _GLFWctxconfig* ctxconfig)
 
                 _glfwInputError(GLFW_INVALID_VALUE,
                                 "Context profiles are only defined for OpenGL version 3.2 and above");
-                return GL_FALSE;
+                return GLFW_FALSE;
             }
         }
 
-        if (ctxconfig->forward && ctxconfig->major < 3)
+        if (ctxconfig->forward && ctxconfig->major <= 2)
         {
             // Forward-compatible contexts are only defined for OpenGL version 3.0 and above
             _glfwInputError(GLFW_INVALID_VALUE,
                             "Forward-compatibility is only defined for OpenGL version 3.0 and above");
-            return GL_FALSE;
+            return GLFW_FALSE;
         }
     }
-    else if (ctxconfig->api == GLFW_OPENGL_ES_API)
+    else if (ctxconfig->client == GLFW_OPENGL_ES_API)
     {
         if (ctxconfig->major < 1 || ctxconfig->minor < 0 ||
             (ctxconfig->major == 1 && ctxconfig->minor > 1) ||
@@ -159,7 +173,7 @@ GLboolean _glfwIsValidContextConfig(const _GLFWctxconfig* ctxconfig)
             _glfwInputError(GLFW_INVALID_VALUE,
                             "Invalid OpenGL ES version %i.%i",
                             ctxconfig->major, ctxconfig->minor);
-            return GL_FALSE;
+            return GLFW_FALSE;
         }
     }
 
@@ -169,8 +183,9 @@ GLboolean _glfwIsValidContextConfig(const _GLFWctxconfig* ctxconfig)
             ctxconfig->robustness != GLFW_LOSE_CONTEXT_ON_RESET)
         {
             _glfwInputError(GLFW_INVALID_ENUM,
-                            "Invalid context robustness mode");
-            return GL_FALSE;
+                            "Invalid context robustness mode %i",
+                            ctxconfig->robustness);
+            return GLFW_FALSE;
         }
     }
 
@@ -180,12 +195,13 @@ GLboolean _glfwIsValidContextConfig(const _GLFWctxconfig* ctxconfig)
             ctxconfig->release != GLFW_RELEASE_BEHAVIOR_FLUSH)
         {
             _glfwInputError(GLFW_INVALID_ENUM,
-                            "Invalid context release behavior");
-            return GL_FALSE;
+                            "Invalid context release behavior %i",
+                            ctxconfig->release);
+            return GLFW_FALSE;
         }
     }
 
-    return GL_TRUE;
+    return GLFW_TRUE;
 }
 
 const _GLFWfbconfig* _glfwChooseFBConfig(const _GLFWfbconfig* desired,
@@ -351,67 +367,96 @@ const _GLFWfbconfig* _glfwChooseFBConfig(const _GLFWfbconfig* desired,
     return closest;
 }
 
-GLboolean _glfwRefreshContextAttribs(const _GLFWctxconfig* ctxconfig)
+GLFWbool _glfwRefreshContextAttribs(const _GLFWctxconfig* ctxconfig)
 {
     _GLFWwindow* window = _glfwPlatformGetCurrentContext();
 
-    window->GetIntegerv = (PFNGLGETINTEGERVPROC) glfwGetProcAddress("glGetIntegerv");
-    window->GetString = (PFNGLGETSTRINGPROC) glfwGetProcAddress("glGetString");
-    window->Clear = (PFNGLCLEARPROC) glfwGetProcAddress("glClear");
+    window->context.GetIntegerv = (PFNGLGETINTEGERVPROC)
+        glfwGetProcAddress("glGetIntegerv");
+    window->context.GetString = (PFNGLGETSTRINGPROC)
+        glfwGetProcAddress("glGetString");
+    if (!window->context.GetIntegerv || !window->context.GetString)
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR, "Entry point retrieval is broken");
+        return GLFW_FALSE;
+    }
 
-    if (!parseVersionString(&window->context.api,
+    if (!parseVersionString(&window->context.client,
                             &window->context.major,
                             &window->context.minor,
                             &window->context.revision))
     {
-        return GL_FALSE;
+        return GLFW_FALSE;
     }
 
-#if defined(_GLFW_USE_OPENGL)
-    if (window->context.major > 2)
+    window->context.source = ctxconfig->source;
+
+    if (window->context.major < ctxconfig->major ||
+        (window->context.major == ctxconfig->major &&
+         window->context.minor < ctxconfig->minor))
+    {
+        // The desired OpenGL version is greater than the actual version
+        // This only happens if the machine lacks {GLX|WGL}_ARB_create_context
+        // /and/ the user has requested an OpenGL version greater than 1.0
+
+        // For API consistency, we emulate the behavior of the
+        // {GLX|WGL}_ARB_create_context extension and fail here
+
+        _glfwInputError(GLFW_VERSION_UNAVAILABLE,
+                        "Requested client API version %i.%i, got version %i.%i",
+                        ctxconfig->major, ctxconfig->minor,
+                        window->context.major, window->context.minor);
+        return GLFW_FALSE;
+    }
+
+    if (window->context.major >= 3)
     {
         // OpenGL 3.0+ uses a different function for extension string retrieval
         // We cache it here instead of in glfwExtensionSupported mostly to alert
         // users as early as possible that their build may be broken
 
-        window->GetStringi = (PFNGLGETSTRINGIPROC) glfwGetProcAddress("glGetStringi");
-        if (!window->GetStringi)
+        window->context.GetStringi = (PFNGLGETSTRINGIPROC)
+            glfwGetProcAddress("glGetStringi");
+        if (!window->context.GetStringi)
         {
             _glfwInputError(GLFW_PLATFORM_ERROR,
                             "Entry point retrieval is broken");
-            return GL_FALSE;
+            return GLFW_FALSE;
         }
     }
 
-    if (window->context.api == GLFW_OPENGL_API)
+    if (window->context.client == GLFW_OPENGL_API)
     {
         // Read back context flags (OpenGL 3.0 and above)
         if (window->context.major >= 3)
         {
             GLint flags;
-            window->GetIntegerv(GL_CONTEXT_FLAGS, &flags);
+            window->context.GetIntegerv(GL_CONTEXT_FLAGS, &flags);
 
             if (flags & GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT)
-                window->context.forward = GL_TRUE;
+                window->context.forward = GLFW_TRUE;
 
             if (flags & GL_CONTEXT_FLAG_DEBUG_BIT)
-                window->context.debug = GL_TRUE;
+                window->context.debug = GLFW_TRUE;
             else if (glfwExtensionSupported("GL_ARB_debug_output") &&
                      ctxconfig->debug)
             {
                 // HACK: This is a workaround for older drivers (pre KHR_debug)
                 //       not setting the debug bit in the context flags for
                 //       debug contexts
-                window->context.debug = GL_TRUE;
+                window->context.debug = GLFW_TRUE;
             }
+
+            if (flags & GL_CONTEXT_FLAG_NO_ERROR_BIT_KHR)
+                window->context.noerror = GLFW_TRUE;
         }
 
         // Read back OpenGL context profile (OpenGL 3.2 and above)
-        if (window->context.major > 3 ||
+        if (window->context.major >= 4 ||
             (window->context.major == 3 && window->context.minor >= 2))
         {
             GLint mask;
-            window->GetIntegerv(GL_CONTEXT_PROFILE_MASK, &mask);
+            window->context.GetIntegerv(GL_CONTEXT_PROFILE_MASK, &mask);
 
             if (mask & GL_CONTEXT_COMPATIBILITY_PROFILE_BIT)
                 window->context.profile = GLFW_OPENGL_COMPAT_PROFILE;
@@ -434,7 +479,8 @@ GLboolean _glfwRefreshContextAttribs(const _GLFWctxconfig* ctxconfig)
             //       only present from 3.0 while the extension applies from 1.1
 
             GLint strategy;
-            window->GetIntegerv(GL_RESET_NOTIFICATION_STRATEGY_ARB, &strategy);
+            window->context.GetIntegerv(GL_RESET_NOTIFICATION_STRATEGY_ARB,
+                                        &strategy);
 
             if (strategy == GL_LOSE_CONTEXT_ON_RESET_ARB)
                 window->context.robustness = GLFW_LOSE_CONTEXT_ON_RESET;
@@ -451,7 +497,8 @@ GLboolean _glfwRefreshContextAttribs(const _GLFWctxconfig* ctxconfig)
             //       one, so we can reuse them here
 
             GLint strategy;
-            window->GetIntegerv(GL_RESET_NOTIFICATION_STRATEGY_ARB, &strategy);
+            window->context.GetIntegerv(GL_RESET_NOTIFICATION_STRATEGY_ARB,
+                                        &strategy);
 
             if (strategy == GL_LOSE_CONTEXT_ON_RESET_ARB)
                 window->context.robustness = GLFW_LOSE_CONTEXT_ON_RESET;
@@ -463,41 +510,26 @@ GLboolean _glfwRefreshContextAttribs(const _GLFWctxconfig* ctxconfig)
     if (glfwExtensionSupported("GL_KHR_context_flush_control"))
     {
         GLint behavior;
-        window->GetIntegerv(GL_CONTEXT_RELEASE_BEHAVIOR, &behavior);
+        window->context.GetIntegerv(GL_CONTEXT_RELEASE_BEHAVIOR, &behavior);
 
         if (behavior == GL_NONE)
             window->context.release = GLFW_RELEASE_BEHAVIOR_NONE;
         else if (behavior == GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH)
             window->context.release = GLFW_RELEASE_BEHAVIOR_FLUSH;
     }
-#endif // _GLFW_USE_OPENGL
 
-    return GL_TRUE;
-}
-
-GLboolean _glfwIsValidContext(const _GLFWctxconfig* ctxconfig)
-{
-    _GLFWwindow* window = _glfwPlatformGetCurrentContext();
-
-    if (window->context.major < ctxconfig->major ||
-        (window->context.major == ctxconfig->major &&
-         window->context.minor < ctxconfig->minor))
+    // Clearing the front buffer to black to avoid garbage pixels left over from
+    // previous uses of our bit of VRAM
     {
-        // The desired OpenGL version is greater than the actual version
-        // This only happens if the machine lacks {GLX|WGL}_ARB_create_context
-        // /and/ the user has requested an OpenGL version greater than 1.0
-
-        // For API consistency, we emulate the behavior of the
-        // {GLX|WGL}_ARB_create_context extension and fail here
-
-        _glfwInputError(GLFW_VERSION_UNAVAILABLE, NULL);
-        return GL_FALSE;
+        PFNGLCLEARPROC glClear = (PFNGLCLEARPROC) glfwGetProcAddress("glClear");
+        glClear(GL_COLOR_BUFFER_BIT);
+        window->context.swapBuffers(window);
     }
 
-    return GL_TRUE;
+    return GLFW_TRUE;
 }
 
-int _glfwStringInExtensionString(const char* string, const char* extensions)
+GLFWbool _glfwStringInExtensionString(const char* string, const char* extensions)
 {
     const char* start = extensions;
 
@@ -508,7 +540,7 @@ int _glfwStringInExtensionString(const char* string, const char* extensions)
 
         where = strstr(start, string);
         if (!where)
-            return GL_FALSE;
+            return GLFW_FALSE;
 
         terminator = where + strlen(string);
         if (where == start || *(where - 1) == ' ')
@@ -520,7 +552,7 @@ int _glfwStringInExtensionString(const char* string, const char* extensions)
         start = terminator;
     }
 
-    return GL_TRUE;
+    return GLFW_TRUE;
 }
 
 
@@ -531,8 +563,24 @@ int _glfwStringInExtensionString(const char* string, const char* extensions)
 GLFWAPI void glfwMakeContextCurrent(GLFWwindow* handle)
 {
     _GLFWwindow* window = (_GLFWwindow*) handle;
+    _GLFWwindow* previous = _glfwPlatformGetCurrentContext();
+
     _GLFW_REQUIRE_INIT();
-    _glfwPlatformMakeContextCurrent(window);
+
+    if (window && window->context.client == GLFW_NO_API)
+    {
+        _glfwInputError(GLFW_NO_WINDOW_CONTEXT, NULL);
+        return;
+    }
+
+    if (previous)
+    {
+        if (!window || window->context.source != previous->context.source)
+            previous->context.makeCurrent(NULL);
+    }
+
+    if (window)
+        window->context.makeCurrent(window);
 }
 
 GLFWAPI GLFWwindow* glfwGetCurrentContext(void)
@@ -544,43 +592,56 @@ GLFWAPI GLFWwindow* glfwGetCurrentContext(void)
 GLFWAPI void glfwSwapBuffers(GLFWwindow* handle)
 {
     _GLFWwindow* window = (_GLFWwindow*) handle;
+    assert(window != NULL);
+
     _GLFW_REQUIRE_INIT();
-    _glfwPlatformSwapBuffers(window);
+
+    if (window->context.client == GLFW_NO_API)
+    {
+        _glfwInputError(GLFW_NO_WINDOW_CONTEXT, NULL);
+        return;
+    }
+
+    window->context.swapBuffers(window);
 }
 
 GLFWAPI void glfwSwapInterval(int interval)
 {
+    _GLFWwindow* window;
+
     _GLFW_REQUIRE_INIT();
 
-    if (!_glfwPlatformGetCurrentContext())
+    window = _glfwPlatformGetCurrentContext();
+    if (!window)
     {
         _glfwInputError(GLFW_NO_CURRENT_CONTEXT, NULL);
         return;
     }
 
-    _glfwPlatformSwapInterval(interval);
+    window->context.swapInterval(interval);
 }
 
 GLFWAPI int glfwExtensionSupported(const char* extension)
 {
     _GLFWwindow* window;
 
-    _GLFW_REQUIRE_INIT_OR_RETURN(GL_FALSE);
+    assert(extension != NULL);
+
+    _GLFW_REQUIRE_INIT_OR_RETURN(GLFW_FALSE);
 
     window = _glfwPlatformGetCurrentContext();
     if (!window)
     {
         _glfwInputError(GLFW_NO_CURRENT_CONTEXT, NULL);
-        return GL_FALSE;
+        return GLFW_FALSE;
     }
 
     if (*extension == '\0')
     {
-        _glfwInputError(GLFW_INVALID_VALUE, NULL);
-        return GL_FALSE;
+        _glfwInputError(GLFW_INVALID_VALUE, "Extension name is empty string");
+        return GLFW_FALSE;
     }
 
-#if defined(_GLFW_USE_OPENGL)
     if (window->context.major >= 3)
     {
         int i;
@@ -588,53 +649,58 @@ GLFWAPI int glfwExtensionSupported(const char* extension)
 
         // Check if extension is in the modern OpenGL extensions string list
 
-        window->GetIntegerv(GL_NUM_EXTENSIONS, &count);
+        window->context.GetIntegerv(GL_NUM_EXTENSIONS, &count);
 
         for (i = 0;  i < count;  i++)
         {
-            const char* en = (const char*) window->GetStringi(GL_EXTENSIONS, i);
+            const char* en = (const char*)
+                window->context.GetStringi(GL_EXTENSIONS, i);
             if (!en)
             {
                 _glfwInputError(GLFW_PLATFORM_ERROR,
-                                "Failed to retrieve extension string %i", i);
-                return GL_FALSE;
+                                "Extension string retrieval is broken");
+                return GLFW_FALSE;
             }
 
             if (strcmp(en, extension) == 0)
-                return GL_TRUE;
+                return GLFW_TRUE;
         }
     }
     else
-#endif // _GLFW_USE_OPENGL
     {
         // Check if extension is in the old style OpenGL extensions string
 
-        const char* extensions = (const char*) window->GetString(GL_EXTENSIONS);
+        const char* extensions = (const char*)
+            window->context.GetString(GL_EXTENSIONS);
         if (!extensions)
         {
             _glfwInputError(GLFW_PLATFORM_ERROR,
-                            "Failed to retrieve extension string");
-            return GL_FALSE;
+                            "Extension string retrieval is broken");
+            return GLFW_FALSE;
         }
 
         if (_glfwStringInExtensionString(extension, extensions))
-            return GL_TRUE;
+            return GLFW_TRUE;
     }
 
     // Check if extension is in the platform-specific string
-    return _glfwPlatformExtensionSupported(extension);
+    return window->context.extensionSupported(extension);
 }
 
 GLFWAPI GLFWglproc glfwGetProcAddress(const char* procname)
 {
+    _GLFWwindow* window;
+    assert(procname != NULL);
+
     _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
 
-    if (!_glfwPlatformGetCurrentContext())
+    window = _glfwPlatformGetCurrentContext();
+    if (!window)
     {
         _glfwInputError(GLFW_NO_CURRENT_CONTEXT, NULL);
         return NULL;
     }
 
-    return _glfwPlatformGetProcAddress(procname);
+    return window->context.getProcAddress(procname);
 }
 

src/egl_context.c

@@ -1,8 +1,8 @@
 //========================================================================
-// GLFW 3.1 EGL - www.glfw.org
+// GLFW 3.2 EGL - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
+// Copyright (c) 2006-2016 Camilla Berglund <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
@@ -68,9 +68,9 @@ static const char* getErrorString(EGLint error)
             return "A NativeWindowType argument does not refer to a valid native window";
         case EGL_CONTEXT_LOST:
             return "The application must destroy all contexts and reinitialise";
+        default:
+            return "ERROR: UNKNOWN EGL ERROR";
     }
-
-    return "UNKNOWN EGL ERROR";
 }
 
 // Returns the specified attribute of the specified EGLConfig
@@ -78,31 +78,30 @@ static const char* getErrorString(EGLint error)
 static int getConfigAttrib(EGLConfig config, int attrib)
 {
     int value;
-    _glfw_eglGetConfigAttrib(_glfw.egl.display, config, attrib, &value);
+    eglGetConfigAttrib(_glfw.egl.display, config, attrib, &value);
     return value;
 }
 
 // Return a list of available and usable framebuffer configs
 //
-static GLboolean chooseFBConfigs(const _GLFWctxconfig* ctxconfig,
-                                 const _GLFWfbconfig* desired,
-                                 EGLConfig* result)
+static GLFWbool chooseFBConfigs(const _GLFWctxconfig* ctxconfig,
+                                const _GLFWfbconfig* desired,
+                                EGLConfig* result)
 {
     EGLConfig* nativeConfigs;
     _GLFWfbconfig* usableConfigs;
     const _GLFWfbconfig* closest;
     int i, nativeCount, usableCount;
 
-    _glfw_eglGetConfigs(_glfw.egl.display, NULL, 0, &nativeCount);
+    eglGetConfigs(_glfw.egl.display, NULL, 0, &nativeCount);
     if (!nativeCount)
     {
         _glfwInputError(GLFW_API_UNAVAILABLE, "EGL: No EGLConfigs returned");
-        return GL_FALSE;
+        return GLFW_FALSE;
     }
 
     nativeConfigs = calloc(nativeCount, sizeof(EGLConfig));
-    _glfw_eglGetConfigs(_glfw.egl.display, nativeConfigs,
-                        nativeCount, &nativeCount);
+    eglGetConfigs(_glfw.egl.display, nativeConfigs, nativeCount, &nativeCount);
 
     usableConfigs = calloc(nativeCount, sizeof(_GLFWfbconfig));
     usableCount = 0;
@@ -112,12 +111,6 @@ static GLboolean chooseFBConfigs(const _GLFWctxconfig* ctxconfig,
         const EGLConfig n = nativeConfigs[i];
         _GLFWfbconfig* u = usableConfigs + usableCount;
 
-#if defined(_GLFW_X11)
-        // Only consider EGLConfigs with associated visuals
-        if (!getConfigAttrib(n, EGL_NATIVE_VISUAL_ID))
-            continue;
-#endif // _GLFW_X11
-
         // Only consider RGB(A) EGLConfigs
         if (!(getConfigAttrib(n, EGL_COLOR_BUFFER_TYPE) & EGL_RGB_BUFFER))
             continue;
@@ -126,7 +119,13 @@ static GLboolean chooseFBConfigs(const _GLFWctxconfig* ctxconfig,
         if (!(getConfigAttrib(n, EGL_SURFACE_TYPE) & EGL_WINDOW_BIT))
             continue;
 
-        if (ctxconfig->api == GLFW_OPENGL_ES_API)
+#if defined(_GLFW_X11)
+        // Only consider EGLConfigs with associated Visuals
+        if (!getConfigAttrib(n, EGL_NATIVE_VISUAL_ID))
+            continue;
+#endif // _GLFW_X11
+
+        if (ctxconfig->client == GLFW_OPENGL_ES_API)
         {
             if (ctxconfig->major == 1)
             {
@@ -139,7 +138,7 @@ static GLboolean chooseFBConfigs(const _GLFWctxconfig* ctxconfig,
                     continue;
             }
         }
-        else if (ctxconfig->api == GLFW_OPENGL_API)
+        else if (ctxconfig->client == GLFW_OPENGL_API)
         {
             if (!(getConfigAttrib(n, EGL_RENDERABLE_TYPE) & EGL_OPENGL_BIT))
                 continue;
@@ -154,20 +153,124 @@ static GLboolean chooseFBConfigs(const _GLFWctxconfig* ctxconfig,
         u->stencilBits = getConfigAttrib(n, EGL_STENCIL_SIZE);
 
         u->samples = getConfigAttrib(n, EGL_SAMPLES);
-        u->doublebuffer = GL_TRUE;
+        u->doublebuffer = GLFW_TRUE;
 
-        u->egl = n;
+        u->handle = (uintptr_t) n;
         usableCount++;
     }
 
     closest = _glfwChooseFBConfig(desired, usableConfigs, usableCount);
     if (closest)
-        *result = closest->egl;
+        *result = (EGLConfig) closest->handle;
 
     free(nativeConfigs);
     free(usableConfigs);
 
-    return closest ? GL_TRUE : GL_FALSE;
+    return closest != NULL;
+}
+
+static void makeContextCurrent(_GLFWwindow* window)
+{
+    if (window)
+    {
+        if (!eglMakeCurrent(_glfw.egl.display,
+                            window->context.egl.surface,
+                            window->context.egl.surface,
+                            window->context.egl.handle))
+        {
+            _glfwInputError(GLFW_PLATFORM_ERROR,
+                            "EGL: Failed to make context current: %s",
+                            getErrorString(eglGetError()));
+            return;
+        }
+    }
+    else
+    {
+        if (!eglMakeCurrent(_glfw.egl.display,
+                            EGL_NO_SURFACE,
+                            EGL_NO_SURFACE,
+                            EGL_NO_CONTEXT))
+        {
+            _glfwInputError(GLFW_PLATFORM_ERROR,
+                            "EGL: Failed to clear current context: %s",
+                            getErrorString(eglGetError()));
+            return;
+        }
+    }
+
+    _glfwPlatformSetCurrentContext(window);
+}
+
+static void swapBuffers(_GLFWwindow* window)
+{
+    if (window != _glfwPlatformGetCurrentContext())
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "EGL: The context must be current on the calling thread when swapping buffers");
+        return;
+    }
+
+    eglSwapBuffers(_glfw.egl.display, window->context.egl.surface);
+}
+
+static void swapInterval(int interval)
+{
+    eglSwapInterval(_glfw.egl.display, interval);
+}
+
+static int extensionSupported(const char* extension)
+{
+    const char* extensions = eglQueryString(_glfw.egl.display, EGL_EXTENSIONS);
+    if (extensions)
+    {
+        if (_glfwStringInExtensionString(extension, extensions))
+            return GLFW_TRUE;
+    }
+
+    return GLFW_FALSE;
+}
+
+static GLFWglproc getProcAddress(const char* procname)
+{
+    _GLFWwindow* window = _glfwPlatformGetCurrentContext();
+
+    if (window->context.egl.client)
+    {
+        GLFWglproc proc = (GLFWglproc) _glfw_dlsym(window->context.egl.client,
+                                                   procname);
+        if (proc)
+            return proc;
+    }
+
+    return eglGetProcAddress(procname);
+}
+
+static void destroyContext(_GLFWwindow* window)
+{
+#if defined(_GLFW_X11)
+    // NOTE: Do not unload libGL.so.1 while the X11 display is still open,
+    //       as it will make XCloseDisplay segfault
+    if (window->context.client != GLFW_OPENGL_API)
+#endif // _GLFW_X11
+    {
+        if (window->context.egl.client)
+        {
+            _glfw_dlclose(window->context.egl.client);
+            window->context.egl.client = NULL;
+        }
+    }
+
+    if (window->context.egl.surface)
+    {
+        eglDestroySurface(_glfw.egl.display, window->context.egl.surface);
+        window->context.egl.surface = EGL_NO_SURFACE;
+    }
+
+    if (window->context.egl.handle)
+    {
+        eglDestroyContext(_glfw.egl.display, window->context.egl.handle);
+        window->context.egl.handle = EGL_NO_CONTEXT;
+    }
 }
 
 
@@ -177,7 +280,7 @@ static GLboolean chooseFBConfigs(const _GLFWctxconfig* ctxconfig,
 
 // Initialize EGL
 //
-int _glfwInitContextAPI(void)
+GLFWbool _glfwInitEGL(void)
 {
     int i;
     const char* sonames[] =
@@ -193,9 +296,6 @@ int _glfwInitContextAPI(void)
         NULL
     };
 
-    if (!_glfwCreateContextTLS())
-        return GL_FALSE;
-
     for (i = 0;  sonames[i];  i++)
     {
         _glfw.egl.handle = _glfw_dlopen(sonames[i]);
@@ -204,84 +304,87 @@ int _glfwInitContextAPI(void)
     }
 
     if (!_glfw.egl.handle)
-    {
-        _glfwInputError(GLFW_API_UNAVAILABLE, "EGL: Failed to load EGL");
-        return GL_FALSE;
-    }
+        return GLFW_FALSE;
 
-    _glfw.egl.GetConfigAttrib =
+    _glfw.egl.GetConfigAttrib = (PFNEGLGETCONFIGATTRIBPROC)
         _glfw_dlsym(_glfw.egl.handle, "eglGetConfigAttrib");
-    _glfw.egl.GetConfigs =
+    _glfw.egl.GetConfigs = (PFNEGLGETCONFIGSPROC)
         _glfw_dlsym(_glfw.egl.handle, "eglGetConfigs");
-    _glfw.egl.GetDisplay =
+    _glfw.egl.GetDisplay = (PFNEGLGETDISPLAYPROC)
         _glfw_dlsym(_glfw.egl.handle, "eglGetDisplay");
-    _glfw.egl.GetError =
+    _glfw.egl.GetError = (PFNEGLGETERRORPROC)
         _glfw_dlsym(_glfw.egl.handle, "eglGetError");
-    _glfw.egl.Initialize =
+    _glfw.egl.Initialize = (PFNEGLINITIALIZEPROC)
         _glfw_dlsym(_glfw.egl.handle, "eglInitialize");
-    _glfw.egl.Terminate =
+    _glfw.egl.Terminate = (PFNEGLTERMINATEPROC)
         _glfw_dlsym(_glfw.egl.handle, "eglTerminate");
-    _glfw.egl.BindAPI =
+    _glfw.egl.BindAPI = (PFNEGLBINDAPIPROC)
         _glfw_dlsym(_glfw.egl.handle, "eglBindAPI");
-    _glfw.egl.CreateContext =
+    _glfw.egl.CreateContext = (PFNEGLCREATECONTEXTPROC)
         _glfw_dlsym(_glfw.egl.handle, "eglCreateContext");
-    _glfw.egl.DestroySurface =
+    _glfw.egl.DestroySurface = (PFNEGLDESTROYSURFACEPROC)
         _glfw_dlsym(_glfw.egl.handle, "eglDestroySurface");
-    _glfw.egl.DestroyContext =
+    _glfw.egl.DestroyContext = (PFNEGLDESTROYCONTEXTPROC)
         _glfw_dlsym(_glfw.egl.handle, "eglDestroyContext");
-    _glfw.egl.CreateWindowSurface =
+    _glfw.egl.CreateWindowSurface = (PFNEGLCREATEWINDOWSURFACEPROC)
         _glfw_dlsym(_glfw.egl.handle, "eglCreateWindowSurface");
-    _glfw.egl.MakeCurrent =
+    _glfw.egl.MakeCurrent = (PFNEGLMAKECURRENTPROC)
         _glfw_dlsym(_glfw.egl.handle, "eglMakeCurrent");
-    _glfw.egl.SwapBuffers =
+    _glfw.egl.SwapBuffers = (PFNEGLSWAPBUFFERSPROC)
         _glfw_dlsym(_glfw.egl.handle, "eglSwapBuffers");
-    _glfw.egl.SwapInterval =
+    _glfw.egl.SwapInterval = (PFNEGLSWAPINTERVALPROC)
         _glfw_dlsym(_glfw.egl.handle, "eglSwapInterval");
-    _glfw.egl.QueryString =
+    _glfw.egl.QueryString = (PFNEGLQUERYSTRINGPROC)
         _glfw_dlsym(_glfw.egl.handle, "eglQueryString");
-    _glfw.egl.GetProcAddress =
+    _glfw.egl.GetProcAddress = (PFNEGLGETPROCADDRESSPROC)
         _glfw_dlsym(_glfw.egl.handle, "eglGetProcAddress");
 
-    _glfw.egl.display =
-        _glfw_eglGetDisplay((EGLNativeDisplayType)_GLFW_EGL_NATIVE_DISPLAY);
+    _glfw.egl.display = eglGetDisplay(_GLFW_EGL_NATIVE_DISPLAY);
     if (_glfw.egl.display == EGL_NO_DISPLAY)
     {
         _glfwInputError(GLFW_API_UNAVAILABLE,
                         "EGL: Failed to get EGL display: %s",
-                        getErrorString(_glfw_eglGetError()));
-        return GL_FALSE;
+                        getErrorString(eglGetError()));
+
+        _glfwTerminateEGL();
+        return GLFW_FALSE;
     }
 
-    if (!_glfw_eglInitialize(_glfw.egl.display,
-                             &_glfw.egl.major,
-                             &_glfw.egl.minor))
+    if (!eglInitialize(_glfw.egl.display, &_glfw.egl.major, &_glfw.egl.minor))
     {
         _glfwInputError(GLFW_API_UNAVAILABLE,
                         "EGL: Failed to initialize EGL: %s",
-                        getErrorString(_glfw_eglGetError()));
-        return GL_FALSE;
+                        getErrorString(eglGetError()));
+
+        _glfwTerminateEGL();
+        return GLFW_FALSE;
     }
 
     _glfw.egl.KHR_create_context =
-        _glfwPlatformExtensionSupported("EGL_KHR_create_context");
+        extensionSupported("EGL_KHR_create_context");
+    _glfw.egl.KHR_create_context_no_error =
+        extensionSupported("EGL_KHR_create_context_no_error");
+    _glfw.egl.KHR_gl_colorspace =
+        extensionSupported("EGL_KHR_gl_colorspace");
 
-    return GL_TRUE;
+    return GLFW_TRUE;
 }
 
 // Terminate EGL
 //
-void _glfwTerminateContextAPI(void)
+void _glfwTerminateEGL(void)
 {
-    if (_glfw_eglTerminate)
-        _glfw_eglTerminate(_glfw.egl.display);
+    if (_glfw.egl.display)
+    {
+        eglTerminate(_glfw.egl.display);
+        _glfw.egl.display = EGL_NO_DISPLAY;
+    }
 
     if (_glfw.egl.handle)
     {
         _glfw_dlclose(_glfw.egl.handle);
         _glfw.egl.handle = NULL;
     }
-
-    _glfwDestroyContextTLS();
 }
 
 #define setEGLattrib(attribName, attribValue) \
@@ -293,91 +396,48 @@ void _glfwTerminateContextAPI(void)
 
 // Create the OpenGL or OpenGL ES context
 //
-int _glfwCreateContext(_GLFWwindow* window,
-                       const _GLFWctxconfig* ctxconfig,
-                       const _GLFWfbconfig* fbconfig)
+GLFWbool _glfwCreateContextEGL(_GLFWwindow* window,
+                               const _GLFWctxconfig* ctxconfig,
+                               const _GLFWfbconfig* fbconfig)
 {
-    int attribs[40];
+    EGLint attribs[40];
     EGLConfig config;
     EGLContext share = NULL;
 
+    if (!_glfw.egl.display)
+    {
+        _glfwInputError(GLFW_API_UNAVAILABLE, "EGL: API not available");
+        return GLFW_FALSE;
+    }
+
     if (ctxconfig->share)
-        share = ctxconfig->share->egl.context;
+        share = ctxconfig->share->context.egl.handle;
 
     if (!chooseFBConfigs(ctxconfig, fbconfig, &config))
     {
         _glfwInputError(GLFW_FORMAT_UNAVAILABLE,
                         "EGL: Failed to find a suitable EGLConfig");
-        return GL_FALSE;
+        return GLFW_FALSE;
     }
 
-#if defined(_GLFW_X11)
-    // Retrieve the visual corresponding to the chosen EGL config
+    if (ctxconfig->client == GLFW_OPENGL_ES_API)
     {
-        EGLint count = 0;
-        int mask;
-        EGLint redBits, greenBits, blueBits, alphaBits, visualID = 0;
-        XVisualInfo info;
-
-        _glfw_eglGetConfigAttrib(_glfw.egl.display, config,
-                                 EGL_NATIVE_VISUAL_ID, &visualID);
-
-        info.screen = _glfw.x11.screen;
-        mask = VisualScreenMask;
-
-        if (visualID)
-        {
-            // The X window visual must match the EGL config
-            info.visualid = visualID;
-            mask |= VisualIDMask;
-        }
-        else
-        {
-            // Some EGL drivers do not implement the EGL_NATIVE_VISUAL_ID
-            // attribute, so attempt to find the closest match
-
-            _glfw_eglGetConfigAttrib(_glfw.egl.display, config,
-                                     EGL_RED_SIZE, &redBits);
-            _glfw_eglGetConfigAttrib(_glfw.egl.display, config,
-                                     EGL_GREEN_SIZE, &greenBits);
-            _glfw_eglGetConfigAttrib(_glfw.egl.display, config,
-                                     EGL_BLUE_SIZE, &blueBits);
-            _glfw_eglGetConfigAttrib(_glfw.egl.display, config,
-                                     EGL_ALPHA_SIZE, &alphaBits);
-
-            info.depth = redBits + greenBits + blueBits + alphaBits;
-            mask |= VisualDepthMask;
-        }
-
-        window->egl.visual = XGetVisualInfo(_glfw.x11.display,
-                                            mask, &info, &count);
-        if (!window->egl.visual)
-        {
-            _glfwInputError(GLFW_PLATFORM_ERROR,
-                            "EGL: Failed to retrieve visual for EGLConfig");
-            return GL_FALSE;
-        }
-    }
-#endif // _GLFW_X11
-
-    if (ctxconfig->api == GLFW_OPENGL_ES_API)
-    {
-        if (!_glfw_eglBindAPI(EGL_OPENGL_ES_API))
+        if (!eglBindAPI(EGL_OPENGL_ES_API))
         {
             _glfwInputError(GLFW_API_UNAVAILABLE,
                             "EGL: Failed to bind OpenGL ES: %s",
-                            getErrorString(_glfw_eglGetError()));
-            return GL_FALSE;
+                            getErrorString(eglGetError()));
+            return GLFW_FALSE;
         }
     }
     else
     {
-        if (!_glfw_eglBindAPI(EGL_OPENGL_API))
+        if (!eglBindAPI(EGL_OPENGL_API))
         {
             _glfwInputError(GLFW_API_UNAVAILABLE,
                             "EGL: Failed to bind OpenGL: %s",
-                            getErrorString(_glfw_eglGetError()));
-            return GL_FALSE;
+                            getErrorString(eglGetError()));
+            return GLFW_FALSE;
         }
     }
 
@@ -385,7 +445,7 @@ int _glfwCreateContext(_GLFWwindow* window,
     {
         int index = 0, mask = 0, flags = 0;
 
-        if (ctxconfig->api == GLFW_OPENGL_API)
+        if (ctxconfig->client == GLFW_OPENGL_API)
         {
             if (ctxconfig->forward)
                 flags |= EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE_BIT_KHR;
@@ -394,6 +454,12 @@ int _glfwCreateContext(_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)
@@ -433,7 +499,7 @@ int _glfwCreateContext(_GLFWwindow* window,
     {
         int index = 0;
 
-        if (ctxconfig->api == GLFW_OPENGL_ES_API)
+        if (ctxconfig->client == GLFW_OPENGL_ES_API)
             setEGLattrib(EGL_CONTEXT_CLIENT_VERSION, ctxconfig->major);
 
         setEGLattrib(EGL_NONE, EGL_NONE);
@@ -442,18 +508,46 @@ int _glfwCreateContext(_GLFWwindow* window,
     // Context release behaviors (GL_KHR_context_flush_control) are not yet
     // supported on EGL but are not a hard constraint, so ignore and continue
 
-    window->egl.context = _glfw_eglCreateContext(_glfw.egl.display,
-                                                 config, share, attribs);
+    window->context.egl.handle = eglCreateContext(_glfw.egl.display,
+                                                  config, share, attribs);
 
-    if (window->egl.context == EGL_NO_CONTEXT)
+    if (window->context.egl.handle == EGL_NO_CONTEXT)
     {
         _glfwInputError(GLFW_VERSION_UNAVAILABLE,
                         "EGL: Failed to create context: %s",
-                        getErrorString(_glfw_eglGetError()));
-        return GL_FALSE;
+                        getErrorString(eglGetError()));
+        return GLFW_FALSE;
     }
 
-    window->egl.config = config;
+    // Set up attributes for surface creation
+    {
+        int index = 0;
+
+        if (fbconfig->sRGB)
+        {
+            if (_glfw.egl.KHR_gl_colorspace)
+            {
+                setEGLattrib(EGL_GL_COLORSPACE_KHR, EGL_GL_COLORSPACE_SRGB_KHR);
+            }
+        }
+
+        setEGLattrib(EGL_NONE, EGL_NONE);
+    }
+
+    window->context.egl.surface =
+        eglCreateWindowSurface(_glfw.egl.display,
+                               config,
+                               _GLFW_EGL_NATIVE_WINDOW,
+                               attribs);
+    if (window->context.egl.surface == EGL_NO_SURFACE)
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "EGL: Failed to create window surface: %s",
+                        getErrorString(eglGetError()));
+        return GLFW_FALSE;
+    }
+
+    window->context.egl.config = config;
 
     // Load the appropriate client library
     {
@@ -494,7 +588,7 @@ int _glfwCreateContext(_GLFWwindow* window,
             NULL
         };
 
-        if (ctxconfig->api == GLFW_OPENGL_ES_API)
+        if (ctxconfig->client == GLFW_OPENGL_ES_API)
         {
             if (ctxconfig->major == 1)
                 sonames = es1sonames;
@@ -506,151 +600,72 @@ int _glfwCreateContext(_GLFWwindow* window,
 
         for (i = 0;  sonames[i];  i++)
         {
-            window->egl.client = _glfw_dlopen(sonames[i]);
-            if (window->egl.client)
+            window->context.egl.client = _glfw_dlopen(sonames[i]);
+            if (window->context.egl.client)
                 break;
         }
 
-        if (!window->egl.client)
+        if (!window->context.egl.client)
         {
             _glfwInputError(GLFW_API_UNAVAILABLE,
                             "EGL: Failed to load client library");
-            return GL_FALSE;
+            return GLFW_FALSE;
         }
     }
 
-    return GL_TRUE;
+    window->context.makeCurrent = makeContextCurrent;
+    window->context.swapBuffers = swapBuffers;
+    window->context.swapInterval = swapInterval;
+    window->context.extensionSupported = extensionSupported;
+    window->context.getProcAddress = getProcAddress;
+    window->context.destroy = destroyContext;
+
+    return GLFW_TRUE;
 }
 
 #undef setEGLattrib
 
-// Destroy the OpenGL context
+// Returns the Visual and depth of the chosen EGLConfig
 //
-void _glfwDestroyContext(_GLFWwindow* window)
-{
 #if defined(_GLFW_X11)
-    // NOTE: Do not unload libGL.so.1 while the X11 display is still open,
-    //       as it will make XCloseDisplay segfault
-    if (window->context.api != GLFW_OPENGL_API)
+GLFWbool _glfwChooseVisualEGL(const _GLFWctxconfig* ctxconfig,
+                              const _GLFWfbconfig* fbconfig,
+                              Visual** visual, int* depth)
+{
+    XVisualInfo* result;
+    XVisualInfo desired;
+    EGLConfig native;
+    EGLint visualID = 0, count = 0;
+    const long vimask = VisualScreenMask | VisualIDMask;
+
+    if (!chooseFBConfigs(ctxconfig, fbconfig, &native))
+    {
+        _glfwInputError(GLFW_FORMAT_UNAVAILABLE,
+                        "EGL: Failed to find a suitable EGLConfig");
+        return GLFW_FALSE;
+    }
+
+    eglGetConfigAttrib(_glfw.egl.display, native,
+                       EGL_NATIVE_VISUAL_ID, &visualID);
+
+    desired.screen = _glfw.x11.screen;
+    desired.visualid = visualID;
+
+    result = XGetVisualInfo(_glfw.x11.display, vimask, &desired, &count);
+    if (!result)
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "EGL: Failed to retrieve Visual for EGLConfig");
+        return GLFW_FALSE;
+    }
+
+    *visual = result->visual;
+    *depth = result->depth;
+
+    XFree(result);
+    return GLFW_TRUE;
+}
 #endif // _GLFW_X11
-    {
-        if (window->egl.client)
-        {
-            _glfw_dlclose(window->egl.client);
-            window->egl.client = NULL;
-        }
-    }
-
-#if defined(_GLFW_X11)
-    if (window->egl.visual)
-    {
-       XFree(window->egl.visual);
-       window->egl.visual = NULL;
-    }
-#endif // _GLFW_X11
-
-    if (window->egl.surface)
-    {
-        _glfw_eglDestroySurface(_glfw.egl.display, window->egl.surface);
-        window->egl.surface = EGL_NO_SURFACE;
-    }
-
-    if (window->egl.context)
-    {
-        _glfw_eglDestroyContext(_glfw.egl.display, window->egl.context);
-        window->egl.context = EGL_NO_CONTEXT;
-    }
-}
-
-// Analyzes the specified context for possible recreation
-//
-int _glfwAnalyzeContext(const _GLFWwindow* window,
-                        const _GLFWctxconfig* ctxconfig,
-                        const _GLFWfbconfig* fbconfig)
-{
-#if defined(_GLFW_WIN32)
-    return _GLFW_RECREATION_NOT_NEEDED;
-#else
-    return 0;
-#endif
-}
-
-
-//////////////////////////////////////////////////////////////////////////
-//////                       GLFW platform API                      //////
-//////////////////////////////////////////////////////////////////////////
-
-void _glfwPlatformMakeContextCurrent(_GLFWwindow* window)
-{
-    if (window)
-    {
-        if (window->egl.surface == EGL_NO_SURFACE)
-        {
-            window->egl.surface =
-                _glfw_eglCreateWindowSurface(_glfw.egl.display,
-                                             window->egl.config,
-                                             (EGLNativeWindowType)_GLFW_EGL_NATIVE_WINDOW,
-                                             NULL);
-            if (window->egl.surface == EGL_NO_SURFACE)
-            {
-                _glfwInputError(GLFW_PLATFORM_ERROR,
-                                "EGL: Failed to create window surface: %s",
-                                getErrorString(_glfw_eglGetError()));
-            }
-        }
-
-        _glfw_eglMakeCurrent(_glfw.egl.display,
-                             window->egl.surface,
-                             window->egl.surface,
-                             window->egl.context);
-    }
-    else
-    {
-        _glfw_eglMakeCurrent(_glfw.egl.display,
-                             EGL_NO_SURFACE,
-                             EGL_NO_SURFACE,
-                             EGL_NO_CONTEXT);
-    }
-
-    _glfwSetContextTLS(window);
-}
-
-void _glfwPlatformSwapBuffers(_GLFWwindow* window)
-{
-    _glfw_eglSwapBuffers(_glfw.egl.display, window->egl.surface);
-}
-
-void _glfwPlatformSwapInterval(int interval)
-{
-    _glfw_eglSwapInterval(_glfw.egl.display, interval);
-}
-
-int _glfwPlatformExtensionSupported(const char* extension)
-{
-    const char* extensions = _glfw_eglQueryString(_glfw.egl.display,
-                                                  EGL_EXTENSIONS);
-    if (extensions)
-    {
-        if (_glfwStringInExtensionString(extension, extensions))
-            return GL_TRUE;
-    }
-
-    return GL_FALSE;
-}
-
-GLFWglproc _glfwPlatformGetProcAddress(const char* procname)
-{
-    _GLFWwindow* window = _glfwPlatformGetCurrentContext();
-
-    if (window->egl.client)
-    {
-        GLFWglproc proc = (GLFWglproc) _glfw_dlsym(window->egl.client, procname);
-        if (proc)
-            return proc;
-    }
-
-    return _glfw_eglGetProcAddress(procname);
-}
 
 
 //////////////////////////////////////////////////////////////////////////
@@ -667,13 +682,27 @@ GLFWAPI EGLContext glfwGetEGLContext(GLFWwindow* handle)
 {
     _GLFWwindow* window = (_GLFWwindow*) handle;
     _GLFW_REQUIRE_INIT_OR_RETURN(EGL_NO_CONTEXT);
-    return window->egl.context;
+
+    if (window->context.client == GLFW_NO_API)
+    {
+        _glfwInputError(GLFW_NO_WINDOW_CONTEXT, NULL);
+        return EGL_NO_CONTEXT;
+    }
+
+    return window->context.egl.handle;
 }
 
 GLFWAPI EGLSurface glfwGetEGLSurface(GLFWwindow* handle)
 {
     _GLFWwindow* window = (_GLFWwindow*) handle;
     _GLFW_REQUIRE_INIT_OR_RETURN(EGL_NO_SURFACE);
-    return window->egl.surface;
+
+    if (window->context.client == GLFW_NO_API)
+    {
+        _glfwInputError(GLFW_NO_WINDOW_CONTEXT, NULL);
+        return EGL_NO_SURFACE;
+    }
+
+    return window->context.egl.surface;
 }
 

src/egl_context.h

@@ -1,8 +1,8 @@
 //========================================================================
-// GLFW 3.1 EGL - www.glfw.org
+// GLFW 3.2 EGL - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
+// Copyright (c) 2006-2016 Camilla Berglund <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,23 +28,92 @@
 #ifndef _glfw3_egl_context_h_
 #define _glfw3_egl_context_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)
+#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_X11)
+ #define EGLAPIENTRY
+typedef Display* EGLNativeDisplayType;
+typedef Window EGLNativeWindowType;
+#elif defined(_GLFW_WAYLAND)
+ #define EGLAPIENTRY
+typedef struct wl_display* EGLNativeDisplayType;
+typedef struct wl_egl_window* EGLNativeWindowType;
+#elif defined(_GLFW_MIR)
+ #define EGLAPIENTRY
+typedef MirEGLNativeDisplayType EGLNativeDisplayType;
+typedef MirEGLNativeWindowType EGLNativeWindowType;
 #else
- #include <dlfcn.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)
+ #error "No supported EGL platform selected"
 #endif
 
-#include <EGL/egl.h>
+#define EGL_SUCCESS	0x3000
+#define EGL_NOT_INITIALIZED	0x3001
+#define EGL_BAD_ACCESS 0x3002
+#define EGL_BAD_ALLOC 0x3003
+#define EGL_BAD_ATTRIBUTE 0x3004
+#define EGL_BAD_CONFIG 0x3005
+#define EGL_BAD_CONTEXT	0x3006
+#define EGL_BAD_CURRENT_SURFACE	0x3007
+#define EGL_BAD_DISPLAY	0x3008
+#define EGL_BAD_MATCH 0x3009
+#define EGL_BAD_NATIVE_PIXMAP 0x300a
+#define EGL_BAD_NATIVE_WINDOW 0x300b
+#define EGL_BAD_PARAMETER 0x300c
+#define EGL_BAD_SURFACE	0x300d
+#define EGL_CONTEXT_LOST 0x300e
+#define EGL_COLOR_BUFFER_TYPE 0x303f
+#define EGL_RGB_BUFFER 0x308e
+#define EGL_SURFACE_TYPE 0x3033
+#define EGL_WINDOW_BIT 0x0004
+#define EGL_RENDERABLE_TYPE	0x3040
+#define EGL_OPENGL_ES_BIT 0x0001
+#define EGL_OPENGL_ES2_BIT 0x0004
+#define EGL_OPENGL_BIT 0x0008
+#define EGL_ALPHA_SIZE 0x3021
+#define EGL_BLUE_SIZE 0x3022
+#define EGL_GREEN_SIZE 0x3023
+#define EGL_RED_SIZE 0x3024
+#define EGL_DEPTH_SIZE 0x3025
+#define EGL_STENCIL_SIZE 0x3026
+#define EGL_SAMPLES	0x3031
+#define EGL_OPENGL_ES_API 0x30a0
+#define EGL_OPENGL_API 0x30a2
+#define EGL_NONE 0x3038
+#define EGL_EXTENSIONS 0x3055
+#define EGL_CONTEXT_CLIENT_VERSION 0x3098
+#define EGL_NATIVE_VISUAL_ID 0x302e
+#define EGL_NO_SURFACE ((EGLSurface) 0)
+#define EGL_NO_DISPLAY ((EGLDisplay) 0)
+#define EGL_NO_CONTEXT ((EGLContext) 0)
+#define EGL_DEFAULT_DISPLAY ((EGLNativeDisplayType) 0)
 
-// This path may need to be changed if you build GLFW using your own setup
-// We ship and use our own copy of eglext.h since GLFW uses fairly new
-// extensions and not all operating systems come with an up-to-date version
-#include "../deps/EGL/eglext.h"
+#define EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE_BIT_KHR 0x00000002
+#define EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT_KHR 0x00000001
+#define EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT_KHR 0x00000002
+#define EGL_CONTEXT_OPENGL_DEBUG_BIT_KHR 0x00000001
+#define EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_KHR 0x31bd
+#define EGL_NO_RESET_NOTIFICATION_KHR 0x31be
+#define EGL_LOSE_CONTEXT_ON_RESET_KHR 0x31bf
+#define EGL_CONTEXT_OPENGL_ROBUST_ACCESS_BIT_KHR 0x00000004
+#define EGL_CONTEXT_MAJOR_VERSION_KHR 0x3098
+#define EGL_CONTEXT_MINOR_VERSION_KHR 0x30fb
+#define EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR 0x30fd
+#define EGL_CONTEXT_FLAGS_KHR 0x30fc
+#define EGL_CONTEXT_OPENGL_NO_ERROR_KHR 0x31b3
+#define EGL_GL_COLORSPACE_KHR 0x309d
+#define EGL_GL_COLORSPACE_SRGB_KHR 0x3089
+
+typedef int EGLint;
+typedef unsigned int EGLBoolean;
+typedef unsigned int EGLenum;
+typedef void* EGLConfig;
+typedef void* EGLContext;
+typedef void* EGLDisplay;
+typedef void* EGLSurface;
 
 // EGL function pointer typedefs
 typedef EGLBoolean (EGLAPIENTRY * PFNEGLGETCONFIGATTRIBPROC)(EGLDisplay,EGLConfig,EGLint,EGLint*);
@@ -63,26 +132,25 @@ typedef EGLBoolean (EGLAPIENTRY * PFNEGLSWAPBUFFERSPROC)(EGLDisplay,EGLSurface);
 typedef EGLBoolean (EGLAPIENTRY * PFNEGLSWAPINTERVALPROC)(EGLDisplay,EGLint);
 typedef const char* (EGLAPIENTRY * PFNEGLQUERYSTRINGPROC)(EGLDisplay,EGLint);
 typedef GLFWglproc (EGLAPIENTRY * PFNEGLGETPROCADDRESSPROC)(const char*);
-#define _glfw_eglGetConfigAttrib _glfw.egl.GetConfigAttrib
-#define _glfw_eglGetConfigs _glfw.egl.GetConfigs
-#define _glfw_eglGetDisplay _glfw.egl.GetDisplay
-#define _glfw_eglGetError _glfw.egl.GetError
-#define _glfw_eglInitialize _glfw.egl.Initialize
-#define _glfw_eglTerminate _glfw.egl.Terminate
-#define _glfw_eglBindAPI _glfw.egl.BindAPI
-#define _glfw_eglCreateContext _glfw.egl.CreateContext
-#define _glfw_eglDestroySurface _glfw.egl.DestroySurface
-#define _glfw_eglDestroyContext _glfw.egl.DestroyContext
-#define _glfw_eglCreateWindowSurface _glfw.egl.CreateWindowSurface
-#define _glfw_eglMakeCurrent _glfw.egl.MakeCurrent
-#define _glfw_eglSwapBuffers _glfw.egl.SwapBuffers
-#define _glfw_eglSwapInterval _glfw.egl.SwapInterval
-#define _glfw_eglQueryString _glfw.egl.QueryString
-#define _glfw_eglGetProcAddress _glfw.egl.GetProcAddress
+#define eglGetConfigAttrib _glfw.egl.GetConfigAttrib
+#define eglGetConfigs _glfw.egl.GetConfigs
+#define eglGetDisplay _glfw.egl.GetDisplay
+#define eglGetError _glfw.egl.GetError
+#define eglInitialize _glfw.egl.Initialize
+#define eglTerminate _glfw.egl.Terminate
+#define eglBindAPI _glfw.egl.BindAPI
+#define eglCreateContext _glfw.egl.CreateContext
+#define eglDestroySurface _glfw.egl.DestroySurface
+#define eglDestroyContext _glfw.egl.DestroyContext
+#define eglCreateWindowSurface _glfw.egl.CreateWindowSurface
+#define eglMakeCurrent _glfw.egl.MakeCurrent
+#define eglSwapBuffers _glfw.egl.SwapBuffers
+#define eglSwapInterval _glfw.egl.SwapInterval
+#define eglQueryString _glfw.egl.QueryString
+#define eglGetProcAddress _glfw.egl.GetProcAddress
 
-#define _GLFW_PLATFORM_FBCONFIG                 EGLConfig       egl
-#define _GLFW_PLATFORM_CONTEXT_STATE            _GLFWcontextEGL egl
-#define _GLFW_PLATFORM_LIBRARY_CONTEXT_STATE    _GLFWlibraryEGL egl
+#define _GLFW_EGL_CONTEXT_STATE            _GLFWcontextEGL egl
+#define _GLFW_EGL_LIBRARY_CONTEXT_STATE    _GLFWlibraryEGL egl
 
 
 // EGL-specific per-context data
@@ -90,13 +158,9 @@ typedef GLFWglproc (EGLAPIENTRY * PFNEGLGETPROCADDRESSPROC)(const char*);
 typedef struct _GLFWcontextEGL
 {
    EGLConfig        config;
-   EGLContext       context;
+   EGLContext       handle;
    EGLSurface       surface;
 
-#if defined(_GLFW_X11)
-   XVisualInfo*     visual;
-#endif
-
    void*            client;
 
 } _GLFWcontextEGL;
@@ -109,7 +173,9 @@ typedef struct _GLFWlibraryEGL
     EGLDisplay      display;
     EGLint          major, minor;
 
-    GLboolean       KHR_create_context;
+    GLFWbool        KHR_create_context;
+    GLFWbool        KHR_create_context_no_error;
+    GLFWbool        KHR_gl_colorspace;
 
     void*           handle;
 
@@ -133,14 +199,15 @@ typedef struct _GLFWlibraryEGL
 } _GLFWlibraryEGL;
 
 
-int _glfwInitContextAPI(void);
-void _glfwTerminateContextAPI(void);
-int _glfwCreateContext(_GLFWwindow* window,
-                       const _GLFWctxconfig* ctxconfig,
-                       const _GLFWfbconfig* fbconfig);
-void _glfwDestroyContext(_GLFWwindow* window);
-int _glfwAnalyzeContext(const _GLFWwindow* window,
-                        const _GLFWctxconfig* ctxconfig,
-                        const _GLFWfbconfig* fbconfig);
+GLFWbool _glfwInitEGL(void);
+void _glfwTerminateEGL(void);
+GLFWbool _glfwCreateContextEGL(_GLFWwindow* window,
+                               const _GLFWctxconfig* ctxconfig,
+                               const _GLFWfbconfig* fbconfig);
+#if defined(_GLFW_X11)
+GLFWbool _glfwChooseVisualEGL(const _GLFWctxconfig* ctxconfig,
+                              const _GLFWfbconfig* fbconfig,
+                              Visual** visual, int* depth);
+#endif /*_GLFW_X11*/
 
 #endif // _glfw3_egl_context_h_

src/glfw3Config.cmake.in

@@ -1,15 +1 @@
-# - Config file for the glfw3 package
-# It defines the following variables
-#   GLFW3_INCLUDE_DIR, the path where GLFW headers are located
-#   GLFW3_LIBRARY_DIR, folder in which the GLFW library is located
-#   GLFW3_LIBRARY, library to link against to use GLFW
-
-set(GLFW3_VERSION "@GLFW_VERSION_FULL@")
-
-@PACKAGE_INIT@
-
-set_and_check(GLFW3_INCLUDE_DIR "@PACKAGE_CMAKE_INSTALL_PREFIX@/include")
-set_and_check(GLFW3_LIBRARY_DIR "@PACKAGE_CMAKE_INSTALL_PREFIX@/lib@LIB_SUFFIX@")
-
-find_library(GLFW3_LIBRARY "@GLFW_LIB_NAME@" HINTS ${GLFW3_LIBRARY_DIR})
-
+include("${CMAKE_CURRENT_LIST_DIR}/glfw3Targets.cmake")

src/glfw_config.h.in

@@ -1,7 +1,7 @@
 //========================================================================
-// GLFW 3.1 - www.glfw.org
+// GLFW 3.2 - www.glfw.org
 //------------------------------------------------------------------------
-// Copyright (c) 2010 Camilla Berglund <elmindreda@elmindreda.org>
+// Copyright (c) 2010-2016 Camilla Berglund <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,23 +45,12 @@
 // Define this to 1 if building GLFW for Mir
 #cmakedefine _GLFW_MIR
 
-// Define this to 1 if building GLFW for EGL
-#cmakedefine _GLFW_EGL
-// Define this to 1 if building GLFW for GLX
-#cmakedefine _GLFW_GLX
-// Define this to 1 if building GLFW for WGL
-#cmakedefine _GLFW_WGL
-// Define this to 1 if building GLFW for NSGL
-#cmakedefine _GLFW_NSGL
-
 // Define this to 1 if building as a shared library / dynamic library / DLL
 #cmakedefine _GLFW_BUILD_DLL
 
 // Define this to 1 to force use of high-performance GPU on hybrid systems
 #cmakedefine _GLFW_USE_HYBRID_HPG
 
-// Define this to 1 if the XInput X11 extension is available
-#cmakedefine _GLFW_HAS_XINPUT
 // Define this to 1 if the Xxf86vm X11 extension is available
 #cmakedefine _GLFW_HAS_XF86VM
 
@@ -72,10 +61,3 @@
 // Define this to 1 if windows should use full resolution on Retina displays
 #cmakedefine _GLFW_USE_RETINA
 
-// Define this to 1 if using OpenGL as the client library
-#cmakedefine _GLFW_USE_OPENGL
-// Define this to 1 if using OpenGL ES 1.1 as the client library
-#cmakedefine _GLFW_USE_GLESV1
-// Define this to 1 if using OpenGL ES 2.0 as the client library
-#cmakedefine _GLFW_USE_GLESV2
-

src/glx_context.c

@@ -1,8 +1,8 @@
 //========================================================================
-// GLFW 3.1 GLX - www.glfw.org
+// GLFW 3.2 GLX - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
+// Copyright (c) 2006-2016 Camilla Berglund <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,7 +30,6 @@
 #include <string.h>
 #include <stdlib.h>
 #include <assert.h>
-#include <dlfcn.h>
 
 #ifndef GLXBadProfileARB
  #define GLXBadProfileARB 13
@@ -42,33 +41,33 @@
 static int getFBConfigAttrib(GLXFBConfig fbconfig, int attrib)
 {
     int value;
-    _glfw_glXGetFBConfigAttrib(_glfw.x11.display, fbconfig, attrib, &value);
+    glXGetFBConfigAttrib(_glfw.x11.display, fbconfig, attrib, &value);
     return value;
 }
 
 // Return a list of available and usable framebuffer configs
 //
-static GLboolean chooseFBConfig(const _GLFWfbconfig* desired, GLXFBConfig* result)
+static GLFWbool chooseFBConfig(const _GLFWfbconfig* desired, GLXFBConfig* result)
 {
     GLXFBConfig* nativeConfigs;
     _GLFWfbconfig* usableConfigs;
     const _GLFWfbconfig* closest;
     int i, nativeCount, usableCount;
     const char* vendor;
-    GLboolean trustWindowBit = GL_TRUE;
+    GLFWbool trustWindowBit = GLFW_TRUE;
 
     // HACK: This is a (hopefully temporary) workaround for Chromium
     //       (VirtualBox GL) not setting the window bit on any GLXFBConfigs
-    vendor = _glfw_glXGetClientString(_glfw.x11.display, GLX_VENDOR);
+    vendor = glXGetClientString(_glfw.x11.display, GLX_VENDOR);
     if (strcmp(vendor, "Chromium") == 0)
-        trustWindowBit = GL_FALSE;
+        trustWindowBit = GLFW_FALSE;
 
-    nativeConfigs = _glfw_glXGetFBConfigs(_glfw.x11.display, _glfw.x11.screen,
-                                          &nativeCount);
+    nativeConfigs =
+        glXGetFBConfigs(_glfw.x11.display, _glfw.x11.screen, &nativeCount);
     if (!nativeCount)
     {
         _glfwInputError(GLFW_API_UNAVAILABLE, "GLX: No GLXFBConfigs returned");
-        return GL_FALSE;
+        return GLFW_FALSE;
     }
 
     usableConfigs = calloc(nativeCount, sizeof(_GLFWfbconfig));
@@ -79,10 +78,6 @@ static GLboolean chooseFBConfig(const _GLFWfbconfig* desired, GLXFBConfig* resul
         const GLXFBConfig n = nativeConfigs[i];
         _GLFWfbconfig* u = usableConfigs + usableCount;
 
-        // Only consider GLXFBConfigs with associated visuals
-        if (!getFBConfigAttrib(n, GLX_VISUAL_ID))
-            continue;
-
         // Only consider RGBA GLXFBConfigs
         if (!(getFBConfigAttrib(n, GLX_RENDER_TYPE) & GLX_RGBA_BIT))
             continue;
@@ -110,9 +105,9 @@ static GLboolean chooseFBConfig(const _GLFWfbconfig* desired, GLXFBConfig* resul
         u->auxBuffers = getFBConfigAttrib(n, GLX_AUX_BUFFERS);
 
         if (getFBConfigAttrib(n, GLX_STEREO))
-            u->stereo = GL_TRUE;
+            u->stereo = GLFW_TRUE;
         if (getFBConfigAttrib(n, GLX_DOUBLEBUFFER))
-            u->doublebuffer = GL_TRUE;
+            u->doublebuffer = GLFW_TRUE;
 
         if (_glfw.glx.ARB_multisample)
             u->samples = getFBConfigAttrib(n, GLX_SAMPLES);
@@ -120,18 +115,18 @@ static GLboolean chooseFBConfig(const _GLFWfbconfig* desired, GLXFBConfig* resul
         if (_glfw.glx.ARB_framebuffer_sRGB || _glfw.glx.EXT_framebuffer_sRGB)
             u->sRGB = getFBConfigAttrib(n, GLX_FRAMEBUFFER_SRGB_CAPABLE_ARB);
 
-        u->glx = n;
+        u->handle = (uintptr_t) n;
         usableCount++;
     }
 
     closest = _glfwChooseFBConfig(desired, usableConfigs, usableCount);
     if (closest)
-        *result = closest->glx;
+        *result = (GLXFBConfig) closest->handle;
 
     XFree(nativeConfigs);
     free(usableConfigs);
 
-    return closest ? GL_TRUE : GL_FALSE;
+    return closest != NULL;
 }
 
 // Create the OpenGL context using legacy API
@@ -140,11 +135,101 @@ static GLXContext createLegacyContext(_GLFWwindow* window,
                                       GLXFBConfig fbconfig,
                                       GLXContext share)
 {
-    return _glfw_glXCreateNewContext(_glfw.x11.display,
-                                     fbconfig,
-                                     GLX_RGBA_TYPE,
-                                     share,
-                                     True);
+    return glXCreateNewContext(_glfw.x11.display,
+                               fbconfig,
+                               GLX_RGBA_TYPE,
+                               share,
+                               True);
+}
+
+static void makeContextCurrent(_GLFWwindow* window)
+{
+    if (window)
+    {
+        if (!glXMakeCurrent(_glfw.x11.display,
+                            window->context.glx.window,
+                            window->context.glx.handle))
+        {
+            _glfwInputError(GLFW_PLATFORM_ERROR,
+                            "GLX: Failed to make context current");
+            return;
+        }
+    }
+    else
+    {
+        if (!glXMakeCurrent(_glfw.x11.display, None, NULL))
+        {
+            _glfwInputError(GLFW_PLATFORM_ERROR,
+                            "GLX: Failed to clear current context");
+            return;
+        }
+    }
+
+    _glfwPlatformSetCurrentContext(window);
+}
+
+static void swapBuffers(_GLFWwindow* window)
+{
+    glXSwapBuffers(_glfw.x11.display, window->context.glx.window);
+}
+
+static void swapInterval(int interval)
+{
+    _GLFWwindow* window = _glfwPlatformGetCurrentContext();
+
+    if (_glfw.glx.EXT_swap_control)
+    {
+        _glfw.glx.SwapIntervalEXT(_glfw.x11.display,
+                                  window->context.glx.window,
+                                  interval);
+    }
+    else if (_glfw.glx.MESA_swap_control)
+        _glfw.glx.SwapIntervalMESA(interval);
+    else if (_glfw.glx.SGI_swap_control)
+    {
+        if (interval > 0)
+            _glfw.glx.SwapIntervalSGI(interval);
+    }
+}
+
+static int extensionSupported(const char* extension)
+{
+    const char* extensions =
+        glXQueryExtensionsString(_glfw.x11.display, _glfw.x11.screen);
+    if (extensions)
+    {
+        if (_glfwStringInExtensionString(extension, extensions))
+            return GLFW_TRUE;
+    }
+
+    return GLFW_FALSE;
+}
+
+static GLFWglproc getProcAddress(const char* procname)
+{
+    if (_glfw.glx.GetProcAddress)
+        return _glfw.glx.GetProcAddress((const GLubyte*) procname);
+    else if (_glfw.glx.GetProcAddressARB)
+        return _glfw.glx.GetProcAddressARB((const GLubyte*) procname);
+    else
+        return dlsym(_glfw.glx.handle, procname);
+}
+
+// Destroy the OpenGL context
+//
+static void destroyContext(_GLFWwindow* window)
+{
+    if (window->context.glx.window)
+    {
+        glXDestroyWindow(_glfw.x11.display, window->context.glx.window);
+        window->context.glx.window = None;
+    }
+
+    if (window->context.glx.handle)
+    {
+        glXDestroyContext(_glfw.x11.display, window->context.glx.handle);
+        window->context.glx.handle = NULL;
+    }
 }
 
 
@@ -154,22 +239,31 @@ static GLXContext createLegacyContext(_GLFWwindow* window,
 
 // Initialize GLX
 //
-int _glfwInitContextAPI(void)
+GLFWbool _glfwInitGLX(void)
 {
+    int i;
+    const char* sonames[] =
+    {
 #if defined(__CYGWIN__)
-    const char* soname = "libGL-1.so";
+        "libGL-1.so",
 #else
-    const char* soname = "libGL.so.1";
+        "libGL.so.1",
+        "libGL.so",
 #endif
+        NULL
+    };
 
-    if (!_glfwCreateContextTLS())
-        return GL_FALSE;
+    for (i = 0;  sonames[i];  i++)
+    {
+        _glfw.glx.handle = dlopen(sonames[i], RTLD_LAZY | RTLD_GLOBAL);
+        if (_glfw.glx.handle)
+            break;
+    }
 
-    _glfw.glx.handle = dlopen(soname, RTLD_LAZY | RTLD_GLOBAL);
     if (!_glfw.glx.handle)
     {
-        _glfwInputError(GLFW_API_UNAVAILABLE, "GLX: %s", dlerror());
-        return GL_FALSE;
+        _glfwInputError(GLFW_API_UNAVAILABLE, "GLX: Failed to load GLX");
+        return GLFW_FALSE;
     }
 
     _glfw.glx.GetFBConfigs =
@@ -192,111 +286,111 @@ int _glfwInitContextAPI(void)
         dlsym(_glfw.glx.handle, "glXQueryExtensionsString");
     _glfw.glx.CreateNewContext =
         dlsym(_glfw.glx.handle, "glXCreateNewContext");
-    _glfw.glx.GetVisualFromFBConfig =
-        dlsym(_glfw.glx.handle, "glXGetVisualFromFBConfig");
+    _glfw.glx.CreateWindow =
+        dlsym(_glfw.glx.handle, "glXCreateWindow");
+    _glfw.glx.DestroyWindow =
+        dlsym(_glfw.glx.handle, "glXDestroyWindow");
     _glfw.glx.GetProcAddress =
         dlsym(_glfw.glx.handle, "glXGetProcAddress");
     _glfw.glx.GetProcAddressARB =
         dlsym(_glfw.glx.handle, "glXGetProcAddressARB");
+    _glfw.glx.GetVisualFromFBConfig =
+        dlsym(_glfw.glx.handle, "glXGetVisualFromFBConfig");
 
-    if (!_glfw_glXQueryExtension(_glfw.x11.display,
-                                 &_glfw.glx.errorBase,
-                                 &_glfw.glx.eventBase))
+    if (!glXQueryExtension(_glfw.x11.display,
+                           &_glfw.glx.errorBase,
+                           &_glfw.glx.eventBase))
     {
         _glfwInputError(GLFW_API_UNAVAILABLE, "GLX: GLX extension not found");
-        return GL_FALSE;
+        return GLFW_FALSE;
     }
 
-    if (!_glfw_glXQueryVersion(_glfw.x11.display,
-                               &_glfw.glx.major,
-                               &_glfw.glx.minor))
+    if (!glXQueryVersion(_glfw.x11.display, &_glfw.glx.major, &_glfw.glx.minor))
     {
         _glfwInputError(GLFW_API_UNAVAILABLE,
                         "GLX: Failed to query GLX version");
-        return GL_FALSE;
+        return GLFW_FALSE;
     }
 
     if (_glfw.glx.major == 1 && _glfw.glx.minor < 3)
     {
         _glfwInputError(GLFW_API_UNAVAILABLE,
                         "GLX: GLX version 1.3 is required");
-        return GL_FALSE;
+        return GLFW_FALSE;
     }
 
-    if (_glfwPlatformExtensionSupported("GLX_EXT_swap_control"))
+    if (extensionSupported("GLX_EXT_swap_control"))
     {
         _glfw.glx.SwapIntervalEXT = (PFNGLXSWAPINTERVALEXTPROC)
-            _glfwPlatformGetProcAddress("glXSwapIntervalEXT");
+            getProcAddress("glXSwapIntervalEXT");
 
         if (_glfw.glx.SwapIntervalEXT)
-            _glfw.glx.EXT_swap_control = GL_TRUE;
+            _glfw.glx.EXT_swap_control = GLFW_TRUE;
     }
 
-    if (_glfwPlatformExtensionSupported("GLX_SGI_swap_control"))
+    if (extensionSupported("GLX_SGI_swap_control"))
     {
         _glfw.glx.SwapIntervalSGI = (PFNGLXSWAPINTERVALSGIPROC)
-            _glfwPlatformGetProcAddress("glXSwapIntervalSGI");
+            getProcAddress("glXSwapIntervalSGI");
 
         if (_glfw.glx.SwapIntervalSGI)
-            _glfw.glx.SGI_swap_control = GL_TRUE;
+            _glfw.glx.SGI_swap_control = GLFW_TRUE;
     }
 
-    if (_glfwPlatformExtensionSupported("GLX_MESA_swap_control"))
+    if (extensionSupported("GLX_MESA_swap_control"))
     {
         _glfw.glx.SwapIntervalMESA = (PFNGLXSWAPINTERVALMESAPROC)
-            _glfwPlatformGetProcAddress("glXSwapIntervalMESA");
+            getProcAddress("glXSwapIntervalMESA");
 
         if (_glfw.glx.SwapIntervalMESA)
-            _glfw.glx.MESA_swap_control = GL_TRUE;
+            _glfw.glx.MESA_swap_control = GLFW_TRUE;
     }
 
-    if (_glfwPlatformExtensionSupported("GLX_ARB_multisample"))
-        _glfw.glx.ARB_multisample = GL_TRUE;
+    if (extensionSupported("GLX_ARB_multisample"))
+        _glfw.glx.ARB_multisample = GLFW_TRUE;
 
-    if (_glfwPlatformExtensionSupported("GLX_ARB_framebuffer_sRGB"))
-        _glfw.glx.ARB_framebuffer_sRGB = GL_TRUE;
+    if (extensionSupported("GLX_ARB_framebuffer_sRGB"))
+        _glfw.glx.ARB_framebuffer_sRGB = GLFW_TRUE;
 
-    if (_glfwPlatformExtensionSupported("GLX_EXT_framebuffer_sRGB"))
-        _glfw.glx.EXT_framebuffer_sRGB = GL_TRUE;
+    if (extensionSupported("GLX_EXT_framebuffer_sRGB"))
+        _glfw.glx.EXT_framebuffer_sRGB = GLFW_TRUE;
 
-    if (_glfwPlatformExtensionSupported("GLX_ARB_create_context"))
+    if (extensionSupported("GLX_ARB_create_context"))
     {
         _glfw.glx.CreateContextAttribsARB = (PFNGLXCREATECONTEXTATTRIBSARBPROC)
-            _glfwPlatformGetProcAddress("glXCreateContextAttribsARB");
+            getProcAddress("glXCreateContextAttribsARB");
 
         if (_glfw.glx.CreateContextAttribsARB)
-            _glfw.glx.ARB_create_context = GL_TRUE;
+            _glfw.glx.ARB_create_context = GLFW_TRUE;
     }
 
-    if (_glfwPlatformExtensionSupported("GLX_ARB_create_context_robustness"))
-        _glfw.glx.ARB_create_context_robustness = GL_TRUE;
+    if (extensionSupported("GLX_ARB_create_context_robustness"))
+        _glfw.glx.ARB_create_context_robustness = GLFW_TRUE;
 
-    if (_glfwPlatformExtensionSupported("GLX_ARB_create_context_profile"))
-        _glfw.glx.ARB_create_context_profile = GL_TRUE;
+    if (extensionSupported("GLX_ARB_create_context_profile"))
+        _glfw.glx.ARB_create_context_profile = GLFW_TRUE;
 
-    if (_glfwPlatformExtensionSupported("GLX_EXT_create_context_es2_profile"))
-        _glfw.glx.EXT_create_context_es2_profile = GL_TRUE;
+    if (extensionSupported("GLX_EXT_create_context_es2_profile"))
+        _glfw.glx.EXT_create_context_es2_profile = GLFW_TRUE;
 
-    if (_glfwPlatformExtensionSupported("GLX_ARB_context_flush_control"))
-        _glfw.glx.ARB_context_flush_control = GL_TRUE;
+    if (extensionSupported("GLX_ARB_context_flush_control"))
+        _glfw.glx.ARB_context_flush_control = GLFW_TRUE;
 
-    return GL_TRUE;
+    return GLFW_TRUE;
 }
 
 // Terminate GLX
 //
-void _glfwTerminateContextAPI(void)
+void _glfwTerminateGLX(void)
 {
-    // NOTE: This function may not call any X11 functions, as it is called after
-    //       XCloseDisplay (see _glfwPlatformTerminate for details)
+    // NOTE: This function must not call any X11 functions, as it is called
+    //       after XCloseDisplay (see _glfwPlatformTerminate for details)
 
     if (_glfw.glx.handle)
     {
         dlclose(_glfw.glx.handle);
         _glfw.glx.handle = NULL;
     }
-
-    _glfwDestroyContextTLS();
 }
 
 #define setGLXattrib(attribName, attribValue) \
@@ -308,34 +402,25 @@ void _glfwTerminateContextAPI(void)
 
 // Create the OpenGL or OpenGL ES context
 //
-int _glfwCreateContext(_GLFWwindow* window,
-                       const _GLFWctxconfig* ctxconfig,
-                       const _GLFWfbconfig* fbconfig)
+GLFWbool _glfwCreateContextGLX(_GLFWwindow* window,
+                               const _GLFWctxconfig* ctxconfig,
+                               const _GLFWfbconfig* fbconfig)
 {
     int attribs[40];
     GLXFBConfig native = NULL;
     GLXContext share = NULL;
 
     if (ctxconfig->share)
-        share = ctxconfig->share->glx.context;
+        share = ctxconfig->share->context.glx.handle;
 
     if (!chooseFBConfig(fbconfig, &native))
     {
         _glfwInputError(GLFW_FORMAT_UNAVAILABLE,
                         "GLX: Failed to find a suitable GLXFBConfig");
-        return GL_FALSE;
+        return GLFW_FALSE;
     }
 
-    window->glx.visual = _glfw_glXGetVisualFromFBConfig(_glfw.x11.display,
-                                                        native);
-    if (!window->glx.visual)
-    {
-        _glfwInputError(GLFW_PLATFORM_ERROR,
-                        "GLX: Failed to retrieve visual for GLXFBConfig");
-        return GL_FALSE;
-    }
-
-    if (ctxconfig->api == GLFW_OPENGL_ES_API)
+    if (ctxconfig->client == GLFW_OPENGL_ES_API)
     {
         if (!_glfw.glx.ARB_create_context ||
             !_glfw.glx.ARB_create_context_profile ||
@@ -343,7 +428,7 @@ int _glfwCreateContext(_GLFWwindow* window,
         {
             _glfwInputError(GLFW_API_UNAVAILABLE,
                             "GLX: OpenGL ES requested but GLX_EXT_create_context_es2_profile is unavailable");
-            return GL_FALSE;
+            return GLFW_FALSE;
         }
     }
 
@@ -353,7 +438,7 @@ int _glfwCreateContext(_GLFWwindow* window,
         {
             _glfwInputError(GLFW_VERSION_UNAVAILABLE,
                             "GLX: Forward compatibility requested but GLX_ARB_create_context_profile is unavailable");
-            return GL_FALSE;
+            return GLFW_FALSE;
         }
     }
 
@@ -364,17 +449,17 @@ int _glfwCreateContext(_GLFWwindow* window,
         {
             _glfwInputError(GLFW_VERSION_UNAVAILABLE,
                             "GLX: An OpenGL profile requested but GLX_ARB_create_context_profile is unavailable");
-            return GL_FALSE;
+            return GLFW_FALSE;
         }
     }
 
-    _glfwGrabXErrorHandler();
+    _glfwGrabErrorHandlerX11();
 
     if (_glfw.glx.ARB_create_context)
     {
         int index = 0, mask = 0, flags = 0;
 
-        if (ctxconfig->api == GLFW_OPENGL_API)
+        if (ctxconfig->client == GLFW_OPENGL_API)
         {
             if (ctxconfig->forward)
                 flags |= GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB;
@@ -389,6 +474,8 @@ int _glfwCreateContext(_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)
         {
@@ -443,7 +530,7 @@ int _glfwCreateContext(_GLFWwindow* window,
 
         setGLXattrib(None, None);
 
-        window->glx.context =
+        window->context.glx.handle =
             _glfw.glx.CreateContextAttribsARB(_glfw.x11.display,
                                               native,
                                               share,
@@ -454,114 +541,78 @@ int _glfwCreateContext(_GLFWwindow* window,
         //       implementation of GLX_ARB_create_context_profile that fail
         //       default 1.0 context creation with a GLXBadProfileARB error in
         //       violation of the extension spec
-        if (!window->glx.context)
+        if (!window->context.glx.handle)
         {
             if (_glfw.x11.errorCode == _glfw.glx.errorBase + GLXBadProfileARB &&
-                ctxconfig->api == GLFW_OPENGL_API &&
+                ctxconfig->client == GLFW_OPENGL_API &&
                 ctxconfig->profile == GLFW_OPENGL_ANY_PROFILE &&
-                ctxconfig->forward == GL_FALSE)
+                ctxconfig->forward == GLFW_FALSE)
             {
-                window->glx.context = createLegacyContext(window, native, share);
+                window->context.glx.handle =
+                    createLegacyContext(window, native, share);
             }
         }
     }
     else
-        window->glx.context = createLegacyContext(window, native, share);
+        window->context.glx.handle = createLegacyContext(window, native, share);
 
-    _glfwReleaseXErrorHandler();
+    _glfwReleaseErrorHandlerX11();
 
-    if (!window->glx.context)
+    if (!window->context.glx.handle)
     {
-        _glfwInputXError(GLFW_VERSION_UNAVAILABLE, "GLX: Failed to create context");
-        return GL_FALSE;
+        _glfwInputErrorX11(GLFW_VERSION_UNAVAILABLE, "GLX: Failed to create context");
+        return GLFW_FALSE;
     }
 
-    return GL_TRUE;
+    window->context.glx.window =
+        glXCreateWindow(_glfw.x11.display, native, window->x11.handle, NULL);
+    if (!window->context.glx.window)
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR, "GLX: Failed to create window");
+        return GLFW_FALSE;
+    }
+
+    window->context.makeCurrent = makeContextCurrent;
+    window->context.swapBuffers = swapBuffers;
+    window->context.swapInterval = swapInterval;
+    window->context.extensionSupported = extensionSupported;
+    window->context.getProcAddress = getProcAddress;
+    window->context.destroy = destroyContext;
+
+    return GLFW_TRUE;
 }
 
 #undef setGLXattrib
 
-// Destroy the OpenGL context
+// Returns the Visual and depth of the chosen GLXFBConfig
 //
-void _glfwDestroyContext(_GLFWwindow* window)
+GLFWbool _glfwChooseVisualGLX(const _GLFWctxconfig* ctxconfig,
+                              const _GLFWfbconfig* fbconfig,
+                              Visual** visual, int* depth)
 {
-    if (window->glx.visual)
+    GLXFBConfig native;
+    XVisualInfo* result;
+
+    if (!chooseFBConfig(fbconfig, &native))
     {
-        XFree(window->glx.visual);
-        window->glx.visual = NULL;
+        _glfwInputError(GLFW_FORMAT_UNAVAILABLE,
+                        "GLX: Failed to find a suitable GLXFBConfig");
+        return GLFW_FALSE;
     }
 
-    if (window->glx.context)
+    result = glXGetVisualFromFBConfig(_glfw.x11.display, native);
+    if (!result)
     {
-        _glfw_glXDestroyContext(_glfw.x11.display, window->glx.context);
-        window->glx.context = NULL;
-    }
-}
-
-
-//////////////////////////////////////////////////////////////////////////
-//////                       GLFW platform API                      //////
-//////////////////////////////////////////////////////////////////////////
-
-void _glfwPlatformMakeContextCurrent(_GLFWwindow* window)
-{
-    if (window)
-    {
-        _glfw_glXMakeCurrent(_glfw.x11.display,
-                             window->x11.handle,
-                             window->glx.context);
-    }
-    else
-        _glfw_glXMakeCurrent(_glfw.x11.display, None, NULL);
-
-    _glfwSetContextTLS(window);
-}
-
-void _glfwPlatformSwapBuffers(_GLFWwindow* window)
-{
-    _glfw_glXSwapBuffers(_glfw.x11.display, window->x11.handle);
-}
-
-void _glfwPlatformSwapInterval(int interval)
-{
-    _GLFWwindow* window = _glfwPlatformGetCurrentContext();
-
-    if (_glfw.glx.EXT_swap_control)
-    {
-        _glfw.glx.SwapIntervalEXT(_glfw.x11.display,
-                                  window->x11.handle,
-                                  interval);
-    }
-    else if (_glfw.glx.MESA_swap_control)
-        _glfw.glx.SwapIntervalMESA(interval);
-    else if (_glfw.glx.SGI_swap_control)
-    {
-        if (interval > 0)
-            _glfw.glx.SwapIntervalSGI(interval);
-    }
-}
-
-int _glfwPlatformExtensionSupported(const char* extension)
-{
-    const char* extensions =
-        _glfw_glXQueryExtensionsString(_glfw.x11.display, _glfw.x11.screen);
-    if (extensions)
-    {
-        if (_glfwStringInExtensionString(extension, extensions))
-            return GL_TRUE;
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "GLX: Failed to retrieve Visual for GLXFBConfig");
+        return GLFW_FALSE;
     }
 
-    return GL_FALSE;
-}
+    *visual = result->visual;
+    *depth = result->depth;
 
-GLFWglproc _glfwPlatformGetProcAddress(const char* procname)
-{
-    if (_glfw.glx.GetProcAddress)
-        return _glfw.glx.GetProcAddress((const GLubyte*) procname);
-    else if (_glfw.glx.GetProcAddressARB)
-        return _glfw.glx.GetProcAddressARB((const GLubyte*) procname);
-    else
-        return dlsym(_glfw.glx.handle, procname);
+    XFree(result);
+    return GLFW_TRUE;
 }
 
 
@@ -573,6 +624,27 @@ GLFWAPI GLXContext glfwGetGLXContext(GLFWwindow* handle)
 {
     _GLFWwindow* window = (_GLFWwindow*) handle;
     _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
-    return window->glx.context;
+
+    if (window->context.client == GLFW_NO_API)
+    {
+        _glfwInputError(GLFW_NO_WINDOW_CONTEXT, NULL);
+        return NULL;
+    }
+
+    return window->context.glx.handle;
+}
+
+GLFWAPI GLXWindow glfwGetGLXWindow(GLFWwindow* handle)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    _GLFW_REQUIRE_INIT_OR_RETURN(None);
+
+    if (window->context.client == GLFW_NO_API)
+    {
+        _glfwInputError(GLFW_NO_WINDOW_CONTEXT, NULL);
+        return None;
+    }
+
+    return window->context.glx.window;
 }
 

src/glx_context.h

@@ -1,8 +1,8 @@
 //========================================================================
-// GLFW 3.1 GLX - www.glfw.org
+// GLFW 3.2 GLX - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
+// Copyright (c) 2006-2016 Camilla Berglund <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,16 +28,52 @@
 #ifndef _glfw3_glx_context_h_
 #define _glfw3_glx_context_h_
 
-#define GLX_GLXEXT_LEGACY
-#include <GL/glx.h>
+#define GLX_VENDOR 1
+#define GLX_RGBA_BIT 0x00000001
+#define GLX_WINDOW_BIT 0x00000001
+#define GLX_DRAWABLE_TYPE 0x8010
+#define GLX_RENDER_TYPE	0x8011
+#define GLX_RGBA_TYPE 0x8014
+#define GLX_DOUBLEBUFFER 5
+#define GLX_STEREO 6
+#define GLX_AUX_BUFFERS	7
+#define GLX_RED_SIZE 8
+#define GLX_GREEN_SIZE 9
+#define GLX_BLUE_SIZE 10
+#define GLX_ALPHA_SIZE 11
+#define GLX_DEPTH_SIZE 12
+#define GLX_STENCIL_SIZE 13
+#define GLX_ACCUM_RED_SIZE 14
+#define GLX_ACCUM_GREEN_SIZE 15
+#define GLX_ACCUM_BLUE_SIZE	16
+#define GLX_ACCUM_ALPHA_SIZE 17
+#define GLX_SAMPLES 0x186a1
+#define GLX_VISUAL_ID 0x800b
 
-// This path may need to be changed if you build GLFW using your own setup
-// We ship and use our own copy of glxext.h since GLFW uses fairly new
-// extensions and not all operating systems come with an up-to-date version
-#define GLX_GLXEXT_PROTOTYPES
-#include "../deps/GL/glxext.h"
+#define GLX_FRAMEBUFFER_SRGB_CAPABLE_ARB 0x20b2
+#define GLX_CONTEXT_DEBUG_BIT_ARB 0x00000001
+#define GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB 0x00000002
+#define GLX_CONTEXT_CORE_PROFILE_BIT_ARB 0x00000001
+#define GLX_CONTEXT_PROFILE_MASK_ARB 0x9126
+#define GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB 0x00000002
+#define GLX_CONTEXT_MAJOR_VERSION_ARB 0x2091
+#define GLX_CONTEXT_MINOR_VERSION_ARB 0x2092
+#define GLX_CONTEXT_FLAGS_ARB 0x2094
+#define GLX_CONTEXT_ES2_PROFILE_BIT_EXT 0x00000004
+#define GLX_CONTEXT_ROBUST_ACCESS_BIT_ARB 0x00000004
+#define GLX_LOSE_CONTEXT_ON_RESET_ARB 0x8252
+#define GLX_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB 0x8256
+#define GLX_NO_RESET_NOTIFICATION_ARB 0x8261
+#define GLX_CONTEXT_RELEASE_BEHAVIOR_ARB 0x2097
+#define GLX_CONTEXT_RELEASE_BEHAVIOR_NONE_ARB 0
+#define GLX_CONTEXT_RELEASE_BEHAVIOR_FLUSH_ARB 0x2098
+
+typedef XID GLXWindow;
+typedef XID GLXDrawable;
+typedef struct __GLXFBConfig* GLXFBConfig;
+typedef struct __GLXcontext* GLXContext;
+typedef void (*__GLXextproc)(void);
 
-// libGL.so function pointer typedefs
 typedef int (*PFNGLXGETFBCONFIGATTRIBPROC)(Display*,GLXFBConfig,int,int*);
 typedef const char* (*PFNGLXGETCLIENTSTRINGPROC)(Display*,int);
 typedef Bool (*PFNGLXQUERYEXTENSIONPROC)(Display*,int*,int*);
@@ -46,35 +82,42 @@ typedef void (*PFNGLXDESTROYCONTEXTPROC)(Display*,GLXContext);
 typedef Bool (*PFNGLXMAKECURRENTPROC)(Display*,GLXDrawable,GLXContext);
 typedef void (*PFNGLXSWAPBUFFERSPROC)(Display*,GLXDrawable);
 typedef const char* (*PFNGLXQUERYEXTENSIONSSTRINGPROC)(Display*,int);
-#define _glfw_glXGetFBConfigs _glfw.glx.GetFBConfigs
-#define _glfw_glXGetFBConfigAttrib _glfw.glx.GetFBConfigAttrib
-#define _glfw_glXGetClientString _glfw.glx.GetClientString
-#define _glfw_glXQueryExtension _glfw.glx.QueryExtension
-#define _glfw_glXQueryVersion _glfw.glx.QueryVersion
-#define _glfw_glXDestroyContext _glfw.glx.DestroyContext
-#define _glfw_glXMakeCurrent _glfw.glx.MakeCurrent
-#define _glfw_glXSwapBuffers _glfw.glx.SwapBuffers
-#define _glfw_glXQueryExtensionsString _glfw.glx.QueryExtensionsString
-#define _glfw_glXCreateNewContext _glfw.glx.CreateNewContext
-#define _glfw_glXGetVisualFromFBConfig _glfw.glx.GetVisualFromFBConfig
+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);
+
+// libGL.so function pointer typedefs
+#define glXGetFBConfigs _glfw.glx.GetFBConfigs
+#define glXGetFBConfigAttrib _glfw.glx.GetFBConfigAttrib
+#define glXGetClientString _glfw.glx.GetClientString
+#define glXQueryExtension _glfw.glx.QueryExtension
+#define glXQueryVersion _glfw.glx.QueryVersion
+#define glXDestroyContext _glfw.glx.DestroyContext
+#define glXMakeCurrent _glfw.glx.MakeCurrent
+#define glXSwapBuffers _glfw.glx.SwapBuffers
+#define glXQueryExtensionsString _glfw.glx.QueryExtensionsString
+#define glXCreateNewContext _glfw.glx.CreateNewContext
+#define glXGetVisualFromFBConfig _glfw.glx.GetVisualFromFBConfig
+#define glXCreateWindow _glfw.glx.CreateWindow
+#define glXDestroyWindow _glfw.glx.DestroyWindow
 
-#define _GLFW_PLATFORM_FBCONFIG                 GLXFBConfig     glx
 #define _GLFW_PLATFORM_CONTEXT_STATE            _GLFWcontextGLX glx
 #define _GLFW_PLATFORM_LIBRARY_CONTEXT_STATE    _GLFWlibraryGLX glx
 
-#ifndef GLX_MESA_swap_control
-typedef int (*PFNGLXSWAPINTERVALMESAPROC)(int);
-#endif
-
 
 // GLX-specific per-context data
 //
 typedef struct _GLFWcontextGLX
 {
-    // Rendering context
-    GLXContext      context;
-    // Visual of selected GLXFBConfig
-    XVisualInfo*    visual;
+    GLXContext      handle;
+    GLXWindow       window;
 
 } _GLFWcontextGLX;
 
@@ -102,6 +145,8 @@ typedef struct _GLFWlibraryGLX
     PFNGLXQUERYEXTENSIONSSTRINGPROC     QueryExtensionsString;
     PFNGLXCREATENEWCONTEXTPROC          CreateNewContext;
     PFNGLXGETVISUALFROMFBCONFIGPROC     GetVisualFromFBConfig;
+    PFNGLXCREATEWINDOWPROC              CreateWindow;
+    PFNGLXDESTROYWINDOWPROC             DestroyWindow;
 
     // GLX 1.4 and extension functions
     PFNGLXGETPROCADDRESSPROC            GetProcAddress;
@@ -110,26 +155,29 @@ typedef struct _GLFWlibraryGLX
     PFNGLXSWAPINTERVALEXTPROC           SwapIntervalEXT;
     PFNGLXSWAPINTERVALMESAPROC          SwapIntervalMESA;
     PFNGLXCREATECONTEXTATTRIBSARBPROC   CreateContextAttribsARB;
-    GLboolean       SGI_swap_control;
-    GLboolean       EXT_swap_control;
-    GLboolean       MESA_swap_control;
-    GLboolean       ARB_multisample;
-    GLboolean       ARB_framebuffer_sRGB;
-    GLboolean       EXT_framebuffer_sRGB;
-    GLboolean       ARB_create_context;
-    GLboolean       ARB_create_context_profile;
-    GLboolean       ARB_create_context_robustness;
-    GLboolean       EXT_create_context_es2_profile;
-    GLboolean       ARB_context_flush_control;
+    GLFWbool        SGI_swap_control;
+    GLFWbool        EXT_swap_control;
+    GLFWbool        MESA_swap_control;
+    GLFWbool        ARB_multisample;
+    GLFWbool        ARB_framebuffer_sRGB;
+    GLFWbool        EXT_framebuffer_sRGB;
+    GLFWbool        ARB_create_context;
+    GLFWbool        ARB_create_context_profile;
+    GLFWbool        ARB_create_context_robustness;
+    GLFWbool        EXT_create_context_es2_profile;
+    GLFWbool        ARB_context_flush_control;
 
 } _GLFWlibraryGLX;
 
 
-int _glfwInitContextAPI(void);
-void _glfwTerminateContextAPI(void);
-int _glfwCreateContext(_GLFWwindow* window,
-                       const _GLFWctxconfig* ctxconfig,
-                       const _GLFWfbconfig* fbconfig);
-void _glfwDestroyContext(_GLFWwindow* window);
+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,
+                              const _GLFWfbconfig* fbconfig,
+                              Visual** visual, int* depth);
 
 #endif // _glfw3_glx_context_h_

src/init.c

@@ -1,8 +1,8 @@
 //========================================================================
-// GLFW 3.1 - www.glfw.org
+// GLFW 3.2 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
+// Copyright (c) 2006-2016 Camilla Berglund <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
@@ -39,7 +39,7 @@
 // Global state shared between compilation units of GLFW
 // These are documented in internal.h
 //
-GLboolean _glfwInitialized = GL_FALSE;
+GLFWbool _glfwInitialized = GLFW_FALSE;
 _GLFWlibrary _glfw;
 
 // This is outside of _glfw so it can be initialized and usable before
@@ -72,9 +72,11 @@ static const char* getErrorString(int error)
             return "A platform-specific error occurred";
         case GLFW_FORMAT_UNAVAILABLE:
             return "The requested format is unavailable";
+        case GLFW_NO_WINDOW_CONTEXT:
+            return "The specified window has no context";
+        default:
+            return "ERROR: UNKNOWN GLFW ERROR";
     }
-
-    return "ERROR: UNKNOWN ERROR TOKEN PASSED TO glfwErrorString";
 }
 
 
@@ -118,23 +120,27 @@ void _glfwInputError(int error, const char* format, ...)
 GLFWAPI int glfwInit(void)
 {
     if (_glfwInitialized)
-        return GL_TRUE;
+        return GLFW_TRUE;
 
     memset(&_glfw, 0, sizeof(_glfw));
 
     if (!_glfwPlatformInit())
     {
         _glfwPlatformTerminate();
-        return GL_FALSE;
+        return GLFW_FALSE;
     }
 
+    _glfwInitVulkan();
+
     _glfw.monitors = _glfwPlatformGetMonitors(&_glfw.monitorCount);
-    _glfwInitialized = GL_TRUE;
+    _glfwInitialized = GLFW_TRUE;
+
+    _glfw.timerOffset = _glfwPlatformGetTimerValue();
 
     // Not all window hints have zero as their default value
     glfwDefaultWindowHints();
 
-    return GL_TRUE;
+    return GLFW_TRUE;
 }
 
 GLFWAPI void glfwTerminate(void)
@@ -159,6 +165,8 @@ GLFWAPI void glfwTerminate(void)
             _glfwPlatformSetGammaRamp(monitor, &monitor->originalRamp);
     }
 
+    _glfwTerminateVulkan();
+
     _glfwFreeMonitors(_glfw.monitors, _glfw.monitorCount);
     _glfw.monitors = NULL;
     _glfw.monitorCount = 0;
@@ -166,7 +174,7 @@ GLFWAPI void glfwTerminate(void)
     _glfwPlatformTerminate();
 
     memset(&_glfw, 0, sizeof(_glfw));
-    _glfwInitialized = GL_FALSE;
+    _glfwInitialized = GLFW_FALSE;
 }
 
 GLFWAPI void glfwGetVersion(int* major, int* minor, int* rev)

src/input.c

@@ -1,8 +1,8 @@
 //========================================================================
-// GLFW 3.1 - www.glfw.org
+// GLFW 3.2 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
+// Copyright (c) 2006-2016 Camilla Berglund <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,106 +27,14 @@
 
 #include "internal.h"
 
+#include <assert.h>
+#include <float.h>
 #include <stdlib.h>
-#if defined(_MSC_VER)
- #include <malloc.h>
-#endif
 
 // Internal key state used for sticky keys
 #define _GLFW_STICK 3
 
 
-// Sets the cursor mode for the specified window
-//
-static void setCursorMode(_GLFWwindow* window, int newMode)
-{
-    const int oldMode = window->cursorMode;
-
-    if (newMode != GLFW_CURSOR_NORMAL &&
-        newMode != GLFW_CURSOR_HIDDEN &&
-        newMode != GLFW_CURSOR_DISABLED)
-    {
-        _glfwInputError(GLFW_INVALID_ENUM, "Invalid cursor mode");
-        return;
-    }
-
-    if (oldMode == newMode)
-        return;
-
-    window->cursorMode = newMode;
-
-    if (_glfw.cursorWindow == window)
-    {
-        if (oldMode == GLFW_CURSOR_DISABLED)
-        {
-            _glfwPlatformSetCursorPos(window,
-                                      _glfw.cursorPosX,
-                                      _glfw.cursorPosY);
-        }
-        else if (newMode == GLFW_CURSOR_DISABLED)
-        {
-            int width, height;
-
-            _glfwPlatformGetCursorPos(window,
-                                      &_glfw.cursorPosX,
-                                      &_glfw.cursorPosY);
-
-            window->cursorPosX = _glfw.cursorPosX;
-            window->cursorPosY = _glfw.cursorPosY;
-
-            _glfwPlatformGetWindowSize(window, &width, &height);
-            _glfwPlatformSetCursorPos(window, width / 2, height / 2);
-        }
-
-        _glfwPlatformApplyCursorMode(window);
-    }
-}
-
-// Set sticky keys mode for the specified window
-//
-static void setStickyKeys(_GLFWwindow* window, int enabled)
-{
-    if (window->stickyKeys == enabled)
-        return;
-
-    if (!enabled)
-    {
-        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 = enabled;
-}
-
-// Set sticky mouse buttons mode for the specified window
-//
-static void setStickyMouseButtons(_GLFWwindow* window, int enabled)
-{
-    if (window->stickyMouseButtons == enabled)
-        return;
-
-    if (!enabled)
-    {
-        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 = enabled;
-}
-
-
 //////////////////////////////////////////////////////////////////////////
 //////                         GLFW event API                       //////
 //////////////////////////////////////////////////////////////////////////
@@ -135,13 +43,13 @@ void _glfwInputKey(_GLFWwindow* window, int key, int scancode, int action, int m
 {
     if (key >= 0 && key <= GLFW_KEY_LAST)
     {
-        GLboolean repeated = GL_FALSE;
+        GLFWbool repeated = GLFW_FALSE;
 
         if (action == GLFW_RELEASE && window->keys[key] == GLFW_RELEASE)
             return;
 
         if (action == GLFW_PRESS && window->keys[key] == GLFW_PRESS)
-            repeated = GL_TRUE;
+            repeated = GLFW_TRUE;
 
         if (action == GLFW_RELEASE && window->stickyKeys)
             window->keys[key] = _GLFW_STICK;
@@ -156,7 +64,7 @@ void _glfwInputKey(_GLFWwindow* window, int key, int scancode, int action, int m
         window->callbacks.key((GLFWwindow*) window, key, scancode, action, mods);
 }
 
-void _glfwInputChar(_GLFWwindow* window, unsigned int codepoint, int mods, int plain)
+void _glfwInputChar(_GLFWwindow* window, unsigned int codepoint, int mods, GLFWbool plain)
 {
     if (codepoint < 32 || (codepoint > 126 && codepoint < 160))
         return;
@@ -192,25 +100,19 @@ void _glfwInputMouseClick(_GLFWwindow* window, int button, int action, int mods)
         window->callbacks.mouseButton((GLFWwindow*) window, button, action, mods);
 }
 
-void _glfwInputCursorMotion(_GLFWwindow* window, double x, double y)
+void _glfwInputCursorPos(_GLFWwindow* window, double xpos, double ypos)
 {
-    if (window->cursorMode == GLFW_CURSOR_DISABLED)
-    {
-        if (x == 0.0 && y == 0.0)
-            return;
+    if (window->virtualCursorPosX == xpos && window->virtualCursorPosY == ypos)
+        return;
 
-        window->cursorPosX += x;
-        window->cursorPosY += y;
-
-        x = window->cursorPosX;
-        y = window->cursorPosY;
-    }
+    window->virtualCursorPosX = xpos;
+    window->virtualCursorPosY = ypos;
 
     if (window->callbacks.cursorPos)
-        window->callbacks.cursorPos((GLFWwindow*) window, x, y);
+        window->callbacks.cursorPos((GLFWwindow*) window, xpos, ypos);
 }
 
-void _glfwInputCursorEnter(_GLFWwindow* window, int entered)
+void _glfwInputCursorEnter(_GLFWwindow* window, GLFWbool entered)
 {
     if (window->callbacks.cursorEnter)
         window->callbacks.cursorEnter((GLFWwindow*) window, entered);
@@ -222,6 +124,24 @@ void _glfwInputDrop(_GLFWwindow* window, int count, const char** paths)
         window->callbacks.drop((GLFWwindow*) window, count, paths);
 }
 
+void _glfwInputJoystickChange(int joy, int event)
+{
+    if (_glfw.callbacks.joystick)
+        _glfw.callbacks.joystick(joy, event);
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW internal API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+GLFWbool _glfwIsPrintable(int key)
+{
+    return (key >= GLFW_KEY_APOSTROPHE && key <= GLFW_KEY_WORLD_2) ||
+           (key >= GLFW_KEY_KP_0 && key <= GLFW_KEY_KP_ADD) ||
+           key == GLFW_KEY_KP_EQUAL;
+}
+
 
 //////////////////////////////////////////////////////////////////////////
 //////                        GLFW public API                       //////
@@ -230,6 +150,7 @@ void _glfwInputDrop(_GLFWwindow* window, int count, const char** paths)
 GLFWAPI int glfwGetInputMode(GLFWwindow* handle, int mode)
 {
     _GLFWwindow* window = (_GLFWwindow*) handle;
+    assert(window != NULL);
 
     _GLFW_REQUIRE_INIT_OR_RETURN(0);
 
@@ -242,7 +163,7 @@ GLFWAPI int glfwGetInputMode(GLFWwindow* handle, int mode)
         case GLFW_STICKY_MOUSE_BUTTONS:
             return window->stickyMouseButtons;
         default:
-            _glfwInputError(GLFW_INVALID_ENUM, "Invalid input mode");
+            _glfwInputError(GLFW_INVALID_ENUM, "Invalid input mode %i", mode);
             return 0;
     }
 }
@@ -250,35 +171,101 @@ GLFWAPI int glfwGetInputMode(GLFWwindow* handle, int mode)
 GLFWAPI void glfwSetInputMode(GLFWwindow* handle, int mode, int value)
 {
     _GLFWwindow* window = (_GLFWwindow*) handle;
+    assert(window != NULL);
 
     _GLFW_REQUIRE_INIT();
 
     switch (mode)
     {
         case GLFW_CURSOR:
-            setCursorMode(window, value);
-            break;
+        {
+            if (value != GLFW_CURSOR_NORMAL &&
+                value != GLFW_CURSOR_HIDDEN &&
+                value != GLFW_CURSOR_DISABLED)
+            {
+                _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:
-            setStickyKeys(window, value ? GL_TRUE : GL_FALSE);
-            break;
+        {
+            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:
-            setStickyMouseButtons(window, value ? GL_TRUE : GL_FALSE);
-            break;
-        default:
-            _glfwInputError(GLFW_INVALID_ENUM, "Invalid input mode");
-            break;
+        {
+            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;
+            return;
+        }
     }
+
+    _glfwInputError(GLFW_INVALID_ENUM, "Invalid input mode %i", mode);
+}
+
+GLFWAPI const char* glfwGetKeyName(int key, int scancode)
+{
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+    return _glfwPlatformGetKeyName(key, scancode);
 }
 
 GLFWAPI int glfwGetKey(GLFWwindow* handle, int key)
 {
     _GLFWwindow* window = (_GLFWwindow*) handle;
+    assert(window != NULL);
 
     _GLFW_REQUIRE_INIT_OR_RETURN(GLFW_RELEASE);
 
-    if (key < 0 || key > GLFW_KEY_LAST)
+    if (key < GLFW_KEY_SPACE || key > GLFW_KEY_LAST)
     {
-        _glfwInputError(GLFW_INVALID_ENUM, "Invalid key");
+        _glfwInputError(GLFW_INVALID_ENUM, "Invalid key %i", key);
         return GLFW_RELEASE;
     }
 
@@ -295,13 +282,13 @@ GLFWAPI int glfwGetKey(GLFWwindow* handle, int key)
 GLFWAPI int glfwGetMouseButton(GLFWwindow* handle, int button)
 {
     _GLFWwindow* window = (_GLFWwindow*) handle;
+    assert(window != NULL);
 
     _GLFW_REQUIRE_INIT_OR_RETURN(GLFW_RELEASE);
 
-    if (button < 0 || button > GLFW_MOUSE_BUTTON_LAST)
+    if (button < GLFW_MOUSE_BUTTON_1 || button > GLFW_MOUSE_BUTTON_LAST)
     {
-        _glfwInputError(GLFW_INVALID_ENUM,
-                        "Invalid mouse button");
+        _glfwInputError(GLFW_INVALID_ENUM, "Invalid mouse button %i", button);
         return GLFW_RELEASE;
     }
 
@@ -318,6 +305,7 @@ GLFWAPI int glfwGetMouseButton(GLFWwindow* handle, int button)
 GLFWAPI void glfwGetCursorPos(GLFWwindow* handle, double* xpos, double* ypos)
 {
     _GLFWwindow* window = (_GLFWwindow*) handle;
+    assert(window != NULL);
 
     if (xpos)
         *xpos = 0;
@@ -329,9 +317,9 @@ GLFWAPI void glfwGetCursorPos(GLFWwindow* handle, double* xpos, double* ypos)
     if (window->cursorMode == GLFW_CURSOR_DISABLED)
     {
         if (xpos)
-            *xpos = window->cursorPosX;
+            *xpos = window->virtualCursorPosX;
         if (ypos)
-            *ypos = window->cursorPosY;
+            *ypos = window->virtualCursorPosY;
     }
     else
         _glfwPlatformGetCursorPos(window, xpos, ypos);
@@ -340,17 +328,27 @@ GLFWAPI void glfwGetCursorPos(GLFWwindow* handle, double* xpos, double* ypos)
 GLFWAPI void glfwSetCursorPos(GLFWwindow* handle, double xpos, double ypos)
 {
     _GLFWwindow* window = (_GLFWwindow*) handle;
+    assert(window != NULL);
 
     _GLFW_REQUIRE_INIT();
 
-    if (_glfw.cursorWindow != window)
+    if (xpos != xpos || xpos < DBL_MIN || xpos > DBL_MAX ||
+        ypos != ypos || ypos < DBL_MIN || ypos > DBL_MAX)
+    {
+        _glfwInputError(GLFW_INVALID_VALUE,
+                        "Invalid cursor position %fx%f",
+                        xpos, ypos);
+        return;
+    }
+
+    if (!_glfwPlatformWindowFocused(window))
         return;
 
     if (window->cursorMode == GLFW_CURSOR_DISABLED)
     {
         // Only update the accumulated position if the cursor is disabled
-        window->cursorPosX = xpos;
-        window->cursorPosY = ypos;
+        window->virtualCursorPosX = xpos;
+        window->virtualCursorPosY = ypos;
     }
     else
     {
@@ -363,6 +361,8 @@ GLFWAPI GLFWcursor* glfwCreateCursor(const GLFWimage* image, int xhot, int yhot)
 {
     _GLFWcursor* cursor;
 
+    assert(image != NULL);
+
     _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
 
     cursor = calloc(1, sizeof(_GLFWcursor));
@@ -391,7 +391,7 @@ GLFWAPI GLFWcursor* glfwCreateStandardCursor(int shape)
         shape != GLFW_HRESIZE_CURSOR &&
         shape != GLFW_VRESIZE_CURSOR)
     {
-        _glfwInputError(GLFW_INVALID_ENUM, "Invalid standard cursor");
+        _glfwInputError(GLFW_INVALID_ENUM, "Invalid standard cursor %i", shape);
         return NULL;
     }
 
@@ -447,17 +447,20 @@ GLFWAPI void glfwSetCursor(GLFWwindow* windowHandle, GLFWcursor* cursorHandle)
 {
     _GLFWwindow* window = (_GLFWwindow*) windowHandle;
     _GLFWcursor* cursor = (_GLFWcursor*) cursorHandle;
+    assert(window != NULL);
 
     _GLFW_REQUIRE_INIT();
 
-    _glfwPlatformSetCursor(window, cursor);
-
     window->cursor = cursor;
+
+    _glfwPlatformSetCursor(window, cursor);
 }
 
 GLFWAPI GLFWkeyfun glfwSetKeyCallback(GLFWwindow* handle, GLFWkeyfun cbfun)
 {
     _GLFWwindow* window = (_GLFWwindow*) handle;
+    assert(window != NULL);
+
     _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
     _GLFW_SWAP_POINTERS(window->callbacks.key, cbfun);
     return cbfun;
@@ -466,6 +469,8 @@ GLFWAPI GLFWkeyfun glfwSetKeyCallback(GLFWwindow* handle, GLFWkeyfun cbfun)
 GLFWAPI GLFWcharfun glfwSetCharCallback(GLFWwindow* handle, GLFWcharfun cbfun)
 {
     _GLFWwindow* window = (_GLFWwindow*) handle;
+    assert(window != NULL);
+
     _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
     _GLFW_SWAP_POINTERS(window->callbacks.character, cbfun);
     return cbfun;
@@ -474,6 +479,8 @@ GLFWAPI GLFWcharfun glfwSetCharCallback(GLFWwindow* handle, GLFWcharfun cbfun)
 GLFWAPI GLFWcharmodsfun glfwSetCharModsCallback(GLFWwindow* handle, GLFWcharmodsfun cbfun)
 {
     _GLFWwindow* window = (_GLFWwindow*) handle;
+    assert(window != NULL);
+
     _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
     _GLFW_SWAP_POINTERS(window->callbacks.charmods, cbfun);
     return cbfun;
@@ -483,6 +490,8 @@ GLFWAPI GLFWmousebuttonfun glfwSetMouseButtonCallback(GLFWwindow* handle,
                                                       GLFWmousebuttonfun cbfun)
 {
     _GLFWwindow* window = (_GLFWwindow*) handle;
+    assert(window != NULL);
+
     _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
     _GLFW_SWAP_POINTERS(window->callbacks.mouseButton, cbfun);
     return cbfun;
@@ -492,6 +501,8 @@ GLFWAPI GLFWcursorposfun glfwSetCursorPosCallback(GLFWwindow* handle,
                                                   GLFWcursorposfun cbfun)
 {
     _GLFWwindow* window = (_GLFWwindow*) handle;
+    assert(window != NULL);
+
     _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
     _GLFW_SWAP_POINTERS(window->callbacks.cursorPos, cbfun);
     return cbfun;
@@ -501,6 +512,8 @@ GLFWAPI GLFWcursorenterfun glfwSetCursorEnterCallback(GLFWwindow* handle,
                                                       GLFWcursorenterfun cbfun)
 {
     _GLFWwindow* window = (_GLFWwindow*) handle;
+    assert(window != NULL);
+
     _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
     _GLFW_SWAP_POINTERS(window->callbacks.cursorEnter, cbfun);
     return cbfun;
@@ -510,6 +523,8 @@ GLFWAPI GLFWscrollfun glfwSetScrollCallback(GLFWwindow* handle,
                                             GLFWscrollfun cbfun)
 {
     _GLFWwindow* window = (_GLFWwindow*) handle;
+    assert(window != NULL);
+
     _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
     _GLFW_SWAP_POINTERS(window->callbacks.scroll, cbfun);
     return cbfun;
@@ -518,6 +533,8 @@ GLFWAPI GLFWscrollfun glfwSetScrollCallback(GLFWwindow* handle,
 GLFWAPI GLFWdropfun glfwSetDropCallback(GLFWwindow* handle, GLFWdropfun cbfun)
 {
     _GLFWwindow* window = (_GLFWwindow*) handle;
+    assert(window != NULL);
+
     _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
     _GLFW_SWAP_POINTERS(window->callbacks.drop, cbfun);
     return cbfun;
@@ -529,7 +546,7 @@ GLFWAPI int glfwJoystickPresent(int joy)
 
     if (joy < 0 || joy > GLFW_JOYSTICK_LAST)
     {
-        _glfwInputError(GLFW_INVALID_ENUM, "Invalid joystick");
+        _glfwInputError(GLFW_INVALID_ENUM, "Invalid joystick %i", joy);
         return 0;
     }
 
@@ -538,13 +555,14 @@ GLFWAPI int glfwJoystickPresent(int joy)
 
 GLFWAPI const float* glfwGetJoystickAxes(int joy, int* count)
 {
+    assert(count != NULL);
     *count = 0;
 
     _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
 
     if (joy < 0 || joy > GLFW_JOYSTICK_LAST)
     {
-        _glfwInputError(GLFW_INVALID_ENUM, "Invalid joystick");
+        _glfwInputError(GLFW_INVALID_ENUM, "Invalid joystick %i", joy);
         return NULL;
     }
 
@@ -553,13 +571,14 @@ GLFWAPI const float* glfwGetJoystickAxes(int joy, int* count)
 
 GLFWAPI const unsigned char* glfwGetJoystickButtons(int joy, int* count)
 {
+    assert(count != NULL);
     *count = 0;
 
     _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
 
     if (joy < 0 || joy > GLFW_JOYSTICK_LAST)
     {
-        _glfwInputError(GLFW_INVALID_ENUM, "Invalid joystick");
+        _glfwInputError(GLFW_INVALID_ENUM, "Invalid joystick %i", joy);
         return NULL;
     }
 
@@ -572,16 +591,26 @@ GLFWAPI const char* glfwGetJoystickName(int joy)
 
     if (joy < 0 || joy > GLFW_JOYSTICK_LAST)
     {
-        _glfwInputError(GLFW_INVALID_ENUM, "Invalid joystick");
+        _glfwInputError(GLFW_INVALID_ENUM, "Invalid joystick %i", joy);
         return NULL;
     }
 
     return _glfwPlatformGetJoystickName(joy);
 }
 
+GLFWAPI GLFWjoystickfun glfwSetJoystickCallback(GLFWjoystickfun cbfun)
+{
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+    _GLFW_SWAP_POINTERS(_glfw.callbacks.joystick, cbfun);
+    return cbfun;
+}
+
 GLFWAPI void glfwSetClipboardString(GLFWwindow* handle, const char* string)
 {
     _GLFWwindow* window = (_GLFWwindow*) handle;
+    assert(window != NULL);
+    assert(string != NULL);
+
     _GLFW_REQUIRE_INIT();
     _glfwPlatformSetClipboardString(window, string);
 }
@@ -589,6 +618,8 @@ GLFWAPI void glfwSetClipboardString(GLFWwindow* handle, const char* string)
 GLFWAPI const char* glfwGetClipboardString(GLFWwindow* handle)
 {
     _GLFWwindow* window = (_GLFWwindow*) handle;
+    assert(window != NULL);
+
     _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
     return _glfwPlatformGetClipboardString(window);
 }
@@ -596,7 +627,8 @@ GLFWAPI const char* glfwGetClipboardString(GLFWwindow* handle)
 GLFWAPI double glfwGetTime(void)
 {
     _GLFW_REQUIRE_INIT_OR_RETURN(0.0);
-    return _glfwPlatformGetTime();
+    return (double) (_glfwPlatformGetTimerValue() - _glfw.timerOffset) /
+        _glfwPlatformGetTimerFrequency();
 }
 
 GLFWAPI void glfwSetTime(double time)
@@ -605,10 +637,23 @@ GLFWAPI void glfwSetTime(double time)
 
     if (time != time || time < 0.0 || time > 18446744073.0)
     {
-        _glfwInputError(GLFW_INVALID_VALUE, "Invalid time");
+        _glfwInputError(GLFW_INVALID_VALUE, "Invalid time %f", time);
         return;
     }
 
-    _glfwPlatformSetTime(time);
+    _glfw.timerOffset = _glfwPlatformGetTimerValue() -
+        (uint64_t) (time * _glfwPlatformGetTimerFrequency());
+}
+
+GLFWAPI uint64_t glfwGetTimerValue(void)
+{
+    _GLFW_REQUIRE_INIT_OR_RETURN(0);
+    return _glfwPlatformGetTimerValue();
+}
+
+GLFWAPI uint64_t glfwGetTimerFrequency(void)
+{
+    _GLFW_REQUIRE_INIT_OR_RETURN(0);
+    return _glfwPlatformGetTimerFrequency();
 }
 

src/internal.h

@@ -1,8 +1,8 @@
 //========================================================================
-// GLFW 3.1 - www.glfw.org
+// GLFW 3.2 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
+// Copyright (c) 2006-2016 Camilla Berglund <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,8 +33,6 @@
  #include "glfw_config.h"
 #endif
 
-#define _GLFW_VERSION_NUMBER "3.1.2"
-
 #if defined(GLFW_INCLUDE_GLCOREARB) || \
     defined(GLFW_INCLUDE_ES1)       || \
     defined(GLFW_INCLUDE_ES2)       || \
@@ -43,44 +41,120 @@
     defined(GLFW_INCLUDE_GLEXT)     || \
     defined(GLFW_INCLUDE_GLU)       || \
     defined(GLFW_DLL)
- #error "You may not define any header option macros when compiling GLFW"
+ #error "You must not define any header option macros when compiling GLFW"
 #endif
 
-#if defined(_GLFW_USE_OPENGL)
- // This is the default for glfw3.h
-#elif defined(_GLFW_USE_GLESV1)
- #define GLFW_INCLUDE_ES1
-#elif defined(_GLFW_USE_GLESV2)
- #define GLFW_INCLUDE_ES2
-#else
- #error "No supported client library selected"
-#endif
-
-// Disable the inclusion of the platform glext.h by gl.h to allow proper
-// inclusion of our own, newer glext.h below
-#define GL_GLEXT_LEGACY
-
+#define GLFW_INCLUDE_NONE
 #include "../include/GLFW/glfw3.h"
 
-#if defined(_GLFW_USE_OPENGL)
- // This path may need to be changed if you build GLFW using your own setup
- // GLFW comes with its own copy of glext.h since it uses fairly new extensions
- // and not all development environments come with an up-to-date version
- #include "../deps/GL/glext.h"
-#endif
-
-typedef void (APIENTRY * PFNGLCLEARPROC)(GLbitfield);
-typedef const GLubyte* (APIENTRY * PFNGLGETSTRINGPROC)(GLenum);
-typedef void (APIENTRY * PFNGLGETINTEGERVPROC)(GLenum,GLint*);
+typedef int GLFWbool;
 
 typedef struct _GLFWwndconfig   _GLFWwndconfig;
 typedef struct _GLFWctxconfig   _GLFWctxconfig;
 typedef struct _GLFWfbconfig    _GLFWfbconfig;
+typedef struct _GLFWcontext     _GLFWcontext;
 typedef struct _GLFWwindow      _GLFWwindow;
 typedef struct _GLFWlibrary     _GLFWlibrary;
 typedef struct _GLFWmonitor     _GLFWmonitor;
 typedef struct _GLFWcursor      _GLFWcursor;
 
+typedef void (* _GLFWmakecontextcurrentfun)(_GLFWwindow*);
+typedef void (* _GLFWswapbuffersfun)(_GLFWwindow*);
+typedef void (* _GLFWswapintervalfun)(int);
+typedef int (* _GLFWextensionsupportedfun)(const char*);
+typedef GLFWglproc (* _GLFWgetprocaddressfun)(const char*);
+typedef void (* _GLFWdestroycontextfun)(_GLFWwindow*);
+
+#define GL_VERSION 0x1f02
+#define GL_NONE	0
+#define GL_COLOR_BUFFER_BIT	0x00004000
+#define GL_EXTENSIONS 0x1f03
+#define GL_NUM_EXTENSIONS 0x821d
+#define GL_CONTEXT_FLAGS 0x821e
+#define GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT 0x00000001
+#define GL_CONTEXT_FLAG_DEBUG_BIT 0x00000002
+#define GL_CONTEXT_PROFILE_MASK 0x9126
+#define GL_CONTEXT_COMPATIBILITY_PROFILE_BIT 0x00000002
+#define GL_CONTEXT_CORE_PROFILE_BIT 0x00000001
+#define GL_RESET_NOTIFICATION_STRATEGY_ARB 0x8256
+#define GL_LOSE_CONTEXT_ON_RESET_ARB 0x8252
+#define GL_NO_RESET_NOTIFICATION_ARB 0x8261
+#define GL_CONTEXT_RELEASE_BEHAVIOR 0x82fb
+#define GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH 0x82fc
+#define GL_CONTEXT_FLAG_NO_ERROR_BIT_KHR 0x00000008
+
+typedef int	GLint;
+typedef unsigned int GLuint;
+typedef unsigned int GLenum;
+typedef unsigned int GLbitfield;
+typedef unsigned char GLubyte;
+
+typedef void (APIENTRY * PFNGLCLEARPROC)(GLbitfield);
+typedef const GLubyte* (APIENTRY * PFNGLGETSTRINGPROC)(GLenum);
+typedef void (APIENTRY * PFNGLGETINTEGERVPROC)(GLenum,GLint*);
+typedef const GLubyte* (APIENTRY * PFNGLGETSTRINGIPROC)(GLenum,GLuint);
+
+#define VK_NULL_HANDLE 0
+
+typedef void* VkInstance;
+typedef void* VkPhysicalDevice;
+typedef uint64_t VkSurfaceKHR;
+typedef uint32_t VkFlags;
+typedef uint32_t VkBool32;
+
+typedef enum VkStructureType
+{
+    VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR = 1000004000,
+    VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR = 1000005000,
+    VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR = 1000006000,
+    VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR = 1000007000,
+    VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR = 1000009000,
+    VK_STRUCTURE_TYPE_MAX_ENUM = 0x7FFFFFFF
+} VkStructureType;
+
+typedef enum VkResult
+{
+    VK_SUCCESS = 0,
+    VK_NOT_READY = 1,
+    VK_TIMEOUT = 2,
+    VK_EVENT_SET = 3,
+    VK_EVENT_RESET = 4,
+    VK_INCOMPLETE = 5,
+    VK_ERROR_OUT_OF_HOST_MEMORY = -1,
+    VK_ERROR_OUT_OF_DEVICE_MEMORY = -2,
+    VK_ERROR_INITIALIZATION_FAILED = -3,
+    VK_ERROR_DEVICE_LOST = -4,
+    VK_ERROR_MEMORY_MAP_FAILED = -5,
+    VK_ERROR_LAYER_NOT_PRESENT = -6,
+    VK_ERROR_EXTENSION_NOT_PRESENT = -7,
+    VK_ERROR_FEATURE_NOT_PRESENT = -8,
+    VK_ERROR_INCOMPATIBLE_DRIVER = -9,
+    VK_ERROR_TOO_MANY_OBJECTS = -10,
+    VK_ERROR_FORMAT_NOT_SUPPORTED = -11,
+    VK_ERROR_SURFACE_LOST_KHR = -1000000000,
+    VK_SUBOPTIMAL_KHR = 1000001003,
+    VK_ERROR_OUT_OF_DATE_KHR = -1000001004,
+    VK_ERROR_INCOMPATIBLE_DISPLAY_KHR = -1000003001,
+    VK_ERROR_NATIVE_WINDOW_IN_USE_KHR = -1000000001,
+    VK_ERROR_VALIDATION_FAILED_EXT = -1000011001,
+    VK_RESULT_MAX_ENUM = 0x7FFFFFFF
+} VkResult;
+
+typedef struct VkAllocationCallbacks VkAllocationCallbacks;
+
+typedef struct VkExtensionProperties
+{
+    char            extensionName[256];
+    uint32_t        specVersion;
+} VkExtensionProperties;
+
+typedef void (APIENTRY * PFN_vkVoidFunction)(void);
+typedef PFN_vkVoidFunction (APIENTRY * PFN_vkGetInstanceProcAddr)(VkInstance,const char*);
+typedef VkResult (APIENTRY * PFN_vkEnumerateInstanceExtensionProperties)(const char*,uint32_t*,VkExtensionProperties*);
+
+#define vkEnumerateInstanceExtensionProperties _glfw.vk.EnumerateInstanceExtensionProperties
+#define vkGetInstanceProcAddr _glfw.vk.GetInstanceProcAddr
+
 #if defined(_GLFW_COCOA)
  #include "cocoa_platform.h"
 #elif defined(_GLFW_WIN32)
@@ -118,7 +192,7 @@ typedef struct _GLFWcursor      _GLFWcursor;
  *  @brief Various utility functions for internal use.
  *
  *  These functions are shared code and may be used by any part of GLFW
- *  Each platform may add its own utility functions, but those may only be
+ *  Each platform may add its own utility functions, but those must only be
  *  called by the platform-specific code
  */
 
@@ -127,6 +201,13 @@ typedef struct _GLFWcursor      _GLFWcursor;
 // Helper macros
 //========================================================================
 
+// Constructs a version number string from the public header macros
+#define _GLFW_CONCAT_VERSION(m, n, r) #m "." #n "." #r
+#define _GLFW_MAKE_VERSION(m, n, r) _GLFW_CONCAT_VERSION(m, n, r)
+#define _GLFW_VERSION_NUMBER _GLFW_MAKE_VERSION(GLFW_VERSION_MAJOR, \
+                                                GLFW_VERSION_MINOR, \
+                                                GLFW_VERSION_REVISION)
+
 // Checks for whether the library has been initialized
 #define _GLFW_REQUIRE_INIT()                         \
     if (!_glfwInitialized)                           \
@@ -166,13 +247,13 @@ struct _GLFWwndconfig
     int           width;
     int           height;
     const char*   title;
-    GLboolean     resizable;
-    GLboolean     visible;
-    GLboolean     decorated;
-    GLboolean     focused;
-    GLboolean     autoIconify;
-    GLboolean     floating;
-    _GLFWmonitor* monitor;
+    GLFWbool      resizable;
+    GLFWbool      visible;
+    GLFWbool      decorated;
+    GLFWbool      focused;
+    GLFWbool      autoIconify;
+    GLFWbool      floating;
+    GLFWbool      maximized;
 };
 
 
@@ -184,11 +265,13 @@ struct _GLFWwndconfig
  */
 struct _GLFWctxconfig
 {
-    int           api;
+    int           client;
+    int           source;
     int           major;
     int           minor;
-    GLboolean     forward;
-    GLboolean     debug;
+    GLFWbool      forward;
+    GLFWbool      debug;
+    GLFWbool      noerror;
     int           profile;
     int           robustness;
     int           release;
@@ -217,13 +300,41 @@ struct _GLFWfbconfig
     int         accumBlueBits;
     int         accumAlphaBits;
     int         auxBuffers;
-    int         stereo;
+    GLFWbool    stereo;
     int         samples;
-    int         sRGB;
-    int         doublebuffer;
+    GLFWbool    sRGB;
+    GLFWbool    doublebuffer;
+    uintptr_t   handle;
+};
+
+
+/*! @brief Context structure.
+ */
+struct _GLFWcontext
+{
+    int                 client;
+    int                 source;
+    int                 major, minor, revision;
+    GLFWbool            forward, debug, noerror;
+    int                 profile;
+    int                 robustness;
+    int                 release;
+
+    PFNGLGETSTRINGIPROC GetStringi;
+    PFNGLGETINTEGERVPROC GetIntegerv;
+    PFNGLGETSTRINGPROC  GetString;
+
+    _GLFWmakecontextcurrentfun  makeCurrent;
+    _GLFWswapbuffersfun         swapBuffers;
+    _GLFWswapintervalfun        swapInterval;
+    _GLFWextensionsupportedfun  extensionSupported;
+    _GLFWgetprocaddressfun      getProcAddress;
+    _GLFWdestroycontextfun      destroy;
 
     // This is defined in the context API's context.h
-    _GLFW_PLATFORM_FBCONFIG;
+    _GLFW_PLATFORM_CONTEXT_STATE;
+    // This is defined in egl_context.h
+    _GLFW_EGL_CONTEXT_STATE;
 };
 
 
@@ -234,40 +345,29 @@ struct _GLFWwindow
     struct _GLFWwindow* next;
 
     // Window settings and state
-    GLboolean           resizable;
-    GLboolean           decorated;
-    GLboolean           autoIconify;
-    GLboolean           floating;
-    GLboolean           closed;
+    GLFWbool            resizable;
+    GLFWbool            decorated;
+    GLFWbool            autoIconify;
+    GLFWbool            floating;
+    GLFWbool            closed;
     void*               userPointer;
     GLFWvidmode         videoMode;
     _GLFWmonitor*       monitor;
     _GLFWcursor*        cursor;
 
-    // Window input state
-    GLboolean           stickyKeys;
-    GLboolean           stickyMouseButtons;
-    double              cursorPosX, cursorPosY;
+    int                 minwidth, minheight;
+    int                 maxwidth, maxheight;
+    int                 numer, denom;
+
+    GLFWbool            stickyKeys;
+    GLFWbool            stickyMouseButtons;
     int                 cursorMode;
     char                mouseButtons[GLFW_MOUSE_BUTTON_LAST + 1];
     char                keys[GLFW_KEY_LAST + 1];
+    // Virtual cursor position when cursor is disabled
+    double              virtualCursorPosX, virtualCursorPosY;
 
-    // OpenGL extensions and context attributes
-    struct {
-        int             api;
-        int             major, minor, revision;
-        GLboolean       forward, debug;
-        int             profile;
-        int             robustness;
-        int             release;
-    } context;
-
-#if defined(_GLFW_USE_OPENGL)
-    PFNGLGETSTRINGIPROC GetStringi;
-#endif
-    PFNGLGETINTEGERVPROC GetIntegerv;
-    PFNGLGETSTRINGPROC  GetString;
-    PFNGLCLEARPROC      Clear;
+    _GLFWcontext        context;
 
     struct {
         GLFWwindowposfun        pos;
@@ -289,8 +389,6 @@ struct _GLFWwindow
 
     // This is defined in the window API's platform.h
     _GLFW_PLATFORM_WINDOW_STATE;
-    // This is defined in the context API's context.h
-    _GLFW_PLATFORM_CONTEXT_STATE;
 };
 
 
@@ -303,6 +401,9 @@ struct _GLFWmonitor
     // Physical dimensions in millimeters.
     int             widthMM, heightMM;
 
+    // The window whose video mode is current on this monitor
+    _GLFWwindow*    window;
+
     GLFWvidmode*    modes;
     int             modeCount;
     GLFWvidmode     currentMode;
@@ -336,18 +437,33 @@ struct _GLFWlibrary
         int             refreshRate;
     } hints;
 
-    double              cursorPosX, cursorPosY;
-
     _GLFWcursor*        cursorListHead;
 
     _GLFWwindow*        windowListHead;
-    _GLFWwindow*        cursorWindow;
 
     _GLFWmonitor**      monitors;
     int                 monitorCount;
 
+    uint64_t            timerOffset;
+
+    struct {
+        GLFWbool        available;
+        void*           handle;
+        char**          extensions;
+        uint32_t        extensionCount;
+        PFN_vkEnumerateInstanceExtensionProperties EnumerateInstanceExtensionProperties;
+        PFN_vkGetInstanceProcAddr GetInstanceProcAddr;
+        GLFWbool        KHR_surface;
+        GLFWbool        KHR_win32_surface;
+        GLFWbool        KHR_xlib_surface;
+        GLFWbool        KHR_xcb_surface;
+        GLFWbool        KHR_wayland_surface;
+        GLFWbool        KHR_mir_surface;
+    } vk;
+
     struct {
         GLFWmonitorfun  monitor;
+        GLFWjoystickfun joystick;
     } callbacks;
 
     // This is defined in the window API's platform.h
@@ -360,6 +476,8 @@ struct _GLFWlibrary
     _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;
 };
 
 
@@ -369,7 +487,7 @@ struct _GLFWlibrary
 
 /*! @brief Flag indicating whether GLFW has been successfully initialized.
  */
-extern GLboolean _glfwInitialized;
+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
@@ -383,7 +501,7 @@ extern _GLFWlibrary _glfw;
 //========================================================================
 
 /*! @brief Initializes the platform-specific part of the library.
- *  @return `GL_TRUE` if successful, or `GL_FALSE` if an error occurred.
+ *  @return `GLFW_TRUE` if successful, or `GLFW_FALSE` if an error occurred.
  *  @ingroup platform
  */
 int _glfwPlatformInit(void);
@@ -412,11 +530,16 @@ void _glfwPlatformGetCursorPos(_GLFWwindow* window, double* xpos, double* ypos);
  */
 void _glfwPlatformSetCursorPos(_GLFWwindow* window, double xpos, double ypos);
 
-/*! @brief Applies the cursor mode of the specified window to the system.
- *  @param[in] window The window whose cursor mode to apply.
+/*! @brief Sets the specified cursor mode of the specified window.
+ *  @param[in] window The window whose cursor mode to set.
  *  @ingroup platform
  */
-void _glfwPlatformApplyCursorMode(_GLFWwindow* window);
+void _glfwPlatformSetCursorMode(_GLFWwindow* window, int mode);
+
+/*! @copydoc glfwGetKeyName
+ *  @ingroup platform
+ */
+const char* _glfwPlatformGetKeyName(int key, int scancode);
 
 /*! @copydoc glfwGetMonitors
  *  @ingroup platform
@@ -427,11 +550,11 @@ _GLFWmonitor** _glfwPlatformGetMonitors(int* count);
  *
  *  @param[in] first The first monitor.
  *  @param[in] second The second monitor.
- *  @return @c GL_TRUE if the monitor objects represent the same monitor, or @c
- *  GL_FALSE otherwise.
+ *  @return @c GLFW_TRUE if the monitor objects represent the same monitor, or
+ *  @c GLFW_FALSE otherwise.
  *  @ingroup platform
  */
-GLboolean _glfwPlatformIsSameMonitor(_GLFWmonitor* first, _GLFWmonitor* second);
+GLFWbool _glfwPlatformIsSameMonitor(_GLFWmonitor* first, _GLFWmonitor* second);
 
 /*! @copydoc glfwGetMonitorPos
  *  @ingroup platform
@@ -490,15 +613,15 @@ const unsigned char* _glfwPlatformGetJoystickButtons(int joy, int* count);
  */
 const char* _glfwPlatformGetJoystickName(int joy);
 
-/*! @copydoc glfwGetTime
+/*! @copydoc glfwGetTimerValue
  *  @ingroup platform
  */
-double _glfwPlatformGetTime(void);
+uint64_t _glfwPlatformGetTimerValue(void);
 
-/*! @copydoc glfwSetTime
+/*! @copydoc glfwGetTimerFrequency
  *  @ingroup platform
  */
-void _glfwPlatformSetTime(double time);
+uint64_t _glfwPlatformGetTimerFrequency(void);
 
 /*! @ingroup platform
  */
@@ -516,6 +639,11 @@ void _glfwPlatformDestroyWindow(_GLFWwindow* window);
  */
 void _glfwPlatformSetWindowTitle(_GLFWwindow* window, const char* title);
 
+/*! @copydoc glfwSetWindowIcon
+ *  @ingroup platform
+ */
+void _glfwPlatformSetWindowIcon(_GLFWwindow* window, int count, const GLFWimage* images);
+
 /*! @copydoc glfwGetWindowPos
  *  @ingroup platform
  */
@@ -536,6 +664,16 @@ void _glfwPlatformGetWindowSize(_GLFWwindow* window, int* width, int* height);
  */
 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
  */
@@ -556,20 +694,31 @@ void _glfwPlatformIconifyWindow(_GLFWwindow* window);
  */
 void _glfwPlatformRestoreWindow(_GLFWwindow* window);
 
+/*! @copydoc glfwMaximizeWindow
+ *  @ingroup platform
+ */
+void _glfwPlatformMaximizeWindow(_GLFWwindow* window);
+
 /*! @copydoc glfwShowWindow
  *  @ingroup platform
  */
 void _glfwPlatformShowWindow(_GLFWwindow* window);
 
-/*! @ingroup platform
- */
-void _glfwPlatformUnhideWindow(_GLFWwindow* window);
-
 /*! @copydoc glfwHideWindow
  *  @ingroup platform
  */
 void _glfwPlatformHideWindow(_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
  */
@@ -585,6 +734,11 @@ int _glfwPlatformWindowIconified(_GLFWwindow* window);
  */
 int _glfwPlatformWindowVisible(_GLFWwindow* window);
 
+/*! @brief Returns whether the window is maximized.
+ *  @ingroup platform
+ */
+int _glfwPlatformWindowMaximized(_GLFWwindow* window);
+
 /*! @copydoc glfwPollEvents
  *  @ingroup platform
  */
@@ -595,41 +749,25 @@ void _glfwPlatformPollEvents(void);
  */
 void _glfwPlatformWaitEvents(void);
 
+/*! @copydoc glfwWaitEventsTimeout
+ *  @ingroup platform
+ */
+void _glfwPlatformWaitEventsTimeout(double timeout);
+
 /*! @copydoc glfwPostEmptyEvent
  *  @ingroup platform
  */
 void _glfwPlatformPostEmptyEvent(void);
 
-/*! @copydoc glfwMakeContextCurrent
- *  @ingroup platform
+/*! @ingroup platform
  */
-void _glfwPlatformMakeContextCurrent(_GLFWwindow* window);
+void _glfwPlatformSetCurrentContext(_GLFWwindow* context);
 
 /*! @copydoc glfwGetCurrentContext
  *  @ingroup platform
  */
 _GLFWwindow* _glfwPlatformGetCurrentContext(void);
 
-/*! @copydoc glfwSwapBuffers
- *  @ingroup platform
- */
-void _glfwPlatformSwapBuffers(_GLFWwindow* window);
-
-/*! @copydoc glfwSwapInterval
- *  @ingroup platform
- */
-void _glfwPlatformSwapInterval(int interval);
-
-/*! @copydoc glfwExtensionSupported
- *  @ingroup platform
- */
-int _glfwPlatformExtensionSupported(const char* extension);
-
-/*! @copydoc glfwGetProcAddress
- *  @ingroup platform
- */
-GLFWglproc _glfwPlatformGetProcAddress(const char* procname);
-
 /*! @copydoc glfwCreateCursor
  *  @ingroup platform
  */
@@ -650,6 +788,18 @@ void _glfwPlatformDestroyCursor(_GLFWcursor* cursor);
  */
 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);
+
 
 //========================================================================
 // Event API functions
@@ -657,11 +807,11 @@ void _glfwPlatformSetCursor(_GLFWwindow* window, _GLFWcursor* cursor);
 
 /*! @brief Notifies shared code of a window focus event.
  *  @param[in] window The window that received the event.
- *  @param[in] focused `GL_TRUE` if the window received focus, or `GL_FALSE`
+ *  @param[in] focused `GLFW_TRUE` if the window received focus, or `GLFW_FALSE`
  *  if it lost focus.
  *  @ingroup event
  */
-void _glfwInputWindowFocus(_GLFWwindow* window, GLboolean focused);
+void _glfwInputWindowFocus(_GLFWwindow* window, GLFWbool focused);
 
 /*! @brief Notifies shared code of a window movement event.
  *  @param[in] window The window that received the event.
@@ -689,11 +839,11 @@ void _glfwInputFramebufferSize(_GLFWwindow* window, int width, int height);
 
 /*! @brief Notifies shared code of a window iconification event.
  *  @param[in] window The window that received the event.
- *  @param[in] iconified `GL_TRUE` if the window was iconified, or `GL_FALSE`
- *  if it was restored.
+ *  @param[in] iconified `GLFW_TRUE` if the window was iconified, or
+ *  `GLFW_FALSE` if it was restored.
  *  @ingroup event
  */
-void _glfwInputWindowIconify(_GLFWwindow* window, int iconified);
+void _glfwInputWindowIconify(_GLFWwindow* window, GLFWbool iconified);
 
 /*! @brief Notifies shared code of a window damage event.
  *  @param[in] window The window that received the event.
@@ -706,6 +856,8 @@ void _glfwInputWindowDamage(_GLFWwindow* window);
  */
 void _glfwInputWindowCloseRequest(_GLFWwindow* window);
 
+void _glfwInputWindowMonitorChange(_GLFWwindow* window, _GLFWmonitor* monitor);
+
 /*! @brief Notifies shared code of a physical key event.
  *  @param[in] window The window that received the event.
  *  @param[in] key The key that was pressed or released.
@@ -720,19 +872,19 @@ void _glfwInputKey(_GLFWwindow* window, int key, int scancode, int action, int m
  *  @param[in] window The window that received the event.
  *  @param[in] codepoint The Unicode code point of the input character.
  *  @param[in] mods Bit field describing which modifier keys were held down.
- *  @param[in] plain `GL_TRUE` if the character is regular text input, or
- *  `GL_FALSE` otherwise.
+ *  @param[in] plain `GLFW_TRUE` if the character is regular text input, or
+ *  `GLFW_FALSE` otherwise.
  *  @ingroup event
  */
-void _glfwInputChar(_GLFWwindow* window, unsigned int codepoint, int mods, int plain);
+void _glfwInputChar(_GLFWwindow* window, unsigned int codepoint, int mods, GLFWbool plain);
 
 /*! @brief Notifies shared code of a scroll event.
  *  @param[in] window The window that received the event.
- *  @param[in] x The scroll offset along the x-axis.
- *  @param[in] y The scroll offset along the y-axis.
+ *  @param[in] xoffset The scroll offset along the x-axis.
+ *  @param[in] yoffset The scroll offset along the y-axis.
  *  @ingroup event
  */
-void _glfwInputScroll(_GLFWwindow* window, double x, double y);
+void _glfwInputScroll(_GLFWwindow* window, double xoffset, double yoffset);
 
 /*! @brief Notifies shared code of a mouse button click event.
  *  @param[in] window The window that received the event.
@@ -744,33 +896,41 @@ void _glfwInputMouseClick(_GLFWwindow* window, int button, int action, int mods)
 
 /*! @brief Notifies shared code of a cursor motion event.
  *  @param[in] window The window that received the event.
- *  @param[in] x The new x-coordinate of the cursor, relative to the left edge
- *  of the client area of the window.
- *  @param[in] y The new y-coordinate of the cursor, relative to the top edge
+ *  @param[in] xpos The new x-coordinate of the cursor, relative to the left
+ *  edge of the client area of the window.
+ *  @param[in] ypos The new y-coordinate of the cursor, relative to the top edge
  *  of the client area of the window.
  *  @ingroup event
  */
-void _glfwInputCursorMotion(_GLFWwindow* window, double x, double y);
+void _glfwInputCursorPos(_GLFWwindow* window, double xpos, double ypos);
 
 /*! @brief Notifies shared code of a cursor enter/leave event.
  *  @param[in] window The window that received the event.
- *  @param[in] entered `GL_TRUE` if the cursor entered the client area of the
- *  window, or `GL_FALSE` if it left it.
+ *  @param[in] entered `GLFW_TRUE` if the cursor entered the client area of the
+ *  window, or `GLFW_FALSE` if it left it.
  *  @ingroup event
  */
-void _glfwInputCursorEnter(_GLFWwindow* window, int entered);
+void _glfwInputCursorEnter(_GLFWwindow* window, GLFWbool entered);
 
 /*! @ingroup event
  */
 void _glfwInputMonitorChange(void);
 
+/*! @ingroup event
+ */
+void _glfwInputMonitorWindowChange(_GLFWmonitor* monitor, _GLFWwindow* window);
+
 /*! @brief Notifies shared code of an error.
  *  @param[in] error 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)));
+#else
 void _glfwInputError(int error, const char* format, ...);
+#endif
 
 /*! @brief Notifies dropped object over window.
  *  @param[in] window The window that received the event.
@@ -780,6 +940,13 @@ 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.
+ *  @param[in] joy 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);
+
 
 //========================================================================
 // Utility functions
@@ -803,10 +970,10 @@ void _glfwSplitBPP(int bpp, int* red, int* green, int* blue);
 /*! @brief Searches an extension string for the specified extension.
  *  @param[in] string The extension string to search.
  *  @param[in] extensions The extension to search for.
- *  @return `GL_TRUE` if the extension was found, or `GL_FALSE` otherwise.
+ *  @return `GLFW_TRUE` if the extension was found, or `GLFW_FALSE` otherwise.
  *  @ingroup utility
  */
-int _glfwStringInExtensionString(const char* string, const char* extensions);
+GLFWbool _glfwStringInExtensionString(const char* string, const char* extensions);
 
 /*! @brief Chooses the framebuffer config that best matches the desired one.
  *  @param[in] desired The desired framebuffer config.
@@ -822,14 +989,15 @@ const _GLFWfbconfig* _glfwChooseFBConfig(const _GLFWfbconfig* desired,
 
 /*! @brief Retrieves the attributes of the current context.
  *  @param[in] ctxconfig The desired context attributes.
- *  @return `GL_TRUE` if successful, or `GL_FALSE` if the context is unusable.
+ *  @return `GLFW_TRUE` if successful, or `GLFW_FALSE` if the context is
+ *  unusable.
  *  @ingroup utility
  */
-GLboolean _glfwRefreshContextAttribs(const _GLFWctxconfig* ctxconfig);
+GLFWbool _glfwRefreshContextAttribs(const _GLFWctxconfig* ctxconfig);
 
 /*! @brief Checks whether the desired context attributes are valid.
  *  @param[in] ctxconfig The context attributes to check.
- *  @return `GL_TRUE` if the context attributes are valid, or `GL_FALSE`
+ *  @return `GLFW_TRUE` if the context attributes are valid, or `GLFW_FALSE`
  *  otherwise.
  *  @ingroup utility
  *
@@ -837,16 +1005,7 @@ GLboolean _glfwRefreshContextAttribs(const _GLFWctxconfig* ctxconfig);
  *  exists and whether all relevant options have supported and non-conflicting
  *  values.
  */
-GLboolean _glfwIsValidContextConfig(const _GLFWctxconfig* ctxconfig);
-
-/*! @brief Checks whether the current context fulfils the specified hard
- *  constraints.
- *  @param[in] ctxconfig The desired context attributes.
- *  @return `GL_TRUE` if the context fulfils the hard constraints, or `GL_FALSE`
- *  otherwise.
- *  @ingroup utility
- */
-GLboolean _glfwIsValidContext(const _GLFWctxconfig* ctxconfig);
+GLFWbool _glfwIsValidContextConfig(const _GLFWctxconfig* ctxconfig);
 
 /*! @ingroup utility
  */
@@ -875,4 +1034,20 @@ void _glfwFreeMonitor(_GLFWmonitor* monitor);
   */
 void _glfwFreeMonitors(_GLFWmonitor** monitors, int count);
 
+/*! @ingroup utility
+ */
+GLFWbool _glfwIsPrintable(int key);
+
+/*! @ingroup utility
+ */
+void _glfwInitVulkan(void);
+
+/*! @ingroup utility
+ */
+void _glfwTerminateVulkan(void);
+
+/*! @ingroup utility
+ */
+const char* _glfwGetVulkanResultString(VkResult result);
+
 #endif // _glfw3_internal_h_

src/linux_joystick.c

@@ -1,8 +1,8 @@
 //========================================================================
-// GLFW 3.1 Linux - www.glfw.org
+// GLFW 3.2 Linux - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
+// Copyright (c) 2006-2016 Camilla Berglund <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 @@
 
 // Attempt to open the specified joystick device
 //
-static void openJoystickDevice(const char* path)
-{
 #if defined(__linux__)
+static GLFWbool openJoystickDevice(const char* path)
+{
     char axisCount, buttonCount;
     char name[256];
     int joy, fd, version;
+    _GLFWjoystickLinux* js;
 
     for (joy = GLFW_JOYSTICK_1;  joy <= GLFW_JOYSTICK_LAST;  joy++)
     {
@@ -58,7 +59,7 @@ static void openJoystickDevice(const char* path)
             continue;
 
         if (strcmp(_glfw.linux_js.js[joy].path, path) == 0)
-            return;
+            return GLFW_FALSE;
     }
 
     for (joy = GLFW_JOYSTICK_1;  joy <= GLFW_JOYSTICK_LAST;  joy++)
@@ -68,13 +69,11 @@ static void openJoystickDevice(const char* path)
     }
 
     if (joy > GLFW_JOYSTICK_LAST)
-        return;
+        return GLFW_FALSE;
 
     fd = open(path, O_RDONLY | O_NONBLOCK);
     if (fd == -1)
-        return;
-
-    _glfw.linux_js.js[joy].fd = fd;
+        return GLFW_FALSE;
 
     // Verify that the joystick driver version is at least 1.0
     ioctl(fd, JSIOCGVERSION, &version);
@@ -82,104 +81,89 @@ static void openJoystickDevice(const char* path)
     {
         // It's an old 0.x interface (we don't support it)
         close(fd);
-        return;
+        return GLFW_FALSE;
     }
 
     if (ioctl(fd, JSIOCGNAME(sizeof(name)), name) < 0)
         strncpy(name, "Unknown", sizeof(name));
 
-    _glfw.linux_js.js[joy].name = strdup(name);
-    _glfw.linux_js.js[joy].path = strdup(path);
+    js = _glfw.linux_js.js + joy;
+    js->present = GLFW_TRUE;
+    js->name = strdup(name);
+    js->path = strdup(path);
+    js->fd = fd;
 
     ioctl(fd, JSIOCGAXES, &axisCount);
-    _glfw.linux_js.js[joy].axisCount = (int) axisCount;
+    js->axisCount = (int) axisCount;
+    js->axes = calloc(axisCount, sizeof(float));
 
     ioctl(fd, JSIOCGBUTTONS, &buttonCount);
-    _glfw.linux_js.js[joy].buttonCount = (int) buttonCount;
+    js->buttonCount = (int) buttonCount;
+    js->buttons = calloc(buttonCount, 1);
 
-    _glfw.linux_js.js[joy].axes = calloc(axisCount, sizeof(float));
-    _glfw.linux_js.js[joy].buttons = calloc(buttonCount, 1);
-
-    _glfw.linux_js.js[joy].present = GL_TRUE;
-#endif // __linux__
+    _glfwInputJoystickChange(joy, GLFW_CONNECTED);
+    return GLFW_TRUE;
 }
+#endif // __linux__
 
-// Polls for and processes events for all present joysticks
+// Polls for and processes events the specified joystick
 //
-static void pollJoystickEvents(void)
+static GLFWbool pollJoystickEvents(_GLFWjoystickLinux* js)
 {
 #if defined(__linux__)
-    int i;
-    struct js_event e;
-    ssize_t offset = 0;
-    char buffer[16384];
+    _glfwPollJoystickEvents();
 
-    const ssize_t size = read(_glfw.linux_js.inotify, buffer, sizeof(buffer));
+    if (!js->present)
+        return GLFW_FALSE;
 
-    while (size > offset)
+    // Read all queued events (non-blocking)
+    for (;;)
     {
-        regmatch_t match;
-        const struct inotify_event* e = (struct inotify_event*) (buffer + offset);
+        struct js_event e;
 
-        if (regexec(&_glfw.linux_js.regex, e->name, 1, &match, 0) == 0)
+        errno = 0;
+        if (read(js->fd, &e, sizeof(e)) < 0)
         {
-            char path[20];
-            snprintf(path, sizeof(path), "/dev/input/%s", e->name);
-            openJoystickDevice(path);
-        }
-
-        offset += sizeof(struct inotify_event) + e->len;
-    }
-
-    for (i = 0;  i <= GLFW_JOYSTICK_LAST;  i++)
-    {
-        if (!_glfw.linux_js.js[i].present)
-            continue;
-
-        // Read all queued events (non-blocking)
-        for (;;)
-        {
-            errno = 0;
-            if (read(_glfw.linux_js.js[i].fd, &e, sizeof(e)) < 0)
+            // Reset the joystick slot if the device was disconnected
+            if (errno == ENODEV)
             {
-                if (errno == ENODEV)
-                {
-                    // The joystick was disconnected
+                free(js->axes);
+                free(js->buttons);
+                free(js->name);
+                free(js->path);
 
-                    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);
+                memset(js, 0, sizeof(_GLFWjoystickLinux));
 
-                    memset(&_glfw.linux_js.js[i], 0, sizeof(_glfw.linux_js.js[i]));
-                }
-
-                break;
+                _glfwInputJoystickChange(js - _glfw.linux_js.js,
+                                         GLFW_DISCONNECTED);
             }
 
-            // We don't care if it's an init event or not
-            e.type &= ~JS_EVENT_INIT;
-
-            switch (e.type)
-            {
-                case JS_EVENT_AXIS:
-                    _glfw.linux_js.js[i].axes[e.number] =
-                        (float) e.value / 32767.0f;
-                    break;
-
-                case JS_EVENT_BUTTON:
-                    _glfw.linux_js.js[i].buttons[e.number] =
-                        e.value ? GLFW_PRESS : GLFW_RELEASE;
-                    break;
-
-                default:
-                    break;
-            }
+            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, used by quicksort
+//
+#if defined(__linux__)
+static int compareJoysticks(const void* fp, const void* sp)
+{
+    const _GLFWjoystickLinux* fj = fp;
+    const _GLFWjoystickLinux* sj = sp;
+    return strcmp(fj->path, sj->path);
+}
+#endif // __linux__
+
 
 //////////////////////////////////////////////////////////////////////////
 //////                       GLFW internal API                      //////
@@ -187,11 +171,12 @@ static void pollJoystickEvents(void)
 
 // Initialize joystick interface
 //
-int _glfwInitJoysticks(void)
+GLFWbool _glfwInitJoysticksLinux(void)
 {
 #if defined(__linux__)
-    const char* dirname = "/dev/input";
     DIR* dir;
+    int count = 0;
+    const char* dirname = "/dev/input";
 
     _glfw.linux_js.inotify = inotify_init1(IN_NONBLOCK | IN_CLOEXEC);
     if (_glfw.linux_js.inotify == -1)
@@ -199,7 +184,7 @@ int _glfwInitJoysticks(void)
         _glfwInputError(GLFW_PLATFORM_ERROR,
                         "Linux: Failed to initialize inotify: %s",
                         strerror(errno));
-        return GL_FALSE;
+        return GLFW_FALSE;
     }
 
     // HACK: Register for IN_ATTRIB as well to get notified when udev is done
@@ -220,7 +205,7 @@ int _glfwInitJoysticks(void)
     if (regcomp(&_glfw.linux_js.regex, "^js[0-9]\\+$", 0) != 0)
     {
         _glfwInputError(GLFW_PLATFORM_ERROR, "Linux: Failed to compile regex");
-        return GL_FALSE;
+        return GLFW_FALSE;
     }
 
     dir = opendir(dirname);
@@ -237,7 +222,8 @@ int _glfwInitJoysticks(void)
                 continue;
 
             snprintf(path, sizeof(path), "%s/%s", dirname, entry->d_name);
-            openJoystickDevice(path);
+            if (openJoystickDevice(path))
+                count++;
         }
 
         closedir(dir);
@@ -251,14 +237,15 @@ int _glfwInitJoysticks(void)
         // Continue with no joysticks detected
     }
 
+    qsort(_glfw.linux_js.js, count, sizeof(_GLFWjoystickLinux), compareJoysticks);
 #endif // __linux__
 
-    return GL_TRUE;
+    return GLFW_TRUE;
 }
 
 // Close all opened joystick handles
 //
-void _glfwTerminateJoysticks(void)
+void _glfwTerminateJoysticksLinux(void)
 {
 #if defined(__linux__)
     int i;
@@ -287,6 +274,31 @@ void _glfwTerminateJoysticks(void)
 #endif // __linux__
 }
 
+void _glfwPollJoystickEvents(void)
+{
+#if defined(__linux__)
+    ssize_t offset = 0;
+    char buffer[16384];
+
+    const ssize_t size = read(_glfw.linux_js.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;
+    }
+#endif
+}
+
 
 //////////////////////////////////////////////////////////////////////////
 //////                       GLFW platform API                      //////
@@ -294,31 +306,36 @@ void _glfwTerminateJoysticks(void)
 
 int _glfwPlatformJoystickPresent(int joy)
 {
-    pollJoystickEvents();
-
-    return _glfw.linux_js.js[joy].present;
+    _GLFWjoystickLinux* js = _glfw.linux_js.js + joy;
+    return pollJoystickEvents(js);
 }
 
 const float* _glfwPlatformGetJoystickAxes(int joy, int* count)
 {
-    pollJoystickEvents();
+    _GLFWjoystickLinux* js = _glfw.linux_js.js + joy;
+    if (!pollJoystickEvents(js))
+        return NULL;
 
-    *count = _glfw.linux_js.js[joy].axisCount;
-    return _glfw.linux_js.js[joy].axes;
+    *count = js->axisCount;
+    return js->axes;
 }
 
 const unsigned char* _glfwPlatformGetJoystickButtons(int joy, int* count)
 {
-    pollJoystickEvents();
+    _GLFWjoystickLinux* js = _glfw.linux_js.js + joy;
+    if (!pollJoystickEvents(js))
+        return NULL;
 
-    *count = _glfw.linux_js.js[joy].buttonCount;
-    return _glfw.linux_js.js[joy].buttons;
+    *count = js->buttonCount;
+    return js->buttons;
 }
 
 const char* _glfwPlatformGetJoystickName(int joy)
 {
-    pollJoystickEvents();
+    _GLFWjoystickLinux* js = _glfw.linux_js.js + joy;
+    if (!pollJoystickEvents(js))
+        return NULL;
 
-    return _glfw.linux_js.js[joy].name;
+    return js->name;
 }
 

src/linux_joystick.h

@@ -1,5 +1,5 @@
 //========================================================================
-// GLFW 3.1 Linux - www.glfw.org
+// GLFW 3.2 Linux - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2014 Jonas Ådahl <jadahl@gmail.com>
 //
@@ -29,35 +29,41 @@
 
 #include <regex.h>
 
-#define _GLFW_PLATFORM_LIBRARY_JOYSTICK_STATE \
-    _GLFWjoystickLinux linux_js
+#define _GLFW_PLATFORM_LIBRARY_JOYSTICK_STATE _GLFWjoylistLinux linux_js
+
+
+// Linux-specific joystick data
+//
+typedef struct _GLFWjoystickLinux
+{
+    GLFWbool        present;
+    int             fd;
+    float*          axes;
+    int             axisCount;
+    unsigned char*  buttons;
+    int             buttonCount;
+    char*           name;
+    char*           path;
+} _GLFWjoystickLinux;
 
 
 // Linux-specific joystick API data
 //
-typedef struct _GLFWjoystickLinux
+typedef struct _GLFWjoylistLinux
 {
-    struct
-    {
-        int             present;
-        int             fd;
-        float*          axes;
-        int             axisCount;
-        unsigned char*  buttons;
-        int             buttonCount;
-        char*           name;
-        char*           path;
-    } js[GLFW_JOYSTICK_LAST + 1];
+    _GLFWjoystickLinux js[GLFW_JOYSTICK_LAST + 1];
 
 #if defined(__linux__)
     int             inotify;
     int             watch;
     regex_t         regex;
 #endif /*__linux__*/
-} _GLFWjoystickLinux;
+} _GLFWjoylistLinux;
 
 
-int _glfwInitJoysticks(void);
-void _glfwTerminateJoysticks(void);
+GLFWbool _glfwInitJoysticksLinux(void);
+void _glfwTerminateJoysticksLinux(void);
+
+void _glfwPollJoystickEvents(void);
 
 #endif // _glfw3_linux_joystick_h_

src/mir_init.c

@@ -1,5 +1,5 @@
 //========================================================================
-// GLFW 3.1 Mir - www.glfw.org
+// GLFW 3.2 Mir - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2014-2015 Brandon Schaefer <brandon.schaefer@canonical.com>
 //
@@ -26,10 +26,136 @@
 
 #include "internal.h"
 
+#include <linux/input.h>
 #include <stdlib.h>
 #include <string.h>
 
 
+// Create key code translation tables
+//
+static void createKeyTables(void)
+{
+    memset(_glfw.mir.publicKeys, -1, sizeof(_glfw.mir.publicKeys));
+
+    _glfw.mir.publicKeys[KEY_GRAVE]      = GLFW_KEY_GRAVE_ACCENT;
+    _glfw.mir.publicKeys[KEY_1]          = GLFW_KEY_1;
+    _glfw.mir.publicKeys[KEY_2]          = GLFW_KEY_2;
+    _glfw.mir.publicKeys[KEY_3]          = GLFW_KEY_3;
+    _glfw.mir.publicKeys[KEY_4]          = GLFW_KEY_4;
+    _glfw.mir.publicKeys[KEY_5]          = GLFW_KEY_5;
+    _glfw.mir.publicKeys[KEY_6]          = GLFW_KEY_6;
+    _glfw.mir.publicKeys[KEY_7]          = GLFW_KEY_7;
+    _glfw.mir.publicKeys[KEY_8]          = GLFW_KEY_8;
+    _glfw.mir.publicKeys[KEY_9]          = GLFW_KEY_9;
+    _glfw.mir.publicKeys[KEY_0]          = GLFW_KEY_0;
+    _glfw.mir.publicKeys[KEY_MINUS]      = GLFW_KEY_MINUS;
+    _glfw.mir.publicKeys[KEY_EQUAL]      = GLFW_KEY_EQUAL;
+    _glfw.mir.publicKeys[KEY_Q]          = GLFW_KEY_Q;
+    _glfw.mir.publicKeys[KEY_W]          = GLFW_KEY_W;
+    _glfw.mir.publicKeys[KEY_E]          = GLFW_KEY_E;
+    _glfw.mir.publicKeys[KEY_R]          = GLFW_KEY_R;
+    _glfw.mir.publicKeys[KEY_T]          = GLFW_KEY_T;
+    _glfw.mir.publicKeys[KEY_Y]          = GLFW_KEY_Y;
+    _glfw.mir.publicKeys[KEY_U]          = GLFW_KEY_U;
+    _glfw.mir.publicKeys[KEY_I]          = GLFW_KEY_I;
+    _glfw.mir.publicKeys[KEY_O]          = GLFW_KEY_O;
+    _glfw.mir.publicKeys[KEY_P]          = GLFW_KEY_P;
+    _glfw.mir.publicKeys[KEY_LEFTBRACE]  = GLFW_KEY_LEFT_BRACKET;
+    _glfw.mir.publicKeys[KEY_RIGHTBRACE] = GLFW_KEY_RIGHT_BRACKET;
+    _glfw.mir.publicKeys[KEY_A]          = GLFW_KEY_A;
+    _glfw.mir.publicKeys[KEY_S]          = GLFW_KEY_S;
+    _glfw.mir.publicKeys[KEY_D]          = GLFW_KEY_D;
+    _glfw.mir.publicKeys[KEY_F]          = GLFW_KEY_F;
+    _glfw.mir.publicKeys[KEY_G]          = GLFW_KEY_G;
+    _glfw.mir.publicKeys[KEY_H]          = GLFW_KEY_H;
+    _glfw.mir.publicKeys[KEY_J]          = GLFW_KEY_J;
+    _glfw.mir.publicKeys[KEY_K]          = GLFW_KEY_K;
+    _glfw.mir.publicKeys[KEY_L]          = GLFW_KEY_L;
+    _glfw.mir.publicKeys[KEY_SEMICOLON]  = GLFW_KEY_SEMICOLON;
+    _glfw.mir.publicKeys[KEY_APOSTROPHE] = GLFW_KEY_APOSTROPHE;
+    _glfw.mir.publicKeys[KEY_Z]          = GLFW_KEY_Z;
+    _glfw.mir.publicKeys[KEY_X]          = GLFW_KEY_X;
+    _glfw.mir.publicKeys[KEY_C]          = GLFW_KEY_C;
+    _glfw.mir.publicKeys[KEY_V]          = GLFW_KEY_V;
+    _glfw.mir.publicKeys[KEY_B]          = GLFW_KEY_B;
+    _glfw.mir.publicKeys[KEY_N]          = GLFW_KEY_N;
+    _glfw.mir.publicKeys[KEY_M]          = GLFW_KEY_M;
+    _glfw.mir.publicKeys[KEY_COMMA]      = GLFW_KEY_COMMA;
+    _glfw.mir.publicKeys[KEY_DOT]        = GLFW_KEY_PERIOD;
+    _glfw.mir.publicKeys[KEY_SLASH]      = GLFW_KEY_SLASH;
+    _glfw.mir.publicKeys[KEY_BACKSLASH]  = GLFW_KEY_BACKSLASH;
+    _glfw.mir.publicKeys[KEY_ESC]        = GLFW_KEY_ESCAPE;
+    _glfw.mir.publicKeys[KEY_TAB]        = GLFW_KEY_TAB;
+    _glfw.mir.publicKeys[KEY_LEFTSHIFT]  = GLFW_KEY_LEFT_SHIFT;
+    _glfw.mir.publicKeys[KEY_RIGHTSHIFT] = GLFW_KEY_RIGHT_SHIFT;
+    _glfw.mir.publicKeys[KEY_LEFTCTRL]   = GLFW_KEY_LEFT_CONTROL;
+    _glfw.mir.publicKeys[KEY_RIGHTCTRL]  = GLFW_KEY_RIGHT_CONTROL;
+    _glfw.mir.publicKeys[KEY_LEFTALT]    = GLFW_KEY_LEFT_ALT;
+    _glfw.mir.publicKeys[KEY_RIGHTALT]   = GLFW_KEY_RIGHT_ALT;
+    _glfw.mir.publicKeys[KEY_LEFTMETA]   = GLFW_KEY_LEFT_SUPER;
+    _glfw.mir.publicKeys[KEY_RIGHTMETA]  = GLFW_KEY_RIGHT_SUPER;
+    _glfw.mir.publicKeys[KEY_MENU]       = GLFW_KEY_MENU;
+    _glfw.mir.publicKeys[KEY_NUMLOCK]    = GLFW_KEY_NUM_LOCK;
+    _glfw.mir.publicKeys[KEY_CAPSLOCK]   = GLFW_KEY_CAPS_LOCK;
+    _glfw.mir.publicKeys[KEY_PRINT]      = GLFW_KEY_PRINT_SCREEN;
+    _glfw.mir.publicKeys[KEY_SCROLLLOCK] = GLFW_KEY_SCROLL_LOCK;
+    _glfw.mir.publicKeys[KEY_PAUSE]      = GLFW_KEY_PAUSE;
+    _glfw.mir.publicKeys[KEY_DELETE]     = GLFW_KEY_DELETE;
+    _glfw.mir.publicKeys[KEY_BACKSPACE]  = GLFW_KEY_BACKSPACE;
+    _glfw.mir.publicKeys[KEY_ENTER]      = GLFW_KEY_ENTER;
+    _glfw.mir.publicKeys[KEY_HOME]       = GLFW_KEY_HOME;
+    _glfw.mir.publicKeys[KEY_END]        = GLFW_KEY_END;
+    _glfw.mir.publicKeys[KEY_PAGEUP]     = GLFW_KEY_PAGE_UP;
+    _glfw.mir.publicKeys[KEY_PAGEDOWN]   = GLFW_KEY_PAGE_DOWN;
+    _glfw.mir.publicKeys[KEY_INSERT]     = GLFW_KEY_INSERT;
+    _glfw.mir.publicKeys[KEY_LEFT]       = GLFW_KEY_LEFT;
+    _glfw.mir.publicKeys[KEY_RIGHT]      = GLFW_KEY_RIGHT;
+    _glfw.mir.publicKeys[KEY_DOWN]       = GLFW_KEY_DOWN;
+    _glfw.mir.publicKeys[KEY_UP]         = GLFW_KEY_UP;
+    _glfw.mir.publicKeys[KEY_F1]         = GLFW_KEY_F1;
+    _glfw.mir.publicKeys[KEY_F2]         = GLFW_KEY_F2;
+    _glfw.mir.publicKeys[KEY_F3]         = GLFW_KEY_F3;
+    _glfw.mir.publicKeys[KEY_F4]         = GLFW_KEY_F4;
+    _glfw.mir.publicKeys[KEY_F5]         = GLFW_KEY_F5;
+    _glfw.mir.publicKeys[KEY_F6]         = GLFW_KEY_F6;
+    _glfw.mir.publicKeys[KEY_F7]         = GLFW_KEY_F7;
+    _glfw.mir.publicKeys[KEY_F8]         = GLFW_KEY_F8;
+    _glfw.mir.publicKeys[KEY_F9]         = GLFW_KEY_F9;
+    _glfw.mir.publicKeys[KEY_F10]        = GLFW_KEY_F10;
+    _glfw.mir.publicKeys[KEY_F11]        = GLFW_KEY_F11;
+    _glfw.mir.publicKeys[KEY_F12]        = GLFW_KEY_F12;
+    _glfw.mir.publicKeys[KEY_F13]        = GLFW_KEY_F13;
+    _glfw.mir.publicKeys[KEY_F14]        = GLFW_KEY_F14;
+    _glfw.mir.publicKeys[KEY_F15]        = GLFW_KEY_F15;
+    _glfw.mir.publicKeys[KEY_F16]        = GLFW_KEY_F16;
+    _glfw.mir.publicKeys[KEY_F17]        = GLFW_KEY_F17;
+    _glfw.mir.publicKeys[KEY_F18]        = GLFW_KEY_F18;
+    _glfw.mir.publicKeys[KEY_F19]        = GLFW_KEY_F19;
+    _glfw.mir.publicKeys[KEY_F20]        = GLFW_KEY_F20;
+    _glfw.mir.publicKeys[KEY_F21]        = GLFW_KEY_F21;
+    _glfw.mir.publicKeys[KEY_F22]        = GLFW_KEY_F22;
+    _glfw.mir.publicKeys[KEY_F23]        = GLFW_KEY_F23;
+    _glfw.mir.publicKeys[KEY_F24]        = GLFW_KEY_F24;
+    _glfw.mir.publicKeys[KEY_KPSLASH]    = GLFW_KEY_KP_DIVIDE;
+    _glfw.mir.publicKeys[KEY_KPDOT]      = GLFW_KEY_KP_MULTIPLY;
+    _glfw.mir.publicKeys[KEY_KPMINUS]    = GLFW_KEY_KP_SUBTRACT;
+    _glfw.mir.publicKeys[KEY_KPPLUS]     = GLFW_KEY_KP_ADD;
+    _glfw.mir.publicKeys[KEY_KP0]        = GLFW_KEY_KP_0;
+    _glfw.mir.publicKeys[KEY_KP1]        = GLFW_KEY_KP_1;
+    _glfw.mir.publicKeys[KEY_KP2]        = GLFW_KEY_KP_2;
+    _glfw.mir.publicKeys[KEY_KP3]        = GLFW_KEY_KP_3;
+    _glfw.mir.publicKeys[KEY_KP4]        = GLFW_KEY_KP_4;
+    _glfw.mir.publicKeys[KEY_KP5]        = GLFW_KEY_KP_5;
+    _glfw.mir.publicKeys[KEY_KP6]        = GLFW_KEY_KP_6;
+    _glfw.mir.publicKeys[KEY_KP7]        = GLFW_KEY_KP_7;
+    _glfw.mir.publicKeys[KEY_KP8]        = GLFW_KEY_KP_8;
+    _glfw.mir.publicKeys[KEY_KP9]        = GLFW_KEY_KP_9;
+    _glfw.mir.publicKeys[KEY_KPCOMMA]    = GLFW_KEY_KP_DECIMAL;
+    _glfw.mir.publicKeys[KEY_KPEQUAL]    = GLFW_KEY_KP_EQUAL;
+    _glfw.mir.publicKeys[KEY_KPENTER]    = GLFW_KEY_KP_ENTER;
+}
+
+
 //////////////////////////////////////////////////////////////////////////
 //////                       GLFW internal API                      //////
 //////////////////////////////////////////////////////////////////////////
@@ -46,23 +172,30 @@ int _glfwPlatformInit(void)
                         "Mir: Unable to connect to server: %s",
                         mir_connection_get_error_message(_glfw.mir.connection));
 
-        return GL_FALSE;
+        return GLFW_FALSE;
     }
 
     _glfw.mir.display =
         mir_connection_get_egl_native_display(_glfw.mir.connection);
 
-    if (!_glfwInitContextAPI())
-        return GL_FALSE;
+    createKeyTables();
+
+    if (!_glfwInitThreadLocalStoragePOSIX())
+        return GLFW_FALSE;
+
+    if (!_glfwInitEGL())
+        return GLFW_FALSE;
+
+    if (!_glfwInitJoysticksLinux())
+        return GLFW_FALSE;
+
+    _glfwInitTimerPOSIX();
 
     // Need the default conf for when we set a NULL cursor
     _glfw.mir.default_conf = mir_cursor_configuration_from_name(mir_arrow_cursor_name);
 
-    _glfwInitTimer();
-    _glfwInitJoysticks();
-
     _glfw.mir.event_queue = calloc(1, sizeof(EventQueue));
-    _glfwInitEventQueue(_glfw.mir.event_queue);
+    _glfwInitEventQueueMir(_glfw.mir.event_queue);
 
     error = pthread_mutex_init(&_glfw.mir.event_mutex, NULL);
     if (error)
@@ -70,18 +203,19 @@ int _glfwPlatformInit(void)
         _glfwInputError(GLFW_PLATFORM_ERROR,
                         "Mir: Failed to create event mutex: %s",
                         strerror(error));
-        return GL_FALSE;
+        return GLFW_FALSE;
     }
 
-    return GL_TRUE;
+    return GLFW_TRUE;
 }
 
 void _glfwPlatformTerminate(void)
 {
-    _glfwTerminateContextAPI();
-    _glfwTerminateJoysticks();
+    _glfwTerminateEGL();
+    _glfwTerminateJoysticksLinux();
+    _glfwTerminateThreadLocalStoragePOSIX();
 
-    _glfwDeleteEventQueue(_glfw.mir.event_queue);
+    _glfwDeleteEventQueueMir(_glfw.mir.event_queue);
 
     pthread_mutex_destroy(&_glfw.mir.event_mutex);
 

src/mir_monitor.c

@@ -1,5 +1,5 @@
 //========================================================================
-// GLFW 3.1 Mir - www.glfw.org
+// GLFW 3.2 Mir - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2014-2015 Brandon Schaefer <brandon.schaefer@canonical.com>
 //
@@ -73,7 +73,7 @@ _GLFWmonitor** _glfwPlatformGetMonitors(int* count)
     return monitors;
 }
 
-GLboolean _glfwPlatformIsSameMonitor(_GLFWmonitor* first, _GLFWmonitor* second)
+GLFWbool _glfwPlatformIsSameMonitor(_GLFWmonitor* first, _GLFWmonitor* second)
 {
     return first->mir.output_id == second->mir.output_id;
 }
@@ -168,3 +168,15 @@ void _glfwPlatformSetGammaRamp(_GLFWmonitor* monitor, const GLFWgammaramp* ramp)
                     "Mir: Unsupported function %s", __PRETTY_FUNCTION__);
 }
 
+
+//////////////////////////////////////////////////////////////////////////
+//////                        GLFW native API                       //////
+//////////////////////////////////////////////////////////////////////////
+
+GLFWAPI int glfwGetMirMonitor(GLFWmonitor* handle)
+{
+    _GLFWmonitor* monitor = (_GLFWmonitor*) handle;
+    _GLFW_REQUIRE_INIT_OR_RETURN(0);
+    return monitor->mir.output_id;
+}
+

src/mir_platform.h

@@ -1,5 +1,5 @@
 //========================================================================
-// GLFW 3.1 Mir - www.glfw.org
+// GLFW 3.2 Mir - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2014-2015 Brandon Schaefer <brandon.schaefer@canonical.com>
 //
@@ -29,28 +29,45 @@
 
 #include <sys/queue.h>
 #include <pthread.h>
+#include <dlfcn.h>
 
 #include <mir_toolkit/mir_client_library.h>
 
+typedef VkFlags VkMirSurfaceCreateFlagsKHR;
+
+typedef struct VkMirSurfaceCreateInfoKHR
+{
+    VkStructureType             sType;
+    const void*                 pNext;
+    VkMirSurfaceCreateFlagsKHR  flags;
+    MirConnection*              connection;
+    MirSurface*                 mirSurface;
+} VkMirSurfaceCreateInfoKHR;
+
+typedef VkResult (APIENTRY *PFN_vkCreateMirSurfaceKHR)(VkInstance,const VkMirSurfaceCreateInfoKHR*,const VkAllocationCallbacks*,VkSurfaceKHR*);
+typedef VkBool32 (APIENTRY *PFN_vkGetPhysicalDeviceMirPresentationSupportKHR)(VkPhysicalDevice,uint32_t,MirConnection*);
+
 #include "posix_tls.h"
 #include "posix_time.h"
 #include "linux_joystick.h"
 #include "xkb_unicode.h"
+#include "egl_context.h"
 
-#if defined(_GLFW_EGL)
- #include "egl_context.h"
-#else
- #error "The Mir backend depends on EGL platform support"
-#endif
+#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  window->mir.window
-#define _GLFW_EGL_NATIVE_DISPLAY _glfw.mir.display
+#define _GLFW_EGL_NATIVE_WINDOW  ((EGLNativeWindowType) window->mir.window)
+#define _GLFW_EGL_NATIVE_DISPLAY ((EGLNativeDisplayType) _glfw.mir.display)
 
 #define _GLFW_PLATFORM_WINDOW_STATE         _GLFWwindowMir  mir
 #define _GLFW_PLATFORM_MONITOR_STATE        _GLFWmonitorMir mir
 #define _GLFW_PLATFORM_LIBRARY_WINDOW_STATE _GLFWlibraryMir mir
 #define _GLFW_PLATFORM_CURSOR_STATE         _GLFWcursorMir  mir
 
+#define _GLFW_PLATFORM_CONTEXT_STATE
+#define _GLFW_PLATFORM_LIBRARY_CONTEXT_STATE
+
 
 // Mir-specific Event Queue
 //
@@ -92,6 +109,8 @@ typedef struct _GLFWlibraryMir
     MirCursorConfiguration* default_conf;
     EventQueue* event_queue;
 
+    short int       publicKeys[256];
+
     pthread_mutex_t event_mutex;
     pthread_cond_t  event_cond;
 
@@ -108,7 +127,7 @@ typedef struct _GLFWcursorMir
 } _GLFWcursorMir;
 
 
-extern void _glfwInitEventQueue(EventQueue* queue);
-extern void _glfwDeleteEventQueue(EventQueue* queue);
+extern void _glfwInitEventQueueMir(EventQueue* queue);
+extern void _glfwDeleteEventQueueMir(EventQueue* queue);
 
 #endif // _glfw3_mir_platform_h_

src/mir_window.c

@@ -1,5 +1,5 @@
 //========================================================================
-// GLFW 3.1 Mir - www.glfw.org
+// GLFW 3.2 Mir - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2014-2015 Brandon Schaefer <brandon.schaefer@canonical.com>
 //
@@ -44,9 +44,9 @@ static void deleteNode(EventQueue* queue, EventNode* node)
     free(node);
 }
 
-static int emptyEventQueue(EventQueue* queue)
+static GLFWbool emptyEventQueue(EventQueue* queue)
 {
-    return queue->head.tqh_first == NULL ? GL_TRUE : GL_FALSE;
+    return queue->head.tqh_first == NULL;
 }
 
 // TODO The mir_event_ref is not supposed to be used but ... its needed
@@ -130,129 +130,12 @@ static int mirModToGLFWMod(uint32_t mods)
     return publicMods;
 }
 
-// Taken from wl_init.c
 static int toGLFWKeyCode(uint32_t key)
 {
-    switch (key)
-    {
-        case KEY_GRAVE:         return GLFW_KEY_GRAVE_ACCENT;
-        case KEY_1:             return GLFW_KEY_1;
-        case KEY_2:             return GLFW_KEY_2;
-        case KEY_3:             return GLFW_KEY_3;
-        case KEY_4:             return GLFW_KEY_4;
-        case KEY_5:             return GLFW_KEY_5;
-        case KEY_6:             return GLFW_KEY_6;
-        case KEY_7:             return GLFW_KEY_7;
-        case KEY_8:             return GLFW_KEY_8;
-        case KEY_9:             return GLFW_KEY_9;
-        case KEY_0:             return GLFW_KEY_0;
-        case KEY_MINUS:         return GLFW_KEY_MINUS;
-        case KEY_EQUAL:         return GLFW_KEY_EQUAL;
-        case KEY_Q:             return GLFW_KEY_Q;
-        case KEY_W:             return GLFW_KEY_W;
-        case KEY_E:             return GLFW_KEY_E;
-        case KEY_R:             return GLFW_KEY_R;
-        case KEY_T:             return GLFW_KEY_T;
-        case KEY_Y:             return GLFW_KEY_Y;
-        case KEY_U:             return GLFW_KEY_U;
-        case KEY_I:             return GLFW_KEY_I;
-        case KEY_O:             return GLFW_KEY_O;
-        case KEY_P:             return GLFW_KEY_P;
-        case KEY_LEFTBRACE:     return GLFW_KEY_LEFT_BRACKET;
-        case KEY_RIGHTBRACE:    return GLFW_KEY_RIGHT_BRACKET;
-        case KEY_A:             return GLFW_KEY_A;
-        case KEY_S:             return GLFW_KEY_S;
-        case KEY_D:             return GLFW_KEY_D;
-        case KEY_F:             return GLFW_KEY_F;
-        case KEY_G:             return GLFW_KEY_G;
-        case KEY_H:             return GLFW_KEY_H;
-        case KEY_J:             return GLFW_KEY_J;
-        case KEY_K:             return GLFW_KEY_K;
-        case KEY_L:             return GLFW_KEY_L;
-        case KEY_SEMICOLON:     return GLFW_KEY_SEMICOLON;
-        case KEY_APOSTROPHE:    return GLFW_KEY_APOSTROPHE;
-        case KEY_Z:             return GLFW_KEY_Z;
-        case KEY_X:             return GLFW_KEY_X;
-        case KEY_C:             return GLFW_KEY_C;
-        case KEY_V:             return GLFW_KEY_V;
-        case KEY_B:             return GLFW_KEY_B;
-        case KEY_N:             return GLFW_KEY_N;
-        case KEY_M:             return GLFW_KEY_M;
-        case KEY_COMMA:         return GLFW_KEY_COMMA;
-        case KEY_DOT:           return GLFW_KEY_PERIOD;
-        case KEY_SLASH:         return GLFW_KEY_SLASH;
-        case KEY_BACKSLASH:     return GLFW_KEY_BACKSLASH;
-        case KEY_ESC:           return GLFW_KEY_ESCAPE;
-        case KEY_TAB:           return GLFW_KEY_TAB;
-        case KEY_LEFTSHIFT:     return GLFW_KEY_LEFT_SHIFT;
-        case KEY_RIGHTSHIFT:    return GLFW_KEY_RIGHT_SHIFT;
-        case KEY_LEFTCTRL:      return GLFW_KEY_LEFT_CONTROL;
-        case KEY_RIGHTCTRL:     return GLFW_KEY_RIGHT_CONTROL;
-        case KEY_LEFTALT:       return GLFW_KEY_LEFT_ALT;
-        case KEY_RIGHTALT:      return GLFW_KEY_RIGHT_ALT;
-        case KEY_LEFTMETA:      return GLFW_KEY_LEFT_SUPER;
-        case KEY_RIGHTMETA:     return GLFW_KEY_RIGHT_SUPER;
-        case KEY_MENU:          return GLFW_KEY_MENU;
-        case KEY_NUMLOCK:       return GLFW_KEY_NUM_LOCK;
-        case KEY_CAPSLOCK:      return GLFW_KEY_CAPS_LOCK;
-        case KEY_PRINT:         return GLFW_KEY_PRINT_SCREEN;
-        case KEY_SCROLLLOCK:    return GLFW_KEY_SCROLL_LOCK;
-        case KEY_PAUSE:         return GLFW_KEY_PAUSE;
-        case KEY_DELETE:        return GLFW_KEY_DELETE;
-        case KEY_BACKSPACE:     return GLFW_KEY_BACKSPACE;
-        case KEY_ENTER:         return GLFW_KEY_ENTER;
-        case KEY_HOME:          return GLFW_KEY_HOME;
-        case KEY_END:           return GLFW_KEY_END;
-        case KEY_PAGEUP:        return GLFW_KEY_PAGE_UP;
-        case KEY_PAGEDOWN:      return GLFW_KEY_PAGE_DOWN;
-        case KEY_INSERT:        return GLFW_KEY_INSERT;
-        case KEY_LEFT:          return GLFW_KEY_LEFT;
-        case KEY_RIGHT:         return GLFW_KEY_RIGHT;
-        case KEY_DOWN:          return GLFW_KEY_DOWN;
-        case KEY_UP:            return GLFW_KEY_UP;
-        case KEY_F1:            return GLFW_KEY_F1;
-        case KEY_F2:            return GLFW_KEY_F2;
-        case KEY_F3:            return GLFW_KEY_F3;
-        case KEY_F4:            return GLFW_KEY_F4;
-        case KEY_F5:            return GLFW_KEY_F5;
-        case KEY_F6:            return GLFW_KEY_F6;
-        case KEY_F7:            return GLFW_KEY_F7;
-        case KEY_F8:            return GLFW_KEY_F8;
-        case KEY_F9:            return GLFW_KEY_F9;
-        case KEY_F10:           return GLFW_KEY_F10;
-        case KEY_F11:           return GLFW_KEY_F11;
-        case KEY_F12:           return GLFW_KEY_F12;
-        case KEY_F13:           return GLFW_KEY_F13;
-        case KEY_F14:           return GLFW_KEY_F14;
-        case KEY_F15:           return GLFW_KEY_F15;
-        case KEY_F16:           return GLFW_KEY_F16;
-        case KEY_F17:           return GLFW_KEY_F17;
-        case KEY_F18:           return GLFW_KEY_F18;
-        case KEY_F19:           return GLFW_KEY_F19;
-        case KEY_F20:           return GLFW_KEY_F20;
-        case KEY_F21:           return GLFW_KEY_F21;
-        case KEY_F22:           return GLFW_KEY_F22;
-        case KEY_F23:           return GLFW_KEY_F23;
-        case KEY_F24:           return GLFW_KEY_F24;
-        case KEY_KPSLASH:       return GLFW_KEY_KP_DIVIDE;
-        case KEY_KPDOT:         return GLFW_KEY_KP_MULTIPLY;
-        case KEY_KPMINUS:       return GLFW_KEY_KP_SUBTRACT;
-        case KEY_KPPLUS:        return GLFW_KEY_KP_ADD;
-        case KEY_KP0:           return GLFW_KEY_KP_0;
-        case KEY_KP1:           return GLFW_KEY_KP_1;
-        case KEY_KP2:           return GLFW_KEY_KP_2;
-        case KEY_KP3:           return GLFW_KEY_KP_3;
-        case KEY_KP4:           return GLFW_KEY_KP_4;
-        case KEY_KP5:           return GLFW_KEY_KP_5;
-        case KEY_KP6:           return GLFW_KEY_KP_6;
-        case KEY_KP7:           return GLFW_KEY_KP_7;
-        case KEY_KP8:           return GLFW_KEY_KP_8;
-        case KEY_KP9:           return GLFW_KEY_KP_9;
-        case KEY_KPCOMMA:       return GLFW_KEY_KP_DECIMAL;
-        case KEY_KPEQUAL:       return GLFW_KEY_KP_EQUAL;
-        case KEY_KPENTER:       return GLFW_KEY_KP_ENTER;
-        default:                return GLFW_KEY_UNKNOWN;
-    }
+    if (key < sizeof(_glfw.mir.publicKeys) / sizeof(_glfw.mir.publicKeys[0]))
+        return _glfw.mir.publicKeys[key];
+
+    return GLFW_KEY_UNKNOWN;
 }
 
 static void handleKeyEvent(const MirKeyboardEvent* key_event, _GLFWwindow* window)
@@ -277,10 +160,15 @@ static void handlePointerButton(_GLFWwindow* window,
                               int pressed,
                               const MirPointerEvent* pointer_event)
 {
-    MirPointerButton button = mir_pointer_event_buttons  (pointer_event);
     int mods                = mir_pointer_event_modifiers(pointer_event);
     const int publicMods    = mirModToGLFWMod(mods);
-    int publicButton;
+    MirPointerButton button = mir_pointer_button_primary;
+    static uint32_t oldButtonStates = 0;
+    uint32_t newButtonStates        = mir_pointer_event_buttons(pointer_event);
+    int publicButton                = GLFW_MOUSE_BUTTON_LEFT;
+
+    // XOR our old button states our new states to figure out what was added or removed
+    button = newButtonStates ^ oldButtonStates;
 
     switch (button)
     {
@@ -305,21 +193,22 @@ static void handlePointerButton(_GLFWwindow* window,
             break;
     }
 
+    oldButtonStates = newButtonStates;
+
     _glfwInputMouseClick(window, publicButton, pressed, publicMods);
 }
 
 static void handlePointerMotion(_GLFWwindow* window,
                                 const MirPointerEvent* pointer_event)
 {
-    int current_x = window->cursorPosX;
-    int current_y = window->cursorPosY;
+    int current_x = window->virtualCursorPosX;
+    int current_y = window->virtualCursorPosY;
     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);
 
-    if (current_x != x || current_y != y)
-      _glfwInputCursorMotion(window, x, y);
+    _glfwInputCursorPos(window, x, y);
     if (dx != 0 || dy != 0)
       _glfwInputScroll(window, dx, dy);
 }
@@ -385,7 +274,7 @@ static void addNewEvent(MirSurface* surface, const MirEvent* event, void* contex
     enqueueEvent(event, context);
 }
 
-static int createSurface(_GLFWwindow* window)
+static GLFWbool createSurface(_GLFWwindow* window)
 {
     MirSurfaceSpec* spec;
     MirBufferUsage buffer_usage = mir_buffer_usage_hardware;
@@ -395,7 +284,7 @@ static int createSurface(_GLFWwindow* window)
     {
         _glfwInputError(GLFW_PLATFORM_ERROR,
                         "Mir: Unable to find a correct pixel format");
-        return GL_FALSE;
+        return GLFW_FALSE;
     }
  
     spec = mir_connection_create_spec_for_normal_surface(_glfw.mir.connection,
@@ -415,24 +304,24 @@ static int createSurface(_GLFWwindow* window)
                         "Mir: Unable to create surface: %s",
                         mir_surface_get_error_message(window->mir.surface));
 
-        return GL_FALSE;
+        return GLFW_FALSE;
     }
 
     mir_surface_set_event_handler(window->mir.surface, addNewEvent, window);
 
-    return GL_TRUE;
+    return GLFW_TRUE;
 }
 
 //////////////////////////////////////////////////////////////////////////
 //////                       GLFW internal API                      //////
 //////////////////////////////////////////////////////////////////////////
 
-void _glfwInitEventQueue(EventQueue* queue)
+void _glfwInitEventQueueMir(EventQueue* queue)
 {
     TAILQ_INIT(&queue->head);
 }
 
-void _glfwDeleteEventQueue(EventQueue* queue)
+void _glfwDeleteEventQueueMir(EventQueue* queue)
 {
     if (queue)
     {
@@ -462,13 +351,10 @@ int _glfwPlatformCreateWindow(_GLFWwindow* window,
                               const _GLFWctxconfig* ctxconfig,
                               const _GLFWfbconfig* fbconfig)
 {
-    if (!_glfwCreateContext(window, ctxconfig, fbconfig))
-        return GL_FALSE;
-
-    if (wndconfig->monitor)
+    if (window->monitor)
     {
         GLFWvidmode mode;
-        _glfwPlatformGetVideoMode(wndconfig->monitor, &mode);
+        _glfwPlatformGetVideoMode(window->monitor, &mode);
 
         mir_surface_set_state(window->mir.surface, mir_surface_state_fullscreen);
 
@@ -478,7 +364,7 @@ int _glfwPlatformCreateWindow(_GLFWwindow* window,
                             "Mir: Requested surface size too large: %ix%i",
                             wndconfig->width, wndconfig->height);
 
-            return GL_FALSE;
+            return GLFW_FALSE;
         }
     }
 
@@ -486,12 +372,18 @@ int _glfwPlatformCreateWindow(_GLFWwindow* window,
     window->mir.height = wndconfig->height;
 
     if (!createSurface(window))
-        return GL_FALSE;
+        return GLFW_FALSE;
 
     window->mir.window = mir_buffer_stream_get_egl_native_window(
                                    mir_surface_get_buffer_stream(window->mir.surface));
 
-    return GL_TRUE;
+    if (ctxconfig->client != GLFW_NO_API)
+    {
+        if (!_glfwCreateContextEGL(window, ctxconfig, fbconfig))
+            return GLFW_FALSE;
+    }
+
+    return GLFW_TRUE;
 }
 
 void _glfwPlatformDestroyWindow(_GLFWwindow* window)
@@ -502,7 +394,8 @@ void _glfwPlatformDestroyWindow(_GLFWwindow* window)
         window->mir.surface = NULL;
     }
 
-    _glfwDestroyContext(window);
+    if (window->context.client != GLFW_NO_API)
+        window->context.destroy(window);
 }
 
 void _glfwPlatformSetWindowTitle(_GLFWwindow* window, const char* title)
@@ -517,6 +410,13 @@ void _glfwPlatformSetWindowTitle(_GLFWwindow* window, const char* title)
     mir_surface_spec_release(spec);
 }
 
+void _glfwPlatformSetWindowIcon(_GLFWwindow* window,
+                                int count, const GLFWimage* images)
+{
+    _glfwInputError(GLFW_PLATFORM_ERROR,
+                    "Mir: Unsupported function %s", __PRETTY_FUNCTION__);
+}
+
 void _glfwPlatformSetWindowSize(_GLFWwindow* window, int width, int height)
 {
     MirSurfaceSpec* spec;
@@ -529,6 +429,20 @@ void _glfwPlatformSetWindowSize(_GLFWwindow* window, int width, int height)
     mir_surface_spec_release(spec);
 }
 
+void _glfwPlatformSetWindowSizeLimits(_GLFWwindow* window,
+                                      int minwidth, int minheight,
+                                      int maxwidth, int maxheight)
+{
+    _glfwInputError(GLFW_PLATFORM_ERROR,
+                    "Mir: Unsupported function %s", __PRETTY_FUNCTION__);
+}
+
+void _glfwPlatformSetWindowAspectRatio(_GLFWwindow* window, int numer, int denom)
+{
+    _glfwInputError(GLFW_PLATFORM_ERROR,
+                    "Mir: Unsupported function %s", __PRETTY_FUNCTION__);
+}
+
 void _glfwPlatformSetWindowPos(_GLFWwindow* window, int xpos, int ypos)
 {
     _glfwInputError(GLFW_PLATFORM_ERROR,
@@ -567,6 +481,12 @@ void _glfwPlatformRestoreWindow(_GLFWwindow* window)
     mir_surface_set_state(window->mir.surface, mir_surface_state_restored);
 }
 
+void _glfwPlatformMaximizeWindow(_GLFWwindow* window)
+{
+    _glfwInputError(GLFW_PLATFORM_ERROR,
+                    "Mir: Unsupported function %s", __PRETTY_FUNCTION__);
+}
+
 void _glfwPlatformHideWindow(_GLFWwindow* window)
 {
     MirSurfaceSpec* spec;
@@ -589,7 +509,17 @@ void _glfwPlatformShowWindow(_GLFWwindow* window)
     mir_surface_spec_release(spec);
 }
 
-void _glfwPlatformUnhideWindow(_GLFWwindow* window)
+void _glfwPlatformFocusWindow(_GLFWwindow* window)
+{
+    _glfwInputError(GLFW_PLATFORM_ERROR,
+                    "Mir: Unsupported function %s", __PRETTY_FUNCTION__);
+}
+
+void _glfwPlatformSetWindowMonitor(_GLFWwindow* window,
+                                   _GLFWmonitor* monitor,
+                                   int xpos, int ypos,
+                                   int width, int height,
+                                   int refreshRate)
 {
     _glfwInputError(GLFW_PLATFORM_ERROR,
                     "Mir: Unsupported function %s", __PRETTY_FUNCTION__);
@@ -599,14 +529,14 @@ int _glfwPlatformWindowFocused(_GLFWwindow* window)
 {
     _glfwInputError(GLFW_PLATFORM_ERROR,
                     "Mir: Unsupported function %s", __PRETTY_FUNCTION__);
-    return GL_FALSE;
+    return GLFW_FALSE;
 }
 
 int _glfwPlatformWindowIconified(_GLFWwindow* window)
 {
     _glfwInputError(GLFW_PLATFORM_ERROR,
                     "Mir: Unsupported function %s", __PRETTY_FUNCTION__);
-    return GL_FALSE;
+    return GLFW_FALSE;
 }
 
 int _glfwPlatformWindowVisible(_GLFWwindow* window)
@@ -614,6 +544,13 @@ int _glfwPlatformWindowVisible(_GLFWwindow* window)
     return mir_surface_get_visibility(window->mir.surface) == mir_surface_visibility_exposed;
 }
 
+int _glfwPlatformWindowMaximized(_GLFWwindow* window)
+{
+    _glfwInputError(GLFW_PLATFORM_ERROR,
+                    "Mir: Unsupported function %s", __PRETTY_FUNCTION__);
+    return GLFW_FALSE;
+}
+
 void _glfwPlatformPollEvents(void)
 {
     EventNode* node = NULL;
@@ -637,6 +574,24 @@ void _glfwPlatformWaitEvents(void)
     _glfwPlatformPollEvents();
 }
 
+void _glfwPlatformWaitEventsTimeout(double timeout)
+{
+    pthread_mutex_lock(&_glfw.mir.event_mutex);
+
+    if (emptyEventQueue(_glfw.mir.event_queue))
+    {
+        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_mutex_unlock(&_glfw.mir.event_mutex);
+
+    _glfwPlatformPollEvents();
+}
+
 void _glfwPlatformPostEmptyEvent(void)
 {
 }
@@ -664,7 +619,7 @@ int _glfwPlatformCreateCursor(_GLFWcursor* cursor,
     {
         _glfwInputError(GLFW_PLATFORM_ERROR,
                         "Mir: Unable to find a correct pixel format");
-        return GL_FALSE;
+        return GLFW_FALSE;
     }
 
     stream = mir_connection_create_buffer_stream_sync(_glfw.mir.connection,
@@ -699,7 +654,7 @@ int _glfwPlatformCreateCursor(_GLFWcursor* cursor,
 
     cursor->mir.custom_cursor = stream;
 
-    return GL_TRUE;
+    return GLFW_TRUE;
 }
 
 const char* getSystemCursorName(int shape)
@@ -732,10 +687,10 @@ int _glfwPlatformCreateStandardCursor(_GLFWcursor* cursor, int shape)
         cursor->mir.conf          = mir_cursor_configuration_from_name(cursor_name);
         cursor->mir.custom_cursor = NULL;
 
-        return GL_TRUE;
+        return GLFW_TRUE;
     }
 
-    return GL_FALSE;
+    return GLFW_FALSE;
 }
 
 void _glfwPlatformDestroyCursor(_GLFWcursor* cursor)
@@ -753,11 +708,6 @@ void _glfwPlatformSetCursor(_GLFWwindow* window, _GLFWcursor* cursor)
         mir_wait_for(mir_surface_configure_cursor(window->mir.surface, cursor->mir.conf));
         if (cursor->mir.custom_cursor)
         {
-            /* FIXME Bug https://bugs.launchpad.net/mir/+bug/1477285
-                     Requires a triple buffer swap to get the cursor buffer on top! (since mir is tripled buffered)
-            */
-            mir_buffer_stream_swap_buffers_sync(cursor->mir.custom_cursor);
-            mir_buffer_stream_swap_buffers_sync(cursor->mir.custom_cursor);
             mir_buffer_stream_swap_buffers_sync(cursor->mir.custom_cursor);
         }
     }
@@ -779,12 +729,19 @@ void _glfwPlatformSetCursorPos(_GLFWwindow* window, double xpos, double ypos)
                     "Mir: Unsupported function %s", __PRETTY_FUNCTION__);
 }
 
-void _glfwPlatformApplyCursorMode(_GLFWwindow* window)
+void _glfwPlatformSetCursorMode(_GLFWwindow* window, int mode)
 {
     _glfwInputError(GLFW_PLATFORM_ERROR,
                     "Mir: Unsupported function %s", __PRETTY_FUNCTION__);
 }
 
+const char* _glfwPlatformGetKeyName(int key, int scancode)
+{
+    _glfwInputError(GLFW_PLATFORM_ERROR,
+                    "Mir: Unsupported function %s", __PRETTY_FUNCTION__);
+    return NULL;
+}
+
 void _glfwPlatformSetClipboardString(_GLFWwindow* window, const char* string)
 {
     _glfwInputError(GLFW_PLATFORM_ERROR,
@@ -799,3 +756,91 @@ const char* _glfwPlatformGetClipboardString(_GLFWwindow* window)
     return NULL;
 }
 
+char** _glfwPlatformGetRequiredInstanceExtensions(uint32_t* count)
+{
+    char** extensions;
+
+    *count = 0;
+
+    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)
+        vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceMirPresentationSupportKHR");
+    if (!vkGetPhysicalDeviceMirPresentationSupportKHR)
+    {
+        _glfwInputError(GLFW_API_UNAVAILABLE,
+                        "Mir: Vulkan instance missing VK_KHR_mir_surface extension");
+        return GLFW_FALSE;
+    }
+
+    return vkGetPhysicalDeviceMirPresentationSupportKHR(device,
+                                                        queuefamily,
+                                                        _glfw.mir.connection);
+}
+
+VkResult _glfwPlatformCreateWindowSurface(VkInstance instance,
+                                          _GLFWwindow* window,
+                                          const VkAllocationCallbacks* allocator,
+                                          VkSurfaceKHR* surface)
+{
+    VkResult err;
+    VkMirSurfaceCreateInfoKHR sci;
+    PFN_vkCreateMirSurfaceKHR vkCreateMirSurfaceKHR;
+
+    vkCreateMirSurfaceKHR = (PFN_vkCreateMirSurfaceKHR)
+        vkGetInstanceProcAddr(instance, "vkCreateMirSurfaceKHR");
+    if (!vkCreateMirSurfaceKHR)
+    {
+        _glfwInputError(GLFW_API_UNAVAILABLE,
+                        "Mir: Vulkan instance missing VK_KHR_mir_surface extension");
+        return VK_ERROR_EXTENSION_NOT_PRESENT;
+    }
+
+    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;
+
+    err = vkCreateMirSurfaceKHR(instance, &sci, allocator, surface);
+    if (err)
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "Mir: Failed to create Vulkan surface: %s",
+                        _glfwGetVulkanResultString(err));
+    }
+
+    return err;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                        GLFW native API                       //////
+//////////////////////////////////////////////////////////////////////////
+
+GLFWAPI MirConnection* glfwGetMirDisplay(void)
+{
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+    return _glfw.mir.connection;
+}
+
+GLFWAPI MirSurface* glfwGetMirWindow(GLFWwindow* handle)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+    return window->mir.surface;
+}
+

src/monitor.c

@@ -1,8 +1,8 @@
 //========================================================================
-// GLFW 3.1 - www.glfw.org
+// GLFW 3.2 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
+// Copyright (c) 2006-2016 Camilla Berglund <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,6 +27,7 @@
 
 #include "internal.h"
 
+#include <assert.h>
 #include <math.h>
 #include <float.h>
 #include <string.h>
@@ -34,43 +35,42 @@
 #include <limits.h>
 
 
-// Lexical comparison function for GLFW video modes, used by qsort
+// Lexically compare video modes, used by qsort
 //
-static int compareVideoModes(const void* firstPtr, const void* secondPtr)
+static int compareVideoModes(const void* fp, const void* sp)
 {
-    int firstBPP, secondBPP, firstSize, secondSize;
-    const GLFWvidmode* first = firstPtr;
-    const GLFWvidmode* second = secondPtr;
+    const GLFWvidmode* fm = fp;
+    const GLFWvidmode* sm = sp;
+    const int fbpp = fm->redBits + fm->greenBits + fm->blueBits;
+    const int sbpp = sm->redBits + sm->greenBits + sm->blueBits;
+    const int farea = fm->width * fm->height;
+    const int sarea = sm->width * sm->height;
 
     // First sort on color bits per pixel
-    firstBPP = first->redBits + first->greenBits + first->blueBits;
-    secondBPP = second->redBits + second->greenBits + second->blueBits;
-    if (firstBPP != secondBPP)
-        return firstBPP - secondBPP;
+    if (fbpp != sbpp)
+        return fbpp - sbpp;
 
-    // Then sort on screen area, in pixels
-    firstSize = first->width * first->height;
-    secondSize = second->width * second->height;
-    if (firstSize != secondSize)
-        return firstSize - secondSize;
+    // Then sort on screen area
+    if (farea != sarea)
+        return farea - sarea;
 
     // Lastly sort on refresh rate
-    return first->refreshRate - second->refreshRate;
+    return fm->refreshRate - sm->refreshRate;
 }
 
 // Retrieves the available modes for the specified monitor
 //
-static int refreshVideoModes(_GLFWmonitor* monitor)
+static GLFWbool refreshVideoModes(_GLFWmonitor* monitor)
 {
     int modeCount;
     GLFWvidmode* modes;
 
     if (monitor->modes)
-        return GL_TRUE;
+        return GLFW_TRUE;
 
     modes = _glfwPlatformGetVideoModes(monitor, &modeCount);
     if (!modes)
-        return GL_FALSE;
+        return GLFW_FALSE;
 
     qsort(modes, modeCount, sizeof(GLFWvidmode), compareVideoModes);
 
@@ -78,7 +78,7 @@ static int refreshVideoModes(_GLFWmonitor* monitor)
     monitor->modes = modes;
     monitor->modeCount = modeCount;
 
-    return GL_TRUE;
+    return GLFW_TRUE;
 }
 
 
@@ -126,7 +126,11 @@ void _glfwInputMonitorChange(void)
         for (window = _glfw.windowListHead;  window;  window = window->next)
         {
             if (window->monitor == monitors[i])
-                window->monitor = NULL;
+            {
+                int width, height;
+                _glfwPlatformGetWindowSize(window, &width, &height);
+                _glfwPlatformSetWindowMonitor(window, NULL, 0, 0, width, height, 0);
+            }
         }
 
         if (_glfw.callbacks.monitor)
@@ -158,6 +162,11 @@ void _glfwInputMonitorChange(void)
     _glfwFreeMonitors(monitors, monitorCount);
 }
 
+void _glfwInputMonitorWindowChange(_GLFWmonitor* monitor, _GLFWwindow* window)
+{
+    monitor->window = window;
+}
+
 
 //////////////////////////////////////////////////////////////////////////
 //////                       GLFW internal API                      //////
@@ -263,9 +272,9 @@ const GLFWvidmode* _glfwChooseVideoMode(_GLFWmonitor* monitor,
     return closest;
 }
 
-int _glfwCompareVideoModes(const GLFWvidmode* first, const GLFWvidmode* second)
+int _glfwCompareVideoModes(const GLFWvidmode* fm, const GLFWvidmode* sm)
 {
-    return compareVideoModes(first, second);
+    return compareVideoModes(fm, sm);
 }
 
 void _glfwSplitBPP(int bpp, int* red, int* green, int* blue)
@@ -294,6 +303,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);
@@ -315,6 +325,7 @@ GLFWAPI GLFWmonitor* glfwGetPrimaryMonitor(void)
 GLFWAPI void glfwGetMonitorPos(GLFWmonitor* handle, int* xpos, int* ypos)
 {
     _GLFWmonitor* monitor = (_GLFWmonitor*) handle;
+    assert(monitor != NULL);
 
     if (xpos)
         *xpos = 0;
@@ -329,6 +340,7 @@ GLFWAPI void glfwGetMonitorPos(GLFWmonitor* handle, int* xpos, int* ypos)
 GLFWAPI void glfwGetMonitorPhysicalSize(GLFWmonitor* handle, int* widthMM, int* heightMM)
 {
     _GLFWmonitor* monitor = (_GLFWmonitor*) handle;
+    assert(monitor != NULL);
 
     if (widthMM)
         *widthMM = 0;
@@ -346,6 +358,8 @@ GLFWAPI void glfwGetMonitorPhysicalSize(GLFWmonitor* handle, int* widthMM, int*
 GLFWAPI const char* glfwGetMonitorName(GLFWmonitor* handle)
 {
     _GLFWmonitor* monitor = (_GLFWmonitor*) handle;
+    assert(monitor != NULL);
+
     _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
     return monitor->name;
 }
@@ -360,6 +374,8 @@ GLFWAPI GLFWmonitorfun glfwSetMonitorCallback(GLFWmonitorfun cbfun)
 GLFWAPI const GLFWvidmode* glfwGetVideoModes(GLFWmonitor* handle, int* count)
 {
     _GLFWmonitor* monitor = (_GLFWmonitor*) handle;
+    assert(monitor != NULL);
+    assert(count != NULL);
 
     *count = 0;
 
@@ -375,6 +391,7 @@ GLFWAPI const GLFWvidmode* glfwGetVideoModes(GLFWmonitor* handle, int* count)
 GLFWAPI const GLFWvidmode* glfwGetVideoMode(GLFWmonitor* handle)
 {
     _GLFWmonitor* monitor = (_GLFWmonitor*) handle;
+    assert(monitor != NULL);
 
     _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
 
@@ -392,7 +409,7 @@ GLFWAPI void glfwSetGamma(GLFWmonitor* handle, float gamma)
 
     if (gamma != gamma || gamma <= 0.f || gamma > FLT_MAX)
     {
-        _glfwInputError(GLFW_INVALID_VALUE, "Invalid gamma value");
+        _glfwInputError(GLFW_INVALID_VALUE, "Invalid gamma value %f", gamma);
         return;
     }
 
@@ -423,6 +440,7 @@ GLFWAPI void glfwSetGamma(GLFWmonitor* handle, float gamma)
 GLFWAPI const GLFWgammaramp* glfwGetGammaRamp(GLFWmonitor* handle)
 {
     _GLFWmonitor* monitor = (_GLFWmonitor*) handle;
+    assert(monitor != NULL);
 
     _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
 
@@ -435,6 +453,19 @@ GLFWAPI const GLFWgammaramp* glfwGetGammaRamp(GLFWmonitor* handle)
 GLFWAPI void glfwSetGammaRamp(GLFWmonitor* handle, const GLFWgammaramp* ramp)
 {
     _GLFWmonitor* monitor = (_GLFWmonitor*) handle;
+    assert(monitor != NULL);
+    assert(ramp != NULL);
+    assert(ramp->red != NULL);
+    assert(ramp->green != NULL);
+    assert(ramp->blue != NULL);
+
+    if (ramp->size <= 0)
+    {
+        _glfwInputError(GLFW_INVALID_VALUE,
+                        "Invalid gamma ramp size %i",
+                        ramp->size);
+        return;
+    }
 
     _GLFW_REQUIRE_INIT();
 

src/nsgl_context.h

@@ -1,7 +1,7 @@
 //========================================================================
-// GLFW 3.1 OS X - www.glfw.org
+// GLFW 3.2 OS X - www.glfw.org
 //------------------------------------------------------------------------
-// Copyright (c) 2009-2010 Camilla Berglund <elmindreda@elmindreda.org>
+// Copyright (c) 2009-2016 Camilla Berglund <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,7 +27,6 @@
 #ifndef _glfw3_nsgl_context_h_
 #define _glfw3_nsgl_context_h_
 
-#define _GLFW_PLATFORM_FBCONFIG
 #define _GLFW_PLATFORM_CONTEXT_STATE            _GLFWcontextNSGL nsgl
 #define _GLFW_PLATFORM_LIBRARY_CONTEXT_STATE    _GLFWlibraryNSGL nsgl
 
@@ -37,7 +36,7 @@
 typedef struct _GLFWcontextNSGL
 {
     id           pixelFormat;
-    id	         context;
+    id	         object;
 
 } _GLFWcontextNSGL;
 
@@ -47,16 +46,16 @@ typedef struct _GLFWcontextNSGL
 typedef struct _GLFWlibraryNSGL
 {
     // dlopen handle for OpenGL.framework (for glfwGetProcAddress)
-    void*           framework;
+    CFBundleRef     framework;
 
 } _GLFWlibraryNSGL;
 
 
-int _glfwInitContextAPI(void);
-void _glfwTerminateContextAPI(void);
-int _glfwCreateContext(_GLFWwindow* window,
-                       const _GLFWctxconfig* ctxconfig,
-                       const _GLFWfbconfig* fbconfig);
-void _glfwDestroyContext(_GLFWwindow* window);
+GLFWbool _glfwInitNSGL(void);
+void _glfwTerminateNSGL(void);
+GLFWbool _glfwCreateContextNSGL(_GLFWwindow* window,
+                                const _GLFWctxconfig* ctxconfig,
+                                const _GLFWfbconfig* fbconfig);
+void _glfwDestroyContextNSGL(_GLFWwindow* window);
 
 #endif // _glfw3_nsgl_context_h_

src/nsgl_context.m

@@ -1,7 +1,7 @@
 //========================================================================
-// GLFW 3.1 OS X - www.glfw.org
+// GLFW 3.2 OS X - www.glfw.org
 //------------------------------------------------------------------------
-// Copyright (c) 2009-2010 Camilla Berglund <elmindreda@elmindreda.org>
+// Copyright (c) 2009-2016 Camilla Berglund <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,57 +27,109 @@
 #include "internal.h"
 
 
+static void makeContextCurrent(_GLFWwindow* window)
+{
+    if (window)
+        [window->context.nsgl.object makeCurrentContext];
+    else
+        [NSOpenGLContext clearCurrentContext];
+
+    _glfwPlatformSetCurrentContext(window);
+}
+
+static void swapBuffers(_GLFWwindow* window)
+{
+    // ARP appears to be unnecessary, but this is future-proof
+    [window->context.nsgl.object flushBuffer];
+}
+
+static void swapInterval(int interval)
+{
+    _GLFWwindow* window = _glfwPlatformGetCurrentContext();
+
+    GLint sync = interval;
+    [window->context.nsgl.object setValues:&sync
+                              forParameter:NSOpenGLCPSwapInterval];
+}
+
+static int extensionSupported(const char* extension)
+{
+    // There are no NSGL extensions
+    return GLFW_FALSE;
+}
+
+static GLFWglproc getProcAddress(const char* procname)
+{
+    CFStringRef symbolName = CFStringCreateWithCString(kCFAllocatorDefault,
+                                                       procname,
+                                                       kCFStringEncodingASCII);
+
+    GLFWglproc symbol = CFBundleGetFunctionPointerForName(_glfw.nsgl.framework,
+                                                          symbolName);
+
+    CFRelease(symbolName);
+
+    return symbol;
+}
+
+// Destroy the OpenGL context
+//
+static void destroyContext(_GLFWwindow* window)
+{
+    [window->context.nsgl.pixelFormat release];
+    window->context.nsgl.pixelFormat = nil;
+
+    [window->context.nsgl.object release];
+    window->context.nsgl.object = nil;
+}
+
+
 //////////////////////////////////////////////////////////////////////////
 //////                       GLFW internal API                      //////
 //////////////////////////////////////////////////////////////////////////
 
 // Initialize OpenGL support
 //
-int _glfwInitContextAPI(void)
+GLFWbool _glfwInitNSGL(void)
 {
-    if (!_glfwCreateContextTLS())
-        return GL_FALSE;
-
     _glfw.nsgl.framework =
         CFBundleGetBundleWithIdentifier(CFSTR("com.apple.opengl"));
     if (_glfw.nsgl.framework == NULL)
     {
         _glfwInputError(GLFW_API_UNAVAILABLE,
                         "NSGL: Failed to locate OpenGL framework");
-        return GL_FALSE;
+        return GLFW_FALSE;
     }
 
-    return GL_TRUE;
+    return GLFW_TRUE;
 }
 
 // Terminate OpenGL support
 //
-void _glfwTerminateContextAPI(void)
+void _glfwTerminateNSGL(void)
 {
-    _glfwDestroyContextTLS();
 }
 
 // Create the OpenGL context
 //
-int _glfwCreateContext(_GLFWwindow* window,
-                       const _GLFWctxconfig* ctxconfig,
-                       const _GLFWfbconfig* fbconfig)
+GLFWbool _glfwCreateContextNSGL(_GLFWwindow* window,
+                                const _GLFWctxconfig* ctxconfig,
+                                const _GLFWfbconfig* fbconfig)
 {
     unsigned int attributeCount = 0;
 
-    if (ctxconfig->api == GLFW_OPENGL_ES_API)
+    if (ctxconfig->client == GLFW_OPENGL_ES_API)
     {
         _glfwInputError(GLFW_API_UNAVAILABLE,
                         "NSGL: OpenGL ES is not available on OS X");
-        return GL_FALSE;
+        return GLFW_FALSE;
     }
 
-#if MAC_OS_X_VERSION_MAX_ALLOWED >= 1070
     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 GL_FALSE;
+        return GLFW_FALSE;
     }
 
     if (ctxconfig->major > 2)
@@ -86,25 +138,16 @@ int _glfwCreateContext(_GLFWwindow* window,
         {
             _glfwInputError(GLFW_VERSION_UNAVAILABLE,
                             "NSGL: The targeted version of OS X only supports forward-compatible contexts for OpenGL 3.2 and above");
-            return GL_FALSE;
+            return GLFW_FALSE;
         }
 
         if (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");
-            return GL_FALSE;
+            return GLFW_FALSE;
         }
     }
-#else
-    // Fail if OpenGL 3.0 or above was requested
-    if (ctxconfig->major > 2)
-    {
-        _glfwInputError(GLFW_VERSION_UNAVAILABLE,
-                        "NSGL: The targeted version of OS X does not support OpenGL version 3.0 or above");
-        return GL_FALSE;
-    }
-#endif /*MAC_OS_X_VERSION_MAX_ALLOWED*/
 
     // Context robustness modes (GL_KHR_robustness) are not yet supported on
     // OS X but are not a hard constraint, so ignore and continue
@@ -121,7 +164,6 @@ int _glfwCreateContext(_GLFWwindow* window,
     ADD_ATTR(NSOpenGLPFAAccelerated);
     ADD_ATTR(NSOpenGLPFAClosestPolicy);
 
-#if MAC_OS_X_VERSION_MAX_ALLOWED >= 1070
 #if MAC_OS_X_VERSION_MAX_ALLOWED >= 101000
     if (ctxconfig->major >= 4)
     {
@@ -133,7 +175,6 @@ int _glfwCreateContext(_GLFWwindow* window,
     {
         ADD_ATTR2(NSOpenGLPFAOpenGLProfile, NSOpenGLProfileVersion3_2Core);
     }
-#endif /*MAC_OS_X_VERSION_MAX_ALLOWED*/
 
     if (ctxconfig->major <= 2)
     {
@@ -207,91 +248,40 @@ int _glfwCreateContext(_GLFWwindow* window,
 #undef ADD_ATTR
 #undef ADD_ATTR2
 
-    window->nsgl.pixelFormat =
+    window->context.nsgl.pixelFormat =
         [[NSOpenGLPixelFormat alloc] initWithAttributes:attributes];
-    if (window->nsgl.pixelFormat == nil)
+    if (window->context.nsgl.pixelFormat == nil)
     {
         _glfwInputError(GLFW_FORMAT_UNAVAILABLE,
                         "NSGL: Failed to find a suitable pixel format");
-        return GL_FALSE;
+        return GLFW_FALSE;
     }
 
     NSOpenGLContext* share = NULL;
 
     if (ctxconfig->share)
-        share = ctxconfig->share->nsgl.context;
+        share = ctxconfig->share->context.nsgl.object;
 
-    window->nsgl.context =
-        [[NSOpenGLContext alloc] initWithFormat:window->nsgl.pixelFormat
+    window->context.nsgl.object =
+        [[NSOpenGLContext alloc] initWithFormat:window->context.nsgl.pixelFormat
                                    shareContext:share];
-    if (window->nsgl.context == nil)
+    if (window->context.nsgl.object == nil)
     {
         _glfwInputError(GLFW_VERSION_UNAVAILABLE,
                         "NSGL: Failed to create OpenGL context");
-        return GL_FALSE;
+        return GLFW_FALSE;
     }
 
-    return GL_TRUE;
-}
+    [window->context.nsgl.object setView:window->ns.view];
 
-// Destroy the OpenGL context
-//
-void _glfwDestroyContext(_GLFWwindow* window)
-{
-    [window->nsgl.pixelFormat release];
-    window->nsgl.pixelFormat = nil;
+    window->context.makeCurrent = makeContextCurrent;
+    window->context.swapBuffers = swapBuffers;
+    window->context.swapInterval = swapInterval;
+    window->context.extensionSupported = extensionSupported;
+    window->context.getProcAddress = getProcAddress;
+    window->context.destroy = destroyContext;
 
-    [window->nsgl.context release];
-    window->nsgl.context = nil;
-}
-
-
-//////////////////////////////////////////////////////////////////////////
-//////                       GLFW platform API                      //////
-//////////////////////////////////////////////////////////////////////////
-
-void _glfwPlatformMakeContextCurrent(_GLFWwindow* window)
-{
-    if (window)
-        [window->nsgl.context makeCurrentContext];
-    else
-        [NSOpenGLContext clearCurrentContext];
-
-    _glfwSetContextTLS(window);
-}
-
-void _glfwPlatformSwapBuffers(_GLFWwindow* window)
-{
-    // ARP appears to be unnecessary, but this is future-proof
-    [window->nsgl.context flushBuffer];
-}
-
-void _glfwPlatformSwapInterval(int interval)
-{
-    _GLFWwindow* window = _glfwPlatformGetCurrentContext();
-
-    GLint sync = interval;
-    [window->nsgl.context setValues:&sync forParameter:NSOpenGLCPSwapInterval];
-}
-
-int _glfwPlatformExtensionSupported(const char* extension)
-{
-    // There are no NSGL extensions
-    return GL_FALSE;
-}
-
-GLFWglproc _glfwPlatformGetProcAddress(const char* procname)
-{
-    CFStringRef symbolName = CFStringCreateWithCString(kCFAllocatorDefault,
-                                                       procname,
-                                                       kCFStringEncodingASCII);
-
-    GLFWglproc symbol = CFBundleGetFunctionPointerForName(_glfw.nsgl.framework,
-                                                          symbolName);
-
-    CFRelease(symbolName);
-
-    return symbol;
+    return GLFW_TRUE;
 }
 
 
@@ -303,6 +293,13 @@ GLFWAPI id glfwGetNSGLContext(GLFWwindow* handle)
 {
     _GLFWwindow* window = (_GLFWwindow*) handle;
     _GLFW_REQUIRE_INIT_OR_RETURN(nil);
-    return window->nsgl.context;
+
+    if (window->context.client == GLFW_NO_API)
+    {
+        _glfwInputError(GLFW_NO_WINDOW_CONTEXT, NULL);
+        return NULL;
+    }
+
+    return window->context.nsgl.object;
 }
 

src/posix_time.c

@@ -1,8 +1,8 @@
 //========================================================================
-// GLFW 3.1 POSIX - www.glfw.org
+// GLFW 3.2 POSIX - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
+// Copyright (c) 2006-2016 Camilla Berglund <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,28 +30,6 @@
 #include <sys/time.h>
 #include <time.h>
 
-// Return raw time
-//
-static uint64_t getRawTime(void)
-{
-#if defined(CLOCK_MONOTONIC)
-    if (_glfw.posix_time.monotonic)
-    {
-        struct timespec ts;
-
-        clock_gettime(CLOCK_MONOTONIC, &ts);
-        return (uint64_t) ts.tv_sec * (uint64_t) 1000000000 + (uint64_t) ts.tv_nsec;
-    }
-    else
-#endif
-    {
-        struct timeval tv;
-
-        gettimeofday(&tv, NULL);
-        return (uint64_t) tv.tv_sec * (uint64_t) 1000000 + (uint64_t) tv.tv_usec;
-    }
-}
-
 
 //////////////////////////////////////////////////////////////////////////
 //////                       GLFW internal API                      //////
@@ -59,23 +37,22 @@ static uint64_t getRawTime(void)
 
 // Initialise timer
 //
-void _glfwInitTimer(void)
+void _glfwInitTimerPOSIX(void)
 {
 #if defined(CLOCK_MONOTONIC)
     struct timespec ts;
 
     if (clock_gettime(CLOCK_MONOTONIC, &ts) == 0)
     {
-        _glfw.posix_time.monotonic = GL_TRUE;
-        _glfw.posix_time.resolution = 1e-9;
+        _glfw.posix_time.monotonic = GLFW_TRUE;
+        _glfw.posix_time.frequency = 1000000000;
     }
     else
 #endif
     {
-        _glfw.posix_time.resolution = 1e-6;
+        _glfw.posix_time.monotonic = GLFW_FALSE;
+        _glfw.posix_time.frequency = 1000000;
     }
-
-    _glfw.posix_time.base = getRawTime();
 }
 
 
@@ -83,15 +60,26 @@ void _glfwInitTimer(void)
 //////                       GLFW platform API                      //////
 //////////////////////////////////////////////////////////////////////////
 
-double _glfwPlatformGetTime(void)
+uint64_t _glfwPlatformGetTimerValue(void)
 {
-    return (double) (getRawTime() - _glfw.posix_time.base) *
-        _glfw.posix_time.resolution;
+#if defined(CLOCK_MONOTONIC)
+    if (_glfw.posix_time.monotonic)
+    {
+        struct timespec ts;
+        clock_gettime(CLOCK_MONOTONIC, &ts);
+        return (uint64_t) ts.tv_sec * (uint64_t) 1000000000 + (uint64_t) ts.tv_nsec;
+    }
+    else
+#endif
+    {
+        struct timeval tv;
+        gettimeofday(&tv, NULL);
+        return (uint64_t) tv.tv_sec * (uint64_t) 1000000 + (uint64_t) tv.tv_usec;
+    }
 }
 
-void _glfwPlatformSetTime(double time)
+uint64_t _glfwPlatformGetTimerFrequency(void)
 {
-    _glfw.posix_time.base = getRawTime() -
-        (uint64_t) (time / _glfw.posix_time.resolution);
+    return _glfw.posix_time.frequency;
 }
 

src/posix_time.h

@@ -1,8 +1,8 @@
 //========================================================================
-// GLFW 3.1 POSIX - www.glfw.org
+// GLFW 3.2 POSIX - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
+// Copyright (c) 2006-2016 Camilla Berglund <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
@@ -37,13 +37,12 @@
 //
 typedef struct _GLFWtimePOSIX
 {
-    GLboolean   monotonic;
-    double      resolution;
-    uint64_t    base;
+    GLFWbool    monotonic;
+    uint64_t    frequency;
 
 } _GLFWtimePOSIX;
 
 
-void _glfwInitTimer(void);
+void _glfwInitTimerPOSIX(void);
 
 #endif // _glfw3_posix_time_h_

src/posix_tls.c

@@ -1,8 +1,8 @@
 //========================================================================
-// GLFW 3.1 POSIX - www.glfw.org
+// GLFW 3.2 POSIX - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
+// Copyright (c) 2006-2016 Camilla Berglund <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,26 +32,23 @@
 //////                       GLFW internal API                      //////
 //////////////////////////////////////////////////////////////////////////
 
-int _glfwCreateContextTLS(void)
+GLFWbool _glfwInitThreadLocalStoragePOSIX(void)
 {
     if (pthread_key_create(&_glfw.posix_tls.context, NULL) != 0)
     {
         _glfwInputError(GLFW_PLATFORM_ERROR,
                         "POSIX: Failed to create context TLS");
-        return GL_FALSE;
+        return GLFW_FALSE;
     }
 
-    return GL_TRUE;
+    _glfw.posix_tls.allocated = GLFW_TRUE;
+    return GLFW_TRUE;
 }
 
-void _glfwDestroyContextTLS(void)
+void _glfwTerminateThreadLocalStoragePOSIX(void)
 {
-    pthread_key_delete(_glfw.posix_tls.context);
-}
-
-void _glfwSetContextTLS(_GLFWwindow* context)
-{
-    pthread_setspecific(_glfw.posix_tls.context, context);
+    if (_glfw.posix_tls.allocated)
+        pthread_key_delete(_glfw.posix_tls.context);
 }
 
 
@@ -59,6 +56,11 @@ void _glfwSetContextTLS(_GLFWwindow* context)
 //////                       GLFW platform API                      //////
 //////////////////////////////////////////////////////////////////////////
 
+void _glfwPlatformSetCurrentContext(_GLFWwindow* context)
+{
+    pthread_setspecific(_glfw.posix_tls.context, context);
+}
+
 _GLFWwindow* _glfwPlatformGetCurrentContext(void)
 {
     return pthread_getspecific(_glfw.posix_tls.context);

src/posix_tls.h

@@ -1,8 +1,8 @@
 //========================================================================
-// GLFW 3.1 POSIX - www.glfw.org
+// GLFW 3.2 POSIX - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
+// Copyright (c) 2006-2016 Camilla Berglund <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
@@ -37,13 +37,13 @@
 //
 typedef struct _GLFWtlsPOSIX
 {
+    GLFWbool        allocated;
     pthread_key_t   context;
 
 } _GLFWtlsPOSIX;
 
 
-int _glfwCreateContextTLS(void);
-void _glfwDestroyContextTLS(void);
-void _glfwSetContextTLS(_GLFWwindow* context);
+GLFWbool _glfwInitThreadLocalStoragePOSIX(void);
+void _glfwTerminateThreadLocalStoragePOSIX(void);
 
 #endif // _glfw3_posix_tls_h_

src/vulkan.c

@@ -0,0 +1,287 @@
+//========================================================================
+// GLFW 3.2 - www.glfw.org
+//------------------------------------------------------------------------
+// Copyright (c) 2002-2006 Marcus Geelnard
+// Copyright (c) 2006-2016 Camilla Berglund <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>
+#include <stdlib.h>
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW internal API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+void _glfwInitVulkan(void)
+{
+    VkResult err;
+    VkExtensionProperties* ep;
+    uint32_t i, count;
+#if defined(_GLFW_WIN32)
+    const char* name = "vulkan-1.dll";
+#else
+    const char* name = "libvulkan.so.1";
+#endif
+
+    _glfw.vk.handle = _glfw_dlopen(name);
+    if (!_glfw.vk.handle)
+        return;
+
+    _glfw.vk.GetInstanceProcAddr = (PFN_vkGetInstanceProcAddr)
+        _glfw_dlsym(_glfw.vk.handle, "vkGetInstanceProcAddr");
+    if (!_glfw.vk.GetInstanceProcAddr)
+    {
+        _glfwInputError(GLFW_API_UNAVAILABLE,
+                        "Vulkan: Loader does not export vkGetInstanceProcAddr");
+        return;
+    }
+
+    _glfw.vk.EnumerateInstanceExtensionProperties = (PFN_vkEnumerateInstanceExtensionProperties)
+        vkGetInstanceProcAddr(NULL, "vkEnumerateInstanceExtensionProperties");
+    if (!_glfw.vk.EnumerateInstanceExtensionProperties)
+    {
+        _glfwInputError(GLFW_API_UNAVAILABLE,
+                        "Vulkan: Failed to retrieve vkEnumerateInstanceExtensionProperties");
+        return;
+    }
+
+    err = vkEnumerateInstanceExtensionProperties(NULL, &count, NULL);
+    if (err)
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "Vulkan: Failed to query instance extension count: %s",
+                        _glfwGetVulkanResultString(err));
+        return;
+    }
+
+    ep = calloc(count, sizeof(VkExtensionProperties));
+
+    err = vkEnumerateInstanceExtensionProperties(NULL, &count, ep);
+    if (err)
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "Vulkan: Failed to query instance extensions: %s",
+                        _glfwGetVulkanResultString(err));
+
+        free(ep);
+        return;
+    }
+
+    for (i = 0;  i < count;  i++)
+    {
+        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)
+            _glfw.vk.KHR_win32_surface = GLFW_TRUE;
+        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)
+            _glfw.vk.KHR_xcb_surface = GLFW_TRUE;
+        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)
+            _glfw.vk.KHR_mir_surface = GLFW_TRUE;
+    }
+
+    free(ep);
+
+    _glfw.vk.available = GLFW_TRUE;
+
+    if (!_glfw.vk.KHR_surface)
+        return;
+
+    _glfw.vk.extensions =
+        _glfwPlatformGetRequiredInstanceExtensions(&_glfw.vk.extensionCount);
+}
+
+void _glfwTerminateVulkan(void)
+{
+    uint32_t i;
+
+    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);
+}
+
+const char* _glfwGetVulkanResultString(VkResult result)
+{
+    switch (result)
+    {
+        case VK_SUCCESS:
+            return "Success";
+        case VK_NOT_READY:
+            return "A fence or query has not yet completed";
+        case VK_TIMEOUT:
+            return "A wait operation has not completed in the specified time";
+        case VK_EVENT_SET:
+            return "An event is signaled";
+        case VK_EVENT_RESET:
+            return "An event is unsignaled";
+        case VK_INCOMPLETE:
+            return "A return array was too small for the result";
+        case VK_ERROR_OUT_OF_HOST_MEMORY:
+            return "A host memory allocation has failed";
+        case VK_ERROR_OUT_OF_DEVICE_MEMORY:
+            return "A device memory allocation has failed";
+        case VK_ERROR_INITIALIZATION_FAILED:
+            return "Initialization of an object could not be completed for implementation-specific reasons";
+        case VK_ERROR_DEVICE_LOST:
+            return "The logical or physical device has been lost";
+        case VK_ERROR_MEMORY_MAP_FAILED:
+            return "Mapping of a memory object has failed";
+        case VK_ERROR_LAYER_NOT_PRESENT:
+            return "A requested layer is not present or could not be loaded";
+        case VK_ERROR_EXTENSION_NOT_PRESENT:
+            return "A requested extension is not supported";
+        case VK_ERROR_FEATURE_NOT_PRESENT:
+            return "A requested feature is not supported";
+        case VK_ERROR_INCOMPATIBLE_DRIVER:
+            return "The requested version of Vulkan is not supported by the driver or is otherwise incompatible";
+        case VK_ERROR_TOO_MANY_OBJECTS:
+            return "Too many objects of the type have already been created";
+        case VK_ERROR_FORMAT_NOT_SUPPORTED:
+            return "A requested format is not supported on this device";
+        case VK_ERROR_SURFACE_LOST_KHR:
+            return "A surface is no longer available";
+        case VK_SUBOPTIMAL_KHR:
+            return "A swapchain no longer matches the surface properties exactly, but can still be used";
+        case VK_ERROR_OUT_OF_DATE_KHR:
+            return "A surface has changed in such a way that it is no longer compatible with the swapchain";
+        case VK_ERROR_INCOMPATIBLE_DISPLAY_KHR:
+            return "The display used by a swapchain does not use the same presentable image layout";
+        case VK_ERROR_NATIVE_WINDOW_IN_USE_KHR:
+            return "The requested window is already connected to a VkSurfaceKHR, or to some other non-Vulkan API";
+        case VK_ERROR_VALIDATION_FAILED_EXT:
+            return "A validation layer found an error";
+        default:
+            return "ERROR: UNKNOWN VULKAN ERROR";
+    }
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                        GLFW public API                       //////
+//////////////////////////////////////////////////////////////////////////
+
+GLFWAPI int glfwVulkanSupported(void)
+{
+    _GLFW_REQUIRE_INIT_OR_RETURN(GLFW_FALSE);
+    return _glfw.vk.available;
+}
+
+GLFWAPI const char** glfwGetRequiredInstanceExtensions(uint32_t* count)
+{
+    *count = 0;
+
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+
+    if (!_glfw.vk.available)
+    {
+        _glfwInputError(GLFW_API_UNAVAILABLE, "Vulkan: Loader not found");
+        return NULL;
+    }
+
+    *count = _glfw.vk.extensionCount;
+    return (const char**) _glfw.vk.extensions;
+}
+
+GLFWAPI GLFWvkproc glfwGetInstanceProcAddress(VkInstance instance,
+                                              const char* procname)
+{
+    GLFWvkproc proc;
+
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+
+    if (!_glfw.vk.available)
+    {
+        _glfwInputError(GLFW_API_UNAVAILABLE, "Vulkan: Loader not found");
+        return NULL;
+    }
+
+    proc = (GLFWvkproc) vkGetInstanceProcAddr(instance, procname);
+    if (!proc)
+        proc = (GLFWvkproc) _glfw_dlsym(_glfw.vk.handle, procname);
+
+    return proc;
+}
+
+GLFWAPI int glfwGetPhysicalDevicePresentationSupport(VkInstance instance,
+                                                     VkPhysicalDevice device,
+                                                     uint32_t queuefamily)
+{
+    _GLFW_REQUIRE_INIT_OR_RETURN(GLFW_FALSE);
+
+    if (!_glfw.vk.available)
+    {
+        _glfwInputError(GLFW_API_UNAVAILABLE, "Vulkan: Loader not found");
+        return GLFW_FALSE;
+    }
+
+    if (!_glfw.vk.extensions)
+    {
+        _glfwInputError(GLFW_API_UNAVAILABLE,
+                        "Vulkan: Window surface creation extensions not found");
+        return GLFW_FALSE;
+    }
+
+    return _glfwPlatformGetPhysicalDevicePresentationSupport(instance,
+                                                             device,
+                                                             queuefamily);
+}
+
+GLFWAPI VkResult glfwCreateWindowSurface(VkInstance instance,
+                                         GLFWwindow* handle,
+                                         const VkAllocationCallbacks* allocator,
+                                         VkSurfaceKHR* surface)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    assert(window != NULL);
+
+    assert(surface != NULL);
+    *surface = VK_NULL_HANDLE;
+
+    _GLFW_REQUIRE_INIT_OR_RETURN(VK_ERROR_INITIALIZATION_FAILED);
+
+    if (!_glfw.vk.available)
+    {
+        _glfwInputError(GLFW_API_UNAVAILABLE, "Vulkan: Loader not found");
+        return VK_ERROR_INITIALIZATION_FAILED;
+    }
+
+    if (!_glfw.vk.extensions)
+    {
+        _glfwInputError(GLFW_API_UNAVAILABLE,
+                        "Vulkan: Window surface creation extensions not found");
+        return VK_ERROR_EXTENSION_NOT_PRESENT;
+    }
+
+    return _glfwPlatformCreateWindowSurface(instance, window, allocator, surface);
+}
+

src/wgl_context.c

@@ -1,8 +1,8 @@
 //========================================================================
-// GLFW 3.1 WGL - www.glfw.org
+// GLFW 3.2 WGL - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
+// Copyright (c) 2006-2016 Camilla Berglund <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,64 +32,17 @@
 #include <assert.h>
 
 
-// Initialize WGL-specific extensions
-//
-static void initWGLExtensions(_GLFWwindow* window)
-{
-    // Functions for WGL_EXT_extension_string
-    // NOTE: These are needed by _glfwPlatformExtensionSupported
-    window->wgl.GetExtensionsStringEXT = (PFNWGLGETEXTENSIONSSTRINGEXTPROC)
-        _glfw_wglGetProcAddress("wglGetExtensionsStringEXT");
-    window->wgl.GetExtensionsStringARB = (PFNWGLGETEXTENSIONSSTRINGARBPROC)
-        _glfw_wglGetProcAddress("wglGetExtensionsStringARB");
-
-    // Functions for WGL_ARB_create_context
-    window->wgl.CreateContextAttribsARB = (PFNWGLCREATECONTEXTATTRIBSARBPROC)
-        _glfw_wglGetProcAddress("wglCreateContextAttribsARB");
-
-    // Functions for WGL_EXT_swap_control
-    window->wgl.SwapIntervalEXT = (PFNWGLSWAPINTERVALEXTPROC)
-        _glfw_wglGetProcAddress("wglSwapIntervalEXT");
-
-    // Functions for WGL_ARB_pixel_format
-    window->wgl.GetPixelFormatAttribivARB = (PFNWGLGETPIXELFORMATATTRIBIVARBPROC)
-        _glfw_wglGetProcAddress("wglGetPixelFormatAttribivARB");
-
-    // This needs to include every extension used below except for
-    // WGL_ARB_extensions_string and WGL_EXT_extensions_string
-    window->wgl.ARB_multisample =
-        _glfwPlatformExtensionSupported("WGL_ARB_multisample");
-    window->wgl.ARB_framebuffer_sRGB =
-        _glfwPlatformExtensionSupported("WGL_ARB_framebuffer_sRGB");
-    window->wgl.EXT_framebuffer_sRGB =
-        _glfwPlatformExtensionSupported("WGL_EXT_framebuffer_sRGB");
-    window->wgl.ARB_create_context =
-        _glfwPlatformExtensionSupported("WGL_ARB_create_context");
-    window->wgl.ARB_create_context_profile =
-        _glfwPlatformExtensionSupported("WGL_ARB_create_context_profile");
-    window->wgl.EXT_create_context_es2_profile =
-        _glfwPlatformExtensionSupported("WGL_EXT_create_context_es2_profile");
-    window->wgl.ARB_create_context_robustness =
-        _glfwPlatformExtensionSupported("WGL_ARB_create_context_robustness");
-    window->wgl.EXT_swap_control =
-        _glfwPlatformExtensionSupported("WGL_EXT_swap_control");
-    window->wgl.ARB_pixel_format =
-        _glfwPlatformExtensionSupported("WGL_ARB_pixel_format");
-    window->wgl.ARB_context_flush_control =
-        _glfwPlatformExtensionSupported("WGL_ARB_context_flush_control");
-}
-
 // Returns the specified attribute of the specified pixel format
 //
 static int getPixelFormatAttrib(_GLFWwindow* window, int pixelFormat, int attrib)
 {
     int value = 0;
 
-    assert(window->wgl.ARB_pixel_format);
+    assert(_glfw.wgl.ARB_pixel_format);
 
-    if (!window->wgl.GetPixelFormatAttribivARB(window->wgl.dc,
-                                               pixelFormat,
-                                               0, 1, &attrib, &value))
+    if (!_glfw.wgl.GetPixelFormatAttribivARB(window->context.wgl.dc,
+                                             pixelFormat,
+                                             0, 1, &attrib, &value))
     {
         _glfwInputError(GLFW_PLATFORM_ERROR,
                         "WGL: Failed to retrieve pixel format attribute %i",
@@ -102,15 +55,15 @@ static int getPixelFormatAttrib(_GLFWwindow* window, int pixelFormat, int attrib
 
 // Return a list of available and usable framebuffer configs
 //
-static GLboolean choosePixelFormat(_GLFWwindow* window,
-                                   const _GLFWfbconfig* desired,
-                                   int* result)
+static GLFWbool choosePixelFormat(_GLFWwindow* window,
+                                  const _GLFWfbconfig* desired,
+                                  int* result)
 {
     _GLFWfbconfig* usableConfigs;
     const _GLFWfbconfig* closest;
     int i, nativeCount, usableCount;
 
-    if (window->wgl.ARB_pixel_format)
+    if (_glfw.wgl.ARB_pixel_format)
     {
         nativeCount = getPixelFormatAttrib(window,
                                          1,
@@ -118,7 +71,7 @@ static GLboolean choosePixelFormat(_GLFWwindow* window,
     }
     else
     {
-        nativeCount = DescribePixelFormat(window->wgl.dc,
+        nativeCount = DescribePixelFormat(window->context.wgl.dc,
                                           1,
                                           sizeof(PIXELFORMATDESCRIPTOR),
                                           NULL);
@@ -132,7 +85,7 @@ static GLboolean choosePixelFormat(_GLFWwindow* window,
         const int n = i + 1;
         _GLFWfbconfig* u = usableConfigs + usableCount;
 
-        if (window->wgl.ARB_pixel_format)
+        if (_glfw.wgl.ARB_pixel_format)
         {
             // Get pixel format attributes through "modern" extension
 
@@ -170,18 +123,18 @@ static GLboolean choosePixelFormat(_GLFWwindow* window,
             u->auxBuffers = getPixelFormatAttrib(window, n, WGL_AUX_BUFFERS_ARB);
 
             if (getPixelFormatAttrib(window, n, WGL_STEREO_ARB))
-                u->stereo = GL_TRUE;
+                u->stereo = GLFW_TRUE;
             if (getPixelFormatAttrib(window, n, WGL_DOUBLE_BUFFER_ARB))
-                u->doublebuffer = GL_TRUE;
+                u->doublebuffer = GLFW_TRUE;
 
-            if (window->wgl.ARB_multisample)
+            if (_glfw.wgl.ARB_multisample)
                 u->samples = getPixelFormatAttrib(window, n, WGL_SAMPLES_ARB);
 
-            if (window->wgl.ARB_framebuffer_sRGB ||
-                window->wgl.EXT_framebuffer_sRGB)
+            if (_glfw.wgl.ARB_framebuffer_sRGB ||
+                _glfw.wgl.EXT_framebuffer_sRGB)
             {
                 if (getPixelFormatAttrib(window, n, WGL_FRAMEBUFFER_SRGB_CAPABLE_ARB))
-                    u->sRGB = GL_TRUE;
+                    u->sRGB = GLFW_TRUE;
             }
         }
         else
@@ -190,7 +143,7 @@ static GLboolean choosePixelFormat(_GLFWwindow* window,
 
             // Get pixel format attributes through legacy PFDs
 
-            if (!DescribePixelFormat(window->wgl.dc,
+            if (!DescribePixelFormat(window->context.wgl.dc,
                                      n,
                                      sizeof(PIXELFORMATDESCRIPTOR),
                                      &pfd))
@@ -229,12 +182,12 @@ static GLboolean choosePixelFormat(_GLFWwindow* window,
             u->auxBuffers = pfd.cAuxBuffers;
 
             if (pfd.dwFlags & PFD_STEREO)
-                u->stereo = GL_TRUE;
+                u->stereo = GLFW_TRUE;
             if (pfd.dwFlags & PFD_DOUBLEBUFFER)
-                u->doublebuffer = GL_TRUE;
+                u->doublebuffer = GLFW_TRUE;
         }
 
-        u->wgl = n;
+        u->handle = n;
         usableCount++;
     }
 
@@ -244,7 +197,7 @@ static GLboolean choosePixelFormat(_GLFWwindow* window,
                         "WGL: The driver does not appear to support OpenGL");
 
         free(usableConfigs);
-        return GL_FALSE;
+        return GLFW_FALSE;
     }
 
     closest = _glfwChooseFBConfig(desired, usableConfigs, usableCount);
@@ -254,13 +207,179 @@ static GLboolean choosePixelFormat(_GLFWwindow* window,
                         "WGL: Failed to find a suitable pixel format");
 
         free(usableConfigs);
-        return GL_FALSE;
+        return GLFW_FALSE;
     }
 
-    *result = closest->wgl;
+    *result = (int) closest->handle;
     free(usableConfigs);
 
-    return GL_TRUE;
+    return GLFW_TRUE;
+}
+
+// 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 makeContextCurrent(_GLFWwindow* window)
+{
+    if (window)
+    {
+        if (wglMakeCurrent(window->context.wgl.dc, window->context.wgl.handle))
+            _glfwPlatformSetCurrentContext(window);
+        else
+        {
+            _glfwInputError(GLFW_PLATFORM_ERROR,
+                            "WGL: Failed to make context current");
+            _glfwPlatformSetCurrentContext(NULL);
+        }
+    }
+    else
+    {
+        if (!wglMakeCurrent(NULL, NULL))
+        {
+            _glfwInputError(GLFW_PLATFORM_ERROR,
+                            "WGL: Failed to clear current context");
+        }
+
+        _glfwPlatformSetCurrentContext(NULL);
+    }
+}
+
+static void swapBuffers(_GLFWwindow* window)
+{
+    // HACK: Use DwmFlush when desktop composition is enabled
+    if (isCompositionEnabled() && !window->monitor)
+    {
+        int count = abs(window->context.wgl.interval);
+        while (count--)
+            _glfw_DwmFlush();
+    }
+
+    SwapBuffers(window->context.wgl.dc);
+}
+
+static void swapInterval(int interval)
+{
+    _GLFWwindow* window = _glfwPlatformGetCurrentContext();
+
+    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)
+        interval = 0;
+
+    if (_glfw.wgl.EXT_swap_control)
+        _glfw.wgl.SwapIntervalEXT(interval);
+}
+
+static int extensionSupported(const char* extension)
+{
+    const char* extensions;
+
+    _GLFWwindow* window = _glfwPlatformGetCurrentContext();
+
+    if (_glfw.wgl.GetExtensionsStringEXT)
+    {
+        extensions = _glfw.wgl.GetExtensionsStringEXT();
+        if (extensions)
+        {
+            if (_glfwStringInExtensionString(extension, extensions))
+                return GLFW_TRUE;
+        }
+    }
+
+    if (_glfw.wgl.GetExtensionsStringARB)
+    {
+        extensions = _glfw.wgl.GetExtensionsStringARB(window->context.wgl.dc);
+        if (extensions)
+        {
+            if (_glfwStringInExtensionString(extension, extensions))
+                return GLFW_TRUE;
+        }
+    }
+
+    return GLFW_FALSE;
+}
+
+static GLFWglproc getProcAddress(const char* procname)
+{
+    const GLFWglproc proc = (GLFWglproc) wglGetProcAddress(procname);
+    if (proc)
+        return proc;
+
+    return (GLFWglproc) GetProcAddress(_glfw.wgl.instance, procname);
+}
+
+// Destroy the OpenGL context
+//
+static void destroyContext(_GLFWwindow* window)
+{
+    if (window->context.wgl.handle)
+    {
+        wglDeleteContext(window->context.wgl.handle);
+        window->context.wgl.handle = NULL;
+    }
+}
+
+// Initialize WGL-specific extensions
+//
+static void loadExtensions(void)
+{
+    // Functions for WGL_EXT_extension_string
+    // NOTE: These are needed by extensionSupported
+    _glfw.wgl.GetExtensionsStringEXT = (PFNWGLGETEXTENSIONSSTRINGEXTPROC)
+        wglGetProcAddress("wglGetExtensionsStringEXT");
+    _glfw.wgl.GetExtensionsStringARB = (PFNWGLGETEXTENSIONSSTRINGARBPROC)
+        wglGetProcAddress("wglGetExtensionsStringARB");
+
+    // Functions for WGL_ARB_create_context
+    _glfw.wgl.CreateContextAttribsARB = (PFNWGLCREATECONTEXTATTRIBSARBPROC)
+        wglGetProcAddress("wglCreateContextAttribsARB");
+
+    // Functions for WGL_EXT_swap_control
+    _glfw.wgl.SwapIntervalEXT = (PFNWGLSWAPINTERVALEXTPROC)
+        wglGetProcAddress("wglSwapIntervalEXT");
+
+    // Functions for WGL_ARB_pixel_format
+    _glfw.wgl.GetPixelFormatAttribivARB = (PFNWGLGETPIXELFORMATATTRIBIVARBPROC)
+        wglGetProcAddress("wglGetPixelFormatAttribivARB");
+
+    // This needs to include every extension used below except for
+    // WGL_ARB_extensions_string and WGL_EXT_extensions_string
+    _glfw.wgl.ARB_multisample =
+        extensionSupported("WGL_ARB_multisample");
+    _glfw.wgl.ARB_framebuffer_sRGB =
+        extensionSupported("WGL_ARB_framebuffer_sRGB");
+    _glfw.wgl.EXT_framebuffer_sRGB =
+        extensionSupported("WGL_EXT_framebuffer_sRGB");
+    _glfw.wgl.ARB_create_context =
+        extensionSupported("WGL_ARB_create_context");
+    _glfw.wgl.ARB_create_context_profile =
+        extensionSupported("WGL_ARB_create_context_profile");
+    _glfw.wgl.EXT_create_context_es2_profile =
+        extensionSupported("WGL_EXT_create_context_es2_profile");
+    _glfw.wgl.ARB_create_context_robustness =
+        extensionSupported("WGL_ARB_create_context_robustness");
+    _glfw.wgl.EXT_swap_control =
+        extensionSupported("WGL_EXT_swap_control");
+    _glfw.wgl.ARB_pixel_format =
+        extensionSupported("WGL_ARB_pixel_format");
+    _glfw.wgl.ARB_context_flush_control =
+        extensionSupported("WGL_ARB_context_flush_control");
+
+    _glfw.wgl.extensionsLoaded = GLFW_TRUE;
 }
 
 
@@ -270,51 +389,35 @@ static GLboolean choosePixelFormat(_GLFWwindow* window,
 
 // Initialize WGL
 //
-int _glfwInitContextAPI(void)
+GLFWbool _glfwInitWGL(void)
 {
-    if (!_glfwCreateContextTLS())
-        return GL_FALSE;
-
-    _glfw.wgl.opengl32.instance = LoadLibraryW(L"opengl32.dll");
-    if (!_glfw.wgl.opengl32.instance)
+    _glfw.wgl.instance = LoadLibraryA("opengl32.dll");
+    if (!_glfw.wgl.instance)
     {
         _glfwInputError(GLFW_PLATFORM_ERROR, "WGL: Failed to load opengl32.dll");
-        return GL_FALSE;
+        return GLFW_FALSE;
     }
 
-    _glfw.wgl.opengl32.CreateContext = (WGLCREATECONTEXT_T)
-        GetProcAddress(_glfw.wgl.opengl32.instance, "wglCreateContext");
-    _glfw.wgl.opengl32.DeleteContext = (WGLDELETECONTEXT_T)
-        GetProcAddress(_glfw.wgl.opengl32.instance, "wglDeleteContext");
-    _glfw.wgl.opengl32.GetProcAddress = (WGLGETPROCADDRESS_T)
-        GetProcAddress(_glfw.wgl.opengl32.instance, "wglGetProcAddress");
-    _glfw.wgl.opengl32.MakeCurrent = (WGLMAKECURRENT_T)
-        GetProcAddress(_glfw.wgl.opengl32.instance, "wglMakeCurrent");
-    _glfw.wgl.opengl32.ShareLists = (WGLSHARELISTS_T)
-        GetProcAddress(_glfw.wgl.opengl32.instance, "wglShareLists");
+    _glfw.wgl.CreateContext = (WGLCREATECONTEXT_T)
+        GetProcAddress(_glfw.wgl.instance, "wglCreateContext");
+    _glfw.wgl.DeleteContext = (WGLDELETECONTEXT_T)
+        GetProcAddress(_glfw.wgl.instance, "wglDeleteContext");
+    _glfw.wgl.GetProcAddress = (WGLGETPROCADDRESS_T)
+        GetProcAddress(_glfw.wgl.instance, "wglGetProcAddress");
+    _glfw.wgl.MakeCurrent = (WGLMAKECURRENT_T)
+        GetProcAddress(_glfw.wgl.instance, "wglMakeCurrent");
+    _glfw.wgl.ShareLists = (WGLSHARELISTS_T)
+        GetProcAddress(_glfw.wgl.instance, "wglShareLists");
 
-    if (!_glfw.wgl.opengl32.CreateContext ||
-        !_glfw.wgl.opengl32.DeleteContext ||
-        !_glfw.wgl.opengl32.GetProcAddress ||
-        !_glfw.wgl.opengl32.MakeCurrent ||
-        !_glfw.wgl.opengl32.ShareLists)
-    {
-        _glfwInputError(GLFW_PLATFORM_ERROR,
-                        "WGL: Failed to load opengl32 functions");
-        return GL_FALSE;
-    }
-
-    return GL_TRUE;
+    return GLFW_TRUE;
 }
 
 // Terminate WGL
 //
-void _glfwTerminateContextAPI(void)
+void _glfwTerminateWGL(void)
 {
-    if (_glfw.wgl.opengl32.instance)
-        FreeLibrary(_glfw.wgl.opengl32.instance);
-
-    _glfwDestroyContextTLS();
+    if (_glfw.wgl.instance)
+        FreeLibrary(_glfw.wgl.instance);
 }
 
 #define setWGLattrib(attribName, attribValue) \
@@ -326,48 +429,52 @@ void _glfwTerminateContextAPI(void)
 
 // Create the OpenGL or OpenGL ES context
 //
-int _glfwCreateContext(_GLFWwindow* window,
-                       const _GLFWctxconfig* ctxconfig,
-                       const _GLFWfbconfig* fbconfig)
+GLFWbool _glfwCreateContextWGL(_GLFWwindow* window,
+                               const _GLFWctxconfig* ctxconfig,
+                               const _GLFWfbconfig* fbconfig)
 {
     int attribs[40];
     int pixelFormat = 0;
     PIXELFORMATDESCRIPTOR pfd;
     HGLRC share = NULL;
 
-    if (ctxconfig->share)
-        share = ctxconfig->share->wgl.context;
+    if (ctxconfig->client == GLFW_NO_API)
+        return GLFW_TRUE;
 
-    window->wgl.dc = GetDC(window->win32.handle);
-    if (!window->wgl.dc)
+    if (ctxconfig->share)
+        share = ctxconfig->share->context.wgl.handle;
+
+    window->context.wgl.dc = GetDC(window->win32.handle);
+    if (!window->context.wgl.dc)
     {
         _glfwInputError(GLFW_PLATFORM_ERROR,
                         "WGL: Failed to retrieve DC for window");
-        return GL_FALSE;
+        return GLFW_FALSE;
     }
 
     if (!choosePixelFormat(window, fbconfig, &pixelFormat))
-        return GL_FALSE;
+        return GLFW_FALSE;
 
-    if (!DescribePixelFormat(window->wgl.dc, pixelFormat, sizeof(pfd), &pfd))
+    if (!DescribePixelFormat(window->context.wgl.dc,
+                             pixelFormat, sizeof(pfd), &pfd))
     {
         _glfwInputError(GLFW_PLATFORM_ERROR,
                         "WGL: Failed to retrieve PFD for selected pixel format");
-        return GL_FALSE;
+        return GLFW_FALSE;
     }
 
-    if (!SetPixelFormat(window->wgl.dc, pixelFormat, &pfd))
+    if (!SetPixelFormat(window->context.wgl.dc, pixelFormat, &pfd))
     {
         _glfwInputError(GLFW_PLATFORM_ERROR,
                         "WGL: Failed to set selected pixel format");
-        return GL_FALSE;
+        return GLFW_FALSE;
     }
 
-    if (window->wgl.ARB_create_context)
+    if (_glfw.wgl.ARB_create_context)
     {
         int index = 0, mask = 0, flags = 0;
 
-        if (ctxconfig->api == GLFW_OPENGL_API)
+        if (ctxconfig->client == GLFW_OPENGL_API)
         {
             if (ctxconfig->forward)
                 flags |= WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB;
@@ -382,10 +489,12 @@ int _glfwCreateContext(_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)
         {
-            if (window->wgl.ARB_create_context_robustness)
+            if (_glfw.wgl.ARB_create_context_robustness)
             {
                 if (ctxconfig->robustness == GLFW_NO_RESET_NOTIFICATION)
                 {
@@ -404,7 +513,7 @@ int _glfwCreateContext(_GLFWwindow* window,
 
         if (ctxconfig->release)
         {
-            if (window->wgl.ARB_context_flush_control)
+            if (_glfw.wgl.ARB_context_flush_control)
             {
                 if (ctxconfig->release == GLFW_RELEASE_BEHAVIOR_NONE)
                 {
@@ -436,143 +545,136 @@ int _glfwCreateContext(_GLFWwindow* window,
 
         setWGLattrib(0, 0);
 
-        window->wgl.context = window->wgl.CreateContextAttribsARB(window->wgl.dc,
-                                                                  share,
-                                                                  attribs);
-        if (!window->wgl.context)
+        window->context.wgl.handle =
+            _glfw.wgl.CreateContextAttribsARB(window->context.wgl.dc,
+                                              share, attribs);
+        if (!window->context.wgl.handle)
         {
             _glfwInputError(GLFW_VERSION_UNAVAILABLE,
                             "WGL: Failed to create OpenGL context");
-            return GL_FALSE;
+            return GLFW_FALSE;
         }
     }
     else
     {
-        window->wgl.context = _glfw_wglCreateContext(window->wgl.dc);
-        if (!window->wgl.context)
+        window->context.wgl.handle = wglCreateContext(window->context.wgl.dc);
+        if (!window->context.wgl.handle)
         {
             _glfwInputError(GLFW_VERSION_UNAVAILABLE,
                             "WGL: Failed to create OpenGL context");
-            return GL_FALSE;
+            return GLFW_FALSE;
         }
 
         if (share)
         {
-            if (!_glfw_wglShareLists(share, window->wgl.context))
+            if (!wglShareLists(share, window->context.wgl.handle))
             {
                 _glfwInputError(GLFW_PLATFORM_ERROR,
                                 "WGL: Failed to enable sharing with specified OpenGL context");
-                return GL_FALSE;
+                return GLFW_FALSE;
             }
         }
     }
 
-    _glfwPlatformMakeContextCurrent(window);
-    initWGLExtensions(window);
+    window->context.makeCurrent = makeContextCurrent;
+    window->context.swapBuffers = swapBuffers;
+    window->context.swapInterval = swapInterval;
+    window->context.extensionSupported = extensionSupported;
+    window->context.getProcAddress = getProcAddress;
+    window->context.destroy = destroyContext;
 
-    return GL_TRUE;
+    return GLFW_TRUE;
 }
 
 #undef setWGLattrib
 
-// Destroy the OpenGL context
-//
-void _glfwDestroyContext(_GLFWwindow* window)
-{
-    if (window->wgl.context)
-    {
-        _glfw_wglDeleteContext(window->wgl.context);
-        window->wgl.context = NULL;
-    }
-
-    if (window->wgl.dc)
-    {
-        ReleaseDC(window->win32.handle, window->wgl.dc);
-        window->wgl.dc = NULL;
-    }
-}
-
 // Analyzes the specified context for possible recreation
 //
-int _glfwAnalyzeContext(const _GLFWwindow* window,
-                        const _GLFWctxconfig* ctxconfig,
-                        const _GLFWfbconfig* fbconfig)
+int _glfwAnalyzeContextWGL(_GLFWwindow* window,
+                           const _GLFWctxconfig* ctxconfig,
+                           const _GLFWfbconfig* fbconfig)
 {
-    GLboolean required = GL_FALSE;
+    GLFWbool required = GLFW_FALSE;
 
-    if (ctxconfig->api == GLFW_OPENGL_API)
+    if (_glfw.wgl.extensionsLoaded)
+        return _GLFW_RECREATION_NOT_NEEDED;
+
+    makeContextCurrent(window);
+    loadExtensions();
+
+    if (ctxconfig->client == GLFW_OPENGL_API)
     {
         if (ctxconfig->forward)
         {
-            if (!window->wgl.ARB_create_context)
+            if (!_glfw.wgl.ARB_create_context)
             {
                 _glfwInputError(GLFW_VERSION_UNAVAILABLE,
                                 "WGL: A forward compatible OpenGL context requested but WGL_ARB_create_context is unavailable");
                 return _GLFW_RECREATION_IMPOSSIBLE;
             }
 
-            required = GL_TRUE;
+            required = GLFW_TRUE;
         }
 
         if (ctxconfig->profile)
         {
-            if (!window->wgl.ARB_create_context_profile)
+            if (!_glfw.wgl.ARB_create_context_profile)
             {
                 _glfwInputError(GLFW_VERSION_UNAVAILABLE,
                                 "WGL: OpenGL profile requested but WGL_ARB_create_context_profile is unavailable");
                 return _GLFW_RECREATION_IMPOSSIBLE;
             }
 
-            required = GL_TRUE;
+            required = GLFW_TRUE;
         }
 
         if (ctxconfig->release)
         {
-            if (window->wgl.ARB_context_flush_control)
-                required = GL_TRUE;
+            if (_glfw.wgl.ARB_context_flush_control)
+                required = GLFW_TRUE;
         }
     }
     else
     {
-        if (!window->wgl.ARB_create_context ||
-            !window->wgl.ARB_create_context_profile ||
-            !window->wgl.EXT_create_context_es2_profile)
+        if (!_glfw.wgl.ARB_create_context ||
+            !_glfw.wgl.ARB_create_context_profile ||
+            !_glfw.wgl.EXT_create_context_es2_profile)
         {
             _glfwInputError(GLFW_API_UNAVAILABLE,
                             "WGL: OpenGL ES requested but WGL_ARB_create_context_es2_profile is unavailable");
             return _GLFW_RECREATION_IMPOSSIBLE;
         }
 
-        required = GL_TRUE;
+        required = GLFW_TRUE;
     }
 
     if (ctxconfig->major != 1 || ctxconfig->minor != 0)
     {
-        if (window->wgl.ARB_create_context)
-            required = GL_TRUE;
+        if (_glfw.wgl.ARB_create_context)
+            required = GLFW_TRUE;
     }
 
     if (ctxconfig->debug)
     {
-        if (window->wgl.ARB_create_context)
-            required = GL_TRUE;
+        if (_glfw.wgl.ARB_create_context)
+            required = GLFW_TRUE;
     }
 
     if (fbconfig->samples > 0)
     {
         // MSAA is not a hard constraint, so do nothing if it's not supported
-        if (window->wgl.ARB_multisample && window->wgl.ARB_pixel_format)
-            required = GL_TRUE;
+        if (_glfw.wgl.ARB_multisample && _glfw.wgl.ARB_pixel_format)
+            required = GLFW_TRUE;
     }
 
     if (fbconfig->sRGB)
     {
         // sRGB is not a hard constraint, so do nothing if it's not supported
-        if ((window->wgl.ARB_framebuffer_sRGB ||
-             window->wgl.EXT_framebuffer_sRGB) &&
-            window->wgl.ARB_pixel_format)
+        if ((_glfw.wgl.ARB_framebuffer_sRGB ||
+             _glfw.wgl.EXT_framebuffer_sRGB) &&
+            _glfw.wgl.ARB_pixel_format)
         {
-            required = GL_TRUE;
+            required = GLFW_TRUE;
         }
     }
 
@@ -583,87 +685,6 @@ int _glfwAnalyzeContext(const _GLFWwindow* window,
 }
 
 
-//////////////////////////////////////////////////////////////////////////
-//////                       GLFW platform API                      //////
-//////////////////////////////////////////////////////////////////////////
-
-void _glfwPlatformMakeContextCurrent(_GLFWwindow* window)
-{
-    if (window)
-        _glfw_wglMakeCurrent(window->wgl.dc, window->wgl.context);
-    else
-        _glfw_wglMakeCurrent(NULL, NULL);
-
-    _glfwSetContextTLS(window);
-}
-
-void _glfwPlatformSwapBuffers(_GLFWwindow* window)
-{
-    // HACK: Use DwmFlush when desktop composition is enabled
-    if (_glfwIsCompositionEnabled() && !window->monitor)
-    {
-        int count = abs(window->wgl.interval);
-        while (count--)
-            _glfw_DwmFlush();
-    }
-
-    SwapBuffers(window->wgl.dc);
-}
-
-void _glfwPlatformSwapInterval(int interval)
-{
-    _GLFWwindow* window = _glfwPlatformGetCurrentContext();
-
-    window->wgl.interval = interval;
-
-    // HACK: Disable WGL swap interval when desktop composition is enabled to
-    //       avoid interfering with DWM vsync
-    if (_glfwIsCompositionEnabled() && !window->monitor)
-        interval = 0;
-
-    if (window->wgl.EXT_swap_control)
-        window->wgl.SwapIntervalEXT(interval);
-}
-
-int _glfwPlatformExtensionSupported(const char* extension)
-{
-    const char* extensions;
-
-    _GLFWwindow* window = _glfwPlatformGetCurrentContext();
-
-    if (window->wgl.GetExtensionsStringEXT != NULL)
-    {
-        extensions = window->wgl.GetExtensionsStringEXT();
-        if (extensions)
-        {
-            if (_glfwStringInExtensionString(extension, extensions))
-                return GL_TRUE;
-        }
-    }
-
-    if (window->wgl.GetExtensionsStringARB != NULL)
-    {
-        extensions = window->wgl.GetExtensionsStringARB(window->wgl.dc);
-        if (extensions)
-        {
-            if (_glfwStringInExtensionString(extension, extensions))
-                return GL_TRUE;
-        }
-    }
-
-    return GL_FALSE;
-}
-
-GLFWglproc _glfwPlatformGetProcAddress(const char* procname)
-{
-    const GLFWglproc proc = (GLFWglproc) _glfw_wglGetProcAddress(procname);
-    if (proc)
-        return proc;
-
-    return (GLFWglproc) GetProcAddress(_glfw.wgl.opengl32.instance, procname);
-}
-
-
 //////////////////////////////////////////////////////////////////////////
 //////                        GLFW native API                       //////
 //////////////////////////////////////////////////////////////////////////
@@ -672,6 +693,13 @@ GLFWAPI HGLRC glfwGetWGLContext(GLFWwindow* handle)
 {
     _GLFWwindow* window = (_GLFWwindow*) handle;
     _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
-    return window->wgl.context;
+
+    if (window->context.client == GLFW_NO_API)
+    {
+        _glfwInputError(GLFW_NO_WINDOW_CONTEXT, NULL);
+        return NULL;
+    }
+
+    return window->context.wgl.handle;
 }
 

src/wgl_context.h

@@ -1,8 +1,8 @@
 //========================================================================
-// GLFW 3.1 WGL - www.glfw.org
+// GLFW 3.2 WGL - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
+// Copyright (c) 2006-2016 Camilla Berglund <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,24 +28,74 @@
 #ifndef _glfw3_wgl_context_h_
 #define _glfw3_wgl_context_h_
 
-// This path may need to be changed if you build GLFW using your own setup
-// We ship and use our own copy of wglext.h since GLFW uses fairly new
-// extensions and not all operating systems come with an up-to-date version
-#include "../deps/GL/wglext.h"
 
-// opengl32.dll function pointer typedefs
+#define WGL_NUMBER_PIXEL_FORMATS_ARB 0x2000
+#define WGL_SUPPORT_OPENGL_ARB 0x2010
+#define WGL_DRAW_TO_WINDOW_ARB 0x2001
+#define WGL_PIXEL_TYPE_ARB 0x2013
+#define WGL_TYPE_RGBA_ARB 0x202b
+#define WGL_ACCELERATION_ARB 0x2003
+#define WGL_NO_ACCELERATION_ARB 0x2025
+#define WGL_RED_BITS_ARB 0x2015
+#define WGL_RED_SHIFT_ARB 0x2016
+#define WGL_GREEN_BITS_ARB 0x2017
+#define WGL_GREEN_SHIFT_ARB 0x2018
+#define WGL_BLUE_BITS_ARB 0x2019
+#define WGL_BLUE_SHIFT_ARB 0x201a
+#define WGL_ALPHA_BITS_ARB 0x201b
+#define WGL_ALPHA_SHIFT_ARB 0x201c
+#define WGL_ACCUM_BITS_ARB 0x201d
+#define WGL_ACCUM_RED_BITS_ARB 0x201e
+#define WGL_ACCUM_GREEN_BITS_ARB 0x201f
+#define WGL_ACCUM_BLUE_BITS_ARB 0x2020
+#define WGL_ACCUM_ALPHA_BITS_ARB 0x2021
+#define WGL_DEPTH_BITS_ARB 0x2022
+#define WGL_STENCIL_BITS_ARB 0x2023
+#define WGL_AUX_BUFFERS_ARB 0x2024
+#define WGL_STEREO_ARB 0x2012
+#define WGL_DOUBLE_BUFFER_ARB 0x2011
+#define WGL_SAMPLES_ARB 0x2042
+#define WGL_FRAMEBUFFER_SRGB_CAPABLE_ARB 0x20a9
+#define WGL_CONTEXT_DEBUG_BIT_ARB 0x00000001
+#define WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB 0x00000002
+#define WGL_CONTEXT_PROFILE_MASK_ARB 0x9126
+#define WGL_CONTEXT_CORE_PROFILE_BIT_ARB 0x00000001
+#define WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB 0x00000002
+#define WGL_CONTEXT_MAJOR_VERSION_ARB 0x2091
+#define WGL_CONTEXT_MINOR_VERSION_ARB 0x2092
+#define WGL_CONTEXT_FLAGS_ARB 0x2094
+#define WGL_CONTEXT_ES2_PROFILE_BIT_EXT 0x00000004
+#define WGL_CONTEXT_ROBUST_ACCESS_BIT_ARB 0x00000004
+#define WGL_LOSE_CONTEXT_ON_RESET_ARB 0x8252
+#define WGL_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB 0x8256
+#define WGL_NO_RESET_NOTIFICATION_ARB 0x8261
+#define WGL_CONTEXT_RELEASE_BEHAVIOR_ARB 0x2097
+#define WGL_CONTEXT_RELEASE_BEHAVIOR_NONE_ARB 0
+#define WGL_CONTEXT_RELEASE_BEHAVIOR_FLUSH_ARB 0x2098
+
+typedef BOOL (WINAPI * PFNWGLSWAPINTERVALEXTPROC)(int);
+typedef BOOL (WINAPI * PFNWGLGETPIXELFORMATATTRIBIVARBPROC)(HDC,int,int,UINT,const int*,int*);
+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 BOOL (WINAPI * WGLDELETECONTEXT_T)(HGLRC);
 typedef PROC (WINAPI * WGLGETPROCADDRESS_T)(LPCSTR);
 typedef BOOL (WINAPI * WGLMAKECURRENT_T)(HDC,HGLRC);
 typedef BOOL (WINAPI * WGLSHARELISTS_T)(HGLRC,HGLRC);
-#define _glfw_wglCreateContext _glfw.wgl.opengl32.CreateContext
-#define _glfw_wglDeleteContext _glfw.wgl.opengl32.DeleteContext
-#define _glfw_wglGetProcAddress _glfw.wgl.opengl32.GetProcAddress
-#define _glfw_wglMakeCurrent _glfw.wgl.opengl32.MakeCurrent
-#define _glfw_wglShareLists _glfw.wgl.opengl32.ShareLists
 
-#define _GLFW_PLATFORM_FBCONFIG                 int             wgl
+// opengl32.dll function pointer typedefs
+#define wglCreateContext _glfw.wgl.CreateContext
+#define wglDeleteContext _glfw.wgl.DeleteContext
+#define wglGetProcAddress _glfw.wgl.GetProcAddress
+#define wglMakeCurrent _glfw.wgl.MakeCurrent
+#define wglShareLists _glfw.wgl.ShareLists
+
+#define _GLFW_RECREATION_NOT_NEEDED 0
+#define _GLFW_RECREATION_REQUIRED   1
+#define _GLFW_RECREATION_IMPOSSIBLE 2
+
 #define _GLFW_PLATFORM_CONTEXT_STATE            _GLFWcontextWGL wgl
 #define _GLFW_PLATFORM_LIBRARY_CONTEXT_STATE    _GLFWlibraryWGL wgl
 
@@ -54,27 +104,10 @@ typedef BOOL (WINAPI * WGLSHARELISTS_T)(HGLRC,HGLRC);
 //
 typedef struct _GLFWcontextWGL
 {
-    HDC       dc;              // Private GDI device context
-    HGLRC     context;         // Permanent rendering context
+    HDC       dc;
+    HGLRC     handle;
     int       interval;
 
-    // WGL extensions (context specific)
-    PFNWGLSWAPINTERVALEXTPROC           SwapIntervalEXT;
-    PFNWGLGETPIXELFORMATATTRIBIVARBPROC GetPixelFormatAttribivARB;
-    PFNWGLGETEXTENSIONSSTRINGEXTPROC    GetExtensionsStringEXT;
-    PFNWGLGETEXTENSIONSSTRINGARBPROC    GetExtensionsStringARB;
-    PFNWGLCREATECONTEXTATTRIBSARBPROC   CreateContextAttribsARB;
-    GLboolean                           EXT_swap_control;
-    GLboolean                           ARB_multisample;
-    GLboolean                           ARB_framebuffer_sRGB;
-    GLboolean                           EXT_framebuffer_sRGB;
-    GLboolean                           ARB_pixel_format;
-    GLboolean                           ARB_create_context;
-    GLboolean                           ARB_create_context_profile;
-    GLboolean                           EXT_create_context_es2_profile;
-    GLboolean                           ARB_create_context_robustness;
-    GLboolean                           ARB_context_flush_control;
-
 } _GLFWcontextWGL;
 
 
@@ -82,26 +115,41 @@ typedef struct _GLFWcontextWGL
 //
 typedef struct _GLFWlibraryWGL
 {
-    struct {
-        HINSTANCE           instance;
-        WGLCREATECONTEXT_T  CreateContext;
-        WGLDELETECONTEXT_T  DeleteContext;
-        WGLGETPROCADDRESS_T GetProcAddress;
-        WGLMAKECURRENT_T    MakeCurrent;
-        WGLSHARELISTS_T     ShareLists;
-    } opengl32;
+    HINSTANCE                           instance;
+    WGLCREATECONTEXT_T                  CreateContext;
+    WGLDELETECONTEXT_T                  DeleteContext;
+    WGLGETPROCADDRESS_T                 GetProcAddress;
+    WGLMAKECURRENT_T                    MakeCurrent;
+    WGLSHARELISTS_T                     ShareLists;
+
+    GLFWbool                            extensionsLoaded;
+
+    PFNWGLSWAPINTERVALEXTPROC           SwapIntervalEXT;
+    PFNWGLGETPIXELFORMATATTRIBIVARBPROC GetPixelFormatAttribivARB;
+    PFNWGLGETEXTENSIONSSTRINGEXTPROC    GetExtensionsStringEXT;
+    PFNWGLGETEXTENSIONSSTRINGARBPROC    GetExtensionsStringARB;
+    PFNWGLCREATECONTEXTATTRIBSARBPROC   CreateContextAttribsARB;
+    GLFWbool                            EXT_swap_control;
+    GLFWbool                            ARB_multisample;
+    GLFWbool                            ARB_framebuffer_sRGB;
+    GLFWbool                            EXT_framebuffer_sRGB;
+    GLFWbool                            ARB_pixel_format;
+    GLFWbool                            ARB_create_context;
+    GLFWbool                            ARB_create_context_profile;
+    GLFWbool                            EXT_create_context_es2_profile;
+    GLFWbool                            ARB_create_context_robustness;
+    GLFWbool                            ARB_context_flush_control;
 
 } _GLFWlibraryWGL;
 
 
-int _glfwInitContextAPI(void);
-void _glfwTerminateContextAPI(void);
-int _glfwCreateContext(_GLFWwindow* window,
-                       const _GLFWctxconfig* ctxconfig,
-                       const _GLFWfbconfig* fbconfig);
-void _glfwDestroyContext(_GLFWwindow* window);
-int _glfwAnalyzeContext(const _GLFWwindow* window,
-                        const _GLFWctxconfig* ctxconfig,
-                        const _GLFWfbconfig* fbconfig);
+GLFWbool _glfwInitWGL(void);
+void _glfwTerminateWGL(void);
+GLFWbool _glfwCreateContextWGL(_GLFWwindow* window,
+                               const _GLFWctxconfig* ctxconfig,
+                               const _GLFWfbconfig* fbconfig);
+int _glfwAnalyzeContextWGL(_GLFWwindow* window,
+                           const _GLFWctxconfig* ctxconfig,
+                           const _GLFWfbconfig* fbconfig);
 
 #endif // _glfw3_wgl_context_h_

src/win32_init.c

@@ -1,8 +1,8 @@
 //========================================================================
-// GLFW 3.1 Win32 - www.glfw.org
+// GLFW 3.2 Win32 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
+// Copyright (c) 2006-2016 Camilla Berglund <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,6 +30,8 @@
 #include <stdlib.h>
 #include <malloc.h>
 
+#include <initguid.h>
+DEFINE_GUID(GUID_DEVINTERFACE_HID,0x4d1e55b2,0xf16f,0x11cf,0x88,0xcb,0x00,0x11,0x11,0x00,0x00,0x30);
 
 #if defined(_GLFW_USE_HYBRID_HPG) || defined(_GLFW_USE_OPTIMUS_HPG)
 
@@ -60,45 +62,65 @@ BOOL WINAPI DllMain(HINSTANCE instance, DWORD reason, LPVOID reserved)
 
 // Load necessary libraries (DLLs)
 //
-static GLboolean initLibraries(void)
+static GLFWbool loadLibraries(void)
 {
-    _glfw.win32.winmm.instance = LoadLibraryW(L"winmm.dll");
+    _glfw.win32.winmm.instance = LoadLibraryA("winmm.dll");
     if (!_glfw.win32.winmm.instance)
     {
-        _glfwInputError(GLFW_PLATFORM_ERROR,
-                        "Win32: Failed to load winmm.dll");
-        return GL_FALSE;
+        _glfwInputError(GLFW_PLATFORM_ERROR, "Win32: Failed to load winmm.dll");
+        return GLFW_FALSE;
     }
 
-    _glfw.win32.winmm.joyGetDevCaps = (JOYGETDEVCAPS_T)
-        GetProcAddress(_glfw.win32.winmm.instance, "joyGetDevCapsW");
-    _glfw.win32.winmm.joyGetPos = (JOYGETPOS_T)
-        GetProcAddress(_glfw.win32.winmm.instance, "joyGetPos");
-    _glfw.win32.winmm.joyGetPosEx = (JOYGETPOSEX_T)
-        GetProcAddress(_glfw.win32.winmm.instance, "joyGetPosEx");
     _glfw.win32.winmm.timeGetTime = (TIMEGETTIME_T)
         GetProcAddress(_glfw.win32.winmm.instance, "timeGetTime");
 
-    if (!_glfw.win32.winmm.joyGetDevCaps ||
-        !_glfw.win32.winmm.joyGetPos ||
-        !_glfw.win32.winmm.joyGetPosEx ||
-        !_glfw.win32.winmm.timeGetTime)
+    _glfw.win32.user32.instance = LoadLibraryA("user32.dll");
+    if (!_glfw.win32.user32.instance)
     {
-        _glfwInputError(GLFW_PLATFORM_ERROR,
-                        "Win32: Failed to load winmm functions");
-        return GL_FALSE;
+        _glfwInputError(GLFW_PLATFORM_ERROR, "Win32: Failed to load user32.dll");
+        return GLFW_FALSE;
     }
 
-    _glfw.win32.user32.instance = LoadLibraryW(L"user32.dll");
-    if (_glfw.win32.user32.instance)
+    _glfw.win32.user32.SetProcessDPIAware = (SETPROCESSDPIAWARE_T)
+        GetProcAddress(_glfw.win32.user32.instance, "SetProcessDPIAware");
+    _glfw.win32.user32.ChangeWindowMessageFilterEx = (CHANGEWINDOWMESSAGEFILTEREX_T)
+        GetProcAddress(_glfw.win32.user32.instance, "ChangeWindowMessageFilterEx");
+
+    _glfw.win32.dinput8.instance = LoadLibraryA("dinput8.dll");
+    if (_glfw.win32.dinput8.instance)
     {
-        _glfw.win32.user32.SetProcessDPIAware = (SETPROCESSDPIAWARE_T)
-            GetProcAddress(_glfw.win32.user32.instance, "SetProcessDPIAware");
-        _glfw.win32.user32.ChangeWindowMessageFilterEx = (CHANGEWINDOWMESSAGEFILTEREX_T)
-            GetProcAddress(_glfw.win32.user32.instance, "ChangeWindowMessageFilterEx");
+        _glfw.win32.dinput8.DirectInput8Create = (DIRECTINPUT8CREATE_T)
+            GetProcAddress(_glfw.win32.dinput8.instance, "DirectInput8Create");
     }
 
-    _glfw.win32.dwmapi.instance = LoadLibraryW(L"dwmapi.dll");
+    {
+        int i;
+        const char* names[] =
+        {
+            "xinput1_4.dll",
+            "xinput1_3.dll",
+            "xinput9_1_0.dll",
+            "xinput1_2.dll",
+            "xinput1_1.dll",
+            NULL
+        };
+
+        for (i = 0;  names[i];  i++)
+        {
+            _glfw.win32.xinput.instance = LoadLibraryA(names[i]);
+            if (_glfw.win32.xinput.instance)
+            {
+                _glfw.win32.xinput.XInputGetCapabilities = (XINPUTGETCAPABILITIES_T)
+                    GetProcAddress(_glfw.win32.xinput.instance, "XInputGetCapabilities");
+                _glfw.win32.xinput.XInputGetState = (XINPUTGETSTATE_T)
+                    GetProcAddress(_glfw.win32.xinput.instance, "XInputGetState");
+
+                break;
+            }
+        }
+    }
+
+    _glfw.win32.dwmapi.instance = LoadLibraryA("dwmapi.dll");
     if (_glfw.win32.dwmapi.instance)
     {
         _glfw.win32.dwmapi.DwmIsCompositionEnabled = (DWMISCOMPOSITIONENABLED_T)
@@ -107,13 +129,26 @@ static GLboolean initLibraries(void)
             GetProcAddress(_glfw.win32.dwmapi.instance, "DwmFlush");
     }
 
-    return GL_TRUE;
+    _glfw.win32.shcore.instance = LoadLibraryA("shcore.dll");
+    if (_glfw.win32.shcore.instance)
+    {
+        _glfw.win32.shcore.SetProcessDpiAwareness = (SETPROCESSDPIAWARENESS_T)
+            GetProcAddress(_glfw.win32.shcore.instance, "SetProcessDpiAwareness");
+    }
+
+    return GLFW_TRUE;
 }
 
 // Unload used libraries (DLLs)
 //
-static void terminateLibraries(void)
+static void freeLibraries(void)
 {
+    if (_glfw.win32.xinput.instance)
+        FreeLibrary(_glfw.win32.xinput.instance);
+
+    if (_glfw.win32.dinput8.instance)
+        FreeLibrary(_glfw.win32.dinput8.instance);
+
     if (_glfw.win32.winmm.instance)
         FreeLibrary(_glfw.win32.winmm.instance);
 
@@ -122,13 +157,19 @@ static void terminateLibraries(void)
 
     if (_glfw.win32.dwmapi.instance)
         FreeLibrary(_glfw.win32.dwmapi.instance);
+
+    if (_glfw.win32.shcore.instance)
+        FreeLibrary(_glfw.win32.shcore.instance);
 }
 
 // Create key code translation tables
 //
 static void createKeyTables(void)
 {
+    int scancode;
+
     memset(_glfw.win32.publicKeys, -1, sizeof(_glfw.win32.publicKeys));
+    memset(_glfw.win32.nativeKeys, -1, sizeof(_glfw.win32.nativeKeys));
 
     _glfw.win32.publicKeys[0x00B] = GLFW_KEY_0;
     _glfw.win32.publicKeys[0x002] = GLFW_KEY_1;
@@ -191,6 +232,7 @@ static void createKeyTables(void)
     _glfw.win32.publicKeys[0x151] = GLFW_KEY_PAGE_DOWN;
     _glfw.win32.publicKeys[0x149] = GLFW_KEY_PAGE_UP;
     _glfw.win32.publicKeys[0x045] = GLFW_KEY_PAUSE;
+    _glfw.win32.publicKeys[0x146] = GLFW_KEY_PAUSE;
     _glfw.win32.publicKeys[0x039] = GLFW_KEY_SPACE;
     _glfw.win32.publicKeys[0x00F] = GLFW_KEY_TAB;
     _glfw.win32.publicKeys[0x03A] = GLFW_KEY_CAPS_LOCK;
@@ -250,6 +292,47 @@ static void createKeyTables(void)
     _glfw.win32.publicKeys[0x11C] = GLFW_KEY_KP_ENTER;
     _glfw.win32.publicKeys[0x037] = GLFW_KEY_KP_MULTIPLY;
     _glfw.win32.publicKeys[0x04A] = GLFW_KEY_KP_SUBTRACT;
+
+    for (scancode = 0;  scancode < 512;  scancode++)
+    {
+        if (_glfw.win32.publicKeys[scancode] > 0)
+            _glfw.win32.nativeKeys[_glfw.win32.publicKeys[scancode]] = scancode;
+    }
+}
+
+// Creates a dummy window for behind-the-scenes work
+//
+static HWND createHelperWindow(void)
+{
+    HWND window = CreateWindowExW(WS_EX_OVERLAPPEDWINDOW,
+                                  _GLFW_WNDCLASSNAME,
+                                  L"GLFW helper window",
+                                  WS_CLIPSIBLINGS | WS_CLIPCHILDREN,
+                                  0, 0, 1, 1,
+                                  HWND_MESSAGE, NULL,
+                                  GetModuleHandleW(NULL),
+                                  NULL);
+    if (!window)
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "Win32: Failed to create helper window");
+        return NULL;
+    }
+
+    // Register for HID device notifications
+    {
+        DEV_BROADCAST_DEVICEINTERFACE_W dbi;
+        ZeroMemory(&dbi, sizeof(dbi));
+        dbi.dbcc_size = sizeof(dbi);
+        dbi.dbcc_devicetype = DBT_DEVTYP_DEVICEINTERFACE;
+        dbi.dbcc_classguid = GUID_DEVINTERFACE_HID;
+
+        RegisterDeviceNotificationW(window,
+                                    (DEV_BROADCAST_HDR*) &dbi,
+                                    DEVICE_NOTIFY_WINDOW_HANDLE);
+    }
+
+   return window;
 }
 
 
@@ -257,24 +340,9 @@ static void createKeyTables(void)
 //////                       GLFW internal API                      //////
 //////////////////////////////////////////////////////////////////////////
 
-// Returns whether desktop compositing is enabled
-//
-BOOL _glfwIsCompositionEnabled(void)
-{
-    BOOL enabled;
-
-    if (!_glfw_DwmIsCompositionEnabled)
-        return FALSE;
-
-    if (_glfw_DwmIsCompositionEnabled(&enabled) != S_OK)
-        return FALSE;
-
-    return enabled;
-}
-
 // Returns a wide string version of the specified UTF-8 string
 //
-WCHAR* _glfwCreateWideStringFromUTF8(const char* source)
+WCHAR* _glfwCreateWideStringFromUTF8Win32(const char* source)
 {
     WCHAR* target;
     int length;
@@ -296,7 +364,7 @@ WCHAR* _glfwCreateWideStringFromUTF8(const char* source)
 
 // Returns a UTF-8 string version of the specified wide string
 //
-char* _glfwCreateUTF8FromWideString(const WCHAR* source)
+char* _glfwCreateUTF8FromWideStringWin32(const WCHAR* source)
 {
     char* target;
     int length;
@@ -323,6 +391,9 @@ char* _glfwCreateUTF8FromWideString(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)
@@ -331,29 +402,41 @@ int _glfwPlatformInit(void)
     SystemParametersInfoW(SPI_SETFOREGROUNDLOCKTIMEOUT, 0, UIntToPtr(0),
                           SPIF_SENDCHANGE);
 
-    if (!initLibraries())
-        return GL_FALSE;
+    if (!loadLibraries())
+        return GLFW_FALSE;
 
     createKeyTables();
 
-    if (_glfw_SetProcessDPIAware)
+    if (_glfw_SetProcessDpiAwareness)
+        _glfw_SetProcessDpiAwareness(PROCESS_PER_MONITOR_DPI_AWARE);
+    else if (_glfw_SetProcessDPIAware)
         _glfw_SetProcessDPIAware();
 
-    if (!_glfwRegisterWindowClass())
-        return GL_FALSE;
+    if (!_glfwRegisterWindowClassWin32())
+        return GLFW_FALSE;
 
-    if (!_glfwInitContextAPI())
-        return GL_FALSE;
+    _glfw.win32.helperWindowHandle = createHelperWindow();
+    if (!_glfw.win32.helperWindowHandle)
+        return GLFW_FALSE;
 
-    _glfwInitTimer();
-    _glfwInitJoysticks();
+    _glfwPlatformPollEvents();
 
-    return GL_TRUE;
+    if (!_glfwInitWGL())
+        return GLFW_FALSE;
+
+    _glfwInitEGL();
+    _glfwInitTimerWin32();
+    _glfwInitJoysticksWin32();
+
+    return GLFW_TRUE;
 }
 
 void _glfwPlatformTerminate(void)
 {
-    _glfwUnregisterWindowClass();
+    if (_glfw.win32.helperWindowHandle)
+        DestroyWindow(_glfw.win32.helperWindowHandle);
+
+    _glfwUnregisterWindowClassWin32();
 
     // Restore previous foreground lock timeout system setting
     SystemParametersInfoW(SPI_SETFOREGROUNDLOCKTIMEOUT, 0,
@@ -362,19 +445,18 @@ void _glfwPlatformTerminate(void)
 
     free(_glfw.win32.clipboardString);
 
-    _glfwTerminateJoysticks();
-    _glfwTerminateContextAPI();
-    terminateLibraries();
+    _glfwTerminateWGL();
+    _glfwTerminateEGL();
+
+    _glfwTerminateJoysticksWin32();
+    _glfwTerminateThreadLocalStorageWin32();
+
+    freeLibraries();
 }
 
 const char* _glfwPlatformGetVersionString(void)
 {
-    return _GLFW_VERSION_NUMBER " Win32"
-#if defined(_GLFW_WGL)
-        " WGL"
-#elif defined(_GLFW_EGL)
-        " EGL"
-#endif
+    return _GLFW_VERSION_NUMBER " Win32 WGL EGL"
 #if defined(__MINGW32__)
         " MinGW"
 #elif defined(_MSC_VER)

src/win32_joystick.c

@@ -0,0 +1,763 @@
+//========================================================================
+// GLFW 3.1 Win32 - www.glfw.org
+//------------------------------------------------------------------------
+// Copyright (c) 2002-2006 Marcus Geelnard
+// Copyright (c) 2006-2016 Camilla Berglund <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 <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
+#define _GLFW_TYPE_POV      3
+
+// Data produced with DirectInput device object enumeration
+//
+typedef struct _GLFWobjenumWin32
+{
+    IDirectInputDevice8W*   device;
+    _GLFWjoyobjectWin32*    objects;
+    int                     objectCount;
+    int                     axisCount;
+    int                     sliderCount;
+    int                     buttonCount;
+    int                     povCount;
+} _GLFWobjenumWin32;
+
+// Define only the necessary GUIDs (it's bad enough that we're exporting these)
+//
+DEFINE_GUID(IID_IDirectInput8W,0xbf798031,0x483a,0x4da2,0xaa,0x99,0x5d,0x64,0xed,0x36,0x97,0x00);
+DEFINE_GUID(GUID_XAxis,0xa36d02e0,0xc9f3,0x11cf,0xbf,0xc7,0x44,0x45,0x53,0x54,0x00,0x00);
+DEFINE_GUID(GUID_YAxis,0xa36d02e1,0xc9f3,0x11cf,0xbf,0xc7,0x44,0x45,0x53,0x54,0x00,0x00);
+DEFINE_GUID(GUID_ZAxis,0xa36d02e2,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);
+DEFINE_GUID(GUID_RyAxis,0xa36d02f5,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);
+DEFINE_GUID(GUID_Slider,0xa36d02e4,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);
+DEFINE_GUID(GUID_POV,0xa36d02f2,0xc9f3,0x11cf,0xbf,0xc7,0x44,0x45,0x53,0x54,0x00,0x00);
+
+// Object data array for our clone of c_dfDIJoystick
+// Generated with https://github.com/elmindreda/c_dfDIJoystick2
+//
+static DIOBJECTDATAFORMAT _glfwObjectDataFormats[] =
+{
+    { &GUID_XAxis,DIJOFS_X,DIDFT_AXIS|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,DIDOI_ASPECTPOSITION },
+    { &GUID_YAxis,DIJOFS_Y,DIDFT_AXIS|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,DIDOI_ASPECTPOSITION },
+    { &GUID_ZAxis,DIJOFS_Z,DIDFT_AXIS|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,DIDOI_ASPECTPOSITION },
+    { &GUID_RxAxis,DIJOFS_RX,DIDFT_AXIS|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,DIDOI_ASPECTPOSITION },
+    { &GUID_RyAxis,DIJOFS_RY,DIDFT_AXIS|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,DIDOI_ASPECTPOSITION },
+    { &GUID_RzAxis,DIJOFS_RZ,DIDFT_AXIS|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,DIDOI_ASPECTPOSITION },
+    { &GUID_Slider,DIJOFS_SLIDER(0),DIDFT_AXIS|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,DIDOI_ASPECTPOSITION },
+    { &GUID_Slider,DIJOFS_SLIDER(1),DIDFT_AXIS|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,DIDOI_ASPECTPOSITION },
+    { &GUID_POV,DIJOFS_POV(0),DIDFT_POV|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,0 },
+    { &GUID_POV,DIJOFS_POV(1),DIDFT_POV|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,0 },
+    { &GUID_POV,DIJOFS_POV(2),DIDFT_POV|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,0 },
+    { &GUID_POV,DIJOFS_POV(3),DIDFT_POV|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,0 },
+    { NULL,DIJOFS_BUTTON(0),DIDFT_BUTTON|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,0 },
+    { NULL,DIJOFS_BUTTON(1),DIDFT_BUTTON|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,0 },
+    { NULL,DIJOFS_BUTTON(2),DIDFT_BUTTON|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,0 },
+    { NULL,DIJOFS_BUTTON(3),DIDFT_BUTTON|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,0 },
+    { NULL,DIJOFS_BUTTON(4),DIDFT_BUTTON|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,0 },
+    { NULL,DIJOFS_BUTTON(5),DIDFT_BUTTON|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,0 },
+    { NULL,DIJOFS_BUTTON(6),DIDFT_BUTTON|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,0 },
+    { NULL,DIJOFS_BUTTON(7),DIDFT_BUTTON|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,0 },
+    { NULL,DIJOFS_BUTTON(8),DIDFT_BUTTON|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,0 },
+    { NULL,DIJOFS_BUTTON(9),DIDFT_BUTTON|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,0 },
+    { NULL,DIJOFS_BUTTON(10),DIDFT_BUTTON|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,0 },
+    { NULL,DIJOFS_BUTTON(11),DIDFT_BUTTON|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,0 },
+    { NULL,DIJOFS_BUTTON(12),DIDFT_BUTTON|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,0 },
+    { NULL,DIJOFS_BUTTON(13),DIDFT_BUTTON|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,0 },
+    { NULL,DIJOFS_BUTTON(14),DIDFT_BUTTON|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,0 },
+    { NULL,DIJOFS_BUTTON(15),DIDFT_BUTTON|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,0 },
+    { NULL,DIJOFS_BUTTON(16),DIDFT_BUTTON|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,0 },
+    { NULL,DIJOFS_BUTTON(17),DIDFT_BUTTON|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,0 },
+    { NULL,DIJOFS_BUTTON(18),DIDFT_BUTTON|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,0 },
+    { NULL,DIJOFS_BUTTON(19),DIDFT_BUTTON|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,0 },
+    { NULL,DIJOFS_BUTTON(20),DIDFT_BUTTON|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,0 },
+    { NULL,DIJOFS_BUTTON(21),DIDFT_BUTTON|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,0 },
+    { NULL,DIJOFS_BUTTON(22),DIDFT_BUTTON|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,0 },
+    { NULL,DIJOFS_BUTTON(23),DIDFT_BUTTON|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,0 },
+    { NULL,DIJOFS_BUTTON(24),DIDFT_BUTTON|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,0 },
+    { NULL,DIJOFS_BUTTON(25),DIDFT_BUTTON|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,0 },
+    { NULL,DIJOFS_BUTTON(26),DIDFT_BUTTON|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,0 },
+    { NULL,DIJOFS_BUTTON(27),DIDFT_BUTTON|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,0 },
+    { NULL,DIJOFS_BUTTON(28),DIDFT_BUTTON|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,0 },
+    { NULL,DIJOFS_BUTTON(29),DIDFT_BUTTON|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,0 },
+    { NULL,DIJOFS_BUTTON(30),DIDFT_BUTTON|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,0 },
+    { NULL,DIJOFS_BUTTON(31),DIDFT_BUTTON|DIDFT_OPTIONAL|DIDFT_ANYINSTANCE,0 },
+};
+
+// Our clone of c_dfDIJoystick
+//
+static const DIDATAFORMAT _glfwDataFormat =
+{
+    sizeof(DIDATAFORMAT),
+    sizeof(DIOBJECTDATAFORMAT),
+    DIDFT_ABSAXIS,
+    sizeof(DIJOYSTATE),
+    sizeof(_glfwObjectDataFormats) / sizeof(DIOBJECTDATAFORMAT),
+    _glfwObjectDataFormats
+};
+
+// Returns a description fitting the specified XInput capabilities
+//
+static const char* getDeviceDescription(const XINPUT_CAPABILITIES* xic)
+{
+    switch (xic->SubType)
+    {
+        case XINPUT_DEVSUBTYPE_WHEEL:
+            return "XInput Wheel";
+        case XINPUT_DEVSUBTYPE_ARCADE_STICK:
+            return "XInput Arcade Stick";
+        case XINPUT_DEVSUBTYPE_FLIGHT_STICK:
+            return "XInput Flight Stick";
+        case XINPUT_DEVSUBTYPE_DANCE_PAD:
+            return "XInput Dance Pad";
+        case XINPUT_DEVSUBTYPE_GUITAR:
+            return "XInput Guitar";
+        case XINPUT_DEVSUBTYPE_DRUM_KIT:
+            return "XInput Drum Kit";
+        case XINPUT_DEVSUBTYPE_GAMEPAD:
+        {
+            if (xic->Flags & XINPUT_CAPS_WIRELESS)
+                return "Wireless Xbox 360 Controller";
+            else
+                return "Xbox 360 Controller";
+        }
+    }
+
+    return "Unknown XInput Device";
+}
+
+// Lexically compare device objects
+//
+static int compareJoystickObjects(const void* first, const void* second)
+{
+    const _GLFWjoyobjectWin32* fo = first;
+    const _GLFWjoyobjectWin32* so = second;
+
+    if (fo->type != so->type)
+        return fo->type - so->type;
+
+    return fo->offset - so->offset;
+}
+
+// Checks whether the specified device supports XInput
+// Technique from FDInputJoystickManager::IsXInputDeviceFast in ZDoom
+//
+static GLFWbool supportsXInput(const GUID* guid)
+{
+    UINT i, count;
+    RAWINPUTDEVICELIST* ridl;
+    GLFWbool result = GLFW_FALSE;
+
+    if (GetRawInputDeviceList(NULL, &count, sizeof(RAWINPUTDEVICELIST)) != 0)
+        return GLFW_FALSE;
+
+    ridl = calloc(count, sizeof(RAWINPUTDEVICELIST));
+
+    if (GetRawInputDeviceList(ridl, &count, sizeof(RAWINPUTDEVICELIST)) == -1)
+    {
+        free(ridl);
+        return GLFW_FALSE;
+    }
+
+    for (i = 0;  i < count;  i++)
+    {
+        RID_DEVICE_INFO rdi;
+        char name[256];
+        UINT size;
+
+        if (ridl[i].dwType != RIM_TYPEHID)
+            continue;
+
+        ZeroMemory(&rdi, sizeof(rdi));
+        rdi.cbSize = sizeof(rdi);
+        size = sizeof(rdi);
+
+        if ((INT) GetRawInputDeviceInfoA(ridl[i].hDevice,
+                                         RIDI_DEVICEINFO,
+                                         &rdi, &size) == -1)
+        {
+            continue;
+        }
+
+        if (MAKELONG(rdi.hid.dwVendorId, rdi.hid.dwProductId) != guid->Data1)
+            continue;
+
+        memset(name, 0, sizeof(name));
+        size = sizeof(name);
+
+        if ((INT) GetRawInputDeviceInfoA(ridl[i].hDevice,
+                                         RIDI_DEVICENAME,
+                                         name, &size) == -1)
+        {
+            break;
+        }
+
+        name[sizeof(name) - 1] = '\0';
+        if (strstr(name, "IG_"))
+        {
+            result = GLFW_TRUE;
+            break;
+        }
+    }
+
+    free(ridl);
+    return result;
+}
+
+// Frees all resources associated with the specified joystick
+//
+static void closeJoystick(_GLFWjoystickWin32* js)
+{
+    if (js->device)
+    {
+        IDirectInputDevice8_Unacquire(js->device);
+        IDirectInputDevice8_Release(js->device);
+    }
+
+    free(js->name);
+    free(js->axes);
+    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
+//
+static BOOL CALLBACK deviceObjectCallback(const DIDEVICEOBJECTINSTANCEW* doi,
+                                          void* user)
+{
+    _GLFWobjenumWin32* data = user;
+    _GLFWjoyobjectWin32* object = data->objects + data->objectCount;
+
+    if (DIDFT_GETTYPE(doi->dwType) & DIDFT_AXIS)
+    {
+        DIPROPRANGE dipr;
+
+        if (memcmp(&doi->guidType, &GUID_Slider, sizeof(GUID)) == 0)
+            object->offset = DIJOFS_SLIDER(data->sliderCount);
+        else if (memcmp(&doi->guidType, &GUID_XAxis, sizeof(GUID)) == 0)
+            object->offset = DIJOFS_X;
+        else if (memcmp(&doi->guidType, &GUID_YAxis, sizeof(GUID)) == 0)
+            object->offset = DIJOFS_Y;
+        else if (memcmp(&doi->guidType, &GUID_ZAxis, sizeof(GUID)) == 0)
+            object->offset = DIJOFS_Z;
+        else if (memcmp(&doi->guidType, &GUID_RxAxis, sizeof(GUID)) == 0)
+            object->offset = DIJOFS_RX;
+        else if (memcmp(&doi->guidType, &GUID_RyAxis, sizeof(GUID)) == 0)
+            object->offset = DIJOFS_RY;
+        else if (memcmp(&doi->guidType, &GUID_RzAxis, sizeof(GUID)) == 0)
+            object->offset = DIJOFS_RZ;
+        else
+            return DIENUM_CONTINUE;
+
+        ZeroMemory(&dipr, sizeof(dipr));
+        dipr.diph.dwSize = sizeof(dipr);
+        dipr.diph.dwHeaderSize = sizeof(dipr.diph);
+        dipr.diph.dwObj = doi->dwType;
+        dipr.diph.dwHow = DIPH_BYID;
+        dipr.lMin = -32768;
+        dipr.lMax =  32767;
+
+        if (FAILED(IDirectInputDevice8_SetProperty(data->device,
+                                                   DIPROP_RANGE,
+                                                   &dipr.diph)))
+        {
+            return DIENUM_CONTINUE;
+        }
+
+        if (memcmp(&doi->guidType, &GUID_Slider, sizeof(GUID)) == 0)
+        {
+            object->type = _GLFW_TYPE_SLIDER;
+            data->sliderCount++;
+        }
+        else
+        {
+            object->type = _GLFW_TYPE_AXIS;
+            data->axisCount++;
+        }
+    }
+    else if (DIDFT_GETTYPE(doi->dwType) & DIDFT_BUTTON)
+    {
+        object->offset = DIJOFS_BUTTON(data->buttonCount);
+        object->type = _GLFW_TYPE_BUTTON;
+        data->buttonCount++;
+    }
+    else if (DIDFT_GETTYPE(doi->dwType) & DIDFT_POV)
+    {
+        object->offset = DIJOFS_POV(data->povCount);
+        object->type = _GLFW_TYPE_POV;
+        data->povCount++;
+    }
+
+    data->objectCount++;
+    return DIENUM_CONTINUE;
+}
+
+// DirectInput device enumeration callback
+//
+static BOOL CALLBACK deviceCallback(const DIDEVICEINSTANCE* di, void* user)
+{
+    int joy = 0;
+    DIDEVCAPS dc;
+    DIPROPDWORD dipd;
+    IDirectInputDevice8* device;
+    _GLFWobjenumWin32 data;
+    _GLFWjoystickWin32* js;
+
+    for (joy = GLFW_JOYSTICK_1;  joy <= GLFW_JOYSTICK_LAST;  joy++)
+    {
+        if (memcmp(&_glfw.win32_js[joy].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;
+
+    if (FAILED(IDirectInput8_CreateDevice(_glfw.win32.dinput8.api,
+                                          &di->guidInstance,
+                                          &device,
+                                          NULL)))
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR, "DI: Failed to create device");
+        return DIENUM_CONTINUE;
+    }
+
+    if (FAILED(IDirectInputDevice8_SetDataFormat(device, &_glfwDataFormat)))
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "DI: Failed to set device data format");
+
+        IDirectInputDevice8_Release(device);
+        return DIENUM_CONTINUE;
+    }
+
+    ZeroMemory(&dc, sizeof(dc));
+    dc.dwSize = sizeof(dc);
+
+    if (FAILED(IDirectInputDevice8_GetCapabilities(device, &dc)))
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "DI: Failed to query device capabilities");
+
+        IDirectInputDevice8_Release(device);
+        return DIENUM_CONTINUE;
+    }
+
+    ZeroMemory(&dipd, sizeof(dipd));
+    dipd.diph.dwSize = sizeof(dipd);
+    dipd.diph.dwHeaderSize = sizeof(dipd.diph);
+    dipd.diph.dwHow = DIPH_DEVICE;
+    dipd.dwData = DIPROPAXISMODE_ABS;
+
+    if (FAILED(IDirectInputDevice8_SetProperty(device,
+                                               DIPROP_AXISMODE,
+                                               &dipd.diph)))
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "DI: Failed to set device axis mode");
+
+        IDirectInputDevice8_Release(device);
+        return DIENUM_CONTINUE;
+    }
+
+    memset(&data, 0, sizeof(data));
+    data.device = device;
+    data.objects = calloc(dc.dwAxes + dc.dwButtons + dc.dwPOVs,
+                          sizeof(_GLFWjoyobjectWin32));
+
+    if (FAILED(IDirectInputDevice8_EnumObjects(device,
+                                               deviceObjectCallback,
+                                               &data,
+                                               DIDFT_AXIS | DIDFT_BUTTON | DIDFT_POV)))
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "DI: Failed to enumerate device objects");
+
+        IDirectInputDevice8_Release(device);
+        free(data.objects);
+        return DIENUM_CONTINUE;
+    }
+
+    qsort(data.objects, data.objectCount,
+          sizeof(_GLFWjoyobjectWin32),
+          compareJoystickObjects);
+
+    js = _glfw.win32_js + joy;
+    js->device = device;
+    js->guid = di->guidInstance;
+    js->axisCount = data.axisCount + data.sliderCount;
+    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 &&
+            _glfw.win32_js[joy].device == NULL &&
+            _glfw.win32_js[joy].index == index)
+        {
+            return GLFW_FALSE;
+        }
+    }
+
+    for (joy = GLFW_JOYSTICK_1;  joy <= GLFW_JOYSTICK_LAST;  joy++)
+    {
+        if (!_glfw.win32_js[joy].present)
+            break;
+    }
+
+    if (joy > GLFW_JOYSTICK_LAST)
+        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;
+        DWORD result;
+        XINPUT_STATE xis;
+        const WORD buttons[14] =
+        {
+            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;
+    }
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW internal API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+// Initialize joystick interface
+//
+void _glfwInitJoysticksWin32(void)
+{
+    if (_glfw.win32.dinput8.instance)
+    {
+        if (FAILED(_glfw_DirectInput8Create(GetModuleHandle(NULL),
+                                            DIRECTINPUT_VERSION,
+                                            &IID_IDirectInput8W,
+                                            (void**) &_glfw.win32.dinput8.api,
+                                            NULL)))
+        {
+            _glfwInputError(GLFW_PLATFORM_ERROR,
+                            "DI: Failed to create interface");
+        }
+    }
+
+    _glfwDetectJoystickConnectionWin32();
+}
+
+// Close all opened joystick handles
+//
+void _glfwTerminateJoysticksWin32(void)
+{
+    int joy;
+
+    for (joy = GLFW_JOYSTICK_1;  joy <= GLFW_JOYSTICK_LAST;  joy++)
+        closeJoystick(_glfw.win32_js + joy);
+
+    if (_glfw.win32.dinput8.api)
+        IDirectInput8_Release(_glfw.win32.dinput8.api);
+}
+
+// Checks for new joysticks after DBT_DEVICEARRIVAL
+//
+void _glfwDetectJoystickConnectionWin32(void)
+{
+    if (_glfw.win32.xinput.instance)
+    {
+        DWORD i;
+
+        for (i = 0;  i < XUSER_MAX_COUNT;  i++)
+            openXinputDevice(i);
+    }
+
+    if (_glfw.win32.dinput8.api)
+    {
+        if (FAILED(IDirectInput8_EnumDevices(_glfw.win32.dinput8.api,
+                                             DI8DEVCLASS_GAMECTRL,
+                                             deviceCallback,
+                                             NULL,
+                                             DIEDFL_ALLDEVICES)))
+        {
+            _glfwInputError(GLFW_PLATFORM_ERROR,
+                            "Failed to enumerate DirectInput8 devices");
+            return;
+        }
+    }
+}
+
+// Checks for joystick disconnection after DBT_DEVICEREMOVECOMPLETE
+//
+void _glfwDetectJoystickDisconnectionWin32(void)
+{
+    int joy;
+
+    for (joy = GLFW_JOYSTICK_1;  joy <= GLFW_JOYSTICK_LAST;  joy++)
+        pollJoystickState(_glfw.win32_js + joy, _GLFW_PRESENCE_ONLY);
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW platform API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+int _glfwPlatformJoystickPresent(int joy)
+{
+    _GLFWjoystickWin32* js = _glfw.win32_js + joy;
+    return pollJoystickState(js, _GLFW_PRESENCE_ONLY);
+}
+
+const float* _glfwPlatformGetJoystickAxes(int joy, int* count)
+{
+    _GLFWjoystickWin32* js = _glfw.win32_js + joy;
+    if (!pollJoystickState(js, _GLFW_UPDATE_STATE))
+        return NULL;
+
+    *count = js->axisCount;
+    return js->axes;
+}
+
+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;
+}
+

src/win32_joystick.h

@@ -1,7 +1,7 @@
 //========================================================================
-// GLFW 3.1 WinMM - www.glfw.org
+// GLFW 3.2 Win32 - www.glfw.org
 //------------------------------------------------------------------------
-// Copyright (c) 2006-2014 Camilla Berglund <elmindreda@elmindreda.org>
+// Copyright (c) 2006-2016 Camilla Berglund <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,24 +24,41 @@
 //
 //========================================================================
 
-#ifndef _glfw3_winmm_joystick_h_
-#define _glfw3_winmm_joystick_h_
+#ifndef _glfw3_win32_joystick_h_
+#define _glfw3_win32_joystick_h_
 
 #define _GLFW_PLATFORM_LIBRARY_JOYSTICK_STATE \
-    _GLFWjoystickWinMM winmm_js[GLFW_JOYSTICK_LAST + 1]
+    _GLFWjoystickWin32 win32_js[GLFW_JOYSTICK_LAST + 1]
 
-
-// WinMM-specific per-joystick data
+// Spoo
 //
-typedef struct _GLFWjoystickWinMM
+typedef struct _GLFWjoyobjectWin32
 {
-    float           axes[6];
-    unsigned char   buttons[36]; // 32 buttons plus one hat
-    char*           name;
-} _GLFWjoystickWinMM;
+    int                     offset;
+    int                     type;
+} _GLFWjoyobjectWin32;
+
+// Win32-specific per-joystick data
+//
+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;
+} _GLFWjoystickWin32;
 
 
-void _glfwInitJoysticks(void);
-void _glfwTerminateJoysticks(void);
+void _glfwInitJoysticksWin32(void);
+void _glfwTerminateJoysticksWin32(void);
+void _glfwDetectJoystickConnectionWin32(void);
+void _glfwDetectJoystickDisconnectionWin32(void);
 
-#endif // _glfw3_winmm_joystick_h_
+#endif // _glfw3_win32_joystick_h_

src/win32_monitor.c

@@ -1,8 +1,8 @@
 //========================================================================
-// GLFW 3.1 Win32 - www.glfw.org
+// GLFW 3.2 Win32 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
+// Copyright (c) 2006-2016 Camilla Berglund <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,13 +32,58 @@
 #include <limits.h>
 #include <malloc.h>
 
-// These constants are missing on MinGW
-#ifndef EDS_ROTATEDMODE
- #define EDS_ROTATEDMODE 0x00000004
-#endif
-#ifndef DISPLAY_DEVICE_ACTIVE
- #define DISPLAY_DEVICE_ACTIVE 0x00000001
-#endif
+
+// Create monitor from an adapter and (optionally) a display
+//
+static _GLFWmonitor* createMonitor(DISPLAY_DEVICEW* adapter,
+                                   DISPLAY_DEVICEW* display)
+{
+    _GLFWmonitor* monitor;
+    char* name;
+    HDC dc;
+
+    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;
+    }
+
+    dc = CreateDCW(L"DISPLAY", adapter->DeviceName, NULL, NULL);
+
+    monitor = _glfwAllocMonitor(name,
+                                GetDeviceCaps(dc, HORZSIZE),
+                                GetDeviceCaps(dc, VERTSIZE));
+
+    DeleteDC(dc);
+    free(name);
+
+    if (adapter->StateFlags & DISPLAY_DEVICE_MODESPRUNED)
+        monitor->win32.modesPruned = GLFW_TRUE;
+
+    wcscpy(monitor->win32.adapterName, adapter->DeviceName);
+    WideCharToMultiByte(CP_UTF8, 0,
+                        adapter->DeviceName, -1,
+                        monitor->win32.publicAdapterName,
+                        sizeof(monitor->win32.publicAdapterName),
+                        NULL, NULL);
+
+    if (display)
+    {
+        wcscpy(monitor->win32.displayName, display->DeviceName);
+        WideCharToMultiByte(CP_UTF8, 0,
+                            display->DeviceName, -1,
+                            monitor->win32.publicDisplayName,
+                            sizeof(monitor->win32.publicDisplayName),
+                            NULL, NULL);
+    }
+
+    return monitor;
+}
 
 
 //////////////////////////////////////////////////////////////////////////
@@ -47,7 +92,7 @@
 
 // Change the current video mode
 //
-GLboolean _glfwSetVideoMode(_GLFWmonitor* monitor, const GLFWvidmode* desired)
+GLFWbool _glfwSetVideoModeWin32(_GLFWmonitor* monitor, const GLFWvidmode* desired)
 {
     GLFWvidmode current;
     const GLFWvidmode* best;
@@ -56,7 +101,7 @@ GLboolean _glfwSetVideoMode(_GLFWmonitor* monitor, const GLFWvidmode* desired)
     best = _glfwChooseVideoMode(monitor, desired);
     _glfwPlatformGetVideoMode(monitor, &current);
     if (_glfwCompareVideoModes(&current, best) == 0)
-        return GL_TRUE;
+        return GLFW_TRUE;
 
     ZeroMemory(&dm, sizeof(dm));
     dm.dmSize = sizeof(DEVMODEW);
@@ -77,22 +122,22 @@ GLboolean _glfwSetVideoMode(_GLFWmonitor* monitor, const GLFWvidmode* desired)
                                  NULL) != DISP_CHANGE_SUCCESSFUL)
     {
         _glfwInputError(GLFW_PLATFORM_ERROR, "Win32: Failed to set video mode");
-        return GL_FALSE;
+        return GLFW_FALSE;
     }
 
-    monitor->win32.modeChanged = GL_TRUE;
-    return GL_TRUE;
+    monitor->win32.modeChanged = GLFW_TRUE;
+    return GLFW_TRUE;
 }
 
 // Restore the previously saved (original) video mode
 //
-void _glfwRestoreVideoMode(_GLFWmonitor* monitor)
+void _glfwRestoreVideoModeWin32(_GLFWmonitor* monitor)
 {
     if (monitor->win32.modeChanged)
     {
         ChangeDisplaySettingsExW(monitor->win32.adapterName,
                                  NULL, NULL, CDS_FULLSCREEN, NULL);
-        monitor->win32.modeChanged = GL_FALSE;
+        monitor->win32.modeChanged = GLFW_FALSE;
     }
 }
 
@@ -104,15 +149,18 @@ void _glfwRestoreVideoMode(_GLFWmonitor* monitor)
 _GLFWmonitor** _glfwPlatformGetMonitors(int* count)
 {
     int found = 0;
+    DWORD adapterIndex, displayIndex, primaryIndex = 0;
+    DISPLAY_DEVICEW adapter, display;
+    GLFWbool hasDisplays = GLFW_FALSE;
     _GLFWmonitor** monitors = NULL;
-    DWORD adapterIndex, displayIndex;
 
     *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++)
     {
-        DISPLAY_DEVICEW adapter;
-
         ZeroMemory(&adapter, sizeof(DISPLAY_DEVICEW));
         adapter.cb = sizeof(DISPLAY_DEVICEW);
 
@@ -122,73 +170,65 @@ _GLFWmonitor** _glfwPlatformGetMonitors(int* count)
         if (!(adapter.StateFlags & DISPLAY_DEVICE_ACTIVE))
             continue;
 
-        for (displayIndex = 0;  ;  displayIndex++)
+        ZeroMemory(&display, sizeof(DISPLAY_DEVICEW));
+        display.cb = sizeof(DISPLAY_DEVICEW);
+
+        if (EnumDisplayDevicesW(adapter.DeviceName, 0, &display, 0))
         {
-            DISPLAY_DEVICEW display;
-            _GLFWmonitor* monitor;
-            char* name;
-            HDC dc;
-
-            ZeroMemory(&display, sizeof(DISPLAY_DEVICEW));
-            display.cb = sizeof(DISPLAY_DEVICEW);
-
-            if (!EnumDisplayDevicesW(adapter.DeviceName, displayIndex, &display, 0))
-                break;
-
-            name = _glfwCreateUTF8FromWideString(display.DeviceString);
-            if (!name)
-            {
-                _glfwInputError(GLFW_PLATFORM_ERROR,
-                                "Win32: Failed to convert string to UTF-8");
-                continue;
-            }
-
-            dc = CreateDCW(L"DISPLAY", adapter.DeviceName, NULL, NULL);
-
-            monitor = _glfwAllocMonitor(name,
-                                        GetDeviceCaps(dc, HORZSIZE),
-                                        GetDeviceCaps(dc, VERTSIZE));
-
-            DeleteDC(dc);
-            free(name);
-
-            if (adapter.StateFlags & DISPLAY_DEVICE_MODESPRUNED)
-                monitor->win32.modesPruned = GL_TRUE;
-
-            wcscpy(monitor->win32.adapterName, adapter.DeviceName);
-            wcscpy(monitor->win32.displayName, display.DeviceName);
-
-            WideCharToMultiByte(CP_UTF8, 0,
-                                adapter.DeviceName, -1,
-                                monitor->win32.publicAdapterName,
-                                sizeof(monitor->win32.publicAdapterName),
-                                NULL, NULL);
-
-            WideCharToMultiByte(CP_UTF8, 0,
-                                display.DeviceName, -1,
-                                monitor->win32.publicDisplayName,
-                                sizeof(monitor->win32.publicDisplayName),
-                                NULL, NULL);
-
-            found++;
-            monitors = realloc(monitors, sizeof(_GLFWmonitor*) * found);
-            monitors[found - 1] = monitor;
-
-            if (adapter.StateFlags & DISPLAY_DEVICE_PRIMARY_DEVICE &&
-                displayIndex == 0)
-            {
-                _GLFW_SWAP_POINTERS(monitors[0], monitors[found - 1]);
-            }
+            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;
 }
 
-GLboolean _glfwPlatformIsSameMonitor(_GLFWmonitor* first, _GLFWmonitor* second)
+GLFWbool _glfwPlatformIsSameMonitor(_GLFWmonitor* first, _GLFWmonitor* second)
 {
-    return wcscmp(first->win32.displayName, second->win32.displayName) == 0;
+    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)
@@ -266,11 +306,7 @@ GLFWvidmode* _glfwPlatformGetVideoModes(_GLFWmonitor* monitor, int* count)
 
         if (*count == size)
         {
-            if (*count)
-                size *= 2;
-            else
-                size = 128;
-
+            size += 128;
             result = (GLFWvidmode*) realloc(result, size * sizeof(GLFWvidmode));
         }
 
@@ -278,6 +314,14 @@ GLFWvidmode* _glfwPlatformGetVideoModes(_GLFWmonitor* monitor, int* count)
         result[*count - 1] = mode;
     }
 
+    if (!*count)
+    {
+        // HACK: Report the current mode if no valid modes were found
+        result = calloc(1, sizeof(GLFWvidmode));
+        _glfwPlatformGetVideoMode(monitor, result);
+        *count = 1;
+    }
+
     return result;
 }
 

src/win32_platform.h

@@ -1,8 +1,8 @@
 //========================================================================
-// GLFW 3.1 Win32 - www.glfw.org
+// GLFW 3.2 Win32 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
+// Copyright (c) 2006-2016 Camilla Berglund <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
@@ -61,8 +61,14 @@
  #define _WIN32_WINNT 0x0501
 #endif
 
+// GLFW uses DirectInput8 interfaces
+#define DIRECTINPUT_VERSION 0x0800
+
+#include <wctype.h>
 #include <windows.h>
 #include <mmsystem.h>
+#include <dinput.h>
+#include <xinput.h>
 #include <dbt.h>
 
 #if defined(_MSC_VER)
@@ -70,7 +76,7 @@
  #define strdup _strdup
 #endif
 
-// HACK: Define macros that some older windows.h variants don't
+// HACK: Define macros that some windows.h variants don't
 #ifndef WM_MOUSEHWHEEL
  #define WM_MOUSEHWHEEL 0x020E
 #endif
@@ -86,6 +92,18 @@
 #ifndef UNICODE_NOCHAR
  #define UNICODE_NOCHAR 0xFFFF
 #endif
+#ifndef WM_DPICHANGED
+ #define WM_DPICHANGED 0x02E0
+#endif
+#ifndef GET_XBUTTON_WPARAM
+ #define GET_XBUTTON_WPARAM(w) (HIWORD(w))
+#endif
+#ifndef EDS_ROTATEDMODE
+ #define EDS_ROTATEDMODE 0x00000004
+#endif
+#ifndef DISPLAY_DEVICE_ACTIVE
+ #define DISPLAY_DEVICE_ACTIVE 0x00000001
+#endif
 
 #if WINVER < 0x0601
 typedef struct tagCHANGEFILTERSTRUCT
@@ -99,16 +117,63 @@ typedef struct tagCHANGEFILTERSTRUCT
 #endif
 #endif /*Windows 7*/
 
+#ifndef DPI_ENUMS_DECLARED
+typedef enum PROCESS_DPI_AWARENESS
+{
+    PROCESS_DPI_UNAWARE = 0,
+    PROCESS_SYSTEM_DPI_AWARE = 1,
+    PROCESS_PER_MONITOR_DPI_AWARE = 2
+} PROCESS_DPI_AWARENESS;
+#endif /*DPI_ENUMS_DECLARED*/
+
+// HACK: Define macros that some xinput.h variants don't
+#ifndef XINPUT_CAPS_WIRELESS
+ #define XINPUT_CAPS_WIRELESS 0x0002
+#endif
+#ifndef XINPUT_DEVSUBTYPE_WHEEL
+ #define XINPUT_DEVSUBTYPE_WHEEL 0x02
+#endif
+#ifndef XINPUT_DEVSUBTYPE_ARCADE_STICK
+ #define XINPUT_DEVSUBTYPE_ARCADE_STICK 0x03
+#endif
+#ifndef XINPUT_DEVSUBTYPE_FLIGHT_STICK
+ #define XINPUT_DEVSUBTYPE_FLIGHT_STICK 0x04
+#endif
+#ifndef XINPUT_DEVSUBTYPE_DANCE_PAD
+ #define XINPUT_DEVSUBTYPE_DANCE_PAD 0x05
+#endif
+#ifndef XINPUT_DEVSUBTYPE_GUITAR
+ #define XINPUT_DEVSUBTYPE_GUITAR 0x06
+#endif
+#ifndef XINPUT_DEVSUBTYPE_DRUM_KIT
+ #define XINPUT_DEVSUBTYPE_DRUM_KIT 0x08
+#endif
+#ifndef XINPUT_DEVSUBTYPE_ARCADE_PAD
+ #define XINPUT_DEVSUBTYPE_ARCADE_PAD 0x13
+#endif
+#ifndef XUSER_MAX_COUNT
+ #define XUSER_MAX_COUNT 4
+#endif
+
+// HACK: Define macros that some dinput.h variants don't
+#ifndef DIDFT_OPTIONAL
+ #define DIDFT_OPTIONAL	0x80000000
+#endif
+
 // winmm.dll function pointer typedefs
-typedef MMRESULT (WINAPI * JOYGETDEVCAPS_T)(UINT,LPJOYCAPS,UINT);
-typedef MMRESULT (WINAPI * JOYGETPOS_T)(UINT,LPJOYINFO);
-typedef MMRESULT (WINAPI * JOYGETPOSEX_T)(UINT,LPJOYINFOEX);
 typedef DWORD (WINAPI * TIMEGETTIME_T)(void);
-#define _glfw_joyGetDevCaps _glfw.win32.winmm.joyGetDevCaps
-#define _glfw_joyGetPos _glfw.win32.winmm.joyGetPos
-#define _glfw_joyGetPosEx _glfw.win32.winmm.joyGetPosEx
 #define _glfw_timeGetTime _glfw.win32.winmm.timeGetTime
 
+// xinput.dll function pointer typedefs
+typedef DWORD (WINAPI * XINPUTGETCAPABILITIES_T)(DWORD,DWORD,XINPUT_CAPABILITIES*);
+typedef DWORD (WINAPI * XINPUTGETSTATE_T)(DWORD,XINPUT_STATE*);
+#define _glfw_XInputGetCapabilities _glfw.win32.xinput.XInputGetCapabilities
+#define _glfw_XInputGetState _glfw.win32.xinput.XInputGetState
+
+// dinput8.dll function pointer typedefs
+typedef HRESULT (WINAPI * DIRECTINPUT8CREATE_T)(HINSTANCE,DWORD,REFIID,LPVOID*,LPUNKNOWN);
+#define _glfw_DirectInput8Create _glfw.win32.dinput8.DirectInput8Create
+
 // user32.dll function pointer typedefs
 typedef BOOL (WINAPI * SETPROCESSDPIAWARE_T)(void);
 typedef BOOL (WINAPI * CHANGEWINDOWMESSAGEFILTEREX_T)(HWND,UINT,DWORD,PCHANGEFILTERSTRUCT);
@@ -121,26 +186,41 @@ typedef HRESULT (WINAPI * DWMFLUSH_T)(VOID);
 #define _glfw_DwmIsCompositionEnabled _glfw.win32.dwmapi.DwmIsCompositionEnabled
 #define _glfw_DwmFlush _glfw.win32.dwmapi.DwmFlush
 
-#define _GLFW_RECREATION_NOT_NEEDED 0
-#define _GLFW_RECREATION_REQUIRED   1
-#define _GLFW_RECREATION_IMPOSSIBLE 2
+// shcore.dll function pointer typedefs
+typedef HRESULT (WINAPI * SETPROCESSDPIAWARENESS_T)(PROCESS_DPI_AWARENESS);
+#define _glfw_SetProcessDpiAwareness _glfw.win32.shcore.SetProcessDpiAwareness
 
-#include "win32_tls.h"
-#include "winmm_joystick.h"
+typedef VkFlags VkWin32SurfaceCreateFlagsKHR;
 
-#if defined(_GLFW_WGL)
- #include "wgl_context.h"
-#elif defined(_GLFW_EGL)
- #define _GLFW_EGL_NATIVE_WINDOW  window->win32.handle
- #define _GLFW_EGL_NATIVE_DISPLAY EGL_DEFAULT_DISPLAY
- #include "egl_context.h"
-#else
- #error "No supported context creation API selected"
-#endif
+typedef struct VkWin32SurfaceCreateInfoKHR
+{
+    VkStructureType                 sType;
+    const void*                     pNext;
+    VkWin32SurfaceCreateFlagsKHR    flags;
+    HINSTANCE                       hinstance;
+    HWND                            hwnd;
+} VkWin32SurfaceCreateInfoKHR;
+
+typedef VkResult (APIENTRY *PFN_vkCreateWin32SurfaceKHR)(VkInstance,const VkWin32SurfaceCreateInfoKHR*,const VkAllocationCallbacks*,VkSurfaceKHR*);
+typedef VkBool32 (APIENTRY *PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR)(VkPhysicalDevice,uint32_t);
+
+#include "win32_joystick.h"
+#include "wgl_context.h"
+#include "egl_context.h"
+
+#define _GLFW_WNDCLASSNAME L"GLFW30"
+
+#define _glfw_dlopen(name) LoadLibraryA(name)
+#define _glfw_dlclose(handle) FreeLibrary((HMODULE) handle)
+#define _glfw_dlsym(handle, name) GetProcAddress((HMODULE) handle, name)
+
+#define _GLFW_EGL_NATIVE_WINDOW  ((EGLNativeWindowType) window->win32.handle)
+#define _GLFW_EGL_NATIVE_DISPLAY EGL_DEFAULT_DISPLAY
 
 #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_TLS_STATE    _GLFWtlsWin32     win32_tls
 #define _GLFW_PLATFORM_MONITOR_STATE        _GLFWmonitorWin32 win32
 #define _GLFW_PLATFORM_CURSOR_STATE         _GLFWcursorWin32  win32
 
@@ -150,12 +230,14 @@ typedef HRESULT (WINAPI * DWMFLUSH_T)(VOID);
 typedef struct _GLFWwindowWin32
 {
     HWND                handle;
+    HICON               bigIcon;
+    HICON               smallIcon;
 
-    GLboolean           cursorTracked;
-    GLboolean           iconified;
+    GLFWbool            cursorTracked;
+    GLFWbool            iconified;
 
     // The last received cursor position, regardless of source
-    int                 cursorPosX, cursorPosY;
+    int                 lastCursorPosX, lastCursorPosY;
 
 } _GLFWwindowWin32;
 
@@ -164,33 +246,51 @@ typedef struct _GLFWwindowWin32
 //
 typedef struct _GLFWlibraryWin32
 {
+    HWND                helperWindowHandle;
     DWORD               foregroundLockTimeout;
     char*               clipboardString;
+    char                keyName[64];
     short int           publicKeys[512];
+    short int           nativeKeys[GLFW_KEY_LAST + 1];
+    // Where to place the cursor when re-enabled
+    double              restoreCursorPosX, restoreCursorPosY;
+    // The window whose disabled cursor mode is active
+    _GLFWwindow*        disabledCursorWindow;
 
-    // winmm.dll
     struct {
         HINSTANCE       instance;
-        JOYGETDEVCAPS_T joyGetDevCaps;
-        JOYGETPOS_T     joyGetPos;
-        JOYGETPOSEX_T   joyGetPosEx;
         TIMEGETTIME_T   timeGetTime;
     } winmm;
 
-    // user32.dll
     struct {
-        HINSTANCE       instance;
-        SETPROCESSDPIAWARE_T SetProcessDPIAware;
+        HINSTANCE            instance;
+        DIRECTINPUT8CREATE_T DirectInput8Create;
+        IDirectInput8W*      api;
+    } dinput8;
+
+    struct {
+        HINSTANCE               instance;
+        XINPUTGETCAPABILITIES_T XInputGetCapabilities;
+        XINPUTGETSTATE_T        XInputGetState;
+    } xinput;
+
+    struct {
+        HINSTANCE                     instance;
+        SETPROCESSDPIAWARE_T          SetProcessDPIAware;
         CHANGEWINDOWMESSAGEFILTEREX_T ChangeWindowMessageFilterEx;
     } user32;
 
-    // dwmapi.dll
     struct {
         HINSTANCE       instance;
         DWMISCOMPOSITIONENABLED_T DwmIsCompositionEnabled;
         DWMFLUSH_T      DwmFlush;
     } dwmapi;
 
+    struct {
+        HINSTANCE       instance;
+        SETPROCESSDPIAWARENESS_T SetProcessDpiAwareness;
+    } shcore;
+
 } _GLFWlibraryWin32;
 
 
@@ -203,8 +303,8 @@ typedef struct _GLFWmonitorWin32
     WCHAR               displayName[32];
     char                publicAdapterName[64];
     char                publicDisplayName[64];
-    GLboolean           modesPruned;
-    GLboolean           modeChanged;
+    GLFWbool            modesPruned;
+    GLFWbool            modeChanged;
 
 } _GLFWmonitorWin32;
 
@@ -222,24 +322,34 @@ typedef struct _GLFWcursorWin32
 //
 typedef struct _GLFWtimeWin32
 {
-    GLboolean           hasPC;
-    double              resolution;
-    unsigned __int64    base;
+    GLFWbool            hasPC;
+    uint64_t            frequency;
 
 } _GLFWtimeWin32;
 
 
-GLboolean _glfwRegisterWindowClass(void);
-void _glfwUnregisterWindowClass(void);
+// Win32-specific global TLS data
+//
+typedef struct _GLFWtlsWin32
+{
+    GLFWbool        allocated;
+    DWORD           context;
 
-BOOL _glfwIsCompositionEnabled(void);
+} _GLFWtlsWin32;
 
-WCHAR* _glfwCreateWideStringFromUTF8(const char* source);
-char* _glfwCreateUTF8FromWideString(const WCHAR* source);
 
-void _glfwInitTimer(void);
+GLFWbool _glfwRegisterWindowClassWin32(void);
+void _glfwUnregisterWindowClassWin32(void);
 
-GLboolean _glfwSetVideoMode(_GLFWmonitor* monitor, const GLFWvidmode* desired);
-void _glfwRestoreVideoMode(_GLFWmonitor* monitor);
+GLFWbool _glfwInitThreadLocalStorageWin32(void);
+void _glfwTerminateThreadLocalStorageWin32(void);
+
+WCHAR* _glfwCreateWideStringFromUTF8Win32(const char* source);
+char* _glfwCreateUTF8FromWideStringWin32(const WCHAR* source);
+
+void _glfwInitTimerWin32(void);
+
+GLFWbool _glfwSetVideoModeWin32(_GLFWmonitor* monitor, const GLFWvidmode* desired);
+void _glfwRestoreVideoModeWin32(_GLFWmonitor* monitor);
 
 #endif // _glfw3_win32_platform_h_

src/win32_time.c

@@ -1,8 +1,8 @@
 //========================================================================
-// GLFW 3.1 Win32 - www.glfw.org
+// GLFW 3.2 Win32 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
+// Copyright (c) 2006-2016 Camilla Berglund <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,43 +28,26 @@
 #include "internal.h"
 
 
-// Return raw time
-//
-static unsigned __int64 getRawTime(void)
-{
-    if (_glfw.win32_time.hasPC)
-    {
-        unsigned __int64 time;
-        QueryPerformanceCounter((LARGE_INTEGER*) &time);
-        return time;
-    }
-    else
-        return (unsigned __int64) _glfw_timeGetTime();
-}
-
-
 //////////////////////////////////////////////////////////////////////////
 //////                       GLFW internal API                      //////
 //////////////////////////////////////////////////////////////////////////
 
 // Initialise timer
 //
-void _glfwInitTimer(void)
+void _glfwInitTimerWin32(void)
 {
-    unsigned __int64 frequency;
+    uint64_t frequency;
 
     if (QueryPerformanceFrequency((LARGE_INTEGER*) &frequency))
     {
-        _glfw.win32_time.hasPC = GL_TRUE;
-        _glfw.win32_time.resolution = 1.0 / (double) frequency;
+        _glfw.win32_time.hasPC = GLFW_TRUE;
+        _glfw.win32_time.frequency = frequency;
     }
     else
     {
-        _glfw.win32_time.hasPC = GL_FALSE;
-        _glfw.win32_time.resolution = 0.001; // winmm resolution is 1 ms
+        _glfw.win32_time.hasPC = GLFW_FALSE;
+        _glfw.win32_time.frequency = 1000;
     }
-
-    _glfw.win32_time.base = getRawTime();
 }
 
 
@@ -72,15 +55,20 @@ void _glfwInitTimer(void)
 //////                       GLFW platform API                      //////
 //////////////////////////////////////////////////////////////////////////
 
-double _glfwPlatformGetTime(void)
+uint64_t _glfwPlatformGetTimerValue(void)
 {
-    return (double) (getRawTime() - _glfw.win32_time.base) *
-        _glfw.win32_time.resolution;
+    if (_glfw.win32_time.hasPC)
+    {
+        uint64_t value;
+        QueryPerformanceCounter((LARGE_INTEGER*) &value);
+        return value;
+    }
+    else
+        return (uint64_t) _glfw_timeGetTime();
 }
 
-void _glfwPlatformSetTime(double time)
+uint64_t _glfwPlatformGetTimerFrequency(void)
 {
-    _glfw.win32_time.base = getRawTime() -
-        (unsigned __int64) (time / _glfw.win32_time.resolution);
+    return _glfw.win32_time.frequency;
 }
 

src/win32_tls.c

@@ -1,8 +1,8 @@
 //========================================================================
-// GLFW 3.1 Win32 - www.glfw.org
+// GLFW 3.2 Win32 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
+// Copyright (c) 2006-2016 Camilla Berglund <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,36 +32,36 @@
 //////                       GLFW internal API                      //////
 //////////////////////////////////////////////////////////////////////////
 
-int _glfwCreateContextTLS(void)
+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 GL_FALSE;
+        return GLFW_FALSE;
     }
 
-    _glfw.win32_tls.allocated = GL_TRUE;
-    return GL_TRUE;
+    _glfw.win32_tls.allocated = GLFW_TRUE;
+    return GLFW_TRUE;
 }
 
-void _glfwDestroyContextTLS(void)
+void _glfwTerminateThreadLocalStorageWin32(void)
 {
     if (_glfw.win32_tls.allocated)
         TlsFree(_glfw.win32_tls.context);
 }
 
-void _glfwSetContextTLS(_GLFWwindow* context)
-{
-    TlsSetValue(_glfw.win32_tls.context, context);
-}
-
 
 //////////////////////////////////////////////////////////////////////////
 //////                       GLFW platform API                      //////
 //////////////////////////////////////////////////////////////////////////
 
+void _glfwPlatformSetCurrentContext(_GLFWwindow* context)
+{
+    TlsSetValue(_glfw.win32_tls.context, context);
+}
+
 _GLFWwindow* _glfwPlatformGetCurrentContext(void)
 {
     return TlsGetValue(_glfw.win32_tls.context);

src/win32_tls.h

@@ -1,48 +0,0 @@
-//========================================================================
-// GLFW 3.1 Win32 - www.glfw.org
-//------------------------------------------------------------------------
-// Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.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.
-//
-//========================================================================
-
-#ifndef _glfw3_win32_tls_h_
-#define _glfw3_win32_tls_h_
-
-#define _GLFW_PLATFORM_LIBRARY_TLS_STATE _GLFWtlsWin32 win32_tls
-
-
-// Win32-specific global TLS data
-//
-typedef struct _GLFWtlsWin32
-{
-    GLboolean       allocated;
-    DWORD           context;
-
-} _GLFWtlsWin32;
-
-
-int _glfwCreateContextTLS(void);
-void _glfwDestroyContextTLS(void);
-void _glfwSetContextTLS(_GLFWwindow* context);
-
-#endif // _glfw3_win32_tls_h_