Removed gtx extension namespace

glm/gtx/color_cast.hpp

@@ -56,7 +56,7 @@ namespace gtx
 	template <typename T> gtc::uint64 u64_bgra_cast(const detail::tvec4<T>& c);		//!< \brief Conversion of a 4 components color into an 64bit unsigned int value. (From GLM_GTX_color_cast extension)
 	template <typename T> gtc::uint64 u64_abgr_cast(const detail::tvec4<T>& c);		//!< \brief Conversion of a 4 components color into an 64bit unsigned int value. (From GLM_GTX_color_cast extension)
 
-	template <typename T> gtx::number_precision::f16vec1 f16_channel_cast(T a);	//!< \brief Conversion of a u8 or u16 value to a single channel floating value. (From GLM_GTX_color_cast extension)
+	template <typename T> gtx::f16vec1 f16_channel_cast(T a);	//!< \brief Conversion of a u8 or u16 value to a single channel floating value. (From GLM_GTX_color_cast extension)
 
 	template <typename T> gtc::f16vec3 f16_rgbx_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
 	template <typename T> gtc::f16vec3 f16_xrgb_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
@@ -68,7 +68,7 @@ namespace gtx
 	template <typename T> gtc::f16vec4 f16_bgra_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 4 components floating color. (From GLM_GTX_color_cast extension)
 	template <typename T> gtc::f16vec4 f16_abgr_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 4 components floating color. (From GLM_GTX_color_cast extension)
 
-	template <typename T> gtx::number_precision::f32vec1 f32_channel_cast(T a);	//!< \brief Conversion of a u8 or u16 value to a single channel floating value. (From GLM_GTX_color_cast extension)
+	template <typename T> gtx::f32vec1 f32_channel_cast(T a);	//!< \brief Conversion of a u8 or u16 value to a single channel floating value. (From GLM_GTX_color_cast extension)
 
 	template <typename T> gtc::f32vec3 f32_rgbx_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
 	template <typename T> gtc::f32vec3 f32_xrgb_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
@@ -80,7 +80,7 @@ namespace gtx
 	template <typename T> gtc::f32vec4 f32_bgra_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 4 components floating color. (From GLM_GTX_color_cast extension)
 	template <typename T> gtc::f32vec4 f32_abgr_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 4 components floating color. (From GLM_GTX_color_cast extension)
 
-	template <typename T> gtx::number_precision::f64vec1 f64_channel_cast(T a);	//!< \brief Conversion of a u8 or u16 value to a single channel floating value. (From GLM_GTX_color_cast extension)
+	template <typename T> gtx::f64vec1 f64_channel_cast(T a);	//!< \brief Conversion of a u8 or u16 value to a single channel floating value. (From GLM_GTX_color_cast extension)
 
 	template <typename T> gtc::f64vec3 f64_rgbx_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
 	template <typename T> gtc::f64vec3 f64_xrgb_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)

glm/gtx/color_cast.inl

@@ -9,8 +9,6 @@
 
 namespace glm{
 namespace gtx{
-//! GLM_GTX_color_cast extension: Conversion between two color types
-namespace color_cast{
 
 template <typename T> 
 GLM_FUNC_QUALIFIER gtc::uint8 u8channel_cast(T a)
@@ -734,6 +732,5 @@ GLM_FUNC_QUALIFIER detail::tvec4<double> f64_abgr_cast<uint64>(uint64 color)
 	return result;
 }
 
-}//namespace color_space
 }//namespace gtx
 }//namespace glm

glm/gtx/gradient_paint.inl

