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

feat: 完成资源系统导入设置类实现

Browse Source 
- 新增 ImportSettings 基类
- 新增 TextureImportSettings 纹理导入设置类
- 新增 MeshImportSettings 网格导入设置类
- 新增 ResourcePath 资源路径类
- 完善 CMakeLists.txt 配置
- 新增对应单元测试 (45个测试用例)
This commit is contained in:
ssdfasd
2026-03-18 13:39:32 +08:00
parent 3196261e9b
commit fc7c8f6797
17 changed files with 774 additions and 12 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
tests/Resources/CMakeLists.txt
View File

@@ -23,6 +23,9 @@ set(RESOURCES_TEST_SOURCES
test_material_loader.cpp
test_resource_package.cpp
test_resource_dependency.cpp
test_texture_import_settings.cpp
test_mesh_import_settings.cpp
test_resource_path.cpp
)
add_executable(xcengine_resources_tests ${RESOURCES_TEST_SOURCES})

104
tests/Resources/test_mesh_import_settings.cpp Normal file
View File

@@ -0,0 +1,104 @@
#include <gtest/gtest.h>
#include <XCEngine/Resources/MeshImportSettings.h>
#include <XCEngine/Resources/ResourceTypes.h>
#include <XCEngine/Math/Vector3.h>
using namespace XCEngine::Resources;
using namespace XCEngine::Math;
namespace {
TEST(MeshImportSettings, DefaultConstructor) {
MeshImportSettings settings;
EXPECT_EQ(settings.GetImportFlags(), MeshImportFlags::None);
EXPECT_FLOAT_EQ(settings.GetScale(), 1.0f);
EXPECT_EQ(settings.GetOffset(), Vector3::Zero());
EXPECT_TRUE(settings.GetAxisConversion());
EXPECT_FALSE(settings.GetMergeMeshes());
EXPECT_FLOAT_EQ(settings.GetOptimizeThreshold(), 0.3f);
EXPECT_FLOAT_EQ(settings.GetImportScale(), 1.0f);
EXPECT_FLOAT_EQ(settings.GetThreshold(), 0.0f);
}
TEST(MeshImportSettings, SetImportFlags) {
MeshImportSettings settings;
settings.SetImportFlags(MeshImportFlags::FlipUVs | MeshImportFlags::GenerateNormals);
EXPECT_TRUE(settings.HasImportFlag(MeshImportFlags::FlipUVs));
EXPECT_TRUE(settings.HasImportFlag(MeshImportFlags::GenerateNormals));
EXPECT_FALSE(settings.HasImportFlag(MeshImportFlags::GenerateTangents));
}
TEST(MeshImportSettings, AddImportFlag) {
MeshImportSettings settings;
settings.AddImportFlag(MeshImportFlags::FlipUVs);
EXPECT_TRUE(settings.HasImportFlag(MeshImportFlags::FlipUVs));
}
TEST(MeshImportSettings, RemoveImportFlag) {
MeshImportSettings settings;
settings.SetImportFlags(MeshImportFlags::FlipUVs | MeshImportFlags::GenerateNormals);
settings.RemoveImportFlag(MeshImportFlags::FlipUVs);
EXPECT_FALSE(settings.HasImportFlag(MeshImportFlags::FlipUVs));
EXPECT_TRUE(settings.HasImportFlag(MeshImportFlags::GenerateNormals));
}
TEST(MeshImportSettings, SetScale) {
MeshImportSettings settings;
settings.SetScale(2.0f);
EXPECT_FLOAT_EQ(settings.GetScale(), 2.0f);
}
TEST(MeshImportSettings, SetOffset) {
MeshImportSettings settings;
Vector3 offset(1.0f, 2.0f, 3.0f);
settings.SetOffset(offset);
EXPECT_EQ(settings.GetOffset(), offset);
}
TEST(MeshImportSettings, SetAxisConversion) {
MeshImportSettings settings;
settings.SetAxisConversion(false);
EXPECT_FALSE(settings.GetAxisConversion());
}
TEST(MeshImportSettings, SetMergeMeshes) {
MeshImportSettings settings;
settings.SetMergeMeshes(true);
EXPECT_TRUE(settings.GetMergeMeshes());
}
TEST(MeshImportSettings, SetOptimizeThreshold) {
MeshImportSettings settings;
settings.SetOptimizeThreshold(0.5f);
EXPECT_FLOAT_EQ(settings.GetOptimizeThreshold(), 0.5f);
}
TEST(MeshImportSettings, SetImportScale) {
MeshImportSettings settings;
settings.SetImportScale(0.5f);
EXPECT_FLOAT_EQ(settings.GetImportScale(), 0.5f);
}
TEST(MeshImportSettings, SetThreshold) {
MeshImportSettings settings;
settings.SetThreshold(0.01f);
EXPECT_FLOAT_EQ(settings.GetThreshold(), 0.01f);
}
TEST(MeshImportSettings, Clone) {
MeshImportSettings settings;
settings.SetImportFlags(MeshImportFlags::FlipUVs | MeshImportFlags::GenerateNormals);
settings.SetScale(2.0f);
settings.SetMergeMeshes(true);
auto cloned = settings.Clone();
ASSERT_NE(cloned, nullptr);
MeshImportSettings* clonedSettings = static_cast<MeshImportSettings*>(cloned.get());
EXPECT_TRUE(clonedSettings->HasImportFlag(MeshImportFlags::FlipUVs));
EXPECT_TRUE(clonedSettings->HasImportFlag(MeshImportFlags::GenerateNormals));
EXPECT_FLOAT_EQ(clonedSettings->GetScale(), 2.0f);
EXPECT_TRUE(clonedSettings->GetMergeMeshes());
}
} // namespace

