Vector4.hpp

// INFINITY_API_PUBLIC
 
#pragma once
 
#include <Infinity/Types/Core/Value.hpp>
#include <Infinity/Types/Containers/Array.hpp>
 
#include <cstdint>
#include <cmath>
 
namespace Infinity::Types::Math
{
    template<typename T>
    struct INFINITY_API_TEMPLATE t_Vector4
    {
        union
        {
            T value[4];  
            struct
            {
                T x, y, z, w;  
            };
            struct
            {
                T r, g, b, a;  
            };
            struct
            {
                T s, t, p, q;  
            };
        };
 
        constexpr t_Vector4() : value{} {}
 
        constexpr t_Vector4(const t_Vector4& v) : value{v.x, v.y, v.z, v.w} {}
 
        constexpr t_Vector4& operator=(const t_Vector4&) = default;
 
        constexpr t_Vector4(T x, T y, T z, T w) : value{x, y, z, w} {}
 
        template<typename R>
        constexpr explicit t_Vector4(const t_Vector4<R>& v) :
            value{static_cast<T>(v.x), static_cast<T>(v.y), static_cast<T>(v.z), static_cast<T>(v.w)} {}
 
        T& operator[](size_t i) { return value[i]; }
 
        T operator[](size_t i) const { return value[i]; }
 
        void set(T in_x, T in_y, T in_z, T in_w)
        {
            x = in_x;
            y = in_y;
            z = in_z;
            w = in_w;
        }
 
        T* data() { return value; }
 
        const T* data() const { return value; }
 
        template<typename R>
        t_Vector4& operator=(const t_Vector4<R>& rhs)
        {
            value[0] = static_cast<T>(rhs[0]);
            value[1] = static_cast<T>(rhs[1]);
            value[2] = static_cast<T>(rhs[2]);
            value[3] = static_cast<T>(rhs[3]);
            return *this;
        }
 
        inline t_Vector4& operator+=(const t_Vector4& rhs)
        {
            value[0] += rhs.value[0];
            value[1] += rhs.value[1];
            value[2] += rhs.value[2];
            value[3] += rhs.value[3];
            return *this;
        }
 
        inline t_Vector4& operator-=(const t_Vector4& rhs)
        {
            value[0] -= rhs.value[0];
            value[1] -= rhs.value[1];
            value[2] -= rhs.value[2];
            value[3] -= rhs.value[3];
            return *this;
        }
 
        inline t_Vector4& operator*=(T rhs)
        {
            value[0] *= rhs;
            value[1] *= rhs;
            value[2] *= rhs;
            value[3] *= rhs;
            return *this;
        }
 
        inline t_Vector4& operator*=(const t_Vector4& rhs)
        {
            value[0] *= rhs.value[0];
            value[1] *= rhs.value[1];
            value[2] *= rhs.value[2];
            value[3] *= rhs.value[3];
            return *this;
        }
 
        inline t_Vector4& operator/=(T rhs)
        {
            if constexpr (std::is_floating_point_v<T>)
            {
                T inv = static_cast<T>(1.0) / rhs;
                value[0] *= inv;
                value[1] *= inv;
                value[2] *= inv;
                value[3] *= inv;
            }
            else
            {
                value[0] /= rhs;
                value[1] /= rhs;
                value[2] /= rhs;
                value[3] /= rhs;
            }
            return *this;
        }
 
        explicit operator bool() const noexcept { return value[0] != 0.0 || value[1] != 0.0 || value[2] != 0.0 || value[3] != 0.0; }
 
        t_Vector4<T> normalized() const
        {
            float len = length();
            if (len > 1e-6f)
            {
                float invLength = 1.0f / len;
                return t_Vector4<T>(x * invLength, y * invLength, z * invLength, w * invLength);
            }
 
            return t_Vector4<T>(0.0f, 0.0f, 0.0f, 1.0f);
        }
 
        t_Vector4<T> cross(const t_Vector4<T>& other) const
        {
            return t_Vector4<T>(
                y * other.z - z * other.y,
                z * other.x - x * other.z,
                x * other.y - y * other.x,
                0.0f // The w component is typically set to 0 for cross products in 3D space
            );
        }
 
