Gestures.cpp

#include "Gestures.h"
 
#include "Timer.h"
#include "../Logging/Logger.h"
 
#include <glm/glm.hpp>
 
namespace
{
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("Gestures");
}
 
Cogs::Gestures::Gestures()
{
  // The current gestures require max 2 pointers, but let's be generous and preallocate space for 5.
  currentPointers.reserve(5);
}
 
void Cogs::Gestures::update()
{
  for (const auto& [id, pointer] : currentPointers) {
    // If a pressed pointer hasn't been updated in 10 seconds, assume something went wrong and discard it.
    if (pointer.curr.timestamp_ms - pointer.prev.timestamp_ms > 10000.0) {
      if (pointer.state == PointerState::Pressed || (pointer.state == PointerState::Moving && pointer.curr.position == pointer.prev.position)) {
        LOG_WARNING(logger, "Discarding out-dated pointer id=%zu", id);
        pointerUp(pointer.type, id, pointer.button, pointer.curr.position, static_cast<double>(Timer::currentTimeMilliseconds()));
      }
    }
  }
 
  presentedGestures = std::move(currentGestures);
  currentGestures = {};
}
 
void Cogs::Gestures::pointerDown(PointerType pointerType, PointerId pointerId, MouseButton button, glm::vec2 position, double timestamp_ms)
{
  currPointerType = pointerType;
  // Record the pressed pointer.
  PointerState& pointer = currentPointers[pointerId];
  pointer.type = pointerType;
  pointer.button = button;
  pointer.init.timestamp_ms = timestamp_ms;
  pointer.init.position = position;
  pointer.prev = pointer.init;
  pointer.curr = pointer.init;
  pointer.state = PointerState::Pressed;
 
  // New pointer, cancel all updating gestures.
  endUpdatingGesture(currPress, Gesture::State::Cancelled);
  endUpdatingGesture(currDrag, Gesture::State::Cancelled);
  endUpdatingGesture(currPan, Gesture::State::Cancelled);
  endUpdatingGesture(currRotate, Gesture::State::Cancelled);
  endUpdatingGesture(currPinch, Gesture::State::Cancelled);
 
  size_t pointersCount = currentPointers.size();
  if (pointersCount == 1) {
    if (pressEnable) {
      // Pressed one button, set the Press start event.
      currPress.emplace();
      currPress->id = nextGestureId();
      currPress->kind = Gesture::Kind::Press;
      currPress->state = Gesture::State::Started;
      currPress->press = { button, {pointer.curr.position.x, pointer.curr.position.y} };
      currentGestures.push_back(*currPress);
    }
    if (dragEnable) {
      // Create the Drag event, but don't set it yet. Do that when the pointer moves.
      currDrag.emplace();
      currDrag->id = nextGestureId();
      currDrag->kind = Gesture::Kind::Drag;
      currDrag->state = Gesture::State::Started;
      currDrag->drag = { button, {pointer.init.position.x, pointer.init.position.y}, {pointer.curr.position.x, pointer.curr.position.y} };
    }
  }
  else if (pointersCount == 2) {
    const PointerState& leftPointer = currentPointers.begin()->second;
    const PointerState& rightPointer = std::next(currentPointers.begin())->second;
    glm::vec2 midCurr(0.5f * (leftPointer.curr.position.x + rightPointer.curr.position.x),
                      0.5f * (leftPointer.curr.position.y + rightPointer.curr.position.y));
 
    if (panEnable) {
      // Create the Pan event, but don't set it yet. Do that when the pointer moves.
      currPan.emplace();
      currPan->id = nextGestureId();
      currPan->kind = Gesture::Kind::Pan;
      currPan->state = Gesture::State::Started;
      currPan->pan.midStartCoord = midCurr;
      currPan->pan.midCurrCoord = midCurr;
    }
 
    if (rotateEnable) {
      // Create the Rotate event, but don't set it yet. Do that when the pointer moves.
      currRotate.emplace();
      currRotate->id = nextGestureId();
      currRotate->kind = Gesture::Kind::Rotate;
      currRotate->state = Gesture::State::Started;
      currRotate->rotate.center = midCurr;
      currRotate->rotate.angle = 0;
    }
 
    if (pinchEnable) {
      // Create the Pinch event, but don't set it yet. Do that when the pointer moves.
      currPinch.emplace();
      currPinch->id = nextGestureId();
      currPinch->kind = Gesture::Kind::Pinch;
      currPinch->state = Gesture::State::Started;
      currPinch->pinch.center = midCurr;
      currPinch->pinch.scale = 1;
    }
  }
}
 
