From 50eb906f2013b274c8fe699f4a7b28329db97e00 Mon Sep 17 00:00:00 2001 From: briaguya <70942617+briaguya-ai@users.noreply.github.com> Date: Tue, 28 Jan 2025 17:29:29 -0800 Subject: [PATCH] let ports set default controls (#795) * start getting stuff in place to let ports set default controls * naming * sdl buttons * axis direction to button mapping * keyboard key to axis direction * button to axis direction * axis direction to axis direction * remove now unused cmake kb mapping stuff * fix a couple little things --- cmake/cvars.cmake | 38 ---- src/controller/controldeck/ControlDeck.cpp | 18 +- src/controller/controldeck/ControlDeck.h | 8 +- .../controldevice/controller/Controller.cpp | 1 + .../controller/ControllerButton.cpp | 6 +- .../mapping/ControllerDefaultMappings.cpp | 174 ++++++++++++++++++ .../mapping/ControllerDefaultMappings.h | 84 +++++++++ .../factories/AxisDirectionMappingFactory.cpp | 52 ++++-- .../factories/ButtonMappingFactory.cpp | 136 +++----------- 9 files changed, 342 insertions(+), 175 deletions(-) create mode 100644 src/controller/controldevice/controller/mapping/ControllerDefaultMappings.cpp create mode 100644 src/controller/controldevice/controller/mapping/ControllerDefaultMappings.h diff --git a/cmake/cvars.cmake b/cmake/cvars.cmake index 72e171d..46b24ad 100644 --- a/cmake/cvars.cmake +++ b/cmake/cvars.cmake @@ -21,25 +21,6 @@ set(CVAR_MENU_BAR_OPEN "gOpenMenuBar" CACHE STRING "") set(CVAR_PREFIX_CONTROLLERS "gControllers" CACHE STRING "") set(CVAR_PREFIX_ADVANCED_RESOLUTION "gAdvancedResolution" CACHE STRING "") -set(LUS_DEFAULT_KB_MAPPING_A KbScancode::LUS_KB_X CACHE STRING "") -set(LUS_DEFAULT_KB_MAPPING_B KbScancode::LUS_KB_C CACHE STRING "") -set(LUS_DEFAULT_KB_MAPPING_L KbScancode::LUS_KB_E CACHE STRING "") -set(LUS_DEFAULT_KB_MAPPING_R KbScancode::LUS_KB_R CACHE STRING "") -set(LUS_DEFAULT_KB_MAPPING_Z KbScancode::LUS_KB_Z CACHE STRING "") -set(LUS_DEFAULT_KB_MAPPING_START KbScancode::LUS_KB_SPACE CACHE STRING "") -set(LUS_DEFAULT_KB_MAPPING_STICKUP KbScancode::LUS_KB_W CACHE STRING "") -set(LUS_DEFAULT_KB_MAPPING_STICKDOWN KbScancode::LUS_KB_S CACHE STRING "") -set(LUS_DEFAULT_KB_MAPPING_STICKLEFT KbScancode::LUS_KB_A CACHE STRING "") -set(LUS_DEFAULT_KB_MAPPING_STICKRIGHT KbScancode::LUS_KB_D CACHE STRING "") -set(LUS_DEFAULT_KB_MAPPING_CUP KbScancode::LUS_KB_ARROWKEY_UP CACHE STRING "") -set(LUS_DEFAULT_KB_MAPPING_CDOWN KbScancode::LUS_KB_ARROWKEY_DOWN CACHE STRING "") -set(LUS_DEFAULT_KB_MAPPING_CLEFT KbScancode::LUS_KB_ARROWKEY_LEFT CACHE STRING "") -set(LUS_DEFAULT_KB_MAPPING_CRIGHT KbScancode::LUS_KB_ARROWKEY_RIGHT CACHE STRING "") -set(LUS_DEFAULT_KB_MAPPING_DUP KbScancode::LUS_KB_T CACHE STRING "") -set(LUS_DEFAULT_KB_MAPPING_DDOWN KbScancode::LUS_KB_G CACHE STRING "") -set(LUS_DEFAULT_KB_MAPPING_DLEFT KbScancode::LUS_KB_F CACHE STRING "") -set(LUS_DEFAULT_KB_MAPPING_DRIGHT KbScancode::LUS_KB_H CACHE STRING "") - add_compile_definitions( CVAR_VSYNC_ENABLED="${CVAR_VSYNC_ENABLED}" CVAR_Z_FIGHTING_MODE="${CVAR_Z_FIGHTING_MODE}" @@ -63,23 +44,4 @@ add_compile_definitions( CVAR_MENU_BAR_OPEN="${CVAR_MENU_BAR_OPEN}" CVAR_PREFIX_CONTROLLERS="${CVAR_PREFIX_CONTROLLERS}" CVAR_PREFIX_ADVANCED_RESOLUTION="${CVAR_PREFIX_ADVANCED_RESOLUTION}" - - LUS_DEFAULT_KB_MAPPING_A=${LUS_DEFAULT_KB_MAPPING_A} - LUS_DEFAULT_KB_MAPPING_B=${LUS_DEFAULT_KB_MAPPING_B} - LUS_DEFAULT_KB_MAPPING_L=${LUS_DEFAULT_KB_MAPPING_L} - LUS_DEFAULT_KB_MAPPING_R=${LUS_DEFAULT_KB_MAPPING_R} - LUS_DEFAULT_KB_MAPPING_Z=${LUS_DEFAULT_KB_MAPPING_Z} - LUS_DEFAULT_KB_MAPPING_START=${LUS_DEFAULT_KB_MAPPING_START} - LUS_DEFAULT_KB_MAPPING_STICKUP=${LUS_DEFAULT_KB_MAPPING_STICKUP} - LUS_DEFAULT_KB_MAPPING_STICKDOWN=${LUS_DEFAULT_KB_MAPPING_STICKDOWN} - LUS_DEFAULT_KB_MAPPING_STICKLEFT=${LUS_DEFAULT_KB_MAPPING_STICKLEFT} - LUS_DEFAULT_KB_MAPPING_STICKRIGHT=${LUS_DEFAULT_KB_MAPPING_STICKRIGHT} - LUS_DEFAULT_KB_MAPPING_CUP=${LUS_DEFAULT_KB_MAPPING_CUP} - LUS_DEFAULT_KB_MAPPING_CDOWN=${LUS_DEFAULT_KB_MAPPING_CDOWN} - LUS_DEFAULT_KB_MAPPING_CLEFT=${LUS_DEFAULT_KB_MAPPING_CLEFT} - LUS_DEFAULT_KB_MAPPING_CRIGHT=${LUS_DEFAULT_KB_MAPPING_CRIGHT} - LUS_DEFAULT_KB_MAPPING_DUP=${LUS_DEFAULT_KB_MAPPING_DUP} - LUS_DEFAULT_KB_MAPPING_DDOWN=${LUS_DEFAULT_KB_MAPPING_DDOWN} - LUS_DEFAULT_KB_MAPPING_DLEFT=${LUS_DEFAULT_KB_MAPPING_DLEFT} - LUS_DEFAULT_KB_MAPPING_DRIGHT=${LUS_DEFAULT_KB_MAPPING_DRIGHT} ) diff --git a/src/controller/controldeck/ControlDeck.cpp b/src/controller/controldeck/ControlDeck.cpp index ed2d7d3..6d44df4 100644 --- a/src/controller/controldeck/ControlDeck.cpp +++ b/src/controller/controldeck/ControlDeck.cpp @@ -9,9 +9,12 @@ namespace Ship { -ControlDeck::ControlDeck(std::vector additionalBitmasks) { +ControlDeck::ControlDeck(std::vector additionalBitmasks, + std::shared_ptr controllerDefaultMappings) { mConnectedPhysicalDeviceManager = std::make_shared(); mGlobalSDLDeviceSettings = std::make_shared(); + mControllerDefaultMappings = controllerDefaultMappings == nullptr ? std::make_shared() + : controllerDefaultMappings; } ControlDeck::~ControlDeck() { @@ -110,16 +113,25 @@ std::shared_ptr ControlDeck::GetConnectedPhysica std::shared_ptr ControlDeck::GetGlobalSDLDeviceSettings() { return mGlobalSDLDeviceSettings; } + +std::shared_ptr ControlDeck::GetControllerDefaultMappings() { + return mControllerDefaultMappings; +} } // namespace Ship namespace LUS { -ControlDeck::ControlDeck(std::vector additionalBitmasks) - : Ship::ControlDeck(additionalBitmasks), mPads(nullptr) { +ControlDeck::ControlDeck(std::vector additionalBitmasks, + std::shared_ptr controllerDefaultMappings) + : Ship::ControlDeck(additionalBitmasks, controllerDefaultMappings), mPads(nullptr) { for (int32_t i = 0; i < MAXCONTROLLERS; i++) { mPorts.push_back(std::make_shared(i, std::make_shared(i, additionalBitmasks))); } } +ControlDeck::ControlDeck(std::vector additionalBitmasks) + : ControlDeck(additionalBitmasks, nullptr) { +} + ControlDeck::ControlDeck() : ControlDeck(std::vector()) { } diff --git a/src/controller/controldeck/ControlDeck.h b/src/controller/controldeck/ControlDeck.h index 703b41d..35bf85b 100644 --- a/src/controller/controldeck/ControlDeck.h +++ b/src/controller/controldeck/ControlDeck.h @@ -6,12 +6,14 @@ #include "controller/controldevice/controller/mapping/keyboard/KeyboardScancodes.h" #include "controller/physicaldevice/ConnectedPhysicalDeviceManager.h" #include "controller/physicaldevice/GlobalSDLDeviceSettings.h" +#include "controller/controldevice/controller/mapping/ControllerDefaultMappings.h" namespace Ship { class ControlDeck { public: - ControlDeck(std::vector additionalBitmasks); + ControlDeck(std::vector additionalBitmasks, + std::shared_ptr controllerDefaultMappings); ~ControlDeck(); void Init(uint8_t* controllerBits); @@ -28,6 +30,7 @@ class ControlDeck { std::shared_ptr GetConnectedPhysicalDeviceManager(); std::shared_ptr GetGlobalSDLDeviceSettings(); + std::shared_ptr GetControllerDefaultMappings(); protected: bool AllGameInputBlocked(); @@ -38,6 +41,7 @@ class ControlDeck { std::unordered_map mGameInputBlockers; std::shared_ptr mConnectedPhysicalDeviceManager; std::shared_ptr mGlobalSDLDeviceSettings; + std::shared_ptr mControllerDefaultMappings; }; } // namespace Ship @@ -46,6 +50,8 @@ class ControlDeck : public Ship::ControlDeck { public: ControlDeck(); ControlDeck(std::vector additionalBitmasks); + ControlDeck(std::vector additionalBitmasks, + std::shared_ptr controllerDefaultMappings); OSContPad* GetPads(); void WriteToPad(void* pad) override; diff --git a/src/controller/controldevice/controller/Controller.cpp b/src/controller/controldevice/controller/Controller.cpp index 77bfec8..b471881 100644 --- a/src/controller/controldevice/controller/Controller.cpp +++ b/src/controller/controldevice/controller/Controller.cpp @@ -107,6 +107,7 @@ void Controller::AddDefaultMappings(PhysicalDeviceType physicalDeviceType) { button->AddDefaultMappings(physicalDeviceType); } GetLeftStick()->AddDefaultMappings(physicalDeviceType); + GetRightStick()->AddDefaultMappings(physicalDeviceType); GetRumble()->AddDefaultMappings(physicalDeviceType); const std::string hasConfigCvarKey = diff --git a/src/controller/controldevice/controller/ControllerButton.cpp b/src/controller/controldevice/controller/ControllerButton.cpp index b2bf911..aa38629 100644 --- a/src/controller/controldevice/controller/ControllerButton.cpp +++ b/src/controller/controldevice/controller/ControllerButton.cpp @@ -266,8 +266,10 @@ bool ControllerButton::ProcessMouseButtonEvent(bool isPressed, MouseBtn button) } void ControllerButton::AddDefaultMappings(PhysicalDeviceType physicalDeviceType) { - for (auto mapping : ButtonMappingFactory::CreateDefaultSDLButtonMappings(mPortIndex, mBitmask)) { - AddButtonMapping(mapping); + if (physicalDeviceType == PhysicalDeviceType::SDLGamepad) { + for (auto mapping : ButtonMappingFactory::CreateDefaultSDLButtonMappings(mPortIndex, mBitmask)) { + AddButtonMapping(mapping); + } } if (physicalDeviceType == PhysicalDeviceType::Keyboard) { diff --git a/src/controller/controldevice/controller/mapping/ControllerDefaultMappings.cpp b/src/controller/controldevice/controller/mapping/ControllerDefaultMappings.cpp new file mode 100644 index 0000000..986af55 --- /dev/null +++ b/src/controller/controldevice/controller/mapping/ControllerDefaultMappings.cpp @@ -0,0 +1,174 @@ +#include "ControllerDefaultMappings.h" +#include "libultraship/libultra/controller.h" + +namespace Ship { +ControllerDefaultMappings::ControllerDefaultMappings( + std::unordered_map> defaultKeyboardKeyToButtonMappings, + std::unordered_map>> + defaultKeyboardKeyToAxisDirectionMappings, + std::unordered_map> + defaultSDLButtonToButtonMappings, + std::unordered_map>> + defaultSDLButtonToAxisDirectionMappings, + std::unordered_map>> + defaultSDLAxisDirectionToButtonMappings, + std::unordered_map>>> + defaultSDLAxisDirectionToAxisDirectionMappings) { + SetDefaultKeyboardKeyToButtonMappings(defaultKeyboardKeyToButtonMappings); + SetDefaultKeyboardKeyToAxisDirectionMappings(defaultKeyboardKeyToAxisDirectionMappings); + + SetDefaultSDLButtonToButtonMappings(defaultSDLButtonToButtonMappings); + SetDefaultSDLButtonToAxisDirectionMappings(defaultSDLButtonToAxisDirectionMappings); + + SetDefaultSDLAxisDirectionToButtonMappings(defaultSDLAxisDirectionToButtonMappings); + SetDefaultSDLAxisDirectionToAxisDirectionMappings(defaultSDLAxisDirectionToAxisDirectionMappings); +} + +ControllerDefaultMappings::ControllerDefaultMappings() + : ControllerDefaultMappings( + std::unordered_map>(), + std::unordered_map>>(), + std::unordered_map>(), + std::unordered_map>>(), + std::unordered_map>>(), + std::unordered_map>>>()) { +} + +ControllerDefaultMappings::~ControllerDefaultMappings() { +} + +std::unordered_map> +ControllerDefaultMappings::GetDefaultKeyboardKeyToButtonMappings() { + return mDefaultKeyboardKeyToButtonMappings; +} + +void ControllerDefaultMappings::SetDefaultKeyboardKeyToButtonMappings( + std::unordered_map> defaultKeyboardKeyToButtonMappings) { + if (!defaultKeyboardKeyToButtonMappings.empty()) { + mDefaultKeyboardKeyToButtonMappings = defaultKeyboardKeyToButtonMappings; + return; + } + + mDefaultKeyboardKeyToButtonMappings[BTN_A] = { KbScancode::LUS_KB_X }; + mDefaultKeyboardKeyToButtonMappings[BTN_B] = { KbScancode::LUS_KB_C }; + mDefaultKeyboardKeyToButtonMappings[BTN_L] = { KbScancode::LUS_KB_E }; + mDefaultKeyboardKeyToButtonMappings[BTN_R] = { KbScancode::LUS_KB_R }; + mDefaultKeyboardKeyToButtonMappings[BTN_Z] = { KbScancode::LUS_KB_Z }; + mDefaultKeyboardKeyToButtonMappings[BTN_START] = { KbScancode::LUS_KB_SPACE }; + mDefaultKeyboardKeyToButtonMappings[BTN_CUP] = { KbScancode::LUS_KB_ARROWKEY_UP }; + mDefaultKeyboardKeyToButtonMappings[BTN_CDOWN] = { KbScancode::LUS_KB_ARROWKEY_DOWN }; + mDefaultKeyboardKeyToButtonMappings[BTN_CLEFT] = { KbScancode::LUS_KB_ARROWKEY_LEFT }; + mDefaultKeyboardKeyToButtonMappings[BTN_CRIGHT] = { KbScancode::LUS_KB_ARROWKEY_RIGHT }; + mDefaultKeyboardKeyToButtonMappings[BTN_DUP] = { KbScancode::LUS_KB_T }; + mDefaultKeyboardKeyToButtonMappings[BTN_DDOWN] = { KbScancode::LUS_KB_G }; + mDefaultKeyboardKeyToButtonMappings[BTN_DLEFT] = { KbScancode::LUS_KB_F }; + mDefaultKeyboardKeyToButtonMappings[BTN_DRIGHT] = { KbScancode::LUS_KB_H }; +} + +std::unordered_map>> +ControllerDefaultMappings::GetDefaultKeyboardKeyToAxisDirectionMappings() { + return mDefaultKeyboardKeyToAxisDirectionMappings; +} + +void ControllerDefaultMappings::SetDefaultKeyboardKeyToAxisDirectionMappings( + std::unordered_map>> + defaultKeyboardKeyToAxisDirectionMappings) { + if (!defaultKeyboardKeyToAxisDirectionMappings.empty()) { + mDefaultKeyboardKeyToAxisDirectionMappings = defaultKeyboardKeyToAxisDirectionMappings; + return; + } + + mDefaultKeyboardKeyToAxisDirectionMappings[LEFT_STICK] = { { LEFT, KbScancode::LUS_KB_A }, + { RIGHT, KbScancode::LUS_KB_D }, + { UP, KbScancode::LUS_KB_W }, + { DOWN, KbScancode::LUS_KB_S } }; +} + +std::unordered_map> +ControllerDefaultMappings::GetDefaultSDLButtonToButtonMappings() { + return mDefaultSDLButtonToButtonMappings; +} + +void ControllerDefaultMappings::SetDefaultSDLButtonToButtonMappings( + std::unordered_map> + defaultSDLButtonToButtonMappings) { + if (!defaultSDLButtonToButtonMappings.empty()) { + mDefaultSDLButtonToButtonMappings = defaultSDLButtonToButtonMappings; + return; + } + + mDefaultSDLButtonToButtonMappings[BTN_A] = { SDL_CONTROLLER_BUTTON_A }; + mDefaultSDLButtonToButtonMappings[BTN_B] = { SDL_CONTROLLER_BUTTON_B }; + mDefaultSDLButtonToButtonMappings[BTN_L] = { SDL_CONTROLLER_BUTTON_LEFTSHOULDER }; + mDefaultSDLButtonToButtonMappings[BTN_START] = { SDL_CONTROLLER_BUTTON_START }; + mDefaultSDLButtonToButtonMappings[BTN_DUP] = { SDL_CONTROLLER_BUTTON_DPAD_UP }; + mDefaultSDLButtonToButtonMappings[BTN_DDOWN] = { SDL_CONTROLLER_BUTTON_DPAD_DOWN }; + mDefaultSDLButtonToButtonMappings[BTN_DLEFT] = { SDL_CONTROLLER_BUTTON_DPAD_LEFT }; + mDefaultSDLButtonToButtonMappings[BTN_DRIGHT] = { SDL_CONTROLLER_BUTTON_DPAD_RIGHT }; +} + +std::unordered_map>> +ControllerDefaultMappings::GetDefaultSDLButtonToAxisDirectionMappings() { + return mDefaultSDLButtonToAxisDirectionMappings; +} + +void ControllerDefaultMappings::SetDefaultSDLButtonToAxisDirectionMappings( + std::unordered_map>> + defaultSDLButtonToAxisDirectionMappings) { + if (!defaultSDLButtonToAxisDirectionMappings.empty()) { + mDefaultSDLButtonToAxisDirectionMappings = defaultSDLButtonToAxisDirectionMappings; + return; + } +} + +std::unordered_map>> +ControllerDefaultMappings::GetDefaultSDLAxisDirectionToButtonMappings() { + return mDefaultSDLAxisDirectionToButtonMappings; +} + +void ControllerDefaultMappings::SetDefaultSDLAxisDirectionToButtonMappings( + std::unordered_map>> + defaultSDLAxisDirectionToButtonMappings) { + if (!defaultSDLAxisDirectionToButtonMappings.empty()) { + mDefaultSDLAxisDirectionToButtonMappings = defaultSDLAxisDirectionToButtonMappings; + return; + } + + mDefaultSDLAxisDirectionToButtonMappings[BTN_R] = { { SDL_CONTROLLER_AXIS_TRIGGERRIGHT, 1 } }; + mDefaultSDLAxisDirectionToButtonMappings[BTN_Z] = { { SDL_CONTROLLER_AXIS_TRIGGERLEFT, 1 } }; + mDefaultSDLAxisDirectionToButtonMappings[BTN_CUP] = { { SDL_CONTROLLER_AXIS_RIGHTY, -1 } }; + mDefaultSDLAxisDirectionToButtonMappings[BTN_CDOWN] = { { SDL_CONTROLLER_AXIS_RIGHTY, 1 } }; + mDefaultSDLAxisDirectionToButtonMappings[BTN_CLEFT] = { { SDL_CONTROLLER_AXIS_RIGHTX, -1 } }; + mDefaultSDLAxisDirectionToButtonMappings[BTN_CRIGHT] = { { SDL_CONTROLLER_AXIS_RIGHTX, 1 } }; +} + +std::unordered_map>>> +ControllerDefaultMappings::GetDefaultSDLAxisDirectionToAxisDirectionMappings() { + return mDefaultSDLAxisDirectionToAxisDirectionMappings; +} + +void ControllerDefaultMappings::SetDefaultSDLAxisDirectionToAxisDirectionMappings( + std::unordered_map>>> + defaultSDLAxisDirectionToAxisDirectionMappings) { + if (!defaultSDLAxisDirectionToAxisDirectionMappings.empty()) { + mDefaultSDLAxisDirectionToAxisDirectionMappings = defaultSDLAxisDirectionToAxisDirectionMappings; + return; + } + + mDefaultSDLAxisDirectionToAxisDirectionMappings[LEFT_STICK] = { + { LEFT, { SDL_CONTROLLER_AXIS_LEFTX, -1 } }, + { RIGHT, { SDL_CONTROLLER_AXIS_LEFTX, 1 } }, + { UP, { SDL_CONTROLLER_AXIS_LEFTY, -1 } }, + { DOWN, { SDL_CONTROLLER_AXIS_LEFTY, 1 } }, + }; + + mDefaultSDLAxisDirectionToAxisDirectionMappings[RIGHT_STICK] = { + { LEFT, { SDL_CONTROLLER_AXIS_RIGHTX, -1 } }, + { RIGHT, { SDL_CONTROLLER_AXIS_RIGHTX, 1 } }, + { UP, { SDL_CONTROLLER_AXIS_RIGHTY, -1 } }, + { DOWN, { SDL_CONTROLLER_AXIS_RIGHTY, 1 } }, + }; +} + +} // namespace Ship diff --git a/src/controller/controldevice/controller/mapping/ControllerDefaultMappings.h b/src/controller/controldevice/controller/mapping/ControllerDefaultMappings.h new file mode 100644 index 0000000..4b0623d --- /dev/null +++ b/src/controller/controldevice/controller/mapping/ControllerDefaultMappings.h @@ -0,0 +1,84 @@ +#pragma once + +#include +#include +#include +#include +#include +#include "ControllerAxisDirectionMapping.h" + +#ifndef CONTROLLERBUTTONS_T +#define CONTROLLERBUTTONS_T uint16_t +#endif + +#include "controller/controldevice/controller/mapping/keyboard/KeyboardScancodes.h" + +namespace Ship { + +class ControllerDefaultMappings { + public: + ControllerDefaultMappings( + std::unordered_map> defaultKeyboardKeyToButtonMappings, + std::unordered_map>> + defaultKeyboardKeyToAxisDirectionMappings, + std::unordered_map> + defaultSDLButtonToButtonMappings, + std::unordered_map>> + defaultSDLButtonToAxisDirectionMappings, + std::unordered_map>> + defaultSDLAxisDirectionToButtonMappings, + std::unordered_map>>> + defaultSDLAxisDirectionToAxisDirectionMappings); + ControllerDefaultMappings(); + ~ControllerDefaultMappings(); + + std::unordered_map> GetDefaultKeyboardKeyToButtonMappings(); + std::unordered_map>> + GetDefaultKeyboardKeyToAxisDirectionMappings(); + + std::unordered_map> + GetDefaultSDLButtonToButtonMappings(); + std::unordered_map>> + GetDefaultSDLButtonToAxisDirectionMappings(); + + std::unordered_map>> + GetDefaultSDLAxisDirectionToButtonMappings(); + std::unordered_map>>> + GetDefaultSDLAxisDirectionToAxisDirectionMappings(); + + private: + void SetDefaultKeyboardKeyToButtonMappings( + std::unordered_map> defaultKeyboardKeyToButtonMappings); + std::unordered_map> mDefaultKeyboardKeyToButtonMappings; + + void SetDefaultKeyboardKeyToAxisDirectionMappings( + std::unordered_map>> + defaultKeyboardKeyToAxisDirectionMappings); + std::unordered_map>> + mDefaultKeyboardKeyToAxisDirectionMappings; + + void SetDefaultSDLButtonToButtonMappings( + std::unordered_map> + defaultSDLButtonToButtonMappings); + std::unordered_map> + mDefaultSDLButtonToButtonMappings; + + void SetDefaultSDLButtonToAxisDirectionMappings( + std::unordered_map>> + defaultSDLButtonToAxisDirectionMappings); + std::unordered_map>> + mDefaultSDLButtonToAxisDirectionMappings; + + void SetDefaultSDLAxisDirectionToButtonMappings( + std::unordered_map>> + defaultSDLAxisDirectionToButtonMappings); + std::unordered_map>> + mDefaultSDLAxisDirectionToButtonMappings; + + void SetDefaultSDLAxisDirectionToAxisDirectionMappings( + std::unordered_map>>> + defaultSDLAxisDirectionToAxisDirectionMappings); + std::unordered_map>>> + mDefaultSDLAxisDirectionToAxisDirectionMappings; +}; +} // namespace Ship diff --git a/src/controller/controldevice/controller/mapping/factories/AxisDirectionMappingFactory.cpp b/src/controller/controldevice/controller/mapping/factories/AxisDirectionMappingFactory.cpp index c274b98..3040ddc 100644 --- a/src/controller/controldevice/controller/mapping/factories/AxisDirectionMappingFactory.cpp +++ b/src/controller/controldevice/controller/mapping/factories/AxisDirectionMappingFactory.cpp @@ -109,31 +109,45 @@ AxisDirectionMappingFactory::CreateAxisDirectionMappingFromConfig(uint8_t portIn std::vector> AxisDirectionMappingFactory::CreateDefaultKeyboardAxisDirectionMappings(uint8_t portIndex, StickIndex stickIndex) { - std::vector> mappings = { - std::make_shared(portIndex, stickIndex, LEFT, - LUS_DEFAULT_KB_MAPPING_STICKLEFT), - std::make_shared(portIndex, stickIndex, RIGHT, - LUS_DEFAULT_KB_MAPPING_STICKRIGHT), - std::make_shared(portIndex, stickIndex, UP, LUS_DEFAULT_KB_MAPPING_STICKUP), - std::make_shared(portIndex, stickIndex, DOWN, - LUS_DEFAULT_KB_MAPPING_STICKDOWN) - }; + std::vector> mappings; + + auto defaultsForStick = Context::GetInstance() + ->GetControlDeck() + ->GetControllerDefaultMappings() + ->GetDefaultKeyboardKeyToAxisDirectionMappings()[stickIndex]; + + for (const auto& [direction, scancode] : defaultsForStick) { + mappings.push_back( + std::make_shared(portIndex, stickIndex, direction, scancode)); + } return mappings; } std::vector> AxisDirectionMappingFactory::CreateDefaultSDLAxisDirectionMappings(uint8_t portIndex, StickIndex stickIndex) { - std::vector> mappings = { - std::make_shared(portIndex, stickIndex, LEFT, - stickIndex == LEFT_STICK ? 0 : 2, -1), - std::make_shared(portIndex, stickIndex, RIGHT, - stickIndex == LEFT_STICK ? 0 : 2, 1), - std::make_shared(portIndex, stickIndex, UP, - stickIndex == LEFT_STICK ? 1 : 3, -1), - std::make_shared(portIndex, stickIndex, DOWN, - stickIndex == LEFT_STICK ? 1 : 3, 1) - }; + std::vector> mappings; + + auto defaultButtonsForStick = Context::GetInstance() + ->GetControlDeck() + ->GetControllerDefaultMappings() + ->GetDefaultSDLButtonToAxisDirectionMappings()[stickIndex]; + + for (const auto& [direction, sdlGamepadButton] : defaultButtonsForStick) { + mappings.push_back( + std::make_shared(portIndex, stickIndex, direction, sdlGamepadButton)); + } + + auto defaultAxisDirectionsForStick = Context::GetInstance() + ->GetControlDeck() + ->GetControllerDefaultMappings() + ->GetDefaultSDLAxisDirectionToAxisDirectionMappings()[stickIndex]; + + for (const auto& [direction, sdlGamepadAxisDirection] : defaultAxisDirectionsForStick) { + auto [sdlGamepadAxis, sdlGamepadDirection] = sdlGamepadAxisDirection; + mappings.push_back(std::make_shared( + portIndex, stickIndex, direction, sdlGamepadAxis, sdlGamepadDirection)); + } return mappings; } diff --git a/src/controller/controldevice/controller/mapping/factories/ButtonMappingFactory.cpp b/src/controller/controldevice/controller/mapping/factories/ButtonMappingFactory.cpp index a6ab7de..82966da 100644 --- a/src/controller/controldevice/controller/mapping/factories/ButtonMappingFactory.cpp +++ b/src/controller/controldevice/controller/mapping/factories/ButtonMappingFactory.cpp @@ -84,63 +84,13 @@ std::vector> ButtonMappingFactory::CreateDefaultKeyboardButtonMappings(uint8_t portIndex, CONTROLLERBUTTONS_T bitmask) { std::vector> mappings; - switch (bitmask) { - case BTN_A: - mappings.push_back( - std::make_shared(portIndex, BTN_A, LUS_DEFAULT_KB_MAPPING_A)); - break; - case BTN_B: - mappings.push_back( - std::make_shared(portIndex, BTN_B, LUS_DEFAULT_KB_MAPPING_B)); - break; - case BTN_L: - mappings.push_back( - std::make_shared(portIndex, BTN_L, LUS_DEFAULT_KB_MAPPING_L)); - break; - case BTN_R: - mappings.push_back( - std::make_shared(portIndex, BTN_R, LUS_DEFAULT_KB_MAPPING_R)); - break; - case BTN_Z: - mappings.push_back( - std::make_shared(portIndex, BTN_Z, LUS_DEFAULT_KB_MAPPING_Z)); - break; - case BTN_START: - mappings.push_back( - std::make_shared(portIndex, BTN_START, LUS_DEFAULT_KB_MAPPING_START)); - break; - case BTN_CUP: - mappings.push_back( - std::make_shared(portIndex, BTN_CUP, LUS_DEFAULT_KB_MAPPING_CUP)); - break; - case BTN_CDOWN: - mappings.push_back( - std::make_shared(portIndex, BTN_CDOWN, LUS_DEFAULT_KB_MAPPING_CDOWN)); - break; - case BTN_CLEFT: - mappings.push_back( - std::make_shared(portIndex, BTN_CLEFT, LUS_DEFAULT_KB_MAPPING_CLEFT)); - break; - case BTN_CRIGHT: - mappings.push_back( - std::make_shared(portIndex, BTN_CRIGHT, LUS_DEFAULT_KB_MAPPING_CRIGHT)); - break; - case BTN_DUP: - mappings.push_back( - std::make_shared(portIndex, BTN_DUP, LUS_DEFAULT_KB_MAPPING_DUP)); - break; - case BTN_DDOWN: - mappings.push_back( - std::make_shared(portIndex, BTN_DDOWN, LUS_DEFAULT_KB_MAPPING_DDOWN)); - break; - case BTN_DLEFT: - mappings.push_back( - std::make_shared(portIndex, BTN_DLEFT, LUS_DEFAULT_KB_MAPPING_DLEFT)); - break; - case BTN_DRIGHT: - mappings.push_back( - std::make_shared(portIndex, BTN_DRIGHT, LUS_DEFAULT_KB_MAPPING_DRIGHT)); - break; + auto defaultsForBitmask = Context::GetInstance() + ->GetControlDeck() + ->GetControllerDefaultMappings() + ->GetDefaultKeyboardKeyToButtonMappings()[bitmask]; + + for (const auto& scancode : defaultsForBitmask) { + mappings.push_back(std::make_shared(portIndex, bitmask, scancode)); } return mappings; @@ -150,61 +100,23 @@ std::vector> ButtonMappingFactory::CreateDefaultSDLButtonMappings(uint8_t portIndex, CONTROLLERBUTTONS_T bitmask) { std::vector> mappings; - switch (bitmask) { - case BTN_A: - mappings.push_back(std::make_shared(portIndex, BTN_A, SDL_CONTROLLER_BUTTON_A)); - break; - case BTN_B: - mappings.push_back(std::make_shared(portIndex, BTN_B, SDL_CONTROLLER_BUTTON_B)); - break; - case BTN_L: - mappings.push_back( - std::make_shared(portIndex, BTN_L, SDL_CONTROLLER_BUTTON_LEFTSHOULDER)); - break; - case BTN_R: - mappings.push_back(std::make_shared(portIndex, BTN_R, - SDL_CONTROLLER_AXIS_TRIGGERRIGHT, 1)); - break; - case BTN_Z: - mappings.push_back(std::make_shared(portIndex, BTN_Z, - SDL_CONTROLLER_AXIS_TRIGGERLEFT, 1)); - break; - case BTN_START: - mappings.push_back( - std::make_shared(portIndex, BTN_START, SDL_CONTROLLER_BUTTON_START)); - break; - case BTN_CUP: - mappings.push_back( - std::make_shared(portIndex, BTN_CUP, SDL_CONTROLLER_AXIS_RIGHTY, -1)); - break; - case BTN_CDOWN: - mappings.push_back( - std::make_shared(portIndex, BTN_CDOWN, SDL_CONTROLLER_AXIS_RIGHTY, 1)); - break; - case BTN_CLEFT: - mappings.push_back(std::make_shared(portIndex, BTN_CLEFT, - SDL_CONTROLLER_AXIS_RIGHTX, -1)); - break; - case BTN_CRIGHT: - mappings.push_back(std::make_shared(portIndex, BTN_CRIGHT, - SDL_CONTROLLER_AXIS_RIGHTX, 1)); - break; - case BTN_DUP: - mappings.push_back( - std::make_shared(portIndex, BTN_DUP, SDL_CONTROLLER_BUTTON_DPAD_UP)); - break; - case BTN_DDOWN: - mappings.push_back( - std::make_shared(portIndex, BTN_DDOWN, SDL_CONTROLLER_BUTTON_DPAD_DOWN)); - break; - case BTN_DLEFT: - mappings.push_back( - std::make_shared(portIndex, BTN_DLEFT, SDL_CONTROLLER_BUTTON_DPAD_LEFT)); - break; - case BTN_DRIGHT: - mappings.push_back( - std::make_shared(portIndex, BTN_DRIGHT, SDL_CONTROLLER_BUTTON_DPAD_RIGHT)); - break; + auto defaultButtonsForBitmask = Context::GetInstance() + ->GetControlDeck() + ->GetControllerDefaultMappings() + ->GetDefaultSDLButtonToButtonMappings()[bitmask]; + + for (const auto& sdlGamepadButton : defaultButtonsForBitmask) { + mappings.push_back(std::make_shared(portIndex, bitmask, sdlGamepadButton)); + } + + auto defaultAxisDirectionsForBitmask = Context::GetInstance() + ->GetControlDeck() + ->GetControllerDefaultMappings() + ->GetDefaultSDLAxisDirectionToButtonMappings()[bitmask]; + + for (const auto& [sdlGamepadAxis, axisDirection] : defaultAxisDirectionsForBitmask) { + mappings.push_back( + std::make_shared(portIndex, bitmask, sdlGamepadAxis, axisDirection)); } return mappings;