Merge nohalf

glm/core/setup.hpp

@@ -133,8 +133,6 @@
 
 // GCC defines
 #define GLM_COMPILER_GCC			0x02000000
-#define GLM_COMPILER_GCC_LLVM		0x02000001
-#define GLM_COMPILER_GCC_CLANG		0x02000002
 #define GLM_COMPILER_GCC34			0x02000050
 #define GLM_COMPILER_GCC35			0x02000060
 #define GLM_COMPILER_GCC40			0x02000070
@@ -588,49 +586,6 @@
 #	endif//GLM_ARCH
 #endif//GLM_MESSAGE
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Support check macros
-
-#define GLM_SUPPORT_ANONYMOUS_UNION() \
-	(GLM_LANG & GLM_LANG_CXX98_FLAG)
-
-#define GLM_SUPPORT_ANONYMOUS_UNION_OF_STRUCTURE() \
-	((GLM_LANG & GLM_LANG_CXXMS_FLAG) && (GLM_COMPILER & GLM_COMPILER_VC))
-
-#define GLM_SUPPORT_SWIZZLE_OPERATOR() \
-	(defined(GLM_SWIZZLE) && GLM_SUPPORT_ANONYMOUS_UNION_OF_STRUCTURE())
-
-#define GLM_SUPPORT_SWIZZLE_FUNCTION() defined(GLM_SWIZZLE)
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Components
-
-//#define GLM_FORCE_ONLY_XYZW
-#define GLM_COMPONENT_ONLY_XYZW				0 // To disable multiple vector component names access.
-#define GLM_COMPONENT_CXX98					1 //  
-#define GLM_COMPONENT_CXXMS					2 // To use anonymous union to provide multiple component names access for class valType. Visual C++ only.
-
-#if(GLM_SUPPORT_ANONYMOUS_UNION_OF_STRUCTURE() && !defined(GLM_FORCE_ONLY_XYZW))
-#	define GLM_COMPONENT GLM_COMPONENT_CXXMS
-#elif(GLM_SUPPORT_ANONYMOUS_UNION() && !defined(GLM_FORCE_ONLY_XYZW))
-#	define GLM_COMPONENT GLM_COMPONENT_CXX98
-#else
-#	define GLM_COMPONENT GLM_COMPONENT_ONLY_XYZW
-#endif
-
-#if(defined(GLM_MESSAGES) && !defined(GLM_MESSAGE_COMPONENT_DISPLAYED))
-#	define GLM_MESSAGE_COMPONENT_DISPLAYED
-#	if(GLM_COMPONENT == GLM_COMPONENT_CXX98)
-#		pragma message("GLM: x,y,z,w; r,g,b,a; s,t,p,q component names except of half based vector types")
-#	elif(GLM_COMPONENT == GLM_COMPONENT_ONLY_XYZW)
-#		pragma message("GLM: x,y,z,w component names for all vector types")
-#	elif(GLM_COMPONENT == GLM_COMPONENT_CXXMS)
-#		pragma message("GLM: x,y,z,w; r,g,b,a; s,t,p,q component names for all vector types")
-#	else
-#		error "GLM: GLM_COMPONENT value unknown"
-#	endif//GLM_MESSAGE_COMPONENT_DISPLAYED
-#endif//GLM_MESSAGE
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // Radians
 
@@ -693,10 +648,8 @@
 
 #if(defined(GLM_MESSAGES) && !defined(GLM_MESSAGE_SWIZZLE_DISPLAYED))
 #	define GLM_MESSAGE_SWIZZLE_DISPLAYED
-#	if(GLM_SUPPORT_SWIZZLE_OPERATOR())
+#	if defined(GLM_SWIZZLE)
 #		pragma message("GLM: Swizzling operators enabled")
-#	elif(GLM_SUPPORT_SWIZZLE_FUNCTION())
-#		pragma message("GLM: Swizzling operators supported through swizzling functions")
 #	else
 #		pragma message("GLM: Swizzling operators disabled")
 #	endif
@@ -719,7 +672,7 @@
 #	define GLM_RESTRICT
 #	define GLM_RESTRICT_VAR __restrict
 #	define GLM_CONSTEXPR
-#elif(((GLM_COMPILER & (GLM_COMPILER_GCC | GLM_COMPILER_LLVM_GCC)) && (GLM_COMPILER >= GLM_COMPILER_GCC31)) || (GLM_COMPILER & GLM_COMPILER_CLANG))
+#elif(((GLM_COMPILER & (GLM_COMPILER_GCC | GLM_COMPILER_LLVM_GCC)) && (GLM_COMPILER >= GLM_COMPILER_GCC34)) || (GLM_COMPILER & GLM_COMPILER_CLANG))
 #	define GLM_DEPRECATED __attribute__((__deprecated__))
 #	define GLM_ALIGN(x) __attribute__((aligned(x)))
 #	define GLM_ALIGNED_STRUCT(x) struct __attribute__((aligned(x)))

glm/core/type_mat2x2.hpp

@@ -65,8 +65,9 @@ namespace detail
 		//////////////////////////////////////
 		// Constructors
 		GLM_FUNC_DECL tmat2x2();
-		GLM_FUNC_DECL tmat2x2(
-			tmat2x2 const & m);
+		GLM_FUNC_DECL tmat2x2(tmat2x2<T, P> const & m);
+		template <precision Q>
+		GLM_FUNC_DECL tmat2x2(tmat2x2<T, Q> const & m);
 
 		GLM_FUNC_DECL explicit tmat2x2(
 			ctor Null);

glm/core/type_mat2x2.inl

@@ -92,6 +92,15 @@ namespace detail
 		this->value[1] = m.value[1];
 	}
 
+	template <typename T, precision P>
+	template <precision Q>
+	GLM_FUNC_QUALIFIER tmat2x2<T, P>::tmat2x2(
+		tmat2x2<T, Q> const & m)
+	{
+		this->value[0] = m.value[0];
+		this->value[1] = m.value[1];
+	}
+
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tmat2x2<T, P>::tmat2x2
 	(
@@ -133,7 +142,7 @@ namespace detail
 	}
 
 	//////////////////////////////////////
-	// Convertion constructors
+	// Conversion constructors
 	template <typename T, precision P>
 	template <typename U>
 	GLM_FUNC_DECL tmat2x2<T, P>::tmat2x2

glm/core/type_mat2x3.hpp

@@ -58,7 +58,9 @@ namespace detail
 	public:
 		// Constructors
 		GLM_FUNC_DECL tmat2x3();
