Vector2.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_Vector2
    {
        union
        {
            T value[2];  
            struct
            {
                T x, y;  
            };
            struct
            {
                T r, g;  
            };
            struct
            {
                T s, t;  
            };
        };
 
        constexpr t_Vector2() : value{} {}
 
        constexpr t_Vector2(const t_Vector2& v) : value{v.x, v.y} {}
 
        constexpr t_Vector2& operator=(const t_Vector2&) = default;
 
        constexpr t_Vector2(T x, T y) : value{x, y} {}
 
        template<typename R>
        constexpr explicit t_Vector2(const t_Vector2<R>& v) :
            value{static_cast<T>(v.x), static_cast<T>(v.y)} {}
 
        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)
        {
            x = in_x;
            y = in_y;
        }
 
        T* data() { return value; }
 
        const T* data() const { return value; }
 
        template<typename R>
        t_Vector2& operator=(const t_Vector2<R>& rhs)
        {
            value[0] = static_cast<T>(rhs[0]);
            value[1] = static_cast<T>(rhs[1]);
            return *this;
        }
 
        inline t_Vector2& operator+=(const t_Vector2& rhs)
        {
            value[0] += rhs.value[0];
            value[1] += rhs.value[1];
            return *this;
        }
 
        inline t_Vector2& operator-=(const t_Vector2& rhs)
        {
            value[0] -= rhs.value[0];
            value[1] -= rhs.value[1];
            return *this;
        }
 
        inline t_Vector2& operator*=(T rhs)
        {
            value[0] *= rhs;
            value[1] *= rhs;
            return *this;
        }
 
        inline t_Vector2& operator*=(const t_Vector2& rhs)
        {
            value[0] *= rhs.value[0];
            value[1] *= rhs.value[1];
            return *this;
        }
 
        inline t_Vector2& 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;
            }
            else
            {
                value[0] /= rhs;
                value[1] /= rhs;
            }
            return *this;
        }
 
        explicit operator bool() const noexcept { return value[0] != 0.0 || value[1] != 0.0; }
 
        t_Vector2<T> normalized() const
        {
            float len = length();
            if (len == 0.0f) return t_Vector2<T>(0, 0);
            return t_Vector2<T>(x / len, y / len);
        }
 
        t_Vector2<T> cross(const t_Vector2<T>& other) const
        {
            return t_Vector2<T>(y * other.x - x * other.y, x * other.y - y * other.x);
        }
 
        float length() const
        {
            return std::sqrt(squaredMagnitude());
        }
 
        float magnitude() const
        {
            return std::sqrt(squaredMagnitude());
        }
 
        float squaredMagnitude() const
        {
            return x * x + y * y;
        }
 
        float distance(const t_Vector2<T>& other) const
        {
            return (*this - other).magnitude();
        }
 
        float dot(const t_Vector2<T>& other) const
        {
            return x * other.x + y * other.y;
        }
 
        float angle(const t_Vector2<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_Vector2<T> abs() const
        {
            if constexpr (std::is_unsigned<T>::value) {
                return *this; // No change for unsigned types
            } else {
                return t_Vector2<T>(std::abs(x), std::abs(y));
            }
        }
    };
 
    using Vector2 = t_Vector2<float>;
 
    using Vector2f = t_Vector2<float>;
 
    using Vector2d = t_Vector2<double>;
 
    using Vector2b = t_Vector2<int8_t>;
 
    using Vector2s = t_Vector2<int16_t>;
 
    using Vector2i = t_Vector2<int32_t>;
 
    using Vector2l = t_Vector2<int64_t>;
 
    using Vector2ub = t_Vector2<uint8_t>;
 
    using Vector2us = t_Vector2<uint16_t>;
 
    using Vector2ui = t_Vector2<uint32_t>;
 
    using Vector2ul = t_Vector2<uint64_t>;
 
    template<typename T>
    constexpr bool operator==(const t_Vector2<T>& lhs, const t_Vector2<T>& rhs)
    {
        return lhs[0] == rhs[0] && lhs[1] == rhs[1];
    }
 
    template<typename T>
    constexpr bool operator!=(const t_Vector2<T>& lhs, const t_Vector2<T>& rhs)
    {
        return lhs[0] != rhs[0] || lhs[1] != rhs[1];
    }
 
    template<typename T>
    constexpr bool operator<(const t_Vector2<T>& lhs, const t_Vector2<T>& rhs)
    {
        if (lhs[0] < rhs[0]) return true;
        if (lhs[0] > rhs[0]) return false;
        return lhs[1] < rhs[1];
    }
 
    template<typename T>
    constexpr t_Vector2<T> operator-(const t_Vector2<T>& lhs, const t_Vector2<T>& rhs)
    {
        return t_Vector2<T>(lhs[0] - rhs[0], lhs[1] - rhs[1]);
    }
 
    template<typename T>
    constexpr t_Vector2<T> operator-(const t_Vector2<T>& v)
    {
        return t_Vector2<T>(-v[0], -v[1]);
    }
 
    template<typename T>
    constexpr t_Vector2<T> operator+(const t_Vector2<T>& lhs, const t_Vector2<T>& rhs)
    {
        return t_Vector2<T>(lhs[0] + rhs[0], lhs[1] + rhs[1]);
    }
 
    template<typename T>
    constexpr t_Vector2<T> operator*(const t_Vector2<T>& lhs, T rhs)
    {
        return t_Vector2<T>(lhs[0] * rhs, lhs[1] * rhs);
    }
 
    template<typename T>
    constexpr t_Vector2<T> operator*(const t_Vector2<T>& lhs, const t_Vector2<T>& rhs)
    {
        return t_Vector2<T>(lhs[0] * rhs[0], lhs[1] * rhs[1]);
    }
 
    template<typename T>
    constexpr t_Vector2<T> operator/(const t_Vector2<T>& lhs, T rhs)
    {
        if constexpr (std::is_floating_point_v<T>)
        {
            T inv = static_cast<T>(1.0) / rhs;
            return t_Vector2<T>(lhs[0] * inv, lhs[1] * inv);
        }
        else
        {
            return t_Vector2<T>(lhs[0] / rhs, lhs[1] / rhs);
        }
    }
 
    template<typename T>
    inline std::ostream& operator<<(std::ostream& out, const t_Vector2<T>& v)
    {
        out << v.x << " " << v.y;
        return out;
    }
 
    template<typename T>
    inline std::istream& operator>>(std::istream& in, t_Vector2<T>& v)
    {
        in >> v.x >> v.y;
        return in;
    }
 
    template<>
    inline std::istream& operator>>(std::istream& in, t_Vector2<uint8_t>& v) {
        int temp_x, temp_y;
        in >> temp_x >> temp_y;
        
        v.x = static_cast<uint8_t>(temp_x);
        v.y = static_cast<uint8_t>(temp_y);
        
        return in;
    }
 
}
 
