InputManager.cpp

#include "InputManager.h"
 
#include "GamepadMapping.h"
#include "KeyboardMapping.h"
#include "Platform/Gamepad.h"
 
#include "../Engine.h"
#include "../ViewContext.h"
#include "../Serialization/JsonParser.h"
#include "../Services/Variables.h"
#include "../Utilities/Parsing.h"
 
#include "Foundation/Logging/Logger.h"
 
#include <algorithm>
#include <cmath>
#include <limits>
 
namespace {
  const Cogs::Logging::Log logger = Cogs::Logging::getLogger("InputManager");
 
  void readInputMapping(Cogs::Core::InputManager& inputManager, const Cogs::StringView& axisName, const rapidjson::Value& jsonValue, bool isAxis) {
    std::string device;
    std::string inputName;
    float scale = 1.0f;
 
    if (jsonValue.IsString()) {
      auto source = Cogs::Core::toKey(jsonValue);
      auto splits = Cogs::Core::split(source, ":");
 
      if (splits.size() < 2) {
        LOG_ERROR(logger, "Invalid input source: %.*s", StringViewFormat(source));
        return;
      }
 
      if (splits.size() == 3) {
        scale = Cogs::Core::parseFloat(splits[2], 1.0f);
      }
 
      device = splits[0].to_string();
      inputName = splits[1].to_string();
    }
    else if (jsonValue.IsObject()) {
      for (auto & mm : jsonValue.GetObject()) {
        auto mmKey = Cogs::Core::toKey(mm.name);
 
        if (mmKey == "device") {
          device = Cogs::Core::toString(mm.value);
        }
        else if (mmKey == "axis" || mmKey == "action") {
          inputName = Cogs::Core::toString(mm.value);
        }
        else if (mmKey == "scale") {
          scale = mm.value.GetFloat();
        }
      }
    }
 
    if (!device.empty() && !inputName.empty()) {
      if (isAxis) {
        inputManager.addAxisMapping(axisName, device, inputName, scale);
      }
      else {
        inputManager.addActionMapping(axisName, device, inputName);
      }
    }
  }
}
 
Cogs::Core::InputManager::InputManager(ViewContext* viewContext) :
  view(viewContext),
  deviceStates(16)
{
}
 
Cogs::Core::InputManager::~InputManager()
{
}
 
void Cogs::Core::InputManager::initialize()
{
  auto & mouse = deviceStates[InputDevices::Mouse];
 
  mouse.deviceId = InputDevices::Mouse;
  mouse.id = "Mouse";
  mouse.isConnected = true;
  mouse.isValid = true;
  mouse.buttonMask = 0x7;
  mouse.axisMask = 0x7;
 
  mouse.actionMap = {
    { "LeftButton", 0 },
    { "RightButton", 1 },
    { "MiddleButton", 2 },
  };
 
  mouse.axisMap = {
    { "X", 0 },
    { "Y", 1 },
    { "Wheel", 2 }
  };
 
  addAxisMapping("MouseX", "Mouse", "X", 1.0f);
  addAxisMapping("MouseY", "Mouse", "Y", 1.0f);
 
  addAxisMapping("MouseWheel", "Mouse", "Wheel", 1.0f, 1);
 
  addActionMapping("LeftMouse", "Mouse", "LeftButton");
  addActionMapping("MiddleMouse", "Mouse", "MiddleButton");
  addActionMapping("RightMouse", "Mouse", "RightButton");
 
  auto & keyboard = deviceStates[InputDevices::Keyboard];
 
  keyboard.id = "Keyboard";
  keyboard.deviceId = InputDevices::Keyboard;
  keyboard.isConnected = true;
  keyboard.isValid = true;
 
  keyboard.buttonMask = static_cast<size_t>(-1);
  keyboard.axisMask = static_cast<size_t>(-1);
  keyboard.actionMap = keyMapping;
  keyboard.axisMap = keyMapping;
 
  for (int i = 0; i < 4; ++i) {
    auto & gamepad = deviceStates[InputDevices::Gamepad0 + i];
 
    gamepad.id = "Gamepad" + std::to_string(i);
    if (i == 0) gamepad.alias = "Gamepad";
 
    gamepad.deviceId = InputDevices::Gamepad0 + i;
 
    gamepad.axisMap = gamepadAxisMapping;
    gamepad.actionMap = gamepadButtonMapping;
 
    gamepad.linkedDeadZones[Gamepad::StickRightX] = Gamepad::StickRightY;
    gamepad.linkedDeadZones[Gamepad::StickRightY] = Gamepad::StickRightX;
 
    gamepad.linkedDeadZones[Gamepad::StickLeftX] = Gamepad::StickLeftY;
    gamepad.linkedDeadZones[Gamepad::StickLeftY] = Gamepad::StickLeftX;
  }
 
  readInputConfig(view->getContext()->variables->get("input.config", "Input.config"));
}
 
