Polar.h

// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0.If a copy of the MPL was not distributed with this
// file, You can obtain one at https ://mozilla.org/MPL/2.0/.
 
#ifndef POLAR_H
#define POLAR_H
 
#include "Angle.h"
 
namespace Passer {
namespace LinearAlgebra {
 
struct Vector2;
template <typename T> class SphericalOf;
 
template <typename T> class PolarOf {
public:
  float distance;
  AngleOf<T> angle;
 
  PolarOf();
  PolarOf(float distance, AngleOf<T> angle);
 
  static PolarOf<T> Degrees(float distance, float degrees);
  constexpr static auto Deg = Degrees;
  static PolarOf<T> Radians(float distance, float radians);
  constexpr static auto Rad = Radians;
 
  static PolarOf<T> FromVector2(Vector2 v);
  static PolarOf<T> FromSpherical(SphericalOf<T> v);
 
  const static PolarOf zero;
  const static PolarOf forward;
  const static PolarOf back;
  const static PolarOf right;
  const static PolarOf left;
 
  bool operator==(const PolarOf &v) const;
 
  inline static float Magnitude(const PolarOf &v) { return v.distance; }
  inline float magnitude() const { return this->distance; }
 
  static PolarOf Normalize(const PolarOf &v);
  PolarOf normalized() const;
 
  PolarOf operator-() const;
 
  PolarOf operator-(const PolarOf &v) const;
  PolarOf operator-=(const PolarOf &v);
  PolarOf operator+(const PolarOf &v) const;
  PolarOf operator+=(const PolarOf &v);
 
  friend PolarOf operator*(const PolarOf &v, float f) {
    return PolarOf(v.distance * f, v.angle);
  }
  friend PolarOf operator*(float f, const PolarOf &v) {
    return PolarOf(f * v.distance, v.angle);
  }
  PolarOf operator*=(float f);
  friend PolarOf operator/(const PolarOf &v, float f) {
    return PolarOf(v.distance / f, v.angle);
  }
  friend PolarOf operator/(float f, const PolarOf &v) {
    return PolarOf(f / v.distance, v.angle);
  }
  PolarOf operator/=(float f);
 
  static float Distance(const PolarOf &v1, const PolarOf &v2);
 
  static PolarOf Rotate(const PolarOf &v, AngleOf<T> a);
};
 
using PolarSingle = PolarOf<float>;
using Polar16 = PolarOf<signed short>;
// using Polar = PolarSingle;
 
} // namespace LinearAlgebra
} // namespace Passer
using namespace Passer::LinearAlgebra;
 
#include "Spherical.h"
#include "Vector2.h"
 
#endif