1
0
mirror of https://github.com/ppy/osu.git synced 2024-12-15 13:22:55 +08:00
osu-lazer/osu.Game/Skinning/Skin.cs

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

244 lines
9.8 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
2018-03-14 19:45:04 +08:00
using System;
2021-05-10 21:43:48 +08:00
using System.Collections.Generic;
2022-03-23 23:08:01 +08:00
using System.Diagnostics;
using System.IO;
2021-05-10 21:43:48 +08:00
using System.Linq;
using System.Text;
using Newtonsoft.Json;
2018-02-22 16:16:48 +08:00
using osu.Framework.Audio.Sample;
using osu.Framework.Bindables;
2018-02-22 16:16:48 +08:00
using osu.Framework.Graphics;
using osu.Framework.Graphics.Containers;
using osu.Framework.Graphics.Textures;
using osu.Framework.IO.Stores;
using osu.Framework.Logging;
2019-08-23 19:32:43 +08:00
using osu.Game.Audio;
2021-11-29 17:02:09 +08:00
using osu.Game.Database;
2021-05-10 21:43:48 +08:00
using osu.Game.IO;
2018-04-13 17:19:50 +08:00
2018-02-22 16:16:48 +08:00
namespace osu.Game.Skinning
{
2019-04-25 16:36:17 +08:00
public abstract class Skin : IDisposable, ISkin
2018-02-22 16:16:48 +08:00
{
/// <summary>
2022-03-24 11:39:47 +08:00
/// A texture store which can be used to perform user file lookups for this skin.
/// </summary>
protected TextureStore? Textures { get; }
/// <summary>
2022-03-24 11:39:47 +08:00
/// A sample store which can be used to perform user file lookups for this skin.
/// </summary>
protected ISampleStore? Samples { get; }
public readonly Live<SkinInfo> SkinInfo;
2018-04-13 17:19:50 +08:00
public SkinConfiguration Configuration { get; set; }
2018-04-13 17:19:50 +08:00
public IDictionary<SkinComponentsContainerLookup.TargetArea, SkinLayoutInfo> LayoutInfos => layoutInfos;
2021-05-10 21:43:48 +08:00
private readonly Dictionary<SkinComponentsContainerLookup.TargetArea, SkinLayoutInfo> layoutInfos =
new Dictionary<SkinComponentsContainerLookup.TargetArea, SkinLayoutInfo>();
2018-04-13 17:19:50 +08:00
public abstract ISample? GetSample(ISampleInfo sampleInfo);
2018-04-13 17:19:50 +08:00
public Texture? GetTexture(string componentName) => GetTexture(componentName, default, default);
2020-07-17 15:54:30 +08:00
public abstract Texture? GetTexture(string componentName, WrapMode wrapModeS, WrapMode wrapModeT);
2018-04-13 17:19:50 +08:00
public abstract IBindable<TValue>? GetConfig<TLookup, TValue>(TLookup lookup)
2022-03-25 14:53:55 +08:00
where TLookup : notnull
where TValue : notnull;
2018-04-13 17:19:50 +08:00
private readonly RealmBackedResourceStore<SkinInfo>? realmBackedStorage;
2022-03-23 12:14:56 +08:00
/// <summary>
/// Construct a new skin.
/// </summary>
/// <param name="skin">The skin's metadata. Usually a live realm object.</param>
/// <param name="resources">Access to game-wide resources.</param>
/// <param name="storage">An optional store which will *replace* all file lookups that are usually sourced from <paramref name="skin"/>.</param>
/// <param name="configurationFilename">An optional filename to read the skin configuration from. If not provided, the configuration will be retrieved from the storage using "skin.ini".</param>
protected Skin(SkinInfo skin, IStorageResourceProvider? resources, IResourceStore<byte[]>? storage = null, string configurationFilename = @"skin.ini")
2018-02-22 16:16:48 +08:00
{
if (resources != null)
{
2022-03-23 23:08:01 +08:00
SkinInfo = skin.ToLive(resources.RealmAccess);
storage ??= realmBackedStorage = new RealmBackedResourceStore<SkinInfo>(SkinInfo, resources.Files, resources.RealmAccess);
var samples = resources.AudioManager?.GetSampleStore(storage);
if (samples != null)
{
samples.PlaybackConcurrency = OsuGameBase.SAMPLE_CONCURRENCY;
// osu-stable performs audio lookups in order of wav -> mp3 -> ogg.
// The GetSampleStore() call above internally adds wav and mp3, so ogg is added at the end to ensure expected ordering.
samples.AddExtension(@"ogg");
}
Samples = samples;
Textures = new TextureStore(resources.Renderer, new MaxDimensionLimitedTextureLoaderStore(resources.CreateTextureLoaderStore(storage)));
}
2022-03-23 23:08:01 +08:00
else
{
// Generally only used for tests.
SkinInfo = skin.ToLiveUnmanaged();
}
var configurationStream = storage?.GetStream(configurationFilename);
if (configurationStream != null)
2022-03-23 23:08:01 +08:00
{
2021-10-24 22:43:37 +08:00
// stream will be closed after use by LineBufferedReader.
ParseConfigurationStream(configurationStream);
2022-03-23 23:08:01 +08:00
Debug.Assert(Configuration != null);
}
else
Configuration = new SkinConfiguration();
2021-05-10 21:43:48 +08:00
2021-11-29 17:02:09 +08:00
// skininfo files may be null for default skin.
foreach (SkinComponentsContainerLookup.TargetArea skinnableTarget in Enum.GetValues<SkinComponentsContainerLookup.TargetArea>())
{
string filename = $"{skinnableTarget}.json";
byte[]? bytes = storage?.Get(filename);
if (bytes == null)
continue;
try
{
string jsonContent = Encoding.UTF8.GetString(bytes);
SkinLayoutInfo? layoutInfo = null;
try
{
// First attempt to deserialise using the new SkinLayoutInfo format
layoutInfo = JsonConvert.DeserializeObject<SkinLayoutInfo>(jsonContent);
}
catch
{
}
// Of note, the migration code below runs on read of skins, but there's nothing to
// force a rewrite after migration. Let's not remove these migration rules until we
// have something in place to ensure we don't end up breaking skins of users that haven't
// manually saved their skin since a change was implemented.
// If deserialisation using SkinLayoutInfo fails, attempt to deserialise using the old naked list.
if (layoutInfo == null)
{
// handle namespace changes...
jsonContent = jsonContent.Replace(@"osu.Game.Screens.Play.SongProgress", @"osu.Game.Screens.Play.HUD.DefaultSongProgress");
jsonContent = jsonContent.Replace(@"osu.Game.Screens.Play.HUD.LegacyComboCounter", @"osu.Game.Skinning.LegacyComboCounter");
var deserializedContent = JsonConvert.DeserializeObject<IEnumerable<SerialisedDrawableInfo>>(jsonContent);
if (deserializedContent == null)
continue;
layoutInfo = new SkinLayoutInfo();
layoutInfo.Update(null, deserializedContent.ToArray());
Logger.Log($"Ferrying {deserializedContent.Count()} components in {skinnableTarget} to global section of new {nameof(SkinLayoutInfo)} format");
}
LayoutInfos[skinnableTarget] = layoutInfo;
}
catch (Exception ex)
{
Logger.Error(ex, "Failed to load skin configuration.");
}
}
}
protected virtual void ParseConfigurationStream(Stream stream)
{
using (LineBufferedReader reader = new LineBufferedReader(stream, true))
Configuration = new LegacySkinDecoder().Decode(reader);
}
2021-05-13 12:09:33 +08:00
/// <summary>
/// Remove all stored customisations for the provided target.
/// </summary>
/// <param name="targetContainer">The target container to reset.</param>
public void ResetDrawableTarget(SkinComponentsContainer targetContainer)
{
LayoutInfos.Remove(targetContainer.Lookup.Target);
2021-05-10 21:43:48 +08:00
}
2021-05-13 12:09:33 +08:00
/// <summary>
/// Update serialised information for the provided target.
/// </summary>
/// <param name="targetContainer">The target container to serialise to this skin.</param>
public void UpdateDrawableTarget(SkinComponentsContainer targetContainer)
2021-05-10 21:43:48 +08:00
{
if (!LayoutInfos.TryGetValue(targetContainer.Lookup.Target, out var layoutInfo))
layoutInfos[targetContainer.Lookup.Target] = layoutInfo = new SkinLayoutInfo();
layoutInfo.Update(targetContainer.Lookup.Ruleset, ((ISerialisableDrawableContainer)targetContainer).CreateSerialisedInfo().ToArray());
2021-05-10 21:43:48 +08:00
}
public virtual Drawable? GetDrawableComponent(ISkinComponentLookup lookup)
2021-05-10 21:43:48 +08:00
{
switch (lookup)
2021-05-10 21:43:48 +08:00
{
// This fallback is important for user skins which use SkinnableSprites.
case SkinnableSprite.SpriteComponentLookup sprite:
return this.GetAnimation(sprite.LookupName, false, false);
case SkinComponentsContainerLookup containerLookup:
// It is important to return null if the user has not configured this yet.
// This allows skin transformers the opportunity to provide default components.
if (!LayoutInfos.TryGetValue(containerLookup.Target, out var layoutInfo)) return null;
if (!layoutInfo.TryGetDrawableInfo(containerLookup.Ruleset, out var drawableInfos)) return null;
return new Container
2021-05-10 21:43:48 +08:00
{
RelativeSizeAxes = Axes.Both,
ChildrenEnumerable = drawableInfos.Select(i => i.CreateInstance())
2021-05-10 21:43:48 +08:00
};
}
return null;
2018-02-22 16:16:48 +08:00
}
2018-04-13 17:19:50 +08:00
2018-03-14 19:45:04 +08:00
#region Disposal
2018-04-13 17:19:50 +08:00
2018-03-14 19:45:04 +08:00
~Skin()
{
// required to potentially clean up sample store from audio hierarchy.
2018-03-14 19:45:04 +08:00
Dispose(false);
}
2018-04-13 17:19:50 +08:00
2018-03-14 19:45:04 +08:00
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}
2018-04-13 17:19:50 +08:00
2018-03-14 19:45:04 +08:00
private bool isDisposed;
2018-04-13 17:19:50 +08:00
2018-03-14 19:45:04 +08:00
protected virtual void Dispose(bool isDisposing)
{
if (isDisposed)
return;
2019-02-28 12:31:40 +08:00
2018-03-14 19:45:04 +08:00
isDisposed = true;
Textures?.Dispose();
Samples?.Dispose();
realmBackedStorage?.Dispose();
2018-03-14 19:45:04 +08:00
}
2018-04-13 17:19:50 +08:00
2018-03-14 19:45:04 +08:00
#endregion
2018-02-22 16:16:48 +08:00
}
}