Merge branch '0.9.1' into gtx_ulp

glm/core/intrinsic_matrix.inl

@@ -1005,8 +1005,7 @@ inline void sse_inverse_fast_ps(__m128 const in[4], __m128 out[4])
 	out[3] = _mm_mul_ps(Inv3, Rcp0);
 }
 
-
-void sse_rotate_ps(__m128 const in[4], float Angle, float const v[3], __m128 out[4])
+inline void sse_rotate_ps(__m128 const in[4], float Angle, float const v[3], __m128 out[4])
 {
 	float a = glm::radians(Angle);
     float c = cos(a);
@@ -1076,7 +1075,7 @@ void sse_rotate_ps(__m128 const in[4], float Angle, float const v[3], __m128 out
 	sse_mul_ps(in, Result, out);
 }
 
-void sse_outer_ps(__m128 const & c, __m128 const & r, __m128 out[4])
+inline void sse_outer_ps(__m128 const & c, __m128 const & r, __m128 out[4])
 {
 	out[0] = _mm_mul_ps(c, _mm_shuffle_ps(r, r, _MM_SHUFFLE(0, 0, 0, 0)));
 	out[1] = _mm_mul_ps(c, _mm_shuffle_ps(r, r, _MM_SHUFFLE(1, 1, 1, 1)));

glm/core/type_int.hpp

@@ -88,7 +88,7 @@ namespace glm
 #elif(GLM_PRECISION & GLM_PRECISION_LOWP_INT)
 	typedef precision::lowp_int					int_t;
 #else
-	typedef mediump_int							int_t;
+	typedef precision::mediump_int							int_t;
 #	pragma message("GLM message: Precisson undefined for signed integer number.");
 #endif//GLM_PRECISION
 

glm/core/type_vec4.hpp

@@ -15,7 +15,6 @@
 #include "type_int.hpp"
 #include "type_size.hpp"
 #include "_swizzle.hpp"
-#include "_detail.hpp"
 
 namespace glm
 {

glm/glm.hpp

@@ -12,9 +12,6 @@
 #ifndef glm_glm
 #define glm_glm
 
-//! TODO: to delete
-#define GLMvalType typename genType::value_type
-
 #include <cmath>
 #include <climits>
 #include <cfloat>

glm/gtc/matrix_transform.inl

@@ -144,13 +144,15 @@ namespace matrix_transform
     }
 
 	template <typename valType> 
-	inline detail::tmat4x4<valType> ortho(
+	inline detail::tmat4x4<valType> ortho
+	(
 		valType const & left, 
 		valType const & right, 
 		valType const & bottom, 
 		valType const & top, 
 		valType const & zNear, 
-		valType const & zFar)
+		valType const & zFar
+	)
 	{
 		detail::tmat4x4<valType> Result(1);
 		Result[0][0] = valType(2) / (right - left);
@@ -179,13 +181,15 @@ namespace matrix_transform
 	}
 
 	template <typename valType> 
-	inline detail::tmat4x4<valType> frustum(
+	inline detail::tmat4x4<valType> frustum
+	(
 		valType const & left, 
 		valType const & right, 
 		valType const & bottom, 
 		valType const & top, 
 		valType const & nearVal, 
-		valType const & farVal)
+		valType const & farVal
+	)
 	{
 		detail::tmat4x4<valType> Result(0);
 		Result[0][0] = (valType(2) * nearVal) / (right - left);
@@ -199,11 +203,13 @@ namespace matrix_transform
 	}
 
 	template <typename valType> 
-	inline detail::tmat4x4<valType> perspective(
+	inline detail::tmat4x4<valType> perspective
+	(
 		valType const & fovy, 
 		valType const & aspect, 
 		valType const & zNear, 
-		valType const & zFar)
+		valType const & zFar
+	)
 	{
 		valType range = tan(radians(fovy / valType(2))) * zNear;	
 		valType left = -range * aspect;
@@ -244,10 +250,12 @@ namespace matrix_transform
 	}
 
 	template <typename T> 
-	inline detail::tmat4x4<T> infinitePerspective(
+	inline detail::tmat4x4<T> infinitePerspective
+	(
 		T fovy, 
 		T aspect, 
-		T zNear)
+		T zNear
+	)
 	{
 		T range = tan(radians(fovy / T(2))) * zNear;	
 		T left = -range * aspect;
@@ -265,10 +273,12 @@ namespace matrix_transform
 	}
 
 	template <typename T> 
-	inline detail::tmat4x4<T> tweakedInfinitePerspective(
+	inline detail::tmat4x4<T> tweakedInfinitePerspective
+	(
 		T fovy, 
 		T aspect, 
-		T zNear)
+		T zNear
+	)
 	{
 		T range = tan(radians(fovy / T(2))) * zNear;	
 		T left = -range * aspect;
@@ -286,11 +296,13 @@ namespace matrix_transform
 	}
 
 	template <typename T, typename U>
-	inline detail::tvec3<T> project(
+	inline detail::tvec3<T> project
+	(
 		detail::tvec3<T> const & obj, 
 		detail::tmat4x4<T> const & model, 
 		detail::tmat4x4<T> const & proj, 
-		detail::tvec4<U> const & viewport)
+		detail::tvec4<U> const & viewport
+	)
 	{
 		detail::tvec4<T> tmp = detail::tvec4<T>(obj, T(1));
 		tmp = model * tmp;
@@ -305,11 +317,13 @@ namespace matrix_transform
 	}
 
 	template <typename T, typename U>
-	inline detail::tvec3<T> unProject(
+	inline detail::tvec3<T> unProject
+	(
 		detail::tvec3<T> const & win, 
 		detail::tmat4x4<T> const & model, 
 		detail::tmat4x4<T> const & proj, 
-		detail::tvec4<U> const & viewport)
+		detail::tvec4<U> const & viewport
+	)
 	{
 		detail::tmat4x4<T> inverse = glm::inverse(proj * model);
 
@@ -338,16 +352,23 @@ namespace matrix_transform
 		if(!(delta.x > T(0) && delta.y > T(0))) 
 			return Result; // Error
 
+		detail::tvec3<T> 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, (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));
+		Result = translate(Result, Temp);
 		return scale(Result, T(viewport[2]) / delta.x, T(viewport[3]) / delta.y, T(1));
 	}
 
     template <typename T> 
-    inline detail::tmat4x4<T> lookAt(
-		const detail::tvec3<T>& eye, 
-		const detail::tvec3<T>& center, 
-		const detail::tvec3<T>& up)
+	inline detail::tmat4x4<T> lookAt
+	(
+		detail::tvec3<T> const & eye,
+		detail::tvec3<T> const & center,
+		detail::tvec3<T> const & up
+	)
     {
         detail::tvec3<T> f = normalize(center - eye);
         detail::tvec3<T> u = normalize(up);

glm/gtx/spline.hpp

@@ -36,31 +36,31 @@ namespace glm
 		//! From GLM_GTX_spline extension.
 		template <typename genType> 
 		genType catmullRom(
-			const genType& v1, 
-			const genType& v2, 
-			const genType& v3, 
-			const genType& v4, 
-			const GLMvalType& s);
+			genType const & v1, 
+			genType const & v2, 
+			genType const & v3, 
+			genType const & v4, 
+			typename genType::value_type const & s);
 		
 		//! Return a point from a hermite curve.
 		//! From GLM_GTX_spline extension.
         template <typename genType> 
 		genType hermite(
-			const genType& v1, 
-			const genType& t1, 
-			const genType& v2, 
-			const genType& t2, 
-			const GLMvalType& s);
+			genType const & v1, 
+			genType const & t1, 
+			genType const & v2, 
+			genType const & t2, 
+			typename genType::value_type const & s);
 		
         //! Return a point from a cubic curve. 
 		//! From GLM_GTX_spline extension.
 		template <typename genType> 
 		genType cubic(
-			const genType& v1, 
-			const genType& v2, 
-			const genType& v3, 
-			const genType& v4, 
-			const GLMvalType& s);
+			genType const & v1, 
+			genType const & v2, 
+			genType const & v3, 
+			genType const & v4, 
+			typename genType::value_type const & s);
 
 		///@}
 

