Removed gtx extension namespace

glm/gtx/associated_min_max.hpp

@@ -22,8 +22,7 @@
 #endif
 
 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 gtx
 {
 	/// \addtogroup gtx_associated_min_max
 	/// @{
@@ -71,12 +70,9 @@ namespace associated_min_max ///< GLM_GTX_associated_min_max extension: Min and
 		const genTypeT& w, const genTypeU& d);
 
 	/// @}
-} //namespace associated_min_max
 } //namespace gtx
 } //namespace glm
 
 #include "associated_min_max.inl"
 
-namespace glm{using namespace gtx::associated_min_max;}
-
 #endif//glm_gtx_associated_min_max

glm/gtx/associated_min_max.inl

@@ -8,9 +8,8 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 namespace glm{
-namespace gtx{
-namespace associated_min_max{
-
+namespace gtx
+{
 	// Min comparison between 2 variables
 	template<typename T, typename U>
 	GLM_FUNC_QUALIFIER U associatedMin(T x, U a, T y, U b)
@@ -911,6 +910,5 @@ namespace associated_min_max{
 		return Result;
 	}
 
-}//namespace associated_min_max
 }//namespace gtx
 }//namespace glm

glm/gtx/bit.hpp

@@ -23,8 +23,7 @@
 #endif
 
 namespace glm{
-namespace gtx{
-namespace bit ///< GLM_GTX_bit extension: Allow to perform bit operations on integer values
+namespace gtx
 {
 	/// \addtogroup gtx_bit
 	/// @{
@@ -110,12 +109,9 @@ namespace bit ///< GLM_GTX_bit extension: Allow to perform bit operations on int
 		int const & ToBit);
 
 	/// @}
-}// namespace bit
 }// namespace gtx
 }// namespace glm
 
 #include "bit.inl"
 
-namespace glm{using namespace gtx::bit;}
-
 #endif//glm_gtx_bit

glm/gtx/bit.inl

@@ -11,7 +11,6 @@
 
 namespace glm{
 namespace gtx{
-namespace bit{
 
 template <typename genIType>
 GLM_FUNC_QUALIFIER genIType mask
@@ -772,6 +771,5 @@ GLM_FUNC_QUALIFIER genIUType fillBitfieldWithZero
 	return Result;
 }
 
-}//namespace bit
 }//namespace gtx
 }//namespace glm

glm/gtx/closest_point.hpp

@@ -21,8 +21,7 @@
 #endif
 
 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 gtx
 {
 	/// \addtogroup gtx_closest_point
 	/// @{
@@ -36,12 +35,9 @@ namespace closest_point ///< GLM_GTX_closest_point extension: Find the point on
 		detail::tvec3<T> const & b);
 
 	/// @}
-}// namespace closest_point
 }// namespace gtx
 }// namespace glm
 
 #include "closest_point.inl"
 
-namespace glm{using namespace gtx::closest_point;}
-
 #endif//glm_gtx_closest_point

glm/gtx/closest_point.inl

@@ -12,7 +12,6 @@
 
 namespace glm{
 namespace gtx{
-namespace closest_point{
 
 template <typename valType> 
 GLM_FUNC_QUALIFIER detail::tvec3<valType> closestPointOnLine
@@ -34,7 +33,6 @@ GLM_FUNC_QUALIFIER detail::tvec3<valType> closestPointOnLine
     return a + LineDirection * Distance;
 }
 
-}//namespace closest_point
 }//namespace gtx
 }//namespace glm
 

glm/gtx/color_cast.hpp

@@ -23,11 +23,8 @@
 #endif
 
 namespace glm{
-namespace gtx{
-namespace color_cast ///< GLM_GTX_color_cast extension: Conversion between two color types
+namespace gtx
 {
-	using namespace gtx::number_precision;
-
 	/// \addtogroup gtx_color_cast
 	/// @{
 
@@ -96,12 +93,9 @@ namespace color_cast ///< GLM_GTX_color_cast extension: Conversion between two c
 	template <typename T> gtc::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 gtx
 }//namespace glm
 
 #include "color_cast.inl"
 
-namespace glm{using namespace gtx::color_cast;}
-
 #endif//glm_gtx_color_cast

glm/gtx/color_space.hpp

@@ -21,8 +21,7 @@
 #endif
 
 namespace glm{
-namespace gtx{
-namespace color_space ///< GLM_GTX_color_space extension: Related to RGB to HSV conversions and operations
+namespace gtx
 {
 	/// \addtogroup gtx_color_space
 	/// @{
@@ -66,12 +65,9 @@ namespace color_space ///< GLM_GTX_color_space extension: Related to RGB to HSV
 		detail::tvec3<valType> const & color);
 
 	/// @}
-}//namespace color_space
 }//namespace gtx
 }//namespace glm
 
 #include "color_space.inl"
 
-namespace glm{using namespace gtx::color_space;}
-
 #endif//glm_gtx_color_space

glm/gtx/color_space.inl

@@ -8,8 +8,7 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 namespace glm{
-namespace gtx{
-namespace color_space
+namespace gtx
 {
     template <typename T> 
     GLM_FUNC_QUALIFIER detail::tvec3<T> rgbColor(const detail::tvec3<T>& hsvColor)
@@ -149,6 +148,5 @@ namespace color_space
 		return dot(color, tmp);
 	}
 
-}//namespace color_space
 }//namespace gtx
 }//namespace glm

glm/gtx/color_space_YCoCg.hpp

@@ -21,8 +21,7 @@
 #endif
 
 namespace glm{
-namespace gtx{
-namespace color_space_YCoCg ///< GLM_GTX_color_space_YCoCg extension: RGB to YCoCg conversions and operations
+namespace gtx
 {
 	/// \addtogroup gtx_color_space_YCoCg
 	/// @{
@@ -54,12 +53,9 @@ namespace color_space_YCoCg ///< GLM_GTX_color_space_YCoCg extension: RGB to YCo
 		detail::tvec3<valType> const & YCoCgColor);
 
 	/// @}
-}//namespace color_space_YCoCg
 }//namespace gtx
 }//namespace glm
 
 #include "color_space_YCoCg.inl"
 
-namespace glm{using namespace gtx::color_space_YCoCg;}
-
 #endif//glm_gtx_color_space_YCoCg

glm/gtx/color_space_YCoCg.inl

@@ -9,7 +9,6 @@
 
 namespace glm{
 namespace gtx{
-namespace color_space_YCoCg{
 
 template <typename valType> 
 GLM_FUNC_QUALIFIER detail::tvec3<valType> rgb2YCoCg
@@ -64,6 +63,5 @@ GLM_FUNC_QUALIFIER detail::tvec3<valType> YCoCgR2rgb
 	return result;
 }
 
-}//namespace color_space_YCoCg
 }//namespace gtx
 }//namespace glm

glm/gtx/compatibility.hpp

@@ -29,11 +29,10 @@
 #endif//GLM_COMPILER
 
 namespace glm{
-namespace gtx{
-namespace compatibility ///< GLM_GTX_compatibility extension: Provide functions to increase the compatibility with Cg and HLSL languages
+namespace gtx
 {
-	/// \addtogroup gtx_compatibility
-	///@{
+	/// @addtogroup gtx_compatibility
+	/// @{
 
 	template <typename T> GLM_FUNC_QUALIFIER T lerp(T x, T y, T a){return mix(x, y, a);}																					//!< \brief Returns x * (1.0 - a) + y * a, i.e., the linear blend of x and y using the floating-point value a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
 	template <typename T> GLM_FUNC_QUALIFIER detail::tvec2<T> lerp(const detail::tvec2<T>& x, const detail::tvec2<T>& y, T a){return mix(x, y, a);}							//!< \brief Returns x * (1.0 - a) + y * a, i.e., the linear blend of x and y using the floating-point value a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
@@ -149,14 +148,11 @@ namespace compatibility ///< GLM_GTX_compatibility extension: Provide functions
 	typedef detail::tmat4x4<double>		double4x4;		//!< \brief double-precision floating-point matrix with 4 x 4 components. (From GLM_GTX_compatibility extension)
 
 	/// @}
-}//namespace compatibility
 }//namespace gtx
 }//namespace glm
 
 #include "compatibility.inl"
