diff -ur glm.org/glm/core/_detail.hpp glm/glm/core/_detail.hpp
--- glm.org/glm/core/_detail.hpp	2013-12-09 02:05:30.115442079 +0100
+++ glm/glm/core/_detail.hpp	2013-12-09 02:06:33.749941584 +0100
@@ -136,12 +136,12 @@
 			i(0)
 		{}
 
-		GLM_FUNC_QUALIFIER uif32(float f) :
-			f(f)
+		GLM_FUNC_QUALIFIER uif32(float f_) :
+			f(f_)
 		{}
 
-		GLM_FUNC_QUALIFIER uif32(unsigned int i) :
-			i(i)
+		GLM_FUNC_QUALIFIER uif32(unsigned int i_) :
+			i(i_)
 		{}
 
 		float f;
@@ -154,12 +154,12 @@
 			i(0)
 		{}
 
-		GLM_FUNC_QUALIFIER uif64(double f) :
-			f(f)
+		GLM_FUNC_QUALIFIER uif64(double f_) :
+			f(f_)
 		{}
 
-		GLM_FUNC_QUALIFIER uif64(uint64 i) :
-			i(i)
+		GLM_FUNC_QUALIFIER uif64(uint64 i_) :
+			i(i_)
 		{}
 
 		double f;
diff -ur glm.org/glm/core/type_vec1.hpp glm/glm/core/type_vec1.hpp
--- glm.org/glm/core/type_vec1.hpp	2013-12-08 17:04:59.706365245 +0100
+++ glm/glm/core/type_vec1.hpp	2013-12-08 17:07:20.079840510 +0100
@@ -86,19 +86,19 @@
 		GLM_FUNC_DECL explicit tvec1(
 			ctor);
 		GLM_FUNC_DECL explicit tvec1(
-			value_type const & s);
+			value_type const & s_);
 
 		//////////////////////////////////////
 		// Swizzle constructors
 
-		GLM_FUNC_DECL tvec1(tref1<T> const & r);
+		GLM_FUNC_DECL tvec1(tref1<T> const & r_);
 
 		//////////////////////////////////////
 		// Convertion 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);
+		GLM_FUNC_DECL explicit tvec1(U const & s_);
 
 		//////////////////////////////////////
 		// Convertion vector constructors
@@ -121,19 +121,19 @@
 		GLM_FUNC_DECL tvec1<T> & operator= (tvec1<U> const & v);
 
 		template <typename U> 
-		GLM_FUNC_DECL tvec1<T> & operator+=(U const & s);
+		GLM_FUNC_DECL tvec1<T> & operator+=(U const & s_);
 		template <typename U> 
 		GLM_FUNC_DECL tvec1<T> & operator+=(tvec1<U> const & v);
 		template <typename U> 
-		GLM_FUNC_DECL tvec1<T> & operator-=(U const & s);
+		GLM_FUNC_DECL tvec1<T> & operator-=(U const & s_);
 		template <typename U> 
 		GLM_FUNC_DECL tvec1<T> & operator-=(tvec1<U> const & v);
 		template <typename U> 
-		GLM_FUNC_DECL tvec1<T> & operator*=(U const & s);
+		GLM_FUNC_DECL tvec1<T> & operator*=(U const & s_);
 		template <typename U> 
 		GLM_FUNC_DECL tvec1<T> & operator*=(tvec1<U> const & v);
 		template <typename U> 
-		GLM_FUNC_DECL tvec1<T> & operator/=(U const & s);
+		GLM_FUNC_DECL tvec1<T> & operator/=(U const & s_);
 		template <typename U> 
 		GLM_FUNC_DECL tvec1<T> & operator/=(tvec1<U> const & v);
 		GLM_FUNC_DECL tvec1<T> & operator++();
@@ -143,27 +143,27 @@
 		// Unary bit operators
 
 		template <typename U> 
-		GLM_FUNC_DECL tvec1<T> & operator%=(U const & s);
+		GLM_FUNC_DECL tvec1<T> & operator%=(U const & s_);
 		template <typename U> 
 		GLM_FUNC_DECL tvec1<T> & operator%=(tvec1<U> const & v);
 		template <typename U> 
-		GLM_FUNC_DECL tvec1<T> & operator&=(U const & s);
+		GLM_FUNC_DECL tvec1<T> & operator&=(U const & s_);
 		template <typename U> 
 		GLM_FUNC_DECL tvec1<T> & operator&=(tvec1<U> const & v);
 		template <typename U> 
-		GLM_FUNC_DECL tvec1<T> & operator|=(U const & s);
+		GLM_FUNC_DECL tvec1<T> & operator|=(U const & s_);
 		template <typename U> 
 		GLM_FUNC_DECL tvec1<T> & operator|=(tvec1<U> const & v);
 		template <typename U> 
-		GLM_FUNC_DECL tvec1<T> & operator^=(U const & s);
+		GLM_FUNC_DECL tvec1<T> & operator^=(U const & s_);
 		template <typename U> 
 		GLM_FUNC_DECL tvec1<T> & operator^=(tvec1<U> const & v);
 		template <typename U> 
-		GLM_FUNC_DECL tvec1<T> & operator<<=(U const & s);
+		GLM_FUNC_DECL tvec1<T> & operator<<=(U const & s_);
 		template <typename U> 
 		GLM_FUNC_DECL tvec1<T> & operator<<=(tvec1<U> const & v);
 		template <typename U> 
-		GLM_FUNC_DECL tvec1<T> & operator>>=(U const & s);
+		GLM_FUNC_DECL tvec1<T> & operator>>=(U const & s_);
 		template <typename U> 
 		GLM_FUNC_DECL tvec1<T> & operator>>=(tvec1<U> const & v);
 
diff -ur glm.org/glm/core/type_vec1.inl glm/glm/core/type_vec1.inl
--- glm.org/glm/core/type_vec1.inl	2013-12-08 17:04:59.707365220 +0100
+++ glm/glm/core/type_vec1.inl	2013-12-08 17:07:20.081840460 +0100
@@ -87,9 +87,9 @@
 	template <typename T>
 	GLM_FUNC_QUALIFIER tvec1<T>::tvec1
 	(
-		value_type const & s
+		value_type const & s_
 	) :
-		x(s)
+		x(s_)
 	{}
 
 	//////////////////////////////////////
@@ -98,9 +98,9 @@
 	template <typename T>
 	GLM_FUNC_QUALIFIER tvec1<T>::tvec1
 	(
-		tref1<T> const & r
+		tref1<T> const & r_
 	) :
-		x(r.x)
+		x(r_.x)
 	{}
 
 	//////////////////////////////////////
@@ -110,9 +110,9 @@
 	template <typename U> 
 	GLM_FUNC_QUALIFIER tvec1<T>::tvec1
 	(
-		U const & s
+		U const & s_
 	) :
-		x(value_type(s))
+		x(value_type(s_))
 	{}
 
 	//////////////////////////////////////
@@ -173,10 +173,10 @@
 	template <typename U> 
 	GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator+=
 	(
-		U const & s
+		U const & s_
 	)
 	{
-		this->x += T(s);
+		this->x += T(s_);
 		return *this;
 	}
 
@@ -195,10 +195,10 @@
 	template <typename U> 
 	GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator-=
 	(
-		U const & s
+		U const & s_
 	)
 	{
-		this->x -= T(s);
+		this->x -= T(s_);
 		return *this;
 	}
 
@@ -217,10 +217,10 @@
 	template <typename U> 
 	GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator*=
 	(
-		U const & s
+		U const & s_
 	)
 	{
-		this->x *= T(s);
+		this->x *= T(s_);
 		return *this;
 	}
 
@@ -239,10 +239,10 @@
 	template <typename U> 
 	GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator/=
 	(
-		U const & s
+		U const & s_
 	)
 	{
-		this->x /= T(s);
+		this->x /= T(s_);
 		return *this;
 	}
 
@@ -301,10 +301,10 @@
 	template <typename U> 
 	GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator%=
 	(
-		U const & s
+		U const & s_
 	)
 	{
-		this->x %= T(s);
+		this->x %= T(s_);
 		return *this;
 	}
 
@@ -323,10 +323,10 @@
 	template <typename U> 
 	GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator&=
 	(
-		U const & s
+		U const & s_
 	)
 	{
-		this->x &= T(s);
+		this->x &= T(s_);
 		return *this;
 	}
 
@@ -345,10 +345,10 @@
 	template <typename U> 
 	GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator|=
 	(
-		U const & s
+		U const & s_
 	)
 	{
-		this->x |= T(s);
+		this->x |= T(s_);
 		return *this;
 	}
 
@@ -367,10 +367,10 @@
 	template <typename U> 
 	GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator^=
 	(
-		U const & s
+		U const & s_
 	)
 	{
-		this->x ^= T(s);
+		this->x ^= T(s_);
 		return *this;
 	}
 
@@ -389,10 +389,10 @@
 	template <typename U> 
 	GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator<<=
 	(
-		U const & s
+		U const & s_
 	)
 	{
-		this->x <<= T(s);
+		this->x <<= T(s_);
 		return *this;
 	}
 
