3esvector4.h

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

#include "3es-core.h"

#include "3esvector3.h"

namespace tes
{
  template <typename T> class Vector4;

  typedef Vector4<float> Vector4f;
  typedef Vector4<double> Vector4d;

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

    static const T Epsilon;

    static const Vector4<T> zero;
    static const Vector4<T> one;
    static const Vector4<T> axisx;
    static const Vector4<T> axisy;
    static const Vector4<T> axisz;
    static const Vector4<T> axisw;

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

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

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

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

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

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

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

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

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

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

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

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

    T normalise(const T &epsilon = Epsilon);

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

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

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

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

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

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

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

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

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

    T dot3(const Vector4<T> &other) const;

    Vector4<T> cross3(const Vector4<T> &other) const;

    T magnitude() const;

    T magnitudeSquared() const;

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

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

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

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

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

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

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

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

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

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

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

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


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


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


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


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


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


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


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


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


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


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


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


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


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


  template <typename T>
  T Vector4<T>::dot3(const Vector4<T> &other) const
  {
    return x * other.x + y * other.y + z * other.z + w * other.w;
  }


  template <typename T>
  Vector4<T> Vector4<T>::cross3(const Vector4<T> &other) const
  {
    Vector4<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;
    v.w = T(1);
    return v;
  }


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


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


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

#endif // _3ESVECTOR4_H_