Add deferred async scene asset loading

engine/src/Core/Asset/AssetDatabase.cpp

@@ -1,6 +1,7 @@
 #include <XCEngine/Core/Asset/AssetDatabase.h>
 
 #include <XCEngine/Core/Asset/ArtifactFormats.h>
+#include <XCEngine/Debug/Logger.h>
 #include <XCEngine/Resources/Mesh/MeshLoader.h>
 #include <XCEngine/Resources/Texture/TextureLoader.h>
 
@@ -23,6 +24,17 @@ std::string ToStdString(const Containers::String& value) {
     return std::string(value.CStr());
 }
 
+bool ShouldTraceAssetPath(const Containers::String& path) {
+    const std::string text = ToStdString(path);
+    return text.rfind("builtin://", 0) == 0 ||
+           text.find("backpack") != std::string::npos ||
+           text.find("New Material.mat") != std::string::npos;
+}
+
+bool HasVirtualPathScheme(const Containers::String& value) {
+    return ToStdString(value).find("://") != std::string::npos;
+}
+
 Containers::String ToContainersString(const std::string& value) {
     return Containers::String(value.c_str());
 }
@@ -368,6 +380,10 @@ bool AssetDatabase::ResolvePath(const Containers::String& requestPath,
         return false;
     }
 
+    if (HasVirtualPathScheme(requestPath)) {
+        return false;
+    }
+
     fs::path inputPath(requestPath.CStr());
     if (inputPath.is_absolute()) {
         outAbsolutePath = NormalizePathString(inputPath);
@@ -863,11 +879,24 @@ bool AssetDatabase::EnsureArtifact(const Containers::String& requestPath,
     Containers::String absolutePath;
     Containers::String relativePath;
     if (!ResolvePath(requestPath, absolutePath, relativePath) || relativePath.Empty()) {
+        if (ShouldTraceAssetPath(requestPath)) {
+            Debug::Logger::Get().Info(
+                Debug::LogCategory::FileSystem,
+                Containers::String("[AssetDatabase] EnsureArtifact unresolved path=") + requestPath);
+        }
         return false;
     }
 
     const fs::path absoluteFsPath(absolutePath.CStr());
     if (!fs::exists(absoluteFsPath)) {
+        if (ShouldTraceAssetPath(requestPath)) {
+            Debug::Logger::Get().Info(
+                Debug::LogCategory::FileSystem,
+                Containers::String("[AssetDatabase] EnsureArtifact missing source path=") +
+                requestPath +
+                " absolute=" +
+                absolutePath);
+        }
         return false;
     }
 
@@ -876,8 +905,31 @@ bool AssetDatabase::EnsureArtifact(const Containers::String& requestPath,
         return false;
     }
 
+    if (ShouldTraceAssetPath(requestPath)) {
+        Debug::Logger::Get().Info(
+            Debug::LogCategory::FileSystem,
+            Containers::String("[AssetDatabase] EnsureArtifact source path=") +
+            requestPath +
+            " guid=" +
+            sourceRecord.guid.ToString() +
+            " importer=" +
+            sourceRecord.importerName +
+            " relative=" +
+            sourceRecord.relativePath);
+    }
+
     const ResourceType primaryType = GetPrimaryResourceTypeForImporter(sourceRecord.importerName);
     if (primaryType == ResourceType::Unknown || primaryType != requestedType) {
+        if (ShouldTraceAssetPath(requestPath)) {
+            Debug::Logger::Get().Info(
+                Debug::LogCategory::FileSystem,
+                Containers::String("[AssetDatabase] EnsureArtifact type-mismatch path=") +
+                requestPath +
+                " requested=" +
+                GetResourceTypeName(requestedType) +
+                " importerType=" +
+                GetResourceTypeName(primaryType));
+        }
         return false;
     }
 
@@ -888,8 +940,18 @@ bool AssetDatabase::EnsureArtifact(const Containers::String& requestPath,
     }
 
     if (ShouldReimport(sourceRecord, artifactRecord)) {
+        if (ShouldTraceAssetPath(requestPath)) {
+            Debug::Logger::Get().Info(
+                Debug::LogCategory::FileSystem,
+                Containers::String("[AssetDatabase] EnsureArtifact reimport path=") + requestPath);
+        }
         ArtifactRecord rebuiltRecord;
         if (!ImportAsset(sourceRecord, rebuiltRecord)) {
+            if (ShouldTraceAssetPath(requestPath)) {
+                Debug::Logger::Get().Error(
+                    Debug::LogCategory::FileSystem,
+                    Containers::String("[AssetDatabase] EnsureArtifact reimport failed path=") + requestPath);
+            }
             return false;
         }
 
@@ -914,6 +976,17 @@ bool AssetDatabase::EnsureArtifact(const Containers::String& requestPath,
     outAsset.artifactDirectory = NormalizePathString(fs::path(m_projectRoot.CStr()) / artifactRecord->artifactDirectory.CStr());
     outAsset.artifactMainPath = NormalizePathString(fs::path(m_projectRoot.CStr()) / artifactRecord->mainArtifactPath.CStr());
     outAsset.mainLocalID = artifactRecord->mainLocalID;
+
+    if (ShouldTraceAssetPath(requestPath)) {
+        Debug::Logger::Get().Info(
+            Debug::LogCategory::FileSystem,
+            Containers::String("[AssetDatabase] EnsureArtifact ready path=") +
+            requestPath +
+            " artifactKey=" +
+            artifactRecord->artifactKey +
+            " artifact=" +
+            outAsset.artifactMainPath);
+    }
     return true;
 }