Merge branch '0.9.2' of ssh://ogl-math.git.sourceforge.net/gitroot/ogl-math/ogl-math into 0.9.2

glm/gtc/half_float.hpp

@@ -17,13 +17,9 @@
 #	pragma message("GLM: GLM_GTC_half_float extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace detail
 {
-	namespace test{
-		bool main_gtc_half_float();
-	}//namespace 
-	namespace detail
-	{
 #ifndef _MSC_EXTENSIONS
 	template <>
 	struct tvec2<thalf>
@@ -319,49 +315,48 @@ namespace glm
 		tref4<thalf> swizzle(comp X, comp Y, comp Z, comp W);
 	};
 #endif//_MSC_EXTENSIONS
-	}
+}
-	//namespace detail
+//namespace detail
 
-	namespace gtc{
+namespace gtc{
-	//! GLM_GTC_half_float extension: Add support for half precision floating-point types
+namespace half_float ///< GLM_GTC_half_float extension: Add support for half precision floating-point types
-	namespace half_float
+{
-	{
 	/// \addtogroup gtc_half_float
 	///@{
 
-		//! Type for half-precision floating-point numbers. 
+	/// Type for half-precision floating-point numbers. 
-		//! From GLM_GTC_half_float extension.
+	/// From GLM_GTC_half_float extension.
 	typedef detail::thalf					half;
 
-		//! Vector of 2 half-precision floating-point numbers. 
+	/// Vector of 2 half-precision floating-point numbers. 
-		//! From GLM_GTC_half_float extension.
+	/// From GLM_GTC_half_float extension.
 	typedef detail::tvec2<detail::thalf>	hvec2;
 
-		//! Vector of 3 half-precision floating-point numbers.
+	/// Vector of 3 half-precision floating-point numbers.
-		//! From GLM_GTC_half_float extension.
+	/// From GLM_GTC_half_float extension.
 	typedef detail::tvec3<detail::thalf>	hvec3;
 
-		//! Vector of 4 half-precision floating-point numbers. 
+	/// Vector of 4 half-precision floating-point numbers. 
-		//! From GLM_GTC_half_float extension.
+	/// From GLM_GTC_half_float extension.
 	typedef detail::tvec4<detail::thalf>	hvec4;
 
-		//! 2 * 2 matrix of half-precision floating-point numbers.
+	/// 2 * 2 matrix of half-precision floating-point numbers.
-		//! From GLM_GTC_half_float extension.
+	/// From GLM_GTC_half_float extension.
 	typedef detail::tmat2x2<detail::thalf>	hmat2;
 
-		//! 3 * 3 matrix of half-precision floating-point numbers.
+	/// 3 * 3 matrix of half-precision floating-point numbers.
-		//! From GLM_GTC_half_float extension.
+	/// From GLM_GTC_half_float extension.
 	typedef detail::tmat3x3<detail::thalf>	hmat3;
 
-		//! 4 * 4 matrix of half-precision floating-point numbers.
+	/// 4 * 4 matrix of half-precision floating-point numbers.
-		//! From GLM_GTC_half_float extension.
+	/// From GLM_GTC_half_float extension.
 	typedef detail::tmat4x4<detail::thalf>	hmat4;
 
-		///@}
+	/// @}
 
-	}//namespace half_float
+}// namespace half_float
-	}//namespace gtc
+}// namespace gtc
-}//namespace glm
+}// namespace glm
 
 #include "half_float.inl"
 

glm/gtc/matrix_access.hpp

@@ -22,8 +22,7 @@
 
 namespace glm{
 namespace gtc{
-//! GLM_GTC_matrix_access extension: Set a column or a row of a matrix
+namespace matrix_access ///< GLM_GTC_matrix_access extension: Set a column or a row of a matrix
-namespace matrix_access
 {
 	/// \addtogroup gtc_matrix_access
 	///@{

glm/gtc/matrix_integer.hpp

@@ -20,16 +20,10 @@
 #	pragma message("GLM: GLM_GTC_matrix_integer extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtc{
+namespace matrix_integer ///< GLM_GTC_matrix_integer extension: Add integer matrices
 {
-	namespace test{
-		bool main_gtc_matrix_integer();
-	}//namespace test
-
-	namespace gtc{
-	//! GLM_GTC_matrix_integer extension: Add integer matrices
-	namespace matrix_integer
-	{
 	/// \addtogroup gtc_matrix_integer
 	///@{
 
@@ -201,8 +195,8 @@ namespace glm
 
 	///@}
 
-	}//namespace matrix_integer
+}//namespace matrix_integer
-	}//namespace gtc
+}//namespace gtc
 }//namespace glm
 
 namespace glm{using namespace gtc::matrix_integer;}

glm/gtc/matrix_inverse.hpp

@@ -22,8 +22,7 @@
 
 namespace glm{
 namespace gtc{
-//! GLM_GTC_matrix_inverse extension: Inverse matrix functions
+namespace matrix_inverse ///< GLM_GTC_matrix_inverse extension: Inverse matrix functions
-namespace matrix_inverse
 {
 	/// \addtogroup gtc_matrix_inverse
 	///@{

glm/gtc/matrix_transform.hpp

@@ -21,16 +21,10 @@
 #	pragma message("GLM: GLM_GTC_matrix_transform extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtc{
+namespace matrix_transform ///< GLM_GTC_matrix_transform extension: Add transformation matrices
 {
-	namespace test{
-		bool main_gtc_matrix_transform();
-	}//namespace test
-
-	namespace gtc{
-	//! GLM_GTC_matrix_transform extension: Add transformation matrices
-	namespace matrix_transform
-	{
 	/// \addtogroup gtc_matrix_transform
 	///@{
 
@@ -153,8 +147,8 @@ namespace glm
 		detail::tvec3<T> const & up);
 
 	///@}
-	}//namespace matrix_transform
+}//namespace matrix_transform
-	}//namespace gtc
+}//namespace gtc
 }//namespace glm
 
 #include "matrix_transform.inl"

glm/gtc/quaternion.hpp

@@ -26,14 +26,9 @@
 #	pragma message("GLM: GLM_GTC_quaternion extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace detail
 {
-	namespace test{
-		bool main_gtc_quaternion();
-	}//namespace test
-
-	namespace detail
-	{
 	//! \brief Template for quaternion. 
 	//! From GLM_GTC_quaternion extension.
 	/// \ingroup gtc_quaternion
@@ -119,12 +114,11 @@ namespace glm
 		detail::tquat<T> const & q, 
 		typename detail::tquat<T>::value_type const & s);
 
-	} //namespace detail
+} //namespace detail
 
-	namespace gtc{
+namespace gtc{
-	//! GLM_GTC_quaternion extension: Quaternion types and functions
+namespace quaternion ///< GLM_GTC_quaternion extension: Quaternion types and functions
-    namespace quaternion
+{
-    {
 	/// \addtogroup gtc_quaternion
 	///@{
 
@@ -224,8 +218,8 @@ namespace glm
 
 	///@}
 
-    }//namespace quaternion
+} //namespace quaternion
-    }//namespace gtc
+} //namespace gtc
 } //namespace glm
 
 #include "quaternion.inl"

glm/gtc/swizzle.hpp

@@ -21,16 +21,10 @@
 #	pragma message("GLM: GLM_GTC_swizzle extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtc{
+namespace swizzle ///< GLM_GTC_swizzle extension
 {
-	namespace test{
-		void main_gtc_swizzle();
-	}//namespace test
-
-	namespace gtc{
-	//! GLM_GTC_swizzle extension
-	namespace swizzle
-	{
 	using namespace gtc::half_float;
 
 	template <typename T, template <typename> class vecType>
@@ -346,8 +340,8 @@ namespace glm
 	static_swizzle4_ref(glm::u32vec4)
 	static_swizzle4_ref(glm::u64vec4)
 
-	}//namespace swizzle
+}//namespace swizzle
-	}//namespace gtc
+}//namespace gtc
 }//namespace glm
 
 #include "swizzle.inl"

glm/gtc/type_precision.hpp

@@ -24,16 +24,10 @@
 #	pragma message("GLM: GLM_GTC_type_precision extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtc{
+namespace type_precision ///< GLM_GTC_type_precision extension: Defined types with specific size.
 {
-	namespace test{
-		bool main_gtc_type_precision();
-	}//namespace test
-
-	namespace gtc{
-	//! GLM_GTC_type_precision extension: Defined types with specific size.
-	namespace type_precision
-	{
 	///////////////////////////
 	// Dependences
 
@@ -215,8 +209,8 @@ namespace glm
 
 	///@}
 
-	}//namespace type_precision
+}//namespace type_precision
-	}//namespace gtc
+}//namespace gtc
 }//namespace glm
 
 #include "type_precision.inl"

glm/gtc/type_ptr.hpp

@@ -21,15 +21,10 @@
 #	pragma message("GLM: GLM_GTC_type_ptr extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtc{
