spk_input_trigger.hpp

#pragma once
 
#include "structure/math/spk_vector2.hpp"
#include "structure/system/device/spk_keyboard.hpp"
#include "structure/system/device/spk_mouse.hpp"
#include "structure/system/event/spk_update_event.hpp"
#include "structure/system/time/spk_duration.hpp"
#include "structure/system/time/spk_timer.hpp"
#include "type/spk_input_state.hpp"
 
#include <functional>
#include <stdexcept>
#include <type_traits>
#include <utility>
 
namespace spk
{
    class InputTrigger
    {
    public:
        virtual ~InputTrigger() = default;
        virtual bool isInitialized() const = 0;
        virtual void initialize(spk::UpdateEvent &p_event) = 0;
        virtual void update() = 0;
    };

    template <typename Device, typename DeviceValue>
    class DeviceInputTrigger : public InputTrigger
    {
    public:
        using Job = std::function<void(const Device *)>;
        using Predicate = std::function<bool()>;
        static inline const long long NoRepeat = -1;
 
    private:
        const Device *_device = nullptr;
 
        DeviceValue _deviceValue;
        spk::InputState _targetState;
 
        spk::Duration _repeatInterval;
        spk::Timer _timer;
        Job _onTriggerCallback;
        Predicate _predicateCallback = []() {
            return true;
        };
 
        bool _lastState = false;
 
    public:
        DeviceInputTrigger(DeviceValue p_deviceValue, spk::InputState p_state, spk::Duration p_repeatInterval, const Job &p_jobCallback) :
            DeviceInputTrigger(p_deviceValue, p_state, p_repeatInterval, [&]() {
                return (true);
            },
                               p_jobCallback)
        {
        }

        DeviceInputTrigger(DeviceValue p_deviceValue, spk::InputState p_state, spk::Duration p_repeatInterval, const Predicate &p_predicateCallback, const Job &p_jobCallback) :
            _deviceValue(p_deviceValue),
            _targetState(p_state),
            _repeatInterval(p_repeatInterval),
            _timer(p_repeatInterval),
            _onTriggerCallback(p_jobCallback),
            _predicateCallback(p_predicateCallback)
        {
        }

        void setDeviceValue(const DeviceValue &p_deviceValue, const spk::InputState &p_state)
        {
            _deviceValue = p_deviceValue;
            _targetState = p_state;
        }

        void setRepeatInterval(const spk::Duration &p_repeatInterval)
        {
            _repeatInterval = p_repeatInterval;
            _timer = spk::Timer(_repeatInterval);
        }

        void setCallback(const Job &p_callback)
        {
            _onTriggerCallback = p_callback;
        }

        void setPredicate(Predicate p_callback)
        {
            _predicateCallback = p_callback ? std::move(p_callback) : Predicate{[]() {
                return true;
            }};
        }

        bool isInitialized() const override
        {
            return (_device != nullptr);
        }

        void initialize(spk::UpdateEvent &p_event) override
        {
            if constexpr (std::is_same_v<Device, spk::Mouse>)
            {
                _device = p_event.mouse;
            }
            else if constexpr (std::is_same_v<Device, spk::Keyboard>)
            {
                _device = p_event.keyboard;
            }
            else
            {
                throw std::runtime_error("Invalid device type");
            }
        }

        const Device *device() const
        {
            return (_device);
        }

        void setDevice(const Device *p_device)
        {
            _device = p_device;
        }

        void update() override
        {
            if (_device == nullptr)
            {
                throw std::runtime_error("Can't update a DeviceInputTrigger without device");
            }
 
            spk::InputState currentState = (*_device)[_deviceValue];
 
            bool needTrigger = (currentState == _targetState);
 
            bool justPressed = needTrigger && _lastState == false;
            _lastState = needTrigger;
 
            const bool shouldFire = _predicateCallback() &&
                                    (justPressed == true ||
                                     (justPressed == false && needTrigger && _repeatInterval >= spk::Duration(0, spk::TimeUnit::Nanosecond) && _timer.state() != spk::Timer::State::Running));
 
            if (shouldFire == true)
            {
                _onTriggerCallback(_device);
 
                if (_repeatInterval > spk::Duration(0, spk::TimeUnit::Nanosecond))
                {
                    _timer.start();
                }
            }
        }
    };
 
    using KeyboardInputTrigger = DeviceInputTrigger<spk::Keyboard, spk::Keyboard::Key>;
    using MouseButtonInputTrigger = DeviceInputTrigger<spk::Mouse, spk::Mouse::Button>;

    class MouseMotionTrigger : public InputTrigger
    {
    public:
        enum class Mode
        {
            Absolute,
            Delta
        };
 
    private:
        std::function<void(const spk::Vector2Int &)> _onTriggerCallback;
        Mode _mode;
        const spk::Mouse *_mouse;
 
    public:
        MouseMotionTrigger(Mode p_mode, const std::function<void(const spk::Vector2Int &)> &p_callback) :
            _onTriggerCallback(p_callback),
            _mode(p_mode),
            _mouse(nullptr)
        {
        }

        bool isInitialized() const override
        {
            return (_mouse != nullptr);
        }

        void initialize(spk::UpdateEvent &p_event) override
        {
            _mouse = p_event.mouse;
        }

        const spk::Mouse *mouse() const
        {
            return (_mouse);
        }

        void setMouse(const spk::Mouse *p_mouse)
        {
            _mouse = p_mouse;
        }

        void update() override
        {
            if (_mouse == nullptr)
            {
                throw std::runtime_error("Can't update a MouseMotionTrigger without device");
            }
 
            _onTriggerCallback(_mode == Mode::Absolute ? _mouse->position : _mouse->deltaPosition);
        }
    };
}