Vec.h

#pragma once
 
#include <type_traits>
#include <utility>
#include <cstddef>
 
namespace PashaBibko::Util
{
    /* Excludes the internal namespace from the documentation */
    #ifndef DOXYGEN_HIDE
 
    namespace Internal
    {
        /* General layout of a Vec<T> with just an array of x length */
        template<std::size_t len, typename Ty, typename Enable = void>
        struct VecMembers
        {
            Ty data[len];
 
            template<typename... Args> VecMembers(Args&&... args) : data{ std::forward<Args>(args)... } {}
        };
 
        /* Provides aliases of [X, Y] to indecies of [0, 1] to the array when of length 2 */
        template<std::size_t len, typename Ty>
        struct VecMembers<len, Ty, std::enable_if_t<(len == 2)>>
        {
            union
            {
                struct { Ty x, y; };
                Ty data[2];
            };
 
            template<typename... Args> VecMembers(Args&&... args) : data{ std::forward<Args>(args)... } {}
        };
 
        /* Provides aliases of [X, Y, Z] and [R, G, B] to indecies of [0, 1, 2] to the array when of length 3 */
        template<std::size_t len, typename Ty>
        struct VecMembers<len, Ty, std::enable_if_t<(len == 3)>>
        {
            union
            {
                struct { Ty x, y, z; };
                struct { Ty r, g, b; };
                Ty data[3];
            };
 
            template<typename... Args> VecMembers(Args&&... args) : data{ std::forward<Args>(args)... } {}
        };
 
        /* Provides aliases of [X, Y, Z, Z] and [R, G, B, A] to indecies of [0, 1, 2, 3] to the array when of length 4 */
        template<std::size_t len, typename Ty>
        struct VecMembers<len, Ty, std::enable_if_t<(len == 4)>>
        {
            union
            {
                struct { Ty x, y, z, w; };
                struct { Ty r, g, b, a; };
                Ty data[4];
            };
 
            template<typename... Args> VecMembers(Args&&... args) : data{ std::forward<Args>(args)... } {}
        };
 
        /* Checks all types within a variadic template are the same */
        template<typename Ty, typename... Args> concept AllSameType = (std::is_same_v<Ty, Args> && ...);
 
        /* Checks types can be added together */
        template<typename LhsTy, typename RhsTy>
        concept CanAdd = requires(LhsTy lhs, RhsTy rhs)
        {
            { lhs + rhs } -> std::same_as<decltype(lhs + rhs)>;
        };
 
        /* The result type when two types are added to each other */
        template<typename LhsTy, typename RhsTy>
        using AddResultT = decltype(std::declval<LhsTy>() + std::declval<RhsTy>());
 
        /* Checks two types can be subtracted from each other */
        template<typename LhsTy, typename RhsTy>
        concept CanSub = requires(LhsTy lhs, RhsTy rhs)
        {
            { lhs - rhs } -> std::same_as<decltype(lhs - rhs)>;
        };
 
        /* The result type when two types are subtracted from each other */
        template<typename LhsTy, typename RhsTy>
        using SubResultT = decltype(std::declval<LhsTy>() + std::declval<RhsTy>());
 
        /* Checks two types can be multipled together */
        template<typename LhsTy, typename RhsTy>
        concept CanMul = requires(LhsTy lhs, RhsTy rhs)
        {
            { lhs * rhs } -> std::same_as<decltype(lhs * rhs)>;
        };
 
        /* The result type when two types are multiplied to each other */
        template<typename LhsTy, typename RhsTy>
        using MulResultT = decltype(std::declval<LhsTy>() * std::declval<RhsTy>());
 
        /* Checks two types can be divided from each other */
        template<typename LhsTy, typename RhsTy>
        concept CanDiv = requires(LhsTy lhs, RhsTy rhs)
        {
            { lhs / rhs } -> std::same_as<decltype(lhs + rhs)>;
        };
 