@@ -411,10 +411,10 @@
 	template <typename U> 
 	GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator>>=
 	(
-		U const & s
+		U const & s_
 	)
 	{
-		this->x >>= T(s);
+		this->x >>= T(s_);
 		return *this;
 	}
 
@@ -434,21 +434,21 @@
 
 	template <typename T>
 	GLM_FUNC_QUALIFIER T 
-	tvec1<T>::swizzle(comp x) const
+	tvec1<T>::swizzle(comp x_) const
 	{
-		return (*this)[x];
+		return (*this)[x_];
 	}
 
 	template <typename T>
 	GLM_FUNC_QUALIFIER tvec2<T> 
 	tvec1<T>::swizzle
 	(
-		comp x, 
+		comp x_, 
 		comp y
 	) const
 	{
 		return tvec2<T>(
-			(*this)[x],
+			(*this)[x_],
 			(*this)[y]);
 	}
 
@@ -456,13 +456,13 @@
 	GLM_FUNC_QUALIFIER tvec3<T> 
 	tvec1<T>::swizzle
 	(
-		comp x, 
+		comp x_, 
 		comp y, 
 		comp z
 	) const
 	{
 		return tvec3<T>(
-			(*this)[x],
+			(*this)[x_],
 			(*this)[y],
 			(*this)[z]);
 	}
@@ -471,14 +471,14 @@
 	GLM_FUNC_QUALIFIER tvec4<T> 
 	tvec1<T>::swizzle
 	(
-		comp x, 
+		comp x_, 
 		comp y, 
 		comp z, 
 		comp w
 	) const
 	{
 		return tvec4<T>(
-			(*this)[x],
+			(*this)[x_],
 			(*this)[y],
 			(*this)[z],
 			(*this)[w]);
@@ -488,11 +488,11 @@
 	GLM_FUNC_QUALIFIER tref1<T> 
 	tvec1<T>::swizzle
 	(
-		comp x
+		comp x_
 	)
 	{
 		return tref1<T>(
-			(*this)[x]);
+			(*this)[x_]);
 	}
 
 	//////////////////////////////////////
@@ -502,22 +502,22 @@
 	GLM_FUNC_QUALIFIER tvec1<T> operator+ 
 	(
 		tvec1<T> const & v, 
-		typename tvec1<T>::value_type const & s
+		typename tvec1<T>::value_type const & s_
 	)
 	{
 		return tvec1<T>(
-			v.x + s);
+			v.x + s_);
 	}
 
 	template <typename T> 
 	GLM_FUNC_QUALIFIER tvec1<T> operator+ 
 	(
-		typename tvec1<T>::value_type const & s, 
+		typename tvec1<T>::value_type const & s_, 
 		tvec1<T> const & v
 	)
 	{
 		return tvec1<T>(
-			s + v.x);
+			s_ + v.x);
 	}
 
 	template <typename T> 
@@ -536,22 +536,22 @@
 	GLM_FUNC_QUALIFIER tvec1<T> operator- 
 	(
 		tvec1<T> const & v, 
-		typename tvec1<T>::value_type const & s
+		typename tvec1<T>::value_type const & s_
 	)
 	{
 		return tvec1<T>(
-			v.x - s);
+			v.x - s_);
 	}
 
 	template <typename T> 
 	GLM_FUNC_QUALIFIER tvec1<T> operator- 
 	(
-		typename tvec1<T>::value_type const & s, 
+		typename tvec1<T>::value_type const & s_,
 		tvec1<T> const & v
 	)
 	{
 		return tvec1<T>(
-			s - v.x);
+			s_ - v.x);
 	}
 
 	template <typename T> 
@@ -570,22 +570,22 @@
 	GLM_FUNC_QUALIFIER tvec1<T> operator* 
 	(
 		tvec1<T> const & v, 
-		typename tvec1<T>::value_type const & s
+		typename tvec1<T>::value_type const & s_
 	)
 	{
 		return tvec1<T>(
-			v.x * s);
+			v.x * s_);
 	}
 
 	template <typename T> 
 	GLM_FUNC_QUALIFIER tvec1<T> operator* 
 	(
-		typename tvec1<T>::value_type const & s, 
+		typename tvec1<T>::value_type const & s_,
 		tvec1<T> const & v
 	)
 	{
 		return tvec1<T>(
-			s * v.x);
+			s_ * v.x);
 	}
 
 	template <typename T> 
@@ -604,22 +604,22 @@
 	GLM_FUNC_QUALIFIER tvec1<T> operator/ 
 	(
 		tvec1<T> const & v, 
-		typename tvec1<T>::value_type const & s
+		typename tvec1<T>::value_type const & s_
 	)
 	{
 		return tvec1<T>(
-			v.x / s);
+			v.x / s_);
 	}
 
 	template <typename T> 
 	GLM_FUNC_QUALIFIER tvec1<T> operator/ 
 	(
-		typename tvec1<T>::value_type const & s, 
+		typename tvec1<T>::value_type const & s_,
 		tvec1<T> const & v
 	)
 	{
 		return tvec1<T>(
-			s / v.x);
+			s_ / v.x);
 	}
 
 	template <typename T> 
@@ -673,22 +673,22 @@
 	GLM_FUNC_QUALIFIER tvec1<T> operator% 
 	(
 		tvec1<T> const & v, 
-		typename tvec1<T>::value_type const & s
+		typename tvec1<T>::value_type const & s_
 	)
 	{
 		return tvec1<T>(
-			v.x % s);
+			v.x % s_);
 	}
 
 	template <typename T>
 	GLM_FUNC_QUALIFIER tvec1<T> operator% 
 	(
-		typename tvec1<T>::value_type const & s, 
+		typename tvec1<T>::value_type const & s_,
 		tvec1<T> const & v
 	)
 	{
 		return tvec1<T>(
-			s % v.x);
+			s_ % v.x);
 	}
 
 	template <typename T>
@@ -706,22 +706,22 @@
 	GLM_FUNC_QUALIFIER tvec1<T> operator& 
 	(
 		tvec1<T> const & v, 
-		typename tvec1<T>::value_type const & s
+		typename tvec1<T>::value_type const & s_
 	)
 	{
 		return tvec1<T>(
-			v.x & s);
+			v.x & s_);
 	}
 
 	template <typename T>
 	GLM_FUNC_QUALIFIER tvec1<T> operator& 
 	(
-		typename tvec1<T>::value_type const & s, 
+		typename tvec1<T>::value_type const & s_,
 		tvec1<T> const & v
 	)
 	{
 		return tvec1<T>(
-			s & v.x);
+			s_ & v.x);
 	}
 
 	template <typename T>
@@ -739,22 +739,22 @@
 	GLM_FUNC_QUALIFIER tvec1<T> operator| 
 	(
 		tvec1<T> const & v, 
-		typename tvec1<T>::value_type const & s
+		typename tvec1<T>::value_type const & s_
 	)
 	{
 		return tvec1<T>(
-			v.x | s);
+			v.x | s_);
 	}
 
 	template <typename T>
 	GLM_FUNC_QUALIFIER tvec1<T> operator| 
 	(
-		typename tvec1<T>::value_type const & s, 
+		typename tvec1<T>::value_type const & s_,
 		tvec1<T> const & v
 	)
 	{
 		return tvec1<T>(
-			s | v.x);
+			s_ | v.x);
 	}
 
 	template <typename T>
@@ -772,22 +772,22 @@
 	GLM_FUNC_QUALIFIER tvec1<T> operator^ 
 	(
 		tvec1<T> const & v, 
-		typename tvec1<T>::value_type const & s
+		typename tvec1<T>::value_type const & s_
 	)
 	{
 		return tvec1<T>(
-			v.x ^ s);
+			v.x ^ s_);
 	}
 
 	template <typename T>
 	GLM_FUNC_QUALIFIER tvec1<T> operator^ 
 	(
-		typename tvec1<T>::value_type const & s, 
+		typename tvec1<T>::value_type const & s_,
 		tvec1<T> const & v
 	)
 	{
 		return tvec1<T>(
-			s ^ v.x);
+			s_ ^ v.x);
 	}
 
 	template <typename T>
@@ -805,22 +805,22 @@
 	GLM_FUNC_QUALIFIER tvec1<T> operator<< 
 	(
 		tvec1<T> const & v, 
-		typename tvec1<T>::value_type const & s
+		typename tvec1<T>::value_type const & s_
 	)
 	{
 		return tvec1<T>(
-			v.x << s);
+			v.x << s_);
 	}
 
 	template <typename T>
 	GLM_FUNC_QUALIFIER tvec1<T> operator<< 
 	(
-		typename tvec1<T>::value_type const & s, 
+		typename tvec1<T>::value_type const & s_,
 		tvec1<T> const & v
 	)
 	{
 		return tvec1<T>(
-			s << v.x);
+			s_ << v.x);
 	}
 
 	template <typename T>