-
-namespace glm{using namespace gtx::compatibility;}
-
+    
 #endif//glm_gtx_compatibility
 
 

glm/gtx/component_wise.hpp

@@ -21,10 +21,9 @@
 #endif
 
 namespace glm{
-namespace gtx{
-namespace component_wise ///< GLM_GTX_component_wise extension: Operations between components of a type
+namespace gtx
 {
-	/// \addtogroup gtx_component_wise
+	/// @addtogroup gtx_component_wise
 	/// @{
 
 	//! Add all vector components together. 
@@ -52,12 +51,9 @@ namespace component_wise ///< GLM_GTX_component_wise extension: Operations betwe
 		genType const & v);
 
 	/// @}
-}//namespace component_wise
 }//namespace gtx
 }//namespace glm
 
 #include "component_wise.inl"
 
-namespace glm{using namespace gtx::component_wise;}
-
 #endif//glm_gtx_component_wise

glm/gtx/component_wise.inl

@@ -8,8 +8,7 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 namespace glm{
-namespace gtx{
-namespace component_wise
+namespace gtx
 {
 	template <typename genType>
 	GLM_FUNC_QUALIFIER typename genType::value_type compAdd(genType const & v)
@@ -47,6 +46,5 @@ namespace component_wise
 		return result;
 	}
 
-}//namespace component_wise
 }//namespace gtx
 }//namespace glm

glm/gtx/epsilon.hpp

@@ -2,7 +2,7 @@
 // OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // Created : 2005-12-21
-// Updated : 2006-11-13
+// Updated : 2011-06-07
 // Licence : This source is under MIT License
 // File    : glm/gtx/epsilon.hpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -25,11 +25,10 @@
 #endif
 
 namespace glm{
-namespace gtx{
-namespace epsilon ///< GLM_GTX_epsilon extension: Comparison functions for a user defined epsilon values.
+namespace gtx
 {
-	/// \addtogroup gtx_epsilon
-	///@{
+	/// @addtogroup gtx_epsilon
+	/// @{
 
 	//! Returns the component-wise compare of |x - y| < epsilon.
 	//! From GLM_GTX_epsilon extension.
@@ -47,13 +46,10 @@ namespace epsilon ///< GLM_GTX_epsilon extension: Comparison functions for a use
 		genTypeT const & y, 
 		genTypeU const & epsilon);
 
-	///@}
-}//namespace epsilon
+	/// @}
 }//namespace gtx
 }//namespace glm
 
 #include "epsilon.inl"
 
-namespace glm{using namespace gtx::epsilon;}
-
 #endif//glm_gtx_epsilon

glm/gtx/epsilon.inl

@@ -2,14 +2,13 @@
 // OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // Created : 2005-12-21
-// Updated : 2006-01-16
+// Updated : 2011-06-07
 // Licence : This source is under MIT License
 // File    : glm/gtx/epsilon.inl
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 namespace glm{
 namespace gtx{
-namespace epsilon{
 
 template <typename genType>
 GLM_FUNC_QUALIFIER bool equalEpsilon
@@ -229,6 +228,5 @@ GLM_FUNC_QUALIFIER detail::tvec4<bool> notEqualEpsilon
         abs(x.w - y.w) >= epsilon.w);
 }
 
-}//namespace epsilon
 }//namespace gtx
 }//namespace glm

glm/gtx/euler_angles.hpp

@@ -27,10 +27,9 @@
 #endif
 
 namespace glm{
-namespace gtx{
-namespace euler_angles ///< GLM_GTX_euler_angles extension: Build matrices from Euler angles.
+namespace gtx
 {
-	/// \addtogroup gtx_euler_angles
+	/// @addtogroup gtx_euler_angles
 	/// @{
 
 	//! Creates a 3D 4 * 4 homogeneous rotation matrix from an euler angle X.
@@ -130,12 +129,9 @@ namespace euler_angles ///< GLM_GTX_euler_angles extension: Build matrices from
 	detail::tmat4x4<T> orientate4(detail::tvec3<T> const & angles);
 
 	/// @}
-}//namespace euler_angles
 }//namespace gtx
 }//namespace glm
 
 #include "euler_angles.inl"
 
-namespace glm{using namespace gtx::euler_angles;}
-
 #endif//glm_gtx_euler_angles

glm/gtx/euler_angles.inl

@@ -9,7 +9,6 @@
 
 namespace glm{
 namespace gtx{
-namespace euler_angles{
 
 template <typename valType> 
 GLM_FUNC_QUALIFIER detail::tmat4x4<valType> eulerAngleX
@@ -244,6 +243,5 @@ GLM_FUNC_QUALIFIER detail::tmat4x4<valType> orientate4
     return yawPitchRoll(angles.z, angles.x, angles.y);
 }
 
-}//namespace euler_angles
 }//namespace gtx
 }//namespace glm

glm/gtx/extend.hpp

@@ -21,10 +21,9 @@
 #endif
 
 namespace glm{
-namespace gtx{
-namespace extend ///< GLM_GTX_extend extension: Extend a position from a source to a position at a defined length.
+namespace gtx
 {
-	/// \addtogroup gtx_extend
+	/// @addtogroup gtx_extend
 	/// @{
 
 	//! Extends of Length the Origin position using the (Source - Origin) direction.
@@ -36,12 +35,9 @@ namespace extend ///< GLM_GTX_extend extension: Extend a position from a source
 		typename genType::value_type const Length);
 
 	/// @}
-}//namespace extend
 }//namespace gtx
 }//namespace glm
 
 #include "extend.inl"
 
-namespace glm{using namespace gtx::extend;}
-
 #endif//glm_gtx_extend

glm/gtx/extend.inl

@@ -9,7 +9,6 @@
 
 namespace glm{
 namespace gtx{
-namespace extend{
 
 template <typename genType>
 genType extend
@@ -55,6 +54,5 @@ detail::tvec4<valType> extend
     return Origin + (Source - Origin) * Distance;
 }
 
-}//namespace extend
 }//namespace gtx
 }//namespace glm

glm/gtx/extented_min_max.hpp

@@ -23,11 +23,10 @@
 #endif
 
 namespace glm{
-namespace gtx{
-namespace extented_min_max ///< GLM_GTX_extented_min_max extension: Min and max functions for 3 to 4 parameters.
+namespace gtx
 {
-	/// \addtogroup gtx_extented_min_max
-	///@{
+	/// @addtogroup gtx_extented_min_max
+	/// @{
 
 	//< Return the minimum component-wise values of 3 inputs 
 	//< From GLM_GTX_extented_min_max extension
@@ -164,12 +163,9 @@ namespace extented_min_max ///< GLM_GTX_extented_min_max extension: Min and max
 		C<T> const & w);
 
 	/// @}
-}//namespace extented_min_max
 }//namespace gtx
 }//namespace glm
 
 #include "extented_min_max.inl"
 
-namespace glm{using namespace gtx::extented_min_max;}
-
 #endif//glm_gtx_extented_min_max

glm/gtx/extented_min_max.inl

@@ -8,8 +8,7 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 namespace glm{
-namespace gtx{
-namespace extented_min_max
+namespace gtx
 {
 	template <typename T>
 	GLM_FUNC_QUALIFIER T min(
@@ -177,6 +176,5 @@ namespace extented_min_max
 		return glm::max(glm::max(x, y), glm::max(z, w));
 	}
 
-}//namespace extented_min_max
 }//namespace gtx
 }//namespace glm

glm/gtx/fast_exponential.hpp

@@ -23,8 +23,7 @@
 #endif
 
 namespace glm{
-namespace gtx{
-namespace fast_exponential ///< GLM_GTX_fast_exponential extension: Fast but less accurate implementations of exponential based functions.
+namespace gtx
 {
 	/// @addtogroup gtx_fast_exponential
 	/// @{
@@ -69,12 +68,9 @@ namespace fast_exponential ///< GLM_GTX_fast_exponential extension: Fast but les
 	T fastLn(const T& x);
 
 	/// @}
-}//namespace fast_exponential
 }//namespace gtx
 }//namespace glm
 
 #include "fast_exponential.inl"
 