+namespace type_ptr ///< GLM_GTC_type_ptr extension: Get access to vectors & matrices value type address.
 { 
-	namespace test{
-		void main_gtc_type_ptr();
-	}//namespace test
-
-	namespace gtc{
-	//! GLM_GTC_type_ptr extension: Get access to vectors & matrices value type address.
-	namespace type_ptr{
 
 	/// \addtogroup gtc_type_ptr
 	///@{
@@ -442,8 +437,8 @@ namespace glm
         
 	///@}
 
-	}//namespace type_ptr
+}//namespace type_ptr
-	}//namespace gtc
+}//namespace gtc
 }//namespace glm
 
 #include "type_ptr.inl"

glm/gtx/associated_min_max.hpp

@@ -21,17 +21,10 @@
 #	pragma message("GLM: GLM_GTX_associated_min_max extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace associated_min_max ///< GLM_GTX_associated_min_max extension: Min and max functions that return associated values not the compared onces.
 {
-	namespace test{
-		void main_gtx_associated_min_max();
-	}//namespace test
-
-	namespace gtx
-	{
-		//! GLM_GTX_associated_min_max extension: Min and max functions that return associated values not the compared onces.
-		namespace associated_min_max
-		{
 	/// \addtogroup gtx_associated_min_max
 	///@{
 
@@ -76,13 +69,11 @@ namespace glm
 		const genTypeT& y, const genTypeU& b, 
 		const genTypeT& z, const genTypeU& c, 
 		const genTypeT& w, const genTypeU& d);
+
 	///@}
-
+} //namespace associated_min_max
-		}//namespace associated_min_max
+} //namespace gtx
-
+} //namespace glm
-		bool test();
-	}//namespace gtx
-}//namespace glm
 
 #include "associated_min_max.inl"
 

glm/gtx/bit.hpp

@@ -22,16 +22,10 @@
 #	pragma message("GLM: GLM_GTX_bit extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace bit ///< GLM_GTX_bit extension: Allow to perform bit operations on integer values
 {
-	namespace test{
-		void main_gtx_bit();
-	}//namespace test
-
-	namespace gtx{
-	//! GLM_GTX_bit extension: Allow to perform bit operations on integer values
-	namespace bit
-	{
 	using namespace gtc::half_float;
 
 	/// \addtogroup gtx_bit
@@ -102,9 +96,8 @@ namespace glm
 	genType bitRotateLeft(genType const & In, std::size_t Shift);
 
 	///@}
-
+}//namespace bit
-	}//namespace bit
+}//namespace gtx
-	}//namespace gtx
 }//namespace glm
 
 #include "bit.inl"

glm/gtx/closest_point.hpp

@@ -20,31 +20,25 @@
 #	pragma message("GLM: GLM_GTX_closest_point extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace closest_point ///< GLM_GTX_closest_point extension: Find the point on a straight line which is the closet of a point.
 {
-	namespace test{
-		void main_gtx_closest_point();
-	}//namespace test
-
-	namespace gtx{
-	//! GLM_GTX_closest_point extension: Find the point on a straight line which is the closet of a point.
-	namespace closest_point{
-
 	/// \addtogroup gtx_closest_point
-	///@{
+	/// @{
 
-	//! Find the point on a straight line which is the closet of a point. 
+	/// Find the point on a straight line which is the closet of a point. 
-	//! From GLM_GTX_closest_point extension.
+	/// From GLM_GTX_closest_point extension.
 	template <typename T> 
 	detail::tvec3<T> closestPointOnLine(
 		detail::tvec3<T> const & point, 
 		detail::tvec3<T> const & a, 
 		detail::tvec3<T> const & b);
-	///@}
 
-	}//namespace closest_point
+	/// @}
-	}//namespace gtx
+}// namespace closest_point
-}//namespace glm
+}// namespace gtx
+}// namespace glm
 
 #include "closest_point.inl"
 

glm/gtx/color_cast.hpp

@@ -22,16 +22,10 @@
 #	pragma message("GLM: GLM_GTX_color_cast extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace color_cast ///< GLM_GTX_color_cast extension: Conversion between two color types
 {
-	namespace test{
-		void main_ext_gtx_color_cast();
-	}//namespace test
-
-	namespace gtx{
-	//! GLM_GTX_color_cast extension: Conversion between two color types
-	namespace color_cast
-	{
 	using namespace gtx::number_precision;
 
 	/// \addtogroup gtx_color_cast
@@ -102,8 +96,8 @@ namespace glm
 	template <typename T> gtc::type_precision::f64vec4 f64_abgr_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 4 components floating color. (From GLM_GTX_color_cast extension)
 
 	///@}
-	}//namespace color_space
+}//namespace color_space
-	}//namespace gtx
+}//namespace gtx
 }//namespace glm
 
 #include "color_cast.inl"

glm/gtx/color_space.hpp

@@ -20,18 +20,12 @@
 #	pragma message("GLM: GLM_GTX_color_space extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace color_space ///< GLM_GTX_color_space extension: Related to RGB to HSV conversions and operations
 {
-	namespace test{
-		void main_gtx_color_space();
-	}//namespace test
-
-    namespace gtx{
-	//! GLM_GTX_color_space extension: Related to RGB to HSV conversions and operations
-    namespace color_space
-    {
 	/// \addtogroup gtx_color_space
-		///@{
+	/// @{
 
 	//! Converts a color from HSV color space to its color in RGB color space.
 	//! From GLM_GTX_color_space extension.
@@ -71,10 +65,9 @@ namespace glm
 	valType luminosity(
 		detail::tvec3<valType> const & color);
 
-		///@}
+	/// @}
-		
+}//namespace color_space
-	}//namespace color_space
+}//namespace gtx
-	}//namespace gtx
 }//namespace glm
 
 #include "color_space.inl"

glm/gtx/color_space_YCoCg.hpp

@@ -20,16 +20,10 @@
 #	pragma message("GLM: GLM_GTX_color_space_YCoCg extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace color_space_YCoCg ///< GLM_GTX_color_space_YCoCg extension: RGB to YCoCg conversions and operations
 {
-	namespace test{
-		void main_gtx_color_space_YCoCg();
-	}//namespace test
-
-    namespace gtx{
-	//! GLM_GTX_color_space_YCoCg extension: RGB to YCoCg conversions and operations
-    namespace color_space_YCoCg
-    {
 	/// \addtogroup gtx_color_space_YCoCg
 	///@{
 
@@ -59,9 +53,9 @@ namespace glm
 	detail::tvec3<valType> YCoCgR2rgb(
 		detail::tvec3<valType> const & YCoCgColor);
 
-		///@}
+	/// @}
-	}//namespace color_space_YCoCg
+}//namespace color_space_YCoCg
-	}//namespace gtx
+}//namespace gtx
 }//namespace glm
 
 #include "color_space_YCoCg.inl"

glm/gtx/compatibility.hpp

@@ -28,16 +28,10 @@
 #include <cmath>
 #endif//GLM_COMPILER
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace compatibility ///< GLM_GTX_compatibility extension: Provide functions to increase the compatibility with Cg and HLSL languages
 {
-	namespace test{
-		void main_gtx_compatibility();
-	}//namespace test
-
-	namespace gtx{
-	//! GLM_GTX_compatibility extension: Provide functions to increase the compatibility with Cg and HLSL languages
-	namespace compatibility
-	{
 	/// \addtogroup gtx_compatibility
 	///@{
 
@@ -154,10 +148,9 @@ namespace glm
 	typedef detail::tmat4x3<double>		double4x3;		//!< \brief double-precision floating-point matrix with 4 x 3 components. (From GLM_GTX_compatibility extension)
 	typedef detail::tmat4x4<double>		double4x4;		//!< \brief double-precision floating-point matrix with 4 x 4 components. (From GLM_GTX_compatibility extension)
 
-		///@}
+	/// @}
-
+}//namespace compatibility
-	}//namespace compatibility
+}//namespace gtx
-	}//namespace gtx
 }//namespace glm
 
 #include "compatibility.inl"

glm/gtx/component_wise.hpp

@@ -20,18 +20,12 @@
 #	pragma message("GLM: GLM_GTX_component_wise extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace component_wise ///< GLM_GTX_component_wise extension: Operations between components of a type
 {
-	namespace test{
-		void main_gtx_component_wise();
-	}//namespace test
-
-	namespace gtx{
-	//! GLM_GTX_component_wise extension: Operations between components of a type
-	namespace component_wise
-	{
 	/// \addtogroup gtx_component_wise
-		///@{
+	/// @{
 
 	//! Add all vector components together. 
 	//! From GLM_GTX_component_wise extension.
@@ -57,10 +51,9 @@ namespace glm
 	typename genType::value_type compMax(
 		genType const & v);
 
-		///@}
+	/// @}
-
+}//namespace component_wise
-	}//namespace component_wise
+}//namespace gtx
-	}//namespace gtx
 }//namespace glm
 
 #include "component_wise.inl"