@@ -838,22 +838,22 @@
 	GLM_FUNC_QUALIFIER tvec1<T> operator>> 
 	(
 		tvec1<T> const & v, 
-		typename tvec1<T>::value_type const & s
+		typename tvec1<T>::value_type const & s_
 	)
 	{
 		return tvec1<T>(
-			v.x >> s);
+			v.x >> s_);
 	}
 
 	template <typename T>
 	GLM_FUNC_QUALIFIER tvec1<T> operator>> 
 	(
-		typename tvec1<T>::value_type const & s, 
+		typename tvec1<T>::value_type const & s_,
 		tvec1<T> const & v
 	)
 	{
 		return tvec1<T>(
-			s >> v.x);
+			s_ >> v.x);
 	}
 
 	template <typename T>
@@ -883,9 +883,9 @@
 	template <typename T> 
 	GLM_FUNC_QUALIFIER tref1<T>::tref1
 	(
-		T & x
+		T & x_
 	) :
-		x(x)
+		x(x_)
 	{}
 
 	template <typename T> 
diff -ur glm.org/glm/core/type_vec2.inl glm/glm/core/type_vec2.inl
--- glm.org/glm/core/type_vec2.inl	2013-12-08 17:04:59.705365270 +0100
+++ glm/glm/core/type_vec2.inl	2013-12-08 17:07:20.078840535 +0100
@@ -91,10 +91,10 @@
 	template <typename T>
 	GLM_FUNC_QUALIFIER tvec2<T>::tvec2
 	(
-		value_type const & s
+		value_type const & s_
 	) :
-		x(s),
-		y(s)
+		x(s_),
+		y(s_)
 	{}
 
 	template <typename T>
@@ -113,10 +113,10 @@
 	template <typename T>
 	GLM_FUNC_QUALIFIER tvec2<T>::tvec2
 	(
-		tref2<T> const & r
+		tref2<T> const & r_
 	) :
-		x(r.x),
-		y(r.y)
+		x(r_.x),
+		y(r_.y)
 	{}
 
 	//////////////////////////////////////
@@ -126,10 +126,10 @@
 	template <typename U> 
 	GLM_FUNC_QUALIFIER tvec2<T>::tvec2
 	(
-		U const & x
+		U const & x_
 	) :
-		x(value_type(x)),
-		y(value_type(x))
+		x(value_type(x_)),
+		y(value_type(x_))
 	{}
 
 	template <typename T>
@@ -204,10 +204,10 @@
 
 	template <typename T>
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator+=(U s)
+	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator+=(U s_)
 	{
-		this->x += T(s);
-		this->y += T(s);
+		this->x += T(s_);
+		this->y += T(s_);
 		return *this;
 	}
 
@@ -225,10 +225,10 @@
 
 	template <typename T>
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator-=(U s)
+	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator-=(U s_)
 	{
-		this->x -= T(s);
-		this->y -= T(s);
+		this->x -= T(s_);
+		this->y -= T(s_);
 		return *this;
 	}
 
@@ -246,10 +246,10 @@
 
 	template <typename T>
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator*=(U s)
+	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator*=(U s_)
 	{
-		this->x *= T(s);
-		this->y *= T(s);
+		this->x *= T(s_);
+		this->y *= T(s_);
 		return *this;
 	}
 
@@ -267,10 +267,10 @@
 
 	template <typename T>
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator/=(U s)
+	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator/=(U s_)
 	{
-		this->x /= T(s);
-		this->y /= T(s);
+		this->x /= T(s_);
+		this->y /= T(s_);
 		return *this;
 	}
 
@@ -330,10 +330,10 @@
 
 	template <typename T>
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator%=(U s)
+	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator%=(U s_)
 	{
-		this->x %= T(s);
-		this->y %= T(s);
+		this->x %= T(s_);
+		this->y %= T(s_);
 		return *this;
 	}
 
@@ -351,10 +351,10 @@
 
 	template <typename T>
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator&=(U s)
+	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator&=(U s_)
 	{
-		this->x &= T(s);
-		this->y &= T(s);
+		this->x &= T(s_);
+		this->y &= T(s_);
 		return *this;
 	}
 
@@ -372,10 +372,10 @@
 
 	template <typename T>
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator|=(U s)
+	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator|=(U s_)
 	{
-		this->x |= T(s);
-		this->y |= T(s);
+		this->x |= T(s_);
+		this->y |= T(s_);
 		return *this;
 	}
 
@@ -393,10 +393,10 @@
 
 	template <typename T>
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator^=(U s)
+	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator^=(U s_)
 	{
-		this->x ^= T(s);
-		this->y ^= T(s);
+		this->x ^= T(s_);
+		this->y ^= T(s_);
 		return *this;
 	}
 
@@ -414,10 +414,10 @@
 
 	template <typename T>
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator<<=(U s)
+	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator<<=(U s_)
 	{
-		this->x <<= T(s);
-		this->y <<= T(s);
+		this->x <<= T(s_);
+		this->y <<= T(s_);
 		return *this;
 	}
 
@@ -435,10 +435,10 @@
 
 	template <typename T>
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator>>=(U s)
+	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator>>=(U s_)
 	{
-		this->x >>= T(s);
-		this->y >>= T(s);
+		this->x >>= T(s_);
+		this->y >>= T(s_);
 		return *this;
 	}
 
@@ -460,50 +460,50 @@
 	template <typename T>
 	GLM_FUNC_QUALIFIER typename tvec2<T>::value_type tvec2<T>::swizzle
 	(
-		comp x
+		comp x_
 	) const
 	{
-		return (*this)[x];
+		return (*this)[x_];
 	}
 
 	template <typename T>
 	GLM_FUNC_QUALIFIER tvec2<T> tvec2<T>::swizzle
 	(
-		comp x, 
-		comp y
+		comp x_, 
+		comp y_
 	) const
 	{
 		return tvec2<T>(
-			(*this)[x],
-			(*this)[y]);
+			(*this)[x_],
+			(*this)[y_]);
 	}
 
 	template <typename T>
 	GLM_FUNC_QUALIFIER tvec3<T> tvec2<T>::swizzle
 	(
-		comp x, 
-		comp y, 
+		comp x_, 
+		comp y_, 
 		comp z
 	) const
 	{
 		return tvec3<T>(
-			(*this)[x],
-			(*this)[y],
+			(*this)[x_],
+			(*this)[y_],
 			(*this)[z]);
 	}
 
 	template <typename T>
 	GLM_FUNC_QUALIFIER tvec4<T> tvec2<T>::swizzle
 	(
-		comp x, 
-		comp y, 
+		comp x_, 
+		comp y_, 
 		comp z, 
 		comp w
 	) const
 	{
 		return tvec4<T>(
-			(*this)[x],
-			(*this)[y],
+			(*this)[x_],
+			(*this)[y_],
 			(*this)[z],
 			(*this)[w]);
 	}
@@ -511,13 +511,13 @@
 	template <typename T>
 	GLM_FUNC_QUALIFIER tref2<T> tvec2<T>::swizzle
 	(
-		comp x, 
-		comp y
+		comp x_, 
+		comp y_
 	)
 	{
 		return tref2<T>(
-			(*this)[x],
-			(*this)[y]);
+			(*this)[x_],
+			(*this)[y_]);
 	}
 
 	//////////////////////////////////////
@@ -527,12 +527,12 @@
 	GLM_FUNC_QUALIFIER tvec2<T> operator+ 
 	(
 		tvec2<T> const & v, 
-		T const & s
+		T const & s_
 	)
 	{
 		return tvec2<T>(
-			v.x + T(s),
-			v.y + T(s));
+			v.x + T(s_),
+			v.y + T(s_));
 	}
 
 	template <typename T> 
@@ -942,11 +942,11 @@
 	template <typename T> 
 	tref2<T>::tref2
 	(
-		T & x, 
-		T & y
+		T & x_, 
+		T & y_
 	) :
-		x(x),
-		y(y)
+		x(x_),
+		y(y_)
 	{}
 
 	template <typename T> 
diff -ur glm.org/glm/core/type_vec3.hpp glm/glm/core/type_vec3.hpp
--- glm.org/glm/core/type_vec3.hpp	2013-12-08 17:04:59.707365220 +0100
+++ glm/glm/core/type_vec3.hpp	2013-12-08 17:07:20.081840460 +0100
@@ -170,15 +170,15 @@
 		}
 
 		template <int E0, int E1>
-		GLM_FUNC_DECL tvec3(glm::detail::swizzle<2, T, tvec2<T>, E0, E1, -1, -2> const & v, T const & s)
+		GLM_FUNC_DECL tvec3(glm::detail::swizzle<2, T, tvec2<T>, E0, E1, -1, -2> const & v, T const & s_)
 		{
-			*this = tvec3<T>(v(), s);
+			*this = tvec3<T>(v(), s_);
 		}
 
 		template <int E0, int E1>