110
tests/Resources/test_resource_path.cpp Normal file
View File

@@ -0,0 +1,110 @@
#include <gtest/gtest.h>
#include <XCEngine/Resources/ResourcePath.h>
#include <XCEngine/Resources/ResourceTypes.h>
#include <XCEngine/Containers/String.h>
using namespace XCEngine::Resources;
using namespace XCEngine::Containers;
namespace {
TEST(ResourcePath, DefaultConstructor) {
ResourcePath path;
EXPECT_FALSE(path.IsValid());
}
TEST(ResourcePath, ConstructorWithCString) {
ResourcePath path("textures/player.png");
EXPECT_TRUE(path.IsValid());
EXPECT_EQ(path.GetPath(), "textures/player.png");
}
TEST(ResourcePath, ConstructorWithString) {
String str = "models/player.fbx";
ResourcePath path(str);
EXPECT_TRUE(path.IsValid());
EXPECT_EQ(path.GetPath(), str);
}
TEST(ResourcePath, GetExtension) {
ResourcePath path("textures/player.png");
EXPECT_EQ(path.GetExtension(), ".png");
}
TEST(ResourcePath, GetExtensionNoExtension) {
ResourcePath path("textures/player");
EXPECT_TRUE(path.GetExtension().Empty());
}
TEST(ResourcePath, GetStem) {
ResourcePath path("textures/player.png");
EXPECT_EQ(path.GetStem(), "player");
}
TEST(ResourcePath, GetStemNoExtension) {
ResourcePath path("textures/player");
EXPECT_EQ(path.GetStem(), "player");
}
TEST(ResourcePath, GetFileName) {
ResourcePath path("textures/player.png");
EXPECT_EQ(path.GetFileName(), "player.png");
}
TEST(ResourcePath, GetDirectory) {
ResourcePath path("textures/player.png");
EXPECT_EQ(path.GetDirectory(), "textures");
}
TEST(ResourcePath, GetDirectoryWithBackslash) {
ResourcePath path("textures\\player.png");
EXPECT_EQ(path.GetDirectory(), "textures");
}
TEST(ResourcePath, GetFullPath) {
ResourcePath path("textures/player.png");
EXPECT_EQ(path.GetFullPath(), "textures/player.png");
}
TEST(ResourcePath, HasExtension) {
ResourcePath path("textures/player.png");
EXPECT_TRUE(path.HasExtension(".png"));
EXPECT_FALSE(path.HasExtension(".jpg"));
}
TEST(ResourcePath, HasExtensionNoExtension) {
ResourcePath path("textures/player");
EXPECT_FALSE(path.HasExtension(".png"));
}
TEST(ResourcePath, HasAnyExtension) {
ResourcePath path("textures/player.png");
const char* extensions[] = { ".jpg", ".png", ".tga" };
EXPECT_TRUE(path.HasAnyExtension(extensions, 3));
}
TEST(ResourcePath, HasAnyExtensionNoMatch) {
ResourcePath path("textures/player.png");
const char* extensions[] = { ".jpg", ".tga", ".bmp" };
EXPECT_FALSE(path.HasAnyExtension(extensions, 3));
}
TEST(ResourcePath, ToGUID) {
ResourcePath path("textures/player.png");
ResourceGUID guid = path.ToGUID();
EXPECT_TRUE(guid.IsValid());
}
TEST(ResourcePath, SetPath) {
ResourcePath path;
path.SetPath("textures/player.png");
EXPECT_TRUE(path.IsValid());
EXPECT_EQ(path.GetPath(), "textures/player.png");
}
TEST(ResourcePath, GetRelativePath) {
ResourcePath path("textures/player.png");
EXPECT_EQ(path.GetRelativePath(), "textures/player.png");
}
} // namespace

119
tests/Resources/test_texture_import_settings.cpp Normal file
View File