void Cogs::Core::InputManager::createAxisMapping(const InputIdentifier & axisId, const StringView & name)
{
  auto deviceId = axisId.deviceId.driver + ":" + axisId.deviceId.id;
 
  addAxisMapping(name, deviceId, axisId.inputName);
}
 
void Cogs::Core::InputManager::createActionMapping(const InputIdentifier & actionId, const StringView & name)
{
  auto deviceId = actionId.deviceId.driver + ":" + actionId.deviceId.id;
 
  addActionMapping(name, deviceId, actionId.inputName);
}
 
void Cogs::Core::InputManager::readInputConfig(const StringView & path)
{
  auto document = parseJson(view->getContext(), path, JsonParseFlags::NoCachedContent);
 
  if (!document.IsObject()) return;
 
  for (auto & m : document.GetObject()) {
    auto key = toKey(m.name);
 
    if (key == "axes" || key == "actions") {
      auto axesObj = m.value.GetObject();
 
      for (auto & axesMember : axesObj) {
        auto axisName = toKey(axesMember.name);
 
        if (axesMember.value.IsArray()) {
          for (auto & element : axesMember.value.GetArray()) {
            readInputMapping(*this, axisName, element, key == "axes");
          }
        } else {
          readInputMapping(*this, axisName, axesMember.value, key == "axes");
        }
      }
    }
  }
}
 
void Cogs::Core::InputManager::addProvider(std::unique_ptr<IInputProvider> provider)
{
  inputProviders.push_back(std::move(provider));
}
 
Cogs::Core::InputDeviceState * Cogs::Core::InputManager::getDevice(const StringView & name)
{
  for (auto & d : deviceStates) {
    if (name == d.id || name == d.alias) {
      return &d;
    }
  }
 
  for (size_t i = InputDevices::Custom; i < deviceStates.size(); ++i) {
    auto & d = deviceStates[i];
 
    if (d.id.empty()) {
      d.id = name.to_string();
      d.deviceId = i;
 
      auto splits = split(name, ":");
 
      if (splits.size() >= 2) {
        pendingDevices.push_back(InputDeviceIdentifier{ splits[0].to_string(), splits[1].to_string() });
      }
 
      return &d;
    }
  }
 
  LOG_ERROR(logger, "No device with identifier %.*s found.", StringViewFormat(name));
 
  return nullptr;
}
 
size_t Cogs::Core::InputManager::getAxisIndex(InputDeviceState * device, const StringView & inputAxis) const
{
  if (device->axisMap.empty()) {
    // Axis map has not yet been set. Defer axis lookup until present.
    return NoAxis;
  }
 
  auto found = device->axisMap.find(inputAxis.to_string());
 
  if (found == device->axisMap.end()) {
    LOG_ERROR(logger, "Axis %.*s does not exist on device %s.", StringViewFormat(inputAxis), device->id.c_str());
    return ErrorAxis;
  }
 
  return found->second;
}
 
void Cogs::Core::InputManager::addAxisMapping(const StringView & name, const StringView & deviceName, const StringView & inputAxis, float scale, int flags)
{
  auto device = getDevice(deviceName);
 
  if (!device) return;
 
  addAxisMapping(name, device, inputAxis, scale, flags);
}
 