@@ -19,11 +19,11 @@ namespace gtx{
 	{
 		glm::detail::tvec2<valType> F = Focal - Center;
 		glm::detail::tvec2<valType> D = Position - Focal;
-		valType Radius2 = gtx::optimum_pow::pow2(Radius);
+		valType Radius2 = gtx::pow2(Radius);
-		valType Fx2 = gtx::optimum_pow::pow2(F.x);
+		valType Fx2 = gtx::pow2(F.x);
-		valType Fy2 = gtx::optimum_pow::pow2(F.y);
+		valType Fy2 = gtx::pow2(F.y);
 
-		valType Numerator = (D.x * F.x + D.y * F.y) + glm::sqrt(Radius2 * (gtx::optimum_pow::pow2(D.x) + gtx::optimum_pow::pow2(D.y)) - gtx::optimum_pow::pow2(D.x * F.y - D.y * F.x));
+		valType Numerator = (D.x * F.x + D.y * F.y) + glm::sqrt(Radius2 * (gtx::pow2(D.x) + gtx::pow2(D.y)) - gtx::pow2(D.x * F.y - D.y * F.x));
 		valType Denominator = Radius2 - (Fx2 + Fy2);
 		return Numerator / Denominator;
 	}

glm/gtx/matrix_operation.hpp

@@ -86,6 +86,4 @@ namespace gtx
 
 #include "matrix_operation.inl"
 
-namespace glm{using namespace gtx::matrix_operation;}
-
 #endif//glm_gtx_matrix_operation

glm/gtx/normalize_dot.inl

@@ -71,7 +71,7 @@ GLM_FUNC_QUALIFIER genType fastNormalizeDot
 {
 	return 
 		glm::dot(x, y) * 
-		glm::gtx::fast_square_root::fastInverseSqrt(glm::dot(x, x) * 
+		glm::gtx::fastInverseSqrt(glm::dot(x, x) * 
 		glm::dot(y, y));
 }
 
@@ -84,7 +84,7 @@ GLM_FUNC_QUALIFIER valType fastNormalizeDot
 {
 	return 
 		glm::dot(x, y) * 
-		glm::gtx::fast_square_root::fastInverseSqrt(glm::dot(x, x) * 
+		glm::gtx::fastInverseSqrt(glm::dot(x, x) * 
 		glm::dot(y, y));
 }
 
@@ -97,7 +97,7 @@ GLM_FUNC_QUALIFIER valType fastNormalizeDot
 {
 	return 
 		glm::dot(x, y) * 
-		glm::gtx::fast_square_root::fastInverseSqrt(glm::dot(x, x) * 
+		glm::gtx::fastInverseSqrt(glm::dot(x, x) * 
 		glm::dot(y, y));
 }
 
@@ -110,7 +110,7 @@ GLM_FUNC_QUALIFIER valType fastNormalizeDot
 {
 	return 
 		glm::dot(x, y) * 
-		glm::gtx::fast_square_root::fastInverseSqrt(glm::dot(x, x) * 
+		glm::gtx::fastInverseSqrt(glm::dot(x, x) * 
 		glm::dot(y, y));
 }
 

glm/gtx/perpendicular.inl

@@ -15,7 +15,7 @@ GLM_FUNC_QUALIFIER detail::tvec2<T> perp(
 	detail::tvec2<T> const & x, 
 	detail::tvec2<T> const & Normal)
 {
-    return x - projection::proj(x, Normal);
+    return x - proj(x, Normal);
 }
 
 template <typename T> 
@@ -23,7 +23,7 @@ GLM_FUNC_QUALIFIER detail::tvec3<T> perp(
 	detail::tvec3<T> const & x, 
 	detail::tvec3<T> const & Normal)
 {
-    return x - projection::proj(x, Normal);
+    return x - proj(x, Normal);
 }
 
 template <typename T> 
@@ -31,7 +31,7 @@ GLM_FUNC_QUALIFIER detail::tvec4<T> perp(
 	detail::tvec4<T> const & x, 
 	detail::tvec4<T> const & Normal)
 {
-    return x - projection::proj(x, Normal);
+    return x - proj(x, Normal);
 }
 
 }//namespace gtx

glm/gtx/raw_data.hpp

@@ -44,7 +44,6 @@ namespace gtx
 	typedef uint64		qword;
 
 	/// @}
-}// namespace raw_data
 }// namespace gtx
 }// namespace glm
 

glm/gtx/rotate_vector.inl

@@ -29,7 +29,7 @@ namespace gtx{
         T const & angle, 
 		const detail::tvec3<T> & normal)
 	{
-		return detail::tmat3x3<T>(glm::gtx::transform::rotate(angle, normal)) * v;
+		return detail::tmat3x3<T>(glm::gtx::rotate(angle, normal)) * v;
 	}
 /*
     template <typename T> 
@@ -49,7 +49,7 @@ namespace gtx{
 		T const & angle, 
         detail::tvec3<T> const & normal)
 	{
-		return glm::gtx::transform::rotate(angle, normal) * v;
+		return glm::gtx::rotate(angle, normal) * v;
 	}
 
 	template <typename T>
@@ -140,7 +140,7 @@ namespace gtx{
 
 		detail::tvec3<T> RotationAxis = cross(Up, Normal);
 		T Angle = degrees(acos(dot(Normal, Up)));
-		return glm::gtx::transform::rotate(Angle, RotationAxis);
+		return glm::gtx::rotate(Angle, RotationAxis);
 	}
 
 }//namespace gtx

glm/gtx/spline.hpp

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

glm/gtx/spline.inl

@@ -8,8 +8,7 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 namespace glm{
-namespace gtx{
+namespace gtx
-namespace spline
 {
 	template <typename genType>
 	GLM_FUNC_QUALIFIER genType catmullRom
@@ -22,8 +21,8 @@ namespace spline
 	)
 	{
 		typename genType::value_type s1 = s;
-		typename genType::value_type s2 = optimum_pow::pow2(s);
+		typename genType::value_type s2 = pow2(s);
-		typename genType::value_type s3 = optimum_pow::pow3(s);
+		typename genType::value_type s3 = pow3(s);
 
 		typename genType::value_type f1 = -s3 + typename genType::value_type(2) * s2 - s;
 		typename genType::value_type f2 = typename genType::value_type(3) * s3 - typename genType::value_type(5) * s2 + typename genType::value_type(2);
@@ -45,8 +44,8 @@ namespace spline
 	)
 	{
 		typename genType::value_type s1 = s;
-		typename genType::value_type s2 = optimum_pow::pow2(s);
+		typename genType::value_type s2 = pow2(s);
-		typename genType::value_type s3 = optimum_pow::pow3(s);
+		typename genType::value_type s3 = pow3(s);
 
 		typename genType::value_type f1 = typename genType::value_type(2) * s3 - typename genType::value_type(3) * s2 + typename genType::value_type(1);
 		typename genType::value_type f2 = typename genType::value_type(-2) * s3 + typename genType::value_type(3) * s2;
@@ -69,6 +68,5 @@ namespace spline
 		return ((v1 * s + v2) * s + v3) * s + v4;
 	}
 
-}//namespace spline
 }//namespace gtx
 }//namespace glm

glm/gtx/std_based_type.hpp

@@ -22,8 +22,7 @@
 #endif
 
 namespace glm{
-namespace gtx{
+namespace gtx
-namespace std_based_type ///< GLM_GTX_std_based_type extension: Add support vector types based on C++ standard type
 {
 	typedef detail::tvec2<std::size_t>		size2;
 	typedef detail::tvec3<std::size_t>		size3;
@@ -61,12 +60,9 @@ namespace std_based_type ///< GLM_GTX_std_based_type extension: Add support vect
 	typedef detail::tvec3<unsigned long>	ulvec3;
 	typedef detail::tvec4<unsigned long>	ulvec4;
 
-}//namespace std_based_type
 }//namespace gtx
 }//namespace glm
 
 #include "std_based_type.inl"
 
-namespace glm{using namespace gtx::std_based_type;}
-
 #endif//glm_gtx_std_based_type

glm/gtx/string_cast.hpp

@@ -29,14 +29,9 @@
 #endif
 
 namespace glm{
-namespace gtx{
+namespace gtx
-namespace string_cast ///< GLM_GTX_string_cast extension: Setup strings for GLM type values
 {
-	using namespace gtx::integer; 
+	/// @addtogroup gtx_string_cast
-	using namespace gtx::unsigned_int; 
-	using namespace gtx::quaternion; 
-
-	/// \addtogroup gtx_string_cast
 	/// @{
 
 	//! Create a string from a GLM type value.
@@ -45,12 +40,9 @@ namespace string_cast ///< GLM_GTX_string_cast extension: Setup strings for GLM
 	std::string to_string(genType const & x);
 
 	/// @}
-}//namespace string_cast
 }//namespace gtx
 }//namespace glm
 
 #include "string_cast.inl"
 
-namespace glm{using namespace gtx::string_cast;}
-
 #endif//glm_gtx_string_cast

glm/gtx/string_cast.inl

@@ -34,8 +34,7 @@ namespace detail
 }//namespace detail
 
 namespace gtx{
-namespace string_cast
+
-{
 	////////////////////////////////
 	// Scalars
 
@@ -592,6 +591,5 @@ namespace string_cast
 			x[3][0], x[3][1], x[3][2], x[3][3]);
 	}
 
-	}//namespace string_cast
 }//namespace gtx
 }//namespace glm

glm/gtx/transform.hpp

@@ -43,8 +43,7 @@
 #endif
 
 namespace glm{
-namespace gtx{
+namespace gtx
-namespace transform ///< GLM_GTX_transform extension: Add transformation matrices
 {
 	/// @addtogroup gtx_transform
 	/// @{
@@ -119,12 +118,9 @@ namespace transform ///< GLM_GTX_transform extension: Add transformation matrice
 		detail::tvec3<T> const & v);
 
 	/// @}
-}// namespace transform
 }// namespace gtx
 }// namespace glm
 
 #include "transform.inl"
 
-namespace glm{using namespace gtx::transform;}
-
 #endif//glm_gtx_transform

glm/gtx/transform.inl

@@ -8,8 +8,7 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 namespace glm{
-namespace gtx{
+namespace gtx
-namespace transform
 {
     template <typename T> 
     GLM_FUNC_QUALIFIER detail::tmat4x4<T> translate(
@@ -89,6 +88,5 @@ namespace transform
 			detail::tmat4x4<T>(1.0f), v);
     }
 
-}//namespace transform
 }//namespace gtx
 }//namespace glm

glm/gtx/transform2.hpp

@@ -23,12 +23,9 @@
 #endif
 
 namespace glm{
-namespace gtx{
+namespace gtx
-namespace transform2 ///< GLM_GTX_transform2 extension: Add extra transformation matrices
 {
-	using namespace gtx::transform;
+	/// @addtogroup gtx_transform2
-
-	/// \addtogroup gtx_transform2
 	/// @{
 
 	//! Transforms a matrix with a shearing on X axis.
@@ -107,12 +104,9 @@ namespace transform2 ///< GLM_GTX_transform2 extension: Add extra transformation
 		valType bias);
 
 	/// @}
-}// namespace transform2
 }// namespace gtx
 }// namespace glm
 
 #include "transform2.inl"
 
-namespace glm{using namespace gtx::transform2;}
-
 #endif//glm_gtx_transform2

glm/gtx/transform2.inl

@@ -9,8 +9,7 @@
 
 namespace glm{
 namespace gtx{
-namespace transform2
+
-{
     template <typename T> 
     GLM_FUNC_QUALIFIER detail::tmat3x3<T> shearX2D(
 		const detail::tmat3x3<T>& m, 
@@ -153,7 +152,6 @@ namespace transform2
 		return m * scaleBias(scale, bias);
 	}
 
-}//namespace transform2
 }//namespace gtx
 }//namespace glm
 

glm/gtx/ulp.hpp

@@ -21,10 +21,9 @@
 #endif
 
 namespace glm{
-namespace gtx{
+namespace gtx
-namespace ulp ///< GLM_GTX_ulp extension: Precision calculation functions
 {
-	/// \addtogroup gtx_ulp
+	/// @addtogroup gtx_ulp
 	/// @{
 
 	//! Return the next ULP value(s) after the input value(s).
@@ -58,13 +57,10 @@ namespace ulp ///< GLM_GTX_ulp extension: Precision calculation functions
     vecType<uint> float_distance(vecType<T> const & x, vecType<T> const & y);
         
 	///@}
-}// namespace ulp
 }// namespace gtx
 }// namespace glm
 
 #include "ulp.inl"
 
-namespace glm{using namespace gtx::ulp;}
-
 #endif//glm_gtx_ulp
 

glm/gtx/ulp.inl

@@ -178,8 +178,7 @@ namespace detail
 
 namespace glm{
 namespace gtx{
-namespace ulp
+
-{
     GLM_FUNC_QUALIFIER float next_float(float const & x)
     {
         return GLM_NEXT_AFTER_FLT(x, std::numeric_limits<float>::max());
@@ -391,6 +390,6 @@ namespace ulp
         return glm::max(glm::max(ulps[0], ulps[1]), glm::max(ulps[2], ulps[3]));
 	}
 */
-}//namespace ulp
+
 }//namespace gtx
 }//namespace glm

