From 49c67405fcbf15b3470080e67ab203c835f1f9b8 Mon Sep 17 00:00:00 2001 From: Pascal Serrarens Date: Mon, 5 Aug 2024 10:03:42 +0200 Subject: [PATCH] Make Angle -> float conversion explicit --- Angle.cpp | 44 ++++++++++------- Angle.h | 11 ++++- Angle16.cpp | 13 +++-- Angle8.cpp | 8 +++- Axis.cpp | 11 +++-- Polar.cpp | 29 +++++++----- Spherical.cpp | 30 +++++++----- Spherical16.cpp | 59 ++++++++++++----------- Vector2.cpp | 6 +-- Vector3.cpp | 6 ++- test/Angle_test.cc | 97 +++++++++++++++++++------------------- test/DiscreteAngle_test.cc | 26 +++++----- test/Polar_test.cc | 34 ++++++------- test/Spherical16_test.cc | 75 +++++++++++++++-------------- test/Spherical_test.cc | 61 ++++++++++++------------ 15 files changed, 283 insertions(+), 227 deletions(-) diff --git a/Angle.cpp b/Angle.cpp index 6719140..3b0b3d5 100644 --- a/Angle.cpp +++ b/Angle.cpp @@ -74,32 +74,37 @@ float Angle::SineRuleAngle(float a, float beta, float b) { //---------------------- template <> -AngleOf::AngleOf(int angle) : value(angle) {} +AngleOf::AngleOf(int angle) : value((float)angle) {} template <> AngleOf::AngleOf(float angle) : value(angle) {} +// template <> +// AngleOf::operator float() const { +// return value; +// } + template <> -AngleOf::operator float() const { +float AngleOf::ToFloat() const { return value; } -template <> -AngleOf AngleOf::pi = 3.1415927410125732421875F; +// template <> +// AngleOf AngleOf::pi = 3.1415927410125732421875F; -template <> -AngleOf AngleOf::Rad2Deg = 360.0f / (pi * 2); -template <> -AngleOf AngleOf::Deg2Rad = (pi * 2) / 360.0f; +// template <> +// AngleOf AngleOf::Rad2Deg = 360.0f / (pi * 2); +// template <> +// AngleOf AngleOf::Deg2Rad = (pi * 2) / 360.0f; template <> bool Passer::LinearAlgebra::AngleOf::operator==(AngleOf a) { - return (float)*this == (float)a; + return this->ToFloat() == a.ToFloat(); } template <> AngleOf AngleOf::Normalize(AngleOf angle) { - float angleValue = angle; + float angleValue = angle.ToFloat(); if (!isfinite(angleValue)) return angleValue; @@ -114,8 +119,8 @@ template <> AngleOf AngleOf::Clamp(AngleOf angle, AngleOf min, AngleOf max) { - float normalizedAngle = Normalize(angle); - float r = Float::Clamp(normalizedAngle, min, max); + float normalizedAngle = Normalize(angle).ToFloat(); + float r = Float::Clamp(normalizedAngle, min.ToFloat(), max.ToFloat()); return r; } @@ -129,10 +134,10 @@ template <> AngleOf AngleOf::MoveTowards(AngleOf fromAngle, AngleOf toAngle, AngleOf maxAngle) { - float d = toAngle - fromAngle; + float d = toAngle.ToFloat() - fromAngle.ToFloat(); int sign = signbit(d) ? -1 : 1; - d = sign * Float::Clamp(fabsf(d), 0, maxAngle); - return fromAngle + d; + d = sign * Float::Clamp(fabsf(d), 0, maxAngle.ToFloat()); + return fromAngle.ToFloat() + d; } template <> @@ -141,7 +146,8 @@ AngleOf AngleOf::CosineRuleSide(float a, AngleOf gamma) { float a2 = a * a; float b2 = b * b; - float d = a2 + b2 - 2 * a * b * cos(gamma * AngleOf::Deg2Rad); + float d = a2 + b2 - + 2 * a * b * cosf(gamma.ToFloat() * Passer::LinearAlgebra::Deg2Rad); // Catch edge cases where float inacuracies lead tot nans if (d < 0) return 0.0f; @@ -162,7 +168,8 @@ AngleOf AngleOf::CosineRuleAngle(float a, float b, float c) { if (d <= -1) return 180.0f; - float gamma = acos(d) * Angle::Rad2Deg; + float rad2deg = Passer::LinearAlgebra::Rad2Deg; + float gamma = acosf(d) * rad2deg; return gamma; } @@ -170,6 +177,7 @@ template <> AngleOf AngleOf::SineRuleAngle(float a, AngleOf beta, float b) { - float alpha = asin(a * sin(beta * Angle::Deg2Rad) / b); + float deg2rad = Passer::LinearAlgebra::Deg2Rad; + float alpha = asinf(a * sinf(beta.ToFloat() * deg2rad) / b); return alpha; } \ No newline at end of file diff --git a/Angle.h b/Angle.h index 5b881da..fc845a8 100644 --- a/Angle.h +++ b/Angle.h @@ -8,13 +8,20 @@ namespace Passer { namespace LinearAlgebra { +static float pi = 3.1415927410125732421875F; + +static float Rad2Deg = 360.0f / (pi * 2); +static float Deg2Rad = (pi * 2) / 360.0f; + template class AngleOf { public: AngleOf() {}; AngleOf(int f); AngleOf(float f); - operator float() const; + // operator float() const; + + float ToFloat() const; inline T GetBinary() const { return this->value; } @@ -28,7 +35,7 @@ class AngleOf { static AngleOf Normalize(AngleOf a); static AngleOf Clamp(AngleOf a, AngleOf min, AngleOf max); static AngleOf Difference(AngleOf a, AngleOf b) { - AngleOf r = Normalize(b - a); + AngleOf r = Normalize(b.ToFloat() - a.ToFloat()); return r; }; static AngleOf MoveTowards(AngleOf fromAngle, diff --git a/Angle16.cpp b/Angle16.cpp index c227779..e5e9cc5 100644 --- a/Angle16.cpp +++ b/Angle16.cpp @@ -23,8 +23,14 @@ AngleOf::AngleOf(float angle) { this->value = (signed short)(angle / 360.0F * 65536.0F); } +// template <> +// AngleOf::operator float() const { +// float f = ((this->value * 180) / 32768.0F); +// return f; +// } + template <> -AngleOf::operator float() const { +float AngleOf::ToFloat() const { float f = ((this->value * 180) / 32768.0F); return f; } @@ -37,7 +43,8 @@ AngleOf AngleOf::CosineRuleSide( AngleOf gamma) { float a2 = a * a; float b2 = b * b; - float d = a2 + b2 - 2 * a * b * cosf(gamma * AngleOf::Deg2Rad); + float d = a2 + b2 - + 2 * a * b * cosf(gamma.ToFloat() * Passer::LinearAlgebra::Deg2Rad); // Catch edge cases where float inacuracies lead tot nans if (d < 0) return 0.0f; @@ -61,6 +68,6 @@ AngleOf AngleOf::CosineRuleAngle(float a, if (d <= -1) return 180.0f; - float gamma = acosf(d) * Angle::Rad2Deg; + float gamma = acosf(d) * Passer::LinearAlgebra::Rad2Deg; return gamma; } diff --git a/Angle8.cpp b/Angle8.cpp index fec8e30..0ff2af0 100644 --- a/Angle8.cpp +++ b/Angle8.cpp @@ -23,8 +23,14 @@ AngleOf::AngleOf(float angle) { this->value = (signed char)(f * 256.0F); } +// template <> +// AngleOf::operator float() const { +// float f = (this->value * 180) / 128.0F; +// return f; +// } + template <> -AngleOf::operator float() const { +float AngleOf::ToFloat() const { float f = (this->value * 180) / 128.0F; return f; } diff --git a/Axis.cpp b/Axis.cpp index 6c7629c..02f9ebc 100644 --- a/Axis.cpp +++ b/Axis.cpp @@ -20,8 +20,9 @@ Axis::Axis(Angle horizontal, Angle vertical) { }; Axis::Axis(Vector3 v) { - this->horizontalAngle = atan2f(v.Right(), v.Forward()) * Angle::Rad2Deg; - this->verticalAngle = 90 - acosf(v.Up()) * Angle::Rad2Deg; + this->horizontalAngle = + atan2f(v.Right(), v.Forward()) * Passer::LinearAlgebra::Rad2Deg; + this->verticalAngle = 90 - acosf(v.Up()) * Passer::LinearAlgebra::Rad2Deg; } const Axis Axis::forward = Axis(0.0f, 0.0f); @@ -32,8 +33,8 @@ const Axis Axis::left = Axis(-90.0f, 0.0f); const Axis Axis::right = Axis(90.0f, 0.0f); Vector3 Axis::ToVector3() { - Vector3 v = - Quaternion::Euler(-this->verticalAngle, this->horizontalAngle, 0) * - Vector3::forward; + Vector3 v = Quaternion::Euler(-(this->verticalAngle.ToFloat()), + this->horizontalAngle.ToFloat(), 0) * + Vector3::forward; return v; } \ No newline at end of file diff --git a/Polar.cpp b/Polar.cpp index 8bebaf1..b3f09e8 100644 --- a/Polar.cpp +++ b/Polar.cpp @@ -12,7 +12,7 @@ Polar::Polar(float distance, Angle angle) { // distance should always be 0 or greater if (distance < 0.0f) { this->distance = -distance; - this->angle = Angle::Normalize(angle - 180); + this->angle = Angle::Normalize(angle.ToFloat() - 180.0f); } else { this->distance = distance; if (this->distance == 0.0f) @@ -27,7 +27,8 @@ Polar::Polar(Vector2 v) { this->angle = Vector2::SignedAngle(Vector2::forward, v); } Polar::Polar(Spherical v) { - this->distance = v.distance * cosf(v.verticalAngle * Angle::Deg2Rad); + this->distance = v.distance * cosf(v.verticalAngle.ToFloat() * + Passer::LinearAlgebra::Deg2Rad); this->angle = v.horizontalAngle; } @@ -38,7 +39,8 @@ const Polar Polar::right = Polar(1.0, 90.0f); const Polar Polar::left = Polar(1.0, -90.0f); bool Polar::operator==(const Polar& v) const { - return (this->distance == v.distance && this->angle == v.angle); + return (this->distance == v.distance && + this->angle.ToFloat() == v.angle.ToFloat()); } Polar Polar::Normalize(const Polar& v) { @@ -51,7 +53,7 @@ Polar Polar::normalized() const { } Polar Polar::operator-() const { - Polar v = Polar(this->distance, this->angle + 180); + Polar v = Polar(this->distance, this->angle.ToFloat() + 180.0f); return v; } @@ -69,7 +71,8 @@ Polar Polar::operator+(const Polar& v) const { if (this->distance == 0.0f) return v; - float deltaAngle = Angle::Normalize(v.angle - (float)this->angle); + float deltaAngle = + Angle::Normalize(v.angle.ToFloat() - this->angle.ToFloat()).ToFloat(); float rotation = deltaAngle < 0.0f ? 180.0f + deltaAngle : 180.0f - deltaAngle; @@ -79,13 +82,14 @@ Polar Polar::operator+(const Polar& v) const { } float newDistance = - Angle::CosineRuleSide(v.distance, this->distance, rotation); + Angle::CosineRuleSide(v.distance, this->distance, rotation).ToFloat(); - float angle = Angle::CosineRuleAngle(newDistance, this->distance, v.distance); + float angle = + Angle::CosineRuleAngle(newDistance, this->distance, v.distance).ToFloat(); - float newAngle = deltaAngle < 0.0f ? (float)this->angle - angle - : (float)this->angle + angle; - newAngle = Angle::Normalize(newAngle); + float newAngle = deltaAngle < 0.0f ? this->angle.ToFloat() - angle + : this->angle.ToFloat() + angle; + newAngle = Angle::Normalize(newAngle).ToFloat(); Polar vector = Polar(newDistance, newAngle); return vector; } @@ -117,12 +121,13 @@ Polar Polar::operator/=(float f) { float Polar::Distance(const Polar& v1, const Polar& v2) { float d = Angle::CosineRuleSide(v1.distance, v2.distance, - (float)v2.angle - (float)v1.angle); + v2.angle.ToFloat() - v1.angle.ToFloat()) + .ToFloat(); return d; } Polar Polar::Rotate(const Polar& v, Angle angle) { - Angle a = Angle::Normalize(v.angle + angle); + Angle a = Angle::Normalize(v.angle.ToFloat() + angle.ToFloat()); Polar r = Polar(v.distance, a); return r; } \ No newline at end of file diff --git a/Spherical.cpp b/Spherical.cpp index ed97484..f1a80d1 100644 --- a/Spherical.cpp +++ b/Spherical.cpp @@ -22,7 +22,8 @@ Spherical::Spherical(float distance, Angle verticalAngle) { if (distance < 0) { this->distance = -distance; - this->horizontalAngle = Angle::Normalize(horizontalAngle - 180); + this->horizontalAngle = + Angle::Normalize(horizontalAngle.ToFloat() - 180.0f); this->verticalAngle = verticalAngle; } else { this->distance = distance; @@ -37,9 +38,10 @@ Spherical::Spherical(Vector3 v) { this->verticalAngle = 0.0f; this->horizontalAngle = 0.0f; } else { - this->verticalAngle = - (90.0f - acosf(v.Up() / this->distance) * Angle::Rad2Deg); - this->horizontalAngle = atan2f(v.Right(), v.Forward()) * Angle::Rad2Deg; + this->verticalAngle = (90.0f - acosf(v.Up() / this->distance) * + Passer::LinearAlgebra::Rad2Deg); + this->horizontalAngle = + atan2f(v.Right(), v.Forward()) * Passer::LinearAlgebra::Rad2Deg; } } @@ -53,8 +55,8 @@ const Spherical Spherical::down = Spherical(1.0f, 0.0f, -90.0f); bool Spherical::operator==(const Spherical& v) const { return (this->distance == v.distance && - this->horizontalAngle == v.horizontalAngle && - this->verticalAngle == v.verticalAngle); + this->horizontalAngle.ToFloat() == v.horizontalAngle.ToFloat() && + this->verticalAngle.ToFloat() == v.verticalAngle.ToFloat()); } Spherical Spherical::Normalize(const Spherical& v) { @@ -67,8 +69,9 @@ Spherical Spherical::normalized() const { } Spherical Spherical::operator-() const { - Spherical v = Spherical(this->distance, this->horizontalAngle + 180.0f, - this->verticalAngle + 180.0f); + Spherical v = + Spherical(this->distance, this->horizontalAngle.ToFloat() + 180.0f, + this->verticalAngle.ToFloat() + 180.0f); return v; } @@ -207,15 +210,18 @@ Angle Spherical::AngleBetween(const Spherical& v1, const Spherical& v2) { Spherical Spherical::Rotate(const Spherical& v, Angle horizontalAngle, Angle verticalAngle) { - Spherical r = Spherical(v.distance, v.horizontalAngle + horizontalAngle, - v.verticalAngle + verticalAngle); + Spherical r = Spherical( + v.distance, v.horizontalAngle.ToFloat() + horizontalAngle.ToFloat(), + v.verticalAngle.ToFloat() + verticalAngle.ToFloat()); return r; } Spherical Spherical::RotateHorizontal(const Spherical& v, Angle a) { - Spherical r = Spherical(v.distance, v.horizontalAngle + a, v.verticalAngle); + Spherical r = Spherical(v.distance, v.horizontalAngle.ToFloat() + a.ToFloat(), + v.verticalAngle.ToFloat()); return r; } Spherical Spherical::RotateVertical(const Spherical& v, Angle a) { - Spherical r = Spherical(v.distance, v.horizontalAngle, v.verticalAngle + a); + Spherical r = Spherical(v.distance, v.horizontalAngle.ToFloat(), + v.verticalAngle.ToFloat() + a.ToFloat()); return r; } \ No newline at end of file diff --git a/Spherical16.cpp b/Spherical16.cpp index b0761fb..5000841 100644 --- a/Spherical16.cpp +++ b/Spherical16.cpp @@ -13,7 +13,7 @@ Spherical16::Spherical16() { Spherical16::Spherical16(Polar polar) { this->distance = polar.distance; - this->horizontalAngle = Angle16(polar.angle); + this->horizontalAngle = Angle16(polar.angle.ToFloat()); this->verticalAngle = Angle16(0); } @@ -22,7 +22,7 @@ Spherical16::Spherical16(float distance, Angle16 verticalAngle) { if (distance < 0) { this->distance = -distance; - this->horizontalAngle = horizontalAngle - Angle16(180); + this->horizontalAngle = horizontalAngle.ToFloat() - Angle16(180).ToFloat(); this->verticalAngle = verticalAngle; } else { this->distance = distance; @@ -37,9 +37,10 @@ Spherical16::Spherical16(Vector3 v) { this->verticalAngle = 0.0f; this->horizontalAngle = 0.0f; } else { - this->verticalAngle = - (90.0f - acosf(v.Up() / this->distance) * Angle::Rad2Deg); - this->horizontalAngle = atan2f(v.Right(), v.Forward()) * Angle::Rad2Deg; + this->verticalAngle = (90.0f - acosf(v.Up() / this->distance) * + Passer::LinearAlgebra::Rad2Deg); + this->horizontalAngle = + atan2f(v.Right(), v.Forward()) * Passer::LinearAlgebra::Rad2Deg; } } @@ -53,8 +54,8 @@ const Spherical16 Spherical16::down = Spherical16(1.0f, 0.0f, -90.0f); bool Spherical16::operator==(const Spherical16& v) const { return (this->distance == v.distance && - this->horizontalAngle == v.horizontalAngle && - this->verticalAngle == v.verticalAngle); + this->horizontalAngle.ToFloat() == v.horizontalAngle.ToFloat() && + this->verticalAngle.ToFloat() == v.verticalAngle.ToFloat()); } Spherical16 Spherical16::Normalize(const Spherical16& v) { @@ -67,16 +68,18 @@ Spherical16 Spherical16::normalized() const { } Spherical16 Spherical16::operator-() const { - Spherical16 v = Spherical16(this->distance, this->horizontalAngle + 180.0f, - this->verticalAngle + 180.0f); + Spherical16 v = + Spherical16(this->distance, this->horizontalAngle.ToFloat() + 180.0f, + this->verticalAngle.ToFloat() + 180.0f); return v; } Spherical16 Spherical16::operator-(const Spherical16& s2) const { - Spherical thisSpherical = Spherical( - this->distance, (Angle)this->horizontalAngle, (Angle)this->verticalAngle); - Spherical spherical2 = Spherical(s2.distance, (Angle)s2.horizontalAngle, - (Angle)s2.verticalAngle); + Spherical thisSpherical = + Spherical(this->distance, this->horizontalAngle.ToFloat(), + this->verticalAngle.ToFloat()); + Spherical spherical2 = Spherical(s2.distance, s2.horizontalAngle.ToFloat(), + s2.verticalAngle.ToFloat()); // let's do it the easy way... Vector3 v1 = Vector3(thisSpherical); @@ -92,10 +95,11 @@ Spherical16 Spherical16::operator-=(const Spherical16& v) { Spherical16 Spherical16::operator+(const Spherical16& s2) const { // let's do it the easy way... - Vector3 v1 = Vector3(Spherical(this->distance, (float)this->horizontalAngle, - (float)this->verticalAngle)); - Vector3 v2 = Vector3(Spherical(s2.distance, (float)s2.horizontalAngle, - (float)s2.verticalAngle)); + Vector3 v1 = + Vector3(Spherical(this->distance, this->horizontalAngle.ToFloat(), + this->verticalAngle.ToFloat())); + Vector3 v2 = Vector3(Spherical(s2.distance, s2.horizontalAngle.ToFloat(), + s2.verticalAngle.ToFloat())); Vector3 v = v1 + v2; Spherical16 r = Spherical16(v); return r; @@ -199,10 +203,10 @@ Angle Spherical16::AngleBetween(const Spherical16& v1, const Spherical16& v2) { if (denominator < epsilon) return 0.0f; - Vector3 v1_3 = Vector3(Spherical(v1.distance, (Angle)v1.horizontalAngle, - (Angle)v1.verticalAngle)); - Vector3 v2_3 = Vector3(Spherical(v2.distance, (Angle)v2.horizontalAngle, - (Angle)v2.verticalAngle)); + Vector3 v1_3 = Vector3(Spherical(v1.distance, v1.horizontalAngle.ToFloat(), + v1.verticalAngle.ToFloat())); + Vector3 v2_3 = Vector3(Spherical(v2.distance, v2.horizontalAngle.ToFloat(), + v2.verticalAngle.ToFloat())); float dot = Vector3::Dot(v1_3, v2_3); float fraction = dot / denominator; if (isnan(fraction)) @@ -216,17 +220,18 @@ Angle Spherical16::AngleBetween(const Spherical16& v1, const Spherical16& v2) { Spherical16 Spherical16::Rotate(const Spherical16& v, Angle horizontalAngle, Angle verticalAngle) { - Spherical16 r = Spherical16(v.distance, v.horizontalAngle + horizontalAngle, - v.verticalAngle + verticalAngle); + Spherical16 r = Spherical16( + v.distance, v.horizontalAngle.ToFloat() + horizontalAngle.ToFloat(), + v.verticalAngle.ToFloat() + verticalAngle.ToFloat()); return r; } Spherical16 Spherical16::RotateHorizontal(const Spherical16& v, Angle a) { - Spherical16 r = - Spherical16(v.distance, v.horizontalAngle + a, v.verticalAngle); + Spherical16 r = Spherical16( + v.distance, v.horizontalAngle.ToFloat() + a.ToFloat(), v.verticalAngle); return r; } Spherical16 Spherical16::RotateVertical(const Spherical16& v, Angle a) { - Spherical16 r = - Spherical16(v.distance, v.horizontalAngle, v.verticalAngle + a); + Spherical16 r = Spherical16(v.distance, v.horizontalAngle, + v.verticalAngle.ToFloat() + a.ToFloat()); return r; } \ No newline at end of file diff --git a/Vector2.cpp b/Vector2.cpp index a7ded06..b4b7d2d 100644 --- a/Vector2.cpp +++ b/Vector2.cpp @@ -30,7 +30,7 @@ Vector2::Vector2(Vector3 v) { y = v.Forward(); // z; } Vector2::Vector2(Polar p) { - float horizontalRad = p.angle * Angle::Deg2Rad; + float horizontalRad = p.angle.ToFloat() * Passer::LinearAlgebra::Deg2Rad; float cosHorizontal = cosf(horizontalRad); float sinHorizontal = sinf(horizontalRad); @@ -156,11 +156,11 @@ float Vector2::SignedAngle(const Vector2& v1, const Vector2& v2) { float angleFrom = atan2f(v1.y, v1.x); float angleTo = atan2f(v2.y, v2.x); - return -(angleTo - angleFrom) * Angle::Rad2Deg; + return -(angleTo - angleFrom) * Passer::LinearAlgebra::Rad2Deg; } Vector2 Vector2::Rotate(const Vector2& v, Passer::LinearAlgebra::Angle a) { - float angleRad = a * Angle::Deg2Rad; + float angleRad = a.ToFloat() * Passer::LinearAlgebra::Deg2Rad; #if defined(AVR) float sinValue = sin(angleRad); float cosValue = cos(angleRad); // * Angle::Deg2Rad); diff --git a/Vector3.cpp b/Vector3.cpp index 50829d7..b8f20ff 100644 --- a/Vector3.cpp +++ b/Vector3.cpp @@ -31,8 +31,10 @@ Vector3::Vector3(Vector2 v) { } Vector3::Vector3(Spherical s) { - float verticalRad = (90 - s.verticalAngle) * Angle::Deg2Rad; - float horizontalRad = s.horizontalAngle * Angle::Deg2Rad; + float verticalRad = + (90.0f - s.verticalAngle.ToFloat()) * Passer::LinearAlgebra::Deg2Rad; + float horizontalRad = + s.horizontalAngle.ToFloat() * Passer::LinearAlgebra::Deg2Rad; float cosVertical = cosf(verticalRad); float sinVertical = sinf(verticalRad); float cosHorizontal = cosf(horizontalRad); diff --git a/test/Angle_test.cc b/test/Angle_test.cc index 21b4dce..5625b2d 100644 --- a/test/Angle_test.cc +++ b/test/Angle_test.cc @@ -9,158 +9,159 @@ #define FLOAT_INFINITY std::numeric_limits::infinity() TEST(Angle, Normalize) { - float r = 0; + Angle r = 0; r = Angle::Normalize(90.0f); - EXPECT_FLOAT_EQ(r, 90) << "Normalize 90"; + EXPECT_FLOAT_EQ(r.ToFloat(), 90) << "Normalize 90"; r = Angle::Normalize(-90); - EXPECT_FLOAT_EQ(r, -90) << "Normalize -90"; + EXPECT_FLOAT_EQ(r.ToFloat(), -90) << "Normalize -90"; r = Angle::Normalize(270); - EXPECT_FLOAT_EQ(r, -90) << "Normalize 270"; + EXPECT_FLOAT_EQ(r.ToFloat(), -90) << "Normalize 270"; r = Angle::Normalize(270 + 360); - EXPECT_FLOAT_EQ(r, -90) << "Normalize 270+360"; + EXPECT_FLOAT_EQ(r.ToFloat(), -90) << "Normalize 270+360"; r = Angle::Normalize(-270); - EXPECT_FLOAT_EQ(r, 90) << "Normalize -270"; + EXPECT_FLOAT_EQ(r.ToFloat(), 90) << "Normalize -270"; r = Angle::Normalize(-270 - 360); - EXPECT_FLOAT_EQ(r, 90) << "Normalize -270-360"; + EXPECT_FLOAT_EQ(r.ToFloat(), 90) << "Normalize -270-360"; r = Angle::Normalize(0); - EXPECT_FLOAT_EQ(r, 0) << "Normalize 0"; + EXPECT_FLOAT_EQ(r.ToFloat(), 0) << "Normalize 0"; if (std::numeric_limits::is_iec559) { r = Angle::Normalize(FLOAT_INFINITY); - EXPECT_FLOAT_EQ(r, FLOAT_INFINITY) << "Normalize INFINITY"; + EXPECT_FLOAT_EQ(r.ToFloat(), FLOAT_INFINITY) << "Normalize INFINITY"; r = Angle::Normalize(-FLOAT_INFINITY); - EXPECT_FLOAT_EQ(r, -FLOAT_INFINITY) << "Normalize INFINITY"; + EXPECT_FLOAT_EQ(r.ToFloat(), -FLOAT_INFINITY) << "Normalize INFINITY"; } } TEST(Angle, Clamp) { - float r = 0; + Angle r = 0; r = Angle::Clamp(1, 0, 2); - EXPECT_FLOAT_EQ(r, 1) << "Clamp 1 0 2"; + EXPECT_FLOAT_EQ(r.ToFloat(), 1) << "Clamp 1 0 2"; r = Angle::Clamp(-1, 0, 2); - EXPECT_FLOAT_EQ(r, 0) << "Clamp -1 0 2"; + EXPECT_FLOAT_EQ(r.ToFloat(), 0) << "Clamp -1 0 2"; r = Angle::Clamp(3, 0, 2); - EXPECT_FLOAT_EQ(r, 2) << "Clamp 3 0 2"; + EXPECT_FLOAT_EQ(r.ToFloat(), 2) << "Clamp 3 0 2"; r = Angle::Clamp(1, 0, 0); - EXPECT_FLOAT_EQ(r, 0) << "Clamp 1 0 0"; + EXPECT_FLOAT_EQ(r.ToFloat(), 0) << "Clamp 1 0 0"; r = Angle::Clamp(0, 0, 0); - EXPECT_FLOAT_EQ(r, 0) << "Clamp 0 0 0"; + EXPECT_FLOAT_EQ(r.ToFloat(), 0) << "Clamp 0 0 0"; r = Angle::Clamp(0, 1, -1); - EXPECT_FLOAT_EQ(r, 1) << "Clamp 0 1 -1"; + EXPECT_FLOAT_EQ(r.ToFloat(), 1) << "Clamp 0 1 -1"; if (std::numeric_limits::is_iec559) { r = Angle::Clamp(1, 0, FLOAT_INFINITY); - EXPECT_FLOAT_EQ(r, 1) << "Clamp 1 0 INFINITY"; + EXPECT_FLOAT_EQ(r.ToFloat(), 1) << "Clamp 1 0 INFINITY"; r = Angle::Clamp(1, -FLOAT_INFINITY, 1); - EXPECT_FLOAT_EQ(r, 1) << "Clamp 1 -INFINITY 1"; + EXPECT_FLOAT_EQ(r.ToFloat(), 1) << "Clamp 1 -INFINITY 1"; } } TEST(Angle, Difference) { - float r = 0; + Angle r = 0; r = Angle::Difference(0, 90); - EXPECT_FLOAT_EQ(r, 90) << "Difference 0 90"; + EXPECT_FLOAT_EQ(r.ToFloat(), 90) << "Difference 0 90"; r = Angle::Difference(0, -90); - EXPECT_FLOAT_EQ(r, -90) << "Difference 0 -90"; + EXPECT_FLOAT_EQ(r.ToFloat(), -90) << "Difference 0 -90"; r = Angle::Difference(0, 270); - EXPECT_FLOAT_EQ(r, -90) << "Difference 0 270"; + EXPECT_FLOAT_EQ(r.ToFloat(), -90) << "Difference 0 270"; r = Angle::Difference(0, -270); - EXPECT_FLOAT_EQ(r, 90) << "Difference 0 -270"; + EXPECT_FLOAT_EQ(r.ToFloat(), 90) << "Difference 0 -270"; r = Angle::Difference(90, 0); - EXPECT_FLOAT_EQ(r, -90) << "Difference 90 0"; + EXPECT_FLOAT_EQ(r.ToFloat(), -90) << "Difference 90 0"; r = Angle::Difference(-90, 0); - EXPECT_FLOAT_EQ(r, 90) << "Difference -90 0"; + EXPECT_FLOAT_EQ(r.ToFloat(), 90) << "Difference -90 0"; r = Angle::Difference(0, 0); - EXPECT_FLOAT_EQ(r, 0) << "Difference 0 0"; + EXPECT_FLOAT_EQ(r.ToFloat(), 0) << "Difference 0 0"; r = Angle::Difference(90, 90); - EXPECT_FLOAT_EQ(r, 0) << "Difference 90 90"; + EXPECT_FLOAT_EQ(r.ToFloat(), 0) << "Difference 90 90"; if (std::numeric_limits::is_iec559) { r = Angle::Difference(0, INFINITY); - EXPECT_FLOAT_EQ(r, INFINITY) << "Difference 0 INFINITY"; + EXPECT_FLOAT_EQ(r.ToFloat(), INFINITY) << "Difference 0 INFINITY"; r = Angle::Difference(0, -INFINITY); - EXPECT_FLOAT_EQ(r, -INFINITY) << "Difference 0 -INFINITY"; + EXPECT_FLOAT_EQ(r.ToFloat(), -INFINITY) << "Difference 0 -INFINITY"; r = Angle::Difference(-INFINITY, INFINITY); - EXPECT_FLOAT_EQ(r, INFINITY) << "Difference -INFINITY INFINITY"; + EXPECT_FLOAT_EQ(r.ToFloat(), INFINITY) << "Difference -INFINITY INFINITY"; } } TEST(Angle, MoveTowards) { - float r = 0; + Angle r = 0; r = Angle::MoveTowards(0, 90, 30); - EXPECT_FLOAT_EQ(r, 30) << "MoveTowards 0 90 30"; + EXPECT_FLOAT_EQ(r.ToFloat(), 30) << "MoveTowards 0 90 30"; r = Angle::MoveTowards(0, 90, 90); - EXPECT_FLOAT_EQ(r, 90) << "MoveTowards 0 90 90"; + EXPECT_FLOAT_EQ(r.ToFloat(), 90) << "MoveTowards 0 90 90"; r = Angle::MoveTowards(0, 90, 180); - EXPECT_FLOAT_EQ(r, 90) << "MoveTowards 0 90 180"; + EXPECT_FLOAT_EQ(r.ToFloat(), 90) << "MoveTowards 0 90 180"; r = Angle::MoveTowards(0, 90, 270); - EXPECT_FLOAT_EQ(r, 90) << "MoveTowards 0 90 270"; + EXPECT_FLOAT_EQ(r.ToFloat(), 90) << "MoveTowards 0 90 270"; r = Angle::MoveTowards(0, 90, -30); - EXPECT_FLOAT_EQ(r, -30) << "MoveTowards 0 90 -30"; + EXPECT_FLOAT_EQ(r.ToFloat(), -30) << "MoveTowards 0 90 -30"; r = Angle::MoveTowards(0, -90, -30); - EXPECT_FLOAT_EQ(r, 30) << "MoveTowards 0 -90 -30"; + EXPECT_FLOAT_EQ(r.ToFloat(), 30) << "MoveTowards 0 -90 -30"; r = Angle::MoveTowards(0, -90, -90); - EXPECT_FLOAT_EQ(r, 90) << "MoveTowards 0 -90 -90"; + EXPECT_FLOAT_EQ(r.ToFloat(), 90) << "MoveTowards 0 -90 -90"; r = Angle::MoveTowards(0, -90, -180); - EXPECT_FLOAT_EQ(r, 180) << "MoveTowards 0 -90 -180"; + EXPECT_FLOAT_EQ(r.ToFloat(), 180) << "MoveTowards 0 -90 -180"; r = Angle::MoveTowards(0, -90, -270); - EXPECT_FLOAT_EQ(r, 270) << "MoveTowards 0 -90 -270"; + EXPECT_FLOAT_EQ(r.ToFloat(), 270) << "MoveTowards 0 -90 -270"; r = Angle::MoveTowards(0, 90, 0); - EXPECT_FLOAT_EQ(r, 0) << "MoveTowards 0 90 0"; + EXPECT_FLOAT_EQ(r.ToFloat(), 0) << "MoveTowards 0 90 0"; r = Angle::MoveTowards(0, 0, 0); - EXPECT_FLOAT_EQ(r, 0) << "MoveTowards 0 0 0"; + EXPECT_FLOAT_EQ(r.ToFloat(), 0) << "MoveTowards 0 0 0"; r = Angle::MoveTowards(0, 0, 30); - EXPECT_FLOAT_EQ(r, 0) << "MoveTowards 0 0 30"; + EXPECT_FLOAT_EQ(r.ToFloat(), 0) << "MoveTowards 0 0 30"; if (std::numeric_limits::is_iec559) { r = Angle::MoveTowards(0, 90, FLOAT_INFINITY); - EXPECT_FLOAT_EQ(r, 90) << "MoveTowards 0 90 FLOAT_INFINITY"; + EXPECT_FLOAT_EQ(r.ToFloat(), 90) << "MoveTowards 0 90 FLOAT_INFINITY"; r = Angle::MoveTowards(0, FLOAT_INFINITY, 30); - EXPECT_FLOAT_EQ(r, 30) << "MoveTowards 0 FLOAT_INFINITY 30"; + EXPECT_FLOAT_EQ(r.ToFloat(), 30) << "MoveTowards 0 FLOAT_INFINITY 30"; r = Angle::MoveTowards(0, -90, -FLOAT_INFINITY); - EXPECT_FLOAT_EQ(r, FLOAT_INFINITY) << "MoveTowards 0 -90 -FLOAT_INFINITY"; + EXPECT_FLOAT_EQ(r.ToFloat(), FLOAT_INFINITY) + << "MoveTowards 0 -90 -FLOAT_INFINITY"; r = Angle::MoveTowards(0, -FLOAT_INFINITY, -30); - EXPECT_FLOAT_EQ(r, 30) << "MoveTowards 0 -FLOAT_INFINITY -30"; + EXPECT_FLOAT_EQ(r.ToFloat(), 30) << "MoveTowards 0 -FLOAT_INFINITY -30"; } } diff --git a/test/DiscreteAngle_test.cc b/test/DiscreteAngle_test.cc index bc26450..8576880 100644 --- a/test/DiscreteAngle_test.cc +++ b/test/DiscreteAngle_test.cc @@ -12,53 +12,53 @@ TEST(Angle8, Construct) { float angle = 0.0F; Angle8 a = Angle8(angle); - float f = (float)a; + float f = a.ToFloat(); EXPECT_FLOAT_EQ(f, angle); angle = -180.0F; a = Angle8(angle); - f = (float)a; + f = a.ToFloat(); EXPECT_FLOAT_EQ(f, angle); } TEST(Angle8, Negate) { float angle = 0; Angle8 a = Angle8(angle); - a = -a; - float f = (float)a; + a = -a.ToFloat(); + float f = a.ToFloat(); EXPECT_FLOAT_EQ(f, angle); angle = 90.0F; a = Angle8(angle); - a = -a; - f = (float)a; + a = -a.ToFloat(); + f = a.ToFloat(); EXPECT_FLOAT_EQ(f, -angle); } TEST(Angle8, Add) { Angle8 a = Angle8(0); Angle8 b = Angle8(0.0F); - Angle8 r = a + b; - EXPECT_FLOAT_EQ((float)r, 0); + Angle8 r = a.ToFloat() + b.ToFloat(); + EXPECT_FLOAT_EQ(r.ToFloat(), 0); } TEST(Angle16, Construct) { Angle16 a = Angle16(0.0F); - float f = (float)a; + float f = a.ToFloat(); EXPECT_FLOAT_EQ(f, 0); } TEST(Angle16, Negate) { float angle = 0; Angle16 a = Angle16(angle); - a = -a; - float f = (float)a; + a = -a.ToFloat(); + float f = a.ToFloat(); EXPECT_FLOAT_EQ(f, angle); angle = 90.0F; a = Angle16(angle); - a = -a; - f = (float)a; + a = -a.ToFloat(); + f = a.ToFloat(); EXPECT_FLOAT_EQ(f, -angle); } #endif \ No newline at end of file diff --git a/test/Polar_test.cc b/test/Polar_test.cc index 8dfc18d..c548d0f 100644 --- a/test/Polar_test.cc +++ b/test/Polar_test.cc @@ -1,7 +1,7 @@ #if GTEST #include -#include #include +#include #include "Polar.h" @@ -12,19 +12,19 @@ TEST(Polar, FromVector2) { Polar p = Polar(v); EXPECT_FLOAT_EQ(p.distance, 1.0F) << "p.distance 0 1"; - EXPECT_FLOAT_EQ(p.angle, 0.0F) << "s.angle 0 0 1"; + EXPECT_FLOAT_EQ(p.angle.ToFloat(), 0.0F) << "s.angle 0 0 1"; v = Vector2(1, 0); p = Polar(v); EXPECT_FLOAT_EQ(p.distance, 1.0F) << "p.distance 1 0"; - EXPECT_FLOAT_EQ(p.angle, 90.0F) << "s.angle 1 0"; + EXPECT_FLOAT_EQ(p.angle.ToFloat(), 90.0F) << "s.angle 1 0"; v = Vector2(-1, 1); p = Polar(v); EXPECT_FLOAT_EQ(p.distance, sqrt(2.0F)) << "p.distance -1 1"; - EXPECT_NEAR(p.angle, -45.0F, 1.0e-05) << "s.angle -1 1"; + EXPECT_NEAR(p.angle.ToFloat(), -45.0F, 1.0e-05) << "s.angle -1 1"; } TEST(Polar, FromSpherical) { @@ -35,37 +35,38 @@ TEST(Polar, FromSpherical) { p = Polar(s); EXPECT_FLOAT_EQ(p.distance, 1.0F) << "p.distance FromSpherical(1 0 0)"; - EXPECT_FLOAT_EQ(p.angle, 0.0F) << "p.angle FromSpherical(1 0 0)"; + EXPECT_FLOAT_EQ(p.angle.ToFloat(), 0.0F) << "p.angle FromSpherical(1 0 0)"; s = Spherical(1, 45, 0); p = Polar(s); EXPECT_FLOAT_EQ(p.distance, 1.0F) << "p.distance FromSpherical(1 45 0)"; - EXPECT_FLOAT_EQ(p.angle, 45.0F) << "p.angle FromSpherical(1 45 0)"; + EXPECT_FLOAT_EQ(p.angle.ToFloat(), 45.0F) << "p.angle FromSpherical(1 45 0)"; s = Spherical(1, -45, 0); p = Polar(s); EXPECT_FLOAT_EQ(p.distance, 1.0F) << "p.distance FromSpherical(1 -45 0)"; - EXPECT_FLOAT_EQ(p.angle, -45.0F) << "p.angle FromSpherical(1 -45 0)"; + EXPECT_FLOAT_EQ(p.angle.ToFloat(), -45.0F) + << "p.angle FromSpherical(1 -45 0)"; s = Spherical(0, 0, 0); p = Polar(s); EXPECT_FLOAT_EQ(p.distance, 0.0F) << "p.distance FromSpherical(0 0 0)"; - EXPECT_FLOAT_EQ(p.angle, 0.0F) << "p.angle FromSpherical(0 0 0)"; + EXPECT_FLOAT_EQ(p.angle.ToFloat(), 0.0F) << "p.angle FromSpherical(0 0 0)"; s = Spherical(-1, 0, 0); p = Polar(s); EXPECT_FLOAT_EQ(p.distance, 1.0F) << "p.distance FromSpherical(-1 0 0)"; - EXPECT_FLOAT_EQ(p.angle, 180.0F) << "p.angle FromSpherical(-1 0 0)"; + EXPECT_FLOAT_EQ(p.angle.ToFloat(), 180.0F) << "p.angle FromSpherical(-1 0 0)"; s = Spherical(0, 0, 90); p = Polar(s); EXPECT_FLOAT_EQ(p.distance, 0.0F) << "p.distance FromSpherical(0 0 90)"; - EXPECT_FLOAT_EQ(p.angle, 0.0F) << "p.angle FromSpherical(0 0 90)"; + EXPECT_FLOAT_EQ(p.angle.ToFloat(), 0.0F) << "p.angle FromSpherical(0 0 90)"; } TEST(Polar, Negation) { @@ -74,7 +75,7 @@ TEST(Polar, Negation) { r = -v; EXPECT_FLOAT_EQ(r.distance, 2); - EXPECT_FLOAT_EQ(r.angle, -135); + EXPECT_FLOAT_EQ(r.angle.ToFloat(), -135); EXPECT_TRUE(r == Polar(2, -135)) << "Negate(2 45)"; v = Polar(2, -45); @@ -88,7 +89,7 @@ TEST(Polar, Negation) { v = Polar(0, 0); r = -v; EXPECT_FLOAT_EQ(r.distance, 0.0f); - EXPECT_FLOAT_EQ(r.angle, 0.0f); + EXPECT_FLOAT_EQ(r.angle.ToFloat(), 0.0f); EXPECT_TRUE(r == Polar(0, 0)) << "Negate(0 0)"; } @@ -124,7 +125,7 @@ TEST(Polar, Addition) { v2 = Polar(1, -45); r = v1 + v2; EXPECT_FLOAT_EQ(r.distance, sqrtf(2)) << "Addition(0 0 0)"; - EXPECT_FLOAT_EQ(r.angle, 0) << "Addition(0 0 0)"; + EXPECT_FLOAT_EQ(r.angle.ToFloat(), 0) << "Addition(0 0 0)"; } TEST(Polar, Scale_Multiply) { @@ -133,7 +134,8 @@ TEST(Polar, Scale_Multiply) { r = v1 * 2.0f; EXPECT_FLOAT_EQ(r.distance, v1.distance * 2) << "ScaleMult(4 45, 2)"; - EXPECT_FLOAT_EQ(r.angle, v1.angle) << "ScaleMult(4 45, 2)"; + EXPECT_FLOAT_EQ(r.angle.ToFloat(), v1.angle.ToFloat()) + << "ScaleMult(4 45, 2)"; } TEST(Polar, Scale_Divide) { @@ -142,7 +144,7 @@ TEST(Polar, Scale_Divide) { r = v1 / 2.0f; EXPECT_FLOAT_EQ(r.distance, v1.distance / 2) << "ScaleDiv(4 45, 2)"; - EXPECT_FLOAT_EQ(r.angle, v1.angle) << "ScaleDiv(4 45, 2)"; + EXPECT_FLOAT_EQ(r.angle.ToFloat(), v1.angle.ToFloat()) << "ScaleDiv(4 45, 2)"; } TEST(Polar, Distance) { @@ -164,7 +166,7 @@ TEST(Polar, Rotate) { r = Polar::Rotate(v, 45); EXPECT_FLOAT_EQ(r.distance, v.distance) << "Rotate(4 45, 45)"; - EXPECT_FLOAT_EQ(r.angle, 90.0f) << "Rotate(4 45, 45)"; + EXPECT_FLOAT_EQ(r.angle.ToFloat(), 90.0f) << "Rotate(4 45, 45)"; } #endif \ No newline at end of file diff --git a/test/Spherical16_test.cc b/test/Spherical16_test.cc index 318d845..4f6f5e1 100644 --- a/test/Spherical16_test.cc +++ b/test/Spherical16_test.cc @@ -12,22 +12,22 @@ TEST(Spherical16, FromVector3) { Spherical16 s = Spherical16(v); EXPECT_FLOAT_EQ(s.distance, 1.0F) << "s.distance 0 0 1"; - EXPECT_FLOAT_EQ((float)s.horizontalAngle, 0.0F) << "s.hor 0 0 1"; - EXPECT_FLOAT_EQ((float)s.verticalAngle, 0.0F) << "s.vert 0 0 1"; + EXPECT_FLOAT_EQ((float)s.horizontalAngle.ToFloat(), 0.0F) << "s.hor 0 0 1"; + EXPECT_FLOAT_EQ((float)s.verticalAngle.ToFloat(), 0.0F) << "s.vert 0 0 1"; v = Vector3(0, 1, 0); s = Spherical16(v); EXPECT_FLOAT_EQ(s.distance, 1.0F) << "s.distance 0 1 0"; - EXPECT_FLOAT_EQ(s.horizontalAngle, 0.0F) << "s.hor 0 1 0"; - EXPECT_FLOAT_EQ(s.verticalAngle, 90.0F) << "s.vert 0 1 0"; + EXPECT_FLOAT_EQ(s.horizontalAngle.ToFloat(), 0.0F) << "s.hor 0 1 0"; + EXPECT_FLOAT_EQ(s.verticalAngle.ToFloat(), 90.0F) << "s.vert 0 1 0"; v = Vector3(1, 0, 0); s = Spherical16(v); EXPECT_FLOAT_EQ(s.distance, 1.0F) << "s.distance 1 0 0"; - EXPECT_FLOAT_EQ(s.horizontalAngle, 90.0F) << "s.hor 1 0 0"; - EXPECT_FLOAT_EQ(s.verticalAngle, 0.0F) << "s.vert 1 0 0"; + EXPECT_FLOAT_EQ(s.horizontalAngle.ToFloat(), 90.0F) << "s.hor 1 0 0"; + EXPECT_FLOAT_EQ(s.verticalAngle.ToFloat(), 0.0F) << "s.vert 1 0 0"; } TEST(Spherical16, FromPolar) { @@ -35,36 +35,36 @@ TEST(Spherical16, FromPolar) { Spherical16 s = Spherical16(p); EXPECT_FLOAT_EQ(s.distance, 1.0F) << "s.distance Polar(1 0)"; - EXPECT_FLOAT_EQ(s.horizontalAngle, 0.0F) << "s.hor Polar(1 0)"; - EXPECT_FLOAT_EQ(s.verticalAngle, 0.0F) << "s.vert Polar(1 0)"; + EXPECT_FLOAT_EQ(s.horizontalAngle.ToFloat(), 0.0F) << "s.hor Polar(1 0)"; + EXPECT_FLOAT_EQ(s.verticalAngle.ToFloat(), 0.0F) << "s.vert Polar(1 0)"; p = Polar(1, 45); s = Spherical16(p); EXPECT_FLOAT_EQ(s.distance, 1.0F) << "s.distance Polar(1 45)"; - EXPECT_FLOAT_EQ(s.horizontalAngle, 45.0F) << "s.hor Polar(1 45)"; - EXPECT_FLOAT_EQ(s.verticalAngle, 0.0F) << "s.vert Polar(1 45)"; + EXPECT_FLOAT_EQ(s.horizontalAngle.ToFloat(), 45.0F) << "s.hor Polar(1 45)"; + EXPECT_FLOAT_EQ(s.verticalAngle.ToFloat(), 0.0F) << "s.vert Polar(1 45)"; p = Polar(1, -45); s = Spherical16(p); EXPECT_FLOAT_EQ(s.distance, 1.0F) << "s.distance Polar(1 -45)"; - EXPECT_FLOAT_EQ(s.horizontalAngle, -45.0F) << "s.hor Polar(1 -45)"; - EXPECT_FLOAT_EQ(s.verticalAngle, 0.0F) << "s.vert Polar(1 -45)"; + EXPECT_FLOAT_EQ(s.horizontalAngle.ToFloat(), -45.0F) << "s.hor Polar(1 -45)"; + EXPECT_FLOAT_EQ(s.verticalAngle.ToFloat(), 0.0F) << "s.vert Polar(1 -45)"; p = Polar(0, 0); s = Spherical16(p); EXPECT_FLOAT_EQ(s.distance, 0.0F) << "s.distance Polar(0 0)"; - EXPECT_FLOAT_EQ(s.horizontalAngle, 0.0F) << "s.hor Polar(0 0)"; - EXPECT_FLOAT_EQ(s.verticalAngle, 0.0F) << "s.vert Polar(0 0)"; + EXPECT_FLOAT_EQ(s.horizontalAngle.ToFloat(), 0.0F) << "s.hor Polar(0 0)"; + EXPECT_FLOAT_EQ(s.verticalAngle.ToFloat(), 0.0F) << "s.vert Polar(0 0)"; p = Polar(-1, 0); s = Spherical16(p); EXPECT_FLOAT_EQ(s.distance, 1.0F) << "s.distance Polar(-1 0)"; - EXPECT_FLOAT_EQ(s.horizontalAngle, -180.0F) << "s.hor Polar(-1 0)"; - EXPECT_FLOAT_EQ(s.verticalAngle, 0.0F) << "s.vert Polar(-1 0)"; + EXPECT_FLOAT_EQ(s.horizontalAngle.ToFloat(), -180.0F) << "s.hor Polar(-1 0)"; + EXPECT_FLOAT_EQ(s.verticalAngle.ToFloat(), 0.0F) << "s.vert Polar(-1 0)"; } TEST(Spherical16, Incident1) { @@ -73,11 +73,12 @@ TEST(Spherical16, Incident1) { Spherical16 sr = Spherical16(2.49F, 98.18f, 24.4F); EXPECT_NEAR(s.distance, sr.distance, 1.0e-01); - EXPECT_NEAR(s.horizontalAngle, sr.horizontalAngle, 1.0e-02); - EXPECT_NEAR(s.verticalAngle, sr.verticalAngle, 1.0e-02); + EXPECT_NEAR(s.horizontalAngle.ToFloat(), sr.horizontalAngle.ToFloat(), + 1.0e-02); + EXPECT_NEAR(s.verticalAngle.ToFloat(), sr.verticalAngle.ToFloat(), 1.0e-02); - Vector3 r = Vector3(Spherical(sr.distance, (Angle)sr.horizontalAngle, - (Angle)sr.verticalAngle)); + Vector3 r = Vector3(Spherical(sr.distance, sr.horizontalAngle.ToFloat(), + sr.verticalAngle.ToFloat())); EXPECT_NEAR(r.Right(), v.Right(), 1.0e-02) << "toVector3.x 1 0 0"; EXPECT_NEAR(r.Up(), v.Up(), 1.0e-02) << "toVector3.y 1 0 0"; EXPECT_NEAR(r.Forward(), v.Forward(), 1.0e-02) << "toVector3.z 1 0 0"; @@ -89,11 +90,12 @@ TEST(Spherical16, Incident2) { Spherical16 sr = Spherical16(1.4142135623F, 45.0f, 0.0F); EXPECT_NEAR(s.distance, sr.distance, 1.0e-05); - EXPECT_NEAR(s.horizontalAngle, sr.horizontalAngle, 1.0e-05); - EXPECT_NEAR(s.verticalAngle, sr.verticalAngle, 1.0e-05); + EXPECT_NEAR(s.horizontalAngle.ToFloat(), sr.horizontalAngle.ToFloat(), + 1.0e-05); + EXPECT_NEAR(s.verticalAngle.ToFloat(), sr.verticalAngle.ToFloat(), 1.0e-05); - Vector3 r = Vector3(Spherical(sr.distance, (Angle)sr.horizontalAngle, - (Angle)sr.verticalAngle)); + Vector3 r = Vector3(Spherical(sr.distance, sr.horizontalAngle.ToFloat(), + sr.verticalAngle.ToFloat())); EXPECT_NEAR(r.Right(), v.Right(), 1.0e-06); EXPECT_NEAR(r.Up(), v.Up(), 1.0e-06); EXPECT_NEAR(r.Forward(), v.Forward(), 1.0e-06); @@ -103,23 +105,24 @@ TEST(Spherical16, Incident2) { sr = Spherical16(1.4142135623F, 0.0f, 45.0F); EXPECT_NEAR(s.distance, sr.distance, 1.0e-05); - EXPECT_NEAR(s.horizontalAngle, sr.horizontalAngle, 1.0e-05); - EXPECT_NEAR(s.verticalAngle, sr.verticalAngle, 1.0e-05); + EXPECT_NEAR(s.horizontalAngle.ToFloat(), sr.horizontalAngle.ToFloat(), + 1.0e-05); + EXPECT_NEAR(s.verticalAngle.ToFloat(), sr.verticalAngle.ToFloat(), 1.0e-05); - r = Vector3(Spherical(sr.distance, (Angle)sr.horizontalAngle, - (Angle)sr.verticalAngle)); + r = Vector3(Spherical(sr.distance, sr.horizontalAngle.ToFloat(), + sr.verticalAngle.ToFloat())); EXPECT_NEAR(r.Right(), v.Right(), 1.0e-06); EXPECT_NEAR(r.Up(), v.Up(), 1.0e-06); EXPECT_NEAR(r.Forward(), v.Forward(), 1.0e-06); v = Vector3(1.0f, 1.0f, 1.0f); s = Spherical16(v); - r = Vector3( - Spherical(s.distance, (Angle)s.horizontalAngle, (Angle)s.verticalAngle)); + r = Vector3(Spherical(s.distance, s.horizontalAngle.ToFloat(), + s.verticalAngle.ToFloat())); EXPECT_NEAR(s.distance, 1.73205080F, 1.0e-02); - EXPECT_NEAR(s.horizontalAngle, 45.0F, 1.0e-02); - EXPECT_NEAR(s.verticalAngle, 35.26F, 1.0e-02); + EXPECT_NEAR(s.horizontalAngle.ToFloat(), 45.0F, 1.0e-02); + EXPECT_NEAR(s.verticalAngle.ToFloat(), 35.26F, 1.0e-02); EXPECT_NEAR(r.Right(), v.Right(), 1.0e-04); EXPECT_NEAR(r.Up(), v.Up(), 1.0e-04); @@ -147,14 +150,14 @@ TEST(Spherical16, Addition) { v2 = Spherical16(1, -45, 0); r = v1 + v2; EXPECT_FLOAT_EQ(r.distance, sqrtf(2)) << "Addition(1 -45 0)"; - EXPECT_FLOAT_EQ(r.horizontalAngle, 0) << "Addition(1 -45 0)"; - EXPECT_FLOAT_EQ(r.verticalAngle, 0) << "Addition(1 -45 0)"; + EXPECT_FLOAT_EQ(r.horizontalAngle.ToFloat(), 0) << "Addition(1 -45 0)"; + EXPECT_FLOAT_EQ(r.verticalAngle.ToFloat(), 0) << "Addition(1 -45 0)"; v2 = Spherical16(1, 0, 90); r = v1 + v2; EXPECT_FLOAT_EQ(r.distance, sqrtf(2)) << "Addition(1 0 90)"; - EXPECT_FLOAT_EQ(r.horizontalAngle, 45) << "Addition(1 0 90)"; - EXPECT_FLOAT_EQ(r.verticalAngle, 45) << "Addition(1 0 90)"; + EXPECT_FLOAT_EQ(r.horizontalAngle.ToFloat(), 45) << "Addition(1 0 90)"; + EXPECT_FLOAT_EQ(r.verticalAngle.ToFloat(), 45) << "Addition(1 0 90)"; } #endif \ No newline at end of file diff --git a/test/Spherical_test.cc b/test/Spherical_test.cc index 0ffae7f..9d963aa 100644 --- a/test/Spherical_test.cc +++ b/test/Spherical_test.cc @@ -1,7 +1,7 @@ #if GTEST #include -#include #include +#include #include "Spherical.h" @@ -12,22 +12,22 @@ TEST(Spherical, FromVector3) { Spherical s = Spherical(v); EXPECT_FLOAT_EQ(s.distance, 1.0F) << "s.distance 0 0 1"; - EXPECT_FLOAT_EQ(s.horizontalAngle, 0.0F) << "s.hor 0 0 1"; - EXPECT_FLOAT_EQ(s.verticalAngle, 0.0F) << "s.vert 0 0 1"; + EXPECT_FLOAT_EQ(s.horizontalAngle.ToFloat(), 0.0F) << "s.hor 0 0 1"; + EXPECT_FLOAT_EQ(s.verticalAngle.ToFloat(), 0.0F) << "s.vert 0 0 1"; v = Vector3(0, 1, 0); s = Spherical(v); EXPECT_FLOAT_EQ(s.distance, 1.0F) << "s.distance 0 1 0"; - EXPECT_FLOAT_EQ(s.horizontalAngle, 0.0F) << "s.hor 0 1 0"; - EXPECT_FLOAT_EQ(s.verticalAngle, 90.0F) << "s.vert 0 1 0"; + EXPECT_FLOAT_EQ(s.horizontalAngle.ToFloat(), 0.0F) << "s.hor 0 1 0"; + EXPECT_FLOAT_EQ(s.verticalAngle.ToFloat(), 90.0F) << "s.vert 0 1 0"; v = Vector3(1, 0, 0); s = Spherical(v); EXPECT_FLOAT_EQ(s.distance, 1.0F) << "s.distance 1 0 0"; - EXPECT_FLOAT_EQ(s.horizontalAngle, 90.0F) << "s.hor 1 0 0"; - EXPECT_FLOAT_EQ(s.verticalAngle, 0.0F) << "s.vert 1 0 0"; + EXPECT_FLOAT_EQ(s.horizontalAngle.ToFloat(), 90.0F) << "s.hor 1 0 0"; + EXPECT_FLOAT_EQ(s.verticalAngle.ToFloat(), 0.0F) << "s.vert 1 0 0"; } TEST(Spherical, FromPolar) { @@ -35,36 +35,36 @@ TEST(Spherical, FromPolar) { Spherical s = Spherical(p); EXPECT_FLOAT_EQ(s.distance, 1.0F) << "s.distance Polar(1 0)"; - EXPECT_FLOAT_EQ(s.horizontalAngle, 0.0F) << "s.hor Polar(1 0)"; - EXPECT_FLOAT_EQ(s.verticalAngle, 0.0F) << "s.vert Polar(1 0)"; + EXPECT_FLOAT_EQ(s.horizontalAngle.ToFloat(), 0.0F) << "s.hor Polar(1 0)"; + EXPECT_FLOAT_EQ(s.verticalAngle.ToFloat(), 0.0F) << "s.vert Polar(1 0)"; p = Polar(1, 45); s = Spherical(p); EXPECT_FLOAT_EQ(s.distance, 1.0F) << "s.distance Polar(1 45)"; - EXPECT_FLOAT_EQ(s.horizontalAngle, 45.0F) << "s.hor Polar(1 45)"; - EXPECT_FLOAT_EQ(s.verticalAngle, 0.0F) << "s.vert Polar(1 45)"; + EXPECT_FLOAT_EQ(s.horizontalAngle.ToFloat(), 45.0F) << "s.hor Polar(1 45)"; + EXPECT_FLOAT_EQ(s.verticalAngle.ToFloat(), 0.0F) << "s.vert Polar(1 45)"; p = Polar(1, -45); s = Spherical(p); EXPECT_FLOAT_EQ(s.distance, 1.0F) << "s.distance Polar(1 -45)"; - EXPECT_FLOAT_EQ(s.horizontalAngle, -45.0F) << "s.hor Polar(1 -45)"; - EXPECT_FLOAT_EQ(s.verticalAngle, 0.0F) << "s.vert Polar(1 -45)"; + EXPECT_FLOAT_EQ(s.horizontalAngle.ToFloat(), -45.0F) << "s.hor Polar(1 -45)"; + EXPECT_FLOAT_EQ(s.verticalAngle.ToFloat(), 0.0F) << "s.vert Polar(1 -45)"; p = Polar(0, 0); s = Spherical(p); EXPECT_FLOAT_EQ(s.distance, 0.0F) << "s.distance Polar(0 0)"; - EXPECT_FLOAT_EQ(s.horizontalAngle, 0.0F) << "s.hor Polar(0 0)"; - EXPECT_FLOAT_EQ(s.verticalAngle, 0.0F) << "s.vert Polar(0 0)"; + EXPECT_FLOAT_EQ(s.horizontalAngle.ToFloat(), 0.0F) << "s.hor Polar(0 0)"; + EXPECT_FLOAT_EQ(s.verticalAngle.ToFloat(), 0.0F) << "s.vert Polar(0 0)"; p = Polar(-1, 0); s = Spherical(p); EXPECT_FLOAT_EQ(s.distance, 1.0F) << "s.distance Polar(-1 0)"; - EXPECT_FLOAT_EQ(s.horizontalAngle, 180.0F) << "s.hor Polar(-1 0)"; - EXPECT_FLOAT_EQ(s.verticalAngle, 0.0F) << "s.vert Polar(-1 0)"; + EXPECT_FLOAT_EQ(s.horizontalAngle.ToFloat(), 180.0F) << "s.hor Polar(-1 0)"; + EXPECT_FLOAT_EQ(s.verticalAngle.ToFloat(), 0.0F) << "s.vert Polar(-1 0)"; } TEST(Spherical, Incident1) { @@ -73,8 +73,9 @@ TEST(Spherical, Incident1) { Spherical sr = Spherical(2.49F, 98.18f, 24.4F); EXPECT_NEAR(s.distance, sr.distance, 1.0e-01); - EXPECT_NEAR(s.horizontalAngle, sr.horizontalAngle, 1.0e-02); - EXPECT_NEAR(s.verticalAngle, sr.verticalAngle, 1.0e-02); + EXPECT_NEAR(s.horizontalAngle.ToFloat(), sr.horizontalAngle.ToFloat(), + 1.0e-02); + EXPECT_NEAR(s.verticalAngle.ToFloat(), sr.verticalAngle.ToFloat(), 1.0e-02); Vector3 r = Vector3(sr); EXPECT_NEAR(r.Right(), v.Right(), 1.0e-02) << "toVector3.x 1 0 0"; @@ -88,8 +89,9 @@ TEST(Spherical, Incident2) { Spherical sr = Spherical(1.4142135623F, 45.0f, 0.0F); EXPECT_NEAR(s.distance, sr.distance, 1.0e-05); - EXPECT_NEAR(s.horizontalAngle, sr.horizontalAngle, 1.0e-05); - EXPECT_NEAR(s.verticalAngle, sr.verticalAngle, 1.0e-05); + EXPECT_NEAR(s.horizontalAngle.ToFloat(), sr.horizontalAngle.ToFloat(), + 1.0e-05); + EXPECT_NEAR(s.verticalAngle.ToFloat(), sr.verticalAngle.ToFloat(), 1.0e-05); Vector3 r = Vector3(sr); EXPECT_NEAR(r.Right(), v.Right(), 1.0e-06); @@ -101,8 +103,9 @@ TEST(Spherical, Incident2) { sr = Spherical(1.4142135623F, 0.0f, 45.0F); EXPECT_NEAR(s.distance, sr.distance, 1.0e-05); - EXPECT_NEAR(s.horizontalAngle, sr.horizontalAngle, 1.0e-05); - EXPECT_NEAR(s.verticalAngle, sr.verticalAngle, 1.0e-05); + EXPECT_NEAR(s.horizontalAngle.ToFloat(), sr.horizontalAngle.ToFloat(), + 1.0e-05); + EXPECT_NEAR(s.verticalAngle.ToFloat(), sr.verticalAngle.ToFloat(), 1.0e-05); r = Vector3(sr); EXPECT_NEAR(r.Right(), v.Right(), 1.0e-06); @@ -114,8 +117,8 @@ TEST(Spherical, Incident2) { r = Vector3(s); EXPECT_NEAR(s.distance, 1.73205080F, 1.0e-02); - EXPECT_NEAR(s.horizontalAngle, 45.0F, 1.0e-02); - EXPECT_NEAR(s.verticalAngle, 35.26F, 1.0e-02); + EXPECT_NEAR(s.horizontalAngle.ToFloat(), 45.0F, 1.0e-02); + EXPECT_NEAR(s.verticalAngle.ToFloat(), 35.26F, 1.0e-02); EXPECT_NEAR(r.Right(), v.Right(), 1.0e-06); EXPECT_NEAR(r.Up(), v.Up(), 1.0e-06); @@ -143,14 +146,14 @@ TEST(Spherical, Addition) { v2 = Spherical(1, -45, 0); r = v1 + v2; EXPECT_FLOAT_EQ(r.distance, sqrtf(2)) << "Addition(1 -45 0)"; - EXPECT_FLOAT_EQ(r.horizontalAngle, 0) << "Addition(1 -45 0)"; - EXPECT_FLOAT_EQ(r.verticalAngle, 0) << "Addition(1 -45 0)"; + EXPECT_FLOAT_EQ(r.horizontalAngle.ToFloat(), 0) << "Addition(1 -45 0)"; + EXPECT_FLOAT_EQ(r.verticalAngle.ToFloat(), 0) << "Addition(1 -45 0)"; v2 = Spherical(1, 0, 90); r = v1 + v2; EXPECT_FLOAT_EQ(r.distance, sqrtf(2)) << "Addition(1 0 90)"; - EXPECT_FLOAT_EQ(r.horizontalAngle, 45) << "Addition(1 0 90)"; - EXPECT_FLOAT_EQ(r.verticalAngle, 45) << "Addition(1 0 90)"; + EXPECT_FLOAT_EQ(r.horizontalAngle.ToFloat(), 45) << "Addition(1 0 90)"; + EXPECT_FLOAT_EQ(r.verticalAngle.ToFloat(), 45) << "Addition(1 0 90)"; } #endif \ No newline at end of file