Add further abstraction to Sliders/IHasCurve.

osu.Game/Modes/Objects/BezierApproximator.cs

@@ -0,0 +1,150 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System.Collections.Generic;
+using OpenTK;
+
+namespace osu.Game.Modes.Objects
+{
+    public class BezierApproximator
+    {
+        private int count;
+        private List<Vector2> controlPoints;
+        private Vector2[] subdivisionBuffer1;
+        private Vector2[] subdivisionBuffer2;
+
+        private const float tolerance = 0.25f;
+        private const float tolerance_sq = tolerance * tolerance;
+
+        public BezierApproximator(List<Vector2> controlPoints)
+        {
+            this.controlPoints = controlPoints;
+            count = controlPoints.Count;
+
+            subdivisionBuffer1 = new Vector2[count];
+            subdivisionBuffer2 = new Vector2[count * 2 - 1];
+        }
+
+        /// <summary>
+        /// Make sure the 2nd order derivative (approximated using finite elements) is within tolerable bounds.
+        /// NOTE: The 2nd order derivative of a 2d curve represents its curvature, so intuitively this function
+        ///       checks (as the name suggests) whether our approximation is _locally_ "flat". More curvy parts
+        ///       need to have a denser approximation to be more "flat".
+        /// </summary>
+        /// <param name="controlPoints">The control points to check for flatness.</param>
+        /// <returns>Whether the control points are flat enough.</returns>
+        private static bool isFlatEnough(Vector2[] controlPoints)
+        {
+            for (int i = 1; i < controlPoints.Length - 1; i++)
+                if ((controlPoints[i - 1] - 2 * controlPoints[i] + controlPoints[i + 1]).LengthSquared > tolerance_sq * 4)
+                    return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Subdivides n control points representing a bezier curve into 2 sets of n control points, each
+        /// describing a bezier curve equivalent to a half of the original curve. Effectively this splits
+        /// the original curve into 2 curves which result in the original curve when pieced back together.
+        /// </summary>
+        /// <param name="controlPoints">The control points to split.</param>
+        /// <param name="l">Output: The control points corresponding to the left half of the curve.</param>
+        /// <param name="r">Output: The control points corresponding to the right half of the curve.</param>
+        private void subdivide(Vector2[] controlPoints, Vector2[] l, Vector2[] r)
+        {
+            Vector2[] midpoints = subdivisionBuffer1;
+
+            for (int i = 0; i < count; ++i)
+                midpoints[i] = controlPoints[i];
+
+            for (int i = 0; i < count; i++)
+            {
+                l[i] = midpoints[0];
+                r[count - i - 1] = midpoints[count - i - 1];
+
+                for (int j = 0; j < count - i - 1; j++)
+                    midpoints[j] = (midpoints[j] + midpoints[j + 1]) / 2;
+            }
+        }
+
+        /// <summary>
+        /// This uses <a href="https://en.wikipedia.org/wiki/De_Casteljau%27s_algorithm">De Casteljau's algorithm</a> to obtain an optimal
+        /// piecewise-linear approximation of the bezier curve with the same amount of points as there are control points.
+        /// </summary>
+        /// <param name="controlPoints">The control points describing the bezier curve to be approximated.</param>
+        /// <param name="output">The points representing the resulting piecewise-linear approximation.</param>
+        private void approximate(Vector2[] controlPoints, List<Vector2> output)
+        {
+            Vector2[] l = subdivisionBuffer2;
+            Vector2[] r = subdivisionBuffer1;
+
+            subdivide(controlPoints, l, r);
+
+            for (int i = 0; i < count - 1; ++i)
+                l[count + i] = r[i + 1];
+
+            output.Add(controlPoints[0]);
+            for (int i = 1; i < count - 1; ++i)
+            {
+                int index = 2 * i;
+                Vector2 p = 0.25f * (l[index - 1] + 2 * l[index] + l[index + 1]);
+                output.Add(p);
+            }
+        }
+
+        /// <summary>
+        /// Creates a piecewise-linear approximation of a bezier curve, by adaptively repeatedly subdividing
+        /// the control points until their approximation error vanishes below a given threshold.
+        /// </summary>
+        /// <returns>A list of vectors representing the piecewise-linear approximation.</returns>
+        public List<Vector2> CreateBezier()
+        {
+            List<Vector2> output = new List<Vector2>();
+
+            if (count == 0)
+                return output;
+
+            Stack<Vector2[]> toFlatten = new Stack<Vector2[]>();
+            Stack<Vector2[]> freeBuffers = new Stack<Vector2[]>();
+
+            // "toFlatten" contains all the curves which are not yet approximated well enough.
+            // We use a stack to emulate recursion without the risk of running into a stack overflow.
+            // (More specifically, we iteratively and adaptively refine our curve with a 
+            // <a href="https://en.wikipedia.org/wiki/Depth-first_search">Depth-first search</a>
+            // over the tree resulting from the subdivisions we make.)
+            toFlatten.Push(controlPoints.ToArray());
+
+            Vector2[] leftChild = subdivisionBuffer2;
+
+            while (toFlatten.Count > 0)
+            {
+                Vector2[] parent = toFlatten.Pop();
+                if (isFlatEnough(parent))
+                {
+                    // If the control points we currently operate on are sufficiently "flat", we use
+                    // an extension to De Casteljau's algorithm to obtain a piecewise-linear approximation
+                    // of the bezier curve represented by our control points, consisting of the same amount
+                    // of points as there are control points.
+                    approximate(parent, output);
+                    freeBuffers.Push(parent);
+                    continue;
+                }
+
+                // If we do not yet have a sufficiently "flat" (in other words, detailed) approximation we keep
+                // subdividing the curve we are currently operating on.
+                Vector2[] rightChild = freeBuffers.Count > 0 ? freeBuffers.Pop() : new Vector2[count];
+                subdivide(parent, leftChild, rightChild);
+
+                // We re-use the buffer of the parent for one of the children, so that we save one allocation per iteration.
+                for (int i = 0; i < count; ++i)
+                    parent[i] = leftChild[i];
+
+                toFlatten.Push(rightChild);
+                toFlatten.Push(parent);
+            }
+
+            output.Add(controlPoints[count - 1]);
+            return output;
+        }
+    }
+}

osu.Game/Modes/Objects/CircularArcApproximator.cs

@@ -0,0 +1,99 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System;
+using System.Collections.Generic;
+using osu.Framework.MathUtils;
+using OpenTK;
+
+namespace osu.Game.Modes.Objects
+{
+    public class CircularArcApproximator
+    {
+        private Vector2 a;
+        private Vector2 b;
+        private Vector2 c;
+
+        private int amountPoints;
+
+        private const float tolerance = 0.1f;
+
+        public CircularArcApproximator(Vector2 a, Vector2 b, Vector2 c)
+        {
+            this.a = a;
+            this.b = b;
+            this.c = c;
+        }
+
+        /// <summary>
+        /// Creates a piecewise-linear approximation of a circular arc curve.
+        /// </summary>
+        /// <returns>A list of vectors representing the piecewise-linear approximation.</returns>
+        public List<Vector2> CreateArc()
+        {
+            float aSq = (b - c).LengthSquared;
+            float bSq = (a - c).LengthSquared;
+            float cSq = (a - b).LengthSquared;
+
+            // If we have a degenerate triangle where a side-length is almost zero, then give up and fall
+            // back to a more numerically stable method.
+            if (Precision.AlmostEquals(aSq, 0) || Precision.AlmostEquals(bSq, 0) || Precision.AlmostEquals(cSq, 0))
+                return new List<Vector2>();
+
+            float s = aSq * (bSq + cSq - aSq);
+            float t = bSq * (aSq + cSq - bSq);
+            float u = cSq * (aSq + bSq - cSq);
+
+            float sum = s + t + u;
+
+            // If we have a degenerate triangle with an almost-zero size, then give up and fall
+            // back to a more numerically stable method.
+            if (Precision.AlmostEquals(sum, 0))
+                return new List<Vector2>();
+
+            Vector2 centre = (s * a + t * b + u * c) / sum;
+            Vector2 dA = a - centre;
+            Vector2 dC = c - centre;
+
+            float r = dA.Length;
+
+            double thetaStart = Math.Atan2(dA.Y, dA.X);
+            double thetaEnd = Math.Atan2(dC.Y, dC.X);
+
+            while (thetaEnd < thetaStart)
+                thetaEnd += 2 * Math.PI;
+
+            double dir = 1;
+            double thetaRange = thetaEnd - thetaStart;
+
+            // Decide in which direction to draw the circle, depending on which side of 
+            // AC B lies.
+            Vector2 orthoAtoC = c - a;
+            orthoAtoC = new Vector2(orthoAtoC.Y, -orthoAtoC.X);
+            if (Vector2.Dot(orthoAtoC, b - a) < 0)
+            {
+                dir = -dir;
+                thetaRange = 2 * Math.PI - thetaRange;
+            }
+
+            // We select the amount of points for the approximation by requiring the discrete curvature
+            // to be smaller than the provided tolerance. The exact angle required to meet the tolerance
+            // is: 2 * Math.Acos(1 - TOLERANCE / r)
+            // The special case is required for extremely short sliders where the radius is smaller than
+            // the tolerance. This is a pathological rather than a realistic case.
+            amountPoints = 2 * r <= tolerance ? 2 : Math.Max(2, (int)Math.Ceiling(thetaRange / (2 * Math.Acos(1 - tolerance / r))));
+
+            List<Vector2> output = new List<Vector2>(amountPoints);
+
+            for (int i = 0; i < amountPoints; ++i)
+            {
+                double fract = (double)i / (amountPoints - 1);
+                double theta = thetaStart + dir * fract * thetaRange;
+                Vector2 o = new Vector2((float)Math.Cos(theta), (float)Math.Sin(theta)) * r;
+                output.Add(centre + o);
+            }
+
+            return output;
+        }
+    }
+}

osu.Game/Modes/Objects/CurvedHitObject.cs

@@ -0,0 +1,46 @@
+using osu.Game.Modes.Objects.Types;
+using System.Collections.Generic;
+using OpenTK;
+
+namespace osu.Game.Modes.Objects
+{
+    public class CurvedHitObject : HitObject, IHasCurve
+    {
+        public SliderCurve Curve { get; } = new SliderCurve();
+
+        public int RepeatCount { get; set; } = 1;
+
+        public double EndTime => 0;
+        public double Duration => 0;
+
+        public List<Vector2> ControlPoints
+        {
+            get { return Curve.ControlPoints; }
+            set { Curve.ControlPoints = value; }
+        }
+
+        public CurveType CurveType
+        {
+            get { return Curve.CurveType; }
+            set { Curve.CurveType = value; }
+        }
+
+        public double Distance
+        {
+            get { return Curve.Distance; }
+            set { Curve.Distance = value; }
+        }
+
+        public Vector2 PositionAt(double progress) => Curve.PositionAt(ProgressAt(progress));
+
+        public double ProgressAt(double progress)
+        {
+            var p = progress * RepeatCount % 1;
+            if (RepeatAt(progress) % 2 == 1)
+                p = 1 - p;
+            return p;
+        }
+
+        public int RepeatAt(double progress) => (int)(progress * RepeatCount);
+    }
+}

osu.Game/Modes/Objects/Legacy/LegacySlider.cs

@@ -1,7 +1,6 @@
 // Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-using System.Collections.Generic;
 using osu.Game.Modes.Objects.Types;
 using OpenTK;
 
@@ -10,17 +9,10 @@ namespace osu.Game.Modes.Objects.Legacy
     /// <summary>
     /// Legacy Slider-type, used for parsing Beatmaps.
     /// </summary>
-    public sealed class LegacySlider : HitObject, IHasCurve, IHasPosition, IHasDistance, IHasRepeats, IHasCombo
+    public sealed class LegacySlider : CurvedHitObject, IHasPosition, IHasCombo
     {
-        public List<Vector2> ControlPoints { get; set; }
-        public CurveType CurveType { get; set; }
-
         public Vector2 Position { get; set; }
 
-        public double Distance { get; set; }
-
-        public int RepeatCount { get; set; }
-
         public bool NewCombo { get; set; }
     }
 }

