Removed initializer list C++98 workarounds

glm/detail/qualifier.hpp

@@ -36,22 +36,20 @@ namespace glm
 	template<length_t C, length_t R, typename T, qualifier Q = defaultp> struct mat;
 	template<typename T, qualifier Q = defaultp> struct qua;
 
-#	if GLM_HAS_TEMPLATE_ALIASES
-		template <typename T, qualifier Q = defaultp> using tvec1 = vec<1, T, Q>;
-		template <typename T, qualifier Q = defaultp> using tvec2 = vec<2, T, Q>;
-		template <typename T, qualifier Q = defaultp> using tvec3 = vec<3, T, Q>;
-		template <typename T, qualifier Q = defaultp> using tvec4 = vec<4, T, Q>;
-		template <typename T, qualifier Q = defaultp> using tmat2x2 = mat<2, 2, T, Q>;
-		template <typename T, qualifier Q = defaultp> using tmat2x3 = mat<2, 3, T, Q>;
-		template <typename T, qualifier Q = defaultp> using tmat2x4 = mat<2, 4, T, Q>;
-		template <typename T, qualifier Q = defaultp> using tmat3x2 = mat<3, 2, T, Q>;
-		template <typename T, qualifier Q = defaultp> using tmat3x3 = mat<3, 3, T, Q>;
-		template <typename T, qualifier Q = defaultp> using tmat3x4 = mat<3, 4, T, Q>;
-		template <typename T, qualifier Q = defaultp> using tmat4x2 = mat<4, 2, T, Q>;
-		template <typename T, qualifier Q = defaultp> using tmat4x3 = mat<4, 3, T, Q>;
-		template <typename T, qualifier Q = defaultp> using tmat4x4 = mat<4, 4, T, Q>;
-		template <typename T, qualifier Q = defaultp> using tquat = qua<T, Q>;
-#	endif
+	template <typename T, qualifier Q = defaultp> using tvec1 = vec<1, T, Q>;
+	template <typename T, qualifier Q = defaultp> using tvec2 = vec<2, T, Q>;
+	template <typename T, qualifier Q = defaultp> using tvec3 = vec<3, T, Q>;
+	template <typename T, qualifier Q = defaultp> using tvec4 = vec<4, T, Q>;
+	template <typename T, qualifier Q = defaultp> using tmat2x2 = mat<2, 2, T, Q>;
+	template <typename T, qualifier Q = defaultp> using tmat2x3 = mat<2, 3, T, Q>;
+	template <typename T, qualifier Q = defaultp> using tmat2x4 = mat<2, 4, T, Q>;
+	template <typename T, qualifier Q = defaultp> using tmat3x2 = mat<3, 2, T, Q>;
+	template <typename T, qualifier Q = defaultp> using tmat3x3 = mat<3, 3, T, Q>;
+	template <typename T, qualifier Q = defaultp> using tmat3x4 = mat<3, 4, T, Q>;
+	template <typename T, qualifier Q = defaultp> using tmat4x2 = mat<4, 2, T, Q>;
+	template <typename T, qualifier Q = defaultp> using tmat4x3 = mat<4, 3, T, Q>;
+	template <typename T, qualifier Q = defaultp> using tmat4x4 = mat<4, 4, T, Q>;
+	template <typename T, qualifier Q = defaultp> using tquat = qua<T, Q>;
 
 namespace detail
 {

glm/detail/setup.hpp

@@ -2,6 +2,7 @@
 
 #include <cassert>
 #include <cstddef>
+#include <type_traits>
 
 #define GLM_VERSION_MAJOR 1
 #define GLM_VERSION_MINOR 1
@@ -93,20 +94,8 @@
 #	define GLM_LANG 0
 #elif defined(GLM_FORCE_CXX20)
 #	define GLM_LANG (GLM_LANG_CXX20 | GLM_LANG_EXT)
-#	define GLM_LANG_STL11_FORCED
 #elif defined(GLM_FORCE_CXX17)
 #	define GLM_LANG (GLM_LANG_CXX17 | GLM_LANG_EXT)
-#	define GLM_LANG_STL11_FORCED
-#elif defined(GLM_FORCE_CXX14)
-#	define GLM_LANG (GLM_LANG_CXX14 | GLM_LANG_EXT)
-#	define GLM_LANG_STL11_FORCED
-#elif defined(GLM_FORCE_CXX11)
-#	define GLM_LANG (GLM_LANG_CXX11 | GLM_LANG_EXT)
-#	define GLM_LANG_STL11_FORCED
-#elif defined(GLM_FORCE_CXX03)
-#	define GLM_LANG (GLM_LANG_CXX03 | GLM_LANG_EXT)
-#elif defined(GLM_FORCE_CXX98)
-#	define GLM_LANG (GLM_LANG_CXX98 | GLM_LANG_EXT)
 #else
 #	if GLM_COMPILER & GLM_COMPILER_VC && defined(_MSVC_LANG)
 #		if GLM_COMPILER >= GLM_COMPILER_VC15_7
@@ -128,14 +117,6 @@
 #		define GLM_LANG (GLM_LANG_CXX20 | GLM_LANG_EXT)
 #	elif __cplusplus == 201703L || GLM_LANG_PLATFORM == 201703L
 #		define GLM_LANG (GLM_LANG_CXX17 | GLM_LANG_EXT)
-#	elif __cplusplus == 201402L || __cplusplus == 201406L || __cplusplus == 201500L || GLM_LANG_PLATFORM == 201402L
-#		define GLM_LANG (GLM_LANG_CXX14 | GLM_LANG_EXT)
-#	elif __cplusplus == 201103L || GLM_LANG_PLATFORM == 201103L
-#		define GLM_LANG (GLM_LANG_CXX11 | GLM_LANG_EXT)
-#	elif defined(__INTEL_CXX11_MODE__) || defined(_MSC_VER) || defined(__GXX_EXPERIMENTAL_CXX0X__)
-#		define GLM_LANG (GLM_LANG_CXX0X | GLM_LANG_EXT)
-#	elif __cplusplus == 199711L
-#		define GLM_LANG (GLM_LANG_CXX98 | GLM_LANG_EXT)
 #	else
 #		define GLM_LANG (0 | GLM_LANG_EXT)
 #	endif
@@ -145,67 +126,7 @@
 // Has of C++ features
 
 // N2672 Initializer lists http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2672.htm
-#if GLM_COMPILER & GLM_COMPILER_CLANG
-#	define GLM_HAS_INITIALIZER_LISTS __has_feature(cxx_generalized_initializers)
-#elif GLM_LANG & GLM_LANG_CXX11_FLAG
-#	define GLM_HAS_INITIALIZER_LISTS 1
-#else
-#	define GLM_HAS_INITIALIZER_LISTS ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\
-		((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC15)) || \
-		((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_COMPILER >= GLM_COMPILER_INTEL14)) || \
-		((GLM_COMPILER & GLM_COMPILER_CUDA)) || \
-		((GLM_COMPILER & GLM_COMPILER_HIP))))
-#endif
-
-// N2544 Unrestricted unions http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2544.pdf
-#if GLM_COMPILER & GLM_COMPILER_CLANG
-#	define GLM_HAS_UNRESTRICTED_UNIONS __has_feature(cxx_unrestricted_unions)
-#elif GLM_LANG & GLM_LANG_CXX11_FLAG
-#	define GLM_HAS_UNRESTRICTED_UNIONS 1
-#else
-#	define GLM_HAS_UNRESTRICTED_UNIONS (GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\
-		(GLM_COMPILER & GLM_COMPILER_VC) || \
-		((GLM_COMPILER & GLM_COMPILER_CUDA)) || \
-		((GLM_COMPILER & GLM_COMPILER_HIP)))
-#endif
-
-// N2346
-#if GLM_COMPILER & GLM_COMPILER_CLANG
-#	define GLM_HAS_DEFAULTED_FUNCTIONS __has_feature(cxx_defaulted_functions)
-#elif GLM_LANG & GLM_LANG_CXX11_FLAG
-#	define GLM_HAS_DEFAULTED_FUNCTIONS 1
-#else
-#	define GLM_HAS_DEFAULTED_FUNCTIONS ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\
-		((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC12)) || \
-		((GLM_COMPILER & GLM_COMPILER_INTEL)) || \
-		(GLM_COMPILER & GLM_COMPILER_CUDA)) || \
-		((GLM_COMPILER & GLM_COMPILER_HIP)))
-#endif
-
-// N2118
-#if GLM_COMPILER & GLM_COMPILER_CLANG
-#	define GLM_HAS_RVALUE_REFERENCES __has_feature(cxx_rvalue_references)
-#elif GLM_LANG & GLM_LANG_CXX11_FLAG
-#	define GLM_HAS_RVALUE_REFERENCES 1
-#else
-#	define GLM_HAS_RVALUE_REFERENCES ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\
-		((GLM_COMPILER & GLM_COMPILER_VC)) || \
-		((GLM_COMPILER & GLM_COMPILER_CUDA)) || \
-		((GLM_COMPILER & GLM_COMPILER_HIP))))
-#endif
-
-// N2258 http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2258.pdf
-#if GLM_COMPILER & GLM_COMPILER_CLANG
-#	define GLM_HAS_TEMPLATE_ALIASES __has_feature(cxx_alias_templates)
-#elif GLM_LANG & GLM_LANG_CXX11_FLAG
-#	define GLM_HAS_TEMPLATE_ALIASES 1
-#else
-#	define GLM_HAS_TEMPLATE_ALIASES ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\
-		((GLM_COMPILER & GLM_COMPILER_INTEL)) || \
-		((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC12)) || \
-		((GLM_COMPILER & GLM_COMPILER_CUDA)) || \
-		((GLM_COMPILER & GLM_COMPILER_HIP))))
-#endif
+#define GLM_HAS_INITIALIZER_LISTS 1
 
 // 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
@@ -339,13 +260,9 @@
 #define GLM_FUNC_QUALIFIER GLM_CUDA_FUNC_DEF GLM_INLINE
 
 // Do not use CUDA function qualifiers on CUDA compiler when functions are made default
-#if GLM_HAS_DEFAULTED_FUNCTIONS
-#	define GLM_DEFAULTED_FUNC_DECL
-#	define GLM_DEFAULTED_FUNC_QUALIFIER GLM_INLINE
-#else
-#	define GLM_DEFAULTED_FUNC_DECL GLM_FUNC_DISCARD_DECL
-#	define GLM_DEFAULTED_FUNC_QUALIFIER GLM_FUNC_QUALIFIER
-#endif//GLM_HAS_DEFAULTED_FUNCTIONS
+#define GLM_DEFAULTED_FUNC_DECL
+#define GLM_DEFAULTED_FUNC_QUALIFIER GLM_INLINE
+
 #if !defined(GLM_FORCE_CTOR_INIT)
 #	define GLM_DEFAULTED_DEFAULT_CTOR_DECL
 #	define GLM_DEFAULTED_DEFAULT_CTOR_QUALIFIER GLM_DEFAULTED_FUNC_QUALIFIER
@@ -483,37 +400,11 @@ namespace glm
 #	endif
 }//namespace glm
 
-///////////////////////////////////////////////////////////////////////////////////
-// constexpr
-
-#if GLM_HAS_CONSTEXPR
-#	define GLM_CONFIG_CONSTEXP GLM_ENABLE
-
-	namespace glm
-	{
-		template<typename T, std::size_t N>
-		constexpr std::size_t countof(T const (&)[N])
-		{
-			return N;
-		}
-	}//namespace glm
-#	define GLM_COUNTOF(arr) glm::countof(arr)
-#elif defined(_MSC_VER)
-#	define GLM_CONFIG_CONSTEXP GLM_DISABLE
-
-#	define GLM_COUNTOF(arr) _countof(arr)
-#else
-#	define GLM_CONFIG_CONSTEXP GLM_DISABLE
-
-#	define GLM_COUNTOF(arr) sizeof(arr) / sizeof(arr[0])
-#endif
-
 ///////////////////////////////////////////////////////////////////////////////////
 // uint
 
 #include <cstdint>
 
-
 namespace glm{
 namespace detail
 {
@@ -594,21 +485,6 @@ namespace detail
 #	define GLM_CONFIG_XYZW_ONLY GLM_DISABLE
 #endif
 
-///////////////////////////////////////////////////////////////////////////////////
-// Configure the use of defaulted initialized types
-
-#define GLM_CTOR_INIT_DISABLE		0
-#define GLM_CTOR_INITIALIZER_LIST	1
-#define GLM_CTOR_INITIALISATION		2
-
-#if defined(GLM_FORCE_CTOR_INIT) && GLM_HAS_INITIALIZER_LISTS
-#	define GLM_CONFIG_CTOR_INIT GLM_CTOR_INITIALIZER_LIST
-#elif defined(GLM_FORCE_CTOR_INIT) && !GLM_HAS_INITIALIZER_LISTS
-#	define GLM_CONFIG_CTOR_INIT GLM_CTOR_INITIALISATION
-#else
-#	define GLM_CONFIG_CTOR_INIT GLM_CTOR_INIT_DISABLE
-#endif
-
 ///////////////////////////////////////////////////////////////////////////////////
 // Use SIMD instruction sets
 
@@ -619,21 +495,22 @@ namespace detail
 #endif
 
 ///////////////////////////////////////////////////////////////////////////////////
-// Configure the use of defaulted function
+// Configure the use of defaulted initialized types
 
-#if GLM_HAS_DEFAULTED_FUNCTIONS
-#	define GLM_CONFIG_DEFAULTED_FUNCTIONS GLM_ENABLE
-#	define GLM_DEFAULT = default
+#if defined(GLM_FORCE_CTOR_INIT)
+#	define GLM_CONFIG_CTOR_INIT GLM_ENABLE
 #else
-#	define GLM_CONFIG_DEFAULTED_FUNCTIONS GLM_DISABLE
-#	define GLM_DEFAULT
+#	define GLM_CONFIG_CTOR_INIT GLM_DISABLE
 #endif
 
-#if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INIT_DISABLE && GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_ENABLE
-#	define GLM_CONFIG_DEFAULTED_DEFAULT_CTOR GLM_ENABLE
+///////////////////////////////////////////////////////////////////////////////////
+// Configure the use of defaulted function
+
+#define GLM_DEFAULT = default
+
+#if GLM_CONFIG_CTOR_INIT == GLM_DISABLE
 #	define GLM_DEFAULT_CTOR GLM_DEFAULT
 #else
-#	define GLM_CONFIG_DEFAULTED_DEFAULT_CTOR GLM_DISABLE
 #	define GLM_DEFAULT_CTOR
 #endif
 
@@ -751,7 +628,7 @@ namespace detail
 #	if (GLM_LANG & GLM_LANG_CXX20_FLAG) && (GLM_LANG & GLM_LANG_EXT)
 #		pragma message("GLM: C++ 20 with extensions")
 #	elif (GLM_LANG & GLM_LANG_CXX20_FLAG)
-#		pragma message("GLM: C++ 2A")
+#		pragma message("GLM: C++ 20")
 #	elif (GLM_LANG & GLM_LANG_CXX17_FLAG) && (GLM_LANG & GLM_LANG_EXT)
 #		pragma message("GLM: C++ 17 with extensions")
 #	elif (GLM_LANG & GLM_LANG_CXX17_FLAG)

glm/detail/type_mat2x2.hpp

@@ -25,7 +25,7 @@ namespace glm
 		// -- Accesses --
 
 		typedef length_t length_type;
-		GLM_FUNC_DECL static GLM_CONSTEXPR length_type length() { return 2; }
+		GLM_FUNC_DECL static constexpr length_type length() { return 2; }
 
 		GLM_FUNC_DECL GLM_CONSTEXPR col_type & operator[](length_type i) GLM_NOEXCEPT;
 		GLM_FUNC_DECL GLM_CONSTEXPR col_type const& operator[](length_type i) const GLM_NOEXCEPT;
@@ -33,6 +33,7 @@ namespace glm
 		// -- Constructors --
 
 		GLM_DEFAULTED_DEFAULT_CTOR_DECL GLM_CONSTEXPR mat() GLM_DEFAULT_CTOR;
+		GLM_CTOR_DECL mat(mat<2, 2, T, Q> const& m) = default;
 		template<qualifier P>
 		GLM_CTOR_DECL mat(mat<2, 2, T, P> const& m);
 
@@ -72,24 +73,26 @@ namespace glm
 
 		// -- Unary arithmetic operators --
 
+		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<2, 2, T, Q>& operator=(mat<2, 2, T, Q> const& m) = default;
+
 		template<typename U>
-		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<2, 2, T, Q> & operator=(mat<2, 2, U, Q> const& m);
+		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<2, 2, T, Q>& operator=(mat<2, 2, U, Q> const& m);
 		template<typename U>
-		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<2, 2, T, Q> & operator+=(U s);
+		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<2, 2, T, Q>& operator+=(U s);
 		template<typename U>
-		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<2, 2, T, Q> & operator+=(mat<2, 2, U, Q> const& m);
+		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<2, 2, T, Q>& operator+=(mat<2, 2, U, Q> const& m);
 		template<typename U>
-		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<2, 2, T, Q> & operator-=(U s);
+		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<2, 2, T, Q>& operator-=(U s);
 		template<typename U>
-		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<2, 2, T, Q> & operator-=(mat<2, 2, U, Q> const& m);
+		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<2, 2, T, Q>& operator-=(mat<2, 2, U, Q> const& m);
 		template<typename U>
-		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<2, 2, T, Q> & operator*=(U s);
+		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<2, 2, T, Q>& operator*=(U s);
 		template<typename U>
-		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<2, 2, T, Q> & operator*=(mat<2, 2, U, Q> const& m);
+		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<2, 2, T, Q>& operator*=(mat<2, 2, U, Q> const& m);
 		template<typename U>
-		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<2, 2, T, Q> & operator/=(U s);
+		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<2, 2, T, Q>& operator/=(U s);
 		template<typename U>
-		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<2, 2, T, Q> & operator/=(mat<2, 2, U, Q> const& m);
+		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<2, 2, T, Q>& operator/=(mat<2, 2, U, Q> const& m);
 
 		// -- Increment and decrement operators --
 

glm/detail/type_mat2x2.inl

@@ -4,44 +4,23 @@ namespace glm
 {
 	// -- Constructors --
 
-#	if GLM_CONFIG_DEFAULTED_DEFAULT_CTOR == GLM_DISABLE
+#	if GLM_CONFIG_CTOR_INIT == GLM_ENABLE
 		template<typename T, qualifier Q>
 		GLM_DEFAULTED_DEFAULT_CTOR_QUALIFIER GLM_CONSTEXPR mat<2, 2, T, Q>::mat()
-#			if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALIZER_LIST
-				: value{col_type(1, 0), col_type(0, 1)}
-#			endif
-		{
-#			if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALISATION
-				this->value[0] = col_type(1, 0);
-				this->value[1] = col_type(0, 1);
-#			endif
-		}
+			: value{col_type(1, 0), col_type(0, 1)}
+		{}
 #	endif
 
 	template<typename T, qualifier Q>
 	template<qualifier P>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 2, T, Q>::mat(mat<2, 2, T, P> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0]), col_type(m[1])}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = m[0];
-			this->value[1] = m[1];
-#		endif
-	}
+		: value{col_type(m[0]), col_type(m[1])}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 2, T, Q>::mat(T scalar)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(scalar, 0), col_type(0, scalar)}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(scalar, 0);
-			this->value[1] = col_type(0, scalar);
-#		endif
-	}
+		: value{col_type(scalar, 0), col_type(0, scalar)}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 2, T, Q>::mat
@@ -49,27 +28,13 @@ namespace glm
 		T const& x0, T const& y0,
 		T const& x1, T const& y1
 	)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(x0, y0), col_type(x1, y1)}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(x0, y0);
-			this->value[1] = col_type(x1, y1);
-#		endif
-	}
+		: value{col_type(x0, y0), col_type(x1, y1)}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 2, T, Q>::mat(col_type const& v0, col_type const& v1)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{v0, v1}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = v0;
-			this->value[1] = v1;
-#		endif
-	}
+		: value{v0, v1}
+	{}
 
 	// -- Conversion constructors --
 
@@ -80,139 +45,62 @@ namespace glm
 		X1 const& x1, Y1 const& y1,
 		X2 const& x2, Y2 const& y2
 	)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(static_cast<T>(x1), value_type(y1)), col_type(static_cast<T>(x2), value_type(y2)) }
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(static_cast<T>(x1), value_type(y1));
-			this->value[1] = col_type(static_cast<T>(x2), value_type(y2));
-#		endif
-	}
+		: value{col_type(static_cast<T>(x1), value_type(y1)), col_type(static_cast<T>(x2), value_type(y2)) }
+	{}
 
 	template<typename T, qualifier Q>
 	template<typename V1, typename V2>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 2, T, Q>::mat(vec<2, V1, Q> const& v1, vec<2, V2, Q> const& v2)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(v1), col_type(v2)}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(v1);
-			this->value[1] = col_type(v2);
-#		endif
-	}
+		: value{col_type(v1), col_type(v2)}
+	{}
 
 	// -- mat2x2 matrix conversions --
 
 	template<typename T, qualifier Q>
 	template<typename U, qualifier P>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 2, T, Q>::mat(mat<2, 2, U, P> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0]), col_type(m[1])}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(m[0]);
-			this->value[1] = col_type(m[1]);
-#		endif
-	}
+		: value{col_type(m[0]), col_type(m[1])}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 2, T, Q>::mat(mat<3, 3, T, Q> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0]), col_type(m[1])}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(m[0]);
-			this->value[1] = col_type(m[1]);
-#		endif
-	}
+		: value{col_type(m[0]), col_type(m[1])}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 2, T, Q>::mat(mat<4, 4, T, Q> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0]), col_type(m[1])}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(m[0]);
-			this->value[1] = col_type(m[1]);
-#		endif
-	}
+		: value{col_type(m[0]), col_type(m[1])}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 2, T, Q>::mat(mat<2, 3, T, Q> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0]), col_type(m[1])}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(m[0]);
-			this->value[1] = col_type(m[1]);
-#		endif
-	}
+		: value{col_type(m[0]), col_type(m[1])}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 2, T, Q>::mat(mat<3, 2, T, Q> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0]), col_type(m[1])}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(m[0]);
-			this->value[1] = col_type(m[1]);
-#		endif
-	}
+		: value{col_type(m[0]), col_type(m[1])}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 2, T, Q>::mat(mat<2, 4, T, Q> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0]), col_type(m[1])}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(m[0]);
-			this->value[1] = col_type(m[1]);
-#		endif
-	}
+		: value{col_type(m[0]), col_type(m[1])}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 2, T, Q>::mat(mat<4, 2, T, Q> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0]), col_type(m[1])}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(m[0]);
-			this->value[1] = col_type(m[1]);
-#		endif
-	}
+		: value{col_type(m[0]), col_type(m[1])}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 2, T, Q>::mat(mat<3, 4, T, Q> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0]), col_type(m[1])}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(m[0]);
-			this->value[1] = col_type(m[1]);
-#		endif
-	}
+		: value{col_type(m[0]), col_type(m[1])}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 2, T, Q>::mat(mat<4, 3, T, Q> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0]), col_type(m[1])}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(m[0]);
-			this->value[1] = col_type(m[1]);
-#		endif
-	}
+		: value{col_type(m[0]), col_type(m[1])}
+	{}
 
 	// -- Accesses --
 

glm/detail/type_mat2x3.hpp

@@ -26,7 +26,7 @@ namespace glm
 		// -- Accesses --
 
 		typedef length_t length_type;
-		GLM_FUNC_DECL static GLM_CONSTEXPR length_type length() { return 2; }
+		GLM_FUNC_DECL static constexpr length_type length() { return 2; }
 
 		GLM_FUNC_DECL GLM_CONSTEXPR col_type & operator[](length_type i) GLM_NOEXCEPT;
 		GLM_FUNC_DECL GLM_CONSTEXPR col_type const& operator[](length_type i) const GLM_NOEXCEPT;
@@ -34,6 +34,7 @@ namespace glm
 		// -- Constructors --
 
 		GLM_DEFAULTED_DEFAULT_CTOR_DECL GLM_CONSTEXPR mat() GLM_DEFAULT_CTOR;
+		GLM_CTOR_DECL mat(mat<2, 3, T, Q> const& m) = default;
 		template<qualifier P>
 		GLM_CTOR_DECL mat(mat<2, 3, T, P> const& m);
 
@@ -73,6 +74,8 @@ namespace glm
 
 		// -- Unary arithmetic operators --
 
+		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<2, 3, T, Q>& operator=(mat<2, 3, T, Q> const& m) = default;
+
 		template<typename U>
 		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<2, 3, T, Q> & operator=(mat<2, 3, U, Q> const& m);
 		template<typename U>

glm/detail/type_mat2x3.inl

@@ -2,44 +2,23 @@ namespace glm
 {
 	// -- Constructors --
 
-#	if GLM_CONFIG_DEFAULTED_DEFAULT_CTOR == GLM_DISABLE
+#	if GLM_CONFIG_CTOR_INIT == GLM_ENABLE
 		template<typename T, qualifier Q>
 		GLM_DEFAULTED_DEFAULT_CTOR_QUALIFIER GLM_CONSTEXPR mat<2, 3, T, Q>::mat()
-#			if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALIZER_LIST
-				: value{col_type(1, 0, 0), col_type(0, 1, 0)}
-#			endif
-		{
-#			if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALISATION
-				this->value[0] = col_type(1, 0, 0);
-				this->value[1] = col_type(0, 1, 0);
-#			endif
-		}
+			: value{col_type(1, 0, 0), col_type(0, 1, 0)}
+		{}
 #	endif
 
 	template<typename T, qualifier Q>
 	template<qualifier P>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 3, T, Q>::mat(mat<2, 3, T, P> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0]), col_type(m[1])}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = m.value[0];
-			this->value[1] = m.value[1];
-#		endif
-	}
+		: value{col_type(m[0]), col_type(m[1])}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 3, T, Q>::mat(T scalar)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(scalar, 0, 0), col_type(0, scalar, 0)}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(scalar, 0, 0);
-			this->value[1] = col_type(0, scalar, 0);
-#		endif
-	}
+		: value{col_type(scalar, 0, 0), col_type(0, scalar, 0)}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 3, T, Q>::mat
@@ -47,27 +26,13 @@ namespace glm
 		T x0, T y0, T z0,
 		T x1, T y1, T z1
 	)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(x0, y0, z0), col_type(x1, y1, z1)}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(x0, y0, z0);
