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

glm/detail/_vectorize.hpp

@@ -1,5 +1,7 @@
 #pragma once
-
+#if GLM_SIMD_CONSTEXPR == 1
+#include "simd_constexpr/_vectorize.hpp"
+#else
 namespace glm{
 namespace detail
 {
@@ -228,3 +230,4 @@ namespace detail
 	};
 }//namespace detail
 }//namespace glm
+#endif

glm/detail/qualifier.hpp

@@ -88,7 +88,77 @@ namespace detail
 			T data[L];
 		} type;
 	};
-
+#if ((defined(__clang__) || defined(__GNUC__)) && (GLM_LANG_CXX20_FLAG & GLM_LANG)) && GLM_SIMD_CONSTEXPR
+#	if GLM_HAS_ALIGNOF
+		template<length_t L, typename T>
+		struct storage<L, T, true>
+		{
+			typedef struct alignas(L * sizeof(T)) type {
+				T data[L];
+			} type;
+		};
+# endif
+	template <typename T>
+	static constexpr size_t requiredAlignment = alignof(T);
+
+	template<typename T>
+	struct __attribute__((packed,aligned(requiredAlignment<T>))) storage<2, T, false>
+	{
+		using VType = std::conditional_t< std::is_same_v<T, bool>, uint8_t, T>;
+		typedef VType type __attribute__((aligned( requiredAlignment<T> ), vector_size(2*sizeof(VType))));
+	};
+	template<typename T>
+	struct __attribute__((packed,aligned(requiredAlignment<T>))) storage<1, T, false>
+	{
+		using VType = std::conditional_t< std::is_same_v<T, bool>, uint8_t, T>;
+		typedef VType type __attribute__((aligned( requiredAlignment<T> ),vector_size(sizeof(VType))));
+	};
+	template<typename T>
+	struct storage<2, T, true>
+	{
+		using VType = std::conditional_t< std::is_same_v<T, bool>, uint8_t, T>;
+		typedef VType type __attribute__((aligned(2*sizeof(VType)),vector_size(2*sizeof(VType))));
+	};
+
+	template<typename T>
+	struct storage<1, T, true>
+	{
+		using VType = std::conditional_t< std::is_same_v<T, bool>, uint8_t, T>;
+		typedef VType type __attribute__((aligned(sizeof(VType)),vector_size(sizeof(VType))));
+	};
+	template <typename T>
+	struct __attribute__((packed,aligned(requiredAlignment<T>))) storage<3, T, false>
+	{
+		typedef struct __attribute__((packed,aligned(requiredAlignment<T>))) type {
+				T data[3];
+			} type;
+	};
+	template <typename T>
+	struct __attribute__((packed,aligned(requiredAlignment<T>))) storage<4, T, false>
+	{
+		using VType = std::conditional_t< std::is_same_v<T, bool>, uint8_t, T>;
+		typedef VType type __attribute__((aligned( requiredAlignment<T> ), vector_size(4*sizeof(VType))));
+	};
+# if (!(GLM_ARCH & GLM_ARCH_SIMD_BIT))
+	template<typename T>
+	struct storage<4, T, true>
+	{
+		using VType = std::conditional_t< std::is_same_v<T, bool>, uint8_t, T>;
+		typedef VType type __attribute__((aligned(4*sizeof(VType)),vector_size(4*sizeof(VType))));
+	};
+	template<typename T>
+	struct storage<3, T, true>
+	{
+		using VType = std::conditional_t< std::is_same_v<T, bool>, uint8_t, T>;
+		typedef VType type __attribute__((aligned(4*sizeof(VType)),vector_size(4*sizeof(VType))));
+	};
+	template<>
+	struct storage<4, bool, true>
+	{
+		typedef uint8_t type  __attribute__((aligned(4*sizeof(uint8_t)),vector_size(4*sizeof(uint8_t))));
+	};
+# endif
+#else
 #	if GLM_HAS_ALIGNOF
 		template<length_t L, typename T>
 		struct storage<L, T, true>
@@ -106,6 +176,7 @@ namespace detail
 			} type;
 		};
 #	endif
+#endif
 
 #	if GLM_ARCH & GLM_ARCH_SSE2_BIT
 	template<>

glm/detail/setup.hpp

@@ -297,7 +297,7 @@
 
 // N2235 Generalized Constant Expressions http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2235.pdf
 // N3652 Extended Constant Expressions http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3652.html
