move glm to external

Change-Id: Ifa9584ab86c2ca02b2b62fb95a2c029a278aea9a

7 files changed, 5365 insertions, 0 deletions

diff --git a/external/Module_external.mk b/external/Module_external.mk
index d1214a3d1385..b3fd60642190 100644
--- a/external/Module_external.mk
+++ b/external/Module_external.mk
@@ -40,6 +40,7 @@ $(eval $(call gb_Module_add_moduledirs,external,\
 	$(call gb_Helper_optional,FONTCONFIG,fontconfig) \
 	$(call gb_Helper_optional,FREEHAND,libfreehand) \
 	$(call gb_Helper_optional,FREETYPE,freetype) \
+	$(call gb_Helper_optional,GLM,glm) \
 	$(call gb_Helper_optional,GRAPHITE,graphite) \
 	$(call gb_Helper_optional,HARFBUZZ,harfbuzz) \
 	$(call gb_Helper_optional,HSQLDB,hsqldb) \
diff --git a/external/glm/Makefile b/external/glm/Makefile
new file mode 100644
index 000000000000..ccb1c85a04da
--- /dev/null
+++ b/external/glm/Makefile
@@ -0,0 +1,7 @@
+# -*- Mode: makefile-gmake; tab-width: 4; indent-tabs-mode: t -*-
+
+module_directory:=$(dir $(realpath $(firstword $(MAKEFILE_LIST))))
+
+include $(module_directory)/../solenv/gbuild/partial_build.mk
+
+# vim: set noet sw=4 ts=4:
diff --git a/external/glm/Module_glm.mk b/external/glm/Module_glm.mk
new file mode 100644
index 000000000000..71ec270b889a
--- /dev/null
+++ b/external/glm/Module_glm.mk
@@ -0,0 +1,20 @@
+# -*- Mode: makefile-gmake; tab-width: 4; indent-tabs-mode: t -*-
+#
+# This file is part of the LibreOffice project.
+#
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+#
+
+$(eval $(call gb_Module_Module,glm))
+
+ifeq ($(SYSTEM_GLM),NO)
+
+$(eval $(call gb_Module_add_targets,glm,\
+	UnpackedTarball_glm \
+))
+
+endif
+
+# vim: set noet sw=4 ts=4:
diff --git a/external/glm/README b/external/glm/README
new file mode 100644
index 000000000000..30122f67b5e2
--- /dev/null
+++ b/external/glm/README
@@ -0,0 +1,3 @@
+Glm provides a header only library for OpenGL mathematics.
+
+It is available from http://glm.g-truc.net/0.9.4/index.html
diff --git a/external/glm/UnpackedTarball_glm.mk b/external/glm/UnpackedTarball_glm.mk
new file mode 100644
index 000000000000..e115bff8f168
--- /dev/null
+++ b/external/glm/UnpackedTarball_glm.mk
@@ -0,0 +1,16 @@
+# -*- Mode: makefile-gmake; tab-width: 4; indent-tabs-mode: t -*-
+#
+# This file is part of the LibreOffice project.
+#
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+#
+
+$(eval $(call gb_UnpackedTarball_UnpackedTarball,glm))
+
+$(eval $(call gb_UnpackedTarball_set_tarball,glm,$(GLM_TARBALL)))
+
+$(eval $(call gb_UnpackedTarball_set_patchlevel,glm,1))
+
+# vim: set noet sw=4 ts=4:
diff --git a/external/glm/Wshadow-unix.patch b/external/glm/Wshadow-unix.patch
new file mode 100644
index 000000000000..be4af10f9896
--- /dev/null
+++ b/external/glm/Wshadow-unix.patch
@@ -0,0 +1,2659 @@
+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_)

+ 	{}

+ 

+ 	//////////////////////////////////////////////////////////////

diff --git a/external/glm/Wshadow-windows.patch b/external/glm/Wshadow-windows.patch
new file mode 100644
index 000000000000..c6c9c6585782
--- /dev/null
+++ b/external/glm/Wshadow-windows.patch
@@ -0,0 +1,2659 @@
+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_)
+ 	{}
+ 
+ 	//////////////////////////////////////////////////////////////