-			this->value[1] = col_type(x1, y1, z1);
-#		endif
-	}
+		: value{col_type(x0, y0, z0), col_type(x1, y1, z1)}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 3, T, Q>::mat(col_type const& v0, col_type const& v1)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(v0), col_type(v1)}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(v0);
-			this->value[1] = col_type(v1);
-#		endif
-	}
+		: value{col_type(v0), col_type(v1)}
+	{}
 
 	// -- Conversion constructors --
 
@@ -80,139 +45,62 @@ namespace glm
 		X1 x1, Y1 y1, Z1 z1,
 		X2 x2, Y2 y2, Z2 z2
 	)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(x1, y1, z1), col_type(x2, y2, z2)}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(x1, y1, z1);
-			this->value[1] = col_type(x2, y2, z2);
-#		endif
-	}
+		: value{col_type(x1, y1, z1), col_type(x2, y2, z2)}
+	{}
 
 	template<typename T, qualifier Q>
 	template<typename V1, typename V2>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 3, T, Q>::mat(vec<3, V1, Q> const& v1, vec<3, V2, Q> const& v2)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(v1), col_type(v2)}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(v1);
-			this->value[1] = col_type(v2);
-#		endif
-	}
+		: value{col_type(v1), col_type(v2)}
+	{}
 
 	// -- Matrix conversions --
 
 	template<typename T, qualifier Q>
 	template<typename U, qualifier P>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 3, T, Q>::mat(mat<2, 3, U, P> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0]), col_type(m[1])}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(m[0]);
-			this->value[1] = col_type(m[1]);
-#		endif
-	}
+		: value{col_type(m[0]), col_type(m[1])}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 3, T, Q>::mat(mat<2, 2, T, Q> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0], 0), col_type(m[1], 0)}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(m[0], 0);
-			this->value[1] = col_type(m[1], 0);
-#		endif
-	}
+		: value{col_type(m[0], 0), col_type(m[1], 0)}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR  mat<2, 3, T, Q>::mat(mat<3, 3, T, Q> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0]), col_type(m[1])}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(m[0]);
-			this->value[1] = col_type(m[1]);
-#		endif
-	}
+		: value{col_type(m[0]), col_type(m[1])}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 3, T, Q>::mat(mat<4, 4, T, Q> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
 		: value{col_type(m[0]), col_type(m[1])}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(m[0]);
-			this->value[1] = col_type(m[1]);
-#		endif
-	}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 3, T, Q>::mat(mat<2, 4, T, Q> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0]), col_type(m[1])}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(m[0]);
-			this->value[1] = col_type(m[1]);
-#		endif
-	}
+		: value{col_type(m[0]), col_type(m[1])}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 3, T, Q>::mat(mat<3, 2, T, Q> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0], 0), col_type(m[1], 0)}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(m[0], 0);
-			this->value[1] = col_type(m[1], 0);
-#		endif
-	}
+		: value{col_type(m[0], 0), col_type(m[1], 0)}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 3, T, Q>::mat(mat<3, 4, T, Q> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0]), col_type(m[1])}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(m[0]);
-			this->value[1] = col_type(m[1]);
-#		endif
-	}
+		: value{col_type(m[0]), col_type(m[1])}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 3, T, Q>::mat(mat<4, 2, T, Q> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0], 0), col_type(m[1], 0)}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(m[0], 0);
-			this->value[1] = col_type(m[1], 0);
-#		endif
-	}
+		: value{col_type(m[0], 0), col_type(m[1], 0)}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 3, T, Q>::mat(mat<4, 3, T, Q> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0]), col_type(m[1])}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(m[0]);
-			this->value[1] = col_type(m[1]);
-#		endif
-	}
+		: value{col_type(m[0]), col_type(m[1])}
+	{}
 
 	// -- Accesses --
 

glm/detail/type_mat2x4.hpp

@@ -26,7 +26,7 @@ namespace glm
 		// -- Accesses --
 
 		typedef length_t length_type;
-		GLM_FUNC_DECL static GLM_CONSTEXPR length_type length() { return 2; }
+		GLM_FUNC_DECL static constexpr length_type length() { return 2; }
 
 		GLM_FUNC_DECL GLM_CONSTEXPR col_type & operator[](length_type i) GLM_NOEXCEPT;
 		GLM_FUNC_DECL GLM_CONSTEXPR col_type const& operator[](length_type i) const GLM_NOEXCEPT;
@@ -34,6 +34,7 @@ namespace glm
 		// -- Constructors --
 
 		GLM_DEFAULTED_DEFAULT_CTOR_DECL GLM_CONSTEXPR mat() GLM_DEFAULT_CTOR;
+		GLM_CTOR_DECL mat(mat<2, 4, T, Q> const& m) = default;
 		template<qualifier P>
 		GLM_CTOR_DECL mat(mat<2, 4, T, P> const& m);
 
@@ -75,25 +76,27 @@ namespace glm
 
 		// -- Unary arithmetic operators --
 
+		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<2, 4, T, Q>& operator=(mat<2, 4, T, Q> const& m) = default;
+
 		template<typename U>
-		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<2, 4, T, Q> & operator=(mat<2, 4, U, Q> const& m);
+		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<2, 4, T, Q>& operator=(mat<2, 4, U, Q> const& m);
 		template<typename U>
-		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<2, 4, T, Q> & operator+=(U s);
+		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<2, 4, T, Q>& operator+=(U s);
 		template<typename U>
-		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<2, 4, T, Q> & operator+=(mat<2, 4, U, Q> const& m);
+		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<2, 4, T, Q>& operator+=(mat<2, 4, U, Q> const& m);
 		template<typename U>
-		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<2, 4, T, Q> & operator-=(U s);
+		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<2, 4, T, Q>& operator-=(U s);
 		template<typename U>
-		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<2, 4, T, Q> & operator-=(mat<2, 4, U, Q> const& m);
+		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<2, 4, T, Q>& operator-=(mat<2, 4, U, Q> const& m);
 		template<typename U>
-		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<2, 4, T, Q> & operator*=(U s);
+		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<2, 4, T, Q>& operator*=(U s);
 		template<typename U>
-		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<2, 4, T, Q> & operator/=(U s);
+		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<2, 4, T, Q>& operator/=(U s);
 
 		// -- Increment and decrement operators --
 
-		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<2, 4, T, Q> & operator++ ();
-		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<2, 4, T, Q> & operator-- ();
+		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<2, 4, T, Q>& operator++ ();
+		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<2, 4, T, Q>& operator-- ();
 		GLM_FUNC_DECL GLM_CONSTEXPR mat<2, 4, T, Q> operator++(int);
 		GLM_FUNC_DECL GLM_CONSTEXPR mat<2, 4, T, Q> operator--(int);
 	};

glm/detail/type_mat2x4.inl

@@ -2,44 +2,23 @@ namespace glm
 {
 	// -- Constructors --
 
-#	if GLM_CONFIG_DEFAULTED_DEFAULT_CTOR == GLM_DISABLE
+#	if GLM_CONFIG_CTOR_INIT == GLM_ENABLE
 		template<typename T, qualifier Q>
 		GLM_DEFAULTED_DEFAULT_CTOR_QUALIFIER GLM_CONSTEXPR mat<2, 4, T, Q>::mat()
-#			if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALIZER_LIST
-				: value{col_type(1, 0, 0, 0), col_type(0, 1, 0, 0)}
-#			endif
-		{
-#			if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALISATION
-				this->value[0] = col_type(1, 0, 0, 0);
-				this->value[1] = col_type(0, 1, 0, 0);
-#			endif
-		}
+			: value{col_type(1, 0, 0, 0), col_type(0, 1, 0, 0)}
+		{}
 #	endif
 
 	template<typename T, qualifier Q>
 	template<qualifier P>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 4, T, Q>::mat(mat<2, 4, T, P> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0]), col_type(m[1])}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = m[0];
-			this->value[1] = m[1];
-#		endif
-	}
+		: value{col_type(m[0]), col_type(m[1])}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 4, T, Q>::mat(T s)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(s, 0, 0, 0), col_type(0, s, 0, 0)}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(s, 0, 0, 0);
-			this->value[1] = col_type(0, s, 0, 0);
-#		endif
-	}
+		: value{col_type(s, 0, 0, 0), col_type(0, s, 0, 0)}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 4, T, Q>::mat
@@ -47,27 +26,13 @@ namespace glm
 		T x0, T y0, T z0, T w0,
 		T x1, T y1, T z1, T w1
 	)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(x0, y0, z0, w0), col_type(x1, y1, z1, w1)}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(x0, y0, z0, w0);
-			this->value[1] = col_type(x1, y1, z1, w1);
-#		endif
-	}
+		: value{col_type(x0, y0, z0, w0), col_type(x1, y1, z1, w1)}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 4, T, Q>::mat(col_type const& v0, col_type const& v1)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(v0), col_type(v1)}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = v0;
-			this->value[1] = v1;
-#		endif
-	}
+		: value{col_type(v0), col_type(v1)}
+	{}
 
 	// -- Conversion constructors --
 
@@ -80,141 +45,64 @@ namespace glm
 		X1 x1, Y1 y1, Z1 z1, W1 w1,
 		X2 x2, Y2 y2, Z2 z2, W2 w2
 	)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{
-				col_type(x1, y1, z1, w1),
-				col_type(x2, y2, z2, w2)}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(x1, y1, z1, w1);
-			this->value[1] = col_type(x2, y2, z2, w2);
-#		endif
-	}
+		: value{
+			col_type(x1, y1, z1, w1),
+			col_type(x2, y2, z2, w2)}
+	{}
 
 	template<typename T, qualifier Q>
 	template<typename V1, typename V2>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 4, T, Q>::mat(vec<4, V1, Q> const& v1, vec<4, V2, Q> const& v2)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(v1), col_type(v2)}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(v1);
-			this->value[1] = col_type(v2);
-#		endif
-	}
+		: value{col_type(v1), col_type(v2)}
+	{}
 
 	// -- Matrix conversions --
 
 	template<typename T, qualifier Q>
 	template<typename U, qualifier P>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 4, T, Q>::mat(mat<2, 4, U, P> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0]), col_type(m[1])}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(m[0]);
-			this->value[1] = col_type(m[1]);
-#		endif
-	}
+		: value{col_type(m[0]), col_type(m[1])}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 4, T, Q>::mat(mat<2, 2, T, Q> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0], 0, 0), col_type(m[1], 0, 0)}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(m[0], 0, 0);
-			this->value[1] = col_type(m[1], 0, 0);
-#		endif
-	}
+		: value{col_type(m[0], 0, 0), col_type(m[1], 0, 0)}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 4, T, Q>::mat(mat<3, 3, T, Q> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0], 0), col_type(m[1], 0)}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(m[0], 0);
-			this->value[1] = col_type(m[1], 0);
-#		endif
-	}
+		: value{col_type(m[0], 0), col_type(m[1], 0)}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 4, T, Q>::mat(mat<4, 4, T, Q> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0]), col_type(m[1])}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(m[0]);
-			this->value[1] = col_type(m[1]);
-#		endif
-	}
+		: value{col_type(m[0]), col_type(m[1])}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 4, T, Q>::mat(mat<2, 3, T, Q> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0], 0), col_type(m[1], 0)}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(m[0], 0);
-			this->value[1] = col_type(m[1], 0);
-#		endif
-	}
+		: value{col_type(m[0], 0), col_type(m[1], 0)}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 4, T, Q>::mat(mat<3, 2, T, Q> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0], 0, 0), col_type(m[1], 0, 0)}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(m[0], 0, 0);
-			this->value[1] = col_type(m[1], 0, 0);
-#		endif
-	}
+		: value{col_type(m[0], 0, 0), col_type(m[1], 0, 0)}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 4, T, Q>::mat(mat<3, 4, T, Q> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0]), col_type(m[1])}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(m[0]);
-			this->value[1] = col_type(m[1]);
-#		endif
-	}
+		: value{col_type(m[0]), col_type(m[1])}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 4, T, Q>::mat(mat<4, 2, T, Q> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0], 0, 0), col_type(m[1], 0, 0)}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(m[0], 0, 0);
-			this->value[1] = col_type(m[1], 0, 0);
-#		endif
-	}
+		: value{col_type(m[0], 0, 0), col_type(m[1], 0, 0)}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<2, 4, T, Q>::mat(mat<4, 3, T, Q> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0], 0), col_type(m[1], 0)}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(m[0], 0);
-			this->value[1] = col_type(m[1], 0);
-#		endif
-	}
+		: value{col_type(m[0], 0), col_type(m[1], 0)}
+	{}
 
 	// -- Accesses --
 

glm/detail/type_mat3x2.hpp

@@ -26,7 +26,7 @@ namespace glm
 		// -- Accesses --
 
 		typedef length_t length_type;
-		GLM_FUNC_DECL static GLM_CONSTEXPR length_type length() { return 3; }
+		GLM_FUNC_DECL static constexpr length_type length() { return 3; }
 
 		GLM_FUNC_DECL GLM_CONSTEXPR col_type & operator[](length_type i) GLM_NOEXCEPT;
 		GLM_FUNC_DECL GLM_CONSTEXPR col_type const& operator[](length_type i) const GLM_NOEXCEPT;
@@ -34,6 +34,7 @@ namespace glm
 		// -- Constructors --
 
 		GLM_DEFAULTED_DEFAULT_CTOR_DECL GLM_CONSTEXPR mat() GLM_DEFAULT_CTOR;
+		GLM_CTOR_DECL mat(mat<3, 2, T, Q> const& m) = default;
 		template<qualifier P>
 		GLM_CTOR_DECL mat(mat<3, 2, T, P> const& m);
 
@@ -80,6 +81,8 @@ namespace glm
 
 		// -- Unary arithmetic operators --
 
+		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<3, 2, T, Q>& operator=(mat<3, 2, T, Q> const& m) = default;
+
 		template<typename U>
 		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<3, 2, T, Q> & operator=(mat<3, 2, U, Q> const& m);
 		template<typename U>

glm/detail/type_mat3x2.inl

@@ -2,47 +2,23 @@ namespace glm
 {
 	// -- Constructors --
 
-#	if GLM_CONFIG_DEFAULTED_DEFAULT_CTOR == GLM_DISABLE
+#	if GLM_CONFIG_CTOR_INIT == GLM_ENABLE
 		template<typename T, qualifier Q>
 		GLM_DEFAULTED_DEFAULT_CTOR_QUALIFIER GLM_CONSTEXPR mat<3, 2, T, Q>::mat()
-#			if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALIZER_LIST
-				: value{col_type(1, 0), col_type(0, 1), col_type(0, 0)}
-#			endif
-		{
-#			if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALISATION
-				this->value[0] = col_type(1, 0);
-				this->value[1] = col_type(0, 1);
-				this->value[2] = col_type(0, 0);
-#			endif
-		}
+			: value{col_type(1, 0), col_type(0, 1), col_type(0, 0)}
+		{}
 #	endif
 
 	template<typename T, qualifier Q>
 	template<qualifier P>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 2, T, Q>::mat(mat<3, 2, T, P> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0]), col_type(m[1]), col_type(m[2])}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = m[0];
-			this->value[1] = m[1];
-			this->value[2] = m[2];
-#		endif
-	}
+		: value{col_type(m[0]), col_type(m[1]), col_type(m[2])}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 2, T, Q>::mat(T s)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(s, 0), col_type(0, s), col_type(0, 0)}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(s, 0);
-			this->value[1] = col_type(0, s);
-			this->value[2] = col_type(0, 0);
-#		endif
-	}
+		: value{col_type(s, 0), col_type(0, s), col_type(0, 0)}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 2, T, Q>::mat
@@ -51,29 +27,13 @@ namespace glm
 		T x1, T y1,
 		T x2, T y2
 	)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(x0, y0), col_type(x1, y1), col_type(x2, y2)}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(x0, y0);
-			this->value[1] = col_type(x1, y1);
-			this->value[2] = col_type(x2, y2);
-#		endif
-	}
+		: value{col_type(x0, y0), col_type(x1, y1), col_type(x2, y2)}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 2, T, Q>::mat(col_type const& v0, col_type const& v1, col_type const& v2)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(v0), col_type(v1), col_type(v2)}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = v0;
-			this->value[1] = v1;
-			this->value[2] = v2;
-#		endif
-	}
+		: value{col_type(v0), col_type(v1), col_type(v2)}
+	{}
 
 	// -- Conversion constructors --
 
@@ -88,150 +48,62 @@ namespace glm
 		X1 x1, Y1 y1,
 		X2 x2, Y2 y2
 	)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(x0, y0), col_type(x1, y1), col_type(x2, y2)}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(x0, y0);
-			this->value[1] = col_type(x1, y1);
-			this->value[2] = col_type(x2, y2);
-#		endif
-	}
+		: value{col_type(x0, y0), col_type(x1, y1), col_type(x2, y2)}
+	{}
 
 	template<typename T, qualifier Q>
 	template<typename V0, typename V1, typename V2>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 2, T, Q>::mat(vec<2, V0, Q> const& v0, vec<2, V1, Q> const& v1, vec<2, V2, Q> const& v2)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(v0), col_type(v1), col_type(v2)}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(v0);
-			this->value[1] = col_type(v1);
-			this->value[2] = col_type(v2);
-#		endif
-	}
+		: value{col_type(v0), col_type(v1), col_type(v2)}
+	{}
 
 	// -- Matrix conversions --
 
 	template<typename T, qualifier Q>
 	template<typename U, qualifier P>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 2, T, Q>::mat(mat<3, 2, U, P> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0]), col_type(m[1]), col_type(m[2])}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(m[0]);
-			this->value[1] = col_type(m[1]);
-			this->value[2] = col_type(m[2]);
-#		endif
-	}
+		: value{col_type(m[0]), col_type(m[1]), col_type(m[2])}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 2, T, Q>::mat(mat<2, 2, T, Q> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0]), col_type(m[1]), col_type(0)}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = m[0];
-			this->value[1] = m[1];
-			this->value[2] = col_type(0);
-#		endif
-	}
+		: value{col_type(m[0]), col_type(m[1]), col_type(0)}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 2, T, Q>::mat(mat<3, 3, T, Q> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0]), col_type(m[1]), col_type(m[2])}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(m[0]);
-			this->value[1] = col_type(m[1]);
-			this->value[2] = col_type(m[2]);
-#		endif
-	}
+		: value{col_type(m[0]), col_type(m[1]), col_type(m[2])}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 2, T, Q>::mat(mat<4, 4, T, Q> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0]), col_type(m[1]), col_type(m[2])}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(m[0]);
-			this->value[1] = col_type(m[1]);
-			this->value[2] = col_type(m[2]);
-#		endif
-	}
+		: value{col_type(m[0]), col_type(m[1]), col_type(m[2])}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 2, T, Q>::mat(mat<2, 3, T, Q> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0]), col_type(m[1]), col_type(0)}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(m[0]);
-			this->value[1] = col_type(m[1]);
-			this->value[2] = col_type(0);
-#		endif
-	}
+		: value{col_type(m[0]), col_type(m[1]), col_type(0)}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 2, T, Q>::mat(mat<2, 4, T, Q> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0]), col_type(m[1]), col_type(0)}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(m[0]);
-			this->value[1] = col_type(m[1]);
-			this->value[2] = col_type(0);
-#		endif
-	}
+		: value{col_type(m[0]), col_type(m[1]), col_type(0)}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 2, T, Q>::mat(mat<3, 4, T, Q> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0]), col_type(m[1]), col_type(m[2])}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(m[0]);
-			this->value[1] = col_type(m[1]);
-			this->value[2] = col_type(m[2]);
-#		endif
-	}
+		: value{col_type(m[0]), col_type(m[1]), col_type(m[2])}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 2, T, Q>::mat(mat<4, 2, T, Q> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0]), col_type(m[1]), col_type(m[2])}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = m[0];
-			this->value[1] = m[1];
-			this->value[2] = m[2];
-#		endif
-	}
+		: value{col_type(m[0]), col_type(m[1]), col_type(m[2])}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 2, T, Q>::mat(mat<4, 3, T, Q> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0]), col_type(m[1]), col_type(m[2])}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(m[0]);
-			this->value[1] = col_type(m[1]);
-			this->value[2] = col_type(m[2]);
-#		endif
-	}
+		: value{col_type(m[0]), col_type(m[1]), col_type(m[2])}
+	{}
 
 	// -- Accesses --
 

glm/detail/type_mat3x3.hpp

@@ -25,7 +25,7 @@ namespace glm
 		// -- Accesses --
 
 		typedef length_t length_type;
-		GLM_FUNC_DECL static GLM_CONSTEXPR length_type length() { return 3; }
+		GLM_FUNC_DECL static constexpr length_type length() { return 3; }
 
 		GLM_FUNC_DECL GLM_CONSTEXPR col_type & operator[](length_type i) GLM_NOEXCEPT;
 		GLM_FUNC_DECL GLM_CONSTEXPR col_type const& operator[](length_type i) const GLM_NOEXCEPT;
@@ -33,6 +33,7 @@ namespace glm
 		// -- Constructors --
 
 		GLM_DEFAULTED_DEFAULT_CTOR_DECL GLM_CONSTEXPR mat() GLM_DEFAULT_CTOR;
+		GLM_CTOR_DECL mat(mat<3, 3, T, Q> const& m) = default;
 		template<qualifier P>
 		GLM_CTOR_DECL mat(mat<3, 3, T, P> const& m);
 
@@ -79,29 +80,31 @@ namespace glm
 
 		// -- Unary arithmetic operators --
 
+		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<3, 3, T, Q>& operator=(mat<3, 3, T, Q> const& m) = default;
+
 		template<typename U>
-		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<3, 3, T, Q> & operator=(mat<3, 3, U, Q> const& m);
+		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<3, 3, T, Q>& operator=(mat<3, 3, U, Q> const& m);
 		template<typename U>
-		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<3, 3, T, Q> & operator+=(U s);
+		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<3, 3, T, Q>& operator+=(U s);
 		template<typename U>
-		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<3, 3, T, Q> & operator+=(mat<3, 3, U, Q> const& m);
+		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<3, 3, T, Q>& operator+=(mat<3, 3, U, Q> const& m);
 		template<typename U>
-		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<3, 3, T, Q> & operator-=(U s);
+		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<3, 3, T, Q>& operator-=(U s);
 		template<typename U>
-		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<3, 3, T, Q> & operator-=(mat<3, 3, U, Q> const& m);
+		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<3, 3, T, Q>& operator-=(mat<3, 3, U, Q> const& m);
 		template<typename U>
-		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<3, 3, T, Q> & operator*=(U s);
+		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<3, 3, T, Q>& operator*=(U s);
 		template<typename U>
-		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<3, 3, T, Q> & operator*=(mat<3, 3, U, Q> const& m);
+		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<3, 3, T, Q>& operator*=(mat<3, 3, U, Q> const& m);
 		template<typename U>
-		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<3, 3, T, Q> & operator/=(U s);
+		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<3, 3, T, Q>& operator/=(U s);
 		template<typename U>
-		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<3, 3, T, Q> & operator/=(mat<3, 3, U, Q> const& m);
+		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<3, 3, T, Q>& operator/=(mat<3, 3, U, Q> const& m);
 
 		// -- Increment and decrement operators --
 
-		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<3, 3, T, Q> & operator++();
-		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<3, 3, T, Q> & operator--();
+		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<3, 3, T, Q>& operator++();
+		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<3, 3, T, Q>& operator--();
 		GLM_FUNC_DECL GLM_CONSTEXPR mat<3, 3, T, Q> operator++(int);
 		GLM_FUNC_DECL GLM_CONSTEXPR mat<3, 3, T, Q> operator--(int);
 	};

glm/detail/type_mat3x3.inl

@@ -5,47 +5,23 @@ namespace glm
 {
 	// -- Constructors --
 
-#	if GLM_CONFIG_DEFAULTED_DEFAULT_CTOR == GLM_DISABLE
+#	if GLM_CONFIG_CTOR_INIT == GLM_ENABLE
 		template<typename T, qualifier Q>
 		GLM_DEFAULTED_DEFAULT_CTOR_QUALIFIER GLM_CONSTEXPR mat<3, 3, T, Q>::mat()
-#			if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALIZER_LIST
-				: value{col_type(1, 0, 0), col_type(0, 1, 0), col_type(0, 0, 1)}
-#			endif
-		{
-#			if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALISATION
-			this->value[0] = col_type(1, 0, 0);
-				this->value[1] = col_type(0, 1, 0);
-				this->value[2] = col_type(0, 0, 1);
-#			endif
-		}
+			: value{col_type(1, 0, 0), col_type(0, 1, 0), col_type(0, 0, 1)}
+		{}
 #	endif
 
 	template<typename T, qualifier Q>
 	template<qualifier P>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 3, T, Q>::mat(mat<3, 3, T, P> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0]), col_type(m[1]), col_type(m[2])}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(m[0]);
-			this->value[1] = col_type(m[1]);
-			this->value[2] = col_type(m[2]);
-#		endif
-	}
+		: value{col_type(m[0]), col_type(m[1]), col_type(m[2])}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 3, T, Q>::mat(T s)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(s, 0, 0), col_type(0, s, 0), col_type(0, 0, s)}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(s, 0, 0);
-			this->value[1] = col_type(0, s, 0);
-			this->value[2] = col_type(0, 0, s);
-#		endif
-	}
+		: value{col_type(s, 0, 0), col_type(0, s, 0), col_type(0, 0, s)}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 3, T, Q>::mat
@@ -54,29 +30,13 @@ namespace glm
 		T x1, T y1, T z1,
 		T x2, T y2, T z2
 	)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(x0, y0, z0), col_type(x1, y1, z1), col_type(x2, y2, z2)}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(x0, y0, z0);
