TQuaternion.h

Go to the documentation of this file.

#pragma once
#include <math/TVector3D.h>
 
namespace sf
{
 
#pragma option push pack(1)
 
template<typename T>
class TQuaternion
{
  public:
    typedef T value_type;
 
    TQuaternion() = default;
 
    TQuaternion(const TQuaternion&);
 
    TQuaternion(T real, const TVector3D<T>& imag);
 
    TQuaternion(const TVector3D<T>& axis, T angle);
 
    TQuaternion(T real_w, T imag_x, T imag_y, T imag_z);
 
    TQuaternion& assign(T real_w, T imag_x, T imag_y, T imag_z);
    TQuaternion& assign(const TQuaternion&);
 
    TQuaternion& operator=(const TQuaternion&);
 
    enum EElement : size_t
    {
      realW = 0,
      imagX = 1,
      imagY = 2,
      imagZ = 3
    };
 
    T& operator[](size_t);
 
    const T& operator[](size_t) const;
 
    T real() const;
 
    T& real();
 
    TVector3D<T> imaginary() const;
 
    T w() const;
 
    T& w();
 
    T x() const;
 
    T& x();
 
    T y() const;
 
    T& y();
 
    T z() const;
 
    T& z();
 
    TQuaternion conjugate() const;
 
    TQuaternion inverse() const;
 
    TQuaternion& invert();
 
    TQuaternion& normalize();
 
    TQuaternion normalized() const;
 
    T magnitudeSqr() const;
 
    T magnitude() const;
 
    TMatrix44<T> toMatrix(TMatrix44<T>&) const;
 
    TMatrix44<T> toMatrix() const;
 
    TQuaternion& fromMatrix(const T[4][4]);
    TVector3D<T> transform(TVector3D<T> v) const;
 
    TQuaternion operator-() const;
 
    TQuaternion& operator+=(const TQuaternion&);
 
    TQuaternion& operator-=(const TQuaternion&);
 
    TQuaternion& operator*=(const TQuaternion&);
 
    TQuaternion& operator/=(const TQuaternion&);
 
    TQuaternion& operator^=(const TQuaternion&);
 
    TQuaternion& operator*=(T c);
 
    TQuaternion& operator/=(T c);
 
    TQuaternion operator*(T) const;
 
    TQuaternion operator/(T) const;
 
    bool isEqual(const TQuaternion& quat, T tol = tolerance) const;
 
    bool operator==(const TQuaternion&) const;
 
    bool operator!=(const TQuaternion&) const;
 
    TQuaternion squared() const;
 
    TQuaternion log() const;
 
    TQuaternion exp() const;
 
    TQuaternion interpolate(const TQuaternion& q, T t) const;
 
    TQuaternion interpolateLogarithmic(const TQuaternion& q, T t) const;
 
    std::string toString() const;
 
    TQuaternion& fromString(const std::string& s) noexcept(false);
 
    static constexpr auto tolerance = TVector3D<T>::tolerance;
 
  protected:
    union data_type
    {
        T array[4];
        struct quat_type
        {
            T w;
            T x;
            T y;
            T z;
        } q;
    } _data{1, 0, 0, 0};
};
 
template<typename T>
TQuaternion<T> operator+(const TQuaternion<T>& lhs, const TQuaternion<T>& rhs)
{
  return TQuaternion<T>(lhs) += rhs;
}
 
template<typename T>
TQuaternion<T> operator-(const TQuaternion<T>& lhs, const TQuaternion<T>& rhs)
{
  return TQuaternion<T>(lhs) -= rhs;
}
 
template<typename T>
TQuaternion<T> operator*(const TQuaternion<T>& lhs, const TQuaternion<T>& rhs)
{
  return TQuaternion<T>(lhs) *= rhs;
}
 
template<typename T>
TQuaternion<T> operator/(const TQuaternion<T>& lhs, const TQuaternion<T>& rhs)
{
  return TQuaternion<T>(lhs) /= rhs;
}
 
template<typename T>
TQuaternion<T> operator*(T c, const TQuaternion<T>& quat)
{
  return {c * quat.w(), c * quat.x(), c * quat.y(), c * quat.z()};
}
 
template<typename T>
std::ostream& operator<<(std::ostream& os, const TQuaternion<T>& quat)
{
  return os << quat.toString();
}
 
template<typename T>
std::istream& operator>>(std::istream& is, TQuaternion<T>& quat) noexcept(false)
{
  std::string s;
  constexpr auto delimiter = ')';
  std::getline(is, s, delimiter);
  quat.fromString(s.append(1, delimiter));
  return is;
}
 
}// namespace sf
 
// Include all inlined functions and template implementations.
#include <math/TQuaternion.hpp>