glfw/src/cocoa_joystick.m

//========================================================================
// GLFW 3.2 Cocoa - 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 _GLFWjoyelementNS
{
    IOHIDElementRef elementRef;

    long min;
    long max;

    long minReport;
    long maxReport;

} _GLFWjoyelementNS;


static void getElementsCFArrayHandler(const void* value, void* parameter);

// Adds an element to the specified joystick
//
static void addJoystickElement(_GLFWjoydeviceNS* joystick,
                               IOHIDElementRef elementRef)
{
    IOHIDElementType elementType;
    long usagePage, usage;
    CFMutableArrayRef elementsArray = NULL;

    elementType = IOHIDElementGetType(elementRef);
    usagePage = IOHIDElementGetUsagePage(elementRef);
    usage = IOHIDElementGetUsage(elementRef);

    if ((elementType != kIOHIDElementTypeInput_Axis) &&
        (elementType != kIOHIDElementTypeInput_Button) &&
        (elementType != kIOHIDElementTypeInput_Misc))
    {
        return;
    }

    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)
    {
        _GLFWjoyelementNS* element = calloc(1, sizeof(_GLFWjoyelementNS));

        CFArrayAppendValue(elementsArray, element);

        element->elementRef = elementRef;

        element->minReport = IOHIDElementGetLogicalMin(elementRef);
        element->maxReport = IOHIDElementGetLogicalMax(elementRef);
    }
}

// Adds an element to the specified joystick
//
static void getElementsCFArrayHandler(const void* value, void* parameter)
{
    if (CFGetTypeID(value) == IOHIDElementGetTypeID())
    {
        addJoystickElement((_GLFWjoydeviceNS*) parameter,
                           (IOHIDElementRef) value);
    }
}

// Returns the value of the specified element of the specified joystick
//
static long getElementValue(_GLFWjoydeviceNS* joystick, _GLFWjoyelementNS* element)
{
    IOReturn result = kIOReturnSuccess;
    IOHIDValueRef valueRef;
    long value = 0;

    if (joystick && element && joystick->deviceRef)
    {
        result = IOHIDDeviceGetValue(joystick->deviceRef,
                                     element->elementRef,
                                     &valueRef);

        if (kIOReturnSuccess == result)
        {
            value = IOHIDValueGetIntegerValue(valueRef);

            // Record min and max for auto calibration
            if (value < element->minReport)
                element->minReport = value;
            if (value > element->maxReport)
                element->maxReport = value;
        }
    }

    // Auto user scale
    return value;
}

// Removes the specified joystick
//
static void removeJoystick(_GLFWjoydeviceNS* joystick)
{
    int i;

    if (!joystick->present)
        return;

    for (i = 0;  i < CFArrayGetCount(joystick->axisElements);  i++)
        free((void*) CFArrayGetValueAtIndex(joystick->axisElements, i));
    CFArrayRemoveAllValues(joystick->axisElements);
    CFRelease(joystick->axisElements);

    for (i = 0;  i < CFArrayGetCount(joystick->buttonElements);  i++)
        free((void*) CFArrayGetValueAtIndex(joystick->buttonElements, i));
    CFArrayRemoveAllValues(joystick->buttonElements);
    CFRelease(joystick->buttonElements);

    for (i = 0;  i < CFArrayGetCount(joystick->hatElements);  i++)
        free((void*) CFArrayGetValueAtIndex(joystick->hatElements, i));
    CFArrayRemoveAllValues(joystick->hatElements);
    CFRelease(joystick->hatElements);

    free(joystick->axes);
    free(joystick->buttons);

    memset(joystick, 0, sizeof(_GLFWjoydeviceNS));
}

// Polls for joystick events and updates GLFW state
//
static GLFWbool pollJoystickEvents(_GLFWjoydeviceNS* joystick)
{
    CFIndex i;
    int buttonIndex = 0;

    if (!joystick->present)
        return GLFW_FALSE;

    for (i = 0;  i < CFArrayGetCount(joystick->buttonElements);  i++)
    {
        _GLFWjoyelementNS* button = (_GLFWjoyelementNS*)
            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++)
    {
        _GLFWjoyelementNS* axis = (_GLFWjoyelementNS*)
            CFArrayGetValueAtIndex(joystick->axisElements, i);

        long value = getElementValue(joystick, axis);
        long readScale = axis->maxReport - axis->minReport;

        if (readScale == 0)
            joystick->axes[i] = value;
        else
            joystick->axes[i] = (2.f * (value - axis->minReport) / readScale) - 1.f;
    }

    for (i = 0;  i < CFArrayGetCount(joystick->hatElements);  i++)
    {
        _GLFWjoyelementNS* hat = (_GLFWjoyelementNS*)
            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;
        }
    }

    return GLFW_TRUE;
}

