1
0
mirror of https://github.com/ppy/osu.git synced 2024-12-18 01:23:05 +08:00
osu-lazer/osu.Game/Beatmaps/ControlPoints/ControlPointInfo.cs

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

332 lines
13 KiB
C#
Raw Normal View History

// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
// See the LICENCE file in the repository root for full licence text.
2018-04-13 17:19:50 +08:00
2022-06-17 15:37:17 +08:00
#nullable disable
using System;
using System.Collections.Generic;
using System.Linq;
using JetBrains.Annotations;
using Newtonsoft.Json;
using osu.Framework.Bindables;
2017-12-21 18:40:41 +08:00
using osu.Framework.Lists;
using osu.Framework.Utils;
using osu.Game.Screens.Edit;
using osu.Game.Utils;
2018-04-13 17:19:50 +08:00
namespace osu.Game.Beatmaps.ControlPoints
{
[Serializable]
[System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembers(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)]
public class ControlPointInfo : IDeepCloneable<ControlPointInfo>
{
/// <summary>
/// Invoked on any change to the set of control points.
/// </summary>
[CanBeNull]
public event Action ControlPointsChanged;
private void raiseControlPointsChanged([CanBeNull] ControlPoint _ = null) => ControlPointsChanged?.Invoke();
2019-10-25 18:48:01 +08:00
/// <summary>
/// All control points grouped by time.
2019-10-25 18:48:01 +08:00
/// </summary>
[JsonProperty]
public IBindableList<ControlPointGroup> Groups => groups;
2019-10-25 18:48:01 +08:00
private readonly BindableList<ControlPointGroup> groups = new BindableList<ControlPointGroup>();
2019-10-25 18:48:01 +08:00
2017-05-23 14:29:38 +08:00
/// <summary>
/// All timing points.
/// </summary>
[JsonProperty]
2019-10-25 18:48:01 +08:00
public IReadOnlyList<TimingControlPoint> TimingPoints => timingPoints;
private readonly SortedList<TimingControlPoint> timingPoints = new SortedList<TimingControlPoint>(Comparer<TimingControlPoint>.Default);
2018-04-13 17:19:50 +08:00
2017-05-23 14:29:38 +08:00
/// <summary>
/// All effect points.
/// </summary>
2017-12-21 18:40:41 +08:00
[JsonProperty]
2019-10-25 18:48:01 +08:00
public IReadOnlyList<EffectControlPoint> EffectPoints => effectPoints;
private readonly SortedList<EffectControlPoint> effectPoints = new SortedList<EffectControlPoint>(Comparer<EffectControlPoint>.Default);
/// <summary>
/// All control points, of all types.
/// </summary>
2020-04-21 12:58:23 +08:00
[JsonIgnore]
2019-10-25 18:48:01 +08:00
public IEnumerable<ControlPoint> AllControlPoints => Groups.SelectMany(g => g.ControlPoints).ToArray();
2018-04-13 17:19:50 +08:00
/// <summary>
/// Finds the effect control point that is active at <paramref name="time"/>.
/// </summary>
/// <param name="time">The time to find the effect control point at.</param>
/// <returns>The effect control point.</returns>
[NotNull]
public EffectControlPoint EffectPointAt(double time) => BinarySearchWithFallback(EffectPoints, time, EffectControlPoint.DEFAULT);
2018-04-13 17:19:50 +08:00
/// <summary>
/// Finds the timing control point that is active at <paramref name="time"/>.
/// </summary>
/// <param name="time">The time to find the timing control point at.</param>
/// <returns>The timing control point.</returns>
[NotNull]
public TimingControlPoint TimingPointAt(double time) => BinarySearchWithFallback(TimingPoints, time, TimingPoints.Count > 0 ? TimingPoints[0] : TimingControlPoint.DEFAULT);
2018-04-13 17:19:50 +08:00
/// <summary>
/// Finds the maximum BPM represented by any timing control point.
/// </summary>
[JsonIgnore]
public double BPMMaximum =>
60000 / (TimingPoints.MinBy(c => c.BeatLength) ?? TimingControlPoint.DEFAULT).BeatLength;
2018-04-13 17:19:50 +08:00
/// <summary>
/// Finds the minimum BPM represented by any timing control point.
/// </summary>
[JsonIgnore]
public double BPMMinimum =>
60000 / (TimingPoints.MaxBy(c => c.BeatLength) ?? TimingControlPoint.DEFAULT).BeatLength;
2018-04-13 17:19:50 +08:00
/// <summary>
/// Remove all <see cref="ControlPointGroup"/>s and return to a pristine state.
/// </summary>
public virtual void Clear()
{
groups.Clear();
timingPoints.Clear();
effectPoints.Clear();
}
/// <summary>
/// Add a new <see cref="ControlPoint"/>. Note that the provided control point may not be added if the correct state is already present at the provided time.
/// </summary>
/// <param name="time">The time at which the control point should be added.</param>
/// <param name="controlPoint">The control point to add.</param>
/// <returns>Whether the control point was added.</returns>
public bool Add(double time, ControlPoint controlPoint)
{
if (CheckAlreadyExisting(time, controlPoint))
return false;
GroupAt(time, true).Add(controlPoint);
return true;
}
public ControlPointGroup GroupAt(double time, bool addIfNotExisting = false)
{
var newGroup = new ControlPointGroup(time);
int i = groups.BinarySearch(newGroup);
if (i >= 0)
return groups[i];
if (addIfNotExisting)
{
newGroup.ItemAdded += GroupItemAdded;
newGroup.ItemChanged += raiseControlPointsChanged;
newGroup.ItemRemoved += GroupItemRemoved;
groups.Insert(~i, newGroup);
return newGroup;
}
return null;
}
public void RemoveGroup(ControlPointGroup group)
{
foreach (var item in group.ControlPoints.ToArray())
group.Remove(item);
group.ItemAdded -= GroupItemAdded;
group.ItemChanged -= raiseControlPointsChanged;
group.ItemRemoved -= GroupItemRemoved;
groups.Remove(group);
}
/// <summary>
/// Returns the time on the given beat divisor closest to the given time.
/// </summary>
/// <param name="time">The time to find the closest snapped time to.</param>
/// <param name="beatDivisor">The beat divisor to snap to.</param>
/// <param name="referenceTime">An optional reference point to use for timing point lookup.</param>
public double GetClosestSnappedTime(double time, int beatDivisor, double? referenceTime = null)
{
var timingPoint = TimingPointAt(referenceTime ?? time);
return getClosestSnappedTime(timingPoint, time, beatDivisor);
}
/// <summary>
/// Returns the time on *ANY* valid beat divisor, favouring the divisor closest to the given time.
/// </summary>
/// <param name="time">The time to find the closest snapped time to.</param>
public double GetClosestSnappedTime(double time) => GetClosestSnappedTime(time, GetClosestBeatDivisor(time));
/// <summary>
/// Returns the beat snap divisor closest to the given time. If two are equally close, the smallest divisor is returned.
/// </summary>
/// <param name="time">The time to find the closest beat snap divisor to.</param>
/// <param name="referenceTime">An optional reference point to use for timing point lookup.</param>
public int GetClosestBeatDivisor(double time, double? referenceTime = null)
{
TimingControlPoint timingPoint = TimingPointAt(referenceTime ?? time);
int closestDivisor = 0;
double closestTime = double.MaxValue;
foreach (int divisor in BindableBeatDivisor.PREDEFINED_DIVISORS)
{
double distanceFromSnap = Math.Abs(time - getClosestSnappedTime(timingPoint, time, divisor));
if (Precision.DefinitelyBigger(closestTime, distanceFromSnap))
{
closestDivisor = divisor;
closestTime = distanceFromSnap;
}
}
return closestDivisor;
}
private static double getClosestSnappedTime(TimingControlPoint timingPoint, double time, int beatDivisor)
{
double beatLength = timingPoint.BeatLength / beatDivisor;
2023-01-12 08:38:57 +08:00
double beats = (Math.Max(time, 0) - timingPoint.Time) / beatLength;
2023-01-12 08:38:57 +08:00
int roundedBeats = (int)Math.Round(beats, MidpointRounding.AwayFromZero);
double snappedTime = timingPoint.Time + roundedBeats * beatLength;
if (snappedTime >= 0)
return snappedTime;
return snappedTime + beatLength;
}
/// <summary>
2017-05-24 01:22:28 +08:00
/// Binary searches one of the control point lists to find the active control point at <paramref name="time"/>.
/// Includes logic for returning a specific point when no matching point is found.
/// </summary>
/// <param name="list">The list to search.</param>
/// <param name="time">The time to find the control point at.</param>
/// <param name="fallback">The control point to use when <paramref name="time"/> is before any control points.</param>
/// <returns>The active control point at <paramref name="time"/>, or a fallback <see cref="ControlPoint"/> if none found.</returns>
public static T BinarySearchWithFallback<T>(IReadOnlyList<T> list, double time, T fallback)
where T : class, IControlPoint
{
return BinarySearch(list, time) ?? fallback;
}
/// <summary>
/// Binary searches one of the control point lists to find the active control point at <paramref name="time"/>.
/// </summary>
/// <param name="list">The list to search.</param>
/// <param name="time">The time to find the control point at.</param>
/// <returns>The active control point at <paramref name="time"/>. Will return <c>null</c> if there are no control points, or if the time is before the first control point.</returns>
public static T BinarySearch<T>(IReadOnlyList<T> list, double time)
where T : class, IControlPoint
{
ArgumentNullException.ThrowIfNull(list);
2018-04-13 17:19:50 +08:00
if (list.Count == 0)
return null;
2018-04-13 17:19:50 +08:00
if (time < list[0].Time)
return null;
2018-04-13 17:19:50 +08:00
2019-12-14 20:54:22 +08:00
if (time >= list[^1].Time)
return list[^1];
2018-10-17 10:39:29 +08:00
int l = 0;
2018-10-17 10:39:29 +08:00
int r = list.Count - 2;
2018-04-13 17:19:50 +08:00
while (l <= r)
{
int pivot = l + ((r - l) >> 1);
2018-04-13 17:19:50 +08:00
if (list[pivot].Time < time)
l = pivot + 1;
else if (list[pivot].Time > time)
r = pivot - 1;
else
return list[pivot];
}
2018-04-13 17:19:50 +08:00
// l will be the first control point with Time > time, but we want the one before it
return list[l - 1];
}
2019-10-25 18:48:01 +08:00
/// <summary>
2019-11-17 20:49:36 +08:00
/// Check whether <paramref name="newPoint"/> should be added.
/// </summary>
/// <param name="time">The time to find the timing control point at.</param>
/// <param name="newPoint">A point to be added.</param>
/// <returns>Whether the new point should be added.</returns>
protected virtual bool CheckAlreadyExisting(double time, ControlPoint newPoint)
{
ControlPoint existing = null;
switch (newPoint)
{
2022-06-24 20:25:23 +08:00
case TimingControlPoint:
// Timing points are a special case and need to be added regardless of fallback availability.
existing = BinarySearch(TimingPoints, time);
break;
2022-06-24 20:25:23 +08:00
case EffectControlPoint:
existing = EffectPointAt(time);
break;
}
2020-04-17 16:10:13 +08:00
return newPoint?.IsRedundant(existing) == true;
}
protected virtual void GroupItemAdded(ControlPoint controlPoint)
2019-10-25 18:48:01 +08:00
{
switch (controlPoint)
2019-10-25 18:48:01 +08:00
{
case TimingControlPoint typed:
timingPoints.Add(typed);
2019-10-25 18:48:01 +08:00
break;
case EffectControlPoint typed:
effectPoints.Add(typed);
2019-10-25 18:48:01 +08:00
break;
default:
throw new ArgumentException($"A control point of unexpected type {controlPoint.GetType()} was added to this {nameof(ControlPointInfo)}");
2019-10-25 18:48:01 +08:00
}
raiseControlPointsChanged();
2019-10-25 18:48:01 +08:00
}
protected virtual void GroupItemRemoved(ControlPoint controlPoint)
2019-10-25 18:48:01 +08:00
{
switch (controlPoint)
2019-10-25 18:48:01 +08:00
{
case TimingControlPoint typed:
timingPoints.Remove(typed);
2019-10-25 18:48:01 +08:00
break;
case EffectControlPoint typed:
effectPoints.Remove(typed);
2019-10-25 18:48:01 +08:00
break;
}
raiseControlPointsChanged();
2019-10-25 18:48:01 +08:00
}
public ControlPointInfo DeepClone()
{
2022-12-16 19:18:02 +08:00
var controlPointInfo = (ControlPointInfo)Activator.CreateInstance(GetType())!;
foreach (var point in AllControlPoints)
controlPointInfo.Add(point.Time, point.DeepClone());
return controlPointInfo;
}
}
}