1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
|
/* -*- 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_behavior_damping_ratio();
}
return 1.0;
}
double ScrollAnimationMSDPhysics::ComputeSpringConstant(
const TimeStamp& aTime) {
if (mAnimationKind == ScrollAnimationKind::SmoothMsd) {
return StaticPrefs::layout_css_scroll_behavior_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");
}
|
