From 2877f4eda3d1b0c7431039e3142ecf1a282a34b1 Mon Sep 17 00:00:00 2001
From: LaG1924 <12997935+LaG1924@users.noreply.github.com>
Date: Tue, 21 Aug 2018 20:40:38 +0500
Subject: Update glm to 0.9.9.0

---
 external/include/glm/detail/func_trigonometric.inl | 106 ++++++++++-----------
 1 file changed, 53 insertions(+), 53 deletions(-)

(limited to 'external/include/glm/detail/func_trigonometric.inl')

diff --git a/external/include/glm/detail/func_trigonometric.inl b/external/include/glm/detail/func_trigonometric.inl
index 2986673..291fccd 100644
--- a/external/include/glm/detail/func_trigonometric.inl
+++ b/external/include/glm/detail/func_trigonometric.inl
@@ -8,7 +8,7 @@
 namespace glm
 {
 	// radians
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType radians(genType degrees)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'radians' only accept floating-point input");
@@ -16,14 +16,14 @@ namespace glm
 		return degrees * static_cast<genType>(0.01745329251994329576923690768489);
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vecType<T, P> radians(vecType<T, P> const & v)
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<L, T, Q> radians(vec<L, T, Q> const& v)
 	{
-		return detail::functor1<T, T, P, vecType>::call(radians, v);
+		return detail::functor1<L, T, T, Q>::call(radians, v);
 	}
-	
+
 	// degrees
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType degrees(genType radians)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'degrees' only accept floating-point input");
@@ -31,59 +31,59 @@ namespace glm
 		return radians * static_cast<genType>(57.295779513082320876798154814105);
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vecType<T, P> degrees(vecType<T, P> const & v)
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<L, T, Q> degrees(vec<L, T, Q> const& v)
 	{
-		return detail::functor1<T, T, P, vecType>::call(degrees, v);
+		return detail::functor1<L, T, T, Q>::call(degrees, v);
 	}
 
 	// sin
 	using ::std::sin;
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> sin(vecType<T, P> const & v)
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> sin(vec<L, T, Q> const& v)
 	{
-		return detail::functor1<T, T, P, vecType>::call(sin, v);
+		return detail::functor1<L, T, T, Q>::call(sin, v);
 	}
 
 	// cos
 	using std::cos;
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> cos(vecType<T, P> const & v)
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> cos(vec<L, T, Q> const& v)
 	{
-		return detail::functor1<T, T, P, vecType>::call(cos, v);
+		return detail::functor1<L, T, T, Q>::call(cos, v);
 	}
 
 	// tan
 	using std::tan;
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> tan(vecType<T, P> const & v)
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> tan(vec<L, T, Q> const& v)
 	{
-		return detail::functor1<T, T, P, vecType>::call(tan, v);
+		return detail::functor1<L, T, T, Q>::call(tan, v);
 	}
 
 	// asin
 	using std::asin;
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> asin(vecType<T, P> const & v)
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> asin(vec<L, T, Q> const& v)
 	{
-		return detail::functor1<T, T, P, vecType>::call(asin, v);
+		return detail::functor1<L, T, T, Q>::call(asin, v);
 	}
 
 	// acos
 	using std::acos;
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> acos(vecType<T, P> const & v)
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> acos(vec<L, T, Q> const& v)
 	{
-		return detail::functor1<T, T, P, vecType>::call(acos, v);
+		return detail::functor1<L, T, T, Q>::call(acos, v);
 	}
 
 	// atan
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER genType atan(genType y, genType x)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'atan' only accept floating-point input");
@@ -91,52 +91,52 @@ namespace glm
 		return ::std::atan2(y, x);
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> atan(vecType<T, P> const & a, vecType<T, P> const & b)
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> atan(vec<L, T, Q> const& a, vec<L, T, Q> const& b)
 	{
-		return detail::functor2<T, P, vecType>::call(::std::atan2, a, b);
+		return detail::functor2<L, T, Q>::call(::std::atan2, a, b);
 	}
 
 	using std::atan;
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> atan(vecType<T, P> const & v)
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> atan(vec<L, T, Q> const& v)
 	{
-		return detail::functor1<T, T, P, vecType>::call(atan, v);
+		return detail::functor1<L, T, T, Q>::call(atan, v);
 	}
 
 	// sinh
 	using std::sinh;
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> sinh(vecType<T, P> const & v)
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> sinh(vec<L, T, Q> const& v)
 	{
-		return detail::functor1<T, T, P, vecType>::call(sinh, v);
+		return detail::functor1<L, T, T, Q>::call(sinh, v);
 	}
 
 	// cosh
 	using std::cosh;
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> cosh(vecType<T, P> const & v)
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> cosh(vec<L, T, Q> const& v)
 	{
-		return detail::functor1<T, T, P, vecType>::call(cosh, v);
+		return detail::functor1<L, T, T, Q>::call(cosh, v);
 	}
 
 	// tanh
 	using std::tanh;
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> tanh(vecType<T, P> const & v)
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> tanh(vec<L, T, Q> const& v)
 	{
-		return detail::functor1<T, T, P, vecType>::call(tanh, v);
+		return detail::functor1<L, T, T, Q>::call(tanh, v);
 	}
 
 	// asinh
 #	if GLM_HAS_CXX11_STL
 		using std::asinh;
 #	else
-		template <typename genType>
+		template<typename genType>
 		GLM_FUNC_QUALIFIER genType asinh(genType x)
 		{
 			GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'asinh' only accept floating-point input");
@@ -145,17 +145,17 @@ namespace glm
 		}
 #	endif
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> asinh(vecType<T, P> const & v)
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> asinh(vec<L, T, Q> const& v)
 	{
-		return detail::functor1<T, T, P, vecType>::call(asinh, v);
+		return detail::functor1<L, T, T, Q>::call(asinh, v);
 	}
 
 	// acosh
 #	if GLM_HAS_CXX11_STL
 		using std::acosh;
 #	else
-		template <typename genType> 
+		template<typename genType>
 		GLM_FUNC_QUALIFIER genType acosh(genType x)
 		{
 			GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'acosh' only accept floating-point input");
@@ -166,31 +166,31 @@ namespace glm
 		}
 #	endif
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> acosh(vecType<T, P> const & v)
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> acosh(vec<L, T, Q> const& v)
 	{
-		return detail::functor1<T, T, P, vecType>::call(acosh, v);
+		return detail::functor1<L, T, T, Q>::call(acosh, v);
 	}
 
 	// atanh
 #	if GLM_HAS_CXX11_STL
 		using std::atanh;
 #	else
-		template <typename genType>
+		template<typename genType>
 		GLM_FUNC_QUALIFIER genType atanh(genType x)
 		{
 			GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'atanh' only accept floating-point input");
-		
+
 			if(std::abs(x) >= static_cast<genType>(1))
 				return 0;
 			return static_cast<genType>(0.5) * log((static_cast<genType>(1) + x) / (static_cast<genType>(1) - x));
 		}
 #	endif
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> atanh(vecType<T, P> const & v)
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> atanh(vec<L, T, Q> const& v)
 	{
-		return detail::functor1<T, T, P, vecType>::call(atanh, v);
+		return detail::functor1<L, T, T, Q>::call(atanh, v);
 	}
 }//namespace glm
 
-- 
cgit v1.2.3