void Cogs::Gestures::pointerUp(PointerType pointerType, PointerId pointerId, MouseButton button, glm::vec2 position, double timestamp_ms)
{
  currPointerType = pointerType;
  auto pointerIt = currentPointers.find(pointerId);
  if (pointerIt == currentPointers.end()) {
    LOG_WARNING(logger, "Discarding pointer release event from unknown pointer.");
    return;
  }
 
  // Record the released pointer state.
  PointerState& pointer = pointerIt->second;
  pointer.curr.timestamp_ms = timestamp_ms;
  pointer.curr.position.x = position.x;
  pointer.curr.position.y = position.y;
  pointer.state = PointerState::Released;
 
  // End or cancel gestures
  if (currDrag) {
    // Ideally we calculate dx, dy, dt between curr and prev, but the last touch event is usually duplicated.
    float dx = static_cast<float>(pointer.curr.position.x - pointer.init.position.x);
    float dy = static_cast<float>(pointer.curr.position.y - pointer.init.position.y);
    float dt = static_cast<float>(pointer.curr.timestamp_ms - pointer.init.timestamp_ms);
    float distance = std::sqrt(dx * dx + dy * dy);
    float velocity = 1000.f * distance / dt;
    float velocityTreshold = displayScale * (pointerType == PointerType::Mouse ? mouseVelocityThreshold : touchVelocityThreshold);
 
    // Check if the drag is actually a swipe. In that case, cancel the drag and submit the swipe.
    if (swipeEnable && (velocityTreshold < velocity) && (timestamp_ms - pointer.init.timestamp_ms < swipeMaxDuration)) {
 
      endUpdatingGesture(currDrag, Gesture::State::Cancelled);
 
      Gesture swipe;
      swipe.id = nextGestureId();
      swipe.kind = Gesture::Kind::Swipe;
      swipe.state = Gesture::State::Ended;
      swipe.swipe.button = button;
      if (std::fabs(dx) > std::fabs(dy)) {
        swipe.swipe.direction = dx < 0 ? Gesture::Swipe::Left : Gesture::Swipe::Right;
      }
      else {
        swipe.swipe.direction = dy < 0 ? Gesture::Swipe::Up : Gesture::Swipe::Down;
      }
      swipe.swipe.startCoord = { pointer.init.position.x, pointer.init.position.y };
      swipe.swipe.velocity = velocity;
 
      currentGestures.push_back(std::move(swipe));
    }
    else if (currDrag->state == Gesture::State::Changed) {
      // Otherwise, if we had an ongoing drag, submit it.
      currDrag->state = Gesture::State::Ended;
      currDrag->drag.currCoord = {pointer.curr.position.x, pointer.curr.position.y};
      currentGestures.push_back(*currDrag);
      currDrag = std::nullopt;
    }
    else {
      // The pointer was pressed, but never moved. Discard the current drag gesture.
      currDrag = std::nullopt;
    }
  }
 
  // If the press was quick, count it as a tap and cancel the press gesture, otherwise end the press gesture normally.
  if (currPress) {
    if (timestamp_ms - pointer.init.timestamp_ms < tapMaxDuration) {
      endUpdatingGesture(currPress, Gesture::State::Cancelled);
 
      // If there was a tap less than doubleTapTreshold ago, submit this gesture as a double tap, otherwise submit a single tap.
      // TODO: Don't submit taps when the finger  was moved from the press prosition.
      if (doubleTapEnable && timestamp_ms - lastTapTimestamp < doubleTapTreshold) {
        Gesture dtap{};
        dtap.id = nextGestureId();
        dtap.kind = Gesture::Kind::DoubleTap;
        dtap.state = Gesture::State::Ended;
        dtap.doubleTap = { button, { pointer.curr.position.x, pointer.curr.position.y } };
        currentGestures.push_back(std::move(dtap));
      }
      else {
        lastTapTimestamp = timestamp_ms;
 
        Gesture tap{};
        tap.id = nextGestureId();
        tap.kind = Gesture::Kind::Tap;
        tap.state = Gesture::State::Ended;
        tap.doubleTap = { button, { pointer.curr.position.x, pointer.curr.position.y } };
        currentGestures.push_back(std::move(tap));
      }
    }
    else {
      currPress->press.coord = {pointer.curr.position.x, pointer.curr.position.y};
      endUpdatingGesture(currPress, Gesture::State::Ended);
    }
  }
 
  // End two finger gestures
  endUpdatingGesture(currPan, Gesture::State::Ended);
  endUpdatingGesture(currRotate, Gesture::State::Ended);
  endUpdatingGesture(currPinch, Gesture::State::Ended);
 
  // Pointer handled, now it can be removed
  currentPointers.erase(pointerId);
}
 
