Merge

glm/core/type_mat2x2.inl

@@ -583,5 +583,28 @@ namespace detail
             m[1] - T(1));
     }
 
+	//////////////////////////////////////
+	// Boolean operators
+
+	template <typename T> 
+	inline bool operator==
+	(
+		tmat2x2<T> const & m1, 
+		tmat2x2<T> const & m2
+	)
+	{
+		return (m1[0] == m2[0]) && (m1[1] == m2[1]);
+	}
+
+	template <typename T> 
+	inline bool operator!=
+	(
+		tmat2x2<T> const & m1, 
+		tmat2x2<T> const & m2
+	)
+	{
+		return (m1[0] != m2[0]) || (m1[1] != m2[1]);
+	}
+
 } //namespace detail
 } //namespace glm

glm/core/type_mat2x3.inl

@@ -514,5 +514,28 @@ namespace detail
             m[1] - typename tmat2x3<T>::value_type(1));
     }
 
+	//////////////////////////////////////
+	// Boolean operators
+
+	template <typename T> 
+	inline bool operator==
+	(
+		tmat2x3<T> const & m1, 
+		tmat2x3<T> const & m2
+	)
+	{
+		return (m1[0] == m2[0]) && (m1[1] == m2[1]);
+	}
+
+	template <typename T> 
+	inline bool operator!=
+	(
+		tmat2x3<T> const & m1, 
+		tmat2x3<T> const & m2
+	)
+	{
+		return (m1[0] != m2[0]) || (m1[1] != m2[1]);
+	}
+
 } //namespace detail
 } //namespace glm

glm/core/type_mat2x4.inl

@@ -542,5 +542,28 @@ namespace detail
             m[1] - typename tmat2x4<T>::value_type(1));
     }
 
+	//////////////////////////////////////
+	// Boolean operators
+
+	template <typename T> 
+	inline bool operator==
+	(
+		tmat2x4<T> const & m1, 
+		tmat2x4<T> const & m2
+	)
+	{
+		return (m1[0] == m2[0]) && (m1[1] == m2[1]);
+	}
+
+	template <typename T> 
+	inline bool operator!=
+	(
+		tmat2x4<T> const & m1, 
+		tmat2x4<T> const & m2
+	)
+	{
+		return (m1[0] != m2[0]) || (m1[1] != m2[1]);
+	}
+
 } //namespace detail
 } //namespace glm

glm/core/type_mat3x2.inl

@@ -548,5 +548,28 @@ namespace detail
             m[2] - One);
     }
 
+	//////////////////////////////////////
+	// Boolean operators
+
+	template <typename T> 
+	inline bool operator==
+	(
+		tmat3x2<T> const & m1, 
+		tmat3x2<T> const & m2
+	)
+	{
+		return (m1[0] == m2[0]) && (m1[1] == m2[1]) && (m1[2] == m2[2]);
+	}
+
+	template <typename T> 
+	inline bool operator!=
+	(
+		tmat3x2<T> const & m1, 
+		tmat3x2<T> const & m2
+	)
+	{
+		return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]);
+	}
+
 } //namespace detail
 } //namespace glm

glm/core/type_mat3x3.inl

@@ -677,5 +677,28 @@ namespace detail
             m[2] - T(1));
     }
 
+	//////////////////////////////////////
+	// Boolean operators
+
+	template <typename T> 
+	inline bool operator==
+	(
+		tmat3x3<T> const & m1, 
+		tmat3x3<T> const & m2
+	)
+	{
+		return (m1[0] == m2[0]) && (m1[1] == m2[1]) && (m1[2] == m2[2]);
+	}
+
+	template <typename T> 
+	inline bool operator!=
+	(
+		tmat3x3<T> const & m1, 
+		tmat3x3<T> const & m2
+	)
+	{
+		return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]);
+	}
+
 } //namespace detail
 } //namespace glm

glm/core/type_mat3x4.inl