-		GLM_FUNC_DECL tvec3(T const & s, glm::detail::swizzle<2, T, tvec2<T>, E0, E1, -1, -2> const & v)
+		GLM_FUNC_DECL tvec3(T const & s_, glm::detail::swizzle<2, T, tvec2<T>, E0, E1, -1, -2> const & v)
 		{
-			*this = tvec3<T>(s, v());
+			*this = tvec3<T>(s_, v());
 		}
 
 		//////////////////////////////////////
diff -ur glm.org/glm/core/type_vec3.inl glm/glm/core/type_vec3.inl
--- glm.org/glm/core/type_vec3.inl	2013-12-08 17:04:59.706365245 +0100
+++ glm/glm/core/type_vec3.inl	2013-12-08 17:07:20.079840510 +0100
@@ -93,11 +93,11 @@
 	template <typename T>
 	GLM_FUNC_QUALIFIER tvec3<T>::tvec3
 	(
-		value_type const & s
+		value_type const & s_
 	) :
-		x(s),
-		y(s),
-		z(s)
+		x(s_),
+		y(s_),
+		z(s_)
 	{}
 
 	template <typename T>
@@ -118,11 +118,11 @@
 	template <typename T>
 	GLM_FUNC_QUALIFIER tvec3<T>::tvec3
 	(
-		tref3<T> const & r
+		tref3<T> const & r_
 	) :
-		x(r.x),
-		y(r.y),
-		z(r.z)
+		x(r_.x),
+		y(r_.y),
+		z(r_.z)
 	{}
 
 	template <typename T>
@@ -130,21 +130,21 @@
 	GLM_FUNC_QUALIFIER tvec3<T>::tvec3
 	(
 		tref2<A> const & v, 
-		B const & s
+		B const & s_
 	) : 
 		x(value_type(v.x)),
 		y(value_type(v.y)),
-		z(value_type(s))
+		z(value_type(s_))
 	{}
 
 	template <typename T>
 	template <typename A, typename B> 
 	GLM_FUNC_QUALIFIER tvec3<T>::tvec3
 	(
-		A const & s, 
+		A const & s_, 
 		tref2<B> const & v
 	) :
-		x(value_type(s)),
+		x(value_type(s_)),
 		y(value_type(v.x)),
 		z(value_type(v.y))
 	{}
@@ -156,24 +156,24 @@
 	template <typename U> 
 	GLM_FUNC_QUALIFIER tvec3<T>::tvec3
 	(
-		U const & s
+		U const & s_
 	) :
-		x(value_type(s)),
-		y(value_type(s)),
-		z(value_type(s))
+		x(value_type(s_)),
+		y(value_type(s_)),
+		z(value_type(s_))
 	{}
 
 	template <typename T>
 	template <typename A, typename B, typename C> 
 	GLM_FUNC_QUALIFIER tvec3<T>::tvec3
 	(
-		A const & x, 
-		B const & y, 
-		C const & z
+		A const & x_, 
+		B const & y_, 
+		C const & z_
 	) :
-		x(value_type(x)),
-		y(value_type(y)),
-		z(value_type(z))
+		x(value_type(x_)),
+		y(value_type(y_)),
+		z(value_type(z_))
 	{}
 
 	//////////////////////////////////////
@@ -184,21 +184,21 @@
 	GLM_FUNC_QUALIFIER tvec3<T>::tvec3
 	(
 		tvec2<A> const & v, 
-		B const & s
+		B const & s_
 	) :
 		x(value_type(v.x)),
 		y(value_type(v.y)),
-		z(value_type(s))
+		z(value_type(s_))
 	{}
 
 	template <typename T>
 	template <typename A, typename B> 
 	GLM_FUNC_QUALIFIER tvec3<T>::tvec3
 	(	
-		A const & s, 
+		A const & s_, 
 		tvec2<B> const & v
 	) :
-		x(value_type(s)),
+		x(value_type(s_)),
 		y(value_type(v.x)),
 		z(value_type(v.y))
 	{}
@@ -255,11 +255,11 @@
 
 	template <typename T>
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator+=(U s)
+	GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator+=(U s_)
 	{
-		this->x += T(s);
-		this->y += T(s);
-		this->z += T(s);
+		this->x += T(s_);
+		this->y += T(s_);
+		this->z += T(s_);
 		return *this;
 	}
 
@@ -278,11 +278,11 @@
 
 	template <typename T>
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator-=(U s)
+	GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator-=(U s_)
 	{
-		this->x -= T(s);
-		this->y -= T(s);
-		this->z -= T(s);
+		this->x -= T(s_);
+		this->y -= T(s_);
+		this->z -= T(s_);
 		return *this;
 	}
 
@@ -301,11 +301,11 @@
 
 	template <typename T>
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator*=(U s)
+	GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator*=(U s_)
 	{
-		this->x *= T(s);
-		this->y *= T(s);
-		this->z *= T(s);
+		this->x *= T(s_);
+		this->y *= T(s_);
+		this->z *= T(s_);
 		return *this;
 	}
 
@@ -324,11 +324,11 @@
 
 	template <typename T>
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator/=(U s)
+	GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator/=(U s_)
 	{
-		this->x /= T(s);
-		this->y /= T(s);
-		this->z /= T(s);
+		this->x /= T(s_);
+		this->y /= T(s_);
+		this->z /= T(s_);
 		return *this;
 	}
 
@@ -391,11 +391,11 @@
 
 	template <typename T>
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator%=(U s)
+	GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator%=(U s_)
 	{
-		this->x %= s;
-		this->y %= s;
-		this->z %= s;
+		this->x %= s_;
+		this->y %= s_;
+		this->z %= s_;
 		return *this;
 	}
 
@@ -414,11 +414,11 @@
 
 	template <typename T>
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator&=(U s)
+	GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator&=(U s_)
 	{
-		this->x &= s;
-		this->y &= s;
-		this->z &= s;
+		this->x &= s_;
+		this->y &= s_;
+		this->z &= s_;
 		return *this;
 	}
 
@@ -437,11 +437,11 @@
 
 	template <typename T>
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator|=(U s)
+	GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator|=(U s_)
 	{
-		this->x |= s;
-		this->y |= s;
-		this->z |= s;
+		this->x |= s_;
+		this->y |= s_;
+		this->z |= s_;
 		return *this;
 	}
 
@@ -460,11 +460,11 @@
 
 	template <typename T>
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator^=(U s)
+	GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator^=(U s_)
 	{
-		this->x ^= s;
-		this->y ^= s;
-		this->z ^= s;
+		this->x ^= s_;
+		this->y ^= s_;
+		this->z ^= s_;
 		return *this;
 	}
 
@@ -483,11 +483,11 @@
 
 	template <typename T>
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator<<=(U s)
+	GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator<<=(U s_)
 	{
-		this->x <<= s;
-		this->y <<= s;
-		this->z <<= s;
+		this->x <<= s_;
+		this->y <<= s_;
+		this->z <<= s_;
 		return *this;
 	}
 
@@ -506,11 +506,11 @@
 
 	template <typename T>
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator>>=(U s)
+	GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator>>=(U s_)
 	{
-		this->x >>= T(s);
-		this->y >>= T(s);
-		this->z >>= T(s);
+		this->x >>= T(s_);
+		this->y >>= T(s_);
+		this->z >>= T(s_);
 		return *this;
 	}
 
@@ -534,78 +534,78 @@
 	GLM_FUNC_QUALIFIER typename tvec3<T>::value_type 
 	tvec3<T>::swizzle
 	(
-		comp x
+		comp x_
 	) const
 	{
-		return (*this)[x];
+		return (*this)[x_];
 	}
 
 	template <typename T>
 	GLM_FUNC_QUALIFIER tvec2<T> tvec3<T>::swizzle
 	(
-		comp x, 
-		comp y
+		comp x_, 
+		comp y_
 	) const
 	{
 		return tvec2<T>(
-			(*this)[x],
-			(*this)[y]);
+			(*this)[x_],
+			(*this)[y_]);
 	}
 
 	template <typename T>
 	GLM_FUNC_QUALIFIER tvec3<T> tvec3<T>::swizzle
 	(
-		comp x, 
-		comp y, 
-		comp z
+		comp x_, 
+		comp y_, 
+		comp z_
 	) const
 	{
 		return tvec3<T>(
-			(*this)[x],
-			(*this)[y],
-			(*this)[z]);
+			(*this)[x_],
+			(*this)[y_],
+			(*this)[z_]);
 	}
 
 	template <typename T>
 	GLM_FUNC_QUALIFIER tvec4<T> tvec3<T>::swizzle
 	(
-		comp x, 
-		comp y, 
-		comp z, 
+		comp x_, 
+		comp y_, 
+		comp z_, 
 		comp w
 	) const
 	{
 		return tvec4<T>(
-			(*this)[x],
-			(*this)[y],
-			(*this)[z],
+			(*this)[x_],
+			(*this)[y_],
+			(*this)[z_],
 			(*this)[w]);
 	}
 
 	template <typename T>
 	GLM_FUNC_QUALIFIER tref2<T> tvec3<T>::swizzle
 	(
-		comp x, 
-		comp y
+		comp x_, 
+		comp y_
 	)
 	{
 		return tref2<T>(
-			(*this)[x],
-			(*this)[y]);
+			(*this)[x_],
+			(*this)[y_]);
 	}
 
 	template <typename T>
 	GLM_FUNC_QUALIFIER tref3<T> tvec3<T>::swizzle
 	(
-		comp x, 
-		comp y, 
-		comp z
+		comp x_, 
+		comp y_, 
+		comp z_
 	)
 	{
 		return tref3<T>(
-			(*this)[x],
-			(*this)[y],
-			(*this)[z]);
+			(*this)[x_],
+			(*this)[y_],
+			(*this)[z_]);
 	}
 
 	//////////////////////////////////////