-			this->value[1] = col_type(x1, y1, z1);
-			this->value[2] = col_type(x2, y2, z2);
-#		endif
-	}
+		: value{col_type(x0, y0, z0), col_type(x1, y1, z1), col_type(x2, y2, z2)}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 3, T, Q>::mat(col_type const& v0, col_type const& v1, col_type const& v2)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(v0), col_type(v1), col_type(v2)}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(v0);
-			this->value[1] = col_type(v1);
-			this->value[2] = col_type(v2);
-#		endif
-	}
+		: value{col_type(v0), col_type(v1), col_type(v2)}
+	{}
 
 	// -- Conversion constructors --
 
@@ -91,150 +51,62 @@ namespace glm
 		X2 x2, Y2 y2, Z2 z2,
 		X3 x3, Y3 y3, Z3 z3
 	)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(x1, y1, z1), col_type(x2, y2, z2), col_type(x3, y3, z3)}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(x1, y1, z1);
-			this->value[1] = col_type(x2, y2, z2);
-			this->value[2] = col_type(x3, y3, z3);
-#		endif
-	}
+		: value{col_type(x1, y1, z1), col_type(x2, y2, z2), col_type(x3, y3, z3)}
+	{}
 
 	template<typename T, qualifier Q>
 	template<typename V1, typename V2, typename V3>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 3, T, Q>::mat(vec<3, V1, Q> const& v1, vec<3, V2, Q> const& v2, vec<3, V3, Q> const& v3)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(v1), col_type(v2), col_type(v3)}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(v1);
-			this->value[1] = col_type(v2);
-			this->value[2] = col_type(v3);
-#		endif
-	}
+		: value{col_type(v1), col_type(v2), col_type(v3)}
+	{}
 
 	// -- Matrix conversions --
 
 	template<typename T, qualifier Q>
 	template<typename U, qualifier P>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 3, T, Q>::mat(mat<3, 3, U, P> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0]), col_type(m[1]), col_type(m[2])}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(m[0]);
-			this->value[1] = col_type(m[1]);
-			this->value[2] = col_type(m[2]);
-#		endif
-	}
+		: value{col_type(m[0]), col_type(m[1]), col_type(m[2])}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 3, T, Q>::mat(mat<2, 2, T, Q> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0], 0), col_type(m[1], 0), col_type(0, 0, 1)}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(m[0], 0);
-			this->value[1] = col_type(m[1], 0);
-			this->value[2] = col_type(0, 0, 1);
-#		endif
-	}
+		: value{col_type(m[0], 0), col_type(m[1], 0), col_type(0, 0, 1)}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 3, T, Q>::mat(mat<4, 4, T, Q> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0]), col_type(m[1]), col_type(m[2])}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(m[0]);
-			this->value[1] = col_type(m[1]);
-			this->value[2] = col_type(m[2]);
-#		endif
-	}
+		: value{col_type(m[0]), col_type(m[1]), col_type(m[2])}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 3, T, Q>::mat(mat<2, 3, T, Q> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0]), col_type(m[1]), col_type(0, 0, 1)}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(m[0]);
-			this->value[1] = col_type(m[1]);
-			this->value[2] = col_type(0, 0, 1);
-#		endif
-	}
+		: value{col_type(m[0]), col_type(m[1]), col_type(0, 0, 1)}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 3, T, Q>::mat(mat<3, 2, T, Q> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0], 0), col_type(m[1], 0), col_type(m[2], 1)}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(m[0], 0);
-			this->value[1] = col_type(m[1], 0);
-			this->value[2] = col_type(m[2], 1);
-#		endif
-	}
+		: value{col_type(m[0], 0), col_type(m[1], 0), col_type(m[2], 1)}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 3, T, Q>::mat(mat<2, 4, T, Q> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0]), col_type(m[1]), col_type(0, 0, 1)}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(m[0]);
-			this->value[1] = col_type(m[1]);
-			this->value[2] = col_type(0, 0, 1);
-#		endif
-	}
+		: value{col_type(m[0]), col_type(m[1]), col_type(0, 0, 1)}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 3, T, Q>::mat(mat<4, 2, T, Q> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0], 0), col_type(m[1], 0), col_type(m[2], 1)}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(m[0], 0);
-			this->value[1] = col_type(m[1], 0);
-			this->value[2] = col_type(m[2], 1);
-#		endif
-	}
+		: value{col_type(m[0], 0), col_type(m[1], 0), col_type(m[2], 1)}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 3, T, Q>::mat(mat<3, 4, T, Q> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0]), col_type(m[1]), col_type(m[2])}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(m[0]);
-			this->value[1] = col_type(m[1]);
-			this->value[2] = col_type(m[2]);
-#		endif
-	}
+		: value{col_type(m[0]), col_type(m[1]), col_type(m[2])}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 3, T, Q>::mat(mat<4, 3, T, Q> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0]), col_type(m[1]), col_type(m[2])}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(m[0]);
-			this->value[1] = col_type(m[1]);
-			this->value[2] = col_type(m[2]);
-#		endif
-	}
+		: value{col_type(m[0]), col_type(m[1]), col_type(m[2])}
+	{}
 
 	// -- Accesses --
 

glm/detail/type_mat3x4.hpp

@@ -26,7 +26,7 @@ namespace glm
 		// -- Accesses --
 
 		typedef length_t length_type;
-		GLM_FUNC_DECL static GLM_CONSTEXPR length_type length() { return 3; }
+		GLM_FUNC_DECL static constexpr length_type length() { return 3; }
 
 		GLM_FUNC_DECL GLM_CONSTEXPR col_type & operator[](length_type i) GLM_NOEXCEPT;
 		GLM_FUNC_DECL GLM_CONSTEXPR col_type const& operator[](length_type i) const GLM_NOEXCEPT;
@@ -34,6 +34,7 @@ namespace glm
 		// -- Constructors --
 
 		GLM_DEFAULTED_DEFAULT_CTOR_DECL GLM_CONSTEXPR mat() GLM_DEFAULT_CTOR;
+		GLM_CTOR_DECL mat(mat<3, 4, T, Q> const& m) = default;
 		template<qualifier P>
 		GLM_CTOR_DECL mat(mat<3, 4, T, P> const& m);
 
@@ -80,25 +81,27 @@ namespace glm
 
 		// -- Unary arithmetic operators --
 
+		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<3, 4, T, Q>& operator=(mat<3, 4, T, Q> const& m) = default;
+
 		template<typename U>
-		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<3, 4, T, Q> & operator=(mat<3, 4, U, Q> const& m);
+		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<3, 4, T, Q>& operator=(mat<3, 4, U, Q> const& m);
 		template<typename U>
-		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<3, 4, T, Q> & operator+=(U s);
+		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<3, 4, T, Q>& operator+=(U s);
 		template<typename U>
-		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<3, 4, T, Q> & operator+=(mat<3, 4, U, Q> const& m);
+		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<3, 4, T, Q>& operator+=(mat<3, 4, U, Q> const& m);
 		template<typename U>
-		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<3, 4, T, Q> & operator-=(U s);
+		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<3, 4, T, Q>& operator-=(U s);
 		template<typename U>
-		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<3, 4, T, Q> & operator-=(mat<3, 4, U, Q> const& m);
+		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<3, 4, T, Q>& operator-=(mat<3, 4, U, Q> const& m);
 		template<typename U>
-		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<3, 4, T, Q> & operator*=(U s);
+		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<3, 4, T, Q>& operator*=(U s);
 		template<typename U>
-		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<3, 4, T, Q> & operator/=(U s);
+		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<3, 4, T, Q>& operator/=(U s);
 
 		// -- Increment and decrement operators --
 
-		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<3, 4, T, Q> & operator++();
-		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<3, 4, T, Q> & operator--();
+		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<3, 4, T, Q>& operator++();
+		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<3, 4, T, Q>& operator--();
 		GLM_FUNC_DECL GLM_CONSTEXPR mat<3, 4, T, Q> operator++(int);
 		GLM_FUNC_DECL GLM_CONSTEXPR mat<3, 4, T, Q> operator--(int);
 	};

glm/detail/type_mat3x4.inl

@@ -2,47 +2,23 @@ namespace glm
 {
 	// -- Constructors --
 
-#	if GLM_CONFIG_DEFAULTED_DEFAULT_CTOR == GLM_DISABLE
+#	if GLM_CONFIG_CTOR_INIT == GLM_ENABLE
 		template<typename T, qualifier Q>
 		GLM_DEFAULTED_DEFAULT_CTOR_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat()
-#			if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALIZER_LIST
-				: value{col_type(1, 0, 0, 0), col_type(0, 1, 0, 0), col_type(0, 0, 1, 0)}
-#			endif
-		{
-#			if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALISATION
-				this->value[0] = col_type(1, 0, 0, 0);
-				this->value[1] = col_type(0, 1, 0, 0);
-				this->value[2] = col_type(0, 0, 1, 0);
-#			endif
-		}
+			: value{col_type(1, 0, 0, 0), col_type(0, 1, 0, 0), col_type(0, 0, 1, 0)}
+		{}
 #	endif
 
 	template<typename T, qualifier Q>
 	template<qualifier P>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat(mat<3, 4, T, P> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0]), col_type(m[1]), col_type(m[2])}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = m[0];
-			this->value[1] = m[1];
-			this->value[2] = m[2];
-#		endif
-	}
+		: value{col_type(m[0]), col_type(m[1]), col_type(m[2])}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat(T s)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(s, 0, 0, 0), col_type(0, s, 0, 0), col_type(0, 0, s, 0)}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(s, 0, 0, 0);
-			this->value[1] = col_type(0, s, 0, 0);
-			this->value[2] = col_type(0, 0, s, 0);
-#		endif
-	}
+		: value{col_type(s, 0, 0, 0), col_type(0, s, 0, 0), col_type(0, 0, s, 0)}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat
@@ -51,32 +27,16 @@ namespace glm
 		T x1, T y1, T z1, T w1,
 		T x2, T y2, T z2, T w2
 	)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{
-				col_type(x0, y0, z0, w0),
-				col_type(x1, y1, z1, w1),
-				col_type(x2, y2, z2, w2)}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(x0, y0, z0, w0);
-			this->value[1] = col_type(x1, y1, z1, w1);
-			this->value[2] = col_type(x2, y2, z2, w2);
-#		endif
-	}
+		: value{
+			col_type(x0, y0, z0, w0),
+			col_type(x1, y1, z1, w1),
+			col_type(x2, y2, z2, w2)}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat(col_type const& v0, col_type const& v1, col_type const& v2)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(v0), col_type(v1), col_type(v2)}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = v0;
-			this->value[1] = v1;
-			this->value[2] = v2;
-#		endif
-	}
+		: value{col_type(v0), col_type(v1), col_type(v2)}
+	{}
 
 	// -- Conversion constructors --
 
@@ -91,153 +51,65 @@ namespace glm
 		X1 x1, Y1 y1, Z1 z1, W1 w1,
 		X2 x2, Y2 y2, Z2 z2, W2 w2
 	)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{
-				col_type(x0, y0, z0, w0),
-				col_type(x1, y1, z1, w1),
-				col_type(x2, y2, z2, w2)}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(x0, y0, z0, w0);
-			this->value[1] = col_type(x1, y1, z1, w1);
-			this->value[2] = col_type(x2, y2, z2, w2);
-#		endif
-	}
+		: value{
+			col_type(x0, y0, z0, w0),
+			col_type(x1, y1, z1, w1),
+			col_type(x2, y2, z2, w2)}
+	{}
 
 	template<typename T, qualifier Q>
 	template<typename V1, typename V2, typename V3>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat(vec<4, V1, Q> const& v0, vec<4, V2, Q> const& v1, vec<4, V3, Q> const& v2)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(v0), col_type(v1), col_type(v2)}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(v0);
-			this->value[1] = col_type(v1);
-			this->value[2] = col_type(v2);
-#		endif
-	}
+		: value{col_type(v0), col_type(v1), col_type(v2)}
+	{}
 
 	// -- Matrix conversions --
 
 	template<typename T, qualifier Q>
 	template<typename U, qualifier P>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat(mat<3, 4, U, P> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0]), col_type(m[1]), col_type(m[2])}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(m[0]);
-			this->value[1] = col_type(m[1]);
-			this->value[2] = col_type(m[2]);
-#		endif
-	}
+		: value{col_type(m[0]), col_type(m[1]), col_type(m[2])}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat(mat<2, 2, T, Q> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0], 0, 0), col_type(m[1], 0, 0), col_type(0, 0, 1, 0)}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(m[0], 0, 0);
-			this->value[1] = col_type(m[1], 0, 0);
-			this->value[2] = col_type(0, 0, 1, 0);
-#		endif
-	}
+		: value{col_type(m[0], 0, 0), col_type(m[1], 0, 0), col_type(0, 0, 1, 0)}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat(mat<3, 3, T, Q> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0], 0), col_type(m[1], 0), col_type(m[2], 0)}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(m[0], 0);
-			this->value[1] = col_type(m[1], 0);
-			this->value[2] = col_type(m[2], 0);
-#		endif
-	}
+		: value{col_type(m[0], 0), col_type(m[1], 0), col_type(m[2], 0)}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat(mat<4, 4, T, Q> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0]), col_type(m[1]), col_type(m[2])}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(m[0]);
-			this->value[1] = col_type(m[1]);
-			this->value[2] = col_type(m[2]);
-#		endif
-	}
+		: value{col_type(m[0]), col_type(m[1]), col_type(m[2])}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat(mat<2, 3, T, Q> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0], 0), col_type(m[1], 0), col_type(0, 0, 1, 0)}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(m[0], 0);
-			this->value[1] = col_type(m[1], 0);
-			this->value[2] = col_type(0, 0, 1, 0);
-#		endif
-	}
+		: value{col_type(m[0], 0), col_type(m[1], 0), col_type(0, 0, 1, 0)}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat(mat<3, 2, T, Q> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0], 0, 0), col_type(m[1], 0, 0), col_type(m[2], 1, 0)}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(m[0], 0, 0);
-			this->value[1] = col_type(m[1], 0, 0);
-			this->value[2] = col_type(m[2], 1, 0);
-#		endif
-	}
+		: value{col_type(m[0], 0, 0), col_type(m[1], 0, 0), col_type(m[2], 1, 0)}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat(mat<2, 4, T, Q> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0]), col_type(m[1]), col_type(0, 0, 1, 0)}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(m[0]);
-			this->value[1] = col_type(m[1]);
-			this->value[2] = col_type(0, 0, 1, 0);
-#		endif
-	}
+		: value{col_type(m[0]), col_type(m[1]), col_type(0, 0, 1, 0)}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat(mat<4, 2, T, Q> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0], 0, 0), col_type(m[1], 0, 0), col_type(m[2], 1, 0)}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(m[0], 0, 0);
-			this->value[1] = col_type(m[1], 0, 0);
-			this->value[2] = col_type(m[2], 1, 0);
-#		endif
-	}
+		: value{col_type(m[0], 0, 0), col_type(m[1], 0, 0), col_type(m[2], 1, 0)}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<3, 4, T, Q>::mat(mat<4, 3, T, Q> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0], 0), col_type(m[1], 0), col_type(m[2], 0)}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(m[0], 0);
-			this->value[1] = col_type(m[1], 0);
-			this->value[2] = col_type(m[2], 0);
-#		endif
-	}
+		: value{col_type(m[0], 0), col_type(m[1], 0), col_type(m[2], 0)}
+	{}
 
 	// -- Accesses --
 

glm/detail/type_mat4x2.hpp

@@ -26,7 +26,7 @@ namespace glm
 		// -- Accesses --
 
 		typedef length_t length_type;
-		GLM_FUNC_DECL static GLM_CONSTEXPR length_type length() { return 4; }
+		GLM_FUNC_DECL static constexpr length_type length() { return 4; }
 
 		GLM_FUNC_DECL GLM_CONSTEXPR col_type & operator[](length_type i) GLM_NOEXCEPT;
 		GLM_FUNC_DECL GLM_CONSTEXPR col_type const& operator[](length_type i) const GLM_NOEXCEPT;
@@ -34,6 +34,7 @@ namespace glm
 		// -- Constructors --
 
 		GLM_DEFAULTED_DEFAULT_CTOR_DECL GLM_CONSTEXPR mat() GLM_DEFAULT_CTOR;
+		GLM_CTOR_DECL mat(mat<4, 2, T, Q> const& m) = default;
 		template<qualifier P>
 		GLM_CTOR_DECL mat(mat<4, 2, T, P> const& m);
 
@@ -85,25 +86,27 @@ namespace glm
 
 		// -- Unary arithmetic operators --
 
+		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<4, 2, T, Q>& operator=(mat<4, 2, T, Q> const& m) = default;
+
 		template<typename U>
-		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<4, 2, T, Q> & operator=(mat<4, 2, U, Q> const& m);
+		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<4, 2, T, Q>& operator=(mat<4, 2, U, Q> const& m);
 		template<typename U>
-		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<4, 2, T, Q> & operator+=(U s);
+		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<4, 2, T, Q>& operator+=(U s);
 		template<typename U>
-		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<4, 2, T, Q> & operator+=(mat<4, 2, U, Q> const& m);
+		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<4, 2, T, Q>& operator+=(mat<4, 2, U, Q> const& m);
 		template<typename U>
-		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<4, 2, T, Q> & operator-=(U s);
+		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<4, 2, T, Q>& operator-=(U s);
 		template<typename U>
-		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<4, 2, T, Q> & operator-=(mat<4, 2, U, Q> const& m);
+		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<4, 2, T, Q>& operator-=(mat<4, 2, U, Q> const& m);
 		template<typename U>
-		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<4, 2, T, Q> & operator*=(U s);
+		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<4, 2, T, Q>& operator*=(U s);
 		template<typename U>
-		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<4, 2, T, Q> & operator/=(U s);
+		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<4, 2, T, Q>& operator/=(U s);
 
 		// -- Increment and decrement operators --
 
-		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<4, 2, T, Q> & operator++ ();
-		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<4, 2, T, Q> & operator-- ();
+		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<4, 2, T, Q>& operator++ ();
+		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<4, 2, T, Q>& operator-- ();
 		GLM_FUNC_DECL GLM_CONSTEXPR mat<4, 2, T, Q> operator++(int);
 		GLM_FUNC_DECL GLM_CONSTEXPR mat<4, 2, T, Q> operator--(int);
 	};

glm/detail/type_mat4x2.inl

@@ -2,50 +2,23 @@ namespace glm
 {
 	// -- Constructors --
 
-#	if GLM_CONFIG_DEFAULTED_DEFAULT_CTOR == GLM_DISABLE
+#	if GLM_CONFIG_CTOR_INIT == GLM_ENABLE
 		template<typename T, qualifier Q>
 		GLM_DEFAULTED_DEFAULT_CTOR_QUALIFIER GLM_CONSTEXPR mat<4, 2, T, Q>::mat()
-#			if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALIZER_LIST
-				: value{col_type(1, 0), col_type(0, 1), col_type(0, 0), col_type(0, 0)}
-#			endif
-		{
-#			if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALISATION
-				this->value[0] = col_type(1, 0);
-				this->value[1] = col_type(0, 1);
-				this->value[2] = col_type(0, 0);
-				this->value[3] = col_type(0, 0);
-#			endif
-		}
+			: value{col_type(1, 0), col_type(0, 1), col_type(0, 0), col_type(0, 0)}
+		{}
 #	endif
 
 	template<typename T, qualifier Q>
 	template<qualifier P>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 2, T, Q>::mat(mat<4, 2, T, P> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(m[3])}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = m[0];
-			this->value[1] = m[1];
-			this->value[2] = m[2];
-			this->value[3] = m[3];
-#		endif
-	}
+		: value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(m[3])}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 2, T, Q>::mat(T s)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(s, 0), col_type(0, s), col_type(0, 0), col_type(0, 0)}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(s, 0);
-			this->value[1] = col_type(0, s);
-			this->value[2] = col_type(0, 0);
-			this->value[3] = col_type(0, 0);
-#		endif
-	}
+		: value{col_type(s, 0), col_type(0, s), col_type(0, 0), col_type(0, 0)}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 2, T, Q>::mat
@@ -55,31 +28,13 @@ namespace glm
 		T x2, T y2,
 		T x3, T y3
 	)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(x0, y0), col_type(x1, y1), col_type(x2, y2), col_type(x3, y3)}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(x0, y0);
-			this->value[1] = col_type(x1, y1);
-			this->value[2] = col_type(x2, y2);
-			this->value[3] = col_type(x3, y3);
-#		endif
-	}
+		: value{col_type(x0, y0), col_type(x1, y1), col_type(x2, y2), col_type(x3, y3)}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 2, T, Q>::mat(col_type const& v0, col_type const& v1, col_type const& v2, col_type const& v3)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(v0), col_type(v1), col_type(v2), col_type(v3)}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = v0;
-			this->value[1] = v1;
-			this->value[2] = v2;
-			this->value[3] = v3;
-#		endif
-	}
+		: value{col_type(v0), col_type(v1), col_type(v2), col_type(v3)}
+	{}
 
 	// -- Conversion constructors --
 
@@ -96,161 +51,62 @@ namespace glm
 		X2 x2, Y2 y2,
 		X3 x3, Y3 y3
 	)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(x0, y0), col_type(x1, y1), col_type(x2, y2), col_type(x3, y3)}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(x0, y0);
-			this->value[1] = col_type(x1, y1);
-			this->value[2] = col_type(x2, y2);
-			this->value[3] = col_type(x3, y3);
-#		endif
-	}
+		: value{col_type(x0, y0), col_type(x1, y1), col_type(x2, y2), col_type(x3, y3)}
+	{}
 
 	template<typename T, qualifier Q>
 	template<typename V0, typename V1, typename V2, typename V3>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 2, T, Q>::mat(vec<2, V0, Q> const& v0, vec<2, V1, Q> const& v1, vec<2, V2, Q> const& v2, vec<2, V3, Q> const& v3)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(v0), col_type(v1), col_type(v2), col_type(v3)}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(v0);
-			this->value[1] = col_type(v1);
-			this->value[2] = col_type(v2);
-			this->value[3] = col_type(v3);
-#		endif
-	}
+		: value{col_type(v0), col_type(v1), col_type(v2), col_type(v3)}
+	{}
 
 	// -- Conversion --
 
 	template<typename T, qualifier Q>
 	template<typename U, qualifier P>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 2, T, Q>::mat(mat<4, 2, U, P> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(m[3])}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(m[0]);
-			this->value[1] = col_type(m[1]);
-			this->value[2] = col_type(m[2]);
-			this->value[3] = col_type(m[3]);
-#		endif
-	}
+		: value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(m[3])}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 2, T, Q>::mat(mat<2, 2, T, Q> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0]), col_type(m[1]), col_type(0), col_type(0)}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(m[0]);
-			this->value[1] = col_type(m[1]);
-			this->value[2] = col_type(0);
-			this->value[3] = col_type(0);
-#		endif
-	}
+		: value{col_type(m[0]), col_type(m[1]), col_type(0), col_type(0)}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 2, T, Q>::mat(mat<3, 3, T, Q> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(0)}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(m[0]);
-			this->value[1] = col_type(m[1]);
-			this->value[2] = col_type(m[2]);
-			this->value[3] = col_type(0);
-#		endif
-	}
+		: value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(0)}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 2, T, Q>::mat(mat<4, 4, T, Q> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(m[3])}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(m[0]);
-			this->value[1] = col_type(m[1]);
-			this->value[2] = col_type(m[2]);
-			this->value[3] = col_type(m[3]);
-#		endif
-	}
+		: value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(m[3])}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 2, T, Q>::mat(mat<2, 3, T, Q> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0]), col_type(m[1]), col_type(0), col_type(0)}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(m[0]);
-			this->value[1] = col_type(m[1]);
-			this->value[2] = col_type(0);
-			this->value[3] = col_type(0);
-#		endif
-	}
+		: value{col_type(m[0]), col_type(m[1]), col_type(0), col_type(0)}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 2, T, Q>::mat(mat<3, 2, T, Q> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(0)}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(m[0]);
-			this->value[1] = col_type(m[1]);
-			this->value[2] = col_type(m[2]);
-			this->value[3] = col_type(0);
-#		endif
-	}
+		: value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(0)}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 2, T, Q>::mat(mat<2, 4, T, Q> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0]), col_type(m[1]), col_type(0), col_type(0)}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(m[0]);
-			this->value[1] = col_type(m[1]);
-			this->value[2] = col_type(0);
-			this->value[3] = col_type(0);
-#		endif
-	}
+		: value{col_type(m[0]), col_type(m[1]), col_type(0), col_type(0)}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 2, T, Q>::mat(mat<4, 3, T, Q> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(m[3])}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-				this->value[0] = col_type(m[0]);
-				this->value[1] = col_type(m[1]);
-				this->value[2] = col_type(m[2]);
-				this->value[3] = col_type(m[3]);
-#		endif
-	}
+		: value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(m[3])}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 2, T, Q>::mat(mat<3, 4, T, Q> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(0)}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(m[0]);
-			this->value[1] = col_type(m[1]);
-			this->value[2] = col_type(m[2]);
-			this->value[3] = col_type(0);
-#		endif
-	}
+		: value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(0)}
+	{}
 
 	// -- Accesses --
 

glm/detail/type_mat4x3.hpp

@@ -26,7 +26,7 @@ namespace glm
 		// -- Accesses --
 
 		typedef length_t length_type;
-		GLM_FUNC_DECL static GLM_CONSTEXPR length_type length() { return 4; }
+		GLM_FUNC_DECL static constexpr length_type length() { return 4; }
 
 		GLM_FUNC_DECL GLM_CONSTEXPR col_type & operator[](length_type i) GLM_NOEXCEPT;
 		GLM_FUNC_DECL GLM_CONSTEXPR col_type const& operator[](length_type i) const GLM_NOEXCEPT;
@@ -34,6 +34,7 @@ namespace glm
 		// -- Constructors --
 
 		GLM_DEFAULTED_DEFAULT_CTOR_DECL GLM_CONSTEXPR mat() GLM_DEFAULT_CTOR;
+		GLM_CTOR_DECL mat(mat<4, 3, T, Q> const& m) = default;
 		template<qualifier P>
 		GLM_CTOR_DECL mat(mat<4, 3, T, P> const& m);
 
@@ -85,20 +86,22 @@ namespace glm
 
 		// -- Unary arithmetic operators --
 
+		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<4, 3, T, Q>& operator=(mat<4, 3, T, Q> const& m) = default;
+
 		template<typename U>