-namespace glm{using namespace gtx::fast_exponential;}
-
 #endif//glm_gtx_fast_exponential

glm/gtx/fast_exponential.inl

@@ -4,12 +4,11 @@
 // Created : 2006-01-09
 // Updated : 2006-01-09
 // Licence : This source is under MIT License
-// File    : glm/gtx/fast_exponential.h
+// File    : glm/gtx/fast_exponential.inl
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 namespace glm{
-namespace gtx{
-namespace fast_exponential
+namespace gtx
 {
     // fastPow:
 	template <typename T>
@@ -289,6 +288,5 @@ namespace fast_exponential
             fastLog2(x.w));
     }
 
-}//namespace fast_exponential
 }//namespace gtx
 }//namespace glm

glm/gtx/fast_square_root.hpp

@@ -25,10 +25,9 @@
 #endif
 
 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 gtx
 {
-	/// \addtogroup gtx_fast_square_root
+	/// @addtogroup gtx_fast_square_root
 	/// @{
 
 	//! Faster than the common sqrt function but less accurate.
@@ -57,12 +56,9 @@ namespace fast_square_root 	///< GLM_GTX_fast_square_root extension: Fast but le
 	genType fastNormalize(genType const & x);
 
 	/// @}
-}// namespace fast_square_root
 }// namespace gtx
 }// namespace glm
 
 #include "fast_square_root.inl"
 
-namespace glm{using namespace gtx::fast_square_root;}
-
 #endif//glm_gtx_fast_square_root

glm/gtx/fast_square_root.inl

@@ -9,7 +9,6 @@
 
 namespace glm{
 namespace gtx{
-namespace fast_square_root{
 
 // fastSqrt
 template <typename genType>
@@ -232,6 +231,5 @@ GLM_FUNC_QUALIFIER detail::tvec4<valType> fastNormalize
     return x * fastInverseSqrt(sqr);
 }
 
-}//namespace fast_square_root
 }//namespace gtx
 }//namespace glm

glm/gtx/fast_trigonometry.hpp

@@ -21,10 +21,9 @@
 #endif
 
 namespace glm{
-namespace gtx{
-namespace fast_trigonometry	///< GLM_GTX_fast_trigonometry extension: Fast but less accurate implementations of trigonometric functions.
+namespace gtx
 {
-	/// \addtogroup gtx_fast_trigonometry
+	/// @addtogroup gtx_fast_trigonometry
 	/// @{
 
 	//! Faster than the common sin function but less accurate. 
@@ -70,12 +69,9 @@ namespace fast_trigonometry	///< GLM_GTX_fast_trigonometry extension: Fast but l
 	T fastAtan(const T& angle);
 
 	/// @}
-}//namespace fast_trigonometry
 }//namespace gtx
 }//namespace glm
 
 #include "fast_trigonometry.inl"
 
-namespace glm{using namespace gtx::fast_trigonometry;}
-
 #endif//glm_gtx_fast_trigonometry

glm/gtx/fast_trigonometry.inl

@@ -8,8 +8,7 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 namespace glm{
-namespace gtx{
-namespace fast_trigonometry
+namespace gtx
 {
     // sin
     template <typename T> 
@@ -267,6 +266,5 @@ namespace fast_trigonometry
             fastAtan(x.w));
     }
 
-}//namespace fast_trigonometry
 }//namespace gtx
 }//namespace glm

glm/gtx/gradient_paint.hpp

@@ -22,12 +22,9 @@
 #endif
 
 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 gtx
 {
-	using namespace gtx::optimum_pow;
-
-	/// \addtogroup gtx_gradient_paint
+	/// @addtogroup gtx_gradient_paint
 	/// @{
 
 	template <typename valType>
@@ -44,12 +41,9 @@ namespace gradient_paint ///< GLM_GTX_gradient_paint extension: Compute a radien
 		glm::detail::tvec2<valType> const & Position);
 
 	/// @}
-}// namespace gradient_paint
 }// namespace gtx
 }// namespace glm
 
 #include "gradient_paint.inl"
 
-namespace glm{using namespace gtx::gradient_paint;}
-
 #endif//glm_gtx_gradient_paint

glm/gtx/gradient_paint.inl

@@ -9,7 +9,6 @@
 
 namespace glm{
 namespace gtx{
-namespace gradient_paint{
 
 	template <typename valType>
 	valType radialGradient(
@@ -39,6 +38,5 @@ namespace gradient_paint{
 		return (Dist.x * (Position.x - Point0.x) + Dist.y * (Position.y - Point0.y)) / glm::dot(Dist, Dist);
 	}
 
-}//namespace gradient_paint
 }//namespace gtx
 }//namespace glm

glm/gtx/handed_coordinate_space.hpp

@@ -21,10 +21,9 @@
 #endif
 
 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
 {
-	/// \addtogroup gtx_handed_coordinate_space
+	/// @addtogroup gtx_handed_coordinate_space
 	/// @{
 
 	//! Return if a trihedron right handed or not.
@@ -44,12 +43,9 @@ namespace handed_coordinate_space ///< GLM_GTX_handed_coordinate_space extension
 		detail::tvec3<T> const & normal);
 
 	/// @}
-}// namespace handed_coordinate_space
 }// namespace gtx
 }// namespace glm
 
 #include "handed_coordinate_space.inl"
 
-namespace glm{using namespace gtx::handed_coordinate_space;}
-
 #endif//glm_gtx_handed_coordinate_space

glm/gtx/handed_coordinate_space.inl

@@ -8,8 +8,7 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 namespace glm{
-namespace gtx{
-namespace handed_coordinate_space
+namespace gtx
 {
     template <typename T> 
     GLM_FUNC_QUALIFIER bool rightHanded(
@@ -29,6 +28,5 @@ namespace handed_coordinate_space
         return dot(cross(normal, tangent), binormal) < T(0);
     }
 
-}//namespace handed_coordinate_space
 }//namespace gtx
 }//namespace glm

glm/gtx/inertia.hpp

@@ -21,10 +21,9 @@
 #endif
 
 namespace glm{
-namespace gtx{
-namespace inertia ///< GLM_GTX_inertia extension: Create inertia matrices
+namespace gtx
 {
-	/// \addtogroup gtx_inertia
+	/// @addtogroup gtx_inertia
 	/// @{
 
 	//! Build an inertia matrix for a box.
@@ -84,12 +83,9 @@ namespace inertia ///< GLM_GTX_inertia extension: Create inertia matrices
 		const T Radius);
 
 	/// @}
-}// namespace inertia
 }// namespace gtx
 }// namespace glm
 
 #include "inertia.inl"
 
-namespace glm{using namespace gtx::inertia;}
-
 #endif//glm_gtx_inertia

glm/gtx/inertia.inl

@@ -9,7 +9,6 @@
 
 namespace glm{
 namespace gtx{
-namespace inertia{
 
     template <typename T>
     GLM_FUNC_QUALIFIER detail::tmat3x3<T> boxInertia3(
@@ -98,6 +97,5 @@ namespace inertia{
         return Result;
     }
 
-}//namespace inertia
 }//namespace gtx
 }//namespace glm

glm/gtx/int_10_10_10_2.hpp

@@ -22,26 +22,19 @@
 #endif
 
 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
 {
-	using namespace gtx::raw_data;
-
-	/// \addtogroup gtx_int_10_10_10_2
-	///@{
+	/// @addtogroup gtx_int_10_10_10_2
+	/// @{
 
 	//! From GLM_GTX_int_10_10_10_2 extension.
 	//! Cast a vec4 to an u_10_10_10_2.
 	dword uint10_10_10_2_cast(glm::vec4 const & v);
 
-	///@}
-
-}//namespace integer
+	/// @}
 }//namespace gtx
 }//namespace glm
 
 #include "int_10_10_10_2.inl"
 
-namespace glm{using namespace gtx::int_10_10_10_2;}
-
 #endif//glm_gtx_int_10_10_10_2

glm/gtx/int_10_10_10_2.inl

