Gamepad.hpp

Go to the documentation of this file.

 
 
#ifndef ECSTASY_INTEGRATIONS_EVENT_INPUTS_GAMEPAD_HPP_
#define ECSTASY_INTEGRATIONS_EVENT_INPUTS_GAMEPAD_HPP_
 
#include <array>
#include <cstdint>
#include <iostream>
#include <unordered_map>
 
#include "util/serialization/SerializableEnum.hpp"
 
namespace ecstasy::integration::event
{
    class Gamepad {
      public:
#ifndef _DOXYGEN_
 
        // LCOV_EXCL_START
 
        SERIALIZABLE_ENUM(Button, -1, Unknown, FaceUp, FaceRight, FaceDown, FaceLeft, BumperLeft, BumperRight,
            MiddleLeft, Middle, MiddleRight, ThumbLeft, ThumbRight, Count)
        SERIALIZABLE_ENUM(
            Axis, -1, Unknown, LeftX, LeftY, RightX, RightY, TriggerLeft, TriggerRight, DPadX, DPadY, Count)
 
            // LCOV_EXCL_STOP
#else
        enum class Button {
            Unknown = -1, 
            FaceUp,    
            FaceRight, 
            FaceDown,  
            FaceLeft,  
            BumperLeft,  
            BumperRight, 
            MiddleLeft,  
            Middle,      
            MiddleRight, 
            ThumbLeft,  
            ThumbRight, 
 
            Count 
        };
 
        enum class Axis {
            Unknown = -1, 
            LeftX,        
            LeftY,        
            RightX,       
            RightY,       
            TriggerLeft,  
            TriggerRight, 
            DPadX,        
            DPadY,        
 
            Count 
 
        };
#endif
 
        enum class Joystick {
            Unknown = -1, 
            Left = 0,     
            Right,        
 
            Count 
        };
 
        constexpr Gamepad(std::size_t id = 0) noexcept : _id(id), _connected(false), _buttons({false}), _axis({0.f})
        {
            setAxisValue(Axis::TriggerLeft, -1.f);
            setAxisValue(Axis::TriggerRight, -1.f);
        }
 
        ~Gamepad() noexcept = default;
 
        [[nodiscard]] constexpr std::size_t getId() const noexcept
        {
            return _id;
        }
 
        constexpr void setId(std::size_t id) noexcept
        {
            _id = id;
        }
 
        [[nodiscard]] constexpr bool isConnected() const noexcept
        {
            return _connected;
        }
 
        constexpr void setConnected(bool connected) noexcept
        {
            _connected = connected;
        }
 
        [[nodiscard]] constexpr bool isButtonDown(Button button) const
        {
            assertButtonValid(button);
            return _buttons[static_cast<std::size_t>(button)];
        }
 
        [[nodiscard]] constexpr bool isButtonUp(Button button) const
        {
            assertButtonValid(button);
            return !isButtonDown(button);
        }
 
        constexpr void setButtonState(Button button, bool down)
        {
            assertButtonValid(button);
            _buttons[static_cast<std::size_t>(button)] = down;
        }
 
        [[nodiscard]] constexpr float getAxisValue(Axis axis) const
        {
            assertAxisValid(axis);
            return _axis[static_cast<std::size_t>(axis)];
        }
 
        constexpr void setAxisValue(Axis axis, float value)
        {
            assertAxisValid(axis);
            _axis[static_cast<std::size_t>(axis)] = value;
        }
 
        constexpr static void assertButtonValid(Button button, bool allowUnknown = false)
        {
            if (static_cast<std::size_t>(button) >= static_cast<std::size_t>(Button::Count)
                || (!allowUnknown && button == Button::Unknown)) [[unlikely]]
                throw std::invalid_argument("Invalid button");
        }
 
        constexpr static void assertAxisValid(Axis axis, bool allowUnknown = false)
        {
            if (static_cast<std::size_t>(axis) >= static_cast<std::size_t>(Axis::Count)
                || (!allowUnknown && axis == Axis::Unknown)) [[unlikely]]
                throw std::invalid_argument("Invalid axis");
        }
 
      private:
        std::size_t _id;
        bool _connected;
        std::array<bool, static_cast<std::size_t>(Button::Count)> _buttons;
        std::array<float, static_cast<std::size_t>(Axis::Count)> _axis;
    };
} // namespace ecstasy::integration::event
 
#endif /* !ECSTASY_INTEGRATIONS_EVENT_INPUTS_GAMEPAD_HPP_ */