glm/gtx/epsilon.hpp

@@ -22,16 +22,10 @@
 #	pragma message("GLM: GLM_GTX_epsilon extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace epsilon ///< GLM_GTX_epsilon extension: Comparison functions for a user defined epsilon values.
 {
-	namespace test{
-		void main_gtx_epsilon();
-	}//namespace test
-
-	namespace gtx{
-	//! GLM_GTX_epsilon extension: Comparison functions for a user defined epsilon values.
-	namespace epsilon
-	{
 	/// \addtogroup gtx_epsilon
 	///@{
 
@@ -52,9 +46,8 @@ namespace glm
 		genTypeU const & epsilon);
 
 	///@}
-
+}//namespace epsilon
-	}//namespace epsilon
+}//namespace gtx
-	}//namespace gtx
 }//namespace glm
 
 #include "epsilon.inl"

glm/gtx/euler_angles.hpp

@@ -26,14 +26,12 @@
 #	pragma message("GLM: GLM_GTX_euler_angles extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace euler_angles ///< GLM_GTX_euler_angles extension: Build matrices from Euler angles.
 {
-    namespace gtx{
-	//! GLM_GTX_euler_angles extension: Build matrices from Euler angles.
-	namespace euler_angles
-	{
 	/// \addtogroup gtx_euler_angles
-		///@{
+	/// @{
 
 	//! Creates a 3D 4 * 4 homogeneous rotation matrix from an euler angle X.
 	//! From GLM_GTX_euler_angles extension.
@@ -131,9 +129,9 @@ namespace glm
 	template <typename T> 
 	detail::tmat4x4<T> orientate4(detail::tvec3<T> const & angles);
 
-		///@}
+	/// @}
-	}//namespace euler_angles
+}//namespace euler_angles
-    }//namespace gtx
+}//namespace gtx
 }//namespace glm
 
 #include "euler_angles.inl"

glm/gtx/extend.hpp

@@ -20,18 +20,12 @@
 #	pragma message("GLM: GLM_GTX_extend extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace extend ///< GLM_GTX_extend extension: Extend a position from a source to a position at a defined length.
 {
-   	namespace test{
-		void main_gtx_extend();
-	}//namespace test
-
-	namespace gtx{
-	//! GLM_GTX_extend extension: Extend a position from a source to a position at a defined length.
-	namespace extend
-	{
 	/// \addtogroup gtx_extend
-		///@{
+	/// @{
 
 	//! Extends of Length the Origin position using the (Source - Origin) direction.
 	//! From GLM_GTX_extend extension.
@@ -41,10 +35,9 @@ namespace glm
 		genType const & Source, 
 		typename genType::value_type const Length);
 
-		///@}
+	/// @}
-
+}//namespace extend
-	}//namespace extend
+}//namespace gtx
-	}//namespace gtx
 }//namespace glm
 
 #include "extend.inl"

glm/gtx/extented_min_max.hpp

@@ -22,16 +22,10 @@
 #	pragma message("GLM: GLM_GTX_extented_min_max extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace extented_min_max ///< GLM_GTX_extented_min_max extension: Min and max functions for 3 to 4 parameters.
 {
-   	namespace test{
-		void main_ext_gtx_extented_min_max();
-	}//namespace test
-
-	namespace gtx{
-	//! GLM_GTX_extented_min_max extension: Min and max functions for 3 to 4 parameters.
-	namespace extented_min_max
-	{
 	/// \addtogroup gtx_extented_min_max
 	///@{
 
@@ -169,10 +163,9 @@ namespace glm
 		C<T> const & z, 
 		C<T> const & w);
 
-		///@}
+	/// @}
-
+}//namespace extented_min_max
-	}//namespace extented_min_max
+}//namespace gtx
-	}//namespace gtx
 }//namespace glm
 
 #include "extented_min_max.inl"

glm/gtx/fast_exponential.hpp

@@ -22,19 +22,13 @@
 #	pragma message("GLM: GLM_GTX_fast_exponential extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace fast_exponential ///< GLM_GTX_fast_exponential extension: Fast but less accurate implementations of exponential based functions.
 {
-   	namespace test{
-		void main_gtx_fast_exponential();
-	}//namespace test
-
-	namespace gtx{
-	//! GLM_GTX_fast_exponential extension: Fast but less accurate implementations of exponential based functions.
-	namespace fast_exponential
-	{
 	using namespace gtc::half_float;
 	/// \addtogroup gtx_fast_exponential
-		///@{
+	/// @{
 
 	//! Faster than the common pow function but less accurate.
 	//! From GLM_GTX_fast_exponential extension.
@@ -75,10 +69,9 @@ namespace glm
 	template <typename T> 
 	T fastLn(const T& x);
 
-		///@}
+	/// @}
-
+}//namespace fast_exponential
-	}//namespace fast_exponential
+}//namespace gtx
-	}//namespace gtx
 }//namespace glm
 
 #include "fast_exponential.inl"

glm/gtx/fast_square_root.hpp

@@ -24,18 +24,12 @@
 #	pragma message("GLM: GLM_GTX_fast_square_root extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace fast_square_root 	///< GLM_GTX_fast_square_root extension: Fast but less accurate implementations of square root based functions.
 {
-   	namespace test{
-		void main_gtx_fast_square_root();
-	}//namespace test
-
-	namespace gtx{
-	//! GLM_GTX_fast_square_root extension: Fast but less accurate implementations of square root based functions.
-	namespace fast_square_root
-	{
 	/// \addtogroup gtx_fast_square_root
-		///@{
+	/// @{
 
 	//! Faster than the common sqrt function but less accurate.
 	//! From GLM_GTX_fast_square_root extension.
@@ -62,11 +56,10 @@ namespace glm
 	template <typename genType> 
 	genType fastNormalize(genType const & x);
 
-		///@}
+	/// @}
-
+}// namespace fast_square_root
-	}//namespace fast_square_root
+}// namespace gtx
-	}//	namespace gtx
+}// namespace glm
-}//namespace glm
 
 #include "fast_square_root.inl"
 

glm/gtx/fast_trigonometry.hpp

@@ -20,18 +20,12 @@
 #	pragma message("GLM: GLM_GTX_fast_trigonometry extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace fast_trigonometry	///< GLM_GTX_fast_trigonometry extension: Fast but less accurate implementations of trigonometric functions.
 {
-   	namespace test{
-		void main_gtx_fast_trigonometry();
-	}//namespace test
-
-    namespace gtx{
-	//! GLM_GTX_fast_trigonometry extension: Fast but less accurate implementations of trigonometric functions.
-    namespace fast_trigonometry
-    {
 	/// \addtogroup gtx_fast_trigonometry
-		///@{
+	/// @{
 
 	//! Faster than the common sin function but less accurate. 
 	//! Defined between -2pi and 2pi. 
@@ -75,10 +69,9 @@ namespace glm
     template <typename T> 
 	T fastAtan(const T& angle);
 
-		///@}
+	/// @}
-
+}//namespace fast_trigonometry
-    }//namespace fast_trigonometry
+}//namespace gtx
-    }//namespace gtx
 }//namespace glm
 
 #include "fast_trigonometry.inl"

glm/gtx/gradient_paint.hpp

@@ -21,18 +21,15 @@
 #	pragma message("GLM: GLM_GTX_gradient_paint extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace gradient_paint ///< GLM_GTX_gradient_paint extension: Compute a radient gradient according section OpenVG 1.1 specifications, 9.3.2 Radial Gradients
 {
-	namespace test{
-		void main_gtx_gradient_paint();
-	}//namespace test
-
-	namespace gtx{
-	//! GLM_GTX_gradient_paint extension: Compute a radient gradient according section OpenVG 1.1 specifications, 9.3.2 Radial Gradients
-	namespace gradient_paint
-	{
 	using namespace gtx::optimum_pow;
 
+	/// \addtogroup gtx_gradient_paint
+	/// @{
+
 	template <typename valType>
 	valType radialGradient(
 		glm::detail::tvec2<valType> const & Center,
@@ -46,9 +43,10 @@ namespace glm
 		glm::detail::tvec2<valType> const & Point1,
 		glm::detail::tvec2<valType> const & Position);
 
-	}//namespace gradient_paint
+	/// @}
-    }//namespace gtx
+}// namespace gradient_paint
-}//namespace glm
+}// namespace gtx
+}// namespace glm
 
 #include "gradient_paint.inl"
 

glm/gtx/handed_coordinate_space.hpp

