Merge branch '0.9.5'

glm/core/func_exponential.inl

@@ -1,224 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/core/func_exponential.inl
-/// @date 2008-08-03 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#include "func_vector_relational.hpp"
-#include "_vectorize.hpp"
-#include <limits>
-#include <cassert>
-
-namespace glm
-{
-	// pow
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType pow
-	(
-		genType const & x, 
-		genType const & y
-	)
-	{
-		GLM_STATIC_ASSERT(
-			std::numeric_limits<genType>::is_iec559,
-			"'pow' only accept floating-point inputs");
-
-		return std::pow(x, y);
-	}
-
-	VECTORIZE_VEC_VEC(pow)
-
-	// exp
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType exp
-	(
-		genType const & x
-	)
-	{
-		GLM_STATIC_ASSERT(
-			std::numeric_limits<genType>::is_iec559,
-			"'exp' only accept floating-point inputs");
-
-		return std::exp(x);
-	}
-
-	VECTORIZE_VEC(exp)
-
-	// log
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType log
-	(
-		genType const & x
-	)
-	{
-		GLM_STATIC_ASSERT(
-			std::numeric_limits<genType>::is_iec559,
-			"'log' only accept floating-point inputs");
-
-		return std::log(x);
-	}
-
-	VECTORIZE_VEC(log)
-
-	//exp2, ln2 = 0.69314718055994530941723212145818f
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType exp2
-	(
-		genType const & 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);
-	}
-
-	VECTORIZE_VEC(exp2)
-
-namespace detail
-{
-	template <bool isFloat>
-	struct compute_log2
-	{
-		template <typename T>
-		T operator() (T const & Value) const;
-	};
-
-	template <>
-	struct compute_log2<true>
-	{
-		template <typename T>
-		T operator() (T const & Value) const
-		{
-			return static_cast<T>(::std::log(Value)) * static_cast<T>(1.4426950408889634073599246810019);
-		}
-	};
-
-}//namespace detail
-
-	// log2, ln2 = 0.69314718055994530941723212145818f
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType log2
-	(
-		genType const & x
-	)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || std::numeric_limits<genType>::is_integer,
-			"GLM core 'log2' only accept floating-point inputs. Include <glm/gtx/integer.hpp> for additional integer support.");
-
-		assert(x > genType(0)); // log2 is only defined on the range (0, inf]
-		return detail::compute_log2<std::numeric_limits<genType>::is_iec559>()(x);
-	}
-
-	VECTORIZE_VEC(log2)
-
-	// sqrt
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType sqrt
-	(
-		genType const & x
-	)
-	{
-		GLM_STATIC_ASSERT(
-			std::numeric_limits<genType>::is_iec559,
-			"'sqrt' only accept floating-point inputs");
-
-		assert(x >= genType(0));
-
-		return std::sqrt(x);
-	}
-
-	VECTORIZE_VEC(sqrt)
-
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType inversesqrt
-	(
-		genType const & x
-	)
-	{
-		GLM_STATIC_ASSERT(
-			std::numeric_limits<genType>::is_iec559,
-			"'inversesqrt' only accept floating-point inputs");
-
-		assert(x > genType(0));
-
-		return genType(1) / std::sqrt(x);
-	}
-
-	VECTORIZE_VEC(inversesqrt)
-	
-	namespace detail
-	{
-		template <typename genType, typename genUType>
-		genType fastInversesqrt(genType const & v)
-		{
-			genType tmp(v);
-			genType xhalf(tmp * genType(0.5f));
-			genUType i = *reinterpret_cast<genUType*>(const_cast<genType*>(&v));
-			i = genUType(0x5f375a86) - (i >> genUType(1));
-      // tmp = *reinterpret_cast<genType*>(&i);
-      {
-        genType* ptr(reinterpret_cast<genType*>(&i));
-        tmp = *ptr;
-      }
-			tmp = tmp * (genType(1.5f) - xhalf * tmp * tmp);
-			return tmp;
-		}
-	}
-	
-	template <>
-	GLM_FUNC_QUALIFIER lowp_vec1 inversesqrt(lowp_vec1 const & v)
-	{
-		assert(glm::all(glm::greaterThan(v, lowp_vec1(0))));
-
-		return detail::fastInversesqrt<lowp_vec1, uint>(v);
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER lowp_vec2 inversesqrt(lowp_vec2 const & v)
-	{
-		assert(glm::all(glm::greaterThan(v, lowp_vec2(0))));
-
-		return detail::fastInversesqrt<lowp_vec2, lowp_uvec2>(v);
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER lowp_vec3 inversesqrt(lowp_vec3 const & v)
-	{
-		assert(glm::all(glm::greaterThan(v, lowp_vec3(0))));
-
-		return detail::fastInversesqrt<lowp_vec3, lowp_uvec3>(v);
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER lowp_vec4 inversesqrt(lowp_vec4 const & v)
-	{
-		assert(glm::all(glm::greaterThan(v, lowp_vec4(0))));
-
-		return detail::fastInversesqrt<lowp_vec4, lowp_uvec4>(v);
-	}
-	
-}//namespace glm

glm/gtc/matrix_transform.hpp

@@ -51,6 +51,7 @@
 #include "../vec2.hpp"
 #include "../vec3.hpp"
 #include "../vec4.hpp"
+#include "../gtc/constants.hpp"
 
 #if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
 #	pragma message("GLM: GLM_GTC_matrix_transform extension included")
@@ -225,7 +226,18 @@ namespace glm
 	/// @see gtc_matrix_transform
 	template <typename T>
 	GLM_FUNC_DECL detail::tmat4x4<T, defaultp> tweakedInfinitePerspective(
-		T fovy, T aspect, T near, T epsilon = epsilon<T>());
+		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.
+	/// 
+	/// @param fovy Expressed in radians if GLM_FORCE_RADIANS is define or degrees otherwise.
+	/// @param aspect 
+	/// @param near 
+	/// @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(
+		T fovy, T aspect, T near, T ep);
 
 	/// Map the specified object coordinates (obj.x, obj.y, obj.z) into window coordinates.
 	/// 

glm/gtc/matrix_transform.inl

@@ -267,7 +267,7 @@ namespace glm
 		T h = glm::cos(static_cast<T>(0.5) * rad) / glm::sin(static_cast<T>(0.5) * rad);
 		T w = h * height / width; ///todo max(width , Height) / min(width , Height)?
 
-		detail::tmat4x4<valType, defaultp> Result(static_cast<T>(0));
+		detail::tmat4x4<T, defaultp> Result(static_cast<T>(0));
 		Result[0][0] = w;
 		Result[1][1] = h;
 		Result[2][2] = - (zFar + zNear) / (zFar - zNear);
@@ -311,7 +311,7 @@ namespace glm
 		T fovy,
 		T aspect,
 		T zNear,
-		T epsilon
+		T ep
 	)
 	{
 #ifdef GLM_FORCE_RADIANS
@@ -328,12 +328,23 @@ namespace glm
 		detail::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] = epsilon - static_cast<T>(1);
