InputDeviceState.h

#pragma once
 
#include "Base.h"
 
#include <array>
#include <unordered_map>
#include <string>
#include <vector>
 
namespace Cogs
{
  namespace Core
  {
    constexpr size_t kMaxAxes = 128;
    constexpr size_t kMaxActions = 128;
 
    constexpr float kDefaultDeadZone = 0.1f;
    constexpr size_t kNoDeadZoneLink = static_cast<size_t>(-1);
    constexpr float kDefaultSensitivity = 1.0f;
 
    struct InputDeviceState
    {
      InputDeviceState() = default;
 
      InputDeviceState(const InputDeviceState &) = default;
 
      void setButton(size_t index, bool state)
      {
        if (state != buttons[index]) {
          buttonDeltas[index] = true;
          buttons[index] = state;
        }
      }
 
      bool pressed(size_t index) const
      {
        return buttons[index] && buttonDeltas[index];
      }
 
      bool released(size_t index) const
      {
        return !buttons[index] && buttonDeltas[index];
      }
 
      void setAxis(size_t index, float value)
      {
        if (value != axes[index]) {
          axisDeltas[index] = value - axes[index];
          axes[index] = value;
        }
      }
 
      size_t countBits(uint64_t flags)
      {
        size_t count = 0;
        for (uint64_t i = 0; i < 64; i++) {
          uint64_t bit = 1;
          uint64_t mask = bit << i;
          if ((flags & mask) > 0) count++;
        }
        return count;
      }
 
      int8_t highestBit(uint64_t flags)
      {
        for (int8_t i = 63; i >= 0; i--) {
          uint64_t bit = 1;
          uint64_t mask = bit << i;
          if ((flags & mask) > 0) return i;
        }
        return -1;
      }
 
      size_t deviceId = static_cast<size_t>(-1);
      std::string id;
      std::string alias;
 
      size_t axisMask = 0;
      size_t buttonMask = 0;
 
      std::array<float, kMaxAxes> axes = { 0.f };
      std::array<float, kMaxAxes> axisDeltas = { 0.f };
 
      // Used to derive final axis values.
      std::array<float, kMaxAxes> deadZones = { kDefaultDeadZone };
      std::array<size_t, kMaxAxes> linkedDeadZones = { kNoDeadZoneLink };
      std::array<float, kMaxAxes> sensitivity = { kDefaultSensitivity };
      std::array<bool, kMaxAxes> invert = { false };
 
      std::array<bool, kMaxActions> buttons = { false };
      std::array<bool, kMaxActions> buttonDeltas = { false };
 
      bool isConnected = false;
      bool isValid = false;
 
      std::unordered_map<std::string, size_t> axisMap;
      std::unordered_map<std::string, size_t> actionMap;
 
      std::vector<std::string> axisNames;
      std::vector<std::string> actionNames;
 
      class IInputDevice * device = nullptr;
    };
  }
}