- Moved template types from 'detail' to 'glm' namespace #239, #244

glm/detail/_noise.hpp

@@ -74,19 +74,19 @@ namespace detail
 	}
 	
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec2<T, P> taylorInvSqrt(detail::tvec2<T, P> const & r)
+	GLM_FUNC_QUALIFIER tvec2<T, P> taylorInvSqrt(tvec2<T, P> const & r)
 	{
 		return T(1.79284291400159) - T(0.85373472095314) * r;
 	}
 	
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec3<T, P> taylorInvSqrt(detail::tvec3<T, P> const & r)
+	GLM_FUNC_QUALIFIER tvec3<T, P> taylorInvSqrt(tvec3<T, P> const & r)
 	{
 		return T(1.79284291400159) - T(0.85373472095314) * r;
 	}
 	
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec4<T, P> taylorInvSqrt(detail::tvec4<T, P> const & r)
+	GLM_FUNC_QUALIFIER tvec4<T, P> taylorInvSqrt(tvec4<T, P> const & r)
 	{
 		return T(1.79284291400159) - T(0.85373472095314) * r;
 	}
@@ -99,19 +99,19 @@ namespace detail
 */
 	
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec2<T, P> fade(detail::tvec2<T, P> const & t)
+	GLM_FUNC_QUALIFIER tvec2<T, P> fade(tvec2<T, P> const & t)
 	{
 		return (t * t * t) * (t * (t * T(6) - T(15)) + T(10));
 	}
 	
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec3<T, P> fade(detail::tvec3<T, P> const & t)
+	GLM_FUNC_QUALIFIER tvec3<T, P> fade(tvec3<T, P> const & t)
 	{
 		return (t * t * t) * (t * (t * T(6) - T(15)) + T(10));
 	}
 	
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec4<T, P> fade(detail::tvec4<T, P> const & t)
+	GLM_FUNC_QUALIFIER tvec4<T, P> fade(tvec4<T, P> const & t)
 	{
 		return (t * t * t) * (t * (t * T(6) - T(15)) + T(10));
 	}

glm/detail/_vectorize.hpp

@@ -35,29 +35,29 @@
 
 #define VECTORIZE1_VEC(func)						\
 	template <typename T, precision P>				\
-	GLM_FUNC_QUALIFIER detail::tvec1<T, P> func(	\
-		detail::tvec1<T, P> const & v)				\
+	GLM_FUNC_QUALIFIER tvec1<T, P> func(	\
+		tvec1<T, P> const & v)				\
 	{												\
-		return detail::tvec1<T, P>(					\
+		return tvec1<T, P>(					\
 			func(v.x));								\
 	}
 
 #define VECTORIZE2_VEC(func)						\
 	template <typename T, precision P>				\
-	GLM_FUNC_QUALIFIER detail::tvec2<T, P> func(	\
-		detail::tvec2<T, P> const & v)				\
+	GLM_FUNC_QUALIFIER tvec2<T, P> func(	\
+		tvec2<T, P> const & v)				\
 	{												\
-		return detail::tvec2<T, P>(					\
+		return tvec2<T, P>(					\
 			func(v.x),								\
 			func(v.y));								\
 	}
 
 #define VECTORIZE3_VEC(func)						\
 	template <typename T, precision P>				\
-	GLM_FUNC_QUALIFIER detail::tvec3<T, P> func(	\
-		detail::tvec3<T, P> const & v)				\
+	GLM_FUNC_QUALIFIER tvec3<T, P> func(	\
+		tvec3<T, P> const & v)				\
 	{												\
-		return detail::tvec3<T, P>(					\
+		return tvec3<T, P>(					\
 			func(v.x),								\
 			func(v.y),								\
 			func(v.z));								\
@@ -65,10 +65,10 @@
 
 #define VECTORIZE4_VEC(func)						\
 	template <typename T, precision P>				\
-	GLM_FUNC_QUALIFIER detail::tvec4<T, P> func(	\
-		detail::tvec4<T, P> const & v)				\
+	GLM_FUNC_QUALIFIER tvec4<T, P> func(	\
+		tvec4<T, P> const & v)				\
 	{												\
-		return detail::tvec4<T, P>(					\
+		return tvec4<T, P>(					\
 			func(v.x),								\
 			func(v.y),								\
 			func(v.z),								\
@@ -83,38 +83,38 @@
 
 #define VECTORIZE1_VEC_SCA(func)							\
 	template <typename T, precision P>						\
-	GLM_FUNC_QUALIFIER detail::tvec1<T, P> func				\
+	GLM_FUNC_QUALIFIER tvec1<T, P> func				\
 	(														\
-		detail::tvec1<T, P> const & x,						\
-		typename detail::tvec1<T, P>::value_type const & y	\
+		tvec1<T, P> const & x,						\
+		typename tvec1<T, P>::value_type const & y	\
 	)														\
 	{														\
-		return detail::tvec1<T, P>(							\
+		return tvec1<T, P>(							\
 			func(x.x, y));									\
 	}
 
 #define VECTORIZE2_VEC_SCA(func)							\
 	template <typename T, precision P>						\
-	GLM_FUNC_QUALIFIER detail::tvec2<T, P> func				\
+	GLM_FUNC_QUALIFIER tvec2<T, P> func				\
 	(														\
-		detail::tvec2<T, P> const & x,						\
-		typename detail::tvec2<T, P>::value_type const & y	\
+		tvec2<T, P> const & x,						\
+		typename tvec2<T, P>::value_type const & y	\
 	)														\
 	{														\
-		return detail::tvec2<T, P>(							\
+		return tvec2<T, P>(							\
 			func(x.x, y),									\
 			func(x.y, y));									\
 	}
 
 #define VECTORIZE3_VEC_SCA(func)							\
 	template <typename T, precision P>						\
-	GLM_FUNC_QUALIFIER detail::tvec3<T, P> func				\
+	GLM_FUNC_QUALIFIER tvec3<T, P> func				\
 	(														\
-		detail::tvec3<T, P> const & x,						\
-		typename detail::tvec3<T, P>::value_type const & y	\
+		tvec3<T, P> const & x,						\
+		typename tvec3<T, P>::value_type const & y	\
 	)														\
 	{														\
-		return detail::tvec3<T, P>(							\
+		return tvec3<T, P>(							\
 			func(x.x, y),									\
 			func(x.y, y),									\
 			func(x.z, y));									\
@@ -122,13 +122,13 @@
 
 #define VECTORIZE4_VEC_SCA(func)							\
 	template <typename T, precision P>						\
-	GLM_FUNC_QUALIFIER detail::tvec4<T, P> func				\
+	GLM_FUNC_QUALIFIER tvec4<T, P> func				\
 	(														\
-		detail::tvec4<T, P> const & x,						\
-		typename detail::tvec4<T, P>::value_type const & y	\
+		tvec4<T, P> const & x,						\
+		typename tvec4<T, P>::value_type const & y	\
 	)														\
 	{														\
-		return detail::tvec4<T, P>(							\
+		return tvec4<T, P>(							\
 			func(x.x, y),									\
 			func(x.y, y),									\
 			func(x.z, y),									\
@@ -143,38 +143,38 @@
 
 #define VECTORIZE1_VEC_VEC(func)					\
 	template <typename T, precision P>				\
-	GLM_FUNC_QUALIFIER detail::tvec1<T, P> func		\
+	GLM_FUNC_QUALIFIER tvec1<T, P> func		\
 	(												\
-		detail::tvec1<T, P> const & x,				\
-		detail::tvec1<T, P> const & y				\
+		tvec1<T, P> const & x,				\
+		tvec1<T, P> const & y				\
 	)												\
 	{												\
-		return detail::tvec1<T, P>(					\
+		return tvec1<T, P>(					\
 			func(x.x, y.x));						\
 	}
 
 #define VECTORIZE2_VEC_VEC(func)					\
 	template <typename T, precision P>				\
-	GLM_FUNC_QUALIFIER detail::tvec2<T, P> func		\
+	GLM_FUNC_QUALIFIER tvec2<T, P> func		\
 	(												\
-		detail::tvec2<T, P> const & x,				\
-		detail::tvec2<T, P> const & y				\
+		tvec2<T, P> const & x,				\
+		tvec2<T, P> const & y				\
 	)												\
 	{												\
-		return detail::tvec2<T, P>(					\
+		return tvec2<T, P>(					\
 			func(x.x, y.x),							\
 			func(x.y, y.y));						\
 	}
 
 #define VECTORIZE3_VEC_VEC(func)					\
 	template <typename T, precision P>				\
-	GLM_FUNC_QUALIFIER detail::tvec3<T, P> func		\
+	GLM_FUNC_QUALIFIER tvec3<T, P> func		\
 	(												\
-		detail::tvec3<T, P> const & x,				\
-		detail::tvec3<T, P> const & y				\
+		tvec3<T, P> const & x,				\
+		tvec3<T, P> const & y				\
 	)												\
 	{												\
-		return detail::tvec3<T, P>(					\
+		return tvec3<T, P>(					\
 			func(x.x, y.x),							\
 			func(x.y, y.y),							\
 			func(x.z, y.z));						\
@@ -182,13 +182,13 @@
 
 #define VECTORIZE4_VEC_VEC(func)				\
 	template <typename T, precision P>			\
-	GLM_FUNC_QUALIFIER detail::tvec4<T, P> func	\
+	GLM_FUNC_QUALIFIER tvec4<T, P> func	\
 	(											\
-		detail::tvec4<T, P> const & x,			\
-		detail::tvec4<T, P> const & y			\
+		tvec4<T, P> const & x,			\
+		tvec4<T, P> const & y			\
 	)											\
 	{											\
-		return detail::tvec4<T, P>(				\
+		return tvec4<T, P>(				\
 			func(x.x, y.x),						\
 			func(x.y, y.y),						\
 			func(x.z, y.z),						\

glm/detail/func_common.inl

@@ -312,49 +312,49 @@ namespace detail
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec1<T, P> modf
+	GLM_FUNC_QUALIFIER tvec1<T, P> modf
 	(
-		detail::tvec1<T, P> const & x,
-		detail::tvec1<T, P> & i
+		tvec1<T, P> const & x,
+		tvec1<T, P> & i
 	)
 	{
-		return detail::tvec1<T, P>(
+		return tvec1<T, P>(
 			modf(x.x, i.x));
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec2<T, P> modf
+	GLM_FUNC_QUALIFIER tvec2<T, P> modf
 	(
-		detail::tvec2<T, P> const & x,
-		detail::tvec2<T, P> & i
+		tvec2<T, P> const & x,
+		tvec2<T, P> & i
 	)
 	{
-		return detail::tvec2<T, P>(
+		return tvec2<T, P>(
 			modf(x.x, i.x),
 			modf(x.y, i.y));
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec3<T, P> modf
+	GLM_FUNC_QUALIFIER tvec3<T, P> modf
 	(
-		detail::tvec3<T, P> const & x,
-		detail::tvec3<T, P> & i
+		tvec3<T, P> const & x,
+		tvec3<T, P> & i
 	)
 	{
-		return detail::tvec3<T, P>(
+		return tvec3<T, P>(
 			modf(x.x, i.x),
 			modf(x.y, i.y),
 			modf(x.z, i.z));
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec4<T, P> modf
+	GLM_FUNC_QUALIFIER tvec4<T, P> modf
 	(
-		detail::tvec4<T, P> const & x,
-		detail::tvec4<T, P> & i
+		tvec4<T, P> const & x,
+		tvec4<T, P> & i
 	)
 	{
-		return detail::tvec4<T, P>(
+		return tvec4<T, P>(
 			modf(x.x, i.x),
 			modf(x.y, i.y),
 			modf(x.z, i.z),
@@ -422,9 +422,9 @@ namespace detail
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec2<T, P> clamp
+	GLM_FUNC_QUALIFIER tvec2<T, P> clamp
 	(
-		detail::tvec2<T, P> const & x,
+		tvec2<T, P> const & x,
 		T const & minVal,
 		T const & maxVal
 	)
@@ -433,15 +433,15 @@ namespace detail
 			std::numeric_limits<T>::is_iec559 || std::numeric_limits<T>::is_integer,
 			"'clamp' only accept floating-point or integer inputs");
 
-		return detail::tvec2<T, P>(
+		return tvec2<T, P>(
 			clamp(x.x, minVal, maxVal),
 			clamp(x.y, minVal, maxVal));
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec3<T, P> clamp
+	GLM_FUNC_QUALIFIER tvec3<T, P> clamp
 	(
-		detail::tvec3<T, P> const & x,
+		tvec3<T, P> const & x,
 		T const & minVal,
 		T const & maxVal
 	)
@@ -450,16 +450,16 @@ namespace detail
 			std::numeric_limits<T>::is_iec559 || std::numeric_limits<T>::is_integer,
 			"'clamp' only accept floating-point or integer inputs");
 
-		return detail::tvec3<T, P>(
+		return tvec3<T, P>(
 			clamp(x.x, minVal, maxVal),
 			clamp(x.y, minVal, maxVal),
 			clamp(x.z, minVal, maxVal));
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec4<T, P> clamp
+	GLM_FUNC_QUALIFIER tvec4<T, P> clamp
 	(
-		detail::tvec4<T, P> const & x,
+		tvec4<T, P> const & x,
 		T const & minVal,
 		T const & maxVal
 	)
@@ -468,7 +468,7 @@ namespace detail
 			std::numeric_limits<T>::is_iec559 || std::numeric_limits<T>::is_integer,
 			"'clamp' only accept floating-point or integer inputs");
 
-		return detail::tvec4<T, P>(
+		return tvec4<T, P>(
 			clamp(x.x, minVal, maxVal),
 			clamp(x.y, minVal, maxVal),
 			clamp(x.z, minVal, maxVal),
@@ -476,53 +476,53 @@ namespace detail
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec2<T, P> clamp
+	GLM_FUNC_QUALIFIER tvec2<T, P> clamp
 	(
-		detail::tvec2<T, P> const & x,
-		detail::tvec2<T, P> const & minVal,
-		detail::tvec2<T, P> const & maxVal
+		tvec2<T, P> const & x,
+		tvec2<T, P> const & minVal,
+		tvec2<T, P> const & maxVal
 	)
 	{
 		GLM_STATIC_ASSERT(
 			std::numeric_limits<T>::is_iec559 || std::numeric_limits<T>::is_integer,
 			"'clamp' only accept floating-point or integer inputs");
 
-		return detail::tvec2<T, P>(
+		return tvec2<T, P>(
 			clamp(x.x, minVal.x, maxVal.x),
 			clamp(x.y, minVal.y, maxVal.y));
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec3<T, P> clamp
+	GLM_FUNC_QUALIFIER tvec3<T, P> clamp
 	(
-		detail::tvec3<T, P> const & x,
-		detail::tvec3<T, P> const & minVal,
-		detail::tvec3<T, P> const & maxVal
+		tvec3<T, P> const & x,
+		tvec3<T, P> const & minVal,
+		tvec3<T, P> const & maxVal
 	)
 	{
 		GLM_STATIC_ASSERT(
 			std::numeric_limits<T>::is_iec559 || std::numeric_limits<T>::is_integer,
 			"'clamp' only accept floating-point or integer inputs");
 
-		return detail::tvec3<T, P>(
+		return tvec3<T, P>(
 			clamp(x.x, minVal.x, maxVal.x),
 			clamp(x.y, minVal.y, maxVal.y),
 			clamp(x.z, minVal.z, maxVal.z));
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec4<T, P> clamp
+	GLM_FUNC_QUALIFIER tvec4<T, P> clamp
 	(
-		detail::tvec4<T, P> const & x,
-		detail::tvec4<T, P> const & minVal,
-		detail::tvec4<T, P> const & maxVal
+		tvec4<T, P> const & x,
+		tvec4<T, P> const & minVal,
+		tvec4<T, P> const & maxVal
 	)
 	{
 		GLM_STATIC_ASSERT(
 			std::numeric_limits<T>::is_iec559 || std::numeric_limits<T>::is_integer,
 			"'clamp' only accept floating-point or integer inputs");
 
-		return detail::tvec4<T, P>(
+		return tvec4<T, P>(
 			clamp(x.x, minVal.x, maxVal.x),
 			clamp(x.y, minVal.y, maxVal.y),
 			clamp(x.z, minVal.z, maxVal.z),
@@ -601,47 +601,47 @@ namespace detail
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec2<T, P> smoothstep
+	GLM_FUNC_QUALIFIER tvec2<T, P> smoothstep
 	(
 		T const & edge0,
 		T const & edge1,
-		detail::tvec2<T, P> const & x
+		tvec2<T, P> const & x
 	)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'smoothstep' only accept floating-point inputs");
 
-		return detail::tvec2<T, P>(
+		return tvec2<T, P>(
 			smoothstep(edge0, edge1, x.x),
 			smoothstep(edge0, edge1, x.y));
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec3<T, P> smoothstep
+	GLM_FUNC_QUALIFIER tvec3<T, P> smoothstep
 	(
 		T const & edge0,
 		T const & edge1,
-		detail::tvec3<T, P> const & x
+		tvec3<T, P> const & x
 	)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'smoothstep' only accept floating-point inputs");
 
-		return detail::tvec3<T, P>(
+		return tvec3<T, P>(
 			smoothstep(edge0, edge1, x.x),
 			smoothstep(edge0, edge1, x.y),
 			smoothstep(edge0, edge1, x.z));
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec4<T, P> smoothstep
+	GLM_FUNC_QUALIFIER tvec4<T, P> smoothstep
 	(
 		T const & edge0,
 		T const & edge1,
-		detail::tvec4<T, P> const & x
+		tvec4<T, P> const & x
 	)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'smoothstep' only accept floating-point inputs");
 
-		return detail::tvec4<T, P>(
+		return tvec4<T, P>(
 			smoothstep(edge0, edge1, x.x),
 			smoothstep(edge0, edge1, x.y),
 			smoothstep(edge0, edge1, x.z),
@@ -649,47 +649,47 @@ namespace detail
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec2<T, P> smoothstep
+	GLM_FUNC_QUALIFIER tvec2<T, P> smoothstep
 	(
-		detail::tvec2<T, P> const & edge0,
-		detail::tvec2<T, P> const & edge1,
-		detail::tvec2<T, P> const & x
+		tvec2<T, P> const & edge0,
+		tvec2<T, P> const & edge1,
+		tvec2<T, P> const & x
 	)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'smoothstep' only accept floating-point inputs");
 
-		return detail::tvec2<T, P>(
+		return tvec2<T, P>(
 			smoothstep(edge0.x, edge1.x, x.x),
 			smoothstep(edge0.y, edge1.y, x.y));
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec3<T, P> smoothstep
+	GLM_FUNC_QUALIFIER tvec3<T, P> smoothstep
 	(
-		detail::tvec3<T, P> const & edge0,
-		detail::tvec3<T, P> const & edge1,
-		detail::tvec3<T, P> const & x
+		tvec3<T, P> const & edge0,
+		tvec3<T, P> const & edge1,
+		tvec3<T, P> const & x
 	)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'smoothstep' only accept floating-point inputs");
 
-		return detail::tvec3<T, P>(
+		return tvec3<T, P>(
 			smoothstep(edge0.x, edge1.x, x.x),
 			smoothstep(edge0.y, edge1.y, x.y),
 			smoothstep(edge0.z, edge1.z, x.z));
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec4<T, P> smoothstep
+	GLM_FUNC_QUALIFIER tvec4<T, P> smoothstep
 	(
-		detail::tvec4<T, P> const & edge0,
-		detail::tvec4<T, P> const & edge1,
-		detail::tvec4<T, P> const & x
+		tvec4<T, P> const & edge0,
+		tvec4<T, P> const & edge1,
+		tvec4<T, P> const & x
 	)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'smoothstep' only accept floating-point inputs");
 
-		return detail::tvec4<T, P>(
+		return tvec4<T, P>(
 			smoothstep(edge0.x, edge1.x, x.x),
 			smoothstep(edge0.y, edge1.y, x.y),
 			smoothstep(edge0.z, edge1.z, x.z),
@@ -720,53 +720,53 @@ namespace detail
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER typename detail::tvec1<T, P>::bool_type isnan
+	GLM_FUNC_QUALIFIER typename tvec1<T, P>::bool_type isnan
 	(
-		detail::tvec1<T, P> const & x
+		tvec1<T, P> const & x
 	)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'isnan' only accept floating-point inputs");
 
-		return typename detail::tvec1<T, P>::bool_type(
+		return typename tvec1<T, P>::bool_type(
 			isnan(x.x));
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER typename detail::tvec2<T, P>::bool_type isnan
+	GLM_FUNC_QUALIFIER typename tvec2<T, P>::bool_type isnan
 	(
-		detail::tvec2<T, P> const & x
+		tvec2<T, P> const & x
 	)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'isnan' only accept floating-point inputs");
 
-		return typename detail::tvec2<T, P>::bool_type(
+		return typename tvec2<T, P>::bool_type(
 			isnan(x.x),
 			isnan(x.y));
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER typename detail::tvec3<T, P>::bool_type isnan
+	GLM_FUNC_QUALIFIER typename tvec3<T, P>::bool_type isnan
 	(
-		detail::tvec3<T, P> const & x
+		tvec3<T, P> const & x
 	)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'isnan' only accept floating-point inputs");
 
-		return typename detail::tvec3<T, P>::bool_type(
+		return typename tvec3<T, P>::bool_type(
 			isnan(x.x),
 			isnan(x.y),
 			isnan(x.z));
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER typename detail::tvec4<T, P>::bool_type isnan
+	GLM_FUNC_QUALIFIER typename tvec4<T, P>::bool_type isnan
 	(
-		detail::tvec4<T, P> const & x
+		tvec4<T, P> const & x
 	)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'isnan' only accept floating-point inputs");
 
-		return typename detail::tvec4<T, P>::bool_type(
+		return typename tvec4<T, P>::bool_type(
 			isnan(x.x),
 			isnan(x.y),
 			isnan(x.z),
@@ -798,53 +798,53 @@ namespace detail
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER typename detail::tvec1<T, P>::bool_type isinf
+	GLM_FUNC_QUALIFIER typename tvec1<T, P>::bool_type isinf
 	(
-		detail::tvec1<T, P> const & x
+		tvec1<T, P> const & x
 	)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'isinf' only accept floating-point inputs");
 
-		return typename detail::tvec1<T, P>::bool_type(
+		return typename tvec1<T, P>::bool_type(
 			isinf(x.x));
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER typename detail::tvec2<T, P>::bool_type isinf
+	GLM_FUNC_QUALIFIER typename tvec2<T, P>::bool_type isinf
 	(
-		detail::tvec2<T, P> const & x
+		tvec2<T, P> const & x
 	)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'isinf' only accept floating-point inputs");
 
-		return typename detail::tvec2<T, P>::bool_type(
+		return typename tvec2<T, P>::bool_type(
 			isinf(x.x),
 			isinf(x.y));
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER typename detail::tvec3<T, P>::bool_type isinf
+	GLM_FUNC_QUALIFIER typename tvec3<T, P>::bool_type isinf
 	(
-		detail::tvec3<T, P> const & x
+		tvec3<T, P> const & x
 	)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'isinf' only accept floating-point inputs");
 
-		return typename detail::tvec3<T, P>::bool_type(
+		return typename tvec3<T, P>::bool_type(
 			isinf(x.x),
 			isinf(x.y),
 			isinf(x.z));
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER typename detail::tvec4<T, P>::bool_type isinf
+	GLM_FUNC_QUALIFIER typename tvec4<T, P>::bool_type isinf
 	(
-		detail::tvec4<T, P> const & x
+		tvec4<T, P> const & x
 	)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'isinf' only accept floating-point inputs");
 
-		return typename detail::tvec4<T, P>::bool_type(
+		return typename tvec4<T, P>::bool_type(
 			isinf(x.x),
 			isinf(x.y),
 			isinf(x.z),
@@ -919,56 +919,56 @@ namespace detail
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec1<T, P> frexp
+	GLM_FUNC_QUALIFIER tvec1<T, P> frexp
 	(
-		detail::tvec1<T, P> const & x,
-		detail::tvec1<int, P> & exp
+		tvec1<T, P> const & x,
+		tvec1<int, P> & exp
 	)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'frexp' only accept floating-point inputs");
 
-		return detail::tvec1<T, P>(std::frexp(x.x, exp.x));
+		return tvec1<T, P>(std::frexp(x.x, exp.x));
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec2<T, P> frexp
+	GLM_FUNC_QUALIFIER tvec2<T, P> frexp
 	(
-		detail::tvec2<T, P> const & x,
-		detail::tvec2<int, P> & exp
+		tvec2<T, P> const & x,
+		tvec2<int, P> & exp
 	)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'frexp' only accept floating-point inputs");
 
-		return detail::tvec2<T, P>(
+		return tvec2<T, P>(
 			frexp(x.x, exp.x),
 			frexp(x.y, exp.y));
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec3<T, P> frexp
+	GLM_FUNC_QUALIFIER tvec3<T, P> frexp
 	(
-		detail::tvec3<T, P> const & x,
-		detail::tvec3<int, P> & exp
+		tvec3<T, P> const & x,
+		tvec3<int, P> & exp
 	)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'frexp' only accept floating-point inputs");
 
-		return detail::tvec3<T, P>(
+		return tvec3<T, P>(
 			frexp(x.x, exp.x),
 			frexp(x.y, exp.y),
 			frexp(x.z, exp.z));
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec4<T, P> frexp
+	GLM_FUNC_QUALIFIER tvec4<T, P> frexp
 	(
-		detail::tvec4<T, P> const & x,
-		detail::tvec4<int, P> & exp
+		tvec4<T, P> const & x,
+		tvec4<int, P> & exp
 	)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'frexp' only accept floating-point inputs");
 
-		return detail::tvec4<T, P>(
+		return tvec4<T, P>(
 			frexp(x.x, exp.x),
 			frexp(x.y, exp.y),
 			frexp(x.z, exp.z),
@@ -988,57 +988,57 @@ namespace detail
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec1<T, P> ldexp
+	GLM_FUNC_QUALIFIER tvec1<T, P> ldexp
 	(
-		detail::tvec1<T, P> const & x,
-		detail::tvec1<int, P> const & exp
+		tvec1<T, P> const & x,
+		tvec1<int, P> const & exp
 	)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'ldexp' only accept floating-point inputs");
 
-		return detail::tvec1<T, P>(
+		return tvec1<T, P>(
 			ldexp(x.x, exp.x));
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec2<T, P> ldexp
+	GLM_FUNC_QUALIFIER tvec2<T, P> ldexp
 	(
-		detail::tvec2<T, P> const & x,
-		detail::tvec2<int, P> const & exp
+		tvec2<T, P> const & x,
+		tvec2<int, P> const & exp
 	)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'ldexp' only accept floating-point inputs");
 
-		return detail::tvec2<T, P>(
+		return tvec2<T, P>(
 			ldexp(x.x, exp.x),
 			ldexp(x.y, exp.y));
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec3<T, P> ldexp
+	GLM_FUNC_QUALIFIER tvec3<T, P> ldexp
 	(
-		detail::tvec3<T, P> const & x,
-		detail::tvec3<int, P> const & exp
+		tvec3<T, P> const & x,
+		tvec3<int, P> const & exp
 	)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'ldexp' only accept floating-point inputs");
 
-		return detail::tvec3<T, P>(
+		return tvec3<T, P>(
 			ldexp(x.x, exp.x),
 			ldexp(x.y, exp.y),
 			ldexp(x.z, exp.z));
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec4<T, P> ldexp
+	GLM_FUNC_QUALIFIER tvec4<T, P> ldexp
 	(
-		detail::tvec4<T, P> const & x,
-		detail::tvec4<int, P> const & exp
+		tvec4<T, P> const & x,
+		tvec4<int, P> const & exp
 	)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'ldexp' only accept floating-point inputs");
 
-		return detail::tvec4<T, P>(
+		return tvec4<T, P>(
 			ldexp(x.x, exp.x),
 			ldexp(x.y, exp.y),
 			ldexp(x.z, exp.z),

glm/detail/func_exponential.inl

@@ -173,38 +173,38 @@ namespace detail
 		struct compute_sqrt{};
 		
 		template <typename T, precision P>
-		struct compute_sqrt<detail::tvec1, T, P>
+		struct compute_sqrt<tvec1, T, P>
 		{
-			GLM_FUNC_QUALIFIER static detail::tvec1<T, P> call(detail::tvec1<T, P> const & x)
+			GLM_FUNC_QUALIFIER static tvec1<T, P> call(tvec1<T, P> const & x)
 			{
-				return detail::tvec1<T, P>(std::sqrt(x.x));
+				return tvec1<T, P>(std::sqrt(x.x));
 			}
 		};
 		
 		template <typename T, precision P>
-		struct compute_sqrt<detail::tvec2, T, P>
+		struct compute_sqrt<tvec2, T, P>
 		{
-			GLM_FUNC_QUALIFIER static detail::tvec2<T, P> call(detail::tvec2<T, P> const & x)
+			GLM_FUNC_QUALIFIER static tvec2<T, P> call(tvec2<T, P> const & x)
 			{
-				return detail::tvec2<T, P>(std::sqrt(x.x), std::sqrt(x.y));
+				return tvec2<T, P>(std::sqrt(x.x), std::sqrt(x.y));
 			}
 		};
 		
 		template <typename T, precision P>
-		struct compute_sqrt<detail::tvec3, T, P>
+		struct compute_sqrt<tvec3, T, P>
 		{
-			GLM_FUNC_QUALIFIER static detail::tvec3<T, P> call(detail::tvec3<T, P> const & x)
+			GLM_FUNC_QUALIFIER static tvec3<T, P> call(tvec3<T, P> const & x)
 			{
-				return detail::tvec3<T, P>(std::sqrt(x.x), std::sqrt(x.y), std::sqrt(x.z));
+				return tvec3<T, P>(std::sqrt(x.x), std::sqrt(x.y), std::sqrt(x.z));
 			}
 		};
 		
 		template <typename T, precision P>
-		struct compute_sqrt<detail::tvec4, T, P>
+		struct compute_sqrt<tvec4, T, P>
 		{
-			GLM_FUNC_QUALIFIER static detail::tvec4<T, P> call(detail::tvec4<T, P> const & x)
+			GLM_FUNC_QUALIFIER static tvec4<T, P> call(tvec4<T, P> const & x)
 			{
-				return detail::tvec4<T, P>(std::sqrt(x.x), std::sqrt(x.y), std::sqrt(x.z), std::sqrt(x.w));
+				return tvec4<T, P>(std::sqrt(x.x), std::sqrt(x.y), std::sqrt(x.z), std::sqrt(x.w));
 			}
 		};
 	}//namespace detail
@@ -215,20 +215,20 @@ namespace detail
 	GLM_FUNC_QUALIFIER float sqrt(float x)
 	{
 #		ifdef __CUDACC__ // Wordaround for a CUDA compiler bug up to CUDA6
-			detail::tvec1<float, highp> tmp(detail::compute_sqrt<detail::tvec1, float, highp>::call(x));
+			tvec1<float, highp> tmp(detail::compute_sqrt<tvec1, float, highp>::call(x));
 			return tmp.x;
 #		else
-			return detail::compute_sqrt<detail::tvec1, float, highp>::call(x).x;
+			return detail::compute_sqrt<tvec1, float, highp>::call(x).x;
 #		endif
 	}
 
 	GLM_FUNC_QUALIFIER double sqrt(double x)
 	{
 #		ifdef __CUDACC__ // Wordaround for a CUDA compiler bug up to CUDA6
-			detail::tvec1<double, highp> tmp(detail::compute_sqrt<detail::tvec1, double, highp>::call(x));
+			tvec1<double, highp> tmp(detail::compute_sqrt<tvec1, double, highp>::call(x));
 			return tmp.x;
 #		else
-			return detail::compute_sqrt<detail::tvec1, double, highp>::call(x).x;
+			return detail::compute_sqrt<tvec1, double, highp>::call(x).x;
 #		endif
 	}
 */

glm/detail/func_geometric.hpp

@@ -92,9 +92,9 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/cross.xml">GLSL cross man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tvec3<T, P> cross(
-		detail::tvec3<T, P> const & x,
-		detail::tvec3<T, P> const & y);
+	GLM_FUNC_DECL tvec3<T, P> cross(
+		tvec3<T, P> const & x,
+		tvec3<T, P> const & y);
 
 	/// Returns a vector in the same direction as x but with length of 1.
 	/// 

glm/detail/func_geometric.inl

@@ -39,45 +39,45 @@ namespace detail
 	struct compute_dot{};
 
 	template <typename T, precision P>
-	struct compute_dot<detail::tvec1, T, P>
+	struct compute_dot<tvec1, T, P>
 	{
-		GLM_FUNC_QUALIFIER static T call(detail::tvec1<T, P> const & x, detail::tvec1<T, P> const & y)
+		GLM_FUNC_QUALIFIER static T call(tvec1<T, P> const & x, tvec1<T, P> const & y)
 		{
 #			ifdef __CUDACC__ // Wordaround for a CUDA compiler bug up to CUDA6
-				detail::tvec1<T, P> tmp(x * y);
+				tvec1<T, P> tmp(x * y);
 				return tmp.x;
 #			else
-				return detail::tvec1<T, P>(x * y).x;
+				return tvec1<T, P>(x * y).x;
 #			endif
 		}
 	};
 
 	template <typename T, precision P>
-	struct compute_dot<detail::tvec2, T, P>
+	struct compute_dot<tvec2, T, P>
 	{
-		GLM_FUNC_QUALIFIER static T call(detail::tvec2<T, P> const & x, detail::tvec2<T, P> const & y)
+		GLM_FUNC_QUALIFIER static T call(tvec2<T, P> const & x, tvec2<T, P> const & y)
 		{
-			detail::tvec2<T, P> tmp(x * y);
+			tvec2<T, P> tmp(x * y);
 			return tmp.x + tmp.y;
 		}
 	};
 
 	template <typename T, precision P>
-	struct compute_dot<detail::tvec3, T, P>
+	struct compute_dot<tvec3, T, P>
 	{
-		GLM_FUNC_QUALIFIER static T call(detail::tvec3<T, P> const & x, detail::tvec3<T, P> const & y)
+		GLM_FUNC_QUALIFIER static T call(tvec3<T, P> const & x, tvec3<T, P> const & y)
 		{
-			detail::tvec3<T, P> tmp(x * y);
+			tvec3<T, P> tmp(x * y);
 			return tmp.x + tmp.y + tmp.z;
 		}
 	};
 
 	template <typename T, precision P>
-	struct compute_dot<detail::tvec4, T, P>
+	struct compute_dot<tvec4, T, P>
 	{
-		GLM_FUNC_QUALIFIER static T call(detail::tvec4<T, P> const & x, detail::tvec4<T, P> const & y)
+		GLM_FUNC_QUALIFIER static T call(tvec4<T, P> const & x, tvec4<T, P> const & y)
 		{
-			detail::tvec4<T, P> tmp(x * y);
+			tvec4<T, P> tmp(x * y);
 			return (tmp.x + tmp.y) + (tmp.z + tmp.w);
 		}
 	};
@@ -96,7 +96,7 @@ namespace detail
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER T length(detail::tvec2<T, P> const & v)
+	GLM_FUNC_QUALIFIER T length(tvec2<T, P> const & v)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'length' only accept floating-point inputs");
 
@@ -105,7 +105,7 @@ namespace detail
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER T length(detail::tvec3<T, P> const & v)
+	GLM_FUNC_QUALIFIER T length(tvec3<T, P> const & v)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'length' only accept floating-point inputs");
 
@@ -114,7 +114,7 @@ namespace detail
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER T length(detail::tvec4<T, P> const & v)
+	GLM_FUNC_QUALIFIER T length(tvec4<T, P> const & v)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'length' only accept floating-point inputs");
 
@@ -138,8 +138,8 @@ namespace detail
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER T distance
 	(
-		detail::tvec2<T, P> const & p0,
-		detail::tvec2<T, P> const & p1
+		tvec2<T, P> const & p0,
+		tvec2<T, P> const & p1
 	)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'distance' only accept floating-point inputs");
@@ -150,8 +150,8 @@ namespace detail
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER T distance
 	(
-		detail::tvec3<T, P> const & p0,
-		detail::tvec3<T, P> const & p1
+		tvec3<T, P> const & p0,
+		tvec3<T, P> const & p1
 	)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'distance' only accept floating-point inputs");
@@ -162,8 +162,8 @@ namespace detail
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER T distance
 	(
-		detail::tvec4<T, P> const & p0,
-		detail::tvec4<T, P> const & p1
+		tvec4<T, P> const & p0,
+		tvec4<T, P> const & p1
 	)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'distance' only accept floating-point inputs");
@@ -180,7 +180,7 @@ namespace detail
 	)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'dot' only accept floating-point inputs");
-		return detail::compute_dot<detail::tvec1, T, highp>::call(x, y);
+		return detail::compute_dot<tvec1, T, highp>::call(x, y);
 	}
 
 	template <typename T, precision P, template <typename, precision> class vecType>
@@ -213,15 +213,15 @@ namespace detail
 */
 	// cross
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec3<T, P> cross
+	GLM_FUNC_QUALIFIER tvec3<T, P> cross
 	(
-		detail::tvec3<T, P> const & x,
-		detail::tvec3<T, P> const & y
+		tvec3<T, P> const & x,
+		tvec3<T, P> const & y
 	)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'cross' only accept floating-point inputs");
 
-		return detail::tvec3<T, P>(
+		return tvec3<T, P>(
 			x.y * y.z - y.y * x.z,
 			x.z * y.x - y.z * x.x,
 			x.x * y.y - y.x * x.y);
@@ -241,9 +241,9 @@ namespace detail
 
 	// According to issue 10 GLSL 1.10 specification, if length(x) == 0 then result is undefine and generate an error
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec2<T, P> normalize
+	GLM_FUNC_QUALIFIER tvec2<T, P> normalize
 	(
-		detail::tvec2<T, P> const & x
+		tvec2<T, P> const & x
 	)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'normalize' only accept floating-point inputs");
@@ -253,9 +253,9 @@ namespace detail
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec3<T, P> normalize
+	GLM_FUNC_QUALIFIER tvec3<T, P> normalize
 	(
-		detail::tvec3<T, P> const & x
+		tvec3<T, P> const & x
 	)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'normalize' only accept floating-point inputs");
@@ -265,9 +265,9 @@ namespace detail
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec4<T, P> normalize
+	GLM_FUNC_QUALIFIER tvec4<T, P> normalize
 	(
-		detail::tvec4<T, P> const & x
+		tvec4<T, P> const & x
 	)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'normalize' only accept floating-point inputs");

glm/detail/func_integer.inl

@@ -300,41 +300,41 @@ namespace glm
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec2<T, P> bitfieldExtract
+	GLM_FUNC_QUALIFIER tvec2<T, P> bitfieldExtract
 	(
-		detail::tvec2<T, P> const & Value,
+		tvec2<T, P> const & Value,
 		int const & Offset,
 		int const & Bits
 	)
 	{
-		return detail::tvec2<T, P>(
+		return tvec2<T, P>(
 			bitfieldExtract(Value[0], Offset, Bits),
 			bitfieldExtract(Value[1], Offset, Bits));
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec3<T, P> bitfieldExtract
+	GLM_FUNC_QUALIFIER tvec3<T, P> bitfieldExtract
 	(
-		detail::tvec3<T, P> const & Value,
+		tvec3<T, P> const & Value,
 		int const & Offset,
 		int const & Bits
 	)
 	{
-		return detail::tvec3<T, P>(
+		return tvec3<T, P>(
 			bitfieldExtract(Value[0], Offset, Bits),
 			bitfieldExtract(Value[1], Offset, Bits),
 			bitfieldExtract(Value[2], Offset, Bits));
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec4<T, P> bitfieldExtract
+	GLM_FUNC_QUALIFIER tvec4<T, P> bitfieldExtract
 	(
-		detail::tvec4<T, P> const & Value,
+		tvec4<T, P> const & Value,
 		int const & Offset,
 		int const & Bits
 	)
 	{
-		return detail::tvec4<T, P>(
+		return tvec4<T, P>(
 			bitfieldExtract(Value[0], Offset, Bits),
 			bitfieldExtract(Value[1], Offset, Bits),
 			bitfieldExtract(Value[2], Offset, Bits),
@@ -365,44 +365,44 @@ namespace glm
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec2<T, P> bitfieldInsert
+	GLM_FUNC_QUALIFIER tvec2<T, P> bitfieldInsert
 	(
-		detail::tvec2<T, P> const & Base,
-		detail::tvec2<T, P> const & Insert,
+		tvec2<T, P> const & Base,
+		tvec2<T, P> const & Insert,
 		int const & Offset,
 		int const & Bits
 	)
 	{
-		return detail::tvec2<T, P>(
+		return tvec2<T, P>(
 			bitfieldInsert(Base[0], Insert[0], Offset, Bits),
 			bitfieldInsert(Base[1], Insert[1], Offset, Bits));
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec3<T, P> bitfieldInsert
+	GLM_FUNC_QUALIFIER tvec3<T, P> bitfieldInsert
 	(
-		detail::tvec3<T, P> const & Base,
-		detail::tvec3<T, P> const & Insert,
+		tvec3<T, P> const & Base,
+		tvec3<T, P> const & Insert,
 		int const & Offset,
 		int const & Bits
 	)
 	{
-		return detail::tvec3<T, P>(
+		return tvec3<T, P>(
 			bitfieldInsert(Base[0], Insert[0], Offset, Bits),
 			bitfieldInsert(Base[1], Insert[1], Offset, Bits),
 			bitfieldInsert(Base[2], Insert[2], Offset, Bits));
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec4<T, P> bitfieldInsert
+	GLM_FUNC_QUALIFIER tvec4<T, P> bitfieldInsert
 	(
-		detail::tvec4<T, P> const & Base,
-		detail::tvec4<T, P> const & Insert,
+		tvec4<T, P> const & Base,
+		tvec4<T, P> const & Insert,
 		int const & Offset,
 		int const & Bits
 	)
 	{
-		return detail::tvec4<T, P>(
+		return tvec4<T, P>(
 			bitfieldInsert(Base[0], Insert[0], Offset, Bits),
 			bitfieldInsert(Base[1], Insert[1], Offset, Bits),
 			bitfieldInsert(Base[2], Insert[2], Offset, Bits),
@@ -441,35 +441,35 @@ namespace glm
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec2<int, P> bitCount
+	GLM_FUNC_QUALIFIER tvec2<int, P> bitCount
 	(
-		detail::tvec2<T, P> const & value
+		tvec2<T, P> const & value
 	)
 	{
-		return detail::tvec2<int, P>(
+		return tvec2<int, P>(
 			bitCount(value[0]),
 			bitCount(value[1]));
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec3<int, P> bitCount
+	GLM_FUNC_QUALIFIER tvec3<int, P> bitCount
 	(
-		detail::tvec3<T, P> const & value
+		tvec3<T, P> const & value
 	)
 	{
-		return detail::tvec3<int, P>(
+		return tvec3<int, P>(
 			bitCount(value[0]),
 			bitCount(value[1]),
 			bitCount(value[2]));
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec4<int, P> bitCount
+	GLM_FUNC_QUALIFIER tvec4<int, P> bitCount
 	(
-		detail::tvec4<T, P> const & value
+		tvec4<T, P> const & value
 	)
 	{
-		return detail::tvec4<int, P>(
+		return tvec4<int, P>(
 			bitCount(value[0]),
 			bitCount(value[1]),
 			bitCount(value[2]),
@@ -493,35 +493,35 @@ namespace glm
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec2<int, P> findLSB
+	GLM_FUNC_QUALIFIER tvec2<int, P> findLSB
 	(
-		detail::tvec2<T, P> const & value
+		tvec2<T, P> const & value
 	)
 	{
-		return detail::tvec2<int, P>(
+		return tvec2<int, P>(
 			findLSB(value[0]),
 			findLSB(value[1]));
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec3<int, P> findLSB
+	GLM_FUNC_QUALIFIER tvec3<int, P> findLSB
 	(
-		detail::tvec3<T, P> const & value
+		tvec3<T, P> const & value
 	)
 	{
-		return detail::tvec3<int, P>(
+		return tvec3<int, P>(
 			findLSB(value[0]),
 			findLSB(value[1]),
 			findLSB(value[2]));
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec4<int, P> findLSB
+	GLM_FUNC_QUALIFIER tvec4<int, P> findLSB
 	(
-		detail::tvec4<T, P> const & value
+		tvec4<T, P> const & value
 	)
 	{
-		return detail::tvec4<int, P>(
+		return tvec4<int, P>(
 			findLSB(value[0]),
 			findLSB(value[1]),
 			findLSB(value[2]),
@@ -617,35 +617,35 @@ namespace glm
 #endif//(GLM_COMPILER)
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec2<int, P> findMSB
+	GLM_FUNC_QUALIFIER tvec2<int, P> findMSB
 	(
-		detail::tvec2<T, P> const & value
+		tvec2<T, P> const & value
 	)
 	{
-		return detail::tvec2<int, P>(
+		return tvec2<int, P>(
 			findMSB(value[0]),
 			findMSB(value[1]));
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec3<int, P> findMSB
+	GLM_FUNC_QUALIFIER tvec3<int, P> findMSB
 	(
-		detail::tvec3<T, P> const & value
+		tvec3<T, P> const & value
 	)
 	{
-		return detail::tvec3<int, P>(
+		return tvec3<int, P>(
 			findMSB(value[0]),
 			findMSB(value[1]),
 			findMSB(value[2]));
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec4<int, P> findMSB
+	GLM_FUNC_QUALIFIER tvec4<int, P> findMSB
 	(
-		detail::tvec4<T, P> const & value
+		tvec4<T, P> const & value
 	)
 	{
-		return detail::tvec4<int, P>(
+		return tvec4<int, P>(
 			findMSB(value[0]),
 			findMSB(value[1]),
 			findMSB(value[2]),

glm/detail/func_matrix.inl

@@ -41,11 +41,11 @@ namespace detail
 	struct compute_outerProduct{};
 
 	template <typename T, precision P>
-	struct compute_outerProduct<detail::tvec2, detail::tvec2, T, P>
+	struct compute_outerProduct<tvec2, tvec2, T, P>
 	{
-		GLM_FUNC_QUALIFIER static typename detail::outerProduct_trait<T, P, detail::tvec2, detail::tvec2>::type call(detail::tvec2<T, P> const & c, detail::tvec2<T, P> const & r)
+		GLM_FUNC_QUALIFIER static typename detail::outerProduct_trait<T, P, tvec2, tvec2>::type call(tvec2<T, P> const & c, tvec2<T, P> const & r)
 		{
-			detail::tmat2x2<T, P> m(detail::tmat2x2<T, P>::_null);
+			tmat2x2<T, P> m(tmat2x2<T, P>::_null);
 			m[0][0] = c[0] * r[0];
 			m[0][1] = c[1] * r[0];
 			m[1][0] = c[0] * r[1];
@@ -55,11 +55,11 @@ namespace detail
 	};
 
 	template <typename T, precision P>
-	struct compute_outerProduct<detail::tvec3, detail::tvec3, T, P>
+	struct compute_outerProduct<tvec3, tvec3, T, P>
 	{
-		GLM_FUNC_QUALIFIER static typename detail::outerProduct_trait<T, P, detail::tvec3, detail::tvec3>::type call(detail::tvec3<T, P> const & c, detail::tvec3<T, P> const & r)
+		GLM_FUNC_QUALIFIER static typename detail::outerProduct_trait<T, P, tvec3, tvec3>::type call(tvec3<T, P> const & c, tvec3<T, P> const & r)
 		{
-			detail::tmat3x3<T, P> m(detail::tmat3x3<T, P>::_null);
+			tmat3x3<T, P> m(tmat3x3<T, P>::_null);
 			for(length_t i(0); i < m.length(); ++i)
 				m[i] = c * r[i];
 			return m;
@@ -67,11 +67,11 @@ namespace detail
 	};
 
 	template <typename T, precision P>
-	struct compute_outerProduct<detail::tvec4, detail::tvec4, T, P>
+	struct compute_outerProduct<tvec4, tvec4, T, P>
 	{
-		GLM_FUNC_QUALIFIER static typename detail::outerProduct_trait<T, P, detail::tvec4, detail::tvec4>::type call(detail::tvec4<T, P> const & c, detail::tvec4<T, P> const & r)
+		GLM_FUNC_QUALIFIER static typename detail::outerProduct_trait<T, P, tvec4, tvec4>::type call(tvec4<T, P> const & c, tvec4<T, P> const & r)
 		{
-			detail::tmat4x4<T, P> m(detail::tmat4x4<T, P>::_null);
+			tmat4x4<T, P> m(tmat4x4<T, P>::_null);
 			for(length_t i(0); i < m.length(); ++i)
 				m[i] = c * r[i];
 			return m;
@@ -79,11 +79,11 @@ namespace detail
 	};
 
 	template <typename T, precision P>
-	struct compute_outerProduct<detail::tvec3, detail::tvec2, T, P>
+	struct compute_outerProduct<tvec3, tvec2, T, P>
 	{
-		GLM_FUNC_QUALIFIER static typename detail::outerProduct_trait<T, P, detail::tvec3, detail::tvec2>::type call(detail::tvec3<T, P> const & c, detail::tvec2<T, P> const & r)
+		GLM_FUNC_QUALIFIER static typename detail::outerProduct_trait<T, P, tvec3, tvec2>::type call(tvec3<T, P> const & c, tvec2<T, P> const & r)
 		{
-			detail::tmat2x3<T, P> m(detail::tmat2x3<T, P>::_null);
+			tmat2x3<T, P> m(tmat2x3<T, P>::_null);
 			m[0][0] = c.x * r.x;
 			m[0][1] = c.y * r.x;
 			m[0][2] = c.z * r.x;
@@ -95,11 +95,11 @@ namespace detail
 	};
 
 	template <typename T, precision P>
-	struct compute_outerProduct<detail::tvec2, detail::tvec3, T, P>
+	struct compute_outerProduct<tvec2, tvec3, T, P>
 	{
-		GLM_FUNC_QUALIFIER static typename detail::outerProduct_trait<T, P, detail::tvec2, detail::tvec3>::type call(detail::tvec2<T, P> const & c, detail::tvec3<T, P> const & r)
+		GLM_FUNC_QUALIFIER static typename detail::outerProduct_trait<T, P, tvec2, tvec3>::type call(tvec2<T, P> const & c, tvec3<T, P> const & r)
 		{
-			detail::tmat3x2<T, P> m(detail::tmat3x2<T, P>::_null);
+			tmat3x2<T, P> m(tmat3x2<T, P>::_null);
 			m[0][0] = c.x * r.x;
 			m[0][1] = c.y * r.x;
 			m[1][0] = c.x * r.y;
@@ -111,11 +111,11 @@ namespace detail
 	};
 
 	template <typename T, precision P>
-	struct compute_outerProduct<detail::tvec4, detail::tvec2, T, P>
+	struct compute_outerProduct<tvec4, tvec2, T, P>
 	{
-		GLM_FUNC_QUALIFIER static typename detail::outerProduct_trait<T, P, detail::tvec4, detail::tvec2>::type call(detail::tvec4<T, P> const & c, detail::tvec2<T, P> const & r)
+		GLM_FUNC_QUALIFIER static typename detail::outerProduct_trait<T, P, tvec4, tvec2>::type call(tvec4<T, P> const & c, tvec2<T, P> const & r)
 		{
-			detail::tmat2x4<T, P> m(detail::tmat2x4<T, P>::_null);
+			tmat2x4<T, P> m(tmat2x4<T, P>::_null);
 			m[0][0] = c.x * r.x;
 			m[0][1] = c.y * r.x;
 			m[0][2] = c.z * r.x;
@@ -129,11 +129,11 @@ namespace detail
 	};
 
 	template <typename T, precision P>
-	struct compute_outerProduct<detail::tvec2, detail::tvec4, T, P>
+	struct compute_outerProduct<tvec2, tvec4, T, P>
 	{
-		GLM_FUNC_QUALIFIER static typename detail::outerProduct_trait<T, P, detail::tvec2, detail::tvec4>::type call(detail::tvec2<T, P> const & c, detail::tvec4<T, P> const & r)
+		GLM_FUNC_QUALIFIER static typename detail::outerProduct_trait<T, P, tvec2, tvec4>::type call(tvec2<T, P> const & c, tvec4<T, P> const & r)
 		{
-			detail::tmat4x2<T, P> m(detail::tmat4x2<T, P>::_null);
+			tmat4x2<T, P> m(tmat4x2<T, P>::_null);
 			m[0][0] = c.x * r.x;
 			m[0][1] = c.y * r.x;
 			m[1][0] = c.x * r.y;
@@ -147,11 +147,11 @@ namespace detail
 	};
 
 	template <typename T, precision P>
-	struct compute_outerProduct<detail::tvec4, detail::tvec3, T, P>
+	struct compute_outerProduct<tvec4, tvec3, T, P>
 	{
-		GLM_FUNC_QUALIFIER static typename detail::outerProduct_trait<T, P, detail::tvec4, detail::tvec3>::type call(detail::tvec4<T, P> const & c, detail::tvec3<T, P> const & r)
+		GLM_FUNC_QUALIFIER static typename detail::outerProduct_trait<T, P, tvec4, tvec3>::type call(tvec4<T, P> const & c, tvec3<T, P> const & r)
 		{
-			detail::tmat3x4<T, P> m(detail::tmat3x4<T, P>::_null);
+			tmat3x4<T, P> m(tmat3x4<T, P>::_null);
 			m[0][0] = c.x * r.x;
 			m[0][1] = c.y * r.x;
 			m[0][2] = c.z * r.x;
@@ -169,11 +169,11 @@ namespace detail
 	};
 
 	template <typename T, precision P>
-	struct compute_outerProduct<detail::tvec3, detail::tvec4, T, P>
+	struct compute_outerProduct<tvec3, tvec4, T, P>
 	{
-		GLM_FUNC_QUALIFIER static typename detail::outerProduct_trait<T, P, detail::tvec3, detail::tvec4>::type call(detail::tvec3<T, P> const & c, detail::tvec4<T, P> const & r)
+		GLM_FUNC_QUALIFIER static typename detail::outerProduct_trait<T, P, tvec3, tvec4>::type call(tvec3<T, P> const & c, tvec4<T, P> const & r)
 		{
-			detail::tmat4x3<T, P> m(detail::tmat4x3<T, P>::_null);
+			tmat4x3<T, P> m(tmat4x3<T, P>::_null);
 			m[0][0] = c.x * r.x;
 			m[0][1] = c.y * r.x;
 			m[0][2] = c.z * r.x;
@@ -194,11 +194,11 @@ namespace detail
 	struct compute_transpose{};
 
 	template <typename T, precision P>
-	struct compute_transpose<detail::tmat2x2, T, P>
+	struct compute_transpose<tmat2x2, T, P>
 	{
-		GLM_FUNC_QUALIFIER static detail::tmat2x2<T, P> call(detail::tmat2x2<T, P> const & m)
+		GLM_FUNC_QUALIFIER static tmat2x2<T, P> call(tmat2x2<T, P> const & m)
 		{
-			detail::tmat2x2<T, P> result(detail::tmat2x2<T, P>::_null);
+			tmat2x2<T, P> result(tmat2x2<T, P>::_null);
 			result[0][0] = m[0][0];
 			result[0][1] = m[1][0];
 			result[1][0] = m[0][1];
@@ -208,11 +208,11 @@ namespace detail
 	};
 
 	template <typename T, precision P>
-	struct compute_transpose<detail::tmat2x3, T, P>
+	struct compute_transpose<tmat2x3, T, P>
 	{
-		GLM_FUNC_QUALIFIER static detail::tmat3x2<T, P> call(detail::tmat2x3<T, P> const & m)
+		GLM_FUNC_QUALIFIER static tmat3x2<T, P> call(tmat2x3<T, P> const & m)
 		{
-			detail::tmat3x2<T, P> result(detail::tmat3x2<T, P>::_null);
+			tmat3x2<T, P> result(tmat3x2<T, P>::_null);
 			result[0][0] = m[0][0];
 			result[0][1] = m[1][0];
 			result[1][0] = m[0][1];
@@ -224,11 +224,11 @@ namespace detail
 	};
 
 	template <typename T, precision P>
-	struct compute_transpose<detail::tmat2x4, T, P>
+	struct compute_transpose<tmat2x4, T, P>
 	{
-		GLM_FUNC_QUALIFIER static detail::tmat4x2<T, P> call(detail::tmat2x4<T, P> const & m)
+		GLM_FUNC_QUALIFIER static tmat4x2<T, P> call(tmat2x4<T, P> const & m)
 		{
-			detail::tmat4x2<T, P> result(detail::tmat4x2<T, P>::_null);
+			tmat4x2<T, P> result(tmat4x2<T, P>::_null);
 			result[0][0] = m[0][0];
 			result[0][1] = m[1][0];
 			result[1][0] = m[0][1];
@@ -242,11 +242,11 @@ namespace detail
 	};
 
 	template <typename T, precision P>
-	struct compute_transpose<detail::tmat3x2, T, P>
+	struct compute_transpose<tmat3x2, T, P>
 	{
-		GLM_FUNC_QUALIFIER static detail::tmat2x3<T, P> call(detail::tmat3x2<T, P> const & m)
+		GLM_FUNC_QUALIFIER static tmat2x3<T, P> call(tmat3x2<T, P> const & m)
 		{
-			detail::tmat2x3<T, P> result(detail::tmat2x3<T, P>::_null);
+			tmat2x3<T, P> result(tmat2x3<T, P>::_null);
 			result[0][0] = m[0][0];
 			result[0][1] = m[1][0];
 			result[0][2] = m[2][0];
@@ -258,11 +258,11 @@ namespace detail
 	};
 
 	template <typename T, precision P>
-	struct compute_transpose<detail::tmat3x3, T, P>
+	struct compute_transpose<tmat3x3, T, P>
 	{
-		GLM_FUNC_QUALIFIER static detail::tmat3x3<T, P> call(detail::tmat3x3<T, P> const & m)
+		GLM_FUNC_QUALIFIER static tmat3x3<T, P> call(tmat3x3<T, P> const & m)
 		{
-			detail::tmat3x3<T, P> result(detail::tmat3x3<T, P>::_null);
+			tmat3x3<T, P> result(tmat3x3<T, P>::_null);
 			result[0][0] = m[0][0];
 			result[0][1] = m[1][0];
 			result[0][2] = m[2][0];
@@ -279,11 +279,11 @@ namespace detail
 	};
 
 	template <typename T, precision P>
-	struct compute_transpose<detail::tmat3x4, T, P>
+	struct compute_transpose<tmat3x4, T, P>
 	{
-		GLM_FUNC_QUALIFIER static detail::tmat4x3<T, P> call(detail::tmat3x4<T, P> const & m)
+		GLM_FUNC_QUALIFIER static tmat4x3<T, P> call(tmat3x4<T, P> const & m)
 		{
-			detail::tmat4x3<T, P> result(detail::tmat4x3<T, P>::_null);
+			tmat4x3<T, P> result(tmat4x3<T, P>::_null);
 			result[0][0] = m[0][0];
 			result[0][1] = m[1][0];
 			result[0][2] = m[2][0];
@@ -301,11 +301,11 @@ namespace detail
 	};
 
 	template <typename T, precision P>
-	struct compute_transpose<detail::tmat4x2, T, P>
+	struct compute_transpose<tmat4x2, T, P>
 	{
-		GLM_FUNC_QUALIFIER static detail::tmat2x4<T, P> call(detail::tmat4x2<T, P> const & m)
+		GLM_FUNC_QUALIFIER static tmat2x4<T, P> call(tmat4x2<T, P> const & m)
 		{
-			detail::tmat2x4<T, P> result(detail::tmat2x4<T, P>::_null);
+			tmat2x4<T, P> result(tmat2x4<T, P>::_null);
 			result[0][0] = m[0][0];
 			result[0][1] = m[1][0];
 			result[0][2] = m[2][0];
@@ -319,11 +319,11 @@ namespace detail
 	};
 
 	template <typename T, precision P>
-	struct compute_transpose<detail::tmat4x3, T, P>
+	struct compute_transpose<tmat4x3, T, P>
 	{
-		GLM_FUNC_QUALIFIER static detail::tmat3x4<T, P> call(detail::tmat4x3<T, P> const & m)
+		GLM_FUNC_QUALIFIER static tmat3x4<T, P> call(tmat4x3<T, P> const & m)
 		{
-			detail::tmat3x4<T, P> result(detail::tmat3x4<T, P>::_null);
+			tmat3x4<T, P> result(tmat3x4<T, P>::_null);
 			result[0][0] = m[0][0];
 			result[0][1] = m[1][0];
 			result[0][2] = m[2][0];
@@ -341,11 +341,11 @@ namespace detail
 	};
 
 	template <typename T, precision P>
-	struct compute_transpose<detail::tmat4x4, T, P>
+	struct compute_transpose<tmat4x4, T, P>
 	{
-		GLM_FUNC_QUALIFIER static detail::tmat4x4<T, P> call(detail::tmat4x4<T, P> const & m)
+		GLM_FUNC_QUALIFIER static tmat4x4<T, P> call(tmat4x4<T, P> const & m)
 		{
-			detail::tmat4x4<T, P> result(detail::tmat4x4<T, P>::_null);
+			tmat4x4<T, P> result(tmat4x4<T, P>::_null);
 			result[0][0] = m[0][0];
 			result[0][1] = m[1][0];
 			result[0][2] = m[2][0];
@@ -373,18 +373,18 @@ namespace detail
 	struct compute_determinant{};
 
 	template <typename T, precision P>
-	struct compute_determinant<detail::tmat2x2, T, P>
+	struct compute_determinant<tmat2x2, T, P>
 	{
-		GLM_FUNC_QUALIFIER static T call(detail::tmat2x2<T, P> const & m)
+		GLM_FUNC_QUALIFIER static T call(tmat2x2<T, P> const & m)
 		{
 			return m[0][0] * m[1][1] - m[1][0] * m[0][1];
 		}
 	};
 
 	template <typename T, precision P>
-	struct compute_determinant<detail::tmat3x3, T, P>
+	struct compute_determinant<tmat3x3, T, P>
 	{
-		GLM_FUNC_QUALIFIER static T call(detail::tmat3x3<T, P> const & m)
+		GLM_FUNC_QUALIFIER static T call(tmat3x3<T, P> const & m)
 		{
 			return
 				+ m[0][0] * (m[1][1] * m[2][2] - m[2][1] * m[1][2])
@@ -394,9 +394,9 @@ namespace detail
 	};
 
 	template <typename T, precision P>
-	struct compute_determinant<detail::tmat4x4, T, P>
+	struct compute_determinant<tmat4x4, T, P>
 	{
-		GLM_FUNC_QUALIFIER static T call(detail::tmat4x4<T, P> const & m)
+		GLM_FUNC_QUALIFIER static T call(tmat4x4<T, P> const & m)
 		{
 			T SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
 			T SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
@@ -405,7 +405,7 @@ namespace detail
 			T SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
 			T SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
 
-			detail::tvec4<T, P> DetCof(
+			tvec4<T, P> DetCof(
 				+ (m[1][1] * SubFactor00 - m[1][2] * SubFactor01 + m[1][3] * SubFactor02),
 				- (m[1][0] * SubFactor00 - m[1][2] * SubFactor03 + m[1][3] * SubFactor04),
 				+ (m[1][0] * SubFactor01 - m[1][1] * SubFactor03 + m[1][3] * SubFactor05),
@@ -454,7 +454,7 @@ namespace detail
 	GLM_FUNC_QUALIFIER matType<T, P> inverse(matType<T, P> const & m)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'inverse' only accept floating-point inputs");
-		return detail::compute_inverse<matType, T, P>::call(m);
+		return detail::compute_inverse(m);
 	}
 
 }//namespace glm

glm/detail/func_noise.hpp

@@ -63,7 +63,7 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/noise2.xml">GLSL noise2 man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.13 Noise Functions</a>
 	template <typename genType>
-	GLM_FUNC_DECL detail::tvec2<typename genType::value_type, defaultp> noise2(genType const & x);
+	GLM_FUNC_DECL tvec2<typename genType::value_type, defaultp> noise2(genType const & x);
 
 	/// Returns a 3D noise value based on the input value x.
 	///
@@ -72,7 +72,7 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/noise3.xml">GLSL noise3 man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.13 Noise Functions</a>
 	template <typename genType>
-	GLM_FUNC_DECL detail::tvec3<typename genType::value_type, defaultp> noise3(genType const & x);
+	GLM_FUNC_DECL tvec3<typename genType::value_type, defaultp> noise3(genType const & x);
 
 	/// Returns a 4D noise value based on the input value x.
 	///
@@ -81,7 +81,7 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/noise4.xml">GLSL noise4 man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.13 Noise Functions</a>
 	template <typename genType>
-	GLM_FUNC_DECL detail::tvec4<typename genType::value_type, defaultp> noise4(genType const & x);
+	GLM_FUNC_DECL tvec4<typename genType::value_type, defaultp> noise4(genType const & x);
 
 	/// @}
 }//namespace glm

glm/detail/func_noise.inl

@@ -33,43 +33,43 @@ namespace glm{
 namespace detail
 {
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec4<T, P> grad4(T const & j, detail::tvec4<T, P> const & ip)
+	GLM_FUNC_QUALIFIER tvec4<T, P> grad4(T const & j, tvec4<T, P> const & ip)
 	{
-		detail::tvec3<T, P> pXYZ = floor(fract(detail::tvec3<T, P>(j) * detail::tvec3<T, P>(ip)) * T(7)) * ip[2] - T(1);
-		T pW = static_cast<T>(1.5) - dot(abs(pXYZ), detail::tvec3<T, P>(1));
-		detail::tvec4<T, P> s = detail::tvec4<T, P>(lessThan(detail::tvec4<T, P>(pXYZ, pW), detail::tvec4<T, P>(0.0)));
-		pXYZ = pXYZ + (detail::tvec3<T, P>(s) * T(2) - T(1)) * s.w; 
-		return detail::tvec4<T, P>(pXYZ, pW);
+		tvec3<T, P> pXYZ = floor(fract(tvec3<T, P>(j) * tvec3<T, P>(ip)) * T(7)) * ip[2] - T(1);
+		T pW = static_cast<T>(1.5) - dot(abs(pXYZ), tvec3<T, P>(1));
+		tvec4<T, P> s = tvec4<T, P>(lessThan(tvec4<T, P>(pXYZ, pW), tvec4<T, P>(0.0)));
+		pXYZ = pXYZ + (tvec3<T, P>(s) * T(2) - T(1)) * s.w; 
+		return tvec4<T, P>(pXYZ, pW);
 	}
 }//namespace detail
 
 	template <typename T>
 	GLM_FUNC_QUALIFIER T noise1(T const & x)
 	{
-		return noise1(detail::tvec2<T, defaultp>(x, T(0)));
+		return noise1(tvec2<T, defaultp>(x, T(0)));
 	}
 
 	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec2<T, defaultp> noise2(T const & x)
+	GLM_FUNC_QUALIFIER tvec2<T, defaultp> noise2(T const & x)
 	{
-		return detail::tvec2<T, defaultp>(
+		return tvec2<T, defaultp>(
 			noise1(x + T(0.0)),
 			noise1(x + T(1.0)));
 	}
 
 	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec3<T, defaultp> noise3(T const & x)
+	GLM_FUNC_QUALIFIER tvec3<T, defaultp> noise3(T const & x)
 	{
-		return detail::tvec3<T, defaultp>(
+		return tvec3<T, defaultp>(
 			noise1(x - T(1.0)),
 			noise1(x + T(0.0)),
 			noise1(x + T(1.0)));
 	}
 
 	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec4<T, defaultp> noise4(T const & x)
+	GLM_FUNC_QUALIFIER tvec4<T, defaultp> noise4(T const & x)
 	{
-		return detail::tvec4<T, defaultp>(
+		return tvec4<T, defaultp>(
 			noise1(x - T(1.0)),
 			noise1(x + T(0.0)),
 			noise1(x + T(1.0)),
@@ -77,38 +77,38 @@ namespace detail
 	}
 	
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER T noise1(detail::tvec2<T, P> const & v)
+	GLM_FUNC_QUALIFIER T noise1(tvec2<T, P> const & v)
 	{
-		detail::tvec4<T, P> const C = detail::tvec4<T, P>(
+		tvec4<T, P> const C = tvec4<T, P>(
 			T( 0.211324865405187),		// (3.0 -  sqrt(3.0)) / 6.0
 			T( 0.366025403784439),		//  0.5 * (sqrt(3.0)  - 1.0)
 			T(-0.577350269189626),		// -1.0 + 2.0 * C.x
 			T( 0.024390243902439));		//  1.0 / 41.0
 		
 		// First corner
-		detail::tvec2<T, P> i  = floor(v + dot(v, detail::tvec2<T, P>(C[1])));
-		detail::tvec2<T, P> x0 = v -   i + dot(i, detail::tvec2<T, P>(C[0]));
+		tvec2<T, P> i  = floor(v + dot(v, tvec2<T, P>(C[1])));
+		tvec2<T, P> x0 = v -   i + dot(i, tvec2<T, P>(C[0]));
 		
 		// Other corners
 		//i1.x = step( x0.y, x0.x ); // x0.x > x0.y ? 1.0 : 0.0
 		//i1.y = 1.0 - i1.x;
-		detail::tvec2<T, P> i1 = (x0.x > x0.y) ? detail::tvec2<T, P>(1, 0) : detail::tvec2<T, P>(0, 1);
+		tvec2<T, P> i1 = (x0.x > x0.y) ? tvec2<T, P>(1, 0) : tvec2<T, P>(0, 1);
 
 		// x0 = x0 - 0.0 + 0.0 * C.xx ;
 		// x1 = x0 - i1 + 1.0 * C.xx ;
 		// x2 = x0 - 1.0 + 2.0 * C.xx ;
-		detail::tvec4<T, P> x12 = detail::tvec4<T, P>(x0.x, x0.y, x0.x, x0.y) + detail::tvec4<T, P>(C.x, C.x, C.z, C.z);
-		x12 = detail::tvec4<T, P>(detail::tvec2<T, P>(x12) - i1, x12.z, x12.w);
+		tvec4<T, P> x12 = tvec4<T, P>(x0.x, x0.y, x0.x, x0.y) + tvec4<T, P>(C.x, C.x, C.z, C.z);
+		x12 = tvec4<T, P>(tvec2<T, P>(x12) - i1, x12.z, x12.w);
 		
 		// Permutations
 		i = mod(i, T(289)); // Avoid truncation effects in permutation
-		detail::tvec3<T, P> p = detail::permute(
-			detail::permute(i.y + detail::tvec3<T, P>(T(0), i1.y, T(1))) + i.x + detail::tvec3<T, P>(T(0), i1.x, T(1)));
+		tvec3<T, P> p = detail::permute(
+			detail::permute(i.y + tvec3<T, P>(T(0), i1.y, T(1))) + i.x + tvec3<T, P>(T(0), i1.x, T(1)));
 		
-		detail::tvec3<T, P> m = max(T(0.5) - detail::tvec3<T, P>(
+		tvec3<T, P> m = max(T(0.5) - tvec3<T, P>(
 			dot(x0, x0),
-			dot(detail::tvec2<T, P>(x12.x, x12.y), detail::tvec2<T, P>(x12.x, x12.y)),
-			dot(detail::tvec2<T, P>(x12.z, x12.w), detail::tvec2<T, P>(x12.z, x12.w))), T(0));
+			dot(tvec2<T, P>(x12.x, x12.y), tvec2<T, P>(x12.x, x12.y)),
+			dot(tvec2<T, P>(x12.z, x12.w), tvec2<T, P>(x12.z, x12.w))), T(0));
 		
 		m = m * m;
 		m = m * m;
@@ -116,17 +116,17 @@ namespace detail
 		// Gradients: 41 points uniformly over a line, mapped onto a diamond.
 		// The ring size 17*17 = 289 is close to a multiple of 41 (41*7 = 287)
 		
-		detail::tvec3<T, P> x = static_cast<T>(2) * fract(p * C.w) - T(1);
-		detail::tvec3<T, P> h = abs(x) - T(0.5);
-		detail::tvec3<T, P> ox = floor(x + T(0.5));
-		detail::tvec3<T, P> a0 = x - ox;
+		tvec3<T, P> x = static_cast<T>(2) * fract(p * C.w) - T(1);
+		tvec3<T, P> h = abs(x) - T(0.5);
+		tvec3<T, P> ox = floor(x + T(0.5));
+		tvec3<T, P> a0 = x - ox;
 		
 		// Normalise gradients implicitly by scaling m
 		// Inlined for speed: m *= taylorInvSqrt( a0*a0 + h*h );
 		m *= static_cast<T>(1.79284291400159) - T(0.85373472095314) * (a0 * a0 + h * h);
 		
 		// Compute final noise value at P
-		detail::tvec3<T, P> g;
+		tvec3<T, P> g;
 		g.x  = a0.x  * x0.x  + h.x  * x0.y;
 		//g.yz = a0.yz * x12.xz + h.yz * x12.yw;
 		g.y = a0.y * x12.x + h.y * x12.y;
@@ -135,84 +135,84 @@ namespace detail
 	}
 	
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER T noise1(detail::tvec3<T, P> const & v)
+	GLM_FUNC_QUALIFIER T noise1(tvec3<T, P> const & v)
 	{
-		detail::tvec2<T, P> const C(1.0 / 6.0, 1.0 / 3.0);
-		detail::tvec4<T, P> const D(0.0, 0.5, 1.0, 2.0);
+		tvec2<T, P> const C(1.0 / 6.0, 1.0 / 3.0);
+		tvec4<T, P> const D(0.0, 0.5, 1.0, 2.0);
 		
 		// First corner
-		detail::tvec3<T, P> i(floor(v + dot(v, detail::tvec3<T, P>(C.y))));
-		detail::tvec3<T, P> x0(v - i + dot(i, detail::tvec3<T, P>(C.x)));
+		tvec3<T, P> i(floor(v + dot(v, tvec3<T, P>(C.y))));
+		tvec3<T, P> x0(v - i + dot(i, tvec3<T, P>(C.x)));
 		
 		// Other corners
-		detail::tvec3<T, P> g(step(detail::tvec3<T, P>(x0.y, x0.z, x0.x), x0));
-		detail::tvec3<T, P> l(T(1) - g);
-		detail::tvec3<T, P> i1(min(g, detail::tvec3<T, P>(l.z, l.x, l.y)));
-		detail::tvec3<T, P> i2(max(g, detail::tvec3<T, P>(l.z, l.x, l.y)));
+		tvec3<T, P> g(step(tvec3<T, P>(x0.y, x0.z, x0.x), x0));
+		tvec3<T, P> l(T(1) - g);
+		tvec3<T, P> i1(min(g, tvec3<T, P>(l.z, l.x, l.y)));
+		tvec3<T, P> i2(max(g, tvec3<T, P>(l.z, l.x, l.y)));
 		
 		// x0 = x0 - 0.0 + 0.0 * C.xxx;
 		// x1 = x0 - i1  + 1.0 * C.xxx;
 		// x2 = x0 - i2  + 2.0 * C.xxx;
 		// x3 = x0 - 1.0 + 3.0 * C.xxx;
-		detail::tvec3<T, P> x1(x0 - i1 + C.x);
-		detail::tvec3<T, P> x2(x0 - i2 + C.y);		// 2.0*C.x = 1/3 = C.y
-		detail::tvec3<T, P> x3(x0 - D.y);			// -1.0+3.0*C.x = -0.5 = -D.y
+		tvec3<T, P> x1(x0 - i1 + C.x);
+		tvec3<T, P> x2(x0 - i2 + C.y);		// 2.0*C.x = 1/3 = C.y
+		tvec3<T, P> x3(x0 - D.y);			// -1.0+3.0*C.x = -0.5 = -D.y
 		
 		// Permutations
 		i = mod289(i); 
-		detail::tvec4<T, P> p(detail::permute(detail::permute(detail::permute(
-			i.z + detail::tvec4<T, P>(T(0), i1.z, i2.z, T(1))) +
-			i.y + detail::tvec4<T, P>(T(0), i1.y, i2.y, T(1))) +
-			i.x + detail::tvec4<T, P>(T(0), i1.x, i2.x, T(1))));
+		tvec4<T, P> p(detail::permute(detail::permute(detail::permute(
+			i.z + tvec4<T, P>(T(0), i1.z, i2.z, T(1))) +
+			i.y + tvec4<T, P>(T(0), i1.y, i2.y, T(1))) +
+			i.x + tvec4<T, P>(T(0), i1.x, i2.x, T(1))));
 		
 		// Gradients: 7x7 points over a square, mapped onto an octahedron.
 		// The ring size 17*17 = 289 is close to a multiple of 49 (49*6 = 294)
 		T n_ = static_cast<T>(0.142857142857); // 1.0/7.0
-		detail::tvec3<T, P> ns(n_ * detail::tvec3<T, P>(D.w, D.y, D.z) - detail::tvec3<T, P>(D.x, D.z, D.x));
+		tvec3<T, P> ns(n_ * tvec3<T, P>(D.w, D.y, D.z) - tvec3<T, P>(D.x, D.z, D.x));
 		
-		detail::tvec4<T, P> j(p - T(49) * floor(p * ns.z * ns.z));	// mod(p,7*7)
+		tvec4<T, P> j(p - T(49) * floor(p * ns.z * ns.z));	// mod(p,7*7)
 		
-		detail::tvec4<T, P> x_(floor(j * ns.z));
-		detail::tvec4<T, P> y_(floor(j - T(7) * x_));				// mod(j,N)
+		tvec4<T, P> x_(floor(j * ns.z));
+		tvec4<T, P> y_(floor(j - T(7) * x_));				// mod(j,N)
 		
-		detail::tvec4<T, P> x(x_ * ns.x + ns.y);
-		detail::tvec4<T, P> y(y_ * ns.x + ns.y);
-		detail::tvec4<T, P> h(T(1) - abs(x) - abs(y));
+		tvec4<T, P> x(x_ * ns.x + ns.y);
+		tvec4<T, P> y(y_ * ns.x + ns.y);
+		tvec4<T, P> h(T(1) - abs(x) - abs(y));
 		
-		detail::tvec4<T, P> b0(x.x, x.y, y.x, y.y);
-		detail::tvec4<T, P> b1(x.z, x.w, y.z, y.w);
+		tvec4<T, P> b0(x.x, x.y, y.x, y.y);
+		tvec4<T, P> b1(x.z, x.w, y.z, y.w);
 		
 		// vec4 s0 = vec4(lessThan(b0,0.0))*2.0 - 1.0;
 		// vec4 s1 = vec4(lessThan(b1,0.0))*2.0 - 1.0;
-		detail::tvec4<T, P> s0(floor(b0) * T(2) + T(1));
-		detail::tvec4<T, P> s1(floor(b1) * T(2) + T(1));
-		detail::tvec4<T, P> sh(-step(h, detail::tvec4<T, P>(0.0)));
+		tvec4<T, P> s0(floor(b0) * T(2) + T(1));
+		tvec4<T, P> s1(floor(b1) * T(2) + T(1));
+		tvec4<T, P> sh(-step(h, tvec4<T, P>(0.0)));
 		
-		detail::tvec4<T, P> a0 = detail::tvec4<T, P>(b0.x, b0.z, b0.y, b0.w) + detail::tvec4<T, P>(s0.x, s0.z, s0.y, s0.w) * detail::tvec4<T, P>(sh.x, sh.x, sh.y, sh.y);
-		detail::tvec4<T, P> a1 = detail::tvec4<T, P>(b1.x, b1.z, b1.y, b1.w) + detail::tvec4<T, P>(s1.x, s1.z, s1.y, s1.w) * detail::tvec4<T, P>(sh.z, sh.z, sh.w, sh.w);
+		tvec4<T, P> a0 = tvec4<T, P>(b0.x, b0.z, b0.y, b0.w) + tvec4<T, P>(s0.x, s0.z, s0.y, s0.w) * tvec4<T, P>(sh.x, sh.x, sh.y, sh.y);
+		tvec4<T, P> a1 = tvec4<T, P>(b1.x, b1.z, b1.y, b1.w) + tvec4<T, P>(s1.x, s1.z, s1.y, s1.w) * tvec4<T, P>(sh.z, sh.z, sh.w, sh.w);
 		
-		detail::tvec3<T, P> p0(a0.x, a0.y, h.x);
-		detail::tvec3<T, P> p1(a0.z, a0.w, h.y);
-		detail::tvec3<T, P> p2(a1.x, a1.y, h.z);
-		detail::tvec3<T, P> p3(a1.z, a1.w, h.w);
+		tvec3<T, P> p0(a0.x, a0.y, h.x);
+		tvec3<T, P> p1(a0.z, a0.w, h.y);
+		tvec3<T, P> p2(a1.x, a1.y, h.z);
+		tvec3<T, P> p3(a1.z, a1.w, h.w);
 		
 		// Normalise gradients
-		detail::tvec4<T, P> norm = taylorInvSqrt(detail::tvec4<T, P>(dot(p0, p0), dot(p1, p1), dot(p2, p2), dot(p3, p3)));
+		tvec4<T, P> norm = taylorInvSqrt(tvec4<T, P>(dot(p0, p0), dot(p1, p1), dot(p2, p2), dot(p3, p3)));
 		p0 *= norm.x;
 		p1 *= norm.y;
 		p2 *= norm.z;
 		p3 *= norm.w;
 		
 		// Mix final noise value
-		detail::tvec4<T, P> m = max(T(0.6) - detail::tvec4<T, P>(dot(x0, x0), dot(x1, x1), dot(x2, x2), dot(x3, x3)), T(0));
+		tvec4<T, P> m = max(T(0.6) - tvec4<T, P>(dot(x0, x0), dot(x1, x1), dot(x2, x2), dot(x3, x3)), T(0));
 		m = m * m;
-		return T(42) * dot(m * m, detail::tvec4<T, P>(dot(p0, x0), dot(p1, x1), dot(p2, x2), dot(p3, x3)));
+		return T(42) * dot(m * m, tvec4<T, P>(dot(p0, x0), dot(p1, x1), dot(p2, x2), dot(p3, x3)));
 	}
 	
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER T noise1(detail::tvec4<T, P> const & v)
+	GLM_FUNC_QUALIFIER T noise1(tvec4<T, P> const & v)
 	{
-		detail::tvec4<T, P> const C(
+		tvec4<T, P> const C(
 			0.138196601125011,		// (5 - sqrt(5))/20  G4
 			0.276393202250021,		// 2 * G4
 			0.414589803375032,		// 3 * G4
@@ -222,66 +222,66 @@ namespace detail
 		T const F4 = static_cast<T>(0.309016994374947451);
 		
 		// First corner
-		detail::tvec4<T, P> i  = floor(v + dot(v, detail::tvec4<T, P>(F4)));
-		detail::tvec4<T, P> x0 = v -   i + dot(i, detail::tvec4<T, P>(C.x));
+		tvec4<T, P> i  = floor(v + dot(v, tvec4<T, P>(F4)));
+		tvec4<T, P> x0 = v -   i + dot(i, tvec4<T, P>(C.x));
 		
 		// Other corners
 		
 		// Rank sorting originally contributed by Bill Licea-Kane, AMD (formerly ATI)
-		detail::tvec4<T, P> i0;
-		detail::tvec3<T, P> isX = step(detail::tvec3<T, P>(x0.y, x0.z, x0.w), detail::tvec3<T, P>(x0.x));
-		detail::tvec3<T, P> isYZ = step(detail::tvec3<T, P>(x0.z, x0.w, x0.w), detail::tvec3<T, P>(x0.y, x0.y, x0.z));
+		tvec4<T, P> i0;
+		tvec3<T, P> isX = step(tvec3<T, P>(x0.y, x0.z, x0.w), tvec3<T, P>(x0.x));
+		tvec3<T, P> isYZ = step(tvec3<T, P>(x0.z, x0.w, x0.w), tvec3<T, P>(x0.y, x0.y, x0.z));
 		
 		//  i0.x = dot(isX, vec3(1.0));
 		//i0.x = isX.x + isX.y + isX.z;
 		//i0.yzw = static_cast<T>(1) - isX;
-		i0 = detail::tvec4<T, P>(isX.x + isX.y + isX.z, T(1) - isX);
+		i0 = tvec4<T, P>(isX.x + isX.y + isX.z, T(1) - isX);
 		
 		//  i0.y += dot(isYZ.xy, vec2(1.0));
 		i0.y += isYZ.x + isYZ.y;
 		
-		//i0.zw += 1.0 - detail::tvec2<T, P>(isYZ.x, isYZ.y);
+		//i0.zw += 1.0 - tvec2<T, P>(isYZ.x, isYZ.y);
 		i0.z += static_cast<T>(1) - isYZ.x;
 		i0.w += static_cast<T>(1) - isYZ.y;
 		i0.z += isYZ.z;
 		i0.w += static_cast<T>(1) - isYZ.z;
 		
 		// i0 now contains the unique values 0,1,2,3 in each channel
-		detail::tvec4<T, P> i3 = clamp(i0, T(0), T(1));
-		detail::tvec4<T, P> i2 = clamp(i0 - T(1), T(0), T(1));
-		detail::tvec4<T, P> i1 = clamp(i0 - T(2), T(0), T(1));
+		tvec4<T, P> i3 = clamp(i0, T(0), T(1));
+		tvec4<T, P> i2 = clamp(i0 - T(1), T(0), T(1));
+		tvec4<T, P> i1 = clamp(i0 - T(2), T(0), T(1));
 		
 		//  x0 = x0 - 0.0 + 0.0 * C.xxxx
 		//  x1 = x0 - i1  + 0.0 * C.xxxx
 		//  x2 = x0 - i2  + 0.0 * C.xxxx
 		//  x3 = x0 - i3  + 0.0 * C.xxxx
 		//  x4 = x0 - 1.0 + 4.0 * C.xxxx
-		detail::tvec4<T, P> x1 = x0 - i1 + C.x;
-		detail::tvec4<T, P> x2 = x0 - i2 + C.y;
-		detail::tvec4<T, P> x3 = x0 - i3 + C.z;
-		detail::tvec4<T, P> x4 = x0 + C.w;
+		tvec4<T, P> x1 = x0 - i1 + C.x;
+		tvec4<T, P> x2 = x0 - i2 + C.y;
+		tvec4<T, P> x3 = x0 - i3 + C.z;
+		tvec4<T, P> x4 = x0 + C.w;
 		
 		// Permutations
 		i = mod(i, T(289));
 		T j0 = detail::permute(detail::permute(detail::permute(detail::permute(i.w) + i.z) + i.y) + i.x);
-		detail::tvec4<T, P> j1 = detail::permute(detail::permute(detail::permute(detail::permute(
-			i.w + detail::tvec4<T, P>(i1.w, i2.w, i3.w, T(1))) +
-			i.z + detail::tvec4<T, P>(i1.z, i2.z, i3.z, T(1))) +
-			i.y + detail::tvec4<T, P>(i1.y, i2.y, i3.y, T(1))) +
-			i.x + detail::tvec4<T, P>(i1.x, i2.x, i3.x, T(1)));
+		tvec4<T, P> j1 = detail::permute(detail::permute(detail::permute(detail::permute(
+			i.w + tvec4<T, P>(i1.w, i2.w, i3.w, T(1))) +
+			i.z + tvec4<T, P>(i1.z, i2.z, i3.z, T(1))) +
+			i.y + tvec4<T, P>(i1.y, i2.y, i3.y, T(1))) +
+			i.x + tvec4<T, P>(i1.x, i2.x, i3.x, T(1)));
 		
 		// Gradients: 7x7x6 points over a cube, mapped onto a 4-cross polytope
 		// 7*7*6 = 294, which is close to the ring size 17*17 = 289.
-		detail::tvec4<T, P> ip = detail::tvec4<T, P>(T(1) / T(294), T(1) / T(49), T(1) / T(7), T(0));
+		tvec4<T, P> ip = tvec4<T, P>(T(1) / T(294), T(1) / T(49), T(1) / T(7), T(0));
 		
-		detail::tvec4<T, P> p0 = detail::grad4(j0,   ip);
-		detail::tvec4<T, P> p1 = detail::grad4(j1.x, ip);
-		detail::tvec4<T, P> p2 = detail::grad4(j1.y, ip);
-		detail::tvec4<T, P> p3 = detail::grad4(j1.z, ip);
-		detail::tvec4<T, P> p4 = detail::grad4(j1.w, ip);
+		tvec4<T, P> p0 = detail::grad4(j0,   ip);
+		tvec4<T, P> p1 = detail::grad4(j1.x, ip);
+		tvec4<T, P> p2 = detail::grad4(j1.y, ip);
+		tvec4<T, P> p3 = detail::grad4(j1.z, ip);
+		tvec4<T, P> p4 = detail::grad4(j1.w, ip);
 		
 		// Normalise gradients
-		detail::tvec4<T, P> norm = detail::taylorInvSqrt(detail::tvec4<T, P>(dot(p0, p0), dot(p1, p1), dot(p2, p2), dot(p3, p3)));
+		tvec4<T, P> norm = detail::taylorInvSqrt(tvec4<T, P>(dot(p0, p0), dot(p1, p1), dot(p2, p2), dot(p3, p3)));
 		p0 *= norm.x;
 		p1 *= norm.y;
 		p2 *= norm.z;
@@ -289,96 +289,96 @@ namespace detail
 		p4 *= taylorInvSqrt(dot(p4, p4));
 		
 		// Mix contributions from the five corners
-		detail::tvec3<T, P> m0 = max(T(0.6) - detail::tvec3<T, P>(dot(x0, x0), dot(x1, x1), dot(x2, x2)), T(0));
-		detail::tvec2<T, P> m1 = max(T(0.6) - detail::tvec2<T, P>(dot(x3, x3), dot(x4, x4)             ), T(0));
+		tvec3<T, P> m0 = max(T(0.6) - tvec3<T, P>(dot(x0, x0), dot(x1, x1), dot(x2, x2)), T(0));
+		tvec2<T, P> m1 = max(T(0.6) - tvec2<T, P>(dot(x3, x3), dot(x4, x4)             ), T(0));
 		m0 = m0 * m0;
 		m1 = m1 * m1;
 		
 		return T(49) * (
-			dot(m0 * m0, detail::tvec3<T, P>(dot(p0, x0), dot(p1, x1), dot(p2, x2))) +
-			dot(m1 * m1, detail::tvec2<T, P>(dot(p3, x3), dot(p4, x4))));
+			dot(m0 * m0, tvec3<T, P>(dot(p0, x0), dot(p1, x1), dot(p2, x2))) +
+			dot(m1 * m1, tvec2<T, P>(dot(p3, x3), dot(p4, x4))));
 	}
 	
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec2<T, P> noise2(detail::tvec2<T, P> const & x)
+	GLM_FUNC_QUALIFIER tvec2<T, P> noise2(tvec2<T, P> const & x)
 	{
-		return detail::tvec2<T, P>(
-			noise1(x + detail::tvec2<T, P>(0.0)),
-			noise1(detail::tvec2<T, P>(0.0) - x));
+		return tvec2<T, P>(
+			noise1(x + tvec2<T, P>(0.0)),
+			noise1(tvec2<T, P>(0.0) - x));
 	}
 	
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec2<T, P> noise2(detail::tvec3<T, P> const & x)
+	GLM_FUNC_QUALIFIER tvec2<T, P> noise2(tvec3<T, P> const & x)
 	{
-		return detail::tvec2<T, P>(
-			noise1(x + detail::tvec3<T, P>(0.0)),
-			noise1(detail::tvec3<T, P>(0.0) - x));
+		return tvec2<T, P>(
+			noise1(x + tvec3<T, P>(0.0)),
+			noise1(tvec3<T, P>(0.0) - x));
 	}
 	
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec2<T, P> noise2(detail::tvec4<T, P> const & x)
+	GLM_FUNC_QUALIFIER tvec2<T, P> noise2(tvec4<T, P> const & x)
 	{
-		return detail::tvec2<T, P>(
-			noise1(x + detail::tvec4<T, P>(0)),
-			noise1(detail::tvec4<T, P>(0) - x));
+		return tvec2<T, P>(
+			noise1(x + tvec4<T, P>(0)),
+			noise1(tvec4<T, P>(0) - x));
 	}
 	
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec3<T, P> noise3(detail::tvec2<T, P> const & x)
+	GLM_FUNC_QUALIFIER tvec3<T, P> noise3(tvec2<T, P> const & x)
 	{
-		return detail::tvec3<T, P>(
-			noise1(x - detail::tvec2<T, P>(1.0)),
-			noise1(x + detail::tvec2<T, P>(0.0)),
-			noise1(x + detail::tvec2<T, P>(1.0)));
+		return tvec3<T, P>(
+			noise1(x - tvec2<T, P>(1.0)),
+			noise1(x + tvec2<T, P>(0.0)),
+			noise1(x + tvec2<T, P>(1.0)));
 	}
 	
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec3<T, P> noise3(detail::tvec3<T, P> const & x)
+	GLM_FUNC_QUALIFIER tvec3<T, P> noise3(tvec3<T, P> const & x)
 	{
-		return detail::tvec3<T, P>(
-			noise1(x - detail::tvec3<T, P>(1.0)),
-			noise1(x + detail::tvec3<T, P>(0.0)),
-			noise1(x + detail::tvec3<T, P>(1.0)));
+		return tvec3<T, P>(
+			noise1(x - tvec3<T, P>(1.0)),
+			noise1(x + tvec3<T, P>(0.0)),
+			noise1(x + tvec3<T, P>(1.0)));
 	}
 	
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec3<T, P> noise3(detail::tvec4<T, P> const & x)
+	GLM_FUNC_QUALIFIER tvec3<T, P> noise3(tvec4<T, P> const & x)
 	{
-		return detail::tvec3<T, P>(
-			noise1(x - detail::tvec4<T, P>(1)),
-			noise1(x + detail::tvec4<T, P>(0)),
-			noise1(x + detail::tvec4<T, P>(1)));
+		return tvec3<T, P>(
+			noise1(x - tvec4<T, P>(1)),
+			noise1(x + tvec4<T, P>(0)),
+			noise1(x + tvec4<T, P>(1)));
 	}
 	
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec4<T, P> noise4(detail::tvec2<T, P> const & x)
+	GLM_FUNC_QUALIFIER tvec4<T, P> noise4(tvec2<T, P> const & x)
 	{
-		return detail::tvec4<T, P>(
-			noise1(x - detail::tvec2<T, P>(1)),
-			noise1(x + detail::tvec2<T, P>(0)),
-			noise1(x + detail::tvec2<T, P>(1)),
-			noise1(x + detail::tvec2<T, P>(2)));
+		return tvec4<T, P>(
+			noise1(x - tvec2<T, P>(1)),
+			noise1(x + tvec2<T, P>(0)),
+			noise1(x + tvec2<T, P>(1)),
+			noise1(x + tvec2<T, P>(2)));
 	}
 
 	
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec4<T, P> noise4(detail::tvec3<T, P> const & x)
+	GLM_FUNC_QUALIFIER tvec4<T, P> noise4(tvec3<T, P> const & x)
 	{
-		return detail::tvec4<T, P>(
-			noise1(x - detail::tvec3<T, P>(1)),
-			noise1(x + detail::tvec3<T, P>(0)),
-			noise1(x + detail::tvec3<T, P>(1)),
-			noise1(x + detail::tvec3<T, P>(2)));
+		return tvec4<T, P>(
+			noise1(x - tvec3<T, P>(1)),
+			noise1(x + tvec3<T, P>(0)),
+			noise1(x + tvec3<T, P>(1)),
+			noise1(x + tvec3<T, P>(2)));
 	}
 	
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec4<T, P> noise4(detail::tvec4<T, P> const & x)
+	GLM_FUNC_QUALIFIER tvec4<T, P> noise4(tvec4<T, P> const & x)
 	{
-		return detail::tvec4<T, P>(
-			noise1(x - detail::tvec4<T, P>(1)),
-			noise1(x + detail::tvec4<T, P>(0)),
-			noise1(x + detail::tvec4<T, P>(1)),
-			noise1(x + detail::tvec4<T, P>(2)));
+		return tvec4<T, P>(
+			noise1(x - tvec4<T, P>(1)),
+			noise1(x + tvec4<T, P>(0)),
+			noise1(x + tvec4<T, P>(1)),
+			noise1(x + tvec4<T, P>(2)));
 	}
 	
 }//namespace glm

glm/detail/intrinsic_matrix.inl

@@ -448,7 +448,7 @@ GLM_FUNC_QUALIFIER __m128 sse_detd_ps
 	__m128 MulC = _mm_mul_ps(Swp2C, Swp3C);
 	__m128 SubF = _mm_sub_ps(_mm_movehl_ps(MulC, MulC), MulC);
 
-	//detail::tvec4<T, P> DetCof(
+	//tvec4<T, P> DetCof(
 	//	+ (m[1][1] * SubFactor00 - m[1][2] * SubFactor01 + m[1][3] * SubFactor02),
 	//	- (m[1][0] * SubFactor00 - m[1][2] * SubFactor03 + m[1][3] * SubFactor04),
 	//	+ (m[1][0] * SubFactor01 - m[1][1] * SubFactor03 + m[1][3] * SubFactor05),
@@ -514,7 +514,7 @@ GLM_FUNC_QUALIFIER __m128 sse_det_ps
 	__m128 MulC = _mm_mul_ps(Swp2C, Swp3C);
 	__m128 SubF = _mm_sub_ps(_mm_movehl_ps(MulC, MulC), MulC);
 
-	//detail::tvec4<T, P> DetCof(
+	//tvec4<T, P> DetCof(
 	//	+ (m[1][1] * SubFactor00 - m[1][2] * SubFactor01 + m[1][3] * SubFactor02),
 	//	- (m[1][0] * SubFactor00 - m[1][2] * SubFactor03 + m[1][3] * SubFactor04),
 	//	+ (m[1][0] * SubFactor01 - m[1][1] * SubFactor03 + m[1][3] * SubFactor05),
@@ -1003,7 +1003,7 @@ GLM_FUNC_QUALIFIER void sse_rotate_ps(__m128 const in[4], float Angle, float con
 	__m128 Sin0 = _mm_set_ss(s);
 	__m128 SinA = _mm_shuffle_ps(Sin0, Sin0, _MM_SHUFFLE(0, 0, 0, 0));
 
-	// detail::tvec3<T, P> temp = (valType(1) - c) * axis;
+	// tvec3<T, P> temp = (valType(1) - c) * axis;
 	__m128 Temp0 = _mm_sub_ps(one, CosA);
 	__m128 Temp1 = _mm_mul_ps(Temp0, AxisC);
 	
@@ -1049,7 +1049,7 @@ GLM_FUNC_QUALIFIER void sse_rotate_ps(__m128 const in[4], float Angle, float con
 	Result[2] = TmpC4;
 	Result[3] = _mm_set_ps(1, 0, 0, 0);
 
-	//detail::tmat4x4<valType> Result(detail::tmat4x4<valType>::_null);
+	//tmat4x4<valType> Result(tmat4x4<valType>::_null);
 	//Result[0] = m[0] * Rotate[0][0] + m[1] * Rotate[0][1] + m[2] * Rotate[0][2];
 	//Result[1] = m[0] * Rotate[1][0] + m[1] * Rotate[1][1] + m[2] * Rotate[1][2];
 	//Result[2] = m[0] * Rotate[2][0] + m[1] * Rotate[2][1] + m[2] * Rotate[2][2];

glm/detail/intrinsic_vector_relational.inl

@@ -28,10 +28,10 @@
 //
 //// lessThan
 //template <typename valType>
-//GLM_FUNC_QUALIFIER typename detail::tvec2<T, P>::bool_type lessThan
+//GLM_FUNC_QUALIFIER typename tvec2<T, P>::bool_type lessThan
 //(
-//	detail::tvec2<T, P> const & x, 
-//	detail::tvec2<T, P> const & y
+//	tvec2<T, P> const & x, 
+//	tvec2<T, P> const & y
 //)
 //{
 //	GLM_STATIC_ASSERT(
@@ -39,14 +39,14 @@
 //		detail::type<valType>::is_int || 
 //		detail::type<valType>::is_uint);
 //
-//    return typename detail::tvec2<bool>::bool_type(x.x < y.x, x.y < y.y);
+//    return typename tvec2<bool>::bool_type(x.x < y.x, x.y < y.y);
 //}
 //
 //template <typename valType>
-//GLM_FUNC_QUALIFIER typename detail::tvec3<T, P>::bool_type lessThan
+//GLM_FUNC_QUALIFIER typename tvec3<T, P>::bool_type lessThan
 //(
-//	detail::tvec3<T, P> const & x, 
-//	detail::tvec3<T, P> const & y
+//	tvec3<T, P> const & x, 
+//	tvec3<T, P> const & y
 //)
 //{
 //	GLM_STATIC_ASSERT(
@@ -54,14 +54,14 @@
 //		detail::type<valType>::is_int || 
 //		detail::type<valType>::is_uint);
 //	
-//	return typename detail::tvec3<bool>::bool_type(x.x < y.x, x.y < y.y, x.z < y.z);
+//	return typename tvec3<bool>::bool_type(x.x < y.x, x.y < y.y, x.z < y.z);
 //}
 //
 //template <typename valType>
-//GLM_FUNC_QUALIFIER typename detail::tvec4<T, P>::bool_type lessThan
+//GLM_FUNC_QUALIFIER typename tvec4<T, P>::bool_type lessThan
 //(
-//	detail::tvec4<T, P> const & x, 
-//	detail::tvec4<T, P> const & y
+//	tvec4<T, P> const & x, 
+//	tvec4<T, P> const & y
 //)
 //{
 //	GLM_STATIC_ASSERT(
@@ -69,15 +69,15 @@
 //		detail::type<valType>::is_int || 
 //		detail::type<valType>::is_uint);
 //
-//	return typename detail::tvec4<bool>::bool_type(x.x < y.x, x.y < y.y, x.z < y.z, x.w < y.w);
+//	return typename tvec4<bool>::bool_type(x.x < y.x, x.y < y.y, x.z < y.z, x.w < y.w);
 //}
 //
 //// lessThanEqual
 //template <typename valType>
-//GLM_FUNC_QUALIFIER typename detail::tvec2<T, P>::bool_type lessThanEqual
+//GLM_FUNC_QUALIFIER typename tvec2<T, P>::bool_type lessThanEqual
 //(
-//	detail::tvec2<T, P> const & x, 
-//	detail::tvec2<T, P> const & y
+//	tvec2<T, P> const & x, 
+//	tvec2<T, P> const & y
 //)
 //{
 //	GLM_STATIC_ASSERT(
@@ -85,14 +85,14 @@
 //		detail::type<valType>::is_int || 
 //		detail::type<valType>::is_uint);
 //
-//	return typename detail::tvec2<bool>::bool_type(x.x <= y.x, x.y <= y.y);
+//	return typename tvec2<bool>::bool_type(x.x <= y.x, x.y <= y.y);
 //}
 //
 //template <typename valType>
-//GLM_FUNC_QUALIFIER typename detail::tvec3<T, P>::bool_type lessThanEqual
+//GLM_FUNC_QUALIFIER typename tvec3<T, P>::bool_type lessThanEqual
 //(
-//	detail::tvec3<T, P> const & x, 
-//	detail::tvec3<T, P> const & y
+//	tvec3<T, P> const & x, 
+//	tvec3<T, P> const & y
 //)
 //{
 //	GLM_STATIC_ASSERT(
@@ -100,14 +100,14 @@
 //		detail::type<valType>::is_int || 
 //		detail::type<valType>::is_uint);
 //	
-//	return typename detail::tvec3<bool>::bool_type(x.x <= y.x, x.y <= y.y, x.z <= y.z);
+//	return typename tvec3<bool>::bool_type(x.x <= y.x, x.y <= y.y, x.z <= y.z);
 //}
 //
 //template <typename valType>
-//GLM_FUNC_QUALIFIER typename detail::tvec4<T, P>::bool_type lessThanEqual
+//GLM_FUNC_QUALIFIER typename tvec4<T, P>::bool_type lessThanEqual
 //(
-//	detail::tvec4<T, P> const & x, 
-//	detail::tvec4<T, P> const & y
+//	tvec4<T, P> const & x, 
+//	tvec4<T, P> const & y
 //)
 //{
 //	GLM_STATIC_ASSERT(
@@ -115,15 +115,15 @@
 //		detail::type<valType>::is_int || 
 //		detail::type<valType>::is_uint);
 //	
-//	return typename detail::tvec4<bool>::bool_type(x.x <= y.x, x.y <= y.y, x.z <= y.z, x.w <= y.w);
+//	return typename tvec4<bool>::bool_type(x.x <= y.x, x.y <= y.y, x.z <= y.z, x.w <= y.w);
 //}
 //
 //// greaterThan
 //template <typename valType>
-//GLM_FUNC_QUALIFIER typename detail::tvec2<T, P>::bool_type greaterThan
+//GLM_FUNC_QUALIFIER typename tvec2<T, P>::bool_type greaterThan
 //(
-//	detail::tvec2<T, P> const & x, 
-//	detail::tvec2<T, P> const & y
+//	tvec2<T, P> const & x, 
+//	tvec2<T, P> const & y
 //)
 //{
 //	GLM_STATIC_ASSERT(
@@ -131,14 +131,14 @@
 //		detail::type<valType>::is_int || 
 //		detail::type<valType>::is_uint);
 //
-//	return typename detail::tvec2<bool>::bool_type(x.x > y.x, x.y > y.y);
+//	return typename tvec2<bool>::bool_type(x.x > y.x, x.y > y.y);
 //}
 //
 //template <typename valType>
-//GLM_FUNC_QUALIFIER typename detail::tvec3<T, P>::bool_type greaterThan
+//GLM_FUNC_QUALIFIER typename tvec3<T, P>::bool_type greaterThan
 //(
-//	detail::tvec3<T, P> const & x, 
-//	detail::tvec3<T, P> const & y
+//	tvec3<T, P> const & x, 
+//	tvec3<T, P> const & y
 //)
 //{
 //	GLM_STATIC_ASSERT(
@@ -146,14 +146,14 @@
 //		detail::type<valType>::is_int || 
 //		detail::type<valType>::is_uint);
 //	
-//	return typename detail::tvec3<bool>::bool_type(x.x > y.x, x.y > y.y, x.z > y.z);
+//	return typename tvec3<bool>::bool_type(x.x > y.x, x.y > y.y, x.z > y.z);
 //}
 //
 //template <typename valType>
-//GLM_FUNC_QUALIFIER typename detail::tvec4<T, P>::bool_type greaterThan
+//GLM_FUNC_QUALIFIER typename tvec4<T, P>::bool_type greaterThan
 //(
-//	detail::tvec4<T, P> const & x, 
-//	detail::tvec4<T, P> const & y
+//	tvec4<T, P> const & x, 
+//	tvec4<T, P> const & y
 //)
 //{
 //	GLM_STATIC_ASSERT(
@@ -161,15 +161,15 @@
 //		detail::type<valType>::is_int || 
 //		detail::type<valType>::is_uint);
 //	
-//	return typename detail::tvec4<bool>::bool_type(x.x > y.x, x.y > y.y, x.z > y.z, x.w > y.w);
+//	return typename tvec4<bool>::bool_type(x.x > y.x, x.y > y.y, x.z > y.z, x.w > y.w);
 //}
 //
 //// greaterThanEqual
 //template <typename valType>
-//GLM_FUNC_QUALIFIER typename detail::tvec2<T, P>::bool_type greaterThanEqual
+//GLM_FUNC_QUALIFIER typename tvec2<T, P>::bool_type greaterThanEqual
 //(
-//	detail::tvec2<T, P> const & x, 
-//	detail::tvec2<T, P> const & y
+//	tvec2<T, P> const & x, 
+//	tvec2<T, P> const & y
 //)
 //{
 //	GLM_STATIC_ASSERT(
@@ -177,14 +177,14 @@
 //		detail::type<valType>::is_int || 
 //		detail::type<valType>::is_uint);
 //
-//	return typename detail::tvec2<bool>::bool_type(x.x >= y.x, x.y >= y.y);
+//	return typename tvec2<bool>::bool_type(x.x >= y.x, x.y >= y.y);
 //}
 //
 //template <typename valType>
-//GLM_FUNC_QUALIFIER typename detail::tvec3<T, P>::bool_type greaterThanEqual
+//GLM_FUNC_QUALIFIER typename tvec3<T, P>::bool_type greaterThanEqual
 //(
-//	detail::tvec3<T, P> const & x, 
-//	detail::tvec3<T, P> const & y
+//	tvec3<T, P> const & x, 
+//	tvec3<T, P> const & y
 //)
 //{
 //	GLM_STATIC_ASSERT(
@@ -192,14 +192,14 @@
 //		detail::type<valType>::is_int || 
 //		detail::type<valType>::is_uint);
 //
-//	return typename detail::tvec3<bool>::bool_type(x.x >= y.x, x.y >= y.y, x.z >= y.z);
+//	return typename tvec3<bool>::bool_type(x.x >= y.x, x.y >= y.y, x.z >= y.z);
 //}
 //
 //template <typename valType>
-//GLM_FUNC_QUALIFIER typename detail::tvec4<T, P>::bool_type greaterThanEqual
+//GLM_FUNC_QUALIFIER typename tvec4<T, P>::bool_type greaterThanEqual
 //(
-//	detail::tvec4<T, P> const & x, 
-//	detail::tvec4<T, P> const & y
+//	tvec4<T, P> const & x, 
+//	tvec4<T, P> const & y
 //)
 //{
 //	GLM_STATIC_ASSERT(
@@ -207,15 +207,15 @@
 //		detail::type<valType>::is_int || 
 //		detail::type<valType>::is_uint);
 //
-//	return typename detail::tvec4<bool>::bool_type(x.x >= y.x, x.y >= y.y, x.z >= y.z, x.w >= y.w);
+//	return typename tvec4<bool>::bool_type(x.x >= y.x, x.y >= y.y, x.z >= y.z, x.w >= y.w);
 //}
 //
 //// equal
 //template <typename valType>
-//GLM_FUNC_QUALIFIER typename detail::tvec2<T, P>::bool_type equal
+//GLM_FUNC_QUALIFIER typename tvec2<T, P>::bool_type equal
 //(
-//	detail::tvec2<T, P> const & x, 
-//	detail::tvec2<T, P> const & y
+//	tvec2<T, P> const & x, 
+//	tvec2<T, P> const & y
 //)
 //{
 //	GLM_STATIC_ASSERT(
@@ -224,14 +224,14 @@
 //		detail::type<valType>::is_uint || 
 //		detail::type<valType>::is_bool);
 //
-//	return typename detail::tvec2<T, P>::bool_type(x.x == y.x, x.y == y.y);
+//	return typename tvec2<T, P>::bool_type(x.x == y.x, x.y == y.y);
 //}
 //
 //template <typename valType>
-//GLM_FUNC_QUALIFIER typename detail::tvec3<T, P>::bool_type equal
+//GLM_FUNC_QUALIFIER typename tvec3<T, P>::bool_type equal
 //(
-//	detail::tvec3<T, P> const & x, 
-//	detail::tvec3<T, P> const & y
+//	tvec3<T, P> const & x, 
+//	tvec3<T, P> const & y
 //)
 //{
 //	GLM_STATIC_ASSERT(
@@ -240,14 +240,14 @@
 //		detail::type<valType>::is_uint || 
 //		detail::type<valType>::is_bool);
 //
-//	return typename detail::tvec3<T, P>::bool_type(x.x == y.x, x.y == y.y, x.z == y.z);
+//	return typename tvec3<T, P>::bool_type(x.x == y.x, x.y == y.y, x.z == y.z);
 //}
 //
 //template <typename valType>
-//GLM_FUNC_QUALIFIER typename detail::tvec4<T, P>::bool_type equal
+//GLM_FUNC_QUALIFIER typename tvec4<T, P>::bool_type equal
 //(
-//	detail::tvec4<T, P> const & x, 
-//	detail::tvec4<T, P> const & y
+//	tvec4<T, P> const & x, 
+//	tvec4<T, P> const & y
 //)
 //{
 //	GLM_STATIC_ASSERT(
@@ -256,15 +256,15 @@
 //		detail::type<valType>::is_uint || 
 //		detail::type<valType>::is_bool);
 //
-//	return typename detail::tvec4<T, P>::bool_type(x.x == y.x, x.y == y.y, x.z == y.z, x.w == y.w);
+//	return typename tvec4<T, P>::bool_type(x.x == y.x, x.y == y.y, x.z == y.z, x.w == y.w);
 //}
 //
 //// notEqual
 //template <typename valType>
-//GLM_FUNC_QUALIFIER typename detail::tvec2<T, P>::bool_type notEqual
+//GLM_FUNC_QUALIFIER typename tvec2<T, P>::bool_type notEqual
 //(
-//	detail::tvec2<T, P> const & x, 
-//	detail::tvec2<T, P> const & y
+//	tvec2<T, P> const & x, 
+//	tvec2<T, P> const & y
 //)
 //{
 //	GLM_STATIC_ASSERT(
@@ -273,14 +273,14 @@
 //		detail::type<valType>::is_uint || 
 //		detail::type<valType>::is_bool);
 //
-//	return typename detail::tvec2<T, P>::bool_type(x.x != y.x, x.y != y.y);
+//	return typename tvec2<T, P>::bool_type(x.x != y.x, x.y != y.y);
 //}
 //
 //template <typename valType>
-//GLM_FUNC_QUALIFIER typename detail::tvec3<T, P>::bool_type notEqual
+//GLM_FUNC_QUALIFIER typename tvec3<T, P>::bool_type notEqual
 //(
-//	detail::tvec3<T, P> const & x, 
-//	detail::tvec3<T, P> const & y
+//	tvec3<T, P> const & x, 
+//	tvec3<T, P> const & y
 //)
 //{
 //	GLM_STATIC_ASSERT(
@@ -289,14 +289,14 @@
 //		detail::type<valType>::is_uint || 
 //		detail::type<valType>::is_bool);
 //
-//	return typename detail::tvec3<T, P>::bool_type(x.x != y.x, x.y != y.y, x.z != y.z);
+//	return typename tvec3<T, P>::bool_type(x.x != y.x, x.y != y.y, x.z != y.z);
 //}
 //
 //template <typename valType>
-//GLM_FUNC_QUALIFIER typename detail::tvec4<T, P>::bool_type notEqual
+//GLM_FUNC_QUALIFIER typename tvec4<T, P>::bool_type notEqual
 //(
-//	detail::tvec4<T, P> const & x, 
-//	detail::tvec4<T, P> const & y
+//	tvec4<T, P> const & x, 
+//	tvec4<T, P> const & y
 //)
 //{
 //	GLM_STATIC_ASSERT(
@@ -305,62 +305,62 @@
 //		detail::type<valType>::is_uint || 
 //		detail::type<valType>::is_bool);
 //
-//	return typename detail::tvec4<T, P>::bool_type(x.x != y.x, x.y != y.y, x.z != y.z, x.w != y.w);
+//	return typename tvec4<T, P>::bool_type(x.x != y.x, x.y != y.y, x.z != y.z, x.w != y.w);
 //}
 //
 //// any
-//GLM_FUNC_QUALIFIER bool any(detail::tvec2<bool> const & x)
+//GLM_FUNC_QUALIFIER bool any(tvec2<bool> const & x)
 //{
 //	return x.x || x.y;
 //}
 //
-//GLM_FUNC_QUALIFIER bool any(detail::tvec3<bool> const & x)
+//GLM_FUNC_QUALIFIER bool any(tvec3<bool> const & x)
 //{
 //    return x.x || x.y || x.z;
 //}
 //
-//GLM_FUNC_QUALIFIER bool any(detail::tvec4<bool> const & x)
+//GLM_FUNC_QUALIFIER bool any(tvec4<bool> const & x)
 //{
 //    return x.x || x.y || x.z || x.w;
 //}
 //
 //// all
-//GLM_FUNC_QUALIFIER bool all(const detail::tvec2<bool>& x)
+//GLM_FUNC_QUALIFIER bool all(const tvec2<bool>& x)
 //{
 //    return x.x && x.y;
 //}
 //
-//GLM_FUNC_QUALIFIER bool all(const detail::tvec3<bool>& x)
+//GLM_FUNC_QUALIFIER bool all(const tvec3<bool>& x)
 //{
 //    return x.x && x.y && x.z;
 //}
 //
-//GLM_FUNC_QUALIFIER bool all(const detail::tvec4<bool>& x)
+//GLM_FUNC_QUALIFIER bool all(const tvec4<bool>& x)
 //{
 //    return x.x && x.y && x.z && x.w;
 //}
 //
 //// not
-//GLM_FUNC_QUALIFIER detail::tvec2<bool>::bool_type not_
+//GLM_FUNC_QUALIFIER tvec2<bool>::bool_type not_
 //(
-//	detail::tvec2<bool> const & v
+//	tvec2<bool> const & v
 //)
 //{
-//    return detail::tvec2<bool>::bool_type(!v.x, !v.y);
+//    return tvec2<bool>::bool_type(!v.x, !v.y);
 //}
 //
-//GLM_FUNC_QUALIFIER detail::tvec3<bool>::bool_type not_
+//GLM_FUNC_QUALIFIER tvec3<bool>::bool_type not_
 //(
-//	detail::tvec3<bool> const & v
+//	tvec3<bool> const & v
 //)
 //{
-//    return detail::tvec3<bool>::bool_type(!v.x, !v.y, !v.z);
+//    return tvec3<bool>::bool_type(!v.x, !v.y, !v.z);
 //}
 //
-//GLM_FUNC_QUALIFIER detail::tvec4<bool>::bool_type not_
+//GLM_FUNC_QUALIFIER tvec4<bool>::bool_type not_
 //(
-//	detail::tvec4<bool> const & v
+//	tvec4<bool> const & v
 //)
 //{
-//    return detail::tvec4<bool>::bool_type(!v.x, !v.y, !v.z, !v.w);
+//    return tvec4<bool>::bool_type(!v.x, !v.y, !v.z, !v.w);
 //}

glm/detail/setup.hpp

@@ -22,7 +22,7 @@
 ///
 /// @ref core
 /// @file glm/core/setup.hpp
-/// @date 2006-11-13 / 2013-03-30
+/// @date 2006-11-13 / 2014-10-05
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
 
@@ -548,6 +548,18 @@
 	((GLM_LANG & GLM_LANG_CXX0X_FLAG) && ((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC10))) || \
 	((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC43)))
 
+#define GLM_HAS_TEMPLATE_ALIASES ( \
+	(GLM_LANG & GLM_LANG_CXX11_FLAG) || \
+	((GLM_LANG & GLM_LANG_CXX0X_FLAG) && ((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC12))) || \
+	((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC47)) || \
+	__has_feature(cxx_alias_templates))
+
+#define GLM_HAS_RANGE_FOR ( \
+	(GLM_LANG & GLM_LANG_CXX11_FLAG) || \
+	((GLM_LANG & GLM_LANG_CXX0X_FLAG) && ((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC11))) || \
+	((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC46)) || \
+	__has_feature(cxx_range_for))
+
 // OpenMP
 #ifdef _OPENMP 
 #	if(GLM_COMPILER & GLM_COMPILER_GCC)

glm/detail/type_mat.hpp

@@ -33,6 +33,10 @@
 namespace glm{
 namespace detail
 {
+	template <typename T, precision P, template <class, precision> class colType, template <class, precision> class rowType>
+	struct outerProduct_trait{};
+}//namespace detail
+
 	template <typename T, precision P> struct tvec2;
 	template <typename T, precision P> struct tvec3;
 	template <typename T, precision P> struct tvec4;
@@ -46,13 +50,6 @@ namespace detail
 	template <typename T, precision P> struct tmat4x3;
 	template <typename T, precision P> struct tmat4x4;
 
-	template <typename T, precision P, template <class, precision> class colType, template <class, precision> class rowType>
-	struct outerProduct_trait{};
-
-	template <template <class, precision> class matType, typename T, precision P>
-	struct compute_inverse{};
-}//namespace detail
-
 	/// @addtogroup core_precision
 	/// @{
 	
@@ -61,42 +58,42 @@ namespace detail
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat2x2<float, lowp>		lowp_mat2;
+	typedef tmat2x2<float, lowp>		lowp_mat2;
 	
 	/// 2 columns of 2 components matrix of medium precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat2x2<float, mediump>		mediump_mat2;
+	typedef tmat2x2<float, mediump>		mediump_mat2;
 	
 	/// 2 columns of 2 components matrix of high precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat2x2<float, highp>		highp_mat2;
+	typedef tmat2x2<float, highp>		highp_mat2;
 	
 	/// 2 columns of 2 components matrix of low precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat2x2<float, lowp>		lowp_mat2x2;
+	typedef tmat2x2<float, lowp>		lowp_mat2x2;
 	
 	/// 2 columns of 2 components matrix of medium precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat2x2<float, mediump>		mediump_mat2x2;
+	typedef tmat2x2<float, mediump>		mediump_mat2x2;
 	
 	/// 2 columns of 2 components matrix of high precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat2x2<float, highp>		highp_mat2x2;
+	typedef tmat2x2<float, highp>		highp_mat2x2;
 	
 	/// @}
 	
@@ -108,21 +105,21 @@ namespace detail
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat2x3<float, lowp>		lowp_mat2x3;
+	typedef tmat2x3<float, lowp>		lowp_mat2x3;
 	
 	/// 2 columns of 3 components matrix of medium precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat2x3<float, mediump>		mediump_mat2x3;
+	typedef tmat2x3<float, mediump>		mediump_mat2x3;
 	
 	/// 2 columns of 3 components matrix of high precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat2x3<float, highp>		highp_mat2x3;
+	typedef tmat2x3<float, highp>		highp_mat2x3;
 	
 	/// @}
 	
@@ -134,21 +131,21 @@ namespace detail
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat2x4<float, lowp>		lowp_mat2x4;
+	typedef tmat2x4<float, lowp>		lowp_mat2x4;
 	
 	/// 2 columns of 4 components matrix of medium precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat2x4<float, mediump>		mediump_mat2x4;
+	typedef tmat2x4<float, mediump>		mediump_mat2x4;
 	
 	/// 2 columns of 4 components matrix of high precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat2x4<float, highp>		highp_mat2x4;
+	typedef tmat2x4<float, highp>		highp_mat2x4;
 	
 	/// @}
 	
@@ -160,21 +157,21 @@ namespace detail
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat3x2<float, lowp>		lowp_mat3x2;
+	typedef tmat3x2<float, lowp>		lowp_mat3x2;
 	
 	/// 3 columns of 2 components matrix of medium precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat3x2<float, mediump>		mediump_mat3x2;
+	typedef tmat3x2<float, mediump>		mediump_mat3x2;
 	
 	/// 3 columns of 2 components matrix of high precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat3x2<float, highp>		highp_mat3x2;
+	typedef tmat3x2<float, highp>		highp_mat3x2;
 	
 	/// @}
 	
@@ -186,42 +183,42 @@ namespace detail
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat3x3<float, lowp>		lowp_mat3;
+	typedef tmat3x3<float, lowp>		lowp_mat3;
 	
 	/// 3 columns of 3 components matrix of medium precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat3x3<float, mediump>		mediump_mat3;
+	typedef tmat3x3<float, mediump>		mediump_mat3;
 	
 	/// 3 columns of 3 components matrix of high precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat3x3<float, highp>		highp_mat3;
+	typedef tmat3x3<float, highp>		highp_mat3;
 	
 	/// 3 columns of 3 components matrix of low precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat3x3<float, lowp>		lowp_mat3x3;
+	typedef tmat3x3<float, lowp>		lowp_mat3x3;
 	
 	/// 3 columns of 3 components matrix of medium precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat3x3<float, mediump>		mediump_mat3x3;
+	typedef tmat3x3<float, mediump>		mediump_mat3x3;
 	
 	/// 3 columns of 3 components matrix of high precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat3x3<float, highp>		highp_mat3x3;
+	typedef tmat3x3<float, highp>		highp_mat3x3;
 	
 	/// @}
 	
@@ -233,21 +230,21 @@ namespace detail
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat3x4<float, lowp>		lowp_mat3x4;
+	typedef tmat3x4<float, lowp>		lowp_mat3x4;
 	
 	/// 3 columns of 4 components matrix of medium precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat3x4<float, mediump>		mediump_mat3x4;
+	typedef tmat3x4<float, mediump>		mediump_mat3x4;
 	
 	/// 3 columns of 4 components matrix of high precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat3x4<float, highp>		highp_mat3x4;
+	typedef tmat3x4<float, highp>		highp_mat3x4;
 	
 	/// @}
 	
@@ -259,21 +256,21 @@ namespace detail
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat4x2<float, lowp>		lowp_mat4x2;
+	typedef tmat4x2<float, lowp>		lowp_mat4x2;
 	
 	/// 4 columns of 2 components matrix of medium precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat4x2<float, mediump>		mediump_mat4x2;
+	typedef tmat4x2<float, mediump>		mediump_mat4x2;
 	
 	/// 4 columns of 2 components matrix of high precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat4x2<float, highp>		highp_mat4x2;
+	typedef tmat4x2<float, highp>		highp_mat4x2;
 	
 	/// @}
 	
@@ -285,21 +282,21 @@ namespace detail
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat4x3<float, lowp>		lowp_mat4x3;
+	typedef tmat4x3<float, lowp>		lowp_mat4x3;
 	
 	/// 4 columns of 3 components matrix of medium precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat4x3<float, mediump>		mediump_mat4x3;
+	typedef tmat4x3<float, mediump>		mediump_mat4x3;
 	
 	/// 4 columns of 3 components matrix of high precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat4x3<float, highp>		highp_mat4x3;
+	typedef tmat4x3<float, highp>		highp_mat4x3;
 	
 	/// @}
 	
@@ -312,42 +309,42 @@ namespace detail
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat4x4<float, lowp>		lowp_mat4;
+	typedef tmat4x4<float, lowp>		lowp_mat4;
 	
 	/// 4 columns of 4 components matrix of medium precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat4x4<float, mediump>		mediump_mat4;
+	typedef tmat4x4<float, mediump>		mediump_mat4;
 	
 	/// 4 columns of 4 components matrix of high precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat4x4<float, highp>		highp_mat4;
+	typedef tmat4x4<float, highp>		highp_mat4;
 	
 	/// 4 columns of 4 components matrix of low precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat4x4<float, lowp>		lowp_mat4x4;
+	typedef tmat4x4<float, lowp>		lowp_mat4x4;
 	
 	/// 4 columns of 4 components matrix of medium precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat4x4<float, mediump>		mediump_mat4x4;
+	typedef tmat4x4<float, mediump>		mediump_mat4x4;
 	
 	/// 4 columns of 4 components matrix of high precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat4x4<float, highp>		highp_mat4x4;
+	typedef tmat4x4<float, highp>		highp_mat4x4;
 	
 	/// @}
 	
@@ -450,37 +447,37 @@ namespace detail
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat2x2<double, lowp>		lowp_dmat2;
+	typedef tmat2x2<double, lowp>		lowp_dmat2;
 	
 	/// 2 columns of 2 components matrix of medium precision floating-point numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat2x2<double, mediump>	mediump_dmat2;
+	typedef tmat2x2<double, mediump>	mediump_dmat2;
 	
 	/// 2 columns of 2 components matrix of high precision floating-point numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat2x2<double, highp>		highp_dmat2;
+	typedef tmat2x2<double, highp>		highp_dmat2;
 	
 	/// 2 columns of 2 components matrix of low precision floating-point numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat2x2<double, lowp>		lowp_dmat2x2;
+	typedef tmat2x2<double, lowp>		lowp_dmat2x2;
 	
 	/// 2 columns of 2 components matrix of medium precision floating-point numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat2x2<double, mediump>	mediump_dmat2x2;
+	typedef tmat2x2<double, mediump>	mediump_dmat2x2;
 	
 	/// 2 columns of 2 components matrix of high precision floating-point numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat2x2<double, highp>		highp_dmat2x2;
+	typedef tmat2x2<double, highp>		highp_dmat2x2;
 	
 	/// @}
 	
@@ -491,19 +488,19 @@ namespace detail
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat2x3<double, lowp>		lowp_dmat2x3;
+	typedef tmat2x3<double, lowp>		lowp_dmat2x3;
 	
 	/// 2 columns of 3 components matrix of medium precision floating-point numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat2x3<double, mediump>	mediump_dmat2x3;
+	typedef tmat2x3<double, mediump>	mediump_dmat2x3;
 	
 	/// 2 columns of 3 components matrix of high precision floating-point numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat2x3<double, highp>		highp_dmat2x3;
+	typedef tmat2x3<double, highp>		highp_dmat2x3;
 	
 	/// @}
 	
@@ -514,19 +511,19 @@ namespace detail
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat2x4<double, lowp>		lowp_dmat2x4;
+	typedef tmat2x4<double, lowp>		lowp_dmat2x4;
 	
 	/// 2 columns of 4 components matrix of medium precision floating-point numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat2x4<double, mediump>	mediump_dmat2x4;
+	typedef tmat2x4<double, mediump>	mediump_dmat2x4;
 	
 	/// 2 columns of 4 components matrix of high precision floating-point numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat2x4<double, highp>		highp_dmat2x4;
+	typedef tmat2x4<double, highp>		highp_dmat2x4;
 	
 	/// @}
 	
@@ -537,19 +534,19 @@ namespace detail
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat3x2<double, lowp>		lowp_dmat3x2;
+	typedef tmat3x2<double, lowp>		lowp_dmat3x2;
 	
 	/// 3 columns of 2 components matrix of medium precision floating-point numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat3x2<double, mediump>	mediump_dmat3x2;
+	typedef tmat3x2<double, mediump>	mediump_dmat3x2;
 	
 	/// 3 columns of 2 components matrix of high precision floating-point numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat3x2<double, highp>		highp_dmat3x2;
+	typedef tmat3x2<double, highp>		highp_dmat3x2;
 	
 	/// @}
 	
@@ -560,37 +557,37 @@ namespace detail
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat3x3<float, lowp>		lowp_dmat3;
+	typedef tmat3x3<float, lowp>		lowp_dmat3;
 	
 	/// 3 columns of 3 components matrix of medium precision floating-point numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat3x3<double, mediump>	mediump_dmat3;
+	typedef tmat3x3<double, mediump>	mediump_dmat3;
 	
 	/// 3 columns of 3 components matrix of high precision floating-point numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat3x3<double, highp>		highp_dmat3;
+	typedef tmat3x3<double, highp>		highp_dmat3;
 	
 	/// 3 columns of 3 components matrix of low precision floating-point numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat3x3<double, lowp>		lowp_dmat3x3;
+	typedef tmat3x3<double, lowp>		lowp_dmat3x3;
 	
 	/// 3 columns of 3 components matrix of medium precision floating-point numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat3x3<double, mediump>	mediump_dmat3x3;
+	typedef tmat3x3<double, mediump>	mediump_dmat3x3;
 	
 	/// 3 columns of 3 components matrix of high precision floating-point numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat3x3<double, highp>		highp_dmat3x3;
+	typedef tmat3x3<double, highp>		highp_dmat3x3;
 	
 	/// @}
 	
@@ -601,19 +598,19 @@ namespace detail
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat3x4<double, lowp>		lowp_dmat3x4;
+	typedef tmat3x4<double, lowp>		lowp_dmat3x4;
 	
 	/// 3 columns of 4 components matrix of medium precision floating-point numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat3x4<double, mediump>	mediump_dmat3x4;
+	typedef tmat3x4<double, mediump>	mediump_dmat3x4;
 	
 	/// 3 columns of 4 components matrix of high precision floating-point numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat3x4<double, highp>		highp_dmat3x4;
+	typedef tmat3x4<double, highp>		highp_dmat3x4;
 	
 	/// @}
 	
@@ -624,19 +621,19 @@ namespace detail
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat4x2<double, lowp>		lowp_dmat4x2;
+	typedef tmat4x2<double, lowp>		lowp_dmat4x2;
 	
 	/// 4 columns of 2 components matrix of medium precision floating-point numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat4x2<double, mediump>	mediump_dmat4x2;
+	typedef tmat4x2<double, mediump>	mediump_dmat4x2;
 	
 	/// 4 columns of 2 components matrix of high precision floating-point numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat4x2<double, highp>		highp_dmat4x2;
+	typedef tmat4x2<double, highp>		highp_dmat4x2;
 	
 	/// @}
 	
@@ -647,19 +644,19 @@ namespace detail
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat4x3<double, lowp>		lowp_dmat4x3;
+	typedef tmat4x3<double, lowp>		lowp_dmat4x3;
 	
 	/// 4 columns of 3 components matrix of medium precision floating-point numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat4x3<double, mediump>	mediump_dmat4x3;
+	typedef tmat4x3<double, mediump>	mediump_dmat4x3;
 	
 	/// 4 columns of 3 components matrix of high precision floating-point numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat4x3<double, highp>		highp_dmat4x3;
+	typedef tmat4x3<double, highp>		highp_dmat4x3;
 	
 	/// @}
 	
@@ -670,37 +667,37 @@ namespace detail
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat4x4<double, lowp>		lowp_dmat4;
+	typedef tmat4x4<double, lowp>		lowp_dmat4;
 	
 	/// 4 columns of 4 components matrix of medium precision floating-point numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat4x4<double, mediump>	mediump_dmat4;
+	typedef tmat4x4<double, mediump>	mediump_dmat4;
 	
 	/// 4 columns of 4 components matrix of high precision floating-point numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat4x4<double, highp>		highp_dmat4;
+	typedef tmat4x4<double, highp>		highp_dmat4;
 	
 	/// 4 columns of 4 components matrix of low precision floating-point numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat4x4<double, lowp>		lowp_dmat4x4;
+	typedef tmat4x4<double, lowp>		lowp_dmat4x4;
 	
 	/// 4 columns of 4 components matrix of medium precision floating-point numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat4x4<double, mediump>	mediump_dmat4x4;
+	typedef tmat4x4<double, mediump>	mediump_dmat4x4;
 	
 	/// 4 columns of 4 components matrix of high precision floating-point numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tmat4x4<double, highp>		highp_dmat4x4;
+	typedef tmat4x4<double, highp>		highp_dmat4x4;
 	
 	/// @}
 	

glm/detail/type_mat2x2.hpp

@@ -41,8 +41,7 @@
 #include <limits>
 #include <cstddef>
 
-namespace glm{
-namespace detail
+namespace glm
 {
 	template <typename T, precision P>
 	struct tmat2x2
@@ -242,7 +241,6 @@ namespace detail
 	template <typename T, precision P> 
 	GLM_FUNC_DECL tmat2x2<T, P> const operator-(
 		tmat2x2<T, P> const & m);
-} //namespace detail
 } //namespace glm
 
 #ifndef GLM_EXTERNAL_TEMPLATE

glm/detail/type_mat2x2.inl

@@ -29,6 +29,23 @@
 namespace glm{
 namespace detail
 {
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tmat2x2<T, P> compute_inverse(tmat2x2<T, P> const & m)
+	{
+		T OneOverDeterminant = static_cast<T>(1) / (
+			+ m[0][0] * m[1][1]
+			- m[1][0] * m[0][1]);
+
+		tmat2x2<T, P> Inverse(
+			+ m[1][1] * OneOverDeterminant,
+			- m[0][1] * OneOverDeterminant,
+			- m[1][0] * OneOverDeterminant,
+			+ m[0][0] * OneOverDeterminant);
+
+		return Inverse;
+	}
+}//namespace detail
+
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR length_t tmat2x2<T, P>::length() const {return 2;}
 
@@ -324,7 +341,7 @@ namespace detail
 	template <typename U>
 	GLM_FUNC_QUALIFIER tmat2x2<T, P>& tmat2x2<T, P>::operator/= (tmat2x2<U, P> const & m)
 	{
-		return (*this = *this * detail::compute_inverse<detail::tmat2x2, T, P>::call(m));
+		return (*this = *this * detail::compute_inverse<T, P>(m));
 	}
 
 	template <typename T, precision P>
@@ -359,25 +376,6 @@ namespace detail
 		return Result;
 	}
 
-	template <typename T, precision P>
-	struct compute_inverse<detail::tmat2x2, T, P>
-	{
-		GLM_FUNC_QUALIFIER static detail::tmat2x2<T, P> call(detail::tmat2x2<T, P> const & m)
-		{
-			T OneOverDeterminant = static_cast<T>(1) / (
-				+ m[0][0] * m[1][1]
-				- m[1][0] * m[0][1]);
-
-			detail::tmat2x2<T, P> Inverse(
-				+ m[1][1] * OneOverDeterminant,
-				- m[0][1] * OneOverDeterminant,
-				- m[1][0] * OneOverDeterminant,
-				+ m[0][0] * OneOverDeterminant);
-
-			return Inverse;
-		}
-	};
-
 	//////////////////////////////////////////////////////////////
 	// Binary operators
 
@@ -484,7 +482,7 @@ namespace detail
 		typename tmat2x2<T, P>::row_type const & v
 	)
 	{
-		return detail::tvec2<T, P>(
+		return tvec2<T, P>(
 			m[0][0] * v.x + m[1][0] * v.y,
 			m[0][1] * v.x + m[1][1] * v.y);
 	}
@@ -496,7 +494,7 @@ namespace detail
 		tmat2x2<T, P> const & m
 	)
 	{
-		return detail::tvec2<T, P>(
+		return tvec2<T, P>(
 			v.x * m[0][0] + v.y * m[0][1],
 			v.x * m[1][0] + v.y * m[1][1]);
 	}
@@ -580,7 +578,7 @@ namespace detail
 		typename tmat2x2<T, P>::row_type & v
 	)
 	{
-		return detail::compute_inverse<detail::tmat2x2, T, P>::call(m) * v;
+		return detail::compute_inverse<tmat2x2, T, P>::call(m) * v;
 	}
 
 	template <typename T, precision P>
@@ -590,7 +588,7 @@ namespace detail
 		tmat2x2<T, P> const & m
 	)
 	{
-		return v * detail::compute_inverse<detail::tmat2x2, T, P>::call(m);
+		return v * detail::compute_inverse<tmat2x2, T, P>::call(m);
 	}
 
 	template <typename T, precision P>
@@ -638,6 +636,4 @@ namespace detail
 	{
 		return (m1[0] != m2[0]) || (m1[1] != m2[1]);
 	}
-
-} //namespace detail
 } //namespace glm

glm/detail/type_mat2x3.hpp

@@ -41,8 +41,7 @@
 #include <limits>
 #include <cstddef>
 
-namespace glm{
-namespace detail
+namespace glm
 {
 	template <typename T, precision P>
 	struct tmat2x3
@@ -205,8 +204,6 @@ namespace detail
 	template <typename T, precision P>
 	GLM_FUNC_DECL tmat2x3<T, P> const operator- (
 		tmat2x3<T, P> const & m);
-
-}//namespace detail
 }//namespace glm
 
 #ifndef GLM_EXTERNAL_TEMPLATE

glm/detail/type_mat2x3.inl

@@ -26,8 +26,7 @@
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
 
-namespace glm{
-namespace detail
+namespace glm
 {
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR length_t tmat2x3<T, P>::length() const
@@ -584,5 +583,4 @@ namespace detail
 	{
 		return (m1[0] != m2[0]) || (m1[1] != m2[1]);
 	}
-} //namespace detail
 } //namespace glm

glm/detail/type_mat2x4.hpp

@@ -41,8 +41,7 @@
 #include <limits>
 #include <cstddef>
 
-namespace glm{
-namespace detail
+namespace glm
 {
 	template <typename T, precision P>
 	struct tmat2x4
@@ -207,8 +206,6 @@ namespace detail
 	template <typename T, precision P>
 	GLM_FUNC_DECL tmat2x4<T, P> const operator- (
 		tmat2x4<T, P> const & m);
-
-}//namespace detail
 }//namespace glm
 
 #ifndef GLM_EXTERNAL_TEMPLATE

glm/detail/type_mat2x4.inl

@@ -26,8 +26,7 @@
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
 
-namespace glm{
-namespace detail
+namespace glm
 {
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR length_t tmat2x4<T, P>::length() const
@@ -179,8 +178,8 @@ namespace detail
 		tmat2x2<T, P> const & m
 	)
 	{
-		this->value[0] = col_type(m[0], detail::tvec2<T, P>(0));
-		this->value[1] = col_type(m[1], detail::tvec2<T, P>(0));
+		this->value[0] = col_type(m[0], tvec2<T, P>(0));
+		this->value[1] = col_type(m[1], tvec2<T, P>(0));
 	}
 
 	template <typename T, precision P>
@@ -219,8 +218,8 @@ namespace detail
 		tmat3x2<T, P> const & m
 	)
 	{
-		this->value[0] = col_type(m[0], detail::tvec2<T, P>(0));
-		this->value[1] = col_type(m[1], detail::tvec2<T, P>(0));
+		this->value[0] = col_type(m[0], tvec2<T, P>(0));
+		this->value[1] = col_type(m[1], tvec2<T, P>(0));
 	}
 
 	template <typename T, precision P>
@@ -239,8 +238,8 @@ namespace detail
 		tmat4x2<T, P> const & m
 	)
 	{
-		this->value[0] = col_type(m[0], detail::tvec2<T, P>(T(0)));
-		this->value[1] = col_type(m[1], detail::tvec2<T, P>(T(0)));
+		this->value[0] = col_type(m[0], tvec2<T, P>(T(0)));
+		this->value[1] = col_type(m[1], tvec2<T, P>(T(0)));
 	}
 
 	template <typename T, precision P>
@@ -603,5 +602,4 @@ namespace detail
 	{
 		return (m1[0] != m2[0]) || (m1[1] != m2[1]);
 	}
-} //namespace detail
 } //namespace glm

glm/detail/type_mat3x2.hpp

@@ -41,8 +41,7 @@
 #include <limits>
 #include <cstddef>
 
-namespace glm{
-namespace detail
+namespace glm
 {
 	template <typename T, precision P>
 	struct tmat3x2
@@ -210,8 +209,6 @@ namespace detail
 	template <typename T, precision P>
 	GLM_FUNC_DECL tmat3x2<T, P> const operator-(
 		tmat3x2<T, P> const & m);
-
-}//namespace detail
 }//namespace glm
 
 #ifndef GLM_EXTERNAL_TEMPLATE

glm/detail/type_mat3x2.inl

@@ -26,8 +26,7 @@
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
 
-namespace glm{
-namespace detail
+namespace glm
 {
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR length_t tmat3x2<T, P>::length() const
@@ -616,6 +615,4 @@ namespace detail
 	{
 		return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]);
 	}
-
-} //namespace detail
 } //namespace glm

glm/detail/type_mat3x3.hpp

@@ -40,8 +40,7 @@
 #include <limits>
 #include <cstddef>
 
-namespace glm{
-namespace detail
+namespace glm
 {
 	template <typename T, precision P>
 	struct tmat3x3
@@ -244,8 +243,6 @@ namespace detail
 	template <typename T, precision P>
 	GLM_FUNC_DECL tmat3x3<T, P> const operator-(
 		tmat3x3<T, P> const & m);
-
-}//namespace detail
 }//namespace glm
 
 #ifndef GLM_EXTERNAL_TEMPLATE

glm/detail/type_mat3x3.inl

@@ -29,6 +29,29 @@
 namespace glm{
 namespace detail
 {
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tmat3x3<T, P> compute_inverse(tmat3x3<T, P> const & m)
+	{
+		T OneOverDeterminant = static_cast<T>(1) / (
+			+ m[0][0] * (m[1][1] * m[2][2] - m[2][1] * m[1][2])
+			- m[1][0] * (m[0][1] * m[2][2] - m[2][1] * m[0][2])
+			+ m[2][0] * (m[0][1] * m[1][2] - m[1][1] * m[0][2]));
+
+		tmat3x3<T, P> Inverse(tmat3x3<T, P>::_null);
+		Inverse[0][0] = + (m[1][1] * m[2][2] - m[2][1] * m[1][2]) * OneOverDeterminant;
+		Inverse[1][0] = - (m[1][0] * m[2][2] - m[2][0] * m[1][2]) * OneOverDeterminant;
+		Inverse[2][0] = + (m[1][0] * m[2][1] - m[2][0] * m[1][1]) * OneOverDeterminant;
+		Inverse[0][1] = - (m[0][1] * m[2][2] - m[2][1] * m[0][2]) * OneOverDeterminant;
+		Inverse[1][1] = + (m[0][0] * m[2][2] - m[2][0] * m[0][2]) * OneOverDeterminant;
+		Inverse[2][1] = - (m[0][0] * m[2][1] - m[2][0] * m[0][1]) * OneOverDeterminant;
+		Inverse[0][2] = + (m[0][1] * m[1][2] - m[1][1] * m[0][2]) * OneOverDeterminant;
+		Inverse[1][2] = - (m[0][0] * m[1][2] - m[1][0] * m[0][2]) * OneOverDeterminant;
+		Inverse[2][2] = + (m[0][0] * m[1][1] - m[1][0] * m[0][1]) * OneOverDeterminant;
+
+		return Inverse;
+	}
+}//namespace detail
+
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR length_t tmat3x3<T, P>::length() const
 	{
@@ -195,7 +218,7 @@ namespace detail
 	{
 		this->value[0] = col_type(m[0], value_type(0));
 		this->value[1] = col_type(m[1], value_type(0));
-		this->value[2] = col_type(detail::tvec2<T, P>(0), value_type(1));
+		this->value[2] = col_type(tvec2<T, P>(0), value_type(1));
 	}
 
 	template <typename T, precision P>
@@ -217,7 +240,7 @@ namespace detail
 	{
 		this->value[0] = m[0];
 		this->value[1] = m[1];
-		this->value[2] = col_type(detail::tvec2<T, P>(0), value_type(1));
+		this->value[2] = col_type(tvec2<T, P>(0), value_type(1));
 	}
 
 	template <typename T, precision P>
@@ -239,7 +262,7 @@ namespace detail
 	{
 		this->value[0] = col_type(m[0]);
 		this->value[1] = col_type(m[1]);
-		this->value[2] = col_type(detail::tvec2<T, P>(0), value_type(1));
+		this->value[2] = col_type(tvec2<T, P>(0), value_type(1));
 	}
 
 	template <typename T, precision P>
@@ -368,7 +391,7 @@ namespace detail
 	template <typename U>
 	GLM_FUNC_QUALIFIER tmat3x3<T, P> & tmat3x3<T, P>::operator/= (tmat3x3<U, P> const & m)
 	{
-		return (*this = *this * detail::compute_inverse<detail::tmat3x3, T, P>::call(m));
+		return (*this = *this * detail::compute_inverse<T, P>(m));
 	}
 
 	template <typename T, precision P>
@@ -405,31 +428,6 @@ namespace detail
 		return Result;
 	}
 
-	template <typename T, precision P>
-	struct compute_inverse<detail::tmat3x3, T, P>
-	{
-		static detail::tmat3x3<T, P> call(detail::tmat3x3<T, P> const & m)
-		{
-			T OneOverDeterminant = static_cast<T>(1) / (
-				+ m[0][0] * (m[1][1] * m[2][2] - m[2][1] * m[1][2])
-				- m[1][0] * (m[0][1] * m[2][2] - m[2][1] * m[0][2])
-				+ m[2][0] * (m[0][1] * m[1][2] - m[1][1] * m[0][2]));
-
-			detail::tmat3x3<T, P> Inverse(detail::tmat3x3<T, P>::_null);
-			Inverse[0][0] = + (m[1][1] * m[2][2] - m[2][1] * m[1][2]) * OneOverDeterminant;
-			Inverse[1][0] = - (m[1][0] * m[2][2] - m[2][0] * m[1][2]) * OneOverDeterminant;
-			Inverse[2][0] = + (m[1][0] * m[2][1] - m[2][0] * m[1][1]) * OneOverDeterminant;
-			Inverse[0][1] = - (m[0][1] * m[2][2] - m[2][1] * m[0][2]) * OneOverDeterminant;
-			Inverse[1][1] = + (m[0][0] * m[2][2] - m[2][0] * m[0][2]) * OneOverDeterminant;
-			Inverse[2][1] = - (m[0][0] * m[2][1] - m[2][0] * m[0][1]) * OneOverDeterminant;
-			Inverse[0][2] = + (m[0][1] * m[1][2] - m[1][1] * m[0][2]) * OneOverDeterminant;
-			Inverse[1][2] = - (m[0][0] * m[1][2] - m[1][0] * m[0][2]) * OneOverDeterminant;
-			Inverse[2][2] = + (m[0][0] * m[1][1] - m[1][0] * m[0][1]) * OneOverDeterminant;
-
-			return Inverse;
-		}
-	};
-
 	//////////////////////////////////////////////////////////////
 	// Binary operators
 
@@ -674,7 +672,7 @@ namespace detail
 		typename tmat3x3<T, P>::row_type const & v
 	)
 	{
-		return detail::compute_inverse<detail::tmat3x3, T, P>::call(m) * v;
+		return detail::compute_inverse<tmat3x3, T, P>::call(m) * v;
 	}
 
 	template <typename T, precision P>
@@ -684,7 +682,7 @@ namespace detail
 		tmat3x3<T, P> const & m
 	)
 	{
-		return v * detail::compute_inverse<detail::tmat3x3, T, P>::call(m);
+		return v * detail::compute_inverse<tmat3x3, T, P>::call(m);
 	}
 
 	template <typename T, precision P>
@@ -733,6 +731,4 @@ namespace detail
 	{
 		return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]);
 	}
-
-} //namespace detail
 } //namespace glm

glm/detail/type_mat3x4.hpp

@@ -41,8 +41,7 @@
 #include <limits>
 #include <cstddef>
 
-namespace glm{
-namespace detail
+namespace glm
 {
 	template <typename T, precision P>
 	struct tmat3x4
@@ -210,8 +209,6 @@ namespace detail
 	template <typename T, precision P>
 	GLM_FUNC_DECL tmat3x4<T, P> const operator-(
 		tmat3x4<T, P> const & m);
-
-}//namespace detail
 }//namespace glm
 
 #ifndef GLM_EXTERNAL_TEMPLATE

glm/detail/type_mat3x4.inl

@@ -26,8 +26,7 @@
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
 
-namespace glm{
-namespace detail
+namespace glm
 {
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR length_t tmat3x4<T, P>::length() const
@@ -189,8 +188,8 @@ namespace detail
 		tmat2x2<T, P> const & m
 	)
 	{
-		this->value[0] = col_type(m[0], detail::tvec2<T, P>(0));
-		this->value[1] = col_type(m[1], detail::tvec2<T, P>(0));
+		this->value[0] = col_type(m[0], tvec2<T, P>(0));
+		this->value[1] = col_type(m[1], tvec2<T, P>(0));
 		this->value[2] = col_type(T(0), T(0), T(1), T(0));
 	}
 
@@ -233,8 +232,8 @@ namespace detail
 		tmat3x2<T, P> const & m
 	)
 	{
-		this->value[0] = col_type(m[0], detail::tvec2<T, P>(0));
-		this->value[1] = col_type(m[1], detail::tvec2<T, P>(0));
+		this->value[0] = col_type(m[0], tvec2<T, P>(0));
+		this->value[1] = col_type(m[1], tvec2<T, P>(0));
 		this->value[2] = col_type(m[2], T(0), T(1));
 	}
 
@@ -255,9 +254,9 @@ namespace detail
 		tmat4x2<T, P> const & m
 	)
 	{
-		this->value[0] = col_type(m[0], detail::tvec2<T, P>(T(0)));
-		this->value[1] = col_type(m[1], detail::tvec2<T, P>(T(0)));
-		this->value[2] = col_type(m[2], detail::tvec2<T, P>(T(1), T(0)));
+		this->value[0] = col_type(m[0], tvec2<T, P>(T(0)));
+		this->value[1] = col_type(m[1], tvec2<T, P>(T(0)));
+		this->value[2] = col_type(m[2], tvec2<T, P>(T(1), T(0)));
 	}
 
 	template <typename T, precision P> 
@@ -649,5 +648,4 @@ namespace detail
 	{
 		return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]);
 	}
-} //namespace detail
 } //namespace glm

glm/detail/type_mat4x2.hpp

@@ -41,8 +41,7 @@
 #include <limits>
 #include <cstddef>
 
-namespace glm{
-namespace detail
+namespace glm
 {
 	template <typename T, precision P>
 	struct tmat4x2
@@ -216,8 +215,6 @@ namespace detail
 	template <typename T, precision P>
 	GLM_FUNC_DECL tmat4x2<T, P> const operator-(
 		tmat4x2<T, P> const & m);
-		
-}//namespace detail
 }//namespace glm
 
 #ifndef GLM_EXTERNAL_TEMPLATE

glm/detail/type_mat4x2.inl

@@ -26,8 +26,7 @@
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
 
-namespace glm{
-namespace detail
+namespace glm
 {
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR length_t tmat4x2<T, P>::length() const
@@ -668,5 +667,4 @@ namespace detail
 	{
 		return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]) || (m1[3] != m2[3]);
 	}
-} //namespace detail
 } //namespace glm

glm/detail/type_mat4x3.hpp

@@ -41,8 +41,7 @@
 #include <limits>
 #include <cstddef>
 
-namespace glm{
-namespace detail
+namespace glm
 {
 	template <typename T, precision P>
 	struct tmat4x3
@@ -216,8 +215,6 @@ namespace detail
 	template <typename T, precision P>
 	GLM_FUNC_DECL tmat4x3<T, P> const operator- (
 		tmat4x3<T, P> const & m);
-
-}//namespace detail
 }//namespace glm
 
 #ifndef GLM_EXTERNAL_TEMPLATE

glm/detail/type_mat4x3.inl

@@ -26,8 +26,7 @@
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
 
-namespace glm{
-namespace detail
+namespace glm
 {
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR length_t tmat4x3<T, P>::length() const
@@ -699,6 +698,5 @@ namespace detail
 	{
 		return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]) || (m1[3] != m2[3]);
 	}
-} //namespace detail
 } //namespace glm
 

glm/detail/type_mat4x4.hpp

@@ -34,8 +34,7 @@
 #include <limits>
 #include <cstddef>
 
-namespace glm{
-namespace detail
+namespace glm
 {
 	template <typename T, precision P>
 	struct tmat4x4
@@ -244,8 +243,6 @@ namespace detail
 	template <typename T, precision P>
 	GLM_FUNC_DECL tmat4x4<T, P> const operator-  (
 		tmat4x4<T, P> const & m);
-
-}//namespace detail
 }//namespace glm
 
 #ifndef GLM_EXTERNAL_TEMPLATE

glm/detail/type_mat4x4.inl

@@ -29,6 +29,65 @@
 namespace glm{
 namespace detail
 {
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tmat4x4<T, P> compute_inverse(tmat4x4<T, P> const & m)
+	{
+		T Coef00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
+		T Coef02 = m[1][2] * m[3][3] - m[3][2] * m[1][3];
+		T Coef03 = m[1][2] * m[2][3] - m[2][2] * m[1][3];
+
+		T Coef04 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
+		T Coef06 = m[1][1] * m[3][3] - m[3][1] * m[1][3];
+		T Coef07 = m[1][1] * m[2][3] - m[2][1] * m[1][3];
+
+		T Coef08 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
+		T Coef10 = m[1][1] * m[3][2] - m[3][1] * m[1][2];
+		T Coef11 = m[1][1] * m[2][2] - m[2][1] * m[1][2];
+
+		T Coef12 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
+		T Coef14 = m[1][0] * m[3][3] - m[3][0] * m[1][3];
+		T Coef15 = m[1][0] * m[2][3] - m[2][0] * m[1][3];
+
+		T Coef16 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
+		T Coef18 = m[1][0] * m[3][2] - m[3][0] * m[1][2];
+		T Coef19 = m[1][0] * m[2][2] - m[2][0] * m[1][2];
+
+		T Coef20 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
+		T Coef22 = m[1][0] * m[3][1] - m[3][0] * m[1][1];
+		T Coef23 = m[1][0] * m[2][1] - m[2][0] * m[1][1];
+
+		tvec4<T, P> Fac0(Coef00, Coef00, Coef02, Coef03);
+		tvec4<T, P> Fac1(Coef04, Coef04, Coef06, Coef07);
+		tvec4<T, P> Fac2(Coef08, Coef08, Coef10, Coef11);
+		tvec4<T, P> Fac3(Coef12, Coef12, Coef14, Coef15);
+		tvec4<T, P> Fac4(Coef16, Coef16, Coef18, Coef19);
+		tvec4<T, P> Fac5(Coef20, Coef20, Coef22, Coef23);
+
+		tvec4<T, P> Vec0(m[1][0], m[0][0], m[0][0], m[0][0]);
+		tvec4<T, P> Vec1(m[1][1], m[0][1], m[0][1], m[0][1]);
+		tvec4<T, P> Vec2(m[1][2], m[0][2], m[0][2], m[0][2]);
+		tvec4<T, P> Vec3(m[1][3], m[0][3], m[0][3], m[0][3]);
+
+		tvec4<T, P> Inv0(Vec1 * Fac0 - Vec2 * Fac1 + Vec3 * Fac2);
+		tvec4<T, P> Inv1(Vec0 * Fac0 - Vec2 * Fac3 + Vec3 * Fac4);
+		tvec4<T, P> Inv2(Vec0 * Fac1 - Vec1 * Fac3 + Vec3 * Fac5);
+		tvec4<T, P> Inv3(Vec0 * Fac2 - Vec1 * Fac4 + Vec2 * Fac5);
+
+		tvec4<T, P> SignA(+1, -1, +1, -1);
+		tvec4<T, P> SignB(-1, +1, -1, +1);
+		tmat4x4<T, P> Inverse(Inv0 * SignA, Inv1 * SignB, Inv2 * SignA, Inv3 * SignB);
+
+		tvec4<T, P> Row0(Inverse[0][0], Inverse[1][0], Inverse[2][0], Inverse[3][0]);
+
+		tvec4<T, P> Dot0(m[0] * Row0);
+		T Dot1 = (Dot0.x + Dot0.y) + (Dot0.z + Dot0.w);
+
+		T OneOverDeterminant = static_cast<T>(1) / Dot1;
+
+		return Inverse * OneOverDeterminant;
+	}
+}//namespace detail
+
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR length_t tmat4x4<T, P>::length() const
 	{
@@ -233,8 +292,8 @@ namespace detail
 		tmat2x2<T, P> const & m
 	)
 	{
-		this->value[0] = col_type(m[0], detail::tvec2<T, P>(0));
-		this->value[1] = col_type(m[1], detail::tvec2<T, P>(0));
+		this->value[0] = col_type(m[0], tvec2<T, P>(0));
+		this->value[1] = col_type(m[1], tvec2<T, P>(0));
 		this->value[2] = col_type(static_cast<T>(0));
 		this->value[3] = col_type(static_cast<T>(0), value_type(0), value_type(0), value_type(1));
 	}
@@ -269,9 +328,9 @@ namespace detail
 		tmat3x2<T, P> const & m
 	)
 	{
-		this->value[0] = col_type(m[0], detail::tvec2<T, P>(0));
-		this->value[1] = col_type(m[1], detail::tvec2<T, P>(0));
-		this->value[2] = col_type(m[2], detail::tvec2<T, P>(0));
+		this->value[0] = col_type(m[0], tvec2<T, P>(0));
+		this->value[1] = col_type(m[1], tvec2<T, P>(0));
+		this->value[2] = col_type(m[2], tvec2<T, P>(0));
 		this->value[3] = col_type(static_cast<T>(0), value_type(0), value_type(0), value_type(1));
 	}
 
@@ -293,8 +352,8 @@ namespace detail
 		tmat4x2<T, P> const & m
 	)
 	{
-		this->value[0] = col_type(m[0], detail::tvec2<T, P>(0));
-		this->value[1] = col_type(m[1], detail::tvec2<T, P>(0));
+		this->value[0] = col_type(m[0], tvec2<T, P>(0));
+		this->value[1] = col_type(m[1], tvec2<T, P>(0));
 		this->value[2] = col_type(T(0));
 		this->value[3] = col_type(T(0), T(0), T(0), T(1));
 	}
@@ -434,7 +493,7 @@ namespace detail
 	template <typename U>
 	GLM_FUNC_QUALIFIER tmat4x4<T, P> & tmat4x4<T, P>::operator/= (tmat4x4<U, P> const & m)
 	{
-		return (*this = *this * detail::compute_inverse<detail::tmat4x4, T, P>::call(m));
+		return (*this = *this * detail::compute_inverse<T, P>(m));
 	}
 
 	template <typename T, precision P>
@@ -473,67 +532,6 @@ namespace detail
 		return Result;
 	}
 
-	template <typename T, precision P>
-	struct compute_inverse<detail::tmat4x4, T, P>
-	{
-		static detail::tmat4x4<T, P> call(detail::tmat4x4<T, P> const & m)
-		{
-			T Coef00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
-			T Coef02 = m[1][2] * m[3][3] - m[3][2] * m[1][3];
-			T Coef03 = m[1][2] * m[2][3] - m[2][2] * m[1][3];
-
-			T Coef04 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
-			T Coef06 = m[1][1] * m[3][3] - m[3][1] * m[1][3];
-			T Coef07 = m[1][1] * m[2][3] - m[2][1] * m[1][3];
-
-			T Coef08 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
-			T Coef10 = m[1][1] * m[3][2] - m[3][1] * m[1][2];
-			T Coef11 = m[1][1] * m[2][2] - m[2][1] * m[1][2];
-
-			T Coef12 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
-			T Coef14 = m[1][0] * m[3][3] - m[3][0] * m[1][3];
-			T Coef15 = m[1][0] * m[2][3] - m[2][0] * m[1][3];
-
-			T Coef16 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
-			T Coef18 = m[1][0] * m[3][2] - m[3][0] * m[1][2];
-			T Coef19 = m[1][0] * m[2][2] - m[2][0] * m[1][2];
-
-			T Coef20 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
-			T Coef22 = m[1][0] * m[3][1] - m[3][0] * m[1][1];
-			T Coef23 = m[1][0] * m[2][1] - m[2][0] * m[1][1];
-
-			detail::tvec4<T, P> Fac0(Coef00, Coef00, Coef02, Coef03);
-			detail::tvec4<T, P> Fac1(Coef04, Coef04, Coef06, Coef07);
-			detail::tvec4<T, P> Fac2(Coef08, Coef08, Coef10, Coef11);
-			detail::tvec4<T, P> Fac3(Coef12, Coef12, Coef14, Coef15);
-			detail::tvec4<T, P> Fac4(Coef16, Coef16, Coef18, Coef19);
-			detail::tvec4<T, P> Fac5(Coef20, Coef20, Coef22, Coef23);
-
-			detail::tvec4<T, P> Vec0(m[1][0], m[0][0], m[0][0], m[0][0]);
-			detail::tvec4<T, P> Vec1(m[1][1], m[0][1], m[0][1], m[0][1]);
-			detail::tvec4<T, P> Vec2(m[1][2], m[0][2], m[0][2], m[0][2]);
-			detail::tvec4<T, P> Vec3(m[1][3], m[0][3], m[0][3], m[0][3]);
-
-			detail::tvec4<T, P> Inv0(Vec1 * Fac0 - Vec2 * Fac1 + Vec3 * Fac2);
-			detail::tvec4<T, P> Inv1(Vec0 * Fac0 - Vec2 * Fac3 + Vec3 * Fac4);
-			detail::tvec4<T, P> Inv2(Vec0 * Fac1 - Vec1 * Fac3 + Vec3 * Fac5);
-			detail::tvec4<T, P> Inv3(Vec0 * Fac2 - Vec1 * Fac4 + Vec2 * Fac5);
-
-			detail::tvec4<T, P> SignA(+1, -1, +1, -1);
-			detail::tvec4<T, P> SignB(-1, +1, -1, +1);
-			detail::tmat4x4<T, P> Inverse(Inv0 * SignA, Inv1 * SignB, Inv2 * SignA, Inv3 * SignB);
-
-			detail::tvec4<T, P> Row0(Inverse[0][0], Inverse[1][0], Inverse[2][0], Inverse[3][0]);
-
-			detail::tvec4<T, P> Dot0(m[0] * Row0);
-			T Dot1 = (Dot0.x + Dot0.y) + (Dot0.z + Dot0.w);
-
-			T OneOverDeterminant = static_cast<T>(1) / Dot1;
-
-			return Inverse * OneOverDeterminant;
-		}
-	};
-
 	// Binary operators
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tmat4x4<T, P> operator+
@@ -809,7 +807,7 @@ namespace detail
 		typename tmat4x4<T, P>::row_type const & v
 	)
 	{
-		return detail::compute_inverse<detail::tmat4x4, T, P>::call(m) * v;
+		return detail::compute_inverse<tmat4x4, T, P>::call(m) * v;
 	}
 
 	template <typename T, precision P>
@@ -819,7 +817,7 @@ namespace detail
 		tmat4x4<T, P> const & m
 	)
 	{
-		return v * detail::compute_inverse<detail::tmat4x4, T, P>::call(m);
+		return v * detail::compute_inverse<tmat4x4, T, P>::call(m);
 	}
 
 	template <typename T, precision P>
@@ -897,6 +895,4 @@ namespace detail
 	{
 		return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]) || (m1[3] != m2[3]);
 	}
-
-} //namespace detail
-} //namespace glm
+}//namespace glm

glm/detail/type_vec.hpp

@@ -22,7 +22,7 @@
 ///
 /// @ref core
 /// @file glm/core/type_vec.hpp
-/// @date 2010-01-26 / 2011-06-15
+/// @date 2010-01-26 / 2014-10-05
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
 
@@ -31,246 +31,244 @@
 #include "precision.hpp"
 #include "type_int.hpp"
 
-namespace glm{
-namespace detail
+namespace glm
 {
 	template <typename T, precision P> struct tvec1;
 	template <typename T, precision P> struct tvec2;
 	template <typename T, precision P> struct tvec3;
 	template <typename T, precision P> struct tvec4;
-}//namespace detail
-	
-	typedef detail::tvec1<float, highp>		highp_vec1_t;
-	typedef detail::tvec1<float, mediump>	mediump_vec1_t;
-	typedef detail::tvec1<float, lowp>		lowp_vec1_t;
-	typedef detail::tvec1<int, highp>		highp_ivec1_t;
-	typedef detail::tvec1<int, mediump>		mediump_ivec1_t;
-	typedef detail::tvec1<int, lowp>		lowp_ivec1_t;
-	typedef detail::tvec1<uint, highp>		highp_uvec1_t;
-	typedef detail::tvec1<uint, mediump>	mediump_uvec1_t;
-	typedef detail::tvec1<uint, lowp>		lowp_uvec1_t;
-	typedef detail::tvec1<bool, highp>		highp_bvec1_t;
-	typedef detail::tvec1<bool, mediump>	mediump_bvec1_t;
-	typedef detail::tvec1<bool, lowp>		lowp_bvec1_t;
-	
+
+	typedef tvec1<float, highp>		highp_vec1_t;
+	typedef tvec1<float, mediump>	mediump_vec1_t;
+	typedef tvec1<float, lowp>		lowp_vec1_t;
+	typedef tvec1<int, highp>		highp_ivec1_t;
+	typedef tvec1<int, mediump>		mediump_ivec1_t;
+	typedef tvec1<int, lowp>		lowp_ivec1_t;
+	typedef tvec1<uint, highp>		highp_uvec1_t;
+	typedef tvec1<uint, mediump>	mediump_uvec1_t;
+	typedef tvec1<uint, lowp>		lowp_uvec1_t;
+	typedef tvec1<bool, highp>		highp_bvec1_t;
+	typedef tvec1<bool, mediump>	mediump_bvec1_t;
+	typedef tvec1<bool, lowp>		lowp_bvec1_t;
+
 	/// @addtogroup core_precision
 	/// @{
-	
+
 	/// 2 components vector of high single-precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tvec2<float, highp>		highp_vec2;
-	
+	typedef tvec2<float, highp>		highp_vec2;
+
 	/// 2 components vector of medium single-precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tvec2<float, mediump>	mediump_vec2;
-	
+	typedef tvec2<float, mediump>	mediump_vec2;
+
 	/// 2 components vector of low single-precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tvec2<float, lowp>		lowp_vec2;
-	
+	typedef tvec2<float, lowp>		lowp_vec2;
+
 	/// 2 components vector of high double-precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tvec2<double, highp>	highp_dvec2;
-	
+	typedef tvec2<double, highp>	highp_dvec2;
+
 	/// 2 components vector of medium double-precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tvec2<double, mediump>	mediump_dvec2;
-	
+	typedef tvec2<double, mediump>	mediump_dvec2;
+
 	/// 2 components vector of low double-precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tvec2<double, lowp>		lowp_dvec2;
-	
+	typedef tvec2<double, lowp>		lowp_dvec2;
+
 	/// 2 components vector of high precision signed integer numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tvec2<int, highp>		highp_ivec2;
-	
+	typedef tvec2<int, highp>		highp_ivec2;
+
 	/// 2 components vector of medium precision signed integer numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tvec2<int, mediump>		mediump_ivec2;
-	
+	typedef tvec2<int, mediump>		mediump_ivec2;
+
 	/// 2 components vector of low precision signed integer numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tvec2<int, lowp>		lowp_ivec2;
-	
+	typedef tvec2<int, lowp>		lowp_ivec2;
+
 	/// 2 components vector of high precision unsigned integer numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tvec2<uint, highp>		highp_uvec2;
-	
+	typedef tvec2<uint, highp>		highp_uvec2;
+
 	/// 2 components vector of medium precision unsigned integer numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tvec2<uint, mediump>	mediump_uvec2;
-	
+	typedef tvec2<uint, mediump>	mediump_uvec2;
+
 	/// 2 components vector of low precision unsigned integer numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tvec2<uint, lowp>		lowp_uvec2;
+	typedef tvec2<uint, lowp>		lowp_uvec2;
 
 	/// 2 components vector of high precision bool numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tvec2<bool, highp>		highp_bvec2;
-	
+	typedef tvec2<bool, highp>		highp_bvec2;
+
 	/// 2 components vector of medium precision bool numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tvec2<bool, mediump>	mediump_bvec2;
-	
+	typedef tvec2<bool, mediump>	mediump_bvec2;
+
 	/// 2 components vector of low precision bool numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tvec2<bool, lowp>		lowp_bvec2;
-	
+	typedef tvec2<bool, lowp>		lowp_bvec2;
+
 	/// @}
-	
-	
+
+
 	/// @addtogroup core_precision
 	/// @{
-	
+
 	/// 3 components vector of high single-precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tvec3<float, highp>		highp_vec3;
-	
+	typedef tvec3<float, highp>		highp_vec3;
+
 	/// 3 components vector of medium single-precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tvec3<float, mediump>	mediump_vec3;
-	
+	typedef tvec3<float, mediump>	mediump_vec3;
+
 	/// 3 components vector of low single-precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tvec3<float, lowp>		lowp_vec3;
-	
+	typedef tvec3<float, lowp>		lowp_vec3;
+
 	/// 3 components vector of high double-precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tvec3<double, highp>	highp_dvec3;
-	
+	typedef tvec3<double, highp>	highp_dvec3;
+
 	/// 3 components vector of medium double-precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tvec3<double, mediump>	mediump_dvec3;
-	
+	typedef tvec3<double, mediump>	mediump_dvec3;
+
 	/// 3 components vector of low double-precision floating-point numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tvec3<double, lowp>		lowp_dvec3;
-	
+	typedef tvec3<double, lowp>		lowp_dvec3;
+
 	/// 3 components vector of high precision signed integer numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tvec3<int, highp>		highp_ivec3;
-	
+	typedef tvec3<int, highp>		highp_ivec3;
+
 	/// 3 components vector of medium precision signed integer numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tvec3<int, mediump>		mediump_ivec3;
-	
+	typedef tvec3<int, mediump>		mediump_ivec3;
+
 	/// 3 components vector of low precision signed integer numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tvec3<int, lowp>		lowp_ivec3;
-	
+	typedef tvec3<int, lowp>		lowp_ivec3;
+
 	/// 3 components vector of high precision unsigned integer numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tvec3<uint, highp>		highp_uvec3;
-	
+	typedef tvec3<uint, highp>		highp_uvec3;
+
 	/// 3 components vector of medium precision unsigned integer numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tvec3<uint, mediump>	mediump_uvec3;
-	
+	typedef tvec3<uint, mediump>	mediump_uvec3;
+
 	/// 3 components vector of low precision unsigned integer numbers.
 	/// There is no guarantee on the actual precision.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tvec3<uint, lowp>		lowp_uvec3;
-	
+	typedef tvec3<uint, lowp>		lowp_uvec3;
+
 	/// 3 components vector of high precision bool numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tvec3<bool, highp>		highp_bvec3;
-	
+	typedef tvec3<bool, highp>		highp_bvec3;
+
 	/// 3 components vector of medium precision bool numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tvec3<bool, mediump>	mediump_bvec3;
-	
+	typedef tvec3<bool, mediump>	mediump_bvec3;
+
 	/// 3 components vector of low precision bool numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tvec3<bool, lowp>		lowp_bvec3;
-	
+	typedef tvec3<bool, lowp>		lowp_bvec3;
+
 	/// @}
-	
+
 	/// @addtogroup core_precision
 	/// @{
 
@@ -278,100 +276,100 @@ namespace detail
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tvec4<float, highp>		highp_vec4;
-	
+	typedef tvec4<float, highp>		highp_vec4;
+
 	/// 4 components vector of medium single-precision floating-point numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tvec4<float, mediump>	mediump_vec4;
-	
+	typedef tvec4<float, mediump>	mediump_vec4;
+
 	/// 4 components vector of low single-precision floating-point numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tvec4<float, lowp>		lowp_vec4;
-	
+	typedef tvec4<float, lowp>		lowp_vec4;
+
 	/// 4 components vector of high double-precision floating-point numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tvec4<double, highp>	highp_dvec4;
-	
+	typedef tvec4<double, highp>	highp_dvec4;
+
 	/// 4 components vector of medium double-precision floating-point numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tvec4<double, mediump>	mediump_dvec4;
-	
+	typedef tvec4<double, mediump>	mediump_dvec4;
+
 	/// 4 components vector of low double-precision floating-point numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tvec4<double, lowp>		lowp_dvec4;
-	
+	typedef tvec4<double, lowp>		lowp_dvec4;
+
 	/// 4 components vector of high precision signed integer numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tvec4<int, highp>		highp_ivec4;
-	
+	typedef tvec4<int, highp>		highp_ivec4;
+
 	/// 4 components vector of medium precision signed integer numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tvec4<int, mediump>		mediump_ivec4;
-	
+	typedef tvec4<int, mediump>		mediump_ivec4;
+
 	/// 4 components vector of low precision signed integer numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tvec4<int, lowp>		lowp_ivec4;
-	
+	typedef tvec4<int, lowp>		lowp_ivec4;
+
 	/// 4 components vector of high precision unsigned integer numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tvec4<uint, highp>		highp_uvec4;
-	
+	typedef tvec4<uint, highp>		highp_uvec4;
+
 	/// 4 components vector of medium precision unsigned integer numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tvec4<uint, mediump>	mediump_uvec4;
-	
+	typedef tvec4<uint, mediump>	mediump_uvec4;
+
 	/// 4 components vector of low precision unsigned integer numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tvec4<uint, lowp>		lowp_uvec4;
+	typedef tvec4<uint, lowp>		lowp_uvec4;
 
 	/// 4 components vector of high precision bool numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tvec4<bool, highp>		highp_bvec4;
-	
+	typedef tvec4<bool, highp>		highp_bvec4;
+
 	/// 4 components vector of medium precision bool numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tvec4<bool, mediump>	mediump_bvec4;
-	
+	typedef tvec4<bool, mediump>	mediump_bvec4;
+
 	/// 4 components vector of low precision bool numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef detail::tvec4<bool, lowp>		lowp_bvec4;
-	
+	typedef tvec4<bool, lowp>		lowp_bvec4;
+
 	/// @}
-	
+
 	/// @addtogroup core_types
 	/// @{
-	
+
 	//////////////////////////
 	// Default float definition
-	
+
 #if(defined(GLM_PRECISION_LOWP_FLOAT))
 	typedef lowp_vec2			vec2;
 	typedef lowp_vec3			vec3;
@@ -385,12 +383,12 @@ namespace detail
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	typedef highp_vec2			vec2;
-	
+
 	//! 3 components vector of floating-point numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	typedef highp_vec3			vec3;
-	
+
 	//! 4 components vector of floating-point numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
@@ -399,7 +397,7 @@ namespace detail
 
 	//////////////////////////
 	// Default double definition
-	
+
 #if(defined(GLM_PRECISION_LOWP_DOUBLE))
 	typedef lowp_dvec2			dvec2;
 	typedef lowp_dvec3			dvec3;

glm/detail/type_vec1.hpp

@@ -39,8 +39,7 @@
 #endif //GLM_SWIZZLE
 #include <cstddef>
 
-namespace glm{
-namespace detail
+namespace glm
 {
 	template <typename T, precision P>
 	struct tvec1
@@ -264,8 +263,6 @@ namespace detail
 
 	template <typename T, precision P> 
 	GLM_FUNC_DECL tvec1<T, P> operator~(tvec1<T, P> const & v);
-
-}//namespace detail
 }//namespace glm
 
 #ifndef GLM_EXTERNAL_TEMPLATE

glm/detail/type_vec1.inl

@@ -26,8 +26,7 @@
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
 
-namespace glm{
-namespace detail
+namespace glm
 {
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR length_t tvec1<T, P>::length() const
@@ -807,6 +806,4 @@ namespace detail
 		return tvec1<T, P>(
 			~v.x);
 	}
-
-}//namespace detail
 }//namespace glm

glm/detail/type_vec2.hpp

@@ -39,8 +39,7 @@
 #endif //GLM_SWIZZLE
 #include <cstddef>
 
-namespace glm{
-namespace detail
+namespace glm
 {
 	template <typename T, precision P>
 	struct tvec2
@@ -85,7 +84,7 @@ namespace detail
 			union {T y, g, t;};
 
 #			ifdef GLM_SWIZZLE
-				GLM_SWIZZLE_GEN_VEC_FROM_VEC2(T, P, detail::tvec2, detail::tvec2, detail::tvec3, detail::tvec4)
+				GLM_SWIZZLE_GEN_VEC_FROM_VEC2(T, P, tvec2, tvec2, tvec3, tvec4)
 #			endif 
 #		endif
 
@@ -379,8 +378,6 @@ namespace detail
 
 	template <typename T, precision P>
 	GLM_FUNC_DECL tvec2<T, P> operator~(tvec2<T, P> const & v);
-
-}//namespace detail
 }//namespace glm
 
 #ifndef GLM_EXTERNAL_TEMPLATE

glm/detail/type_vec2.inl

@@ -26,8 +26,7 @@
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
 
-namespace glm{
-namespace detail
+namespace glm
 {
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR length_t tvec2<T, P>::length() const
@@ -910,6 +909,4 @@ namespace detail
 			~v.x,
 			~v.y);
 	}
-
-}//namespace detail
 }//namespace glm

glm/detail/type_vec3.hpp

@@ -39,8 +39,7 @@
 #endif //GLM_SWIZZLE
 #include <cstddef>
 
-namespace glm{
-namespace detail
+namespace glm
 {
 	template <typename T, precision P>
 	struct tvec3
@@ -86,7 +85,7 @@ namespace detail
 			union { T z, b, p; };
 
 #			ifdef GLM_SWIZZLE
-				GLM_SWIZZLE_GEN_VEC_FROM_VEC3(T, P, detail::tvec3, detail::tvec2, detail::tvec3, detail::tvec4)
+				GLM_SWIZZLE_GEN_VEC_FROM_VEC3(T, P, tvec3, tvec2, tvec3, tvec4)
 #			endif
 #		endif//GLM_LANG
 
@@ -396,8 +395,6 @@ namespace detail
 
 	template <typename T, precision P> 
 	GLM_FUNC_DECL tvec3<T, P> operator~(tvec3<T, P> const & v);
-
-}//namespace detail
 }//namespace glm
 
 #ifndef GLM_EXTERNAL_TEMPLATE

glm/detail/type_vec3.inl

@@ -26,8 +26,7 @@
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
 
-namespace glm{
-namespace detail
+namespace glm
 {
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR length_t tvec3<T, P>::length() const
@@ -876,6 +875,4 @@ namespace detail
 			~v.y,
 			~v.z);
 	}
-
-}//namespace detail
 }//namespace glm

glm/detail/type_vec4.hpp

@@ -40,8 +40,7 @@
 #endif //GLM_SWIZZLE
 #include <cstddef>
 
-namespace glm{
-namespace detail
+namespace glm
 {
 	template <typename T>
 	struct simd
@@ -125,7 +124,7 @@ namespace detail
 #			endif
 		
 #			ifdef GLM_SWIZZLE
-				GLM_SWIZZLE_GEN_VEC_FROM_VEC4(T, P, detail::tvec4, detail::tvec2, detail::tvec3, detail::tvec4)
+				GLM_SWIZZLE_GEN_VEC_FROM_VEC4(T, P, tvec4, tvec2, tvec3, tvec4)
 #			endif
 #		endif//GLM_LANG
 
@@ -410,8 +409,6 @@ namespace detail
 
 	template <typename T, precision P> 
 	GLM_FUNC_DECL tvec4<T, P> operator~(tvec4<T, P> const & v);
-
-}//namespace detail
 }//namespace glm
 
 #ifndef GLM_EXTERNAL_TEMPLATE

glm/detail/type_vec4.inl

@@ -26,8 +26,7 @@
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
 
-namespace glm{
-namespace detail
+namespace glm
 {
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR length_t tvec4<T, P>::length() const
@@ -1159,6 +1158,4 @@ namespace detail
 			~v.z,
 			~v.w);
 	}
-
-}//namespace detail
 }//namespace glm

glm/ext.hpp

@@ -128,8 +128,11 @@
 #include "./gtx/vector_query.hpp"
 #include "./gtx/wrap.hpp"
 
-#if GLM_LANG & GLM_LANG_CXX0X_FLAG
+#if GLM_HAS_TEMPLATE_ALIASES
 #	include "./gtx/scalar_multiplication.hpp"
+#endif
+
+#if GLM_HAS_RANGE_FOR
 #	include "./gtx/range.hpp"
 #endif
 

glm/gtc/epsilon.inl

@@ -125,26 +125,26 @@ namespace glm
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec4<bool, P> epsilonEqual
+	GLM_FUNC_QUALIFIER tvec4<bool, P> epsilonEqual
 	(
-		detail::tquat<T, P> const & x,
-		detail::tquat<T, P> const & y,
+		tquat<T, P> const & x,
+		tquat<T, P> const & y,
 		T const & epsilon
 	)
 	{
-		detail::tvec4<T, P> v(x.x - y.x, x.y - y.y, x.z - y.z, x.w - y.w);
-		return lessThan(abs(v), detail::tvec4<T, P>(epsilon));
+		tvec4<T, P> v(x.x - y.x, x.y - y.y, x.z - y.z, x.w - y.w);
+		return lessThan(abs(v), tvec4<T, P>(epsilon));
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec4<bool, P> epsilonNotEqual
+	GLM_FUNC_QUALIFIER tvec4<bool, P> epsilonNotEqual
 	(
-		detail::tquat<T, P> const & x,
-		detail::tquat<T, P> const & y,
+		tquat<T, P> const & x,
+		tquat<T, P> const & y,
 		T const & epsilon
 	)
 	{
-		detail::tvec4<T, P> v(x.x - y.x, x.y - y.y, x.z - y.z, x.w - y.w);
-		return greaterThanEqual(abs(v), detail::tvec4<T, P>(epsilon));
+		tvec4<T, P> v(x.x - y.x, x.y - y.y, x.z - y.z, x.w - y.w);
+		return greaterThanEqual(abs(v), tvec4<T, P>(epsilon));
 	}
 }//namespace glm

glm/gtc/matrix_integer.hpp

@@ -58,300 +58,300 @@ namespace glm
 
 	/// High-precision signed integer 2x2 matrix.
 	/// @see gtc_matrix_integer
-	typedef detail::tmat2x2<int, highp>				highp_imat2;
+	typedef tmat2x2<int, highp>				highp_imat2;
 
 	/// High-precision signed integer 3x3 matrix.
 	/// @see gtc_matrix_integer
-	typedef detail::tmat3x3<int, highp>				highp_imat3;
+	typedef tmat3x3<int, highp>				highp_imat3;
 
 	/// High-precision signed integer 4x4 matrix.
 	/// @see gtc_matrix_integer
-	typedef detail::tmat4x4<int, highp>				highp_imat4;
+	typedef tmat4x4<int, highp>				highp_imat4;
 
 	/// High-precision signed integer 2x2 matrix.
 	/// @see gtc_matrix_integer
-	typedef detail::tmat2x2<int, highp>				highp_imat2x2;
+	typedef tmat2x2<int, highp>				highp_imat2x2;
 
 	/// High-precision signed integer 2x3 matrix.
 	/// @see gtc_matrix_integer
-	typedef detail::tmat2x3<int, highp>				highp_imat2x3;
+	typedef tmat2x3<int, highp>				highp_imat2x3;
 
 	/// High-precision signed integer 2x4 matrix.
 	/// @see gtc_matrix_integer
-	typedef detail::tmat2x4<int, highp>				highp_imat2x4;
+	typedef tmat2x4<int, highp>				highp_imat2x4;
 
 	/// High-precision signed integer 3x2 matrix.
 	/// @see gtc_matrix_integer
-	typedef detail::tmat3x2<int, highp>				highp_imat3x2;
+	typedef tmat3x2<int, highp>				highp_imat3x2;
 
 	/// High-precision signed integer 3x3 matrix.
 	/// @see gtc_matrix_integer
-	typedef detail::tmat3x3<int, highp>				highp_imat3x3;
+	typedef tmat3x3<int, highp>				highp_imat3x3;
 
 	/// High-precision signed integer 3x4 matrix.
 	/// @see gtc_matrix_integer
-	typedef detail::tmat3x4<int, highp>				highp_imat3x4;
+	typedef tmat3x4<int, highp>				highp_imat3x4;
 
 	/// High-precision signed integer 4x2 matrix.
 	/// @see gtc_matrix_integer
-	typedef detail::tmat4x2<int, highp>				highp_imat4x2;
+	typedef tmat4x2<int, highp>				highp_imat4x2;
 
 	/// High-precision signed integer 4x3 matrix.
 	/// @see gtc_matrix_integer
-	typedef detail::tmat4x3<int, highp>				highp_imat4x3;
+	typedef tmat4x3<int, highp>				highp_imat4x3;
 
 	/// High-precision signed integer 4x4 matrix.
 	/// @see gtc_matrix_integer
-	typedef detail::tmat4x4<int, highp>				highp_imat4x4;
+	typedef tmat4x4<int, highp>				highp_imat4x4;
 
 
 	/// Medium-precision signed integer 2x2 matrix.
 	/// @see gtc_matrix_integer
-	typedef detail::tmat2x2<int, mediump>			mediump_imat2;
+	typedef tmat2x2<int, mediump>			mediump_imat2;
 
 	/// Medium-precision signed integer 3x3 matrix.
 	/// @see gtc_matrix_integer
-	typedef detail::tmat3x3<int, mediump>			mediump_imat3;
+	typedef tmat3x3<int, mediump>			mediump_imat3;
 
 	/// Medium-precision signed integer 4x4 matrix.
 	/// @see gtc_matrix_integer
-	typedef detail::tmat4x4<int, mediump>			mediump_imat4;
+	typedef tmat4x4<int, mediump>			mediump_imat4;
 
 
 	/// Medium-precision signed integer 2x2 matrix.
 	/// @see gtc_matrix_integer
-	typedef detail::tmat2x2<int, mediump>			mediump_imat2x2;
+	typedef tmat2x2<int, mediump>			mediump_imat2x2;
 
 	/// Medium-precision signed integer 2x3 matrix.
 	/// @see gtc_matrix_integer
-	typedef detail::tmat2x3<int, mediump>			mediump_imat2x3;
+	typedef tmat2x3<int, mediump>			mediump_imat2x3;
 
 	/// Medium-precision signed integer 2x4 matrix.
 	/// @see gtc_matrix_integer
-	typedef detail::tmat2x4<int, mediump>			mediump_imat2x4;
+	typedef tmat2x4<int, mediump>			mediump_imat2x4;
 
 	/// Medium-precision signed integer 3x2 matrix.
 	/// @see gtc_matrix_integer
-	typedef detail::tmat3x2<int, mediump>			mediump_imat3x2;
+	typedef tmat3x2<int, mediump>			mediump_imat3x2;
 
 	/// Medium-precision signed integer 3x3 matrix.
 	/// @see gtc_matrix_integer
-	typedef detail::tmat3x3<int, mediump>			mediump_imat3x3;
+	typedef tmat3x3<int, mediump>			mediump_imat3x3;
 
 	/// Medium-precision signed integer 3x4 matrix.
 	/// @see gtc_matrix_integer
-	typedef detail::tmat3x4<int, mediump>			mediump_imat3x4;
+	typedef tmat3x4<int, mediump>			mediump_imat3x4;
 
 	/// Medium-precision signed integer 4x2 matrix.
 	/// @see gtc_matrix_integer
-	typedef detail::tmat4x2<int, mediump>			mediump_imat4x2;
+	typedef tmat4x2<int, mediump>			mediump_imat4x2;
 
 	/// Medium-precision signed integer 4x3 matrix.
 	/// @see gtc_matrix_integer
-	typedef detail::tmat4x3<int, mediump>			mediump_imat4x3;
+	typedef tmat4x3<int, mediump>			mediump_imat4x3;
 
 	/// Medium-precision signed integer 4x4 matrix.
 	/// @see gtc_matrix_integer
-	typedef detail::tmat4x4<int, mediump>			mediump_imat4x4;
+	typedef tmat4x4<int, mediump>			mediump_imat4x4;
 
 
 	/// Low-precision signed integer 2x2 matrix.
 	/// @see gtc_matrix_integer
-	typedef detail::tmat2x2<int, lowp>				lowp_imat2;
+	typedef tmat2x2<int, lowp>				lowp_imat2;
 	
 	/// Low-precision signed integer 3x3 matrix.
 	/// @see gtc_matrix_integer
-	typedef detail::tmat3x3<int, lowp>				lowp_imat3;
+	typedef tmat3x3<int, lowp>				lowp_imat3;
 
 	/// Low-precision signed integer 4x4 matrix.
 	/// @see gtc_matrix_integer
-	typedef detail::tmat4x4<int, lowp>				lowp_imat4;
+	typedef tmat4x4<int, lowp>				lowp_imat4;
 
 
 	/// Low-precision signed integer 2x2 matrix.
 	/// @see gtc_matrix_integer
-	typedef detail::tmat2x2<int, lowp>				lowp_imat2x2;
+	typedef tmat2x2<int, lowp>				lowp_imat2x2;
 
 	/// Low-precision signed integer 2x3 matrix.
 	/// @see gtc_matrix_integer
-	typedef detail::tmat2x3<int, lowp>				lowp_imat2x3;
+	typedef tmat2x3<int, lowp>				lowp_imat2x3;
 
 	/// Low-precision signed integer 2x4 matrix.
 	/// @see gtc_matrix_integer
-	typedef detail::tmat2x4<int, lowp>				lowp_imat2x4;
+	typedef tmat2x4<int, lowp>				lowp_imat2x4;
 
 	/// Low-precision signed integer 3x2 matrix.
 	/// @see gtc_matrix_integer
-	typedef detail::tmat3x2<int, lowp>				lowp_imat3x2;
+	typedef tmat3x2<int, lowp>				lowp_imat3x2;
 
 	/// Low-precision signed integer 3x3 matrix.
 	/// @see gtc_matrix_integer
-	typedef detail::tmat3x3<int, lowp>				lowp_imat3x3;
+	typedef tmat3x3<int, lowp>				lowp_imat3x3;
 
 	/// Low-precision signed integer 3x4 matrix.
 	/// @see gtc_matrix_integer
-	typedef detail::tmat3x4<int, lowp>				lowp_imat3x4;
+	typedef tmat3x4<int, lowp>				lowp_imat3x4;
 
 	/// Low-precision signed integer 4x2 matrix.
 	/// @see gtc_matrix_integer
-	typedef detail::tmat4x2<int, lowp>				lowp_imat4x2;
+	typedef tmat4x2<int, lowp>				lowp_imat4x2;
 
 	/// Low-precision signed integer 4x3 matrix.
 	/// @see gtc_matrix_integer
-	typedef detail::tmat4x3<int, lowp>				lowp_imat4x3;
+	typedef tmat4x3<int, lowp>				lowp_imat4x3;
 
 	/// Low-precision signed integer 4x4 matrix.
 	/// @see gtc_matrix_integer
-	typedef detail::tmat4x4<int, lowp>				lowp_imat4x4;
+	typedef tmat4x4<int, lowp>				lowp_imat4x4;
 
 
 	/// High-precision unsigned integer 2x2 matrix.
 	/// @see gtc_matrix_integer
-	typedef detail::tmat2x2<uint, highp>				highp_umat2;	
+	typedef tmat2x2<uint, highp>				highp_umat2;	
 
 	/// High-precision unsigned integer 3x3 matrix.
 	/// @see gtc_matrix_integer
-	typedef detail::tmat3x3<uint, highp>				highp_umat3;
+	typedef tmat3x3<uint, highp>				highp_umat3;
 
 	/// High-precision unsigned integer 4x4 matrix.
 	/// @see gtc_matrix_integer
-	typedef detail::tmat4x4<uint, highp>				highp_umat4;
+	typedef tmat4x4<uint, highp>				highp_umat4;
 
 	/// High-precision unsigned integer 2x2 matrix.
 	/// @see gtc_matrix_integer
-	typedef detail::tmat2x2<uint, highp>				highp_umat2x2;
+	typedef tmat2x2<uint, highp>				highp_umat2x2;
 
 	/// High-precision unsigned integer 2x3 matrix.
 	/// @see gtc_matrix_integer
-	typedef detail::tmat2x3<uint, highp>				highp_umat2x3;
+	typedef tmat2x3<uint, highp>				highp_umat2x3;
 
 	/// High-precision unsigned integer 2x4 matrix.
 	/// @see gtc_matrix_integer
-	typedef detail::tmat2x4<uint, highp>				highp_umat2x4;
+	typedef tmat2x4<uint, highp>				highp_umat2x4;
 
 	/// High-precision unsigned integer 3x2 matrix.
 	/// @see gtc_matrix_integer
-	typedef detail::tmat3x2<uint, highp>				highp_umat3x2;
+	typedef tmat3x2<uint, highp>				highp_umat3x2;
 
 	/// High-precision unsigned integer 3x3 matrix.
 	/// @see gtc_matrix_integer
-	typedef detail::tmat3x3<uint, highp>				highp_umat3x3;
+	typedef tmat3x3<uint, highp>				highp_umat3x3;
 
 	/// High-precision unsigned integer 3x4 matrix.
 	/// @see gtc_matrix_integer
-	typedef detail::tmat3x4<uint, highp>				highp_umat3x4;
+	typedef tmat3x4<uint, highp>				highp_umat3x4;
 
 	/// High-precision unsigned integer 4x2 matrix.
 	/// @see gtc_matrix_integer
-	typedef detail::tmat4x2<uint, highp>				highp_umat4x2;
+	typedef tmat4x2<uint, highp>				highp_umat4x2;
 
 	/// High-precision unsigned integer 4x3 matrix.
 	/// @see gtc_matrix_integer
-	typedef detail::tmat4x3<uint, highp>				highp_umat4x3;
+	typedef tmat4x3<uint, highp>				highp_umat4x3;
 
 	/// High-precision unsigned integer 4x4 matrix.
 	/// @see gtc_matrix_integer
-	typedef detail::tmat4x4<uint, highp>				highp_umat4x4;
+	typedef tmat4x4<uint, highp>				highp_umat4x4;
 
 
 	/// Medium-precision unsigned integer 2x2 matrix.
 	/// @see gtc_matrix_integer
-	typedef detail::tmat2x2<uint, mediump>			mediump_umat2;
+	typedef tmat2x2<uint, mediump>			mediump_umat2;
 
 	/// Medium-precision unsigned integer 3x3 matrix.
 	/// @see gtc_matrix_integer
-	typedef detail::tmat3x3<uint, mediump>			mediump_umat3;
+	typedef tmat3x3<uint, mediump>			mediump_umat3;
 
 	/// Medium-precision unsigned integer 4x4 matrix.
 	/// @see gtc_matrix_integer
-	typedef detail::tmat4x4<uint, mediump>			mediump_umat4;
+	typedef tmat4x4<uint, mediump>			mediump_umat4;
 
 
 	/// Medium-precision unsigned integer 2x2 matrix.
 	/// @see gtc_matrix_integer
-	typedef detail::tmat2x2<uint, mediump>			mediump_umat2x2;
+	typedef tmat2x2<uint, mediump>			mediump_umat2x2;
 
 	/// Medium-precision unsigned integer 2x3 matrix.
 	/// @see gtc_matrix_integer
-	typedef detail::tmat2x3<uint, mediump>			mediump_umat2x3;
+	typedef tmat2x3<uint, mediump>			mediump_umat2x3;
 
 	/// Medium-precision unsigned integer 2x4 matrix.
 	/// @see gtc_matrix_integer
-	typedef detail::tmat2x4<uint, mediump>			mediump_umat2x4;
+	typedef tmat2x4<uint, mediump>			mediump_umat2x4;
 
 	/// Medium-precision unsigned integer 3x2 matrix.
 	/// @see gtc_matrix_integer
-	typedef detail::tmat3x2<uint, mediump>			mediump_umat3x2;
+	typedef tmat3x2<uint, mediump>			mediump_umat3x2;
 
 	/// Medium-precision unsigned integer 3x3 matrix.
 	/// @see gtc_matrix_integer
-	typedef detail::tmat3x3<uint, mediump>			mediump_umat3x3;
+	typedef tmat3x3<uint, mediump>			mediump_umat3x3;
 
 	/// Medium-precision unsigned integer 3x4 matrix.
 	/// @see gtc_matrix_integer
-	typedef detail::tmat3x4<uint, mediump>			mediump_umat3x4;
+	typedef tmat3x4<uint, mediump>			mediump_umat3x4;
 
 	/// Medium-precision unsigned integer 4x2 matrix.
 	/// @see gtc_matrix_integer
-	typedef detail::tmat4x2<uint, mediump>			mediump_umat4x2;
+	typedef tmat4x2<uint, mediump>			mediump_umat4x2;
 
 	/// Medium-precision unsigned integer 4x3 matrix.
 	/// @see gtc_matrix_integer
-	typedef detail::tmat4x3<uint, mediump>			mediump_umat4x3;
+	typedef tmat4x3<uint, mediump>			mediump_umat4x3;
 
 	/// Medium-precision unsigned integer 4x4 matrix.
 	/// @see gtc_matrix_integer
-	typedef detail::tmat4x4<uint, mediump>			mediump_umat4x4;
+	typedef tmat4x4<uint, mediump>			mediump_umat4x4;
 
 
 	/// Low-precision unsigned integer 2x2 matrix.
 	/// @see gtc_matrix_integer
-	typedef detail::tmat2x2<uint, lowp>				lowp_umat2;
+	typedef tmat2x2<uint, lowp>				lowp_umat2;
 	
 	/// Low-precision unsigned integer 3x3 matrix.
 	/// @see gtc_matrix_integer
-	typedef detail::tmat3x3<uint, lowp>				lowp_umat3;
+	typedef tmat3x3<uint, lowp>				lowp_umat3;
 
 	/// Low-precision unsigned integer 4x4 matrix.
 	/// @see gtc_matrix_integer
-	typedef detail::tmat4x4<uint, lowp>				lowp_umat4;
+	typedef tmat4x4<uint, lowp>				lowp_umat4;
 
 
 	/// Low-precision unsigned integer 2x2 matrix.
 	/// @see gtc_matrix_integer
-	typedef detail::tmat2x2<uint, lowp>				lowp_umat2x2;
+	typedef tmat2x2<uint, lowp>				lowp_umat2x2;
 
 	/// Low-precision unsigned integer 2x3 matrix.
 	/// @see gtc_matrix_integer
-	typedef detail::tmat2x3<uint, lowp>				lowp_umat2x3;
+	typedef tmat2x3<uint, lowp>				lowp_umat2x3;
 
 	/// Low-precision unsigned integer 2x4 matrix.
 	/// @see gtc_matrix_integer
-	typedef detail::tmat2x4<uint, lowp>				lowp_umat2x4;
+	typedef tmat2x4<uint, lowp>				lowp_umat2x4;
 
 	/// Low-precision unsigned integer 3x2 matrix.
 	/// @see gtc_matrix_integer
-	typedef detail::tmat3x2<uint, lowp>				lowp_umat3x2;
+	typedef tmat3x2<uint, lowp>				lowp_umat3x2;
 
 	/// Low-precision unsigned integer 3x3 matrix.
 	/// @see gtc_matrix_integer
-	typedef detail::tmat3x3<uint, lowp>				lowp_umat3x3;
+	typedef tmat3x3<uint, lowp>				lowp_umat3x3;
 
 	/// Low-precision unsigned integer 3x4 matrix.
 	/// @see gtc_matrix_integer
-	typedef detail::tmat3x4<uint, lowp>				lowp_umat3x4;
+	typedef tmat3x4<uint, lowp>				lowp_umat3x4;
 
 	/// Low-precision unsigned integer 4x2 matrix.
 	/// @see gtc_matrix_integer
-	typedef detail::tmat4x2<uint, lowp>				lowp_umat4x2;
+	typedef tmat4x2<uint, lowp>				lowp_umat4x2;
 
 	/// Low-precision unsigned integer 4x3 matrix.
 	/// @see gtc_matrix_integer
-	typedef detail::tmat4x3<uint, lowp>				lowp_umat4x3;
+	typedef tmat4x3<uint, lowp>				lowp_umat4x3;
 
 	/// Low-precision unsigned integer 4x4 matrix.
 	/// @see gtc_matrix_integer
-	typedef detail::tmat4x4<uint, lowp>				lowp_umat4x4;
+	typedef tmat4x4<uint, lowp>				lowp_umat4x4;
 
 #if(defined(GLM_PRECISION_HIGHP_INT))
 	typedef highp_imat2								imat2;

glm/gtc/matrix_inverse.inl

@@ -33,42 +33,42 @@
 namespace glm
 {
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tmat3x3<T, P> affineInverse
+	GLM_FUNC_QUALIFIER tmat3x3<T, P> affineInverse
 	(
-		detail::tmat3x3<T, P> const & m
+		tmat3x3<T, P> const & m
 	)
 	{
-		detail::tmat3x3<T, P> Result(m);
-		Result[2] = detail::tvec3<T, P>(0, 0, 1);
+		tmat3x3<T, P> Result(m);
+		Result[2] = tvec3<T, P>(0, 0, 1);
 		Result = transpose(Result);
-		detail::tvec3<T, P> Translation = Result * detail::tvec3<T, P>(-detail::tvec2<T, P>(m[2]), m[2][2]);
+		tvec3<T, P> Translation = Result * tvec3<T, P>(-tvec2<T, P>(m[2]), m[2][2]);
 		Result[2] = Translation;
 		return Result;
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T, P> affineInverse
+	GLM_FUNC_QUALIFIER tmat4x4<T, P> affineInverse
 	(
-		detail::tmat4x4<T, P> const & m
+		tmat4x4<T, P> const & m
 	)
 	{
-		detail::tmat4x4<T, P> Result(m);
-		Result[3] = detail::tvec4<T, P>(0, 0, 0, 1);
+		tmat4x4<T, P> Result(m);
+		Result[3] = tvec4<T, P>(0, 0, 0, 1);
 		Result = transpose(Result);
-		detail::tvec4<T, P> Translation = Result * detail::tvec4<T, P>(-detail::tvec3<T, P>(m[3]), m[3][3]);
+		tvec4<T, P> Translation = Result * tvec4<T, P>(-tvec3<T, P>(m[3]), m[3][3]);
 		Result[3] = Translation;
 		return Result;
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tmat2x2<T, P> inverseTranspose
+	GLM_FUNC_QUALIFIER tmat2x2<T, P> inverseTranspose
 	(
-		detail::tmat2x2<T, P> const & m
+		tmat2x2<T, P> const & m
 	)
 	{
 		T Determinant = m[0][0] * m[1][1] - m[1][0] * m[0][1];
 
-		detail::tmat2x2<T, P> Inverse(
+		tmat2x2<T, P> Inverse(
 			+ m[1][1] / Determinant,
 			- m[0][1] / Determinant,
 			- m[1][0] / Determinant,
@@ -78,9 +78,9 @@ namespace glm
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tmat3x3<T, P> inverseTranspose
+	GLM_FUNC_QUALIFIER tmat3x3<T, P> inverseTranspose
 	(
-		detail::tmat3x3<T, P> const & m
+		tmat3x3<T, P> const & m
 	)
 	{
 		T Determinant =
@@ -88,7 +88,7 @@ namespace glm
 			- m[0][1] * (m[1][0] * m[2][2] - m[1][2] * m[2][0])
 			+ m[0][2] * (m[1][0] * m[2][1] - m[1][1] * m[2][0]);
 
-		detail::tmat3x3<T, P> Inverse;
+		tmat3x3<T, P> Inverse;
 		Inverse[0][0] = + (m[1][1] * m[2][2] - m[2][1] * m[1][2]);
 		Inverse[0][1] = - (m[1][0] * m[2][2] - m[2][0] * m[1][2]);
 		Inverse[0][2] = + (m[1][0] * m[2][1] - m[2][0] * m[1][1]);
@@ -104,9 +104,9 @@ namespace glm
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T, P> inverseTranspose
+	GLM_FUNC_QUALIFIER tmat4x4<T, P> inverseTranspose
 	(
-		detail::tmat4x4<T, P> const & m
+		tmat4x4<T, P> const & m
 	)
 	{
 		T SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
@@ -129,7 +129,7 @@ namespace glm
 		T SubFactor17 = m[1][0] * m[2][2] - m[2][0] * m[1][2];
 		T SubFactor18 = m[1][0] * m[2][1] - m[2][0] * m[1][1];
 
-		detail::tmat4x4<T, P> Inverse;
+		tmat4x4<T, P> Inverse;
 		Inverse[0][0] = + (m[1][1] * SubFactor00 - m[1][2] * SubFactor01 + m[1][3] * SubFactor02);
 		Inverse[0][1] = - (m[1][0] * SubFactor00 - m[1][2] * SubFactor03 + m[1][3] * SubFactor04);
 		Inverse[0][2] = + (m[1][0] * SubFactor01 - m[1][1] * SubFactor03 + m[1][3] * SubFactor05);

glm/gtc/matrix_transform.hpp

@@ -79,12 +79,12 @@ namespace glm
 	/// @see gtc_matrix_transform
 	/// @see gtx_transform
 	/// @see - translate(T x, T y, T z)
-	/// @see - translate(detail::tmat4x4<T, P> const & m, T x, T y, T z)
-	/// @see - translate(detail::tvec3<T, P> const & v)
+	/// @see - translate(tmat4x4<T, P> const & m, T x, T y, T z)
+	/// @see - translate(tvec3<T, P> const & v)
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tmat4x4<T, P> translate(
-		detail::tmat4x4<T, P> const & m,
-		detail::tvec3<T, P> const & v);
+	GLM_FUNC_DECL tmat4x4<T, P> translate(
+		tmat4x4<T, P> const & m,
+		tvec3<T, P> const & v);
 		
 	/// Builds a rotation 4 * 4 matrix created from an axis vector and an angle. 
 	/// 
@@ -95,13 +95,13 @@ namespace glm
 	/// @see gtc_matrix_transform
 	/// @see gtx_transform
 	/// @see - rotate(T angle, T x, T y, T z) 
-	/// @see - rotate(detail::tmat4x4<T, P> const & m, T angle, T x, T y, T z) 
-	/// @see - rotate(T angle, detail::tvec3<T, P> const & v) 
+	/// @see - rotate(tmat4x4<T, P> const & m, T angle, T x, T y, T z) 
+	/// @see - rotate(T angle, tvec3<T, P> const & v) 
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tmat4x4<T, P> rotate(
-		detail::tmat4x4<T, P> const & m,
+	GLM_FUNC_DECL tmat4x4<T, P> rotate(
+		tmat4x4<T, P> const & m,
 		T const & angle,
-		detail::tvec3<T, P> const & axis);
+		tvec3<T, P> const & axis);
 
 	/// Builds a scale 4 * 4 matrix created from 3 scalars. 
 	/// 
@@ -111,12 +111,12 @@ namespace glm
 	/// @see gtc_matrix_transform
 	/// @see gtx_transform
 	/// @see - scale(T x, T y, T z) scale(T const & x, T const & y, T const & z)
-	/// @see - scale(detail::tmat4x4<T, P> const & m, T x, T y, T z)
-	/// @see - scale(detail::tvec3<T, P> const & v)
+	/// @see - scale(tmat4x4<T, P> const & m, T x, T y, T z)
+	/// @see - scale(tvec3<T, P> const & v)
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tmat4x4<T, P> scale(
-		detail::tmat4x4<T, P> const & m,
-		detail::tvec3<T, P> const & v);
+	GLM_FUNC_DECL tmat4x4<T, P> scale(
+		tmat4x4<T, P> const & m,
+		tvec3<T, P> const & v);
 
 	/// Creates a matrix for an orthographic parallel viewing volume.
 	/// 
@@ -130,7 +130,7 @@ namespace glm
 	/// @see gtc_matrix_transform
 	/// @see - glm::ortho(T const & left, T const & right, T const & bottom, T const & top)
 	template <typename T>
-	GLM_FUNC_DECL detail::tmat4x4<T, defaultp> ortho(
+	GLM_FUNC_DECL tmat4x4<T, defaultp> ortho(
 		T const & left,
 		T const & right,
 		T const & bottom,
@@ -148,7 +148,7 @@ namespace glm
 	/// @see gtc_matrix_transform
 	/// @see - glm::ortho(T const & left, T const & right, T const & bottom, T const & top, T const & zNear, T const & zFar)
 	template <typename T>
-	GLM_FUNC_DECL detail::tmat4x4<T, defaultp> ortho(
+	GLM_FUNC_DECL tmat4x4<T, defaultp> ortho(
 		T const & left,
 		T const & right,
 		T const & bottom,
@@ -165,7 +165,7 @@ namespace glm
 	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double.
 	/// @see gtc_matrix_transform
 	template <typename T>
-	GLM_FUNC_DECL detail::tmat4x4<T, defaultp> frustum(
+	GLM_FUNC_DECL tmat4x4<T, defaultp> frustum(
 		T const & left,
 		T const & right,
 		T const & bottom,
@@ -182,7 +182,7 @@ namespace glm
 	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double.
 	/// @see gtc_matrix_transform
 	template <typename T>
-	GLM_FUNC_DECL detail::tmat4x4<T, defaultp> perspective(
+	GLM_FUNC_DECL tmat4x4<T, defaultp> perspective(
 		T const & fovy,
 		T const & aspect,
 		T const & near,
@@ -198,7 +198,7 @@ namespace glm
 	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double.
 	/// @see gtc_matrix_transform
 	template <typename T>
-	GLM_FUNC_DECL detail::tmat4x4<T, defaultp> perspectiveFov(
+	GLM_FUNC_DECL tmat4x4<T, defaultp> perspectiveFov(
 		T const & fov,
 		T const & width,
 		T const & height,
@@ -213,7 +213,7 @@ namespace glm
 	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double.
 	/// @see gtc_matrix_transform
 	template <typename T>
-	GLM_FUNC_DECL detail::tmat4x4<T, defaultp> infinitePerspective(
+	GLM_FUNC_DECL tmat4x4<T, defaultp> infinitePerspective(
 		T fovy, T aspect, T near);
 
 	/// Creates a matrix for a symmetric perspective-view frustum with far plane at infinite for graphics hardware that doesn't support depth clamping.
@@ -224,7 +224,7 @@ namespace glm
 	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double.
 	/// @see gtc_matrix_transform
 	template <typename T>
-	GLM_FUNC_DECL detail::tmat4x4<T, defaultp> tweakedInfinitePerspective(
+	GLM_FUNC_DECL tmat4x4<T, defaultp> tweakedInfinitePerspective(
 		T fovy, T aspect, T near);
 
 	/// Creates a matrix for a symmetric perspective-view frustum with far plane at infinite for graphics hardware that doesn't support depth clamping.
@@ -235,7 +235,7 @@ namespace glm
 	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double.
 	/// @see gtc_matrix_transform
 	template <typename T>
-	GLM_FUNC_DECL detail::tmat4x4<T, defaultp> tweakedInfinitePerspective(
+	GLM_FUNC_DECL tmat4x4<T, defaultp> tweakedInfinitePerspective(
 		T fovy, T aspect, T near, T ep);
 
 	/// Map the specified object coordinates (obj.x, obj.y, obj.z) into window coordinates.
@@ -248,11 +248,11 @@ namespace glm
 	/// @tparam U Currently supported: Floating-point types and integer types.
 	/// @see gtc_matrix_transform
 	template <typename T, typename U, precision P>
-	GLM_FUNC_DECL detail::tvec3<T, P> project(
-		detail::tvec3<T, P> const & obj,
-		detail::tmat4x4<T, P> const & model,
-		detail::tmat4x4<T, P> const & proj,
-		detail::tvec4<U, P> const & viewport);
+	GLM_FUNC_DECL tvec3<T, P> project(
+		tvec3<T, P> const & obj,
+		tmat4x4<T, P> const & model,
+		tmat4x4<T, P> const & proj,
+		tvec4<U, P> const & viewport);
 
 	/// Map the specified window coordinates (win.x, win.y, win.z) into object coordinates.
 	///
@@ -264,11 +264,11 @@ namespace glm
 	/// @tparam U Currently supported: Floating-point types and integer types.
 	/// @see gtc_matrix_transform
 	template <typename T, typename U, precision P>
-	GLM_FUNC_DECL detail::tvec3<T, P> unProject(
-		detail::tvec3<T, P> const & win,
-		detail::tmat4x4<T, P> const & model,
-		detail::tmat4x4<T, P> const & proj,
-		detail::tvec4<U, P> const & viewport);
+	GLM_FUNC_DECL tvec3<T, P> unProject(
+		tvec3<T, P> const & win,
+		tmat4x4<T, P> const & model,
+		tmat4x4<T, P> const & proj,
+		tvec4<U, P> const & viewport);
 
 	/// Define a picking region
 	///
@@ -279,10 +279,10 @@ namespace glm
 	/// @tparam U Currently supported: Floating-point types and integer types.
 	/// @see gtc_matrix_transform
 	template <typename T, precision P, typename U>
-	GLM_FUNC_DECL detail::tmat4x4<T, P> pickMatrix(
-		detail::tvec2<T, P> const & center,
-		detail::tvec2<T, P> const & delta,
-		detail::tvec4<U, P> const & viewport);
+	GLM_FUNC_DECL tmat4x4<T, P> pickMatrix(
+		tvec2<T, P> const & center,
+		tvec2<T, P> const & delta,
+		tvec4<U, P> const & viewport);
 
 	/// Build a look at view matrix.
 	///
@@ -292,10 +292,10 @@ namespace glm
 	/// @see gtc_matrix_transform
 	/// @see - frustum(T const & left, T const & right, T const & bottom, T const & top, T const & nearVal, T const & farVal) frustum(T const & left, T const & right, T const & bottom, T const & top, T const & nearVal, T const & farVal)
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tmat4x4<T, P> lookAt(
-		detail::tvec3<T, P> const & eye,
-		detail::tvec3<T, P> const & center,
-		detail::tvec3<T, P> const & up);
+	GLM_FUNC_DECL tmat4x4<T, P> lookAt(
+		tvec3<T, P> const & eye,
+		tvec3<T, P> const & center,
+		tvec3<T, P> const & up);
 
 	/// @}
 }//namespace glm

glm/gtc/matrix_transform.inl

@@ -33,33 +33,33 @@
 namespace glm
 {
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T, P> translate
+	GLM_FUNC_QUALIFIER tmat4x4<T, P> translate
 	(
-		detail::tmat4x4<T, P> const & m,
-		detail::tvec3<T, P> const & v
+		tmat4x4<T, P> const & m,
+		tvec3<T, P> const & v
 	)
 	{
-		detail::tmat4x4<T, P> Result(m);
+		tmat4x4<T, P> Result(m);
 		Result[3] = m[0] * v[0] + m[1] * v[1] + m[2] * v[2] + m[3];
 		return Result;
 	}
 	
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T, P> rotate
+	GLM_FUNC_QUALIFIER tmat4x4<T, P> rotate
 	(
-		detail::tmat4x4<T, P> const & m,
+		tmat4x4<T, P> const & m,
 		T const & angle,
-		detail::tvec3<T, P> const & v
+		tvec3<T, P> const & v
 	)
 	{
 		T const a = angle;
 		T const c = cos(a);
 		T const s = sin(a);
 
-		detail::tvec3<T, P> axis(normalize(v));
-		detail::tvec3<T, P> temp((T(1) - c) * axis);
+		tvec3<T, P> axis(normalize(v));
+		tvec3<T, P> temp((T(1) - c) * axis);
 
-		detail::tmat4x4<T, P> Rotate(detail::tmat4x4<T, P>::_null);
+		tmat4x4<T, P> Rotate(tmat4x4<T, P>::_null);
 		Rotate[0][0] = c + temp[0] * axis[0];
 		Rotate[0][1] = 0 + temp[0] * axis[1] + s * axis[2];
 		Rotate[0][2] = 0 + temp[0] * axis[2] - s * axis[1];
@@ -72,7 +72,7 @@ namespace glm
 		Rotate[2][1] = 0 + temp[2] * axis[1] - s * axis[0];
 		Rotate[2][2] = c + temp[2] * axis[2];
 
-		detail::tmat4x4<T, P> Result(detail::tmat4x4<T, P>::_null);
+		tmat4x4<T, P> Result(tmat4x4<T, P>::_null);
 		Result[0] = m[0] * Rotate[0][0] + m[1] * Rotate[0][1] + m[2] * Rotate[0][2];
 		Result[1] = m[0] * Rotate[1][0] + m[1] * Rotate[1][1] + m[2] * Rotate[1][2];
 		Result[2] = m[0] * Rotate[2][0] + m[1] * Rotate[2][1] + m[2] * Rotate[2][2];
@@ -81,19 +81,19 @@ namespace glm
 	}
 		
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T, P> rotate_slow
+	GLM_FUNC_QUALIFIER tmat4x4<T, P> rotate_slow
 	(
-		detail::tmat4x4<T, P> const & m,
+		tmat4x4<T, P> const & m,
 		T const & angle, 
-		detail::tvec3<T, P> const & v
+		tvec3<T, P> const & v
 	)
 	{
 		T const a = angle;
 		T const c = cos(a);
 		T const s = sin(a);
-		detail::tmat4x4<T, P> Result;
+		tmat4x4<T, P> Result;
 
-		detail::tvec3<T, P> axis = normalize(v);
+		tvec3<T, P> axis = normalize(v);
 
 		Result[0][0] = c + (1 - c)      * axis.x     * axis.x;
 		Result[0][1] = (1 - c) * axis.x * axis.y + s * axis.z;
@@ -110,18 +110,18 @@ namespace glm
 		Result[2][2] = c + (1 - c) * axis.z * axis.z;
 		Result[2][3] = 0;
 
-		Result[3] = detail::tvec4<T, P>(0, 0, 0, 1);
+		Result[3] = tvec4<T, P>(0, 0, 0, 1);
 		return m * Result;
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T, P> scale
+	GLM_FUNC_QUALIFIER tmat4x4<T, P> scale
 	(
-		detail::tmat4x4<T, P> const & m,
-		detail::tvec3<T, P> const & v
+		tmat4x4<T, P> const & m,
+		tvec3<T, P> const & v
 	)
 	{
-		detail::tmat4x4<T, P> Result(detail::tmat4x4<T, P>::_null);
+		tmat4x4<T, P> Result(tmat4x4<T, P>::_null);
 		Result[0] = m[0] * v[0];
 		Result[1] = m[1] * v[1];
 		Result[2] = m[2] * v[2];
@@ -130,13 +130,13 @@ namespace glm
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T, P> scale_slow
+	GLM_FUNC_QUALIFIER tmat4x4<T, P> scale_slow
 	(
-		detail::tmat4x4<T, P> const & m,
-		detail::tvec3<T, P> const & v
+		tmat4x4<T, P> const & m,
+		tvec3<T, P> const & v
 	)
 	{
-		detail::tmat4x4<T, P> Result(T(1));
+		tmat4x4<T, P> Result(T(1));
 		Result[0][0] = v.x;
 		Result[1][1] = v.y;
 		Result[2][2] = v.z;
@@ -144,7 +144,7 @@ namespace glm
 	}
 
 	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T, defaultp> ortho
+	GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> ortho
 	(
 		T const & left,
 		T const & right,
@@ -154,7 +154,7 @@ namespace glm
 		T const & zFar
 	)
 	{
-		detail::tmat4x4<T, defaultp> Result(1);
+		tmat4x4<T, defaultp> Result(1);
 		Result[0][0] = static_cast<T>(2) / (right - left);
 		Result[1][1] = static_cast<T>(2) / (top - bottom);
 		Result[2][2] = - static_cast<T>(2) / (zFar - zNear);
@@ -165,7 +165,7 @@ namespace glm
 	}
 
 	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T, defaultp> ortho
+	GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> ortho
 	(
 		T const & left,
 		T const & right,
@@ -173,7 +173,7 @@ namespace glm
 		T const & top
 	)
 	{
-		detail::tmat4x4<T, defaultp> Result(1);
+		tmat4x4<T, defaultp> Result(1);
 		Result[0][0] = static_cast<T>(2) / (right - left);
 		Result[1][1] = static_cast<T>(2) / (top - bottom);
 		Result[2][2] = - static_cast<T>(1);
@@ -183,7 +183,7 @@ namespace glm
 	}
 
 	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T, defaultp> frustum
+	GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> frustum
 	(
 		T const & left,
 		T const & right,
@@ -193,7 +193,7 @@ namespace glm
 		T const & farVal
 	)
 	{
-		detail::tmat4x4<T, defaultp> Result(0);
+		tmat4x4<T, defaultp> Result(0);
 		Result[0][0] = (static_cast<T>(2) * nearVal) / (right - left);
 		Result[1][1] = (static_cast<T>(2) * nearVal) / (top - bottom);
 		Result[2][0] = (right + left) / (right - left);
@@ -205,7 +205,7 @@ namespace glm
 	}
 
 	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T, defaultp> perspective
+	GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> perspective
 	(
 		T const & fovy,
 		T const & aspect,
@@ -219,7 +219,7 @@ namespace glm
 		T const rad = fovy;
 		T const tanHalfFovy = tan(rad / static_cast<T>(2));
 
-		detail::tmat4x4<T, defaultp> Result(static_cast<T>(0));
+		tmat4x4<T, defaultp> Result(static_cast<T>(0));
 		Result[0][0] = static_cast<T>(1) / (aspect * tanHalfFovy);
 		Result[1][1] = static_cast<T>(1) / (tanHalfFovy);
 		Result[2][2] = - (zFar + zNear) / (zFar - zNear);
@@ -229,7 +229,7 @@ namespace glm
 	}
 	
 	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T, defaultp> perspectiveFov
+	GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> perspectiveFov
 	(
 		T const & fov,
 		T const & width,
@@ -246,7 +246,7 @@ namespace glm
 		T const h = glm::cos(static_cast<T>(0.5) * rad) / glm::sin(static_cast<T>(0.5) * rad);
 		T const w = h * height / width; ///todo max(width , Height) / min(width , Height)?
 
-		detail::tmat4x4<T, defaultp> Result(static_cast<T>(0));
+		tmat4x4<T, defaultp> Result(static_cast<T>(0));
 		Result[0][0] = w;
 		Result[1][1] = h;
 		Result[2][2] = - (zFar + zNear) / (zFar - zNear);
@@ -256,7 +256,7 @@ namespace glm
 	}
 
 	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T, defaultp> infinitePerspective
+	GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> infinitePerspective
 	(
 		T fovy,
 		T aspect,
@@ -269,7 +269,7 @@ namespace glm
 		T const bottom = -range;
 		T const top = range;
 
-		detail::tmat4x4<T, defaultp> Result(T(0));
+		tmat4x4<T, defaultp> Result(T(0));
 		Result[0][0] = (T(2) * zNear) / (right - left);
 		Result[1][1] = (T(2) * zNear) / (top - bottom);
 		Result[2][2] = - T(1);
@@ -280,7 +280,7 @@ namespace glm
 
 	// Infinite projection matrix: http://www.terathon.com/gdc07_lengyel.pdf
 	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T, defaultp> tweakedInfinitePerspective
+	GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> tweakedInfinitePerspective
 	(
 		T fovy,
 		T aspect,
@@ -294,7 +294,7 @@ namespace glm
 		T const bottom = -range;
 		T const top = range;
 
-		detail::tmat4x4<T, defaultp> Result(T(0));
+		tmat4x4<T, defaultp> Result(T(0));
 		Result[0][0] = (static_cast<T>(2) * zNear) / (right - left);
 		Result[1][1] = (static_cast<T>(2) * zNear) / (top - bottom);
 		Result[2][2] = ep - static_cast<T>(1);
@@ -304,7 +304,7 @@ namespace glm
 	}
 
 	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T, defaultp> tweakedInfinitePerspective
+	GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> tweakedInfinitePerspective
 	(
 		T fovy,
 		T aspect,
@@ -315,15 +315,15 @@ namespace glm
 	}
 
 	template <typename T, typename U, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec3<T, P> project
+	GLM_FUNC_QUALIFIER tvec3<T, P> project
 	(
-		detail::tvec3<T, P> const & obj,
-		detail::tmat4x4<T, P> const & model,
-		detail::tmat4x4<T, P> const & proj,
-		detail::tvec4<U, P> const & viewport
+		tvec3<T, P> const & obj,
+		tmat4x4<T, P> const & model,
+		tmat4x4<T, P> const & proj,
+		tvec4<U, P> const & viewport
 	)
 	{
-		detail::tvec4<T, P> tmp = detail::tvec4<T, P>(obj, T(1));
+		tvec4<T, P> tmp = tvec4<T, P>(obj, T(1));
 		tmp = model * tmp;
 		tmp = proj * tmp;
 
@@ -332,68 +332,68 @@ namespace glm
 		tmp[0] = tmp[0] * T(viewport[2]) + T(viewport[0]);
 		tmp[1] = tmp[1] * T(viewport[3]) + T(viewport[1]);
 
-		return detail::tvec3<T, P>(tmp);
+		return tvec3<T, P>(tmp);
 	}
 
 	template <typename T, typename U, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec3<T, P> unProject
+	GLM_FUNC_QUALIFIER tvec3<T, P> unProject
 	(
-		detail::tvec3<T, P> const & win,
-		detail::tmat4x4<T, P> const & model,
-		detail::tmat4x4<T, P> const & proj,
-		detail::tvec4<U, P> const & viewport
+		tvec3<T, P> const & win,
+		tmat4x4<T, P> const & model,
+		tmat4x4<T, P> const & proj,
+		tvec4<U, P> const & viewport
 	)
 	{
-		detail::tmat4x4<T, P> Inverse = inverse(proj * model);
+		tmat4x4<T, P> Inverse = inverse(proj * model);
 
-		detail::tvec4<T, P> tmp = detail::tvec4<T, P>(win, T(1));
+		tvec4<T, P> tmp = tvec4<T, P>(win, T(1));
 		tmp.x = (tmp.x - T(viewport[0])) / T(viewport[2]);
 		tmp.y = (tmp.y - T(viewport[1])) / T(viewport[3]);
 		tmp = tmp * T(2) - T(1);
 
-		detail::tvec4<T, P> obj = Inverse * tmp;
+		tvec4<T, P> obj = Inverse * tmp;
 		obj /= obj.w;
 
-		return detail::tvec3<T, P>(obj);
+		return tvec3<T, P>(obj);
 	}
 
 	template <typename T, precision P, typename U>
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T, P> pickMatrix
+	GLM_FUNC_QUALIFIER tmat4x4<T, P> pickMatrix
 	(
-		detail::tvec2<T, P> const & center,
-		detail::tvec2<T, P> const & delta,
-		detail::tvec4<U, P> const & viewport
+		tvec2<T, P> const & center,
+		tvec2<T, P> const & delta,
+		tvec4<U, P> const & viewport
 	)
 	{
 		assert(delta.x > T(0) && delta.y > T(0));
-		detail::tmat4x4<T, P> Result(1.0f);
+		tmat4x4<T, P> Result(1.0f);
 
 		if(!(delta.x > T(0) && delta.y > T(0)))
 			return Result; // Error
 
-		detail::tvec3<T, P> Temp(
+		tvec3<T, P> Temp(
 			(T(viewport[2]) - T(2) * (center.x - T(viewport[0]))) / delta.x,
 			(T(viewport[3]) - T(2) * (center.y - T(viewport[1]))) / delta.y,
 			T(0));
 
 		// Translate and scale the picked region to the entire window
 		Result = translate(Result, Temp);
-		return scale(Result, detail::tvec3<T, P>(T(viewport[2]) / delta.x, T(viewport[3]) / delta.y, T(1)));
+		return scale(Result, tvec3<T, P>(T(viewport[2]) / delta.x, T(viewport[3]) / delta.y, T(1)));
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T, P> lookAt
+	GLM_FUNC_QUALIFIER tmat4x4<T, P> lookAt
 	(
-		detail::tvec3<T, P> const & eye,
-		detail::tvec3<T, P> const & center,
-		detail::tvec3<T, P> const & up
+		tvec3<T, P> const & eye,
+		tvec3<T, P> const & center,
+		tvec3<T, P> const & up
 	)
 	{
-		detail::tvec3<T, P> const f(normalize(center - eye));
-		detail::tvec3<T, P> const s(normalize(cross(f, up)));
-		detail::tvec3<T, P> const u(cross(s, f));
+		tvec3<T, P> const f(normalize(center - eye));
+		tvec3<T, P> const s(normalize(cross(f, up)));
+		tvec3<T, P> const u(cross(s, f));
 
-		detail::tmat4x4<T, P> Result(1);
+		tmat4x4<T, P> Result(1);
 		Result[0][0] = s.x;
 		Result[1][0] = s.y;
 		Result[2][0] = s.z;

glm/gtc/quaternion.hpp

@@ -50,9 +50,11 @@
 #	pragma message("GLM: GLM_GTC_quaternion extension included")
 #endif
 
-namespace glm{
-namespace detail
+namespace glm
 {
+	/// @addtogroup gtc_quaternion
+	/// @{
+
 	template <typename T, precision P>
 	struct tquat
 	{
@@ -89,8 +91,8 @@ namespace detail
 		/// @see gtc_quaternion
 		/// @see http://lolengine.net/blog/2013/09/18/beautiful-maths-quaternion-from-vectors
 		GLM_FUNC_DECL explicit tquat(
-			detail::tvec3<T, P> const & u,
-			detail::tvec3<T, P> const & v);
+			tvec3<T, P> const & u,
+			tvec3<T, P> const & v);
 		/// Build a quaternion from euler angles (pitch, yaw, roll), in radians.
 		GLM_FUNC_DECL explicit tquat(
 			tvec3<T, P> const & eulerAngles);
@@ -111,72 +113,67 @@ namespace detail
 	};
 
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tquat<T, P> operator- (
-		detail::tquat<T, P> const & q);
+	GLM_FUNC_DECL tquat<T, P> operator- (
+		tquat<T, P> const & q);
 
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tquat<T, P> operator+ (
-		detail::tquat<T, P> const & q,
-		detail::tquat<T, P> const & p);
+	GLM_FUNC_DECL tquat<T, P> operator+ (
+		tquat<T, P> const & q,
+		tquat<T, P> const & p);
 
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tquat<T, P> operator* (
-		detail::tquat<T, P> const & q,
-		detail::tquat<T, P> const & p);
+	GLM_FUNC_DECL tquat<T, P> operator* (
+		tquat<T, P> const & q,
+		tquat<T, P> const & p);
 
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tvec3<T, P> operator* (
-		detail::tquat<T, P> const & q,
-		detail::tvec3<T, P> const & v);
+	GLM_FUNC_DECL tvec3<T, P> operator* (
+		tquat<T, P> const & q,
+		tvec3<T, P> const & v);
 
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tvec3<T, P> operator* (
-		detail::tvec3<T, P> const & v,
-		detail::tquat<T, P> const & q);
+	GLM_FUNC_DECL tvec3<T, P> operator* (
+		tvec3<T, P> const & v,
+		tquat<T, P> const & q);
 
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tvec4<T, P> operator* (
-		detail::tquat<T, P> const & q, 
-		detail::tvec4<T, P> const & v);
+	GLM_FUNC_DECL tvec4<T, P> operator* (
+		tquat<T, P> const & q, 
+		tvec4<T, P> const & v);
 
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tvec4<T, P> operator* (
-		detail::tvec4<T, P> const & v,
-		detail::tquat<T, P> const & q);
+	GLM_FUNC_DECL tvec4<T, P> operator* (
+		tvec4<T, P> const & v,
+		tquat<T, P> const & q);
 
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tquat<T, P> operator* (
-		detail::tquat<T, P> const & q,
+	GLM_FUNC_DECL tquat<T, P> operator* (
+		tquat<T, P> const & q,
 		T const & s);
 
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tquat<T, P> operator* (
+	GLM_FUNC_DECL tquat<T, P> operator* (
 		T const & s,
-		detail::tquat<T, P> const & q);
+		tquat<T, P> const & q);
 
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tquat<T, P> operator/ (
-		detail::tquat<T, P> const & q,
+	GLM_FUNC_DECL tquat<T, P> operator/ (
+		tquat<T, P> const & q,
 		T const & s);
 
-} //namespace detail
-
-	/// @addtogroup gtc_quaternion
-	/// @{
-
 	/// Returns the length of the quaternion.
 	/// 
 	/// @see gtc_quaternion
 	template <typename T, precision P>
 	GLM_FUNC_DECL T length(
-		detail::tquat<T, P> const & q);
+		tquat<T, P> const & q);
 
 	/// Returns the normalized quaternion.
 	/// 
 	/// @see gtc_quaternion
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tquat<T, P> normalize(
-		detail::tquat<T, P> const & q);
+	GLM_FUNC_DECL tquat<T, P> normalize(
+		tquat<T, P> const & q);
 		
 	/// Returns dot product of q1 and q2, i.e., q1[0] * q2[0] + q1[1] * q2[1] + ...
 	/// 
@@ -195,11 +192,11 @@ namespace detail
 	/// @param a Interpolation factor. The interpolation is defined beyond the range [0, 1].
 	/// @tparam T Value type used to build the quaternion. Supported: half, float or double.
 	/// @see gtc_quaternion
-	/// @see - slerp(detail::tquat<T, P> const & x, detail::tquat<T, P> const & y, T const & a)
+	/// @see - slerp(tquat<T, P> const & x, tquat<T, P> const & y, T const & a)
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tquat<T, P> mix(
-		detail::tquat<T, P> const & x,
-		detail::tquat<T, P> const & y,
+	GLM_FUNC_DECL tquat<T, P> mix(
+		tquat<T, P> const & x,
+		tquat<T, P> const & y,
 		T const & a);
 
 	/// Linear interpolation of two quaternions.
@@ -211,9 +208,9 @@ namespace detail
 	/// @tparam T Value type used to build the quaternion. Supported: half, float or double.
 	/// @see gtc_quaternion
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tquat<T, P> lerp(
-		detail::tquat<T, P> const & x,
-		detail::tquat<T, P> const & y,
+	GLM_FUNC_DECL tquat<T, P> lerp(
+		tquat<T, P> const & x,
+		tquat<T, P> const & y,
 		T const & a);
 
 	/// Spherical linear interpolation of two quaternions.
@@ -225,24 +222,24 @@ namespace detail
 	/// @tparam T Value type used to build the quaternion. Supported: half, float or double.
 	/// @see gtc_quaternion
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tquat<T, P> slerp(
-		detail::tquat<T, P> const & x,
-		detail::tquat<T, P> const & y,
+	GLM_FUNC_DECL tquat<T, P> slerp(
+		tquat<T, P> const & x,
+		tquat<T, P> const & y,
 		T const & a);
 
 	/// Returns the q conjugate.
 	/// 
 	/// @see gtc_quaternion
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tquat<T, P> conjugate(
-		detail::tquat<T, P> const & q);
+	GLM_FUNC_DECL tquat<T, P> conjugate(
+		tquat<T, P> const & q);
 
 	/// Returns the q inverse.
 	/// 
 	/// @see gtc_quaternion
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tquat<T, P> inverse(
-		detail::tquat<T, P> const & q);
+	GLM_FUNC_DECL tquat<T, P> inverse(
+		tquat<T, P> const & q);
 
 	/// Rotates a quaternion from a vector of 3 components axis and an angle.
 	/// 
@@ -252,77 +249,77 @@ namespace detail
 	/// 
 	/// @see gtc_quaternion
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tquat<T, P> rotate(
-		detail::tquat<T, P> const & q,
+	GLM_FUNC_DECL tquat<T, P> rotate(
+		tquat<T, P> const & q,
 		T const & angle,
-		detail::tvec3<T, P> const & axis);
+		tvec3<T, P> const & axis);
 
 	/// Returns euler angles, yitch as x, yaw as y, roll as z.
 	/// The result is expressed in radians if GLM_FORCE_RADIANS is defined or degrees otherwise.
 	/// 
 	/// @see gtc_quaternion
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tvec3<T, P> eulerAngles(
-		detail::tquat<T, P> const & x);
+	GLM_FUNC_DECL tvec3<T, P> eulerAngles(
+		tquat<T, P> const & x);
 
 	/// Returns roll value of euler angles expressed in radians.
 	///
 	/// @see gtx_quaternion
 	template <typename T, precision P>
-	GLM_FUNC_DECL T roll(detail::tquat<T, P> const & x);
+	GLM_FUNC_DECL T roll(tquat<T, P> const & x);
 
 	/// Returns pitch value of euler angles expressed in radians.
 	///
 	/// @see gtx_quaternion
 	template <typename T, precision P>
-	GLM_FUNC_DECL T pitch(detail::tquat<T, P> const & x);
+	GLM_FUNC_DECL T pitch(tquat<T, P> const & x);
 
 	/// Returns yaw value of euler angles expressed in radians.
 	///
 	/// @see gtx_quaternion
 	template <typename T, precision P>
-	GLM_FUNC_DECL T yaw(detail::tquat<T, P> const & x);
+	GLM_FUNC_DECL T yaw(tquat<T, P> const & x);
 
 	/// Converts a quaternion to a 3 * 3 matrix.
 	/// 
 	/// @see gtc_quaternion
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tmat3x3<T, P> mat3_cast(
-		detail::tquat<T, P> const & x);
+	GLM_FUNC_DECL tmat3x3<T, P> mat3_cast(
+		tquat<T, P> const & x);
 
 	/// Converts a quaternion to a 4 * 4 matrix.
 	/// 
 	/// @see gtc_quaternion
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tmat4x4<T, P> mat4_cast(
-		detail::tquat<T, P> const & x);
+	GLM_FUNC_DECL tmat4x4<T, P> mat4_cast(
+		tquat<T, P> const & x);
 
 	/// Converts a 3 * 3 matrix to a quaternion.
 	/// 
 	/// @see gtc_quaternion
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tquat<T, P> quat_cast(
-		detail::tmat3x3<T, P> const & x);
+	GLM_FUNC_DECL tquat<T, P> quat_cast(
+		tmat3x3<T, P> const & x);
 
 	/// Converts a 4 * 4 matrix to a quaternion.
 	/// 
 	/// @see gtc_quaternion
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tquat<T, P> quat_cast(
-		detail::tmat4x4<T, P> const & x);
+	GLM_FUNC_DECL tquat<T, P> quat_cast(
+		tmat4x4<T, P> const & x);
 
 	/// Returns the quaternion rotation angle.
 	///
 	/// @see gtc_quaternion
 	template <typename T, precision P>
-	GLM_FUNC_DECL T angle(detail::tquat<T, P> const & x);
+	GLM_FUNC_DECL T angle(tquat<T, P> const & x);
 
 	/// Returns the q rotation axis.
 	///
 	/// @see gtc_quaternion
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tvec3<T, P> axis(
-		detail::tquat<T, P> const & x);
+	GLM_FUNC_DECL tvec3<T, P> axis(
+		tquat<T, P> const & x);
 
 	/// Build a quaternion from an angle and a normalized axis.
 	///
@@ -331,9 +328,9 @@ namespace detail
 	///
 	/// @see gtc_quaternion
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tquat<T, P> angleAxis(
+	GLM_FUNC_DECL tquat<T, P> angleAxis(
 		T const & angle,
-		detail::tvec3<T, P> const & axis);
+		tvec3<T, P> const & axis);
 
 	/// Returns the component-wise comparison result of x < y.
 	/// 
@@ -341,9 +338,9 @@ namespace detail
 	///
 	/// @see gtc_quaternion
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tvec4<bool, P> lessThan(
-		detail::tquat<T, P> const & x, 
-		detail::tquat<T, P> const & y);
+	GLM_FUNC_DECL tvec4<bool, P> lessThan(
+		tquat<T, P> const & x, 
+		tquat<T, P> const & y);
 
 	/// Returns the component-wise comparison of result x <= y.
 	///
@@ -351,9 +348,9 @@ namespace detail
 	///
 	/// @see gtc_quaternion
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tvec4<bool, P> lessThanEqual(
-		detail::tquat<T, P> const & x, 
-		detail::tquat<T, P> const & y);
+	GLM_FUNC_DECL tvec4<bool, P> lessThanEqual(
+		tquat<T, P> const & x, 
+		tquat<T, P> const & y);
 
 	/// Returns the component-wise comparison of result x > y.
 	///
@@ -361,9 +358,9 @@ namespace detail
 	///
 	/// @see gtc_quaternion
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tvec4<bool, P> greaterThan(
-		detail::tquat<T, P> const & x, 
-		detail::tquat<T, P> const & y);
+	GLM_FUNC_DECL tvec4<bool, P> greaterThan(
+		tquat<T, P> const & x, 
+		tquat<T, P> const & y);
 
 	/// Returns the component-wise comparison of result x >= y.
 	///
@@ -371,9 +368,9 @@ namespace detail
 	///
 	/// @see gtc_quaternion
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tvec4<bool, P> greaterThanEqual(
-		detail::tquat<T, P> const & x, 
-		detail::tquat<T, P> const & y);
+	GLM_FUNC_DECL tvec4<bool, P> greaterThanEqual(
+		tquat<T, P> const & x, 
+		tquat<T, P> const & y);
 
 	/// Returns the component-wise comparison of result x == y.
 	///
@@ -381,9 +378,9 @@ namespace detail
 	///
 	/// @see gtc_quaternion
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tvec4<bool, P> equal(
-		detail::tquat<T, P> const & x, 
-		detail::tquat<T, P> const & y);
+	GLM_FUNC_DECL tvec4<bool, P> equal(
+		tquat<T, P> const & x, 
+		tquat<T, P> const & y);
 
 	/// Returns the component-wise comparison of result x != y.
 	/// 
@@ -391,9 +388,9 @@ namespace detail
 	///
 	/// @see gtc_quaternion
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tvec4<bool, P> notEqual(
-		detail::tquat<T, P> const & x, 
-		detail::tquat<T, P> const & y);
+	GLM_FUNC_DECL tvec4<bool, P> notEqual(
+		tquat<T, P> const & x, 
+		tquat<T, P> const & y);
 
 	/// @}
 } //namespace glm

glm/gtc/quaternion.inl

@@ -34,6 +34,17 @@
 namespace glm{
 namespace detail
 {
+	template <typename T, precision P>
+	struct compute_dot<tquat, T, P>
+	{
+		static GLM_FUNC_QUALIFIER T call(tquat<T, P> const & x, tquat<T, P> const & y)
+		{
+			tvec4<T, P> tmp(x.x * y.x, x.y * y.y, x.z * y.z, x.w * y.w);
+			return (tmp.x + tmp.y) + (tmp.z + tmp.w);
+		}
+	};
+}//namespace detail
+
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR length_t tquat<T, P>::length() const
 	{
@@ -110,13 +121,13 @@ namespace detail
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tquat<T, P>::tquat
 	(
-		detail::tvec3<T, P> const & u,
-		detail::tvec3<T, P> const & v
+		tvec3<T, P> const & u,
+		tvec3<T, P> const & v
 	)
 	{
-		detail::tvec3<T, P> const LocalW(cross(u, v));
-		T Dot = detail::compute_dot<detail::tvec3, T, P>::call(u, v);
-		detail::tquat<T, P> q(T(1) + Dot, LocalW.x, LocalW.y, LocalW.z);
+		tvec3<T, P> const LocalW(cross(u, v));
+		T Dot = detail::compute_dot<tvec3, T, P>::call(u, v);
+		tquat<T, P> q(T(1) + Dot, LocalW.x, LocalW.y, LocalW.z);
 
 		*this = normalize(q);
 	}
@@ -170,28 +181,25 @@ namespace detail
 		assert(i >= 0 && i < this->length());
 		return (&x)[i];
 	}
-}//namespace detail
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tquat<T, P> conjugate
+	GLM_FUNC_QUALIFIER tquat<T, P> conjugate
 	(
-		detail::tquat<T, P> const & q
+		tquat<T, P> const & q
 	)
 	{
-		return detail::tquat<T, P>(q.w, -q.x, -q.y, -q.z);
+		return tquat<T, P>(q.w, -q.x, -q.y, -q.z);
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tquat<T, P> inverse
+	GLM_FUNC_QUALIFIER tquat<T, P> inverse
 	(
-		detail::tquat<T, P> const & q
+		tquat<T, P> const & q
 	)
 	{
 		return conjugate(q) / dot(q, q);
 	}
 
-namespace detail
-{
 	//////////////////////////////////////////////////////////////
 	// tquat<valType> operators
 
@@ -249,125 +257,112 @@ namespace detail
 		return *this;
 	}
 
-	//////////////////////////////////////////////////////////////
-	// tquat<T, P> external functions
-
-	template <typename T, precision P>
-	struct compute_dot<tquat, T, P>
-	{
-		static GLM_FUNC_QUALIFIER T call(tquat<T, P> const & x, tquat<T, P> const & y)
-		{
-			tvec4<T, P> tmp(x.x * y.x, x.y * y.y, x.z * y.z, x.w * y.w);
-			return (tmp.x + tmp.y) + (tmp.z + tmp.w);
-		}
-	};
-
 	//////////////////////////////////////////////////////////////
 	// tquat<T, P> external operators
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tquat<T, P> operator-
+	GLM_FUNC_QUALIFIER tquat<T, P> operator-
 	(
-		detail::tquat<T, P> const & q
+		tquat<T, P> const & q
 	)
 	{
-		return detail::tquat<T, P>(-q.w, -q.x, -q.y, -q.z);
+		return tquat<T, P>(-q.w, -q.x, -q.y, -q.z);
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tquat<T, P> operator+
+	GLM_FUNC_QUALIFIER tquat<T, P> operator+
 	(
-		detail::tquat<T, P> const & q,
-		detail::tquat<T, P> const & p
+		tquat<T, P> const & q,
+		tquat<T, P> const & p
 	)
 	{
-		return detail::tquat<T, P>(q) += p;
+		return tquat<T, P>(q) += p;
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tquat<T, P> operator*
+	GLM_FUNC_QUALIFIER tquat<T, P> operator*
 	(
-		detail::tquat<T, P> const & q,
-		detail::tquat<T, P> const & p
+		tquat<T, P> const & q,
+		tquat<T, P> const & p
 	)
 	{
-		return detail::tquat<T, P>(q) *= p;
+		return tquat<T, P>(q) *= p;
 	}
 
 	// Transformation
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec3<T, P> operator*
+	GLM_FUNC_QUALIFIER tvec3<T, P> operator*
 	(
-		detail::tquat<T, P> const & q,
-		detail::tvec3<T, P> const & v
+		tquat<T, P> const & q,
+		tvec3<T, P> const & v
 	)
 	{
-		detail::tvec3<T, P> const QuatVector(q.x, q.y, q.z);
-		detail::tvec3<T, P> const uv(glm::cross(QuatVector, v));
-		detail::tvec3<T, P> const uuv(glm::cross(QuatVector, uv));
+		tvec3<T, P> const QuatVector(q.x, q.y, q.z);
+		tvec3<T, P> const uv(glm::cross(QuatVector, v));
+		tvec3<T, P> const uuv(glm::cross(QuatVector, uv));
 
 		return v + ((uv * q.w) + uuv) * static_cast<T>(2);
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec3<T, P> operator*
+	GLM_FUNC_QUALIFIER tvec3<T, P> operator*
 	(
-		detail::tvec3<T, P> const & v,
-		detail::tquat<T, P> const & q
+		tvec3<T, P> const & v,
+		tquat<T, P> const & q
 	)
 	{
 		return glm::inverse(q) * v;
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec4<T, P> operator*
+	GLM_FUNC_QUALIFIER tvec4<T, P> operator*
 	(
-		detail::tquat<T, P> const & q,
-		detail::tvec4<T, P> const & v
+		tquat<T, P> const & q,
+		tvec4<T, P> const & v
 	)
 	{
-		return detail::tvec4<T, P>(q * detail::tvec3<T, P>(v), v.w);
+		return tvec4<T, P>(q * tvec3<T, P>(v), v.w);
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec4<T, P> operator*
+	GLM_FUNC_QUALIFIER tvec4<T, P> operator*
 	(
-		detail::tvec4<T, P> const & v,
-		detail::tquat<T, P> const & q
+		tvec4<T, P> const & v,
+		tquat<T, P> const & q
 	)
 	{
 		return glm::inverse(q) * v;
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tquat<T, P> operator*
+	GLM_FUNC_QUALIFIER tquat<T, P> operator*
 	(
-		detail::tquat<T, P> const & q,
+		tquat<T, P> const & q,
 		T const & s
 	)
 	{
-		return detail::tquat<T, P>(
+		return tquat<T, P>(
 			q.w * s, q.x * s, q.y * s, q.z * s);
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tquat<T, P> operator*
+	GLM_FUNC_QUALIFIER tquat<T, P> operator*
 	(
 		T const & s,
-		detail::tquat<T, P> const & q
+		tquat<T, P> const & q
 	)
 	{
 		return q * s;
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tquat<T, P> operator/
+	GLM_FUNC_QUALIFIER tquat<T, P> operator/
 	(
-		detail::tquat<T, P> const & q,
+		tquat<T, P> const & q,
 		T const & s
 	)
 	{
-		return detail::tquat<T, P>(
+		return tquat<T, P>(
 			q.w / s, q.x / s, q.y / s, q.z / s);
 	}
 
@@ -377,8 +372,8 @@ namespace detail
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER bool operator==
 	(
-		detail::tquat<T, P> const & q1,
-		detail::tquat<T, P> const & q2
+		tquat<T, P> const & q1,
+		tquat<T, P> const & q2
 	)
 	{
 		return (q1.x == q2.x) && (q1.y == q2.y) && (q1.z == q2.z) && (q1.w == q2.w);
@@ -387,46 +382,44 @@ namespace detail
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER bool operator!=
 	(
-		detail::tquat<T, P> const & q1,
-		detail::tquat<T, P> const & q2
+		tquat<T, P> const & q1,
+		tquat<T, P> const & q2
 	)
 	{
 		return (q1.x != q2.x) || (q1.y != q2.y) || (q1.z != q2.z) || (q1.w != q2.w);
 	}
 
-}//namespace detail
-
 	////////////////////////////////////////////////////////
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER T length
 	(
-		detail::tquat<T, P> const & q
+		tquat<T, P> const & q
 	)
 	{
 		return glm::sqrt(dot(q, q));
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tquat<T, P> normalize
+	GLM_FUNC_QUALIFIER tquat<T, P> normalize
 	(
-		detail::tquat<T, P> const & q
+		tquat<T, P> const & q
 	)
 	{
 		T len = length(q);
 		if(len <= T(0)) // Problem
-			return detail::tquat<T, P>(1, 0, 0, 0);
+			return tquat<T, P>(1, 0, 0, 0);
 		T oneOverLen = T(1) / len;
-		return detail::tquat<T, P>(q.w * oneOverLen, q.x * oneOverLen, q.y * oneOverLen, q.z * oneOverLen);
+		return tquat<T, P>(q.w * oneOverLen, q.x * oneOverLen, q.y * oneOverLen, q.z * oneOverLen);
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tquat<T, P> cross
+	GLM_FUNC_QUALIFIER tquat<T, P> cross
 	(
-		detail::tquat<T, P> const & q1,
-		detail::tquat<T, P> const & q2
+		tquat<T, P> const & q1,
+		tquat<T, P> const & q2
 	)
 	{
-		return detail::tquat<T, P>(
+		return tquat<T, P>(
 			q1.w * q2.w - q1.x * q2.x - q1.y * q2.y - q1.z * q2.z,
 			q1.w * q2.x + q1.x * q2.w + q1.y * q2.z - q1.z * q2.y,
 			q1.w * q2.y + q1.y * q2.w + q1.z * q2.x - q1.x * q2.z,
@@ -435,10 +428,10 @@ namespace detail
 /*
 	// (x * sin(1 - a) * angle / sin(angle)) + (y * sin(a) * angle / sin(angle))
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tquat<T, P> mix
+	GLM_FUNC_QUALIFIER tquat<T, P> mix
 	(
-		detail::tquat<T, P> const & x, 
-		detail::tquat<T, P> const & y, 
+		tquat<T, P> const & x, 
+		tquat<T, P> const & y, 
 		T const & a
 	)
 	{
@@ -446,7 +439,7 @@ namespace detail
 		if(a >= T(1)) return y;
 
 		float fCos = dot(x, y);
-		detail::tquat<T, P> y2(y); //BUG!!! tquat<T, P> y2;
+		tquat<T, P> y2(y); //BUG!!! tquat<T, P> y2;
 		if(fCos < T(0))
 		{
 			y2 = -y;
@@ -469,7 +462,7 @@ namespace detail
 			k1 = sin((T(0) + a) * fAngle) * fOneOverSin;
 		}
 
-		return detail::tquat<T, P>(
+		return tquat<T, P>(
 			k0 * x.w + k1 * y2.w,
 			k0 * x.x + k1 * y2.x,
 			k0 * x.y + k1 * y2.y,
@@ -477,10 +470,10 @@ namespace detail
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tquat<T, P> mix2
+	GLM_FUNC_QUALIFIER tquat<T, P> mix2
 	(
-		detail::tquat<T, P> const & x, 
-		detail::tquat<T, P> const & y, 
+		tquat<T, P> const & x, 
+		tquat<T, P> const & y, 
 		T const & a
 	)
 	{
@@ -515,10 +508,10 @@ namespace detail
 */
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tquat<T, P> mix
+	GLM_FUNC_QUALIFIER tquat<T, P> mix
 	(
-		detail::tquat<T, P> const & x,
-		detail::tquat<T, P> const & y,
+		tquat<T, P> const & x,
+		tquat<T, P> const & y,
 		T const & a
 	)
 	{
@@ -528,7 +521,7 @@ namespace detail
 		if(cosTheta > T(1) - epsilon<T>())
 		{
 			// Linear interpolation
-			return detail::tquat<T, P>(
+			return tquat<T, P>(
 				mix(x.w, y.w, a),
 				mix(x.x, y.x, a),
 				mix(x.y, y.y, a),
@@ -543,10 +536,10 @@ namespace detail
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tquat<T, P> lerp
+	GLM_FUNC_QUALIFIER tquat<T, P> lerp
 	(
-		detail::tquat<T, P> const & x, 
-		detail::tquat<T, P> const & y, 
+		tquat<T, P> const & x, 
+		tquat<T, P> const & y, 
 		T const & a
 	)
 	{
@@ -558,14 +551,14 @@ namespace detail
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tquat<T, P> slerp
+	GLM_FUNC_QUALIFIER tquat<T, P> slerp
 	(
-		detail::tquat<T, P> const & x,
-		detail::tquat<T, P> const & y,
+		tquat<T, P> const & x,
+		tquat<T, P> const & y,
 		T const & a
 	)
 	{
-		detail::tquat<T, P> z = y;
+		tquat<T, P> z = y;
 
 		T cosTheta = dot(x, y);
 
@@ -581,7 +574,7 @@ namespace detail
 		if(cosTheta > T(1) - epsilon<T>())
 		{
 			// Linear interpolation
-			return detail::tquat<T, P>(
+			return tquat<T, P>(
 				mix(x.w, z.w, a),
 				mix(x.x, z.x, a),
 				mix(x.y, z.y, a),
@@ -596,14 +589,14 @@ namespace detail
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tquat<T, P> rotate
+	GLM_FUNC_QUALIFIER tquat<T, P> rotate
 	(
-		detail::tquat<T, P> const & q,
+		tquat<T, P> const & q,
 		T const & angle,
-		detail::tvec3<T, P> const & v
+		tvec3<T, P> const & v
 	)
 	{
-		detail::tvec3<T, P> Tmp = v;
+		tvec3<T, P> Tmp = v;
 
 		// Axis of rotation must be normalised
 		T len = glm::length(Tmp);
@@ -618,23 +611,23 @@ namespace detail
 		T const AngleRad(angle);
 		T const Sin = sin(AngleRad * T(0.5));
 
-		return q * detail::tquat<T, P>(cos(AngleRad * T(0.5)), Tmp.x * Sin, Tmp.y * Sin, Tmp.z * Sin);
-		//return gtc::quaternion::cross(q, detail::tquat<T, P>(cos(AngleRad * T(0.5)), Tmp.x * fSin, Tmp.y * fSin, Tmp.z * fSin));
+		return q * tquat<T, P>(cos(AngleRad * T(0.5)), Tmp.x * Sin, Tmp.y * Sin, Tmp.z * Sin);
+		//return gtc::quaternion::cross(q, tquat<T, P>(cos(AngleRad * T(0.5)), Tmp.x * fSin, Tmp.y * fSin, Tmp.z * fSin));
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec3<T, P> eulerAngles
+	GLM_FUNC_QUALIFIER tvec3<T, P> eulerAngles
 	(
-		detail::tquat<T, P> const & x
+		tquat<T, P> const & x
 	)
 	{
-		return detail::tvec3<T, P>(pitch(x), yaw(x), roll(x));
+		return tvec3<T, P>(pitch(x), yaw(x), roll(x));
 	}
 
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER T roll
 	(
-		detail::tquat<T, P> const & q
+		tquat<T, P> const & q
 	)
 	{
 		return T(atan(T(2) * (q.x * q.y + q.w * q.z), q.w * q.w + q.x * q.x - q.y * q.y - q.z * q.z));
@@ -643,7 +636,7 @@ namespace detail
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER T pitch
 	(
-		detail::tquat<T, P> const & q
+		tquat<T, P> const & q
 	)
 	{
 		return T(atan(T(2) * (q.y * q.z + q.w * q.x), q.w * q.w - q.x * q.x - q.y * q.y + q.z * q.z));
@@ -652,19 +645,19 @@ namespace detail
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER T yaw
 	(
-		detail::tquat<T, P> const & q
+		tquat<T, P> const & q
 	)
 	{
 		return asin(T(-2) * (q.x * q.z - q.w * q.y));
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tmat3x3<T, P> mat3_cast
+	GLM_FUNC_QUALIFIER tmat3x3<T, P> mat3_cast
 	(
-		detail::tquat<T, P> const & q
+		tquat<T, P> const & q
 	)
 	{
-		detail::tmat3x3<T, P> Result(T(1));
+		tmat3x3<T, P> Result(T(1));
 		T qxx(q.x * q.x);
 		T qyy(q.y * q.y);
 		T qzz(q.z * q.z);
@@ -690,18 +683,18 @@ namespace detail
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T, P> mat4_cast
+	GLM_FUNC_QUALIFIER tmat4x4<T, P> mat4_cast
 	(
-		detail::tquat<T, P> const & q
+		tquat<T, P> const & q
 	)
 	{
-		return detail::tmat4x4<T, P>(mat3_cast(q));
+		return tmat4x4<T, P>(mat3_cast(q));
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tquat<T, P> quat_cast
+	GLM_FUNC_QUALIFIER tquat<T, P> quat_cast
 	(
-		detail::tmat3x3<T, P> const & m
+		tmat3x3<T, P> const & m
 	)
 	{
 		T fourXSquaredMinus1 = m[0][0] - m[1][1] - m[2][2];
@@ -730,7 +723,7 @@ namespace detail
 		T biggestVal = sqrt(fourBiggestSquaredMinus1 + T(1)) * T(0.5);
 		T mult = static_cast<T>(0.25) / biggestVal;
 
-		detail::tquat<T, P> Result;
+		tquat<T, P> Result;
 		switch(biggestIndex)
 		{
 		case 0:
@@ -766,44 +759,44 @@ namespace detail
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tquat<T, P> quat_cast
+	GLM_FUNC_QUALIFIER tquat<T, P> quat_cast
 	(
-		detail::tmat4x4<T, P> const & m4
+		tmat4x4<T, P> const & m4
 	)
 	{
-		return quat_cast(detail::tmat3x3<T, P>(m4));
+		return quat_cast(tmat3x3<T, P>(m4));
 	}
 
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER T angle
 	(
-		detail::tquat<T, P> const & x
+		tquat<T, P> const & x
 	)
 	{
 		return acos(x.w) * T(2);
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec3<T, P> axis
+	GLM_FUNC_QUALIFIER tvec3<T, P> axis
 	(
-		detail::tquat<T, P> const & x
+		tquat<T, P> const & x
 	)
 	{
 		T tmp1 = static_cast<T>(1) - x.w * x.w;
 		if(tmp1 <= static_cast<T>(0))
-			return detail::tvec3<T, P>(0, 0, 1);
+			return tvec3<T, P>(0, 0, 1);
 		T tmp2 = static_cast<T>(1) / sqrt(tmp1);
-		return detail::tvec3<T, P>(x.x * tmp2, x.y * tmp2, x.z * tmp2);
+		return tvec3<T, P>(x.x * tmp2, x.y * tmp2, x.z * tmp2);
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tquat<T, P> angleAxis
+	GLM_FUNC_QUALIFIER tquat<T, P> angleAxis
 	(
 		T const & angle,
-		detail::tvec3<T, P> const & v
+		tvec3<T, P> const & v
 	)
 	{
-		detail::tquat<T, P> result;
+		tquat<T, P> result;
 
 		T const a(angle);
 		T const s = glm::sin(a * static_cast<T>(0.5));
@@ -816,78 +809,78 @@ namespace detail
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec4<bool, P> lessThan
+	GLM_FUNC_QUALIFIER tvec4<bool, P> lessThan
 	(
-		detail::tquat<T, P> const & x,
-		detail::tquat<T, P> const & y
+		tquat<T, P> const & x,
+		tquat<T, P> const & y
 	)
 	{
-		detail::tvec4<bool, P> Result;
+		tvec4<bool, P> Result;
 		for(length_t i = 0; i < x.length(); ++i)
 			Result[i] = x[i] < y[i];
 		return Result;
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec4<bool, P> lessThanEqual
+	GLM_FUNC_QUALIFIER tvec4<bool, P> lessThanEqual
 	(
-		detail::tquat<T, P> const & x,
-		detail::tquat<T, P> const & y
+		tquat<T, P> const & x,
+		tquat<T, P> const & y
 	)
 	{
-		detail::tvec4<bool, P> Result;
+		tvec4<bool, P> Result;
 		for(length_t i = 0; i < x.length(); ++i)
 			Result[i] = x[i] <= y[i];
 		return Result;
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec4<bool, P> greaterThan
+	GLM_FUNC_QUALIFIER tvec4<bool, P> greaterThan
 	(
-		detail::tquat<T, P> const & x,
-		detail::tquat<T, P> const & y
+		tquat<T, P> const & x,
+		tquat<T, P> const & y
 	)
 	{
-		detail::tvec4<bool, P> Result;
+		tvec4<bool, P> Result;
 		for(length_t i = 0; i < x.length(); ++i)
 			Result[i] = x[i] > y[i];
 		return Result;
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec4<bool, P> greaterThanEqual
+	GLM_FUNC_QUALIFIER tvec4<bool, P> greaterThanEqual
 	(
-		detail::tquat<T, P> const & x,
-		detail::tquat<T, P> const & y
+		tquat<T, P> const & x,
+		tquat<T, P> const & y
 	)
 	{
-		detail::tvec4<bool, P> Result;
+		tvec4<bool, P> Result;
 		for(length_t i = 0; i < x.length(); ++i)
 			Result[i] = x[i] >= y[i];
 		return Result;
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec4<bool, P> equal
+	GLM_FUNC_QUALIFIER tvec4<bool, P> equal
 	(
-		detail::tquat<T, P> const & x,
-		detail::tquat<T, P> const & y
+		tquat<T, P> const & x,
+		tquat<T, P> const & y
 	)
 	{
-		detail::tvec4<bool, P> Result;
+		tvec4<bool, P> Result;
 		for(length_t i = 0; i < x.length(); ++i)
 			Result[i] = x[i] == y[i];
 		return Result;
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec4<bool, P>  notEqual
+	GLM_FUNC_QUALIFIER tvec4<bool, P>  notEqual
 	(
-		detail::tquat<T, P> const & x,
-		detail::tquat<T, P> const & y
+		tquat<T, P> const & x,
+		tquat<T, P> const & y
 	)
 	{
-		detail::tvec4<bool, P> Result;
+		tvec4<bool, P> Result;
 		for(length_t i = 0; i < x.length(); ++i)
 			Result[i] = x[i] != y[i];
 		return Result;

glm/gtc/random.hpp

@@ -83,7 +83,7 @@ namespace glm
 	/// @param Radius 
 	/// @see gtc_random
 	template <typename T>
-	GLM_FUNC_DECL detail::tvec2<T, defaultp> circularRand(
+	GLM_FUNC_DECL tvec2<T, defaultp> circularRand(
 		T const & Radius);
 	
 	/// Generate a random 3D vector which coordinates are regulary distributed on a sphere of a given radius
@@ -91,7 +91,7 @@ namespace glm
 	/// @param Radius
 	/// @see gtc_random
 	template <typename T>
-	GLM_FUNC_DECL detail::tvec3<T, defaultp> sphericalRand(
+	GLM_FUNC_DECL tvec3<T, defaultp> sphericalRand(
 		T const & Radius);
 	
 	/// Generate a random 2D vector which coordinates are regulary distributed within the area of a disk of a given radius
@@ -99,7 +99,7 @@ namespace glm
 	/// @param Radius
 	/// @see gtc_random
 	template <typename T>
-	GLM_FUNC_DECL detail::tvec2<T, defaultp> diskRand(
+	GLM_FUNC_DECL tvec2<T, defaultp> diskRand(
 		T const & Radius);
 	
 	/// Generate a random 3D vector which coordinates are regulary distributed within the volume of a ball of a given radius
@@ -107,7 +107,7 @@ namespace glm
 	/// @param Radius
 	/// @see gtc_random
 	template <typename T>
-	GLM_FUNC_DECL detail::tvec3<T, defaultp> ballRand(
+	GLM_FUNC_DECL tvec3<T, defaultp> ballRand(
 		T const & Radius);
 	
 	/// @}

glm/gtc/random.inl

@@ -42,32 +42,32 @@ namespace detail
 	};
 
 	template <precision P>
-	struct compute_rand<uint8, P, detail::tvec1>
+	struct compute_rand<uint8, P, tvec1>
 	{
-		GLM_FUNC_QUALIFIER static detail::tvec1<uint8, P> call()
+		GLM_FUNC_QUALIFIER static tvec1<uint8, P> call()
 		{
-			return detail::tvec1<uint8, P>(
+			return tvec1<uint8, P>(
 				std::rand()) % std::numeric_limits<uint8>::max();
 		}
 	};
 
 	template <precision P>
-	struct compute_rand<uint8, P, detail::tvec2>
+	struct compute_rand<uint8, P, tvec2>
 	{
-		GLM_FUNC_QUALIFIER static detail::tvec2<uint8, P> call()
+		GLM_FUNC_QUALIFIER static tvec2<uint8, P> call()
 		{
-			return detail::tvec2<uint8, P>(
+			return tvec2<uint8, P>(
 				std::rand(),
 				std::rand()) % std::numeric_limits<uint8>::max();
 		}
 	};
 
 	template <precision P>
-	struct compute_rand<uint8, P, detail::tvec3>
+	struct compute_rand<uint8, P, tvec3>
 	{
-		GLM_FUNC_QUALIFIER static detail::tvec3<uint8, P> call()
+		GLM_FUNC_QUALIFIER static tvec3<uint8, P> call()
 		{
-			return detail::tvec3<uint8, P>(
+			return tvec3<uint8, P>(
 				std::rand(),
 				std::rand(),
 				std::rand()) % std::numeric_limits<uint8>::max();
@@ -75,11 +75,11 @@ namespace detail
 	};
 
 	template <precision P>
-	struct compute_rand<uint8, P, detail::tvec4>
+	struct compute_rand<uint8, P, tvec4>
 	{
-		GLM_FUNC_QUALIFIER static detail::tvec4<uint8, P> call()
+		GLM_FUNC_QUALIFIER static tvec4<uint8, P> call()
 		{
-			return detail::tvec4<uint8, P>(
+			return tvec4<uint8, P>(
 				std::rand(),
 				std::rand(),
 				std::rand(),
@@ -297,9 +297,9 @@ namespace detail
 		float const & Max
 	)
 	{
-		return detail::compute_linearRand<float, highp, detail::tvec1>::call(
-			detail::tvec1<float, highp>(Min),
-			detail::tvec1<float, highp>(Max)).x;
+		return detail::compute_linearRand<float, highp, tvec1>::call(
+			tvec1<float, highp>(Min),
+			tvec1<float, highp>(Max)).x;
 	}
 
 	template <>
@@ -309,9 +309,9 @@ namespace detail
 		double const & Max
 	)
 	{
-		return detail::compute_linearRand<double, highp, detail::tvec1>::call(
-			detail::tvec1<double, highp>(Min),
-			detail::tvec1<double, highp>(Max)).x;
+		return detail::compute_linearRand<double, highp, tvec1>::call(
+			tvec1<double, highp>(Min),
+			tvec1<double, highp>(Max)).x;
 	}
 
 	template <typename genType>
@@ -337,19 +337,19 @@ namespace detail
 	VECTORIZE_VEC_VEC(gaussRand)
 
 	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec2<T, defaultp> diskRand
+	GLM_FUNC_QUALIFIER tvec2<T, defaultp> diskRand
 	(
 		T const & Radius
 	)
 	{		
-		detail::tvec2<T, defaultp> Result(T(0));
+		tvec2<T, defaultp> Result(T(0));
 		T LenRadius(T(0));
 		
 		do
 		{
 			Result = linearRand(
-				detail::tvec2<T, defaultp>(-Radius),
-				detail::tvec2<T, defaultp>(Radius));
+				tvec2<T, defaultp>(-Radius),
+				tvec2<T, defaultp>(Radius));
 			LenRadius = length(Result);
 		}
 		while(LenRadius > Radius);
@@ -358,19 +358,19 @@ namespace detail
 	}
 	
 	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec3<T, defaultp> ballRand
+	GLM_FUNC_QUALIFIER tvec3<T, defaultp> ballRand
 	(
 		T const & Radius
 	)
 	{		
-		detail::tvec3<T, defaultp> Result(T(0));
+		tvec3<T, defaultp> Result(T(0));
 		T LenRadius(T(0));
 		
 		do
 		{
 			Result = linearRand(
-				detail::tvec3<T, defaultp>(-Radius),
-				detail::tvec3<T, defaultp>(Radius));
+				tvec3<T, defaultp>(-Radius),
+				tvec3<T, defaultp>(Radius));
 			LenRadius = length(Result);
 		}
 		while(LenRadius > Radius);
@@ -379,17 +379,17 @@ namespace detail
 	}
 	
 	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec2<T, defaultp> circularRand
+	GLM_FUNC_QUALIFIER tvec2<T, defaultp> circularRand
 	(
 		T const & Radius
 	)
 	{
 		T a = linearRand(T(0), T(6.283185307179586476925286766559f));
-		return detail::tvec2<T, defaultp>(cos(a), sin(a)) * Radius;		
+		return tvec2<T, defaultp>(cos(a), sin(a)) * Radius;		
 	}
 	
 	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec3<T, defaultp> sphericalRand
+	GLM_FUNC_QUALIFIER tvec3<T, defaultp> sphericalRand
 	(
 		T const & Radius
 	)
@@ -402,6 +402,6 @@ namespace detail
 		T x = r * cos(a);
 		T y = r * sin(a);
 	
-		return detail::tvec3<T, defaultp>(x, y, z) * Radius;	
+		return tvec3<T, defaultp>(x, y, z) * Radius;	
 	}
 }//namespace glm

glm/gtc/type_precision.hpp

@@ -272,70 +272,70 @@ namespace glm
 
 	/// 8 bit signed integer scalar type.
 	/// @see gtc_type_precision
-	typedef detail::tvec1<i8, defaultp> i8vec1;
+	typedef tvec1<i8, defaultp> i8vec1;
 	
 	/// 8 bit signed integer vector of 2 components type.
 	/// @see gtc_type_precision
-	typedef detail::tvec2<i8, defaultp> i8vec2;
+	typedef tvec2<i8, defaultp> i8vec2;
 
 	/// 8 bit signed integer vector of 3 components type.
 	/// @see gtc_type_precision
-	typedef detail::tvec3<i8, defaultp> i8vec3;
+	typedef tvec3<i8, defaultp> i8vec3;
 
 	/// 8 bit signed integer vector of 4 components type.
 	/// @see gtc_type_precision
-	typedef detail::tvec4<i8, defaultp> i8vec4;
+	typedef tvec4<i8, defaultp> i8vec4;
 
 
 	/// 16 bit signed integer scalar type.
 	/// @see gtc_type_precision
-	typedef detail::tvec1<i16, defaultp> i16vec1;
+	typedef tvec1<i16, defaultp> i16vec1;
 	
 	/// 16 bit signed integer vector of 2 components type.
 	/// @see gtc_type_precision
-	typedef detail::tvec2<i16, defaultp> i16vec2;
+	typedef tvec2<i16, defaultp> i16vec2;
 
 	/// 16 bit signed integer vector of 3 components type.
 	/// @see gtc_type_precision
-	typedef detail::tvec3<i16, defaultp> i16vec3;
+	typedef tvec3<i16, defaultp> i16vec3;
 
 	/// 16 bit signed integer vector of 4 components type.
 	/// @see gtc_type_precision
-	typedef detail::tvec4<i16, defaultp> i16vec4;
+	typedef tvec4<i16, defaultp> i16vec4;
 
 
 	/// 32 bit signed integer scalar type.
 	/// @see gtc_type_precision
-	typedef detail::tvec1<i32, defaultp> i32vec1;
+	typedef tvec1<i32, defaultp> i32vec1;
 	
 	/// 32 bit signed integer vector of 2 components type.
 	/// @see gtc_type_precision
-	typedef detail::tvec2<i32, defaultp> i32vec2;
+	typedef tvec2<i32, defaultp> i32vec2;
 
 	/// 32 bit signed integer vector of 3 components type.
 	/// @see gtc_type_precision
-	typedef detail::tvec3<i32, defaultp> i32vec3;
+	typedef tvec3<i32, defaultp> i32vec3;
 
 	/// 32 bit signed integer vector of 4 components type.
 	/// @see gtc_type_precision
-	typedef detail::tvec4<i32, defaultp> i32vec4;
+	typedef tvec4<i32, defaultp> i32vec4;
 
 
 	/// 64 bit signed integer scalar type.
 	/// @see gtc_type_precision
-	typedef detail::tvec1<i64, defaultp> i64vec1;
+	typedef tvec1<i64, defaultp> i64vec1;
 	
 	/// 64 bit signed integer vector of 2 components type.
 	/// @see gtc_type_precision
-	typedef detail::tvec2<i64, defaultp> i64vec2;
+	typedef tvec2<i64, defaultp> i64vec2;
 
 	/// 64 bit signed integer vector of 3 components type.
 	/// @see gtc_type_precision
-	typedef detail::tvec3<i64, defaultp> i64vec3;
+	typedef tvec3<i64, defaultp> i64vec3;
 
 	/// 64 bit signed integer vector of 4 components type.
 	/// @see gtc_type_precision
-	typedef detail::tvec4<i64, defaultp> i64vec4;
+	typedef tvec4<i64, defaultp> i64vec4;
 
 
 	/////////////////////////////
@@ -544,70 +544,70 @@ namespace glm
 
 	/// Default precision 8 bit unsigned integer scalar type.
 	/// @see gtc_type_precision
-	typedef detail::tvec1<u8, defaultp> u8vec1;
+	typedef tvec1<u8, defaultp> u8vec1;
 	
 	/// Default precision 8 bit unsigned integer vector of 2 components type.
 	/// @see gtc_type_precision
-	typedef detail::tvec2<u8, defaultp> u8vec2;
+	typedef tvec2<u8, defaultp> u8vec2;
 
 	/// Default precision 8 bit unsigned integer vector of 3 components type.
 	/// @see gtc_type_precision
-	typedef detail::tvec3<u8, defaultp> u8vec3;
+	typedef tvec3<u8, defaultp> u8vec3;
 
 	/// Default precision 8 bit unsigned integer vector of 4 components type.
 	/// @see gtc_type_precision
-	typedef detail::tvec4<u8, defaultp> u8vec4;
+	typedef tvec4<u8, defaultp> u8vec4;
 
 
 	/// Default precision 16 bit unsigned integer scalar type.
 	/// @see gtc_type_precision
-	typedef detail::tvec1<u16, defaultp> u16vec1;
+	typedef tvec1<u16, defaultp> u16vec1;
 	
 	/// Default precision 16 bit unsigned integer vector of 2 components type.
 	/// @see gtc_type_precision
-	typedef detail::tvec2<u16, defaultp> u16vec2;
+	typedef tvec2<u16, defaultp> u16vec2;
 
 	/// Default precision 16 bit unsigned integer vector of 3 components type.
 	/// @see gtc_type_precision
-	typedef detail::tvec3<u16, defaultp> u16vec3;
+	typedef tvec3<u16, defaultp> u16vec3;
 
 	/// Default precision 16 bit unsigned integer vector of 4 components type.
 	/// @see gtc_type_precision
-	typedef detail::tvec4<u16, defaultp> u16vec4;
+	typedef tvec4<u16, defaultp> u16vec4;
 
 
 	/// Default precision 32 bit unsigned integer scalar type.
 	/// @see gtc_type_precision
-	typedef detail::tvec1<u32, defaultp> u32vec1;
+	typedef tvec1<u32, defaultp> u32vec1;
 	
 	/// Default precision 32 bit unsigned integer vector of 2 components type.
 	/// @see gtc_type_precision
-	typedef detail::tvec2<u32, defaultp> u32vec2;
+	typedef tvec2<u32, defaultp> u32vec2;
 
 	/// Default precision 32 bit unsigned integer vector of 3 components type.
 	/// @see gtc_type_precision
-	typedef detail::tvec3<u32, defaultp> u32vec3;
+	typedef tvec3<u32, defaultp> u32vec3;
 
 	/// Default precision 32 bit unsigned integer vector of 4 components type.
 	/// @see gtc_type_precision
-	typedef detail::tvec4<u32, defaultp> u32vec4;
+	typedef tvec4<u32, defaultp> u32vec4;
 
 
 	/// Default precision 64 bit unsigned integer scalar type.
 	/// @see gtc_type_precision
-	typedef detail::tvec1<u64, defaultp> u64vec1;
+	typedef tvec1<u64, defaultp> u64vec1;
 	
 	/// Default precision 64 bit unsigned integer vector of 2 components type.
 	/// @see gtc_type_precision
-	typedef detail::tvec2<u64, defaultp> u64vec2;
+	typedef tvec2<u64, defaultp> u64vec2;
 
 	/// Default precision 64 bit unsigned integer vector of 3 components type.
 	/// @see gtc_type_precision
-	typedef detail::tvec3<u64, defaultp> u64vec3;
+	typedef tvec3<u64, defaultp> u64vec3;
 
 	/// Default precision 64 bit unsigned integer vector of 4 components type.
 	/// @see gtc_type_precision
-	typedef detail::tvec4<u64, defaultp> u64vec4;
+	typedef tvec4<u64, defaultp> u64vec4;
 
 
 	//////////////////////
@@ -642,53 +642,53 @@ namespace glm
 
 	/// Single-precision floating-point vector of 1 component.
 	/// @see gtc_type_precision
-	typedef detail::tvec1<float, defaultp> fvec1;
+	typedef tvec1<float, defaultp> fvec1;
 
 	/// Single-precision floating-point vector of 2 components.
 	/// @see gtc_type_precision
-	typedef detail::tvec2<float, defaultp> fvec2;
+	typedef tvec2<float, defaultp> fvec2;
 
 	/// Single-precision floating-point vector of 3 components.
 	/// @see gtc_type_precision
-	typedef detail::tvec3<float, defaultp> fvec3;
+	typedef tvec3<float, defaultp> fvec3;
 
 	/// Single-precision floating-point vector of 4 components.
 	/// @see gtc_type_precision
-	typedef detail::tvec4<float, defaultp> fvec4;
+	typedef tvec4<float, defaultp> fvec4;
 
 	
 	/// Single-precision floating-point vector of 1 component.
 	/// @see gtc_type_precision
-	typedef detail::tvec1<f32, defaultp> f32vec1;
+	typedef tvec1<f32, defaultp> f32vec1;
 
 	/// Single-precision floating-point vector of 2 components.
 	/// @see gtc_type_precision
-	typedef detail::tvec2<f32, defaultp> f32vec2;
+	typedef tvec2<f32, defaultp> f32vec2;
 
 	/// Single-precision floating-point vector of 3 components.
 	/// @see gtc_type_precision
-	typedef detail::tvec3<f32, defaultp> f32vec3;
+	typedef tvec3<f32, defaultp> f32vec3;
 
 	/// Single-precision floating-point vector of 4 components.
 	/// @see gtc_type_precision
-	typedef detail::tvec4<f32, defaultp> f32vec4;
+	typedef tvec4<f32, defaultp> f32vec4;
 
 
 	/// Double-precision floating-point vector of 1 component.
 	/// @see gtc_type_precision
-	typedef detail::tvec1<f64, defaultp> f64vec1;
+	typedef tvec1<f64, defaultp> f64vec1;
 
 	/// Double-precision floating-point vector of 2 components.
 	/// @see gtc_type_precision
-	typedef detail::tvec2<f64, defaultp> f64vec2;
+	typedef tvec2<f64, defaultp> f64vec2;
 
 	/// Double-precision floating-point vector of 3 components.
 	/// @see gtc_type_precision
-	typedef detail::tvec3<f64, defaultp> f64vec3;
+	typedef tvec3<f64, defaultp> f64vec3;
 
 	/// Double-precision floating-point vector of 4 components.
 	/// @see gtc_type_precision
-	typedef detail::tvec4<f64, defaultp> f64vec4;
+	typedef tvec4<f64, defaultp> f64vec4;
 
 
 	//////////////////////
@@ -700,15 +700,15 @@ namespace glm
 
 	/// Single-precision floating-point 2x2 matrix.
 	/// @see gtc_type_precision
-	typedef detail::tmat2x2<f32, defaultp> fmat2;
+	typedef tmat2x2<f32, defaultp> fmat2;
 
 	/// Single-precision floating-point 3x3 matrix.
 	/// @see gtc_type_precision
-	typedef detail::tmat3x3<f32, defaultp> fmat3;
+	typedef tmat3x3<f32, defaultp> fmat3;
 
 	/// Single-precision floating-point 4x4 matrix.
 	/// @see gtc_type_precision
-	typedef detail::tmat4x4<f32, defaultp> fmat4;
+	typedef tmat4x4<f32, defaultp> fmat4;
 
 
 	/// Single-precision floating-point 1x1 matrix.
@@ -717,39 +717,39 @@ namespace glm
 
 	/// Single-precision floating-point 2x2 matrix.
 	/// @see gtc_type_precision
-	typedef detail::tmat2x2<f32, defaultp> fmat2x2;
+	typedef tmat2x2<f32, defaultp> fmat2x2;
 
 	/// Single-precision floating-point 2x3 matrix.
 	/// @see gtc_type_precision
-	typedef detail::tmat2x3<f32, defaultp> fmat2x3;
+	typedef tmat2x3<f32, defaultp> fmat2x3;
 
 	/// Single-precision floating-point 2x4 matrix.
 	/// @see gtc_type_precision
-	typedef detail::tmat2x4<f32, defaultp> fmat2x4;
+	typedef tmat2x4<f32, defaultp> fmat2x4;
 
 	/// Single-precision floating-point 3x2 matrix.
 	/// @see gtc_type_precision
-	typedef detail::tmat3x2<f32, defaultp> fmat3x2;
+	typedef tmat3x2<f32, defaultp> fmat3x2;
 
 	/// Single-precision floating-point 3x3 matrix.
 	/// @see gtc_type_precision
-	typedef detail::tmat3x3<f32, defaultp> fmat3x3;
+	typedef tmat3x3<f32, defaultp> fmat3x3;
 
 	/// Single-precision floating-point 3x4 matrix.
 	/// @see gtc_type_precision
-	typedef detail::tmat3x4<f32, defaultp> fmat3x4;
+	typedef tmat3x4<f32, defaultp> fmat3x4;
 
 	/// Single-precision floating-point 4x2 matrix.
 	/// @see gtc_type_precision
-	typedef detail::tmat4x2<f32, defaultp> fmat4x2;
+	typedef tmat4x2<f32, defaultp> fmat4x2;
 
 	/// Single-precision floating-point 4x3 matrix.
 	/// @see gtc_type_precision
-	typedef detail::tmat4x3<f32, defaultp> fmat4x3;
+	typedef tmat4x3<f32, defaultp> fmat4x3;
 
 	/// Single-precision floating-point 4x4 matrix.
 	/// @see gtc_type_precision
-	typedef detail::tmat4x4<f32, defaultp> fmat4x4;
+	typedef tmat4x4<f32, defaultp> fmat4x4;
 
 
 	/// Single-precision floating-point 1x1 matrix.
@@ -758,15 +758,15 @@ namespace glm
 
 	/// Single-precision floating-point 2x2 matrix.
 	/// @see gtc_type_precision
-	typedef detail::tmat2x2<f32, defaultp> f32mat2;
+	typedef tmat2x2<f32, defaultp> f32mat2;
 
 	/// Single-precision floating-point 3x3 matrix.
 	/// @see gtc_type_precision
-	typedef detail::tmat3x3<f32, defaultp> f32mat3;
+	typedef tmat3x3<f32, defaultp> f32mat3;
 
 	/// Single-precision floating-point 4x4 matrix.
 	/// @see gtc_type_precision
-	typedef detail::tmat4x4<f32, defaultp> f32mat4;
+	typedef tmat4x4<f32, defaultp> f32mat4;
 
 
 	/// Single-precision floating-point 1x1 matrix.
@@ -775,39 +775,39 @@ namespace glm
 
 	/// Single-precision floating-point 2x2 matrix.
 	/// @see gtc_type_precision
-	typedef detail::tmat2x2<f32, defaultp> f32mat2x2;
+	typedef tmat2x2<f32, defaultp> f32mat2x2;
 
 	/// Single-precision floating-point 2x3 matrix.
 	/// @see gtc_type_precision
-	typedef detail::tmat2x3<f32, defaultp> f32mat2x3;
+	typedef tmat2x3<f32, defaultp> f32mat2x3;
 
 	/// Single-precision floating-point 2x4 matrix.
 	/// @see gtc_type_precision
-	typedef detail::tmat2x4<f32, defaultp> f32mat2x4;
+	typedef tmat2x4<f32, defaultp> f32mat2x4;
 
 	/// Single-precision floating-point 3x2 matrix.
 	/// @see gtc_type_precision
-	typedef detail::tmat3x2<f32, defaultp> f32mat3x2;
+	typedef tmat3x2<f32, defaultp> f32mat3x2;
 
 	/// Single-precision floating-point 3x3 matrix.
 	/// @see gtc_type_precision
-	typedef detail::tmat3x3<f32, defaultp> f32mat3x3;
+	typedef tmat3x3<f32, defaultp> f32mat3x3;
 
 	/// Single-precision floating-point 3x4 matrix.
 	/// @see gtc_type_precision
-	typedef detail::tmat3x4<f32, defaultp> f32mat3x4;
+	typedef tmat3x4<f32, defaultp> f32mat3x4;
 
 	/// Single-precision floating-point 4x2 matrix.
 	/// @see gtc_type_precision
-	typedef detail::tmat4x2<f32, defaultp> f32mat4x2;
+	typedef tmat4x2<f32, defaultp> f32mat4x2;
 
 	/// Single-precision floating-point 4x3 matrix.
 	/// @see gtc_type_precision
-	typedef detail::tmat4x3<f32, defaultp> f32mat4x3;
+	typedef tmat4x3<f32, defaultp> f32mat4x3;
 
 	/// Single-precision floating-point 4x4 matrix.
 	/// @see gtc_type_precision
-	typedef detail::tmat4x4<f32, defaultp> f32mat4x4;
+	typedef tmat4x4<f32, defaultp> f32mat4x4;
 
 
 	/// Double-precision floating-point 1x1 matrix.
@@ -816,15 +816,15 @@ namespace glm
 
 	/// Double-precision floating-point 2x2 matrix.
 	/// @see gtc_type_precision
-	typedef detail::tmat2x2<f64, defaultp> f64mat2;
+	typedef tmat2x2<f64, defaultp> f64mat2;
 
 	/// Double-precision floating-point 3x3 matrix.
 	/// @see gtc_type_precision
-	typedef detail::tmat3x3<f64, defaultp> f64mat3;
+	typedef tmat3x3<f64, defaultp> f64mat3;
 
 	/// Double-precision floating-point 4x4 matrix.
 	/// @see gtc_type_precision
-	typedef detail::tmat4x4<f64, defaultp> f64mat4;
+	typedef tmat4x4<f64, defaultp> f64mat4;
 
 
 	/// Double-precision floating-point 1x1 matrix.
@@ -833,39 +833,39 @@ namespace glm
 
 	/// Double-precision floating-point 2x2 matrix.
 	/// @see gtc_type_precision
-	typedef detail::tmat2x2<f64, defaultp> f64mat2x2;
+	typedef tmat2x2<f64, defaultp> f64mat2x2;
 
 	/// Double-precision floating-point 2x3 matrix.
 	/// @see gtc_type_precision
-	typedef detail::tmat2x3<f64, defaultp> f64mat2x3;
+	typedef tmat2x3<f64, defaultp> f64mat2x3;
 
 	/// Double-precision floating-point 2x4 matrix.
 	/// @see gtc_type_precision
-	typedef detail::tmat2x4<f64, defaultp> f64mat2x4;
+	typedef tmat2x4<f64, defaultp> f64mat2x4;
 
 	/// Double-precision floating-point 3x2 matrix.
 	/// @see gtc_type_precision
-	typedef detail::tmat3x2<f64, defaultp> f64mat3x2;
+	typedef tmat3x2<f64, defaultp> f64mat3x2;
 
 	/// Double-precision floating-point 3x3 matrix.
 	/// @see gtc_type_precision
-	typedef detail::tmat3x3<f64, defaultp> f64mat3x3;
+	typedef tmat3x3<f64, defaultp> f64mat3x3;
 
 	/// Double-precision floating-point 3x4 matrix.
 	/// @see gtc_type_precision
-	typedef detail::tmat3x4<f64, defaultp> f64mat3x4;
+	typedef tmat3x4<f64, defaultp> f64mat3x4;
 
 	/// Double-precision floating-point 4x2 matrix.
 	/// @see gtc_type_precision
-	typedef detail::tmat4x2<f64, defaultp> f64mat4x2;
+	typedef tmat4x2<f64, defaultp> f64mat4x2;
 
 	/// Double-precision floating-point 4x3 matrix.
 	/// @see gtc_type_precision
-	typedef detail::tmat4x3<f64, defaultp> f64mat4x3;
+	typedef tmat4x3<f64, defaultp> f64mat4x3;
 
 	/// Double-precision floating-point 4x4 matrix.
 	/// @see gtc_type_precision
-	typedef detail::tmat4x4<f64, defaultp> f64mat4x4;
+	typedef tmat4x4<f64, defaultp> f64mat4x4;
 
 
 	//////////////////////////
@@ -873,11 +873,11 @@ namespace glm
 
 	/// Single-precision floating-point quaternion.
 	/// @see gtc_type_precision
-	typedef detail::tquat<f32, defaultp> f32quat;
+	typedef tquat<f32, defaultp> f32quat;
 
 	/// Double-precision floating-point quaternion.
 	/// @see gtc_type_precision
-	typedef detail::tquat<f64, defaultp> f64quat;
+	typedef tquat<f64, defaultp> f64quat;
 
 	/// @}
 }//namespace glm

glm/gtc/type_ptr.hpp

@@ -91,83 +91,83 @@ namespace glm
 	/// Build a vector from a pointer.
 	/// @see gtc_type_ptr
 	template<typename T>
-	GLM_FUNC_DECL detail::tvec2<T, defaultp> make_vec2(T const * const ptr);
+	GLM_FUNC_DECL tvec2<T, defaultp> make_vec2(T const * const ptr);
 
 	/// Build a vector from a pointer.
 	/// @see gtc_type_ptr
 	template<typename T>
-	GLM_FUNC_DECL detail::tvec3<T, defaultp> make_vec3(T const * const ptr);
+	GLM_FUNC_DECL tvec3<T, defaultp> make_vec3(T const * const ptr);
 
 	/// Build a vector from a pointer.
 	/// @see gtc_type_ptr
 	template<typename T>
-	GLM_FUNC_DECL detail::tvec4<T, defaultp> make_vec4(T const * const ptr);
+	GLM_FUNC_DECL tvec4<T, defaultp> make_vec4(T const * const ptr);
 
 	/// Build a matrix from a pointer.
 	/// @see gtc_type_ptr
 	template<typename T>
-	GLM_FUNC_DECL detail::tmat2x2<T, defaultp> make_mat2x2(T const * const ptr);
+	GLM_FUNC_DECL tmat2x2<T, defaultp> make_mat2x2(T const * const ptr);
 
 	/// Build a matrix from a pointer.
 	/// @see gtc_type_ptr
 	template<typename T>
-	GLM_FUNC_DECL detail::tmat2x3<T, defaultp> make_mat2x3(T const * const ptr);
+	GLM_FUNC_DECL tmat2x3<T, defaultp> make_mat2x3(T const * const ptr);
 
 	/// Build a matrix from a pointer.
 	/// @see gtc_type_ptr
 	template<typename T>
-	GLM_FUNC_DECL detail::tmat2x4<T, defaultp> make_mat2x4(T const * const ptr);
+	GLM_FUNC_DECL tmat2x4<T, defaultp> make_mat2x4(T const * const ptr);
 
 	/// Build a matrix from a pointer.
 	/// @see gtc_type_ptr
 	template<typename T>
-	GLM_FUNC_DECL detail::tmat3x2<T, defaultp> make_mat3x2(T const * const ptr);
+	GLM_FUNC_DECL tmat3x2<T, defaultp> make_mat3x2(T const * const ptr);
 
 	/// Build a matrix from a pointer.
 	/// @see gtc_type_ptr
 	template<typename T>
-	GLM_FUNC_DECL detail::tmat3x3<T, defaultp> make_mat3x3(T const * const ptr);
+	GLM_FUNC_DECL tmat3x3<T, defaultp> make_mat3x3(T const * const ptr);
 
 	/// Build a matrix from a pointer.
 	/// @see gtc_type_ptr
 	template<typename T>
-	GLM_FUNC_DECL detail::tmat3x4<T, defaultp> make_mat3x4(T const * const ptr);
+	GLM_FUNC_DECL tmat3x4<T, defaultp> make_mat3x4(T const * const ptr);
 
 	/// Build a matrix from a pointer.
 	/// @see gtc_type_ptr
 	template<typename T>
-	GLM_FUNC_DECL detail::tmat4x2<T, defaultp> make_mat4x2(
+	GLM_FUNC_DECL tmat4x2<T, defaultp> make_mat4x2(
 		T const * const ptr);
 
 	/// Build a matrix from a pointer.
 	/// @see gtc_type_ptr
 	template<typename T>
-	GLM_FUNC_DECL detail::tmat4x3<T, defaultp> make_mat4x3(T const * const ptr);
+	GLM_FUNC_DECL tmat4x3<T, defaultp> make_mat4x3(T const * const ptr);
 
 	/// Build a matrix from a pointer.
 	/// @see gtc_type_ptr
 	template<typename T>
-	GLM_FUNC_DECL detail::tmat4x4<T, defaultp> make_mat4x4(T const * const ptr);
+	GLM_FUNC_DECL tmat4x4<T, defaultp> make_mat4x4(T const * const ptr);
 	
 	/// Build a matrix from a pointer.
 	/// @see gtc_type_ptr
 	template<typename T>
-	GLM_FUNC_DECL detail::tmat2x2<T, defaultp> make_mat2(T const * const ptr);
+	GLM_FUNC_DECL tmat2x2<T, defaultp> make_mat2(T const * const ptr);
 
 	/// Build a matrix from a pointer.
 	/// @see gtc_type_ptr
 	template<typename T>
-	GLM_FUNC_DECL detail::tmat3x3<T, defaultp> make_mat3(T const * const ptr);
+	GLM_FUNC_DECL tmat3x3<T, defaultp> make_mat3(T const * const ptr);
 		
 	/// Build a matrix from a pointer.
 	/// @see gtc_type_ptr
 	template<typename T>
-	GLM_FUNC_DECL detail::tmat4x4<T, defaultp> make_mat4(T const * const ptr);
+	GLM_FUNC_DECL tmat4x4<T, defaultp> make_mat4(T const * const ptr);
 
 	/// Build a quaternion from a pointer.
 	/// @see gtc_type_ptr
 	template<typename T>
-	GLM_FUNC_DECL detail::tquat<T, defaultp> make_quat(T const * const ptr);
+	GLM_FUNC_DECL tquat<T, defaultp> make_quat(T const * const ptr);
 
 	/// @}
 }//namespace glm

glm/gtc/type_ptr.inl

@@ -38,7 +38,7 @@ namespace glm
 	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER T const * value_ptr
 	(
-		detail::tvec2<T, P> const & vec
+		tvec2<T, P> const & vec
 	)
 	{
 		return &(vec.x);
@@ -49,7 +49,7 @@ namespace glm
 	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER T * value_ptr
 	(
-		detail::tvec2<T, P> & vec
+		tvec2<T, P> & vec
 	)
 	{
 		return &(vec.x);
@@ -60,7 +60,7 @@ namespace glm
 	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER T const * value_ptr
 	(
-		detail::tvec3<T, P> const & vec
+		tvec3<T, P> const & vec
 	)
 	{
 		return &(vec.x);
@@ -71,7 +71,7 @@ namespace glm
 	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER T * value_ptr
 	(
-		detail::tvec3<T, P> & vec
+		tvec3<T, P> & vec
 	)
 	{
 		return &(vec.x);
@@ -82,7 +82,7 @@ namespace glm
 	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER T const * value_ptr
 	(	
-		detail::tvec4<T, P> const & vec
+		tvec4<T, P> const & vec
 	)
 	{
 		return &(vec.x);
@@ -93,7 +93,7 @@ namespace glm
 	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER T * value_ptr
 	(	
-		detail::tvec4<T, P> & vec
+		tvec4<T, P> & vec
 	)
 	{
 		return &(vec.x);
@@ -104,7 +104,7 @@ namespace glm
 	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER T const * value_ptr
 	(
-		detail::tmat2x2<T, P> const & mat
+		tmat2x2<T, P> const & mat
 	)
 	{
 		return &(mat[0].x);
@@ -115,7 +115,7 @@ namespace glm
 	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER T * value_ptr
 	(
-		detail::tmat2x2<T, P> & mat
+		tmat2x2<T, P> & mat
 	)
 	{
 		return &(mat[0].x);
@@ -126,7 +126,7 @@ namespace glm
 	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER T const * value_ptr
 	(
-		detail::tmat3x3<T, P> const & mat
+		tmat3x3<T, P> const & mat
 	)
 	{
 		return &(mat[0].x);
@@ -137,7 +137,7 @@ namespace glm
 	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER T * value_ptr
 	(
-		detail::tmat3x3<T, P> & mat
+		tmat3x3<T, P> & mat
 	)
 	{
 		return &(mat[0].x);
@@ -148,7 +148,7 @@ namespace glm
 	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER T const * value_ptr
 	(
-		detail::tmat4x4<T, P> const & mat
+		tmat4x4<T, P> const & mat
 	)
 	{
 		return &(mat[0].x);
@@ -159,7 +159,7 @@ namespace glm
 	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER T * value_ptr
 	(
-		detail::tmat4x4<T, P> & mat
+		tmat4x4<T, P> & mat
 	)
 	{
 		return &(mat[0].x);
@@ -170,7 +170,7 @@ namespace glm
 	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER T const * value_ptr
 	(
-		detail::tmat2x3<T, P> const & mat
+		tmat2x3<T, P> const & mat
 	)
 	{
 		return &(mat[0].x);
@@ -181,7 +181,7 @@ namespace glm
 	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER T * value_ptr
 	(
-		detail::tmat2x3<T, P> & mat
+		tmat2x3<T, P> & mat
 	)
 	{
 		return &(mat[0].x);
@@ -192,7 +192,7 @@ namespace glm
 	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER T const * value_ptr
 	(
-		detail::tmat3x2<T, P> const & mat
+		tmat3x2<T, P> const & mat
 	)
 	{
 		return &(mat[0].x);
@@ -203,7 +203,7 @@ namespace glm
 	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER T * value_ptr
 	(
-		detail::tmat3x2<T, P> & mat
+		tmat3x2<T, P> & mat
 	)
 	{
 		return &(mat[0].x);
@@ -214,7 +214,7 @@ namespace glm
 	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER T const * value_ptr
 	(
-		detail::tmat2x4<T, P> const & mat
+		tmat2x4<T, P> const & mat
 	)
 	{
 		return &(mat[0].x);
@@ -225,7 +225,7 @@ namespace glm
 	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER T * value_ptr
 	(
-		detail::tmat2x4<T, P> & mat
+		tmat2x4<T, P> & mat
 	)
 	{
 		return &(mat[0].x);
@@ -236,7 +236,7 @@ namespace glm
 	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER T const * value_ptr
 	(
-		detail::tmat4x2<T, P> const & mat
+		tmat4x2<T, P> const & mat
 	)
 	{
 		return &(mat[0].x);
@@ -247,7 +247,7 @@ namespace glm
 	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER T * value_ptr
 	(	
-		detail::tmat4x2<T, P> & mat
+		tmat4x2<T, P> & mat
 	)
 	{
 		return &(mat[0].x);
@@ -258,7 +258,7 @@ namespace glm
 	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER T const * value_ptr
 	(
-		detail::tmat3x4<T, P> const & mat
+		tmat3x4<T, P> const & mat
 	)
 	{
 		return &(mat[0].x);
@@ -269,7 +269,7 @@ namespace glm
 	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER T * value_ptr
 	(
-		detail::tmat3x4<T, P> & mat
+		tmat3x4<T, P> & mat
 	)
 	{
 		return &(mat[0].x);
@@ -280,7 +280,7 @@ namespace glm
 	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER T const * value_ptr
 	(
-		detail::tmat4x3<T, P> const & mat
+		tmat4x3<T, P> const & mat
 	)
 	{
 		return &(mat[0].x);
@@ -289,7 +289,7 @@ namespace glm
 	/// Return the address to the data of the matrix input.
 	/// @see gtc_type_ptr
 	template<typename T, precision P>
-	GLM_FUNC_QUALIFIER T * value_ptr(detail::tmat4x3<T, P> & mat)
+	GLM_FUNC_QUALIFIER T * value_ptr(tmat4x3<T, P> & mat)
 	{
 		return &(mat[0].x);
 	}
@@ -299,7 +299,7 @@ namespace glm
 	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER T const * value_ptr
 	(
-		detail::tquat<T, P> const & q
+		tquat<T, P> const & q
 	)
 	{
 		return &(q[0]);
@@ -310,7 +310,7 @@ namespace glm
 	template<typename T, precision P>
 	GLM_FUNC_QUALIFIER T * value_ptr
 	(
-		detail::tquat<T, P> & q
+		tquat<T, P> & q
 	)
 	{
 		return &(q[0]);
@@ -319,127 +319,127 @@ namespace glm
 	/// Build a vector from a pointer.
 	/// @see gtc_type_ptr
 	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec2<T, defaultp> make_vec2(T const * const ptr)
+	GLM_FUNC_QUALIFIER tvec2<T, defaultp> make_vec2(T const * const ptr)
 	{
-		detail::tvec2<T, defaultp> Result;
-		memcpy(value_ptr(Result), ptr, sizeof(detail::tvec2<T, defaultp>));
+		tvec2<T, defaultp> Result;
+		memcpy(value_ptr(Result), ptr, sizeof(tvec2<T, defaultp>));
 		return Result;
 	}
 
 	/// Build a vector from a pointer.
 	/// @see gtc_type_ptr
 	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec3<T, defaultp> make_vec3(T const * const ptr)
+	GLM_FUNC_QUALIFIER tvec3<T, defaultp> make_vec3(T const * const ptr)
 	{
-		detail::tvec3<T, defaultp> Result;
-		memcpy(value_ptr(Result), ptr, sizeof(detail::tvec3<T, defaultp>));
+		tvec3<T, defaultp> Result;
+		memcpy(value_ptr(Result), ptr, sizeof(tvec3<T, defaultp>));
 		return Result;
 	}
 
 	/// Build a vector from a pointer.
 	/// @see gtc_type_ptr
 	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec4<T, defaultp> make_vec4(T const * const ptr)
+	GLM_FUNC_QUALIFIER tvec4<T, defaultp> make_vec4(T const * const ptr)
 	{
-		detail::tvec4<T, defaultp> Result;
-		memcpy(value_ptr(Result), ptr, sizeof(detail::tvec4<T, defaultp>));
+		tvec4<T, defaultp> Result;
+		memcpy(value_ptr(Result), ptr, sizeof(tvec4<T, defaultp>));
 		return Result;
 	}
 
 	/// Build a matrix from a pointer.
 	/// @see gtc_type_ptr
 	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat2x2<T, defaultp> make_mat2x2(T const * const ptr)
+	GLM_FUNC_QUALIFIER tmat2x2<T, defaultp> make_mat2x2(T const * const ptr)
 	{
-		detail::tmat2x2<T, defaultp> Result;
-		memcpy(value_ptr(Result), ptr, sizeof(detail::tmat2x2<T, defaultp>));
+		tmat2x2<T, defaultp> Result;
+		memcpy(value_ptr(Result), ptr, sizeof(tmat2x2<T, defaultp>));
 		return Result;
 	}
 
 	/// Build a matrix from a pointer.
 	/// @see gtc_type_ptr
 	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat2x3<T, defaultp> make_mat2x3(T const * const ptr)
+	GLM_FUNC_QUALIFIER tmat2x3<T, defaultp> make_mat2x3(T const * const ptr)
 	{
-		detail::tmat2x3<T, defaultp> Result;
-		memcpy(value_ptr(Result), ptr, sizeof(detail::tmat2x3<T, defaultp>));
+		tmat2x3<T, defaultp> Result;
+		memcpy(value_ptr(Result), ptr, sizeof(tmat2x3<T, defaultp>));
 		return Result;
 	}
 
 	/// Build a matrix from a pointer.
 	/// @see gtc_type_ptr
 	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat2x4<T, defaultp> make_mat2x4(T const * const ptr)
+	GLM_FUNC_QUALIFIER tmat2x4<T, defaultp> make_mat2x4(T const * const ptr)
 	{
-		detail::tmat2x4<T, defaultp> Result;
-		memcpy(value_ptr(Result), ptr, sizeof(detail::tmat2x4<T, defaultp>));
+		tmat2x4<T, defaultp> Result;
+		memcpy(value_ptr(Result), ptr, sizeof(tmat2x4<T, defaultp>));
 		return Result;
 	}
 
 	/// Build a matrix from a pointer.
 	/// @see gtc_type_ptr
 	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat3x2<T, defaultp> make_mat3x2(T const * const ptr)
+	GLM_FUNC_QUALIFIER tmat3x2<T, defaultp> make_mat3x2(T const * const ptr)
 	{
-		detail::tmat3x2<T, defaultp> Result;
-		memcpy(value_ptr(Result), ptr, sizeof(detail::tmat3x2<T, defaultp>));
+		tmat3x2<T, defaultp> Result;
+		memcpy(value_ptr(Result), ptr, sizeof(tmat3x2<T, defaultp>));
 		return Result;
 	}
 
 	//! Build a matrix from a pointer.
 	/// @see gtc_type_ptr
 	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat3x3<T, defaultp> make_mat3x3(T const * const ptr)
+	GLM_FUNC_QUALIFIER tmat3x3<T, defaultp> make_mat3x3(T const * const ptr)
 	{
-		detail::tmat3x3<T, defaultp> Result;
-		memcpy(value_ptr(Result), ptr, sizeof(detail::tmat3x3<T, defaultp>));
+		tmat3x3<T, defaultp> Result;
+		memcpy(value_ptr(Result), ptr, sizeof(tmat3x3<T, defaultp>));
 		return Result;
 	}
 
 	//! Build a matrix from a pointer.
 	/// @see gtc_type_ptr
 	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat3x4<T, defaultp> make_mat3x4(T const * const ptr)
+	GLM_FUNC_QUALIFIER tmat3x4<T, defaultp> make_mat3x4(T const * const ptr)
 	{
-		detail::tmat3x4<T, defaultp> Result;
-		memcpy(value_ptr(Result), ptr, sizeof(detail::tmat3x4<T, defaultp>));
+		tmat3x4<T, defaultp> Result;
+		memcpy(value_ptr(Result), ptr, sizeof(tmat3x4<T, defaultp>));
 		return Result;
 	}
 
 	//! Build a matrix from a pointer.
 	/// @see gtc_type_ptr
 	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat4x2<T, defaultp> make_mat4x2(T const * const ptr)
+	GLM_FUNC_QUALIFIER tmat4x2<T, defaultp> make_mat4x2(T const * const ptr)
 	{
-		detail::tmat4x2<T, defaultp> Result;
-		memcpy(value_ptr(Result), ptr, sizeof(detail::tmat4x2<T, defaultp>));
+		tmat4x2<T, defaultp> Result;
+		memcpy(value_ptr(Result), ptr, sizeof(tmat4x2<T, defaultp>));
 		return Result;
 	}
 
 	//! Build a matrix from a pointer.
 	/// @see gtc_type_ptr
 	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat4x3<T, defaultp> make_mat4x3(T const * const ptr)
+	GLM_FUNC_QUALIFIER tmat4x3<T, defaultp> make_mat4x3(T const * const ptr)
 	{
-		detail::tmat4x3<T, defaultp> Result;
-		memcpy(value_ptr(Result), ptr, sizeof(detail::tmat4x3<T, defaultp>));
+		tmat4x3<T, defaultp> Result;
+		memcpy(value_ptr(Result), ptr, sizeof(tmat4x3<T, defaultp>));
 		return Result;
 	}
 
 	//! Build a matrix from a pointer.
 	/// @see gtc_type_ptr
 	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T, defaultp> make_mat4x4(T const * const ptr)
+	GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> make_mat4x4(T const * const ptr)
 	{
-		detail::tmat4x4<T, defaultp> Result;
-		memcpy(value_ptr(Result), ptr, sizeof(detail::tmat4x4<T, defaultp>));
+		tmat4x4<T, defaultp> Result;
+		memcpy(value_ptr(Result), ptr, sizeof(tmat4x4<T, defaultp>));
 		return Result;
 	}
 
 	//! Build a matrix from a pointer.
 	/// @see gtc_type_ptr
 	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat2x2<T, defaultp> make_mat2(T const * const ptr)
+	GLM_FUNC_QUALIFIER tmat2x2<T, defaultp> make_mat2(T const * const ptr)
 	{
 		return make_mat2x2(ptr);
 	}
@@ -447,7 +447,7 @@ namespace glm
 	//! Build a matrix from a pointer.
 	/// @see gtc_type_ptr
 	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat3x3<T, defaultp> make_mat3(T const * const ptr)
+	GLM_FUNC_QUALIFIER tmat3x3<T, defaultp> make_mat3(T const * const ptr)
 	{
 		return make_mat3x3(ptr);
 	}
@@ -455,7 +455,7 @@ namespace glm
 	//! Build a matrix from a pointer.
 	/// @see gtc_type_ptr
 	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T, defaultp> make_mat4(T const * const ptr)
+	GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> make_mat4(T const * const ptr)
 	{
 		return make_mat4x4(ptr);
 	}
@@ -463,10 +463,10 @@ namespace glm
 	//! Build a quaternion from a pointer.
 	/// @see gtc_type_ptr
 	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tquat<T, defaultp> make_quat(T const * const ptr)
+	GLM_FUNC_QUALIFIER tquat<T, defaultp> make_quat(T const * const ptr)
 	{
-		detail::tquat<T, defaultp> Result;
-		memcpy(value_ptr(Result), ptr, sizeof(detail::tquat<T, defaultp>));
+		tquat<T, defaultp> Result;
+		memcpy(value_ptr(Result), ptr, sizeof(tquat<T, defaultp>));
 		return Result;
 	}
 

glm/gtx/bit.inl

@@ -41,35 +41,35 @@ namespace glm
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec2<int, P> highestBitValue
+	GLM_FUNC_QUALIFIER tvec2<int, P> highestBitValue
 	(
-		detail::tvec2<T, P> const & value
+		tvec2<T, P> const & value
 	)
 	{
-		return detail::tvec2<int, P>(
+		return tvec2<int, P>(
 			highestBitValue(value[0]),
 			highestBitValue(value[1]));
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec3<int, P> highestBitValue
+	GLM_FUNC_QUALIFIER tvec3<int, P> highestBitValue
 	(
-		detail::tvec3<T, P> const & value
+		tvec3<T, P> const & value
 	)
 	{
-		return detail::tvec3<int, P>(
+		return tvec3<int, P>(
 			highestBitValue(value[0]),
 			highestBitValue(value[1]),
 			highestBitValue(value[2]));
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec4<int, P> highestBitValue
+	GLM_FUNC_QUALIFIER tvec4<int, P> highestBitValue
 	(
-		detail::tvec4<T, P> const & value
+		tvec4<T, P> const & value
 	)
 	{
-		return detail::tvec4<int, P>(
+		return tvec4<int, P>(
 			highestBitValue(value[0]),
 			highestBitValue(value[1]),
 			highestBitValue(value[2]),
@@ -91,35 +91,35 @@ namespace glm
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec2<bool, P> isPowerOfTwo
+	GLM_FUNC_QUALIFIER tvec2<bool, P> isPowerOfTwo
 	(
-		detail::tvec2<T, P> const & value
+		tvec2<T, P> const & value
 	)
 	{
-		return detail::tvec2<bool, P>(
+		return tvec2<bool, P>(
 			isPowerOfTwo(value[0]),
 			isPowerOfTwo(value[1]));
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec3<bool, P> isPowerOfTwo
+	GLM_FUNC_QUALIFIER tvec3<bool, P> isPowerOfTwo
 	(
-		detail::tvec3<T, P> const & value
+		tvec3<T, P> const & value
 	)
 	{
-		return detail::tvec3<bool, P>(
+		return tvec3<bool, P>(
 			isPowerOfTwo(value[0]),
 			isPowerOfTwo(value[1]),
 			isPowerOfTwo(value[2]));
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec4<bool, P> isPowerOfTwo
+	GLM_FUNC_QUALIFIER tvec4<bool, P> isPowerOfTwo
 	(
-		detail::tvec4<T, P> const & value
+		tvec4<T, P> const & value
 	)
 	{
-		return detail::tvec4<bool, P>(
+		return tvec4<bool, P>(
 			isPowerOfTwo(value[0]),
 			isPowerOfTwo(value[1]),
 			isPowerOfTwo(value[2]),
@@ -189,38 +189,38 @@ namespace glm
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec2<T, P> bitRotateRight
+	GLM_FUNC_QUALIFIER tvec2<T, P> bitRotateRight
 	(
-		detail::tvec2<T, P> const & Value, 
+		tvec2<T, P> const & Value, 
 		std::size_t Shift
 	)
 	{
-		return detail::tvec2<T, P>(
+		return tvec2<T, P>(
 			bitRotateRight(Value[0], Shift),
 			bitRotateRight(Value[1], Shift));
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec3<T, P> bitRotateRight
+	GLM_FUNC_QUALIFIER tvec3<T, P> bitRotateRight
 	(
-		detail::tvec3<T, P> const & Value, 
+		tvec3<T, P> const & Value, 
 		std::size_t Shift
 	)
 	{
-		return detail::tvec3<T, P>(
+		return tvec3<T, P>(
 			bitRotateRight(Value[0], Shift),
 			bitRotateRight(Value[1], Shift),
 			bitRotateRight(Value[2], Shift));
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec4<T, P> bitRotateRight
+	GLM_FUNC_QUALIFIER tvec4<T, P> bitRotateRight
 	(
-		detail::tvec4<T, P> const & Value, 
+		tvec4<T, P> const & Value, 
 		std::size_t Shift
 	)
 	{
-		return detail::tvec4<T, P>(
+		return tvec4<T, P>(
 			bitRotateRight(Value[0], Shift),
 			bitRotateRight(Value[1], Shift),
 			bitRotateRight(Value[2], Shift),
@@ -237,38 +237,38 @@ namespace glm
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec2<T, P> bitRotateLeft
+	GLM_FUNC_QUALIFIER tvec2<T, P> bitRotateLeft
 	(
-		detail::tvec2<T, P> const & Value, 
+		tvec2<T, P> const & Value, 
 		std::size_t Shift
 	)
 	{
-		return detail::tvec2<T, P>(
+		return tvec2<T, P>(
 			bitRotateLeft(Value[0], Shift),
 			bitRotateLeft(Value[1], Shift));
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec3<T, P> bitRotateLeft
+	GLM_FUNC_QUALIFIER tvec3<T, P> bitRotateLeft
 	(
-		detail::tvec3<T, P> const & Value, 
+		tvec3<T, P> const & Value, 
 		std::size_t Shift
 	)
 	{
-		return detail::tvec3<T, P>(
+		return tvec3<T, P>(
 			bitRotateLeft(Value[0], Shift),
 			bitRotateLeft(Value[1], Shift),
 			bitRotateLeft(Value[2], Shift));
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec4<T, P> bitRotateLeft
+	GLM_FUNC_QUALIFIER tvec4<T, P> bitRotateLeft
 	(
-		detail::tvec4<T, P> const & Value, 
+		tvec4<T, P> const & Value, 
 		std::size_t Shift
 	)
 	{
-		return detail::tvec4<T, P>(
+		return tvec4<T, P>(
 			bitRotateLeft(Value[0], Shift),
 			bitRotateLeft(Value[1], Shift),
 			bitRotateLeft(Value[2], Shift),

glm/gtx/closest_point.hpp

@@ -52,17 +52,17 @@ namespace glm
 	/// Find the point on a straight line which is the closet of a point. 
 	/// @see gtx_closest_point
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tvec3<T, P> closestPointOnLine(
-		detail::tvec3<T, P> const & point,
-		detail::tvec3<T, P> const & a, 
-		detail::tvec3<T, P> const & b);
+	GLM_FUNC_DECL tvec3<T, P> closestPointOnLine(
+		tvec3<T, P> const & point,
+		tvec3<T, P> const & a, 
+		tvec3<T, P> const & b);
 	
 	/// 2d lines work as well	
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tvec2<T, P> closestPointOnLine(
-		detail::tvec2<T, P> const & point,
-		detail::tvec2<T, P> const & a, 
-		detail::tvec2<T, P> const & b);	
+	GLM_FUNC_DECL tvec2<T, P> closestPointOnLine(
+		tvec2<T, P> const & point,
+		tvec2<T, P> const & a, 
+		tvec2<T, P> const & b);	
 
 	/// @}
 }// namespace glm

glm/gtx/closest_point.inl

@@ -10,16 +10,16 @@
 namespace glm
 {
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec3<T, P> closestPointOnLine
+	GLM_FUNC_QUALIFIER tvec3<T, P> closestPointOnLine
 	(
-		detail::tvec3<T, P> const & point,
-		detail::tvec3<T, P> const & a,
-		detail::tvec3<T, P> const & b
+		tvec3<T, P> const & point,
+		tvec3<T, P> const & a,
+		tvec3<T, P> const & b
 	)
 	{
 		T LineLength = distance(a, b);
-		detail::tvec3<T, P> Vector = point - a;
-		detail::tvec3<T, P> LineDirection = (b - a) / LineLength;
+		tvec3<T, P> Vector = point - a;
+		tvec3<T, P> LineDirection = (b - a) / LineLength;
 
 		// Project Vector to LineDirection to get the distance of point from a
 		T Distance = dot(Vector, LineDirection);
@@ -30,16 +30,16 @@ namespace glm
 	}
 	
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec2<T, P> closestPointOnLine
+	GLM_FUNC_QUALIFIER tvec2<T, P> closestPointOnLine
 	(
-		detail::tvec2<T, P> const & point,
-		detail::tvec2<T, P> const & a,
-		detail::tvec2<T, P> const & b
+		tvec2<T, P> const & point,
+		tvec2<T, P> const & a,
+		tvec2<T, P> const & b
 	)
 	{
 		T LineLength = distance(a, b);
-		detail::tvec2<T, P> Vector = point - a;
-		detail::tvec2<T, P> LineDirection = (b - a) / LineLength;
+		tvec2<T, P> Vector = point - a;
+		tvec2<T, P> LineDirection = (b - a) / LineLength;
 
 		// Project Vector to LineDirection to get the distance of point from a
 		T Distance = dot(Vector, LineDirection);

glm/gtx/color_space.hpp

@@ -52,40 +52,40 @@ namespace glm
 	/// Converts a color from HSV color space to its color in RGB color space.
 	/// @see gtx_color_space
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tvec3<T, P> rgbColor(
-		detail::tvec3<T, P> const & hsvValue);
+	GLM_FUNC_DECL tvec3<T, P> rgbColor(
+		tvec3<T, P> const & hsvValue);
 
 	/// Converts a color from RGB color space to its color in HSV color space.
 	/// @see gtx_color_space
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tvec3<T, P> hsvColor(
-		detail::tvec3<T, P> const & rgbValue);
+	GLM_FUNC_DECL tvec3<T, P> hsvColor(
+		tvec3<T, P> const & rgbValue);
 		
 	/// Build a saturation matrix.
 	/// @see gtx_color_space
 	template <typename T>
-	GLM_FUNC_DECL detail::tmat4x4<T, defaultp> saturation(
+	GLM_FUNC_DECL tmat4x4<T, defaultp> saturation(
 		T const s);
 
 	/// Modify the saturation of a color.
 	/// @see gtx_color_space
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tvec3<T, P> saturation(
+	GLM_FUNC_DECL tvec3<T, P> saturation(
 		T const s,
-		detail::tvec3<T, P> const & color);
+		tvec3<T, P> const & color);
 		
 	/// Modify the saturation of a color.
 	/// @see gtx_color_space
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tvec4<T, P> saturation(
+	GLM_FUNC_DECL tvec4<T, P> saturation(
 		T const s,
-		detail::tvec4<T, P> const & color);
+		tvec4<T, P> const & color);
 		
 	/// Compute color luminosity associating ratios (0.33, 0.59, 0.11) to RGB canals.
 	/// @see gtx_color_space
 	template <typename T, precision P>
 	GLM_FUNC_DECL T luminosity(
-		detail::tvec3<T, P> const & color);
+		tvec3<T, P> const & color);
 
 	/// @}
 }//namespace glm

glm/gtx/color_space.inl

@@ -10,14 +10,14 @@
 namespace glm
 {
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec3<T, P> rgbColor(const detail::tvec3<T, P>& hsvColor)
+	GLM_FUNC_QUALIFIER tvec3<T, P> rgbColor(const tvec3<T, P>& hsvColor)
 	{
-		detail::tvec3<T, P> hsv = hsvColor;
-		detail::tvec3<T, P> rgbColor;
+		tvec3<T, P> hsv = hsvColor;
+		tvec3<T, P> rgbColor;
 
 		if(hsv.y == static_cast<T>(0))
 			// achromatic (grey)
-			rgbColor = detail::tvec3<T, P>(hsv.z);
+			rgbColor = tvec3<T, P>(hsv.z);
 		else
 		{
 			T sector = floor(hsv.x / T(60));
@@ -67,9 +67,9 @@ namespace glm
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec3<T, P> hsvColor(const detail::tvec3<T, P>& rgbColor)
+	GLM_FUNC_QUALIFIER tvec3<T, P> hsvColor(const tvec3<T, P>& rgbColor)
 	{
-		detail::tvec3<T, P> hsv = rgbColor;
+		tvec3<T, P> hsv = rgbColor;
 		float Min   = min(min(rgbColor.r, rgbColor.g), rgbColor.b);
 		float Max   = max(max(rgbColor.r, rgbColor.g), rgbColor.b);
 		float Delta = Max - Min;
@@ -107,15 +107,15 @@ namespace glm
 	}
 
 	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T, defaultp> saturation(T const s)
+	GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> saturation(T const s)
 	{
-		detail::tvec3<T, defaultp> rgbw = detail::tvec3<T, defaultp>(T(0.2126), T(0.7152), T(0.0722));
+		tvec3<T, defaultp> rgbw = tvec3<T, defaultp>(T(0.2126), T(0.7152), T(0.0722));
 
 		T col0 = (T(1) - s) * rgbw.r;
 		T col1 = (T(1) - s) * rgbw.g;
 		T col2 = (T(1) - s) * rgbw.b;
 
-		detail::tmat4x4<T, defaultp> result(T(1));
+		tmat4x4<T, defaultp> result(T(1));
 		result[0][0] = col0 + s;
 		result[0][1] = col0;
 		result[0][2] = col0;
@@ -129,21 +129,21 @@ namespace glm
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec3<T, P> saturation(const T s, const detail::tvec3<T, P>& color)
+	GLM_FUNC_QUALIFIER tvec3<T, P> saturation(const T s, const tvec3<T, P>& color)
 	{
-		return detail::tvec3<T, P>(saturation(s) * detail::tvec4<T, P>(color, T(0)));
+		return tvec3<T, P>(saturation(s) * tvec4<T, P>(color, T(0)));
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec4<T, P> saturation(const T s, const detail::tvec4<T, P>& color)
+	GLM_FUNC_QUALIFIER tvec4<T, P> saturation(const T s, const tvec4<T, P>& color)
 	{
 		return saturation(s) * color;
 	}
 
 	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER T luminosity(const detail::tvec3<T, P>& color)
+	GLM_FUNC_QUALIFIER T luminosity(const tvec3<T, P>& color)
 	{
-		const detail::tvec3<T, P> tmp = detail::tvec3<T, P>(0.33, 0.59, 0.11);
+		const tvec3<T, P> tmp = tvec3<T, P>(0.33, 0.59, 0.11);
 		return dot(color, tmp);
 	}
 }//namespace glm

glm/gtx/color_space_YCoCg.hpp

@@ -52,28 +52,28 @@ namespace glm
 	/// Convert a color from RGB color space to YCoCg color space.
 	/// @see gtx_color_space_YCoCg
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tvec3<T, P> rgb2YCoCg(
-		detail::tvec3<T, P> const & rgbColor);
+	GLM_FUNC_DECL tvec3<T, P> rgb2YCoCg(
+		tvec3<T, P> const & rgbColor);
 
 	/// Convert a color from YCoCg color space to RGB color space.
 	/// @see gtx_color_space_YCoCg
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tvec3<T, P> YCoCg2rgb(
-		detail::tvec3<T, P> const & YCoCgColor);
+	GLM_FUNC_DECL tvec3<T, P> YCoCg2rgb(
+		tvec3<T, P> const & YCoCgColor);
 
 	/// Convert a color from RGB color space to YCoCgR color space.
 	/// @see "YCoCg-R: A Color Space with RGB Reversibility and Low Dynamic Range"
 	/// @see gtx_color_space_YCoCg
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tvec3<T, P> rgb2YCoCgR(
-		detail::tvec3<T, P> const & rgbColor);
+	GLM_FUNC_DECL tvec3<T, P> rgb2YCoCgR(
+		tvec3<T, P> const & rgbColor);
 
 	/// Convert a color from YCoCgR color space to RGB color space.
 	/// @see "YCoCg-R: A Color Space with RGB Reversibility and Low Dynamic Range"
 	/// @see gtx_color_space_YCoCg
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tvec3<T, P> YCoCgR2rgb(
-		detail::tvec3<T, P> const & YCoCgColor);
+	GLM_FUNC_DECL tvec3<T, P> YCoCgR2rgb(
+		tvec3<T, P> const & YCoCgColor);
 
 	/// @}
 }//namespace glm

glm/gtx/color_space_YCoCg.inl

@@ -10,12 +10,12 @@
 namespace glm
 {
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec3<T, P> rgb2YCoCg
+	GLM_FUNC_QUALIFIER tvec3<T, P> rgb2YCoCg
 	(
-		detail::tvec3<T, P> const & rgbColor
+		tvec3<T, P> const & rgbColor
 	)
 	{
-		detail::tvec3<T, P> result;
+		tvec3<T, P> result;
 		result.x/*Y */ =   rgbColor.r / T(4) + rgbColor.g / T(2) + rgbColor.b / T(4);
 		result.y/*Co*/ =   rgbColor.r / T(2) + rgbColor.g * T(0) - rgbColor.b / T(2);
 		result.z/*Cg*/ = - rgbColor.r / T(4) + rgbColor.g / T(2) - rgbColor.b / T(4);
@@ -23,12 +23,12 @@ namespace glm
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec3<T, P> rgb2YCoCgR
+	GLM_FUNC_QUALIFIER tvec3<T, P> rgb2YCoCgR
 	(
-		detail::tvec3<T, P> const & rgbColor
+		tvec3<T, P> const & rgbColor
 	)
 	{
-		detail::tvec3<T, P> result;
+		tvec3<T, P> result;
 		result.x/*Y */ = rgbColor.g / T(2) + (rgbColor.r + rgbColor.b) / T(4);
 		result.y/*Co*/ = rgbColor.r - rgbColor.b;
 		result.z/*Cg*/ = rgbColor.g - (rgbColor.r + rgbColor.b) / T(2);
@@ -36,12 +36,12 @@ namespace glm
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec3<T, P> YCoCg2rgb
+	GLM_FUNC_QUALIFIER tvec3<T, P> YCoCg2rgb
 	(
-		detail::tvec3<T, P> const & YCoCgColor
+		tvec3<T, P> const & YCoCgColor
 	)
 	{
-		detail::tvec3<T, P> result;
+		tvec3<T, P> result;
 		result.r = YCoCgColor.x + YCoCgColor.y - YCoCgColor.z;
 		result.g = YCoCgColor.x                + YCoCgColor.z;
 		result.b = YCoCgColor.x - YCoCgColor.y - YCoCgColor.z;
@@ -49,12 +49,12 @@ namespace glm
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec3<T, P> YCoCgR2rgb
+	GLM_FUNC_QUALIFIER tvec3<T, P> YCoCgR2rgb
 	(
-		detail::tvec3<T, P> const & YCoCgRColor
+		tvec3<T, P> const & YCoCgRColor
 	)
 	{
-		detail::tvec3<T, P> result;
+		tvec3<T, P> result;
 		T tmp = YCoCgRColor.x - (YCoCgRColor.z / T(2));
 		result.g = YCoCgRColor.z + tmp;
 		result.b = tmp - (YCoCgRColor.y / T(2));

glm/gtx/common.inl

@@ -43,53 +43,53 @@ namespace glm
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER typename detail::tvec1<T, P>::bool_type isdenormal
+	GLM_FUNC_QUALIFIER typename tvec1<T, P>::bool_type isdenormal
 	(
-		detail::tvec1<T, P> const & x
+		tvec1<T, P> const & x
 	)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'isdenormal' only accept floating-point inputs");
 
-		return typename detail::tvec1<T, P>::bool_type(
+		return typename tvec1<T, P>::bool_type(
 			isdenormal(x.x));
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER typename detail::tvec2<T, P>::bool_type isdenormal
+	GLM_FUNC_QUALIFIER typename tvec2<T, P>::bool_type isdenormal
 	(
-		detail::tvec2<T, P> const & x
+		tvec2<T, P> const & x
 	)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'isdenormal' only accept floating-point inputs");
 
-		return typename detail::tvec2<T, P>::bool_type(
+		return typename tvec2<T, P>::bool_type(
 			isdenormal(x.x),
 			isdenormal(x.y));
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER typename detail::tvec3<T, P>::bool_type isdenormal
+	GLM_FUNC_QUALIFIER typename tvec3<T, P>::bool_type isdenormal
 	(
-		detail::tvec3<T, P> const & x
+		tvec3<T, P> const & x
 	)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'isdenormal' only accept floating-point inputs");
 
-		return typename detail::tvec3<T, P>::bool_type(
+		return typename tvec3<T, P>::bool_type(
 			isdenormal(x.x),
 			isdenormal(x.y),
 			isdenormal(x.z));
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER typename detail::tvec4<T, P>::bool_type isdenormal
+	GLM_FUNC_QUALIFIER typename tvec4<T, P>::bool_type isdenormal
 	(
-		detail::tvec4<T, P> const & x
+		tvec4<T, P> const & x
 	)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'isdenormal' only accept floating-point inputs");
 
-		return typename detail::tvec4<T, P>::bool_type(
+		return typename tvec4<T, P>::bool_type(
 			isdenormal(x.x),
 			isdenormal(x.y),
 			isdenormal(x.z),

glm/gtx/compatibility.hpp

@@ -61,94 +61,94 @@ namespace glm
 	/// @{
 
 	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, precision P> GLM_FUNC_QUALIFIER detail::tvec2<T, P> lerp(const detail::tvec2<T, P>& x, const detail::tvec2<T, P>& 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, precision P> GLM_FUNC_QUALIFIER tvec2<T, P> lerp(const tvec2<T, P>& x, const tvec2<T, P>& 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, precision P> GLM_FUNC_QUALIFIER detail::tvec3<T, P> lerp(const detail::tvec3<T, P>& x, const detail::tvec3<T, P>& 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, precision P> GLM_FUNC_QUALIFIER detail::tvec4<T, P> lerp(const detail::tvec4<T, P>& x, const detail::tvec4<T, P>& 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, precision P> GLM_FUNC_QUALIFIER detail::tvec2<T, P> lerp(const detail::tvec2<T, P>& x, const detail::tvec2<T, P>& y, const detail::tvec2<T, P>& a){return mix(x, y, a);}	//!< \brief Returns the component-wise result of x * (1.0 - a) + y * a, i.e., the linear blend of x and y using vector a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
-	template <typename T, precision P> GLM_FUNC_QUALIFIER detail::tvec3<T, P> lerp(const detail::tvec3<T, P>& x, const detail::tvec3<T, P>& y, const detail::tvec3<T, P>& a){return mix(x, y, a);}	//!< \brief Returns the component-wise result of x * (1.0 - a) + y * a, i.e., the linear blend of x and y using vector a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
-	template <typename T, precision P> GLM_FUNC_QUALIFIER detail::tvec4<T, P> lerp(const detail::tvec4<T, P>& x, const detail::tvec4<T, P>& y, const detail::tvec4<T, P>& a){return mix(x, y, a);}	//!< \brief Returns the component-wise result of x * (1.0 - a) + y * a, i.e., the linear blend of x and y using vector a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
+	template <typename T, precision P> GLM_FUNC_QUALIFIER tvec3<T, P> lerp(const tvec3<T, P>& x, const tvec3<T, P>& 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, precision P> GLM_FUNC_QUALIFIER tvec4<T, P> lerp(const tvec4<T, P>& x, const tvec4<T, P>& 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, precision P> GLM_FUNC_QUALIFIER tvec2<T, P> lerp(const tvec2<T, P>& x, const tvec2<T, P>& y, const tvec2<T, P>& a){return mix(x, y, a);}	//!< \brief Returns the component-wise result of x * (1.0 - a) + y * a, i.e., the linear blend of x and y using vector a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
+	template <typename T, precision P> GLM_FUNC_QUALIFIER tvec3<T, P> lerp(const tvec3<T, P>& x, const tvec3<T, P>& y, const tvec3<T, P>& a){return mix(x, y, a);}	//!< \brief Returns the component-wise result of x * (1.0 - a) + y * a, i.e., the linear blend of x and y using vector a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
+	template <typename T, precision P> GLM_FUNC_QUALIFIER tvec4<T, P> lerp(const tvec4<T, P>& x, const tvec4<T, P>& y, const tvec4<T, P>& a){return mix(x, y, a);}	//!< \brief Returns the component-wise result of x * (1.0 - a) + y * a, i.e., the linear blend of x and y using vector a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
 
-	template <typename T, precision P> GLM_FUNC_QUALIFIER T slerp(detail::tquat<T, P> const & x, detail::tquat<T, P> const & y, T const & a){return mix(x, y, a);} //!< \brief Returns the slurp interpolation between two quaternions.
+	template <typename T, precision P> GLM_FUNC_QUALIFIER T slerp(tquat<T, P> const & x, tquat<T, P> const & y, T const & a){return mix(x, y, a);} //!< \brief Returns the slurp interpolation between two quaternions.
 
 	template <typename T, precision P> GLM_FUNC_QUALIFIER T saturate(T x){return clamp(x, T(0), T(1));}														//!< \brief Returns clamp(x, 0, 1) for each component in x. (From GLM_GTX_compatibility)
-	template <typename T, precision P> GLM_FUNC_QUALIFIER detail::tvec2<T, P> saturate(const detail::tvec2<T, P>& x){return clamp(x, T(0), T(1));}					//!< \brief Returns clamp(x, 0, 1) for each component in x. (From GLM_GTX_compatibility)
-	template <typename T, precision P> GLM_FUNC_QUALIFIER detail::tvec3<T, P> saturate(const detail::tvec3<T, P>& x){return clamp(x, T(0), T(1));}					//!< \brief Returns clamp(x, 0, 1) for each component in x. (From GLM_GTX_compatibility)
-	template <typename T, precision P> GLM_FUNC_QUALIFIER detail::tvec4<T, P> saturate(const detail::tvec4<T, P>& x){return clamp(x, T(0), T(1));}					//!< \brief Returns clamp(x, 0, 1) for each component in x. (From GLM_GTX_compatibility)
+	template <typename T, precision P> GLM_FUNC_QUALIFIER tvec2<T, P> saturate(const tvec2<T, P>& x){return clamp(x, T(0), T(1));}					//!< \brief Returns clamp(x, 0, 1) for each component in x. (From GLM_GTX_compatibility)
+	template <typename T, precision P> GLM_FUNC_QUALIFIER tvec3<T, P> saturate(const tvec3<T, P>& x){return clamp(x, T(0), T(1));}					//!< \brief Returns clamp(x, 0, 1) for each component in x. (From GLM_GTX_compatibility)
+	template <typename T, precision P> GLM_FUNC_QUALIFIER tvec4<T, P> saturate(const tvec4<T, P>& x){return clamp(x, T(0), T(1));}					//!< \brief Returns clamp(x, 0, 1) for each component in x. (From GLM_GTX_compatibility)
 
 	template <typename T, precision P> GLM_FUNC_QUALIFIER T atan2(T x, T y){return atan(x, y);}																//!< \brief Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0. (From GLM_GTX_compatibility)
-	template <typename T, precision P> GLM_FUNC_QUALIFIER detail::tvec2<T, P> atan2(const detail::tvec2<T, P>& x, const detail::tvec2<T, P>& y){return atan(x, y);}	//!< \brief Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0. (From GLM_GTX_compatibility)
-	template <typename T, precision P> GLM_FUNC_QUALIFIER detail::tvec3<T, P> atan2(const detail::tvec3<T, P>& x, const detail::tvec3<T, P>& y){return atan(x, y);}	//!< \brief Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0. (From GLM_GTX_compatibility)
-	template <typename T, precision P> GLM_FUNC_QUALIFIER detail::tvec4<T, P> atan2(const detail::tvec4<T, P>& x, const detail::tvec4<T, P>& y){return atan(x, y);}	//!< \brief Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0. (From GLM_GTX_compatibility)
+	template <typename T, precision P> GLM_FUNC_QUALIFIER tvec2<T, P> atan2(const tvec2<T, P>& x, const tvec2<T, P>& y){return atan(x, y);}	//!< \brief Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0. (From GLM_GTX_compatibility)
+	template <typename T, precision P> GLM_FUNC_QUALIFIER tvec3<T, P> atan2(const tvec3<T, P>& x, const tvec3<T, P>& y){return atan(x, y);}	//!< \brief Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0. (From GLM_GTX_compatibility)
+	template <typename T, precision P> GLM_FUNC_QUALIFIER tvec4<T, P> atan2(const tvec4<T, P>& x, const tvec4<T, P>& y){return atan(x, y);}	//!< \brief Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0. (From GLM_GTX_compatibility)
 
 	template <typename genType> GLM_FUNC_DECL bool isfinite(genType const & x);											//!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
-	template <typename T, precision P> GLM_FUNC_DECL detail::tvec2<bool, P> isfinite(const detail::tvec2<T, P>& x);				//!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
-	template <typename T, precision P> GLM_FUNC_DECL detail::tvec3<bool, P> isfinite(const detail::tvec3<T, P>& x);				//!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
-	template <typename T, precision P> GLM_FUNC_DECL detail::tvec4<bool, P> isfinite(const detail::tvec4<T, P>& x);				//!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
+	template <typename T, precision P> GLM_FUNC_DECL tvec2<bool, P> isfinite(const tvec2<T, P>& x);				//!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
+	template <typename T, precision P> GLM_FUNC_DECL tvec3<bool, P> isfinite(const tvec3<T, P>& x);				//!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
+	template <typename T, precision P> GLM_FUNC_DECL tvec4<bool, P> isfinite(const tvec4<T, P>& x);				//!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
 
 	typedef bool						bool1;			//!< \brief boolean type with 1 component. (From GLM_GTX_compatibility extension)
-	typedef detail::tvec2<bool, highp>			bool2;			//!< \brief boolean type with 2 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tvec3<bool, highp>			bool3;			//!< \brief boolean type with 3 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tvec4<bool, highp>			bool4;			//!< \brief boolean type with 4 components. (From GLM_GTX_compatibility extension)
+	typedef tvec2<bool, highp>			bool2;			//!< \brief boolean type with 2 components. (From GLM_GTX_compatibility extension)
+	typedef tvec3<bool, highp>			bool3;			//!< \brief boolean type with 3 components. (From GLM_GTX_compatibility extension)
+	typedef tvec4<bool, highp>			bool4;			//!< \brief boolean type with 4 components. (From GLM_GTX_compatibility extension)
 
 	typedef bool						bool1x1;		//!< \brief boolean matrix with 1 x 1 component. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat2x2<bool, highp>		bool2x2;		//!< \brief boolean matrix with 2 x 2 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat2x3<bool, highp>		bool2x3;		//!< \brief boolean matrix with 2 x 3 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat2x4<bool, highp>		bool2x4;		//!< \brief boolean matrix with 2 x 4 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat3x2<bool, highp>		bool3x2;		//!< \brief boolean matrix with 3 x 2 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat3x3<bool, highp>		bool3x3;		//!< \brief boolean matrix with 3 x 3 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat3x4<bool, highp>		bool3x4;		//!< \brief boolean matrix with 3 x 4 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat4x2<bool, highp>		bool4x2;		//!< \brief boolean matrix with 4 x 2 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat4x3<bool, highp>		bool4x3;		//!< \brief boolean matrix with 4 x 3 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat4x4<bool, highp>		bool4x4;		//!< \brief boolean matrix with 4 x 4 components. (From GLM_GTX_compatibility extension)
+	typedef tmat2x2<bool, highp>		bool2x2;		//!< \brief boolean matrix with 2 x 2 components. (From GLM_GTX_compatibility extension)
+	typedef tmat2x3<bool, highp>		bool2x3;		//!< \brief boolean matrix with 2 x 3 components. (From GLM_GTX_compatibility extension)
+	typedef tmat2x4<bool, highp>		bool2x4;		//!< \brief boolean matrix with 2 x 4 components. (From GLM_GTX_compatibility extension)
+	typedef tmat3x2<bool, highp>		bool3x2;		//!< \brief boolean matrix with 3 x 2 components. (From GLM_GTX_compatibility extension)
+	typedef tmat3x3<bool, highp>		bool3x3;		//!< \brief boolean matrix with 3 x 3 components. (From GLM_GTX_compatibility extension)
+	typedef tmat3x4<bool, highp>		bool3x4;		//!< \brief boolean matrix with 3 x 4 components. (From GLM_GTX_compatibility extension)
+	typedef tmat4x2<bool, highp>		bool4x2;		//!< \brief boolean matrix with 4 x 2 components. (From GLM_GTX_compatibility extension)
+	typedef tmat4x3<bool, highp>		bool4x3;		//!< \brief boolean matrix with 4 x 3 components. (From GLM_GTX_compatibility extension)
+	typedef tmat4x4<bool, highp>		bool4x4;		//!< \brief boolean matrix with 4 x 4 components. (From GLM_GTX_compatibility extension)
 
 	typedef int							int1;			//!< \brief integer vector with 1 component. (From GLM_GTX_compatibility extension)
-	typedef detail::tvec2<int, highp>			int2;			//!< \brief integer vector with 2 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tvec3<int, highp>			int3;			//!< \brief integer vector with 3 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tvec4<int, highp>			int4;			//!< \brief integer vector with 4 components. (From GLM_GTX_compatibility extension)
+	typedef tvec2<int, highp>			int2;			//!< \brief integer vector with 2 components. (From GLM_GTX_compatibility extension)
+	typedef tvec3<int, highp>			int3;			//!< \brief integer vector with 3 components. (From GLM_GTX_compatibility extension)
+	typedef tvec4<int, highp>			int4;			//!< \brief integer vector with 4 components. (From GLM_GTX_compatibility extension)
 
 	typedef int							int1x1;			//!< \brief integer matrix with 1 component. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat2x2<int, highp>		int2x2;			//!< \brief integer matrix with 2 x 2 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat2x3<int, highp>		int2x3;			//!< \brief integer matrix with 2 x 3 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat2x4<int, highp>		int2x4;			//!< \brief integer matrix with 2 x 4 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat3x2<int, highp>		int3x2;			//!< \brief integer matrix with 3 x 2 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat3x3<int, highp>		int3x3;			//!< \brief integer matrix with 3 x 3 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat3x4<int, highp>		int3x4;			//!< \brief integer matrix with 3 x 4 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat4x2<int, highp>		int4x2;			//!< \brief integer matrix with 4 x 2 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat4x3<int, highp>		int4x3;			//!< \brief integer matrix with 4 x 3 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat4x4<int, highp>		int4x4;			//!< \brief integer matrix with 4 x 4 components. (From GLM_GTX_compatibility extension)
+	typedef tmat2x2<int, highp>		int2x2;			//!< \brief integer matrix with 2 x 2 components. (From GLM_GTX_compatibility extension)
+	typedef tmat2x3<int, highp>		int2x3;			//!< \brief integer matrix with 2 x 3 components. (From GLM_GTX_compatibility extension)
+	typedef tmat2x4<int, highp>		int2x4;			//!< \brief integer matrix with 2 x 4 components. (From GLM_GTX_compatibility extension)
+	typedef tmat3x2<int, highp>		int3x2;			//!< \brief integer matrix with 3 x 2 components. (From GLM_GTX_compatibility extension)
+	typedef tmat3x3<int, highp>		int3x3;			//!< \brief integer matrix with 3 x 3 components. (From GLM_GTX_compatibility extension)
+	typedef tmat3x4<int, highp>		int3x4;			//!< \brief integer matrix with 3 x 4 components. (From GLM_GTX_compatibility extension)
+	typedef tmat4x2<int, highp>		int4x2;			//!< \brief integer matrix with 4 x 2 components. (From GLM_GTX_compatibility extension)
+	typedef tmat4x3<int, highp>		int4x3;			//!< \brief integer matrix with 4 x 3 components. (From GLM_GTX_compatibility extension)
+	typedef tmat4x4<int, highp>		int4x4;			//!< \brief integer matrix with 4 x 4 components. (From GLM_GTX_compatibility extension)
 
 	typedef float						float1;			//!< \brief single-precision floating-point vector with 1 component. (From GLM_GTX_compatibility extension)
-	typedef detail::tvec2<float, highp>		float2;			//!< \brief single-precision floating-point vector with 2 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tvec3<float, highp>		float3;			//!< \brief single-precision floating-point vector with 3 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tvec4<float, highp>		float4;			//!< \brief single-precision floating-point vector with 4 components. (From GLM_GTX_compatibility extension)
+	typedef tvec2<float, highp>		float2;			//!< \brief single-precision floating-point vector with 2 components. (From GLM_GTX_compatibility extension)
+	typedef tvec3<float, highp>		float3;			//!< \brief single-precision floating-point vector with 3 components. (From GLM_GTX_compatibility extension)
+	typedef tvec4<float, highp>		float4;			//!< \brief single-precision floating-point vector with 4 components. (From GLM_GTX_compatibility extension)
 
 	typedef float						float1x1;		//!< \brief single-precision floating-point matrix with 1 component. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat2x2<float, highp>		float2x2;		//!< \brief single-precision floating-point matrix with 2 x 2 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat2x3<float, highp>		float2x3;		//!< \brief single-precision floating-point matrix with 2 x 3 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat2x4<float, highp>		float2x4;		//!< \brief single-precision floating-point matrix with 2 x 4 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat3x2<float, highp>		float3x2;		//!< \brief single-precision floating-point matrix with 3 x 2 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat3x3<float, highp>		float3x3;		//!< \brief single-precision floating-point matrix with 3 x 3 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat3x4<float, highp>		float3x4;		//!< \brief single-precision floating-point matrix with 3 x 4 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat4x2<float, highp>		float4x2;		//!< \brief single-precision floating-point matrix with 4 x 2 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat4x3<float, highp>		float4x3;		//!< \brief single-precision floating-point matrix with 4 x 3 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat4x4<float, highp>		float4x4;		//!< \brief single-precision floating-point matrix with 4 x 4 components. (From GLM_GTX_compatibility extension)
+	typedef tmat2x2<float, highp>		float2x2;		//!< \brief single-precision floating-point matrix with 2 x 2 components. (From GLM_GTX_compatibility extension)
+	typedef tmat2x3<float, highp>		float2x3;		//!< \brief single-precision floating-point matrix with 2 x 3 components. (From GLM_GTX_compatibility extension)
+	typedef tmat2x4<float, highp>		float2x4;		//!< \brief single-precision floating-point matrix with 2 x 4 components. (From GLM_GTX_compatibility extension)
+	typedef tmat3x2<float, highp>		float3x2;		//!< \brief single-precision floating-point matrix with 3 x 2 components. (From GLM_GTX_compatibility extension)
+	typedef tmat3x3<float, highp>		float3x3;		//!< \brief single-precision floating-point matrix with 3 x 3 components. (From GLM_GTX_compatibility extension)
+	typedef tmat3x4<float, highp>		float3x4;		//!< \brief single-precision floating-point matrix with 3 x 4 components. (From GLM_GTX_compatibility extension)
+	typedef tmat4x2<float, highp>		float4x2;		//!< \brief single-precision floating-point matrix with 4 x 2 components. (From GLM_GTX_compatibility extension)
+	typedef tmat4x3<float, highp>		float4x3;		//!< \brief single-precision floating-point matrix with 4 x 3 components. (From GLM_GTX_compatibility extension)
+	typedef tmat4x4<float, highp>		float4x4;		//!< \brief single-precision floating-point matrix with 4 x 4 components. (From GLM_GTX_compatibility extension)
 
 	typedef double						double1;		//!< \brief double-precision floating-point vector with 1 component. (From GLM_GTX_compatibility extension)
-	typedef detail::tvec2<double, highp>		double2;		//!< \brief double-precision floating-point vector with 2 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tvec3<double, highp>		double3;		//!< \brief double-precision floating-point vector with 3 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tvec4<double, highp>		double4;		//!< \brief double-precision floating-point vector with 4 components. (From GLM_GTX_compatibility extension)
+	typedef tvec2<double, highp>		double2;		//!< \brief double-precision floating-point vector with 2 components. (From GLM_GTX_compatibility extension)
+	typedef tvec3<double, highp>		double3;		//!< \brief double-precision floating-point vector with 3 components. (From GLM_GTX_compatibility extension)
+	typedef tvec4<double, highp>		double4;		//!< \brief double-precision floating-point vector with 4 components. (From GLM_GTX_compatibility extension)
 
 	typedef double						double1x1;		//!< \brief double-precision floating-point matrix with 1 component. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat2x2<double, highp>		double2x2;		//!< \brief double-precision floating-point matrix with 2 x 2 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat2x3<double, highp>		double2x3;		//!< \brief double-precision floating-point matrix with 2 x 3 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat2x4<double, highp>		double2x4;		//!< \brief double-precision floating-point matrix with 2 x 4 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat3x2<double, highp>		double3x2;		//!< \brief double-precision floating-point matrix with 3 x 2 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat3x3<double, highp>		double3x3;		//!< \brief double-precision floating-point matrix with 3 x 3 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat3x4<double, highp>		double3x4;		//!< \brief double-precision floating-point matrix with 3 x 4 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat4x2<double, highp>		double4x2;		//!< \brief double-precision floating-point matrix with 4 x 2 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat4x3<double, highp>		double4x3;		//!< \brief double-precision floating-point matrix with 4 x 3 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat4x4<double, highp>		double4x4;		//!< \brief double-precision floating-point matrix with 4 x 4 components. (From GLM_GTX_compatibility extension)
+	typedef tmat2x2<double, highp>		double2x2;		//!< \brief double-precision floating-point matrix with 2 x 2 components. (From GLM_GTX_compatibility extension)
+	typedef tmat2x3<double, highp>		double2x3;		//!< \brief double-precision floating-point matrix with 2 x 3 components. (From GLM_GTX_compatibility extension)
+	typedef tmat2x4<double, highp>		double2x4;		//!< \brief double-precision floating-point matrix with 2 x 4 components. (From GLM_GTX_compatibility extension)
+	typedef tmat3x2<double, highp>		double3x2;		//!< \brief double-precision floating-point matrix with 3 x 2 components. (From GLM_GTX_compatibility extension)
+	typedef tmat3x3<double, highp>		double3x3;		//!< \brief double-precision floating-point matrix with 3 x 3 components. (From GLM_GTX_compatibility extension)
+	typedef tmat3x4<double, highp>		double3x4;		//!< \brief double-precision floating-point matrix with 3 x 4 components. (From GLM_GTX_compatibility extension)
+	typedef tmat4x2<double, highp>		double4x2;		//!< \brief double-precision floating-point matrix with 4 x 2 components. (From GLM_GTX_compatibility extension)
+	typedef tmat4x3<double, highp>		double4x3;		//!< \brief double-precision floating-point matrix with 4 x 3 components. (From GLM_GTX_compatibility extension)
+	typedef tmat4x4<double, highp>		double4x4;		//!< \brief double-precision floating-point matrix with 4 x 4 components. (From GLM_GTX_compatibility extension)
 
 	/// @}
 }//namespace glm

glm/gtx/compatibility.inl

@@ -28,29 +28,29 @@ namespace glm
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec2<bool, P> isfinite(
-		detail::tvec2<T, P> const & x)
+	GLM_FUNC_QUALIFIER tvec2<bool, P> isfinite(
+		tvec2<T, P> const & x)
 	{
-		return detail::tvec2<bool, P>(
+		return tvec2<bool, P>(
 			isfinite(x.x),
 			isfinite(x.y));
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec3<bool, P> isfinite(
-		detail::tvec3<T, P> const & x)
+	GLM_FUNC_QUALIFIER tvec3<bool, P> isfinite(
+		tvec3<T, P> const & x)
 	{
-		return detail::tvec3<bool, P>(
+		return tvec3<bool, P>(
 			isfinite(x.x),
 			isfinite(x.y),
 			isfinite(x.z));
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec4<bool, P> isfinite(
-		detail::tvec4<T, P> const & x)
+	GLM_FUNC_QUALIFIER tvec4<bool, P> isfinite(
+		tvec4<T, P> const & x)
 	{
-		return detail::tvec4<bool, P>(
+		return tvec4<bool, P>(
 			isfinite(x.x),
 			isfinite(x.y),
 			isfinite(x.z),

glm/gtx/dual_quaternion.hpp

@@ -49,18 +49,20 @@
 #	pragma message("GLM: GLM_GTX_dual_quaternion extension included")
 #endif
 
-namespace glm{
-namespace detail
+namespace glm
 {
+	/// @addtogroup gtc_dual_quaternion
+	/// @{
+
 	template <typename T, precision P>
 	struct tdualquat
 	{
 		enum ctor{null};
 		typedef T value_type;
-		typedef glm::detail::tquat<T, P> part_type;
+		typedef glm::tquat<T, P> part_type;
 		
 	public:
-		glm::detail::tquat<T, P> real, dual;
+		glm::tquat<T, P> real, dual;
 		
 		GLM_FUNC_DECL GLM_CONSTEXPR length_t length() const;
 		
@@ -85,80 +87,76 @@ namespace detail
 	};
 	
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tquat<T, P> operator- (
-		detail::tquat<T, P> const & q);
+	GLM_FUNC_DECL tquat<T, P> operator- (
+		tquat<T, P> const & q);
 	
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tdualquat<T, P> operator+ (
-		detail::tdualquat<T, P> const & q,
-		detail::tdualquat<T, P> const & p);
+	GLM_FUNC_DECL tdualquat<T, P> operator+ (
+		tdualquat<T, P> const & q,
+		tdualquat<T, P> const & p);
 	
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tdualquat<T, P> operator* (
-		detail::tdualquat<T, P> const & q,
-		detail::tdualquat<T, P> const & p);
+	GLM_FUNC_DECL tdualquat<T, P> operator* (
+		tdualquat<T, P> const & q,
+		tdualquat<T, P> const & p);
 	
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tvec3<T, P> operator* (
-		detail::tquat<T, P> const & q,
-		detail::tvec3<T, P> const & v);
+	GLM_FUNC_DECL tvec3<T, P> operator* (
+		tquat<T, P> const & q,
+		tvec3<T, P> const & v);
 	
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tvec3<T, P> operator* (
-		detail::tvec3<T, P> const & v,
-		detail::tquat<T, P> const & q);
+	GLM_FUNC_DECL tvec3<T, P> operator* (
+		tvec3<T, P> const & v,
+		tquat<T, P> const & q);
 	
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tvec4<T, P> operator* (
-		detail::tquat<T, P> const & q,
-		detail::tvec4<T, P> const & v);
+	GLM_FUNC_DECL tvec4<T, P> operator* (
+		tquat<T, P> const & q,
+		tvec4<T, P> const & v);
 	
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tvec4<T, P> operator* (
-		detail::tvec4<T, P> const & v,
-		detail::tquat<T, P> const & q);
+	GLM_FUNC_DECL tvec4<T, P> operator* (
+		tvec4<T, P> const & v,
+		tquat<T, P> const & q);
 	
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tdualquat<T, P> operator* (
-		detail::tdualquat<T, P> const & q,
+	GLM_FUNC_DECL tdualquat<T, P> operator* (
+		tdualquat<T, P> const & q,
 		T const & s);
 	
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tdualquat<T, P> operator* (
+	GLM_FUNC_DECL tdualquat<T, P> operator* (
 		T const & s,
-		detail::tdualquat<T, P> const & q);
+		tdualquat<T, P> const & q);
 	
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tdualquat<T, P> operator/ (
-		detail::tdualquat<T, P> const & q,
+	GLM_FUNC_DECL tdualquat<T, P> operator/ (
+		tdualquat<T, P> const & q,
 		T const & s);
-} //namespace detail
-	
-	/// @addtogroup gtc_dual_quaternion
-	/// @{
 
 	/// Returns the normalized quaternion.
 	///
 	/// @see gtc_dual_quaternion
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tdualquat<T, P> normalize(
-		detail::tdualquat<T, P> const & q);
+	GLM_FUNC_DECL tdualquat<T, P> normalize(
+		tdualquat<T, P> const & q);
 
 	/// Returns the linear interpolation of two dual quaternion.
 	///
 	/// @see gtc_dual_quaternion
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tdualquat<T, P> lerp(
-		detail::tdualquat<T, P> const & x,
-		detail::tdualquat<T, P> const & y,
+	GLM_FUNC_DECL tdualquat<T, P> lerp(
+		tdualquat<T, P> const & x,
+		tdualquat<T, P> const & y,
 		T const & a);
 
 	/// Returns the q inverse.
 	///
 	/// @see gtc_dual_quaternion
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tdualquat<T, P> inverse(
-		detail::tdualquat<T, P> const & q);
+	GLM_FUNC_DECL tdualquat<T, P> inverse(
+		tdualquat<T, P> const & q);
 
 	/*
 	/// Extracts a rotation part from dual-quaternion to a 3 * 3 matrix.
@@ -166,85 +164,85 @@ namespace detail
 	///
 	/// @see gtc_dual_quaternion
 	template <typename T, precision P>
-	detail::tmat3x3<T, P> mat3_cast(
-		detail::tdualquat<T, P> const & x);
+	tmat3x3<T, P> mat3_cast(
+		tdualquat<T, P> const & x);
 	*/
 	
 	/// Converts a quaternion to a 2 * 4 matrix.
 	///
 	/// @see gtc_dual_quaternion
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tmat2x4<T, P> mat2x4_cast(
-		detail::tdualquat<T, P> const & x);
+	GLM_FUNC_DECL tmat2x4<T, P> mat2x4_cast(
+		tdualquat<T, P> const & x);
 
 	/// Converts a quaternion to a 3 * 4 matrix.
 	///
 	/// @see gtc_dual_quaternion
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tmat3x4<T, P> mat3x4_cast(
-		detail::tdualquat<T, P> const & x);
+	GLM_FUNC_DECL tmat3x4<T, P> mat3x4_cast(
+		tdualquat<T, P> const & x);
 
 	/// Converts a 2 * 4 matrix (matrix which holds real and dual parts) to a quaternion.
 	///
 	/// @see gtc_dual_quaternion
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tdualquat<T, P> dualquat_cast(
-		detail::tmat2x4<T, P> const & x);
+	GLM_FUNC_DECL tdualquat<T, P> dualquat_cast(
+		tmat2x4<T, P> const & x);
 
 	/// Converts a 3 * 4 matrix (augmented matrix rotation + translation) to a quaternion.
 	///
 	/// @see gtc_dual_quaternion
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tdualquat<T, P> dualquat_cast(
-		detail::tmat3x4<T, P> const & x);
+	GLM_FUNC_DECL tdualquat<T, P> dualquat_cast(
+		tmat3x4<T, P> const & x);
 
 	
 	/// Dual-quaternion of low single-precision floating-point numbers.
 	///
 	/// @see gtc_dual_quaternion
-	typedef detail::tdualquat<float, lowp>		lowp_dualquat;
+	typedef tdualquat<float, lowp>		lowp_dualquat;
 	
 	/// Dual-quaternion of medium single-precision floating-point numbers.
 	///
 	/// @see gtc_dual_quaternion
-	typedef detail::tdualquat<float, mediump>	mediump_dualquat;
+	typedef tdualquat<float, mediump>	mediump_dualquat;
 	
 	/// Dual-quaternion of high single-precision floating-point numbers.
 	///
 	/// @see gtc_dual_quaternion
-	typedef detail::tdualquat<float, highp>		highp_dualquat;
+	typedef tdualquat<float, highp>		highp_dualquat;
 
 
 	/// Dual-quaternion of low single-precision floating-point numbers.
 	///
 	/// @see gtc_dual_quaternion
-	typedef detail::tdualquat<float, lowp>		lowp_fdualquat;
+	typedef tdualquat<float, lowp>		lowp_fdualquat;
 	
 	/// Dual-quaternion of medium single-precision floating-point numbers.
 	///
 	/// @see gtc_dual_quaternion
-	typedef detail::tdualquat<float, mediump>	mediump_fdualquat;
+	typedef tdualquat<float, mediump>	mediump_fdualquat;
 	
 	/// Dual-quaternion of high single-precision floating-point numbers.
 	///
 	/// @see gtc_dual_quaternion
-	typedef detail::tdualquat<float, highp>		highp_fdualquat;
+	typedef tdualquat<float, highp>		highp_fdualquat;
 	
 	
 	/// Dual-quaternion of low double-precision floating-point numbers.
 	///
 	/// @see gtc_dual_quaternion
-	typedef detail::tdualquat<double, lowp>		lowp_ddualquat;
+	typedef tdualquat<double, lowp>		lowp_ddualquat;
 	
 	/// Dual-quaternion of medium double-precision floating-point numbers.
 	///
 	/// @see gtc_dual_quaternion
-	typedef detail::tdualquat<double, mediump>	mediump_ddualquat;
+	typedef tdualquat<double, mediump>	mediump_ddualquat;
 	
 	/// Dual-quaternion of high double-precision floating-point numbers.
 	///
 	/// @see gtc_dual_quaternion
-	typedef detail::tdualquat<double, highp>	highp_ddualquat;
+	typedef tdualquat<double, highp>	highp_ddualquat;
 
 	
 #if(!defined(GLM_PRECISION_HIGHP_FLOAT) && !defined(GLM_PRECISION_MEDIUMP_FLOAT) && !defined(GLM_PRECISION_LOWP_FLOAT))

glm/gtx/dual_quaternion.inl

@@ -29,8 +29,7 @@
 #include "../geometric.hpp"
 #include <limits>
 
-namespace glm{
-namespace detail
+namespace glm
 {
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR length_t tdualquat<T, P>::length() const
@@ -143,105 +142,105 @@ namespace detail
 	// tquat<valType> external operators
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tdualquat<T, P> operator-
+	GLM_FUNC_QUALIFIER tdualquat<T, P> operator-
 	(
-		detail::tdualquat<T, P> const & q
+		tdualquat<T, P> const & q
 	)
 	{
-		return detail::tdualquat<T, P>(-q.real,-q.dual);
+		return tdualquat<T, P>(-q.real,-q.dual);
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tdualquat<T, P> operator+
+	GLM_FUNC_QUALIFIER tdualquat<T, P> operator+
 	(
-		detail::tdualquat<T, P> const & q,
-		detail::tdualquat<T, P> const & p
+		tdualquat<T, P> const & q,
+		tdualquat<T, P> const & p
 	)
 	{
-		return detail::tdualquat<T, P>(q.real + p.real,q.dual + p.dual);
+		return tdualquat<T, P>(q.real + p.real,q.dual + p.dual);
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tdualquat<T, P> operator*
+	GLM_FUNC_QUALIFIER tdualquat<T, P> operator*
 	(
-		detail::tdualquat<T, P> const & p,
-		detail::tdualquat<T, P> const & o
+		tdualquat<T, P> const & p,
+		tdualquat<T, P> const & o
 	)
 	{
-		return detail::tdualquat<T, P>(p.real * o.real,p.real * o.dual + p.dual * o.real);
+		return tdualquat<T, P>(p.real * o.real,p.real * o.dual + p.dual * o.real);
 	}
 
 	// Transformation
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec3<T, P> operator*
+	GLM_FUNC_QUALIFIER tvec3<T, P> operator*
 	(
-		detail::tdualquat<T, P> const & q,
-		detail::tvec3<T, P> const & v
+		tdualquat<T, P> const & q,
+		tvec3<T, P> const & v
 	)
 	{
-		detail::tvec3<T, P> const real_v3(q.real.x,q.real.y,q.real.z);
-		detail::tvec3<T, P> const dual_v3(q.dual.x,q.dual.y,q.dual.z);
+		tvec3<T, P> const real_v3(q.real.x,q.real.y,q.real.z);
+		tvec3<T, P> const dual_v3(q.dual.x,q.dual.y,q.dual.z);
 		return (cross(real_v3, cross(real_v3,v) + v * q.real.w + dual_v3) + dual_v3 * q.real.w - real_v3 * q.dual.w) * T(2) + v;
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec3<T, P> operator*
+	GLM_FUNC_QUALIFIER tvec3<T, P> operator*
 	(
-		detail::tvec3<T, P> const & v,
-		detail::tdualquat<T, P> const & q
+		tvec3<T, P> const & v,
+		tdualquat<T, P> const & q
 	)
 	{
 		return glm::inverse(q) * v;
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec4<T, P> operator*
+	GLM_FUNC_QUALIFIER tvec4<T, P> operator*
 	(
-		detail::tdualquat<T, P> const & q,
-		detail::tvec4<T, P> const & v
+		tdualquat<T, P> const & q,
+		tvec4<T, P> const & v
 	)
 	{
-		return detail::tvec4<T, P>(q * detail::tvec3<T, P>(v), v.w);
+		return tvec4<T, P>(q * tvec3<T, P>(v), v.w);
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec4<T, P> operator*
+	GLM_FUNC_QUALIFIER tvec4<T, P> operator*
 	(
-		detail::tvec4<T, P> const & v,
-		detail::tdualquat<T, P> const & q
+		tvec4<T, P> const & v,
+		tdualquat<T, P> const & q
 	)
 	{
 		return glm::inverse(q) * v;
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tdualquat<T, P> operator*
+	GLM_FUNC_QUALIFIER tdualquat<T, P> operator*
 	(
-		detail::tdualquat<T, P> const & q,
+		tdualquat<T, P> const & q,
 		T const & s
 	)
 	{
-		return detail::tdualquat<T, P>(q.real * s, q.dual * s);
+		return tdualquat<T, P>(q.real * s, q.dual * s);
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tdualquat<T, P> operator*
+	GLM_FUNC_QUALIFIER tdualquat<T, P> operator*
 	(
 		T const & s,
-		detail::tdualquat<T, P> const & q
+		tdualquat<T, P> const & q
 	)
 	{
 		return q * s;
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tdualquat<T, P> operator/
+	GLM_FUNC_QUALIFIER tdualquat<T, P> operator/
 	(
-		detail::tdualquat<T, P> const & q,
+		tdualquat<T, P> const & q,
 		T const & s
 	)
 	{
-		return detail::tdualquat<T, P>(q.real / s, q.dual / s);
+		return tdualquat<T, P>(q.real / s, q.dual / s);
 	}
 
 	//////////////////////////////////////
@@ -249,8 +248,8 @@ namespace detail
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER bool operator==
 	(
-		detail::tdualquat<T, P> const & q1,
-		detail::tdualquat<T, P> const & q2
+		tdualquat<T, P> const & q1,
+		tdualquat<T, P> const & q2
 	)
 	{
 		return (q1.real == q2.real) && (q1.dual == q2.dual);
@@ -259,29 +258,28 @@ namespace detail
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER bool operator!=
 	(
-		detail::tdualquat<T, P> const & q1,
-		detail::tdualquat<T, P> const & q2
+		tdualquat<T, P> const & q1,
+		tdualquat<T, P> const & q2
 	)
 	{
 		return (q1.real != q2.dual) || (q1.real != q2.dual);
 	}
-	}//namespace detail
 
 	////////////////////////////////////////////////////////
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tdualquat<T, P> normalize
+	GLM_FUNC_QUALIFIER tdualquat<T, P> normalize
 	(
-		detail::tdualquat<T, P> const & q
+		tdualquat<T, P> const & q
 	)
 	{
 		return q / length(q.real);
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tdualquat<T, P> lerp
+	GLM_FUNC_QUALIFIER tdualquat<T, P> lerp
 	(
-		detail::tdualquat<T, P> const & x,
-		detail::tdualquat<T, P> const & y,
+		tdualquat<T, P> const & x,
+		tdualquat<T, P> const & y,
 		T const & a
 	)
 	{
@@ -291,38 +289,38 @@ namespace detail
 		assert(a <= static_cast<T>(1));
 		T const k = dot(x.real,y.real) < static_cast<T>(0) ? -a : a;
 		T const one(1);
-		return detail::tdualquat<T, P>(x * (one - a) + y * k);
+		return tdualquat<T, P>(x * (one - a) + y * k);
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tdualquat<T, P> inverse
+	GLM_FUNC_QUALIFIER tdualquat<T, P> inverse
 	(
-		detail::tdualquat<T, P> const & q
+		tdualquat<T, P> const & q
 	)
 	{
-		const glm::detail::tquat<T, P> real = conjugate(q.real);
-		const glm::detail::tquat<T, P> dual = conjugate(q.dual);
-		return detail::tdualquat<T, P>(real, dual + (real * (-2.0f * dot(real,dual))));
+		const glm::tquat<T, P> real = conjugate(q.real);
+		const glm::tquat<T, P> dual = conjugate(q.dual);
+		return tdualquat<T, P>(real, dual + (real * (-2.0f * dot(real,dual))));
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tmat2x4<T, P> mat2x4_cast
+	GLM_FUNC_QUALIFIER tmat2x4<T, P> mat2x4_cast
 	(
-		detail::tdualquat<T, P> const & x
+		tdualquat<T, P> const & x
 	)
 	{
-		return detail::tmat2x4<T, P>( x[0].x, x[0].y, x[0].z, x[0].w, x[1].x, x[1].y, x[1].z, x[1].w );
+		return tmat2x4<T, P>( x[0].x, x[0].y, x[0].z, x[0].w, x[1].x, x[1].y, x[1].z, x[1].w );
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tmat3x4<T, P> mat3x4_cast
+	GLM_FUNC_QUALIFIER tmat3x4<T, P> mat3x4_cast
 	(
-		detail::tdualquat<T, P> const & x
+		tdualquat<T, P> const & x
 	)
 	{
-		detail::tquat<T, P> r = x.real / length2(x.real);
+		tquat<T, P> r = x.real / length2(x.real);
 		
-		detail::tquat<T, P> const rr(r.w * x.real.w, r.x * x.real.x, r.y * x.real.y, r.z * x.real.z);
+		tquat<T, P> const rr(r.w * x.real.w, r.x * x.real.x, r.y * x.real.y, r.z * x.real.z);
 		r *= static_cast<T>(2);
 		
 		T const xy = r.x * x.real.y;
@@ -332,45 +330,45 @@ namespace detail
 		T const wy = r.w * x.real.y;
 		T const wz = r.w * x.real.z;
 		
-		detail::tvec4<T, P> const a(
+		tvec4<T, P> const a(
 			rr.w + rr.x - rr.y - rr.z,
 			xy - wz,
 			xz + wy,
 			-(x.dual.w * r.x - x.dual.x * r.w + x.dual.y * r.z - x.dual.z * r.y));
 		
-		detail::tvec4<T, P> const b(
+		tvec4<T, P> const b(
 			xy + wz,
 			rr.w + rr.y - rr.x - rr.z,
 			yz - wx,
 			-(x.dual.w * r.y - x.dual.x * r.z - x.dual.y * r.w + x.dual.z * r.x));
 		
-		detail::tvec4<T, P> const c(
+		tvec4<T, P> const c(
 			xz - wy,
 			yz + wx,
 			rr.w + rr.z - rr.x - rr.y,
 			-(x.dual.w * r.z + x.dual.x * r.y - x.dual.y * r.x - x.dual.z * r.w));
 		
-		return detail::tmat3x4<T, P>(a, b, c);
+		return tmat3x4<T, P>(a, b, c);
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tdualquat<T, P> dualquat_cast
+	GLM_FUNC_QUALIFIER tdualquat<T, P> dualquat_cast
 	(
-		detail::tmat2x4<T, P> const & x
+		tmat2x4<T, P> const & x
 	)
 	{
-		return detail::tdualquat<T, P>(
-			detail::tquat<T, P>( x[0].w, x[0].x, x[0].y, x[0].z ),
-			detail::tquat<T, P>( x[1].w, x[1].x, x[1].y, x[1].z ));
+		return tdualquat<T, P>(
+			tquat<T, P>( x[0].w, x[0].x, x[0].y, x[0].z ),
+			tquat<T, P>( x[1].w, x[1].x, x[1].y, x[1].z ));
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tdualquat<T, P> dualquat_cast
+	GLM_FUNC_QUALIFIER tdualquat<T, P> dualquat_cast
 	(
-		detail::tmat3x4<T, P> const & x
+		tmat3x4<T, P> const & x
 	)
 	{
-		detail::tquat<T, P> real;
+		tquat<T, P> real;
 		
 		T const trace = x[0].x + x[1].y + x[2].z;
 		if(trace > T(0))
@@ -410,12 +408,12 @@ namespace detail
 			real.w = (x[1].x - x[0].y) * invr;
 		}
 		
-		detail::tquat<T, P> dual;
+		tquat<T, P> dual;
 		dual.x =  T(0.5) * ( x[0].w * real.w + x[1].w * real.z - x[2].w * real.y);
 		dual.y =  T(0.5) * (-x[0].w * real.z + x[1].w * real.w + x[2].w * real.x);
 		dual.z =  T(0.5) * ( x[0].w * real.y - x[1].w * real.x + x[2].w * real.w);
 		dual.w = -T(0.5) * ( x[0].w * real.x + x[1].w * real.y + x[2].w * real.z);
-		return detail::tdualquat<T, P>(real, dual);
+		return tdualquat<T, P>(real, dual);
 	}
 
 }//namespace glm

glm/gtx/euler_angles.hpp

@@ -53,67 +53,67 @@ namespace glm
 	/// Creates a 3D 4 * 4 homogeneous rotation matrix from an euler angle X.
 	/// @see gtx_euler_angles
 	template <typename T>
-	GLM_FUNC_DECL detail::tmat4x4<T, defaultp> eulerAngleX(
+	GLM_FUNC_DECL tmat4x4<T, defaultp> eulerAngleX(
 		T const & angleX);
 
 	/// Creates a 3D 4 * 4 homogeneous rotation matrix from an euler angle Y.
 	/// @see gtx_euler_angles
 	template <typename T>
-	GLM_FUNC_DECL detail::tmat4x4<T, defaultp> eulerAngleY(
+	GLM_FUNC_DECL tmat4x4<T, defaultp> eulerAngleY(
 		T const & angleY);
 
 	/// Creates a 3D 4 * 4 homogeneous rotation matrix from an euler angle Z.
 	/// @see gtx_euler_angles
 	template <typename T>
-	GLM_FUNC_DECL detail::tmat4x4<T, defaultp> eulerAngleZ(
+	GLM_FUNC_DECL tmat4x4<T, defaultp> eulerAngleZ(
 		T const & angleZ);
 
 	/// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (X * Y).
 	/// @see gtx_euler_angles
 	template <typename T>
-	GLM_FUNC_DECL detail::tmat4x4<T, defaultp> eulerAngleXY(
+	GLM_FUNC_DECL tmat4x4<T, defaultp> eulerAngleXY(
 		T const & angleX,
 		T const & angleY);
 
 	/// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * X).
 	/// @see gtx_euler_angles
 	template <typename T>
-	GLM_FUNC_DECL detail::tmat4x4<T, defaultp> eulerAngleYX(
+	GLM_FUNC_DECL tmat4x4<T, defaultp> eulerAngleYX(
 		T const & angleY,
 		T const & angleX);
 
 	/// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (X * Z).
 	/// @see gtx_euler_angles
 	template <typename T>
-	GLM_FUNC_DECL detail::tmat4x4<T, defaultp> eulerAngleXZ(
+	GLM_FUNC_DECL tmat4x4<T, defaultp> eulerAngleXZ(
 		T const & angleX,
 		T const & angleZ);
 
 	/// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Z * X).
 	/// @see gtx_euler_angles
 	template <typename T>
-	GLM_FUNC_DECL detail::tmat4x4<T, defaultp> eulerAngleZX(
+	GLM_FUNC_DECL tmat4x4<T, defaultp> eulerAngleZX(
 		T const & angle,
 		T const & angleX);
 
 	/// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * Z).
 	/// @see gtx_euler_angles
 	template <typename T>
-	GLM_FUNC_DECL detail::tmat4x4<T, defaultp> eulerAngleYZ(
+	GLM_FUNC_DECL tmat4x4<T, defaultp> eulerAngleYZ(
 		T const & angleY,
 		T const & angleZ);
 
 	/// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Z * Y).
 	/// @see gtx_euler_angles
 	template <typename T>
-	GLM_FUNC_DECL detail::tmat4x4<T, defaultp> eulerAngleZY(
+	GLM_FUNC_DECL tmat4x4<T, defaultp> eulerAngleZY(
 		T const & angleZ,
 		T const & angleY);
 
 	/// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * X * Z).
 	/// @see gtx_euler_angles
 	template <typename T>
-	GLM_FUNC_DECL detail::tmat4x4<T, defaultp> eulerAngleYXZ(
+	GLM_FUNC_DECL tmat4x4<T, defaultp> eulerAngleYXZ(
 		T const & yaw,
 		T const & pitch,
 		T const & roll);
@@ -121,7 +121,7 @@ namespace glm
 	/// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * X * Z).
 	/// @see gtx_euler_angles
 	template <typename T>
-	GLM_FUNC_DECL detail::tmat4x4<T, defaultp> yawPitchRoll(
+	GLM_FUNC_DECL tmat4x4<T, defaultp> yawPitchRoll(
 		T const & yaw,
 		T const & pitch,
 		T const & roll);
@@ -129,22 +129,22 @@ namespace glm
 	/// Creates a 2D 2 * 2 rotation matrix from an euler angle.
 	/// @see gtx_euler_angles
 	template <typename T>
-	GLM_FUNC_DECL detail::tmat2x2<T, defaultp> orientate2(T const & angle);
+	GLM_FUNC_DECL tmat2x2<T, defaultp> orientate2(T const & angle);
 
 	/// Creates a 2D 4 * 4 homogeneous rotation matrix from an euler angle.
 	/// @see gtx_euler_angles
 	template <typename T>
-	GLM_FUNC_DECL detail::tmat3x3<T, defaultp> orientate3(T const & angle);
+	GLM_FUNC_DECL tmat3x3<T, defaultp> orientate3(T const & angle);
 
 	/// Creates a 3D 3 * 3 rotation matrix from euler angles (Y * X * Z). 
 	/// @see gtx_euler_angles
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tmat3x3<T, P> orientate3(detail::tvec3<T, P> const & angles);
+	GLM_FUNC_DECL tmat3x3<T, P> orientate3(tvec3<T, P> const & angles);
 		
 	/// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * X * Z).
 	/// @see gtx_euler_angles
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tmat4x4<T, P> orientate4(detail::tvec3<T, P> const & angles);
+	GLM_FUNC_DECL tmat4x4<T, P> orientate4(tvec3<T, P> const & angles);
 
 	/// @}
 }//namespace glm

glm/gtx/euler_angles.inl

@@ -10,7 +10,7 @@
 namespace glm
 {
 	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T, defaultp> eulerAngleX
+	GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> eulerAngleX
 	(
 		T const & angleX
 	)
@@ -18,7 +18,7 @@ namespace glm
 		T cosX = glm::cos(angleX);
 		T sinX = glm::sin(angleX);
 	
-		return detail::tmat4x4<T, defaultp>(
+		return tmat4x4<T, defaultp>(
 			T(1), T(0), T(0), T(0),
 			T(0), cosX, sinX, T(0),
 			T(0),-sinX, cosX, T(0),
@@ -26,7 +26,7 @@ namespace glm
 	}
 
 	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T, defaultp> eulerAngleY
+	GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> eulerAngleY
 	(
 		T const & angleY
 	)
@@ -34,7 +34,7 @@ namespace glm
 		T cosY = glm::cos(angleY);
 		T sinY = glm::sin(angleY);
 
-		return detail::tmat4x4<T, defaultp>(
+		return tmat4x4<T, defaultp>(
 			cosY,	T(0),	-sinY,	T(0),
 			T(0),	T(1),	T(0),	T(0),
 			sinY,	T(0),	cosY,	T(0),
@@ -42,7 +42,7 @@ namespace glm
 	}
 
 	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T, defaultp> eulerAngleZ
+	GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> eulerAngleZ
 	(
 		T const & angleZ
 	)
@@ -50,7 +50,7 @@ namespace glm
 		T cosZ = glm::cos(angleZ);
 		T sinZ = glm::sin(angleZ);
 
-		return detail::tmat4x4<T, defaultp>(
+		return tmat4x4<T, defaultp>(
 			cosZ,	sinZ,	T(0), T(0),
 			-sinZ,	cosZ,	T(0), T(0),
 			T(0),	T(0),	T(1), T(0),
@@ -58,7 +58,7 @@ namespace glm
 	}
 
 	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T, defaultp> eulerAngleXY
+	GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> eulerAngleXY
 	(
 		T const & angleX,
 		T const & angleY
@@ -69,7 +69,7 @@ namespace glm
 		T cosY = glm::cos(angleY);
 		T sinY = glm::sin(angleY);
 
-		return detail::tmat4x4<T, defaultp>(
+		return tmat4x4<T, defaultp>(
 			cosY,   -sinX * -sinY,  cosX * -sinY,   T(0),
 			T(0),   cosX,           sinX,           T(0),
 			sinY,   -sinX * cosY,   cosX * cosY,    T(0),
@@ -77,7 +77,7 @@ namespace glm
 	}
 
 	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T, defaultp> eulerAngleYX
+	GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> eulerAngleYX
 	(
 		T const & angleY,
 		T const & angleX
@@ -88,7 +88,7 @@ namespace glm
 		T cosY = glm::cos(angleY);
 		T sinY = glm::sin(angleY);
 
-		return detail::tmat4x4<T, defaultp>(
+		return tmat4x4<T, defaultp>(
 			cosY,          0,      -sinY,    T(0),
 			sinY * sinX,  cosX, cosY * sinX, T(0),
 			sinY * cosX, -sinX, cosY * cosX, T(0),
@@ -96,7 +96,7 @@ namespace glm
 	}
 
 	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T, defaultp> eulerAngleXZ
+	GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> eulerAngleXZ
 	(
 		T const & angleX,
 		T const & angleZ
@@ -106,7 +106,7 @@ namespace glm
 	}
 
 	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T, defaultp> eulerAngleZX
+	GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> eulerAngleZX
 	(
 		T const & angleZ,
 		T const & angleX
@@ -116,7 +116,7 @@ namespace glm
 	}
 
 	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T, defaultp> eulerAngleYZ
+	GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> eulerAngleYZ
 	(
 		T const & angleY,
 		T const & angleZ
@@ -126,7 +126,7 @@ namespace glm
 	}
 
 	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T, defaultp> eulerAngleZY
+	GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> eulerAngleZY
 	(
 		T const & angleZ,
 		T const & angleY
@@ -136,7 +136,7 @@ namespace glm
 	}
 
 	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T, defaultp> eulerAngleYXZ
+	GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> eulerAngleYXZ
 	(
 		T const & yaw,
 		T const & pitch,
@@ -150,7 +150,7 @@ namespace glm
 		T tmp_cb = glm::cos(roll);
 		T tmp_sb = glm::sin(roll);
 
-		detail::tmat4x4<T, defaultp> Result;
+		tmat4x4<T, defaultp> Result;
 		Result[0][0] = tmp_ch * tmp_cb + tmp_sh * tmp_sp * tmp_sb;
 		Result[0][1] = tmp_sb * tmp_cp;
 		Result[0][2] = -tmp_sh * tmp_cb + tmp_ch * tmp_sp * tmp_sb;
@@ -171,7 +171,7 @@ namespace glm
 	}
 
 	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T, defaultp> yawPitchRoll
+	GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> yawPitchRoll
 	(
 		T const & yaw,
 		T const & pitch,
@@ -185,7 +185,7 @@ namespace glm
 		T tmp_cb = glm::cos(roll);
 		T tmp_sb = glm::sin(roll);
 
-		detail::tmat4x4<T, defaultp> Result;
+		tmat4x4<T, defaultp> Result;
 		Result[0][0] = tmp_ch * tmp_cb + tmp_sh * tmp_sp * tmp_sb;
 		Result[0][1] = tmp_sb * tmp_cp;
 		Result[0][2] = -tmp_sh * tmp_cb + tmp_ch * tmp_sp * tmp_sb;
@@ -206,7 +206,7 @@ namespace glm
 	}
 
 	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat2x2<T, defaultp> orientate2
+	GLM_FUNC_QUALIFIER tmat2x2<T, defaultp> orientate2
 	(
 		T const & angle
 	)
@@ -214,7 +214,7 @@ namespace glm
 		T c = glm::cos(angle);
 		T s = glm::sin(angle);
 
-		detail::tmat2x2<T, defaultp> Result;
+		tmat2x2<T, defaultp> Result;
 		Result[0][0] = c;
 		Result[0][1] = s;
 		Result[1][0] = -s;
@@ -223,7 +223,7 @@ namespace glm
 	}
 
 	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat3x3<T, defaultp> orientate3
+	GLM_FUNC_QUALIFIER tmat3x3<T, defaultp> orientate3
 	(
 		T const & angle
 	)
@@ -231,7 +231,7 @@ namespace glm
 		T c = glm::cos(angle);
 		T s = glm::sin(angle);
 
-		detail::tmat3x3<T, defaultp> Result;
+		tmat3x3<T, defaultp> Result;
 		Result[0][0] = c;
 		Result[0][1] = s;
 		Result[0][2] = 0.0f;
@@ -245,18 +245,18 @@ namespace glm
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tmat3x3<T, P> orientate3
+	GLM_FUNC_QUALIFIER tmat3x3<T, P> orientate3
 	(
-		detail::tvec3<T, P> const & angles
+		tvec3<T, P> const & angles
 	)
 	{
-		return detail::tmat3x3<T, P>(yawPitchRoll(angles.z, angles.x, angles.y));
+		return tmat3x3<T, P>(yawPitchRoll(angles.z, angles.x, angles.y));
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T, P> orientate4
+	GLM_FUNC_QUALIFIER tmat4x4<T, P> orientate4
 	(
-		detail::tvec3<T, P> const & angles
+		tvec3<T, P> const & angles
 	)
 	{
 		return yawPitchRoll(angles.z, angles.x, angles.y);

glm/gtx/extend.inl

@@ -21,10 +21,10 @@ namespace glm
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec2<T, P> extend
+	GLM_FUNC_QUALIFIER tvec2<T, P> extend
 	(
-		detail::tvec2<T, P> const & Origin,
-		detail::tvec2<T, P> const & Source,
+		tvec2<T, P> const & Origin,
+		tvec2<T, P> const & Source,
 		T const & Distance
 	)
 	{
@@ -32,10 +32,10 @@ namespace glm
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec3<T, P> extend
+	GLM_FUNC_QUALIFIER tvec3<T, P> extend
 	(
-		detail::tvec3<T, P> const & Origin,
-		detail::tvec3<T, P> const & Source,
+		tvec3<T, P> const & Origin,
+		tvec3<T, P> const & Source,
 		T const & Distance
 	)
 	{
@@ -43,10 +43,10 @@ namespace glm
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec4<T, P> extend
+	GLM_FUNC_QUALIFIER tvec4<T, P> extend
 	(
-		detail::tvec4<T, P> const & Origin,
-		detail::tvec4<T, P> const & Source,
+		tvec4<T, P> const & Origin,
+		tvec4<T, P> const & Source,
 		T const & Distance
 	)
 	{

glm/gtx/fast_exponential.inl

@@ -28,32 +28,32 @@ namespace glm
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec2<T, P> fastPow(
-		const detail::tvec2<T, P>& x, 
-		const detail::tvec2<int, P>& y)
+	GLM_FUNC_QUALIFIER tvec2<T, P> fastPow(
+		const tvec2<T, P>& x, 
+		const tvec2<int, P>& y)
 	{
-		return detail::tvec2<T, P>(
+		return tvec2<T, P>(
 			fastPow(x.x, y.x),
 			fastPow(x.y, y.y));
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec3<T, P> fastPow(
-		const detail::tvec3<T, P>& x, 
-		const detail::tvec3<int, P>& y)
+	GLM_FUNC_QUALIFIER tvec3<T, P> fastPow(
+		const tvec3<T, P>& x, 
+		const tvec3<int, P>& y)
 	{
-		return detail::tvec3<T, P>(
+		return tvec3<T, P>(
 			fastPow(x.x, y.x),
 			fastPow(x.y, y.y),
 			fastPow(x.z, y.z));
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec4<T, P> fastPow(
-		const detail::tvec4<T, P>& x, 
-		const detail::tvec4<int, P>& y)
+	GLM_FUNC_QUALIFIER tvec4<T, P> fastPow(
+		const tvec4<T, P>& x, 
+		const tvec4<int, P>& y)
 	{
-		return detail::tvec4<T, P>(
+		return tvec4<T, P>(
 			fastPow(x.x, y.x),
 			fastPow(x.y, y.y),
 			fastPow(x.z, y.z),

glm/gtx/fast_square_root.inl

@@ -28,10 +28,10 @@ namespace glm
 	GLM_FUNC_QUALIFIER float fastInverseSqrt<float>(float const & x)
 	{
 #		ifdef __CUDACC__ // Wordaround for a CUDA compiler bug up to CUDA6
-			detail::tvec1<T, P> tmp(detail::compute_inversesqrt<detail::tvec1, float, lowp>::call(detail::tvec1<float, lowp>(x)));
+			tvec1<T, P> tmp(detail::compute_inversesqrt<tvec1, float, lowp>::call(tvec1<float, lowp>(x)));
 			return tmp.x;
 #		else
-			return detail::compute_inversesqrt<detail::tvec1, float, lowp>::call(detail::tvec1<float, lowp>(x)).x;
+			return detail::compute_inversesqrt<tvec1, float, lowp>::call(tvec1<float, lowp>(x)).x;
 #		endif
 	}
 
@@ -39,10 +39,10 @@ namespace glm
 	GLM_FUNC_QUALIFIER double fastInverseSqrt<double>(double const & x)
 	{
 #		ifdef __CUDACC__ // Wordaround for a CUDA compiler bug up to CUDA6
-			detail::tvec1<T, P> tmp(detail::compute_inversesqrt<detail::tvec1, double, lowp>::call(detail::tvec1<double, lowp>(x)));
+			tvec1<T, P> tmp(detail::compute_inversesqrt<tvec1, double, lowp>::call(tvec1<double, lowp>(x)));
 			return tmp.x;
 #		else
-			return detail::compute_inversesqrt<detail::tvec1, double, lowp>::call(detail::tvec1<double, lowp>(x)).x;
+			return detail::compute_inversesqrt<tvec1, double, lowp>::call(tvec1<double, lowp>(x)).x;
 #		endif
 	}
 
@@ -70,7 +70,7 @@ namespace glm
 	template <typename valType, precision P>
 	GLM_FUNC_QUALIFIER valType fastLength
 	(
-		detail::tvec2<valType, P> const & x
+		tvec2<valType, P> const & x
 	)
 	{
 		valType sqr = x.x * x.x + x.y * x.y;
@@ -80,7 +80,7 @@ namespace glm
 	template <typename valType, precision P>
 	GLM_FUNC_QUALIFIER valType fastLength
 	(
-		detail::tvec3<valType, P> const & x
+		tvec3<valType, P> const & x
 	)
 	{
 		valType sqr = x.x * x.x + x.y * x.y + x.z * x.z;
@@ -90,7 +90,7 @@ namespace glm
 	template <typename valType, precision P>
 	GLM_FUNC_QUALIFIER valType fastLength
 	(
-		detail::tvec4<valType, P> const & x
+		tvec4<valType, P> const & x
 	)
 	{
 		valType sqr = x.x * x.x + x.y * x.y + x.z * x.z + x.w * x.w;
@@ -111,8 +111,8 @@ namespace glm
 	template <typename valType, precision P>
 	GLM_FUNC_QUALIFIER valType fastDistance
 	(
-		detail::tvec2<valType, P> const & x,
-		detail::tvec2<valType, P> const & y
+		tvec2<valType, P> const & x,
+		tvec2<valType, P> const & y
 	)
 	{
 		return fastLength(y - x);
@@ -121,8 +121,8 @@ namespace glm
 	template <typename valType, precision P>
 	GLM_FUNC_QUALIFIER valType fastDistance
 	(
-		detail::tvec3<valType, P> const & x,
-		detail::tvec3<valType, P> const & y
+		tvec3<valType, P> const & x,
+		tvec3<valType, P> const & y
 	)
 	{
 		return fastLength(y - x);
@@ -131,8 +131,8 @@ namespace glm
 	template <typename valType, precision P>
 	GLM_FUNC_QUALIFIER valType fastDistance
 	(
-		detail::tvec4<valType, P> const & x,
-		detail::tvec4<valType, P> const & y
+		tvec4<valType, P> const & x,
+		tvec4<valType, P> const & y
 	)
 	{
 		return fastLength(y - x);
@@ -149,9 +149,9 @@ namespace glm
 	}
 
 	template <typename valType, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec2<valType, P> fastNormalize
+	GLM_FUNC_QUALIFIER tvec2<valType, P> fastNormalize
 	(
-		detail::tvec2<valType, P> const & x
+		tvec2<valType, P> const & x
 	)
 	{
 		valType sqr = x.x * x.x + x.y * x.y;
@@ -159,9 +159,9 @@ namespace glm
 	}
 
 	template <typename valType, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec3<valType, P> fastNormalize
+	GLM_FUNC_QUALIFIER tvec3<valType, P> fastNormalize
 	(
-		detail::tvec3<valType, P> const & x
+		tvec3<valType, P> const & x
 	)
 	{
 		valType sqr = x.x * x.x + x.y * x.y + x.z * x.z;
@@ -169,9 +169,9 @@ namespace glm
 	}
 
 	template <typename valType, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec4<valType, P> fastNormalize
+	GLM_FUNC_QUALIFIER tvec4<valType, P> fastNormalize
 	(
-		detail::tvec4<valType, P> const & x
+		tvec4<valType, P> const & x
 	)
 	{
 		valType sqr = x.x * x.x + x.y * x.y + x.z * x.z + x.w * x.w;

glm/gtx/gradient_paint.hpp

@@ -54,18 +54,18 @@ namespace glm
 	/// @see - gtx_gradient_paint
 	template <typename T, precision P>
 	GLM_FUNC_DECL T radialGradient(
-		detail::tvec2<T, P> const & Center,
+		tvec2<T, P> const & Center,
 		T const & Radius,
-		detail::tvec2<T, P> const & Focal,
-		detail::tvec2<T, P> const & Position);
+		tvec2<T, P> const & Focal,
+		tvec2<T, P> const & Position);
 
 	/// Return a color from a linear gradient.
 	/// @see - gtx_gradient_paint
 	template <typename T, precision P>
 	GLM_FUNC_DECL T linearGradient(
-		detail::tvec2<T, P> const & Point0,
-		detail::tvec2<T, P> const & Point1,
-		detail::tvec2<T, P> const & Position);
+		tvec2<T, P> const & Point0,
+		tvec2<T, P> const & Point1,
+		tvec2<T, P> const & Position);
 
 	/// @}
 }// namespace glm

glm/gtx/gradient_paint.inl

@@ -12,14 +12,14 @@ namespace glm
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER T radialGradient
 	(
-		detail::tvec2<T, P> const & Center,
+		tvec2<T, P> const & Center,
 		T const & Radius,
-		detail::tvec2<T, P> const & Focal,
-		detail::tvec2<T, P> const & Position
+		tvec2<T, P> const & Focal,
+		tvec2<T, P> const & Position
 	)
 	{
-		detail::tvec2<T, P> F = Focal - Center;
-		detail::tvec2<T, P> D = Position - Focal;
+		tvec2<T, P> F = Focal - Center;
+		tvec2<T, P> D = Position - Focal;
 		T Radius2 = pow2(Radius);
 		T Fx2 = pow2(F.x);
 		T Fy2 = pow2(F.y);
@@ -32,12 +32,12 @@ namespace glm
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER T linearGradient
 	(
-		detail::tvec2<T, P> const & Point0,
-		detail::tvec2<T, P> const & Point1,
-		detail::tvec2<T, P> const & Position
+		tvec2<T, P> const & Point0,
+		tvec2<T, P> const & Point1,
+		tvec2<T, P> const & Position
 	)
 	{
-		detail::tvec2<T, P> Dist = Point1 - Point0;
+		tvec2<T, P> Dist = Point1 - Point0;
 		return (Dist.x * (Position.x - Point0.x) + Dist.y * (Position.y - Point0.y)) / glm::dot(Dist, Dist);
 	}
 }//namespace glm

glm/gtx/handed_coordinate_space.hpp

@@ -53,17 +53,17 @@ namespace glm
 	//! From GLM_GTX_handed_coordinate_space extension.
 	template <typename T, precision P>
 	GLM_FUNC_DECL bool rightHanded(
-		detail::tvec3<T, P> const & tangent,
-		detail::tvec3<T, P> const & binormal,
-		detail::tvec3<T, P> const & normal);
+		tvec3<T, P> const & tangent,
+		tvec3<T, P> const & binormal,
+		tvec3<T, P> const & normal);
 
 	//! Return if a trihedron left handed or not.
 	//! From GLM_GTX_handed_coordinate_space extension.
 	template <typename T, precision P>
 	GLM_FUNC_DECL bool leftHanded(
-		detail::tvec3<T, P> const & tangent,
-		detail::tvec3<T, P> const & binormal,
-		detail::tvec3<T, P> const & normal);
+		tvec3<T, P> const & tangent,
+		tvec3<T, P> const & binormal,
+		tvec3<T, P> const & normal);
 
 	/// @}
 }// namespace glm

glm/gtx/handed_coordinate_space.inl

@@ -12,9 +12,9 @@ namespace glm
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER bool rightHanded
 	(
-		detail::tvec3<T, P> const & tangent,
-		detail::tvec3<T, P> const & binormal,
-		detail::tvec3<T, P> const & normal
+		tvec3<T, P> const & tangent,
+		tvec3<T, P> const & binormal,
+		tvec3<T, P> const & normal
 	)
 	{
 		return dot(cross(normal, tangent), binormal) > T(0);
@@ -23,9 +23,9 @@ namespace glm
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER bool leftHanded
 	(
-		detail::tvec3<T, P> const & tangent,
-		detail::tvec3<T, P> const & binormal,
-		detail::tvec3<T, P> const & normal
+		tvec3<T, P> const & tangent,
+		tvec3<T, P> const & binormal,
+		tvec3<T, P> const & normal
 	)
 	{
 		return dot(cross(normal, tangent), binormal) < T(0);

glm/gtx/inertia.hpp

@@ -54,56 +54,56 @@ namespace glm
 	//! Build an inertia matrix for a box.
 	//! From GLM_GTX_inertia extension.
 	template <typename T, precision P>
-	detail::tmat3x3<T, P> boxInertia3(
+	tmat3x3<T, P> boxInertia3(
 		T const & Mass, 
-		detail::tvec3<T, P> const & Scale);
+		tvec3<T, P> const & Scale);
 		
 	//! Build an inertia matrix for a box.
 	//! From GLM_GTX_inertia extension.
 	template <typename T, precision P>
-	detail::tmat4x4<T, P> boxInertia4(
+	tmat4x4<T, P> boxInertia4(
 		T const & Mass, 
-		detail::tvec3<T, P> const & Scale);
+		tvec3<T, P> const & Scale);
 		
 	//! Build an inertia matrix for a disk.
 	//! From GLM_GTX_inertia extension.
 	template <typename T, precision P>
-	detail::tmat3x3<T, P> diskInertia3(
+	tmat3x3<T, P> diskInertia3(
 		T const & Mass, 
 		T const & Radius);
 
 	//! Build an inertia matrix for a disk.
 	//! From GLM_GTX_inertia extension.
 	template <typename T, precision P>
-	detail::tmat4x4<T, P> diskInertia4(
+	tmat4x4<T, P> diskInertia4(
 		T const & Mass, 
 		T const & Radius);
 
 	//! Build an inertia matrix for a ball.
 	//! From GLM_GTX_inertia extension.
 	template <typename T, precision P>
-	detail::tmat3x3<T, P> ballInertia3(
+	tmat3x3<T, P> ballInertia3(
 		T const & Mass, 
 		T const & Radius);
 		
 	//! Build an inertia matrix for a ball.
 	//! From GLM_GTX_inertia extension.
 	template <typename T, precision P>
-	detail::tmat4x4<T, P> ballInertia4(
+	tmat4x4<T, P> ballInertia4(
 		T const & Mass, 
 		T const & Radius);
 
 	//! Build an inertia matrix for a sphere.
 	//! From GLM_GTX_inertia extension.
 	template <typename T, precision P>
-	detail::tmat3x3<T, P> sphereInertia3(
+	tmat3x3<T, P> sphereInertia3(
 		T const & Mass, 
 		T const & Radius);
 
 	//! Build an inertia matrix for a sphere.
 	//! From GLM_GTX_inertia extension.
 	template <typename T, precision P> 
-	detail::tmat4x4<T, P> sphereInertia4(
+	tmat4x4<T, P> sphereInertia4(
 		T const & Mass, 
 		T const & Radius);
 	*/

glm/gtx/inertia.inl

@@ -11,13 +11,13 @@ namespace glm
 {
 /*
 	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat3x3<T, P> boxInertia3
+	GLM_FUNC_QUALIFIER tmat3x3<T, P> boxInertia3
 	(
 		T const & Mass, 
-		detail::tvec3<T, P> const & Scale
+		tvec3<T, P> const & Scale
 	)
 	{
-		detail::tmat3x3<T, P> Result(T(1));
+		tmat3x3<T, P> Result(T(1));
 		Result[0][0] = (Scale.y * Scale.y + Scale.z * Scale.z) * Mass / T(12);
 		Result[1][1] = (Scale.x * Scale.x + Scale.z * Scale.z) * Mass / T(12);
 		Result[2][2] = (Scale.x * Scale.x + Scale.y * Scale.y) * Mass / T(12);
@@ -25,13 +25,13 @@ namespace glm
 	}
 
 	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T, P> boxInertia4
+	GLM_FUNC_QUALIFIER tmat4x4<T, P> boxInertia4
 	(
 		T const & Mass, 
-		detail::tvec3<T, P> const & Scale
+		tvec3<T, P> const & Scale
 	)
 	{
-		detail::tmat4x4<T, P> Result(T(1));
+		tmat4x4<T, P> Result(T(1));
 		Result[0][0] = (Scale.y * Scale.y + Scale.z * Scale.z) * Mass / T(12);
 		Result[1][1] = (Scale.x * Scale.x + Scale.z * Scale.z) * Mass / T(12);
 		Result[2][2] = (Scale.x * Scale.x + Scale.y * Scale.y) * Mass / T(12);
@@ -39,76 +39,76 @@ namespace glm
 	}
 
 	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat3x3<T, P> diskInertia3
+	GLM_FUNC_QUALIFIER tmat3x3<T, P> diskInertia3
 	(
 		T const & Mass, 
 		T const & Radius
 	)
 	{
 		T a = Mass * Radius * Radius / T(2);
-		detail::tmat3x3<T, P> Result(a);
+		tmat3x3<T, P> Result(a);
 		Result[2][2] *= static_cast<T>(2);
 		return Result;
 	}
 
 	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T, P> diskInertia4
+	GLM_FUNC_QUALIFIER tmat4x4<T, P> diskInertia4
 	(
 		T const & Mass, 
 		T const & Radius
 	)
 	{
 		T a = Mass * Radius * Radius / T(2);
-		detail::tmat4x4<T, P> Result(a);
+		tmat4x4<T, P> Result(a);
 		Result[2][2] *= static_cast<T>(2);
 		Result[3][3] = static_cast<T>(1);
 		return Result;
 	}
 
 	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat3x3<T, P> ballInertia3
+	GLM_FUNC_QUALIFIER tmat3x3<T, P> ballInertia3
 	(
 		T const & Mass, 
 		T const & Radius
 	)
 	{
 		T a = static_cast<T>(2) * Mass * Radius * Radius / T(5);
-		return detail::tmat3x3<T, P>(a);
+		return tmat3x3<T, P>(a);
 	}
 
 	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T, P> ballInertia4
+	GLM_FUNC_QUALIFIER tmat4x4<T, P> ballInertia4
 	(
 		T const & Mass, 
 		T const & Radius
 	)
 	{
 		T a = static_cast<T>(2) * Mass * Radius * Radius / T(5);
-		detail::tmat4x4<T, P> Result(a);
+		tmat4x4<T, P> Result(a);
 		Result[3][3] = static_cast<T>(1);
 		return Result;
 	}
 
 	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat3x3<T, P> sphereInertia3
+	GLM_FUNC_QUALIFIER tmat3x3<T, P> sphereInertia3
 	(
 		T const & Mass, 
 		T const & Radius
 	)
 	{
 		T a = static_cast<T>(2) * Mass * Radius * Radius / T(3);
-		return detail::tmat3x3<T, P>(a);
+		return tmat3x3<T, P>(a);
 	}
 
 	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T, P> sphereInertia4
+	GLM_FUNC_QUALIFIER tmat4x4<T, P> sphereInertia4
 	(
 		T const & Mass, 
 		T const & Radius
 	)
 	{
 		T a = static_cast<T>(2) * Mass * Radius * Radius / T(3);
-		detail::tmat4x4<T, P> Result(a);
+		tmat4x4<T, P> Result(a);
 		Result[3][3] = static_cast<T>(1);
 		return Result;
 	}

glm/gtx/integer.inl

@@ -100,29 +100,29 @@ namespace detail
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec2<T, P> factorial(
-		detail::tvec2<T, P> const & x)
+	GLM_FUNC_QUALIFIER tvec2<T, P> factorial(
+		tvec2<T, P> const & x)
 	{
-		return detail::tvec2<T, P>(
+		return tvec2<T, P>(
 			factorial(x.x),
 			factorial(x.y));
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec3<T, P> factorial(
-		detail::tvec3<T, P> const & x)
+	GLM_FUNC_QUALIFIER tvec3<T, P> factorial(
+		tvec3<T, P> const & x)
 	{
-		return detail::tvec3<T, P>(
+		return tvec3<T, P>(
 			factorial(x.x),
 			factorial(x.y),
 			factorial(x.z));
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec4<T, P> factorial(
-		detail::tvec4<T, P> const & x)
+	GLM_FUNC_QUALIFIER tvec4<T, P> factorial(
+		tvec4<T, P> const & x)
 	{
-		return detail::tvec4<T, P>(
+		return tvec4<T, P>(
 			factorial(x.x),
 			factorial(x.y),
 			factorial(x.z),

glm/gtx/io.hpp

@@ -181,41 +181,38 @@ namespace glm
 		std::basic_ostream<CTy, CTr>& operator<<(std::basic_ostream<CTy, CTr>&, order const&);
 	}//namespace io
 
-	namespace detail
-	{
-		template <typename CTy, typename CTr, typename T, precision P>
-		GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tquat<T,P> const&);
-		template <typename CTy, typename CTr, typename T, precision P>
-		GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tvec2<T,P> const&);
-		template <typename CTy, typename CTr, typename T, precision P>
-		GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tvec3<T,P> const&);
-		template <typename CTy, typename CTr, typename T, precision P>
-		GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tvec4<T,P> const&);
-		template <typename CTy, typename CTr, typename T, precision P>
-		GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat2x2<T,P> const&);
-		template <typename CTy, typename CTr, typename T, precision P>
-		GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat2x3<T,P> const&);
-		template <typename CTy, typename CTr, typename T, precision P>
-		GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat2x4<T,P> const&);
-		template <typename CTy, typename CTr, typename T, precision P>
-		GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat3x2<T,P> const&);
-		template <typename CTy, typename CTr, typename T, precision P>
-		GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat3x3<T,P> const&);
-		template <typename CTy, typename CTr, typename T, precision P>
-		GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat3x4<T,P> const&);
-		template <typename CTy, typename CTr, typename T, precision P>
-		GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat4x2<T,P> const&);
-		template <typename CTy, typename CTr, typename T, precision P>
-		GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat4x3<T,P> const&);
-		template <typename CTy, typename CTr, typename T, precision P>
-		GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat4x4<T,P> const&);
-
-		template <typename CTy, typename CTr, typename T, precision P>
-		GLM_FUNC_DECL std::basic_ostream<CTy,CTr> & operator<<(
-			std::basic_ostream<CTy,CTr> &,
-			std::pair<tmat4x4<T,P> const,
-			tmat4x4<T,P> const> const &);
-	}//namespace detail
+	template <typename CTy, typename CTr, typename T, precision P>
+	GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tquat<T,P> const&);
+	template <typename CTy, typename CTr, typename T, precision P>
+	GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tvec2<T,P> const&);
+	template <typename CTy, typename CTr, typename T, precision P>
+	GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tvec3<T,P> const&);
+	template <typename CTy, typename CTr, typename T, precision P>
+	GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tvec4<T,P> const&);
+	template <typename CTy, typename CTr, typename T, precision P>
+	GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat2x2<T,P> const&);
+	template <typename CTy, typename CTr, typename T, precision P>
+	GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat2x3<T,P> const&);
+	template <typename CTy, typename CTr, typename T, precision P>
+	GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat2x4<T,P> const&);
+	template <typename CTy, typename CTr, typename T, precision P>
+	GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat3x2<T,P> const&);
+	template <typename CTy, typename CTr, typename T, precision P>
+	GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat3x3<T,P> const&);
+	template <typename CTy, typename CTr, typename T, precision P>
+	GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat3x4<T,P> const&);
+	template <typename CTy, typename CTr, typename T, precision P>
+	GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat4x2<T,P> const&);
+	template <typename CTy, typename CTr, typename T, precision P>
+	GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat4x3<T,P> const&);
+	template <typename CTy, typename CTr, typename T, precision P>
+	GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat4x4<T,P> const&);
+
+	template <typename CTy, typename CTr, typename T, precision P>
+	GLM_FUNC_DECL std::basic_ostream<CTy,CTr> & operator<<(
+		std::basic_ostream<CTy,CTr> &,
+		std::pair<tmat4x4<T,P> const,
+		tmat4x4<T,P> const> const &);
 
 	/// @}
 }//namespace glm

glm/gtx/io.inl

@@ -162,8 +162,6 @@ namespace io
 	}
 } // namespace io
 
-namespace detail
-{
 	template <typename CTy, typename CTr, typename T, precision P>
 	GLM_FUNC_QUALIFIER std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>& os, tquat<T,P> const& a)
 	{
@@ -594,5 +592,4 @@ namespace detail
 
 		return os;
 	}
-}//namespace detail
 }//namespace glm

glm/gtx/matrix_cross_product.hpp

@@ -53,14 +53,14 @@ namespace glm
 	//! Build a cross product matrix.
 	//! From GLM_GTX_matrix_cross_product extension.
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tmat3x3<T, P> matrixCross3(
-		detail::tvec3<T, P> const & x);
+	GLM_FUNC_DECL tmat3x3<T, P> matrixCross3(
+		tvec3<T, P> const & x);
 		
 	//! Build a cross product matrix.
 	//! From GLM_GTX_matrix_cross_product extension.
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tmat4x4<T, P> matrixCross4(
-		detail::tvec3<T, P> const & x);
+	GLM_FUNC_DECL tmat4x4<T, P> matrixCross4(
+		tvec3<T, P> const & x);
 
 	/// @}
 }//namespace glm

glm/gtx/matrix_cross_product.inl

@@ -10,12 +10,12 @@
 namespace glm
 {
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tmat3x3<T, P> matrixCross3
+	GLM_FUNC_QUALIFIER tmat3x3<T, P> matrixCross3
 	(
-		detail::tvec3<T, P> const & x
+		tvec3<T, P> const & x
 	)
 	{
-		detail::tmat3x3<T, P> Result(T(0));
+		tmat3x3<T, P> Result(T(0));
 		Result[0][1] = x.z;
 		Result[1][0] = -x.z;
 		Result[0][2] = -x.y;
@@ -26,12 +26,12 @@ namespace glm
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T, P> matrixCross4
+	GLM_FUNC_QUALIFIER tmat4x4<T, P> matrixCross4
 	(
-		detail::tvec3<T, P> const & x
+		tvec3<T, P> const & x
 	)
 	{
-		detail::tmat4x4<T, P> Result(T(0));
+		tmat4x4<T, P> Result(T(0));
 		Result[0][1] = x.z;
 		Result[1][0] = -x.z;
 		Result[0][2] = -x.y;

glm/gtx/matrix_decompose.hpp

@@ -57,8 +57,8 @@ namespace glm
 	/// @see gtx_decomposition
 	template <typename T, precision P>
 	GLM_FUNC_DECL bool decompose(
-		detail::tmat4x4<T, P> const & modelMatrix,
-		detail::tvec3<T, P> & scale, detail::tquat<T, P> & orientation, detail::tvec3<T, P> & translation, detail::tvec3<T, P> & skew, detail::tvec4<T, P> & perspective);
+		tmat4x4<T, P> const & modelMatrix,
+		tvec3<T, P> & scale, tquat<T, P> & orientation, tvec3<T, P> & translation, tvec3<T, P> & skew, tvec4<T, P> & perspective);
 
 	/// @}
 }//namespace glm

glm/gtx/matrix_decompose.inl

@@ -31,16 +31,16 @@ namespace glm
 	/// Make a linear combination of two vectors and return the result.
 	// result = (a * ascl) + (b * bscl)
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec3<T, P> combine(
-		detail::tvec3<T, P> const & a, 
-		detail::tvec3<T, P> const & b,
+	GLM_FUNC_QUALIFIER tvec3<T, P> combine(
+		tvec3<T, P> const & a, 
+		tvec3<T, P> const & b,
 		T ascl, T bscl)
 	{
 	    return (a * ascl) + (b * bscl);
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER void v3Scale(detail::tvec3<T, P> & v, T desiredLength) 
+	GLM_FUNC_QUALIFIER void v3Scale(tvec3<T, P> & v, T desiredLength) 
 	{
 	    T len = glm::length(v);
 	    if(len != 0)
@@ -60,9 +60,9 @@ namespace glm
 	*/
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER bool decompose(detail::tmat4x4<T, P> const & ModelMatrix, detail::tvec3<T, P> & Scale, detail::tquat<T, P> & Orientation, detail::tvec3<T, P> & Translation, detail::tvec3<T, P> & Skew, detail::tvec4<T, P> & Perspective)
+	GLM_FUNC_QUALIFIER bool decompose(tmat4x4<T, P> const & ModelMatrix, tvec3<T, P> & Scale, tquat<T, P> & Orientation, tvec3<T, P> & Translation, tvec3<T, P> & Skew, tvec4<T, P> & Perspective)
 	{
-		detail::tmat4x4<T, P> LocalMatrix(ModelMatrix);
+		tmat4x4<T, P> LocalMatrix(ModelMatrix);
 
 	    // Normalize the matrix.
 	    if(LocalMatrix[3][3] == static_cast<T>(0))
@@ -74,7 +74,7 @@ namespace glm
 
 		// perspectiveMatrix is used to solve for perspective, but it also provides
 		// an easy way to test for singularity of the upper 3x3 component.
-		detail::tmat4x4<T, P> PerspectiveMatrix(LocalMatrix);
+		tmat4x4<T, P> PerspectiveMatrix(LocalMatrix);
 
 	    for(length_t i = 0; i < 3; i++)
 	        PerspectiveMatrix[i][3] = 0;
@@ -88,7 +88,7 @@ namespace glm
 	    if(LocalMatrix[0][3] != 0 || LocalMatrix[1][3] != 0 || LocalMatrix[2][3] != 0)
 	    {
 			// rightHandSide is the right hand side of the equation.
-			detail::tvec4<T, P> RightHandSide;
+			tvec4<T, P> RightHandSide;
 			RightHandSide[0] = LocalMatrix[0][3];
 			RightHandSide[1] = LocalMatrix[1][3];
 			RightHandSide[2] = LocalMatrix[2][3];
@@ -97,8 +97,8 @@ namespace glm
 			// Solve the equation by inverting PerspectiveMatrix and multiplying
 			// rightHandSide by the inverse.  (This is the easiest way, not
 			// necessarily the best.)
-			detail::tmat4x4<T, P> InversePerspectiveMatrix = glm::inverse(PerspectiveMatrix);//   inverse(PerspectiveMatrix, inversePerspectiveMatrix);
-			detail::tmat4x4<T, P> TransposedInversePerspectiveMatrix = glm::transpose(InversePerspectiveMatrix);//   transposeMatrix4(inversePerspectiveMatrix, transposedInversePerspectiveMatrix);
+			tmat4x4<T, P> InversePerspectiveMatrix = glm::inverse(PerspectiveMatrix);//   inverse(PerspectiveMatrix, inversePerspectiveMatrix);
+			tmat4x4<T, P> TransposedInversePerspectiveMatrix = glm::transpose(InversePerspectiveMatrix);//   transposeMatrix4(inversePerspectiveMatrix, transposedInversePerspectiveMatrix);
 
 			Perspective = TransposedInversePerspectiveMatrix * RightHandSide;
 			//  v4MulPointByMatrix(rightHandSide, transposedInversePerspectiveMatrix, perspectivePoint);
@@ -110,14 +110,14 @@ namespace glm
 	    else
 	    {
 			// No perspective.
-			Perspective = detail::tvec4<T, P>(0, 0, 0, 1);
+			Perspective = tvec4<T, P>(0, 0, 0, 1);
 	    }
 
 	    // Next take care of translation (easy).
-	    Translation = detail::tvec3<T, P>(LocalMatrix[3]);
-	    LocalMatrix[3] = detail::tvec4<T, P>(0, 0, 0, LocalMatrix[3].w);
+	    Translation = tvec3<T, P>(LocalMatrix[3]);
+	    LocalMatrix[3] = tvec4<T, P>(0, 0, 0, LocalMatrix[3].w);
 
-	    detail::tvec3<T, P> Row[3], Pdum3;
+	    tvec3<T, P> Row[3], Pdum3;
 
 	    // Now get scale and shear.
 	    for(length_t i = 0; i < 3; ++i)

glm/gtx/matrix_interpolation.hpp

@@ -53,30 +53,30 @@ namespace glm
 	/// From GLM_GTX_matrix_interpolation extension.
 	template <typename T, precision P>
 	GLM_FUNC_DECL void axisAngle(
-		detail::tmat4x4<T, P> const & mat,
-		detail::tvec3<T, P> & axis,
+		tmat4x4<T, P> const & mat,
+		tvec3<T, P> & axis,
 		T & angle);
 
 	/// Build a matrix from axis and angle.
 	/// From GLM_GTX_matrix_interpolation extension.
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tmat4x4<T, P> axisAngleMatrix(
-		detail::tvec3<T, P> const & axis,
+	GLM_FUNC_DECL tmat4x4<T, P> axisAngleMatrix(
+		tvec3<T, P> const & axis,
 		T const angle);
 
 	/// Extracts the rotation part of a matrix.
 	/// From GLM_GTX_matrix_interpolation extension.
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tmat4x4<T, P> extractMatrixRotation(
-		detail::tmat4x4<T, P> const & mat);
+	GLM_FUNC_DECL tmat4x4<T, P> extractMatrixRotation(
+		tmat4x4<T, P> const & mat);
 
 	/// Build a interpolation of 4 * 4 matrixes.
 	/// From GLM_GTX_matrix_interpolation extension.
 	/// Warning! works only with rotation and/or translation matrixes, scale will generate unexpected results.
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tmat4x4<T, P> interpolate(
-		detail::tmat4x4<T, P> const & m1,
-		detail::tmat4x4<T, P> const & m2,
+	GLM_FUNC_DECL tmat4x4<T, P> interpolate(
+		tmat4x4<T, P> const & m1,
+		tmat4x4<T, P> const & m2,
 		T const delta);
 
 	/// @}

glm/gtx/matrix_interpolation.inl

@@ -12,8 +12,8 @@ namespace glm
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER void axisAngle
 	(
-		detail::tmat4x4<T, P> const & mat,
-		detail::tvec3<T, P> & axis,
+		tmat4x4<T, P> const & mat,
+		tvec3<T, P> & axis,
 		T & angle
 	)
 	{
@@ -85,18 +85,18 @@ namespace glm
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T, P> axisAngleMatrix
+	GLM_FUNC_QUALIFIER tmat4x4<T, P> axisAngleMatrix
 	(
-		detail::tvec3<T, P> const & axis,
+		tvec3<T, P> const & axis,
 		T const angle
 	)
 	{
 		T c = cos(angle);
 		T s = sin(angle);
 		T t = static_cast<T>(1) - c;
-		detail::tvec3<T, P> n = normalize(axis);
+		tvec3<T, P> n = normalize(axis);
 
-		return detail::tmat4x4<T, P>(
+		return tmat4x4<T, P>(
 			t * n.x * n.x + c,          t * n.x * n.y + n.z * s,    t * n.x * n.z - n.y * s,    T(0),
 			t * n.x * n.y - n.z * s,    t * n.y * n.y + c,          t * n.y * n.z + n.x * s,    T(0),
 			t * n.x * n.z + n.y * s,    t * n.y * n.z - n.x * s,    t * n.z * n.z + c,          T(0),
@@ -105,12 +105,12 @@ namespace glm
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T, P> extractMatrixRotation
+	GLM_FUNC_QUALIFIER tmat4x4<T, P> extractMatrixRotation
 	(
-		detail::tmat4x4<T, P> const & mat
+		tmat4x4<T, P> const & mat
 	)
 	{
-		return detail::tmat4x4<T, P>(
+		return tmat4x4<T, P>(
 			mat[0][0], mat[0][1], mat[0][2], 0.0,
 			mat[1][0], mat[1][1], mat[1][2], 0.0,
 			mat[2][0], mat[2][1], mat[2][2], 0.0,
@@ -119,19 +119,19 @@ namespace glm
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T, P> interpolate
+	GLM_FUNC_QUALIFIER tmat4x4<T, P> interpolate
 	(
-		detail::tmat4x4<T, P> const & m1,
-		detail::tmat4x4<T, P> const & m2,
+		tmat4x4<T, P> const & m1,
+		tmat4x4<T, P> const & m2,
 		T const delta
 	)
 	{
-		detail::tmat4x4<T, P> m1rot = extractMatrixRotation(m1);
-		detail::tmat4x4<T, P> dltRotation = m2 * transpose(m1rot);
-		detail::tvec3<T, P> dltAxis;
+		tmat4x4<T, P> m1rot = extractMatrixRotation(m1);
+		tmat4x4<T, P> dltRotation = m2 * transpose(m1rot);
+		tvec3<T, P> dltAxis;
 		T dltAngle;
 		axisAngle(dltRotation, dltAxis, dltAngle);
-		detail::tmat4x4<T, P> out = axisAngleMatrix(dltAxis, dltAngle * delta) * m1rot;
+		tmat4x4<T, P> out = axisAngleMatrix(dltAxis, dltAngle * delta) * m1rot;
 		out[3][0] = m1[3][0] + delta * (m2[3][0] - m1[3][0]);
 		out[3][1] = m1[3][1] + delta * (m2[3][1] - m1[3][1]);
 		out[3][2] = m1[3][2] + delta * (m2[3][2] - m1[3][2]);

glm/gtx/matrix_major_storage.hpp

@@ -53,86 +53,86 @@ namespace glm
 	//! Build a row major matrix from row vectors.
 	//! From GLM_GTX_matrix_major_storage extension.
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tmat2x2<T, P> rowMajor2(
-		detail::tvec2<T, P> const & v1, 
-		detail::tvec2<T, P> const & v2);
+	GLM_FUNC_DECL tmat2x2<T, P> rowMajor2(
+		tvec2<T, P> const & v1, 
+		tvec2<T, P> const & v2);
 		
 	//! Build a row major matrix from other matrix.
 	//! From GLM_GTX_matrix_major_storage extension.
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tmat2x2<T, P> rowMajor2(
-		detail::tmat2x2<T, P> const & m);
+	GLM_FUNC_DECL tmat2x2<T, P> rowMajor2(
+		tmat2x2<T, P> const & m);
 
 	//! Build a row major matrix from row vectors.
 	//! From GLM_GTX_matrix_major_storage extension.
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tmat3x3<T, P> rowMajor3(
-		detail::tvec3<T, P> const & v1, 
-		detail::tvec3<T, P> const & v2, 
-		detail::tvec3<T, P> const & v3);
+	GLM_FUNC_DECL tmat3x3<T, P> rowMajor3(
+		tvec3<T, P> const & v1, 
+		tvec3<T, P> const & v2, 
+		tvec3<T, P> const & v3);
 
 	//! Build a row major matrix from other matrix.
 	//! From GLM_GTX_matrix_major_storage extension.
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tmat3x3<T, P> rowMajor3(
-		detail::tmat3x3<T, P> const & m);
+	GLM_FUNC_DECL tmat3x3<T, P> rowMajor3(
+		tmat3x3<T, P> const & m);
 
 	//! Build a row major matrix from row vectors.
 	//! From GLM_GTX_matrix_major_storage extension.
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tmat4x4<T, P> rowMajor4(
-		detail::tvec4<T, P> const & v1, 
-		detail::tvec4<T, P> const & v2,
-		detail::tvec4<T, P> const & v3, 
-		detail::tvec4<T, P> const & v4);
+	GLM_FUNC_DECL tmat4x4<T, P> rowMajor4(
+		tvec4<T, P> const & v1, 
+		tvec4<T, P> const & v2,
+		tvec4<T, P> const & v3, 
+		tvec4<T, P> const & v4);
 
 	//! Build a row major matrix from other matrix.
 	//! From GLM_GTX_matrix_major_storage extension.
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tmat4x4<T, P> rowMajor4(
-		detail::tmat4x4<T, P> const & m);
+	GLM_FUNC_DECL tmat4x4<T, P> rowMajor4(
+		tmat4x4<T, P> const & m);
 
 	//! Build a column major matrix from column vectors.
 	//! From GLM_GTX_matrix_major_storage extension.
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tmat2x2<T, P> colMajor2(
-		detail::tvec2<T, P> const & v1, 
-		detail::tvec2<T, P> const & v2);
+	GLM_FUNC_DECL tmat2x2<T, P> colMajor2(
+		tvec2<T, P> const & v1, 
+		tvec2<T, P> const & v2);
 		
 	//! Build a column major matrix from other matrix.
 	//! From GLM_GTX_matrix_major_storage extension.
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tmat2x2<T, P> colMajor2(
-		detail::tmat2x2<T, P> const & m);
+	GLM_FUNC_DECL tmat2x2<T, P> colMajor2(
+		tmat2x2<T, P> const & m);
 
 	//! Build a column major matrix from column vectors.
 	//! From GLM_GTX_matrix_major_storage extension.
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tmat3x3<T, P> colMajor3(
-		detail::tvec3<T, P> const & v1, 
-		detail::tvec3<T, P> const & v2, 
-		detail::tvec3<T, P> const & v3);
+	GLM_FUNC_DECL tmat3x3<T, P> colMajor3(
+		tvec3<T, P> const & v1, 
+		tvec3<T, P> const & v2, 
+		tvec3<T, P> const & v3);
 		
 	//! Build a column major matrix from other matrix.
 	//! From GLM_GTX_matrix_major_storage extension.
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tmat3x3<T, P> colMajor3(
-		detail::tmat3x3<T, P> const & m);
+	GLM_FUNC_DECL tmat3x3<T, P> colMajor3(
+		tmat3x3<T, P> const & m);
 		
 	//! Build a column major matrix from column vectors.
 	//! From GLM_GTX_matrix_major_storage extension.
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tmat4x4<T, P> colMajor4(
-		detail::tvec4<T, P> const & v1, 
-		detail::tvec4<T, P> const & v2, 
-		detail::tvec4<T, P> const & v3, 
-		detail::tvec4<T, P> const & v4);
+	GLM_FUNC_DECL tmat4x4<T, P> colMajor4(
+		tvec4<T, P> const & v1, 
+		tvec4<T, P> const & v2, 
+		tvec4<T, P> const & v3, 
+		tvec4<T, P> const & v4);
 				
 	//! Build a column major matrix from other matrix.
 	//! From GLM_GTX_matrix_major_storage extension.
 	template <typename T, precision P> 
-	GLM_FUNC_DECL detail::tmat4x4<T, P> colMajor4(
-		detail::tmat4x4<T, P> const & m);
+	GLM_FUNC_DECL tmat4x4<T, P> colMajor4(
+		tmat4x4<T, P> const & m);
 
 	/// @}
 }//namespace glm

glm/gtx/matrix_major_storage.inl

@@ -10,13 +10,13 @@
 namespace glm
 {
 	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER detail::tmat2x2<T, P> rowMajor2
+	GLM_FUNC_QUALIFIER tmat2x2<T, P> rowMajor2
 	(
-		detail::tvec2<T, P> const & v1, 
-		detail::tvec2<T, P> const & v2
+		tvec2<T, P> const & v1, 
+		tvec2<T, P> const & v2
 	)
 	{
-		detail::tmat2x2<T, P> Result;
+		tmat2x2<T, P> Result;
 		Result[0][0] = v1.x;
 		Result[1][0] = v1.y;
 		Result[0][1] = v2.x;
@@ -25,10 +25,10 @@ namespace glm
 	}
 
 	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER detail::tmat2x2<T, P> rowMajor2(
-		const detail::tmat2x2<T, P>& m)
+	GLM_FUNC_QUALIFIER tmat2x2<T, P> rowMajor2(
+		const tmat2x2<T, P>& m)
 	{
-		detail::tmat2x2<T, P> Result;
+		tmat2x2<T, P> Result;
 		Result[0][0] = m[0][0];
 		Result[0][1] = m[1][0];
 		Result[1][0] = m[0][1];
@@ -37,12 +37,12 @@ namespace glm
 	}
 
 	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER detail::tmat3x3<T, P> rowMajor3(
-		const detail::tvec3<T, P>& v1, 
-		const detail::tvec3<T, P>& v2, 
-		const detail::tvec3<T, P>& v3)
+	GLM_FUNC_QUALIFIER tmat3x3<T, P> rowMajor3(
+		const tvec3<T, P>& v1, 
+		const tvec3<T, P>& v2, 
+		const tvec3<T, P>& v3)
 	{
-		detail::tmat3x3<T, P> Result;
+		tmat3x3<T, P> Result;
 		Result[0][0] = v1.x;
 		Result[1][0] = v1.y;
 		Result[2][0] = v1.z;
@@ -56,10 +56,10 @@ namespace glm
 	}
 
 	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER detail::tmat3x3<T, P> rowMajor3(
-		const detail::tmat3x3<T, P>& m)
+	GLM_FUNC_QUALIFIER tmat3x3<T, P> rowMajor3(
+		const tmat3x3<T, P>& m)
 	{
-		detail::tmat3x3<T, P> Result;
+		tmat3x3<T, P> Result;
 		Result[0][0] = m[0][0];
 		Result[0][1] = m[1][0];
 		Result[0][2] = m[2][0];
@@ -73,13 +73,13 @@ namespace glm
 	}
 
 	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T, P> rowMajor4(
-		const detail::tvec4<T, P>& v1, 
-		const detail::tvec4<T, P>& v2, 
-		const detail::tvec4<T, P>& v3, 
-		const detail::tvec4<T, P>& v4)
+	GLM_FUNC_QUALIFIER tmat4x4<T, P> rowMajor4(
+		const tvec4<T, P>& v1, 
+		const tvec4<T, P>& v2, 
+		const tvec4<T, P>& v3, 
+		const tvec4<T, P>& v4)
 	{
-		detail::tmat4x4<T, P> Result;
+		tmat4x4<T, P> Result;
 		Result[0][0] = v1.x;
 		Result[1][0] = v1.y;
 		Result[2][0] = v1.z;
@@ -100,10 +100,10 @@ namespace glm
 	}
 
 	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T, P> rowMajor4(
-		const detail::tmat4x4<T, P>& m)
+	GLM_FUNC_QUALIFIER tmat4x4<T, P> rowMajor4(
+		const tmat4x4<T, P>& m)
 	{
-		detail::tmat4x4<T, P> Result;
+		tmat4x4<T, P> Result;
 		Result[0][0] = m[0][0];
 		Result[0][1] = m[1][0];
 		Result[0][2] = m[2][0];
@@ -124,50 +124,50 @@ namespace glm
 	}
 
 	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER detail::tmat2x2<T, P> colMajor2(
-		const detail::tvec2<T, P>& v1, 
-		const detail::tvec2<T, P>& v2)
+	GLM_FUNC_QUALIFIER tmat2x2<T, P> colMajor2(
+		const tvec2<T, P>& v1, 
+		const tvec2<T, P>& v2)
 	{
-		return detail::tmat2x2<T, P>(v1, v2);
+		return tmat2x2<T, P>(v1, v2);
 	}
 
 	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER detail::tmat2x2<T, P> colMajor2(
-		const detail::tmat2x2<T, P>& m)
+	GLM_FUNC_QUALIFIER tmat2x2<T, P> colMajor2(
+		const tmat2x2<T, P>& m)
 	{
-		return detail::tmat2x2<T, P>(m);
+		return tmat2x2<T, P>(m);
 	}
 
 	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER detail::tmat3x3<T, P> colMajor3(
-		const detail::tvec3<T, P>& v1, 
-		const detail::tvec3<T, P>& v2, 
-		const detail::tvec3<T, P>& v3)
+	GLM_FUNC_QUALIFIER tmat3x3<T, P> colMajor3(
+		const tvec3<T, P>& v1, 
+		const tvec3<T, P>& v2, 
+		const tvec3<T, P>& v3)
 	{
-		return detail::tmat3x3<T, P>(v1, v2, v3);
+		return tmat3x3<T, P>(v1, v2, v3);
 	}
 
 	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER detail::tmat3x3<T, P> colMajor3(
-		const detail::tmat3x3<T, P>& m)
+	GLM_FUNC_QUALIFIER tmat3x3<T, P> colMajor3(
+		const tmat3x3<T, P>& m)
 	{
-		return detail::tmat3x3<T, P>(m);
+		return tmat3x3<T, P>(m);
 	}
 
 	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T, P> colMajor4(
-		const detail::tvec4<T, P>& v1, 
-		const detail::tvec4<T, P>& v2, 
-		const detail::tvec4<T, P>& v3, 
-		const detail::tvec4<T, P>& v4)
+	GLM_FUNC_QUALIFIER tmat4x4<T, P> colMajor4(
+		const tvec4<T, P>& v1, 
+		const tvec4<T, P>& v2, 
+		const tvec4<T, P>& v3, 
+		const tvec4<T, P>& v4)
 	{
-		return detail::tmat4x4<T, P>(v1, v2, v3, v4);
+		return tmat4x4<T, P>(v1, v2, v3, v4);
 	}
 
 	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T, P> colMajor4(
-		const detail::tmat4x4<T, P>& m)
+	GLM_FUNC_QUALIFIER tmat4x4<T, P> colMajor4(
+		const tmat4x4<T, P>& m)
 	{
-		return detail::tmat4x4<T, P>(m);
+		return tmat4x4<T, P>(m);
 	}
 }//namespace glm

glm/gtx/matrix_operation.hpp

@@ -52,56 +52,56 @@ namespace glm
 	//! Build a diagonal matrix.
 	//! From GLM_GTX_matrix_operation extension.
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tmat2x2<T, P> diagonal2x2(
-		detail::tvec2<T, P> const & v);
+	GLM_FUNC_DECL tmat2x2<T, P> diagonal2x2(
+		tvec2<T, P> const & v);
 
 	//! Build a diagonal matrix.
 	//! From GLM_GTX_matrix_operation extension.
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tmat2x3<T, P> diagonal2x3(
-		detail::tvec2<T, P> const & v);
+	GLM_FUNC_DECL tmat2x3<T, P> diagonal2x3(
+		tvec2<T, P> const & v);
 
 	//! Build a diagonal matrix.
 	//! From GLM_GTX_matrix_operation extension.
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tmat2x4<T, P> diagonal2x4(
-		detail::tvec2<T, P> const & v);
+	GLM_FUNC_DECL tmat2x4<T, P> diagonal2x4(
+		tvec2<T, P> const & v);
 
 	//! Build a diagonal matrix.
 	//! From GLM_GTX_matrix_operation extension.
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tmat3x2<T, P> diagonal3x2(
-		detail::tvec2<T, P> const & v);
+	GLM_FUNC_DECL tmat3x2<T, P> diagonal3x2(
+		tvec2<T, P> const & v);
 
 	//! Build a diagonal matrix.
 	//! From GLM_GTX_matrix_operation extension.
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tmat3x3<T, P> diagonal3x3(
-		detail::tvec3<T, P> const & v);
+	GLM_FUNC_DECL tmat3x3<T, P> diagonal3x3(
+		tvec3<T, P> const & v);
 
 	//! Build a diagonal matrix.
 	//! From GLM_GTX_matrix_operation extension.
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tmat3x4<T, P> diagonal3x4(
-		detail::tvec3<T, P> const & v);
+	GLM_FUNC_DECL tmat3x4<T, P> diagonal3x4(
+		tvec3<T, P> const & v);
 
 	//! Build a diagonal matrix.
 	//! From GLM_GTX_matrix_operation extension.
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tmat4x2<T, P> diagonal4x2(
-		detail::tvec2<T, P> const & v);
+	GLM_FUNC_DECL tmat4x2<T, P> diagonal4x2(
+		tvec2<T, P> const & v);
 
 	//! Build a diagonal matrix.
 	//! From GLM_GTX_matrix_operation extension.
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tmat4x3<T, P> diagonal4x3(
-		detail::tvec3<T, P> const & v);
+	GLM_FUNC_DECL tmat4x3<T, P> diagonal4x3(
+		tvec3<T, P> const & v);
 
 	//! Build a diagonal matrix.
 	//! From GLM_GTX_matrix_operation extension.
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tmat4x4<T, P> diagonal4x4(
-		detail::tvec4<T, P> const & v);
+	GLM_FUNC_DECL tmat4x4<T, P> diagonal4x4(
+		tvec4<T, P> const & v);
 
 	/// @}
 }//namespace glm

glm/gtx/matrix_operation.inl

@@ -10,60 +10,60 @@
 namespace glm
 {
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tmat2x2<T, P> diagonal2x2
+	GLM_FUNC_QUALIFIER tmat2x2<T, P> diagonal2x2
 	(
-		detail::tvec2<T, P> const & v
+		tvec2<T, P> const & v
 	)
 	{
-		detail::tmat2x2<T, P> Result(static_cast<T>(1));
+		tmat2x2<T, P> Result(static_cast<T>(1));
 		Result[0][0] = v[0];
 		Result[1][1] = v[1];
 		return Result;
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tmat2x3<T, P> diagonal2x3
+	GLM_FUNC_QUALIFIER tmat2x3<T, P> diagonal2x3
 	(
-		detail::tvec2<T, P> const & v
+		tvec2<T, P> const & v
 	)
 	{
-		detail::tmat2x3<T, P> Result(static_cast<T>(1));
+		tmat2x3<T, P> Result(static_cast<T>(1));
 		Result[0][0] = v[0];
 		Result[1][1] = v[1];
 		return Result;
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tmat2x4<T, P> diagonal2x4
+	GLM_FUNC_QUALIFIER tmat2x4<T, P> diagonal2x4
 	(
-		detail::tvec2<T, P> const & v
+		tvec2<T, P> const & v
 	)
 	{
-		detail::tmat2x4<T, P> Result(static_cast<T>(1));
+		tmat2x4<T, P> Result(static_cast<T>(1));
 		Result[0][0] = v[0];
 		Result[1][1] = v[1];
 		return Result;
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tmat3x2<T, P> diagonal3x2
+	GLM_FUNC_QUALIFIER tmat3x2<T, P> diagonal3x2
 	(
-		detail::tvec2<T, P> const & v
+		tvec2<T, P> const & v
 	)
 	{
-		detail::tmat3x2<T, P> Result(static_cast<T>(1));
+		tmat3x2<T, P> Result(static_cast<T>(1));
 		Result[0][0] = v[0];
 		Result[1][1] = v[1];
 		return Result;
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tmat3x3<T, P> diagonal3x3
+	GLM_FUNC_QUALIFIER tmat3x3<T, P> diagonal3x3
 	(
-		detail::tvec3<T, P> const & v
+		tvec3<T, P> const & v
 	)
 	{
-		detail::tmat3x3<T, P> Result(static_cast<T>(1));
+		tmat3x3<T, P> Result(static_cast<T>(1));
 		Result[0][0] = v[0];
 		Result[1][1] = v[1];
 		Result[2][2] = v[2];
@@ -71,12 +71,12 @@ namespace glm
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tmat3x4<T, P> diagonal3x4
+	GLM_FUNC_QUALIFIER tmat3x4<T, P> diagonal3x4
 	(
-		detail::tvec3<T, P> const & v
+		tvec3<T, P> const & v
 	)
 	{
-		detail::tmat3x4<T, P> Result(static_cast<T>(1));
+		tmat3x4<T, P> Result(static_cast<T>(1));
 		Result[0][0] = v[0];
 		Result[1][1] = v[1];
 		Result[2][2] = v[2];
@@ -84,12 +84,12 @@ namespace glm
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T, P> diagonal4x4
+	GLM_FUNC_QUALIFIER tmat4x4<T, P> diagonal4x4
 	(
-		detail::tvec4<T, P> const & v
+		tvec4<T, P> const & v
 	)
 	{
-		detail::tmat4x4<T, P> Result(static_cast<T>(1));
+		tmat4x4<T, P> Result(static_cast<T>(1));
 		Result[0][0] = v[0];
 		Result[1][1] = v[1];
 		Result[2][2] = v[2];
@@ -98,12 +98,12 @@ namespace glm
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tmat4x3<T, P> diagonal4x3
+	GLM_FUNC_QUALIFIER tmat4x3<T, P> diagonal4x3
 	(
-		detail::tvec3<T, P> const & v
+		tvec3<T, P> const & v
 	)
 	{
-		detail::tmat4x3<T, P> Result(static_cast<T>(1));
+		tmat4x3<T, P> Result(static_cast<T>(1));
 		Result[0][0] = v[0];
 		Result[1][1] = v[1];
 		Result[2][2] = v[2];
@@ -111,12 +111,12 @@ namespace glm
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tmat4x2<T, P> diagonal4x2
+	GLM_FUNC_QUALIFIER tmat4x2<T, P> diagonal4x2
 	(
-		detail::tvec2<T, P> const & v
+		tvec2<T, P> const & v
 	)
 	{
-		detail::tmat4x2<T, P> Result(static_cast<T>(1));
+		tmat4x2<T, P> Result(static_cast<T>(1));
 		Result[0][0] = v[0];
 		Result[1][1] = v[1];
 		return Result;		

glm/gtx/matrix_query.hpp

@@ -55,17 +55,17 @@ namespace glm
 	/// Return whether a matrix a null matrix.
 	/// From GLM_GTX_matrix_query extension.
 	template<typename T, precision P>
-	GLM_FUNC_DECL bool isNull(detail::tmat2x2<T, P> const & m, T const & epsilon);
+	GLM_FUNC_DECL bool isNull(tmat2x2<T, P> const & m, T const & epsilon);
 		
 	/// Return whether a matrix a null matrix.
 	/// From GLM_GTX_matrix_query extension.
 	template<typename T, precision P>
-	GLM_FUNC_DECL bool isNull(detail::tmat3x3<T, P> const & m, T const & epsilon);
+	GLM_FUNC_DECL bool isNull(tmat3x3<T, P> const & m, T const & epsilon);
 		
 	/// Return whether a matrix is a null matrix.
 	/// From GLM_GTX_matrix_query extension.
 	template<typename T, precision P>
-	GLM_FUNC_DECL bool isNull(detail::tmat4x4<T, P> const & m, T const & epsilon);
+	GLM_FUNC_DECL bool isNull(tmat4x4<T, P> const & m, T const & epsilon);
 			
 	/// Return whether a matrix is an identity matrix.
 	/// From GLM_GTX_matrix_query extension.
@@ -75,17 +75,17 @@ namespace glm
 	/// Return whether a matrix is a normalized matrix.
 	/// From GLM_GTX_matrix_query extension.
 	template<typename T, precision P>
-	GLM_FUNC_DECL bool isNormalized(detail::tmat2x2<T, P> const & m, T const & epsilon);
+	GLM_FUNC_DECL bool isNormalized(tmat2x2<T, P> const & m, T const & epsilon);
 
 	/// Return whether a matrix is a normalized matrix.
 	/// From GLM_GTX_matrix_query extension.
 	template<typename T, precision P>
-	GLM_FUNC_DECL bool isNormalized(detail::tmat3x3<T, P> const & m, T const & epsilon);
+	GLM_FUNC_DECL bool isNormalized(tmat3x3<T, P> const & m, T const & epsilon);
 
 	/// Return whether a matrix is a normalized matrix.
 	/// From GLM_GTX_matrix_query extension.
 	template<typename T, precision P>
-	GLM_FUNC_DECL bool isNormalized(detail::tmat4x4<T, P> const & m, T const & epsilon);
+	GLM_FUNC_DECL bool isNormalized(tmat4x4<T, P> const & m, T const & epsilon);
 
 	/// Return whether a matrix is an orthonormalized matrix.
 	/// From GLM_GTX_matrix_query extension.

glm/gtx/matrix_query.inl

@@ -13,7 +13,7 @@
 namespace glm
 {
 	template<typename T, precision P>
-	GLM_FUNC_QUALIFIER bool isNull(detail::tmat2x2<T, P> const & m, T const & epsilon)
+	GLM_FUNC_QUALIFIER bool isNull(tmat2x2<T, P> const & m, T const & epsilon)
 	{
 		bool result = true;
 		for(length_t i = 0; result && i < 2 ; ++i)
@@ -22,7 +22,7 @@ namespace glm
 	}
 
 	template<typename T, precision P>
-	GLM_FUNC_QUALIFIER bool isNull(detail::tmat3x3<T, P> const & m, T const & epsilon)
+	GLM_FUNC_QUALIFIER bool isNull(tmat3x3<T, P> const & m, T const & epsilon)
 	{
 		bool result = true;
 		for(length_t i = 0; result && i < 3 ; ++i)
@@ -31,7 +31,7 @@ namespace glm
 	}
 
 	template<typename T, precision P>
-	GLM_FUNC_QUALIFIER bool isNull(detail::tmat4x4<T, P> const & m, T const & epsilon)
+	GLM_FUNC_QUALIFIER bool isNull(tmat4x4<T, P> const & m, T const & epsilon)
 	{
 		bool result = true;
 		for(length_t i = 0; result && i < 4 ; ++i)
@@ -56,14 +56,14 @@ namespace glm
 	}
 
 	template<typename T, precision P>
-	GLM_FUNC_QUALIFIER bool isNormalized(detail::tmat2x2<T, P> const & m, T const & epsilon)
+	GLM_FUNC_QUALIFIER bool isNormalized(tmat2x2<T, P> const & m, T const & epsilon)
 	{
 		bool result(true);
 		for(length_t i(0); result && i < m.length(); ++i)
 			result = isNormalized(m[i], epsilon);
 		for(length_t i(0); result && i < m.length(); ++i)
 		{
-			typename detail::tmat2x2<T, P>::col_type v;
+			typename tmat2x2<T, P>::col_type v;
 			for(length_t j(0); j < m.length(); ++j)
 				v[j] = m[j][i];
 			result = isNormalized(v, epsilon);
@@ -72,14 +72,14 @@ namespace glm
 	}
 
 	template<typename T, precision P>
-	GLM_FUNC_QUALIFIER bool isNormalized(detail::tmat3x3<T, P> const & m, T const & epsilon)
+	GLM_FUNC_QUALIFIER bool isNormalized(tmat3x3<T, P> const & m, T const & epsilon)
 	{
 		bool result(true);
 		for(length_t i(0); result && i < m.length(); ++i)
 			result = isNormalized(m[i], epsilon);
 		for(length_t i(0); result && i < m.length(); ++i)
 		{
-			typename detail::tmat3x3<T, P>::col_type v;
+			typename tmat3x3<T, P>::col_type v;
 			for(length_t j(0); j < m.length(); ++j)
 				v[j] = m[j][i];
 			result = isNormalized(v, epsilon);
@@ -88,14 +88,14 @@ namespace glm
 	}
 
 	template<typename T, precision P>
-	GLM_FUNC_QUALIFIER bool isNormalized(detail::tmat4x4<T, P> const & m, T const & epsilon)
+	GLM_FUNC_QUALIFIER bool isNormalized(tmat4x4<T, P> const & m, T const & epsilon)
 	{
 		bool result(true);
 		for(length_t i(0); result && i < m.length(); ++i)
 			result = isNormalized(m[i], epsilon);
 		for(length_t i(0); result && i < m.length(); ++i)
 		{
-			typename detail::tmat4x4<T, P>::col_type v;
+			typename tmat4x4<T, P>::col_type v;
 			for(length_t j(0); j < m.length(); ++j)
 				v[j] = m[j][i];
 			result = isNormalized(v, epsilon);

glm/gtx/matrix_transform_2d.hpp

@@ -56,17 +56,17 @@ namespace glm
 	/// @param m Input matrix multiplied by this translation matrix.
 	/// @param v Coordinates of a translation vector.		
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tmat3x3<T, P> translate(
-		detail::tmat3x3<T, P> const & m,
-		detail::tvec2<T, P> const & v);
+	GLM_FUNC_QUALIFIER tmat3x3<T, P> translate(
+		tmat3x3<T, P> const & m,
+		tvec2<T, P> const & v);
 
 	/// Builds a rotation 3 * 3 matrix created from an angle. 
 	///
 	/// @param m Input matrix multiplied by this translation matrix.
 	/// @param angle Rotation angle expressed in radians if GLM_FORCE_RADIANS is defined or degrees otherwise.
 	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER detail::tmat3x3<T, P> rotate(
-		detail::tmat3x3<T, P> const & m,
+	GLM_FUNC_QUALIFIER tmat3x3<T, P> rotate(
+		tmat3x3<T, P> const & m,
 		T const & angle);
 
 	/// Builds a scale 3 * 3 matrix created from a vector of 2 components.
@@ -74,17 +74,17 @@ namespace glm
 	/// @param m Input matrix multiplied by this translation matrix.
 	/// @param v Coordinates of a scale vector.		
 	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER detail::tmat3x3<T, P> scale(
-		detail::tmat3x3<T, P> const & m,
-		detail::tvec2<T, P> const & v);
+	GLM_FUNC_QUALIFIER tmat3x3<T, P> scale(
+		tmat3x3<T, P> const & m,
+		tvec2<T, P> const & v);
 
 	/// Builds an horizontal (parallel to the x axis) shear 3 * 3 matrix. 
 	///
 	/// @param m Input matrix multiplied by this translation matrix.
 	/// @param y Shear factor.
 	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER detail::tmat3x3<T, P> shearX(
-		detail::tmat3x3<T, P> const & m,
+	GLM_FUNC_QUALIFIER tmat3x3<T, P> shearX(
+		tmat3x3<T, P> const & m,
 		T const & y);
 
 	/// Builds a vertical (parallel to the y axis) shear 3 * 3 matrix. 
@@ -92,8 +92,8 @@ namespace glm
 	/// @param m Input matrix multiplied by this translation matrix.
 	/// @param x Shear factor.
 	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER detail::tmat3x3<T, P> shearY(
-		detail::tmat3x3<T, P> const & m,
+	GLM_FUNC_QUALIFIER tmat3x3<T, P> shearY(
+		tmat3x3<T, P> const & m,
 		T const & x);
 
 	/// @}

glm/gtx/matrix_transform_2d.inl

@@ -32,26 +32,26 @@ namespace glm
 {
 	
 	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER detail::tmat3x3<T, P> translate(
-		detail::tmat3x3<T, P> const & m,
-		detail::tvec2<T, P> const & v)
+	GLM_FUNC_QUALIFIER tmat3x3<T, P> translate(
+		tmat3x3<T, P> const & m,
+		tvec2<T, P> const & v)
 	{
-		detail::tmat3x3<T, P> Result(m);
+		tmat3x3<T, P> Result(m);
 		Result[2] = m[0] * v[0] + m[1] * v[1] + m[2];
 		return Result;
 	}
 
 
 	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER detail::tmat3x3<T, P> rotate(
-		detail::tmat3x3<T, P> const & m,
+	GLM_FUNC_QUALIFIER tmat3x3<T, P> rotate(
+		tmat3x3<T, P> const & m,
 		T const & angle)
 	{
 		T const a = angle;
 		T const c = cos(a);
 		T const s = sin(a);
 
-		detail::tmat3x3<T, P> Result(detail::tmat3x3<T, P>::_null);
+		tmat3x3<T, P> Result(tmat3x3<T, P>::_null);
 		Result[0] = m[0] * c + m[1] * s;
 		Result[1] = m[0] * -s + m[1] * c;
 		Result[2] = m[2];
@@ -59,11 +59,11 @@ namespace glm
 	}
 
 	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER detail::tmat3x3<T, P> scale(
-		detail::tmat3x3<T, P> const & m,
-		detail::tvec2<T, P> const & v)
+	GLM_FUNC_QUALIFIER tmat3x3<T, P> scale(
+		tmat3x3<T, P> const & m,
+		tvec2<T, P> const & v)
 	{
-		detail::tmat3x3<T, P> Result(detail::tmat3x3<T, P>::_null);
+		tmat3x3<T, P> Result(tmat3x3<T, P>::_null);
 		Result[0] = m[0] * v[0];
 		Result[1] = m[1] * v[1];
 		Result[2] = m[2];
@@ -71,21 +71,21 @@ namespace glm
 	}
 
 	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER detail::tmat3x3<T, P> shearX(
-		detail::tmat3x3<T, P> const & m,
+	GLM_FUNC_QUALIFIER tmat3x3<T, P> shearX(
+		tmat3x3<T, P> const & m,
 		T const & y)
 	{
-		detail::tmat3x3<T, P> Result();
+		tmat3x3<T, P> Result();
 		Result[0][1] = y;
 		return m * Result;
 	}
 
 	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER detail::tmat3x3<T, P> shearY(
-		detail::tmat3x3<T, P> const & m,
+	GLM_FUNC_QUALIFIER tmat3x3<T, P> shearY(
+		tmat3x3<T, P> const & m,
 		T const & x)
 	{
-		detail::tmat3x3<T, P> Result();
+		tmat3x3<T, P> Result();
 		Result[1][0] = x;
 		return m * Result;
 	}

glm/gtx/mixed_product.hpp

@@ -52,9 +52,9 @@ namespace glm
 	/// @brief Mixed product of 3 vectors (from GLM_GTX_mixed_product extension)
 	template <typename T, precision P> 
 	GLM_FUNC_DECL T mixedProduct(
-		detail::tvec3<T, P> const & v1, 
-		detail::tvec3<T, P> const & v2, 
-		detail::tvec3<T, P> const & v3);
+		tvec3<T, P> const & v1, 
+		tvec3<T, P> const & v2, 
+		tvec3<T, P> const & v3);
 
 	/// @}
 }// namespace glm

glm/gtx/mixed_product.inl

@@ -12,9 +12,9 @@ namespace glm
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER T mixedProduct
 	(
-		detail::tvec3<T, P> const & v1,
-		detail::tvec3<T, P> const & v2,
-		detail::tvec3<T, P> const & v3
+		tvec3<T, P> const & v1,
+		tvec3<T, P> const & v2,
+		tvec3<T, P> const & v3
 	)
 	{
 		return dot(cross(v1, v2), v3);

glm/gtx/norm.hpp

@@ -81,41 +81,41 @@ namespace glm
 	//! From GLM_GTX_norm extension.
 	template <typename T, precision P>
 	GLM_FUNC_DECL T l1Norm(
-		detail::tvec3<T, P> const & x,
-		detail::tvec3<T, P> const & y);
+		tvec3<T, P> const & x,
+		tvec3<T, P> const & y);
 		
 	//! Returns the L1 norm of v.
 	//! From GLM_GTX_norm extension.
 	template <typename T, precision P>
 	GLM_FUNC_DECL T l1Norm(
-		detail::tvec3<T, P> const & v);
+		tvec3<T, P> const & v);
 		
 	//! Returns the L2 norm between x and y.
 	//! From GLM_GTX_norm extension.
 	template <typename T, precision P>
 	GLM_FUNC_DECL T l2Norm(
-		detail::tvec3<T, P> const & x,
-		detail::tvec3<T, P> const & y);
+		tvec3<T, P> const & x,
+		tvec3<T, P> const & y);
 		
 	//! Returns the L2 norm of v.
 	//! From GLM_GTX_norm extension.
 	template <typename T, precision P>
 	GLM_FUNC_DECL T l2Norm(
-		detail::tvec3<T, P> const & x);
+		tvec3<T, P> const & x);
 		
 	//! Returns the L norm between x and y.
 	//! From GLM_GTX_norm extension.
 	template <typename T, precision P>
 	GLM_FUNC_DECL T lxNorm(
-		detail::tvec3<T, P> const & x,
-		detail::tvec3<T, P> const & y,
+		tvec3<T, P> const & x,
+		tvec3<T, P> const & y,
 		unsigned int Depth);
 
 	//! Returns the L norm of v.
 	//! From GLM_GTX_norm extension.
 	template <typename T, precision P>
 	GLM_FUNC_DECL T lxNorm(
-		detail::tvec3<T, P> const & x,
+		tvec3<T, P> const & x,
 		unsigned int Depth);
 
 	/// @}