Removed default Angle type
This commit is contained in:
Pascal Serrarens
parent
58beb363ea
commit
64b7f1103b
2
Angle.h
2
Angle.h
@ -214,7 +214,7 @@ private:
|
||||
AngleOf<T>(T value);
|
||||
};
|
||||
|
||||
using Angle = AngleOf<float>;
|
||||
// using Angle = AngleOf<float>;
|
||||
using AngleSingle = AngleOf<float>;
|
||||
using Angle16 = AngleOf<signed short>;
|
||||
using Angle8 = AngleOf<signed char>;
|
||||
|
||||
@ -2,8 +2,8 @@ warning: source 'images' is not a readable file or directory... skipping.
|
||||
d:/PlatformIO/linear-algebra/Quaternion.cpp:100: warning: no uniquely matching class member found for
|
||||
Quaternion Quaternion::operator*(const Quaternion &r2) const
|
||||
Possible candidates:
|
||||
'friend AngleOf< T > Passer::LinearAlgebra::AngleOf< T >::operator*(const AngleOf< T > &a, float f)' at line 48 of file d:/PlatformIO/linear-algebra/Angle.h
|
||||
'friend AngleOf< T > Passer::LinearAlgebra::AngleOf< T >::operator*(float f, const AngleOf< T > &a)' at line 51 of file d:/PlatformIO/linear-algebra/Angle.h
|
||||
'friend AngleOf< T > Passer::LinearAlgebra::AngleOf< T >::operator*(const AngleOf< T > &angle, float factor)' at line 120 of file d:/PlatformIO/linear-algebra/Angle.h
|
||||
'friend AngleOf< T > Passer::LinearAlgebra::AngleOf< T >::operator*(float factor, const AngleOf< T > &angle)' at line 127 of file d:/PlatformIO/linear-algebra/Angle.h
|
||||
'Vector3 Passer::LinearAlgebra::MatrixOf< T >::operator*(const Vector3 v) const' at line 64 of file d:/PlatformIO/linear-algebra/Matrix.h
|
||||
'friend PolarOf Passer::LinearAlgebra::PolarOf< T >::operator*(const PolarOf &v, float f)' at line 100 of file d:/PlatformIO/linear-algebra/Polar.h
|
||||
'friend PolarOf Passer::LinearAlgebra::PolarOf< T >::operator*(float f, const PolarOf &v)' at line 103 of file d:/PlatformIO/linear-algebra/Polar.h
|
||||
@ -20,8 +20,8 @@ Possible candidates:
|
||||
d:/PlatformIO/linear-algebra/Quaternion.cpp:108: warning: no uniquely matching class member found for
|
||||
Vector3 Quaternion::operator*(const Vector3 &p) const
|
||||
Possible candidates:
|
||||
'friend AngleOf< T > Passer::LinearAlgebra::AngleOf< T >::operator*(const AngleOf< T > &a, float f)' at line 48 of file d:/PlatformIO/linear-algebra/Angle.h
|
||||
'friend AngleOf< T > Passer::LinearAlgebra::AngleOf< T >::operator*(float f, const AngleOf< T > &a)' at line 51 of file d:/PlatformIO/linear-algebra/Angle.h
|
||||
'friend AngleOf< T > Passer::LinearAlgebra::AngleOf< T >::operator*(const AngleOf< T > &angle, float factor)' at line 120 of file d:/PlatformIO/linear-algebra/Angle.h
|
||||
'friend AngleOf< T > Passer::LinearAlgebra::AngleOf< T >::operator*(float factor, const AngleOf< T > &angle)' at line 127 of file d:/PlatformIO/linear-algebra/Angle.h
|
||||
'Vector3 Passer::LinearAlgebra::MatrixOf< T >::operator*(const Vector3 v) const' at line 64 of file d:/PlatformIO/linear-algebra/Matrix.h
|
||||
'friend PolarOf Passer::LinearAlgebra::PolarOf< T >::operator*(const PolarOf &v, float f)' at line 100 of file d:/PlatformIO/linear-algebra/Polar.h
|
||||
'friend PolarOf Passer::LinearAlgebra::PolarOf< T >::operator*(float f, const PolarOf &v)' at line 103 of file d:/PlatformIO/linear-algebra/Polar.h
|
||||
@ -54,8 +54,8 @@ d:/PlatformIO/linear-algebra/Spherical.cpp:137: warning: no uniquely matching cl
|
||||
template < T >
|
||||
SphericalOf< T > SphericalOf::operator-(const SphericalOf< T > &s2) const
|
||||
Possible candidates:
|
||||
'AngleOf< T > Passer::LinearAlgebra::AngleOf< T >::operator-() const' at line 43 of file d:/PlatformIO/linear-algebra/Angle.h
|
||||
'AngleOf< T > Passer::LinearAlgebra::AngleOf< T >::operator-(const AngleOf< T > &a) const' at line 44 of file d:/PlatformIO/linear-algebra/Angle.h
|
||||
'AngleOf< T > Passer::LinearAlgebra::AngleOf< T >::operator-() const' at line 102 of file d:/PlatformIO/linear-algebra/Angle.h
|
||||
'AngleOf< T > Passer::LinearAlgebra::AngleOf< T >::operator-(const AngleOf< T > &angle) const' at line 106 of file d:/PlatformIO/linear-algebra/Angle.h
|
||||
'DirectionOf< T > Passer::LinearAlgebra::DirectionOf< T >::operator-() const' at line 41 of file d:/PlatformIO/linear-algebra/Direction.h
|
||||
'PolarOf Passer::LinearAlgebra::PolarOf< T >::operator-() const' at line 82 of file d:/PlatformIO/linear-algebra/Polar.h
|
||||
'PolarOf Passer::LinearAlgebra::PolarOf< T >::operator-(const PolarOf &v) const' at line 87 of file d:/PlatformIO/linear-algebra/Polar.h
|
||||
@ -118,3 +118,5 @@ d:/PlatformIO/linear-algebra/Vector3.h:158: warning: Member operator*=(float f)
|
||||
d:/PlatformIO/linear-algebra/Vector3.h:170: warning: Member operator/=(float f) (function) of struct Passer::LinearAlgebra::Vector3 is not documented.
|
||||
d:/PlatformIO/linear-algebra/Vector3.h:154: warning: Member operator*(float f, const Vector3 &v) (friend) of struct Passer::LinearAlgebra::Vector3 is not documented.
|
||||
d:/PlatformIO/linear-algebra/Vector3.h:166: warning: Member operator/(float f, const Vector3 &v) (friend) of struct Passer::LinearAlgebra::Vector3 is not documented.
|
||||
t f, const Vector3 &v) (friend) of struct Passer::LinearAlgebra::Vector3 is not documented.
|
||||
d:/PlatformIO/linear-algebra/Vector3.h:166: warning: Member operator/(float f, const Vector3 &v) (friend) of struct Passer::LinearAlgebra::Vector3 is not documented.
|
||||
|
||||
45
Polar.cpp
45
Polar.cpp
@ -2,13 +2,11 @@
|
||||
|
||||
#include "Polar.h"
|
||||
|
||||
template <typename T>
|
||||
PolarOf<T>::PolarOf() {
|
||||
template <typename T> PolarOf<T>::PolarOf() {
|
||||
this->distance = 0.0f;
|
||||
this->angle = AngleOf<T>();
|
||||
}
|
||||
template <typename T>
|
||||
PolarOf<T>::PolarOf(float distance, AngleOf<T> angle) {
|
||||
template <typename T> PolarOf<T>::PolarOf(float distance, AngleOf<T> angle) {
|
||||
// distance should always be 0 or greater
|
||||
if (distance < 0.0f) {
|
||||
this->distance = -distance;
|
||||
@ -23,16 +21,14 @@ PolarOf<T>::PolarOf(float distance, AngleOf<T> angle) {
|
||||
}
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
PolarOf<T> PolarOf<T>::FromVector2(Vector2 v) {
|
||||
template <typename T> PolarOf<T> PolarOf<T>::FromVector2(Vector2 v) {
|
||||
float distance = v.magnitude();
|
||||
AngleOf<T> angle =
|
||||
AngleOf<T>::Degrees(Vector2::SignedAngle(Vector2::forward, v));
|
||||
PolarOf<T> p = PolarOf(distance, angle);
|
||||
return p;
|
||||
}
|
||||
template <typename T>
|
||||
PolarOf<T> PolarOf<T>::FromSpherical(SphericalOf<T> v) {
|
||||
template <typename T> PolarOf<T> PolarOf<T>::FromSpherical(SphericalOf<T> v) {
|
||||
float distance = v.distance * cosf(v.direction.vertical.InDegrees() *
|
||||
Passer::LinearAlgebra::Deg2Rad);
|
||||
AngleOf<T> angle = v.direction.horizontal;
|
||||
@ -51,43 +47,36 @@ const PolarOf<T> PolarOf<T>::right = PolarOf(1.0, AngleOf<T>::Degrees(90));
|
||||
template <typename T>
|
||||
const PolarOf<T> PolarOf<T>::left = PolarOf(1.0, AngleOf<T>::Degrees(-90));
|
||||
|
||||
template <typename T>
|
||||
bool PolarOf<T>::operator==(const PolarOf& v) const {
|
||||
template <typename T> bool PolarOf<T>::operator==(const PolarOf &v) const {
|
||||
return (this->distance == v.distance &&
|
||||
this->angle.InDegrees() == v.angle.InDegrees());
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
PolarOf<T> PolarOf<T>::Normalize(const PolarOf& v) {
|
||||
template <typename T> PolarOf<T> PolarOf<T>::Normalize(const PolarOf &v) {
|
||||
PolarOf<T> r = PolarOf(1, v.angle);
|
||||
return r;
|
||||
}
|
||||
template <typename T>
|
||||
PolarOf<T> PolarOf<T>::normalized() const {
|
||||
template <typename T> PolarOf<T> PolarOf<T>::normalized() const {
|
||||
PolarOf<T> r = PolarOf(1, this->angle);
|
||||
return r;
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
PolarOf<T> PolarOf<T>::operator-() const {
|
||||
template <typename T> PolarOf<T> PolarOf<T>::operator-() const {
|
||||
PolarOf<T> v =
|
||||
PolarOf(this->distance, this->angle + AngleOf<T>::Degrees(180));
|
||||
return v;
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
PolarOf<T> PolarOf<T>::operator-(const PolarOf& v) const {
|
||||
template <typename T> PolarOf<T> PolarOf<T>::operator-(const PolarOf &v) const {
|
||||
PolarOf<T> r = -v;
|
||||
return *this + r;
|
||||
}
|
||||
template <typename T>
|
||||
PolarOf<T> PolarOf<T>::operator-=(const PolarOf& v) {
|
||||
template <typename T> PolarOf<T> PolarOf<T>::operator-=(const PolarOf &v) {
|
||||
*this = *this - v;
|
||||
return *this;
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
PolarOf<T> PolarOf<T>::operator+(const PolarOf& v) const {
|
||||
template <typename T> PolarOf<T> PolarOf<T>::operator+(const PolarOf &v) const {
|
||||
if (v.distance == 0)
|
||||
return PolarOf(this->distance, this->angle);
|
||||
if (this->distance == 0.0f)
|
||||
@ -105,7 +94,8 @@ PolarOf<T> PolarOf<T>::operator+(const PolarOf& v) const {
|
||||
float newDistance = AngleOf<T>::CosineRuleSide(v.distance, this->distance,
|
||||
AngleOf<T>::Degrees(rotation));
|
||||
|
||||
float angle = Angle::CosineRuleAngle(newDistance, this->distance, v.distance)
|
||||
float angle =
|
||||
AngleSingle::CosineRuleAngle(newDistance, this->distance, v.distance)
|
||||
.InDegrees();
|
||||
|
||||
float newAngle = deltaAngle < 0.0f ? this->angle.InDegrees() - angle
|
||||
@ -114,19 +104,16 @@ PolarOf<T> PolarOf<T>::operator+(const PolarOf& v) const {
|
||||
PolarOf vector = PolarOf(newDistance, newAngleA);
|
||||
return vector;
|
||||
}
|
||||
template <typename T>
|
||||
PolarOf<T> PolarOf<T>::operator+=(const PolarOf& v) {
|
||||
template <typename T> PolarOf<T> PolarOf<T>::operator+=(const PolarOf &v) {
|
||||
*this = *this + v;
|
||||
return *this;
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
PolarOf<T> PolarOf<T>::operator*=(float f) {
|
||||
template <typename T> PolarOf<T> PolarOf<T>::operator*=(float f) {
|
||||
this->distance *= f;
|
||||
return *this;
|
||||
}
|
||||
template <typename T>
|
||||
PolarOf<T> PolarOf<T>::operator/=(float f) {
|
||||
template <typename T> PolarOf<T> PolarOf<T>::operator/=(float f) {
|
||||
this->distance /= f;
|
||||
return *this;
|
||||
}
|
||||
|
||||
@ -251,7 +251,7 @@ AngleOf<T> SphericalOf<T>::AngleBetween(const SphericalOf &v1,
|
||||
|
||||
// float cdot = Float::Clamp(fraction, -1.0, 1.0);
|
||||
// float r = ((float)acos(cdot)) * Rad2Deg;
|
||||
Angle r = Vector3::Angle(v1_3, v2_3);
|
||||
AngleSingle r = Vector3::Angle(v1_3, v2_3);
|
||||
return AngleOf<T>::Degrees(r.InDegrees());
|
||||
}
|
||||
|
||||
@ -262,7 +262,7 @@ AngleOf<T> Passer::LinearAlgebra::SphericalOf<T>::SignedAngleBetween(
|
||||
Vector3 v1_vector = v1.ToVector3();
|
||||
Vector3 v2_vector = v2.ToVector3();
|
||||
Vector3 axis_vector = axis.ToVector3();
|
||||
Angle r = Vector3::SignedAngle(v1_vector, v2_vector, axis_vector);
|
||||
AngleSingle r = Vector3::SignedAngle(v1_vector, v2_vector, axis_vector);
|
||||
return AngleOf<T>::Degrees(r.InDegrees());
|
||||
}
|
||||
|
||||
|
||||
19
Vector2.cpp
19
Vector2.cpp
@ -56,15 +56,9 @@ bool Vector2::operator==(const Vector2& v) {
|
||||
float Vector2::Magnitude(const Vector2 &v) {
|
||||
return sqrtf(v.x * v.x + v.y * v.y);
|
||||
}
|
||||
float Vector2::magnitude() const {
|
||||
return (float)sqrtf(x * x + y * y);
|
||||
}
|
||||
float Vector2::SqrMagnitude(const Vector2& v) {
|
||||
return v.x * v.x + v.y * v.y;
|
||||
}
|
||||
float Vector2::sqrMagnitude() const {
|
||||
return (x * x + y * y);
|
||||
}
|
||||
float Vector2::magnitude() const { return (float)sqrtf(x * x + y * y); }
|
||||
float Vector2::SqrMagnitude(const Vector2 &v) { return v.x * v.x + v.y * v.y; }
|
||||
float Vector2::sqrMagnitude() const { return (x * x + y * y); }
|
||||
|
||||
Vector2 Vector2::Normalize(const Vector2 &v) {
|
||||
float num = Vector2::Magnitude(v);
|
||||
@ -83,9 +77,7 @@ Vector2 Vector2::normalized() const {
|
||||
return result;
|
||||
}
|
||||
|
||||
Vector2 Vector2::operator-() {
|
||||
return Vector2(-this->x, -this->y);
|
||||
}
|
||||
Vector2 Vector2::operator-() { return Vector2(-this->x, -this->y); }
|
||||
|
||||
Vector2 Vector2::operator-(const Vector2 &v) const {
|
||||
return Vector2(this->x - v.x, this->y - v.y);
|
||||
@ -159,7 +151,8 @@ float Vector2::SignedAngle(const Vector2& v1, const Vector2& v2) {
|
||||
return -(angleTo - angleFrom) * Passer::LinearAlgebra::Rad2Deg;
|
||||
}
|
||||
|
||||
Vector2 Vector2::Rotate(const Vector2& v, Passer::LinearAlgebra::Angle a) {
|
||||
Vector2 Vector2::Rotate(const Vector2 &v,
|
||||
Passer::LinearAlgebra::AngleSingle a) {
|
||||
float angleRad = a.InDegrees() * Passer::LinearAlgebra::Deg2Rad;
|
||||
#if defined(AVR)
|
||||
float sinValue = sin(angleRad);
|
||||
|
||||
@ -30,8 +30,7 @@ namespace Passer {
|
||||
namespace LinearAlgebra {
|
||||
|
||||
struct Vector3;
|
||||
template <typename T>
|
||||
class PolarOf;
|
||||
template <typename T> class PolarOf;
|
||||
// using Polar = PolarOf<float>
|
||||
|
||||
/// @brief A 2=dimensional vector
|
||||
@ -190,7 +189,7 @@ struct Vector2 : Vec2 {
|
||||
/// @param v The vector to rotate
|
||||
/// @param a The angle in degrees to rotate
|
||||
/// @return The rotated vector
|
||||
static Vector2 Rotate(const Vector2& v, Passer::LinearAlgebra::Angle a);
|
||||
static Vector2 Rotate(const Vector2 &v, Passer::LinearAlgebra::AngleSingle a);
|
||||
|
||||
/// @brief Lerp (linear interpolation) between two vectors
|
||||
/// @param v1 The starting vector
|
||||
|
||||
@ -63,7 +63,7 @@ TEST(AngleSingle, Compare) {
|
||||
}
|
||||
|
||||
TEST(AngleSingle, Normalize) {
|
||||
Angle r = AngleSingle();
|
||||
AngleSingle r = AngleSingle();
|
||||
|
||||
r = AngleSingle::Normalize(AngleSingle::Degrees(90.0f));
|
||||
EXPECT_FLOAT_EQ(r.InDegrees(), 90) << "Normalize 90";
|
||||
@ -96,7 +96,7 @@ TEST(AngleSingle, Normalize) {
|
||||
}
|
||||
|
||||
TEST(AngleSingle, Clamp) {
|
||||
Angle r = AngleSingle();
|
||||
AngleSingle r = AngleSingle();
|
||||
|
||||
r = AngleSingle::Clamp(AngleSingle::Degrees(1), AngleSingle::Degrees(0),
|
||||
AngleSingle::Degrees(2));
|
||||
@ -135,7 +135,7 @@ TEST(AngleSingle, Clamp) {
|
||||
}
|
||||
|
||||
// TEST(AngleSingle, Difference) {
|
||||
// Angle r = 0;
|
||||
// AngleSingle r = 0;
|
||||
|
||||
// r = AngleSingle::Difference(0, 90);
|
||||
// EXPECT_FLOAT_EQ(r.InDegrees(), 90) << "Difference 0 90";
|
||||
|
||||
@ -32,40 +32,40 @@ TEST(Polar, FromSpherical) {
|
||||
SphericalSingle s;
|
||||
Polar p;
|
||||
|
||||
s = SphericalSingle(1, Angle::Degrees(0), Angle::Degrees(0));
|
||||
s = SphericalSingle(1, AngleSingle::Degrees(0), AngleSingle::Degrees(0));
|
||||
p = Polar::FromSpherical(s);
|
||||
|
||||
EXPECT_FLOAT_EQ(p.distance, 1.0F) << "p.distance FromSpherical(1 0 0)";
|
||||
EXPECT_FLOAT_EQ(p.angle.InDegrees(), 0.0F) << "p.angle FromSpherical(1 0 0)";
|
||||
|
||||
s = SphericalSingle(1, Angle::Degrees(45), Angle::Degrees(0));
|
||||
s = SphericalSingle(1, AngleSingle::Degrees(45), AngleSingle::Degrees(0));
|
||||
p = Polar::FromSpherical(s);
|
||||
|
||||
EXPECT_FLOAT_EQ(p.distance, 1.0F) << "p.distance FromSpherical(1 45 0)";
|
||||
EXPECT_FLOAT_EQ(p.angle.InDegrees(), 45.0F)
|
||||
<< "p.angle FromSpherical(1 45 0)";
|
||||
|
||||
s = SphericalSingle(1, Angle::Degrees(-45), Angle::Degrees(0));
|
||||
s = SphericalSingle(1, AngleSingle::Degrees(-45), AngleSingle::Degrees(0));
|
||||
p = Polar::FromSpherical(s);
|
||||
|
||||
EXPECT_FLOAT_EQ(p.distance, 1.0F) << "p.distance FromSpherical(1 -45 0)";
|
||||
EXPECT_FLOAT_EQ(p.angle.InDegrees(), -45.0F)
|
||||
<< "p.angle FromSpherical(1 -45 0)";
|
||||
|
||||
s = SphericalSingle(0, Angle::Degrees(0), Angle::Degrees(0));
|
||||
s = SphericalSingle(0, AngleSingle::Degrees(0), AngleSingle::Degrees(0));
|
||||
p = Polar::FromSpherical(s);
|
||||
|
||||
EXPECT_FLOAT_EQ(p.distance, 0.0F) << "p.distance FromSpherical(0 0 0)";
|
||||
EXPECT_FLOAT_EQ(p.angle.InDegrees(), 0.0F) << "p.angle FromSpherical(0 0 0)";
|
||||
|
||||
s = SphericalSingle(-1, Angle::Degrees(0), Angle::Degrees(0));
|
||||
s = SphericalSingle(-1, AngleSingle::Degrees(0), AngleSingle::Degrees(0));
|
||||
p = Polar::FromSpherical(s);
|
||||
|
||||
EXPECT_FLOAT_EQ(p.distance, 1.0F) << "p.distance FromSpherical(-1 0 0)";
|
||||
EXPECT_FLOAT_EQ(p.angle.InDegrees(), -180.0F)
|
||||
<< "p.angle FromSpherical(-1 0 0)";
|
||||
|
||||
s = SphericalSingle(0, Angle::Degrees(0), Angle::Degrees(90));
|
||||
s = SphericalSingle(0, AngleSingle::Degrees(0), AngleSingle::Degrees(90));
|
||||
p = Polar::FromSpherical(s);
|
||||
|
||||
EXPECT_FLOAT_EQ(p.distance, 0.0F) << "p.distance FromSpherical(0 0 90)";
|
||||
@ -73,32 +73,32 @@ TEST(Polar, FromSpherical) {
|
||||
}
|
||||
|
||||
TEST(Polar, Negation) {
|
||||
Polar v = Polar(2, Angle::Degrees(45));
|
||||
Polar v = Polar(2, AngleSingle::Degrees(45));
|
||||
Polar r = Polar::zero;
|
||||
|
||||
r = -v;
|
||||
EXPECT_FLOAT_EQ(r.distance, 2);
|
||||
EXPECT_FLOAT_EQ(r.angle.InDegrees(), -135);
|
||||
EXPECT_TRUE(r == Polar(2, Angle::Degrees(-135))) << "Negate(2 45)";
|
||||
EXPECT_TRUE(r == Polar(2, AngleSingle::Degrees(-135))) << "Negate(2 45)";
|
||||
|
||||
v = Polar(2, Angle::Degrees(-45));
|
||||
v = Polar(2, AngleSingle::Degrees(-45));
|
||||
r = -v;
|
||||
EXPECT_TRUE(r == Polar(2, Angle::Degrees(135))) << "Negate(2 -45)";
|
||||
EXPECT_TRUE(r == Polar(2, AngleSingle::Degrees(135))) << "Negate(2 -45)";
|
||||
|
||||
v = Polar(2, Angle::Degrees(0));
|
||||
v = Polar(2, AngleSingle::Degrees(0));
|
||||
r = -v;
|
||||
EXPECT_TRUE(r == Polar(2, Angle::Degrees(180))) << "Negate(2 0)";
|
||||
EXPECT_TRUE(r == Polar(2, AngleSingle::Degrees(180))) << "Negate(2 0)";
|
||||
|
||||
v = Polar(0, Angle::Degrees(0));
|
||||
v = Polar(0, AngleSingle::Degrees(0));
|
||||
r = -v;
|
||||
EXPECT_FLOAT_EQ(r.distance, 0.0f);
|
||||
EXPECT_FLOAT_EQ(r.angle.InDegrees(), 0.0f);
|
||||
EXPECT_TRUE(r == Polar(0, Angle::Degrees(0))) << "Negate(0 0)";
|
||||
EXPECT_TRUE(r == Polar(0, AngleSingle::Degrees(0))) << "Negate(0 0)";
|
||||
}
|
||||
|
||||
TEST(Polar, Subtraction) {
|
||||
Polar v1 = Polar(4, Angle::Degrees(45));
|
||||
Polar v2 = Polar(1, Angle::Degrees(-90));
|
||||
Polar v1 = Polar(4, AngleSingle::Degrees(45));
|
||||
Polar v2 = Polar(1, AngleSingle::Degrees(-90));
|
||||
Polar r = Polar::zero;
|
||||
|
||||
r = v1 - v2;
|
||||
@ -110,8 +110,8 @@ TEST(Polar, Subtraction) {
|
||||
}
|
||||
|
||||
TEST(Polar, Addition) {
|
||||
Polar v1 = Polar(1, Angle::Degrees(45));
|
||||
Polar v2 = Polar(1, Angle::Degrees(-90));
|
||||
Polar v1 = Polar(1, AngleSingle::Degrees(45));
|
||||
Polar v2 = Polar(1, AngleSingle::Degrees(-90));
|
||||
Polar r = Polar::zero;
|
||||
|
||||
r = v1 - v2;
|
||||
@ -125,14 +125,14 @@ TEST(Polar, Addition) {
|
||||
r += v2;
|
||||
EXPECT_FLOAT_EQ(r.distance, v1.distance) << "Addition(0 0)";
|
||||
|
||||
v2 = Polar(1, Angle::Degrees(-45));
|
||||
v2 = Polar(1, AngleSingle::Degrees(-45));
|
||||
r = v1 + v2;
|
||||
EXPECT_FLOAT_EQ(r.distance, sqrtf(2)) << "Addition(0 0 0)";
|
||||
EXPECT_FLOAT_EQ(r.angle.InDegrees(), 0) << "Addition(0 0 0)";
|
||||
}
|
||||
|
||||
TEST(Polar, Scale_Multiply) {
|
||||
Polar v1 = Polar(4, Angle::Degrees(45));
|
||||
Polar v1 = Polar(4, AngleSingle::Degrees(45));
|
||||
Polar r = Polar::zero;
|
||||
|
||||
r = v1 * 2.0f;
|
||||
@ -142,7 +142,7 @@ TEST(Polar, Scale_Multiply) {
|
||||
}
|
||||
|
||||
TEST(Polar, Scale_Divide) {
|
||||
Polar v1 = Polar(4, Angle::Degrees(45));
|
||||
Polar v1 = Polar(4, AngleSingle::Degrees(45));
|
||||
Polar r = Polar::zero;
|
||||
|
||||
r = v1 / 2.0f;
|
||||
@ -152,8 +152,8 @@ TEST(Polar, Scale_Divide) {
|
||||
}
|
||||
|
||||
TEST(Polar, Distance) {
|
||||
Polar v1 = Polar(4, Angle::Degrees(45));
|
||||
Polar v2 = Polar(1, Angle::Degrees(-90));
|
||||
Polar v1 = Polar(4, AngleSingle::Degrees(45));
|
||||
Polar v2 = Polar(1, AngleSingle::Degrees(-90));
|
||||
float d = 0;
|
||||
|
||||
d = Polar::Distance(v1, v2);
|
||||
@ -165,10 +165,10 @@ TEST(Polar, Distance) {
|
||||
}
|
||||
|
||||
TEST(Polar, Rotate) {
|
||||
Polar v = Polar(4, Angle::Degrees(45));
|
||||
Polar v = Polar(4, AngleSingle::Degrees(45));
|
||||
Polar r = Polar::zero;
|
||||
|
||||
r = Polar::Rotate(v, Angle::Degrees(45));
|
||||
r = Polar::Rotate(v, AngleSingle::Degrees(45));
|
||||
EXPECT_FLOAT_EQ(r.distance, v.distance) << "Rotate(4 45, 45)";
|
||||
EXPECT_FLOAT_EQ(r.angle.InDegrees(), 90.0f) << "Rotate(4 45, 45)";
|
||||
}
|
||||
|
||||
@ -31,7 +31,7 @@ TEST(SphericalSingle, FromVector3) {
|
||||
}
|
||||
|
||||
TEST(SphericalSingle, FromPolar) {
|
||||
Polar p = Polar(1, Angle::Degrees(0));
|
||||
Polar p = Polar(1, AngleSingle::Degrees(0));
|
||||
SphericalSingle s = SphericalSingle ::FromPolar(p);
|
||||
|
||||
EXPECT_FLOAT_EQ(s.distance, 1.0F) << "s.distance Polar(1 0)";
|
||||
@ -40,7 +40,7 @@ TEST(SphericalSingle, FromPolar) {
|
||||
EXPECT_FLOAT_EQ(s.direction.vertical.InDegrees(), 0.0F)
|
||||
<< "s.vert Polar(1 0)";
|
||||
|
||||
p = Polar(1, Angle::Degrees(45));
|
||||
p = Polar(1, AngleSingle::Degrees(45));
|
||||
s = SphericalSingle ::FromPolar(p);
|
||||
|
||||
EXPECT_FLOAT_EQ(s.distance, 1.0F) << "s.distance Polar(1 45)";
|
||||
@ -49,7 +49,7 @@ TEST(SphericalSingle, FromPolar) {
|
||||
EXPECT_FLOAT_EQ(s.direction.vertical.InDegrees(), 0.0F)
|
||||
<< "s.vert Polar(1 45)";
|
||||
|
||||
p = Polar(1, Angle::Degrees(-45));
|
||||
p = Polar(1, AngleSingle::Degrees(-45));
|
||||
s = SphericalSingle ::FromPolar(p);
|
||||
|
||||
EXPECT_FLOAT_EQ(s.distance, 1.0F) << "s.distance Polar(1 -45)";
|
||||
@ -58,7 +58,7 @@ TEST(SphericalSingle, FromPolar) {
|
||||
EXPECT_FLOAT_EQ(s.direction.vertical.InDegrees(), 0.0F)
|
||||
<< "s.vert Polar(1 -45)";
|
||||
|
||||
p = Polar(0, Angle::Degrees(0));
|
||||
p = Polar(0, AngleSingle::Degrees(0));
|
||||
s = SphericalSingle ::FromPolar(p);
|
||||
|
||||
EXPECT_FLOAT_EQ(s.distance, 0.0F) << "s.distance Polar(0 0)";
|
||||
@ -67,7 +67,7 @@ TEST(SphericalSingle, FromPolar) {
|
||||
EXPECT_FLOAT_EQ(s.direction.vertical.InDegrees(), 0.0F)
|
||||
<< "s.vert Polar(0 0)";
|
||||
|
||||
p = Polar(-1, Angle::Degrees(0));
|
||||
p = Polar(-1, AngleSingle::Degrees(0));
|
||||
s = SphericalSingle ::FromPolar(p);
|
||||
|
||||
EXPECT_FLOAT_EQ(s.distance, 1.0F) << "s.distance Polar(-1 0)";
|
||||
@ -81,8 +81,8 @@ TEST(SphericalSingle, Incident1) {
|
||||
Vector3 v = Vector3(2.242557f, 1.027884f, -0.322347f);
|
||||
SphericalSingle s = SphericalSingle ::FromVector3(v);
|
||||
|
||||
SphericalSingle sr =
|
||||
SphericalSingle(2.49F, Angle::Degrees(98.18f), Angle::Degrees(24.4F));
|
||||
SphericalSingle sr = SphericalSingle(2.49F, AngleSingle::Degrees(98.18f),
|
||||
AngleSingle::Degrees(24.4F));
|
||||
EXPECT_NEAR(s.distance, sr.distance, 1.0e-01);
|
||||
EXPECT_NEAR(s.direction.horizontal.InDegrees(),
|
||||
sr.direction.horizontal.InDegrees(), 1.0e-02);
|
||||
@ -99,8 +99,8 @@ TEST(SphericalSingle, Incident2) {
|
||||
Vector3 v = Vector3(1.0f, 0.0f, 1.0f);
|
||||
SphericalSingle s = SphericalSingle ::FromVector3(v);
|
||||
|
||||
SphericalSingle sr = SphericalSingle(1.4142135623F, Angle::Degrees(45.0f),
|
||||
Angle::Degrees(0.0F));
|
||||
SphericalSingle sr = SphericalSingle(
|
||||
1.4142135623F, AngleSingle::Degrees(45.0f), AngleSingle::Degrees(0.0F));
|
||||
EXPECT_NEAR(s.distance, sr.distance, 1.0e-05);
|
||||
EXPECT_NEAR(s.direction.horizontal.InDegrees(),
|
||||
sr.direction.horizontal.InDegrees(), 1.0e-05);
|
||||
@ -115,8 +115,8 @@ TEST(SphericalSingle, Incident2) {
|
||||
v = Vector3(0.0f, 1.0f, 1.0f);
|
||||
s = SphericalSingle ::FromVector3(v);
|
||||
|
||||
sr = SphericalSingle(1.4142135623F, Angle::Degrees(0.0f),
|
||||
Angle::Degrees(45.0F));
|
||||
sr = SphericalSingle(1.4142135623F, AngleSingle::Degrees(0.0f),
|
||||
AngleSingle::Degrees(45.0F));
|
||||
EXPECT_NEAR(s.distance, sr.distance, 1.0e-05);
|
||||
EXPECT_NEAR(s.direction.horizontal.InDegrees(),
|
||||
sr.direction.horizontal.InDegrees(), 1.0e-05);
|
||||
@ -149,7 +149,7 @@ TEST(SphericalSingle, Incident2) {
|
||||
|
||||
TEST(SphericalSingle, Addition) {
|
||||
SphericalSingle v1 =
|
||||
SphericalSingle(1, Angle::Degrees(45), Angle::Degrees(0));
|
||||
SphericalSingle(1, AngleSingle::Degrees(45), AngleSingle::Degrees(0));
|
||||
SphericalSingle v2 = SphericalSingle ::zero;
|
||||
SphericalSingle r = SphericalSingle ::zero;
|
||||
|
||||
@ -160,13 +160,13 @@ TEST(SphericalSingle, Addition) {
|
||||
r += v2;
|
||||
EXPECT_FLOAT_EQ(r.distance, v1.distance) << "Addition(0 0 0)";
|
||||
|
||||
v2 = SphericalSingle(1, Angle::Degrees(-45), Angle::Degrees(0));
|
||||
v2 = SphericalSingle(1, AngleSingle::Degrees(-45), AngleSingle::Degrees(0));
|
||||
r = v1 + v2;
|
||||
EXPECT_FLOAT_EQ(r.distance, sqrtf(2)) << "Addition(1 -45 0)";
|
||||
EXPECT_FLOAT_EQ(r.direction.horizontal.InDegrees(), 0) << "Addition(1 -45 0)";
|
||||
EXPECT_FLOAT_EQ(r.direction.vertical.InDegrees(), 0) << "Addition(1 -45 0)";
|
||||
|
||||
v2 = SphericalSingle(1, Angle::Degrees(0), Angle::Degrees(90));
|
||||
v2 = SphericalSingle(1, AngleSingle::Degrees(0), AngleSingle::Degrees(90));
|
||||
r = v1 + v2;
|
||||
EXPECT_FLOAT_EQ(r.distance, sqrtf(2)) << "Addition(1 0 90)";
|
||||
EXPECT_FLOAT_EQ(r.direction.horizontal.InDegrees(), 45) << "Addition(1 0 90)";
|
||||
|
||||
@ -1,7 +1,7 @@
|
||||
#if GTEST
|
||||
#include <gtest/gtest.h>
|
||||
#include <math.h>
|
||||
#include <limits>
|
||||
#include <math.h>
|
||||
|
||||
#include "Vector2.h"
|
||||
|
||||
@ -462,16 +462,16 @@ TEST(Vector2, Rotate) {
|
||||
Vector2 v1 = Vector2(1, 2);
|
||||
Vector2 r = Vector2(0, 0);
|
||||
|
||||
r = Vector2::Rotate(v1, Angle::Degrees(0));
|
||||
r = Vector2::Rotate(v1, AngleSingle::Degrees(0));
|
||||
EXPECT_FLOAT_EQ(Vector2::Distance(r, v1), 0);
|
||||
|
||||
r = Vector2::Rotate(v1, Angle::Degrees(180));
|
||||
r = Vector2::Rotate(v1, AngleSingle::Degrees(180));
|
||||
EXPECT_NEAR(Vector2::Distance(r, Vector2(-1, -2)), 0, 1.0e-06);
|
||||
|
||||
r = Vector2::Rotate(v1, Angle::Degrees(-90));
|
||||
r = Vector2::Rotate(v1, AngleSingle::Degrees(-90));
|
||||
EXPECT_NEAR(Vector2::Distance(r, Vector2(2, -1)), 0, 1.0e-06);
|
||||
|
||||
r = Vector2::Rotate(v1, Angle::Degrees(270));
|
||||
r = Vector2::Rotate(v1, AngleSingle::Degrees(270));
|
||||
EXPECT_NEAR(Vector2::Distance(r, Vector2(2, -1)), 0, 1.0e-06);
|
||||
}
|
||||
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user