Pascal Serrarens
9b76dfd094
Some checks failed
Build and Run C++ Unit Tests / build-and-test (push) Failing after 29s
691 lines
17 KiB
C++
691 lines
17 KiB
C++
#if GTEST
|
|
#include <gtest/gtest.h>
|
|
#include <math.h>
|
|
#include <limits>
|
|
|
|
#include "Polar.h"
|
|
#include "Vector2.h"
|
|
|
|
#define FLOAT_INFINITY std::numeric_limits<float>::infinity()
|
|
|
|
using BaseTypes = ::testing::Types<float, int>;
|
|
using FpTypes = ::testing::Types<float>;
|
|
|
|
template <typename T>
|
|
class Vector2Tests : public ::testing::Test {};
|
|
TYPED_TEST_SUITE(Vector2Tests, BaseTypes);
|
|
|
|
template <typename T>
|
|
class Vector2FpTests : public ::testing::Test {};
|
|
TYPED_TEST_SUITE(Vector2FpTests, FpTypes);
|
|
|
|
TYPED_TEST(Vector2Tests, FromPolar) {
|
|
using T = TypeParam;
|
|
using Vector2 = Vector2Of<T>;
|
|
|
|
Vector2 v;
|
|
PolarSingle p;
|
|
Vector2Float r;
|
|
|
|
v = Vector2(0, 1);
|
|
p = PolarSingle::FromVector2(v);
|
|
r = Vector2Of<float>::FromPolar(p);
|
|
|
|
EXPECT_FLOAT_EQ(r.horizontal, 0.0F) << "FromPolar(0 1)";
|
|
EXPECT_FLOAT_EQ(r.vertical, 1.0F) << "FromPolar(0 1)";
|
|
|
|
v = Vector2(1, 0);
|
|
p = PolarSingle::FromVector2(v);
|
|
r = Vector2Of<float>::FromPolar(p);
|
|
|
|
EXPECT_FLOAT_EQ(r.horizontal, 1.0F) << "FromPolar(1 0)";
|
|
EXPECT_NEAR(r.vertical, 0.0F, 1.0e-07) << "FromPolar(1 0)";
|
|
|
|
v = Vector2(0, 0);
|
|
p = PolarSingle::FromVector2(v);
|
|
r = Vector2Of<float>::FromPolar(p);
|
|
|
|
EXPECT_FLOAT_EQ(r.horizontal, 0.0F) << "FromPolar(0 0)";
|
|
EXPECT_FLOAT_EQ(r.vertical, 0.0F) << "FromPolar(0 0)";
|
|
}
|
|
|
|
TYPED_TEST(Vector2Tests, Magnitude) {
|
|
using T = TypeParam;
|
|
using Vector2 = Vector2Of<T>;
|
|
|
|
Vector2 v = Vector2(1, 2);
|
|
float m = 0;
|
|
|
|
m = v.Magnitude();
|
|
EXPECT_FLOAT_EQ(m, 2.236068F) << "v.magnitude 1 2";
|
|
|
|
m = Vector2::MagnitudeOf(v);
|
|
EXPECT_FLOAT_EQ(m, 2.236068F) << "Vector2::Magnitude 1 2";
|
|
|
|
v = Vector2(-1, -2);
|
|
m = v.Magnitude();
|
|
EXPECT_FLOAT_EQ(m, 2.236068F) << "v.magnitude -1 -2";
|
|
|
|
v = Vector2(0, 0);
|
|
m = v.Magnitude();
|
|
EXPECT_FLOAT_EQ(m, 0) << "v.magnitude 0 0 ";
|
|
}
|
|
|
|
TYPED_TEST(Vector2FpTests, Magnitude) {
|
|
using T = TypeParam;
|
|
using Vector2 = Vector2Of<T>;
|
|
|
|
Vector2 v;
|
|
float m = 0;
|
|
|
|
if (std::numeric_limits<float>::is_iec559) {
|
|
v = Vector2(FLOAT_INFINITY, FLOAT_INFINITY);
|
|
m = v.Magnitude();
|
|
EXPECT_FLOAT_EQ(m, FLOAT_INFINITY) << "v.magnitude INFINITY INFINITY ";
|
|
|
|
v = Vector2(-FLOAT_INFINITY, -FLOAT_INFINITY);
|
|
m = v.Magnitude();
|
|
EXPECT_FLOAT_EQ(m, FLOAT_INFINITY) << "v.magnitude -INFINITY -INFINITY ";
|
|
}
|
|
}
|
|
|
|
TYPED_TEST(Vector2Tests, SqrMagnitude) {
|
|
using T = TypeParam;
|
|
using Vector2 = Vector2Of<T>;
|
|
|
|
Vector2 v = Vector2(1, 2);
|
|
float m = 0;
|
|
|
|
m = v.SqrMagnitude();
|
|
EXPECT_FLOAT_EQ(m, 5) << "v.sqrMagnitude 1 2";
|
|
|
|
m = Vector2::SqrMagnitudeOf(v);
|
|
EXPECT_FLOAT_EQ(m, 5) << "Vector2::SqrMagnitude 1 2";
|
|
|
|
v = Vector2(-1, -2);
|
|
m = v.SqrMagnitude();
|
|
EXPECT_FLOAT_EQ(m, 5) << "v.sqrMagnitude -1 -2";
|
|
|
|
v = Vector2(0, 0);
|
|
m = v.SqrMagnitude();
|
|
EXPECT_FLOAT_EQ(m, 0) << "v.sqrMagnitude 0 0 ";
|
|
}
|
|
|
|
TYPED_TEST(Vector2FpTests, SqrMagnitude) {
|
|
using T = TypeParam;
|
|
using Vector2 = Vector2Of<T>;
|
|
|
|
Vector2 v;
|
|
float m;
|
|
|
|
if (std::numeric_limits<float>::is_iec559) {
|
|
v = Vector2(FLOAT_INFINITY, FLOAT_INFINITY);
|
|
m = v.SqrMagnitude();
|
|
EXPECT_FLOAT_EQ(m, FLOAT_INFINITY) << "v.sqrMagnitude INFINITY INFINITY ";
|
|
|
|
v = Vector2(-FLOAT_INFINITY, -FLOAT_INFINITY);
|
|
m = v.SqrMagnitude();
|
|
EXPECT_FLOAT_EQ(m, FLOAT_INFINITY) << "v.sqrMagnitude -INFINITY -INFINITY ";
|
|
}
|
|
}
|
|
|
|
TYPED_TEST(Vector2Tests, Normalize) {
|
|
using T = TypeParam;
|
|
using Vector2 = Vector2Of<T>;
|
|
|
|
|
|
Vector2 v1 = Vector2(0, 2);
|
|
Vector2 v = Vector2::zero;
|
|
|
|
v = v1.Normalized();
|
|
EXPECT_TRUE(v == Vector2(0, 1)) << "v.normalized 0 2";
|
|
|
|
v = Vector2::Normalize(v1);
|
|
EXPECT_TRUE(v == Vector2(0, 1)) << "Vector3::Normalize 0 2";
|
|
|
|
v1 = Vector2(0, -2);
|
|
v = v1.Normalized();
|
|
EXPECT_TRUE(v == Vector2(0, -1)) << "v.normalized 0 -2";
|
|
|
|
v1 = Vector2(0, 0);
|
|
v = v1.Normalized();
|
|
EXPECT_TRUE(v == Vector2(0, 0)) << "v.normalized 0 0";
|
|
}
|
|
|
|
TYPED_TEST(Vector2FpTests, Normalize) {
|
|
using T = TypeParam;
|
|
using Vector2 = Vector2Of<T>;
|
|
|
|
Vector2 v;
|
|
Vector2 v1;
|
|
float r;
|
|
|
|
if (std::numeric_limits<float>::is_iec559) {
|
|
v1 = Vector2(FLOAT_INFINITY, FLOAT_INFINITY);
|
|
v = v1.Normalized();
|
|
r = isnan(v.horizontal) && isnan(v.vertical);
|
|
EXPECT_TRUE(r) << "v.normalized INFINITY INFINITY";
|
|
|
|
v1 = Vector2(-FLOAT_INFINITY, -FLOAT_INFINITY);
|
|
v = v1.Normalized();
|
|
r = isnan(v.horizontal) && isnan(v.vertical);
|
|
EXPECT_TRUE(r) << "v.normalized -INFINITY -INFINITY";
|
|
}
|
|
}
|
|
|
|
TYPED_TEST(Vector2Tests, Negate) {
|
|
using T = TypeParam;
|
|
using Vector2 = Vector2Of<T>;
|
|
|
|
Vector2 v1 = Vector2(4, 5);
|
|
Vector2 v = Vector2::zero;
|
|
|
|
v = -v1;
|
|
EXPECT_TRUE(v == Vector2(-4, -5)) << "- 4 5";
|
|
|
|
v1 = Vector2(-4, -5);
|
|
v = -v1;
|
|
EXPECT_TRUE(v == Vector2(4, 5)) << "- -4 -5";
|
|
|
|
v1 = Vector2(0, 0);
|
|
v = -v1;
|
|
EXPECT_TRUE(v == Vector2(0, 0)) << "- 0 0";
|
|
}
|
|
|
|
TYPED_TEST(Vector2FpTests, Negate) {
|
|
using T = TypeParam;
|
|
using Vector2 = Vector2Of<T>;
|
|
|
|
Vector2 v;
|
|
Vector2 v1;
|
|
|
|
if (std::numeric_limits<float>::is_iec559) {
|
|
v1 = Vector2(FLOAT_INFINITY, FLOAT_INFINITY);
|
|
v = -v1;
|
|
EXPECT_TRUE(v == Vector2(-FLOAT_INFINITY, -FLOAT_INFINITY))
|
|
<< "- INFINITY INFINITY";
|
|
|
|
v1 = Vector2(-FLOAT_INFINITY, -FLOAT_INFINITY);
|
|
v = -v1;
|
|
EXPECT_TRUE(v == Vector2(FLOAT_INFINITY, FLOAT_INFINITY))
|
|
<< "- -INFINITY -INFINITY";
|
|
}
|
|
}
|
|
|
|
TYPED_TEST(Vector2Tests, Subtract) {
|
|
using T = TypeParam;
|
|
using Vector2 = Vector2Of<T>;
|
|
|
|
Vector2 v1 = Vector2(4, 5);
|
|
Vector2 v2 = Vector2(1, 2);
|
|
Vector2 v = Vector2::zero;
|
|
|
|
v = v1 - v2;
|
|
EXPECT_TRUE(v == Vector2(3, 3)) << "4 5 - 1 2";
|
|
|
|
v2 = Vector2(-1, -2);
|
|
v = v1 - v2;
|
|
EXPECT_TRUE(v == Vector2(5, 7)) << "4 5 - -1 -2";
|
|
|
|
v2 = Vector2(4, 5);
|
|
v = v1 - v2;
|
|
EXPECT_TRUE(v == Vector2(0, 0)) << "4 5 - 4 5";
|
|
v = v1;
|
|
v -= v2;
|
|
EXPECT_TRUE(v == Vector2(0, 0)) << "4 5 - 4 5";
|
|
|
|
v2 = Vector2(0, 0);
|
|
v = v1 - v2;
|
|
EXPECT_TRUE(v == Vector2(4, 5)) << "4 5 - 0 0";
|
|
|
|
v -= v2;
|
|
EXPECT_TRUE(v == Vector2(4, 5)) << "4 5 - 0 0";
|
|
}
|
|
|
|
TYPED_TEST(Vector2FpTests, Subtract) {
|
|
using T = TypeParam;
|
|
using Vector2 = Vector2Of<T>;
|
|
|
|
Vector2 v;
|
|
Vector2 v1 = Vector2(4, 5);
|
|
Vector2 v2;
|
|
|
|
if (std::numeric_limits<float>::is_iec559) {
|
|
v2 = Vector2(FLOAT_INFINITY, FLOAT_INFINITY);
|
|
v = v1 - v2;
|
|
EXPECT_TRUE(v == Vector2(-FLOAT_INFINITY, -FLOAT_INFINITY))
|
|
<< "4 5 - INFINITY INFINITY";
|
|
|
|
v2 = Vector2(-FLOAT_INFINITY, -FLOAT_INFINITY);
|
|
v = v1 - v2;
|
|
EXPECT_TRUE(v == Vector2(FLOAT_INFINITY, FLOAT_INFINITY))
|
|
<< "4 5 - -INFINITY -INFINITY";
|
|
}
|
|
}
|
|
|
|
TYPED_TEST(Vector2Tests, Addition) {
|
|
using T = TypeParam;
|
|
using Vector2 = Vector2Of<T>;
|
|
|
|
Vector2 v1 = Vector2(4, 5);
|
|
Vector2 v2 = Vector2(1, 2);
|
|
Vector2 v = Vector2::zero;
|
|
|
|
v = v1 + v2;
|
|
EXPECT_TRUE(v == Vector2(5, 7)) << "4 5 + 1 2";
|
|
|
|
v2 = Vector2(-1, -2);
|
|
v = v1 + v2;
|
|
EXPECT_TRUE(v == Vector2(3, 3)) << "4 5 + -1 -2";
|
|
v = v1;
|
|
v += v2;
|
|
EXPECT_TRUE(v == Vector2(3, 3)) << "4 5 + -1 -2";
|
|
|
|
v2 = Vector2(0, 0);
|
|
v = v1 + v2;
|
|
EXPECT_TRUE(v == Vector2(4, 5)) << "4 5 + 0 0";
|
|
v += v2;
|
|
EXPECT_TRUE(v == Vector2(4, 5)) << "4 5 + 0 0";
|
|
}
|
|
|
|
TYPED_TEST(Vector2FpTests, Addition) {
|
|
using T = TypeParam;
|
|
using Vector2 = Vector2Of<T>;
|
|
|
|
Vector2 v;
|
|
Vector2 v1 = Vector2(4, 5);
|
|
Vector2 v2 = Vector2(0, 0);
|
|
|
|
if (std::numeric_limits<float>::is_iec559) {
|
|
v2 = Vector2(FLOAT_INFINITY, FLOAT_INFINITY);
|
|
v = v1 + v2;
|
|
EXPECT_TRUE(v == Vector2(FLOAT_INFINITY, FLOAT_INFINITY))
|
|
<< "4 5 + INFINITY INFINITY";
|
|
|
|
v2 = Vector2(-FLOAT_INFINITY, -FLOAT_INFINITY);
|
|
v = v1 + v2;
|
|
EXPECT_TRUE(v == Vector2(-FLOAT_INFINITY, -FLOAT_INFINITY))
|
|
<< "4 5 + -INFINITY -INFINITY";
|
|
}
|
|
}
|
|
|
|
TYPED_TEST(Vector2Tests, Scale) {
|
|
using T = TypeParam;
|
|
using Vector2 = Vector2Of<T>;
|
|
|
|
Vector2 v1 = Vector2(4, 5);
|
|
Vector2 v2 = Vector2(1, 2);
|
|
Vector2 v = Vector2::zero;
|
|
|
|
v = Vector2::Scale(v1, v2);
|
|
EXPECT_TRUE(v == Vector2(4, 10)) << "Scale 4 5 , 1 2";
|
|
|
|
v2 = Vector2(-1, -2);
|
|
v = Vector2::Scale(v1, v2);
|
|
EXPECT_TRUE(v == Vector2(-4, -10)) << "Scale 4 5 , -1 -2";
|
|
|
|
v2 = Vector2(0, 0);
|
|
v = Vector2::Scale(v1, v2);
|
|
EXPECT_TRUE(v == Vector2(0, 0)) << "Scale 4 5 , 0 0";
|
|
}
|
|
|
|
TYPED_TEST(Vector2FpTests, Scale) {
|
|
using T = TypeParam;
|
|
using Vector2 = Vector2Of<T>;
|
|
|
|
Vector2 v;
|
|
Vector2 v1 = Vector2(4, 5);
|
|
Vector2 v2;
|
|
|
|
if (std::numeric_limits<float>::is_iec559) {
|
|
v2 = Vector2(FLOAT_INFINITY, FLOAT_INFINITY);
|
|
v = Vector2::Scale(v1, v2);
|
|
EXPECT_TRUE(v == Vector2(FLOAT_INFINITY, FLOAT_INFINITY))
|
|
<< "4 5 + INFINITY INFINITY";
|
|
|
|
v2 = Vector2(-FLOAT_INFINITY, -FLOAT_INFINITY);
|
|
v = Vector2::Scale(v1, v2);
|
|
EXPECT_TRUE(v == Vector2(-FLOAT_INFINITY, -FLOAT_INFINITY))
|
|
<< "4 5 + -INFINITY -INFINITY";
|
|
}
|
|
}
|
|
|
|
TYPED_TEST(Vector2Tests, Multiply) {
|
|
using T = TypeParam;
|
|
using Vector2 = Vector2Of<T>;
|
|
|
|
Vector2 v1 = Vector2(4, 5);
|
|
T f = 3;
|
|
Vector2 v = Vector2::zero;
|
|
|
|
v = v1 * f;
|
|
EXPECT_TRUE(v == Vector2(12, 15)) << "4 5 * 3";
|
|
|
|
f = -3;
|
|
v = v1 * f;
|
|
EXPECT_TRUE(v == Vector2(-12, -15)) << "4 5 * -3";
|
|
|
|
f = 0;
|
|
v = v1 * f;
|
|
EXPECT_TRUE(v == Vector2(0, 0)) << "4 5 * 0";
|
|
}
|
|
|
|
TYPED_TEST(Vector2FpTests, Multiply) {
|
|
using T = TypeParam;
|
|
using Vector2 = Vector2Of<T>;
|
|
|
|
Vector2 v;
|
|
Vector2 v1 = Vector2(4, 5);
|
|
T f;
|
|
|
|
if (std::numeric_limits<float>::is_iec559) {
|
|
f = FLOAT_INFINITY;
|
|
v = v1 * f;
|
|
EXPECT_TRUE(v == Vector2(FLOAT_INFINITY, FLOAT_INFINITY))
|
|
<< "4 5 * INFINITY";
|
|
|
|
f = -FLOAT_INFINITY;
|
|
v = v1 * f;
|
|
EXPECT_TRUE(v == Vector2(-FLOAT_INFINITY, -FLOAT_INFINITY))
|
|
<< "4 5 * -INFINITY";
|
|
}
|
|
}
|
|
|
|
TYPED_TEST(Vector2Tests, Divide) {
|
|
using T = TypeParam;
|
|
using Vector2 = Vector2Of<T>;
|
|
|
|
Vector2 v1 = Vector2(4, 5);
|
|
T f = 2;
|
|
Vector2 v = Vector2::zero;
|
|
|
|
v = v1 / f;
|
|
EXPECT_TRUE(v == Vector2((T)2, (T)2.5)) << "4 5 / 3";
|
|
|
|
f = -2;
|
|
v = v1 / f;
|
|
EXPECT_TRUE(v == Vector2((T)-2, (T)-2.5)) << "4 5 / -3";
|
|
}
|
|
|
|
TYPED_TEST(Vector2FpTests, Divide) {
|
|
using T = TypeParam;
|
|
using Vector2 = Vector2Of<T>;
|
|
|
|
Vector2 v;
|
|
Vector2 v1 = Vector2(4, 5);
|
|
T f;
|
|
|
|
if (std::numeric_limits<float>::is_iec559) {
|
|
f = 0;
|
|
v = v1 / f;
|
|
EXPECT_TRUE(v == Vector2(FLOAT_INFINITY, FLOAT_INFINITY)) << "4 5 / 0";
|
|
|
|
f = FLOAT_INFINITY;
|
|
v = v1 / f;
|
|
EXPECT_TRUE(v == Vector2(0, 0)) << "4 5 / INFINITY";
|
|
|
|
f = -FLOAT_INFINITY;
|
|
v = v1 / f;
|
|
EXPECT_TRUE(v == Vector2(0, 0)) << "4 5 / -INFINITY";
|
|
}
|
|
}
|
|
|
|
TYPED_TEST(Vector2Tests, Dot) {
|
|
using T = TypeParam;
|
|
using Vector2 = Vector2Of<T>;
|
|
|
|
Vector2 v1 = Vector2(4, 5);
|
|
Vector2 v2 = Vector2(1, 2);
|
|
T f = 0;
|
|
|
|
f = Vector2::Dot(v1, v2);
|
|
EXPECT_FLOAT_EQ((float)f, 14) << "Dot(4 5, 1 2)";
|
|
|
|
v2 = Vector2(-1, -2);
|
|
f = Vector2::Dot(v1, v2);
|
|
EXPECT_FLOAT_EQ((float)f, -14) << "Dot(4 5, -1 -2)";
|
|
|
|
v2 = Vector2(0, 0);
|
|
f = Vector2::Dot(v1, v2);
|
|
EXPECT_FLOAT_EQ((float)f, 0) << "Dot(4 5, 0 0)";
|
|
}
|
|
|
|
TYPED_TEST(Vector2FpTests, Dot) {
|
|
using T = TypeParam;
|
|
using Vector2 = Vector2Of<T>;
|
|
|
|
Vector2 v2;
|
|
Vector2 v1 = Vector2(4, 5);
|
|
T f;
|
|
|
|
if (std::numeric_limits<float>::is_iec559) {
|
|
v2 = Vector2(FLOAT_INFINITY, FLOAT_INFINITY);
|
|
f = Vector2::Dot(v1, v2);
|
|
EXPECT_FLOAT_EQ(f, FLOAT_INFINITY) << "Dot(4 5, INFINITY INFINITY)";
|
|
|
|
v2 = Vector2(-FLOAT_INFINITY, -FLOAT_INFINITY);
|
|
f = Vector2::Dot(v1, v2);
|
|
EXPECT_FLOAT_EQ(f, -FLOAT_INFINITY) << "Dot(4 5, -INFINITY -INFINITY)";
|
|
}
|
|
}
|
|
|
|
TYPED_TEST(Vector2Tests, Equality) {
|
|
using T = TypeParam;
|
|
using Vector2 = Vector2Of<T>;
|
|
|
|
Vector2 v1 = Vector2(4, 5);
|
|
Vector2 v2 = Vector2(1, 2);
|
|
bool r = false;
|
|
|
|
r = v1 == v2;
|
|
EXPECT_FALSE(r) << "4 5 == 1 2";
|
|
|
|
v2 = Vector2(4, 5);
|
|
r = v1 == v2;
|
|
EXPECT_TRUE(r) << "4 5 == 1 2";
|
|
}
|
|
|
|
TYPED_TEST(Vector2FpTests, Equality) {
|
|
using T = TypeParam;
|
|
using Vector2 = Vector2Of<T>;
|
|
|
|
Vector2 v1 = Vector2(4, 5);
|
|
Vector2 v2;
|
|
bool r;
|
|
|
|
if (std::numeric_limits<float>::is_iec559) {
|
|
v2 = Vector2(FLOAT_INFINITY, FLOAT_INFINITY);
|
|
r = v1 == v2;
|
|
EXPECT_FALSE(r) << "4 5 == INFINITY INFINITY";
|
|
|
|
v1 = Vector2(-FLOAT_INFINITY, -FLOAT_INFINITY);
|
|
r = v1 == v2;
|
|
EXPECT_FALSE(r) << "-INFINITY -INFINITY == INFINITY INFINITY";
|
|
}
|
|
}
|
|
|
|
TYPED_TEST(Vector2Tests, Distance) {
|
|
using T = TypeParam;
|
|
using Vector2 = Vector2Of<T>;
|
|
|
|
Vector2 v1 = Vector2(4, 5);
|
|
Vector2 v2 = Vector2(1, 2);
|
|
float f = 0;
|
|
|
|
f = Vector2::Distance(v1, v2);
|
|
EXPECT_FLOAT_EQ(f, 4.24264F) << "Distance(4 5, 1 2)";
|
|
|
|
v2 = Vector2(-1, -2);
|
|
f = Vector2::Distance(v1, v2);
|
|
EXPECT_FLOAT_EQ(f, 8.602325F) << "Distance(4 5, -1 -2)";
|
|
|
|
v2 = Vector2(0, 0);
|
|
f = Vector2::Distance(v1, v2);
|
|
EXPECT_FLOAT_EQ(f, 6.403124F) << "Distance(4 5, 0 0)";
|
|
}
|
|
|
|
TYPED_TEST(Vector2FpTests, Distance) {
|
|
using T = TypeParam;
|
|
using Vector2 = Vector2Of<T>;
|
|
|
|
Vector2 v1 = Vector2(4, 5);
|
|
Vector2 v2;
|
|
float f;
|
|
|
|
if (std::numeric_limits<float>::is_iec559) {
|
|
v2 = Vector2(FLOAT_INFINITY, FLOAT_INFINITY);
|
|
f = Vector2::Distance(v1, v2);
|
|
EXPECT_FLOAT_EQ(f, FLOAT_INFINITY) << "Distance(4 5, INFINITY INFINITY)";
|
|
|
|
v2 = Vector2(-FLOAT_INFINITY, -FLOAT_INFINITY);
|
|
f = Vector2::Distance(v1, v2);
|
|
EXPECT_FLOAT_EQ(f, FLOAT_INFINITY) << "Distance(4 5, -INFINITY -INFINITY)";
|
|
}
|
|
}
|
|
|
|
TYPED_TEST(Vector2Tests, Angle) {
|
|
using T = TypeParam;
|
|
using Vector2 = Vector2Of<T>;
|
|
using Angle = AngleOf<float>;
|
|
|
|
Vector2 v1 = Vector2(4, 5);
|
|
Vector2 v2 = Vector2(1, 2);
|
|
Angle f = Angle::zero;
|
|
|
|
f = Vector2::UnsignedAngle(v1, v2);
|
|
EXPECT_FLOAT_EQ(f.InDegrees(), 12.09476F) << "Angle(4 5, 1 2)";
|
|
|
|
v2 = Vector2(-1, -2);
|
|
f = Vector2::UnsignedAngle(v1, v2);
|
|
EXPECT_FLOAT_EQ(f.InDegrees(), 167.9052F) << "Angle(4 5, -1 -2)";
|
|
|
|
v2 = Vector2(0, 0);
|
|
f = Vector2::UnsignedAngle(v1, v2);
|
|
EXPECT_FLOAT_EQ(f.InDegrees(), 0) << "Angle(4 5, 0 0)";
|
|
}
|
|
|
|
TYPED_TEST(Vector2FpTests, Angle) {
|
|
using T = TypeParam;
|
|
using Vector2 = Vector2Of<T>;
|
|
|
|
Vector2 v1 = Vector2(4, 5);
|
|
Vector2 v2;
|
|
AngleOf<float> f;
|
|
float r;
|
|
|
|
if (std::numeric_limits<float>::is_iec559) {
|
|
v2 = Vector2(FLOAT_INFINITY, FLOAT_INFINITY);
|
|
f = Vector2::UnsignedAngle(v1, v2);
|
|
// r = isnan(f.InDegrees());
|
|
r = f.InDegrees() == 0;
|
|
EXPECT_TRUE(r) << "Angle(4 5, INFINITY INFINITY)";
|
|
|
|
v2 = Vector2(-FLOAT_INFINITY, -FLOAT_INFINITY);
|
|
f = Vector2::UnsignedAngle(v1, v2);
|
|
// r = isnan(f.InDegrees());
|
|
r = f.InDegrees() == 0;
|
|
EXPECT_TRUE(r) << "Angle(4 5, -INFINITY -INFINITY)";
|
|
}
|
|
}
|
|
|
|
TYPED_TEST(Vector2Tests, SignedAngle) {
|
|
using T = TypeParam;
|
|
using Vector2 = Vector2Of<T>;
|
|
using Angle = AngleOf<float>;
|
|
|
|
Vector2 v1 = Vector2(4, 5);
|
|
Vector2 v2 = Vector2(1, 2);
|
|
Angle f = Angle::zero;
|
|
|
|
f = Vector2::SignedAngle(v1, v2);
|
|
EXPECT_FLOAT_EQ(f.InDegrees(), -12.09476F) << "SignedAngle(4 5, 1 2)";
|
|
|
|
v2 = Vector2(-1, -2);
|
|
f = Vector2::SignedAngle(v1, v2);
|
|
EXPECT_FLOAT_EQ(f.InDegrees(), 167.9052F) << "SignedAngle(4 5, -1 -2)";
|
|
|
|
v2 = Vector2(0, 0);
|
|
f = Vector2::SignedAngle(v1, v2);
|
|
EXPECT_FLOAT_EQ(f.InDegrees(), 0) << "SignedAngle(4 5, 0 0)";
|
|
|
|
v1 = Vector2(0, 1);
|
|
v2 = Vector2(1, 0);
|
|
f = Vector2::SignedAngle(v1, v2);
|
|
EXPECT_FLOAT_EQ(f.InDegrees(), 90.0F) << "SignedAngle(0 1, 1 0)";
|
|
|
|
v1 = Vector2(0, 1);
|
|
v2 = Vector2(0, -1);
|
|
f = Vector2::SignedAngle(v1, v2);
|
|
EXPECT_FLOAT_EQ(f.InDegrees(), 180.0F) << "SignedAngle(0 1, 1 0)";
|
|
}
|
|
|
|
TYPED_TEST(Vector2FpTests, SignedAngle) {
|
|
using T = TypeParam;
|
|
using Vector2 = Vector2Of<T>;
|
|
|
|
Vector2 v1 = Vector2(4, 5);
|
|
Vector2 v2;
|
|
AngleOf<float> f;
|
|
float r;
|
|
|
|
if (std::numeric_limits<float>::is_iec559) {
|
|
v2 = Vector2(FLOAT_INFINITY, FLOAT_INFINITY);
|
|
f = Vector2::SignedAngle(v1, v2);
|
|
// r = isnan(f.InDegrees());
|
|
r = f.InDegrees() == 0;
|
|
EXPECT_TRUE(r) << "SignedAngle(4 5, INFINITY INFINITY)";
|
|
|
|
v2 = Vector2(-FLOAT_INFINITY, -FLOAT_INFINITY);
|
|
f = Vector2::SignedAngle(v1, v2);
|
|
// r = isnan(f.InDegrees());
|
|
r = f.InDegrees() == 0;
|
|
EXPECT_TRUE(r) << "SignedAngle(4 5, -INFINITY -INFINITY)";
|
|
}
|
|
}
|
|
|
|
TYPED_TEST(Vector2Tests, Rotate) {
|
|
using T = TypeParam;
|
|
using Vector2 = Vector2Of<T>;
|
|
using Angle = AngleOf<float>;
|
|
|
|
Vector2 v1 = Vector2(1, 2);
|
|
Vector2Of<float> r = Vector2(0, 0);
|
|
|
|
r = Vector2::Rotate(v1, Angle::Degrees(0));
|
|
EXPECT_FLOAT_EQ(Vector2::Distance(r, v1), 0);
|
|
|
|
r = Vector2::Rotate(v1, Angle::Degrees(180));
|
|
EXPECT_NEAR(Vector2Of<float>::Distance(r, Vector2(-1, -2)), 0, 1.0e-06);
|
|
|
|
r = Vector2::Rotate(v1, Angle::Degrees(-90));
|
|
EXPECT_NEAR(Vector2::Distance(r, Vector2(2, -1)), 0, 1.0e-06);
|
|
|
|
r = Vector2::Rotate(v1, Angle::Degrees(270));
|
|
EXPECT_NEAR(Vector2::Distance(r, Vector2(2, -1)), 0, 1.0e-06);
|
|
}
|
|
|
|
TYPED_TEST(Vector2Tests, Lerp) {
|
|
using T = TypeParam;
|
|
using Vector2 = Vector2Of<T>;
|
|
|
|
Vector2 v1 = Vector2(4, 5);
|
|
Vector2 v2 = Vector2(1, 2);
|
|
Vector2 r = Vector2(0, 0);
|
|
|
|
r = Vector2::Lerp(v1, v2, 0);
|
|
EXPECT_FLOAT_EQ(Vector2::Distance(r, v1), 0);
|
|
|
|
r = Vector2::Lerp(v1, v2, 1);
|
|
EXPECT_FLOAT_EQ(Vector2::Distance(r, v2), 0);
|
|
|
|
r = Vector2::Lerp(v1, v2, 0.5f);
|
|
EXPECT_FLOAT_EQ(Vector2::Distance(r, Vector2((T)2.5, (T)3.5)), 0);
|
|
|
|
r = Vector2::Lerp(v1, v2, -1);
|
|
EXPECT_FLOAT_EQ(Vector2::Distance(r, Vector2((T)7.0, (T)8.0f)), 0);
|
|
|
|
r = Vector2::Lerp(v1, v2, 2);
|
|
EXPECT_FLOAT_EQ(Vector2::Distance(r, Vector2((T)-2.0, (T)-1.0)), 0);
|
|
}
|
|
|
|
#endif |