3esvector3.h

//
// author: Kazys Stepanas
//
#ifndef _3ESVECTOR3_H_
#define _3ESVECTOR3_H_

#include "3es-core.h"

#include <cstdlib>
#include <cmath>

namespace tes
{
  template <typename T> class Vector3;
  typedef Vector3<float> Vector3f;
  typedef Vector3<double> Vector3d;

  template <typename T>
  class Vector3
  {
  public:
    union
    {
      struct
      {
        T x, y, z;
      };
      T v[3];
    };

    static const T Epsilon;

    static const Vector3<T> zero;
    static const Vector3<T> one;
    static const Vector3<T> axisx;
    static const Vector3<T> axisy;
    static const Vector3<T> axisz;

    inline Vector3() {}
    inline Vector3(const T &scalar) : x(scalar), y(scalar), z(scalar) {}
    inline Vector3(const Vector3<T> &other) : x(other.x), y(other.y), z(other.z) {}
    inline Vector3(const T &x, const T &y, const T &z) : x(x), y(y), z(z) {}
    inline Vector3(const T *array3) : x(array3[0]), y(array3[1]), z(array3[2]) {}

    template <typename Q>
    explicit inline Vector3(const Vector3<Q> &other) : x(T(other.x)), y(T(other.y)), z(T(other.z)) {}

    inline T &operator[](int index) { return v[index]; }
    inline const T &operator[](int index) const { return v[index]; }

    inline T &operator[](unsigned index) { return v[index]; }
    inline const T &operator[](unsigned index) const { return v[index]; }

    inline Vector3<T> &operator=(const Vector3<T> &other) { x = other.x; y = other.y; z = other.z; return *this; }

    template <typename Q>
    inline Vector3<T> &operator=(const Vector3<Q> &other) { x = T(other.x); y = T(other.y); z = T(other.z); return *this; }

    bool operator==(const Vector3<T> &other) const;
    bool operator!=(const Vector3<T> &other) const;

    inline Vector3<T> operator-() const { return negated(); }

    bool isEqual(const Vector3<T> &other, const T &epsilon = Epsilon) const;

    bool isZero(const T &epsilon = Epsilon) const;

    inline Vector3<T> &negate() { x = -x; y = -y; z = -y; return *this; }

    inline Vector3<T> negated() const { return Vector3<T>(-x, -y, -z); }

    T normalise(const T &epsilon = Epsilon);

    Vector3<T> normalised(const T &epsilon = Epsilon) const;

    Vector3<T> &add(const Vector3<T> &other);

    Vector3<T> &add(const T &scalar);

    Vector3<T> &subtract(const Vector3<T> &other);

    Vector3<T> &subtract(const T &scalar);

    Vector3<T> &multiply(const T &scalar);

    inline Vector3<T> &scale(const T &scalar) { return multiply(scalar); }

    Vector3<T> &divide(const T &scalar);

    T dot(const Vector3<T> &other) const;

    Vector3<T> cross(const Vector3<T> &other) const;

    T magnitude() const;

    T magnitudeSquared() const;

    inline Vector3<T> &operator+=(const Vector3 &other) { return add(other); }
    inline Vector3<T> &operator+=(const T &scalar) { return add(scalar); }
    inline Vector3<T> &operator-=(const Vector3 &other) { return subtract(other); }
    inline Vector3<T> &operator-=(const T &scalar) { return subtract(scalar); }
    inline Vector3<T> &operator*=(const T &scalar) { return multiply(scalar); }
    inline Vector3<T> &operator/=(const T &scalar) { return divide(scalar); }

    // Swizzle operations.

    inline Vector3<T> xyz() const { return Vector3<T>(*this); }
    inline Vector3<T> xzy() const { return Vector3<T>(x, z, y); }
    inline Vector3<T> yzx() const { return Vector3<T>(y, z, x); }
    inline Vector3<T> yxz() const { return Vector3<T>(y, x, z); }
    inline Vector3<T> zxy() const { return Vector3<T>(z, x, y); }
    inline Vector3<T> zyx() const { return Vector3<T>(x, y, x); }
  };

  template class _3es_coreAPI Vector3<float>;
  template class _3es_coreAPI Vector3<double>;


  //---------------------------------------------------------------------------
  // Arithmetic operators
  //---------------------------------------------------------------------------

  template <class T>
  inline Vector3<T> operator+(const Vector3<T> &a, const Vector3<T> &b)
  {
    Vector3<T> v(a);
    v.add(b);
    return v;
  }

  template <class T>
  inline Vector3<T> operator+(const Vector3<T> &a, const T &b)
  {
    Vector3<T> v(a);
    v.add(b);
    return v;
  }

