| // Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file |
| // for details. All rights reserved. Use of this source code is governed by a |
| // BSD-style license that can be found in the LICENSE file. |
| |
| // @dart = 2.9 |
| |
| part of touch; |
| |
| /// Functions to model constant acceleration as a cubic Bezier |
| /// curve (http://en.wikipedia.org/wiki/Bezier_curve). These functions are |
| /// intended to generate the transition timing function for CSS transitions. |
| /// Please see |
| /// [http://www.w3.org/TR/css3-transitions/#transition-timing-function_tag]. |
| /// |
| /// The main operation of computing a cubic Bezier is split up into multiple |
| /// functions so that, should it be required, more operations and cases can be |
| /// supported in the future. |
| class BezierPhysics { |
| static const _ONE_THIRD = 1 / 3; |
| static const _TWO_THIRDS = 2 / 3; |
| |
| /// A list [:[x1, y1, x2, y2]:] of the intermediate control points of a cubic |
| /// bezier when the final velocity is zero. This is a special case for which |
| /// these control points are constants. |
| static const List<num> _FINAL_VELOCITY_ZERO_BEZIER = [ |
| _ONE_THIRD, |
| _TWO_THIRDS, |
| _TWO_THIRDS, |
| 1 |
| ]; |
| |
| /// Given consistent kinematics parameters for constant acceleration, returns |
| /// the intermediate control points of the cubic Bezier curve that models the |
| /// motion. All input values must have correct signs. |
| /// Returns a list [:[x1, y1, x2, y2]:] representing the intermediate control |
| /// points of the cubic Bezier. |
| static List<num> calculateCubicBezierFromKinematics(num initialVelocity, |
| num finalVelocity, num totalTime, num totalDisplacement) { |
| // Total time must be greater than 0. |
| assert(!GoogleMath.nearlyEquals(totalTime, 0) && totalTime > 0); |
| // Total displacement must not be 0. |
| assert(!GoogleMath.nearlyEquals(totalDisplacement, 0)); |
| // Parameters must form a consistent constant acceleration model in |
| // Newtonian kinematics. |
| assert(GoogleMath.nearlyEquals(totalDisplacement, |
| (initialVelocity + finalVelocity) * 0.5 * totalTime)); |
| |
| if (GoogleMath.nearlyEquals(finalVelocity, 0)) { |
| return _FINAL_VELOCITY_ZERO_BEZIER; |
| } |
| List<num> controlPoint = _tangentLinesToQuadraticBezier( |
| initialVelocity, finalVelocity, totalTime, totalDisplacement); |
| controlPoint = _normalizeQuadraticBezier( |
| controlPoint[0], controlPoint[1], totalTime, totalDisplacement); |
| return _quadraticToCubic(controlPoint[0], controlPoint[1]); |
| } |
| |
| /// Given a quadratic curve crossing points (0, 0) and (x2, y2), calculates the |
| /// intermediate control point (x1, y1) of the equivalent quadratic Bezier |
| /// curve with starting point (0, 0) and ending point (x2, y2). |
| /// [m0] The slope of the line tangent to the curve at (0, 0). |
| /// [m2] The slope of the line tangent to the curve at a different |
| /// point (x2, y2). |
| /// [x2] The x-coordinate of the other point on the curve. |
| /// [y2] The y-coordinate of the other point on the curve. |
| /// Returns a list [:[x1, y1]:] representing the intermediate |
| /// control point of the quadratic Bezier. |
| static List<num> _tangentLinesToQuadraticBezier( |
| num m0, num m2, num x2, num y2) { |
| if (GoogleMath.nearlyEquals(m0, m2)) { |
| return [0, 0]; |
| } |
| num x1 = (y2 - x2 * m2) / (m0 - m2); |
| num y1 = x1 * m0; |
| return [x1, y1]; |
| } |
| |
| /// Normalizes a quadratic Bezier curve to have end point at (1, 1). |
| /// [x1] The x-coordinate of the intermediate control point. |
| /// [y1] The y-coordinate of the intermediate control point. |
| /// [x2] The x-coordinate of the end point. |
| /// [y2] The y-coordinate of the end point. |
| /// Returns a list [:[x1, y1]:] representing the intermediate control point. |
| static List<num> _normalizeQuadraticBezier(num x1, num y1, num x2, num y2) { |
| // The end point must not lie on any axes. |
| assert(!GoogleMath.nearlyEquals(x2, 0) && !GoogleMath.nearlyEquals(y2, 0)); |
| return [x1 / x2, y1 / y2]; |
| } |
| |
| /// Converts a quadratic Bezier curve defined by the control points |
| /// (x0, y0) = (0, 0), (x1, y1) = (x, y), and (x2, y2) = (1, 1) into an |
| /// equivalent cubic Bezier curve with four control points. Note that the start |
| /// and end points will be unchanged. |
| /// [x] The x-coordinate of the intermediate control point. |
| /// [y] The y-coordinate of the intermediate control point. |
| /// Returns a list [:[x1, y1, x2, y2]:] containing the two |
| /// intermediate points of the equivalent cubic Bezier curve. |
| static List<num> _quadraticToCubic(num x, num y) { |
| // The intermediate control point must have coordinates within the |
| // interval [0,1]. |
| assert(x >= 0 && x <= 1 && y >= 0 && y <= 1); |
| num x1 = x * _TWO_THIRDS; |
| num y1 = y * _TWO_THIRDS; |
| num x2 = x1 + _ONE_THIRD; |
| num y2 = y1 + _ONE_THIRD; |
| return [x1, y1, x2, y2]; |
| } |
| } |