From 8409c195cda73a27bde4cf6c122a5f59cd9f23f9 Mon Sep 17 00:00:00 2001
From: christophe <christophe@g-truc.net>
Date: Mon, 20 Oct 2025 00:11:56 +0200
Subject: [PATCH] Add static_assert to basic types

---
 glm/detail/setup.hpp                          | 24 +---------
 glm/ext/matrix_double2x2.hpp                  | 14 ++++++
 glm/ext/matrix_double2x2_precision.hpp        | 33 ++++++++++++++
 glm/ext/matrix_double2x3.hpp                  |  9 ++++
 glm/ext/matrix_double2x3_precision.hpp        | 19 ++++++++
 glm/ext/matrix_double2x4.hpp                  |  8 ++++
 glm/ext/matrix_double2x4_precision.hpp        | 18 ++++++++
 glm/ext/matrix_double3x2.hpp                  |  8 ++++
 glm/ext/matrix_double3x2_precision.hpp        | 18 ++++++++
 glm/ext/matrix_double3x3.hpp                  | 14 ++++++
 glm/ext/matrix_double3x3_precision.hpp        | 33 ++++++++++++++
 glm/ext/matrix_double3x4.hpp                  |  8 ++++
 glm/ext/matrix_double3x4_precision.hpp        | 19 ++++++++
 glm/ext/matrix_double4x2.hpp                  |  8 ++++
 glm/ext/matrix_double4x2_precision.hpp        | 18 ++++++++
 glm/ext/matrix_double4x3.hpp                  |  8 ++++
 glm/ext/matrix_double4x3_precision.hpp        | 18 ++++++++
 glm/ext/matrix_double4x4.hpp                  | 14 ++++++
 glm/ext/matrix_double4x4_precision.hpp        | 33 ++++++++++++++
 glm/ext/matrix_float2x2.hpp                   | 13 ++++++
 glm/ext/matrix_float2x2_precision.hpp         | 34 ++++++++++++++
 glm/ext/matrix_float2x3.hpp                   |  9 ++++
 glm/ext/matrix_float2x3_precision.hpp         | 20 +++++++++
 glm/ext/matrix_float2x4.hpp                   | 10 +++++
 glm/ext/matrix_float2x4_precision.hpp         | 18 ++++++++
 glm/ext/matrix_float3x2.hpp                   |  8 ++++
 glm/ext/matrix_float3x2_precision.hpp         | 19 ++++++++
 glm/ext/matrix_float3x3.hpp                   | 13 ++++++
 glm/ext/matrix_float3x3_precision.hpp         | 34 ++++++++++++++
 glm/ext/matrix_float3x4.hpp                   |  8 ++++
 glm/ext/matrix_float3x4_precision.hpp         | 18 ++++++++
 glm/ext/matrix_float4x2.hpp                   |  8 ++++
 glm/ext/matrix_float4x2_precision.hpp         | 18 ++++++++
 glm/ext/matrix_float4x3.hpp                   |  8 ++++
 glm/ext/matrix_float4x3_precision.hpp         | 18 ++++++++
 glm/ext/matrix_float4x4.hpp                   | 13 ++++++
 glm/ext/matrix_float4x4_precision.hpp         | 33 ++++++++++++++
 glm/ext/matrix_int2x2.hpp                     | 14 ++++++
 glm/ext/matrix_int2x2_sized.hpp               | 43 ++++++++++++++++++
 glm/ext/matrix_int2x3.hpp                     |  8 ++++
 glm/ext/matrix_int2x3_sized.hpp               | 23 ++++++++++
 glm/ext/matrix_int2x4.hpp                     |  9 ++++
 glm/ext/matrix_int2x4_sized.hpp               | 23 ++++++++++
 glm/ext/matrix_int3x2.hpp                     |  8 ++++
 glm/ext/matrix_int3x2_sized.hpp               | 23 ++++++++++
 glm/ext/matrix_int3x3.hpp                     | 14 ++++++
 glm/ext/matrix_int3x3_sized.hpp               | 43 ++++++++++++++++++
 glm/ext/matrix_int3x4.hpp                     |  8 ++++
 glm/ext/matrix_int3x4_sized.hpp               | 23 ++++++++++
 glm/ext/matrix_int4x2.hpp                     |  8 ++++
 glm/ext/matrix_int4x2_sized.hpp               | 23 ++++++++++
 glm/ext/matrix_int4x3.hpp                     |  8 ++++
 glm/ext/matrix_int4x3_sized.hpp               | 24 ++++++++++
 glm/ext/matrix_int4x4.hpp                     | 13 ++++++
 glm/ext/matrix_int4x4_sized.hpp               | 45 +++++++++++++++++++
 glm/ext/matrix_uint2x2.hpp                    | 13 ++++++
 glm/ext/matrix_uint2x2_sized.hpp              | 43 ++++++++++++++++++
 glm/ext/matrix_uint2x3.hpp                    |  9 ++++
 glm/ext/matrix_uint2x3_sized.hpp              | 24 ++++++++++
 glm/ext/matrix_uint2x4.hpp                    |  8 ++++
 glm/ext/matrix_uint2x4_sized.hpp              | 23 ++++++++++
 glm/ext/matrix_uint3x2.hpp                    |  9 ++++
 glm/ext/matrix_uint3x2_sized.hpp              | 23 ++++++++++
 glm/ext/matrix_uint3x3.hpp                    | 13 ++++++
 glm/ext/matrix_uint3x3_sized.hpp              | 43 ++++++++++++++++++
 glm/ext/matrix_uint3x4.hpp                    |  8 ++++
 glm/ext/matrix_uint3x4_sized.hpp              | 23 ++++++++++
 glm/ext/matrix_uint4x2.hpp                    |  9 ++++
 glm/ext/matrix_uint4x2_sized.hpp              | 23 ++++++++++
 glm/ext/matrix_uint4x3.hpp                    |  9 ++++
 glm/ext/matrix_uint4x3_sized.hpp              | 24 ++++++++++
 glm/ext/matrix_uint4x4.hpp                    | 14 ++++++
 glm/ext/matrix_uint4x4_sized.hpp              | 44 ++++++++++++++++++
 glm/ext/quaternion_double.hpp                 |  7 +++
 glm/ext/quaternion_double_precision.hpp       | 17 +++++++
 glm/ext/quaternion_float.hpp                  |  7 +++
 glm/ext/quaternion_float_precision.hpp        | 17 +++++++
 glm/ext/vector_double1.hpp                    |  8 ++++
 glm/ext/vector_double1_precision.hpp          | 20 +++++++++
 glm/ext/vector_double2.hpp                    |  8 ++++
 glm/ext/vector_double2_precision.hpp          | 21 +++++++++
 glm/ext/vector_double3.hpp                    |  8 ++++
 glm/ext/vector_double3_precision.hpp          | 20 +++++++++
 glm/ext/vector_double4.hpp                    |  8 ++++
 glm/ext/vector_double4_precision.hpp          | 20 +++++++++
 glm/ext/vector_float1.hpp                     |  8 ++++
 glm/ext/vector_float1_precision.hpp           | 20 +++++++++
 glm/ext/vector_float2.hpp                     |  8 ++++
 glm/ext/vector_float2_precision.hpp           | 21 +++++++++
 glm/ext/vector_float3.hpp                     |  8 ++++
 glm/ext/vector_float3_precision.hpp           | 21 +++++++++
 glm/ext/vector_float4.hpp                     |  9 ++++
 glm/ext/vector_float4_precision.hpp           | 20 +++++++++
 glm/ext/vector_int1.hpp                       |  7 +++
 glm/ext/vector_int1_sized.hpp                 | 24 ++++++++++
 glm/ext/vector_int2.hpp                       |  9 ++++
 glm/ext/vector_int2_sized.hpp                 | 23 ++++++++++
 glm/ext/vector_int3.hpp                       |  9 ++++
 glm/ext/vector_int3_sized.hpp                 | 23 ++++++++++
 glm/ext/vector_int4.hpp                       |  8 ++++
 glm/ext/vector_int4_sized.hpp                 | 23 ++++++++++
 glm/ext/vector_uint1.hpp                      |  7 +++
 glm/ext/vector_uint1_sized.hpp                | 23 ++++++++++
 glm/ext/vector_uint2.hpp                      |  8 ++++
 glm/ext/vector_uint2_sized.hpp                | 23 ++++++++++
 glm/ext/vector_uint3.hpp                      |  9 ++++
 glm/ext/vector_uint3_sized.hpp                | 23 ++++++++++
 glm/ext/vector_uint4.hpp                      | 10 +++++
 glm/ext/vector_uint4_sized.hpp                | 23 ++++++++++
 glm/gtx/dual_quaternion.hpp                   | 24 ++++++++++
 manual.md                                     | 11 +++--
 test/core/CMakeLists.txt                      |  4 +-
 test/core/core_force_intrinsics.cpp           |  2 -
 test/core/core_force_pure.cpp                 |  2 -
 ...e_cxx03.cpp => core_setup_force_cxx17.cpp} | 14 +-----
 ...e_cxx98.cpp => core_setup_force_cxx20.cpp} | 14 +-----
 test/core/core_type_mat2x2.cpp                |  3 --
 test/core/core_type_mat2x3.cpp                |  3 --
 test/core/core_type_mat2x4.cpp                |  5 +--
 test/core/core_type_mat3x2.cpp                |  7 +--
 test/core/core_type_mat3x3.cpp                |  7 +--
 test/core/core_type_mat3x4.cpp                |  7 +--
 test/core/core_type_mat4x2.cpp                |  5 +--
 test/core/core_type_mat4x3.cpp                |  5 +--
 test/core/core_type_mat4x4.cpp                | 12 +++--
 test/core/core_type_vec1.cpp                  | 10 ++---
 test/core/core_type_vec2.cpp                  |  2 -
 test/core/core_type_vec3.cpp                  |  6 +--
 test/core/core_type_vec4.cpp                  | 13 ------
 test/ext/ext_quaternion_type.cpp              | 12 +++--
 130 files changed, 1910 insertions(+), 134 deletions(-)
 rename test/core/{core_setup_force_cxx03.cpp => core_setup_force_cxx17.cpp} (53%)
 rename test/core/{core_setup_force_cxx98.cpp => core_setup_force_cxx20.cpp} (53%)

