InputManager.hpp

#pragma once
#if !RVE_SERVER
#include "Ref.hpp"
    #include <SDL3/SDL_scancode.h>
    #include <SDL3/SDL_mouse.h>
    #include <SDL3/SDL_events.h>
    #include <SDL3/SDL_gamepad.h>
#include "Function.hpp"
#include "IInputListener.hpp"
#include "SpinLock.hpp"
#include "Map.hpp"
#include "DataStructures.hpp"
#include <RavEngine/mathtypes.hpp>
#include "WeakRef.hpp"
 
namespace RavEngine {
 
    enum ActionState{
        Released = 0,
        Pressed = 1
    };
 
    struct Special {
        enum {
            MOUSEMOVE_X = -500,
            MOUSEMOVE_Y = -501,
            MOUSEMOVE_XVEL = -502,
            MOUSEMOVE_YVEL = -503,
            MOUSEWHEEL_X = -504,
            MOUSEWHEEL_Y = -505,
            CONTROLLER_AXIS_OFFSET = -8000,
            CONTROLLER_BUTTON_OFFSET = -10000
        };
    };
 
    //use this when binding controller buttons
    struct ControllerButton {
        enum {
            SDL_CONTROLLER_BUTTON_INVALID = -1,
            SDL_CONTROLLER_BUTTON_A = Special::CONTROLLER_BUTTON_OFFSET,
            SDL_CONTROLLER_BUTTON_B,
            SDL_CONTROLLER_BUTTON_X,
            SDL_CONTROLLER_BUTTON_Y,
            SDL_CONTROLLER_BUTTON_BACK,
            SDL_CONTROLLER_BUTTON_GUIDE,
            SDL_CONTROLLER_BUTTON_START,
            SDL_CONTROLLER_BUTTON_LEFTSTICK,
            SDL_CONTROLLER_BUTTON_RIGHTSTICK,
            SDL_CONTROLLER_BUTTON_LEFTSHOULDER,
            SDL_CONTROLLER_BUTTON_RIGHTSHOULDER,
            SDL_CONTROLLER_BUTTON_DPAD_UP,
            SDL_CONTROLLER_BUTTON_DPAD_DOWN,
            SDL_CONTROLLER_BUTTON_DPAD_LEFT,
            SDL_CONTROLLER_BUTTON_DPAD_RIGHT,
            SDL_CONTROLLER_BUTTON_MAX
        };
    };
 
    //use this when binding controller axis
    struct ControllerAxis {
        enum {
            SDL_CONTROLLER_AXIS_INVALID = -1,
            SDL_CONTROLLER_AXIS_LEFTX = Special::CONTROLLER_AXIS_OFFSET,
            SDL_CONTROLLER_AXIS_LEFTY,
            SDL_CONTROLLER_AXIS_RIGHTX,
            SDL_CONTROLLER_AXIS_RIGHTY,
            SDL_CONTROLLER_AXIS_TRIGGERLEFT,
            SDL_CONTROLLER_AXIS_TRIGGERRIGHT,
            SDL_CONTROLLER_AXIS_MAX
        };
    };
 
 
    struct Event{
        int ID;
        ActionState value;
    };
 
    //controller IDs
    enum class CID{
        NONE = 0,
        C0 = 1 << 0,
        C1 = 1 << 1,
        C2 = 1 << 2,
        C3 = 1 << 3,
        C4 = 1 << 4,
        C5 = 1 << 5,
        C6 = 1 << 6,
        C7 = 1 << 7,
        
        C8 = 1 << 8,
        C9 = 1 << 9,
        C10 = 1 << 10,
        C11 = 1 << 11,
        C12 = 1 << 12,
        C13 = 1 << 13,
        C14 = 1 << 14,
        C15 = 1 << 15,
        ANY = ~0
    };
    //bitwise
    constexpr inline CID operator | (CID lhs, CID rhs)
    {
        using T = std::underlying_type_t<CID>;
        return static_cast<CID>(static_cast<T>(lhs) | static_cast<T>(rhs));
    }
 
    constexpr inline CID& operator |= (CID& lhs, CID rhs)
    {
        lhs = lhs | rhs;
        return lhs;
    }
    constexpr inline CID operator & (CID lhs, CID rhs)
    {
        using T = std::underlying_type_t<CID>;
        return static_cast<CID>(static_cast<T>(lhs) & static_cast<T>(rhs));
    }
 
    constexpr inline CID& operator &= (CID& lhs, CID rhs)
    {
        lhs = lhs & rhs;
        return lhs;
    }
 
    constexpr inline static CID Make_CID(int x){
        return static_cast<CID>(1 << x);
    }
 
    typedef Function<void(float)> axisCallback;
    typedef Function<void()> actionCallback;
 
    class InputManager
    {
    protected:
        class ActionBinding{
            actionCallback func;    //the lambda to invoke
            void* func_addr = nullptr;      //used for equality comparison
            size_t id;  //used for determining validity
            CID controller;
            ActionState state;
            
        public:
            ActionBinding(decltype(id) id, actionCallback fn, void* addr, CID c, ActionState s) : id(id), func(fn), controller(c), state(s), func_addr(addr){}
            constexpr inline void operator()(ActionState state_in, CID c_in) const{
                if (state_in == state && (controller & c_in) != CID::NONE && IsValid()){
                    func();
                }
            }
            inline bool IsValid() const{
                return true;
            }
            
