From 64b7f1103b6bbb31a0a5726b47da933c4251cda2 Mon Sep 17 00:00:00 2001 From: Pascal Serrarens Date: Fri, 27 Dec 2024 23:18:39 +0100 Subject: [PATCH] Removed default Angle type --- Angle.h | 2 +- DoxyGen/DoxyWarnLogfile.txt | 14 +++++----- Polar.cpp | 51 ++++++++++++++---------------------- Spherical.cpp | 4 +-- Vector2.cpp | 51 ++++++++++++++++-------------------- Vector2.h | 47 ++++++++++++++++----------------- test/AngleSingle_test.cc | 6 ++--- test/Polar_test.cc | 50 +++++++++++++++++------------------ test/SphericalSingle_test.cc | 28 ++++++++++---------- test/Vector2_test.cc | 10 +++---- 10 files changed, 122 insertions(+), 141 deletions(-) diff --git a/Angle.h b/Angle.h index 1e4b445..27aac41 100644 --- a/Angle.h +++ b/Angle.h @@ -214,7 +214,7 @@ private: AngleOf(T value); }; -using Angle = AngleOf; +// using Angle = AngleOf; using AngleSingle = AngleOf; using Angle16 = AngleOf; using Angle8 = AngleOf; diff --git a/DoxyGen/DoxyWarnLogfile.txt b/DoxyGen/DoxyWarnLogfile.txt index 2e253db..b1425a0 100644 --- a/DoxyGen/DoxyWarnLogfile.txt +++ b/DoxyGen/DoxyWarnLogfile.txt @@ -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. diff --git a/Polar.cpp b/Polar.cpp index 35d1576..92f4ba0 100644 --- a/Polar.cpp +++ b/Polar.cpp @@ -2,13 +2,11 @@ #include "Polar.h" -template -PolarOf::PolarOf() { +template PolarOf::PolarOf() { this->distance = 0.0f; this->angle = AngleOf(); } -template -PolarOf::PolarOf(float distance, AngleOf angle) { +template PolarOf::PolarOf(float distance, AngleOf angle) { // distance should always be 0 or greater if (distance < 0.0f) { this->distance = -distance; @@ -23,16 +21,14 @@ PolarOf::PolarOf(float distance, AngleOf angle) { } } -template -PolarOf PolarOf::FromVector2(Vector2 v) { +template PolarOf PolarOf::FromVector2(Vector2 v) { float distance = v.magnitude(); AngleOf angle = AngleOf::Degrees(Vector2::SignedAngle(Vector2::forward, v)); PolarOf p = PolarOf(distance, angle); return p; } -template -PolarOf PolarOf::FromSpherical(SphericalOf v) { +template PolarOf PolarOf::FromSpherical(SphericalOf v) { float distance = v.distance * cosf(v.direction.vertical.InDegrees() * Passer::LinearAlgebra::Deg2Rad); AngleOf angle = v.direction.horizontal; @@ -51,43 +47,36 @@ const PolarOf PolarOf::right = PolarOf(1.0, AngleOf::Degrees(90)); template const PolarOf PolarOf::left = PolarOf(1.0, AngleOf::Degrees(-90)); -template -bool PolarOf::operator==(const PolarOf& v) const { +template bool PolarOf::operator==(const PolarOf &v) const { return (this->distance == v.distance && this->angle.InDegrees() == v.angle.InDegrees()); } -template -PolarOf PolarOf::Normalize(const PolarOf& v) { +template PolarOf PolarOf::Normalize(const PolarOf &v) { PolarOf r = PolarOf(1, v.angle); return r; } -template -PolarOf PolarOf::normalized() const { +template PolarOf PolarOf::normalized() const { PolarOf r = PolarOf(1, this->angle); return r; } -template -PolarOf PolarOf::operator-() const { +template PolarOf PolarOf::operator-() const { PolarOf v = PolarOf(this->distance, this->angle + AngleOf::Degrees(180)); return v; } -template -PolarOf PolarOf::operator-(const PolarOf& v) const { +template PolarOf PolarOf::operator-(const PolarOf &v) const { PolarOf r = -v; return *this + r; } -template -PolarOf PolarOf::operator-=(const PolarOf& v) { +template PolarOf PolarOf::operator-=(const PolarOf &v) { *this = *this - v; return *this; } -template -PolarOf PolarOf::operator+(const PolarOf& v) const { +template PolarOf PolarOf::operator+(const PolarOf &v) const { if (v.distance == 0) return PolarOf(this->distance, this->angle); if (this->distance == 0.0f) @@ -105,8 +94,9 @@ PolarOf PolarOf::operator+(const PolarOf& v) const { float newDistance = AngleOf::CosineRuleSide(v.distance, this->distance, AngleOf::Degrees(rotation)); - float angle = Angle::CosineRuleAngle(newDistance, this->distance, v.distance) - .InDegrees(); + float angle = + AngleSingle::CosineRuleAngle(newDistance, this->distance, v.distance) + .InDegrees(); float newAngle = deltaAngle < 0.0f ? this->angle.InDegrees() - angle : this->angle.InDegrees() + angle; @@ -114,32 +104,29 @@ PolarOf PolarOf::operator+(const PolarOf& v) const { PolarOf vector = PolarOf(newDistance, newAngleA); return vector; } -template -PolarOf PolarOf::operator+=(const PolarOf& v) { +template PolarOf PolarOf::operator+=(const PolarOf &v) { *this = *this + v; return *this; } -template -PolarOf PolarOf::operator*=(float f) { +template PolarOf PolarOf::operator*=(float f) { this->distance *= f; return *this; } -template -PolarOf PolarOf::operator/=(float f) { +template PolarOf PolarOf::operator/=(float f) { this->distance /= f; return *this; } template -float PolarOf::Distance(const PolarOf& v1, const PolarOf& v2) { +float PolarOf::Distance(const PolarOf &v1, const PolarOf &v2) { float d = AngleOf::CosineRuleSide(v1.distance, v2.distance, v2.angle - v1.angle); return d; } template -PolarOf PolarOf::Rotate(const PolarOf& v, AngleOf angle) { +PolarOf PolarOf::Rotate(const PolarOf &v, AngleOf angle) { AngleOf a = AngleOf::Normalize(v.angle + angle); PolarOf r = PolarOf(v.distance, a); return r; diff --git a/Spherical.cpp b/Spherical.cpp index cde7654..e82c9af 100644 --- a/Spherical.cpp +++ b/Spherical.cpp @@ -251,7 +251,7 @@ AngleOf SphericalOf::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::Degrees(r.InDegrees()); } @@ -262,7 +262,7 @@ AngleOf Passer::LinearAlgebra::SphericalOf::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::Degrees(r.InDegrees()); } diff --git a/Vector2.cpp b/Vector2.cpp index 01c72e9..e895992 100644 --- a/Vector2.cpp +++ b/Vector2.cpp @@ -26,8 +26,8 @@ Vector2::Vector2(float _x, float _y) { // y = v.y; // } Vector2::Vector2(Vector3 v) { - x = v.Right(); // x; - y = v.Forward(); // z; + x = v.Right(); // x; + y = v.Forward(); // z; } Vector2::Vector2(Polar p) { float horizontalRad = p.angle.InDegrees() * Passer::LinearAlgebra::Deg2Rad; @@ -49,24 +49,18 @@ const Vector2 Vector2::down = Vector2(0, -1); const Vector2 Vector2::forward = Vector2(0, 1); const Vector2 Vector2::back = Vector2(0, -1); -bool Vector2::operator==(const Vector2& v) { +bool Vector2::operator==(const Vector2 &v) { return (this->x == v.x && this->y == v.y); } -float Vector2::Magnitude(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) { +Vector2 Vector2::Normalize(const Vector2 &v) { float num = Vector2::Magnitude(v); Vector2 result = Vector2::zero; if (num > Float::epsilon) { @@ -83,28 +77,26 @@ 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 { +Vector2 Vector2::operator-(const Vector2 &v) const { return Vector2(this->x - v.x, this->y - v.y); } -Vector2 Vector2::operator-=(const Vector2& v) { +Vector2 Vector2::operator-=(const Vector2 &v) { this->x -= v.x; this->y -= v.y; return *this; } -Vector2 Vector2::operator+(const Vector2& v) const { +Vector2 Vector2::operator+(const Vector2 &v) const { return Vector2(this->x + v.x, this->y + v.y); } -Vector2 Vector2::operator+=(const Vector2& v) { +Vector2 Vector2::operator+=(const Vector2 &v) { this->x += v.x; this->y += v.y; return *this; } -Vector2 Vector2::Scale(const Vector2& v1, const Vector2& v2) { +Vector2 Vector2::Scale(const Vector2 &v1, const Vector2 &v2) { return Vector2(v1.x * v2.x, v1.y * v2.y); } // Vector2 Passer::LinearAlgebra::operator*(const Vector2 &v, float f) { @@ -130,18 +122,18 @@ Vector2 Vector2::operator/=(float f) { return *this; } -float Vector2::Dot(const Vector2& v1, const Vector2& v2) { +float Vector2::Dot(const Vector2 &v1, const Vector2 &v2) { return v1.x * v2.x + v1.y * v2.y; } -float Vector2::Distance(const Vector2& v1, const Vector2& v2) { +float Vector2::Distance(const Vector2 &v1, const Vector2 &v2) { return Magnitude(v1 - v2); } -float Vector2::Angle(const Vector2& v1, const Vector2& v2) { +float Vector2::Angle(const Vector2 &v1, const Vector2 &v2) { return (float)fabs(SignedAngle(v1, v2)); } -float Vector2::SignedAngle(const Vector2& v1, const Vector2& v2) { +float Vector2::SignedAngle(const Vector2 &v1, const Vector2 &v2) { float sqrMagFrom = v1.sqrMagnitude(); float sqrMagTo = v2.sqrMagnitude(); @@ -159,11 +151,12 @@ 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); - float cosValue = cos(angleRad); // * Angle::Deg2Rad); + float cosValue = cos(angleRad); // * Angle::Deg2Rad); #else float sinValue = (float)sinf(angleRad); float cosValue = (float)cosf(angleRad); @@ -176,7 +169,7 @@ Vector2 Vector2::Rotate(const Vector2& v, Passer::LinearAlgebra::Angle a) { return r; } -Vector2 Vector2::Lerp(const Vector2& v1, const Vector2& v2, float f) { +Vector2 Vector2::Lerp(const Vector2 &v1, const Vector2 &v2, float f) { Vector2 v = v1 + (v2 - v1) * f; return v; } diff --git a/Vector2.h b/Vector2.h index 7805e69..eabac98 100644 --- a/Vector2.h +++ b/Vector2.h @@ -30,8 +30,7 @@ namespace Passer { namespace LinearAlgebra { struct Vector3; -template -class PolarOf; +template class PolarOf; // using Polar = PolarOf /// @brief A 2=dimensional vector @@ -40,7 +39,7 @@ class PolarOf; struct Vector2 : Vec2 { friend struct Vec2; - public: +public: /// @brief A new 2-dimensional zero vector Vector2(); /// @brief A new 2-dimensional vector @@ -82,12 +81,12 @@ struct Vector2 : Vec2 { /// @return true if it is identical to the given vector /// @note This uses float comparison to check equality which may have strange /// effects. Equality on floats should be avoided. - bool operator==(const Vector2& v); + bool operator==(const Vector2 &v); /// @brief The vector length /// @param v The vector for which you need the length /// @return The vector length - static float Magnitude(const Vector2& v); + static float Magnitude(const Vector2 &v); /// @brief The vector length /// @return The vector length float magnitude() const; @@ -97,7 +96,7 @@ struct Vector2 : Vec2 { /// @remark The squared length is computationally simpler than the real /// length. Think of Pythagoras A^2 + B^2 = C^2. This prevents the calculation /// of the squared root of C. - static float SqrMagnitude(const Vector2& v); + static float SqrMagnitude(const Vector2 &v); /// @brief The squared vector length /// @return The squared vector length /// @remark The squared length is computationally simpler than the real @@ -108,7 +107,7 @@ struct Vector2 : Vec2 { /// @brief Convert the vector to a length of 1 /// @param v The vector to convert /// @return The vector normalized to a length of 1 - static Vector2 Normalize(const Vector2& v); + static Vector2 Normalize(const Vector2 &v); /// @brief Convert the vector to a length 1 /// @return The vector normalized to a length of 1 Vector2 normalized() const; @@ -120,13 +119,13 @@ struct Vector2 : Vec2 { /// @brief Subtract a vector from this vector /// @param v The vector to subtract from this vector /// @return The result of the subtraction - Vector2 operator-(const Vector2& v) const; - Vector2 operator-=(const Vector2& v); + Vector2 operator-(const Vector2 &v) const; + Vector2 operator-=(const Vector2 &v); /// @brief Add a vector to this vector /// @param v The vector to add to this vector /// @return The result of the addition - Vector2 operator+(const Vector2& v) const; - Vector2 operator+=(const Vector2& v); + Vector2 operator+(const Vector2 &v) const; + Vector2 operator+=(const Vector2 &v); /// @brief Scale the vector using another vector /// @param v1 The vector to scale @@ -134,16 +133,16 @@ struct Vector2 : Vec2 { /// @return The scaled vector /// @remark Each component of the vector v1 will be multiplied with the /// matching component from the scaling vector v2. - static Vector2 Scale(const Vector2& v1, const Vector2& v2); + static Vector2 Scale(const Vector2 &v1, const Vector2 &v2); /// @brief Scale the vector uniformly up /// @param f The scaling factor /// @return The scaled vector /// @remark Each component of the vector will be multipled with the same /// factor f. - friend Vector2 operator*(const Vector2& v, float f) { + friend Vector2 operator*(const Vector2 &v, float f) { return Vector2(v.x * f, v.y * f); } - friend Vector2 operator*(float f, const Vector2& v) { + friend Vector2 operator*(float f, const Vector2 &v) { return Vector2(v.x * f, v.y * f); // return Vector2(f * v.x, f * v.y); } @@ -152,10 +151,10 @@ struct Vector2 : Vec2 { /// @param f The scaling factor /// @return The scaled vector /// @remark Each componet of the vector will be divided by the same factor. - friend Vector2 operator/(const Vector2& v, float f) { + friend Vector2 operator/(const Vector2 &v, float f) { return Vector2(v.x / f, v.y / f); } - friend Vector2 operator/(float f, const Vector2& v) { + friend Vector2 operator/(float f, const Vector2 &v) { return Vector2(f / v.x, f / v.y); } Vector2 operator/=(float f); @@ -164,13 +163,13 @@ struct Vector2 : Vec2 { /// @param v1 The first vector /// @param v2 The second vector /// @return The dot product of the two vectors - static float Dot(const Vector2& v1, const Vector2& v2); + static float Dot(const Vector2 &v1, const Vector2 &v2); /// @brief The distance between two vectors /// @param v1 The first vector /// @param v2 The second vector /// @return The distance between the two vectors - static float Distance(const Vector2& v1, const Vector2& v2); + static float Distance(const Vector2 &v1, const Vector2 &v2); /// @brief The angle between two vectors /// @param v1 The first vector @@ -179,18 +178,18 @@ struct Vector2 : Vec2 { /// @remark This reterns an unsigned angle which is the shortest distance /// between the two vectors. Use Vector2::SignedAngle if a signed angle is /// needed. - static float Angle(const Vector2& v1, const Vector2& v2); + static float Angle(const Vector2 &v1, const Vector2 &v2); /// @brief The signed angle between two vectors /// @param v1 The starting vector /// @param v2 The ending vector /// @return The signed angle between the two vectors - static float SignedAngle(const Vector2& v1, const Vector2& v2); + static float SignedAngle(const Vector2 &v1, const Vector2 &v2); /// @brief Rotate the vector /// @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 @@ -200,11 +199,11 @@ struct Vector2 : Vec2 { /// @remark The factor f is unclamped. Value 0 matches the vector *v1*, Value /// 1 matches vector *v2*. Value -1 is vector *v1* minus the difference /// between *v1* and *v2* etc. - static Vector2 Lerp(const Vector2& v1, const Vector2& v2, float f); + static Vector2 Lerp(const Vector2 &v1, const Vector2 &v2, float f); }; -} // namespace LinearAlgebra -} // namespace Passer +} // namespace LinearAlgebra +} // namespace Passer using namespace Passer::LinearAlgebra; #include "Polar.h" diff --git a/test/AngleSingle_test.cc b/test/AngleSingle_test.cc index 9537ffb..773dfe4 100644 --- a/test/AngleSingle_test.cc +++ b/test/AngleSingle_test.cc @@ -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"; diff --git a/test/Polar_test.cc b/test/Polar_test.cc index 8bfd55f..7f93074 100644 --- a/test/Polar_test.cc +++ b/test/Polar_test.cc @@ -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)"; } diff --git a/test/SphericalSingle_test.cc b/test/SphericalSingle_test.cc index 43f4151..e77276a 100644 --- a/test/SphericalSingle_test.cc +++ b/test/SphericalSingle_test.cc @@ -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)"; diff --git a/test/Vector2_test.cc b/test/Vector2_test.cc index 3f8768e..05c95d8 100644 --- a/test/Vector2_test.cc +++ b/test/Vector2_test.cc @@ -1,7 +1,7 @@ #if GTEST #include -#include #include +#include #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); }