Added move contructors and assignment operators (#141)

glm/detail/setup.hpp

@@ -527,6 +527,25 @@
 	((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC46)) || \
 	__has_feature(cxx_unrestricted_unions))
 
+// N2346
+#define GLM_HAS_DEFAULTED_FUNCTIONS ( \
+	(GLM_LANG & GLM_LANG_CXX11_FLAG) || \
+	((GLM_LANG & GLM_LANG_CXX0X_FLAG) && ((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC12))) || \
+	((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC44)) || \
+	__has_feature(cxx_defaulted_functions))
+
+// N2118
+#define GLM_HAS_RVALUE_REFERENCES ( \
+	(GLM_LANG & GLM_LANG_CXX11_FLAG) || \
+	((GLM_LANG & GLM_LANG_CXX0X_FLAG) && ((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC11))) || \
+	((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC43)) || \
+	__has_feature(cxx_rvalue_references))
+
+#define GLM_HAS_STL_ARRAY ( \
+	(GLM_LANG & GLM_LANG_CXX11_FLAG) || \
+	((GLM_LANG & GLM_LANG_CXX0X_FLAG) && ((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC10))) || \
+	((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC43)))
+
 // OpenMP
 #ifdef _OPENMP 
 #	if(GLM_COMPILER & GLM_COMPILER_GCC)

glm/detail/type_mat2x2.hpp

@@ -33,6 +33,14 @@
 #include "type_vec2.hpp"
 #include "type_mat.hpp"
 #include <limits>
