Make Angle -> float conversion explicit
This commit is contained in:
Pascal Serrarens
parent
608c45c1a7
commit
49c67405fc
44
Angle.cpp
44
Angle.cpp
@ -74,32 +74,37 @@ float Angle::SineRuleAngle(float a, float beta, float b) {
|
||||
//----------------------
|
||||
|
||||
template <>
|
||||
AngleOf<float>::AngleOf(int angle) : value(angle) {}
|
||||
AngleOf<float>::AngleOf(int angle) : value((float)angle) {}
|
||||
|
||||
template <>
|
||||
AngleOf<float>::AngleOf(float angle) : value(angle) {}
|
||||
|
||||
// template <>
|
||||
// AngleOf<float>::operator float() const {
|
||||
// return value;
|
||||
// }
|
||||
|
||||
template <>
|
||||
AngleOf<float>::operator float() const {
|
||||
float AngleOf<float>::ToFloat() const {
|
||||
return value;
|
||||
}
|
||||
|
||||
template <>
|
||||
AngleOf<float> AngleOf<float>::pi = 3.1415927410125732421875F;
|
||||
// template <>
|
||||
// AngleOf<float> AngleOf<float>::pi = 3.1415927410125732421875F;
|
||||
|
||||
template <>
|
||||
AngleOf<float> AngleOf<float>::Rad2Deg = 360.0f / (pi * 2);
|
||||
template <>
|
||||
AngleOf<float> AngleOf<float>::Deg2Rad = (pi * 2) / 360.0f;
|
||||
// template <>
|
||||
// AngleOf<float> AngleOf<float>::Rad2Deg = 360.0f / (pi * 2);
|
||||
// template <>
|
||||
// AngleOf<float> AngleOf<float>::Deg2Rad = (pi * 2) / 360.0f;
|
||||
|
||||
template <>
|
||||
bool Passer::LinearAlgebra::AngleOf<float>::operator==(AngleOf<float> a) {
|
||||
return (float)*this == (float)a;
|
||||
return this->ToFloat() == a.ToFloat();
|
||||
}
|
||||
|
||||
template <>
|
||||
AngleOf<float> AngleOf<float>::Normalize(AngleOf<float> angle) {
|
||||
float angleValue = angle;
|
||||
float angleValue = angle.ToFloat();
|
||||
if (!isfinite(angleValue))
|
||||
return angleValue;
|
||||
|
||||
@ -114,8 +119,8 @@ template <>
|
||||
AngleOf<float> AngleOf<float>::Clamp(AngleOf<float> angle,
|
||||
AngleOf<float> min,
|
||||
AngleOf<float> 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<float> AngleOf<float>::MoveTowards(AngleOf<float> fromAngle,
|
||||
AngleOf<float> toAngle,
|
||||
AngleOf<float> 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<float> AngleOf<float>::CosineRuleSide(float a,
|
||||
AngleOf<float> gamma) {
|
||||
float a2 = a * a;
|
||||
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
|
||||
if (d < 0)
|
||||
return 0.0f;
|
||||
@ -162,7 +168,8 @@ AngleOf<float> AngleOf<float>::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<float> AngleOf<float>::SineRuleAngle(float a,
|
||||
AngleOf<float> 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;
|
||||
}
|
||||
11
Angle.h
11
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 <typename T>
|
||||
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<T> Normalize(AngleOf<T> a);
|
||||
static AngleOf<T> Clamp(AngleOf<T> a, AngleOf<T> min, AngleOf<T> max);
|
||||
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;
|
||||
};
|
||||
static AngleOf<T> MoveTowards(AngleOf<T> fromAngle,
|
||||
|
||||
13
Angle16.cpp
13
Angle16.cpp
@ -23,8 +23,14 @@ AngleOf<signed short>::AngleOf(float angle) {
|
||||
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 <>
|
||||
AngleOf<signed short>::operator float() const {
|
||||
float AngleOf<signed short>::ToFloat() const {
|
||||
float f = ((this->value * 180) / 32768.0F);
|
||||
return f;
|
||||
}
|
||||
@ -37,7 +43,8 @@ AngleOf<signed short> AngleOf<signed short>::CosineRuleSide(
|
||||
AngleOf<signed short> gamma) {
|
||||
float a2 = a * a;
|
||||
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
|
||||
if (d < 0)
|
||||
return 0.0f;
|
||||
@ -61,6 +68,6 @@ AngleOf<signed short> AngleOf<signed short>::CosineRuleAngle(float a,
|
||||
if (d <= -1)
|
||||
return 180.0f;
|
||||
|
||||
float gamma = acosf(d) * Angle::Rad2Deg;
|
||||
float gamma = acosf(d) * Passer::LinearAlgebra::Rad2Deg;
|
||||
return gamma;
|
||||
}
|
||||
|
||||
@ -23,8 +23,14 @@ AngleOf<signed char>::AngleOf(float angle) {
|
||||
this->value = (signed char)(f * 256.0F);
|
||||
}
|
||||
|
||||
// template <>
|
||||
// AngleOf<signed char>::operator float() const {
|
||||
// float f = (this->value * 180) / 128.0F;
|
||||
// return f;
|
||||
// }
|
||||
|
||||
template <>
|
||||
AngleOf<signed char>::operator float() const {
|
||||
float AngleOf<signed char>::ToFloat() const {
|
||||
float f = (this->value * 180) / 128.0F;
|
||||
return f;
|
||||
}
|
||||
|
||||
11
Axis.cpp
11
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;
|
||||
}
|
||||
29
Polar.cpp
29
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;
|
||||
}
|
||||
@ -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;
|
||||
}
|
||||
@ -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;
|
||||
}
|
||||
@ -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);
|
||||
|
||||
@ -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);
|
||||
|
||||
@ -9,158 +9,159 @@
|
||||
#define FLOAT_INFINITY std::numeric_limits<float>::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<float>::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<float>::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<float>::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<float>::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";
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -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
|
||||
@ -1,7 +1,7 @@
|
||||
#if GTEST
|
||||
#include <gtest/gtest.h>
|
||||
#include <limits>
|
||||
#include <math.h>
|
||||
#include <limits>
|
||||
|
||||
#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
|
||||
@ -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
|
||||
@ -1,7 +1,7 @@
|
||||
#if GTEST
|
||||
#include <gtest/gtest.h>
|
||||
#include <limits>
|
||||
#include <math.h>
|
||||
#include <limits>
|
||||
|
||||
#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
|
||||
Loading…
x
Reference in New Issue
Block a user