Scarfski/glm
1
0
Fork 0
mirror of https://github.com/g-truc/glm.git synced 2026-09-08 03:28:08 +00:00
Code Issues Packages Projects Releases Wiki Activity

Add static_assert to basic types

Browse Source
This commit is contained in:
christophe
2025-10-20 00:11:56 +02:00
parent 761885683c
commit 8409c195cd
130 changed files with 1910 additions and 134 deletions
Download Patch File Download Diff File Expand all files Collapse all files

24
glm/detail/setup.hpp
View File

@@ -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)

14
glm/ext/matrix_double2x2.hpp
View File

@@ -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);

33
glm/ext/matrix_double2x2_precision.hpp
View File

@@ -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);

9
glm/ext/matrix_double2x3.hpp
View File

@@ -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);

19
glm/ext/matrix_double2x3_precision.hpp
View File

@@ -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);

8
glm/ext/matrix_double2x4.hpp
View File

@@ -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);

18
glm/ext/matrix_double2x4_precision.hpp
View File

@@ -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);

8
glm/ext/matrix_double3x2.hpp
View File

@@ -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);

18
glm/ext/matrix_double3x2_precision.hpp
View File

@@ -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);

14
glm/ext/matrix_double3x3.hpp
View File

@@ -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);

33
glm/ext/matrix_double3x3_precision.hpp
View File

@@ -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);

8
glm/ext/matrix_double3x4.hpp
View File

@@ -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);

19
glm/ext/matrix_double3x4_precision.hpp
View File

@@ -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);

8
glm/ext/matrix_double4x2.hpp
View File

@@ -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);

18
glm/ext/matrix_double4x2_precision.hpp
View File

@@ -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);

8
glm/ext/matrix_double4x3.hpp
View File

@@ -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);

18
glm/ext/matrix_double4x3_precision.hpp
View File

@@ -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);

14
glm/ext/matrix_double4x4.hpp
View File

@@ -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);

33
glm/ext/matrix_double4x4_precision.hpp
View File

@@ -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);

13
glm/ext/matrix_float2x2.hpp
View File

@@ -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);

34
glm/ext/matrix_float2x2_precision.hpp
View File

@@ -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);

9
glm/ext/matrix_float2x3.hpp
View File

@@ -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);

20
glm/ext/matrix_float2x3_precision.hpp
View File

@@ -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);

10
glm/ext/matrix_float2x4.hpp
View File

@@ -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);

18
glm/ext/matrix_float2x4_precision.hpp
View File

@@ -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);

8
glm/ext/matrix_float3x2.hpp
View File

@@ -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);

19
glm/ext/matrix_float3x2_precision.hpp
View File

@@ -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);

13
glm/ext/matrix_float3x3.hpp
View File

@@ -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);

34
glm/ext/matrix_float3x3_precision.hpp
View File

@@ -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);

8
glm/ext/matrix_float3x4.hpp
View File

@@ -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);

18
glm/ext/matrix_float3x4_precision.hpp
View File

@@ -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);

8
glm/ext/matrix_float4x2.hpp
View File

@@ -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);

18
glm/ext/matrix_float4x2_precision.hpp
View File

@@ -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);

8
glm/ext/matrix_float4x3.hpp
View File

@@ -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);

18
glm/ext/matrix_float4x3_precision.hpp
View File

@@ -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);

13
glm/ext/matrix_float4x4.hpp
View File

@@ -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);

33
glm/ext/matrix_float4x4_precision.hpp
View File

@@ -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);

14
glm/ext/matrix_int2x2.hpp
View File

@@ -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);

43
glm/ext/matrix_int2x2_sized.hpp
View File

@@ -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);

8
glm/ext/matrix_int2x3.hpp
View File

@@ -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);

23
glm/ext/matrix_int2x3_sized.hpp
View File

@@ -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);

9
glm/ext/matrix_int2x4.hpp
View File

@@ -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);

23
glm/ext/matrix_int2x4_sized.hpp
View File

@@ -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);

8
glm/ext/matrix_int3x2.hpp
View File

@@ -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);

23
glm/ext/matrix_int3x2_sized.hpp
View File

@@ -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);

14
glm/ext/matrix_int3x3.hpp
View File

@@ -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);

43
glm/ext/matrix_int3x3_sized.hpp
View File

