Added epsilon constant and improved queries... still probably broken, need extra test

glm/gtx/constants.hpp

@@ -52,8 +52,12 @@ namespace glm
 	/// @addtogroup gtx_constants
 	/// @{
 
+	/// @todo Implement epsilon for half-precision floating point type.
 	template <typename T>
-	T pi();
+	GLM_FUNC_QUALIFIER T epsilon()
+	{
+		return std::numeric_limits<T>::epsilon();
+	}
 
 	template <typename T>
 	GLM_FUNC_QUALIFIER T pi()

glm/gtx/matrix_query.hpp

@@ -42,6 +42,7 @@
 // Dependency:
 #include "../glm.hpp"
 #include "../gtx/vector_query.hpp"
+#include <limits>
 
 #if(defined(GLM_MESSAGES) && !defined(glm_ext))
 #	pragma message("GLM: GLM_GTX_matrix_query extension included")
@@ -52,61 +53,61 @@ namespace glm
 	/// @addtogroup gtx_matrix_query
 	/// @{
 
-	//! Return if a matrix a null matrix.
-	//! From GLM_GTX_matrix_query extension.
+	/// Return whether a matrix a null matrix.
+	/// From GLM_GTX_matrix_query extension.
 	template<typename T> 
 	bool isNull(
 		detail::tmat2x2<T> const & m, 
-		T const & epsilon = std::numeric_limits<T>::epsilon());
+		T const & epsilon/* = std::numeric_limits<T>::epsilon()*/);
 		
-	//! Return if a matrix a null matrix.
-	//! From GLM_GTX_matrix_query extension.
+	/// Return whether a matrix a null matrix.
+	/// From GLM_GTX_matrix_query extension.
 	template<typename T> 
 	bool isNull(
 		detail::tmat3x3<T> const & m, 
-		T const & epsilon = std::numeric_limits<T>::epsilon());
+		T const & epsilon/* = std::numeric_limits<T>::epsilon()*/);
 		
-	//! Return if a matrix a null matrix.
-	//! From GLM_GTX_matrix_query extension.
+	/// Return whether a matrix is a null matrix.
+	/// From GLM_GTX_matrix_query extension.
 	template<typename T> 
 	bool isNull(
 		detail::tmat4x4<T> const & m, 
-		T const & epsilon = std::numeric_limits<T>::epsilon());
+		T const & epsilon/* = std::numeric_limits<T>::epsilon()*/);
 			
-	//! Return if a matrix an identity matrix. 
-	//! From GLM_GTX_matrix_query extension.
+	/// Return whether a matrix is an identity matrix. 
+	/// From GLM_GTX_matrix_query extension.
 	template<typename genType> 
 	bool isIdentity(
 		genType const & m, 
-		typename genType::value_type const & epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
+		typename genType::value_type const & epsilon/* = std::numeric_limits<typename genType::value_type>::epsilon()*/);
 
-	//! Return if a matrix a normalized matrix.
-	//! From GLM_GTX_matrix_query extension.
-	template<typename T> 
+	/// Return whether a matrix is a normalized matrix.
+	/// From GLM_GTX_matrix_query extension.
+	template<typename valType>   
 	bool isNormalized(
-		detail::tmat2x2<T> const & m, 
-		T const & epsilon = std::numeric_limits<T>::epsilon());
-		
-	//! Return if a matrix a normalized matrix.
-	//! From GLM_GTX_matrix_query extension.
-	template<typename T> 
+		detail::tmat2x2<valType> const & m, 
+		valType const & epsilon/* = std::numeric_limits<valType>::epsilon()*/);
+
+	/// Return whether a matrix is a normalized matrix.
+	/// From GLM_GTX_matrix_query extension.
+	template<typename valType>   
 	bool isNormalized(
-		detail::tmat3x3<T> const & m, 
-		T const & epsilon = std::numeric_limits<T>::epsilon());
-		
-	//! Return if a matrix a normalized matrix.
-	//! From GLM_GTX_matrix_query extension.
-	template<typename T> 
+		detail::tmat3x3<valType> const & m, 
+		valType const & epsilon/* = std::numeric_limits<valType>::epsilon()*/);
+
+	/// Return whether a matrix is a normalized matrix.
+	/// From GLM_GTX_matrix_query extension.
+	template<typename valType>   
 	bool isNormalized(
-		detail::tmat4x4<T> const & m, 
-		T const & epsilon = std::numeric_limits<T>::epsilon());
+		detail::tmat4x4<valType> const & m, 
+		valType const & epsilon/* = std::numeric_limits<valType>::epsilon()*/);
 