@@ -20,14 +20,12 @@
 #	pragma message("GLM: GLM_GTX_handed_coordinate_space extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace handed_coordinate_space ///< GLM_GTX_handed_coordinate_space extension: To know if a set of three basis vectors defines a right or left-handed coordinate system.
 {
-	namespace gtx{
-	//! GLM_GTX_handed_coordinate_space extension: To know if a set of three basis vectors defines a right or left-handed coordinate system.
-	namespace handed_coordinate_space
-	{
 	/// \addtogroup gtx_handed_coordinate_space
-		///@{
+	/// @{
 
 	//! Return if a trihedron right handed or not.
 	//! From GLM_GTX_handed_coordinate_space extension.
@@ -45,11 +43,10 @@ namespace glm
 		detail::tvec3<T> const & binormal, 
 		detail::tvec3<T> const & normal);
 
-		///@}
+	/// @}
-
+}// namespace handed_coordinate_space
-	}//namespace handed_coordinate_space
+}// namespace gtx
-	}//namespace gtx
+}// namespace glm
-}//namespace glm
 
 #include "handed_coordinate_space.inl"
 

glm/gtx/inertia.hpp

@@ -20,14 +20,12 @@
 #	pragma message("GLM: GLM_GTX_inertia extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace inertia ///< GLM_GTX_inertia extension: Create inertia matrices
 {
-	namespace gtx{
-	//! GLM_GTX_inertia extension: Create inertia matrices
-	namespace inertia
-	{
 	/// \addtogroup gtx_inertia
-		///@{
+	/// @{
 
 	//! Build an inertia matrix for a box.
 	//! From GLM_GTX_inertia extension.
@@ -85,11 +83,10 @@ namespace glm
 		const T Mass, 
 		const T Radius);
 
-		///@}
+	/// @}
-
+}// namespace inertia
-	}//namespace inertia
+}// namespace gtx
-	}//namespace gtx
+}// namespace glm
-}//namespace glm
 
 #include "inertia.inl"
 

glm/gtx/int_10_10_10_2.hpp

@@ -21,12 +21,10 @@
 #	pragma message("GLM: GLM_GTX_int_10_10_10_2 extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace int_10_10_10_2 ///< GLM_GTX_int_10_10_10_2 extension: Add support for integer for core functions
 {
-	namespace gtx{
-	//! GLM_GTX_int_10_10_10_2 extension: Add support for integer for core functions
-	namespace int_10_10_10_2
-	{
 	using namespace gtx::raw_data;
 
 	/// \addtogroup gtx_int_10_10_10_2
@@ -38,8 +36,8 @@ namespace glm
 
 	///@}
 
-	}//namespace integer
+}//namespace integer
-	}//namespace gtx
+}//namespace gtx
 }//namespace glm
 
 #include "int_10_10_10_2.inl"

glm/gtx/integer.hpp

@@ -20,14 +20,12 @@
 #	pragma message("GLM: GLM_GTX_integer extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace integer ///< GLM_GTX_integer extension: Add support for integer for core functions
 {
-	namespace gtx{
-	//! GLM_GTX_integer extension: Add support for integer for core functions
-	namespace integer
-	{
 	/// \addtogroup gtx_integer
-		///@{
+	/// @{
 
 	//! Returns x raised to the y power. 
 	//! From GLM_GTX_integer extension.
@@ -46,10 +44,9 @@ namespace glm
 	template <typename genType> 
 	genType factorial(genType const & x);
 
-		///@}
+	/// @}
-
+}//namespace integer
-	}//namespace integer
+}//namespace gtx
-	}//namespace gtx
 }//namespace glm
 
 #include "integer.inl"

glm/gtx/intersect.hpp

@@ -22,18 +22,12 @@
 #	pragma message("GLM: GLM_GTX_closest_point extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace intersect	///< GLM_GTX_intersect extension: Add intersection functions
 {
-	namespace test{
-		void main_gtx_intesect();
-	}//namespace test
-
-	namespace gtx{
-	//! GLM_GTX_intersect extension: Add intersection functions
-	namespace intersect
-	{
 	/// \addtogroup gtx_intersect
-		///@{
+	/// @{
 
 	//! Compute the intersection of a ray and a triangle.
 	//! From GLM_GTX_intersect extension.
@@ -67,9 +61,8 @@ namespace glm
 		genType const & center, typename genType::value_type radius,
 		genType & position, genType & normal);
 
-		///@}
+	/// @}
-
+}//namespace intersect
-	}//namespace intersect
 }//namespace gtx
 }//namespace glm
 

glm/gtx/log_base.hpp

@@ -20,18 +20,12 @@
 #	pragma message("GLM: GLM_GTX_log_base extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace log_base ///< GLM_GTX_log_base extension: Logarithm for any base. base can be a vector or a scalar.
 {
-   	namespace test{
-		void main_ext_gtx_log_base();
-	}//namespace test
-
-	namespace gtx{
-	//! GLM_GTX_log_base extension: Logarithm for any base. base can be a vector or a scalar.
-	namespace log_base
-	{
 	/// \addtogroup gtx_log_base
-		///@{
+	/// @{
 
 	//! Logarithm for any base.
 	//! From GLM_GTX_log_base.
@@ -40,10 +34,10 @@ namespace glm
 		genType const & x, 
 		genType const & base);
 
-		///@}
+	/// @}
 
-	}//namespace extend
+}//namespace extend
-	}//namespace gtx
+}//namespace gtx
 }//namespace glm
 
 #include "log_base.inl"

glm/gtx/matrix_cross_product.hpp

@@ -20,18 +20,12 @@
 #	pragma message("GLM: GLM_GTX_matrix_cross_product extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace matrix_cross_product ///< GLM_GTX_matrix_cross_product: Build cross product matrices
 {
-   	namespace test{
-		void main_gtx_matrix_cross_product();
-	}//namespace test
-
-	namespace gtx{
-	//! GLM_GTX_matrix_cross_product: Build cross product matrices
-	namespace matrix_cross_product
-	{
 	/// \addtogroup gtx_matrix_cross_product
-		///@{
+	/// @{
 
 	//! Build a cross product matrix.
 	//! From GLM_GTX_matrix_cross_product extension.
@@ -45,10 +39,9 @@ namespace glm
 	detail::tmat4x4<T> matrixCross4(
 		detail::tvec3<T> const & x);
 
-		///@}
+	/// @}
-
+}//namespace matrix_cross_product
-	}//namespace matrix_cross_product
+}//namespace gtx
-	}//namespace gtx
 }//namespace glm
 
 #include "matrix_cross_product.inl"

glm/gtx/matrix_interpolation.hpp

@@ -23,18 +23,12 @@
 #	pragma message("GLM: GLM_GTX_matrix_interpolation extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace matrix_interpolation ///< GLM_GTX_matrix_interpolation extension: Add transformation matrices
 {
-	namespace test{
-		void main_gtx_transform();
-	}//namespace test
-
-	namespace gtx{
-	//! GLM_GTX_matrix_interpolation extension: Add transformation matrices
-	namespace matrix_interpolation
-	{
 	/// \addtogroup gtx_matrix_interpolation
-		///@{
+	/// @{
 
 	//! Get the axis and angle of the rotation from a matrix.
     //! From GLM_GTX_matrix_interpolation extension.
@@ -60,10 +54,9 @@ namespace glm
         detail::tmat4x4<T> const & m2,
         T const delta);
 
-		///@}
+	/// @}
-
+}//namespace matrix_interpolation
-	}//namespace matrix_interpolation
+}//namespace gtx
-	}//namespace gtx
 }//namespace glm
 
 #include "matrix_interpolation.inl"

glm/gtx/matrix_major_storage.hpp

@@ -20,14 +20,12 @@
 #	pragma message("GLM: GLM_GTX_matrix_major_storage extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace matrix_major_storage ///< GLM_GTX_matrix_major_storage: Build matrices with specific matrix order, row or column
 {
-	namespace gtx{
-	//! GLM_GTX_matrix_major_storage: Build matrices with specific matrix order, row or column
-	namespace matrix_major_storage
-	{
 	/// \addtogroup gtx_matrix_major_storage
-		///@{
+	/// @{
 
 	//! Build a row major matrix from row vectors.
 	//! From GLM_GTX_matrix_major_storage extension.
@@ -113,10 +111,9 @@ namespace glm
 	detail::tmat4x4<T> colMajor4(
 		const detail::tmat4x4<T>& m);
 
-		///@}
+	/// @}
-		
+}//namespace matrix_major_storage
-	}//namespace matrix_major_storage
+}//namespace gtx
-	}//namespace gtx
 }//namespace glm
 
 #include "matrix_major_storage.inl"

glm/gtx/matrix_operation.hpp

@@ -20,18 +20,12 @@
 #	pragma message("GLM: GLM_GTX_matrix_operation extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace matrix_operation ///< GLM_GTX_matrix_operation: Build diagonal matrices
 {
-   	namespace test{
-		void main_gtx_matrix_operation();
-	}//namespace test
-
-	namespace gtx{
-	//! GLM_GTX_matrix_operation: Build diagonal matrices
-	namespace matrix_operation
-	{
 	/// \addtogroup gtx_matrix_operation
-		///@{
+	/// @{
 
 	//! Build a diagonal matrix.
 	//! From GLM_GTX_matrix_operation extension.
@@ -87,10 +81,9 @@ namespace glm
 	detail::tmat4x4<valType> diagonal4x4(
 		detail::tvec4<valType> const & v);
 
-		///@}
+	/// @}
-
+}//namespace matrix_operation
-	}//namespace matrix_operation
+}//namespace gtx
-	}//namespace gtx
 }//namespace glm
 
 #include "matrix_operation.inl"