void Cogs::Core::InputManager::addAxisMapping(const StringView & name, InputDeviceState * device, const StringView & inputAxis, float scale, int flags)
{
  auto & axisMapping = axisMappings[name.hash()];
 
  if (axisMapping.name.empty()) {
    axisMapping.name = name.to_string();
  }
 
  SourceAxisMapping sourceAxis = {};
  sourceAxis.scale = scale;
  sourceAxis.deviceId = device->deviceId;
  sourceAxis.axisName = inputAxis.to_string();
  sourceAxis.axisId = getAxisIndex(device, inputAxis);
  sourceAxis.flags = flags;
 
  if (sourceAxis.axisId == ErrorAxis) return;
 
  axisMapping.inputs.push_back(sourceAxis);
}
 
size_t Cogs::Core::InputManager::getButtonIndex(InputDeviceState * device, const StringView & inputAction) const
{
  if (device->actionMap.empty()) {
    return NoButton;
  }
 
  auto found = device->actionMap.find(inputAction.to_string());
 
  if (found == device->actionMap.end()) {
    LOG_ERROR(logger, "Action %.*s does not exist on device %s.", StringViewFormat(inputAction), device->id.c_str());
    return ErrorButton;
  }
 
  return found->second;
}
 
void Cogs::Core::InputManager::addActionMapping(const StringView & name, const StringView & deviceName, const StringView & inputAction, int placeholder)
{
  auto device = getDevice(deviceName);
 
  if (!device) return;
 
  addActionMapping(name, device, inputAction, placeholder);
}
 
void Cogs::Core::InputManager::addActionMapping(const StringView & name, InputDeviceState * device, const StringView & inputAction, int /*placeholder*/)
{
  auto & actionMapping = actionMappings[name.hash()];
 
  if (actionMapping.name.empty()) {
    actionMapping.name = name.to_string();
  }
 
  SourceActionMapping sourceAction = {};
  sourceAction.deviceId = device->deviceId;
  sourceAction.buttonId = getButtonIndex(device, inputAction);
  sourceAction.actionName = inputAction.to_string();
 
  if (sourceAction.buttonId == ErrorButton) return;
 
  actionMapping.inputs.push_back(sourceAction);
}
 
void Cogs::Core::InputManager::gainedFocus(double /*timestamp_ms*/) {
  // Nothing to do, yay!
}
 
void Cogs::Core::InputManager::lostFocus(double timestamp_ms) {
  timestamp_ms = checkTimeStamp(timestamp_ms);
  view->refGestures().reset();
  view->refMouse().submitReset(timestamp_ms);
  view->refKeyboard().submitReset(timestamp_ms);
}
 
void Cogs::Core::InputManager::triggerPointerPress(PointerType pointerType, PointerId pointerId, MouseButton button, const glm::ivec2& position, double timestamp_ms) {
  timestamp_ms = checkTimeStamp(timestamp_ms);
  if (pointerType == PointerType::Mouse) {
    view->refMouse().submitButtonDown(button, timestamp_ms);
  }
  view->refGestures().pointerDown(pointerType, pointerId, button, position, timestamp_ms);
 
  view->getContext()->engine->setDirty();
}
 
void Cogs::Core::InputManager::triggerPointerRelease(PointerType pointerType, PointerId pointerId, MouseButton button, const glm::ivec2& position, double timestamp_ms) {
  timestamp_ms = checkTimeStamp(timestamp_ms);
  if (pointerType == PointerType::Mouse) {
    view->refMouse().submitButtonUp(button, timestamp_ms);
  }
  view->refGestures().pointerUp(pointerType, pointerId, button, position, timestamp_ms);
 
  view->getContext()->engine->setDirty();
}
 
void Cogs::Core::InputManager::triggerPointerMove(PointerType pointerType, PointerId pointerId, const glm::ivec2& position, double timestamp_ms) {
  timestamp_ms = checkTimeStamp(timestamp_ms);
  if (pointerType == PointerType::Mouse) {
    view->refMouse().submitMove(position, timestamp_ms);
  }
  view->refGestures().pointerMove(pointerType, pointerId, position, timestamp_ms);
 
  view->getContext()->engine->setDirty();
}
 