        float length() const
        {
            return std::sqrt(squaredMagnitude());
        }
 
        float magnitude() const
        {
            return std::sqrt(squaredMagnitude());
        }
 
        float squaredMagnitude() const
        {
            return x * x + y * y + z * z + w * w;
        }
 
        float distance(const t_Vector4<T>& other) const
        {
            return (*this - other).magnitude();
        }
 
        float dot(const t_Vector4<T>& other) const
        {
            return x * other.x + y * other.y + z * other.z + w * other.w;
        }
 
        float angle(const t_Vector4<T>& other) const
        {
            float dotProduct = dot(other);
            float lengths = length() * other.length();
            if (lengths == 0.0f) return 0.0f; // Avoid division by zero
            return std::acos(dotProduct / lengths);
        }
 
        t_Vector4<T> abs() const
        {
            if constexpr (std::is_unsigned<T>::value) {
                return *this; // No change for unsigned types
            } else {
                return t_Vector4<T>(std::abs(x), std::abs(y), std::abs(z), std::abs(w));
            }
        }
    };
 
    using Vector4 = t_Vector4<float>;
 
    using Quaternion = t_Vector4<float>;
 
    using Vector4f = t_Vector4<float>;
 
    using Vector4d = t_Vector4<double>;
 
    using Vector4b = t_Vector4<int8_t>;
 
    using Vector4s = t_Vector4<int16_t>;
 
    using Vector4i = t_Vector4<int32_t>;
 
    using Vector4l = t_Vector4<int64_t>;
 
    using Vector4ub = t_Vector4<uint8_t>;
 
    using Vector4us = t_Vector4<uint16_t>;
 
    using Vector4ui = t_Vector4<uint32_t>;
 
    using Vector4ul = t_Vector4<uint64_t>;
 
    template<typename T>
    constexpr bool operator==(const t_Vector4<T>& lhs, const t_Vector4<T>& rhs)
    {
        return lhs[0] == rhs[0] && lhs[1] == rhs[1] && lhs[2] == rhs[2] && lhs[3] == rhs[3];
    }
 
    template<typename T>
    constexpr bool operator!=(const t_Vector4<T>& lhs, const t_Vector4<T>& rhs)
    {
        return lhs[0] != rhs[0] || lhs[1] != rhs[1] || lhs[2] != rhs[2] || lhs[3] != rhs[3];
    }
 
    template<typename T>
    constexpr bool operator<(const t_Vector4<T>& lhs, const t_Vector4<T>& rhs)
    {
        if (lhs[0] < rhs[0]) return true;
        if (lhs[0] > rhs[0]) return false;
        if (lhs[1] < rhs[1]) return true;
        if (lhs[1] > rhs[1]) return false;
        if (lhs[2] < rhs[2]) return true;
        if (lhs[2] > rhs[2]) return false;
        return lhs[3] < rhs[3];
    }
 
    template<typename T>
    constexpr t_Vector4<T> operator-(const t_Vector4<T>& lhs, const t_Vector4<T>& rhs)
    {
        return t_Vector4<T>(lhs[0] - rhs[0], lhs[1] - rhs[1], lhs[2] - rhs[2], lhs[3] - rhs[3]);
    }
 
    template<typename T>
    constexpr t_Vector4<T> operator-(const t_Vector4<T>& v)
    {
        return t_Vector4<T>(-v[0], -v[1], -v[2], -v[3]);
    }
 
    template<typename T>
    constexpr t_Vector4<T> operator+(const t_Vector4<T>& lhs, const t_Vector4<T>& rhs)
    {
        return t_Vector4<T>(lhs[0] + rhs[0], lhs[1] + rhs[1], lhs[2] + rhs[2], lhs[3] + rhs[3]);
    }
 
    template<typename T>
    constexpr t_Vector4<T> operator*(const t_Vector4<T>& lhs, T rhs)
    {
        return t_Vector4<T>(lhs[0] * rhs, lhs[1] * rhs, lhs[2] * rhs, lhs[3] * rhs);
    }
 