osu.Game/Modes/Objects/SliderCurve.cs

@@ -0,0 +1,203 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System.Collections.Generic;
+using System.Linq;
+using osu.Framework.MathUtils;
+using osu.Game.Modes.Objects.Types;
+using OpenTK;
+
+namespace osu.Game.Modes.Objects
+{
+    public class SliderCurve
+    {
+        public double Distance;
+
+        public List<Vector2> ControlPoints;
+
+        public CurveType CurveType = CurveType.PerfectCurve;
+
+        public Vector2 Offset;
+
+        private List<Vector2> calculatedPath = new List<Vector2>();
+        private List<double> cumulativeLength = new List<double>();
+
+        private List<Vector2> calculateSubpath(List<Vector2> subControlPoints)
+        {
+            switch (CurveType)
+            {
+                case CurveType.Linear:
+                    return subControlPoints;
+                case CurveType.PerfectCurve:
+                    //we can only use CircularArc iff we have exactly three control points and no dissection.
+                    if (ControlPoints.Count != 3 || subControlPoints.Count != 3)
+                        break;
+
+                    // Here we have exactly 3 control points. Attempt to fit a circular arc.
+                    List<Vector2> subpath = new CircularArcApproximator(subControlPoints[0], subControlPoints[1], subControlPoints[2]).CreateArc();
+
+                    // If for some reason a circular arc could not be fit to the 3 given points, fall back to a numerically stable bezier approximation.
+                    if (subpath.Count == 0)
+                        break;
+
+                    return subpath;
+            }
+
+            return new BezierApproximator(subControlPoints).CreateBezier();
+        }
+
+        private void calculatePath()
+        {
+            calculatedPath.Clear();
+
+            // Sliders may consist of various subpaths separated by two consecutive vertices
+            // with the same position. The following loop parses these subpaths and computes
+            // their shape independently, consecutively appending them to calculatedPath.
+            List<Vector2> subControlPoints = new List<Vector2>();
+            for (int i = 0; i < ControlPoints.Count; ++i)
+            {
+                subControlPoints.Add(ControlPoints[i]);
+                if (i == ControlPoints.Count - 1 || ControlPoints[i] == ControlPoints[i + 1])
+                {
+                    List<Vector2> subpath = calculateSubpath(subControlPoints);
+                    foreach (Vector2 t in subpath)
+                        if (calculatedPath.Count == 0 || calculatedPath.Last() != t)
+                            calculatedPath.Add(t);
+
+                    subControlPoints.Clear();
+                }
+            }
+        }
+
+        private void calculateCumulativeLengthAndTrimPath()
+        {
+            double l = 0;
+
+            cumulativeLength.Clear();
+            cumulativeLength.Add(l);
+
+            for (int i = 0; i < calculatedPath.Count - 1; ++i)
+            {
+                Vector2 diff = calculatedPath[i + 1] - calculatedPath[i];
+                double d = diff.Length;
+
+                // Shorten slider curves that are too long compared to what's
+                // in the .osu file.
+                if (Distance - l < d)
+                {
+                    calculatedPath[i + 1] = calculatedPath[i] + diff * (float)((Distance - l) / d);
+                    calculatedPath.RemoveRange(i + 2, calculatedPath.Count - 2 - i);
+
+                    l = Distance;
+                    cumulativeLength.Add(l);
+                    break;
+                }
+
+                l += d;
+                cumulativeLength.Add(l);
+            }
+
+            //TODO: Figure out if the following code is needed in some cases. Judging by the map
+            //      "Transform" http://osu.ppy.sh/s/484689 it seems like we should _not_ be doing this.
+            // Lengthen slider curves that are too short compared to what's
+            // in the .osu file.
+            /*if (l < Length && calculatedPath.Count > 1)
+            {
+                Vector2 diff = calculatedPath[calculatedPath.Count - 1] - calculatedPath[calculatedPath.Count - 2];
+                double d = diff.Length;
+
+                if (d <= 0)
+                    return;
+
+                calculatedPath[calculatedPath.Count - 1] += diff * (float)((Length - l) / d);
+                cumulativeLength[calculatedPath.Count - 1] = Length;
+            }*/
+        }
+
+        public void Calculate()
+        {
+            calculatePath();
+            calculateCumulativeLengthAndTrimPath();
+        }
+
+        private int indexOfDistance(double d)
+        {
+            int i = cumulativeLength.BinarySearch(d);
+            if (i < 0) i = ~i;
+
+            return i;
+        }
+
+        private double progressToDistance(double progress)
+        {
+            return MathHelper.Clamp(progress, 0, 1) * Distance;
+        }
+
+        private Vector2 interpolateVertices(int i, double d)
+        {
+            if (calculatedPath.Count == 0)
+                return Vector2.Zero;
+
+            if (i <= 0)
+                return calculatedPath.First();
+            else if (i >= calculatedPath.Count)
+                return calculatedPath.Last();
+
+            Vector2 p0 = calculatedPath[i - 1];
+            Vector2 p1 = calculatedPath[i];
+
+            double d0 = cumulativeLength[i - 1];
+            double d1 = cumulativeLength[i];
+
+            // Avoid division by and almost-zero number in case two points are extremely close to each other.
+            if (Precision.AlmostEquals(d0, d1))
+                return p0;
+
+            double w = (d - d0) / (d1 - d0);
+            return p0 + (p1 - p0) * (float)w;
+        }
+
+        /// <summary>
+        /// Computes the slider curve until a given progress that ranges from 0 (beginning of the slider)
+        /// to 1 (end of the slider) and stores the generated path in the given list.
+        /// </summary>
+        /// <param name="path">The list to be filled with the computed curve.</param>
+        /// <param name="p0">Start progress. Ranges from 0 (beginning of the slider) to 1 (end of the slider).</param>
+        /// <param name="p1">End progress. Ranges from 0 (beginning of the slider) to 1 (end of the slider).</param>
+        public void GetPathToProgress(List<Vector2> path, double p0, double p1)
+        {
+            if (calculatedPath.Count == 0 && ControlPoints.Count > 0)
+                Calculate();
+
+            double d0 = progressToDistance(p0);
+            double d1 = progressToDistance(p1);
+
+            path.Clear();
+
+            int i = 0;
+            for (; i < calculatedPath.Count && cumulativeLength[i] < d0; ++i) { }
+
+            path.Add(interpolateVertices(i, d0) + Offset);
+
+            for (; i < calculatedPath.Count && cumulativeLength[i] <= d1; ++i)
+                path.Add(calculatedPath[i] + Offset);
+
+            path.Add(interpolateVertices(i, d1) + Offset);
+        }
+
+        /// <summary>
+        /// Computes the position on the slider at a given progress that ranges from 0 (beginning of the curve)
+        /// to 1 (end of the curve).
+        /// </summary>
+        /// <param name="progress">Ranges from 0 (beginning of the curve) to 1 (end of the curve).</param>
+        /// <returns></returns>
+        public Vector2 PositionAt(double progress)
+        {
+            if (calculatedPath.Count == 0 && ControlPoints.Count > 0)
+                Calculate();
+
+            double d = progressToDistance(progress);
+            return interpolateVertices(indexOfDistance(d), d) + Offset;
+        }
+    }
+}