@@ -0,0 +1,119 @@
#include <gtest/gtest.h>
#include <XCEngine/Resources/TextureImportSettings.h>
#include <XCEngine/Resources/ResourceTypes.h>
using namespace XCEngine::Resources;
namespace {
TEST(TextureImportSettings, DefaultConstructor) {
TextureImportSettings settings;
EXPECT_EQ(settings.GetTextureType(), TextureType::Texture2D);
EXPECT_EQ(settings.GetTargetFormat(), TextureFormat::Unknown);
EXPECT_TRUE(settings.GetGenerateMipmaps());
EXPECT_EQ(settings.GetMipmapFilter(), MipmapFilter::Box);
EXPECT_EQ(settings.GetMaxAnisotropy(), 16u);
EXPECT_FALSE(settings.GetSRGB());
EXPECT_FALSE(settings.GetFlipVertical());
EXPECT_FALSE(settings.GetFlipHorizontal());
EXPECT_EQ(settings.GetCompressionQuality(), CompressionQuality::High);
EXPECT_TRUE(settings.GetUseHardwareCompression());
EXPECT_EQ(settings.GetMaxSize(), 0u);
EXPECT_FALSE(settings.GetGenerateNormalMap());
EXPECT_FLOAT_EQ(settings.GetNormalMapStrength(), 1.0f);
}
TEST(TextureImportSettings, SetTextureType) {
TextureImportSettings settings;
settings.SetTextureType(TextureType::TextureCube);
EXPECT_EQ(settings.GetTextureType(), TextureType::TextureCube);
}
TEST(TextureImportSettings, SetTargetFormat) {
TextureImportSettings settings;
settings.SetTargetFormat(TextureFormat::BC7_UNORM_SRGB);
EXPECT_EQ(settings.GetTargetFormat(), TextureFormat::BC7_UNORM_SRGB);
}
TEST(TextureImportSettings, SetGenerateMipmaps) {
TextureImportSettings settings;
settings.SetGenerateMipmaps(false);
EXPECT_FALSE(settings.GetGenerateMipmaps());
}
TEST(TextureImportSettings, SetMipmapFilter) {
TextureImportSettings settings;
settings.SetMipmapFilter(MipmapFilter::Kaiser);
EXPECT_EQ(settings.GetMipmapFilter(), MipmapFilter::Kaiser);
}
TEST(TextureImportSettings, SetMaxAnisotropy) {
TextureImportSettings settings;
settings.SetMaxAnisotropy(8);
EXPECT_EQ(settings.GetMaxAnisotropy(), 8u);
}
TEST(TextureImportSettings, SetSRGB) {
TextureImportSettings settings;
settings.SetSRGB(true);
EXPECT_TRUE(settings.GetSRGB());
}
TEST(TextureImportSettings, SetFlipVertical) {
TextureImportSettings settings;
settings.SetFlipVertical(true);
EXPECT_TRUE(settings.GetFlipVertical());
}
TEST(TextureImportSettings, SetFlipHorizontal) {
TextureImportSettings settings;
settings.SetFlipHorizontal(true);
EXPECT_TRUE(settings.GetFlipHorizontal());
}
TEST(TextureImportSettings, SetCompressionQuality) {
TextureImportSettings settings;
settings.SetCompressionQuality(CompressionQuality::Low);
EXPECT_EQ(settings.GetCompressionQuality(), CompressionQuality::Low);
}
TEST(TextureImportSettings, SetUseHardwareCompression) {
TextureImportSettings settings;
settings.SetUseHardwareCompression(false);
EXPECT_FALSE(settings.GetUseHardwareCompression());
}
TEST(TextureImportSettings, SetMaxSize) {
TextureImportSettings settings;
settings.SetMaxSize(2048);
EXPECT_EQ(settings.GetMaxSize(), 2048u);
}
TEST(TextureImportSettings, SetGenerateNormalMap) {
TextureImportSettings settings;
settings.SetGenerateNormalMap(true);
EXPECT_TRUE(settings.GetGenerateNormalMap());
}
TEST(TextureImportSettings, SetNormalMapStrength) {
TextureImportSettings settings;
settings.SetNormalMapStrength(2.0f);
EXPECT_FLOAT_EQ(settings.GetNormalMapStrength(), 2.0f);
}
TEST(TextureImportSettings, Clone) {
TextureImportSettings settings;
settings.SetTextureType(TextureType::TextureCube);
settings.SetSRGB(true);
settings.SetMaxAnisotropy(8);
auto cloned = settings.Clone();
ASSERT_NE(cloned, nullptr);
TextureImportSettings* clonedSettings = static_cast<TextureImportSettings*>(cloned.get());
EXPECT_EQ(clonedSettings->GetTextureType(), TextureType::TextureCube);
EXPECT_TRUE(clonedSettings->GetSRGB());
EXPECT_EQ(clonedSettings->GetMaxAnisotropy(), 8u);
}
} // namespace