[Assets] Made asset database loading async and save a cache as a binary file for faster loading in the editor;

[Jobs] Add Failure call for when a job fails due to an exception;
[Jobs] Add JobHandle Complete static method for lists of job handles;
[Editor] Make project meta file processing be async;
[Editor] Support showing background progress manually;
[Baker] Fix crash on invalid assimp scene loading;

Author: LittleCodingFox

Engine/Core/Assets/AssetDatabase.cs

@@ -0,0 +1,6 @@
+namespace Staple.Internal;
+
+public interface IAssetDatabaseObserver
+{
+    void AssetDatabaseSetProgress(float progress, string message);
+}

Engine/Core/Assets/IAssetDatabaseObserver.cs

@@ -2,12 +2,19 @@
 
 namespace Staple.Jobs;
 
-public class ActionJob(Action action) : IJob
+public class ActionJob(Action action, Action<Exception> exception = null) : IJob
 {
     public Action action = action;
+
+    public Action<Exception> exception = exception;
 
     public void Execute()
     {
         action();
     }
+
+    public void Failure(Exception e)
+    {
+        exception?.Invoke(e);
+    }
 }

Engine/Core/Jobs/ActionJob.cs

@@ -1,4 +1,6 @@
-namespace Staple.Jobs;
+using System;
+
+namespace Staple.Jobs;
 
 /// <summary>
 /// Job interface
@@ -9,4 +11,10 @@ public interface IJob
     /// Called to execute the job
     /// </summary>
     void Execute();
+
+    /// <summary>
+    /// Called when there's a failure with a job due to an exception
+    /// </summary>
+    /// <param name="e">The exception</param>
+    void Failure(Exception e);
 }

Engine/Core/Jobs/IJob.cs

@@ -1,4 +1,6 @@
 using System;
+using System.Collections;
+using System.Collections.Generic;
 using System.Threading.Tasks;
 
 namespace Staple.Jobs;
@@ -38,6 +40,18 @@ public readonly void Complete()
         task.Wait();
     }
 
+    /// <summary>
+    /// Waits for a set of jobs to complete
+    /// </summary>
+    /// <param name="jobs">The jobs to wawit</param>
+    public static void Complete(IEnumerable<JobHandle> jobs)
+    {
+        foreach(var job in jobs)
+        {
+            job.Complete();
+        }
+    }
+
     public override readonly bool Equals(object obj)
     {
         return obj is JobHandle handle && Equals(handle);

Engine/Core/Jobs/JobHandle.cs

@@ -55,6 +55,15 @@ public static JobHandle Schedule(IJob job)
             catch(Exception e)
             {
                 Log.Debug($"[JobScheduler] Failed to execute job {job.GetType().FullName}: {e}");
+
+                try
+                {
+                    job.Failure(e);
+                }
+                catch(Exception e2)
+                {
+                    Log.Debug($"[JobScheduler] Failed to execute failure handler for job {job.GetType().FullName}: {e2}");
+                }
             }
         });
 

Engine/Core/Jobs/JobSheduler.cs

@@ -16,6 +16,8 @@ internal class AppPlayer
 
     internal const bool printTypeCacheTypes = false;
 