diff --git a/glm/detail/setup.hpp b/glm/detail/setup.hpp
index fa57ba99c..471506917 100644
--- a/glm/detail/setup.hpp
+++ b/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)
diff --git a/glm/ext/matrix_double2x2.hpp b/glm/ext/matrix_double2x2.hpp
index 94dca54b5..472ea9ff5 100644
--- a/glm/ext/matrix_double2x2.hpp
+++ b/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);
+
diff --git a/glm/ext/matrix_double2x2_precision.hpp b/glm/ext/matrix_double2x2_precision.hpp
index 9e2c174e4..6a7c0206f 100644
--- a/glm/ext/matrix_double2x2_precision.hpp
+++ b/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);
diff --git a/glm/ext/matrix_double2x3.hpp b/glm/ext/matrix_double2x3.hpp
index bfef87a66..6c2f0a04d 100644
--- a/glm/ext/matrix_double2x3.hpp
+++ b/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);
+
diff --git a/glm/ext/matrix_double2x3_precision.hpp b/glm/ext/matrix_double2x3_precision.hpp
index 098fb6046..6098dd459 100644
--- a/glm/ext/matrix_double2x3_precision.hpp
+++ b/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);
+
diff --git a/glm/ext/matrix_double2x4.hpp b/glm/ext/matrix_double2x4.hpp
index 499284bce..45f851aba 100644
--- a/glm/ext/matrix_double2x4.hpp
+++ b/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);
diff --git a/glm/ext/matrix_double2x4_precision.hpp b/glm/ext/matrix_double2x4_precision.hpp
index 9b61ebcee..f555c97a0 100644
--- a/glm/ext/matrix_double2x4_precision.hpp
+++ b/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);
diff --git a/glm/ext/matrix_double3x2.hpp b/glm/ext/matrix_double3x2.hpp
index dd23f36cd..8f664e7f1 100644
--- a/glm/ext/matrix_double3x2.hpp
+++ b/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);
diff --git a/glm/ext/matrix_double3x2_precision.hpp b/glm/ext/matrix_double3x2_precision.hpp
index 068d9e911..2df71f1ab 100644
--- a/glm/ext/matrix_double3x2_precision.hpp
+++ b/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);
diff --git a/glm/ext/matrix_double3x3.hpp b/glm/ext/matrix_double3x3.hpp
index 53572b735..9d3827fda 100644
--- a/glm/ext/matrix_double3x3.hpp
+++ b/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);
+
diff --git a/glm/ext/matrix_double3x3_precision.hpp b/glm/ext/matrix_double3x3_precision.hpp
index 8691e7808..694094a7c 100644
--- a/glm/ext/matrix_double3x3_precision.hpp
+++ b/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);
diff --git a/glm/ext/matrix_double3x4.hpp b/glm/ext/matrix_double3x4.hpp
index c572d637c..25606b576 100644
--- a/glm/ext/matrix_double3x4.hpp
+++ b/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);
diff --git a/glm/ext/matrix_double3x4_precision.hpp b/glm/ext/matrix_double3x4_precision.hpp
index f040217e7..5d9ef04b7 100644
--- a/glm/ext/matrix_double3x4_precision.hpp
+++ b/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);
+
diff --git a/glm/ext/matrix_double4x2.hpp b/glm/ext/matrix_double4x2.hpp
index 9b229f471..997dc7a27 100644
--- a/glm/ext/matrix_double4x2.hpp
+++ b/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);
diff --git a/glm/ext/matrix_double4x2_precision.hpp b/glm/ext/matrix_double4x2_precision.hpp
index 6ad18ba9e..8ef532aff 100644
--- a/glm/ext/matrix_double4x2_precision.hpp
+++ b/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);
diff --git a/glm/ext/matrix_double4x3.hpp b/glm/ext/matrix_double4x3.hpp
index dca4cf956..6cd04059a 100644
--- a/glm/ext/matrix_double4x3.hpp
+++ b/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);
diff --git a/glm/ext/matrix_double4x3_precision.hpp b/glm/ext/matrix_double4x3_precision.hpp
index f7371de84..4b2e65e1c 100644
--- a/glm/ext/matrix_double4x3_precision.hpp
+++ b/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);
diff --git a/glm/ext/matrix_double4x4.hpp b/glm/ext/matrix_double4x4.hpp
index 81e1bf65c..1884cd7cd 100644
--- a/glm/ext/matrix_double4x4.hpp
+++ b/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);
+
diff --git a/glm/ext/matrix_double4x4_precision.hpp b/glm/ext/matrix_double4x4_precision.hpp
index 4c36a8486..b808abe2f 100644
--- a/glm/ext/matrix_double4x4_precision.hpp
+++ b/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);
diff --git a/glm/ext/matrix_float2x2.hpp b/glm/ext/matrix_float2x2.hpp
index 53df921fe..2249a9af7 100644
--- a/glm/ext/matrix_float2x2.hpp
+++ b/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);
diff --git a/glm/ext/matrix_float2x2_precision.hpp b/glm/ext/matrix_float2x2_precision.hpp
index 898b6db71..822aef432 100644
--- a/glm/ext/matrix_float2x2_precision.hpp
+++ b/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);
+
diff --git a/glm/ext/matrix_float2x3.hpp b/glm/ext/matrix_float2x3.hpp
index 6f68822db..92e31edb3 100644
--- a/glm/ext/matrix_float2x3.hpp
+++ b/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);
+
diff --git a/glm/ext/matrix_float2x3_precision.hpp b/glm/ext/matrix_float2x3_precision.hpp
index 50c103245..a8b43ca68 100644
--- a/glm/ext/matrix_float2x3_precision.hpp
+++ b/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);
+
+
diff --git a/glm/ext/matrix_float2x4.hpp b/glm/ext/matrix_float2x4.hpp
index 30f30de3c..a68514c1e 100644
--- a/glm/ext/matrix_float2x4.hpp
+++ b/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);
+
+
diff --git a/glm/ext/matrix_float2x4_precision.hpp b/glm/ext/matrix_float2x4_precision.hpp
index 079d63828..1187d66a2 100644
--- a/glm/ext/matrix_float2x4_precision.hpp
+++ b/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);
diff --git a/glm/ext/matrix_float3x2.hpp b/glm/ext/matrix_float3x2.hpp
index 280d0a3e9..70ce33ff1 100644
--- a/glm/ext/matrix_float3x2.hpp
+++ b/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);
diff --git a/glm/ext/matrix_float3x2_precision.hpp b/glm/ext/matrix_float3x2_precision.hpp
index 8572c2a1b..e6419129e 100644
--- a/glm/ext/matrix_float3x2_precision.hpp
+++ b/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);
+
diff --git a/glm/ext/matrix_float3x3.hpp b/glm/ext/matrix_float3x3.hpp
index 177d809ff..a45db40e1 100644
--- a/glm/ext/matrix_float3x3.hpp
+++ b/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);
diff --git a/glm/ext/matrix_float3x3_precision.hpp b/glm/ext/matrix_float3x3_precision.hpp
index 8a900c164..77eda477a 100644
--- a/glm/ext/matrix_float3x3_precision.hpp
+++ b/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);
+
diff --git a/glm/ext/matrix_float3x4.hpp b/glm/ext/matrix_float3x4.hpp
index 64b8459dc..410c72f38 100644
--- a/glm/ext/matrix_float3x4.hpp
+++ b/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);
diff --git a/glm/ext/matrix_float3x4_precision.hpp b/glm/ext/matrix_float3x4_precision.hpp
index bc36bf13a..76a219f87 100644
--- a/glm/ext/matrix_float3x4_precision.hpp
+++ b/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);
diff --git a/glm/ext/matrix_float4x2.hpp b/glm/ext/matrix_float4x2.hpp
index 1ed5227bf..e96e00f2b 100644
--- a/glm/ext/matrix_float4x2.hpp
+++ b/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);
diff --git a/glm/ext/matrix_float4x2_precision.hpp b/glm/ext/matrix_float4x2_precision.hpp
index 88fd06963..0f2e44d19 100644
--- a/glm/ext/matrix_float4x2_precision.hpp
+++ b/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);
diff --git a/glm/ext/matrix_float4x3.hpp b/glm/ext/matrix_float4x3.hpp
index 5dbe76570..759d25a82 100644
--- a/glm/ext/matrix_float4x3.hpp
+++ b/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);
diff --git a/glm/ext/matrix_float4x3_precision.hpp b/glm/ext/matrix_float4x3_precision.hpp
index 846ed4fc8..8048d92c1 100644
--- a/glm/ext/matrix_float4x3_precision.hpp
+++ b/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);
diff --git a/glm/ext/matrix_float4x4.hpp b/glm/ext/matrix_float4x4.hpp
index 5ba111de0..51f74ca65 100644
--- a/glm/ext/matrix_float4x4.hpp
+++ b/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);
diff --git a/glm/ext/matrix_float4x4_precision.hpp b/glm/ext/matrix_float4x4_precision.hpp
index 597149bcf..43687ca31 100644
--- a/glm/ext/matrix_float4x4_precision.hpp
+++ b/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);
diff --git a/glm/ext/matrix_int2x2.hpp b/glm/ext/matrix_int2x2.hpp
index c6aa0686a..685bc880d 100644
--- a/glm/ext/matrix_int2x2.hpp
+++ b/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);
+
diff --git a/glm/ext/matrix_int2x2_sized.hpp b/glm/ext/matrix_int2x2_sized.hpp
index 70c0c2106..07025effe 100644
--- a/glm/ext/matrix_int2x2_sized.hpp
+++ b/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);
diff --git a/glm/ext/matrix_int2x3.hpp b/glm/ext/matrix_int2x3.hpp
index aee415caa..c93c3ff18 100644
--- a/glm/ext/matrix_int2x3.hpp
+++ b/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);
diff --git a/glm/ext/matrix_int2x3_sized.hpp b/glm/ext/matrix_int2x3_sized.hpp
index b5526fe55..321a8b080 100644
--- a/glm/ext/matrix_int2x3_sized.hpp
+++ b/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);
diff --git a/glm/ext/matrix_int2x4.hpp b/glm/ext/matrix_int2x4.hpp
index 4f36331d6..238afbe1f 100644
--- a/glm/ext/matrix_int2x4.hpp
+++ b/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);
+
diff --git a/glm/ext/matrix_int2x4_sized.hpp b/glm/ext/matrix_int2x4_sized.hpp
index a66a5e726..4c1afac9d 100644
--- a/glm/ext/matrix_int2x4_sized.hpp
+++ b/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);
diff --git a/glm/ext/matrix_int3x2.hpp b/glm/ext/matrix_int3x2.hpp
index 3bd563b7d..3611e7d8a 100644
--- a/glm/ext/matrix_int3x2.hpp
+++ b/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);
diff --git a/glm/ext/matrix_int3x2_sized.hpp b/glm/ext/matrix_int3x2_sized.hpp
index 7e34c5240..782c24c70 100644
--- a/glm/ext/matrix_int3x2_sized.hpp
+++ b/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);
diff --git a/glm/ext/matrix_int3x3.hpp b/glm/ext/matrix_int3x3.hpp
index 287488da0..6a2efa4c3 100644
--- a/glm/ext/matrix_int3x3.hpp
+++ b/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);
+
diff --git a/glm/ext/matrix_int3x3_sized.hpp b/glm/ext/matrix_int3x3_sized.hpp
index 577e305aa..36747fa58 100644
--- a/glm/ext/matrix_int3x3_sized.hpp
+++ b/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);
diff --git a/glm/ext/matrix_int3x4.hpp b/glm/ext/matrix_int3x4.hpp
index 08e534d9c..f17547960 100644
--- a/glm/ext/matrix_int3x4.hpp
+++ b/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);
diff --git a/glm/ext/matrix_int3x4_sized.hpp b/glm/ext/matrix_int3x4_sized.hpp
index 692c48c43..959d14af1 100644
--- a/glm/ext/matrix_int3x4_sized.hpp
+++ b/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);
diff --git a/glm/ext/matrix_int4x2.hpp b/glm/ext/matrix_int4x2.hpp
index f756ef280..9beadcfeb 100644
--- a/glm/ext/matrix_int4x2.hpp
+++ b/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);
diff --git a/glm/ext/matrix_int4x2_sized.hpp b/glm/ext/matrix_int4x2_sized.hpp
index 63a99d604..51edafec6 100644
--- a/glm/ext/matrix_int4x2_sized.hpp
+++ b/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);
diff --git a/glm/ext/matrix_int4x3.hpp b/glm/ext/matrix_int4x3.hpp
index d5d97a7a3..0bd29e843 100644
--- a/glm/ext/matrix_int4x3.hpp
+++ b/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);
diff --git a/glm/ext/matrix_int4x3_sized.hpp b/glm/ext/matrix_int4x3_sized.hpp
index 55078fadc..937bb5d3d 100644
--- a/glm/ext/matrix_int4x3_sized.hpp
+++ b/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);
+
diff --git a/glm/ext/matrix_int4x4.hpp b/glm/ext/matrix_int4x4.hpp
index e17cff17f..40db26d6b 100644
--- a/glm/ext/matrix_int4x4.hpp
+++ b/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);
diff --git a/glm/ext/matrix_int4x4_sized.hpp b/glm/ext/matrix_int4x4_sized.hpp
index 4a11203eb..c7c11e820 100644
--- a/glm/ext/matrix_int4x4_sized.hpp
+++ b/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);
+
+
diff --git a/glm/ext/matrix_uint2x2.hpp b/glm/ext/matrix_uint2x2.hpp
index 034771ae5..bab90a784 100644
--- a/glm/ext/matrix_uint2x2.hpp
+++ b/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);
diff --git a/glm/ext/matrix_uint2x2_sized.hpp b/glm/ext/matrix_uint2x2_sized.hpp
index 4555324d2..8bcc8d458 100644
--- a/glm/ext/matrix_uint2x2_sized.hpp
+++ b/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);
diff --git a/glm/ext/matrix_uint2x3.hpp b/glm/ext/matrix_uint2x3.hpp
index f496c531a..8a916f4ed 100644
--- a/glm/ext/matrix_uint2x3.hpp
+++ b/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);
+
diff --git a/glm/ext/matrix_uint2x3_sized.hpp b/glm/ext/matrix_uint2x3_sized.hpp
index db7939c94..18fca1d25 100644
--- a/glm/ext/matrix_uint2x3_sized.hpp
+++ b/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);
+
diff --git a/glm/ext/matrix_uint2x4.hpp b/glm/ext/matrix_uint2x4.hpp
index 0f993509c..9e236ac5a 100644
--- a/glm/ext/matrix_uint2x4.hpp
+++ b/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);
diff --git a/glm/ext/matrix_uint2x4_sized.hpp b/glm/ext/matrix_uint2x4_sized.hpp
index 5c55547ff..d533e4209 100644
--- a/glm/ext/matrix_uint2x4_sized.hpp
+++ b/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);
diff --git a/glm/ext/matrix_uint3x2.hpp b/glm/ext/matrix_uint3x2.hpp
index 55a9bed68..e3fcb70cb 100644
--- a/glm/ext/matrix_uint3x2.hpp
+++ b/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);
+
diff --git a/glm/ext/matrix_uint3x2_sized.hpp b/glm/ext/matrix_uint3x2_sized.hpp
index c81af8f96..6bd15dade 100644
--- a/glm/ext/matrix_uint3x2_sized.hpp
+++ b/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);
diff --git a/glm/ext/matrix_uint3x3.hpp b/glm/ext/matrix_uint3x3.hpp
index 1004c0d2d..8aecbba81 100644
--- a/glm/ext/matrix_uint3x3.hpp
+++ b/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);
diff --git a/glm/ext/matrix_uint3x3_sized.hpp b/glm/ext/matrix_uint3x3_sized.hpp
index 41a8be748..b5c70f7e1 100644
--- a/glm/ext/matrix_uint3x3_sized.hpp
+++ b/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);
diff --git a/glm/ext/matrix_uint3x4.hpp b/glm/ext/matrix_uint3x4.hpp
index c6dd78c4a..619c37543 100644
--- a/glm/ext/matrix_uint3x4.hpp
+++ b/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);
diff --git a/glm/ext/matrix_uint3x4_sized.hpp b/glm/ext/matrix_uint3x4_sized.hpp
index 2ce28ad81..fc128f68b 100644
--- a/glm/ext/matrix_uint3x4_sized.hpp
+++ b/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);
diff --git a/glm/ext/matrix_uint4x2.hpp b/glm/ext/matrix_uint4x2.hpp
index 0446f5745..42c828c29 100644
--- a/glm/ext/matrix_uint4x2.hpp
+++ b/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);
+
diff --git a/glm/ext/matrix_uint4x2_sized.hpp b/glm/ext/matrix_uint4x2_sized.hpp
index 57a66bf9b..9eed07720 100644
--- a/glm/ext/matrix_uint4x2_sized.hpp
+++ b/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);
diff --git a/glm/ext/matrix_uint4x3.hpp b/glm/ext/matrix_uint4x3.hpp
index 54c24e4e5..9e65a4e78 100644
--- a/glm/ext/matrix_uint4x3.hpp
+++ b/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);
+
diff --git a/glm/ext/matrix_uint4x3_sized.hpp b/glm/ext/matrix_uint4x3_sized.hpp
index 2e61124d6..09efaf930 100644
--- a/glm/ext/matrix_uint4x3_sized.hpp
+++ b/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);
+
diff --git a/glm/ext/matrix_uint4x4.hpp b/glm/ext/matrix_uint4x4.hpp
index 5cc84553d..864dd6d8a 100644
--- a/glm/ext/matrix_uint4x4.hpp
+++ b/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);
+
diff --git a/glm/ext/matrix_uint4x4_sized.hpp b/glm/ext/matrix_uint4x4_sized.hpp
index bb10bd2b7..10443c866 100644
--- a/glm/ext/matrix_uint4x4_sized.hpp
+++ b/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);
+
diff --git a/glm/ext/quaternion_double.hpp b/glm/ext/quaternion_double.hpp
index 63b24de4d..de19eab8b 100644
--- a/glm/ext/quaternion_double.hpp
+++ b/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);
diff --git a/glm/ext/quaternion_double_precision.hpp b/glm/ext/quaternion_double_precision.hpp
index 8aa24a177..650b65a96 100644
--- a/glm/ext/quaternion_double_precision.hpp
+++ b/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);
diff --git a/glm/ext/quaternion_float.hpp b/glm/ext/quaternion_float.hpp
index ca42a6059..b438b6dba 100644
--- a/glm/ext/quaternion_float.hpp
+++ b/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);
diff --git a/glm/ext/quaternion_float_precision.hpp b/glm/ext/quaternion_float_precision.hpp
index f9e4f5c21..89f037c80 100644
--- a/glm/ext/quaternion_float_precision.hpp
+++ b/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);
diff --git a/glm/ext/vector_double1.hpp b/glm/ext/vector_double1.hpp
index 388266774..69db7ee84 100644
--- a/glm/ext/vector_double1.hpp
+++ b/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);
diff --git a/glm/ext/vector_double1_precision.hpp b/glm/ext/vector_double1_precision.hpp
index 1d4719595..160c3fccd 100644
--- a/glm/ext/vector_double1_precision.hpp
+++ b/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));
diff --git a/glm/ext/vector_double2.hpp b/glm/ext/vector_double2.hpp
index 60e357750..1aff70e6d 100644
--- a/glm/ext/vector_double2.hpp
+++ b/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);
diff --git a/glm/ext/vector_double2_precision.hpp b/glm/ext/vector_double2_precision.hpp
index fa53940f6..49e1f72b3 100644
--- a/glm/ext/vector_double2_precision.hpp
+++ b/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));
+
diff --git a/glm/ext/vector_double3.hpp b/glm/ext/vector_double3.hpp
index 6dfe4c675..4c495893a 100644
--- a/glm/ext/vector_double3.hpp
+++ b/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);
diff --git a/glm/ext/vector_double3_precision.hpp b/glm/ext/vector_double3_precision.hpp
index a8cfa37a8..8f4c984ce 100644
--- a/glm/ext/vector_double3_precision.hpp
+++ b/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));
diff --git a/glm/ext/vector_double4.hpp b/glm/ext/vector_double4.hpp
index 87f225f64..90b8a174e 100644
--- a/glm/ext/vector_double4.hpp
+++ b/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);
diff --git a/glm/ext/vector_double4_precision.hpp b/glm/ext/vector_double4_precision.hpp
index 09cafa1eb..c99e0dcd0 100644
--- a/glm/ext/vector_double4_precision.hpp
+++ b/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));
diff --git a/glm/ext/vector_float1.hpp b/glm/ext/vector_float1.hpp
index 28acc2c9c..3d3f0bece 100644
--- a/glm/ext/vector_float1.hpp
+++ b/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);
diff --git a/glm/ext/vector_float1_precision.hpp b/glm/ext/vector_float1_precision.hpp
index 6e8dad8d1..3178b2289 100644
--- a/glm/ext/vector_float1_precision.hpp
+++ b/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));
diff --git a/glm/ext/vector_float2.hpp b/glm/ext/vector_float2.hpp
index d31545dcc..297d64eed 100644
--- a/glm/ext/vector_float2.hpp
+++ b/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);
diff --git a/glm/ext/vector_float2_precision.hpp b/glm/ext/vector_float2_precision.hpp
index 23c0820d0..784ac30ff 100644
--- a/glm/ext/vector_float2_precision.hpp
+++ b/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));
+
diff --git a/glm/ext/vector_float3.hpp b/glm/ext/vector_float3.hpp
index cd79a6200..bcd6884b0 100644
--- a/glm/ext/vector_float3.hpp
+++ b/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);
diff --git a/glm/ext/vector_float3_precision.hpp b/glm/ext/vector_float3_precision.hpp
index be640b531..79b7b6ee9 100644
--- a/glm/ext/vector_float3_precision.hpp
+++ b/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));
+
diff --git a/glm/ext/vector_float4.hpp b/glm/ext/vector_float4.hpp
index d84adcc22..bbabe49d9 100644
--- a/glm/ext/vector_float4.hpp
+++ b/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);
+
diff --git a/glm/ext/vector_float4_precision.hpp b/glm/ext/vector_float4_precision.hpp
index aede83882..426632c99 100644
--- a/glm/ext/vector_float4_precision.hpp
+++ b/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));
diff --git a/glm/ext/vector_int1.hpp b/glm/ext/vector_int1.hpp
index dc8603891..1ec3f6e30 100644
--- a/glm/ext/vector_int1.hpp
+++ b/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);
diff --git a/glm/ext/vector_int1_sized.hpp b/glm/ext/vector_int1_sized.hpp
index de0d4cf82..d315b3faf 100644
--- a/glm/ext/vector_int1_sized.hpp
+++ b/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);
+
diff --git a/glm/ext/vector_int2.hpp b/glm/ext/vector_int2.hpp
index aef803e91..b5308b4ec 100644
--- a/glm/ext/vector_int2.hpp
+++ b/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);
+
diff --git a/glm/ext/vector_int2_sized.hpp b/glm/ext/vector_int2_sized.hpp
index 1fd57eef3..2baab4570 100644
--- a/glm/ext/vector_int2_sized.hpp
+++ b/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);
diff --git a/glm/ext/vector_int3.hpp b/glm/ext/vector_int3.hpp
index 4767e61e8..da81cb126 100644
--- a/glm/ext/vector_int3.hpp
+++ b/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);
+
diff --git a/glm/ext/vector_int3_sized.hpp b/glm/ext/vector_int3_sized.hpp
index 085a3febb..799d9ddf2 100644
--- a/glm/ext/vector_int3_sized.hpp
+++ b/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);
diff --git a/glm/ext/vector_int4.hpp b/glm/ext/vector_int4.hpp
index bb23adf70..3c0c51412 100644
--- a/glm/ext/vector_int4.hpp
+++ b/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);
diff --git a/glm/ext/vector_int4_sized.hpp b/glm/ext/vector_int4_sized.hpp
index c63d46540..4fac02148 100644
--- a/glm/ext/vector_int4_sized.hpp
+++ b/glm/ext/vector_int4_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::i8vec4>::value);
+static_assert(std::is_trivially_default_constructible<glm::i16vec4>::value);
+static_assert(std::is_trivially_default_constructible<glm::i32vec4>::value);
+static_assert(std::is_trivially_default_constructible<glm::i64vec4>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::i8vec4>::value);
+static_assert(std::is_trivially_copy_assignable<glm::i16vec4>::value);
+static_assert(std::is_trivially_copy_assignable<glm::i32vec4>::value);
+static_assert(std::is_trivially_copy_assignable<glm::i64vec4>::value);
+static_assert(std::is_trivially_copyable<glm::i8vec4>::value);
+static_assert(std::is_trivially_copyable<glm::i16vec4>::value);
+static_assert(std::is_trivially_copyable<glm::i32vec4>::value);
+static_assert(std::is_trivially_copyable<glm::i64vec4>::value);
+static_assert(std::is_copy_constructible<glm::i8vec4>::value);
+static_assert(std::is_copy_constructible<glm::i16vec4>::value);
+static_assert(std::is_copy_constructible<glm::i32vec4>::value);
+static_assert(std::is_copy_constructible<glm::i64vec4>::value);
+static_assert(glm::i8vec4::length() == 4);
+static_assert(glm::i16vec4::length() == 4);
+static_assert(glm::i32vec4::length() == 4);
+static_assert(glm::i64vec4::length() == 4);
diff --git a/glm/ext/vector_uint1.hpp b/glm/ext/vector_uint1.hpp
index eb8a70497..513b54109 100644
--- a/glm/ext/vector_uint1.hpp
+++ b/glm/ext/vector_uint1.hpp
@@ -30,3 +30,10 @@ namespace glm
 	/// @}
 }//namespace glm
 
