quaternion.h

// =====================================================================================================================
//  fennec, a free and open source game engine
//  Copyright © 2025  Medusa Slockbower
//
//  This program is free software: you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation, either version 3 of the License, or
//  (at your option) any later version.
//
//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with this program.  If not, see <https://www.gnu.org/licenses/>.
// =====================================================================================================================
 
#ifndef FENNEC_MATH_EXT_QUATERNION_H
#define FENNEC_MATH_EXT_QUATERNION_H
 
#include <fennec/math/geometric.h>
#include <fennec/math/vector_base.h>
 
namespace fennec
{
 
template<typename ScalarT> struct quaternion;
 
template<typename genType> using qua = quaternion<genType>;
 
using quat  = qua<float>;
using dquat = qua<double>;
 
 
#ifndef FENNEC_DOXYGEN
template<typename genType>
constexpr genType dot(const qua<genType>& x, const qua<genType>& y) {
    return x.w*y.w + x.x*y.x + x.y*y.y + x.z*y.z;
}
#endif
 
template<typename genType>
constexpr genType sqnorm(const qua<genType>& q) {
    return fennec::dot(q, q);
}
 
template<typename genType>
constexpr genType norm(const qua<genType>& q) {
    return fennec::sqrt(sqnorm(q));
}
 
template<typename genType>
constexpr qua<genType> unit(const qua<genType>& q) {
    genType n = fennec::norm(q);
    return q * (genType(1) / n);
}
 
template<typename genType>
constexpr qua<genType> reciprocal(const qua<genType>& q) {
    return ~q / fennec::sqnorm(q);
}
 
 
template<typename ScalarT>
struct quaternion : detail::vector_base_type<ScalarT, 4>
{
public:
// Typedefs ============================================================================================================
 
    using base_type = detail::vector_base_type<ScalarT, 4>;
    using scalar_t  = ScalarT;
    using quat_t    = quaternion;
    using vec3_t    = vec<scalar_t, 3>;
    using vec4_t    = vec<scalar_t, 4>;
 
    using base_type::data;
    using base_type::x, base_type::y, base_type::z, base_type::w;
 
 
// Constructors ========================================================================================================
 
    constexpr quaternion() {
        data = { 0, 0, 0, 1 };
    }
 
    constexpr quaternion(scalar_t w, scalar_t x, scalar_t y, scalar_t z) {
        data = { x, y, z, w };
    }
 
    constexpr quaternion(scalar_t s, vec3_t v) {
        data = { v.x, v.y, v.z, s };
    }
 
    constexpr quaternion(const vec4_t& v) {
        data = v.data;
    }
 
    template<typename DataT, size_t...IndicesV> requires(sizeof...(IndicesV) == 4)
    constexpr quaternion(const detail::swizzle_storage<DataT, scalar_t, IndicesV...>& s) {
        data[0] = s[0];
        data[1] = s[1];
        data[2] = s[2];
        data[3] = s[3];
    }
 
    constexpr quaternion(const quaternion& q) {
        data = q.data;
    }
 
    constexpr quaternion(quaternion&& q) noexcept {
        data = q.data;
    }
 
 
// Assignment Operators ================================================================================================
 
    constexpr quat_t& operator=(const quat_t& q) {
        data = q.data;
        return *this;
    }
 
    constexpr quat_t& operator=(quat_t&& q) noexcept {
        data = q.data;
        return *this;
    }
 
 
// Comparison Operators ================================================================================================
 
    constexpr friend bool operator==(const quat_t& lhs, const quat_t& rhs) {
        return lhs.data == rhs.data;
    }
 
    constexpr friend bool operator!=(const quat_t& lhs, const quat_t& rhs) {
        return lhs.data != rhs.data;
    }
 
 
// Unary Operators =====================================================================================================
 
    constexpr friend quat_t operator-(const quat_t& rhs) {
        return quat_t(-rhs.w, -rhs.x, -rhs.y, -rhs.z);
    }
 
    constexpr friend quat_t operator~(const quat_t& rhs) {
        return quat_t(rhs.w, -rhs.x, -rhs.y, -rhs.z);
    }
 
 
// Quaternion Scalar Arithmetic Operators ==============================================================================
 
    constexpr friend quat_t operator*(const quat_t& lhs, scalar_t rhs) {
        return quat_t(lhs.w * rhs, lhs.x * rhs, lhs.y * rhs, lhs.z * rhs);
    }
 
