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_exponential.inl | 96 +++++++++++++-----------
 1 file changed, 51 insertions(+), 45 deletions(-)

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

diff --git a/external/include/glm/detail/func_exponential.inl b/external/include/glm/detail/func_exponential.inl
index 227fe91..b962674 100644
--- a/external/include/glm/detail/func_exponential.inl
+++ b/external/include/glm/detail/func_exponential.inl
@@ -1,7 +1,7 @@
 /// @ref core
 /// @file glm/detail/func_exponential.inl
 
-#include "func_vector_relational.hpp"
+#include "../vector_relational.hpp"
 #include "_vectorize.hpp"
 #include <limits>
 #include <cmath>
@@ -13,50 +13,52 @@ namespace detail
 #	if GLM_HAS_CXX11_STL
 		using std::log2;
 #	else
-		template <typename genType>
+		template<typename genType>
 		genType log2(genType Value)
 		{
 			return std::log(Value) * static_cast<genType>(1.4426950408889634073599246810019);
 		}
 #	endif
 
-	template <typename T, precision P, template <class, precision> class vecType, bool isFloat, bool Aligned>
+	template<length_t L, typename T, qualifier Q, bool isFloat, bool Aligned>
 	struct compute_log2
 	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & vec)
+		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& v)
 		{
-			return detail::functor1<T, T, P, vecType>::call(log2, vec);
+			GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'log2' only accept floating-point inputs. Include <glm/gtc/integer.hpp> for integer inputs.");
+
+			return detail::functor1<L, T, T, Q>::call(log2, v);
 		}
 	};
 
-	template <template <class, precision> class vecType, typename T, precision P, bool Aligned>
+	template<length_t L, typename T, qualifier Q, bool Aligned>
 	struct compute_sqrt
 	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x)
+		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& x)
 		{
-			return detail::functor1<T, T, P, vecType>::call(std::sqrt, x);
+			return detail::functor1<L, T, T, Q>::call(std::sqrt, x);
 		}
 	};
 
-	template <template <class, precision> class vecType, typename T, precision P, bool Aligned>
+	template<length_t L, typename T, qualifier Q, bool Aligned>
 	struct compute_inversesqrt
 	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x)
+		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& x)
 		{
 			return static_cast<T>(1) / sqrt(x);
 		}
 	};
-		
-	template <template <class, precision> class vecType, bool Aligned>
-	struct compute_inversesqrt<vecType, float, lowp, Aligned>
+
+	template<length_t L, bool Aligned>
+	struct compute_inversesqrt<L, float, lowp, Aligned>
 	{
-		GLM_FUNC_QUALIFIER static vecType<float, lowp> call(vecType<float, lowp> const & x)
+		GLM_FUNC_QUALIFIER static vec<L, float, lowp> call(vec<L, float, lowp> const& x)
 		{
-			vecType<float, lowp> tmp(x);
-			vecType<float, lowp> xhalf(tmp * 0.5f);
-			vecType<uint, lowp>* p = reinterpret_cast<vecType<uint, lowp>*>(const_cast<vecType<float, lowp>*>(&x));
-			vecType<uint, lowp> i = vecType<uint, lowp>(0x5f375a86) - (*p >> vecType<uint, lowp>(1));
-			vecType<float, lowp>* ptmp = reinterpret_cast<vecType<float, lowp>*>(&i);
+			vec<L, float, lowp> tmp(x);
+			vec<L, float, lowp> xhalf(tmp * 0.5f);
+			vec<L, uint, lowp>* p = reinterpret_cast<vec<L, uint, lowp>*>(const_cast<vec<L, float, lowp>*>(&x));
+			vec<L, uint, lowp> i = vec<L, uint, lowp>(0x5f375a86) - (*p >> vec<L, uint, lowp>(1));
+			vec<L, float, lowp>* ptmp = reinterpret_cast<vec<L, float, lowp>*>(&i);
 			tmp = *ptmp;
 			tmp = tmp * (1.5f - xhalf * tmp * tmp);
 			return tmp;
@@ -66,77 +68,81 @@ namespace detail
 
 	// pow
 	using std::pow;
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> pow(vecType<T, P> const & base, vecType<T, P> const & exponent)
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> pow(vec<L, T, Q> const& base, vec<L, T, Q> const& exponent)
 	{
-		return detail::functor2<T, P, vecType>::call(pow, base, exponent);
+		return detail::functor2<L, T, Q>::call(pow, base, exponent);
 	}
 
 	// exp
 	using std::exp;
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> exp(vecType<T, P> const & x)
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> exp(vec<L, T, Q> const& x)
 	{
-		return detail::functor1<T, T, P, vecType>::call(exp, x);
+		return detail::functor1<L, T, T, Q>::call(exp, x);
 	}
 
 	// log
 	using std::log;
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> log(vecType<T, P> const & x)
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> log(vec<L, T, Q> const& x)
 	{
-		return detail::functor1<T, T, P, vecType>::call(log, x);
+		return detail::functor1<L, T, T, Q>::call(log, x);
 	}
 
+#   if GLM_HAS_CXX11_STL
+    using std::exp2;
+#   else
 	//exp2, ln2 = 0.69314718055994530941723212145818f
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER genType exp2(genType x)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'exp2' only accept floating-point inputs");
 
 		return std::exp(static_cast<genType>(0.69314718055994530941723212145818) * x);
 	}
+#   endif
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> exp2(vecType<T, P> const & x)
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> exp2(vec<L, T, Q> const& x)
 	{
-		return detail::functor1<T, T, P, vecType>::call(exp2, x);
+		return detail::functor1<L, T, T, Q>::call(exp2, x);
 	}
 
 	// log2, ln2 = 0.69314718055994530941723212145818f
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER genType log2(genType x)
 	{
-		return log2(tvec1<genType>(x)).x;
+		return log2(vec<1, genType>(x)).x;
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> log2(vecType<T, P> const & x)
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> log2(vec<L, T, Q> const& x)
 	{
-		return detail::compute_log2<T, P, vecType, std::numeric_limits<T>::is_iec559, detail::is_aligned<P>::value>::call(x);
+		return detail::compute_log2<L, T, Q, std::numeric_limits<T>::is_iec559, detail::is_aligned<Q>::value>::call(x);
 	}
 
 	// sqrt
 	using std::sqrt;
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> sqrt(vecType<T, P> const & x)
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> sqrt(vec<L, T, Q> const& x)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'sqrt' only accept floating-point inputs");
-		return detail::compute_sqrt<vecType, T, P, detail::is_aligned<P>::value>::call(x);
+		return detail::compute_sqrt<L, T, Q, detail::is_aligned<Q>::value>::call(x);
 	}
 
 	// inversesqrt
-	template <typename genType>
+	template<typename genType>
 	GLM_FUNC_QUALIFIER genType inversesqrt(genType x)
 	{
 		return static_cast<genType>(1) / sqrt(x);
 	}
-	
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> inversesqrt(vecType<T, P> const & x)
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<L, T, Q> inversesqrt(vec<L, T, Q> const& x)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'inversesqrt' only accept floating-point inputs");
-		return detail::compute_inversesqrt<vecType, T, P, detail::is_aligned<P>::value>::call(x);
+		return detail::compute_inversesqrt<L, T, Q, detail::is_aligned<Q>::value>::call(x);
 	}
 }//namespace glm
 
-- 
cgit v1.2.3