InputManager.hpp

Go to the documentation of this file.

#ifndef DONUT_EVENTS_INPUT_MANAGER_HPP
#define DONUT_EVENTS_INPUT_MANAGER_HPP
 
#include <donut/UniqueHandle.hpp>
#include <donut/events/Event.hpp>
#include <donut/events/Input.hpp>
#include <donut/math.hpp>
 
#include <array>         // std::array
#include <bitset>        // std::bitset
#include <cstddef>       // std::size_t
#include <optional>      // std::optional
#include <type_traits>   // std::is_same_v, std::is_enum_v, std::underlying_type_t
#include <unordered_map> // std::unordered_map
#include <vector>        // std::vector
 
namespace donut::events {
 
struct InputManagerOptions {
    float mouseSensitivity = 0.00038397243543875251f;
 
    float controllerLeftStickSensitivity = 1.0f;
 
    float controllerRightStickSensitivity = 1.0f;
 
    float controllerLeftStickDeadzone = 0.2f;
 
    float controllerRightStickDeadzone = 0.2f;
 
    float controllerLeftTriggerDeadzone = 0.2f;
 
    float controllerRightTriggerDeadzone = 0.2f;
 
    float touchMotionSensitivity = 1.0f;
 
    float touchPressureDeadzone = 0.2f;
};
 
class InputManager {
public:
    static constexpr std::size_t OUTPUT_COUNT = 64;
 
    using Outputs = std::bitset<OUTPUT_COUNT>;
 
    struct Binding {
        Input input;
        Outputs outputs;
    };
 
    InputManager(const InputManagerOptions& options = {});
 
    ~InputManager();
 
    InputManager(const InputManager&) = delete;
 
    InputManager(InputManager&&) = delete;
 
    InputManager& operator=(const InputManager&) = delete;
 
    InputManager& operator=(InputManager&&) = delete;
 
    void prepareForEvents();
 
    void handleEvent(const Event& event);
 
    void bind(Input input, Outputs outputs);
 
    void addBinding(Input input, Outputs outputs);
 
    void unbind(Input input);
 
    void unbindAll() noexcept;
 
    void press(Input input, i32 offset = 32767) noexcept;
 
    void release(Input input, i32 offset = -32767) noexcept;
 
    void move(Input input, i32 offset) noexcept;
 
    void set(Input input, i32 value) noexcept;
 
    void resetAllInputs() noexcept;
 
    void setMouseSensitivity(float sensitivity) noexcept;
 
    void setControllerLeftStickSensitivity(float sensitivity) noexcept;
 
    void setControllerRightStickSensitivity(float sensitivity) noexcept;
 
    void setControllerLeftStickDeadzone(float deadzone) noexcept;
 
    void setControllerRightStickDeadzone(float deadzone) noexcept;
 
    void setControllerLeftTriggerDeadzone(float deadzone) noexcept;
 
    void setControllerRightTriggerDeadzone(float deadzone) noexcept;
 
    void setTouchMotionSensitivity(float sensitivity) noexcept;
 
    void setTouchPressureDeadzone(float deadzone) noexcept;
 
    [[nodiscard]] bool hasAnyBindings() const noexcept;
 
    [[nodiscard]] std::vector<Binding> getBindings() const;
 
    [[nodiscard]] std::optional<Outputs> findBinding(Input input) const noexcept;
 
    [[nodiscard]] std::optional<vec2> getMousePosition() const noexcept;
 
    [[nodiscard]] bool mouseJustMoved() const noexcept;
 
    [[nodiscard]] bool mouseWheelJustScrolledHorizontally() const noexcept;
 
    [[nodiscard]] bool mouseWheelJustScrolledVertically() const noexcept;
 
    [[nodiscard]] bool isControllerConnected() const noexcept;
 
    [[nodiscard]] std::optional<vec2> getControllerLeftStickPosition() const noexcept;
 
    [[nodiscard]] std::optional<vec2> getControllerRightStickPosition() const noexcept;
 
    [[nodiscard]] std::optional<float> getControllerLeftTriggerPosition() const noexcept;
 
    [[nodiscard]] std::optional<float> getControllerRightTriggerPosition() const noexcept;
 
    [[nodiscard]] bool controllerLeftStickJustMoved() const noexcept;
 
