mgl_gamepad_state.h

[詳解]

// SPDX-License-Identifier: Zlib
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
 
#ifndef INCGUARD_MGL_GAMEPAD_STATE_H_1609654412
#define INCGUARD_MGL_GAMEPAD_STATE_H_1609654412
 
#include <array>
#include <atomic>
 
#include <mgl/input/gamepad/mgl_gamepad_defs.h>
#include <mgl/input/mgl_input_repeat.h>
#include <mgl/math/mgl_vector2.h>
#include <mgl/mgl_environment.h>
 
namespace MGL::Input
{
class PadState
{
public:
    PadState() noexcept;
 
    void PreUpdate() noexcept;
    void PostUpdate(const RepeatSetting &repeatSetting) noexcept;
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    constexpr void SetUsing(bool isUsing) noexcept
    {
        _isUsing = isUsing;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] constexpr bool IsUsing() const noexcept
    {
        return _isUsing || IsEnabled();
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    void RequestsActivate(PadType type, PadPriority priority, const PadDeviceInfo &deviceInfo) noexcept
    {
        _type = type;
        _priority = priority;
        _deviceInfo = deviceInfo;
        _shouldActivate = true;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    void RequestsDeactivate() noexcept
    {
        _shouldDeactivate = true;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    bool operator==(const PadState &rhs) const noexcept
    {
        return _identifier == rhs._identifier;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    bool operator!=(const PadState &rhs) const noexcept
    {
        return _identifier != rhs._identifier;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] constexpr bool IsEnabled() const noexcept
    {
        return _identifier != PadID::Invalid;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    constexpr void SetPlayerIndex(int32_t playerIndex) noexcept
    {
        _playerIndex = playerIndex;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] constexpr int32_t GetPlayerIndex() const noexcept
    {
        return _playerIndex;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] constexpr PadType GetType() const noexcept
    {
        return _type;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    constexpr void SetEntry(PadEntry entry) noexcept
    {
        if (entry < PadEntry::Reserve_Start)
        {
            _entry = entry;
        }
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] constexpr PadEntry GetEntry() const noexcept
    {
        return _entry;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] constexpr bool HasEntry() const noexcept
    {
        return IsEnabled() && (_entry < PadEntry::Reserve_Start);
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    constexpr void SetButton(PadButton button) noexcept
    {
        _buttonFlags.Set(button);
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    constexpr void SetButton(PadButtonFlags buttonFlags) noexcept
    {
        _buttonFlags |= buttonFlags;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] constexpr PadButtonFlags GetButtonFlags() const noexcept
    {
        return _buttonFlags;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    constexpr void SetLeftStick(const Vector2 &axisValue) noexcept
    {
        _leftStick = axisValue;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    constexpr void SetRightStick(const Vector2 &axisValue) noexcept
    {
        _rightStick = axisValue;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] constexpr const Vector2 &GetLeftStick() const noexcept
    {
        return _leftStick;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] constexpr Vector2 &GetLeftStick() noexcept
    {
        return _leftStick;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] constexpr const Vector2 &GetRightStick() const noexcept
    {
        return _rightStick;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] constexpr Vector2 &GetRightStick() noexcept
    {
        return _rightStick;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] constexpr bool IsPressing(PadButton button) const noexcept
    {
        return IsPressingAny(button);
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] constexpr bool IsPressing(PadButtonFlags buttonFlags) const noexcept
    {
        return (_buttonFlags & buttonFlags) == buttonFlags;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] constexpr bool IsPressingAny(PadButtonFlags buttonFlags = kGamepadButtonAll) const noexcept
    {
        return (_buttonFlags & buttonFlags).HasAny();
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] constexpr bool IsTriggered(PadButton button) const noexcept
    {
        return IsPressing(button) && !_prevButtonFlags.Has(button);
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] constexpr bool IsReleased(PadButton button) const noexcept
    {
        return !IsPressing(button) && _prevButtonFlags.Has(button);
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] constexpr bool HasInputButton() const noexcept
    {
        return IsEnabled() && (_buttonFlags.HasAny() || _prevButtonFlags.HasAny());
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] constexpr bool IsARepeat(PadButton button) const noexcept
    {
        return _repeatFlags.Has(button);
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    constexpr void SetPortraitMode(bool isEnabled) noexcept
    {
        _isPortraitMode = isEnabled;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] constexpr bool IsPortraitMode() const noexcept
    {
        return _isPortraitMode;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] constexpr PadPriority GetPriority() const noexcept
    {
        return _priority;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    constexpr void SetDecideButton(PadButton button) noexcept
    {
        _decideButton = button;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] constexpr PadButton GetDecideButton() const noexcept
    {
        return _decideButton;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    constexpr void SetCancelButton(PadButton button) noexcept
    {
        _cancelButton = button;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] constexpr PadButton GetCancelButton() const noexcept
    {
        return _cancelButton;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] constexpr const PadDeviceInfo &GetDeviceInfo() const noexcept
    {
        return _deviceInfo;
    }
 
    void ApplyLeftStickToDPad() noexcept;
 
    // コピーとムーブは禁止
    PadState(const PadState &) = delete;
    PadState &operator=(const PadState &) = delete;
    PadState(PadState &&) = delete;
    PadState &operator=(PadState &&) = delete;
 
private:
    void Activate() noexcept;
    void Deactivate() noexcept;
 
    void ApplyDecideCancelButton() noexcept;
    void UpdateRepeatFlags(const RepeatSetting &repeatSetting) noexcept;
 
    PadType _type{PadType::Disable};
    PadID _identifier{PadID::Invalid};
    PadDeviceInfo _deviceInfo;
    bool _isUsing{false};
 
    PadButtonFlags _buttonFlags;
    PadButtonFlags _prevButtonFlags;
    PadButtonFlags _repeatFlags;
 
    Vector2 _leftStick;
    Vector2 _rightStick;
 
    int32_t _playerIndex{-1};
    PadEntry _entry{PadEntry::NoEntry};
 
    PadPriority _priority{PadPriority::Low};
 
    PadButton _decideButton{PadButton::None};
    PadButton _cancelButton{PadButton::None};
 
    bool _isPortraitMode{false};
 
    std::array<float, PadButtonFlags::kSize> _repeatTimerArray;
 
    std::atomic<bool> _shouldActivate{false};
    std::atomic<bool> _shouldDeactivate{false};
};
}    // namespace MGL::Input
 
#endif    // INCGUARD_MGL_GAMEPAD_STATE_H_1609654412
 
// vim: et ts=4 sw=4 sts=4