ref: 8d3f31b70dd68e1bb49cbad976acc0119e329ef8
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]);
}
}