            constexpr inline bool operator==(const ActionBinding& other) const{
                return controller == other.controller && state == other.state && id == other.id && func_addr == other.func_addr;
            }
        };
        
        class AxisBinding{
        protected:
            axisCallback func;      //the lambda to invoke
            void* func_addr = nullptr;      //used for equality comparison
            size_t id; //used for determining validity
            CID controller;
            float deadzone = 0;
        public:
            AxisBinding(decltype(id) id, axisCallback fn, void* addr, CID c, float dz): id(id), func(fn), func_addr(addr), controller(c),deadzone(dz){}
            
            constexpr inline void operator()(float value, CID c_in) const{
                //check if can run
                if ((controller & c_in) != CID::NONE && IsValid()){
                    func(std::abs(value) >= deadzone ? value : 0);  //pass 0 if in deadzone range
                }
            }
            inline bool IsValid() const{
                return true;
                //return ! bound_object.expired();
            }
            
            constexpr inline bool operator==(const AxisBinding& other) const{
                return deadzone == other.deadzone && controller == other.controller && id == other.id && func_addr == other.func_addr;
            }
        };
        
        
        //stores which mappings each event ID is bound to
        locked_hashmap<int, locked_hashset<std::string,SpinLock>,SpinLock> CodeToAction;
        //the binding objects, keyed by binding ID
        locked_hashmap<std::string, LinkedList<ActionBinding>,SpinLock> ActionBindings;
        //stores which mappings each event ID is bound to
        struct AxisID{
            std::string identifier;
            float scale = 1;
        };
        
        struct aid_hasher{
            inline std::size_t operator()(const AxisID& other) const{
                std::hash<std::string> hasher;
                return hasher(other.identifier);
            }
        };
        
        struct aid_eq{
            inline bool operator()(const AxisID& A, const AxisID& B) const{
                return A.identifier == B.identifier && A.scale == B.scale;
            }
        };
        
        locked_hashmap<int, locked_hashset<AxisID,SpinLock,aid_hasher,aid_eq>,SpinLock> CodeToAxis;
        //the buffered axis inputs for each identifier
        struct AxisInput{
            float value;
            CID source_controller;
        };
        struct AxisData{
            UnorderedMap<int,AxisInput> bufferedInputs;
            LinkedList<AxisBinding> bindings;
        };
        UnorderedMap<std::string, AxisData> AxisBindings;
        
        //AnyActions
        LinkedList<WeakPtrKey<IInputListener>> AnyEventBindings;
        
        void ProcessActionID(int ID, ActionState state_in, CID controller);
        
        void ProcessAxisID(int ID, float value, CID controller);
        
        void CleanupBindings();
    public:
        InputManager();
 
        static vector2 GetMousePosPixels(float dpiScaleFactor);
        
        //process axis maps
        void TickAxes();
        
        void ProcessInput(const SDL_Event&, uint32_t windowflags, float scale, int windowWidth, int windowHeight, float dpiScale);
 
        inline void AddActionMap(const std::string& name, int Id){
            CodeToAction[Id].insert(name);
        }
        
        inline void AddAxisMap(const std::string& name, int Id, float scale = 1){
            CodeToAxis[Id].insert({name,scale});
        }
        
        inline void RemoveActionMap(const std::string& name, int Id){
            CodeToAction[Id].erase(name);
        }
        
        inline void RemoveAxisMap(const std::string& name, int Id, float scale = 1){
            CodeToAxis[Id].erase({name, scale});
        }
        
        template<class U,typename T>
        inline void BindAction(const std::string& name, T thisptr, void(U::* f)(), ActionState type, CID controllers){
            auto binding = [=]() mutable{
                (thisptr.get()->*f)();
            };
            ActionBinding ab(thisptr.get_id(),binding,&f,controllers,type);
            
            ActionBindings[name].push_back(ab);
        }
 
        template<typename U, typename T>
        inline void BindAxis(const std::string& name, T thisptr, void(U::* f)(float), CID controllers, float deadZone = 0) {
            auto func = [=](float amt) mutable{
                (thisptr.get()->*f)(amt);
            };
            AxisBinding ab(thisptr.get_id(), func, &f, controllers, deadZone);
            
            AxisBindings[name].bindings.push_back(ab);
        }
 
        template<typename U, typename T>
        inline void UnbindAction(const std::string& name, T thisptr, void(U::* f)(), ActionState type, CID controllers){
            auto binding = [=](){
                (thisptr.get()->*f)();
            };
            ActionBinding ab(thisptr.get_id(),binding,&f,controllers,type);
            
            ActionBindings[name].remove(ab);    //remove the first binding that compares equal
        }
        
        template<typename U, typename T>
        inline void UnbindAxis(const std::string& name, T thisptr, void(U::* f)(float), CID controllers, float deadZone){
            auto func = [=](float amt){
                (thisptr.get()->*f)(amt);
            };
            AxisBinding ab(thisptr.get_id(), func, &f, controllers, deadZone);
            
            AxisBindings[name].bindings.remove(ab);
        }
        
        inline void BindAnyAction(Ref<IInputListener> listener){
            AnyEventBindings.push_back(listener);
        }
        
        inline void UnbindAnyAction(Ref<IInputListener> listener){
            AnyEventBindings.remove(listener);
        }
    };
}
#endif