summaryrefslogtreecommitdiffstats
path: root/gfx/layers/apz/src/GenericFlingAnimation.h
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 09:22:09 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 09:22:09 +0000
commit43a97878ce14b72f0981164f87f2e35e14151312 (patch)
tree620249daf56c0258faa40cbdcf9cfba06de2a846 /gfx/layers/apz/src/GenericFlingAnimation.h
parentInitial commit. (diff)
downloadfirefox-upstream.tar.xz
firefox-upstream.zip
Adding upstream version 110.0.1.upstream/110.0.1upstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'gfx/layers/apz/src/GenericFlingAnimation.h')
-rw-r--r--gfx/layers/apz/src/GenericFlingAnimation.h207
1 files changed, 207 insertions, 0 deletions
diff --git a/gfx/layers/apz/src/GenericFlingAnimation.h b/gfx/layers/apz/src/GenericFlingAnimation.h
new file mode 100644
index 0000000000..82f981ae0a
--- /dev/null
+++ b/gfx/layers/apz/src/GenericFlingAnimation.h
@@ -0,0 +1,207 @@
+/* -*- 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/. */
+
+#ifndef mozilla_layers_GenericFlingAnimation_h_
+#define mozilla_layers_GenericFlingAnimation_h_
+
+#include "APZUtils.h"
+#include "AsyncPanZoomAnimation.h"
+#include "AsyncPanZoomController.h"
+#include "FrameMetrics.h"
+#include "Units.h"
+#include "OverscrollHandoffState.h"
+#include "mozilla/Assertions.h"
+#include "mozilla/Monitor.h"
+#include "mozilla/RefPtr.h"
+#include "mozilla/StaticPrefs_apz.h"
+#include "mozilla/TimeStamp.h"
+#include "mozilla/ToString.h"
+#include "nsThreadUtils.h"
+
+static mozilla::LazyLogModule sApzFlgLog("apz.fling");
+#define FLING_LOG(...) MOZ_LOG(sApzFlgLog, LogLevel::Debug, (__VA_ARGS__))
+
+namespace mozilla {
+namespace layers {
+
+/**
+ * The FlingPhysics template parameter determines the physics model
+ * that the fling animation follows. It must have the following methods:
+ *
+ * - Default constructor.
+ *
+ * - Init(const ParentLayerPoint& aStartingVelocity, float aPLPPI).
+ * Called at the beginning of the fling, with the fling's starting velocity,
+ * and the number of ParentLayer pixels per (Screen) inch at the point of
+ * the fling's start in the fling's direction.
+ *
+ * - Sample(const TimeDuration& aDelta,
+ * ParentLayerPoint* aOutVelocity,
+ * ParentLayerPoint* aOutOffset);
+ * Called on each sample of the fling.
+ * |aDelta| is the time elapsed since the last sample.
+ * |aOutVelocity| should be the desired velocity after the current sample,
+ * in ParentLayer pixels per millisecond.
+ * |aOutOffset| should be the desired _delta_ to the scroll offset after
+ * the current sample. |aOutOffset| should _not_ be clamped to the APZC's
+ * scrollable bounds; the caller will do the clamping, and it needs to
+ * know the unclamped value to handle handoff/overscroll correctly.
+ */
+template <typename FlingPhysics>
+class GenericFlingAnimation : public AsyncPanZoomAnimation,
+ public FlingPhysics {
+ public:
+ GenericFlingAnimation(AsyncPanZoomController& aApzc,
+ const FlingHandoffState& aHandoffState, float aPLPPI)
+ : mApzc(aApzc),
+ mOverscrollHandoffChain(aHandoffState.mChain),
+ mScrolledApzc(aHandoffState.mScrolledApzc) {
+ MOZ_ASSERT(mOverscrollHandoffChain);
+
+ // Drop any velocity on axes where we don't have room to scroll anyways
+ // (in this APZC, or an APZC further in the handoff chain).
+ // This ensures that we don't take the 'overscroll' path in Sample()
+ // on account of one axis which can't scroll having a velocity.
+ if (!mOverscrollHandoffChain->CanScrollInDirection(
+ &mApzc, ScrollDirection::eHorizontal)) {
+ RecursiveMutexAutoLock lock(mApzc.mRecursiveMutex);
+ mApzc.mX.SetVelocity(0);
+ }
+ if (!mOverscrollHandoffChain->CanScrollInDirection(
+ &mApzc, ScrollDirection::eVertical)) {
+ RecursiveMutexAutoLock lock(mApzc.mRecursiveMutex);
+ mApzc.mY.SetVelocity(0);
+ }
+
+ if (aHandoffState.mIsHandoff) {
+ // Only apply acceleration in the APZC that originated the fling, not in
+ // APZCs further down the handoff chain during handoff.
+ mApzc.mFlingAccelerator.Reset();
+ }
+
+ ParentLayerPoint velocity =
+ mApzc.mFlingAccelerator.GetFlingStartingVelocity(
+ aApzc.GetFrameTime(), mApzc.GetVelocityVector(), aHandoffState);
+
+ mApzc.SetVelocityVector(velocity);
+
+ FlingPhysics::Init(mApzc.GetVelocityVector(), aPLPPI);
+ }
+
+ /**
+ * Advances a fling by an interpolated amount based on the passed in |aDelta|.
+ * This should be called whenever sampling the content transform for this
+ * frame. Returns true if the fling animation should be advanced by one frame,
+ * or false if there is no fling or the fling has ended.
+ */
+ virtual bool DoSample(FrameMetrics& aFrameMetrics,
+ const TimeDuration& aDelta) override {
+ CSSToParentLayerScale zoom(aFrameMetrics.GetZoom());
+ if (zoom == CSSToParentLayerScale(0)) {
+ return false;
+ }
+
+ ParentLayerPoint velocity;
+ ParentLayerPoint offset;
+ FlingPhysics::Sample(aDelta, &velocity, &offset);
+
+ mApzc.SetVelocityVector(velocity);
+
+ // If we shouldn't continue the fling, let's just stop and repaint.
+ if (IsZero(velocity / zoom)) {
+ FLING_LOG("%p ending fling animation. overscrolled=%d\n", &mApzc,
+ mApzc.IsOverscrolled());
+ // This APZC or an APZC further down the handoff chain may be be
+ // overscrolled. Start a snap-back animation on the overscrolled APZC.
+ // Note:
+ // This needs to be a deferred task even though it can safely run
+ // while holding mRecursiveMutex, because otherwise, if the overscrolled
+ // APZC is this one, then the SetState(NOTHING) in UpdateAnimation will
+ // stomp on the SetState(SNAP_BACK) it does.
+ mDeferredTasks.AppendElement(NewRunnableMethod<AsyncPanZoomController*>(
+ "layers::OverscrollHandoffChain::SnapBackOverscrolledApzc",
+ mOverscrollHandoffChain.get(),
+ &OverscrollHandoffChain::SnapBackOverscrolledApzc, &mApzc));
+ return false;
+ }
+
+ // Ordinarily we might need to do a ScheduleComposite if either of
+ // the following AdjustDisplacement calls returns true, but this
+ // is already running as part of a FlingAnimation, so we'll be compositing
+ // per frame of animation anyway.
+ ParentLayerPoint overscroll;
+ ParentLayerPoint adjustedOffset;
+ mApzc.mX.AdjustDisplacement(offset.x, adjustedOffset.x, overscroll.x);
+ mApzc.mY.AdjustDisplacement(offset.y, adjustedOffset.y, overscroll.y);
+ if (aFrameMetrics.GetZoom() != CSSToParentLayerScale(0)) {
+ mApzc.ScrollBy(adjustedOffset / aFrameMetrics.GetZoom());
+ }
+
+ // The fling may have caused us to reach the end of our scroll range.
+ if (!IsZero(overscroll / zoom)) {
+ // Hand off the fling to the next APZC in the overscroll handoff chain.
+
+ // We may have reached the end of the scroll range along one axis but
+ // not the other. In such a case we only want to hand off the relevant
+ // component of the fling.
+ if (mApzc.IsZero(overscroll.x)) {
+ velocity.x = 0;
+ } else if (mApzc.IsZero(overscroll.y)) {
+ velocity.y = 0;
+ }
+
+ // To hand off the fling, we attempt to find a target APZC and start a new
+ // fling with the same velocity on that APZC. For simplicity, the actual
+ // overscroll of the current sample is discarded rather than being handed
+ // off. The compositor should sample animations sufficiently frequently
+ // that this is not noticeable. The target APZC is chosen by seeing if
+ // there is an APZC further in the handoff chain which is pannable; if
+ // there isn't, we take the new fling ourselves, entering an overscrolled
+ // state.
+ // Note: APZC is holding mRecursiveMutex, so directly calling
+ // HandleFlingOverscroll() (which acquires the tree lock) would violate
+ // the lock ordering. Instead we schedule HandleFlingOverscroll() to be
+ // called after mRecursiveMutex is released.
+ FLING_LOG("%p fling went into overscroll, handing off with velocity %s\n",
+ &mApzc, ToString(velocity).c_str());
+ mDeferredTasks.AppendElement(
+ NewRunnableMethod<ParentLayerPoint, SideBits,
+ RefPtr<const OverscrollHandoffChain>,
+ RefPtr<const AsyncPanZoomController>>(
+ "layers::AsyncPanZoomController::HandleFlingOverscroll", &mApzc,
+ &AsyncPanZoomController::HandleFlingOverscroll, velocity,
+ apz::GetOverscrollSideBits(overscroll), mOverscrollHandoffChain,
+ mScrolledApzc));
+
+ // If there is a remaining velocity on this APZC, continue this fling
+ // as well. (This fling and the handed-off fling will run concurrently.)
+ // Note that AdjustDisplacement() will have zeroed out the velocity
+ // along the axes where we're overscrolled.
+ return !IsZero(mApzc.GetVelocityVector() / zoom);
+ }
+
+ return true;
+ }
+
+ void Cancel(CancelAnimationFlags aFlags) override {
+ mApzc.mFlingAccelerator.ObserveFlingCanceled(mApzc.GetVelocityVector());
+ }
+
+ virtual bool HandleScrollOffsetUpdate(
+ const Maybe<CSSPoint>& aRelativeDelta) override {
+ return true;
+ }
+
+ private:
+ AsyncPanZoomController& mApzc;
+ RefPtr<const OverscrollHandoffChain> mOverscrollHandoffChain;
+ RefPtr<const AsyncPanZoomController> mScrolledApzc;
+};
+
+} // namespace layers
+} // namespace mozilla
+
+#endif // mozilla_layers_GenericFlingAnimation_h_