+#if GLM_CONFIG_CTOR_INIT == GLM_DISABLE
+static_assert(std::is_trivially_default_constructible<glm::uvec1>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::uvec1>::value);
+static_assert(std::is_trivially_copyable<glm::uvec1>::value);
+static_assert(std::is_copy_constructible<glm::uvec1>::value);
+static_assert(glm::uvec1::length() == 1);
diff --git a/glm/ext/vector_uint1_sized.hpp b/glm/ext/vector_uint1_sized.hpp
index 2a938bbaf..43c4e3c9d 100644
--- a/glm/ext/vector_uint1_sized.hpp
+++ b/glm/ext/vector_uint1_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::u8vec1>::value);
+static_assert(std::is_trivially_default_constructible<glm::u16vec1>::value);
+static_assert(std::is_trivially_default_constructible<glm::u32vec1>::value);
+static_assert(std::is_trivially_default_constructible<glm::u64vec1>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::u8vec1>::value);
+static_assert(std::is_trivially_copy_assignable<glm::u16vec1>::value);
+static_assert(std::is_trivially_copy_assignable<glm::u32vec1>::value);
+static_assert(std::is_trivially_copy_assignable<glm::u64vec1>::value);
+static_assert(std::is_trivially_copyable<glm::u8vec1>::value);
+static_assert(std::is_trivially_copyable<glm::u16vec1>::value);
+static_assert(std::is_trivially_copyable<glm::u32vec1>::value);
+static_assert(std::is_trivially_copyable<glm::u64vec1>::value);
+static_assert(std::is_copy_constructible<glm::u8vec1>::value);
+static_assert(std::is_copy_constructible<glm::u16vec1>::value);
+static_assert(std::is_copy_constructible<glm::u32vec1>::value);
+static_assert(std::is_copy_constructible<glm::u64vec1>::value);
+static_assert(glm::u8vec1::length() == 1);
+static_assert(glm::u16vec1::length() == 1);
+static_assert(glm::u32vec1::length() == 1);
+static_assert(glm::u64vec1::length() == 1);
diff --git a/glm/ext/vector_uint2.hpp b/glm/ext/vector_uint2.hpp
index 03c00f5ff..8f883940e 100644
--- a/glm/ext/vector_uint2.hpp
+++ b/glm/ext/vector_uint2.hpp
@@ -16,3 +16,11 @@ namespace glm
 
 	/// @}
 }//namespace glm
