502 lines
18 KiB
C++
502 lines
18 KiB
C++
#include <gtest/gtest.h>
|
|
|
|
#include <XCEngine/Components/GameObject.h>
|
|
#include <XCEngine/Components/MeshFilterComponent.h>
|
|
#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;
|
|
|
|
namespace {
|
|
|
|
Mesh* CreateTestMesh(const char* name, const char* path) {
|
|
auto* mesh = new Mesh();
|
|
IResource::ConstructParams params = {};
|
|
params.name = name;
|
|
params.path = path;
|
|
params.guid = ResourceGUID::Generate(path);
|
|
mesh->Initialize(params);
|
|
return mesh;
|
|
}
|
|
|
|
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 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>();
|
|
Mesh* mesh = CreateTestMesh("Quad", "Meshes/quad.mesh");
|
|
|
|
component->SetMesh(mesh);
|
|
|
|
EXPECT_EQ(component->GetMesh(), mesh);
|
|
EXPECT_EQ(component->GetMeshPath(), "Meshes/quad.mesh");
|
|
|
|
component->ClearMesh();
|
|
delete mesh;
|
|
}
|
|
|
|
TEST(MeshFilterComponent_Test, SerializeAndDeserializePreservesPath) {
|
|
MeshFilterComponent source;
|
|
source.SetMeshPath("builtin://meshes/cube");
|
|
|
|
std::stringstream stream;
|
|
source.Serialize(stream);
|
|
const std::string serialized = stream.str();
|
|
EXPECT_NE(serialized.find("meshRef="), std::string::npos);
|
|
EXPECT_NE(serialized.find("meshPath=builtin://meshes/cube;"), std::string::npos);
|
|
|
|
MeshFilterComponent target;
|
|
std::stringstream deserializeStream(serialized);
|
|
target.Deserialize(deserializeStream);
|
|
|
|
EXPECT_EQ(target.GetMeshPath(), "builtin://meshes/cube");
|
|
ASSERT_NE(target.GetMesh(), nullptr);
|
|
EXPECT_FALSE(target.GetMeshAssetRef().IsValid());
|
|
}
|
|
|
|
TEST(MeshFilterComponent_Test, DeserializeIgnoresPlainMeshPathWithoutAssetRef) {
|
|
MeshFilterComponent target;
|
|
|
|
std::stringstream stream("meshPath=Meshes/legacy.mesh;meshRef=;");
|
|
target.Deserialize(stream);
|
|
|
|
EXPECT_TRUE(target.GetMeshPath().empty());
|
|
EXPECT_EQ(target.GetMesh(), nullptr);
|
|
EXPECT_FALSE(target.GetMeshAssetRef().IsValid());
|
|
}
|
|
|
|
TEST(MeshFilterComponent_Test, SetMeshPathPreservesPathWithoutLoadedResource) {
|
|
MeshFilterComponent component;
|
|
|
|
component.SetMeshPath("Meshes/runtime.mesh");
|
|
|
|
EXPECT_EQ(component.GetMeshPath(), "Meshes/runtime.mesh");
|
|
EXPECT_EQ(component.GetMesh(), nullptr);
|
|
|
|
component.SetMeshPath("");
|
|
EXPECT_EQ(component.GetMeshPath(), "");
|
|
EXPECT_EQ(component.GetMesh(), nullptr);
|
|
}
|
|
|
|
TEST(MeshFilterComponent_Test, SetMeshAssetRefPreservesProjectSubAssetReference) {
|
|
namespace fs = std::filesystem;
|
|
|
|
ResourceManager& manager = ResourceManager::Get();
|
|
manager.Initialize();
|
|
|
|
const fs::path projectRoot = fs::temp_directory_path() / "xc_mesh_filter_asset_ref_test";
|
|
const fs::path assetsDir = projectRoot / "Assets";
|
|
const fs::path meshPath = assetsDir / "runtime.mesh";
|
|
|
|
fs::remove_all(projectRoot);
|
|
fs::create_directories(assetsDir);
|
|
{
|
|
std::ofstream meshFile(meshPath);
|
|
ASSERT_TRUE(meshFile.is_open());
|
|
meshFile << "placeholder";
|
|
}
|
|
|
|
manager.SetResourceRoot(projectRoot.string().c_str());
|
|
|
|
AssetRef meshRef;
|
|
ASSERT_TRUE(manager.TryGetAssetRef("Assets/runtime.mesh", ResourceType::Mesh, meshRef));
|
|
|
|
MeshFilterComponent component;
|
|
component.SetMeshAssetRef(meshRef);
|
|
|
|
EXPECT_TRUE(component.GetMeshAssetRef().IsValid());
|
|
EXPECT_EQ(component.GetMeshAssetRef().assetGuid, meshRef.assetGuid);
|
|
EXPECT_EQ(component.GetMeshAssetRef().localID, meshRef.localID);
|
|
EXPECT_EQ(component.GetMeshAssetRef().resourceType, meshRef.resourceType);
|
|
EXPECT_EQ(component.GetMeshPath(), "Assets/runtime.mesh");
|
|
|
|
std::stringstream stream;
|
|
component.Serialize(stream);
|
|
EXPECT_NE(stream.str().find("meshRef="), std::string::npos);
|
|
EXPECT_EQ(stream.str().find("meshRef=;"), std::string::npos);
|
|
|
|
manager.SetResourceRoot("");
|
|
manager.Shutdown();
|
|
fs::remove_all(projectRoot);
|
|
}
|
|
|
|
TEST(MeshFilterComponent_Test, DeferredSceneDeserializeLoadsMeshAsyncByPath) {
|
|
ResourceManager& manager = ResourceManager::Get();
|
|
manager.Initialize();
|
|
|
|
IResourceLoader* originalLoader = manager.GetLoader(ResourceType::Mesh);
|
|
FakeAsyncMeshLoader fakeLoader;
|
|
manager.RegisterLoader(&fakeLoader);
|
|
|
|
MeshFilterComponent target;
|
|
const auto pendingBeforeDeserialize = manager.GetAsyncPendingCount();
|
|
{
|
|
ResourceManager::ScopedDeferredSceneLoad deferredLoadScope;
|
|
EXPECT_TRUE(manager.IsDeferredSceneLoadEnabled());
|
|
std::stringstream stream("meshPath=test://meshes/async.mesh;meshRef=;");
|
|
target.Deserialize(stream);
|
|
}
|
|
|
|
EXPECT_EQ(target.GetMeshPath(), "test://meshes/async.mesh");
|
|
EXPECT_EQ(target.GetMesh(), nullptr);
|
|
EXPECT_GT(manager.GetAsyncPendingCount(), pendingBeforeDeserialize);
|
|
ASSERT_TRUE(PumpAsyncLoadsUntilIdle(manager));
|
|
ASSERT_NE(target.GetMesh(), nullptr);
|
|
EXPECT_EQ(target.GetMeshPath(), "test://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>();
|
|
Material* material0 = CreateTestMaterial("M0", "Materials/m0.mat");
|
|
Material* material1 = CreateTestMaterial("M1", "Materials/m1.mat");
|
|
|
|
component->SetMaterial(0, material0);
|
|
component->SetMaterial(1, material1);
|
|
component->SetCastShadows(false);
|
|
component->SetReceiveShadows(false);
|
|
component->SetRenderLayer(7);
|
|
|
|
ASSERT_EQ(component->GetMaterialCount(), 2u);
|
|
EXPECT_EQ(component->GetMaterial(0), material0);
|
|
EXPECT_EQ(component->GetMaterial(1), material1);
|
|
EXPECT_EQ(component->GetMaterialPaths()[0], "Materials/m0.mat");
|
|
EXPECT_EQ(component->GetMaterialPaths()[1], "Materials/m1.mat");
|
|
EXPECT_FALSE(component->GetCastShadows());
|
|
EXPECT_FALSE(component->GetReceiveShadows());
|
|
EXPECT_EQ(component->GetRenderLayer(), 7u);
|
|
|
|
component->ClearMaterials();
|
|
delete material0;
|
|
delete material1;
|
|
}
|
|
|
|
TEST(MeshRendererComponent_Test, SerializeAndDeserializePreservesMaterialPathsAndSettings) {
|
|
MeshRendererComponent source;
|
|
source.SetMaterialPath(0, "builtin://materials/default-primitive");
|
|
source.SetMaterialPath(1, "builtin://materials/default-primitive");
|
|
source.SetCastShadows(false);
|
|
source.SetReceiveShadows(true);
|
|
source.SetRenderLayer(3);
|
|
|
|
std::stringstream stream;
|
|
source.Serialize(stream);
|
|
const std::string serialized = stream.str();
|
|
EXPECT_NE(
|
|
serialized.find("materialPaths=builtin://materials/default-primitive|builtin://materials/default-primitive;"),
|
|
std::string::npos);
|
|
EXPECT_NE(serialized.find("materialRefs=|;"), std::string::npos);
|
|
|
|
MeshRendererComponent target;
|
|
std::stringstream deserializeStream(serialized);
|
|
target.Deserialize(deserializeStream);
|
|
|
|
ASSERT_EQ(target.GetMaterialCount(), 2u);
|
|
ASSERT_NE(target.GetMaterial(0), nullptr);
|
|
ASSERT_NE(target.GetMaterial(1), nullptr);
|
|
EXPECT_EQ(target.GetMaterialPaths()[0], "builtin://materials/default-primitive");
|
|
EXPECT_EQ(target.GetMaterialPaths()[1], "builtin://materials/default-primitive");
|
|
EXPECT_FALSE(target.GetCastShadows());
|
|
EXPECT_TRUE(target.GetReceiveShadows());
|
|
EXPECT_EQ(target.GetRenderLayer(), 3u);
|
|
}
|
|
|
|
TEST(MeshRendererComponent_Test, SerializeAndDeserializePreservesTrailingEmptyMaterialSlots) {
|
|
MeshRendererComponent source;
|
|
source.SetMaterialPath(0, "builtin://materials/default-primitive");
|
|
source.SetMaterialPath(1, "");
|
|
source.SetCastShadows(false);
|
|
source.SetReceiveShadows(true);
|
|
source.SetRenderLayer(9);
|
|
|
|
std::stringstream stream;
|
|
source.Serialize(stream);
|
|
const std::string serialized = stream.str();
|
|
EXPECT_NE(serialized.find("materialPaths=builtin://materials/default-primitive|;"), std::string::npos);
|
|
EXPECT_NE(serialized.find("materialRefs=|;"), std::string::npos);
|
|
|
|
MeshRendererComponent target;
|
|
std::stringstream deserializeStream(serialized);
|
|
target.Deserialize(deserializeStream);
|
|
|
|
ASSERT_EQ(target.GetMaterialCount(), 2u);
|
|
ASSERT_NE(target.GetMaterial(0), nullptr);
|
|
EXPECT_EQ(target.GetMaterial(1), nullptr);
|
|
EXPECT_EQ(target.GetMaterialPath(0), "builtin://materials/default-primitive");
|
|
EXPECT_EQ(target.GetMaterialPath(1), "");
|
|
EXPECT_FALSE(target.GetCastShadows());
|
|
EXPECT_TRUE(target.GetReceiveShadows());
|
|
EXPECT_EQ(target.GetRenderLayer(), 9u);
|
|
}
|
|
|
|
TEST(MeshRendererComponent_Test, SetMaterialPathPreservesPathWithoutLoadedResource) {
|
|
MeshRendererComponent component;
|
|
|
|
component.SetMaterialPath(1, "Materials/runtime.mat");
|
|
|
|
ASSERT_EQ(component.GetMaterialCount(), 2u);
|
|
EXPECT_EQ(component.GetMaterial(0), nullptr);
|
|
EXPECT_EQ(component.GetMaterial(1), nullptr);
|
|
EXPECT_EQ(component.GetMaterialPath(0), "");
|
|
EXPECT_EQ(component.GetMaterialPath(1), "Materials/runtime.mat");
|
|
|
|
component.SetMaterialPath(1, "");
|
|
EXPECT_EQ(component.GetMaterialPath(1), "");
|
|
EXPECT_EQ(component.GetMaterial(1), nullptr);
|
|
}
|
|
|
|
TEST(MeshRendererComponent_Test, SetMaterialAssetRefPreservesProjectSubAssetReference) {
|
|
namespace fs = std::filesystem;
|
|
|
|
ResourceManager& manager = ResourceManager::Get();
|
|
manager.Initialize();
|
|
|
|
const fs::path projectRoot = fs::temp_directory_path() / "xc_mesh_renderer_sub_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());
|
|
|
|
AssetRef materialRef;
|
|
ASSERT_TRUE(manager.TryGetAssetRef("Assets/runtime.material", ResourceType::Material, materialRef));
|
|
|
|
MeshRendererComponent component;
|
|
component.SetMaterialAssetRef(0, materialRef);
|
|
|
|
ASSERT_EQ(component.GetMaterialCount(), 1u);
|
|
EXPECT_TRUE(component.GetMaterialAssetRefs()[0].IsValid());
|
|
EXPECT_EQ(component.GetMaterialAssetRefs()[0].assetGuid, materialRef.assetGuid);
|
|
EXPECT_EQ(component.GetMaterialAssetRefs()[0].localID, materialRef.localID);
|
|
EXPECT_EQ(component.GetMaterialAssetRefs()[0].resourceType, materialRef.resourceType);
|
|
EXPECT_EQ(component.GetMaterialPath(0), "Assets/runtime.material");
|
|
ASSERT_NE(component.GetMaterial(0), nullptr);
|
|
|
|
std::stringstream stream;
|
|
component.Serialize(stream);
|
|
EXPECT_NE(stream.str().find("materialRefs="), std::string::npos);
|
|
EXPECT_EQ(stream.str().find("materialRefs=;"), std::string::npos);
|
|
|
|
manager.SetResourceRoot("");
|
|
manager.Shutdown();
|
|
fs::remove_all(projectRoot);
|
|
}
|
|
|
|
TEST(MeshRendererComponent_Test, DeserializeIgnoresPlainMaterialPathsWithoutAssetRefs) {
|
|
MeshRendererComponent target;
|
|
|
|
std::stringstream stream(
|
|
"materialPaths=Materials/legacy0.mat|;materialRefs=|;castShadows=0;receiveShadows=1;renderLayer=5;");
|
|
target.Deserialize(stream);
|
|
|
|
ASSERT_EQ(target.GetMaterialCount(), 2u);
|
|
EXPECT_EQ(target.GetMaterialPath(0), "");
|
|
EXPECT_EQ(target.GetMaterialPath(1), "");
|
|
EXPECT_EQ(target.GetMaterial(0), nullptr);
|
|
EXPECT_EQ(target.GetMaterial(1), nullptr);
|
|
EXPECT_FALSE(target.GetCastShadows());
|
|
EXPECT_TRUE(target.GetReceiveShadows());
|
|
EXPECT_EQ(target.GetRenderLayer(), 5u);
|
|
}
|
|
|
|
TEST(MeshRendererComponent_Test, SerializeAndDeserializeLoadsProjectMaterialByAssetRef) {
|
|
namespace fs = std::filesystem;
|
|
|
|
ResourceManager& manager = ResourceManager::Get();
|
|
manager.Initialize();
|
|
|
|
const fs::path projectRoot = fs::temp_directory_path() / "xc_mesh_renderer_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");
|
|
|
|
ASSERT_EQ(source.GetMaterialCount(), 1u);
|
|
ASSERT_NE(source.GetMaterial(0), nullptr);
|
|
ASSERT_EQ(source.GetMaterialPath(0), "Assets/runtime.material");
|
|
ASSERT_EQ(source.GetMaterialAssetRefs().size(), 1u);
|
|
EXPECT_TRUE(source.GetMaterialAssetRefs()[0].IsValid());
|
|
|
|
std::stringstream stream;
|
|
source.Serialize(stream);
|
|
const std::string serialized = stream.str();
|
|
EXPECT_NE(serialized.find("materialPaths=;"), std::string::npos);
|
|
EXPECT_NE(serialized.find("materialRefs="), std::string::npos);
|
|
EXPECT_EQ(serialized.find("materialRefs=;"), std::string::npos);
|
|
|
|
std::stringstream deserializeStream(serialized);
|
|
MeshRendererComponent target;
|
|
target.Deserialize(deserializeStream);
|
|
|
|
ASSERT_EQ(target.GetMaterialCount(), 1u);
|
|
EXPECT_EQ(target.GetMaterialPath(0), "Assets/runtime.material");
|
|
ASSERT_NE(target.GetMaterial(0), nullptr);
|
|
EXPECT_TRUE(target.GetMaterialAssetRefs()[0].IsValid());
|
|
|
|
manager.SetResourceRoot("");
|
|
manager.Shutdown();
|
|
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;
|
|
const auto pendingBeforeDeserialize = manager.GetAsyncPendingCount();
|
|
{
|
|
ResourceManager::ScopedDeferredSceneLoad deferredLoadScope;
|
|
EXPECT_TRUE(manager.IsDeferredSceneLoadEnabled());
|
|
std::stringstream deserializeStream(serializedStream.str());
|
|
target.Deserialize(deserializeStream);
|
|
EXPECT_EQ(manager.GetAsyncPendingCount(), pendingBeforeDeserialize);
|
|
}
|
|
|
|
ASSERT_EQ(target.GetMaterialCount(), 1u);
|
|
EXPECT_EQ(target.GetMaterialPath(0), "Assets/runtime.material");
|
|
EXPECT_EQ(target.GetMaterial(0), nullptr);
|
|
EXPECT_GT(manager.GetAsyncPendingCount(), pendingBeforeDeserialize);
|
|
|
|
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
|