xuanchi/XCEngine
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Split mesh artifacts into material and texture artifacts

Browse Source
This commit is contained in:
ssdfasd
2026-04-02 19:36:16 +08:00
parent b2d0570b1b
commit e30f5d5ffa
12 changed files with 939 additions and 135 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
tests/Resources/Material/CMakeLists.txt
View File

@@ -27,5 +27,9 @@ target_include_directories(material_tests PRIVATE
${CMAKE_SOURCE_DIR}/tests/Fixtures
)
target_compile_definitions(material_tests PRIVATE
XCENGINE_TEST_FIXTURES_DIR="${CMAKE_SOURCE_DIR}/tests/Fixtures"
)
include(GoogleTest)
gtest_discover_tests(material_tests)

132
tests/Resources/Material/test_material_loader.cpp
View File

@@ -1,18 +1,46 @@
#include <gtest/gtest.h>
#include <XCEngine/Core/Asset/ArtifactFormats.h>
#include <XCEngine/Core/Asset/AssetDatabase.h>
#include <XCEngine/Resources/Material/MaterialLoader.h>
#include <XCEngine/Core/Asset/ResourceManager.h>
#include <XCEngine/Core/Asset/ResourceTypes.h>
#include <XCEngine/Core/Containers/Array.h>
#include <chrono>
#include <cstdio>
#include <filesystem>
#include <fstream>
#include <thread>
using namespace XCEngine::Resources;
using namespace XCEngine::Containers;
namespace {
std::string GetMeshFixturePath(const char* fileName) {
return (std::filesystem::path(XCENGINE_TEST_FIXTURES_DIR) / "Resources" / "Mesh" / fileName).string();
}
void WriteArtifactString(std::ofstream& output, const XCEngine::Containers::String& value) {
const XCEngine::Core::uint32 length = static_cast<XCEngine::Core::uint32>(value.Length());
output.write(reinterpret_cast<const char*>(&length), sizeof(length));
if (length > 0) {
output.write(value.CStr(), length);
}
}
bool PumpAsyncLoadsUntilIdle(ResourceManager& manager,
std::chrono::milliseconds timeout = std::chrono::milliseconds(4000)) {
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(MaterialLoader, GetResourceType) {
MaterialLoader loader;
EXPECT_EQ(loader.GetResourceType(), ResourceType::Material);
@@ -28,6 +56,7 @@ TEST(MaterialLoader, CanLoad) {
MaterialLoader loader;
EXPECT_TRUE(loader.CanLoad("test.mat"));
EXPECT_TRUE(loader.CanLoad("test.json"));
EXPECT_TRUE(loader.CanLoad("test.xcmat"));
EXPECT_FALSE(loader.CanLoad("test.txt"));
EXPECT_FALSE(loader.CanLoad("test.png"));
}
@@ -184,4 +213,107 @@ TEST(MaterialLoader, ResourceManagerLoadsRelativeMaterialFromResourceRoot) {
manager.Shutdown();
}
TEST(MaterialLoader, AssetDatabaseCreatesMaterialArtifact) {
namespace fs = std::filesystem;
const fs::path projectRoot = fs::temp_directory_path() / "xc_material_artifact_test";
const fs::path assetsDir = projectRoot / "Assets";
const fs::path materialPath = assetsDir / "relative.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 << "}";
}
AssetDatabase database;
database.Initialize(projectRoot.string().c_str());
AssetDatabase::ResolvedAsset resolvedAsset;
ASSERT_TRUE(database.EnsureArtifact("Assets/relative.material", ResourceType::Material, resolvedAsset));
EXPECT_TRUE(resolvedAsset.artifactReady);
EXPECT_EQ(fs::path(resolvedAsset.artifactMainPath.CStr()).extension().string(), ".xcmat");
EXPECT_TRUE(fs::exists(resolvedAsset.artifactMainPath.CStr()));
database.Shutdown();
fs::remove_all(projectRoot);
}
TEST(MaterialLoader, LoadMaterialArtifactDefersTexturePayloadUntilRequested) {
namespace fs = std::filesystem;
ResourceManager& manager = ResourceManager::Get();
manager.Initialize();
const fs::path projectRoot = fs::temp_directory_path() / "xc_material_xcmat_lazy_texture_test";
const fs::path assetsDir = projectRoot / "Assets";
const fs::path libraryDir = projectRoot / "Library" / "Manual";
const fs::path materialArtifactPath = libraryDir / "test.xcmat";
fs::remove_all(projectRoot);
fs::create_directories(assetsDir);
fs::create_directories(libraryDir);
fs::copy_file(
GetMeshFixturePath("checker.bmp"),
assetsDir / "checker.bmp",
fs::copy_options::overwrite_existing);
{
std::ofstream output(materialArtifactPath, std::ios::binary | std::ios::trunc);
ASSERT_TRUE(output.is_open());
MaterialArtifactFileHeader fileHeader;
output.write(reinterpret_cast<const char*>(&fileHeader), sizeof(fileHeader));
WriteArtifactString(output, "LazyMaterial");
WriteArtifactString(output, "Assets/lazy.material");
WriteArtifactString(output, "");
WriteArtifactString(output, "");
MaterialArtifactHeader header;
header.renderQueue = static_cast<XCEngine::Core::int32>(MaterialRenderQueue::Geometry);
header.textureBindingCount = 1;
output.write(reinterpret_cast<const char*>(&header), sizeof(header));
WriteArtifactString(output, "baseColorTexture");
WriteArtifactString(output, "Assets/checker.bmp");
}
manager.SetResourceRoot(projectRoot.string().c_str());
MaterialLoader loader;
LoadResult result = loader.Load("Library/Manual/test.xcmat");
ASSERT_TRUE(result);
ASSERT_NE(result.resource, nullptr);
auto* material = static_cast<Material*>(result.resource);
ASSERT_NE(material, nullptr);
EXPECT_EQ(material->GetTextureBindingCount(), 1u);
EXPECT_EQ(
fs::path(material->GetTextureBindingPath(0).CStr()).lexically_normal().generic_string(),
(projectRoot / "Assets" / "checker.bmp").lexically_normal().generic_string());
const ResourceHandle<Texture> initialTexture = material->GetTexture("baseColorTexture");
EXPECT_FALSE(initialTexture.IsValid());
EXPECT_GT(manager.GetAsyncPendingCount(), 0u);
ASSERT_TRUE(PumpAsyncLoadsUntilIdle(manager));
const ResourceHandle<Texture> loadedTexture = material->GetTexture("baseColorTexture");
ASSERT_TRUE(loadedTexture.IsValid());
EXPECT_EQ(loadedTexture->GetWidth(), 2u);
EXPECT_EQ(loadedTexture->GetHeight(), 2u);
delete material;
manager.SetResourceRoot("");
manager.Shutdown();
fs::remove_all(projectRoot);
}
} // namespace

