344 lines
10 KiB
C++
344 lines
10 KiB
C++
#include "input.h"
|
|
|
|
#include <SDL3/SDL.h>
|
|
|
|
#include <iostream> // for basic_ostream, operator<<, cout, basi...
|
|
|
|
// Constructor
|
|
Input::Input(std::string file) {
|
|
// Fichero gamecontrollerdb.txt
|
|
dbPath = file;
|
|
|
|
// Inicializa las variables
|
|
keyBindings_t kb;
|
|
kb.scancode = 0;
|
|
kb.active = false;
|
|
keyBindings.resize(input_number_of_inputs, kb);
|
|
|
|
GameControllerBindings_t gcb;
|
|
gcb.button = SDL_GAMEPAD_BUTTON_INVALID;
|
|
gcb.active = false;
|
|
gameControllerBindings.resize(input_number_of_inputs, gcb);
|
|
|
|
numGamepads = 0;
|
|
verbose = true;
|
|
enabled = true;
|
|
}
|
|
|
|
// Destructor
|
|
Input::~Input() {
|
|
for (auto *pad : connectedControllers) {
|
|
if (pad != nullptr) {
|
|
SDL_CloseGamepad(pad);
|
|
}
|
|
}
|
|
connectedControllers.clear();
|
|
connectedControllerIds.clear();
|
|
controllerNames.clear();
|
|
numGamepads = 0;
|
|
}
|
|
|
|
// Actualiza el estado del objeto
|
|
void Input::update() {
|
|
if (disabledUntil == d_keyPressed && !checkAnyInput()) {
|
|
enable();
|
|
}
|
|
}
|
|
|
|
// Asigna inputs a teclas
|
|
void Input::bindKey(Uint8 input, SDL_Scancode code) {
|
|
keyBindings[input].scancode = code;
|
|
}
|
|
|
|
// Asigna inputs a botones del mando
|
|
void Input::bindGameControllerButton(Uint8 input, SDL_GamepadButton button) {
|
|
gameControllerBindings[input].button = button;
|
|
}
|
|
|
|
// Comprueba si un input esta activo
|
|
bool Input::checkInput(Uint8 input, bool repeat, int device, int index) {
|
|
if (!enabled) {
|
|
return false;
|
|
}
|
|
|
|
bool successKeyboard = false;
|
|
bool successGameController = false;
|
|
|
|
if (device == INPUT_USE_ANY) {
|
|
index = 0;
|
|
}
|
|
|
|
if (device == INPUT_USE_KEYBOARD || device == INPUT_USE_ANY) {
|
|
const bool *keyStates = SDL_GetKeyboardState(nullptr);
|
|
|
|
if (repeat) {
|
|
if (keyStates[keyBindings[input].scancode]) {
|
|
successKeyboard = true;
|
|
} else {
|
|
successKeyboard = false;
|
|
}
|
|
} else {
|
|
if (!keyBindings[input].active) {
|
|
if (keyStates[keyBindings[input].scancode]) {
|
|
keyBindings[input].active = true;
|
|
successKeyboard = true;
|
|
} else {
|
|
successKeyboard = false;
|
|
}
|
|
} else {
|
|
if (!keyStates[keyBindings[input].scancode]) {
|
|
keyBindings[input].active = false;
|
|
successKeyboard = false;
|
|
} else {
|
|
successKeyboard = false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (gameControllerFound() && index >= 0 && index < (int)connectedControllers.size())
|
|
if ((device == INPUT_USE_GAMECONTROLLER) || (device == INPUT_USE_ANY)) {
|
|
if (repeat) {
|
|
if (SDL_GetGamepadButton(connectedControllers[index], gameControllerBindings[input].button)) {
|
|
successGameController = true;
|
|
} else {
|
|
successGameController = false;
|
|
}
|
|
} else {
|
|
if (!gameControllerBindings[input].active) {
|
|
if (SDL_GetGamepadButton(connectedControllers[index], gameControllerBindings[input].button)) {
|
|
gameControllerBindings[input].active = true;
|
|
successGameController = true;
|
|
} else {
|
|
successGameController = false;
|
|
}
|
|
} else {
|
|
if (!SDL_GetGamepadButton(connectedControllers[index], gameControllerBindings[input].button)) {
|
|
gameControllerBindings[input].active = false;
|
|
successGameController = false;
|
|
} else {
|
|
successGameController = false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return (successKeyboard || successGameController);
|
|
}
|
|
|
|
// Comprueba si hay almenos un input activo
|
|
bool Input::checkAnyInput(int device, int index) {
|
|
if (device == INPUT_USE_ANY) {
|
|
index = 0;
|
|
}
|
|
|
|
if (device == INPUT_USE_KEYBOARD || device == INPUT_USE_ANY) {
|
|
const bool *mKeystates = SDL_GetKeyboardState(nullptr);
|
|
|
|
for (int i = 0; i < (int)keyBindings.size(); ++i) {
|
|
if (mKeystates[keyBindings[i].scancode]) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (gameControllerFound() && index >= 0 && index < (int)connectedControllers.size()) {
|
|
if (device == INPUT_USE_GAMECONTROLLER || device == INPUT_USE_ANY) {
|
|
for (int i = 0; i < (int)gameControllerBindings.size(); ++i) {
|
|
if (SDL_GetGamepadButton(connectedControllers[index], gameControllerBindings[i].button)) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
// Construye el nombre visible de un mando
|
|
std::string Input::buildControllerName(SDL_Gamepad *pad, int padIndex) {
|
|
(void)padIndex;
|
|
const char *padName = SDL_GetGamepadName(pad);
|
|
std::string name = padName ? padName : "Unknown";
|
|
if (name.size() > 25) {
|
|
name.resize(25);
|
|
}
|
|
return name;
|
|
}
|
|
|
|
// Busca si hay un mando conectado. Cierra y limpia el estado previo para
|
|
// que la función sea idempotente si se invoca más de una vez.
|
|
bool Input::discoverGameController() {
|
|
// Cierra los mandos ya abiertos y limpia los vectores paralelos
|
|
for (auto *pad : connectedControllers) {
|
|
if (pad != nullptr) {
|
|
SDL_CloseGamepad(pad);
|
|
}
|
|
}
|
|
connectedControllers.clear();
|
|
connectedControllerIds.clear();
|
|
controllerNames.clear();
|
|
numGamepads = 0;
|
|
|
|
bool found = false;
|
|
|
|
if (SDL_WasInit(SDL_INIT_GAMEPAD) != SDL_INIT_GAMEPAD) {
|
|
SDL_InitSubSystem(SDL_INIT_GAMEPAD);
|
|
}
|
|
|
|
if (SDL_AddGamepadMappingsFromFile(dbPath.c_str()) < 0) {
|
|
if (verbose) {
|
|
std::cout << "Error, could not load " << dbPath.c_str() << " file: " << SDL_GetError() << std::endl;
|
|
}
|
|
}
|
|
|
|
int nJoysticks = 0;
|
|
SDL_JoystickID *joysticks = SDL_GetJoysticks(&nJoysticks);
|
|
|
|
if (joysticks) {
|
|
int gamepadCount = 0;
|
|
for (int i = 0; i < nJoysticks; ++i) {
|
|
if (SDL_IsGamepad(joysticks[i])) {
|
|
gamepadCount++;
|
|
}
|
|
}
|
|
|
|
if (verbose) {
|
|
std::cout << "\nChecking for game controllers...\n";
|
|
std::cout << nJoysticks << " joysticks found, " << gamepadCount << " are gamepads\n";
|
|
}
|
|
|
|
if (gamepadCount > 0) {
|
|
found = true;
|
|
int padIndex = 0;
|
|
|
|
for (int i = 0; i < nJoysticks; i++) {
|
|
if (!SDL_IsGamepad(joysticks[i])) continue;
|
|
|
|
SDL_Gamepad *pad = SDL_OpenGamepad(joysticks[i]);
|
|
if (pad != nullptr) {
|
|
const std::string name = buildControllerName(pad, padIndex);
|
|
connectedControllers.push_back(pad);
|
|
connectedControllerIds.push_back(joysticks[i]);
|
|
controllerNames.push_back(name);
|
|
numGamepads++;
|
|
padIndex++;
|
|
if (verbose) {
|
|
std::cout << name << std::endl;
|
|
}
|
|
} else {
|
|
if (verbose) {
|
|
std::cout << "SDL_GetError() = " << SDL_GetError() << std::endl;
|
|
}
|
|
}
|
|
}
|
|
|
|
SDL_SetGamepadEventsEnabled(true);
|
|
}
|
|
|
|
SDL_free(joysticks);
|
|
}
|
|
|
|
return found;
|
|
}
|
|
|
|
// Procesa un evento SDL_EVENT_GAMEPAD_ADDED
|
|
bool Input::handleGamepadAdded(SDL_JoystickID jid, std::string &outName) {
|
|
if (!SDL_IsGamepad(jid)) {
|
|
return false;
|
|
}
|
|
|
|
// Si el mando ya está registrado no hace nada (ej. evento retroactivo tras el scan inicial)
|
|
for (SDL_JoystickID existing : connectedControllerIds) {
|
|
if (existing == jid) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
SDL_Gamepad *pad = SDL_OpenGamepad(jid);
|
|
if (pad == nullptr) {
|
|
if (verbose) {
|
|
std::cout << "Failed to open gamepad " << jid << ": " << SDL_GetError() << std::endl;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
const int padIndex = (int)connectedControllers.size();
|
|
const std::string name = buildControllerName(pad, padIndex);
|
|
connectedControllers.push_back(pad);
|
|
connectedControllerIds.push_back(jid);
|
|
controllerNames.push_back(name);
|
|
numGamepads++;
|
|
|
|
if (verbose) {
|
|
std::cout << "Gamepad connected: " << name << std::endl;
|
|
}
|
|
|
|
outName = name;
|
|
return true;
|
|
}
|
|
|
|
// Procesa un evento SDL_EVENT_GAMEPAD_REMOVED
|
|
bool Input::handleGamepadRemoved(SDL_JoystickID jid, std::string &outName) {
|
|
for (size_t i = 0; i < connectedControllerIds.size(); ++i) {
|
|
if (connectedControllerIds[i] != jid) continue;
|
|
|
|
outName = controllerNames[i];
|
|
if (connectedControllers[i] != nullptr) {
|
|
SDL_CloseGamepad(connectedControllers[i]);
|
|
}
|
|
connectedControllers.erase(connectedControllers.begin() + i);
|
|
connectedControllerIds.erase(connectedControllerIds.begin() + i);
|
|
controllerNames.erase(controllerNames.begin() + i);
|
|
numGamepads--;
|
|
if (numGamepads < 0) numGamepads = 0;
|
|
|
|
if (verbose) {
|
|
std::cout << "Gamepad disconnected: " << outName << std::endl;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// Comprueba si hay algun mando conectado
|
|
bool Input::gameControllerFound() {
|
|
if (numGamepads > 0) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// Obten el nombre de un mando de juego
|
|
std::string Input::getControllerName(int index) {
|
|
if (numGamepads > 0) {
|
|
return controllerNames[index];
|
|
} else {
|
|
return "";
|
|
}
|
|
}
|
|
|
|
// Obten el numero de mandos conectados
|
|
int Input::getNumControllers() {
|
|
return numGamepads;
|
|
}
|
|
|
|
// Establece si ha de mostrar mensajes
|
|
void Input::setVerbose(bool value) {
|
|
verbose = value;
|
|
}
|
|
|
|
// Deshabilita las entradas durante un periodo de tiempo
|
|
void Input::disableUntil(i_disable_e value) {
|
|
disabledUntil = value;
|
|
enabled = false;
|
|
}
|
|
|
|
// Hablita las entradas
|
|
void Input::enable() {
|
|
enabled = true;
|
|
disabledUntil = d_notDisabled;
|
|
}
|