InputManager.hpp

Go to the documentation of this file.

#pragma once
 
#include <GLFW/glfw3.h>
#include <glm/vec2.hpp>
 
#include <functional>
#include <vector>
 
#include "CallableFunction.hpp"
#include "FunctionContainer.hpp"
#include "core/Core.hpp"
#include "resource/Window.hpp"
 
namespace Input::Resource {
class InputManager {
  public:
    explicit InputManager(Engine::Core &core) : _core(core)
    {
        _keyCallbacks = std::make_shared<KeyCallbackContainer>();
        _charCallbacks = std::make_shared<CharCallbackContainer>();
        _charModsCallbacks = std::make_shared<CharModsCallbackContainer>();
        _mouseButtonCallbacks = std::make_shared<MouseButtonCallbackContainer>();
        _cursorPosCallbacks = std::make_shared<CursorPosCallbackContainer>();
        _cursorEnterCallbacks = std::make_shared<CursorEnterCallbackContainer>();
        _scrollCallbacks = std::make_shared<ScrollCallbackContainer>();
        _dropCallbacks = std::make_shared<DropCallbackContainer>();
    }
    ~InputManager() = default;

    template <typename TCallable> inline FunctionUtils::FunctionID RegisterKeyCallback(TCallable callback)
    {
        using KeyCallback = FunctionUtils::CallableFunction<TCallable, void, Engine::Core &, int, int, int, int>;
        std::unique_ptr<FunctionUtils::BaseFunction<void, Engine::Core &, int, int, int, int>> keyCallback =
            std::make_unique<KeyCallback>(callback);
 
        return _keyCallbacks->AddFunction(std::move(keyCallback));
    }

    template <typename TCallable> inline FunctionUtils::FunctionID RegisterCharCallback(TCallable callback)
    {
        using CharCallback = FunctionUtils::CallableFunction<TCallable, void, Engine::Core &, unsigned int>;
        std::unique_ptr<FunctionUtils::BaseFunction<void, Engine::Core &, unsigned int>> charCallback =
            std::make_unique<CharCallback>(callback);
 
        return _charCallbacks->AddFunction(std::move(charCallback));
    }

    template <typename TCallable> inline FunctionUtils::FunctionID RegisterCharModsCallback(TCallable callback)
    {
        using CharModsCallback = FunctionUtils::CallableFunction<TCallable, void, Engine::Core &, unsigned int, int>;
        std::unique_ptr<FunctionUtils::BaseFunction<void, Engine::Core &, unsigned int, int>> charModsCallback =
            std::make_unique<CharModsCallback>(callback);
 
        return _charModsCallbacks->AddFunction(std::move(charModsCallback));
    }

    template <typename TCallable> inline FunctionUtils::FunctionID RegisterMouseButtonCallback(TCallable callback)
    {
        using MouseButtonCallback = FunctionUtils::CallableFunction<TCallable, void, Engine::Core &, int, int, int>;
        std::unique_ptr<FunctionUtils::BaseFunction<void, Engine::Core &, int, int, int>> mouseButtonCallback =
            std::make_unique<MouseButtonCallback>(callback);
 
        return _mouseButtonCallbacks->AddFunction(std::move(mouseButtonCallback));
    }

    template <typename TCallable> inline FunctionUtils::FunctionID RegisterCursorPosCallback(TCallable callback)
    {
        using CursorPosCallback = FunctionUtils::CallableFunction<TCallable, void, Engine::Core &, double, double>;
        std::unique_ptr<FunctionUtils::BaseFunction<void, Engine::Core &, double, double>> cursorPosCallback =
            std::make_unique<CursorPosCallback>(callback);
 
        return _cursorPosCallbacks->AddFunction(std::move(cursorPosCallback));
    }

    template <typename TCallable> inline FunctionUtils::FunctionID RegisterCursorEnterCallback(TCallable callback)
    {
        using CursorEnterCallback = FunctionUtils::CallableFunction<TCallable, void, Engine::Core &, int>;
        std::unique_ptr<FunctionUtils::BaseFunction<void, Engine::Core &, int>> cursorEnterCallback =
            std::make_unique<CursorEnterCallback>(callback);
 
        return _cursorEnterCallbacks->AddFunction(std::move(cursorEnterCallback));
    }

    template <typename TCallable> inline FunctionUtils::FunctionID RegisterScrollCallback(TCallable callback)
    {
        using ScrollCallback = FunctionUtils::CallableFunction<TCallable, void, Engine::Core &, double, double>;
        std::unique_ptr<FunctionUtils::BaseFunction<void, Engine::Core &, double, double>> scrollCallback =
            std::make_unique<ScrollCallback>(callback);
 
        return _scrollCallbacks->AddFunction(std::move(scrollCallback));
    }

    template <typename TCallable> inline FunctionUtils::FunctionID RegisterDropCallback(TCallable callback)
    {
        using DropCallback = FunctionUtils::CallableFunction<TCallable, void, Engine::Core &, int, const char **>;
        std::unique_ptr<FunctionUtils::BaseFunction<void, Engine::Core &, int, const char **>> dropCallback =
            std::make_unique<DropCallback>(callback);
 
        return _dropCallbacks->AddFunction(std::move(dropCallback));
    }

