gecko-dev/layout/generic/ScrollAnimationMSDPhysics.cpp

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "ScrollAnimationMSDPhysics.h"
#include "gfxPrefs.h"

using namespace mozilla;

ScrollAnimationMSDPhysics::ScrollAnimationMSDPhysics(const nsPoint& aStartPos)
 : mStartPos(aStartPos)
 , mModelX(0, 0, 0, gfxPrefs::SmoothScrollMSDPhysicsRegularSpringConstant(), 1)
 , mModelY(0, 0, 0, gfxPrefs::SmoothScrollMSDPhysicsRegularSpringConstant(), 1)
 , mIsFirstIteration(true)
{
}

void
ScrollAnimationMSDPhysics::Update(const TimeStamp& aTime,
                                  const nsPoint& aDestination,
                                  const nsSize& aCurrentVelocity)
{
  double springConstant = ComputeSpringConstant(aTime);

  // mLastSimulatedTime is the most recent time that this animation has been
  // "observed" at. We don't want to update back to a state in the past, so we
  // set mStartTime to the more recent of mLastSimulatedTime and aTime.
  // aTime can be in the past if we're processing an input event whose internal
  // timestamp is in the past.
  if (mLastSimulatedTime && aTime < mLastSimulatedTime) {
    mStartTime = mLastSimulatedTime;
  } else {
    mStartTime = aTime;
  }

  if (!mIsFirstIteration) {
    mStartPos = PositionAt(mStartTime);
  }

  mLastSimulatedTime = mStartTime;
  mDestination = aDestination;
  mModelX = AxisPhysicsMSDModel(mStartPos.x, aDestination.x,
                                aCurrentVelocity.width, springConstant, 1);
  mModelY = AxisPhysicsMSDModel(mStartPos.y, aDestination.y,
                                aCurrentVelocity.height, springConstant, 1);
  mIsFirstIteration = false;
}

double
ScrollAnimationMSDPhysics::ComputeSpringConstant(const TimeStamp& aTime)
{
  if (!mPreviousEventTime) {
    mPreviousEventTime = aTime;
    mPreviousDelta = TimeDuration();
    return gfxPrefs::SmoothScrollMSDPhysicsMotionBeginSpringConstant();
  }

  TimeDuration delta = aTime - mPreviousEventTime;
  TimeDuration previousDelta = mPreviousDelta;

  mPreviousEventTime = aTime;
  mPreviousDelta = delta;

  double deltaMS = delta.ToMilliseconds();
  if (deltaMS >= gfxPrefs::SmoothScrollMSDPhysicsContinuousMotionMaxDeltaMS()) {
    return gfxPrefs::SmoothScrollMSDPhysicsMotionBeginSpringConstant();
  }

  if (previousDelta &&
      deltaMS >= gfxPrefs::SmoothScrollMSDPhysicsSlowdownMinDeltaMS() &&
      deltaMS >= previousDelta.ToMilliseconds() * gfxPrefs::SmoothScrollMSDPhysicsSlowdownMinDeltaRatio()) {
    // The rate of events has slowed (the time delta between events has
    // increased) enough that we think that the current scroll motion is coming
    // to a stop. Use a stiffer spring in order to reach the destination more
    // quickly.
    return gfxPrefs::SmoothScrollMSDPhysicsSlowdownSpringConstant();
  }

  return gfxPrefs::SmoothScrollMSDPhysicsRegularSpringConstant();
}

void
ScrollAnimationMSDPhysics::SimulateUntil(const TimeStamp& aTime)
{
  if (!mLastSimulatedTime || aTime < mLastSimulatedTime) {
    return;
  }
  TimeDuration delta = aTime - mLastSimulatedTime;
  mModelX.Simulate(delta);
  mModelY.Simulate(delta);
  mLastSimulatedTime = aTime;
}

nsPoint
ScrollAnimationMSDPhysics::PositionAt(const TimeStamp& aTime)
{
  SimulateUntil(aTime);
  return nsPoint(NSToCoordRound(mModelX.GetPosition()),
                 NSToCoordRound(mModelY.GetPosition()));
}

nsSize
ScrollAnimationMSDPhysics::VelocityAt(const TimeStamp& aTime)
{
  SimulateUntil(aTime);
  return nsSize(NSToCoordRound(mModelX.GetVelocity()),
                NSToCoordRound(mModelY.GetVelocity()));
}