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

Removed initializer list C++98 workarounds

Browse Source
This commit is contained in:
christophe
2025-10-19 21:26:37 +02:00
committed by Christophe
parent c33f2fa56a
commit 24a14718fe
175 changed files with 2498 additions and 2347 deletions
Download Patch File Download Diff File Expand all files Collapse all files

30
glm/detail/qualifier.hpp
View File

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

155
glm/detail/setup.hpp
View File

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

23
glm/detail/type_mat2x2.hpp
View File

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

178
glm/detail/type_mat2x2.inl
View File

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

5
glm/detail/type_mat2x3.hpp
View File

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

176
glm/detail/type_mat2x3.inl
View File

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

23
glm/detail/type_mat2x4.hpp
View File

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

182
glm/detail/type_mat2x4.inl
View File

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

5
glm/detail/type_mat3x2.hpp
View File

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

194
glm/detail/type_mat3x2.inl
View File

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

27
glm/detail/type_mat3x3.hpp
View File

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

194
glm/detail/type_mat3x3.inl
View File

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

23
glm/detail/type_mat3x4.hpp
View File

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

206
glm/detail/type_mat3x4.inl
View File

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

23
glm/detail/type_mat4x2.hpp
View File

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

210
glm/detail/type_mat4x2.inl
View File

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

19
glm/detail/type_mat4x3.hpp
View File

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

210
glm/detail/type_mat4x3.inl
View File

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

26
glm/detail/type_mat4x4.hpp
View File

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

212
glm/detail/type_mat4x4.inl
View File

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

6
glm/detail/type_quat.hpp
View File

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

31
glm/detail/type_quat.inl
View File

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

6
glm/detail/type_vec1.hpp
View File

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

22
glm/detail/type_vec1.inl
View File

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

6
glm/detail/type_vec2.hpp
View File

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

23
glm/detail/type_vec2.inl
View File

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

6
glm/detail/type_vec3.hpp
View File

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

24
glm/detail/type_vec3.inl
View File

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

6
glm/detail/type_vec4.hpp
View File

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

25
glm/detail/type_vec4.inl
View File

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

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

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