@@ -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);

8
glm/ext/matrix_int3x4.hpp
View File

@@ -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);

23
glm/ext/matrix_int3x4_sized.hpp
View File

@@ -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);

8
glm/ext/matrix_int4x2.hpp
View File

@@ -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);

23
glm/ext/matrix_int4x2_sized.hpp
View File

@@ -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);

8
glm/ext/matrix_int4x3.hpp
View File

@@ -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);

24
glm/ext/matrix_int4x3_sized.hpp
View File

@@ -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);

13
glm/ext/matrix_int4x4.hpp
View File

@@ -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);

45
glm/ext/matrix_int4x4_sized.hpp
View File

@@ -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);

13
glm/ext/matrix_uint2x2.hpp
View File

@@ -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);

43
glm/ext/matrix_uint2x2_sized.hpp
View File

@@ -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);

9
glm/ext/matrix_uint2x3.hpp
View File

@@ -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);

24
glm/ext/matrix_uint2x3_sized.hpp
View File

@@ -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);

8
glm/ext/matrix_uint2x4.hpp
View File

@@ -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);

23
glm/ext/matrix_uint2x4_sized.hpp
View File

@@ -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);

9
glm/ext/matrix_uint3x2.hpp
View File

@@ -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);

23
glm/ext/matrix_uint3x2_sized.hpp
View File

@@ -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);

13
glm/ext/matrix_uint3x3.hpp
View File

@@ -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);

43
glm/ext/matrix_uint3x3_sized.hpp
View File

@@ -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);

8
glm/ext/matrix_uint3x4.hpp
View File

@@ -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);

23
glm/ext/matrix_uint3x4_sized.hpp
View File

@@ -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);

9
glm/ext/matrix_uint4x2.hpp
View File

@@ -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);

23
glm/ext/matrix_uint4x2_sized.hpp
View File

@@ -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);

9
glm/ext/matrix_uint4x3.hpp
View File

@@ -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);

24
glm/ext/matrix_uint4x3_sized.hpp
View File

@@ -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);

14
glm/ext/matrix_uint4x4.hpp
View File

@@ -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);

44
glm/ext/matrix_uint4x4_sized.hpp
View File

@@ -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);

7
glm/ext/quaternion_double.hpp
View File

@@ -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);

17
glm/ext/quaternion_double_precision.hpp
View File

@@ -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);

7
glm/ext/quaternion_float.hpp
View File

@@ -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);

17
glm/ext/quaternion_float_precision.hpp
View File

@@ -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);

8
glm/ext/vector_double1.hpp
View File

@@ -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);

20
glm/ext/vector_double1_precision.hpp
View File

@@ -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));

8
glm/ext/vector_double2.hpp
View File

@@ -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);

21
glm/ext/vector_double2_precision.hpp
View File

@@ -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));

8
glm/ext/vector_double3.hpp
View File

@@ -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);

20
glm/ext/vector_double3_precision.hpp
View File

@@ -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));

8
glm/ext/vector_double4.hpp
View File

@@ -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);

20
glm/ext/vector_double4_precision.hpp
View File

@@ -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));

8
glm/ext/vector_float1.hpp
View File

@@ -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);

20
glm/ext/vector_float1_precision.hpp
View File

@@ -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));

8
glm/ext/vector_float2.hpp
View File

@@ -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);

21
glm/ext/vector_float2_precision.hpp
View File

@@ -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));

8
glm/ext/vector_float3.hpp
View File

@@ -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);

21
glm/ext/vector_float3_precision.hpp
View File

@@ -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));

9
glm/ext/vector_float4.hpp
View File

@@ -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);

20
glm/ext/vector_float4_precision.hpp
View File

@@ -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));

7
glm/ext/vector_int1.hpp
View File

@@ -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);

24
glm/ext/vector_int1_sized.hpp
View File

@@ -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);

9
glm/ext/vector_int2.hpp
View File

@@ -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);

23
glm/ext/vector_int2_sized.hpp
View File

@@ -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);

9
glm/ext/vector_int3.hpp
View File

@@ -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);

23
glm/ext/vector_int3_sized.hpp
View File

@@ -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);

8
glm/ext/vector_int4.hpp
View File

@@ -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);

Some files were not shown because too many files have changed in this diff Show More