ResourceManager!

DaggerFramework/Source/Resources/Loaders/FontLoader.cs

@@ -1,8 +1,15 @@
-namespace DaggerFramework;
+namespace DaggerFramework.Resources;
 
-public class FontLoader : ResourceLoader<Font>
+public class FontLoader : IResourceLoader
 {
-    public override Font Load(string path)
+    public IEnumerable<string> SupportedExtensions => new string[]
+    {
+        ".ttf"
+    };
+
+    public Type ResourceType => typeof(Font);
+
+    public Resource Load(string path)
     {
         return default;
     }

DaggerFramework/Source/Resources/Loaders/IResourceLoader.cs

@@ -0,0 +1,9 @@
+namespace DaggerFramework.Resources
+{
+    public interface IResourceLoader
+    {
+        public IEnumerable<string> SupportedExtensions { get; }
+        public Type ResourceType { get; }
+        public Resource Load(string path);
+    }
+}

DaggerFramework/Source/Resources/Loaders/ResourceLoader.cs

@@ -1,8 +0,0 @@
-namespace DaggerFramework
-{
-    public abstract class ResourceLoader<T> : IDisposable where T : Resource
-    {
-        public void Dispose() { }
-        public abstract T Load(string path);
-    }
-}

DaggerFramework/Source/Resources/Loaders/SoundLoader.cs

@@ -1,10 +1,17 @@
 using StbVorbisSharp;
 
-namespace DaggerFramework
+namespace DaggerFramework.Resources
 {
-    public class SoundLoader : ResourceLoader<Sound>
+    public class SoundLoader : IResourceLoader
     {
-        public override Sound Load(string path)
+        public IEnumerable<string> SupportedExtensions => new string[]
+        {
+            "ogg"
+        };
+
+        public Type ResourceType => typeof(Sound);
+
+        public Resource Load(string path)
         {
             Vorbis vorbis;
             Sound result;

DaggerFramework/Source/Resources/Loaders/Texture2dLoader.cs

@@ -1,10 +1,20 @@
+using DaggerFramework.Resources;
 using StbImageSharp;
 
 namespace DaggerFramework
 {
-    public class Texture2dLoader : ResourceLoader<Texture2d>
+    public class Texture2dLoader : IResourceLoader
     {
-        public override Texture2d Load(string path)
+        public IEnumerable<string> SupportedExtensions => new string[]
+        {
+            ".png",
+            ".jpg",
+            ".jpeg"
+        };
+
+        public Type ResourceType => typeof(Texture2d);
+
+        public Resource Load(string path)
         {
             ImageResult image;
             using (var stream = File.OpenRead(path))
@@ -18,5 +28,10 @@ namespace DaggerFramework
 
             return result;
         }
+
+        Resource IResourceLoader.Load(string path)
+        {
+            throw new NotImplementedException();
+        }
     }
 }

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();
+    }
+}

DaggerFramework/Source/Utils/Logger.cs

@@ -0,0 +1,47 @@
+namespace DaggerFramework.Utils
+{
+    public class Logger
+    {
+        public static Action<string, LogType>? OnLog;
+        public Logger(string className)
+        {
+            _className = className;
+        }
+        public void Info(object what)
+        {
+            LogType logType = LogType.Info;
+            string message = $"({DateFormat}) [{logType.ToString().ToUpper()}/{_className}] {what}";
+            LogConsole(message);
+            OnLog?.Invoke(message, logType);
+        }
+
+        public void Warn(object what)
+        {
+            LogType logType = LogType.Warn;
+            string message = $"({DateFormat}) [{logType.ToString().ToUpper()}/{_className}] {what}";
+            LogConsole(message);
+            OnLog?.Invoke(message, logType);
+        }
+
+        public void Error(object what)
+        {
+            LogType logType = LogType.Error;
+            string message = $"({DateFormat}) [{logType.ToString().ToUpper()}/{_className}] {what}";
+            LogConsole(message);
+            OnLog?.Invoke(message, logType);
+        }
+
+
+        private static string DateFormat => $"{DateTime.Now:t}";
+
+        private static void LogConsole(string what) => Console.WriteLine(what);
+        private readonly string _className;
+    }
+
+    public enum LogType
+    {
+        Info,
+        Warn,
+        Error
+    }
+}