void Cogs::Core::InputManager::triggerMouseWheel(int32_t deltaValue, double timestamp_ms) {
  timestamp_ms = checkTimeStamp(timestamp_ms);
  view->refMouse().submitWheel(deltaValue, timestamp_ms);
  view->refGestures().mouseWheelMove(deltaValue);
 
  view->getContext()->engine->setDirty();
}
 
void Cogs::Core::InputManager::triggerKeyDown(Key key, double timestamp_ms) {
  timestamp_ms = checkTimeStamp(timestamp_ms);
  view->refKeyboard().submitKeyDown(key, timestamp_ms);
 
  view->getContext()->engine->setDirty();
}
 
void Cogs::Core::InputManager::triggerKeyUp(Key key, double timestamp_ms) {
  timestamp_ms = checkTimeStamp(timestamp_ms);
  view->refKeyboard().submitKeyUp(key, timestamp_ms);
 
  view->getContext()->engine->setDirty();
}
 
void Cogs::Core::InputManager::triggerKeyChar(std::string ch, double timestamp_ms) {
  timestamp_ms = checkTimeStamp(timestamp_ms);
  view->refKeyboard().submitChar(std::move(ch), timestamp_ms);
 
  view->getContext()->engine->setDirty();
}
 
Cogs::Core::InputDeviceState & Cogs::Core::InputManager::getDevice(InputDevices::EValues deviceId)
{
  return deviceStates[deviceId];
}
 
float Cogs::Core::InputManager::getAxisValue(const StringView & name) const
{
  auto mapping = axisMappings.find(name.hash());
 
  if (mapping == axisMappings.end()) {
    LOG_WARNING(logger, "No such axis: %.*s", StringViewFormat(name));
    return 0.f;
  }
 
  return mapping->second.value;
}
 
bool Cogs::Core::InputManager::getActionState(const StringView & name) const
{
  auto mapping = actionMappings.find(name.hash());
 
  if (mapping == actionMappings.end()) {
    LOG_WARNING(logger, "No such action: %.*s", StringViewFormat(name));
    return false;
  }
 
  return mapping->second.value;
}
 
void Cogs::Core::InputManager::update()
{
  view->refKeyboard().update();
  view->refMouse().update();
  view->refGestures().update();
 
  updateConnections();
  updateInputs();
 
  for (auto & d : deviceStates) {
    if (d.isConnected && !d.actionMap.empty() && d.actionNames.empty()) {
      d.actionNames.resize(d.highestBit(d.buttonMask) + 1);
 
      for (const auto & a : d.actionMap) {
        if (a.second < d.actionNames.size()) {
          d.actionNames[a.second] = a.first;
        }
      }
    }
 
    if (d.isConnected && !d.axisMap.empty() && d.axisNames.empty()) {
      d.axisNames.resize(d.highestBit(d.axisMask) + 1);
 
      for (auto & a : d.axisMap) {
        if (a.second < d.axisNames.size()) {
          d.axisNames[a.second] = a.first;
        }
      }
    }
  }
 
  updateAxes();
  updateActions();
}
 
void Cogs::Core::InputManager::updateConnections()
{
  std::vector<InputDeviceIdentifier> found;
 
  for (auto & deviceId : pendingDevices) {
    for (auto & provider : inputProviders) {
      if (provider->canCreate(deviceId)) {
        auto device = provider->create(deviceId);
 
        if (device) {
          found.push_back(deviceId);
 
          auto & state = *getDevice(deviceId.driver + ":" + deviceId.id);
 
          if (!state.isConnected) {
            state.isConnected = true;
            state.device = device;
          } else {
            // Log error, already connected.
          }
        }
      }
    }
  }
 
  for (auto & toRemove : found) {
    pendingDevices.erase(std::remove(pendingDevices.begin(), pendingDevices.end(), toRemove), pendingDevices.end());
  }
}
 
