Add static_assert to basic types

glm/detail/setup.hpp

@@ -93,20 +93,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 +116,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
@@ -144,8 +124,6 @@
 ///////////////////////////////////////////////////////////////////////////////////
 // Has of C++ features
 
-#define GLM_HAS_INITIALIZER_LISTS 1
-
 #define GLM_CONSTEXPR constexpr
 
 // [nodiscard]
@@ -628,7 +606,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/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);
+

glm/ext/matrix_uint4x4.hpp

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

glm/ext/matrix_uint4x4_sized.hpp

@@ -68,3 +68,47 @@ namespace glm
 
 	/// @}
 }//namespace glm
+
+#if GLM_CONFIG_CTOR_INIT == GLM_DISABLE
+static_assert(std::is_trivially_default_constructible<glm::u8mat4x4>::value);
+static_assert(std::is_trivially_default_constructible<glm::u16mat4x4>::value);
+static_assert(std::is_trivially_default_constructible<glm::u32mat4x4>::value);
+static_assert(std::is_trivially_default_constructible<glm::u64mat4x4>::value);
+static_assert(std::is_trivially_default_constructible<glm::u8mat4>::value);
+static_assert(std::is_trivially_default_constructible<glm::u16mat4>::value);
+static_assert(std::is_trivially_default_constructible<glm::u32mat4>::value);
+static_assert(std::is_trivially_default_constructible<glm::u64mat4>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::u8mat4x4>::value);
+static_assert(std::is_trivially_copy_assignable<glm::u16mat4x4>::value);
+static_assert(std::is_trivially_copy_assignable<glm::u32mat4x4>::value);
+static_assert(std::is_trivially_copy_assignable<glm::u64mat4x4>::value);
+static_assert(std::is_trivially_copy_assignable<glm::u8mat4>::value);
+static_assert(std::is_trivially_copy_assignable<glm::u16mat4>::value);
+static_assert(std::is_trivially_copy_assignable<glm::u32mat4>::value);
+static_assert(std::is_trivially_copy_assignable<glm::u64mat4>::value);
+static_assert(std::is_trivially_copyable<glm::u8mat4x4>::value);
+static_assert(std::is_trivially_copyable<glm::u16mat4x4>::value);
+static_assert(std::is_trivially_copyable<glm::u32mat4x4>::value);
+static_assert(std::is_trivially_copyable<glm::u64mat4x4>::value);
+static_assert(std::is_trivially_copyable<glm::u8mat4>::value);
+static_assert(std::is_trivially_copyable<glm::u16mat4>::value);
+static_assert(std::is_trivially_copyable<glm::u32mat4>::value);
+static_assert(std::is_trivially_copyable<glm::u64mat4>::value);
+static_assert(std::is_copy_constructible<glm::u8mat4x4>::value);
+static_assert(std::is_copy_constructible<glm::u16mat4x4>::value);
+static_assert(std::is_copy_constructible<glm::u32mat4x4>::value);
+static_assert(std::is_copy_constructible<glm::u64mat4x4>::value);
+static_assert(std::is_copy_constructible<glm::u8mat4>::value);
+static_assert(std::is_copy_constructible<glm::u16mat4>::value);
+static_assert(std::is_copy_constructible<glm::u32mat4>::value);
+static_assert(std::is_copy_constructible<glm::u64mat4>::value);
+static_assert(glm::u8mat4x4::length() == 4);
+static_assert(glm::u16mat4x4::length() == 4);
+static_assert(glm::u32mat4x4::length() == 4);
+static_assert(glm::u64mat4x4::length() == 4);
+static_assert(glm::u8mat4::length() == 4);
+static_assert(glm::u16mat4::length() == 4);
+static_assert(glm::u32mat4::length() == 4);
+static_assert(glm::u64mat4::length() == 4);
+

glm/ext/quaternion_double.hpp

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

glm/ext/quaternion_double_precision.hpp

@@ -40,3 +40,20 @@ namespace glm
 	/// @}
 } //namespace glm
 
