Pascal Serrarens
9b76dfd094
Some checks failed
Build and Run C++ Unit Tests / build-and-test (push) Failing after 29s
809 lines
22 KiB
C++
809 lines
22 KiB
C++
#if GTEST
|
|
#include <gtest/gtest.h>
|
|
#include <math.h>
|
|
#include <limits>
|
|
|
|
#include "Vector3.h"
|
|
|
|
#define FLOAT_INFINITY std::numeric_limits<float>::infinity()
|
|
|
|
using BaseTypes = ::testing::Types<float, int>;
|
|
using FpTypes = ::testing::Types<float>;
|
|
|
|
template <typename T>
|
|
class Vector3Tests : public ::testing::Test {};
|
|
TYPED_TEST_SUITE(Vector3Tests, BaseTypes);
|
|
|
|
template <typename T>
|
|
class Vector3FpTests : public ::testing::Test {};
|
|
TYPED_TEST_SUITE(Vector3FpTests, FpTypes);
|
|
|
|
TYPED_TEST(Vector3FpTests, FromSpherical) {
|
|
using T = TypeParam;
|
|
using Vector3 = Vector3Of<T>;
|
|
|
|
Vector3 v = Vector3(0, 0, 1);
|
|
SphericalOf<float> s = SphericalOf<float>::FromVector3(v);
|
|
Vector3 r = Vector3::FromSpherical(s);
|
|
|
|
EXPECT_FLOAT_EQ(r.horizontal, 0.0F) << "toVector3.x 0 0 1";
|
|
EXPECT_NEAR(r.vertical, 0.0F, 1.0e-06) << "toVector3.y 0 0 1";
|
|
EXPECT_FLOAT_EQ(r.depth, 1.0F) << "toVector3.z 0 0 1";
|
|
|
|
v = Vector3(0, 1, 0);
|
|
s = SphericalOf<float>::FromVector3(v);
|
|
r = Vector3::FromSpherical(s);
|
|
|
|
EXPECT_FLOAT_EQ(r.horizontal, 0.0F) << "toVector3.x 0 1 0";
|
|
EXPECT_FLOAT_EQ(r.vertical, 1.0F) << "toVector3.y 0 1 0";
|
|
EXPECT_NEAR(r.depth, 0.0F, 1.0e-06) << "toVector3.z 0 1 0";
|
|
|
|
v = Vector3(1, 0, 0);
|
|
s = SphericalOf<float>::FromVector3(v);
|
|
r = Vector3::FromSpherical(s);
|
|
|
|
EXPECT_FLOAT_EQ(r.horizontal, 1.0F) << "toVector3.x 1 0 0";
|
|
EXPECT_NEAR(r.vertical, 0.0F, 1.0e-06) << "toVector3.y 1 0 0";
|
|
EXPECT_NEAR(r.depth, 0.0F, 1.0e-06) << "toVector3.z 1 0 0";
|
|
}
|
|
|
|
TYPED_TEST(Vector3Tests, Magnitude) {
|
|
using T = TypeParam;
|
|
using Vector3 = Vector3Of<T>;
|
|
|
|
Vector3 v = Vector3(1, 2, 3);
|
|
float m = 0;
|
|
|
|
m = v.Magnitude();
|
|
EXPECT_FLOAT_EQ(m, 3.741657F) << "v.magnitude 1 2 3";
|
|
|
|
m = Vector3::MagnitudeOf(v);
|
|
EXPECT_FLOAT_EQ(m, 3.741657F) << "Vector3::Magnitude 1 2 3";
|
|
|
|
v = Vector3(-1, -2, -3);
|
|
m = v.Magnitude();
|
|
EXPECT_FLOAT_EQ(m, 3.741657F) << "v.magnitude -1 -2 -3";
|
|
|
|
v = Vector3(0, 0, 0);
|
|
m = v.Magnitude();
|
|
EXPECT_FLOAT_EQ(m, 0) << "v.magnitude 0 0 0 ";
|
|
}
|
|
|
|
TYPED_TEST(Vector3FpTests, Magnitude) {
|
|
using T = TypeParam;
|
|
using Vector3 = Vector3Of<T>;
|
|
|
|
Vector3 v;
|
|
float m;
|
|
|
|
if (std::numeric_limits<float>::is_iec559) {
|
|
v = Vector3(FLOAT_INFINITY, FLOAT_INFINITY, FLOAT_INFINITY);
|
|
m = v.Magnitude();
|
|
EXPECT_FLOAT_EQ(m, FLOAT_INFINITY)
|
|
<< "v.magnitude INFINITY INFINITY INFINITY ";
|
|
|
|
v = Vector3(-FLOAT_INFINITY, -FLOAT_INFINITY, -FLOAT_INFINITY);
|
|
m = v.Magnitude();
|
|
EXPECT_FLOAT_EQ(m, FLOAT_INFINITY)
|
|
<< "v.magnitude -INFINITY -INFINITY -INFINITY ";
|
|
}
|
|
}
|
|
|
|
TYPED_TEST(Vector3Tests, SqrMagnitude) {
|
|
using T = TypeParam;
|
|
using Vector3 = Vector3Of<T>;
|
|
|
|
Vector3 v = Vector3(1, 2, 3);
|
|
float m = 0;
|
|
|
|
m = v.SqrMagnitude();
|
|
EXPECT_FLOAT_EQ(m, 14) << "v.sqrMagnitude 1 2 3";
|
|
|
|
m = Vector3::SqrMagnitudeOf(v);
|
|
EXPECT_FLOAT_EQ(m, 14) << "Vector3::SqrMagnitude 1 2 3";
|
|
|
|
v = Vector3(-1, -2, -3);
|
|
m = v.SqrMagnitude();
|
|
EXPECT_FLOAT_EQ(m, 14) << "v.sqrMagnitude -1 -2 -3";
|
|
|
|
v = Vector3(0, 0, 0);
|
|
m = v.SqrMagnitude();
|
|
EXPECT_FLOAT_EQ(m, 0) << "v.sqrMagnitude 0 0 0 ";
|
|
}
|
|
|
|
TYPED_TEST(Vector3FpTests, SqrMagnitude) {
|
|
using T = TypeParam;
|
|
using Vector3 = Vector3Of<T>;
|
|
|
|
Vector3 v;
|
|
float m;
|
|
|
|
if (std::numeric_limits<float>::is_iec559) {
|
|
v = Vector3(FLOAT_INFINITY, FLOAT_INFINITY, FLOAT_INFINITY);
|
|
m = v.SqrMagnitude();
|
|
EXPECT_FLOAT_EQ(m, FLOAT_INFINITY)
|
|
<< "v.sqrMagnitude INFINITY INFINITY INFINITY ";
|
|
|
|
v = Vector3(-FLOAT_INFINITY, -FLOAT_INFINITY, -FLOAT_INFINITY);
|
|
m = v.SqrMagnitude();
|
|
EXPECT_FLOAT_EQ(m, FLOAT_INFINITY)
|
|
<< "v.sqrMagnitude -INFINITY -INFINITY -INFINITY ";
|
|
}
|
|
}
|
|
|
|
TYPED_TEST(Vector3Tests, Normalize) {
|
|
using T = TypeParam;
|
|
using Vector3 = Vector3Of<T>;
|
|
|
|
Vector3 v1 = Vector3(0, 2, 0);
|
|
Vector3 v = Vector3::zero;
|
|
|
|
v = v1.Normalized();
|
|
EXPECT_TRUE(v == Vector3(0, 1, 0)) << "v.normalized 0 2 0";
|
|
|
|
v = Vector3::Normalize(v1);
|
|
EXPECT_TRUE(v == Vector3(0, 1, 0)) << "Vector3::Normalize 0 2 0";
|
|
|
|
v1 = Vector3(0, -2, 0);
|
|
v = v1.Normalized();
|
|
EXPECT_TRUE(v == Vector3(0, -1, 0)) << "v.normalized 0 -2 0";
|
|
|
|
v1 = Vector3(0, 0, 0);
|
|
v = v1.Normalized();
|
|
EXPECT_TRUE(v == Vector3(0, 0, 0)) << "v.normalized 0 0 0";
|
|
}
|
|
|
|
TYPED_TEST(Vector3FpTests, Normalize) {
|
|
using T = TypeParam;
|
|
using Vector3 = Vector3Of<T>;
|
|
|
|
bool r = false;
|
|
|
|
Vector3 v1 = Vector3(0, 2, 0);
|
|
Vector3 v = Vector3::zero;
|
|
|
|
if (std::numeric_limits<float>::is_iec559) {
|
|
v1 = Vector3(FLOAT_INFINITY, FLOAT_INFINITY, FLOAT_INFINITY);
|
|
v = v1.Normalized();
|
|
r = isnan(v.horizontal) && isnan(v.vertical) && isnan(v.depth);
|
|
EXPECT_TRUE(r) << "v.normalized INFINITY INFINITY INFINITY";
|
|
|
|
v1 = Vector3(-FLOAT_INFINITY, -FLOAT_INFINITY, -FLOAT_INFINITY);
|
|
v = v1.Normalized();
|
|
r = isnan(v.horizontal) && isnan(v.vertical) && isnan(v.depth);
|
|
EXPECT_TRUE(r) << "v.normalized -INFINITY -INFINITY -INFINITY";
|
|
}
|
|
}
|
|
|
|
TYPED_TEST(Vector3Tests, Negate) {
|
|
using T = TypeParam;
|
|
using Vector3 = Vector3Of<T>;
|
|
|
|
Vector3 v1 = Vector3(4, 5, 6);
|
|
Vector3 v = Vector3::zero;
|
|
|
|
v = -v1;
|
|
EXPECT_TRUE(v == Vector3(-4, -5, -6)) << "- 4 5 6";
|
|
|
|
v1 = Vector3(-4, -5, -6);
|
|
v = -v1;
|
|
EXPECT_TRUE(v == Vector3(4, 5, 6)) << "- -4 -5 -6";
|
|
|
|
v1 = Vector3(0, 0, 0);
|
|
v = -v1;
|
|
EXPECT_TRUE(v == Vector3(0, 0, 0)) << "- 0 0 0";
|
|
}
|
|
|
|
TYPED_TEST(Vector3FpTests, Negate) {
|
|
using T = TypeParam;
|
|
using Vector3 = Vector3Of<T>;
|
|
|
|
Vector3 v1 = Vector3(4, 5, 6);
|
|
Vector3 v = Vector3::zero;
|
|
|
|
if (std::numeric_limits<float>::is_iec559) {
|
|
v1 = Vector3(FLOAT_INFINITY, FLOAT_INFINITY, FLOAT_INFINITY);
|
|
v = -v1;
|
|
EXPECT_TRUE(v == Vector3(-FLOAT_INFINITY, -FLOAT_INFINITY, -FLOAT_INFINITY))
|
|
<< "- INFINITY INFINITY INFINITY";
|
|
|
|
v1 = Vector3(-FLOAT_INFINITY, -FLOAT_INFINITY, -FLOAT_INFINITY);
|
|
v = -v1;
|
|
EXPECT_TRUE(v == Vector3(FLOAT_INFINITY, FLOAT_INFINITY, FLOAT_INFINITY))
|
|
<< "- -INFINITY -INFINITY -INFINITY";
|
|
}
|
|
}
|
|
|
|
TYPED_TEST(Vector3Tests, Subtract) {
|
|
using T = TypeParam;
|
|
using Vector3 = Vector3Of<T>;
|
|
;
|
|
|
|
Vector3 v1 = Vector3(4, 5, 6);
|
|
Vector3 v2 = Vector3(1, 2, 3);
|
|
Vector3 v = Vector3::zero;
|
|
|
|
v = v1 - v2;
|
|
EXPECT_TRUE(v == Vector3(3, 3, 3)) << "4 5 6 - 1 2 3";
|
|
|
|
v2 = Vector3(-1, -2, -3);
|
|
v = v1 - v2;
|
|
EXPECT_TRUE(v == Vector3(5, 7, 9)) << "4 5 6 - -1 -2 -3";
|
|
|
|
v2 = Vector3(4, 5, 6);
|
|
v = v1 - v2;
|
|
EXPECT_TRUE(v == Vector3(0, 0, 0)) << "4 5 6 - 4 5 6";
|
|
|
|
v2 = Vector3(0, 0, 0);
|
|
v = v1 - v2;
|
|
EXPECT_TRUE(v == Vector3(4, 5, 6)) << "4 5 6 - 0 0 0";
|
|
}
|
|
|
|
TYPED_TEST(Vector3FpTests, Subtract) {
|
|
using T = TypeParam;
|
|
using Vector3 = Vector3Of<T>;
|
|
|
|
Vector3 v1 = Vector3(4, 5, 6);
|
|
Vector3 v2 = Vector3(1, 2, 3);
|
|
Vector3 v = Vector3::zero;
|
|
|
|
if (std::numeric_limits<float>::is_iec559) {
|
|
v2 = Vector3(FLOAT_INFINITY, FLOAT_INFINITY, FLOAT_INFINITY);
|
|
v = v1 - v2;
|
|
EXPECT_TRUE(v == Vector3(-FLOAT_INFINITY, -FLOAT_INFINITY, -FLOAT_INFINITY))
|
|
<< "4 5 6 - INFINITY INFINITY INFINITY";
|
|
|
|
v2 = Vector3(-FLOAT_INFINITY, -FLOAT_INFINITY, -FLOAT_INFINITY);
|
|
v = v1 - v2;
|
|
EXPECT_TRUE(v == Vector3(FLOAT_INFINITY, FLOAT_INFINITY, FLOAT_INFINITY))
|
|
<< "4 5 6 - -INFINITY -INFINITY -INFINITY";
|
|
}
|
|
}
|
|
|
|
TYPED_TEST(Vector3Tests, Addition) {
|
|
using T = TypeParam;
|
|
using Vector3 = Vector3Of<T>;
|
|
|
|
Vector3 v1 = Vector3(4, 5, 6);
|
|
Vector3 v2 = Vector3(1, 2, 3);
|
|
Vector3 v = Vector3::zero;
|
|
|
|
v = v1 + v2;
|
|
EXPECT_TRUE(v == Vector3(5, 7, 9)) << "4 5 6 + 1 2 3";
|
|
|
|
v2 = Vector3(-1, -2, -3);
|
|
v = v1 + v2;
|
|
EXPECT_TRUE(v == Vector3(3, 3, 3)) << "4 5 6 + -1 -2 -3";
|
|
|
|
v2 = Vector3(0, 0, 0);
|
|
v = v1 + v2;
|
|
EXPECT_TRUE(v == Vector3(4, 5, 6)) << "4 5 6 + 0 0 0";
|
|
}
|
|
|
|
TYPED_TEST(Vector3FpTests, Addition) {
|
|
using T = TypeParam;
|
|
using Vector3 = Vector3Of<T>;
|
|
|
|
Vector3 v1 = Vector3(4, 5, 6);
|
|
Vector3 v2 = Vector3(1, 2, 3);
|
|
Vector3 v = Vector3::zero;
|
|
|
|
if (std::numeric_limits<float>::is_iec559) {
|
|
v2 = Vector3(FLOAT_INFINITY, FLOAT_INFINITY, FLOAT_INFINITY);
|
|
v = v1 + v2;
|
|
EXPECT_TRUE(v == Vector3(FLOAT_INFINITY, FLOAT_INFINITY, FLOAT_INFINITY))
|
|
<< "4 5 6 + INFINITY INFINITY INFINITY";
|
|
|
|
v2 = Vector3(-FLOAT_INFINITY, -FLOAT_INFINITY, -FLOAT_INFINITY);
|
|
v = v1 + v2;
|
|
EXPECT_TRUE(v == Vector3(-FLOAT_INFINITY, -FLOAT_INFINITY, -FLOAT_INFINITY))
|
|
<< "4 5 6 + -INFINITY -INFINITY -INFINITY";
|
|
}
|
|
}
|
|
|
|
TYPED_TEST(Vector3Tests, Scale) {
|
|
using T = TypeParam;
|
|
using Vector3 = Vector3Of<T>;
|
|
;
|
|
|
|
Vector3 v1 = Vector3(4, 5, 6);
|
|
Vector3 v2 = Vector3(1, 2, 3);
|
|
Vector3 v = Vector3::zero;
|
|
|
|
v = Vector3::Scale(v1, v2);
|
|
EXPECT_TRUE(v == Vector3(4, 10, 18)) << "Scale 4 5 6 , 1 2 3";
|
|
|
|
v2 = Vector3(-1, -2, -3);
|
|
v = Vector3::Scale(v1, v2);
|
|
EXPECT_TRUE(v == Vector3(-4, -10, -18)) << "Scale 4 5 6 , -1 -2 -3";
|
|
|
|
v2 = Vector3(0, 0, 0);
|
|
v = Vector3::Scale(v1, v2);
|
|
EXPECT_TRUE(v == Vector3(0, 0, 0)) << "Scale 4 5 6 , 0 0 0";
|
|
}
|
|
|
|
TYPED_TEST(Vector3FpTests, Scale) {
|
|
using T = TypeParam;
|
|
using Vector3 = Vector3Of<T>;
|
|
|
|
Vector3 v1 = Vector3(4, 5, 6);
|
|
Vector3 v2 = Vector3(1, 2, 3);
|
|
Vector3 v = Vector3::zero;
|
|
|
|
if (std::numeric_limits<float>::is_iec559) {
|
|
v2 = Vector3(FLOAT_INFINITY, FLOAT_INFINITY, FLOAT_INFINITY);
|
|
v = Vector3::Scale(v1, v2);
|
|
EXPECT_TRUE(v == Vector3(FLOAT_INFINITY, FLOAT_INFINITY, FLOAT_INFINITY))
|
|
<< "4 5 6 + INFINITY INFINITY INFINITY";
|
|
|
|
v2 = Vector3(-FLOAT_INFINITY, -FLOAT_INFINITY, -FLOAT_INFINITY);
|
|
v = Vector3::Scale(v1, v2);
|
|
EXPECT_TRUE(v == Vector3(-FLOAT_INFINITY, -FLOAT_INFINITY, -FLOAT_INFINITY))
|
|
<< "4 5 6 + -INFINITY -INFINITY -INFINITY";
|
|
}
|
|
}
|
|
|
|
TYPED_TEST(Vector3Tests, Multiply) {
|
|
using T = TypeParam;
|
|
using Vector3 = Vector3Of<T>;
|
|
|
|
Vector3 v1 = Vector3(4, 5, 6);
|
|
T f = 3;
|
|
Vector3 v = Vector3::zero;
|
|
|
|
v = v1 * f;
|
|
EXPECT_TRUE(v == Vector3(12, 15, 18)) << "4 5 6 * 3";
|
|
|
|
f = -3;
|
|
v = v1 * f;
|
|
EXPECT_TRUE(v == Vector3(-12, -15, -18)) << "4 5 6 * -3";
|
|
|
|
f = 0;
|
|
v = v1 * f;
|
|
EXPECT_TRUE(v == Vector3(0, 0, 0)) << "4 5 6 * 0";
|
|
}
|
|
|
|
TYPED_TEST(Vector3FpTests, Multiply) {
|
|
using T = TypeParam;
|
|
using Vector3 = Vector3Of<T>;
|
|
|
|
Vector3 v1 = Vector3(4, 5, 6);
|
|
float f = 3;
|
|
Vector3 v = Vector3::zero;
|
|
|
|
if (std::numeric_limits<float>::is_iec559) {
|
|
f = FLOAT_INFINITY;
|
|
v = v1 * f;
|
|
EXPECT_TRUE(v == Vector3(FLOAT_INFINITY, FLOAT_INFINITY, FLOAT_INFINITY))
|
|
<< "4 5 6 * INFINITY";
|
|
|
|
f = -FLOAT_INFINITY;
|
|
v = v1 * f;
|
|
EXPECT_TRUE(v == Vector3(-FLOAT_INFINITY, -FLOAT_INFINITY, -FLOAT_INFINITY))
|
|
<< "4 5 6 * -INFINITY";
|
|
}
|
|
}
|
|
|
|
TYPED_TEST(Vector3Tests, Divide) {
|
|
using T = TypeParam;
|
|
using Vector3 = Vector3Of<T>;
|
|
|
|
Vector3 v1 = Vector3(4, 5, 6);
|
|
T f = 2;
|
|
Vector3 v = Vector3::zero;
|
|
|
|
v = v1 / f;
|
|
EXPECT_TRUE(v == Vector3((T)2, (T)2.5, (T)3)) << "4 5 6 / 3";
|
|
|
|
f = -2;
|
|
v = v1 / f;
|
|
EXPECT_TRUE(v == Vector3((T)-2, (T)-2.5, (T)-3)) << "4 5 6 / -3";
|
|
}
|
|
|
|
TYPED_TEST(Vector3FpTests, Divide) {
|
|
using T = TypeParam;
|
|
using Vector3 = Vector3Of<T>;
|
|
|
|
Vector3 v1 = Vector3(4, 5, 6);
|
|
float f = 2;
|
|
Vector3 v = Vector3::zero;
|
|
|
|
|
|
if (std::numeric_limits<float>::is_iec559) {
|
|
f = 0;
|
|
v = v1 / f;
|
|
EXPECT_TRUE(v == Vector3(FLOAT_INFINITY, FLOAT_INFINITY, FLOAT_INFINITY))
|
|
<< "4 5 6 / 0";
|
|
|
|
f = FLOAT_INFINITY;
|
|
v = v1 / f;
|
|
EXPECT_TRUE(v == Vector3(0, 0, 0)) << "4 5 6 / INFINITY";
|
|
|
|
f = -FLOAT_INFINITY;
|
|
v = v1 / f;
|
|
EXPECT_TRUE(v == Vector3(0, 0, 0)) << "4 5 6 / -INFINITY";
|
|
}
|
|
}
|
|
|
|
TYPED_TEST(Vector3Tests, Dot) {
|
|
using T = TypeParam;
|
|
using Vector3 = Vector3Of<T>;
|
|
|
|
Vector3 v1 = Vector3(4, 5, 6);
|
|
Vector3 v2 = Vector3(1, 2, 3);
|
|
T f = 0;
|
|
|
|
f = Vector3::Dot(v1, v2);
|
|
EXPECT_FLOAT_EQ((float)f, 32) << "Dot(4 5 6, 1 2 3)";
|
|
|
|
v2 = Vector3(-1, -2, -3);
|
|
f = Vector3::Dot(v1, v2);
|
|
EXPECT_FLOAT_EQ((float)f, -32) << "Dot(4 5 6, -1 -2 -3)";
|
|
|
|
v2 = Vector3(0, 0, 0);
|
|
f = Vector3::Dot(v1, v2);
|
|
EXPECT_FLOAT_EQ((float)f, 0) << "Dot(4 5 6, 0 0 0)";
|
|
}
|
|
|
|
TYPED_TEST(Vector3FpTests, Dot) {
|
|
using T = TypeParam;
|
|
using Vector3 = Vector3Of<T>;
|
|
|
|
Vector3 v1 = Vector3(4, 5, 6);
|
|
Vector3 v2 = Vector3(1, 2, 3);
|
|
T f = 0;
|
|
|
|
if (std::numeric_limits<float>::is_iec559) {
|
|
v2 = Vector3(FLOAT_INFINITY, FLOAT_INFINITY, FLOAT_INFINITY);
|
|
f = Vector3::Dot(v1, v2);
|
|
EXPECT_FLOAT_EQ(f, FLOAT_INFINITY)
|
|
<< "Dot(4 5 6, INFINITY INFINITY INFINITY)";
|
|
|
|
v2 = Vector3(-FLOAT_INFINITY, -FLOAT_INFINITY, -FLOAT_INFINITY);
|
|
f = Vector3::Dot(v1, v2);
|
|
EXPECT_FLOAT_EQ(f, -FLOAT_INFINITY)
|
|
<< "Dot(4 5 6, -INFINITY -INFINITY -INFINITY)";
|
|
}
|
|
}
|
|
|
|
TYPED_TEST(Vector3Tests, Equality) {
|
|
using T = TypeParam;
|
|
using Vector3 = Vector3Of<T>;
|
|
|
|
Vector3 v1 = Vector3(4, 5, 6);
|
|
Vector3 v2 = Vector3(1, 2, 3);
|
|
bool r = false;
|
|
|
|
r = v1 == v2;
|
|
EXPECT_FALSE(r) << "4 5 6 == 1 2 3";
|
|
|
|
v2 = Vector3(4, 5, 6);
|
|
r = v1 == v2;
|
|
EXPECT_TRUE(r) << "4 5 6 == 1 2 3";
|
|
}
|
|
|
|
TYPED_TEST(Vector3FpTests, Equality) {
|
|
using T = TypeParam;
|
|
using Vector3 = Vector3Of<T>;
|
|
|
|
Vector3 v1 = Vector3(4, 5, 6);
|
|
Vector3 v2 = Vector3(1, 2, 3);
|
|
bool r = false;
|
|
|
|
if (std::numeric_limits<float>::is_iec559) {
|
|
v2 = Vector3(FLOAT_INFINITY, FLOAT_INFINITY, FLOAT_INFINITY);
|
|
r = v1 == v2;
|
|
EXPECT_FALSE(r) << "4 5 6 == INFINITY INFINITY INFINITY";
|
|
|
|
v1 = Vector3(-FLOAT_INFINITY, -FLOAT_INFINITY, -FLOAT_INFINITY);
|
|
r = v1 == v2;
|
|
EXPECT_FALSE(r)
|
|
<< "-INFINITY -INFINITY -INFINITY == INFINITY INFINITY INFINITY";
|
|
}
|
|
}
|
|
|
|
TYPED_TEST(Vector3Tests, Distance) {
|
|
using T = TypeParam;
|
|
using Vector3 = Vector3Of<T>;
|
|
|
|
Vector3 v1 = Vector3(4, 5, 6);
|
|
Vector3 v2 = Vector3(1, 2, 3);
|
|
float f = 0;
|
|
|
|
f = Vector3::Distance(v1, v2);
|
|
EXPECT_FLOAT_EQ(f, 5.19615221F) << "Distance(4 5 6, 1 2 3)";
|
|
|
|
v2 = Vector3(-1, -2, -3);
|
|
f = Vector3::Distance(v1, v2);
|
|
EXPECT_FLOAT_EQ(f, 12.4498997F) << "Distance(4 5 6, -1 -2 -3)";
|
|
|
|
v2 = Vector3(0, 0, 0);
|
|
f = Vector3::Distance(v1, v2);
|
|
EXPECT_FLOAT_EQ(f, 8.77496433F) << "Distance(4 5 6, 0 0 0)";
|
|
}
|
|
|
|
TYPED_TEST(Vector3FpTests, Distance) {
|
|
using T = TypeParam;
|
|
using Vector3 = Vector3Of<T>;
|
|
|
|
Vector3 v1 = Vector3(4, 5, 6);
|
|
Vector3 v2 = Vector3(1, 2, 3);
|
|
float f = 0;
|
|
|
|
if (std::numeric_limits<float>::is_iec559) {
|
|
v2 = Vector3(FLOAT_INFINITY, FLOAT_INFINITY, FLOAT_INFINITY);
|
|
f = Vector3::Distance(v1, v2);
|
|
EXPECT_FLOAT_EQ(f, FLOAT_INFINITY)
|
|
<< "Distance(4 5 6, INFINITY INFINITY INFINITY)";
|
|
|
|
v2 = Vector3(-FLOAT_INFINITY, -FLOAT_INFINITY, -FLOAT_INFINITY);
|
|
f = Vector3::Distance(v1, v2);
|
|
EXPECT_FLOAT_EQ(f, FLOAT_INFINITY)
|
|
<< "Distance(4 5 6, -INFINITY -INFINITY -INFINITY)";
|
|
}
|
|
}
|
|
|
|
TYPED_TEST(Vector3Tests, Cross) {
|
|
using T = TypeParam;
|
|
using Vector3 = Vector3Of<T>;
|
|
|
|
Vector3 v1 = Vector3(4, 5, 6);
|
|
Vector3 v2 = Vector3(1, 2, 3);
|
|
Vector3 v = Vector3::zero;
|
|
bool r = false;
|
|
|
|
v = Vector3::Cross(v1, v2);
|
|
r = v == Vector3(3, -6, 3);
|
|
EXPECT_TRUE(r) << "Cross(4 5 6, 1 2 3)";
|
|
|
|
v2 = Vector3(-1, -2, -3);
|
|
v = Vector3::Cross(v1, v2);
|
|
r = v == Vector3(-3, 6, -3);
|
|
EXPECT_TRUE(r) << "Cross(4 5 6, -1 -2 -3)";
|
|
|
|
v2 = Vector3(0, 0, 0);
|
|
v = Vector3::Cross(v1, v2);
|
|
r = v == Vector3(0, 0, 0);
|
|
EXPECT_TRUE(r) << "Cross(4 5 6, 0 0 0)";
|
|
}
|
|
|
|
TYPED_TEST(Vector3FpTests, Cross) {
|
|
using T = TypeParam;
|
|
using Vector3 = Vector3Of<T>;
|
|
|
|
Vector3 v1 = Vector3(4, 5, 6);
|
|
Vector3 v2 = Vector3(1, 2, 3);
|
|
Vector3 v = Vector3::zero;
|
|
bool r = false;
|
|
|
|
if (std::numeric_limits<float>::is_iec559) {
|
|
v2 = Vector3(FLOAT_INFINITY, FLOAT_INFINITY, FLOAT_INFINITY);
|
|
v = Vector3::Cross(v1, v2);
|
|
r = isnan(v.horizontal) && isnan(v.vertical) && isnan(v.depth);
|
|
EXPECT_TRUE(r) << "Cross(4 5 6, INFINITY INFINITY INFINITY)";
|
|
|
|
v2 = Vector3(-FLOAT_INFINITY, -FLOAT_INFINITY, -FLOAT_INFINITY);
|
|
v = Vector3::Cross(v1, v2);
|
|
r = isnan(v.horizontal) && isnan(v.vertical) && isnan(v.depth);
|
|
EXPECT_TRUE(r) << "Cross(4 5 6, -INFINITY -INFINITY -INFINITY)";
|
|
}
|
|
}
|
|
|
|
TYPED_TEST(Vector3Tests, Project) {
|
|
using T = TypeParam;
|
|
using Vector3 = Vector3Of<T>;
|
|
|
|
Vector3 v1 = Vector3(4, 5, 6);
|
|
Vector3 v2 = Vector3(1, 2, 3);
|
|
Vector3 v = Vector3::zero;
|
|
bool r = false;
|
|
|
|
v = Vector3::Project(v1, v2);
|
|
r = v == Vector3((T)2.28571439F, (T)4.57142878F, (T)6.85714293F);
|
|
EXPECT_TRUE(r) << "Project(4 5 6, 1 2 3)";
|
|
|
|
v2 = Vector3(-1, -2, -3);
|
|
v = Vector3::Project(v1, v2);
|
|
r = v == Vector3((T)2.28571439F, (T)4.57142878F, (T)6.85714293F);
|
|
EXPECT_TRUE(r) << "Project(4 5 6, -1 -2 -3)";
|
|
|
|
v2 = Vector3(0, 0, 0);
|
|
v = Vector3::Project(v1, v2);
|
|
r = v == Vector3(0, 0, 0);
|
|
EXPECT_TRUE(r) << "Project(4 5 6, 0 0 0)";
|
|
}
|
|
|
|
TYPED_TEST(Vector3FpTests, Project) {
|
|
using T = TypeParam;
|
|
using Vector3 = Vector3Of<T>;
|
|
|
|
Vector3 v1 = Vector3(4, 5, 6);
|
|
Vector3 v2 = Vector3(1, 2, 3);
|
|
Vector3 v = Vector3::zero;
|
|
bool r = false;
|
|
|
|
if (std::numeric_limits<float>::is_iec559) {
|
|
v2 = Vector3(FLOAT_INFINITY, FLOAT_INFINITY, FLOAT_INFINITY);
|
|
v = Vector3::Project(v1, v2);
|
|
r = isnan(v.horizontal) && isnan(v.vertical) && isnan(v.depth);
|
|
EXPECT_TRUE(r) << "Project(4 5 6, INFINITY INFINITY INFINITY)";
|
|
|
|
v2 = Vector3(-FLOAT_INFINITY, -FLOAT_INFINITY, -FLOAT_INFINITY);
|
|
v = Vector3::Project(v1, v2);
|
|
r = isnan(v.horizontal) && isnan(v.vertical) && isnan(v.depth);
|
|
EXPECT_TRUE(r) << "Project(4 5 6, -INFINITY -INFINITY -INFINITY)";
|
|
}
|
|
}
|
|
|
|
TYPED_TEST(Vector3Tests, ProjectOnPlane) {
|
|
using T = TypeParam;
|
|
using Vector3 = Vector3Of<T>;
|
|
|
|
Vector3 v1 = Vector3(4, 5, 6);
|
|
Vector3 v2 = Vector3(1, 2, 3);
|
|
Vector3Of<float> v = Vector3Of<float>::zero;
|
|
bool r = false;
|
|
|
|
v = Vector3::ProjectOnPlane(v1, v2);
|
|
r = v == Vector3Of<float>(1.71428561F, 0.428571224F, -0.857142925F);
|
|
EXPECT_TRUE(r) << "ProjectOnPlane(4 5 6, 1 2 3)";
|
|
//EXPECT_EQ(v, Vector3(1.71428561F, 0.428571224F, -0.857142925F));
|
|
|
|
v2 = Vector3(-1, -2, -3);
|
|
v = Vector3::ProjectOnPlane(v1, v2);
|
|
r = v == Vector3Of<float>(1.71428561F, 0.428571224F, -0.857142925F);
|
|
EXPECT_TRUE(r) << "ProjectOnPlane(4 5 6, -1 -2 -3)";
|
|
|
|
v2 = Vector3(0, 0, 0);
|
|
v = Vector3::ProjectOnPlane(v1, v2);
|
|
r = v == Vector3(4, 5, 6);
|
|
EXPECT_TRUE(r) << "ProjectOnPlane(4 5 6, 0 0 0)";
|
|
}
|
|
|
|
TYPED_TEST(Vector3FpTests, ProjectOnPlane) {
|
|
using T = TypeParam;
|
|
using Vector3 = Vector3Of<T>;
|
|
|
|
Vector3 v1 = Vector3(4, 5, 6);
|
|
Vector3 v2 = Vector3(1, 2, 3);
|
|
Vector3 v = Vector3::zero;
|
|
bool r = false;
|
|
|
|
if (std::numeric_limits<float>::is_iec559) {
|
|
v2 = Vector3(FLOAT_INFINITY, FLOAT_INFINITY, FLOAT_INFINITY);
|
|
v = Vector3::ProjectOnPlane(v1, v2);
|
|
r = isnan(v.horizontal) && isnan(v.vertical) && isnan(v.depth);
|
|
EXPECT_TRUE(r) << "ProjectOnPlane(4 5 6, INFINITY INFINITY INFINITY)";
|
|
|
|
v2 = Vector3(-FLOAT_INFINITY, -FLOAT_INFINITY, -FLOAT_INFINITY);
|
|
v = Vector3::ProjectOnPlane(v1, v2);
|
|
r = isnan(v.horizontal) && isnan(v.vertical) && isnan(v.depth);
|
|
EXPECT_TRUE(r) << "ProjectOnPlane(4 5 6, -INFINITY -INFINITY -INFINITY)";
|
|
}
|
|
}
|
|
|
|
TYPED_TEST(Vector3Tests, Angle) {
|
|
using T = TypeParam;
|
|
using Vector3 = Vector3Of<T>;
|
|
|
|
Vector3 v1 = Vector3(4, 5, 6);
|
|
Vector3 v2 = Vector3(1, 2, 3);
|
|
AngleOf<float> f = AngleOf<float>::Degrees(0);
|
|
|
|
f = Vector3::UnsignedAngle(v1, v2);
|
|
EXPECT_FLOAT_EQ(f.InDegrees(), 12.9331388F) << "Angle(4 5 6, 1 2 3)";
|
|
|
|
v2 = Vector3(-1, -2, -3);
|
|
f = Vector3::UnsignedAngle(v1, v2);
|
|
EXPECT_FLOAT_EQ(f.InDegrees(), 167.066864F) << "Angle(4 5 6, -1 -2 -3)";
|
|
|
|
v2 = Vector3(0, 0, 0);
|
|
f = Vector3::UnsignedAngle(v1, v2);
|
|
EXPECT_FLOAT_EQ(f.InDegrees(), 0) << "Angle(4 5 6, 0 0 0)";
|
|
}
|
|
|
|
TYPED_TEST(Vector3FpTests, Angle) {
|
|
using T = TypeParam;
|
|
using Vector3 = Vector3Of<T>;
|
|
|
|
Vector3 v1 = Vector3(4, 5, 6);
|
|
Vector3 v2 = Vector3(1, 2, 3);
|
|
AngleOf<float> f = AngleOf<float>::Degrees(0);
|
|
bool r = false;
|
|
|
|
if (std::numeric_limits<float>::is_iec559) {
|
|
v2 = Vector3(FLOAT_INFINITY, FLOAT_INFINITY, FLOAT_INFINITY);
|
|
f = Vector3::UnsignedAngle(v1, v2);
|
|
r = isnan(f.InDegrees());
|
|
EXPECT_TRUE(r) << "Angle(4 5 6, INFINITY INFINITY INFINITY)";
|
|
|
|
v2 = Vector3(-FLOAT_INFINITY, -FLOAT_INFINITY, -FLOAT_INFINITY);
|
|
f = Vector3::UnsignedAngle(v1, v2);
|
|
r = isnan(f.InDegrees());
|
|
EXPECT_TRUE(r) << "Angle(4 5 6, -INFINITY -INFINITY -INFINITY)";
|
|
}
|
|
}
|
|
|
|
TYPED_TEST(Vector3Tests, SignedAngle) {
|
|
using T = TypeParam;
|
|
using Vector3 = Vector3Of<T>;
|
|
|
|
Vector3 v1 = Vector3(4, 5, 6);
|
|
Vector3 v2 = Vector3(1, 2, 3);
|
|
Vector3 v3 = Vector3(7, 8, -9);
|
|
AngleOf<float> f = AngleOf<float>::Degrees(0);
|
|
|
|
f = Vector3::SignedAngle(v1, v2, v3);
|
|
EXPECT_FLOAT_EQ(f.InDegrees(), -12.9331388F)
|
|
<< "SignedAngle(4 5 6, 1 2 3, 7 8 -9)";
|
|
|
|
v2 = Vector3(-1, -2, -3);
|
|
f = Vector3::SignedAngle(v1, v2, v3);
|
|
EXPECT_FLOAT_EQ(f.InDegrees(), 167.066864F)
|
|
<< "SignedAngle(4 5 6, -1 -2 -3, 7 8 -9)";
|
|
|
|
v2 = Vector3(0, 0, 0);
|
|
f = Vector3::SignedAngle(v1, v2, v3);
|
|
EXPECT_FLOAT_EQ(f.InDegrees(), 0) << "SignedAngle(4 5 6, 0 0 0, 7 8 -9 )";
|
|
|
|
v2 = Vector3(1, 2, 3);
|
|
|
|
v3 = Vector3(-7, -8, 9);
|
|
f = Vector3::SignedAngle(v1, v2, v3);
|
|
EXPECT_FLOAT_EQ(f.InDegrees(), 12.9331388F)
|
|
<< "SignedAngle(4 5 6, 1 2 3, -7 -8 9)";
|
|
|
|
v3 = Vector3(0, 0, 0);
|
|
f = Vector3::SignedAngle(v1, v2, v3);
|
|
EXPECT_FLOAT_EQ(f.InDegrees(), 0) << "SignedAngle(4 5 6, 1 2 3, 0 0 0)";
|
|
}
|
|
|
|
TYPED_TEST(Vector3FpTests, SignedAngle) {
|
|
using T = TypeParam;
|
|
using Vector3 = Vector3Of<T>;
|
|
|
|
Vector3 v1 = Vector3(4, 5, 6);
|
|
Vector3 v2 = Vector3(1, 2, 3);
|
|
Vector3 v3 = Vector3(7, 8, -9);
|
|
AngleOf<float> f = AngleOf<float>::Degrees(0);
|
|
bool r = false;
|
|
|
|
if (std::numeric_limits<float>::is_iec559) {
|
|
v2 = Vector3(FLOAT_INFINITY, FLOAT_INFINITY, FLOAT_INFINITY);
|
|
f = Vector3::SignedAngle(v1, v2, v3);
|
|
r = isnan(f.InDegrees());
|
|
EXPECT_TRUE(r) << "SignedAngle(4 5 6, INFINITY INFINITY INFINITY)";
|
|
|
|
v2 = Vector3(-FLOAT_INFINITY, -FLOAT_INFINITY, -FLOAT_INFINITY);
|
|
f = Vector3::SignedAngle(v1, v2, v3);
|
|
r = isnan(f.InDegrees());
|
|
EXPECT_TRUE(r) << "SignedAngle(4 5 6, -INFINITY -INFINITY -INFINITY)";
|
|
}
|
|
}
|
|
|
|
TYPED_TEST(Vector3Tests, Lerp) {
|
|
using T = TypeParam;
|
|
using Vector3 = Vector3Of<T>;
|
|
;
|
|
|
|
Vector3 v1 = Vector3(4, 5, 6);
|
|
Vector3 v2 = Vector3(1, 2, 3);
|
|
Vector3 r = Vector3(0, 0, 0);
|
|
|
|
r = Vector3::Lerp(v1, v2, 0);
|
|
EXPECT_FLOAT_EQ(Vector3::Distance(r, v1), 0);
|
|
|
|
r = Vector3::Lerp(v1, v2, 1);
|
|
EXPECT_FLOAT_EQ(Vector3::Distance(r, v2), 0);
|
|
|
|
r = Vector3::Lerp(v1, v2, 0.5f);
|
|
EXPECT_FLOAT_EQ(Vector3::Distance(r, Vector3((T)2.5, (T)3.5, (T)4.5)), 0);
|
|
|
|
r = Vector3::Lerp(v1, v2, -1);
|
|
EXPECT_FLOAT_EQ(Vector3::Distance(r, Vector3((T)7.0, (T)8.0, (T)9.0)), 0);
|
|
|
|
r = Vector3::Lerp(v1, v2, 2);
|
|
EXPECT_FLOAT_EQ(Vector3::Distance(r, Vector3((T)-2.0, (T)-1.0, (T)0.0)), 0);
|
|
}
|
|
|
|
#endif |