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