-		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<4, 3, T, Q> & operator=(mat<4, 3, U, Q> const& m);
+		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<4, 3, T, Q>& operator=(mat<4, 3, U, Q> const& m);
 		template<typename U>
-		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<4, 3, T, Q> & operator+=(U s);
+		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<4, 3, T, Q>& operator+=(U s);
 		template<typename U>
-		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<4, 3, T, Q> & operator+=(mat<4, 3, U, Q> const& m);
+		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<4, 3, T, Q>& operator+=(mat<4, 3, U, Q> const& m);
 		template<typename U>
-		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<4, 3, T, Q> & operator-=(U s);
+		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<4, 3, T, Q>& operator-=(U s);
 		template<typename U>
-		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<4, 3, T, Q> & operator-=(mat<4, 3, U, Q> const& m);
+		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<4, 3, T, Q>& operator-=(mat<4, 3, U, Q> const& m);
 		template<typename U>
-		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<4, 3, T, Q> & operator*=(U s);
+		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<4, 3, T, Q>& operator*=(U s);
 		template<typename U>
-		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<4, 3, T, Q> & operator/=(U s);
+		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<4, 3, T, Q>& operator/=(U s);
 
 		// -- Increment and decrement operators --
 

glm/detail/type_mat4x3.inl

@@ -2,50 +2,23 @@ namespace glm
 {
 	// -- Constructors --
 
-#	if GLM_CONFIG_DEFAULTED_DEFAULT_CTOR == GLM_DISABLE
+#	if GLM_CONFIG_CTOR_INIT == GLM_ENABLE
 		template<typename T, qualifier Q>
 		GLM_DEFAULTED_DEFAULT_CTOR_QUALIFIER GLM_CONSTEXPR mat<4, 3, T, Q>::mat()
-#			if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALIZER_LIST
-				: value{col_type(1, 0, 0), col_type(0, 1, 0), col_type(0, 0, 1), col_type(0, 0, 0)}
-#			endif
-		{
-#			if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALISATION
-				this->value[0] = col_type(1, 0, 0);
-				this->value[1] = col_type(0, 1, 0);
-				this->value[2] = col_type(0, 0, 1);
-				this->value[3] = col_type(0, 0, 0);
-#			endif
-		}
+			: value{col_type(1, 0, 0), col_type(0, 1, 0), col_type(0, 0, 1), col_type(0, 0, 0)}
+		{}
 #	endif
 
 	template<typename T, qualifier Q>
 	template<qualifier P>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 3, T, Q>::mat(mat<4, 3, T, P> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(m[3])}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = m[0];
-			this->value[1] = m[1];
-			this->value[2] = m[2];
-			this->value[3] = m[3];
-#		endif
-	}
+		: value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(m[3])}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 3, T, Q>::mat(T s)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(s, 0, 0), col_type(0, s, 0), col_type(0, 0, s), col_type(0, 0, 0)}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(s, 0, 0);
-			this->value[1] = col_type(0, s, 0);
-			this->value[2] = col_type(0, 0, s);
-			this->value[3] = col_type(0, 0, 0);
-#		endif
-	}
+		: value{col_type(s, 0, 0), col_type(0, s, 0), col_type(0, 0, s), col_type(0, 0, 0)}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 3, T, Q>::mat
@@ -55,31 +28,13 @@ namespace glm
 		T const& x2, T const& y2, T const& z2,
 		T const& x3, T const& y3, T const& z3
 	)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(x0, y0, z0), col_type(x1, y1, z1), col_type(x2, y2, z2), col_type(x3, y3, z3)}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(x0, y0, z0);
-			this->value[1] = col_type(x1, y1, z1);
-			this->value[2] = col_type(x2, y2, z2);
-			this->value[3] = col_type(x3, y3, z3);
-#		endif
-	}
+		: value{col_type(x0, y0, z0), col_type(x1, y1, z1), col_type(x2, y2, z2), col_type(x3, y3, z3)}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 3, T, Q>::mat(col_type const& v0, col_type const& v1, col_type const& v2, col_type const& v3)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(v0), col_type(v1), col_type(v2), col_type(v3)}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = v0;
-			this->value[1] = v1;
-			this->value[2] = v2;
-			this->value[3] = v3;
-#		endif
-	}
+		: value{col_type(v0), col_type(v1), col_type(v2), col_type(v3)}
+	{}
 
 	// -- Conversion constructors --
 
@@ -96,161 +51,62 @@ namespace glm
 		X2 const& x2, Y2 const& y2, Z2 const& z2,
 		X3 const& x3, Y3 const& y3, Z3 const& z3
 	)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(x0, y0, z0), col_type(x1, y1, z1), col_type(x2, y2, z2), col_type(x3, y3, z3)}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(x0, y0, z0);
-			this->value[1] = col_type(x1, y1, z1);
-			this->value[2] = col_type(x2, y2, z2);
-			this->value[3] = col_type(x3, y3, z3);
-#		endif
-	}
+		: value{col_type(x0, y0, z0), col_type(x1, y1, z1), col_type(x2, y2, z2), col_type(x3, y3, z3)}
+	{}
 
 	template<typename T, qualifier Q>
 	template<typename V1, typename V2, typename V3, typename V4>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 3, T, Q>::mat(vec<3, V1, Q> const& v1, vec<3, V2, Q> const& v2, vec<3, V3, Q> const& v3, vec<3, V4, Q> const& v4)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(v1), col_type(v2), col_type(v3), col_type(v4)}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(v1);
-			this->value[1] = col_type(v2);
-			this->value[2] = col_type(v3);
-			this->value[3] = col_type(v4);
-#		endif
-	}
+		: value{col_type(v1), col_type(v2), col_type(v3), col_type(v4)}
+	{}
 
 	// -- Matrix conversions --
 
 	template<typename T, qualifier Q>
 	template<typename U, qualifier P>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 3, T, Q>::mat(mat<4, 3, U, P> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(m[3])}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(m[0]);
-			this->value[1] = col_type(m[1]);
-			this->value[2] = col_type(m[2]);
-			this->value[3] = col_type(m[3]);
-#		endif
-	}
+		: value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(m[3])}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 3, T, Q>::mat(mat<2, 2, T, Q> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0], 0), col_type(m[1], 0), col_type(0, 0, 1), col_type(0)}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(m[0], 0);
-			this->value[1] = col_type(m[1], 0);
-			this->value[2] = col_type(0, 0, 1);
-			this->value[3] = col_type(0);
-#		endif
-	}
+		: value{col_type(m[0], 0), col_type(m[1], 0), col_type(0, 0, 1), col_type(0)}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 3, T, Q>::mat(mat<3, 3, T, Q> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(0)}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(m[0]);
-			this->value[1] = col_type(m[1]);
-			this->value[2] = col_type(m[2]);
-			this->value[3] = col_type(0);
-#		endif
-	}
+		: value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(0)}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 3, T, Q>::mat(mat<4, 4, T, Q> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(m[3])}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(m[0]);
-			this->value[1] = col_type(m[1]);
-			this->value[2] = col_type(m[2]);
-			this->value[3] = col_type(m[3]);
-#		endif
-	}
+		: value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(m[3])}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 3, T, Q>::mat(mat<2, 3, T, Q> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0]), col_type(m[1]), col_type(0, 0, 1), col_type(0)}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(m[0]);
-			this->value[1] = col_type(m[1]);
-			this->value[2] = col_type(0, 0, 1);
-			this->value[3] = col_type(0);
-#		endif
-	}
+		: value{col_type(m[0]), col_type(m[1]), col_type(0, 0, 1), col_type(0)}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 3, T, Q>::mat(mat<3, 2, T, Q> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0], 0), col_type(m[1], 0), col_type(m[2], 1), col_type(0)}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(m[0], 0);
-			this->value[1] = col_type(m[1], 0);
-			this->value[2] = col_type(m[2], 1);
-			this->value[3] = col_type(0);
-#		endif
-	}
+		: value{col_type(m[0], 0), col_type(m[1], 0), col_type(m[2], 1), col_type(0)}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 3, T, Q>::mat(mat<2, 4, T, Q> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0]), col_type(m[1]), col_type(0, 0, 1), col_type(0)}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(m[0]);
-			this->value[1] = col_type(m[1]);
-			this->value[2] = col_type(0, 0, 1);
-			this->value[3] = col_type(0);
-#		endif
-	}
+		: value{col_type(m[0]), col_type(m[1]), col_type(0, 0, 1), col_type(0)}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 3, T, Q>::mat(mat<4, 2, T, Q> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0], 0), col_type(m[1], 0), col_type(m[2], 1), col_type(m[3], 0)}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(m[0], 0);
-			this->value[1] = col_type(m[1], 0);
-			this->value[2] = col_type(m[2], 1);
-			this->value[3] = col_type(m[3], 0);
-#		endif
-	}
+		: value{col_type(m[0], 0), col_type(m[1], 0), col_type(m[2], 1), col_type(m[3], 0)}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 3, T, Q>::mat(mat<3, 4, T, Q> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(0)}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(m[0]);
-			this->value[1] = col_type(m[1]);
-			this->value[2] = col_type(m[2]);
-			this->value[3] = col_type(0);
-#		endif
-	}
+		: value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(0)}
+	{}
 
 	// -- Accesses --
 

glm/detail/type_mat4x4.hpp

@@ -25,7 +25,7 @@ namespace glm
 		// -- Accesses --
 
 		typedef length_t length_type;
-		GLM_FUNC_DECL static GLM_CONSTEXPR length_type length(){return 4;}
+		GLM_FUNC_DECL static constexpr length_type length(){return 4;}
 
 		GLM_FUNC_DECL GLM_CONSTEXPR col_type & operator[](length_type i) GLM_NOEXCEPT;
 		GLM_FUNC_DECL GLM_CONSTEXPR col_type const& operator[](length_type i) const GLM_NOEXCEPT;
@@ -33,6 +33,7 @@ namespace glm
 		// -- Constructors --
 
 		GLM_DEFAULTED_DEFAULT_CTOR_DECL GLM_CONSTEXPR mat() GLM_DEFAULT_CTOR;
+		GLM_CTOR_DECL mat(mat<4, 4, T, Q> const& m) = default;
 		template<qualifier P>
 		GLM_CTOR_DECL mat(mat<4, 4, T, P> const& m);
 
@@ -84,29 +85,30 @@ namespace glm
 
 		// -- Unary arithmetic operators --
 
+		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<4, 4, T, Q>& operator=(mat<4, 4, T, Q> const& m) = default;
 		template<typename U>
-		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<4, 4, T, Q> & operator=(mat<4, 4, U, Q> const& m);
+		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<4, 4, T, Q>& operator=(mat<4, 4, U, Q> const& m);
 		template<typename U>
-		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<4, 4, T, Q> & operator+=(U s);
+		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<4, 4, T, Q>& operator+=(U s);
 		template<typename U>
-		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<4, 4, T, Q> & operator+=(mat<4, 4, U, Q> const& m);
+		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<4, 4, T, Q>& operator+=(mat<4, 4, U, Q> const& m);
 		template<typename U>
-		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<4, 4, T, Q> & operator-=(U s);
+		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<4, 4, T, Q>& operator-=(U s);
 		template<typename U>
-		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<4, 4, T, Q> & operator-=(mat<4, 4, U, Q> const& m);
+		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<4, 4, T, Q>& operator-=(mat<4, 4, U, Q> const& m);
 		template<typename U>
-		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<4, 4, T, Q> & operator*=(U s);
+		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<4, 4, T, Q>& operator*=(U s);
 		template<typename U>
-		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<4, 4, T, Q> & operator*=(mat<4, 4, U, Q> const& m);
+		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<4, 4, T, Q>& operator*=(mat<4, 4, U, Q> const& m);
 		template<typename U>
-		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<4, 4, T, Q> & operator/=(U s);
+		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<4, 4, T, Q>& operator/=(U s);
 		template<typename U>
-		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<4, 4, T, Q> & operator/=(mat<4, 4, U, Q> const& m);
+		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<4, 4, T, Q>& operator/=(mat<4, 4, U, Q> const& m);
 
 		// -- Increment and decrement operators --
 
-		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<4, 4, T, Q> & operator++();
-		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<4, 4, T, Q> & operator--();
+		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<4, 4, T, Q>& operator++();
+		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR mat<4, 4, T, Q>& operator--();
 		GLM_FUNC_DECL GLM_CONSTEXPR mat<4, 4, T, Q> operator++(int);
 		GLM_FUNC_DECL GLM_CONSTEXPR mat<4, 4, T, Q> operator--(int);
 	};

glm/detail/type_mat4x4.inl

@@ -5,50 +5,23 @@ namespace glm
 {
 	// -- Constructors --
 
-#	if GLM_CONFIG_DEFAULTED_DEFAULT_CTOR == GLM_DISABLE
+#	if GLM_CONFIG_CTOR_INIT == GLM_ENABLE
 		template<typename T, qualifier Q>
 		GLM_DEFAULTED_DEFAULT_CTOR_QUALIFIER GLM_CONSTEXPR mat<4, 4, T, Q>::mat()
-#			if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALIZER_LIST
-				: value{col_type(1, 0, 0, 0), col_type(0, 1, 0, 0), col_type(0, 0, 1, 0), col_type(0, 0, 0, 1)}
-#			endif
-		{
-#			if GLM_CONFIG_CTOR_INIT == GLM_CTOR_INITIALISATION
-				this->value[0] = col_type(1, 0, 0, 0);
-				this->value[1] = col_type(0, 1, 0, 0);
-				this->value[2] = col_type(0, 0, 1, 0);
-				this->value[3] = col_type(0, 0, 0, 1);
-#			endif
-		}
+			: value{col_type(1, 0, 0, 0), col_type(0, 1, 0, 0), col_type(0, 0, 1, 0), col_type(0, 0, 0, 1)}
+		{}
 #	endif
 
 	template<typename T, qualifier Q>
 	template<qualifier P>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 4, T, Q>::mat(mat<4, 4, T, P> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(m[3])}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = m[0];
-			this->value[1] = m[1];
-			this->value[2] = m[2];
-			this->value[3] = m[3];
-#		endif
-	}
+		: value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(m[3])}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 4, T, Q>::mat(T s)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(s, 0, 0, 0), col_type(0, s, 0, 0), col_type(0, 0, s, 0), col_type(0, 0, 0, s)}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(s, 0, 0, 0);
-			this->value[1] = col_type(0, s, 0, 0);
-			this->value[2] = col_type(0, 0, s, 0);
-			this->value[3] = col_type(0, 0, 0, s);
-#		endif
-	}
+		: value{col_type(s, 0, 0, 0), col_type(0, s, 0, 0), col_type(0, 0, s, 0), col_type(0, 0, 0, s)}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 4, T, Q>::mat
@@ -58,50 +31,23 @@ namespace glm
 		T const& x2, T const& y2, T const& z2, T const& w2,
 		T const& x3, T const& y3, T const& z3, T const& w3
 	)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{
-				col_type(x0, y0, z0, w0),
-				col_type(x1, y1, z1, w1),
-				col_type(x2, y2, z2, w2),
-				col_type(x3, y3, z3, w3)}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(x0, y0, z0, w0);
-			this->value[1] = col_type(x1, y1, z1, w1);
-			this->value[2] = col_type(x2, y2, z2, w2);
-			this->value[3] = col_type(x3, y3, z3, w3);
-#		endif
-	}
+		: value{
+			col_type(x0, y0, z0, w0),
+			col_type(x1, y1, z1, w1),
+			col_type(x2, y2, z2, w2),
+			col_type(x3, y3, z3, w3)}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 4, T, Q>::mat(col_type const& v0, col_type const& v1, col_type const& v2, col_type const& v3)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(v0), col_type(v1), col_type(v2), col_type(v3)}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = v0;
-			this->value[1] = v1;
-			this->value[2] = v2;
-			this->value[3] = v3;
-#		endif
-	}
+		: value{col_type(v0), col_type(v1), col_type(v2), col_type(v3)}
+	{}
 
 	template<typename T, qualifier Q>
 	template<typename U, qualifier P>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 4, T, Q>::mat(mat<4, 4, U, P> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(m[3])}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(m[0]);
-			this->value[1] = col_type(m[1]);
-			this->value[2] = col_type(m[2]);
-			this->value[3] = col_type(m[3]);
-#		endif
-	}
+		: value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(m[3])}
+	{}
 
 	// -- Conversions --
 
@@ -118,9 +64,7 @@ namespace glm
 		X3 const& x3, Y3 const& y3, Z3 const& z3, W3 const& w3,
 		X4 const& x4, Y4 const& y4, Z4 const& z4, W4 const& w4
 	)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(x1, y1, z1, w1), col_type(x2, y2, z2, w2), col_type(x3, y3, z3, w3), col_type(x4, y4, z4, w4)}
-#		endif
+		: value{col_type(x1, y1, z1, w1), col_type(x2, y2, z2, w2), col_type(x3, y3, z3, w3), col_type(x4, y4, z4, w4)}
 	{
 		static_assert(std::numeric_limits<X1>::is_iec559 || std::numeric_limits<X1>::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 1st parameter type invalid.");
 		static_assert(std::numeric_limits<Y1>::is_iec559 || std::numeric_limits<Y1>::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 2nd parameter type invalid.");
@@ -141,148 +85,60 @@ namespace glm
 		static_assert(std::numeric_limits<Y4>::is_iec559 || std::numeric_limits<Y4>::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 14th parameter type invalid.");
 		static_assert(std::numeric_limits<Z4>::is_iec559 || std::numeric_limits<Z4>::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 15th parameter type invalid.");
 		static_assert(std::numeric_limits<W4>::is_iec559 || std::numeric_limits<W4>::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 16th parameter type invalid.");
-
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(x1, y1, z1, w1);
-			this->value[1] = col_type(x2, y2, z2, w2);
-			this->value[2] = col_type(x3, y3, z3, w3);
-			this->value[3] = col_type(x4, y4, z4, w4);
-#		endif
 	}
 
 	template<typename T, qualifier Q>
 	template<typename V1, typename V2, typename V3, typename V4>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 4, T, Q>::mat(vec<4, V1, Q> const& v1, vec<4, V2, Q> const& v2, vec<4, V3, Q> const& v3, vec<4, V4, Q> const& v4)
-#		if GLM_HAS_INITIALIZER_LISTS
 			: value{col_type(v1), col_type(v2), col_type(v3), col_type(v4)}
-#		endif
 	{
 		static_assert(std::numeric_limits<V1>::is_iec559 || std::numeric_limits<V1>::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 1st parameter type invalid.");
 		static_assert(std::numeric_limits<V2>::is_iec559 || std::numeric_limits<V2>::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 2nd parameter type invalid.");
 		static_assert(std::numeric_limits<V3>::is_iec559 || std::numeric_limits<V3>::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 3rd parameter type invalid.");
 		static_assert(std::numeric_limits<V4>::is_iec559 || std::numeric_limits<V4>::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 4th parameter type invalid.");
-
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(v1);
-			this->value[1] = col_type(v2);
-			this->value[2] = col_type(v3);
-			this->value[3] = col_type(v4);
-#		endif
 	}
 
 	// -- Matrix conversions --
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 4, T, Q>::mat(mat<2, 2, T, Q> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0], 0, 0), col_type(m[1], 0, 0), col_type(0, 0, 1, 0), col_type(0, 0, 0, 1)}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(m[0], 0, 0);
-			this->value[1] = col_type(m[1], 0, 0);
-			this->value[2] = col_type(0, 0, 1, 0);
-			this->value[3] = col_type(0, 0, 0, 1);
-#		endif
-	}
+		: value{col_type(m[0], 0, 0), col_type(m[1], 0, 0), col_type(0, 0, 1, 0), col_type(0, 0, 0, 1)}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 4, T, Q>::mat(mat<3, 3, T, Q> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0], 0), col_type(m[1], 0), col_type(m[2], 0), col_type(0, 0, 0, 1)}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(m[0], 0);
-			this->value[1] = col_type(m[1], 0);
-			this->value[2] = col_type(m[2], 0);
-			this->value[3] = col_type(0, 0, 0, 1);
-#		endif
-	}
+		: value{col_type(m[0], 0), col_type(m[1], 0), col_type(m[2], 0), col_type(0, 0, 0, 1)}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 4, T, Q>::mat(mat<2, 3, T, Q> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0], 0), col_type(m[1], 0), col_type(0, 0, 1, 0), col_type(0, 0, 0, 1)}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(m[0], 0);
-			this->value[1] = col_type(m[1], 0);
-			this->value[2] = col_type(0, 0, 1, 0);
-			this->value[3] = col_type(0, 0, 0, 1);
-#		endif
-	}
+		: value{col_type(m[0], 0), col_type(m[1], 0), col_type(0, 0, 1, 0), col_type(0, 0, 0, 1)}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 4, T, Q>::mat(mat<3, 2, T, Q> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0], 0, 0), col_type(m[1], 0, 0), col_type(m[2], 1, 0), col_type(0, 0, 0, 1)}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(m[0], 0, 0);
-			this->value[1] = col_type(m[1], 0, 0);
-			this->value[2] = col_type(m[2], 1, 0);
-			this->value[3] = col_type(0, 0, 0, 1);
-#		endif
-	}
+		: value{col_type(m[0], 0, 0), col_type(m[1], 0, 0), col_type(m[2], 1, 0), col_type(0, 0, 0, 1)}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 4, T, Q>::mat(mat<2, 4, T, Q> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0]), col_type(m[1]), col_type(0, 0, 1, 0), col_type(0, 0, 0, 1)}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = m[0];
-			this->value[1] = m[1];
-			this->value[2] = col_type(0, 0, 1, 0);
-			this->value[3] = col_type(0, 0, 0, 1);
-#		endif
-	}
+		: value{col_type(m[0]), col_type(m[1]), col_type(0, 0, 1, 0), col_type(0, 0, 0, 1)}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 4, T, Q>::mat(mat<4, 2, T, Q> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0], 0, 0), col_type(m[1], 0, 0), col_type(0, 0, 1, 0), col_type(0, 0, 0, 1)}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(m[0], 0, 0);
-			this->value[1] = col_type(m[1], 0, 0);
-			this->value[2] = col_type(0, 0, 1, 0);
-			this->value[3] = col_type(0, 0, 0, 1);
-#		endif
-	}
+		: value{col_type(m[0], 0, 0), col_type(m[1], 0, 0), col_type(0, 0, 1, 0), col_type(0, 0, 0, 1)}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 4, T, Q>::mat(mat<3, 4, T, Q> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(0, 0, 0, 1)}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = m[0];
-			this->value[1] = m[1];
-			this->value[2] = m[2];
-			this->value[3] = col_type(0, 0, 0, 1);
-#		endif
-	}
+		: value{col_type(m[0]), col_type(m[1]), col_type(m[2]), col_type(0, 0, 0, 1)}
+	{}
 
 	template<typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 4, T, Q>::mat(mat<4, 3, T, Q> const& m)
-#		if GLM_HAS_INITIALIZER_LISTS
-			: value{col_type(m[0], 0), col_type(m[1], 0), col_type(m[2], 0), col_type(m[3], 1)}
-#		endif
-	{
-#		if !GLM_HAS_INITIALIZER_LISTS
-			this->value[0] = col_type(m[0], 0);
-			this->value[1] = col_type(m[1], 0);
-			this->value[2] = col_type(m[2], 0);
-			this->value[3] = col_type(m[3], 1);
-#		endif
-	}
+		: value{col_type(m[0], 0), col_type(m[1], 0), col_type(m[2], 0), col_type(m[3], 1)}
+	{}
 
 	// -- Accesses --
 

glm/detail/type_quat.hpp

@@ -63,7 +63,7 @@ namespace glm
 		typedef length_t length_type;
 
 		/// Return the count of components of a quaternion
-		GLM_FUNC_DECL static GLM_CONSTEXPR length_type length(){return 4;}
+		GLM_FUNC_DECL static constexpr length_type length(){return 4;}
 
 		GLM_FUNC_DECL GLM_CONSTEXPR T & operator[](length_type i);
 		GLM_FUNC_DECL GLM_CONSTEXPR T const& operator[](length_type i) const;
@@ -71,7 +71,7 @@ namespace glm
 		// -- Implicit basic constructors --
 
 		GLM_DEFAULTED_DEFAULT_CTOR_DECL GLM_CONSTEXPR qua() GLM_DEFAULT_CTOR;
-		GLM_DEFAULTED_FUNC_DECL GLM_CONSTEXPR qua(qua<T, Q> const& q) GLM_DEFAULT;
+		GLM_CTOR_DECL qua(qua<T, Q> const& q) = default;
 		template<qualifier P>
 		GLM_CTOR_DECL qua(qua<T, P> const& q);
 
@@ -110,7 +110,7 @@ namespace glm
 
 		// -- Unary arithmetic operators --
 
-		GLM_DEFAULTED_FUNC_DECL GLM_CONSTEXPR qua<T, Q>& operator=(qua<T, Q> const& q) GLM_DEFAULT;
+		GLM_DEFAULTED_FUNC_DECL GLM_CONSTEXPR qua<T, Q>& operator=(qua<T, Q> const& q) = default;
 
 		template<typename U>
 		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR qua<T, Q>& operator=(qua<U, Q> const& q);

glm/detail/type_quat.inl

@@ -95,26 +95,13 @@ namespace detail
 
 	// -- Implicit basic constructors --
 
-#	if GLM_CONFIG_DEFAULTED_DEFAULT_CTOR == GLM_DISABLE
+#	if GLM_CONFIG_CTOR_INIT == GLM_ENABLE
 		template<typename T, qualifier Q>
 		GLM_DEFAULTED_DEFAULT_CTOR_QUALIFIER GLM_CONSTEXPR qua<T, Q>::qua()
-#			if GLM_CONFIG_CTOR_INIT != GLM_CTOR_INIT_DISABLE
-#				ifdef GLM_FORCE_QUAT_DATA_WXYZ
-					: w(1), x(0), y(0), z(0)
-#				else
-					: x(0), y(0), z(0), w(1)
-#				endif
-#			endif
-		{}
-#	endif
-
-#	if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE
-		template<typename T, qualifier Q>
-		GLM_DEFAULTED_FUNC_QUALIFIER GLM_CONSTEXPR qua<T, Q>::qua(qua<T, Q> const& q)
 #			ifdef GLM_FORCE_QUAT_DATA_WXYZ