@@ -615,26 +615,26 @@
 	GLM_FUNC_QUALIFIER tvec3<T> operator+
 	(
 		tvec3<T> const & v, 
-		T const & s
+		T const & s_
 	)
 	{
 		return tvec3<T>(
-			v.x + T(s),
-			v.y + T(s),
-			v.z + T(s));
+			v.x + T(s_),
+			v.y + T(s_),
+			v.z + T(s_));
 	}
 
 	template <typename T> 
 	GLM_FUNC_QUALIFIER tvec3<T> operator+ 
 	(
-		T const & s, 
+		T const & s_, 
 		tvec3<T> const & v
 	)
 	{
 		return tvec3<T>(
-			T(s) + v.x,
-			T(s) + v.y,
-			T(s) + v.z);
+			T(s_) + v.x,
+			T(s_) + v.y,
+			T(s_) + v.z);
 	}
 
 	template <typename T> 
@@ -655,26 +655,26 @@
 	GLM_FUNC_QUALIFIER tvec3<T> operator- 
 	(
 		tvec3<T> const & v, 
-		T const & s
+		T const & s_
 	)
 	{
 		return tvec3<T>(
-			v.x - T(s),
-			v.y - T(s),
-			v.z - T(s));
+			v.x - T(s_),
+			v.y - T(s_),
+			v.z - T(s_));
 	}
 
 	template <typename T> 
 	GLM_FUNC_QUALIFIER tvec3<T> operator- 
 	(
-		T const & s, 
+		T const & s_, 
 		tvec3<T> const & v
 	)
 	{
 		return tvec3<T>(
-			T(s) - v.x,
-			T(s) - v.y,
-			T(s) - v.z);
+			T(s_) - v.x,
+			T(s_) - v.y,
+			T(s_) - v.z);
 	}
 
 	template <typename T> 
@@ -695,26 +695,26 @@
 	GLM_FUNC_QUALIFIER tvec3<T> operator*
 	(
 		tvec3<T> const & v, 
-		T const & s
+		T const & s_
 	)
 	{
 		return tvec3<T>(
-			v.x * T(s),
-			v.y * T(s),
-			v.z * T(s));
+			v.x * T(s_),
+			v.y * T(s_),
+			v.z * T(s_));
 	}
 
 	template <typename T> 
 	GLM_FUNC_QUALIFIER tvec3<T> operator* 
 	(
-		T const & s, 
+		T const & s_, 
 		tvec3<T> const & v
 	)
 	{
 		return tvec3<T>(
-			T(s) * v.x,
-			T(s) * v.y,
-			T(s) * v.z);
+			T(s_) * v.x,
+			T(s_) * v.y,
+			T(s_) * v.z);
 	}
 
 	template <typename T> 
@@ -735,26 +735,26 @@
 	GLM_FUNC_QUALIFIER tvec3<T> operator/
 	(
 		tvec3<T> const & v, 
-		T const & s
+		T const & s_
 	)
 	{
 		return tvec3<T>(
-			v.x / T(s),
-			v.y / T(s),
-			v.z / T(s));
+			v.x / T(s_),
+			v.y / T(s_),
+			v.z / T(s_));
 	}
 
 	template <typename T> 
 	GLM_FUNC_QUALIFIER tvec3<T> operator/ 
 	(
-		T const & s, 
+		T const & s_, 
 		tvec3<T> const & v
 	)
 	{
 		return tvec3<T>(
-			T(s) / v.x,
-			T(s) / v.y,
-			T(s) / v.z);
+			T(s_) / v.x,
+			T(s_) / v.y,
+			T(s_) / v.z);
 	}
 
 	template <typename T> 
@@ -816,26 +816,26 @@
 	GLM_FUNC_QUALIFIER tvec3<T> operator% 
 	(
 		tvec3<T> const & v, 
-		T const & s
+		T const & s_
 	)
 	{
 		return tvec3<T>(
-			v.x % T(s),
-			v.y % T(s),
-			v.z % T(s));
+			v.x % T(s_),
+			v.y % T(s_),
+			v.z % T(s_));
 	}
 
 	template <typename T>
 	GLM_FUNC_QUALIFIER tvec3<T> operator%
 	(
-		T const & s, 
+		T const & s_, 
 		tvec3<T> const & v
 	)
 	{
 		return tvec3<T>(
-			T(s) % v.x,
-			T(s) % v.y,
-			T(s) % v.z);
+			T(s_) % v.x,
+			T(s_) % v.y,
+			T(s_) % v.z);
 	}
 
 	template <typename T>
@@ -855,26 +855,26 @@
 	GLM_FUNC_QUALIFIER tvec3<T> operator& 
 	(
 		tvec3<T> const & v, 
-		T const & s
+		T const & s_
 	)
 	{
 		return tvec3<T>(
-			v.x & T(s),
-			v.y & T(s),
-			v.z & T(s));
+			v.x & T(s_),
+			v.y & T(s_),
+			v.z & T(s_));
 	}
 
 	template <typename T>
 	GLM_FUNC_QUALIFIER tvec3<T> operator& 
 	(
-		T const & s, 
+		T const & s_, 
 		tvec3<T> const & v
 	)
 	{
 		return tvec3<T>(
-			T(s) & v.x,
-			T(s) & v.y,
-			T(s) & v.z);
+			T(s_) & v.x,
+			T(s_) & v.y,
+			T(s_) & v.z);
 	}
 
 	template <typename T>
@@ -894,26 +894,26 @@
 	GLM_FUNC_QUALIFIER tvec3<T> operator| 
 	(
 		tvec3<T> const & v, 
-		T const & s
+		T const & s_
 	)
 	{
 		return tvec3<T>(
-			v.x | T(s),
-			v.y | T(s),
-			v.z | T(s));
+			v.x | T(s_),
+			v.y | T(s_),
+			v.z | T(s_));
 	}
 
 	template <typename T>
 	GLM_FUNC_QUALIFIER tvec3<T> operator| 
 	(
-		T const & s, 
+		T const & s_, 
 		tvec3<T> const & v
 	)
 	{
 		return tvec3<T>(
-			T(s) | v.x,
-			T(s) | v.y,
-			T(s) | v.z);
+			T(s_) | v.x,
+			T(s_) | v.y,
+			T(s_) | v.z);
 	}
 
 	template <typename T>
@@ -933,26 +933,26 @@
 	GLM_FUNC_QUALIFIER tvec3<T> operator^ 
 	(
 		tvec3<T> const & v, 
-		T const & s
+		T const & s_
 	)
 	{
 		return tvec3<T>(
-			v.x ^ T(s),
-			v.y ^ T(s),
-			v.z ^ T(s));
+			v.x ^ T(s_),
+			v.y ^ T(s_),
+			v.z ^ T(s_));
 	}
 
 	template <typename T>
 	GLM_FUNC_QUALIFIER tvec3<T> operator^ 
 	(
-		T const & s, 
+		T const & s_, 
 		tvec3<T> const & v
 	)
 	{
 		return tvec3<T>(
-			T(s) ^ v.x,
-			T(s) ^ v.y,
-			T(s) ^ v.z);
+			T(s_) ^ v.x,
+			T(s_) ^ v.y,
+			T(s_) ^ v.z);
 	}
 
 	template <typename T>
@@ -972,26 +972,26 @@
 	GLM_FUNC_QUALIFIER tvec3<T> operator<< 
 	(
 		tvec3<T> const & v, 
-		T const & s
+		T const & s_
 	)
 	{
 		return tvec3<T>(
-			v.x << T(s),
-			v.y << T(s),
-			v.z << T(s));
+			v.x << T(s_),
+			v.y << T(s_),
+			v.z << T(s_));
 	}
 
 	template <typename T>
 	GLM_FUNC_QUALIFIER tvec3<T> operator<< 
 	(
-		T const & s, 
+		T const & s_, 
 		tvec3<T> const & v
 	)
 	{
 		return tvec3<T>(
-			T(s) << v.x,
-			T(s) << v.y,
-			T(s) << v.z);
+			T(s_) << v.x,
+			T(s_) << v.y,
+			T(s_) << v.z);
 	}
 
 	template <typename T>
