InputBindings.hpp

Go to the documentation of this file.

#pragma once
 
#include "SDL3/SDL_events.h"
#include "SDL3/SDL_gamepad.h"
#include "SDL3/SDL_mouse.h"
#include "SDL3/SDL_scancode.h"
 
#include <array>
#include <cstddef>
#include <cstdint>
#include <string>
#include <string_view>

enum class Action : uint8_t
{
    Forward,           
    Back,              
    Left,              
    Right,             
    Jump,              
    Crouch,            
    AbilityMenu,       
    Ability1,          
    Ability2,          
    Shoot,             
    Scope,             
    Reload,            
    Pickup,            
    SwitchToPrimary,   
    SwitchToSecondary, 
    PreviousWeapon,    
    NextWeapon,        
    CycleGrenade,      
    ThrowGrenade,      
    KillSelf,          
    Scoreboard,        
    Emote,             
    PushToTalk,        
    Count              
};
 
enum class BindingDevice : uint8_t
{
    KeyboardMouse,
    Controller
};

enum class BindingKind : uint8_t
{
    Unbound,       
    Keyboard,      
    MouseButton,   
    MouseWheel,    
    GamepadButton, 
    GamepadAxis    
};

enum class MouseButton : uint8_t
{
    None = 0,                   
    Left = SDL_BUTTON_LEFT,     
    Middle = SDL_BUTTON_MIDDLE, 
    Right = SDL_BUTTON_RIGHT,   
    X1 = SDL_BUTTON_X1,         
    X2 = SDL_BUTTON_X2,         
};
 
enum class MouseWheelDirection : uint8_t
{
    None,
    Up,
    Down
};
 
enum class GamepadAxisBinding : uint8_t
{
    None,
    LeftTrigger,
    RightTrigger
};

struct Binding
{
    BindingKind kind{BindingKind::Unbound};                      
    SDL_Scancode key{SDL_SCANCODE_UNKNOWN};                      
    MouseButton mouseButton{MouseButton::None};                  
    MouseWheelDirection mouseWheel{MouseWheelDirection::None};   
    SDL_GamepadButton gamepadButton{SDL_GAMEPAD_BUTTON_INVALID}; 
    GamepadAxisBinding gamepadAxis{GamepadAxisBinding::None};    

    static Binding bindKeyboard(SDL_Scancode key) { return Binding{.kind = BindingKind::Keyboard, .key = key}; };

    static Binding bindMouse(MouseButton button)
    {
        return Binding{.kind = BindingKind::MouseButton, .mouseButton = button};
    };

    static Binding bindMouseWheel(MouseWheelDirection direction)
    {
        return Binding{.kind = BindingKind::MouseWheel, .mouseWheel = direction};
    };

    static Binding bindGamepadButton(SDL_GamepadButton button)
    {
        return Binding{.kind = BindingKind::GamepadButton, .gamepadButton = button};
    };

    static Binding bindGamepadAxis(GamepadAxisBinding axis)
    {
        return Binding{.kind = BindingKind::GamepadAxis, .gamepadAxis = axis};
    };

    static Binding unbound() { return Binding{}; };
};

class InputBindings
{
public:
    static constexpr std::size_t kBindingSlots = 2;

    static InputBindings defaults();

    [[nodiscard]] Binding
    get(Action a, BindingDevice device = BindingDevice::KeyboardMouse, std::size_t slot = 0) const;

    void rebind(Action a, Binding b, BindingDevice device = BindingDevice::KeyboardMouse, std::size_t slot = 0);

    bool pressed(Action a, const bool* keyStates, SDL_MouseButtonFlags mouseState) const;

    bool controllerPressed(Action a, SDL_Gamepad* gamepad) const;

    bool eventMatches(Action a, const SDL_Event& event, bool& down) const;

    static constexpr std::array<Action, size_t(Action::Count)> actions()
    {
        return {Action::Forward,
                Action::Back,
                Action::Left,
                Action::Right,
                Action::Jump,
                Action::Crouch,
                Action::AbilityMenu,
                Action::Ability1,
                Action::Ability2,
                Action::Shoot,
                Action::Scope,
                Action::Reload,
                Action::Pickup,
                Action::SwitchToPrimary,
                Action::SwitchToSecondary,
                Action::PreviousWeapon,
                Action::NextWeapon,
                Action::CycleGrenade,
                Action::ThrowGrenade,
                Action::KillSelf,
                Action::Scoreboard,
                Action::Emote,
                Action::PushToTalk};
    }

    static std::string_view actionLabel(Action a);

    static std::string_view configKey(Action a);

    static bool actionFromConfigKey(std::string_view key, Action& out);

    static std::string bindingLabel(Binding b);

    static std::string bindingConfigValue(Binding b);

    static bool bindingFromConfigValue(std::string_view value, Binding& out);
 
private:
    using BindingRow = std::array<Binding, kBindingSlots>;
    using BindingTable = std::array<BindingRow, size_t(Action::Count)>;
 
    [[nodiscard]] BindingTable& tableFor(BindingDevice device);
    [[nodiscard]] const BindingTable& tableFor(BindingDevice device) const;
 
    BindingTable keyboardMouseBindings{}; 
    BindingTable controllerBindings{};    
};