glm/gtx/unsigned_int.hpp

@@ -23,12 +23,9 @@
 #endif
 
 namespace glm{
-namespace gtx{
+namespace gtx
-namespace unsigned_int ///< GLM_GTX_unsigned_int extension: Add support for unsigned integer for core functions
 {
-	using namespace gtx::integer;
+	/// @addtogroup gtx_unsigned_int
-
-	/// \addtogroup gtx_unsigned_int
 	/// @{
 
 	//! 32bit signed integer. 
@@ -48,12 +45,9 @@ namespace unsigned_int ///< GLM_GTX_unsigned_int extension: Add support for unsi
 	uint mod(uint x, uint y);
 
 	/// @}
-}//namespace unsigned_int
 }//namespace gtx
 }//namespace glm
 
 #include "unsigned_int.inl"
 
-namespace glm{using namespace gtx::unsigned_int;}
-
 #endif//glm_gtx_unsigned_int

glm/gtx/unsigned_int.inl

@@ -9,7 +9,6 @@
 
 namespace glm{
 namespace gtx{
-namespace unsigned_int{
 
 GLM_FUNC_QUALIFIER uint pow(uint x, uint y)
 {
@@ -40,6 +39,5 @@ GLM_FUNC_QUALIFIER uint mod(uint x, uint y)
 	return x - y * (x / y);
 }
 
-}//namespace unsigned_int
 }//namespace gtx
 }//namespace glm