-		GLM_FUNC_DECL tmat2x3(tmat2x3 const & m);
+		GLM_FUNC_DECL tmat2x3(tmat2x3<T, P> const & m);
+		template <precision Q>
+		GLM_FUNC_DECL tmat2x3(tmat2x3<T, Q> const & m);
 
 		GLM_FUNC_DECL explicit tmat2x3(
 			ctor);

glm/core/type_mat2x3.inl

@@ -92,6 +92,15 @@ namespace detail
 		this->value[1] = m.value[1];
 	}
 
+	template <typename T, precision P>
+	template <precision Q>
+	GLM_FUNC_QUALIFIER tmat2x3<T, P>::tmat2x3(
+		tmat2x3<T, Q> const & m)
+	{
+		this->value[0] = m.value[0];
+		this->value[1] = m.value[1];
+	}
+
 	template <typename T, precision P> 
 	GLM_FUNC_QUALIFIER tmat2x3<T, P>::tmat2x3
 	(
@@ -132,7 +141,7 @@ namespace detail
 	}
 
 	//////////////////////////////////////
-	// Convertion constructors
+	// Conversion constructors
 	template <typename T, precision P>
 	template <typename U>
 	GLM_FUNC_DECL tmat2x3<T, P>::tmat2x3

glm/core/type_mat2x4.hpp

@@ -58,7 +58,9 @@ namespace detail
 	public:
 		// Constructors
 		GLM_FUNC_DECL tmat2x4();
-		GLM_FUNC_DECL tmat2x4(tmat2x4 const & m);
+		GLM_FUNC_DECL tmat2x4(tmat2x4<T, P> const & m);
+		template <precision Q>
+		GLM_FUNC_DECL tmat2x4(tmat2x4<T, Q> const & m);
 
 		GLM_FUNC_DECL explicit tmat2x4(
 			ctor);

glm/core/type_mat2x4.inl

@@ -94,6 +94,15 @@ namespace detail
 		this->value[1] = m.value[1];
 	}
 
+	template <typename T, precision P>
+	template <precision Q>
+	GLM_FUNC_QUALIFIER tmat2x4<T, P>::tmat2x4(
+		tmat2x4<T, Q> const & m)
+	{
+		this->value[0] = m.value[0];
+		this->value[1] = m.value[1];
+	}
+
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tmat2x4<T, P>::tmat2x4
 	(
@@ -135,7 +144,7 @@ namespace detail
 	}
 
 	//////////////////////////////////////
-	// Convertion constructors
+	// Conversion constructors
 	template <typename T, precision P>
 	template <typename U>
 	GLM_FUNC_DECL tmat2x4<T, P>::tmat2x4

glm/core/type_mat3x2.hpp

@@ -59,6 +59,8 @@ namespace detail
 		// Constructors
 		GLM_FUNC_DECL tmat3x2();
 		GLM_FUNC_DECL tmat3x2(tmat3x2<T, P> const & m);
+		template <precision Q>
+		GLM_FUNC_DECL tmat3x2(tmat3x2<T, Q> const & m);
 
 		GLM_FUNC_DECL explicit tmat3x2(
 			ctor);

glm/core/type_mat3x2.inl

@@ -94,6 +94,16 @@ namespace detail
 		this->value[2] = m.value[2];
 	}
 
+	template <typename T, precision P>
+	template <precision Q>
+	GLM_FUNC_QUALIFIER tmat3x2<T, P>::tmat3x2(
+		tmat3x2<T, Q> const & m)
+	{
+		this->value[0] = m.value[0];
+		this->value[1] = m.value[1];
+		this->value[2] = m.value[2];
+	}
+
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tmat3x2<T, P>::tmat3x2
 	(
@@ -139,7 +149,7 @@ namespace detail
 	}
 
 	//////////////////////////////////////
-	// Convertion constructors
+	// Conversion constructors
 	template <typename T, precision P>
 	template <typename U>
 	GLM_FUNC_DECL tmat3x2<T, P>::tmat3x2

glm/core/type_mat3x3.hpp

@@ -65,6 +65,8 @@ namespace detail
 		// Constructors
 		GLM_FUNC_DECL tmat3x3();
 		GLM_FUNC_DECL tmat3x3(tmat3x3<T, P> const & m);
+		template <precision Q>
+		GLM_FUNC_DECL tmat3x3(tmat3x3<T, Q> const & m);
 
 		GLM_FUNC_DECL explicit tmat3x3(
 			ctor Null);

glm/core/type_mat3x3.inl

@@ -103,6 +103,16 @@ namespace detail
 	)
 	{}
 
+	template <typename T, precision P>
+	template <precision Q>
+	GLM_FUNC_QUALIFIER tmat3x3<T, P>::tmat3x3(
+		tmat3x3<T, Q> const & m)
+	{
+		this->value[0] = m.value[0];
+		this->value[1] = m.value[1];
+		this->value[2] = m.value[2];
+	}
+
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tmat3x3<T, P>::tmat3x3
 	(
@@ -142,7 +152,7 @@ namespace detail
 	}
 
 	//////////////////////////////////////
-	// Convertion constructors
+	// Conversion constructors
 	template <typename T, precision P>
 	template <typename U>
 	GLM_FUNC_DECL tmat3x3<T, P>::tmat3x3

glm/core/type_mat3x4.hpp

@@ -58,7 +58,9 @@ namespace detail
 	public:
 		// Constructors
 		GLM_FUNC_DECL tmat3x4();
-		GLM_FUNC_DECL tmat3x4(tmat3x4 const & m);
+		GLM_FUNC_DECL tmat3x4(tmat3x4<T, P> const & m);
+		template <precision Q>
+		GLM_FUNC_DECL tmat3x4(tmat3x4<T, Q> const & m);
 
 		GLM_FUNC_DECL explicit tmat3x4(
 			ctor Null);

glm/core/type_mat3x4.inl

@@ -94,6 +94,16 @@ namespace detail
 		this->value[2] = m.value[2];
 	}
 
+	template <typename T, precision P>
+	template <precision Q>
+	GLM_FUNC_QUALIFIER tmat3x4<T, P>::tmat3x4(
+		tmat3x4<T, Q> const & m)
+	{
+		this->value[0] = m.value[0];
+		this->value[1] = m.value[1];
+		this->value[2] = m.value[2];
+	}
+
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tmat3x4<T, P>::tmat3x4
 	(
@@ -140,7 +150,7 @@ namespace detail
 	}
 
 	//////////////////////////////////////
-	// Convertion constructors
+	// Conversion constructors
 	template <typename T, precision P>
 	template <typename U>
 	GLM_FUNC_DECL tmat3x4<T, P>::tmat3x4

glm/core/type_mat4x2.hpp