+		Result[2][2] = ep - static_cast<T>(1);
 		Result[2][3] = static_cast<T>(-1);
-		Result[3][2] = (epsilon - static_cast<T>(2)) * zNear;
+		Result[3][2] = (ep - static_cast<T>(2)) * zNear;
 		return Result;
 	}
 
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tmat4x4<T, defaultp> tweakedInfinitePerspective
+	(
+		T fovy,
+		T aspect,
+		T zNear
+	)
+	{
+		return tweakedInfinitePerspective(fovy, aspect, zNear, epsilon<T>());
+	}
+
 	template <typename T, typename U, precision P>
 	GLM_FUNC_QUALIFIER detail::tvec3<T, P> project
 	(

glm/gtc/packing.hpp

@@ -62,7 +62,7 @@ namespace glm
 	/// @see uint32 packUnorm4x8(vec4 const & v)
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packUnorm4x8.xml">GLSL packUnorm4x8 man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
-	GLM_FUNC_DECL uint8 packUnorm1x8(float const & v);
+	GLM_FUNC_DECL uint8 packUnorm1x8(float v);
 
 	/// Convert a single 8-bit integer to a normalized floating-point value.
 	/// 
@@ -74,7 +74,7 @@ namespace glm
 	/// @see vec4 unpackUnorm4x8(uint32 p)
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackUnorm4x8.xml">GLSL unpackUnorm4x8 man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
-	GLM_FUNC_DECL float unpackUnorm1x8(uint8 const & p);
+	GLM_FUNC_DECL float unpackUnorm1x8(uint8 p);
 
 	/// First, converts each component of the normalized floating-point value v into 8-bit integer values.
 	/// Then, the results are packed into the returned 16-bit unsigned integer.
@@ -106,7 +106,7 @@ namespace glm
 	/// @see vec4 unpackUnorm4x8(uint32 p)
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackUnorm4x8.xml">GLSL unpackUnorm4x8 man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
-	GLM_FUNC_DECL vec2 unpackUnorm2x8(uint16 const & p);
+	GLM_FUNC_DECL vec2 unpackUnorm2x8(uint16 p);
 	
 	/// First, converts the normalized floating-point value v into 8-bit integer value.
 	/// Then, the results are packed into the returned 8-bit unsigned integer.
@@ -119,7 +119,7 @@ namespace glm
 	/// @see uint32 packSnorm4x8(vec4 const & v)
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packSnorm4x8.xml">GLSL packSnorm4x8 man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
-	GLM_FUNC_DECL uint8 packSnorm1x8(float const & s);
+	GLM_FUNC_DECL uint8 packSnorm1x8(float s);
 
 	/// First, unpacks a single 8-bit unsigned integer p into a single 8-bit signed integers. 
 	/// Then, the value is converted to a normalized floating-point value to generate the returned scalar.
@@ -132,7 +132,7 @@ namespace glm
 	/// @see vec4 unpackSnorm4x8(uint32 p)
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackSnorm4x8.xml">GLSL unpackSnorm4x8 man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
-	GLM_FUNC_DECL float unpackSnorm1x8(uint8 const & p);
+	GLM_FUNC_DECL float unpackSnorm1x8(uint8 p);
 	
 	/// First, converts each component of the normalized floating-point value v into 8-bit integer values.
 	/// Then, the results are packed into the returned 16-bit unsigned integer.
@@ -164,7 +164,7 @@ namespace glm
 	/// @see vec4 unpackSnorm4x8(uint32 p)
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackSnorm4x8.xml">GLSL unpackSnorm4x8 man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
-	GLM_FUNC_DECL vec2 unpackSnorm2x8(uint16 const & p);
+	GLM_FUNC_DECL vec2 unpackSnorm2x8(uint16 p);
 	
 	/// First, converts the normalized floating-point value v into a 16-bit integer value.
 	/// Then, the results are packed into the returned 16-bit unsigned integer.
@@ -177,7 +177,7 @@ namespace glm
 	/// @see uint64 packSnorm4x16(vec4 const & v)
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packUnorm4x8.xml">GLSL packUnorm4x8 man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
-	GLM_FUNC_DECL uint16 packUnorm1x16(float const & v);
+	GLM_FUNC_DECL uint16 packUnorm1x16(float v);
 
 	/// First, unpacks a single 16-bit unsigned integer p into a of 16-bit unsigned integers. 
 	/// Then, the value is converted to a normalized floating-point value to generate the returned scalar.
@@ -190,7 +190,7 @@ namespace glm
 	/// @see vec4 unpackUnorm4x16(uint64 p)
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackUnorm2x16.xml">GLSL unpackUnorm2x16 man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
-	GLM_FUNC_DECL float unpackUnorm1x16(uint16 const & p);
+	GLM_FUNC_DECL float unpackUnorm1x16(uint16 p);
 
 	/// First, converts each component of the normalized floating-point value v into 16-bit integer values.
 	/// Then, the results are packed into the returned 64-bit unsigned integer.
@@ -222,7 +222,7 @@ namespace glm
 	/// @see vec2 unpackUnorm2x16(uint32 p)
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackUnorm2x16.xml">GLSL unpackUnorm2x16 man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
-	GLM_FUNC_DECL vec4 unpackUnorm4x16(uint64 const & p);
+	GLM_FUNC_DECL vec4 unpackUnorm4x16(uint64 p);
 
 	/// First, converts the normalized floating-point value v into 16-bit integer value.
 	/// Then, the results are packed into the returned 16-bit unsigned integer.
@@ -235,7 +235,7 @@ namespace glm
 	/// @see uint64 packSnorm4x16(vec4 const & v)
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packSnorm4x8.xml">GLSL packSnorm4x8 man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
-	GLM_FUNC_DECL uint16 packSnorm1x16(float const & v);
+	GLM_FUNC_DECL uint16 packSnorm1x16(float v);
 
 	/// First, unpacks a single 16-bit unsigned integer p into a single 16-bit signed integers. 
 	/// Then, each component is converted to a normalized floating-point value to generate the returned scalar.
@@ -248,7 +248,7 @@ namespace glm
 	/// @see vec4 unpackSnorm4x16(uint64 p)
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackSnorm1x16.xml">GLSL unpackSnorm4x8 man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
-	GLM_FUNC_DECL float unpackSnorm1x16(uint16 const & p);
+	GLM_FUNC_DECL float unpackSnorm1x16(uint16 p);
 
 	/// First, converts each component of the normalized floating-point value v into 16-bit integer values.
 	/// Then, the results are packed into the returned 64-bit unsigned integer.
@@ -291,7 +291,7 @@ namespace glm
 	/// @see uint64 packHalf4x16(vec4 const & v)
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packHalf2x16.xml">GLSL packHalf2x16 man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
-	GLM_FUNC_DECL uint16 packHalf1x16(float const & v);
+	GLM_FUNC_DECL uint16 packHalf1x16(float v);
 	
 	/// Returns a floating-point scalar with components obtained by unpacking a 16-bit unsigned integer into a 16-bit value,
 	/// interpreted as a 16-bit floating-point number according to the OpenGL Specification,
@@ -302,7 +302,7 @@ namespace glm
 	/// @see vec4 unpackHalf4x16(uint64 const & v)
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackHalf2x16.xml">GLSL unpackHalf2x16 man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
-	GLM_FUNC_DECL float unpackHalf1x16(uint16 const & v);
+	GLM_FUNC_DECL float unpackHalf1x16(uint16 v);
 
 	/// Returns an unsigned integer obtained by converting the components of a four-component floating-point vector 
 	/// to the 16-bit floating-point representation found in the OpenGL Specification, 
@@ -328,7 +328,7 @@ namespace glm
 	/// @see vec2 unpackHalf2x16(uint32 const & v)
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackHalf2x16.xml">GLSL unpackHalf2x16 man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
-	GLM_FUNC_DECL vec4 unpackHalf4x16(uint64 const & p);
+	GLM_FUNC_DECL vec4 unpackHalf4x16(uint64 p);
 
 	/// Returns an unsigned integer obtained by converting the components of a four-component signed integer vector 
 	/// to the 10-10-10-2-bit signed integer representation found in the OpenGL Specification, 
@@ -352,7 +352,7 @@ namespace glm
 	/// @see uint32 packU3x10_1x2(uvec4 const & v)
 	/// @see vec4 unpackSnorm3x10_1x2(uint32 const & p);
 	/// @see uvec4 unpackI3x10_1x2(uint32 const & p);
-	GLM_FUNC_DECL ivec4 unpackI3x10_1x2(uint32 const & p);
+	GLM_FUNC_DECL ivec4 unpackI3x10_1x2(uint32 p);
 
 	/// Returns an unsigned integer obtained by converting the components of a four-component unsigned integer vector 
 	/// to the 10-10-10-2-bit unsigned integer representation found in the OpenGL Specification, 
@@ -376,7 +376,7 @@ namespace glm
 	/// @see uint32 packU3x10_1x2(uvec4 const & v)
 	/// @see vec4 unpackSnorm3x10_1x2(uint32 const & p);
 	/// @see uvec4 unpackI3x10_1x2(uint32 const & p);
-	GLM_FUNC_DECL uvec4 unpackU3x10_1x2(uint32 const & p);
+	GLM_FUNC_DECL uvec4 unpackU3x10_1x2(uint32 p);
 
 	/// First, converts the first three components of the normalized floating-point value v into 10-bit signed integer values.
 	/// Then, converts the forth component of the normalized floating-point value v into 2-bit signed integer values.
@@ -411,7 +411,7 @@ namespace glm
 	/// @see vec4 unpackUnorm3x10_1x2(uint32 const & p))
 	/// @see uvec4 unpackI3x10_1x2(uint32 const & p)
 	/// @see uvec4 unpackU3x10_1x2(uint32 const & p)
-	GLM_FUNC_DECL vec4 unpackSnorm3x10_1x2(uint32 const & p);
+	GLM_FUNC_DECL vec4 unpackSnorm3x10_1x2(uint32 p);
 
 	/// First, converts the first three components of the normalized floating-point value v into 10-bit unsigned integer values.
 	/// Then, converts the forth component of the normalized floating-point value v into 2-bit signed uninteger values.
@@ -446,7 +446,7 @@ namespace glm
 	/// @see vec4 unpackInorm3x10_1x2(uint32 const & p))
 	/// @see uvec4 unpackI3x10_1x2(uint32 const & p)
 	/// @see uvec4 unpackU3x10_1x2(uint32 const & p)
-	GLM_FUNC_DECL vec4 unpackUnorm3x10_1x2(uint32 const & p);
+	GLM_FUNC_DECL vec4 unpackUnorm3x10_1x2(uint32 p);
 
 	/// First, converts the first two components of the normalized floating-point value v into 11-bit signless floating-point values.
 	/// Then, converts the third component of the normalized floating-point value v into a 10-bit signless floating-point value.
@@ -467,7 +467,7 @@ namespace glm
 	/// 
 	/// @see gtc_packing
 	/// @see uint32 packF2x11_1x10(vec3 const & v)
-	GLM_FUNC_DECL vec3 unpackF2x11_1x10(uint32 const & p);
+	GLM_FUNC_DECL vec3 unpackF2x11_1x10(uint32 p);
 
 	/// @}
 }// namespace glm

