InputManager.h

Go to the documentation of this file.

#pragma once
 
#include <glm/glm.hpp>
 
#include <cstdint>
#include <functional>
#include <string>
#include <unordered_map>
#include <vector>
 
namespace Input
{
    namespace Actions
    {
        inline constexpr const char* XrLeftTrigger    = "XR.LeftTrigger";
        inline constexpr const char* XrRightTrigger   = "XR.RightTrigger";
        inline constexpr const char* XrLeftGrip       = "XR.LeftGrip";
        inline constexpr const char* XrRightGrip      = "XR.RightGrip";
        inline constexpr const char* XrLeftThumbstick = "XR.LeftThumbstick";
        inline constexpr const char* XrRightThumbstick = "XR.RightThumbstick";
    }  // namespace Actions
 
    class InputManager
    {
    public:
        enum class DispatchRule
        {
            EveryFrame,
            Changed,
            Pressed,
            Released,
        };
 
        struct CallbackHandle
        {
            uint64_t id = 0;
 
            [[nodiscard]] explicit operator bool() const
            {
                return id != 0;
            }
        };
 
        using BoolProvider = std::function<bool()>;
        using FloatProvider = std::function<float()>;
        using Vec2Provider = std::function<glm::vec2()>;
 
        using BoolCallback = std::function<void( bool value )>;
        using FloatCallback = std::function<void( float value )>;
        using Vec2Callback = std::function<void( glm::vec2 value )>;
 
        void bindBoolAction( std::string name, BoolProvider provider );
        void bindFloatAction( std::string name, FloatProvider provider );
        void bindVec2Action( std::string name, Vec2Provider provider );
 
        CallbackHandle onBoolAction( const std::string & name, DispatchRule rule, BoolCallback callback );
        CallbackHandle onBoolPressed( const std::string & name, std::function<void()> callback );
        CallbackHandle onBoolReleased( const std::string & name, std::function<void()> callback );
        CallbackHandle onFloatAction( const std::string & name, DispatchRule rule, FloatCallback callback );
        CallbackHandle onVec2Action( const std::string & name, DispatchRule rule, Vec2Callback callback );
 
        void removeCallback( CallbackHandle handle );
 
        void beginFrame();
        void dispatchCallbacks();
 
        [[nodiscard]] bool getBoolAction( const std::string & name ) const;
        [[nodiscard]] float getFloatAction( const std::string & name ) const;
        [[nodiscard]] glm::vec2 getVec2Action( const std::string & name ) const;
 
    private:
        struct BoolCallbackEntry
        {
            CallbackHandle handle;
            DispatchRule   rule = DispatchRule::EveryFrame;
            BoolCallback   callback;
        };
 
        struct Vec2CallbackEntry
        {
            CallbackHandle handle;
            DispatchRule   rule = DispatchRule::EveryFrame;
            Vec2Callback   callback;
        };
 
        struct FloatCallbackEntry
        {
            CallbackHandle handle;
            DispatchRule   rule = DispatchRule::EveryFrame;
            FloatCallback  callback;
        };
 
        struct BoolAction
        {
            BoolProvider                   provider;
            bool                           current = false;
            bool                           previous = false;
            std::vector<BoolCallbackEntry> callbacks;
        };
 
        struct Vec2Action
        {
            Vec2Provider                   provider;
            glm::vec2                      current{ 0.0f };
            glm::vec2                      previous{ 0.0f };
            std::vector<Vec2CallbackEntry> callbacks;
        };
 
        struct FloatAction
        {
            FloatProvider                    provider;
            float                            current = 0.0f;
            float                            previous = 0.0f;
            std::vector<FloatCallbackEntry>  callbacks;
        };
 
        [[nodiscard]] CallbackHandle makeHandle();
 
        std::unordered_map<std::string, BoolAction> boolActions_;
        std::unordered_map<std::string, FloatAction> floatActions_;
        std::unordered_map<std::string, Vec2Action> vec2Actions_;
        uint64_t                                    nextCallbackId_ = 1;
        bool                                        callbacksDispatched_ = true;
    };
}  // namespace Input