    [[nodiscard]] bool controllerRightStickJustMoved() const noexcept;
 
    [[nodiscard]] bool controllerLeftTriggerJustMoved() const noexcept;
 
    [[nodiscard]] bool controllerRightTriggerJustMoved() const noexcept;
 
    [[nodiscard]] std::optional<vec2> getTouchPosition() const noexcept;
 
    [[nodiscard]] std::optional<float> getTouchPressure() const noexcept;
 
    [[nodiscard]] bool touchJustMoved() const noexcept;
 
    [[nodiscard]] bool touchJustChangedPressure() const noexcept;
 
    [[nodiscard]] Outputs getCurrentOutputs() const noexcept;
 
    [[nodiscard]] Outputs getPreviousOutputs() const noexcept;
 
    [[nodiscard]] Outputs getJustPressedOutputs() const noexcept;
 
    [[nodiscard]] Outputs getJustReleasedOutputs() const noexcept;
 
    [[nodiscard]] bool isPressed(std::size_t output) const noexcept;
 
    [[nodiscard]] bool justPressed(std::size_t output) const noexcept;
 
    [[nodiscard]] bool justReleased(std::size_t output) const noexcept;
 
    [[nodiscard]] i32 getAbsoluteState(std::size_t output) const noexcept;
 
    [[nodiscard]] i32 getRelativeState(std::size_t output) const noexcept;
 
    [[nodiscard]] float getAbsoluteValue(std::size_t outputPositive) const noexcept;
 
    [[nodiscard]] float getRelativeValue(std::size_t outputPositive) const noexcept;
 
    [[nodiscard]] float getAbsoluteValue(std::size_t outputNegative, std::size_t outputPositive) const noexcept;
 
    [[nodiscard]] float getRelativeValue(std::size_t outputNegative, std::size_t outputPositive) const noexcept;
 
    [[nodiscard]] vec2 getAbsoluteValue(std::size_t outputNegativeX, std::size_t outputPositiveX, std::size_t outputNegativeY, std::size_t outputPositiveY) const noexcept;
 
    [[nodiscard]] vec2 getRelativeValue(std::size_t outputNegativeX, std::size_t outputPositiveX, std::size_t outputNegativeY, std::size_t outputPositiveY) const noexcept;
 
    [[nodiscard]] vec3 getAbsoluteValue(std::size_t outputNegativeX, std::size_t outputPositiveX, std::size_t outputNegativeY, std::size_t outputPositiveY,
        std::size_t outputNegativeZ, std::size_t outputPositiveZ) const noexcept;
 
    [[nodiscard]] vec3 getRelativeValue(std::size_t outputNegativeX, std::size_t outputPositiveX, std::size_t outputNegativeY, std::size_t outputPositiveY,
        std::size_t outputNegativeZ, std::size_t outputPositiveZ) const noexcept;
 
    [[nodiscard]] bool isPressed(Input input) const noexcept;
 
    [[nodiscard]] bool justPressed(Input input) const noexcept;
 
    [[nodiscard]] bool justReleased(Input input) const noexcept;
 
    template <typename... Actions>
    void bind(Input input, Actions... actions) requires((std::is_enum_v<Actions> && !std::is_same_v<Actions, Input>) && ...) {
        Outputs outputs{};
        (outputs.set(static_cast<std::size_t>(static_cast<std::underlying_type_t<Actions>>(actions))), ...);
        bind(input, outputs);
    }
 
    template <typename... Actions>
    void addBinding(Input input, Actions... actions) requires((std::is_enum_v<Actions> && !std::is_same_v<Actions, Input>) && ...) {
        Outputs outputs{};
        (outputs.set(static_cast<std::size_t>(static_cast<std::underlying_type_t<Actions>>(actions))), ...);
        addBinding(input, outputs);
    }
 
    template <typename Action>
    [[nodiscard]] bool isPressed(Action action) const noexcept requires(std::is_enum_v<Action> && !std::is_same_v<Action, Input>) {
        return isPressed(static_cast<std::size_t>(static_cast<std::underlying_type_t<Action>>(action)));
    }
 
    template <typename Action>
    [[nodiscard]] bool justPressed(Action action) const noexcept requires(std::is_enum_v<Action> && !std::is_same_v<Action, Input>) {
        return justPressed(static_cast<std::size_t>(static_cast<std::underlying_type_t<Action>>(action)));
    }
 
