- Added constexpr for *vec*, *mat*, *quat* and *dual_quat* types #493

glm/detail/type_mat2x2.hpp

@@ -55,45 +55,45 @@ namespace glm
 	public:
 		// -- Constructors --
 
-		GLM_FUNC_DECL tmat2x2() GLM_DEFAULT_CTOR;
-		GLM_FUNC_DECL tmat2x2(tmat2x2<T, P> const & m) GLM_DEFAULT;
+		GLM_FUNC_DECL GLM_CONSTEXPR tmat2x2() GLM_DEFAULT_CTOR;
+		GLM_FUNC_DECL GLM_CONSTEXPR tmat2x2(tmat2x2<T, P> const & m) GLM_DEFAULT;
 		template <precision Q>
-		GLM_FUNC_DECL tmat2x2(tmat2x2<T, Q> const & m);
+		GLM_FUNC_DECL GLM_CONSTEXPR tmat2x2(tmat2x2<T, Q> const & m);
 
-		GLM_FUNC_DECL explicit tmat2x2(ctor);
-		GLM_FUNC_DECL explicit tmat2x2(T scalar);
-		GLM_FUNC_DECL tmat2x2(
+		GLM_FUNC_DECL GLM_CONSTEXPR explicit tmat2x2(ctor);
+		GLM_FUNC_DECL GLM_CONSTEXPR explicit tmat2x2(T scalar);
+		GLM_FUNC_DECL GLM_CONSTEXPR tmat2x2(
 			T const & x1, T const & y1,
 			T const & x2, T const & y2);
-		GLM_FUNC_DECL tmat2x2(
+		GLM_FUNC_DECL GLM_CONSTEXPR tmat2x2(
 			col_type const & v1,
 			col_type const & v2);
 
 		// -- Conversions --
 
 		template <typename U, typename V, typename M, typename N>
-		GLM_FUNC_DECL tmat2x2(
+		GLM_FUNC_DECL GLM_CONSTEXPR tmat2x2(
 			U const & x1, V const & y1,
 			M const & x2, N const & y2);
 
 		template <typename U, typename V>
-		GLM_FUNC_DECL tmat2x2(
+		GLM_FUNC_DECL GLM_CONSTEXPR tmat2x2(
 			tvec2<U, P> const & v1,
 			tvec2<V, P> const & v2);
 
 		// -- Matrix conversions --
 
 		template <typename U, precision Q>
-		GLM_FUNC_DECL GLM_EXPLICIT tmat2x2(tmat2x2<U, Q> const & m);
-
-		GLM_FUNC_DECL GLM_EXPLICIT tmat2x2(tmat3x3<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat2x2(tmat4x4<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat2x2(tmat2x3<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat2x2(tmat3x2<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat2x2(tmat2x4<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat2x2(tmat4x2<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat2x2(tmat3x4<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat2x2(tmat4x3<T, P> const & x);
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tmat2x2(tmat2x2<U, Q> const & m);
+
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tmat2x2(tmat3x3<T, P> const & x);
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tmat2x2(tmat4x4<T, P> const & x);
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tmat2x2(tmat2x3<T, P> const & x);
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tmat2x2(tmat3x2<T, P> const & x);
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tmat2x2(tmat2x4<T, P> const & x);
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tmat2x2(tmat4x2<T, P> const & x);
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tmat2x2(tmat3x4<T, P> const & x);
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tmat2x2(tmat4x3<T, P> const & x);
 
 		// -- Accesses --
 

glm/detail/type_mat2x2.inl

@@ -54,7 +54,7 @@ namespace detail
 
 #	if !GLM_HAS_DEFAULTED_FUNCTIONS || !defined(GLM_FORCE_NO_CTOR_INIT)
 		template <typename T, precision P>
-		GLM_FUNC_QUALIFIER tmat2x2<T, P>::tmat2x2()
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat2x2<T, P>::tmat2x2()
 		{
 #			ifndef GLM_FORCE_NO_CTOR_INIT 
 				this->value[0] = col_type(1, 0);
@@ -65,7 +65,7 @@ namespace detail
 
 #	if !GLM_HAS_DEFAULTED_FUNCTIONS
 		template <typename T, precision P>
-		GLM_FUNC_QUALIFIER tmat2x2<T, P>::tmat2x2(tmat2x2<T, P> const & m)
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat2x2<T, P>::tmat2x2(tmat2x2<T, P> const & m)
 		{
 			this->value[0] = m.value[0];
 			this->value[1] = m.value[1];
@@ -74,25 +74,25 @@ namespace detail
 
 	template <typename T, precision P>
 	template <precision Q>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P>::tmat2x2(tmat2x2<T, Q> const & m)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat2x2<T, P>::tmat2x2(tmat2x2<T, Q> const & m)
 	{
 		this->value[0] = m.value[0];
 		this->value[1] = m.value[1];
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P>::tmat2x2(ctor)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat2x2<T, P>::tmat2x2(ctor)
 	{}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P>::tmat2x2(T scalar)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat2x2<T, P>::tmat2x2(T scalar)
 	{
 		this->value[0] = col_type(scalar, 0);
 		this->value[1] = col_type(0, scalar);
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P>::tmat2x2
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat2x2<T, P>::tmat2x2
 	(
 		T const & x0, T const & y0,
 		T const & x1, T const & y1
@@ -103,7 +103,7 @@ namespace detail
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P>::tmat2x2(col_type const & v0, col_type const & v1)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat2x2<T, P>::tmat2x2(col_type const & v0, col_type const & v1)
 	{
 		this->value[0] = v0;
 		this->value[1] = v1;
@@ -113,7 +113,7 @@ namespace detail
 
 	template <typename T, precision P>
 	template <typename X1, typename Y1, typename X2, typename Y2>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P>::tmat2x2
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat2x2<T, P>::tmat2x2
 	(
 		X1 const & x1, Y1 const & y1,
 		X2 const & x2, Y2 const & y2
@@ -125,7 +125,7 @@ namespace detail
 	
 	template <typename T, precision P>
 	template <typename V1, typename V2>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P>::tmat2x2(tvec2<V1, P> const & v1, tvec2<V2, P> const & v2)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat2x2<T, P>::tmat2x2(tvec2<V1, P> const & v1, tvec2<V2, P> const & v2)
 	{
 		this->value[0] = col_type(v1);
 		this->value[1] = col_type(v2);
@@ -135,63 +135,63 @@ namespace detail
 
 	template <typename T, precision P>
 	template <typename U, precision Q>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P>::tmat2x2(tmat2x2<U, Q> const & m)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat2x2<T, P>::tmat2x2(tmat2x2<U, Q> const & m)
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P>::tmat2x2(tmat3x3<T, P> const & m)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat2x2<T, P>::tmat2x2(tmat3x3<T, P> const & m)
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P>::tmat2x2(tmat4x4<T, P> const & m)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat2x2<T, P>::tmat2x2(tmat4x4<T, P> const & m)
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);
 	}
 
 	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat2x2<T, P>::tmat2x2(tmat2x3<T, P> const & m)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat2x2<T, P>::tmat2x2(tmat2x3<T, P> const & m)
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P>::tmat2x2(tmat3x2<T, P> const & m)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat2x2<T, P>::tmat2x2(tmat3x2<T, P> const & m)
 	{
 		this->value[0] = m[0];
 		this->value[1] = m[1];
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P>::tmat2x2(tmat2x4<T, P> const & m)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat2x2<T, P>::tmat2x2(tmat2x4<T, P> const & m)
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P>::tmat2x2(tmat4x2<T, P> const & m)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat2x2<T, P>::tmat2x2(tmat4x2<T, P> const & m)
 	{
 		this->value[0] = m[0];
 		this->value[1] = m[1];
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P>::tmat2x2(tmat3x4<T, P> const & m)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat2x2<T, P>::tmat2x2(tmat3x4<T, P> const & m)
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P>::tmat2x2(tmat4x3<T, P> const & m)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat2x2<T, P>::tmat2x2(tmat4x3<T, P> const & m)
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);

glm/detail/type_mat2x3.hpp

@@ -56,45 +56,45 @@ namespace glm
 	public:
 		// -- Constructors --
 
-		GLM_FUNC_DECL tmat2x3() GLM_DEFAULT_CTOR;
-		GLM_FUNC_DECL tmat2x3(tmat2x3<T, P> const & m) GLM_DEFAULT;
+		GLM_FUNC_DECL GLM_CONSTEXPR tmat2x3() GLM_DEFAULT_CTOR;
+		GLM_FUNC_DECL GLM_CONSTEXPR tmat2x3(tmat2x3<T, P> const & m) GLM_DEFAULT;
 		template <precision Q>
-		GLM_FUNC_DECL tmat2x3(tmat2x3<T, Q> const & m);
+		GLM_FUNC_DECL GLM_CONSTEXPR tmat2x3(tmat2x3<T, Q> const & m);
 
-		GLM_FUNC_DECL explicit tmat2x3(ctor);
-		GLM_FUNC_DECL explicit tmat2x3(T scalar);
-		GLM_FUNC_DECL tmat2x3(
+		GLM_FUNC_DECL GLM_CONSTEXPR explicit tmat2x3(ctor);
+		GLM_FUNC_DECL GLM_CONSTEXPR explicit tmat2x3(T scalar);
+		GLM_FUNC_DECL GLM_CONSTEXPR tmat2x3(
 			T x0, T y0, T z0,
 			T x1, T y1, T z1);
-		GLM_FUNC_DECL tmat2x3(
+		GLM_FUNC_DECL GLM_CONSTEXPR tmat2x3(
 			col_type const & v0,
 			col_type const & v1);
 
 		// -- Conversions --
 
 		template <typename X1, typename Y1, typename Z1, typename X2, typename Y2, typename Z2>
-		GLM_FUNC_DECL tmat2x3(
+		GLM_FUNC_DECL GLM_CONSTEXPR tmat2x3(
 			X1 x1, Y1 y1, Z1 z1,
 			X2 x2, Y2 y2, Z2 z2);
 
 		template <typename U, typename V>
-		GLM_FUNC_DECL tmat2x3(
+		GLM_FUNC_DECL GLM_CONSTEXPR tmat2x3(
 			tvec3<U, P> const & v1,
 			tvec3<V, P> const & v2);
 
 		// -- Matrix conversions --
 
 		template <typename U, precision Q>
-		GLM_FUNC_DECL GLM_EXPLICIT tmat2x3(tmat2x3<U, Q> const & m);
-
-		GLM_FUNC_DECL GLM_EXPLICIT tmat2x3(tmat2x2<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat2x3(tmat3x3<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat2x3(tmat4x4<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat2x3(tmat2x4<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat2x3(tmat3x2<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat2x3(tmat3x4<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat2x3(tmat4x2<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat2x3(tmat4x3<T, P> const & x);
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tmat2x3(tmat2x3<U, Q> const & m);
+
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tmat2x3(tmat2x2<T, P> const & x);
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tmat2x3(tmat3x3<T, P> const & x);
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tmat2x3(tmat4x4<T, P> const & x);
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tmat2x3(tmat2x4<T, P> const & x);
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tmat2x3(tmat3x2<T, P> const & x);
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tmat2x3(tmat3x4<T, P> const & x);
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tmat2x3(tmat4x2<T, P> const & x);
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tmat2x3(tmat4x3<T, P> const & x);
 
 		// -- Accesses --
 

glm/detail/type_mat2x3.inl

@@ -36,7 +36,7 @@ namespace glm
 
 #	if !GLM_HAS_DEFAULTED_FUNCTIONS || !defined(GLM_FORCE_NO_CTOR_INIT)
 		template <typename T, precision P> 
-		GLM_FUNC_QUALIFIER tmat2x3<T, P>::tmat2x3()
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat2x3<T, P>::tmat2x3()
 		{
 #			ifndef GLM_FORCE_NO_CTOR_INIT 
 				this->value[0] = col_type(1, 0, 0);
@@ -47,7 +47,7 @@ namespace glm
 
 #	if !GLM_HAS_DEFAULTED_FUNCTIONS
 		template <typename T, precision P>
-		GLM_FUNC_QUALIFIER tmat2x3<T, P>::tmat2x3(tmat2x3<T, P> const & m)
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat2x3<T, P>::tmat2x3(tmat2x3<T, P> const & m)
 		{
 			this->value[0] = m.value[0];
 			this->value[1] = m.value[1];
@@ -56,25 +56,25 @@ namespace glm
 
 	template <typename T, precision P>
 	template <precision Q>
-	GLM_FUNC_QUALIFIER tmat2x3<T, P>::tmat2x3(tmat2x3<T, Q> const & m)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat2x3<T, P>::tmat2x3(tmat2x3<T, Q> const & m)
 	{
 		this->value[0] = m.value[0];
 		this->value[1] = m.value[1];
 	}
 
 	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat2x3<T, P>::tmat2x3(ctor)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat2x3<T, P>::tmat2x3(ctor)
 	{}
 
 	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat2x3<T, P>::tmat2x3(T scalar)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat2x3<T, P>::tmat2x3(T scalar)
 	{
 		this->value[0] = col_type(scalar, 0, 0);
 		this->value[1] = col_type(0, scalar, 0);
 	}
 
 	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat2x3<T, P>::tmat2x3
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat2x3<T, P>::tmat2x3
 	(
 		T x0, T y0, T z0,
 		T x1, T y1, T z1
@@ -85,7 +85,7 @@ namespace glm
 	}
 
 	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat2x3<T, P>::tmat2x3(col_type const & v0, col_type const & v1)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat2x3<T, P>::tmat2x3(col_type const & v0, col_type const & v1)
 	{
 		this->value[0] = v0;
 		this->value[1] = v1;
@@ -97,7 +97,7 @@ namespace glm
 	template <
 		typename X1, typename Y1, typename Z1,
 		typename X2, typename Y2, typename Z2>
-	GLM_FUNC_QUALIFIER tmat2x3<T, P>::tmat2x3
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat2x3<T, P>::tmat2x3
 	(
 		X1 x1, Y1 y1, Z1 z1,
 		X2 x2, Y2 y2, Z2 z2
@@ -109,7 +109,7 @@ namespace glm
 	
 	template <typename T, precision P>
 	template <typename V1, typename V2>
-	GLM_FUNC_QUALIFIER tmat2x3<T, P>::tmat2x3(tvec3<V1, P> const & v1, tvec3<V2, P> const & v2)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat2x3<T, P>::tmat2x3(tvec3<V1, P> const & v1, tvec3<V2, P> const & v2)
 	{
 		this->value[0] = col_type(v1);
 		this->value[1] = col_type(v2);
@@ -119,63 +119,63 @@ namespace glm
 
 	template <typename T, precision P>
 	template <typename U, precision Q>
-	GLM_FUNC_QUALIFIER tmat2x3<T, P>::tmat2x3(tmat2x3<U, Q> const & m)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat2x3<T, P>::tmat2x3(tmat2x3<U, Q> const & m)
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);
 	}
 
 	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat2x3<T, P>::tmat2x3(tmat2x2<T, P> const & m)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat2x3<T, P>::tmat2x3(tmat2x2<T, P> const & m)
 	{
 		this->value[0] = col_type(m[0], 0);
 		this->value[1] = col_type(m[1], 0);
 	}
 
 	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat2x3<T, P>::tmat2x3(tmat3x3<T, P> const & m)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat2x3<T, P>::tmat2x3(tmat3x3<T, P> const & m)
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);
 	}
 
 	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat2x3<T, P>::tmat2x3(tmat4x4<T, P> const & m)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat2x3<T, P>::tmat2x3(tmat4x4<T, P> const & m)
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);
 	}
 
 	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat2x3<T, P>::tmat2x3(tmat2x4<T, P> const & m)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat2x3<T, P>::tmat2x3(tmat2x4<T, P> const & m)
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);
 	}
 
 	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat2x3<T, P>::tmat2x3(tmat3x2<T, P> const & m)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat2x3<T, P>::tmat2x3(tmat3x2<T, P> const & m)
 	{
 		this->value[0] = col_type(m[0], 0);
 		this->value[1] = col_type(m[1], 0);
 	}
 
 	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat2x3<T, P>::tmat2x3(tmat3x4<T, P> const & m)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat2x3<T, P>::tmat2x3(tmat3x4<T, P> const & m)
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);
 	}
 
 	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat2x3<T, P>::tmat2x3(tmat4x2<T, P> const & m)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat2x3<T, P>::tmat2x3(tmat4x2<T, P> const & m)
 	{
 		this->value[0] = col_type(m[0], 0);
 		this->value[1] = col_type(m[1], 0);
 	}
 
 	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat2x3<T, P>::tmat2x3(tmat4x3<T, P> const & m)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat2x3<T, P>::tmat2x3(tmat4x3<T, P> const & m)
 	{
 		this->value[0] = m[0];
 		this->value[1] = m[1];

glm/detail/type_mat2x4.hpp

@@ -56,17 +56,17 @@ namespace glm
 	public:
 		// -- Constructors --
 
-		GLM_FUNC_DECL tmat2x4() GLM_DEFAULT_CTOR;
-		GLM_FUNC_DECL tmat2x4(tmat2x4<T, P> const & m) GLM_DEFAULT;
+		GLM_FUNC_DECL GLM_CONSTEXPR tmat2x4() GLM_DEFAULT_CTOR;
+		GLM_FUNC_DECL GLM_CONSTEXPR tmat2x4(tmat2x4<T, P> const & m) GLM_DEFAULT;
 		template <precision Q>
-		GLM_FUNC_DECL tmat2x4(tmat2x4<T, Q> const & m);
+		GLM_FUNC_DECL GLM_CONSTEXPR tmat2x4(tmat2x4<T, Q> const & m);
 
-		GLM_FUNC_DECL explicit tmat2x4(ctor);
-		GLM_FUNC_DECL explicit tmat2x4(T scalar);
-		GLM_FUNC_DECL tmat2x4(
+		GLM_FUNC_DECL GLM_CONSTEXPR explicit tmat2x4(ctor);
+		GLM_FUNC_DECL GLM_CONSTEXPR explicit tmat2x4(T scalar);
+		GLM_FUNC_DECL GLM_CONSTEXPR tmat2x4(
 			T x0, T y0, T z0, T w0,
 			T x1, T y1, T z1, T w1);
-		GLM_FUNC_DECL tmat2x4(
+		GLM_FUNC_DECL GLM_CONSTEXPR tmat2x4(
 			col_type const & v0,
 			col_type const & v1);
 
@@ -75,28 +75,28 @@ namespace glm
 		template <
 			typename X1, typename Y1, typename Z1, typename W1,
 			typename X2, typename Y2, typename Z2, typename W2>
-		GLM_FUNC_DECL tmat2x4(
+		GLM_FUNC_DECL GLM_CONSTEXPR tmat2x4(
 			X1 x1, Y1 y1, Z1 z1, W1 w1,
 			X2 x2, Y2 y2, Z2 z2, W2 w2);
 
 		template <typename U, typename V>
-		GLM_FUNC_DECL tmat2x4(
+		GLM_FUNC_DECL GLM_CONSTEXPR tmat2x4(
 			tvec4<U, P> const & v1,
 			tvec4<V, P> const & v2);
 
 		// -- Matrix conversions --
 
 		template <typename U, precision Q>
-		GLM_FUNC_DECL GLM_EXPLICIT tmat2x4(tmat2x4<U, Q> const & m);
-
-		GLM_FUNC_DECL GLM_EXPLICIT tmat2x4(tmat2x2<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat2x4(tmat3x3<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat2x4(tmat4x4<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat2x4(tmat2x3<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat2x4(tmat3x2<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat2x4(tmat3x4<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat2x4(tmat4x2<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat2x4(tmat4x3<T, P> const & x);
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tmat2x4(tmat2x4<U, Q> const & m);
+
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tmat2x4(tmat2x2<T, P> const & x);
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tmat2x4(tmat3x3<T, P> const & x);
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tmat2x4(tmat4x4<T, P> const & x);
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tmat2x4(tmat2x3<T, P> const & x);
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tmat2x4(tmat3x2<T, P> const & x);
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tmat2x4(tmat3x4<T, P> const & x);
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tmat2x4(tmat4x2<T, P> const & x);
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tmat2x4(tmat4x3<T, P> const & x);
 
 		// -- Accesses --
 

glm/detail/type_mat2x4.inl

@@ -36,7 +36,7 @@ namespace glm
 
 #	if !GLM_HAS_DEFAULTED_FUNCTIONS || !defined(GLM_FORCE_NO_CTOR_INIT)
 		template <typename T, precision P>
-		GLM_FUNC_QUALIFIER tmat2x4<T, P>::tmat2x4()
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat2x4<T, P>::tmat2x4()
 		{
 #			ifndef GLM_FORCE_NO_CTOR_INIT 
 				this->value[0] = col_type(1, 0, 0, 0);
@@ -47,7 +47,7 @@ namespace glm
 
 #	if !GLM_HAS_DEFAULTED_FUNCTIONS
 		template <typename T, precision P>
-		GLM_FUNC_QUALIFIER tmat2x4<T, P>::tmat2x4(tmat2x4<T, P> const & m)
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat2x4<T, P>::tmat2x4(tmat2x4<T, P> const & m)
 		{
 			this->value[0] = m.value[0];
 			this->value[1] = m.value[1];
@@ -56,18 +56,18 @@ namespace glm
 
 	template <typename T, precision P>
 	template <precision Q>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P>::tmat2x4(tmat2x4<T, Q> const & m)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat2x4<T, P>::tmat2x4(tmat2x4<T, Q> const & m)
 	{
 		this->value[0] = m.value[0];
 		this->value[1] = m.value[1];
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P>::tmat2x4(ctor)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat2x4<T, P>::tmat2x4(ctor)
 	{}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P>::tmat2x4(T scalar)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat2x4<T, P>::tmat2x4(T scalar)
 	{
 		value_type const Zero(0);
 		this->value[0] = col_type(scalar, Zero, Zero, Zero);
@@ -75,7 +75,7 @@ namespace glm
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P>::tmat2x4
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat2x4<T, P>::tmat2x4
 	(
 		T x0, T y0, T z0, T w0,
 		T x1, T y1, T z1, T w1
@@ -86,7 +86,7 @@ namespace glm
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P>::tmat2x4(col_type const & v0, col_type const & v1)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat2x4<T, P>::tmat2x4(col_type const & v0, col_type const & v1)
 	{
 		this->value[0] = v0;
 		this->value[1] = v1;
@@ -98,7 +98,7 @@ namespace glm
 	template <
 		typename X1, typename Y1, typename Z1, typename W1,
 		typename X2, typename Y2, typename Z2, typename W2>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P>::tmat2x4
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat2x4<T, P>::tmat2x4
 	(
 		X1 x1, Y1 y1, Z1 z1, W1 w1,
 		X2 x2, Y2 y2, Z2 z2, W2 w2
@@ -110,7 +110,7 @@ namespace glm
 	
 	template <typename T, precision P>
 	template <typename V1, typename V2>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P>::tmat2x4(tvec4<V1, P> const & v1, tvec4<V2, P> const & v2)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat2x4<T, P>::tmat2x4(tvec4<V1, P> const & v1, tvec4<V2, P> const & v2)
 	{
 		this->value[0] = col_type(v1);
 		this->value[1] = col_type(v2);
@@ -120,63 +120,63 @@ namespace glm
 
 	template <typename T, precision P>
 	template <typename U, precision Q>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P>::tmat2x4(tmat2x4<U, Q> const & m)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat2x4<T, P>::tmat2x4(tmat2x4<U, Q> const & m)
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P>::tmat2x4(tmat2x2<T, P> const & m)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat2x4<T, P>::tmat2x4(tmat2x2<T, P> const & m)
 	{
 		this->value[0] = col_type(m[0], 0, 0);
 		this->value[1] = col_type(m[1], 0, 0);
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P>::tmat2x4(tmat3x3<T, P> const & m)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat2x4<T, P>::tmat2x4(tmat3x3<T, P> const & m)
 	{
 		this->value[0] = col_type(m[0], 0);
 		this->value[1] = col_type(m[1], 0);
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P>::tmat2x4(tmat4x4<T, P> const & m)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat2x4<T, P>::tmat2x4(tmat4x4<T, P> const & m)
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P>::tmat2x4(tmat2x3<T, P> const & m)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat2x4<T, P>::tmat2x4(tmat2x3<T, P> const & m)
 	{
 		this->value[0] = col_type(m[0], 0);
 		this->value[1] = col_type(m[1], 0);
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P>::tmat2x4(tmat3x2<T, P> const & m)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat2x4<T, P>::tmat2x4(tmat3x2<T, P> const & m)
 	{
 		this->value[0] = col_type(m[0], 0, 0);
 		this->value[1] = col_type(m[1], 0, 0);
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P>::tmat2x4(tmat3x4<T, P> const & m)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat2x4<T, P>::tmat2x4(tmat3x4<T, P> const & m)
 	{
 		this->value[0] = m[0];
 		this->value[1] = m[1];
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P>::tmat2x4(tmat4x2<T, P> const & m)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat2x4<T, P>::tmat2x4(tmat4x2<T, P> const & m)
 	{
 		this->value[0] = col_type(m[0], 0, 0);
 		this->value[1] = col_type(m[1], 0, 0);
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P>::tmat2x4(tmat4x3<T, P> const & m)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat2x4<T, P>::tmat2x4(tmat4x3<T, P> const & m)
 	{
 		this->value[0] = col_type(m[0], 0);
 		this->value[1] = col_type(m[1], 0);

glm/detail/type_mat3x2.hpp

@@ -56,18 +56,18 @@ namespace glm
 	public:
 		// -- Constructors --
 
-		GLM_FUNC_DECL tmat3x2() GLM_DEFAULT_CTOR;
-		GLM_FUNC_DECL tmat3x2(tmat3x2<T, P> const & m) GLM_DEFAULT;
+		GLM_FUNC_DECL GLM_CONSTEXPR tmat3x2() GLM_DEFAULT_CTOR;
+		GLM_FUNC_DECL GLM_CONSTEXPR tmat3x2(tmat3x2<T, P> const & m) GLM_DEFAULT;
 		template <precision Q>
-		GLM_FUNC_DECL tmat3x2(tmat3x2<T, Q> const & m);
+		GLM_FUNC_DECL GLM_CONSTEXPR tmat3x2(tmat3x2<T, Q> const & m);
 
-		GLM_FUNC_DECL explicit tmat3x2(ctor);
-		GLM_FUNC_DECL explicit tmat3x2(T scalar);
-		GLM_FUNC_DECL tmat3x2(
+		GLM_FUNC_DECL GLM_CONSTEXPR explicit tmat3x2(ctor);
+		GLM_FUNC_DECL GLM_CONSTEXPR explicit tmat3x2(T scalar);
+		GLM_FUNC_DECL GLM_CONSTEXPR tmat3x2(
 			T x0, T y0,
 			T x1, T y1,
 			T x2, T y2);
-		GLM_FUNC_DECL tmat3x2(
+		GLM_FUNC_DECL GLM_CONSTEXPR tmat3x2(
 			col_type const & v0,
 			col_type const & v1,
 			col_type const & v2);
@@ -78,13 +78,13 @@ namespace glm
 			typename X1, typename Y1,
 			typename X2, typename Y2,
 			typename X3, typename Y3>
-		GLM_FUNC_DECL tmat3x2(
+		GLM_FUNC_DECL GLM_CONSTEXPR tmat3x2(
 			X1 x1, Y1 y1,
 			X2 x2, Y2 y2,
 			X3 x3, Y3 y3);
 
 		template <typename V1, typename V2, typename V3>
-		GLM_FUNC_DECL tmat3x2(
+		GLM_FUNC_DECL GLM_CONSTEXPR tmat3x2(
 			tvec2<V1, P> const & v1,
 			tvec2<V2, P> const & v2,
 			tvec2<V3, P> const & v3);
@@ -92,16 +92,16 @@ namespace glm
 		// -- Matrix conversions --
 
 		template <typename U, precision Q>
-		GLM_FUNC_DECL GLM_EXPLICIT tmat3x2(tmat3x2<U, Q> const & m);
-
-		GLM_FUNC_DECL GLM_EXPLICIT tmat3x2(tmat2x2<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat3x2(tmat3x3<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat3x2(tmat4x4<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat3x2(tmat2x3<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat3x2(tmat2x4<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat3x2(tmat3x4<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat3x2(tmat4x2<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat3x2(tmat4x3<T, P> const & x);
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tmat3x2(tmat3x2<U, Q> const & m);
+
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tmat3x2(tmat2x2<T, P> const & x);
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tmat3x2(tmat3x3<T, P> const & x);
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tmat3x2(tmat4x4<T, P> const & x);
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tmat3x2(tmat2x3<T, P> const & x);
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tmat3x2(tmat2x4<T, P> const & x);
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tmat3x2(tmat3x4<T, P> const & x);
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tmat3x2(tmat4x2<T, P> const & x);
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tmat3x2(tmat4x3<T, P> const & x);
 
 		// -- Accesses --
 

glm/detail/type_mat3x2.inl

@@ -36,7 +36,7 @@ namespace glm
 
 #	if !GLM_HAS_DEFAULTED_FUNCTIONS || !defined(GLM_FORCE_NO_CTOR_INIT)
 		template <typename T, precision P> 
-		GLM_FUNC_QUALIFIER tmat3x2<T, P>::tmat3x2()
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat3x2<T, P>::tmat3x2()
 		{
 #			ifndef GLM_FORCE_NO_CTOR_INIT 
 				this->value[0] = col_type(1, 0);
@@ -48,7 +48,7 @@ namespace glm
 
 #	if !GLM_HAS_DEFAULTED_FUNCTIONS
 		template <typename T, precision P>
-		GLM_FUNC_QUALIFIER tmat3x2<T, P>::tmat3x2(tmat3x2<T, P> const & m)
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat3x2<T, P>::tmat3x2(tmat3x2<T, P> const & m)
 		{
 			this->value[0] = m.value[0];
 			this->value[1] = m.value[1];
@@ -58,7 +58,7 @@ namespace glm
 
 	template <typename T, precision P>
 	template <precision Q>
-	GLM_FUNC_QUALIFIER tmat3x2<T, P>::tmat3x2(tmat3x2<T, Q> const & m)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat3x2<T, P>::tmat3x2(tmat3x2<T, Q> const & m)
 	{
 		this->value[0] = m.value[0];
 		this->value[1] = m.value[1];
@@ -66,11 +66,11 @@ namespace glm
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x2<T, P>::tmat3x2(ctor)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat3x2<T, P>::tmat3x2(ctor)
 	{}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x2<T, P>::tmat3x2(T scalar)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat3x2<T, P>::tmat3x2(T scalar)
 	{
 		this->value[0] = col_type(scalar, 0);
 		this->value[1] = col_type(0, scalar);
@@ -78,7 +78,7 @@ namespace glm
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x2<T, P>::tmat3x2
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat3x2<T, P>::tmat3x2
 	(
 		T x0, T y0,
 		T x1, T y1,
@@ -91,7 +91,7 @@ namespace glm
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x2<T, P>::tmat3x2
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat3x2<T, P>::tmat3x2
 	(
 		col_type const & v0,
 		col_type const & v1,
@@ -110,7 +110,7 @@ namespace glm
 		typename X1, typename Y1,
 		typename X2, typename Y2,
 		typename X3, typename Y3>
-	GLM_FUNC_QUALIFIER tmat3x2<T, P>::tmat3x2
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat3x2<T, P>::tmat3x2
 	(
 		X1 x1, Y1 y1,
 		X2 x2, Y2 y2,
@@ -124,7 +124,7 @@ namespace glm
 
 	template <typename T, precision P>
 	template <typename V1, typename V2, typename V3>
-	GLM_FUNC_QUALIFIER tmat3x2<T, P>::tmat3x2
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat3x2<T, P>::tmat3x2
 	(
 		tvec2<V1, P> const & v1,
 		tvec2<V2, P> const & v2,
@@ -140,7 +140,7 @@ namespace glm
 
 	template <typename T, precision P>
 	template <typename U, precision Q>
-	GLM_FUNC_QUALIFIER tmat3x2<T, P>::tmat3x2(tmat3x2<U, Q> const & m)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat3x2<T, P>::tmat3x2(tmat3x2<U, Q> const & m)
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);
@@ -148,7 +148,7 @@ namespace glm
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x2<T, P>::tmat3x2(tmat2x2<T, P> const & m)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat3x2<T, P>::tmat3x2(tmat2x2<T, P> const & m)
 	{
 		this->value[0] = m[0];
 		this->value[1] = m[1];
@@ -156,7 +156,7 @@ namespace glm
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x2<T, P>::tmat3x2(tmat3x3<T, P> const & m)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat3x2<T, P>::tmat3x2(tmat3x3<T, P> const & m)
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);
@@ -164,7 +164,7 @@ namespace glm
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x2<T, P>::tmat3x2(tmat4x4<T, P> const & m)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat3x2<T, P>::tmat3x2(tmat4x4<T, P> const & m)
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);
@@ -172,39 +172,39 @@ namespace glm
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x2<T, P>::tmat3x2(tmat2x3<T, P> const & m)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat3x2<T, P>::tmat3x2(tmat2x3<T, P> const & m)
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);
 		this->value[2] = col_type(T(0));
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat3x2<T, P>::tmat3x2(tmat2x4<T, P> const & m)
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat3x2<T, P>::tmat3x2(tmat2x4<T, P> const & m)
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);
 		this->value[2] = col_type(T(0));
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat3x2<T, P>::tmat3x2(tmat3x4<T, P> const & m)
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat3x2<T, P>::tmat3x2(tmat3x4<T, P> const & m)
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);
 		this->value[2] = col_type(m[2]);
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat3x2<T, P>::tmat3x2(tmat4x2<T, P> const & m)
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat3x2<T, P>::tmat3x2(tmat4x2<T, P> const & m)
 	{
 		this->value[0] = m[0];
 		this->value[1] = m[1];
 		this->value[2] = m[2];
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat3x2<T, P>::tmat3x2(tmat4x3<T, P> const & m)
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat3x2<T, P>::tmat3x2(tmat4x3<T, P> const & m)
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);

glm/detail/type_mat3x3.hpp

@@ -55,18 +55,18 @@ namespace glm
 	public:
 		// -- Constructors --
 
-		GLM_FUNC_DECL tmat3x3() GLM_DEFAULT_CTOR;
-		GLM_FUNC_DECL tmat3x3(tmat3x3<T, P> const & m) GLM_DEFAULT;
+		GLM_FUNC_DECL GLM_CONSTEXPR tmat3x3() GLM_DEFAULT_CTOR;
+		GLM_FUNC_DECL GLM_CONSTEXPR tmat3x3(tmat3x3<T, P> const & m) GLM_DEFAULT;
 		template <precision Q>
-		GLM_FUNC_DECL tmat3x3(tmat3x3<T, Q> const & m);
+		GLM_FUNC_DECL GLM_CONSTEXPR tmat3x3(tmat3x3<T, Q> const & m);
 
-		GLM_FUNC_DECL explicit tmat3x3(ctor);
-		GLM_FUNC_DECL explicit tmat3x3(T scalar);
-		GLM_FUNC_DECL tmat3x3(
+		GLM_FUNC_DECL GLM_CONSTEXPR explicit tmat3x3(ctor);
+		GLM_FUNC_DECL GLM_CONSTEXPR explicit tmat3x3(T scalar);
+		GLM_FUNC_DECL GLM_CONSTEXPR tmat3x3(
 			T x0, T y0, T z0,
 			T x1, T y1, T z1,
 			T x2, T y2, T z2);
-		GLM_FUNC_DECL tmat3x3(
+		GLM_FUNC_DECL GLM_CONSTEXPR tmat3x3(
 			col_type const & v0,
 			col_type const & v1,
 			col_type const & v2);
@@ -77,13 +77,13 @@ namespace glm
 			typename X1, typename Y1, typename Z1,
 			typename X2, typename Y2, typename Z2,
 			typename X3, typename Y3, typename Z3>
-		GLM_FUNC_DECL tmat3x3(
+		GLM_FUNC_DECL GLM_CONSTEXPR tmat3x3(
 			X1 x1, Y1 y1, Z1 z1,
 			X2 x2, Y2 y2, Z2 z2,
 			X3 x3, Y3 y3, Z3 z3);
 
 		template <typename V1, typename V2, typename V3>
-		GLM_FUNC_DECL tmat3x3(
+		GLM_FUNC_DECL GLM_CONSTEXPR tmat3x3(
 			tvec3<V1, P> const & v1,
 			tvec3<V2, P> const & v2,
 			tvec3<V3, P> const & v3);
@@ -91,16 +91,16 @@ namespace glm
 		// -- Matrix conversions --
 
 		template <typename U, precision Q>
-		GLM_FUNC_DECL GLM_EXPLICIT tmat3x3(tmat3x3<U, Q> const & m);
-
-		GLM_FUNC_DECL GLM_EXPLICIT tmat3x3(tmat2x2<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat3x3(tmat4x4<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat3x3(tmat2x3<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat3x3(tmat3x2<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat3x3(tmat2x4<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat3x3(tmat4x2<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat3x3(tmat3x4<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat3x3(tmat4x3<T, P> const & x);
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tmat3x3(tmat3x3<U, Q> const & m);
+
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tmat3x3(tmat2x2<T, P> const & x);
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tmat3x3(tmat4x4<T, P> const & x);
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tmat3x3(tmat2x3<T, P> const & x);
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tmat3x3(tmat3x2<T, P> const & x);
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tmat3x3(tmat2x4<T, P> const & x);
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tmat3x3(tmat4x2<T, P> const & x);
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tmat3x3(tmat3x4<T, P> const & x);
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tmat3x3(tmat4x3<T, P> const & x);
 
 		// -- Accesses --
 

glm/detail/type_mat3x3.inl

@@ -60,7 +60,7 @@ namespace detail
 
 #	if !GLM_HAS_DEFAULTED_FUNCTIONS || !defined(GLM_FORCE_NO_CTOR_INIT)
 		template <typename T, precision P>
-		GLM_FUNC_QUALIFIER tmat3x3<T, P>::tmat3x3()
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat3x3<T, P>::tmat3x3()
 		{
 #			ifndef GLM_FORCE_NO_CTOR_INIT 
 				this->value[0] = col_type(1, 0, 0);
@@ -72,7 +72,7 @@ namespace detail
 
 #	if !GLM_HAS_DEFAULTED_FUNCTIONS
 		template <typename T, precision P>
-		GLM_FUNC_QUALIFIER tmat3x3<T, P>::tmat3x3(tmat3x3<T, P> const & m)
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat3x3<T, P>::tmat3x3(tmat3x3<T, P> const & m)
 		{
 			this->value[0] = m.value[0];
 			this->value[1] = m.value[1];
@@ -82,7 +82,7 @@ namespace detail
 
 	template <typename T, precision P>
 	template <precision Q>
-	GLM_FUNC_QUALIFIER tmat3x3<T, P>::tmat3x3(tmat3x3<T, Q> const & m)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat3x3<T, P>::tmat3x3(tmat3x3<T, Q> const & m)
 	{
 		this->value[0] = m.value[0];
 		this->value[1] = m.value[1];
@@ -90,11 +90,11 @@ namespace detail
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x3<T, P>::tmat3x3(ctor)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat3x3<T, P>::tmat3x3(ctor)
 	{}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x3<T, P>::tmat3x3(T scalar)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat3x3<T, P>::tmat3x3(T scalar)
 	{
 		this->value[0] = col_type(scalar, 0, 0);
 		this->value[1] = col_type(0, scalar, 0);
@@ -102,7 +102,7 @@ namespace detail
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x3<T, P>::tmat3x3
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat3x3<T, P>::tmat3x3
 	(
 		T x0, T y0, T z0,
 		T x1, T y1, T z1,
@@ -115,7 +115,7 @@ namespace detail
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x3<T, P>::tmat3x3
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat3x3<T, P>::tmat3x3
 	(
 		col_type const & v0,
 		col_type const & v1,
@@ -134,7 +134,7 @@ namespace detail
 		typename X1, typename Y1, typename Z1,
 		typename X2, typename Y2, typename Z2,
 		typename X3, typename Y3, typename Z3>
-	GLM_FUNC_QUALIFIER tmat3x3<T, P>::tmat3x3
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat3x3<T, P>::tmat3x3
 	(
 		X1 x1, Y1 y1, Z1 z1,
 		X2 x2, Y2 y2, Z2 z2,
@@ -148,7 +148,7 @@ namespace detail
 	
 	template <typename T, precision P>
 	template <typename V1, typename V2, typename V3>
-	GLM_FUNC_QUALIFIER tmat3x3<T, P>::tmat3x3
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat3x3<T, P>::tmat3x3
 	(
 		tvec3<V1, P> const & v1,
 		tvec3<V2, P> const & v2,
@@ -164,7 +164,7 @@ namespace detail
 
 	template <typename T, precision P>
 	template <typename U, precision Q>
-	GLM_FUNC_QUALIFIER tmat3x3<T, P>::tmat3x3(tmat3x3<U, Q> const & m)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat3x3<T, P>::tmat3x3(tmat3x3<U, Q> const & m)
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);
@@ -172,7 +172,7 @@ namespace detail
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x3<T, P>::tmat3x3(tmat2x2<T, P> const & m)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat3x3<T, P>::tmat3x3(tmat2x2<T, P> const & m)
 	{
 		this->value[0] = col_type(m[0], 0);
 		this->value[1] = col_type(m[1], 0);
@@ -180,7 +180,7 @@ namespace detail
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x3<T, P>::tmat3x3(tmat4x4<T, P> const & m)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat3x3<T, P>::tmat3x3(tmat4x4<T, P> const & m)
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);
@@ -188,7 +188,7 @@ namespace detail
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x3<T, P>::tmat3x3(tmat2x3<T, P> const & m)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat3x3<T, P>::tmat3x3(tmat2x3<T, P> const & m)
 	{
 		this->value[0] = m[0];
 		this->value[1] = m[1];
@@ -196,7 +196,7 @@ namespace detail
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x3<T, P>::tmat3x3(tmat3x2<T, P> const & m)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat3x3<T, P>::tmat3x3(tmat3x2<T, P> const & m)
 	{
 		this->value[0] = col_type(m[0], 0);
 		this->value[1] = col_type(m[1], 0);
@@ -204,7 +204,7 @@ namespace detail
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x3<T, P>::tmat3x3(tmat2x4<T, P> const & m)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat3x3<T, P>::tmat3x3(tmat2x4<T, P> const & m)
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);
@@ -212,7 +212,7 @@ namespace detail
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x3<T, P>::tmat3x3(tmat4x2<T, P> const & m)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat3x3<T, P>::tmat3x3(tmat4x2<T, P> const & m)
 	{
 		this->value[0] = col_type(m[0], 0);
 		this->value[1] = col_type(m[1], 0);
@@ -220,7 +220,7 @@ namespace detail
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x3<T, P>::tmat3x3(tmat3x4<T, P> const & m)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat3x3<T, P>::tmat3x3(tmat3x4<T, P> const & m)
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);
@@ -228,7 +228,7 @@ namespace detail
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x3<T, P>::tmat3x3(tmat4x3<T, P> const & m)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat3x3<T, P>::tmat3x3(tmat4x3<T, P> const & m)
 	{
 		this->value[0] = m[0];
 		this->value[1] = m[1];

glm/detail/type_mat3x4.hpp

@@ -56,18 +56,18 @@ namespace glm
 	public:
 		// -- Constructors --
 
-		GLM_FUNC_DECL tmat3x4() GLM_DEFAULT_CTOR;
-		GLM_FUNC_DECL tmat3x4(tmat3x4<T, P> const & m) GLM_DEFAULT;
+		GLM_FUNC_DECL GLM_CONSTEXPR tmat3x4() GLM_DEFAULT_CTOR;
+		GLM_FUNC_DECL GLM_CONSTEXPR tmat3x4(tmat3x4<T, P> const & m) GLM_DEFAULT;
 		template <precision Q>
-		GLM_FUNC_DECL tmat3x4(tmat3x4<T, Q> const & m);
+		GLM_FUNC_DECL GLM_CONSTEXPR tmat3x4(tmat3x4<T, Q> const & m);
 
-		GLM_FUNC_DECL explicit tmat3x4(ctor);
-		GLM_FUNC_DECL explicit tmat3x4(T scalar);
-		GLM_FUNC_DECL tmat3x4(
+		GLM_FUNC_DECL GLM_CONSTEXPR explicit tmat3x4(ctor);
+		GLM_FUNC_DECL GLM_CONSTEXPR explicit tmat3x4(T scalar);
+		GLM_FUNC_DECL GLM_CONSTEXPR tmat3x4(
 			T x0, T y0, T z0, T w0,
 			T x1, T y1, T z1, T w1,
 			T x2, T y2, T z2, T w2);
-		GLM_FUNC_DECL tmat3x4(
+		GLM_FUNC_DECL GLM_CONSTEXPR tmat3x4(
 			col_type const & v0,
 			col_type const & v1,
 			col_type const & v2);
@@ -78,13 +78,13 @@ namespace glm
 			typename X1, typename Y1, typename Z1, typename W1,
 			typename X2, typename Y2, typename Z2, typename W2,
 			typename X3, typename Y3, typename Z3, typename W3>
-		GLM_FUNC_DECL tmat3x4(
+		GLM_FUNC_DECL GLM_CONSTEXPR tmat3x4(
 			X1 x1, Y1 y1, Z1 z1, W1 w1,
 			X2 x2, Y2 y2, Z2 z2, W2 w2,
 			X3 x3, Y3 y3, Z3 z3, W3 w3);
 
 		template <typename V1, typename V2, typename V3>
-		GLM_FUNC_DECL tmat3x4(
+		GLM_FUNC_DECL GLM_CONSTEXPR tmat3x4(
 			tvec4<V1, P> const & v1,
 			tvec4<V2, P> const & v2,
 			tvec4<V3, P> const & v3);
@@ -92,16 +92,16 @@ namespace glm
 		// -- Matrix conversions --
 
 		template <typename U, precision Q>
-		GLM_FUNC_DECL GLM_EXPLICIT tmat3x4(tmat3x4<U, Q> const & m);
-
-		GLM_FUNC_DECL GLM_EXPLICIT tmat3x4(tmat2x2<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat3x4(tmat3x3<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat3x4(tmat4x4<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat3x4(tmat2x3<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat3x4(tmat3x2<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat3x4(tmat2x4<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat3x4(tmat4x2<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat3x4(tmat4x3<T, P> const & x);
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tmat3x4(tmat3x4<U, Q> const & m);
+
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tmat3x4(tmat2x2<T, P> const & x);
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tmat3x4(tmat3x3<T, P> const & x);
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tmat3x4(tmat4x4<T, P> const & x);
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tmat3x4(tmat2x3<T, P> const & x);
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tmat3x4(tmat3x2<T, P> const & x);
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tmat3x4(tmat2x4<T, P> const & x);
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tmat3x4(tmat4x2<T, P> const & x);
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tmat3x4(tmat4x3<T, P> const & x);
 
 		// -- Accesses --
 

glm/detail/type_mat3x4.inl

@@ -36,7 +36,7 @@ namespace glm
 
 #	if !GLM_HAS_DEFAULTED_FUNCTIONS || !defined(GLM_FORCE_NO_CTOR_INIT)
 		template <typename T, precision P>
-		GLM_FUNC_QUALIFIER tmat3x4<T, P>::tmat3x4()
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat3x4<T, P>::tmat3x4()
 		{
 #			ifndef GLM_FORCE_NO_CTOR_INIT 
 				this->value[0] = col_type(1, 0, 0, 0);
@@ -48,7 +48,7 @@ namespace glm
 
 #	if !GLM_HAS_DEFAULTED_FUNCTIONS
 		template <typename T, precision P>
-		GLM_FUNC_QUALIFIER tmat3x4<T, P>::tmat3x4(tmat3x4<T, P> const & m)
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat3x4<T, P>::tmat3x4(tmat3x4<T, P> const & m)
 		{
 			this->value[0] = m.value[0];
 			this->value[1] = m.value[1];
@@ -58,7 +58,7 @@ namespace glm
 
 	template <typename T, precision P>
 	template <precision Q>
-	GLM_FUNC_QUALIFIER tmat3x4<T, P>::tmat3x4(tmat3x4<T, Q> const & m)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat3x4<T, P>::tmat3x4(tmat3x4<T, Q> const & m)
 	{
 		this->value[0] = m.value[0];
 		this->value[1] = m.value[1];
@@ -66,11 +66,11 @@ namespace glm
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x4<T, P>::tmat3x4(ctor)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat3x4<T, P>::tmat3x4(ctor)
 	{}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x4<T, P>::tmat3x4(T scalar)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat3x4<T, P>::tmat3x4(T scalar)
 	{
 		this->value[0] = col_type(scalar, 0, 0, 0);
 		this->value[1] = col_type(0, scalar, 0, 0);
@@ -78,7 +78,7 @@ namespace glm
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x4<T, P>::tmat3x4
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat3x4<T, P>::tmat3x4
 	(
 		T x0, T y0, T z0, T w0,
 		T x1, T y1, T z1, T w1,
@@ -91,7 +91,7 @@ namespace glm
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x4<T, P>::tmat3x4
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat3x4<T, P>::tmat3x4
 	(
 		col_type const & v0,
 		col_type const & v1,
@@ -110,7 +110,7 @@ namespace glm
 		typename X1, typename Y1, typename Z1, typename W1,
 		typename X2, typename Y2, typename Z2, typename W2,
 		typename X3, typename Y3, typename Z3, typename W3>
-	GLM_FUNC_QUALIFIER tmat3x4<T, P>::tmat3x4
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat3x4<T, P>::tmat3x4
 	(
 		X1 x1, Y1 y1, Z1 z1, W1 w1,
 		X2 x2, Y2 y2, Z2 z2, W2 w2,
@@ -124,7 +124,7 @@ namespace glm
 	
 	template <typename T, precision P>
 	template <typename V1, typename V2, typename V3>
-	GLM_FUNC_QUALIFIER tmat3x4<T, P>::tmat3x4
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat3x4<T, P>::tmat3x4
 	(
 		tvec4<V1, P> const & v1,
 		tvec4<V2, P> const & v2,
@@ -140,7 +140,7 @@ namespace glm
 
 	template <typename T, precision P>
 	template <typename U, precision Q>
-	GLM_FUNC_QUALIFIER tmat3x4<T, P>::tmat3x4(tmat3x4<U, Q> const & m)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat3x4<T, P>::tmat3x4(tmat3x4<U, Q> const & m)
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);
@@ -148,7 +148,7 @@ namespace glm
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x4<T, P>::tmat3x4(tmat2x2<T, P> const & m)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat3x4<T, P>::tmat3x4(tmat2x2<T, P> const & m)
 	{
 		this->value[0] = col_type(m[0], 0, 0);
 		this->value[1] = col_type(m[1], 0, 0);
@@ -156,55 +156,55 @@ namespace glm
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x4<T, P>::tmat3x4(tmat3x3<T, P> const & m)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat3x4<T, P>::tmat3x4(tmat3x3<T, P> const & m)
 	{
 		this->value[0] = col_type(m[0], 0);
 		this->value[1] = col_type(m[1], 0);
 		this->value[2] = col_type(m[2], 0);
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat3x4<T, P>::tmat3x4(tmat4x4<T, P> const & m)
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat3x4<T, P>::tmat3x4(tmat4x4<T, P> const & m)
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);
 		this->value[2] = col_type(m[2]);
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat3x4<T, P>::tmat3x4(tmat2x3<T, P> const & m)
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat3x4<T, P>::tmat3x4(tmat2x3<T, P> const & m)
 	{
 		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);
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat3x4<T, P>::tmat3x4(tmat3x2<T, P> const & m)
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat3x4<T, P>::tmat3x4(tmat3x2<T, P> const & m)
 	{
 		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);
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat3x4<T, P>::tmat3x4(tmat2x4<T, P> const & m)
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat3x4<T, P>::tmat3x4(tmat2x4<T, P> const & m)
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);
 		this->value[2] = col_type(0, 0, 1, 0);
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat3x4<T, P>::tmat3x4(tmat4x2<T, P> const & m)
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat3x4<T, P>::tmat3x4(tmat4x2<T, P> const & m)
 	{
 		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);
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat3x4<T, P>::tmat3x4(tmat4x3<T, P> const & m)
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat3x4<T, P>::tmat3x4(tmat4x3<T, P> const & m)
 	{
 		this->value[0] = col_type(m[0], 0);
 		this->value[1] = col_type(m[1], 0);

glm/detail/type_mat4x2.hpp

@@ -56,19 +56,19 @@ namespace glm
 	public:
 		// -- Constructors --
 
-		GLM_FUNC_DECL tmat4x2() GLM_DEFAULT_CTOR;
-		GLM_FUNC_DECL tmat4x2(tmat4x2<T, P> const & m) GLM_DEFAULT;
+		GLM_FUNC_DECL GLM_CONSTEXPR tmat4x2() GLM_DEFAULT_CTOR;
+		GLM_FUNC_DECL GLM_CONSTEXPR tmat4x2(tmat4x2<T, P> const & m) GLM_DEFAULT;
 		template <precision Q>
-		GLM_FUNC_DECL tmat4x2(tmat4x2<T, Q> const & m);
+		GLM_FUNC_DECL GLM_CONSTEXPR tmat4x2(tmat4x2<T, Q> const & m);
 
-		GLM_FUNC_DECL explicit tmat4x2(ctor);
-		GLM_FUNC_DECL explicit tmat4x2(T scalar);
-		GLM_FUNC_DECL tmat4x2(
+		GLM_FUNC_DECL GLM_CONSTEXPR explicit tmat4x2(ctor);
+		GLM_FUNC_DECL GLM_CONSTEXPR explicit tmat4x2(T scalar);
+		GLM_FUNC_DECL GLM_CONSTEXPR tmat4x2(
 			T x0, T y0,
 			T x1, T y1,
 			T x2, T y2,
 			T x3, T y3);
-		GLM_FUNC_DECL tmat4x2(
+		GLM_FUNC_DECL GLM_CONSTEXPR tmat4x2(
 			col_type const & v0,
 			col_type const & v1,
 			col_type const & v2,
@@ -81,14 +81,14 @@ namespace glm
 			typename X2, typename Y2,
 			typename X3, typename Y3,
 			typename X4, typename Y4>
-		GLM_FUNC_DECL tmat4x2(
+		GLM_FUNC_DECL GLM_CONSTEXPR tmat4x2(
 			X1 x1, Y1 y1,
 			X2 x2, Y2 y2,
 			X3 x3, Y3 y3,
 			X4 x4, Y4 y4);
 
 		template <typename V1, typename V2, typename V3, typename V4>
-		GLM_FUNC_DECL tmat4x2(
+		GLM_FUNC_DECL GLM_CONSTEXPR tmat4x2(
 			tvec2<V1, P> const & v1,
 			tvec2<V2, P> const & v2,
 			tvec2<V3, P> const & v3,
@@ -97,16 +97,16 @@ namespace glm
 		// -- Matrix conversions --
 
 		template <typename U, precision Q>
-		GLM_FUNC_DECL GLM_EXPLICIT tmat4x2(tmat4x2<U, Q> const & m);
-
-		GLM_FUNC_DECL GLM_EXPLICIT tmat4x2(tmat2x2<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat4x2(tmat3x3<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat4x2(tmat4x4<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat4x2(tmat2x3<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat4x2(tmat3x2<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat4x2(tmat2x4<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat4x2(tmat4x3<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat4x2(tmat3x4<T, P> const & x);
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tmat4x2(tmat4x2<U, Q> const & m);
+
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tmat4x2(tmat2x2<T, P> const & x);
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tmat4x2(tmat3x3<T, P> const & x);
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tmat4x2(tmat4x4<T, P> const & x);
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tmat4x2(tmat2x3<T, P> const & x);
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tmat4x2(tmat3x2<T, P> const & x);
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tmat4x2(tmat2x4<T, P> const & x);
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tmat4x2(tmat4x3<T, P> const & x);
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tmat4x2(tmat3x4<T, P> const & x);
 
 		// -- Accesses --
 

glm/detail/type_mat4x2.inl

@@ -43,7 +43,7 @@ namespace glm
 
 #	if !GLM_HAS_DEFAULTED_FUNCTIONS || !defined(GLM_FORCE_NO_CTOR_INIT)
 		template <typename T, precision P> 
-		GLM_FUNC_QUALIFIER tmat4x2<T, P>::tmat4x2()
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat4x2<T, P>::tmat4x2()
 		{
 #			ifndef GLM_FORCE_NO_CTOR_INIT 
 				this->value[0] = col_type(1, 0);
@@ -56,7 +56,7 @@ namespace glm
 
 #	if !GLM_HAS_DEFAULTED_FUNCTIONS
 		template <typename T, precision P>
-		GLM_FUNC_QUALIFIER tmat4x2<T, P>::tmat4x2(tmat4x2<T, P> const & m)
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat4x2<T, P>::tmat4x2(tmat4x2<T, P> const & m)
 		{
 			this->value[0] = m.value[0];
 			this->value[1] = m.value[1];
@@ -67,7 +67,7 @@ namespace glm
 
 	template <typename T, precision P>
 	template <precision Q>
-	GLM_FUNC_QUALIFIER tmat4x2<T, P>::tmat4x2(tmat4x2<T, Q> const & m)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat4x2<T, P>::tmat4x2(tmat4x2<T, Q> const & m)
 	{
 		this->value[0] = m.value[0];
 		this->value[1] = m.value[1];
@@ -76,11 +76,11 @@ namespace glm
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x2<T, P>::tmat4x2(ctor)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat4x2<T, P>::tmat4x2(ctor)
 	{}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x2<T, P>::tmat4x2(T scalar)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat4x2<T, P>::tmat4x2(T scalar)
 	{
 		this->value[0] = col_type(scalar, 0);
 		this->value[1] = col_type(0, scalar);
@@ -89,7 +89,7 @@ namespace glm
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x2<T, P>::tmat4x2
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat4x2<T, P>::tmat4x2
 	(
 		T x0, T y0,
 		T x1, T y1,
@@ -104,7 +104,7 @@ namespace glm
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x2<T, P>::tmat4x2
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat4x2<T, P>::tmat4x2
 	(
 		col_type const & v0,
 		col_type const & v1,
@@ -126,7 +126,7 @@ namespace glm
 		typename X2, typename Y2,
 		typename X3, typename Y3,
 		typename X4, typename Y4>
-	GLM_FUNC_QUALIFIER tmat4x2<T, P>::tmat4x2
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat4x2<T, P>::tmat4x2
 	(
 		X1 x1, Y1 y1,
 		X2 x2, Y2 y2,
@@ -142,7 +142,7 @@ namespace glm
 	
 	template <typename T, precision P>
 	template <typename V1, typename V2, typename V3, typename V4>
-	GLM_FUNC_QUALIFIER tmat4x2<T, P>::tmat4x2
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat4x2<T, P>::tmat4x2
 	(
 		tvec2<V1, P> const & v1,
 		tvec2<V2, P> const & v2,
@@ -160,7 +160,7 @@ namespace glm
 
 	template <typename T, precision P>
 	template <typename U, precision Q>
-	GLM_FUNC_QUALIFIER tmat4x2<T, P>::tmat4x2(tmat4x2<U, Q> const & m)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat4x2<T, P>::tmat4x2(tmat4x2<U, Q> const & m)
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);
@@ -169,7 +169,7 @@ namespace glm
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x2<T, P>::tmat4x2(tmat2x2<T, P> const & m)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat4x2<T, P>::tmat4x2(tmat2x2<T, P> const & m)
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);
@@ -177,8 +177,8 @@ namespace glm
 		this->value[3] = col_type(0);
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat4x2<T, P>::tmat4x2(tmat3x3<T, P> const & m)
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat4x2<T, P>::tmat4x2(tmat3x3<T, P> const & m)
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);
@@ -186,8 +186,8 @@ namespace glm
 		this->value[3] = col_type(0);
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat4x2<T, P>::tmat4x2(tmat4x4<T, P> const & m)
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat4x2<T, P>::tmat4x2(tmat4x4<T, P> const & m)
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);
@@ -195,8 +195,8 @@ namespace glm
 		this->value[3] = col_type(m[3]);
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat4x2<T, P>::tmat4x2(tmat2x3<T, P> const & m)
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat4x2<T, P>::tmat4x2(tmat2x3<T, P> const & m)
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);
@@ -204,8 +204,8 @@ namespace glm
 		this->value[3] = col_type(0);
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat4x2<T, P>::tmat4x2(tmat3x2<T, P> const & m)
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat4x2<T, P>::tmat4x2(tmat3x2<T, P> const & m)
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);
@@ -213,8 +213,8 @@ namespace glm
 		this->value[3] = col_type(0);
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat4x2<T, P>::tmat4x2(tmat2x4<T, P> const & m)
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat4x2<T, P>::tmat4x2(tmat2x4<T, P> const & m)
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);
@@ -222,8 +222,8 @@ namespace glm
 		this->value[3] = col_type(0);
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat4x2<T, P>::tmat4x2(tmat4x3<T, P> const & m)
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat4x2<T, P>::tmat4x2(tmat4x3<T, P> const & m)
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);
@@ -231,8 +231,8 @@ namespace glm
 		this->value[3] = col_type(m[3]);
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat4x2<T, P>::tmat4x2(tmat3x4<T, P> const & m)
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat4x2<T, P>::tmat4x2(tmat3x4<T, P> const & m)
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);

glm/detail/type_mat4x3.hpp

@@ -56,19 +56,19 @@ namespace glm
 	public:
 		// -- Constructors --
 
-		GLM_FUNC_DECL tmat4x3() GLM_DEFAULT_CTOR;
-		GLM_FUNC_DECL tmat4x3(tmat4x3<T, P> const & m) GLM_DEFAULT;
+		GLM_FUNC_DECL GLM_CONSTEXPR tmat4x3() GLM_DEFAULT_CTOR;
+		GLM_FUNC_DECL GLM_CONSTEXPR tmat4x3(tmat4x3<T, P> const & m) GLM_DEFAULT;
 		template <precision Q>
-		GLM_FUNC_DECL tmat4x3(tmat4x3<T, Q> const & m);
+		GLM_FUNC_DECL GLM_CONSTEXPR tmat4x3(tmat4x3<T, Q> const & m);
 
-		GLM_FUNC_DECL explicit tmat4x3(ctor);
-		GLM_FUNC_DECL explicit tmat4x3(T const & x);
-		GLM_FUNC_DECL tmat4x3(
+		GLM_FUNC_DECL GLM_CONSTEXPR explicit tmat4x3(ctor);
+		GLM_FUNC_DECL GLM_CONSTEXPR explicit tmat4x3(T const & x);
+		GLM_FUNC_DECL GLM_CONSTEXPR tmat4x3(
 			T const & x0, T const & y0, T const & z0,
 			T const & x1, T const & y1, T const & z1,
 			T const & x2, T const & y2, T const & z2,
 			T const & x3, T const & y3, T const & z3);
-		GLM_FUNC_DECL tmat4x3(
+		GLM_FUNC_DECL GLM_CONSTEXPR tmat4x3(
 			col_type const & v0,
 			col_type const & v1,
 			col_type const & v2,
@@ -81,14 +81,14 @@ namespace glm
 			typename X2, typename Y2, typename Z2,
 			typename X3, typename Y3, typename Z3,
 			typename X4, typename Y4, typename Z4>
-		GLM_FUNC_DECL tmat4x3(
+		GLM_FUNC_DECL GLM_CONSTEXPR tmat4x3(
 			X1 const & x1, Y1 const & y1, Z1 const & z1,
 			X2 const & x2, Y2 const & y2, Z2 const & z2,
 			X3 const & x3, Y3 const & y3, Z3 const & z3,
 			X4 const & x4, Y4 const & y4, Z4 const & z4);
 
 		template <typename V1, typename V2, typename V3, typename V4>
-		GLM_FUNC_DECL tmat4x3(
+		GLM_FUNC_DECL GLM_CONSTEXPR tmat4x3(
 			tvec3<V1, P> const & v1,
 			tvec3<V2, P> const & v2,
 			tvec3<V3, P> const & v3,
@@ -97,16 +97,16 @@ namespace glm
 		// -- Matrix conversions --
 
 		template <typename U, precision Q>
-		GLM_FUNC_DECL GLM_EXPLICIT tmat4x3(tmat4x3<U, Q> const & m);
-
-		GLM_FUNC_DECL GLM_EXPLICIT tmat4x3(tmat2x2<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat4x3(tmat3x3<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat4x3(tmat4x4<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat4x3(tmat2x3<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat4x3(tmat3x2<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat4x3(tmat2x4<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat4x3(tmat4x2<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat4x3(tmat3x4<T, P> const & x);
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tmat4x3(tmat4x3<U, Q> const & m);
+
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tmat4x3(tmat2x2<T, P> const & x);
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tmat4x3(tmat3x3<T, P> const & x);
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tmat4x3(tmat4x4<T, P> const & x);
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tmat4x3(tmat2x3<T, P> const & x);
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tmat4x3(tmat3x2<T, P> const & x);
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tmat4x3(tmat2x4<T, P> const & x);
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tmat4x3(tmat4x2<T, P> const & x);
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tmat4x3(tmat3x4<T, P> const & x);
 
 		// -- Accesses --
 

glm/detail/type_mat4x3.inl

@@ -35,8 +35,8 @@ namespace glm
 	// -- Constructors --
 
 #	if !GLM_HAS_DEFAULTED_FUNCTIONS || !defined(GLM_FORCE_NO_CTOR_INIT)
-		template <typename T, precision P> 
-		GLM_FUNC_QUALIFIER tmat4x3<T, P>::tmat4x3()
+		template <typename T, precision P>
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat4x3<T, P>::tmat4x3()
 		{
 #			ifndef GLM_FORCE_NO_CTOR_INIT 
 				this->value[0] = col_type(1, 0, 0);
@@ -49,7 +49,7 @@ namespace glm
 
 #	if !GLM_HAS_DEFAULTED_FUNCTIONS
 		template <typename T, precision P>
-		GLM_FUNC_QUALIFIER tmat4x3<T, P>::tmat4x3(tmat4x3<T, P> const & m)
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat4x3<T, P>::tmat4x3(tmat4x3<T, P> const & m)
 		{
 			this->value[0] = m.value[0];
 			this->value[1] = m.value[1];
@@ -60,7 +60,7 @@ namespace glm
 
 	template <typename T, precision P>
 	template <precision Q>
-	GLM_FUNC_QUALIFIER tmat4x3<T, P>::tmat4x3(tmat4x3<T, Q> const & m)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat4x3<T, P>::tmat4x3(tmat4x3<T, Q> const & m)
 	{
 		this->value[0] = m.value[0];
 		this->value[1] = m.value[1];
@@ -68,12 +68,12 @@ namespace glm
 		this->value[3] = m.value[3];
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat4x3<T, P>::tmat4x3(ctor)
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat4x3<T, P>::tmat4x3(ctor)
 	{}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat4x3<T, P>::tmat4x3(T const & s)
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat4x3<T, P>::tmat4x3(T const & s)
 	{
 		this->value[0] = col_type(s, 0, 0);
 		this->value[1] = col_type(0, s, 0);
@@ -81,8 +81,8 @@ namespace glm
 		this->value[3] = col_type(0, 0, 0);
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat4x3<T, P>::tmat4x3
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat4x3<T, P>::tmat4x3
 	(
 		T const & x0, T const & y0, T const & z0,
 		T const & x1, T const & y1, T const & z1,
@@ -96,11 +96,11 @@ namespace glm
 		this->value[3] = col_type(x3, y3, z3);
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat4x3<T, P>::tmat4x3
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat4x3<T, P>::tmat4x3
 	(
-		col_type const & v0, 
-		col_type const & v1, 
+		col_type const & v0,
+		col_type const & v1,
 		col_type const & v2,
 		col_type const & v3
 	)
@@ -113,13 +113,13 @@ namespace glm
 
 	// -- Conversion constructors --
 
-	template <typename T, precision P> 
+	template <typename T, precision P>
 	template <
 		typename X1, typename Y1, typename Z1,
 		typename X2, typename Y2, typename Z2,
 		typename X3, typename Y3, typename Z3,
 		typename X4, typename Y4, typename Z4>
-	GLM_FUNC_QUALIFIER tmat4x3<T, P>::tmat4x3
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat4x3<T, P>::tmat4x3
 	(
 		X1 const & x1, Y1 const & y1, Z1 const & z1,
 		X2 const & x2, Y2 const & y2, Z2 const & z2,
@@ -135,7 +135,7 @@ namespace glm
 	
 	template <typename T, precision P>
 	template <typename V1, typename V2, typename V3, typename V4>
-	GLM_FUNC_QUALIFIER tmat4x3<T, P>::tmat4x3
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat4x3<T, P>::tmat4x3
 	(
 		tvec3<V1, P> const & v1,
 		tvec3<V2, P> const & v2,
@@ -153,7 +153,7 @@ namespace glm
 
 	template <typename T, precision P>
 	template <typename U, precision Q>
-	GLM_FUNC_QUALIFIER tmat4x3<T, P>::tmat4x3(tmat4x3<U, Q> const & m)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat4x3<T, P>::tmat4x3(tmat4x3<U, Q> const & m)
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);
@@ -161,8 +161,8 @@ namespace glm
 		this->value[3] = col_type(m[3]);
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat4x3<T, P>::tmat4x3(tmat2x2<T, P> const & m)
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat4x3<T, P>::tmat4x3(tmat2x2<T, P> const & m)
 	{
 		this->value[0] = col_type(m[0], 0);
 		this->value[1] = col_type(m[1], 0);
@@ -170,8 +170,8 @@ namespace glm
 		this->value[3] = col_type(0);
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat4x3<T, P>::tmat4x3(tmat3x3<T, P> const & m)
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat4x3<T, P>::tmat4x3(tmat3x3<T, P> const & m)
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);
@@ -180,7 +180,7 @@ namespace glm
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x3<T, P>::tmat4x3(tmat4x4<T, P> const & m)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat4x3<T, P>::tmat4x3(tmat4x4<T, P> const & m)
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);
@@ -188,8 +188,8 @@ namespace glm
 		this->value[3] = col_type(m[3]);
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat4x3<T, P>::tmat4x3(tmat2x3<T, P> const & m)
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat4x3<T, P>::tmat4x3(tmat2x3<T, P> const & m)
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);
@@ -197,8 +197,8 @@ namespace glm
 		this->value[3] = col_type(0);
 	}
 
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat4x3<T, P>::tmat4x3(tmat3x2<T, P> const & m)
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat4x3<T, P>::tmat4x3(tmat3x2<T, P> const & m)
 	{
 		this->value[0] = col_type(m[0], 0);
 		this->value[1] = col_type(m[1], 0);
@@ -207,7 +207,7 @@ namespace glm
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x3<T, P>::tmat4x3(tmat2x4<T, P> const & m)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat4x3<T, P>::tmat4x3(tmat2x4<T, P> const & m)
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);
@@ -216,7 +216,7 @@ namespace glm
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x3<T, P>::tmat4x3(tmat4x2<T, P> const & m)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat4x3<T, P>::tmat4x3(tmat4x2<T, P> const & m)
 	{
 		this->value[0] = col_type(m[0], 0);
 		this->value[1] = col_type(m[1], 0);
@@ -225,7 +225,7 @@ namespace glm
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x3<T, P>::tmat4x3(tmat3x4<T, P> const & m)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat4x3<T, P>::tmat4x3(tmat3x4<T, P> const & m)
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);

glm/detail/type_mat4x4.hpp

@@ -55,19 +55,19 @@ namespace glm
 	public:
 		// -- Constructors --
 
-		GLM_FUNC_DECL tmat4x4() GLM_DEFAULT_CTOR;
-		GLM_FUNC_DECL tmat4x4(tmat4x4<T, P> const & m) GLM_DEFAULT;
+		GLM_FUNC_DECL GLM_CONSTEXPR tmat4x4() GLM_DEFAULT_CTOR;
+		GLM_FUNC_DECL GLM_CONSTEXPR tmat4x4(tmat4x4<T, P> const & m) GLM_DEFAULT;
 		template <precision Q>
-		GLM_FUNC_DECL tmat4x4(tmat4x4<T, Q> const & m);
+		GLM_FUNC_DECL GLM_CONSTEXPR tmat4x4(tmat4x4<T, Q> const & m);
 
-		GLM_FUNC_DECL explicit tmat4x4(ctor);
-		GLM_FUNC_DECL explicit tmat4x4(T const & x);
-		GLM_FUNC_DECL tmat4x4(
+		GLM_FUNC_DECL GLM_CONSTEXPR explicit tmat4x4(ctor);
+		GLM_FUNC_DECL GLM_CONSTEXPR explicit tmat4x4(T const & x);
+		GLM_FUNC_DECL GLM_CONSTEXPR tmat4x4(
 			T const & x0, T const & y0, T const & z0, T const & w0,
 			T const & x1, T const & y1, T const & z1, T const & w1,
 			T const & x2, T const & y2, T const & z2, T const & w2,
 			T const & x3, T const & y3, T const & z3, T const & w3);
-		GLM_FUNC_DECL tmat4x4(
+		GLM_FUNC_DECL GLM_CONSTEXPR tmat4x4(
 			col_type const & v0,
 			col_type const & v1,
 			col_type const & v2,
@@ -80,14 +80,14 @@ namespace glm
 			typename X2, typename Y2, typename Z2, typename W2,
 			typename X3, typename Y3, typename Z3, typename W3,
 			typename X4, typename Y4, typename Z4, typename W4>
-		GLM_FUNC_DECL tmat4x4(
+		GLM_FUNC_DECL GLM_CONSTEXPR tmat4x4(
 			X1 const & x1, Y1 const & y1, Z1 const & z1, W1 const & w1,
 			X2 const & x2, Y2 const & y2, Z2 const & z2, W2 const & w2,
 			X3 const & x3, Y3 const & y3, Z3 const & z3, W3 const & w3,
 			X4 const & x4, Y4 const & y4, Z4 const & z4, W4 const & w4);
 
 		template <typename V1, typename V2, typename V3, typename V4>
-		GLM_FUNC_DECL tmat4x4(
+		GLM_FUNC_DECL GLM_CONSTEXPR tmat4x4(
 			tvec4<V1, P> const & v1,
 			tvec4<V2, P> const & v2,
 			tvec4<V3, P> const & v3,
@@ -96,16 +96,16 @@ namespace glm
 		// -- Matrix conversions --
 
 		template <typename U, precision Q>
-		GLM_FUNC_DECL GLM_EXPLICIT tmat4x4(tmat4x4<U, Q> const & m);
-
-		GLM_FUNC_DECL GLM_EXPLICIT tmat4x4(tmat2x2<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat4x4(tmat3x3<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat4x4(tmat2x3<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat4x4(tmat3x2<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat4x4(tmat2x4<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat4x4(tmat4x2<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat4x4(tmat3x4<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat4x4(tmat4x3<T, P> const & x);
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tmat4x4(tmat4x4<U, Q> const & m);
+
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tmat4x4(tmat2x2<T, P> const & x);
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tmat4x4(tmat3x3<T, P> const & x);
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tmat4x4(tmat2x3<T, P> const & x);
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tmat4x4(tmat3x2<T, P> const & x);
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tmat4x4(tmat2x4<T, P> const & x);
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tmat4x4(tmat4x2<T, P> const & x);
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tmat4x4(tmat3x4<T, P> const & x);
+		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tmat4x4(tmat4x3<T, P> const & x);
 
 		// -- Accesses --
 

glm/detail/type_mat4x4.inl

@@ -96,7 +96,7 @@ namespace detail
 
 #	if !GLM_HAS_DEFAULTED_FUNCTIONS || !defined(GLM_FORCE_NO_CTOR_INIT)
 		template <typename T, precision P>
-		GLM_FUNC_QUALIFIER tmat4x4<T, P>::tmat4x4()
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat4x4<T, P>::tmat4x4()
 		{
 #			ifndef GLM_FORCE_NO_CTOR_INIT 
 				this->value[0] = col_type(1, 0, 0, 0);
@@ -109,7 +109,7 @@ namespace detail
 
 #	if !GLM_HAS_DEFAULTED_FUNCTIONS
 		template <typename T, precision P>
-		GLM_FUNC_QUALIFIER tmat4x4<T, P>::tmat4x4(tmat4x4<T, P> const & m)
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat4x4<T, P>::tmat4x4(tmat4x4<T, P> const & m)
 		{
 			this->value[0] = m[0];
 			this->value[1] = m[1];
@@ -120,7 +120,7 @@ namespace detail
 
 	template <typename T, precision P>
 	template <precision Q>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P>::tmat4x4(tmat4x4<T, Q> const & m)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat4x4<T, P>::tmat4x4(tmat4x4<T, Q> const & m)
 	{
 		this->value[0] = m[0];
 		this->value[1] = m[1];
@@ -129,11 +129,11 @@ namespace detail
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P>::tmat4x4(ctor)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat4x4<T, P>::tmat4x4(ctor)
 	{}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P>::tmat4x4(T const & s)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat4x4<T, P>::tmat4x4(T const & s)
 	{
 		this->value[0] = col_type(s, 0, 0, 0);
 		this->value[1] = col_type(0, s, 0, 0);
@@ -142,7 +142,7 @@ namespace detail
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P>::tmat4x4
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat4x4<T, P>::tmat4x4
 	(
 		T const & x0, T const & y0, T const & z0, T const & w0,
 		T const & x1, T const & y1, T const & z1, T const & w1,
@@ -157,7 +157,7 @@ namespace detail
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P>::tmat4x4
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat4x4<T, P>::tmat4x4
 	(
 		col_type const & v0,
 		col_type const & v1,
@@ -173,7 +173,7 @@ namespace detail
 
 	template <typename T, precision P>
 	template <typename U, precision Q>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P>::tmat4x4
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat4x4<T, P>::tmat4x4
 	(
 		tmat4x4<U, Q> const & m
 	)
@@ -192,7 +192,7 @@ namespace detail
 		typename X2, typename Y2, typename Z2, typename W2,
 		typename X3, typename Y3, typename Z3, typename W3,
 		typename X4, typename Y4, typename Z4, typename W4>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P>::tmat4x4
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat4x4<T, P>::tmat4x4
 	(
 		X1 const & x1, Y1 const & y1, Z1 const & z1, W1 const & w1,
 		X2 const & x2, Y2 const & y2, Z2 const & z2, W2 const & w2,
@@ -228,7 +228,7 @@ namespace detail
 	
 	template <typename T, precision P>
 	template <typename V1, typename V2, typename V3, typename V4>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P>::tmat4x4
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat4x4<T, P>::tmat4x4
 	(
 		tvec4<V1, P> const & v1,
 		tvec4<V2, P> const & v2,
@@ -250,7 +250,7 @@ namespace detail
 	// -- Matrix conversions --
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P>::tmat4x4(tmat2x2<T, P> const & m)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat4x4<T, P>::tmat4x4(tmat2x2<T, P> const & m)
 	{
 		this->value[0] = col_type(m[0], 0, 0);
 		this->value[1] = col_type(m[1], 0, 0);
@@ -259,7 +259,7 @@ namespace detail
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P>::tmat4x4(tmat3x3<T, P> const & m)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat4x4<T, P>::tmat4x4(tmat3x3<T, P> const & m)
 	{
 		this->value[0] = col_type(m[0], 0);
 		this->value[1] = col_type(m[1], 0);
@@ -268,7 +268,7 @@ namespace detail
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P>::tmat4x4(tmat2x3<T, P> const & m)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat4x4<T, P>::tmat4x4(tmat2x3<T, P> const & m)
 	{
 		this->value[0] = col_type(m[0], 0);
 		this->value[1] = col_type(m[1], 0);
@@ -277,7 +277,7 @@ namespace detail
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P>::tmat4x4(tmat3x2<T, P> const & m)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat4x4<T, P>::tmat4x4(tmat3x2<T, P> const & m)
 	{
 		this->value[0] = col_type(m[0], 0, 0);
 		this->value[1] = col_type(m[1], 0, 0);
@@ -286,7 +286,7 @@ namespace detail
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P>::tmat4x4(tmat2x4<T, P> const & m)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat4x4<T, P>::tmat4x4(tmat2x4<T, P> const & m)
 	{
 		this->value[0] = m[0];
 		this->value[1] = m[1];
@@ -295,7 +295,7 @@ namespace detail
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P>::tmat4x4(tmat4x2<T, P> const & m)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat4x4<T, P>::tmat4x4(tmat4x2<T, P> const & m)
 	{
 		this->value[0] = col_type(m[0], 0, 0);
 		this->value[1] = col_type(m[1], 0, 0);
@@ -304,7 +304,7 @@ namespace detail
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P>::tmat4x4(tmat3x4<T, P> const & m)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat4x4<T, P>::tmat4x4(tmat3x4<T, P> const & m)
 	{
 		this->value[0] = m[0];
 		this->value[1] = m[1];
@@ -313,7 +313,7 @@ namespace detail
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P>::tmat4x4(tmat4x3<T, P> const & m)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tmat4x4<T, P>::tmat4x4(tmat4x3<T, P> const & m)
 	{
 		this->value[0] = col_type(m[0], 0);
 		this->value[1] = col_type(m[1], 0);

glm/detail/type_vec1.inl

@@ -36,7 +36,7 @@ namespace glm
 
 #	if !GLM_HAS_DEFAULTED_FUNCTIONS || !defined(GLM_FORCE_NO_CTOR_INIT)
 		template <typename T, precision P>
-		GLM_FUNC_QUALIFIER tvec1<T, P>::tvec1()
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec1<T, P>::tvec1()
 #			ifndef GLM_FORCE_NO_CTOR_INIT
 				: x(0)
 #			endif
@@ -45,25 +45,25 @@ namespace glm
 
 #	if !GLM_HAS_DEFAULTED_FUNCTIONS
 		template <typename T, precision P>
-		GLM_FUNC_QUALIFIER tvec1<T, P>::tvec1(tvec1<T, P> const & v)
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec1<T, P>::tvec1(tvec1<T, P> const & v)
 			: x(v.x)
 		{}
 #	endif//!GLM_HAS_DEFAULTED_FUNCTIONS
 
 	template <typename T, precision P>
 	template <precision Q>
-	GLM_FUNC_QUALIFIER tvec1<T, P>::tvec1(tvec1<T, Q> const & v)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec1<T, P>::tvec1(tvec1<T, Q> const & v)
 		: x(v.x)
 	{}
 
 	// -- Explicit basic constructors --
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec1<T, P>::tvec1(ctor)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec1<T, P>::tvec1(ctor)
 	{}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER  tvec1<T, P>::tvec1(T scalar)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec1<T, P>::tvec1(T scalar)
 		: x(scalar)
 	{}
 
@@ -71,25 +71,25 @@ namespace glm
 
 	template <typename T, precision P>
 	template <typename U, precision Q>
-	GLM_FUNC_QUALIFIER tvec1<T, P>::tvec1(tvec1<U, Q> const & v)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec1<T, P>::tvec1(tvec1<U, Q> const & v)
 		: x(static_cast<T>(v.x))
 	{}
 
 	template <typename T, precision P>
 	template <typename U, precision Q>
-	GLM_FUNC_QUALIFIER tvec1<T, P>::tvec1(tvec2<U, Q> const & v)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec1<T, P>::tvec1(tvec2<U, Q> const & v)
 		: x(static_cast<T>(v.x))
 	{}
 
 	template <typename T, precision P>
 	template <typename U, precision Q>
-	GLM_FUNC_QUALIFIER tvec1<T, P>::tvec1(tvec3<U, Q> const & v)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec1<T, P>::tvec1(tvec3<U, Q> const & v)
 		: x(static_cast<T>(v.x))
 	{}
 
 	template <typename T, precision P>
 	template <typename U, precision Q>
-	GLM_FUNC_QUALIFIER tvec1<T, P>::tvec1(tvec4<U, Q> const & v)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec1<T, P>::tvec1(tvec4<U, Q> const & v)
 		: x(static_cast<T>(v.x))
 	{}
 

glm/detail/type_vec2.inl

@@ -45,7 +45,7 @@ namespace glm
 
 #	if !GLM_HAS_DEFAULTED_FUNCTIONS || !defined(GLM_FORCE_NO_CTOR_INIT)
 		template <typename T, precision P>
-		GLM_FUNC_QUALIFIER tvec2<T, P>::tvec2()
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec2<T, P>::tvec2()
 #			ifndef GLM_FORCE_NO_CTOR_INIT
 				: x(0), y(0)
 #			endif
@@ -54,30 +54,30 @@ namespace glm
 
 #	if !GLM_HAS_DEFAULTED_FUNCTIONS
 		template <typename T, precision P>
-		GLM_FUNC_QUALIFIER tvec2<T, P>::tvec2(tvec2<T, P> const & v)
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec2<T, P>::tvec2(tvec2<T, P> const & v)
 			: x(v.x), y(v.y)
 		{}
 #	endif//!GLM_HAS_DEFAULTED_FUNCTIONS
 
 	template <typename T, precision P>
 	template <precision Q>
-	GLM_FUNC_QUALIFIER tvec2<T, P>::tvec2(tvec2<T, Q> const & v)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec2<T, P>::tvec2(tvec2<T, Q> const & v)
 		: x(v.x), y(v.y)
 	{}
 
 	// -- Explicit basic constructors --
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec2<T, P>::tvec2(ctor)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec2<T, P>::tvec2(ctor)
 	{}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec2<T, P>::tvec2(T scalar)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec2<T, P>::tvec2(T scalar)
 		: x(scalar), y(scalar)
 	{}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec2<T, P>::tvec2(T s1, T s2)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec2<T, P>::tvec2(T s1, T s2)
 		: x(s1), y(s2)
 	{}
 
@@ -85,14 +85,14 @@ namespace glm
 
 	template <typename T, precision P>
 	template <typename A, typename B>
-	GLM_FUNC_QUALIFIER tvec2<T, P>::tvec2(A a, B b)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec2<T, P>::tvec2(A a, B b)
 		: x(static_cast<T>(a))
 		, y(static_cast<T>(b))
 	{}
 
 	template <typename T, precision P>
 	template <typename A, typename B>
-	GLM_FUNC_QUALIFIER tvec2<T, P>::tvec2(tvec1<A, P> const & a, tvec1<B, P> const & b)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec2<T, P>::tvec2(tvec1<A, P> const & a, tvec1<B, P> const & b)
 		: x(static_cast<T>(a.x))
 		, y(static_cast<T>(b.x))
 	{}
@@ -101,21 +101,21 @@ namespace glm
 
 	template <typename T, precision P>
 	template <typename U, precision Q>
-	GLM_FUNC_QUALIFIER tvec2<T, P>::tvec2(tvec2<U, Q> const & v)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec2<T, P>::tvec2(tvec2<U, Q> const & v)
 		: x(static_cast<T>(v.x))
 		, y(static_cast<T>(v.y))
 	{}
 
 	template <typename T, precision P>
 	template <typename U, precision Q>
-	GLM_FUNC_QUALIFIER tvec2<T, P>::tvec2(tvec3<U, Q> const & v)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec2<T, P>::tvec2(tvec3<U, Q> const & v)
 		: x(static_cast<T>(v.x))
 		, y(static_cast<T>(v.y))
 	{}
 
 	template <typename T, precision P>
 	template <typename U, precision Q>
-	GLM_FUNC_QUALIFIER tvec2<T, P>::tvec2(tvec4<U, Q> const & v)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec2<T, P>::tvec2(tvec4<U, Q> const & v)
 		: x(static_cast<T>(v.x))
 		, y(static_cast<T>(v.y))
 	{}

glm/detail/type_vec3.inl

@@ -62,7 +62,7 @@ namespace glm
 
 #	if !GLM_HAS_DEFAULTED_FUNCTIONS || !defined(GLM_FORCE_NO_CTOR_INIT)
 		template <typename T, precision P>
-		GLM_FUNC_QUALIFIER tvec3<T, P>::tvec3()
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec3<T, P>::tvec3()
 #			ifndef GLM_FORCE_NO_CTOR_INIT 
 				: x(0), y(0), z(0)
 #			endif
@@ -71,30 +71,30 @@ namespace glm
 
 #	if !GLM_HAS_DEFAULTED_FUNCTIONS
 		template <typename T, precision P>
-		GLM_FUNC_QUALIFIER tvec3<T, P>::tvec3(tvec3<T, P> const & v)
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec3<T, P>::tvec3(tvec3<T, P> const & v)
 			: x(v.x), y(v.y), z(v.z)
 		{}
 #	endif//!GLM_HAS_DEFAULTED_FUNCTIONS
 
 	template <typename T, precision P>
 	template <precision Q>
-	GLM_FUNC_QUALIFIER tvec3<T, P>::tvec3(tvec3<T, Q> const & v)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec3<T, P>::tvec3(tvec3<T, Q> const & v)
 		: x(v.x), y(v.y), z(v.z)
 	{}
 
 	// -- Explicit basic constructors --
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P>::tvec3(ctor)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec3<T, P>::tvec3(ctor)
 	{}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P>::tvec3(T scalar)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec3<T, P>::tvec3(T scalar)
 		: x(scalar), y(scalar), z(scalar)
 	{}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P>::tvec3(T a, T b, T c)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec3<T, P>::tvec3(T a, T b, T c)
 		: x(a), y(b), z(c)
 	{}
 
@@ -102,7 +102,7 @@ namespace glm
 
 	template <typename T, precision P>
 	template <typename A, typename B, typename C>
-	GLM_FUNC_QUALIFIER tvec3<T, P>::tvec3(A a, B b, C c) :
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec3<T, P>::tvec3(A a, B b, C c) :
 		x(static_cast<T>(a)),
 		y(static_cast<T>(b)),
 		z(static_cast<T>(c))
@@ -110,7 +110,7 @@ namespace glm
 
 	template <typename T, precision P>
 	template <typename A, typename B, typename C>
-	GLM_FUNC_QUALIFIER tvec3<T, P>::tvec3(tvec1<A, P> const & a, tvec1<B, P> const & b, tvec1<C, P> const & c) :
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec3<T, P>::tvec3(tvec1<A, P> const & a, tvec1<B, P> const & b, tvec1<C, P> const & c) :
 		x(static_cast<T>(a)),
 		y(static_cast<T>(b)),
 		z(static_cast<T>(c))
@@ -120,7 +120,7 @@ namespace glm
 
 	template <typename T, precision P>
 	template <typename A, typename B, precision Q>
-	GLM_FUNC_QUALIFIER tvec3<T, P>::tvec3(tvec2<A, Q> const & a, B b) :
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec3<T, P>::tvec3(tvec2<A, Q> const & a, B b) :
 		x(static_cast<T>(a.x)),
 		y(static_cast<T>(a.y)),
 		z(static_cast<T>(b))
@@ -128,7 +128,7 @@ namespace glm
 
 	template <typename T, precision P>
 	template <typename A, typename B, precision Q>
-	GLM_FUNC_QUALIFIER tvec3<T, P>::tvec3(tvec2<A, Q> const & a, tvec1<B, Q> const & b) :
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec3<T, P>::tvec3(tvec2<A, Q> const & a, tvec1<B, Q> const & b) :
 		x(static_cast<T>(a.x)),
 		y(static_cast<T>(a.y)),
 		z(static_cast<T>(b.x))
@@ -136,7 +136,7 @@ namespace glm
 
 	template <typename T, precision P>
 	template <typename A, typename B, precision Q>
-	GLM_FUNC_QUALIFIER tvec3<T, P>::tvec3(A a, tvec2<B, Q> const & b) :
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec3<T, P>::tvec3(A a, tvec2<B, Q> const & b) :
 		x(static_cast<T>(a)),
 		y(static_cast<T>(b.x)),
 		z(static_cast<T>(b.y))
@@ -144,7 +144,7 @@ namespace glm
 
 	template <typename T, precision P>
 	template <typename A, typename B, precision Q>
-	GLM_FUNC_QUALIFIER tvec3<T, P>::tvec3(tvec1<A, Q> const & a, tvec2<B, Q> const & b) :
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec3<T, P>::tvec3(tvec1<A, Q> const & a, tvec2<B, Q> const & b) :
 		x(static_cast<T>(a.x)),
 		y(static_cast<T>(b.x)),
 		z(static_cast<T>(b.y))
@@ -152,7 +152,7 @@ namespace glm
 
 	template <typename T, precision P>
 	template <typename U, precision Q>
-	GLM_FUNC_QUALIFIER tvec3<T, P>::tvec3(tvec3<U, Q> const & v) :
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec3<T, P>::tvec3(tvec3<U, Q> const & v) :
 		x(static_cast<T>(v.x)),
 		y(static_cast<T>(v.y)),
 		z(static_cast<T>(v.z))
@@ -160,7 +160,7 @@ namespace glm
 
 	template <typename T, precision P>
 	template <typename U, precision Q>
-	GLM_FUNC_QUALIFIER tvec3<T, P>::tvec3(tvec4<U, Q> const & v) :
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec3<T, P>::tvec3(tvec4<U, Q> const & v) :
 		x(static_cast<T>(v.x)),
 		y(static_cast<T>(v.y)),
 		z(static_cast<T>(v.z))

glm/detail/type_vec4.inl

@@ -36,7 +36,7 @@ namespace glm
 
 #	if !GLM_HAS_DEFAULTED_FUNCTIONS || !defined(GLM_FORCE_NO_CTOR_INIT)
 		template <typename T, precision P>
-		GLM_FUNC_QUALIFIER tvec4<T, P>::tvec4()
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec4<T, P>::tvec4()
 #			ifndef GLM_FORCE_NO_CTOR_INIT
 				: x(0), y(0), z(0), w(0)
 #			endif
@@ -45,30 +45,30 @@ namespace glm
 
 #	if !GLM_HAS_DEFAULTED_FUNCTIONS
 		template <typename T, precision P>
-		GLM_FUNC_QUALIFIER tvec4<T, P>::tvec4(tvec4<T, P> const & v)
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec4<T, P>::tvec4(tvec4<T, P> const & v)
 			: x(v.x), y(v.y), z(v.z), w(v.w)
 		{}
 #	endif//!GLM_HAS_DEFAULTED_FUNCTIONS
 
 	template <typename T, precision P>
 	template <precision Q>
-	GLM_FUNC_QUALIFIER tvec4<T, P>::tvec4(tvec4<T, Q> const & v)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec4<T, P>::tvec4(tvec4<T, Q> const & v)
 		: x(v.x), y(v.y), z(v.z), w(v.w)
 	{}
 
 	// -- Explicit basic constructors --
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P>::tvec4(ctor)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec4<T, P>::tvec4(ctor)
 	{}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P>::tvec4(T scalar)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec4<T, P>::tvec4(T scalar)
 		: x(scalar), y(scalar), z(scalar), w(scalar)
 	{}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P>::tvec4(T a, T b, T c, T d)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec4<T, P>::tvec4(T a, T b, T c, T d)
 		: x(a), y(b), z(c), w(d)
 	{}
 
@@ -76,7 +76,7 @@ namespace glm
 
 	template <typename T, precision P>
 	template <typename A, typename B, typename C, typename D>
-	GLM_FUNC_QUALIFIER tvec4<T, P>::tvec4(A a, B b, C c, D d) :
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec4<T, P>::tvec4(A a, B b, C c, D d) :
 		x(static_cast<T>(a)),
 		y(static_cast<T>(b)),
 		z(static_cast<T>(c)),
@@ -85,7 +85,7 @@ namespace glm
 
 	template <typename T, precision P>
 	template <typename A, typename B, typename C, typename D>
-	GLM_FUNC_QUALIFIER tvec4<T, P>::tvec4(tvec1<A, P> const & a, tvec1<B, P> const & b, tvec1<C, P> const & c, tvec1<D, P> const & d) :
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec4<T, P>::tvec4(tvec1<A, P> const & a, tvec1<B, P> const & b, tvec1<C, P> const & c, tvec1<D, P> const & d) :
 		x(static_cast<T>(a.x)),
 		y(static_cast<T>(b.x)),
 		z(static_cast<T>(c.x)),
@@ -96,7 +96,7 @@ namespace glm
 
 	template <typename T, precision P>
 	template <typename A, typename B, typename C, precision Q>
-	GLM_FUNC_QUALIFIER tvec4<T, P>::tvec4(tvec2<A, Q> const & a, B b, C c) :
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec4<T, P>::tvec4(tvec2<A, Q> const & a, B b, C c) :
 		x(static_cast<T>(a.x)),
 		y(static_cast<T>(a.y)),
 		z(static_cast<T>(b)),
@@ -105,7 +105,7 @@ namespace glm
 
 	template <typename T, precision P>
 	template <typename A, typename B, typename C, precision Q>
-	GLM_FUNC_QUALIFIER tvec4<T, P>::tvec4(tvec2<A, Q> const & a, tvec1<B, Q> const & b, tvec1<C, Q> const & c) :
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec4<T, P>::tvec4(tvec2<A, Q> const & a, tvec1<B, Q> const & b, tvec1<C, Q> const & c) :
 		x(static_cast<T>(a.x)),
 		y(static_cast<T>(a.y)),
 		z(static_cast<T>(b.x)),
@@ -114,7 +114,7 @@ namespace glm
 
 	template <typename T, precision P>
 	template <typename A, typename B, typename C, precision Q>
-	GLM_FUNC_QUALIFIER tvec4<T, P>::tvec4(A s1, tvec2<B, Q> const & v, C s2) :
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec4<T, P>::tvec4(A s1, tvec2<B, Q> const & v, C s2) :
 		x(static_cast<T>(s1)),
 		y(static_cast<T>(v.x)),
 		z(static_cast<T>(v.y)),
@@ -123,7 +123,7 @@ namespace glm
 
 	template <typename T, precision P>
 	template <typename A, typename B, typename C, precision Q>
-	GLM_FUNC_QUALIFIER tvec4<T, P>::tvec4(tvec1<A, Q> const & a, tvec2<B, Q> const & b, tvec1<C, Q> const & c) :
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec4<T, P>::tvec4(tvec1<A, Q> const & a, tvec2<B, Q> const & b, tvec1<C, Q> const & c) :
 		x(static_cast<T>(a.x)),
 		y(static_cast<T>(b.x)),
 		z(static_cast<T>(b.y)),
@@ -132,7 +132,7 @@ namespace glm
 
 	template <typename T, precision P>
 	template <typename A, typename B, typename C, precision Q>
-	GLM_FUNC_QUALIFIER tvec4<T, P>::tvec4(A s1, B s2, tvec2<C, Q> const & v) :
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec4<T, P>::tvec4(A s1, B s2, tvec2<C, Q> const & v) :
 		x(static_cast<T>(s1)),
 		y(static_cast<T>(s2)),
 		z(static_cast<T>(v.x)),
@@ -141,7 +141,7 @@ namespace glm
 
 	template <typename T, precision P>
 	template <typename A, typename B, typename C, precision Q>
-	GLM_FUNC_QUALIFIER tvec4<T, P>::tvec4(tvec1<A, Q> const & a, tvec1<B, Q> const & b, tvec2<C, Q> const & c) :
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec4<T, P>::tvec4(tvec1<A, Q> const & a, tvec1<B, Q> const & b, tvec2<C, Q> const & c) :
 		x(static_cast<T>(a.x)),
 		y(static_cast<T>(b.x)),
 		z(static_cast<T>(c.x)),
@@ -150,7 +150,7 @@ namespace glm
 
 	template <typename T, precision P>
 	template <typename A, typename B, precision Q>
-	GLM_FUNC_QUALIFIER tvec4<T, P>::tvec4(tvec3<A, Q> const & a, B b) :
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec4<T, P>::tvec4(tvec3<A, Q> const & a, B b) :
 		x(static_cast<T>(a.x)),
 		y(static_cast<T>(a.y)),
 		z(static_cast<T>(a.z)),
@@ -159,7 +159,7 @@ namespace glm
 
 	template <typename T, precision P>
 	template <typename A, typename B, precision Q>
-	GLM_FUNC_QUALIFIER tvec4<T, P>::tvec4(tvec3<A, Q> const & a, tvec1<B, Q> const & b) :
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec4<T, P>::tvec4(tvec3<A, Q> const & a, tvec1<B, Q> const & b) :
 		x(static_cast<T>(a.x)),
 		y(static_cast<T>(a.y)),
 		z(static_cast<T>(a.z)),
@@ -168,7 +168,7 @@ namespace glm
 
 	template <typename T, precision P>
 	template <typename A, typename B, precision Q>
-	GLM_FUNC_QUALIFIER tvec4<T, P>::tvec4(A a, tvec3<B, Q> const & b) :
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec4<T, P>::tvec4(A a, tvec3<B, Q> const & b) :
 		x(static_cast<T>(a)),
 		y(static_cast<T>(b.x)),
 		z(static_cast<T>(b.y)),
@@ -177,7 +177,7 @@ namespace glm
 
 	template <typename T, precision P>
 	template <typename A, typename B, precision Q>
-	GLM_FUNC_QUALIFIER tvec4<T, P>::tvec4(tvec1<A, Q> const & a, tvec3<B, Q> const & b) :
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec4<T, P>::tvec4(tvec1<A, Q> const & a, tvec3<B, Q> const & b) :
 		x(static_cast<T>(a.x)),
 		y(static_cast<T>(b.x)),
 		z(static_cast<T>(b.y)),
@@ -186,7 +186,7 @@ namespace glm
 
 	template <typename T, precision P>
 	template <typename A, typename B, precision Q>
-	GLM_FUNC_QUALIFIER tvec4<T, P>::tvec4(tvec2<A, Q> const & a, tvec2<B, Q> const & b) :
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec4<T, P>::tvec4(tvec2<A, Q> const & a, tvec2<B, Q> const & b) :
 		x(static_cast<T>(a.x)),
 		y(static_cast<T>(a.y)),
 		z(static_cast<T>(b.x)),
@@ -195,7 +195,7 @@ namespace glm
 
 	template <typename T, precision P>
 	template <typename U, precision Q>
-	GLM_FUNC_QUALIFIER tvec4<T, P>::tvec4(tvec4<U, Q> const & v) :
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec4<T, P>::tvec4(tvec4<U, Q> const & v) :
 		x(static_cast<T>(v.x)),
 		y(static_cast<T>(v.y)),
 		z(static_cast<T>(v.z)),

glm/gtc/quaternion.inl

@@ -84,30 +84,30 @@ namespace detail
 
 #	if !GLM_HAS_DEFAULTED_FUNCTIONS
 		template <typename T, precision P>
-		GLM_FUNC_QUALIFIER tquat<T, P>::tquat(tquat<T, P> const & q)
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR tquat<T, P>::tquat(tquat<T, P> const & q)
 			: x(q.x), y(q.y), z(q.z), w(q.w)
 		{}
 #	endif//!GLM_HAS_DEFAULTED_FUNCTIONS
 
 	template <typename T, precision P>
 	template <precision Q>
-	GLM_FUNC_QUALIFIER tquat<T, P>::tquat(tquat<T, Q> const & q)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tquat<T, P>::tquat(tquat<T, Q> const & q)
 		: x(q.x), y(q.y), z(q.z), w(q.w)
 	{}
 
 	// -- Explicit basic constructors --
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tquat<T, P>::tquat(ctor)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tquat<T, P>::tquat(ctor)
 	{}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tquat<T, P>::tquat(T const & s, tvec3<T, P> const & v)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tquat<T, P>::tquat(T const & s, tvec3<T, P> const & v)
 		: x(v.x), y(v.y), z(v.z), w(s)
 	{}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tquat<T, P>::tquat(T const & w, T const & x, T const & y, T const & z)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tquat<T, P>::tquat(T const & w, T const & x, T const & y, T const & z)
 		: x(x), y(y), z(z), w(w)
 	{}
 
@@ -115,7 +115,7 @@ namespace detail
 
 	template <typename T, precision P>
 	template <typename U, precision Q>
-	GLM_FUNC_QUALIFIER tquat<T, P>::tquat(tquat<U, Q> const & q)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tquat<T, P>::tquat(tquat<U, Q> const & q)
 		: x(static_cast<T>(q.x))
 		, y(static_cast<T>(q.y))
 		, z(static_cast<T>(q.z))
@@ -141,7 +141,7 @@ namespace detail
 	//}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tquat<T, P>::tquat(tvec3<T, P> const & u, tvec3<T, P> const & v)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tquat<T, P>::tquat(tvec3<T, P> const & u, tvec3<T, P> const & v)
 	{
 		tvec3<T, P> const LocalW(cross(u, v));
 		T Dot = detail::compute_dot<tvec3, T, P>::call(u, v);
@@ -151,7 +151,7 @@ namespace detail
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tquat<T, P>::tquat(tvec3<T, P> const & eulerAngle)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tquat<T, P>::tquat(tvec3<T, P> const & eulerAngle)
 	{
 		tvec3<T, P> c = glm::cos(eulerAngle * T(0.5));
 		tvec3<T, P> s = glm::sin(eulerAngle * T(0.5));
@@ -163,13 +163,13 @@ namespace detail
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tquat<T, P>::tquat(tmat3x3<T, P> const & m)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tquat<T, P>::tquat(tmat3x3<T, P> const & m)
 	{
 		*this = quat_cast(m);
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tquat<T, P>::tquat(tmat4x4<T, P> const & m)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tquat<T, P>::tquat(tmat4x4<T, P> const & m)
 	{
 		*this = quat_cast(m);
 	}

glm/gtx/dual_quaternion.inl

@@ -61,7 +61,7 @@ namespace glm
 
 #	if !GLM_HAS_DEFAULTED_FUNCTIONS || !defined(GLM_FORCE_NO_CTOR_INIT)
 		template <typename T, precision P>
-		GLM_FUNC_QUALIFIER tdualquat<T, P>::tdualquat()
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR tdualquat<T, P>::tdualquat()
 #			ifndef GLM_FORCE_NO_CTOR_INIT 
 				: real(tquat<T, P>())
 				, dual(tquat<T, P>(0, 0, 0, 0))
@@ -71,7 +71,7 @@ namespace glm
 
 #	if !GLM_HAS_DEFAULTED_FUNCTIONS
 		template <typename T, precision P>
-		GLM_FUNC_QUALIFIER tdualquat<T, P>::tdualquat(tdualquat<T, P> const & d)
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR tdualquat<T, P>::tdualquat(tdualquat<T, P> const & d)
 			: real(d.real)
 			, dual(d.dual)
 		{}
@@ -79,7 +79,7 @@ namespace glm
 
 	template <typename T, precision P>
 	template <precision Q>
-	GLM_FUNC_QUALIFIER tdualquat<T, P>::tdualquat(tdualquat<T, Q> const & d)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tdualquat<T, P>::tdualquat(tdualquat<T, Q> const & d)
 		: real(d.real)
 		, dual(d.dual)
 	{}
@@ -87,16 +87,16 @@ namespace glm
 	// -- Explicit basic constructors --
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tdualquat<T, P>::tdualquat(ctor)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tdualquat<T, P>::tdualquat(ctor)
 	{}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tdualquat<T, P>::tdualquat(tquat<T, P> const & r)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tdualquat<T, P>::tdualquat(tquat<T, P> const & r)
 		: real(r), dual(tquat<T, P>(0, 0, 0, 0))
 	{}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tdualquat<T, P>::tdualquat(tquat<T, P> const & q, tvec3<T, P> const& p)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tdualquat<T, P>::tdualquat(tquat<T, P> const & q, tvec3<T, P> const& p)
 		: real(q), dual(
 			T(-0.5) * ( p.x*q.x + p.y*q.y + p.z*q.z),
 			T(+0.5) * ( p.x*q.w + p.y*q.z - p.z*q.y),
@@ -105,7 +105,7 @@ namespace glm
 	{}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tdualquat<T, P>::tdualquat(tquat<T, P> const & r, tquat<T, P> const & d)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tdualquat<T, P>::tdualquat(tquat<T, P> const & r, tquat<T, P> const & d)
 		: real(r), dual(d)
 	{}
 
@@ -113,19 +113,19 @@ namespace glm
 
 	template <typename T, precision P>
 	template <typename U, precision Q>
-	GLM_FUNC_QUALIFIER tdualquat<T, P>::tdualquat(tdualquat<U, Q> const & q)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tdualquat<T, P>::tdualquat(tdualquat<U, Q> const & q)
 		: real(q.real)
 		, dual(q.dual)
 	{}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tdualquat<T, P>::tdualquat(tmat2x4<T, P> const & m)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tdualquat<T, P>::tdualquat(tmat2x4<T, P> const & m)
 	{
 		*this = dualquat_cast(m);
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tdualquat<T, P>::tdualquat(tmat3x4<T, P> const & m)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR tdualquat<T, P>::tdualquat(tmat3x4<T, P> const & m)
 	{
 		*this = dualquat_cast(m);
 	}

readme.md

@@ -65,11 +65,12 @@ glm::mat4 camera(float Translate, glm::vec2 const & Rotate)
 - Added raw SIMD API
 
 ##### Improvements:
-- Improved SIMD and swizzle operators interactions with GCC and Clang
+- Improved SIMD and swizzle operators interactions with GCC and Clang #474
 - Improved GTC_random linearRand documentation
 - Improved GTC_reciprocal documentation
 - Improved GLM_FORCE_EXPLICIT_CTOR coverage #481
 - Improved OpenMP support detection for Clang, GCC, ICC and VC
+- Added constexpr for *vec*, *mat*, *quat* and *dual_quat* types #493
 
 ##### Fixes:
 - Fixed GTX_extended_min_max filename typo #386