    template<typename T>
    constexpr t_Vector4<T> operator*(const t_Vector4<T>& lhs, const t_Vector4<T>& rhs)
    {
        return t_Vector4<T>(lhs[0] * rhs[0], lhs[1] * rhs[1], lhs[2] * rhs[2], lhs[3] * rhs[3]);
    }
 
    template<typename T>
    constexpr t_Vector4<T> operator/(const t_Vector4<T>& lhs, T rhs)
    {
        if constexpr (std::is_floating_point_v<T>)
        {
            T inv = static_cast<T>(1.0) / rhs;
            return t_Vector4<T>(lhs[0] * inv, lhs[1] * inv, lhs[2] * inv, lhs[3] * inv);
        }
        else
        {
            return t_Vector4<T>(lhs[0] / rhs, lhs[1] / rhs, lhs[2] / rhs, lhs[3] / rhs);
        }
    }
 
    template<typename T>
    inline std::ostream& operator<<(std::ostream& out, const t_Vector4<T>& v)
    {
        out << v.x << " " << v.y << " " << v.z << " " << v.w;
        return out;
    }
 
    template<typename T>
    inline std::istream& operator>>(std::istream& in, t_Vector4<T>& v)
    {
        in >> v.x >> v.y >> v.z >> v.w;
        return in;
    }
 
    template<>
    inline std::istream& operator>>(std::istream& in, t_Vector4<uint8_t>& v) {
        int temp_x, temp_y, temp_z, temp_w;
        in >> temp_x >> temp_y >> temp_z >> temp_w;
        
        v.x = static_cast<uint8_t>(temp_x);
        v.y = static_cast<uint8_t>(temp_y);
        v.z = static_cast<uint8_t>(temp_z);
        v.w = static_cast<uint8_t>(temp_w);
        
        return in;
    }
}
 
// Register Value<Vector4> specializations in the type system
INFINITY_TYPE(Infinity::Types::Core::Value<Infinity::Types::Math::Vector4>)
INFINITY_TYPE(Infinity::Types::Core::Value<Infinity::Types::Math::Vector4d>)
INFINITY_TYPE(Infinity::Types::Core::Value<Infinity::Types::Math::Vector4b>)
INFINITY_TYPE(Infinity::Types::Core::Value<Infinity::Types::Math::Vector4s>)
INFINITY_TYPE(Infinity::Types::Core::Value<Infinity::Types::Math::Vector4i>)
INFINITY_TYPE(Infinity::Types::Core::Value<Infinity::Types::Math::Vector4l>)
INFINITY_TYPE(Infinity::Types::Core::Value<Infinity::Types::Math::Vector4ub>)
INFINITY_TYPE(Infinity::Types::Core::Value<Infinity::Types::Math::Vector4us>)
INFINITY_TYPE(Infinity::Types::Core::Value<Infinity::Types::Math::Vector4ui>)
INFINITY_TYPE(Infinity::Types::Core::Value<Infinity::Types::Math::Vector4ul>)
 
// Register Array<Vector4> specializations in the type system
INFINITY_TYPE(Infinity::Types::Containers::Array<Infinity::Types::Math::Vector4>)
INFINITY_TYPE(Infinity::Types::Containers::Array<Infinity::Types::Math::Vector4d>)
INFINITY_TYPE(Infinity::Types::Containers::Array<Infinity::Types::Math::Vector4b>)
INFINITY_TYPE(Infinity::Types::Containers::Array<Infinity::Types::Math::Vector4s>)
INFINITY_TYPE(Infinity::Types::Containers::Array<Infinity::Types::Math::Vector4i>)
INFINITY_TYPE(Infinity::Types::Containers::Array<Infinity::Types::Math::Vector4l>)
INFINITY_TYPE(Infinity::Types::Containers::Array<Infinity::Types::Math::Vector4ub>)
INFINITY_TYPE(Infinity::Types::Containers::Array<Infinity::Types::Math::Vector4us>)
INFINITY_TYPE(Infinity::Types::Containers::Array<Infinity::Types::Math::Vector4ui>)
INFINITY_TYPE(Infinity::Types::Containers::Array<Infinity::Types::Math::Vector4ul>)