quaternion.h

/*
**  UICore
**  Copyright (c) 1997-2015 The UICore Team
**
**  This software is provided 'as-is', without any express or implied
**  warranty.  In no event will the authors be held liable for any damages
**  arising from the use of this software.
**
**  Permission is granted to anyone to use this software for any purpose,
**  including commercial applications, and to alter it and redistribute it
**  freely, subject to the following restrictions:
**
**  1. The origin of this software must not be misrepresented; you must not
**     claim that you wrote the original software. If you use this software
**     in a product, an acknowledgment in the product documentation would be
**     appreciated but is not required.
**  2. Altered source versions must be plainly marked as such, and must not be
**     misrepresented as being the original software.
**  3. This notice may not be removed or altered from any source distribution.
**
**  Note: Some of the libraries UICore may link to may have additional
**  requirements or restrictions.
**
**  File Author(s):
**
**    Mark Page
*/

#pragma once

#include "vec3.h"
#include "angle.h"

namespace uicore
{
    template<typename Type>
    class Quaternionx
    {
    public:
        Type x = Type(0);
        Type y = Type(0);
        Type z = Type(0);

        Type w = Type(1);

        Quaternionx() { }
        Quaternionx(const Quaternionx &other) : x(other.x), y(other.y), z(other.z), w(other.w) { }
        Quaternionx(Type x, Type y, Type z, Type w) : x(x), y(y), z(z), w(w) { }
        Quaternionx(const Vec4<Type> &quat) : x(quat.x), y(quat.y), z(quat.z), w(quat.w) { }
        explicit Quaternionx(const Mat4<Type> &rotation_matrix);

        static Quaternionx<Type> euler(Type x, Type y, Type z, EulerOrder order = EulerOrder::yxz);
        static Quaternionx<Type> euler(const Vec3<Type> &xyz, EulerOrder order = EulerOrder::yxz);
        static Quaternionx<Type> axis_angle(Type angle, const Vec3f &axis);

        static Quaternionx<Type> multiply(const Quaternionx<Type> &quaternion_1, const Quaternionx<Type> &quaternion_2);

        static Quaternionx<Type> rotation_between(Vec3<Type> v0, Vec3<Type> v1);

        static Quaternionx<Type> rotation_between(Vec4<Type> v0, Vec4<Type> v1);

        static Quaternionx<Type> lerp(const Quaternionx<Type> &quaternion_initial, const Quaternionx<Type> &quaternion_final, Type lerp_time);

        static Quaternionx<Type> slerp(const Quaternionx<Type> &quaternion_initial, const Quaternionx<Type> &quaternion_final, Type slerp_time);

        Mat4<Type> to_matrix() const;

        Vec4<Type> to_vec4() const { return Vec4<Type>(x, y, z, w); }

        Type magnitude() const;

        Quaternionx<Type> &rotate(Type angle, const Vec3f &axis);

        Quaternionx<Type> &rotate(Type euler_x, Type euler_y, Type euler_z, EulerOrder order);

        Quaternionx<Type> &normalize();

        Quaternionx<Type> &inverse();

        Vec3<Type> rotate_vector(const Vec3<Type> &v) const;

        Vec4<Type> rotate_vector(const Vec4<Type> &v) const;

        static Quaternionx<Type> normalize(Quaternionx<Type> q) { return q.normalize(); }

        static Quaternionx<Type> inverse(Quaternionx<Type> q) { return q.inverse(); }

        operator Vec4<Type>() const { return to_vec4(); }

        Quaternionx<Type> operator *(const Quaternionx<Type> &mult) const { return Quaternionx<Type>::multiply(*this, mult); }

        Quaternionx<Type> operator *(const Mat4<Type> &matrix) const;

        Vec3<Type> operator *(const Vec3<Type> &v) const { return rotate_vector(v); }
        Vec4<Type> operator *(const Vec4<Type> &v) const { return rotate_vector(v); }

        bool operator<(const Quaternionx<Type> &other) const
        {
            if (x != other.x) return x < other.x;
            else if (y != other.y) return y < other.y;
            else if (z != other.z) return z < other.z;
            else return w < other.w;
        }

        bool operator>(const Quaternionx<Type> &other) const
        {
            if (x != other.x) return x > other.x;
            else if (y != other.y) return y > other.y;
            else if (z != other.z) return z > other.z;
            else return w > other.w;
        }

        bool operator<=(const Quaternionx<Type> &other) const { return *this < other || *this == other; }

        bool operator>=(const Quaternionx<Type> &other) const { return *this > other || *this == other; }

        bool operator==(const Quaternionx<Type> &other) const { return x == other.x && y == other.y && z == other.z && w == other.w; }

        bool operator!=(const Quaternionx<Type> &other) const { return x != other.x || y != other.y || z != other.z || w == other.w; }
    };

    typedef Quaternionx<float> Quaternionf;
    typedef Quaternionx<double> Quaterniond;
}