/*
* This file is part of the DXX-Rebirth project <https://www.dxx-rebirth.com/>.
* It is copyright by its individual contributors, as recorded in the
* project's Git history. See COPYING.txt at the top level for license
* terms and a link to the Git history.
*/
/*
*
* SDL joystick support
*
*/
#include <memory>
#include <vector>
#include <tuple>
#include <type_traits>
#include "joy.h"
#include "key.h"
#include "dxxerror.h"
#include "timer.h"
#include "console.h"
#include "event.h"
#include "u_mem.h"
#include "playsave.h"
#include "kconfig.h"
#include "compiler-range_for.h"
#if DXX_MAX_JOYSTICKS
#include "compiler-cf_assert.h"
#include "d_enumerate.h"
#include "d_range.h"
#include "partial_range.h"
#include <utility>
namespace dcx {
namespace {
int num_joysticks = 0;
std::vector<unsigned> joy_key_map;
/* This struct is a "virtual" joystick, which includes all the axes
* and buttons of every joystick found.
*/
static struct joyinfo {
#if DXX_MAX_BUTTONS_PER_JOYSTICK
std::array<uint8_t, JOY_MAX_BUTTONS> button_state;
#endif
} Joystick;
struct d_event_joystickbutton : d_event
{
const unsigned button;
constexpr d_event_joystickbutton(const event_type t, const unsigned b) :
d_event(t), button(b)
{
}
};
struct d_event_joystick_moved : d_event, d_event_joystick_axis_value
{
DXX_INHERIT_CONSTRUCTORS(d_event_joystick_moved, d_event);
};
class SDL_Joystick_deleter
{
public:
void operator()(SDL_Joystick *j) const
{
SDL_JoystickClose(j);
}
};
#ifndef DXX_USE_SIZE_SORTED_TUPLE
#define DXX_USE_SIZE_SORTED_TUPLE (__cplusplus > 201103L)
#endif
#if DXX_USE_SIZE_SORTED_TUPLE
template <typename T, std::size_t... Is, std::size_t... Js>
auto d_split_tuple(T &&t, std::index_sequence<Is...>, std::index_sequence<Js...>) ->
std::pair<
std::tuple<typename std::tuple_element<Is, T>::type...>,
std::tuple<typename std::tuple_element<sizeof...(Is) + Js, T>::type...>
>;
template <typename>
class d_size_sorted;
/* Given an input tuple T, define a public member `type` with the same
* members as T, but sorted such that sizeof(Ti) <= sizeof(Tj) for all i
* <= j.
*/
template <typename... Ts>
class d_size_sorted<std::tuple<Ts...>>
{
using split_tuple = decltype(d_split_tuple(
std::declval<std::tuple<Ts...>>(),
std::make_index_sequence<sizeof...(Ts) / 2>(),
std::make_index_sequence<(1 + sizeof...(Ts)) / 2>()
));
using first_type = typename split_tuple::first_type;
using second_type = typename split_tuple::second_type;
public:
using type = typename std::conditional<(sizeof(first_type) < sizeof(second_type)),
decltype(std::tuple_cat(std::declval<first_type>(), std::declval<second_type>())),
decltype(std::tuple_cat(std::declval<second_type>(), std::declval<first_type>()))
>::type;
};
template <typename T1>
class d_size_sorted<std::tuple<T1>>
{
public:
using type = std::tuple<T1>;
};
#endif
template <typename>
class ignore_empty {};
template <typename T>
using maybe_empty_array = typename std::conditional<T().empty(), ignore_empty<T>, T>::type;
/* This struct is an array, with one entry for each physical joystick
* found.
*/
class d_physical_joystick
{
#define for_each_tuple_item(HANDLE_VERB,VERB) \
HANDLE_VERB(handle) \
VERB(hat_map) \
VERB(button_map) \
VERB(axis_map) \
VERB(axis_value) \
VERB(axis_button_map) \
#if DXX_USE_SIZE_SORTED_TUPLE
template <typename... Ts>
using tuple_type = typename d_size_sorted<std::tuple<Ts...>>::type;
#define define_handle_getter(N) \
define_getter(N, tuple_member_type_##N)
#define define_array_getter(N) \
define_getter(N, maybe_empty_array<tuple_member_type_##N>)
#else
template <typename... Ts>
using tuple_type = std::tuple<Ts...>;
enum
{
#define define_enum(V) tuple_item_##V,
for_each_tuple_item(define_enum, define_enum)
#undef define_enum
};
/* std::get<index> does not handle the maybe_empty_array case, so
* reuse the same getter for both handle and array.
*/
#define define_handle_getter(N) \
define_getter(N, tuple_item_##N)
#define define_array_getter define_handle_getter
#endif
#define define_getter(N,V) \
auto &N() \
{ \
return std::get<V>(t); \
}
using tuple_member_type_handle = std::unique_ptr<SDL_Joystick, SDL_Joystick_deleter>;
//Note: Descent expects hats to be buttons, so these are indices into Joystick.buttons
struct tuple_member_type_hat_map : std::array<unsigned, DXX_MAX_HATS_PER_JOYSTICK> {};
struct tuple_member_type_button_map : std::array<unsigned, DXX_MAX_BUTTONS_PER_JOYSTICK> {};
struct tuple_member_type_axis_map : std::array<unsigned, DXX_MAX_AXES_PER_JOYSTICK> {};
struct tuple_member_type_axis_value : std::array<int, DXX_MAX_AXES_PER_JOYSTICK> {};
struct tuple_member_type_axis_button_map : std::array<unsigned, DXX_MAX_AXES_PER_JOYSTICK> {};
tuple_type<
tuple_member_type_handle,
maybe_empty_array<tuple_member_type_hat_map>,
maybe_empty_array<tuple_member_type_button_map>,
maybe_empty_array<tuple_member_type_axis_map>,
maybe_empty_array<tuple_member_type_axis_value>,
maybe_empty_array<tuple_member_type_axis_button_map>
> t;
public:
for_each_tuple_item(define_handle_getter, define_array_getter);
#undef define_handle_getter
#undef define_array_getter
#undef define_getter
#undef for_each_tuple_item
};
}
static std::array<d_physical_joystick, DXX_MAX_JOYSTICKS> SDL_Joysticks;
#if DXX_MAX_BUTTONS_PER_JOYSTICK
window_event_result joy_button_handler(const SDL_JoyButtonEvent *const jbe)
{
const unsigned button = SDL_Joysticks[jbe->which].button_map()[jbe->button];
Joystick.button_state[button] = jbe->state;
const d_event_joystickbutton event{
(jbe->type == SDL_JOYBUTTONDOWN) ? EVENT_JOYSTICK_BUTTON_DOWN : EVENT_JOYSTICK_BUTTON_UP,
button
};
con_printf(CON_DEBUG, "Sending event %s, button %d", (jbe->type == SDL_JOYBUTTONDOWN) ? "EVENT_JOYSTICK_BUTTON_DOWN" : "EVENT_JOYSTICK_JOYSTICK_UP", event.button);
return event_send(event);
}
#endif
#if DXX_MAX_HATS_PER_JOYSTICK
window_event_result joy_hat_handler(const SDL_JoyHatEvent *const jhe)
{
int hat = SDL_Joysticks[jhe->which].hat_map()[jhe->hat];
window_event_result highest_result(window_event_result::ignored);
//Save last state of the hat-button
//get current state of the hat-button
const auto jhe_value = jhe->value;
/* Every value must have exactly one bit set, and the union must
* cover the lower four bits. If any of these assertions fail, the
* loop will not work right.
*/
#define assert_hat_one_bit(M) \
static_assert(!((SDL_HAT_##M) & ((SDL_HAT_##M) - 1)), "unexpected " #M " mask");
assert_hat_one_bit(UP);
assert_hat_one_bit(RIGHT);
assert_hat_one_bit(DOWN);
assert_hat_one_bit(LEFT);
#undef assert_hat_one_bit
static_assert((SDL_HAT_UP | SDL_HAT_RIGHT | SDL_HAT_DOWN | SDL_HAT_LEFT) == 0xf, "unexpected hat mask");
//determine if a hat-button up or down event based on state and last_state
range_for (const unsigned i, xrange(4u))
{
const auto current_button_state = !!(jhe_value & (1 << i));
auto &saved_button_state = Joystick.button_state[hat + i];
if (saved_button_state == current_button_state)
// Same state as before
continue;
saved_button_state = current_button_state;
const d_event_joystickbutton event{current_button_state ? EVENT_JOYSTICK_BUTTON_DOWN : EVENT_JOYSTICK_BUTTON_UP, hat + i};
if (current_button_state) //last_state up, current state down
{
con_printf(CON_DEBUG, "Sending event EVENT_JOYSTICK_BUTTON_DOWN, button %d", event.button);
}
else //last_state down, current state up
{
con_printf(CON_DEBUG, "Sending event EVENT_JOYSTICK_BUTTON_UP, button %d", event.button);
}
highest_result = std::max(event_send(event), highest_result);
}
return highest_result;
}
#endif
#if DXX_MAX_AXES_PER_JOYSTICK
#if DXX_MAX_BUTTONS_PER_JOYSTICK || DXX_MAX_HATS_PER_JOYSTICK
static window_event_result send_axis_button_event(unsigned button, event_type e)
{
Joystick.button_state[button] = (e == EVENT_JOYSTICK_BUTTON_UP) ? 0 : 1;
const d_event_joystickbutton event{ e, button };
con_printf(CON_DEBUG, "Sending event %s, button %d", (e == EVENT_JOYSTICK_BUTTON_UP) ? "EVENT_JOYSTICK_BUTTON_UP" : "EVENT_JOYSTICK_BUTTON_DOWN", event.button);
return event_send(event);
}
window_event_result joy_axisbutton_handler(const SDL_JoyAxisEvent *const jae)
{
auto &js = SDL_Joysticks[jae->which];
auto axis_value = js.axis_value()[jae->axis];
auto button = js.axis_button_map()[jae->axis];
window_event_result highest_result(window_event_result::ignored);
// We have to hardcode a deadzone here. It's not mapped into the settings.
// We could add another deadzone slider called "axis button deadzone".
// I think it's safe to assume a 30% deadzone on analog button presses for now.
const decltype(axis_value) deadzone = 38;
auto prev_value = apply_deadzone(axis_value, deadzone);
auto new_value = apply_deadzone(jae->value/256, deadzone);
if (prev_value <= 0 && new_value >= 0) // positive pressed
{
if (prev_value < 0) // Do previous direction release first if the case
highest_result = std::max(send_axis_button_event(button + 1, EVENT_JOYSTICK_BUTTON_UP), highest_result);
if (new_value > 0)
highest_result = std::max(send_axis_button_event(button, EVENT_JOYSTICK_BUTTON_DOWN), highest_result);
}
else if (prev_value >= 0 && new_value <= 0) // negative pressed
{
if (prev_value > 0) // Do previous direction release first if the case
highest_result = std::max(send_axis_button_event(button, EVENT_JOYSTICK_BUTTON_UP), highest_result);
if (new_value < 0)
highest_result = std::max(send_axis_button_event(button + 1, EVENT_JOYSTICK_BUTTON_DOWN), highest_result);
}
return highest_result;
}
#endif
window_event_result joy_axis_handler(const SDL_JoyAxisEvent *const jae)
{
auto &js = SDL_Joysticks[jae->which];
const auto axis = js.axis_map()[jae->axis];
auto &axis_value = js.axis_value()[jae->axis];
// inaccurate stick is inaccurate. SDL might send SDL_JoyAxisEvent even if the value is the same as before.
if (axis_value == jae->value/256)
return window_event_result::ignored;
d_event_joystick_moved event{EVENT_JOYSTICK_MOVED};
event.value = axis_value = jae->value/256;
event.axis = axis;
con_printf(CON_DEBUG, "Sending event EVENT_JOYSTICK_MOVED, axis: %d, value: %d",event.axis, event.value);
return event_send(event);
}
#endif
/* ----------------------------------------------- */
static unsigned check_warn_joy_support_limit(const unsigned n, const char *const desc, const unsigned MAX)
{
if (n <= MAX)
{
con_printf(CON_NORMAL, "sdl-joystick: %d %ss", n, desc);
return n;
}
Warning("sdl-joystick: found %d %ss, only %d supported.\n", n, desc, MAX);
return MAX;
}
void joy_init()
{
if (SDL_Init(SDL_INIT_JOYSTICK) < 0) {
con_printf(CON_NORMAL, "sdl-joystick: initialisation failed: %s.",SDL_GetError());
return;
}
Joystick = {};
#if DXX_MAX_AXES_PER_JOYSTICK
joyaxis_text.clear();
#endif
joybutton_text.clear();
joy_key_map.clear();
const auto n = check_warn_joy_support_limit(SDL_NumJoysticks(), "joystick", DXX_MAX_JOYSTICKS);
cf_assert(n <= DXX_MAX_JOYSTICKS);
unsigned joystick_n_buttons = 0, joystick_n_axes = 0;
range_for (const unsigned i, xrange(n))
{
auto &joystick = SDL_Joysticks[num_joysticks];
const auto handle = SDL_JoystickOpen(i);
joystick.handle().reset(handle);
#if SDL_MAJOR_VERSION == 1
con_printf(CON_NORMAL, "sdl-joystick %d: %s", i, SDL_JoystickName(i));
#else
con_printf(CON_NORMAL, "sdl-joystick %d: %s", i, SDL_JoystickName(handle));
#endif
if (handle)
{
#if DXX_MAX_AXES_PER_JOYSTICK
const auto n_axes = check_warn_joy_support_limit(SDL_JoystickNumAxes(handle), "axe", DXX_MAX_AXES_PER_JOYSTICK);
joyaxis_text.resize(joyaxis_text.size() + n_axes);
range_for (auto &&e, enumerate(partial_range(joystick.axis_map(), n_axes), 1))
{
cf_assert(e.idx <= DXX_MAX_AXES_PER_JOYSTICK);
auto &text = joyaxis_text[joystick_n_axes];
e.value = joystick_n_axes++;
snprintf(&text[0], sizeof(text), "J%d A%u", i + 1, e.idx);
}
#else
const auto n_axes = 0;
#endif
const auto n_buttons = check_warn_joy_support_limit(SDL_JoystickNumButtons(handle), "button", DXX_MAX_BUTTONS_PER_JOYSTICK);
const auto n_hats = check_warn_joy_support_limit(SDL_JoystickNumHats(handle), "hat", DXX_MAX_HATS_PER_JOYSTICK);
const auto n_virtual_buttons = n_buttons + (4 * n_hats) + (2 * n_axes);
joybutton_text.resize(joybutton_text.size() + n_virtual_buttons);
joy_key_map.resize(joy_key_map.size() + n_virtual_buttons, 0);
#if DXX_MAX_BUTTONS_PER_JOYSTICK
range_for (auto &&e, enumerate(partial_range(joystick.button_map(), n_buttons), 1))
{
switch (e.idx) {
case 1: joy_key_map[joystick_n_buttons] = KEY_ENTER; break;
case 2: joy_key_map[joystick_n_buttons] = KEY_ESC; break;
case 3: joy_key_map[joystick_n_buttons] = KEY_SPACEBAR; break;
case 4: joy_key_map[joystick_n_buttons] = KEY_DELETE; break;
default: break;
}
auto &text = joybutton_text[joystick_n_buttons];
e.value = joystick_n_buttons++;
cf_assert(e.idx <= DXX_MAX_BUTTONS_PER_JOYSTICK);
snprintf(&text[0], sizeof(text), "J%u B%u", i + 1, e.idx);
}
#endif
#if DXX_MAX_HATS_PER_JOYSTICK
range_for (auto &&e, enumerate(partial_range(joystick.hat_map(), n_hats), 1))
{
e.value = joystick_n_buttons;
cf_assert(e.idx <= DXX_MAX_HATS_PER_JOYSTICK);
//a hat counts as four buttons
joy_key_map[joystick_n_buttons] = KEY_UP;
snprintf(&joybutton_text[joystick_n_buttons++][0], sizeof(joybutton_text[0]), "J%u H%u%c", i + 1, e.idx, 0202);
joy_key_map[joystick_n_buttons] = KEY_RIGHT;
snprintf(&joybutton_text[joystick_n_buttons++][0], sizeof(joybutton_text[0]), "J%u H%u%c", i + 1, e.idx, 0177);
joy_key_map[joystick_n_buttons] = KEY_DOWN;
snprintf(&joybutton_text[joystick_n_buttons++][0], sizeof(joybutton_text[0]), "J%u H%u%c", i + 1, e.idx, 0200);
joy_key_map[joystick_n_buttons] = KEY_LEFT;
snprintf(&joybutton_text[joystick_n_buttons++][0], sizeof(joybutton_text[0]), "J%u H%u%c", i + 1, e.idx, 0201);
}
#endif
#if DXX_MAX_AXES_PER_JOYSTICK
range_for (auto &&e, enumerate(partial_range(joystick.axis_button_map(), n_axes), 1))
{
e.value = joystick_n_buttons;
cf_assert(e.idx <= DXX_MAX_AXES_PER_JOYSTICK);
//an axis count as 2 buttons. negative - and positive +
joy_key_map[joystick_n_buttons] = (e.idx == 1) ? KEY_RIGHT : (e.idx == 2) ? KEY_DOWN : 0;
snprintf(&joybutton_text[joystick_n_buttons++][0], sizeof(joybutton_text[0]), "J%u -A%u", i + 1, e.idx);
joy_key_map[joystick_n_buttons] = (e.idx == 1) ? KEY_LEFT : (e.idx == 2) ? KEY_UP : 0;
snprintf(&joybutton_text[joystick_n_buttons++][0], sizeof(joybutton_text[0]), "J%u +A%u", i + 1, e.idx);
}
#endif
num_joysticks++;
}
else
con_puts(CON_NORMAL, "sdl-joystick: initialization failed!");
con_printf(CON_NORMAL, "sdl-joystick: %d axes (total)", joystick_n_axes);
con_printf(CON_NORMAL, "sdl-joystick: %d buttons (total)", joystick_n_buttons);
}
}
void joy_close()
{
range_for (auto &j, SDL_Joysticks)
j.handle().reset();
#if DXX_MAX_AXES_PER_JOYSTICK
joyaxis_text.clear();
#endif
joybutton_text.clear();
}
const d_event_joystick_axis_value &event_joystick_get_axis(const d_event &event)
{
auto &e = static_cast<const d_event_joystick_moved &>(event);
Assert(e.type == EVENT_JOYSTICK_MOVED);
return e;
}
void joy_flush()
{
if (!num_joysticks)
return;
static_assert(SDL_RELEASED == uint8_t(), "SDL_RELEASED not 0.");
#if DXX_MAX_BUTTONS_PER_JOYSTICK
Joystick.button_state = {};
#endif
#if DXX_MAX_AXES_PER_JOYSTICK
range_for (auto &j, SDL_Joysticks)
j.axis_value() = {};
#endif
}
int event_joystick_get_button(const d_event &event)
{
auto &e = static_cast<const d_event_joystickbutton &>(event);
Assert(e.type == EVENT_JOYSTICK_BUTTON_DOWN || e.type == EVENT_JOYSTICK_BUTTON_UP);
return e.button;
}
int apply_deadzone(int value, int deadzone)
{
if (value > deadzone)
return ((value - deadzone) * 128) / (128 - deadzone);
else if (value < -deadzone)
return ((value + deadzone) * 128) / (128 - deadzone);
else
return 0;
}
bool joy_translate_menu_key(const d_event &event) {
if (event.type != EVENT_JOYSTICK_BUTTON_DOWN)
return false;
#if DXX_MAX_JOYSTICKS
auto &e = static_cast<const d_event_joystickbutton &>(event);
assert(e.button < joy_key_map.size());
auto key = joy_key_map[e.button];
if (key)
{
event_keycommand_send(key);
return true;
}
return false;
#endif
}
}
#endif