129
tests/Resources/Mesh/test_mesh_loader.cpp
View File

@@ -1,6 +1,7 @@
#include <gtest/gtest.h>
#include <XCEngine/Core/Asset/AssetDatabase.h>
#include <XCEngine/Core/Asset/ResourceManager.h>
#include <XCEngine/Resources/Material/MaterialLoader.h>
#include <XCEngine/Resources/Mesh/MeshLoader.h>
#include <XCEngine/Resources/Mesh/MeshImportSettings.h>
#include <XCEngine/Resources/Material/Material.h>
@@ -21,6 +22,35 @@ std::string GetMeshFixturePath(const char* fileName) {
return (std::filesystem::path(XCENGINE_TEST_FIXTURES_DIR) / "Resources" / "Mesh" / fileName).string();
}
XCEngine::Core::uint32 GetFirstSectionMaterialIndex(const Mesh& mesh) {
if (mesh.GetSections().Empty()) {
return 0;
}
return mesh.GetSections()[0].materialID;
}
Material* GetFirstSectionMaterial(Mesh& mesh) {
const XCEngine::Core::uint32 materialIndex = GetFirstSectionMaterialIndex(mesh);
if (materialIndex >= mesh.GetMaterials().Size()) {
return nullptr;
}
return mesh.GetMaterial(materialIndex);
}
bool PumpAsyncLoadsUntilIdle(ResourceManager& manager,
std::chrono::milliseconds timeout = std::chrono::milliseconds(4000)) {
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(MeshLoader, GetResourceType) {
MeshLoader loader;
EXPECT_EQ(loader.GetResourceType(), ResourceType::Mesh);
@@ -151,6 +181,9 @@ TEST(MeshLoader, AssetDatabaseCreatesModelArtifactAndReusesItWithoutReimport) {
namespace fs = std::filesystem;
using namespace std::chrono_literals;
ResourceManager& manager = ResourceManager::Get();
manager.Initialize();
const fs::path projectRoot = fs::temp_directory_path() / "xc_mesh_library_cache_test";
const fs::path assetsDir = projectRoot / "Assets";
@@ -166,6 +199,22 @@ TEST(MeshLoader, AssetDatabaseCreatesModelArtifactAndReusesItWithoutReimport) {
assetsDir / "checker.bmp",
fs::copy_options::overwrite_existing);
MeshLoader sourceMeshLoader;
LoadResult sourceMeshResult =
sourceMeshLoader.Load((assetsDir / "textured_triangle.obj").string().c_str());
ASSERT_TRUE(sourceMeshResult);
ASSERT_NE(sourceMeshResult.resource, nullptr);
auto* sourceMesh = static_cast<Mesh*>(sourceMeshResult.resource);
ASSERT_NE(sourceMesh, nullptr);
ASSERT_GE(sourceMesh->GetMaterials().Size(), 1u);
Material* sourceSectionMaterial = GetFirstSectionMaterial(*sourceMesh);
ASSERT_NE(sourceSectionMaterial, nullptr);
const XCEngine::Core::uint32 sourceMaterialIndex = GetFirstSectionMaterialIndex(*sourceMesh);
EXPECT_EQ(sourceSectionMaterial->GetTextureBindingCount(), 1u);
EXPECT_EQ(sourceSectionMaterial->GetTextureBindingName(0), "baseColorTexture");
EXPECT_FALSE(sourceSectionMaterial->GetTextureBindingPath(0).Empty());
delete sourceMesh;
AssetDatabase database;
database.Initialize(projectRoot.string().c_str());
@@ -177,8 +226,54 @@ TEST(MeshLoader, AssetDatabaseCreatesModelArtifactAndReusesItWithoutReimport) {
EXPECT_TRUE(fs::exists(projectRoot / "Library" / "SourceAssetDB" / "assets.db"));
EXPECT_TRUE(fs::exists(projectRoot / "Library" / "ArtifactDB" / "artifacts.db"));
EXPECT_TRUE(fs::exists(firstResolve.artifactMainPath.CStr()));
EXPECT_TRUE(fs::exists((fs::path(firstResolve.artifactDirectory.CStr()) /
("material_" + std::to_string(sourceMaterialIndex) + ".xcmat"))));
EXPECT_TRUE(fs::exists((fs::path(firstResolve.artifactDirectory.CStr()) / "texture_0.xctex")));
MaterialLoader materialLoader;
LoadResult materialArtifactResult =
materialLoader.Load((fs::path(firstResolve.artifactDirectory.CStr()) /
("material_" + std::to_string(sourceMaterialIndex) + ".xcmat")).string().c_str());
ASSERT_TRUE(materialArtifactResult);
ASSERT_NE(materialArtifactResult.resource, nullptr);
auto* artifactMaterial = static_cast<Material*>(materialArtifactResult.resource);
ASSERT_NE(artifactMaterial, nullptr);
EXPECT_EQ(artifactMaterial->GetTextureBindingCount(), 1u);
EXPECT_EQ(artifactMaterial->GetTextureBindingName(0), "baseColorTexture");
EXPECT_FALSE(artifactMaterial->GetTextureBindingPath(0).Empty());
const ResourceHandle<Texture> artifactLazyTexture = artifactMaterial->GetTexture("baseColorTexture");
EXPECT_FALSE(artifactLazyTexture.IsValid());
EXPECT_GT(manager.GetAsyncPendingCount(), 0u);
ASSERT_TRUE(PumpAsyncLoadsUntilIdle(manager));
const ResourceHandle<Texture> artifactResolvedTexture = artifactMaterial->GetTexture("baseColorTexture");
ASSERT_TRUE(artifactResolvedTexture.IsValid());
EXPECT_EQ(artifactResolvedTexture->GetWidth(), 2u);
EXPECT_EQ(artifactResolvedTexture->GetHeight(), 2u);
delete artifactMaterial;
MeshLoader meshLoader;
LoadResult meshArtifactResult = meshLoader.Load(firstResolve.artifactMainPath.CStr());
ASSERT_TRUE(meshArtifactResult);
ASSERT_NE(meshArtifactResult.resource, nullptr);
auto* artifactMesh = static_cast<Mesh*>(meshArtifactResult.resource);
ASSERT_NE(artifactMesh, nullptr);
ASSERT_GE(artifactMesh->GetMaterials().Size(), 1u);
Material* artifactSectionMaterial = GetFirstSectionMaterial(*artifactMesh);
ASSERT_NE(artifactSectionMaterial, nullptr);
EXPECT_EQ(artifactSectionMaterial->GetTextureBindingCount(), 1u);
EXPECT_EQ(artifactSectionMaterial->GetTextureBindingName(0), "baseColorTexture");
EXPECT_FALSE(artifactSectionMaterial->GetTextureBindingPath(0).Empty());
const ResourceHandle<Texture> artifactMeshLazyTexture = artifactSectionMaterial->GetTexture("baseColorTexture");
EXPECT_FALSE(artifactMeshLazyTexture.IsValid());
EXPECT_GT(manager.GetAsyncPendingCount(), 0u);
ASSERT_TRUE(PumpAsyncLoadsUntilIdle(manager));
const ResourceHandle<Texture> artifactMeshResolvedTexture =
artifactSectionMaterial->GetTexture("baseColorTexture");
ASSERT_TRUE(artifactMeshResolvedTexture.IsValid());
EXPECT_EQ(artifactMeshResolvedTexture->GetWidth(), 2u);
EXPECT_EQ(artifactMeshResolvedTexture->GetHeight(), 2u);
delete artifactMesh;
AssetRef assetRef;
ASSERT_TRUE(database.TryGetAssetRef("Assets/textured_triangle.obj", ResourceType::Mesh, assetRef));
EXPECT_TRUE(assetRef.IsValid());
@@ -192,6 +287,7 @@ TEST(MeshLoader, AssetDatabaseCreatesModelArtifactAndReusesItWithoutReimport) {
EXPECT_EQ(originalArtifactWriteTime, fs::last_write_time(secondResolve.artifactMainPath.CStr()));
database.Shutdown();
manager.Shutdown();
fs::remove_all(projectRoot);
}
@@ -223,8 +319,23 @@ TEST(MeshLoader, ResourceManagerLoadsModelByAssetRefFromProjectAssets) {
EXPECT_EQ(firstHandle->GetVertexCount(), 3u);
EXPECT_EQ(firstHandle->GetIndexCount(), 3u);
EXPECT_GE(firstHandle->GetMaterials().Size(), 1u);
EXPECT_EQ(firstHandle->GetTextures().Size(), 1u);
EXPECT_EQ(firstHandle->GetTextures().Size(), 0u);
const auto initialMaterialCount = firstHandle->GetMaterials().Size();
const XCEngine::Core::uint32 firstSectionMaterialIndex = GetFirstSectionMaterialIndex(*firstHandle.Get());
EXPECT_LT(firstSectionMaterialIndex, initialMaterialCount);
Material* firstMaterial = GetFirstSectionMaterial(*firstHandle.Get());
ASSERT_NE(firstMaterial, nullptr);
EXPECT_EQ(firstMaterial->GetTextureBindingCount(), 1u);
EXPECT_EQ(firstMaterial->GetTextureBindingName(0), "baseColorTexture");
EXPECT_FALSE(firstMaterial->GetTextureBindingPath(0).Empty());
const ResourceHandle<Texture> firstLazyTexture = firstMaterial->GetTexture("baseColorTexture");
EXPECT_FALSE(firstLazyTexture.IsValid());
EXPECT_GT(manager.GetAsyncPendingCount(), 0u);
ASSERT_TRUE(PumpAsyncLoadsUntilIdle(manager));
const ResourceHandle<Texture> firstResolvedTexture = firstMaterial->GetTexture("baseColorTexture");
ASSERT_TRUE(firstResolvedTexture.IsValid());
EXPECT_EQ(firstResolvedTexture->GetWidth(), 2u);
EXPECT_EQ(firstResolvedTexture->GetHeight(), 2u);
AssetRef assetRef;
ASSERT_TRUE(manager.TryGetAssetRef("Assets/textured_triangle.obj", ResourceType::Mesh, assetRef));
@@ -238,7 +349,21 @@ TEST(MeshLoader, ResourceManagerLoadsModelByAssetRefFromProjectAssets) {
EXPECT_EQ(secondHandle->GetVertexCount(), 3u);
EXPECT_EQ(secondHandle->GetIndexCount(), 3u);
EXPECT_EQ(secondHandle->GetMaterials().Size(), initialMaterialCount);
EXPECT_EQ(secondHandle->GetTextures().Size(), 1u);
EXPECT_EQ(secondHandle->GetTextures().Size(), 0u);
EXPECT_EQ(GetFirstSectionMaterialIndex(*secondHandle.Get()), firstSectionMaterialIndex);
Material* secondMaterial = GetFirstSectionMaterial(*secondHandle.Get());
ASSERT_NE(secondMaterial, nullptr);
EXPECT_EQ(secondMaterial->GetTextureBindingCount(), 1u);
EXPECT_EQ(secondMaterial->GetTextureBindingName(0), "baseColorTexture");
EXPECT_FALSE(secondMaterial->GetTextureBindingPath(0).Empty());
const ResourceHandle<Texture> secondLazyTexture = secondMaterial->GetTexture("baseColorTexture");
EXPECT_FALSE(secondLazyTexture.IsValid());
EXPECT_GT(manager.GetAsyncPendingCount(), 0u);
ASSERT_TRUE(PumpAsyncLoadsUntilIdle(manager));
const ResourceHandle<Texture> secondResolvedTexture = secondMaterial->GetTexture("baseColorTexture");
ASSERT_TRUE(secondResolvedTexture.IsValid());
EXPECT_EQ(secondResolvedTexture->GetWidth(), 2u);
EXPECT_EQ(secondResolvedTexture->GetHeight(), 2u);
manager.SetResourceRoot("");
manager.Shutdown();