void Cogs::Gestures::pointerMove(PointerType pointerType, PointerId pointerId, glm::vec2 position, double timestamp_ms)
{
  currPointerType = pointerType;
  auto pointerIt = currentPointers.find(pointerId);
  if (pointerIt == currentPointers.end()) {
    // Don't add the hovering pointer to currentPointers. Mouse specific.
    if (hoverEnable) {
      Gesture g{};
      g.id = nextGestureId();
      g.kind = Gesture::Kind::Hover;
      g.state = Gesture::State::Ended;
      g.hover = { { position.x, position.y } };
      currentGestures.push_back(std::move(g));
    }
  }
  else {
    // Record the moved pointer state.
    PointerState& pointer = pointerIt->second;
    pointer.prev = pointer.curr;
    pointer.curr.timestamp_ms = timestamp_ms;
    pointer.curr.position = position;
    pointer.state = PointerState::Moving;
 
    // Send start events for gestures that crossed the treshold and send changed events for updating gestures.
    bool isMouse = pointerType == PointerType::Mouse;
    if (currentPointers.size() == 1) {
      if (currDrag) {
        float dx = static_cast<float>(pointer.curr.position.x - pointer.init.position.x);
        float dy = static_cast<float>(pointer.curr.position.y - pointer.init.position.y);
        float distanceSq = dx * dx + dy * dy;
        float distanceTreshold = displayScale * (isMouse ? mouseMoveThreshold : touchMoveThreshold);
 
        if (currDrag->state == Gesture::State::Started && distanceTreshold * distanceTreshold < distanceSq) {
          // The pointer moved pass the distance treshold, cancel the press gesture and start the Drag one.
          endUpdatingGesture(currPress, Gesture::State::Cancelled);
 
          currentGestures.push_back(*currDrag);
          currDrag->state = Gesture::State::Changed;
        }
        if (currDrag->state == Gesture::State::Changed &&
          (currDrag->drag.currCoord.x != pointer.curr.position.x || currDrag->drag.currCoord.y != pointer.curr.position.y)) {
          // Pointer moved, update the Drag gesture.
          currDrag->drag.currCoord = { pointer.curr.position.x, pointer.curr.position.y };
          currentGestures.push_back(*currDrag);
        }
      }
    }
    else if (currentPointers.size() == 2) {
      const PointerState& leftPointer = currentPointers.begin()->second;
      const PointerState& rightPointer = std::next(currentPointers.begin())->second;
      float midCurrX = 0.5f * (leftPointer.curr.position.x + rightPointer.curr.position.x);
      float midCurrY = 0.5f * (leftPointer.curr.position.y + rightPointer.curr.position.y);
      glm::vec2 midCurr(midCurrX, midCurrY);
 
      if (currPan) {
        float midInitX = 0.5f * (leftPointer.init.position.x + rightPointer.init.position.x);
        float midInitY = 0.5f * (leftPointer.init.position.y + rightPointer.init.position.y);
        float dx = midCurr.x - midInitX;
        float dy = midCurr.y - midInitY;
        float distanceSq = dx * dx + dy * dy;
        float distanceTreshold = displayScale * (isMouse ? mouseMoveThreshold : touchMoveThreshold);
 
        if (currPan->state == Gesture::State::Started && distanceTreshold * distanceTreshold < distanceSq) {
          // The pointers moved pass the distance treshold, start the Pan gesture.
          currentGestures.push_back(*currPan);
          currPan->state = Gesture::State::Changed;
        }
        if (currPan->state == Gesture::State::Changed &&
          (currPan->pan.midCurrCoord.x != midCurr.x || currPan->pan.midCurrCoord.y != midCurr.y)) {
          // Pointer moved, update the Pan gesture.
          currPan->pan.midCurrCoord = { midCurr.x, midCurr.y };
          currentGestures.push_back(*currPan);
        }
      }
 
      if (currRotate) {
        glm::vec2 vi = glm::vec2(rightPointer.init.position - leftPointer.init.position);
        glm::vec2 vc = glm::vec2(rightPointer.curr.position - leftPointer.curr.position);
        float s = 1.f / (glm::length(vi) * glm::length(vc));
        if (std::isfinite(s)) {
          float angle_cos = s * glm::dot(vc, vi);
          float angle_sin = s * glm::cross(glm::vec3(vc, 0.f), glm::vec3(vi, 0.f)).z;
          float angle = std::atan2(angle_sin, angle_cos);
          if (currRotate->state == Gesture::State::Started && std::abs(angle) > rotateThreshold) {
            // The angle changed more than the rotation treshold, start the Rotation gesture.
            currentGestures.push_back(*currRotate);
            currRotate->state = Gesture::State::Changed;
          }
          if (currRotate->state == Gesture::State::Changed && currRotate->rotate.angle != angle) {
            // Angle changed, update the Rotation gesture.
            currRotate->rotate.center = { midCurr.x, midCurr.y };
            currRotate->rotate.angle = angle;
            currentGestures.push_back(*currRotate);
          }
        }
      }
 
      if (currPinch) {
        glm::vec2 pi0(leftPointer.init.position);
        glm::vec2 pi1(rightPointer.init.position);
        glm::vec2 pc0(leftPointer.curr.position);
        glm::vec2 pc1(rightPointer.curr.position);
        float scale = glm::distance(pc1, pc0) / glm::distance(pi1, pi0);
        if (std::isfinite(scale)) {
          if (currPinch->state == Gesture::State::Started && std::abs(1.f - scale) > pinchThreshold) {
            // The scale changed more than the treshold, start the Pinch gesture.
            currentGestures.push_back(*currPinch);
            currPinch->state = Gesture::State::Changed;
          }
          if (currPinch->state == Gesture::State::Changed && currPinch->pinch.scale != scale) {
            // Scale changed, update the Pinch gesture.
            currPinch->pinch.center = { midCurr.x, midCurr.y };
            currPinch->pinch.scale = scale;
            currentGestures.push_back(*currPinch);
          }
        }
      }
    }
  }
}
 
void Cogs::Gestures::mouseWheelMove(int32_t delta) {
  Gesture g{};
  g.kind = Gesture::Kind::Wheel;
  g.id = nextGestureId();
  g.state = Gesture::State::Ended;
  g.wheel.delta = delta;
  currentGestures.push_back(std::move(g));
}
 
void Cogs::Gestures::reset() {
  currentGestures = {};
}
 
void Cogs::Gestures::endUpdatingGesture(std::optional<Gesture>& gesture, Gesture::State state)
{
  if (gesture) {
    // Submit end events only if the gesture started. For updating gestures, that means at least one Changed event.
    if(gesture->kind == Gesture::Kind::Press || gesture->state == Gesture::State::Changed) {
      gesture->state = state;
      currentGestures.push_back(*gesture);
    }
    gesture = std::nullopt;
  }
}
 
Cogs::PointerType Cogs::Gestures::getPointerType()
{
  return currPointerType;
}