-				: w(q.w), x(q.x), y(q.y), z(q.z)
+				: w(1), x(0), y(0), z(0)
 #			else
-				: x(q.x), y(q.y), z(q.z), w(q.w)
+				: x(0), y(0), z(0), w(1)
 #			endif
 		{}
 #	endif
@@ -254,18 +241,6 @@ namespace detail
 
 	// -- Unary arithmetic operators --
 
-#	if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE
-		template<typename T, qualifier Q>
-		GLM_DEFAULTED_FUNC_QUALIFIER GLM_CONSTEXPR qua<T, Q> & qua<T, Q>::operator=(qua<T, Q> const& q)
-		{
-			this->w = q.w;
-			this->x = q.x;
-			this->y = q.y;
-			this->z = q.z;
-			return *this;
-		}
-#	endif
-
 	template<typename T, qualifier Q>
 	template<typename U>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR qua<T, Q> & qua<T, Q>::operator=(qua<U, Q> const& q)

glm/detail/type_vec1.hpp

@@ -85,7 +85,7 @@ namespace glm
 
 		/// Return the count of components of the vector
 		typedef length_t length_type;
-		GLM_FUNC_DECL static GLM_CONSTEXPR length_type length(){return 1;}
+		GLM_FUNC_DECL static constexpr length_type length(){return 1;}
 
 		GLM_FUNC_DECL GLM_CONSTEXPR T & operator[](length_type i);
 		GLM_FUNC_DECL GLM_CONSTEXPR T const& operator[](length_type i) const;
@@ -93,7 +93,7 @@ namespace glm
 		// -- Implicit basic constructors --
 
 		GLM_DEFAULTED_DEFAULT_CTOR_DECL GLM_CONSTEXPR vec() GLM_DEFAULT_CTOR;
-		GLM_DEFAULTED_FUNC_DECL GLM_CONSTEXPR vec(vec const& v) GLM_DEFAULT;
+		GLM_CTOR_DECL vec(vec<1, T, Q> const& v) = default;
 		template<qualifier P>
 		GLM_CTOR_DECL vec(vec<1, T, P> const& v);
 
@@ -129,7 +129,7 @@ namespace glm
 */
 		// -- Unary arithmetic operators --
 
-		GLM_DEFAULTED_FUNC_DECL GLM_CONSTEXPR vec<1, T, Q> & operator=(vec const& v) GLM_DEFAULT;
+		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR vec<1, T, Q> & operator=(vec const& v) = default;
 
 		template<typename U>
 		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR vec<1, T, Q> & operator=(vec<1, U, Q> const& v);

glm/detail/type_vec1.inl

@@ -6,19 +6,10 @@ namespace glm
 {
 	// -- Implicit basic constructors --
 
-#	if GLM_CONFIG_DEFAULTED_DEFAULT_CTOR == GLM_DISABLE
+#	if GLM_CONFIG_CTOR_INIT == GLM_ENABLE
 		template<typename T, qualifier Q>
 		GLM_DEFAULTED_DEFAULT_CTOR_QUALIFIER GLM_CONSTEXPR vec<1, T, Q>::vec()
-#			if GLM_CONFIG_CTOR_INIT != GLM_CTOR_INIT_DISABLE
-				: x(0)
-#			endif
-		{}
-#	endif
-
-#	if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE
-		template<typename T, qualifier Q>
-		GLM_DEFAULTED_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q>::vec(vec<1, T, Q> const& v)
-			: x(v.x)
+			: x(0)
 		{}
 #	endif
 
@@ -77,15 +68,6 @@ namespace glm
 
 	// -- Unary arithmetic operators --
 
-#	if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE
-		template<typename T, qualifier Q>
-		GLM_DEFAULTED_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator=(vec<1, T, Q> const& v)
-		{
-			this->x = v.x;
-			return *this;
-		}
-#	endif
-
 	template<typename T, qualifier Q>
 	template<typename U>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, Q> & vec<1, T, Q>::operator=(vec<1, U, Q> const& v)

glm/detail/type_vec2.hpp

@@ -91,7 +91,7 @@ namespace glm
 
 		/// Return the count of components of the vector
 		typedef length_t length_type;
-		GLM_FUNC_DECL static GLM_CONSTEXPR length_type length(){return 2;}
+		GLM_FUNC_DECL static constexpr length_type length(){return 2;}
 
 		GLM_FUNC_DECL GLM_CONSTEXPR T& operator[](length_type i);
 		GLM_FUNC_DECL GLM_CONSTEXPR T const& operator[](length_type i) const;
@@ -99,7 +99,7 @@ namespace glm
 		// -- Implicit basic constructors --
 
 		GLM_DEFAULTED_DEFAULT_CTOR_DECL GLM_CONSTEXPR vec() GLM_DEFAULT_CTOR;
-		GLM_DEFAULTED_FUNC_DECL GLM_CONSTEXPR vec(vec const& v) GLM_DEFAULT;
+		GLM_CTOR_DECL vec(vec<2, T, Q> const& v) = default;
 		template<qualifier P>
 		GLM_CTOR_DECL vec(vec<2, T, P> const& v);
 
@@ -147,7 +147,7 @@ namespace glm
 
 		// -- Unary arithmetic operators --
 
-		GLM_DEFAULTED_FUNC_DECL GLM_CONSTEXPR vec<2, T, Q> & operator=(vec const& v) GLM_DEFAULT;
+		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR vec<2, T, Q> & operator=(vec const& v) = default;
 
 		template<typename U>
 		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR vec<2, T, Q> & operator=(vec<2, U, Q> const& v);

glm/detail/type_vec2.inl

@@ -6,19 +6,10 @@ namespace glm
 {
 	// -- Implicit basic constructors --
 
-#	if GLM_CONFIG_DEFAULTED_DEFAULT_CTOR == GLM_DISABLE
+#	if GLM_CONFIG_CTOR_INIT == GLM_ENABLE
 		template<typename T, qualifier Q>
 		GLM_DEFAULTED_DEFAULT_CTOR_QUALIFIER GLM_CONSTEXPR vec<2, T, Q>::vec()
-#			if GLM_CONFIG_CTOR_INIT != GLM_CTOR_INIT_DISABLE
-				: x(0), y(0)
-#			endif
-		{}
-#	endif
-
-#	if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE
-		template<typename T, qualifier Q>
-		GLM_DEFAULTED_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q>::vec(vec<2, T, Q> const& v)
-			: x(v.x), y(v.y)
+			: x(0), y(0)
 		{}
 #	endif
 
@@ -132,16 +123,6 @@ namespace glm
 
 	// -- Unary arithmetic operators --
 
-#	if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE
-		template<typename T, qualifier Q>
-		GLM_DEFAULTED_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator=(vec<2, T, Q> const& v)
-		{
-			this->x = v.x;
-			this->y = v.y;
-			return *this;
-		}
-#	endif
-
 	template<typename T, qualifier Q>
 	template<typename U>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, Q> & vec<2, T, Q>::operator=(vec<2, U, Q> const& v)

glm/detail/type_vec3.hpp

@@ -97,7 +97,7 @@ namespace glm
 
 		/// Return the count of components of the vector
 		typedef length_t length_type;
-		GLM_FUNC_DECL static GLM_CONSTEXPR length_type length(){return 3;}
+		GLM_FUNC_DECL static constexpr length_type length(){return 3;}
 
 		GLM_FUNC_DECL GLM_CONSTEXPR T & operator[](length_type i);
 		GLM_FUNC_DECL GLM_CONSTEXPR T const& operator[](length_type i) const;
@@ -105,7 +105,7 @@ namespace glm
 		// -- Implicit basic constructors --
 
 		GLM_DEFAULTED_DEFAULT_CTOR_DECL GLM_CONSTEXPR vec() GLM_DEFAULT_CTOR;
-		GLM_DEFAULTED_FUNC_DECL GLM_CONSTEXPR vec(vec const& v) GLM_DEFAULT;
+		GLM_CTOR_DECL vec(vec<3, T, Q> const& v) = default;
 		template<qualifier P>
 		GLM_CTOR_DECL vec(vec<3, T, P> const& v);
 
@@ -182,7 +182,7 @@ namespace glm
 
 		// -- Unary arithmetic operators --
 
-		GLM_DEFAULTED_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q>& operator=(vec<3, T, Q> const& v) GLM_DEFAULT;
+		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR vec<3, T, Q>& operator=(vec<3, T, Q> const& v) = default;
 
 		template<typename U>
 		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR vec<3, T, Q> & operator=(vec<3, U, Q> const& v);

glm/detail/type_vec3.inl

@@ -7,19 +7,10 @@ namespace glm
 {
 	// -- Implicit basic constructors --
 
-#	if GLM_CONFIG_DEFAULTED_DEFAULT_CTOR == GLM_DISABLE
+#	if GLM_CONFIG_CTOR_INIT == GLM_ENABLE
 		template<typename T, qualifier Q>
 		GLM_DEFAULTED_DEFAULT_CTOR_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>::vec()
-#			if GLM_CONFIG_CTOR_INIT != GLM_CTOR_INIT_DISABLE
-				: x(0), y(0), z(0)
-#			endif
-		{}
-#	endif
-
-#	if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE
-		template<typename T, qualifier Q>
-		GLM_DEFAULTED_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>::vec(vec<3, T, Q> const& v)
-			: x(v.x), y(v.y), z(v.z)
+			: x(0), y(0), z(0)
 		{}
 #	endif
 
@@ -201,17 +192,6 @@ namespace glm
 
 	// -- Unary arithmetic operators --
 
-#	if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE
-		template<typename T, qualifier Q>
-		GLM_DEFAULTED_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>& vec<3, T, Q>::operator=(vec<3, T, Q> const& v)
-		{
-			this->x = v.x;
-			this->y = v.y;
-			this->z = v.z;
-			return *this;
-		}
-#	endif
-
 	template<typename T, qualifier Q>
 	template<typename U>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q>& vec<3, T, Q>::operator=(vec<3, U, Q> const& v)

glm/detail/type_vec4.hpp

@@ -95,7 +95,7 @@ namespace glm
 		typedef length_t length_type;
 
 		/// Return the count of components of the vector
-		GLM_FUNC_DECL static GLM_CONSTEXPR length_type length(){return 4;}
+		GLM_FUNC_DECL static constexpr length_type length(){return 4;}
 
 		GLM_FUNC_DECL GLM_CONSTEXPR T & operator[](length_type i);
 		GLM_FUNC_DECL GLM_CONSTEXPR T const& operator[](length_type i) const;
@@ -103,7 +103,7 @@ namespace glm
 		// -- Implicit basic constructors --
 
 		GLM_DEFAULTED_DEFAULT_CTOR_DECL GLM_CONSTEXPR vec() GLM_DEFAULT_CTOR;
-		GLM_DEFAULTED_FUNC_DECL GLM_CONSTEXPR vec(vec<4, T, Q> const& v) GLM_DEFAULT;
+		GLM_CTOR_DECL vec(vec<4, T, Q> const& v) = default;
 		template<qualifier P>
 		GLM_CTOR_DECL vec(vec<4, T, P> const& v);
 
@@ -254,7 +254,7 @@ namespace glm
 
 		// -- Unary arithmetic operators --
 
-		GLM_DEFAULTED_FUNC_DECL GLM_CONSTEXPR vec<4, T, Q>& operator=(vec<4, T, Q> const& v) GLM_DEFAULT;
+		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR vec<4, T, Q>& operator=(vec<4, T, Q> const& v) = default;
 
 		template<typename U>
 		GLM_FUNC_DISCARD_DECL GLM_CONSTEXPR vec<4, T, Q>& operator=(vec<4, U, Q> const& v);

glm/detail/type_vec4.inl

@@ -11,19 +11,10 @@ namespace detail
 
 	// -- Implicit basic constructors --
 
-#	if GLM_CONFIG_DEFAULTED_DEFAULT_CTOR == GLM_DISABLE
+#	if GLM_CONFIG_CTOR_INIT == GLM_ENABLE
 		template<typename T, qualifier Q>
 		GLM_DEFAULTED_DEFAULT_CTOR_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec()
-#			if GLM_CONFIG_CTOR_INIT != GLM_CTOR_INIT_DISABLE
-				: x(0), y(0), z(0), w(0)
-#			endif
-		{}
-#	endif
-
-#	if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE
-		template<typename T, qualifier Q>
-		GLM_DEFAULTED_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>::vec(vec<4, T, Q> const& v)
-			: x(v.x), y(v.y), z(v.z), w(v.w)
+			: x(0), y(0), z(0), w(0)
 		{}
 #	endif
 
@@ -396,18 +387,6 @@ namespace detail
 
 	// -- Unary arithmetic operators --
 
-#	if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_DISABLE
-		template<typename T, qualifier Q>
-		GLM_DEFAULTED_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>& vec<4, T, Q>::operator=(vec<4, T, Q> const& v)
-		{
-			this->x = v.x;
-			this->y = v.y;
-			this->z = v.z;
-			this->w = v.w;
-			return *this;
-		}
-#	endif
-
 	template<typename T, qualifier Q>
 	template<typename U>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, T, Q>& vec<4, T, Q>::operator=(vec<4, U, Q> const& v)

glm/ext/matrix_double2x2.hpp

@@ -21,3 +21,17 @@ namespace glm
 
 	/// @}
 }//namespace glm
+
+#if GLM_CONFIG_CTOR_INIT == GLM_DISABLE
+static_assert(std::is_trivially_default_constructible<glm::dmat2x2>::value);
+static_assert(std::is_trivially_default_constructible<glm::dmat2>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::dmat2x2>::value);
+static_assert(std::is_trivially_copy_assignable<glm::dmat2>::value);
+static_assert(std::is_trivially_copyable<glm::dmat2x2>::value);
+static_assert(std::is_trivially_copyable<glm::dmat2>::value);
+static_assert(std::is_copy_constructible<glm::dmat2x2>::value);
+static_assert(std::is_copy_constructible<glm::dmat2>::value);
+static_assert(glm::dmat2x2::length() == 2);
+static_assert(glm::dmat2::length() == 2);
+

glm/ext/matrix_double2x2_precision.hpp

@@ -47,3 +47,36 @@ namespace glm
 
 	/// @}
 }//namespace glm
+
+#if GLM_CONFIG_CTOR_INIT == GLM_DISABLE
+static_assert(std::is_trivially_default_constructible<glm::lowp_dmat2x2>::value);
+static_assert(std::is_trivially_default_constructible<glm::mediump_dmat2x2>::value);
+static_assert(std::is_trivially_default_constructible<glm::highp_dmat2x2>::value);
+static_assert(std::is_trivially_default_constructible<glm::lowp_dmat2>::value);
+static_assert(std::is_trivially_default_constructible<glm::mediump_dmat2>::value);
+static_assert(std::is_trivially_default_constructible<glm::highp_dmat2>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::lowp_dmat2x2>::value);
+static_assert(std::is_trivially_copy_assignable<glm::mediump_dmat2x2>::value);
+static_assert(std::is_trivially_copy_assignable<glm::highp_dmat2x2>::value);
+static_assert(std::is_trivially_copy_assignable<glm::lowp_dmat2>::value);
+static_assert(std::is_trivially_copy_assignable<glm::mediump_dmat2>::value);
+static_assert(std::is_trivially_copy_assignable<glm::highp_dmat2>::value);
+static_assert(std::is_trivially_copyable<glm::lowp_dmat2x2>::value);
+static_assert(std::is_trivially_copyable<glm::mediump_dmat2x2>::value);
+static_assert(std::is_trivially_copyable<glm::highp_dmat2x2>::value);
+static_assert(std::is_trivially_copyable<glm::lowp_dmat2>::value);
+static_assert(std::is_trivially_copyable<glm::mediump_dmat2>::value);
+static_assert(std::is_trivially_copyable<glm::highp_dmat2>::value);
+static_assert(std::is_copy_constructible<glm::lowp_dmat2x2>::value);
+static_assert(std::is_copy_constructible<glm::mediump_dmat2x2>::value);
+static_assert(std::is_copy_constructible<glm::highp_dmat2x2>::value);
+static_assert(std::is_copy_constructible<glm::lowp_dmat2>::value);
+static_assert(std::is_copy_constructible<glm::mediump_dmat2>::value);
+static_assert(std::is_copy_constructible<glm::highp_dmat2>::value);
+static_assert(glm::lowp_dmat2x2::length() == 2);
+static_assert(glm::mediump_dmat2x2::length() == 2);
+static_assert(glm::highp_dmat2x2::length() == 2);
+static_assert(glm::lowp_dmat2::length() == 2);
+static_assert(glm::mediump_dmat2::length() == 2);
+static_assert(glm::highp_dmat2::length() == 2);

glm/ext/matrix_double2x3.hpp

@@ -16,3 +16,12 @@ namespace glm
 
 	/// @}
 }//namespace glm
+
+#if GLM_CONFIG_CTOR_INIT == GLM_DISABLE
+static_assert(std::is_trivially_default_constructible<glm::dmat2x3>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::dmat2x3>::value);
+static_assert(std::is_trivially_copyable<glm::dmat2x3>::value);
+static_assert(std::is_copy_constructible<glm::dmat2x3>::value);
+static_assert(glm::dmat2x3::length() == 2);
+

glm/ext/matrix_double2x3_precision.hpp

@@ -29,3 +29,22 @@ namespace glm
 
 	/// @}
 }//namespace glm
+
+#if GLM_CONFIG_CTOR_INIT == GLM_DISABLE
+static_assert(std::is_trivially_default_constructible<glm::lowp_dmat2x3>::value);
+static_assert(std::is_trivially_default_constructible<glm::mediump_dmat2x3>::value);
+static_assert(std::is_trivially_default_constructible<glm::highp_dmat2x3>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::lowp_dmat2x3>::value);
+static_assert(std::is_trivially_copy_assignable<glm::mediump_dmat2x3>::value);
+static_assert(std::is_trivially_copy_assignable<glm::highp_dmat2x3>::value);
+static_assert(std::is_trivially_copyable<glm::lowp_dmat2x3>::value);
+static_assert(std::is_trivially_copyable<glm::mediump_dmat2x3>::value);
+static_assert(std::is_trivially_copyable<glm::highp_dmat2x3>::value);
+static_assert(std::is_copy_constructible<glm::lowp_dmat2x3>::value);
+static_assert(std::is_copy_constructible<glm::mediump_dmat2x3>::value);
+static_assert(std::is_copy_constructible<glm::highp_dmat2x3>::value);
+static_assert(glm::lowp_dmat2x3::length() == 2);
+static_assert(glm::mediump_dmat2x3::length() == 2);
+static_assert(glm::highp_dmat2x3::length() == 2);
+

glm/ext/matrix_double2x4.hpp

@@ -16,3 +16,11 @@ namespace glm
 
 	/// @}
 }//namespace glm
+
+#if GLM_CONFIG_CTOR_INIT == GLM_DISABLE
+static_assert(std::is_trivially_default_constructible<glm::dmat2x4>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::dmat2x4>::value);
+static_assert(std::is_trivially_copyable<glm::dmat2x4>::value);
+static_assert(std::is_copy_constructible<glm::dmat2x4>::value);
+static_assert(glm::dmat2x4::length() == 2);

glm/ext/matrix_double2x4_precision.hpp

@@ -29,3 +29,21 @@ namespace glm
 
 	/// @}
 }//namespace glm
+
+#if GLM_CONFIG_CTOR_INIT == GLM_DISABLE
+static_assert(std::is_trivially_default_constructible<glm::lowp_dmat2x4>::value);
+static_assert(std::is_trivially_default_constructible<glm::mediump_dmat2x4>::value);
+static_assert(std::is_trivially_default_constructible<glm::highp_dmat2x4>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::lowp_dmat2x4>::value);
+static_assert(std::is_trivially_copy_assignable<glm::mediump_dmat2x4>::value);
+static_assert(std::is_trivially_copy_assignable<glm::highp_dmat2x4>::value);
+static_assert(std::is_trivially_copyable<glm::lowp_dmat2x4>::value);
+static_assert(std::is_trivially_copyable<glm::mediump_dmat2x4>::value);
+static_assert(std::is_trivially_copyable<glm::highp_dmat2x4>::value);
+static_assert(std::is_copy_constructible<glm::lowp_dmat2x4>::value);
+static_assert(std::is_copy_constructible<glm::mediump_dmat2x4>::value);
+static_assert(std::is_copy_constructible<glm::highp_dmat2x4>::value);
+static_assert(glm::lowp_dmat2x4::length() == 2);
+static_assert(glm::mediump_dmat2x4::length() == 2);
+static_assert(glm::highp_dmat2x4::length() == 2);

glm/ext/matrix_double3x2.hpp

@@ -16,3 +16,11 @@ namespace glm
 
 	/// @}
 }//namespace glm
+
+#if GLM_CONFIG_CTOR_INIT == GLM_DISABLE
+static_assert(std::is_trivially_default_constructible<glm::dmat3x2>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::dmat3x2>::value);
+static_assert(std::is_trivially_copyable<glm::dmat3x2>::value);
+static_assert(std::is_copy_constructible<glm::dmat3x2>::value);
+static_assert(glm::dmat3x2::length() == 3);

glm/ext/matrix_double3x2_precision.hpp

@@ -29,3 +29,21 @@ namespace glm
 
 	/// @}
 }//namespace glm
+
+#if GLM_CONFIG_CTOR_INIT == GLM_DISABLE
+static_assert(std::is_trivially_default_constructible<glm::lowp_dmat3x2>::value);
+static_assert(std::is_trivially_default_constructible<glm::mediump_dmat3x2>::value);
+static_assert(std::is_trivially_default_constructible<glm::highp_dmat3x2>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::lowp_dmat3x2>::value);
+static_assert(std::is_trivially_copy_assignable<glm::mediump_dmat3x2>::value);
+static_assert(std::is_trivially_copy_assignable<glm::highp_dmat3x2>::value);
+static_assert(std::is_trivially_copyable<glm::lowp_dmat3x2>::value);
+static_assert(std::is_trivially_copyable<glm::mediump_dmat3x2>::value);
+static_assert(std::is_trivially_copyable<glm::highp_dmat3x2>::value);
+static_assert(std::is_copy_constructible<glm::lowp_dmat3x2>::value);
+static_assert(std::is_copy_constructible<glm::mediump_dmat3x2>::value);
+static_assert(std::is_copy_constructible<glm::highp_dmat3x2>::value);
+static_assert(glm::lowp_dmat3x2::length() == 3);
+static_assert(glm::mediump_dmat3x2::length() == 3);
+static_assert(glm::highp_dmat3x2::length() == 3);

glm/ext/matrix_double3x3.hpp

@@ -21,3 +21,17 @@ namespace glm
 
 	/// @}
 }//namespace glm
+
+#if GLM_CONFIG_CTOR_INIT == GLM_DISABLE
+static_assert(std::is_trivially_default_constructible<glm::dmat3x3>::value);
+static_assert(std::is_trivially_default_constructible<glm::dmat3>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::dmat3x3>::value);
+static_assert(std::is_trivially_copy_assignable<glm::dmat3>::value);
+static_assert(std::is_trivially_copyable<glm::dmat3x3>::value);
+static_assert(std::is_trivially_copyable<glm::dmat3>::value);
+static_assert(std::is_copy_constructible<glm::dmat3x3>::value);
+static_assert(std::is_copy_constructible<glm::dmat3>::value);
+static_assert(glm::dmat3x3::length() == 3);
+static_assert(glm::dmat3::length() == 3);
+

glm/ext/matrix_double3x3_precision.hpp

@@ -47,3 +47,36 @@ namespace glm
 
 	/// @}
 }//namespace glm
+
+#if GLM_CONFIG_CTOR_INIT == GLM_DISABLE
+static_assert(std::is_trivially_default_constructible<glm::lowp_dmat3x3>::value);
+static_assert(std::is_trivially_default_constructible<glm::mediump_dmat3x3>::value);
+static_assert(std::is_trivially_default_constructible<glm::highp_dmat3x3>::value);
+static_assert(std::is_trivially_default_constructible<glm::lowp_dmat3>::value);
+static_assert(std::is_trivially_default_constructible<glm::mediump_dmat3>::value);
+static_assert(std::is_trivially_default_constructible<glm::highp_dmat3>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::lowp_dmat3x3>::value);
+static_assert(std::is_trivially_copy_assignable<glm::mediump_dmat3x3>::value);
+static_assert(std::is_trivially_copy_assignable<glm::highp_dmat3x3>::value);
+static_assert(std::is_trivially_copy_assignable<glm::lowp_dmat3>::value);
+static_assert(std::is_trivially_copy_assignable<glm::mediump_dmat3>::value);
+static_assert(std::is_trivially_copy_assignable<glm::highp_dmat3>::value);
+static_assert(std::is_trivially_copyable<glm::lowp_dmat3x3>::value);
+static_assert(std::is_trivially_copyable<glm::mediump_dmat3x3>::value);
+static_assert(std::is_trivially_copyable<glm::highp_dmat3x3>::value);
+static_assert(std::is_trivially_copyable<glm::lowp_dmat3>::value);
+static_assert(std::is_trivially_copyable<glm::mediump_dmat3>::value);
+static_assert(std::is_trivially_copyable<glm::highp_dmat3>::value);
+static_assert(std::is_copy_constructible<glm::lowp_dmat3x3>::value);
+static_assert(std::is_copy_constructible<glm::mediump_dmat3x3>::value);
+static_assert(std::is_copy_constructible<glm::highp_dmat3x3>::value);
+static_assert(std::is_copy_constructible<glm::lowp_dmat3>::value);
+static_assert(std::is_copy_constructible<glm::mediump_dmat3>::value);
+static_assert(std::is_copy_constructible<glm::highp_dmat3>::value);
+static_assert(glm::lowp_dmat3x3::length() == 3);
+static_assert(glm::mediump_dmat3x3::length() == 3);
+static_assert(glm::highp_dmat3x3::length() == 3);
+static_assert(glm::lowp_dmat3::length() == 3);
+static_assert(glm::mediump_dmat3::length() == 3);
+static_assert(glm::highp_dmat3::length() == 3);

glm/ext/matrix_double3x4.hpp

@@ -16,3 +16,11 @@ namespace glm
 
 	/// @}
 }//namespace glm
