feat: ✨ Implement asynchronous scene and resource loading

Author: Marco Klein

Source/Composition/Extensions/IServiceCollectionExtensions.cs

@@ -11,6 +11,13 @@ public static IServiceCollection MapSingleton<TNewMapping, TSource>(
       return collection.AddSingleton<TNewMapping>(x => x.GetRequiredService<TSource>());
     }
 
+    public static IServiceCollection MapSingleton<TNewMapping>(
+      this IServiceCollection collection, Type type)
+      where TNewMapping : class {
+
+      return collection.AddSingleton<TNewMapping>(x => x.GetRequiredService(type) as TNewMapping);
+    }
+
     public static IServiceCollection AddFactory<TService, TImplementation>(this IServiceCollection services)
       where TService : class
       where TImplementation : class, TService {

Source/Composition/Extensions/NodeExtension.cs

@@ -8,7 +8,8 @@
 
 namespace GoDough.Composition.Extensions {
   public static class NodeCompositionExtensions {
-		public static Node WireNode(this Node node) {
+		public static T WireNode<T>(this T node)
+			where T : Node {
 			try {
 				Func<Attribute, bool> isInjectionAttribute = x =>
 				x.GetType().IsAssignableFrom(typeof(InjectAttribute));

Source/Runtime/GodotApi.cs

@@ -1,17 +1,89 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
 using Godot;
+using GoDough.Runtime.LivecycleHooks;
 
 namespace GoDough.Runtime {
   internal class GodotApi : IGodotApi {
+    private readonly Dictionary<string, List<Action<double>>> _threadedResourceLoadProgress = new Dictionary<string, List<Action<double>>>();
+    private readonly Dictionary<string, Task<Resource>> _resourceLoadTasks = new Dictionary<string, Task<Resource>>();
+    private readonly Timer _timer;
+
+    public GodotApi(AppHost appHost) {
+      this._timer = new Timer();
+      appHost.AutoLoadNode.AddChild(this._timer);
+
+      this._timer.WaitTime = 0.1;
+      this._timer.Name = "GodotApiTimer";
+      this._timer.Timeout += () => this.OnProcess();
+      this._timer.Start();
+    }
     public PackedScene LoadScene(string fileName) {
       return (PackedScene)this.LoadResource(fileName);
     }
 
+    public async Task<PackedScene> LoadSceneAsync(string fileName, Action<double> progress = null) {
+      return (PackedScene)(await this.LoadResourceAsync(fileName, progress));
+    }
+
+    public async Task<Shader> LoadShaderAsync(string fileName, Action<double> progress = null) {
+      return (Shader)(await this.LoadResourceAsync(fileName, progress));
+    }
+
+    public Resource LoadResource(string fileName) {
+      return this.LoadResourceAsync(fileName).Result;
+    }
+
+    public Task<Resource> LoadResourceAsync(string fileName, Action<double> progress = null) {
+      if (progress != null) {
+        if(!this._threadedResourceLoadProgress.ContainsKey(fileName)) {
+          this._threadedResourceLoadProgress[fileName] = new List<Action<double>>();
+        }
+
+        this._threadedResourceLoadProgress[fileName].Add(progress);
+      }
+
+      if (!this._resourceLoadTasks.ContainsKey(fileName)) {
+        this._resourceLoadTasks[fileName] = Task.Run(() => {
+          var error = ResourceLoader.LoadThreadedRequest(fileName);
+          var loadStatus = ResourceLoader.LoadThreadedGetStatus(fileName);
+          var resourceLoaded = ResourceLoader.LoadThreadedGet(fileName);
+
+          return resourceLoaded;
+        });
+      }
+
+      return this._resourceLoadTasks[fileName];
+    }
+
     public Shader LoadShader(string fileName) {
       return (Shader)this.LoadResource(fileName);
     }
 
-    public Resource LoadResource(string fileName) {
-      return GD.Load(fileName);
+    public void OnProcess() {
+      var keysToRemove = new List<string>();
+      foreach (var progressInfo in this._threadedResourceLoadProgress) {
+        var progressArray = new Godot.Collections.Array();
+        var loadStatus = ResourceLoader.LoadThreadedGetStatus(progressInfo.Key, progressArray);
+        if (loadStatus != ResourceLoader.ThreadLoadStatus.InProgress) {
+          if (loadStatus == ResourceLoader.ThreadLoadStatus.Loaded) {
+            progressInfo.Value.ForEach(x => x(1));
+          }
+
+          keysToRemove.Add(progressInfo.Key);
+
+          continue;
+        }
+
+        var progress = progressArray.FirstOrDefault().AsSingle();
+        progressInfo.Value.ForEach(x => x(progress));
+      }
+
+      foreach (var key in keysToRemove) {
+        this._threadedResourceLoadProgress.Remove(key);
+      }
     }
   }
 }

Source/Runtime/IGodotApi.cs

@@ -1,8 +1,13 @@
+using System;
+using System.Threading.Tasks;
 using Godot;
 
 namespace GoDough.Runtime {
   public interface IGodotApi {
     Shader LoadShader(string fileName);
     PackedScene LoadScene(string fileName);
+
+    Task<Shader> LoadShaderAsync(string fileName, Action<double> progress = null);
+    Task<PackedScene> LoadSceneAsync(string fileName, Action<double> progress = null);
   }
 }

Source/Visuals/SceneManagementService.cs

@@ -3,6 +3,7 @@
 using System.Collections.ObjectModel;
 using System.Threading.Tasks;
 using Godot;
+using GoDough.Runtime;
 using Microsoft.Extensions.Logging;
 
 // TODO: OnSceneChanging Event - Scene Change blocker?
@@ -17,6 +18,9 @@ public class SceneManagementService<TSceneEnum>
     private readonly Dictionary<TSceneEnum, string> _registeredScenes = new Dictionary<TSceneEnum, string>();
     private readonly ILogger<SceneManagementService<TSceneEnum>> _logger;
     private readonly IAppHostNodeProvider _appHostNodeProvider;
+    private readonly IGodotApi _godotApi;
+
+    private readonly GoDough.Threading.Dispatcher _dispatcher;
     #endregion
 
     #region Properties
@@ -32,7 +36,11 @@ public ReadOnlyDictionary<TSceneEnum, string> RegisteredSceneFiles {
     #region Ctor
     public SceneManagementService(
       ILogger<SceneManagementService<TSceneEnum>> logger,
-      IAppHostNodeProvider appHostNodeProvider) => (_logger, _appHostNodeProvider) = (logger, appHostNodeProvider);
+      IGodotApi godotApi,
+      GoDough.Threading.Dispatcher dispatcher,
+      IAppHostNodeProvider appHostNodeProvider) =>
+      (_dispatcher, _godotApi, _logger, _appHostNodeProvider) =
+      (dispatcher, godotApi, logger, appHostNodeProvider);
     #endregion
 
     #region Events
@@ -58,14 +66,38 @@ public SceneManagementService<TSceneEnum> RegisterSceneFile(TSceneEnum sceneKey,
       return this;
     }
 
-    public void LoadScene(TSceneEnum sceneKey) {
+    public async Task LoadScene(TSceneEnum sceneKey, PackedScene loadingScreen = null) {
       if (!this._registeredScenes.ContainsKey(sceneKey)) {
         throw new KeyNotFoundException(
           String.Format(
             "Could not find Scene with key '{0}'",
             Enum.GetName(typeof(TSceneEnum), sceneKey)));
       }
 
+      var appHostNode = this._appHostNodeProvider.GetNode();
+      ProgressBar progressBar = null;
+
+      Action<double> progress = loadingProgress =>
+        this._dispatcher.Invoke(() => {
+          if(progressBar != null) {
+            progressBar.Value = loadingProgress;
+          }
+        });
+
+      if (loadingScreen != null) {
+        appHostNode
+          .GetTree()
+          .ChangeSceneToPacked(loadingScreen);
+
+        double progressValue = 0;
+
+        while (progressBar == null) {
+          await appHostNode.ToSignal(appHostNode.GetTree(), "process_frame");
+          progressBar = appHostNode.GetTree().CurrentScene.GetNode<ProgressBar>("%ProgressBar");
+          progressBar.Value = progressValue;
+        }
+      }
+
       var fileName = this._registeredScenes[sceneKey];
       this._logger.LogInformation("Loading Scene '{0}' from '{1}'",
         Enum.GetName(typeof(TSceneEnum), sceneKey),
@@ -75,8 +107,9 @@ public void LoadScene(TSceneEnum sceneKey) {
         this._logger.LogInformation("_appHostNodeProvider null");
       }
 
-      var appHostNode = this._appHostNodeProvider.GetNode();
-      appHostNode.GetTree().ChangeSceneToFile(fileName);
+      var loadingTask = this._godotApi.LoadSceneAsync(fileName, progress);
+
+      appHostNode.GetTree().ChangeSceneToPacked(await loadingTask);
 
       var task = this.WaitForNextFrame(appHostNode, () => {
         this.CurrentScene = sceneKey;