Spherical.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 SPHERICAL_H
#define SPHERICAL_H
 
#include "Direction.h"
 
namespace Passer {
namespace LinearAlgebra {
 
struct Vector3;
template <typename T> class PolarOf;
 
template <typename T> class SphericalOf {
public:
  float distance;
  // AngleOf<T> horizontal;
  // AngleOf<T> vertical;
  DirectionOf<T> direction;
 
  SphericalOf<T>();
  SphericalOf<T>(float distance, AngleOf<T> horizontal, AngleOf<T> vertical);
  SphericalOf<T>(float distance, DirectionOf<T> direction);
 
  static SphericalOf<T> Degrees(float distance, float horizontal,
                                float vertical);
  constexpr static auto Deg = Degrees;
  static SphericalOf<T> Radians(float distance, float horizontal,
                                float vertical);
  // Short-hand Rad alias for the Radians function
  constexpr static auto Rad = Radians;
 
  static SphericalOf<T> FromPolar(PolarOf<T> v);
 
  static SphericalOf<T> FromVector3(Vector3 v);
  Vector3 ToVector3() const;
 
  const static SphericalOf<T> zero;
  const static SphericalOf<T> forward;
  const static SphericalOf<T> back;
  const static SphericalOf<T> right;
  const static SphericalOf<T> left;
  const static SphericalOf<T> up;
  const static SphericalOf<T> down;
 
  SphericalOf<T> WithDistance(float distance);
 
  SphericalOf<T> operator-() const;
 
  SphericalOf<T> operator-(const SphericalOf<T> &v) const;
  SphericalOf<T> operator-=(const SphericalOf<T> &v);
  SphericalOf<T> operator+(const SphericalOf<T> &v) const;
  SphericalOf<T> operator+=(const SphericalOf<T> &v);
 
  friend SphericalOf<T> operator*(const SphericalOf<T> &v, float f) {
    return SphericalOf<T>(v.distance * f, v.direction);
  }
  friend SphericalOf<T> operator*(float f, const SphericalOf<T> &v) {
    return SphericalOf<T>(f * v.distance, v.direction);
  }
  SphericalOf<T> operator*=(float f);
  friend SphericalOf<T> operator/(const SphericalOf<T> &v, float f) {
    return SphericalOf<T>(v.distance / f, v.direction);
  }
  friend SphericalOf<T> operator/(float f, const SphericalOf<T> &v) {
    return SphericalOf<T>(f / v.distance, v.direction);
  }
  SphericalOf<T> operator/=(float f);
 
  static float DistanceBetween(const SphericalOf<T> &v1,
                               const SphericalOf<T> &v2);
  static AngleOf<T> AngleBetween(const SphericalOf<T> &v1,
                                 const SphericalOf<T> &v2);
  static AngleOf<T> SignedAngleBetween(const SphericalOf<T> &v1,
                                       const SphericalOf<T> &v2,
                                       const SphericalOf<T> &axis);
 
  static SphericalOf<T> Rotate(const SphericalOf &v, AngleOf<T> horizontalAngle,
                               AngleOf<T> verticalAngle);
  static SphericalOf<T> RotateHorizontal(const SphericalOf<T> &v,
                                         AngleOf<T> angle);
  static SphericalOf<T> RotateVertical(const SphericalOf<T> &v,
                                       AngleOf<T> angle);
};
 
using SphericalSingle = SphericalOf<float>;
using Spherical16 = SphericalOf<signed short>;
 
} // namespace LinearAlgebra
} // namespace Passer
using namespace Passer::LinearAlgebra;
 
#include "Polar.h"
#include "Vector3.h"
 
#endif