    inline void CallKeyCallbacks(Engine::Core &core, int key, int scancode, int action, int mods)
    {
        for (auto &callback : _keyCallbacks->GetFunctions())
        {
            callback->Call(core, key, scancode, action, mods);
        }
    }

    inline void CallCharCallbacks(Engine::Core &core, unsigned int codepoint)
    {
        for (auto &callback : _charCallbacks->GetFunctions())
        {
            callback->Call(core, codepoint);
        }
    }

    inline void CallCharModsCallbacks(Engine::Core &core, unsigned int codepoint, int mods) const
    {
        for (auto &callback : _charModsCallbacks->GetFunctions())
        {
            callback->Call(core, codepoint, mods);
        }
    }

    inline void CallMouseButtonCallbacks(Engine::Core &core, int button, int action, int mods) const
    {
        for (auto &callback : _mouseButtonCallbacks->GetFunctions())
        {
            callback->Call(core, button, action, mods);
        }
    }

    inline void CallCursorPosCallbacks(Engine::Core &core, double xpos, double ypos) const
    {
        for (auto &callback : _cursorPosCallbacks->GetFunctions())
        {
            callback->Call(core, xpos, ypos);
        }
    }

    inline void CallCursorEnterCallbacks(Engine::Core &core, int entered) const
    {
        for (auto &callback : _cursorEnterCallbacks->GetFunctions())
        {
            callback->Call(core, entered);
        }
    }

    inline void CallScrollCallbacks(Engine::Core &core, double xoffset, double yoffset) const
    {
        for (auto &callback : _scrollCallbacks->GetFunctions())
        {
            callback->Call(core, xoffset, yoffset);
        }
    }

    inline void CallDropCallbacks(Engine::Core &core, int count, const char **paths) const
    {
        for (auto &callback : _dropCallbacks->GetFunctions())
        {
            callback->Call(core, count, paths);
        }
    }

    inline bool DeleteKeyCallback(FunctionUtils::FunctionID id) { return _keyCallbacks->DeleteFunction(id) != nullptr; }

    inline bool DeleteCharCallback(FunctionUtils::FunctionID id)
    {
        return _charCallbacks->DeleteFunction(id) != nullptr;
    }

    inline bool DeleteCharModsCallback(FunctionUtils::FunctionID id)
    {
        return _charModsCallbacks->DeleteFunction(id) != nullptr;
    }

    inline bool DeleteMouseButtonCallback(FunctionUtils::FunctionID id)
    {
        return _mouseButtonCallbacks->DeleteFunction(id) != nullptr;
    }

    inline bool DeleteCursorPosCallback(FunctionUtils::FunctionID id)
    {
        return _cursorPosCallbacks->DeleteFunction(id) != nullptr;
    }

    inline bool DeleteCursorEnterCallback(FunctionUtils::FunctionID id)
    {
        return _cursorEnterCallbacks->DeleteFunction(id) != nullptr;
    }

    inline bool DeleteScrollCallback(FunctionUtils::FunctionID id)
    {
        return _scrollCallbacks->DeleteFunction(id) != nullptr;
    }

    inline bool DeleteDropCallback(FunctionUtils::FunctionID id)
    {
        return _dropCallbacks->DeleteFunction(id) != nullptr;
    }
 
    inline bool IsKeyPressed(int key) noexcept
    {
        return glfwGetKey(_core.GetResource<Window::Resource::Window>().GetGLFWWindow(), key) == GLFW_PRESS;
    }
 
  private:
    Engine::Core &_core;
    using KeyCallbackContainer = FunctionUtils::FunctionContainer<void, Engine::Core &, int, int, int, int>;
    std::shared_ptr<KeyCallbackContainer> _keyCallbacks;
    using CharCallbackContainer = FunctionUtils::FunctionContainer<void, Engine::Core &, unsigned int>;
    std::shared_ptr<CharCallbackContainer> _charCallbacks;
    using CharModsCallbackContainer = FunctionUtils::FunctionContainer<void, Engine::Core &, unsigned int, int>;
    std::shared_ptr<CharModsCallbackContainer> _charModsCallbacks;
    using MouseButtonCallbackContainer = FunctionUtils::FunctionContainer<void, Engine::Core &, int, int, int>;
    std::shared_ptr<MouseButtonCallbackContainer> _mouseButtonCallbacks;
    using CursorPosCallbackContainer = FunctionUtils::FunctionContainer<void, Engine::Core &, double, double>;
    std::shared_ptr<CursorPosCallbackContainer> _cursorPosCallbacks;
    using CursorEnterCallbackContainer = FunctionUtils::FunctionContainer<void, Engine::Core &, int>;
    std::shared_ptr<CursorEnterCallbackContainer> _cursorEnterCallbacks;
    using ScrollCallbackContainer = FunctionUtils::FunctionContainer<void, Engine::Core &, double, double>;
    std::shared_ptr<ScrollCallbackContainer> _scrollCallbacks;
    using DropCallbackContainer = FunctionUtils::FunctionContainer<void, Engine::Core &, int, const char **>;
    std::shared_ptr<DropCallbackContainer> _dropCallbacks;
};
} // namespace Input::Resource