smath/tests/vec.cpp

#include <format>
#include <string>
#include <type_traits>

#include <gtest/gtest.h>

#include <smath.hpp>

using smath::Vec;
using smath::Vec2;
using smath::Vec3;
using smath::Vec4;

template<class T>
static void ExpectVecNear(
    const Vec<3, T> &a, const Vec<3, T> &b, T eps = T(1e-6))
{
	for (int i = 0; i < 3; ++i)
		EXPECT_NEAR(double(a[i]), double(b[i]), double(eps));
}

// Constructors and accessors
TEST(Vec, DefaultZero)
{
	Vec3 v;
	EXPECT_EQ(v[0], 0.0f);
	EXPECT_EQ(v[1], 0.0f);
	EXPECT_EQ(v[2], 0.0f);
}

TEST(Vec, ScalarFillCtor)
{
	Vec4 v { 2.0f };
	EXPECT_EQ(v.x(), 2.0f);
	EXPECT_EQ(v.y(), 2.0f);
	EXPECT_EQ(v.z(), 2.0f);
	EXPECT_EQ(v.w(), 2.0f);
}

TEST(Vec, VariadicCtorScalarsAndSubvectors)
{
	Vec2 a { 1.0f, 2.0f };
	Vec2 b { 3.0f, 4.0f };
	Vec4 v { a, b };
	EXPECT_EQ(v.r(), 1.0f);
	EXPECT_EQ(v.g(), 2.0f);
	EXPECT_EQ(v.b(), 3.0f);
	EXPECT_EQ(v.a(), 4.0f);
}

TEST(Vec, NamedAccessorsAliases)
{
	Vec3 v { 1.0f, 2.0f, 3.0f };
	EXPECT_EQ(v.x(), v.r());
	EXPECT_EQ(v.y(), v.g());
	EXPECT_EQ(v.z(), v.b());
}

// Arithmetic
TEST(Vec, ElementwiseAndScalarOps)
{
	Vec3 a { 1.0f, 2.0f, 3.0f };
	Vec3 b { 4.0f, 5.0f, 6.0f };

	auto s1 = a + b;
	EXPECT_EQ(s1[0], 5.0f);
	EXPECT_EQ(s1[1], 7.0f);
	EXPECT_EQ(s1[2], 9.0f);

	auto s2 = a * 2.0f;
	EXPECT_EQ(s2[0], 2.0f);
	EXPECT_EQ(s2[1], 4.0f);
	EXPECT_EQ(s2[2], 6.0f);

	auto s3 = 2.0f * a; // RHS overloads
	EXPECT_EQ(s3[0], 2.0f);
	EXPECT_EQ(s3[1], 4.0f);
	EXPECT_EQ(s3[2], 6.0f);

	Vec3 c { 1.0f, 2.0f, 3.0f };
	c += Vec3 { 1.0f, 1.0f, 1.0f };
	EXPECT_EQ(c[0], 2.0f);
	EXPECT_EQ(c[1], 3.0f);
	EXPECT_EQ(c[2], 4.0f);

	c *= 2.0f;
	EXPECT_EQ(c[0], 4.0f);
	EXPECT_EQ(c[1], 6.0f);
	EXPECT_EQ(c[2], 8.0f);
}

// Length, dot, cross, normalize
TEST(Vec, MagnitudeAndDot)
{
	Vec3 v { 3.0f, 4.0f, 12.0f };
	EXPECT_FLOAT_EQ(v.magnitude(), 13.0f);
	EXPECT_FLOAT_EQ(v.length(), 13.0f);

	Vec3 u { 1.0f, 0.0f, 2.0f };
	EXPECT_FLOAT_EQ(v.dot(u), 27.0f);
}

TEST(Vec, Cross3D)
{
	Vec3 x { 1.0f, 0.0f, 0.0f };
	Vec3 y { 0.0f, 1.0f, 0.0f };
	auto z = x.cross(y);
	EXPECT_EQ(z[0], 0.0f);
	EXPECT_EQ(z[1], 0.0f);
	EXPECT_EQ(z[2], 1.0f);
}

TEST(Vec, NormalizeAndSafeNormalize)
{
	Vec3 v { 10.0f, 0.0f, 0.0f };
	auto n = v.normalized();
	auto ns = v.normalized_safe();
	ExpectVecNear(n, Vec3 { 1.0f, 0.0f, 0.0f });

	Vec3 zero {};
	auto zs = zero.normalized_safe();
	EXPECT_EQ(zs[0], 0.0f);
	EXPECT_EQ(zs[1], 0.0f);
	EXPECT_EQ(zs[2], 0.0f);
}

TEST(Vec, DistanceAndProjection)
{
	Vec3 a { 1.0f, 2.0f, 3.0f };
	Vec3 b { 4.0f, 6.0f, 3.0f };
	EXPECT_FLOAT_EQ(a.distance(b), 5.0f);

	Vec3 n { 2.0f, 0.0f, 0.0f }; // onto x-axis scaled
	auto p = a.project_onto(n);  // (a·n)/(n·n) * n = (2)/4 * n = 0.5 * n
	ExpectVecNear(p, Vec3 { 1.0f, 0.0f, 0.0f });
}

// Approx equal
TEST(Vec, ApproxEqual)
{
	Vec3 a { 1.0f, 2.0f, 3.0f };
	Vec3 b { 1.0f + 1e-7f, 2.0f - 1e-7f, 3.0f };
	EXPECT_TRUE(a.approx_equal(b, 1e-6f));
	EXPECT_FALSE(a.approx_equal(b, 1e-9f));
}

// std::get & tuple interop
TEST(Vec, StdGetAndTuple)
{
	Vec3 v { 7.0f, 8.0f, 9.0f };
	static_assert(std::tuple_size_v<Vec3> == 3);
	static_assert(std::is_same_v<std::tuple_element_t<1, Vec3>, float>);
	EXPECT_EQ(std::get<0>(v), 7.0f);
	EXPECT_EQ(std::get<1>(v), 8.0f);
	EXPECT_EQ(std::get<2>(v), 9.0f);
}

// Swizzle
TEST(Vec, SwizzleBasic)
{
	const Vec3 v { 1.0f, 2.0f, 3.0f };

	auto yz = smath::swizzle<"yz">(v);
	EXPECT_EQ(yz[0], 2.0f);
	EXPECT_EQ(yz[1], 3.0f);

	auto rxx = smath::swizzle<"xxy">(v);
	EXPECT_EQ(rxx[0], 1.0f);
	EXPECT_EQ(rxx[1], 1.0f);
	EXPECT_EQ(rxx[2], 2.0f);
}

// std::formatter
TEST(Vec, Formatter)
{
	smath::Vec<3, int> vi { 1, 2, 3 };
	std::string s = std::format("{}", vi);
	EXPECT_EQ(s, "{1, 2, 3}");
}

// Conversions
TEST(Vec, ExplicitConversionBetweenScalarTypes)
{
	smath::Vec<3, int> vi { 1, 2, 3 };
	smath::Vec<3, float> vf { vi };
	EXPECT_EQ(vf[0], 1.0f);
	EXPECT_EQ(vf[1], 2.0f);
	EXPECT_EQ(vf[2], 3.0f);

	auto vi2 = static_cast<smath::Vec<3, int>>(vf);
	EXPECT_EQ(vi2[0], 1);
	EXPECT_EQ(vi2[1], 2);
	EXPECT_EQ(vi2[2], 3);
}