+
+#if GLM_CONFIG_CTOR_INIT == GLM_DISABLE
+static_assert(std::is_trivially_default_constructible<glm::dmat3x4>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::dmat3x4>::value);
+static_assert(std::is_trivially_copyable<glm::dmat3x4>::value);
+static_assert(std::is_copy_constructible<glm::dmat3x4>::value);
+static_assert(glm::dmat3x4::length() == 3);

glm/ext/matrix_double3x4_precision.hpp

@@ -29,3 +29,22 @@ namespace glm
 
 	/// @}
 }//namespace glm
+
+#if GLM_CONFIG_CTOR_INIT == GLM_DISABLE
+static_assert(std::is_trivially_default_constructible<glm::lowp_dmat3x4>::value);
+static_assert(std::is_trivially_default_constructible<glm::mediump_dmat3x4>::value);
+static_assert(std::is_trivially_default_constructible<glm::highp_dmat3x4>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::lowp_dmat3x4>::value);
+static_assert(std::is_trivially_copy_assignable<glm::mediump_dmat3x4>::value);
+static_assert(std::is_trivially_copy_assignable<glm::highp_dmat3x4>::value);
+static_assert(std::is_trivially_copyable<glm::lowp_dmat3x4>::value);
+static_assert(std::is_trivially_copyable<glm::mediump_dmat3x4>::value);
+static_assert(std::is_trivially_copyable<glm::highp_dmat3x4>::value);
+static_assert(std::is_copy_constructible<glm::lowp_dmat3x4>::value);
+static_assert(std::is_copy_constructible<glm::mediump_dmat3x4>::value);
+static_assert(std::is_copy_constructible<glm::highp_dmat3x4>::value);
+static_assert(glm::lowp_dmat3x4::length() == 3);
+static_assert(glm::mediump_dmat3x4::length() == 3);
+static_assert(glm::highp_dmat3x4::length() == 3);
+

glm/ext/matrix_double4x2.hpp

@@ -16,3 +16,11 @@ namespace glm
 
 	/// @}
 }//namespace glm
+
+#if GLM_CONFIG_CTOR_INIT == GLM_DISABLE
+static_assert(std::is_trivially_default_constructible<glm::dmat4x2>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::dmat4x2>::value);
+static_assert(std::is_trivially_copyable<glm::dmat4x2>::value);
+static_assert(std::is_copy_constructible<glm::dmat4x2>::value);
+static_assert(glm::dmat4x2::length() == 4);

glm/ext/matrix_double4x2_precision.hpp

@@ -29,3 +29,21 @@ namespace glm
 
 	/// @}
 }//namespace glm
+
+#if GLM_CONFIG_CTOR_INIT == GLM_DISABLE
+static_assert(std::is_trivially_default_constructible<glm::lowp_dmat4x2>::value);
+static_assert(std::is_trivially_default_constructible<glm::mediump_dmat4x2>::value);
+static_assert(std::is_trivially_default_constructible<glm::highp_dmat4x2>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::lowp_dmat4x2>::value);
+static_assert(std::is_trivially_copy_assignable<glm::mediump_dmat4x2>::value);
+static_assert(std::is_trivially_copy_assignable<glm::highp_dmat4x2>::value);
+static_assert(std::is_trivially_copyable<glm::lowp_dmat4x2>::value);
+static_assert(std::is_trivially_copyable<glm::mediump_dmat4x2>::value);
+static_assert(std::is_trivially_copyable<glm::highp_dmat4x2>::value);
+static_assert(std::is_copy_constructible<glm::lowp_dmat4x2>::value);
+static_assert(std::is_copy_constructible<glm::mediump_dmat4x2>::value);
+static_assert(std::is_copy_constructible<glm::highp_dmat4x2>::value);
+static_assert(glm::lowp_dmat4x2::length() == 4);
+static_assert(glm::mediump_dmat4x2::length() == 4);
+static_assert(glm::highp_dmat4x2::length() == 4);

glm/ext/matrix_double4x3.hpp

@@ -16,3 +16,11 @@ namespace glm
 
 	/// @}
 }//namespace glm
+
+#if GLM_CONFIG_CTOR_INIT == GLM_DISABLE
+static_assert(std::is_trivially_default_constructible<glm::dmat4x3>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::dmat4x3>::value);
+static_assert(std::is_trivially_copyable<glm::dmat4x3>::value);
+static_assert(std::is_copy_constructible<glm::dmat4x3>::value);
+static_assert(glm::dmat4x3::length() == 4);

glm/ext/matrix_double4x3_precision.hpp

@@ -29,3 +29,21 @@ namespace glm
 
 	/// @}
 }//namespace glm
+
+#if GLM_CONFIG_CTOR_INIT == GLM_DISABLE
+static_assert(std::is_trivially_default_constructible<glm::lowp_dmat4x3>::value);
+static_assert(std::is_trivially_default_constructible<glm::mediump_dmat4x3>::value);
+static_assert(std::is_trivially_default_constructible<glm::highp_dmat4x3>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::lowp_dmat4x3>::value);
+static_assert(std::is_trivially_copy_assignable<glm::mediump_dmat4x3>::value);
+static_assert(std::is_trivially_copy_assignable<glm::highp_dmat4x3>::value);
+static_assert(std::is_trivially_copyable<glm::lowp_dmat4x3>::value);
+static_assert(std::is_trivially_copyable<glm::mediump_dmat4x3>::value);
+static_assert(std::is_trivially_copyable<glm::highp_dmat4x3>::value);
+static_assert(std::is_copy_constructible<glm::lowp_dmat4x3>::value);
+static_assert(std::is_copy_constructible<glm::mediump_dmat4x3>::value);
+static_assert(std::is_copy_constructible<glm::highp_dmat4x3>::value);
+static_assert(glm::lowp_dmat4x3::length() == 4);
+static_assert(glm::mediump_dmat4x3::length() == 4);
+static_assert(glm::highp_dmat4x3::length() == 4);

glm/ext/matrix_double4x4.hpp

@@ -21,3 +21,17 @@ namespace glm
 
 	/// @}
 }//namespace glm
+
+#if GLM_CONFIG_CTOR_INIT == GLM_DISABLE
+static_assert(std::is_trivially_default_constructible<glm::dmat4x4>::value);
+static_assert(std::is_trivially_default_constructible<glm::dmat4>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::dmat4x4>::value);
+static_assert(std::is_trivially_copy_assignable<glm::dmat4>::value);
+static_assert(std::is_trivially_copyable<glm::dmat4x4>::value);
+static_assert(std::is_trivially_copyable<glm::dmat4>::value);
+static_assert(std::is_copy_constructible<glm::dmat4x4>::value);
+static_assert(std::is_copy_constructible<glm::dmat4>::value);
+static_assert(glm::dmat4x4::length() == 4);
+static_assert(glm::dmat4::length() == 4);
+

glm/ext/matrix_double4x4_precision.hpp

@@ -47,3 +47,36 @@ namespace glm
 
 	/// @}
 }//namespace glm
+
+#if GLM_CONFIG_CTOR_INIT == GLM_DISABLE
+static_assert(std::is_trivially_default_constructible<glm::lowp_dmat4x4>::value);
+static_assert(std::is_trivially_default_constructible<glm::mediump_dmat4x4>::value);
+static_assert(std::is_trivially_default_constructible<glm::highp_dmat4x4>::value);
+static_assert(std::is_trivially_default_constructible<glm::lowp_dmat4>::value);
+static_assert(std::is_trivially_default_constructible<glm::mediump_dmat4>::value);
+static_assert(std::is_trivially_default_constructible<glm::highp_dmat4>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::lowp_dmat4x4>::value);
+static_assert(std::is_trivially_copy_assignable<glm::mediump_dmat4x4>::value);
+static_assert(std::is_trivially_copy_assignable<glm::highp_dmat4x4>::value);
+static_assert(std::is_trivially_copy_assignable<glm::lowp_dmat4>::value);
+static_assert(std::is_trivially_copy_assignable<glm::mediump_dmat4>::value);
+static_assert(std::is_trivially_copy_assignable<glm::highp_dmat4>::value);
+static_assert(std::is_trivially_copyable<glm::lowp_dmat4x4>::value);
+static_assert(std::is_trivially_copyable<glm::mediump_dmat4x4>::value);
+static_assert(std::is_trivially_copyable<glm::highp_dmat4x4>::value);
+static_assert(std::is_trivially_copyable<glm::lowp_dmat4>::value);
+static_assert(std::is_trivially_copyable<glm::mediump_dmat4>::value);
+static_assert(std::is_trivially_copyable<glm::highp_dmat4>::value);
+static_assert(std::is_copy_constructible<glm::lowp_dmat4x4>::value);
+static_assert(std::is_copy_constructible<glm::mediump_dmat4x4>::value);
+static_assert(std::is_copy_constructible<glm::highp_dmat4x4>::value);
+static_assert(std::is_copy_constructible<glm::lowp_dmat4>::value);
+static_assert(std::is_copy_constructible<glm::mediump_dmat4>::value);
+static_assert(std::is_copy_constructible<glm::highp_dmat4>::value);
+static_assert(glm::lowp_dmat4x4::length() == 4);
+static_assert(glm::mediump_dmat4x4::length() == 4);
+static_assert(glm::highp_dmat4x4::length() == 4);
+static_assert(glm::lowp_dmat4::length() == 4);
+static_assert(glm::mediump_dmat4::length() == 4);
+static_assert(glm::highp_dmat4::length() == 4);

glm/ext/matrix_float2x2.hpp

@@ -21,3 +21,16 @@ namespace glm
 
 	/// @}
 }//namespace glm
+
+#if GLM_CONFIG_CTOR_INIT == GLM_DISABLE
+static_assert(std::is_trivially_default_constructible<glm::mat2x2>::value);
+static_assert(std::is_trivially_default_constructible<glm::mat2>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::mat2x2>::value);
+static_assert(std::is_trivially_copy_assignable<glm::mat2>::value);
+static_assert(std::is_trivially_copyable<glm::mat2x2>::value);
+static_assert(std::is_trivially_copyable<glm::mat2>::value);
+static_assert(std::is_copy_constructible<glm::mat2x2>::value);
+static_assert(std::is_copy_constructible<glm::mat2>::value);
+static_assert(glm::mat2x2::length() == 2);
+static_assert(glm::mat2::length() == 2);

glm/ext/matrix_float2x2_precision.hpp

@@ -47,3 +47,37 @@ namespace glm
 
 	/// @}
 }//namespace glm
+
+#if GLM_CONFIG_CTOR_INIT == GLM_DISABLE
+static_assert(std::is_trivially_default_constructible<glm::lowp_mat2x2>::value);
+static_assert(std::is_trivially_default_constructible<glm::mediump_mat2x2>::value);
+static_assert(std::is_trivially_default_constructible<glm::highp_mat2x2>::value);
+static_assert(std::is_trivially_default_constructible<glm::lowp_mat2>::value);
+static_assert(std::is_trivially_default_constructible<glm::mediump_mat2>::value);
+static_assert(std::is_trivially_default_constructible<glm::highp_mat2>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::lowp_mat2x2>::value);
+static_assert(std::is_trivially_copy_assignable<glm::mediump_mat2x2>::value);
+static_assert(std::is_trivially_copy_assignable<glm::highp_mat2x2>::value);
+static_assert(std::is_trivially_copy_assignable<glm::lowp_mat2>::value);
+static_assert(std::is_trivially_copy_assignable<glm::mediump_mat2>::value);
+static_assert(std::is_trivially_copy_assignable<glm::highp_mat2>::value);
+static_assert(std::is_trivially_copyable<glm::lowp_mat2x2>::value);
+static_assert(std::is_trivially_copyable<glm::mediump_mat2x2>::value);
+static_assert(std::is_trivially_copyable<glm::highp_mat2x2>::value);
+static_assert(std::is_trivially_copyable<glm::lowp_mat2>::value);
+static_assert(std::is_trivially_copyable<glm::mediump_mat2>::value);
+static_assert(std::is_trivially_copyable<glm::highp_mat2>::value);
+static_assert(std::is_copy_constructible<glm::lowp_mat2x2>::value);
+static_assert(std::is_copy_constructible<glm::mediump_mat2x2>::value);
+static_assert(std::is_copy_constructible<glm::highp_mat2x2>::value);
+static_assert(std::is_copy_constructible<glm::lowp_mat2>::value);
+static_assert(std::is_copy_constructible<glm::mediump_mat2>::value);
+static_assert(std::is_copy_constructible<glm::highp_mat2>::value);
+static_assert(glm::lowp_mat2x2::length() == 2);
+static_assert(glm::mediump_mat2x2::length() == 2);
+static_assert(glm::highp_mat2x2::length() == 2);
+static_assert(glm::lowp_mat2::length() == 2);
+static_assert(glm::mediump_mat2::length() == 2);
+static_assert(glm::highp_mat2::length() == 2);
+

glm/ext/matrix_float2x3.hpp

@@ -16,3 +16,12 @@ namespace glm
 
 	/// @}
 }//namespace glm
+
+#if GLM_CONFIG_CTOR_INIT == GLM_DISABLE
+static_assert(std::is_trivially_default_constructible<glm::mat2x3>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::mat2x3>::value);
+static_assert(std::is_trivially_copyable<glm::mat2x3>::value);
+static_assert(std::is_copy_constructible<glm::mat2x3>::value);
+static_assert(glm::mat2x3::length() == 2);
+

glm/ext/matrix_float2x3_precision.hpp

@@ -29,3 +29,23 @@ namespace glm
 
 	/// @}
 }//namespace glm
+
+#if GLM_CONFIG_CTOR_INIT == GLM_DISABLE
+static_assert(std::is_trivially_default_constructible<glm::lowp_mat2x3>::value);
+static_assert(std::is_trivially_default_constructible<glm::mediump_mat2x3>::value);
+static_assert(std::is_trivially_default_constructible<glm::highp_mat2x3>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::lowp_mat2x3>::value);
+static_assert(std::is_trivially_copy_assignable<glm::mediump_mat2x3>::value);
+static_assert(std::is_trivially_copy_assignable<glm::highp_mat2x3>::value);
+static_assert(std::is_trivially_copyable<glm::lowp_mat2x3>::value);
+static_assert(std::is_trivially_copyable<glm::mediump_mat2x3>::value);
+static_assert(std::is_trivially_copyable<glm::highp_mat2x3>::value);
+static_assert(std::is_copy_constructible<glm::lowp_mat2x3>::value);
+static_assert(std::is_copy_constructible<glm::mediump_mat2x3>::value);
+static_assert(std::is_copy_constructible<glm::highp_mat2x3>::value);
+static_assert(glm::lowp_mat2x3::length() == 2);
+static_assert(glm::mediump_mat2x3::length() == 2);
+static_assert(glm::highp_mat2x3::length() == 2);
+
+

glm/ext/matrix_float2x4.hpp

@@ -16,3 +16,13 @@ namespace glm
 
 	/// @}
 }//namespace glm
+
+#if GLM_CONFIG_CTOR_INIT == GLM_DISABLE
+static_assert(std::is_trivially_default_constructible<glm::mat2x4>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::mat2x4>::value);
+static_assert(std::is_trivially_copyable<glm::mat2x4>::value);
+static_assert(std::is_copy_constructible<glm::mat2x4>::value);
+static_assert(glm::mat2x4::length() == 2);
+
+

glm/ext/matrix_float2x4_precision.hpp

@@ -29,3 +29,21 @@ namespace glm
 
 	/// @}
 }//namespace glm
+
+#if GLM_CONFIG_CTOR_INIT == GLM_DISABLE
+static_assert(std::is_trivially_default_constructible<glm::lowp_mat2x4>::value);
+static_assert(std::is_trivially_default_constructible<glm::mediump_mat2x4>::value);
+static_assert(std::is_trivially_default_constructible<glm::highp_mat2x4>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::lowp_mat2x4>::value);
+static_assert(std::is_trivially_copy_assignable<glm::mediump_mat2x4>::value);
+static_assert(std::is_trivially_copy_assignable<glm::highp_mat2x4>::value);
+static_assert(std::is_trivially_copyable<glm::lowp_mat2x4>::value);
+static_assert(std::is_trivially_copyable<glm::mediump_mat2x4>::value);
+static_assert(std::is_trivially_copyable<glm::highp_mat2x4>::value);
+static_assert(std::is_copy_constructible<glm::lowp_mat2x4>::value);
+static_assert(std::is_copy_constructible<glm::mediump_mat2x4>::value);
+static_assert(std::is_copy_constructible<glm::highp_mat2x4>::value);
+static_assert(glm::lowp_mat2x4::length() == 2);
+static_assert(glm::mediump_mat2x4::length() == 2);
+static_assert(glm::highp_mat2x4::length() == 2);

glm/ext/matrix_float3x2.hpp

@@ -16,3 +16,11 @@ namespace glm
 
 	/// @}
 }//namespace glm
+
+#if GLM_CONFIG_CTOR_INIT == GLM_DISABLE
+static_assert(std::is_trivially_default_constructible<glm::mat3x2>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::mat3x2>::value);
+static_assert(std::is_trivially_copyable<glm::mat3x2>::value);
+static_assert(std::is_copy_constructible<glm::mat3x2>::value);
+static_assert(glm::mat3x2::length() == 3);

glm/ext/matrix_float3x2_precision.hpp

@@ -29,3 +29,22 @@ namespace glm
 
 	/// @}
 }//namespace glm
+
+#if GLM_CONFIG_CTOR_INIT == GLM_DISABLE
+static_assert(std::is_trivially_default_constructible<glm::lowp_mat3x2>::value);
+static_assert(std::is_trivially_default_constructible<glm::mediump_mat3x2>::value);
+static_assert(std::is_trivially_default_constructible<glm::highp_mat3x2>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::lowp_mat3x2>::value);
+static_assert(std::is_trivially_copy_assignable<glm::mediump_mat3x2>::value);
+static_assert(std::is_trivially_copy_assignable<glm::highp_mat3x2>::value);
+static_assert(std::is_trivially_copyable<glm::lowp_mat3x2>::value);
+static_assert(std::is_trivially_copyable<glm::mediump_mat3x2>::value);
+static_assert(std::is_trivially_copyable<glm::highp_mat3x2>::value);
+static_assert(std::is_copy_constructible<glm::lowp_mat3x2>::value);
+static_assert(std::is_copy_constructible<glm::mediump_mat3x2>::value);
+static_assert(std::is_copy_constructible<glm::highp_mat3x2>::value);
+static_assert(glm::lowp_mat3x2::length() == 3);
+static_assert(glm::mediump_mat3x2::length() == 3);
+static_assert(glm::highp_mat3x2::length() == 3);
+

glm/ext/matrix_float3x3.hpp

@@ -21,3 +21,16 @@ namespace glm
 
 	/// @}
 }//namespace glm
+
+#if GLM_CONFIG_CTOR_INIT == GLM_DISABLE
+static_assert(std::is_trivially_default_constructible<glm::mat3x3>::value);
+static_assert(std::is_trivially_default_constructible<glm::mat3>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::mat3x3>::value);
+static_assert(std::is_trivially_copy_assignable<glm::mat3>::value);
+static_assert(std::is_trivially_copyable<glm::mat3x3>::value);
+static_assert(std::is_trivially_copyable<glm::mat3>::value);
+static_assert(std::is_copy_constructible<glm::mat3x3>::value);
+static_assert(std::is_copy_constructible<glm::mat3>::value);
+static_assert(glm::mat3x3::length() == 3);
+static_assert(glm::mat3::length() == 3);

glm/ext/matrix_float3x3_precision.hpp

@@ -47,3 +47,37 @@ namespace glm
 
 	/// @}
 }//namespace glm
+
+#if GLM_CONFIG_CTOR_INIT == GLM_DISABLE
+static_assert(std::is_trivially_default_constructible<glm::lowp_mat3x3>::value);
+static_assert(std::is_trivially_default_constructible<glm::mediump_mat3x3>::value);
+static_assert(std::is_trivially_default_constructible<glm::highp_mat3x3>::value);
+static_assert(std::is_trivially_default_constructible<glm::lowp_mat3>::value);
+static_assert(std::is_trivially_default_constructible<glm::mediump_mat3>::value);
+static_assert(std::is_trivially_default_constructible<glm::highp_mat3>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::lowp_mat3x3>::value);
+static_assert(std::is_trivially_copy_assignable<glm::mediump_mat3x3>::value);
+static_assert(std::is_trivially_copy_assignable<glm::highp_mat3x3>::value);
+static_assert(std::is_trivially_copy_assignable<glm::lowp_mat3>::value);
+static_assert(std::is_trivially_copy_assignable<glm::mediump_mat3>::value);
+static_assert(std::is_trivially_copy_assignable<glm::highp_mat3>::value);
+static_assert(std::is_trivially_copyable<glm::lowp_mat3x3>::value);
+static_assert(std::is_trivially_copyable<glm::mediump_mat3x3>::value);
+static_assert(std::is_trivially_copyable<glm::highp_mat3x3>::value);
+static_assert(std::is_trivially_copyable<glm::lowp_mat3>::value);
+static_assert(std::is_trivially_copyable<glm::mediump_mat3>::value);
+static_assert(std::is_trivially_copyable<glm::highp_mat3>::value);
+static_assert(std::is_copy_constructible<glm::lowp_mat3x3>::value);
+static_assert(std::is_copy_constructible<glm::mediump_mat3x3>::value);
+static_assert(std::is_copy_constructible<glm::highp_mat3x3>::value);
+static_assert(std::is_copy_constructible<glm::lowp_mat3>::value);
+static_assert(std::is_copy_constructible<glm::mediump_mat3>::value);
+static_assert(std::is_copy_constructible<glm::highp_mat3>::value);
+static_assert(glm::lowp_mat3x3::length() == 3);
+static_assert(glm::mediump_mat3x3::length() == 3);
+static_assert(glm::highp_mat3x3::length() == 3);
+static_assert(glm::lowp_mat3::length() == 3);
+static_assert(glm::mediump_mat3::length() == 3);
+static_assert(glm::highp_mat3::length() == 3);
+

glm/ext/matrix_float3x4.hpp

@@ -16,3 +16,11 @@ namespace glm
 
 	/// @}
 }//namespace glm
+
+#if GLM_CONFIG_CTOR_INIT == GLM_DISABLE
+static_assert(std::is_trivially_default_constructible<glm::mat3x4>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::mat3x4>::value);
+static_assert(std::is_trivially_copyable<glm::mat3x4>::value);
+static_assert(std::is_copy_constructible<glm::mat3x4>::value);
+static_assert(glm::mat3x4::length() == 3);

glm/ext/matrix_float3x4_precision.hpp

@@ -29,3 +29,21 @@ namespace glm
 
 	/// @}
 }//namespace glm
+
+#if GLM_CONFIG_CTOR_INIT == GLM_DISABLE
+static_assert(std::is_trivially_default_constructible<glm::lowp_mat3x4>::value);
+static_assert(std::is_trivially_default_constructible<glm::mediump_mat3x4>::value);
+static_assert(std::is_trivially_default_constructible<glm::highp_mat3x4>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::lowp_mat3x4>::value);
+static_assert(std::is_trivially_copy_assignable<glm::mediump_mat3x4>::value);
+static_assert(std::is_trivially_copy_assignable<glm::highp_mat3x4>::value);
+static_assert(std::is_trivially_copyable<glm::lowp_mat3x4>::value);
+static_assert(std::is_trivially_copyable<glm::mediump_mat3x4>::value);
+static_assert(std::is_trivially_copyable<glm::highp_mat3x4>::value);
+static_assert(std::is_copy_constructible<glm::lowp_mat3x4>::value);
+static_assert(std::is_copy_constructible<glm::mediump_mat3x4>::value);
+static_assert(std::is_copy_constructible<glm::highp_mat3x4>::value);
+static_assert(glm::lowp_mat3x4::length() == 3);
+static_assert(glm::mediump_mat3x4::length() == 3);
+static_assert(glm::highp_mat3x4::length() == 3);

glm/ext/matrix_float4x2.hpp

@@ -16,3 +16,11 @@ namespace glm
 
 	/// @}
 }//namespace glm
+
+#if GLM_CONFIG_CTOR_INIT == GLM_DISABLE
+static_assert(std::is_trivially_default_constructible<glm::mat4x2>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::mat4x2>::value);
+static_assert(std::is_trivially_copyable<glm::mat4x2>::value);
+static_assert(std::is_copy_constructible<glm::mat4x2>::value);
+static_assert(glm::mat4x2::length() == 4);

glm/ext/matrix_float4x2_precision.hpp

@@ -29,3 +29,21 @@ namespace glm
 
 	/// @}
 }//namespace glm
+
+#if GLM_CONFIG_CTOR_INIT == GLM_DISABLE
+static_assert(std::is_trivially_default_constructible<glm::lowp_mat4x2>::value);
+static_assert(std::is_trivially_default_constructible<glm::mediump_mat4x2>::value);
+static_assert(std::is_trivially_default_constructible<glm::highp_mat4x2>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::lowp_mat4x2>::value);
+static_assert(std::is_trivially_copy_assignable<glm::mediump_mat4x2>::value);
+static_assert(std::is_trivially_copy_assignable<glm::highp_mat4x2>::value);
+static_assert(std::is_trivially_copyable<glm::lowp_mat4x2>::value);
+static_assert(std::is_trivially_copyable<glm::mediump_mat4x2>::value);
+static_assert(std::is_trivially_copyable<glm::highp_mat4x2>::value);
+static_assert(std::is_copy_constructible<glm::lowp_mat4x2>::value);
+static_assert(std::is_copy_constructible<glm::mediump_mat4x2>::value);
+static_assert(std::is_copy_constructible<glm::highp_mat4x2>::value);
+static_assert(glm::lowp_mat4x2::length() == 4);
+static_assert(glm::mediump_mat4x2::length() == 4);
+static_assert(glm::highp_mat4x2::length() == 4);

glm/ext/matrix_float4x3.hpp

@@ -16,3 +16,11 @@ namespace glm
 
 	/// @}
 }//namespace glm
+
+#if GLM_CONFIG_CTOR_INIT == GLM_DISABLE
+static_assert(std::is_trivially_default_constructible<glm::mat4x3>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::mat4x3>::value);
+static_assert(std::is_trivially_copyable<glm::mat4x3>::value);
+static_assert(std::is_copy_constructible<glm::mat4x3>::value);
+static_assert(glm::mat4x3::length() == 4);