@@ -1011,26 +1011,26 @@
 	GLM_FUNC_QUALIFIER tvec3<T> operator>> 
 	(
 		tvec3<T> const & v, 
-		T const & s
+		T const & s_
 	)
 	{
 		return tvec3<T>(
-			v.x >> T(s),
-			v.y >> T(s),
-			v.z >> T(s));
+			v.x >> T(s_),
+			v.y >> T(s_),
+			v.z >> T(s_));
 	}
 
 	template <typename T>
 	GLM_FUNC_QUALIFIER tvec3<T> operator>> 
 	(
-		T const & s, 
+		T const & s_, 
 		tvec3<T> const & v
 	)
 	{
 		return tvec3<T>(
-			s >> T(v.x),
-			s >> T(v.y),
-			s >> T(v.z));
+			s_ >> T(v.x),
+			s_ >> T(v.y),
+			s_ >> T(v.z));
 	}
 
 	template <typename T>
@@ -1062,10 +1062,10 @@
 	// tref definition
 
 	template <typename T> 
-	GLM_FUNC_QUALIFIER tref3<T>::tref3(T & x, T & y, T & z) :
-		x(x),
-		y(y),
-		z(z)
+	GLM_FUNC_QUALIFIER tref3<T>::tref3(T & x_, T & y_, T & z_) :
+		x(x_),
+		y(y_),
+		z(z_)
 	{}
 
 	template <typename T> 
diff -ur glm.org/glm/core/type_vec4.hpp glm/glm/core/type_vec4.hpp
--- glm.org/glm/core/type_vec4.hpp	2013-12-08 17:04:59.705365270 +0100
+++ glm/glm/core/type_vec4.hpp	2013-12-08 17:07:20.078840535 +0100
@@ -177,33 +177,33 @@
 		}
 
 		template <int E0, int E1>
-		GLM_FUNC_DECL tvec4(T const & x, T const & y, glm::detail::swizzle<2, T, tvec2<T>, E0, E1, -1, -2> const & v)
+		GLM_FUNC_DECL tvec4(T const & x_, T const & y_, glm::detail::swizzle<2, T, tvec2<T>, E0, E1, -1, -2> const & v)
 		{
-			*this = tvec4<T>(x, y, v());
+			*this = tvec4<T>(x_, y_, v());
 		}
 
 		template <int E0, int E1>
-		GLM_FUNC_DECL tvec4(T const & x, glm::detail::swizzle<2, T, tvec2<T>, E0, E1, -1, -2> const & v, T const & w)
+		GLM_FUNC_DECL tvec4(T const & x_, glm::detail::swizzle<2, T, tvec2<T>, E0, E1, -1, -2> const & v, T const & w_)
 		{
-			*this = tvec4<T>(x, v(), w);
+			*this = tvec4<T>(x_, v(), w);
 		}
 
 		template <int E0, int E1>
-		GLM_FUNC_DECL tvec4(glm::detail::swizzle<2, T, tvec2<T>, E0, E1, -1, -2> const & v, T const & z, T const & w)
+		GLM_FUNC_DECL tvec4(glm::detail::swizzle<2, T, tvec2<T>, E0, E1, -1, -2> const & v, T const & z_, T const & w_)
 		{
-			*this = tvec4<T>(v(), z, w);
+			*this = tvec4<T>(v(), z_, w_);
 		}
 
 		template <int E0, int E1, int E2>
-		GLM_FUNC_DECL tvec4(glm::detail::swizzle<3, T, tvec3<T>, E0, E1, E2, -1> const & v, T const & w)
+		GLM_FUNC_DECL tvec4(glm::detail::swizzle<3, T, tvec3<T>, E0, E1, E2, -1> const & v, T const & w_)
 		{
-			*this = tvec4<T>(v(), w);
+			*this = tvec4<T>(v(), w_);
 		}
 
 		template <int E0, int E1, int E2>
-		GLM_FUNC_DECL tvec4(T const & x, glm::detail::swizzle<3, T, tvec3<T>, E0, E1, E2, -1> const & v)
+		GLM_FUNC_DECL tvec4(T const & x_, glm::detail::swizzle<3, T, tvec3<T>, E0, E1, E2, -1> const & v)
 		{
-			*this = tvec4<T>(x, v());
+			*this = tvec4<T>(x_, v());
 		}
 
 		//////////////////////////////////////
diff -ur glm.org/glm/core/type_vec4.inl glm/glm/core/type_vec4.inl
--- glm.org/glm/core/type_vec4.inl	2013-12-08 17:04:59.706365245 +0100
+++ glm/glm/core/type_vec4.inl	2013-12-08 17:07:20.079840510 +0100
@@ -95,12 +95,12 @@
 	template <typename T>
 	GLM_FUNC_QUALIFIER tvec4<T>::tvec4
 	(
-		value_type const & s
+		value_type const & s_
 	) :
-		x(s),
-		y(s),
-		z(s),
-		w(s)
+		x(s_),
+		y(s_),
+		z(s_),
+		w(s_)
 	{}
 
 	template <typename T>
@@ -123,12 +123,12 @@
 	template <typename T>
 	GLM_FUNC_QUALIFIER tvec4<T>::tvec4
 	(
-		tref4<T> const & r
+		tref4<T> const & r_
 	) :
-		x(r.x),
-		y(r.y),
-		z(r.z),
-		w(r.w)
+		x(r_.x),
+		y(r_.y),
+		z(r_.z),
+		w(r_.w)
 	{}
 
 	template <typename T>
@@ -178,22 +178,22 @@
 	GLM_FUNC_QUALIFIER tvec4<T>::tvec4
 	(
 		tref3<A> const & v, 
-		B const & s
+		B const & s_
 	) :
 		x(value_type(v.x)),
 		y(value_type(v.y)),
 		z(value_type(v.z)),
-		w(value_type(s))
+		w(value_type(s_))
 	{}
 
 	template <typename T>
 	template <typename A, typename B> 
 	GLM_FUNC_QUALIFIER tvec4<T>::tvec4
 	(
-		A const & s, 
+		A const & s_, 
 		tref3<B> const & v
 	) :
-		x(value_type(s)),
+		x(value_type(s_)),
 		y(value_type(v.x)),
 		z(value_type(v.y)),
 		w(value_type(v.z))
@@ -245,27 +245,27 @@
 	template <typename U> 
 	GLM_FUNC_QUALIFIER tvec4<T>::tvec4
 	(
-		U const & x
+		U const & x_
 	) :
-		x(value_type(x)),
-		y(value_type(x)),
-		z(value_type(x)),
-		w(value_type(x))
+		x(value_type(x_)),
+		y(value_type(x_)),
+		z(value_type(x_)),
+		w(value_type(x_))
 	{}
 
 	template <typename T>
 	template <typename A, typename B, typename C, typename D> 
 	GLM_FUNC_QUALIFIER tvec4<T>::tvec4
 	(
-		A const & x, 
-		B const & y, 
-		C const & z, 
-		D const & w
-	) :
-		x(value_type(x)),
-		y(value_type(y)),
-		z(value_type(z)),
-		w(value_type(w))
+		A const & x_, 
+		B const & y_, 
+		C const & z_, 
+		D const & w_
+	) :
+		x(value_type(x_)),
+		y(value_type(y_)),
+		z(value_type(z_)),
+		w(value_type(w_))
 	{}
 
 	//////////////////////////////////////
@@ -318,22 +318,22 @@
 	GLM_FUNC_QUALIFIER tvec4<T>::tvec4
 	(
 		tvec3<A> const & v, 
-		B const & s
+		B const & s_
 	) :
 		x(value_type(v.x)),
 		y(value_type(v.y)),
 		z(value_type(v.z)),
-		w(value_type(s))
+		w(value_type(s_))
 	{}
 
 	template <typename T>
 	template <typename A, typename B> 
 	GLM_FUNC_QUALIFIER tvec4<T>::tvec4
 	(
-		A const & s, 
+		A const & s_, 
 		tvec3<B> const & v
 	) :
-		x(value_type(s)),
+		x(value_type(s_)),
 		y(value_type(v.x)),
 		z(value_type(v.y)),
 		w(value_type(v.z))
@@ -396,12 +396,12 @@
 
 	template <typename T>
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator+= (U s)
+	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator+= (U s_)
 	{
-		this->x += T(s);
-		this->y += T(s);
-		this->z += T(s);
-		this->w += T(s);
+		this->x += T(s_);
+		this->y += T(s_);
+		this->z += T(s_);
+		this->w += T(s_);
 		return *this;
 	}
 
@@ -421,12 +421,12 @@
 
 	template <typename T>
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator-= (U s)
+	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator-= (U s_)
 	{
-		this->x -= T(s);
-		this->y -= T(s);
-		this->z -= T(s);
-		this->w -= T(s);
+		this->x -= T(s_);
+		this->y -= T(s_);
+		this->z -= T(s_);
+		this->w -= T(s_);
 		return *this;
 	}
 
@@ -446,12 +446,12 @@
 
 	template <typename T>
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator*= (U s)
+	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator*= (U s_)
 	{
-		this->x *= T(s);
-		this->y *= T(s);
-		this->z *= T(s);
-		this->w *= T(s);
+		this->x *= T(s_);
+		this->y *= T(s_);
+		this->z *= T(s_);
+		this->w *= T(s_);
 		return *this;
 	}
 
