Quaternion.hpp

Go to the documentation of this file.

// This code is based on Jet framework.
// Copyright (c) 2018 Doyub Kim
// CubbyFlow is voxel-based fluid simulation engine for computer games.
// Copyright (c) 2020 CubbyFlow Team
// Core Part: Chris Ohk, Junwoo Hwang, Jihong Sin, Seungwoo Yoo
// AI Part: Dongheon Cho, Minseo Kim
// We are making my contributions/submissions to this project solely in our
// personal capacity and are not conveying any rights to any intellectual
// property of any third parties.
 
#ifndef CUBBYFLOW_QUATERNION_HPP
#define CUBBYFLOW_QUATERNION_HPP
 
#include <Core/Matrix/Matrix.hpp>
 
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");
 
    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);
 
    Quaternion(Quaternion&& other) noexcept;
 
    ~Quaternion() = default;
 
    Quaternion& operator=(const Quaternion& other);
 
    Quaternion& operator=(Quaternion&& other) noexcept;
 
    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);
 
    template <typename U>
    [[nodiscard]] Quaternion<U> CastTo() const;
 
    [[nodiscard]] Quaternion Normalized() const;
 
    [[nodiscard]] Vector3<T> Mul(const Vector3<T>& v) const;
 
    [[nodiscard]] Quaternion Mul(const Quaternion& other) const;
 
    [[nodiscard]] T Dot(const Quaternion<T>& other) const;
 
    [[nodiscard]] Quaternion RMul(const Quaternion& other) const;
 
    void IMul(const Quaternion& other);
 
    void SetIdentity();
 
    void Rotate(T angleInRadians);
 
    void Normalize();
 
    [[nodiscard]] Vector3<T> Axis() const;
 
    [[nodiscard]] T Angle() const;
 
    void GetAxisAngle(Vector3<T>* axis, T* angle) const;
 
    [[nodiscard]] Quaternion Inverse() const;
 
    [[nodiscard]] Matrix3x3<T> Matrix3() const;
 
    [[nodiscard]] Matrix4x4<T> Matrix4() const;
 
    [[nodiscard]] T L2Norm() const;
 
    Quaternion& operator*=(const Quaternion& other);
 
    T& operator[](size_t i);
 
    const T& operator[](size_t i) const;
 
    bool operator==(const Quaternion& other) const;
 
    bool operator!=(const Quaternion& other) const;
 
    [[nodiscard]] static Quaternion MakeIdentity();
 
    T w;
 
    T x;
 
    T y;
 
    T z;
};
 
template <typename T>
[[nodiscard]] Quaternion<T> Slerp(const Quaternion<T>& a,
                                  const Quaternion<T>& b, T t);
 
template <typename T>
[[nodiscard]] Vector<T, 3> operator*(const Quaternion<T>& q,
                                     const Vector<T, 3>& v);
 
template <typename T>
[[nodiscard]] Quaternion<T> operator*(const Quaternion<T>& a,
                                      const Quaternion<T>& b);
 
using QuaternionF = Quaternion<float>;
 
using QuaternionD = Quaternion<double>;
}  // namespace CubbyFlow
 
#include <Core/Math/Quaternion-Impl.hpp>
 
#endif