Gestures.h

#pragma once
#include "Mouse.h"
 
#include <optional>
#include <unordered_map>
 
namespace Cogs
{
  using PointerId = size_t;
 
  enum class PointerType
  {
    Mouse,
    Touch,
 
    Count,
    Unknown,
  };
 
  struct Gesture
  {
    struct Hover
    {
      glm::vec2 coord = {};                     
    };
    struct Wheel
    {
      glm::vec2 coord = {};                     
      int32_t delta;                            
    };
    struct Tap
    {
      MouseButton button;                       
      glm::vec2 coord = {};                     
    };
    struct DoubleTap
    {
      MouseButton button;                       
      glm::vec2 coord = {};                     
    };
    struct Press
    {
      MouseButton button;                       
      glm::vec2 coord = {};                     
    };
    struct Drag
    {
      MouseButton button;                       
      glm::vec2 startCoord = {};                
      glm::vec2 currCoord = {};                 
    };
    struct Swipe
    {
      enum Direction {
        Left,
        Right,
        Up,
        Down
      };
 
      MouseButton button;                       
      Direction direction;                      
      glm::vec2 startCoord = {};                
      float velocity;                           
    };
    struct Pan
    {
      glm::vec2 midStartCoord = {};             
      glm::vec2 midCurrCoord = {};              
    };
    struct Rotate
    {
      glm::vec2 center = {};                    
      float angle;                              
    };
    struct Pinch
    {
      glm::vec2 center = {};                    
      float scale;                              
    };
 
    enum struct Kind : uint32_t
    {
      Hover,                                    
      Wheel,                                    
      Tap,                                      
      DoubleTap,                                
      Press,                                    
      Drag,                                     
      Swipe,                                    
      Pan,                                      
      Rotate,                                   
      Pinch,                                    
    };
 
    enum struct State : uint8_t
    {
      Started,                                  
      Changed,                                  
      Ended,                                    
      Cancelled                                 
    };
 
    Kind kind;                                  
    uint32_t id;                                
    State state;                                
    union {                                     
      Hover hover;
      Wheel wheel;
      Tap tap;
      DoubleTap doubleTap;
      Press press;
      Drag drag;
      Swipe swipe;
      Pan pan;
      Rotate rotate;
      Pinch pinch;
    };
 
    Gesture() { memset((void*)this, 0, sizeof(*this)); }
    Gesture(const Gesture& src) { memcpy((void*)this, &src, sizeof(*this)); }
    void operator =(const Gesture& src) { memcpy((void*)this, &src, sizeof(*this)); }
  };
 
  class COGSFOUNDATION_API Gestures
  {
  public:
    // Enable/disable gestures
    bool hoverEnable = true;                    
    bool wheelEnable = true;                    
    bool tapEnable = true;                      
    bool doubleTapEnable = true;                
    bool pressEnable = true;                    
    bool dragEnable = true;                     
    bool swipeEnable = true;                    
    bool panEnable = true;                      
    bool rotateEnable = true;                   
    bool pinchEnable = true;                    
 
    // Configuration
    uint32_t tapMaxDuration = 250;              
    uint32_t doubleTapTreshold = 300;           
    uint32_t swipeMaxDuration = 200;            
    float mouseMoveThreshold = 1.f;             
    float touchMoveThreshold = 16.f;            
    float touchVelocityThreshold = 500.f;       
    float mouseVelocityThreshold = 100.f;       
    float rotateThreshold = 0.05f;              
    float pinchThreshold = 0.1f;                
 
    Gestures();
    void update();
    void setDisplayScale(float scale) { displayScale = scale; }
 
    void pointerDown(PointerType pointerType, PointerId pointerId, MouseButton button, glm::vec2 position, double timestamp_ms);
    void pointerUp(PointerType pointerType, PointerId pointerId, MouseButton button, glm::vec2 position, double timestamp_ms);
    void pointerMove(PointerType pointerType, PointerId pointerId, glm::vec2 position, double timestamp_ms);
    void mouseWheelMove(int32_t delta);
    void reset();
    
    PointerType getPointerType();
 
    const std::vector<Gesture>& getGestures() const { return presentedGestures; }
 
  private:
    float displayScale = 1.0f;
 
    PointerType currPointerType = PointerType::Unknown;
 
    std::vector<Gesture> presentedGestures; // Will be available next frame and last one frame
    std::vector<Gesture> currentGestures; // Update durring the current frame. At the end of the frame it is moved to presentedGestures, then cleaned.
 
    // Timestamp of last tap, used for double tap detection.
    double lastTapTimestamp = 0;
    // State for updatable gestures.
    std::optional<Gesture> currPress = std::nullopt;
    std::optional<Gesture> currDrag = std::nullopt;
    std::optional<Gesture> currPan = std::nullopt;
    std::optional<Gesture> currRotate = std::nullopt;
    std::optional<Gesture> currPinch = std::nullopt;
 
    struct PointerState
    {
      enum State: uint32_t
      {
        None,
        Pressed,
        Moving,
        Released
      };
 
      struct Data
      {
        double timestamp_ms = 0.0;        
        glm::vec2 position;               
      };
 
      PointerType type = PointerType::Unknown;    
      MouseButton button = MouseButton::NoButton; 
      State state = State::None;                  
      Data init;                                  
      Data prev;                                  
      Data curr;                                  
    };
 
    std::unordered_map<PointerId, PointerState> currentPointers;  
 
    uint32_t idCounter = 0;
    [[nodiscard]] uint32_t nextGestureId() { return idCounter++; }
 
 
    void endUpdatingGesture(std::optional<Gesture>& gesture, Gesture::State state);
  };
}