glm/gtx/vec1.hpp

@@ -22,9 +22,7 @@
 #endif
 
 namespace glm{
-namespace gtx{
+namespace gtx
-namespace vector1{ ///< GLM_GTX_vec1 extension: 1 component vector.
-namespace precision
 {
 	//! 1 component vector of high precision floating-point numbers. 
 	//! There is no guarantee on the actual precision.
@@ -64,7 +62,6 @@ namespace precision
 	//! There is no guarantee on the actual precision.
 	//! From GLM_GTX_vec1 extension.
 	typedef detail::lowp_uvec1_t			lowp_uvec1;
-}//namespace precision
 
 	//////////////////////////
 	// vec1 definition
@@ -74,48 +71,45 @@ namespace precision
 	typedef detail::tvec1<bool>	bvec1;
 
 #if(defined(GLM_PRECISION_HIGHP_FLOAT))
-	typedef precision::highp_vec1			vec1;
+	typedef highp_vec1			vec1;
 #elif(defined(GLM_PRECISION_MEDIUMP_FLOAT))
-	typedef precision::mediump_vec1			vec1;
+	typedef mediump_vec1			vec1;
 #elif(defined(GLM_PRECISION_LOWP_FLOAT))
-	typedef precision::lowp_vec1			vec1;
+	typedef lowp_vec1			vec1;
 #else
 	//! 1 component vector of floating-point numbers.
 	//! From GLM_GTX_vec1 extension.
-	typedef precision::mediump_vec1			vec1;
+	typedef mediump_vec1			vec1;
 #endif//GLM_PRECISION
 
 #if(defined(GLM_PRECISION_HIGHP_INT))
-	typedef precision::highp_ivec1			ivec1;
+	typedef highp_ivec1			ivec1;
 #elif(defined(GLM_PRECISION_MEDIUMP_INT))
-	typedef precision::mediump_ivec1		ivec1;
+	typedef mediump_ivec1		ivec1;
 #elif(defined(GLM_PRECISION_LOWP_INT))
-	typedef precision::lowp_ivec1			ivec1;
+	typedef lowp_ivec1			ivec1;
 #else
 	//! 1 component vector of signed integer numbers. 
 	//! From GLM_GTX_vec1 extension.
-	typedef precision::mediump_ivec1		ivec1;
+	typedef mediump_ivec1		ivec1;
 #endif//GLM_PRECISION
 
 #if(defined(GLM_PRECISION_HIGHP_UINT))
-	typedef precision::highp_uvec1			uvec1;
+	typedef highp_uvec1			uvec1;
 #elif(defined(GLM_PRECISION_MEDIUMP_UINT))
-	typedef precision::mediump_uvec1		uvec1;
+	typedef mediump_uvec1		uvec1;
 #elif(defined(GLM_PRECISION_LOWP_UINT))
-	typedef precision::lowp_uvec1			uvec1;
+	typedef lowp_uvec1			uvec1;
 #else
 	//! 1 component vector of unsigned integer numbers. 
 	//! From GLM_GTX_vec1 extension.
-	typedef precision::mediump_uvec1		uvec1;
+	typedef mediump_uvec1		uvec1;
 #endif//GLM_PRECISION
 
-}// namespace vec1
 }// namespace gtx
 }// namespace glm
 
 #include "vec1.inl"
 