+#if GLM_CONFIG_CTOR_INIT == GLM_DISABLE
+static_assert(std::is_trivially_default_constructible<glm::lowp_dquat>::value);
+static_assert(std::is_trivially_default_constructible<glm::mediump_dquat>::value);
+static_assert(std::is_trivially_default_constructible<glm::highp_dquat>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::lowp_dquat>::value);
+static_assert(std::is_trivially_copy_assignable<glm::mediump_dquat>::value);
+static_assert(std::is_trivially_copy_assignable<glm::highp_dquat>::value);
+static_assert(std::is_trivially_copyable<glm::lowp_dquat>::value);
+static_assert(std::is_trivially_copyable<glm::mediump_dquat>::value);
+static_assert(std::is_trivially_copyable<glm::highp_dquat>::value);
+static_assert(std::is_copy_constructible<glm::lowp_dquat>::value);
+static_assert(std::is_copy_constructible<glm::mediump_dquat>::value);
+static_assert(std::is_copy_constructible<glm::highp_dquat>::value);
+static_assert(glm::lowp_dquat::length() == 4);
+static_assert(glm::mediump_dquat::length() == 4);
+static_assert(glm::highp_dquat::length() == 4);

glm/ext/quaternion_float.hpp

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

glm/ext/quaternion_float_precision.hpp

@@ -34,3 +34,20 @@ namespace glm
 	/// @}
 } //namespace glm
 
+#if GLM_CONFIG_CTOR_INIT == GLM_DISABLE
+static_assert(std::is_trivially_default_constructible<glm::lowp_quat>::value);
+static_assert(std::is_trivially_default_constructible<glm::mediump_quat>::value);
+static_assert(std::is_trivially_default_constructible<glm::highp_quat>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::lowp_quat>::value);
+static_assert(std::is_trivially_copy_assignable<glm::mediump_quat>::value);
+static_assert(std::is_trivially_copy_assignable<glm::highp_quat>::value);
+static_assert(std::is_trivially_copyable<glm::lowp_quat>::value);
+static_assert(std::is_trivially_copyable<glm::mediump_quat>::value);
+static_assert(std::is_trivially_copyable<glm::highp_quat>::value);
+static_assert(std::is_copy_constructible<glm::lowp_quat>::value);
+static_assert(std::is_copy_constructible<glm::mediump_quat>::value);
+static_assert(std::is_copy_constructible<glm::highp_quat>::value);
+static_assert(glm::lowp_quat::length() == 4);
+static_assert(glm::mediump_quat::length() == 4);
+static_assert(glm::highp_quat::length() == 4);

glm/ext/vector_double1.hpp

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

glm/ext/vector_double1_precision.hpp

@@ -34,3 +34,23 @@ namespace glm
 
 	/// @}
 }//namespace glm
+
+#if GLM_CONFIG_CTOR_INIT == GLM_DISABLE
+static_assert(std::is_trivially_default_constructible<glm::highp_dvec1>::value);
+static_assert(std::is_trivially_default_constructible<glm::mediump_dvec1>::value);
+static_assert(std::is_trivially_default_constructible<glm::lowp_dvec1>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::highp_dvec1>::value);
+static_assert(std::is_trivially_copy_assignable<glm::mediump_dvec1>::value);
+static_assert(std::is_trivially_copy_assignable<glm::lowp_dvec1>::value);
+static_assert(std::is_trivially_copyable<glm::highp_dvec1>::value);
+static_assert(std::is_trivially_copyable<glm::mediump_dvec1>::value);
+static_assert(std::is_trivially_copyable<glm::lowp_dvec1>::value);
+static_assert(std::is_copy_constructible<glm::highp_dvec1>::value);
+static_assert(std::is_copy_constructible<glm::mediump_dvec1>::value);
+static_assert(std::is_copy_constructible<glm::lowp_dvec1>::value);
+static_assert(glm::highp_dvec1::length() == 1);
+static_assert(glm::mediump_dvec1::length() == 1);
+static_assert(glm::lowp_dvec1::length() == 1);
+static_assert(sizeof(glm::highp_dvec1) == sizeof(glm::mediump_dvec1));
+static_assert(sizeof(glm::highp_dvec1) == sizeof(glm::lowp_dvec1));