glm/gtx/spline.inl

@@ -12,53 +12,59 @@ namespace gtx{
 namespace spline
 {
 	template <typename genType>
-	inline genType catmullRom(
-		const genType& v1, 
-		const genType& v2, 
-		const genType& v3, 
-		const genType& v4, 
-		const GLMvalType& s)
+	inline genType catmullRom
+	(
+		genType const & v1, 
+		genType const & v2, 
+		genType const & v3, 
+		genType const & v4, 
+		typename genType::value_type const & s
+	)
 	{
-		GLMvalType s1 = s;
-		GLMvalType s2 = optimum_pow::pow2(s);
-		GLMvalType s3 = optimum_pow::pow3(s);
+		typename genType::value_type s1 = s;
+		typename genType::value_type s2 = optimum_pow::pow2(s);
+		typename genType::value_type s3 = optimum_pow::pow3(s);
 
-		GLMvalType f1 = -s3 + GLMvalType(2) * s2 - s;
-		GLMvalType f2 = GLMvalType(3) * s3 - GLMvalType(5) * s2 + GLMvalType(2);
-		GLMvalType f3 = GLMvalType(-3) * s3 + GLMvalType(4) * s2 + s;
-		GLMvalType f4 = s3 - s2;
+		typename genType::value_type f1 = -s3 + typename genType::value_type(2) * s2 - s;
+		typename genType::value_type f2 = typename genType::value_type(3) * s3 - typename genType::value_type(5) * s2 + typename genType::value_type(2);
+		typename genType::value_type f3 = typename genType::value_type(-3) * s3 + typename genType::value_type(4) * s2 + s;
+		typename genType::value_type f4 = s3 - s2;
 
-		return (f1 * v1 + f2 * v2 + f3 * v3 + f4 * v4) / GLMvalType(2);
+		return (f1 * v1 + f2 * v2 + f3 * v3 + f4 * v4) / typename genType::value_type(2);
 
 	}
 
 	template <typename genType>
-	inline genType hermite(
-		const genType& v1, 
-		const genType& t1, 
-		const genType& v2, 
-		const genType& t2, 
-		const GLMvalType& s)
+	inline genType hermite
+	(
+		genType const & v1, 
+		genType const & t1, 
+		genType const & v2, 
+		genType const & t2, 
+		typename genType::value_type const & s
+	)
 	{
-		GLMvalType s1 = s;
-		GLMvalType s2 = optimum_pow::pow2(s);
-		GLMvalType s3 = optimum_pow::pow3(s);
+		typename genType::value_type s1 = s;
+		typename genType::value_type s2 = optimum_pow::pow2(s);
+		typename genType::value_type s3 = optimum_pow::pow3(s);
 
-		GLMvalType f1 = GLMvalType(2) * s3 - GLMvalType(3) * s2 + GLMvalType(1);
-		GLMvalType f2 = GLMvalType(-2) * s3 + GLMvalType(3) * s2;
-		GLMvalType f3 = s3 - GLMvalType(2) * s2 + s;
-		GLMvalType f4 = s3 - s2;
+		typename genType::value_type f1 = typename genType::value_type(2) * s3 - typename genType::value_type(3) * s2 + typename genType::value_type(1);
+		typename genType::value_type f2 = typename genType::value_type(-2) * s3 + typename genType::value_type(3) * s2;
+		typename genType::value_type f3 = s3 - typename genType::value_type(2) * s2 + s;
+		typename genType::value_type f4 = s3 - s2;
 
 		return f1 * v1 + f2 * v2 + f3 * t1 + f4 * t2;
 	}
 
 	template <typename genType>
-	inline genType cubic(
-		const genType& v1, 
-		const genType& v2, 
-		const genType& v3, 
-		const genType& v4, 
-		const GLMvalType& s)
+	inline genType cubic
+	(
+		genType const & v1, 
+		genType const & v2, 
+		genType const & v3, 
+		genType const & v4, 
+		typename genType::value_type const & s
+	)
 	{
 		return ((v1 * s + v2) * s + v3) * s + v4;
 	}

glm/gtx/vector_query.hpp

@@ -39,55 +39,55 @@ namespace glm
 		//! From GLM_GTX_vector_query extensions.
 		template <typename genType> 
 		bool areCollinear(
-			const genType & v0, 
-			const genType & v1, 
-			const GLMvalType epsilon = std::numeric_limits<GLMvalType>::epsilon());
+			genType const & v0, 
+			genType const & v1, 
+			typename genType::value_type const & epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
 		
         //! Check if two vectors are opposites.
 		//! From GLM_GTX_vector_query extensions.
 		template <typename genType> 
 		bool areOpposite(
-			const genType & v0, 
-			const genType & v1, 
-			const GLMvalType epsilon = std::numeric_limits<GLMvalType>::epsilon());
+			genType const & v0, 
+			genType const & v1, 
+			typename genType::value_type const & epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
 		
         //! Check if two vectors are orthogonals.
 		//! From GLM_GTX_vector_query extensions.
 		template <typename genType> 
 		bool areOrthogonal(
-			const genType & v0, 
-			const genType & v1, 
-			const GLMvalType epsilon = std::numeric_limits<GLMvalType>::epsilon());
+			genType const & v0, 
+			genType const & v1, 
+			typename genType::value_type const & epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
 
 		//! Check if a vector is normalized.
 		//! From GLM_GTX_vector_query extensions.
 		template <typename genType> 
 		bool isNormalized(
-			const genType & v, 
-			const GLMvalType epsilon = std::numeric_limits<GLMvalType>::epsilon());
+			genType const & v, 
+			typename genType::value_type const & epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
 		
 		//! Check if a vector is null.
 		//! From GLM_GTX_vector_query extensions.
 		template <typename genType> 
 		bool isNull(
-			const genType& v, 
-			const GLMvalType epsilon = std::numeric_limits<GLMvalType>::epsilon());
+			genType const & v, 
+			typename genType::value_type const & epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
 
 		//! Check if two vectors are orthonormal.
 		//! From GLM_GTX_vector_query extensions.
 		template <typename genType>
 		bool areOrthonormal(
-			const genType & v0, 
-			const genType & v1, 
-			const GLMvalType epsilon = std::numeric_limits<GLMvalType>::epsilon());
+			genType const & v0, 
+			genType const & v1, 
+			typename genType::value_type const & epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
 
 		//! Check if two vectors are similar.
 		//! From GLM_GTX_vector_query extensions.
 		template <typename genType> 
 		bool areSimilar(
-			const genType& v0, 
-			const genType& v1, 
-			const GLMvalType epsilon = std::numeric_limits<GLMvalType>::epsilon());
+			genType const & v0, 
+			genType const & v1, 
+			typename genType::value_type const & epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
 
 		///@}
 

glm/gtx/vector_query.inl

@@ -17,77 +17,100 @@ namespace gtx{
 namespace vector_query
 {
 	template <typename T>
-	inline bool areCollinear(
-		const detail::tvec2<T>& v0, 
-		const detail::tvec2<T>& v1, 
-		const T epsilon)
+	inline bool areCollinear
+	(
+		detail::tvec2<T> const & v0, 
+		detail::tvec2<T> const & v1, 
+		T const & epsilon
+	)
 	{
 		return length(cross(detail::tvec3<T>(v0, T(0)), detail::tvec3<T>(v1, T(0)))) < epsilon;
 	}
 
 	template <typename T>
-	inline bool areCollinear(
-		const detail::tvec3<T>& v0, 
-		const detail::tvec3<T>& v1, 
-		const T epsilon)
+	inline bool areCollinear
+	(
+		detail::tvec3<T> const & v0, 
+		detail::tvec3<T> const & v1, 
+		T const & epsilon
+	)
 	{
 		return length(cross(v0, v1)) < epsilon;
 	}
 
 	template <typename T>
-	inline bool areCollinear(
-		const detail::tvec4<T>& v0, 
-		const detail::tvec4<T>& v1, 
-		const T epsilon)
+	inline bool areCollinear
+	(
+		detail::tvec4<T> const & v0, 
+		detail::tvec4<T> const & v1, 
+		T const & epsilon
+	)
 	{
 		return length(cross(detail::tvec3<T>(v0), detail::tvec3<T>(v1))) < epsilon;
 	}
 
 	template <typename genType>
-	inline bool areOpposite(
-		const genType& v0, 
-		const genType& v1, 
-		const GLMvalType epsilon)
+	inline bool areOpposite
+	(
+		genType const & v0, 
+		genType const & v1, 
+		typename genType::value_type const & epsilon
+	)
 	{
 		assert(isNormalized(v0) && isNormalized(v1));
-        return((genType::value_type(1) + dot(v0, v1)) <= epsilon);
+        return((typename genType::value_type(1) + dot(v0, v1)) <= epsilon);
 	}
 
 	template <typename genType>
-	inline bool areOrthogonal(
-		const genType& v0, 
-		const genType& v1, 
-		const GLMvalType epsilon)
+	inline bool areOrthogonal
+	(
+		genType const & v0, 
+		genType const & v1, 
+		typename genType::value_type const & epsilon
+	)
 	{
-		return abs(dot(v0, v1)) <= max(GLMvalType(1), length(v0)) * max(GLMvalType(1), length(v1)) * epsilon;
+		return abs(dot(v0, v1)) <= max(
+			typename genType::value_type(1), 
+			length(v0)) * max(
+				typename genType::value_type(1), 
+				length(v1)) * epsilon;
 	}
 
 	template <typename genType> 
-	inline bool isNormalized(
-		const genType& v, 
-		const GLMvalType epsilon)
+	inline bool isNormalized
+	(
+		genType const & v, 
+		typename genType::value_type const & epsilon
+	)
 	{
 		return abs(length(v) - GLMvalType(1)) <= GLMvalType(2) * epsilon;
 	}
 
 	template <typename genType> 
-	inline bool isNull(const genType& v, const GLMvalType epsilon)
+	inline bool isNull
+	(
+		genType const & v, 
+		typename genType::value_type const & epsilon
+	)
 	{
 		return length(v) <= epsilon;
 	}
 
     template <typename T> 
-    inline bool isCompNull(
-		const T s, 
-		const T epsilon)
+    inline bool isCompNull
+	(
+		T const & s, 
+		T const & epsilon
+	)
     {
         return abs(s) < epsilon;
     }
 
     template <typename T> 
-    inline detail::tvec2<bool> isCompNull(
-		const detail::tvec2<T>& v, 
-		const T epsilon)
+    inline detail::tvec2<bool> isCompNull
+	(
+		detail::tvec2<T> const & v, 
+		T const & epsilon)
     {
         return detail::tvec2<bool>(
             (abs(v.x) < epsilon),
@@ -95,9 +118,11 @@ namespace vector_query
     }
 
     template <typename T> 
-    inline detail::tvec3<bool> isCompNull(
-		const detail::tvec3<T>& v, 
-		const T epsilon)
+    inline detail::tvec3<bool> isCompNull
+	(
+		detail::tvec3<T> const & v, 
+		T const & epsilon
+	)
     {
         return detail::tvec3<bool>(
             abs(v.x) < epsilon,
@@ -106,9 +131,11 @@ namespace vector_query
     }
 
     template <typename T> 
-    inline detail::tvec4<bool> isCompNull(
-		const detail::tvec4<T>& v, 
-		const T epsilon)
+    inline detail::tvec4<bool> isCompNull
+	(
+		detail::tvec4<T> const & v, 
+		T const & epsilon
+	)
     {
         return detail::tvec4<bool>(
             abs(v.x) < epsilon,
@@ -118,19 +145,23 @@ namespace vector_query
     }
 
 	template <typename genType>
-	inline bool areOrthonormal(
-		const genType& v0, 
-		const genType& v1, 
-		const GLMvalType epsilon)
+	inline bool areOrthonormal
+	(
+		genType const & v0, 
+		genType const & v1, 
+		typename genType::value_type const & epsilon
+	)
 	{
 		return isNormalized(v0, epsilon) && isNormalized(v1, epsilon) && (abs(dot(v0, v1)) <= epsilon);
 	}
 
 	template <typename genType>
-	inline bool areSimilar(
-		const genType& v0, 
-		const genType& v1, 
-		const GLMvalType epsilon)
+	inline bool areSimilar
+	(
+		genType const & v0, 
+		genType const & v1, 
+		typename genType::value_type const & epsilon
+	)
 	{
 		bool similar = true;
         for(typename genType::size_type i = 0; similar && i < genType::value_size(); i++)