qtk/src/input.cpp

/*##############################################################################
## Author: Shaun Reed                                                         ##
## Legal: All Content (c) 2022 Shaun Reed, all rights reserved                ##
## About: Input class from tutorials followed at trentreed.net                ##
##                                                                            ##
## Contact: shaunrd0@gmail.com	| URL: www.shaunreed.com | GitHub: shaunrd0   ##
##############################################################################*/

#include <algorithm>
#include <vector>

#include <QCursor>

#include <input.h>


/*******************************************************************************
 * Static Helper Structs
 ******************************************************************************/
template <typename T>
struct InputInstance : std::pair<T, Input::InputState>
{
  typedef std::pair<T, Input::InputState> base_class;

  inline InputInstance(T value)
      : base_class(value, Input::InputInvalid) {}

  inline InputInstance(T value, Input::InputState state)
      : base_class(value, state) {}

  inline bool operator==(const InputInstance & rhs) const
  { return this->first == rhs.first;}
};

// Key, button instance typedefs
typedef InputInstance<Qt::Key> KeyInstance;
typedef InputInstance<Qt::MouseButton> ButtonInstance;

// Key, button instance container typedefs
typedef std::vector<KeyInstance> KeyContainer;
typedef std::vector<ButtonInstance> ButtonContainer;

// Static containers for key, button instances
static KeyContainer sg_keyInstances;
static ButtonContainer sg_buttonInstances;
// Static containers for mouse data
static QPoint sg_mouseCurrPosition;
static QPoint sg_mousePrevPosition;
static QPoint sg_mouseDelta;


/*******************************************************************************
 * Static Inline Helper Functions
 ******************************************************************************/

static inline KeyContainer::iterator FindKey(Qt::Key value)
{
  return std::find(sg_keyInstances.begin(), sg_keyInstances.end(), value);
}

static inline ButtonContainer::iterator FindButton(Qt::MouseButton value)
{
  return std::find(sg_buttonInstances.begin(), sg_buttonInstances.end(), value);
}

template <typename TPair>
static inline void UpdateStates(TPair & instance)
{
  switch (instance.second)
  {
    case Input::InputRegistered:
      instance.second = Input::InputTriggered;
      break;
    case Input::InputTriggered:
      instance.second = Input::InputPressed;
      break;
    case Input::InputUnregistered:
      instance.second = Input::InputReleased;
      break;
    default:
      break;
  }
}

template <typename TPair>
static inline bool CheckReleased(const TPair & instance)
{
  return instance.second == Input::InputReleased;
}

template <typename Container>
static inline void Update(Container & container)
{
  typedef typename Container::iterator Iter;
  typedef typename Container::value_type TPair;

  // Remove old data
  Iter remove =
      std::remove_if(container.begin(), container.end(), &CheckReleased<TPair>);
  container.erase(remove, container.end());

  // Update existing data
  std::for_each(container.begin(), container.end(), &UpdateStates<TPair>);
}


/*******************************************************************************
 * Input Implementation
 ******************************************************************************/

Input::InputState Input::keyState(Qt::Key k)
{
  KeyContainer::iterator it = FindKey(k);
  return (it != sg_keyInstances.end()) ? it->second : InputInvalid;
}

Input::InputState Input::buttonState(Qt::MouseButton k)
{
  ButtonContainer::iterator it = FindButton(k);
  return (it != sg_buttonInstances.end()) ? it->second : InputInvalid;
}

QPoint Input::mousePosition()
{
  return QCursor::pos();
}

QPoint Input::mouseDelta()
{
  return sg_mouseDelta;
}

void Input::update()
{
  // Update Mouse Delta
  sg_mousePrevPosition = sg_mouseCurrPosition;
  sg_mouseCurrPosition = QCursor::pos();
  sg_mouseDelta = sg_mouseCurrPosition - sg_mousePrevPosition;

  // Update KeyState values
  Update(sg_buttonInstances);
  Update(sg_keyInstances);
}

void Input::registerKeyPress(int k)
{
  KeyContainer::iterator it = FindKey((Qt::Key)k);
  if (it == sg_keyInstances.end())
  {
    sg_keyInstances.push_back(KeyInstance((Qt::Key)k, InputRegistered));
  }
}

void Input::registerKeyRelease(int k)
{
  KeyContainer::iterator it = FindKey((Qt::Key)k);
  if (it != sg_keyInstances.end())
  {
    it->second = InputUnregistered;
  }
}

void Input::registerMousePress(Qt::MouseButton btn)
{
  ButtonContainer::iterator it = FindButton(btn);
  if (it == sg_buttonInstances.end())
  {
    sg_buttonInstances.push_back(ButtonInstance(btn, InputRegistered));
  }
}

void Input::registerMouseRelease(Qt::MouseButton btn)
{
  ButtonContainer::iterator it = FindButton(btn);
  if (it != sg_buttonInstances.end())
  {
    it->second = InputUnregistered;
  }
}

void Input::reset()
{
  sg_keyInstances.clear();
  sg_buttonInstances.clear();
}