Quaternion.h

Go to the documentation of this file.

/*************************************************************************
> File Name: Quaternion.h
> Project Name: CubbyFlow
> Author: Chan-Ho Chris Ohk
> Purpose: Quaternion class defined as q = w + xi + yj + zk.
> Created Time: 2017/03/21
> Copyright (c) 2018, Chan-Ho Chris Ohk
*************************************************************************/
#ifndef CUBBYFLOW_QUATERNION_H
#define CUBBYFLOW_QUATERNION_H

#include <Core/Matrix/Matrix4x4.h>

namespace CubbyFlow
{
    template <typename T>
    class Quaternion
    {
    public:
        static_assert(std::is_floating_point<T>::value, "Quaternion only can be instantiated with floating point types");

        T w;

        T x;

        T y;

        T z;

        // MARK: Constructors
        Quaternion();

        Quaternion(T newW, T newX, T newY, T newZ);

        Quaternion(const std::initializer_list<T>& list);

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

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

        Quaternion(const Vector3<T>& axis0, const Vector3<T>& axis1, const Vector3<T>& axis2);

        explicit Quaternion(const Matrix3x3<T>& m33);

        Quaternion(const Quaternion& other);

        // MARK: Basic setters
        void Set(const Quaternion& other);

        void Set(T newW, T newX, T newY, T newZ);

        void Set(const std::initializer_list<T>& list);

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

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

        void Set(const Vector3<T>& rotationBasis0, const Vector3<T>& rotationBasis1, const Vector3<T>& rotationBasis2);

        void Set(const Matrix3x3<T>& m);

        // MARK: Basic getters
        template <typename U>
        Quaternion<U> CastTo() const;

        Quaternion Normalized() const;

        // MARK: Binary operator methods - new instance = this instance (+) input
        Vector3<T> Mul(const Vector3<T>& v) const;

        Quaternion Mul(const Quaternion& other) const;
        
        T Dot(const Quaternion<T>& other);

        // MARK: Binary operator methods - new instance = input (+) this instance
        Quaternion RMul(const Quaternion& other) const;

        // MARK: Augmented operator methods - this instance (+)= input
        void IMul(const Quaternion& other);

        // MARK: Modifiers
        void SetIdentity();

        void Rotate(T angleInRadians);

        void Normalize();

        // MARK: Complex getters
        Vector3<T> Axis() const;

        T Angle() const;

        void GetAxisAngle(Vector3<T>* axis, T* angle) const;

        Quaternion Inverse() const;

        Matrix3x3<T> Matrix3() const;

        Matrix4x4<T> Matrix4() const;

        T L2Norm() const;

        // MARK: Setter operators
        Quaternion& operator=(const Quaternion& other);

        Quaternion& operator*=(const Quaternion& other);

        // MARK: Getter operators
        T& operator[](size_t i);

        const T& operator[](size_t i) const;

        bool operator==(const Quaternion& other) const;

        bool operator!=(const Quaternion& other) const;

        // MARK: Builders
        static Quaternion MakeIdentity();
    };

    template <typename T>
    Quaternion<T> Slerp(const Quaternion<T>& a, const Quaternion<T>& b, T t);

    template <typename T>
    Vector<T, 3> operator*(const Quaternion<T>& q, const Vector<T, 3>& v);

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

    using QuaternionF = Quaternion<float>;

    using QuaternionD = Quaternion<double>;
}

#include <Core/Math/Quaternion-Impl.h>

#endif