glm/ext/vector_double2.hpp

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

glm/ext/vector_double2_precision.hpp

@@ -29,3 +29,24 @@ namespace glm
 
 	/// @}
 }//namespace glm
+
+#if GLM_CONFIG_CTOR_INIT == GLM_DISABLE
+static_assert(std::is_trivially_default_constructible<glm::highp_dvec2>::value);
+static_assert(std::is_trivially_default_constructible<glm::mediump_dvec2>::value);
+static_assert(std::is_trivially_default_constructible<glm::lowp_dvec2>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::highp_dvec2>::value);
+static_assert(std::is_trivially_copy_assignable<glm::mediump_dvec2>::value);
+static_assert(std::is_trivially_copy_assignable<glm::lowp_dvec2>::value);
+static_assert(std::is_trivially_copyable<glm::highp_dvec2>::value);
+static_assert(std::is_trivially_copyable<glm::mediump_dvec2>::value);
+static_assert(std::is_trivially_copyable<glm::lowp_dvec2>::value);
+static_assert(std::is_copy_constructible<glm::highp_dvec2>::value);
+static_assert(std::is_copy_constructible<glm::mediump_dvec2>::value);
+static_assert(std::is_copy_constructible<glm::lowp_dvec2>::value);
+static_assert(glm::highp_dvec2::length() == 2);
+static_assert(glm::mediump_dvec2::length() == 2);
+static_assert(glm::lowp_dvec2::length() == 2);
+static_assert(sizeof(glm::highp_dvec2) == sizeof(glm::mediump_dvec2));
+static_assert(sizeof(glm::highp_dvec2) == sizeof(glm::lowp_dvec2));
+

glm/ext/vector_double3.hpp

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

glm/ext/vector_double3_precision.hpp

@@ -32,3 +32,23 @@ namespace glm
 
 	/// @}
 }//namespace glm
+
+#if GLM_CONFIG_CTOR_INIT == GLM_DISABLE
+static_assert(std::is_trivially_default_constructible<glm::highp_dvec3>::value);
+static_assert(std::is_trivially_default_constructible<glm::mediump_dvec3>::value);
+static_assert(std::is_trivially_default_constructible<glm::lowp_dvec3>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::highp_dvec3>::value);
+static_assert(std::is_trivially_copy_assignable<glm::mediump_dvec3>::value);
+static_assert(std::is_trivially_copy_assignable<glm::lowp_dvec3>::value);
+static_assert(std::is_trivially_copyable<glm::highp_dvec3>::value);
+static_assert(std::is_trivially_copyable<glm::mediump_dvec3>::value);
+static_assert(std::is_trivially_copyable<glm::lowp_dvec3>::value);
+static_assert(std::is_copy_constructible<glm::highp_dvec3>::value);
+static_assert(std::is_copy_constructible<glm::mediump_dvec3>::value);
+static_assert(std::is_copy_constructible<glm::lowp_dvec3>::value);
+static_assert(glm::highp_dvec3::length() == 3);
+static_assert(glm::mediump_dvec3::length() == 3);
+static_assert(glm::lowp_dvec3::length() == 3);
+static_assert(sizeof(glm::highp_dvec3) == sizeof(glm::mediump_dvec3));
+static_assert(sizeof(glm::highp_dvec3) == sizeof(glm::lowp_dvec3));

glm/ext/vector_double4.hpp

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

glm/ext/vector_double4_precision.hpp

@@ -33,3 +33,23 @@ namespace glm
 
 	/// @}
 }//namespace glm