  template <class T>
  inline Vector3<T> operator+(const T &a, const Vector3<T> &b) { return b * a; }

  template <class T>
  inline Vector3<T> operator-(const Vector3<T> &a, const Vector3<T> &b)
  {
    Vector3<T> v(a);
    v.subtract(b);
    return v;
  }

  template <class T>
  inline Vector3<T> operator-(const Vector3<T> &a, const T &b)
  {
    Vector3<T> v(a);
    v.subtract(b);
    return v;
  }

  template <class T>
  inline Vector3<T> operator*(const Vector3<T> &a, const T &b)
  {
    Vector3<T> v(a);
    v.multiply(b);
    return v;
  }

  template <class T>
  inline Vector3<T> operator*(const T &a, const Vector3<T> &b) { return b * a; }

  template <class T>
  inline Vector3<T> operator/(const Vector3<T> &a, const T &b)
  {
    Vector3<T> v(a);
    v.divide(b);
    return v;
  }


  template <typename T>
  inline bool Vector3<T>::operator==(const Vector3<T> &other) const
  {
    return x == other.x && y == other.y && z == other.z;
  }


  template <typename T>
  inline bool Vector3<T>::operator!=(const Vector3<T> &other) const
  {
    return x != other.x || y != other.y || z != other.z;
  }


  template <typename T>
  inline bool Vector3<T>::isEqual(const Vector3<T> &other, const T &epsilon) const
  {
    const T distanceSquared = std::abs((*this - other).magnitudeSquared());
    return distanceSquared <= epsilon * epsilon;
  }


  template <typename T>
  inline bool Vector3<T>::isZero(const T &epsilon) const
  {
    return isEqual(zero, epsilon);
  }


  template <typename T>
  inline T Vector3<T>::normalise(const T &epsilon)
  {
    T mag = magnitude();
    if (mag > epsilon)
    {
      divide(mag);
    }
    return mag;
  }


  template <typename T>
  inline Vector3<T> Vector3<T>::normalised(const T &epsilon) const
  {
    T mag = magnitude();
    if (mag > epsilon)
    {
      Vector3<T> v(*this);
      v.divide(mag);
      return v;
    }
    return zero;
  }


  template <typename T>
  inline Vector3<T> &Vector3<T>::add(const Vector3<T> &other)
  {
    x += other.x;
    y += other.y;
    z += other.z;
    return *this;
  }


  template <typename T>
  inline Vector3<T> &Vector3<T>::add(const T &scalar)
  {
    x += scalar;
    y += scalar;
    z += scalar;
    return *this;
  }


  template <typename T>
  inline Vector3<T> &Vector3<T>::subtract(const Vector3<T> &other)
  {
    x -= other.x;
    y -= other.y;
    z -= other.z;
    return *this;
  }


  template <typename T>
  inline Vector3<T> &Vector3<T>::subtract(const T &scalar)
  {
    x -= scalar;
    y -= scalar;
    z -= scalar;
    return *this;
  }


  template <typename T>
  inline Vector3<T> &Vector3<T>::multiply(const T &scalar)
  {
    x *= scalar;
    y *= scalar;
    z *= scalar;
    return *this;
  }


  template <typename T>
  inline Vector3<T> &Vector3<T>::divide(const T &scalar)
  {
    const T div = T(1) / scalar;
    x *= div;
    y *= div;
    z *= div;
    return *this;
  }


  template <typename T>
  inline T Vector3<T>::dot(const Vector3<T> &other) const
  {
    return x * other.x + y * other.y + z * other.z;
  }


  template <typename T>
  inline Vector3<T> Vector3<T>::cross(const Vector3<T> &other) const
  {
    Vector3<T> v;
    v.x = y * other.z - z * other.y;
    v.y = z * other.x - x * other.z;
    v.z = x * other.y - y * other.x;
    return v;
  }


  template <typename T>
  inline T Vector3<T>::magnitude() const
  {
    T mag = magnitudeSquared();
    mag = std::sqrt(mag);
    return mag;
  }


  template <typename T>
  inline T Vector3<T>::magnitudeSquared() const
  {
    return dot(*this);
  }


  template <typename T> const T Vector3<T>::Epsilon = T(1e-6);
  template <typename T> const Vector3<T> Vector3<T>::zero(T(0));
  template <typename T> const Vector3<T> Vector3<T>::one(T(1));
  template <typename T> const Vector3<T> Vector3<T>::axisx(1, 0, 0);
  template <typename T> const Vector3<T> Vector3<T>::axisy(0, 1, 0);
  template <typename T> const Vector3<T> Vector3<T>::axisz(0, 0, 1);
}

#endif // _3ESVECTOR3_H_