Mercurial > repos > blastem
view bindings.c @ 1850:30f2821ffd65
Allow rom directory and rom name in screenshot path. Allow rom name in screenshot name. Remove ability for path variables to contain underscores
author | Michael Pavone <pavone@retrodev.com> |
---|---|
date | Tue, 23 Apr 2019 23:33:16 -0700 |
parents | 78abbabfd58d |
children | 508522f08e4d |
line wrap: on
line source
#include <string.h> #include <stdlib.h> #include "render.h" #include "system.h" #include "io.h" #include "blastem.h" #include "saves.h" #include "util.h" #include "genesis.h" #include "sms.h" #include "menu.h" #include "bindings.h" #include "controller_info.h" #ifndef DISABLE_NUKLEAR #include "nuklear_ui/blastem_nuklear.h" #endif enum { BIND_NONE, BIND_UI, BIND_GAMEPAD, BIND_MOUSE }; typedef enum { UI_DEBUG_MODE_INC, UI_ENTER_DEBUGGER, UI_SAVE_STATE, UI_SET_SPEED, UI_NEXT_SPEED, UI_PREV_SPEED, UI_RELEASE_MOUSE, UI_TOGGLE_KEYBOARD_CAPTURE, UI_TOGGLE_FULLSCREEN, UI_SOFT_RESET, UI_RELOAD, UI_SMS_PAUSE, UI_SCREENSHOT, UI_EXIT, UI_PLANE_DEBUG, UI_VRAM_DEBUG, UI_CRAM_DEBUG, UI_COMPOSITE_DEBUG } ui_action; typedef struct { uint8_t bind_type; uint8_t subtype_a; uint8_t subtype_b; } keybinding; typedef struct { keybinding bindings[4]; uint8_t state; } joydpad; typedef struct { keybinding positive; keybinding negative; int16_t value; } joyaxis; typedef struct { keybinding *buttons; joydpad *dpads; joyaxis *axes; uint32_t num_buttons; //number of entries in the buttons array, not necessarily the number of buttons on the device uint32_t num_dpads; //number of entries in the dpads array, not necessarily the number of dpads on the device uint32_t num_axes; //number of entries in the axes array, not necessarily the number of dpads on the device } joystick; typedef struct { keybinding buttons[MAX_MOUSE_BUTTONS]; keybinding motion; } mousebinding; #define DEFAULT_JOYBUTTON_ALLOC 12 static keybinding *bindings[0x10000]; static joystick joysticks[MAX_JOYSTICKS]; static mousebinding mice[MAX_MICE]; const uint8_t dpadbits[] = {RENDER_DPAD_UP, RENDER_DPAD_DOWN, RENDER_DPAD_LEFT, RENDER_DPAD_RIGHT}; static void do_bind(keybinding *binding, uint8_t bind_type, uint8_t subtype_a, uint8_t subtype_b) { binding->bind_type = bind_type; binding->subtype_a = subtype_a; binding->subtype_b = subtype_b; } void bind_key(int keycode, uint8_t bind_type, uint8_t subtype_a, uint8_t subtype_b) { int bucket = keycode >> 15 & 0xFFFF; if (!bindings[bucket]) { bindings[bucket] = malloc(sizeof(keybinding) * 0x8000); memset(bindings[bucket], 0, sizeof(keybinding) * 0x8000); } int idx = keycode & 0x7FFF; do_bind(bindings[bucket] + idx, bind_type, subtype_a, subtype_b); } void bind_button(int joystick, int button, uint8_t bind_type, uint8_t subtype_a, uint8_t subtype_b) { if (joystick >= MAX_JOYSTICKS) { return; } if (!joysticks[joystick].buttons) { joysticks[joystick].num_buttons = button < DEFAULT_JOYBUTTON_ALLOC ? DEFAULT_JOYBUTTON_ALLOC : button + 1; joysticks[joystick].buttons = calloc(joysticks[joystick].num_buttons, sizeof(keybinding)); } else if (joysticks[joystick].num_buttons <= button) { uint32_t old_capacity = joysticks[joystick].num_buttons; joysticks[joystick].num_buttons *= 2; joysticks[joystick].buttons = realloc(joysticks[joystick].buttons, sizeof(keybinding) * joysticks[joystick].num_buttons); memset(joysticks[joystick].buttons + old_capacity, 0, joysticks[joystick].num_buttons - old_capacity); } do_bind(joysticks[joystick].buttons + button, bind_type, subtype_a, subtype_b); } void bind_dpad(int joystick, int dpad, int direction, uint8_t bind_type, uint8_t subtype_a, uint8_t subtype_b) { if (joystick >= MAX_JOYSTICKS) { return; } if (!joysticks[joystick].dpads) { //multiple D-pads/hats are not common, so don't allocate any extra space joysticks[joystick].dpads = calloc(dpad+1, sizeof(joydpad)); joysticks[joystick].num_dpads = dpad+1; } else if (joysticks[joystick].num_dpads <= dpad) { uint32_t old_capacity = joysticks[joystick].num_dpads; joysticks[joystick].num_dpads *= 2; joysticks[joystick].dpads = realloc(joysticks[joystick].dpads, sizeof(joydpad) * joysticks[joystick].num_dpads); memset(joysticks[joystick].dpads + old_capacity, 0, (joysticks[joystick].num_dpads - old_capacity) * sizeof(joydpad)); } for (int i = 0; i < 4; i ++) { if (dpadbits[i] & direction) { do_bind(joysticks[joystick].dpads[dpad].bindings + i, bind_type, subtype_a, subtype_b); break; } } } void bind_axis(int joystick, int axis, int positive, uint8_t bind_type, uint8_t subtype_a, uint8_t subtype_b) { if (joystick >= MAX_JOYSTICKS) { return; } if (!joysticks[joystick].axes) { //typical gamepad has 4 axes joysticks[joystick].num_axes = axis+1 > 4 ? axis+1 : 4; joysticks[joystick].axes = calloc(joysticks[joystick].num_axes, sizeof(joyaxis)); } else if (joysticks[joystick].num_axes <= axis) { uint32_t old_capacity = joysticks[joystick].num_axes; joysticks[joystick].num_axes *= 2; joysticks[joystick].axes = realloc(joysticks[joystick].axes, sizeof(joyaxis) * joysticks[joystick].num_axes); memset(joysticks[joystick].axes + old_capacity, 0, (joysticks[joystick].num_axes - old_capacity) * sizeof(joyaxis)); } if (positive) { do_bind(&joysticks[joystick].axes[axis].positive, bind_type, subtype_a, subtype_b); } else { do_bind(&joysticks[joystick].axes[axis].negative, bind_type, subtype_a, subtype_b); } } void reset_joystick_bindings(int joystick) { if (joystick >= MAX_JOYSTICKS) { return; } if (joysticks[joystick].buttons) { for (int i = 0; i < joysticks[joystick].num_buttons; i++) { joysticks[joystick].buttons[i].bind_type = BIND_NONE; } } if (joysticks[joystick].dpads) { for (int i = 0; i < joysticks[joystick].num_dpads; i++) { for (int dir = 0; dir < 4; dir++) { joysticks[joystick].dpads[i].bindings[dir].bind_type = BIND_NONE; } } } if (joysticks[joystick].axes) { for (int i = 0; i < joysticks[joystick].num_axes; i++) { joysticks[joystick].axes[i].positive.bind_type = BIND_NONE; joysticks[joystick].axes[i].negative.bind_type = BIND_NONE; } } } static uint8_t content_binds_enabled = 1; void set_content_binding_state(uint8_t enabled) { content_binds_enabled = enabled; } void handle_binding_down(keybinding * binding) { if (!current_system) { return; } if (binding->bind_type == BIND_GAMEPAD && current_system && current_system->gamepad_down) { current_system->gamepad_down(current_system, binding->subtype_a, binding->subtype_b); } else if (binding->bind_type == BIND_MOUSE && current_system && current_system->mouse_down) { current_system->mouse_down(current_system, binding->subtype_a, binding->subtype_b); } } static uint8_t keyboard_captured; void handle_keydown(int keycode, uint8_t scancode) { int bucket = keycode >> 15 & 0xFFFF; int idx = keycode & 0x7FFF; keybinding * binding = bindings[bucket] ? bindings[bucket] + idx : NULL; if (binding && (!keyboard_captured || (binding->bind_type == BIND_UI && binding->subtype_a == UI_TOGGLE_KEYBOARD_CAPTURE))) { handle_binding_down(binding); } else if (keyboard_captured && current_system && current_system->keyboard_down) { current_system->keyboard_down(current_system, scancode); } } void handle_joydown(int joystick, int button) { if (joystick >= MAX_JOYSTICKS || button >= joysticks[joystick].num_buttons) { return; } keybinding * binding = joysticks[joystick].buttons + button; handle_binding_down(binding); } static uint8_t mouse_mode = MOUSE_NONE; static uint8_t mouse_captured; void handle_mousedown(int mouse, int button) { if (mouse_mode == MOUSE_CAPTURE && !mouse_captured) { mouse_captured = 1; render_relative_mouse(1); return; } if (mouse >= MAX_MICE || button > MAX_MOUSE_BUTTONS || button <= 0) { return; } keybinding * binding = mice[mouse].buttons + button - 1; handle_binding_down(binding); } static int current_speed = 0; static int num_speeds = 1; static uint32_t * speeds = NULL; static uint8_t mouse_captured; #ifdef _WIN32 #define localtime_r(a,b) localtime(a) #endif void handle_binding_up(keybinding * binding) { uint8_t allow_content_binds = content_binds_enabled && current_system; switch(binding->bind_type) { case BIND_GAMEPAD: if (allow_content_binds && current_system->gamepad_up) { current_system->gamepad_up(current_system, binding->subtype_a, binding->subtype_b); } break; case BIND_MOUSE: if (allow_content_binds && current_system->mouse_up) { current_system->mouse_up(current_system, binding->subtype_a, binding->subtype_b); } break; case BIND_UI: switch (binding->subtype_a) { case UI_DEBUG_MODE_INC: if (allow_content_binds) { current_system->inc_debug_mode(current_system); } break; case UI_ENTER_DEBUGGER: if (allow_content_binds) { current_system->enter_debugger = 1; } break; case UI_SAVE_STATE: if (allow_content_binds) { current_system->save_state = QUICK_SAVE_SLOT+1; } break; case UI_NEXT_SPEED: if (allow_content_binds) { current_speed++; if (current_speed >= num_speeds) { current_speed = 0; } printf("Setting speed to %d: %d\n", current_speed, speeds[current_speed]); current_system->set_speed_percent(current_system, speeds[current_speed]); } break; case UI_PREV_SPEED: if (allow_content_binds) { current_speed--; if (current_speed < 0) { current_speed = num_speeds - 1; } printf("Setting speed to %d: %d\n", current_speed, speeds[current_speed]); current_system->set_speed_percent(current_system, speeds[current_speed]); } break; case UI_SET_SPEED: if (allow_content_binds) { if (binding->subtype_b < num_speeds) { current_speed = binding->subtype_b; printf("Setting speed to %d: %d\n", current_speed, speeds[current_speed]); current_system->set_speed_percent(current_system, speeds[current_speed]); } else { printf("Setting speed to %d\n", speeds[current_speed]); current_system->set_speed_percent(current_system, speeds[current_speed]); } } break; case UI_RELEASE_MOUSE: if (mouse_captured) { mouse_captured = 0; render_relative_mouse(0); } break; case UI_TOGGLE_KEYBOARD_CAPTURE: if (allow_content_binds && current_system->has_keyboard) { keyboard_captured = !keyboard_captured; } break; case UI_TOGGLE_FULLSCREEN: render_toggle_fullscreen(); break; case UI_SOFT_RESET: if (allow_content_binds) { current_system->soft_reset(current_system); } break; case UI_RELOAD: if (allow_content_binds) { reload_media(); } break; case UI_SMS_PAUSE: if (allow_content_binds && current_system->gamepad_down) { current_system->gamepad_down(current_system, GAMEPAD_MAIN_UNIT, MAIN_UNIT_PAUSE); } break; case UI_SCREENSHOT: { if (allow_content_binds) { char *screenshot_base = tern_find_path(config, "ui\0screenshot_path\0", TVAL_PTR).ptrval; if (!screenshot_base) { screenshot_base = "$HOME"; } const system_media *media = current_media(); tern_node *vars = tern_insert_ptr(NULL, "HOME", get_home_dir()); vars = tern_insert_ptr(vars, "EXEDIR", get_exe_dir()); vars = tern_insert_ptr(vars, "USERDATA", (char *)get_userdata_dir()); vars = tern_insert_ptr(vars, "ROMNAME", media->name); vars = tern_insert_ptr(vars, "ROMDIR", media->dir); screenshot_base = replace_vars(screenshot_base, vars, 1); tern_free(vars); ensure_dir_exists(screenshot_base); time_t now = time(NULL); struct tm local_store; char fname_part[256]; char *template = tern_find_path(config, "ui\0screenshot_template\0", TVAL_PTR).ptrval; if (template) { vars = tern_insert_ptr(NULL, "ROMNAME", media->name); template = replace_vars(template, vars, 0); } else { template = strdup("blastem_%c.ppm"); } strftime(fname_part, sizeof(fname_part), template, localtime_r(&now, &local_store)); char const *parts[] = {screenshot_base, PATH_SEP, fname_part}; char *path = alloc_concat_m(3, parts); free(screenshot_base); free(template); render_save_screenshot(path); } break; } case UI_EXIT: #ifndef DISABLE_NUKLEAR if (is_nuklear_active()) { show_pause_menu(); } else { #endif current_system->request_exit(current_system); if (current_system->type == SYSTEM_GENESIS) { genesis_context *gen = (genesis_context *)current_system; if (gen->extra) { //TODO: More robust mechanism for detecting menu menu_context *menu = gen->extra; menu->external_game_load = 1; } } #ifndef DISABLE_NUKLEAR } #endif break; case UI_PLANE_DEBUG: case UI_VRAM_DEBUG: case UI_CRAM_DEBUG: case UI_COMPOSITE_DEBUG: if (allow_content_binds) { vdp_context *vdp = NULL; if (current_system->type == SYSTEM_GENESIS) { genesis_context *gen = (genesis_context *)current_system; vdp = gen->vdp; } else if (current_system->type == SYSTEM_SMS) { sms_context *sms = (sms_context *)current_system; vdp = sms->vdp; } if (vdp) { uint8_t debug_type; switch(binding->subtype_a) { case UI_PLANE_DEBUG: debug_type = VDP_DEBUG_PLANE; break; case UI_VRAM_DEBUG: debug_type = VDP_DEBUG_VRAM; break; case UI_CRAM_DEBUG: debug_type = VDP_DEBUG_CRAM; break; case UI_COMPOSITE_DEBUG: debug_type = VDP_DEBUG_COMPOSITE; break; default: return; } vdp_toggle_debug_view(vdp, debug_type); } break; } } break; } } void handle_keyup(int keycode, uint8_t scancode) { int bucket = keycode >> 15 & 0xFFFF; int idx = keycode & 0x7FFF; keybinding * binding = bindings[bucket] ? bindings[bucket] + idx : NULL; if (binding && (!keyboard_captured || (binding->bind_type == BIND_UI && binding->subtype_a == UI_TOGGLE_KEYBOARD_CAPTURE))) { handle_binding_up(binding); } else if (keyboard_captured && current_system && current_system->keyboard_up) { current_system->keyboard_up(current_system, scancode); } } void handle_joyup(int joystick, int button) { if (joystick >= MAX_JOYSTICKS || button >= joysticks[joystick].num_buttons) { return; } keybinding * binding = joysticks[joystick].buttons + button; handle_binding_up(binding); } void handle_joy_dpad(int joystick, int dpadnum, uint8_t value) { if (joystick >= MAX_JOYSTICKS || dpadnum >= joysticks[joystick].num_dpads) { return; } joydpad * dpad = joysticks[joystick].dpads + dpadnum; uint8_t newdown = (value ^ dpad->state) & value; uint8_t newup = ((~value) ^ (~dpad->state)) & (~value); dpad->state = value; for (int i = 0; i < 4; i++) { if (newdown & dpadbits[i]) { handle_binding_down(dpad->bindings + i); } else if(newup & dpadbits[i]) { handle_binding_up(dpad->bindings + i); } } } #define JOY_AXIS_THRESHOLD 2000 void handle_joy_axis(int joystick, int axis, int16_t value) { if (joystick >= MAX_JOYSTICKS || axis >= joysticks[joystick].num_axes) { return; } joyaxis *jaxis = joysticks[joystick].axes + axis; int old_active = abs(jaxis->value) > JOY_AXIS_THRESHOLD; int new_active = abs(value) > JOY_AXIS_THRESHOLD; int old_pos = jaxis->value > 0; int new_pos = value > 0; jaxis->value = value; if (old_active && (!new_active || old_pos != new_pos)) { //previously activated direction is no longer active handle_binding_up(old_pos ? &jaxis->positive : &jaxis->negative); } if (new_active && (!old_active || old_pos != new_pos)) { //previously unactivated direction is now active handle_binding_down(new_pos ? &jaxis->positive : &jaxis->negative); } } void handle_mouse_moved(int mouse, uint16_t x, uint16_t y, int16_t deltax, int16_t deltay) { if (mouse >= MAX_MICE || !current_system) { return; } if (mice[mouse].motion.bind_type == BIND_MOUSE && mice[mouse].motion.subtype_b == PSEUDO_BUTTON_MOTION) { uint8_t target_mouse = mice[mouse].motion.subtype_a; switch(mouse_mode) { case MOUSE_NONE: break; case MOUSE_ABSOLUTE: { if (current_system->mouse_motion_absolute) { float scale_x = (render_emulated_width() * 2.0f) / ((float)render_width()); float scale_y = (render_emulated_height() * 2.0f) / ((float)render_height()); int32_t adj_x = x * scale_x + 2 * render_overscan_left() - 2 * BORDER_LEFT; int32_t adj_y = y * scale_y + 2 * render_overscan_top() - 4; current_system->mouse_motion_absolute(current_system, target_mouse, adj_x, adj_y); } break; } case MOUSE_RELATIVE: { if (current_system->mouse_motion_relative) { current_system->mouse_motion_relative(current_system, target_mouse, deltax, deltay); } break; } case MOUSE_CAPTURE: { if (mouse_captured && current_system->mouse_motion_relative) { current_system->mouse_motion_relative(current_system, target_mouse, deltax, deltay); } break; } } } else { handle_binding_up(&mice[mouse].motion); } } void handle_mouseup(int mouse, int button) { if (mouse >= MAX_MICE || button > MAX_MOUSE_BUTTONS || button <= 0) { return; } keybinding * binding = mice[mouse].buttons + button - 1; handle_binding_up(binding); } void bindings_release_capture(void) { if (mouse_mode == MOUSE_RELATIVE || (mouse_mode == MOUSE_CAPTURE && mouse_captured)) { render_relative_mouse(0); } keyboard_captured = 0; } void bindings_reacquire_capture(void) { if (mouse_mode == MOUSE_RELATIVE || (mouse_mode == MOUSE_CAPTURE && mouse_captured)) { render_relative_mouse(1); } } int parse_binding_target(int device_num, char * target, tern_node * padbuttons, tern_node *mousebuttons, uint8_t * subtype_a, uint8_t * subtype_b) { const int gpadslen = strlen("gamepads."); const int mouselen = strlen("mouse."); if (startswith(target, "gamepads.")) { int padnum = target[gpadslen] == 'n' ? device_num + 1 : target[gpadslen] - '0'; if (padnum >= 1 && padnum <= 8) { int button = tern_find_int(padbuttons, target + gpadslen + 1, 0); if (button) { *subtype_a = padnum; *subtype_b = button; return BIND_GAMEPAD; } else { if (target[gpadslen+1]) { warning("Gamepad mapping string '%s' refers to an invalid button '%s'\n", target, target + gpadslen + 1); } else { warning("Gamepad mapping string '%s' has no button component\n", target); } } } else { warning("Gamepad mapping string '%s' refers to an invalid gamepad number %c\n", target, target[gpadslen]); } } else if(startswith(target, "mouse.")) { int mousenum = target[mouselen] == 'n' ? device_num + 1 : target[mouselen] - '0'; if (mousenum >= 1 && mousenum <= 8) { int button = tern_find_int(mousebuttons, target + mouselen + 1, 0); if (button) { *subtype_a = mousenum; *subtype_b = button; return BIND_MOUSE; } else { if (target[mouselen+1]) { warning("Mouse mapping string '%s' refers to an invalid button '%s'\n", target, target + mouselen + 1); } else { warning("Mouse mapping string '%s' has no button component\n", target); } } } else { warning("Gamepad mapping string '%s' refers to an invalid mouse number %c\n", target, target[mouselen]); } } else if(startswith(target, "ui.")) { if (!strcmp(target + 3, "vdp_debug_mode")) { *subtype_a = UI_DEBUG_MODE_INC; } else if(!strcmp(target + 3, "vdp_debug_pal")) { //legacy binding, ignore return 0; } else if(!strcmp(target + 3, "enter_debugger")) { *subtype_a = UI_ENTER_DEBUGGER; } else if(!strcmp(target + 3, "save_state")) { *subtype_a = UI_SAVE_STATE; } else if(startswith(target + 3, "set_speed.")) { *subtype_a = UI_SET_SPEED; *subtype_b = atoi(target + 3 + strlen("set_speed.")); } else if(!strcmp(target + 3, "next_speed")) { *subtype_a = UI_NEXT_SPEED; } else if(!strcmp(target + 3, "prev_speed")) { *subtype_a = UI_PREV_SPEED; } else if(!strcmp(target + 3, "release_mouse")) { *subtype_a = UI_RELEASE_MOUSE; } else if(!strcmp(target + 3, "toggle_keyboard_captured")) { *subtype_a = UI_TOGGLE_KEYBOARD_CAPTURE; } else if (!strcmp(target + 3, "toggle_fullscreen")) { *subtype_a = UI_TOGGLE_FULLSCREEN; } else if (!strcmp(target + 3, "soft_reset")) { *subtype_a = UI_SOFT_RESET; } else if (!strcmp(target + 3, "reload")) { *subtype_a = UI_RELOAD; } else if (!strcmp(target + 3, "sms_pause")) { *subtype_a = UI_SMS_PAUSE; } else if (!strcmp(target + 3, "screenshot")) { *subtype_a = UI_SCREENSHOT; } else if(!strcmp(target + 3, "exit")) { *subtype_a = UI_EXIT; } else if (!strcmp(target + 3, "plane_debug")) { *subtype_a = UI_PLANE_DEBUG; } else if (!strcmp(target + 3, "vram_debug")) { *subtype_a = UI_VRAM_DEBUG; } else if (!strcmp(target + 3, "cram_debug")) { *subtype_a = UI_CRAM_DEBUG; } else if (!strcmp(target + 3, "compositing_debug")) { *subtype_a = UI_COMPOSITE_DEBUG; } else { warning("Unreconized UI binding type %s\n", target); return 0; } return BIND_UI; } else { warning("Unrecognized binding type %s\n", target); } return 0; } void process_keys(tern_node * cur, tern_node * special, tern_node * padbuttons, tern_node *mousebuttons, char * prefix) { char * curstr = NULL; int len; if (!cur) { return; } char onec[2]; if (prefix) { len = strlen(prefix); curstr = malloc(len + 2); memcpy(curstr, prefix, len); } else { curstr = onec; len = 0; } curstr[len] = cur->el; curstr[len+1] = 0; if (cur->el) { process_keys(cur->straight.next, special, padbuttons, mousebuttons, curstr); } else { int keycode = tern_find_int(special, curstr, 0); if (!keycode) { keycode = curstr[0]; if (curstr[1] != 0) { warning("%s is not recognized as a key identifier, truncating to %c\n", curstr, curstr[0]); } } char * target = cur->straight.value.ptrval; uint8_t subtype_a = 0, subtype_b = 0; int bindtype = parse_binding_target(0, target, padbuttons, mousebuttons, &subtype_a, &subtype_b); bind_key(keycode, bindtype, subtype_a, subtype_b); } process_keys(cur->left, special, padbuttons, mousebuttons, prefix); process_keys(cur->right, special, padbuttons, mousebuttons, prefix); if (curstr && len) { free(curstr); } } void process_speeds(tern_node * cur, char * prefix) { char * curstr = NULL; int len; if (!cur) { return; } char onec[2]; if (prefix) { len = strlen(prefix); curstr = malloc(len + 2); memcpy(curstr, prefix, len); } else { curstr = onec; len = 0; } curstr[len] = cur->el; curstr[len+1] = 0; if (cur->el) { process_speeds(cur->straight.next, curstr); } else { char *end; long speed_index = strtol(curstr, &end, 10); if (speed_index < 0 || end == curstr || *end) { warning("%s is not a valid speed index", curstr); } else { if (speed_index >= num_speeds) { speeds = realloc(speeds, sizeof(uint32_t) * (speed_index+1)); for(; num_speeds < speed_index + 1; num_speeds++) { speeds[num_speeds] = 0; } } speeds[speed_index] = atoi(cur->straight.value.ptrval); if (speeds[speed_index] < 1) { warning("%s is not a valid speed percentage, setting speed %d to 100", cur->straight.value.ptrval, speed_index); speeds[speed_index] = 100; } } } process_speeds(cur->left, prefix); process_speeds(cur->right, prefix); if (curstr && len) { free(curstr); } } typedef struct { tern_node *padbuttons; tern_node *mousebuttons; int mouseidx; } pmb_state; void process_mouse_button(char *buttonstr, tern_val value, uint8_t valtype, void *data) { pmb_state *state = data; int buttonnum = atoi(buttonstr); if (buttonnum < 1 || buttonnum > MAX_MOUSE_BUTTONS) { warning("Mouse button %s is out of the supported range of 1-8\n", buttonstr); return; } if (valtype != TVAL_PTR) { warning("Mouse button %s is not a scalar value!\n", buttonstr); return; } buttonnum--; uint8_t subtype_a = 0, subtype_b = 0; int bindtype = parse_binding_target(state->mouseidx, value.ptrval, state->padbuttons, state->mousebuttons, &subtype_a, &subtype_b); mice[state->mouseidx].buttons[buttonnum].bind_type = bindtype; mice[state->mouseidx].buttons[buttonnum].subtype_a = subtype_a; mice[state->mouseidx].buttons[buttonnum].subtype_b = subtype_b; } void process_mouse(char *mousenum, tern_val value, uint8_t valtype, void *data) { tern_node **buttonmaps = data; if (valtype != TVAL_NODE) { warning("Binding for mouse %s is a scalar!\n", mousenum); return; } tern_node *mousedef = value.ptrval; tern_node *padbuttons = buttonmaps[0]; tern_node *mousebuttons = buttonmaps[1]; int mouseidx = atoi(mousenum); if (mouseidx < 0 || mouseidx >= MAX_MICE) { warning("Mouse numbers must be between 0 and %d, but %d is not\n", MAX_MICE, mouseidx); return; } char *motion = tern_find_ptr(mousedef, "motion"); if (motion) { uint8_t subtype_a = 0, subtype_b = 0; int bindtype = parse_binding_target(mouseidx, motion, padbuttons, mousebuttons, &subtype_a, &subtype_b); mice[mouseidx].motion.bind_type = bindtype; mice[mouseidx].motion.subtype_a = subtype_a; mice[mouseidx].motion.subtype_b = subtype_b; } tern_node *buttons = tern_find_path(mousedef, "buttons\0\0", TVAL_NODE).ptrval; if (buttons) { pmb_state state = {padbuttons, mousebuttons, mouseidx}; tern_foreach(buttons, process_mouse_button, &state); } } typedef struct { int padnum; tern_node *padbuttons; tern_node *mousebuttons; } pad_button_state; static long map_warning_pad = -1; void process_pad_button(char *key, tern_val val, uint8_t valtype, void *data) { pad_button_state *state = data; int hostpadnum = state->padnum; if (valtype != TVAL_PTR) { warning("Pad button %s has a non-scalar value\n", key); return; } uint8_t subtype_a = 0, subtype_b = 0; int bindtype = parse_binding_target(hostpadnum, val.ptrval, state->padbuttons, state->mousebuttons, &subtype_a, &subtype_b); char *end; long hostbutton = strtol(key, &end, 10); if (*end) { //key is not a valid base 10 integer hostbutton = render_translate_input_name(hostpadnum, key, 0); if (hostbutton < 0) { if (hostbutton == RENDER_INVALID_NAME) { warning("%s is not a valid gamepad input name\n", key); } else if (hostbutton == RENDER_NOT_MAPPED && hostpadnum != map_warning_pad) { debug_message("No SDL 2 mapping exists for input %s on gamepad %d\n", key, hostpadnum); map_warning_pad = hostpadnum; } return; } if (hostbutton & RENDER_DPAD_BIT) { bind_dpad(hostpadnum, render_dpad_part(hostbutton), render_direction_part(hostbutton), bindtype, subtype_a, subtype_b); return; } else if (hostbutton & RENDER_AXIS_BIT) { bind_axis(hostpadnum, render_axis_part(hostbutton), hostbutton & RENDER_AXIS_POS, bindtype, subtype_a, subtype_b); return; } } bind_button(hostpadnum, hostbutton, bindtype, subtype_a, subtype_b); } void process_pad_axis(char *key, tern_val val, uint8_t valtype, void *data) { key = strdup(key); pad_button_state *state = data; int hostpadnum = state->padnum; if (valtype != TVAL_PTR) { warning("Mapping for axis %s has a non-scalar value", key); return; } uint8_t subtype_a = 0, subtype_b = 0; int bindtype = parse_binding_target(hostpadnum, val.ptrval, state->padbuttons, state->mousebuttons, &subtype_a, &subtype_b); char *modifier = strchr(key, '.'); int positive = 1; if (modifier) { *modifier = 0; modifier++; if (!strcmp("negative", modifier)) { positive = 0; } else if(strcmp("positive", modifier)) { warning("Invalid axis modifier %s for axis %s on pad %d\n", modifier, key, hostpadnum); } } char *end; long axis = strtol(key, &end, 10); if (*end) { //key is not a valid base 10 integer axis = render_translate_input_name(hostpadnum, key, 1); if (axis < 0) { if (axis == RENDER_INVALID_NAME) { warning("%s is not a valid gamepad input name\n", key); } else if (axis == RENDER_NOT_MAPPED && hostpadnum != map_warning_pad) { debug_message("No SDL 2 mapping exists for input %s on gamepad %d\n", key, hostpadnum); map_warning_pad = hostpadnum; } goto done; } if (axis & RENDER_DPAD_BIT) { bind_dpad(hostpadnum, render_dpad_part(axis), render_direction_part(axis), bindtype, subtype_a, subtype_b); goto done; } else if (axis & RENDER_AXIS_BIT) { axis = render_axis_part(axis); } else { bind_button(hostpadnum, axis, bindtype, subtype_a, subtype_b); goto done; } } bind_axis(hostpadnum, axis, positive, bindtype, subtype_a, subtype_b); done: free(key); return; } static tern_node *get_pad_buttons() { static tern_node *padbuttons; if (!padbuttons) { padbuttons = tern_insert_int(NULL, ".up", DPAD_UP); padbuttons = tern_insert_int(padbuttons, ".down", DPAD_DOWN); padbuttons = tern_insert_int(padbuttons, ".left", DPAD_LEFT); padbuttons = tern_insert_int(padbuttons, ".right", DPAD_RIGHT); padbuttons = tern_insert_int(padbuttons, ".a", BUTTON_A); padbuttons = tern_insert_int(padbuttons, ".b", BUTTON_B); padbuttons = tern_insert_int(padbuttons, ".c", BUTTON_C); padbuttons = tern_insert_int(padbuttons, ".x", BUTTON_X); padbuttons = tern_insert_int(padbuttons, ".y", BUTTON_Y); padbuttons = tern_insert_int(padbuttons, ".z", BUTTON_Z); padbuttons = tern_insert_int(padbuttons, ".start", BUTTON_START); padbuttons = tern_insert_int(padbuttons, ".mode", BUTTON_MODE); } return padbuttons; } static tern_node *get_mouse_buttons() { static tern_node *mousebuttons; if (!mousebuttons) { mousebuttons = tern_insert_int(NULL, ".left", MOUSE_LEFT); mousebuttons = tern_insert_int(mousebuttons, ".middle", MOUSE_MIDDLE); mousebuttons = tern_insert_int(mousebuttons, ".right", MOUSE_RIGHT); mousebuttons = tern_insert_int(mousebuttons, ".start", MOUSE_START); mousebuttons = tern_insert_int(mousebuttons, ".motion", PSEUDO_BUTTON_MOTION); } return mousebuttons; } tern_node *get_binding_node_for_pad(int padnum) { if (padnum > MAX_JOYSTICKS) { return NULL; } tern_node * pads = tern_find_path(config, "bindings\0pads\0", TVAL_NODE).ptrval; if (!pads) { return NULL; } char numstr[11]; sprintf(numstr, "%d", padnum); tern_node * pad = tern_find_node(pads, numstr); if (!pad) { char *type_id = render_joystick_type_id(padnum); pad = tern_find_node(pads, type_id); free(type_id); } if (!pad) { controller_info info = get_controller_info(padnum); char *key = make_controller_type_key(&info); pad = tern_find_node(pads, key); free(key); } if (!pad) { pad = tern_find_node(pads, "default"); } return pad; } void handle_joy_added(int joystick) { tern_node *pad = get_binding_node_for_pad(joystick); if (!pad) { return; } tern_node * dpad_node = tern_find_node(pad, "dpads"); if (dpad_node) { for (int dpad = 0; dpad < 10; dpad++) { char numstr[2] = {dpad + '0', 0}; tern_node * pad_dpad = tern_find_node(dpad_node, numstr); char * dirs[] = {"up", "down", "left", "right"}; char *render_dirs[] = {"dpup", "dpdown", "dpleft", "dpright"}; int dirnums[] = {RENDER_DPAD_UP, RENDER_DPAD_DOWN, RENDER_DPAD_LEFT, RENDER_DPAD_RIGHT}; for (int dir = 0; dir < sizeof(dirs)/sizeof(dirs[0]); dir++) { char * target = tern_find_ptr(pad_dpad, dirs[dir]); if (target) { uint8_t subtype_a = 0, subtype_b = 0; int bindtype = parse_binding_target(joystick, target, get_pad_buttons(), get_mouse_buttons(), &subtype_a, &subtype_b); int32_t hostbutton = dpad >0 ? -1 : render_translate_input_name(joystick, render_dirs[dir], 0); if (hostbutton < 0) { //assume this is a raw dpad mapping bind_dpad(joystick, dpad, dirnums[dir], bindtype, subtype_a, subtype_b); } else if (hostbutton & RENDER_DPAD_BIT) { bind_dpad(joystick, render_dpad_part(hostbutton), render_direction_part(hostbutton), bindtype, subtype_a, subtype_b); } else if (hostbutton & RENDER_AXIS_BIT) { //SDL2 knows internally whether this should be a positive or negative binding, but doesn't expose that externally //for now I'll just assume that any controller with axes for a d-pad has these mapped the "sane" way bind_axis(joystick, render_axis_part(hostbutton), dir == 1 || dir == 3 ? 1 : 0, bindtype, subtype_a, subtype_b); } else { bind_button(joystick, hostbutton, bindtype, subtype_a, subtype_b); } } } } } tern_node *button_node = tern_find_node(pad, "buttons"); if (button_node) { pad_button_state state = { .padnum = joystick, .padbuttons = get_pad_buttons(), .mousebuttons = get_mouse_buttons() }; tern_foreach(button_node, process_pad_button, &state); } tern_node *axes_node = tern_find_node(pad, "axes"); if (axes_node) { pad_button_state state = { .padnum = joystick, .padbuttons = get_pad_buttons(), .mousebuttons = get_mouse_buttons() }; tern_foreach(axes_node, process_pad_axis, &state); } } //only handles keyboards and mice as gamepads are handled on hotplug events void set_bindings(void) { tern_node * special = tern_insert_int(NULL, "up", RENDERKEY_UP); special = tern_insert_int(special, "down", RENDERKEY_DOWN); special = tern_insert_int(special, "left", RENDERKEY_LEFT); special = tern_insert_int(special, "right", RENDERKEY_RIGHT); special = tern_insert_int(special, "enter", '\r'); special = tern_insert_int(special, "space", ' '); special = tern_insert_int(special, "tab", '\t'); special = tern_insert_int(special, "backspace", '\b'); special = tern_insert_int(special, "esc", RENDERKEY_ESC); special = tern_insert_int(special, "delete", RENDERKEY_DEL); special = tern_insert_int(special, "lshift", RENDERKEY_LSHIFT); special = tern_insert_int(special, "rshift", RENDERKEY_RSHIFT); special = tern_insert_int(special, "lctrl", RENDERKEY_LCTRL); special = tern_insert_int(special, "rctrl", RENDERKEY_RCTRL); special = tern_insert_int(special, "lalt", RENDERKEY_LALT); special = tern_insert_int(special, "ralt", RENDERKEY_RALT); special = tern_insert_int(special, "home", RENDERKEY_HOME); special = tern_insert_int(special, "end", RENDERKEY_END); special = tern_insert_int(special, "pageup", RENDERKEY_PAGEUP); special = tern_insert_int(special, "pagedown", RENDERKEY_PAGEDOWN); special = tern_insert_int(special, "f1", RENDERKEY_F1); special = tern_insert_int(special, "f2", RENDERKEY_F2); special = tern_insert_int(special, "f3", RENDERKEY_F3); special = tern_insert_int(special, "f4", RENDERKEY_F4); special = tern_insert_int(special, "f5", RENDERKEY_F5); special = tern_insert_int(special, "f6", RENDERKEY_F6); special = tern_insert_int(special, "f7", RENDERKEY_F7); special = tern_insert_int(special, "f8", RENDERKEY_F8); special = tern_insert_int(special, "f9", RENDERKEY_F9); special = tern_insert_int(special, "f10", RENDERKEY_F10); special = tern_insert_int(special, "f11", RENDERKEY_F11); special = tern_insert_int(special, "f12", RENDERKEY_F12); special = tern_insert_int(special, "select", RENDERKEY_SELECT); special = tern_insert_int(special, "play", RENDERKEY_PLAY); special = tern_insert_int(special, "search", RENDERKEY_SEARCH); special = tern_insert_int(special, "back", RENDERKEY_BACK); special = tern_insert_int(special, "np0", RENDERKEY_NP0); special = tern_insert_int(special, "np1", RENDERKEY_NP1); special = tern_insert_int(special, "np2", RENDERKEY_NP2); special = tern_insert_int(special, "np3", RENDERKEY_NP3); special = tern_insert_int(special, "np4", RENDERKEY_NP4); special = tern_insert_int(special, "np5", RENDERKEY_NP5); special = tern_insert_int(special, "np6", RENDERKEY_NP6); special = tern_insert_int(special, "np7", RENDERKEY_NP7); special = tern_insert_int(special, "np8", RENDERKEY_NP8); special = tern_insert_int(special, "np9", RENDERKEY_NP9); special = tern_insert_int(special, "np/", RENDERKEY_NP_DIV); special = tern_insert_int(special, "np*", RENDERKEY_NP_MUL); special = tern_insert_int(special, "np-", RENDERKEY_NP_MIN); special = tern_insert_int(special, "np+", RENDERKEY_NP_PLUS); special = tern_insert_int(special, "npenter", RENDERKEY_NP_ENTER); special = tern_insert_int(special, "np.", RENDERKEY_NP_STOP); tern_node *padbuttons = get_pad_buttons(); tern_node *mousebuttons = get_mouse_buttons(); tern_node * keys = tern_find_path(config, "bindings\0keys\0", TVAL_NODE).ptrval; process_keys(keys, special, padbuttons, mousebuttons, NULL); tern_free(special); memset(mice, 0, sizeof(mice)); tern_node * mice = tern_find_path(config, "bindings\0mice\0", TVAL_NODE).ptrval; if (mice) { tern_node *buttonmaps[2] = {padbuttons, mousebuttons}; tern_foreach(mice, process_mouse, buttonmaps); } tern_node * speed_nodes = tern_find_path(config, "clocks\0speeds\0", TVAL_NODE).ptrval; speeds = malloc(sizeof(uint32_t)); speeds[0] = 100; process_speeds(speed_nodes, NULL); for (int i = 0; i < num_speeds; i++) { if (!speeds[i]) { warning("Speed index %d was not set to a valid percentage!", i); speeds[i] = 100; } } } void bindings_set_mouse_mode(uint8_t mode) { mouse_mode = mode; if (mode == MOUSE_RELATIVE) { render_relative_mouse(1); } }