-namespace glm{using namespace gtx::vector1;}
-
 #endif//glm_gtx_vec1
 

glm/gtx/vector_access.hpp

@@ -21,10 +21,9 @@
 #endif
 
 namespace glm{
-namespace gtx{
+namespace gtx
-namespace vector_access ///< GLM_GTX_vector_access extension: Function to set values to vectors
 {
-	/// \addtogroup gtx_vector_access
+	/// @addtogroup gtx_vector_access
 	/// @{
 
 	//! Set values to a 2 components vector.
@@ -55,12 +54,9 @@ namespace vector_access ///< GLM_GTX_vector_access extension: Function to set va
 		valType const & w);
 
 	/// @}
-}//namespace vector_access
 }//namespace gtx
 }//namespace glm
 
 #include "vector_access.inl"
 
-namespace glm{using namespace gtx::vector_access;}
-
 #endif//glm_gtx_vector_access

glm/gtx/vector_access.inl

@@ -9,7 +9,6 @@
 
 namespace glm{
 namespace gtx{
-namespace vector_access{
 
 template <typename valType> 
 GLM_FUNC_QUALIFIER void set
@@ -53,6 +52,5 @@ GLM_FUNC_QUALIFIER void set
     v.w = w;
 }
 
-}//namespace vector_access
 }//namespace gtx
 }//namespace glm