glm/gtc/packing.inl

@@ -31,11 +31,12 @@
 #include "../vec3.hpp"
 #include "../vec4.hpp"
 #include "../detail/type_half.hpp"
+#include <cstring>
 
 namespace glm{
 namespace detail
 {
-	GLM_FUNC_QUALIFIER glm::uint16 float2half(glm::uint32 const & f)
+	GLM_FUNC_QUALIFIER glm::uint16 float2half(glm::uint32 f)
 	{
 		// 10 bits    =>                         EE EEEFFFFF
 		// 11 bits    =>                        EEE EEFFFFFF
@@ -53,7 +54,7 @@ namespace detail
 			((f >> 13) & 0x03ff); // Mantissa
 	}
 
-	GLM_FUNC_QUALIFIER glm::uint32 float2packed11(glm::uint32 const & f)
+	GLM_FUNC_QUALIFIER glm::uint32 float2packed11(glm::uint32 f)
 	{
 		// 10 bits    =>                         EE EEEFFFFF
 		// 11 bits    =>                        EEE EEFFFFFF
@@ -71,7 +72,7 @@ namespace detail
 			((f >> 17) & 0x003f); // Mantissa
 	}
 
-	GLM_FUNC_QUALIFIER glm::uint32 packed11ToFloat(glm::uint32 const & p)
+	GLM_FUNC_QUALIFIER glm::uint32 packed11ToFloat(glm::uint32 p)
 	{
 		// 10 bits    =>                         EE EEEFFFFF
 		// 11 bits    =>                        EEE EEFFFFFF
@@ -89,7 +90,7 @@ namespace detail
 			((p & 0x003f) << 17); // Mantissa
 	}
 
-	GLM_FUNC_QUALIFIER glm::uint32 float2packed10(glm::uint32 const & f)
+	GLM_FUNC_QUALIFIER glm::uint32 float2packed10(glm::uint32 f)
 	{
 		// 10 bits    =>                         EE EEEFFFFF
 		// 11 bits    =>                        EEE EEFFFFFF
@@ -110,7 +111,7 @@ namespace detail
 			((f >> 18) & 0x001f); // Mantissa
 	}
 
-	GLM_FUNC_QUALIFIER glm::uint32 packed10ToFloat(glm::uint32 const & p)
+	GLM_FUNC_QUALIFIER glm::uint32 packed10ToFloat(glm::uint32 p)
 	{
 		// 10 bits    =>                         EE EEEFFFFF
 		// 11 bits    =>                        EEE EEFFFFFF
@@ -131,7 +132,7 @@ namespace detail
 			((p & 0x001f) << 18); // Mantissa
 	}
 
-	GLM_FUNC_QUALIFIER glm::uint half2float(glm::uint const & h)
+	GLM_FUNC_QUALIFIER glm::uint half2float(glm::uint h)
 	{
 		return ((h & 0x8000) << 16) | ((( h & 0x7c00) + 0x1C000) << 13) | ((h & 0x03FF) << 13);
 	}
@@ -145,7 +146,14 @@ namespace detail
 		else if(glm::isinf(x))
 			return 0x1f << 6;
 
-		return float2packed11(reinterpret_cast<uint&>(x));
+#		if(GLM_COMPILER & GLM_COMPILER_GCC || GLM_COMPILER & GLM_COMPILER_CLANG)
+			uint Pack = 0;
+			memcpy(&Pack, &x, sizeof(Pack));
+#		else	
+			uint Pack = reinterpret_cast<uint&>(x);
+#		endif
+
+		return float2packed11(Pack);
 	}
 
 	GLM_FUNC_QUALIFIER float packed11bitToFloat(glm::uint x)
@@ -157,8 +165,15 @@ namespace detail
 		else if(x == (0x1f << 6))
 			return ~0;//Inf
 
-		uint result = packed11ToFloat(x);
-		return reinterpret_cast<float&>(result);
+		uint Result = packed11ToFloat(x);
+
+#		if(GLM_COMPILER & GLM_COMPILER_GCC || GLM_COMPILER & GLM_COMPILER_CLANG)
+			float Temp = 0;
+			memcpy(&Temp, &Result, sizeof(Temp));
+			return Temp;
+#		else	
+			return reinterpret_cast<float&>(Result);
+#		endif
 	}
 
 	GLM_FUNC_QUALIFIER glm::uint floatTo10bit(float x)
