Added Box2D

external/Box2D-2.3.1/Box2D/glfw/clipboard.c

@@ -0,0 +1,50 @@
+//========================================================================
+// GLFW 3.0 - www.glfw.org
+//------------------------------------------------------------------------
+// Copyright (c) 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.
+//
+//========================================================================
+
+#include "internal.h"
+
+#include <math.h>
+#include <string.h>
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                        GLFW public API                       //////
+//////////////////////////////////////////////////////////////////////////
+
+GLFWAPI void glfwSetClipboardString(GLFWwindow* handle, const char* string)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    _GLFW_REQUIRE_INIT();
+    _glfwPlatformSetClipboardString(window, string);
+}
+
+GLFWAPI const char* glfwGetClipboardString(GLFWwindow* handle)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+    return _glfwPlatformGetClipboardString(window);
+}
+

external/Box2D-2.3.1/Box2D/glfw/cocoa_clipboard.m

@@ -0,0 +1,70 @@
+//========================================================================
+// GLFW 3.0 OS X - www.glfw.org
+//------------------------------------------------------------------------
+// Copyright (c) 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.
+//
+//========================================================================
+
+#include "internal.h"
+
+#include <limits.h>
+#include <string.h>
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW platform API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+void _glfwPlatformSetClipboardString(_GLFWwindow* window, const char* string)
+{
+    NSArray* types = [NSArray arrayWithObjects:NSStringPboardType, nil];
+
+    NSPasteboard* pasteboard = [NSPasteboard generalPasteboard];
+    [pasteboard declareTypes:types owner:nil];
+    [pasteboard setString:[NSString stringWithUTF8String:string]
+                  forType:NSStringPboardType];
+}
+
+const char* _glfwPlatformGetClipboardString(_GLFWwindow* window)
+{
+    NSPasteboard* pasteboard = [NSPasteboard generalPasteboard];
+
+    if (![[pasteboard types] containsObject:NSStringPboardType])
+    {
+        _glfwInputError(GLFW_FORMAT_UNAVAILABLE, NULL);
+        return NULL;
+    }
+
+    NSString* object = [pasteboard stringForType:NSStringPboardType];
+    if (!object)
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "Cocoa: Failed to retrieve object from pasteboard");
+        return NULL;
+    }
+
+    free(_glfw.ns.clipboardString);
+    _glfw.ns.clipboardString = strdup([object UTF8String]);
+
+    return _glfw.ns.clipboardString;
+}
+

external/Box2D-2.3.1/Box2D/glfw/cocoa_gamma.c

@@ -0,0 +1,84 @@
+//========================================================================
+// GLFW 3.0 OS X - www.glfw.org
+//------------------------------------------------------------------------
+// Copyright (c) 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.
+//
+//========================================================================
+
+#include "internal.h"
+
+#include <limits.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <ApplicationServices/ApplicationServices.h>
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW platform API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+void _glfwPlatformGetGammaRamp(_GLFWmonitor* monitor, GLFWgammaramp* ramp)
+{
+    uint32_t i, size = CGDisplayGammaTableCapacity(monitor->ns.displayID);
+    CGGammaValue* values = calloc(size * 3, sizeof(CGGammaValue));
+
+    CGGetDisplayTransferByTable(monitor->ns.displayID,
+                                size,
+                                values,
+                                values + size,
+                                values + size * 2,
+                                &size);
+
+    _glfwAllocGammaArrays(ramp, size);
+
+    for (i = 0; i < size; i++)
+    {
+        ramp->red[i]   = (unsigned short) (values[i] * 65535);
+        ramp->green[i] = (unsigned short) (values[i + size] * 65535);
+        ramp->blue[i]  = (unsigned short) (values[i + size * 2] * 65535);
+    }
+
+    free(values);
+}
+
+void _glfwPlatformSetGammaRamp(_GLFWmonitor* monitor, const GLFWgammaramp* ramp)
+{
+    int i;
+    CGGammaValue* values = calloc(ramp->size * 3, sizeof(CGGammaValue));
+
+    for (i = 0;  i < ramp->size;  i++)
+    {
+        values[i]                  = ramp->red[i] / 65535.f;
+        values[i + ramp->size]     = ramp->green[i] / 65535.f;
+        values[i + ramp->size * 2] = ramp->blue[i] / 65535.f;
+    }
+
+    CGSetDisplayTransferByTable(monitor->ns.displayID,
+                                ramp->size,
+                                values,
+                                values + ramp->size,
+                                values + ramp->size * 2);
+
+    free(values);
+}
+

external/Box2D-2.3.1/Box2D/glfw/cocoa_init.m

@@ -0,0 +1,142 @@
+//========================================================================
+// GLFW 3.0 OS X - www.glfw.org
+//------------------------------------------------------------------------
+// Copyright (c) 2009-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.
+//
+//========================================================================
+
+#include "internal.h"
+#include <sys/param.h> // For MAXPATHLEN
+
+
+#if defined(_GLFW_USE_CHDIR)
+
+// Change to our application bundle's resources directory, if present
+//
+static void changeToResourcesDirectory(void)
+{
+    char resourcesPath[MAXPATHLEN];
+
+    CFBundleRef bundle = CFBundleGetMainBundle();
+    if (!bundle)
+        return;
+
+    CFURLRef resourcesURL = CFBundleCopyResourcesDirectoryURL(bundle);
+
+    CFStringRef last = CFURLCopyLastPathComponent(resourcesURL);
+    if (CFStringCompare(CFSTR("Resources"), last, 0) != kCFCompareEqualTo)
+    {
+        CFRelease(last);
+        CFRelease(resourcesURL);
+        return;
+    }
+
+    CFRelease(last);
+
+    if (!CFURLGetFileSystemRepresentation(resourcesURL,
+                                          true,
+                                          (UInt8*) resourcesPath,
+                                          MAXPATHLEN))
+    {
+        CFRelease(resourcesURL);
+        return;
+    }
+
+    CFRelease(resourcesURL);
+
+    chdir(resourcesPath);
+}
+
+#endif /* _GLFW_USE_CHDIR */
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW platform API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+int _glfwPlatformInit(void)
+{
+    _glfw.ns.autoreleasePool = [[NSAutoreleasePool alloc] init];
+
+#if defined(_GLFW_USE_CHDIR)
+    changeToResourcesDirectory();
+#endif
+
+    _glfw.ns.eventSource = CGEventSourceCreate(kCGEventSourceStateHIDSystemState);
+    if (!_glfw.ns.eventSource)
+        return GL_FALSE;
+
+    CGEventSourceSetLocalEventsSuppressionInterval(_glfw.ns.eventSource, 0.0);
+
+    if (!_glfwInitContextAPI())
+        return GL_FALSE;
+
+    _glfwInitTimer();
+    _glfwInitJoysticks();
+
+    return GL_TRUE;
+}
+
+void _glfwPlatformTerminate(void)
+{
+    if (_glfw.ns.eventSource)
+    {
+        CFRelease(_glfw.ns.eventSource);
+        _glfw.ns.eventSource = NULL;
+    }
+
+    [NSApp setDelegate:nil];
+    [_glfw.ns.delegate release];
+    _glfw.ns.delegate = nil;
+
+    [_glfw.ns.autoreleasePool release];
+    _glfw.ns.autoreleasePool = nil;
+
+    [_glfw.ns.cursor release];
+    _glfw.ns.cursor = nil;
+
+    free(_glfw.ns.clipboardString);
+
+    _glfwTerminateJoysticks();
+    _glfwTerminateContextAPI();
+}
+
+const char* _glfwPlatformGetVersionString(void)
+{
+    const char* version = _GLFW_VERSION_FULL " Cocoa"
+#if defined(_GLFW_NSGL)
+        " NSGL"
+#endif
+#if defined(_GLFW_USE_CHDIR)
+        " chdir"
+#endif
+#if defined(_GLFW_USE_MENUBAR)
+        " menubar"
+#endif
+#if defined(_GLFW_BUILD_DLL)
+        " dynamic"
+#endif
+        ;
+
+    return version;
+}
+

external/Box2D-2.3.1/Box2D/glfw/cocoa_joystick.m

@@ -0,0 +1,496 @@
+//========================================================================
+// GLFW 3.0 OS X - www.glfw.org
+//------------------------------------------------------------------------
+// Copyright (c) 2009-2010 Camilla Berglund <elmindreda@elmindreda.org>
+// Copyright (c) 2012 Torsten Walluhn <tw@mad-cad.net>
+//
+// 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 <unistd.h>
+#include <ctype.h>
+
+#include <mach/mach.h>
+#include <mach/mach_error.h>
+
+#include <CoreFoundation/CoreFoundation.h>
+#include <Kernel/IOKit/hidsystem/IOHIDUsageTables.h>
+
+
+//------------------------------------------------------------------------
+// Joystick element information
+//------------------------------------------------------------------------
+typedef struct
+{
+    IOHIDElementCookie cookie;
+
+    long min;
+    long max;
+
+    long minReport;
+    long maxReport;
+
+} _GLFWjoyelement;
+
+
+static void getElementsCFArrayHandler(const void* value, void* parameter);
+
+
+// Adds an element to the specified joystick
+//
+static void addJoystickElement(_GLFWjoy* joystick, CFTypeRef elementRef)
+{
+    long elementType, usagePage, usage;
+    CFMutableArrayRef elementsArray = NULL;
+
+    CFNumberGetValue(CFDictionaryGetValue(elementRef, CFSTR(kIOHIDElementTypeKey)),
+                     kCFNumberLongType, &elementType);
+    CFNumberGetValue(CFDictionaryGetValue(elementRef, CFSTR(kIOHIDElementUsagePageKey)),
+                     kCFNumberLongType, &usagePage);
+    CFNumberGetValue(CFDictionaryGetValue(elementRef, CFSTR(kIOHIDElementUsageKey)),
+                     kCFNumberLongType, &usage);
+
+    if ((elementType == kIOHIDElementTypeInput_Axis) ||
+        (elementType == kIOHIDElementTypeInput_Button) ||
+        (elementType == kIOHIDElementTypeInput_Misc))
+    {
+        switch (usagePage)
+        {
+            case kHIDPage_GenericDesktop:
+            {
+                switch (usage)
+                {
+                    case kHIDUsage_GD_X:
+                    case kHIDUsage_GD_Y:
+                    case kHIDUsage_GD_Z:
+                    case kHIDUsage_GD_Rx:
+                    case kHIDUsage_GD_Ry:
+                    case kHIDUsage_GD_Rz:
+                    case kHIDUsage_GD_Slider:
+                    case kHIDUsage_GD_Dial:
+                    case kHIDUsage_GD_Wheel:
+                        elementsArray = joystick->axisElements;
+                        break;
+                    case kHIDUsage_GD_Hatswitch:
+                        elementsArray = joystick->hatElements;
+                        break;
+                }
+
+                break;
+            }
+
+            case kHIDPage_Button:
+                elementsArray = joystick->buttonElements;
+                break;
+            default:
+                break;
+        }
+
+        if (elementsArray)
+        {
+            long number;
+            CFTypeRef numberRef;
+            _GLFWjoyelement* element = calloc(1, sizeof(_GLFWjoyelement));
+
+            CFArrayAppendValue(elementsArray, element);
+
+            numberRef = CFDictionaryGetValue(elementRef, CFSTR(kIOHIDElementCookieKey));
+            if (numberRef && CFNumberGetValue(numberRef, kCFNumberLongType, &number))
+                element->cookie = (IOHIDElementCookie) number;
+
+            numberRef = CFDictionaryGetValue(elementRef, CFSTR(kIOHIDElementMinKey));
+            if (numberRef && CFNumberGetValue(numberRef, kCFNumberLongType, &number))
+                element->minReport = element->min = number;
+
+            numberRef = CFDictionaryGetValue(elementRef, CFSTR(kIOHIDElementMaxKey));
+            if (numberRef && CFNumberGetValue(numberRef, kCFNumberLongType, &number))
+                element->maxReport = element->max = number;
+        }
+    }
+    else
+    {
+        CFTypeRef array = CFDictionaryGetValue(elementRef, CFSTR(kIOHIDElementKey));
+        if (array)
+        {
+            if (CFGetTypeID(array) == CFArrayGetTypeID())
+            {
+                CFRange range = { 0, CFArrayGetCount(array) };
+                CFArrayApplyFunction(array, range, getElementsCFArrayHandler, joystick);
+            }
+        }
+    }
+}
+
+// Adds an element to the specified joystick
+//
+static void getElementsCFArrayHandler(const void* value, void* parameter)
+{
+    if (CFGetTypeID(value) == CFDictionaryGetTypeID())
+        addJoystickElement((_GLFWjoy*) parameter, (CFTypeRef) value);
+}
+
+// Returns the value of the specified element of the specified joystick
+//
+static long getElementValue(_GLFWjoy* joystick, _GLFWjoyelement* element)
+{
+    IOReturn result = kIOReturnSuccess;
+    IOHIDEventStruct hidEvent;
+    hidEvent.value = 0;
+
+    if (joystick && element && joystick->interface)
+    {
+        result = (*(joystick->interface))->getElementValue(joystick->interface,
+                                                           element->cookie,
+                                                           &hidEvent);
+        if (kIOReturnSuccess == result)
+        {
+            // Record min and max for auto calibration
+            if (hidEvent.value < element->minReport)
+                element->minReport = hidEvent.value;
+            if (hidEvent.value > element->maxReport)
+                element->maxReport = hidEvent.value;
+        }
+    }
+
+    // Auto user scale
+    return (long) hidEvent.value;
+}
+
+// Removes the specified joystick
+//
+static void removeJoystick(_GLFWjoy* joystick)
+{
+    int i;
+
+    if (!joystick->present)
+        return;
+
+    for (i = 0;  i < CFArrayGetCount(joystick->axisElements);  i++)
+        free((void*) CFArrayGetValueAtIndex(joystick->axisElements, i));
+    CFArrayRemoveAllValues(joystick->axisElements);
+
+    for (i = 0;  i < CFArrayGetCount(joystick->buttonElements);  i++)
+        free((void*) CFArrayGetValueAtIndex(joystick->buttonElements, i));
+    CFArrayRemoveAllValues(joystick->buttonElements);
+
+    for (i = 0;  i < CFArrayGetCount(joystick->hatElements);  i++)
+        free((void*) CFArrayGetValueAtIndex(joystick->hatElements, i));
+    CFArrayRemoveAllValues(joystick->hatElements);
+
+    free(joystick->axes);
+    free(joystick->buttons);
+
+    (*(joystick->interface))->close(joystick->interface);
+    (*(joystick->interface))->Release(joystick->interface);
+
+    memset(joystick, 0, sizeof(_GLFWjoy));
+}
+
+// Callback for user-initiated joystick removal
+//
+static void removalCallback(void* target, IOReturn result, void* refcon, void* sender)
+{
+    removeJoystick((_GLFWjoy*) refcon);
+}
+
+// Polls for joystick events and updates GLFW state
+//
+static void pollJoystickEvents(void)
+{
+    int joy;
+
+    for (joy = 0;  joy <= GLFW_JOYSTICK_LAST;  joy++)
+    {
+        CFIndex i;
+        int buttonIndex = 0;
+        _GLFWjoy* joystick = _glfw.ns.joysticks + joy;
+
+        if (!joystick->present)
+            continue;
+
+        for (i = 0;  i < CFArrayGetCount(joystick->buttonElements);  i++)
+        {
+            _GLFWjoyelement* button =
+                (_GLFWjoyelement*) CFArrayGetValueAtIndex(joystick->buttonElements, i);
+
+            if (getElementValue(joystick, button))
+                joystick->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;
+
+            if (i & 1)
+                joystick->axes[i] = -joystick->axes[i];
+        }
+
+        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;
+            }
+        }
+    }
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW internal API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+// Initialize joystick interface
+//
+void _glfwInitJoysticks(void)
+{
+    int joy = 0;
+    IOReturn result = kIOReturnSuccess;
+    mach_port_t masterPort = 0;
+    io_iterator_t objectIterator = 0;
+    CFMutableDictionaryRef hidMatchDictionary = NULL;
+    io_object_t ioHIDDeviceObject = 0;
+
+    result = IOMasterPort(bootstrap_port, &masterPort);
+    hidMatchDictionary = IOServiceMatching(kIOHIDDeviceKey);
+    if (kIOReturnSuccess != result || !hidMatchDictionary)
+    {
+        if (hidMatchDictionary)
+            CFRelease(hidMatchDictionary);
+
+        return;
+    }
+
+    result = IOServiceGetMatchingServices(masterPort,
+                                          hidMatchDictionary,
+                                          &objectIterator);
+    if (result != kIOReturnSuccess)
+        return;
+
+    if (!objectIterator)
+    {
+        // There are no joysticks
+        return;
+    }
+
+    while ((ioHIDDeviceObject = IOIteratorNext(objectIterator)))
+    {
+        kern_return_t result;
+        CFTypeRef valueRef = 0;
+
+        IOCFPlugInInterface** ppPlugInInterface = NULL;
+        HRESULT plugInResult = S_OK;
+        SInt32 score = 0;
+
+        long usagePage, usage;
+
+        // Check device type
+        valueRef = IORegistryEntryCreateCFProperty(ioHIDDeviceObject,
+                                                   CFSTR(kIOHIDPrimaryUsagePageKey),
+                                                   kCFAllocatorDefault,
+                                                   kNilOptions);
+        if (valueRef)
+        {
+            CFNumberGetValue(valueRef, kCFNumberLongType, &usagePage);
+            if (usagePage != kHIDPage_GenericDesktop)
+            {
+                // This device is not relevant to GLFW
+                continue;
+            }
+
+            CFRelease(valueRef);
+        }
+
+        valueRef = IORegistryEntryCreateCFProperty(ioHIDDeviceObject,
+                                                   CFSTR(kIOHIDPrimaryUsageKey),
+                                                   kCFAllocatorDefault,
+                                                   kNilOptions);
+        if (valueRef)
+        {
+            CFNumberGetValue(valueRef, kCFNumberLongType, &usage);
+
+            if ((usage != kHIDUsage_GD_Joystick &&
+                 usage != kHIDUsage_GD_GamePad &&
+                 usage != kHIDUsage_GD_MultiAxisController))
+            {
+                // This device is not relevant to GLFW
+                continue;
+            }
+
+            CFRelease(valueRef);
+        }
+
+        _GLFWjoy* joystick = _glfw.ns.joysticks + joy;
+        joystick->present = GL_TRUE;
+
+        result = IOCreatePlugInInterfaceForService(ioHIDDeviceObject,
+                                                   kIOHIDDeviceUserClientTypeID,
+                                                   kIOCFPlugInInterfaceID,
+                                                   &ppPlugInInterface,
+                                                   &score);
+
+        if (kIOReturnSuccess != result)
+            return;
+
+        plugInResult = (*ppPlugInInterface)->QueryInterface(
+                            ppPlugInInterface,
+                            CFUUIDGetUUIDBytes(kIOHIDDeviceInterfaceID),
+                            (void *) &(joystick->interface));
+
+        if (plugInResult != S_OK)
+            return;
+
+        (*ppPlugInInterface)->Release(ppPlugInInterface);
+
+        (*(joystick->interface))->open(joystick->interface, 0);
+        (*(joystick->interface))->setRemovalCallback(joystick->interface,
+                                                     removalCallback,
+                                                     joystick,
+                                                     joystick);
+
+        // Get product string
+        valueRef = IORegistryEntryCreateCFProperty(ioHIDDeviceObject,
+                                                   CFSTR(kIOHIDProductKey),
+                                                   kCFAllocatorDefault,
+                                                   kNilOptions);
+        if (valueRef)
+        {
+            CFStringGetCString(valueRef,
+                               joystick->name,
+                               sizeof(joystick->name),
+                               kCFStringEncodingUTF8);
+            CFRelease(valueRef);
+        }
+
+        joystick->axisElements = CFArrayCreateMutable(NULL, 0, NULL);
+        joystick->buttonElements = CFArrayCreateMutable(NULL, 0, NULL);
+        joystick->hatElements = CFArrayCreateMutable(NULL, 0, NULL);
+
+        valueRef = IORegistryEntryCreateCFProperty(ioHIDDeviceObject,
+                                                   CFSTR(kIOHIDElementKey),
+                                                   kCFAllocatorDefault,
+                                                   kNilOptions);
+        if (CFGetTypeID(valueRef) == CFArrayGetTypeID())
+        {
+            CFRange range = { 0, CFArrayGetCount(valueRef) };
+            CFArrayApplyFunction(valueRef,
+                                 range,
+                                 getElementsCFArrayHandler,
+                                 (void*) joystick);
+            CFRelease(valueRef);
+        }
+
+        joystick->axes = calloc(CFArrayGetCount(joystick->axisElements),
+                                         sizeof(float));
+        joystick->buttons = calloc(CFArrayGetCount(joystick->buttonElements) +
+                                   CFArrayGetCount(joystick->hatElements) * 4, 1);
+
+        joy++;
+        if (joy > GLFW_JOYSTICK_LAST)
+            break;
+    }
+}
+
+// Close all opened joystick handles
+//
+void _glfwTerminateJoysticks(void)
+{
+    int i;
+
+    for (i = 0;  i < GLFW_JOYSTICK_LAST + 1;  i++)
+    {
+        _GLFWjoy* joystick = &_glfw.ns.joysticks[i];
+        removeJoystick(joystick);
+    }
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW platform API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+int _glfwPlatformJoystickPresent(int joy)
+{
+    pollJoystickEvents();
+
+    return _glfw.ns.joysticks[joy].present;
+}
+
+const float* _glfwPlatformGetJoystickAxes(int joy, int* count)
+{
+    _GLFWjoy* joystick = _glfw.ns.joysticks + joy;
+
+    pollJoystickEvents();
+
+    if (!joystick->present)
+        return NULL;
+
+    *count = (int) CFArrayGetCount(joystick->axisElements);
+    return joystick->axes;
+}
+
+const unsigned char* _glfwPlatformGetJoystickButtons(int joy, int* count)
+{
+    _GLFWjoy* joystick = _glfw.ns.joysticks + joy;
+
+    pollJoystickEvents();
+
+    if (!joystick->present)
+        return NULL;
+
+    *count = (int) CFArrayGetCount(joystick->buttonElements) +
+             (int) CFArrayGetCount(joystick->hatElements) * 4;
+    return joystick->buttons;
+}
+
+const char* _glfwPlatformGetJoystickName(int joy)
+{
+    pollJoystickEvents();
+
+    return _glfw.ns.joysticks[joy].name;
+}
+

external/Box2D-2.3.1/Box2D/glfw/cocoa_monitor.m

@@ -0,0 +1,368 @@
+//========================================================================
+// GLFW 3.0 OS X - 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.
+//
+//========================================================================
+
+#include "internal.h"
+
+#include <stdlib.h>
+#include <limits.h>
+
+#include <IOKit/graphics/IOGraphicsLib.h>
+
+
+// Get the name of the specified display
+//
+static const char* getDisplayName(CGDirectDisplayID displayID)
+{
+    char* name;
+    CFDictionaryRef info, names;
+    CFStringRef value;
+    CFIndex size;
+
+    info = IODisplayCreateInfoDictionary(CGDisplayIOServicePort(displayID),
+                                         kIODisplayOnlyPreferredName);
+    names = CFDictionaryGetValue(info, CFSTR(kDisplayProductName));
+
+    if (!CFDictionaryGetValueIfPresent(names, CFSTR("en_US"),
+                                       (const void**) &value))
+    {
+        CFRelease(info);
+        return strdup("Unknown");
+    }
+
+    size = CFStringGetMaximumSizeForEncoding(CFStringGetLength(value),
+                                             kCFStringEncodingUTF8);
+    name = calloc(size + 1, sizeof(char));
+    CFStringGetCString(value, name, size, kCFStringEncodingUTF8);
+
+    CFRelease(info);
+
+    return name;
+}
+
+// Check whether the display mode should be included in enumeration
+//
+static GLboolean modeIsGood(CGDisplayModeRef mode)
+{
+    uint32_t flags = CGDisplayModeGetIOFlags(mode);
+    if (!(flags & kDisplayModeValidFlag) || !(flags & kDisplayModeSafeFlag))
+        return GL_FALSE;
+
+    if (flags & kDisplayModeInterlacedFlag)
+        return GL_FALSE;
+
+    if (flags & kDisplayModeTelevisionFlag)
+        return GL_FALSE;
+
+    if (flags & kDisplayModeStretchedFlag)
+        return GL_FALSE;
+
+    CFStringRef format = CGDisplayModeCopyPixelEncoding(mode);
+    if (CFStringCompare(format, CFSTR(IO16BitDirectPixels), 0) &&
+        CFStringCompare(format, CFSTR(IO32BitDirectPixels), 0))
+    {
+        CFRelease(format);
+        return GL_FALSE;
+    }
+
+    CFRelease(format);
+    return GL_TRUE;
+}
+
+// Convert Core Graphics display mode to GLFW video mode
+//
+static GLFWvidmode vidmodeFromCGDisplayMode(CGDisplayModeRef mode)
+{
+    GLFWvidmode result;
+    result.width = CGDisplayModeGetWidth(mode);
+    result.height = CGDisplayModeGetHeight(mode);
+    result.refreshRate = (int) CGDisplayModeGetRefreshRate(mode);
+
+    CFStringRef format = CGDisplayModeCopyPixelEncoding(mode);
+
+    if (CFStringCompare(format, CFSTR(IO16BitDirectPixels), 0) == 0)
+    {
+        result.redBits = 5;
+        result.greenBits = 5;
+        result.blueBits = 5;
+    }
+    else
+    {
+        result.redBits = 8;
+        result.greenBits = 8;
+        result.blueBits = 8;
+    }
+
+    CFRelease(format);
+    return result;
+}
+
+// Starts reservation for display fading
+//
+static CGDisplayFadeReservationToken beginFadeReservation(void)
+{
+    CGDisplayFadeReservationToken token = kCGDisplayFadeReservationInvalidToken;
+
+    if (CGAcquireDisplayFadeReservation(5, &token) == kCGErrorSuccess)
+        CGDisplayFade(token, 0.3, kCGDisplayBlendNormal, kCGDisplayBlendSolidColor, 0.0, 0.0, 0.0, TRUE);
+
+    return token;
+}
+
+// Ends reservation for display fading
+//
+static void endFadeReservation(CGDisplayFadeReservationToken token)
+{
+    if (token != kCGDisplayFadeReservationInvalidToken)
+    {
+        CGDisplayFade(token, 0.5, kCGDisplayBlendSolidColor, kCGDisplayBlendNormal, 0.0, 0.0, 0.0, FALSE);
+        CGReleaseDisplayFadeReservation(token);
+    }
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW internal API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+// Change the current video mode
+//
+GLboolean _glfwSetVideoMode(_GLFWmonitor* monitor, const GLFWvidmode* desired)
+{
+    CGDisplayModeRef bestMode = NULL;
+    CFArrayRef modes;
+    CFIndex count, i;
+    unsigned int sizeDiff, leastSizeDiff = UINT_MAX;
+    unsigned int rateDiff, leastRateDiff = UINT_MAX;
+    const int bpp = desired->redBits - desired->greenBits - desired->blueBits;
+
+    modes = CGDisplayCopyAllDisplayModes(monitor->ns.displayID, NULL);
+    count = CFArrayGetCount(modes);
+
+    for (i = 0;  i < count;  i++)
+    {
+        CGDisplayModeRef mode = (CGDisplayModeRef) CFArrayGetValueAtIndex(modes, i);
+        if (!modeIsGood(mode))
+            continue;
+
+        int modeBPP;
+
+        // Identify display mode pixel encoding
+        {
+            CFStringRef format = CGDisplayModeCopyPixelEncoding(mode);
+
+            if (CFStringCompare(format, CFSTR(IO16BitDirectPixels), 0) == 0)
+                modeBPP = 16;
+            else
+                modeBPP = 32;
+
+            CFRelease(format);
+        }
+
+        const int modeWidth = (int) CGDisplayModeGetWidth(mode);
+        const int modeHeight = (int) CGDisplayModeGetHeight(mode);
+        const int modeRate = (int) CGDisplayModeGetRefreshRate(mode);
+
+        sizeDiff = (abs(modeBPP - bpp) << 25) |
+                   ((modeWidth - desired->width) * (modeWidth - desired->width) +
+                    (modeHeight - desired->height) * (modeHeight - desired->height));
+
+        if (desired->refreshRate)
+            rateDiff = abs(modeRate - desired->refreshRate);
+        else
+            rateDiff = UINT_MAX - modeRate;
+
+        if ((sizeDiff < leastSizeDiff) ||
+            (sizeDiff == leastSizeDiff && rateDiff < leastRateDiff))
+        {
+            bestMode = mode;
+            leastSizeDiff = sizeDiff;
+            leastRateDiff = rateDiff;
+        }
+    }
+
+    if (!bestMode)
+    {
+        CFRelease(modes);
+        return GL_FALSE;
+    }
+
+    monitor->ns.previousMode = CGDisplayCopyDisplayMode(monitor->ns.displayID);
+
+    CGDisplayFadeReservationToken token = beginFadeReservation();
+
+    CGDisplayCapture(monitor->ns.displayID);
+    CGDisplaySetDisplayMode(monitor->ns.displayID, bestMode, NULL);
+
+    endFadeReservation(token);
+
+    CFRelease(modes);
+    return GL_TRUE;
+}
+
+// Restore the previously saved (original) video mode
+//
+void _glfwRestoreVideoMode(_GLFWmonitor* monitor)
+{
+    CGDisplayFadeReservationToken token = beginFadeReservation();
+
+    CGDisplaySetDisplayMode(monitor->ns.displayID, monitor->ns.previousMode, NULL);
+    CGDisplayRelease(monitor->ns.displayID);
+
+    endFadeReservation(token);
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW platform API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+_GLFWmonitor** _glfwPlatformGetMonitors(int* count)
+{
+    uint32_t i, found = 0, monitorCount;
+    _GLFWmonitor** monitors;
+    CGDirectDisplayID* displays;
+
+    *count = 0;
+
+    CGGetActiveDisplayList(0, NULL, &monitorCount);
+
+    displays = calloc(monitorCount, sizeof(CGDirectDisplayID));
+    monitors = calloc(monitorCount, sizeof(_GLFWmonitor*));
+
+    CGGetActiveDisplayList(monitorCount, displays, &monitorCount);
+
+    for (i = 0;  i < monitorCount;  i++)
+    {
+        const CGSize size = CGDisplayScreenSize(displays[i]);
+
+        monitors[found] = _glfwCreateMonitor(getDisplayName(displays[i]),
+                                             size.width, size.height);
+
+        monitors[found]->ns.displayID = displays[i];
+        found++;
+    }
+
+    free(displays);
+
+    for (i = 0;  i < monitorCount;  i++)
+    {
+        if (CGDisplayIsMain(monitors[i]->ns.displayID))
+        {
+            _GLFWmonitor* temp = monitors[0];
+            monitors[0] = monitors[i];
+            monitors[i] = temp;
+            break;
+        }
+    }
+
+    NSArray* screens = [NSScreen screens];
+
+    for (i = 0;  i < monitorCount;  i++)
+    {
+        int j;
+
+        for (j = 0;  j < [screens count];  j++)
+        {
+            NSScreen* screen = [screens objectAtIndex:j];
+            NSDictionary* dictionary = [screen deviceDescription];
+            NSNumber* number = [dictionary objectForKey:@"NSScreenNumber"];
+
+            if (monitors[i]->ns.displayID == [number unsignedIntegerValue])
+            {
+                monitors[i]->ns.screen = screen;
+                break;
+            }
+        }
+
+        if (monitors[i]->ns.screen == nil)
+        {
+            _glfwDestroyMonitors(monitors, monitorCount);
+            _glfwInputError(GLFW_PLATFORM_ERROR,
+                            "Cocoa: Failed to find NSScreen for CGDisplay %s",
+                            monitors[i]->name);
+
+            free(monitors);
+            return NULL;
+        }
+    }
+
+    *count = monitorCount;
+    return monitors;
+}
+
+GLboolean _glfwPlatformIsSameMonitor(_GLFWmonitor* first, _GLFWmonitor* second)
+{
+    return first->ns.displayID == second->ns.displayID;
+}
+
+void _glfwPlatformGetMonitorPos(_GLFWmonitor* monitor, int* xpos, int* ypos)
+{
+    const CGRect bounds = CGDisplayBounds(monitor->ns.displayID);
+
+    if (xpos)
+        *xpos = (int) bounds.origin.x;
+    if (ypos)
+        *ypos = (int) bounds.origin.y;
+}
+
+GLFWvidmode* _glfwPlatformGetVideoModes(_GLFWmonitor* monitor, int* found)
+{
+    CFArrayRef modes;
+    CFIndex count, i;
+    GLFWvidmode* result;
+
+    modes = CGDisplayCopyAllDisplayModes(monitor->ns.displayID, NULL);
+    count = CFArrayGetCount(modes);
+
+    result = calloc(count, sizeof(GLFWvidmode));
+    *found = 0;
+
+    for (i = 0;  i < count;  i++)
+    {
+        CGDisplayModeRef mode;
+
+        mode = (CGDisplayModeRef) CFArrayGetValueAtIndex(modes, i);
+        if (modeIsGood(mode))
+        {
+            result[*found] = vidmodeFromCGDisplayMode(mode);
+            (*found)++;
+        }
+    }
+
+    CFRelease(modes);
+    return result;
+}
+
+void _glfwPlatformGetVideoMode(_GLFWmonitor* monitor, GLFWvidmode *mode)
+{
+    CGDisplayModeRef displayMode;
+
+    displayMode = CGDisplayCopyDisplayMode(monitor->ns.displayID);
+    *mode = vidmodeFromCGDisplayMode(displayMode);
+    CGDisplayModeRelease(displayMode);
+}
+

external/Box2D-2.3.1/Box2D/glfw/cocoa_platform.h

@@ -0,0 +1,149 @@
+//========================================================================
+// GLFW 3.0 OS X - www.glfw.org
+//------------------------------------------------------------------------
+// Copyright (c) 2009-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 _cocoa_platform_h_
+#define _cocoa_platform_h_
+
+
+#include <stdint.h>
+
+#if defined(__OBJC__)
+#import <Cocoa/Cocoa.h>
+#else
+#include <ApplicationServices/ApplicationServices.h>
+typedef void* id;
+#endif
+
+#if defined(_GLFW_NSGL)
+ #include "nsgl_platform.h"
+#else
+ #error "No supported context creation API selected"
+#endif
+
+#include <IOKit/IOKitLib.h>
+#include <IOKit/IOCFPlugIn.h>
+#include <IOKit/hid/IOHIDLib.h>
+#include <IOKit/hid/IOHIDKeys.h>
+
+#define _GLFW_PLATFORM_WINDOW_STATE         _GLFWwindowNS  ns
+#define _GLFW_PLATFORM_LIBRARY_WINDOW_STATE _GLFWlibraryNS ns
+#define _GLFW_PLATFORM_MONITOR_STATE        _GLFWmonitorNS ns
+
+
+//========================================================================
+// GLFW platform specific types
+//========================================================================
+
+
+//------------------------------------------------------------------------
+// Platform-specific window structure
+//------------------------------------------------------------------------
+typedef struct _GLFWwindowNS
+{
+    id              object;
+    id	            delegate;
+    id              view;
+    unsigned int    modifierFlags;
+} _GLFWwindowNS;
+
+
+//------------------------------------------------------------------------
+// Joystick information & state
+//------------------------------------------------------------------------
+typedef struct
+{
+    int             present;
+    char            name[256];
+
+    IOHIDDeviceInterface** interface;
+
+    CFMutableArrayRef axisElements;
+    CFMutableArrayRef buttonElements;
+    CFMutableArrayRef hatElements;
+
+    float*          axes;
+    unsigned char*  buttons;
+
+} _GLFWjoy;
+
+
+//------------------------------------------------------------------------
+// Platform-specific library global data for Cocoa
+//------------------------------------------------------------------------
+typedef struct _GLFWlibraryNS
+{
+    struct {
+        double      base;
+        double      resolution;
+    } timer;
+
+    CGEventSourceRef eventSource;
+    id              delegate;
+    id              autoreleasePool;
+    id              cursor;
+
+    char*           clipboardString;
+
+    _GLFWjoy        joysticks[GLFW_JOYSTICK_LAST + 1];
+} _GLFWlibraryNS;
+
+
+//------------------------------------------------------------------------
+// Platform-specific monitor structure
+//------------------------------------------------------------------------
+typedef struct _GLFWmonitorNS
+{
+    CGDirectDisplayID   displayID;
+    CGDisplayModeRef    previousMode;
+    id                  screen;
+
+} _GLFWmonitorNS;
+
+
+//========================================================================
+// Prototypes for platform specific internal functions
+//========================================================================
+
+// Time
+void _glfwInitTimer(void);
+
+// Joystick input
+void _glfwInitJoysticks(void);
+void _glfwTerminateJoysticks(void);
+
+// Fullscreen
+GLboolean _glfwSetVideoMode(_GLFWmonitor* monitor, const GLFWvidmode* desired);
+void _glfwRestoreVideoMode(_GLFWmonitor* monitor);
+
+// OpenGL support
+int _glfwInitContextAPI(void);
+void _glfwTerminateContextAPI(void);
+int _glfwCreateContext(_GLFWwindow* window,
+                       const _GLFWwndconfig* wndconfig,
+                       const _GLFWfbconfig* fbconfig);
+void _glfwDestroyContext(_GLFWwindow* window);
+
+#endif // _cocoa_platform_h_

external/Box2D-2.3.1/Box2D/glfw/cocoa_time.c

@@ -0,0 +1,71 @@
+//========================================================================
+// GLFW 3.0 OS X - www.glfw.org
+//------------------------------------------------------------------------
+// Copyright (c) 2009-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.
+//
+//========================================================================
+
+#include "internal.h"
+
+#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)
+{
+    mach_timebase_info_data_t info;
+    mach_timebase_info(&info);
+
+    _glfw.ns.timer.resolution = (double) info.numer / (info.denom * 1.0e9);
+    _glfw.ns.timer.base = getRawTime();
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW platform API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+double _glfwPlatformGetTime(void)
+{
+    return (double) (getRawTime() - _glfw.ns.timer.base) *
+        _glfw.ns.timer.resolution;
+}
+
+void _glfwPlatformSetTime(double time)
+{
+    _glfw.ns.timer.base = getRawTime() -
+        (uint64_t) (time / _glfw.ns.timer.resolution);
+}
+

external/Box2D-2.3.1/Box2D/glfw/config.h

@@ -0,0 +1,52 @@
+//========================================================================
+// GLFW 3.0 - www.glfw.org
+//------------------------------------------------------------------------
+// Copyright (c) 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.
+//
+//========================================================================
+// As config.h.in, this file is used by CMake to produce the config.h shared
+// configuration header file.  If you are adding a feature requiring
+// conditional compilation, this is the proper place to add the macros.
+//========================================================================
+// As config.h, this file defines compile-time build options and macros for
+// all platforms supported by GLFW.  As this is a generated file, don't modify
+// it.  Instead, you should modify the config.h.in file.
+//========================================================================
+
+// GLFW doesn't like to be embedded as source, but that is what I'm doing.
+#if defined(WIN32)
+#define _GLFW_WIN32
+#define _GLFW_WGL
+#endif
+
+#if defined(__APPLE__)
+#define _GLFW_COCOA
+#define _GLFW_NSGL
+//#define _GLFW_USE_CHDIR
+#define _GLFW_USE_MENUBAR
+#endif
+
+// TODO get defines for other platforms
+
+#define _GLFW_USE_OPENGL
+#define _GLFW_VERSION_FULL "3.0.3"
+

external/Box2D-2.3.1/Box2D/glfw/context.c

@@ -0,0 +1,623 @@
+//========================================================================
+// GLFW 3.0 - 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.
+//
+//========================================================================
+
+#include "internal.h"
+
+#include <stdio.h>
+#include <string.h>
+#include <limits.h>
+#include <stdio.h>
+
+
+// Parses the client API version string and extracts the version number
+//
+static GLboolean parseGLVersion(int* api, int* major, int* minor, int* rev)
+{
+    int i, _api = GLFW_OPENGL_API, _major, _minor = 0, _rev = 0;
+    const char* version;
+    const char* prefixes[] =
+    {
+        "OpenGL ES-CM ",
+        "OpenGL ES-CL ",
+        "OpenGL ES ",
+        NULL
+    };
+
+    version = (const char*) glGetString(GL_VERSION);
+    if (!version)
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "Failed to retrieve context version string");
+        return GL_FALSE;
+    }
+
+    for (i = 0;  prefixes[i];  i++)
+    {
+        const size_t length = strlen(prefixes[i]);
+
+        if (strncmp(version, prefixes[i], length) == 0)
+        {
+            version += length;
+            _api = GLFW_OPENGL_ES_API;
+            break;
+        }
+    }
+
+    if (!sscanf(version, "%d.%d.%d", &_major, &_minor, &_rev))
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "No version found in context version string");
+        return GL_FALSE;
+    }
+
+    *api = _api;
+    *major = _major;
+    *minor = _minor;
+    *rev = _rev;
+
+    return GL_TRUE;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW internal API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+GLboolean _glfwIsValidContextConfig(_GLFWwndconfig* wndconfig)
+{
+    if (wndconfig->clientAPI != GLFW_OPENGL_API &&
+        wndconfig->clientAPI != GLFW_OPENGL_ES_API)
+    {
+        _glfwInputError(GLFW_INVALID_ENUM, "Invalid client API requested");
+        return GL_FALSE;
+    }
+
+    if (wndconfig->clientAPI == GLFW_OPENGL_API)
+    {
+        if (wndconfig->glMajor < 1 || wndconfig->glMinor < 0 ||
+            (wndconfig->glMajor == 1 && wndconfig->glMinor > 5) ||
+            (wndconfig->glMajor == 2 && wndconfig->glMinor > 1) ||
+            (wndconfig->glMajor == 3 && wndconfig->glMinor > 3))
+        {
+            // OpenGL 1.0 is the smallest valid version
+            // OpenGL 1.x series ended with version 1.5
+            // OpenGL 2.x series ended with version 2.1
+            // OpenGL 3.x series ended with version 3.3
+
+            _glfwInputError(GLFW_INVALID_VALUE,
+                            "Invalid OpenGL version %i.%i requested",
+                            wndconfig->glMajor, wndconfig->glMinor);
+            return GL_FALSE;
+        }
+        else
+        {
+            // For now, let everything else through
+        }
+
+        if (wndconfig->glProfile)
+        {
+            if (wndconfig->glProfile != GLFW_OPENGL_CORE_PROFILE &&
+                wndconfig->glProfile != GLFW_OPENGL_COMPAT_PROFILE)
+            {
+                _glfwInputError(GLFW_INVALID_ENUM,
+                                "Invalid OpenGL profile requested");
+                return GL_FALSE;
+            }
+
+            if (wndconfig->glMajor < 3 ||
+                (wndconfig->glMajor == 3 && wndconfig->glMinor < 2))
+            {
+                // Desktop OpenGL context profiles are only defined for version 3.2
+                // and above
+
+                _glfwInputError(GLFW_INVALID_VALUE,
+                                "Context profiles only exist for "
+                                "OpenGL version 3.2 and above");
+                return GL_FALSE;
+            }
+        }
+
+        if (wndconfig->glForward && wndconfig->glMajor < 3)
+        {
+            // Forward-compatible contexts are only defined for OpenGL version 3.0 and above
+            _glfwInputError(GLFW_INVALID_VALUE,
+                            "Forward compatibility only exist for OpenGL "
+                            "version 3.0 and above");
+            return GL_FALSE;
+        }
+    }
+    else if (wndconfig->clientAPI == GLFW_OPENGL_ES_API)
+    {
+        if (wndconfig->glMajor < 1 || wndconfig->glMinor < 0 ||
+            (wndconfig->glMajor == 1 && wndconfig->glMinor > 1) ||
+            (wndconfig->glMajor == 2 && wndconfig->glMinor > 0))
+        {
+            // OpenGL ES 1.0 is the smallest valid version
+            // OpenGL ES 1.x series ended with version 1.1
+            // OpenGL ES 2.x series ended with version 2.0
+
+            _glfwInputError(GLFW_INVALID_VALUE,
+                            "Invalid OpenGL ES version %i.%i requested",
+                            wndconfig->glMajor, wndconfig->glMinor);
+            return GL_FALSE;
+        }
+        else
+        {
+            // For now, let everything else through
+        }
+
+        if (wndconfig->glProfile)
+        {
+            // OpenGL ES does not support profiles
+            _glfwInputError(GLFW_INVALID_VALUE,
+                            "Context profiles are not supported by OpenGL ES");
+            return GL_FALSE;
+        }
+
+        if (wndconfig->glForward)
+        {
+            // OpenGL ES does not support forward-compatibility
+            _glfwInputError(GLFW_INVALID_VALUE,
+                            "Forward compatibility is not supported by OpenGL ES");
+            return GL_FALSE;
+        }
+    }
+
+    if (wndconfig->glRobustness)
+    {
+        if (wndconfig->glRobustness != GLFW_NO_RESET_NOTIFICATION &&
+            wndconfig->glRobustness != GLFW_LOSE_CONTEXT_ON_RESET)
+        {
+            _glfwInputError(GLFW_INVALID_VALUE,
+                            "Invalid context robustness mode requested");
+            return GL_FALSE;
+        }
+    }
+
+    return GL_TRUE;
+}
+
+const _GLFWfbconfig* _glfwChooseFBConfig(const _GLFWfbconfig* desired,
+                                         const _GLFWfbconfig* alternatives,
+                                         unsigned int count)
+{
+    unsigned int i;
+    unsigned int missing, leastMissing = UINT_MAX;
+    unsigned int colorDiff, leastColorDiff = UINT_MAX;
+    unsigned int extraDiff, leastExtraDiff = UINT_MAX;
+    const _GLFWfbconfig* current;
+    const _GLFWfbconfig* closest = NULL;
+
+    for (i = 0;  i < count;  i++)
+    {
+        current = alternatives + i;
+
+        if (desired->stereo > 0 && current->stereo == 0)
+        {
+            // Stereo is a hard constraint
+            continue;
+        }
+
+        // Count number of missing buffers
+        {
+            missing = 0;
+
+            if (desired->alphaBits > 0 && current->alphaBits == 0)
+                missing++;
+
+            if (desired->depthBits > 0 && current->depthBits == 0)
+                missing++;
+
+            if (desired->stencilBits > 0 && current->stencilBits == 0)
+                missing++;
+
+            if (desired->auxBuffers > 0 && current->auxBuffers < desired->auxBuffers)
+                missing += desired->auxBuffers - current->auxBuffers;
+
+            if (desired->samples > 0 && current->samples == 0)
+            {
+                // Technically, several multisampling buffers could be
+                // involved, but that's a lower level implementation detail and
+                // not important to us here, so we count them as one
+                missing++;
+            }
+        }
+
+        // These polynomials make many small channel size differences matter
+        // less than one large channel size difference
+
+        // Calculate color channel size difference value
+        {
+            colorDiff = 0;
+
+            if (desired->redBits > 0)
+            {
+                colorDiff += (desired->redBits - current->redBits) *
+                             (desired->redBits - current->redBits);
+            }
+
+            if (desired->greenBits > 0)
+            {
+                colorDiff += (desired->greenBits - current->greenBits) *
+                             (desired->greenBits - current->greenBits);
+            }
+
+            if (desired->blueBits > 0)
+            {
+                colorDiff += (desired->blueBits - current->blueBits) *
+                             (desired->blueBits - current->blueBits);
+            }
+        }
+
+        // Calculate non-color channel size difference value
+        {
+            extraDiff = 0;
+
+            if (desired->alphaBits > 0)
+            {
+                extraDiff += (desired->alphaBits - current->alphaBits) *
+                             (desired->alphaBits - current->alphaBits);
+            }
+
+            if (desired->depthBits > 0)
+            {
+                extraDiff += (desired->depthBits - current->depthBits) *
+                             (desired->depthBits - current->depthBits);
+            }
+
+            if (desired->stencilBits > 0)
+            {
+                extraDiff += (desired->stencilBits - current->stencilBits) *
+                             (desired->stencilBits - current->stencilBits);
+            }
+
+            if (desired->accumRedBits > 0)
+            {
+                extraDiff += (desired->accumRedBits - current->accumRedBits) *
+                             (desired->accumRedBits - current->accumRedBits);
+            }
+
+            if (desired->accumGreenBits > 0)
+            {
+                extraDiff += (desired->accumGreenBits - current->accumGreenBits) *
+                             (desired->accumGreenBits - current->accumGreenBits);
+            }
+
+            if (desired->accumBlueBits > 0)
+            {
+                extraDiff += (desired->accumBlueBits - current->accumBlueBits) *
+                             (desired->accumBlueBits - current->accumBlueBits);
+            }
+
+            if (desired->accumAlphaBits > 0)
+            {
+                extraDiff += (desired->accumAlphaBits - current->accumAlphaBits) *
+                             (desired->accumAlphaBits - current->accumAlphaBits);
+            }
+
+            if (desired->samples > 0)
+            {
+                extraDiff += (desired->samples - current->samples) *
+                             (desired->samples - current->samples);
+            }
+
+            if (desired->sRGB)
+            {
+                if (!current->sRGB)
+                    extraDiff++;
+            }
+        }
+
+        // Figure out if the current one is better than the best one found so far
+        // Least number of missing buffers is the most important heuristic,
+        // then color buffer size match and lastly size match for other buffers
+
+        if (missing < leastMissing)
+            closest = current;
+        else if (missing == leastMissing)
+        {
+            if ((colorDiff < leastColorDiff) ||
+                (colorDiff == leastColorDiff && extraDiff < leastExtraDiff))
+            {
+                closest = current;
+            }
+        }
+
+        if (current == closest)
+        {
+            leastMissing = missing;
+            leastColorDiff = colorDiff;
+            leastExtraDiff = extraDiff;
+        }
+    }
+
+    return closest;
+}
+
+GLboolean _glfwRefreshContextAttribs(void)
+{
+    _GLFWwindow* window = _glfwPlatformGetCurrentContext();
+
+    if (!parseGLVersion(&window->clientAPI,
+                        &window->glMajor,
+                        &window->glMinor,
+                        &window->glRevision))
+    {
+        return GL_FALSE;
+    }
+
+#if defined(_GLFW_USE_OPENGL)
+    if (window->glMajor > 2)
+    {
+        // 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)
+        {
+            _glfwInputError(GLFW_PLATFORM_ERROR,
+                            "Entry point retrieval is broken");
+            return GL_FALSE;
+        }
+    }
+
+    if (window->clientAPI == GLFW_OPENGL_API)
+    {
+        // Read back context flags (OpenGL 3.0 and above)
+        if (window->glMajor >= 3)
+        {
+            GLint flags;
+            glGetIntegerv(GL_CONTEXT_FLAGS, &flags);
+
+            if (flags & GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT)
+                window->glForward = GL_TRUE;
+
+            if (flags & GL_CONTEXT_FLAG_DEBUG_BIT)
+                window->glDebug = GL_TRUE;
+            else if (glfwExtensionSupported("GL_ARB_debug_output"))
+            {
+                // HACK: This is a workaround for older drivers (pre KHR_debug)
+                // not setting the debug bit in the context flags for debug
+                // contexts
+                window->glDebug = GL_TRUE;
+            }
+        }
+
+        // Read back OpenGL context profile (OpenGL 3.2 and above)
+        if (window->glMajor > 3 ||
+            (window->glMajor == 3 && window->glMinor >= 2))
+        {
+            GLint mask;
+            glGetIntegerv(GL_CONTEXT_PROFILE_MASK, &mask);
+
+            if (mask & GL_CONTEXT_COMPATIBILITY_PROFILE_BIT)
+                window->glProfile = GLFW_OPENGL_COMPAT_PROFILE;
+            else if (mask & GL_CONTEXT_CORE_PROFILE_BIT)
+                window->glProfile = GLFW_OPENGL_CORE_PROFILE;
+        }
+
+        // Read back robustness strategy
+        if (glfwExtensionSupported("GL_ARB_robustness"))
+        {
+            // NOTE: We avoid using the context flags for detection, as they are
+            // only present from 3.0 while the extension applies from 1.1
+
+            GLint strategy;
+            glGetIntegerv(GL_RESET_NOTIFICATION_STRATEGY_ARB, &strategy);
+
+            if (strategy == GL_LOSE_CONTEXT_ON_RESET_ARB)
+                window->glRobustness = GLFW_LOSE_CONTEXT_ON_RESET;
+            else if (strategy == GL_NO_RESET_NOTIFICATION_ARB)
+                window->glRobustness = GLFW_NO_RESET_NOTIFICATION;
+        }
+    }
+    else
+    {
+        // Read back robustness strategy
+        if (glfwExtensionSupported("GL_EXT_robustness"))
+        {
+            // NOTE: The values of these constants match those of the OpenGL ARB
+            // one, so we can reuse them here
+
+            GLint strategy;
+            glGetIntegerv(GL_RESET_NOTIFICATION_STRATEGY_ARB, &strategy);
+
+            if (strategy == GL_LOSE_CONTEXT_ON_RESET_ARB)
+                window->glRobustness = GLFW_LOSE_CONTEXT_ON_RESET;
+            else if (strategy == GL_NO_RESET_NOTIFICATION_ARB)
+                window->glRobustness = GLFW_NO_RESET_NOTIFICATION;
+        }
+    }
+#endif // _GLFW_USE_OPENGL
+
+    return GL_TRUE;
+}
+
+GLboolean _glfwIsValidContext(_GLFWwndconfig* wndconfig)
+{
+    _GLFWwindow* window = _glfwPlatformGetCurrentContext();
+
+    if (window->glMajor < wndconfig->glMajor ||
+        (window->glMajor == wndconfig->glMajor &&
+         window->glMinor < wndconfig->glMinor))
+    {
+        // 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;
+    }
+
+    return GL_TRUE;
+}
+
+int _glfwStringInExtensionString(const char* string, const GLubyte* extensions)
+{
+    const GLubyte* start;
+    GLubyte* where;
+    GLubyte* terminator;
+
+    // It takes a bit of care to be fool-proof about parsing the
+    // OpenGL extensions string. Don't be fooled by sub-strings,
+    // etc.
+    start = extensions;
+    for (;;)
+    {
+        where = (GLubyte*) strstr((const char*) start, string);
+        if (!where)
+            return GL_FALSE;
+
+        terminator = where + strlen(string);
+        if (where == start || *(where - 1) == ' ')
+        {
+            if (*terminator == ' ' || *terminator == '\0')
+                break;
+        }
+
+        start = terminator;
+    }
+
+    return GL_TRUE;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                        GLFW public API                       //////
+//////////////////////////////////////////////////////////////////////////
+
+GLFWAPI void glfwMakeContextCurrent(GLFWwindow* handle)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+
+    _GLFW_REQUIRE_INIT();
+
+    if (_glfwPlatformGetCurrentContext() == window)
+        return;
+
+    _glfwPlatformMakeContextCurrent(window);
+}
+
+GLFWAPI GLFWwindow* glfwGetCurrentContext(void)
+{
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+    return (GLFWwindow*) _glfwPlatformGetCurrentContext();
+}
+
+GLFWAPI void glfwSwapBuffers(GLFWwindow* handle)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    _GLFW_REQUIRE_INIT();
+    _glfwPlatformSwapBuffers(window);
+}
+
+GLFWAPI void glfwSwapInterval(int interval)
+{
+    _GLFW_REQUIRE_INIT();
+
+    if (!_glfwPlatformGetCurrentContext())
+    {
+        _glfwInputError(GLFW_NO_CURRENT_CONTEXT, NULL);
+        return;
+    }
+
+    _glfwPlatformSwapInterval(interval);
+}
+
+GLFWAPI int glfwExtensionSupported(const char* extension)
+{
+    const GLubyte* extensions;
+    _GLFWwindow* window;
+
+    _GLFW_REQUIRE_INIT_OR_RETURN(GL_FALSE);
+
+    window = _glfwPlatformGetCurrentContext();
+    if (!window)
+    {
+        _glfwInputError(GLFW_NO_CURRENT_CONTEXT, NULL);
+        return GL_FALSE;
+    }
+
+    if (extension == NULL || *extension == '\0')
+    {
+        _glfwInputError(GLFW_INVALID_VALUE, NULL);
+        return GL_FALSE;
+    }
+
+    if (window->glMajor < 3)
+    {
+        // Check if extension is in the old style OpenGL extensions string
+
+        extensions = glGetString(GL_EXTENSIONS);
+        if (extensions != NULL)
+        {
+            if (_glfwStringInExtensionString(extension, extensions))
+                return GL_TRUE;
+        }
+    }
+#if defined(_GLFW_USE_OPENGL)
+    else
+    {
+        int i;
+        GLint count;
+
+        // Check if extension is in the modern OpenGL extensions string list
+
+        glGetIntegerv(GL_NUM_EXTENSIONS, &count);
+
+        for (i = 0;  i < count;  i++)
+        {
+             if (strcmp((const char*) window->GetStringi(GL_EXTENSIONS, i),
+                         extension) == 0)
+             {
+                 return GL_TRUE;
+             }
+        }
+    }
+#endif // _GLFW_USE_OPENGL
+
+    // Check if extension is in the platform-specific string
+    return _glfwPlatformExtensionSupported(extension);
+}
+
+GLFWAPI GLFWglproc glfwGetProcAddress(const char* procname)
+{
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+
+    if (!_glfwPlatformGetCurrentContext())
+    {
+        _glfwInputError(GLFW_NO_CURRENT_CONTEXT, NULL);
+        return NULL;
+    }
+
+    return _glfwPlatformGetProcAddress(procname);
+}
+

external/Box2D-2.3.1/Box2D/glfw/egl_context.c

@@ -0,0 +1,546 @@
+//========================================================================
+// GLFW 3.0 EGL - 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.
+//
+//========================================================================
+
+#include "internal.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+
+
+// Thread local storage attribute macro
+//
+#if defined(_MSC_VER)
+ #define _GLFW_TLS __declspec(thread)
+#elif defined(__GNUC__)
+ #define _GLFW_TLS __thread
+#else
+ #define _GLFW_TLS
+#endif
+
+
+// The per-thread current context/window pointer
+//
+static _GLFW_TLS _GLFWwindow* _glfwCurrentWindow = NULL;
+
+
+// Return a description of the specified EGL error
+//
+static const char* getErrorString(EGLint error)
+{
+    switch (error)
+    {
+        case EGL_SUCCESS:
+            return "Success";
+        case EGL_NOT_INITIALIZED:
+            return "EGL is not or could not be initialized";
+        case EGL_BAD_ACCESS:
+            return "EGL cannot access a requested resource";
+        case EGL_BAD_ALLOC:
+            return "EGL failed to allocate resources for the requested operation";
+        case EGL_BAD_ATTRIBUTE:
+            return "An unrecognized attribute or attribute value was passed "
+                   "in the attribute list";
+        case EGL_BAD_CONTEXT:
+            return "An EGLContext argument does not name a valid EGL "
+                   "rendering context";
+        case EGL_BAD_CONFIG:
+            return "An EGLConfig argument does not name a valid EGL frame "
+                   "buffer configuration";
+        case EGL_BAD_CURRENT_SURFACE:
+            return "The current surface of the calling thread is a window, pixel "
+                   "buffer or pixmap that is no longer valid";
+        case EGL_BAD_DISPLAY:
+            return "An EGLDisplay argument does not name a valid EGL display "
+                   "connection";
+        case EGL_BAD_SURFACE:
+            return "An EGLSurface argument does not name a valid surface "
+                   "configured for GL rendering";
+        case EGL_BAD_MATCH:
+            return "Arguments are inconsistent";
+        case EGL_BAD_PARAMETER:
+            return "One or more argument values are invalid";
+        case EGL_BAD_NATIVE_PIXMAP:
+            return "A NativePixmapType argument does not refer to a valid "
+                   "native pixmap";
+        case EGL_BAD_NATIVE_WINDOW:
+            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";
+    }
+
+    return "UNKNOWN EGL ERROR";
+}
+
+// Returns the specified attribute of the specified EGLConfig
+//
+static int getConfigAttrib(EGLConfig config, int attrib)
+{
+    int value;
+    eglGetConfigAttrib(_glfw.egl.display, config, attrib, &value);
+    return value;
+}
+
+// Return a list of available and usable framebuffer configs
+//
+static GLboolean chooseFBConfigs(const _GLFWwndconfig* wndconfig,
+                                 const _GLFWfbconfig* desired,
+                                 EGLConfig* result)
+{
+    EGLConfig* nativeConfigs;
+    _GLFWfbconfig* usableConfigs;
+    const _GLFWfbconfig* closest;
+    int i, nativeCount, usableCount;
+
+    eglGetConfigs(_glfw.egl.display, NULL, 0, &nativeCount);
+    if (!nativeCount)
+    {
+        _glfwInputError(GLFW_API_UNAVAILABLE, "EGL: No EGLConfigs returned");
+        return GL_FALSE;
+    }
+
+    nativeConfigs = calloc(nativeCount, sizeof(EGLConfig));
+    eglGetConfigs(_glfw.egl.display, nativeConfigs, nativeCount, &nativeCount);
+
+    usableConfigs = calloc(nativeCount, sizeof(_GLFWfbconfig));
+    usableCount = 0;
+
+    for (i = 0;  i < nativeCount;  i++)
+    {
+        const EGLConfig n = nativeConfigs[i];
+        _GLFWfbconfig* u = usableConfigs + usableCount;
+
+#if defined(_GLFW_X11)
+        if (!getConfigAttrib(n, EGL_NATIVE_VISUAL_ID))
+        {
+            // Only consider EGLConfigs with associated visuals
+            continue;
+        }
+#endif // _GLFW_X11
+
+        if (!(getConfigAttrib(n, EGL_COLOR_BUFFER_TYPE) & EGL_RGB_BUFFER))
+        {
+            // Only consider RGB(A) EGLConfigs
+            continue;
+        }
+
+        if (!(getConfigAttrib(n, EGL_SURFACE_TYPE) & EGL_WINDOW_BIT))
+        {
+            // Only consider window EGLConfigs
+            continue;
+        }
+
+        if (wndconfig->clientAPI == GLFW_OPENGL_ES_API)
+        {
+            if (wndconfig->glMajor == 1)
+            {
+                if (!(getConfigAttrib(n, EGL_RENDERABLE_TYPE) & EGL_OPENGL_ES_BIT))
+                    continue;
+            }
+            else
+            {
+                if (!(getConfigAttrib(n, EGL_RENDERABLE_TYPE) & EGL_OPENGL_ES2_BIT))
+                    continue;
+            }
+        }
+        else if (wndconfig->clientAPI == GLFW_OPENGL_API)
+        {
+            if (!(getConfigAttrib(n, EGL_RENDERABLE_TYPE) & EGL_OPENGL_BIT))
+                continue;
+        }
+
+        u->redBits = getConfigAttrib(n, EGL_RED_SIZE);
+        u->greenBits = getConfigAttrib(n, EGL_GREEN_SIZE);
+        u->blueBits = getConfigAttrib(n, EGL_BLUE_SIZE);
+
+        u->alphaBits = getConfigAttrib(n, EGL_ALPHA_SIZE);
+        u->depthBits = getConfigAttrib(n, EGL_DEPTH_SIZE);
+        u->stencilBits = getConfigAttrib(n, EGL_STENCIL_SIZE);
+
+        u->samples = getConfigAttrib(n, EGL_SAMPLES);
+
+        u->egl = n;
+        usableCount++;
+    }
+
+    closest = _glfwChooseFBConfig(desired, usableConfigs, usableCount);
+    if (closest)
+        *result = closest->egl;
+
+    free(nativeConfigs);
+    free(usableConfigs);
+
+    return closest ? GL_TRUE : GL_FALSE;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW internal API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+// Initialize EGL
+//
+int _glfwInitContextAPI(void)
+{
+    _glfw.egl.display = eglGetDisplay((EGLNativeDisplayType)_GLFW_EGL_NATIVE_DISPLAY);
+    if (_glfw.egl.display == EGL_NO_DISPLAY)
+    {
+        _glfwInputError(GLFW_API_UNAVAILABLE,
+                        "EGL: Failed to get EGL display: %s",
+                        getErrorString(eglGetError()));
+        return GL_FALSE;
+    }
+
+    if (!eglInitialize(_glfw.egl.display,
+                       &_glfw.egl.versionMajor,
+                       &_glfw.egl.versionMinor))
+    {
+        _glfwInputError(GLFW_API_UNAVAILABLE,
+                        "EGL: Failed to initialize EGL: %s",
+                        getErrorString(eglGetError()));
+        return GL_FALSE;
+    }
+
+    if (_glfwPlatformExtensionSupported("EGL_KHR_create_context"))
+        _glfw.egl.KHR_create_context = GL_TRUE;
+
+    return GL_TRUE;
+}
+
+// Terminate EGL
+//
+void _glfwTerminateContextAPI(void)
+{
+    eglTerminate(_glfw.egl.display);
+}
+
+#define setEGLattrib(attribName, attribValue) \
+{ \
+    attribs[index++] = attribName; \
+    attribs[index++] = attribValue; \
+    assert((size_t) index < sizeof(attribs) / sizeof(attribs[0])); \
+}
+
+// Prepare for creation of the OpenGL context
+//
+int _glfwCreateContext(_GLFWwindow* window,
+                       const _GLFWwndconfig* wndconfig,
+                       const _GLFWfbconfig* fbconfig)
+{
+    int attribs[40];
+    EGLint count = 0;
+    EGLConfig config;
+    EGLContext share = NULL;
+
+    if (wndconfig->share)
+        share = wndconfig->share->egl.context;
+
+    if (!chooseFBConfigs(wndconfig, fbconfig, &config))
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "EGL: Failed to find a suitable EGLConfig");
+        return GL_FALSE;
+    }
+
+#if defined(_GLFW_X11)
+    // Retrieve the visual corresponding to the chosen EGL config
+    {
+        int mask;
+        EGLint redBits, greenBits, blueBits, alphaBits, visualID = 0;
+        XVisualInfo info;
+
+        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 don't implement the EGL_NATIVE_VISUAL_ID
+            // attribute, so attempt to find the closest match.
+
+            eglGetConfigAttrib(_glfw.egl.display, config,
+                               EGL_RED_SIZE, &redBits);
+            eglGetConfigAttrib(_glfw.egl.display, config,
+                               EGL_GREEN_SIZE, &greenBits);
+            eglGetConfigAttrib(_glfw.egl.display, config,
+                               EGL_BLUE_SIZE, &blueBits);
+            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 == NULL)
+        {
+            _glfwInputError(GLFW_PLATFORM_ERROR,
+                            "EGL: Failed to retrieve visual for EGLConfig");
+            return GL_FALSE;
+        }
+    }
+#endif // _GLFW_X11
+
+    if (wndconfig->clientAPI == GLFW_OPENGL_ES_API)
+    {
+        if (!eglBindAPI(EGL_OPENGL_ES_API))
+        {
+            _glfwInputError(GLFW_PLATFORM_ERROR,
+                            "EGL: Failed to bind OpenGL ES: %s",
+                            getErrorString(eglGetError()));
+            return GL_FALSE;
+        }
+    }
+    else
+    {
+        if (!eglBindAPI(EGL_OPENGL_API))
+        {
+            _glfwInputError(GLFW_PLATFORM_ERROR,
+                            "EGL: Failed to bind OpenGL: %s",
+                            getErrorString(eglGetError()));
+            return GL_FALSE;
+        }
+    }
+
+    if (_glfw.egl.KHR_create_context)
+    {
+        int index = 0, mask = 0, flags = 0, strategy = 0;
+
+        if (wndconfig->clientAPI == GLFW_OPENGL_API)
+        {
+            if (wndconfig->glProfile == GLFW_OPENGL_CORE_PROFILE)
+                mask |= EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT_KHR;
+            else if (wndconfig->glProfile == GLFW_OPENGL_COMPAT_PROFILE)
+                mask |= EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT_KHR;
+
+            if (wndconfig->glForward)
+                flags |= EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE_BIT_KHR;
+
+            if (wndconfig->glDebug)
+                flags |= EGL_CONTEXT_OPENGL_DEBUG_BIT_KHR;
+        }
+
+        if (wndconfig->glRobustness != GLFW_NO_ROBUSTNESS)
+        {
+            if (wndconfig->glRobustness == GLFW_NO_RESET_NOTIFICATION)
+                strategy = EGL_NO_RESET_NOTIFICATION_KHR;
+            else if (wndconfig->glRobustness == GLFW_LOSE_CONTEXT_ON_RESET)
+                strategy = EGL_LOSE_CONTEXT_ON_RESET_KHR;
+
+            flags |= EGL_CONTEXT_OPENGL_ROBUST_ACCESS_BIT_KHR;
+        }
+
+        if (wndconfig->glMajor != 1 || wndconfig->glMinor != 0)
+        {
+            setEGLattrib(EGL_CONTEXT_MAJOR_VERSION_KHR, wndconfig->glMajor);
+            setEGLattrib(EGL_CONTEXT_MINOR_VERSION_KHR, wndconfig->glMinor);
+        }
+
+        if (mask)
+            setEGLattrib(EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR, mask);
+
+        if (flags)
+            setEGLattrib(EGL_CONTEXT_FLAGS_KHR, flags);
+
+        if (strategy)
+            setEGLattrib(EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_KHR, strategy);
+
+        setEGLattrib(EGL_NONE, EGL_NONE);
+    }
+    else
+    {
+        int index = 0;
+
+        if (wndconfig->clientAPI == GLFW_OPENGL_ES_API)
+            setEGLattrib(EGL_CONTEXT_CLIENT_VERSION, wndconfig->glMajor);
+
+        setEGLattrib(EGL_NONE, EGL_NONE);
+    }
+
+    window->egl.context = eglCreateContext(_glfw.egl.display,
+                                           config, share, attribs);
+
+    if (window->egl.context == EGL_NO_CONTEXT)
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "EGL: Failed to create context: %s",
+                        getErrorString(eglGetError()));
+        return GL_FALSE;
+    }
+
+    window->egl.config = config;
+
+    return GL_TRUE;
+}
+
+#undef setEGLattrib
+
+// Destroy the OpenGL context
+//
+void _glfwDestroyContext(_GLFWwindow* window)
+{
+#if defined(_GLFW_X11)
+    if (window->egl.visual)
+    {
+       XFree(window->egl.visual);
+       window->egl.visual = NULL;
+    }
+#endif // _GLFW_X11
+
+    if (window->egl.surface)
+    {
+        eglDestroySurface(_glfw.egl.display, window->egl.surface);
+        window->egl.surface = EGL_NO_SURFACE;
+    }
+
+    if (window->egl.context)
+    {
+        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 _GLFWwndconfig* wndconfig,
+                        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 = 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(eglGetError()));
+            }
+        }
+
+        eglMakeCurrent(_glfw.egl.display,
+                       window->egl.surface,
+                       window->egl.surface,
+                       window->egl.context);
+    }
+    else
+    {
+        eglMakeCurrent(_glfw.egl.display,
+                       EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
+    }
+
+    _glfwCurrentWindow = window;
+}
+
+_GLFWwindow* _glfwPlatformGetCurrentContext(void)
+{
+    return _glfwCurrentWindow;
+}
+
+void _glfwPlatformSwapBuffers(_GLFWwindow* window)
+{
+    eglSwapBuffers(_glfw.egl.display, window->egl.surface);
+}
+
+void _glfwPlatformSwapInterval(int interval)
+{
+    eglSwapInterval(_glfw.egl.display, interval);
+}
+
+int _glfwPlatformExtensionSupported(const char* extension)
+{
+    const char* extensions;
+
+    extensions = eglQueryString(_glfw.egl.display, EGL_EXTENSIONS);
+    if (extensions != NULL)
+    {
+        if (_glfwStringInExtensionString(extension, (unsigned char*) extensions))
+            return GL_TRUE;
+    }
+
+    return GL_FALSE;
+}
+
+GLFWglproc _glfwPlatformGetProcAddress(const char* procname)
+{
+    return eglGetProcAddress(procname);
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                        GLFW native API                       //////
+//////////////////////////////////////////////////////////////////////////
+
+GLFWAPI EGLDisplay glfwGetEGLDisplay(void)
+{
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+    return _glfw.egl.display;
+}
+
+GLFWAPI EGLContext glfwGetEGLContext(GLFWwindow* handle)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+    return window->egl.context;
+}
+
+GLFWAPI EGLSurface glfwGetEGLSurface(GLFWwindow* handle)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    _GLFW_REQUIRE_INIT_OR_RETURN(0);
+    return window->egl.surface;
+}
+

external/Box2D-2.3.1/Box2D/glfw/egl_platform.h

@@ -0,0 +1,80 @@
+//========================================================================
+// GLFW 3.0 EGL - 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 _egl_platform_h_
+#define _egl_platform_h_
+
+#include <EGL/egl.h>
+
+// 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"
+
+// Do we have support for dlopen/dlsym?
+#if defined(_GLFW_HAS_DLOPEN)
+ #include <dlfcn.h>
+#endif
+
+#define _GLFW_PLATFORM_FBCONFIG             EGLConfig       egl
+#define _GLFW_PLATFORM_CONTEXT_STATE        _GLFWcontextEGL egl
+#define _GLFW_PLATFORM_LIBRARY_OPENGL_STATE _GLFWlibraryEGL egl
+
+
+//========================================================================
+// GLFW platform specific types
+//========================================================================
+
+//------------------------------------------------------------------------
+// Platform-specific OpenGL context structure
+//------------------------------------------------------------------------
+typedef struct _GLFWcontextEGL
+{
+   EGLConfig      config;
+   EGLContext     context;
+   EGLSurface     surface;
+
+#if defined(_GLFW_X11)
+   XVisualInfo*   visual;
+#endif
+} _GLFWcontextEGL;
+
+
+//------------------------------------------------------------------------
+// Platform-specific library global data for EGL
+//------------------------------------------------------------------------
+typedef struct _GLFWlibraryEGL
+{
+    EGLDisplay      display;
+    EGLint          versionMajor, versionMinor;
+
+    GLboolean       KHR_create_context;
+
+} _GLFWlibraryEGL;
+
+
+#endif // _egl_platform_h_

external/Box2D-2.3.1/Box2D/glfw/gamma.c

@@ -0,0 +1,126 @@
+//========================================================================
+// GLFW 3.0 - www.glfw.org
+//------------------------------------------------------------------------
+// Copyright (c) 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.
+//
+//========================================================================
+
+#include "internal.h"
+
+#include <math.h>
+#include <stdlib.h>
+#include <string.h>
+
+#if defined(_MSC_VER)
+ #include <malloc.h>
+#endif
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW internal API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+void _glfwAllocGammaArrays(GLFWgammaramp* ramp, unsigned int size)
+{
+    ramp->red = calloc(size, sizeof(unsigned short));
+    ramp->green = calloc(size, sizeof(unsigned short));
+    ramp->blue = calloc(size, sizeof(unsigned short));
+    ramp->size = size;
+}
+
+void _glfwFreeGammaArrays(GLFWgammaramp* ramp)
+{
+    free(ramp->red);
+    free(ramp->green);
+    free(ramp->blue);
+
+    memset(ramp, 0, sizeof(GLFWgammaramp));
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                        GLFW public API                       //////
+//////////////////////////////////////////////////////////////////////////
+
+GLFWAPI void glfwSetGamma(GLFWmonitor* handle, float gamma)
+{
+    int i;
+    unsigned short values[256];
+    GLFWgammaramp ramp;
+
+    _GLFW_REQUIRE_INIT();
+
+    if (gamma <= 0.f)
+    {
+        _glfwInputError(GLFW_INVALID_VALUE,
+                        "Gamma value must be greater than zero");
+        return;
+    }
+
+    for (i = 0;  i < 256;  i++)
+    {
+        double value;
+
+        // Calculate intensity
+        value = i / 255.0;
+        // Apply gamma curve
+        value = pow(value, 1.0 / gamma) * 65535.0 + 0.5;
+
+        // Clamp to value range
+        if (value > 65535.0)
+            value = 65535.0;
+
+        values[i] = (unsigned short) value;
+    }
+
+    ramp.red = values;
+    ramp.green = values;
+    ramp.blue = values;
+    ramp.size = 256;
+
+    glfwSetGammaRamp(handle, &ramp);
+}
+
+GLFWAPI const GLFWgammaramp* glfwGetGammaRamp(GLFWmonitor* handle)
+{
+    _GLFWmonitor* monitor = (_GLFWmonitor*) handle;
+
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+
+    _glfwFreeGammaArrays(&monitor->currentRamp);
+    _glfwPlatformGetGammaRamp(monitor, &monitor->currentRamp);
+
+    return &monitor->currentRamp;
+}
+
+GLFWAPI void glfwSetGammaRamp(GLFWmonitor* handle, const GLFWgammaramp* ramp)
+{
+    _GLFWmonitor* monitor = (_GLFWmonitor*) handle;
+
+    _GLFW_REQUIRE_INIT();
+
+    if (!monitor->originalRamp.size)
+        _glfwPlatformGetGammaRamp(monitor, &monitor->originalRamp);
+
+    _glfwPlatformSetGammaRamp(monitor, ramp);
+}
+

external/Box2D-2.3.1/Box2D/glfw/glfw3native.h

@@ -0,0 +1,180 @@
+/*************************************************************************
+ * GLFW 3.0 - 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>
+ *
+ * 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_native_h_
+#define _glfw3_native_h_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/*************************************************************************
+ * Doxygen documentation
+ *************************************************************************/
+
+/*! @defgroup native Native access
+ *
+ *  **By using the native API, you assert that you know what you're doing and
+ *  how to fix problems caused by using it.  If you don't, you shouldn't be
+ *  using it.**
+ *
+ *  Before the inclusion of @ref glfw3native.h, you must define exactly one
+ *  window API macro and exactly one context API macro.  Failure to do this
+ *  will cause a compile-time error.
+ *
+ *  The available window API macros are:
+ *  * `GLFW_EXPOSE_NATIVE_WIN32`
+ *  * `GLFW_EXPOSE_NATIVE_COCOA`
+ *  * `GLFW_EXPOSE_NATIVE_X11`
+ *
+ *  The available context API macros are:
+ *  * `GLFW_EXPOSE_NATIVE_WGL`
+ *  * `GLFW_EXPOSE_NATIVE_NSGL`
+ *  * `GLFW_EXPOSE_NATIVE_GLX`
+ *  * `GLFW_EXPOSE_NATIVE_EGL`
+ *
+ *  These macros select which of the native access functions that are declared
+ *  and which platform-specific headers to include.  It is then up your (by
+ *  definition platform-specific) code to handle which of these should be
+ *  defined.
+ */
+
+
+/*************************************************************************
+ * System headers and types
+ *************************************************************************/
+
+#if defined(GLFW_EXPOSE_NATIVE_WIN32)
+ #include <windows.h>
+#elif defined(GLFW_EXPOSE_NATIVE_COCOA)
+ #if defined(__OBJC__)
+  #import <Cocoa/Cocoa.h>
+ #else
+  typedef void* id;
+ #endif
+#elif defined(GLFW_EXPOSE_NATIVE_X11)
+ #include <X11/Xlib.h>
+#else
+ #error "No window API specified"
+#endif
+
+#if defined(GLFW_EXPOSE_NATIVE_WGL)
+ /* WGL is declared by windows.h */
+#elif defined(GLFW_EXPOSE_NATIVE_NSGL)
+ /* NSGL is declared by Cocoa.h */
+#elif defined(GLFW_EXPOSE_NATIVE_GLX)
+ #include <GL/glx.h>
+#elif defined(GLFW_EXPOSE_NATIVE_EGL)
+ #include <EGL/egl.h>
+#else
+ #error "No context API specified"
+#endif
+
+
+/*************************************************************************
+ * Functions
+ *************************************************************************/
+
+#if defined(GLFW_EXPOSE_NATIVE_WIN32)
+/*! @brief Returns the `HWND` of the specified window.
+ *  @return The `HWND` of the specified window.
+ *  @ingroup native
+ */
+GLFWAPI HWND glfwGetWin32Window(GLFWwindow* window);
+#endif
+
+#if defined(GLFW_EXPOSE_NATIVE_WGL)
+/*! @brief Returns the `HGLRC` of the specified window.
+ *  @return The `HGLRC` of the specified window.
+ *  @ingroup native
+ */
+GLFWAPI HGLRC glfwGetWGLContext(GLFWwindow* window);
+#endif
+
+#if defined(GLFW_EXPOSE_NATIVE_COCOA)
+/*! @brief Returns the `NSWindow` of the specified window.
+ *  @return The `NSWindow` of the specified window.
+ *  @ingroup native
+ */
+GLFWAPI id glfwGetCocoaWindow(GLFWwindow* window);
+#endif
+
+#if defined(GLFW_EXPOSE_NATIVE_NSGL)
+/*! @brief Returns the `NSOpenGLContext` of the specified window.
+ *  @return The `NSOpenGLContext` of the specified window.
+ *  @ingroup native
+ */
+GLFWAPI id glfwGetNSGLContext(GLFWwindow* window);
+#endif
+
+#if defined(GLFW_EXPOSE_NATIVE_X11)
+/*! @brief Returns the `Display` used by GLFW.
+ *  @return The `Display` used by GLFW.
+ *  @ingroup native
+ */
+GLFWAPI Display* glfwGetX11Display(void);
+/*! @brief Returns the `Window` of the specified window.
+ *  @return The `Window` of the specified window.
+ *  @ingroup native
+ */
+GLFWAPI Window glfwGetX11Window(GLFWwindow* window);
+#endif
+
+#if defined(GLFW_EXPOSE_NATIVE_GLX)
+/*! @brief Returns the `GLXContext` of the specified window.
+ *  @return The `GLXContext` of the specified window.
+ *  @ingroup native
+ */
+GLFWAPI GLXContext glfwGetGLXContext(GLFWwindow* window);
+#endif
+
+#if defined(GLFW_EXPOSE_NATIVE_EGL)
+/*! @brief Returns the `EGLDisplay` used by GLFW.
+ *  @return The `EGLDisplay` used by GLFW.
+ *  @ingroup native
+ */
+GLFWAPI EGLDisplay glfwGetEGLDisplay(void);
+/*! @brief Returns the `EGLContext` of the specified window.
+ *  @return The `EGLContext` of the specified window.
+ *  @ingroup native
+ */
+GLFWAPI EGLContext glfwGetEGLContext(GLFWwindow* window);
+/*! @brief Returns the `EGLSurface` of the specified window.
+ *  @return The `EGLSurface` of the specified window.
+ *  @ingroup native
+ */
+GLFWAPI EGLSurface glfwGetEGLSurface(GLFWwindow* window);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _glfw3_native_h_ */
+

external/Box2D-2.3.1/Box2D/glfw/glx_context.c

@@ -0,0 +1,612 @@
+//========================================================================
+// GLFW 3.0 GLX - 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.
+//
+//========================================================================
+
+#include "internal.h"
+
+#include <string.h>
+#include <stdlib.h>
+#include <assert.h>
+#include <pthread.h>
+
+
+// This is the only glXGetProcAddress variant not declared by glxext.h
+void (*glXGetProcAddressEXT(const GLubyte* procName))();
+
+
+#ifndef GLXBadProfileARB
+ #define GLXBadProfileARB 13
+#endif
+
+
+// Returns the specified attribute of the specified GLXFBConfig
+// NOTE: Do not call this unless we have found GLX 1.3+ or GLX_SGIX_fbconfig
+//
+static int getFBConfigAttrib(GLXFBConfig fbconfig, int attrib)
+{
+    int value;
+
+    if (_glfw.glx.SGIX_fbconfig)
+    {
+        _glfw.glx.GetFBConfigAttribSGIX(_glfw.x11.display,
+                                        fbconfig, attrib, &value);
+    }
+    else
+        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)
+{
+    GLXFBConfig* nativeConfigs;
+    _GLFWfbconfig* usableConfigs;
+    const _GLFWfbconfig* closest;
+    int i, nativeCount, usableCount;
+    const char* vendor;
+    GLboolean trustWindowBit = GL_TRUE;
+
+    vendor = glXGetClientString(_glfw.x11.display, GLX_VENDOR);
+    if (strcmp(vendor, "Chromium") == 0)
+    {
+        // HACK: This is a (hopefully temporary) workaround for Chromium
+        // (VirtualBox GL) not setting the window bit on any GLXFBConfigs
+        trustWindowBit = GL_FALSE;
+    }
+
+    if (_glfw.glx.SGIX_fbconfig)
+    {
+        nativeConfigs = _glfw.glx.ChooseFBConfigSGIX(_glfw.x11.display,
+                                                     _glfw.x11.screen,
+                                                     NULL,
+                                                     &nativeCount);
+    }
+    else
+    {
+        nativeConfigs = glXGetFBConfigs(_glfw.x11.display,
+                                        _glfw.x11.screen,
+                                        &nativeCount);
+    }
+
+    if (!nativeCount)
+    {
+        _glfwInputError(GLFW_API_UNAVAILABLE,
+                        "GLX: No GLXFBConfigs returned");
+        return GL_FALSE;
+    }
+
+    usableConfigs = calloc(nativeCount, sizeof(_GLFWfbconfig));
+    usableCount = 0;
+
+    for (i = 0;  i < nativeCount;  i++)
+    {
+        const GLXFBConfig n = nativeConfigs[i];
+        _GLFWfbconfig* u = usableConfigs + usableCount;
+
+        if (!getFBConfigAttrib(n, GLX_DOUBLEBUFFER) ||
+            !getFBConfigAttrib(n, GLX_VISUAL_ID))
+        {
+            // Only consider double-buffered GLXFBConfigs with associated visuals
+            continue;
+        }
+
+        if (!(getFBConfigAttrib(n, GLX_RENDER_TYPE) & GLX_RGBA_BIT))
+        {
+            // Only consider RGBA GLXFBConfigs
+            continue;
+        }
+
+        if (!(getFBConfigAttrib(n, GLX_DRAWABLE_TYPE) & GLX_WINDOW_BIT))
+        {
+            if (trustWindowBit)
+            {
+                // Only consider window GLXFBConfigs
+                continue;
+            }
+        }
+
+        u->redBits = getFBConfigAttrib(n, GLX_RED_SIZE);
+        u->greenBits = getFBConfigAttrib(n, GLX_GREEN_SIZE);
+        u->blueBits = getFBConfigAttrib(n, GLX_BLUE_SIZE);
+
+        u->alphaBits = getFBConfigAttrib(n, GLX_ALPHA_SIZE);
+        u->depthBits = getFBConfigAttrib(n, GLX_DEPTH_SIZE);
+        u->stencilBits = getFBConfigAttrib(n, GLX_STENCIL_SIZE);
+
+        u->accumRedBits = getFBConfigAttrib(n, GLX_ACCUM_RED_SIZE);
+        u->accumGreenBits = getFBConfigAttrib(n, GLX_ACCUM_GREEN_SIZE);
+        u->accumBlueBits = getFBConfigAttrib(n, GLX_ACCUM_BLUE_SIZE);
+        u->accumAlphaBits = getFBConfigAttrib(n, GLX_ACCUM_ALPHA_SIZE);
+
+        u->auxBuffers = getFBConfigAttrib(n, GLX_AUX_BUFFERS);
+        u->stereo = getFBConfigAttrib(n, GLX_STEREO);
+
+        if (_glfw.glx.ARB_multisample)
+            u->samples = getFBConfigAttrib(n, GLX_SAMPLES);
+
+        if (_glfw.glx.ARB_framebuffer_sRGB)
+            u->sRGB = getFBConfigAttrib(n, GLX_FRAMEBUFFER_SRGB_CAPABLE_ARB);
+
+        u->glx = n;
+        usableCount++;
+    }
+
+    closest = _glfwChooseFBConfig(desired, usableConfigs, usableCount);
+    if (closest)
+        *result = closest->glx;
+
+    XFree(nativeConfigs);
+    free(usableConfigs);
+
+    return closest ? GL_TRUE : GL_FALSE;
+}
+
+// Create the OpenGL context using legacy API
+//
+static GLXContext createLegacyContext(_GLFWwindow* window,
+                                      GLXFBConfig fbconfig,
+                                      GLXContext share)
+{
+    if (_glfw.glx.SGIX_fbconfig)
+    {
+        return _glfw.glx.CreateContextWithConfigSGIX(_glfw.x11.display,
+                                                     fbconfig,
+                                                     GLX_RGBA_TYPE,
+                                                     share,
+                                                     True);
+    }
+
+    return glXCreateNewContext(_glfw.x11.display,
+                               fbconfig,
+                               GLX_RGBA_TYPE,
+                               share,
+                               True);
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW internal API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+// Initialize GLX
+//
+int _glfwInitContextAPI(void)
+{
+#ifdef _GLFW_DLOPEN_LIBGL
+    int i;
+    char* libGL_names[ ] =
+    {
+        "libGL.so",
+        "libGL.so.1",
+        "/usr/lib/libGL.so",
+        "/usr/lib/libGL.so.1",
+        NULL
+    };
+
+    for (i = 0;  libGL_names[i] != NULL;  i++)
+    {
+        _glfw.glx.libGL = dlopen(libGL_names[i], RTLD_LAZY | RTLD_GLOBAL);
+        if (_glfw.glx.libGL)
+            break;
+    }
+
+    if (!_glfw.glx.libGL)
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR, "GLX: Failed to find libGL");
+        return GL_FALSE;
+    }
+#endif
+
+    if (pthread_key_create(&_glfw.glx.current, NULL) != 0)
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "GLX: Failed to create context TLS");
+        return GL_FALSE;
+    }
+
+    // Check if GLX is supported on this display
+    if (!glXQueryExtension(_glfw.x11.display,
+                           &_glfw.glx.errorBase,
+                           &_glfw.glx.eventBase))
+    {
+        _glfwInputError(GLFW_API_UNAVAILABLE, "GLX: GLX support not found");
+        return GL_FALSE;
+    }
+
+    if (!glXQueryVersion(_glfw.x11.display,
+                         &_glfw.glx.versionMajor,
+                         &_glfw.glx.versionMinor))
+    {
+        _glfwInputError(GLFW_API_UNAVAILABLE,
+                        "GLX: Failed to query GLX version");
+        return GL_FALSE;
+    }
+
+    if (_glfwPlatformExtensionSupported("GLX_EXT_swap_control"))
+    {
+        _glfw.glx.SwapIntervalEXT = (PFNGLXSWAPINTERVALEXTPROC)
+            _glfwPlatformGetProcAddress("glXSwapIntervalEXT");
+
+        if (_glfw.glx.SwapIntervalEXT)
+            _glfw.glx.EXT_swap_control = GL_TRUE;
+    }
+
+    if (_glfwPlatformExtensionSupported("GLX_SGI_swap_control"))
+    {
+        _glfw.glx.SwapIntervalSGI = (PFNGLXSWAPINTERVALSGIPROC)
+            _glfwPlatformGetProcAddress("glXSwapIntervalSGI");
+
+        if (_glfw.glx.SwapIntervalSGI)
+            _glfw.glx.SGI_swap_control = GL_TRUE;
+    }
+
+    if (_glfwPlatformExtensionSupported("GLX_MESA_swap_control"))
+    {
+        _glfw.glx.SwapIntervalMESA = (PFNGLXSWAPINTERVALMESAPROC)
+            _glfwPlatformGetProcAddress("glXSwapIntervalMESA");
+
+        if (_glfw.glx.SwapIntervalMESA)
+            _glfw.glx.MESA_swap_control = GL_TRUE;
+    }
+
+    if (_glfwPlatformExtensionSupported("GLX_SGIX_fbconfig"))
+    {
+        _glfw.glx.GetFBConfigAttribSGIX = (PFNGLXGETFBCONFIGATTRIBSGIXPROC)
+            _glfwPlatformGetProcAddress("glXGetFBConfigAttribSGIX");
+        _glfw.glx.ChooseFBConfigSGIX = (PFNGLXCHOOSEFBCONFIGSGIXPROC)
+            _glfwPlatformGetProcAddress("glXChooseFBConfigSGIX");
+        _glfw.glx.CreateContextWithConfigSGIX = (PFNGLXCREATECONTEXTWITHCONFIGSGIXPROC)
+            _glfwPlatformGetProcAddress("glXCreateContextWithConfigSGIX");
+        _glfw.glx.GetVisualFromFBConfigSGIX = (PFNGLXGETVISUALFROMFBCONFIGSGIXPROC)
+            _glfwPlatformGetProcAddress("glXGetVisualFromFBConfigSGIX");
+
+        if (_glfw.glx.GetFBConfigAttribSGIX &&
+            _glfw.glx.ChooseFBConfigSGIX &&
+            _glfw.glx.CreateContextWithConfigSGIX &&
+            _glfw.glx.GetVisualFromFBConfigSGIX)
+        {
+            _glfw.glx.SGIX_fbconfig = GL_TRUE;
+        }
+    }
+
+    if (_glfwPlatformExtensionSupported("GLX_ARB_multisample"))
+        _glfw.glx.ARB_multisample = GL_TRUE;
+
+    if (_glfwPlatformExtensionSupported("GLX_ARB_framebuffer_sRGB"))
+        _glfw.glx.ARB_framebuffer_sRGB = GL_TRUE;
+
+    if (_glfwPlatformExtensionSupported("GLX_ARB_create_context"))
+    {
+        _glfw.glx.CreateContextAttribsARB = (PFNGLXCREATECONTEXTATTRIBSARBPROC)
+            _glfwPlatformGetProcAddress("glXCreateContextAttribsARB");
+
+        if (_glfw.glx.CreateContextAttribsARB)
+            _glfw.glx.ARB_create_context = GL_TRUE;
+    }
+
+    if (_glfwPlatformExtensionSupported("GLX_ARB_create_context_robustness"))
+        _glfw.glx.ARB_create_context_robustness = GL_TRUE;
+
+    if (_glfwPlatformExtensionSupported("GLX_ARB_create_context_profile"))
+        _glfw.glx.ARB_create_context_profile = GL_TRUE;
+
+    if (_glfwPlatformExtensionSupported("GLX_EXT_create_context_es2_profile"))
+        _glfw.glx.EXT_create_context_es2_profile = GL_TRUE;
+
+    return GL_TRUE;
+}
+
+// Terminate GLX
+//
+void _glfwTerminateContextAPI(void)
+{
+    // Unload libGL.so if necessary
+#ifdef _GLFW_DLOPEN_LIBGL
+    if (_glfw.glx.libGL != NULL)
+    {
+        dlclose(_glfw.glx.libGL);
+        _glfw.glx.libGL = NULL;
+    }
+#endif
+
+    pthread_key_delete(_glfw.glx.current);
+}
+
+#define setGLXattrib(attribName, attribValue) \
+{ \
+    attribs[index++] = attribName; \
+    attribs[index++] = attribValue; \
+    assert((size_t) index < sizeof(attribs) / sizeof(attribs[0])); \
+}
+
+// Prepare for creation of the OpenGL context
+//
+int _glfwCreateContext(_GLFWwindow* window,
+                       const _GLFWwndconfig* wndconfig,
+                       const _GLFWfbconfig* fbconfig)
+{
+    int attribs[40];
+    GLXFBConfig native;
+    GLXContext share = NULL;
+
+    if (wndconfig->share)
+        share = wndconfig->share->glx.context;
+
+    if (!chooseFBConfig(fbconfig, &native))
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "GLX: Failed to find a suitable GLXFBConfig");
+        return GL_FALSE;
+    }
+
+    // Retrieve the corresponding visual
+    if (_glfw.glx.SGIX_fbconfig)
+    {
+        window->glx.visual =
+            _glfw.glx.GetVisualFromFBConfigSGIX(_glfw.x11.display, native);
+    }
+    else
+        window->glx.visual = glXGetVisualFromFBConfig(_glfw.x11.display, native);
+
+    if (window->glx.visual == NULL)
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "GLX: Failed to retrieve visual for GLXFBConfig");
+        return GL_FALSE;
+    }
+
+    if (wndconfig->clientAPI == GLFW_OPENGL_ES_API)
+    {
+        if (!_glfw.glx.ARB_create_context ||
+            !_glfw.glx.ARB_create_context_profile ||
+            !_glfw.glx.EXT_create_context_es2_profile)
+        {
+            _glfwInputError(GLFW_API_UNAVAILABLE,
+                            "GLX: OpenGL ES requested but "
+                            "GLX_EXT_create_context_es2_profile is unavailable");
+            return GL_FALSE;
+        }
+    }
+
+    if (wndconfig->glForward)
+    {
+        if (!_glfw.glx.ARB_create_context)
+        {
+            _glfwInputError(GLFW_VERSION_UNAVAILABLE,
+                            "GLX: Forward compatibility requested but "
+                            "GLX_ARB_create_context_profile is unavailable");
+            return GL_FALSE;
+        }
+    }
+
+    if (wndconfig->glProfile)
+    {
+        if (!_glfw.glx.ARB_create_context ||
+            !_glfw.glx.ARB_create_context_profile)
+        {
+            _glfwInputError(GLFW_VERSION_UNAVAILABLE,
+                            "GLX: An OpenGL profile requested but "
+                            "GLX_ARB_create_context_profile is unavailable");
+            return GL_FALSE;
+        }
+    }
+
+    _glfwGrabXErrorHandler();
+
+    if (_glfw.glx.ARB_create_context)
+    {
+        int index = 0, mask = 0, flags = 0, strategy = 0;
+
+        if (wndconfig->clientAPI == GLFW_OPENGL_API)
+        {
+            if (wndconfig->glForward)
+                flags |= GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB;
+
+            if (wndconfig->glDebug)
+                flags |= GLX_CONTEXT_DEBUG_BIT_ARB;
+
+            if (wndconfig->glProfile)
+            {
+                if (wndconfig->glProfile == GLFW_OPENGL_CORE_PROFILE)
+                    mask |= GLX_CONTEXT_CORE_PROFILE_BIT_ARB;
+                else if (wndconfig->glProfile == GLFW_OPENGL_COMPAT_PROFILE)
+                    mask |= GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB;
+            }
+        }
+        else
+            mask |= GLX_CONTEXT_ES2_PROFILE_BIT_EXT;
+
+        if (wndconfig->glRobustness != GLFW_NO_ROBUSTNESS)
+        {
+            if (_glfw.glx.ARB_create_context_robustness)
+            {
+                if (wndconfig->glRobustness == GLFW_NO_RESET_NOTIFICATION)
+                    strategy = GLX_NO_RESET_NOTIFICATION_ARB;
+                else if (wndconfig->glRobustness == GLFW_LOSE_CONTEXT_ON_RESET)
+                    strategy = GLX_LOSE_CONTEXT_ON_RESET_ARB;
+
+                flags |= GLX_CONTEXT_ROBUST_ACCESS_BIT_ARB;
+            }
+        }
+
+        if (wndconfig->glMajor != 1 || wndconfig->glMinor != 0)
+        {
+            // NOTE: Only request an explicitly versioned context when
+            // necessary, as explicitly requesting version 1.0 does not always
+            // return the highest available version
+
+            setGLXattrib(GLX_CONTEXT_MAJOR_VERSION_ARB, wndconfig->glMajor);
+            setGLXattrib(GLX_CONTEXT_MINOR_VERSION_ARB, wndconfig->glMinor);
+        }
+
+        if (mask)
+            setGLXattrib(GLX_CONTEXT_PROFILE_MASK_ARB, mask);
+
+        if (flags)
+            setGLXattrib(GLX_CONTEXT_FLAGS_ARB, flags);
+
+        if (strategy)
+            setGLXattrib(GLX_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB, strategy);
+
+        setGLXattrib(None, None);
+
+        window->glx.context =
+            _glfw.glx.CreateContextAttribsARB(_glfw.x11.display,
+                                              native,
+                                              share,
+                                              True,
+                                              attribs);
+
+        if (window->glx.context == NULL)
+        {
+            // HACK: This is a fallback for the broken Mesa implementation of
+            // GLX_ARB_create_context_profile, which fails default 1.0 context
+            // creation with a GLXBadProfileARB error in violation of the spec
+            if (_glfw.x11.errorCode == _glfw.glx.errorBase + GLXBadProfileARB &&
+                wndconfig->clientAPI == GLFW_OPENGL_API &&
+                wndconfig->glProfile == GLFW_OPENGL_ANY_PROFILE &&
+                wndconfig->glForward == GL_FALSE)
+            {
+                window->glx.context = createLegacyContext(window, native, share);
+            }
+        }
+    }
+    else
+        window->glx.context = createLegacyContext(window, native, share);
+
+    _glfwReleaseXErrorHandler();
+
+    if (window->glx.context == NULL)
+    {
+        _glfwInputXError(GLFW_PLATFORM_ERROR, "GLX: Failed to create context");
+        return GL_FALSE;
+    }
+
+    return GL_TRUE;
+}
+
+#undef setGLXattrib
+
+// Destroy the OpenGL context
+//
+void _glfwDestroyContext(_GLFWwindow* window)
+{
+    if (window->glx.visual)
+    {
+        XFree(window->glx.visual);
+        window->glx.visual = NULL;
+    }
+
+    if (window->glx.context)
+    {
+        glXDestroyContext(_glfw.x11.display, window->glx.context);
+        window->glx.context = NULL;
+    }
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW platform API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+void _glfwPlatformMakeContextCurrent(_GLFWwindow* window)
+{
+    if (window)
+    {
+        glXMakeCurrent(_glfw.x11.display,
+                       window->x11.handle,
+                       window->glx.context);
+    }
+    else
+        glXMakeCurrent(_glfw.x11.display, None, NULL);
+
+    pthread_setspecific(_glfw.glx.current, window);
+}
+
+_GLFWwindow* _glfwPlatformGetCurrentContext(void)
+{
+    return (_GLFWwindow*) pthread_getspecific(_glfw.glx.current);
+}
+
+void _glfwPlatformSwapBuffers(_GLFWwindow* window)
+{
+    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 GLubyte* extensions;
+
+    // Get list of GLX extensions
+    extensions = (const GLubyte*) glXQueryExtensionsString(_glfw.x11.display,
+                                                           _glfw.x11.screen);
+    if (extensions != NULL)
+    {
+        if (_glfwStringInExtensionString(extension, extensions))
+            return GL_TRUE;
+    }
+
+    return GL_FALSE;
+}
+
+GLFWglproc _glfwPlatformGetProcAddress(const char* procname)
+{
+    return _glfw_glXGetProcAddress((const GLubyte*) procname);
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                        GLFW native API                       //////
+//////////////////////////////////////////////////////////////////////////
+
+GLFWAPI GLXContext glfwGetGLXContext(GLFWwindow* handle)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+    return window->glx.context;
+}
+

external/Box2D-2.3.1/Box2D/glfw/glx_platform.h

@@ -0,0 +1,123 @@
+//========================================================================
+// GLFW 3.0 GLX - 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 _glx_platform_h_
+#define _glx_platform_h_
+
+#define GLX_GLXEXT_LEGACY
+#include <GL/glx.h>
+
+// 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
+#include "../deps/GL/glxext.h"
+
+// Do we have support for dlopen/dlsym?
+#if defined(_GLFW_HAS_DLOPEN)
+ #include <dlfcn.h>
+#endif
+
+// We support four different ways for getting addresses for GL/GLX
+// extension functions: glXGetProcAddress, glXGetProcAddressARB,
+// glXGetProcAddressEXT, and dlsym
+#if defined(_GLFW_HAS_GLXGETPROCADDRESSARB)
+ #define _glfw_glXGetProcAddress(x) glXGetProcAddressARB(x)
+#elif defined(_GLFW_HAS_GLXGETPROCADDRESS)
+ #define _glfw_glXGetProcAddress(x) glXGetProcAddress(x)
+#elif defined(_GLFW_HAS_GLXGETPROCADDRESSEXT)
+ #define _glfw_glXGetProcAddress(x) glXGetProcAddressEXT(x)
+#elif defined(_GLFW_HAS_DLOPEN)
+ #define _glfw_glXGetProcAddress(x) dlsym(_glfw.glx.libGL, x)
+ #define _GLFW_DLOPEN_LIBGL
+#else
+ #error "No OpenGL entry point retrieval mechanism was enabled"
+#endif
+
+#define _GLFW_PLATFORM_FBCONFIG             GLXFBConfig     glx
+#define _GLFW_PLATFORM_CONTEXT_STATE        _GLFWcontextGLX glx
+#define _GLFW_PLATFORM_LIBRARY_OPENGL_STATE _GLFWlibraryGLX glx
+
+#ifndef GLX_MESA_swap_control
+typedef int (*PFNGLXSWAPINTERVALMESAPROC)(int);
+#endif
+
+
+//========================================================================
+// GLFW platform specific types
+//========================================================================
+
+//------------------------------------------------------------------------
+// Platform-specific OpenGL context structure
+//------------------------------------------------------------------------
+typedef struct _GLFWcontextGLX
+{
+    GLXContext      context; // OpenGL rendering context
+    XVisualInfo*    visual;  // Visual for selected GLXFBConfig
+
+} _GLFWcontextGLX;
+
+
+//------------------------------------------------------------------------
+// Platform-specific library global data for GLX
+//------------------------------------------------------------------------
+typedef struct _GLFWlibraryGLX
+{
+    // Server-side GLX version
+    int             versionMajor, versionMinor;
+    int             eventBase;
+    int             errorBase;
+
+    // TLS key for per-thread current context/window
+    pthread_key_t   current;
+
+    // GLX extensions
+    PFNGLXSWAPINTERVALSGIPROC             SwapIntervalSGI;
+    PFNGLXSWAPINTERVALEXTPROC             SwapIntervalEXT;
+    PFNGLXSWAPINTERVALMESAPROC            SwapIntervalMESA;
+    PFNGLXGETFBCONFIGATTRIBSGIXPROC       GetFBConfigAttribSGIX;
+    PFNGLXCHOOSEFBCONFIGSGIXPROC          ChooseFBConfigSGIX;
+    PFNGLXCREATECONTEXTWITHCONFIGSGIXPROC CreateContextWithConfigSGIX;
+    PFNGLXGETVISUALFROMFBCONFIGSGIXPROC   GetVisualFromFBConfigSGIX;
+    PFNGLXCREATECONTEXTATTRIBSARBPROC     CreateContextAttribsARB;
+    GLboolean       SGIX_fbconfig;
+    GLboolean       SGI_swap_control;
+    GLboolean       EXT_swap_control;
+    GLboolean       MESA_swap_control;
+    GLboolean       ARB_multisample;
+    GLboolean       ARB_framebuffer_sRGB;
+    GLboolean       ARB_create_context;
+    GLboolean       ARB_create_context_profile;
+    GLboolean       ARB_create_context_robustness;
+    GLboolean       EXT_create_context_es2_profile;
+
+#if defined(_GLFW_DLOPEN_LIBGL)
+    void*           libGL;  // dlopen handle for libGL.so
+#endif
+} _GLFWlibraryGLX;
+
+
+#endif // _glx_platform_h_

external/Box2D-2.3.1/Box2D/glfw/glxext.h

@@ -0,0 +1,838 @@
+#ifndef __glxext_h_
+#define __glxext_h_ 1
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+** Copyright (c) 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.
+*/
+/*
+** 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$ on $Date$
+*/
+
+#define GLX_GLXEXT_VERSION 20130710
+
+/* 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 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_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
+typedef XID GLXContextID;
+#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_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_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_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_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_output
+#define GLX_NV_video_output 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_output */
+
+#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

external/Box2D-2.3.1/Box2D/glfw/init.c

@@ -0,0 +1,197 @@
+//========================================================================
+// GLFW 3.0 - 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.
+//
+//========================================================================
+
+#include "internal.h"
+
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdarg.h>
+
+
+// Global state shared between compilation units of GLFW
+// These are documented in internal.h
+//
+GLboolean _glfwInitialized = GL_FALSE;
+_GLFWlibrary _glfw;
+
+
+// The current error callback
+// This is outside of _glfw so it can be initialized and usable before
+// glfwInit is called, which lets that function report errors
+//
+static GLFWerrorfun _glfwErrorCallback = NULL;
+
+
+// Returns a generic string representation of the specified error
+//
+static const char* getErrorString(int error)
+{
+    switch (error)
+    {
+        case GLFW_NOT_INITIALIZED:
+            return "The GLFW library is not initialized";
+        case GLFW_NO_CURRENT_CONTEXT:
+            return "There is no current context";
+        case GLFW_INVALID_ENUM:
+            return "Invalid argument for enum parameter";
+        case GLFW_INVALID_VALUE:
+            return "Invalid value for parameter";
+        case GLFW_OUT_OF_MEMORY:
+            return "Out of memory";
+        case GLFW_API_UNAVAILABLE:
+            return "The requested client API is unavailable";
+        case GLFW_VERSION_UNAVAILABLE:
+            return "The requested client API version is unavailable";
+        case GLFW_PLATFORM_ERROR:
+            return "A platform-specific error occurred";
+        case GLFW_FORMAT_UNAVAILABLE:
+            return "The requested format is unavailable";
+    }
+
+    return "ERROR: UNKNOWN ERROR TOKEN PASSED TO glfwErrorString";
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                         GLFW event API                       //////
+//////////////////////////////////////////////////////////////////////////
+
+void _glfwInputError(int error, const char* format, ...)
+{
+    if (_glfwErrorCallback)
+    {
+        char buffer[16384];
+        const char* description;
+
+        if (format)
+        {
+            int count;
+            va_list vl;
+
+            va_start(vl, format);
+            count = vsnprintf(buffer, sizeof(buffer), format, vl);
+            va_end(vl);
+
+            if (count < 0)
+                buffer[sizeof(buffer) - 1] = '\0';
+
+            description = buffer;
+        }
+        else
+            description = getErrorString(error);
+
+        _glfwErrorCallback(error, description);
+    }
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                        GLFW public API                       //////
+//////////////////////////////////////////////////////////////////////////
+
+GLFWAPI int glfwInit(void)
+{
+    if (_glfwInitialized)
+        return GL_TRUE;
+
+    memset(&_glfw, 0, sizeof(_glfw));
+
+    if (!_glfwPlatformInit())
+    {
+        _glfwPlatformTerminate();
+        return GL_FALSE;
+    }
+
+    _glfw.monitors = _glfwPlatformGetMonitors(&_glfw.monitorCount);
+    if (_glfw.monitors == NULL)
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR, "No monitors found");
+        _glfwPlatformTerminate();
+        return GL_FALSE;
+    }
+
+    _glfwInitialized = GL_TRUE;
+
+    // Not all window hints have zero as their default value
+    glfwDefaultWindowHints();
+
+    return GL_TRUE;
+}
+
+GLFWAPI void glfwTerminate(void)
+{
+    int i;
+
+    if (!_glfwInitialized)
+        return;
+
+    memset(&_glfw.callbacks, 0, sizeof(_glfw.callbacks));
+
+    // Close all remaining windows
+    while (_glfw.windowListHead)
+        glfwDestroyWindow((GLFWwindow*) _glfw.windowListHead);
+
+    for (i = 0;  i < _glfw.monitorCount;  i++)
+    {
+        _GLFWmonitor* monitor = _glfw.monitors[i];
+        if (monitor->originalRamp.size)
+            _glfwPlatformSetGammaRamp(monitor, &monitor->originalRamp);
+    }
+
+    _glfwDestroyMonitors(_glfw.monitors, _glfw.monitorCount);
+    _glfw.monitors = NULL;
+    _glfw.monitorCount = 0;
+
+    _glfwPlatformTerminate();
+
+    _glfwInitialized = GL_FALSE;
+}
+
+GLFWAPI void glfwGetVersion(int* major, int* minor, int* rev)
+{
+    if (major != NULL)
+        *major = GLFW_VERSION_MAJOR;
+
+    if (minor != NULL)
+        *minor = GLFW_VERSION_MINOR;
+
+    if (rev != NULL)
+        *rev = GLFW_VERSION_REVISION;
+}
+
+GLFWAPI const char* glfwGetVersionString(void)
+{
+    return _glfwPlatformGetVersionString();
+}
+
+GLFWAPI GLFWerrorfun glfwSetErrorCallback(GLFWerrorfun cbfun)
+{
+    _GLFW_SWAP_POINTERS(_glfwErrorCallback, cbfun);
+    return cbfun;
+}
+

external/Box2D-2.3.1/Box2D/glfw/input.c

@@ -0,0 +1,397 @@
+//========================================================================
+// GLFW 3.0 - 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.
+//
+//========================================================================
+
+#include "internal.h"
+
+// 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)
+{
+    int oldMode;
+
+    if (newMode != GLFW_CURSOR_NORMAL &&
+        newMode != GLFW_CURSOR_HIDDEN &&
+        newMode != GLFW_CURSOR_DISABLED)
+    {
+        _glfwInputError(GLFW_INVALID_ENUM, NULL);
+        return;
+    }
+
+    oldMode = window->cursorMode;
+    if (oldMode == newMode)
+        return;
+
+    if (window == _glfw.focusedWindow)
+    {
+        if (oldMode == GLFW_CURSOR_DISABLED)
+        {
+            window->cursorPosX = _glfw.cursorPosX;
+            window->cursorPosY = _glfw.cursorPosY;
+
+            _glfwPlatformSetCursorPos(window, _glfw.cursorPosX, _glfw.cursorPosY);
+        }
+        else if (newMode == GLFW_CURSOR_DISABLED)
+        {
+            int width, height;
+
+            _glfw.cursorPosX = window->cursorPosX;
+            _glfw.cursorPosY = window->cursorPosY;
+
+            _glfwPlatformGetWindowSize(window, &width, &height);
+            _glfwPlatformSetCursorPos(window, width / 2.0, height / 2.0);
+        }
+
+        _glfwPlatformSetCursorMode(window, newMode);
+    }
+
+    window->cursorMode = newMode;
+}
+
+// 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->key[i] == _GLFW_STICK)
+                window->key[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->mouseButton[i] == _GLFW_STICK)
+                window->mouseButton[i] = GLFW_RELEASE;
+        }
+    }
+
+    window->stickyMouseButtons = enabled;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                         GLFW event API                       //////
+//////////////////////////////////////////////////////////////////////////
+
+void _glfwInputKey(_GLFWwindow* window, int key, int scancode, int action, int mods)
+{
+    GLboolean repeated = GL_FALSE;
+
+    if (action == GLFW_RELEASE && window->key[key] == GLFW_RELEASE)
+        return;
+
+    if (key >= 0 && key <= GLFW_KEY_LAST)
+    {
+        if (action == GLFW_PRESS && window->key[key] == GLFW_PRESS)
+            repeated = GL_TRUE;
+
+        if (action == GLFW_RELEASE && window->stickyKeys)
+            window->key[key] = _GLFW_STICK;
+        else
+            window->key[key] = (char) action;
+    }
+
+    if (repeated)
+        action = GLFW_REPEAT;
+
+    if (window->callbacks.key)
+        window->callbacks.key((GLFWwindow*) window, key, scancode, action, mods);
+}
+
+void _glfwInputChar(_GLFWwindow* window, unsigned int character)
+{
+    if (character < 32 || (character > 126 && character < 160))
+        return;
+
+    if (window->callbacks.character)
+        window->callbacks.character((GLFWwindow*) window, character);
+}
+
+void _glfwInputScroll(_GLFWwindow* window, double xoffset, double yoffset)
+{
+    if (window->callbacks.scroll)
+        window->callbacks.scroll((GLFWwindow*) window, xoffset, yoffset);
+}
+
+void _glfwInputMouseClick(_GLFWwindow* window, int button, int action, int mods)
+{
+    if (button < 0 || button > GLFW_MOUSE_BUTTON_LAST)
+        return;
+
+    // Register mouse button action
+    if (action == GLFW_RELEASE && window->stickyMouseButtons)
+        window->mouseButton[button] = _GLFW_STICK;
+    else
+        window->mouseButton[button] = (char) action;
+
+    if (window->callbacks.mouseButton)
+        window->callbacks.mouseButton((GLFWwindow*) window, button, action, mods);
+}
+
+void _glfwInputCursorMotion(_GLFWwindow* window, double x, double y)
+{
+    if (window->cursorMode == GLFW_CURSOR_DISABLED)
+    {
+        if (x == 0.0 && y == 0.0)
+            return;
+
+        window->cursorPosX += x;
+        window->cursorPosY += y;
+    }
+    else
+    {
+        if (window->cursorPosX == x && window->cursorPosY == y)
+            return;
+
+        window->cursorPosX = x;
+        window->cursorPosY = y;
+    }
+
+    if (window->callbacks.cursorPos)
+    {
+        window->callbacks.cursorPos((GLFWwindow*) window,
+                                    window->cursorPosX,
+                                    window->cursorPosY);
+    }
+}
+
+void _glfwInputCursorEnter(_GLFWwindow* window, int entered)
+{
+    if (window->callbacks.cursorEnter)
+        window->callbacks.cursorEnter((GLFWwindow*) window, entered);
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                        GLFW public API                       //////
+//////////////////////////////////////////////////////////////////////////
+
+GLFWAPI int glfwGetInputMode(GLFWwindow* handle, int mode)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+
+    _GLFW_REQUIRE_INIT_OR_RETURN(0);
+
+    switch (mode)
+    {
+        case GLFW_CURSOR:
+            return window->cursorMode;
+        case GLFW_STICKY_KEYS:
+            return window->stickyKeys;
+        case GLFW_STICKY_MOUSE_BUTTONS:
+            return window->stickyMouseButtons;
+        default:
+            _glfwInputError(GLFW_INVALID_ENUM, NULL);
+            return 0;
+    }
+}
+
+GLFWAPI void glfwSetInputMode(GLFWwindow* handle, int mode, int value)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+
+    _GLFW_REQUIRE_INIT();
+
+    switch (mode)
+    {
+        case GLFW_CURSOR:
+            setCursorMode(window, value);
+            break;
+        case GLFW_STICKY_KEYS:
+            setStickyKeys(window, value ? GL_TRUE : GL_FALSE);
+            break;
+        case GLFW_STICKY_MOUSE_BUTTONS:
+            setStickyMouseButtons(window, value ? GL_TRUE : GL_FALSE);
+            break;
+        default:
+            _glfwInputError(GLFW_INVALID_ENUM, NULL);
+            break;
+    }
+}
+
+GLFWAPI int glfwGetKey(GLFWwindow* handle, int key)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+
+    _GLFW_REQUIRE_INIT_OR_RETURN(GLFW_RELEASE);
+
+    if (key < 0 || key > GLFW_KEY_LAST)
+    {
+        _glfwInputError(GLFW_INVALID_ENUM, "The specified key is invalid");
+        return GLFW_RELEASE;
+    }
+
+    if (window->key[key] == _GLFW_STICK)
+    {
+        // Sticky mode: release key now
+        window->key[key] = GLFW_RELEASE;
+        return GLFW_PRESS;
+    }
+
+    return (int) window->key[key];
+}
+
+GLFWAPI int glfwGetMouseButton(GLFWwindow* handle, int button)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+
+    _GLFW_REQUIRE_INIT_OR_RETURN(GLFW_RELEASE);
+
+    if (button < 0 || button > GLFW_MOUSE_BUTTON_LAST)
+    {
+        _glfwInputError(GLFW_INVALID_ENUM,
+                        "The specified mouse button is invalid");
+        return GLFW_RELEASE;
+    }
+
+    if (window->mouseButton[button] == _GLFW_STICK)
+    {
+        // Sticky mode: release mouse button now
+        window->mouseButton[button] = GLFW_RELEASE;
+        return GLFW_PRESS;
+    }
+
+    return (int) window->mouseButton[button];
+}
+
+GLFWAPI void glfwGetCursorPos(GLFWwindow* handle, double* xpos, double* ypos)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+
+    _GLFW_REQUIRE_INIT();
+
+    if (xpos)
+        *xpos = window->cursorPosX;
+
+    if (ypos)
+        *ypos = window->cursorPosY;
+}
+
+GLFWAPI void glfwSetCursorPos(GLFWwindow* handle, double xpos, double ypos)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+
+    _GLFW_REQUIRE_INIT();
+
+    if (_glfw.focusedWindow != window)
+        return;
+
+    // Don't do anything if the cursor position did not change
+    if (xpos == window->cursorPosX && ypos == window->cursorPosY)
+        return;
+
+    // Set GLFW cursor position
+    window->cursorPosX = xpos;
+    window->cursorPosY = ypos;
+
+    // Do not move physical cursor if it is disabled
+    if (window->cursorMode == GLFW_CURSOR_DISABLED)
+        return;
+
+    // Update physical cursor position
+    _glfwPlatformSetCursorPos(window, xpos, ypos);
+}
+
+GLFWAPI GLFWkeyfun glfwSetKeyCallback(GLFWwindow* handle, GLFWkeyfun cbfun)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+    _GLFW_SWAP_POINTERS(window->callbacks.key, cbfun);
+    return cbfun;
+}
+
+GLFWAPI GLFWcharfun glfwSetCharCallback(GLFWwindow* handle, GLFWcharfun cbfun)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+    _GLFW_SWAP_POINTERS(window->callbacks.character, cbfun);
+    return cbfun;
+}
+
+GLFWAPI GLFWmousebuttonfun glfwSetMouseButtonCallback(GLFWwindow* handle,
+                                                      GLFWmousebuttonfun cbfun)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+    _GLFW_SWAP_POINTERS(window->callbacks.mouseButton, cbfun);
+    return cbfun;
+}
+
+GLFWAPI GLFWcursorposfun glfwSetCursorPosCallback(GLFWwindow* handle,
+                                                  GLFWcursorposfun cbfun)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+    _GLFW_SWAP_POINTERS(window->callbacks.cursorPos, cbfun);
+    return cbfun;
+}
+
+GLFWAPI GLFWcursorenterfun glfwSetCursorEnterCallback(GLFWwindow* handle,
+                                                      GLFWcursorenterfun cbfun)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+    _GLFW_SWAP_POINTERS(window->callbacks.cursorEnter, cbfun);
+    return cbfun;
+}
+
+GLFWAPI GLFWscrollfun glfwSetScrollCallback(GLFWwindow* handle,
+                                            GLFWscrollfun cbfun)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+    _GLFW_SWAP_POINTERS(window->callbacks.scroll, cbfun);
+    return cbfun;
+}
+

external/Box2D-2.3.1/Box2D/glfw/internal.h

@@ -0,0 +1,765 @@
+//========================================================================
+// GLFW 3.0 - 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 _internal_h_
+#define _internal_h_
+
+
+#include "config.h"
+
+#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
+
+#include "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 "glext.h"
+#endif
+
+typedef struct _GLFWhints       _GLFWhints;
+typedef struct _GLFWwndconfig   _GLFWwndconfig;
+typedef struct _GLFWfbconfig    _GLFWfbconfig;
+typedef struct _GLFWwindow      _GLFWwindow;
+typedef struct _GLFWlibrary     _GLFWlibrary;
+typedef struct _GLFWmonitor     _GLFWmonitor;
+
+#if defined(_GLFW_COCOA)
+ #include "cocoa_platform.h"
+#elif defined(_GLFW_WIN32)
+ #include "win32_platform.h"
+#elif defined(_GLFW_X11)
+ #include "x11_platform.h"
+#else
+ #error "No supported window creation API selected"
+#endif
+
+
+//========================================================================
+// Doxygen group definitions
+//========================================================================
+
+/*! @defgroup platform Platform interface
+ *  @brief The interface implemented by the platform-specific code.
+ *
+ *  The platform API is the interface exposed by the platform-specific code for
+ *  each platform and is called by the shared code of the public API It mirrors
+ *  the public API except it uses objects instead of handles.
+ */
+/*! @defgroup event Event interface
+ *  @brief The interface used by the platform-specific code to report events.
+ *
+ *  The event API is used by the platform-specific code to notify the shared
+ *  code of events that can be translated into state changes and/or callback
+ *  calls.
+ */
+/*! @defgroup utility Utility functions
+ *  @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
+ *  called by the platform-specific code
+ */
+
+
+//========================================================================
+// Helper macros
+//========================================================================
+
+// Checks for whether the library has been intitalized
+#define _GLFW_REQUIRE_INIT()                         \
+    if (!_glfwInitialized)                           \
+    {                                                \
+        _glfwInputError(GLFW_NOT_INITIALIZED, NULL); \
+        return;                                      \
+    }
+#define _GLFW_REQUIRE_INIT_OR_RETURN(x)              \
+    if (!_glfwInitialized)                           \
+    {                                                \
+        _glfwInputError(GLFW_NOT_INITIALIZED, NULL); \
+        return x;                                    \
+    }
+
+// Swaps the provided pointers
+#define _GLFW_SWAP_POINTERS(x, y) \
+    {                             \
+        void* t;                  \
+        t = x;                    \
+        x = y;                    \
+        y = t;                    \
+    }
+
+
+//========================================================================
+// Internal types
+//========================================================================
+
+/*! @brief Window and context configuration.
+ *
+ *  Parameters relating to the creation of the context and window but not
+ *  directly related to the framebuffer.  This is used to pass window and
+ *  context creation parameters from shared code to the platform API.
+ */
+struct _GLFWwndconfig
+{
+    int           width;
+    int           height;
+    const char*   title;
+    GLboolean     resizable;
+    GLboolean     visible;
+    GLboolean     decorated;
+    int           clientAPI;
+    int           glMajor;
+    int           glMinor;
+    GLboolean     glForward;
+    GLboolean     glDebug;
+    int           glProfile;
+    int           glRobustness;
+    _GLFWmonitor* monitor;
+    _GLFWwindow*  share;
+};
+
+
+/*! @brief Framebuffer configuration.
+ *
+ *  This describes buffers and their sizes.  It also contains
+ *  a platform-specific ID used to map back to the backend API's object.
+ *
+ *  It is used to pass framebuffer parameters from shared code to the platform
+ *  API and also to enumerate and select available framebuffer configs.
+ */
+struct _GLFWfbconfig
+{
+    int         redBits;
+    int         greenBits;
+    int         blueBits;
+    int         alphaBits;
+    int         depthBits;
+    int         stencilBits;
+    int         accumRedBits;
+    int         accumGreenBits;
+    int         accumBlueBits;
+    int         accumAlphaBits;
+    int         auxBuffers;
+    GLboolean   stereo;
+    int         samples;
+    GLboolean   sRGB;
+
+    // This is defined in the context API's platform.h
+    _GLFW_PLATFORM_FBCONFIG;
+};
+
+
+/*! @brief Window and context structure.
+ */
+struct _GLFWwindow
+{
+    struct _GLFWwindow* next;
+
+    // Window settings and state
+    GLboolean           iconified;
+    GLboolean           resizable;
+    GLboolean           decorated;
+    GLboolean           visible;
+    GLboolean           closed;
+    void*               userPointer;
+    GLFWvidmode         videoMode;
+    _GLFWmonitor*       monitor;
+
+    // Window input state
+    GLboolean           stickyKeys;
+    GLboolean           stickyMouseButtons;
+    double              cursorPosX, cursorPosY;
+    int                 cursorMode;
+    char                mouseButton[GLFW_MOUSE_BUTTON_LAST + 1];
+    char                key[GLFW_KEY_LAST + 1];
+
+    // OpenGL extensions and context attributes
+    int                 clientAPI;
+    int                 glMajor, glMinor, glRevision;
+    GLboolean           glForward, glDebug;
+    int                 glProfile;
+    int                 glRobustness;
+#if defined(_GLFW_USE_OPENGL)
+    PFNGLGETSTRINGIPROC GetStringi;
+#endif
+
+    struct {
+        GLFWwindowposfun        pos;
+        GLFWwindowsizefun       size;
+        GLFWwindowclosefun      close;
+        GLFWwindowrefreshfun    refresh;
+        GLFWwindowfocusfun      focus;
+        GLFWwindowiconifyfun    iconify;
+        GLFWframebuffersizefun  fbsize;
+        GLFWmousebuttonfun      mouseButton;
+        GLFWcursorposfun        cursorPos;
+        GLFWcursorenterfun      cursorEnter;
+        GLFWscrollfun           scroll;
+        GLFWkeyfun              key;
+        GLFWcharfun             character;
+    } callbacks;
+
+    // This is defined in the window API's platform.h
+    _GLFW_PLATFORM_WINDOW_STATE;
+    // This is defined in the context API's platform.h
+    _GLFW_PLATFORM_CONTEXT_STATE;
+};
+
+
+/*! @brief Monitor structure.
+ */
+struct _GLFWmonitor
+{
+    char*           name;
+
+    // Physical dimensions in millimeters.
+    int             widthMM, heightMM;
+
+    GLFWvidmode*    modes;
+    int             modeCount;
+    GLFWvidmode     currentMode;
+
+    GLFWgammaramp   originalRamp;
+    GLFWgammaramp   currentRamp;
+
+    // This is defined in the window API's platform.h
+    _GLFW_PLATFORM_MONITOR_STATE;
+};
+
+
+/*! @brief Library global data.
+ */
+struct _GLFWlibrary
+{
+    struct {
+        int         redBits;
+        int         greenBits;
+        int         blueBits;
+        int         alphaBits;
+        int         depthBits;
+        int         stencilBits;
+        int         accumRedBits;
+        int         accumGreenBits;
+        int         accumBlueBits;
+        int         accumAlphaBits;
+        int         auxBuffers;
+        GLboolean   stereo;
+        GLboolean   resizable;
+        GLboolean   visible;
+        GLboolean   decorated;
+        int         samples;
+        GLboolean   sRGB;
+        int         refreshRate;
+        int         clientAPI;
+        int         glMajor;
+        int         glMinor;
+        GLboolean   glForward;
+        GLboolean   glDebug;
+        int         glProfile;
+        int         glRobustness;
+    } hints;
+
+    double          cursorPosX, cursorPosY;
+
+    _GLFWwindow*    windowListHead;
+    _GLFWwindow*    focusedWindow;
+
+    _GLFWmonitor**  monitors;
+    int             monitorCount;
+
+    struct {
+        GLFWmonitorfun  monitor;
+    } callbacks;
+
+    // This is defined in the window API's platform.h
+    _GLFW_PLATFORM_LIBRARY_WINDOW_STATE;
+    // This is defined in the context API's platform.h
+    _GLFW_PLATFORM_LIBRARY_OPENGL_STATE;
+};
+
+
+//========================================================================
+// Global state shared between compilation units of GLFW
+//========================================================================
+
+/*! @brief Flag indicating whether GLFW has been successfully initialized.
+ */
+extern GLboolean _glfwInitialized;
+
+/*! @brief All global data protected by @ref _glfwInitialized.
+ *  This should only be touched after a call to @ref glfwInit that has not been
+ *  followed by a call to @ref glfwTerminate.
+ */
+extern _GLFWlibrary _glfw;
+
+
+//========================================================================
+// Platform API functions
+//========================================================================
+
+/*! @brief Initializes the platform-specific part of the library.
+ *  @return `GL_TRUE` if successful, or `GL_FALSE` if an error occurred.
+ *  @ingroup platform
+ */
+int _glfwPlatformInit(void);
+
+/*! @brief Terminates the platform-specific part of the library.
+ *  @ingroup platform
+ */
+void _glfwPlatformTerminate(void);
+
+/*! @copydoc glfwGetVersionString
+ *  @ingroup platform
+ *
+ *  @note The returned string must be available for the duration of the program.
+ *
+ *  @note The returned string must not change for the duration of the program.
+ */
+const char* _glfwPlatformGetVersionString(void);
+
+/*! @copydoc glfwSetCursorPos
+ *  @ingroup platform
+ */
+void _glfwPlatformSetCursorPos(_GLFWwindow* window, double xpos, double ypos);
+
+/*! @brief Sets up the specified cursor mode for the specified window.
+ *  @param[in] window The window whose cursor mode to change.
+ *  @param[in] mode The desired cursor mode.
+ *  @ingroup platform
+ */
+void _glfwPlatformSetCursorMode(_GLFWwindow* window, int mode);
+
+/*! @copydoc glfwGetMonitors
+ *  @ingroup platform
+ */
+_GLFWmonitor** _glfwPlatformGetMonitors(int* count);
+
+/*! @brief Checks whether two monitor objects represent the same monitor.
+ *
+ *  @param[in] first The first monitor.
+ *  @param[in] second The second monitor.
+ *  @return @c GL_TRUE if the monitor objects represent the same monitor, or @c
+ *  GL_FALSE otherwise.
+ *  @ingroup platform
+ */
+GLboolean _glfwPlatformIsSameMonitor(_GLFWmonitor* first, _GLFWmonitor* second);
+
+/*! @copydoc glfwGetMonitorPos
+ *  @ingroup platform
+ */
+void _glfwPlatformGetMonitorPos(_GLFWmonitor* monitor, int* xpos, int* ypos);
+
+/*! @copydoc glfwGetVideoModes
+ *  @ingroup platform
+ */
+GLFWvidmode* _glfwPlatformGetVideoModes(_GLFWmonitor* monitor, int* count);
+
+/*! @ingroup platform
+ */
+void _glfwPlatformGetVideoMode(_GLFWmonitor* monitor, GLFWvidmode* mode);
+
+/*! @copydoc glfwGetGammaRamp
+ *  @ingroup platform
+ */
+void _glfwPlatformGetGammaRamp(_GLFWmonitor* monitor, GLFWgammaramp* ramp);
+
+/*! @copydoc glfwSetGammaRamp
+ *  @ingroup platform
+ */
+void _glfwPlatformSetGammaRamp(_GLFWmonitor* monitor, const GLFWgammaramp* ramp);
+
+/*! @copydoc glfwSetClipboardString
+ *  @ingroup platform
+ */
+void _glfwPlatformSetClipboardString(_GLFWwindow* window, const char* string);
+
+/*! @copydoc glfwGetClipboardString
+ *  @ingroup platform
+ *
+ *  @note The returned string must be valid until the next call to @ref
+ *  _glfwPlatformGetClipboardString or @ref _glfwPlatformSetClipboardString.
+ */
+const char* _glfwPlatformGetClipboardString(_GLFWwindow* window);
+
+/*! @copydoc glfwJoystickPresent
+ *  @ingroup platform
+ */
+int _glfwPlatformJoystickPresent(int joy);
+
+/*! @copydoc glfwGetJoystickAxes
+ *  @ingroup platform
+ */
+const float* _glfwPlatformGetJoystickAxes(int joy, int* count);
+
+/*! @copydoc glfwGetJoystickButtons
+ *  @ingroup platform
+ */
+const unsigned char* _glfwPlatformGetJoystickButtons(int joy, int* count);
+
+/*! @copydoc glfwGetJoystickName
+ *  @ingroup platform
+ */
+const char* _glfwPlatformGetJoystickName(int joy);
+
+/*! @copydoc glfwGetTime
+ *  @ingroup platform
+ */
+double _glfwPlatformGetTime(void);
+
+/*! @copydoc glfwSetTime
+ *  @ingroup platform
+ */
+void _glfwPlatformSetTime(double time);
+
+/*! @ingroup platform
+ */
+int _glfwPlatformCreateWindow(_GLFWwindow* window,
+                              const _GLFWwndconfig* wndconfig,
+                              const _GLFWfbconfig* fbconfig);
+
+/*! @ingroup platform
+ */
+void _glfwPlatformDestroyWindow(_GLFWwindow* window);
+
+/*! @copydoc glfwSetWindowTitle
+ *  @ingroup platform
+ */
+void _glfwPlatformSetWindowTitle(_GLFWwindow* window, const char* title);
+
+/*! @copydoc glfwGetWindowPos
+ *  @ingroup platform
+ */
+void _glfwPlatformGetWindowPos(_GLFWwindow* window, int* xpos, int* ypos);
+
+/*! @copydoc glfwSetWindowPos
+ *  @ingroup platform
+ */
+void _glfwPlatformSetWindowPos(_GLFWwindow* window, int xpos, int ypos);
+
+/*! @copydoc glfwGetWindowSize
+ *  @ingroup platform
+ */
+void _glfwPlatformGetWindowSize(_GLFWwindow* window, int* width, int* height);
+
+/*! @copydoc glfwSetWindowSize
+ *  @ingroup platform
+ */
+void _glfwPlatformSetWindowSize(_GLFWwindow* window, int width, int height);
+
+/*! @copydoc glfwGetFramebufferSize
+ *  @ingroup platform
+ */
+void _glfwPlatformGetFramebufferSize(_GLFWwindow* window, int* width, int* height);
+
+/*! @copydoc glfwIconifyWindow
+ *  @ingroup platform
+ */
+void _glfwPlatformIconifyWindow(_GLFWwindow* window);
+
+/*! @copydoc glfwRestoreWindow
+ *  @ingroup platform
+ */
+void _glfwPlatformRestoreWindow(_GLFWwindow* window);
+
+/*! @copydoc glfwShowWindow
+ *  @ingroup platform
+ */
+void _glfwPlatformShowWindow(_GLFWwindow* window);
+
+/*! @copydoc glfwHideWindow
+ *  @ingroup platform
+ */
+void _glfwPlatformHideWindow(_GLFWwindow* window);
+
+/*! @copydoc glfwPollEvents
+ *  @ingroup platform
+ */
+void _glfwPlatformPollEvents(void);
+
+/*! @copydoc glfwWaitEvents
+ *  @ingroup platform
+ */
+void _glfwPlatformWaitEvents(void);
+
+/*! @copydoc glfwMakeContextCurrent
+ *  @ingroup platform
+ */
+void _glfwPlatformMakeContextCurrent(_GLFWwindow* window);
+
+/*! @copydoc glfwGetCurrentContext
+ *  @ingroup platform
+ */
+_GLFWwindow* _glfwPlatformGetCurrentContext(void);
+
+/*! @copydoc glfwSwapBuffers
+ *  @ingroup platform
+ */
+void _glfwPlatformSwapBuffers(_GLFWwindow* window);
+
+/*! @copydoc glfwSwapInterval
+ *  @ingroup platform
+ */
+void _glfwPlatformSwapInterval(int interval);
+
+/*! @ingroup platform
+ */
+int _glfwPlatformExtensionSupported(const char* extension);
+
+/*! @copydoc glfwGetProcAddress
+ *  @ingroup platform
+ */
+GLFWglproc _glfwPlatformGetProcAddress(const char* procname);
+
+
+//========================================================================
+// Event API functions
+//========================================================================
+
+/*! @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`
+ *  if it lost focus.
+ *  @ingroup event
+ */
+void _glfwInputWindowFocus(_GLFWwindow* window, GLboolean focused);
+
+/*! @brief Notifies shared code of a window movement event.
+ *  @param[in] window The window that received the event.
+ *  @param[in] xpos The new x-coordinate of the client area of the window.
+ *  @param[in] ypos The new y-coordinate of the client area of the window.
+ *  @ingroup event
+ */
+void _glfwInputWindowPos(_GLFWwindow* window, int xpos, int ypos);
+
+/*! @brief Notifies shared code of a window resize event.
+ *  @param[in] window The window that received the event.
+ *  @param[in] width The new width of the client area of the window.
+ *  @param[in] height The new height of the client area of the window.
+ *  @ingroup event
+ */
+void _glfwInputWindowSize(_GLFWwindow* window, int width, int height);
+
+/*! @brief Notifies shared code of a framebuffer resize event.
+ *  @param[in] window The window that received the event.
+ *  @param[in] width The new width, in pixels, of the framebuffer.
+ *  @param[in] height The new height, in pixels, of the framebuffer.
+ *  @ingroup event
+ */
+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.
+ *  @ingroup event
+ */
+void _glfwInputWindowIconify(_GLFWwindow* window, int iconified);
+
+/*! @brief Notifies shared code of a window show/hide event.
+ *  @param[in] window The window that received the event.
+ *  @param[in] visible `GL_TRUE` if the window was shown, or `GL_FALSE` if it
+ *  was hidden.
+ *  @ingroup event
+ */
+void _glfwInputWindowVisibility(_GLFWwindow* window, int visible);
+
+/*! @brief Notifies shared code of a window damage event.
+ *  @param[in] window The window that received the event.
+ */
+void _glfwInputWindowDamage(_GLFWwindow* window);
+
+/*! @brief Notifies shared code of a window close request event
+ *  @param[in] window The window that received the event.
+ *  @ingroup event
+ */
+void _glfwInputWindowCloseRequest(_GLFWwindow* window);
+
+/*! @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.
+ *  @param[in] scancode The system-specific scan code of the key.
+ *  @param[in] action @ref GLFW_PRESS or @ref GLFW_RELEASE.
+ *  @param[in] mods The modifiers pressed when the event was generated.
+ *  @ingroup event
+ */
+void _glfwInputKey(_GLFWwindow* window, int key, int scancode, int action, int mods);
+
+/*! @brief Notifies shared code of a Unicode character input event.
+ *  @param[in] window The window that received the event.
+ *  @param[in] character The Unicode code point of the input character.
+ *  @ingroup event
+ */
+void _glfwInputChar(_GLFWwindow* window, unsigned int character);
+
+/*! @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.
+ *  @ingroup event
+ */
+void _glfwInputScroll(_GLFWwindow* window, double x, double y);
+
+/*! @brief Notifies shared code of a mouse button click event.
+ *  @param[in] window The window that received the event.
+ *  @param[in] button The button that was pressed or released.
+ *  @param[in] action @ref GLFW_PRESS or @ref GLFW_RELEASE.
+ *  @ingroup event
+ */
+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
+ *  of the client area of the window.
+ *  @ingroup event
+ */
+void _glfwInputCursorMotion(_GLFWwindow* window, double x, double y);
+
+/*! @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.
+ *  @ingroup event
+ */
+void _glfwInputCursorEnter(_GLFWwindow* window, int entered);
+
+/*! @ingroup event
+ */
+void _glfwInputMonitorChange(void);
+
+/*! @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
+ */
+void _glfwInputError(int error, const char* format, ...);
+
+
+//========================================================================
+// Utility functions
+//========================================================================
+
+/*! @ingroup utility
+ */
+const GLFWvidmode* _glfwChooseVideoMode(_GLFWmonitor* monitor,
+                                        const GLFWvidmode* desired);
+
+/*! @brief Performs lexical comparison between two @ref GLFWvidmode structures.
+ *  @ingroup utility
+ */
+int _glfwCompareVideoModes(const GLFWvidmode* first, const GLFWvidmode* second);
+
+/*! @brief Splits a color depth into red, green and blue bit depths.
+ *  @ingroup utility
+ */
+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.
+ *  @ingroup utility
+ */
+int _glfwStringInExtensionString(const char* string, const GLubyte* extensions);
+
+/*! @brief Chooses the framebuffer config that best matches the desired one.
+ *  @param[in] desired The desired framebuffer config.
+ *  @param[in] alternatives The framebuffer configs supported by the system.
+ *  @param[in] count The number of entries in the alternatives array.
+ *  @return The framebuffer config most closely matching the desired one, or @c
+ *  NULL if none fulfilled the hard constraints of the desired values.
+ *  @ingroup utility
+ */
+const _GLFWfbconfig* _glfwChooseFBConfig(const _GLFWfbconfig* desired,
+                                         const _GLFWfbconfig* alternatives,
+                                         unsigned int count);
+
+/*! @brief Retrieves the attributes of the current context.
+ *  @return `GL_TRUE` if successful, or `GL_FALSE` if the context is unusable.
+ *  @ingroup utility
+ */
+GLboolean _glfwRefreshContextAttribs(void);
+
+/*! @brief Checks whether the desired context attributes are valid.
+ *  @param[in] wndconfig The context attributes to check.
+ *  @return `GL_TRUE` if the context attributes are valid, or `GL_FALSE`
+ *  otherwise.
+ *  @ingroup utility
+ *
+ *  This function checks things like whether the specified client API version
+ *  exists and whether all relevant options have supported and non-conflicting
+ *  values.
+ */
+GLboolean _glfwIsValidContextConfig(_GLFWwndconfig* wndconfig);
+
+/*! @brief Checks whether the current context fulfils the specified hard
+ *  constraints.
+ *  @param[in] wndconfig The desired context attributes.
+ *  @return `GL_TRUE` if the context fulfils the hard constraints, or `GL_FALSE`
+ *  otherwise.
+ *  @ingroup utility
+ */
+GLboolean _glfwIsValidContext(_GLFWwndconfig* wndconfig);
+
+/*! @ingroup utility
+ */
+void _glfwAllocGammaArrays(GLFWgammaramp* ramp, unsigned int size);
+
+/*! @ingroup utility
+ */
+void _glfwFreeGammaArrays(GLFWgammaramp* ramp);
+
+/*! @ingroup utility
+ */
+_GLFWmonitor* _glfwCreateMonitor(const char* name, int widthMM, int heightMM);
+
+/*! @ingroup utility
+  */
+void _glfwDestroyMonitor(_GLFWmonitor* monitor);
+
+/*! @ingroup utility
+  */
+void _glfwDestroyMonitors(_GLFWmonitor** monitors, int count);
+
+#endif // _internal_h_

external/Box2D-2.3.1/Box2D/glfw/joystick.c

@@ -0,0 +1,90 @@
+//========================================================================
+// GLFW 3.0 - 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.
+//
+//========================================================================
+
+#include "internal.h"
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                        GLFW public API                       //////
+//////////////////////////////////////////////////////////////////////////
+
+GLFWAPI int glfwJoystickPresent(int joy)
+{
+    _GLFW_REQUIRE_INIT_OR_RETURN(0);
+
+    if (joy < 0 || joy > GLFW_JOYSTICK_LAST)
+    {
+        _glfwInputError(GLFW_INVALID_ENUM, NULL);
+        return 0;
+    }
+
+    return _glfwPlatformJoystickPresent(joy);
+}
+
+GLFWAPI const float* glfwGetJoystickAxes(int joy, int* count)
+{
+    *count = 0;
+
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+
+    if (joy < 0 || joy > GLFW_JOYSTICK_LAST)
+    {
+        _glfwInputError(GLFW_INVALID_ENUM, NULL);
+        return NULL;
+    }
+
+    return _glfwPlatformGetJoystickAxes(joy, count);
+}
+
+GLFWAPI const unsigned char* glfwGetJoystickButtons(int joy, int* count)
+{
+    *count = 0;
+
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+
+    if (joy < 0 || joy > GLFW_JOYSTICK_LAST)
+    {
+        _glfwInputError(GLFW_INVALID_ENUM, NULL);
+        return NULL;
+    }
+
+    return _glfwPlatformGetJoystickButtons(joy, count);
+}
+
+GLFWAPI const char* glfwGetJoystickName(int joy)
+{
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+
+    if (joy < 0 || joy > GLFW_JOYSTICK_LAST)
+    {
+        _glfwInputError(GLFW_INVALID_ENUM, NULL);
+        return NULL;
+    }
+
+    return _glfwPlatformGetJoystickName(joy);
+}
+

external/Box2D-2.3.1/Box2D/glfw/monitor.c

@@ -0,0 +1,357 @@
+//========================================================================
+// GLFW 3.0 - 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.
+//
+//========================================================================
+
+#include "internal.h"
+
+#include <string.h>
+#include <stdlib.h>
+#include <limits.h>
+
+#if defined(_MSC_VER)
+ #include <malloc.h>
+ #define strdup _strdup
+#endif
+
+
+// Lexical comparison function for GLFW video modes, used by qsort
+//
+static int compareVideoModes(const void* firstPtr, const void* secondPtr)
+{
+    int firstBPP, secondBPP, firstSize, secondSize;
+    GLFWvidmode* first = (GLFWvidmode*) firstPtr;
+    GLFWvidmode* second = (GLFWvidmode*) secondPtr;
+
+    // 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;
+
+    // Then sort on screen area, in pixels
+
+    firstSize = first->width * first->height;
+    secondSize = second->width * second->height;
+
+    if (firstSize != secondSize)
+        return firstSize - secondSize;
+
+    // Lastly sort on refresh rate
+
+    return first->refreshRate - second->refreshRate;
+}
+
+// Retrieves the available modes for the specified monitor
+//
+static int refreshVideoModes(_GLFWmonitor* monitor)
+{
+    int modeCount;
+    GLFWvidmode* modes;
+
+    if (monitor->modes)
+        return GL_TRUE;
+
+    modes = _glfwPlatformGetVideoModes(monitor, &modeCount);
+    if (!modes)
+        return GL_FALSE;
+
+    qsort(modes, modeCount, sizeof(GLFWvidmode), compareVideoModes);
+
+    free(monitor->modes);
+    monitor->modes = modes;
+    monitor->modeCount = modeCount;
+
+    return GL_TRUE;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                         GLFW event API                       //////
+//////////////////////////////////////////////////////////////////////////
+
+void _glfwInputMonitorChange(void)
+{
+    int i, j, monitorCount = _glfw.monitorCount;
+    _GLFWmonitor** monitors = _glfw.monitors;
+
+    _glfw.monitors = _glfwPlatformGetMonitors(&_glfw.monitorCount);
+
+    // Re-use still connected monitor objects
+
+    for (i = 0;  i < _glfw.monitorCount;  i++)
+    {
+        for (j = 0;  j < monitorCount;  j++)
+        {
+            if (_glfwPlatformIsSameMonitor(_glfw.monitors[i], monitors[j]))
+            {
+                _glfwDestroyMonitor(_glfw.monitors[i]);
+                _glfw.monitors[i] = monitors[j];
+                break;
+            }
+        }
+    }
+
+    // Find and report disconnected monitors (not in the new list)
+
+    for (i = 0;  i < monitorCount;  i++)
+    {
+        _GLFWwindow* window;
+
+        for (j = 0;  j < _glfw.monitorCount;  j++)
+        {
+            if (monitors[i] == _glfw.monitors[j])
+                break;
+        }
+
+        if (j < _glfw.monitorCount)
+            continue;
+
+        for (window = _glfw.windowListHead;  window;  window = window->next)
+        {
+            if (window->monitor == monitors[i])
+                window->monitor = NULL;
+        }
+
+        if (_glfw.callbacks.monitor)
+            _glfw.callbacks.monitor((GLFWmonitor*) monitors[i], GLFW_DISCONNECTED);
+    }
+
+    // Find and report newly connected monitors (not in the old list)
+    // Re-used monitor objects are then removed from the old list to avoid
+    // having them destroyed at the end of this function
+
+    for (i = 0;  i < _glfw.monitorCount;  i++)
+    {
+        for (j = 0;  j < monitorCount;  j++)
+        {
+            if (_glfw.monitors[i] == monitors[j])
+            {
+                monitors[j] = NULL;
+                break;
+            }
+        }
+
+        if (j < monitorCount)
+            continue;
+
+        if (_glfw.callbacks.monitor)
+            _glfw.callbacks.monitor((GLFWmonitor*) _glfw.monitors[i], GLFW_CONNECTED);
+    }
+
+    _glfwDestroyMonitors(monitors, monitorCount);
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW internal API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+_GLFWmonitor* _glfwCreateMonitor(const char* name, int widthMM, int heightMM)
+{
+    _GLFWmonitor* monitor = calloc(1, sizeof(_GLFWmonitor));
+    monitor->name = strdup(name);
+    monitor->widthMM = widthMM;
+    monitor->heightMM = heightMM;
+
+    return monitor;
+}
+
+void _glfwDestroyMonitor(_GLFWmonitor* monitor)
+{
+    if (monitor == NULL)
+        return;
+
+    _glfwFreeGammaArrays(&monitor->originalRamp);
+    _glfwFreeGammaArrays(&monitor->currentRamp);
+
+    free(monitor->modes);
+    free(monitor->name);
+    free(monitor);
+}
+
+void _glfwDestroyMonitors(_GLFWmonitor** monitors, int count)
+{
+    int i;
+
+    for (i = 0;  i < count;  i++)
+        _glfwDestroyMonitor(monitors[i]);
+
+    free(monitors);
+}
+
+const GLFWvidmode* _glfwChooseVideoMode(_GLFWmonitor* monitor,
+                                        const GLFWvidmode* desired)
+{
+    int i;
+    unsigned int sizeDiff, leastSizeDiff = UINT_MAX;
+    unsigned int rateDiff, leastRateDiff = UINT_MAX;
+    unsigned int colorDiff, leastColorDiff = UINT_MAX;
+    const GLFWvidmode* current;
+    const GLFWvidmode* closest = NULL;
+
+    if (!refreshVideoModes(monitor))
+        return NULL;
+
+    for (i = 0;  i < monitor->modeCount;  i++)
+    {
+        current = monitor->modes + i;
+
+        colorDiff = abs((current->redBits + current->greenBits + current->blueBits) -
+                        (desired->redBits + desired->greenBits + desired->blueBits));
+
+        sizeDiff = abs((current->width - desired->width) *
+                       (current->width - desired->width) +
+                       (current->height - desired->height) *
+                       (current->height - desired->height));
+
+        if (desired->refreshRate)
+            rateDiff = abs(current->refreshRate - desired->refreshRate);
+        else
+            rateDiff = UINT_MAX - current->refreshRate;
+
+        if ((colorDiff < leastColorDiff) ||
+            (colorDiff == leastColorDiff && sizeDiff < leastSizeDiff) ||
+            (colorDiff == leastColorDiff && sizeDiff == leastSizeDiff && rateDiff < leastRateDiff))
+        {
+            closest = current;
+            leastSizeDiff = sizeDiff;
+            leastRateDiff = rateDiff;
+            leastColorDiff = colorDiff;
+        }
+    }
+
+    return closest;
+}
+
+int _glfwCompareVideoModes(const GLFWvidmode* first, const GLFWvidmode* second)
+{
+    return compareVideoModes(first, second);
+}
+
+void _glfwSplitBPP(int bpp, int* red, int* green, int* blue)
+{
+    int delta;
+
+    // We assume that by 32 the user really meant 24
+    if (bpp == 32)
+        bpp = 24;
+
+    // Convert "bits per pixel" to red, green & blue sizes
+
+    *red = *green = *blue = bpp / 3;
+    delta = bpp - (*red * 3);
+    if (delta >= 1)
+        *green = *green + 1;
+
+    if (delta == 2)
+        *red = *red + 1;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                        GLFW public API                       //////
+//////////////////////////////////////////////////////////////////////////
+
+GLFWAPI GLFWmonitor** glfwGetMonitors(int* count)
+{
+    *count = 0;
+
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+
+    *count = _glfw.monitorCount;
+    return (GLFWmonitor**) _glfw.monitors;
+}
+
+GLFWAPI GLFWmonitor* glfwGetPrimaryMonitor(void)
+{
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+    return (GLFWmonitor*) _glfw.monitors[0];
+}
+
+GLFWAPI void glfwGetMonitorPos(GLFWmonitor* handle, int* xpos, int* ypos)
+{
+    _GLFWmonitor* monitor = (_GLFWmonitor*) handle;
+    _GLFW_REQUIRE_INIT();
+    _glfwPlatformGetMonitorPos(monitor, xpos, ypos);
+}
+
+GLFWAPI void glfwGetMonitorPhysicalSize(GLFWmonitor* handle, int* width, int* height)
+{
+    _GLFWmonitor* monitor = (_GLFWmonitor*) handle;
+
+    _GLFW_REQUIRE_INIT();
+
+    if (width)
+        *width = monitor->widthMM;
+    if (height)
+        *height = monitor->heightMM;
+}
+
+GLFWAPI const char* glfwGetMonitorName(GLFWmonitor* handle)
+{
+    _GLFWmonitor* monitor = (_GLFWmonitor*) handle;
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+    return monitor->name;
+}
+
+GLFWAPI GLFWmonitorfun glfwSetMonitorCallback(GLFWmonitorfun cbfun)
+{
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+    _GLFW_SWAP_POINTERS(_glfw.callbacks.monitor, cbfun);
+    return cbfun;
+}
+
+GLFWAPI const GLFWvidmode* glfwGetVideoModes(GLFWmonitor* handle, int* count)
+{
+    _GLFWmonitor* monitor = (_GLFWmonitor*) handle;
+
+    *count = 0;
+
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+
+    if (!refreshVideoModes(monitor))
+        return NULL;
+
+    *count = monitor->modeCount;
+    return monitor->modes;
+}
+
+GLFWAPI const GLFWvidmode* glfwGetVideoMode(GLFWmonitor* handle)
+{
+    _GLFWmonitor* monitor = (_GLFWmonitor*) handle;
+
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+
+    _glfwPlatformGetVideoMode(monitor, &monitor->currentMode);
+    return &monitor->currentMode;
+}
+

external/Box2D-2.3.1/Box2D/glfw/nsgl_context.m

@@ -0,0 +1,291 @@
+//========================================================================
+// GLFW 3.0 OS X - www.glfw.org
+//------------------------------------------------------------------------
+// Copyright (c) 2009-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.
+//
+//========================================================================
+
+#include "internal.h"
+
+#include <pthread.h>
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW internal API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+// Initialize OpenGL support
+//
+int _glfwInitContextAPI(void)
+{
+    if (pthread_key_create(&_glfw.nsgl.current, NULL) != 0)
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "NSGL: Failed to create context TLS");
+        return GL_FALSE;
+    }
+
+    _glfw.nsgl.framework =
+        CFBundleGetBundleWithIdentifier(CFSTR("com.apple.opengl"));
+    if (_glfw.nsgl.framework == NULL)
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "NSGL: Failed to locate OpenGL framework");
+        return GL_FALSE;
+    }
+
+    return GL_TRUE;
+}
+
+// Terminate OpenGL support
+//
+void _glfwTerminateContextAPI(void)
+{
+    pthread_key_delete(_glfw.nsgl.current);
+}
+
+// Create the OpenGL context
+//
+int _glfwCreateContext(_GLFWwindow* window,
+                       const _GLFWwndconfig* wndconfig,
+                       const _GLFWfbconfig* fbconfig)
+{
+    unsigned int attributeCount = 0;
+
+    // OS X needs non-zero color size, so set resonable values
+    int colorBits = fbconfig->redBits + fbconfig->greenBits + fbconfig->blueBits;
+    if (colorBits == 0)
+        colorBits = 24;
+    else if (colorBits < 15)
+        colorBits = 15;
+
+    if (wndconfig->clientAPI == GLFW_OPENGL_ES_API)
+    {
+        _glfwInputError(GLFW_VERSION_UNAVAILABLE,
+                        "NSGL: This API does not support OpenGL ES");
+        return GL_FALSE;
+    }
+
+#if MAC_OS_X_VERSION_MAX_ALLOWED >= 1070
+    if (wndconfig->glMajor == 3 && wndconfig->glMinor < 2)
+    {
+        _glfwInputError(GLFW_VERSION_UNAVAILABLE,
+                        "NSGL: The targeted version of OS X does not "
+                        "support OpenGL 3.0 or 3.1");
+        return GL_FALSE;
+    }
+
+    if (wndconfig->glMajor > 2)
+    {
+        if (!wndconfig->glForward)
+        {
+            _glfwInputError(GLFW_VERSION_UNAVAILABLE,
+                            "NSGL: The targeted version of OS X only "
+                            "supports OpenGL 3.2 and later versions if they "
+                            "are forward-compatible");
+            return GL_FALSE;
+        }
+
+        if (wndconfig->glProfile != GLFW_OPENGL_CORE_PROFILE)
+        {
+            _glfwInputError(GLFW_VERSION_UNAVAILABLE,
+                            "NSGL: The targeted version of OS X only "
+                            "supports OpenGL 3.2 and later versions if they "
+                            "use the core profile");
+            return GL_FALSE;
+        }
+    }
+#else
+    // Fail if OpenGL 3.0 or above was requested
+    if (wndconfig->glMajor > 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*/
+
+    // Fail if a robustness strategy was requested
+    if (wndconfig->glRobustness)
+    {
+        _glfwInputError(GLFW_VERSION_UNAVAILABLE,
+                        "NSGL: OS X does not support OpenGL robustness "
+                        "strategies");
+        return GL_FALSE;
+    }
+
+#define ADD_ATTR(x) { attributes[attributeCount++] = x; }
+#define ADD_ATTR2(x, y) { ADD_ATTR(x); ADD_ATTR(y); }
+
+    // Arbitrary array size here
+    NSOpenGLPixelFormatAttribute attributes[40];
+
+    ADD_ATTR(NSOpenGLPFADoubleBuffer);
+    ADD_ATTR(NSOpenGLPFAClosestPolicy);
+
+#if MAC_OS_X_VERSION_MAX_ALLOWED >= 1070
+    if (wndconfig->glMajor > 2)
+        ADD_ATTR2(NSOpenGLPFAOpenGLProfile, NSOpenGLProfileVersion3_2Core);
+#endif /*MAC_OS_X_VERSION_MAX_ALLOWED*/
+
+    ADD_ATTR2(NSOpenGLPFAColorSize, colorBits);
+
+    if (fbconfig->alphaBits > 0)
+        ADD_ATTR2(NSOpenGLPFAAlphaSize, fbconfig->alphaBits);
+
+    if (fbconfig->depthBits > 0)
+        ADD_ATTR2(NSOpenGLPFADepthSize, fbconfig->depthBits);
+
+    if (fbconfig->stencilBits > 0)
+        ADD_ATTR2(NSOpenGLPFAStencilSize, fbconfig->stencilBits);
+
+    int accumBits = fbconfig->accumRedBits + fbconfig->accumGreenBits +
+                    fbconfig->accumBlueBits + fbconfig->accumAlphaBits;
+
+    if (accumBits > 0)
+        ADD_ATTR2(NSOpenGLPFAAccumSize, accumBits);
+
+    if (fbconfig->auxBuffers > 0)
+        ADD_ATTR2(NSOpenGLPFAAuxBuffers, fbconfig->auxBuffers);
+
+    if (fbconfig->stereo)
+        ADD_ATTR(NSOpenGLPFAStereo);
+
+    if (fbconfig->samples > 0)
+    {
+        ADD_ATTR2(NSOpenGLPFASampleBuffers, 1);
+        ADD_ATTR2(NSOpenGLPFASamples, fbconfig->samples);
+    }
+
+    // NOTE: All NSOpenGLPixelFormats on the relevant cards support sRGB
+    // frambuffer, so there's no need (and no way) to request it
+
+    ADD_ATTR(0);
+
+#undef ADD_ATTR
+#undef ADD_ATTR2
+
+    window->nsgl.pixelFormat =
+        [[NSOpenGLPixelFormat alloc] initWithAttributes:attributes];
+    if (window->nsgl.pixelFormat == nil)
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "NSGL: Failed to create OpenGL pixel format");
+        return GL_FALSE;
+    }
+
+    NSOpenGLContext* share = NULL;
+
+    if (wndconfig->share)
+        share = wndconfig->share->nsgl.context;
+
+    window->nsgl.context =
+        [[NSOpenGLContext alloc] initWithFormat:window->nsgl.pixelFormat
+                                   shareContext:share];
+    if (window->nsgl.context == nil)
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "NSGL: Failed to create OpenGL context");
+        return GL_FALSE;
+    }
+
+    return GL_TRUE;
+}
+
+// Destroy the OpenGL context
+//
+void _glfwDestroyContext(_GLFWwindow* window)
+{
+    [window->nsgl.pixelFormat release];
+    window->nsgl.pixelFormat = nil;
+
+    [window->nsgl.context release];
+    window->nsgl.context = nil;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW platform API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+void _glfwPlatformMakeContextCurrent(_GLFWwindow* window)
+{
+    if (window)
+        [window->nsgl.context makeCurrentContext];
+    else
+        [NSOpenGLContext clearCurrentContext];
+
+    pthread_setspecific(_glfw.nsgl.current, window);
+}
+
+_GLFWwindow* _glfwPlatformGetCurrentContext(void)
+{
+    return (_GLFWwindow*) pthread_getspecific(_glfw.nsgl.current);
+}
+
+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;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                        GLFW native API                       //////
+//////////////////////////////////////////////////////////////////////////
+
+GLFWAPI id glfwGetNSGLContext(GLFWwindow* handle)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    _GLFW_REQUIRE_INIT_OR_RETURN(nil);
+    return window->nsgl.context;
+}
+

external/Box2D-2.3.1/Box2D/glfw/nsgl_platform.h

@@ -0,0 +1,64 @@
+//========================================================================
+// GLFW 3.0 OS X - www.glfw.org
+//------------------------------------------------------------------------
+// Copyright (c) 2009-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 _nsgl_platform_h_
+#define _nsgl_platform_h_
+
+
+#define _GLFW_PLATFORM_FBCONFIG
+#define _GLFW_PLATFORM_CONTEXT_STATE        _GLFWcontextNSGL nsgl
+#define _GLFW_PLATFORM_LIBRARY_OPENGL_STATE _GLFWlibraryNSGL nsgl
+
+
+//========================================================================
+// GLFW platform specific types
+//========================================================================
+
+//------------------------------------------------------------------------
+// Platform-specific OpenGL context structure
+//------------------------------------------------------------------------
+typedef struct _GLFWcontextNSGL
+{
+    id           pixelFormat;
+    id	         context;
+} _GLFWcontextNSGL;
+
+
+//------------------------------------------------------------------------
+// Platform-specific library global data for NSGL
+//------------------------------------------------------------------------
+typedef struct _GLFWlibraryNSGL
+{
+    // dlopen handle for dynamically loading OpenGL extension entry points
+    void*           framework;
+
+    // TLS key for per-thread current context/window
+    pthread_key_t   current;
+
+} _GLFWlibraryNSGL;
+
+
+#endif // _nsgl_platform_h_

external/Box2D-2.3.1/Box2D/glfw/time.c

@@ -0,0 +1,46 @@
+//========================================================================
+// GLFW 3.0 - 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.
+//
+//========================================================================
+
+#include "internal.h"
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                        GLFW public API                       //////
+//////////////////////////////////////////////////////////////////////////
+
+GLFWAPI double glfwGetTime(void)
+{
+    _GLFW_REQUIRE_INIT_OR_RETURN(0.0);
+    return _glfwPlatformGetTime();
+}
+
+GLFWAPI void glfwSetTime(double time)
+{
+    _GLFW_REQUIRE_INIT();
+    _glfwPlatformSetTime(time);
+}
+

external/Box2D-2.3.1/Box2D/glfw/wgl_context.c

@@ -0,0 +1,662 @@
+//========================================================================
+// GLFW 3.0 WGL - 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.
+//
+//========================================================================
+
+#include "internal.h"
+
+#include <stdlib.h>
+#include <malloc.h>
+#include <assert.h>
+
+
+// Initialize WGL-specific extensions
+// This function is called once before initial context creation, i.e. before
+// any WGL extensions could be present.  This is done in order to have both
+// extension variable clearing and loading in the same place, hopefully
+// decreasing the possibility of forgetting to add one without the other.
+//
+static void initWGLExtensions(_GLFWwindow* window)
+{
+    // This needs to include every function pointer loaded below
+    window->wgl.SwapIntervalEXT = NULL;
+    window->wgl.GetPixelFormatAttribivARB = NULL;
+    window->wgl.GetExtensionsStringARB = NULL;
+    window->wgl.GetExtensionsStringEXT = NULL;
+    window->wgl.CreateContextAttribsARB = NULL;
+
+    // This needs to include every extension used below except for
+    // WGL_ARB_extensions_string and WGL_EXT_extensions_string
+    window->wgl.ARB_multisample = GL_FALSE;
+    window->wgl.ARB_framebuffer_sRGB = GL_FALSE;
+    window->wgl.ARB_create_context = GL_FALSE;
+    window->wgl.ARB_create_context_profile = GL_FALSE;
+    window->wgl.EXT_create_context_es2_profile = GL_FALSE;
+    window->wgl.ARB_create_context_robustness = GL_FALSE;
+    window->wgl.EXT_swap_control = GL_FALSE;
+    window->wgl.ARB_pixel_format = GL_FALSE;
+
+    window->wgl.GetExtensionsStringEXT = (PFNWGLGETEXTENSIONSSTRINGEXTPROC)
+        wglGetProcAddress("wglGetExtensionsStringEXT");
+    if (!window->wgl.GetExtensionsStringEXT)
+    {
+        window->wgl.GetExtensionsStringARB = (PFNWGLGETEXTENSIONSSTRINGARBPROC)
+            wglGetProcAddress("wglGetExtensionsStringARB");
+        if (!window->wgl.GetExtensionsStringARB)
+            return;
+    }
+
+    if (_glfwPlatformExtensionSupported("WGL_ARB_multisample"))
+        window->wgl.ARB_multisample = GL_TRUE;
+
+    if (_glfwPlatformExtensionSupported("WGL_ARB_framebuffer_sRGB"))
+        window->wgl.ARB_framebuffer_sRGB = GL_TRUE;
+
+    if (_glfwPlatformExtensionSupported("WGL_ARB_create_context"))
+    {
+        window->wgl.CreateContextAttribsARB = (PFNWGLCREATECONTEXTATTRIBSARBPROC)
+            wglGetProcAddress("wglCreateContextAttribsARB");
+
+        if (window->wgl.CreateContextAttribsARB)
+            window->wgl.ARB_create_context = GL_TRUE;
+    }
+
+    if (window->wgl.ARB_create_context)
+    {
+        if (_glfwPlatformExtensionSupported("WGL_ARB_create_context_profile"))
+            window->wgl.ARB_create_context_profile = GL_TRUE;
+    }
+
+    if (window->wgl.ARB_create_context &&
+        window->wgl.ARB_create_context_profile)
+    {
+        if (_glfwPlatformExtensionSupported("WGL_EXT_create_context_es2_profile"))
+            window->wgl.EXT_create_context_es2_profile = GL_TRUE;
+    }
+
+    if (window->wgl.ARB_create_context)
+    {
+        if (_glfwPlatformExtensionSupported("WGL_ARB_create_context_robustness"))
+            window->wgl.ARB_create_context_robustness = GL_TRUE;
+    }
+
+    if (_glfwPlatformExtensionSupported("WGL_EXT_swap_control"))
+    {
+        window->wgl.SwapIntervalEXT = (PFNWGLSWAPINTERVALEXTPROC)
+            wglGetProcAddress("wglSwapIntervalEXT");
+
+        if (window->wgl.SwapIntervalEXT)
+            window->wgl.EXT_swap_control = GL_TRUE;
+    }
+
+    if (_glfwPlatformExtensionSupported("WGL_ARB_pixel_format"))
+    {
+        window->wgl.GetPixelFormatAttribivARB = (PFNWGLGETPIXELFORMATATTRIBIVARBPROC)
+            wglGetProcAddress("wglGetPixelFormatAttribivARB");
+
+        if (window->wgl.GetPixelFormatAttribivARB)
+            window->wgl.ARB_pixel_format = GL_TRUE;
+    }
+}
+
+// Returns the specified attribute of the specified pixel format
+// NOTE: Do not call this unless we have found WGL_ARB_pixel_format
+//
+static int getPixelFormatAttrib(_GLFWwindow* window, int pixelFormat, int attrib)
+{
+    int value = 0;
+
+    if (!window->wgl.GetPixelFormatAttribivARB(window->wgl.dc,
+                                               pixelFormat,
+                                               0, 1, &attrib, &value))
+    {
+        // NOTE: We should probably handle this error somehow
+        return 0;
+    }
+
+    return value;
+}
+
+// Return a list of available and usable framebuffer configs
+//
+static GLboolean choosePixelFormat(_GLFWwindow* window,
+                                   const _GLFWfbconfig* desired,
+                                   int* result)
+{
+    _GLFWfbconfig* usableConfigs;
+    const _GLFWfbconfig* closest;
+    int i, nativeCount, usableCount;
+
+    if (window->wgl.ARB_pixel_format)
+    {
+        nativeCount = getPixelFormatAttrib(window,
+                                         1,
+                                         WGL_NUMBER_PIXEL_FORMATS_ARB);
+    }
+    else
+    {
+        nativeCount = DescribePixelFormat(window->wgl.dc,
+                                          1,
+                                          sizeof(PIXELFORMATDESCRIPTOR),
+                                          NULL);
+    }
+
+    if (!nativeCount)
+    {
+        _glfwInputError(GLFW_API_UNAVAILABLE, "WGL: No pixel formats found");
+        return GL_FALSE;
+    }
+
+    usableConfigs = calloc(nativeCount, sizeof(_GLFWfbconfig));
+    usableCount = 0;
+
+    for (i = 0;  i < nativeCount;  i++)
+    {
+        const int n = i + 1;
+        _GLFWfbconfig* u = usableConfigs + usableCount;
+
+        if (window->wgl.ARB_pixel_format)
+        {
+            // Get pixel format attributes through WGL_ARB_pixel_format
+            if (!getPixelFormatAttrib(window, n, WGL_SUPPORT_OPENGL_ARB) ||
+                !getPixelFormatAttrib(window, n, WGL_DRAW_TO_WINDOW_ARB) ||
+                !getPixelFormatAttrib(window, n, WGL_DOUBLE_BUFFER_ARB))
+            {
+                continue;
+            }
+
+            if (getPixelFormatAttrib(window, n, WGL_PIXEL_TYPE_ARB) !=
+                WGL_TYPE_RGBA_ARB)
+            {
+                continue;
+            }
+
+            if (getPixelFormatAttrib(window, n, WGL_ACCELERATION_ARB) ==
+                 WGL_NO_ACCELERATION_ARB)
+            {
+                continue;
+            }
+
+            u->redBits = getPixelFormatAttrib(window, n, WGL_RED_BITS_ARB);
+            u->greenBits = getPixelFormatAttrib(window, n, WGL_GREEN_BITS_ARB);
+            u->blueBits = getPixelFormatAttrib(window, n, WGL_BLUE_BITS_ARB);
+            u->alphaBits = getPixelFormatAttrib(window, n, WGL_ALPHA_BITS_ARB);
+
+            u->depthBits = getPixelFormatAttrib(window, n, WGL_DEPTH_BITS_ARB);
+            u->stencilBits = getPixelFormatAttrib(window, n, WGL_STENCIL_BITS_ARB);
+
+            u->accumRedBits = getPixelFormatAttrib(window, n, WGL_ACCUM_RED_BITS_ARB);
+            u->accumGreenBits = getPixelFormatAttrib(window, n, WGL_ACCUM_GREEN_BITS_ARB);
+            u->accumBlueBits = getPixelFormatAttrib(window, n, WGL_ACCUM_BLUE_BITS_ARB);
+            u->accumAlphaBits = getPixelFormatAttrib(window, n, WGL_ACCUM_ALPHA_BITS_ARB);
+
+            u->auxBuffers = getPixelFormatAttrib(window, n, WGL_AUX_BUFFERS_ARB);
+            u->stereo = getPixelFormatAttrib(window, n, WGL_STEREO_ARB);
+
+            if (window->wgl.ARB_multisample)
+                u->samples = getPixelFormatAttrib(window, n, WGL_SAMPLES_ARB);
+
+            if (window->wgl.ARB_framebuffer_sRGB)
+                u->sRGB = getPixelFormatAttrib(window, n, WGL_FRAMEBUFFER_SRGB_CAPABLE_ARB);
+        }
+        else
+        {
+            PIXELFORMATDESCRIPTOR pfd;
+
+            // Get pixel format attributes through old-fashioned PFDs
+
+            if (!DescribePixelFormat(window->wgl.dc,
+                                     n,
+                                     sizeof(PIXELFORMATDESCRIPTOR),
+                                     &pfd))
+            {
+                continue;
+            }
+
+            if (!(pfd.dwFlags & PFD_DRAW_TO_WINDOW) ||
+                !(pfd.dwFlags & PFD_SUPPORT_OPENGL) ||
+                !(pfd.dwFlags & PFD_DOUBLEBUFFER))
+            {
+                continue;
+            }
+
+            if (!(pfd.dwFlags & PFD_GENERIC_ACCELERATED) &&
+                (pfd.dwFlags & PFD_GENERIC_FORMAT))
+            {
+                continue;
+            }
+
+            if (pfd.iPixelType != PFD_TYPE_RGBA)
+                continue;
+
+            u->redBits = pfd.cRedBits;
+            u->greenBits = pfd.cGreenBits;
+            u->blueBits = pfd.cBlueBits;
+            u->alphaBits = pfd.cAlphaBits;
+
+            u->depthBits = pfd.cDepthBits;
+            u->stencilBits = pfd.cStencilBits;
+
+            u->accumRedBits = pfd.cAccumRedBits;
+            u->accumGreenBits = pfd.cAccumGreenBits;
+            u->accumBlueBits = pfd.cAccumBlueBits;
+            u->accumAlphaBits = pfd.cAccumAlphaBits;
+
+            u->auxBuffers = pfd.cAuxBuffers;
+            u->stereo = (pfd.dwFlags & PFD_STEREO) ? GL_TRUE : GL_FALSE;
+        }
+
+        u->wgl = n;
+        usableCount++;
+    }
+
+    closest = _glfwChooseFBConfig(desired, usableConfigs, usableCount);
+    if (!closest)
+    {
+        free(usableConfigs);
+        return GL_FALSE;
+    }
+
+    *result = closest->wgl;
+    free(usableConfigs);
+
+    return GL_TRUE;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW internal API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+// Initialize WGL
+//
+int _glfwInitContextAPI(void)
+{
+    _glfw.wgl.opengl32.instance = LoadLibrary(L"opengl32.dll");
+    if (!_glfw.wgl.opengl32.instance)
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR, "Failed to load opengl32.dll");
+        return GL_FALSE;
+    }
+
+    _glfw.wgl.current = TlsAlloc();
+    if (_glfw.wgl.current == TLS_OUT_OF_INDEXES)
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "WGL: Failed to allocate TLS index");
+        return GL_FALSE;
+    }
+
+    _glfw.wgl.hasTLS = GL_TRUE;
+
+    return GL_TRUE;
+}
+
+// Terminate WGL
+//
+void _glfwTerminateContextAPI(void)
+{
+    if (_glfw.wgl.hasTLS)
+        TlsFree(_glfw.wgl.current);
+
+    if (_glfw.wgl.opengl32.instance)
+        FreeLibrary(_glfw.wgl.opengl32.instance);
+}
+
+#define setWGLattrib(attribName, attribValue) \
+{ \
+    attribs[index++] = attribName; \
+    attribs[index++] = attribValue; \
+    assert((size_t) index < sizeof(attribs) / sizeof(attribs[0])); \
+}
+
+// Prepare for creation of the OpenGL context
+//
+int _glfwCreateContext(_GLFWwindow* window,
+                       const _GLFWwndconfig* wndconfig,
+                       const _GLFWfbconfig* fbconfig)
+{
+    int attribs[40];
+    int pixelFormat = 0;
+    PIXELFORMATDESCRIPTOR pfd;
+    HGLRC share = NULL;
+
+    if (wndconfig->share)
+        share = wndconfig->share->wgl.context;
+
+    window->wgl.dc = GetDC(window->win32.handle);
+    if (!window->wgl.dc)
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "Win32: Failed to retrieve DC for window");
+        return GL_FALSE;
+    }
+
+    if (!choosePixelFormat(window, fbconfig, &pixelFormat))
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "WGL: Failed to find a suitable pixel format");
+        return GL_FALSE;
+    }
+
+    if (!DescribePixelFormat(window->wgl.dc, pixelFormat, sizeof(pfd), &pfd))
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "Win32: Failed to retrieve PFD for selected pixel "
+                        "format");
+        return GL_FALSE;
+    }
+
+    if (!SetPixelFormat(window->wgl.dc, pixelFormat, &pfd))
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "Win32: Failed to set selected pixel format");
+        return GL_FALSE;
+    }
+
+    if (window->wgl.ARB_create_context)
+    {
+        int index = 0, mask = 0, flags = 0, strategy = 0;
+
+        if (wndconfig->clientAPI == GLFW_OPENGL_API)
+        {
+            if (wndconfig->glForward)
+                flags |= WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB;
+
+            if (wndconfig->glDebug)
+                flags |= WGL_CONTEXT_DEBUG_BIT_ARB;
+
+            if (wndconfig->glProfile)
+            {
+                if (wndconfig->glProfile == GLFW_OPENGL_CORE_PROFILE)
+                    mask |= WGL_CONTEXT_CORE_PROFILE_BIT_ARB;
+                else if (wndconfig->glProfile == GLFW_OPENGL_COMPAT_PROFILE)
+                    mask |= WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB;
+            }
+        }
+        else
+            mask |= WGL_CONTEXT_ES2_PROFILE_BIT_EXT;
+
+        if (wndconfig->glRobustness)
+        {
+            if (window->wgl.ARB_create_context_robustness)
+            {
+                if (wndconfig->glRobustness == GLFW_NO_RESET_NOTIFICATION)
+                    strategy = WGL_NO_RESET_NOTIFICATION_ARB;
+                else if (wndconfig->glRobustness == GLFW_LOSE_CONTEXT_ON_RESET)
+                    strategy = WGL_LOSE_CONTEXT_ON_RESET_ARB;
+
+                flags |= WGL_CONTEXT_ROBUST_ACCESS_BIT_ARB;
+            }
+        }
+
+        if (wndconfig->glMajor != 1 || wndconfig->glMinor != 0)
+        {
+            setWGLattrib(WGL_CONTEXT_MAJOR_VERSION_ARB, wndconfig->glMajor);
+            setWGLattrib(WGL_CONTEXT_MINOR_VERSION_ARB, wndconfig->glMinor);
+        }
+
+        if (flags)
+            setWGLattrib(WGL_CONTEXT_FLAGS_ARB, flags);
+
+        if (mask)
+            setWGLattrib(WGL_CONTEXT_PROFILE_MASK_ARB, mask);
+
+        if (strategy)
+            setWGLattrib(WGL_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB, strategy);
+
+        setWGLattrib(0, 0);
+
+        window->wgl.context = window->wgl.CreateContextAttribsARB(window->wgl.dc,
+                                                                  share,
+                                                                  attribs);
+        if (!window->wgl.context)
+        {
+            _glfwInputError(GLFW_VERSION_UNAVAILABLE,
+                            "WGL: Failed to create OpenGL context");
+            return GL_FALSE;
+        }
+    }
+    else
+    {
+        window->wgl.context = wglCreateContext(window->wgl.dc);
+        if (!window->wgl.context)
+        {
+            _glfwInputError(GLFW_PLATFORM_ERROR,
+                            "WGL: Failed to create OpenGL context");
+            return GL_FALSE;
+        }
+
+        if (share)
+        {
+            if (!wglShareLists(share, window->wgl.context))
+            {
+                _glfwInputError(GLFW_PLATFORM_ERROR,
+                                "WGL: Failed to enable sharing with specified "
+                                "OpenGL context");
+                return GL_FALSE;
+            }
+        }
+    }
+
+    _glfwPlatformMakeContextCurrent(window);
+    initWGLExtensions(window);
+
+    return GL_TRUE;
+}
+
+#undef setWGLattrib
+
+// Destroy the OpenGL context
+//
+void _glfwDestroyContext(_GLFWwindow* window)
+{
+    if (window->wgl.context)
+    {
+        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 _GLFWwndconfig* wndconfig,
+                        const _GLFWfbconfig* fbconfig)
+{
+    GLboolean required = GL_FALSE;
+
+    if (wndconfig->clientAPI == GLFW_OPENGL_API)
+    {
+        if (wndconfig->glForward)
+        {
+            if (!window->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;
+        }
+
+        if (wndconfig->glProfile)
+        {
+            if (!window->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;
+        }
+    }
+    else
+    {
+        if (!window->wgl.ARB_create_context ||
+            !window->wgl.ARB_create_context_profile ||
+            !window->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;
+    }
+
+    if (wndconfig->glMajor != 1 || wndconfig->glMinor != 0)
+    {
+        if (window->wgl.ARB_create_context)
+            required = GL_TRUE;
+    }
+
+    if (wndconfig->glDebug)
+    {
+        if (window->wgl.ARB_create_context)
+            required = GL_TRUE;
+    }
+
+    if (fbconfig->samples > 0)
+    {
+        // We want FSAA, but can we get it?
+        // FSAA is not a hard constraint, so otherwise we just don't care
+
+        if (window->wgl.ARB_multisample && window->wgl.ARB_pixel_format)
+        {
+            // We appear to have both the extension and the means to ask for it
+            required = GL_TRUE;
+        }
+    }
+
+    if (required)
+        return _GLFW_RECREATION_REQUIRED;
+
+    return _GLFW_RECREATION_NOT_NEEDED;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW platform API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+void _glfwPlatformMakeContextCurrent(_GLFWwindow* window)
+{
+    if (window)
+        wglMakeCurrent(window->wgl.dc, window->wgl.context);
+    else
+        wglMakeCurrent(NULL, NULL);
+
+    TlsSetValue(_glfw.wgl.current, window);
+}
+
+_GLFWwindow* _glfwPlatformGetCurrentContext(void)
+{
+    return TlsGetValue(_glfw.wgl.current);
+}
+
+void _glfwPlatformSwapBuffers(_GLFWwindow* window)
+{
+    SwapBuffers(window->wgl.dc);
+}
+
+void _glfwPlatformSwapInterval(int interval)
+{
+    _GLFWwindow* window = _glfwPlatformGetCurrentContext();
+
+#if !defined(_GLFW_USE_DWM_SWAP_INTERVAL)
+    if (_glfwIsCompositionEnabled())
+    {
+        // Don't enabled vsync when desktop compositing is enabled, as it leads
+        // to frame jitter
+        return;
+    }
+#endif
+
+    if (window->wgl.EXT_swap_control)
+        window->wgl.SwapIntervalEXT(interval);
+}
+
+int _glfwPlatformExtensionSupported(const char* extension)
+{
+    const GLubyte* extensions;
+
+    _GLFWwindow* window = _glfwPlatformGetCurrentContext();
+
+    if (window->wgl.GetExtensionsStringEXT != NULL)
+    {
+        extensions = (GLubyte*) window->wgl.GetExtensionsStringEXT();
+        if (extensions != NULL)
+        {
+            if (_glfwStringInExtensionString(extension, extensions))
+                return GL_TRUE;
+        }
+    }
+
+    if (window->wgl.GetExtensionsStringARB != NULL)
+    {
+        extensions = (GLubyte*) window->wgl.GetExtensionsStringARB(window->wgl.dc);
+        if (extensions != NULL)
+        {
+            if (_glfwStringInExtensionString(extension, extensions))
+                return GL_TRUE;
+        }
+    }
+
+    return GL_FALSE;
+}
+
+GLFWglproc _glfwPlatformGetProcAddress(const char* procname)
+{
+    const GLFWglproc proc = (GLFWglproc) wglGetProcAddress(procname);
+    if (proc)
+        return proc;
+
+    return (GLFWglproc) GetProcAddress(_glfw.wgl.opengl32.instance, procname);
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                        GLFW native API                       //////
+//////////////////////////////////////////////////////////////////////////
+
+GLFWAPI HGLRC glfwGetWGLContext(GLFWwindow* handle)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+    return window->wgl.context;
+}
+

external/Box2D-2.3.1/Box2D/glfw/wgl_platform.h

@@ -0,0 +1,88 @@
+//========================================================================
+// GLFW 3.0 WGL - 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 _wgl_platform_h_
+#define _wgl_platform_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 "wglext.h"
+
+
+#define _GLFW_PLATFORM_FBCONFIG             int             wgl
+#define _GLFW_PLATFORM_CONTEXT_STATE        _GLFWcontextWGL wgl
+#define _GLFW_PLATFORM_LIBRARY_OPENGL_STATE _GLFWlibraryWGL wgl
+
+
+//========================================================================
+// GLFW platform specific types
+//========================================================================
+
+//------------------------------------------------------------------------
+// Platform-specific OpenGL context structure
+//------------------------------------------------------------------------
+typedef struct _GLFWcontextWGL
+{
+    // Platform specific window resources
+    HDC       dc;              // Private GDI device context
+    HGLRC     context;         // Permanent rendering context
+
+    // Platform specific 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                           ARB_pixel_format;
+    GLboolean                           ARB_create_context;
+    GLboolean                           ARB_create_context_profile;
+    GLboolean                           EXT_create_context_es2_profile;
+    GLboolean                           ARB_create_context_robustness;
+} _GLFWcontextWGL;
+
+
+//------------------------------------------------------------------------
+// Platform-specific library global data for WGL
+//------------------------------------------------------------------------
+typedef struct _GLFWlibraryWGL
+{
+    GLboolean       hasTLS;
+    DWORD           current;
+
+    // opengl32.dll
+    struct {
+        HINSTANCE   instance;
+    } opengl32;
+
+} _GLFWlibraryWGL;
+
+
+#endif // _wgl_platform_h_

external/Box2D-2.3.1/Box2D/glfw/wglext.h

@@ -0,0 +1,825 @@
+#ifndef __wglext_h_
+#define __wglext_h_ 1
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+** Copyright (c) 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.
+*/
+/*
+** 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$ on $Date$
+*/
+
+#if defined(_WIN32) && !defined(APIENTRY) && !defined(__CYGWIN__) && !defined(__SCITECH_SNAP__)
+#define WIN32_LEAN_AND_MEAN 1
+#include <windows.h>
+#endif
+
+#define WGL_WGLEXT_VERSION 20130710
+
+/* 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_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_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

external/Box2D-2.3.1/Box2D/glfw/win32_clipboard.c

@@ -0,0 +1,127 @@
+//========================================================================
+// GLFW 3.0 Win32 - www.glfw.org
+//------------------------------------------------------------------------
+// Copyright (c) 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.
+//
+//========================================================================
+
+#include "internal.h"
+
+#include <limits.h>
+#include <string.h>
+#include <stdlib.h>
+#include <malloc.h>
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW platform API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+void _glfwPlatformSetClipboardString(_GLFWwindow* window, const char* string)
+{
+    WCHAR* wideString;
+    HANDLE stringHandle;
+    size_t wideSize;
+
+    wideString = _glfwCreateWideStringFromUTF8(string);
+    if (!wideString)
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "Win32: Failed to convert clipboard string to "
+                        "wide string");
+        return;
+    }
+
+    wideSize = (wcslen(wideString) + 1) * sizeof(WCHAR);
+
+    stringHandle = GlobalAlloc(GMEM_MOVEABLE, wideSize);
+    if (!stringHandle)
+    {
+        free(wideString);
+
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "Win32: Failed to allocate global handle for clipboard");
+        return;
+    }
+
+    memcpy(GlobalLock(stringHandle), wideString, wideSize);
+    GlobalUnlock(stringHandle);
+
+    if (!OpenClipboard(window->win32.handle))
+    {
+        GlobalFree(stringHandle);
+        free(wideString);
+
+        _glfwInputError(GLFW_PLATFORM_ERROR, "Win32: Failed to open clipboard");
+        return;
+    }
+
+    EmptyClipboard();
+    SetClipboardData(CF_UNICODETEXT, stringHandle);
+    CloseClipboard();
+
+    free(wideString);
+}
+
+const char* _glfwPlatformGetClipboardString(_GLFWwindow* window)
+{
+    HANDLE stringHandle;
+
+    if (!IsClipboardFormatAvailable(CF_UNICODETEXT))
+    {
+        _glfwInputError(GLFW_FORMAT_UNAVAILABLE, NULL);
+        return NULL;
+    }
+
+    if (!OpenClipboard(window->win32.handle))
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR, "Win32: Failed to open clipboard");
+        return NULL;
+    }
+
+    stringHandle = GetClipboardData(CF_UNICODETEXT);
+    if (!stringHandle)
+    {
+        CloseClipboard();
+
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "Win32: Failed to retrieve clipboard data");
+        return NULL;
+    }
+
+    free(_glfw.win32.clipboardString);
+    _glfw.win32.clipboardString =
+        _glfwCreateUTF8FromWideString(GlobalLock(stringHandle));
+
+    GlobalUnlock(stringHandle);
+    CloseClipboard();
+
+    if (!_glfw.win32.clipboardString)
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "Win32: Failed to convert wide string to UTF-8");
+        return NULL;
+    }
+
+    return _glfw.win32.clipboardString;
+}
+

external/Box2D-2.3.1/Box2D/glfw/win32_gamma.c

@@ -0,0 +1,82 @@
+//========================================================================
+// GLFW 3.0 Win32 - www.glfw.org
+//------------------------------------------------------------------------
+// Copyright (c) 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.
+//
+//========================================================================
+
+#include "internal.h"
+
+#include <limits.h>
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW platform API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+void _glfwPlatformGetGammaRamp(_GLFWmonitor* monitor, GLFWgammaramp* ramp)
+{
+    HDC dc;
+    WORD values[768];
+    DISPLAY_DEVICE display;
+
+    ZeroMemory(&display, sizeof(DISPLAY_DEVICE));
+    display.cb = sizeof(DISPLAY_DEVICE);
+    EnumDisplayDevices(monitor->win32.name, 0, &display, 0);
+
+    dc = CreateDC(L"DISPLAY", display.DeviceString, NULL, NULL);
+    GetDeviceGammaRamp(dc, values);
+    DeleteDC(dc);
+
+    _glfwAllocGammaArrays(ramp, 256);
+
+    memcpy(ramp->red,   values +   0, 256 * sizeof(unsigned short));
+    memcpy(ramp->green, values + 256, 256 * sizeof(unsigned short));
+    memcpy(ramp->blue,  values + 512, 256 * sizeof(unsigned short));
+}
+
+void _glfwPlatformSetGammaRamp(_GLFWmonitor* monitor, const GLFWgammaramp* ramp)
+{
+    HDC dc;
+    WORD values[768];
+    DISPLAY_DEVICE display;
+
+    if (ramp->size != 256)
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "Win32: Gamma ramp size must be 256");
+        return;
+    }
+
+    memcpy(values +   0, ramp->red,   256 * sizeof(unsigned short));
+    memcpy(values + 256, ramp->green, 256 * sizeof(unsigned short));
+    memcpy(values + 512, ramp->blue,  256 * sizeof(unsigned short));
+
+    ZeroMemory(&display, sizeof(DISPLAY_DEVICE));
+    display.cb = sizeof(DISPLAY_DEVICE);
+    EnumDisplayDevices(monitor->win32.name, 0, &display, 0);
+
+    dc = CreateDC(L"DISPLAY", display.DeviceString, NULL, NULL);
+    SetDeviceGammaRamp(dc, values);
+    DeleteDC(dc);
+}
+

external/Box2D-2.3.1/Box2D/glfw/win32_init.c

@@ -0,0 +1,269 @@
+//========================================================================
+// GLFW 3.0 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.
+//
+//========================================================================
+
+#include "internal.h"
+
+#include <stdlib.h>
+#include <malloc.h>
+
+#ifdef __BORLANDC__
+// With the Borland C++ compiler, we want to disable FPU exceptions
+#include <float.h>
+#endif // __BORLANDC__
+
+
+#if defined(_GLFW_USE_OPTIMUS_HPG)
+
+// Applications exporting this symbol with this value will be automatically
+// directed to the high-performance GPU on nVidia Optimus systems
+//
+GLFWAPI DWORD NvOptimusEnablement = 0x00000001;
+
+#endif // _GLFW_USE_OPTIMUS_HPG
+
+#if defined(_GLFW_BUILD_DLL)
+
+// GLFW DLL entry point
+//
+BOOL WINAPI DllMain(HINSTANCE instance, DWORD reason, LPVOID reserved)
+{
+    return TRUE;
+}
+
+#endif // _GLFW_BUILD_DLL
+
+// Load necessary libraries (DLLs)
+//
+static GLboolean initLibraries(void)
+{
+#ifndef _GLFW_NO_DLOAD_WINMM
+    // winmm.dll (for joystick and timer support)
+
+    _glfw.win32.winmm.instance = LoadLibrary(L"winmm.dll");
+    if (!_glfw.win32.winmm.instance)
+        return GL_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)
+    {
+        return GL_FALSE;
+    }
+#endif // _GLFW_NO_DLOAD_WINMM
+
+    _glfw.win32.user32.instance = LoadLibrary(L"user32.dll");
+    if (_glfw.win32.user32.instance)
+    {
+        _glfw.win32.user32.SetProcessDPIAware = (SETPROCESSDPIAWARE_T)
+            GetProcAddress(_glfw.win32.user32.instance, "SetProcessDPIAware");
+    }
+
+    _glfw.win32.dwmapi.instance = LoadLibrary(L"dwmapi.dll");
+    if (_glfw.win32.dwmapi.instance)
+    {
+        _glfw.win32.dwmapi.DwmIsCompositionEnabled = (DWMISCOMPOSITIONENABLED_T)
+            GetProcAddress(_glfw.win32.dwmapi.instance, "DwmIsCompositionEnabled");
+    }
+
+    return GL_TRUE;
+}
+
+// Unload used libraries (DLLs)
+//
+static void terminateLibraries(void)
+{
+#ifndef _GLFW_NO_DLOAD_WINMM
+    if (_glfw.win32.winmm.instance != NULL)
+    {
+        FreeLibrary(_glfw.win32.winmm.instance);
+        _glfw.win32.winmm.instance = NULL;
+    }
+#endif // _GLFW_NO_DLOAD_WINMM
+
+    if (_glfw.win32.user32.instance)
+        FreeLibrary(_glfw.win32.user32.instance);
+
+    if (_glfw.win32.dwmapi.instance)
+        FreeLibrary(_glfw.win32.dwmapi.instance);
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       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* target;
+    int length;
+
+    length = MultiByteToWideChar(CP_UTF8, 0, source, -1, NULL, 0);
+    if (!length)
+        return NULL;
+
+    target = calloc(length + 1, sizeof(WCHAR));
+
+    if (!MultiByteToWideChar(CP_UTF8, 0, source, -1, target, length + 1))
+    {
+        free(target);
+        return NULL;
+    }
+
+    return target;
+}
+
+// Returns a UTF-8 string version of the specified wide string
+//
+char* _glfwCreateUTF8FromWideString(const WCHAR* source)
+{
+    char* target;
+    int length;
+
+    length = WideCharToMultiByte(CP_UTF8, 0, source, -1, NULL, 0, NULL, NULL);
+    if (!length)
+        return NULL;
+
+    target = calloc(length + 1, sizeof(char));
+
+    if (!WideCharToMultiByte(CP_UTF8, 0, source, -1, target, length + 1, NULL, NULL))
+    {
+        free(target);
+        return NULL;
+    }
+
+    return target;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW platform API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+int _glfwPlatformInit(void)
+{
+    // 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)
+    SystemParametersInfo(SPI_GETFOREGROUNDLOCKTIMEOUT, 0,
+                         &_glfw.win32.foregroundLockTimeout, 0);
+    SystemParametersInfo(SPI_SETFOREGROUNDLOCKTIMEOUT, 0, UIntToPtr(0),
+                         SPIF_SENDCHANGE);
+
+    if (!initLibraries())
+        return GL_FALSE;
+
+    if (_glfw_SetProcessDPIAware)
+        _glfw_SetProcessDPIAware();
+
+#ifdef __BORLANDC__
+    // With the Borland C++ compiler, we want to disable FPU exceptions
+    // (this is recommended for OpenGL applications under Windows)
+    _control87(MCW_EM, MCW_EM);
+#endif
+
+    if (!_glfwInitContextAPI())
+        return GL_FALSE;
+
+    _glfwInitTimer();
+    _glfwInitJoysticks();
+
+    return GL_TRUE;
+}
+
+void _glfwPlatformTerminate(void)
+{
+    if (_glfw.win32.classAtom)
+    {
+        UnregisterClass(_GLFW_WNDCLASSNAME, GetModuleHandle(NULL));
+        _glfw.win32.classAtom = 0;
+    }
+
+    // Restore previous foreground lock timeout system setting
+    SystemParametersInfo(SPI_SETFOREGROUNDLOCKTIMEOUT, 0,
+                         UIntToPtr(_glfw.win32.foregroundLockTimeout),
+                         SPIF_SENDCHANGE);
+
+    free(_glfw.win32.clipboardString);
+
+    _glfwTerminateJoysticks();
+    _glfwTerminateContextAPI();
+    terminateLibraries();
+}
+
+const char* _glfwPlatformGetVersionString(void)
+{
+    const char* version = _GLFW_VERSION_FULL " Win32"
+#if defined(_GLFW_WGL)
+        " WGL"
+#elif defined(_GLFW_EGL)
+        " EGL"
+#endif
+#if defined(__MINGW32__)
+        " MinGW"
+#elif defined(_MSC_VER)
+        " VisualC "
+#elif defined(__BORLANDC__)
+        " BorlandC"
+#endif
+#if !defined(_GLFW_NO_DLOAD_WINMM)
+        " LoadLibrary(winmm)"
+#endif
+#if defined(_GLFW_BUILD_DLL)
+        " DLL"
+#endif
+        ;
+
+    return version;
+}
+

external/Box2D-2.3.1/Box2D/glfw/win32_joystick.c

@@ -0,0 +1,177 @@
+//========================================================================
+// GLFW 3.0 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.
+//
+//========================================================================
+
+#include "internal.h"
+
+#include <stdlib.h>
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW internal API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+// Calculate normalized joystick position
+//
+static float calcJoystickPos(DWORD pos, DWORD min, DWORD max)
+{
+    float fpos = (float) pos;
+    float fmin = (float) min;
+    float fmax = (float) max;
+
+    return (2.f * (fpos - fmin) / (fmax - fmin)) - 1.f;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW internal API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+// Initialize joystick interface
+//
+void _glfwInitJoysticks(void)
+{
+}
+
+// Close all opened joystick handles
+//
+void _glfwTerminateJoysticks(void)
+{
+    int i;
+
+    for (i = 0;  i < GLFW_JOYSTICK_LAST;  i++)
+        free(_glfw.win32.joystick[i].name);
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW platform API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+int _glfwPlatformJoystickPresent(int joy)
+{
+    JOYINFO ji;
+
+    if (_glfw_joyGetPos(joy, &ji) != JOYERR_NOERROR)
+        return GL_FALSE;
+
+    return GL_TRUE;
+}
+
+const float* _glfwPlatformGetJoystickAxes(int joy, int* count)
+{
+    JOYCAPS jc;
+    JOYINFOEX ji;
+    float* axes = _glfw.win32.joystick[joy].axes;
+
+    if (_glfw_joyGetDevCaps(joy, &jc, sizeof(JOYCAPS)) != JOYERR_NOERROR)
+        return NULL;
+
+    ji.dwSize = sizeof(JOYINFOEX);
+    ji.dwFlags = JOY_RETURNX | JOY_RETURNY | JOY_RETURNZ |
+                 JOY_RETURNR | JOY_RETURNU | JOY_RETURNV;
+    if (_glfw_joyGetPosEx(joy, &ji) != JOYERR_NOERROR)
+        return NULL;
+
+    axes[(*count)++] = calcJoystickPos(ji.dwXpos, jc.wXmin, jc.wXmax);
+    axes[(*count)++] = -calcJoystickPos(ji.dwYpos, jc.wYmin, jc.wYmax);
+
+    if (jc.wCaps & JOYCAPS_HASZ)
+        axes[(*count)++] = calcJoystickPos(ji.dwZpos, jc.wZmin, jc.wZmax);
+
+    if (jc.wCaps & JOYCAPS_HASR)
+        axes[(*count)++] = calcJoystickPos(ji.dwRpos, jc.wRmin, jc.wRmax);
+
+    if (jc.wCaps & JOYCAPS_HASU)
+        axes[(*count)++] = calcJoystickPos(ji.dwUpos, jc.wUmin, jc.wUmax);
+
+    if (jc.wCaps & JOYCAPS_HASV)
+        axes[(*count)++] = -calcJoystickPos(ji.dwVpos, jc.wVmin, jc.wVmax);
+
+    return axes;
+}
+
+const unsigned char* _glfwPlatformGetJoystickButtons(int joy, int* count)
+{
+    JOYCAPS jc;
+    JOYINFOEX ji;
+    unsigned char* buttons = _glfw.win32.joystick[joy].buttons;
+
+    if (_glfw_joyGetDevCaps(joy, &jc, sizeof(JOYCAPS)) != JOYERR_NOERROR)
+        return NULL;
+
+    ji.dwSize = sizeof(JOYINFOEX);
+    ji.dwFlags = JOY_RETURNBUTTONS | JOY_RETURNPOV;
+    if (_glfw_joyGetPosEx(joy, &ji) != JOYERR_NOERROR)
+        return NULL;
+
+    while (*count < (int) jc.wNumButtons)
+    {
+        buttons[*count] = (unsigned char)
+            (ji.dwButtons & (1UL << *count) ? GLFW_PRESS : GLFW_RELEASE);
+        (*count)++;
+    }
+
+    // Virtual buttons - Inject data from hats
+    // Each hat is exposed as 4 buttons which exposes 8 directions with
+    // concurrent button presses
+    // NOTE: this API exposes only one hat
+
+    if ((jc.wCaps & JOYCAPS_HASPOV) && (jc.wCaps & JOYCAPS_POV4DIR))
+    {
+        int i, value = ji.dwPOV / 100 / 45;
+
+        // Bit fields of button presses for each direction, including nil
+        const int directions[9] = { 1, 3, 2, 6, 4, 12, 8, 9, 0 };
+
+        if (value < 0 || value > 8)
+            value = 8;
+
+        for (i = 0;  i < 4;  i++)
+        {
+            if (directions[value] & (1 << i))
+                buttons[(*count)++] = GLFW_PRESS;
+            else
+                buttons[(*count)++] = GLFW_RELEASE;
+        }
+    }
+
+    return buttons;
+}
+
+const char* _glfwPlatformGetJoystickName(int joy)
+{
+    JOYCAPS jc;
+
+    if (_glfw_joyGetDevCaps(joy, &jc, sizeof(JOYCAPS)) != JOYERR_NOERROR)
+        return NULL;
+
+    free(_glfw.win32.joystick[joy].name);
+    _glfw.win32.joystick[joy].name = _glfwCreateUTF8FromWideString(jc.szPname);
+
+    return _glfw.win32.joystick[joy].name;
+}
+

external/Box2D-2.3.1/Box2D/glfw/win32_monitor.c

@@ -0,0 +1,284 @@
+//========================================================================
+// GLFW 3.0 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.
+//
+//========================================================================
+
+#include "internal.h"
+
+#include <stdlib.h>
+#include <string.h>
+#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
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW internal API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+// Change the current video mode
+//
+GLboolean _glfwSetVideoMode(_GLFWmonitor* monitor, const GLFWvidmode* desired)
+{
+    GLFWvidmode current;
+    const GLFWvidmode* best;
+    DEVMODE dm;
+
+    best = _glfwChooseVideoMode(monitor, desired);
+
+    _glfwPlatformGetVideoMode(monitor, &current);
+    if (_glfwCompareVideoModes(&current, best) == 0)
+        return GL_TRUE;
+
+    ZeroMemory(&dm, sizeof(dm));
+    dm.dmSize = sizeof(DEVMODE);
+    dm.dmFields           = DM_PELSWIDTH | DM_PELSHEIGHT | DM_BITSPERPEL |
+                            DM_DISPLAYFREQUENCY;
+    dm.dmPelsWidth        = best->width;
+    dm.dmPelsHeight       = best->height;
+    dm.dmBitsPerPel       = best->redBits + best->greenBits + best->blueBits;
+    dm.dmDisplayFrequency = best->refreshRate;
+
+    if (dm.dmBitsPerPel < 15 || dm.dmBitsPerPel >= 24)
+        dm.dmBitsPerPel = 32;
+
+    if (ChangeDisplaySettingsEx(monitor->win32.name,
+                                &dm,
+                                NULL,
+                                CDS_FULLSCREEN,
+                                NULL) != DISP_CHANGE_SUCCESSFUL)
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR, "Win32: Failed to set video mode");
+        return GL_FALSE;
+    }
+
+    return GL_TRUE;
+}
+
+// Restore the previously saved (original) video mode
+//
+void _glfwRestoreVideoMode(_GLFWmonitor* monitor)
+{
+    ChangeDisplaySettingsEx(monitor->win32.name,
+                            NULL, NULL, CDS_FULLSCREEN, NULL);
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW platform API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+_GLFWmonitor** _glfwPlatformGetMonitors(int* count)
+{
+    int size = 0, found = 0;
+    _GLFWmonitor** monitors = NULL;
+    DWORD adapterIndex = 0;
+    int primaryIndex = 0;
+
+    *count = 0;
+
+    for (;;)
+    {
+        DISPLAY_DEVICE adapter, display;
+        char* name;
+        HDC dc;
+
+        ZeroMemory(&adapter, sizeof(DISPLAY_DEVICE));
+        adapter.cb = sizeof(DISPLAY_DEVICE);
+
+        if (!EnumDisplayDevices(NULL, adapterIndex, &adapter, 0))
+            break;
+
+        adapterIndex++;
+
+        if ((adapter.StateFlags & DISPLAY_DEVICE_MIRRORING_DRIVER) ||
+            !(adapter.StateFlags & DISPLAY_DEVICE_ACTIVE))
+        {
+            continue;
+        }
+
+        if (found == size)
+        {
+            if (size)
+                size *= 2;
+            else
+                size = 4;
+
+            monitors = (_GLFWmonitor**) realloc(monitors, sizeof(_GLFWmonitor*) * size);
+        }
+
+        ZeroMemory(&display, sizeof(DISPLAY_DEVICE));
+        display.cb = sizeof(DISPLAY_DEVICE);
+
+        EnumDisplayDevices(adapter.DeviceName, 0, &display, 0);
+        dc = CreateDC(L"DISPLAY", display.DeviceString, NULL, NULL);
+
+        if (adapter.StateFlags & DISPLAY_DEVICE_PRIMARY_DEVICE)
+            primaryIndex = found;
+
+        name = _glfwCreateUTF8FromWideString(display.DeviceString);
+        if (!name)
+        {
+            _glfwDestroyMonitors(monitors, found);
+            _glfwInputError(GLFW_PLATFORM_ERROR,
+                            "Failed to convert string to UTF-8");
+
+            free(monitors);
+            return NULL;
+        }
+
+        monitors[found] = _glfwCreateMonitor(name,
+                                             GetDeviceCaps(dc, HORZSIZE),
+                                             GetDeviceCaps(dc, VERTSIZE));
+
+        free(name);
+        DeleteDC(dc);
+
+        wcscpy(monitors[found]->win32.name, adapter.DeviceName);
+        found++;
+    }
+
+    if (primaryIndex > 0)
+    {
+        _GLFWmonitor* temp = monitors[0];
+        monitors[0] = monitors[primaryIndex];
+        monitors[primaryIndex] = temp;
+    }
+
+    *count = found;
+    return monitors;
+}
+
+GLboolean _glfwPlatformIsSameMonitor(_GLFWmonitor* first, _GLFWmonitor* second)
+{
+    return wcscmp(first->win32.name, second->win32.name) == 0;
+}
+
+void _glfwPlatformGetMonitorPos(_GLFWmonitor* monitor, int* xpos, int* ypos)
+{
+    DEVMODE settings;
+    ZeroMemory(&settings, sizeof(DEVMODE));
+    settings.dmSize = sizeof(DEVMODE);
+
+    EnumDisplaySettingsEx(monitor->win32.name,
+                          ENUM_CURRENT_SETTINGS,
+                          &settings,
+                          EDS_ROTATEDMODE);
+
+    if (xpos)
+        *xpos = settings.dmPosition.x;
+    if (ypos)
+        *ypos = settings.dmPosition.y;
+}
+
+GLFWvidmode* _glfwPlatformGetVideoModes(_GLFWmonitor* monitor, int* found)
+{
+    int modeIndex = 0, count = 0;
+    GLFWvidmode* result = NULL;
+
+    *found = 0;
+
+    for (;;)
+    {
+        int i;
+        GLFWvidmode mode;
+        DEVMODE dm;
+
+        ZeroMemory(&dm, sizeof(DEVMODE));
+        dm.dmSize = sizeof(DEVMODE);
+
+        if (!EnumDisplaySettings(monitor->win32.name, modeIndex, &dm))
+            break;
+
+        modeIndex++;
+
+        if (dm.dmBitsPerPel < 15)
+        {
+            // Skip modes with less than 15 BPP
+            continue;
+        }
+
+        mode.width  = dm.dmPelsWidth;
+        mode.height = dm.dmPelsHeight;
+        mode.refreshRate = dm.dmDisplayFrequency;
+        _glfwSplitBPP(dm.dmBitsPerPel,
+                      &mode.redBits,
+                      &mode.greenBits,
+                      &mode.blueBits);
+
+        for (i = 0;  i < *found;  i++)
+        {
+            if (_glfwCompareVideoModes(result + i, &mode) == 0)
+                break;
+        }
+
+        if (i < *found)
+        {
+            // This is a duplicate, so skip it
+            continue;
+        }
+
+        if (*found == count)
+        {
+            if (count)
+                count *= 2;
+            else
+                count = 128;
+
+            result = (GLFWvidmode*) realloc(result, count * sizeof(GLFWvidmode));
+        }
+
+        result[*found] = mode;
+        (*found)++;
+    }
+
+    return result;
+}
+
+void _glfwPlatformGetVideoMode(_GLFWmonitor* monitor, GLFWvidmode* mode)
+{
+    DEVMODE dm;
+
+    ZeroMemory(&dm, sizeof(DEVMODE));
+    dm.dmSize = sizeof(DEVMODE);
+
+    EnumDisplaySettings(monitor->win32.name, ENUM_CURRENT_SETTINGS, &dm);
+
+    mode->width  = dm.dmPelsWidth;
+    mode->height = dm.dmPelsHeight;
+    mode->refreshRate = dm.dmDisplayFrequency;
+    _glfwSplitBPP(dm.dmBitsPerPel,
+                  &mode->redBits,
+                  &mode->greenBits,
+                  &mode->blueBits);
+}
+

external/Box2D-2.3.1/Box2D/glfw/win32_platform.h

@@ -0,0 +1,258 @@
+//========================================================================
+// GLFW 3.0 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 _win32_platform_h_
+#define _win32_platform_h_
+
+
+// We don't need all the fancy stuff
+#ifndef NOMINMAX
+ #define NOMINMAX
+#endif
+
+#ifndef VC_EXTRALEAN
+ #define VC_EXTRALEAN
+#endif
+
+#ifndef WIN32_LEAN_AND_MEAN
+ #define WIN32_LEAN_AND_MEAN
+#endif
+
+// This is a workaround for the fact that glfw3.h needs to export APIENTRY (to
+// correctly declare a GL_ARB_debug_output callback, for example) but windows.h
+// thinks it is the only one that gets to do so
+#undef APIENTRY
+
+// GLFW on Windows is Unicode only and does not work in MBCS mode
+#ifndef UNICODE
+ #define UNICODE
+#endif
+
+// GLFW requires Windows XP or later
+#if WINVER < 0x0501
+ #undef WINVER
+ #define WINVER 0x0501
+#endif
+#if _WIN32_WINNT < 0x0501
+ #undef _WIN32_WINNT
+ #define _WIN32_WINNT 0x0501
+#endif
+
+#include <windows.h>
+#include <mmsystem.h>
+#include <dbt.h>
+
+
+//========================================================================
+// Hack: Define things that some windows.h variants don't
+//========================================================================
+
+#ifndef WM_MOUSEHWHEEL
+ #define WM_MOUSEHWHEEL 0x020E
+#endif
+#ifndef WM_DWMCOMPOSITIONCHANGED
+ #define WM_DWMCOMPOSITIONCHANGED 0x031E
+#endif
+
+
+//========================================================================
+// DLLs that are loaded at glfwInit()
+//========================================================================
+
+// winmm.dll function pointer typedefs
+#ifndef _GLFW_NO_DLOAD_WINMM
+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);
+#endif // _GLFW_NO_DLOAD_WINMM
+
+
+// winmm.dll shortcuts
+#ifndef _GLFW_NO_DLOAD_WINMM
+ #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
+#else
+ #define _glfw_joyGetDevCaps joyGetDevCaps
+ #define _glfw_joyGetPos     joyGetPos
+ #define _glfw_joyGetPosEx   joyGetPosEx
+ #define _glfw_timeGetTime   timeGetTime
+#endif // _GLFW_NO_DLOAD_WINMM
+
+// user32.dll function pointer typedefs
+typedef BOOL (WINAPI * SETPROCESSDPIAWARE_T)(void);
+#define _glfw_SetProcessDPIAware _glfw.win32.user32.SetProcessDPIAware
+
+// dwmapi.dll function pointer typedefs
+typedef HRESULT (WINAPI * DWMISCOMPOSITIONENABLED_T)(BOOL*);
+#define _glfw_DwmIsCompositionEnabled _glfw.win32.dwmapi.DwmIsCompositionEnabled
+
+
+// We use versioned window class names in order not to cause conflicts
+// between applications using different versions of GLFW
+#define _GLFW_WNDCLASSNAME L"GLFW30"
+
+#define _GLFW_RECREATION_NOT_NEEDED 0
+#define _GLFW_RECREATION_REQUIRED   1
+#define _GLFW_RECREATION_IMPOSSIBLE 2
+
+
+#if defined(_GLFW_WGL)
+ #include "wgl_platform.h"
+#elif defined(_GLFW_EGL)
+ #define _GLFW_EGL_NATIVE_WINDOW  window->win32.handle
+ #define _GLFW_EGL_NATIVE_DISPLAY EGL_DEFAULT_DISPLAY
+ #include "egl_platform.h"
+#else
+ #error "No supported context creation API selected"
+#endif
+
+#define _GLFW_PLATFORM_WINDOW_STATE         _GLFWwindowWin32  win32
+#define _GLFW_PLATFORM_LIBRARY_WINDOW_STATE _GLFWlibraryWin32 win32
+#define _GLFW_PLATFORM_MONITOR_STATE        _GLFWmonitorWin32 win32
+
+
+//========================================================================
+// GLFW platform specific types
+//========================================================================
+
+
+//------------------------------------------------------------------------
+// Platform-specific window structure
+//------------------------------------------------------------------------
+typedef struct _GLFWwindowWin32
+{
+    // Platform specific window resources
+    HWND                handle;    // Window handle
+    DWORD               dwStyle;   // Window styles used for window creation
+    DWORD               dwExStyle; // --"--
+
+    // Various platform specific internal variables
+    GLboolean           cursorCentered;
+    GLboolean           cursorInside;
+    GLboolean           cursorHidden;
+    double              oldCursorX, oldCursorY;
+} _GLFWwindowWin32;
+
+
+//------------------------------------------------------------------------
+// Platform-specific library global data for Win32
+//------------------------------------------------------------------------
+typedef struct _GLFWlibraryWin32
+{
+    ATOM                classAtom;
+    DWORD               foregroundLockTimeout;
+    char*               clipboardString;
+
+    // Timer data
+    struct {
+        GLboolean       hasPC;
+        double          resolution;
+        unsigned int    t0_32;
+        __int64         t0_64;
+    } timer;
+
+#ifndef _GLFW_NO_DLOAD_WINMM
+    // winmm.dll
+    struct {
+        HINSTANCE       instance;
+        JOYGETDEVCAPS_T joyGetDevCaps;
+        JOYGETPOS_T     joyGetPos;
+        JOYGETPOSEX_T   joyGetPosEx;
+        TIMEGETTIME_T   timeGetTime;
+    } winmm;
+#endif // _GLFW_NO_DLOAD_WINMM
+
+    // user32.dll
+    struct {
+        HINSTANCE       instance;
+        SETPROCESSDPIAWARE_T SetProcessDPIAware;
+    } user32;
+
+    // dwmapi.dll
+    struct {
+        HINSTANCE       instance;
+        DWMISCOMPOSITIONENABLED_T DwmIsCompositionEnabled;
+    } dwmapi;
+
+    struct {
+        float           axes[6];
+        unsigned char   buttons[36]; // 32 buttons plus one hat
+        char*           name;
+    } joystick[GLFW_JOYSTICK_LAST + 1];
+
+} _GLFWlibraryWin32;
+
+
+//------------------------------------------------------------------------
+// Platform-specific monitor structure
+//------------------------------------------------------------------------
+typedef struct _GLFWmonitorWin32
+{
+    // This size matches the static size of DISPLAY_DEVICE.DeviceName
+    WCHAR               name[32];
+
+} _GLFWmonitorWin32;
+
+
+//========================================================================
+// Prototypes for platform specific internal functions
+//========================================================================
+
+// Desktop compositing
+BOOL _glfwIsCompositionEnabled(void);
+
+// Wide strings
+WCHAR* _glfwCreateWideStringFromUTF8(const char* source);
+char* _glfwCreateUTF8FromWideString(const WCHAR* source);
+
+// Time
+void _glfwInitTimer(void);
+
+// Joystick input
+void _glfwInitJoysticks(void);
+void _glfwTerminateJoysticks(void);
+
+// OpenGL support
+int _glfwInitContextAPI(void);
+void _glfwTerminateContextAPI(void);
+int _glfwCreateContext(_GLFWwindow* window,
+                       const _GLFWwndconfig* wndconfig,
+                       const _GLFWfbconfig* fbconfig);
+void _glfwDestroyContext(_GLFWwindow* window);
+int _glfwAnalyzeContext(const _GLFWwindow* window,
+                        const _GLFWwndconfig* wndconfig,
+                        const _GLFWfbconfig* fbconfig);
+
+// Fullscreen support
+GLboolean _glfwSetVideoMode(_GLFWmonitor* monitor, const GLFWvidmode* desired);
+void _glfwRestoreVideoMode(_GLFWmonitor* monitor);
+
+
+#endif // _win32_platform_h_

external/Box2D-2.3.1/Box2D/glfw/win32_time.c

@@ -0,0 +1,88 @@
+//========================================================================
+// GLFW 3.0 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.
+//
+//========================================================================
+
+#include "internal.h"
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW internal API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+// Initialise timer
+//
+void _glfwInitTimer(void)
+{
+    __int64 freq;
+
+    if (QueryPerformanceFrequency((LARGE_INTEGER*) &freq))
+    {
+        _glfw.win32.timer.hasPC = GL_TRUE;
+        _glfw.win32.timer.resolution = 1.0 / (double) freq;
+        QueryPerformanceCounter((LARGE_INTEGER*) &_glfw.win32.timer.t0_64);
+    }
+    else
+    {
+        _glfw.win32.timer.hasPC = GL_FALSE;
+        _glfw.win32.timer.resolution = 0.001; // winmm resolution is 1 ms
+        _glfw.win32.timer.t0_32 = _glfw_timeGetTime();
+    }
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW platform API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+double _glfwPlatformGetTime(void)
+{
+    double t;
+    __int64 t_64;
+
+    if (_glfw.win32.timer.hasPC)
+    {
+        QueryPerformanceCounter((LARGE_INTEGER*) &t_64);
+        t =  (double)(t_64 - _glfw.win32.timer.t0_64);
+    }
+    else
+        t = (double)(_glfw_timeGetTime() - _glfw.win32.timer.t0_32);
+
+    return t * _glfw.win32.timer.resolution;
+}
+
+void _glfwPlatformSetTime(double t)
+{
+    __int64 t_64;
+
+    if (_glfw.win32.timer.hasPC)
+    {
+        QueryPerformanceCounter((LARGE_INTEGER*) &t_64);
+        _glfw.win32.timer.t0_64 = t_64 - (__int64) (t / _glfw.win32.timer.resolution);
+    }
+    else
+        _glfw.win32.timer.t0_32 = _glfw_timeGetTime() - (int)(t * 1000.0);
+}
+

external/Box2D-2.3.1/Box2D/glfw/window.c

@@ -0,0 +1,674 @@
+//========================================================================
+// GLFW 3.0 - www.glfw.org
+//------------------------------------------------------------------------
+// Copyright (c) 2002-2006 Marcus Geelnard
+// Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
+// Copyright (c) 2012 Torsten Walluhn <tw@mad-cad.net>
+//
+// 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 <string.h>
+#include <stdlib.h>
+#if defined(_MSC_VER)
+ #include <malloc.h>
+#endif
+
+
+// Return the maxiumum of the specified values
+//
+static int Max(int a, int b)
+{
+    return (a > b) ? a : b;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                         GLFW event API                       //////
+//////////////////////////////////////////////////////////////////////////
+
+void _glfwInputWindowFocus(_GLFWwindow* window, GLboolean focused)
+{
+    if (focused)
+    {
+        if (_glfw.focusedWindow != window)
+        {
+            _glfw.focusedWindow = window;
+
+            if (window->callbacks.focus)
+                window->callbacks.focus((GLFWwindow*) window, focused);
+        }
+    }
+    else
+    {
+        if (_glfw.focusedWindow == window)
+        {
+            int i;
+
+            _glfw.focusedWindow = NULL;
+
+            if (window->callbacks.focus)
+                window->callbacks.focus((GLFWwindow*) window, focused);
+
+            // Release all pressed keyboard keys
+            for (i = 0;  i <= GLFW_KEY_LAST;  i++)
+            {
+                if (window->key[i] == GLFW_PRESS)
+                    _glfwInputKey(window, i, 0, GLFW_RELEASE, 0);
+            }
+
+            // Release all pressed mouse buttons
+            for (i = 0;  i <= GLFW_MOUSE_BUTTON_LAST;  i++)
+            {
+                if (window->mouseButton[i] == GLFW_PRESS)
+                    _glfwInputMouseClick(window, i, GLFW_RELEASE, 0);
+            }
+        }
+    }
+}
+
+void _glfwInputWindowPos(_GLFWwindow* window, int x, int y)
+{
+    if (window->callbacks.pos)
+        window->callbacks.pos((GLFWwindow*) window, x, y);
+}
+
+void _glfwInputWindowSize(_GLFWwindow* window, int width, int height)
+{
+    if (window->callbacks.size)
+        window->callbacks.size((GLFWwindow*) window, width, height);
+}
+
+void _glfwInputWindowIconify(_GLFWwindow* window, int iconified)
+{
+    if (window->iconified == iconified)
+        return;
+
+    window->iconified = iconified;
+
+    if (window->callbacks.iconify)
+        window->callbacks.iconify((GLFWwindow*) window, iconified);
+}
+
+void _glfwInputFramebufferSize(_GLFWwindow* window, int width, int height)
+{
+    if (window->callbacks.fbsize)
+        window->callbacks.fbsize((GLFWwindow*) window, width, height);
+}
+
+void _glfwInputWindowVisibility(_GLFWwindow* window, int visible)
+{
+    window->visible = visible;
+}
+
+void _glfwInputWindowDamage(_GLFWwindow* window)
+{
+    if (window->callbacks.refresh)
+        window->callbacks.refresh((GLFWwindow*) window);
+}
+
+void _glfwInputWindowCloseRequest(_GLFWwindow* window)
+{
+        window->closed = GL_TRUE;
+
+    if (window->callbacks.close)
+        window->callbacks.close((GLFWwindow*) window);
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                        GLFW public API                       //////
+//////////////////////////////////////////////////////////////////////////
+
+GLFWAPI GLFWwindow* glfwCreateWindow(int width, int height,
+                                     const char* title,
+                                     GLFWmonitor* monitor,
+                                     GLFWwindow* share)
+{
+    _GLFWfbconfig fbconfig;
+    _GLFWwndconfig wndconfig;
+    _GLFWwindow* window;
+    _GLFWwindow* previous;
+
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+
+    if (width <= 0 || height <= 0)
+    {
+        _glfwInputError(GLFW_INVALID_VALUE, "Invalid window size");
+        return NULL;
+    }
+
+    // Set up desired framebuffer config
+    fbconfig.redBits        = Max(_glfw.hints.redBits, 0);
+    fbconfig.greenBits      = Max(_glfw.hints.greenBits, 0);
+    fbconfig.blueBits       = Max(_glfw.hints.blueBits, 0);
+    fbconfig.alphaBits      = Max(_glfw.hints.alphaBits, 0);
+    fbconfig.depthBits      = Max(_glfw.hints.depthBits, 0);
+    fbconfig.stencilBits    = Max(_glfw.hints.stencilBits, 0);
+    fbconfig.accumRedBits   = Max(_glfw.hints.accumRedBits, 0);
+    fbconfig.accumGreenBits = Max(_glfw.hints.accumGreenBits, 0);
+    fbconfig.accumBlueBits  = Max(_glfw.hints.accumBlueBits, 0);
+    fbconfig.accumAlphaBits = Max(_glfw.hints.accumAlphaBits, 0);
+    fbconfig.auxBuffers     = Max(_glfw.hints.auxBuffers, 0);
+    fbconfig.stereo         = _glfw.hints.stereo ? GL_TRUE : GL_FALSE;
+    fbconfig.samples        = Max(_glfw.hints.samples, 0);
+    fbconfig.sRGB           = _glfw.hints.sRGB ? GL_TRUE : GL_FALSE;
+
+    // Set up desired window config
+    wndconfig.width         = width;
+    wndconfig.height        = height;
+    wndconfig.title         = title;
+    wndconfig.resizable     = _glfw.hints.resizable ? GL_TRUE : GL_FALSE;
+    wndconfig.visible       = _glfw.hints.visible ? GL_TRUE : GL_FALSE;
+    wndconfig.decorated     = _glfw.hints.decorated ? GL_TRUE : GL_FALSE;
+    wndconfig.clientAPI     = _glfw.hints.clientAPI;
+    wndconfig.glMajor       = _glfw.hints.glMajor;
+    wndconfig.glMinor       = _glfw.hints.glMinor;
+    wndconfig.glForward     = _glfw.hints.glForward ? GL_TRUE : GL_FALSE;
+    wndconfig.glDebug       = _glfw.hints.glDebug ? GL_TRUE : GL_FALSE;
+    wndconfig.glProfile     = _glfw.hints.glProfile;
+    wndconfig.glRobustness  = _glfw.hints.glRobustness;
+    wndconfig.monitor       = (_GLFWmonitor*) monitor;
+    wndconfig.share         = (_GLFWwindow*) share;
+
+    // Check the OpenGL bits of the window config
+    if (!_glfwIsValidContextConfig(&wndconfig))
+        return NULL;
+
+    window = calloc(1, sizeof(_GLFWwindow));
+    window->next = _glfw.windowListHead;
+    _glfw.windowListHead = window;
+
+    if (wndconfig.monitor)
+    {
+        wndconfig.resizable = GL_TRUE;
+        wndconfig.visible   = GL_TRUE;
+
+        // Set up desired video mode
+        window->videoMode.width       = width;
+        window->videoMode.height      = height;
+        window->videoMode.redBits     = Max(_glfw.hints.redBits, 0);
+        window->videoMode.greenBits   = Max(_glfw.hints.greenBits, 0);
+        window->videoMode.blueBits    = Max(_glfw.hints.blueBits, 0);
+        window->videoMode.refreshRate = Max(_glfw.hints.refreshRate, 0);
+    }
+
+    window->monitor     = wndconfig.monitor;
+    window->resizable   = wndconfig.resizable;
+    window->decorated   = wndconfig.decorated;
+    window->cursorMode  = GLFW_CURSOR_NORMAL;
+
+    // Save the currently current context so it can be restored later
+    previous = (_GLFWwindow*) glfwGetCurrentContext();
+
+    // Open the actual window and create its context
+    if (!_glfwPlatformCreateWindow(window, &wndconfig, &fbconfig))
+    {
+        glfwDestroyWindow((GLFWwindow*) window);
+        glfwMakeContextCurrent((GLFWwindow*) previous);
+        return NULL;
+    }
+
+    glfwMakeContextCurrent((GLFWwindow*) window);
+
+    // Retrieve the actual (as opposed to requested) context attributes
+    if (!_glfwRefreshContextAttribs())
+    {
+        glfwDestroyWindow((GLFWwindow*) window);
+        glfwMakeContextCurrent((GLFWwindow*) previous);
+        return NULL;
+    }
+
+    // Verify the context against the requested parameters
+    if (!_glfwIsValidContext(&wndconfig))
+    {
+        glfwDestroyWindow((GLFWwindow*) window);
+        glfwMakeContextCurrent((GLFWwindow*) previous);
+        return NULL;
+    }
+
+    // Clearing the front buffer to black to avoid garbage pixels left over
+    // from previous uses of our bit of VRAM
+    glClear(GL_COLOR_BUFFER_BIT);
+    _glfwPlatformSwapBuffers(window);
+
+    // Restore the previously current context (or NULL)
+    glfwMakeContextCurrent((GLFWwindow*) previous);
+
+    if (wndconfig.monitor == NULL && wndconfig.visible)
+        glfwShowWindow((GLFWwindow*) window);
+
+    return (GLFWwindow*) window;
+}
+
+void glfwDefaultWindowHints(void)
+{
+    _GLFW_REQUIRE_INIT();
+
+    memset(&_glfw.hints, 0, sizeof(_glfw.hints));
+
+    // The default is OpenGL with minimum version 1.0
+    _glfw.hints.clientAPI = GLFW_OPENGL_API;
+    _glfw.hints.glMajor = 1;
+    _glfw.hints.glMinor = 0;
+
+    // The default is a visible, resizable window with decorations
+    _glfw.hints.resizable = GL_TRUE;
+    _glfw.hints.visible   = GL_TRUE;
+    _glfw.hints.decorated = GL_TRUE;
+
+    // The default is 24 bits of color, 24 bits of depth and 8 bits of stencil
+    _glfw.hints.redBits     = 8;
+    _glfw.hints.greenBits   = 8;
+    _glfw.hints.blueBits    = 8;
+    _glfw.hints.alphaBits   = 8;
+    _glfw.hints.depthBits   = 24;
+    _glfw.hints.stencilBits = 8;
+}
+
+GLFWAPI void glfwWindowHint(int target, int hint)
+{
+    _GLFW_REQUIRE_INIT();
+
+    switch (target)
+    {
+        case GLFW_RED_BITS:
+            _glfw.hints.redBits = hint;
+            break;
+        case GLFW_GREEN_BITS:
+            _glfw.hints.greenBits = hint;
+            break;
+        case GLFW_BLUE_BITS:
+            _glfw.hints.blueBits = hint;
+            break;
+        case GLFW_ALPHA_BITS:
+            _glfw.hints.alphaBits = hint;
+            break;
+        case GLFW_DEPTH_BITS:
+            _glfw.hints.depthBits = hint;
+            break;
+        case GLFW_STENCIL_BITS:
+            _glfw.hints.stencilBits = hint;
+            break;
+        case GLFW_ACCUM_RED_BITS:
+            _glfw.hints.accumRedBits = hint;
+            break;
+        case GLFW_ACCUM_GREEN_BITS:
+            _glfw.hints.accumGreenBits = hint;
+            break;
+        case GLFW_ACCUM_BLUE_BITS:
+            _glfw.hints.accumBlueBits = hint;
+            break;
+        case GLFW_ACCUM_ALPHA_BITS:
+            _glfw.hints.accumAlphaBits = hint;
+            break;
+        case GLFW_AUX_BUFFERS:
+            _glfw.hints.auxBuffers = hint;
+            break;
+        case GLFW_STEREO:
+            _glfw.hints.stereo = hint;
+            break;
+        case GLFW_REFRESH_RATE:
+            _glfw.hints.refreshRate = hint;
+            break;
+        case GLFW_RESIZABLE:
+            _glfw.hints.resizable = hint;
+            break;
+        case GLFW_DECORATED:
+            _glfw.hints.decorated = hint;
+            break;
+        case GLFW_VISIBLE:
+            _glfw.hints.visible = hint;
+            break;
+        case GLFW_SAMPLES:
+            _glfw.hints.samples = hint;
+            break;
+        case GLFW_SRGB_CAPABLE:
+            _glfw.hints.sRGB = hint;
+            break;
+        case GLFW_CLIENT_API:
+            _glfw.hints.clientAPI = hint;
+            break;
+        case GLFW_CONTEXT_VERSION_MAJOR:
+            _glfw.hints.glMajor = hint;
+            break;
+        case GLFW_CONTEXT_VERSION_MINOR:
+            _glfw.hints.glMinor = hint;
+            break;
+        case GLFW_CONTEXT_ROBUSTNESS:
+            _glfw.hints.glRobustness = hint;
+            break;
+        case GLFW_OPENGL_FORWARD_COMPAT:
+            _glfw.hints.glForward = hint;
+            break;
+        case GLFW_OPENGL_DEBUG_CONTEXT:
+            _glfw.hints.glDebug = hint;
+            break;
+        case GLFW_OPENGL_PROFILE:
+            _glfw.hints.glProfile = hint;
+            break;
+        default:
+            _glfwInputError(GLFW_INVALID_ENUM, NULL);
+            break;
+    }
+}
+
+GLFWAPI void glfwDestroyWindow(GLFWwindow* handle)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+
+    _GLFW_REQUIRE_INIT();
+
+    // Allow closing of NULL (to match the behavior of free)
+    if (window == NULL)
+        return;
+
+    // Clear all callbacks to avoid exposing a half torn-down window object
+    memset(&window->callbacks, 0, sizeof(window->callbacks));
+
+    // The window's context must not be current on another thread when the
+    // window is destroyed
+    if (window == _glfwPlatformGetCurrentContext())
+        _glfwPlatformMakeContextCurrent(NULL);
+
+    // Clear the focused window pointer if this is the focused window
+    if (window == _glfw.focusedWindow)
+        _glfw.focusedWindow = NULL;
+
+    _glfwPlatformDestroyWindow(window);
+
+    // Unlink window from global linked list
+    {
+        _GLFWwindow** prev = &_glfw.windowListHead;
+
+        while (*prev != window)
+            prev = &((*prev)->next);
+
+        *prev = window->next;
+    }
+
+    free(window);
+}
+
+GLFWAPI int glfwWindowShouldClose(GLFWwindow* handle)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    _GLFW_REQUIRE_INIT_OR_RETURN(0);
+    return window->closed;
+}
+
+GLFWAPI void glfwSetWindowShouldClose(GLFWwindow* handle, int value)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    _GLFW_REQUIRE_INIT();
+    window->closed = value;
+}
+
+GLFWAPI void glfwSetWindowTitle(GLFWwindow* handle, const char* title)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    _GLFW_REQUIRE_INIT();
+    _glfwPlatformSetWindowTitle(window, title);
+}
+
+GLFWAPI void glfwGetWindowPos(GLFWwindow* handle, int* xpos, int* ypos)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    _GLFW_REQUIRE_INIT();
+    _glfwPlatformGetWindowPos(window, xpos, ypos);
+}
+
+GLFWAPI void glfwSetWindowPos(GLFWwindow* handle, int xpos, int ypos)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+
+    _GLFW_REQUIRE_INIT();
+
+    if (window->monitor)
+    {
+        _glfwInputError(GLFW_INVALID_VALUE,
+                        "Fullscreen windows cannot be positioned");
+        return;
+    }
+
+    _glfwPlatformSetWindowPos(window, xpos, ypos);
+}
+
+GLFWAPI void glfwGetWindowSize(GLFWwindow* handle, int* width, int* height)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    _GLFW_REQUIRE_INIT();
+    _glfwPlatformGetWindowSize(window, width, height);
+}
+
+GLFWAPI void glfwSetWindowSize(GLFWwindow* handle, int width, int height)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+
+    _GLFW_REQUIRE_INIT();
+
+    if (window->iconified)
+        return;
+
+    if (window->monitor)
+    {
+        window->videoMode.width  = width;
+        window->videoMode.height = height;
+    }
+
+    _glfwPlatformSetWindowSize(window, width, height);
+}
+
+GLFWAPI void glfwGetFramebufferSize(GLFWwindow* handle, int* width, int* height)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+
+    _GLFW_REQUIRE_INIT();
+
+    _glfwPlatformGetFramebufferSize(window, width, height);
+}
+
+GLFWAPI void glfwIconifyWindow(GLFWwindow* handle)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+
+    _GLFW_REQUIRE_INIT();
+
+    if (window->iconified)
+        return;
+
+    _glfwPlatformIconifyWindow(window);
+}
+
+GLFWAPI void glfwRestoreWindow(GLFWwindow* handle)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+
+    _GLFW_REQUIRE_INIT();
+
+    if (!window->iconified)
+        return;
+
+    _glfwPlatformRestoreWindow(window);
+}
+
+GLFWAPI void glfwShowWindow(GLFWwindow* handle)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+
+    _GLFW_REQUIRE_INIT();
+
+    if (window->monitor)
+        return;
+
+    _glfwPlatformShowWindow(window);
+}
+
+GLFWAPI void glfwHideWindow(GLFWwindow* handle)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+
+    _GLFW_REQUIRE_INIT();
+
+    if (window->monitor)
+        return;
+
+    _glfwPlatformHideWindow(window);
+}
+
+GLFWAPI int glfwGetWindowAttrib(GLFWwindow* handle, int attrib)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+
+    _GLFW_REQUIRE_INIT_OR_RETURN(0);
+
+    switch (attrib)
+    {
+        case GLFW_FOCUSED:
+            return window == _glfw.focusedWindow;
+        case GLFW_ICONIFIED:
+            return window->iconified;
+        case GLFW_RESIZABLE:
+            return window->resizable;
+        case GLFW_DECORATED:
+            return window->decorated;
+        case GLFW_VISIBLE:
+            return window->visible;
+        case GLFW_CLIENT_API:
+            return window->clientAPI;
+        case GLFW_CONTEXT_VERSION_MAJOR:
+            return window->glMajor;
+        case GLFW_CONTEXT_VERSION_MINOR:
+            return window->glMinor;
+        case GLFW_CONTEXT_REVISION:
+            return window->glRevision;
+        case GLFW_CONTEXT_ROBUSTNESS:
+            return window->glRobustness;
+        case GLFW_OPENGL_FORWARD_COMPAT:
+            return window->glForward;
+        case GLFW_OPENGL_DEBUG_CONTEXT:
+            return window->glDebug;
+        case GLFW_OPENGL_PROFILE:
+            return window->glProfile;
+    }
+
+    _glfwInputError(GLFW_INVALID_ENUM, NULL);
+    return 0;
+}
+
+GLFWAPI GLFWmonitor* glfwGetWindowMonitor(GLFWwindow* handle)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+    return (GLFWmonitor*) window->monitor;
+}
+
+GLFWAPI void glfwSetWindowUserPointer(GLFWwindow* handle, void* pointer)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    _GLFW_REQUIRE_INIT();
+    window->userPointer = pointer;
+}
+
+GLFWAPI void* glfwGetWindowUserPointer(GLFWwindow* handle)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+    return window->userPointer;
+}
+
+GLFWAPI GLFWwindowposfun glfwSetWindowPosCallback(GLFWwindow* handle,
+                                                  GLFWwindowposfun cbfun)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+    _GLFW_SWAP_POINTERS(window->callbacks.pos, cbfun);
+    return cbfun;
+}
+
+GLFWAPI GLFWwindowsizefun glfwSetWindowSizeCallback(GLFWwindow* handle,
+                                                    GLFWwindowsizefun cbfun)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+    _GLFW_SWAP_POINTERS(window->callbacks.size, cbfun);
+    return cbfun;
+}
+
+GLFWAPI GLFWwindowclosefun glfwSetWindowCloseCallback(GLFWwindow* handle,
+                                                      GLFWwindowclosefun cbfun)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+    _GLFW_SWAP_POINTERS(window->callbacks.close, cbfun);
+    return cbfun;
+}
+
+GLFWAPI GLFWwindowrefreshfun glfwSetWindowRefreshCallback(GLFWwindow* handle,
+                                                          GLFWwindowrefreshfun cbfun)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+    _GLFW_SWAP_POINTERS(window->callbacks.refresh, cbfun);
+    return cbfun;
+}
+
+GLFWAPI GLFWwindowfocusfun glfwSetWindowFocusCallback(GLFWwindow* handle,
+                                                      GLFWwindowfocusfun cbfun)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+    _GLFW_SWAP_POINTERS(window->callbacks.focus, cbfun);
+    return cbfun;
+}
+
+GLFWAPI GLFWwindowiconifyfun glfwSetWindowIconifyCallback(GLFWwindow* handle,
+                                                          GLFWwindowiconifyfun cbfun)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+    _GLFW_SWAP_POINTERS(window->callbacks.iconify, cbfun);
+    return cbfun;
+}
+
+GLFWAPI GLFWframebuffersizefun glfwSetFramebufferSizeCallback(GLFWwindow* handle,
+                                                              GLFWframebuffersizefun cbfun)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+    _GLFW_SWAP_POINTERS(window->callbacks.fbsize, cbfun);
+    return cbfun;
+}
+
+GLFWAPI void glfwPollEvents(void)
+{
+    _GLFW_REQUIRE_INIT();
+    _glfwPlatformPollEvents();
+}
+
+GLFWAPI void glfwWaitEvents(void)
+{
+    _GLFW_REQUIRE_INIT();
+    _glfwPlatformWaitEvents();
+}
+

external/Box2D-2.3.1/Box2D/glfw/x11_clipboard.c

@@ -0,0 +1,335 @@
+//========================================================================
+// GLFW 3.0 X11 - www.glfw.org
+//------------------------------------------------------------------------
+// Copyright (c) 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.
+//
+//========================================================================
+
+#include "internal.h"
+
+#include <stdio.h>
+#include <limits.h>
+#include <string.h>
+#include <stdlib.h>
+
+
+// Returns whether the event is a selection event
+//
+static Bool isSelectionMessage(Display* display, XEvent* event, XPointer pointer)
+{
+    return event->type == SelectionRequest ||
+           event->type == SelectionNotify ||
+           event->type == SelectionClear;
+}
+
+// Set the specified property to the selection converted to the requested target
+//
+static Atom writeTargetToProperty(const XSelectionRequestEvent* request)
+{
+    int i;
+    const Atom formats[] = { _glfw.x11.UTF8_STRING,
+                             _glfw.x11.COMPOUND_STRING,
+                             XA_STRING };
+    const int formatCount = sizeof(formats) / sizeof(formats[0]);
+
+    if (request->property == None)
+    {
+        // The requestor is a legacy client (ICCCM section 2.2)
+        // We don't support legacy clients, so fail here
+        return None;
+    }
+
+    if (request->target == _glfw.x11.TARGETS)
+    {
+        // The list of supported targets was requested
+
+        const Atom targets[] = { _glfw.x11.TARGETS,
+                                 _glfw.x11.MULTIPLE,
+                                 _glfw.x11.UTF8_STRING,
+                                 _glfw.x11.COMPOUND_STRING,
+                                 XA_STRING };
+
+        XChangeProperty(_glfw.x11.display,
+                        request->requestor,
+                        request->property,
+                        XA_ATOM,
+                        32,
+                        PropModeReplace,
+                        (unsigned char*) targets,
+                        sizeof(targets) / sizeof(targets[0]));
+
+        return request->property;
+    }
+
+    if (request->target == _glfw.x11.MULTIPLE)
+    {
+        // Multiple conversions were requested
+
+        Atom* targets;
+        unsigned long i, count;
+
+        count = _glfwGetWindowProperty(request->requestor,
+                                       request->property,
+                                       _glfw.x11.ATOM_PAIR,
+                                       (unsigned char**) &targets);
+
+        for (i = 0;  i < count;  i += 2)
+        {
+            int j;
+
+            for (j = 0;  j < formatCount;  j++)
+            {
+                if (targets[i] == formats[j])
+                    break;
+            }
+
+            if (j < formatCount)
+            {
+                XChangeProperty(_glfw.x11.display,
+                                request->requestor,
+                                targets[i + 1],
+                                targets[i],
+                                8,
+                                PropModeReplace,
+                                (unsigned char*) _glfw.x11.selection.string,
+                                strlen(_glfw.x11.selection.string));
+            }
+            else
+                targets[i + 1] = None;
+        }
+
+        XChangeProperty(_glfw.x11.display,
+                        request->requestor,
+                        request->property,
+                        _glfw.x11.ATOM_PAIR,
+                        32,
+                        PropModeReplace,
+                        (unsigned char*) targets,
+                        count);
+
+        XFree(targets);
+
+        return request->property;
+    }
+
+    if (request->target == _glfw.x11.SAVE_TARGETS)
+    {
+        // The request is a check whether we support SAVE_TARGETS
+        // It should be handled as a no-op side effect target
+
+        XChangeProperty(_glfw.x11.display,
+                        request->requestor,
+                        request->property,
+                        XInternAtom(_glfw.x11.display, "NULL", False),
+                        32,
+                        PropModeReplace,
+                        NULL,
+                        0);
+
+        return request->property;
+    }
+
+    // Conversion to a data target was requested
+
+    for (i = 0;  i < formatCount;  i++)
+    {
+        if (request->target == formats[i])
+        {
+            // The requested target is one we support
+
+            XChangeProperty(_glfw.x11.display,
+                            request->requestor,
+                            request->property,
+                            request->target,
+                            8,
+                            PropModeReplace,
+                            (unsigned char*) _glfw.x11.selection.string,
+                            strlen(_glfw.x11.selection.string));
+
+            return request->property;
+        }
+    }
+
+    // The requested target is not supported
+
+    return None;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW internal API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+void _glfwHandleSelectionClear(XEvent* event)
+{
+    free(_glfw.x11.selection.string);
+    _glfw.x11.selection.string = NULL;
+}
+
+void _glfwHandleSelectionRequest(XEvent* event)
+{
+    const XSelectionRequestEvent* request = &event->xselectionrequest;
+
+    XEvent response;
+    memset(&response, 0, sizeof(response));
+
+    response.xselection.property = writeTargetToProperty(request);
+    response.xselection.type = SelectionNotify;
+    response.xselection.display = request->display;
+    response.xselection.requestor = request->requestor;
+    response.xselection.selection = request->selection;
+    response.xselection.target = request->target;
+    response.xselection.time = request->time;
+
+    XSendEvent(_glfw.x11.display, request->requestor, False, 0, &response);
+}
+
+void _glfwPushSelectionToManager(_GLFWwindow* window)
+{
+    XConvertSelection(_glfw.x11.display,
+                      _glfw.x11.CLIPBOARD_MANAGER,
+                      _glfw.x11.SAVE_TARGETS,
+                      None,
+                      window->x11.handle,
+                      CurrentTime);
+
+    for (;;)
+    {
+        XEvent event;
+
+        if (!XCheckIfEvent(_glfw.x11.display, &event, isSelectionMessage, NULL))
+            continue;
+
+        switch (event.type)
+        {
+            case SelectionRequest:
+                _glfwHandleSelectionRequest(&event);
+                break;
+
+            case SelectionClear:
+                _glfwHandleSelectionClear(&event);
+                break;
+
+            case SelectionNotify:
+            {
+                if (event.xselection.target == _glfw.x11.SAVE_TARGETS)
+                {
+                    // This means one of two things; either the selection was
+                    // not owned, which means there is no clipboard manager, or
+                    // the transfer to the clipboard manager has completed
+                    // In either case, it means we are done here
+                    return;
+                }
+
+                break;
+            }
+        }
+    }
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW platform API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+void _glfwPlatformSetClipboardString(_GLFWwindow* window, const char* string)
+{
+    free(_glfw.x11.selection.string);
+    _glfw.x11.selection.string = strdup(string);
+
+    XSetSelectionOwner(_glfw.x11.display,
+                       _glfw.x11.CLIPBOARD,
+                       window->x11.handle, CurrentTime);
+
+    if (XGetSelectionOwner(_glfw.x11.display, _glfw.x11.CLIPBOARD) !=
+        window->x11.handle)
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "X11: Failed to become owner of the clipboard selection");
+    }
+}
+
+const char* _glfwPlatformGetClipboardString(_GLFWwindow* window)
+{
+    size_t i;
+    const Atom formats[] = { _glfw.x11.UTF8_STRING,
+                             _glfw.x11.COMPOUND_STRING,
+                             XA_STRING };
+    const size_t formatCount = sizeof(formats) / sizeof(formats[0]);
+
+    if (_glfwFindWindowByHandle(XGetSelectionOwner(_glfw.x11.display,
+                                                   _glfw.x11.CLIPBOARD)))
+    {
+        // Instead of doing a large number of X round-trips just to put this
+        // string into a window property and then read it back, just return it
+        return _glfw.x11.selection.string;
+    }
+
+    free(_glfw.x11.selection.string);
+    _glfw.x11.selection.string = NULL;
+
+    for (i = 0;  i < formatCount;  i++)
+    {
+        char* data;
+        XEvent event;
+
+        XConvertSelection(_glfw.x11.display,
+                          _glfw.x11.CLIPBOARD,
+                          formats[i],
+                          _glfw.x11.GLFW_SELECTION,
+                          window->x11.handle, CurrentTime);
+
+        // XCheckTypedEvent is used instead of XIfEvent in order not to lock
+        // other threads out from the display during the entire wait period
+        while (!XCheckTypedEvent(_glfw.x11.display, SelectionNotify, &event))
+            ;
+
+        if (event.xselection.property == None)
+            continue;
+
+        if (_glfwGetWindowProperty(event.xselection.requestor,
+                                   event.xselection.property,
+                                   event.xselection.target,
+                                   (unsigned char**) &data))
+        {
+            _glfw.x11.selection.string = strdup(data);
+        }
+
+        XFree(data);
+
+        XDeleteProperty(_glfw.x11.display,
+                        event.xselection.requestor,
+                        event.xselection.property);
+
+        if (_glfw.x11.selection.string)
+            break;
+    }
+
+    if (_glfw.x11.selection.string == NULL)
+    {
+        _glfwInputError(GLFW_FORMAT_UNAVAILABLE,
+                        "X11: Failed to convert selection to string");
+    }
+
+    return _glfw.x11.selection.string;
+}
+

external/Box2D-2.3.1/Box2D/glfw/x11_gamma.c

@@ -0,0 +1,123 @@
+//========================================================================
+// GLFW 3.0 X11 - www.glfw.org
+//------------------------------------------------------------------------
+// Copyright (c) 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.
+//
+//========================================================================
+
+#include "internal.h"
+
+#include <limits.h>
+#include <string.h>
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW internal API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+// Detect gamma ramp support
+//
+void _glfwInitGammaRamp(void)
+{
+    // RandR gamma support is only available with version 1.2 and above
+    if (_glfw.x11.randr.available &&
+        (_glfw.x11.randr.versionMajor > 1 ||
+         (_glfw.x11.randr.versionMajor == 1 &&
+          _glfw.x11.randr.versionMinor >= 2)))
+    {
+        // FIXME: Assumes that all monitors have the same size gamma tables
+        // This is reasonable as I suspect the that if they did differ, it
+        // would imply that setting the gamma size to an arbitary size is
+        // possible as well.
+        XRRScreenResources* rr = XRRGetScreenResources(_glfw.x11.display,
+                                                       _glfw.x11.root);
+
+        if (XRRGetCrtcGammaSize(_glfw.x11.display, rr->crtcs[0]) == 0)
+        {
+            // This is probably older Nvidia RandR with broken gamma support
+            // Flag it as useless and try Xf86VidMode below, if available
+            _glfw.x11.randr.gammaBroken = GL_TRUE;
+        }
+
+        XRRFreeScreenResources(rr);
+    }
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW platform API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+void _glfwPlatformGetGammaRamp(_GLFWmonitor* monitor, GLFWgammaramp* ramp)
+{
+    if (_glfw.x11.randr.available && !_glfw.x11.randr.gammaBroken)
+    {
+        const size_t size = XRRGetCrtcGammaSize(_glfw.x11.display,
+                                                monitor->x11.crtc);
+        XRRCrtcGamma* gamma = XRRGetCrtcGamma(_glfw.x11.display,
+                                              monitor->x11.crtc);
+
+        _glfwAllocGammaArrays(ramp, size);
+
+        memcpy(ramp->red, gamma->red, size * sizeof(unsigned short));
+        memcpy(ramp->green, gamma->green, size * sizeof(unsigned short));
+        memcpy(ramp->blue, gamma->blue, size * sizeof(unsigned short));
+
+        XRRFreeGamma(gamma);
+    }
+    else if (_glfw.x11.vidmode.available)
+    {
+        int size;
+        XF86VidModeGetGammaRampSize(_glfw.x11.display, _glfw.x11.screen, &size);
+
+        _glfwAllocGammaArrays(ramp, size);
+
+        XF86VidModeGetGammaRamp(_glfw.x11.display,
+                                _glfw.x11.screen,
+                                ramp->size, ramp->red, ramp->green, ramp->blue);
+    }
+}
+
+void _glfwPlatformSetGammaRamp(_GLFWmonitor* monitor, const GLFWgammaramp* ramp)
+{
+    if (_glfw.x11.randr.available && !_glfw.x11.randr.gammaBroken)
+    {
+        XRRCrtcGamma* gamma = XRRAllocGamma(ramp->size);
+
+        memcpy(gamma->red, ramp->red, ramp->size * sizeof(unsigned short));
+        memcpy(gamma->green, ramp->green, ramp->size * sizeof(unsigned short));
+        memcpy(gamma->blue, ramp->blue, ramp->size * sizeof(unsigned short));
+
+        XRRSetCrtcGamma(_glfw.x11.display, monitor->x11.crtc, gamma);
+        XRRFreeGamma(gamma);
+    }
+    else if (_glfw.x11.vidmode.available)
+    {
+        XF86VidModeSetGammaRamp(_glfw.x11.display,
+                                _glfw.x11.screen,
+                                ramp->size,
+                                (unsigned short*) ramp->red,
+                                (unsigned short*) ramp->green,
+                                (unsigned short*) ramp->blue);
+    }
+}
+

external/Box2D-2.3.1/Box2D/glfw/x11_init.c

@@ -0,0 +1,711 @@
+//========================================================================
+// GLFW 3.0 X11 - 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.
+//
+//========================================================================
+
+#include "internal.h"
+
+#include <X11/Xresource.h>
+
+#include <stdlib.h>
+#include <string.h>
+#include <limits.h>
+
+
+// Translate an X11 key code to a GLFW key code.
+//
+static int translateKey(int keyCode)
+{
+    int keySym;
+
+    // Valid key code range is  [8,255], according to the XLib manual
+    if (keyCode < 8 || keyCode > 255)
+        return GLFW_KEY_UNKNOWN;
+
+    // Try secondary keysym, for numeric keypad keys
+    // Note: This way we always force "NumLock = ON", which is intentional
+    // since the returned key code should correspond to a physical
+    // location.
+    keySym = XkbKeycodeToKeysym(_glfw.x11.display, keyCode, 0, 1);
+    switch (keySym)
+    {
+        case XK_KP_0:           return GLFW_KEY_KP_0;
+        case XK_KP_1:           return GLFW_KEY_KP_1;
+        case XK_KP_2:           return GLFW_KEY_KP_2;
+        case XK_KP_3:           return GLFW_KEY_KP_3;
+        case XK_KP_4:           return GLFW_KEY_KP_4;
+        case XK_KP_5:           return GLFW_KEY_KP_5;
+        case XK_KP_6:           return GLFW_KEY_KP_6;
+        case XK_KP_7:           return GLFW_KEY_KP_7;
+        case XK_KP_8:           return GLFW_KEY_KP_8;
+        case XK_KP_9:           return GLFW_KEY_KP_9;
+        case XK_KP_Separator:
+        case XK_KP_Decimal:     return GLFW_KEY_KP_DECIMAL;
+        case XK_KP_Equal:       return GLFW_KEY_KP_EQUAL;
+        case XK_KP_Enter:       return GLFW_KEY_KP_ENTER;
+        default:                break;
+    }
+
+    // Now try pimary keysym for function keys (non-printable keys). These
+    // should not be layout dependent (i.e. US layout and international
+    // layouts should give the same result).
+    keySym = XkbKeycodeToKeysym(_glfw.x11.display, keyCode, 0, 0);
+    switch (keySym)
+    {
+        case XK_Escape:         return GLFW_KEY_ESCAPE;
+        case XK_Tab:            return GLFW_KEY_TAB;
+        case XK_Shift_L:        return GLFW_KEY_LEFT_SHIFT;
+        case XK_Shift_R:        return GLFW_KEY_RIGHT_SHIFT;
+        case XK_Control_L:      return GLFW_KEY_LEFT_CONTROL;
+        case XK_Control_R:      return GLFW_KEY_RIGHT_CONTROL;
+        case XK_Meta_L:
+        case XK_Alt_L:          return GLFW_KEY_LEFT_ALT;
+        case XK_Mode_switch: // Mapped to Alt_R on many keyboards
+        case XK_ISO_Level3_Shift: // AltGr on at least some machines
+        case XK_Meta_R:
+        case XK_Alt_R:          return GLFW_KEY_RIGHT_ALT;
+        case XK_Super_L:        return GLFW_KEY_LEFT_SUPER;
+        case XK_Super_R:        return GLFW_KEY_RIGHT_SUPER;
+        case XK_Menu:           return GLFW_KEY_MENU;
+        case XK_Num_Lock:       return GLFW_KEY_NUM_LOCK;
+        case XK_Caps_Lock:      return GLFW_KEY_CAPS_LOCK;
+        case XK_Print:          return GLFW_KEY_PRINT_SCREEN;
+        case XK_Scroll_Lock:    return GLFW_KEY_SCROLL_LOCK;
+        case XK_Pause:          return GLFW_KEY_PAUSE;
+        case XK_Delete:         return GLFW_KEY_DELETE;
+        case XK_BackSpace:      return GLFW_KEY_BACKSPACE;
+        case XK_Return:         return GLFW_KEY_ENTER;
+        case XK_Home:           return GLFW_KEY_HOME;
+        case XK_End:            return GLFW_KEY_END;
+        case XK_Page_Up:        return GLFW_KEY_PAGE_UP;
+        case XK_Page_Down:      return GLFW_KEY_PAGE_DOWN;
+        case XK_Insert:         return GLFW_KEY_INSERT;
+        case XK_Left:           return GLFW_KEY_LEFT;
+        case XK_Right:          return GLFW_KEY_RIGHT;
+        case XK_Down:           return GLFW_KEY_DOWN;
+        case XK_Up:             return GLFW_KEY_UP;
+        case XK_F1:             return GLFW_KEY_F1;
+        case XK_F2:             return GLFW_KEY_F2;
+        case XK_F3:             return GLFW_KEY_F3;
+        case XK_F4:             return GLFW_KEY_F4;
+        case XK_F5:             return GLFW_KEY_F5;
+        case XK_F6:             return GLFW_KEY_F6;
+        case XK_F7:             return GLFW_KEY_F7;
+        case XK_F8:             return GLFW_KEY_F8;
+        case XK_F9:             return GLFW_KEY_F9;
+        case XK_F10:            return GLFW_KEY_F10;
+        case XK_F11:            return GLFW_KEY_F11;
+        case XK_F12:            return GLFW_KEY_F12;
+        case XK_F13:            return GLFW_KEY_F13;
+        case XK_F14:            return GLFW_KEY_F14;
+        case XK_F15:            return GLFW_KEY_F15;
+        case XK_F16:            return GLFW_KEY_F16;
+        case XK_F17:            return GLFW_KEY_F17;
+        case XK_F18:            return GLFW_KEY_F18;
+        case XK_F19:            return GLFW_KEY_F19;
+        case XK_F20:            return GLFW_KEY_F20;
+        case XK_F21:            return GLFW_KEY_F21;
+        case XK_F22:            return GLFW_KEY_F22;
+        case XK_F23:            return GLFW_KEY_F23;
+        case XK_F24:            return GLFW_KEY_F24;
+        case XK_F25:            return GLFW_KEY_F25;
+
+        // Numeric keypad
+        case XK_KP_Divide:      return GLFW_KEY_KP_DIVIDE;
+        case XK_KP_Multiply:    return GLFW_KEY_KP_MULTIPLY;
+        case XK_KP_Subtract:    return GLFW_KEY_KP_SUBTRACT;
+        case XK_KP_Add:         return GLFW_KEY_KP_ADD;
+
+        // These should have been detected in secondary keysym test above!
+        case XK_KP_Insert:      return GLFW_KEY_KP_0;
+        case XK_KP_End:         return GLFW_KEY_KP_1;
+        case XK_KP_Down:        return GLFW_KEY_KP_2;
+        case XK_KP_Page_Down:   return GLFW_KEY_KP_3;
+        case XK_KP_Left:        return GLFW_KEY_KP_4;
+        case XK_KP_Right:       return GLFW_KEY_KP_6;
+        case XK_KP_Home:        return GLFW_KEY_KP_7;
+        case XK_KP_Up:          return GLFW_KEY_KP_8;
+        case XK_KP_Page_Up:     return GLFW_KEY_KP_9;
+        case XK_KP_Delete:      return GLFW_KEY_KP_DECIMAL;
+        case XK_KP_Equal:       return GLFW_KEY_KP_EQUAL;
+        case XK_KP_Enter:       return GLFW_KEY_KP_ENTER;
+
+        // Last resort: Check for printable keys (should not happen if the XKB
+        // extension is available). This will give a layout dependent mapping
+        // (which is wrong, and we may miss some keys, especially on non-US
+        // keyboards), but it's better than nothing...
+        case XK_a:              return GLFW_KEY_A;
+        case XK_b:              return GLFW_KEY_B;
+        case XK_c:              return GLFW_KEY_C;
+        case XK_d:              return GLFW_KEY_D;
+        case XK_e:              return GLFW_KEY_E;
+        case XK_f:              return GLFW_KEY_F;
+        case XK_g:              return GLFW_KEY_G;
+        case XK_h:              return GLFW_KEY_H;
+        case XK_i:              return GLFW_KEY_I;
+        case XK_j:              return GLFW_KEY_J;
+        case XK_k:              return GLFW_KEY_K;
+        case XK_l:              return GLFW_KEY_L;
+        case XK_m:              return GLFW_KEY_M;
+        case XK_n:              return GLFW_KEY_N;
+        case XK_o:              return GLFW_KEY_O;
+        case XK_p:              return GLFW_KEY_P;
+        case XK_q:              return GLFW_KEY_Q;
+        case XK_r:              return GLFW_KEY_R;
+        case XK_s:              return GLFW_KEY_S;
+        case XK_t:              return GLFW_KEY_T;
+        case XK_u:              return GLFW_KEY_U;
+        case XK_v:              return GLFW_KEY_V;
+        case XK_w:              return GLFW_KEY_W;
+        case XK_x:              return GLFW_KEY_X;
+        case XK_y:              return GLFW_KEY_Y;
+        case XK_z:              return GLFW_KEY_Z;
+        case XK_1:              return GLFW_KEY_1;
+        case XK_2:              return GLFW_KEY_2;
+        case XK_3:              return GLFW_KEY_3;
+        case XK_4:              return GLFW_KEY_4;
+        case XK_5:              return GLFW_KEY_5;
+        case XK_6:              return GLFW_KEY_6;
+        case XK_7:              return GLFW_KEY_7;
+        case XK_8:              return GLFW_KEY_8;
+        case XK_9:              return GLFW_KEY_9;
+        case XK_0:              return GLFW_KEY_0;
+        case XK_space:          return GLFW_KEY_SPACE;
+        case XK_minus:          return GLFW_KEY_MINUS;
+        case XK_equal:          return GLFW_KEY_EQUAL;
+        case XK_bracketleft:    return GLFW_KEY_LEFT_BRACKET;
+        case XK_bracketright:   return GLFW_KEY_RIGHT_BRACKET;
+        case XK_backslash:      return GLFW_KEY_BACKSLASH;
+        case XK_semicolon:      return GLFW_KEY_SEMICOLON;
+        case XK_apostrophe:     return GLFW_KEY_APOSTROPHE;
+        case XK_grave:          return GLFW_KEY_GRAVE_ACCENT;
+        case XK_comma:          return GLFW_KEY_COMMA;
+        case XK_period:         return GLFW_KEY_PERIOD;
+        case XK_slash:          return GLFW_KEY_SLASH;
+        case XK_less:           return GLFW_KEY_WORLD_1; // At least in some layouts...
+        default:                break;
+    }
+
+    // No matching translation was found
+    return GLFW_KEY_UNKNOWN;
+}
+
+// Update the key code LUT
+//
+static void updateKeyCodeLUT(void)
+{
+    int i, keyCode, keyCodeGLFW;
+    char name[XkbKeyNameLength + 1];
+    XkbDescPtr descr;
+
+    // Clear the LUT
+    for (keyCode = 0;  keyCode < 256;  keyCode++)
+        _glfw.x11.keyCodeLUT[keyCode] = GLFW_KEY_UNKNOWN;
+
+    // Use XKB to determine physical key locations independently of the current
+    // keyboard layout
+
+    // Get keyboard description
+    descr = XkbGetKeyboard(_glfw.x11.display,
+                            XkbAllComponentsMask,
+                            XkbUseCoreKbd);
+
+    // Find the X11 key code -> GLFW key code mapping
+    for (keyCode = descr->min_key_code; keyCode <= descr->max_key_code; ++keyCode)
+    {
+        // Get the key name
+        for (i = 0;  i < XkbKeyNameLength;  i++)
+            name[i] = descr->names->keys[keyCode].name[i];
+
+        name[XkbKeyNameLength] = 0;
+
+        // Map the key name to a GLFW key code. Note: We only map printable
+        // keys here, and we use the US keyboard layout. The rest of the
+        // keys (function keys) are mapped using traditional KeySym
+        // translations.
+        if (strcmp(name, "TLDE") == 0) keyCodeGLFW = GLFW_KEY_GRAVE_ACCENT;
+        else if (strcmp(name, "AE01") == 0) keyCodeGLFW = GLFW_KEY_1;
+        else if (strcmp(name, "AE02") == 0) keyCodeGLFW = GLFW_KEY_2;
+        else if (strcmp(name, "AE03") == 0) keyCodeGLFW = GLFW_KEY_3;
+        else if (strcmp(name, "AE04") == 0) keyCodeGLFW = GLFW_KEY_4;
+        else if (strcmp(name, "AE05") == 0) keyCodeGLFW = GLFW_KEY_5;
+        else if (strcmp(name, "AE06") == 0) keyCodeGLFW = GLFW_KEY_6;
+        else if (strcmp(name, "AE07") == 0) keyCodeGLFW = GLFW_KEY_7;
+        else if (strcmp(name, "AE08") == 0) keyCodeGLFW = GLFW_KEY_8;
+        else if (strcmp(name, "AE09") == 0) keyCodeGLFW = GLFW_KEY_9;
+        else if (strcmp(name, "AE10") == 0) keyCodeGLFW = GLFW_KEY_0;
+        else if (strcmp(name, "AE11") == 0) keyCodeGLFW = GLFW_KEY_MINUS;
+        else if (strcmp(name, "AE12") == 0) keyCodeGLFW = GLFW_KEY_EQUAL;
+        else if (strcmp(name, "AD01") == 0) keyCodeGLFW = GLFW_KEY_Q;
+        else if (strcmp(name, "AD02") == 0) keyCodeGLFW = GLFW_KEY_W;
+        else if (strcmp(name, "AD03") == 0) keyCodeGLFW = GLFW_KEY_E;
+        else if (strcmp(name, "AD04") == 0) keyCodeGLFW = GLFW_KEY_R;
+        else if (strcmp(name, "AD05") == 0) keyCodeGLFW = GLFW_KEY_T;
+        else if (strcmp(name, "AD06") == 0) keyCodeGLFW = GLFW_KEY_Y;
+        else if (strcmp(name, "AD07") == 0) keyCodeGLFW = GLFW_KEY_U;
+        else if (strcmp(name, "AD08") == 0) keyCodeGLFW = GLFW_KEY_I;
+        else if (strcmp(name, "AD09") == 0) keyCodeGLFW = GLFW_KEY_O;
+        else if (strcmp(name, "AD10") == 0) keyCodeGLFW = GLFW_KEY_P;
+        else if (strcmp(name, "AD11") == 0) keyCodeGLFW = GLFW_KEY_LEFT_BRACKET;
+        else if (strcmp(name, "AD12") == 0) keyCodeGLFW = GLFW_KEY_RIGHT_BRACKET;
+        else if (strcmp(name, "AC01") == 0) keyCodeGLFW = GLFW_KEY_A;
+        else if (strcmp(name, "AC02") == 0) keyCodeGLFW = GLFW_KEY_S;
+        else if (strcmp(name, "AC03") == 0) keyCodeGLFW = GLFW_KEY_D;
+        else if (strcmp(name, "AC04") == 0) keyCodeGLFW = GLFW_KEY_F;
+        else if (strcmp(name, "AC05") == 0) keyCodeGLFW = GLFW_KEY_G;
+        else if (strcmp(name, "AC06") == 0) keyCodeGLFW = GLFW_KEY_H;
+        else if (strcmp(name, "AC07") == 0) keyCodeGLFW = GLFW_KEY_J;
+        else if (strcmp(name, "AC08") == 0) keyCodeGLFW = GLFW_KEY_K;
+        else if (strcmp(name, "AC09") == 0) keyCodeGLFW = GLFW_KEY_L;
+        else if (strcmp(name, "AC10") == 0) keyCodeGLFW = GLFW_KEY_SEMICOLON;
+        else if (strcmp(name, "AC11") == 0) keyCodeGLFW = GLFW_KEY_APOSTROPHE;
+        else if (strcmp(name, "AB01") == 0) keyCodeGLFW = GLFW_KEY_Z;
+        else if (strcmp(name, "AB02") == 0) keyCodeGLFW = GLFW_KEY_X;
+        else if (strcmp(name, "AB03") == 0) keyCodeGLFW = GLFW_KEY_C;
+        else if (strcmp(name, "AB04") == 0) keyCodeGLFW = GLFW_KEY_V;
+        else if (strcmp(name, "AB05") == 0) keyCodeGLFW = GLFW_KEY_B;
+        else if (strcmp(name, "AB06") == 0) keyCodeGLFW = GLFW_KEY_N;
+        else if (strcmp(name, "AB07") == 0) keyCodeGLFW = GLFW_KEY_M;
+        else if (strcmp(name, "AB08") == 0) keyCodeGLFW = GLFW_KEY_COMMA;
+        else if (strcmp(name, "AB09") == 0) keyCodeGLFW = GLFW_KEY_PERIOD;
+        else if (strcmp(name, "AB10") == 0) keyCodeGLFW = GLFW_KEY_SLASH;
+        else if (strcmp(name, "BKSL") == 0) keyCodeGLFW = GLFW_KEY_BACKSLASH;
+        else if (strcmp(name, "LSGT") == 0) keyCodeGLFW = GLFW_KEY_WORLD_1;
+        else keyCodeGLFW = GLFW_KEY_UNKNOWN;
+
+        // Update the key code LUT
+        if ((keyCode >= 0) && (keyCode < 256))
+            _glfw.x11.keyCodeLUT[keyCode] = keyCodeGLFW;
+    }
+
+    // Free the keyboard description
+    XkbFreeKeyboard(descr, 0, True);
+
+    // Translate the un-translated key codes using traditional X11 KeySym
+    // lookups
+    for (keyCode = 0;  keyCode < 256;  keyCode++)
+    {
+        if (_glfw.x11.keyCodeLUT[keyCode] < 0)
+            _glfw.x11.keyCodeLUT[keyCode] = translateKey(keyCode);
+    }
+}
+
+// Check whether the specified atom is supported
+//
+static Atom getSupportedAtom(Atom* supportedAtoms,
+                             unsigned long atomCount,
+                             const char* atomName)
+{
+    Atom atom = XInternAtom(_glfw.x11.display, atomName, True);
+    if (atom != None)
+    {
+        unsigned long i;
+
+        for (i = 0;  i < atomCount;  i++)
+        {
+            if (supportedAtoms[i] == atom)
+                return atom;
+        }
+    }
+
+    return None;
+}
+
+// Check whether the running window manager is EWMH-compliant
+//
+static void detectEWMH(void)
+{
+    Window* windowFromRoot = NULL;
+    Window* windowFromChild = NULL;
+
+    // First we need a couple of atoms, which should already be there
+    Atom supportingWmCheck =
+        XInternAtom(_glfw.x11.display, "_NET_SUPPORTING_WM_CHECK", True);
+    Atom wmSupported =
+        XInternAtom(_glfw.x11.display, "_NET_SUPPORTED", True);
+    if (supportingWmCheck == None || wmSupported == None)
+        return;
+
+    // Then we look for the _NET_SUPPORTING_WM_CHECK property of the root window
+    if (_glfwGetWindowProperty(_glfw.x11.root,
+                               supportingWmCheck,
+                               XA_WINDOW,
+                               (unsigned char**) &windowFromRoot) != 1)
+    {
+        XFree(windowFromRoot);
+        return;
+    }
+
+    // It should be the ID of a child window (of the root)
+    // Then we look for the same property on the child window
+    if (_glfwGetWindowProperty(*windowFromRoot,
+                               supportingWmCheck,
+                               XA_WINDOW,
+                               (unsigned char**) &windowFromChild) != 1)
+    {
+        XFree(windowFromRoot);
+        XFree(windowFromChild);
+        return;
+    }
+
+    // It should be the ID of that same child window
+    if (*windowFromRoot != *windowFromChild)
+    {
+        XFree(windowFromRoot);
+        XFree(windowFromChild);
+        return;
+    }
+
+    XFree(windowFromRoot);
+    XFree(windowFromChild);
+
+    // We are now fairly sure that an EWMH-compliant window manager is running
+
+    Atom* supportedAtoms;
+    unsigned long atomCount;
+
+    // Now we need to check the _NET_SUPPORTED property of the root window
+    // It should be a list of supported WM protocol and state atoms
+    atomCount = _glfwGetWindowProperty(_glfw.x11.root,
+                                       wmSupported,
+                                       XA_ATOM,
+                                       (unsigned char**) &supportedAtoms);
+
+    // See which of the atoms we support that are supported by the WM
+
+    _glfw.x11.NET_WM_STATE =
+        getSupportedAtom(supportedAtoms, atomCount, "_NET_WM_STATE");
+    _glfw.x11.NET_WM_STATE_FULLSCREEN =
+        getSupportedAtom(supportedAtoms, atomCount, "_NET_WM_STATE_FULLSCREEN");
+    _glfw.x11.NET_WM_NAME =
+        getSupportedAtom(supportedAtoms, atomCount, "_NET_WM_NAME");
+    _glfw.x11.NET_WM_ICON_NAME =
+        getSupportedAtom(supportedAtoms, atomCount, "_NET_WM_ICON_NAME");
+    _glfw.x11.NET_WM_PID =
+        getSupportedAtom(supportedAtoms, atomCount, "_NET_WM_PID");
+    _glfw.x11.NET_WM_PING =
+        getSupportedAtom(supportedAtoms, atomCount, "_NET_WM_PING");
+    _glfw.x11.NET_ACTIVE_WINDOW =
+        getSupportedAtom(supportedAtoms, atomCount, "_NET_ACTIVE_WINDOW");
+
+    XFree(supportedAtoms);
+
+    _glfw.x11.hasEWMH = GL_TRUE;
+}
+
+// Initialize X11 display and look for supported X11 extensions
+//
+static GLboolean initExtensions(void)
+{
+    Bool supported;
+
+    // Find or create window manager atoms
+    _glfw.x11.WM_STATE = XInternAtom(_glfw.x11.display, "WM_STATE", False);
+    _glfw.x11.WM_DELETE_WINDOW = XInternAtom(_glfw.x11.display,
+                                             "WM_DELETE_WINDOW",
+                                             False);
+    _glfw.x11.MOTIF_WM_HINTS = XInternAtom(_glfw.x11.display,
+                                           "_MOTIF_WM_HINTS",
+                                           False);
+
+    // Check for XF86VidMode extension
+    _glfw.x11.vidmode.available =
+        XF86VidModeQueryExtension(_glfw.x11.display,
+                                  &_glfw.x11.vidmode.eventBase,
+                                  &_glfw.x11.vidmode.errorBase);
+
+    // Check for RandR extension
+    _glfw.x11.randr.available =
+        XRRQueryExtension(_glfw.x11.display,
+                          &_glfw.x11.randr.eventBase,
+                          &_glfw.x11.randr.errorBase);
+
+    if (_glfw.x11.randr.available)
+    {
+        if (!XRRQueryVersion(_glfw.x11.display,
+                             &_glfw.x11.randr.versionMajor,
+                             &_glfw.x11.randr.versionMinor))
+        {
+            _glfwInputError(GLFW_PLATFORM_ERROR,
+                            "X11: Failed to query RandR version");
+            return GL_FALSE;
+        }
+
+        // The GLFW RandR path requires at least version 1.3
+        if (_glfw.x11.randr.versionMajor == 1 &&
+            _glfw.x11.randr.versionMinor < 3)
+        {
+            _glfw.x11.randr.available = GL_FALSE;
+        }
+    }
+
+    if (XQueryExtension(_glfw.x11.display,
+                        "XInputExtension",
+                        &_glfw.x11.xi.majorOpcode,
+                        &_glfw.x11.xi.eventBase,
+                        &_glfw.x11.xi.errorBase))
+    {
+        _glfw.x11.xi.versionMajor = 2;
+        _glfw.x11.xi.versionMinor = 0;
+
+        if (XIQueryVersion(_glfw.x11.display,
+                           &_glfw.x11.xi.versionMajor,
+                           &_glfw.x11.xi.versionMinor) != BadRequest)
+        {
+            _glfw.x11.xi.available = GL_TRUE;
+        }
+    }
+
+    // Check if Xkb is supported on this display
+    _glfw.x11.xkb.versionMajor = 1;
+    _glfw.x11.xkb.versionMinor = 0;
+    if (!XkbQueryExtension(_glfw.x11.display,
+                           &_glfw.x11.xkb.majorOpcode,
+                           &_glfw.x11.xkb.eventBase,
+                           &_glfw.x11.xkb.errorBase,
+                           &_glfw.x11.xkb.versionMajor,
+                           &_glfw.x11.xkb.versionMinor))
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "X11: The keyboard extension is not available");
+        return GL_FALSE;
+    }
+
+    if (!XkbSetDetectableAutoRepeat(_glfw.x11.display, True, &supported))
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "X11: Failed to set detectable key repeat");
+        return GL_FALSE;
+    }
+
+    if (!supported)
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "X11: Detectable key repeat is not supported");
+        return GL_FALSE;
+    }
+
+    // Update the key code LUT
+    // FIXME: We should listen to XkbMapNotify events to track changes to
+    // the keyboard mapping.
+    updateKeyCodeLUT();
+
+    // Detect whether an EWMH-conformant window manager is running
+    detectEWMH();
+
+    // Find or create string format atoms
+    _glfw.x11.UTF8_STRING =
+        XInternAtom(_glfw.x11.display, "UTF8_STRING", False);
+    _glfw.x11.COMPOUND_STRING =
+        XInternAtom(_glfw.x11.display, "COMPOUND_STRING", False);
+    _glfw.x11.ATOM_PAIR = XInternAtom(_glfw.x11.display, "ATOM_PAIR", False);
+
+    // Find or create selection property atom
+    _glfw.x11.GLFW_SELECTION =
+        XInternAtom(_glfw.x11.display, "GLFW_SELECTION", False);
+
+    // Find or create standard clipboard atoms
+    _glfw.x11.TARGETS = XInternAtom(_glfw.x11.display, "TARGETS", False);
+    _glfw.x11.MULTIPLE = XInternAtom(_glfw.x11.display, "MULTIPLE", False);
+    _glfw.x11.CLIPBOARD = XInternAtom(_glfw.x11.display, "CLIPBOARD", False);
+
+    // Find or create clipboard manager atoms
+    _glfw.x11.CLIPBOARD_MANAGER =
+        XInternAtom(_glfw.x11.display, "CLIPBOARD_MANAGER", False);
+    _glfw.x11.SAVE_TARGETS =
+        XInternAtom(_glfw.x11.display, "SAVE_TARGETS", False);
+
+    return GL_TRUE;
+}
+
+// Create a blank cursor (for locked mouse mode)
+//
+static Cursor createNULLCursor(void)
+{
+    Pixmap cursormask;
+    XGCValues xgc;
+    GC gc;
+    XColor col;
+    Cursor cursor;
+
+    _glfwGrabXErrorHandler();
+
+    cursormask = XCreatePixmap(_glfw.x11.display, _glfw.x11.root, 1, 1, 1);
+    xgc.function = GXclear;
+    gc = XCreateGC(_glfw.x11.display, cursormask, GCFunction, &xgc);
+    XFillRectangle(_glfw.x11.display, cursormask, gc, 0, 0, 1, 1);
+    col.pixel = 0;
+    col.red = 0;
+    col.flags = 4;
+    cursor = XCreatePixmapCursor(_glfw.x11.display,
+                                 cursormask, cursormask,
+                                 &col, &col, 0, 0);
+    XFreePixmap(_glfw.x11.display, cursormask);
+    XFreeGC(_glfw.x11.display, gc);
+
+    _glfwReleaseXErrorHandler();
+
+    if (cursor == None)
+    {
+        _glfwInputXError(GLFW_PLATFORM_ERROR,
+                         "X11: Failed to create null cursor");
+    }
+
+    return cursor;
+}
+
+// Terminate X11 display
+//
+static void terminateDisplay(void)
+{
+    if (_glfw.x11.display)
+    {
+        XCloseDisplay(_glfw.x11.display);
+        _glfw.x11.display = NULL;
+    }
+}
+
+// X error handler
+//
+static int errorHandler(Display *display, XErrorEvent* event)
+{
+    _glfw.x11.errorCode = event->error_code;
+    return 0;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW internal API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+// Install the X error handler
+//
+void _glfwGrabXErrorHandler(void)
+{
+    _glfw.x11.errorCode = Success;
+    XSetErrorHandler(errorHandler);
+}
+
+// Remove the X error handler
+//
+void _glfwReleaseXErrorHandler(void)
+{
+    // Synchronize to make sure all commands are processed
+    XSync(_glfw.x11.display, False);
+    XSetErrorHandler(NULL);
+}
+
+// Report X error
+//
+void _glfwInputXError(int error, const char* message)
+{
+    char buffer[8192];
+    XGetErrorText(_glfw.x11.display, _glfw.x11.errorCode,
+                  buffer, sizeof(buffer));
+
+    _glfwInputError(error, "%s: %s", message, buffer);
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW platform API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+int _glfwPlatformInit(void)
+{
+    XInitThreads();
+
+    _glfw.x11.display = XOpenDisplay(NULL);
+    if (!_glfw.x11.display)
+    {
+        _glfwInputError(GLFW_API_UNAVAILABLE, "X11: Failed to open X display");
+        return GL_FALSE;
+    }
+
+    _glfw.x11.screen = DefaultScreen(_glfw.x11.display);
+    _glfw.x11.root = RootWindow(_glfw.x11.display, _glfw.x11.screen);
+    _glfw.x11.context = XUniqueContext();
+
+    if (!initExtensions())
+        return GL_FALSE;
+
+    _glfw.x11.cursor = createNULLCursor();
+
+    if (!_glfwInitContextAPI())
+        return GL_FALSE;
+
+    _glfwInitTimer();
+    _glfwInitJoysticks();
+    _glfwInitGammaRamp();
+
+    return GL_TRUE;
+}
+
+void _glfwPlatformTerminate(void)
+{
+    if (_glfw.x11.cursor)
+    {
+        XFreeCursor(_glfw.x11.display, _glfw.x11.cursor);
+        _glfw.x11.cursor = (Cursor) 0;
+    }
+
+    free(_glfw.x11.selection.string);
+
+    _glfwTerminateJoysticks();
+    _glfwTerminateContextAPI();
+    terminateDisplay();
+}
+
+const char* _glfwPlatformGetVersionString(void)
+{
+    const char* version = _GLFW_VERSION_FULL " X11"
+#if defined(_GLFW_GLX)
+        " GLX"
+#elif defined(_GLFW_EGL)
+        " EGL"
+#endif
+#if defined(_GLFW_HAS_GLXGETPROCADDRESS)
+        " glXGetProcAddress"
+#elif defined(_GLFW_HAS_GLXGETPROCADDRESSARB)
+        " glXGetProcAddressARB"
+#elif defined(_GLFW_HAS_GLXGETPROCADDRESSEXT)
+        " glXGetProcAddressEXT"
+#elif defined(_GLFW_DLOPEN_LIBGL)
+        " dlsym(libGL)"
+#endif
+#if defined(_POSIX_TIMERS) && defined(_POSIX_MONOTONIC_CLOCK)
+        " clock_gettime"
+#endif
+#if defined(__linux__)
+        " /dev/js"
+#endif
+#if defined(_GLFW_BUILD_DLL)
+        " shared"
+#endif
+        ;
+
+    return version;
+}
+

external/Box2D-2.3.1/Box2D/glfw/x11_joystick.c

@@ -0,0 +1,268 @@
+//========================================================================
+// GLFW 3.0 X11 - 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.
+//
+//========================================================================
+
+#include "internal.h"
+
+#ifdef __linux__
+#include <linux/joystick.h>
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <regex.h>
+#include <dirent.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#endif // __linux__
+
+
+// Attempt to open the specified joystick device
+//
+static int openJoystickDevice(int joy, const char* path)
+{
+#ifdef __linux__
+    char axisCount, buttonCount;
+    char name[256];
+    int fd, version;
+
+    fd = open(path, O_RDONLY | O_NONBLOCK);
+    if (fd == -1)
+        return GL_FALSE;
+
+    _glfw.x11.joystick[joy].fd = fd;
+
+    // Verify that the joystick driver version is at least 1.0
+    ioctl(fd, JSIOCGVERSION, &version);
+    if (version < 0x010000)
+    {
+        // It's an old 0.x interface (we don't support it)
+        close(fd);
+        return GL_FALSE;
+    }
+
+    if (ioctl(fd, JSIOCGNAME(sizeof(name)), name) < 0)
+        strncpy(name, "Unknown", sizeof(name));
+
+    _glfw.x11.joystick[joy].name = strdup(name);
+
+    ioctl(fd, JSIOCGAXES, &axisCount);
+    _glfw.x11.joystick[joy].axisCount = (int) axisCount;
+
+    ioctl(fd, JSIOCGBUTTONS, &buttonCount);
+    _glfw.x11.joystick[joy].buttonCount = (int) buttonCount;
+
+    _glfw.x11.joystick[joy].axes = calloc(axisCount, sizeof(float));
+    _glfw.x11.joystick[joy].buttons = calloc(buttonCount, 1);
+
+    _glfw.x11.joystick[joy].present = GL_TRUE;
+#endif // __linux__
+
+    return GL_TRUE;
+}
+
+// Polls for and processes events for all present joysticks
+//
+static void pollJoystickEvents(void)
+{
+#ifdef __linux__
+    int i;
+    ssize_t result;
+    struct js_event e;
+
+    for (i = 0;  i <= GLFW_JOYSTICK_LAST;  i++)
+    {
+        if (!_glfw.x11.joystick[i].present)
+            continue;
+
+        // Read all queued events (non-blocking)
+        for (;;)
+        {
+            errno = 0;
+            result = read(_glfw.x11.joystick[i].fd, &e, sizeof(e));
+
+            if (errno == ENODEV)
+            {
+                free(_glfw.x11.joystick[i].axes);
+                free(_glfw.x11.joystick[i].buttons);
+                free(_glfw.x11.joystick[i].name);
+                _glfw.x11.joystick[i].present = GL_FALSE;
+            }
+
+            if (result == -1)
+                break;
+
+            // 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.x11.joystick[i].axes[e.number] =
+                        (float) e.value / 32767.0f;
+
+                    // We need to change the sign for the Y axes, so that
+                    // positive = up/forward, according to the GLFW spec.
+                    if (e.number & 1)
+                    {
+                        _glfw.x11.joystick[i].axes[e.number] =
+                            -_glfw.x11.joystick[i].axes[e.number];
+                    }
+
+                    break;
+
+                case JS_EVENT_BUTTON:
+                    _glfw.x11.joystick[i].buttons[e.number] =
+                        e.value ? GLFW_PRESS : GLFW_RELEASE;
+                    break;
+
+                default:
+                    break;
+            }
+        }
+    }
+#endif // __linux__
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW internal API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+// Initialize joystick interface
+//
+void _glfwInitJoysticks(void)
+{
+#ifdef __linux__
+    int joy = 0;
+    size_t i;
+    regex_t regex;
+    DIR* dir;
+    const char* dirs[] =
+    {
+        "/dev/input",
+        "/dev"
+    };
+
+    if (regcomp(&regex, "^js[0-9]\\+$", 0) != 0)
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR, "X11: Failed to compile regex");
+        return;
+    }
+
+    for (i = 0;  i < sizeof(dirs) / sizeof(dirs[0]);  i++)
+    {
+        struct dirent* entry;
+
+        dir = opendir(dirs[i]);
+        if (!dir)
+            continue;
+
+        while ((entry = readdir(dir)))
+        {
+            char path[20];
+            regmatch_t match;
+
+            if (regexec(&regex, entry->d_name, 1, &match, 0) != 0)
+                continue;
+
+            snprintf(path, sizeof(path), "%s/%s", dirs[i], entry->d_name);
+            if (openJoystickDevice(joy, path))
+                joy++;
+        }
+
+        closedir(dir);
+    }
+
+    regfree(&regex);
+#endif // __linux__
+}
+
+// Close all opened joystick handles
+//
+void _glfwTerminateJoysticks(void)
+{
+#ifdef __linux__
+    int i;
+
+    for (i = 0;  i <= GLFW_JOYSTICK_LAST;  i++)
+    {
+        if (_glfw.x11.joystick[i].present)
+        {
+            close(_glfw.x11.joystick[i].fd);
+            free(_glfw.x11.joystick[i].axes);
+            free(_glfw.x11.joystick[i].buttons);
+            free(_glfw.x11.joystick[i].name);
+
+            _glfw.x11.joystick[i].present = GL_FALSE;
+        }
+    }
+#endif // __linux__
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW platform API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+int _glfwPlatformJoystickPresent(int joy)
+{
+    pollJoystickEvents();
+
+    return _glfw.x11.joystick[joy].present;
+}
+
+const float* _glfwPlatformGetJoystickAxes(int joy, int* count)
+{
+    pollJoystickEvents();
+
+    if (!_glfw.x11.joystick[joy].present)
+        return NULL;
+
+    *count = _glfw.x11.joystick[joy].axisCount;
+    return _glfw.x11.joystick[joy].axes;
+}
+
+const unsigned char* _glfwPlatformGetJoystickButtons(int joy, int* count)
+{
+    pollJoystickEvents();
+
+    if (!_glfw.x11.joystick[joy].present)
+        return NULL;
+
+    *count = _glfw.x11.joystick[joy].buttonCount;
+    return _glfw.x11.joystick[joy].buttons;
+}
+
+const char* _glfwPlatformGetJoystickName(int joy)
+{
+    pollJoystickEvents();
+
+    return _glfw.x11.joystick[joy].name;
+}
+

external/Box2D-2.3.1/Box2D/glfw/x11_monitor.c

@@ -0,0 +1,401 @@
+//========================================================================
+// GLFW 3.0 X11 - 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.
+//
+//========================================================================
+
+#include "internal.h"
+
+#include <limits.h>
+#include <stdlib.h>
+#include <string.h>
+
+
+static int calculateRefreshRate(const XRRModeInfo* mi)
+{
+    if (!mi->hTotal || !mi->vTotal)
+        return 0;
+
+    return (int) ((double) mi->dotClock / ((double) mi->hTotal * (double) mi->vTotal));
+}
+
+static const XRRModeInfo* getModeInfo(const XRRScreenResources* sr, RRMode id)
+{
+    int i;
+
+    for (i = 0;  i < sr->nmode;  i++)
+    {
+        if (sr->modes[i].id == id)
+            return sr->modes + i;
+    }
+
+    return NULL;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW internal API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+// Set the current video mode for the specified monitor
+//
+void _glfwSetVideoMode(_GLFWmonitor* monitor, const GLFWvidmode* desired)
+{
+    if (_glfw.x11.randr.available)
+    {
+        int i, j;
+        XRRScreenResources* sr;
+        XRRCrtcInfo* ci;
+        XRROutputInfo* oi;
+        RRMode bestMode = 0;
+        unsigned int sizeDiff, leastSizeDiff = UINT_MAX;
+        unsigned int rateDiff, leastRateDiff = UINT_MAX;
+
+        sr = XRRGetScreenResources(_glfw.x11.display, _glfw.x11.root);
+        ci = XRRGetCrtcInfo(_glfw.x11.display, sr, monitor->x11.crtc);
+        oi = XRRGetOutputInfo(_glfw.x11.display, sr, monitor->x11.output);
+
+        for (i = 0;  i < sr->nmode;  i++)
+        {
+            const XRRModeInfo* mi = sr->modes + i;
+
+            if (mi->modeFlags & RR_Interlace)
+                continue;
+
+            for (j = 0;  j < oi->nmode;  j++)
+            {
+                if (oi->modes[j] == mi->id)
+                    break;
+            }
+
+            if (j == oi->nmode)
+                continue;
+
+            sizeDiff = (mi->width - desired->width) *
+                       (mi->width - desired->width) +
+                       (mi->height - desired->height) *
+                       (mi->height - desired->height);
+
+            if (desired->refreshRate)
+                rateDiff = abs(calculateRefreshRate(mi) - desired->refreshRate);
+            else
+                rateDiff = UINT_MAX - calculateRefreshRate(mi);
+
+            if ((sizeDiff < leastSizeDiff) ||
+                (sizeDiff == leastSizeDiff && rateDiff < leastRateDiff))
+            {
+                bestMode = mi->id;
+                leastSizeDiff = sizeDiff;
+                leastRateDiff = rateDiff;
+            }
+        }
+
+        if (monitor->x11.oldMode == None)
+            monitor->x11.oldMode = ci->mode;
+
+        XRRSetCrtcConfig(_glfw.x11.display,
+                         sr, monitor->x11.crtc,
+                         CurrentTime,
+                         ci->x, ci->y,
+                         bestMode,
+                         ci->rotation,
+                         ci->outputs,
+                         ci->noutput);
+
+        XRRFreeOutputInfo(oi);
+        XRRFreeCrtcInfo(ci);
+        XRRFreeScreenResources(sr);
+    }
+}
+
+// Restore the saved (original) video mode for the specified monitor
+//
+void _glfwRestoreVideoMode(_GLFWmonitor* monitor)
+{
+    if (_glfw.x11.randr.available)
+    {
+        XRRScreenResources* sr;
+        XRRCrtcInfo* ci;
+
+        if (monitor->x11.oldMode == None)
+            return;
+
+        sr = XRRGetScreenResources(_glfw.x11.display, _glfw.x11.root);
+        ci = XRRGetCrtcInfo(_glfw.x11.display, sr, monitor->x11.crtc);
+
+        XRRSetCrtcConfig(_glfw.x11.display,
+                         sr, monitor->x11.crtc,
+                         CurrentTime,
+                         ci->x, ci->y,
+                         monitor->x11.oldMode,
+                         ci->rotation,
+                         ci->outputs,
+                         ci->noutput);
+
+        XRRFreeCrtcInfo(ci);
+        XRRFreeScreenResources(sr);
+
+        monitor->x11.oldMode = None;
+    }
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW platform API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+_GLFWmonitor** _glfwPlatformGetMonitors(int* count)
+{
+    _GLFWmonitor** monitors = NULL;
+
+    *count = 0;
+
+    if (_glfw.x11.randr.available)
+    {
+        int i, found = 0;
+        RROutput primary;
+        XRRScreenResources* sr;
+
+        sr = XRRGetScreenResources(_glfw.x11.display, _glfw.x11.root);
+        primary = XRRGetOutputPrimary(_glfw.x11.display, _glfw.x11.root);
+
+        monitors = calloc(sr->ncrtc, sizeof(_GLFWmonitor*));
+
+        for (i = 0;  i < sr->ncrtc;  i++)
+        {
+            int j;
+            XRROutputInfo* oi;
+            XRRCrtcInfo* ci;
+            RROutput output;
+
+            ci = XRRGetCrtcInfo(_glfw.x11.display, sr, sr->crtcs[i]);
+            if (ci->noutput == 0)
+            {
+                XRRFreeCrtcInfo(ci);
+                continue;
+            }
+
+            output = ci->outputs[0];
+
+            for (j = 0;  j < ci->noutput;  j++)
+            {
+                if (ci->outputs[j] == primary)
+                {
+                    output = primary;
+                    break;
+                }
+            }
+
+            oi = XRRGetOutputInfo(_glfw.x11.display, sr, output);
+            if (oi->connection != RR_Connected)
+            {
+                XRRFreeOutputInfo(oi);
+                XRRFreeCrtcInfo(ci);
+                continue;
+            }
+
+            monitors[found] = _glfwCreateMonitor(oi->name,
+                                                 oi->mm_width, oi->mm_height);
+
+            monitors[found]->x11.output = output;
+            monitors[found]->x11.crtc   = oi->crtc;
+
+            XRRFreeOutputInfo(oi);
+            XRRFreeCrtcInfo(ci);
+
+            found++;
+        }
+
+        XRRFreeScreenResources(sr);
+
+        for (i = 0;  i < found;  i++)
+        {
+            if (monitors[i]->x11.output == primary)
+            {
+                _GLFWmonitor* temp = monitors[0];
+                monitors[0] = monitors[i];
+                monitors[i] = temp;
+                break;
+            }
+        }
+
+        if (found == 0)
+        {
+            free(monitors);
+            monitors = NULL;
+        }
+
+        *count = found;
+    }
+    else
+    {
+        monitors = calloc(1, sizeof(_GLFWmonitor*));
+        monitors[0] = _glfwCreateMonitor("Display",
+                                         DisplayWidthMM(_glfw.x11.display,
+                                                        _glfw.x11.screen),
+                                         DisplayHeightMM(_glfw.x11.display,
+                                                         _glfw.x11.screen));
+        *count = 1;
+    }
+
+    return monitors;
+}
+
+GLboolean _glfwPlatformIsSameMonitor(_GLFWmonitor* first, _GLFWmonitor* second)
+{
+    return first->x11.crtc == second->x11.crtc;
+}
+
+void _glfwPlatformGetMonitorPos(_GLFWmonitor* monitor, int* xpos, int* ypos)
+{
+    if (_glfw.x11.randr.available)
+    {
+        XRRScreenResources* sr;
+        XRRCrtcInfo* ci;
+
+        sr = XRRGetScreenResources(_glfw.x11.display, _glfw.x11.root);
+        ci = XRRGetCrtcInfo(_glfw.x11.display, sr, monitor->x11.crtc);
+
+        if (xpos)
+            *xpos = ci->x;
+        if (ypos)
+            *ypos = ci->y;
+
+        XRRFreeCrtcInfo(ci);
+        XRRFreeScreenResources(sr);
+    }
+    else
+    {
+        if (xpos)
+            *xpos = 0;
+        if (ypos)
+            *ypos = 0;
+    }
+}
+
+GLFWvidmode* _glfwPlatformGetVideoModes(_GLFWmonitor* monitor, int* found)
+{
+    GLFWvidmode* result;
+    int depth, r, g, b;
+
+    depth = DefaultDepth(_glfw.x11.display, _glfw.x11.screen);
+    _glfwSplitBPP(depth, &r, &g, &b);
+
+    *found = 0;
+
+    // Build array of available resolutions
+
+    if (_glfw.x11.randr.available)
+    {
+        int i, j;
+        XRRScreenResources* sr;
+        XRROutputInfo* oi;
+
+        sr = XRRGetScreenResources(_glfw.x11.display, _glfw.x11.root);
+        oi = XRRGetOutputInfo(_glfw.x11.display, sr, monitor->x11.output);
+
+        result = calloc(oi->nmode, sizeof(GLFWvidmode));
+
+        for (i = 0;  i < oi->nmode;  i++)
+        {
+            GLFWvidmode mode;
+            const XRRModeInfo* mi = getModeInfo(sr, oi->modes[i]);
+
+            mode.width  = mi->width;
+            mode.height = mi->height;
+            mode.refreshRate = calculateRefreshRate(mi);
+
+            for (j = 0;  j < *found;  j++)
+            {
+                if (result[j].width == mode.width &&
+                    result[j].height == mode.height &&
+                    result[j].refreshRate == mode.refreshRate)
+                {
+                    break;
+                }
+            }
+
+            if (j < *found)
+            {
+                // This is a duplicate, so skip it
+                continue;
+            }
+
+            mode.redBits = r;
+            mode.greenBits = g;
+            mode.blueBits = b;
+
+            result[*found] = mode;
+            (*found)++;
+        }
+
+        XRRFreeOutputInfo(oi);
+        XRRFreeScreenResources(sr);
+    }
+    else
+    {
+        *found = 1;
+
+        result = calloc(1, sizeof(GLFWvidmode));
+
+        result[0].width = DisplayWidth(_glfw.x11.display, _glfw.x11.screen);
+        result[0].height = DisplayHeight(_glfw.x11.display, _glfw.x11.screen);
+        result[0].redBits = r;
+        result[0].greenBits = g;
+        result[0].blueBits = b;
+        result[0].refreshRate = 0;
+    }
+
+    return result;
+}
+
+void _glfwPlatformGetVideoMode(_GLFWmonitor* monitor, GLFWvidmode* mode)
+{
+    if (_glfw.x11.randr.available)
+    {
+        XRRScreenResources* sr;
+        XRRCrtcInfo* ci;
+
+        sr = XRRGetScreenResources(_glfw.x11.display, _glfw.x11.root);
+        ci = XRRGetCrtcInfo(_glfw.x11.display, sr, monitor->x11.crtc);
+
+        mode->width = ci->width;
+        mode->height = ci->height;
+
+        mode->refreshRate = calculateRefreshRate(getModeInfo(sr, ci->mode));
+
+        XRRFreeCrtcInfo(ci);
+        XRRFreeScreenResources(sr);
+    }
+    else
+    {
+        mode->width = DisplayWidth(_glfw.x11.display, _glfw.x11.screen);
+        mode->height = DisplayHeight(_glfw.x11.display, _glfw.x11.screen);
+        mode->refreshRate = 0;
+    }
+
+    _glfwSplitBPP(DefaultDepth(_glfw.x11.display, _glfw.x11.screen),
+                  &mode->redBits, &mode->greenBits, &mode->blueBits);
+}
+

external/Box2D-2.3.1/Box2D/glfw/x11_platform.h

@@ -0,0 +1,264 @@
+//========================================================================
+// GLFW 3.0 X11 - 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 _x11_platform_h_
+#define _x11_platform_h_
+
+#include <unistd.h>
+#include <signal.h>
+#include <stdint.h>
+#include <X11/Xlib.h>
+#include <X11/keysym.h>
+#include <X11/Xatom.h>
+
+// The Xf86VidMode extension provides fallback gamma control
+#include <X11/extensions/xf86vmode.h>
+
+// The XRandR extension provides mode setting and gamma control
+#include <X11/extensions/Xrandr.h>
+
+// The XInput2 extension provides improved input events
+#include <X11/extensions/XInput2.h>
+
+// The Xkb extension provides improved keyboard support
+#include <X11/XKBlib.h>
+
+#if defined(_GLFW_GLX)
+ #define _GLFW_X11_CONTEXT_VISUAL window->glx.visual
+ #include "glx_platform.h"
+#elif defined(_GLFW_EGL)
+ #define _GLFW_X11_CONTEXT_VISUAL window->egl.visual
+ #define _GLFW_EGL_NATIVE_WINDOW  window->x11.handle
+ #define _GLFW_EGL_NATIVE_DISPLAY _glfw.x11.display
+ #include "egl_platform.h"
+#else
+ #error "No supported context creation API selected"
+#endif
+
+#define _GLFW_PLATFORM_WINDOW_STATE         _GLFWwindowX11  x11
+#define _GLFW_PLATFORM_LIBRARY_WINDOW_STATE _GLFWlibraryX11 x11
+#define _GLFW_PLATFORM_MONITOR_STATE        _GLFWmonitorX11 x11
+
+
+//========================================================================
+// GLFW platform specific types
+//========================================================================
+
+
+//------------------------------------------------------------------------
+// Platform-specific window structure
+//------------------------------------------------------------------------
+typedef struct _GLFWwindowX11
+{
+    // Platform specific window resources
+    Colormap        colormap;          // Window colormap
+    Window          handle;            // Window handle
+
+    // Various platform specific internal variables
+    GLboolean       overrideRedirect; // True if window is OverrideRedirect
+    GLboolean       cursorGrabbed;    // True if cursor is currently grabbed
+    GLboolean       cursorHidden;     // True if cursor is currently hidden
+
+    // Cached position and size used to filter out duplicate events
+    int             width, height;
+    int             xpos, ypos;
+
+    // The last received cursor position, regardless of source
+    double          cursorPosX, cursorPosY;
+    // The last position the cursor was warped to by GLFW
+    int             warpPosX, warpPosY;
+
+} _GLFWwindowX11;
+
+
+//------------------------------------------------------------------------
+// Platform-specific library global data for X11
+//------------------------------------------------------------------------
+typedef struct _GLFWlibraryX11
+{
+    Display*        display;
+    int             screen;
+    Window          root;
+
+    // Invisible cursor for hidden cursor mode
+    Cursor          cursor;
+    XContext        context;
+
+    // Window manager atoms
+    Atom            WM_STATE;
+    Atom            WM_DELETE_WINDOW;
+    Atom            NET_WM_NAME;
+    Atom            NET_WM_ICON_NAME;
+    Atom            NET_WM_PID;
+    Atom            NET_WM_PING;
+    Atom            NET_WM_STATE;
+    Atom            NET_WM_STATE_FULLSCREEN;
+    Atom            NET_ACTIVE_WINDOW;
+    Atom            MOTIF_WM_HINTS;
+
+    // Selection atoms
+    Atom            TARGETS;
+    Atom            MULTIPLE;
+    Atom            CLIPBOARD;
+    Atom            CLIPBOARD_MANAGER;
+    Atom            SAVE_TARGETS;
+    Atom            UTF8_STRING;
+    Atom            COMPOUND_STRING;
+    Atom            ATOM_PAIR;
+    Atom            GLFW_SELECTION;
+
+    // True if window manager supports EWMH
+    GLboolean       hasEWMH;
+
+    // Error code received by the X error handler
+    int             errorCode;
+
+    struct {
+        GLboolean   available;
+        int         eventBase;
+        int         errorBase;
+    } vidmode;
+
+    struct {
+        GLboolean   available;
+        int         eventBase;
+        int         errorBase;
+        int         versionMajor;
+        int         versionMinor;
+        GLboolean   gammaBroken;
+    } randr;
+
+    struct {
+        int         majorOpcode;
+        int         eventBase;
+        int         errorBase;
+        int         versionMajor;
+        int         versionMinor;
+    } xkb;
+
+    struct {
+        GLboolean   available;
+        int         majorOpcode;
+        int         eventBase;
+        int         errorBase;
+        int         versionMajor;
+        int         versionMinor;
+    } xi;
+
+    // LUT for mapping X11 key codes to GLFW key codes
+    int             keyCodeLUT[256];
+
+    struct {
+        int         count;
+        int         timeout;
+        int         interval;
+        int         blanking;
+        int         exposure;
+    } saver;
+
+    struct {
+        GLboolean   monotonic;
+        double      resolution;
+        uint64_t    base;
+    } timer;
+
+    struct {
+        char*       string;
+    } selection;
+
+    struct {
+        int         present;
+        int         fd;
+        float*      axes;
+        int         axisCount;
+        unsigned char* buttons;
+        int         buttonCount;
+        char*       name;
+    } joystick[GLFW_JOYSTICK_LAST + 1];
+
+} _GLFWlibraryX11;
+
+
+//------------------------------------------------------------------------
+// Platform-specific monitor structure
+//------------------------------------------------------------------------
+typedef struct _GLFWmonitorX11
+{
+    RROutput        output;
+    RRCrtc          crtc;
+    RRMode          oldMode;
+
+} _GLFWmonitorX11;
+
+
+//========================================================================
+// Prototypes for platform specific internal functions
+//========================================================================
+
+// Time
+void _glfwInitTimer(void);
+
+// Gamma
+void _glfwInitGammaRamp(void);
+
+// OpenGL support
+int _glfwInitContextAPI(void);
+void _glfwTerminateContextAPI(void);
+int _glfwCreateContext(_GLFWwindow* window,
+                       const _GLFWwndconfig* wndconfig,
+                       const _GLFWfbconfig* fbconfig);
+void _glfwDestroyContext(_GLFWwindow* window);
+
+// Fullscreen support
+void _glfwSetVideoMode(_GLFWmonitor* monitor, const GLFWvidmode* desired);
+void _glfwRestoreVideoMode(_GLFWmonitor* monitor);
+
+// Joystick input
+void _glfwInitJoysticks(void);
+void _glfwTerminateJoysticks(void);
+
+// Unicode support
+long _glfwKeySym2Unicode(KeySym keysym);
+
+// Clipboard handling
+void _glfwHandleSelectionClear(XEvent* event);
+void _glfwHandleSelectionRequest(XEvent* event);
+void _glfwPushSelectionToManager(_GLFWwindow* window);
+
+// Window support
+_GLFWwindow* _glfwFindWindowByHandle(Window handle);
+unsigned long _glfwGetWindowProperty(Window window,
+                                     Atom property,
+                                     Atom type,
+                                     unsigned char** value);
+
+// X11 error handler
+void _glfwGrabXErrorHandler(void);
+void _glfwReleaseXErrorHandler(void);
+void _glfwInputXError(int error, const char* message);
+
+#endif // _x11_platform_h_

external/Box2D-2.3.1/Box2D/glfw/x11_time.c

@@ -0,0 +1,98 @@
+//========================================================================
+// GLFW 3.0 X11 - 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.
+//
+//========================================================================
+
+#include "internal.h"
+
+#include <sys/time.h>
+#include <time.h>
+
+
+// Return raw time
+//
+static uint64_t getRawTime(void)
+{
+#if defined(CLOCK_MONOTONIC)
+    if (_glfw.x11.timer.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                      //////
+//////////////////////////////////////////////////////////////////////////
+
+// Initialise timer
+//
+void _glfwInitTimer(void)
+{
+#if defined(CLOCK_MONOTONIC)
+    struct timespec ts;
+
+    if (clock_gettime(CLOCK_MONOTONIC, &ts) == 0)
+    {
+        _glfw.x11.timer.monotonic = GL_TRUE;
+        _glfw.x11.timer.resolution = 1e-9;
+    }
+    else
+#endif
+    {
+        _glfw.x11.timer.resolution = 1e-6;
+    }
+
+    _glfw.x11.timer.base = getRawTime();
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW platform API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+double _glfwPlatformGetTime(void)
+{
+    return (double) (getRawTime() - _glfw.x11.timer.base) *
+        _glfw.x11.timer.resolution;
+}
+
+void _glfwPlatformSetTime(double time)
+{
+    _glfw.x11.timer.base = getRawTime() -
+        (uint64_t) (time / _glfw.x11.timer.resolution);
+}
+

external/Box2D-2.3.1/Box2D/glfw/x11_unicode.c

@@ -0,0 +1,891 @@
+//========================================================================
+// GLFW 3.0 X11 - 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.
+//
+//========================================================================
+
+#include "internal.h"
+
+
+/*
+ * Marcus: This code was originally written by Markus G. Kuhn.
+ * I have made some slight changes (trimmed it down a bit from >60 KB to
+ * 20 KB), but the functionality is the same.
+ */
+
+/*
+ * This module converts keysym values into the corresponding ISO 10646
+ * (UCS, Unicode) values.
+ *
+ * The array keysymtab[] contains pairs of X11 keysym values for graphical
+ * characters and the corresponding Unicode value. The function
+ * _glfwKeySym2Unicode() maps a keysym onto a Unicode value using a binary
+ * search, therefore keysymtab[] must remain SORTED by keysym value.
+ *
+ * We allow to represent any UCS character in the range U-00000000 to
+ * U-00FFFFFF by a keysym value in the range 0x01000000 to 0x01ffffff.
+ * This admittedly does not cover the entire 31-bit space of UCS, but
+ * it does cover all of the characters up to U-10FFFF, which can be
+ * represented by UTF-16, and more, and it is very unlikely that higher
+ * UCS codes will ever be assigned by ISO. So to get Unicode character
+ * U+ABCD you can directly use keysym 0x0100abcd.
+ *
+ * Original author: Markus G. Kuhn <mkuhn@acm.org>, University of
+ *                  Cambridge, April 2001
+ *
+ * Special thanks to Richard Verhoeven <river@win.tue.nl> for preparing
+ * an initial draft of the mapping table.
+ *
+ */
+
+
+//************************************************************************
+//****                KeySym to Unicode mapping table                 ****
+//************************************************************************
+
+static struct codepair {
+  unsigned short keysym;
+  unsigned short ucs;
+} keysymtab[] = {
+  { 0x01a1, 0x0104 },
+  { 0x01a2, 0x02d8 },
+  { 0x01a3, 0x0141 },
+  { 0x01a5, 0x013d },
+  { 0x01a6, 0x015a },
+  { 0x01a9, 0x0160 },
+  { 0x01aa, 0x015e },
+  { 0x01ab, 0x0164 },
+  { 0x01ac, 0x0179 },
+  { 0x01ae, 0x017d },
+  { 0x01af, 0x017b },
+  { 0x01b1, 0x0105 },
+  { 0x01b2, 0x02db },
+  { 0x01b3, 0x0142 },
+  { 0x01b5, 0x013e },
+  { 0x01b6, 0x015b },
+  { 0x01b7, 0x02c7 },
+  { 0x01b9, 0x0161 },
+  { 0x01ba, 0x015f },
+  { 0x01bb, 0x0165 },
+  { 0x01bc, 0x017a },
+  { 0x01bd, 0x02dd },
+  { 0x01be, 0x017e },
+  { 0x01bf, 0x017c },
+  { 0x01c0, 0x0154 },
+  { 0x01c3, 0x0102 },
+  { 0x01c5, 0x0139 },
+  { 0x01c6, 0x0106 },
+  { 0x01c8, 0x010c },
+  { 0x01ca, 0x0118 },
+  { 0x01cc, 0x011a },
+  { 0x01cf, 0x010e },
+  { 0x01d0, 0x0110 },
+  { 0x01d1, 0x0143 },
+  { 0x01d2, 0x0147 },
+  { 0x01d5, 0x0150 },
+  { 0x01d8, 0x0158 },
+  { 0x01d9, 0x016e },
+  { 0x01db, 0x0170 },
+  { 0x01de, 0x0162 },
+  { 0x01e0, 0x0155 },
+  { 0x01e3, 0x0103 },
+  { 0x01e5, 0x013a },
+  { 0x01e6, 0x0107 },
+  { 0x01e8, 0x010d },
+  { 0x01ea, 0x0119 },
+  { 0x01ec, 0x011b },
+  { 0x01ef, 0x010f },
+  { 0x01f0, 0x0111 },
+  { 0x01f1, 0x0144 },
+  { 0x01f2, 0x0148 },
+  { 0x01f5, 0x0151 },
+  { 0x01f8, 0x0159 },
+  { 0x01f9, 0x016f },
+  { 0x01fb, 0x0171 },
+  { 0x01fe, 0x0163 },
+  { 0x01ff, 0x02d9 },
+  { 0x02a1, 0x0126 },
+  { 0x02a6, 0x0124 },
+  { 0x02a9, 0x0130 },
+  { 0x02ab, 0x011e },
+  { 0x02ac, 0x0134 },
+  { 0x02b1, 0x0127 },
+  { 0x02b6, 0x0125 },
+  { 0x02b9, 0x0131 },
+  { 0x02bb, 0x011f },
+  { 0x02bc, 0x0135 },
+  { 0x02c5, 0x010a },
+  { 0x02c6, 0x0108 },
+  { 0x02d5, 0x0120 },
+  { 0x02d8, 0x011c },
+  { 0x02dd, 0x016c },
+  { 0x02de, 0x015c },
+  { 0x02e5, 0x010b },
+  { 0x02e6, 0x0109 },
+  { 0x02f5, 0x0121 },
+  { 0x02f8, 0x011d },
+  { 0x02fd, 0x016d },
+  { 0x02fe, 0x015d },
+  { 0x03a2, 0x0138 },
+  { 0x03a3, 0x0156 },
+  { 0x03a5, 0x0128 },
+  { 0x03a6, 0x013b },
+  { 0x03aa, 0x0112 },
+  { 0x03ab, 0x0122 },
+  { 0x03ac, 0x0166 },
+  { 0x03b3, 0x0157 },
+  { 0x03b5, 0x0129 },
+  { 0x03b6, 0x013c },
+  { 0x03ba, 0x0113 },
+  { 0x03bb, 0x0123 },
+  { 0x03bc, 0x0167 },
+  { 0x03bd, 0x014a },
+  { 0x03bf, 0x014b },
+  { 0x03c0, 0x0100 },
+  { 0x03c7, 0x012e },
+  { 0x03cc, 0x0116 },
+  { 0x03cf, 0x012a },
+  { 0x03d1, 0x0145 },
+  { 0x03d2, 0x014c },
+  { 0x03d3, 0x0136 },
+  { 0x03d9, 0x0172 },
+  { 0x03dd, 0x0168 },
+  { 0x03de, 0x016a },
+  { 0x03e0, 0x0101 },
+  { 0x03e7, 0x012f },
+  { 0x03ec, 0x0117 },
+  { 0x03ef, 0x012b },
+  { 0x03f1, 0x0146 },
+  { 0x03f2, 0x014d },
+  { 0x03f3, 0x0137 },
+  { 0x03f9, 0x0173 },
+  { 0x03fd, 0x0169 },
+  { 0x03fe, 0x016b },
+  { 0x047e, 0x203e },
+  { 0x04a1, 0x3002 },
+  { 0x04a2, 0x300c },
+  { 0x04a3, 0x300d },
+  { 0x04a4, 0x3001 },
+  { 0x04a5, 0x30fb },
+  { 0x04a6, 0x30f2 },
+  { 0x04a7, 0x30a1 },
+  { 0x04a8, 0x30a3 },
+  { 0x04a9, 0x30a5 },
+  { 0x04aa, 0x30a7 },
+  { 0x04ab, 0x30a9 },
+  { 0x04ac, 0x30e3 },
+  { 0x04ad, 0x30e5 },
+  { 0x04ae, 0x30e7 },
+  { 0x04af, 0x30c3 },
+  { 0x04b0, 0x30fc },
+  { 0x04b1, 0x30a2 },
+  { 0x04b2, 0x30a4 },
+  { 0x04b3, 0x30a6 },
+  { 0x04b4, 0x30a8 },
+  { 0x04b5, 0x30aa },
+  { 0x04b6, 0x30ab },
+  { 0x04b7, 0x30ad },
+  { 0x04b8, 0x30af },
+  { 0x04b9, 0x30b1 },
+  { 0x04ba, 0x30b3 },
+  { 0x04bb, 0x30b5 },
+  { 0x04bc, 0x30b7 },
+  { 0x04bd, 0x30b9 },
+  { 0x04be, 0x30bb },
+  { 0x04bf, 0x30bd },
+  { 0x04c0, 0x30bf },
+  { 0x04c1, 0x30c1 },
+  { 0x04c2, 0x30c4 },
+  { 0x04c3, 0x30c6 },
+  { 0x04c4, 0x30c8 },
+  { 0x04c5, 0x30ca },
+  { 0x04c6, 0x30cb },
+  { 0x04c7, 0x30cc },
+  { 0x04c8, 0x30cd },
+  { 0x04c9, 0x30ce },
+  { 0x04ca, 0x30cf },
+  { 0x04cb, 0x30d2 },
+  { 0x04cc, 0x30d5 },
+  { 0x04cd, 0x30d8 },
+  { 0x04ce, 0x30db },
+  { 0x04cf, 0x30de },
+  { 0x04d0, 0x30df },
+  { 0x04d1, 0x30e0 },
+  { 0x04d2, 0x30e1 },
+  { 0x04d3, 0x30e2 },
+  { 0x04d4, 0x30e4 },
+  { 0x04d5, 0x30e6 },
+  { 0x04d6, 0x30e8 },
+  { 0x04d7, 0x30e9 },
+  { 0x04d8, 0x30ea },
+  { 0x04d9, 0x30eb },
+  { 0x04da, 0x30ec },
+  { 0x04db, 0x30ed },
+  { 0x04dc, 0x30ef },
+  { 0x04dd, 0x30f3 },
+  { 0x04de, 0x309b },
+  { 0x04df, 0x309c },
+  { 0x05ac, 0x060c },
+  { 0x05bb, 0x061b },
+  { 0x05bf, 0x061f },
+  { 0x05c1, 0x0621 },
+  { 0x05c2, 0x0622 },
+  { 0x05c3, 0x0623 },
+  { 0x05c4, 0x0624 },
+  { 0x05c5, 0x0625 },
+  { 0x05c6, 0x0626 },
+  { 0x05c7, 0x0627 },
+  { 0x05c8, 0x0628 },
+  { 0x05c9, 0x0629 },
+  { 0x05ca, 0x062a },
+  { 0x05cb, 0x062b },
+  { 0x05cc, 0x062c },
+  { 0x05cd, 0x062d },
+  { 0x05ce, 0x062e },
+  { 0x05cf, 0x062f },
+  { 0x05d0, 0x0630 },
+  { 0x05d1, 0x0631 },
+  { 0x05d2, 0x0632 },
+  { 0x05d3, 0x0633 },
+  { 0x05d4, 0x0634 },
+  { 0x05d5, 0x0635 },
+  { 0x05d6, 0x0636 },
+  { 0x05d7, 0x0637 },
+  { 0x05d8, 0x0638 },
+  { 0x05d9, 0x0639 },
+  { 0x05da, 0x063a },
+  { 0x05e0, 0x0640 },
+  { 0x05e1, 0x0641 },
+  { 0x05e2, 0x0642 },
+  { 0x05e3, 0x0643 },
+  { 0x05e4, 0x0644 },
+  { 0x05e5, 0x0645 },
+  { 0x05e6, 0x0646 },
+  { 0x05e7, 0x0647 },
+  { 0x05e8, 0x0648 },
+  { 0x05e9, 0x0649 },
+  { 0x05ea, 0x064a },
+  { 0x05eb, 0x064b },
+  { 0x05ec, 0x064c },
+  { 0x05ed, 0x064d },
+  { 0x05ee, 0x064e },
+  { 0x05ef, 0x064f },
+  { 0x05f0, 0x0650 },
+  { 0x05f1, 0x0651 },
+  { 0x05f2, 0x0652 },
+  { 0x06a1, 0x0452 },
+  { 0x06a2, 0x0453 },
+  { 0x06a3, 0x0451 },
+  { 0x06a4, 0x0454 },
+  { 0x06a5, 0x0455 },
+  { 0x06a6, 0x0456 },
+  { 0x06a7, 0x0457 },
+  { 0x06a8, 0x0458 },
+  { 0x06a9, 0x0459 },
+  { 0x06aa, 0x045a },
+  { 0x06ab, 0x045b },
+  { 0x06ac, 0x045c },
+  { 0x06ae, 0x045e },
+  { 0x06af, 0x045f },
+  { 0x06b0, 0x2116 },
+  { 0x06b1, 0x0402 },
+  { 0x06b2, 0x0403 },
+  { 0x06b3, 0x0401 },
+  { 0x06b4, 0x0404 },
+  { 0x06b5, 0x0405 },
+  { 0x06b6, 0x0406 },
+  { 0x06b7, 0x0407 },
+  { 0x06b8, 0x0408 },
+  { 0x06b9, 0x0409 },
+  { 0x06ba, 0x040a },
+  { 0x06bb, 0x040b },
+  { 0x06bc, 0x040c },
+  { 0x06be, 0x040e },
+  { 0x06bf, 0x040f },
+  { 0x06c0, 0x044e },
+  { 0x06c1, 0x0430 },
+  { 0x06c2, 0x0431 },
+  { 0x06c3, 0x0446 },
+  { 0x06c4, 0x0434 },
+  { 0x06c5, 0x0435 },
+  { 0x06c6, 0x0444 },
+  { 0x06c7, 0x0433 },
+  { 0x06c8, 0x0445 },
+  { 0x06c9, 0x0438 },
+  { 0x06ca, 0x0439 },
+  { 0x06cb, 0x043a },
+  { 0x06cc, 0x043b },
+  { 0x06cd, 0x043c },
+  { 0x06ce, 0x043d },
+  { 0x06cf, 0x043e },
+  { 0x06d0, 0x043f },
+  { 0x06d1, 0x044f },
+  { 0x06d2, 0x0440 },
+  { 0x06d3, 0x0441 },
+  { 0x06d4, 0x0442 },
+  { 0x06d5, 0x0443 },
+  { 0x06d6, 0x0436 },
+  { 0x06d7, 0x0432 },
+  { 0x06d8, 0x044c },
+  { 0x06d9, 0x044b },
+  { 0x06da, 0x0437 },
+  { 0x06db, 0x0448 },
+  { 0x06dc, 0x044d },
+  { 0x06dd, 0x0449 },
+  { 0x06de, 0x0447 },
+  { 0x06df, 0x044a },
+  { 0x06e0, 0x042e },
+  { 0x06e1, 0x0410 },
+  { 0x06e2, 0x0411 },
+  { 0x06e3, 0x0426 },
+  { 0x06e4, 0x0414 },
+  { 0x06e5, 0x0415 },
+  { 0x06e6, 0x0424 },
+  { 0x06e7, 0x0413 },
+  { 0x06e8, 0x0425 },
+  { 0x06e9, 0x0418 },
+  { 0x06ea, 0x0419 },
+  { 0x06eb, 0x041a },
+  { 0x06ec, 0x041b },
+  { 0x06ed, 0x041c },
+  { 0x06ee, 0x041d },
+  { 0x06ef, 0x041e },
+  { 0x06f0, 0x041f },
+  { 0x06f1, 0x042f },
+  { 0x06f2, 0x0420 },
+  { 0x06f3, 0x0421 },
+  { 0x06f4, 0x0422 },
+  { 0x06f5, 0x0423 },
+  { 0x06f6, 0x0416 },
+  { 0x06f7, 0x0412 },
+  { 0x06f8, 0x042c },
+  { 0x06f9, 0x042b },
+  { 0x06fa, 0x0417 },
+  { 0x06fb, 0x0428 },
+  { 0x06fc, 0x042d },
+  { 0x06fd, 0x0429 },
+  { 0x06fe, 0x0427 },
+  { 0x06ff, 0x042a },
+  { 0x07a1, 0x0386 },
+  { 0x07a2, 0x0388 },
+  { 0x07a3, 0x0389 },
+  { 0x07a4, 0x038a },
+  { 0x07a5, 0x03aa },
+  { 0x07a7, 0x038c },
+  { 0x07a8, 0x038e },
+  { 0x07a9, 0x03ab },
+  { 0x07ab, 0x038f },
+  { 0x07ae, 0x0385 },
+  { 0x07af, 0x2015 },
+  { 0x07b1, 0x03ac },
+  { 0x07b2, 0x03ad },
+  { 0x07b3, 0x03ae },
+  { 0x07b4, 0x03af },
+  { 0x07b5, 0x03ca },
+  { 0x07b6, 0x0390 },
+  { 0x07b7, 0x03cc },
+  { 0x07b8, 0x03cd },
+  { 0x07b9, 0x03cb },
+  { 0x07ba, 0x03b0 },
+  { 0x07bb, 0x03ce },
+  { 0x07c1, 0x0391 },
+  { 0x07c2, 0x0392 },
+  { 0x07c3, 0x0393 },
+  { 0x07c4, 0x0394 },
+  { 0x07c5, 0x0395 },
+  { 0x07c6, 0x0396 },
+  { 0x07c7, 0x0397 },
+  { 0x07c8, 0x0398 },
+  { 0x07c9, 0x0399 },
+  { 0x07ca, 0x039a },
+  { 0x07cb, 0x039b },
+  { 0x07cc, 0x039c },
+  { 0x07cd, 0x039d },
+  { 0x07ce, 0x039e },
+  { 0x07cf, 0x039f },
+  { 0x07d0, 0x03a0 },
+  { 0x07d1, 0x03a1 },
+  { 0x07d2, 0x03a3 },
+  { 0x07d4, 0x03a4 },
+  { 0x07d5, 0x03a5 },
+  { 0x07d6, 0x03a6 },
+  { 0x07d7, 0x03a7 },
+  { 0x07d8, 0x03a8 },
+  { 0x07d9, 0x03a9 },
+  { 0x07e1, 0x03b1 },
+  { 0x07e2, 0x03b2 },
+  { 0x07e3, 0x03b3 },
+  { 0x07e4, 0x03b4 },
+  { 0x07e5, 0x03b5 },
+  { 0x07e6, 0x03b6 },
+  { 0x07e7, 0x03b7 },
+  { 0x07e8, 0x03b8 },
+  { 0x07e9, 0x03b9 },
+  { 0x07ea, 0x03ba },
+  { 0x07eb, 0x03bb },
+  { 0x07ec, 0x03bc },
+  { 0x07ed, 0x03bd },
+  { 0x07ee, 0x03be },
+  { 0x07ef, 0x03bf },
+  { 0x07f0, 0x03c0 },
+  { 0x07f1, 0x03c1 },
+  { 0x07f2, 0x03c3 },
+  { 0x07f3, 0x03c2 },
+  { 0x07f4, 0x03c4 },
+  { 0x07f5, 0x03c5 },
+  { 0x07f6, 0x03c6 },
+  { 0x07f7, 0x03c7 },
+  { 0x07f8, 0x03c8 },
+  { 0x07f9, 0x03c9 },
+  { 0x08a1, 0x23b7 },
+  { 0x08a2, 0x250c },
+  { 0x08a3, 0x2500 },
+  { 0x08a4, 0x2320 },
+  { 0x08a5, 0x2321 },
+  { 0x08a6, 0x2502 },
+  { 0x08a7, 0x23a1 },
+  { 0x08a8, 0x23a3 },
+  { 0x08a9, 0x23a4 },
+  { 0x08aa, 0x23a6 },
+  { 0x08ab, 0x239b },
+  { 0x08ac, 0x239d },
+  { 0x08ad, 0x239e },
+  { 0x08ae, 0x23a0 },
+  { 0x08af, 0x23a8 },
+  { 0x08b0, 0x23ac },
+  { 0x08bc, 0x2264 },
+  { 0x08bd, 0x2260 },
+  { 0x08be, 0x2265 },
+  { 0x08bf, 0x222b },
+  { 0x08c0, 0x2234 },
+  { 0x08c1, 0x221d },
+  { 0x08c2, 0x221e },
+  { 0x08c5, 0x2207 },
+  { 0x08c8, 0x223c },
+  { 0x08c9, 0x2243 },
+  { 0x08cd, 0x21d4 },
+  { 0x08ce, 0x21d2 },
+  { 0x08cf, 0x2261 },
+  { 0x08d6, 0x221a },
+  { 0x08da, 0x2282 },
+  { 0x08db, 0x2283 },
+  { 0x08dc, 0x2229 },
+  { 0x08dd, 0x222a },
+  { 0x08de, 0x2227 },
+  { 0x08df, 0x2228 },
+  { 0x08ef, 0x2202 },
+  { 0x08f6, 0x0192 },
+  { 0x08fb, 0x2190 },
+  { 0x08fc, 0x2191 },
+  { 0x08fd, 0x2192 },
+  { 0x08fe, 0x2193 },
+  { 0x09e0, 0x25c6 },
+  { 0x09e1, 0x2592 },
+  { 0x09e2, 0x2409 },
+  { 0x09e3, 0x240c },
+  { 0x09e4, 0x240d },
+  { 0x09e5, 0x240a },
+  { 0x09e8, 0x2424 },
+  { 0x09e9, 0x240b },
+  { 0x09ea, 0x2518 },
+  { 0x09eb, 0x2510 },
+  { 0x09ec, 0x250c },
+  { 0x09ed, 0x2514 },
+  { 0x09ee, 0x253c },
+  { 0x09ef, 0x23ba },
+  { 0x09f0, 0x23bb },
+  { 0x09f1, 0x2500 },
+  { 0x09f2, 0x23bc },
+  { 0x09f3, 0x23bd },
+  { 0x09f4, 0x251c },
+  { 0x09f5, 0x2524 },
+  { 0x09f6, 0x2534 },
+  { 0x09f7, 0x252c },
+  { 0x09f8, 0x2502 },
+  { 0x0aa1, 0x2003 },
+  { 0x0aa2, 0x2002 },
+  { 0x0aa3, 0x2004 },
+  { 0x0aa4, 0x2005 },
+  { 0x0aa5, 0x2007 },
+  { 0x0aa6, 0x2008 },
+  { 0x0aa7, 0x2009 },
+  { 0x0aa8, 0x200a },
+  { 0x0aa9, 0x2014 },
+  { 0x0aaa, 0x2013 },
+  { 0x0aae, 0x2026 },
+  { 0x0aaf, 0x2025 },
+  { 0x0ab0, 0x2153 },
+  { 0x0ab1, 0x2154 },
+  { 0x0ab2, 0x2155 },
+  { 0x0ab3, 0x2156 },
+  { 0x0ab4, 0x2157 },
+  { 0x0ab5, 0x2158 },
+  { 0x0ab6, 0x2159 },
+  { 0x0ab7, 0x215a },
+  { 0x0ab8, 0x2105 },
+  { 0x0abb, 0x2012 },
+  { 0x0abc, 0x2329 },
+  { 0x0abe, 0x232a },
+  { 0x0ac3, 0x215b },
+  { 0x0ac4, 0x215c },
+  { 0x0ac5, 0x215d },
+  { 0x0ac6, 0x215e },
+  { 0x0ac9, 0x2122 },
+  { 0x0aca, 0x2613 },
+  { 0x0acc, 0x25c1 },
+  { 0x0acd, 0x25b7 },
+  { 0x0ace, 0x25cb },
+  { 0x0acf, 0x25af },
+  { 0x0ad0, 0x2018 },
+  { 0x0ad1, 0x2019 },
+  { 0x0ad2, 0x201c },
+  { 0x0ad3, 0x201d },
+  { 0x0ad4, 0x211e },
+  { 0x0ad6, 0x2032 },
+  { 0x0ad7, 0x2033 },
+  { 0x0ad9, 0x271d },
+  { 0x0adb, 0x25ac },
+  { 0x0adc, 0x25c0 },
+  { 0x0add, 0x25b6 },
+  { 0x0ade, 0x25cf },
+  { 0x0adf, 0x25ae },
+  { 0x0ae0, 0x25e6 },
+  { 0x0ae1, 0x25ab },
+  { 0x0ae2, 0x25ad },
+  { 0x0ae3, 0x25b3 },
+  { 0x0ae4, 0x25bd },
+  { 0x0ae5, 0x2606 },
+  { 0x0ae6, 0x2022 },
+  { 0x0ae7, 0x25aa },
+  { 0x0ae8, 0x25b2 },
+  { 0x0ae9, 0x25bc },
+  { 0x0aea, 0x261c },
+  { 0x0aeb, 0x261e },
+  { 0x0aec, 0x2663 },
+  { 0x0aed, 0x2666 },
+  { 0x0aee, 0x2665 },
+  { 0x0af0, 0x2720 },
+  { 0x0af1, 0x2020 },
+  { 0x0af2, 0x2021 },
+  { 0x0af3, 0x2713 },
+  { 0x0af4, 0x2717 },
+  { 0x0af5, 0x266f },
+  { 0x0af6, 0x266d },
+  { 0x0af7, 0x2642 },
+  { 0x0af8, 0x2640 },
+  { 0x0af9, 0x260e },
+  { 0x0afa, 0x2315 },
+  { 0x0afb, 0x2117 },
+  { 0x0afc, 0x2038 },
+  { 0x0afd, 0x201a },
+  { 0x0afe, 0x201e },
+  { 0x0ba3, 0x003c },
+  { 0x0ba6, 0x003e },
+  { 0x0ba8, 0x2228 },
+  { 0x0ba9, 0x2227 },
+  { 0x0bc0, 0x00af },
+  { 0x0bc2, 0x22a5 },
+  { 0x0bc3, 0x2229 },
+  { 0x0bc4, 0x230a },
+  { 0x0bc6, 0x005f },
+  { 0x0bca, 0x2218 },
+  { 0x0bcc, 0x2395 },
+  { 0x0bce, 0x22a4 },
+  { 0x0bcf, 0x25cb },
+  { 0x0bd3, 0x2308 },
+  { 0x0bd6, 0x222a },
+  { 0x0bd8, 0x2283 },
+  { 0x0bda, 0x2282 },
+  { 0x0bdc, 0x22a2 },
+  { 0x0bfc, 0x22a3 },
+  { 0x0cdf, 0x2017 },
+  { 0x0ce0, 0x05d0 },
+  { 0x0ce1, 0x05d1 },
+  { 0x0ce2, 0x05d2 },
+  { 0x0ce3, 0x05d3 },
+  { 0x0ce4, 0x05d4 },
+  { 0x0ce5, 0x05d5 },
+  { 0x0ce6, 0x05d6 },
+  { 0x0ce7, 0x05d7 },
+  { 0x0ce8, 0x05d8 },
+  { 0x0ce9, 0x05d9 },
+  { 0x0cea, 0x05da },
+  { 0x0ceb, 0x05db },
+  { 0x0cec, 0x05dc },
+  { 0x0ced, 0x05dd },
+  { 0x0cee, 0x05de },
+  { 0x0cef, 0x05df },
+  { 0x0cf0, 0x05e0 },
+  { 0x0cf1, 0x05e1 },
+  { 0x0cf2, 0x05e2 },
+  { 0x0cf3, 0x05e3 },
+  { 0x0cf4, 0x05e4 },
+  { 0x0cf5, 0x05e5 },
+  { 0x0cf6, 0x05e6 },
+  { 0x0cf7, 0x05e7 },
+  { 0x0cf8, 0x05e8 },
+  { 0x0cf9, 0x05e9 },
+  { 0x0cfa, 0x05ea },
+  { 0x0da1, 0x0e01 },
+  { 0x0da2, 0x0e02 },
+  { 0x0da3, 0x0e03 },
+  { 0x0da4, 0x0e04 },
+  { 0x0da5, 0x0e05 },
+  { 0x0da6, 0x0e06 },
+  { 0x0da7, 0x0e07 },
+  { 0x0da8, 0x0e08 },
+  { 0x0da9, 0x0e09 },
+  { 0x0daa, 0x0e0a },
+  { 0x0dab, 0x0e0b },
+  { 0x0dac, 0x0e0c },
+  { 0x0dad, 0x0e0d },
+  { 0x0dae, 0x0e0e },
+  { 0x0daf, 0x0e0f },
+  { 0x0db0, 0x0e10 },
+  { 0x0db1, 0x0e11 },
+  { 0x0db2, 0x0e12 },
+  { 0x0db3, 0x0e13 },
+  { 0x0db4, 0x0e14 },
+  { 0x0db5, 0x0e15 },
+  { 0x0db6, 0x0e16 },
+  { 0x0db7, 0x0e17 },
+  { 0x0db8, 0x0e18 },
+  { 0x0db9, 0x0e19 },
+  { 0x0dba, 0x0e1a },
+  { 0x0dbb, 0x0e1b },
+  { 0x0dbc, 0x0e1c },
+  { 0x0dbd, 0x0e1d },
+  { 0x0dbe, 0x0e1e },
+  { 0x0dbf, 0x0e1f },
+  { 0x0dc0, 0x0e20 },
+  { 0x0dc1, 0x0e21 },
+  { 0x0dc2, 0x0e22 },
+  { 0x0dc3, 0x0e23 },
+  { 0x0dc4, 0x0e24 },
+  { 0x0dc5, 0x0e25 },
+  { 0x0dc6, 0x0e26 },
+  { 0x0dc7, 0x0e27 },
+  { 0x0dc8, 0x0e28 },
+  { 0x0dc9, 0x0e29 },
+  { 0x0dca, 0x0e2a },
+  { 0x0dcb, 0x0e2b },
+  { 0x0dcc, 0x0e2c },
+  { 0x0dcd, 0x0e2d },
+  { 0x0dce, 0x0e2e },
+  { 0x0dcf, 0x0e2f },
+  { 0x0dd0, 0x0e30 },
+  { 0x0dd1, 0x0e31 },
+  { 0x0dd2, 0x0e32 },
+  { 0x0dd3, 0x0e33 },
+  { 0x0dd4, 0x0e34 },
+  { 0x0dd5, 0x0e35 },
+  { 0x0dd6, 0x0e36 },
+  { 0x0dd7, 0x0e37 },
+  { 0x0dd8, 0x0e38 },
+  { 0x0dd9, 0x0e39 },
+  { 0x0dda, 0x0e3a },
+  { 0x0ddf, 0x0e3f },
+  { 0x0de0, 0x0e40 },
+  { 0x0de1, 0x0e41 },
+  { 0x0de2, 0x0e42 },
+  { 0x0de3, 0x0e43 },
+  { 0x0de4, 0x0e44 },
+  { 0x0de5, 0x0e45 },
+  { 0x0de6, 0x0e46 },
+  { 0x0de7, 0x0e47 },
+  { 0x0de8, 0x0e48 },
+  { 0x0de9, 0x0e49 },
+  { 0x0dea, 0x0e4a },
+  { 0x0deb, 0x0e4b },
+  { 0x0dec, 0x0e4c },
+  { 0x0ded, 0x0e4d },
+  { 0x0df0, 0x0e50 },
+  { 0x0df1, 0x0e51 },
+  { 0x0df2, 0x0e52 },
+  { 0x0df3, 0x0e53 },
+  { 0x0df4, 0x0e54 },
+  { 0x0df5, 0x0e55 },
+  { 0x0df6, 0x0e56 },
+  { 0x0df7, 0x0e57 },
+  { 0x0df8, 0x0e58 },
+  { 0x0df9, 0x0e59 },
+  { 0x0ea1, 0x3131 },
+  { 0x0ea2, 0x3132 },
+  { 0x0ea3, 0x3133 },
+  { 0x0ea4, 0x3134 },
+  { 0x0ea5, 0x3135 },
+  { 0x0ea6, 0x3136 },
+  { 0x0ea7, 0x3137 },
+  { 0x0ea8, 0x3138 },
+  { 0x0ea9, 0x3139 },
+  { 0x0eaa, 0x313a },
+  { 0x0eab, 0x313b },
+  { 0x0eac, 0x313c },
+  { 0x0ead, 0x313d },
+  { 0x0eae, 0x313e },
+  { 0x0eaf, 0x313f },
+  { 0x0eb0, 0x3140 },
+  { 0x0eb1, 0x3141 },
+  { 0x0eb2, 0x3142 },
+  { 0x0eb3, 0x3143 },
+  { 0x0eb4, 0x3144 },
+  { 0x0eb5, 0x3145 },
+  { 0x0eb6, 0x3146 },
+  { 0x0eb7, 0x3147 },
+  { 0x0eb8, 0x3148 },
+  { 0x0eb9, 0x3149 },
+  { 0x0eba, 0x314a },
+  { 0x0ebb, 0x314b },
+  { 0x0ebc, 0x314c },
+  { 0x0ebd, 0x314d },
+  { 0x0ebe, 0x314e },
+  { 0x0ebf, 0x314f },
+  { 0x0ec0, 0x3150 },
+  { 0x0ec1, 0x3151 },
+  { 0x0ec2, 0x3152 },
+  { 0x0ec3, 0x3153 },
+  { 0x0ec4, 0x3154 },
+  { 0x0ec5, 0x3155 },
+  { 0x0ec6, 0x3156 },
+  { 0x0ec7, 0x3157 },
+  { 0x0ec8, 0x3158 },
+  { 0x0ec9, 0x3159 },
+  { 0x0eca, 0x315a },
+  { 0x0ecb, 0x315b },
+  { 0x0ecc, 0x315c },
+  { 0x0ecd, 0x315d },
+  { 0x0ece, 0x315e },
+  { 0x0ecf, 0x315f },
+  { 0x0ed0, 0x3160 },
+  { 0x0ed1, 0x3161 },
+  { 0x0ed2, 0x3162 },
+  { 0x0ed3, 0x3163 },
+  { 0x0ed4, 0x11a8 },
+  { 0x0ed5, 0x11a9 },
+  { 0x0ed6, 0x11aa },
+  { 0x0ed7, 0x11ab },
+  { 0x0ed8, 0x11ac },
+  { 0x0ed9, 0x11ad },
+  { 0x0eda, 0x11ae },
+  { 0x0edb, 0x11af },
+  { 0x0edc, 0x11b0 },
+  { 0x0edd, 0x11b1 },
+  { 0x0ede, 0x11b2 },
+  { 0x0edf, 0x11b3 },
+  { 0x0ee0, 0x11b4 },
+  { 0x0ee1, 0x11b5 },
+  { 0x0ee2, 0x11b6 },
+  { 0x0ee3, 0x11b7 },
+  { 0x0ee4, 0x11b8 },
+  { 0x0ee5, 0x11b9 },
+  { 0x0ee6, 0x11ba },
+  { 0x0ee7, 0x11bb },
+  { 0x0ee8, 0x11bc },
+  { 0x0ee9, 0x11bd },
+  { 0x0eea, 0x11be },
+  { 0x0eeb, 0x11bf },
+  { 0x0eec, 0x11c0 },
+  { 0x0eed, 0x11c1 },
+  { 0x0eee, 0x11c2 },
+  { 0x0eef, 0x316d },
+  { 0x0ef0, 0x3171 },
+  { 0x0ef1, 0x3178 },
+  { 0x0ef2, 0x317f },
+  { 0x0ef3, 0x3181 },
+  { 0x0ef4, 0x3184 },
+  { 0x0ef5, 0x3186 },
+  { 0x0ef6, 0x318d },
+  { 0x0ef7, 0x318e },
+  { 0x0ef8, 0x11eb },
+  { 0x0ef9, 0x11f0 },
+  { 0x0efa, 0x11f9 },
+  { 0x0eff, 0x20a9 },
+  { 0x13a4, 0x20ac },
+  { 0x13bc, 0x0152 },
+  { 0x13bd, 0x0153 },
+  { 0x13be, 0x0178 },
+  { 0x20ac, 0x20ac },
+  // Numeric keypad with numlock on
+  { XK_KP_Space, ' ' },
+  { XK_KP_Equal, '=' },
+  { XK_KP_Multiply, '*' },
+  { XK_KP_Add, '+' },
+  { XK_KP_Separator, ',' },
+  { XK_KP_Subtract, '-' },
+  { XK_KP_Decimal, '.' },
+  { XK_KP_Divide, '/' },
+  { XK_KP_0, 0x0030 },
+  { XK_KP_1, 0x0031 },
+  { XK_KP_2, 0x0032 },
+  { XK_KP_3, 0x0033 },
+  { XK_KP_4, 0x0034 },
+  { XK_KP_5, 0x0035 },
+  { XK_KP_6, 0x0036 },
+  { XK_KP_7, 0x0037 },
+  { XK_KP_8, 0x0038 },
+  { XK_KP_9, 0x0039 }
+};
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW internal API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+// Convert X11 KeySym to Unicode
+//
+long _glfwKeySym2Unicode( KeySym keysym )
+{
+    int min = 0;
+    int max = sizeof(keysymtab) / sizeof(struct codepair) - 1;
+    int mid;
+
+    /* First check for Latin-1 characters (1:1 mapping) */
+    if( (keysym >= 0x0020 && keysym <= 0x007e) ||
+        (keysym >= 0x00a0 && keysym <= 0x00ff) )
+    { return keysym;
+    }
+
+    /* Also check for directly encoded 24-bit UCS characters */
+    if( (keysym & 0xff000000) == 0x01000000 )
+        return keysym & 0x00ffffff;
+
+    /* Binary search in table */
+    while( max >= min )
+    {
+        mid = (min + max) / 2;
+        if( keysymtab[mid].keysym < keysym )
+            min = mid + 1;
+        else if( keysymtab[mid].keysym > keysym )
+            max = mid - 1;
+        else
+        {
+            /* Found it! */
+            return keysymtab[mid].ucs;
+        }
+    }
+
+    /* No matching Unicode value found */
+    return -1;
+}
+