@@ -471,12 +471,12 @@
 
 	template <typename T>
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator/= (U s)
+	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator/= (U s_)
 	{
-		this->x /= T(s);
-		this->y /= T(s);
-		this->z /= T(s);
-		this->w /= T(s);
+		this->x /= T(s_);
+		this->y /= T(s_);
+		this->z /= T(s_);
+		this->w /= T(s_);
 		return *this;
 	}
 
@@ -519,12 +519,12 @@
 
 	template <typename T>
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator%= (U s)
+	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator%= (U s_)
 	{
-		this->x %= T(s);
-		this->y %= T(s);
-		this->z %= T(s);
-		this->w %= T(s);
+		this->x %= T(s_);
+		this->y %= T(s_);
+		this->z %= T(s_);
+		this->w %= T(s_);
 		return *this;
 	}
 
@@ -544,12 +544,12 @@
 
 	template <typename T>
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator&= (U s)
+	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator&= (U s_)
 	{
-		this->x &= T(s);
-		this->y &= T(s);
-		this->z &= T(s);
-		this->w &= T(s);
+		this->x &= T(s_);
+		this->y &= T(s_);
+		this->z &= T(s_);
+		this->w &= T(s_);
 		return *this;
 	}
 
@@ -569,12 +569,12 @@
 
 	template <typename T>
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator|= (U s)
+	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator|= (U s_)
 	{
-		this->x |= T(s);
-		this->y |= T(s);
-		this->z |= T(s);
-		this->w |= T(s);
+		this->x |= T(s_);
+		this->y |= T(s_);
+		this->z |= T(s_);
+		this->w |= T(s_);
 		return *this;
 	}
 
@@ -594,12 +594,12 @@
 
 	template <typename T>
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator^= (U s)
+	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator^= (U s_)
 	{
-		this->x ^= T(s);
-		this->y ^= T(s);
-		this->z ^= T(s);
-		this->w ^= T(s);
+		this->x ^= T(s_);
+		this->y ^= T(s_);
+		this->z ^= T(s_);
+		this->w ^= T(s_);
 		return *this;
 	}
 
@@ -619,12 +619,12 @@
 
 	template <typename T>
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator<<= (U s)
+	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator<<= (U s_)
 	{
-		this->x <<= T(s);
-		this->y <<= T(s);
-		this->z <<= T(s);
-		this->w <<= T(s);
+		this->x <<= T(s_);
+		this->y <<= T(s_);
+		this->z <<= T(s_);
+		this->w <<= T(s_);
 		return *this;
 	}
 
@@ -644,12 +644,12 @@
 
 	template <typename T>
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator>>= (U s)
+	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator>>= (U s_)
 	{
-		this->x >>= T(s);
-		this->y >>= T(s);
-		this->z >>= T(s);
-		this->w >>= T(s);
+		this->x >>= T(s_);
+		this->y >>= T(s_);
+		this->z >>= T(s_);
+		this->w >>= T(s_);
 		return *this;
 	}
 
@@ -674,94 +674,94 @@
 	GLM_FUNC_QUALIFIER typename tvec4<T>::value_type 
 	tvec4<T>::swizzle
 	(	
-		comp x
+		comp x_
 	) const
 	{
-		return (*this)[x];
+		return (*this)[x_];
 	}
 
 	template <typename T>
 	GLM_FUNC_QUALIFIER tvec2<T> tvec4<T>::swizzle
 	(
-		comp x, 
-		comp y
+		comp x_, 
+		comp y_
 	) const
 	{
 		return tvec2<T>(
-			(*this)[x],
-			(*this)[y]);
+			(*this)[x_],
+			(*this)[y_]);
 	}
 
 	template <typename T>
 	GLM_FUNC_QUALIFIER tvec3<T> tvec4<T>::swizzle
 	(
-		comp x, 
-		comp y, 
-		comp z
+		comp x_, 
+		comp y_, 
+		comp z_
 	) const
 	{
 		return tvec3<T>(
-			(*this)[x],
-			(*this)[y],
-			(*this)[z]);
+			(*this)[x_],
+			(*this)[y_],
+			(*this)[z_]);
 	}
 
 	template <typename T>
 	GLM_FUNC_QUALIFIER tvec4<T> tvec4<T>::swizzle
 	(
-		comp x, 
-		comp y, 
-		comp z, 
-		comp w
+		comp x_, 
+		comp y_, 
+		comp z_, 
+		comp w_
 	) const
 	{
 		return tvec4<T>(
-			(*this)[x],
-			(*this)[y],
-			(*this)[z],
-			(*this)[w]);
+			(*this)[x_],
+			(*this)[y_],
+			(*this)[z_],
+			(*this)[w_]);
 	}
 
 	template <typename T>
 	GLM_FUNC_QUALIFIER tref2<T> tvec4<T>::swizzle
 	(
-		comp x, 
-		comp y
+		comp x_, 
+		comp y_
 	)
 	{
 		return tref2<T>(
-			(*this)[x],
-			(*this)[y]);
+			(*this)[x_],
+			(*this)[y_]);
 	}
 
 	template <typename T>
 	GLM_FUNC_QUALIFIER tref3<T> tvec4<T>::swizzle
 	(
-		comp x, 
-		comp y, 
-		comp z
+		comp x_, 
+		comp y_, 
+		comp z_
 	)
 	{
 		return tref3<T>(
-			(*this)[x],
-			(*this)[y],
-			(*this)[z]);
+			(*this)[x_],
+			(*this)[y_],
+			(*this)[z_]);
 	}
 
 	template <typename T>
 	GLM_FUNC_QUALIFIER tref4<T> tvec4<T>::swizzle
 	(
-		comp x, 
-		comp y, 
-		comp z, 
-		comp w
+		comp x_, 
+		comp y_, 
+		comp z_, 
+		comp w_
 	)
 	{
 		return tref4<T>(
-			(*this)[x],
-			(*this)[y],
-			(*this)[z],
-			(*this)[w]);
+			(*this)[x_],
+			(*this)[y_],
+			(*this)[z_],
+			(*this)[w_]);
 	}
 
 	//////////////////////////////////////
@@ -771,28 +771,28 @@
 	GLM_FUNC_QUALIFIER tvec4<T> operator+ 
 	(
 		tvec4<T> const & v, 
-		typename tvec4<T>::value_type const & s
+		typename tvec4<T>::value_type const & s_
 	)
 	{
 		return tvec4<T>(
-			v.x + s,
-			v.y + s,
-			v.z + s,
-			v.w + s);
+			v.x + s_,
+			v.y + s_,
+			v.z + s_,
+			v.w + s_);
 	}
 
 	template <typename T> 
 	GLM_FUNC_QUALIFIER tvec4<T> operator+ 
 	(
-		typename tvec4<T>::value_type const & s, 
+		typename tvec4<T>::value_type const & s_, 
 		tvec4<T> const & v
 	)
 	{
 		return tvec4<T>(
-			s + v.x,
-			s + v.y,
-			s + v.z,
-			s + v.w);
+			s_ + v.x,
+			s_ + v.y,
+			s_ + v.z,
+			s_ + v.w);
 	}
 
 	template <typename T> 
@@ -814,28 +814,28 @@
 	GLM_FUNC_QUALIFIER tvec4<T> operator- 
 	(
 		tvec4<T> const & v, 
-		typename tvec4<T>::value_type const & s
+		typename tvec4<T>::value_type const & s_
 	)
 	{
 		return tvec4<T>(
-			v.x - s,
-			v.y - s,
-			v.z - s,
-			v.w - s);
+			v.x - s_,
+			v.y - s_,
+			v.z - s_,
+			v.w - s_);
 	}
 
 	template <typename T> 
 	GLM_FUNC_QUALIFIER tvec4<T> operator- 
 	(
-		typename tvec4<T>::value_type const & s, 
+		typename tvec4<T>::value_type const & s_, 
 		tvec4<T> const & v
 	)
 	{
 		return tvec4<T>(
-			s - v.x,
-			s - v.y,
-			s - v.z,
-			s - v.w);
+			s_ - v.x,
+			s_ - v.y,
+			s_ - v.z,
+			s_ - v.w);
 	}
 
 	template <typename T> 
@@ -857,28 +857,28 @@
 	GLM_FUNC_QUALIFIER tvec4<T> operator* 
 	(
 		tvec4<T> const & v, 
-		typename tvec4<T>::value_type const & s
+		typename tvec4<T>::value_type const & s_
 	)
 	{
 		return tvec4<T>(
-			v.x * s,
-			v.y * s,
-			v.z * s,
-			v.w * s);
+			v.x * s_,
+			v.y * s_,
+			v.z * s_,
+			v.w * s_);
 	}
 
 	template <typename T> 
 	GLM_FUNC_QUALIFIER tvec4<T> operator* 
 	(
-		typename tvec4<T>::value_type const & s, 
+		typename tvec4<T>::value_type const & s_, 
 		tvec4<T> const & v
 	)
 	{
 		return tvec4<T>(
-			s * v.x,
-			s * v.y,
-			s * v.z,
-			s * v.w);
+			s_ * v.x,
+			s_ * v.y,
+			s_ * v.z,
+			s_ * v.w);
 	}
 
 	template <typename T> 