@@ -170,7 +185,14 @@ namespace detail
 		else if(glm::isinf(x))
 			return 0x1f << 5;
 
-		return float2packed10(reinterpret_cast<uint&>(x));
+#		if(GLM_COMPILER & GLM_COMPILER_GCC || GLM_COMPILER & GLM_COMPILER_CLANG)
+			uint Pack = 0;
+			memcpy(&Pack, &x, sizeof(Pack));
+#		else	
+			uint Pack = reinterpret_cast<uint&>(x);
+#		endif
+
+		return float2packed10(Pack);
 	}
 
 	GLM_FUNC_QUALIFIER float packed10bitToFloat(glm::uint x)
@@ -182,8 +204,15 @@ namespace detail
 		else if(x == (0x1f << 5))
 			return ~0;//Inf
 
-		uint result = packed10ToFloat(x);
-		return reinterpret_cast<float&>(result);
+		uint Result = packed10ToFloat(x);
+
+#		if(GLM_COMPILER & GLM_COMPILER_GCC || GLM_COMPILER & GLM_COMPILER_CLANG)
+			float Temp = 0;
+			memcpy(&Temp, &Result, sizeof(Temp));
+			return Temp;
+#		else	
+			return reinterpret_cast<float&>(Result);
+#		endif
 	}
 
 //	GLM_FUNC_QUALIFIER glm::uint f11_f11_f10(float x, float y, float z)