glm/ext/matrix_float4x3_precision.hpp

@@ -29,3 +29,21 @@ namespace glm
 
 	/// @}
 }//namespace glm
+
+#if GLM_CONFIG_CTOR_INIT == GLM_DISABLE
+static_assert(std::is_trivially_default_constructible<glm::lowp_mat4x3>::value);
+static_assert(std::is_trivially_default_constructible<glm::mediump_mat4x3>::value);
+static_assert(std::is_trivially_default_constructible<glm::highp_mat4x3>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::lowp_mat4x3>::value);
+static_assert(std::is_trivially_copy_assignable<glm::mediump_mat4x3>::value);
+static_assert(std::is_trivially_copy_assignable<glm::highp_mat4x3>::value);
+static_assert(std::is_trivially_copyable<glm::lowp_mat4x3>::value);
+static_assert(std::is_trivially_copyable<glm::mediump_mat4x3>::value);
+static_assert(std::is_trivially_copyable<glm::highp_mat4x3>::value);
+static_assert(std::is_copy_constructible<glm::lowp_mat4x3>::value);
+static_assert(std::is_copy_constructible<glm::mediump_mat4x3>::value);
+static_assert(std::is_copy_constructible<glm::highp_mat4x3>::value);
+static_assert(glm::lowp_mat4x3::length() == 4);
+static_assert(glm::mediump_mat4x3::length() == 4);
+static_assert(glm::highp_mat4x3::length() == 4);

glm/ext/matrix_float4x4.hpp

@@ -21,3 +21,16 @@ namespace glm
 
 	/// @}
 }//namespace glm
+
+#if GLM_CONFIG_CTOR_INIT == GLM_DISABLE
+static_assert(std::is_trivially_default_constructible<glm::mat4x4>::value);
+static_assert(std::is_trivially_default_constructible<glm::mat4>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::mat4x4>::value);
+static_assert(std::is_trivially_copy_assignable<glm::mat4>::value);
+static_assert(std::is_trivially_copyable<glm::mat4x4>::value);
+static_assert(std::is_trivially_copyable<glm::mat4>::value);
+static_assert(std::is_copy_constructible<glm::mat4x4>::value);
+static_assert(std::is_copy_constructible<glm::mat4>::value);
+static_assert(glm::mat4x4::length() == 4);
+static_assert(glm::mat4::length() == 4);

glm/ext/matrix_float4x4_precision.hpp

@@ -47,3 +47,36 @@ namespace glm
 
 	/// @}
 }//namespace glm
+
+#if GLM_CONFIG_CTOR_INIT == GLM_DISABLE
+static_assert(std::is_trivially_default_constructible<glm::lowp_mat4x4>::value);
+static_assert(std::is_trivially_default_constructible<glm::mediump_mat4x4>::value);
+static_assert(std::is_trivially_default_constructible<glm::highp_mat4x4>::value);
+static_assert(std::is_trivially_default_constructible<glm::lowp_mat4>::value);
+static_assert(std::is_trivially_default_constructible<glm::mediump_mat4>::value);
+static_assert(std::is_trivially_default_constructible<glm::highp_mat4>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::lowp_mat4x4>::value);
+static_assert(std::is_trivially_copy_assignable<glm::mediump_mat4x4>::value);
+static_assert(std::is_trivially_copy_assignable<glm::highp_mat4x4>::value);
+static_assert(std::is_trivially_copy_assignable<glm::lowp_mat4>::value);
+static_assert(std::is_trivially_copy_assignable<glm::mediump_mat4>::value);
+static_assert(std::is_trivially_copy_assignable<glm::highp_mat4>::value);
+static_assert(std::is_trivially_copyable<glm::lowp_mat4x4>::value);
+static_assert(std::is_trivially_copyable<glm::mediump_mat4x4>::value);
+static_assert(std::is_trivially_copyable<glm::highp_mat4x4>::value);
+static_assert(std::is_trivially_copyable<glm::lowp_mat4>::value);
+static_assert(std::is_trivially_copyable<glm::mediump_mat4>::value);
+static_assert(std::is_trivially_copyable<glm::highp_mat4>::value);
+static_assert(std::is_copy_constructible<glm::lowp_mat4x4>::value);
+static_assert(std::is_copy_constructible<glm::mediump_mat4x4>::value);
+static_assert(std::is_copy_constructible<glm::highp_mat4x4>::value);
+static_assert(std::is_copy_constructible<glm::lowp_mat4>::value);
+static_assert(std::is_copy_constructible<glm::mediump_mat4>::value);
+static_assert(std::is_copy_constructible<glm::highp_mat4>::value);
+static_assert(glm::lowp_mat4x4::length() == 4);
+static_assert(glm::mediump_mat4x4::length() == 4);
+static_assert(glm::highp_mat4x4::length() == 4);
+static_assert(glm::lowp_mat4::length() == 4);
+static_assert(glm::mediump_mat4::length() == 4);
+static_assert(glm::highp_mat4::length() == 4);

glm/ext/matrix_int2x2.hpp

@@ -36,3 +36,17 @@ namespace glm
 
 	/// @}
 }//namespace glm
+
+#if GLM_CONFIG_CTOR_INIT == GLM_DISABLE
+static_assert(std::is_trivially_default_constructible<glm::imat2x2>::value);
+static_assert(std::is_trivially_default_constructible<glm::imat2>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::imat2x2>::value);
+static_assert(std::is_trivially_copy_assignable<glm::imat2>::value);
+static_assert(std::is_trivially_copyable<glm::imat2x2>::value);
+static_assert(std::is_trivially_copyable<glm::imat2>::value);
+static_assert(std::is_copy_constructible<glm::imat2x2>::value);
+static_assert(std::is_copy_constructible<glm::imat2>::value);
+static_assert(glm::imat2x2::length() == 2);
+static_assert(glm::imat2::length() == 2);
+

glm/ext/matrix_int2x2_sized.hpp

@@ -68,3 +68,46 @@ namespace glm
 
 	/// @}
 }//namespace glm
+
+#if GLM_CONFIG_CTOR_INIT == GLM_DISABLE
+static_assert(std::is_trivially_default_constructible<glm::i8mat2x2>::value);
+static_assert(std::is_trivially_default_constructible<glm::i16mat2x2>::value);
+static_assert(std::is_trivially_default_constructible<glm::i32mat2x2>::value);
+static_assert(std::is_trivially_default_constructible<glm::i64mat2x2>::value);
+static_assert(std::is_trivially_default_constructible<glm::i8mat2>::value);
+static_assert(std::is_trivially_default_constructible<glm::i16mat2>::value);
+static_assert(std::is_trivially_default_constructible<glm::i32mat2>::value);
+static_assert(std::is_trivially_default_constructible<glm::i64mat2>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::i8mat2x2>::value);
+static_assert(std::is_trivially_copy_assignable<glm::i16mat2x2>::value);
+static_assert(std::is_trivially_copy_assignable<glm::i32mat2x2>::value);
+static_assert(std::is_trivially_copy_assignable<glm::i64mat2x2>::value);
+static_assert(std::is_trivially_copy_assignable<glm::i8mat2>::value);
+static_assert(std::is_trivially_copy_assignable<glm::i16mat2>::value);
+static_assert(std::is_trivially_copy_assignable<glm::i32mat2>::value);
+static_assert(std::is_trivially_copy_assignable<glm::i64mat2>::value);
+static_assert(std::is_trivially_copyable<glm::i8mat2x2>::value);
+static_assert(std::is_trivially_copyable<glm::i16mat2x2>::value);
+static_assert(std::is_trivially_copyable<glm::i32mat2x2>::value);
+static_assert(std::is_trivially_copyable<glm::i64mat2x2>::value);
+static_assert(std::is_trivially_copyable<glm::i8mat2>::value);
+static_assert(std::is_trivially_copyable<glm::i16mat2>::value);
+static_assert(std::is_trivially_copyable<glm::i32mat2>::value);
+static_assert(std::is_trivially_copyable<glm::i64mat2>::value);
+static_assert(std::is_copy_constructible<glm::i8mat2x2>::value);
+static_assert(std::is_copy_constructible<glm::i16mat2x2>::value);
+static_assert(std::is_copy_constructible<glm::i32mat2x2>::value);
+static_assert(std::is_copy_constructible<glm::i64mat2x2>::value);
+static_assert(std::is_copy_constructible<glm::i8mat2>::value);
+static_assert(std::is_copy_constructible<glm::i16mat2>::value);
+static_assert(std::is_copy_constructible<glm::i32mat2>::value);
+static_assert(std::is_copy_constructible<glm::i64mat2>::value);
+static_assert(glm::i8mat2x2::length() == 2);
+static_assert(glm::i16mat2x2::length() == 2);
+static_assert(glm::i32mat2x2::length() == 2);
+static_assert(glm::i64mat2x2::length() == 2);
+static_assert(glm::i8mat2::length() == 2);
+static_assert(glm::i16mat2::length() == 2);
+static_assert(glm::i32mat2::length() == 2);
+static_assert(glm::i64mat2::length() == 2);

glm/ext/matrix_int2x3.hpp

@@ -31,3 +31,11 @@ namespace glm
 
 	/// @}
 }//namespace glm
+
+#if GLM_CONFIG_CTOR_INIT == GLM_DISABLE
+static_assert(std::is_trivially_default_constructible<glm::imat2x3>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::imat2x3>::value);
+static_assert(std::is_trivially_copyable<glm::imat2x3>::value);
+static_assert(std::is_copy_constructible<glm::imat2x3>::value);
+static_assert(glm::imat2x3::length() == 2);

glm/ext/matrix_int2x3_sized.hpp

@@ -47,3 +47,26 @@ namespace glm
 
 	/// @}
 }//namespace glm
+
+#if GLM_CONFIG_CTOR_INIT == GLM_DISABLE
+static_assert(std::is_trivially_default_constructible<glm::i8mat2x3>::value);
+static_assert(std::is_trivially_default_constructible<glm::i16mat2x3>::value);
+static_assert(std::is_trivially_default_constructible<glm::i32mat2x3>::value);
+static_assert(std::is_trivially_default_constructible<glm::i64mat2x3>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::i8mat2x3>::value);
+static_assert(std::is_trivially_copy_assignable<glm::i16mat2x3>::value);
+static_assert(std::is_trivially_copy_assignable<glm::i32mat2x3>::value);
+static_assert(std::is_trivially_copy_assignable<glm::i64mat2x3>::value);
+static_assert(std::is_trivially_copyable<glm::i8mat2x3>::value);
+static_assert(std::is_trivially_copyable<glm::i16mat2x3>::value);
+static_assert(std::is_trivially_copyable<glm::i32mat2x3>::value);
+static_assert(std::is_trivially_copyable<glm::i64mat2x3>::value);
+static_assert(std::is_copy_constructible<glm::i8mat2x3>::value);
+static_assert(std::is_copy_constructible<glm::i16mat2x3>::value);
+static_assert(std::is_copy_constructible<glm::i32mat2x3>::value);
+static_assert(std::is_copy_constructible<glm::i64mat2x3>::value);
+static_assert(glm::i8mat2x3::length() == 2);
+static_assert(glm::i16mat2x3::length() == 2);
+static_assert(glm::i32mat2x3::length() == 2);
+static_assert(glm::i64mat2x3::length() == 2);

glm/ext/matrix_int2x4.hpp

@@ -31,3 +31,12 @@ namespace glm
 
 	/// @}
 }//namespace glm
+
+#if GLM_CONFIG_CTOR_INIT == GLM_DISABLE
+static_assert(std::is_trivially_default_constructible<glm::imat2x4>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::imat2x4>::value);
+static_assert(std::is_trivially_copyable<glm::imat2x4>::value);
+static_assert(std::is_copy_constructible<glm::imat2x4>::value);
+static_assert(glm::imat2x4::length() == 2);
+

glm/ext/matrix_int2x4_sized.hpp

@@ -47,3 +47,26 @@ namespace glm
 
 	/// @}
 }//namespace glm
+
+#if GLM_CONFIG_CTOR_INIT == GLM_DISABLE
+static_assert(std::is_trivially_default_constructible<glm::i8mat2x4>::value);
+static_assert(std::is_trivially_default_constructible<glm::i16mat2x4>::value);
+static_assert(std::is_trivially_default_constructible<glm::i32mat2x4>::value);
+static_assert(std::is_trivially_default_constructible<glm::i64mat2x4>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::i8mat2x4>::value);
+static_assert(std::is_trivially_copy_assignable<glm::i16mat2x4>::value);
+static_assert(std::is_trivially_copy_assignable<glm::i32mat2x4>::value);
+static_assert(std::is_trivially_copy_assignable<glm::i64mat2x4>::value);
+static_assert(std::is_trivially_copyable<glm::i8mat2x4>::value);
+static_assert(std::is_trivially_copyable<glm::i16mat2x4>::value);
+static_assert(std::is_trivially_copyable<glm::i32mat2x4>::value);
+static_assert(std::is_trivially_copyable<glm::i64mat2x4>::value);
+static_assert(std::is_copy_constructible<glm::i8mat2x4>::value);
+static_assert(std::is_copy_constructible<glm::i16mat2x4>::value);
+static_assert(std::is_copy_constructible<glm::i32mat2x4>::value);
+static_assert(std::is_copy_constructible<glm::i64mat2x4>::value);
+static_assert(glm::i8mat2x4::length() == 2);
+static_assert(glm::i16mat2x4::length() == 2);
+static_assert(glm::i32mat2x4::length() == 2);
+static_assert(glm::i64mat2x4::length() == 2);

glm/ext/matrix_int3x2.hpp

@@ -31,3 +31,11 @@ namespace glm
 
 	/// @}
 }//namespace glm
+
+#if GLM_CONFIG_CTOR_INIT == GLM_DISABLE
+static_assert(std::is_trivially_default_constructible<glm::imat3x2>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::imat3x2>::value);
+static_assert(std::is_trivially_copyable<glm::imat3x2>::value);
+static_assert(std::is_copy_constructible<glm::imat3x2>::value);
+static_assert(glm::imat3x2::length() == 3);

glm/ext/matrix_int3x2_sized.hpp

@@ -47,3 +47,26 @@ namespace glm
 
 	/// @}
 }//namespace glm
+
+#if GLM_CONFIG_CTOR_INIT == GLM_DISABLE
+static_assert(std::is_trivially_default_constructible<glm::i8mat3x2>::value);
+static_assert(std::is_trivially_default_constructible<glm::i16mat3x2>::value);
+static_assert(std::is_trivially_default_constructible<glm::i32mat3x2>::value);
+static_assert(std::is_trivially_default_constructible<glm::i64mat3x2>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::i8mat3x2>::value);
+static_assert(std::is_trivially_copy_assignable<glm::i16mat3x2>::value);
+static_assert(std::is_trivially_copy_assignable<glm::i32mat3x2>::value);
+static_assert(std::is_trivially_copy_assignable<glm::i64mat3x2>::value);
+static_assert(std::is_trivially_copyable<glm::i8mat3x2>::value);
+static_assert(std::is_trivially_copyable<glm::i16mat3x2>::value);
+static_assert(std::is_trivially_copyable<glm::i32mat3x2>::value);
+static_assert(std::is_trivially_copyable<glm::i64mat3x2>::value);
+static_assert(std::is_copy_constructible<glm::i8mat3x2>::value);
+static_assert(std::is_copy_constructible<glm::i16mat3x2>::value);
+static_assert(std::is_copy_constructible<glm::i32mat3x2>::value);
+static_assert(std::is_copy_constructible<glm::i64mat3x2>::value);
+static_assert(glm::i8mat3x2::length() == 3);
+static_assert(glm::i16mat3x2::length() == 3);
+static_assert(glm::i32mat3x2::length() == 3);
+static_assert(glm::i64mat3x2::length() == 3);

glm/ext/matrix_int3x3.hpp

@@ -36,3 +36,17 @@ namespace glm
 
 	/// @}
 }//namespace glm
+
+#if GLM_CONFIG_CTOR_INIT == GLM_DISABLE
+static_assert(std::is_trivially_default_constructible<glm::imat3x3>::value);
+static_assert(std::is_trivially_default_constructible<glm::imat3>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::imat3x3>::value);
+static_assert(std::is_trivially_copy_assignable<glm::imat3>::value);
+static_assert(std::is_trivially_copyable<glm::imat3x3>::value);
+static_assert(std::is_trivially_copyable<glm::imat3>::value);
+static_assert(std::is_copy_constructible<glm::imat3x3>::value);
+static_assert(std::is_copy_constructible<glm::imat3>::value);
+static_assert(glm::imat3x3::length() == 3);
+static_assert(glm::imat3::length() == 3);
+

glm/ext/matrix_int3x3_sized.hpp

@@ -68,3 +68,46 @@ namespace glm
 
 	/// @}
 }//namespace glm
+
+#if GLM_CONFIG_CTOR_INIT == GLM_DISABLE
+static_assert(std::is_trivially_default_constructible<glm::i8mat3x3>::value);
+static_assert(std::is_trivially_default_constructible<glm::i16mat3x3>::value);
+static_assert(std::is_trivially_default_constructible<glm::i32mat3x3>::value);
+static_assert(std::is_trivially_default_constructible<glm::i64mat3x3>::value);
+static_assert(std::is_trivially_default_constructible<glm::i8mat3>::value);
+static_assert(std::is_trivially_default_constructible<glm::i16mat3>::value);
+static_assert(std::is_trivially_default_constructible<glm::i32mat3>::value);
+static_assert(std::is_trivially_default_constructible<glm::i64mat3>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::i8mat3x3>::value);
+static_assert(std::is_trivially_copy_assignable<glm::i16mat3x3>::value);
+static_assert(std::is_trivially_copy_assignable<glm::i32mat3x3>::value);
+static_assert(std::is_trivially_copy_assignable<glm::i64mat3x3>::value);
+static_assert(std::is_trivially_copy_assignable<glm::i8mat3>::value);
+static_assert(std::is_trivially_copy_assignable<glm::i16mat3>::value);
+static_assert(std::is_trivially_copy_assignable<glm::i32mat3>::value);
+static_assert(std::is_trivially_copy_assignable<glm::i64mat3>::value);
+static_assert(std::is_trivially_copyable<glm::i8mat3x3>::value);
+static_assert(std::is_trivially_copyable<glm::i16mat3x3>::value);
+static_assert(std::is_trivially_copyable<glm::i32mat3x3>::value);
+static_assert(std::is_trivially_copyable<glm::i64mat3x3>::value);
+static_assert(std::is_trivially_copyable<glm::i8mat3>::value);
+static_assert(std::is_trivially_copyable<glm::i16mat3>::value);
+static_assert(std::is_trivially_copyable<glm::i32mat3>::value);
+static_assert(std::is_trivially_copyable<glm::i64mat3>::value);
+static_assert(std::is_copy_constructible<glm::i8mat3x3>::value);
+static_assert(std::is_copy_constructible<glm::i16mat3x3>::value);
+static_assert(std::is_copy_constructible<glm::i32mat3x3>::value);
+static_assert(std::is_copy_constructible<glm::i64mat3x3>::value);
+static_assert(std::is_copy_constructible<glm::i8mat3>::value);
+static_assert(std::is_copy_constructible<glm::i16mat3>::value);
+static_assert(std::is_copy_constructible<glm::i32mat3>::value);
+static_assert(std::is_copy_constructible<glm::i64mat3>::value);
+static_assert(glm::i8mat3x3::length() == 3);
+static_assert(glm::i16mat3x3::length() == 3);
+static_assert(glm::i32mat3x3::length() == 3);
+static_assert(glm::i64mat3x3::length() == 3);
+static_assert(glm::i8mat3::length() == 3);
+static_assert(glm::i16mat3::length() == 3);
+static_assert(glm::i32mat3::length() == 3);
+static_assert(glm::i64mat3::length() == 3);

glm/ext/matrix_int3x4.hpp

@@ -31,3 +31,11 @@ namespace glm
 
 	/// @}
 }//namespace glm
+
+#if GLM_CONFIG_CTOR_INIT == GLM_DISABLE
+static_assert(std::is_trivially_default_constructible<glm::imat3x4>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::imat3x4>::value);
+static_assert(std::is_trivially_copyable<glm::imat3x4>::value);
+static_assert(std::is_copy_constructible<glm::imat3x4>::value);
+static_assert(glm::imat3x4::length() == 3);

glm/ext/matrix_int3x4_sized.hpp

@@ -47,3 +47,26 @@ namespace glm
 
 	/// @}
 }//namespace glm
+
+#if GLM_CONFIG_CTOR_INIT == GLM_DISABLE
+static_assert(std::is_trivially_default_constructible<glm::i8mat3x4>::value);
+static_assert(std::is_trivially_default_constructible<glm::i16mat3x4>::value);
+static_assert(std::is_trivially_default_constructible<glm::i32mat3x4>::value);
+static_assert(std::is_trivially_default_constructible<glm::i64mat3x4>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::i8mat3x4>::value);
+static_assert(std::is_trivially_copy_assignable<glm::i16mat3x4>::value);
+static_assert(std::is_trivially_copy_assignable<glm::i32mat3x4>::value);
+static_assert(std::is_trivially_copy_assignable<glm::i64mat3x4>::value);
+static_assert(std::is_trivially_copyable<glm::i8mat3x4>::value);
+static_assert(std::is_trivially_copyable<glm::i16mat3x4>::value);
+static_assert(std::is_trivially_copyable<glm::i32mat3x4>::value);
+static_assert(std::is_trivially_copyable<glm::i64mat3x4>::value);
+static_assert(std::is_copy_constructible<glm::i8mat3x4>::value);
+static_assert(std::is_copy_constructible<glm::i16mat3x4>::value);
+static_assert(std::is_copy_constructible<glm::i32mat3x4>::value);
+static_assert(std::is_copy_constructible<glm::i64mat3x4>::value);
+static_assert(glm::i8mat3x4::length() == 3);
+static_assert(glm::i16mat3x4::length() == 3);
+static_assert(glm::i32mat3x4::length() == 3);
+static_assert(glm::i64mat3x4::length() == 3);

glm/ext/matrix_int4x2.hpp

@@ -31,3 +31,11 @@ namespace glm
 
 	/// @}
 }//namespace glm
+
+#if GLM_CONFIG_CTOR_INIT == GLM_DISABLE
+static_assert(std::is_trivially_default_constructible<glm::imat4x2>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::imat4x2>::value);
+static_assert(std::is_trivially_copyable<glm::imat4x2>::value);
+static_assert(std::is_copy_constructible<glm::imat4x2>::value);
+static_assert(glm::imat4x2::length() == 4);

glm/ext/matrix_int4x2_sized.hpp

@@ -47,3 +47,26 @@ namespace glm
 
 	/// @}
 }//namespace glm
+
+#if GLM_CONFIG_CTOR_INIT == GLM_DISABLE
+static_assert(std::is_trivially_default_constructible<glm::i8mat4x2>::value);
+static_assert(std::is_trivially_default_constructible<glm::i16mat4x2>::value);
+static_assert(std::is_trivially_default_constructible<glm::i32mat4x2>::value);
+static_assert(std::is_trivially_default_constructible<glm::i64mat4x2>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::i8mat4x2>::value);
+static_assert(std::is_trivially_copy_assignable<glm::i16mat4x2>::value);
+static_assert(std::is_trivially_copy_assignable<glm::i32mat4x2>::value);
+static_assert(std::is_trivially_copy_assignable<glm::i64mat4x2>::value);
+static_assert(std::is_trivially_copyable<glm::i8mat4x2>::value);
+static_assert(std::is_trivially_copyable<glm::i16mat4x2>::value);
+static_assert(std::is_trivially_copyable<glm::i32mat4x2>::value);
+static_assert(std::is_trivially_copyable<glm::i64mat4x2>::value);
+static_assert(std::is_copy_constructible<glm::i8mat4x2>::value);
+static_assert(std::is_copy_constructible<glm::i16mat4x2>::value);
+static_assert(std::is_copy_constructible<glm::i32mat4x2>::value);
+static_assert(std::is_copy_constructible<glm::i64mat4x2>::value);
+static_assert(glm::i8mat4x2::length() == 4);
+static_assert(glm::i16mat4x2::length() == 4);
+static_assert(glm::i32mat4x2::length() == 4);
+static_assert(glm::i64mat4x2::length() == 4);

glm/ext/matrix_int4x3.hpp

@@ -31,3 +31,11 @@ namespace glm
 
 	/// @}
 }//namespace glm
+
+#if GLM_CONFIG_CTOR_INIT == GLM_DISABLE
+static_assert(std::is_trivially_default_constructible<glm::imat4x3>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::imat4x3>::value);
+static_assert(std::is_trivially_copyable<glm::imat4x3>::value);
+static_assert(std::is_copy_constructible<glm::imat4x3>::value);
+static_assert(glm::imat4x3::length() == 4);

glm/ext/matrix_int4x3_sized.hpp

@@ -47,3 +47,27 @@ namespace glm
 
 	/// @}
 }//namespace glm
+
+#if GLM_CONFIG_CTOR_INIT == GLM_DISABLE
+static_assert(std::is_trivially_default_constructible<glm::i8mat4x3>::value);
+static_assert(std::is_trivially_default_constructible<glm::i16mat4x3>::value);
+static_assert(std::is_trivially_default_constructible<glm::i32mat4x3>::value);
+static_assert(std::is_trivially_default_constructible<glm::i64mat4x3>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::i8mat4x3>::value);
+static_assert(std::is_trivially_copy_assignable<glm::i16mat4x3>::value);
+static_assert(std::is_trivially_copy_assignable<glm::i32mat4x3>::value);
+static_assert(std::is_trivially_copy_assignable<glm::i64mat4x3>::value);
+static_assert(std::is_trivially_copyable<glm::i8mat4x3>::value);
+static_assert(std::is_trivially_copyable<glm::i16mat4x3>::value);
+static_assert(std::is_trivially_copyable<glm::i32mat4x3>::value);
+static_assert(std::is_trivially_copyable<glm::i64mat4x3>::value);
+static_assert(std::is_copy_constructible<glm::i8mat4x3>::value);
+static_assert(std::is_copy_constructible<glm::i16mat4x3>::value);
+static_assert(std::is_copy_constructible<glm::i32mat4x3>::value);
+static_assert(std::is_copy_constructible<glm::i64mat4x3>::value);
+static_assert(glm::i8mat4x3::length() == 4);
+static_assert(glm::i16mat4x3::length() == 4);
+static_assert(glm::i32mat4x3::length() == 4);
+static_assert(glm::i64mat4x3::length() == 4);
+