    template <typename Action>
    [[nodiscard]] bool justReleased(Action action) const noexcept requires(std::is_enum_v<Action> && !std::is_same_v<Action, Input>) {
        return justReleased(static_cast<std::size_t>(static_cast<std::underlying_type_t<Action>>(action)));
    }
 
    template <typename Action>
    [[nodiscard]] i32 getAbsoluteState(Action action) const noexcept requires(std::is_enum_v<Action> && !std::is_same_v<Action, Input>) {
        return getAbsoluteState(static_cast<std::size_t>(static_cast<std::underlying_type_t<Action>>(action)));
    }
 
    template <typename Action>
    [[nodiscard]] i32 getRelativeState(Action action) const noexcept requires(std::is_enum_v<Action> && !std::is_same_v<Action, Input>) {
        return getRelativeState(static_cast<std::size_t>(static_cast<std::underlying_type_t<Action>>(action)));
    }
 
    template <typename Action>
    [[nodiscard]] float getAbsoluteValue(Action actionPositive) const noexcept requires(std::is_enum_v<Action> && !std::is_same_v<Action, Input>) {
        return getAbsoluteValue(static_cast<std::size_t>(static_cast<std::underlying_type_t<Action>>(actionPositive)));
    }
 
    template <typename Action>
    [[nodiscard]] float getRelativeValue(Action actionPositive) const noexcept requires(std::is_enum_v<Action> && !std::is_same_v<Action, Input>) {
        return getRelativeValue(static_cast<std::size_t>(static_cast<std::underlying_type_t<Action>>(actionPositive)));
    }
 
    template <typename Action>
    [[nodiscard]] float getAbsoluteValue(Action actionNegative, Action actionPositive) const noexcept requires(std::is_enum_v<Action> && !std::is_same_v<Action, Input>) {
        return getAbsoluteValue(static_cast<std::size_t>(static_cast<std::underlying_type_t<Action>>(actionNegative)),
            static_cast<std::size_t>(static_cast<std::underlying_type_t<Action>>(actionPositive)));
    }
 
    template <typename Action>
    [[nodiscard]] float getRelativeValue(Action actionNegative, Action actionPositive) const noexcept requires(std::is_enum_v<Action> && !std::is_same_v<Action, Input>) {
        return getRelativeValue(static_cast<std::size_t>(static_cast<std::underlying_type_t<Action>>(actionNegative)),
            static_cast<std::size_t>(static_cast<std::underlying_type_t<Action>>(actionPositive)));
    }
 
    template <typename Action>
    [[nodiscard]] vec2 getAbsoluteValue(Action actionNegativeX, Action actionPositiveX, Action actionNegativeY, Action actionPositiveY) const noexcept
        requires(std::is_enum_v<Action> && !std::is_same_v<Action, Input>) {
        return getAbsoluteValue(static_cast<std::size_t>(static_cast<std::underlying_type_t<Action>>(actionNegativeX)),
            static_cast<std::size_t>(static_cast<std::underlying_type_t<Action>>(actionPositiveX)),
            static_cast<std::size_t>(static_cast<std::underlying_type_t<Action>>(actionNegativeY)),
            static_cast<std::size_t>(static_cast<std::underlying_type_t<Action>>(actionPositiveY)));
    }
 
    template <typename Action>
    [[nodiscard]] vec2 getRelativeValue(Action actionNegativeX, Action actionPositiveX, Action actionNegativeY, Action actionPositiveY) const noexcept
        requires(std::is_enum_v<Action> && !std::is_same_v<Action, Input>) {
        return getRelativeValue(static_cast<std::size_t>(static_cast<std::underlying_type_t<Action>>(actionNegativeX)),
            static_cast<std::size_t>(static_cast<std::underlying_type_t<Action>>(actionPositiveX)),
            static_cast<std::size_t>(static_cast<std::underlying_type_t<Action>>(actionNegativeY)),
            static_cast<std::size_t>(static_cast<std::underlying_type_t<Action>>(actionPositiveY)));
    }
 
