Vector3.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 VECTOR3_H
#define VECTOR3_H
 
#include "Vector2.h"
 
extern "C" {
typedef struct Vec3 {
protected:
  float x;
  float y;
  float z;
 
} Vec3;
}
 
namespace Passer {
namespace LinearAlgebra {
 
template <typename T> class SphericalOf;
 
struct Vector3 : Vec3 {
  friend struct Vec3;
 
public:
  Vector3();
  Vector3(float right, float up, float forward);
  Vector3(Vector2 v);
  Vector3(SphericalOf<float> v);
 
  ~Vector3();
 
  const static Vector3 zero;
  const static Vector3 one;
  const static Vector3 forward;
  const static Vector3 back;
  const static Vector3 right;
  const static Vector3 left;
  const static Vector3 up;
  const static Vector3 down;
 
  // Access functions which are intended to replace the use of XYZ
  inline float Forward() const { return z; };
  inline float Up() const { return y; };
  inline float Right() const { return x; };
 
  bool operator==(const Vector3 &v) const;
 
  static float Magnitude(const Vector3 &v);
  float magnitude() const;
  static float SqrMagnitude(const Vector3 &v);
  float sqrMagnitude() const;
 
  static Vector3 Normalize(const Vector3 &v);
  Vector3 normalized() const;
 
  Vector3 operator-() const;
 
  Vector3 operator-(const Vector3 &v) const;
  Vector3 operator-=(const Vector3 &v);
  Vector3 operator+(const Vector3 &v) const;
  Vector3 operator+=(const Vector3 &v);
 
  static Vector3 Scale(const Vector3 &v1, const Vector3 &v2);
  friend Vector3 operator*(const Vector3 &v, float f) {
    return Vector3(v.x * f, v.y * f, v.z * f);
  }
  friend Vector3 operator*(float f, const Vector3 &v) {
    // return Vector3(f * v.x, f * v.y, f * v.z);
    return Vector3(v.x * f, v.y * f, v.z * f);
  }
  Vector3 operator*=(float f);
  friend Vector3 operator/(const Vector3 &v, float f) {
    return Vector3(v.x / f, v.y / f, v.z / f);
  }
  friend Vector3 operator/(float f, const Vector3 &v) {
    // return Vector3(f / v.x, f / v.y, f / v.z);
    return Vector3(v.x / f, v.y / f, v.z / f);
  }
  Vector3 operator/=(float f);
 
  static float Distance(const Vector3 &v1, const Vector3 &v2);
 
  static float Dot(const Vector3 &v1, const Vector3 &v2);
 
  static Vector3 Cross(const Vector3 &v1, const Vector3 &v2);
 
  static Vector3 Project(const Vector3 &v, const Vector3 &n);
  static Vector3 ProjectOnPlane(const Vector3 &v, const Vector3 &n);
 
  static AngleOf<float> Angle(const Vector3 &v1, const Vector3 &v2);
  static AngleOf<float> SignedAngle(const Vector3 &v1, const Vector3 &v2,
                                    const Vector3 &axis);
 
  static Vector3 Lerp(const Vector3 &v1, const Vector3 &v2, float f);
};
 
} // namespace LinearAlgebra
} // namespace Passer
using namespace Passer::LinearAlgebra;
 
#include "Spherical.h"
 
#endif