diff options
Diffstat (limited to 'platform')
| -rw-r--r-- | platform/osx/SCsub | 1 | ||||
| -rw-r--r-- | platform/osx/detect.py | 2 | ||||
| -rw-r--r-- | platform/osx/joystick_osx.cpp | 623 | ||||
| -rw-r--r-- | platform/osx/joystick_osx.h | 125 | ||||
| -rw-r--r-- | platform/osx/os_osx.h | 3 | ||||
| -rw-r--r-- | platform/osx/os_osx.mm | 9 |
6 files changed, 760 insertions, 3 deletions
diff --git a/platform/osx/SCsub b/platform/osx/SCsub index 3785eb3fb3..4169795519 100644 --- a/platform/osx/SCsub +++ b/platform/osx/SCsub @@ -7,6 +7,7 @@ files = [ 'sem_osx.cpp', # 'context_gl_osx.cpp', 'dir_access_osx.mm', + 'joystick_osx.cpp', ] env.Program('#bin/godot',files) diff --git a/platform/osx/detect.py b/platform/osx/detect.py index 1982beb10e..01ea09fa21 100644 --- a/platform/osx/detect.py +++ b/platform/osx/detect.py @@ -92,7 +92,7 @@ def configure(env): env.Append(LIBS=['pthread']) #env.Append(CPPFLAGS=['-F/Developer/SDKs/MacOSX10.4u.sdk/System/Library/Frameworks', '-isysroot', '/Developer/SDKs/MacOSX10.4u.sdk', '-mmacosx-version-min=10.4']) #env.Append(LINKFLAGS=['-mmacosx-version-min=10.4', '-isysroot', '/Developer/SDKs/MacOSX10.4u.sdk', '-Wl,-syslibroot,/Developer/SDKs/MacOSX10.4u.sdk']) - env.Append(LINKFLAGS=['-framework', 'Cocoa', '-framework', 'Carbon', '-framework', 'OpenGL', '-framework', 'AGL', '-framework', 'AudioUnit','-lz']) + env.Append(LINKFLAGS=['-framework', 'Cocoa', '-framework', 'Carbon', '-framework', 'OpenGL', '-framework', 'AGL', '-framework', 'AudioUnit','-lz', '-framework', 'IOKit', '-framework', 'ForceFeedback']) if (env["CXX"]=="clang++"): env.Append(CPPFLAGS=['-DTYPED_METHOD_BIND']) diff --git a/platform/osx/joystick_osx.cpp b/platform/osx/joystick_osx.cpp new file mode 100644 index 0000000000..ffb6ac326b --- /dev/null +++ b/platform/osx/joystick_osx.cpp @@ -0,0 +1,623 @@ +/*************************************************************************/ +/* joystick_osx.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2016 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is 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 Software. */ +/* */ +/* THE SOFTWARE IS 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 */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#include "joystick_osx.h" +#include <machine/endian.h> + +#define GODOT_JOY_LOOP_RUN_MODE CFSTR("GodotJoystick") + +static JoystickOSX* self = NULL; + +joystick::joystick() { + device_ref = NULL; + ff_device = NULL; + ff_axes = NULL; + ff_directions = NULL; + ffservice = 0; + ff_timestamp = 0; + id = 0; + + ff_constant_force.lMagnitude = 10000; + ff_effect.dwDuration = 0; + ff_effect.dwSamplePeriod = 0; + ff_effect.dwGain = 10000; + ff_effect.dwFlags = FFEFF_OBJECTOFFSETS; + ff_effect.dwTriggerButton = FFEB_NOTRIGGER; + ff_effect.dwStartDelay = 0; + ff_effect.dwTriggerRepeatInterval = 0; + ff_effect.lpEnvelope = NULL; + ff_effect.cbTypeSpecificParams = sizeof(FFCONSTANTFORCE); + ff_effect.lpvTypeSpecificParams = &ff_constant_force; + ff_effect.dwSize = sizeof(ff_effect); +} + +void joystick::free() { + if (device_ref) { + IOHIDDeviceUnscheduleFromRunLoop(device_ref, CFRunLoopGetCurrent(), GODOT_JOY_LOOP_RUN_MODE); + } + if (ff_device) { + FFDeviceReleaseEffect(ff_device, ff_object); + FFReleaseDevice(ff_device); + memfree(ff_axes); + memfree(ff_directions); + } +} + +bool joystick::has_element(IOHIDElementCookie p_cookie, Vector<rec_element> *p_list) const { + for (int i = 0; i < p_list->size(); i++) { + if (p_cookie == p_list->get(i).cookie) { + return true; + } + } + return false; +} + +int joystick::get_hid_element_state(rec_element *p_element) const { + int value = 0; + if (p_element && p_element->ref) { + IOHIDValueRef valueRef; + if (IOHIDDeviceGetValue(device_ref, p_element->ref, &valueRef) == kIOReturnSuccess) { + value = (SInt32) IOHIDValueGetIntegerValue(valueRef); + + /* record min and max for auto calibration */ + if (value < p_element->min) { + p_element->min = value; + } + if (value > p_element->max) { + p_element->max = value; + } + } + } + return value; +} +void joystick::add_hid_element(IOHIDElementRef p_element) { + const CFTypeID elementTypeID = p_element ? CFGetTypeID(p_element) : 0; + + if (p_element && (elementTypeID == IOHIDElementGetTypeID())) { + const IOHIDElementCookie cookie = IOHIDElementGetCookie(p_element); + const uint32_t usagePage = IOHIDElementGetUsagePage(p_element); + const uint32_t usage = IOHIDElementGetUsage(p_element); + Vector<rec_element> *list = NULL; + + switch (IOHIDElementGetType(p_element)) { + case kIOHIDElementTypeInput_Misc: + case kIOHIDElementTypeInput_Button: + case kIOHIDElementTypeInput_Axis: { + 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: + if (!has_element(cookie, &axis_elements)) { + list = &axis_elements; + } + break; + + case kHIDUsage_GD_Hatswitch: + if (!has_element(cookie, &hat_elements)) { + list = &hat_elements; + } + break; + case kHIDUsage_GD_DPadUp: + case kHIDUsage_GD_DPadDown: + case kHIDUsage_GD_DPadRight: + case kHIDUsage_GD_DPadLeft: + case kHIDUsage_GD_Start: + case kHIDUsage_GD_Select: + if (!has_element(cookie, &button_elements)) { + list = &button_elements; + } + break; + } + break; + + case kHIDPage_Simulation: + switch (usage) { + case kHIDUsage_Sim_Rudder: + case kHIDUsage_Sim_Throttle: + if (!has_element(cookie, &axis_elements)) { + list = &axis_elements; + } + break; + + default: + break; + } + break; + + case kHIDPage_Button: + case kHIDPage_Consumer: + if (!has_element(cookie, &button_elements)) { + list = &button_elements; + } + break; + + default: + break; + } + } + break; + + case kIOHIDElementTypeCollection: { + CFArrayRef array = IOHIDElementGetChildren(p_element); + if (array) { + add_hid_elements(array); + } + } + break; + + default: + break; + } + + if (list) { /* add to list */ + rec_element element; + + element.ref = p_element; + element.usage = usage; + + element.min = (SInt32) IOHIDElementGetLogicalMin(p_element); + element.max = (SInt32) IOHIDElementGetLogicalMax(p_element); + element.cookie = IOHIDElementGetCookie(p_element); + list->push_back(element); + list->sort_custom<rec_element::Comparator>(); + } + } +} + +static void hid_element_added(const void *p_value, void *p_parameter) { + joystick *joy = (joystick*) p_parameter; + joy->add_hid_element((IOHIDElementRef) p_value); +} + +void joystick::add_hid_elements(CFArrayRef p_array) { + CFRange range = { 0, CFArrayGetCount(p_array) }; + CFArrayApplyFunction(p_array, range,hid_element_added,this); +} + +static void joystick_removed_callback(void *ctx, IOReturn result, void *sender) { + int id = (intptr_t) ctx; + self->_device_removed(id); +} + + +static void joystick_added_callback(void *ctx, IOReturn res, void *sender, IOHIDDeviceRef ioHIDDeviceObject) { + self->_device_added(res, ioHIDDeviceObject); +} + +static bool is_joystick(IOHIDDeviceRef p_device_ref) { + CFTypeRef refCF = NULL; + int usage_page = 0; + int usage = 0; + refCF = IOHIDDeviceGetProperty(p_device_ref, CFSTR(kIOHIDPrimaryUsagePageKey)); + if (refCF) { + CFNumberGetValue((CFNumberRef) refCF, kCFNumberSInt32Type, &usage_page); + } + if (usage_page != kHIDPage_GenericDesktop) { + return false; + } + + refCF = IOHIDDeviceGetProperty(p_device_ref, CFSTR(kIOHIDPrimaryUsageKey)); + if (refCF) { + CFNumberGetValue((CFNumberRef) refCF, kCFNumberSInt32Type, &usage); + } + if ((usage != kHIDUsage_GD_Joystick && + usage != kHIDUsage_GD_GamePad && + usage != kHIDUsage_GD_MultiAxisController)) { + return false; + } + return true; +} + +void JoystickOSX::_device_added(IOReturn p_res, IOHIDDeviceRef p_device) { + + if (p_res != kIOReturnSuccess || have_device(p_device)) { + return; + } + + joystick new_joystick; + if (is_joystick(p_device)) { + configure_joystick(p_device, &new_joystick); +#if MAC_OS_X_VERSION_MIN_REQUIRED < 1060 + if (IOHIDDeviceGetService != NULL) { +#endif + const io_service_t ioservice = IOHIDDeviceGetService(p_device); + if ((ioservice) && (FFIsForceFeedback(ioservice) == FF_OK) && new_joystick.config_force_feedback(ioservice)) { + new_joystick.ffservice = ioservice; + } +#if MAC_OS_X_VERSION_MIN_REQUIRED < 1060 + } +#endif + device_list.push_back(new_joystick); + } + IOHIDDeviceRegisterRemovalCallback(p_device, joystick_removed_callback, (void*) (intptr_t) new_joystick.id); + IOHIDDeviceScheduleWithRunLoop(p_device, CFRunLoopGetCurrent(), GODOT_JOY_LOOP_RUN_MODE); +} + +void JoystickOSX::_device_removed(int p_id) { + + int device = get_joy_index(p_id); + ERR_FAIL_COND(device == -1); + + input->joy_connection_changed(p_id, false, ""); + device_list[device].free(); + device_list.remove(device); + attached_devices[p_id] = false; +} + +static String _hex_str(uint8_t p_byte) { + + static const char* dict = "0123456789abcdef"; + char ret[3]; + ret[2] = 0; + + ret[0] = dict[p_byte>>4]; + ret[1] = dict[p_byte & 0xF]; + + return ret; +} + +bool JoystickOSX::configure_joystick(IOHIDDeviceRef p_device_ref, joystick* p_joy) { + + CFTypeRef refCF = NULL; + + p_joy->device_ref = p_device_ref; + /* get device name */ + String name; + char c_name[256]; + refCF = IOHIDDeviceGetProperty(p_device_ref, CFSTR(kIOHIDProductKey)); + if (!refCF) { + refCF = IOHIDDeviceGetProperty(p_device_ref, CFSTR(kIOHIDManufacturerKey)); + } + if ((!refCF) || (!CFStringGetCString((CFStringRef) refCF, c_name, sizeof (c_name), kCFStringEncodingUTF8))) { + name = "Unidentified Joystick"; + } + name = c_name; + + int id = get_free_joy_id(); + ERR_FAIL_COND_V(id == -1, false); + p_joy->id = id; + int vendor = 0; + refCF = IOHIDDeviceGetProperty(p_device_ref, CFSTR(kIOHIDVendorIDKey)); + if (refCF) { + CFNumberGetValue((CFNumberRef)refCF, kCFNumberSInt32Type, &vendor); + } + + int product_id = 0; + refCF = IOHIDDeviceGetProperty(p_device_ref, CFSTR(kIOHIDProductIDKey)); + if (refCF) { + CFNumberGetValue((CFNumberRef)refCF, kCFNumberSInt32Type, &product_id); + } + if (vendor && product_id) { + char uid[128]; + sprintf(uid, "%04x%08x%04x%08x", OSSwapHostToBigInt32(vendor),0, OSSwapHostToBigInt32(product_id), 0); + input->joy_connection_changed(id, true, name, uid); + } + else { + //bluetooth device + String guid = "05000000"; + for (int i = 0; i < 12; i++) { + if (i < name.size()) guid += _hex_str(name[i]); + else guid += "00"; + } + input->joy_connection_changed(id, true, name, guid); + } + + CFArrayRef array = NULL; + array = IOHIDDeviceCopyMatchingElements(p_device_ref, NULL, kIOHIDOptionsTypeNone); + if (array) { + p_joy->add_hid_elements(array); + CFRelease(array); + } + return true; +} + +#define FF_ERR() { if (ret != FF_OK) { FFReleaseDevice(ff_device); return false; } } +bool joystick::config_force_feedback(io_service_t p_service) { + + HRESULT ret = FFCreateDevice(p_service, &ff_device); + ERR_FAIL_COND_V(ret != FF_OK, false); + + ret = FFDeviceSendForceFeedbackCommand(ff_device, FFSFFC_RESET); + FF_ERR(); + + ret = FFDeviceSendForceFeedbackCommand(ff_device, FFSFFC_SETACTUATORSON); + FF_ERR(); + + if (check_ff_features()) { + ret = FFDeviceCreateEffect(ff_device, kFFEffectType_ConstantForce_ID, &ff_effect, &ff_object); + FF_ERR(); + return true; + } + FFReleaseDevice(ff_device); + return false; +} +#undef FF_ERR + +#define TEST_FF(ff) (features.supportedEffects & (ff)) +bool joystick::check_ff_features() { + + FFCAPABILITIES features; + HRESULT ret = FFDeviceGetForceFeedbackCapabilities(ff_device, &features); + if (ret == FF_OK && (features.supportedEffects & FFCAP_ET_CONSTANTFORCE)) { + uint32_t val; + ret = FFDeviceGetForceFeedbackProperty(ff_device, FFPROP_FFGAIN, &val, sizeof(val)); + if (ret != FF_OK) return false; + int num_axes = features.numFfAxes; + ff_axes = (DWORD*) memalloc(sizeof(DWORD) * num_axes); + ff_directions = (LONG*) memalloc(sizeof(LONG) * num_axes); + + for (int i = 0; i < num_axes; i++) { + ff_axes[i] = features.ffAxes[i]; + ff_directions[i] = 0; + } + + ff_effect.cAxes = num_axes; + ff_effect.rgdwAxes = ff_axes; + ff_effect.rglDirection = ff_directions; + return true; + } + return false; +} + +static int process_hat_value(int p_min, int p_max, int p_value) { + int range = (p_max - p_min + 1); + int value = p_value - p_min; + int hat_value = InputDefault::HAT_MASK_CENTER; + if (range == 4) { + value *= 2; + } + + switch (value) { + case 0: + hat_value = InputDefault::HAT_MASK_UP; + break; + case 1: + hat_value = InputDefault::HAT_MASK_UP | InputDefault::HAT_MASK_RIGHT; + break; + case 2: + hat_value = InputDefault::HAT_MASK_RIGHT; + break; + case 3: + hat_value = InputDefault::HAT_MASK_DOWN | InputDefault::HAT_MASK_RIGHT; + break; + case 4: + hat_value = InputDefault::HAT_MASK_DOWN; + break; + case 5: + hat_value = InputDefault::HAT_MASK_DOWN | InputDefault::HAT_MASK_LEFT; + break; + case 6: + hat_value = InputDefault::HAT_MASK_LEFT; + break; + case 7: + hat_value = InputDefault::HAT_MASK_UP | InputDefault::HAT_MASK_LEFT; + break; + default: + hat_value = InputDefault::HAT_MASK_CENTER; + break; + } + return hat_value; +} + +void JoystickOSX::poll_joysticks() const { + while (CFRunLoopRunInMode(GODOT_JOY_LOOP_RUN_MODE,0,TRUE) == kCFRunLoopRunHandledSource) { + /* no-op. Pending callbacks will fire. */ + } +} + +static const InputDefault::JoyAxis axis_correct(int p_value, int p_min, int p_max) { + InputDefault::JoyAxis jx; + if (p_min < 0) { + jx.min = -1; + if (p_value < 0) { + jx.value = (float) -p_value / p_min; + } + else jx.value = (float) p_value / p_max; + } + if (p_min == 0) { + jx.min = 0; + jx.value = 0.0f + (float) p_value / p_max; + } + return jx; +} + +uint32_t JoystickOSX::process_joysticks(uint32_t p_last_id){ + poll_joysticks(); + + for (int i = 0; i < device_list.size(); i++) { + joystick &joy = device_list[i]; + + for (int j = 0; j < joy.axis_elements.size(); j++) { + rec_element &elem = joy.axis_elements[j]; + int value = joy.get_hid_element_state(&elem); + p_last_id = input->joy_axis(p_last_id, joy.id, j, axis_correct(value, elem.min, elem.max)); + } + for (int j = 0; j < joy.button_elements.size(); j++) { + int value = joy.get_hid_element_state(&joy.button_elements[j]); + p_last_id = input->joy_button(p_last_id, joy.id, j, (value>=1)); + } + for (int j = 0; j < joy.hat_elements.size(); j++) { + rec_element &elem = joy.hat_elements[j]; + int value = joy.get_hid_element_state(&elem); + int hat_value = process_hat_value(elem.min, elem.max, value); + p_last_id = input->joy_hat(p_last_id, joy.id, hat_value); + } + + if (joy.ffservice) { + uint64_t timestamp = input->get_joy_vibration_timestamp(joy.id); + if (timestamp > joy.ff_timestamp) { + Vector2 strength = input->get_joy_vibration_strength(joy.id); + float duration = input->get_joy_vibration_duration(joy.id); + if (strength.x == 0 && strength.y == 0) { + joystick_vibration_stop(joy.id, timestamp); + } + else { + float gain = MAX(strength.x, strength.y); + joystick_vibration_start(joy.id, gain, duration, timestamp); + } + } + } + } + return p_last_id; +} + +void JoystickOSX::joystick_vibration_start(int p_id, float p_magnitude, float p_duration, uint64_t p_timestamp) { + joystick *joy = &device_list[get_joy_index(p_id)]; + joy->ff_timestamp = p_timestamp; + joy->ff_effect.dwDuration = p_duration * FF_SECONDS; + joy->ff_effect.dwGain = p_magnitude * FF_FFNOMINALMAX; + FFEffectSetParameters(joy->ff_object, &joy->ff_effect, FFEP_DURATION | FFEP_GAIN); + FFEffectStart(joy->ff_object, 1, 0); +} + +void JoystickOSX::joystick_vibration_stop(int p_id, uint64_t p_timestamp) { + joystick* joy = &device_list[get_joy_index(p_id)]; + joy->ff_timestamp = p_timestamp; + FFEffectStop(joy->ff_object); +} + +int JoystickOSX::get_free_joy_id() { + for (int i = 0; i < JOYSTICKS_MAX; i++) { + if (!attached_devices[i]) { + attached_devices[i] = true; + return i; + } + } + return -1; +} + +int JoystickOSX::get_joy_index(int p_id) const { + for (int i = 0; i < device_list.size(); i++) { + if (device_list[i].id == p_id) return i; + } + return -1; +} + +bool JoystickOSX::have_device(IOHIDDeviceRef p_device) const { + for (int i = 0; i < device_list.size(); i++) { + if (device_list[i].device_ref == p_device) { + return true; + } + } + return false; +} + +static CFDictionaryRef create_match_dictionary(const UInt32 page, const UInt32 usage, int *okay) +{ + CFDictionaryRef retval = NULL; + CFNumberRef pageNumRef = CFNumberCreate(kCFAllocatorDefault, kCFNumberIntType, &page); + CFNumberRef usageNumRef = CFNumberCreate(kCFAllocatorDefault, kCFNumberIntType, &usage); + const void *keys[2] = { (void *) CFSTR(kIOHIDDeviceUsagePageKey), (void *) CFSTR(kIOHIDDeviceUsageKey) }; + const void *vals[2] = { (void *) pageNumRef, (void *) usageNumRef }; + + if (pageNumRef && usageNumRef) { + retval = CFDictionaryCreate(kCFAllocatorDefault, keys, vals, 2, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks); + } + + if (pageNumRef) { + CFRelease(pageNumRef); + } + if (usageNumRef) { + CFRelease(usageNumRef); + } + + if (!retval) { + *okay = 0; + } + + return retval; +} + +void JoystickOSX::config_hid_manager(CFArrayRef p_matching_array) const { + + CFRunLoopRef runloop = CFRunLoopGetCurrent(); + IOReturn ret = IOHIDManagerOpen(hid_manager, kIOHIDOptionsTypeNone); + ERR_FAIL_COND(ret != kIOReturnSuccess); + + IOHIDManagerSetDeviceMatchingMultiple(hid_manager, p_matching_array); + IOHIDManagerRegisterDeviceMatchingCallback(hid_manager, joystick_added_callback, NULL); + IOHIDManagerScheduleWithRunLoop(hid_manager, runloop, GODOT_JOY_LOOP_RUN_MODE); + + while (CFRunLoopRunInMode(GODOT_JOY_LOOP_RUN_MODE,0,TRUE) == kCFRunLoopRunHandledSource) { + /* no-op. Callback fires once per existing device. */ + } +} + +JoystickOSX::JoystickOSX() +{ + self = this; + input = (InputDefault*)Input::get_singleton(); + + for (int i = 0; i < JOYSTICKS_MAX; i++) { + attached_devices[i] = false; + } + + int okay = 1; + const void *vals[] = { + (void *) create_match_dictionary(kHIDPage_GenericDesktop, kHIDUsage_GD_Joystick, &okay), + (void *) create_match_dictionary(kHIDPage_GenericDesktop, kHIDUsage_GD_GamePad, &okay), + (void *) create_match_dictionary(kHIDPage_GenericDesktop, kHIDUsage_GD_MultiAxisController, &okay), + }; + const size_t n_elements = sizeof(vals)/sizeof(vals[0]); + CFArrayRef array = okay ? CFArrayCreate(kCFAllocatorDefault, vals, n_elements, &kCFTypeArrayCallBacks) : NULL; + + for (int i = 0; i < n_elements; i++) { + if (vals[i]) { + CFRelease((CFTypeRef) vals[i]); + } + } + + if (array) { + hid_manager = IOHIDManagerCreate(kCFAllocatorDefault, kIOHIDOptionsTypeNone); + if (hid_manager != NULL) { + config_hid_manager(array); + } + CFRelease(array); + } +} + +JoystickOSX::~JoystickOSX() { + + for (int i = 0; i < device_list.size(); i++) { + device_list[i].free(); + } + + IOHIDManagerUnscheduleFromRunLoop(hid_manager, CFRunLoopGetCurrent(), GODOT_JOY_LOOP_RUN_MODE); + IOHIDManagerClose(hid_manager, kIOHIDOptionsTypeNone); + CFRelease(hid_manager); + hid_manager = NULL; +} + diff --git a/platform/osx/joystick_osx.h b/platform/osx/joystick_osx.h new file mode 100644 index 0000000000..38a4e3b1d3 --- /dev/null +++ b/platform/osx/joystick_osx.h @@ -0,0 +1,125 @@ +/*************************************************************************/ +/* joystick_osx.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2016 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is 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 Software. */ +/* */ +/* THE SOFTWARE IS 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 */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#ifndef JOYSTICKOSX_H +#define JOYSTICKOSX_H + +#ifdef MACOS_10_0_4 +#include <IOKit/hidsystem/IOHIDUsageTables.h> +#else +#include <Kernel/IOKit/hidsystem/IOHIDUsageTables.h> +#endif +#include <IOKit/hid/IOHIDLib.h> +#include <ForceFeedback/ForceFeedback.h> +#include <ForceFeedback/ForceFeedbackConstants.h> + +#include "main/input_default.h" + +struct rec_element { + IOHIDElementRef ref; + IOHIDElementCookie cookie; + + uint32_t usage; + + int min; + int max; + + struct Comparator { + bool operator()(const rec_element p_a, const rec_element p_b) const { return p_a.usage < p_b.usage; } + }; +}; + +struct joystick { + IOHIDDeviceRef device_ref; + + Vector<rec_element> axis_elements; + Vector<rec_element> button_elements; + Vector<rec_element> hat_elements; + + int id; + + io_service_t ffservice; /* Interface for force feedback, 0 = no ff */ + FFCONSTANTFORCE ff_constant_force; + FFDeviceObjectReference ff_device; + FFEffectObjectReference ff_object; + uint64_t ff_timestamp; + LONG *ff_directions; + FFEFFECT ff_effect; + DWORD *ff_axes; + + void add_hid_elements(CFArrayRef p_array); + void add_hid_element(IOHIDElementRef p_element); + + bool has_element(IOHIDElementCookie p_cookie, Vector<rec_element> *p_list) const; + bool config_force_feedback(io_service_t p_service); + bool check_ff_features(); + + int get_hid_element_state(rec_element *p_element) const; + + void free(); + joystick(); +}; + +class JoystickOSX { + + enum { + JOYSTICKS_MAX = 16, + }; + +private: + InputDefault *input; + IOHIDManagerRef hid_manager; + + bool attached_devices[JOYSTICKS_MAX]; + Vector<joystick> device_list; + + bool have_device(IOHIDDeviceRef p_device) const; + bool configure_joystick(IOHIDDeviceRef p_device_ref, joystick *p_joy); + + + int get_free_joy_id(); + int get_joy_index(int p_id) const; + + void poll_joysticks() const; + void setup_joystick_objects(); + void config_hid_manager(CFArrayRef p_matching_array) const; + + void joystick_vibration_start(int p_id, float p_magnitude, float p_duration, uint64_t p_timestamp); + void joystick_vibration_stop(int p_id, uint64_t p_timestamp); + +public: + uint32_t process_joysticks(uint32_t p_last_id); + + void _device_added(IOReturn p_res, IOHIDDeviceRef p_device); + void _device_removed(int p_id); + + JoystickOSX(); + ~JoystickOSX(); +}; + +#endif // JOYSTICKOSX_H diff --git a/platform/osx/os_osx.h b/platform/osx/os_osx.h index 8f89695a68..e23ae49a35 100644 --- a/platform/osx/os_osx.h +++ b/platform/osx/os_osx.h @@ -31,6 +31,7 @@ #include "os/input.h" +#include "joystick_osx.h" #include "drivers/unix/os_unix.h" #include "main/input_default.h" #include "servers/visual_server.h" @@ -76,6 +77,7 @@ public: SpatialSound2DServerSW *spatial_sound_2d_server; InputDefault *input; + JoystickOSX *joystick_osx; /* objc */ @@ -203,6 +205,7 @@ public: virtual void set_window_maximized(bool p_enabled); virtual bool is_window_maximized() const; virtual void request_attention(); + virtual String get_joy_guid(int p_device) const; void run(); diff --git a/platform/osx/os_osx.mm b/platform/osx/os_osx.mm index b084a08ecc..cc893cc7a0 100644 --- a/platform/osx/os_osx.mm +++ b/platform/osx/os_osx.mm @@ -1123,6 +1123,7 @@ void OS_OSX::initialize(const VideoMode& p_desired,int p_video_driver,int p_audi physics_2d_server->init(); input = memnew( InputDefault ); + joystick_osx = memnew( JoystickOSX ); _ensure_data_dir(); @@ -1165,7 +1166,7 @@ void OS_OSX::finalize() { spatial_sound_2d_server->finish(); memdelete(spatial_sound_2d_server); - + memdelete(joystick_osx); memdelete(input); memdelete(sample_manager); @@ -1738,7 +1739,7 @@ void OS_OSX::run() { while (!force_quit) { process_events(); // get rid of pending events -// process_joysticks(); + last_id = joystick_osx->process_joysticks(last_id); if (Main::iteration()==true) break; }; @@ -1773,6 +1774,10 @@ OS::MouseMode OS_OSX::get_mouse_mode() const { return mouse_mode; } +String OS_OSX::get_joy_guid(int p_device) const { + return input->get_joy_guid_remapped(p_device); +} + OS_OSX* OS_OSX::singleton=NULL; OS_OSX::OS_OSX() { |