/*
* Copyright (c) 2008-2024 Jonathan Schleifer <js@nil.im>
*
* All rights reserved.
*
* This program is free software: you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License version 3.0 only,
* as published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
* version 3.0 for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* version 3.0 along with this program. If not, see
* <https://www.gnu.org/licenses/>.
*/
#include "config.h"
#include <errno.h>
#include <fcntl.h>
#include <unistd.h>
#import "OFGameController.h"
#import "OFArray.h"
#import "OFFileManager.h"
#import "OFLocale.h"
#import "OFNumber.h"
#import "OFSet.h"
#include <sys/ioctl.h>
#include <linux/input.h>
#import "OFInitializationFailedException.h"
#import "OFInvalidArgumentException.h"
#import "OFOpenItemFailedException.h"
#import "OFOutOfRangeException.h"
#import "OFReadFailedException.h"
/*
* Controllers with tested correct mapping:
*
* Microsoft X-Box 360 pad [045E:028E]
* Joy-Con (L) [057E:2006]
* Joy-Con (R) [057E:2007]
* N64 Controller [057E:2019]
* Sony Interactive Entertainment DualSense Wireless Controller [054C:0CE6]
* 8BitDo Pro 2 Wired Controller [2DC8:3106]
*/
static const uint16_t vendorIDMicrosoft = 0x045E;
static const uint16_t vendorIDNintendo = 0x057E;
static const uint16_t vendorIDSony = 0x054C;
/* Microsoft controllers */
static const uint16_t productIDXbox360 = 0x028E;
/* Nintendo controllers */
static const uint16_t productIDLeftJoycon = 0x2006;
static const uint16_t productIDRightJoycon = 0x2007;
static const uint16_t productIDN64Controller = 0x2019;
/* Sony controllers */
static const uint16_t productIDDualSense = 0x0CE6;
@interface OFGameController ()
- (instancetype)of_initWithPath: (OFString *)path OF_METHOD_FAMILY(init);
@end
static const uint16_t buttons[] = {
BTN_A, BTN_B, BTN_C, BTN_X, BTN_Y, BTN_Z, BTN_TL, BTN_TR, BTN_TL2,
BTN_TR2, BTN_SELECT, BTN_START, BTN_MODE, BTN_THUMBL, BTN_THUMBR,
BTN_DPAD_UP, BTN_DPAD_DOWN, BTN_DPAD_LEFT, BTN_DPAD_RIGHT
};
static OFGameControllerButton
buttonToName(uint16_t button, uint16_t vendorID, uint16_t productID)
{
if (vendorID == vendorIDNintendo &&
productID == productIDLeftJoycon) {
switch (button) {
case BTN_SELECT:
return OFGameControllerMinusButton;
case BTN_Z:
return OFGameControllerCaptureButton;
case BTN_TR:
return OFGameControllerSLButton;
case BTN_TR2:
return OFGameControllerSRButton;
}
} else if (vendorID == vendorIDNintendo &&
productID == productIDRightJoycon) {
switch (button) {
case BTN_NORTH:
return OFGameControllerNorthButton;
case BTN_WEST:
return OFGameControllerWestButton;
case BTN_START:
return OFGameControllerPlusButton;
case BTN_TL:
return OFGameControllerSLButton;
case BTN_TL2:
return OFGameControllerSRButton;
}
} else if (vendorID == vendorIDNintendo &&
productID == productIDN64Controller) {
switch (button) {
case BTN_A:
return OFGameControllerAButton;
case BTN_B:
return OFGameControllerBButton;
case BTN_SELECT:
return OFGameControllerCPadUpButton;
case BTN_X:
return OFGameControllerCPadDownButton;
case BTN_Y:
return OFGameControllerCPadLeftButton;
case BTN_C:
return OFGameControllerCPadRightButton;
case BTN_Z:
return OFGameControllerCaptureButton;
}
} else if (vendorID == vendorIDSony &&
productID == productIDDualSense) {
switch (button) {
case BTN_NORTH:
return OFGameControllerNorthButton;
case BTN_WEST:
return OFGameControllerWestButton;
}
}
switch (button) {
case BTN_Y:
return OFGameControllerNorthButton;
case BTN_A:
return OFGameControllerSouthButton;
case BTN_X:
return OFGameControllerWestButton;
case BTN_B:
return OFGameControllerEastButton;
case BTN_TL2:
return OFGameControllerLeftTriggerButton;
case BTN_TR2:
return OFGameControllerRightTriggerButton;
case BTN_TL:
return OFGameControllerLeftShoulderButton;
case BTN_TR:
return OFGameControllerRightShoulderButton;
case BTN_THUMBL:
return OFGameControllerLeftStickButton;
case BTN_THUMBR:
return OFGameControllerRightStickButton;
case BTN_DPAD_UP:
return OFGameControllerDPadUpButton;
case BTN_DPAD_DOWN:
return OFGameControllerDPadDownButton;
case BTN_DPAD_LEFT:
return OFGameControllerDPadLeftButton;
case BTN_DPAD_RIGHT:
return OFGameControllerDPadRightButton;
case BTN_START:
return OFGameControllerStartButton;
case BTN_SELECT:
return OFGameControllerSelectButton;
case BTN_MODE:
return OFGameControllerHomeButton;
case BTN_C:
return OFGameControllerCButton;
case BTN_Z:
return OFGameControllerZButton;
}
return nil;
}
static float
scale(float value, float min, float max)
{
if (value < min)
value = min;
if (value > max)
value = max;
return ((value - min) / (max - min) * 2) - 1;
}
@implementation OFGameController
@synthesize name = _name, buttons = _buttons;
@synthesize hasLeftAnalogStick = _hasLeftAnalogStick;
@synthesize hasRightAnalogStick = _hasRightAnalogStick;
@synthesize leftAnalogStickPosition = _leftAnalogStickPosition;
@synthesize rightAnalogStickPosition = _rightAnalogStickPosition;
+ (OFArray OF_GENERIC(OFGameController *) *)controllers
{
OFMutableArray *controllers = [OFMutableArray array];
void *pool = objc_autoreleasePoolPush();
for (OFString *device in [[OFFileManager defaultManager]
contentsOfDirectoryAtPath: @"/dev/input"]) {
OFString *path;
OFGameController *controller;
if (![device hasPrefix: @"event"])
continue;
path = [@"/dev/input" stringByAppendingPathComponent: device];
@try {
controller = [[[OFGameController alloc]
of_initWithPath: path] autorelease];
} @catch (OFOpenItemFailedException *e) {
if (e.errNo == EACCES)
continue;
@throw e;
} @catch (OFInvalidArgumentException *e) {
/* Not a game controller. */
continue;
}
[controllers addObject: controller];
}
[controllers sort];
[controllers makeImmutable];
objc_autoreleasePoolPop(pool);
return controllers;
}
- (instancetype)init
{
OF_INVALID_INIT_METHOD
}
- (instancetype)of_initWithPath: (OFString *)path
{
self = [super init];
@try {
OFStringEncoding encoding = [OFLocale encoding];
unsigned long evBits[OFRoundUpToPowerOf2(OF_ULONG_BIT,
EV_MAX) / OF_ULONG_BIT] = { 0 };
unsigned long keyBits[OFRoundUpToPowerOf2(OF_ULONG_BIT,
KEY_MAX) / OF_ULONG_BIT] = { 0 };
unsigned long absBits[OFRoundUpToPowerOf2(OF_ULONG_BIT,
ABS_MAX) / OF_ULONG_BIT] = { 0 };
struct input_id inputID;
char name[128];
_path = [path copy];
if ((_fd = open([_path cStringWithEncoding: encoding],
O_RDONLY | O_NONBLOCK)) == -1)
@throw [OFOpenItemFailedException
exceptionWithPath: _path
mode: @"r"
errNo: errno];
if (ioctl(_fd, EVIOCGBIT(0, sizeof(evBits)), evBits) == -1)
@throw [OFInitializationFailedException exception];
if (!OFBitSetIsSet(evBits, EV_KEY))
@throw [OFInvalidArgumentException exception];
if (ioctl(_fd, EVIOCGBIT(EV_KEY, sizeof(keyBits)), keyBits) ==
-1)
@throw [OFInitializationFailedException exception];
if (!OFBitSetIsSet(keyBits, BTN_GAMEPAD) &&
!OFBitSetIsSet(keyBits, BTN_DPAD_UP))
@throw [OFInvalidArgumentException exception];
if (ioctl(_fd, EVIOCGID, &inputID) == -1)
@throw [OFInvalidArgumentException exception];
_vendorID = inputID.vendor;
_productID = inputID.product;
if (ioctl(_fd, EVIOCGNAME(sizeof(name)), name) == -1)
@throw [OFInitializationFailedException exception];
_name = [[OFString alloc] initWithCString: name
encoding: encoding];
_buttons = [[OFMutableSet alloc] init];
for (size_t i = 0; i < sizeof(buttons) / sizeof(*buttons);
i++)
if (OFBitSetIsSet(keyBits, buttons[i]))
[_buttons addObject: buttonToName(
buttons[i], _vendorID, _productID)];
_pressedButtons = [[OFMutableSet alloc] init];
if (OFBitSetIsSet(evBits, EV_ABS)) {
if (ioctl(_fd, EVIOCGBIT(EV_ABS, sizeof(absBits)),
absBits) == -1)
@throw [OFInitializationFailedException
exception];
if (OFBitSetIsSet(absBits, ABS_X) &&
OFBitSetIsSet(absBits, ABS_Y)) {
struct input_absinfo infoX, infoY;
_hasLeftAnalogStick = true;
if (ioctl(_fd, EVIOCGABS(ABS_X), &infoX) == -1)
@throw [OFInitializationFailedException
exception];
if (ioctl(_fd, EVIOCGABS(ABS_Y), &infoY) == -1)
@throw [OFInitializationFailedException
exception];
_leftAnalogStickMinX = infoX.minimum;
_leftAnalogStickMaxX = infoX.maximum;
_leftAnalogStickMinY = infoY.minimum;
_leftAnalogStickMaxY = infoY.maximum;
}
if (OFBitSetIsSet(absBits, ABS_RX) &&
OFBitSetIsSet(absBits, ABS_RY)) {
struct input_absinfo infoX, infoY;
_hasRightAnalogStick = true;
if (ioctl(_fd, EVIOCGABS(ABS_RX), &infoX) == -1)
@throw [OFInitializationFailedException
exception];
if (ioctl(_fd, EVIOCGABS(ABS_RY), &infoY) == -1)
@throw [OFInitializationFailedException
exception];
_rightAnalogStickMinX = infoX.minimum;
_rightAnalogStickMaxX = infoX.maximum;
_rightAnalogStickMinY = infoY.minimum;
_rightAnalogStickMaxY = infoY.maximum;
}
if (OFBitSetIsSet(absBits, ABS_HAT0X) &&
OFBitSetIsSet(absBits, ABS_HAT0Y)) {
[_buttons addObject:
OFGameControllerDPadLeftButton];
[_buttons addObject:
OFGameControllerDPadRightButton];
[_buttons addObject:
OFGameControllerDPadUpButton];
[_buttons addObject:
OFGameControllerDPadDownButton];
}
if (OFBitSetIsSet(absBits, ABS_Z)) {
struct input_absinfo info;
_hasLeftTriggerPressure = true;
if (ioctl(_fd, EVIOCGABS(ABS_Z), &info) == -1)
@throw [OFInitializationFailedException
exception];
_leftTriggerMinPressure = info.minimum;
_leftTriggerMaxPressure = info.maximum;
[_buttons addObject:
OFGameControllerLeftTriggerButton];
}
if (OFBitSetIsSet(absBits, ABS_RZ)) {
struct input_absinfo info;
_hasRightTriggerPressure = true;
if (ioctl(_fd, EVIOCGABS(ABS_RZ), &info) == -1)
@throw [OFInitializationFailedException
exception];
_rightTriggerMinPressure = info.minimum;
_rightTriggerMaxPressure = info.maximum;
[_buttons addObject:
OFGameControllerRightTriggerButton];
}
}
[_buttons makeImmutable];
[self retrieveState];
} @catch (id e) {
[self release];
@throw e;
}
return self;
}
- (void)dealloc
{
[_path release];
if (_fd != -1)
close(_fd);
[_name release];
[_buttons release];
[_pressedButtons release];
[super dealloc];
}
- (OFNumber *)vendorID
{
return [OFNumber numberWithUnsignedShort: _vendorID];
}
- (OFNumber *)productID
{
return [OFNumber numberWithUnsignedShort: _productID];
}
- (void)retrieveState
{
struct input_event event;
for (;;) {
OFGameControllerButton button;
errno = 0;
if (read(_fd, &event, sizeof(event)) < (int)sizeof(event)) {
if (errno == EWOULDBLOCK)
return;
@throw [OFReadFailedException
exceptionWithObject: self
requestedLength: sizeof(event)
errNo: errno];
}
switch (event.type) {
case EV_KEY:
if ((button = buttonToName(event.code, _vendorID,
_productID)) != nil) {
if (event.value)
[_pressedButtons addObject: button];
else
[_pressedButtons removeObject: button];
}
break;
case EV_ABS:
switch (event.code) {
case ABS_X:
_leftAnalogStickPosition.x = scale(event.value,
_leftAnalogStickMinX, _leftAnalogStickMaxX);
break;
case ABS_Y:
_leftAnalogStickPosition.y = scale(event.value,
_leftAnalogStickMinY, _leftAnalogStickMaxY);
break;
case ABS_RX:
_rightAnalogStickPosition.x = scale(event.value,
_rightAnalogStickMinX,
_rightAnalogStickMaxX);
break;
case ABS_RY:
_rightAnalogStickPosition.y = scale(event.value,
_rightAnalogStickMinY,
_rightAnalogStickMaxY);
break;
case ABS_HAT0X:
if (event.value < 0) {
[_pressedButtons addObject:
OFGameControllerDPadLeftButton];
[_pressedButtons removeObject:
OFGameControllerDPadRightButton];
} else if (event.value > 0) {
[_pressedButtons addObject:
OFGameControllerDPadRightButton];
[_pressedButtons removeObject:
OFGameControllerDPadLeftButton];
} else {
[_pressedButtons removeObject:
OFGameControllerDPadLeftButton];
[_pressedButtons removeObject:
OFGameControllerDPadRightButton];
}
break;
case ABS_HAT0Y:
if (event.value < 0) {
[_pressedButtons addObject:
OFGameControllerDPadUpButton];
[_pressedButtons removeObject:
OFGameControllerDPadDownButton];
} else if (event.value > 0) {
[_pressedButtons addObject:
OFGameControllerDPadDownButton];
[_pressedButtons removeObject:
OFGameControllerDPadUpButton];
} else {
[_pressedButtons removeObject:
OFGameControllerDPadUpButton];
[_pressedButtons removeObject:
OFGameControllerDPadDownButton];
}
break;
case ABS_Z:
_leftTriggerPressure = scale(event.value,
_leftTriggerMinPressure,
_leftTriggerMaxPressure);
if (_leftTriggerPressure > 0)
[_pressedButtons addObject:
OFGameControllerLeftTriggerButton];
else
[_pressedButtons removeObject:
OFGameControllerLeftTriggerButton];
break;
case ABS_RZ:
_rightTriggerPressure = scale(event.value,
_rightTriggerMinPressure,
_rightTriggerMaxPressure);
if (_rightTriggerPressure > 0)
[_pressedButtons addObject:
OFGameControllerRightTriggerButton];
else
[_pressedButtons removeObject:
OFGameControllerRightTriggerButton];
break;
}
break;
}
}
}
- (OFComparisonResult)compare: (OFGameController *)otherController
{
unsigned long long selfIndex, otherIndex;
if (![otherController isKindOfClass: [OFGameController class]])
@throw [OFInvalidArgumentException exception];
selfIndex = [_path substringFromIndex: 16].unsignedLongLongValue;
otherIndex = [otherController->_path substringFromIndex: 16]
.unsignedLongLongValue;
if (selfIndex > otherIndex)
return OFOrderedDescending;
if (selfIndex < otherIndex)
return OFOrderedAscending;
return OFOrderedSame;
}
- (OFSet *)pressedButtons
{
return [[_pressedButtons copy] autorelease];
}
- (float)pressureForButton: (OFGameControllerButton)button
{
if (button == OFGameControllerLeftTriggerButton &&
_hasLeftTriggerPressure)
return _leftTriggerPressure;
if (button == OFGameControllerRightTriggerButton &&
_hasRightTriggerPressure)
return _rightTriggerPressure;
return ([self.pressedButtons containsObject: button] ? 1 : 0);
}
- (OFString *)description
{
return [OFString stringWithFormat: @"<%@: %@>", self.class, self.name];
}
@end