@@ -58,7 +58,9 @@ namespace detail
 	public:
 		// Constructors
 		GLM_FUNC_DECL tmat4x2();
-		GLM_FUNC_DECL tmat4x2(tmat4x2 const & m);
+		GLM_FUNC_DECL tmat4x2(tmat4x2<T, P> const & m);
+		template <precision Q>
+		GLM_FUNC_DECL tmat4x2(tmat4x2<T, Q> const & m);
 
 		GLM_FUNC_DECL explicit tmat4x2(
 			ctor Null);

glm/core/type_mat4x2.inl

@@ -87,10 +87,8 @@ namespace detail
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x2<T, P>::tmat4x2
-	(
-		tmat4x2<T, P> const & m
-	)
+	GLM_FUNC_QUALIFIER tmat4x2<T, P>::tmat4x2(
+		tmat4x2<T, P> const & m)
 	{
 		this->value[0] = m.value[0];
 		this->value[1] = m.value[1];
@@ -99,10 +97,18 @@ namespace detail
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x2<T, P>::tmat4x2
-	(
-		ctor
-	)
+	template <precision Q>
+	GLM_FUNC_QUALIFIER tmat4x2<T, P>::tmat4x2(
+		tmat4x2<T, Q> const & m)
+	{
+		this->value[0] = m.value[0];
+		this->value[1] = m.value[1];
+		this->value[2] = m.value[2];
+		this->value[3] = m.value[3];
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tmat4x2<T, P>::tmat4x2(ctor)
 	{}
 
 	template <typename T, precision P>
@@ -149,7 +155,7 @@ namespace detail
 	}
 
 	//////////////////////////////////////
-	// Convertion constructors
+	// Conversion constructors
 	template <typename T, precision P>
 	template <typename U>
 	GLM_FUNC_DECL tmat4x2<T, P>::tmat4x2

glm/core/type_mat4x3.hpp

@@ -58,7 +58,9 @@ namespace detail
 	public:
 		// Constructors
 		GLM_FUNC_DECL tmat4x3();
-		GLM_FUNC_DECL tmat4x3(tmat4x3 const & m);
+		GLM_FUNC_DECL tmat4x3(tmat4x3<T, P> const & m);
+		template <precision Q>
+		GLM_FUNC_DECL tmat4x3(tmat4x3<T, Q> const & m);
 
 		GLM_FUNC_DECL explicit tmat4x3(
 			ctor Null);

glm/core/type_mat4x3.inl

@@ -87,10 +87,8 @@ namespace detail
 	}
 
 	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat4x3<T, P>::tmat4x3
-	(
-		tmat4x3<T, P> const & m
-	)
+	GLM_FUNC_QUALIFIER tmat4x3<T, P>::tmat4x3(
+		tmat4x3<T, P> const & m)
 	{
 		this->value[0] = m.value[0];
 		this->value[1] = m.value[1];
@@ -99,17 +97,23 @@ namespace detail
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x3<T, P>::tmat4x3
-	(
-		ctor
-	)
+	template <precision Q>
+	GLM_FUNC_QUALIFIER tmat4x3<T, P>::tmat4x3(
+		tmat4x3<T, Q> const & m)
+	{
+		this->value[0] = m.value[0];
+		this->value[1] = m.value[1];
+		this->value[2] = m.value[2];
+		this->value[3] = m.value[3];
+	}
+
+	template <typename T, precision P> 
+	GLM_FUNC_QUALIFIER tmat4x3<T, P>::tmat4x3(ctor)
 	{}
 
 	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat4x3<T, P>::tmat4x3
-	(
-		value_type const & s
-	)
+	GLM_FUNC_QUALIFIER tmat4x3<T, P>::tmat4x3(
+		value_type const & s)
 	{
 		value_type const Zero(0);
 		this->value[0] = col_type(s, Zero, Zero);
@@ -149,7 +153,7 @@ namespace detail
 	}
 
 	//////////////////////////////////////
-	// Convertion constructors
+	// Conversion constructors
 	template <typename T, precision P> 
 	template <typename U> 
 	GLM_FUNC_DECL tmat4x3<T, P>::tmat4x3

glm/core/type_mat4x4.hpp

@@ -64,7 +64,9 @@ namespace detail
 	public:
 		// Constructors
 		GLM_FUNC_DECL tmat4x4();
-		GLM_FUNC_DECL tmat4x4(tmat4x4 const & m);
+		GLM_FUNC_DECL tmat4x4(tmat4x4<T, P> const & m);
+		template <precision Q>
+		GLM_FUNC_DECL tmat4x4(tmat4x4<T, Q> const & m);
 
 		GLM_FUNC_DECL explicit tmat4x4(
 			ctor Null);

glm/core/type_mat4x4.inl

@@ -98,6 +98,19 @@ namespace detail
 		this->value[3] = m.value[3];
 	}
 
+	template <typename T, precision P>
+	template <precision Q>
+	GLM_FUNC_QUALIFIER tmat4x4<T, P>::tmat4x4
+	(
+		tmat4x4<T, Q> const & m
+	)
+	{
+		this->value[0] = m.value[0];
+		this->value[1] = m.value[1];
+		this->value[2] = m.value[2];
+		this->value[3] = m.value[3];
+	}
+
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tmat4x4<T, P>::tmat4x4
 	(
@@ -162,7 +175,7 @@ namespace detail
 	}
 
 	//////////////////////////////////////
-	// Convertion constructors
+	// Conversion constructors
 	template <typename T, precision P>
 	template <typename U>
 	GLM_FUNC_DECL tmat4x4<T, P>::tmat4x4

glm/core/type_vec1.hpp

@@ -68,6 +68,8 @@ namespace detail
 
 		GLM_FUNC_DECL tvec1();
 		GLM_FUNC_DECL tvec1(tvec1<T, P> const & v);
+		template <precision Q>
+		GLM_FUNC_DECL tvec1(tvec1<T, Q> const & v);
 
 		//////////////////////////////////////
 		// Explicit basic constructors
@@ -83,14 +85,14 @@ namespace detail
 		GLM_FUNC_DECL tvec1(tref1<T, P> const & r);
 
 		//////////////////////////////////////
-		// Convertion scalar constructors
+		// Conversion scalar constructors
 
 		//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 		template <typename U>
 		GLM_FUNC_DECL explicit tvec1(U const & s);
 
 		//////////////////////////////////////
-		// Convertion vector constructors
+		// Conversion vector constructors
 		
 		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 		template <typename U, precision Q>

glm/core/type_vec1.inl

@@ -69,14 +69,16 @@ namespace detail
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tvec1<T, P>::tvec1
 	(
-		ctor
-	)
+		tvec1<T, P> const & v
+	) :
+		x(v.x)
 	{}
 
 	template <typename T, precision P>