@@ -217,12 +246,12 @@ namespace detail
 
 }//namespace detail
 
-	GLM_FUNC_QUALIFIER uint8 packUnorm1x8(float const & v)
+	GLM_FUNC_QUALIFIER uint8 packUnorm1x8(float v)
 	{
 		return static_cast<uint8>(round(clamp(v, 0.0f, 1.0f) * 255.0f));
 	}
 	
-	GLM_FUNC_QUALIFIER float unpackUnorm1x8(uint8 const & p)
+	GLM_FUNC_QUALIFIER float unpackUnorm1x8(uint8 p)
 	{
 		float Unpack(static_cast<float>(p));
 		return Unpack * static_cast<float>(0.0039215686274509803921568627451); // 1 / 255
@@ -235,20 +264,20 @@ namespace detail
 		return *Packed;
 	}
 	
-	GLM_FUNC_QUALIFIER vec2 unpackUnorm2x8(uint16 const & p)
+	GLM_FUNC_QUALIFIER vec2 unpackUnorm2x8(uint16 p)
 	{
 		u8vec2* Unpacked = reinterpret_cast<u8vec2*>(const_cast<uint16*>(&p));
 		return vec2(*Unpacked) * float(0.0039215686274509803921568627451); // 1 / 255
 	}
 
-	GLM_FUNC_QUALIFIER uint8 packSnorm1x8(float const & v)
+	GLM_FUNC_QUALIFIER uint8 packSnorm1x8(float v)
 	{
 		int8 Topack(static_cast<int8>(round(clamp(v ,-1.0f, 1.0f) * 127.0f)));
 		uint8* Packed = reinterpret_cast<uint8*>(&Topack);
 		return *Packed;
 	}
 	