        /* The result type when two types are divided from each other */
        template<typename LhsTy, typename RhsTy>
        using DivResultT = decltype(std::declval<LhsTy>() / std::declval<RhsTy>());
 
        /* Checks the types can be compared equally */
        template<typename LhsTy, typename RhsTy>
        concept CanEqualityCheck = requires(LhsTy lhs, RhsTy rhs)
        {
            { lhs == rhs } -> std::convertible_to<bool>;
            { lhs != rhs } -> std::convertible_to<bool>;
        };
    }
 
    #endif // DOXYGEN_HIDE
 
    template<std::size_t len, typename Ty>
        requires (len != 0 && len != 1) && std::is_copy_constructible_v<Ty>
    struct Vec : public Internal::VecMembers<len, Ty>
    {
        template<typename = std::enable_if_t<std::is_default_constructible_v<Ty>>>
        Vec()
        {
            for (std::size_t index = 0; index < len; index++)
                this->data[index] = Ty{};
        }
 
        explicit Vec(const Ty& value)
        {
            for (std::size_t index = 0; index < len; index++)
                this->data[index] = value;
        }
 
        template<typename... Args> requires Internal::AllSameType<Ty, Args...> && (sizeof...(Args) == len)
        explicit Vec(Args&&... args) : Internal::VecMembers<len, Ty>(std::forward<Args>(args)...) {}
 
        Ty& operator[](std::size_t index) { return this->data[index]; }
 
        Ty* begin() noexcept { return this->data; }
 
        Ty* end() { return this->data + len; }
 
        /* Hides const versions of functions as they do not need to be documented twice */
        #ifndef DOXYGEN_HIDE
 
        const Ty& operator[](std::size_t index) const { return this->data[index]; }
 
        const Ty* begin() const noexcept { return this->data; }
        const Ty* cbegin() const noexcept { return this->data; }
 
        const Ty* end() const noexcept { return this->data + len; }
        const Ty* cend() const noexcept { return this->data + len; }
 
        #endif // DOXYGEN_HIDE
 
        template<typename OtherTy>
            requires Internal::CanAdd<Ty, OtherTy> && std::is_same_v<Ty, Internal::AddResultT<Ty, OtherTy>>
        Vec& operator+= (const Vec<len, OtherTy>& other)
        {
            for (std::size_t index = 0; index < len; index++)
                this->data[index] += other[index];
 
            return *this;
        }
 
        template<typename OtherTy>
            requires Internal::CanSub<Ty, OtherTy> && std::is_same_v<Ty, Internal::SubResultT<Ty, OtherTy>>
        Vec& operator-= (const Vec<len, OtherTy>& other)
        {
            for (std::size_t index = 0; index < len; index++)
                this->data[index] += other[index];
 
            return *this;
        }
 
        template<typename OtherTy>
            requires Internal::CanMul<Ty, OtherTy> && std::is_same_v<Ty, Internal::MulResultT<Ty, OtherTy>>
        Vec& operator*= (const Vec<len, OtherTy>& other)
        {
            for (std::size_t index = 0; index < len; index++)
                this->data[index] += other[index];
 
            return *this;
        }
 
        template<typename OtherTy>
            requires Internal::CanDiv<Ty, OtherTy> && std::is_same_v<Ty, Internal::DivResultT<Ty, OtherTy>>
        Vec& operator/= (const Vec<len, OtherTy>& other)
        {
            for (std::size_t index = 0; index < len; index++)
                this->data[index] += other[index];
 
            return *this;
        }
    };
 
    template<std::size_t len, typename LhsTy, typename RhsTy, typename ResTy = Internal::AddResultT<LhsTy, RhsTy>>
        requires Internal::CanAdd<LhsTy, RhsTy>
    Vec<len, ResTy> operator+ (const Vec<len, LhsTy>& lhs, const Vec<len, RhsTy>& rhs)
    {
        return [&]<std::size_t... index>(std::index_sequence<index...>) { return Vec<len, ResTy>{ (lhs[index] + rhs[index])... }; } (std::make_index_sequence<len>{});
    }
 