glm/gtx/vector_angle.hpp

@@ -26,13 +26,9 @@
 #endif
 
 namespace glm{
-namespace gtx{
+namespace gtx
-namespace vector_angle ///< GLM_GTX_vector_angle extension: Compute angle between vectors
 {
-	using namespace quaternion;
+	/// @addtogroup gtx_vector_angle
-	using namespace epsilon;
-
-	/// \addtogroup gtx_vector_angle
 	/// @{
 
 	//! Returns the absolute angle between two vectors
@@ -61,12 +57,9 @@ namespace vector_angle ///< GLM_GTX_vector_angle extension: Compute angle betwee
 		detail::tvec3<T> const & ref);
 
 	/// @}
-}// namespace vector_angle
 }// namespace gtx
 }// namespace glm
 
 #include "vector_angle.inl"
 
-namespace glm{using namespace gtx::vector_angle;}
-
 #endif//glm_gtx_vector_angle

glm/gtx/vector_angle.inl

@@ -9,7 +9,6 @@
 
 namespace glm{
 namespace gtx{
-namespace vector_angle{
 
 template <typename genType> 
 GLM_FUNC_QUALIFIER typename genType::value_type angle
@@ -30,7 +29,7 @@ GLM_FUNC_QUALIFIER valType orientedAngle
 )
 {
     valType Angle = glm::degrees(acos(dot(x, y)));
-	detail::tvec2<valType> TransformedVector = glm::gtx::rotate_vector::rotate(x, Angle);
+	detail::tvec2<valType> TransformedVector = glm::gtx::rotate(x, Angle);
     if(all(equalEpsilon(y, TransformedVector, valType(0.01))))
 		return Angle;
     else
@@ -53,6 +52,5 @@ GLM_FUNC_QUALIFIER valType orientedAngle
 		return Angle;
 }
 
-}//namespace vector_angle
 }//namespace gtx
 }//namespace glm