// Callback for user-initiated joystick addition
//
static void matchCallback(void* context,
                          IOReturn result,
                          void* sender,
                          IOHIDDeviceRef deviceRef)
{
    _GLFWjoydeviceNS* joystick;
    int joy;

    for (joy = GLFW_JOYSTICK_1;  joy <= GLFW_JOYSTICK_LAST;  joy++)
    {
        joystick = _glfw.ns_js.devices + joy;

        if (!joystick->present)
            continue;

        if (joystick->deviceRef == deviceRef)
            return;
    }

    for (joy = GLFW_JOYSTICK_1;  joy <= GLFW_JOYSTICK_LAST;  joy++)
    {
        joystick = _glfw.ns_js.devices + joy;

        if (!joystick->present)
            break;
    }

    if (joy > GLFW_JOYSTICK_LAST)
        return;

    joystick->present = GLFW_TRUE;
    joystick->deviceRef = deviceRef;

    CFStringRef name = IOHIDDeviceGetProperty(deviceRef,
                                              CFSTR(kIOHIDProductKey));
    CFStringGetCString(name,
                       joystick->name,
                       sizeof(joystick->name),
                       kCFStringEncodingUTF8);

    joystick->axisElements = CFArrayCreateMutable(NULL, 0, NULL);
    joystick->buttonElements = CFArrayCreateMutable(NULL, 0, NULL);
    joystick->hatElements = CFArrayCreateMutable(NULL, 0, NULL);

    CFArrayRef arrayRef = IOHIDDeviceCopyMatchingElements(deviceRef,
                                                          NULL,
                                                          kIOHIDOptionsTypeNone);
    CFRange range = { 0, CFArrayGetCount(arrayRef) };
    CFArrayApplyFunction(arrayRef,
                         range,
                         getElementsCFArrayHandler,
                         (void*) joystick);

    CFRelease(arrayRef);

    joystick->axes = calloc(CFArrayGetCount(joystick->axisElements),
                            sizeof(float));
    joystick->buttons = calloc(CFArrayGetCount(joystick->buttonElements) +
                               CFArrayGetCount(joystick->hatElements) * 4, 1);
}

// Callback for user-initiated joystick removal
//
static void removeCallback(void* context,
                           IOReturn result,
                           void* sender,
                           IOHIDDeviceRef deviceRef)
{
    int joy;

    for (joy = GLFW_JOYSTICK_1;  joy <= GLFW_JOYSTICK_LAST;  joy++)
    {
        _GLFWjoydeviceNS* joystick = _glfw.ns_js.devices + joy;
        if (joystick->deviceRef == deviceRef)
        {
            removeJoystick(joystick);
            break;
        }
    }
}

// Creates a dictionary to match against devices with the specified usage page
// and usage
//
static CFMutableDictionaryRef createMatchingDictionary(long usagePage,
                                                       long usage)
{
    CFMutableDictionaryRef result =
        CFDictionaryCreateMutable(kCFAllocatorDefault,
                                  0,
                                  &kCFTypeDictionaryKeyCallBacks,
                                  &kCFTypeDictionaryValueCallBacks);

    if (result)
    {
        CFNumberRef pageRef = CFNumberCreate(kCFAllocatorDefault,
                                             kCFNumberLongType,
                                             &usagePage);
        if (pageRef)
        {
            CFDictionarySetValue(result,
                                 CFSTR(kIOHIDDeviceUsagePageKey),
                                 pageRef);
            CFRelease(pageRef);

            CFNumberRef usageRef = CFNumberCreate(kCFAllocatorDefault,
                                                  kCFNumberLongType,
                                                  &usage);
            if (usageRef)
            {
                CFDictionarySetValue(result,
                                     CFSTR(kIOHIDDeviceUsageKey),
                                     usageRef);
                CFRelease(usageRef);
            }
        }
    }

    return result;
}


