XCEngine/tests/Resources/Mesh/test_mesh_import_settings.cpp

#include <gtest/gtest.h>
#include <XCEngine/Resources/Mesh/MeshImportSettings.h>
#include <XCEngine/Core/Asset/ResourceTypes.h>
#include <XCEngine/Core/Math/Vector3.h>

using namespace XCEngine::Resources;
using namespace XCEngine::Math;

namespace {

TEST(MeshImportSettings, DefaultConstructor) {
    MeshImportSettings settings;
    EXPECT_EQ(settings.GetImportFlags(), MeshImportFlags::ImportMaterials);
    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());
}

TEST(MeshImportSettings, SaveAndLoadJSON) {
    MeshImportSettings settings;
    settings.SetImportFlags(MeshImportFlags::FlipUVs | MeshImportFlags::GenerateTangents);
    settings.SetScale(2.5f);
    settings.SetOffset(Vector3(1.0f, 2.0f, 3.0f));
    settings.SetAxisConversion(false);
    settings.SetMergeMeshes(true);
    settings.SetOptimizeThreshold(0.6f);
    settings.SetImportScale(0.75f);
    settings.SetThreshold(0.05f);

    const auto json = settings.SaveToJSON();

    MeshImportSettings loaded;
    EXPECT_TRUE(loaded.LoadFromJSON(json));
    EXPECT_TRUE(loaded.HasImportFlag(MeshImportFlags::FlipUVs));
    EXPECT_TRUE(loaded.HasImportFlag(MeshImportFlags::GenerateTangents));
    EXPECT_FLOAT_EQ(loaded.GetScale(), 2.5f);
    EXPECT_EQ(loaded.GetOffset(), Vector3(1.0f, 2.0f, 3.0f));
    EXPECT_FALSE(loaded.GetAxisConversion());
    EXPECT_TRUE(loaded.GetMergeMeshes());
    EXPECT_FLOAT_EQ(loaded.GetOptimizeThreshold(), 0.6f);
    EXPECT_FLOAT_EQ(loaded.GetImportScale(), 0.75f);
    EXPECT_FLOAT_EQ(loaded.GetThreshold(), 0.05f);
}

} // namespace