    template <typename Action>
    [[nodiscard]] vec3 getAbsoluteValue(Action actionNegativeX, Action actionPositiveX, Action actionNegativeY, Action actionPositiveY, Action actionNegativeZ,
        Action actionPositiveZ) const noexcept requires(std::is_enum_v<Action> && !std::is_same_v<Action, Input>) {
        return getAbsoluteValue(static_cast<std::size_t>(static_cast<std::underlying_type_t<Action>>(actionNegativeX)),
            static_cast<std::size_t>(static_cast<std::underlying_type_t<Action>>(actionPositiveX)),
            static_cast<std::size_t>(static_cast<std::underlying_type_t<Action>>(actionNegativeY)),
            static_cast<std::size_t>(static_cast<std::underlying_type_t<Action>>(actionPositiveY)),
            static_cast<std::size_t>(static_cast<std::underlying_type_t<Action>>(actionNegativeZ)),
            static_cast<std::size_t>(static_cast<std::underlying_type_t<Action>>(actionPositiveZ)));
    }
 
    template <typename Action>
    [[nodiscard]] vec3 getRelativeValue(Action actionNegativeX, Action actionPositiveX, Action actionNegativeY, Action actionPositiveY, Action actionNegativeZ,
        Action actionPositiveZ) const noexcept requires(std::is_enum_v<Action> && !std::is_same_v<Action, Input>) {
        return getRelativeValue(static_cast<std::size_t>(static_cast<std::underlying_type_t<Action>>(actionNegativeX)),
            static_cast<std::size_t>(static_cast<std::underlying_type_t<Action>>(actionPositiveX)),
            static_cast<std::size_t>(static_cast<std::underlying_type_t<Action>>(actionNegativeY)),
            static_cast<std::size_t>(static_cast<std::underlying_type_t<Action>>(actionPositiveY)),
            static_cast<std::size_t>(static_cast<std::underlying_type_t<Action>>(actionNegativeZ)),
            static_cast<std::size_t>(static_cast<std::underlying_type_t<Action>>(actionPositiveZ)));
    }
 
private:
    struct ControllerDeleter {
        void operator()(void* handle) const noexcept;
    };
 
    using Controller = UniqueHandle<void*, ControllerDeleter>;
 
    void setMousePosition(vec2 position, vec2 relativeMotion) noexcept;
    void scrollMouseWheelHorizontally(float offset) noexcept;
    void scrollMouseWheelVertically(float offset) noexcept;
 
    void setControllerLeftStickPosition(vec2 position) noexcept;
    void setControllerRightStickPosition(vec2 position) noexcept;
    void setControllerLeftTriggerPosition(float position) noexcept;
    void setControllerRightTriggerPosition(float position) noexcept;
 
    void setTouchPosition(vec2 position) noexcept;
    void setTouchPressure(float pressure) noexcept;
 
    InputManagerOptions options;
    std::unordered_map<Input, Outputs> bindings{};
    std::optional<vec2> mousePosition{};
    Controller controller{};
    std::optional<vec2> controllerLeftStickPosition{};
    std::optional<vec2> controllerRightStickPosition{};
    std::optional<float> controllerLeftTriggerPosition{};
    std::optional<float> controllerRightTriggerPosition{};
    std::optional<vec2> touchPosition{};
    std::optional<float> touchPressure{};
    Outputs currentPersistentOutputs{};
    Outputs previousPersistentOutputs{};
    Outputs transientOutputPresses{};
    Outputs transientOutputReleases{};
    std::array<i32, OUTPUT_COUNT> outputAbsoluteStates{};
    std::array<i32, OUTPUT_COUNT> outputRelativeStates{};
    std::array<u8, OUTPUT_COUNT> outputPersistentPresses{};
    std::bitset<INPUT_COUNT> currentPersistentInputs{};
    std::bitset<INPUT_COUNT> previousPersistentInputs{};
    std::bitset<INPUT_COUNT> transientInputPresses{};
    std::bitset<INPUT_COUNT> transientInputReleases{};
    bool mouseTransientMotion = false;
    bool mouseWheelHorizontalTransientMotion = false;
    bool mouseWheelVerticalTransientMotion = false;
    bool controllerLeftStickTransientMotion = false;
    bool controllerRightStickTransientMotion = false;
    bool controllerLeftTriggerTransientMotion = false;
    bool controllerRightTriggerTransientMotion = false;
    bool touchTransientMotion = false;
    bool touchTransientPressure = false;
};
 
} // namespace donut::events
 
#endif