wip: constexpr vec (constructors & operators) when using simd

[sharkautarch]

Yes this is creating a whole new vec implementation, because trying to add std::is_constant_evaluated() while also making both constexpr and simd work well, and also maintain backwards compatibility would be too complicated to incorporate into the pre-existing vec classes.

oh also this is only compatible with gcc and clang, because it makes use of gcc’s vector extension for simd in vec’s comstructors (for when std::is_constant_evaluated() = false)
This is because it allows me to write one simd construction function that works for all vec lengths (and I will be adding support for use w/ packed vecs soon)
support for use/ packed vecs & conversion between packed and aligned vecs works now

I don't intend this separate vec implementation to make the pre-existing vec implementations deprecated, this is just the most straightforward way to make constexpr work well w/ simd, without making the entire codebase unreadable

[sharkautarch]

Todo:

• Add all the operators to this vec struct
• Edit the setup headers so that the simd define bits are enabled when using the c++20 vec class
• Add support for packed vec types by changing the gcc vec attributes to __attribute__((vector_size(sizeof(T)*L), aligned(alignof(data_t))))
• Add support for converting a packed vec to an aligned vec & vice versa (I’ll probably just use a non-constexpr constructor for this to make things simpler)
  ^ after adding support for packed vecs, now I’m pretty sure that the current constructors should now already allow converting between packed and unpacked vecs

[sharkautarch]

I did a small amount of testing, (though only with aligned highp vec4), so far things are seeming to work OK~~, except:~~

When swizzling w/ .y (etc), passing stuff to c-style va_arg functions via a direct swizzle expression (ex: printf("%f\n", v.y); prints 0.000 no matter what) is broken
I think it is because of default conversions that are specific to only c-style va_arg functions:
https://en.cppreference.com/w/cpp/language/variadic_arguments
Edit: I fixed the aforementioned issue

[sharkautarch]

New feature added: swizzling functions (enabled by default)
They leverage the compiler intrinsic (this is done for both packed and aligned vecs) __builtin_shufflevector() so that the swizzle functions will get optimized into simd shuffle/blend instructions.

Tho you have to specify at least two swizzle members, max N swizzle members for vec of length N, and you can’t have duplicate members (you can’t swizzle vec1’s because that’d be silly). Example: v.yzx(), v.gbr()

[sharkautarch]

Major improvements to this PR:

• All operators for this vec class are now able to be compile-time evaluated
• Swizzling functions now support duplicated components (EX: v.xxyy())
• Only available when compiling w/ clang: swizzling w/ don't-care components, where you can specify lanes that you won't use, which can sometimes allow the compiler to use either a lower latency or higher throughput swizzling instruction (EX: v.Xyzz())
• New method added to this vec class for doing simd blends between two vectors: template <std::array mask> vec<L,T,Q> blend(vec<L,T,Q> rhs) Use it like: auto v3 = v1.blend<{0,1,0,1}>(v2); //v3 = {v1[0], v2[1], v0[2], v1[3]}. On x86_64 w/ sse or avx, this method should just compile down to a single simd instruction