Add volume renderer extraction stage 5

tests/Components/test_volume_renderer_component.cpp

@@ -0,0 +1,171 @@
+#include <gtest/gtest.h>
+
+#include <XCEngine/Components/GameObject.h>
+#include <XCEngine/Components/VolumeRendererComponent.h>
+#include <XCEngine/Core/Asset/IResource.h>
+#include <XCEngine/Core/Asset/ResourceManager.h>
+#include <XCEngine/Core/IO/IResourceLoader.h>
+#include <XCEngine/Core/Math/Bounds.h>
+#include <XCEngine/Resources/Material/Material.h>
+#include <XCEngine/Resources/Volume/VolumeField.h>
+
+#include <chrono>
+#include <sstream>
+#include <thread>
+
+using namespace XCEngine::Components;
+using namespace XCEngine::Math;
+using namespace XCEngine::Resources;
+
+namespace {
+
+VolumeField* CreateTestVolumeField(const char* name, const char* path) {
+    auto* volumeField = new VolumeField();
+    IResource::ConstructParams params = {};
+    params.name = name;
+    params.path = path;
+    params.guid = ResourceGUID::Generate(path);
+    volumeField->Initialize(params);
+
+    const unsigned char payload[8] = { 1, 3, 5, 7, 9, 11, 13, 15 };
+    EXPECT_TRUE(volumeField->Create(
+        VolumeStorageKind::NanoVDB,
+        payload,
+        sizeof(payload),
+        Bounds(Vector3::Zero(), Vector3::One()),
+        Vector3(0.5f, 0.5f, 0.5f)));
+    return volumeField;
+}
+
+Material* CreateTestMaterial(const char* name, const char* path) {
+    auto* material = new Material();
+    IResource::ConstructParams params = {};
+    params.name = name;
+    params.path = path;
+    params.guid = ResourceGUID::Generate(path);
+    material->Initialize(params);
+    return material;
+}
+
+class FakeAsyncVolumeFieldLoader : public IResourceLoader {
+public:
+    ResourceType GetResourceType() const override { return ResourceType::VolumeField; }
+
+    XCEngine::Containers::Array<XCEngine::Containers::String> GetSupportedExtensions() const override {
+        XCEngine::Containers::Array<XCEngine::Containers::String> extensions;
+        extensions.PushBack("nvdb");
+        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;
+        return LoadResult(CreateTestVolumeField("AsyncVolume", path.CStr()));
+    }
+
+    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(VolumeRendererComponent_Test, SetResourcesCachesHandlesPathsAndFlags) {
+    GameObject gameObject("VolumeHolder");
+    auto* component = gameObject.AddComponent<VolumeRendererComponent>();
+    VolumeField* volumeField = CreateTestVolumeField("Cloud", "Volumes/cloud.nvdb");
+    Material* material = CreateTestMaterial("VolumeMaterial", "Materials/volume.mat");
+
+    component->SetVolumeField(volumeField);
+    component->SetMaterial(material);
+    component->SetCastShadows(false);
+    component->SetReceiveShadows(false);
+
+    EXPECT_EQ(component->GetVolumeField(), volumeField);
+    EXPECT_EQ(component->GetVolumeFieldPath(), "Volumes/cloud.nvdb");
+    EXPECT_EQ(component->GetMaterial(), material);
+    EXPECT_EQ(component->GetMaterialPath(), "Materials/volume.mat");
+    EXPECT_FALSE(component->GetCastShadows());
+    EXPECT_FALSE(component->GetReceiveShadows());
+
+    component->ClearVolumeField();
+    component->ClearMaterial();
+    delete volumeField;
+    delete material;
+}
+
+TEST(VolumeRendererComponent_Test, SerializeAndDeserializePreservesVirtualPathsAndFlags) {
+    VolumeRendererComponent source;
+    source.SetVolumeFieldPath("test://volumes/cloud.nvdb");
+    source.SetMaterialPath("test://materials/volume.material");
+    source.SetCastShadows(false);
+    source.SetReceiveShadows(true);
+
+    std::stringstream stream;
+    source.Serialize(stream);
+    const std::string serialized = stream.str();
+    EXPECT_NE(serialized.find("volumePath=test://volumes/cloud.nvdb;"), std::string::npos);
+    EXPECT_NE(serialized.find("materialPath=test://materials/volume.material;"), std::string::npos);
+    EXPECT_NE(serialized.find("castShadows=0;"), std::string::npos);
+    EXPECT_NE(serialized.find("receiveShadows=1;"), std::string::npos);
+
+    VolumeRendererComponent target;
+    std::stringstream deserializeStream(serialized);
+    target.Deserialize(deserializeStream);
+
+    EXPECT_EQ(target.GetVolumeFieldPath(), "test://volumes/cloud.nvdb");
+    EXPECT_EQ(target.GetMaterialPath(), "test://materials/volume.material");
+    EXPECT_FALSE(target.GetCastShadows());
+    EXPECT_TRUE(target.GetReceiveShadows());
+    EXPECT_FALSE(target.GetVolumeFieldAssetRef().IsValid());
+    EXPECT_FALSE(target.GetMaterialAssetRef().IsValid());
+}
+
+TEST(VolumeRendererComponent_Test, DeferredSceneDeserializeLoadsVolumeFieldAsyncByPath) {
+    ResourceManager& manager = ResourceManager::Get();
+    manager.Initialize();
+
+    IResourceLoader* originalLoader = manager.GetLoader(ResourceType::VolumeField);
+    FakeAsyncVolumeFieldLoader fakeLoader;
+    manager.RegisterLoader(&fakeLoader);
+
+    VolumeRendererComponent target;
+    const auto pendingBeforeDeserialize = manager.GetAsyncPendingCount();
+    {
+        ResourceManager::ScopedDeferredSceneLoad deferredLoadScope;
+        EXPECT_TRUE(manager.IsDeferredSceneLoadEnabled());
+        std::stringstream stream(
+            "volumePath=test://volumes/async.nvdb;volumeRef=;materialRef=;castShadows=1;receiveShadows=1;");
+        target.Deserialize(stream);
+    }
+
+    EXPECT_EQ(target.GetVolumeFieldPath(), "test://volumes/async.nvdb");
+    EXPECT_EQ(target.GetVolumeField(), nullptr);
+    EXPECT_GT(manager.GetAsyncPendingCount(), pendingBeforeDeserialize);
+    ASSERT_TRUE(PumpAsyncLoadsUntilIdle(manager));
+    ASSERT_NE(target.GetVolumeField(), nullptr);
+    EXPECT_EQ(target.GetVolumeFieldPath(), "test://volumes/async.nvdb");
+    EXPECT_EQ(target.GetVolumeField()->GetStorageKind(), VolumeStorageKind::NanoVDB);
+
+    manager.RegisterLoader(originalLoader);
+    manager.Shutdown();
+}
+
+} // namespace