1
0
mirror of https://github.com/ppy/osu.git synced 2024-12-16 06:23:20 +08:00
osu-lazer/osu.Game/Graphics/Containers/BeatSyncedContainer.cs

145 lines
5.0 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
using osu.Framework.Allocation;
using osu.Framework.Audio.Track;
2019-02-21 18:04:31 +08:00
using osu.Framework.Bindables;
2018-04-13 17:19:50 +08:00
using osu.Framework.Graphics.Containers;
using osu.Game.Beatmaps;
using osu.Game.Beatmaps.ControlPoints;
namespace osu.Game.Graphics.Containers
{
public class BeatSyncedContainer : Container
{
protected readonly IBindable<WorkingBeatmap> Beatmap = new Bindable<WorkingBeatmap>();
2018-04-13 17:19:50 +08:00
private int lastBeat;
private TimingControlPoint lastTimingPoint;
/// <summary>
/// The amount of time before a beat we should fire <see cref="OnNewBeat(int, TimingControlPoint, EffectControlPoint, TrackAmplitudes)"/>.
/// This allows for adding easing to animations that may be synchronised to the beat.
/// </summary>
protected double EarlyActivationMilliseconds;
/// <summary>
/// The time in milliseconds until the next beat.
/// </summary>
public double TimeUntilNextBeat { get; private set; }
/// <summary>
/// The time in milliseconds since the last beat
/// </summary>
public double TimeSinceLastBeat { get; private set; }
2019-12-16 18:16:54 +08:00
/// <summary>
2019-12-18 16:58:29 +08:00
/// How many beats per beatlength to trigger. Defaults to 1.
2019-12-16 18:16:54 +08:00
/// </summary>
public int Divisor { get; set; } = 1;
/// <summary>
/// An optional minimum beat length. Any beat length below this will be multiplied by two until valid.
/// </summary>
public double MinimumBeatLength { get; set; }
/// <summary>
/// Default length of a beat in milliseconds. Used whenever there is no beatmap or track playing.
/// </summary>
private const double default_beat_length = 60000.0 / 60.0;
2018-04-13 17:19:50 +08:00
private TimingControlPoint defaultTiming;
private EffectControlPoint defaultEffect;
private TrackAmplitudes defaultAmplitudes;
2018-04-13 17:19:50 +08:00
2019-12-16 17:51:22 +08:00
protected bool IsBeatSyncedWithTrack { get; private set; }
protected override void Update()
{
Track track = null;
IBeatmap beatmap = null;
double currentTrackTime = 0;
TimingControlPoint timingPoint = null;
EffectControlPoint effectPoint = null;
if (Beatmap.Value.TrackLoaded && Beatmap.Value.BeatmapLoaded)
{
track = Beatmap.Value.Track;
beatmap = Beatmap.Value.Beatmap;
}
if (track != null && beatmap != null && track.IsRunning && track.Length > 0)
{
currentTrackTime = track.CurrentTime + EarlyActivationMilliseconds;
timingPoint = beatmap.ControlPointInfo.TimingPointAt(currentTrackTime);
effectPoint = beatmap.ControlPointInfo.EffectPointAt(currentTrackTime);
}
IsBeatSyncedWithTrack = timingPoint?.BeatLength > 0;
2019-12-16 17:51:22 +08:00
if (timingPoint == null || !IsBeatSyncedWithTrack)
{
currentTrackTime = Clock.CurrentTime;
timingPoint = defaultTiming;
effectPoint = defaultEffect;
}
2018-04-13 17:19:50 +08:00
2019-12-16 18:16:54 +08:00
double beatLength = timingPoint.BeatLength / Divisor;
while (beatLength < MinimumBeatLength)
beatLength *= 2;
int beatIndex = (int)((currentTrackTime - timingPoint.Time) / beatLength) - (effectPoint.OmitFirstBarLine ? 1 : 0);
2018-04-13 17:19:50 +08:00
// The beats before the start of the first control point are off by 1, this should do the trick
if (currentTrackTime < timingPoint.Time)
beatIndex--;
2019-12-16 18:16:54 +08:00
TimeUntilNextBeat = (timingPoint.Time - currentTrackTime) % beatLength;
2018-04-13 17:19:50 +08:00
if (TimeUntilNextBeat < 0)
2019-12-16 18:16:54 +08:00
TimeUntilNextBeat += beatLength;
2018-04-13 17:19:50 +08:00
2019-12-16 18:16:54 +08:00
TimeSinceLastBeat = beatLength - TimeUntilNextBeat;
2018-04-13 17:19:50 +08:00
2020-04-17 16:04:09 +08:00
if (timingPoint == lastTimingPoint && beatIndex == lastBeat)
2018-04-13 17:19:50 +08:00
return;
using (BeginDelayedSequence(-TimeSinceLastBeat, true))
OnNewBeat(beatIndex, timingPoint, effectPoint, track?.CurrentAmplitudes ?? defaultAmplitudes);
2018-04-13 17:19:50 +08:00
lastBeat = beatIndex;
lastTimingPoint = timingPoint;
}
[BackgroundDependencyLoader]
2019-02-01 14:42:15 +08:00
private void load(IBindable<WorkingBeatmap> beatmap)
2018-04-13 17:19:50 +08:00
{
Beatmap.BindTo(beatmap);
2019-09-03 10:37:56 +08:00
defaultTiming = new TimingControlPoint
{
BeatLength = default_beat_length,
};
2019-09-03 10:37:56 +08:00
defaultEffect = new EffectControlPoint
{
KiaiMode = false,
OmitFirstBarLine = false
};
2019-09-03 10:37:56 +08:00
defaultAmplitudes = new TrackAmplitudes
{
FrequencyAmplitudes = new float[256],
LeftChannel = 0,
RightChannel = 0
};
2018-04-13 17:19:50 +08:00
}
protected virtual void OnNewBeat(int beatIndex, TimingControlPoint timingPoint, EffectControlPoint effectPoint, TrackAmplitudes amplitudes)
{
}
}
}