-	GLM_FUNC_QUALIFIER float unpackSnorm1x8(uint8 const & p)
+	GLM_FUNC_QUALIFIER float unpackSnorm1x8(uint8 p)
 	{
 		float Unpack(static_cast<float>(*const_cast<uint8*>(&p)));
 		return clamp(
@@ -263,7 +292,7 @@ namespace detail
 		return *Packed;
 	}
 	
-	GLM_FUNC_QUALIFIER vec2 unpackSnorm2x8(uint16 const & p)
+	GLM_FUNC_QUALIFIER vec2 unpackSnorm2x8(uint16 p)
 	{
 		i8vec2* Unpack = reinterpret_cast<i8vec2*>(const_cast<uint16*>(&p));
 		return clamp(
@@ -271,12 +300,12 @@ namespace detail
 			-1.0f, 1.0f);
 	}
 	
-	GLM_FUNC_QUALIFIER uint16 packUnorm1x16(float const & s)
+	GLM_FUNC_QUALIFIER uint16 packUnorm1x16(float s)
 	{
 		return static_cast<uint16>(round(clamp(s, 0.0f, 1.0f) * 65535.0f));
 	}
 
-	GLM_FUNC_QUALIFIER float unpackUnorm1x16(uint16 const & p)
+	GLM_FUNC_QUALIFIER float unpackUnorm1x16(uint16 p)
 	{
 		float Unpack = static_cast<float>(*const_cast<uint16*>(&p));
 		return Unpack * 1.5259021896696421759365224689097e-5f; // 1.0 / 65535.0
@@ -289,20 +318,20 @@ namespace detail
 		return *Packed;
 	}
 
-	GLM_FUNC_QUALIFIER vec4 unpackUnorm4x16(uint64 const & p)
+	GLM_FUNC_QUALIFIER vec4 unpackUnorm4x16(uint64 p)
 	{
 		u16vec4* Unpack = reinterpret_cast<u16vec4*>(const_cast<uint64*>(&p));
 		return vec4(*Unpack) * 1.5259021896696421759365224689097e-5f; // 1.0 / 65535.0
 	}
 
-	GLM_FUNC_QUALIFIER uint16 packSnorm1x16(float const & v)
+	GLM_FUNC_QUALIFIER uint16 packSnorm1x16(float v)
 	{
 		int16 Topack = static_cast<int16>(round(clamp(v ,-1.0f, 1.0f) * 32767.0f));
 		uint16* Packed = reinterpret_cast<uint16*>(&Topack);
 		return *Packed;
 	}
 
-	GLM_FUNC_QUALIFIER float unpackSnorm1x16(uint16 const & p)
+	GLM_FUNC_QUALIFIER float unpackSnorm1x16(uint16 p)
 	{
 		float Unpack = static_cast<float>(*const_cast<uint16*>(&p));
 		return clamp(
@@ -317,7 +346,7 @@ namespace detail
 		return *Packed;
 	}
 
-	GLM_FUNC_QUALIFIER vec4 unpackSnorm4x16(uint64 const & p)
+	GLM_FUNC_QUALIFIER vec4 unpackSnorm4x16(uint64 p)
 	{
 		i16vec4* Unpack(reinterpret_cast<i16vec4*>(const_cast<uint64*>(&p)));
 		return clamp(
@@ -325,14 +354,14 @@ namespace detail
 			-1.0f, 1.0f);
 	}
 
-	GLM_FUNC_QUALIFIER uint16 packHalf1x16(float const & v)
+	GLM_FUNC_QUALIFIER uint16 packHalf1x16(float v)
 	{
 		int16 Topack = detail::toFloat16(v);
 		uint16* Packed = reinterpret_cast<uint16*>(&Topack);
 		return *Packed;
 	}
 
-	GLM_FUNC_QUALIFIER float unpackHalf1x16(uint16 const & v)
+	GLM_FUNC_QUALIFIER float unpackHalf1x16(uint16 v)
 	{
 		int16* Unpack = reinterpret_cast<int16*>(const_cast<uint16*>(&v));
 		return detail::toFloat32(*Unpack);
@@ -350,7 +379,7 @@ namespace detail
 		return *Packed;
 	}
 
-	GLM_FUNC_QUALIFIER glm::vec4 unpackHalf4x16(uint64 const & v)
+	GLM_FUNC_QUALIFIER glm::vec4 unpackHalf4x16(uint64 v)
 	{
 		i16vec4* p = reinterpret_cast<i16vec4*>(const_cast<uint64*>(&v));
 		i16vec4 Unpack(*p);
@@ -372,7 +401,7 @@ namespace detail
 		return Result.pack; 
 	}
 
-	GLM_FUNC_QUALIFIER ivec4 unpackI3x10_1x2(uint32 const & v)
+	GLM_FUNC_QUALIFIER ivec4 unpackI3x10_1x2(uint32 v)
 	{
 		detail::i10i10i10i2 Unpack;
 		Unpack.pack = v;
@@ -393,7 +422,7 @@ namespace detail
 		return Result.pack; 
 	}
 
-	GLM_FUNC_QUALIFIER uvec4 unpackU3x10_1x2(uint32 const & v)
+	GLM_FUNC_QUALIFIER uvec4 unpackU3x10_1x2(uint32 v)
 	{
 		detail::u10u10u10u2 Unpack;
 		Unpack.pack = v;
@@ -414,7 +443,7 @@ namespace detail
 		return Result.pack;
 	}
 
-	GLM_FUNC_QUALIFIER vec4 unpackSnorm3x10_1x2(uint32 const & v)
+	GLM_FUNC_QUALIFIER vec4 unpackSnorm3x10_1x2(uint32 v)
 	{
 		detail::i10i10i10i2 Unpack;
 		Unpack.pack = v;
@@ -436,7 +465,7 @@ namespace detail
 		return Result.pack;
 	}
 
-	GLM_FUNC_QUALIFIER vec4 unpackUnorm3x10_1x2(uint32 const & v)
+	GLM_FUNC_QUALIFIER vec4 unpackUnorm3x10_1x2(uint32 v)
 	{
 		detail::i10i10i10i2 Unpack;
 		Unpack.pack = v;
@@ -456,7 +485,7 @@ namespace detail
 			((detail::floatTo10bit(v.z) & ((1 << 10) - 1)) << 22);
 	}
 
-	GLM_FUNC_QUALIFIER vec3 unpackF2x11_1x10(uint32 const & v)
+	GLM_FUNC_QUALIFIER vec3 unpackF2x11_1x10(uint32 v)
 	{
 		return vec3(
 			detail::packed11bitToFloat(v >> 0), 

glm/gtc/ulp.inl

@@ -199,9 +199,9 @@ namespace glm
 	template <>
 	GLM_FUNC_QUALIFIER float next_float(float const & x)
 	{
-#		if((GLM_LANG & GLM_LANG_CXX11_FLAG))
+#		if((GLM_LANG & GLM_LANG_CXX11_FLAG) && !(GLM_PLATFORM & GLM_PLATFORM_ANDROID))
 			return std::nextafter(x, std::numeric_limits<float>::max());
-#		elif((GLM_COMPILER & GLM_COMPILER_VC) || ((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_PLATFORM & GLM_PLATFORM_WINDOWS)))
+#		elif((GLM_PLATFORM & GLM_PLATFORM_ANDROID) || (GLM_COMPILER & GLM_COMPILER_VC) || ((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_PLATFORM & GLM_PLATFORM_WINDOWS)))
 			return detail::nextafterf(x, FLT_MAX);
 #		else
 			return nextafterf(x, FLT_MAX);
@@ -211,9 +211,9 @@ namespace glm
 	template <>
 	GLM_FUNC_QUALIFIER double next_float(double const & x)
 	{
-#		if((GLM_LANG & GLM_LANG_CXX11_FLAG))
+#		if((GLM_LANG & GLM_LANG_CXX11_FLAG) && !(GLM_PLATFORM & GLM_PLATFORM_ANDROID))
 			return std::nextafter(x, std::numeric_limits<double>::max());
-#		elif((GLM_COMPILER & GLM_COMPILER_VC) || ((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_PLATFORM & GLM_PLATFORM_WINDOWS)))
+#		elif((GLM_PLATFORM & GLM_PLATFORM_ANDROID) || (GLM_COMPILER & GLM_COMPILER_VC) || ((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_PLATFORM & GLM_PLATFORM_WINDOWS)))
 			return detail::nextafter(x, std::numeric_limits<double>::max());
 #		else
 			return nextafter(x, DBL_MAX);
@@ -231,9 +231,9 @@ namespace glm
 
 	GLM_FUNC_QUALIFIER float prev_float(float const & x)
 	{
-#		if((GLM_LANG & GLM_LANG_CXX11_FLAG))
+#		if((GLM_LANG & GLM_LANG_CXX11_FLAG) && !(GLM_PLATFORM & GLM_PLATFORM_ANDROID))
 			return std::nextafter(x, std::numeric_limits<float>::min());
-#		elif((GLM_COMPILER & GLM_COMPILER_VC) || ((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_PLATFORM & GLM_PLATFORM_WINDOWS)))
+#		elif((GLM_PLATFORM & GLM_PLATFORM_ANDROID) || (GLM_COMPILER & GLM_COMPILER_VC) || ((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_PLATFORM & GLM_PLATFORM_WINDOWS)))
 			return detail::nextafterf(x, FLT_MIN);
 #		else
 			return nextafterf(x, FLT_MIN);
@@ -242,9 +242,9 @@ namespace glm
 
 	GLM_FUNC_QUALIFIER double prev_float(double const & x)
 	{
-#		if((GLM_LANG & GLM_LANG_CXX11_FLAG))
+#		if((GLM_LANG & GLM_LANG_CXX11_FLAG) && !(GLM_PLATFORM & GLM_PLATFORM_ANDROID))
 			return std::nextafter(x, std::numeric_limits<double>::min());
-#		elif((GLM_COMPILER & GLM_COMPILER_VC) || ((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_PLATFORM & GLM_PLATFORM_WINDOWS)))
+#		elif((GLM_PLATFORM & GLM_PLATFORM_ANDROID) || (GLM_COMPILER & GLM_COMPILER_VC) || ((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_PLATFORM & GLM_PLATFORM_WINDOWS)))
 			return _nextafter(x, DBL_MIN);
 #		else
 			return nextafter(x, DBL_MIN);

glm/virtrev/xstream.hpp

@@ -1,166 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref virtrev_xstream
-/// @file glm/virtrev/xstream.hpp
-/// @date 2008-05-24 / 2008-05-26
-/// @author Mathieu Roumillac (matrem84.free.fr)
-///
-/// @see core (dependence)
-/// @see gtc_matrix_access (dependence)
-///
-/// @defgroup virtrev_xstream GLM_VIRTREV_xstream: xml like output
-/// @ingroup virtrev
-/// 
-/// @brief Streaming vector and matrix in a xml way.
-/// 
-/// Include <glm/virtrev/xstream.hpp> for this functionality.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef GLM_VIRTREV_xstream
-#define GLM_VIRTREV_xstream GLM_VERSION
-
-#include "../glm.hpp"
-#include "../gtc/matrix_access.hpp"
-#include <iostream>
-
-#if(defined(GLM_MESSAGES) && !defined(glm_ext))
-#	pragma message("GLM: GLM_VIRTREV_xstream extension included")
-#endif
-/*
-namespace glm{
-namespace detail
-{
-	template<typename T>
-	std::ostream & operator << (std::ostream & stream, glm::detail::tvec2<T, P> const & vec)
-	{
-		stream << "<glm_vec2 ";
-		stream << "x=\"" << vec.x << "\" ";
-		stream << "y=\"" << vec.y << "\" ";
-		stream << "/>";
-
-		return stream;
-	}
-
-	template<typename T>
-	std::ostream & operator << (std::ostream & stream, glm::detail::tvec3<T, P> const & vec)
-	{
-		stream << "<glm_vec3 ";
-		stream << "x=\"" << vec.x << "\" ";
-		stream << "y=\"" << vec.y << "\" ";
-		stream << "z=\"" << vec.z << "\" ";
-		stream << "/>";
-
-		return stream;
-	}
-
-	template<typename T>
-	std::ostream & operator << (std::ostream & stream, glm::detail::tvec4<T, P> const & vec)
-	{
-		stream << "<glm_vec4 ";
-		stream << "x=\"" << vec.x << "\" ";
-		stream << "y=\"" << vec.y << "\" ";
-		stream << "z=\"" << vec.z << "\" ";
-		stream << "w=\"" << vec.w << "\" ";
-		stream << "/>";
-
-		return stream;
-	}
-
-	template<typename T>
-	std::ostream & operator << (std::ostream & stream, glm::detail::tmat2x2<T, P> const & mat)
-	{
-		stream << "<glm_mat2>" << std::endl;
-		stream << "<row ";
-		stream << "x=\"" << glm::row(mat, 0)[0] << "\" ";
-		stream << "y=\"" << glm::row(mat, 0)[1] << "\" ";
-		stream << "/>" << std::endl;
-		stream << "<row ";
-		stream << "x=\"" << glm::row(mat, 1)[0] << "\" ";
-		stream << "y=\"" << glm::row(mat, 1)[1] << "\" ";
-		stream << "/>" << std::endl;
-		stream << "</glm_mat2>";
-
-		return stream;
-	}
-
-	template<typename T>
-	std::ostream & operator << (std::ostream & stream, glm::detail::tmat3x3<T, P> const & mat)
-	{
-		stream << "<glm_mat3>" << std::endl;
-		stream << "<row ";
-		stream << "x=\"" << glm::row(mat, 0)[0] << "\" ";
-		stream << "y=\"" << glm::row(mat, 0)[1] << "\" ";
-		stream << "z=\"" << glm::row(mat, 0)[2] << "\" ";
-		stream << "/>" << std::endl;
-		stream << "<row ";
-		stream << "x=\"" << glm::row(mat, 1)[0] << "\" ";
-		stream << "y=\"" << glm::row(mat, 1)[1] << "\" ";
-		stream << "z=\"" << glm::row(mat, 1)[2] << "\" ";
-		stream << "/>" << std::endl;
-		stream << "<row ";
-		stream << "x=\"" << glm::row(mat, 2)[0] << "\" ";
-		stream << "y=\"" << glm::row(mat, 2)[1] << "\" ";
-		stream << "z=\"" << glm::row(mat, 2)[2] << "\" ";
-		stream << "/>" << std::endl;
-		stream << "</glm_mat3>";
-
-		return stream;
-	}
-
-	template<typename T>
-	std::ostream & operator << (std::ostream & stream, glm::detail::tmat4x4<T, P> const & mat)
-	{
-		stream << "<glm_mat4>" << std::endl;
-		stream << "<row ";
-		stream << "x=\"" << glm::row(mat, 0)[0] << "\" ";
-		stream << "y=\"" << glm::row(mat, 0)[1] << "\" ";
-		stream << "z=\"" << glm::row(mat, 0)[2] << "\" ";
-		stream << "w=\"" << glm::row(mat, 0)[3] << "\" ";
-		stream << "/>" << std::endl;
-		stream << "<row ";
-		stream << "x=\"" << glm::row(mat, 1)[0] << "\" ";
-		stream << "y=\"" << glm::row(mat, 1)[1] << "\" ";
-		stream << "z=\"" << glm::row(mat, 1)[2] << "\" ";
-		stream << "w=\"" << glm::row(mat, 1)[3] << "\" ";
-		stream << "/>" << std::endl;
-		stream << "<row ";
-		stream << "x=\"" << glm::row(mat, 2)[0] << "\" ";
-		stream << "y=\"" << glm::row(mat, 2)[1] << "\" ";
-		stream << "z=\"" << glm::row(mat, 2)[2] << "\" ";
-		stream << "w=\"" << glm::row(mat, 2)[3] << "\" ";
-		stream << "/>" << std::endl;
-		stream << "<row ";
-		stream << "x=\"" << glm::row(mat, 3)[0] << "\" ";
-		stream << "y=\"" << glm::row(mat, 3)[1] << "\" ";
-		stream << "z=\"" << glm::row(mat, 3)[2] << "\" ";
-		stream << "w=\"" << glm::row(mat, 3)[3] << "\" ";
-		stream << "/>" << std::endl;
-		stream << "</glm_mat4>";
-			
-		return stream;
-	}
-
-}//namespace detail
-}//namespace glm
-*/
-#endif//GLM_VIRTREV_xstream

readme.txt

@@ -62,6 +62,8 @@ GLM 0.9.5.4: 2014-0X-XX
 - Fixed tweakedInfinitePerspective #208 and added user-defined epsilon to
   tweakedInfinitePerspective
 - Fixed std::copy and std::vector with GLM types #214
+- Fixed strict aliasing issues #212, #152
+- Fixed std::nextafter not supported with C++11 on Android #213
 
 ================================================================================
 GLM 0.9.5.3: 2014-04-02

test/gtc/gtc_packing.cpp

@@ -100,7 +100,7 @@ int test_Half1x16()
 		glm::uint32 p0 = glm::packHalf1x16(Tests[i]);
 		float v0 = glm::unpackHalf1x16(p0);
 		glm::uint32 p1 = glm::packHalf1x16(v0);
-		float v1 = glm::unpackHalf1x16(p0);
+		float v1 = glm::unpackHalf1x16(p1);
 		Error += (v0 == v1) ? 0 : 1;
 	}
 
@@ -124,7 +124,7 @@ int test_Half4x16()
 		glm::uint64 p0 = glm::packHalf4x16(Tests[i]);
 		glm::vec4 v0 = glm::unpackHalf4x16(p0);
 		glm::uint64 p1 = glm::packHalf4x16(v0);
-		glm::vec4 v1 = glm::unpackHalf4x16(p0);
+		glm::vec4 v1 = glm::unpackHalf4x16(p1);
 		Error += glm::all(glm::equal(v0, v1)) ? 0 : 1;
 	}
 
@@ -148,7 +148,7 @@ int test_I3x10_1x2()
 		glm::uint32 p0 = glm::packI3x10_1x2(Tests[i]);
 		glm::ivec4 v0 = glm::unpackI3x10_1x2(p0);
 		glm::uint32 p1 = glm::packI3x10_1x2(v0);
-		glm::ivec4 v1 = glm::unpackI3x10_1x2(p0);
+		glm::ivec4 v1 = glm::unpackI3x10_1x2(p1);
 		Error += glm::all(glm::equal(v0, v1)) ? 0 : 1;
 	}
 
@@ -172,7 +172,7 @@ int test_U3x10_1x2()
 		glm::uint32 p0 = glm::packU3x10_1x2(Tests[i]);
 		glm::uvec4 v0 = glm::unpackU3x10_1x2(p0);
 		glm::uint32 p1 = glm::packU3x10_1x2(v0);
-		glm::uvec4 v1 = glm::unpackU3x10_1x2(p0);
+		glm::uvec4 v1 = glm::unpackU3x10_1x2(p1);
 		Error += glm::all(glm::equal(v0, v1)) ? 0 : 1;
 	}
 
@@ -196,7 +196,7 @@ int test_Snorm3x10_1x2()
 		glm::uint32 p0 = glm::packSnorm3x10_1x2(Tests[i]);
 		glm::vec4 v0 = glm::unpackSnorm3x10_1x2(p0);
 		glm::uint32 p1 = glm::packSnorm3x10_1x2(v0);
-		glm::vec4 v1 = glm::unpackSnorm3x10_1x2(p0);
+		glm::vec4 v1 = glm::unpackSnorm3x10_1x2(p1);
 		Error += glm::all(glm::equal(v0, v1)) ? 0 : 1;
 	}
 
@@ -220,7 +220,7 @@ int test_Unorm3x10_1x2()
 		glm::uint32 p0 = glm::packSnorm3x10_1x2(Tests[i]);
 		glm::vec4 v0 = glm::unpackSnorm3x10_1x2(p0);
 		glm::uint32 p1 = glm::packSnorm3x10_1x2(v0);
-		glm::vec4 v1 = glm::unpackSnorm3x10_1x2(p0);
+		glm::vec4 v1 = glm::unpackSnorm3x10_1x2(p1);
 		Error += glm::all(glm::equal(v0, v1)) ? 0 : 1;
 	}
 
@@ -244,7 +244,7 @@ int test_F2x11_1x10()
 		glm::uint32 p0 = glm::packF2x11_1x10(Tests[i]);
 		glm::vec3 v0 = glm::unpackF2x11_1x10(p0);
 		glm::uint32 p1 = glm::packF2x11_1x10(v0);
-		glm::vec3 v1 = glm::unpackF2x11_1x10(p0);
+		glm::vec3 v1 = glm::unpackF2x11_1x10(p1);
 		Error += glm::all(glm::equal(v0, v1)) ? 0 : 1;
 	}