+	template <precision Q>
 	GLM_FUNC_QUALIFIER tvec1<T, P>::tvec1
 	(
-		tvec1<T, P> const & v
+		tvec1<T, Q> const & v
 	) :
 		x(v.x)
 	{}
@@ -84,6 +86,13 @@ namespace detail
 	//////////////////////////////////////
 	// Explicit basic constructors
 
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tvec1<T, P>::tvec1
+	(
+		ctor
+	)
+	{}
+
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tvec1<T, P>::tvec1
 	(
@@ -104,7 +113,7 @@ namespace detail
 	{}
 
 	//////////////////////////////////////
-	// Convertion scalar constructors
+	// Conversion scalar constructors
 		
 	template <typename T, precision P>
 	template <typename U> 
@@ -116,7 +125,7 @@ namespace detail
 	{}
 
 	//////////////////////////////////////
-	// Convertion vector constructors
+	// Conversion vector constructors
 
 	template <typename T, precision P>
 	template <typename U, precision Q>

glm/core/type_vec2.hpp

@@ -22,7 +22,7 @@
 ///
 /// @ref core
 /// @file glm/core/type_vec2.hpp
-/// @date 2008-08-18 / 2011-06-15
+/// @date 2008-08-18 / 2013-08-27
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
 
@@ -51,14 +51,13 @@ namespace detail
 		//////////////////////////////////////
 		// Data
 
-#	if(GLM_COMPONENT == GLM_COMPONENT_CXXMS)
+#		if((GLM_LANG & GLM_LANG_CXXMS_FLAG) && defined(GLM_SWIZZLE))
 			union
 			{
 				struct{ value_type x, y; };
 				struct{ value_type r, g; };
 				struct{ value_type s, t; };
 
-#           if(defined(GLM_SWIZZLE))
 				_GLM_SWIZZLE2_2_MEMBERS(T, P, tvec2, x, y)
 				_GLM_SWIZZLE2_2_MEMBERS(T, P, tvec2, r, g)
 				_GLM_SWIZZLE2_2_MEMBERS(T, P, tvec2, s, t)
@@ -68,26 +67,16 @@ namespace detail
 				_GLM_SWIZZLE2_4_MEMBERS(T, P, tvec4, x, y)
 				_GLM_SWIZZLE2_4_MEMBERS(T, P, tvec4, r, g)
 				_GLM_SWIZZLE2_4_MEMBERS(T, P, tvec4, s, t)
-#           endif//(defined(GLM_SWIZZLE))
 			};
-#	elif(GLM_COMPONENT == GLM_COMPONENT_CXX98)
+#		else
 			union {value_type x, r, s;};
 			union {value_type y, g, t;};
 
 #			if(defined(GLM_SWIZZLE))
-			// Defines all he swizzle operator as functions
-			GLM_SWIZZLE_GEN_REF_FROM_VEC2(value_type, P, detail::tvec2, detail::tref2)
+				//GLM_SWIZZLE_GEN_REF_FROM_VEC2(value_type, P, detail::tvec2, detail::tref2)
 				GLM_SWIZZLE_GEN_VEC_FROM_VEC2(value_type, P, detail::tvec2, detail::tvec2, detail::tvec3, detail::tvec4)
 #			endif//(defined(GLM_SWIZZLE))
-#	else //(GLM_COMPONENT == GLM_COMPONENT_ONLY_XYZW)
-		value_type x, y;
-
-#		if(defined(GLM_SWIZZLE))
-			// Defines all he swizzle operator as functions
-			GLM_SWIZZLE_GEN_REF2_FROM_VEC2_SWIZZLE(value_type, P, detail::tvec2, detail::tref2, x, y)
-			GLM_SWIZZLE_GEN_VEC_FROM_VEC2_COMP(value_type, P, detail::tvec2, detail::tvec2, detail::tvec3, detail::tvec4, x, y)
-#		endif//(defined(GLM_SWIZZLE))
-#	endif//GLM_COMPONENT
+#		endif//GLM_LANG
 
 		//////////////////////////////////////
 		// Accesses
@@ -100,6 +89,8 @@ namespace detail
 
 		GLM_FUNC_DECL tvec2();
 		GLM_FUNC_DECL tvec2(tvec2<T, P> const & v);
+		template <precision Q>
+		GLM_FUNC_DECL tvec2(tvec2<T, Q> const & v);
 
 		//////////////////////////////////////
 		// Explicit basic constructors
@@ -124,7 +115,7 @@ namespace detail
 		}
 
 		//////////////////////////////////////
-		// Convertion constructors
+		// Conversion constructors
 
 		//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 		template <typename U>
@@ -137,7 +128,7 @@ namespace detail
 			V const & y);
 
 		//////////////////////////////////////
-		// Convertion vector constructors
+		// Conversion vector constructors
 
 		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 		template <typename U, precision Q>

glm/core/type_vec2.inl

@@ -64,14 +64,17 @@ namespace detail
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tvec2<T, P>::tvec2
 	(
-		ctor
-	)
+		tvec2<T, P> const & v
+	) :
+		x(v.x),
+		y(v.y)
 	{}
 
 	template <typename T, precision P>
+	template <precision Q>
 	GLM_FUNC_QUALIFIER tvec2<T, P>::tvec2
 	(
-		tvec2<T, P> const & v
+		tvec2<T, Q> const & v
 	) :
 		x(v.x),
 		y(v.y)
