quat.h

Go to the documentation of this file.

#pragma once
 
#include "base/vec3.h"
#include "base/numeric.h"
#include "base/axisangle.h"
#include "base/angle.h"
#include "base/mat4.h"
 
 
namespace eu
{
    struct Q
    {
        float w;
        float x;
        float y;
        float z;
 
        constexpr Q(float aw, const v3& v)
            : w(aw)
            , x(v.x)
            , y(v.y)
            , z(v.z)
        {
        }
 
        [[nodiscard]] static Q from(const AA& aa);
 
        [[nodiscard]] static Q from(const Ypr& ypr);
 
        [[nodiscard]] static Q from_to(const Q& from, const Q& to);
 
        [[nodiscard]] static std::optional<Q> look_at(const v3& from, const v3& to, const n3& up);
 
        [[nodiscard]] static Q look_in_direction(const n3& dir, const n3& up);
 
        void normalize();
 
        [[nodiscard]] Q then_get_rotated(const Q& q) const;
 
        [[nodiscard]] n3 get_rotated(const n3& v) const;
 
        [[nodiscard]] Q get_negated() const;
 
        [[nodiscard]] v3 get_vec_part() const;
 
        [[nodiscard]] Q get_conjugate() const;
 
        [[nodiscard]] Q get_inverse() const;
 
        [[nodiscard]] float get_length() const;
 
        [[nodiscard]] Q get_normalized() const;
 
        [[nodiscard]] n3 get_local_in() const;
 
        [[nodiscard]] n3 get_local_out() const;
 
        [[nodiscard]] n3 get_local_right() const;
 
        [[nodiscard]] n3 get_local_left() const;
 
        [[nodiscard]] n3 get_local_up() const;
 
        [[nodiscard]] n3 get_local_down() const;
 
        void operator*=(float rhs);
        void operator*=(const Q& rhs);
 
        static Q nlerp(const Q& f, float scale, const Q& t);
 
        static Q slerp_fast(const Q& qa, float t, const Q& qb);
 
        static Q slerp(const Q& from, float scale, const Q& to);
    };
 
    constexpr Q q_identity = Q(1, v3(0, 0, 0));
 
    float dot(const Q& lhs, const Q& rhs);
 
    std::string string_from(const Q& v);
 
    Q operator*(const Q& lhs, const Q& rhs);
    Q operator*(float scale, const Q& q);
    Q operator*(const Q& q, float scale);
 
    ADD_CATCH_FORMATTER_DEF(Q)
}
 
ADD_DEFAULT_FORMATTER(eu::Q, std::string, eu::string_from);