@@ -9,13 +9,11 @@
 
 namespace glm{
 namespace gtx{
-namespace int_10_10_10_2
+
+GLM_FUNC_QUALIFIER dword uint10_10_10_2_cast(glm::vec4 const & v)
 {
-	GLM_FUNC_QUALIFIER dword uint10_10_10_2_cast(glm::vec4 const & v)
-	{
-		return dword(uint(v.x * 2047.f) << 0 | uint(v.y * 2047.f) << 10 | uint(v.z * 2047.f) << 20 | uint(v.w * 3.f) << 30);
-	}
+    return dword(uint(v.x * 2047.f) << 0 | uint(v.y * 2047.f) << 10 | uint(v.z * 2047.f) << 20 | uint(v.w * 3.f) << 30);
+}
 
-}//namespace int_10_10_10_2
 }//namespace gtx
 }//namespace glm

glm/gtx/integer.hpp

@@ -21,10 +21,9 @@
 #endif
 
 namespace glm{
-namespace gtx{
-namespace integer ///< GLM_GTX_integer extension: Add support for integer for core functions
+namespace gtx
 {
-	/// \addtogroup gtx_integer
+	/// @addtogroup gtx_integer
 	/// @{
 
 	//! Returns x raised to the y power. 
@@ -45,12 +44,9 @@ namespace integer ///< GLM_GTX_integer extension: Add support for integer for co
 	genType factorial(genType const & x);
 
 	/// @}
-}//namespace integer
 }//namespace gtx
 }//namespace glm
 
 #include "integer.inl"
 
-namespace glm{using namespace gtx::integer;}
-
 #endif//glm_gtx_integer

glm/gtx/integer.inl

@@ -9,8 +9,7 @@
 
 namespace glm{
 namespace gtx{
-namespace integer
-{
+
     // pow
     GLM_FUNC_QUALIFIER int pow(int x, int y)
     {
@@ -86,6 +85,5 @@ namespace integer
             factorial(x.w));
     }
 
-}//namespace integer
 }//namespace gtx
 }//namespace glm

glm/gtx/intersect.hpp

@@ -23,10 +23,9 @@
 #endif
 
 namespace glm{
-namespace gtx{
-namespace intersect	///< GLM_GTX_intersect extension: Add intersection functions
+namespace gtx
 {
-	/// \addtogroup gtx_intersect
+	/// @addtogroup gtx_intersect
 	/// @{
 
 	//! Compute the intersection of a ray and a triangle.
@@ -62,12 +61,9 @@ namespace intersect	///< GLM_GTX_intersect extension: Add intersection functions
 		genType & position, genType & normal);
 
 	/// @}
-}//namespace intersect
 }//namespace gtx
 }//namespace glm
 
 #include "intersect.inl"
 
-namespace glm{using namespace gtx::intersect;}
-
 #endif//glm_gtx_intersect

glm/gtx/intersect.inl

@@ -12,7 +12,6 @@
 
 namespace glm{
 namespace gtx{
-namespace intersect{
 
 template <typename genType>
 GLM_FUNC_QUALIFIER bool intersectRayTriangle
@@ -196,6 +195,5 @@ GLM_FUNC_QUALIFIER bool intersectLineSphere
 	return false;
 }
 
-}//namespace intersect
 }//namespace gtx
 }//namespace glm

glm/gtx/log_base.hpp

@@ -21,10 +21,9 @@
 #endif
 
 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 gtx
 {
-	/// \addtogroup gtx_log_base
+	/// @addtogroup gtx_log_base
 	/// @{
 
 	//! Logarithm for any base.
@@ -35,13 +34,9 @@ namespace log_base ///< GLM_GTX_log_base extension: Logarithm for any base. base
 		genType const & base);
 
 	/// @}
-
-}//namespace extend
 }//namespace gtx
 }//namespace glm
 
 #include "log_base.inl"
 
-namespace glm{using namespace gtx::log_base;}
-
 #endif//glm_gtx_log_base

glm/gtx/log_base.inl

@@ -9,7 +9,6 @@
 
 namespace glm{
 namespace gtx{
-namespace log_base{
 
 template <typename genType> 
 GLM_FUNC_QUALIFIER genType log(
@@ -87,6 +86,5 @@ GLM_FUNC_QUALIFIER detail::tvec4<valType> log(
 		log(v.w, base.w));
 }
 
-}//namespace log_base
 }//namespace gtx
 }//namespace glm

glm/gtx/matrix_cross_product.hpp

@@ -21,8 +21,7 @@
 #endif
 
 namespace glm{
-namespace gtx{
-namespace matrix_cross_product ///< GLM_GTX_matrix_cross_product: Build cross product matrices
+namespace gtx
 {
 	/// \addtogroup gtx_matrix_cross_product
 	/// @{
@@ -40,12 +39,9 @@ namespace matrix_cross_product ///< GLM_GTX_matrix_cross_product: Build cross pr
 		detail::tvec3<T> const & x);
 
 	/// @}
-}//namespace matrix_cross_product
 }//namespace gtx
 }//namespace glm
 
 #include "matrix_cross_product.inl"
 
-namespace glm{using namespace gtx::matrix_cross_product;}
-
 #endif//glm_gtx_matrix_cross_product

glm/gtx/matrix_cross_product.inl

@@ -9,36 +9,34 @@
 
 namespace glm{
 namespace gtx{
-namespace matrix_cross_product
+
+template <typename T> 
+GLM_FUNC_QUALIFIER detail::tmat3x3<T> matrixCross3(
+    detail::tvec3<T> const & x)
 {
-    template <typename T> 
-    GLM_FUNC_QUALIFIER detail::tmat3x3<T> matrixCross3(
-		detail::tvec3<T> const & x)
-    {
-        detail::tmat3x3<T> Result(T(0));
-        Result[0][1] = x.z;
-        Result[1][0] = -x.z;
-        Result[0][2] = -x.y;
-        Result[2][0] = x.y;
-        Result[1][2] = x.x;
-        Result[2][1] = -x.x;
-        return Result;
-    }
+    detail::tmat3x3<T> Result(T(0));
+    Result[0][1] = x.z;
+    Result[1][0] = -x.z;
+    Result[0][2] = -x.y;
+    Result[2][0] = x.y;
+    Result[1][2] = x.x;
+    Result[2][1] = -x.x;
+    return Result;
+}
 
-    template <typename T> 
-    GLM_FUNC_QUALIFIER detail::tmat4x4<T> matrixCross4(
-		detail::tvec3<T> const & x)
-    {
-        detail::tmat4x4<T> Result(T(0));
-        Result[0][1] = x.z;
-        Result[1][0] = -x.z;
-        Result[0][2] = -x.y;
-        Result[2][0] = x.y;
-        Result[1][2] = x.x;
-        Result[2][1] = -x.x;
-        return Result;
-    }
+template <typename T> 
+GLM_FUNC_QUALIFIER detail::tmat4x4<T> matrixCross4(
+    detail::tvec3<T> const & x)
+{
+    detail::tmat4x4<T> Result(T(0));
+    Result[0][1] = x.z;
+    Result[1][0] = -x.z;
+    Result[0][2] = -x.y;
+    Result[2][0] = x.y;
+    Result[1][2] = x.x;
+    Result[2][1] = -x.x;
+    return Result;
+}
 
-}//namespace matrix_cross_product
 }//namespace gtx
 }//namespace glm

glm/gtx/matrix_interpolation.hpp

@@ -24,8 +24,7 @@
 #endif
 
 namespace glm{
-namespace gtx{
-namespace matrix_interpolation ///< GLM_GTX_matrix_interpolation extension: Add transformation matrices
+namespace gtx
 {
 	/// \addtogroup gtx_matrix_interpolation
 	/// @{
@@ -55,12 +54,9 @@ namespace matrix_interpolation ///< GLM_GTX_matrix_interpolation extension: Add
         T const delta);
 
 	/// @}
-}//namespace matrix_interpolation
 }//namespace gtx
 }//namespace glm
 
 #include "matrix_interpolation.inl"
 
-namespace glm{using namespace gtx::matrix_interpolation;}
-
 #endif//glm_gtx_transform

glm/gtx/matrix_interpolation.inl