@@ -80,6 +83,13 @@ namespace detail
 	//////////////////////////////////////
 	// Explicit basic constructors
 
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tvec2<T, P>::tvec2
+	(
+		ctor
+	)
+	{}
+
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tvec2<T, P>::tvec2
 	(
@@ -112,7 +122,7 @@ namespace detail
 	{}
 
 	//////////////////////////////////////
-	// Convertion scalar constructors
+	// Conversion scalar constructors
 		
 	template <typename T, precision P>
 	template <typename U>
@@ -136,7 +146,7 @@ namespace detail
 	{}
 
 	//////////////////////////////////////
-	// Convertion vector constructors
+	// Conversion vector constructors
 
 	template <typename T, precision P>
 	template <typename U, precision Q>

glm/core/type_vec3.hpp

@@ -51,14 +51,13 @@ namespace detail
 		//////////////////////////////////////
 		// Data
 
-#	if(GLM_COMPONENT == GLM_COMPONENT_CXXMS)
+#		if((GLM_LANG & GLM_LANG_CXXMS_FLAG) && defined(GLM_SWIZZLE))
 			union
 			{
 				struct{ value_type x, y, z; };
 				struct{ value_type r, g, b; };
 				struct{ value_type s, t, p; };
 
-#			if(defined(GLM_SWIZZLE))
 				_GLM_SWIZZLE3_2_MEMBERS(T, P, tvec2, x, y, z)
 				_GLM_SWIZZLE3_2_MEMBERS(T, P, tvec2, r, g, b)
 				_GLM_SWIZZLE3_2_MEMBERS(T, P, tvec2, s, t, p)
@@ -68,27 +67,17 @@ namespace detail
 				_GLM_SWIZZLE3_4_MEMBERS(T, P, tvec4, x, y, z)
 				_GLM_SWIZZLE3_4_MEMBERS(T, P, tvec4, r, g, b)
 				_GLM_SWIZZLE3_4_MEMBERS(T, P, tvec4, s, t, p)
-#			endif//(defined(GLM_SWIZZLE))
 			};
-#	elif(GLM_COMPONENT == GLM_COMPONENT_CXX98)
+#		else
 			union { value_type x, r, s; };
 			union { value_type y, g, t; };
 			union { value_type z, b, p; };
 
 #			if(defined(GLM_SWIZZLE))
-			// Defines all he swizzle operator as functions
-			GLM_SWIZZLE_GEN_REF_FROM_VEC3(T, P, detail::tvec3, detail::tref2, detail::tref3)
+				//GLM_SWIZZLE_GEN_REF_FROM_VEC3(T, P, detail::tvec3, detail::tref2, detail::tref3)
 				GLM_SWIZZLE_GEN_VEC_FROM_VEC3(T, P, detail::tvec3, detail::tvec2, detail::tvec3, detail::tvec4)
 #			endif//(defined(GLM_SWIZZLE))
-#	else //(GLM_COMPONENT == GLM_COMPONENT_ONLY_XYZW)
-		value_type x, y, z;
-
-#		if(defined(GLM_SWIZZLE))
-			// Defines all he swizzle operator as functions
-			GLM_SWIZZLE_GEN_REF_FROM_VEC3_COMP(T, P, detail::tvec3, detail::tref2, detail::tref3, x, y, z)
-			GLM_SWIZZLE_GEN_VEC_FROM_VEC3_COMP(T, P, detail::tvec3, detail::tvec2, detail::tvec3, detail::tvec4, x, y, z)
-#		endif//(defined(GLM_SWIZZLE))
-#	endif//GLM_COMPONENT
+#		endif//GLM_LANG
 
 		//////////////////////////////////////
 		// Accesses
@@ -101,6 +90,8 @@ namespace detail
 
 		GLM_FUNC_DECL tvec3();
 		GLM_FUNC_DECL tvec3(tvec3<T, P> const & v);
+		template <precision Q>
+		GLM_FUNC_DECL tvec3(tvec3<T, Q> const & v);
 
 		//////////////////////////////////////
 		// Explicit basic constructors
@@ -115,7 +106,7 @@ namespace detail
 			value_type const & s3);
 
 		//////////////////////////////////////
-		// Convertion scalar constructors
+		// Conversion scalar constructors
 
 		//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 		template <typename U>
@@ -129,7 +120,7 @@ namespace detail
 			W const & z);			
 
 		//////////////////////////////////////
-		// Convertion vector constructors
+		// Conversion vector constructors
 
 		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 		template <typename A, typename B, precision Q>

glm/core/type_vec3.inl

@@ -65,14 +65,18 @@ namespace detail
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tvec3<T, P>::tvec3
 	(
-		ctor
-	)
+		tvec3<T, P> const & v
+	) :
+		x(v.x),
+		y(v.y),
+		z(v.z)
 	{}
 
 	template <typename T, precision P>
+	template <precision Q>
 	GLM_FUNC_QUALIFIER tvec3<T, P>::tvec3
 	(
-		tvec3<T, P> const & v
+		tvec3<T, Q> const & v
 	) :
 		x(v.x),
 		y(v.y),
@@ -82,6 +86,13 @@ namespace detail
 	//////////////////////////////////////
 	// Explicit basic constructors
 
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tvec3<T, P>::tvec3
+	(
+		ctor
+	)
+	{}
+
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tvec3<T, P>::tvec3
 	(
@@ -142,7 +153,7 @@ namespace detail
 	{}
 
 	//////////////////////////////////////
-	// Convertion scalar constructors
+	// Conversion scalar constructors
 		
 	template <typename T, precision P>
 	template <typename U>
@@ -169,7 +180,7 @@ namespace detail
 	{}
 
 	//////////////////////////////////////
-	// Convertion vector constructors
+	// Conversion vector constructors
 
 	template <typename T, precision P>
 	template <typename A, typename B, precision Q>

glm/core/type_vec4.hpp

@@ -51,14 +51,13 @@ namespace detail
 		//////////////////////////////////////
 		// Data
 
-#	if(GLM_COMPONENT == GLM_COMPONENT_CXXMS)
+#		if((GLM_LANG & GLM_LANG_CXXMS_FLAG) && defined(GLM_SWIZZLE))
 			union
 			{
 				struct { value_type r, g, b, a; };
 				struct { value_type s, t, p, q; };
 				struct { value_type x, y, z, w;};
 
-#			if(defined(GLM_SWIZZLE))
 				_GLM_SWIZZLE4_2_MEMBERS(T, P, tvec2, x, y, z, w)
 				_GLM_SWIZZLE4_2_MEMBERS(T, P, tvec2, r, g, b, a)
 				_GLM_SWIZZLE4_2_MEMBERS(T, P, tvec2, s, t, p, q)
@@ -68,28 +67,18 @@ namespace detail
 				_GLM_SWIZZLE4_4_MEMBERS(T, P, tvec4, x, y, z, w)
 				_GLM_SWIZZLE4_4_MEMBERS(T, P, tvec4, r, g, b, a)
 				_GLM_SWIZZLE4_4_MEMBERS(T, P, tvec4, s, t, p, q)
-#			endif//(defined(GLM_SWIZZLE))
 			};
-#	elif(GLM_COMPONENT == GLM_COMPONENT_CXX98)
+#		else
 			union { value_type x, r, s; };
 			union { value_type y, g, t; };
 			union { value_type z, b, p; };
 			union { value_type w, a, q; };
 
 #			if(defined(GLM_SWIZZLE))
-			// Defines all he swizzle operator as functions
-			GLM_SWIZZLE_GEN_REF_FROM_VEC4(T, P, detail::tvec4, detail::tref2, detail::tref3, detail::tref4)
+				//GLM_SWIZZLE_GEN_REF_FROM_VEC4(T, P, detail::tvec4, detail::tref2, detail::tref3, detail::tref4)
 				GLM_SWIZZLE_GEN_VEC_FROM_VEC4(T, P, detail::tvec4, detail::tvec2, detail::tvec3, detail::tvec4)
 #			endif//(defined(GLM_SWIZZLE))
-#	else //(GLM_COMPONENT == GLM_COMPONENT_ONLY_XYZW)
-		value_type x, y, z, w;
-
-#		if(defined(GLM_SWIZZLE))
-			// Defines all he swizzle operator as functions
-			GLM_SWIZZLE_GEN_REF_FROM_VEC4_COMP(T, P, detail::tvec4, detail::tref2, detail::tref3, detail::tref4, x, y, z, w)
-			GLM_SWIZZLE_GEN_VEC_FROM_VEC4_COMP(T, P, detail::tvec4, detail::tvec2, detail::tvec3, detail::tvec4, x, y, z, w)
-#		endif//(defined(GLM_SWIZZLE))
-#	endif//GLM_COMPONENT
+#		endif//GLM_LANG
 
 		//////////////////////////////////////
 		// Accesses
@@ -102,6 +91,8 @@ namespace detail
 
 		GLM_FUNC_DECL tvec4();
 		GLM_FUNC_DECL tvec4(type const & v);
+		template <precision Q>
+		GLM_FUNC_DECL tvec4(tvec4<T, Q> const & v);
 
 		//////////////////////////////////////
 		// Explicit basic constructors
@@ -117,13 +108,13 @@ namespace detail
 			value_type const & s3);
 
 		//////////////////////////////////////