    constexpr friend quat_t operator*(scalar_t lhs, const quat_t& rhs) {
        return quat_t(lhs * rhs.w, lhs * rhs.x, lhs * rhs.y, lhs * rhs.z);
    }
 
    constexpr friend quat_t operator/(const quat_t& lhs, scalar_t rhs) {
        return quat_t(lhs.w / rhs, lhs.x / rhs, lhs.y / rhs, lhs.z / rhs);
    }
 
    constexpr friend quat_t operator/(scalar_t lhs, const quat_t& rhs) {
        return quat_t(lhs / rhs.w, lhs / rhs.x, lhs / rhs.y, lhs / rhs.z);
    }
 
 
// Quaternion Scalar Arithmetic Assignment Operators ===================================================================
 
    constexpr friend quat_t& operator*=(quat_t& lhs, scalar_t rhs) {
        lhs.x *= rhs;
        lhs.y *= rhs;
        lhs.z *= rhs;
        lhs.w *= rhs;
        return lhs;
    }
 
    constexpr friend quat_t& operator/=(const quat_t& lhs, scalar_t rhs) {
        lhs.x /= rhs;
        lhs.y /= rhs;
        lhs.z /= rhs;
        lhs.w /= rhs;
        return lhs;
    }
 
 
// Quaternion Vector Arithmetic Operators ==============================================================================
 
    constexpr friend vec3_t operator*(const quat_t& q, const vec3_t& v) {
        const vec3_t u   = q.xyz;
        const vec3_t uv  = fennec::cross(u, v);
        const vec3_t uuv = fennec::cross(u, uv);
        return v + (uv*q.w + uuv) * scalar_t(2);
    }
 
    constexpr friend vec3_t operator*(const vec3_t& v, const quat_t& q) {
        return fennec::reciprocal(q) * v;
    }
 
    constexpr friend vec4_t operator*(const quat_t& q, const vec4_t& v) {
        return vec4_t(q * v.xyz, v.w);
    }
 
    constexpr friend vec4_t operator*(const vec4_t& v, const quat_t& q) {
        return fennec::reciprocal(q) * v;
    }
 
 
// Quaternion Quaternion Arithmetic Operators ==========================================================================
 
    constexpr friend quat_t operator+(const quat_t& lhs, const quat_t& rhs) {
        return quat_t(
            lhs.w + rhs.w,
            lhs.x + rhs.x,
            lhs.y + rhs.y,
            lhs.z + rhs.z
        );
    }
 
    constexpr friend quat_t operator-(const quat_t& lhs, const quat_t& rhs) {
        return quat_t(
            lhs.w - rhs.w,
            lhs.x - rhs.x,
            lhs.y - rhs.y,
            lhs.z - rhs.z
        );
    }
 
    constexpr friend quat_t operator*(const quat_t& lhs, const quat_t& rhs) {
        return quat_t(
            lhs.w*rhs.w - lhs.x*rhs.x - lhs.y*rhs.y - lhs.z * rhs.z,
            lhs.w*rhs.x + lhs.x*rhs.w + lhs.y*rhs.z - lhs.z * rhs.y,
            lhs.w*rhs.y - lhs.x*rhs.z + lhs.y*rhs.w + lhs.z * rhs.x,
            lhs.w*rhs.z - lhs.x*rhs.y - lhs.y*rhs.x + lhs.z * rhs.w
        );
    }
 
 
// Quaternion Quaternion Arithmetic Assignment Operators ===============================================================
 
    constexpr friend quat_t& operator+=(quat_t& lhs, const quat_t& rhs) {
        lhs.w += rhs.w;
        lhs.x += rhs.x;
        lhs.y += rhs.y;
        lhs.z += rhs.z;
        return lhs;
    }
 
    constexpr friend quat_t& operator-=(quat_t& lhs, const quat_t& rhs) {
        lhs.w -= rhs.w;
        lhs.x -= rhs.x;
        lhs.y -= rhs.y;
        lhs.z -= rhs.z;
        return lhs;
    }
 
    constexpr friend quat_t& operator*=(quat_t& lhs, const quat_t& rhs) {
        return lhs = lhs * rhs;
    }
 
private:
 
};
 
}
 
#endif // FENNEC_MATH_EXT_QUATERNION_H