ActionBinding.hpp

Go to the documentation of this file.

 
 
#ifndef ECSTASY_INTEGRATIONS_USER_ACTION_ACTIONBINDING_HPP_
#define ECSTASY_INTEGRATIONS_USER_ACTION_ACTIONBINDING_HPP_
 
#include <iostream>
#include <toml++/toml.h>
#include <unordered_map>
 
#include "Action.hpp"
#include "ecstasy/integrations/event/inputs/Gamepad.hpp"
#include "ecstasy/integrations/event/inputs/Keyboard.hpp"
#include "ecstasy/integrations/event/inputs/Mouse.hpp"
#include "util/serialization/SerializableEnum.hpp"
 
namespace ecstasy::integration::user_action
{
    namespace
    {
        namespace event = ecstasy::integration::event;
    }
 
    template <typename E>
    using is_valid_action_id =
        typename std::conditional<std::is_enum_v<E>, std::true_type, std::is_same<E, Action::Id>>::type;
 
    class ActionBinding {
      public:
        // LCOV_EXCL_START
 
        SERIALIZABLE_ENUM(Type, 0, MouseButton, Key, GamepadButton, GamepadAxis, Count)
 
        // LCOV_EXCL_STOP
#ifdef _DOXYGEN_
        enum class Type {
            MouseButton,   
            Key,           
            GamepadButton, 
            GamepadAxis,   
 
            Count 
        };
#endif
 
        constexpr ActionBinding() noexcept : type(Type::Count), actionId(0)
        {
        }
 
        template <typename E, typename = is_valid_action_id<E>>
        constexpr ActionBinding(E id, event::Mouse::Button input) noexcept
            : type(Type::MouseButton), actionId(static_cast<Action::Id>(id)), mouseButton(input)
        {
        }
 
        template <typename E, typename = is_valid_action_id<E>>
        constexpr ActionBinding(E id, event::Keyboard::Key input)
            : type(Type::Key), actionId(static_cast<Action::Id>(id)), key(input)
        {
            event::Keyboard::assertKeyValid(input);
        }
 
        template <typename E, typename = is_valid_action_id<E>>
        constexpr ActionBinding(E id, event::Gamepad::Button input)
            : type(Type::GamepadButton), actionId(static_cast<Action::Id>(id)), gamepadButton(input)
        {
            event::Gamepad::assertButtonValid(input);
        }
 
        template <typename E, typename = is_valid_action_id<E>>
        constexpr ActionBinding(E id, event::Gamepad::Axis input)
            : type(Type::GamepadAxis), actionId(static_cast<Action::Id>(id)), gamepadAxis(input)
        {
            event::Gamepad::assertAxisValid(input);
        }
 
        [[nodiscard]] constexpr bool operator==(const ActionBinding &other) const noexcept
        {
            if (type != other.type || actionId != other.actionId)
                return false;
 
            switch (type) {
                case Type::MouseButton: return mouseButton == other.mouseButton;
                case Type::Key: return key == other.key;
                case Type::GamepadButton: return gamepadButton == other.gamepadButton;
                case Type::GamepadAxis: return gamepadAxis == other.gamepadAxis;
                default: return true;
            }
        }
 
        Type type;
 
        Action::Id actionId;
 
        union {
            event::Mouse::Button mouseButton;     
            event::Keyboard::Key key;             
            event::Gamepad::Button gamepadButton; 
            event::Gamepad::Axis gamepadAxis;     
        };
    };
} // namespace ecstasy::integration::user_action
 
#endif /* !ECSTASY_INTEGRATIONS_USER_ACTION_ACTIONBINDING_HPP_ */