@@ -9,8 +9,7 @@
 
 namespace glm{
 namespace gtx{
-namespace matrix_interpolation
-{
+
     template <typename T>
     GLM_FUNC_QUALIFIER void axisAngle(
         detail::tmat4x4<T> const & mat,
@@ -112,6 +111,5 @@ namespace matrix_interpolation
 		return out;
     }
 
-}//namespace transform
 }//namespace gtx
 }//namespace glm

glm/gtx/matrix_major_storage.hpp

@@ -21,8 +21,7 @@
 #endif
 
 namespace glm{
-namespace gtx{
-namespace matrix_major_storage ///< GLM_GTX_matrix_major_storage: Build matrices with specific matrix order, row or column
+namespace gtx
 {
 	/// \addtogroup gtx_matrix_major_storage
 	/// @{
@@ -112,12 +111,9 @@ namespace matrix_major_storage ///< GLM_GTX_matrix_major_storage: Build matrices
 		const detail::tmat4x4<T>& m);
 
 	/// @}
-}//namespace matrix_major_storage
 }//namespace gtx
 }//namespace glm
 
 #include "matrix_major_storage.inl"
 
-namespace glm{using namespace gtx::matrix_major_storage;}
-
 #endif//glm_gtx_matrix_major_storage

glm/gtx/matrix_major_storage.inl

@@ -9,8 +9,7 @@
 
 namespace glm{
 namespace gtx{
-namespace matrix_major_storage
-{
+
     template <typename T> 
     GLM_FUNC_QUALIFIER detail::tmat2x2<T> rowMajor2(
 		const detail::tvec2<T>& v1, 
@@ -171,6 +170,5 @@ namespace matrix_major_storage
         return detail::tmat4x4<T>(m);
 	}
 
-}//namespace matrix_major_storage
 }//namespace gtx
 }//namespace glm

glm/gtx/matrix_operation.hpp

@@ -21,8 +21,7 @@
 #endif
 
 namespace glm{
-namespace gtx{
-namespace matrix_operation ///< GLM_GTX_matrix_operation: Build diagonal matrices
+namespace gtx
 {
 	/// \addtogroup gtx_matrix_operation
 	/// @{
@@ -82,7 +81,6 @@ namespace matrix_operation ///< GLM_GTX_matrix_operation: Build diagonal matrice
 		detail::tvec4<valType> const & v);
 
 	/// @}
-}//namespace matrix_operation
 }//namespace gtx
 }//namespace glm
 

glm/gtx/matrix_operation.inl

@@ -9,8 +9,7 @@
 
 namespace glm{
 namespace gtx{
-namespace matrix_operation
-{
+
 	template <typename valType> 
 	GLM_FUNC_QUALIFIER detail::tmat2x2<valType> diagonal2x2
 	(
@@ -124,6 +123,5 @@ namespace matrix_operation
 		return Result;		
 	}
 
-}//namespace matrix_operation
 }//namespace gtx
 }//namespace glm

glm/gtx/matrix_query.hpp

@@ -21,8 +21,7 @@
 #endif
 
 namespace glm{
-namespace gtx{
-namespace matrix_query ///< GLM_GTX_matrix_query: Query to evaluate matrix properties
+namespace gtx
 {
 	/// \addtogroup gtx_matrix_query
 	/// @{
@@ -84,12 +83,9 @@ namespace matrix_query ///< GLM_GTX_matrix_query: Query to evaluate matrix prope
 		const typename genType::value_type epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
 
 	/// @}
-}//namespace matrix_query
 }//namespace gtx
 }//namespace glm
 
 #include "matrix_query.inl"
 
-namespace glm{using namespace gtx::matrix_query;}
-
 #endif//glm_gtx_matrix_query

glm/gtx/matrix_query.inl

@@ -11,8 +11,7 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 namespace glm{
-namespace gtx{
-namespace matrix_query
+namespace gtx
 {
 	template<typename T> 
 	GLM_FUNC_QUALIFIER bool isNull(
@@ -139,6 +138,5 @@ namespace matrix_query
 		return result;
 	}
 
-}//namespace matrix_query
 }//namespace gtx
 }//namespace glm

glm/gtx/mixed_product.hpp

@@ -21,13 +21,12 @@
 #endif
 
 namespace glm{
-namespace gtx{
-namespace mixed_product ///< GLM_GTX_mixed_product extension: Mixed product of 3 vectors.
+namespace gtx
 {
-	/// \addtogroup gtx_mixed_product
+	/// @addtogroup gtx_mixed_product
 	/// @{
 
-	//! \brief Mixed product of 3 vectors (from GLM_GTX_mixed_product extension)
+	/// @brief Mixed product of 3 vectors (from GLM_GTX_mixed_product extension)
 	template <typename valType> 
 	valType mixedProduct(
 		detail::tvec3<valType> const & v1, 
@@ -35,12 +34,9 @@ namespace mixed_product ///< GLM_GTX_mixed_product extension: Mixed product of 3
 		detail::tvec3<valType> const & v3);
 
 	/// @}
-}// namespace mixed_product
 }// namespace gtx
 }// namespace glm
 
 #include "mixed_product.inl"
 
-namespace glm{using namespace gtx::mixed_product;}
-
 #endif//glm_gtx_mixed_product

glm/gtx/mixed_product.inl

@@ -10,18 +10,14 @@
 namespace glm{
 namespace gtx{
 
-namespace mixed_product
+template <typename valType> 
+GLM_FUNC_QUALIFIER valType mixedProduct(
+    detail::tvec3<valType> const & v1, 
+    detail::tvec3<valType> const & v2, 
+    detail::tvec3<valType> const & v3)
 {
-    template <typename valType> 
-	GLM_FUNC_QUALIFIER valType mixedProduct(
-		detail::tvec3<valType> const & v1, 
-		detail::tvec3<valType> const & v2, 
-		detail::tvec3<valType> const & v3)
-	{
-		return dot(cross(v1, v2), v3);
-	}
+    return dot(cross(v1, v2), v3);
 }
-//namespace mixed_product
 
 }//namespace gtx
 }//namespace glm

glm/gtx/multiple.hpp

@@ -21,10 +21,9 @@
 #endif
 
 namespace glm{
-namespace gtx{
-namespace multiple ///< GLM_GTX_multiple: Find the closest number of a number multiple of other number.
+namespace gtx
 {
-	/// \addtogroup gtx_multiple
+	/// @addtogroup gtx_multiple
 	/// @{
 
 	//! Higher Multiple number of Source.
@@ -42,12 +41,9 @@ namespace multiple ///< GLM_GTX_multiple: Find the closest number of a number mu
 		genType const & Multiple);
 
 	/// @}
-}//namespace multiple
 }//namespace gtx
 }//namespace glm
 
 #include "multiple.inl"
 
-namespace glm{using namespace gtx::multiple;}
-
 #endif//glm_gtx_multiple

glm/gtx/multiple.inl

@@ -2,7 +2,7 @@
 // OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // Created : 2009-10-26
-// Updated : 2009-10-26
+// Updated : 2011-06-07
 // Licence : This source is under MIT License
 // File    : glm/gtx/multiple.inl
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -11,8 +11,7 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 namespace glm{
-namespace gtx{
-namespace multiple
+namespace gtx
 {
 	//////////////////////
 	// higherMultiple
@@ -186,6 +185,5 @@ namespace multiple
 		return Result;
 	}
 
-}//namespace multiple
 }//namespace gtx
 }//namespace glm

glm/gtx/noise.hpp

@@ -26,10 +26,9 @@
 #endif
 
 namespace glm{
-namespace gtx{
-namespace noise	///< GLM_GTX_noise extension: Comparison functions for a user defined epsilon values.
+namespace gtx
 {
-	/// \addtogroup gtx_noise
+	/// @addtogroup gtx_noise
 	/// @{
 
 	//! Classic perlin noise.
@@ -52,12 +51,9 @@ namespace noise	///< GLM_GTX_noise extension: Comparison functions for a user de
 		vecType<T> const & p);
 
 	/// @}
-}//namespace noise
 }//namespace gtx
 }//namespace glm
 
 #include "noise.inl"
 