void Cogs::Core::InputManager::updateInputs()
{
  // Reset deltas before update.
  for (auto & d : deviceStates) {
    d.axisDeltas.fill(0.0f);
    d.buttonDeltas.fill(false);
  }
 
  InputDeviceState&       keyboardDeviceState = getDevice(Core::InputDevices::Keyboard);
  for (int i = 0; i < static_cast<int>(Key::Count); ++i) {
    if (view->refKeyboard().isKeyDown(static_cast<Key>(i))) {
      keyboardDeviceState.setButton(i, true);
      keyboardDeviceState.setAxis(i, 1.0f);
    }
    else {
      keyboardDeviceState.setButton(i, false);
      keyboardDeviceState.setAxis(i, 0.0f);
    }
  }
 
  InputDeviceState&     mouseDeviceState = getDevice(Core::InputDevices::Mouse);
  const Mouse::State&   mouseState = view->refMouse().getState();
 
  for (size_t i = 0; i < MouseButton::Count; ++i) {
    mouseDeviceState.setButton(i, mouseState.buttonDown[i]);
  }
 
  mouseDeviceState.setAxis(0, static_cast<float>(mouseState.position.x));
  mouseDeviceState.setAxis(1, static_cast<float>(mouseState.position.y));
  mouseDeviceState.setAxis(2, static_cast<float>(mouseState.wheel));
 
  view->gamepadHandler->update();
 
  // Connected devices
  for (auto & d : deviceStates) {
    if (d.device) {
      d.device->getState(d);
    }
  }
 
  // Extensions
  for (const auto & p : inputProviders) {
    p->update(*this);
  }
}
 
void Cogs::Core::InputManager::updateAxes()
{
  for (auto & p : axisMappings) {
    auto & axisMapping = p.second;
 
    for (auto & input : axisMapping.inputs) {
      auto & d = deviceStates[input.deviceId];
 
      if (input.axisId == NoAxis) {
        input.axisId = getAxisIndex(&d, input.axisName);
        if (input.axisId == NoAxis) continue;
      }
      if (input.axisId == ErrorAxis) continue;
 
      const size_t axis = input.axisId;
      const float rawValue = d.axes[axis];
 
      if (d.axisDeltas[axis] || (rawValue != 0 && axisMapping.value == 0)) {
        const float deadZone = d.deadZones[axis];
        const size_t deadZoneLink = d.linkedDeadZones[axis];
        const float sensitivity = d.sensitivity[axis];
 
        float magnitude = glm::abs(rawValue);
 
        if (deadZoneLink != kNoDeadZoneLink) {
          const glm::vec2 pos(rawValue, d.axes[deadZoneLink]);
          magnitude = glm::length(pos);
        }
 
        if (magnitude > deadZone) {
          const float axisValue = rawValue * sensitivity * input.scale;
 
          if (input.flags) {
            axisMapping.value = axisValue;
          } else {
            axisMapping.value = axisValue * (magnitude - deadZone) / (1 - deadZone);
          }
        } else {
          axisMapping.value = 0.0f;
        }
      }
    }
  }
}
 
void Cogs::Core::InputManager::updateActions()
{
  for (auto & p : actionMappings) {
    auto & actionMapping = p.second;
 
    actionMapping.value = false;
 
    for (auto & input : actionMapping.inputs) {
      auto & d = deviceStates[input.deviceId];
 
      if (input.buttonId == NoButton) {
        input.buttonId = getButtonIndex(&d, input.actionName);
        if (input.buttonId == NoButton) continue;
      }
      if (input.buttonId == ErrorButton) continue;
 
      bool actionState = d.buttons[input.buttonId];
 
      //TODO: Check modifier state etc.
 
      actionMapping.value |= actionState;
    }
  }
}
 
double Cogs::Core::InputManager::checkTimeStamp(double timestamp_ms)
{
  double result = std::max(timestamp_ms, prevTimeStamp);
  if (result == prevTimeStamp) {
    result = std::nextafter(result, std::numeric_limits<double>::max());
  }
  prevTimeStamp = result;
  return result;
}