Rev 1 | Details | Compare with Previous | Last modification | View Log | RSS feed
| Rev | Author | Line No. | Line |
|---|---|---|---|
| 1 | pmbaty | 1 | /* |
| 2 | Simple DirectMedia Layer |
||
| 8 | pmbaty | 3 | Copyright (C) 1997-2018 Sam Lantinga <slouken@libsdl.org> |
| 1 | pmbaty | 4 | |
| 5 | This software is provided 'as-is', without any express or implied |
||
| 6 | warranty. In no event will the authors be held liable for any damages |
||
| 7 | arising from the use of this software. |
||
| 8 | |||
| 9 | Permission is granted to anyone to use this software for any purpose, |
||
| 10 | including commercial applications, and to alter it and redistribute it |
||
| 11 | freely, subject to the following restrictions: |
||
| 12 | |||
| 13 | 1. The origin of this software must not be misrepresented; you must not |
||
| 14 | claim that you wrote the original software. If you use this software |
||
| 15 | in a product, an acknowledgment in the product documentation would be |
||
| 16 | appreciated but is not required. |
||
| 17 | 2. Altered source versions must be plainly marked as such, and must not be |
||
| 18 | misrepresented as being the original software. |
||
| 19 | 3. This notice may not be removed or altered from any source distribution. |
||
| 20 | */ |
||
| 21 | |||
| 22 | /** |
||
| 23 | * \file SDL_gamecontroller.h |
||
| 24 | * |
||
| 25 | * Include file for SDL game controller event handling |
||
| 26 | */ |
||
| 27 | |||
| 28 | #ifndef SDL_gamecontroller_h_ |
||
| 29 | #define SDL_gamecontroller_h_ |
||
| 30 | |||
| 31 | #include "SDL_stdinc.h" |
||
| 32 | #include "SDL_error.h" |
||
| 33 | #include "SDL_rwops.h" |
||
| 34 | #include "SDL_joystick.h" |
||
| 35 | |||
| 36 | #include "begin_code.h" |
||
| 37 | /* Set up for C function definitions, even when using C++ */ |
||
| 38 | #ifdef __cplusplus |
||
| 39 | extern "C" { |
||
| 40 | #endif |
||
| 41 | |||
| 42 | /** |
||
| 43 | * \file SDL_gamecontroller.h |
||
| 44 | * |
||
| 45 | * In order to use these functions, SDL_Init() must have been called |
||
| 46 | * with the ::SDL_INIT_GAMECONTROLLER flag. This causes SDL to scan the system |
||
| 47 | * for game controllers, and load appropriate drivers. |
||
| 48 | * |
||
| 49 | * If you would like to receive controller updates while the application |
||
| 50 | * is in the background, you should set the following hint before calling |
||
| 51 | * SDL_Init(): SDL_HINT_JOYSTICK_ALLOW_BACKGROUND_EVENTS |
||
| 52 | */ |
||
| 53 | |||
| 54 | /** |
||
| 55 | * The gamecontroller structure used to identify an SDL game controller |
||
| 56 | */ |
||
| 57 | struct _SDL_GameController; |
||
| 58 | typedef struct _SDL_GameController SDL_GameController; |
||
| 59 | |||
| 60 | |||
| 61 | typedef enum |
||
| 62 | { |
||
| 63 | SDL_CONTROLLER_BINDTYPE_NONE = 0, |
||
| 64 | SDL_CONTROLLER_BINDTYPE_BUTTON, |
||
| 65 | SDL_CONTROLLER_BINDTYPE_AXIS, |
||
| 66 | SDL_CONTROLLER_BINDTYPE_HAT |
||
| 67 | } SDL_GameControllerBindType; |
||
| 68 | |||
| 69 | /** |
||
| 70 | * Get the SDL joystick layer binding for this controller button/axis mapping |
||
| 71 | */ |
||
| 72 | typedef struct SDL_GameControllerButtonBind |
||
| 73 | { |
||
| 74 | SDL_GameControllerBindType bindType; |
||
| 75 | union |
||
| 76 | { |
||
| 77 | int button; |
||
| 78 | int axis; |
||
| 79 | struct { |
||
| 80 | int hat; |
||
| 81 | int hat_mask; |
||
| 82 | } hat; |
||
| 83 | } value; |
||
| 84 | |||
| 85 | } SDL_GameControllerButtonBind; |
||
| 86 | |||
| 87 | |||
| 88 | /** |
||
| 89 | * To count the number of game controllers in the system for the following: |
||
| 90 | * int nJoysticks = SDL_NumJoysticks(); |
||
| 91 | * int nGameControllers = 0; |
||
| 92 | * for (int i = 0; i < nJoysticks; i++) { |
||
| 93 | * if (SDL_IsGameController(i)) { |
||
| 94 | * nGameControllers++; |
||
| 95 | * } |
||
| 96 | * } |
||
| 97 | * |
||
| 98 | * Using the SDL_HINT_GAMECONTROLLERCONFIG hint or the SDL_GameControllerAddMapping() you can add support for controllers SDL is unaware of or cause an existing controller to have a different binding. The format is: |
||
| 99 | * guid,name,mappings |
||
| 100 | * |
||
| 101 | * Where GUID is the string value from SDL_JoystickGetGUIDString(), name is the human readable string for the device and mappings are controller mappings to joystick ones. |
||
| 102 | * Under Windows there is a reserved GUID of "xinput" that covers any XInput devices. |
||
| 103 | * The mapping format for joystick is: |
||
| 104 | * bX - a joystick button, index X |
||
| 105 | * hX.Y - hat X with value Y |
||
| 106 | * aX - axis X of the joystick |
||
| 107 | * Buttons can be used as a controller axis and vice versa. |
||
| 108 | * |
||
| 109 | * This string shows an example of a valid mapping for a controller |
||
| 110 | * "03000000341a00003608000000000000,PS3 Controller,a:b1,b:b2,y:b3,x:b0,start:b9,guide:b12,back:b8,dpup:h0.1,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,leftshoulder:b4,rightshoulder:b5,leftstick:b10,rightstick:b11,leftx:a0,lefty:a1,rightx:a2,righty:a3,lefttrigger:b6,righttrigger:b7", |
||
| 111 | * |
||
| 112 | */ |
||
| 113 | |||
| 114 | /** |
||
| 115 | * Load a set of mappings from a seekable SDL data stream (memory or file), filtered by the current SDL_GetPlatform() |
||
| 116 | * A community sourced database of controllers is available at https://raw.github.com/gabomdq/SDL_GameControllerDB/master/gamecontrollerdb.txt |
||
| 117 | * |
||
| 118 | * If \c freerw is non-zero, the stream will be closed after being read. |
||
| 119 | * |
||
| 120 | * \return number of mappings added, -1 on error |
||
| 121 | */ |
||
| 122 | extern DECLSPEC int SDLCALL SDL_GameControllerAddMappingsFromRW(SDL_RWops * rw, int freerw); |
||
| 123 | |||
| 124 | /** |
||
| 125 | * Load a set of mappings from a file, filtered by the current SDL_GetPlatform() |
||
| 126 | * |
||
| 127 | * Convenience macro. |
||
| 128 | */ |
||
| 129 | #define SDL_GameControllerAddMappingsFromFile(file) SDL_GameControllerAddMappingsFromRW(SDL_RWFromFile(file, "rb"), 1) |
||
| 130 | |||
| 131 | /** |
||
| 132 | * Add or update an existing mapping configuration |
||
| 133 | * |
||
| 134 | * \return 1 if mapping is added, 0 if updated, -1 on error |
||
| 135 | */ |
||
| 136 | extern DECLSPEC int SDLCALL SDL_GameControllerAddMapping(const char* mappingString); |
||
| 137 | |||
| 138 | /** |
||
| 139 | * Get the number of mappings installed |
||
| 140 | * |
||
| 141 | * \return the number of mappings |
||
| 142 | */ |
||
| 143 | extern DECLSPEC int SDLCALL SDL_GameControllerNumMappings(void); |
||
| 144 | |||
| 145 | /** |
||
| 146 | * Get the mapping at a particular index. |
||
| 147 | * |
||
| 148 | * \return the mapping string. Must be freed with SDL_free(). Returns NULL if the index is out of range. |
||
| 149 | */ |
||
| 150 | extern DECLSPEC char * SDLCALL SDL_GameControllerMappingForIndex(int mapping_index); |
||
| 151 | |||
| 152 | /** |
||
| 153 | * Get a mapping string for a GUID |
||
| 154 | * |
||
| 155 | * \return the mapping string. Must be freed with SDL_free(). Returns NULL if no mapping is available |
||
| 156 | */ |
||
| 157 | extern DECLSPEC char * SDLCALL SDL_GameControllerMappingForGUID(SDL_JoystickGUID guid); |
||
| 158 | |||
| 159 | /** |
||
| 160 | * Get a mapping string for an open GameController |
||
| 161 | * |
||
| 162 | * \return the mapping string. Must be freed with SDL_free(). Returns NULL if no mapping is available |
||
| 163 | */ |
||
| 164 | extern DECLSPEC char * SDLCALL SDL_GameControllerMapping(SDL_GameController * gamecontroller); |
||
| 165 | |||
| 166 | /** |
||
| 167 | * Is the joystick on this index supported by the game controller interface? |
||
| 168 | */ |
||
| 169 | extern DECLSPEC SDL_bool SDLCALL SDL_IsGameController(int joystick_index); |
||
| 170 | |||
| 171 | /** |
||
| 172 | * Get the implementation dependent name of a game controller. |
||
| 173 | * This can be called before any controllers are opened. |
||
| 174 | * If no name can be found, this function returns NULL. |
||
| 175 | */ |
||
| 176 | extern DECLSPEC const char *SDLCALL SDL_GameControllerNameForIndex(int joystick_index); |
||
| 177 | |||
| 178 | /** |
||
| 8 | pmbaty | 179 | * Get the mapping of a game controller. |
| 180 | * This can be called before any controllers are opened. |
||
| 181 | * |
||
| 182 | * \return the mapping string. Must be freed with SDL_free(). Returns NULL if no mapping is available |
||
| 183 | */ |
||
| 184 | extern DECLSPEC char *SDLCALL SDL_GameControllerMappingForDeviceIndex(int joystick_index); |
||
| 185 | |||
| 186 | /** |
||
| 1 | pmbaty | 187 | * Open a game controller for use. |
| 188 | * The index passed as an argument refers to the N'th game controller on the system. |
||
| 189 | * This index is not the value which will identify this controller in future |
||
| 190 | * controller events. The joystick's instance id (::SDL_JoystickID) will be |
||
| 191 | * used there instead. |
||
| 192 | * |
||
| 193 | * \return A controller identifier, or NULL if an error occurred. |
||
| 194 | */ |
||
| 195 | extern DECLSPEC SDL_GameController *SDLCALL SDL_GameControllerOpen(int joystick_index); |
||
| 196 | |||
| 197 | /** |
||
| 198 | * Return the SDL_GameController associated with an instance id. |
||
| 199 | */ |
||
| 200 | extern DECLSPEC SDL_GameController *SDLCALL SDL_GameControllerFromInstanceID(SDL_JoystickID joyid); |
||
| 201 | |||
| 202 | /** |
||
| 203 | * Return the name for this currently opened controller |
||
| 204 | */ |
||
| 205 | extern DECLSPEC const char *SDLCALL SDL_GameControllerName(SDL_GameController *gamecontroller); |
||
| 206 | |||
| 207 | /** |
||
| 8 | pmbaty | 208 | * Get the player index of an opened game controller, or -1 if it's not available |
| 209 | * |
||
| 210 | * For XInput controllers this returns the XInput user index. |
||
| 211 | */ |
||
| 212 | extern DECLSPEC int SDLCALL SDL_GameControllerGetPlayerIndex(SDL_GameController *gamecontroller); |
||
| 213 | |||
| 214 | /** |
||
| 1 | pmbaty | 215 | * Get the USB vendor ID of an opened controller, if available. |
| 216 | * If the vendor ID isn't available this function returns 0. |
||
| 217 | */ |
||
| 218 | extern DECLSPEC Uint16 SDLCALL SDL_GameControllerGetVendor(SDL_GameController * gamecontroller); |
||
| 219 | |||
| 220 | /** |
||
| 221 | * Get the USB product ID of an opened controller, if available. |
||
| 222 | * If the product ID isn't available this function returns 0. |
||
| 223 | */ |
||
| 224 | extern DECLSPEC Uint16 SDLCALL SDL_GameControllerGetProduct(SDL_GameController * gamecontroller); |
||
| 225 | |||
| 226 | /** |
||
| 227 | * Get the product version of an opened controller, if available. |
||
| 228 | * If the product version isn't available this function returns 0. |
||
| 229 | */ |
||
| 230 | extern DECLSPEC Uint16 SDLCALL SDL_GameControllerGetProductVersion(SDL_GameController * gamecontroller); |
||
| 231 | |||
| 232 | /** |
||
| 233 | * Returns SDL_TRUE if the controller has been opened and currently connected, |
||
| 234 | * or SDL_FALSE if it has not. |
||
| 235 | */ |
||
| 236 | extern DECLSPEC SDL_bool SDLCALL SDL_GameControllerGetAttached(SDL_GameController *gamecontroller); |
||
| 237 | |||
| 238 | /** |
||
| 239 | * Get the underlying joystick object used by a controller |
||
| 240 | */ |
||
| 241 | extern DECLSPEC SDL_Joystick *SDLCALL SDL_GameControllerGetJoystick(SDL_GameController *gamecontroller); |
||
| 242 | |||
| 243 | /** |
||
| 244 | * Enable/disable controller event polling. |
||
| 245 | * |
||
| 246 | * If controller events are disabled, you must call SDL_GameControllerUpdate() |
||
| 247 | * yourself and check the state of the controller when you want controller |
||
| 248 | * information. |
||
| 249 | * |
||
| 250 | * The state can be one of ::SDL_QUERY, ::SDL_ENABLE or ::SDL_IGNORE. |
||
| 251 | */ |
||
| 252 | extern DECLSPEC int SDLCALL SDL_GameControllerEventState(int state); |
||
| 253 | |||
| 254 | /** |
||
| 255 | * Update the current state of the open game controllers. |
||
| 256 | * |
||
| 257 | * This is called automatically by the event loop if any game controller |
||
| 258 | * events are enabled. |
||
| 259 | */ |
||
| 260 | extern DECLSPEC void SDLCALL SDL_GameControllerUpdate(void); |
||
| 261 | |||
| 262 | |||
| 263 | /** |
||
| 264 | * The list of axes available from a controller |
||
| 265 | * |
||
| 266 | * Thumbstick axis values range from SDL_JOYSTICK_AXIS_MIN to SDL_JOYSTICK_AXIS_MAX, |
||
| 267 | * and are centered within ~8000 of zero, though advanced UI will allow users to set |
||
| 268 | * or autodetect the dead zone, which varies between controllers. |
||
| 269 | * |
||
| 270 | * Trigger axis values range from 0 to SDL_JOYSTICK_AXIS_MAX. |
||
| 271 | */ |
||
| 272 | typedef enum |
||
| 273 | { |
||
| 274 | SDL_CONTROLLER_AXIS_INVALID = -1, |
||
| 275 | SDL_CONTROLLER_AXIS_LEFTX, |
||
| 276 | SDL_CONTROLLER_AXIS_LEFTY, |
||
| 277 | SDL_CONTROLLER_AXIS_RIGHTX, |
||
| 278 | SDL_CONTROLLER_AXIS_RIGHTY, |
||
| 279 | SDL_CONTROLLER_AXIS_TRIGGERLEFT, |
||
| 280 | SDL_CONTROLLER_AXIS_TRIGGERRIGHT, |
||
| 281 | SDL_CONTROLLER_AXIS_MAX |
||
| 282 | } SDL_GameControllerAxis; |
||
| 283 | |||
| 284 | /** |
||
| 285 | * turn this string into a axis mapping |
||
| 286 | */ |
||
| 287 | extern DECLSPEC SDL_GameControllerAxis SDLCALL SDL_GameControllerGetAxisFromString(const char *pchString); |
||
| 288 | |||
| 289 | /** |
||
| 290 | * turn this axis enum into a string mapping |
||
| 291 | */ |
||
| 292 | extern DECLSPEC const char* SDLCALL SDL_GameControllerGetStringForAxis(SDL_GameControllerAxis axis); |
||
| 293 | |||
| 294 | /** |
||
| 295 | * Get the SDL joystick layer binding for this controller button mapping |
||
| 296 | */ |
||
| 297 | extern DECLSPEC SDL_GameControllerButtonBind SDLCALL |
||
| 298 | SDL_GameControllerGetBindForAxis(SDL_GameController *gamecontroller, |
||
| 299 | SDL_GameControllerAxis axis); |
||
| 300 | |||
| 301 | /** |
||
| 302 | * Get the current state of an axis control on a game controller. |
||
| 303 | * |
||
| 304 | * The state is a value ranging from -32768 to 32767 (except for the triggers, |
||
| 305 | * which range from 0 to 32767). |
||
| 306 | * |
||
| 307 | * The axis indices start at index 0. |
||
| 308 | */ |
||
| 309 | extern DECLSPEC Sint16 SDLCALL |
||
| 310 | SDL_GameControllerGetAxis(SDL_GameController *gamecontroller, |
||
| 311 | SDL_GameControllerAxis axis); |
||
| 312 | |||
| 313 | /** |
||
| 314 | * The list of buttons available from a controller |
||
| 315 | */ |
||
| 316 | typedef enum |
||
| 317 | { |
||
| 318 | SDL_CONTROLLER_BUTTON_INVALID = -1, |
||
| 319 | SDL_CONTROLLER_BUTTON_A, |
||
| 320 | SDL_CONTROLLER_BUTTON_B, |
||
| 321 | SDL_CONTROLLER_BUTTON_X, |
||
| 322 | SDL_CONTROLLER_BUTTON_Y, |
||
| 323 | SDL_CONTROLLER_BUTTON_BACK, |
||
| 324 | SDL_CONTROLLER_BUTTON_GUIDE, |
||
| 325 | SDL_CONTROLLER_BUTTON_START, |
||
| 326 | SDL_CONTROLLER_BUTTON_LEFTSTICK, |
||
| 327 | SDL_CONTROLLER_BUTTON_RIGHTSTICK, |
||
| 328 | SDL_CONTROLLER_BUTTON_LEFTSHOULDER, |
||
| 329 | SDL_CONTROLLER_BUTTON_RIGHTSHOULDER, |
||
| 330 | SDL_CONTROLLER_BUTTON_DPAD_UP, |
||
| 331 | SDL_CONTROLLER_BUTTON_DPAD_DOWN, |
||
| 332 | SDL_CONTROLLER_BUTTON_DPAD_LEFT, |
||
| 333 | SDL_CONTROLLER_BUTTON_DPAD_RIGHT, |
||
| 334 | SDL_CONTROLLER_BUTTON_MAX |
||
| 335 | } SDL_GameControllerButton; |
||
| 336 | |||
| 337 | /** |
||
| 338 | * turn this string into a button mapping |
||
| 339 | */ |
||
| 340 | extern DECLSPEC SDL_GameControllerButton SDLCALL SDL_GameControllerGetButtonFromString(const char *pchString); |
||
| 341 | |||
| 342 | /** |
||
| 343 | * turn this button enum into a string mapping |
||
| 344 | */ |
||
| 345 | extern DECLSPEC const char* SDLCALL SDL_GameControllerGetStringForButton(SDL_GameControllerButton button); |
||
| 346 | |||
| 347 | /** |
||
| 348 | * Get the SDL joystick layer binding for this controller button mapping |
||
| 349 | */ |
||
| 350 | extern DECLSPEC SDL_GameControllerButtonBind SDLCALL |
||
| 351 | SDL_GameControllerGetBindForButton(SDL_GameController *gamecontroller, |
||
| 352 | SDL_GameControllerButton button); |
||
| 353 | |||
| 354 | |||
| 355 | /** |
||
| 356 | * Get the current state of a button on a game controller. |
||
| 357 | * |
||
| 358 | * The button indices start at index 0. |
||
| 359 | */ |
||
| 360 | extern DECLSPEC Uint8 SDLCALL SDL_GameControllerGetButton(SDL_GameController *gamecontroller, |
||
| 361 | SDL_GameControllerButton button); |
||
| 362 | |||
| 363 | /** |
||
| 8 | pmbaty | 364 | * Trigger a rumble effect |
| 365 | * Each call to this function cancels any previous rumble effect, and calling it with 0 intensity stops any rumbling. |
||
| 366 | * |
||
| 367 | * \param gamecontroller The controller to vibrate |
||
| 368 | * \param low_frequency_rumble The intensity of the low frequency (left) rumble motor, from 0 to 0xFFFF |
||
| 369 | * \param high_frequency_rumble The intensity of the high frequency (right) rumble motor, from 0 to 0xFFFF |
||
| 370 | * \param duration_ms The duration of the rumble effect, in milliseconds |
||
| 371 | * |
||
| 372 | * \return 0, or -1 if rumble isn't supported on this joystick |
||
| 373 | */ |
||
| 374 | extern DECLSPEC int SDLCALL SDL_GameControllerRumble(SDL_GameController *gamecontroller, Uint16 low_frequency_rumble, Uint16 high_frequency_rumble, Uint32 duration_ms); |
||
| 375 | |||
| 376 | /** |
||
| 1 | pmbaty | 377 | * Close a controller previously opened with SDL_GameControllerOpen(). |
| 378 | */ |
||
| 379 | extern DECLSPEC void SDLCALL SDL_GameControllerClose(SDL_GameController *gamecontroller); |
||
| 380 | |||
| 381 | |||
| 382 | /* Ends C function definitions when using C++ */ |
||
| 383 | #ifdef __cplusplus |
||
| 384 | } |
||
| 385 | #endif |
||
| 386 | #include "close_code.h" |
||
| 387 | |||
| 388 | #endif /* SDL_gamecontroller_h_ */ |
||
| 389 | |||
| 390 | /* vi: set ts=4 sw=4 expandtab: */ |