+#if GLM_HAS_INITIALIZER_LISTS
+#	include <initializer_list>
+#endif
+#if GLM_HAS_RVALUE_REFERENCES
+#	include <algorithm>
+#endif
+#include <limits>
+#include <cstddef>
 
 namespace glm{
 namespace detail
@@ -81,11 +89,19 @@ namespace detail
 
 #		if(GLM_HAS_INITIALIZER_LISTS)
 			template <typename U>
-		GLM_FUNC_DECL tmat2x2(std::initializer_list<U> m);
+			GLM_FUNC_DECL tmat2x2(std::initializer_list<U> l);
 
-		GLM_FUNC_DECL tmat2x2(std::initializer_list<tvec2<T, P> > m);
+			GLM_FUNC_DECL tmat2x2(std::initializer_list<tvec2<T, P> > l);
 #		endif//GLM_HAS_INITIALIZER_LISTS
 
+#		if(GLM_HAS_DEFAULTED_FUNCTIONS && GLM_HAS_RVALUE_REFERENCES)
+			GLM_FUNC_DECL tmat2x2(tmat2x2<T, P> && m)
+			{
+				this->value[0] = std::move(m.value[0]);
+				this->value[1] = std::move(m.value[1]);
+			}
+#		endif//(GLM_HAS_DEFAULTED_FUNCTIONS && GLM_HAS_RVALUE_REFERENCES)
+
 		//////////////////////////////////////
 		// Conversions
 		template <typename U, typename V, typename M, typename N>
@@ -119,6 +135,15 @@ namespace detail
 		GLM_FUNC_DECL col_type const & operator[](length_t i) const;
 
 		// Unary updatable operators
+#		if(GLM_HAS_DEFAULTED_FUNCTIONS && GLM_HAS_RVALUE_REFERENCES)
+			GLM_FUNC_DECL tmat2x2<T, P> & operator=(tmat2x2<T, P> && m)
+			{
+				this->value[0] = std::move(m.value[0]);
+				this->value[1] = std::move(m.value[1]);
+				return *this;
+			}
+#		endif//(GLM_HAS_DEFAULTED_FUNCTIONS && GLM_HAS_RVALUE_REFERENCES)
+
 		GLM_FUNC_DECL tmat2x2<T, P> & operator=(tmat2x2<T, P> const & m);
 		template <typename U> 
 		GLM_FUNC_DECL tmat2x2<T, P> & operator=(tmat2x2<U, P> const & m);
@@ -148,9 +173,6 @@ namespace detail
 		GLM_FUNC_DECL tmat2x2<T, P> operator--(int);
 	};
 
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x2<T, P> compute_inverse_mat2(tmat2x2<T, P> const & m);
-
 	// Binary operators
 	template <typename T, precision P>
 	GLM_FUNC_DECL tmat2x2<T, P> operator+ (

glm/detail/type_mat2x2.inl

@@ -30,31 +30,20 @@ namespace glm{
 namespace detail
 {
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR length_t tmat2x2<T, P>::length() const
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR length_t tmat2x2<T, P>::length() const {return 2;}
-	{
-		return 2;
-	}
 
 	//////////////////////////////////////
 	// Accesses
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER typename tmat2x2<T, P>::col_type &
+	GLM_FUNC_QUALIFIER typename tmat2x2<T, P>::col_type & tmat2x2<T, P>::operator[](length_t i)
-	tmat2x2<T, P>::operator[]
-	(
-		length_t i
-	)
 	{
 		assert(i < this->length());
 		return this->value[i];
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER typename tmat2x2<T, P>::col_type const &
+	GLM_FUNC_QUALIFIER typename tmat2x2<T, P>::col_type const & tmat2x2<T, P>::operator[](length_t i) const
-	tmat2x2<T, P>::operator[]
-	(
-		length_t i
-	) const
 	{
 		assert(i < this->length());
 		return this->value[i];

glm/detail/type_mat2x3.hpp

@@ -33,7 +33,14 @@
 #include "type_vec2.hpp"
 #include "type_vec3.hpp"
 #include "type_mat.hpp"
+#if GLM_HAS_INITIALIZER_LISTS
+#	include <initializer_list>
+#endif
+#if GLM_HAS_RVALUE_REFERENCES
+#	include <algorithm>
+#endif
 #include <limits>
+#include <cstddef>
 
 namespace glm{
 namespace detail
@@ -80,6 +87,14 @@ namespace detail
 			GLM_FUNC_DECL tmat2x3(std::initializer_list<tvec3<T, P> > m);
 #		endif//GLM_HAS_INITIALIZER_LISTS
 
+#		if(GLM_HAS_DEFAULTED_FUNCTIONS && GLM_HAS_RVALUE_REFERENCES)
+			GLM_FUNC_DECL tmat2x3(tmat2x3<T, P> && m)
+			{
+				this->value[0] = std::move(m.value[0]);
+				this->value[1] = std::move(m.value[1]);
+			}
+#		endif//(GLM_HAS_DEFAULTED_FUNCTIONS && GLM_HAS_RVALUE_REFERENCES)
+
 		//////////////////////////////////////
 		// Conversions
 		template <typename X1, typename Y1, typename Z1, typename X2, typename Y2, typename Z2>
@@ -111,6 +126,15 @@ namespace detail
 		GLM_FUNC_DECL col_type const & operator[](length_t i) const;
 
 		// Unary updatable operators
+#		if(GLM_HAS_DEFAULTED_FUNCTIONS && GLM_HAS_RVALUE_REFERENCES)
+			GLM_FUNC_DECL tmat2x3<T, P> & operator=(tmat2x3<T, P> && m)
+			{
+				this->value[0] = std::move(m.value[0]);
+				this->value[1] = std::move(m.value[1]);
+				return *this;
+			}
+#		endif//(GLM_HAS_DEFAULTED_FUNCTIONS && GLM_HAS_RVALUE_REFERENCES)
+
 		GLM_FUNC_DECL tmat2x3<T, P> & operator=  (tmat2x3<T, P> const & m);
 		template <typename U> 
 		GLM_FUNC_DECL tmat2x3<T, P> & operator=  (tmat2x3<U, P> const & m);

glm/detail/type_mat2x4.hpp

@@ -33,7 +33,14 @@
 #include "type_vec2.hpp"
 #include "type_vec4.hpp"
 #include "type_mat.hpp"
+#if GLM_HAS_INITIALIZER_LISTS
+#	include <initializer_list>
+#endif
+#if GLM_HAS_RVALUE_REFERENCES
+#	include <algorithm>
+#endif
 #include <limits>
+#include <cstddef>
 
 namespace glm{
 namespace detail
@@ -80,6 +87,14 @@ namespace detail
 			GLM_FUNC_DECL tmat2x4(std::initializer_list<tvec4<T, P> > m);
 #		endif//GLM_HAS_INITIALIZER_LISTS
 
+#		if(GLM_HAS_DEFAULTED_FUNCTIONS && GLM_HAS_RVALUE_REFERENCES)
+			GLM_FUNC_DECL tmat2x4(tmat2x4<T, P> && m)
+			{
+				this->value[0] = std::move(m.value[0]);
+				this->value[1] = std::move(m.value[1]);
+			}
+#		endif//(GLM_HAS_DEFAULTED_FUNCTIONS && GLM_HAS_RVALUE_REFERENCES)
+
 		//////////////////////////////////////
 		// Conversions
 		template <
@@ -113,6 +128,15 @@ namespace detail
 		GLM_FUNC_DECL col_type const & operator[](length_t i) const;
 
 		// Unary updatable operators
+#		if(GLM_HAS_DEFAULTED_FUNCTIONS && GLM_HAS_RVALUE_REFERENCES)
+			GLM_FUNC_DECL tmat2x4<T, P> & operator=(tmat2x4<T, P> && m)
+			{
+				this->value[0] = std::move(m.value[0]);
+				this->value[1] = std::move(m.value[1]);
+				return *this;
+			}
+#		endif//(GLM_HAS_DEFAULTED_FUNCTIONS && GLM_HAS_RVALUE_REFERENCES)
+
 		GLM_FUNC_DECL tmat2x4<T, P>& operator=  (tmat2x4<T, P> const & m);
 		template <typename U> 
 		GLM_FUNC_DECL tmat2x4<T, P>& operator=  (tmat2x4<U, P> const & m);

glm/detail/type_mat3x2.hpp

@@ -33,7 +33,14 @@
 #include "type_vec2.hpp"
 #include "type_vec3.hpp"
 #include "type_mat.hpp"
+#if GLM_HAS_INITIALIZER_LISTS
+#	include <initializer_list>
+#endif
+#if GLM_HAS_RVALUE_REFERENCES
+#	include <algorithm>
+#endif
 #include <limits>
+#include <cstddef>
 
 namespace glm{
 namespace detail
@@ -82,6 +89,15 @@ namespace detail
 			GLM_FUNC_DECL tmat3x2(std::initializer_list<tvec2<T, P> > l);
 #		endif//GLM_HAS_INITIALIZER_LISTS
 
+#		if(GLM_HAS_DEFAULTED_FUNCTIONS && GLM_HAS_RVALUE_REFERENCES)
+			GLM_FUNC_DECL tmat3x2(tmat3x2<T, P> && m)
+			{
+				this->value[0] = std::move(m.value[0]);
+				this->value[1] = std::move(m.value[1]);
+				this->value[2] = std::move(m.value[2]);
+			}
+#		endif//(GLM_HAS_DEFAULTED_FUNCTIONS && GLM_HAS_RVALUE_REFERENCES)
+
 		//////////////////////////////////////
 		// Conversions
 		template<
@@ -117,6 +133,16 @@ namespace detail
 		GLM_FUNC_DECL col_type const & operator[](length_t i) const;
 
 		// Unary updatable operators
+#		if(GLM_HAS_DEFAULTED_FUNCTIONS && GLM_HAS_RVALUE_REFERENCES)
+			GLM_FUNC_DECL tmat3x2<T, P> & operator=(tmat3x2<T, P> && m)
+			{
+				this->value[0] = std::move(m.value[0]);
+				this->value[1] = std::move(m.value[1]);
+				this->value[2] = std::move(m.value[2]);
+				return *this;
+			}
+#		endif//(GLM_HAS_DEFAULTED_FUNCTIONS && GLM_HAS_RVALUE_REFERENCES)
+
 		GLM_FUNC_DECL tmat3x2<T, P> & operator=  (tmat3x2<T, P> const & m);
 		template <typename U> 
 		GLM_FUNC_DECL tmat3x2<T, P> & operator=  (tmat3x2<U, P> const & m);

glm/detail/type_mat3x3.hpp

@@ -32,7 +32,14 @@
 #include "../fwd.hpp"
 #include "type_vec3.hpp"
 #include "type_mat.hpp"
+#if GLM_HAS_INITIALIZER_LISTS
+#	include <initializer_list>
+#endif
+#if GLM_HAS_RVALUE_REFERENCES
+#	include <algorithm>
+#endif
 #include <limits>
+#include <cstddef>
 
 namespace glm{
 namespace detail
@@ -87,6 +94,15 @@ namespace detail
 			GLM_FUNC_DECL tmat3x3(std::initializer_list<tvec3<T, P> > m);
 #		endif//GLM_HAS_INITIALIZER_LISTS
 
+#		if(GLM_HAS_DEFAULTED_FUNCTIONS && GLM_HAS_RVALUE_REFERENCES)
+			GLM_FUNC_DECL tmat3x3(tmat3x3<T, P> && m)
+			{
+				this->value[0] = std::move(m.value[0]);
+				this->value[1] = std::move(m.value[1]);
+				this->value[2] = std::move(m.value[2]);
+			}
+#		endif//(GLM_HAS_DEFAULTED_FUNCTIONS && GLM_HAS_RVALUE_REFERENCES)
+
 		//////////////////////////////////////
 		// Conversions
 		template<
@@ -122,6 +138,16 @@ namespace detail
 		GLM_FUNC_DECL col_type const & operator[](length_t i) const;
 
 		// Unary updatable operators
+#		if(GLM_HAS_DEFAULTED_FUNCTIONS && GLM_HAS_RVALUE_REFERENCES)
+			GLM_FUNC_DECL tmat3x3<T, P> & operator=(tmat3x3<T, P> && m)
+			{
+				this->value[0] = std::move(m.value[0]);
+				this->value[1] = std::move(m.value[1]);
+				this->value[2] = std::move(m.value[2]);
+				return *this;
+			}
+#		endif//(GLM_HAS_DEFAULTED_FUNCTIONS && GLM_HAS_RVALUE_REFERENCES)
+
 		GLM_FUNC_DECL tmat3x3<T, P>& operator=  (tmat3x3<T, P> const & m);
 		template <typename U>
 		GLM_FUNC_DECL tmat3x3<T, P>& operator=  (tmat3x3<U, P> const & m);

glm/detail/type_mat3x4.hpp

@@ -33,7 +33,14 @@
 #include "type_vec3.hpp"
 #include "type_vec4.hpp"
 #include "type_mat.hpp"
+#if GLM_HAS_INITIALIZER_LISTS
+#	include <initializer_list>
+#endif
+#if GLM_HAS_RVALUE_REFERENCES
+#	include <algorithm>
+#endif
 #include <limits>
+#include <cstddef>
 
 namespace glm{
 namespace detail
@@ -82,6 +89,15 @@ namespace detail
 			GLM_FUNC_DECL tmat3x4(std::initializer_list<tvec4<T, P> > m);
 #		endif//GLM_HAS_INITIALIZER_LISTS
 
+#		if(GLM_HAS_DEFAULTED_FUNCTIONS && GLM_HAS_RVALUE_REFERENCES)
+			GLM_FUNC_DECL tmat3x4(tmat3x4<T, P> && m)
+			{
+				this->value[0] = std::move(m.value[0]);
+				this->value[1] = std::move(m.value[1]);
+				this->value[2] = std::move(m.value[2]);
+			}
+#		endif//(GLM_HAS_DEFAULTED_FUNCTIONS && GLM_HAS_RVALUE_REFERENCES)
+
 		//////////////////////////////////////
 		// Conversions
 		template<
@@ -117,6 +133,16 @@ namespace detail
 		GLM_FUNC_DECL col_type const & operator[](length_t i) const;
 
 		// Unary updatable operators
+#		if(GLM_HAS_DEFAULTED_FUNCTIONS && GLM_HAS_RVALUE_REFERENCES)
+			GLM_FUNC_DECL tmat3x4<T, P> & operator=(tmat3x4<T, P> && m)
+			{
+				this->value[0] = std::move(m.value[0]);
+				this->value[1] = std::move(m.value[1]);
+				this->value[2] = std::move(m.value[2]);
+				return *this;
+			}
+#		endif//(GLM_HAS_DEFAULTED_FUNCTIONS && GLM_HAS_RVALUE_REFERENCES)
+
 		GLM_FUNC_DECL tmat3x4<T, P> & operator=  (tmat3x4<T, P> const & m);
 		template <typename U> 
 		GLM_FUNC_DECL tmat3x4<T, P> & operator=  (tmat3x4<U, P> const & m);

glm/detail/type_mat4x2.hpp

@@ -33,7 +33,14 @@
 #include "type_vec2.hpp"
 #include "type_vec4.hpp"
 #include "type_mat.hpp"
+#if GLM_HAS_INITIALIZER_LISTS
+#	include <initializer_list>
+#endif
+#if GLM_HAS_RVALUE_REFERENCES
+#	include <algorithm>
+#endif
 #include <limits>
+#include <cstddef>
 
 namespace glm{
 namespace detail
@@ -84,6 +91,16 @@ namespace detail
 			GLM_FUNC_DECL tmat4x2(std::initializer_list<tvec2<T, P> > m);
 #		endif//GLM_HAS_INITIALIZER_LISTS
 
+#		if(GLM_HAS_DEFAULTED_FUNCTIONS && GLM_HAS_RVALUE_REFERENCES)
+			GLM_FUNC_DECL tmat4x2(tmat4x2<T, P> && m)
+			{
+				this->value[0] = std::move(m.value[0]);
+				this->value[1] = std::move(m.value[1]);
+				this->value[2] = std::move(m.value[2]);
+				this->value[3] = std::move(m.value[3]);
+			}
+#		endif//(GLM_HAS_DEFAULTED_FUNCTIONS && GLM_HAS_RVALUE_REFERENCES)
+
 		//////////////////////////////////////
 		// Conversions
 
@@ -123,6 +140,17 @@ namespace detail
 		GLM_FUNC_DECL col_type const & operator[](length_t i) const;
 
 		// Unary updatable operators
+#		if(GLM_HAS_DEFAULTED_FUNCTIONS && GLM_HAS_RVALUE_REFERENCES)
+			GLM_FUNC_DECL tmat4x2<T, P> & operator=(tmat4x2<T, P> && m)
+			{
+				this->value[0] = std::move(m.value[0]);
+				this->value[1] = std::move(m.value[1]);
+				this->value[2] = std::move(m.value[2]);
+				this->value[3] = std::move(m.value[3]);
+				return *this;
+			}
+#		endif//(GLM_HAS_DEFAULTED_FUNCTIONS && GLM_HAS_RVALUE_REFERENCES)
+
 		GLM_FUNC_DECL tmat4x2<T, P>& operator=  (tmat4x2<T, P> const & m);
 		template <typename U> 
 		GLM_FUNC_DECL tmat4x2<T, P>& operator=  (tmat4x2<U, P> const & m);

glm/detail/type_mat4x3.hpp

@@ -33,7 +33,14 @@
 #include "type_vec3.hpp"
 #include "type_vec4.hpp"
 #include "type_mat.hpp"
+#if GLM_HAS_INITIALIZER_LISTS
+#	include <initializer_list>
+#endif
+#if GLM_HAS_RVALUE_REFERENCES
+#	include <algorithm>
+#endif
 #include <limits>
+#include <cstddef>
 
 namespace glm{
 namespace detail
@@ -84,6 +91,16 @@ namespace detail
 			GLM_FUNC_DECL tmat4x3(std::initializer_list<tvec3<T, P> > m);
 #		endif//GLM_HAS_INITIALIZER_LISTS
 
+#		if(GLM_HAS_DEFAULTED_FUNCTIONS && GLM_HAS_RVALUE_REFERENCES)
+			GLM_FUNC_DECL tmat4x3(tmat4x3<T, P> && m)
+			{
+				this->value[0] = std::move(m.value[0]);
+				this->value[1] = std::move(m.value[1]);
+				this->value[2] = std::move(m.value[2]);
+				this->value[3] = std::move(m.value[3]);
+			}
+#		endif//(GLM_HAS_DEFAULTED_FUNCTIONS && GLM_HAS_RVALUE_REFERENCES)
+
 		//////////////////////////////////////
 		// Conversions
 
@@ -123,6 +140,17 @@ namespace detail
 		GLM_FUNC_DECL col_type const & operator[](size_type i) const;
 
 		// Unary updatable operators
+#		if(GLM_HAS_DEFAULTED_FUNCTIONS && GLM_HAS_RVALUE_REFERENCES)
+			GLM_FUNC_DECL tmat4x3<T, P> & operator=(tmat4x3<T, P> && m)
+			{
+				this->value[0] = std::move(m.value[0]);
+				this->value[1] = std::move(m.value[1]);
+				this->value[2] = std::move(m.value[2]);
+				this->value[3] = std::move(m.value[3]);
+				return *this;
+			}
+#		endif//(GLM_HAS_DEFAULTED_FUNCTIONS && GLM_HAS_RVALUE_REFERENCES)
+
 		GLM_FUNC_DECL tmat4x3<T, P> & operator=  (tmat4x3<T, P> const & m);
 		template <typename U>
 		GLM_FUNC_DECL tmat4x3<T, P> & operator=  (tmat4x3<U, P> const & m);

glm/detail/type_mat4x4.hpp

@@ -32,9 +32,12 @@
 #include "../fwd.hpp"
 #include "type_vec4.hpp"
 #include "type_mat.hpp"
-#if(GLM_HAS_INITIALIZER_LISTS)
+#if GLM_HAS_INITIALIZER_LISTS
 #	include <initializer_list>
-#endif //GLM_HAS_INITIALIZER_LISTS
+#endif
+#if GLM_HAS_RVALUE_REFERENCES
+#	include <algorithm>
+#endif
 #include <limits>
 #include <cstddef>
 
@@ -92,6 +95,16 @@ namespace detail
 			GLM_FUNC_DECL tmat4x4(std::initializer_list<tvec4<T, P> > m);
 #		endif//GLM_HAS_INITIALIZER_LISTS
 
+#		if(GLM_HAS_DEFAULTED_FUNCTIONS && GLM_HAS_RVALUE_REFERENCES)
+			GLM_FUNC_DECL tmat4x4(tmat4x4<T, P> && m)
+			{
+				this->value[0] = std::move(m.value[0]);
+				this->value[1] = std::move(m.value[1]);
+				this->value[2] = std::move(m.value[2]);
+				this->value[3] = std::move(m.value[3]);
+			}
+#		endif//(GLM_HAS_DEFAULTED_FUNCTIONS && GLM_HAS_RVALUE_REFERENCES)
+
 		//////////////////////////////////////
 		// Conversions
 
@@ -131,6 +144,17 @@ namespace detail
 		GLM_FUNC_DECL col_type const & operator[](length_t i) const;
 
 		// Unary updatable operators
+#		if(GLM_HAS_DEFAULTED_FUNCTIONS && GLM_HAS_RVALUE_REFERENCES)
+			GLM_FUNC_DECL tmat4x4<T, P> & operator=(tmat4x4<T, P> && m)
+			{
+				this->value[0] = std::move(m.value[0]);
+				this->value[1] = std::move(m.value[1]);
+				this->value[2] = std::move(m.value[2]);
+				this->value[3] = std::move(m.value[3]);
+				return *this;
+			}
+#		endif//(GLM_HAS_DEFAULTED_FUNCTIONS && GLM_HAS_RVALUE_REFERENCES)
+
 		GLM_FUNC_DECL tmat4x4<T, P> & operator=  (tmat4x4<T, P> const & m);
 		template <typename U>
 		GLM_FUNC_DECL tmat4x4<T, P> & operator=  (tmat4x4<U, P> const & m);

glm/detail/type_vec1.hpp

@@ -84,7 +84,7 @@ namespace detail
 
 #		if(GLM_HAS_INITIALIZER_LISTS)
 			template <typename U>
-		GLM_FUNC_DECL tvec1(std::initializer_list<U> const & v);
+			GLM_FUNC_DECL tvec1(std::initializer_list<U> l);
 #		endif//GLM_HAS_INITIALIZER_LISTS
 
 		//////////////////////////////////////
@@ -115,9 +115,9 @@ namespace detail
 		// Unary arithmetic operators
 
 		GLM_FUNC_DECL tvec1<T, P> & operator= (tvec1<T, P> const & v);
+
 		template <typename U> 
 		GLM_FUNC_DECL tvec1<T, P> & operator= (tvec1<U, P> const & v);
-
 		template <typename U> 
 		GLM_FUNC_DECL tvec1<T, P> & operator+=(U const & s);
 		template <typename U> 

glm/detail/type_vec1.inl

@@ -74,10 +74,10 @@ namespace detail
 #if(GLM_HAS_INITIALIZER_LISTS)
 	template <typename T, precision P>
 	template <typename U>
-	GLM_FUNC_QUALIFIER tvec1<T, P>::tvec1(std::initializer_list<U> const & v) :
+	GLM_FUNC_QUALIFIER tvec1<T, P>::tvec1(std::initializer_list<U> l) :
-		x(static_cast<T>(v.begin()[0]))
+		x(static_cast<T>(l.begin()[0]))
 	{
-		assert(v.size() == this->length());
+		assert(l.size() == this->length());
 	}
 #endif//GLM_HAS_INITIALIZER_LISTS
 

glm/detail/type_vec2.hpp

@@ -109,7 +109,7 @@ namespace detail
 
 #		if(GLM_HAS_INITIALIZER_LISTS)
 			template <typename U>
-		GLM_FUNC_DECL tvec2(std::initializer_list<U> const & v);
+			GLM_FUNC_DECL tvec2(std::initializer_list<U> l);
 #		endif//GLM_HAS_INITIALIZER_LISTS
 
 		//////////////////////////////////////
@@ -160,9 +160,9 @@ namespace detail
 		// Unary arithmetic operators
 
 		GLM_FUNC_DECL tvec2<T, P> & operator= (tvec2<T, P> const & v);
+
 		template <typename U> 
 		GLM_FUNC_DECL tvec2<T, P> & operator= (tvec2<U, P> const & v);
-
 		template <typename U> 
 		GLM_FUNC_DECL tvec2<T, P> & operator+=(U s);
 		template <typename U> 

glm/detail/type_vec2.inl

@@ -77,11 +77,11 @@ namespace detail
 #if(GLM_HAS_INITIALIZER_LISTS)
 	template <typename T, precision P>
 	template <typename U>
-	GLM_FUNC_QUALIFIER tvec2<T, P>::tvec2(std::initializer_list<U> const & v) :
+	GLM_FUNC_QUALIFIER tvec2<T, P>::tvec2(std::initializer_list<U> l) :
-		x(static_cast<T>(v.begin()[0])),
+		x(static_cast<T>(l.begin()[0])),
-		y(static_cast<T>(v.begin()[1]))
+		y(static_cast<T>(l.begin()[1]))
 	{
-		assert(v.size() == this->length());
+		assert(l.size() == this->length());
 	}
 #endif//GLM_HAS_INITIALIZER_LISTS
 

glm/detail/type_vec3.hpp

@@ -110,7 +110,7 @@ namespace detail
 
 #		if(GLM_HAS_INITIALIZER_LISTS)
 			template <typename U>
-		GLM_FUNC_DECL tvec3(std::initializer_list<U> const & v);
+			GLM_FUNC_DECL tvec3(std::initializer_list<U> l);
 #		endif//GLM_HAS_INITIALIZER_LISTS
 
 		//////////////////////////////////////
@@ -178,9 +178,9 @@ namespace detail
 		// Unary arithmetic operators
 
 		GLM_FUNC_DECL tvec3<T, P> & operator= (tvec3<T, P> const & v);
+
 		template <typename U> 
 		GLM_FUNC_DECL tvec3<T, P> & operator= (tvec3<U, P> const & v);
-
 		template <typename U> 
 		GLM_FUNC_DECL tvec3<T, P> & operator+=(U s);
 		template <typename U> 

glm/detail/type_vec3.inl

@@ -80,12 +80,12 @@ namespace detail
 #if(GLM_HAS_INITIALIZER_LISTS)
 	template <typename T, precision P>
 	template <typename U>
-	GLM_FUNC_QUALIFIER tvec3<T, P>::tvec3(std::initializer_list<U> const & v) :
+	GLM_FUNC_QUALIFIER tvec3<T, P>::tvec3(std::initializer_list<U> l) :
-		x(static_cast<T>(v.begin()[0])),
+		x(static_cast<T>(l.begin()[0])),
-		y(static_cast<T>(v.begin()[1])),
+		y(static_cast<T>(l.begin()[1])),
-		z(static_cast<T>(v.begin()[2]))
+		z(static_cast<T>(l.begin()[2]))
 	{
-		assert(v.size() == this->length());
+		assert(l.size() == this->length());
 	}
 #endif//GLM_HAS_INITIALIZER_LISTS
 

glm/detail/type_vec4.hpp

@@ -252,6 +252,7 @@ namespace detail
 		// Unary arithmetic operators
 
 		GLM_FUNC_DECL tvec4<T, P> & operator= (tvec4<T, P> const & v);
+
 		GLM_FUNC_DECL tvec4<T, P> & operator+=(T s);
 		GLM_FUNC_DECL tvec4<T, P> & operator+=(tvec4<T, P> const & v);
 		GLM_FUNC_DECL tvec4<T, P> & operator-=(T s);

glm/detail/type_vec4.inl

@@ -121,13 +121,13 @@ namespace detail
 #if(GLM_HAS_INITIALIZER_LISTS)
 	template <typename T, precision P>
 	template <typename U>
-	GLM_FUNC_QUALIFIER tvec4<T, P>::tvec4(std::initializer_list<U> v) :
+	GLM_FUNC_QUALIFIER tvec4<T, P>::tvec4(std::initializer_list<U> l) :
-		x(static_cast<T>(v.begin()[0])),
+		x(static_cast<T>(l.begin()[0])),
-		y(static_cast<T>(v.begin()[1])),
+		y(static_cast<T>(l.begin()[1])),
-		z(static_cast<T>(v.begin()[2])),
+		z(static_cast<T>(l.begin()[2])),
-		w(static_cast<T>(v.begin()[3]))
+		w(static_cast<T>(l.begin()[3]))
 	{
-		assert(v.size() == this->length());
+		assert(l.size() == this->length());
 	}
 #endif//GLM_HAS_INITIALIZER_LISTS
 

readme.txt

@@ -42,6 +42,7 @@ GLM 0.9.6.0: 2014-XX-XX
 - Added transparent use of SIMD instructions for vec4 and mat4 types
 - Removed degrees for function parameters
 - Removed GLM_FORCE_RADIANS, active by default
+- Added move contructors and assignment operators (#141)
 
 ================================================================================
 GLM 0.9.5.2: 2014-0X-XX