+
+#if GLM_CONFIG_CTOR_INIT == GLM_DISABLE
+static_assert(std::is_trivially_default_constructible<glm::uvec2>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::uvec2>::value);
+static_assert(std::is_trivially_copyable<glm::uvec2>::value);
+static_assert(std::is_copy_constructible<glm::uvec2>::value);
+static_assert(glm::uvec2::length() == 2);
diff --git a/glm/ext/vector_uint2_sized.hpp b/glm/ext/vector_uint2_sized.hpp
index 620fdc6ec..67632313c 100644
--- a/glm/ext/vector_uint2_sized.hpp
+++ b/glm/ext/vector_uint2_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::u8vec2>::value);
+static_assert(std::is_trivially_default_constructible<glm::u16vec2>::value);
+static_assert(std::is_trivially_default_constructible<glm::u32vec2>::value);
+static_assert(std::is_trivially_default_constructible<glm::u64vec2>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::u8vec2>::value);
+static_assert(std::is_trivially_copy_assignable<glm::u16vec2>::value);
+static_assert(std::is_trivially_copy_assignable<glm::u32vec2>::value);
+static_assert(std::is_trivially_copy_assignable<glm::u64vec2>::value);
+static_assert(std::is_trivially_copyable<glm::u8vec2>::value);
+static_assert(std::is_trivially_copyable<glm::u16vec2>::value);
+static_assert(std::is_trivially_copyable<glm::u32vec2>::value);
+static_assert(std::is_trivially_copyable<glm::u64vec2>::value);
+static_assert(std::is_copy_constructible<glm::u8vec2>::value);
+static_assert(std::is_copy_constructible<glm::u16vec2>::value);
+static_assert(std::is_copy_constructible<glm::u32vec2>::value);
+static_assert(std::is_copy_constructible<glm::u64vec2>::value);
+static_assert(glm::u8vec2::length() == 2);
+static_assert(glm::u16vec2::length() == 2);
+static_assert(glm::u32vec2::length() == 2);
+static_assert(glm::u64vec2::length() == 2);
diff --git a/glm/ext/vector_uint3.hpp b/glm/ext/vector_uint3.hpp
index f5b41c408..27c2c70be 100644
--- a/glm/ext/vector_uint3.hpp
+++ b/glm/ext/vector_uint3.hpp
@@ -16,3 +16,12 @@ namespace glm
 
 	/// @}
 }//namespace glm
