2016-12-06 17:56:20 +08:00
|
|
|
|
//Copyright (c) 2007-2016 ppy Pty Ltd <contact@ppy.sh>.
|
|
|
|
|
//Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
|
2016-12-03 20:56:35 +08:00
|
|
|
|
|
|
|
|
|
using System.Collections.Generic;
|
2016-11-29 20:29:53 +08:00
|
|
|
|
using OpenTK;
|
2016-12-03 17:41:03 +08:00
|
|
|
|
using System.Linq;
|
|
|
|
|
using osu.Framework.MathUtils;
|
2016-12-10 01:04:02 +08:00
|
|
|
|
using System.Diagnostics;
|
2016-11-29 20:29:53 +08:00
|
|
|
|
|
|
|
|
|
namespace osu.Game.Modes.Osu.Objects
|
|
|
|
|
{
|
|
|
|
|
public class SliderCurve
|
|
|
|
|
{
|
|
|
|
|
public double Length;
|
|
|
|
|
|
2016-12-10 01:04:02 +08:00
|
|
|
|
public List<Vector2> ControlPoints;
|
2016-11-29 20:29:53 +08:00
|
|
|
|
|
|
|
|
|
public CurveTypes CurveType;
|
|
|
|
|
|
2016-12-03 17:41:03 +08:00
|
|
|
|
private List<Vector2> calculatedPath = new List<Vector2>();
|
|
|
|
|
private List<double> cumulativeLength = new List<double>();
|
2016-11-29 20:29:53 +08:00
|
|
|
|
|
2016-12-10 01:04:02 +08:00
|
|
|
|
private List<Vector2> calculateSubpath(List<Vector2> subControlPoints)
|
2016-11-29 20:29:53 +08:00
|
|
|
|
{
|
|
|
|
|
switch (CurveType)
|
|
|
|
|
{
|
|
|
|
|
case CurveTypes.Linear:
|
2016-12-10 01:04:02 +08:00
|
|
|
|
return subControlPoints;
|
|
|
|
|
case CurveTypes.PerfectCurve:
|
|
|
|
|
// If we have a different amount than 3 control points, use bezier for perfect curves.
|
|
|
|
|
if (ControlPoints.Count != 3)
|
|
|
|
|
return new BezierApproximator(subControlPoints).CreateBezier();
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
Debug.Assert(subControlPoints.Count == 3);
|
|
|
|
|
|
|
|
|
|
// 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 (subpath.Count == 0)
|
|
|
|
|
// For some reason a circular arc could not be fit to the 3 given points. Fall back
|
|
|
|
|
// to a numerically stable bezier approximation.
|
|
|
|
|
subpath = new BezierApproximator(subControlPoints).CreateBezier();
|
|
|
|
|
|
|
|
|
|
return subpath;
|
|
|
|
|
}
|
2016-11-29 20:29:53 +08:00
|
|
|
|
default:
|
2016-12-10 01:04:02 +08:00
|
|
|
|
return new BezierApproximator(subControlPoints).CreateBezier();
|
2016-11-30 05:27:27 +08:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2016-12-03 22:19:23 +08:00
|
|
|
|
private void calculatePath()
|
2016-11-30 05:27:27 +08:00
|
|
|
|
{
|
2016-12-03 17:41:03 +08:00
|
|
|
|
calculatedPath.Clear();
|
2016-11-30 05:27:27 +08:00
|
|
|
|
|
|
|
|
|
// 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.
|
2016-12-10 01:04:02 +08:00
|
|
|
|
List<Vector2> subControlPoints = new List<Vector2>();
|
|
|
|
|
for (int i = 0; i < ControlPoints.Count; ++i)
|
2016-11-30 05:27:27 +08:00
|
|
|
|
{
|
2016-12-10 01:04:02 +08:00
|
|
|
|
subControlPoints.Add(ControlPoints[i]);
|
|
|
|
|
if (i == ControlPoints.Count - 1 || ControlPoints[i] == ControlPoints[i + 1])
|
2016-11-30 05:27:27 +08:00
|
|
|
|
{
|
2016-12-10 01:04:02 +08:00
|
|
|
|
List<Vector2> subpath = calculateSubpath(subControlPoints);
|
|
|
|
|
for (int j = 0; j < subpath.Count; ++j)
|
|
|
|
|
// Only add those vertices that add a new segment to the path.
|
|
|
|
|
if (calculatedPath.Count == 0 || calculatedPath.Last() != subpath[j])
|
|
|
|
|
calculatedPath.Add(subpath[j]);
|
2016-11-30 05:27:27 +08:00
|
|
|
|
|
2016-12-10 01:04:02 +08:00
|
|
|
|
subControlPoints.Clear();
|
2016-11-30 05:27:27 +08:00
|
|
|
|
}
|
2016-11-29 20:29:53 +08:00
|
|
|
|
}
|
2016-12-03 22:19:23 +08:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private void calculateCumulativeLengthAndTrimPath()
|
|
|
|
|
{
|
|
|
|
|
double l = 0;
|
|
|
|
|
|
2016-12-03 17:41:03 +08:00
|
|
|
|
cumulativeLength.Clear();
|
2016-12-03 22:19:23 +08:00
|
|
|
|
cumulativeLength.Add(l);
|
|
|
|
|
|
2016-12-03 17:41:03 +08:00
|
|
|
|
for (int i = 0; i < calculatedPath.Count - 1; ++i)
|
|
|
|
|
{
|
2016-12-03 22:19:23 +08:00
|
|
|
|
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 (Length - l < d)
|
|
|
|
|
{
|
|
|
|
|
calculatedPath[i + 1] = calculatedPath[i] + diff * (float)((Length - l) / d);
|
|
|
|
|
calculatedPath.RemoveRange(i + 2, calculatedPath.Count - 2 - i);
|
|
|
|
|
|
|
|
|
|
l = Length;
|
|
|
|
|
cumulativeLength.Add(l);
|
|
|
|
|
break;
|
|
|
|
|
}
|
2016-12-03 17:41:03 +08:00
|
|
|
|
|
2016-12-03 22:19:23 +08:00
|
|
|
|
l += d;
|
|
|
|
|
cumulativeLength.Add(l);
|
2016-12-03 17:41:03 +08:00
|
|
|
|
}
|
2016-12-03 22:19:23 +08:00
|
|
|
|
|
2016-12-17 15:44:58 +08:00
|
|
|
|
//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.
|
2016-12-03 22:19:23 +08:00
|
|
|
|
// Lengthen slider curves that are too short compared to what's
|
|
|
|
|
// in the .osu file.
|
2016-12-17 15:44:58 +08:00
|
|
|
|
/*if (l < Length && calculatedPath.Count > 1)
|
2016-12-03 22:19:23 +08:00
|
|
|
|
{
|
|
|
|
|
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;
|
2016-12-17 15:44:58 +08:00
|
|
|
|
}*/
|
2016-12-03 22:19:23 +08:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public void Calculate()
|
|
|
|
|
{
|
|
|
|
|
calculatePath();
|
|
|
|
|
calculateCumulativeLengthAndTrimPath();
|
2016-11-29 20:29:53 +08:00
|
|
|
|
}
|
|
|
|
|
|
2016-12-03 18:43:56 +08:00
|
|
|
|
private int indexOfDistance(double d)
|
2016-11-29 20:29:53 +08:00
|
|
|
|
{
|
2016-12-03 17:41:03 +08:00
|
|
|
|
int i = cumulativeLength.BinarySearch(d);
|
|
|
|
|
if (i < 0) i = ~i;
|
|
|
|
|
|
2016-12-03 18:43:56 +08:00
|
|
|
|
return i;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private double progressToDistance(double progress)
|
|
|
|
|
{
|
|
|
|
|
return MathHelper.Clamp(progress, 0, 1) * Length;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private Vector2 interpolateVertices(int i, double d)
|
|
|
|
|
{
|
|
|
|
|
if (calculatedPath.Count == 0)
|
|
|
|
|
return Vector2.Zero;
|
2016-12-03 17:41:03 +08:00
|
|
|
|
|
|
|
|
|
if (i <= 0)
|
|
|
|
|
return calculatedPath.First();
|
2016-12-03 18:43:56 +08:00
|
|
|
|
else if (i >= calculatedPath.Count)
|
|
|
|
|
return calculatedPath.Last();
|
2016-12-03 17:41:03 +08:00
|
|
|
|
|
|
|
|
|
Vector2 p0 = calculatedPath[i - 1];
|
|
|
|
|
Vector2 p1 = calculatedPath[i];
|
|
|
|
|
|
|
|
|
|
double d0 = cumulativeLength[i - 1];
|
|
|
|
|
double d1 = cumulativeLength[i];
|
2016-11-29 20:29:53 +08:00
|
|
|
|
|
2016-12-03 17:41:03 +08:00
|
|
|
|
// Avoid division by and almost-zero number in case two points are extremely close to each other.
|
|
|
|
|
if (Precision.AlmostEquals(d0, d1))
|
|
|
|
|
return p0;
|
2016-11-29 20:29:53 +08:00
|
|
|
|
|
2016-12-03 17:41:03 +08:00
|
|
|
|
double w = (d - d0) / (d1 - d0);
|
|
|
|
|
return p0 + (p1 - p0) * (float)w;
|
2016-11-29 20:29:53 +08:00
|
|
|
|
}
|
2016-12-03 18:43:56 +08:00
|
|
|
|
|
2016-12-03 20:25:31 +08:00
|
|
|
|
/// <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="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)
|
2016-12-03 18:43:56 +08:00
|
|
|
|
{
|
2016-12-03 20:25:31 +08:00
|
|
|
|
double d0 = progressToDistance(p0);
|
|
|
|
|
double d1 = progressToDistance(p1);
|
|
|
|
|
|
|
|
|
|
path.Clear();
|
2016-12-03 18:43:56 +08:00
|
|
|
|
|
|
|
|
|
int i = 0;
|
2016-12-03 20:25:31 +08:00
|
|
|
|
for (; i < calculatedPath.Count && cumulativeLength[i] < d0; ++i);
|
|
|
|
|
|
|
|
|
|
path.Add(interpolateVertices(i, d0));
|
|
|
|
|
|
|
|
|
|
for (; i < calculatedPath.Count && cumulativeLength[i] <= d1; ++i)
|
|
|
|
|
path.Add(calculatedPath[i]);
|
2016-12-03 18:43:56 +08:00
|
|
|
|
|
2016-12-03 20:25:31 +08:00
|
|
|
|
path.Add(interpolateVertices(i, d1));
|
2016-12-03 18:43:56 +08:00
|
|
|
|
}
|
|
|
|
|
|
2016-12-03 20:25:31 +08:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// Computes the position on the slider at a given progress that ranges from 0 (beginning of the slider)
|
|
|
|
|
/// to 1 (end of the slider).
|
|
|
|
|
/// </summary>
|
|
|
|
|
/// <param name="progress">Ranges from 0 (beginning of the slider) to 1 (end of the slider).</param>
|
|
|
|
|
/// <returns></returns>
|
2016-12-03 18:43:56 +08:00
|
|
|
|
public Vector2 PositionAt(double progress)
|
|
|
|
|
{
|
|
|
|
|
double d = progressToDistance(progress);
|
|
|
|
|
return interpolateVertices(indexOfDistance(d), d);
|
|
|
|
|
}
|
2016-11-29 20:29:53 +08:00
|
|
|
|
}
|
|
|
|
|
}
|