glm/gtx/matrix_query.hpp

@@ -20,18 +20,12 @@
 #	pragma message("GLM: GLM_GTX_matrix_query extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace matrix_query ///< GLM_GTX_matrix_query: Query to evaluate matrix properties
 {
-   	namespace test{
-		void main_gtx_matrix_query();
-	}//namespace test
-
-	namespace gtx{
-	//! GLM_GTX_matrix_query: Query to evaluate matrix properties
-	namespace matrix_query
-	{
 	/// \addtogroup gtx_matrix_query
-		///@{
+	/// @{
 
 	//! Return if a matrix a null matrix.
 	//! From GLM_GTX_matrix_query extension.
@@ -89,9 +83,9 @@ namespace glm
 		const genType& m, 
 		const typename genType::value_type epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
 
-		///@}
+	/// @}
-	}//namespace matrix_query
+}//namespace matrix_query
-	}//namespace gtx
+}//namespace gtx
 }//namespace glm
 
 #include "matrix_query.inl"

glm/gtx/mixed_product.hpp

@@ -20,18 +20,12 @@
 #	pragma message("GLM: GLM_GTX_mixed_product extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace mixed_product ///< GLM_GTX_mixed_product extension: Mixed product of 3 vectors.
 {
-	namespace test{
-		void main_gtx_matrix_selection();
-	}//namespace test
-
-	namespace gtx{
-	//! GLM_GTX_mixed_product extension: Mixed product of 3 vectors.
-	namespace mixed_product
-	{
 	/// \addtogroup gtx_mixed_product
-		///@{
+	/// @{
 
 	//! \brief Mixed product of 3 vectors (from GLM_GTX_mixed_product extension)
 	template <typename valType> 
@@ -40,10 +34,10 @@ namespace glm
 		detail::tvec3<valType> const & v2, 
 		detail::tvec3<valType> const & v3);
 
-		///@}
+	/// @}
-	}//namespace mixed_product
+}// namespace mixed_product
-	}//namespace gtx
+}// namespace gtx
-}//namespace glm
+}// namespace glm
 
 #include "mixed_product.inl"
 

glm/gtx/multiple.hpp

@@ -20,18 +20,12 @@
 #	pragma message("GLM: GLM_GTX_multiple extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace multiple ///< GLM_GTX_multiple: Find the closest number of a number multiple of other number.
 {
-	namespace test{
-		bool main_img_multiple();
-	}//namespace test
-
-	namespace gtx{
-	//! GLM_GTX_multiple: Find the closest number of a number multiple of other number.
-	namespace multiple
-	{
 	/// \addtogroup gtx_multiple
-		///@{
+	/// @{
 
 	//! Higher Multiple number of Source.
 	//! From GLM_GTX_multiple extension.
@@ -47,10 +41,9 @@ namespace glm
 		genType const & Source, 
 		genType const & Multiple);
 
-		///@}
+	/// @}
-
+}//namespace multiple
-	}//namespace multiple
+}//namespace gtx
-	}//namespace gtx
 }//namespace glm
 
 #include "multiple.inl"

glm/gtx/noise.hpp

@@ -25,18 +25,12 @@
 #	pragma message("GLM: GLM_GTX_noise extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace noise	///< GLM_GTX_noise extension: Comparison functions for a user defined epsilon values.
 {
-	namespace test{
-		void main_gtx_noise();
-	}//namespace test
-
-	namespace gtx{
-	//! GLM_GTX_noise extension: Comparison functions for a user defined epsilon values.
-	namespace noise
-	{
 	/// \addtogroup gtx_noise
-		///@{
+	/// @{
 
 	//! Classic perlin noise.
 	//! From GLM_GTX_noise extension.
@@ -57,10 +51,9 @@ namespace glm
     T simplex(
 		vecType<T> const & p);
 
-		///@}
+	/// @}
-
+}//namespace noise
-	}//namespace noise
+}//namespace gtx
-	}//namespace gtx
 }//namespace glm
 
 #include "noise.inl"

glm/gtx/norm.hpp

@@ -25,18 +25,12 @@
 #	pragma message("GLM: GLM_GTX_norm extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace norm ///< GLM_GTX_norm extension: Various way to compute vector norms.
 {
-   	namespace test{
-		void main_gtx_norm();
-	}//namespace test
-
-	namespace gtx{
-	//! GLM_GTX_norm extension: Various way to compute vector norms.
-	namespace norm
-	{
 	/// \addtogroup gtx_norm
-		///@{
+	/// @{
 
 	//! Returns the squared length of x.
 	//! From GLM_GTX_norm extension.
@@ -137,10 +131,9 @@ namespace glm
 		const detail::tvec3<T>& x,
 		unsigned int Depth);
 
-		///@}
+	/// @}
-
+}//namespace norm
-	}//namespace norm
+}//namespace gtx
-	}//namespace gtx
 }//namespace glm
 
 #include "norm.inl"

glm/gtx/normal.hpp

@@ -20,18 +20,12 @@
 #	pragma message("GLM: GLM_GTX_normal extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace normal ///< GLM_GTX_normal extension: Compute the normal of a triangle.
 {
-   	namespace test{
-		void main_gtx_normal();
-	}//namespace test
-	
-	namespace gtx{
-	//! GLM_GTX_normal extension: Compute the normal of a triangle.
-    namespace normal
-    {
 	/// \addtogroup gtx_normal
-		///@{
+	/// @{
 
 	//! Computes triangle normal from triangle points. 
 	//! From GLM_GTX_normal extension.
@@ -41,10 +35,9 @@ namespace glm
 		detail::tvec3<T> const & p2, 
 		detail::tvec3<T> const & p3);
 
-		///@}
+	/// @}
-
+}//namespace normal
-    }//namespace normal
+}//namespace gtx
-    }//namespace gtx
 }//namespace glm
 
 #include "normal.inl"

glm/gtx/normalize_dot.hpp

@@ -22,16 +22,14 @@
 #	pragma message("GLM: GLM_GTX_normalize_dot extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace normalize_dot	///< GLM_GTX_normalize_dot extension: Dot product of vectors that need to be normalize with a single square root.
 {
-	namespace gtx{
-	//! GLM_GTX_normalize_dot extension: Dot product of vectors that need to be normalize with a single square root.
-	namespace normalize_dot
-	{
 	using namespace gtx::fast_square_root;
 
 	/// \addtogroup gtx_normalize_dot
-		///@{
+	/// @{
 
 	//! Normalize parameters and returns the dot product of x and y.
 	//! It's faster that dot(normalize(x), normalize(y)).
@@ -49,10 +47,9 @@ namespace glm
 		genType const & x, 
 		genType const & y);
 
-		///@}
+	/// @}
-
+}//namespace normalize_dot
-	}//namespace normalize_dot
+}//namespace gtx
-	}//namespace gtx
 }//namespace glm
 
 #include "normalize_dot.inl"

glm/gtx/number_precision.hpp

@@ -25,8 +25,7 @@
 
 namespace glm{
 namespace gtx{
-//! GLM_GTX_number_precision extension: Defined size types.
+namespace number_precision ///< GLM_GTX_number_precision extension: Defined size types.
-namespace number_precision
 {
 	using namespace gtc::type_precision;
 
@@ -34,7 +33,7 @@ namespace number_precision
 	// Unsigned int vector types 
 
 	/// \addtogroup gtx_number_precision
-	///@{
+	/// @{
 
 	typedef u8			u8vec1;		//!< \brief 8bit unsigned integer scalar. (from GLM_GTX_number_precision extension)
 	typedef u16			u16vec1;    //!< \brief 16bit unsigned integer scalar. (from GLM_GTX_number_precision extension)
@@ -58,7 +57,7 @@ namespace number_precision
 	typedef f64			f64mat1;	//!< \brief Double-precision floating-point scalar. (from GLM_GTX_number_precision extension)
 	typedef f64			f64mat1x1;	//!< \brief Double-precision floating-point scalar. (from GLM_GTX_number_precision extension)
 
-	///@}
+	/// @}
 }//namespace number_precision
 }//namespace gtx
 }//namespace glm

glm/gtx/ocl_type.hpp

