Vector3.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_Vector3
    {
        union
        {
            T value[3];  
            struct
            {
                T x, y, z;  
            };
            struct
            {
                T r, g, b;  
            };
            struct
            {
                T s, t, p;  
            };
        };
 
        constexpr t_Vector3() : value{} {}
 
        constexpr t_Vector3(const t_Vector3& v) : value{v.x, v.y, v.z} {}
 
        constexpr t_Vector3& operator=(const t_Vector3&) = default;
 
        constexpr t_Vector3(T x, T y, T z) : value{x, y, z} {}
 
        template<typename R>
        constexpr explicit t_Vector3(const t_Vector3<R>& v) :
            value{static_cast<T>(v.x), static_cast<T>(v.y), static_cast<T>(v.z)} {}
 
        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)
        {
            x = in_x;
            y = in_y;
            z = in_z;
        }
 
        T* data() { return value; }
 
        const T* data() const { return value; }
 
        template<typename R>
        t_Vector3& operator=(const t_Vector3<R>& rhs)
        {
            value[0] = static_cast<T>(rhs[0]);
            value[1] = static_cast<T>(rhs[1]);
            value[2] = static_cast<T>(rhs[2]);
            return *this;
        }
 
        inline t_Vector3& operator+=(const t_Vector3& rhs)
        {
            value[0] += rhs.value[0];
            value[1] += rhs.value[1];
            value[2] += rhs.value[2];
            return *this;
        }
 
        inline t_Vector3& operator-=(const t_Vector3& rhs)
        {
            value[0] -= rhs.value[0];
            value[1] -= rhs.value[1];
            value[2] -= rhs.value[2];
            return *this;
        }
 
        inline t_Vector3& operator*=(T rhs)
        {
            value[0] *= rhs;
            value[1] *= rhs;
            value[2] *= rhs;
            return *this;
        }
 
        inline t_Vector3& operator*=(const t_Vector3& rhs)
        {
            value[0] *= rhs.value[0];
            value[1] *= rhs.value[1];
            value[2] *= rhs.value[2];
            return *this;
        }
 
        inline t_Vector3& 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;
            }
            else
            {
                value[0] /= rhs;
                value[1] /= rhs;
                value[2] /= rhs;
            }
            return *this;
        }
 
        explicit operator bool() const noexcept { return value[0] != 0.0 || value[1] != 0.0 || value[2] != 0.0; }
 
        t_Vector3<T> normalized() const
        {
            float len = length();
            if (len == 0.0f) return t_Vector3<T>(0, 0, 0);
            return t_Vector3<T>(x / len, y / len, z / len);
        }
 
        t_Vector3<T> cross(const t_Vector3<T>& other) const
        {
            return t_Vector3<T>(
                y * other.z - z * other.y,
                z * other.x - x * other.z,
                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 + z * z;
        }
 
        float distance(const t_Vector3<T>& other) const
        {
            return (*this - other).magnitude();
        }
 
        float dot(const t_Vector3<T>& other) const
        {
            return x * other.x + y * other.y + z * other.z;
        }
 
        float angle(const t_Vector3<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_Vector3<T> abs() const
        {
            if constexpr (std::is_unsigned<T>::value) {
                return *this; // No change for unsigned types
            } else {
                return t_Vector3<T>(std::abs(x), std::abs(y), std::abs(z));
            }
        }
 
        static constexpr t_Vector3<T> zero() { return t_Vector3<T>((T)0.0f, (T)0.0f, (T)0.0f); }
 
        static constexpr t_Vector3<T> identity() { return t_Vector3<T>((T)0.0f, (T)0.0f, (T)0.0f); }
 
        static constexpr t_Vector3<T> left() { return t_Vector3<T>((T)-1.0f, (T)0.0f, (T)0.0f); }
 
        static constexpr t_Vector3<T> right() { return t_Vector3<T>((T)1.0f, (T)0.0f, (T)0.0f); }
 
        static constexpr t_Vector3<T> up() { return t_Vector3<T>((T)0.0f, (T)1.0f, (T)0.0f); }
 
        static constexpr t_Vector3<T> down() { return t_Vector3<T>((T)0.0f, (T)-1.0f, (T)0.0f); }
 
        static constexpr t_Vector3<T> front() { return t_Vector3<T>((T)0.0f, (T)0.0f, (T)1.0f); }
 
        static constexpr t_Vector3<T> back() { return t_Vector3<T>((T)0.0f, (T)0.0f, (T)-1.0f); }
    };
 
    using Vector3 = t_Vector3<float>;
 
    using Vector3f = t_Vector3<float>;
 
    using Vector3d = t_Vector3<double>;
 
    using Vector3b = t_Vector3<int8_t>;
 
    using Vector3s = t_Vector3<int16_t>;
 
    using Vector3i = t_Vector3<int32_t>;
 
    using Vector3l = t_Vector3<int64_t>;
 
    using Vector3ub = t_Vector3<uint8_t>;
 
    using Vector3us = t_Vector3<uint16_t>;
 
    using Vector3ui = t_Vector3<uint32_t>;
 
    using Vector3ul = t_Vector3<uint64_t>;
 
    template<typename T>
    constexpr bool operator==(const t_Vector3<T>& lhs, const t_Vector3<T>& rhs)
    {
        return lhs[0] == rhs[0] && lhs[1] == rhs[1] && lhs[2] == rhs[2];
    }
 
    template<typename T>
    constexpr bool operator!=(const t_Vector3<T>& lhs, const t_Vector3<T>& rhs)
    {
        return lhs[0] != rhs[0] || lhs[1] != rhs[1] || lhs[2] != rhs[2];
    }
 
    template<typename T>
    constexpr bool operator<(const t_Vector3<T>& lhs, const t_Vector3<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;
        return lhs[2] < rhs[2];
    }
 
    template<typename T>
    constexpr t_Vector3<T> operator-(const t_Vector3<T>& lhs, const t_Vector3<T>& rhs)
    {
        return t_Vector3<T>(lhs[0] - rhs[0], lhs[1] - rhs[1], lhs[2] - rhs[2]);
    }
 
    template<typename T>
    constexpr t_Vector3<T> operator-(const t_Vector3<T>& v)
    {
        return t_Vector3<T>(-v[0], -v[1], -v[2]);
    }
 
    template<typename T>
    constexpr t_Vector3<T> operator+(const t_Vector3<T>& lhs, const t_Vector3<T>& rhs)
    {
        return t_Vector3<T>(lhs[0] + rhs[0], lhs[1] + rhs[1], lhs[2] + rhs[2]);
    }
 
    template<typename T>
    constexpr t_Vector3<T> operator*(const t_Vector3<T>& lhs, T rhs)
    {
        return t_Vector3<T>(lhs[0] * rhs, lhs[1] * rhs, lhs[2] * rhs);
    }
 
    template<typename T>
    constexpr t_Vector3<T> operator*(const t_Vector3<T>& lhs, const t_Vector3<T>& rhs)
    {
        return t_Vector3<T>(lhs[0] * rhs[0], lhs[1] * rhs[1], lhs[2] * rhs[2]);
    }
 
    template<typename T>
    constexpr t_Vector3<T> operator/(const t_Vector3<T>& lhs, T rhs)
    {
        if constexpr (std::is_floating_point_v<T>)
        {
            T inv = static_cast<T>(1.0) / rhs;
            return t_Vector3<T>(lhs[0] * inv, lhs[1] * inv, lhs[2] * inv);
        }
        else
        {
            return t_Vector3<T>(lhs[0] / rhs, lhs[1] / rhs, lhs[2] / rhs);
        }
    }
 
    template<typename T>
    inline std::ostream& operator<<(std::ostream& out, const t_Vector3<T>& v)
    {
        out << v.x << " " << v.y << " " << v.z;
        return out;
    }
 
    template<typename T>
    inline std::istream& operator>>(std::istream& in, t_Vector3<T>& v)
    {
        in >> v.x >> v.y >> v.z;
        return in;
    }
 
    template<>
    inline std::istream& operator>>(std::istream& in, t_Vector3<uint8_t>& v) {
        int temp_x, temp_y, temp_z;
        in >> temp_x >> temp_y >> temp_z;
        
        v.x = static_cast<uint8_t>(temp_x);
        v.y = static_cast<uint8_t>(temp_y);
        v.z = static_cast<uint8_t>(temp_z);
        return in;
    }
 
}
 