-		// Convertion scalar constructors
+		// Conversion scalar constructors
 
-		//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		/// Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 		template <typename U>
 		GLM_FUNC_DECL explicit tvec4(
 			U const & x);
-		//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		/// Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 		template <typename A, typename B, typename C, typename D>
 		GLM_FUNC_DECL explicit tvec4(
 			A const & x,
@@ -132,7 +123,7 @@ namespace detail
 			D const & w);
 
 		//////////////////////////////////////
-		// Convertion vector constructors
+		// Conversion vector constructors
 
 		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 		template <typename A, typename B, typename C, precision Q>
@@ -232,8 +223,8 @@ namespace detail
 		// Unary arithmetic operators
 
 		GLM_FUNC_DECL tvec4<T, P> & operator= (tvec4<T, P> const & v);
-		template <typename U>
-		GLM_FUNC_DECL tvec4<T, P> & operator= (tvec4<U, P> const & v);
+		template <typename U, precision Q>
+		GLM_FUNC_DECL tvec4<T, P> & operator= (tvec4<U, Q> const & v);
 
 		template <typename U>
 		GLM_FUNC_DECL tvec4<T, P> & operator+=(U const & s);

glm/core/type_vec4.inl

@@ -72,14 +72,19 @@ namespace detail
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tvec4<T, P>::tvec4
 	(
-		ctor
-	)
+		type const & v
+	) :
+		x(v.x),
+		y(v.y),
+		z(v.z),
+		w(v.w)
 	{}
 
 	template <typename T, precision P>
+	template <precision Q>
 	GLM_FUNC_QUALIFIER tvec4<T, P>::tvec4
 	(
-		type const & v
+		tvec4<T, Q> const & v
 	) :
 		x(v.x),
 		y(v.y),
@@ -90,6 +95,13 @@ namespace detail
 	//////////////////////////////////////
 	// Explicit basic constructors
 
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tvec4<T, P>::tvec4
+	(
+		ctor
+	)
+	{}
+
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tvec4<T, P>::tvec4
 	(
@@ -237,7 +249,7 @@ namespace detail
 	{}
 
 	//////////////////////////////////////
-	// Convertion scalar constructors
+	// Conversion scalar constructors
 
 	template <typename T, precision P>
 	template <typename U>
@@ -266,8 +278,20 @@ namespace detail
 		w(value_type(w))
 	{}
 
+	template <typename T, precision P>
+	template <typename U, precision Q>
+	GLM_FUNC_QUALIFIER tvec4<T, P>::tvec4
+		(
+		tvec4<U, Q> const & v
+		) :
+		x(value_type(v.x)),
+		y(value_type(v.y)),
+		z(value_type(v.z)),
+		w(value_type(v.w))
+	{}
+
 	//////////////////////////////////////
-	// Convertion vector constructors
+	// Conversion vector constructors
 
 	template <typename T, precision P>
 	template <typename A, typename B, typename C, precision Q>
@@ -350,18 +374,6 @@ namespace detail
 		w(value_type(v2.y))
 	{}
 
-	template <typename T, precision P>
-	template <typename U, precision Q>
-	GLM_FUNC_QUALIFIER tvec4<T, P>::tvec4
-	(
-		tvec4<U, Q> const & v
-	) :
-		x(value_type(v.x)),
-		y(value_type(v.y)),
-		z(value_type(v.z)),
-		w(value_type(v.w))
-	{}
-
 	//////////////////////////////////////
 	// Unary arithmetic operators
 
@@ -379,10 +391,10 @@ namespace detail
 	}
 
 	template <typename T, precision P>
