435 lines
16 KiB
C++
435 lines
16 KiB
C++
#include "input.h"
|
|
|
|
#include <SDL3/SDL.h> // Para SDL_LogInfo, SDL_LogCategory, SDL_GetGamepa...
|
|
|
|
#include <algorithm> // Para find
|
|
#include <cstddef> // Para size_t
|
|
#include <iterator> // Para distance
|
|
#include <memory> // Para std::unique_ptr
|
|
#include <unordered_map> // Para unordered_map, _Node_const_iterator, operat...
|
|
#include <utility> // Para pair
|
|
|
|
// Singleton
|
|
Input *Input::instance = nullptr;
|
|
|
|
// Inicializa la instancia única del singleton
|
|
void Input::init(const std::string &game_controller_db_path) { Input::instance = new Input(game_controller_db_path); }
|
|
|
|
// Libera la instancia
|
|
void Input::destroy() { delete Input::instance; }
|
|
|
|
// Obtiene la instancia
|
|
auto Input::get() -> Input * { return Input::instance; }
|
|
|
|
// Constructor
|
|
Input::Input(std::string game_controller_db_path)
|
|
: game_controller_db_path_(std::move(game_controller_db_path)) {
|
|
// Inicializa el subsistema SDL_INIT_GAMEPAD
|
|
initSDLGamePad();
|
|
|
|
// Inicializa los vectores
|
|
key_bindings_.resize(static_cast<int>(Action::SIZE), KeyBindings());
|
|
controller_bindings_.resize(num_gamepads_, std::vector<ControllerBindings>(static_cast<int>(Action::SIZE), ControllerBindings()));
|
|
|
|
// Listado de los inputs para jugar que utilizan botones, ni palancas ni crucetas
|
|
button_inputs_ = {Action::FIRE_LEFT, Action::FIRE_CENTER, Action::FIRE_RIGHT, Action::START};
|
|
}
|
|
|
|
// Asigna inputs a teclas
|
|
void Input::bindKey(Action input, SDL_Scancode code) {
|
|
key_bindings_.at(static_cast<int>(input)).scancode = code;
|
|
}
|
|
|
|
// Asigna inputs a botones del mando
|
|
void Input::bindGameControllerButton(int controller_index, Action input, SDL_GamepadButton button) {
|
|
if (controller_index < num_gamepads_) {
|
|
controller_bindings_.at(controller_index).at(static_cast<int>(input)).button = button;
|
|
}
|
|
}
|
|
|
|
// Asigna inputs a botones del mando
|
|
void Input::bindGameControllerButton(int controller_index, Action input_target, Action input_source) {
|
|
if (controller_index < num_gamepads_) {
|
|
controller_bindings_.at(controller_index).at(static_cast<int>(input_target)).button = controller_bindings_.at(controller_index).at(static_cast<int>(input_source)).button;
|
|
}
|
|
}
|
|
|
|
// Comprueba si un input esta activo
|
|
auto Input::checkAction(Action input, bool repeat, Device device, int controller_index) -> bool {
|
|
bool success_keyboard = false;
|
|
bool success_controller = false;
|
|
const int INPUT_INDEX = static_cast<int>(input);
|
|
|
|
if (device == Device::KEYBOARD || device == Device::ANY) {
|
|
if (repeat) { // El usuario quiere saber si está pulsada (estado mantenido)
|
|
success_keyboard = key_bindings_[INPUT_INDEX].is_held;
|
|
} else { // El usuario quiere saber si ACABA de ser pulsada (evento de un solo fotograma)
|
|
success_keyboard = key_bindings_[INPUT_INDEX].just_pressed;
|
|
}
|
|
}
|
|
|
|
if (gameControllerFound() && controller_index >= 0 && controller_index < num_gamepads_) {
|
|
if ((device == Device::CONTROLLER) || (device == Device::ANY)) {
|
|
success_controller = checkAxisInput(input, controller_index, repeat);
|
|
|
|
if (!success_controller) {
|
|
if (repeat) { // El usuario quiere saber si está pulsada (estado mantenido)
|
|
success_controller = controller_bindings_.at(controller_index).at(INPUT_INDEX).is_held;
|
|
} else { // El usuario quiere saber si ACABA de ser pulsada (evento de un solo fotograma)
|
|
success_controller = controller_bindings_.at(controller_index).at(INPUT_INDEX).just_pressed;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return (success_keyboard || success_controller);
|
|
}
|
|
|
|
// Comprueba si hay almenos un input activo
|
|
auto Input::checkAnyInput(Device device, int controller_index) -> bool {
|
|
// Obtenemos el número total de acciones posibles para iterar sobre ellas.
|
|
const int NUM_ACTIONS = static_cast<int>(Action::SIZE);
|
|
|
|
// --- Comprobación del Teclado ---
|
|
if (device == Device::KEYBOARD || device == Device::ANY) {
|
|
for (int i = 0; i < NUM_ACTIONS; ++i) {
|
|
// Simplemente leemos el estado pre-calculado por Input::update().
|
|
// Ya no se llama a SDL_GetKeyboardState ni se modifica el estado '.active'.
|
|
if (key_bindings_.at(i).just_pressed) {
|
|
return true; // Se encontró una acción recién pulsada.
|
|
}
|
|
}
|
|
}
|
|
|
|
// --- Comprobación del Mando ---
|
|
// Comprobamos si hay mandos y si el índice solicitado es válido.
|
|
if (gameControllerFound() && controller_index >= 0 && controller_index < num_gamepads_) {
|
|
if (device == Device::CONTROLLER || device == Device::ANY) {
|
|
// Bucle CORREGIDO: Iteramos sobre todas las acciones, no sobre el número de mandos.
|
|
for (int i = 0; i < NUM_ACTIONS; ++i) {
|
|
// Leemos el estado pre-calculado para el mando y la acción específicos.
|
|
if (controller_bindings_.at(controller_index).at(i).just_pressed) {
|
|
return true; // Se encontró una acción recién pulsada en el mando.
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Si llegamos hasta aquí, no se detectó ninguna nueva pulsación.
|
|
return false;
|
|
}
|
|
|
|
// Comprueba si hay algún botón pulsado. Devuelve 0 en caso de no encontrar nada o el indice del dispositivo + 1. Se hace así para poder gastar el valor devuelto como un valor "booleano"
|
|
auto Input::checkAnyButton(bool repeat) -> int {
|
|
// Solo comprueba los botones definidos previamente
|
|
for (auto bi : button_inputs_) {
|
|
// Comprueba el teclado
|
|
if (checkAction(bi, repeat, Device::KEYBOARD)) {
|
|
return 1;
|
|
}
|
|
|
|
// Comprueba los mandos
|
|
for (int i = 0; i < num_gamepads_; ++i) {
|
|
if (checkAction(bi, repeat, Device::CONTROLLER, i)) {
|
|
return i + 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
// Busca si hay mandos conectados
|
|
/*auto Input::discoverGameControllers() -> bool {
|
|
bool found = false;
|
|
|
|
if (SDL_AddGamepadMappingsFromFile(game_controller_db_path_.c_str()) < 0) {
|
|
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Error: could not load %s file: %s", game_controller_db_path_.c_str(), SDL_GetError());
|
|
}
|
|
|
|
// En SDL3, SDL_GetJoysticks devuelve un array de IDs, no un contador
|
|
SDL_JoystickID *joystick_ids = SDL_GetJoysticks(&num_joysticks_);
|
|
num_gamepads_ = 0;
|
|
|
|
// Cuenta el número de mandos
|
|
joysticks_.clear();
|
|
for (int i = 0; i < num_joysticks_; ++i) {
|
|
// Usar el ID del joystick, no el índice
|
|
auto *joy = SDL_OpenJoystick(joystick_ids[i]);
|
|
joysticks_.push_back(joy);
|
|
|
|
// En SDL3, SDL_IsGamepad toma un SDL_JoystickID, no un índice
|
|
if (SDL_IsGamepad(joystick_ids[i])) {
|
|
num_gamepads_++;
|
|
}
|
|
}
|
|
|
|
SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION, ">> LOOKING FOR GAME CONTROLLERS");
|
|
if (num_joysticks_ != num_gamepads_) {
|
|
SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION, "Joysticks found: %d", num_joysticks_);
|
|
SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION, "Gamepads found : %d", num_gamepads_);
|
|
} else {
|
|
SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION, "Gamepads found: %d", num_gamepads_);
|
|
}
|
|
|
|
if (num_gamepads_ > 0) {
|
|
found = true;
|
|
|
|
// Recorrer los joysticks y abrir solo los que son gamepads
|
|
for (int i = 0; i < num_joysticks_; i++) {
|
|
if (SDL_IsGamepad(joystick_ids[i])) {
|
|
// Abre el mando usando el ID del joystick
|
|
auto *pad = SDL_OpenGamepad(joystick_ids[i]);
|
|
if (pad != nullptr) {
|
|
connected_controllers_.push_back(pad);
|
|
|
|
// Obtener el nombre usando el ID del joystick
|
|
const char *name_cstr = SDL_GetGamepadNameForID(joystick_ids[i]);
|
|
std::string name = (name_cstr != nullptr) ? name_cstr : "Unknown Gamepad";
|
|
|
|
SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION, "#%d: %s", i, name.c_str());
|
|
controller_names_.push_back(name);
|
|
} else {
|
|
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Failed to open gamepad %d: %s", joystick_ids[i], SDL_GetError());
|
|
}
|
|
}
|
|
}
|
|
|
|
SDL_SetGamepadEventsEnabled(true);
|
|
}
|
|
|
|
// Liberar el array de IDs
|
|
if (joystick_ids != nullptr) {
|
|
SDL_free(joystick_ids);
|
|
}
|
|
|
|
SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION, "\n>> FINISHED LOOKING FOR GAME CONTROLLERS");
|
|
return found;
|
|
}*/
|
|
|
|
// Comprueba si hay algun mando conectado
|
|
auto Input::gameControllerFound() const -> bool { return num_gamepads_ > 0; }
|
|
|
|
// Obten el nombre de un mando de juego
|
|
auto Input::getControllerName(int controller_index) const -> std::string { return num_gamepads_ > 0 ? controller_names_.at(controller_index) : std::string(); }
|
|
|
|
// Obten el número de mandos conectados
|
|
auto Input::getNumControllers() const -> int { return num_gamepads_; }
|
|
|
|
// Obtiene el indice del controlador a partir de un event.id
|
|
auto Input::getJoyIndex(SDL_JoystickID id) const -> int {
|
|
for (int i = 0; i < num_joysticks_; ++i) {
|
|
if (SDL_GetJoystickID(joysticks_[i]) == id) {
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
// Muestra por consola los controles asignados
|
|
void Input::printBindings(Device device, int controller_index) const {
|
|
if (device == Device::ANY || device == Device::KEYBOARD) {
|
|
return;
|
|
}
|
|
|
|
if (device == Device::CONTROLLER) {
|
|
if (controller_index >= num_gamepads_) {
|
|
return;
|
|
}
|
|
|
|
// Muestra el nombre del mando
|
|
SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION, "\n%s", controller_names_.at(controller_index).c_str());
|
|
|
|
// Muestra los botones asignados
|
|
for (auto bi : button_inputs_) {
|
|
SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION, "%s : %d", inputToString(bi).c_str(), controller_bindings_.at(controller_index).at(static_cast<int>(bi)).button);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Obtiene el SDL_GamepadButton asignado a un input
|
|
auto Input::getControllerBinding(int controller_index, Action input) const -> SDL_GamepadButton {
|
|
return controller_bindings_[controller_index][static_cast<int>(input)].button;
|
|
}
|
|
|
|
// Obtiene el indice a partir del nombre del mando
|
|
auto Input::getIndexByName(const std::string &name) const -> int {
|
|
auto it = std::find(controller_names_.begin(), controller_names_.end(), name);
|
|
return it != controller_names_.end() ? std::distance(controller_names_.begin(), it) : -1;
|
|
}
|
|
|
|
// Convierte un InputAction a std::string
|
|
auto Input::inputToString(Action input) -> std::string {
|
|
switch (input) {
|
|
case Action::FIRE_LEFT:
|
|
return "input_fire_left";
|
|
case Action::FIRE_CENTER:
|
|
return "input_fire_center";
|
|
case Action::FIRE_RIGHT:
|
|
return "input_fire_right";
|
|
case Action::START:
|
|
return "input_start";
|
|
case Action::SERVICE:
|
|
return "input_service";
|
|
default:
|
|
return "";
|
|
}
|
|
}
|
|
|
|
// Convierte un std::string a InputAction
|
|
auto Input::stringToInput(const std::string &name) -> Action {
|
|
static const std::unordered_map<std::string, Action> INPUT_MAP = {
|
|
{"input_fire_left", Action::FIRE_LEFT},
|
|
{"input_fire_center", Action::FIRE_CENTER},
|
|
{"input_fire_right", Action::FIRE_RIGHT},
|
|
{"input_start", Action::START},
|
|
{"input_service", Action::SERVICE}};
|
|
|
|
auto it = INPUT_MAP.find(name);
|
|
return it != INPUT_MAP.end() ? it->second : Action::NONE;
|
|
}
|
|
|
|
// Comprueba el eje del mando
|
|
auto Input::checkAxisInput(Action input, int controller_index, bool repeat) -> bool {
|
|
// Umbral para considerar el eje como activo
|
|
bool axis_active_now = false;
|
|
|
|
switch (input) {
|
|
case Action::LEFT:
|
|
axis_active_now = SDL_GetGamepadAxis(connected_controllers_[controller_index], SDL_GAMEPAD_AXIS_LEFTX) < -AXIS_THRESHOLD;
|
|
break;
|
|
case Action::RIGHT:
|
|
axis_active_now = SDL_GetGamepadAxis(connected_controllers_[controller_index], SDL_GAMEPAD_AXIS_LEFTX) > AXIS_THRESHOLD;
|
|
break;
|
|
case Action::UP:
|
|
axis_active_now = SDL_GetGamepadAxis(connected_controllers_[controller_index], SDL_GAMEPAD_AXIS_LEFTY) < -AXIS_THRESHOLD;
|
|
break;
|
|
case Action::DOWN:
|
|
axis_active_now = SDL_GetGamepadAxis(connected_controllers_[controller_index], SDL_GAMEPAD_AXIS_LEFTY) > AXIS_THRESHOLD;
|
|
break;
|
|
default:
|
|
return false;
|
|
}
|
|
|
|
// Referencia al binding correspondiente
|
|
auto &binding = controller_bindings_.at(controller_index).at(static_cast<int>(input));
|
|
|
|
if (repeat) {
|
|
// Si se permite repetir, simplemente devolvemos el estado actual
|
|
return axis_active_now;
|
|
} // Si no se permite repetir, aplicamos la lógica de transición
|
|
if (axis_active_now && !binding.axis_active) {
|
|
// Transición de inactivo a activo
|
|
binding.axis_active = true;
|
|
return true;
|
|
}
|
|
if (!axis_active_now && binding.axis_active) {
|
|
// Transición de activo a inactivo
|
|
binding.axis_active = false;
|
|
}
|
|
// Mantener el estado actual
|
|
return false;
|
|
}
|
|
|
|
void Input::initSDLGamePad() {
|
|
if (SDL_WasInit(SDL_INIT_GAMEPAD) != 1) {
|
|
if (!SDL_InitSubSystem(SDL_INIT_GAMEPAD)) {
|
|
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "SDL_GAMEPAD could not initialize! SDL Error: %s", SDL_GetError());
|
|
} else {
|
|
//SDL_LogInfo(SDL_LOG_CATEGORY_TEST, "\n** SDL_GAMEPAD: INITIALIZING");
|
|
//discoverGameControllers();
|
|
//printConnectedGamepads();
|
|
SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION, "** Input System initialized successfully\n");
|
|
}
|
|
}
|
|
}
|
|
|
|
void Input::resetInputStates() {
|
|
// Resetear todos los KeyBindings.active a false
|
|
for (auto &key : key_bindings_) {
|
|
key.is_held = false;
|
|
key.just_pressed = false;
|
|
}
|
|
// Resetear todos los ControllerBindings.active a false
|
|
for (auto &controller_vec : controller_bindings_) {
|
|
for (auto &binding : controller_vec) {
|
|
binding.is_held = false;
|
|
binding.just_pressed = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
void Input::update() {
|
|
// --- TECLADO ---
|
|
const bool *key_states = SDL_GetKeyboardState(nullptr);
|
|
|
|
for (auto &key_binding : key_bindings_) {
|
|
bool key_is_down_now = key_states[key_binding.scancode];
|
|
|
|
// El estado .is_held del fotograma anterior nos sirve para saber si es un pulso nuevo
|
|
key_binding.just_pressed = key_is_down_now && !key_binding.is_held;
|
|
key_binding.is_held = key_is_down_now;
|
|
}
|
|
|
|
// --- MANDOS ---
|
|
for (int c = 0; c < num_gamepads_; ++c) {
|
|
for (size_t i = 0; i < controller_bindings_[c].size(); ++i) {
|
|
bool button_is_down_now = static_cast<int>(SDL_GetGamepadButton(connected_controllers_.at(c), controller_bindings_.at(c).at(i).button)) != 0;
|
|
|
|
// El estado .is_held del fotograma anterior nos sirve para saber si es un pulso nuevo
|
|
controller_bindings_[c][i].just_pressed = button_is_down_now && !controller_bindings_[c][i].is_held;
|
|
controller_bindings_[c][i].is_held = button_is_down_now;
|
|
}
|
|
}
|
|
}
|
|
|
|
void Input::handleEvent(const SDL_Event &event) {
|
|
switch (event.type) {
|
|
case SDL_EVENT_GAMEPAD_ADDED:
|
|
add_gamepad(event.gdevice.which);
|
|
break;
|
|
case SDL_EVENT_GAMEPAD_REMOVED:
|
|
remove_gamepad(event.gdevice.which);
|
|
break;
|
|
}
|
|
}
|
|
|
|
void Input::add_gamepad(int device_index) {
|
|
SDL_Gamepad *pad = SDL_OpenGamepad(device_index);
|
|
if (!pad) {
|
|
std::cerr << "Error al abrir el gamepad: " << SDL_GetError() << "\n";
|
|
return;
|
|
}
|
|
|
|
auto gamepad = std::make_unique<Gamepad>(pad);
|
|
std::cout << "Gamepad conectado (ID " << gamepad->instance_id << ")\n";
|
|
gamepads.push_back(std::move(gamepad));
|
|
}
|
|
|
|
void Input::remove_gamepad(SDL_JoystickID id) {
|
|
auto it = std::remove_if(gamepads.begin(), gamepads.end(), [id](const std::unique_ptr<Gamepad> &gamepad) {
|
|
return gamepad->instance_id == id;
|
|
});
|
|
|
|
if (it != gamepads.end()) {
|
|
std::cout << "Gamepad desconectado (ID " << id << ")\n";
|
|
gamepads.erase(it, gamepads.end());
|
|
} else {
|
|
std::cerr << "No se encontró el gamepad con ID " << id << "\n";
|
|
}
|
|
}
|
|
|
|
void Input::printConnectedGamepads() const {
|
|
if (gamepads.empty()) {
|
|
std::cout << "No hay gamepads conectados.\n";
|
|
return;
|
|
}
|
|
|
|
std::cout << "Gamepads conectados:\n";
|
|
for (const auto& gamepad : gamepads) {
|
|
const char* name = SDL_GetGamepadName(gamepad->pad);
|
|
std::cout << " - ID: " << gamepad->instance_id
|
|
<< ", Nombre: " << (name ? name : "Desconocido") << "\n";
|
|
}
|
|
}
|