@@ -582,5 +582,28 @@ namespace detail
             m[2] - T(1));
 	}
 
+	//////////////////////////////////////
+	// Boolean operators
+
+	template <typename T> 
+	inline bool operator==
+	(
+		tmat3x4<T> const & m1, 
+		tmat3x4<T> const & m2
+	)
+	{
+		return (m1[0] == m2[0]) && (m1[1] == m2[1]) && (m1[2] == m2[2]);
+	}
+
+	template <typename T> 
+	inline bool operator!=
+	(
+		tmat3x4<T> const & m1, 
+		tmat3x4<T> const & m2
+	)
+	{
+		return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]);
+	}
+
 } //namespace detail
 } //namespace glm

glm/core/type_mat4x2.inl

@@ -591,5 +591,28 @@ namespace detail
             m[3] - typename tmat4x2<T>::value_type(1));
     }
 
+	//////////////////////////////////////
+	// Boolean operators
+
+	template <typename T> 
+	inline bool operator==
+	(
+		tmat4x2<T> const & m1, 
+		tmat4x2<T> const & m2
+	)
+	{
+		return (m1[0] == m2[0]) && (m1[1] == m2[1]) && (m1[2] == m2[2]) && (m1[3] == m2[3]);
+	}
+
+	template <typename T> 
+	inline bool operator!=
+	(
+		tmat4x2<T> const & m1, 
+		tmat4x2<T> const & m2
+	)
+	{
+		return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]) || (m1[3] != m2[3]);
+	}
+
 } //namespace detail
 } //namespace glm

glm/core/type_mat4x3.inl

@@ -595,6 +595,29 @@ namespace detail
             m[3] - T(1));
     }
 
+	//////////////////////////////////////
+	// Boolean operators
+
+	template <typename T> 
+	inline bool operator==
+	(
+		tmat4x3<T> const & m1, 
+		tmat4x3<T> const & m2
+	)
+	{
+		return (m1[0] == m2[0]) && (m1[1] == m2[1]) && (m1[2] == m2[2]) && (m1[3] == m2[3]);
+	}
+
+	template <typename T> 
+	inline bool operator!=
+	(
+		tmat4x3<T> const & m1, 
+		tmat4x3<T> const & m2
+	)
+	{
+		return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]) || (m1[3] != m2[3]);
+	}
+
 } //namespace detail
 } //namespace glm
 

glm/core/type_mat4x4.inl

@@ -732,5 +732,28 @@ namespace detail
             m[3] - typename tmat4x4<T>::value_type(1));
     }
 
+	//////////////////////////////////////
+	// Boolean operators
+
+	template <typename T> 
+	inline bool operator==
+	(
+		tmat4x4<T> const & m1, 
+		tmat4x4<T> const & m2
+	)
+	{
+		return (m1[0] == m2[0]) && (m1[1] == m2[1]) && (m1[2] == m2[2]) && (m1[3] == m2[3]);
+	}
+
+	template <typename T> 
+	inline bool operator!=
+	(
+		tmat4x4<T> const & m1, 
+		tmat4x4<T> const & m2
+	)
+	{
+		return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]) || (m1[3] != m2[3]);
+	}
+
 } //namespace detail
 } //namespace glm

glm/core/type_vec1.inl

@@ -234,6 +234,29 @@ namespace glm
 			return *this;
 		}
 
+		//////////////////////////////////////
+		// Boolean operators
+
+		template <typename T> 
+		inline bool operator==
+		(
+			tvec1<T> const & v1, 
+			tvec1<T> const & v2
+		)
+		{
+			return (v1.x == v2.x);
+		}
+
+		template <typename T> 
+		inline bool operator!=
+		(
+			tvec1<T> const & v1, 
+			tvec1<T> const & v2
+		)
+		{
+			return (v1.x != v2.x);
+		}
+
 		//////////////////////////////////////
 		// Unary bit operators
 