-namespace glm{using namespace gtx::noise;}
-
 #endif//glm_gtx_noise

glm/gtx/noise.inl

@@ -15,8 +15,9 @@
 // - GLM core
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-namespace glm
-{
+namespace glm{
+namespace gtx{
+
 	template <typename T>
 	GLM_FUNC_QUALIFIER T permute(T const & x)
 	{
@@ -57,9 +58,6 @@ namespace glm
 		return detail::tvec4<T>(pXYZ, pW);
 	}
 
-namespace gtx{
-namespace noise
-{
 	// Classic Perlin noise
 	template <typename T>
 	GLM_FUNC_QUALIFIER T perlin(detail::tvec2<T> const & P)
@@ -787,6 +785,5 @@ namespace noise
 			dot(m1 * m1, detail::tvec2<T>(dot(p3, x3), dot(p4, x4))));
 	}
 
-}//namespace noise
 }//namespace gtx
 }//namespace glm

glm/gtx/norm.hpp

@@ -26,10 +26,9 @@
 #endif
 
 namespace glm{
-namespace gtx{
-namespace norm ///< GLM_GTX_norm extension: Various way to compute vector norms.
+namespace gtx
 {
-	/// \addtogroup gtx_norm
+	/// @addtogroup gtx_norm
 	/// @{
 
 	//! Returns the squared length of x.
@@ -132,12 +131,9 @@ namespace norm ///< GLM_GTX_norm extension: Various way to compute vector norms.
 		unsigned int Depth);
 
 	/// @}
-}//namespace norm
 }//namespace gtx
 }//namespace glm
 
 #include "norm.inl"
 
-namespace glm{using namespace gtx::norm;}
-
 #endif//glm_gtx_norm

glm/gtx/norm.inl

@@ -8,8 +8,7 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 namespace glm{
-namespace gtx{
-namespace norm
+namespace gtx
 {
 	template <typename T>
     GLM_FUNC_QUALIFIER T length2(
@@ -125,6 +124,5 @@ namespace norm
 		return pow(pow(v.x, T(Depth)) + pow(v.y, T(Depth)) + pow(v.z, T(Depth)), T(1) / T(Depth));
 	}
 
-}//namespace norm
 }//namespace gtx
 }//namespace glm

glm/gtx/normal.hpp

@@ -21,10 +21,9 @@
 #endif
 
 namespace glm{
-namespace gtx{
-namespace normal ///< GLM_GTX_normal extension: Compute the normal of a triangle.
+namespace gtx
 {
-	/// \addtogroup gtx_normal
+	/// @addtogroup gtx_normal
 	/// @{
 
 	//! Computes triangle normal from triangle points. 
@@ -36,12 +35,9 @@ namespace normal ///< GLM_GTX_normal extension: Compute the normal of a triangle
 		detail::tvec3<T> const & p3);
 
 	/// @}
-}//namespace normal
 }//namespace gtx
 }//namespace glm
 
 #include "normal.inl"
 
-namespace glm{using namespace gtx::normal;}
-
 #endif//glm_gtx_normal

glm/gtx/normal.inl

@@ -2,26 +2,24 @@
 // OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // Created : 2005-12-21
-// Updated : 2005-12-21
+// Updated : 2011-06-07
 // Licence : This source is under MIT License
 // File    : glm/gtx/normal.inl
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 namespace glm{
 namespace gtx{
-namespace normal{
 
-    template <typename T> 
-    GLM_FUNC_QUALIFIER detail::tvec3<T> triangleNormal
-	(
-		detail::tvec3<T> const & p1, 
-		detail::tvec3<T> const & p2, 
-		detail::tvec3<T> const & p3
-	)
-    {
-        return normalize(cross(p1 - p2, p1 - p3));
-    }
+template <typename T> 
+GLM_FUNC_QUALIFIER detail::tvec3<T> triangleNormal
+(
+    detail::tvec3<T> const & p1, 
+    detail::tvec3<T> const & p2, 
+    detail::tvec3<T> const & p3
+)
+{
+    return normalize(cross(p1 - p2, p1 - p3));
+}
 
-}//namespace normal
 }//namespace gtx
 }//namespace glm

glm/gtx/normalize_dot.hpp

@@ -23,12 +23,9 @@
 #endif
 
 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
 {
-	using namespace gtx::fast_square_root;
-
-	/// \addtogroup gtx_normalize_dot
+	/// @addtogroup gtx_normalize_dot
 	/// @{
 
 	//! Normalize parameters and returns the dot product of x and y.
@@ -48,12 +45,9 @@ namespace normalize_dot	///< GLM_GTX_normalize_dot extension: Dot product of vec
 		genType const & y);
 
 	/// @}
-}//namespace normalize_dot
 }//namespace gtx
 }//namespace glm
 
 #include "normalize_dot.inl"
 
-namespace glm{using namespace gtx::normalize_dot;}
-
 #endif//glm_gtx_normalize_dot

glm/gtx/normalize_dot.inl

@@ -9,7 +9,6 @@
 
 namespace glm{
 namespace gtx{
-namespace normalize_dot{
 
 template <typename genType> 
 GLM_FUNC_QUALIFIER genType normalizeDot
@@ -115,6 +114,5 @@ GLM_FUNC_QUALIFIER valType fastNormalizeDot
 		glm::dot(y, y));
 }
 
-}//namespace normalize_dot
 }//namespace gtx
 }//namespace glm

glm/gtx/number_precision.hpp

@@ -24,13 +24,12 @@
 #endif
 
 namespace glm{
-namespace gtx{
-namespace number_precision ///< GLM_GTX_number_precision extension: Defined size types.
+namespace gtx
 {
 	/////////////////////////////
 	// Unsigned int vector types 
 
-	/// \addtogroup gtx_number_precision
+	/// @addtogroup gtx_number_precision
 	/// @{
 
 	typedef u8			u8vec1;		//!< \brief 8bit unsigned integer scalar. (from GLM_GTX_number_precision extension)
@@ -56,12 +55,9 @@ namespace number_precision ///< GLM_GTX_number_precision extension: Defined size
 	typedef f64			f64mat1x1;	//!< \brief Double-precision floating-point scalar. (from GLM_GTX_number_precision extension)
 
 	/// @}
-}//namespace number_precision
 }//namespace gtx
 }//namespace glm
 
 #include "number_precision.inl"
 
-namespace glm{using namespace gtx::number_precision;}
-
 #endif//glm_gtx_number_precision

glm/gtx/ocl_type.hpp

