InputManager.h

#pragma once
 
#include <cstdint>
#include <functional>
#include <glm/glm.hpp>
#include <string>
#include <unordered_map>
#include <vector>
 
#include "XrInputHandler.h"
#include "XrRig.h"
 
namespace Input
{
    namespace Actions
    {
        inline constexpr auto XrLeftTrigger = "XR.LeftTrigger";
        inline constexpr auto XrRightTrigger = "XR.RightTrigger";
        inline constexpr auto XrLeftGrip = "XR.LeftGrip";
        inline constexpr auto XrRightGrip = "XR.RightGrip";
        inline constexpr auto XrLeftThumbstick = "XR.LeftThumbstick";
        inline constexpr auto XrRightThumbstick = "XR.RightThumbstick";
        inline constexpr auto XrRightAButton = "XR.RightAButton";
        inline constexpr auto XrRightBButton = "XR.RightBButton";
        inline constexpr auto XrLeftXButton = "XR.LeftXButton";
        inline constexpr auto XrLeftYButton = "XR.LeftYButton";
        inline constexpr auto XrMenu = "XR.Menu";
    }  // namespace Actions

    class InputManager
    {
    public:
        InputManager();
        ~InputManager() = default;
        enum class DispatchRule
        {
            EveryFrame,  
            Changed,     
            Pressed,     
            Released,    
        };

        enum class ActionValueType
        {
            Bool,   
            Float,  
            Vec2,   
        };

        struct CallbackHandle
        {
            uint64_t id = 0;  

            [[nodiscard]] explicit operator bool() const
            {
                return id != 0;
            }
        };

        void setupDefaultBindings();

        struct ProviderHandle
        {
            uint64_t id = 0;  
 
            ActionValueType type = ActionValueType::Bool;  
            std::string     name;                          

            [[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 )>;

        ProviderHandle bindBoolAction( std::string name, BoolProvider provider );

        ProviderHandle bindFloatAction( std::string name, FloatProvider provider );

        ProviderHandle 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 removeProvider( ProviderHandle 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;
 
        const XrInputHandler& getXrInputHandler() const;
        XrInputHandler& getXrInputHandler();
        const XrRig& getXrRig() const;
        XrRig& getXrRig();
 
    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;            
            uint64_t                       providerId = 0;      
            bool                           current    = false;  
            bool                           previous   = false;  
            std::vector<BoolCallbackEntry> callbacks;           
        };

        struct Vec2Action
        {
            Vec2Provider                   provider;          
            uint64_t                       providerId = 0;    
            glm::vec2                      current{ 0.0f };   
            glm::vec2                      previous{ 0.0f };  
            std::vector<Vec2CallbackEntry> callbacks;         
        };

        struct FloatAction
        {
            FloatProvider                   provider;           
            uint64_t                        providerId = 0;     
            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;     
        uint64_t                                     nextProviderId_      = 1;     
        bool                                         callbacksDispatched_ = true;  
 
        XrInputHandler xrInputHandler_;
        XrRig xrRig_;
    };

    class InputBindingScope
    {
    public:
        InputBindingScope() = default;

        explicit InputBindingScope( InputManager & inputManager );

        InputBindingScope( const InputBindingScope & ) = delete;

        InputBindingScope & operator=( const InputBindingScope & ) = delete;

        InputBindingScope( InputBindingScope && other ) noexcept;

        InputBindingScope & operator=( InputBindingScope && other ) noexcept;

        ~InputBindingScope();

        void add( InputManager & inputManager, InputManager::ProviderHandle handle );

        void add( InputManager & inputManager, InputManager::CallbackHandle handle );

        void reset();
 
    private:
        void bindTo( InputManager & inputManager );
 
        InputManager *                            inputManager_ = nullptr;  
        std::vector<InputManager::ProviderHandle> providerHandles_;         
        std::vector<InputManager::CallbackHandle> callbackHandles_;         
    };
}  // namespace Input