glm/core/type_vec2.inl

@@ -296,6 +296,29 @@ namespace glm
 			return *this;
 		}
 
+		//////////////////////////////////////
+		// Boolean operators
+
+		template <typename T> 
+		inline bool operator==
+		(
+			tvec2<T> const & v1, 
+			tvec2<T> const & v2
+		)
+		{
+			return (v1.x == v2.x) && (v1.y == v2.y);
+		}
+
+		template <typename T> 
+		inline bool operator!=
+		(
+			tvec2<T> const & v1, 
+			tvec2<T> const & v2
+		)
+		{
+			return (v1.x != v2.x) || (v1.y != v2.y);
+		}
+
 		//////////////////////////////////////
 		// Unary bit operators
 

glm/core/type_vec3.inl

@@ -333,6 +333,29 @@ namespace glm
 			return *this;
 		}
 
+		//////////////////////////////////////
+		// Boolean operators
+
+		template <typename T> 
+		inline bool operator==
+		(
+			tvec3<T> const & v1, 
+			tvec3<T> const & v2
+		)
+		{
+			return (v1.x == v2.x) && (v1.y == v2.y) && (v1.z == v2.z);
+		}
+
+		template <typename T> 
+		inline bool operator!=
+		(
+			tvec3<T> const & v1, 
+			tvec3<T> const & v2
+		)
+		{
+			return (v1.x != v2.x) || (v1.y != v2.y) || (v1.z != v2.z);
+		}
+
 		//////////////////////////////////////
 		// Unary bit operators
 

glm/core/type_vec4.inl

@@ -861,6 +861,29 @@ namespace glm
 				v.w - One);
 		}
 
+		//////////////////////////////////////
+		// Boolean operators
+
+		template <typename T> 
+		inline bool operator==
+		(
+			tvec4<T> const & v1, 
+			tvec4<T> const & v2
+		)
+		{
+			return (v1.x == v2.x) && (v1.y == v2.y) && (v1.z == v2.z) && (v1.w == v2.w);
+		}
+
+		template <typename T> 
+		inline bool operator!=
+		(
+			tvec4<T> const & v1, 
+			tvec4<T> const & v2
+		)
+		{
+			return (v1.x != v2.x) || (v1.y != v2.y) || (v1.z != v2.z) || (v1.w != v2.w);
+		}
+
 		//////////////////////////////////////
 		// Binary bit operators
 
@@ -1129,6 +1152,19 @@ namespace glm
 				~v.w);
 		}
 
+		template <typename T> 
+		inline tvec4<T> operator~
+		(
+			tvec4<T> const & v
+		)
+		{
+			return tvec4<T>(
+				~v.x,
+				~v.y,
+				~v.z,
+				~v.w);
+		}
+
 		//////////////////////////////////////
 		// tref definition
 

glm/gtx/comparison.hpp

@@ -24,8 +24,9 @@ namespace glm
 
 	namespace gtx{
 	//! GLM_GTX_comparison extension: Defined comparison operators for vectors.
-	namespace comparison{
+	namespace comparison
-
+	{
+/*
 		//! Define == operator for vectors
 		//! From GLM_GTX_comparison extension.
 		template <typename T>
@@ -67,7 +68,7 @@ namespace glm
 		bool operator!= (
 			detail::tvec4<T> const & x, 
 			detail::tvec4<T> const & y);
-
+*/
 	}//namespace comparison
 	}//namespace gtx
 }//namespace glm

glm/gtx/comparison.inl

@@ -10,7 +10,7 @@
 namespace glm{
 namespace gtx{
 namespace comparison{
-
+/*
 template <typename valType>
 inline bool operator== 
 (
@@ -70,7 +70,7 @@ inline bool operator!=
 {
 	return glm::any(glm::notEqual(x, y));
 }
-
+*/
 }//namespace comparison
 }//namespace gtx
 }//namespace glm