osu/osu.Game/Beatmaps/WorkingBeatmap.cs

316 lines
11 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 09:19:50 +00:00
using osu.Framework.Audio.Track;
using osu.Framework.Graphics.Textures;
using osu.Game.Rulesets.Mods;
using System;
using System.Collections.Generic;
using osu.Game.Storyboards;
using System.IO;
2019-02-21 10:04:31 +00:00
using System.Linq;
2018-09-06 03:51:23 +00:00
using System.Threading;
using System.Threading.Tasks;
using osu.Framework.Audio;
using osu.Framework.Statistics;
2018-04-13 09:19:50 +00:00
using osu.Game.IO.Serialization;
using osu.Game.Rulesets;
2019-05-29 07:43:27 +00:00
using osu.Game.Rulesets.Objects.Types;
using osu.Game.Rulesets.UI;
2018-04-13 09:19:50 +00:00
using osu.Game.Skinning;
2019-08-30 20:19:34 +00:00
using osu.Framework.Graphics.Video;
2018-04-13 09:19:50 +00:00
namespace osu.Game.Beatmaps
{
2019-08-29 10:38:44 +00:00
public abstract class WorkingBeatmap : IWorkingBeatmap, IDisposable
2018-04-13 09:19:50 +00:00
{
public readonly BeatmapInfo BeatmapInfo;
public readonly BeatmapSetInfo BeatmapSetInfo;
public readonly BeatmapMetadata Metadata;
protected AudioManager AudioManager { get; }
private static readonly GlobalStatistic<int> total_count = GlobalStatistics.Get<int>(nameof(Beatmaps), $"Total {nameof(WorkingBeatmap)}s");
protected WorkingBeatmap(BeatmapInfo beatmapInfo, AudioManager audioManager)
2018-04-13 09:19:50 +00:00
{
AudioManager = audioManager;
2018-04-13 09:19:50 +00:00
BeatmapInfo = beatmapInfo;
BeatmapSetInfo = beatmapInfo.BeatmapSet;
Metadata = beatmapInfo.Metadata ?? BeatmapSetInfo?.Metadata ?? new BeatmapMetadata();
2019-06-04 02:25:18 +00:00
track = new RecyclableLazy<Track>(() => GetTrack() ?? GetVirtualTrack());
2018-09-06 03:51:23 +00:00
background = new RecyclableLazy<Texture>(GetBackground, BackgroundStillValid);
waveform = new RecyclableLazy<Waveform>(GetWaveform);
storyboard = new RecyclableLazy<Storyboard>(GetStoryboard);
skin = new RecyclableLazy<ISkin>(GetSkin);
total_count.Value++;
2018-04-13 09:19:50 +00:00
}
2019-06-04 02:25:18 +00:00
protected virtual Track GetVirtualTrack()
2019-05-29 07:43:27 +00:00
{
const double excess_length = 1000;
2019-06-04 02:25:18 +00:00
var lastObject = Beatmap.HitObjects.LastOrDefault();
2019-05-29 07:43:27 +00:00
double length;
switch (lastObject)
{
case null:
length = excess_length;
break;
case IHasEndTime endTime:
length = endTime.EndTime + excess_length;
break;
default:
length = lastObject.StartTime + excess_length;
break;
}
return AudioManager.Tracks.GetVirtual(length);
}
2018-04-13 09:19:50 +00:00
/// <summary>
2018-05-07 01:29:38 +00:00
/// Saves the <see cref="Beatmaps.Beatmap"/>.
2018-04-13 09:19:50 +00:00
/// </summary>
2018-06-19 11:19:52 +00:00
/// <returns>The absolute path of the output file.</returns>
public string Save()
2018-04-13 09:19:50 +00:00
{
2019-11-19 12:34:35 +00:00
string directory = Path.Combine(Path.GetTempPath(), @"osu!");
Directory.CreateDirectory(directory);
var path = Path.Combine(directory, Guid.NewGuid().ToString().Replace("-", string.Empty) + ".json");
2018-04-13 09:19:50 +00:00
using (var sw = new StreamWriter(path))
2018-05-07 01:29:38 +00:00
sw.WriteLine(Beatmap.Serialize());
2018-06-19 11:19:52 +00:00
return path;
2018-04-13 09:19:50 +00:00
}
/// <summary>
/// Creates a <see cref="IBeatmapConverter"/> to convert a <see cref="IBeatmap"/> for a specified <see cref="Ruleset"/>.
/// </summary>
/// <param name="beatmap">The <see cref="IBeatmap"/> to be converted.</param>
/// <param name="ruleset">The <see cref="Ruleset"/> for which <paramref name="beatmap"/> should be converted.</param>
/// <returns>The applicable <see cref="IBeatmapConverter"/>.</returns>
protected virtual IBeatmapConverter CreateBeatmapConverter(IBeatmap beatmap, Ruleset ruleset) => ruleset.CreateBeatmapConverter(beatmap);
public IBeatmap GetPlayableBeatmap(RulesetInfo ruleset, IReadOnlyList<Mod> mods = null)
{
mods ??= Array.Empty<Mod>();
var rulesetInstance = ruleset.CreateInstance();
IBeatmapConverter converter = CreateBeatmapConverter(Beatmap, rulesetInstance);
// Check if the beatmap can be converted
if (!converter.CanConvert)
2018-05-07 05:28:30 +00:00
throw new BeatmapInvalidForRulesetException($"{nameof(Beatmaps.Beatmap)} can not be converted for the ruleset (ruleset: {ruleset.InstantiationInfo}, converter: {converter}).");
// Apply conversion mods
2019-04-08 09:32:05 +00:00
foreach (var mod in mods.OfType<IApplicableToBeatmapConverter>())
mod.ApplyToBeatmapConverter(converter);
// Convert
IBeatmap converted = converter.Convert();
// Apply difficulty mods
2019-04-08 09:32:05 +00:00
if (mods.Any(m => m is IApplicableToDifficulty))
{
converted.BeatmapInfo = converted.BeatmapInfo.Clone();
converted.BeatmapInfo.BaseDifficulty = converted.BeatmapInfo.BaseDifficulty.Clone();
2019-04-08 09:32:05 +00:00
foreach (var mod in mods.OfType<IApplicableToDifficulty>())
mod.ApplyToDifficulty(converted.BeatmapInfo.BaseDifficulty);
}
IBeatmapProcessor processor = rulesetInstance.CreateBeatmapProcessor(converted);
processor?.PreProcess();
// Compute default values for hitobjects, including creating nested hitobjects in-case they're needed
foreach (var obj in converted.HitObjects)
obj.ApplyDefaults(converted.ControlPointInfo, converted.BeatmapInfo.BaseDifficulty);
2019-04-08 09:32:05 +00:00
foreach (var mod in mods.OfType<IApplicableToHitObject>())
2019-11-11 11:53:22 +00:00
{
foreach (var obj in converted.HitObjects)
mod.ApplyToHitObject(obj);
}
processor?.PostProcess();
foreach (var mod in mods.OfType<IApplicableToBeatmap>())
2019-08-01 04:37:40 +00:00
mod.ApplyToBeatmap(converted);
return converted;
}
2018-07-19 09:43:11 +00:00
public override string ToString() => BeatmapInfo.ToString();
public bool BeatmapLoaded => beatmapLoadTask?.IsCompleted ?? false;
2019-11-12 10:35:08 +00:00
public Task<IBeatmap> LoadBeatmapAsync() => beatmapLoadTask ??= Task.Factory.StartNew(() =>
{
// Todo: Handle cancellation during beatmap parsing
var b = GetBeatmap() ?? new Beatmap();
// The original beatmap version needs to be preserved as the database doesn't contain it
BeatmapInfo.BeatmapVersion = b.BeatmapInfo.BeatmapVersion;
// Use the database-backed info for more up-to-date values (beatmap id, ranked status, etc)
b.BeatmapInfo = BeatmapInfo;
return b;
2019-11-12 10:35:08 +00:00
}, beatmapCancellation.Token, TaskCreationOptions.LongRunning, TaskScheduler.Default);
public IBeatmap Beatmap
{
get
{
try
{
return LoadBeatmapAsync().Result;
}
catch (TaskCanceledException)
{
return null;
}
}
}
private readonly CancellationTokenSource beatmapCancellation = new CancellationTokenSource();
2018-09-06 03:51:23 +00:00
protected abstract IBeatmap GetBeatmap();
private Task<IBeatmap> beatmapLoadTask;
2018-04-13 09:19:50 +00:00
2018-09-06 03:51:23 +00:00
public bool BackgroundLoaded => background.IsResultAvailable;
public Texture Background => background.Value;
protected virtual bool BackgroundStillValid(Texture b) => b == null || b.Available;
2018-09-06 03:51:23 +00:00
protected abstract Texture GetBackground();
private readonly RecyclableLazy<Texture> background;
2018-04-13 09:19:50 +00:00
public VideoSprite Video => GetVideo();
2019-08-30 20:19:34 +00:00
protected abstract VideoSprite GetVideo();
2018-04-13 09:19:50 +00:00
public bool TrackLoaded => track.IsResultAvailable;
2018-09-06 03:51:23 +00:00
public Track Track => track.Value;
protected abstract Track GetTrack();
private RecyclableLazy<Track> track;
2018-04-13 09:19:50 +00:00
public bool WaveformLoaded => waveform.IsResultAvailable;
2018-09-06 03:51:23 +00:00
public Waveform Waveform => waveform.Value;
2019-01-07 09:50:27 +00:00
protected virtual Waveform GetWaveform() => new Waveform(null);
2018-09-06 03:51:23 +00:00
private readonly RecyclableLazy<Waveform> waveform;
2018-04-13 09:19:50 +00:00
public bool StoryboardLoaded => storyboard.IsResultAvailable;
2018-09-06 03:51:23 +00:00
public Storyboard Storyboard => storyboard.Value;
protected virtual Storyboard GetStoryboard() => new Storyboard { BeatmapInfo = BeatmapInfo };
private readonly RecyclableLazy<Storyboard> storyboard;
2018-04-13 09:19:50 +00:00
public bool SkinLoaded => skin.IsResultAvailable;
public ISkin Skin => skin.Value;
protected virtual ISkin GetSkin() => new DefaultSkin();
private readonly RecyclableLazy<ISkin> skin;
2018-04-13 09:19:50 +00:00
2018-09-06 03:51:23 +00:00
/// <summary>
/// Transfer pieces of a beatmap to a new one, where possible, to save on loading.
/// </summary>
/// <param name="other">The new beatmap which is being switched to.</param>
public virtual void TransferTo(WorkingBeatmap other)
2018-04-13 09:19:50 +00:00
{
if (track.IsResultAvailable && Track != null && BeatmapInfo.AudioEquals(other.BeatmapInfo))
other.track = track;
}
/// <summary>
/// Eagerly dispose of the audio track associated with this <see cref="WorkingBeatmap"/> (if any).
/// Accessing track again will load a fresh instance.
/// </summary>
public virtual void RecycleTrack() => track.Recycle();
2018-04-13 09:19:50 +00:00
2019-06-27 04:56:36 +00:00
#region Disposal
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}
private bool isDisposed;
2019-06-27 04:56:36 +00:00
protected virtual void Dispose(bool isDisposing)
{
if (isDisposed)
return;
isDisposed = true;
2019-06-27 04:56:36 +00:00
// recycling logic is not here for the time being, as components which use
// retrieved objects from WorkingBeatmap may not hold a reference to the WorkingBeatmap itself.
2019-07-02 13:24:08 +00:00
// this should be fine as each retrieved component do have their own finalizers.
2019-06-27 04:56:36 +00:00
// cancelling the beatmap load is safe for now since the retrieval is a synchronous
// operation. if we add an async retrieval method this may need to be reconsidered.
beatmapCancellation?.Cancel();
total_count.Value--;
2019-06-27 04:56:36 +00:00
}
2019-07-02 13:21:56 +00:00
~WorkingBeatmap()
{
Dispose(false);
}
2019-06-27 04:56:36 +00:00
#endregion
2018-09-06 03:51:23 +00:00
public class RecyclableLazy<T>
2018-04-13 09:19:50 +00:00
{
2018-09-06 03:51:23 +00:00
private Lazy<T> lazy;
2018-04-13 09:19:50 +00:00
private readonly Func<T> valueFactory;
private readonly Func<T, bool> stillValidFunction;
2018-09-06 04:27:53 +00:00
private readonly object fetchLock = new object();
2018-04-13 09:19:50 +00:00
2018-09-06 03:51:23 +00:00
public RecyclableLazy(Func<T> valueFactory, Func<T, bool> stillValidFunction = null)
2018-04-13 09:19:50 +00:00
{
this.valueFactory = valueFactory;
this.stillValidFunction = stillValidFunction;
recreate();
}
public void Recycle()
{
if (!IsResultAvailable) return;
2018-09-06 03:51:23 +00:00
(lazy.Value as IDisposable)?.Dispose();
2018-04-13 09:19:50 +00:00
recreate();
}
2018-09-06 03:51:23 +00:00
public bool IsResultAvailable => stillValid;
2018-04-13 09:19:50 +00:00
2018-09-06 03:51:23 +00:00
public T Value
2018-04-13 09:19:50 +00:00
{
get
{
2018-09-06 04:27:53 +00:00
lock (fetchLock)
{
if (!stillValid)
recreate();
return lazy.Value;
}
2018-04-13 09:19:50 +00:00
}
}
2018-09-06 03:51:23 +00:00
private bool stillValid => lazy.IsValueCreated && (stillValidFunction?.Invoke(lazy.Value) ?? true);
private void recreate() => lazy = new Lazy<T>(valueFactory, LazyThreadSafetyMode.ExecutionAndPublication);
2018-04-13 09:19:50 +00:00
}
}
}