LinearAlgebra/LinearAlgebra-cpp
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Make Angle -> float conversion explicit

Browse Source
This commit is contained in:
Pascal Serrarens 2024-08-05 10:03:42 +02:00
parent 608c45c1a7
commit 49c67405fc
15 changed files with 283 additions and 227 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

44
Angle.cpp
View File

@ -74,32 +74,37 @@ float Angle::SineRuleAngle(float a, float beta, float b) {
//---------------------- //----------------------
template <> template <>
AngleOf<float>::AngleOf(int angle) : value(angle) {} AngleOf<float>::AngleOf(int angle) : value((float)angle) {}
template <> template <>
AngleOf<float>::AngleOf(float angle) : value(angle) {} AngleOf<float>::AngleOf(float angle) : value(angle) {}
// template <>
// AngleOf<float>::operator float() const {
// return value;
// }
template <> template <>
AngleOf<float>::operator float() const { float AngleOf<float>::ToFloat() const {
return value; return value;
} }
template <> // template <>
AngleOf<float> AngleOf<float>::pi = 3.1415927410125732421875F; // AngleOf<float> AngleOf<float>::pi = 3.1415927410125732421875F;
template <> // template <>
AngleOf<float> AngleOf<float>::Rad2Deg = 360.0f / (pi * 2); // AngleOf<float> AngleOf<float>::Rad2Deg = 360.0f / (pi * 2);
template <> // template <>
AngleOf<float> AngleOf<float>::Deg2Rad = (pi * 2) / 360.0f; // AngleOf<float> AngleOf<float>::Deg2Rad = (pi * 2) / 360.0f;
template <> template <>
bool Passer::LinearAlgebra::AngleOf<float>::operator==(AngleOf<float> a) { bool Passer::LinearAlgebra::AngleOf<float>::operator==(AngleOf<float> a) {
return (float)*this == (float)a; return this->ToFloat() == a.ToFloat();
} }
template <> template <>
AngleOf<float> AngleOf<float>::Normalize(AngleOf<float> angle) { AngleOf<float> AngleOf<float>::Normalize(AngleOf<float> angle) {
float angleValue = angle; float angleValue = angle.ToFloat();
if (!isfinite(angleValue)) if (!isfinite(angleValue))
return angleValue; return angleValue;
@ -114,8 +119,8 @@ template <>
AngleOf<float> AngleOf<float>::Clamp(AngleOf<float> angle, AngleOf<float> AngleOf<float>::Clamp(AngleOf<float> angle,
AngleOf<float> min, AngleOf<float> min,
AngleOf<float> max) { AngleOf<float> max) {
float normalizedAngle = Normalize(angle); float normalizedAngle = Normalize(angle).ToFloat();
float r = Float::Clamp(normalizedAngle, min, max); float r = Float::Clamp(normalizedAngle, min.ToFloat(), max.ToFloat());
return r; return r;
} }
@ -129,10 +134,10 @@ template <>
AngleOf<float> AngleOf<float>::MoveTowards(AngleOf<float> fromAngle, AngleOf<float> AngleOf<float>::MoveTowards(AngleOf<float> fromAngle,
AngleOf<float> toAngle, AngleOf<float> toAngle,
AngleOf<float> maxAngle) { AngleOf<float> maxAngle) {
float d = toAngle - fromAngle; float d = toAngle.ToFloat() - fromAngle.ToFloat();
int sign = signbit(d) ? -1 : 1; int sign = signbit(d) ? -1 : 1;
d = sign * Float::Clamp(fabsf(d), 0, maxAngle); d = sign * Float::Clamp(fabsf(d), 0, maxAngle.ToFloat());
return fromAngle + d; return fromAngle.ToFloat() + d;
} }
template <> template <>
@ -141,7 +146,8 @@ AngleOf<float> AngleOf<float>::CosineRuleSide(float a,
AngleOf<float> gamma) { AngleOf<float> gamma) {
float a2 = a * a; float a2 = a * a;
float b2 = b * b; float b2 = b * b;
float d = a2 + b2 - 2 * a * b * cos(gamma * AngleOf<float>::Deg2Rad); float d = a2 + b2 -
2 * a * b * cosf(gamma.ToFloat() * Passer::LinearAlgebra::Deg2Rad);
// Catch edge cases where float inacuracies lead tot nans // Catch edge cases where float inacuracies lead tot nans
if (d < 0) if (d < 0)
return 0.0f; return 0.0f;
@ -162,7 +168,8 @@ AngleOf<float> AngleOf<float>::CosineRuleAngle(float a, float b, float c) {
if (d <= -1) if (d <= -1)
return 180.0f; return 180.0f;
float gamma = acos(d) * Angle::Rad2Deg; float rad2deg = Passer::LinearAlgebra::Rad2Deg;
float gamma = acosf(d) * rad2deg;
return gamma; return gamma;
} }
@ -170,6 +177,7 @@ template <>
AngleOf<float> AngleOf<float>::SineRuleAngle(float a, AngleOf<float> AngleOf<float>::SineRuleAngle(float a,
AngleOf<float> beta, AngleOf<float> beta,
float b) { 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; return alpha;
} }

11
Angle.h
View File

@ -8,13 +8,20 @@
namespace Passer { namespace Passer {
namespace LinearAlgebra { namespace LinearAlgebra {
static float pi = 3.1415927410125732421875F;
static float Rad2Deg = 360.0f / (pi * 2);
static float Deg2Rad = (pi * 2) / 360.0f;
template <typename T> template <typename T>
class AngleOf { class AngleOf {
public: public:
AngleOf() {}; AngleOf() {};
AngleOf(int f); AngleOf(int f);
AngleOf(float f); AngleOf(float f);
operator float() const; // operator float() const;
float ToFloat() const;
inline T GetBinary() const { return this->value; } inline T GetBinary() const { return this->value; }
@ -28,7 +35,7 @@ class AngleOf {
static AngleOf<T> Normalize(AngleOf<T> a); static AngleOf<T> Normalize(AngleOf<T> a);
static AngleOf<T> Clamp(AngleOf<T> a, AngleOf<T> min, AngleOf<T> max); static AngleOf<T> Clamp(AngleOf<T> a, AngleOf<T> min, AngleOf<T> max);
static AngleOf<T> Difference(AngleOf<T> a, AngleOf<T> b) { static AngleOf<T> Difference(AngleOf<T> a, AngleOf<T> b) {
AngleOf<T> r = Normalize(b - a); AngleOf<T> r = Normalize(b.ToFloat() - a.ToFloat());
return r; return r;
}; };
static AngleOf<T> MoveTowards(AngleOf<T> fromAngle, static AngleOf<T> MoveTowards(AngleOf<T> fromAngle,

13
Angle16.cpp
View File

@ -23,8 +23,14 @@ AngleOf<signed short>::AngleOf(float angle) {
this->value = (signed short)(angle / 360.0F * 65536.0F); this->value = (signed short)(angle / 360.0F * 65536.0F);
} }
// template <>
// AngleOf<signed short>::operator float() const {
// float f = ((this->value * 180) / 32768.0F);
// return f;
// }
template <> template <>
AngleOf<signed short>::operator float() const { float AngleOf<signed short>::ToFloat() const {
float f = ((this->value * 180) / 32768.0F); float f = ((this->value * 180) / 32768.0F);
return f; return f;
} }
@ -37,7 +43,8 @@ AngleOf<signed short> AngleOf<signed short>::CosineRuleSide(
AngleOf<signed short> gamma) { AngleOf<signed short> gamma) {
float a2 = a * a; float a2 = a * a;
float b2 = b * b; float b2 = b * b;
float d = a2 + b2 - 2 * a * b * cosf(gamma * AngleOf<float>::Deg2Rad); float d = a2 + b2 -
2 * a * b * cosf(gamma.ToFloat() * Passer::LinearAlgebra::Deg2Rad);
// Catch edge cases where float inacuracies lead tot nans // Catch edge cases where float inacuracies lead tot nans
if (d < 0) if (d < 0)
return 0.0f; return 0.0f;
@ -61,6 +68,6 @@ AngleOf<signed short> AngleOf<signed short>::CosineRuleAngle(float a,
if (d <= -1) if (d <= -1)
return 180.0f; return 180.0f;
float gamma = acosf(d) * Angle::Rad2Deg; float gamma = acosf(d) * Passer::LinearAlgebra::Rad2Deg;
return gamma; return gamma;
} }

8
Angle8.cpp
View File

@ -23,8 +23,14 @@ AngleOf<signed char>::AngleOf(float angle) {
this->value = (signed char)(f * 256.0F); this->value = (signed char)(f * 256.0F);
} }
// template <>
// AngleOf<signed char>::operator float() const {
// float f = (this->value * 180) / 128.0F;
// return f;
// }
template <> template <>
AngleOf<signed char>::operator float() const { float AngleOf<signed char>::ToFloat() const {
float f = (this->value * 180) / 128.0F; float f = (this->value * 180) / 128.0F;
return f; return f;
} }

9
Axis.cpp
View File

@ -20,8 +20,9 @@ Axis::Axis(Angle horizontal, Angle vertical) {
}; };
Axis::Axis(Vector3 v) { Axis::Axis(Vector3 v) {
this->horizontalAngle = atan2f(v.Right(), v.Forward()) * Angle::Rad2Deg; this->horizontalAngle =
this->verticalAngle = 90 - acosf(v.Up()) * Angle::Rad2Deg; 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); 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); const Axis Axis::right = Axis(90.0f, 0.0f);
Vector3 Axis::ToVector3() { Vector3 Axis::ToVector3() {
Vector3 v = Vector3 v = Quaternion::Euler(-(this->verticalAngle.ToFloat()),
Quaternion::Euler(-this->verticalAngle, this->horizontalAngle, 0) * this->horizontalAngle.ToFloat(), 0) *
Vector3::forward; Vector3::forward;
return v; return v;
} }

29
Polar.cpp
View File

@ -12,7 +12,7 @@ Polar::Polar(float distance, Angle angle) {
// distance should always be 0 or greater // distance should always be 0 or greater
if (distance < 0.0f) { if (distance < 0.0f) {
this->distance = -distance; this->distance = -distance;
this->angle = Angle::Normalize(angle - 180); this->angle = Angle::Normalize(angle.ToFloat() - 180.0f);
} else { } else {
this->distance = distance; this->distance = distance;
if (this->distance == 0.0f) if (this->distance == 0.0f)
@ -27,7 +27,8 @@ Polar::Polar(Vector2 v) {
this->angle = Vector2::SignedAngle(Vector2::forward, v); this->angle = Vector2::SignedAngle(Vector2::forward, v);
} }
Polar::Polar(Spherical 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; 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); const Polar Polar::left = Polar(1.0, -90.0f);
bool Polar::operator==(const Polar& v) const { 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) { Polar Polar::Normalize(const Polar& v) {
@ -51,7 +53,7 @@ Polar Polar::normalized() const {
} }
Polar Polar::operator-() 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; return v;
} }
@ -69,7 +71,8 @@ Polar Polar::operator+(const Polar& v) const {
if (this->distance == 0.0f) if (this->distance == 0.0f)
return v; return v;
float deltaAngle = Angle::Normalize(v.angle - (float)this->angle); float deltaAngle =
Angle::Normalize(v.angle.ToFloat() - this->angle.ToFloat()).ToFloat();
float rotation = float rotation =
deltaAngle < 0.0f ? 180.0f + deltaAngle : 180.0f - deltaAngle; deltaAngle < 0.0f ? 180.0f + deltaAngle : 180.0f - deltaAngle;
@ -79,13 +82,14 @@ Polar Polar::operator+(const Polar& v) const {
} }
float newDistance = 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 newAngle = deltaAngle < 0.0f ? this->angle.ToFloat() - angle
: (float)this->angle + angle; : this->angle.ToFloat() + angle;
newAngle = Angle::Normalize(newAngle); newAngle = Angle::Normalize(newAngle).ToFloat();
Polar vector = Polar(newDistance, newAngle); Polar vector = Polar(newDistance, newAngle);
return vector; return vector;
} }
@ -117,12 +121,13 @@ Polar Polar::operator/=(float f) {
float Polar::Distance(const Polar& v1, const Polar& v2) { float Polar::Distance(const Polar& v1, const Polar& v2) {
float d = Angle::CosineRuleSide(v1.distance, v2.distance, float d = Angle::CosineRuleSide(v1.distance, v2.distance,
(float)v2.angle - (float)v1.angle); v2.angle.ToFloat() - v1.angle.ToFloat())
.ToFloat();
return d; return d;
} }
Polar Polar::Rotate(const Polar& v, Angle angle) { 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); Polar r = Polar(v.distance, a);
return r; return r;
} }

30
Spherical.cpp
View File

@ -22,7 +22,8 @@ Spherical::Spherical(float distance,
Angle verticalAngle) { Angle verticalAngle) {
if (distance < 0) { if (distance < 0) {
this->distance = -distance; this->distance = -distance;
this->horizontalAngle = Angle::Normalize(horizontalAngle - 180); this->horizontalAngle =
Angle::Normalize(horizontalAngle.ToFloat() - 180.0f);
this->verticalAngle = verticalAngle; this->verticalAngle = verticalAngle;
} else { } else {
this->distance = distance; this->distance = distance;
@ -37,9 +38,10 @@ Spherical::Spherical(Vector3 v) {
this->verticalAngle = 0.0f; this->verticalAngle = 0.0f;
this->horizontalAngle = 0.0f; this->horizontalAngle = 0.0f;
} else { } else {
this->verticalAngle = this->verticalAngle = (90.0f - acosf(v.Up() / this->distance) *
(90.0f - acosf(v.Up() / this->distance) * Angle::Rad2Deg); Passer::LinearAlgebra::Rad2Deg);
this->horizontalAngle = atan2f(v.Right(), v.Forward()) * Angle::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 { bool Spherical::operator==(const Spherical& v) const {
return (this->distance == v.distance && return (this->distance == v.distance &&
this->horizontalAngle == v.horizontalAngle && this->horizontalAngle.ToFloat() == v.horizontalAngle.ToFloat() &&
this->verticalAngle == v.verticalAngle); this->verticalAngle.ToFloat() == v.verticalAngle.ToFloat());
} }
Spherical Spherical::Normalize(const Spherical& v) { Spherical Spherical::Normalize(const Spherical& v) {
@ -67,8 +69,9 @@ Spherical Spherical::normalized() const {
} }
Spherical Spherical::operator-() const { Spherical Spherical::operator-() const {
Spherical v = Spherical(this->distance, this->horizontalAngle + 180.0f, Spherical v =
this->verticalAngle + 180.0f); Spherical(this->distance, this->horizontalAngle.ToFloat() + 180.0f,
this->verticalAngle.ToFloat() + 180.0f);
return v; return v;
} }
@ -207,15 +210,18 @@ Angle Spherical::AngleBetween(const Spherical& v1, const Spherical& v2) {
Spherical Spherical::Rotate(const Spherical& v, Spherical Spherical::Rotate(const Spherical& v,
Angle horizontalAngle, Angle horizontalAngle,
Angle verticalAngle) { Angle verticalAngle) {
Spherical r = Spherical(v.distance, v.horizontalAngle + horizontalAngle, Spherical r = Spherical(
v.verticalAngle + verticalAngle); v.distance, v.horizontalAngle.ToFloat() + horizontalAngle.ToFloat(),
v.verticalAngle.ToFloat() + verticalAngle.ToFloat());
return r; return r;
} }
Spherical Spherical::RotateHorizontal(const Spherical& v, Angle a) { 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; return r;
} }
Spherical Spherical::RotateVertical(const Spherical& v, Angle a) { 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; return r;
} }

59
Spherical16.cpp
View File

@ -13,7 +13,7 @@ Spherical16::Spherical16() {
Spherical16::Spherical16(Polar polar) { Spherical16::Spherical16(Polar polar) {
this->distance = polar.distance; this->distance = polar.distance;
this->horizontalAngle = Angle16(polar.angle); this->horizontalAngle = Angle16(polar.angle.ToFloat());
this->verticalAngle = Angle16(0); this->verticalAngle = Angle16(0);
} }
@ -22,7 +22,7 @@ Spherical16::Spherical16(float distance,
Angle16 verticalAngle) { Angle16 verticalAngle) {
if (distance < 0) { if (distance < 0) {
this->distance = -distance; this->distance = -distance;
this->horizontalAngle = horizontalAngle - Angle16(180); this->horizontalAngle = horizontalAngle.ToFloat() - Angle16(180).ToFloat();
this->verticalAngle = verticalAngle; this->verticalAngle = verticalAngle;
} else { } else {
this->distance = distance; this->distance = distance;
@ -37,9 +37,10 @@ Spherical16::Spherical16(Vector3 v) {
this->verticalAngle = 0.0f; this->verticalAngle = 0.0f;
this->horizontalAngle = 0.0f; this->horizontalAngle = 0.0f;
} else { } else {
this->verticalAngle = this->verticalAngle = (90.0f - acosf(v.Up() / this->distance) *
(90.0f - acosf(v.Up() / this->distance) * Angle::Rad2Deg); Passer::LinearAlgebra::Rad2Deg);
this->horizontalAngle = atan2f(v.Right(), v.Forward()) * Angle::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 { bool Spherical16::operator==(const Spherical16& v) const {
return (this->distance == v.distance && return (this->distance == v.distance &&
this->horizontalAngle == v.horizontalAngle && this->horizontalAngle.ToFloat() == v.horizontalAngle.ToFloat() &&
this->verticalAngle == v.verticalAngle); this->verticalAngle.ToFloat() == v.verticalAngle.ToFloat());
} }
Spherical16 Spherical16::Normalize(const Spherical16& v) { Spherical16 Spherical16::Normalize(const Spherical16& v) {
@ -67,16 +68,18 @@ Spherical16 Spherical16::normalized() const {
} }
Spherical16 Spherical16::operator-() const { Spherical16 Spherical16::operator-() const {
Spherical16 v = Spherical16(this->distance, this->horizontalAngle + 180.0f, Spherical16 v =
this->verticalAngle + 180.0f); Spherical16(this->distance, this->horizontalAngle.ToFloat() + 180.0f,
this->verticalAngle.ToFloat() + 180.0f);
return v; return v;
} }
Spherical16 Spherical16::operator-(const Spherical16& s2) const { Spherical16 Spherical16::operator-(const Spherical16& s2) const {
Spherical thisSpherical = Spherical( Spherical thisSpherical =
this->distance, (Angle)this->horizontalAngle, (Angle)this->verticalAngle); Spherical(this->distance, this->horizontalAngle.ToFloat(),
Spherical spherical2 = Spherical(s2.distance, (Angle)s2.horizontalAngle, this->verticalAngle.ToFloat());
(Angle)s2.verticalAngle); Spherical spherical2 = Spherical(s2.distance, s2.horizontalAngle.ToFloat(),
s2.verticalAngle.ToFloat());
// let's do it the easy way... // let's do it the easy way...
Vector3 v1 = Vector3(thisSpherical); Vector3 v1 = Vector3(thisSpherical);
@ -92,10 +95,11 @@ Spherical16 Spherical16::operator-=(const Spherical16& v) {
Spherical16 Spherical16::operator+(const Spherical16& s2) const { Spherical16 Spherical16::operator+(const Spherical16& s2) const {
// let's do it the easy way... // let's do it the easy way...
Vector3 v1 = Vector3(Spherical(this->distance, (float)this->horizontalAngle, Vector3 v1 =
(float)this->verticalAngle)); Vector3(Spherical(this->distance, this->horizontalAngle.ToFloat(),
Vector3 v2 = Vector3(Spherical(s2.distance, (float)s2.horizontalAngle, this->verticalAngle.ToFloat()));
(float)s2.verticalAngle)); Vector3 v2 = Vector3(Spherical(s2.distance, s2.horizontalAngle.ToFloat(),
s2.verticalAngle.ToFloat()));
Vector3 v = v1 + v2; Vector3 v = v1 + v2;
Spherical16 r = Spherical16(v); Spherical16 r = Spherical16(v);
return r; return r;
@ -199,10 +203,10 @@ Angle Spherical16::AngleBetween(const Spherical16& v1, const Spherical16& v2) {
if (denominator < epsilon) if (denominator < epsilon)
return 0.0f; return 0.0f;
Vector3 v1_3 = Vector3(Spherical(v1.distance, (Angle)v1.horizontalAngle, Vector3 v1_3 = Vector3(Spherical(v1.distance, v1.horizontalAngle.ToFloat(),
(Angle)v1.verticalAngle)); v1.verticalAngle.ToFloat()));
Vector3 v2_3 = Vector3(Spherical(v2.distance, (Angle)v2.horizontalAngle, Vector3 v2_3 = Vector3(Spherical(v2.distance, v2.horizontalAngle.ToFloat(),
(Angle)v2.verticalAngle)); v2.verticalAngle.ToFloat()));
float dot = Vector3::Dot(v1_3, v2_3); float dot = Vector3::Dot(v1_3, v2_3);
float fraction = dot / denominator; float fraction = dot / denominator;
if (isnan(fraction)) if (isnan(fraction))
@ -216,17 +220,18 @@ Angle Spherical16::AngleBetween(const Spherical16& v1, const Spherical16& v2) {
Spherical16 Spherical16::Rotate(const Spherical16& v, Spherical16 Spherical16::Rotate(const Spherical16& v,
Angle horizontalAngle, Angle horizontalAngle,
Angle verticalAngle) { Angle verticalAngle) {
Spherical16 r = Spherical16(v.distance, v.horizontalAngle + horizontalAngle, Spherical16 r = Spherical16(
v.verticalAngle + verticalAngle); v.distance, v.horizontalAngle.ToFloat() + horizontalAngle.ToFloat(),
v.verticalAngle.ToFloat() + verticalAngle.ToFloat());
return r; return r;
} }
Spherical16 Spherical16::RotateHorizontal(const Spherical16& v, Angle a) { Spherical16 Spherical16::RotateHorizontal(const Spherical16& v, Angle a) {
Spherical16 r = Spherical16 r = Spherical16(
Spherical16(v.distance, v.horizontalAngle + a, v.verticalAngle); v.distance, v.horizontalAngle.ToFloat() + a.ToFloat(), v.verticalAngle);
return r; return r;
} }
Spherical16 Spherical16::RotateVertical(const Spherical16& v, Angle a) { Spherical16 Spherical16::RotateVertical(const Spherical16& v, Angle a) {
Spherical16 r = Spherical16 r = Spherical16(v.distance, v.horizontalAngle,
Spherical16(v.distance, v.horizontalAngle, v.verticalAngle + a); v.verticalAngle.ToFloat() + a.ToFloat());
return r; return r;
} }

6
Vector2.cpp
View File

@ -30,7 +30,7 @@ Vector2::Vector2(Vector3 v) {
y = v.Forward(); // z; y = v.Forward(); // z;
} }
Vector2::Vector2(Polar p) { Vector2::Vector2(Polar p) {
float horizontalRad = p.angle * Angle::Deg2Rad; float horizontalRad = p.angle.ToFloat() * Passer::LinearAlgebra::Deg2Rad;
float cosHorizontal = cosf(horizontalRad); float cosHorizontal = cosf(horizontalRad);
float sinHorizontal = sinf(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 angleFrom = atan2f(v1.y, v1.x);
float angleTo = atan2f(v2.y, v2.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) { 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) #if defined(AVR)
float sinValue = sin(angleRad); float sinValue = sin(angleRad);
float cosValue = cos(angleRad); // * Angle::Deg2Rad); float cosValue = cos(angleRad); // * Angle::Deg2Rad);

6
Vector3.cpp
View File

@ -31,8 +31,10 @@ Vector3::Vector3(Vector2 v) {
} }
Vector3::Vector3(Spherical s) { Vector3::Vector3(Spherical s) {
float verticalRad = (90 - s.verticalAngle) * Angle::Deg2Rad; float verticalRad =
float horizontalRad = s.horizontalAngle * Angle::Deg2Rad; (90.0f - s.verticalAngle.ToFloat()) * Passer::LinearAlgebra::Deg2Rad;
float horizontalRad =
s.horizontalAngle.ToFloat() * Passer::LinearAlgebra::Deg2Rad;
float cosVertical = cosf(verticalRad); float cosVertical = cosf(verticalRad);
float sinVertical = sinf(verticalRad); float sinVertical = sinf(verticalRad);
float cosHorizontal = cosf(horizontalRad); float cosHorizontal = cosf(horizontalRad);

97
test/Angle_test.cc
View File

@ -9,158 +9,159 @@
#define FLOAT_INFINITY std::numeric_limits<float>::infinity() #define FLOAT_INFINITY std::numeric_limits<float>::infinity()
TEST(Angle, Normalize) { TEST(Angle, Normalize) {
float r = 0; Angle r = 0;
r = Angle::Normalize(90.0f); r = Angle::Normalize(90.0f);
EXPECT_FLOAT_EQ(r, 90) << "Normalize 90"; EXPECT_FLOAT_EQ(r.ToFloat(), 90) << "Normalize 90";
r = Angle::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); r = Angle::Normalize(270);
EXPECT_FLOAT_EQ(r, -90) << "Normalize 270"; EXPECT_FLOAT_EQ(r.ToFloat(), -90) << "Normalize 270";
r = Angle::Normalize(270 + 360); 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); r = Angle::Normalize(-270);
EXPECT_FLOAT_EQ(r, 90) << "Normalize -270"; EXPECT_FLOAT_EQ(r.ToFloat(), 90) << "Normalize -270";
r = Angle::Normalize(-270 - 360); 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); r = Angle::Normalize(0);
EXPECT_FLOAT_EQ(r, 0) << "Normalize 0"; EXPECT_FLOAT_EQ(r.ToFloat(), 0) << "Normalize 0";
if (std::numeric_limits<float>::is_iec559) { if (std::numeric_limits<float>::is_iec559) {
r = Angle::Normalize(FLOAT_INFINITY); 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); 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) { TEST(Angle, Clamp) {
float r = 0; Angle r = 0;
r = Angle::Clamp(1, 0, 2); 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); 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); 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); 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); 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); 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<float>::is_iec559) { if (std::numeric_limits<float>::is_iec559) {
r = Angle::Clamp(1, 0, FLOAT_INFINITY); 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); 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) { TEST(Angle, Difference) {
float r = 0; Angle r = 0;
r = Angle::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, -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); 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); 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); 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); 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); 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); 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<float>::is_iec559) { if (std::numeric_limits<float>::is_iec559) {
r = Angle::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(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); 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) { TEST(Angle, MoveTowards) {
float r = 0; Angle r = 0;
r = Angle::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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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<float>::is_iec559) { if (std::numeric_limits<float>::is_iec559) {
r = Angle::MoveTowards(0, 90, FLOAT_INFINITY); 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); 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); 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); 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";
} }
} }

26
test/DiscreteAngle_test.cc
View File

@ -12,53 +12,53 @@
TEST(Angle8, Construct) { TEST(Angle8, Construct) {
float angle = 0.0F; float angle = 0.0F;
Angle8 a = Angle8(angle); Angle8 a = Angle8(angle);
float f = (float)a; float f = a.ToFloat();
EXPECT_FLOAT_EQ(f, angle); EXPECT_FLOAT_EQ(f, angle);
angle = -180.0F; angle = -180.0F;
a = Angle8(angle); a = Angle8(angle);
f = (float)a; f = a.ToFloat();
EXPECT_FLOAT_EQ(f, angle); EXPECT_FLOAT_EQ(f, angle);
} }
TEST(Angle8, Negate) { TEST(Angle8, Negate) {
float angle = 0; float angle = 0;
Angle8 a = Angle8(angle); Angle8 a = Angle8(angle);
a = -a; a = -a.ToFloat();
float f = (float)a; float f = a.ToFloat();
EXPECT_FLOAT_EQ(f, angle); EXPECT_FLOAT_EQ(f, angle);
angle = 90.0F; angle = 90.0F;
a = Angle8(angle); a = Angle8(angle);
a = -a; a = -a.ToFloat();
f = (float)a; f = a.ToFloat();
EXPECT_FLOAT_EQ(f, -angle); EXPECT_FLOAT_EQ(f, -angle);
} }
TEST(Angle8, Add) { TEST(Angle8, Add) {
Angle8 a = Angle8(0); Angle8 a = Angle8(0);
Angle8 b = Angle8(0.0F); Angle8 b = Angle8(0.0F);
Angle8 r = a + b; Angle8 r = a.ToFloat() + b.ToFloat();
EXPECT_FLOAT_EQ((float)r, 0); EXPECT_FLOAT_EQ(r.ToFloat(), 0);
} }
TEST(Angle16, Construct) { TEST(Angle16, Construct) {
Angle16 a = Angle16(0.0F); Angle16 a = Angle16(0.0F);
float f = (float)a; float f = a.ToFloat();
EXPECT_FLOAT_EQ(f, 0); EXPECT_FLOAT_EQ(f, 0);
} }
TEST(Angle16, Negate) { TEST(Angle16, Negate) {
float angle = 0; float angle = 0;
Angle16 a = Angle16(angle); Angle16 a = Angle16(angle);
a = -a; a = -a.ToFloat();
float f = (float)a; float f = a.ToFloat();
EXPECT_FLOAT_EQ(f, angle); EXPECT_FLOAT_EQ(f, angle);
angle = 90.0F; angle = 90.0F;
a = Angle16(angle); a = Angle16(angle);
a = -a; a = -a.ToFloat();
f = (float)a; f = a.ToFloat();
EXPECT_FLOAT_EQ(f, -angle); EXPECT_FLOAT_EQ(f, -angle);
} }
#endif #endif

34
test/Polar_test.cc
View File

@ -1,7 +1,7 @@
#if GTEST #if GTEST
#include <gtest/gtest.h> #include <gtest/gtest.h>
#include <limits>
#include <math.h> #include <math.h>
#include <limits>
#include "Polar.h" #include "Polar.h"
@ -12,19 +12,19 @@ TEST(Polar, FromVector2) {
Polar p = Polar(v); Polar p = Polar(v);
EXPECT_FLOAT_EQ(p.distance, 1.0F) << "p.distance 0 1"; 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); v = Vector2(1, 0);
p = Polar(v); p = Polar(v);
EXPECT_FLOAT_EQ(p.distance, 1.0F) << "p.distance 1 0"; 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); v = Vector2(-1, 1);
p = Polar(v); p = Polar(v);
EXPECT_FLOAT_EQ(p.distance, sqrt(2.0F)) << "p.distance -1 1"; 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) { TEST(Polar, FromSpherical) {
@ -35,37 +35,38 @@ TEST(Polar, FromSpherical) {
p = Polar(s); p = Polar(s);
EXPECT_FLOAT_EQ(p.distance, 1.0F) << "p.distance FromSpherical(1 0 0)"; 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); s = Spherical(1, 45, 0);
p = Polar(s); p = Polar(s);
EXPECT_FLOAT_EQ(p.distance, 1.0F) << "p.distance FromSpherical(1 45 0)"; 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); s = Spherical(1, -45, 0);
p = Polar(s); p = Polar(s);
EXPECT_FLOAT_EQ(p.distance, 1.0F) << "p.distance FromSpherical(1 -45 0)"; 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); s = Spherical(0, 0, 0);
p = Polar(s); p = Polar(s);
EXPECT_FLOAT_EQ(p.distance, 0.0F) << "p.distance FromSpherical(0 0 0)"; 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); s = Spherical(-1, 0, 0);
p = Polar(s); p = Polar(s);
EXPECT_FLOAT_EQ(p.distance, 1.0F) << "p.distance FromSpherical(-1 0 0)"; 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); s = Spherical(0, 0, 90);
p = Polar(s); p = Polar(s);
EXPECT_FLOAT_EQ(p.distance, 0.0F) << "p.distance FromSpherical(0 0 90)"; 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) { TEST(Polar, Negation) {
@ -74,7 +75,7 @@ TEST(Polar, Negation) {
r = -v; r = -v;
EXPECT_FLOAT_EQ(r.distance, 2); 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)"; EXPECT_TRUE(r == Polar(2, -135)) << "Negate(2 45)";
v = Polar(2, -45); v = Polar(2, -45);
@ -88,7 +89,7 @@ TEST(Polar, Negation) {
v = Polar(0, 0); v = Polar(0, 0);
r = -v; r = -v;
EXPECT_FLOAT_EQ(r.distance, 0.0f); 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)"; EXPECT_TRUE(r == Polar(0, 0)) << "Negate(0 0)";
} }
@ -124,7 +125,7 @@ TEST(Polar, Addition) {
v2 = Polar(1, -45); v2 = Polar(1, -45);
r = v1 + v2; r = v1 + v2;
EXPECT_FLOAT_EQ(r.distance, sqrtf(2)) << "Addition(0 0 0)"; 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) { TEST(Polar, Scale_Multiply) {
@ -133,7 +134,8 @@ TEST(Polar, Scale_Multiply) {
r = v1 * 2.0f; r = v1 * 2.0f;
EXPECT_FLOAT_EQ(r.distance, v1.distance * 2) << "ScaleMult(4 45, 2)"; 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) { TEST(Polar, Scale_Divide) {
@ -142,7 +144,7 @@ TEST(Polar, Scale_Divide) {
r = v1 / 2.0f; r = v1 / 2.0f;
EXPECT_FLOAT_EQ(r.distance, v1.distance / 2) << "ScaleDiv(4 45, 2)"; 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) { TEST(Polar, Distance) {
@ -164,7 +166,7 @@ TEST(Polar, Rotate) {
r = Polar::Rotate(v, 45); r = Polar::Rotate(v, 45);
EXPECT_FLOAT_EQ(r.distance, v.distance) << "Rotate(4 45, 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 #endif

75
test/Spherical16_test.cc
View File

@ -12,22 +12,22 @@ TEST(Spherical16, FromVector3) {
Spherical16 s = Spherical16(v); Spherical16 s = Spherical16(v);
EXPECT_FLOAT_EQ(s.distance, 1.0F) << "s.distance 0 0 1"; 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.horizontalAngle.ToFloat(), 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.verticalAngle.ToFloat(), 0.0F) << "s.vert 0 0 1";
v = Vector3(0, 1, 0); v = Vector3(0, 1, 0);
s = Spherical16(v); s = Spherical16(v);
EXPECT_FLOAT_EQ(s.distance, 1.0F) << "s.distance 0 1 0"; 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.horizontalAngle.ToFloat(), 0.0F) << "s.hor 0 1 0";
EXPECT_FLOAT_EQ(s.verticalAngle, 90.0F) << "s.vert 0 1 0"; EXPECT_FLOAT_EQ(s.verticalAngle.ToFloat(), 90.0F) << "s.vert 0 1 0";
v = Vector3(1, 0, 0); v = Vector3(1, 0, 0);
s = Spherical16(v); s = Spherical16(v);
EXPECT_FLOAT_EQ(s.distance, 1.0F) << "s.distance 1 0 0"; 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.horizontalAngle.ToFloat(), 90.0F) << "s.hor 1 0 0";
EXPECT_FLOAT_EQ(s.verticalAngle, 0.0F) << "s.vert 1 0 0"; EXPECT_FLOAT_EQ(s.verticalAngle.ToFloat(), 0.0F) << "s.vert 1 0 0";
} }
TEST(Spherical16, FromPolar) { TEST(Spherical16, FromPolar) {
@ -35,36 +35,36 @@ TEST(Spherical16, FromPolar) {
Spherical16 s = Spherical16(p); Spherical16 s = Spherical16(p);
EXPECT_FLOAT_EQ(s.distance, 1.0F) << "s.distance Polar(1 0)"; 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.horizontalAngle.ToFloat(), 0.0F) << "s.hor Polar(1 0)";
EXPECT_FLOAT_EQ(s.verticalAngle, 0.0F) << "s.vert Polar(1 0)"; EXPECT_FLOAT_EQ(s.verticalAngle.ToFloat(), 0.0F) << "s.vert Polar(1 0)";
p = Polar(1, 45); p = Polar(1, 45);
s = Spherical16(p); s = Spherical16(p);
EXPECT_FLOAT_EQ(s.distance, 1.0F) << "s.distance Polar(1 45)"; 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.horizontalAngle.ToFloat(), 45.0F) << "s.hor Polar(1 45)";
EXPECT_FLOAT_EQ(s.verticalAngle, 0.0F) << "s.vert Polar(1 45)"; EXPECT_FLOAT_EQ(s.verticalAngle.ToFloat(), 0.0F) << "s.vert Polar(1 45)";
p = Polar(1, -45); p = Polar(1, -45);
s = Spherical16(p); s = Spherical16(p);
EXPECT_FLOAT_EQ(s.distance, 1.0F) << "s.distance Polar(1 -45)"; 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.horizontalAngle.ToFloat(), -45.0F) << "s.hor Polar(1 -45)";
EXPECT_FLOAT_EQ(s.verticalAngle, 0.0F) << "s.vert Polar(1 -45)"; EXPECT_FLOAT_EQ(s.verticalAngle.ToFloat(), 0.0F) << "s.vert Polar(1 -45)";
p = Polar(0, 0); p = Polar(0, 0);
s = Spherical16(p); s = Spherical16(p);
EXPECT_FLOAT_EQ(s.distance, 0.0F) << "s.distance Polar(0 0)"; 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.horizontalAngle.ToFloat(), 0.0F) << "s.hor Polar(0 0)";
EXPECT_FLOAT_EQ(s.verticalAngle, 0.0F) << "s.vert Polar(0 0)"; EXPECT_FLOAT_EQ(s.verticalAngle.ToFloat(), 0.0F) << "s.vert Polar(0 0)";
p = Polar(-1, 0); p = Polar(-1, 0);
s = Spherical16(p); s = Spherical16(p);
EXPECT_FLOAT_EQ(s.distance, 1.0F) << "s.distance Polar(-1 0)"; 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.horizontalAngle.ToFloat(), -180.0F) << "s.hor Polar(-1 0)";
EXPECT_FLOAT_EQ(s.verticalAngle, 0.0F) << "s.vert Polar(-1 0)"; EXPECT_FLOAT_EQ(s.verticalAngle.ToFloat(), 0.0F) << "s.vert Polar(-1 0)";
} }
TEST(Spherical16, Incident1) { TEST(Spherical16, Incident1) {
@ -73,11 +73,12 @@ TEST(Spherical16, Incident1) {
Spherical16 sr = Spherical16(2.49F, 98.18f, 24.4F); Spherical16 sr = Spherical16(2.49F, 98.18f, 24.4F);
EXPECT_NEAR(s.distance, sr.distance, 1.0e-01); EXPECT_NEAR(s.distance, sr.distance, 1.0e-01);
EXPECT_NEAR(s.horizontalAngle, sr.horizontalAngle, 1.0e-02); EXPECT_NEAR(s.horizontalAngle.ToFloat(), sr.horizontalAngle.ToFloat(),
EXPECT_NEAR(s.verticalAngle, sr.verticalAngle, 1.0e-02); 1.0e-02);
EXPECT_NEAR(s.verticalAngle.ToFloat(), sr.verticalAngle.ToFloat(), 1.0e-02);
Vector3 r = Vector3(Spherical(sr.distance, (Angle)sr.horizontalAngle, Vector3 r = Vector3(Spherical(sr.distance, sr.horizontalAngle.ToFloat(),
(Angle)sr.verticalAngle)); sr.verticalAngle.ToFloat()));
EXPECT_NEAR(r.Right(), v.Right(), 1.0e-02) << "toVector3.x 1 0 0"; 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.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"; 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); Spherical16 sr = Spherical16(1.4142135623F, 45.0f, 0.0F);
EXPECT_NEAR(s.distance, sr.distance, 1.0e-05); EXPECT_NEAR(s.distance, sr.distance, 1.0e-05);
EXPECT_NEAR(s.horizontalAngle, sr.horizontalAngle, 1.0e-05); EXPECT_NEAR(s.horizontalAngle.ToFloat(), sr.horizontalAngle.ToFloat(),
EXPECT_NEAR(s.verticalAngle, sr.verticalAngle, 1.0e-05); 1.0e-05);
EXPECT_NEAR(s.verticalAngle.ToFloat(), sr.verticalAngle.ToFloat(), 1.0e-05);
Vector3 r = Vector3(Spherical(sr.distance, (Angle)sr.horizontalAngle, Vector3 r = Vector3(Spherical(sr.distance, sr.horizontalAngle.ToFloat(),
(Angle)sr.verticalAngle)); sr.verticalAngle.ToFloat()));
EXPECT_NEAR(r.Right(), v.Right(), 1.0e-06); EXPECT_NEAR(r.Right(), v.Right(), 1.0e-06);
EXPECT_NEAR(r.Up(), v.Up(), 1.0e-06); EXPECT_NEAR(r.Up(), v.Up(), 1.0e-06);
EXPECT_NEAR(r.Forward(), v.Forward(), 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); sr = Spherical16(1.4142135623F, 0.0f, 45.0F);
EXPECT_NEAR(s.distance, sr.distance, 1.0e-05); EXPECT_NEAR(s.distance, sr.distance, 1.0e-05);
EXPECT_NEAR(s.horizontalAngle, sr.horizontalAngle, 1.0e-05); EXPECT_NEAR(s.horizontalAngle.ToFloat(), sr.horizontalAngle.ToFloat(),
EXPECT_NEAR(s.verticalAngle, sr.verticalAngle, 1.0e-05); 1.0e-05);
EXPECT_NEAR(s.verticalAngle.ToFloat(), sr.verticalAngle.ToFloat(), 1.0e-05);
r = Vector3(Spherical(sr.distance, (Angle)sr.horizontalAngle, r = Vector3(Spherical(sr.distance, sr.horizontalAngle.ToFloat(),
(Angle)sr.verticalAngle)); sr.verticalAngle.ToFloat()));
EXPECT_NEAR(r.Right(), v.Right(), 1.0e-06); EXPECT_NEAR(r.Right(), v.Right(), 1.0e-06);
EXPECT_NEAR(r.Up(), v.Up(), 1.0e-06); EXPECT_NEAR(r.Up(), v.Up(), 1.0e-06);
EXPECT_NEAR(r.Forward(), v.Forward(), 1.0e-06); EXPECT_NEAR(r.Forward(), v.Forward(), 1.0e-06);
v = Vector3(1.0f, 1.0f, 1.0f); v = Vector3(1.0f, 1.0f, 1.0f);
s = Spherical16(v); s = Spherical16(v);
r = Vector3( r = Vector3(Spherical(s.distance, s.horizontalAngle.ToFloat(),
Spherical(s.distance, (Angle)s.horizontalAngle, (Angle)s.verticalAngle)); s.verticalAngle.ToFloat()));
EXPECT_NEAR(s.distance, 1.73205080F, 1.0e-02); EXPECT_NEAR(s.distance, 1.73205080F, 1.0e-02);
EXPECT_NEAR(s.horizontalAngle, 45.0F, 1.0e-02); EXPECT_NEAR(s.horizontalAngle.ToFloat(), 45.0F, 1.0e-02);
EXPECT_NEAR(s.verticalAngle, 35.26F, 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.Right(), v.Right(), 1.0e-04);
EXPECT_NEAR(r.Up(), v.Up(), 1.0e-04); EXPECT_NEAR(r.Up(), v.Up(), 1.0e-04);
@ -147,14 +150,14 @@ TEST(Spherical16, Addition) {
v2 = Spherical16(1, -45, 0); v2 = Spherical16(1, -45, 0);
r = v1 + v2; r = v1 + v2;
EXPECT_FLOAT_EQ(r.distance, sqrtf(2)) << "Addition(1 -45 0)"; 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.horizontalAngle.ToFloat(), 0) << "Addition(1 -45 0)";
EXPECT_FLOAT_EQ(r.verticalAngle, 0) << "Addition(1 -45 0)"; EXPECT_FLOAT_EQ(r.verticalAngle.ToFloat(), 0) << "Addition(1 -45 0)";
v2 = Spherical16(1, 0, 90); v2 = Spherical16(1, 0, 90);
r = v1 + v2; r = v1 + v2;
EXPECT_FLOAT_EQ(r.distance, sqrtf(2)) << "Addition(1 0 90)"; 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.horizontalAngle.ToFloat(), 45) << "Addition(1 0 90)";
EXPECT_FLOAT_EQ(r.verticalAngle, 45) << "Addition(1 0 90)"; EXPECT_FLOAT_EQ(r.verticalAngle.ToFloat(), 45) << "Addition(1 0 90)";
} }
#endif #endif

61
test/Spherical_test.cc
View File

@ -1,7 +1,7 @@
#if GTEST #if GTEST
#include <gtest/gtest.h> #include <gtest/gtest.h>
#include <limits>
#include <math.h> #include <math.h>
#include <limits>
#include "Spherical.h" #include "Spherical.h"
@ -12,22 +12,22 @@ TEST(Spherical, FromVector3) {
Spherical s = Spherical(v); Spherical s = Spherical(v);
EXPECT_FLOAT_EQ(s.distance, 1.0F) << "s.distance 0 0 1"; 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.horizontalAngle.ToFloat(), 0.0F) << "s.hor 0 0 1";
EXPECT_FLOAT_EQ(s.verticalAngle, 0.0F) << "s.vert 0 0 1"; EXPECT_FLOAT_EQ(s.verticalAngle.ToFloat(), 0.0F) << "s.vert 0 0 1";
v = Vector3(0, 1, 0); v = Vector3(0, 1, 0);
s = Spherical(v); s = Spherical(v);
EXPECT_FLOAT_EQ(s.distance, 1.0F) << "s.distance 0 1 0"; 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.horizontalAngle.ToFloat(), 0.0F) << "s.hor 0 1 0";
EXPECT_FLOAT_EQ(s.verticalAngle, 90.0F) << "s.vert 0 1 0"; EXPECT_FLOAT_EQ(s.verticalAngle.ToFloat(), 90.0F) << "s.vert 0 1 0";
v = Vector3(1, 0, 0); v = Vector3(1, 0, 0);
s = Spherical(v); s = Spherical(v);
EXPECT_FLOAT_EQ(s.distance, 1.0F) << "s.distance 1 0 0"; 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.horizontalAngle.ToFloat(), 90.0F) << "s.hor 1 0 0";
EXPECT_FLOAT_EQ(s.verticalAngle, 0.0F) << "s.vert 1 0 0"; EXPECT_FLOAT_EQ(s.verticalAngle.ToFloat(), 0.0F) << "s.vert 1 0 0";
} }
TEST(Spherical, FromPolar) { TEST(Spherical, FromPolar) {
@ -35,36 +35,36 @@ TEST(Spherical, FromPolar) {
Spherical s = Spherical(p); Spherical s = Spherical(p);
EXPECT_FLOAT_EQ(s.distance, 1.0F) << "s.distance Polar(1 0)"; 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.horizontalAngle.ToFloat(), 0.0F) << "s.hor Polar(1 0)";
EXPECT_FLOAT_EQ(s.verticalAngle, 0.0F) << "s.vert Polar(1 0)"; EXPECT_FLOAT_EQ(s.verticalAngle.ToFloat(), 0.0F) << "s.vert Polar(1 0)";
p = Polar(1, 45); p = Polar(1, 45);
s = Spherical(p); s = Spherical(p);
EXPECT_FLOAT_EQ(s.distance, 1.0F) << "s.distance Polar(1 45)"; 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.horizontalAngle.ToFloat(), 45.0F) << "s.hor Polar(1 45)";
EXPECT_FLOAT_EQ(s.verticalAngle, 0.0F) << "s.vert Polar(1 45)"; EXPECT_FLOAT_EQ(s.verticalAngle.ToFloat(), 0.0F) << "s.vert Polar(1 45)";
p = Polar(1, -45); p = Polar(1, -45);
s = Spherical(p); s = Spherical(p);
EXPECT_FLOAT_EQ(s.distance, 1.0F) << "s.distance Polar(1 -45)"; 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.horizontalAngle.ToFloat(), -45.0F) << "s.hor Polar(1 -45)";
EXPECT_FLOAT_EQ(s.verticalAngle, 0.0F) << "s.vert Polar(1 -45)"; EXPECT_FLOAT_EQ(s.verticalAngle.ToFloat(), 0.0F) << "s.vert Polar(1 -45)";
p = Polar(0, 0); p = Polar(0, 0);
s = Spherical(p); s = Spherical(p);
EXPECT_FLOAT_EQ(s.distance, 0.0F) << "s.distance Polar(0 0)"; 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.horizontalAngle.ToFloat(), 0.0F) << "s.hor Polar(0 0)";
EXPECT_FLOAT_EQ(s.verticalAngle, 0.0F) << "s.vert Polar(0 0)"; EXPECT_FLOAT_EQ(s.verticalAngle.ToFloat(), 0.0F) << "s.vert Polar(0 0)";
p = Polar(-1, 0); p = Polar(-1, 0);
s = Spherical(p); s = Spherical(p);
EXPECT_FLOAT_EQ(s.distance, 1.0F) << "s.distance Polar(-1 0)"; 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.horizontalAngle.ToFloat(), 180.0F) << "s.hor Polar(-1 0)";
EXPECT_FLOAT_EQ(s.verticalAngle, 0.0F) << "s.vert Polar(-1 0)"; EXPECT_FLOAT_EQ(s.verticalAngle.ToFloat(), 0.0F) << "s.vert Polar(-1 0)";
} }
TEST(Spherical, Incident1) { TEST(Spherical, Incident1) {
@ -73,8 +73,9 @@ TEST(Spherical, Incident1) {
Spherical sr = Spherical(2.49F, 98.18f, 24.4F); Spherical sr = Spherical(2.49F, 98.18f, 24.4F);
EXPECT_NEAR(s.distance, sr.distance, 1.0e-01); EXPECT_NEAR(s.distance, sr.distance, 1.0e-01);
EXPECT_NEAR(s.horizontalAngle, sr.horizontalAngle, 1.0e-02); EXPECT_NEAR(s.horizontalAngle.ToFloat(), sr.horizontalAngle.ToFloat(),
EXPECT_NEAR(s.verticalAngle, sr.verticalAngle, 1.0e-02); 1.0e-02);
EXPECT_NEAR(s.verticalAngle.ToFloat(), sr.verticalAngle.ToFloat(), 1.0e-02);
Vector3 r = Vector3(sr); Vector3 r = Vector3(sr);
EXPECT_NEAR(r.Right(), v.Right(), 1.0e-02) << "toVector3.x 1 0 0"; 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); Spherical sr = Spherical(1.4142135623F, 45.0f, 0.0F);
EXPECT_NEAR(s.distance, sr.distance, 1.0e-05); EXPECT_NEAR(s.distance, sr.distance, 1.0e-05);
EXPECT_NEAR(s.horizontalAngle, sr.horizontalAngle, 1.0e-05); EXPECT_NEAR(s.horizontalAngle.ToFloat(), sr.horizontalAngle.ToFloat(),
EXPECT_NEAR(s.verticalAngle, sr.verticalAngle, 1.0e-05); 1.0e-05);
EXPECT_NEAR(s.verticalAngle.ToFloat(), sr.verticalAngle.ToFloat(), 1.0e-05);
Vector3 r = Vector3(sr); Vector3 r = Vector3(sr);
EXPECT_NEAR(r.Right(), v.Right(), 1.0e-06); EXPECT_NEAR(r.Right(), v.Right(), 1.0e-06);
@ -101,8 +103,9 @@ TEST(Spherical, Incident2) {
sr = Spherical(1.4142135623F, 0.0f, 45.0F); sr = Spherical(1.4142135623F, 0.0f, 45.0F);
EXPECT_NEAR(s.distance, sr.distance, 1.0e-05); EXPECT_NEAR(s.distance, sr.distance, 1.0e-05);
EXPECT_NEAR(s.horizontalAngle, sr.horizontalAngle, 1.0e-05); EXPECT_NEAR(s.horizontalAngle.ToFloat(), sr.horizontalAngle.ToFloat(),
EXPECT_NEAR(s.verticalAngle, sr.verticalAngle, 1.0e-05); 1.0e-05);
EXPECT_NEAR(s.verticalAngle.ToFloat(), sr.verticalAngle.ToFloat(), 1.0e-05);
r = Vector3(sr); r = Vector3(sr);
EXPECT_NEAR(r.Right(), v.Right(), 1.0e-06); EXPECT_NEAR(r.Right(), v.Right(), 1.0e-06);
@ -114,8 +117,8 @@ TEST(Spherical, Incident2) {
r = Vector3(s); r = Vector3(s);
EXPECT_NEAR(s.distance, 1.73205080F, 1.0e-02); EXPECT_NEAR(s.distance, 1.73205080F, 1.0e-02);
EXPECT_NEAR(s.horizontalAngle, 45.0F, 1.0e-02); EXPECT_NEAR(s.horizontalAngle.ToFloat(), 45.0F, 1.0e-02);
EXPECT_NEAR(s.verticalAngle, 35.26F, 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.Right(), v.Right(), 1.0e-06);
EXPECT_NEAR(r.Up(), v.Up(), 1.0e-06); EXPECT_NEAR(r.Up(), v.Up(), 1.0e-06);
@ -143,14 +146,14 @@ TEST(Spherical, Addition) {
v2 = Spherical(1, -45, 0); v2 = Spherical(1, -45, 0);
r = v1 + v2; r = v1 + v2;
EXPECT_FLOAT_EQ(r.distance, sqrtf(2)) << "Addition(1 -45 0)"; 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.horizontalAngle.ToFloat(), 0) << "Addition(1 -45 0)";
EXPECT_FLOAT_EQ(r.verticalAngle, 0) << "Addition(1 -45 0)"; EXPECT_FLOAT_EQ(r.verticalAngle.ToFloat(), 0) << "Addition(1 -45 0)";
v2 = Spherical(1, 0, 90); v2 = Spherical(1, 0, 90);
r = v1 + v2; r = v1 + v2;
EXPECT_FLOAT_EQ(r.distance, sqrtf(2)) << "Addition(1 0 90)"; 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.horizontalAngle.ToFloat(), 45) << "Addition(1 0 90)";
EXPECT_FLOAT_EQ(r.verticalAngle, 45) << "Addition(1 0 90)"; EXPECT_FLOAT_EQ(r.verticalAngle.ToFloat(), 45) << "Addition(1 0 90)";
} }
#endif #endif