-	//! Return if a matrix an orthonormalized matrix.
-	//! From GLM_GTX_matrix_query extension.
-	template<typename genType> 
+	/// Return whether a matrix is an orthonormalized matrix.
+	/// From GLM_GTX_matrix_query extension.
+	template<typename valType, template <typename> class matType> 
 	bool isOrthogonal(
-		genType const & m, 
-		typename genType::value_type const & epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
+		matType<valType> const & m, 
+		valType const & epsilon/* = std::numeric_limits<genType>::epsilon()*/);
 
 	/// @}
 }//namespace glm

glm/gtx/matrix_query.inl

@@ -70,83 +70,83 @@ namespace glm
 		return result;
 	}
 
-	template<typename T> 
+	template<typename genType>  
 	GLM_FUNC_QUALIFIER bool isNormalized
 	(
-		detail::tmat2x2<T> const & m, 
-		T const & epsilon
+		detail::tmat2x2<genType> const & m, 
+		genType const & epsilon
 	)
 	{
-		bool result = true;
-		for(int i = 0; result && i < 2; ++i)
+		bool result(true);
+		for(detail::tmat2x2<genType>::size_type i(0); result && i < m.length(); ++i)
 			result = isNormalized(m[i], epsilon);
-		for(int i = 0; result && i < 2; ++i)
+		for(detail::tmat2x2<genType>::size_type i(0); result && i < m.length(); ++i)
 		{
-			detail::tvec2<T> v;
-			for(int j = 0; j < 2; ++j)
+			detail::tmat2x2<genType>::col_type v;
+			for(detail::tmat2x2<genType>::size_type j(0); j < m.length(); ++j)
 				v[j] = m[j][i];
 			result = isNormalized(v, epsilon);
 		}
 		return result;
 	}
 
-	template<typename T> 
+	template<typename genType>  
 	GLM_FUNC_QUALIFIER bool isNormalized
 	(
-		detail::tmat3x3<T> const & m, 
-		T const & epsilon
+		detail::tmat3x3<genType> const & m, 
+		genType const & epsilon
 	)
 	{
-		bool result = true;
-		for(int i = 0; result && i < 3; ++i)
+		bool result(true);
+		for(detail::tmat3x3<genType>::size_type i(0); result && i < m.length(); ++i)
 			result = isNormalized(m[i], epsilon);
-		for(int i = 0; result && i < 3; ++i)
+		for(detail::tmat3x3<genType>::size_type i(0); result && i < m.length(); ++i)
 		{
-			detail::tvec3<T> v;
-			for(int j = 0; j < 3; ++j)
+			detail::tmat3x3<genType>::col_type v;
+			for(detail::tmat3x3<genType>::size_type j(0); j < m.length(); ++j)
 				v[j] = m[j][i];
 			result = isNormalized(v, epsilon);
 		}
 		return result;
 	}
 
-	template<typename T> 
+	template<typename genType>  
 	GLM_FUNC_QUALIFIER bool isNormalized
 	(
-		detail::tmat4x4<T> const & m, 
-		T const & epsilon
+		detail::tmat4x4<genType> const & m, 
+		genType const & epsilon
 	)
 	{
-		bool result = true;
-		for(int i = 0; result && i < 4; ++i)
+		bool result(true);
+		for(detail::tmat4x4<genType>::size_type i(0); result && i < m.length(); ++i)
 			result = isNormalized(m[i], epsilon);
-		for(int i = 0; result && i < 4; ++i)
+		for(detail::tmat4x4<genType>::size_type i(0); result && i < m.length(); ++i)
 		{
-			detail::tvec4<T> v;
-			for(int j = 0; j < 4; ++j)
+			detail::tmat4x4<genType>::col_type v;
+			for(detail::tmat4x4<genType>::size_type j(0); j < m.length(); ++j)
 				v[j] = m[j][i];
 			result = isNormalized(v, epsilon);
 		}
 		return result;
 	}
 
