typedef unsigned long keybits_t;
#define KEYBITS_WORD_BITS (sizeof(keybits_t) * 8)
+#ifndef ARRAY_SIZE
+#define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0]))
+#endif
+
struct in_sdl_state {
+ const in_drv_t *drv;
SDL_Joystick *joy;
int joy_id;
- int axis_keydown[2];
+ int joy_numaxes;
+ int joy_numbuttons;
+ int *joy_axis_keydown;
+ int joy_hat_down;
+ unsigned int joy_axis_as_btn; // bitmask; vs axes of centered sticks
+ unsigned int redraw:1;
+ unsigned int abs_to_udlr:1;
+ unsigned int hat_warned:1;
+ SDL_Event revent;
+ SDL_Event mevent; // last mouse event
keybits_t keystate[SDLK_LAST / KEYBITS_WORD_BITS + 1];
+ // emulator keys should always be processed immediately lest one is lost
+ keybits_t emu_keys[SDLK_LAST / KEYBITS_WORD_BITS + 1];
};
+static void (*ext_event_handler)(void *event);
+
static const char * const in_sdl_keys[SDLK_LAST] = {
[SDLK_BACKSPACE] = "backspace",
[SDLK_TAB] = "tab",
[SDLK_8] = "8",
[SDLK_9] = "9",
[SDLK_COLON] = ":",
- [SDLK_SEMICOLON] = ",",
+ [SDLK_SEMICOLON] = ";",
[SDLK_LESS] = "<",
[SDLK_EQUALS] = "=",
[SDLK_GREATER] = ">",
[SDLK_z] = "z",
[SDLK_DELETE] = "delete",
+ // gamepad buttons
+ #define B(x) [SDLK_WORLD_##x] = "b"#x
+ B(0), B(1), B(2), B(3), B(4), B(5), B(6), B(7),
+ B(8), B(9), B(10), B(11), B(12), B(13), B(14), B(15),
+ B(16), B(17), B(18), B(19), B(20), B(21), B(22), B(23),
+ B(24), B(25), B(26), B(27), B(28), B(29), B(30), B(31),
+ B(32), B(33), B(34), B(35), B(36), B(37), B(38), B(39),
+ #undef B
+
[SDLK_KP0] = "[0]",
[SDLK_KP1] = "[1]",
[SDLK_KP2] = "[2]",
[SDLK_DOWN] = "down",
[SDLK_RIGHT] = "right",
[SDLK_LEFT] = "left",
- [SDLK_DOWN] = "down",
[SDLK_INSERT] = "insert",
[SDLK_HOME] = "home",
[SDLK_END] = "end",
[SDLK_COMPOSE] = "compose",
};
-static void in_sdl_probe(void)
+static struct in_sdl_state *state_alloc(int joy_numaxes)
{
struct in_sdl_state *state;
- SDL_Joystick *joy;
- int i, joycount;
- char name[256];
state = calloc(1, sizeof(*state));
if (state == NULL) {
fprintf(stderr, "in_sdl: OOM\n");
- return;
+ return NULL;
+ }
+
+ if (joy_numaxes) {
+ state->abs_to_udlr = 1;
+ state->joy_numaxes = joy_numaxes;
+ state->joy_axis_keydown = malloc(joy_numaxes * sizeof(state->joy_axis_keydown[0]));
+ if (!state->joy_axis_keydown) {
+ free(state);
+ return NULL;
+ }
+ memset(state->joy_axis_keydown, 0xff, joy_numaxes * sizeof(state->joy_axis_keydown[0]));
}
+ return state;
+}
+static void in_sdl_probe(const in_drv_t *drv)
+{
+ const struct in_pdata *pdata = drv->pdata;
+ const char * const * key_names = in_sdl_keys;
+ struct in_sdl_state *state;
+ SDL_Joystick *joy;
+ int i, a, joycount;
+ char name[256];
+
+ if (pdata->key_names)
+ key_names = pdata->key_names;
+
+ if (!(state = state_alloc(0)))
+ return;
+
+ state->drv = drv;
in_register(IN_SDL_PREFIX "keys", -1, state, SDLK_LAST,
- in_sdl_keys, 0);
+ key_names, 0);
+ //SDL_EnableUNICODE(1);
/* joysticks go here too */
SDL_InitSubSystem(SDL_INIT_JOYSTICK);
if (joy == NULL)
continue;
- state = calloc(1, sizeof(*state));
- if (state == NULL) {
- fprintf(stderr, "in_sdl: OOM\n");
+ if (!(state = state_alloc(SDL_JoystickNumAxes(joy))))
break;
- }
state->joy = joy;
state->joy_id = i;
+ state->joy_numbuttons = SDL_JoystickNumButtons(joy);
+ state->drv = drv;
+ for (a = 0; a < state->joy_numaxes; a++)
+ if (SDL_JoystickGetAxis(joy, a) < -16384)
+ state->joy_axis_as_btn |= 1u << a;
snprintf(name, sizeof(name), IN_SDL_PREFIX "%s", SDL_JoystickName(i));
- in_register(name, -1, state, SDLK_LAST, in_sdl_keys, 0);
+ in_register(name, -1, state, SDLK_LAST, key_names, 0);
+
+ printf(" %s: %d buttons %d axes %d hat(s), "
+ "guessed axis_as_btn mask: %x\n",
+ name, state->joy_numbuttons, state->joy_numaxes,
+ SDL_JoystickNumHats(joy), state->joy_axis_as_btn);
}
if (joycount > 0)
if (state != NULL) {
if (state->joy != NULL)
SDL_JoystickClose(state->joy);
+ free(state->joy_axis_keydown);
free(state);
}
}
static const char * const *
-in_sdl_get_key_names(int *count)
+in_sdl_get_key_names(const in_drv_t *drv, int *count)
{
+ const struct in_pdata *pdata = drv->pdata;
*count = SDLK_LAST;
+
+ if (pdata->key_names)
+ return pdata->key_names;
return in_sdl_keys;
}
*ks_word &= ~mask;
}
+static int get_keystate(keybits_t *keystate, int sym)
+{
+ keybits_t *ks_word, mask;
+
+ mask = 1;
+ mask <<= sym & (KEYBITS_WORD_BITS - 1);
+ ks_word = keystate + sym / KEYBITS_WORD_BITS;
+ return !!(*ks_word & mask);
+}
+
static int handle_event(struct in_sdl_state *state, SDL_Event *event,
- int *kc_out, int *down_out)
+ int *kc_out, int *down_out, int *emu_out)
{
+ int emu;
+
if (event->type != SDL_KEYDOWN && event->type != SDL_KEYUP)
- return 0;
+ return -1;
+ emu = get_keystate(state->emu_keys, event->key.keysym.sym);
update_keystate(state->keystate, event->key.keysym.sym,
event->type == SDL_KEYDOWN);
if (kc_out != NULL)
*kc_out = event->key.keysym.sym;
if (down_out != NULL)
*down_out = event->type == SDL_KEYDOWN;
+ if (emu_out != NULL)
+ *emu_out = emu;
return 1;
}
static int handle_joy_event(struct in_sdl_state *state, SDL_Event *event,
- int *kc_out, int *down_out)
+ int *kc_out, int *down_out, int *emu_out)
{
- int kc = -1, down = 0, ret = 0;
+ static const int hat2uldr[4] = { SDLK_UP, SDLK_RIGHT, SDLK_DOWN, SDLK_LEFT };
+ int kc = -1, kc_prev = -1, down = 0, emu = 0, ret = 0, i, val, xor;
+ int kc_button_base = SDLK_WORLD_0;
+ int kc_axis_base = kc_button_base + state->joy_numbuttons;
+ int kc_hat_base = kc_axis_base + state->joy_numaxes;
- /* FIXME: should ckeck .which */
- /* TODO: remaining axis */
switch (event->type) {
case SDL_JOYAXISMOTION:
- if (event->jaxis.axis > 1)
- break;
- if (-16384 <= event->jaxis.value && event->jaxis.value <= 16384) {
- kc = state->axis_keydown[event->jaxis.axis];
- state->axis_keydown[event->jaxis.axis] = 0;
- ret = 1;
- }
- else if (event->jaxis.value < -16384) {
- kc = state->axis_keydown[event->jaxis.axis];
- if (kc)
- update_keystate(state->keystate, kc, 0);
- kc = event->jaxis.axis ? SDLK_UP : SDLK_LEFT;
- state->axis_keydown[event->jaxis.axis] = kc;
+ if ((unsigned)event->jaxis.axis >= (unsigned)state->joy_numaxes)
+ return 1;
+ if (event->jaxis.which != state->joy_id)
+ return -2;
+ if (event->jaxis.value < -16384) {
+ if (state->abs_to_udlr && event->jaxis.axis < 2)
+ kc = event->jaxis.axis ? SDLK_UP : SDLK_LEFT;
+ // some pressure sensitive buttons appear as an axis that goes
+ // from -32768 (released) to 32767 (pressed) and there is no
+ // way to distinguish from ones centered at 0? :(
+ else if (!(state->joy_axis_as_btn & (1u << event->jaxis.axis)))
+ kc = kc_axis_base + event->jaxis.axis * 2;
down = 1;
- ret = 1;
}
else if (event->jaxis.value > 16384) {
- kc = state->axis_keydown[event->jaxis.axis];
- if (kc)
- update_keystate(state->keystate, kc, 0);
- kc = event->jaxis.axis ? SDLK_DOWN : SDLK_RIGHT;
- state->axis_keydown[event->jaxis.axis] = kc;
+ if (state->abs_to_udlr && event->jaxis.axis < 2)
+ kc = event->jaxis.axis ? SDLK_DOWN : SDLK_RIGHT;
+ else
+ kc = kc_axis_base + event->jaxis.axis * 2 + 1;
down = 1;
- ret = 1;
}
+ kc_prev = state->joy_axis_keydown[event->jaxis.axis];
+ state->joy_axis_keydown[event->jaxis.axis] = kc;
+ if (kc == kc_prev)
+ return -1; // no simulated key change
+ if (kc >= 0 && kc_prev >= 0) {
+ // must release the old key first
+ state->joy_axis_keydown[event->jaxis.axis] = -1;
+ kc = kc_prev;
+ down = 0;
+ }
+ else if (kc_prev >= 0)
+ kc = kc_prev;
+ ret = 1;
break;
case SDL_JOYBUTTONDOWN:
case SDL_JOYBUTTONUP:
- kc = (int)event->jbutton.button + SDLK_WORLD_0;
+ if (event->jbutton.which != state->joy_id)
+ return -2;
+ kc = kc_button_base + (int)event->jbutton.button;
down = event->jbutton.state == SDL_PRESSED;
ret = 1;
break;
+ case SDL_JOYHATMOTION:
+ if (event->jhat.which != state->joy_id)
+ return -2;
+ xor = event->jhat.value ^ state->joy_hat_down;
+ val = state->joy_hat_down = event->jhat.value;
+ for (i = 0; i < 4; i++, xor >>= 1, val >>= 1) {
+ if (xor & 1) {
+ if (event->jhat.hat)
+ kc = kc_hat_base + event->jhat.hat * 4 + i;
+ else
+ kc = hat2uldr[i];
+ down = val & 1;
+ ret = 1;
+ break;
+ }
+ }
+ if ((!ret || (xor >> ret)) && !state->hat_warned) {
+ // none, more than 1, or upper bits changed
+ fprintf(stderr, "in_sdl: unexpected hat behavior\n");
+ state->hat_warned = 1;
+ }
+ break;
+ default:
+ //printf("joy ev %d\n", event->type);
+ return -1;
}
- if (ret)
+ if (ret) {
+ emu |= get_keystate(state->emu_keys, kc);
update_keystate(state->keystate, kc, down);
+ }
if (kc_out != NULL)
*kc_out = kc;
if (down_out != NULL)
*down_out = down;
+ if (emu_out != 0)
+ *emu_out = emu;
return ret;
}
static int collect_events(struct in_sdl_state *state, int *one_kc, int *one_down)
{
- SDL_Event events[4];
+ SDL_Event events[8];
Uint32 mask = state->joy ? JOY_EVENTS : (SDL_ALLEVENTS & ~JOY_EVENTS);
- int count, maxcount;
- int i, ret, retval = 0;
-
- maxcount = (one_kc != NULL) ? 1 : sizeof(events) / sizeof(events[0]);
+ int count, maxcount, is_emukey = 0;
+ int i = 0, ret = 0, retval = 0;
+ SDL_Event *event;
SDL_PumpEvents();
- while (1) {
- count = SDL_PeepEvents(events, maxcount, SDL_GETEVENT, mask);
- if (count <= 0)
- break;
+
+ maxcount = ARRAY_SIZE(events);
+ if ((count = SDL_PeepEvents(events, maxcount, SDL_GETEVENT, mask)) > 0) {
for (i = 0; i < count; i++) {
- if (state->joy)
+ event = &events[i];
+ if (state->joy) {
ret = handle_joy_event(state,
- &events[i], one_kc, one_down);
- else
+ event, one_kc, one_down, &is_emukey);
+ } else {
ret = handle_event(state,
- &events[i], one_kc, one_down);
+ event, one_kc, one_down, &is_emukey);
+ }
+ if (ret < 0) {
+ switch (ret) {
+ case -2:
+ SDL_PushEvent(event);
+ break;
+ default:
+ if (event->type == SDL_VIDEORESIZE) {
+ state->redraw = 1;
+ state->revent = *event;
+ } else if (event->type == SDL_VIDEOEXPOSE) {
+ if (state->revent.type == SDL_NOEVENT) {
+ state->redraw = 1;
+ state->revent.type = SDL_VIDEOEXPOSE;
+ }
+ } else
+ if ((event->type == SDL_MOUSEBUTTONDOWN) ||
+ (event->type == SDL_MOUSEBUTTONUP)) {
+ int mask = SDL_BUTTON(event->button.button);
+ if (event->button.state == SDL_PRESSED)
+ state->mevent.motion.state |= mask;
+ else state->mevent.motion.state &= ~mask;
+ } else if (event->type == SDL_MOUSEMOTION) {
+ event->motion.xrel += state->mevent.motion.xrel;
+ event->motion.yrel += state->mevent.motion.yrel;
+ state->mevent = *event;
+ }
+ else if (ext_event_handler != NULL)
+ ext_event_handler(event);
+ break;
+ }
+ continue;
+ }
+
retval |= ret;
- if (one_kc != NULL && ret)
- goto out;
+ if ((is_emukey || one_kc != NULL) && retval)
+ {
+ break;
+ }
}
}
-out:
+ // if the event queue has been emptied and resize/expose events were in it
+ if (state->redraw && count == 0) {
+ if (ext_event_handler != NULL)
+ ext_event_handler(&state->revent);
+ state->redraw = 0;
+ state->revent.type = SDL_NOEVENT;
+ // dummy key event to force returning from the key loop,
+ // so the application has a chance to redraw the window
+ if (one_kc != NULL) {
+ *one_kc = SDLK_UNKNOWN;
+ retval |= 1;
+ }
+ if (one_down != NULL)
+ *one_down = 1;
+ } else
+ i++;
+ // don't lose events other devices might want to handle
+ if (i < count)
+ SDL_PeepEvents(events+i, count-i, SDL_ADDEVENT, mask);
return retval;
}
return 0;
}
+static int in_sdl_update_kbd(void *drv_data, const int *binds, int *result)
+{
+ struct in_sdl_state *state = drv_data;
+ keybits_t mask;
+ int i, sym, bit, b = 0;
+
+ collect_events(state, NULL, NULL);
+
+ for (i = 0; i < SDLK_LAST / KEYBITS_WORD_BITS + 1; i++) {
+ mask = state->keystate[i];
+ if (mask == 0)
+ continue;
+ for (bit = 0; mask != 0; bit++, mask >>= 1) {
+ if ((mask & 1) == 0)
+ continue;
+ sym = i * KEYBITS_WORD_BITS + bit;
+ result[b++] = binds[sym];
+ }
+ }
+
+ return b;
+}
+
+static int in_sdl_update_analog(void *drv_data, int axis_id, int *result)
+{
+ struct in_sdl_state *state = drv_data;
+ int v;
+
+ if (!state || !state->joy || !result)
+ return -1;
+ if ((unsigned)axis_id >= (unsigned)state->joy_numaxes)
+ return -1;
+
+ v = SDL_JoystickGetAxis(state->joy, axis_id);
+
+ // -32768...32767 -> -IN_ABS_RANGE...IN_ABS_RANGE
+ *result = (v + ((v >> 31) | 1)) / (32768 / IN_ABS_RANGE);
+ return 0;
+}
+
+static int in_sdl_update_pointer(void *drv_data, int id, int *result)
+{
+ struct in_sdl_state *state = drv_data;
+ int max;
+
+ *result = 0;
+
+ switch (id) {
+ // absolute position, clipped at the window/screen border
+ case 0: if ((max = state->revent.resize.w))
+ *result = state->mevent.motion.x * 2*1024/max - 1024;
+ break;
+ case 1: if ((max = state->revent.resize.h))
+ *result = state->mevent.motion.y * 2*1024/max - 1024;
+ break;
+ // relative mouse movements since last query
+ case 2: if ((max = state->revent.resize.w))
+ *result = state->mevent.motion.xrel * 2*1024/max;
+ state->mevent.motion.xrel = 0;
+ break;
+ case 3: if ((max = state->revent.resize.h))
+ *result = state->mevent.motion.yrel * 2*1024/max;
+ state->mevent.motion.yrel = 0;
+ break;
+ // buttons
+ case -1: *result = state->mevent.motion.state;
+ break;
+ default: return -1;
+ }
+
+ return 0;
+}
+
static int in_sdl_update_keycode(void *drv_data, int *is_down)
{
struct in_sdl_state *state = drv_data;
return ret_kc;
}
-struct menu_keymap {
- short key;
- short pbtn;
-};
-
-static const struct menu_keymap key_pbtn_map[] =
-{
- { SDLK_UP, PBTN_UP },
- { SDLK_DOWN, PBTN_DOWN },
- { SDLK_LEFT, PBTN_LEFT },
- { SDLK_RIGHT, PBTN_RIGHT },
- /* XXX: maybe better set this from it's plat code somehow */
- { SDLK_RETURN, PBTN_MOK },
- { SDLK_ESCAPE, PBTN_MBACK },
- { SDLK_a, PBTN_MA2 },
- { SDLK_s, PBTN_MA3 },
- { SDLK_BACKSLASH, PBTN_MENU },
- { SDLK_LEFTBRACKET, PBTN_L },
- { SDLK_RIGHTBRACKET, PBTN_R },
-};
-#define KEY_PBTN_MAP_SIZE (sizeof(key_pbtn_map) / sizeof(key_pbtn_map[0]))
-
-static const struct menu_keymap joybtn_pbtn_map[] =
-{
- { SDLK_UP, PBTN_UP },
- { SDLK_DOWN, PBTN_DOWN },
- { SDLK_LEFT, PBTN_LEFT },
- { SDLK_RIGHT, PBTN_RIGHT },
- /* joystick */
- { SDLK_WORLD_0, PBTN_MOK },
- { SDLK_WORLD_1, PBTN_MBACK },
- { SDLK_WORLD_2, PBTN_MA2 },
- { SDLK_WORLD_3, PBTN_MA3 },
-};
-#define JOYBTN_PBTN_MAP_SIZE (sizeof(joybtn_pbtn_map) / sizeof(joybtn_pbtn_map[0]))
-
static int in_sdl_menu_translate(void *drv_data, int keycode, char *charcode)
{
struct in_sdl_state *state = drv_data;
+ const struct in_pdata *pdata = state->drv->pdata;
+ const char * const * key_names = in_sdl_keys;
const struct menu_keymap *map;
int map_len;
int ret = 0;
int i;
- map = state->joy ? joybtn_pbtn_map : key_pbtn_map;
- map_len = state->joy ? JOYBTN_PBTN_MAP_SIZE : KEY_PBTN_MAP_SIZE;
+ if (pdata->key_names)
+ key_names = pdata->key_names;
+
+ if (state->joy) {
+ map = pdata->joy_map;
+ map_len = pdata->jmap_size;
+ } else {
+ map = pdata->key_map;
+ map_len = pdata->kmap_size;
+ }
if (keycode < 0)
{
}
else
{
+ if (keycode == SDLK_UNKNOWN)
+ ret = PBTN_RDRAW;
+ else
for (i = 0; i < map_len; i++) {
if (map[i].key == keycode) {
ret = map[i].pbtn;
}
if (charcode != NULL && (unsigned int)keycode < SDLK_LAST &&
- in_sdl_keys[keycode] != NULL && in_sdl_keys[keycode][1] == 0)
+ key_names[keycode] != NULL && key_names[keycode][1] == 0)
{
ret |= PBTN_CHAR;
- *charcode = in_sdl_keys[keycode][0];
+ *charcode = key_names[keycode][0];
}
}
return ret;
}
+static int in_sdl_clean_binds(void *drv_data, int *binds, int *def_binds)
+{
+ struct in_sdl_state *state = drv_data;
+ int i, t, cnt = 0;
+
+ memset(state->emu_keys, 0, sizeof(state->emu_keys));
+ for (t = 0; t < IN_BINDTYPE_COUNT; t++) {
+ for (i = 0; i < SDLK_LAST; i++) {
+ int offs = IN_BIND_OFFS(i, t);
+ if (state->joy && i < SDLK_WORLD_0)
+ binds[offs] = def_binds[offs] = 0;
+ if (binds[offs]) {
+ if (t == IN_BINDTYPE_EMU)
+ update_keystate(state->emu_keys, i, 1);
+ cnt ++;
+ }
+ }
+ }
+
+ return cnt;
+}
+
+static int in_sdl_get_config(void *drv_data, enum in_cfg_opt what, int *val)
+{
+ struct in_sdl_state *state = drv_data;
+
+ switch (what) {
+ case IN_CFG_ABS_AXIS_COUNT:
+ *val = state->joy_numaxes;
+ break;
+ case IN_CFG_ANALOG_MAP_ULDR:
+ *val = state->abs_to_udlr;
+ break;
+ default:
+ return -1;
+ }
+
+ return 0;
+}
+
+static int in_sdl_set_config(void *drv_data, enum in_cfg_opt what, int val)
+{
+ struct in_sdl_state *state = drv_data;
+ size_t i;
+
+ switch (what) {
+ case IN_CFG_ANALOG_MAP_ULDR:
+ state->abs_to_udlr = val ? 1 : 0;
+ for (i = 0; !val && i < state->joy_numaxes; i++) {
+ if (state->joy_axis_keydown[i] < 0)
+ continue;
+ update_keystate(state->keystate, state->joy_axis_keydown[i], 0);
+ state->joy_axis_keydown[i] = -1;
+ }
+ break;
+ default:
+ return -1;
+ }
+
+ return 0;
+}
+
static const in_drv_t in_sdl_drv = {
- .prefix = IN_SDL_PREFIX,
- .probe = in_sdl_probe,
- .free = in_sdl_free,
- .get_key_names = in_sdl_get_key_names,
- .update = in_sdl_update,
- .update_keycode = in_sdl_update_keycode,
- .menu_translate = in_sdl_menu_translate,
+ .prefix = IN_SDL_PREFIX,
+ .probe = in_sdl_probe,
+ .free = in_sdl_free,
+ .get_key_names = in_sdl_get_key_names,
+ .update = in_sdl_update,
+ .update_kbd = in_sdl_update_kbd,
+ .update_analog = in_sdl_update_analog,
+ .update_pointer = in_sdl_update_pointer,
+ .update_keycode = in_sdl_update_keycode,
+ .menu_translate = in_sdl_menu_translate,
+ .clean_binds = in_sdl_clean_binds,
+ .get_config = in_sdl_get_config,
+ .set_config = in_sdl_set_config,
};
-void in_sdl_init(const struct in_default_bind *defbinds)
+int in_sdl_init(const struct in_pdata *pdata, void (*handler)(void *event))
{
- in_register_driver(&in_sdl_drv, defbinds);
-}
+ if (!pdata) {
+ fprintf(stderr, "in_sdl: Missing input platform data\n");
+ return -1;
+ }
+ in_register_driver(&in_sdl_drv, pdata->defbinds, pdata->kbd_map, pdata);
+ ext_event_handler = handler;
+ return 0;
+}
notaz.gp2x.de / libpicofe.git / blobdiff