+
+#if GLM_CONFIG_CTOR_INIT == GLM_DISABLE
+static_assert(std::is_trivially_default_constructible<glm::highp_dvec4>::value);
+static_assert(std::is_trivially_default_constructible<glm::mediump_dvec4>::value);
+static_assert(std::is_trivially_default_constructible<glm::lowp_dvec4>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::highp_dvec4>::value);
+static_assert(std::is_trivially_copy_assignable<glm::mediump_dvec4>::value);
+static_assert(std::is_trivially_copy_assignable<glm::lowp_dvec4>::value);
+static_assert(std::is_trivially_copyable<glm::highp_dvec4>::value);
+static_assert(std::is_trivially_copyable<glm::mediump_dvec4>::value);
+static_assert(std::is_trivially_copyable<glm::lowp_dvec4>::value);
+static_assert(std::is_copy_constructible<glm::highp_dvec4>::value);
+static_assert(std::is_copy_constructible<glm::mediump_dvec4>::value);
+static_assert(std::is_copy_constructible<glm::lowp_dvec4>::value);
+static_assert(glm::highp_dvec4::length() == 4);
+static_assert(glm::mediump_dvec4::length() == 4);
+static_assert(glm::lowp_dvec4::length() == 4);
+static_assert(sizeof(glm::highp_dvec4) == sizeof(glm::mediump_dvec4));
+static_assert(sizeof(glm::highp_dvec4) == sizeof(glm::lowp_dvec4));

glm/ext/vector_float1.hpp

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

glm/ext/vector_float1_precision.hpp

@@ -34,3 +34,23 @@ namespace glm
 
 	/// @}
 }//namespace glm
+
+#if GLM_CONFIG_CTOR_INIT == GLM_DISABLE
+static_assert(std::is_trivially_default_constructible<glm::highp_vec1>::value);
+static_assert(std::is_trivially_default_constructible<glm::mediump_vec1>::value);
+static_assert(std::is_trivially_default_constructible<glm::lowp_vec1>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::highp_vec1>::value);
+static_assert(std::is_trivially_copy_assignable<glm::mediump_vec1>::value);
+static_assert(std::is_trivially_copy_assignable<glm::lowp_vec1>::value);
+static_assert(std::is_trivially_copyable<glm::highp_vec1>::value);
+static_assert(std::is_trivially_copyable<glm::mediump_vec1>::value);
+static_assert(std::is_trivially_copyable<glm::lowp_vec1>::value);
+static_assert(std::is_copy_constructible<glm::highp_vec1>::value);
+static_assert(std::is_copy_constructible<glm::mediump_vec1>::value);
+static_assert(std::is_copy_constructible<glm::lowp_vec1>::value);
+static_assert(glm::highp_vec1::length() == 1);
+static_assert(glm::mediump_vec1::length() == 1);
+static_assert(glm::lowp_vec1::length() == 1);
+static_assert(sizeof(glm::highp_vec1) == sizeof(glm::mediump_vec1));
+static_assert(sizeof(glm::highp_vec1) == sizeof(glm::lowp_vec1));

glm/ext/vector_float2.hpp

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

glm/ext/vector_float2_precision.hpp

@@ -29,3 +29,24 @@ namespace glm
 
 	/// @}
 }//namespace glm
+
+#if GLM_CONFIG_CTOR_INIT == GLM_DISABLE
+static_assert(std::is_trivially_default_constructible<glm::highp_vec2>::value);
+static_assert(std::is_trivially_default_constructible<glm::mediump_vec2>::value);
+static_assert(std::is_trivially_default_constructible<glm::lowp_vec2>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::highp_vec2>::value);
+static_assert(std::is_trivially_copy_assignable<glm::mediump_vec2>::value);
+static_assert(std::is_trivially_copy_assignable<glm::lowp_vec2>::value);
+static_assert(std::is_trivially_copyable<glm::highp_vec2>::value);
+static_assert(std::is_trivially_copyable<glm::mediump_vec2>::value);
+static_assert(std::is_trivially_copyable<glm::lowp_vec2>::value);
+static_assert(std::is_copy_constructible<glm::highp_vec2>::value);
+static_assert(std::is_copy_constructible<glm::mediump_vec2>::value);
+static_assert(std::is_copy_constructible<glm::lowp_vec2>::value);
+static_assert(glm::highp_vec2::length() == 2);
+static_assert(glm::mediump_vec2::length() == 2);
+static_assert(glm::lowp_vec2::length() == 2);
+static_assert(sizeof(glm::highp_vec2) == sizeof(glm::mediump_vec2));
+static_assert(sizeof(glm::highp_vec2) == sizeof(glm::lowp_vec2));
+

