3esquaternion.h

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

#include "3es-core.h"

#include "3esvector3.h"

namespace tes
{
  template <typename T>
  class Quaternion
  {
  public:
    union
    {
      struct
      {
        T x, y, z, w;
      };
      T q[4];
    };

    static const Quaternion<T> identity;

    inline Quaternion() {}

    inline Quaternion(bool) { *this = identity; }

    inline Quaternion(const Quaternion<T> &other) : x(other.x), y(other.y), z(other.z), w(other.w) {}
    template <typename Q>
    inline Quaternion(const Quaternion<Q> &other) : x(T(other.x)), y(T(other.y)), z(T(other.z)), w(T(other.w)) {}
    inline Quaternion(const T &x, const T &y, const T &z, const T &w) : x(x), y(y), z(z), w(w) {}
    inline Quaternion(const Vector3<T> &v, const T &w) : x(v.x), y(v.y), z(v.z), w(w) {}
    inline Quaternion(const T *array4) : x(array4[0]), y(array4[1]), z(array4[2]), w(array4[3]) {}

    Quaternion(const Vector3<T> &from, const Vector3<T> &to);

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

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

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

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

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

    bool isIdentity();

    void getAxisAngle(Vector3<T> &axis, T &angle) const;

    Quaternion<T> &setAxisAngle(const Vector3<T> &axis, const T &angle);

    Quaternion<T> &invert();

    Quaternion<T> inverse() const;

    Quaternion<T> &conjugate();

    Quaternion<T> conjugated() const;

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

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

    T magnitude() const;

    T magnitudeSquared() const;

    T dot(const Quaternion<T> other) const;

    Vector3<T> transform(const Vector3<T> &v) const;

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

    static Quaternion<T> slerp(const Quaternion<T> &from, const Quaternion<T> &to, const T &t);

    Quaternion<T> operator *= (const Quaternion<T> &other);
    inline Quaternion<T> operator *= (const T &scalar) { return multiply(scalar); }
  };


  template <typename T>
  Quaternion<T> operator * (const Quaternion<T> &a, const Quaternion<T> &b);

  template <typename T>
  Vector3<T> operator * (const Quaternion<T> &a, const Vector3<T> &v);

  typedef Quaternion<float> Quaternionf;
  typedef Quaternion<double> Quaterniond;

  template class _3es_coreAPI Quaternion<float>;
  template class _3es_coreAPI Quaternion<double>;
}

#include "3esquaternion.inl"

#endif // _3ESQUATERNION_H_