ResourceManager!

DaggerFramework/Source/Resources/ResourceManager.cs

@@ -0,0 +1,110 @@
+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()}
+        };
+
+        private Dictionary<string, Resource> _loadedResources = new();
+    }
+}