/
SDL_sysjoystick.m
861 lines (725 loc) · 28 KB
1
2
/*
Simple DirectMedia Layer
3
Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
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 "../../SDL_internal.h"
/* This is the iOS implementation of the SDL joystick API */
24
25
26
27
#include "SDL_sysjoystick_c.h"
/* needed for SDL_IPHONE_MAX_GFORCE macro */
#include "SDL_config_iphoneos.h"
28
29
#include "SDL_assert.h"
30
#include "SDL_events.h"
31
32
33
34
35
#include "SDL_joystick.h"
#include "SDL_hints.h"
#include "SDL_stdinc.h"
#include "../SDL_sysjoystick.h"
#include "../SDL_joystick_c.h"
36
37
38
39
40
41
42
#if !SDL_EVENTS_DISABLED
#include "../../events/SDL_events_c.h"
#endif
#if !TARGET_OS_TV
43
#import <CoreMotion/CoreMotion.h>
44
#endif
45
46
47
#ifdef SDL_JOYSTICK_MFI
#import <GameController/GameController.h>
48
49
50
static id connectObserver = nil;
static id disconnectObserver = nil;
51
52
53
54
#include <Availability.h>
#include <objc/message.h>
55
56
57
/* remove compilation warnings for strict builds by defining these selectors, even though
* they are only ever used indirectly through objc_msgSend
*/
58
@interface GCExtendedGamepad (SDL)
59
60
61
62
63
#if (__IPHONE_OS_VERSION_MAX_ALLOWED < 121000) || (__APPLETV_OS_VERSION_MAX_ALLOWED < 121000) || (__MAC_OS_VERSION_MAX_ALLOWED < 1401000)
@property (nonatomic, readonly, nullable) GCControllerButtonInput *leftThumbstickButton;
@property (nonatomic, readonly, nullable) GCControllerButtonInput *rightThumbstickButton;
#endif
#if (__IPHONE_OS_VERSION_MAX_ALLOWED < 130000) || (__APPLETV_OS_VERSION_MAX_ALLOWED < 130000) || (__MAC_OS_VERSION_MAX_ALLOWED < 1500000)
64
65
66
@property (nonatomic, readonly) GCControllerButtonInput *buttonMenu;
@property (nonatomic, readonly, nullable) GCControllerButtonInput *buttonOptions;
#endif
67
68
69
70
@end
@interface GCMicroGamepad (SDL)
#if (__IPHONE_OS_VERSION_MAX_ALLOWED < 130000) || (__APPLETV_OS_VERSION_MAX_ALLOWED < 130000) || (__MAC_OS_VERSION_MAX_ALLOWED < 1500000)
@property (nonatomic, readonly) GCControllerButtonInput *buttonMenu;
71
72
73
#endif
@end
74
#endif /* SDL_JOYSTICK_MFI */
75
76
#if !TARGET_OS_TV
77
static const char *accelerometerName = "iOS Accelerometer";
78
static CMMotionManager *motionManager = nil;
79
#endif /* !TARGET_OS_TV */
80
81
82
static SDL_JoystickDeviceItem *deviceList = NULL;
83
static int numjoysticks = 0;
84
int SDL_AppleTVRemoteOpenedAsJoystick = 0;
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
static SDL_JoystickDeviceItem *
GetDeviceForIndex(int device_index)
{
SDL_JoystickDeviceItem *device = deviceList;
int i = 0;
while (i < device_index) {
if (device == NULL) {
return NULL;
}
device = device->next;
i++;
}
return device;
}
static void
104
IOS_AddMFIJoystickDevice(SDL_JoystickDeviceItem *device, GCController *controller)
105
106
{
#ifdef SDL_JOYSTICK_MFI
107
const Uint16 VENDOR_APPLE = 0x05AC;
108
109
const Uint16 VENDOR_MICROSOFT = 0x045e;
const Uint16 VENDOR_SONY = 0x054C;
110
Uint16 *guid16 = (Uint16 *)device->guid.data;
111
112
113
Uint16 vendor = 0;
Uint16 product = 0;
Uint8 subtype = 0;
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
const char *name = NULL;
/* Explicitly retain the controller because SDL_JoystickDeviceItem is a
* struct, and ARC doesn't work with structs. */
device->controller = (__bridge GCController *) CFBridgingRetain(controller);
if (controller.vendorName) {
name = controller.vendorName.UTF8String;
}
if (!name) {
name = "MFi Gamepad";
}
device->name = SDL_strdup(name);
if (controller.extendedGamepad) {
131
GCExtendedGamepad *gamepad = controller.extendedGamepad;
132
133
134
BOOL is_xbox = [controller.vendorName containsString: @"Xbox"];
BOOL is_ps4 = [controller.vendorName containsString: @"DUALSHOCK"];
BOOL is_MFi = (!is_xbox && !is_ps4);
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
int nbuttons = 0;
/* These buttons are part of the original MFi spec */
device->button_mask |= (1 << SDL_CONTROLLER_BUTTON_A);
device->button_mask |= (1 << SDL_CONTROLLER_BUTTON_B);
device->button_mask |= (1 << SDL_CONTROLLER_BUTTON_X);
device->button_mask |= (1 << SDL_CONTROLLER_BUTTON_Y);
device->button_mask |= (1 << SDL_CONTROLLER_BUTTON_LEFTSHOULDER);
device->button_mask |= (1 << SDL_CONTROLLER_BUTTON_RIGHTSHOULDER);
nbuttons += 6;
/* These buttons are available on some newer controllers */
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunguarded-availability-new"
if ([gamepad respondsToSelector:@selector(leftThumbstickButton)] && gamepad.leftThumbstickButton) {
device->button_mask |= (1 << SDL_CONTROLLER_BUTTON_LEFTSTICK);
++nbuttons;
}
if ([gamepad respondsToSelector:@selector(rightThumbstickButton)] && gamepad.rightThumbstickButton) {
device->button_mask |= (1 << SDL_CONTROLLER_BUTTON_RIGHTSTICK);
++nbuttons;
156
}
157
158
159
160
if ([gamepad respondsToSelector:@selector(buttonOptions)] && gamepad.buttonOptions) {
device->button_mask |= (1 << SDL_CONTROLLER_BUTTON_BACK);
++nbuttons;
}
161
162
163
164
165
166
167
168
169
170
BOOL has_direct_menu = [gamepad respondsToSelector:@selector(buttonMenu)] && gamepad.buttonMenu;
#if TARGET_OS_TV
/* On tvOS MFi controller menu button brings you to the home screen */
if (is_MFi) {
has_direct_menu = FALSE;
}
#endif
device->button_mask |= (1 << SDL_CONTROLLER_BUTTON_START);
++nbuttons;
if (!has_direct_menu) {
171
172
173
device->uses_pause_handler = SDL_TRUE;
}
#pragma clang diagnostic pop
174
175
if (is_xbox) {
176
vendor = VENDOR_MICROSOFT;
177
product = 0x02E0; /* Assume Xbox One S BLE Controller unless/until GCController flows VID/PID */
178
} else if (is_ps4) {
179
vendor = VENDOR_SONY;
180
product = 0x09CC; /* Assume DS4 Slim unless/until GCController flows VID/PID */
181
182
183
184
185
} else {
vendor = VENDOR_APPLE;
product = 1;
subtype = 1;
}
186
187
188
device->naxes = 6; /* 2 thumbsticks and 2 triggers */
device->nhats = 1; /* d-pad */
189
device->nbuttons = nbuttons;
190
191
} else if (controller.gamepad) {
192
193
194
195
196
197
198
199
200
201
202
203
204
int nbuttons = 0;
/* These buttons are part of the original MFi spec */
device->button_mask |= (1 << SDL_CONTROLLER_BUTTON_A);
device->button_mask |= (1 << SDL_CONTROLLER_BUTTON_B);
device->button_mask |= (1 << SDL_CONTROLLER_BUTTON_X);
device->button_mask |= (1 << SDL_CONTROLLER_BUTTON_Y);
device->button_mask |= (1 << SDL_CONTROLLER_BUTTON_LEFTSHOULDER);
device->button_mask |= (1 << SDL_CONTROLLER_BUTTON_RIGHTSHOULDER);
device->button_mask |= (1 << SDL_CONTROLLER_BUTTON_START);
nbuttons += 7;
device->uses_pause_handler = SDL_TRUE;
205
206
207
vendor = VENDOR_APPLE;
product = 2;
subtype = 2;
208
209
device->naxes = 0; /* no traditional analog inputs */
device->nhats = 1; /* d-pad */
210
device->nbuttons = nbuttons;
211
}
212
213
#if TARGET_OS_TV
else if (controller.microGamepad) {
214
215
216
217
218
219
int nbuttons = 0;
device->button_mask |= (1 << SDL_CONTROLLER_BUTTON_A);
device->button_mask |= (1 << SDL_CONTROLLER_BUTTON_B); /* Button X on microGamepad */
nbuttons += 2;
220
221
222
device->button_mask |= (1 << SDL_CONTROLLER_BUTTON_START);
++nbuttons;
device->uses_pause_handler = SDL_TRUE;
223
224
225
226
vendor = VENDOR_APPLE;
product = 3;
subtype = 3;
227
228
device->naxes = 2; /* treat the touch surface as two axes */
device->nhats = 0; /* apparently the touch surface-as-dpad is buggy */
229
device->nbuttons = nbuttons;
230
231
controller.microGamepad.allowsRotation = SDL_GetHintBoolean(SDL_HINT_APPLE_TV_REMOTE_ALLOW_ROTATION, SDL_FALSE);
232
233
}
#endif /* TARGET_OS_TV */
234
235
236
/* We only need 16 bits for each of these; space them out to fill 128. */
/* Byteswap so devices get same GUID on little/big endian platforms. */
237
*guid16++ = SDL_SwapLE16(SDL_HARDWARE_BUS_BLUETOOTH);
238
*guid16++ = 0;
239
240
241
242
*guid16++ = SDL_SwapLE16(vendor);
*guid16++ = 0;
*guid16++ = SDL_SwapLE16(product);
*guid16++ = 0;
243
244
245
246
247
248
249
250
*guid16++ = SDL_SwapLE16(device->button_mask);
if (subtype != 0) {
/* Note that this is an MFI controller and what subtype it is */
device->guid.data[14] = 'm';
device->guid.data[15] = subtype;
}
251
252
253
254
/* This will be set when the first button press of the controller is
* detected. */
controller.playerIndex = -1;
255
256
#endif /* SDL_JOYSTICK_MFI */
257
258
259
}
static void
260
IOS_AddJoystickDevice(GCController *controller, SDL_bool accelerometer)
261
262
263
{
SDL_JoystickDeviceItem *device = deviceList;
264
265
266
267
268
269
270
271
272
#if TARGET_OS_TV
if (!SDL_GetHintBoolean(SDL_HINT_TV_REMOTE_AS_JOYSTICK, SDL_TRUE)) {
/* Ignore devices that aren't actually controllers (e.g. remotes), they'll be handled as keyboard input */
if (controller && !controller.extendedGamepad && !controller.gamepad && controller.microGamepad) {
return;
}
}
#endif
273
274
275
276
277
278
279
while (device != NULL) {
if (device->controller == controller) {
return;
}
device = device->next;
}
280
device = (SDL_JoystickDeviceItem *) SDL_calloc(1, sizeof(SDL_JoystickDeviceItem));
281
282
283
284
285
if (device == NULL) {
return;
}
device->accelerometer = accelerometer;
286
device->instance_id = SDL_GetNextJoystickInstanceID();
287
288
if (accelerometer) {
289
290
291
292
#if TARGET_OS_TV
SDL_free(device);
return;
#else
293
294
295
296
297
298
299
device->name = SDL_strdup(accelerometerName);
device->naxes = 3; /* Device acceleration in the x, y, and z axes. */
device->nhats = 0;
device->nbuttons = 0;
/* Use the accelerometer name as a GUID. */
SDL_memcpy(&device->guid.data, device->name, SDL_min(sizeof(SDL_JoystickGUID), SDL_strlen(device->name)));
300
#endif /* TARGET_OS_TV */
301
} else if (controller) {
302
IOS_AddMFIJoystickDevice(device, controller);
303
304
305
306
307
308
309
310
311
312
313
314
315
316
}
if (deviceList == NULL) {
deviceList = device;
} else {
SDL_JoystickDeviceItem *lastdevice = deviceList;
while (lastdevice->next != NULL) {
lastdevice = lastdevice->next;
}
lastdevice->next = device;
}
++numjoysticks;
317
SDL_PrivateJoystickAdded(device->instance_id);
318
319
}
320
static SDL_JoystickDeviceItem *
321
IOS_RemoveJoystickDevice(SDL_JoystickDeviceItem *device)
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
{
SDL_JoystickDeviceItem *prev = NULL;
SDL_JoystickDeviceItem *next = NULL;
SDL_JoystickDeviceItem *item = deviceList;
if (device == NULL) {
return NULL;
}
next = device->next;
while (item != NULL) {
if (item == device) {
break;
}
prev = item;
item = item->next;
}
/* Unlink the device item from the device list. */
if (prev) {
prev->next = device->next;
} else if (device == deviceList) {
deviceList = device->next;
}
if (device->joystick) {
device->joystick->hwdata = NULL;
}
#ifdef SDL_JOYSTICK_MFI
@autoreleasepool {
if (device->controller) {
/* The controller was explicitly retained in the struct, so it
* should be explicitly released before freeing the struct. */
GCController *controller = CFBridgingRelease((__bridge CFTypeRef)(device->controller));
controller.controllerPausedHandler = nil;
device->controller = nil;
}
}
#endif /* SDL_JOYSTICK_MFI */
--numjoysticks;
366
SDL_PrivateJoystickRemoved(device->instance_id);
367
368
369
370
SDL_free(device->name);
SDL_free(device);
371
372
return next;
}
373
374
#if TARGET_OS_TV
375
static void SDLCALL
376
377
378
379
380
381
382
383
384
385
386
387
388
389
SDL_AppleTVRemoteRotationHintChanged(void *udata, const char *name, const char *oldValue, const char *newValue)
{
BOOL allowRotation = newValue != NULL && *newValue != '0';
@autoreleasepool {
for (GCController *controller in [GCController controllers]) {
if (controller.microGamepad) {
controller.microGamepad.allowsRotation = allowRotation;
}
}
}
}
#endif /* TARGET_OS_TV */
390
391
static int
IOS_JoystickInit(void)
392
{
393
394
395
@autoreleasepool {
NSNotificationCenter *center = [NSNotificationCenter defaultCenter];
396
#if !TARGET_OS_TV
397
if (SDL_GetHintBoolean(SDL_HINT_ACCELEROMETER_AS_JOYSTICK, SDL_TRUE)) {
398
/* Default behavior, accelerometer as joystick */
399
IOS_AddJoystickDevice(nil, SDL_TRUE);
400
}
401
#endif /* !TARGET_OS_TV */
402
403
404
405
#ifdef SDL_JOYSTICK_MFI
/* GameController.framework was added in iOS 7. */
if (![GCController class]) {
406
return 0;
407
408
409
}
for (GCController *controller in [GCController controllers]) {
410
IOS_AddJoystickDevice(controller, SDL_FALSE);
411
412
}
413
414
415
416
417
#if TARGET_OS_TV
SDL_AddHintCallback(SDL_HINT_APPLE_TV_REMOTE_ALLOW_ROTATION,
SDL_AppleTVRemoteRotationHintChanged, NULL);
#endif /* TARGET_OS_TV */
418
419
420
421
422
connectObserver = [center addObserverForName:GCControllerDidConnectNotification
object:nil
queue:nil
usingBlock:^(NSNotification *note) {
GCController *controller = note.object;
423
IOS_AddJoystickDevice(controller, SDL_FALSE);
424
425
426
427
428
429
430
431
432
433
}];
disconnectObserver = [center addObserverForName:GCControllerDidDisconnectNotification
object:nil
queue:nil
usingBlock:^(NSNotification *note) {
GCController *controller = note.object;
SDL_JoystickDeviceItem *device = deviceList;
while (device != NULL) {
if (device->controller == controller) {
434
IOS_RemoveJoystickDevice(device);
435
436
437
438
439
440
break;
}
device = device->next;
}
}];
#endif /* SDL_JOYSTICK_MFI */
441
442
}
443
return 0;
444
445
}
446
447
static int
IOS_JoystickGetCount(void)
448
449
450
451
{
return numjoysticks;
}
452
453
static void
IOS_JoystickDetect(void)
454
455
456
{
}
457
458
static const char *
IOS_JoystickGetDeviceName(int device_index)
459
{
460
461
SDL_JoystickDeviceItem *device = GetDeviceForIndex(device_index);
return device ? device->name : "Unknown";
462
463
}
464
465
466
static int
IOS_JoystickGetDevicePlayerIndex(int device_index)
{
467
468
SDL_JoystickDeviceItem *device = GetDeviceForIndex(device_index);
return device ? (int)device->controller.playerIndex : -1;
469
470
}
471
472
473
474
475
476
477
478
479
static void
IOS_JoystickSetDevicePlayerIndex(int device_index, int player_index)
{
SDL_JoystickDeviceItem *device = GetDeviceForIndex(device_index);
if (device) {
device->controller.playerIndex = player_index;
}
}
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
static SDL_JoystickGUID
IOS_JoystickGetDeviceGUID( int device_index )
{
SDL_JoystickDeviceItem *device = GetDeviceForIndex(device_index);
SDL_JoystickGUID guid;
if (device) {
guid = device->guid;
} else {
SDL_zero(guid);
}
return guid;
}
static SDL_JoystickID
IOS_JoystickGetDeviceInstanceID(int device_index)
495
{
496
SDL_JoystickDeviceItem *device = GetDeviceForIndex(device_index);
497
return device ? device->instance_id : -1;
498
499
}
500
501
static int
IOS_JoystickOpen(SDL_Joystick * joystick, int device_index)
502
{
503
504
505
506
507
508
509
510
511
512
513
SDL_JoystickDeviceItem *device = GetDeviceForIndex(device_index);
if (device == NULL) {
return SDL_SetError("Could not open Joystick: no hardware device for the specified index");
}
joystick->hwdata = device;
joystick->instance_id = device->instance_id;
joystick->naxes = device->naxes;
joystick->nhats = device->nhats;
joystick->nbuttons = device->nbuttons;
514
joystick->nballs = 0;
515
516
device->joystick = joystick;
517
518
@autoreleasepool {
519
if (device->accelerometer) {
520
#if !TARGET_OS_TV
521
522
523
524
525
526
527
if (motionManager == nil) {
motionManager = [[CMMotionManager alloc] init];
}
/* Shorter times between updates can significantly increase CPU usage. */
motionManager.accelerometerUpdateInterval = 0.1;
[motionManager startAccelerometerUpdates];
528
#endif /* !TARGET_OS_TV */
529
530
} else {
#ifdef SDL_JOYSTICK_MFI
531
532
533
534
535
536
537
538
if (device->uses_pause_handler) {
GCController *controller = device->controller;
controller.controllerPausedHandler = ^(GCController *c) {
if (joystick->hwdata) {
++joystick->hwdata->num_pause_presses;
}
};
}
539
#endif /* SDL_JOYSTICK_MFI */
540
541
}
}
542
543
544
if (device->remote) {
++SDL_AppleTVRemoteOpenedAsJoystick;
}
545
546
547
548
return 0;
}
549
static void
550
IOS_AccelerometerUpdate(SDL_Joystick * joystick)
551
{
552
#if !TARGET_OS_TV
553
554
555
556
557
const float maxgforce = SDL_IPHONE_MAX_GFORCE;
const SInt16 maxsint16 = 0x7FFF;
CMAcceleration accel;
@autoreleasepool {
558
if (!motionManager.isAccelerometerActive) {
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
return;
}
accel = motionManager.accelerometerData.acceleration;
}
/*
Convert accelerometer data from floating point to Sint16, which is what
the joystick system expects.
To do the conversion, the data is first clamped onto the interval
[-SDL_IPHONE_MAX_G_FORCE, SDL_IPHONE_MAX_G_FORCE], then the data is multiplied
by MAX_SINT16 so that it is mapped to the full range of an Sint16.
You can customize the clamped range of this function by modifying the
SDL_IPHONE_MAX_GFORCE macro in SDL_config_iphoneos.h.
Once converted to Sint16, the accelerometer data no longer has coherent
units. You can convert the data back to units of g-force by multiplying
it in your application's code by SDL_IPHONE_MAX_GFORCE / 0x7FFF.
*/
/* clamp the data */
accel.x = SDL_min(SDL_max(accel.x, -maxgforce), maxgforce);
accel.y = SDL_min(SDL_max(accel.y, -maxgforce), maxgforce);
accel.z = SDL_min(SDL_max(accel.z, -maxgforce), maxgforce);
/* pass in data mapped to range of SInt16 */
587
SDL_PrivateJoystickAxis(joystick, 0, (accel.x / maxgforce) * maxsint16);
588
SDL_PrivateJoystickAxis(joystick, 1, -(accel.y / maxgforce) * maxsint16);
589
SDL_PrivateJoystickAxis(joystick, 2, (accel.z / maxgforce) * maxsint16);
590
#endif /* !TARGET_OS_TV */
591
592
593
594
}
#ifdef SDL_JOYSTICK_MFI
static Uint8
595
IOS_MFIJoystickHatStateForDPad(GCControllerDirectionPad *dpad)
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
{
Uint8 hat = 0;
if (dpad.up.isPressed) {
hat |= SDL_HAT_UP;
} else if (dpad.down.isPressed) {
hat |= SDL_HAT_DOWN;
}
if (dpad.left.isPressed) {
hat |= SDL_HAT_LEFT;
} else if (dpad.right.isPressed) {
hat |= SDL_HAT_RIGHT;
}
if (hat == 0) {
return SDL_HAT_CENTERED;
}
return hat;
}
#endif
static void
620
IOS_MFIJoystickUpdate(SDL_Joystick * joystick)
621
{
622
#if SDL_JOYSTICK_MFI
623
624
625
626
@autoreleasepool {
GCController *controller = joystick->hwdata->controller;
Uint8 hatstate = SDL_HAT_CENTERED;
int i;
627
int pause_button_index = 0;
628
629
630
631
632
if (controller.extendedGamepad) {
GCExtendedGamepad *gamepad = controller.extendedGamepad;
/* Axis order matches the XInput Windows mappings. */
633
634
635
636
637
638
639
640
641
642
Sint16 axes[] = {
(Sint16) (gamepad.leftThumbstick.xAxis.value * 32767),
(Sint16) (gamepad.leftThumbstick.yAxis.value * -32767),
(Sint16) ((gamepad.leftTrigger.value * 65535) - 32768),
(Sint16) (gamepad.rightThumbstick.xAxis.value * 32767),
(Sint16) (gamepad.rightThumbstick.yAxis.value * -32767),
(Sint16) ((gamepad.rightTrigger.value * 65535) - 32768),
};
/* Button order matches the XInput Windows mappings. */
643
Uint8 buttons[joystick->nbuttons];
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
int button_count = 0;
/* These buttons are part of the original MFi spec */
buttons[button_count++] = gamepad.buttonA.isPressed;
buttons[button_count++] = gamepad.buttonB.isPressed;
buttons[button_count++] = gamepad.buttonX.isPressed;
buttons[button_count++] = gamepad.buttonY.isPressed;
buttons[button_count++] = gamepad.leftShoulder.isPressed;
buttons[button_count++] = gamepad.rightShoulder.isPressed;
/* These buttons are available on some newer controllers */
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunguarded-availability-new"
if (joystick->hwdata->button_mask & (1 << SDL_CONTROLLER_BUTTON_LEFTSTICK)) {
buttons[button_count++] = gamepad.leftThumbstickButton.isPressed;
659
}
660
661
if (joystick->hwdata->button_mask & (1 << SDL_CONTROLLER_BUTTON_RIGHTSTICK)) {
buttons[button_count++] = gamepad.rightThumbstickButton.isPressed;
662
}
663
664
665
666
667
668
669
if (joystick->hwdata->button_mask & (1 << SDL_CONTROLLER_BUTTON_BACK)) {
buttons[button_count++] = gamepad.buttonOptions.isPressed;
}
/* This must be the last button, so we can optionally handle it with pause_button_index below */
if (joystick->hwdata->button_mask & (1 << SDL_CONTROLLER_BUTTON_START)) {
if (joystick->hwdata->uses_pause_handler) {
pause_button_index = button_count;
670
buttons[button_count++] = joystick->delayed_guide_button;
671
672
673
674
675
} else {
buttons[button_count++] = gamepad.buttonMenu.isPressed;
}
}
#pragma clang diagnostic pop
676
677
hatstate = IOS_MFIJoystickHatStateForDPad(gamepad.dpad);
678
679
680
681
682
for (i = 0; i < SDL_arraysize(axes); i++) {
SDL_PrivateJoystickAxis(joystick, i, axes[i]);
}
683
for (i = 0; i < button_count; i++) {
684
685
SDL_PrivateJoystickButton(joystick, i, buttons[i]);
}
686
687
688
} else if (controller.gamepad) {
GCGamepad *gamepad = controller.gamepad;
689
/* Button order matches the XInput Windows mappings. */
690
691
692
693
694
695
696
697
698
Uint8 buttons[joystick->nbuttons];
int button_count = 0;
buttons[button_count++] = gamepad.buttonA.isPressed;
buttons[button_count++] = gamepad.buttonB.isPressed;
buttons[button_count++] = gamepad.buttonX.isPressed;
buttons[button_count++] = gamepad.buttonY.isPressed;
buttons[button_count++] = gamepad.leftShoulder.isPressed;
buttons[button_count++] = gamepad.rightShoulder.isPressed;
pause_button_index = button_count;
699
buttons[button_count++] = joystick->delayed_guide_button;
700
701
hatstate = IOS_MFIJoystickHatStateForDPad(gamepad.dpad);
702
703
for (i = 0; i < button_count; i++) {
704
705
SDL_PrivateJoystickButton(joystick, i, buttons[i]);
}
706
}
707
708
709
710
711
712
713
714
715
716
717
718
719
#if TARGET_OS_TV
else if (controller.microGamepad) {
GCMicroGamepad *gamepad = controller.microGamepad;
Sint16 axes[] = {
(Sint16) (gamepad.dpad.xAxis.value * 32767),
(Sint16) (gamepad.dpad.yAxis.value * -32767),
};
for (i = 0; i < SDL_arraysize(axes); i++) {
SDL_PrivateJoystickAxis(joystick, i, axes[i]);
}
720
721
722
723
724
725
726
727
728
729
Uint8 buttons[joystick->nbuttons];
int button_count = 0;
buttons[button_count++] = gamepad.buttonA.isPressed;
buttons[button_count++] = gamepad.buttonX.isPressed;
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunguarded-availability-new"
/* This must be the last button, so we can optionally handle it with pause_button_index below */
if (joystick->hwdata->button_mask & (1 << SDL_CONTROLLER_BUTTON_START)) {
if (joystick->hwdata->uses_pause_handler) {
pause_button_index = button_count;
730
buttons[button_count++] = joystick->delayed_guide_button;
731
732
733
734
735
} else {
buttons[button_count++] = gamepad.buttonMenu.isPressed;
}
}
#pragma clang diagnostic pop
736
737
for (i = 0; i < button_count; i++) {
738
739
740
741
SDL_PrivateJoystickButton(joystick, i, buttons[i]);
}
}
#endif /* TARGET_OS_TV */
742
743
744
745
if (joystick->nhats > 0) {
SDL_PrivateJoystickHat(joystick, 0, hatstate);
}
746
747
748
749
750
751
752
if (joystick->hwdata->uses_pause_handler) {
for (i = 0; i < joystick->hwdata->num_pause_presses; i++) {
SDL_PrivateJoystickButton(joystick, pause_button_index, SDL_PRESSED);
SDL_PrivateJoystickButton(joystick, pause_button_index, SDL_RELEASED);
}
joystick->hwdata->num_pause_presses = 0;
753
754
}
}
755
#endif /* SDL_JOYSTICK_MFI */
756
757
}
758
759
760
761
762
763
764
765
static int
IOS_JoystickRumble(SDL_Joystick * joystick, Uint16 low_frequency_rumble, Uint16 high_frequency_rumble, Uint32 duration_ms)
{
return SDL_Unsupported();
}
static void
IOS_JoystickUpdate(SDL_Joystick * joystick)
766
{
767
768
769
770
771
SDL_JoystickDeviceItem *device = joystick->hwdata;
if (device == NULL) {
return;
}
772
773
if (device->accelerometer) {
774
IOS_AccelerometerUpdate(joystick);
775
} else if (device->controller) {
776
IOS_MFIJoystickUpdate(joystick);
777
}
778
779
}
780
781
static void
IOS_JoystickClose(SDL_Joystick * joystick)
782
{
783
784
785
786
787
788
789
790
SDL_JoystickDeviceItem *device = joystick->hwdata;
if (device == NULL) {
return;
}
device->joystick = NULL;
791
@autoreleasepool {
792
if (device->accelerometer) {
793
#if !TARGET_OS_TV
794
[motionManager stopAccelerometerUpdates];
795
#endif /* !TARGET_OS_TV */
796
797
798
799
} else if (device->controller) {
#ifdef SDL_JOYSTICK_MFI
GCController *controller = device->controller;
controller.controllerPausedHandler = nil;
800
controller.playerIndex = -1;
801
802
#endif
}
803
}
804
805
806
if (device->remote) {
--SDL_AppleTVRemoteOpenedAsJoystick;
}
807
808
}
809
810
static void
IOS_JoystickQuit(void)
811
812
{
@autoreleasepool {
813
814
815
816
817
818
819
820
821
822
823
824
#ifdef SDL_JOYSTICK_MFI
NSNotificationCenter *center = [NSNotificationCenter defaultCenter];
if (connectObserver) {
[center removeObserver:connectObserver name:GCControllerDidConnectNotification object:nil];
connectObserver = nil;
}
if (disconnectObserver) {
[center removeObserver:disconnectObserver name:GCControllerDidDisconnectNotification object:nil];
disconnectObserver = nil;
}
825
826
827
828
829
#if TARGET_OS_TV
SDL_DelHintCallback(SDL_HINT_APPLE_TV_REMOTE_ALLOW_ROTATION,
SDL_AppleTVRemoteRotationHintChanged, NULL);
#endif /* TARGET_OS_TV */
830
831
832
#endif /* SDL_JOYSTICK_MFI */
while (deviceList != NULL) {
833
IOS_RemoveJoystickDevice(deviceList);
834
835
}
836
#if !TARGET_OS_TV
837
motionManager = nil;
838
#endif /* !TARGET_OS_TV */
839
840
841
842
843
}
numjoysticks = 0;
}
844
SDL_JoystickDriver SDL_IOS_JoystickDriver =
845
{
846
847
848
849
IOS_JoystickInit,
IOS_JoystickGetCount,
IOS_JoystickDetect,
IOS_JoystickGetDeviceName,
850
IOS_JoystickGetDevicePlayerIndex,
851
IOS_JoystickSetDevicePlayerIndex,
852
853
854
855
856
857
858
859
IOS_JoystickGetDeviceGUID,
IOS_JoystickGetDeviceInstanceID,
IOS_JoystickOpen,
IOS_JoystickRumble,
IOS_JoystickUpdate,
IOS_JoystickClose,
IOS_JoystickQuit,
};
860
861
/* vi: set ts=4 sw=4 expandtab: */