tor-browser

ScrollAnimationMSDPhysics.cpp (8021B)

---

/* -*- 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 "mozilla/Logging.h"
#include "mozilla/StaticPrefs_general.h"
#include "mozilla/StaticPrefs_layout.h"
#include "mozilla/ToString.h"

static mozilla::LazyLogModule sApzMsdLog("apz.msd");
#define MSD_LOG(...) MOZ_LOG(sApzMsdLog, LogLevel::Debug, (__VA_ARGS__))

using namespace mozilla;

ScrollAnimationMSDPhysics::ScrollAnimationMSDPhysics(
   ScrollAnimationKind aAnimationKind, const nsPoint& aStartPos,
   nscoord aSmallestVisibleIncrement)
   : mAnimationKind(aAnimationKind),
     mSmallestVisibleIncrement(aSmallestVisibleIncrement),
     mStartPos(aStartPos),
     mModelX(
         0, 0, 0,
         StaticPrefs::general_smoothScroll_msdPhysics_regularSpringConstant(),
         1),
     mModelY(
         0, 0, 0,
         StaticPrefs::general_smoothScroll_msdPhysics_regularSpringConstant(),
         1),
     mIsFirstIteration(true) {}

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

 // 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 = NonOscillatingAxisPhysicsMSDModel(mStartPos.x, aDestination.x,
                                             aCurrentVelocity.width,
                                             springConstant, dampingRatio);
 mModelY = NonOscillatingAxisPhysicsMSDModel(mStartPos.y, aDestination.y,
                                             aCurrentVelocity.height,
                                             springConstant, dampingRatio);
 mIsFirstIteration = false;
}

void ScrollAnimationMSDPhysics::ApplyContentShift(const CSSPoint& aShiftDelta) {
 nsPoint shiftDelta = CSSPoint::ToAppUnits(aShiftDelta);
 mStartPos += shiftDelta;
 mDestination += shiftDelta;
 TimeStamp currentTime = mLastSimulatedTime;
 nsPoint currentPosition = PositionAt(currentTime) + shiftDelta;
 nsSize currentVelocity = VelocityAt(currentTime);
 double springConstant = ComputeSpringConstant(currentTime);
 double dampingRatio = GetDampingRatio();
 mModelX = NonOscillatingAxisPhysicsMSDModel(currentPosition.x, mDestination.x,
                                             currentVelocity.width,
                                             springConstant, dampingRatio);
 mModelY = NonOscillatingAxisPhysicsMSDModel(currentPosition.y, mDestination.y,
                                             currentVelocity.height,
                                             springConstant, dampingRatio);
}

double ScrollAnimationMSDPhysics::GetDampingRatio() const {
 if (mAnimationKind == ScrollAnimationKind::SmoothMsd) {
   return StaticPrefs::layout_css_scroll_snap_damping_ratio();
 }
 return 1.0;
}

double ScrollAnimationMSDPhysics::ComputeSpringConstant(
   const TimeStamp& aTime) {
 if (mAnimationKind == ScrollAnimationKind::SmoothMsd) {
   return StaticPrefs::layout_css_scroll_snap_spring_constant();
 }

 if (!mPreviousEventTime) {
   mPreviousEventTime = aTime;
   mPreviousDelta = TimeDuration();
   return StaticPrefs::
       general_smoothScroll_msdPhysics_motionBeginSpringConstant();
 }

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

 mPreviousEventTime = aTime;
 mPreviousDelta = delta;

 double deltaMS = delta.ToMilliseconds();
 if (deltaMS >=
     StaticPrefs::
         general_smoothScroll_msdPhysics_continuousMotionMaxDeltaMS()) {
   return StaticPrefs::
       general_smoothScroll_msdPhysics_motionBeginSpringConstant();
 }

 if (previousDelta &&
     deltaMS >=
         StaticPrefs::general_smoothScroll_msdPhysics_slowdownMinDeltaMS() &&
     deltaMS >=
         previousDelta.ToMilliseconds() *
             StaticPrefs::
                 general_smoothScroll_msdPhysics_slowdownMinDeltaRatio()) {
   // 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 StaticPrefs::
       general_smoothScroll_msdPhysics_slowdownSpringConstant();
 }

 return StaticPrefs::general_smoothScroll_msdPhysics_regularSpringConstant();
}

void ScrollAnimationMSDPhysics::SimulateUntil(const TimeStamp& aTime) {
 if (!mLastSimulatedTime || aTime <= mLastSimulatedTime) {
   return;
 }
 TimeDuration delta = aTime - mLastSimulatedTime;
 mModelX.Simulate(delta);
 mModelY.Simulate(delta);
 mLastSimulatedTime = aTime;
 MSD_LOG("Simulated for duration %f, finished %d position %s velocity %s\n",
         delta.ToMilliseconds(), IsFinished(aTime),
         ToString(CSSPoint::FromAppUnits(PositionAt(aTime))).c_str(),
         ToString(CSSPoint::FromAppUnits(VelocityAt(aTime))).c_str());
}

bool mozilla::ScrollAnimationMSDPhysics::IsFinished(const TimeStamp& aTime) {
 SimulateUntil(aTime);
 return mModelX.IsFinished(mSmallestVisibleIncrement) &&
        mModelY.IsFinished(mSmallestVisibleIncrement);
}

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()));
}

static double ClampVelocityToMaximum(double aVelocity, double aInitialPosition,
                                    double aDestination,
                                    double aSpringConstant) {
 // Clamp velocity to the maximum value it could obtain if we started at this
 // position with zero velocity (see bug 1866904 comment 3). With a damping
 // ratio >= 1.0, this should be low enough to avoid overshooting the
 // destination.
 double velocityLimit =
     sqrt(aSpringConstant) * abs(aDestination - aInitialPosition);
 return std::clamp(aVelocity, -velocityLimit, velocityLimit);
}

ScrollAnimationMSDPhysics::NonOscillatingAxisPhysicsMSDModel::
   NonOscillatingAxisPhysicsMSDModel(double aInitialPosition,
                                     double aInitialDestination,
                                     double aInitialVelocity,
                                     double aSpringConstant,
                                     double aDampingRatio)
   : AxisPhysicsMSDModel(
         aInitialPosition, aInitialDestination,
         ClampVelocityToMaximum(aInitialVelocity, aInitialPosition,
                                aInitialDestination, aSpringConstant),
         aSpringConstant, aDampingRatio) {
 MSD_LOG("Constructing axis physics model with parameters %f %f %f %f %f\n",
         aInitialPosition, aInitialDestination, aInitialVelocity,
         aSpringConstant, aDampingRatio);
 MOZ_ASSERT(aDampingRatio >= 1.0,
            "Damping ratio must be >= 1.0 to avoid oscillation");
}