//////////////////////////////////////////////////////////////////////////
//////                       GLFW internal API                      //////
//////////////////////////////////////////////////////////////////////////

// Initialize joystick interface
//
void _glfwInitJoysticksNS(void)
{
    CFMutableArrayRef matchingCFArrayRef;

    _glfw.ns_js.managerRef = IOHIDManagerCreate(kCFAllocatorDefault,
                                                kIOHIDOptionsTypeNone);

    matchingCFArrayRef = CFArrayCreateMutable(kCFAllocatorDefault,
                                              0,
                                              &kCFTypeArrayCallBacks);
    if (matchingCFArrayRef)
    {
        CFDictionaryRef matchingCFDictRef =
            createMatchingDictionary(kHIDPage_GenericDesktop,
                                     kHIDUsage_GD_Joystick);
        if (matchingCFDictRef)
        {
            CFArrayAppendValue(matchingCFArrayRef, matchingCFDictRef);
            CFRelease(matchingCFDictRef);
        }

        matchingCFDictRef = createMatchingDictionary(kHIDPage_GenericDesktop,
                                                     kHIDUsage_GD_GamePad);
        if (matchingCFDictRef)
        {
            CFArrayAppendValue(matchingCFArrayRef, matchingCFDictRef);
            CFRelease(matchingCFDictRef);
        }

        matchingCFDictRef =
            createMatchingDictionary(kHIDPage_GenericDesktop,
                                     kHIDUsage_GD_MultiAxisController);
        if (matchingCFDictRef)
        {
            CFArrayAppendValue(matchingCFArrayRef, matchingCFDictRef);
            CFRelease(matchingCFDictRef);
        }

        IOHIDManagerSetDeviceMatchingMultiple(_glfw.ns_js.managerRef,
                                              matchingCFArrayRef);
        CFRelease(matchingCFArrayRef);
    }

    IOHIDManagerRegisterDeviceMatchingCallback(_glfw.ns_js.managerRef,
                                               &matchCallback, NULL);
    IOHIDManagerRegisterDeviceRemovalCallback(_glfw.ns_js.managerRef,
                                              &removeCallback, NULL);

    IOHIDManagerScheduleWithRunLoop(_glfw.ns_js.managerRef,
                                    CFRunLoopGetMain(),
                                    kCFRunLoopDefaultMode);

    IOHIDManagerOpen(_glfw.ns_js.managerRef, kIOHIDOptionsTypeNone);

    // Execute the run loop once in order to register any initially-attached
    // joysticks
    CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0, false);
}

// Close all opened joystick handles
//
void _glfwTerminateJoysticksNS(void)
{
    int joy;

    for (joy = 0;  joy <= GLFW_JOYSTICK_LAST;  joy++)
    {
        _GLFWjoydeviceNS* joystick = _glfw.ns_js.devices + joy;
        removeJoystick(joystick);
    }

    CFRelease(_glfw.ns_js.managerRef);
    _glfw.ns_js.managerRef = NULL;
}


//////////////////////////////////////////////////////////////////////////
//////                       GLFW platform API                      //////
//////////////////////////////////////////////////////////////////////////

int _glfwPlatformJoystickPresent(int joy)
{
    _GLFWjoydeviceNS* joystick = _glfw.ns_js.devices + joy;
    return pollJoystickEvents(joystick);
}

const float* _glfwPlatformGetJoystickAxes(int joy, int* count)
{
    _GLFWjoydeviceNS* joystick = _glfw.ns_js.devices + joy;
    if (!pollJoystickEvents(joystick))
        return NULL;

    *count = (int) CFArrayGetCount(joystick->axisElements);
    return joystick->axes;
}

const unsigned char* _glfwPlatformGetJoystickButtons(int joy, int* count)
{
    _GLFWjoydeviceNS* joystick = _glfw.ns_js.devices + joy;
    if (!pollJoystickEvents(joystick))
        return NULL;

    *count = (int) CFArrayGetCount(joystick->buttonElements) +
             (int) CFArrayGetCount(joystick->hatElements) * 4;
    return joystick->buttons;
}

const char* _glfwPlatformGetJoystickName(int joy)
{
    _GLFWjoydeviceNS* joystick = _glfw.ns_js.devices + joy;
    if (!pollJoystickEvents(joystick))
        return NULL;

    return joystick->name;
}