@@ -22,14 +22,13 @@
 
 namespace glm{
 namespace gtx{
-//! GLM_GTX_ocl_type extension: OpenCL types.
+namespace ocl_type ///< GLM_GTX_ocl_type extension: OpenCL types.
-namespace ocl_type
 {
 	///////////////////////////
 	// Scalar types 
 
 	/// \addtogroup gtx_ocl_type
-	///@{
+	/// @{
 
 	typedef detail::int8						cl_char;		//!< \brief 8bit signed integer. (from GLM_GTX_ocl_type extension)
 	typedef detail::int16						cl_short;		//!< \brief 16bit signed integer. (from GLM_GTX_ocl_type extension)
@@ -99,8 +98,7 @@ namespace ocl_type
 	//typedef detail::tvec4<detail::float16>		cl_half4;	//!< \brief Half-precision floating-point scalar. (from GLM_GTX_ocl_type extension)
 	typedef detail::tvec4<detail::float32>		cl_float4;	//!< \brief Single-precision floating-point scalar. (from GLM_GTX_ocl_type extension)
 
-	///@}
+	/// @}
-
 }//namespace ocl_type
 }//namespace gtx
 }//namespace glm

glm/gtx/optimum_pow.hpp

@@ -20,18 +20,12 @@
 #	pragma message("GLM: GLM_GTX_optimum_pow extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace optimum_pow ///< GLM_GTX_optimum_pow extension: Integer exponentiation of power functions.
 {
-	namespace test{
-		void main_gtx_optimum_pow();
-	}//namespace test
-
-    namespace gtx{
-	//! GLM_GTX_optimum_pow extension: Integer exponentiation of power functions.
-    namespace optimum_pow
-    {
 	/// \addtogroup gtx_optimum_pow
-		///@{
+	/// @{
 
 	//! Returns x raised to the power of 2.
 	//! From GLM_GTX_optimum_pow extension.
@@ -64,10 +58,9 @@ namespace glm
 	//! From GLM_GTX_optimum_pow extension.
     detail::tvec4<bool> powOfTwo(const detail::tvec4<int>& x);
 
-		///@}
+	/// @}
-
+}//namespace optimum_pow
-    }//namespace optimum_pow
+}//namespace gtx
-    }//namespace gtx
 }//namespace glm
 
 #include "optimum_pow.inl"

glm/gtx/orthonormalize.hpp

@@ -20,18 +20,12 @@
 #	pragma message("GLM: GLM_GTX_orthonormalize extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace orthonormalize ///< GLM_GTX_orthonormalize extension: Orthonormalize matrices.
 {
-	namespace test{
-		void main_gtx_orthonormalize();
-	}//namespace test
-
-    namespace gtx{
-	//! GLM_GTX_orthonormalize extension: Orthonormalize matrices.
-    namespace orthonormalize
-    {
 	/// \addtogroup gtx_orthonormalize
-		///@{
+	/// @{
 
 	//! Returns the orthonormalized matrix of m.
 	//! From GLM_GTX_orthonormalize extension.
@@ -46,10 +40,9 @@ namespace glm
 		const detail::tvec3<T>& x, 
 		const detail::tvec3<T>& y);
 
-		///@}
+	/// @}
-
+}//namespace orthonormalize
-    }//namespace orthonormalize
+}//namespace gtx
-    }//namespace gtx
 }//namespace glm
 
 #include "orthonormalize.inl"

glm/gtx/perpendicular.hpp

@@ -22,18 +22,12 @@
 #	pragma message("GLM: GLM_GTX_perpendicular extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace perpendicular ///< GLM_GTX_perpendicular extension: Perpendicular of a vector from other one
 {
-	namespace test{
-		void main_gtx_perpendicular();
-	}//namespace test
-
-    namespace gtx{
-	//! GLM_GTX_perpendicular extension: Perpendicular of a vector from other one
-    namespace perpendicular
-    {
 	/// \addtogroup gtx_perpendicular
-		///@{
+	/// @{
 
 	//! Projects x a perpendicular axis of Normal.
 	//! From GLM_GTX_perpendicular extension.
@@ -56,11 +50,9 @@ namespace glm
 		detail::tvec4<T> const & x, 
 		detail::tvec4<T> const & Normal);
 
-
+	/// @}
-		///@}
+}//namespace perpendicular
-		
+}//namespace gtx
-    }//namespace perpendicular
-    }//namespace gtx
 }//namespace glm
 
 #include "perpendicular.inl"

glm/gtx/polar_coordinates.hpp

@@ -20,14 +20,12 @@
 #	pragma message("GLM: GLM_GTX_polar_coordinates extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace polar_coordinates ///< GLM_GTX_polar_coordinates extension: Conversion from Euclidean space to polar space and revert.
 {
-	namespace gtx{
-	//! GLM_GTX_polar_coordinates extension: Conversion from Euclidean space to polar space and revert.
-	namespace polar_coordinates
-	{
 	/// \addtogroup gtx_polar_coordinates
-		///@{
+	/// @{
 
 	//! Convert Euclidean to Polar coordinates, x is the xz distance, y, the latitude and z the longitude.
 	//! From GLM_GTX_polar_coordinates extension.
@@ -39,10 +37,9 @@ namespace glm
 	template <typename T> 
 	detail::tvec3<T> euclidean(const detail::tvec3<T>& polar);
 
-		///@}
+	/// @}
-
+}//namespace polar_coordinates
-	}//namespace polar_coordinates
+}//namespace gtx
-	}//namespace gtx
 }//namespace glm
 
 #include "polar_coordinates.inl"

glm/gtx/projection.hpp

@@ -20,18 +20,12 @@
 #	pragma message("GLM: GLM_GTX_projection extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace projection ///< GLM_GTX_projection extension: Projection of a vector to other one
 {
-	namespace test{
-		void main_gtx_projection();
-	}//namespace test
-
-	namespace gtx{
-	//! GLM_GTX_projection extension: Projection of a vector to other one
-	namespace projection
-	{
 	/// \addtogroup gtx_projection
-		///@{
+	/// @{
 
 	//! Projects x on Normal.
 	//! From GLM_GTX_projection extension.
@@ -54,10 +48,9 @@ namespace glm
 		detail::tvec4<T> const & x, 
 		detail::tvec4<T> const & Normal);
 
-		///@}
+	/// @}
-		
+}//namespace projection
-	}//namespace projection
+}//namespace gtx
-    }//namespace gtx
 }//namespace glm
 
 #include "projection.inl"

glm/gtx/quaternion.hpp

@@ -25,12 +25,10 @@
 #	pragma message("GLM: GLM_GTX_quaternion extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace quaternion ///< GLM_GTX_quaternion extension: Quaternion types and functions
 {
-	namespace gtx{
-	//! GLM_GTX_quaternion extension: Quaternion types and functions
-    namespace quaternion
-    {
 	using namespace gtc::quaternion;
 
 	/// \addtogroup gtx_quaternion
@@ -207,10 +205,9 @@ namespace glm
 		detail::tquat<T> const & y, 
 		T const & a);
 
-		///@}
+	/// @}
-
+}//namespace quaternion
-    }//namespace quaternion
+}//namespace gtx
-    }//namespace gtx
 } //namespace glm
 
 #include "quaternion.inl"

glm/gtx/random.hpp

@@ -25,11 +25,10 @@
 
 namespace glm{
 namespace gtx{
-//! GLM_GTX_random extension: Generate random number from various distribution methods
+namespace random ///< GLM_GTX_random extension: Generate random number from various distribution methods
-namespace random
 {
 	/// \addtogroup gtx_random
-	///@{
+	/// @{
 
 	//! Generate a random number in the interval [-1, 1], according a linear distribution.
 	//! From GLM_GTX_random extension.

glm/gtx/raw_data.hpp

@@ -22,11 +22,9 @@
 #endif
 
 namespace glm{
-namespace gtx
+namespace gtx{
+namespace raw_data ///< GLM_GTX_raw_data extension: Projection of a vector to other one
 {
-	//! GLM_GTX_raw_data extension: Projection of a vector to other one
-    namespace raw_data
-    {
 	using namespace gtc::type_precision;
 
 	/// \addtogroup gtx_raw_data
@@ -49,9 +47,9 @@ namespace gtx
 	typedef uint64		qword;
 
 	///@}
-	}
+}// namespace raw_data
-}//namespace gtx
+}// namespace gtx
-}//namespace glm
+}// namespace glm
 
 #include "raw_data.inl"
 

glm/gtx/reciprocal.hpp

@@ -17,18 +17,12 @@
 #	pragma message("GLM: GLM_GTX_reciprocal extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace reciprocal ///< GLM_GTX_reciprocal extension: Define secant, cosecant and cotangent functions.
 {
-   	namespace test{
-		void main_gtx_reciprocal();
-	}//namespace test
-
-	namespace gtx{
-	//! GLM_GTX_reciprocal extension: Define secant, cosecant and cotangent functions.
-	namespace reciprocal
-	{
 	/// \addtogroup gtx_reciprocal
-		///@{
+	/// @{
 
 	//! Secant function. 
 	//! hypotenuse / adjacent or 1 / cos(x)
@@ -93,10 +87,9 @@ namespace glm
 	template <typename genType> 
 	genType acoth(genType const & x);
 
-		///@}
+	/// @}
-
+}//namespace reciprocal
-	}//namespace reciprocal
+}//namespace gtx
-	}//namespace gtx
 }//namespace glm
 
 #include "reciprocal.inl"

