This repository has been archived by the owner on Feb 11, 2021. It is now read-only.
/
SDL_haptic.c
349 lines (289 loc) · 6.96 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
/*
SDL - Simple DirectMedia Layer
Copyright (C) 2008 Edgar Simo
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library 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 for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Sam Lantinga
slouken@libsdl.org
*/
#include "SDL_config.h"
#include "SDL_haptic_c.h"
#include "SDL_syshaptic.h"
static Uint8 SDL_numhaptics = 0;
SDL_Haptic **SDL_haptics = NULL;
static SDL_Haptic *default_haptic = NULL;
/*
* Initializes the Haptic devices.
*/
int
SDL_HapticInit(void)
{
int arraylen;
int status;
SDL_numhaptics = 0;
status = SDL_SYS_HapticInit();
if (status >= 0) {
arraylen = (status + 1) * sizeof(*SDL_haptics);
SDL_haptics = (SDL_Haptic **) SDL_malloc(arraylen);
if (SDL_haptics == NULL) {
SDL_numhaptics = 0;
} else {
SDL_memset(SDL_haptics, 0, arraylen);
SDL_numhaptics = status;
}
status = 0;
}
default_haptic = NULL;
return status;
}
/*
* Returns the number of available devices.
*/
int
SDL_NumHaptics(void)
{
return SDL_numhaptics;
}
/*
* Gets the name of a Haptic device by index.
*/
const char *
SDL_HapticName(int device_index)
{
if ((device_index < 0) || (device_index >= SDL_numhaptics)) {
SDL_SetError("There are %d haptic devices available", SDL_numhaptics);
return NULL;
}
return SDL_SYS_HapticName(device_index);
}
/*
86
* Opens a Haptic device.
87
88
89
90
91
92
93
94
95
96
97
98
99
*/
SDL_Haptic *
SDL_HapticOpen(int device_index)
{
int i;
SDL_Haptic *haptic;
if ((device_index < 0) || (device_index >= SDL_numhaptics)) {
SDL_SetError("There are %d haptic devices available", SDL_numhaptics);
return NULL;
}
/* If the haptic is already open, return it */
100
for (i=0; SDL_haptics[i]; i++) {
101
102
103
104
105
106
107
if (device_index == SDL_haptics[i]->index) {
haptic = SDL_haptics[i];
++haptic->ref_count;
return haptic;
}
}
108
/* Create the haptic device */
109
haptic = (SDL_Haptic *) SDL_malloc((sizeof *haptic));
110
111
112
if (haptic == NULL) {
SDL_OutOfMemory();
return NULL;
113
}
114
115
116
117
118
119
120
/* Initialize the haptic device */
SDL_memset(haptic, 0, (sizeof *haptic));
haptic->index = device_index;
if (SDL_SYS_HapticOpen(haptic) < 0) {
SDL_free(haptic);
return NULL;
121
}
122
123
124
125
126
127
128
/* Add haptic to list */
++haptic->ref_count;
for (i = 0; SDL_haptics[i]; ++i)
/* Skip to next haptic */ ;
SDL_haptics[i] = haptic;
129
130
return haptic;
}
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
/*
* Checks to see if the haptic device is valid
*/
static int
ValidHaptic(SDL_Haptic ** haptic)
{
int valid;
if (*haptic == NULL) {
SDL_SetError("Haptic device hasn't been opened yet");
valid = 0;
} else {
valid = 1;
}
return valid;
}
151
152
153
154
155
156
/*
* Closes a SDL_Haptic device.
*/
void
SDL_HapticClose(SDL_Haptic * haptic)
{
157
158
159
160
161
162
163
164
165
166
167
168
int i;
/* Must be valid */
if (!ValidHaptic(&haptic)) {
return;
}
/* Check if it's still in use */
if (--haptic->ref_count < 0) {
return;
}
169
170
171
172
173
174
/* Close it, properly removing effects if needed */
for (i=0; i<haptic->neffects; i++) {
if (haptic->effects[i].hweffect != NULL) {
SDL_HapticDestroyEffect(haptic,i);
}
}
175
176
177
178
179
180
181
182
183
184
185
186
187
SDL_SYS_HapticClose(haptic);
/* Remove from the list */
for (i = 0; SDL_haptics[i]; ++i) {
if (haptic == SDL_haptics[i]) {
SDL_memcpy(&SDL_haptics[i], &SDL_haptics[i + 1],
(SDL_numhaptics - i) * sizeof(haptic));
break;
}
}
/* Free */
SDL_free(haptic);
188
189
190
191
192
}
/*
* Cleans up after the subsystem.
*/
193
194
195
196
197
198
199
200
201
202
203
void
SDL_HapticQuit(void)
{
SDL_numhaptics = 0;
SDL_SYS_HapticQuit();
if (SDL_haptics != NULL) {
SDL_free(SDL_haptics);
SDL_haptics = NULL;
}
}
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
/*
* Returns the number of effects a haptic device has.
*/
int
SDL_HapticNumEffects(SDL_Haptic * haptic)
{
if (!ValidHaptic(&haptic)) {
return -1;
}
return haptic->neffects;
}
/*
* Returns supported effects by the device.
*/
unsigned int
SDL_HapticQueryEffects(SDL_Haptic * haptic)
{
if (!ValidHaptic(&haptic)) {
return -1;
}
return haptic->supported;
}
int
SDL_HapticEffectSupported(SDL_Haptic * haptic, SDL_HapticEffect * effect)
{
if (!ValidHaptic(&haptic)) {
return -1;
}
if ((haptic->supported & effect->type) != 0)
return SDL_TRUE;
return SDL_FALSE;
}
242
243
244
245
246
247
248
249
250
251
252
253
254
255
/*
* Creates a new haptic effect.
*/
int
SDL_HapticNewEffect(SDL_Haptic * haptic, SDL_HapticEffect * effect)
{
int i;
/* Check for device validity. */
if (!ValidHaptic(&haptic)) {
return -1;
}
256
257
258
259
260
261
/* Check to see if effect is supported */
if (SDL_HapticEffectSupported(haptic,effect)==SDL_FALSE) {
SDL_SetError("Haptic effect not supported by haptic device.");
return -1;
}
262
263
264
265
266
/* See if there's a free slot */
for (i=0; i<haptic->neffects; i++) {
if (haptic->effects[i].hweffect == NULL) {
/* Now let the backend create the real effect */
267
if (SDL_SYS_HapticNewEffect(haptic,&haptic->effects[i],effect) != 0) {
268
269
270
271
272
273
274
275
276
277
return -1; /* Backend failed to create effect */
}
return i;
}
}
SDL_SetError("Haptic device has no free space left.");
return -1;
}
278
279
280
281
282
283
284
285
286
287
288
289
290
/*
* Checks to see if an effect is valid.
*/
static int
ValidEffect(SDL_Haptic * haptic, int effect)
{
if ((effect < 0) || (effect >= haptic->neffects)) {
SDL_SetError("Invalid haptic effect identifier.");
return 0;
}
return 1;
}
291
292
293
294
295
296
/*
* Runs the haptic effect on the device.
*/
int
SDL_HapticRunEffect(SDL_Haptic * haptic, int effect)
{
297
if (!ValidHaptic(&haptic) || !ValidEffect(haptic,effect)) {
298
299
return -1;
}
300
301
302
303
304
305
306
/* Run the effect */
if (SDL_SYS_HapticRunEffect(haptic,&haptic->effects[effect]) < 0) {
return -1;
}
return 0;
307
308
309
310
311
312
313
314
}
/*
* Gets rid of a haptic effect.
*/
void
SDL_HapticDestroyEffect(SDL_Haptic * haptic, int effect)
{
315
if (!ValidHaptic(&haptic) || !ValidEffect(haptic,effect)) {
316
317
return;
}
318
319
320
321
322
323
324
/* Not allocated */
if (haptic->effects[effect].hweffect == NULL) {
return;
}
SDL_SYS_HapticDestroyEffect(haptic, &haptic->effects[effect]);
325
326
}
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
/*
* Sets the global gain of the device.
*/
int
SDL_HapticSetGain(SDL_Haptic * haptic, int gain )
{
if (!ValidHaptic(&haptic)) {
return -1;
}
if ((gain < 0) || (gain > 100)) {
SDL_SetError("Haptic gain must be between 0 and 100.");
return -1;
}
if (SDL_SYS_HapticSetGain(haptic,gain) < 0) {
return -1;
}
return 0;
}