@@ -21,13 +21,12 @@
 #endif
 
 namespace glm{
-namespace gtx{
-namespace ocl_type ///< GLM_GTX_ocl_type extension: OpenCL types.
+namespace gtx
 {
 	///////////////////////////
 	// Scalar types 
 
-	/// \addtogroup gtx_ocl_type
+	/// @addtogroup gtx_ocl_type
 	/// @{
 
 	typedef detail::int8						cl_char;		//!< \brief 8bit signed integer. (from GLM_GTX_ocl_type extension)
@@ -99,12 +98,9 @@ namespace ocl_type ///< GLM_GTX_ocl_type extension: OpenCL types.
 	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
 
 #include "ocl_type.inl"
 
-namespace glm{using namespace gtx::ocl_type;}
-
 #endif//glm_gtx_ocl_type

glm/gtx/optimum_pow.hpp

@@ -21,10 +21,9 @@
 #endif
 
 namespace glm{
-namespace gtx{
-namespace optimum_pow ///< GLM_GTX_optimum_pow extension: Integer exponentiation of power functions.
+namespace gtx
 {
-	/// \addtogroup gtx_optimum_pow
+	/// @addtogroup gtx_optimum_pow
 	/// @{
 
 	//! Returns x raised to the power of 2.
@@ -59,12 +58,9 @@ namespace optimum_pow ///< GLM_GTX_optimum_pow extension: Integer exponentiation
     detail::tvec4<bool> powOfTwo(const detail::tvec4<int>& x);
 
 	/// @}
-}//namespace optimum_pow
 }//namespace gtx
 }//namespace glm
 
 #include "optimum_pow.inl"
 
-namespace glm{using namespace gtx::optimum_pow;}
-
 #endif//glm_gtx_optimum_pow

glm/gtx/optimum_pow.inl

@@ -9,7 +9,6 @@
 
 namespace glm{
 namespace gtx{
-namespace optimum_pow{
 
     template <typename genType> 
     GLM_FUNC_QUALIFIER genType pow2(const genType& x)
@@ -58,6 +57,5 @@ namespace optimum_pow{
             powOfTwo(x.w));
     }
 
-}//namespace optimum_pow
 }//namespace gtx
 }//namespace glm

glm/gtx/orthonormalize.hpp

@@ -21,10 +21,9 @@
 #endif
 
 namespace glm{
-namespace gtx{
-namespace orthonormalize ///< GLM_GTX_orthonormalize extension: Orthonormalize matrices.
+namespace gtx
 {
-	/// \addtogroup gtx_orthonormalize
+	/// @addtogroup gtx_orthonormalize
 	/// @{
 
 	//! Returns the orthonormalized matrix of m.
@@ -41,12 +40,9 @@ namespace orthonormalize ///< GLM_GTX_orthonormalize extension: Orthonormalize m
 		const detail::tvec3<T>& y);
 
 	/// @}
-}//namespace orthonormalize
 }//namespace gtx
 }//namespace glm
 
 #include "orthonormalize.inl"
 
-namespace glm{using namespace gtx::orthonormalize;}
-
 #endif//glm_gtx_orthonormalize

glm/gtx/orthonormalize.inl

@@ -9,7 +9,6 @@
 
 namespace glm{
 namespace gtx{
-namespace orthonormalize{
 
     template <typename T>
     GLM_FUNC_QUALIFIER detail::tmat3x3<T> orthonormalize
@@ -43,7 +42,6 @@ namespace orthonormalize{
         return normalize(x - y * dot(y, x));
     }
 
-}//namespace orthonormalize
 }//namespace gtx
 }//namespace glm
 

glm/gtx/perpendicular.hpp

@@ -23,10 +23,9 @@
 #endif
 
 namespace glm{
-namespace gtx{
-namespace perpendicular ///< GLM_GTX_perpendicular extension: Perpendicular of a vector from other one
+namespace gtx
 {
-	/// \addtogroup gtx_perpendicular
+	/// @addtogroup gtx_perpendicular
 	/// @{
 
 	//! Projects x a perpendicular axis of Normal.
@@ -51,12 +50,9 @@ namespace perpendicular ///< GLM_GTX_perpendicular extension: Perpendicular of a
 		detail::tvec4<T> const & Normal);
 
 	/// @}
-}//namespace perpendicular
 }//namespace gtx
 }//namespace glm
 
 #include "perpendicular.inl"
 
-namespace glm{using namespace gtx::perpendicular;}
-
 #endif//glm_gtx_perpendicular

glm/gtx/perpendicular.inl

@@ -9,7 +9,6 @@
 
 namespace glm{
 namespace gtx{
-namespace perpendicular{
 
 template <typename T> 
 GLM_FUNC_QUALIFIER detail::tvec2<T> perp(
@@ -35,6 +34,5 @@ GLM_FUNC_QUALIFIER detail::tvec4<T> perp(
     return x - projection::proj(x, Normal);
 }
 
-}//namespace perpendicular
 }//namespace gtx
 }//namespace glm

glm/gtx/polar_coordinates.hpp

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

glm/gtx/polar_coordinates.inl

@@ -8,8 +8,7 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 namespace glm{
-namespace gtx{
-namespace polar_coordinates
+namespace gtx
 {
 	template <typename T> 
 	GLM_FUNC_QUALIFIER detail::tvec3<T> polar(
@@ -37,6 +36,5 @@ namespace polar_coordinates
 			cos(latitude) * cos(longitude));
 	}
 
-}//namespace polar_coordinates
 }//namespace gtx
 }//namespace glm

glm/gtx/projection.hpp

@@ -21,10 +21,9 @@
 #endif
 
 namespace glm{
-namespace gtx{
-namespace projection ///< GLM_GTX_projection extension: Projection of a vector to other one
+namespace gtx
 {
-	/// \addtogroup gtx_projection
+	/// @addtogroup gtx_projection
 	/// @{
 
 	//! Projects x on Normal.
@@ -49,12 +48,9 @@ namespace projection ///< GLM_GTX_projection extension: Projection of a vector t
 		detail::tvec4<T> const & Normal);
 
 	/// @}
-}//namespace projection
 }//namespace gtx
 }//namespace glm
 
 #include "projection.inl"
 
-namespace glm{using namespace gtx::projection;}
-
 #endif//glm_gtx_projection

glm/gtx/projection.inl

@@ -9,7 +9,6 @@
 
 namespace glm{
 namespace gtx{
-namespace projection{
 
 template <typename T> 
 GLM_FUNC_QUALIFIER detail::tvec2<T> proj(
@@ -35,6 +34,5 @@ GLM_FUNC_QUALIFIER detail::tvec4<T> proj(
 	return glm::dot(x, Normal) / glm::dot(Normal, Normal) * Normal;
 }
 
-}//namespace projection
 }//namespace gtx
 }//namespace glm

glm/gtx/quaternion.hpp

@@ -26,11 +26,10 @@
 #endif
 
 namespace glm{
-namespace gtx{
-namespace quaternion ///< GLM_GTX_quaternion extension: Quaternion types and functions
+namespace gtx
 {
-	/// \addtogroup gtx_quaternion
-	///@{
+	/// @addtogroup gtx_quaternion
+	/// @{
 
 	//! Compute a cross product between a quaternion and a vector. 
 	//! From GLM_GTX_quaternion extension.
@@ -204,12 +203,9 @@ namespace quaternion ///< GLM_GTX_quaternion extension: Quaternion types and fun
 		T const & a);
 
 	/// @}
-}//namespace quaternion
 }//namespace gtx
 }//namespace glm
 
 #include "quaternion.inl"
 
-namespace glm{using namespace gtx::quaternion;}
-
 #endif//glm_gtx_quaternion

glm/gtx/quaternion.inl

@@ -10,8 +10,7 @@
 #include <limits>
 
 namespace glm{
-namespace gtx{
-namespace quaternion
+namespace gtx
 {
     template <typename valType> 
     GLM_FUNC_QUALIFIER detail::tvec3<valType> cross
@@ -298,6 +297,5 @@ namespace quaternion
 		return glm::normalize(x * (T(1) - a) + (y * a));
 	}
 
-}//namespace quaternion
 }//namespace gtx
 }//namespace glm

glm/gtx/random.hpp

@@ -24,10 +24,9 @@
 #endif
 
 namespace glm{
-namespace gtx{
-namespace random ///< GLM_GTX_random extension: Generate random number from various distribution methods
+namespace gtx
 {
-	/// \addtogroup gtx_random
+	/// @addtogroup gtx_random
 	/// @{
 
 	//! Generate a random number in the interval [-1, 1], according a linear distribution.
@@ -78,12 +77,9 @@ namespace random ///< GLM_GTX_random extension: Generate random number from vari
     template <typename T> detail::tvec4<T> gaussRand4(const detail::tvec4<T>& mean, const detail::tvec4<T>& std_deviation);     //!< \brief Gererate 4 random floating numbers according a Gauss distribution. (From GLM_GTX_random extension)
 
 	///@}
-}//namespace random
 }//namespace gtx
 }//namespace glm
 
 #include "random.inl"
 
-namespace glm{using namespace gtx::random;}
-
 #endif//glm_gtx_random

glm/gtx/random.inl

@@ -11,8 +11,7 @@
 #include <cassert>
 
 namespace glm{
-namespace gtx{
-namespace random
+namespace gtx
 {
     template <>
 	GLM_FUNC_QUALIFIER float signedRand1()
@@ -531,6 +530,5 @@ namespace random
             gaussRand1(mean.w, std_deviation.w));
     }
 
-}//namespace random
 }//namespace gtx
 }//namespace glm

glm/gtx/raw_data.hpp