glm/ext/vector_float3.hpp

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

glm/ext/vector_float3_precision.hpp

@@ -29,3 +29,24 @@ namespace glm
 
 	/// @}
 }//namespace glm
+
+#if GLM_CONFIG_CTOR_INIT == GLM_DISABLE
+static_assert(std::is_trivially_default_constructible<glm::highp_vec3>::value);
+static_assert(std::is_trivially_default_constructible<glm::mediump_vec3>::value);
+static_assert(std::is_trivially_default_constructible<glm::lowp_vec3>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::highp_vec3>::value);
+static_assert(std::is_trivially_copy_assignable<glm::mediump_vec3>::value);
+static_assert(std::is_trivially_copy_assignable<glm::lowp_vec3>::value);
+static_assert(std::is_trivially_copyable<glm::highp_vec3>::value);
+static_assert(std::is_trivially_copyable<glm::mediump_vec3>::value);
+static_assert(std::is_trivially_copyable<glm::lowp_vec3>::value);
+static_assert(std::is_copy_constructible<glm::highp_vec3>::value);
+static_assert(std::is_copy_constructible<glm::mediump_vec3>::value);
+static_assert(std::is_copy_constructible<glm::lowp_vec3>::value);
+static_assert(glm::highp_vec3::length() == 3);
+static_assert(glm::mediump_vec3::length() == 3);
+static_assert(glm::lowp_vec3::length() == 3);
+static_assert(sizeof(glm::highp_vec3) == sizeof(glm::mediump_vec3));
+static_assert(sizeof(glm::highp_vec3) == sizeof(glm::lowp_vec3));
+

glm/ext/vector_float4.hpp

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

glm/ext/vector_float4_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::highp_vec4>::value);
+static_assert(std::is_trivially_default_constructible<glm::mediump_vec4>::value);
+static_assert(std::is_trivially_default_constructible<glm::lowp_vec4>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::highp_vec4>::value);
+static_assert(std::is_trivially_copy_assignable<glm::mediump_vec4>::value);
+static_assert(std::is_trivially_copy_assignable<glm::lowp_vec4>::value);
+static_assert(std::is_trivially_copyable<glm::highp_vec4>::value);
+static_assert(std::is_trivially_copyable<glm::mediump_vec4>::value);
+static_assert(std::is_trivially_copyable<glm::lowp_vec4>::value);
+static_assert(std::is_copy_constructible<glm::highp_vec4>::value);
+static_assert(std::is_copy_constructible<glm::mediump_vec4>::value);
+static_assert(std::is_copy_constructible<glm::lowp_vec4>::value);
+static_assert(glm::highp_vec4::length() == 4);
+static_assert(glm::mediump_vec4::length() == 4);
+static_assert(glm::lowp_vec4::length() == 4);
+static_assert(sizeof(glm::highp_vec4) == sizeof(glm::mediump_vec4));
+static_assert(sizeof(glm::highp_vec4) == sizeof(glm::lowp_vec4));

glm/ext/vector_int1.hpp

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

