XCEngine/tests/Resources/test_texture_import_settings.cpp

#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