@@ -22,11 +22,10 @@
 #endif
 
 namespace glm{
-namespace gtx{
-namespace raw_data ///< GLM_GTX_raw_data extension: Projection of a vector to other one
+namespace gtx
 {
-	/// \addtogroup gtx_raw_data
-	///@{
+	/// @addtogroup gtx_raw_data
+	/// @{
 
 	//! Type for byte numbers. 
 	//! From GLM_GTX_raw_data extension.
@@ -44,13 +43,11 @@ namespace raw_data ///< GLM_GTX_raw_data extension: Projection of a vector to ot
 	//! From GLM_GTX_raw_data extension.
 	typedef uint64		qword;
 
-	///@}
+	/// @}
 }// namespace raw_data
 }// namespace gtx
 }// namespace glm
 
 #include "raw_data.inl"
 
-namespace glm{using namespace gtx::raw_data;}
-
 #endif//glm_gtx_raw_data

glm/gtx/reciprocal.hpp

@@ -18,10 +18,9 @@
 #endif
 
 namespace glm{
-namespace gtx{
-namespace reciprocal ///< GLM_GTX_reciprocal extension: Define secant, cosecant and cotangent functions.
+namespace gtx
 {
-	/// \addtogroup gtx_reciprocal
+	/// @addtogroup gtx_reciprocal
 	/// @{
 
 	//! Secant function. 
@@ -88,12 +87,9 @@ namespace reciprocal ///< GLM_GTX_reciprocal extension: Define secant, cosecant
 	genType acoth(genType const & x);
 
 	/// @}
-}//namespace reciprocal
 }//namespace gtx
 }//namespace glm
 
 #include "reciprocal.inl"
 
-namespace glm{using namespace gtx::reciprocal;}
-
 #endif//glm_gtx_reciprocal

glm/gtx/reciprocal.inl

@@ -9,7 +9,6 @@
 
 namespace glm{
 namespace gtx{
-namespace reciprocal{
 
 // sec
 template <typename genType>
@@ -588,6 +587,5 @@ GLM_FUNC_QUALIFIER detail::tvec4<valType> acoth
         acoth(x.w));
 }
 
-}//namespace reciprocal
 }//namespace gtx
 }//namespace glm

glm/gtx/rotate_vector.hpp

@@ -22,12 +22,9 @@
 #endif
 
 namespace glm{
-namespace gtx{
-namespace rotate_vector ///< GLM_GTX_rotate_vector extension: Function to directly rotate a vector
+namespace gtx
 {
-	using namespace transform;
-
-	/// \addtogroup gtx_rotate_vector
+	/// @addtogroup gtx_rotate_vector
 	/// @{
 
 	//! Rotate a two dimensional vector.
@@ -103,12 +100,9 @@ namespace rotate_vector ///< GLM_GTX_rotate_vector extension: Function to direct
         detail::tvec3<T> const & Up);
 
 	/// @}
-}//namespace rotate_vector
 }//namespace gtx
 }//namespace glm
 
 #include "rotate_vector.inl"
 
-namespace glm{using namespace gtx::rotate_vector;}
-
 #endif//glm_gtx_rotate_vector

glm/gtx/rotate_vector.inl

@@ -9,8 +9,7 @@
 
 namespace glm{
 namespace gtx{
-namespace rotate_vector
-{
+
 	template <typename T>
 	GLM_FUNC_QUALIFIER detail::tvec2<T> rotate(
         detail::tvec2<T> const & v, 
@@ -144,6 +143,5 @@ namespace rotate_vector
 		return glm::gtx::transform::rotate(Angle, RotationAxis);
 	}
 
-}//namespace rotate_vector
 }//namespace gtx
 }//namespace glm

glm/gtx/simd_mat4.hpp

@@ -128,13 +128,12 @@ namespace detail
 	fmat4x4SIMD const operator++ (fmat4x4SIMD const & m, int);
 }//namespace detail
 
-namespace gtx{
-namespace simd_mat4 ///< GLM_GTX_simd_mat4 extension: SIMD implementation of mat4 type.
+namespace gtx
 {
 	typedef detail::fmat4x4SIMD simdMat4;
 
-	/// \addtogroup gtx_simd_mat4
-	///@{
+	/// @addtogroup gtx_simd_mat4
+	/// @{
 
 	//! Convert a simdMat4 to a mat4.
 	//! (From GLM_GTX_simd_mat4 extension)
@@ -172,12 +171,9 @@ namespace simd_mat4 ///< GLM_GTX_simd_mat4 extension: SIMD implementation of mat
 		detail::fmat4x4SIMD const & m);
 
 	/// @}
-}// namespace simd_mat4
 }// namespace gtx
 }// namespace glm
 
 #include "simd_mat4.inl"
 
-namespace glm{using namespace gtx::simd_mat4;}
-
 #endif//glm_gtx_simd_mat4

glm/gtx/simd_mat4.inl

@@ -234,8 +234,7 @@ namespace detail
 
 }//namespace detail
 
-namespace gtx{
-namespace simd_mat4
+namespace gtx
 {
 	GLM_FUNC_QUALIFIER detail::tmat4x4<float> mat4_cast
 	(
@@ -303,7 +302,6 @@ namespace simd_mat4
 		detail::sse_inverse_ps(&m[0].Data, &result[0].Data);
 		return result;
 	}
-}//namespace simd_mat4
-}//namespace gtx
 
+}//namespace gtx
 }//namespace glm

glm/gtx/simd_vec4.hpp

@@ -111,13 +111,12 @@ namespace detail
 	};
 }//namespace detail
 
-namespace gtx{
-namespace simd_vec4 ///< GLM_GTX_simd_vec4 extension: SIMD implementation of vec4 type.
+namespace gtx
 {
 	typedef glm::detail::fvec4SIMD simdVec4;
 
-	/// \addtogroup gtx_simd_vec4
-	///@{
+	/// @addtogroup gtx_simd_vec4
+	/// @{
 
 	//! Convert a simdVec4 to a vec4.
 	//! (From GLM_GTX_simd_vec4 extension)
@@ -463,12 +462,9 @@ namespace simd_vec4 ///< GLM_GTX_simd_vec4 extension: SIMD implementation of vec
 		detail::fvec4SIMD const & x);
 
 	/// @}
-}//namespace simd_vec4
 }//namespace gtx
 }//namespace glm
 
 #include "simd_vec4.inl"
 
-namespace glm{using namespace gtx::simd_vec4;}
-
 #endif//glm_gtx_simd_vec4

glm/gtx/simd_vec4.inl

@@ -7,10 +7,9 @@
 // File    : glm/gtx/simd_vec4.inl
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-namespace glm
+namespace glm{
+namespace detail
 {
-	namespace detail
-	{
 		template <int Value>
 		struct mask
 		{
@@ -265,11 +264,10 @@ namespace glm
 			return fvec4SIMD(_mm_sub_ps(v.Data, glm::detail::one));
 		}
 
-	}//namespace detail
+}//namespace detail
+
+namespace gtx{
 
-	namespace gtx{
-	namespace simd_vec4
-	{
 		GLM_FUNC_QUALIFIER detail::tvec4<float> vec4_cast
 		(
 			detail::fvec4SIMD const & x
@@ -725,6 +723,5 @@ namespace glm
 			return _mm_rsqrt_ps(x.Data);
 		}
 
-	}//namespace simd_vec4
-	}//namespace gtx
+}//namespace gtx
 }//namespace glm

glm/gtx/simplex.hpp

@@ -21,11 +21,10 @@
 #endif
 
 namespace glm{
-namespace gtx{
-namespace spline ///< GLM_GTX_simplex extension: Spline functions
+namespace gtx
 {
-    /// \addtogroup gtx_spline
-    ///@{
+    /// @addtogroup gtx_spline
+    /// @{
             
     //! Return a point from a catmull rom curve.
     //! From GLM_GTX_spline extension.
@@ -58,13 +57,10 @@ namespace spline ///< GLM_GTX_simplex extension: Spline functions
                     typename genType::value_type const & s);
             
     /// @}
-}// namespace simplex
 }// namespace gtx
 }// namespace glm
 
 #include "simplex.inl"
 
-namespace glm{using namespace gtx::simplex;}
-
 #endif//glm_gtx_spline