Add deferred async scene asset loading

tests/Components/test_mesh_render_components.cpp

@@ -5,12 +5,15 @@
 #include <XCEngine/Components/MeshRendererComponent.h>
 #include <XCEngine/Core/Asset/IResource.h>
 #include <XCEngine/Core/Asset/ResourceManager.h>
+#include <XCEngine/Core/IO/IResourceLoader.h>
 #include <XCEngine/Resources/Material/Material.h>
 #include <XCEngine/Resources/Mesh/Mesh.h>
 
 #include <filesystem>
 #include <fstream>
 #include <sstream>
+#include <chrono>
+#include <thread>
 
 using namespace XCEngine::Components;
 using namespace XCEngine::Resources;
@@ -37,6 +40,56 @@ Material* CreateTestMaterial(const char* name, const char* path) {
     return material;
 }
 
+class FakeAsyncMeshLoader : public IResourceLoader {
+public:
+    ResourceType GetResourceType() const override { return ResourceType::Mesh; }
+
+    XCEngine::Containers::Array<XCEngine::Containers::String> GetSupportedExtensions() const override {
+        XCEngine::Containers::Array<XCEngine::Containers::String> extensions;
+        extensions.PushBack("mesh");
+        return extensions;
+    }
+
+    bool CanLoad(const XCEngine::Containers::String& path) const override {
+        (void)path;
+        return true;
+    }
+
+    LoadResult Load(const XCEngine::Containers::String& path,
+                    const ImportSettings* settings = nullptr) override {
+        (void)settings;
+
+        auto* mesh = new Mesh();
+        IResource::ConstructParams params = {};
+        params.name = "AsyncMesh";
+        params.path = path;
+        params.guid = ResourceGUID::Generate(path);
+        mesh->Initialize(params);
+
+        const StaticMeshVertex vertices[3] = {};
+        const XCEngine::Core::uint32 indices[3] = {0, 1, 2};
+        mesh->SetVertexData(vertices, sizeof(vertices), 3, sizeof(StaticMeshVertex), VertexAttribute::Position);
+        mesh->SetIndexData(indices, sizeof(indices), 3, true);
+        return LoadResult(mesh);
+    }
+
+    ImportSettings* GetDefaultSettings() const override {
+        return nullptr;
+    }
+};
+
+bool PumpAsyncLoadsUntilIdle(ResourceManager& manager,
+                             std::chrono::milliseconds timeout = std::chrono::milliseconds(2000)) {
+    const auto deadline = std::chrono::steady_clock::now() + timeout;
+    while (manager.IsAsyncLoading() && std::chrono::steady_clock::now() < deadline) {
+        manager.UpdateAsyncLoads();
+        std::this_thread::sleep_for(std::chrono::milliseconds(5));
+    }
+
+    manager.UpdateAsyncLoads();
+    return !manager.IsAsyncLoading();
+}
+
 TEST(MeshFilterComponent_Test, SetMeshCachesResourceAndPath) {
     GameObject gameObject("MeshHolder");
     auto* component = gameObject.AddComponent<MeshFilterComponent>();
@@ -82,6 +135,33 @@ TEST(MeshFilterComponent_Test, SetMeshPathPreservesPathWithoutLoadedResource) {
     EXPECT_EQ(component.GetMesh(), nullptr);
 }
 
+TEST(MeshFilterComponent_Test, DeferredSceneDeserializeLoadsMeshAsyncByPath) {
+    ResourceManager& manager = ResourceManager::Get();
+    manager.Initialize();
+
+    IResourceLoader* originalLoader = manager.GetLoader(ResourceType::Mesh);
+    FakeAsyncMeshLoader fakeLoader;
+    manager.RegisterLoader(&fakeLoader);
+
+    MeshFilterComponent target;
+    {
+        ResourceManager::ScopedDeferredSceneLoad deferredLoadScope;
+        EXPECT_TRUE(manager.IsDeferredSceneLoadEnabled());
+        std::stringstream stream("mesh=Meshes/async.mesh;meshRef=;");
+        target.Deserialize(stream);
+        EXPECT_GT(manager.GetAsyncPendingCount(), 0u);
+    }
+
+    EXPECT_EQ(target.GetMeshPath(), "Meshes/async.mesh");
+    ASSERT_TRUE(PumpAsyncLoadsUntilIdle(manager));
+    ASSERT_NE(target.GetMesh(), nullptr);
+    EXPECT_EQ(target.GetMeshPath(), "Meshes/async.mesh");
+    EXPECT_EQ(target.GetMesh()->GetVertexCount(), 3u);
+
+    manager.RegisterLoader(originalLoader);
+    manager.Shutdown();
+}
+
 TEST(MeshRendererComponent_Test, SetMaterialsKeepsSlotsAndFlags) {
     GameObject gameObject("RendererHolder");
     auto* component = gameObject.AddComponent<MeshRendererComponent>();
@@ -237,4 +317,58 @@ TEST(MeshRendererComponent_Test, SerializeAndDeserializeLoadsProjectMaterialByAs
     fs::remove_all(projectRoot);
 }
 
+TEST(MeshRendererComponent_Test, DeferredSceneDeserializeLoadsProjectMaterialAsync) {
+    namespace fs = std::filesystem;
+
+    ResourceManager& manager = ResourceManager::Get();
+    manager.Initialize();
+
+    const fs::path projectRoot = fs::temp_directory_path() / "xc_mesh_renderer_async_asset_ref_test";
+    const fs::path assetsDir = projectRoot / "Assets";
+    const fs::path materialPath = assetsDir / "runtime.material";
+
+    fs::remove_all(projectRoot);
+    fs::create_directories(assetsDir);
+
+    {
+        std::ofstream materialFile(materialPath);
+        ASSERT_TRUE(materialFile.is_open());
+        materialFile << "{\n";
+        materialFile << "  \"renderQueue\": \"geometry\",\n";
+        materialFile << "  \"renderState\": {\n";
+        materialFile << "    \"cull\": \"back\"\n";
+        materialFile << "  }\n";
+        materialFile << "}";
+    }
+
+    manager.SetResourceRoot(projectRoot.string().c_str());
+
+    MeshRendererComponent source;
+    source.SetMaterialPath(0, "Assets/runtime.material");
+
+    std::stringstream serializedStream;
+    source.Serialize(serializedStream);
+
+    MeshRendererComponent target;
+    {
+        ResourceManager::ScopedDeferredSceneLoad deferredLoadScope;
+        EXPECT_TRUE(manager.IsDeferredSceneLoadEnabled());
+        std::stringstream deserializeStream(serializedStream.str());
+        target.Deserialize(deserializeStream);
+        EXPECT_GT(manager.GetAsyncPendingCount(), 0u);
+    }
+
+    ASSERT_EQ(target.GetMaterialCount(), 1u);
+    EXPECT_EQ(target.GetMaterialPath(0), "Assets/runtime.material");
+
+    ASSERT_TRUE(PumpAsyncLoadsUntilIdle(manager));
+    ASSERT_NE(target.GetMaterial(0), nullptr);
+    EXPECT_EQ(target.GetMaterialPath(0), "Assets/runtime.material");
+    EXPECT_TRUE(target.GetMaterialAssetRefs()[0].IsValid());
+
+    manager.SetResourceRoot("");
+    manager.Shutdown();
+    fs::remove_all(projectRoot);
+}
+
 } // namespace