-#if (GLM_ARCH & GLM_ARCH_SIMD_BIT) // Compiler SIMD intrinsics don't support constexpr...
+#if (GLM_ARCH & GLM_ARCH_SIMD_BIT) && GLM_SIMD_CONSTEXPR == 0 // Compiler SIMD intrinsics don't support constexpr...
 #	define GLM_HAS_CONSTEXPR 0
 #elif (GLM_COMPILER & GLM_COMPILER_CLANG)
 #	define GLM_HAS_CONSTEXPR __has_feature(cxx_relaxed_constexpr)
@@ -883,7 +883,7 @@ namespace detail
 #	define GLM_FORCE_ALIGNED_GENTYPES
 #endif
 
-#if GLM_HAS_ALIGNOF && (GLM_LANG & GLM_LANG_CXXMS_FLAG) && (defined(GLM_FORCE_ALIGNED_GENTYPES) || (GLM_CONFIG_SIMD == GLM_ENABLE))
+#if (GLM_HAS_ALIGNOF && (GLM_LANG & GLM_LANG_CXXMS_FLAG) && (defined(GLM_FORCE_ALIGNED_GENTYPES) || (GLM_CONFIG_SIMD == GLM_ENABLE))) || GLM_SIMD_CONSTEXPR
 #	define GLM_CONFIG_ALIGNED_GENTYPES GLM_ENABLE
 #else
 #	define GLM_CONFIG_ALIGNED_GENTYPES GLM_DISABLE

glm/detail/simd_constexpr/_vectorize.hpp

@@ -0,0 +1,92 @@
+#pragma once
+namespace glm{
+namespace detail
+{
+	template<template<length_t L, typename T, qualifier Q> class vec, length_t L, typename R, typename T, qualifier Q>
+	struct functor1
+	{
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR static vec<L, R, Q> call(R (*Func) (T x), vec<L, T, Q> const& v)
+		{
+			vec<L, R, Q> ret{v};
+			#pragma GCC unroll(4)
+			for (int i = 0; i < L; i++) {
+				ret[i] = Func(v[i]);
+			}
+			return ret;
+		}
+	};
+
+
+	template<template<length_t L, typename T, qualifier Q> class vec, length_t L, typename T, qualifier Q>
+	struct functor2
+	{
+		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(T (*Func) (T x, T y), vec<L, T, Q> a, vec<L, T, Q> const& b)
+		{
+			vec<L, T, Q> ret{a};
+			#pragma GCC unroll(4)
+			for (int i = 0; i < L; i++) {
+				ret[i] = Func(a[i], b[i]);
+			}
+			return ret;
+		}
+
+		template<typename Fct>
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR static vec<L, T, Q> call(Fct Func, vec<L, T, Q> a, vec<L, T, Q> const& b)
+		{
+			vec<L, T, Q> ret{a};
+			#pragma GCC unroll(4)
+			for (int i = 0; i < L; i++) {
+				ret[i] = Func(a[i], b[i]);
+			}
+			return ret;
+		}
+	};
+
+	template<template<length_t L, typename T, qualifier Q> class vec, length_t L, typename T, qualifier Q>
+	struct functor2_vec_sca{
+		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(T (*Func) (T x, T y), vec<L, T, Q> a, T b)
+		{
+			vec<L, T, Q> ret{a};
+			#pragma GCC unroll(4)
+			for (int i = 0; i < L; i++) {
+				ret[i] = Func(a[i], b);
+			}
+			return ret;
+		}
+		template<class Fct>
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR static vec<L, T, Q> call(Fct Func, vec<L, T, Q> a, T b)
+		{
+			vec<L, T, Q> ret{a};
+			#pragma GCC unroll(4)
+			for (int i = 0; i < L; i++) {
+				ret[i] = Func(a[i], b);
+			}
+			return ret;
+		}
+	};
+
+	template<length_t L, typename T, qualifier Q>
+	struct functor2_vec_int {
+		GLM_FUNC_QUALIFIER static vec<L, int, Q> call(int (*Func) (T x, int y), vec<L, T, Q> const& a, vec<L, int, Q> b)
+		{
+			vec<L, int, Q> ret{b};
+			#pragma GCC unroll(4)
+			for (int i = 0; i < L; i++) {
+				ret[i] = Func(a[i], b[i]);
+			}
+			return ret;
+		}
+
+		template<class Fct>
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR static vec<L, int, Q> call(Fct Func, vec<L, T, Q> const& a, vec<L, int, Q> b)
+		{
+			vec<L, int, Q> ret{b};
+			#pragma GCC unroll(4)
+			for (int i = 0; i < L; i++) {
+				ret[i] = Func(a[i], b[i]);
+			}
+			return ret;
+		}
+	};
+}//namespace detail
+}//namespace glm