111 lines
3.4 KiB
C#
111 lines
3.4 KiB
C#
using System.Diagnostics.CodeAnalysis;
|
|
using System.Linq;
|
|
|
|
using DaggerFramework.Utils;
|
|
|
|
namespace DaggerFramework.Resources
|
|
{
|
|
public class ResourceManager
|
|
{
|
|
public string ResourceRoot { get; set; } = "Resources/";
|
|
|
|
public bool TryLoad<T>(string resourceId, string path) where T : Resource
|
|
{
|
|
T? resource = null;
|
|
|
|
var fullPath = Path.Combine(ResourceRoot, path);
|
|
|
|
// TODO: don't check if file doesn't exist in the file system, make it more generic but for now it's fine
|
|
if (!File.Exists(fullPath))
|
|
{
|
|
_logger.Error($"File at \"{path}\" doesn't exist!");
|
|
return false;
|
|
}
|
|
|
|
_logger.Info($"Loading {path} as {typeof(T)} with id \"{resourceId}\"...");
|
|
|
|
if (!TryGetLoader<T>(out IResourceLoader? loader))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
var extension = Path.GetExtension(fullPath);
|
|
var hasExtension = loader.SupportedExtensions.Any(ext => extension[1..] == ext);
|
|
|
|
if (!hasExtension)
|
|
{
|
|
_logger.Error($"Extension {extension} is not supported!");
|
|
}
|
|
|
|
if (loader.Load(fullPath) is not T loadedResource)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
resource = loadedResource;
|
|
_loadedResources.Add(resourceId, resource);
|
|
|
|
_logger.Info($"\"{resourceId}\" was loaded successfully.");
|
|
|
|
return true;
|
|
}
|
|
|
|
public bool TryGetResource<T>(string resourceId, [NotNullWhen(true)] out T? resource) where T : Resource
|
|
{
|
|
resource = null;
|
|
|
|
if (!IsResourceLoaded(resourceId))
|
|
{
|
|
_logger.Error($"Resource \"{resourceId}\" has not yet been loaded!");
|
|
return false;
|
|
}
|
|
|
|
var expectedResource = _loadedResources[resourceId];
|
|
|
|
if (expectedResource is not T loadedResource)
|
|
{
|
|
_logger.Error($"Given resource is of wrong type: provided {typeof(T)}, expected {expectedResource.GetType()}!");
|
|
return false;
|
|
}
|
|
|
|
resource = loadedResource;
|
|
|
|
return true;
|
|
}
|
|
|
|
public bool IsResourceLoaded(string resourceId) => _loadedResources.ContainsKey(resourceId);
|
|
|
|
public void AddResourceAssociation(Type resourceType, IResourceLoader loader)
|
|
{
|
|
_resourceLoaderAssociations.Add(resourceType, loader);
|
|
}
|
|
|
|
private bool TryGetLoader<T>([NotNullWhen(true)] out IResourceLoader? loader) where T : Resource
|
|
{
|
|
loader = null;
|
|
|
|
if (!_resourceLoaderAssociations.ContainsKey(typeof(T)))
|
|
{
|
|
_logger.Error($"No loader for {typeof(T).ToString()} was found!");
|
|
return false;
|
|
}
|
|
|
|
loader = _resourceLoaderAssociations[typeof(T)];
|
|
|
|
_logger.Info($"Using {loader.GetType().ToString()} for loading...");
|
|
|
|
return true;
|
|
}
|
|
|
|
private Logger _logger = new(nameof(ResourceManager));
|
|
|
|
private readonly Dictionary<Type, IResourceLoader> _resourceLoaderAssociations = new()
|
|
{
|
|
{typeof(Sound), new SoundLoader()},
|
|
{typeof(Texture2d), new Texture2dLoader()},
|
|
{typeof(Font), new FontLoader()}
|
|
};
|
|
|
|
private Dictionary<string, Resource> _loadedResources = new();
|
|
}
|
|
} |