glm/gtx/rotate_vector.hpp

@@ -23,13 +23,12 @@
 
 namespace glm{
 namespace gtx{
-//! GLM_GTX_rotate_vector extension: Function to directly rotate a vector
+namespace rotate_vector ///< GLM_GTX_rotate_vector extension: Function to directly rotate a vector
-namespace rotate_vector
 {
 	using namespace transform;
 
 	/// \addtogroup gtx_rotate_vector
-		///@{
+	/// @{
 
 	//! Rotate a two dimensional vector.
 	//! From GLM_GTX_rotate_vector extension.
@@ -103,8 +102,7 @@ namespace rotate_vector
         detail::tvec3<T> const & Normal, 
         detail::tvec3<T> const & Up);
 
-		///@}
+	/// @}
-		
 }//namespace rotate_vector
 }//namespace gtx
 }//namespace glm

glm/gtx/simd_mat4.hpp

@@ -28,10 +28,9 @@
 #	pragma message("GLM: GLM_GTX_simd_mat4 extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace detail
 {
-	namespace detail
-	{
 	/// 4x4 Matrix implemented using SIMD SEE intrinsics.
 	/// \ingroup gtx_simd_mat4
 	GLM_ALIGNED_STRUCT(16) fmat4x4SIMD
@@ -127,13 +126,11 @@ namespace glm
 	fmat4x4SIMD const operator-  (fmat4x4SIMD const & m);
 	fmat4x4SIMD const operator-- (fmat4x4SIMD const & m, int);
 	fmat4x4SIMD const operator++ (fmat4x4SIMD const & m, int);
+}//namespace detail
 
-	}//namespace detail
+namespace gtx{
-
+namespace simd_mat4 ///< GLM_GTX_simd_mat4 extension: SIMD implementation of mat4 type.
-	namespace gtx{
+{
-	//! GLM_GTX_simd_mat4 extension: SIMD implementation of mat4 type.
-	namespace simd_mat4
-	{
 	typedef detail::fmat4x4SIMD simdMat4;
 
 	/// \addtogroup gtx_simd_mat4
@@ -174,11 +171,10 @@ namespace glm
 	detail::fmat4x4SIMD inverse(
 		detail::fmat4x4SIMD const & m);
 
-		///@}
+	/// @}
-
+}// namespace simd_mat4
-	}//namespace simd_mat4
+}// namespace gtx
-	}//namespace gtx
+}// namespace glm
-}//namespace glm
 
 #include "simd_mat4.inl"
 

glm/gtx/simd_vec4.hpp

@@ -28,10 +28,9 @@
 #	pragma message("GLM: GLM_GTX_simd_vec4 extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace detail
 {
-	namespace detail
-	{
 	/// 4-dimensional vector implemented using SIMD SEE intrinsics.
 	/// \ingroup gtx_simd_vec4
 	GLM_ALIGNED_STRUCT(4) fvec4SIMD
@@ -110,13 +109,11 @@ namespace glm
 		template <comp X>
 		fvec4SIMD swizzle() const;
 	};
+}//namespace detail
 
-	}//namespace detail
+namespace gtx{
-
+namespace simd_vec4 ///< GLM_GTX_simd_vec4 extension: SIMD implementation of vec4 type.
-	namespace gtx{
+{
-	//! GLM_GTX_simd_vec4 extension: SIMD implementation of vec4 type.
-	namespace simd_vec4
-	{
 	typedef detail::fvec4SIMD simdVec4;
 
 	/// \addtogroup gtx_simd_vec4
@@ -465,9 +462,9 @@ namespace glm
 	detail::fvec4SIMD fastInversesqrt(
 		detail::fvec4SIMD const & x);
 
-		///@}
+	/// @}
-	}//namespace simd_vec4
+}//namespace simd_vec4
-	}//namespace gtx
+}//namespace gtx
 }//namespace glm
 
 #include "simd_vec4.inl"

glm/gtx/simplex.hpp

@@ -20,12 +20,10 @@
 #	pragma message("GLM: GLM_GTX_simplex extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace spline ///< GLM_GTX_simplex extension: Spline functions
 {
-    namespace gtx{
-        //! GLM_GTX_simplex extension: Spline functions
-        namespace spline
-        {
     /// \addtogroup gtx_spline
     ///@{
             
@@ -59,11 +57,10 @@ namespace glm
                     genType const & v4, 
                     typename genType::value_type const & s);
             
-            ///@}
+    /// @}
-            
+}// namespace simplex
-        }//namespace simplex
+}// namespace gtx
-    }//namespace gtx
+}// namespace glm
-}//namespace glm
 
 #include "simplex.inl"
 

glm/gtx/spline.hpp

@@ -21,16 +21,14 @@
 #	pragma message("GLM: GLM_GTX_spline extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace spline ///< GLM_GTX_spline extension: Spline functions
 {
-    namespace gtx{
-	//! GLM_GTX_spline extension: Spline functions
-    namespace spline
-    {
 	using namespace gtx::optimum_pow;
 
 	/// \addtogroup gtx_spline
-		///@{
+	/// @{
 
 	//! Return a point from a catmull rom curve.
 	//! From GLM_GTX_spline extension.
@@ -62,10 +60,9 @@ namespace glm
 		genType const & v4, 
 		typename genType::value_type const & s);
 
-		///@}
+	/// @}
-
+}//namespace spline
-	}//namespace spline
+}//namespace gtx
-    }//namespace gtx
 }//namespace glm
 
 #include "spline.inl"

glm/gtx/std_based_type.hpp

@@ -21,16 +21,10 @@
 #	pragma message("GLM: GLM_GTX_std_based_type extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace std_based_type ///< GLM_GTX_std_based_type extension: Add support vector types based on C++ standard type
 {
-	namespace test{
-		void main_gtx_std_based_type();
-	}//namespace test
-
-	namespace gtx{
-	//! GLM_GTX_std_based_type extension: Add support vector types based on C++ standard type
-	namespace std_based_type
-	{
 	typedef detail::tvec2<std::size_t>		size2;
 	typedef detail::tvec3<std::size_t>		size3;
 	typedef detail::tvec4<std::size_t>		size4;
@@ -67,8 +61,8 @@ namespace glm
 	typedef detail::tvec3<unsigned long>	ulvec3;
 	typedef detail::tvec4<unsigned long>	ulvec4;
 
-	}//namespace std_based_type
+}//namespace std_based_type
-	}//namespace gtx
+}//namespace gtx
 }//namespace glm
 
 #include "std_based_type.inl"

glm/gtx/string_cast.hpp

@@ -28,33 +28,26 @@
 #	pragma message("GLM: GLM_GTX_string_cast extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace string_cast ///< GLM_GTX_string_cast extension: Setup strings for GLM type values
 {
-	namespace test{
-		void main_gtx_string_cast();
-	}//namespace test
-
-	namespace gtx{
-	//! GLM_GTX_string_cast extension: Setup strings for GLM type values
-	namespace string_cast
-	{
 	using namespace gtc::half_float; 
 	using namespace gtx::integer; 
 	using namespace gtx::unsigned_int; 
 	using namespace gtx::quaternion; 
 
 	/// \addtogroup gtx_string_cast
-		///@{
+	/// @{
 
 	//! Create a string from a GLM type value.
 	//! From GLM_GTX_string_cast extension.
 	template <typename genType> 
 	std::string to_string(genType const & x);
 
-		///@}
+	/// @}
-
+}//namespace string_cast
-	}//namespace string_cast
+}//namespace gtx
-	}//namespace gtx
 }//namespace glm
 
 #include "string_cast.inl"

glm/gtx/transform.hpp

@@ -22,20 +22,14 @@
 #	pragma message("GLM: GLM_GTX_transform extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace transform ///< GLM_GTX_transform extension: Add transformation matrices
 {
-	namespace test{
-		void main_gtx_transform();
-	}//namespace test
-
-	namespace gtx{
-	//! GLM_GTX_transform extension: Add transformation matrices
-	namespace transform
-	{
 	using namespace gtc::matrix_transform; 
 
 	/// \addtogroup gtx_transform
-		///@{
+	/// @{
 
 	//! Builds a translation 4 * 4 matrix created from 3 scalars.
 	//! From GLM_GTX_transform extension.
@@ -97,10 +91,9 @@ namespace glm
 	detail::tmat4x4<T> scale(
 		detail::tvec3<T> const & v);
 
-		///@}
+	/// @}
-
+}//namespace transform
-	}//namespace transform
+}//namespace gtx
-	}//namespace gtx
 }//namespace glm
 
 #include "transform.inl"

glm/gtx/transform2.hpp