-	template<typename genType> 
+	template<typename genType, template <typename> class matType>  
 	GLM_FUNC_QUALIFIER bool isOrthogonal
 	(
-		genType const & m, 
-		typename genType::value_type const & epsilon
+		matType<genType> const & m, 
+		genType const & epsilon
 	)
 	{
-		bool result = true;
-		for(int i = 0; result && i < genType::col_size() - 1; ++i)
-		for(int j= i + 1; result && j < genType::col_size(); ++j)
+		bool result(true);
+		for(typename matType<genType>::size_type i(0); result && i < m.length() - 1; ++i)
+		for(typename matType<genType>::size_type j(i + 1); result && j < m.length(); ++j)
 			result = areOrthogonal(m[i], m[j], epsilon);
 
 		if(result)
 		{
-			genType tmp = transpose(m);
-			for(int i = 0; result && i < genType::col_size() - 1 ; ++i)
-			for(int j = i + 1; result && j < genType::col_size(); ++j)
+			matType<genType> tmp = transpose(m);
+			for(typename matType<genType>::size_type i(0); result && i < m.length() - 1 ; ++i)
+			for(typename matType<genType>::size_type j(i + 1); result && j < m.length(); ++j)
 				result = areOrthogonal(tmp[i], tmp[j], epsilon);
 		}
 		return result;

glm/gtx/vector_query.hpp

@@ -52,59 +52,73 @@ namespace glm
 	/// @addtogroup gtx_vector_query
 	/// @{
 
-	//! Check if two vectors are collinears.
+	//! Check whether two vectors are collinears.
 	//! From GLM_GTX_vector_query extensions.
 	template <typename genType> 
 	bool areCollinear(
 		genType const & v0, 
 		genType const & v1, 
-		typename genType::value_type const & epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
+		typename genType::value_type const & epsilon/* = std::numeric_limits<typename genType::value_type>::epsilon()*/);
 		
-    //! Check if two vectors are opposites.
+    //! Check whether two vectors are opposites.
 	//! From GLM_GTX_vector_query extensions.
 	template <typename genType> 
 	bool areOpposite(
 		genType const & v0, 
 		genType const & v1, 
-		typename genType::value_type const & epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
+		typename genType::value_type const & epsilon/* = std::numeric_limits<typename genType::value_type>::epsilon()*/);
 		
-    //! Check if two vectors are orthogonals.
+    //! Check whether two vectors are orthogonals.
 	//! From GLM_GTX_vector_query extensions.
 	template <typename genType> 
 	bool areOrthogonal(
 		genType const & v0, 
 		genType const & v1, 
-		typename genType::value_type const & epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
+		typename genType::value_type const & epsilon/* = std::numeric_limits<typename genType::value_type>::epsilon()*/);
 
-	//! Check if a vector is normalized.
+	//! Check whether a vector is normalized.
 	//! From GLM_GTX_vector_query extensions.
-	template <typename genType> 
+	template <typename genType, template <typename> class vecType> 
 	bool isNormalized(
-		genType const & v, 
-		typename genType::value_type const & epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
+		vecType<genType> const & v, 
+		genType const & epsilon/* = std::numeric_limits<genType>::epsilon()*/);
 		
-	//! Check if a vector is null.
+	//! Check whether a vector is null.
 	//! From GLM_GTX_vector_query extensions.
-	template <typename genType> 
+	template <typename valType> 
+	bool isNull(
+		detail::tvec2<valType> const & v, 
+		valType const & epsilon/* = std::numeric_limits<typename genType::value_type>::epsilon()*/);
+
+	//! Check whether a vector is null.
+	//! From GLM_GTX_vector_query extensions.
+	template <typename valType> 
+	bool isNull(
+		detail::tvec3<valType> const & v, 
+		valType const & epsilon/* = std::numeric_limits<typename genType::value_type>::epsilon()*/);
+
+	//! Check whether a vector is null.
+	//! From GLM_GTX_vector_query extensions.
+	template <typename valType> 
 	bool isNull(
-		genType const & v, 
-		typename genType::value_type const & epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
+		detail::tvec4<valType> const & v, 
+		valType const & epsilon/* = std::numeric_limits<typename genType::value_type>::epsilon()*/);
 
-	//! Check if two vectors are orthonormal.
+	//! Check whether two vectors are orthonormal.
 	//! From GLM_GTX_vector_query extensions.
 	template <typename genType>
 	bool areOrthonormal(
 		genType const & v0, 
 		genType const & v1, 
-		typename genType::value_type const & epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
+		typename genType::value_type const & epsilon/* = std::numeric_limits<typename genType::value_type>::epsilon()*/);
 
-	//! Check if two vectors are similar.
+	//! Check whether two vectors are similar.
 	//! From GLM_GTX_vector_query extensions.
 	template <typename genType> 
 	bool areSimilar(
 		genType const & v0, 
 		genType const & v1, 
-		typename genType::value_type const & epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
+		typename genType::value_type const & epsilon/* = std::numeric_limits<typename genType::value_type>::epsilon()*/);
 
 	/// @}
 }// namespace glm