glm/gtx/vector_query.hpp

@@ -23,10 +23,9 @@
 #endif
 
 namespace glm{
-namespace gtx{
+namespace gtx
-namespace vector_query ///< GLM_GTX_vector_query extension: Query informations of vector types
 {
-	/// \addtogroup gtx_vector_query
+	/// @addtogroup gtx_vector_query
 	/// @{
 
 	//! Check if two vectors are collinears.
@@ -84,12 +83,9 @@ namespace vector_query ///< GLM_GTX_vector_query extension: Query informations o
 		typename genType::value_type const & epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
 
 	/// @}
-}// namespace vector_query
 }// namespace gtx
 }// namespace glm
 
 #include "vector_query.inl"
 
-namespace glm{using namespace gtx::vector_query;}
-
 #endif//glm_gtx_vector_query

glm/gtx/vector_query.inl

@@ -14,8 +14,7 @@
 
 namespace glm{
 namespace gtx{
-namespace vector_query
+
-{
 	template <typename T>
 	GLM_FUNC_QUALIFIER bool areCollinear
 	(
@@ -169,6 +168,5 @@ namespace vector_query
 		return similar;
 	}
 
-}//namespace vector_query
 }//namespace gtx
 }//namespace glm

glm/gtx/verbose_operator.hpp

@@ -21,10 +21,9 @@
 #endif
 
 namespace glm{
-namespace gtx{
+namespace gtx
-namespace verbose_operator ///< GLM_GTX_verbose_operator extension: Use words to replace operators
 {
-	/// \addtogroup gtx_verbose_operator
+	/// @addtogroup gtx_verbose_operator
 	/// @{
 
 	//! Addition of two values
@@ -53,12 +52,9 @@ namespace verbose_operator ///< GLM_GTX_verbose_operator extension: Use words to
 	genTypeT mad(genTypeT const & a, genTypeU const & b, genTypeV const & c);
 
 	/// @}
-}// namespace verbose_operator
 }// namespace gtx
 }// namespace glm
 
 #include "verbose_operator.inl"
 
-namespace glm{using namespace gtx::verbose_operator;}
-
 #endif//glm_gtx_verbose_operator

glm/gtx/verbose_operator.inl

@@ -9,7 +9,6 @@
 
 namespace glm{
 namespace gtx{
-namespace verbose_operator{
 
 template <typename genType>
 GLM_FUNC_QUALIFIER genType add(genType const & a, genType const & b)
@@ -124,6 +123,5 @@ GLM_FUNC_QUALIFIER genTypeT mad(genTypeT const & a, genTypeU const & b, genTypeV
 	return a * b + c;
 }
 
-}//namespace verbose_operator
 }//namespace gtx
 }//namespace glm

glm/gtx/wrap.hpp

@@ -21,10 +21,9 @@
 #endif
 
 namespace glm{
-namespace gtx{
+namespace gtx
-namespace wrap ///< GLM_GTX_wrap: Wrapping mode using my texture samping.
 {
-	/// \addtogroup gtx_wrap
+	/// @addtogroup gtx_wrap
 	/// @{
 
 	//! Simulate GL_CLAMP OpenGL wrap mode
@@ -43,12 +42,9 @@ namespace wrap ///< GLM_GTX_wrap: Wrapping mode using my texture samping.
 	genType mirrorRepeat(genType const & Texcoord);
 
 	/// @}
-}// namespace wrap
 }// namespace gtx
 }// namespace glm
 
 #include "wrap.inl"
 
-namespace glm{using namespace gtx::wrap;}
-
 #endif//glm_img_wrap

glm/gtx/wrap.inl

@@ -11,8 +11,7 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 namespace glm{
-namespace gtx{
+namespace gtx
-namespace wrap
 {
 	////////////////////////
 	// clamp
@@ -168,6 +167,5 @@ namespace wrap
 		return Result;
 	}
 
-}//namespace wrap
 }//namespace gtx
 }//namespace glm