/
SDL_sysjoystick.m
734 lines (612 loc) · 22.3 KB
1
2
/*
Simple DirectMedia Layer
3
Copyright (C) 1997-2018 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
51
static id connectObserver = nil;
static id disconnectObserver = nil;
#endif /* SDL_JOYSTICK_MFI */
52
53
#if !TARGET_OS_TV
54
static const char *accelerometerName = "iOS Accelerometer";
55
static CMMotionManager *motionManager = nil;
56
#endif /* !TARGET_OS_TV */
57
58
59
static SDL_JoystickDeviceItem *deviceList = NULL;
60
static int numjoysticks = 0;
61
int SDL_AppleTVRemoteOpenedAsJoystick = 0;
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
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
81
IOS_AddMFIJoystickDevice(SDL_JoystickDeviceItem *device, GCController *controller)
82
83
{
#ifdef SDL_JOYSTICK_MFI
84
const Uint16 VENDOR_APPLE = 0x05AC;
85
Uint16 *guid16 = (Uint16 *)device->guid.data;
86
87
88
89
Uint16 vendor = 0;
Uint16 product = 0;
Uint16 version = 0;
Uint8 subtype = 0;
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
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) {
107
108
109
vendor = VENDOR_APPLE;
product = 1;
subtype = 1;
110
111
112
113
device->naxes = 6; /* 2 thumbsticks and 2 triggers */
device->nhats = 1; /* d-pad */
device->nbuttons = 7; /* ABXY, shoulder buttons, pause button */
} else if (controller.gamepad) {
114
115
116
vendor = VENDOR_APPLE;
product = 2;
subtype = 2;
117
118
119
120
device->naxes = 0; /* no traditional analog inputs */
device->nhats = 1; /* d-pad */
device->nbuttons = 7; /* ABXY, shoulder buttons, pause button */
}
121
122
#if TARGET_OS_TV
else if (controller.microGamepad) {
123
124
125
vendor = VENDOR_APPLE;
product = 3;
subtype = 3;
126
127
128
device->naxes = 2; /* treat the touch surface as two axes */
device->nhats = 0; /* apparently the touch surface-as-dpad is buggy */
device->nbuttons = 3; /* AX, pause button */
129
130
controller.microGamepad.allowsRotation = SDL_GetHintBoolean(SDL_HINT_APPLE_TV_REMOTE_ALLOW_ROTATION, SDL_FALSE);
131
132
}
#endif /* TARGET_OS_TV */
133
134
135
/* 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. */
136
*guid16++ = SDL_SwapLE16(SDL_HARDWARE_BUS_BLUETOOTH);
137
*guid16++ = 0;
138
139
140
141
142
143
*guid16++ = SDL_SwapLE16(vendor);
*guid16++ = 0;
*guid16++ = SDL_SwapLE16(product);
*guid16++ = 0;
*guid16++ = SDL_SwapLE16(version);
*guid16++ = 0;
144
145
146
147
/* Note that this is an MFI controller and what subtype it is */
device->guid.data[14] = 'm';
device->guid.data[15] = subtype;
148
149
150
151
/* This will be set when the first button press of the controller is
* detected. */
controller.playerIndex = -1;
152
153
#endif /* SDL_JOYSTICK_MFI */
154
155
156
}
static void
157
IOS_AddJoystickDevice(GCController *controller, SDL_bool accelerometer)
158
159
160
{
SDL_JoystickDeviceItem *device = deviceList;
161
162
163
164
165
166
167
168
169
#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
170
171
172
173
174
175
176
while (device != NULL) {
if (device->controller == controller) {
return;
}
device = device->next;
}
177
device = (SDL_JoystickDeviceItem *) SDL_calloc(1, sizeof(SDL_JoystickDeviceItem));
178
179
180
181
182
if (device == NULL) {
return;
}
device->accelerometer = accelerometer;
183
device->instance_id = SDL_GetNextJoystickInstanceID();
184
185
if (accelerometer) {
186
187
188
189
#if TARGET_OS_TV
SDL_free(device);
return;
#else
190
191
192
193
194
195
196
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)));
197
#endif /* TARGET_OS_TV */
198
} else if (controller) {
199
IOS_AddMFIJoystickDevice(device, controller);
200
201
202
203
204
205
206
207
208
209
210
211
212
213
}
if (deviceList == NULL) {
deviceList = device;
} else {
SDL_JoystickDeviceItem *lastdevice = deviceList;
while (lastdevice->next != NULL) {
lastdevice = lastdevice->next;
}
lastdevice->next = device;
}
++numjoysticks;
214
SDL_PrivateJoystickAdded(device->instance_id);
215
216
}
217
static SDL_JoystickDeviceItem *
218
IOS_RemoveJoystickDevice(SDL_JoystickDeviceItem *device)
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
{
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;
263
SDL_PrivateJoystickRemoved(device->instance_id);
264
265
266
267
SDL_free(device->name);
SDL_free(device);
268
269
return next;
}
270
271
#if TARGET_OS_TV
272
static void SDLCALL
273
274
275
276
277
278
279
280
281
282
283
284
285
286
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 */
287
288
static int
IOS_JoystickInit(void)
289
{
290
291
292
@autoreleasepool {
NSNotificationCenter *center = [NSNotificationCenter defaultCenter];
293
#if !TARGET_OS_TV
294
if (SDL_GetHintBoolean(SDL_HINT_ACCELEROMETER_AS_JOYSTICK, SDL_TRUE)) {
295
/* Default behavior, accelerometer as joystick */
296
IOS_AddJoystickDevice(nil, SDL_TRUE);
297
}
298
#endif /* !TARGET_OS_TV */
299
300
301
302
#ifdef SDL_JOYSTICK_MFI
/* GameController.framework was added in iOS 7. */
if (![GCController class]) {
303
return 0;
304
305
306
}
for (GCController *controller in [GCController controllers]) {
307
IOS_AddJoystickDevice(controller, SDL_FALSE);
308
309
}
310
311
312
313
314
#if TARGET_OS_TV
SDL_AddHintCallback(SDL_HINT_APPLE_TV_REMOTE_ALLOW_ROTATION,
SDL_AppleTVRemoteRotationHintChanged, NULL);
#endif /* TARGET_OS_TV */
315
316
317
318
319
connectObserver = [center addObserverForName:GCControllerDidConnectNotification
object:nil
queue:nil
usingBlock:^(NSNotification *note) {
GCController *controller = note.object;
320
IOS_AddJoystickDevice(controller, SDL_FALSE);
321
322
323
324
325
326
327
328
329
330
}];
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) {
331
IOS_RemoveJoystickDevice(device);
332
333
334
335
336
337
break;
}
device = device->next;
}
}];
#endif /* SDL_JOYSTICK_MFI */
338
339
}
340
return 0;
341
342
}
343
344
static int
IOS_JoystickGetCount(void)
345
346
347
348
{
return numjoysticks;
}
349
350
static void
IOS_JoystickDetect(void)
351
352
353
{
}
354
355
static const char *
IOS_JoystickGetDeviceName(int device_index)
356
{
357
358
SDL_JoystickDeviceItem *device = GetDeviceForIndex(device_index);
return device ? device->name : "Unknown";
359
360
}
361
362
363
364
365
366
static int
IOS_JoystickGetDevicePlayerIndex(int device_index)
{
return -1;
}
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
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)
382
{
383
SDL_JoystickDeviceItem *device = GetDeviceForIndex(device_index);
384
return device ? device->instance_id : -1;
385
386
}
387
388
static int
IOS_JoystickOpen(SDL_Joystick * joystick, int device_index)
389
{
390
391
392
393
394
395
396
397
398
399
400
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;
401
joystick->nballs = 0;
402
403
device->joystick = joystick;
404
405
@autoreleasepool {
406
if (device->accelerometer) {
407
#if !TARGET_OS_TV
408
409
410
411
412
413
414
if (motionManager == nil) {
motionManager = [[CMMotionManager alloc] init];
}
/* Shorter times between updates can significantly increase CPU usage. */
motionManager.accelerometerUpdateInterval = 0.1;
[motionManager startAccelerometerUpdates];
415
#endif /* !TARGET_OS_TV */
416
417
418
} else {
#ifdef SDL_JOYSTICK_MFI
GCController *controller = device->controller;
419
controller.controllerPausedHandler = ^(GCController *c) {
420
421
422
423
424
if (joystick->hwdata) {
++joystick->hwdata->num_pause_presses;
}
};
#endif /* SDL_JOYSTICK_MFI */
425
426
}
}
427
428
429
if (device->remote) {
++SDL_AppleTVRemoteOpenedAsJoystick;
}
430
431
432
433
return 0;
}
434
static void
435
IOS_AccelerometerUpdate(SDL_Joystick * joystick)
436
{
437
#if !TARGET_OS_TV
438
439
440
441
442
const float maxgforce = SDL_IPHONE_MAX_GFORCE;
const SInt16 maxsint16 = 0x7FFF;
CMAcceleration accel;
@autoreleasepool {
443
if (!motionManager.isAccelerometerActive) {
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
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 */
472
SDL_PrivateJoystickAxis(joystick, 0, (accel.x / maxgforce) * maxsint16);
473
SDL_PrivateJoystickAxis(joystick, 1, -(accel.y / maxgforce) * maxsint16);
474
SDL_PrivateJoystickAxis(joystick, 2, (accel.z / maxgforce) * maxsint16);
475
#endif /* !TARGET_OS_TV */
476
477
478
479
}
#ifdef SDL_JOYSTICK_MFI
static Uint8
480
IOS_MFIJoystickHatStateForDPad(GCControllerDirectionPad *dpad)
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
{
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
505
IOS_MFIJoystickUpdate(SDL_Joystick * joystick)
506
{
507
#if SDL_JOYSTICK_MFI
508
509
510
511
@autoreleasepool {
GCController *controller = joystick->hwdata->controller;
Uint8 hatstate = SDL_HAT_CENTERED;
int i;
512
int updateplayerindex = 0;
513
514
515
516
517
if (controller.extendedGamepad) {
GCExtendedGamepad *gamepad = controller.extendedGamepad;
/* Axis order matches the XInput Windows mappings. */
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
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. */
Uint8 buttons[] = {
gamepad.buttonA.isPressed, gamepad.buttonB.isPressed,
gamepad.buttonX.isPressed, gamepad.buttonY.isPressed,
gamepad.leftShoulder.isPressed,
gamepad.rightShoulder.isPressed,
};
534
535
hatstate = IOS_MFIJoystickHatStateForDPad(gamepad.dpad);
536
537
538
539
540
541
for (i = 0; i < SDL_arraysize(axes); i++) {
/* The triggers (axes 2 and 5) are resting at -32768 but SDL
* initializes its values to 0. We only want to make sure the
* player index is up to date if the user actually moves an axis. */
if ((i != 2 && i != 5) || axes[i] != -32768) {
542
updateplayerindex |= (joystick->axes[i].value != axes[i]);
543
544
545
546
547
548
549
550
}
SDL_PrivateJoystickAxis(joystick, i, axes[i]);
}
for (i = 0; i < SDL_arraysize(buttons); i++) {
updateplayerindex |= (joystick->buttons[i] != buttons[i]);
SDL_PrivateJoystickButton(joystick, i, buttons[i]);
}
551
552
553
} else if (controller.gamepad) {
GCGamepad *gamepad = controller.gamepad;
554
555
556
557
558
559
560
561
/* Button order matches the XInput Windows mappings. */
Uint8 buttons[] = {
gamepad.buttonA.isPressed, gamepad.buttonB.isPressed,
gamepad.buttonX.isPressed, gamepad.buttonY.isPressed,
gamepad.leftShoulder.isPressed,
gamepad.rightShoulder.isPressed,
};
562
hatstate = IOS_MFIJoystickHatStateForDPad(gamepad.dpad);
563
564
565
566
567
for (i = 0; i < SDL_arraysize(buttons); i++) {
updateplayerindex |= (joystick->buttons[i] != buttons[i]);
SDL_PrivateJoystickButton(joystick, i, buttons[i]);
}
568
}
569
570
571
572
573
574
575
576
577
578
#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++) {
579
updateplayerindex |= (joystick->axes[i].value != axes[i]);
580
581
582
583
584
585
586
587
588
589
590
591
592
593
SDL_PrivateJoystickAxis(joystick, i, axes[i]);
}
Uint8 buttons[] = {
gamepad.buttonA.isPressed,
gamepad.buttonX.isPressed,
};
for (i = 0; i < SDL_arraysize(buttons); i++) {
updateplayerindex |= (joystick->buttons[i] != buttons[i]);
SDL_PrivateJoystickButton(joystick, i, buttons[i]);
}
}
#endif /* TARGET_OS_TV */
594
595
596
597
598
if (joystick->nhats > 0) {
updateplayerindex |= (joystick->hats[0] != hatstate);
SDL_PrivateJoystickHat(joystick, 0, hatstate);
}
599
600
for (i = 0; i < joystick->hwdata->num_pause_presses; i++) {
601
const Uint8 pausebutton = joystick->nbuttons - 1; /* The pause button is always last. */
602
SDL_PrivateJoystickButton(joystick, pausebutton, SDL_PRESSED);
603
SDL_PrivateJoystickButton(joystick, pausebutton, SDL_RELEASED);
604
updateplayerindex = YES;
605
606
}
joystick->hwdata->num_pause_presses = 0;
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
if (updateplayerindex && controller.playerIndex == -1) {
BOOL usedPlayerIndexSlots[4] = {NO, NO, NO, NO};
/* Find the player index of all other connected controllers. */
for (GCController *c in [GCController controllers]) {
if (c != controller && c.playerIndex >= 0) {
usedPlayerIndexSlots[c.playerIndex] = YES;
}
}
/* Set this controller's player index to the first unused index.
* FIXME: This logic isn't great... but SDL doesn't expose this
* concept in its external API, so we don't have much to go on. */
for (i = 0; i < SDL_arraysize(usedPlayerIndexSlots); i++) {
if (!usedPlayerIndexSlots[i]) {
controller.playerIndex = i;
break;
}
}
}
628
}
629
#endif /* SDL_JOYSTICK_MFI */
630
631
}
632
633
634
635
636
637
638
639
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)
640
{
641
642
643
644
645
SDL_JoystickDeviceItem *device = joystick->hwdata;
if (device == NULL) {
return;
}
646
647
if (device->accelerometer) {
648
IOS_AccelerometerUpdate(joystick);
649
} else if (device->controller) {
650
IOS_MFIJoystickUpdate(joystick);
651
}
652
653
}
654
655
static void
IOS_JoystickClose(SDL_Joystick * joystick)
656
{
657
658
659
660
661
662
663
664
SDL_JoystickDeviceItem *device = joystick->hwdata;
if (device == NULL) {
return;
}
device->joystick = NULL;
665
@autoreleasepool {
666
if (device->accelerometer) {
667
#if !TARGET_OS_TV
668
[motionManager stopAccelerometerUpdates];
669
#endif /* !TARGET_OS_TV */
670
671
672
673
} else if (device->controller) {
#ifdef SDL_JOYSTICK_MFI
GCController *controller = device->controller;
controller.controllerPausedHandler = nil;
674
controller.playerIndex = -1;
675
676
#endif
}
677
}
678
679
680
if (device->remote) {
--SDL_AppleTVRemoteOpenedAsJoystick;
}
681
682
}
683
684
static void
IOS_JoystickQuit(void)
685
686
{
@autoreleasepool {
687
688
689
690
691
692
693
694
695
696
697
698
#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;
}
699
700
701
702
703
#if TARGET_OS_TV
SDL_DelHintCallback(SDL_HINT_APPLE_TV_REMOTE_ALLOW_ROTATION,
SDL_AppleTVRemoteRotationHintChanged, NULL);
#endif /* TARGET_OS_TV */
704
705
706
#endif /* SDL_JOYSTICK_MFI */
while (deviceList != NULL) {
707
IOS_RemoveJoystickDevice(deviceList);
708
709
}
710
#if !TARGET_OS_TV
711
motionManager = nil;
712
#endif /* !TARGET_OS_TV */
713
714
715
716
717
}
numjoysticks = 0;
}
718
SDL_JoystickDriver SDL_IOS_JoystickDriver =
719
{
720
721
722
723
IOS_JoystickInit,
IOS_JoystickGetCount,
IOS_JoystickDetect,
IOS_JoystickGetDeviceName,
724
IOS_JoystickGetDevicePlayerIndex,
725
726
727
728
729
730
731
732
IOS_JoystickGetDeviceGUID,
IOS_JoystickGetDeviceInstanceID,
IOS_JoystickOpen,
IOS_JoystickRumble,
IOS_JoystickUpdate,
IOS_JoystickClose,
IOS_JoystickQuit,
};
733
734
/* vi: set ts=4 sw=4 expandtab: */