+
+#if GLM_CONFIG_CTOR_INIT == GLM_DISABLE
+static_assert(std::is_trivially_default_constructible<glm::uvec3>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::uvec3>::value);
+static_assert(std::is_trivially_copyable<glm::uvec3>::value);
+static_assert(std::is_copy_constructible<glm::uvec3>::value);
+static_assert(glm::uvec3::length() == 3);
+
diff --git a/glm/ext/vector_uint3_sized.hpp b/glm/ext/vector_uint3_sized.hpp
index 6f96b98e2..1310bb2ce 100644
--- a/glm/ext/vector_uint3_sized.hpp
+++ b/glm/ext/vector_uint3_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::u8vec3>::value);
+static_assert(std::is_trivially_default_constructible<glm::u16vec3>::value);
+static_assert(std::is_trivially_default_constructible<glm::u32vec3>::value);
+static_assert(std::is_trivially_default_constructible<glm::u64vec3>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::u8vec3>::value);
+static_assert(std::is_trivially_copy_assignable<glm::u16vec3>::value);
+static_assert(std::is_trivially_copy_assignable<glm::u32vec3>::value);
+static_assert(std::is_trivially_copy_assignable<glm::u64vec3>::value);
+static_assert(std::is_trivially_copyable<glm::u8vec3>::value);
+static_assert(std::is_trivially_copyable<glm::u16vec3>::value);
+static_assert(std::is_trivially_copyable<glm::u32vec3>::value);
+static_assert(std::is_trivially_copyable<glm::u64vec3>::value);
+static_assert(std::is_copy_constructible<glm::u8vec3>::value);
+static_assert(std::is_copy_constructible<glm::u16vec3>::value);
+static_assert(std::is_copy_constructible<glm::u32vec3>::value);
+static_assert(std::is_copy_constructible<glm::u64vec3>::value);
+static_assert(glm::u8vec3::length() == 3);
+static_assert(glm::u16vec3::length() == 3);
+static_assert(glm::u32vec3::length() == 3);
+static_assert(glm::u64vec3::length() == 3);
diff --git a/glm/ext/vector_uint4.hpp b/glm/ext/vector_uint4.hpp
index 32ced58a8..2fd66381a 100644
--- a/glm/ext/vector_uint4.hpp
+++ b/glm/ext/vector_uint4.hpp
@@ -16,3 +16,13 @@ namespace glm
 
 	/// @}
 }//namespace glm
