input_system.hpp

Go to the documentation of this file.

 
#ifndef FOOLSENGINE_INPUTSYSTEM_H
#define FOOLSENGINE_INPUTSYSTEM_H
 
#include <string>
#include <map>
#include <queue>
#include <memory>
 
#include <nlohmann/json.hpp>
#include <SDL2/SDL.h>
 
#include "input_data.hpp"
 
namespace ToyMaker {
    class ActionContext;
    class ActionDispatch;
    class InputManager;

    class InputManager {
    public:
        enum ActionContextPriority: uint8_t {
            VERY_LOW=0,
            LOW=1,
            DEFAULT=2,
            HIGH=3,
            VERY_HIGH=4,
            TOTAL=5,
        };

        void queueInput(const SDL_Event& inputEvent);

        void registerInputBind(const nlohmann::json& inputBindingParameters);

        void registerAction(const nlohmann::json& actionParameters);

        void registerActionContext(const ::std::string& name, ActionContextPriority priority=DEFAULT);

        void unregisterActionContext(const ::std::string& name);

        void loadInputConfiguration(const nlohmann::json& inputConfiguration);

        ActionContext& operator[] (const ::std::string& actionContext);

        ::std::vector<::std::pair<ActionDefinition, ActionData>> getTriggeredActions(uint32_t targetTimeMillis);
 
    private:

        double getRawValue(const InputFilter& inputFilter, const SDL_Event& inputEvent) const;

        void registerInputCombo(const ::std::string& actionContext, const InputCombo& inputCombo);

        void unregisterInputCombo(const ::std::string& actionContext, const InputCombo& inputCombo);

        void unregisterInputCombos(const ::std::string& actionContext);

        void unregisterInputCombos();

        ::std::unordered_map<ContextName, ::std::pair<ActionContext, ActionContextPriority>> mActionContexts {};

        ::std::unordered_map<InputFilter, double> mRawInputState {};

        ::std::unordered_map<InputFilter, ::std::set<InputCombo>> mInputFilterToCombos {};

        ::std::unordered_map<InputCombo, ::std::array<
            ::std::set<ContextName>, ActionContextPriority::TOTAL
        >> mInputComboToActionContexts {};

        ::std::unordered_map<InputCombo, UnmappedInputValue> mInputComboStates {};

        ::std::queue<::std::pair<InputCombo, UnmappedInputValue>> mUnmappedInputs {};

        float mModifierThreshold { .7f };
 
    friend class ActionContext;
    };

    class IActionHandler {
    public:
    private:
        virtual bool handleAction(const ActionData& actionData, const ActionDefinition& actionDefinition) {
            (void)actionData; // prevent unused parameter warnings
            (void)actionDefinition; // prevent unused parameter warnings
            return false;
        };
 
    friend class ActionDispatch;
    };

    class ActionContext {
    public:
        ActionContext(InputManager& inputManager, const ContextName& name): mInputManager{inputManager}, mName {name} {}

        ActionContext(InputManager&& inputManager, const ContextName& name) = delete;

        static ActionData ApplyInput(const ActionDefinition& actionDefinition, const ActionData& actionData, const AxisFilter targetAxis, const UnmappedInputValue& inputValue);

        ::std::vector<::std::pair<ActionDefinition, ActionData>> getTriggeredActions();

        void registerAction(const ActionName& name, InputAttributesType attributes);

        void registerAction(const nlohmann::json& actionParameters);

        void unregisterAction(const ActionName& name);

        void registerInputBind(const ActionName& forAction, AxisFilter targetAxis, const InputCombo& withInput);

        void registerInputBind(const nlohmann::json& inputBindParameters);

        void unregisterInputBind(const InputCombo& inputCombo);

        void unregisterInputBinds(const ActionName& forAction);

        void unregisterInputBinds();

        inline bool propagateAllowed() { return mPropagateInput; };
 
        // Enable or disable input propagation to lower priority contexts
        inline void setPropagateAllowed(bool allowPropagate) { mPropagateInput = allowPropagate; }

        inline bool enabled() { return mEnabled; }

        inline void setEnabled(bool enable)  { mEnabled = enable; }
 
    private:
        void resetActionData(const ActionName& forAction, uint32_t timestamp);

        void resetActionData(uint32_t timestamp);

        void mapToAction(const UnmappedInputValue& inputValue, const InputCombo& inputCombo);
 
        /* 
         * @brief A reference to the input manager that created this 
         * action context.
         * 
         * (apparently the technical term for this is "dependency injection via constructor")
        */
        InputManager& mInputManager;

        const ContextName mName;

        bool mEnabled { true };

        bool mPropagateInput { false };

        ::std::unordered_map<ActionDefinition, ActionData> mActions {};

        ::std::vector<::std::pair<ActionDefinition, ActionData>> mPendingTriggeredActions {};

        ::std::unordered_map<ActionDefinition, ::std::set<InputCombo>> mActionToInputBinds {};

        ::std::unordered_map<InputCombo, ::std::pair<AxisFilter, ActionDefinition>> mInputBindToAction {};
 
    friend class InputManager;
    };

    class ActionDispatch {
    public:
        void registerActionHandler(const QualifiedActionName& contextActionPair, ::std::weak_ptr<IActionHandler> actionHandler);

        void unregisterActionHandler(const QualifiedActionName& contextActionPair, ::std::weak_ptr<IActionHandler> actionHandler);

        void unregisterActionHandler(::std::weak_ptr<IActionHandler> actionHandler);

        bool dispatchAction(const ::std::pair<ActionDefinition, ActionData>& pendingAction);
 
    private:

        ::std::map<QualifiedActionName, ::std::set<::std::weak_ptr<IActionHandler>, ::std::owner_less<::std::weak_ptr<IActionHandler>>>, ::std::less<QualifiedActionName>> mActionHandlers {};
    };
}
 
#endif