vec4.hpp

Go to the documentation of this file.

#pragma once
 
#include "vec.hpp"
#pragma warning(push)
#pragma warning(disable : 4201)
namespace mal_math
{
    template <Primitive T>
    struct vec<4, T>
    {
        static_assert(!std::is_const_v<T>);
        using type = T;
        static constexpr size_t size = 4;
        constexpr vec() = default;
        template <Primitive U>
        constexpr vec(U value);
        template <Primitive A, Primitive B, Primitive C, Primitive D>
        constexpr vec(A a, B b, C c, D d);
        template <typename... U>
        constexpr vec(U... data);
        constexpr vec(std::array<T, size> const &arr) : data{ arr } {}
        constexpr vec(std::array<T, size> &&arr) : data{ std::move(arr) } {}
        constexpr static vec<4, T> zero() noexcept { return vec<4, T>(0); }
        constexpr void reset() noexcept;
 
        template <typename U>
        constexpr vec<size, T> &operator=(_detail::rvec<size, U> const &b)
        {
            for (size_t i = 0; i < size; i++)
            {
                data[i] = b.data[i];
            }
            return *this;
        }
        constexpr vec<size, T> &operator=(_detail::rvec<size, U> const &b) {…}
 
        template <typename U>
        constexpr vec<size, T> &operator=(vec<size, U> const &b)
        {
            for (size_t i = 0; i < size; i++)
            {
                data[i] = b.data[i];
            }
            return *this;
        }
        constexpr vec<size, T> &operator=(vec<size, U> const &b) {…}
 
        [[nodiscard]] constexpr vec<4, T> const &operator+() const noexcept;
        [[nodiscard]] constexpr vec<4, T> operator-() const noexcept;
 
        template <Primitive U>
        constexpr vec<4, T> &operator+=(U const value) noexcept;
        template <Primitive U>
        constexpr vec<4, T> &operator-=(U const value) noexcept;
        template <Primitive U>
        constexpr vec<4, T> &operator*=(U const value) noexcept;
        template <Primitive U>
        constexpr vec<4, T> &operator/=(U const value) noexcept;
        template <Primitive U>
        constexpr vec<4, T> &operator%=(U const value) noexcept;
        template <AnyVec U>
        constexpr vec<4, T> &operator+=(U const &other) noexcept requires(size == U::size);
        template <AnyVec U>
        constexpr vec<4, T> &operator-=(U const &other) noexcept requires(size == U::size);
        template <AnyVec U>
        constexpr vec<4, T> &operator*=(U const &other) noexcept requires(size == U::size);
        template <AnyVec U>
        constexpr vec<4, T> &operator/=(U const &other) noexcept requires(size == U::size);
        template <AnyVec U>
        constexpr vec<4, T> &operator%=(U const &other) noexcept requires(size == U::size);
        
        [[nodiscard]] constexpr T &operator[](size_t i);
        [[nodiscard]] constexpr T const &operator[](size_t i) const;
 
        union
        {
            struct
            {
                union
                {
                    T x, r, s;
                };
                union
                {
                    T y, g, t;
                };
                union
                {
                    T z, b, p;
                };
                union
                {
                    T w, a, q;
                };
            };
            std::array<T, size> data;
            vec<3, T> xyz;
            struct
            {
                T x_anonymous_padding_;
                vec<2, T> yz;
            };
            struct
            {
                vec<2, T> xy;
                vec<2, T> zw;
            };
            struct
            {
                T x_anonymous_padding__;
                vec<2, T> yzw;
            };
        };
        static_assert(sizeof(data) == size * sizeof(T));
 
    private:
        template <Primitive _>
        static constexpr size_t get_parameter_pack_size();
        template <class V>
        static constexpr size_t get_parameter_pack_size();
        template <typename A, typename B, typename... C>
        static constexpr size_t get_parameter_pack_size();
 
 
        template <Primitive U>
        constexpr void unpack_data(size_t offset, U u);
        template <class V>
        constexpr void unpack_data(size_t offset, V vec);
        template <typename A, typename B, typename... C>
        constexpr void unpack_data(size_t offset, A a, B b, C... c);
    };
    struct vec<4, T> {…};
}; // namespace mal_math
 
#pragma warning(pop)
#include "vec4.inl"