@@ -900,28 +900,28 @@
 	GLM_FUNC_QUALIFIER tvec4<T> operator/ 
 	(
 		tvec4<T> const & v, 
-		typename tvec4<T>::value_type const & s
+		typename tvec4<T>::value_type const & s_
 	)
 	{
 		return tvec4<T>(
-			v.x / s,
-			v.y / s,
-			v.z / s,
-			v.w / s);
+			v.x / s_,
+			v.y / s_,
+			v.z / s_,
+			v.w / s_);
 	}
 
 	template <typename T> 
 	GLM_FUNC_QUALIFIER tvec4<T> operator/ 
 	(
-		typename tvec4<T>::value_type const & s, 
+		typename tvec4<T>::value_type const & s_, 
 		tvec4<T> const & v
 	)
 	{
 		return tvec4<T>(
-			s / v.x,
-			s / v.y,
-			s / v.z,
-			s / v.w);
+			s_ / v.x,
+			s_ / v.y,
+			s_ / v.z,
+			s_ / v.w);
 	}
 
 	template <typename T> 
@@ -1012,28 +1012,28 @@
 	GLM_FUNC_QUALIFIER tvec4<T> operator% 
 	(
 		tvec4<T> const & v, 
-		typename tvec4<T>::value_type const & s
+		typename tvec4<T>::value_type const & s_
 	)
 	{
 		return tvec4<T>(
-			v.x % s,
-			v.y % s,
-			v.z % s,
-			v.w % s);
+			v.x % s_,
+			v.y % s_,
+			v.z % s_,
+			v.w % s_);
 	}
 
 	template <typename T>
 	GLM_FUNC_QUALIFIER tvec4<T> operator% 
 	(
-		typename tvec4<T>::value_type const & s, 
+		typename tvec4<T>::value_type const & s_, 
 		tvec4<T> const & v
 	)
 	{
 		return tvec4<T>(
-			s % v.x,
-			s % v.y,
-			s % v.z,
-			s % v.w);
+			s_ % v.x,
+			s_ % v.y,
+			s_ % v.z,
+			s_ % v.w);
 	}
 
 	template <typename T>
@@ -1054,28 +1054,28 @@
 	GLM_FUNC_QUALIFIER tvec4<T> operator& 
 	(
 		tvec4<T> const & v, 
-		typename tvec4<T>::value_type const & s
+		typename tvec4<T>::value_type const & s_
 	)
 	{
 		return tvec4<T>(
-			v.x & s,
-			v.y & s,
-			v.z & s,
-			v.w & s);
+			v.x & s_,
+			v.y & s_,
+			v.z & s_,
+			v.w & s_);
 	}
 
 	template <typename T>
 	GLM_FUNC_QUALIFIER tvec4<T> operator& 
 	(
-		typename tvec4<T>::value_type const & s, 
+		typename tvec4<T>::value_type const & s_, 
 		tvec4<T> const & v
 	)
 	{
 		return tvec4<T>(
-			s & v.x,
-			s & v.y,
-			s & v.z,
-			s & v.w);
+			s_ & v.x,
+			s_ & v.y,
+			s_ & v.z,
+			s_ & v.w);
 	}
 
 	template <typename T>
@@ -1096,28 +1096,28 @@
 	GLM_FUNC_QUALIFIER tvec4<T> operator|
 	(
 		tvec4<T> const & v, 
-		typename tvec4<T>::value_type const & s
+		typename tvec4<T>::value_type const & s_
 	)
 	{
 		return tvec4<T>(
-			v.x | s,
-			v.y | s,
-			v.z | s,
-			v.w | s);
+			v.x | s_,
+			v.y | s_,
+			v.z | s_,
+			v.w | s_);
 	}
 
 	template <typename T>
 	GLM_FUNC_QUALIFIER tvec4<T> operator|
 	(
-		typename tvec4<T>::value_type const & s, 
+		typename tvec4<T>::value_type const & s_, 
 		tvec4<T> const & v
 	)
 	{
 		return tvec4<T>(
-			s | v.x,
-			s | v.y,
-			s | v.z,
-			s | v.w);
+			s_ | v.x,
+			s_ | v.y,
+			s_ | v.z,
+			s_ | v.w);
 	}
 
 	template <typename T>
@@ -1138,28 +1138,28 @@
 	GLM_FUNC_QUALIFIER tvec4<T> operator^
 	(
 		tvec4<T> const & v, 
-		typename tvec4<T>::value_type const & s
+		typename tvec4<T>::value_type const & s_
 	)
 	{
 		return tvec4<T>(
-			v.x ^ s,
-			v.y ^ s,
-			v.z ^ s,
-			v.w ^ s);
+			v.x ^ s_,
+			v.y ^ s_,
+			v.z ^ s_,
+			v.w ^ s_);
 	}
 
 	template <typename T>
 	GLM_FUNC_QUALIFIER tvec4<T> operator^
 	(
-		typename tvec4<T>::value_type const & s, 
+		typename tvec4<T>::value_type const & s_, 
 		tvec4<T> const & v
 	)
 	{
 		return tvec4<T>(
-			s ^ v.x,
-			s ^ v.y,
-			s ^ v.z,
-			s ^ v.w);
+			s_ ^ v.x,
+			s_ ^ v.y,
+			s_ ^ v.z,
+			s_ ^ v.w);
 	}
 
 	template <typename T>
@@ -1180,28 +1180,28 @@
 	GLM_FUNC_QUALIFIER tvec4<T> operator<<
 	(
 		tvec4<T> const & v,
-		typename tvec4<T>::value_type const & s
+		typename tvec4<T>::value_type const & s_
 	)
 	{
 		return tvec4<T>(
-			v.x << s,
-			v.y << s,
-			v.z << s,
-			v.w << s);
+			v.x << s_,
+			v.y << s_,
+			v.z << s_,
+			v.w << s_);
 	}
 
 	template <typename T>
 	GLM_FUNC_QUALIFIER tvec4<T> operator<<
 	(
-		typename tvec4<T>::value_type const & s,
+		typename tvec4<T>::value_type const & s_,
 		tvec4<T> const & v
 	)
 	{
 		return tvec4<T>(
-			s << v.x,
-			s << v.y,
-			s << v.z,
-			s << v.w);
+			s_ << v.x,
+			s_ << v.y,
+			s_ << v.z,
+			s_ << v.w);
 	}
 
 	template <typename T>
@@ -1222,28 +1222,28 @@
 	GLM_FUNC_QUALIFIER tvec4<T> operator>>
 	(
 		tvec4<T> const & v,
-		typename tvec4<T>::value_type const & s
+		typename tvec4<T>::value_type const & s_
 	)
 	{
 		return tvec4<T>(
-			v.x >> s,
-			v.y >> s,
-			v.z >> s,
-			v.w >> s);
+			v.x >> s_,
+			v.y >> s_,
+			v.z >> s_,
+			v.w >> s_);
 	}
 
 	template <typename T>
 	GLM_FUNC_QUALIFIER tvec4<T> operator>>
 	(
-		typename tvec4<T>::value_type const & s,
+		typename tvec4<T>::value_type const & s_,
 		tvec4<T> const & v
 	)
 	{
 		return tvec4<T>(
-			s >> v.x,
-			s >> v.y,
-			s >> v.z,
-			s >> v.w);
+			s_ >> v.x,
+			s_ >> v.y,
+			s_ >> v.z,
+			s_ >> v.w);
 	}
 
 	template <typename T>
@@ -1279,15 +1279,15 @@
 	template <typename T> 
 	tref4<T>::tref4
 	(
-		T & x, 
-		T & y, 
-		T & z, 
-		T & w
-	) :
-		x(x),
-		y(y),
-		z(z),
-		w(w)
+		T & x_, 
+		T & y_, 
+		T & z_, 
+		T & w_
+	) :
+		x(x_),
+		y(y_),
+		z(z_),
+		w(w_)
 	{}
 
 	template <typename T> 
diff -ur glm.org/glm/gtc/quaternion.inl glm/glm/gtc/quaternion.inl
--- glm.org/glm/gtc/quaternion.inl	2013-12-08 17:04:59.707365220 +0100
+++ glm/glm/gtc/quaternion.inl	2013-12-08 17:07:20.081840460 +0100
@@ -60,15 +60,15 @@
 	template <typename T> 
 	GLM_FUNC_QUALIFIER tquat<T>::tquat
 	(
-		value_type const & w, 
-		value_type const & x, 
-		value_type const & y, 
-		value_type const & z
+		value_type const & w_, 
+		value_type const & x_, 
+		value_type const & y_, 
+		value_type const & z_
 	) :
-		x(x),
-		y(y),
-		z(z),
-		w(w)
+		x(x_),
+		y(y_),
+		z(z_),
+		w(w_)
 	{}
 
 	//////////////////////////////////////////////////////////////