TouchState.hh

 
#ifndef GRAMODS_TOUCH_TOUCHSTATE
#define GRAMODS_TOUCH_TOUCHSTATE
 
#include <gmTouch/config.hh>
 
#include <gmMisc/EFFOAW.hh>
 
#include <Eigen/Eigen>
 
#include <vector>
#include <chrono>
#include <map>
#include <typeindex>
#include <typeinfo>
#include <unordered_map>
#include <unordered_set>
 
#include <assert.h>
 
BEGIN_NAMESPACE_GMTOUCH;
 
class TouchState {
 
public:
 
  TouchState();
 
  ~TouchState();
 
  typedef std::chrono::steady_clock clock;
 
  typedef int64_t TouchPointId;
 
  static const TouchPointId MOUSE_STATE_ID;
 
  struct State {
    static const unsigned char NONE = 0;
 
    static const unsigned char DRAG = 0x01 << 0;
 
    static const unsigned char HOLD = 0x01 << 1;
 
    static const unsigned char MULTI = 0x01 << 2;
 
    static const unsigned char TOUCH_DOWN = 0x01 << 3;
 
    static const unsigned char RELEASE = 0x01 << 4;
 
    static const unsigned char CLICK = 0x01 << 5;
  };
 
  struct TouchPoint {
 
    TouchPoint(TouchPointId id, float x, float y);
 
    TouchPoint();
 
    float x;
 
    float y;
 
    float vx;
 
    float vy;
 
    float ex;
 
    float ey;
 
    float sx;
 
    float sy;
 
    TouchPointId id;
 
    unsigned char state;
 
    unsigned int clicks;
  };
 
  typedef std::vector<TouchPoint> TouchPoints;
 
  struct TouchLine {
 
    Eigen::Vector3f x;
 
    Eigen::Vector3f v;
 
    TouchPointId id;
 
    unsigned char state;
 
    unsigned int clicks;
  };
 
  typedef std::vector<TouchLine> TouchLines;
 
 
  bool empty() const { return current_state.empty(); }
 
  int getTouchPoints(TouchPoints &current) const;
 
  int getTouchPoints(TouchPoints &current, TouchPoints &previous) const;
 
  int getTouchPoints(void *ass, TouchPoints &current) const;
 
  int getTouchPoints(void *ass, TouchPoints &current, TouchPoints &previous) const;
 
  int getTouchPoints(std::map<void*, TouchPoints> &current) const;
 
  int getTouchPoints(std::map<void*, TouchPoints> &current,
                     std::map<void*, TouchPoints> &previous) const;
 
  bool setAssociation(TouchPointId id, void* pt);
 
  bool unsetAssociation(TouchPointId id, void* pt);
 
  bool getAssociation(TouchPointId id, void** pt) const;
 
 
 
  void setCurrentProjection(Eigen::Matrix4f WPV_inv);
 
  struct CameraAdaptor {
 
    virtual ~CameraAdaptor() {}
 
    virtual void init(int width, int height);
 
    virtual void done();
 
  protected:
 
    void setCurrentProjection(Eigen::Matrix4f WPV_inv);
 
  private:
 
    TouchState *owner;
    friend TouchState;
  };
  friend CameraAdaptor;
 
  template<class T>
  T & getCameraAdaptor();
 
  bool getTouchLines(TouchLines &current) const;
 
  bool getTouchLines(TouchLines &current, TouchLines &previous) const;
 
  bool getTouchLines(void *ass, TouchLines &current) const;
 
  bool getTouchLines(void *ass, TouchLines &current, TouchLines &previous) const;
 
  bool getTouchLines(std::map<void*, TouchLines> &current) const;
 
  bool getTouchLines(std::map<void*, TouchLines> &current,
                     std::map<void*, TouchLines> &previous) const;
 
 
 
  float getMouseWheel() const;
 
  bool getMouseDown() const;
 
  void getMousePoint(int &x, int &y) const;
 
  bool getMouseLine(Eigen::Vector3f &x,
                    Eigen::Vector3f &v) const;
 
 
 
  void setSmoothing(float r);
 
  float getSmoothing();
 
  void setRemoveMouseUponTouch(bool on);
 