// Register Value<Vector3> specializations in the type system
INFINITY_TYPE(Infinity::Types::Core::Value<Infinity::Types::Math::Vector3>)
INFINITY_TYPE(Infinity::Types::Core::Value<Infinity::Types::Math::Vector3d>)
INFINITY_TYPE(Infinity::Types::Core::Value<Infinity::Types::Math::Vector3b>)
INFINITY_TYPE(Infinity::Types::Core::Value<Infinity::Types::Math::Vector3s>)
INFINITY_TYPE(Infinity::Types::Core::Value<Infinity::Types::Math::Vector3i>)
INFINITY_TYPE(Infinity::Types::Core::Value<Infinity::Types::Math::Vector3l>)
INFINITY_TYPE(Infinity::Types::Core::Value<Infinity::Types::Math::Vector3ub>)
INFINITY_TYPE(Infinity::Types::Core::Value<Infinity::Types::Math::Vector3us>)
INFINITY_TYPE(Infinity::Types::Core::Value<Infinity::Types::Math::Vector3ui>)
INFINITY_TYPE(Infinity::Types::Core::Value<Infinity::Types::Math::Vector3ul>)
 
// Register Array<Vector3> specializations in the type system
INFINITY_TYPE(Infinity::Types::Containers::Array<Infinity::Types::Math::Vector3>)
INFINITY_TYPE(Infinity::Types::Containers::Array<Infinity::Types::Math::Vector3d>)
INFINITY_TYPE(Infinity::Types::Containers::Array<Infinity::Types::Math::Vector3b>)
INFINITY_TYPE(Infinity::Types::Containers::Array<Infinity::Types::Math::Vector3s>)
INFINITY_TYPE(Infinity::Types::Containers::Array<Infinity::Types::Math::Vector3i>)
INFINITY_TYPE(Infinity::Types::Containers::Array<Infinity::Types::Math::Vector3l>)
INFINITY_TYPE(Infinity::Types::Containers::Array<Infinity::Types::Math::Vector3ub>)
INFINITY_TYPE(Infinity::Types::Containers::Array<Infinity::Types::Math::Vector3us>)
INFINITY_TYPE(Infinity::Types::Containers::Array<Infinity::Types::Math::Vector3ui>)
INFINITY_TYPE(Infinity::Types::Containers::Array<Infinity::Types::Math::Vector3ul>)