glm/ext/vector_int1_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::i8vec1>::value);
+static_assert(std::is_trivially_default_constructible<glm::i16vec1>::value);
+static_assert(std::is_trivially_default_constructible<glm::i32vec1>::value);
+static_assert(std::is_trivially_default_constructible<glm::i64vec1>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::i8vec1>::value);
+static_assert(std::is_trivially_copy_assignable<glm::i16vec1>::value);
+static_assert(std::is_trivially_copy_assignable<glm::i32vec1>::value);
+static_assert(std::is_trivially_copy_assignable<glm::i64vec1>::value);
+static_assert(std::is_trivially_copyable<glm::i8vec1>::value);
+static_assert(std::is_trivially_copyable<glm::i16vec1>::value);
+static_assert(std::is_trivially_copyable<glm::i32vec1>::value);
+static_assert(std::is_trivially_copyable<glm::i64vec1>::value);
+static_assert(std::is_copy_constructible<glm::i8vec1>::value);
+static_assert(std::is_copy_constructible<glm::i16vec1>::value);
+static_assert(std::is_copy_constructible<glm::i32vec1>::value);
+static_assert(std::is_copy_constructible<glm::i64vec1>::value);
+static_assert(glm::i8vec1::length() == 1);
+static_assert(glm::i16vec1::length() == 1);
+static_assert(glm::i32vec1::length() == 1);
+static_assert(glm::i64vec1::length() == 1);
+

glm/ext/vector_int2.hpp

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

glm/ext/vector_int2_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::i8vec2>::value);
+static_assert(std::is_trivially_default_constructible<glm::i16vec2>::value);
+static_assert(std::is_trivially_default_constructible<glm::i32vec2>::value);
+static_assert(std::is_trivially_default_constructible<glm::i64vec2>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::i8vec2>::value);
+static_assert(std::is_trivially_copy_assignable<glm::i16vec2>::value);
+static_assert(std::is_trivially_copy_assignable<glm::i32vec2>::value);
+static_assert(std::is_trivially_copy_assignable<glm::i64vec2>::value);
+static_assert(std::is_trivially_copyable<glm::i8vec2>::value);
+static_assert(std::is_trivially_copyable<glm::i16vec2>::value);
+static_assert(std::is_trivially_copyable<glm::i32vec2>::value);
+static_assert(std::is_trivially_copyable<glm::i64vec2>::value);
+static_assert(std::is_copy_constructible<glm::i8vec2>::value);
+static_assert(std::is_copy_constructible<glm::i16vec2>::value);
+static_assert(std::is_copy_constructible<glm::i32vec2>::value);
+static_assert(std::is_copy_constructible<glm::i64vec2>::value);
+static_assert(glm::i8vec2::length() == 2);
+static_assert(glm::i16vec2::length() == 2);
+static_assert(glm::i32vec2::length() == 2);
+static_assert(glm::i64vec2::length() == 2);

glm/ext/vector_int3.hpp

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

glm/ext/vector_int3_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::i8vec3>::value);
+static_assert(std::is_trivially_default_constructible<glm::i16vec3>::value);
+static_assert(std::is_trivially_default_constructible<glm::i32vec3>::value);
+static_assert(std::is_trivially_default_constructible<glm::i64vec3>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::i8vec3>::value);
+static_assert(std::is_trivially_copy_assignable<glm::i16vec3>::value);
+static_assert(std::is_trivially_copy_assignable<glm::i32vec3>::value);
+static_assert(std::is_trivially_copy_assignable<glm::i64vec3>::value);
+static_assert(std::is_trivially_copyable<glm::i8vec3>::value);
+static_assert(std::is_trivially_copyable<glm::i16vec3>::value);
+static_assert(std::is_trivially_copyable<glm::i32vec3>::value);
+static_assert(std::is_trivially_copyable<glm::i64vec3>::value);
+static_assert(std::is_copy_constructible<glm::i8vec3>::value);
+static_assert(std::is_copy_constructible<glm::i16vec3>::value);
+static_assert(std::is_copy_constructible<glm::i32vec3>::value);
+static_assert(std::is_copy_constructible<glm::i64vec3>::value);
+static_assert(glm::i8vec3::length() == 3);
+static_assert(glm::i16vec3::length() == 3);
+static_assert(glm::i32vec3::length() == 3);
+static_assert(glm::i64vec3::length() == 3);

glm/ext/vector_int4.hpp

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