in_sdl.c 10 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467
  1. /*
  2. * (C) Gražvydas "notaz" Ignotas, 2012
  3. *
  4. * This work is licensed under the terms of any of these licenses
  5. * (at your option):
  6. * - GNU GPL, version 2 or later.
  7. * - GNU LGPL, version 2.1 or later.
  8. * See the COPYING file in the top-level directory.
  9. */
  10. #include <stdio.h>
  11. #include <SDL.h>
  12. #include "input.h"
  13. #include "in_sdl.h"
  14. #define IN_SDL_PREFIX "sdl:"
  15. /* should be machine word for best performace */
  16. typedef unsigned long keybits_t;
  17. #define KEYBITS_WORD_BITS (sizeof(keybits_t) * 8)
  18. struct in_sdl_state {
  19. SDL_Joystick *joy;
  20. int joy_id;
  21. int axis_keydown[2];
  22. keybits_t keystate[SDLK_LAST / KEYBITS_WORD_BITS + 1];
  23. };
  24. static const char * const in_sdl_keys[SDLK_LAST] = {
  25. [SDLK_BACKSPACE] = "backspace",
  26. [SDLK_TAB] = "tab",
  27. [SDLK_CLEAR] = "clear",
  28. [SDLK_RETURN] = "return",
  29. [SDLK_PAUSE] = "pause",
  30. [SDLK_ESCAPE] = "escape",
  31. [SDLK_SPACE] = "space",
  32. [SDLK_EXCLAIM] = "!",
  33. [SDLK_QUOTEDBL] = "\"",
  34. [SDLK_HASH] = "#",
  35. [SDLK_DOLLAR] = "$",
  36. [SDLK_AMPERSAND] = "&",
  37. [SDLK_QUOTE] = "'",
  38. [SDLK_LEFTPAREN] = "(",
  39. [SDLK_RIGHTPAREN] = ")",
  40. [SDLK_ASTERISK] = "*",
  41. [SDLK_PLUS] = "+",
  42. [SDLK_COMMA] = ",",
  43. [SDLK_MINUS] = "-",
  44. [SDLK_PERIOD] = ".",
  45. [SDLK_SLASH] = "/",
  46. [SDLK_0] = "0",
  47. [SDLK_1] = "1",
  48. [SDLK_2] = "2",
  49. [SDLK_3] = "3",
  50. [SDLK_4] = "4",
  51. [SDLK_5] = "5",
  52. [SDLK_6] = "6",
  53. [SDLK_7] = "7",
  54. [SDLK_8] = "8",
  55. [SDLK_9] = "9",
  56. [SDLK_COLON] = ":",
  57. [SDLK_SEMICOLON] = ",",
  58. [SDLK_LESS] = "<",
  59. [SDLK_EQUALS] = "=",
  60. [SDLK_GREATER] = ">",
  61. [SDLK_QUESTION] = "?",
  62. [SDLK_AT] = "@",
  63. [SDLK_LEFTBRACKET] = "[",
  64. [SDLK_BACKSLASH] = "\\",
  65. [SDLK_RIGHTBRACKET] = "]",
  66. [SDLK_CARET] = "^",
  67. [SDLK_UNDERSCORE] = "_",
  68. [SDLK_BACKQUOTE] = "`",
  69. [SDLK_a] = "a",
  70. [SDLK_b] = "b",
  71. [SDLK_c] = "c",
  72. [SDLK_d] = "d",
  73. [SDLK_e] = "e",
  74. [SDLK_f] = "f",
  75. [SDLK_g] = "g",
  76. [SDLK_h] = "h",
  77. [SDLK_i] = "i",
  78. [SDLK_j] = "j",
  79. [SDLK_k] = "k",
  80. [SDLK_l] = "l",
  81. [SDLK_m] = "m",
  82. [SDLK_n] = "n",
  83. [SDLK_o] = "o",
  84. [SDLK_p] = "p",
  85. [SDLK_q] = "q",
  86. [SDLK_r] = "r",
  87. [SDLK_s] = "s",
  88. [SDLK_t] = "t",
  89. [SDLK_u] = "u",
  90. [SDLK_v] = "v",
  91. [SDLK_w] = "w",
  92. [SDLK_x] = "x",
  93. [SDLK_y] = "y",
  94. [SDLK_z] = "z",
  95. [SDLK_DELETE] = "delete",
  96. [SDLK_KP0] = "[0]",
  97. [SDLK_KP1] = "[1]",
  98. [SDLK_KP2] = "[2]",
  99. [SDLK_KP3] = "[3]",
  100. [SDLK_KP4] = "[4]",
  101. [SDLK_KP5] = "[5]",
  102. [SDLK_KP6] = "[6]",
  103. [SDLK_KP7] = "[7]",
  104. [SDLK_KP8] = "[8]",
  105. [SDLK_KP9] = "[9]",
  106. [SDLK_KP_PERIOD] = "[.]",
  107. [SDLK_KP_DIVIDE] = "[/]",
  108. [SDLK_KP_MULTIPLY] = "[*]",
  109. [SDLK_KP_MINUS] = "[-]",
  110. [SDLK_KP_PLUS] = "[+]",
  111. [SDLK_KP_ENTER] = "enter",
  112. [SDLK_KP_EQUALS] = "equals",
  113. [SDLK_UP] = "up",
  114. [SDLK_DOWN] = "down",
  115. [SDLK_RIGHT] = "right",
  116. [SDLK_LEFT] = "left",
  117. [SDLK_DOWN] = "down",
  118. [SDLK_INSERT] = "insert",
  119. [SDLK_HOME] = "home",
  120. [SDLK_END] = "end",
  121. [SDLK_PAGEUP] = "page up",
  122. [SDLK_PAGEDOWN] = "page down",
  123. [SDLK_F1] = "f1",
  124. [SDLK_F2] = "f2",
  125. [SDLK_F3] = "f3",
  126. [SDLK_F4] = "f4",
  127. [SDLK_F5] = "f5",
  128. [SDLK_F6] = "f6",
  129. [SDLK_F7] = "f7",
  130. [SDLK_F8] = "f8",
  131. [SDLK_F9] = "f9",
  132. [SDLK_F10] = "f10",
  133. [SDLK_F11] = "f11",
  134. [SDLK_F12] = "f12",
  135. [SDLK_F13] = "f13",
  136. [SDLK_F14] = "f14",
  137. [SDLK_F15] = "f15",
  138. [SDLK_NUMLOCK] = "numlock",
  139. [SDLK_CAPSLOCK] = "caps lock",
  140. [SDLK_SCROLLOCK] = "scroll lock",
  141. [SDLK_RSHIFT] = "right shift",
  142. [SDLK_LSHIFT] = "left shift",
  143. [SDLK_RCTRL] = "right ctrl",
  144. [SDLK_LCTRL] = "left ctrl",
  145. [SDLK_RALT] = "right alt",
  146. [SDLK_LALT] = "left alt",
  147. [SDLK_RMETA] = "right meta",
  148. [SDLK_LMETA] = "left meta",
  149. [SDLK_LSUPER] = "left super", /* "Windows" keys */
  150. [SDLK_RSUPER] = "right super",
  151. [SDLK_MODE] = "alt gr",
  152. [SDLK_COMPOSE] = "compose",
  153. };
  154. static void in_sdl_probe(void)
  155. {
  156. struct in_sdl_state *state;
  157. SDL_Joystick *joy;
  158. int i, joycount;
  159. char name[256];
  160. state = calloc(1, sizeof(*state));
  161. if (state == NULL) {
  162. fprintf(stderr, "in_sdl: OOM\n");
  163. return;
  164. }
  165. in_register(IN_SDL_PREFIX "keys", -1, state, SDLK_LAST,
  166. in_sdl_keys, 0);
  167. /* joysticks go here too */
  168. SDL_InitSubSystem(SDL_INIT_JOYSTICK);
  169. joycount = SDL_NumJoysticks();
  170. for (i = 0; i < joycount; i++) {
  171. joy = SDL_JoystickOpen(i);
  172. if (joy == NULL)
  173. continue;
  174. state = calloc(1, sizeof(*state));
  175. if (state == NULL) {
  176. fprintf(stderr, "in_sdl: OOM\n");
  177. break;
  178. }
  179. state->joy = joy;
  180. state->joy_id = i;
  181. snprintf(name, sizeof(name), IN_SDL_PREFIX "%s", SDL_JoystickName(i));
  182. in_register(name, -1, state, SDLK_LAST, in_sdl_keys, 0);
  183. }
  184. if (joycount > 0)
  185. SDL_JoystickEventState(SDL_ENABLE);
  186. }
  187. static void in_sdl_free(void *drv_data)
  188. {
  189. struct in_sdl_state *state = drv_data;
  190. if (state != NULL) {
  191. if (state->joy != NULL)
  192. SDL_JoystickClose(state->joy);
  193. free(state);
  194. }
  195. }
  196. static const char * const *
  197. in_sdl_get_key_names(int *count)
  198. {
  199. *count = SDLK_LAST;
  200. return in_sdl_keys;
  201. }
  202. /* could use SDL_GetKeyState, but this gives better packing */
  203. static void update_keystate(keybits_t *keystate, int sym, int is_down)
  204. {
  205. keybits_t *ks_word, mask;
  206. mask = 1;
  207. mask <<= sym & (KEYBITS_WORD_BITS - 1);
  208. ks_word = keystate + sym / KEYBITS_WORD_BITS;
  209. if (is_down)
  210. *ks_word |= mask;
  211. else
  212. *ks_word &= ~mask;
  213. }
  214. static int handle_event(struct in_sdl_state *state, SDL_Event *event,
  215. int *kc_out, int *down_out)
  216. {
  217. if (event->type != SDL_KEYDOWN && event->type != SDL_KEYUP)
  218. return 0;
  219. update_keystate(state->keystate, event->key.keysym.sym,
  220. event->type == SDL_KEYDOWN);
  221. if (kc_out != NULL)
  222. *kc_out = event->key.keysym.sym;
  223. if (down_out != NULL)
  224. *down_out = event->type == SDL_KEYDOWN;
  225. return 1;
  226. }
  227. static int handle_joy_event(struct in_sdl_state *state, SDL_Event *event,
  228. int *kc_out, int *down_out)
  229. {
  230. int kc = -1, down = 0, ret = 0;
  231. /* FIXME: should ckeck .which */
  232. /* TODO: remaining axis */
  233. switch (event->type) {
  234. case SDL_JOYAXISMOTION:
  235. if (event->jaxis.axis > 1)
  236. break;
  237. if (-16384 <= event->jaxis.value && event->jaxis.value <= 16384) {
  238. kc = state->axis_keydown[event->jaxis.axis];
  239. state->axis_keydown[event->jaxis.axis] = 0;
  240. ret = 1;
  241. }
  242. else if (event->jaxis.value < -16384) {
  243. kc = state->axis_keydown[event->jaxis.axis];
  244. if (kc)
  245. update_keystate(state->keystate, kc, 0);
  246. kc = event->jaxis.axis ? SDLK_UP : SDLK_LEFT;
  247. state->axis_keydown[event->jaxis.axis] = kc;
  248. down = 1;
  249. ret = 1;
  250. }
  251. else if (event->jaxis.value > 16384) {
  252. kc = state->axis_keydown[event->jaxis.axis];
  253. if (kc)
  254. update_keystate(state->keystate, kc, 0);
  255. kc = event->jaxis.axis ? SDLK_DOWN : SDLK_RIGHT;
  256. state->axis_keydown[event->jaxis.axis] = kc;
  257. down = 1;
  258. ret = 1;
  259. }
  260. break;
  261. case SDL_JOYBUTTONDOWN:
  262. case SDL_JOYBUTTONUP:
  263. kc = (int)event->jbutton.button + SDLK_WORLD_0;
  264. down = event->jbutton.state == SDL_PRESSED;
  265. ret = 1;
  266. break;
  267. }
  268. if (ret)
  269. update_keystate(state->keystate, kc, down);
  270. if (kc_out != NULL)
  271. *kc_out = kc;
  272. if (down_out != NULL)
  273. *down_out = down;
  274. return ret;
  275. }
  276. #define JOY_EVENTS (SDL_JOYAXISMOTIONMASK | SDL_JOYBALLMOTIONMASK | SDL_JOYHATMOTIONMASK \
  277. | SDL_JOYBUTTONDOWNMASK | SDL_JOYBUTTONUPMASK)
  278. static int collect_events(struct in_sdl_state *state, int *one_kc, int *one_down)
  279. {
  280. SDL_Event events[4];
  281. Uint32 mask = state->joy ? JOY_EVENTS : (SDL_ALLEVENTS & ~JOY_EVENTS);
  282. int count, maxcount;
  283. int i, ret, retval = 0;
  284. maxcount = (one_kc != NULL) ? 1 : sizeof(events) / sizeof(events[0]);
  285. SDL_PumpEvents();
  286. while (1) {
  287. count = SDL_PeepEvents(events, maxcount, SDL_GETEVENT, mask);
  288. if (count <= 0)
  289. break;
  290. for (i = 0; i < count; i++) {
  291. if (state->joy)
  292. ret = handle_joy_event(state,
  293. &events[i], one_kc, one_down);
  294. else
  295. ret = handle_event(state,
  296. &events[i], one_kc, one_down);
  297. retval |= ret;
  298. if (one_kc != NULL && ret)
  299. goto out;
  300. }
  301. }
  302. out:
  303. return retval;
  304. }
  305. static int in_sdl_update(void *drv_data, const int *binds, int *result)
  306. {
  307. struct in_sdl_state *state = drv_data;
  308. keybits_t mask;
  309. int i, sym, bit, b;
  310. collect_events(state, NULL, NULL);
  311. for (i = 0; i < SDLK_LAST / KEYBITS_WORD_BITS + 1; i++) {
  312. mask = state->keystate[i];
  313. if (mask == 0)
  314. continue;
  315. for (bit = 0; mask != 0; bit++, mask >>= 1) {
  316. if ((mask & 1) == 0)
  317. continue;
  318. sym = i * KEYBITS_WORD_BITS + bit;
  319. for (b = 0; b < IN_BINDTYPE_COUNT; b++)
  320. result[b] |= binds[IN_BIND_OFFS(sym, b)];
  321. }
  322. }
  323. return 0;
  324. }
  325. static int in_sdl_update_keycode(void *drv_data, int *is_down)
  326. {
  327. struct in_sdl_state *state = drv_data;
  328. int ret_kc = -1, ret_down = 0;
  329. collect_events(state, &ret_kc, &ret_down);
  330. if (is_down != NULL)
  331. *is_down = ret_down;
  332. return ret_kc;
  333. }
  334. struct menu_keymap {
  335. short key;
  336. short pbtn;
  337. };
  338. static const struct menu_keymap key_pbtn_map[] =
  339. {
  340. { SDLK_UP, PBTN_UP },
  341. { SDLK_DOWN, PBTN_DOWN },
  342. { SDLK_LEFT, PBTN_LEFT },
  343. { SDLK_RIGHT, PBTN_RIGHT },
  344. /* XXX: maybe better set this from it's plat code somehow */
  345. { SDLK_RETURN, PBTN_MOK },
  346. { SDLK_ESCAPE, PBTN_MBACK },
  347. { SDLK_a, PBTN_MA2 },
  348. { SDLK_s, PBTN_MA3 },
  349. { SDLK_BACKSLASH, PBTN_MENU },
  350. { SDLK_LEFTBRACKET, PBTN_L },
  351. { SDLK_RIGHTBRACKET, PBTN_R },
  352. };
  353. #define KEY_PBTN_MAP_SIZE (sizeof(key_pbtn_map) / sizeof(key_pbtn_map[0]))
  354. static const struct menu_keymap joybtn_pbtn_map[] =
  355. {
  356. { SDLK_UP, PBTN_UP },
  357. { SDLK_DOWN, PBTN_DOWN },
  358. { SDLK_LEFT, PBTN_LEFT },
  359. { SDLK_RIGHT, PBTN_RIGHT },
  360. /* joystick */
  361. { SDLK_WORLD_0, PBTN_MOK },
  362. { SDLK_WORLD_1, PBTN_MBACK },
  363. { SDLK_WORLD_2, PBTN_MA2 },
  364. { SDLK_WORLD_3, PBTN_MA3 },
  365. };
  366. #define JOYBTN_PBTN_MAP_SIZE (sizeof(joybtn_pbtn_map) / sizeof(joybtn_pbtn_map[0]))
  367. static int in_sdl_menu_translate(void *drv_data, int keycode, char *charcode)
  368. {
  369. struct in_sdl_state *state = drv_data;
  370. const struct menu_keymap *map;
  371. int map_len;
  372. int ret = 0;
  373. int i;
  374. map = state->joy ? joybtn_pbtn_map : key_pbtn_map;
  375. map_len = state->joy ? JOYBTN_PBTN_MAP_SIZE : KEY_PBTN_MAP_SIZE;
  376. if (keycode < 0)
  377. {
  378. /* menu -> kc */
  379. keycode = -keycode;
  380. for (i = 0; i < map_len; i++)
  381. if (map[i].pbtn == keycode)
  382. return map[i].key;
  383. }
  384. else
  385. {
  386. for (i = 0; i < map_len; i++) {
  387. if (map[i].key == keycode) {
  388. ret = map[i].pbtn;
  389. break;
  390. }
  391. }
  392. if (charcode != NULL && (unsigned int)keycode < SDLK_LAST &&
  393. in_sdl_keys[keycode] != NULL && in_sdl_keys[keycode][1] == 0)
  394. {
  395. ret |= PBTN_CHAR;
  396. *charcode = in_sdl_keys[keycode][0];
  397. }
  398. }
  399. return ret;
  400. }
  401. static const in_drv_t in_sdl_drv = {
  402. .prefix = IN_SDL_PREFIX,
  403. .probe = in_sdl_probe,
  404. .free = in_sdl_free,
  405. .get_key_names = in_sdl_get_key_names,
  406. .update = in_sdl_update,
  407. .update_keycode = in_sdl_update_keycode,
  408. .menu_translate = in_sdl_menu_translate,
  409. };
  410. void in_sdl_init(const struct in_default_bind *defbinds)
  411. {
  412. in_register_driver(&in_sdl_drv, defbinds);
  413. }