glm/ext/matrix_int4x4.hpp

@@ -36,3 +36,16 @@ namespace glm
 
 	/// @}
 }//namespace glm
+
+#if GLM_CONFIG_CTOR_INIT == GLM_DISABLE
+static_assert(std::is_trivially_default_constructible<glm::imat4x4>::value);
+static_assert(std::is_trivially_default_constructible<glm::imat4>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::imat4x4>::value);
+static_assert(std::is_trivially_copy_assignable<glm::imat4>::value);
+static_assert(std::is_trivially_copyable<glm::imat4x4>::value);
+static_assert(std::is_trivially_copyable<glm::imat4>::value);
+static_assert(std::is_copy_constructible<glm::imat4x4>::value);
+static_assert(std::is_copy_constructible<glm::imat4>::value);
+static_assert(glm::imat4x4::length() == 4);
+static_assert(glm::imat4::length() == 4);

glm/ext/matrix_int4x4_sized.hpp

@@ -68,3 +68,48 @@ namespace glm
 
 	/// @}
 }//namespace glm
+
+#if GLM_CONFIG_CTOR_INIT == GLM_DISABLE
+static_assert(std::is_trivially_default_constructible<glm::i8mat4x4>::value);
+static_assert(std::is_trivially_default_constructible<glm::i16mat4x4>::value);
+static_assert(std::is_trivially_default_constructible<glm::i32mat4x4>::value);
+static_assert(std::is_trivially_default_constructible<glm::i64mat4x4>::value);
+static_assert(std::is_trivially_default_constructible<glm::i8mat4>::value);
+static_assert(std::is_trivially_default_constructible<glm::i16mat4>::value);
+static_assert(std::is_trivially_default_constructible<glm::i32mat4>::value);
+static_assert(std::is_trivially_default_constructible<glm::i64mat4>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::i8mat4x4>::value);
+static_assert(std::is_trivially_copy_assignable<glm::i16mat4x4>::value);
+static_assert(std::is_trivially_copy_assignable<glm::i32mat4x4>::value);
+static_assert(std::is_trivially_copy_assignable<glm::i64mat4x4>::value);
+static_assert(std::is_trivially_copy_assignable<glm::i8mat4>::value);
+static_assert(std::is_trivially_copy_assignable<glm::i16mat4>::value);
+static_assert(std::is_trivially_copy_assignable<glm::i32mat4>::value);
+static_assert(std::is_trivially_copy_assignable<glm::i64mat4>::value);
+static_assert(std::is_trivially_copyable<glm::i8mat4x4>::value);
+static_assert(std::is_trivially_copyable<glm::i16mat4x4>::value);
+static_assert(std::is_trivially_copyable<glm::i32mat4x4>::value);
+static_assert(std::is_trivially_copyable<glm::i64mat4x4>::value);
+static_assert(std::is_trivially_copyable<glm::i8mat4>::value);
+static_assert(std::is_trivially_copyable<glm::i16mat4>::value);
+static_assert(std::is_trivially_copyable<glm::i32mat4>::value);
+static_assert(std::is_trivially_copyable<glm::i64mat4>::value);
+static_assert(std::is_copy_constructible<glm::i8mat4x4>::value);
+static_assert(std::is_copy_constructible<glm::i16mat4x4>::value);
+static_assert(std::is_copy_constructible<glm::i32mat4x4>::value);
+static_assert(std::is_copy_constructible<glm::i64mat4x4>::value);
+static_assert(std::is_copy_constructible<glm::i8mat4>::value);
+static_assert(std::is_copy_constructible<glm::i16mat4>::value);
+static_assert(std::is_copy_constructible<glm::i32mat4>::value);
+static_assert(std::is_copy_constructible<glm::i64mat4>::value);
+static_assert(glm::i8mat4x4::length() == 4);
+static_assert(glm::i16mat4x4::length() == 4);
+static_assert(glm::i32mat4x4::length() == 4);
+static_assert(glm::i64mat4x4::length() == 4);
+static_assert(glm::i8mat4::length() == 4);
+static_assert(glm::i16mat4::length() == 4);
+static_assert(glm::i32mat4::length() == 4);
+static_assert(glm::i64mat4::length() == 4);
+
+

glm/ext/matrix_uint2x2.hpp

@@ -36,3 +36,16 @@ namespace glm
 
 	/// @}
 }//namespace glm
+
+#if GLM_CONFIG_CTOR_INIT == GLM_DISABLE
+static_assert(std::is_trivially_default_constructible<glm::umat2x2>::value);
+static_assert(std::is_trivially_default_constructible<glm::umat2>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::umat2x2>::value);
+static_assert(std::is_trivially_copy_assignable<glm::umat2>::value);
+static_assert(std::is_trivially_copyable<glm::umat2x2>::value);
+static_assert(std::is_trivially_copyable<glm::umat2>::value);
+static_assert(std::is_copy_constructible<glm::umat2x2>::value);
+static_assert(std::is_copy_constructible<glm::umat2>::value);
+static_assert(glm::umat2x2::length() == 2);
+static_assert(glm::umat2::length() == 2);

glm/ext/matrix_uint2x2_sized.hpp

@@ -68,3 +68,46 @@ namespace glm
 
 	/// @}
 }//namespace glm
+
+#if GLM_CONFIG_CTOR_INIT == GLM_DISABLE
+static_assert(std::is_trivially_default_constructible<glm::u8mat2x2>::value);
+static_assert(std::is_trivially_default_constructible<glm::u16mat2x2>::value);
+static_assert(std::is_trivially_default_constructible<glm::u32mat2x2>::value);
+static_assert(std::is_trivially_default_constructible<glm::u64mat2x2>::value);
+static_assert(std::is_trivially_default_constructible<glm::u8mat2>::value);
+static_assert(std::is_trivially_default_constructible<glm::u16mat2>::value);
+static_assert(std::is_trivially_default_constructible<glm::u32mat2>::value);
+static_assert(std::is_trivially_default_constructible<glm::u64mat2>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::u8mat2x2>::value);
+static_assert(std::is_trivially_copy_assignable<glm::u16mat2x2>::value);
+static_assert(std::is_trivially_copy_assignable<glm::u32mat2x2>::value);
+static_assert(std::is_trivially_copy_assignable<glm::u64mat2x2>::value);
+static_assert(std::is_trivially_copy_assignable<glm::u8mat2>::value);
+static_assert(std::is_trivially_copy_assignable<glm::u16mat2>::value);
+static_assert(std::is_trivially_copy_assignable<glm::u32mat2>::value);
+static_assert(std::is_trivially_copy_assignable<glm::u64mat2>::value);
+static_assert(std::is_trivially_copyable<glm::u8mat2x2>::value);
+static_assert(std::is_trivially_copyable<glm::u16mat2x2>::value);
+static_assert(std::is_trivially_copyable<glm::u32mat2x2>::value);
+static_assert(std::is_trivially_copyable<glm::u64mat2x2>::value);
+static_assert(std::is_trivially_copyable<glm::u8mat2>::value);
+static_assert(std::is_trivially_copyable<glm::u16mat2>::value);
+static_assert(std::is_trivially_copyable<glm::u32mat2>::value);
+static_assert(std::is_trivially_copyable<glm::u64mat2>::value);
+static_assert(std::is_copy_constructible<glm::u8mat2x2>::value);
+static_assert(std::is_copy_constructible<glm::u16mat2x2>::value);
+static_assert(std::is_copy_constructible<glm::u32mat2x2>::value);
+static_assert(std::is_copy_constructible<glm::u64mat2x2>::value);
+static_assert(std::is_copy_constructible<glm::u8mat2>::value);
+static_assert(std::is_copy_constructible<glm::u16mat2>::value);
+static_assert(std::is_copy_constructible<glm::u32mat2>::value);
+static_assert(std::is_copy_constructible<glm::u64mat2>::value);
+static_assert(glm::u8mat2x2::length() == 2);
+static_assert(glm::u16mat2x2::length() == 2);
+static_assert(glm::u32mat2x2::length() == 2);
+static_assert(glm::u64mat2x2::length() == 2);
+static_assert(glm::u8mat2::length() == 2);
+static_assert(glm::u16mat2::length() == 2);
+static_assert(glm::u32mat2::length() == 2);
+static_assert(glm::u64mat2::length() == 2);

glm/ext/matrix_uint2x3.hpp

@@ -31,3 +31,12 @@ namespace glm
 
 	/// @}
 }//namespace glm
+
+#if GLM_CONFIG_CTOR_INIT == GLM_DISABLE
+static_assert(std::is_trivially_default_constructible<glm::umat2x3>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::umat2x3>::value);
+static_assert(std::is_trivially_copyable<glm::umat2x3>::value);
+static_assert(std::is_copy_constructible<glm::umat2x3>::value);
+static_assert(glm::umat2x3::length() == 2);
+

glm/ext/matrix_uint2x3_sized.hpp

@@ -47,3 +47,27 @@ namespace glm
 
 	/// @}
 }//namespace glm
+
+#if GLM_CONFIG_CTOR_INIT == GLM_DISABLE
+static_assert(std::is_trivially_default_constructible<glm::u8mat2x3>::value);
+static_assert(std::is_trivially_default_constructible<glm::u16mat2x3>::value);
+static_assert(std::is_trivially_default_constructible<glm::u32mat2x3>::value);
+static_assert(std::is_trivially_default_constructible<glm::u64mat2x3>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::u8mat2x3>::value);
+static_assert(std::is_trivially_copy_assignable<glm::u16mat2x3>::value);
+static_assert(std::is_trivially_copy_assignable<glm::u32mat2x3>::value);
+static_assert(std::is_trivially_copy_assignable<glm::u64mat2x3>::value);
+static_assert(std::is_trivially_copyable<glm::u8mat2x3>::value);
+static_assert(std::is_trivially_copyable<glm::u16mat2x3>::value);
+static_assert(std::is_trivially_copyable<glm::u32mat2x3>::value);
+static_assert(std::is_trivially_copyable<glm::u64mat2x3>::value);
+static_assert(std::is_copy_constructible<glm::u8mat2x3>::value);
+static_assert(std::is_copy_constructible<glm::u16mat2x3>::value);
+static_assert(std::is_copy_constructible<glm::u32mat2x3>::value);
+static_assert(std::is_copy_constructible<glm::u64mat2x3>::value);
+static_assert(glm::u8mat2x3::length() == 2);
+static_assert(glm::u16mat2x3::length() == 2);
+static_assert(glm::u32mat2x3::length() == 2);
+static_assert(glm::u64mat2x3::length() == 2);
+

glm/ext/matrix_uint2x4.hpp

@@ -31,3 +31,11 @@ namespace glm
 
 	/// @}
 }//namespace glm
+
+#if GLM_CONFIG_CTOR_INIT == GLM_DISABLE
+static_assert(std::is_trivially_default_constructible<glm::umat2x4>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::umat2x4>::value);
+static_assert(std::is_trivially_copyable<glm::umat2x4>::value);
+static_assert(std::is_copy_constructible<glm::umat2x4>::value);
+static_assert(glm::umat2x4::length() == 2);

glm/ext/matrix_uint2x4_sized.hpp

@@ -47,3 +47,26 @@ namespace glm
 
 	/// @}
 }//namespace glm
+
+#if GLM_CONFIG_CTOR_INIT == GLM_DISABLE
+static_assert(std::is_trivially_default_constructible<glm::u8mat2x4>::value);
+static_assert(std::is_trivially_default_constructible<glm::u16mat2x4>::value);
+static_assert(std::is_trivially_default_constructible<glm::u32mat2x4>::value);
+static_assert(std::is_trivially_default_constructible<glm::u64mat2x4>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::u8mat2x4>::value);
+static_assert(std::is_trivially_copy_assignable<glm::u16mat2x4>::value);
+static_assert(std::is_trivially_copy_assignable<glm::u32mat2x4>::value);
+static_assert(std::is_trivially_copy_assignable<glm::u64mat2x4>::value);
+static_assert(std::is_trivially_copyable<glm::u8mat2x4>::value);
+static_assert(std::is_trivially_copyable<glm::u16mat2x4>::value);
+static_assert(std::is_trivially_copyable<glm::u32mat2x4>::value);
+static_assert(std::is_trivially_copyable<glm::u64mat2x4>::value);
+static_assert(std::is_copy_constructible<glm::u8mat2x4>::value);
+static_assert(std::is_copy_constructible<glm::u16mat2x4>::value);
+static_assert(std::is_copy_constructible<glm::u32mat2x4>::value);
+static_assert(std::is_copy_constructible<glm::u64mat2x4>::value);
+static_assert(glm::u8mat2x4::length() == 2);
+static_assert(glm::u16mat2x4::length() == 2);
+static_assert(glm::u32mat2x4::length() == 2);
+static_assert(glm::u64mat2x4::length() == 2);

glm/ext/matrix_uint3x2.hpp

@@ -31,3 +31,12 @@ namespace glm
 
 	/// @}
 }//namespace glm
+
+#if GLM_CONFIG_CTOR_INIT == GLM_DISABLE
+static_assert(std::is_trivially_default_constructible<glm::umat3x2>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::umat3x2>::value);
+static_assert(std::is_trivially_copyable<glm::umat3x2>::value);
+static_assert(std::is_copy_constructible<glm::umat3x2>::value);
+static_assert(glm::umat3x2::length() == 3);
+

glm/ext/matrix_uint3x2_sized.hpp

@@ -47,3 +47,26 @@ namespace glm
 
 	/// @}
 }//namespace glm
+
+#if GLM_CONFIG_CTOR_INIT == GLM_DISABLE
+static_assert(std::is_trivially_default_constructible<glm::u8mat3x2>::value);
+static_assert(std::is_trivially_default_constructible<glm::u16mat3x2>::value);
+static_assert(std::is_trivially_default_constructible<glm::u32mat3x2>::value);
+static_assert(std::is_trivially_default_constructible<glm::u64mat3x2>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::u8mat3x2>::value);
+static_assert(std::is_trivially_copy_assignable<glm::u16mat3x2>::value);
+static_assert(std::is_trivially_copy_assignable<glm::u32mat3x2>::value);
+static_assert(std::is_trivially_copy_assignable<glm::u64mat3x2>::value);
+static_assert(std::is_trivially_copyable<glm::u8mat3x2>::value);
+static_assert(std::is_trivially_copyable<glm::u16mat3x2>::value);
+static_assert(std::is_trivially_copyable<glm::u32mat3x2>::value);
+static_assert(std::is_trivially_copyable<glm::u64mat3x2>::value);
+static_assert(std::is_copy_constructible<glm::u8mat3x2>::value);
+static_assert(std::is_copy_constructible<glm::u16mat3x2>::value);
+static_assert(std::is_copy_constructible<glm::u32mat3x2>::value);
+static_assert(std::is_copy_constructible<glm::u64mat3x2>::value);
+static_assert(glm::u8mat3x2::length() == 3);
+static_assert(glm::u16mat3x2::length() == 3);
+static_assert(glm::u32mat3x2::length() == 3);
+static_assert(glm::u64mat3x2::length() == 3);

glm/ext/matrix_uint3x3.hpp

@@ -36,3 +36,16 @@ namespace glm
 
 	/// @}
 }//namespace glm
+
+#if GLM_CONFIG_CTOR_INIT == GLM_DISABLE
+static_assert(std::is_trivially_default_constructible<glm::umat3x3>::value);
+static_assert(std::is_trivially_default_constructible<glm::umat3>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::umat3x3>::value);
+static_assert(std::is_trivially_copy_assignable<glm::umat3>::value);
+static_assert(std::is_trivially_copyable<glm::umat3x3>::value);
+static_assert(std::is_trivially_copyable<glm::umat3>::value);
+static_assert(std::is_copy_constructible<glm::umat3x3>::value);
+static_assert(std::is_copy_constructible<glm::umat3>::value);
+static_assert(glm::umat3x3::length() == 3);
+static_assert(glm::umat3::length() == 3);

glm/ext/matrix_uint3x3_sized.hpp

@@ -68,3 +68,46 @@ namespace glm
 
 	/// @}
 }//namespace glm
+
+#if GLM_CONFIG_CTOR_INIT == GLM_DISABLE
+static_assert(std::is_trivially_default_constructible<glm::u8mat3x3>::value);
+static_assert(std::is_trivially_default_constructible<glm::u16mat3x3>::value);
+static_assert(std::is_trivially_default_constructible<glm::u32mat3x3>::value);
+static_assert(std::is_trivially_default_constructible<glm::u64mat3x3>::value);
+static_assert(std::is_trivially_default_constructible<glm::u8mat3>::value);
+static_assert(std::is_trivially_default_constructible<glm::u16mat3>::value);
+static_assert(std::is_trivially_default_constructible<glm::u32mat3>::value);
+static_assert(std::is_trivially_default_constructible<glm::u64mat3>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::u8mat3x3>::value);
+static_assert(std::is_trivially_copy_assignable<glm::u16mat3x3>::value);
+static_assert(std::is_trivially_copy_assignable<glm::u32mat3x3>::value);
+static_assert(std::is_trivially_copy_assignable<glm::u64mat3x3>::value);
+static_assert(std::is_trivially_copy_assignable<glm::u8mat3>::value);
+static_assert(std::is_trivially_copy_assignable<glm::u16mat3>::value);
+static_assert(std::is_trivially_copy_assignable<glm::u32mat3>::value);
+static_assert(std::is_trivially_copy_assignable<glm::u64mat3>::value);
+static_assert(std::is_trivially_copyable<glm::u8mat3x3>::value);
+static_assert(std::is_trivially_copyable<glm::u16mat3x3>::value);
+static_assert(std::is_trivially_copyable<glm::u32mat3x3>::value);
+static_assert(std::is_trivially_copyable<glm::u64mat3x3>::value);
+static_assert(std::is_trivially_copyable<glm::u8mat3>::value);
+static_assert(std::is_trivially_copyable<glm::u16mat3>::value);
+static_assert(std::is_trivially_copyable<glm::u32mat3>::value);
+static_assert(std::is_trivially_copyable<glm::u64mat3>::value);
+static_assert(std::is_copy_constructible<glm::u8mat3x3>::value);
+static_assert(std::is_copy_constructible<glm::u16mat3x3>::value);
+static_assert(std::is_copy_constructible<glm::u32mat3x3>::value);
+static_assert(std::is_copy_constructible<glm::u64mat3x3>::value);
+static_assert(std::is_copy_constructible<glm::u8mat3>::value);
+static_assert(std::is_copy_constructible<glm::u16mat3>::value);
+static_assert(std::is_copy_constructible<glm::u32mat3>::value);
+static_assert(std::is_copy_constructible<glm::u64mat3>::value);
+static_assert(glm::u8mat3x3::length() == 3);
+static_assert(glm::u16mat3x3::length() == 3);
+static_assert(glm::u32mat3x3::length() == 3);
+static_assert(glm::u64mat3x3::length() == 3);
+static_assert(glm::u8mat3::length() == 3);
+static_assert(glm::u16mat3::length() == 3);
+static_assert(glm::u32mat3::length() == 3);
+static_assert(glm::u64mat3::length() == 3);

glm/ext/matrix_uint3x4.hpp

@@ -31,3 +31,11 @@ namespace glm
 
 	/// @}
 }//namespace glm
+
+#if GLM_CONFIG_CTOR_INIT == GLM_DISABLE
+static_assert(std::is_trivially_default_constructible<glm::umat3x4>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::umat3x4>::value);
+static_assert(std::is_trivially_copyable<glm::umat3x4>::value);
+static_assert(std::is_copy_constructible<glm::umat3x4>::value);
+static_assert(glm::umat3x4::length() == 3);

glm/ext/matrix_uint3x4_sized.hpp

@@ -47,3 +47,26 @@ namespace glm
 
 	/// @}
 }//namespace glm
+
+#if GLM_CONFIG_CTOR_INIT == GLM_DISABLE
+static_assert(std::is_trivially_default_constructible<glm::u8mat3x4>::value);
+static_assert(std::is_trivially_default_constructible<glm::u16mat3x4>::value);
+static_assert(std::is_trivially_default_constructible<glm::u32mat3x4>::value);
+static_assert(std::is_trivially_default_constructible<glm::u64mat3x4>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::u8mat3x4>::value);
+static_assert(std::is_trivially_copy_assignable<glm::u16mat3x4>::value);
+static_assert(std::is_trivially_copy_assignable<glm::u32mat3x4>::value);
+static_assert(std::is_trivially_copy_assignable<glm::u64mat3x4>::value);
+static_assert(std::is_trivially_copyable<glm::u8mat3x4>::value);
+static_assert(std::is_trivially_copyable<glm::u16mat3x4>::value);
+static_assert(std::is_trivially_copyable<glm::u32mat3x4>::value);
+static_assert(std::is_trivially_copyable<glm::u64mat3x4>::value);
+static_assert(std::is_copy_constructible<glm::u8mat3x4>::value);
+static_assert(std::is_copy_constructible<glm::u16mat3x4>::value);
+static_assert(std::is_copy_constructible<glm::u32mat3x4>::value);
+static_assert(std::is_copy_constructible<glm::u64mat3x4>::value);
+static_assert(glm::u8mat3x4::length() == 3);
+static_assert(glm::u16mat3x4::length() == 3);
+static_assert(glm::u32mat3x4::length() == 3);
+static_assert(glm::u64mat3x4::length() == 3);

glm/ext/matrix_uint4x2.hpp

@@ -31,3 +31,12 @@ namespace glm
 
 	/// @}
 }//namespace glm
+
+#if GLM_CONFIG_CTOR_INIT == GLM_DISABLE
+static_assert(std::is_trivially_default_constructible<glm::umat4x2>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::umat4x2>::value);
+static_assert(std::is_trivially_copyable<glm::umat4x2>::value);
+static_assert(std::is_copy_constructible<glm::umat4x2>::value);
+static_assert(glm::umat4x2::length() == 4);
+

glm/ext/matrix_uint4x2_sized.hpp

@@ -47,3 +47,26 @@ namespace glm
 
 	/// @}
 }//namespace glm
+
+#if GLM_CONFIG_CTOR_INIT == GLM_DISABLE
+static_assert(std::is_trivially_default_constructible<glm::u8mat4x2>::value);
+static_assert(std::is_trivially_default_constructible<glm::u16mat4x2>::value);
+static_assert(std::is_trivially_default_constructible<glm::u32mat4x2>::value);
+static_assert(std::is_trivially_default_constructible<glm::u64mat4x2>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::u8mat4x2>::value);
+static_assert(std::is_trivially_copy_assignable<glm::u16mat4x2>::value);
+static_assert(std::is_trivially_copy_assignable<glm::u32mat4x2>::value);
+static_assert(std::is_trivially_copy_assignable<glm::u64mat4x2>::value);
+static_assert(std::is_trivially_copyable<glm::u8mat4x2>::value);
+static_assert(std::is_trivially_copyable<glm::u16mat4x2>::value);
+static_assert(std::is_trivially_copyable<glm::u32mat4x2>::value);
+static_assert(std::is_trivially_copyable<glm::u64mat4x2>::value);
+static_assert(std::is_copy_constructible<glm::u8mat4x2>::value);
+static_assert(std::is_copy_constructible<glm::u16mat4x2>::value);
+static_assert(std::is_copy_constructible<glm::u32mat4x2>::value);
+static_assert(std::is_copy_constructible<glm::u64mat4x2>::value);
+static_assert(glm::u8mat4x2::length() == 4);
+static_assert(glm::u16mat4x2::length() == 4);
+static_assert(glm::u32mat4x2::length() == 4);
+static_assert(glm::u64mat4x2::length() == 4);

glm/ext/matrix_uint4x3.hpp

@@ -31,3 +31,12 @@ namespace glm
 
 	/// @}
 }//namespace glm
+
+#if GLM_CONFIG_CTOR_INIT == GLM_DISABLE
+static_assert(std::is_trivially_default_constructible<glm::umat4x3>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::umat4x3>::value);
+static_assert(std::is_trivially_copyable<glm::umat4x3>::value);
+static_assert(std::is_copy_constructible<glm::umat4x3>::value);
+static_assert(glm::umat4x3::length() == 4);
+

glm/ext/matrix_uint4x3_sized.hpp

@@ -47,3 +47,27 @@ namespace glm
 
 	/// @}
 }//namespace glm
+
+#if GLM_CONFIG_CTOR_INIT == GLM_DISABLE
+static_assert(std::is_trivially_default_constructible<glm::u8mat4x3>::value);
+static_assert(std::is_trivially_default_constructible<glm::u16mat4x3>::value);
+static_assert(std::is_trivially_default_constructible<glm::u32mat4x3>::value);
+static_assert(std::is_trivially_default_constructible<glm::u64mat4x3>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::u8mat4x3>::value);
+static_assert(std::is_trivially_copy_assignable<glm::u16mat4x3>::value);
+static_assert(std::is_trivially_copy_assignable<glm::u32mat4x3>::value);
+static_assert(std::is_trivially_copy_assignable<glm::u64mat4x3>::value);
+static_assert(std::is_trivially_copyable<glm::u8mat4x3>::value);
+static_assert(std::is_trivially_copyable<glm::u16mat4x3>::value);
+static_assert(std::is_trivially_copyable<glm::u32mat4x3>::value);
+static_assert(std::is_trivially_copyable<glm::u64mat4x3>::value);
+static_assert(std::is_copy_constructible<glm::u8mat4x3>::value);
+static_assert(std::is_copy_constructible<glm::u16mat4x3>::value);
+static_assert(std::is_copy_constructible<glm::u32mat4x3>::value);
+static_assert(std::is_copy_constructible<glm::u64mat4x3>::value);
+static_assert(glm::u8mat4x3::length() == 4);
+static_assert(glm::u16mat4x3::length() == 4);
+static_assert(glm::u32mat4x3::length() == 4);
+static_assert(glm::u64mat4x3::length() == 4);
+