InputManager.h

#pragma once
 
#include "IInputProvider.h"
 
#include "Foundation/StringView.h"
 
#include "Foundation/Platform/Keyboard.h"
#include "Foundation/Platform/Gestures.h"
 
namespace Cogs
{
  namespace Core
  {
    class Context;
    class ViewContext;
 
    struct InputDevices
    {
      enum EValues
      {
        Mouse = 0,
        Keyboard,
        Gamepad0,
        Gamepad1,
        Gamepad2,
        Gamepad3,
        LeftHandController,
        RightHandController,
        Custom
      };
    };
 
    class COGSCORE_DLL_API InputManager
    {
    public:
      explicit InputManager(ViewContext* viewContext);
 
      ~InputManager();
 
      // Disable copy constructors to avoid issues with vector of unique_ptr
      InputManager(const InputManager&) = delete;
      InputManager& operator=(const InputManager&) = delete;
 
      void initialize();
 
      void addProvider(std::unique_ptr<IInputProvider> provider);
 
      void createAxisMapping(const InputIdentifier & axisId, const StringView & name);
 
      void createActionMapping(const InputIdentifier & actionId, const StringView & name);
 
      float getAxisValue(const StringView & name) const;
 
      bool getActionState(const StringView & name) const;
 
      void update();
 
      inline Cogs::Core::InputIdentifier getAxis(std::string driver, std::string device, std::string axis)
      {
        return InputIdentifier{ { driver, device }, axis };
      }
 
      size_t getAxisIndex(InputDeviceState * device, const StringView & inputAxis) const;
 
      void addAxisMapping(const StringView & name, const StringView & device, const StringView & inputAxis, float scale = 1.0f, int flags = 0);
      void addAxisMapping(const StringView & name, InputDeviceState * device, const StringView & inputAxis, float scale = 1.0f, int flags = 0);
 
      size_t getButtonIndex(InputDeviceState * device, const StringView & inputAction) const;
 
      void addActionMapping(const StringView & name, const StringView & device, const StringView & inputAction, int placeholder = 0);
      void addActionMapping(const StringView & name, InputDeviceState * device, const StringView & inputAction, int placeholder = 0);
 
      void gainedFocus(double timestamp_ms);
      void lostFocus(double timestamp_ms);
 
      void triggerPointerPress(PointerType pointerType, PointerId pointerId, MouseButton button, const glm::ivec2& position, double timestamp_ms);
      void triggerPointerRelease(PointerType pointerType, PointerId pointerId, MouseButton button, const glm::ivec2& position, double timestamp_ms);
      void triggerPointerMove(PointerType pointerType, PointerId pointerId, const glm::ivec2& position, double timestamp_ms);
      void triggerMouseWheel(int32_t deltaValue, double timestamp_ms);
 
      void triggerKeyDown(Key key, double timestamp_ms);
      void triggerKeyUp(Key key, double timestamp_ms);
      void triggerKeyChar(std::string ch, double timestamp_ms);
 
      // TODO: Trigger controller input
 
      InputDeviceState & getDevice(InputDevices::EValues deviceId);
      ViewContext * getView() const { return view; }
 
    private:
      void updateConnections();
      void updateInputs();
      void updateActions();
      void updateAxes();
 
      double checkTimeStamp(double timestamp_ms);
 
      void readInputConfig(const StringView & path);
 
      InputDeviceState * getDevice(const StringView & name);
 
      ViewContext* view = nullptr;
 
      double prevTimeStamp = 0.0;
 
      static constexpr size_t NoAxis = static_cast<size_t>(-1);
      static constexpr size_t NoButton = static_cast<size_t>(-1);
 
      static constexpr size_t ErrorAxis = static_cast<size_t>(-2);
      static constexpr size_t ErrorButton = static_cast<size_t>(-2);
 
      struct SourceAxisMapping
      {
        std::string axisName;
 
        size_t deviceId;
        size_t axisId;
 
        float scale = 1.0f;
 
        int flags = 0;
      };
 
      struct InputAxisMapping
      {
        std::string name;
 
        float value = 0;
 
        std::vector<SourceAxisMapping> inputs;
      };
 
      struct SourceActionMapping
      {
        std::string actionName;
 
        size_t deviceId;
        size_t buttonId;
        // Modifiers etc.
      };
 
      struct InputActionMapping
      {
        std::string name;
 
        bool value = false;
 
        std::vector<SourceActionMapping> inputs;
      };
 
      std::vector<InputDeviceState> deviceStates;
 
      std::unordered_map<size_t, InputAxisMapping> axisMappings;
      std::unordered_map<size_t, InputActionMapping> actionMappings;
 
      std::vector<std::unique_ptr<IInputProvider>> inputProviders;
 
      std::vector<InputDeviceIdentifier> pendingDevices;
 
      friend void inputInspector(Context * context, bool * show);
    };
  }
}