+
+#if GLM_CONFIG_CTOR_INIT == GLM_DISABLE
+static_assert(std::is_trivially_default_constructible<glm::uvec4>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::uvec4>::value);
+static_assert(std::is_trivially_copyable<glm::uvec4>::value);
+static_assert(std::is_copy_constructible<glm::uvec4>::value);
+static_assert(glm::uvec4::length() == 4);
+
+
diff --git a/glm/ext/vector_uint4_sized.hpp b/glm/ext/vector_uint4_sized.hpp
index da992ea2d..d604ff198 100644
--- a/glm/ext/vector_uint4_sized.hpp
+++ b/glm/ext/vector_uint4_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::u8vec4>::value);
+static_assert(std::is_trivially_default_constructible<glm::u16vec4>::value);
+static_assert(std::is_trivially_default_constructible<glm::u32vec4>::value);
+static_assert(std::is_trivially_default_constructible<glm::u64vec4>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::u8vec4>::value);
+static_assert(std::is_trivially_copy_assignable<glm::u16vec4>::value);
+static_assert(std::is_trivially_copy_assignable<glm::u32vec4>::value);
+static_assert(std::is_trivially_copy_assignable<glm::u64vec4>::value);
+static_assert(std::is_trivially_copyable<glm::u8vec4>::value);
+static_assert(std::is_trivially_copyable<glm::u16vec4>::value);
+static_assert(std::is_trivially_copyable<glm::u32vec4>::value);
+static_assert(std::is_trivially_copyable<glm::u64vec4>::value);
+static_assert(std::is_copy_constructible<glm::u8vec4>::value);
+static_assert(std::is_copy_constructible<glm::u16vec4>::value);
+static_assert(std::is_copy_constructible<glm::u32vec4>::value);
+static_assert(std::is_copy_constructible<glm::u64vec4>::value);
+static_assert(glm::u8vec4::length() == 4);
+static_assert(glm::u16vec4::length() == 4);
+static_assert(glm::u32vec4::length() == 4);
+static_assert(glm::u64vec4::length() == 4);
diff --git a/glm/gtx/dual_quaternion.hpp b/glm/gtx/dual_quaternion.hpp
index 718acc58f..fd3e66cd6 100644
--- a/glm/gtx/dual_quaternion.hpp
+++ b/glm/gtx/dual_quaternion.hpp
@@ -269,4 +269,28 @@ namespace glm
 	/// @}
 } //namespace glm
 
+
+#if GLM_CONFIG_CTOR_INIT == GLM_DISABLE
+static_assert(std::is_trivially_default_constructible<glm::dualquat>::value);
+static_assert(std::is_trivially_default_constructible<glm::lowp_dualquat>::value);
+static_assert(std::is_trivially_default_constructible<glm::mediump_dualquat>::value);
+static_assert(std::is_trivially_default_constructible<glm::highp_dualquat>::value);
+#endif
+static_assert(std::is_trivially_copy_assignable<glm::dualquat>::value);
+static_assert(std::is_trivially_copy_assignable<glm::lowp_dualquat>::value);
+static_assert(std::is_trivially_copy_assignable<glm::mediump_dualquat>::value);
+static_assert(std::is_trivially_copy_assignable<glm::highp_dualquat>::value);
+static_assert(std::is_trivially_copyable<glm::dualquat>::value);
+static_assert(std::is_trivially_copyable<glm::lowp_dualquat>::value);
+static_assert(std::is_trivially_copyable<glm::mediump_dualquat>::value);
+static_assert(std::is_trivially_copyable<glm::highp_dualquat>::value);
+static_assert(std::is_copy_constructible<glm::dualquat>::value);
+static_assert(std::is_copy_constructible<glm::lowp_dualquat>::value);
+static_assert(std::is_copy_constructible<glm::mediump_dualquat>::value);
+static_assert(std::is_copy_constructible<glm::highp_dualquat>::value);
+static_assert(glm::dualquat::length() == 2);
+static_assert(glm::lowp_dualquat::length() == 2);
+static_assert(glm::mediump_dualquat::length() == 2);
+static_assert(glm::highp_dualquat::length() == 2);
+
 #include "dual_quaternion.inl"
diff --git a/manual.md b/manual.md
index e2d09ea99..b0af52bc8 100644
--- a/manual.md
+++ b/manual.md
@@ -361,19 +361,18 @@ The following subsections describe each configurations and defines.
 
 ### <a name="section2_6"></a> 2.6. GLM\_FORCE\_CXX**: C++ language detection
 
-GLM will automatically take advantage of compilers’ language extensions when enabled. To increase cross platform compatibility and to avoid compiler extensions, a programmer can define `GLM_FORCE_CXX98` before
-any inclusion of `<glm/glm.hpp>` to restrict the language feature set C++98:
+GLM will automatically take advantage of compilers’ language extensions when enabled. To increase cross platform compatibility and to avoid compiler extensions, a programmer can define `GLM_FORCE_CXX17` before
+any inclusion of `<glm/glm.hpp>` to restrict the language feature set C++17:
 
 ```cpp
-#define GLM_FORCE_CXX98
+#define GLM_FORCE_CXX17
 #include <glm/glm.hpp>
 ```
 
-For C++11, C++14, and C++17 equivalent defines are available:
+For C++17 and C++20 equivalent defines are available:
 
-* `GLM_FORCE_CXX11`
-* `GLM_FORCE_CXX14`
 * `GLM_FORCE_CXX17`