  bool getRemoveMouseUponTouch();
 
  void setMoveMagnitude(float dist);
 
  float getMoveMagnitude();
 
  void setHoldTime(clock::duration time);
 
  clock::duration getHoldTime();
 
  void setClickTime(clock::duration time);
 
  clock::duration getClickTime();
 
  void setMultiClickTime(clock::duration time);
 
  clock::duration getMultiClickTime();
 
 
 
  struct EventAdaptor {
 
    virtual ~EventAdaptor() {}
 
    virtual void init(int, int);
 
    virtual void done();
 
  protected:
 
    void addTouchState(TouchPointId id, float x, float y);
 
    void removeTouchState(TouchPointId id, float x, float y);
 
    void addMouseState(float x, float y, bool mouse_down);
 
    void addMouseWheel(float s);
 
  private:
 
    TouchState *owner;
    friend TouchState;
  };
  friend EventAdaptor;
 
  template<class T>
  T & getEventAdaptor();
 
  void eventsInit(int width, int height);
 
  void eventsDone();
 
 
private:
 
  struct HistoryState {
    TouchPoint point;
    clock::time_point time;
  };
 
  gmMisc::EFFOAW velocityEstimator;
 
  void addTouchState(TouchPointId id, float x, float y);
 
  void removeTouchState(TouchPointId id, float x, float y);
 
  void addMouseState(float x, float y, bool mouse_down);
 
  void addMouseWheel(float s);
 
  void addState(TouchPointId id, float x, float y);
 
  clock::time_point start_time = clock::time_point::min();
  float noise_level;
  float velocity_reestimation_rate;
 
  float smoothing;
  float move_magnitude;
  clock::duration hold_time;
  clock::duration click_time;
  clock::duration multi_time;
 
  bool remove_mouse_upon_touch = true;
  bool use_mouse = true;
 
  std::map<TouchPointId, TouchPoint> current_state;
  std::map<TouchPointId, TouchPoint> previous_state;
 
  std::map<TouchPointId, void*> last_association;
  std::map<TouchPointId, void*> current_association;
 
  std::map<TouchPointId, HistoryState> history;
 
  void check_multi(TouchPoint &new_pt);
 
  void check_drag(HistoryState hist, TouchPoint &new_pt);
 
  void check_hold(HistoryState hist, TouchPoint &new_pt);
 
  void check_click(HistoryState hist, TouchPoint &new_pt);
 
  void clearReleasedStates();
 
  int state = 0;
 
  TouchLine touchPointToTouchLine(TouchPoint pt, Eigen::Matrix4f WPV_inv) const;
 
  Eigen::Matrix4f current_WPV_inv;
  bool current_WPV_inv_valid = false;
 
  Eigen::Matrix4f previous_WPV_inv;
  bool previous_WPV_inv_valid = false;
 
  int current_height = -1;
  int previous_height = -1;
  int current_width = -1;
  int previous_width = -1;
 
  float mouse_wheel = 0.f;
  bool mouse_down = false;
  int mouse_point_x = 0;
  int mouse_point_y = 0;
 
  std::unordered_map<std::type_index, EventAdaptor*> event_adaptors;
  std::unordered_map<std::type_index, CameraAdaptor*> camera_adaptors;
};
 
 
template<class T>
T & TouchState::getEventAdaptor() {
  if (event_adaptors.find(typeid(T)) == event_adaptors.end()) {
    event_adaptors[typeid(T)] = new T;
    event_adaptors[typeid(T)]->owner = this;
  }
  assert(dynamic_cast<T*>(event_adaptors[typeid(T)]));
  return *dynamic_cast<T*>(event_adaptors[typeid(T)]);
}
 
template<class T>
T & TouchState::getCameraAdaptor() {
  if (camera_adaptors.find(typeid(T)) == camera_adaptors.end()) {
    camera_adaptors[typeid(T)] = new T;
    camera_adaptors[typeid(T)]->owner = this;
  }
  assert(dynamic_cast<T*>(camera_adaptors[typeid(T)]));
  return *dynamic_cast<T*>(camera_adaptors[typeid(T)]);
}
 
END_NAMESPACE_GMTOUCH;
 
#endif