    template<std::size_t len, typename LhsTy, typename RhsTy, typename ResTy = Internal::SubResultT<LhsTy, RhsTy>>
        requires Internal::CanSub<LhsTy, RhsTy>
    Vec<len, ResTy> operator- (const Vec<len, LhsTy>& lhs, const Vec<len, RhsTy>& rhs)
    {
        return [&]<std::size_t... index>(std::index_sequence<index...>) { return Vec<len, ResTy>{ (lhs[index] - rhs[index])... }; } (std::make_index_sequence<len>{});
    }
 
    template<std::size_t len, typename LhsTy, typename RhsTy, typename ResTy = Internal::MulResultT<LhsTy, RhsTy>>
        requires Internal::CanMul<LhsTy, RhsTy>
    Vec<len, ResTy> operator* (const Vec<len, LhsTy>& lhs, const Vec<len, RhsTy>& rhs)
    {
        return [&]<std::size_t... index>(std::index_sequence<index...>) { return Vec<len, ResTy>{ (lhs[index] * rhs[index])... }; } (std::make_index_sequence<len>{});
    }
 
    template<std::size_t len, typename LhsTy, typename RhsTy, typename ResTy = Internal::SubResultT<LhsTy, RhsTy>>
        requires Internal::CanDiv<LhsTy, RhsTy>
    Vec<len, ResTy> operator/ (const Vec<len, LhsTy>& lhs, const Vec<len, RhsTy>& rhs)
    {
        return [&]<std::size_t... index>(std::index_sequence<index...>) { return Vec<len, ResTy>{ (lhs[index] / rhs[index])... }; } (std::make_index_sequence<len>{});
    }
 
    template<std::size_t len, typename LhsTy, typename RhsTy>
        requires Internal::CanEqualityCheck<LhsTy, RhsTy>
    bool operator== (const Vec<len, LhsTy>& lhs, const Vec<len, RhsTy>& rhs)
    {
        for (std::size_t index = 0; index < len; index++)
        {
            if (lhs[index] != rhs[index])
                return false;
        }
 
        return true;
    }
 
    template<std::size_t len, typename LhsTy, typename RhsTy>
        requires Internal::CanEqualityCheck<LhsTy, RhsTy>
    bool operator!= (const Vec<len, LhsTy>& lhs, const Vec<len, RhsTy>& rhs)
    {
        for (size_t index = 0; index < len; index++)
        {
            if (lhs[index] == rhs[index])
                return false;
        }
 
        return true;
    }
 
    /* Hides using aliases to avoid uneccesary bloat in doxygen documentation */
    /* The types are mentoined in the description of Vec<len, T>              */
    #ifndef DOXYGEN_HIDE
 
    template<typename Ty = float>
    using Vec2 = Vec<2, Ty>;
 
    template<typename Ty = float>
    using Vec3 = Vec<3, Ty>;
 
    template<typename Ty = float>
    using Vec4 = Vec<4, Ty>;
 
    using Vec2s = Vec3<short>;
    using Vec2i = Vec3<int>;
    using Vec2u = Vec3<unsigned int>;
    using Vec2l = Vec3<long>;
    using Vec2d = Vec3<double>;
 
    using Vec3s = Vec3<short>;
    using Vec3i = Vec3<int>;
    using Vec3u = Vec3<unsigned int>;
    using Vec3l = Vec3<long>;
    using Vec3d = Vec3<double>;
 
    using Vec3s = Vec3<short>;
    using Vec3i = Vec3<int>;
    using Vec3u = Vec3<unsigned int>;
    using Vec3l = Vec3<long>;
    using Vec3d = Vec3<double>;
 
    #endif // DOXYGEN_HIDE
}