glm/gtx/vector_query.inl

@@ -74,21 +74,41 @@ namespace glm
 				length(v1)) * epsilon;
 	}
 
-	template <typename genType> 
+	template <typename genType, template <typename> class vecType> 
 	GLM_FUNC_QUALIFIER bool isNormalized
 	(
-		genType const & v, 
-		typename genType::value_type const & epsilon
+		vecType<genType> const & v, 
+		genType const & epsilon
 	)
 	{
-		return abs(length(v) - typename genType::value_type(1)) <= typename genType::value_type(2) * epsilon;
+		return abs(length(v) - genType(1)) <= genType(2) * epsilon;
 	}
 
-	template <typename genType> 
+	template <typename valType> 
 	GLM_FUNC_QUALIFIER bool isNull
 	(
-		genType const & v, 
-		typename genType::value_type const & epsilon
+		detail::tvec2<valType> const & v, 
+		valType const & epsilon
+	)
+	{
+		return length(v) <= epsilon;
+	}
+
+	template <typename valType> 
+	GLM_FUNC_QUALIFIER bool isNull
+	(
+		detail::tvec3<valType> const & v, 
+		valType const & epsilon
+	)
+	{
+		return length(v) <= epsilon;
+	}
+
+	template <typename valType> 
+	GLM_FUNC_QUALIFIER bool isNull
+	(
+		detail::tvec4<valType> const & v, 
+		valType const & epsilon
 	)
 	{
 		return length(v) <= epsilon;

test/gtx/CMakeLists.txt

@@ -1,6 +1,7 @@
 glmCreateTestGTC(gtx_bit)
 glmCreateTestGTC(gtx_gradient_paint)
 glmCreateTestGTC(gtx_integer)
+glmCreateTestGTC(gtx_matrix_query)
 glmCreateTestGTC(gtx_noise)
 glmCreateTestGTC(gtx_quaternion)
 glmCreateTestGTC(gtx_random)

test/gtx/gtx_matrix_query.cpp

@@ -0,0 +1,54 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2011-11-22
+// Updated : 2011-11-22
+// Licence : This source is under MIT licence
+// File    : test/gtx/matrix_query.cpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#include <glm/glm.hpp>
+#include <glm/gtx/matrix_query.hpp>
+
+int test_isNull()
+{
+    int Error(0);
+    
+	bool TestA = glm::isNull(glm::mat4(0), 0.00001f);
+    Error += TestA ? 0 : 1;
+
+    return Error;
+}
+
+int test_isNormalized()
+{
+    int Error(0);
+    
+	bool TestA = glm::isNormalized(glm::mat4(1), 0.00001f);
+    Error += TestA ? 0 : 1;
+
+    return Error;
+}
+
+int test_isOrthogonal()
+{
+    int Error(0);
+    
+	bool TestA = glm::isOrthogonal(glm::mat4(1), 0.00001f);
+    Error += TestA ? 0 : 1;
+
+    return Error;
+}
+
+int main()
+{
+	int Error(0);
+
+	Error += test_isNull();
+	Error += test_isNormalized();
+	Error += test_isOrthogonal();
+
+	return Error;
+}
+
+