+* `GLM_FORCE_CXX20`
 
 ```cpp
 #define GLM_FORCE_CXX11
diff --git a/test/core/CMakeLists.txt b/test/core/CMakeLists.txt
index 5c0ab5b98..5e83fca22 100644
--- a/test/core/CMakeLists.txt
+++ b/test/core/CMakeLists.txt
@@ -44,8 +44,8 @@ glmCreateTestGTC(core_func_trigonometric)
 glmCreateTestGTC(core_func_vector_relational)
 glmCreateTestGTC(core_func_swizzle)
 glmCreateTestGTC(core_setup_force_cxx_unknown)
-glmCreateTestGTC(core_setup_force_cxx98)
-glmCreateTestGTC(core_setup_force_cxx03)
+glmCreateTestGTC(core_setup_force_cxx17)
+glmCreateTestGTC(core_setup_force_cxx20)
 glmCreateTestGTC(core_setup_force_size_t_length)
 glmCreateTestGTC(core_setup_message)
 glmCreateTestGTC(core_setup_platform_unknown)
diff --git a/test/core/core_force_intrinsics.cpp b/test/core/core_force_intrinsics.cpp
index db029765c..a5e4aef5e 100644
--- a/test/core/core_force_intrinsics.cpp
+++ b/test/core/core_force_intrinsics.cpp
@@ -32,7 +32,6 @@ static int test_vec4_ctor()
 		Error += std::is_copy_constructible<glm::vec4>::value ? 0 : 1;
 	}
 
-#if GLM_HAS_INITIALIZER_LISTS
 	{
 		glm::vec4 a{ 0, 1, 2, 3 };
 		Error += glm::all(glm::equal(a, glm::vec4(0, 1, 2, 3), glm::epsilon<float>())) ? 0 : 1;
@@ -58,7 +57,6 @@ static int test_vec4_ctor()
 		Error += glm::all(glm::equal(v[1], glm::dvec4(4, 5, 6, 7), glm::epsilon<double>())) ? 0 : 1;
 		Error += glm::all(glm::equal(v[2], glm::dvec4(8, 9, 0, 1), glm::epsilon<double>())) ? 0 : 1;
 	}
-#endif
 
 #	if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR
 	{
diff --git a/test/core/core_force_pure.cpp b/test/core/core_force_pure.cpp
index d5296f5fc..db887356d 100644
--- a/test/core/core_force_pure.cpp
+++ b/test/core/core_force_pure.cpp
@@ -33,7 +33,6 @@ static int test_vec4_ctor()
 		Error += std::is_copy_constructible<glm::vec4>::value ? 0 : 1;
 	}
 
-#if GLM_HAS_INITIALIZER_LISTS
 	{
 		glm::vec4 a{ 0, 1, 2, 3 };
 		Error += glm::all(glm::equal(a, glm::vec4(0, 1, 2, 3), glm::epsilon<float>())) ? 0 : 1;
@@ -59,7 +58,6 @@ static int test_vec4_ctor()
 		Error += glm::all(glm::equal(v[1], glm::dvec4(4, 5, 6, 7), glm::epsilon<double>())) ? 0 : 1;
 		Error += glm::all(glm::equal(v[2], glm::dvec4(8, 9, 0, 1), glm::epsilon<double>())) ? 0 : 1;
 	}
-#endif
 
 #	if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR
 	{
diff --git a/test/core/core_setup_force_cxx03.cpp b/test/core/core_setup_force_cxx17.cpp
similarity index 53%
rename from test/core/core_setup_force_cxx03.cpp
rename to test/core/core_setup_force_cxx17.cpp
index ac8c04c08..72983f0b7 100644
--- a/test/core/core_setup_force_cxx03.cpp
+++ b/test/core/core_setup_force_cxx17.cpp
@@ -7,20 +7,8 @@
 #ifdef GLM_FORCE_CXX17
 #undef GLM_FORCE_CXX17
 #endif
-#ifdef GLM_FORCE_CXX14
-#undef GLM_FORCE_CXX14
-#endif
-#ifdef GLM_FORCE_CXX11
-#undef GLM_FORCE_CXX11
-#endif
-#ifdef GLM_FORCE_CXX03
-#undef GLM_FORCE_CXX03
-#endif
-#ifdef GLM_FORCE_CXX98
-#undef GLM_FORCE_CXX98
-#endif
 
-#define GLM_FORCE_CXX03
+#define GLM_FORCE_CXX17
 
 #include <glm/glm.hpp>
 #include <glm/ext.hpp>
diff --git a/test/core/core_setup_force_cxx98.cpp b/test/core/core_setup_force_cxx20.cpp
similarity index 53%
rename from test/core/core_setup_force_cxx98.cpp
rename to test/core/core_setup_force_cxx20.cpp
index 6090b79c9..d465e0267 100644
--- a/test/core/core_setup_force_cxx98.cpp
+++ b/test/core/core_setup_force_cxx20.cpp
@@ -7,20 +7,8 @@
 #ifdef GLM_FORCE_CXX17
 #undef GLM_FORCE_CXX17
 #endif
-#ifdef GLM_FORCE_CXX14
-#undef GLM_FORCE_CXX14
-#endif
-#ifdef GLM_FORCE_CXX11
-#undef GLM_FORCE_CXX11
-#endif
-#ifdef GLM_FORCE_CXX03
-#undef GLM_FORCE_CXX03
-#endif
-#ifdef GLM_FORCE_CXX98
-#undef GLM_FORCE_CXX98
-#endif
 
-#define GLM_FORCE_CXX98
+#define GLM_FORCE_CXX20
 
 #include <glm/glm.hpp>
 #include <glm/ext.hpp>
diff --git a/test/core/core_type_mat2x2.cpp b/test/core/core_type_mat2x2.cpp
index cd4c37343..04c50edf4 100644
--- a/test/core/core_type_mat2x2.cpp
+++ b/test/core/core_type_mat2x2.cpp
@@ -86,7 +86,6 @@ static int test_ctr()
 		Error += glm::all(glm::equal(A, C, glm::epsilon<float>())) ? 0 : 1;
 	}
 
-#if GLM_HAS_INITIALIZER_LISTS
 	glm::mat2x2 m0(
 		glm::vec2(0, 1),
 		glm::vec2(2, 3));
@@ -116,8 +115,6 @@ static int test_ctr()
 		}
 	};
 
-#endif//GLM_HAS_INITIALIZER_LISTS
-
 	return Error;
 }
 
diff --git a/test/core/core_type_mat2x3.cpp b/test/core/core_type_mat2x3.cpp
index b763534fe..e9a0a3f87 100644
--- a/test/core/core_type_mat2x3.cpp
+++ b/test/core/core_type_mat2x3.cpp
@@ -52,7 +52,6 @@ static int test_ctr()
 {
 	int Error(0);
 
-#if GLM_HAS_INITIALIZER_LISTS
 	glm::mat2x3 m0(
 		glm::vec3(0, 1, 2),
 		glm::vec3(3, 4, 5));
@@ -82,8 +81,6 @@ static int test_ctr()
 		}
 	};
 	
-#endif//GLM_HAS_INITIALIZER_LISTS
-	
 	return Error;
 }
 
diff --git a/test/core/core_type_mat2x4.cpp b/test/core/core_type_mat2x4.cpp
index 4d9b963f2..b2fc4bbd8 100644
--- a/test/core/core_type_mat2x4.cpp
+++ b/test/core/core_type_mat2x4.cpp
@@ -51,9 +51,8 @@ static int test_operators()
 
 static int test_ctr()
 {
-	int Error(0);
+	int Error = 0;
 
-#if(GLM_HAS_INITIALIZER_LISTS)
 	glm::mat2x4 m0(
 		glm::vec4(0, 1, 2, 3),
 		glm::vec4(4, 5, 6, 7));
@@ -82,8 +81,6 @@ static int test_ctr()
 			{ 4, 5, 6, 7}
 		}
 	};
-	
-#endif//GLM_HAS_INITIALIZER_LISTS
 
 	return Error;
 }
diff --git a/test/core/core_type_mat3x2.cpp b/test/core/core_type_mat3x2.cpp
index bb1fd1d76..4da1946f7 100644
--- a/test/core/core_type_mat3x2.cpp
+++ b/test/core/core_type_mat3x2.cpp
@@ -50,9 +50,8 @@ static int test_operators()
 
 static int test_ctr()
 {
-	int Error(0);
+	int Error = 0;
 
-#if(GLM_HAS_INITIALIZER_LISTS)
 	glm::mat3x2 m0(
 		glm::vec2(0, 1),
 		glm::vec2(2, 3),
@@ -85,9 +84,7 @@ static int test_ctr()
 			{ 4, 5}
 		}
 	};
-	
-#endif//GLM_HAS_INITIALIZER_LISTS
-	
+
 	return Error;
 }
 
diff --git a/test/core/core_type_mat3x3.cpp b/test/core/core_type_mat3x3.cpp
index cea7864a8..270d6e72a 100644
--- a/test/core/core_type_mat3x3.cpp
+++ b/test/core/core_type_mat3x3.cpp
@@ -96,9 +96,8 @@ static int test_inverse()
 
 static int test_ctr()
 {
-	int Error(0);
+	int Error = 0;
 
-#if(GLM_HAS_INITIALIZER_LISTS)
 	glm::mat3x3 m0(
 		glm::vec3(0, 1, 2),
 		glm::vec3(3, 4, 5),
@@ -131,9 +130,7 @@ static int test_ctr()
 			{ 6, 7, 8}
 		}
 	};
-	
-#endif//GLM_HAS_INITIALIZER_LISTS
-	
+
 	return Error;
 }
 
diff --git a/test/core/core_type_mat3x4.cpp b/test/core/core_type_mat3x4.cpp
index 02735db66..ce2b4ff30 100644
--- a/test/core/core_type_mat3x4.cpp
+++ b/test/core/core_type_mat3x4.cpp
@@ -51,9 +51,8 @@ static int test_operators()
 
 static int test_ctr()
 {
-	int Error(0);
+	int Error = 0;
 
-#if(GLM_HAS_INITIALIZER_LISTS)
 	glm::mat3x4 m0(
 		glm::vec4(0, 1, 2, 3),
 		glm::vec4(4, 5, 6, 7),
@@ -86,9 +85,7 @@ static int test_ctr()
 			{ 8, 9, 10, 11}
 		}
 	};
-	
-#endif//GLM_HAS_INITIALIZER_LISTS
-	
+
 	return Error;
 }
 
diff --git a/test/core/core_type_mat4x2.cpp b/test/core/core_type_mat4x2.cpp
index ab4d299fe..7c3240d20 100644
--- a/test/core/core_type_mat4x2.cpp
+++ b/test/core/core_type_mat4x2.cpp
@@ -50,9 +50,8 @@ static int test_operators()
 
 static int test_ctr()
 {
-	int Error(0);
+	int Error = 0;
 
-#if(GLM_HAS_INITIALIZER_LISTS)
 	glm::mat4x2 m0(
 		glm::vec2(0, 1), 
 		glm::vec2(2, 3),
@@ -90,8 +89,6 @@ static int test_ctr()
 		}
 	};
 
-#endif//GLM_HAS_INITIALIZER_LISTS
-
 	return Error;
 }
 
diff --git a/test/core/core_type_mat4x3.cpp b/test/core/core_type_mat4x3.cpp
index 9a81800d5..a199ac1bb 100644
--- a/test/core/core_type_mat4x3.cpp
+++ b/test/core/core_type_mat4x3.cpp
@@ -50,9 +50,8 @@ static int test_operators()
 
 static int test_ctr()
 {
-	int Error(0);
+	int Error = 0;
 
-#if(GLM_HAS_INITIALIZER_LISTS)
 	glm::mat4x3 m0(
 		glm::vec3(0, 1, 2), 
 		glm::vec3(3, 4, 5),
@@ -90,8 +89,6 @@ static int test_ctr()
 		}
 	};
 
-#endif//GLM_HAS_INITIALIZER_LISTS
-
 	return Error;
 }
 
diff --git a/test/core/core_type_mat4x4.cpp b/test/core/core_type_mat4x4.cpp
index 0296bc02c..4304e87b9 100644
--- a/test/core/core_type_mat4x4.cpp
+++ b/test/core/core_type_mat4x4.cpp
@@ -71,13 +71,13 @@ static int test_ctr()
 {
 	int Error = 0;
 
-	//Error += std::is_trivially_default_constructible<glm::mat4>::value ? 0 : 1;
-	//Error += std::is_trivially_copy_assignable<glm::mat4>::value ? 0 : 1;
-	Error += std::is_trivially_copyable<glm::mat4>::value ? 0 : 1;
-	//Error += std::is_copy_constructible<glm::mat4>::value ? 0 : 1;
+	static_assert(std::is_trivially_default_constructible<glm::mat4>::value);
+	static_assert(std::is_trivially_copy_assignable<glm::mat4>::value);
+	static_assert(std::is_trivially_copyable<glm::mat4>::value);
+	static_assert(std::is_copy_constructible<glm::mat4>::value);
+
 	//Error += std::has_trivial_copy_constructor<glm::mat4>::value ? 0 : 1;
 
-#if GLM_HAS_INITIALIZER_LISTS
 	glm::mat4 const m0(
 		glm::vec4(0, 1, 2, 3),
 		glm::vec4(4, 5, 6, 7),
@@ -133,8 +133,6 @@ static int test_ctr()
 			{ 12, 13, 14, 15 }
 		}};
 
-#endif//GLM_HAS_INITIALIZER_LISTS
-
 	return Error;
 }
 
diff --git a/test/core/core_type_vec1.cpp b/test/core/core_type_vec1.cpp
index e83b7f8bc..baee13b39 100644
--- a/test/core/core_type_vec1.cpp
+++ b/test/core/core_type_vec1.cpp
@@ -51,8 +51,8 @@ static int test_ctor()
 	int Error = 0;
 
 	{
-	//	Error += std::is_trivially_default_constructible<glm::vec1>::value ? 0 : 1;
-	//	Error += std::is_trivially_copy_assignable<glm::vec1>::value ? 0 : 1;
+		Error += std::is_trivially_default_constructible<glm::vec1>::value ? 0 : 1;
+		Error += std::is_trivially_copy_assignable<glm::vec1>::value ? 0 : 1;
 		Error += std::is_trivially_copyable<glm::vec1>::value ? 0 : 1;
 		Error += std::is_trivially_copyable<glm::dvec1>::value ? 0 : 1;
 		Error += std::is_trivially_copyable<glm::ivec1>::value ? 0 : 1;
@@ -60,9 +60,7 @@ static int test_ctor()
 
 		Error += std::is_copy_constructible<glm::vec1>::value ? 0 : 1;
 	}
-	
-/*
-#if GLM_HAS_INITIALIZER_LISTS
+/*	
 	{
 		glm::vec1 a{ 0 };
 		std::vector<glm::vec1> v = {
@@ -78,9 +76,7 @@ static int test_ctor()
 			{4.0},
 			{8.0}};
 	}
-#endif
 */
-
 	{
 		glm::vec1 A = glm::vec2(2.0f);
 		Error += glm::all(glm::equal(A, glm::vec1(2.0f), glm::epsilon<float>())) ? 0 : 1;
diff --git a/test/core/core_type_vec2.cpp b/test/core/core_type_vec2.cpp
index b33ca0722..16e0f6405 100644
--- a/test/core/core_type_vec2.cpp
+++ b/test/core/core_type_vec2.cpp
@@ -238,7 +238,6 @@ static int test_ctor()
 		Error += std::is_copy_constructible<glm::vec2>::value ? 0 : 1;
 	}
 
-#if GLM_HAS_INITIALIZER_LISTS
 	{
 		glm::vec2 a{ 0, 1 };
 		std::vector<glm::vec2> v = {
@@ -254,7 +253,6 @@ static int test_ctor()
 			{4, 5},
 			{8, 9}};
 	}
-#endif
 
 	{
 		glm::vec2 A = glm::vec2(2.0f);
diff --git a/test/core/core_type_vec3.cpp b/test/core/core_type_vec3.cpp
index ab3979a71..fa6c6eca4 100644
--- a/test/core/core_type_vec3.cpp
+++ b/test/core/core_type_vec3.cpp
@@ -28,8 +28,8 @@ static int test_vec3_ctor()
 	int Error = 0;
 
 	{
-	//	Error += std::is_trivially_default_constructible<glm::vec3>::value ? 0 : 1;
-	//	Error += std::is_trivially_copy_assignable<glm::vec3>::value ? 0 : 1;
+		Error += std::is_trivially_default_constructible<glm::vec3>::value ? 0 : 1;
+		Error += std::is_trivially_copy_assignable<glm::vec3>::value ? 0 : 1;
 		Error += std::is_trivially_copyable<glm::vec3>::value ? 0 : 1;
 		Error += std::is_trivially_copyable<glm::dvec3>::value ? 0 : 1;
 		Error += std::is_trivially_copyable<glm::ivec3>::value ? 0 : 1;
@@ -38,7 +38,6 @@ static int test_vec3_ctor()
 		Error += std::is_copy_constructible<glm::vec3>::value ? 0 : 1;
 	}
 	
-#	if GLM_HAS_INITIALIZER_LISTS
 	{
 		glm::vec3 a{ 0, 1, 2 };
 		std::vector<glm::vec3> v = {
@@ -54,7 +53,6 @@ static int test_vec3_ctor()
 			{4, 5, 6},
 			{8, 9, 0}};
 	}
-#	endif
 
 	{
 		glm::ivec3 A(1);
diff --git a/test/core/core_type_vec4.cpp b/test/core/core_type_vec4.cpp
index 22eaab5ad..a583b2ba3 100644
--- a/test/core/core_type_vec4.cpp
+++ b/test/core/core_type_vec4.cpp
@@ -55,19 +55,7 @@ static int test_vec4_ctor()
 		glm::ivec4 B(A);
 		Error += glm::all(glm::equal(A, B)) ? 0 : 1;
 	}
-
-	{
-	//	Error += std::is_trivially_default_constructible<glm::vec4>::value ? 0 : 1;
-	//	Error += std::is_trivially_copy_assignable<glm::vec4>::value ? 0 : 1;
-		Error += std::is_trivially_copyable<glm::vec4>::value ? 0 : 1;
-		Error += std::is_trivially_copyable<glm::dvec4>::value ? 0 : 1;
-		Error += std::is_trivially_copyable<glm::ivec4>::value ? 0 : 1;
-		Error += std::is_trivially_copyable<glm::uvec4>::value ? 0 : 1;
-
-		Error += std::is_copy_constructible<glm::vec4>::value ? 0 : 1;
-	}
 	
-#if GLM_HAS_INITIALIZER_LISTS
 	{
 		glm::vec4 a{ 0, 1, 2, 3 };
 		std::vector<glm::vec4> v = {
@@ -83,7 +71,6 @@ static int test_vec4_ctor()
 			{4, 5, 6, 7},
 			{8, 9, 0, 1}};
 	}
-#endif
 
 	{
 		glm::ivec4 A(1);
diff --git a/test/ext/ext_quaternion_type.cpp b/test/ext/ext_quaternion_type.cpp
index 43169423e..62db7795d 100644
--- a/test/ext/ext_quaternion_type.cpp
+++ b/test/ext/ext_quaternion_type.cpp
@@ -9,13 +9,13 @@
 
 static int test_ctr()
 {
-	int Error(0);
+	int Error = 0;
 
 	{
-	//	Error += std::is_trivially_default_constructible<glm::quat>::value ? 0 : 1;
-	//	Error += std::is_trivially_default_constructible<glm::dquat>::value ? 0 : 1;
-	//	Error += std::is_trivially_copy_assignable<glm::quat>::value ? 0 : 1;
-	//	Error += std::is_trivially_copy_assignable<glm::dquat>::value ? 0 : 1;
+		Error += std::is_trivially_default_constructible<glm::quat>::value ? 0 : 1;
+		Error += std::is_trivially_default_constructible<glm::dquat>::value ? 0 : 1;
+		Error += std::is_trivially_copy_assignable<glm::quat>::value ? 0 : 1;
+		Error += std::is_trivially_copy_assignable<glm::dquat>::value ? 0 : 1;
 		Error += std::is_trivially_copyable<glm::quat>::value ? 0 : 1;
 		Error += std::is_trivially_copyable<glm::dquat>::value ? 0 : 1;
 
@@ -23,7 +23,6 @@ static int test_ctr()
 		Error += std::is_copy_constructible<glm::dquat>::value ? 0 : 1;
 	}
 	
-#	if GLM_HAS_INITIALIZER_LISTS
 	{
 		glm::quat A{0, 1, 2, 3};
 
@@ -31,7 +30,6 @@ static int test_ctr()
 			A,
 			{0, 1, 2, 3}};
 	}
-#	endif//GLM_HAS_INITIALIZER_LISTS
 
 	return Error;
 }