| /* |
| * Copyright (C) 2016 Igalia S.L. |
| * Copyright (C) 2015 Apple Inc. All rights reserved. |
| * Copyright (c) 2011, Google Inc. All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * 2. Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * |
| * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' |
| * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, |
| * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
| * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS |
| * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
| * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
| * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS |
| * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
| * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
| * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF |
| * THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| #include "config.h" |
| #include "ScrollAnimationSmooth.h" |
| |
| #include "FloatPoint.h" |
| #include "ScrollableArea.h" |
| |
| namespace WebCore { |
| |
| static const double frameRate = 60; |
| static const Seconds tickTime = 1_s / frameRate; |
| static const Seconds minimumTimerInterval { 1_ms }; |
| static const double smoothFactorForProgrammaticScroll = 5; |
| |
| ScrollAnimationSmooth::ScrollAnimationSmooth(ScrollableArea& scrollableArea, const FloatPoint& position, WTF::Function<void (FloatPoint&&)>&& notifyPositionChangedFunction) |
| : ScrollAnimation(scrollableArea) |
| , m_notifyPositionChangedFunction(WTFMove(notifyPositionChangedFunction)) |
| , m_horizontalData(position.x(), scrollableArea.visibleWidth()) |
| , m_verticalData(position.y(), scrollableArea.visibleHeight()) |
| , m_animationTimer(*this, &ScrollAnimationSmooth::animationTimerFired) |
| { |
| } |
| |
| bool ScrollAnimationSmooth::scroll(ScrollbarOrientation orientation, ScrollGranularity granularity, float step, float multiplier) |
| { |
| float minScrollPosition; |
| float maxScrollPosition; |
| if (orientation == HorizontalScrollbar) { |
| minScrollPosition = m_scrollableArea.minimumScrollPosition().x(); |
| maxScrollPosition = m_scrollableArea.maximumScrollPosition().x(); |
| } else { |
| minScrollPosition = m_scrollableArea.minimumScrollPosition().y(); |
| maxScrollPosition = m_scrollableArea.maximumScrollPosition().y(); |
| } |
| bool needToScroll = updatePerAxisData(orientation == HorizontalScrollbar ? m_horizontalData : m_verticalData, granularity, step * multiplier, minScrollPosition, maxScrollPosition); |
| if (needToScroll && !animationTimerActive()) { |
| m_startTime = orientation == HorizontalScrollbar ? m_horizontalData.startTime : m_verticalData.startTime; |
| animationTimerFired(); |
| } |
| return needToScroll; |
| } |
| |
| void ScrollAnimationSmooth::scroll(const FloatPoint& position) |
| { |
| ScrollGranularity granularity = ScrollByPage; |
| bool needToScroll = updatePerAxisData(m_horizontalData, granularity, position.x() - m_horizontalData.currentPosition, m_scrollableArea.minimumScrollPosition().x(), m_scrollableArea.maximumScrollPosition().x(), smoothFactorForProgrammaticScroll); |
| needToScroll |= |
| updatePerAxisData(m_verticalData, granularity, position.y() - m_verticalData.currentPosition, m_scrollableArea.minimumScrollPosition().y(), m_scrollableArea.maximumScrollPosition().y(), smoothFactorForProgrammaticScroll); |
| if (needToScroll && !animationTimerActive()) { |
| m_startTime = m_horizontalData.startTime; |
| animationTimerFired(); |
| } |
| }; |
| |
| void ScrollAnimationSmooth::stop() |
| { |
| m_animationTimer.stop(); |
| m_scrollableArea.setScrollBehaviorStatus(ScrollBehaviorStatus::NotInAnimation); |
| } |
| |
| void ScrollAnimationSmooth::updateVisibleLengths() |
| { |
| m_horizontalData.visibleLength = m_scrollableArea.visibleWidth(); |
| m_verticalData.visibleLength = m_scrollableArea.visibleHeight(); |
| } |
| |
| void ScrollAnimationSmooth::setCurrentPosition(const FloatPoint& position) |
| { |
| stop(); |
| m_horizontalData = PerAxisData(position.x(), m_horizontalData.visibleLength); |
| m_verticalData = PerAxisData(position.y(), m_verticalData.visibleLength); |
| } |
| |
| ScrollAnimationSmooth::~ScrollAnimationSmooth() = default; |
| |
| static inline double curveAt(ScrollAnimationSmooth::Curve curve, double t) |
| { |
| switch (curve) { |
| case ScrollAnimationSmooth::Curve::Linear: |
| return t; |
| case ScrollAnimationSmooth::Curve::Quadratic: |
| return t * t; |
| case ScrollAnimationSmooth::Curve::Cubic: |
| return t * t * t; |
| case ScrollAnimationSmooth::Curve::Quartic: |
| return t * t * t * t; |
| case ScrollAnimationSmooth::Curve::Bounce: |
| // Time base is chosen to keep the bounce points simpler: |
| // 1 (half bounce coming in) + 1 + .5 + .25 |
| static const double timeBase = 2.75; |
| static const double timeBaseSquared = timeBase * timeBase; |
| if (t < 1 / timeBase) |
| return timeBaseSquared * t * t; |
| if (t < 2 / timeBase) { |
| // Invert a [-.5,.5] quadratic parabola, center it in [1,2]. |
| double t1 = t - 1.5 / timeBase; |
| const double parabolaAtEdge = 1 - .5 * .5; |
| return timeBaseSquared * t1 * t1 + parabolaAtEdge; |
| } |
| if (t < 2.5 / timeBase) { |
| // Invert a [-.25,.25] quadratic parabola, center it in [2,2.5]. |
| double t2 = t - 2.25 / timeBase; |
| const double parabolaAtEdge = 1 - .25 * .25; |
| return timeBaseSquared * t2 * t2 + parabolaAtEdge; |
| } |
| // Invert a [-.125,.125] quadratic parabola, center it in [2.5,2.75]. |
| const double parabolaAtEdge = 1 - .125 * .125; |
| t -= 2.625 / timeBase; |
| return timeBaseSquared * t * t + parabolaAtEdge; |
| } |
| ASSERT_NOT_REACHED(); |
| return 0; |
| } |
| |
| static inline double attackCurve(ScrollAnimationSmooth::Curve curve, double deltaTime, double curveT, double startPosition, double attackPosition) |
| { |
| double t = deltaTime / curveT; |
| double positionFactor = curveAt(curve, t); |
| return startPosition + positionFactor * (attackPosition - startPosition); |
| } |
| |
| static inline double releaseCurve(ScrollAnimationSmooth::Curve curve, double deltaTime, double curveT, double releasePosition, double desiredPosition) |
| { |
| double t = deltaTime / curveT; |
| double positionFactor = 1 - curveAt(curve, 1 - t); |
| return releasePosition + (positionFactor * (desiredPosition - releasePosition)); |
| } |
| |
| static inline double coastCurve(ScrollAnimationSmooth::Curve curve, double factor) |
| { |
| return 1 - curveAt(curve, 1 - factor); |
| } |
| |
| static inline double curveIntegralAt(ScrollAnimationSmooth::Curve curve, double t) |
| { |
| switch (curve) { |
| case ScrollAnimationSmooth::Curve::Linear: |
| return t * t / 2; |
| case ScrollAnimationSmooth::Curve::Quadratic: |
| return t * t * t / 3; |
| case ScrollAnimationSmooth::Curve::Cubic: |
| return t * t * t * t / 4; |
| case ScrollAnimationSmooth::Curve::Quartic: |
| return t * t * t * t * t / 5; |
| case ScrollAnimationSmooth::Curve::Bounce: |
| static const double timeBase = 2.75; |
| static const double timeBaseSquared = timeBase * timeBase; |
| static const double timeBaseSquaredOverThree = timeBaseSquared / 3; |
| double area; |
| double t1 = std::min(t, 1 / timeBase); |
| area = timeBaseSquaredOverThree * t1 * t1 * t1; |
| if (t < 1 / timeBase) |
| return area; |
| |
| t1 = std::min(t - 1 / timeBase, 1 / timeBase); |
| // The integral of timeBaseSquared * (t1 - .5 / timeBase) * (t1 - .5 / timeBase) + parabolaAtEdge |
| static const double secondInnerOffset = timeBaseSquared * .5 / timeBase; |
| double bounceArea = t1 * (t1 * (timeBaseSquaredOverThree * t1 - secondInnerOffset) + 1); |
| area += bounceArea; |
| if (t < 2 / timeBase) |
| return area; |
| |
| t1 = std::min(t - 2 / timeBase, 0.5 / timeBase); |
| // The integral of timeBaseSquared * (t1 - .25 / timeBase) * (t1 - .25 / timeBase) + parabolaAtEdge |
| static const double thirdInnerOffset = timeBaseSquared * .25 / timeBase; |
| bounceArea = t1 * (t1 * (timeBaseSquaredOverThree * t1 - thirdInnerOffset) + 1); |
| area += bounceArea; |
| if (t < 2.5 / timeBase) |
| return area; |
| |
| t1 = t - 2.5 / timeBase; |
| // The integral of timeBaseSquared * (t1 - .125 / timeBase) * (t1 - .125 / timeBase) + parabolaAtEdge |
| static const double fourthInnerOffset = timeBaseSquared * .125 / timeBase; |
| bounceArea = t1 * (t1 * (timeBaseSquaredOverThree * t1 - fourthInnerOffset) + 1); |
| area += bounceArea; |
| return area; |
| } |
| ASSERT_NOT_REACHED(); |
| return 0; |
| } |
| |
| static inline double attackArea(ScrollAnimationSmooth::Curve curve, double startT, double endT) |
| { |
| double startValue = curveIntegralAt(curve, startT); |
| double endValue = curveIntegralAt(curve, endT); |
| return endValue - startValue; |
| } |
| |
| static inline double releaseArea(ScrollAnimationSmooth::Curve curve, double startT, double endT) |
| { |
| double startValue = curveIntegralAt(curve, 1 - endT); |
| double endValue = curveIntegralAt(curve, 1 - startT); |
| return endValue - startValue; |
| } |
| |
| static inline void getAnimationParametersForGranularity(ScrollGranularity granularity, Seconds& animationTime, Seconds& repeatMinimumSustainTime, Seconds& attackTime, Seconds& releaseTime, ScrollAnimationSmooth::Curve& coastTimeCurve, Seconds& maximumCoastTime) |
| { |
| switch (granularity) { |
| case ScrollByDocument: |
| animationTime = tickTime * 10; |
| repeatMinimumSustainTime = tickTime * 10; |
| attackTime = tickTime * 10; |
| releaseTime = tickTime * 10; |
| coastTimeCurve = ScrollAnimationSmooth::Curve::Linear; |
| maximumCoastTime = 1_s; |
| break; |
| case ScrollByLine: |
| animationTime = tickTime * 10; |
| repeatMinimumSustainTime = tickTime * 7; |
| attackTime = tickTime * 3; |
| releaseTime = tickTime * 3; |
| coastTimeCurve = ScrollAnimationSmooth::Curve::Linear; |
| maximumCoastTime = 1_s; |
| break; |
| case ScrollByPage: |
| animationTime = tickTime * 15; |
| repeatMinimumSustainTime = tickTime * 10; |
| attackTime = tickTime * 5; |
| releaseTime = tickTime * 5; |
| coastTimeCurve = ScrollAnimationSmooth::Curve::Linear; |
| maximumCoastTime = 1_s; |
| break; |
| case ScrollByPixel: |
| animationTime = tickTime * 11; |
| repeatMinimumSustainTime = tickTime * 2; |
| attackTime = tickTime * 3; |
| releaseTime = tickTime * 3; |
| coastTimeCurve = ScrollAnimationSmooth::Curve::Quadratic; |
| maximumCoastTime = 1250_ms; |
| break; |
| default: |
| ASSERT_NOT_REACHED(); |
| } |
| } |
| |
| bool ScrollAnimationSmooth::updatePerAxisData(PerAxisData& data, ScrollGranularity granularity, float delta, float minScrollPosition, float maxScrollPosition, double smoothFactor) |
| { |
| if (!data.startTime || !delta || (delta < 0) != (data.desiredPosition - data.currentPosition < 0)) { |
| data.desiredPosition = data.currentPosition; |
| data.startTime = { }; |
| } |
| float newPosition = data.desiredPosition + delta; |
| |
| newPosition = std::max(std::min(newPosition, maxScrollPosition), minScrollPosition); |
| |
| if (newPosition == data.desiredPosition) |
| return false; |
| |
| Seconds animationTime, repeatMinimumSustainTime, attackTime, releaseTime, maximumCoastTime; |
| Curve coastTimeCurve; |
| getAnimationParametersForGranularity(granularity, animationTime, repeatMinimumSustainTime, attackTime, releaseTime, coastTimeCurve, maximumCoastTime); |
| |
| animationTime *= smoothFactor; |
| repeatMinimumSustainTime *= smoothFactor; |
| attackTime *= smoothFactor; |
| releaseTime *= smoothFactor; |
| maximumCoastTime *= smoothFactor; |
| |
| data.desiredPosition = newPosition; |
| if (!data.startTime) |
| data.attackTime = attackTime; |
| data.animationTime = animationTime; |
| data.releaseTime = releaseTime; |
| |
| // Prioritize our way out of over constraint. |
| if (data.attackTime + data.releaseTime > data.animationTime) { |
| if (data.releaseTime > data.animationTime) |
| data.releaseTime = data.animationTime; |
| data.attackTime = data.animationTime - data.releaseTime; |
| } |
| |
| if (!data.startTime) { |
| // FIXME: This should be the time from the event that got us here. |
| data.startTime = MonotonicTime::now() - tickTime / 2.; |
| data.startPosition = data.currentPosition; |
| data.lastAnimationTime = data.startTime; |
| } |
| data.startVelocity = data.currentVelocity; |
| |
| double remainingDelta = data.desiredPosition - data.currentPosition; |
| double attackAreaLeft = 0; |
| Seconds deltaTime = data.lastAnimationTime - data.startTime; |
| Seconds attackTimeLeft = std::max(0_s, data.attackTime - deltaTime); |
| Seconds timeLeft = data.animationTime - deltaTime; |
| Seconds minTimeLeft = data.releaseTime + std::min(repeatMinimumSustainTime, data.animationTime - data.releaseTime - attackTimeLeft); |
| if (timeLeft < minTimeLeft) { |
| data.animationTime = deltaTime + minTimeLeft; |
| timeLeft = minTimeLeft; |
| } |
| |
| if (maximumCoastTime > (repeatMinimumSustainTime + releaseTime)) { |
| double targetMaxCoastVelocity = data.visibleLength * .25 * frameRate; |
| // This needs to be as minimal as possible while not being intrusive to page up/down. |
| double minCoastDelta = data.visibleLength; |
| |
| if (fabs(remainingDelta) > minCoastDelta) { |
| double maxCoastDelta = maximumCoastTime.value() * targetMaxCoastVelocity; |
| double coastFactor = std::min(1., (fabs(remainingDelta) - minCoastDelta) / (maxCoastDelta - minCoastDelta)); |
| |
| // We could play with the curve here - linear seems a little soft. Initial testing makes me want to feed into the sustain time more aggressively. |
| Seconds coastMinTimeLeft = std::min(maximumCoastTime, minTimeLeft + (maximumCoastTime - minTimeLeft) * coastCurve(coastTimeCurve, coastFactor)); |
| |
| if (Seconds additionalTime = std::max(0_s, coastMinTimeLeft - minTimeLeft)) { |
| Seconds additionalReleaseTime = std::min(additionalTime, additionalTime * (releaseTime / (releaseTime + repeatMinimumSustainTime))); |
| data.releaseTime = releaseTime + additionalReleaseTime; |
| data.animationTime = deltaTime + coastMinTimeLeft; |
| timeLeft = coastMinTimeLeft; |
| } |
| } |
| } |
| |
| Seconds releaseTimeLeft = std::min(timeLeft, data.releaseTime); |
| Seconds sustainTimeLeft = std::max(0_s, timeLeft - releaseTimeLeft - attackTimeLeft); |
| if (attackTimeLeft) { |
| double attackSpot = deltaTime / data.attackTime; |
| attackAreaLeft = attackArea(Curve::Cubic, attackSpot, 1) * data.attackTime.value(); |
| } |
| |
| double releaseSpot = (data.releaseTime - releaseTimeLeft) / data.releaseTime; |
| double releaseAreaLeft = releaseArea(Curve::Cubic, releaseSpot, 1) * data.releaseTime.value(); |
| |
| data.desiredVelocity = remainingDelta / (attackAreaLeft + sustainTimeLeft.value() + releaseAreaLeft); |
| data.releasePosition = data.desiredPosition - data.desiredVelocity * releaseAreaLeft; |
| if (attackAreaLeft) |
| data.attackPosition = data.startPosition + data.desiredVelocity * attackAreaLeft; |
| else |
| data.attackPosition = data.releasePosition - (data.animationTime - data.releaseTime - data.attackTime).value() * data.desiredVelocity; |
| |
| if (sustainTimeLeft) { |
| double roundOff = data.releasePosition - ((attackAreaLeft ? data.attackPosition : data.currentPosition) + data.desiredVelocity * sustainTimeLeft.value()); |
| data.desiredVelocity += roundOff / sustainTimeLeft.value(); |
| } |
| |
| return true; |
| } |
| |
| bool ScrollAnimationSmooth::animateScroll(PerAxisData& data, MonotonicTime currentTime) |
| { |
| if (!data.startTime) |
| return false; |
| |
| Seconds lastScrollInterval = currentTime - data.lastAnimationTime; |
| if (lastScrollInterval < minimumTimerInterval) |
| return true; |
| |
| data.lastAnimationTime = currentTime; |
| |
| Seconds deltaTime = currentTime - data.startTime; |
| double newPosition = data.currentPosition; |
| |
| if (deltaTime > data.animationTime) { |
| data = PerAxisData(data.desiredPosition, data.visibleLength); |
| return false; |
| } |
| if (deltaTime < data.attackTime) |
| newPosition = attackCurve(Curve::Cubic, deltaTime.value(), data.attackTime.value(), data.startPosition, data.attackPosition); |
| else if (deltaTime < (data.animationTime - data.releaseTime)) |
| newPosition = data.attackPosition + (deltaTime - data.attackTime).value() * data.desiredVelocity; |
| else { |
| // release is based on targeting the exact final position. |
| Seconds releaseDeltaT = deltaTime - (data.animationTime - data.releaseTime); |
| newPosition = releaseCurve(Curve::Cubic, releaseDeltaT.value(), data.releaseTime.value(), data.releasePosition, data.desiredPosition); |
| } |
| |
| // Normalize velocity to a per second amount. Could be used to check for jank. |
| if (lastScrollInterval > 0_s) |
| data.currentVelocity = (newPosition - data.currentPosition) / lastScrollInterval.value(); |
| data.currentPosition = newPosition; |
| |
| return true; |
| } |
| |
| void ScrollAnimationSmooth::animationTimerFired() |
| { |
| MonotonicTime currentTime = MonotonicTime::now(); |
| Seconds deltaToNextFrame = 1_s * ceil((currentTime - m_startTime).value() * frameRate) / frameRate - (currentTime - m_startTime); |
| currentTime += deltaToNextFrame; |
| |
| bool continueAnimation = false; |
| if (animateScroll(m_horizontalData, currentTime)) |
| continueAnimation = true; |
| if (animateScroll(m_verticalData, currentTime)) |
| continueAnimation = true; |
| |
| if (continueAnimation) |
| startNextTimer(std::max(minimumTimerInterval, deltaToNextFrame)); |
| else |
| m_scrollableArea.setScrollBehaviorStatus(ScrollBehaviorStatus::NotInAnimation); |
| |
| m_notifyPositionChangedFunction(FloatPoint(m_horizontalData.currentPosition, m_verticalData.currentPosition)); |
| } |
| |
| void ScrollAnimationSmooth::startNextTimer(Seconds delay) |
| { |
| m_animationTimer.startOneShot(delay); |
| } |
| |
| bool ScrollAnimationSmooth::animationTimerActive() const |
| { |
| return m_animationTimer.isActive(); |
| } |
| |
| } // namespace WebCore |
