input_map.h

#pragma once
 
#include <cstdint>
#include <bitset>
#include <map>
#include <string>
#include <string_view>
#include <vector>
 
#include <glm/glm.hpp>
#include <glm/gtc/quaternion.hpp>
 
#include "platform/input/input_command.h"
#include "platform/input/input_handle.h"
 
namespace Vkm::Engine {
 
class HostChrome;

namespace InputActions {
    inline constexpr const char* UI_CLICK = "UI/Click";
 
} // namespace InputActions

enum class InputSource : uint8_t {
    Key,
    MouseButton,
};

struct InputBinding {
    InputSource source = InputSource::Key;
    int         code   = 0;     
    float       scale  = 1.0f;  
};

class InputMap {
    public:
        InputMap();
        ~InputMap() = default;
 
        InputMap(const InputMap& other) = delete;
        InputMap& operator=(const InputMap& other) = delete;
 
        InputMap(InputMap && other) = delete;
        InputMap& operator=(InputMap && other) = delete;
 
    public:
        void define(std::string_view action, std::vector<InputBinding> bindings);

        void addBinding(std::string_view action, InputBinding binding);

        void clearBindings(std::string_view action);

        const std::vector<InputBinding>& bindings(std::string_view action) const;

        std::vector<std::string> actions() const;

        void update(InputHandle& input, const HostChrome& chrome);

        void setPointerOverUI(bool over) { m_pointerOverUI = over; }

        void discardPendingEdges();

        void reset();

        void beginTick(uint32_t tick);

        void setView(const glm::quat& view) { m_view = view; }

        int indexOf(std::string_view action) const;

        uint64_t actionFingerprint() const;

        bool held(std::string_view action) const;

        bool pressed(std::string_view action) const;

        bool released(std::string_view action) const;

        float axis(std::string_view action) const;

        bool held(const InputCommand& command, std::string_view action) const;

        bool pressed(const InputCommand& command, std::string_view action) const;

        bool released(const InputCommand& command, std::string_view action) const;

        float axis(const InputCommand& command, std::string_view action) const;

        bool pointerOverUI() const { return m_pointerOverUI; }

        const glm::vec2& pointer() const { return m_pointer; }

        const glm::vec2& pointerDelta() const { return m_pointerDelta; }

        float wheel() const { return m_wheel; }

        float uiWheel() const { return m_uiWheel; }

        std::u32string_view text() const { return m_text; }

        bool typed(int key) const { return key >= 0 && key <= MAX_KEY && m_typed[static_cast<size_t>(key)]; }

        const InputCommand& command() const { return m_command; }

        uint32_t actionCount() const { return m_nextSlot; }
 
    private:
        struct Action {
            std::vector<InputBinding> bindings;
 
            float value     = 0.0f;   
            bool  active    = false;  
            bool  wasActive = false;  
            int   slot      = -1;     
        };

        enum class Holder : uint8_t {
            Host,      
            UI,        
            Gameplay,  
        };

        struct HeldPress {
            InputSource source;
            int         code;
            Holder      holder;
        };

        void defineEngineActions();

        const Action* find(std::string_view action) const;

        Action& mutableAction(std::string_view action);

        void assignSlot(Action& entry, std::string_view action);

        bool heldElsewhere(const InputBinding& binding, bool down, bool hostHas, bool uiHas, bool forUI);
 
    private:
        std::map<std::string, Action, std::less<>> m_actions;
 
        glm::vec2 m_pointer{0.0f};       
        glm::vec2 m_pointerDelta{0.0f};
        float     m_wheel   = 0.0f;      
        float     m_uiWheel = 0.0f;      
 
        std::u32string             m_text;   
        std::bitset<MAX_KEY + 1>   m_typed;  
 
        InputCommand m_command;              
        glm::quat    m_view{1.0f, 0.0f, 0.0f, 0.0f};  
        uint32_t     m_pendingPressed  = 0;  
        uint32_t     m_pendingReleased = 0;
        uint32_t     m_nextSequence    = 1;  
        uint32_t     m_nextSlot        = 0;
 
        bool m_pointerOverUI = false;  

        std::vector<HeldPress> m_heldPresses;
};
 
} // namespace Vkm::Engine