ref: 3e63451df5b5d3f9f4019f19977e6b0b1ec10053
dir: /src/setup/joystick.c/
// // Copyright(C) 2005-2014 Simon Howard // // This program is free software; you can redistribute it and/or // modify it under the terms of the GNU General Public License // as published by the Free Software Foundation; either version 2 // of the License, or (at your option) any later version. // // This program 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 General Public License for more details. // #include <stdio.h> #include <stdlib.h> #include <string.h> #include "doomtype.h" #include "i_joystick.h" #include "m_config.h" #include "m_controls.h" #include "m_misc.h" #include "textscreen.h" #include "execute.h" #include "joystick.h" #include "mode.h" #include "txt_joyaxis.h" #include "txt_joybinput.h" #define WINDOW_HELP_URL "https://www.chocolate-doom.org/setup-gamepad" typedef struct { const char *name; // Config file name int value; } joystick_config_t; typedef struct { const char *name; int axes, buttons, hats; const joystick_config_t *configs; } known_joystick_t; // SDL joystick successfully initialized? static int joystick_initted = 0; // Joystick enable/disable static int usejoystick = 0; // GUID and index of joystick to use. char *joystick_guid = ""; int joystick_index = -1; // Calibration button. This is the button the user pressed at the // start of the calibration sequence. They *must* press this button // for each subsequent sequence. static int calibrate_button = -1; // Which joystick axis to use for horizontal movement, and whether to // invert the direction: static int joystick_x_axis = 0; static int joystick_x_invert = 0; // Which joystick axis to use for vertical movement, and whether to // invert the direction: static int joystick_y_axis = 1; static int joystick_y_invert = 0; // Strafe axis. static int joystick_strafe_axis = -1; static int joystick_strafe_invert = 0; // Look axis. static int joystick_look_axis = -1; static int joystick_look_invert = 0; // Virtual to physical mapping. int joystick_physical_buttons[NUM_VIRTUAL_BUTTONS] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; static txt_button_t *joystick_button; static txt_joystick_axis_t *x_axis_widget; static txt_joystick_axis_t *y_axis_widget; // // Calibration // static txt_window_t *calibration_window; static SDL_Joystick **all_joysticks = NULL; static int all_joysticks_len = 0; // Known controllers. // There are lots of game controllers on the market. Try to configure // them in a consistent way: // // * Use the D-pad rather than an analog stick. left/right turns the // player, up/down moves forward/backward - ie. a "traditional" // layout like Vanilla Doom rather than something more elaborate. // * No strafe axis. // * Fire and run keys together, on the main right-side buttons, // ideally arranged so both can be controlled/covered simultaneously // with the thumb. // * Jump/use keys in the same cluster if possible. // * Strafe left/right configured to map to shoulder buttons if they // are present. No "strafe on" key unless shoulder buttons not present. // * If a second set of shoulder buttons are also present, these map // to prev weapon/next weapon. // * Menu button mapped to start button. // // With the common right-side button arrangement that looks like this, // which is similar to the Vanilla default configuration when using // a Gravis Gamepad: // // B A = Fire // A D B = Jump // C C = Speed // D = Use // Always loaded before others, to get a known starting configuration. static const joystick_config_t empty_defaults[] = { {"joystick_x_axis", -1}, {"joystick_x_invert", 0}, {"joystick_y_axis", -1}, {"joystick_y_invert", 0}, {"joystick_strafe_axis", -1}, {"joystick_strafe_invert", 0}, {"joystick_look_axis", -1}, {"joystick_look_invert", 0}, {"joyb_fire", -1}, {"joyb_use", -1}, {"joyb_strafe", -1}, {"joyb_speed", -1}, {"joyb_strafeleft", -1}, {"joyb_straferight", -1}, {"joyb_prevweapon", -1}, {"joyb_nextweapon", -1}, {"joyb_jump", -1}, {"joyb_menu_activate", -1}, {"joyb_toggle_automap", -1}, {"joystick_physical_button0", 0}, {"joystick_physical_button1", 1}, {"joystick_physical_button2", 2}, {"joystick_physical_button3", 3}, {"joystick_physical_button4", 4}, {"joystick_physical_button5", 5}, {"joystick_physical_button6", 6}, {"joystick_physical_button7", 7}, {"joystick_physical_button8", 8}, {"joystick_physical_button9", 9}, {NULL, 0}, }; static const joystick_config_t ps3_controller[] = { {"joystick_x_axis", CREATE_BUTTON_AXIS(7, 5)}, {"joystick_y_axis", CREATE_BUTTON_AXIS(4, 6)}, {"joyb_fire", 15}, // Square {"joyb_speed", 14}, // X {"joyb_use", 13}, // Circle {"joyb_jump", 12}, // Triangle {"joyb_strafeleft", 8}, // Bottom shoulder buttons {"joyb_straferight", 9}, {"joyb_prevweapon", 10}, // Top shoulder buttons {"joyb_nextweapon", 11}, {"joyb_menu_activate", 3}, // Start {NULL, 0}, }; // Playstation 4 Dual Shock 4 (DS4) static const joystick_config_t ps4_ds4_controller[] = { {"joystick_x_axis", CREATE_HAT_AXIS(0, HAT_AXIS_HORIZONTAL)}, {"joystick_y_axis", CREATE_HAT_AXIS(0, HAT_AXIS_VERTICAL)}, {"joyb_fire", 0}, // Square {"joyb_speed", 1}, // X {"joyb_use", 2}, // Circle {"joyb_jump", 3}, // Triangle {"joyb_strafeleft", 6}, // Bottom shoulder buttons {"joyb_straferight", 7}, {"joyb_prevweapon", 4}, // Top shoulder buttons {"joyb_nextweapon", 5}, {"joyb_menu_activate", 12}, // Playstation logo button }; static const joystick_config_t airflo_controller[] = { {"joystick_x_axis", CREATE_HAT_AXIS(0, HAT_AXIS_HORIZONTAL)}, {"joystick_y_axis", CREATE_HAT_AXIS(0, HAT_AXIS_VERTICAL)}, {"joyb_fire", 2}, // "3" {"joyb_speed", 0}, // "1" {"joyb_jump", 3}, // "4" {"joyb_use", 1}, // "2" {"joyb_strafeleft", 6}, // Bottom shoulder buttons {"joyb_straferight", 7}, {"joyb_prevweapon", 4}, // Top shoulder buttons {"joyb_nextweapon", 5}, {"joyb_menu_activate", 9}, // "10", where "Start" usually is. {NULL, 0}, }; // Wii controller is weird, so we have to take some liberties. // Also it's not a HID device, so it won't appear the same everywhere. // Assume there is no nunchuk or classic controller attached. // When using WJoy on OS X. static const joystick_config_t wii_controller_wjoy[] = { {"joystick_x_axis", CREATE_BUTTON_AXIS(2, 3)}, {"joystick_y_axis", CREATE_BUTTON_AXIS(1, 0)}, {"joyb_fire", 9}, // Button 1 {"joyb_speed", 10}, // Button 2 {"joyb_use", 5}, // Button B (trigger) {"joyb_prevweapon", 7}, // - {"joyb_nextweapon", 6}, // + {"joyb_menu_activate", 9}, // Button A {NULL, 0}, }; // Xbox 360 controller. Thanks to Brad Harding for the details. static const joystick_config_t xbox360_controller[] = { {"joystick_x_axis", CREATE_HAT_AXIS(0, HAT_AXIS_HORIZONTAL)}, {"joystick_y_axis", CREATE_HAT_AXIS(0, HAT_AXIS_VERTICAL)}, {"joystick_strafe_axis", 2}, // Trigger buttons form an axis(???) {"joyb_fire", 2}, // X {"joyb_speed", 0}, // A {"joyb_jump", 3}, // Y {"joyb_use", 1}, // B {"joyb_prevweapon", 4}, // LB {"joyb_nextweapon", 5}, // RB {"joyb_menu_activate", 9}, // Start {NULL, 0}, }; // Xbox 360 controller under Linux. static const joystick_config_t xbox360_controller_linux[] = { {"joystick_x_axis", CREATE_HAT_AXIS(0, HAT_AXIS_HORIZONTAL)}, {"joystick_y_axis", CREATE_HAT_AXIS(0, HAT_AXIS_VERTICAL)}, // Ideally we'd like the trigger buttons to be strafe left/right // But Linux presents each trigger button as its own axis, which // we can't really work with. So we have to settle for a // suboptimal setup. {"joyb_fire", 2}, // X {"joyb_speed", 0}, // A {"joyb_jump", 3}, // Y {"joyb_use", 1}, // B {"joyb_strafeleft", 4}, // LB {"joyb_straferight", 5}, // RB {"joyb_menu_activate", 7}, // Start {"joyb_prevweapon", 6}, // Back {NULL, 0}, }; // Logitech Dual Action (F310, F710). Thanks to Brad Harding for details. static const joystick_config_t logitech_f310_controller[] = { {"joystick_x_axis", CREATE_HAT_AXIS(0, HAT_AXIS_HORIZONTAL)}, {"joystick_y_axis", CREATE_HAT_AXIS(0, HAT_AXIS_VERTICAL)}, {"joyb_fire", 0}, // X {"joyb_speed", 1}, // A {"joyb_jump", 3}, // Y {"joyb_use", 2}, // B {"joyb_strafeleft", 6}, // LT {"joyb_straferight", 7}, // RT {"joyb_prevweapon", 4}, // LB {"joyb_nextweapon", 5}, // RB {"joyb_menu_activate", 11}, // Start {NULL, 0}, }; // Multilaser JS030 gamepad, similar to a PS2 controller. static const joystick_config_t multilaser_js030_controller[] = { {"joystick_x_axis", 0}, // Left stick / D-pad {"joystick_y_axis", 1}, {"joyb_fire", 3}, // Square {"joyb_speed", 2}, // X {"joyb_use", 1}, // Circle {"joyb_jump", 0}, // Triangle {"joyb_strafeleft", 6}, // Bottom shoulder buttons {"joyb_straferight", 7}, {"joyb_prevweapon", 4}, // Top shoulder buttons {"joyb_nextweapon", 5}, {"joyb_menu_activate", 9}, // Start {NULL, 0}, }; // Buffalo Classic USB Gamepad (thanks Fabian Greffrath). static const joystick_config_t buffalo_classic_controller[] = { {"joystick_x_axis", 0}, {"joystick_y_axis", 1}, {"joyb_use", 0}, // A {"joyb_speed", 1}, // B {"joyb_jump", 2}, // X {"joyb_fire", 3}, // Y {"joyb_strafeleft", 4}, // Left shoulder {"joyb_straferight", 5}, // Right shoulder {"joyb_prevweapon", 6}, // Select {"joyb_menu_activate", 7}, // Start {NULL, 0}, }; // Config for if the user is actually using an old PC joystick or gamepad, // probably via a USB-Gameport adapter. static const joystick_config_t pc_gameport_controller[] = { {"joystick_x_axis", 0}, {"joystick_y_axis", 1}, // Button configuration is the default as used for Vanilla Doom, // Heretic and Hexen. When playing with a Gravis Gamepad, this // layout should also be vaguely similar to the standard layout // described above. {"joyb_fire", 0}, {"joyb_strafe", 1}, {"joyb_use", 3}, {"joyb_speed", 2}, {NULL, 0}, }; // http://www.8bitdo.com/nes30pro/ and http://www.8bitdo.com/fc30pro/ static const joystick_config_t nes30_pro_controller[] = { {"joystick_x_axis", CREATE_HAT_AXIS(0, HAT_AXIS_HORIZONTAL)}, {"joystick_y_axis", CREATE_HAT_AXIS(0, HAT_AXIS_VERTICAL)}, {"joyb_fire", 4}, // Y {"joyb_speed", 1}, // B {"joyb_jump", 3}, // X {"joyb_use", 0}, // A {"joyb_strafeleft", 6}, // L1 {"joyb_straferight", 7}, // R1 {"joyb_prevweapon", 8}, // L2 {"joyb_nextweapon", 9}, // R2 {"joyb_menu_activate", 11}, // Start {"joyb_toggle_automap", 10}, // Select {NULL, 0}, }; // http://www.8bitdo.com/sfc30/ or http://www.8bitdo.com/snes30/ // and http://www.nes30.com/ and http://www.fc30.com/ static const joystick_config_t sfc30_controller[] = { {"joystick_x_axis", 0}, {"joystick_y_axis", 1}, {"joyb_fire", 4}, // Y {"joyb_speed", 1}, // B {"joyb_jump", 3}, // X {"joyb_use", 0}, // A {"joyb_strafeleft", 6}, // L {"joyb_straferight", 7}, // R {"joyb_menu_activate", 11}, // Start {"joyb_toggle_automap", 10}, // Select {NULL, 0}, }; static const known_joystick_t known_joysticks[] = { { "PLAYSTATION(R)3 Controller", 4, 19, 0, ps3_controller, }, { "AIRFLO ", 4, 13, 1, airflo_controller, }, { "Wiimote (*", // WJoy includes the Wiimote MAC address. 6, 26, 0, wii_controller_wjoy, }, { "Controller (XBOX 360 For Windows)", 5, 10, 1, xbox360_controller, }, { "Controller (XBOX One For Windows)", 5, 10, 1, xbox360_controller, }, // Xbox 360 controller as it appears on Linux. { "Microsoft X-Box 360 pad", 6, 11, 1, xbox360_controller_linux, }, // Xbox One controller as it appears on Linux. { "Microsoft X-Box One pad", 6, 11, 1, xbox360_controller_linux, }, { "Logitech Dual Action", 4, 12, 1, logitech_f310_controller, }, { "USB Vibration Joystick", 4, 12, 1, multilaser_js030_controller, }, { "USB,2-axis 8-button gamepad ", 2, 8, 0, buffalo_classic_controller, }, // PS4 controller just appears as the generic-sounding "Wireless // Controller". Hopefully the number of buttons/axes/hats should be // enough to distinguish it from other gamepads. { "Wireless Controller", 6, 14, 1, ps4_ds4_controller, }, // This is the configuration for the USB-Gameport adapter listed on // this page as the "Mayflash USB to Gameport Adapter" (though the // device is labeled as "Super Joy Box 7"): // https://sites.google.com/site/joystickrehab/itemcatal // TODO: Add extra configurations here for other USB-Gameport adapters, // which should just be the same configuration. { "WiseGroup.,Ltd Gameport to USB Controller", 4, 8, 1, pc_gameport_controller, }, // How the Super Joy Box 7 appears on Mac OS X. { "Gameport to USB Controller", 2, 8, 1, pc_gameport_controller, }, // 8Bitdo NES30 Pro, http://www.8bitdo.com/nes30pro/ { "8Bitdo NES30 Pro", 4, 16, 1, nes30_pro_controller, }, // the above, NES variant, via USB on Linux/Raspbian (odd values) { "8Bitdo NES30 Pro*", 6, 15, 1, nes30_pro_controller, }, // the above, NES variant, connected over bluetooth { "8Bitdo NES30 Pro", 6, 16, 1, nes30_pro_controller, }, // 8bitdo NES30 Pro, in joystick mode (R1+Power), swaps the D-Pad // and analog stick inputs. Only applicable over Bluetooth. On USB, // this mode registers the device as an Xbox 360 pad. { "8Bitdo NES30 Pro Joystick", 6, 16, 1, nes30_pro_controller, }, // variant of the above, via USB on Mac // Note: untested, but theorized to exist based on us comparing // a NES30 Pro tested on Linux with a FC30 Pro tested with Mac & Linux { "8Bitdo NES30 Pro", 4, 15, 1, nes30_pro_controller, }, // 8Bitdo FC30 Pro, http://8bitdo.cn/fc30pro/ // connected over bluetooth { "8Bitdo FC30 Pro", 4, 16, 1, nes30_pro_controller, }, // variant of the above, via USB on Linux/Raspbian { "8Bitdo FC30 Pro*", 6, 15, 1, nes30_pro_controller, }, // variant of the above, Linux/bluetooth { "8Bitdo FC30 Pro", 6, 16, 1, nes30_pro_controller, }, // variant of the above, via USB on Mac { "8Bitdo FC30 Pro", 4, 15, 1, nes30_pro_controller, }, // 8Bitdo SFC30 SNES replica controller // in default mode and in controller mode (Start+R) // the latter suffixes "Joystick" to the name // http://www.8bitdo.com/sfc30/ { "8Bitdo SFC30 GamePad*", 4, 16, 1, sfc30_controller, }, // As above, but as detected on RHEL Linux (odd extra axes) { "8Bitdo SFC30 GamePad*", 6, 16, 1, sfc30_controller, }, // SNES30 colour variation of the above // http://www.8bitdo.com/snes30/ { "8Bitdo SNES30 GamePad*", 4, 16, 1, sfc30_controller, }, // 8Bitdo SFC30 SNES replica controller in USB controller mode // tested with firmware V2.68 (Beta); latest stable V2.65 doesn't work on // OS X in USB controller mode // Names seen so far: // 'SFC30 Joystick' (OS X) // 'SFC30 SFC30 Joystick' (Fedora 24; RHEL7) // XXX: there is probably a SNES30 variant of this too { "SFC30 *", 4, 12, 1, sfc30_controller, }, // NES30 (not pro), tested in default and "hold R whilst turning on" // mode, with whatever firmware it came with out of the box. Latter // mode puts " Joystick" suffix on the name string { "8Bitdo NES30 GamePad*", 4, 16, 1, sfc30_controller, // identical to SFC30 }, // FC30 variant of the above { "8Bitdo FC30 GamePad*", 4, 16, 1, sfc30_controller, // identical to SFC30 }, // NES30 in USB mode { "NES30*", 4, 12, 1, sfc30_controller, // identical to SFC30 }, // FC30 variant of the above { "FC30*", 4, 12, 1, sfc30_controller, // identical to SFC30 }, }; static const known_joystick_t *GetJoystickType(int index) { SDL_Joystick *joystick; const char *name; int axes, buttons, hats; int i; joystick = all_joysticks[index]; name = SDL_JoystickName(joystick); axes = SDL_JoystickNumAxes(joystick); buttons = SDL_JoystickNumButtons(joystick); hats = SDL_JoystickNumHats(joystick); for (i = 0; i < arrlen(known_joysticks); ++i) { // Check for a name match. If the name ends in '*', this means // ignore the rest. if (M_StringEndsWith(known_joysticks[i].name, "*")) { if (strncmp(known_joysticks[i].name, name, strlen(known_joysticks[i].name) - 1) != 0) { continue; } } else { if (strcmp(known_joysticks[i].name, name) != 0) { continue; } } if (known_joysticks[i].axes == axes && known_joysticks[i].buttons == buttons && known_joysticks[i].hats == hats) { return &known_joysticks[i]; } } printf("Unknown joystick '%s' with %i axes, %i buttons, %i hats\n", name, axes, buttons, hats); printf("Please consider sending in details about your gamepad!\n"); return NULL; } // Query if the joystick at the given index is a known joystick type. static boolean IsKnownJoystick(int index) { return GetJoystickType(index) != NULL; } // Load a configuration set. static void LoadConfigurationSet(const joystick_config_t *configs) { const joystick_config_t *config; char buf[10]; int button; int i; button = 0; for (i = 0; configs[i].name != NULL; ++i) { config = &configs[i]; // Don't overwrite autorun if it is set. if (!strcmp(config->name, "joyb_speed") && joybspeed >= 20) { continue; } // For buttons, set the virtual button mapping as well. if (M_StringStartsWith(config->name, "joyb_") && config->value >= 0) { joystick_physical_buttons[button] = config->value; M_snprintf(buf, sizeof(buf), "%i", button); M_SetVariable(config->name, buf); ++button; } else { M_snprintf(buf, sizeof(buf), "%i", config->value); M_SetVariable(config->name, buf); } } } // Load configuration for joystick_index based on known types. static void LoadKnownConfiguration(void) { const known_joystick_t *jstype; jstype = GetJoystickType(joystick_index); if (jstype == NULL) { return; } LoadConfigurationSet(empty_defaults); LoadConfigurationSet(jstype->configs); } static void InitJoystick(void) { if (!joystick_initted) { joystick_initted = SDL_Init(SDL_INIT_JOYSTICK) >= 0; } } static void UnInitJoystick(void) { if (joystick_initted) { SDL_QuitSubSystem(SDL_INIT_JOYSTICK); joystick_initted = 0; } } // We identify joysticks using GUID where possible, but joystick_index // is used to distinguish between different devices. As the index can // change, UpdateJoystickIndex() checks to see if it is still valid and // updates it as appropriate. static void UpdateJoystickIndex(void) { SDL_JoystickGUID guid, dev_guid; int i; guid = SDL_JoystickGetGUIDFromString(joystick_guid); // Is joystick_index already correct? if (joystick_index >= 0 && joystick_index < SDL_NumJoysticks()) { dev_guid = SDL_JoystickGetDeviceGUID(joystick_index); if (!memcmp(&guid, &dev_guid, sizeof(SDL_JoystickGUID))) { return; } } // If index is not correct, look for the first device with the // expected GUID. It may have moved to a different index. for (i = 0; i < SDL_NumJoysticks(); ++i) { dev_guid = SDL_JoystickGetDeviceGUID(i); if (!memcmp(&guid, &dev_guid, sizeof(SDL_JoystickGUID))) { joystick_index = i; return; } } // Not found; it's possible the device is disconnected. Do not // reset joystick_guid or joystick_index in case they are // reconnected later. } // Set the label showing the name of the currently selected joystick static void SetJoystickButtonLabel(void) { SDL_JoystickGUID guid, dev_guid; const char *name; if (!usejoystick || !strcmp(joystick_guid, "")) { name = "None set"; } else { name = "Not found (device disconnected?)"; // Use the device name if the GUID and index match. if (joystick_index >= 0 && joystick_index < SDL_NumJoysticks()) { guid = SDL_JoystickGetGUIDFromString(joystick_guid); dev_guid = SDL_JoystickGetDeviceGUID(joystick_index); if (!memcmp(&guid, &dev_guid, sizeof(SDL_JoystickGUID))) { name = SDL_JoystickNameForIndex(joystick_index); } } } TXT_SetButtonLabel(joystick_button, (char *) name); } // Try to open all joysticks visible to SDL. static int OpenAllJoysticks(void) { int i; int result; InitJoystick(); // SDL_JoystickOpen() all joysticks. all_joysticks_len = SDL_NumJoysticks(); all_joysticks = calloc(all_joysticks_len, sizeof(SDL_Joystick *)); result = 0; for (i = 0; i < all_joysticks_len; ++i) { all_joysticks[i] = SDL_JoystickOpen(i); // If any joystick is successfully opened, return true. if (all_joysticks[i] != NULL) { result = 1; } } // Success? Turn on joystick events. if (result) { SDL_JoystickEventState(SDL_ENABLE); } else { free(all_joysticks); all_joysticks = NULL; } return result; } // Close all the joysticks opened with OpenAllJoysticks() static void CloseAllJoysticks(void) { int i; for (i = 0; i < all_joysticks_len; ++i) { if (all_joysticks[i] != NULL) { SDL_JoystickClose(all_joysticks[i]); } } SDL_JoystickEventState(SDL_DISABLE); free(all_joysticks); all_joysticks = NULL; UnInitJoystick(); } static void CalibrateXAxis(void) { TXT_ConfigureJoystickAxis(x_axis_widget, calibrate_button, NULL); } // Given the SDL_JoystickID instance ID from a button event, set the // joystick_guid and joystick_index config variables. static boolean SetJoystickGUID(SDL_JoystickID joy_id) { SDL_JoystickGUID guid; int i; for (i = 0; i < all_joysticks_len; ++i) { if (SDL_JoystickInstanceID(all_joysticks[i]) == joy_id) { guid = SDL_JoystickGetGUID(all_joysticks[i]); joystick_guid = malloc(33); SDL_JoystickGetGUIDString(guid, joystick_guid, 33); joystick_index = i; return true; } } return false; } static int CalibrationEventCallback(SDL_Event *event, void *user_data) { if (event->type != SDL_JOYBUTTONDOWN) { return 0; } if (!SetJoystickGUID(event->jbutton.which)) { return 0; } // At this point, we have a button press. // In the first "center" stage, we're just trying to work out which // joystick is being configured and which button the user is pressing. usejoystick = 1; calibrate_button = event->jbutton.button; // If the joystick is a known one, auto-load default // config for it. Otherwise, proceed with calibration. if (IsKnownJoystick(joystick_index)) { LoadKnownConfiguration(); TXT_CloseWindow(calibration_window); } else { TXT_CloseWindow(calibration_window); // Calibrate joystick axes: Y axis first, then X axis once // completed. TXT_ConfigureJoystickAxis(y_axis_widget, calibrate_button, CalibrateXAxis); } return 1; } static void NoJoystick(void) { TXT_MessageBox(NULL, "No gamepads or joysticks could be found.\n\n" "Try configuring your controller from within\n" "your OS first. Maybe you need to install\n" "some drivers or otherwise configure it."); usejoystick = 0; joystick_index = -1; SetJoystickButtonLabel(); } static void CalibrateWindowClosed(TXT_UNCAST_ARG(widget), TXT_UNCAST_ARG(unused)) { TXT_SDL_SetEventCallback(NULL, NULL); SetJoystickButtonLabel(); CloseAllJoysticks(); } static void CalibrateJoystick(TXT_UNCAST_ARG(widget), TXT_UNCAST_ARG(unused)) { // Try to open all available joysticks. If none are opened successfully, // bomb out with an error. if (!OpenAllJoysticks()) { NoJoystick(); return; } calibration_window = TXT_NewWindow("Gamepad/Joystick calibration"); TXT_AddWidgets(calibration_window, TXT_NewStrut(0, 1), TXT_NewLabel("Center the D-pad or joystick,\n" "and press a button."), TXT_NewStrut(0, 1), NULL); TXT_SetWindowAction(calibration_window, TXT_HORIZ_LEFT, NULL); TXT_SetWindowAction(calibration_window, TXT_HORIZ_CENTER, TXT_NewWindowAbortAction(calibration_window)); TXT_SetWindowAction(calibration_window, TXT_HORIZ_RIGHT, NULL); TXT_SDL_SetEventCallback(CalibrationEventCallback, NULL); TXT_SignalConnect(calibration_window, "closed", CalibrateWindowClosed, NULL); // Start calibration usejoystick = 0; joystick_index = -1; } // // GUI // static void AddJoystickControl(TXT_UNCAST_ARG(table), const char *label, int *var) { TXT_CAST_ARG(txt_table_t, table); txt_joystick_input_t *joy_input; joy_input = TXT_NewJoystickInput(var); TXT_AddWidgets(table, TXT_NewLabel(label), joy_input, TXT_TABLE_EMPTY, NULL); } void ConfigJoystick(TXT_UNCAST_ARG(widget), void *user_data) { txt_window_t *window; window = TXT_NewWindow("Gamepad/Joystick configuration"); TXT_SetTableColumns(window, 6); TXT_SetColumnWidths(window, 18, 10, 1, 15, 10, 0); TXT_SetWindowHelpURL(window, WINDOW_HELP_URL); TXT_AddWidgets(window, TXT_NewLabel("Controller"), joystick_button = TXT_NewButton("zzzz"), TXT_TABLE_EOL, TXT_NewSeparator("Axes"), TXT_NewLabel("Forward/backward"), y_axis_widget = TXT_NewJoystickAxis(&joystick_y_axis, &joystick_y_invert, JOYSTICK_AXIS_VERTICAL), TXT_TABLE_OVERFLOW_RIGHT, TXT_TABLE_OVERFLOW_RIGHT, TXT_TABLE_EMPTY, TXT_TABLE_EMPTY, TXT_NewLabel("Turn left/right"), x_axis_widget = TXT_NewJoystickAxis(&joystick_x_axis, &joystick_x_invert, JOYSTICK_AXIS_HORIZONTAL), TXT_TABLE_OVERFLOW_RIGHT, TXT_TABLE_OVERFLOW_RIGHT, TXT_TABLE_EMPTY, TXT_TABLE_EMPTY, TXT_NewLabel("Strafe left/right"), TXT_NewJoystickAxis(&joystick_strafe_axis, &joystick_strafe_invert, JOYSTICK_AXIS_HORIZONTAL), TXT_TABLE_OVERFLOW_RIGHT, TXT_TABLE_OVERFLOW_RIGHT, TXT_TABLE_EMPTY, TXT_TABLE_EMPTY, NULL); if (gamemission == heretic || gamemission == hexen || gamemission == strife) { TXT_AddWidgets(window, TXT_NewLabel("Look up/down"), TXT_NewJoystickAxis(&joystick_look_axis, &joystick_look_invert, JOYSTICK_AXIS_VERTICAL), TXT_TABLE_OVERFLOW_RIGHT, TXT_TABLE_OVERFLOW_RIGHT, TXT_TABLE_EMPTY, TXT_TABLE_EMPTY, NULL); } TXT_AddWidget(window, TXT_NewSeparator("Buttons")); AddJoystickControl(window, "Fire/Attack", &joybfire); AddJoystickControl(window, "Strafe Left", &joybstrafeleft); AddJoystickControl(window, "Use", &joybuse); AddJoystickControl(window, "Strafe Right", &joybstraferight); AddJoystickControl(window, "Previous weapon", &joybprevweapon); AddJoystickControl(window, "Strafe", &joybstrafe); AddJoystickControl(window, "Next weapon", &joybnextweapon); // High values of joybspeed are used to activate the "always run mode" // trick in Vanilla Doom. If this has been enabled, not only is the // joybspeed value meaningless, but the control itself is useless. if (joybspeed < 20) { AddJoystickControl(window, "Run", &joybspeed); } if (gamemission == hexen || gamemission == strife) { AddJoystickControl(window, "Jump", &joybjump); } AddJoystickControl(window, "Activate menu", &joybmenu); AddJoystickControl(window, "Toggle Automap", &joybautomap); TXT_SignalConnect(joystick_button, "pressed", CalibrateJoystick, NULL); TXT_SetWindowAction(window, TXT_HORIZ_CENTER, TestConfigAction()); InitJoystick(); UpdateJoystickIndex(); SetJoystickButtonLabel(); UnInitJoystick(); } void BindJoystickVariables(void) { int i; M_BindIntVariable("use_joystick", &usejoystick); M_BindStringVariable("joystick_guid", &joystick_guid); M_BindIntVariable("joystick_index", &joystick_index); M_BindIntVariable("joystick_x_axis", &joystick_x_axis); M_BindIntVariable("joystick_y_axis", &joystick_y_axis); M_BindIntVariable("joystick_strafe_axis", &joystick_strafe_axis); M_BindIntVariable("joystick_x_invert", &joystick_x_invert); M_BindIntVariable("joystick_y_invert", &joystick_y_invert); M_BindIntVariable("joystick_strafe_invert", &joystick_strafe_invert); M_BindIntVariable("joystick_look_axis", &joystick_look_axis); M_BindIntVariable("joystick_look_invert", &joystick_look_invert); for (i = 0; i < NUM_VIRTUAL_BUTTONS; ++i) { char name[32]; M_snprintf(name, sizeof(name), "joystick_physical_button%i", i); M_BindIntVariable(name, &joystick_physical_buttons[i]); } }