Small ResourceManager refactor, add ResourceSaver<T>.

DaggerFramework/Source/SceneGraph/Entities/Entity.cs

@@ -1,3 +1,4 @@
+using System.Text.Json.Serialization;
 using DaggerFramework.Audio;
 using DaggerFramework.Rendering;
 
@@ -26,4 +27,11 @@ namespace DaggerFramework.SceneGraph
             Layer?.DestroyEntity(Id);
         }
     }
+
+    [JsonSourceGenerationOptions(WriteIndented = true)]
+    [JsonSerializable(typeof(Entity))]
+    internal partial class EntitySourceGenerationContext : JsonSerializerContext
+    {
+
+    }
 }

DaggerFramework/Source/SceneGraph/EntityLayer.cs

@@ -1,3 +1,4 @@
+using System.Text.Json.Serialization;
 using DaggerFramework.Rendering;
 using DaggerFramework.Utils;
 
@@ -5,17 +6,17 @@ namespace DaggerFramework.SceneGraph
 {
     public class EntityLayer : Layer
     {
-        public List<Entity> Entities { get => _entities; }
+        [JsonInclude] public List<Entity> Entities { get; set; }
         public Camera2d? CurrentCamera { get; set; }
 
         public EntityLayer(List<Entity> entities)
         {
-            _entities = entities;
+            Entities = entities;
         }
 
         public EntityLayer()
         {
-            _entities = new List<Entity>();
+            Entities = new List<Entity>();
         }
 
         public void UpdateCurrentCamera()
@@ -53,14 +54,14 @@ namespace DaggerFramework.SceneGraph
 
         public void DestroyEntity(int at)
         {
-            _entities.RemoveAt(at);
+            Entities.RemoveAt(at);
         }
 
         protected override void OnStart()
         {
-            for (int i = 0; i < _entities.Count; i++)
+            for (int i = 0; i < Entities.Count; i++)
             {
-                var entity = _entities[i];
+                var entity = Entities[i];
                 entity.Layer = this;
                 entity.Start();
             }
@@ -68,7 +69,7 @@ namespace DaggerFramework.SceneGraph
 
         protected override void OnUpdate(double dt)
         {
-            foreach (var entity in _entities)
+            foreach (var entity in Entities)
             {
                 entity.Update(dt);
             }
@@ -94,7 +95,7 @@ namespace DaggerFramework.SceneGraph
         protected override void OnDraw(Renderer renderer)
         {
             // TODO: can be done more efficiently, needs rendering redesign.
-            foreach (var entity in _entities)
+            foreach (var entity in Entities)
             {
                 if (entity is IDrawable drawable)
                 {
@@ -102,8 +103,6 @@ namespace DaggerFramework.SceneGraph
                 }
             }
         }
-
-        private List<Entity> _entities;
         private List<Camera2d> _cameraEntities = new();
     }
 }

DaggerFramework/Source/SceneGraph/Layer.cs

@@ -1,13 +1,14 @@
 using DaggerFramework.Resources;
 using DaggerFramework.Rendering;
+using System.Text.Json.Serialization;
 
 namespace DaggerFramework.SceneGraph
 {
     public abstract class Layer : IDrawable
     {
-        public Scene? Scene { get; set; }
-        public InputHandler? Input { get; set; }
-        public ResourceManager ResourceManager => Scene!.ResourceManager;
+        [JsonIgnore] public Scene? Scene { get; set; }
+        [JsonIgnore] public InputHandler? Input { get; set; }
+        [JsonIgnore] public ResourceManager ResourceManager => Scene!.ResourceManager;
 
         public void BeginDraw(Renderer renderer) => OnBeginDraw(renderer);
         public void Draw(Renderer renderer) => OnDraw(renderer);

DaggerFramework/Source/SceneGraph/Resources/SerializedScene.cs

@@ -0,0 +1,20 @@
+using System.Text.Json.Serialization;
+
+namespace DaggerFramework.SceneGraph
+{
+    public class SerializedScene : Resource
+    {
+        public Dictionary<string, Layer> Layers { get; set; }
+
+        public SerializedScene(string path, byte[] buffer) : base(path, buffer)
+        {
+        }
+    }
+
+    [JsonSourceGenerationOptions(WriteIndented = true)]
+    [JsonSerializable(typeof(SerializedScene))]
+    internal partial class SerializedSceneContext : JsonSerializerContext
+    {
+
+    }
+}

DaggerFramework/Source/SceneGraph/Resources/SerializedSceneSaver.cs

@@ -0,0 +1,23 @@
+using DaggerFramework.Resources;
+using DaggerFramework.Utils;
+
+namespace DaggerFramework.SceneGraph
+{
+    public class SerializedSceneSaver : IResourceSaver<SerializedScene>
+    {
+        public bool TrySave(string path, in SerializedScene resource)
+        {
+            if (resource.Buffer is null)
+            {
+                _logger.Error($"Tried to save a resource at \"{path}\" with a null buffer!");
+                return false;
+            }
+
+            File.WriteAllBytes(path, resource.Buffer);
+
+            return true;
+        }
+
+        private Logger _logger = new(nameof(SerializedSceneSaver));
+    }
+}

DaggerFramework/Source/SceneGraph/Scene.cs

@@ -1,4 +1,4 @@
-using System.Numerics;
+using System.Text.Json;
 using DaggerFramework.Audio;
 using DaggerFramework.Rendering;
 using DaggerFramework.Resources;
@@ -16,20 +16,43 @@ namespace DaggerFramework.SceneGraph
         public double DeltaTime => _renderer.FrameTime;
         public bool ShouldRun => Renderer.ShouldRun;
 
-        public Scene(Renderer renderer, InputHandler input, AudioBackend audioBackend, ResourceManager resourceManager)
+        public Scene(SceneSettings settings)
         {
-            _renderer = renderer;
-            _input = input;
-            _audioBackend = audioBackend;
-            _resourceManager = resourceManager;
-
-            _layers = new Dictionary<string, Layer>();
+            _renderer = settings.Renderer;
+            _input = settings.InputHandler;
+            _audioBackend = settings.AudioBackend;
+            _resourceManager = settings.ResourceManager;
         }
 
-        public Scene(Renderer renderer, ResourceManager resourceManager)
+        public static Scene FromSerialized(SerializedScene serializedScene, SceneSettings settings)
         {
-            _renderer = renderer;
-            _resourceManager = resourceManager;
+            var scene = new Scene(settings);
+            scene.WithLayers(serializedScene.Layers);
+
+            return scene;
+        }
+
+        public bool TrySerialize(out SerializedScene serializedScene)
+        {
+            serializedScene = new SerializedScene(string.Empty, new byte[] { })
+            {
+                Layers = _layers
+            };
+
+            var sourceGenOptions = new JsonSerializerOptions
+            {
+                TypeInfoResolver = SerializedSceneContext.Default
+            };
+
+            serializedScene.Buffer = JsonSerializer.SerializeToUtf8Bytes(serializedScene, typeof(SerializedScene), sourceGenOptions);
+            serializedScene.BufferSize = serializedScene.Buffer.LongLength;
+
+            return true;
+        }
+
+        public void WithLayers(Dictionary<string, Layer> layers)
+        {
+            _layers = layers;
         }
 
         public void Init() => SetupRenderer();
@@ -97,4 +120,12 @@ namespace DaggerFramework.SceneGraph
         private InputHandler? _input;
         private ResourceManager _resourceManager;
     }
+
+    public struct SceneSettings
+    {
+        public Renderer Renderer { get; set; }
+        public AudioBackend AudioBackend { get; set; }
+        public InputHandler InputHandler { get; set; }
+        public ResourceManager ResourceManager { get; set; }
+    }
 }