@@ -22,20 +22,14 @@
 #	pragma message("GLM: GLM_GTX_transform2 extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace transform2 ///< GLM_GTX_transform2 extension: Add extra transformation matrices
 {
-	namespace test{
-		void main_gtx_transform2();
-	}//namespace test
-
-    namespace gtx{
-	//! GLM_GTX_transform2 extension: Add extra transformation matrices
-	namespace transform2
-	{
 	using namespace gtx::transform;
 
 	/// \addtogroup gtx_transform2
-		///@{
+	/// @{
 
 	//! Transforms a matrix with a shearing on X axis.
 	//! From GLM_GTX_transform2 extension.
@@ -112,11 +106,10 @@ namespace glm
 		valType scale, 
 		valType bias);
 
-		///@}
+	/// @}
-
+}// namespace transform2
-	}//namespace transform2
+}// namespace gtx
-    }//namespace gtx
+}// namespace glm
-}//namespace glm
 
 #include "transform2.inl"
 

glm/gtx/ulp.hpp

@@ -20,14 +20,12 @@
 #	pragma message("GLM: GLM_GTX_ulp extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace ulp ///< GLM_GTX_ulp extension: Precision calculation functions
 {
-	namespace gtx{
-	//! GLM_GTX_ulp extension: Precision calculation functions
-	namespace ulp
-	{
 	/// \addtogroup gtx_ulp
-		///@{
+	/// @{
 
 	//! Return the next ULP value(s) after the input value(s).
 	//! From GLM_GTX_ulp extension.
@@ -60,10 +58,9 @@ namespace glm
     vecType<uint> float_distance(vecType<T> const & x, vecType<T> const & y);
         
 	///@}
-
+}// namespace ulp
-	}//namespace ulp
+}// namespace gtx
-	}//namespace gtx
+}// namespace glm
-}//namespace glm
 
 #include "ulp.inl"
 

glm/gtx/unsigned_int.hpp

@@ -22,20 +22,14 @@
 #	pragma message("GLM: GLM_GTX_unsigned_int extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace unsigned_int ///< GLM_GTX_unsigned_int extension: Add support for unsigned integer for core functions
 {
-	namespace test{
-		void main_gtx_unsigned_int();
-	}//namespace test
-
-	namespace gtx{
-	//! GLM_GTX_unsigned_int extension: Add support for unsigned integer for core functions
-	namespace unsigned_int
-	{
 	using namespace gtx::integer;
 
 	/// \addtogroup gtx_unsigned_int
-		///@{
+	/// @{
 
 	//! 32bit signed integer. 
 	//! From GLM_GTX_unsigned_int extension.
@@ -53,10 +47,9 @@ namespace glm
 	//! From GLM_GTX_unsigned_int extension.
 	uint mod(uint x, uint y);
 
-		///@}
+	/// @}
-
+}//namespace unsigned_int
-	}//namespace unsigned_int
+}//namespace gtx
-	}//namespace gtx
 }//namespace glm
 
 #include "unsigned_int.inl"

glm/gtx/vec1.hpp

@@ -21,18 +21,11 @@
 #	pragma message("GLM: GLM_GTX_vec1 extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace vector1{ ///< GLM_GTX_vec1 extension: 1 component vector.
+namespace precision
 {
-	namespace test{
-		void main_gtx_vector1();
-	}//namespace test
-
-	namespace gtx{
-	//! GLM_GTX_vector1 extension: 1 component vector.
-	namespace vector1
-	{
-		namespace precision
-		{
 	//! 1 component vector of high precision floating-point numbers. 
 	//! There is no guarantee on the actual precision.
 	//! From GLM_GTX_vec1 extension.
@@ -71,7 +64,7 @@ namespace glm
 	//! There is no guarantee on the actual precision.
 	//! From GLM_GTX_vec1 extension.
 	typedef detail::lowp_uvec1_t			lowp_uvec1;
-		}//namespace precision
+}//namespace precision
 
 	//////////////////////////
 	// vec1 definition
@@ -116,9 +109,9 @@ namespace glm
 	typedef precision::mediump_uvec1		uvec1;
 #endif//GLM_PRECISION
 
-	}//namespace vec1
+}// namespace vec1
-	}//namespace gtx
+}// namespace gtx
-}//namespace glm
+}// namespace glm
 
 #include "vec1.inl"
 

glm/gtx/vector_access.hpp

@@ -20,18 +20,12 @@
 #	pragma message("GLM: GLM_GTX_vector_access extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace vector_access ///< GLM_GTX_vector_access extension: Function to set values to vectors
 {
-	namespace test{
-		void main_gtx_vector_access();
-	}//namespace test
-
-    namespace gtx{
-	//! GLM_GTX_vector_access extension: Function to set values to vectors
-    namespace vector_access
-    {
 	/// \addtogroup gtx_vector_access
-		///@{
+	/// @{
 
 	//! Set values to a 2 components vector.
 	//! From GLM_GTX_vector_access extension.
@@ -60,10 +54,9 @@ namespace glm
 		valType const & z, 
 		valType const & w);
 
-		///@}
+	/// @}
-
+}//namespace vector_access
-    }//namespace vector_access
+}//namespace gtx
-    }//namespace gtx
 }//namespace glm
 
 #include "vector_access.inl"

glm/gtx/vector_angle.hpp

@@ -27,8 +27,7 @@
 
 namespace glm{
 namespace gtx{
-//! GLM_GTX_vector_angle extension: Compute angle between vectors
+namespace vector_angle ///< GLM_GTX_vector_angle extension: Compute angle between vectors
-namespace vector_angle
 {
 	using namespace quaternion;
 	using namespace epsilon;
@@ -61,10 +60,10 @@ namespace vector_angle
 		detail::tvec3<T> const & y,
 		detail::tvec3<T> const & ref);
 
-	///@}
+	/// @}
-}//namespace vector_angle
+}// namespace vector_angle
-}//namespace gtx
+}// namespace gtx
-}//namespace glm
+}// namespace glm
 
 #include "vector_angle.inl"
 

glm/gtx/vector_query.hpp

@@ -22,18 +22,12 @@
 #	pragma message("GLM: GLM_GTX_vector_query extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace vector_query ///< GLM_GTX_vector_query extension: Query informations of vector types
 {
-	namespace test{
-		void main_ext_gtx_vector_query();
-	}//namespace test
-
-    namespace gtx{
-	//! GLM_GTX_vector_query extension: Query informations of vector types
-    namespace vector_query
-    {
 	/// \addtogroup gtx_vector_query
-		///@{
+	/// @{
 
 	//! Check if two vectors are collinears.
 	//! From GLM_GTX_vector_query extensions.
@@ -89,11 +83,10 @@ namespace glm
 		genType const & v1, 
 		typename genType::value_type const & epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
 
-		///@}
+	/// @}
-
+}// namespace vector_query
-    }//namespace vector_query
+}// namespace gtx
-    }//namespace gtx
+}// namespace glm
-}//namespace glm
 
 #include "vector_query.inl"
 

glm/gtx/verbose_operator.hpp

@@ -20,18 +20,12 @@
 #	pragma message("GLM: GLM_GTX_verbose_operator extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace verbose_operator ///< GLM_GTX_verbose_operator extension: Use words to replace operators
 {
-	namespace test{
-		void main_ext_gtx_verbose_operator();
-	}//namespace test
-
-	namespace gtx{
-	//! GLM_GTX_verbose_operator extension: Use words to replace operators
-	namespace verbose_operator
-	{
 	/// \addtogroup gtx_verbose_operator
-		///@{
+	/// @{
 
 	//! Addition of two values
 	//! From GLM_GTX_verbose_operator extension.
@@ -58,10 +52,10 @@ namespace glm
 	template <typename genTypeT, typename genTypeU, typename genTypeV> 
 	genTypeT mad(genTypeT const & a, genTypeU const & b, genTypeV const & c);
 
-		///@}
+	/// @}
-	}//namespace verbose_operator
+}// namespace verbose_operator
-	}//namespace gtx
+}// namespace gtx
-}//namespace glm
+}// namespace glm
 
 #include "verbose_operator.inl"
 

glm/gtx/wrap.hpp

@@ -20,18 +20,12 @@
 #	pragma message("GLM: GLM_GTX_wrap extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace wrap ///< GLM_GTX_wrap: Wrapping mode using my texture samping.
 {
-	namespace test{
-		bool main_gtx_wrap();
-	}//namespace test
-
-	namespace gtx{
-	//! GLM_GTX_wrap: Wrapping mode using my texture samping.
-	namespace wrap
-	{
 	/// \addtogroup gtx_wrap
-		///@{
+	/// @{
 
 	//! Simulate GL_CLAMP OpenGL wrap mode
 	//! From GLM_GTX_wrap extension.
@@ -48,11 +42,10 @@ namespace glm
 	template <typename genType> 
 	genType mirrorRepeat(genType const & Texcoord);
 
-		///@}
+	/// @}
-
+}// namespace wrap
-	}//namespace wrap
+}// namespace gtx
-	}//namespace gtx
+}// namespace glm
-}//namespace glm
 
 #include "wrap.inl"