osu.Game/Modes/Objects/Types/IHasCurve.cs

@@ -9,8 +9,13 @@ namespace osu.Game.Modes.Objects.Types
     /// <summary>
     /// A HitObject that has a curve.
     /// </summary>
-    public interface IHasCurve : IHasDistance
+    public interface IHasCurve : IHasDistance, IHasRepeats
     {
+        /// <summary>
+        /// The curve.
+        /// </summary>
+        SliderCurve Curve { get; }
+
         /// <summary>
         /// The control points that shape the curve.
         /// </summary>
@@ -20,5 +25,28 @@ namespace osu.Game.Modes.Objects.Types
         /// The type of curve.
         /// </summary>
         CurveType CurveType { get; }
+
+        /// <summary>
+        /// Computes the position on the curve at a given progress, accounting for repeat logic.
+        /// <para>
+        /// Ranges from [0, 1] where 0 is the beginning of the curve and 1 is the end of the curve.
+        /// </para>
+        /// </summary>
+        /// <param name="progress">[0, 1] where 0 is the beginning of the curve and 1 is the end of the curve.</param>
+        Vector2 PositionAt(double progress);
+
+        /// <summary>
+        /// Finds the progress along the curve, accounting for repeat logic.
+        /// </summary>
+        /// <param name="progress">[0, 1] where 0 is the beginning of the curve and 1 is the end of the curve.</param>
+        /// <returns>[0, 1] where 0 is the beginning of the curve and 1 is the end of the curve.</returns>
+        double ProgressAt(double progress);
+
+        /// <summary>
+        /// Determines which repeat of the curve the progress point is on.
+        /// </summary>
+        /// <param name="progress">[0, 1] where 0 is the beginning of the curve and 1 is the end of the curve.</param>
+        /// <returns>[0, RepeatCount] where 0 is the first run.</returns>
+        int RepeatAt(double progress);
     }
 }