// Register Value<Vector2> specializations in the type system
INFINITY_TYPE(Infinity::Types::Core::Value<Infinity::Types::Math::Vector2>)
INFINITY_TYPE(Infinity::Types::Core::Value<Infinity::Types::Math::Vector2d>)
INFINITY_TYPE(Infinity::Types::Core::Value<Infinity::Types::Math::Vector2b>)
INFINITY_TYPE(Infinity::Types::Core::Value<Infinity::Types::Math::Vector2s>)
INFINITY_TYPE(Infinity::Types::Core::Value<Infinity::Types::Math::Vector2i>)
INFINITY_TYPE(Infinity::Types::Core::Value<Infinity::Types::Math::Vector2l>)
INFINITY_TYPE(Infinity::Types::Core::Value<Infinity::Types::Math::Vector2ub>)
INFINITY_TYPE(Infinity::Types::Core::Value<Infinity::Types::Math::Vector2us>)
INFINITY_TYPE(Infinity::Types::Core::Value<Infinity::Types::Math::Vector2ui>)
INFINITY_TYPE(Infinity::Types::Core::Value<Infinity::Types::Math::Vector2ul>)
 
// Register Array<Vector2> specializations in the type system
INFINITY_TYPE(Infinity::Types::Containers::Array<Infinity::Types::Math::Vector2>)
INFINITY_TYPE(Infinity::Types::Containers::Array<Infinity::Types::Math::Vector2d>)
INFINITY_TYPE(Infinity::Types::Containers::Array<Infinity::Types::Math::Vector2b>)
INFINITY_TYPE(Infinity::Types::Containers::Array<Infinity::Types::Math::Vector2s>)
INFINITY_TYPE(Infinity::Types::Containers::Array<Infinity::Types::Math::Vector2i>)
INFINITY_TYPE(Infinity::Types::Containers::Array<Infinity::Types::Math::Vector2l>)
INFINITY_TYPE(Infinity::Types::Containers::Array<Infinity::Types::Math::Vector2ub>)
INFINITY_TYPE(Infinity::Types::Containers::Array<Infinity::Types::Math::Vector2us>)
INFINITY_TYPE(Infinity::Types::Containers::Array<Infinity::Types::Math::Vector2ui>)
INFINITY_TYPE(Infinity::Types::Containers::Array<Infinity::Types::Math::Vector2ul>)