424 lines
13 KiB
C++
424 lines
13 KiB
C++
|
#include "stdafx.h"
|
||
|
|
#include "CppUnitTest.h"
|
||
|
|
#include "../Src/lmath/lmath.h"
|
||
|
|
#include "../Src/lmath/lm_vector_sse.h"
|
||
|
|
|
||
|
|
using namespace Microsoft::VisualStudio::CppUnitTestFramework;
|
||
|
|
using namespace lm;
|
||
|
|
|
||
|
|
namespace lmath_test {
|
||
|
|
TEST_CLASS(lm_vector_test_class) {
|
||
|
|
public:
|
||
|
|
|
||
|
|
TEST_METHOD(lm_vector_test_sse_constructors_and_getters) {
|
||
|
|
lm::float4_sse v0;
|
||
|
|
Assert::AreEqual(0.0f, v0.get<0>());
|
||
|
|
Assert::AreEqual(0.0f, v0.get<1>());
|
||
|
|
Assert::AreEqual(0.0f, v0.get<2>());
|
||
|
|
Assert::AreEqual(0.0f, v0.get<3>());
|
||
|
|
|
||
|
|
lm::float4_sse v1(5.0f);
|
||
|
|
Assert::AreEqual(5.0f, v1.get<0>(), L"0");
|
||
|
|
Assert::AreEqual(5.0f, v1.get<1>(), L"1");
|
||
|
|
Assert::AreEqual(5.0f, v1.get<2>(), L"2");
|
||
|
|
Assert::AreEqual(5.0f, v1.get<3>(), L"3");
|
||
|
|
|
||
|
|
lm::float4_sse v2(2,3,4,5);
|
||
|
|
Assert::AreEqual(2.0f, v2.get<0>(), L"0");
|
||
|
|
Assert::AreEqual(3.0f, v2.get<1>(), L"1");
|
||
|
|
Assert::AreEqual(4.0f, v2.get<2>(), L"2");
|
||
|
|
Assert::AreEqual(5.0f, v2.get<3>(), L"3");
|
||
|
|
|
||
|
|
Assert::AreEqual(v2.get(0), v2.get<0>(), L"0");
|
||
|
|
Assert::AreEqual(v2.get(1), v2.get<1>(), L"1");
|
||
|
|
Assert::AreEqual(v2.get(2), v2.get<2>(), L"2");
|
||
|
|
Assert::AreEqual(v2.get(3), v2.get<3>(), L"3");
|
||
|
|
|
||
|
|
|
||
|
|
auto m1 = v2 * v2;
|
||
|
|
Assert::AreEqual(m1.get<0>(), 4.0f, L"0");
|
||
|
|
Assert::AreEqual(m1.get<1>(), 9.0f, L"1");
|
||
|
|
Assert::AreEqual(m1.get<2>(), 16.0f, L"2");
|
||
|
|
Assert::AreEqual(m1.get<3>(), 25.0f, L"3");
|
||
|
|
|
||
|
|
v2 *= v2;
|
||
|
|
Assert::AreEqual(v2.get<0>(), 4.0f, L"0");
|
||
|
|
Assert::AreEqual(v2.get<1>(), 9.0f, L"1");
|
||
|
|
Assert::AreEqual(v2.get<2>(), 16.0f, L"2");
|
||
|
|
Assert::AreEqual(v2.get<3>(), 25.0f, L"3");
|
||
|
|
|
||
|
|
auto d1 = lm::float4_sse{ 2,4,6,8 };
|
||
|
|
auto d2 = d1 / lm::float4_sse{ 2,2,3,4 };
|
||
|
|
|
||
|
|
Assert::AreEqual(d2.get<0>(), 1.0f, L"0");
|
||
|
|
Assert::AreEqual(d2.get<1>(), 2.0f, L"1");
|
||
|
|
Assert::AreEqual(d2.get<2>(), 2.0f, L"2");
|
||
|
|
Assert::AreEqual(d2.get<3>(), 2.0f, L"3");
|
||
|
|
|
||
|
|
d1 /= lm::float4_sse{ 2,2,3,4 };
|
||
|
|
Assert::AreEqual(d1.get<0>(), 1.0f, L"0");
|
||
|
|
Assert::AreEqual(d1.get<1>(), 2.0f, L"1");
|
||
|
|
Assert::AreEqual(d1.get<2>(), 2.0f, L"2");
|
||
|
|
Assert::AreEqual(d1.get<3>(), 2.0f, L"3");
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
template<typename V>
|
||
|
|
void testMin() {
|
||
|
|
Assert::IsTrue(lm::min(1.0f, 2.0f) == 1.0f);
|
||
|
|
Assert::IsTrue(lm::min(2.0f, 1.0f) == 1.0f);
|
||
|
|
|
||
|
|
V v1(1.0f, 2.0f, 3.0f, 4.0f);
|
||
|
|
V v2(-5.0f, 0.0f, 5.0f, 7.0f);
|
||
|
|
|
||
|
|
const float epsilon = 0.001f;
|
||
|
|
Assert::IsTrue(lm::min(v1, v2).equals(V(-5.0f, 0.0f, 3.0f, 4.0f), epsilon));
|
||
|
|
Assert::IsTrue(lm::min(v2, v1).equals(V(-5.0f, 0.0f, 3.0f, 4.0f), epsilon));
|
||
|
|
Assert::IsTrue(lm::max(v1, v2).equals(V(1.0f, 2.0f, 5.0f, 7.0f), epsilon));
|
||
|
|
Assert::IsTrue(lm::max(v2, v1).equals(V(1.0f, 2.0f, 5.0f, 7.0f), epsilon));
|
||
|
|
|
||
|
|
Assert::AreEqual(1.0f, lm::min(v1), epsilon);
|
||
|
|
Assert::AreEqual(-5.0f, lm::min(v2), epsilon);
|
||
|
|
|
||
|
|
Assert::AreEqual(4.0f, lm::max(v1), epsilon);
|
||
|
|
Assert::AreEqual(7.0f, lm::max(v2), epsilon);
|
||
|
|
}
|
||
|
|
|
||
|
|
TEST_METHOD(lm_vector_test_min_sse) {
|
||
|
|
testMin<float4_sse>();
|
||
|
|
}
|
||
|
|
TEST_METHOD(lm_vector_test_dot_sse) {
|
||
|
|
Assert::AreEqual(0.0f, dot(float4_sse(), float4_sse()));
|
||
|
|
Assert::AreEqual(1.0f, dot(float4_sse(1,1,1,1), float4_sse(1,0,0,0)));
|
||
|
|
}
|
||
|
|
|
||
|
|
TEST_METHOD(lm_vector_test_min) {
|
||
|
|
testMin<float4>();
|
||
|
|
}
|
||
|
|
TEST_METHOD(lm_vector_test_operators) {
|
||
|
|
float3 v1(0.0f);
|
||
|
|
float3 v2(2.0f);
|
||
|
|
double3 v3(0.0);
|
||
|
|
|
||
|
|
Assert::IsTrue(v1 == v1);
|
||
|
|
Assert::IsFalse(v1 != v1);
|
||
|
|
|
||
|
|
Assert::IsFalse(v1 == v2);
|
||
|
|
Assert::IsTrue(v1 != v2);
|
||
|
|
|
||
|
|
Assert::IsTrue(v1 == v3);
|
||
|
|
Assert::IsFalse(v1 != v3);
|
||
|
|
const float epsilon = 0.0001f;
|
||
|
|
|
||
|
|
v2 = v2 / 2.0f;
|
||
|
|
Assert::IsTrue(v2.equals(float3(1.0f), epsilon));
|
||
|
|
v2 = v2 * 5.0f;
|
||
|
|
Assert::IsTrue(v2.equals(float3(5.0f), epsilon));
|
||
|
|
v2 = v2 + 5.0f;
|
||
|
|
Assert::IsTrue(v2.equals(float3(10.0f), epsilon));
|
||
|
|
v2 = v2 - 9.0f;
|
||
|
|
Assert::IsTrue(v2.equals(float3(1.0f), epsilon));
|
||
|
|
v2 *= 3.0f;
|
||
|
|
Assert::IsTrue(v2.equals(float3(3.0f), epsilon));
|
||
|
|
v2 /= 6.0f;
|
||
|
|
Assert::IsTrue(v2.equals(float3(0.5f), epsilon));
|
||
|
|
v2 += 1.5f;
|
||
|
|
Assert::IsTrue(v2.equals(float3(2.0f), epsilon));
|
||
|
|
v2 -= 2.0f;
|
||
|
|
Assert::IsTrue(v2.equals(float3(0.0f), epsilon));
|
||
|
|
|
||
|
|
}
|
||
|
|
TEST_METHOD(lm_vector_test_constructors_N1) {
|
||
|
|
Vector<float, 1> v1{};
|
||
|
|
Vector<float, 1> v2(2.2f);
|
||
|
|
Vector<float, 1> v3{ 3.3f };
|
||
|
|
Vector<float, 1> v4 = v3;
|
||
|
|
|
||
|
|
Vector<float, 1> v5;
|
||
|
|
v5 = v3;
|
||
|
|
|
||
|
|
Assert::AreEqual(2.2f, v2[0], L"v2 ctor fail");
|
||
|
|
Assert::AreEqual(3.3f, v3[0], L"v3 ctor fail");
|
||
|
|
Assert::AreEqual(3.3f, v4[0], L"v4 ctor fail");
|
||
|
|
Assert::AreEqual(3.3f, v5[0], L"v5 ctor fail");
|
||
|
|
}
|
||
|
|
TEST_METHOD(lm_vector_test_constructors_N2) {
|
||
|
|
Vector<float, 2> v1{};
|
||
|
|
Vector<float, 2> v2(2.2f, 3.3f);
|
||
|
|
Vector<float, 2> v3{ 4.4f };
|
||
|
|
Assert::AreEqual(2.2f, v2[0], L"v2 ctor fail");
|
||
|
|
Assert::AreEqual(3.3f, v2[1], L"v2 ctor fail");
|
||
|
|
Assert::AreEqual(4.4f, v3[0], L"v3 ctor fail");
|
||
|
|
Assert::AreEqual(4.4f, v3[1], L"v3 ctor fail");
|
||
|
|
}
|
||
|
|
TEST_METHOD(lm_vector_test_constructors_N3) {
|
||
|
|
Vector<float, 3> v1{};
|
||
|
|
Vector<float, 3> v2(2.2f, 3.3f, 4.4f);
|
||
|
|
Vector<float, 3> v3{ 5.5f };
|
||
|
|
|
||
|
|
Assert::AreEqual(2.2f, v2[0], L"v2 ctor fail");
|
||
|
|
Assert::AreEqual(3.3f, v2[1], L"v2 ctor fail");
|
||
|
|
Assert::AreEqual(4.4f, v2[2], L"v2 ctor fail");
|
||
|
|
|
||
|
|
Assert::AreEqual(5.5f, v3[0], L"v3 ctor fail");
|
||
|
|
Assert::AreEqual(5.5f, v3[1], L"v3 ctor fail");
|
||
|
|
Assert::AreEqual(5.5f, v3[2], L"v3 ctor fail");
|
||
|
|
|
||
|
|
Vector<float, 2> v4(1.1f, 2.2f);
|
||
|
|
Vector<float, 3> v5(v4, 3.3f);
|
||
|
|
|
||
|
|
Assert::AreEqual(1.1f, v5[0], L"v5 ctor fail");
|
||
|
|
Assert::AreEqual(2.2f, v5[1], L"v5 ctor fail");
|
||
|
|
Assert::AreEqual(3.3f, v5[2], L"v5 ctor fail");
|
||
|
|
|
||
|
|
Vector<float, 3> v6(3.3f, v4);
|
||
|
|
|
||
|
|
Assert::AreEqual(3.3f, v6[0], L"v6 ctor fail");
|
||
|
|
Assert::AreEqual(1.1f, v6[1], L"v6 ctor fail");
|
||
|
|
Assert::AreEqual(2.2f, v6[2], L"v6 ctor fail");
|
||
|
|
}
|
||
|
|
TEST_METHOD(lm_vector_test_constructors_N4) {
|
||
|
|
Vector<float, 4> v1{};
|
||
|
|
Vector<float, 4> v2(1.1f, 2.2f, 3.3f, 4.4f);
|
||
|
|
Vector<float, 4> v3{ 5.5f };
|
||
|
|
|
||
|
|
Assert::AreEqual(1.1f, v2[0], L"v2 ctor fail");
|
||
|
|
Assert::AreEqual(2.2f, v2[1], L"v2 ctor fail");
|
||
|
|
Assert::AreEqual(3.3f, v2[2], L"v2 ctor fail");
|
||
|
|
Assert::AreEqual(4.4f, v2[3], L"v2 ctor fail");
|
||
|
|
|
||
|
|
Assert::AreEqual(5.5f, v3[0], L"v3 ctor fail");
|
||
|
|
Assert::AreEqual(5.5f, v3[1], L"v3 ctor fail");
|
||
|
|
Assert::AreEqual(5.5f, v3[2], L"v3 ctor fail");
|
||
|
|
Assert::AreEqual(5.5f, v3[3], L"v3 ctor fail");
|
||
|
|
|
||
|
|
Vector<float, 2> p2_1{ 6.6f, 7.7f };
|
||
|
|
Vector<float, 2> p2_2{ 8.8f, 9.9f };
|
||
|
|
Vector<float, 3> p3{ 6.0f, 7.0f, 8.0f };
|
||
|
|
|
||
|
|
Vector<float, 4> v4{ p2_1, p2_2 };
|
||
|
|
Assert::AreEqual(p2_1[0], v4[0], L"v4 ctor fail");
|
||
|
|
Assert::AreEqual(p2_1[1], v4[1], L"v4 ctor fail");
|
||
|
|
Assert::AreEqual(p2_2[0], v4[2], L"v4 ctor fail");
|
||
|
|
Assert::AreEqual(p2_2[1], v4[3], L"v4 ctor fail");
|
||
|
|
|
||
|
|
Vector<float, 4> v5(p2_1, 2.0f, 3.0f);
|
||
|
|
Assert::AreEqual(p2_1[0], v5[0], L"v5 ctor fail");
|
||
|
|
Assert::AreEqual(p2_1[1], v5[1], L"v5 ctor fail");
|
||
|
|
Assert::AreEqual(2.0f, v5[2], L"v5 ctor fail");
|
||
|
|
Assert::AreEqual(3.0f, v5[3], L"v5 ctor fail");
|
||
|
|
|
||
|
|
Vector<float, 4> v6(2.0f, 3.0f, p2_1);
|
||
|
|
Assert::AreEqual(2.0f, v6[0], L"v6 ctor fail");
|
||
|
|
Assert::AreEqual(3.0f, v6[1], L"v6 ctor fail");
|
||
|
|
Assert::AreEqual(p2_1[0], v6[2], L"v6 ctor fail");
|
||
|
|
Assert::AreEqual(p2_1[1], v6[3], L"v6 ctor fail");
|
||
|
|
|
||
|
|
|
||
|
|
Vector<float, 4> v7(p3, 9.9f);
|
||
|
|
Assert::AreEqual(p3[0], v7[0], L"v7 ctor fail");
|
||
|
|
Assert::AreEqual(p3[1], v7[1], L"v7 ctor fail");
|
||
|
|
Assert::AreEqual(p3[2], v7[2], L"v7 ctor fail");
|
||
|
|
Assert::AreEqual(9.9f, v7[3], L"v7 ctor fail");
|
||
|
|
|
||
|
|
Vector<float, 4> v8(9.9f, p3);
|
||
|
|
Assert::AreEqual(9.9f, v8[0], L"v8 ctor fail");
|
||
|
|
Assert::AreEqual(p3[0], v8[1], L"v8 ctor fail");
|
||
|
|
Assert::AreEqual(p3[1], v8[2], L"v8 ctor fail");
|
||
|
|
Assert::AreEqual(p3[2], v8[3], L"v8 ctor fail");
|
||
|
|
|
||
|
|
}
|
||
|
|
TEST_METHOD(lm_vector_test_constructors_N) {
|
||
|
|
Vector<float, 7> v1(5.5f);
|
||
|
|
for (LmSize i = 0; i < 7; ++i) {
|
||
|
|
Assert::AreEqual(5.5f, v1[i], L"Vector N ctor fail");
|
||
|
|
}
|
||
|
|
|
||
|
|
Vector<float, 7> v2(0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f);
|
||
|
|
for (LmSize i = 0; i < 7; ++i) {
|
||
|
|
Assert::AreEqual((float)i, v2[i], L"Vector N ctor fail");
|
||
|
|
}
|
||
|
|
|
||
|
|
v1 = v2;
|
||
|
|
|
||
|
|
for (LmSize i = 0; i < 7; ++i) {
|
||
|
|
Assert::AreEqual((float)i, v1[i], L"Vector N ctor fail");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
TEST_METHOD(lm_vector_test_slice) {
|
||
|
|
float3 v1(1.0f, 2.0f, 3.0f);
|
||
|
|
|
||
|
|
auto& s1 = v1.slice<0, 1>();
|
||
|
|
Assert::AreEqual((LmSize)1, s1.Size, L"Invalid slice size");
|
||
|
|
Assert::AreEqual(1.0f, s1[0], L"Invalid slice value");
|
||
|
|
|
||
|
|
auto& s2 = v1.slice<0, 2>();
|
||
|
|
Assert::AreEqual((LmSize)2, s2.Size, L"Invalid slice size");
|
||
|
|
Assert::AreEqual(1.0f, s2[0], L"Invalid slice value");
|
||
|
|
Assert::AreEqual(2.0f, s2[1], L"Invalid slice value");
|
||
|
|
|
||
|
|
auto& s3 = v1.slice<0, 3>();
|
||
|
|
Assert::AreEqual((LmSize)3, s3.Size, L"Invalid slice size");
|
||
|
|
Assert::AreEqual(1.0f, s3[0], L"Invalid slice value");
|
||
|
|
Assert::AreEqual(2.0f, s3[1], L"Invalid slice value");
|
||
|
|
Assert::AreEqual(3.0f, s3[2], L"Invalid slice value");
|
||
|
|
|
||
|
|
auto& s4 = v1.slice<1, 1>();
|
||
|
|
Assert::AreEqual((LmSize)1, s4.Size, L"Invalid slice size");
|
||
|
|
Assert::AreEqual(2.0f, s4[0], L"Invalid slice value");
|
||
|
|
|
||
|
|
auto& s5 = v1.slice<2, 1>();
|
||
|
|
Assert::AreEqual((LmSize)1, s5.Size, L"Invalid slice size");
|
||
|
|
Assert::AreEqual(3.0f, s5[0], L"Invalid slice value");
|
||
|
|
}
|
||
|
|
TEST_METHOD(lm_vector_test_dot) {
|
||
|
|
double3 x{ 1.0, 0.0, 0.0 };
|
||
|
|
double3 y{ 0.0, 1.0, 0.0 };
|
||
|
|
double3 z{ 0.0, 0.0, 1.0 };
|
||
|
|
|
||
|
|
double3 _x{ -1.0, 0.0, 0.0 };
|
||
|
|
|
||
|
|
const double dotTolerance = 0.01;
|
||
|
|
Assert::AreEqual(1.0, lm::dot(x, x), dotTolerance, L"Dot fail");
|
||
|
|
Assert::AreEqual(1.0, lm::dot(y, y), dotTolerance, L"Dot fail");
|
||
|
|
Assert::AreEqual(1.0, lm::dot(z, z), dotTolerance, L"Dot fail");
|
||
|
|
|
||
|
|
Assert::AreEqual(0.0, lm::dot(x, y), dotTolerance, L"Dot fail");
|
||
|
|
Assert::AreEqual(0.0, lm::dot(y, z), dotTolerance, L"Dot fail");
|
||
|
|
Assert::AreEqual(0.0, lm::dot(x, z), dotTolerance, L"Dot fail");
|
||
|
|
|
||
|
|
Assert::AreEqual(-1.0, lm::dot(x, _x), dotTolerance, L"Dot fail");
|
||
|
|
|
||
|
|
double3 w{ 1.0, 1.0, 0.0 };
|
||
|
|
w = lm::normalize(w);
|
||
|
|
|
||
|
|
Assert::AreEqual(std::cos(lm::pi_d / 4.0), lm::dot(y, w), dotTolerance, L"Dot fail");
|
||
|
|
Assert::AreEqual(-std::cos(lm::pi_d / 4.0), lm::dot(y, w * -1.0f), dotTolerance, L"Dot fail");
|
||
|
|
}
|
||
|
|
TEST_METHOD(lm_vector_test_trigonometry) {
|
||
|
|
float3 v{ 2.0f, 3.0f, 4.0f };
|
||
|
|
|
||
|
|
auto vSin = lm::sin(v);
|
||
|
|
|
||
|
|
Assert::AreEqual(std::sin(v[0]), vSin[0], L"Sin fail");
|
||
|
|
Assert::AreEqual(std::sin(v[1]), vSin[1], L"Sin fail");
|
||
|
|
Assert::AreEqual(std::sin(v[2]), vSin[2], L"Sin fail");
|
||
|
|
}
|
||
|
|
TEST_METHOD(lm_vector_test_all_any) {
|
||
|
|
float3 v1{ 0.0f, 0.0f, 0.0f };
|
||
|
|
float3 v2{ 0.0f, 0.0f, 3.0f };
|
||
|
|
float3 v3{ 3.0f, 3.0f, 3.0f };
|
||
|
|
|
||
|
|
Assert::IsFalse(lm::all(v1));
|
||
|
|
Assert::IsFalse(lm::any(v1));
|
||
|
|
|
||
|
|
Assert::IsFalse(lm::all(v2));
|
||
|
|
Assert::IsTrue(lm::any(v2));
|
||
|
|
|
||
|
|
Assert::IsTrue(lm::all(v3));
|
||
|
|
Assert::IsTrue(lm::any(v3));
|
||
|
|
}
|
||
|
|
TEST_METHOD(lm_vector_test_unit) {
|
||
|
|
auto x2 = float2::unitX();
|
||
|
|
auto y2 = float2::unitY();
|
||
|
|
|
||
|
|
Assert::AreEqual(1.0f, x2[0]);
|
||
|
|
Assert::AreEqual(0.0f, x2[1]);
|
||
|
|
|
||
|
|
Assert::AreEqual(0.0f, y2[0]);
|
||
|
|
Assert::AreEqual(1.0f, y2[1]);
|
||
|
|
|
||
|
|
auto z3 = float3::unitZ();
|
||
|
|
auto w4 = float4::unitW();
|
||
|
|
|
||
|
|
Assert::AreEqual(0.0f, z3[0]);
|
||
|
|
Assert::AreEqual(0.0f, z3[1]);
|
||
|
|
Assert::AreEqual(1.0f, z3[2]);
|
||
|
|
|
||
|
|
|
||
|
|
Assert::AreEqual(0.0f, w4[0]);
|
||
|
|
Assert::AreEqual(0.0f, w4[1]);
|
||
|
|
Assert::AreEqual(0.0f, w4[2]);
|
||
|
|
Assert::AreEqual(1.0f, w4[3]);
|
||
|
|
}
|
||
|
|
TEST_METHOD(lm_vector_test_length_lengthSquared) {
|
||
|
|
float3 v1{ 1.0f, 0.0f, 0.0f };
|
||
|
|
float3 v2{ 0.0f, 2.0f, 0.0f };
|
||
|
|
float3 v3{ 1.0f, 1.0f, 0.0f };
|
||
|
|
const float tolerance = 0.001f;
|
||
|
|
|
||
|
|
Assert::AreEqual(1.0f, v1.length(), tolerance);
|
||
|
|
Assert::AreEqual(1.0f, v1.lengthSquared(), tolerance);
|
||
|
|
|
||
|
|
Assert::AreEqual(2.0f, v2.length(), tolerance);
|
||
|
|
Assert::AreEqual(4.0f, v2.lengthSquared(), tolerance);
|
||
|
|
|
||
|
|
Assert::AreEqual(std::sqrt(2.0f), v3.length(), tolerance);
|
||
|
|
Assert::AreEqual(2.0f, v3.lengthSquared(), tolerance);
|
||
|
|
}
|
||
|
|
|
||
|
|
TEST_METHOD(lm_vector_test_equals) {
|
||
|
|
float3 v1(1.0f, 2.0f, 3.0f);
|
||
|
|
float3 v2(2.0f, 2.0f, 3.0f);
|
||
|
|
|
||
|
|
float tolerance = 0.001f;
|
||
|
|
Assert::IsTrue(v1.equals(v1, tolerance));
|
||
|
|
Assert::IsFalse(v1.equals(v2, tolerance));
|
||
|
|
|
||
|
|
for (LmSize i = 0; i < 3; ++i) {
|
||
|
|
v2[i] = v1[i] + tolerance * 2.0f;
|
||
|
|
}
|
||
|
|
|
||
|
|
Assert::IsFalse(v1.equals(v2, tolerance));
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
TEST_METHOD(lm_vector_test_cross) {
|
||
|
|
float3 x{ 1.0f, 0.0f, 0.0f };
|
||
|
|
float3 y{ 0.0f, 1.0f, 0.0f };
|
||
|
|
float3 z{ 0.0f, 0.0f, 1.0f };
|
||
|
|
const float tolerance = 0.001f;
|
||
|
|
|
||
|
|
auto c1 = lm::cross(y, z);
|
||
|
|
auto c2 = lm::cross(z, y);
|
||
|
|
|
||
|
|
Assert::AreEqual(1.0f, c1[0], tolerance);
|
||
|
|
Assert::AreEqual(0.0f, c1[1], tolerance);
|
||
|
|
Assert::AreEqual(0.0f, c1[2], tolerance);
|
||
|
|
|
||
|
|
Assert::AreEqual(-1.0f, c2[0], tolerance);
|
||
|
|
Assert::AreEqual(0.0f, c2[1], tolerance);
|
||
|
|
Assert::AreEqual(0.0f, c2[2], tolerance);
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
TEST_METHOD(lm_vector_test_normalize) {
|
||
|
|
float3 v1{ 1.0f,0.0f, 0.0f };
|
||
|
|
float3 v2{ 2.0f,0.0f, 0.0f };
|
||
|
|
float3 v3{ 2.0f,2.0f, 2.0f };
|
||
|
|
float3 v4{ -2.0f, -2.0f, -2.0f };
|
||
|
|
|
||
|
|
const float tolerance = 0.001f;
|
||
|
|
Assert::AreEqual(1.0f, v1.normalized().length(), tolerance);
|
||
|
|
Assert::AreEqual(1.0f, v2.normalized().length(), tolerance);
|
||
|
|
Assert::AreEqual(1.0f, v3.normalized().length(), tolerance);
|
||
|
|
Assert::AreEqual(1.0f, v4.normalized().length(), tolerance);
|
||
|
|
}
|
||
|
|
|
||
|
|
TEST_METHOD(lm_vector_test_lerp) {
|
||
|
|
float3 v1{ -1.0f };
|
||
|
|
float3 v2{ 1.0f};
|
||
|
|
|
||
|
|
const float tolerance = 0.001f;
|
||
|
|
Assert::IsTrue(lm::lerp(v1, v2, 0.0f).equals(v1, tolerance));
|
||
|
|
Assert::IsTrue(lm::lerp(v1, v2, 1.0f).equals(v2, tolerance));
|
||
|
|
Assert::IsTrue(lm::lerp(v1, v2, 0.5f).equals(float3(0.0f, 0.0f, 0.0f), tolerance));
|
||
|
|
Assert::IsTrue(lm::lerp(v1, v2, 0.1f).equals(float3(-0.8f, -0.8f, -0.8f), tolerance));
|
||
|
|
Assert::IsTrue(lm::lerp(v1, v2, 0.9f).equals(float3(0.8f, 0.8f, 0.8f), tolerance));
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
};
|
||
|
|
}
|