Small ResourceManager refactor, add ResourceSaver<T>.

DaggerFramework/Source/Resources/Loaders/FontLoader.cs

@@ -1,15 +1,13 @@
 namespace DaggerFramework.Resources;
 
-public class FontLoader : IResourceLoader
+public class FontLoader : IResourceLoader<Font>
 {
     public IEnumerable<string> SupportedExtensions => new string[]
     {
         "ttf"
     };
 
-    public Type ResourceType => typeof(Font);
-
-    public Resource Load(string path)
+    public Font Load(string path)
     {
         byte[] fileBuffer = File.ReadAllBytes(path);
         var result = new Font(path, fileBuffer);

DaggerFramework/Source/Resources/Loaders/IResourceLoader.cs

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

DaggerFramework/Source/Resources/Loaders/SoundLoader.cs

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

DaggerFramework/Source/Resources/Loaders/Texture2dLoader.cs

@@ -3,7 +3,7 @@ using StbImageSharp;
 
 namespace DaggerFramework
 {
-    public class Texture2dLoader : IResourceLoader
+    public class Texture2dLoader : IResourceLoader<Texture2d>
     {
         public IEnumerable<string> SupportedExtensions => new string[]
         {
@@ -12,9 +12,7 @@ namespace DaggerFramework
             ".jpeg"
         };
 
-        public Type ResourceType => typeof(Texture2d);
-
-        public Resource Load(string path)
+        public Texture2d Load(string path)
         {
             ImageResult image;
             using (var stream = File.OpenRead(path))
@@ -28,10 +26,5 @@ namespace DaggerFramework
 
             return result;
         }
-
-        Resource IResourceLoader.Load(string path)
-        {
-            throw new NotImplementedException();
-        }
     }
 }

DaggerFramework/Source/Resources/Resource.cs

@@ -1,10 +1,15 @@
+using System.Text.Json.Serialization;
+
 namespace DaggerFramework
 {
     public abstract class Resource : IDisposable
     {
         public string? Path { get => _path; set => _path = value; }
+
+        [JsonIgnore]
         public byte[]? Buffer { get => _buffer; set => _buffer = value; }
 
+        [JsonIgnore]
         public long BufferSize { get; set; }
 
         public Resource(string path, byte[] buffer)

DaggerFramework/Source/Resources/ResourceManager.cs

@@ -24,7 +24,7 @@ namespace DaggerFramework.Resources
 
             _logger.Info($"Loading {path} as {typeof(T)} with id \"{resourceId}\"...");
 
-            if (!TryGetLoader<T>(out IResourceLoader? loader))
+            if (!TryGetLoader(out IResourceLoader<T>? loader))
             {
                 return false;
             }
@@ -50,6 +50,21 @@ namespace DaggerFramework.Resources
             return true;
         }
 
+        public bool TrySave<T>(string path, in T resource) where T : Resource
+        {
+            if (!TryGetSaver(out IResourceSaver<T>? saver))
+            {
+                return false;
+            }
+
+            if (!saver.TrySave(path, in resource))
+            {
+                return false;
+            }
+
+            return true;
+        }
+
         public bool TryGetResource<T>(string resourceId, [NotNullWhen(true)] out T? resource) where T : Resource
         {
             resource = null;
@@ -75,37 +90,82 @@ namespace DaggerFramework.Resources
 
         public bool IsResourceLoaded(string resourceId) => _loadedResources.ContainsKey(resourceId);
 
-        public void AddResourceAssociation(Type resourceType, IResourceLoader loader)
+        public void AddResourceLoaderAssociation<T>(IResourceLoader<T> loader) where T : Resource
         {
-            _resourceLoaderAssociations.Add(resourceType, loader);
+            _logger.Info($"Added resource loader association for {typeof(T)}.");
+            _resourceLoaderAssociations.Add(typeof(T), loader);
         }
 
-        private bool TryGetLoader<T>([NotNullWhen(true)] out IResourceLoader? loader) where T : Resource
+        public void AddResourceSaverAssociation<T>(IResourceSaver<T> saver) where T : Resource
+        {
+            _logger.Info($"Added resource saver association for {typeof(T)}.");
+            _resourceSaverAssociations.Add(typeof(T), saver);
+        }
+
+        private bool TryGetLoader<T>([NotNullWhen(true)] out IResourceLoader<T>? loader) where T : Resource
         {
             loader = null;
 
             if (!_resourceLoaderAssociations.ContainsKey(typeof(T)))
             {
-                _logger.Error($"No loader for {typeof(T).ToString()} was found!");
+                _logger.Error($"No loader association found for {typeof(T)}.");
                 return false;
             }
 
-            loader = _resourceLoaderAssociations[typeof(T)];
+            loader = _resourceLoaderAssociations[typeof(T)] as IResourceLoader<T>;
 
-            _logger.Info($"Using {loader.GetType().ToString()} for loading...");
+            if (loader is not null)
+            {
+                _logger.Info($"Using {loader.GetType()} for loading...");
+            }
+            else
+            {
+                _logger.Error($"No loader association found for {typeof(T)}.");
+                return false;
+            }
+
+            return true;
+        }
+
+        private bool TryGetSaver<T>([NotNullWhen(true)] out IResourceSaver<T>? saver) where T : Resource
+        {
+            saver = null;
+
+            if (!_resourceSaverAssociations.ContainsKey(typeof(T)))
+            {
+                _logger.Error($"No saver association found for {typeof(T)}.");
+                return false;
+            }
+
+            saver = _resourceSaverAssociations[typeof(T)] as IResourceSaver<T>;
+
+            if (saver is not null)
+            {
+                _logger.Info($"Using {saver.GetType()} for saving...");
+            }
+            else
+            {
+                _logger.Error($"No saver association found for {typeof(T)}.");
+                return false;
+            }
 
             return true;
         }
 
         private Logger _logger = new(nameof(ResourceManager));
 
-        private readonly Dictionary<Type, IResourceLoader> _resourceLoaderAssociations = new()
+        private readonly Dictionary<Type, object> _resourceLoaderAssociations = new()
         {
             {typeof(Sound), new SoundLoader()},
             {typeof(Texture2d), new Texture2dLoader()},
             {typeof(Font), new FontLoader()}
         };
 
+        private readonly Dictionary<Type, object> _resourceSaverAssociations = new()
+        {
+
+        };
+
         private Dictionary<string, Resource> _loadedResources = new();
     }
 }

DaggerFramework/Source/Resources/Savers/IResourceSaver.cs

@@ -0,0 +1,7 @@
+namespace DaggerFramework.Resources
+{
+    public interface IResourceSaver<T> where T : Resource
+    {
+        public bool TrySave(string path, in T resource);
+    }
+}