-	template <typename U> 
+	template <typename U, precision Q>
 	GLM_FUNC_QUALIFIER tvec4<T, P> & tvec4<T, P>::operator=
 	(
-		tvec4<U, P> const & v
+		tvec4<U, Q> const & v
 	)
 	{
 		this->x = T(v.x);

glm/gtc/packing.inl

@@ -304,7 +304,7 @@ namespace detail
 
 	GLM_FUNC_QUALIFIER uint8 packUnorm1x8(float const & v)
 	{
-		int8 Scaled(round(clamp(v ,-1.0f, 1.0f) * 255.0f));
+		int8 Scaled(int8(round(clamp(v, -1.0f, 1.0f) * 255.0f)));
 		detail::unorm1x8 Packing;
 		Packing.data = Scaled;
 		return Packing.pack;
@@ -337,7 +337,7 @@ namespace detail
 
 	GLM_FUNC_QUALIFIER uint8 packSnorm1x8(float const & v)
 	{
-		glm::int8 Scaled(round(clamp(v ,-1.0f, 1.0f) * 127.0f));
+		glm::int8 Scaled(int8(round(clamp(v ,-1.0f, 1.0f) * 127.0f)));
 		detail::snorm1x8 Packing;
 		Packing.data = Scaled;
 		return Packing.pack;

glm/gtx/simd_vec4.hpp

@@ -111,7 +111,7 @@ namespace detail
 			vec4 const & v);
 
 		////////////////////////////////////////
-		//// Convertion vector constructors
+		//// Conversion vector constructors
 
 		fvec4SIMD(vec2 const & v, float const & s1, float const & s2);
 		fvec4SIMD(float const & s1, vec2 const & v, float const & s2);

glm/gtx/simd_vec4.inl

@@ -59,7 +59,7 @@ GLM_FUNC_QUALIFIER fvec4SIMD::fvec4SIMD(float const v[4]) :
 //fvec4SIMD(ref4<float> const & r);
 
 //////////////////////////////////////
-// Convertion vector constructors
+// Conversion vector constructors
 
 GLM_FUNC_QUALIFIER fvec4SIMD::fvec4SIMD(vec2 const & v, float const & s1, float const & s2) :
 	Data(_mm_set_ps(s2, s1, v.y, v.x))

readme.txt

@@ -51,6 +51,7 @@ GLM 0.9.5.0: 2013-XX-XX
 - Removed GTX_ocl_type extension
 - Fixed post increment and decrement operators
 - Fixed perspective with zNear == 0 (#71)
+- Removed l-value swizzle operators
 - Clean up compiler detection code for unsupported compilers
 
 ================================================================================

test/core/core_func_swizzle.cpp

@@ -7,24 +7,11 @@
 // File    : test/core/core_func_swizzle.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-#ifndef GLM_FORCE_ONLY_XYZW
-#	define GLM_FORCE_ONLY_XYZW
-#endif
-//#ifndef GLM_FORCE_PURE
-//#	define GLM_FORCE_PURE
-//#endif
-#ifndef GLM_MESSAGES
 #define GLM_MESSAGES
-#endif
-#ifndef GLM_SWIZZLE
 #define GLM_SWIZZLE
-#endif
-#ifndef GLM_FORCE_CXX98
-#	define GLM_FORCE_CXX98
-#endif
 #include <glm/glm.hpp>
 
-int test_vec2_swizzle()
+int test_ivec2_swizzle()
 {
 	int Error = 0;
 
@@ -39,7 +26,7 @@ int test_vec2_swizzle()
 	return Error;
 }
 
-int test_vec3_swizzle()
+int test_ivec3_swizzle()
 {
 	int Error = 0;
 
@@ -54,7 +41,7 @@ int test_vec3_swizzle()
 	return Error;
 }
 
-int test_vec4_swizzle()
+int test_ivec4_swizzle()
 {
 	int Error = 0;
 
@@ -69,12 +56,33 @@ int test_vec4_swizzle()
 	return Error;
 }
 
+int test_vec4_swizzle()
+{
+	int Error = 0;
+
+	glm::vec4 A(1, 2, 3, 4);
+	glm::vec4 B = A.xyzw();
+	glm::vec4 C(0);
+	C.xyzw = B.xyzw;
+
+	float f = glm::dot(C.wzyx(), C.xyzw());
+
+	Error += A == B ? 0 : 1;
+	Error += A == C ? 0 : 1;
+
+
+	static_assert(sizeof(int) <= 4, "Test");
+	return Error;
+}
+
 int main()
 {
 	int Error = 0;
 
-	Error += test_vec2_swizzle();
-	Error += test_vec3_swizzle();
+	Error += test_ivec2_swizzle();
+	Error += test_ivec3_swizzle();
+	Error += test_ivec4_swizzle();
+
 	Error += test_vec4_swizzle();
 
 	return Error;

test/core/core_type_vec3.cpp

@@ -2,7 +2,7 @@
 // OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // Created : 2008-08-31
-// Updated : 2011-09-19
+// Updated : 2013-08-27
 // Licence : This source is under MIT License
 // File    : test/core/type_vec3.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -192,12 +192,12 @@ int test_vec3_swizzle3_2()
 	glm::vec3 v(1, 2, 3);
 	glm::vec2 u;
 
+#	if(GLM_LANG & GLM_LANG_CXXMS_FLAG)
 		// Can not assign a vec3 swizzle to a vec2
 		//u = v.xyz;    //Illegal
 		//u = v.rgb;    //Illegal
 		//u = v.stp;    //Illegal
 
-#if(GLM_SUPPORT_SWIZZLE_OPERATOR())
 		u = v.xx;       Error += (u.x == 1.0f && u.y == 1.0f) ? 0 : 1;
 		u = v.xy;       Error += (u.x == 1.0f && u.y == 2.0f) ? 0 : 1;
 		u = v.xz;       Error += (u.x == 1.0f && u.y == 3.0f) ? 0 : 1;
@@ -231,7 +231,6 @@ int test_vec3_swizzle3_2()
 		//u = v.rx;     //Illegal
 		//u = v.sy;     //Illegal
 
-
 		u = glm::vec2(1, 2);
 		v = glm::vec3(1, 2, 3);
 		//v.xx = u;     //Illegal
@@ -243,7 +242,8 @@ int test_vec3_swizzle3_2()
 		v.zx = u;       Error += (v.x == 2.0f && v.y == 1.0f && v.z == 1.0f) ? 0 : 1;
 		v.zy = u;       Error += (v.x == 2.0f && v.y == 2.0f && v.z == 1.0f) ? 0 : 1;
 		//v.zz = u;     //Illegal
-#endif//(GLM_SUPPORT_SWIZZLE_OPERATOR())
+
+#	endif//GLM_LANG
 
 	return Error;
 }
@@ -255,9 +255,9 @@ int test_vec3_swizzle3_3()
 	glm::vec3 v(1, 2, 3);
 	glm::vec3 u;
 
+#	if(GLM_LANG & GLM_LANG_CXXMS_FLAG)
 		u = v;          Error += (u.x == 1.0f && u.y == 2.0f && u.z == 3.0f) ? 0 : 1;
 
-#if(GLM_SUPPORT_SWIZZLE_OPERATOR())
 		u = v.xyz;      Error += (u.x == 1.0f && u.y == 2.0f && u.z == 3.0f) ? 0 : 1;
 		u = v.zyx;      Error += (u.x == 3.0f && u.y == 2.0f && u.z == 1.0f) ? 0 : 1;
 		u.zyx = v;      Error += (u.x == 3.0f && u.y == 2.0f && u.z == 1.0f) ? 0 : 1;
@@ -269,7 +269,8 @@ int test_vec3_swizzle3_3()
 		u = v.stp;      Error += (u.x == 1.0f && u.y == 2.0f && u.z == 3.0f) ? 0 : 1;
 		u = v.pts;      Error += (u.x == 3.0f && u.y == 2.0f && u.z == 1.0f) ? 0 : 1;
 		u.pts = v;      Error += (u.x == 3.0f && u.y == 2.0f && u.z == 1.0f) ? 0 : 1;
-#endif//(GLM_SUPPORT_SWIZZLE_OPERATOR())
+#	endif//GLM_LANG
+
 	return Error;
 }
 
@@ -282,7 +283,7 @@ int test_vec3_swizzle_operators()
 	u = glm::vec3(1, 2, 3);
 	v = glm::vec3(10, 20, 30);
 
-#if(GLM_SUPPORT_SWIZZLE_OPERATOR())
+#	if(GLM_LANG & GLM_LANG_CXXMS_FLAG)
 		// Swizzle, swizzle binary operators
 		q = u.xyz + v.xyz;          Error += (q == (u + v)) ? 0 : 1;
 		q = (u.zyx + v.zyx).zyx;    Error += (q == (u + v)) ? 0 : 1;
@@ -304,7 +305,7 @@ int test_vec3_swizzle_operators()
 		q = (u.xyz * v);            Error += (q == (u * v)) ? 0 : 1;
 		q = (u.xxx * v);            Error += (q == u.x * v) ? 0 : 1;
 		q = (u.xyz / v);            Error += (q == (u / v)) ? 0 : 1;
-#endif//(GLM_SUPPORT_SWIZZLE_OPERATOR())
+#	endif//GLM_LANG
 
 	// Compile errors
 	//q = (u.yz * v.xyz);
@@ -324,7 +325,6 @@ int test_vec3_swizzle_functions()
 	// glm::dot(u.xy, v.xy);        <--- Compile error
 	// glm::dot(u.xy(), v.xy());    <--- Compiles correctly
 
-#if(GLM_SUPPORT_SWIZZLE_OPERATOR())
 	float r;
 
 	// vec2
@@ -351,7 +351,6 @@ int test_vec3_swizzle_functions()
 	r = glm::dot(s, t);                 Error += (int(r) == 300) ? 0 : 1;
 	r = glm::dot(s.xyzw(), t.xyzw());   Error += (int(r) == 300) ? 0 : 1;
 	r = glm::dot(s.xyz(), t.xyz());     Error += (int(r) == 140) ? 0 : 1;
-#endif//(GLM_SUPPORT_SWIZZLE_OPERATOR())
 
 	return Error;
 }
@@ -360,9 +359,9 @@ int test_vec3_swizzle_partial()
 {
 	int Error = 0;
 
-#if(GLM_SUPPORT_SWIZZLE_OPERATOR())
 	glm::vec3 A(1, 2, 3);
 
+#	if(GLM_LANG & GLM_LANG_CXXMS_FLAG)
 	{
 		glm::vec3 B(A.xy, 3.0f);
 		Error += A == B ? 0 : 1;
@@ -377,7 +376,7 @@ int test_vec3_swizzle_partial()
 		glm::vec3 B(A.xyz);
 		Error += A == B ? 0 : 1;
 	}
-#endif//(GLM_SUPPORT_SWIZZLE_OPERATOR())
+#	endif//GLM_LANG
 
 	return Error;
 }

test/core/core_type_vec4.cpp

@@ -216,7 +216,7 @@ int test_vec4_swizzle_partial()
 
 	glm::vec4 A(1, 2, 3, 4);
 
-#if(GLM_SUPPORT_SWIZZLE_OPERATOR())
+#	if((GLM_LANG & GLM_LANG_CXXMS_FLAG) && defined(GLM_SWIZZLE))
 	{
 		glm::vec4 B(A.xy, A.zw);
 		Error += A == B ? 0 : 1;
@@ -242,7 +242,7 @@ int test_vec4_swizzle_partial()
 		glm::vec4 B(1.0f, A.yzw);
 		Error += A == B ? 0 : 1;
 	}
-#endif//(GLM_SUPPORT_SWIZZLE_OPERATOR())
+#	endif//GLM_LANG
 
 	return Error;
 }

