CGNICO/UnrealEngine
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
ue5-main
UnrealEngine/Engine/Plugins/Animation/RigLogic/Source/RigLogicLibTest/Private/tdmtests/TestMat.cpp
Jeffreytsai1004 c11d382a6f ue5-main
2025-05-18 13:04:45 +08:00

622 lines
18 KiB
C++
Raw Permalink Blame History

// Copyright Epic Games, Inc. All Rights Reserved.
#include "tdmtests/Defs.h"
#include "tdmtests/Helpers.h"
#include "tdm/TDM.h"
TEST(MatTestConstruction, DefaultConstructMat4) {
tdm::mat4<int> m;
tdm::vec4<int> v{};
ASSERT_EQ(m[0], v);
ASSERT_EQ(m[1], v);
ASSERT_EQ(m[2], v);
ASSERT_EQ(m[3], v);
}
TEST(MatTestConstruction, DefaultConstructMat5) {
tdm::mat<5, 5, int> m;
tdm::vec<5, int> v{};
ASSERT_EQ(m[0], v);
ASSERT_EQ(m[1], v);
ASSERT_EQ(m[2], v);
ASSERT_EQ(m[3], v);
ASSERT_EQ(m[4], v);
}
TEST(MatTestConstruction, ConstructFromScalar) {
tdm::mat4<int> m{4};
tdm::vec4<int> v{4};
ASSERT_EQ(m[0], v);
ASSERT_EQ(m[1], v);
ASSERT_EQ(m[2], v);
ASSERT_EQ(m[3], v);
}
TEST(MatTestConstruction, ConstructFromScalarValues) {
tdm::mat4<int> m{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
ASSERT_EQ(m[0], tdm::vec4<int>(1, 2, 3, 4));
ASSERT_EQ(m[1], tdm::vec4<int>(5, 6, 7, 8));
ASSERT_EQ(m[2], tdm::vec4<int>(9, 10, 11, 12));
ASSERT_EQ(m[3], tdm::vec4<int>(13, 14, 15, 16));
}
TEST(MatTestConstruction, ConstructFromVec2s) {
tdm::vec2<int> v{2};
tdm::mat2<int> m{v, v};
ASSERT_EQ(m[0], v);
ASSERT_EQ(m[1], v);
}
TEST(MatTestConstruction, ConstructFromVec3s) {
tdm::vec3<int> v{3};
tdm::mat3<int> m{v, v, v};
ASSERT_EQ(m[0], v);
ASSERT_EQ(m[1], v);
ASSERT_EQ(m[2], v);
}
TEST(MatTestConstruction, ConstructFromVec4s) {
tdm::vec4<int> v{4};
tdm::mat4<int> m{v, v, v, v};
ASSERT_EQ(m[0], v);
ASSERT_EQ(m[1], v);
ASSERT_EQ(m[2], v);
ASSERT_EQ(m[3], v);
}
TEST(MatTestConstruction, ConstructFromArbitraryVecs) {
tdm::vec<5, int> v{5};
tdm::mat<5, 5, int> m{v, v, v, v, v};
ASSERT_EQ(m[0], v);
ASSERT_EQ(m[1], v);
ASSERT_EQ(m[2], v);
ASSERT_EQ(m[3], v);
ASSERT_EQ(m[4], v);
}
TEST(MatTestConstruction, ConstructSquareFromRows) {
tdm::vec4<int> v{1, 2, 3, 4};
tdm::mat4<int> m = tdm::mat4<int>::fromRows(v, v, v, v);
ASSERT_EQ(m[0], tdm::vec4<int>(1, 2, 3, 4));
ASSERT_EQ(m[1], tdm::vec4<int>(1, 2, 3, 4));
ASSERT_EQ(m[2], tdm::vec4<int>(1, 2, 3, 4));
ASSERT_EQ(m[3], tdm::vec4<int>(1, 2, 3, 4));
}
TEST(MatTestConstruction, ConstructNonSquareFromRows) {
tdm::vec2<int> v{1, 2};
tdm::mat<4, 2, int> m = tdm::mat<4, 2, int>::fromRows(v, v, v, v);
ASSERT_EQ(m[0], tdm::vec2<int>(1, 2));
ASSERT_EQ(m[1], tdm::vec2<int>(1, 2));
ASSERT_EQ(m[2], tdm::vec2<int>(1, 2));
ASSERT_EQ(m[3], tdm::vec2<int>(1, 2));
}
TEST(MatTestConstruction, ConstructSquareFromCols) {
tdm::vec4<int> v{1, 2, 3, 4};
tdm::mat4<int> m = tdm::mat4<int>::fromColumns(v, v, v, v);
ASSERT_EQ(m[0], tdm::vec4<int>(1, 1, 1, 1));
ASSERT_EQ(m[1], tdm::vec4<int>(2, 2, 2, 2));
ASSERT_EQ(m[2], tdm::vec4<int>(3, 3, 3, 3));
ASSERT_EQ(m[3], tdm::vec4<int>(4, 4, 4, 4));
}
TEST(MatTestConstruction, ConstructNonSquareFromCols) {
tdm::vec4<int> v{1, 2, 3, 4};
tdm::mat<4, 2, int> m = tdm::mat<4, 2, int>::fromColumns(v, v);
ASSERT_EQ(m[0], tdm::vec2<int>(1, 1));
ASSERT_EQ(m[1], tdm::vec2<int>(2, 2));
ASSERT_EQ(m[2], tdm::vec2<int>(3, 3));
ASSERT_EQ(m[3], tdm::vec2<int>(4, 4));
}
TEST(MatTestConstruction, ConstructFromMat) {
tdm::mat4<long int> m{tdm::mat4<int>{4}};
tdm::vec4<long int> v{4};
ASSERT_EQ(m[0], v);
ASSERT_EQ(m[1], v);
ASSERT_EQ(m[2], v);
ASSERT_EQ(m[3], v);
}
TEST(MatTestConstruction, ConstructDiagonalMatFromScalar) {
auto m = tdm::mat4<int>::diagonal(42);
ASSERT_EQ(m[0], tdm::vec4<int>(42, 0, 0, 0));
ASSERT_EQ(m[1], tdm::vec4<int>(0, 42, 0, 0));
ASSERT_EQ(m[2], tdm::vec4<int>(0, 0, 42, 0));
ASSERT_EQ(m[3], tdm::vec4<int>(0, 0, 0, 42));
}
TEST(MatTestConstruction, ConstructDiagonalMatFromScalarValues) {
auto m = tdm::mat4<int>::diagonal(1, 2, 3, 4);
ASSERT_EQ(m[0], tdm::vec4<int>(1, 0, 0, 0));
ASSERT_EQ(m[1], tdm::vec4<int>(0, 2, 0, 0));
ASSERT_EQ(m[2], tdm::vec4<int>(0, 0, 3, 0));
ASSERT_EQ(m[3], tdm::vec4<int>(0, 0, 0, 4));
}
TEST(MatTestConstruction, ConstructDiagonalMatFromVec) {
auto m = tdm::mat4<int>::diagonal(tdm::vec4<int>{42});
ASSERT_EQ(m[0], tdm::vec4<int>(42, 0, 0, 0));
ASSERT_EQ(m[1], tdm::vec4<int>(0, 42, 0, 0));
ASSERT_EQ(m[2], tdm::vec4<int>(0, 0, 42, 0));
ASSERT_EQ(m[3], tdm::vec4<int>(0, 0, 0, 42));
}
TEST(MatTestConstruction, ConstructIdentityMat) {
auto m = tdm::mat4<int>::identity();
ASSERT_EQ(m[0], tdm::vec4<int>(1, 0, 0, 0));
ASSERT_EQ(m[1], tdm::vec4<int>(0, 1, 0, 0));
ASSERT_EQ(m[2], tdm::vec4<int>(0, 0, 1, 0));
ASSERT_EQ(m[3], tdm::vec4<int>(0, 0, 0, 1));
}
namespace {
class MatTestOperators : public ::testing::Test {
protected:
void SetUp() override {
v1 = tdm::vec4<int>{1, 2, 3, 4};
v2 = tdm::vec4<int>{5, 6, 7, 8};
v3 = tdm::vec4<int>{9, 10, 11, 12};
v4 = tdm::vec4<int>{13, 14, 15, 16};
m = tdm::mat4<int>{v1, v2, v3, v4};
m_rev = tdm::mat4<int>{v4, v3, v2, v1};
invertible = tdm::mat4<int>{tdm::vec4<int>{2, 3, 1, 5},
tdm::vec4<int>{1, 0, 3, 1},
tdm::vec4<int>{0, 2, -3, 2},
tdm::vec4<int>{0, 2, 3, 1}};
}
protected:
tdm::vec4<int> v1;
tdm::vec4<int> v2;
tdm::vec4<int> v3;
tdm::vec4<int> v4;
tdm::mat4<int> m;
tdm::mat4<int> m_rev;
tdm::mat4<int> invertible;
};
} // namespace
TEST_F(MatTestOperators, AssignMat) {
tdm::vec4<long int> v{4};
tdm::mat4<long int> lm;
lm = tdm::mat4<int>{4};
ASSERT_EQ(lm[0], v);
ASSERT_EQ(lm[1], v);
ASSERT_EQ(lm[2], v);
ASSERT_EQ(lm[3], v);
}
TEST_F(MatTestOperators, TestSubscript) {
ASSERT_EQ(m[0], v1);
ASSERT_EQ(m[1], v2);
ASSERT_EQ(m[2], v3);
ASSERT_EQ(m[3], v4);
}
TEST_F(MatTestOperators, TestLookup) {
ASSERT_EQ(m(0, 0), 1);
ASSERT_EQ(m(3, 3), 16);
ASSERT_EQ(m(1, 2), 7);
ASSERT_EQ(m(2, 0), 9);
}
TEST_F(MatTestOperators, TestIncrement) {
++m;
ASSERT_EQ(m[0], v1 + 1);
ASSERT_EQ(m[1], v2 + 1);
ASSERT_EQ(m[2], v3 + 1);
ASSERT_EQ(m[3], v4 + 1);
}
TEST_F(MatTestOperators, TestDecrement) {
--m;
ASSERT_EQ(m[0], v1 - 1);
ASSERT_EQ(m[1], v2 - 1);
ASSERT_EQ(m[2], v3 - 1);
ASSERT_EQ(m[3], v4 - 1);
}
TEST_F(MatTestOperators, TestCompoundAssignmentAddScalar) {
m += 2;
ASSERT_EQ(m[0], v1 + 2);
ASSERT_EQ(m[1], v2 + 2);
ASSERT_EQ(m[2], v3 + 2);
ASSERT_EQ(m[3], v4 + 2);
}
TEST_F(MatTestOperators, TestCompoundAssignmentAddInitializer) {
m += {v1, v2, v3, v4};
ASSERT_EQ(m[0], v1 + v1);
ASSERT_EQ(m[1], v2 + v2);
ASSERT_EQ(m[2], v3 + v3);
ASSERT_EQ(m[3], v4 + v4);
}
TEST_F(MatTestOperators, TestCompoundAssignmentAddMat) {
m += m_rev;
ASSERT_EQ(m[0], v1 + v4);
ASSERT_EQ(m[1], v2 + v3);
ASSERT_EQ(m[2], v3 + v2);
ASSERT_EQ(m[3], v4 + v1);
}
TEST_F(MatTestOperators, TestCompoundAssignmentSubtractScalar) {
m -= 2;
ASSERT_EQ(m[0], v1 - 2);
ASSERT_EQ(m[1], v2 - 2);
ASSERT_EQ(m[2], v3 - 2);
ASSERT_EQ(m[3], v4 - 2);
}
TEST_F(MatTestOperators, TestCompoundAssignmentSubtractInitializer) {
m -= {v4, v3, v2, v1};
ASSERT_EQ(m[0], v1 - v4);
ASSERT_EQ(m[1], v2 - v3);
ASSERT_EQ(m[2], v3 - v2);
ASSERT_EQ(m[3], v4 - v1);
}
TEST_F(MatTestOperators, TestCompoundAssignmentSubtractMat) {
m -= m_rev;
ASSERT_EQ(m[0], v1 - v4);
ASSERT_EQ(m[1], v2 - v3);
ASSERT_EQ(m[2], v3 - v2);
ASSERT_EQ(m[3], v4 - v1);
}
TEST_F(MatTestOperators, TestCompoundAssignmentMultiplyScalar) {
m *= 2;
ASSERT_EQ(m[0], v1 * 2);
ASSERT_EQ(m[1], v2 * 2);
ASSERT_EQ(m[2], v3 * 2);
ASSERT_EQ(m[3], v4 * 2);
}
TEST_F(MatTestOperators, TestCompoundAssignmentMultiplyInitializer) {
m *= {v4, v3, v2, v1};
ASSERT_EQ(m[0], tdm::vec4<int>(50, 60, 70, 80));
ASSERT_EQ(m[1], tdm::vec4<int>(162, 188, 214, 240));
ASSERT_EQ(m[2], tdm::vec4<int>(274, 316, 358, 400));
ASSERT_EQ(m[3], tdm::vec4<int>(386, 444, 502, 560));
}
TEST_F(MatTestOperators, TestCompoundAssignmentMultiplyMat) {
m *= m_rev;
ASSERT_EQ(m[0], tdm::vec4<int>(50, 60, 70, 80));
ASSERT_EQ(m[1], tdm::vec4<int>(162, 188, 214, 240));
ASSERT_EQ(m[2], tdm::vec4<int>(274, 316, 358, 400));
ASSERT_EQ(m[3], tdm::vec4<int>(386, 444, 502, 560));
}
TEST_F(MatTestOperators, TestCompoundAssignmentDivideScalar) {
m /= 2;
ASSERT_EQ(m[0], v1 / 2);
ASSERT_EQ(m[1], v2 / 2);
ASSERT_EQ(m[2], v3 / 2);
ASSERT_EQ(m[3], v4 / 2);
}
TEST_F(MatTestOperators, TestCompoundAssignmentDivideInitializer) {
tdm::mat4<float> fm{tdm::vec4<float>{0.6f, 0.2f, 0.3f, 0.4f},
tdm::vec4<float>{0.2f, 0.7f, 0.5f, 0.3f},
tdm::vec4<float>{0.3f, 0.5f, 0.7f, 0.2f},
tdm::vec4<float>{0.4f, 0.3f, 0.2f, 0.6f}};
fm /= {fm[0], fm[1], fm[2], fm[3]};
tdm::mat4<float>
expected{tdm::vec4<float>{1.0f, -5.96046e-08f, 2.38419e-07f, -2.38419e-07f},
tdm::vec4<float>{-1.19209e-07f, 1.0f, 4.47035e-07f, -1.19209e-07f},
tdm::vec4<float>{-1.19209e-07f, 2.98023e-07f, 1.0f, -2.98023e-07f},
tdm::vec4<float>{-1.19209e-07f, 0.0f, 2.98023e-07f, 1.0f}};
ASSERT_MAT_NEAR(fm, expected, 0.0001f);
}
TEST_F(MatTestOperators, TestCompoundAssignmentDivideMat) {
tdm::mat4<float> fm{tdm::vec4<float>{0.6f, 0.2f, 0.3f, 0.4f},
tdm::vec4<float>{0.2f, 0.7f, 0.5f, 0.3f},
tdm::vec4<float>{0.3f, 0.5f, 0.7f, 0.2f},
tdm::vec4<float>{0.4f, 0.3f, 0.2f, 0.6f}};
tdm::mat4<float> divisor{fm};
fm /= divisor;
tdm::mat4<float>
expected{tdm::vec4<float>{1.0f, -5.96046e-08f, 2.38419e-07f, -2.38419e-07f},
tdm::vec4<float>{-1.19209e-07f, 1.0f, 4.47035e-07f, -1.19209e-07f},
tdm::vec4<float>{-1.19209e-07f, 2.98023e-07f, 1.0f, -2.98023e-07f},
tdm::vec4<float>{-1.19209e-07f, 0.0f, 2.98023e-07f, 1.0f}};
ASSERT_MAT_NEAR(fm, expected, 0.0001f);
}
TEST_F(MatTestOperators, TestUnaryPlus) {
tdm::vec4<int> v{-4, -3, 5, 6};
tdm::mat4<int> m1{v, v2, v3, v4};
tdm::mat4<int> m2 = +m1;
ASSERT_EQ(m2[0], v);
ASSERT_EQ(m2[1], v2);
ASSERT_EQ(m2[2], v3);
ASSERT_EQ(m2[3], v4);
}
TEST_F(MatTestOperators, TestUnaryMinus) {
tdm::mat4<int> m1 = -m;
ASSERT_EQ(m1[0], -v1);
ASSERT_EQ(m1[1], -v2);
ASSERT_EQ(m1[2], -v3);
ASSERT_EQ(m1[3], -v4);
}
TEST_F(MatTestOperators, TestEquality) {
auto m1 = m;
ASSERT_TRUE(m == m1);
ASSERT_FALSE(m == m_rev);
}
TEST_F(MatTestOperators, TestNonEquality) {
auto m1 = m;
ASSERT_FALSE(m != m1);
ASSERT_TRUE(m != m_rev);
}
TEST_F(MatTestOperators, TestAddScalarMat) {
auto res = 2 + m;
ASSERT_EQ(res[0], v1 + 2);
ASSERT_EQ(res[1], v2 + 2);
ASSERT_EQ(res[2], v3 + 2);
ASSERT_EQ(res[3], v4 + 2);
}
TEST_F(MatTestOperators, TestAddMatScalar) {
auto res = m + 2;
ASSERT_EQ(res[0], v1 + 2);
ASSERT_EQ(res[1], v2 + 2);
ASSERT_EQ(res[2], v3 + 2);
ASSERT_EQ(res[3], v4 + 2);
}
TEST_F(MatTestOperators, TestAddMatMat) {
auto res = m + m_rev;
ASSERT_EQ(res[0], v1 + v4);
ASSERT_EQ(res[1], v2 + v3);
ASSERT_EQ(res[2], v3 + v2);
ASSERT_EQ(res[3], v4 + v1);
}
TEST_F(MatTestOperators, TestSubtractScalarMat) {
auto res = 2 - m;
ASSERT_EQ(res[0], 2 - v1);
ASSERT_EQ(res[1], 2 - v2);
ASSERT_EQ(res[2], 2 - v3);
ASSERT_EQ(res[3], 2 - v4);
}
TEST_F(MatTestOperators, TestSubtractMatScalar) {
auto res = m - 2;
ASSERT_EQ(res[0], v1 - 2);
ASSERT_EQ(res[1], v2 - 2);
ASSERT_EQ(res[2], v3 - 2);
ASSERT_EQ(res[3], v4 - 2);
}
TEST_F(MatTestOperators, TestSubtractMatMat) {
auto res = m - m_rev;
ASSERT_EQ(res[0], v1 - v4);
ASSERT_EQ(res[1], v2 - v3);
ASSERT_EQ(res[2], v3 - v2);
ASSERT_EQ(res[3], v4 - v1);
}
TEST_F(MatTestOperators, TestMultiplyScalarMat) {
auto res = 2 * m;
ASSERT_EQ(res[0], v1 * 2);
ASSERT_EQ(res[1], v2 * 2);
ASSERT_EQ(res[2], v3 * 2);
ASSERT_EQ(res[3], v4 * 2);
}
TEST_F(MatTestOperators, TestMultiplyMatScalar) {
auto res = m * 2;
ASSERT_EQ(res[0], v1 * 2);
ASSERT_EQ(res[1], v2 * 2);
ASSERT_EQ(res[2], v3 * 2);
ASSERT_EQ(res[3], v4 * 2);
}
TEST_F(MatTestOperators, TestMultiplyMat4x4Mat4x4) {
auto res = m * m_rev;
ASSERT_EQ(res[0], tdm::vec4<int>(50, 60, 70, 80));
ASSERT_EQ(res[1], tdm::vec4<int>(162, 188, 214, 240));
ASSERT_EQ(res[2], tdm::vec4<int>(274, 316, 358, 400));
ASSERT_EQ(res[3], tdm::vec4<int>(386, 444, 502, 560));
}
TEST_F(MatTestOperators, TestMultiplyMat4x3Mat3x4) {
tdm::mat<4, 3, int> m4x3{
1, 2, 3,
5, 6, 7,
9, 10, 11,
13, 14, 15
};
tdm::mat<3, 2, int> m3x2{
3, 4,
7, 8,
11, 12
};
tdm::mat<4, 2, int> res = m4x3 * m3x2;
ASSERT_EQ(res[0], tdm::vec2<int>(50, 56));
ASSERT_EQ(res[1], tdm::vec2<int>(134, 152));
ASSERT_EQ(res[2], tdm::vec2<int>(218, 248));
ASSERT_EQ(res[3], tdm::vec2<int>(302, 344));
}
TEST_F(MatTestOperators, TestMultiplyMat4x4Vec) {
tdm::vec4<int> v{2, 3, 4, 5};
auto res = m * v;
ASSERT_EQ(res, tdm::vec4<int>(40, 96, 152, 208));
}
TEST_F(MatTestOperators, TestMultiplyVecMat4x4) {
tdm::vec4<int> v{2, 3, 4, 5};
auto res = v * m;
ASSERT_EQ(res, tdm::vec4<int>(118, 132, 146, 160));
}
TEST_F(MatTestOperators, TestMultiplyMat4x3Vec) {
tdm::mat<4, 3, int> m4x3{
1, 2, 3,
5, 6, 7,
9, 10, 11,
13, 14, 15
};
tdm::vec3<int> v{2, 3, 4};
tdm::vec4<int> res = m4x3 * v;
ASSERT_EQ(res, tdm::vec4<int>(20, 56, 92, 128));
}
TEST_F(MatTestOperators, TestMultiplyVecMat4x3) {
tdm::vec4<int> v{2, 3, 4, 5};
tdm::mat<4, 3, int> m4x3{
1, 2, 3,
5, 6, 7,
9, 10, 11,
13, 14, 15
};
tdm::vec3<int> res = v * m4x3;
ASSERT_EQ(res, tdm::vec3<int>(118, 132, 146));
}
TEST_F(MatTestOperators, TestDivideScalarMat) {
auto res = 2 / m;
ASSERT_EQ(res[0], 2 / v1);
ASSERT_EQ(res[1], 2 / v2);
ASSERT_EQ(res[2], 2 / v3);
ASSERT_EQ(res[3], 2 / v4);
}
TEST_F(MatTestOperators, TestDivideMatScalar) {
auto res = m / 2;
ASSERT_EQ(res[0], v1 / 2);
ASSERT_EQ(res[1], v2 / 2);
ASSERT_EQ(res[2], v3 / 2);
ASSERT_EQ(res[3], v4 / 2);
}
TEST_F(MatTestOperators, TestDivideMatMat) {
const tdm::mat4<float> fm{tdm::vec4<float>{0.6f, 0.2f, 0.3f, 0.4f},
tdm::vec4<float>{0.2f, 0.7f, 0.5f, 0.3f},
tdm::vec4<float>{0.3f, 0.5f, 0.7f, 0.2f},
tdm::vec4<float>{0.4f, 0.3f, 0.2f, 0.6f}};
const tdm::mat4<float> divisor{fm[0], fm[1], fm[2], fm[3]};
auto res = fm / divisor;
tdm::mat4<float>
expected{tdm::vec4<float>{1.0f, -5.96046e-08f, 2.38419e-07f, -2.38419e-07f},
tdm::vec4<float>{-1.19209e-07f, 1.0f, 4.47035e-07f, -1.19209e-07f},
tdm::vec4<float>{-1.19209e-07f, 2.98023e-07f, 1.0f, -2.98023e-07f},
tdm::vec4<float>{-1.19209e-07f, 0.0f, 2.98023e-07f, 1.0f}};
ASSERT_MAT_NEAR(res, expected, 0.0001f);
}
TEST_F(MatTestOperators, TestDivideMatVec) {
tdm::vec4<int> v{2, 3, 4, 5};
auto res = invertible / v;
ASSERT_EQ(res, tdm::vec4<int>(-176, -87, 20, 119));
}
TEST_F(MatTestOperators, TestDivideVecMat) {
tdm::vec4<int> v{2, 3, 4, 5};
auto res = v / invertible;
ASSERT_EQ(res, tdm::vec4<int>(-5, 12, 9, 0));
}
namespace {
class MatTestMembers : public ::testing::Test {
protected:
void SetUp() override {
v1 = tdm::vec4<int>{1, 2, 3, 4};
v2 = tdm::vec4<int>{5, 6, 7, 8};
v3 = tdm::vec4<int>{9, 10, 11, 12};
v4 = tdm::vec4<int>{13, 14, 15, 16};
m = tdm::mat4<int>{v1, v2, v3, v4};
}
protected:
tdm::vec4<int> v1;
tdm::vec4<int> v2;
tdm::vec4<int> v3;
tdm::vec4<int> v4;
tdm::mat4<int> m;
};
} // namespace
TEST_F(MatTestMembers, TestRow) {
ASSERT_EQ(m.row(0), v1);
ASSERT_EQ(m.row(1), v2);
ASSERT_EQ(m.row(2), v3);
ASSERT_EQ(m.row(3), v4);
}
TEST_F(MatTestMembers, TestCol) {
ASSERT_EQ(m.column(0), tdm::vec4<int>(1, 5, 9, 13));
ASSERT_EQ(m.column(1), tdm::vec4<int>(2, 6, 10, 14));
ASSERT_EQ(m.column(2), tdm::vec4<int>(3, 7, 11, 15));
ASSERT_EQ(m.column(3), tdm::vec4<int>(4, 8, 12, 16));
}
TEST_F(MatTestMembers, TestSubMatSquare) {
tdm::mat2<int> sm2 = m.submat<2, 2>(1, 1);
ASSERT_EQ(sm2[0], tdm::vec2<int>(6, 7));
ASSERT_EQ(sm2[1], tdm::vec2<int>(10, 11));
tdm::mat3<int> sm3 = m.submat<3, 3>(1, 0);
ASSERT_EQ(sm3[0], tdm::vec3<int>(5, 6, 7));
ASSERT_EQ(sm3[1], tdm::vec3<int>(9, 10, 11));
ASSERT_EQ(sm3[2], tdm::vec3<int>(13, 14, 15));
}
TEST_F(MatTestMembers, TestSubMatNonSquare) {
tdm::mat<2, 3, int> sm2 = m.submat<2, 3>(1, 1);
ASSERT_EQ(sm2[0], tdm::vec3<int>(6, 7, 8));
ASSERT_EQ(sm2[1], tdm::vec3<int>(10, 11, 12));
tdm::mat<3, 4, int> sm3 = m.submat<3, 4>(1, 0);
ASSERT_EQ(sm3[0], tdm::vec4<int>(5, 6, 7, 8));
ASSERT_EQ(sm3[1], tdm::vec4<int>(9, 10, 11, 12));
ASSERT_EQ(sm3[2], tdm::vec4<int>(13, 14, 15, 16));
}
TEST_F(MatTestMembers, TestApplyMat3) {
std::size_t count{};
tdm::mat3<int> m1{tdm::vec3<int>{1, 2, 3},
tdm::vec3<int>{4, 5, 6},
tdm::vec3<int>{7, 8, 9}};
m1.apply([&](tdm::mat3<int>::row_type& row, tdm::dim_t /*unused*/) {
ASSERT_EQ(row, m1[count]);
++count;
});
ASSERT_EQ(count, 3u);
}
TEST_F(MatTestMembers, TestApplyMat4) {
std::size_t count{};
m.apply([&](tdm::mat4<int>::row_type& row, tdm::dim_t /*unused*/) {
ASSERT_EQ(row, m[count]);
++count;
});
ASSERT_EQ(count, 4u);
}
TEST_F(MatTestMembers, TestTranspose) {
auto m_copy = m;
m.transpose();
ASSERT_EQ(m[0], m_copy.column(0));
ASSERT_EQ(m[1], m_copy.column(1));
ASSERT_EQ(m[2], m_copy.column(2));
ASSERT_EQ(m[3], m_copy.column(3));
}
Reference in New Issue View Git Blame Copy Permalink