+    private bool initialized = false;
+
     public AppPlayer(string[] args, bool shouldConsoleLog)
     {
         instance = this;
@@ -86,157 +88,170 @@ public void Create()
 
         renderWindow.OnInit = () =>
         {
-            AssetDatabase.Reload();
-
-            try
+            AssetDatabase.Reload(null, () =>
             {
-                var data = ResourceManager.instance.LoadFile("StapleAppIcon.png");
-
-                if(data != null)
+                try
                 {
-                    var rawInfo = Texture.LoadStandard(data, StandardTextureColorComponents.RGBA);
+                    var data = ResourceManager.instance.LoadFile("StapleAppIcon.png");
 
-                    if(rawInfo != null)
+                    if (data != null)
                     {
-                        var width = 256;
-                        var height = (int)(rawInfo.height / (float)rawInfo.width * 256);
+                        var rawInfo = Texture.LoadStandard(data, StandardTextureColorComponents.RGBA);
 
-                        if(rawInfo.Resize(width, height))
+                        if (rawInfo != null)
                         {
-                            renderWindow.window.SetIcon(rawInfo);
+                            var width = 256;
+                            var height = (int)(rawInfo.height / (float)rawInfo.width * 256);
+
+                            if (rawInfo.Resize(width, height))
+                            {
+                                renderWindow.window.SetIcon(rawInfo);
+                            }
                         }
                     }
                 }
-            }
-            catch(Exception)
-            {
-            }
+                catch (Exception)
+                {
+                }
 
-            Time.fixedDeltaTime = 1 / (float)AppSettings.Current.fixedTimeFrameRate;
-            Physics3D.PhysicsDeltaTime = 1 / (float)AppSettings.Current.physicsFrameRate;
+                Time.fixedDeltaTime = 1 / (float)AppSettings.Current.fixedTimeFrameRate;
+                Physics3D.PhysicsDeltaTime = 1 / (float)AppSettings.Current.physicsFrameRate;
 
-            bool hasFocus = renderWindow.window.IsFocused;
+                bool hasFocus = renderWindow.window.IsFocused;
 
-            if (AppSettings.Current.runInBackground == false && hasFocus == false)
-            {
-                ResetRendering(hasFocus);
-            }
+                if (AppSettings.Current.runInBackground == false && hasFocus == false)
+                {
+                    ResetRendering(hasFocus);
+                }
 
-            Scene.sceneList = ResourceManager.instance.LoadSceneList();
+                Scene.sceneList = ResourceManager.instance.LoadSceneList();
 
-            if (Scene.sceneList == null || Scene.sceneList.Count == 0)
-            {
-                Log.Error($"Failed to load scene list");
+                if (Scene.sceneList == null || Scene.sceneList.Count == 0)
+                {
+                    Log.Error($"Failed to load scene list");
 
-                renderWindow.shouldStop = true;
+                    renderWindow.shouldStop = true;
 
-                throw new Exception("Failed to load scene list");
-            }
+                    throw new Exception("Failed to load scene list");
+                }
 
-            Log.Info("Loaded scene list");
+                Log.Info("Loaded scene list");
 
-            if(Physics3D.ImplType != null && Physics3D.ImplType.IsAssignableTo(typeof(IPhysics3D)) == false)
-            {
-                Log.Error($"Failed to initialize physics: {Physics3D.ImplType.FullName} doesn't implement IPhysics3D");
+                if (Physics3D.ImplType != null && Physics3D.ImplType.IsAssignableTo(typeof(IPhysics3D)) == false)
+                {
+                    Log.Error($"Failed to initialize physics: {Physics3D.ImplType.FullName} doesn't implement IPhysics3D");
 
-                renderWindow.shouldStop = true;
+                    renderWindow.shouldStop = true;
 
-                throw new Exception("Failed to initialize physics");
-            }
+                    throw new Exception("Failed to initialize physics");
+                }
 
-            var physicsInstance = Physics3D.ImplType != null ? ObjectCreation.CreateObject<IPhysics3D>(Physics3D.ImplType) : null;
+                var physicsInstance = Physics3D.ImplType != null ? ObjectCreation.CreateObject<IPhysics3D>(Physics3D.ImplType) : null;
 
-            try
-            {
-                Physics3D.Instance = new Physics3D(physicsInstance);
-            }
-            catch (Exception e)
-            {
-                Log.Error(e.ToString());
+                try
+                {
+                    Physics3D.Instance = new Physics3D(physicsInstance);
+                }
+                catch (Exception e)
+                {
+                    Log.Error(e.ToString());
 
-                renderWindow.shouldStop = true;
+                    renderWindow.shouldStop = true;
 
-                throw new Exception("Failed to initialize physics");
-            }
+                    throw new Exception("Failed to initialize physics");
+                }
 
-            SubsystemManager.instance.RegisterSubsystem(RenderSystem.Instance, RenderSystem.Priority);
-            SubsystemManager.instance.RegisterSubsystem(EntitySystemManager.Instance, EntitySystemManager.Priority);
-            SubsystemManager.instance.RegisterSubsystem(AudioSystem.Instance, AudioSystem.Priority);
+                SubsystemManager.instance.RegisterSubsystem(RenderSystem.Instance, RenderSystem.Priority);
+                SubsystemManager.instance.RegisterSubsystem(EntitySystemManager.Instance, EntitySystemManager.Priority);
+                SubsystemManager.instance.RegisterSubsystem(AudioSystem.Instance, AudioSystem.Priority);
 
-            if (Physics3D.Instance != null)
-            {
-                SubsystemManager.instance.RegisterSubsystem(Physics3D.Instance, Physics3D.Priority);
-            }
+                if (Physics3D.Instance != null)
+                {
+                    SubsystemManager.instance.RegisterSubsystem(Physics3D.Instance, Physics3D.Priority);
+                }
 
-            void HandleTypes<T>(string caption, Func<Type, bool> check, Action<T> callback)
-            {
-                var types = TypeCache.AllTypes()
-                    .Where(x => check(x))
-                    .ToArray();
+                void HandleTypes<T>(string caption, Func<Type, bool> check, Action<T> callback)
+                {
+                    var types = TypeCache.AllTypes()
+                        .Where(x => check(x))
+                        .ToArray();
 
-                Log.Info($"Loading {types.Length} {caption}s");
+                    Log.Info($"Loading {types.Length} {caption}s");
 
-                foreach(var type in types)
-                {
-                    try
+                    foreach (var type in types)
                     {
-                        var instance = (T)Activator.CreateInstance(type);
-
-                        if (instance != null)
+                        try
                         {
-                            callback(instance);
-
-                            Log.Info($"Created {caption} {type.FullName}");
+                            var instance = (T)Activator.CreateInstance(type);
+
+                            if (instance != null)
+                            {
+                                callback(instance);
+
+                                Log.Info($"Created {caption} {type.FullName}");
+                            }
+                            else
+                            {
+                                Log.Info($"Failed to create {caption} {type.FullName}");
+                            }
                         }
-                        else
+                        catch (Exception e)
                         {
-                            Log.Info($"Failed to create {caption} {type.FullName}");
+                            Log.Warning($"Player: Failed to load {caption} {type.FullName}: {e}");
                         }
                     }
-                    catch (Exception e)
-                    {
-                        Log.Warning($"Player: Failed to load {caption} {type.FullName}: {e}");
-                    }
                 }
-            }
 
-            HandleTypes<IRenderSystem>("render system",
-                (x => typeof(IRenderSystem).IsAssignableFrom(x) && x != typeof(IRenderSystem)),
-                (instance => RenderSystem.Instance.RegisterSystem(instance)));
+                HandleTypes<IRenderSystem>("render system",
+                    (x => typeof(IRenderSystem).IsAssignableFrom(x) && x != typeof(IRenderSystem)),
+                    (instance => RenderSystem.Instance.RegisterSystem(instance)));
 
-            HandleTypes<object>("entity system",
-                (x => (typeof(IEntitySystemUpdate).IsAssignableFrom(x) && x != typeof(IEntitySystemUpdate)) ||
-                    (typeof(IEntitySystemFixedUpdate).IsAssignableFrom(x) && x != typeof(IEntitySystemFixedUpdate))),
-                (instance => EntitySystemManager.Instance.RegisterSystem(instance)));
+                HandleTypes<object>("entity system",
+                    (x => (typeof(IEntitySystemUpdate).IsAssignableFrom(x) && x != typeof(IEntitySystemUpdate)) ||
+                        (typeof(IEntitySystemFixedUpdate).IsAssignableFrom(x) && x != typeof(IEntitySystemFixedUpdate))),
+                    (instance => EntitySystemManager.Instance.RegisterSystem(instance)));
 
-            var scene = ResourceManager.instance.LoadScene(Scene.sceneList[0]);
+                var scene = ResourceManager.instance.LoadScene(Scene.sceneList[0]);
 
-            if (scene == null)
-            {
-                Log.Error($"Failed to load main scene");
+                if (scene == null)
+                {
+                    Log.Error($"Failed to load main scene");
 
-                renderWindow.shouldStop = true;
+                    renderWindow.shouldStop = true;
 
-                throw new Exception("Failed to load main scene");
-            }
+                    throw new Exception("Failed to load main scene");
+                }
+
+                Scene.SetActiveScene(scene);
 
-            Scene.SetActiveScene(scene);
+                Log.Info("Loaded first scene");
 
-            Log.Info("Loaded first scene");
+                Log.Info("Finished initializing");
 
-            Log.Info("Finished initializing");
+                initialized = true;
+            });
         };
 
         renderWindow.OnFixedUpdate = () =>
         {
+            if(initialized == false)
+            {
+                return;
+            }
+
             SubsystemManager.instance.Update(SubsystemType.FixedUpdate);
 
             EntitySystemManager.Instance.UpdateFixed();
         };
 
         renderWindow.OnUpdate = () =>
         {
-            if((AppSettings.Current?.allowFullscreenSwitch ?? true) && Input.GetKey(KeyCode.LeftAlt) && Input.GetKeyDown(KeyCode.Enter))
+            if (initialized == false)
+            {
+                return;
+            }
+
+            if ((AppSettings.Current?.allowFullscreenSwitch ?? true) && Input.GetKey(KeyCode.LeftAlt) && Input.GetKeyDown(KeyCode.Enter))
             {
                 Screen.SetResolution(Screen.Width, Screen.Height, Screen.WindowMode == WindowMode.Windowed ? WindowMode.BorderlessFullscreen : WindowMode.Windowed);
             }