test/gtc/gtc_packing.cpp

@@ -31,25 +31,6 @@
 #include <cstdio>
 #include <vector>
 
-void print_bits(glm::half const & s)
-{
-    union
-    {
-        glm::detail::hdata h;
-        unsigned short i;
-    } uif;
-    
-    uif.h = s._data();
-    
-    printf("f16: ");
-    for(std::size_t j = sizeof(s) * 8; j > 0; --j)
-    {
-        if(j == 10 || j == 15)
-            printf(" ");
-        printf("%d", (uif.i & (1 << (j - 1))) ? 1 : 0);
-    }
-}
-
 void print_bits(float const & s)
 {
 	union
@@ -96,43 +77,12 @@ void print_value(float const & s)
 	printf("%2.5f, ", s);
 	print_bits(s);
 	printf(", ");
-    print_bits(glm::half(s));
-//    printf(", ");
 //	print_11bits(detail::floatTo11bit(s));
 //	printf(", ");
 //	print_10bits(detail::floatTo10bit(s));
 	printf("\n");
 }
 
-int test_half()
-{
-    int Error = 0;
-
-    print_value(0.0f);
-    print_value(0.1f);
-    print_value(0.2f);
-    print_value(0.3f);
-    print_value(0.4f);
-    print_value(0.5f);
-    print_value(0.6f);
-    print_value(1.0f);
-    print_value(1.1f);
-    print_value(1.2f);
-    print_value(1.3f);
-    print_value(1.4f);
-    print_value(1.5f);
-    print_value(1.6f);
-    print_value(2.0f);
-    print_value(2.1f);
-    print_value(2.2f);
-    print_value(2.3f);
-    print_value(2.4f);
-    print_value(2.5f);
-    print_value(2.6f);
-    
-    return Error;
-}
-
 int test_Half1x16()
 {
 	int Error = 0;

test/gtc/gtc_type_precision.cpp

@@ -836,12 +836,31 @@ static int test_quat_precision()
 	return Error;
 }
 
+static int test_fvec_conversion()
+{
+	int Error(0);
+
+	{
+		glm::highp_vec4 a = glm::vec4(1, 2, 3, 4);
+		glm::mediump_vec4 b = glm::vec4(1, 2, 3, 4);
+		glm::lowp_vec4 c = b;
+		glm::mediump_vec4 d = c;
+		glm::lowp_ivec4 e = glm::ivec4(d);
+		glm::lowp_ivec3 f = glm::ivec3(e);
+
+		Error += glm::all(glm::equal(b, d)) ? 0 : 1;
+	}
+
+	return Error;
+}
+
 int main()
 {
 	int Error(0);
 	Error += test_scalar_size();
 	Error += test_fvec_size();
 	Error += test_fvec_precision();
+	Error += test_fvec_conversion();
 	Error += test_dvec_precision();
 	Error += test_ivec_size();
 	Error += test_ivec_precision();