mirror of
https://github.com/ppy/osu
synced 2024-12-15 03:16:17 +00:00
415 lines
15 KiB
C#
415 lines
15 KiB
C#
// 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.
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using JetBrains.Annotations;
|
|
using osu.Framework.Allocation;
|
|
using osu.Framework.Audio;
|
|
using osu.Framework.Audio.Track;
|
|
using osu.Framework.Bindables;
|
|
using osu.Framework.Graphics;
|
|
using osu.Framework.Graphics.Audio;
|
|
using osu.Framework.Graphics.Containers;
|
|
using osu.Framework.Threading;
|
|
using osu.Game.Beatmaps;
|
|
using osu.Game.Database;
|
|
using osu.Game.Rulesets.Mods;
|
|
|
|
namespace osu.Game.Overlays
|
|
{
|
|
/// <summary>
|
|
/// Handles playback of the global music track.
|
|
/// </summary>
|
|
public class MusicController : CompositeDrawable
|
|
{
|
|
[Resolved]
|
|
private BeatmapManager beatmaps { get; set; }
|
|
|
|
/// <summary>
|
|
/// Point in time after which the current track will be restarted on triggering a "previous track" action.
|
|
/// </summary>
|
|
private const double restart_cutoff_point = 5000;
|
|
|
|
/// <summary>
|
|
/// Whether the user has requested the track to be paused. Use <see cref="IsPlaying"/> to determine whether the track is still playing.
|
|
/// </summary>
|
|
public bool UserPauseRequested { get; private set; }
|
|
|
|
/// <summary>
|
|
/// Fired when the global <see cref="WorkingBeatmap"/> has changed.
|
|
/// Includes direction information for display purposes.
|
|
/// </summary>
|
|
public event Action<WorkingBeatmap, TrackChangeDirection> TrackChanged;
|
|
|
|
[Resolved]
|
|
private IBindable<WorkingBeatmap> beatmap { get; set; }
|
|
|
|
[Resolved]
|
|
private IBindable<IReadOnlyList<Mod>> mods { get; set; }
|
|
|
|
[NotNull]
|
|
public DrawableTrack CurrentTrack { get; private set; } = new DrawableTrack(new TrackVirtual(1000));
|
|
|
|
[Resolved]
|
|
private RealmAccess realm { get; set; }
|
|
|
|
[BackgroundDependencyLoader]
|
|
private void load()
|
|
{
|
|
// Todo: These binds really shouldn't be here, but are unlikely to cause any issues for now.
|
|
// They are placed here for now since some tests rely on setting the beatmap _and_ their hierarchies inside their load(), which runs before the MusicController's load().
|
|
beatmap.BindValueChanged(beatmapChanged, true);
|
|
mods.BindValueChanged(_ => ResetTrackAdjustments(), true);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Forcefully reload the current <see cref="WorkingBeatmap"/>'s track from disk.
|
|
/// </summary>
|
|
public void ReloadCurrentTrack() => changeTrack();
|
|
|
|
/// <summary>
|
|
/// Returns whether the beatmap track is playing.
|
|
/// </summary>
|
|
public bool IsPlaying => CurrentTrack.IsRunning;
|
|
|
|
/// <summary>
|
|
/// Returns whether the beatmap track is loaded.
|
|
/// </summary>
|
|
public bool TrackLoaded => CurrentTrack.TrackLoaded;
|
|
|
|
private ScheduledDelegate seekDelegate;
|
|
|
|
public void SeekTo(double position)
|
|
{
|
|
seekDelegate?.Cancel();
|
|
seekDelegate = Schedule(() =>
|
|
{
|
|
if (!beatmap.Disabled)
|
|
CurrentTrack.Seek(position);
|
|
});
|
|
}
|
|
|
|
/// <summary>
|
|
/// Ensures music is playing, no matter what, unless the user has explicitly paused.
|
|
/// This means that if the current beatmap has a virtual track (see <see cref="TrackVirtual"/>) a new beatmap will be selected.
|
|
/// </summary>
|
|
public void EnsurePlayingSomething()
|
|
{
|
|
if (UserPauseRequested) return;
|
|
|
|
if (CurrentTrack.IsDummyDevice || beatmap.Value.BeatmapSetInfo.DeletePending)
|
|
{
|
|
if (beatmap.Disabled)
|
|
return;
|
|
|
|
NextTrack();
|
|
}
|
|
else if (!IsPlaying)
|
|
{
|
|
Play();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Start playing the current track (if not already playing).
|
|
/// </summary>
|
|
/// <param name="restart">Whether to restart the track from the beginning.</param>
|
|
/// <param name="requestedByUser">
|
|
/// Whether the request to play was issued by the user rather than internally.
|
|
/// Specifying <c>true</c> will ensure that other methods like <see cref="EnsurePlayingSomething"/>
|
|
/// will resume music playback going forward.
|
|
/// </param>
|
|
/// <returns>Whether the operation was successful.</returns>
|
|
public bool Play(bool restart = false, bool requestedByUser = false)
|
|
{
|
|
if (requestedByUser)
|
|
UserPauseRequested = false;
|
|
|
|
if (restart)
|
|
CurrentTrack.Restart();
|
|
else if (!IsPlaying)
|
|
CurrentTrack.Start();
|
|
|
|
return true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Stop playing the current track and pause at the current position.
|
|
/// </summary>
|
|
/// <param name="requestedByUser">
|
|
/// Whether the request to stop was issued by the user rather than internally.
|
|
/// Specifying <c>true</c> will ensure that other methods like <see cref="EnsurePlayingSomething"/>
|
|
/// will not resume music playback until the next explicit call to <see cref="Play"/>.
|
|
/// </param>
|
|
public void Stop(bool requestedByUser = false)
|
|
{
|
|
UserPauseRequested |= requestedByUser;
|
|
if (CurrentTrack.IsRunning)
|
|
CurrentTrack.Stop();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Toggle pause / play.
|
|
/// </summary>
|
|
/// <returns>Whether the operation was successful.</returns>
|
|
public bool TogglePause()
|
|
{
|
|
if (CurrentTrack.IsRunning)
|
|
Stop(true);
|
|
else
|
|
Play(requestedByUser: true);
|
|
|
|
return true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Play the previous track or restart the current track if it's current time below <see cref="restart_cutoff_point"/>.
|
|
/// </summary>
|
|
/// <param name="onSuccess">Invoked when the operation has been performed successfully.</param>
|
|
public void PreviousTrack(Action<PreviousTrackResult> onSuccess = null) => Schedule(() =>
|
|
{
|
|
PreviousTrackResult res = prev();
|
|
if (res != PreviousTrackResult.None)
|
|
onSuccess?.Invoke(res);
|
|
});
|
|
|
|
/// <summary>
|
|
/// Play the previous track or restart the current track if it's current time below <see cref="restart_cutoff_point"/>.
|
|
/// </summary>
|
|
/// <returns>The <see cref="PreviousTrackResult"/> that indicate the decided action.</returns>
|
|
private PreviousTrackResult prev()
|
|
{
|
|
if (beatmap.Disabled)
|
|
return PreviousTrackResult.None;
|
|
|
|
double currentTrackPosition = CurrentTrack.CurrentTime;
|
|
|
|
if (currentTrackPosition >= restart_cutoff_point)
|
|
{
|
|
SeekTo(0);
|
|
return PreviousTrackResult.Restart;
|
|
}
|
|
|
|
queuedDirection = TrackChangeDirection.Prev;
|
|
|
|
var playableSet = getBeatmapSets().AsEnumerable().TakeWhile(i => !i.Equals(current.BeatmapSetInfo)).LastOrDefault()
|
|
?? getBeatmapSets().LastOrDefault();
|
|
|
|
if (playableSet != null)
|
|
{
|
|
changeBeatmap(beatmaps.GetWorkingBeatmap(playableSet.Beatmaps.First()));
|
|
restartTrack();
|
|
return PreviousTrackResult.Previous;
|
|
}
|
|
|
|
return PreviousTrackResult.None;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Play the next random or playlist track.
|
|
/// </summary>
|
|
/// <param name="onSuccess">Invoked when the operation has been performed successfully.</param>
|
|
/// <returns>A <see cref="ScheduledDelegate"/> of the operation.</returns>
|
|
public void NextTrack(Action onSuccess = null) => Schedule(() =>
|
|
{
|
|
bool res = next();
|
|
if (res)
|
|
onSuccess?.Invoke();
|
|
});
|
|
|
|
private bool next()
|
|
{
|
|
if (beatmap.Disabled)
|
|
return false;
|
|
|
|
queuedDirection = TrackChangeDirection.Next;
|
|
|
|
var playableSet = getBeatmapSets().AsEnumerable().SkipWhile(i => !i.Equals(current.BeatmapSetInfo)).ElementAtOrDefault(1)
|
|
?? getBeatmapSets().FirstOrDefault();
|
|
|
|
var playableBeatmap = playableSet?.Beatmaps.FirstOrDefault();
|
|
|
|
if (playableBeatmap != null)
|
|
{
|
|
changeBeatmap(beatmaps.GetWorkingBeatmap(playableBeatmap));
|
|
restartTrack();
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
private void restartTrack()
|
|
{
|
|
// if not scheduled, the previously track will be stopped one frame later (see ScheduleAfterChildren logic in GameBase).
|
|
// we probably want to move this to a central method for switching to a new working beatmap in the future.
|
|
Schedule(() => CurrentTrack.Restart());
|
|
}
|
|
|
|
private WorkingBeatmap current;
|
|
|
|
private TrackChangeDirection? queuedDirection;
|
|
|
|
private IQueryable<BeatmapSetInfo> getBeatmapSets() => realm.Realm.All<BeatmapSetInfo>().Where(s => !s.DeletePending);
|
|
|
|
private void beatmapChanged(ValueChangedEvent<WorkingBeatmap> beatmap) => changeBeatmap(beatmap.NewValue);
|
|
|
|
private void changeBeatmap(WorkingBeatmap newWorking)
|
|
{
|
|
// This method can potentially be triggered multiple times as it is eagerly fired in next() / prev() to ensure correct execution order
|
|
// (changeBeatmap must be called before consumers receive the bindable changed event, which is not the case when the local beatmap bindable is updated directly).
|
|
if (newWorking == current)
|
|
return;
|
|
|
|
var lastWorking = current;
|
|
|
|
TrackChangeDirection direction = TrackChangeDirection.None;
|
|
|
|
bool audioEquals = newWorking?.BeatmapInfo?.AudioEquals(current?.BeatmapInfo) ?? false;
|
|
|
|
if (current != null)
|
|
{
|
|
if (audioEquals)
|
|
direction = TrackChangeDirection.None;
|
|
else if (queuedDirection.HasValue)
|
|
{
|
|
direction = queuedDirection.Value;
|
|
queuedDirection = null;
|
|
}
|
|
else
|
|
{
|
|
// figure out the best direction based on order in playlist.
|
|
int last = getBeatmapSets().AsEnumerable().TakeWhile(b => !b.Equals(current.BeatmapSetInfo)).Count();
|
|
int next = newWorking == null ? -1 : getBeatmapSets().AsEnumerable().TakeWhile(b => !b.Equals(newWorking.BeatmapSetInfo)).Count();
|
|
|
|
direction = last > next ? TrackChangeDirection.Prev : TrackChangeDirection.Next;
|
|
}
|
|
}
|
|
|
|
current = newWorking;
|
|
|
|
if (!audioEquals || CurrentTrack.IsDummyDevice)
|
|
{
|
|
changeTrack();
|
|
}
|
|
else
|
|
{
|
|
// transfer still valid track to new working beatmap
|
|
current.TransferTrack(lastWorking.Track);
|
|
}
|
|
|
|
TrackChanged?.Invoke(current, direction);
|
|
|
|
ResetTrackAdjustments();
|
|
|
|
queuedDirection = null;
|
|
|
|
// this will be a noop if coming from the beatmapChanged event.
|
|
// the exception is local operations like next/prev, where we want to complete loading the track before sending out a change.
|
|
if (beatmap.Value != current && beatmap is Bindable<WorkingBeatmap> working)
|
|
working.Value = current;
|
|
}
|
|
|
|
private void changeTrack()
|
|
{
|
|
var queuedTrack = getQueuedTrack();
|
|
|
|
var lastTrack = CurrentTrack;
|
|
CurrentTrack = queuedTrack;
|
|
|
|
// At this point we may potentially be in an async context from tests. This is extremely dangerous but we have to make do for now.
|
|
// CurrentTrack is immediately updated above for situations where a immediate knowledge about the new track is required,
|
|
// but the mutation of the hierarchy is scheduled to avoid exceptions.
|
|
Schedule(() =>
|
|
{
|
|
lastTrack.VolumeTo(0, 500, Easing.Out).Expire();
|
|
|
|
if (queuedTrack == CurrentTrack)
|
|
{
|
|
AddInternal(queuedTrack);
|
|
queuedTrack.VolumeTo(0).Then().VolumeTo(1, 300, Easing.Out);
|
|
}
|
|
else
|
|
{
|
|
// If the track has changed since the call to changeTrack, it is safe to dispose the
|
|
// queued track rather than consume it.
|
|
queuedTrack.Dispose();
|
|
}
|
|
});
|
|
}
|
|
|
|
private DrawableTrack getQueuedTrack()
|
|
{
|
|
// Important to keep this in its own method to avoid inadvertently capturing unnecessary variables in the callback.
|
|
// Can lead to leaks.
|
|
var queuedTrack = new DrawableTrack(current.LoadTrack());
|
|
queuedTrack.Completed += () => onTrackCompleted(current);
|
|
return queuedTrack;
|
|
}
|
|
|
|
private void onTrackCompleted(WorkingBeatmap workingBeatmap)
|
|
{
|
|
// the source of track completion is the audio thread, so the beatmap may have changed before firing.
|
|
if (current != workingBeatmap)
|
|
return;
|
|
|
|
if (!CurrentTrack.Looping && !beatmap.Disabled)
|
|
NextTrack();
|
|
}
|
|
|
|
private bool allowTrackAdjustments;
|
|
|
|
/// <summary>
|
|
/// Whether mod track adjustments are allowed to be applied.
|
|
/// </summary>
|
|
public bool AllowTrackAdjustments
|
|
{
|
|
get => allowTrackAdjustments;
|
|
set
|
|
{
|
|
if (allowTrackAdjustments == value)
|
|
return;
|
|
|
|
allowTrackAdjustments = value;
|
|
ResetTrackAdjustments();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Resets the adjustments currently applied on <see cref="CurrentTrack"/> and applies the mod adjustments if <see cref="AllowTrackAdjustments"/> is <c>true</c>.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Does not reset any adjustments applied directly to the beatmap track.
|
|
/// </remarks>
|
|
public void ResetTrackAdjustments()
|
|
{
|
|
CurrentTrack.RemoveAllAdjustments(AdjustableProperty.Balance);
|
|
CurrentTrack.RemoveAllAdjustments(AdjustableProperty.Frequency);
|
|
CurrentTrack.RemoveAllAdjustments(AdjustableProperty.Tempo);
|
|
CurrentTrack.RemoveAllAdjustments(AdjustableProperty.Volume);
|
|
|
|
if (allowTrackAdjustments)
|
|
{
|
|
foreach (var mod in mods.Value.OfType<IApplicableToTrack>())
|
|
mod.ApplyToTrack(CurrentTrack);
|
|
}
|
|
}
|
|
}
|
|
|
|
public enum TrackChangeDirection
|
|
{
|
|
None,
|
|
Next,
|
|
Prev
|
|
}
|
|
|
|
public enum PreviousTrackResult
|
|
{
|
|
None,
|
|
Restart,
|
|
Previous
|
|
}
|
|
}
|