From 55c242c15c5022bf4646ed7264bf3772d1de0ca5 Mon Sep 17 00:00:00 2001
From: Christophe Riccio <mail@g-truc.net>
Date: Tue, 17 Sep 2013 22:51:04 +0200
Subject: [PATCH 1/5] Added GCC49 detection

---
 glm/core/setup.hpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/glm/core/setup.hpp b/glm/core/setup.hpp
index 7a9d5c71..824086b4 100644
--- a/glm/core/setup.hpp
+++ b/glm/core/setup.hpp
@@ -154,6 +154,7 @@
 #define GLM_COMPILER_GCC46			0x020000D0
 #define GLM_COMPILER_GCC47			0x020000E0
 #define GLM_COMPILER_GCC48			0x020000F0
+#define GLM_COMPILER_GCC49			0x02000100
 
 // G++ command line to display defined
 // echo "" | g++ -E -dM -x c++ - | sort

From 33a482a6bea312dac98c785225f657fb910f4672 Mon Sep 17 00:00:00 2001
From: Christophe Riccio <mail@g-truc.net>
Date: Tue, 17 Sep 2013 22:51:24 +0200
Subject: [PATCH 2/5] Added GCC49 detection

---
 test/core/core_setup_message.cpp | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/test/core/core_setup_message.cpp b/test/core/core_setup_message.cpp
index 3fea7dca..c990de49 100644
--- a/test/core/core_setup_message.cpp
+++ b/test/core/core_setup_message.cpp
@@ -51,6 +51,9 @@ int test_compiler()
 		case GLM_COMPILER_VC2012:
 			std::cout << "GLM_COMPILER_VC2012" << std::endl;	
 			break;
+		case GLM_COMPILER_VC2013:
+			std::cout << "GLM_COMPILER_VC2013" << std::endl;
+			break;
 		default:
 			std::cout << "Visual C++ version not detected" << std::endl;
 			Error += 1;
@@ -108,6 +111,9 @@ int test_compiler()
 		case GLM_COMPILER_GCC48:
 			std::cout << "GLM_COMPILER_GCC48" << std::endl;	
 			break;
+		case GLM_COMPILER_GCC49:
+			std::cout << "GLM_COMPILER_GCC49" << std::endl;
+			break;
 		default:
 			std::cout << "GCC version not detected" << std::endl;
 			Error += 1;

From dbef0b4eb5238cc0fdafe85e4921b47c587b2b3a Mon Sep 17 00:00:00 2001
From: Christophe Riccio <mail@g-truc.net>
Date: Tue, 17 Sep 2013 22:51:39 +0200
Subject: [PATCH 3/5] Fixed build

---
 test/external/gli/core/operation.inl | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/test/external/gli/core/operation.inl b/test/external/gli/core/operation.inl
index 87999a81..58b6428f 100644
--- a/test/external/gli/core/operation.inl
+++ b/test/external/gli/core/operation.inl
@@ -123,8 +123,8 @@ namespace gli
 			glm::byte * DstData = DstMipmap.data();
 			glm::byte const * const SrcData = SrcMipmap.data();
 
-			std::size_t SizeX = std::min(std::size_t(SrcSize.x + SrcPosition.x), std::size_t(DstMipmap.dimensions().x  + DstPosition.x));
-			std::size_t SizeY = std::min(std::size_t(SrcSize.y + SrcPosition.y), std::size_t(DstMipmap.dimensions().y + DstPosition.y));
+			std::size_t SizeX = glm::min(std::size_t(SrcSize.x + SrcPosition.x), std::size_t(DstMipmap.dimensions().x  + DstPosition.x));
+			std::size_t SizeY = glm::min(std::size_t(SrcSize.y + SrcPosition.y), std::size_t(DstMipmap.dimensions().y + DstPosition.y));
 
 			for(std::size_t j = 0; j < SizeY; ++j)
 			{

From 0a9162e18970041acd9187212830860cf24999f3 Mon Sep 17 00:00:00 2001
From: Christophe Riccio <mail@g-truc.net>
Date: Tue, 17 Sep 2013 22:52:37 +0200
Subject: [PATCH 4/5] Fixed const ref issue for matrix types. Backport from GLM
 0.9.5 branch #116

---
 glm/core/type_mat2x2.hpp |  8 ++++----
 glm/core/type_mat2x2.inl | 20 ++++----------------
 glm/core/type_mat2x3.hpp |  8 ++++----
 glm/core/type_mat2x3.inl | 20 ++++----------------
 glm/core/type_mat2x4.hpp |  8 ++++----
 glm/core/type_mat2x4.inl | 20 ++++----------------
 glm/core/type_mat3x2.hpp |  8 ++++----
 glm/core/type_mat3x2.inl | 20 ++++----------------
 glm/core/type_mat3x3.hpp |  8 ++++----
 glm/core/type_mat3x3.inl | 20 ++++----------------
 glm/core/type_mat3x4.hpp |  8 ++++----
 glm/core/type_mat3x4.inl | 20 ++++----------------
 glm/core/type_mat4x2.hpp |  8 ++++----
 glm/core/type_mat4x2.inl | 20 ++++----------------
 glm/core/type_mat4x3.hpp |  8 ++++----
 glm/core/type_mat4x3.inl | 20 ++++----------------
 glm/core/type_mat4x4.hpp |  8 ++++----
 glm/core/type_mat4x4.inl | 20 ++++----------------
 18 files changed, 72 insertions(+), 180 deletions(-)

diff --git a/glm/core/type_mat2x2.hpp b/glm/core/type_mat2x2.hpp
index 9d756d8b..432a6b99 100644
--- a/glm/core/type_mat2x2.hpp
+++ b/glm/core/type_mat2x2.hpp
@@ -133,19 +133,19 @@ namespace detail
 		template <typename U> 
 		GLM_FUNC_DECL tmat2x2<T> & operator=(tmat2x2<U> const & m);
 		template <typename U> 
-		GLM_FUNC_DECL tmat2x2<T> & operator+=(U const & s);
+		GLM_FUNC_DECL tmat2x2<T> & operator+=(U s);
 		template <typename U> 
 		GLM_FUNC_DECL tmat2x2<T> & operator+=(tmat2x2<U> const & m);
 		template <typename U> 
-		GLM_FUNC_DECL tmat2x2<T> & operator-=(U const & s);
+		GLM_FUNC_DECL tmat2x2<T> & operator-=(U s);
 		template <typename U> 
 		GLM_FUNC_DECL tmat2x2<T> & operator-=(tmat2x2<U> const & m);
 		template <typename U> 
-		GLM_FUNC_DECL tmat2x2<T> & operator*=(U const & s);
+		GLM_FUNC_DECL tmat2x2<T> & operator*=(U s);
 		template <typename U> 
 		GLM_FUNC_DECL tmat2x2<T> & operator*=(tmat2x2<U> const & m);
 		template <typename U> 
-		GLM_FUNC_DECL tmat2x2<T> & operator/=(U const & s);
+		GLM_FUNC_DECL tmat2x2<T> & operator/=(U s);
 		template <typename U> 
 		GLM_FUNC_DECL tmat2x2<T> & operator/=(tmat2x2<U> const & m);
 		GLM_FUNC_DECL tmat2x2<T> & operator++();
diff --git a/glm/core/type_mat2x2.inl b/glm/core/type_mat2x2.inl
index 4c7249d5..9d6e1911 100644
--- a/glm/core/type_mat2x2.inl
+++ b/glm/core/type_mat2x2.inl
@@ -306,10 +306,7 @@ namespace detail
 
 	template <typename T> 
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat2x2<T>& tmat2x2<T>::operator+=
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tmat2x2<T>& tmat2x2<T>::operator+= (U s)
 	{
 		this->value[0] += s;
 		this->value[1] += s;
@@ -330,10 +327,7 @@ namespace detail
 
 	template <typename T> 
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat2x2<T>& tmat2x2<T>::operator-=
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tmat2x2<T>& tmat2x2<T>::operator-= (U s)
 	{
 		this->value[0] -= s;
 		this->value[1] -= s;
@@ -354,10 +348,7 @@ namespace detail
 
 	template <typename T> 
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat2x2<T>& tmat2x2<T>::operator*= 
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tmat2x2<T>& tmat2x2<T>::operator*= (U s)
 	{
 		this->value[0] *= s;
 		this->value[1] *= s;
@@ -376,10 +367,7 @@ namespace detail
 
 	template <typename T> 
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat2x2<T>& tmat2x2<T>::operator/= 
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tmat2x2<T>& tmat2x2<T>::operator/= (U s)
 	{
 		this->value[0] /= s;
 		this->value[1] /= s;
diff --git a/glm/core/type_mat2x3.hpp b/glm/core/type_mat2x3.hpp
index beb58179..14f1548b 100644
--- a/glm/core/type_mat2x3.hpp
+++ b/glm/core/type_mat2x3.hpp
@@ -123,19 +123,19 @@ namespace detail
 		template <typename U> 
 		GLM_FUNC_DECL tmat2x3<T> & operator=  (tmat2x3<U> const & m);
 		template <typename U> 
-		GLM_FUNC_DECL tmat2x3<T> & operator+= (U const & s);
+		GLM_FUNC_DECL tmat2x3<T> & operator+= (U s);
 		template <typename U> 
 		GLM_FUNC_DECL tmat2x3<T> & operator+= (tmat2x3<U> const & m);
 		template <typename U> 
-		GLM_FUNC_DECL tmat2x3<T> & operator-= (U const & s);
+		GLM_FUNC_DECL tmat2x3<T> & operator-= (U s);
 		template <typename U> 
 		GLM_FUNC_DECL tmat2x3<T> & operator-= (tmat2x3<U> const & m);
 		template <typename U> 
-		GLM_FUNC_DECL tmat2x3<T> & operator*= (U const & s);
+		GLM_FUNC_DECL tmat2x3<T> & operator*= (U s);
 		template <typename U> 
 		GLM_FUNC_DECL tmat2x3<T> & operator*= (tmat2x3<U> const & m);
 		template <typename U> 
-		GLM_FUNC_DECL tmat2x3<T> & operator/= (U const & s);
+		GLM_FUNC_DECL tmat2x3<T> & operator/= (U s);
 
 		GLM_FUNC_DECL tmat2x3<T> & operator++ ();
 		GLM_FUNC_DECL tmat2x3<T> & operator-- ();
diff --git a/glm/core/type_mat2x3.inl b/glm/core/type_mat2x3.inl
index 4644c1b2..b77f4fa0 100644
--- a/glm/core/type_mat2x3.inl
+++ b/glm/core/type_mat2x3.inl
@@ -293,10 +293,7 @@ namespace detail
 
 	template <typename T> 
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat2x3<T> & tmat2x3<T>::operator+= 
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tmat2x3<T> & tmat2x3<T>::operator+= (U s)
 	{
 		this->value[0] += s;
 		this->value[1] += s;
@@ -317,10 +314,7 @@ namespace detail
 
 	template <typename T> 
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat2x3<T>& tmat2x3<T>::operator-= 
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tmat2x3<T>& tmat2x3<T>::operator-= (U s)
 	{
 		this->value[0] -= s;
 		this->value[1] -= s;
@@ -341,10 +335,7 @@ namespace detail
 
 	template <typename T> 
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat2x3<T>& tmat2x3<T>::operator*= 
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tmat2x3<T>& tmat2x3<T>::operator*= (U s)
 	{
 		this->value[0] *= s;
 		this->value[1] *= s;
@@ -363,10 +354,7 @@ namespace detail
 
 	template <typename T>
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat2x3<T> & tmat2x3<T>::operator/= 
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tmat2x3<T> & tmat2x3<T>::operator/= (U s)
 	{
 		this->value[0] /= s;
 		this->value[1] /= s;
diff --git a/glm/core/type_mat2x4.hpp b/glm/core/type_mat2x4.hpp
index 04f824c6..c3357009 100644
--- a/glm/core/type_mat2x4.hpp
+++ b/glm/core/type_mat2x4.hpp
@@ -125,19 +125,19 @@ namespace detail
 		template <typename U> 
 		GLM_FUNC_DECL tmat2x4<T>& operator=  (tmat2x4<U> const & m);
 		template <typename U> 
-		GLM_FUNC_DECL tmat2x4<T>& operator+= (U const & s);
+		GLM_FUNC_DECL tmat2x4<T>& operator+= (U s);
 		template <typename U> 
 		GLM_FUNC_DECL tmat2x4<T>& operator+= (tmat2x4<U> const & m);
 		template <typename U> 
-		GLM_FUNC_DECL tmat2x4<T>& operator-= (U const & s);
+		GLM_FUNC_DECL tmat2x4<T>& operator-= (U s);
 		template <typename U> 
 		GLM_FUNC_DECL tmat2x4<T>& operator-= (tmat2x4<U> const & m);
 		template <typename U> 
-		GLM_FUNC_DECL tmat2x4<T>& operator*= (U const & s);
+		GLM_FUNC_DECL tmat2x4<T>& operator*= (U s);
 		template <typename U> 
 		GLM_FUNC_DECL tmat2x4<T>& operator*= (tmat2x4<U> const & m);
 		template <typename U> 
-		GLM_FUNC_DECL tmat2x4<T>& operator/= (U const & s);
+		GLM_FUNC_DECL tmat2x4<T>& operator/= (U s);
 
 		GLM_FUNC_DECL tmat2x4<T>& operator++ ();
 		GLM_FUNC_DECL tmat2x4<T>& operator-- ();
diff --git a/glm/core/type_mat2x4.inl b/glm/core/type_mat2x4.inl
index d324b580..598bddc3 100644
--- a/glm/core/type_mat2x4.inl
+++ b/glm/core/type_mat2x4.inl
@@ -296,10 +296,7 @@ namespace detail
 
 	template <typename T> 
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat2x4<T>& tmat2x4<T>::operator+= 
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tmat2x4<T>& tmat2x4<T>::operator+= (U s)
 	{
 		this->value[0] += s;
 		this->value[1] += s;
@@ -320,10 +317,7 @@ namespace detail
 
 	template <typename T> 
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat2x4<T>& tmat2x4<T>::operator-= 
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tmat2x4<T>& tmat2x4<T>::operator-= (U s)
 	{
 		this->value[0] -= s;
 		this->value[1] -= s;
@@ -344,10 +338,7 @@ namespace detail
 
 	template <typename T> 
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat2x4<T>& tmat2x4<T>::operator*= 
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tmat2x4<T>& tmat2x4<T>::operator*= (U s)
 	{
 		this->value[0] *= s;
 		this->value[1] *= s;
@@ -366,10 +357,7 @@ namespace detail
 
 	template <typename T> 
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat2x4<T> & tmat2x4<T>::operator/= 
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tmat2x4<T> & tmat2x4<T>::operator/= (U s)
 	{
 		this->value[0] /= s;
 		this->value[1] /= s;
diff --git a/glm/core/type_mat3x2.hpp b/glm/core/type_mat3x2.hpp
index d3663647..06a3228f 100644
--- a/glm/core/type_mat3x2.hpp
+++ b/glm/core/type_mat3x2.hpp
@@ -131,19 +131,19 @@ namespace detail
 		template <typename U> 
 		GLM_FUNC_DECL tmat3x2<T> & operator=  (tmat3x2<U> const & m);
 		template <typename U> 
-		GLM_FUNC_DECL tmat3x2<T> & operator+= (U const & s);
+		GLM_FUNC_DECL tmat3x2<T> & operator+= (U s);
 		template <typename U> 
 		GLM_FUNC_DECL tmat3x2<T> & operator+= (tmat3x2<U> const & m);
 		template <typename U> 
-		GLM_FUNC_DECL tmat3x2<T> & operator-= (U const & s);
+		GLM_FUNC_DECL tmat3x2<T> & operator-= (U s);
 		template <typename U> 
 		GLM_FUNC_DECL tmat3x2<T> & operator-= (tmat3x2<U> const & m);
 		template <typename U> 
-		GLM_FUNC_DECL tmat3x2<T> & operator*= (U const & s);
+		GLM_FUNC_DECL tmat3x2<T> & operator*= (U s);
 		template <typename U> 
 		GLM_FUNC_DECL tmat3x2<T> & operator*= (tmat3x2<U> const & m);
 		template <typename U> 
-		GLM_FUNC_DECL tmat3x2<T> & operator/= (U const & s);
+		GLM_FUNC_DECL tmat3x2<T> & operator/= (U s);
 
 		GLM_FUNC_DECL tmat3x2<T> & operator++ ();
 		GLM_FUNC_DECL tmat3x2<T> & operator-- ();
diff --git a/glm/core/type_mat3x2.inl b/glm/core/type_mat3x2.inl
index a4da3dbc..7d7e16e6 100644
--- a/glm/core/type_mat3x2.inl
+++ b/glm/core/type_mat3x2.inl
@@ -317,10 +317,7 @@ namespace detail
 
 	template <typename T> 
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat3x2<T>& tmat3x2<T>::operator+= 
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tmat3x2<T>& tmat3x2<T>::operator+= (U s)
 	{
 		this->value[0] += s;
 		this->value[1] += s;
@@ -343,10 +340,7 @@ namespace detail
 
 	template <typename T> 
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat3x2<T>& tmat3x2<T>::operator-= 
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tmat3x2<T>& tmat3x2<T>::operator-= (U s)
 	{
 		this->value[0] -= s;
 		this->value[1] -= s;
@@ -369,10 +363,7 @@ namespace detail
 
 	template <typename T> 
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat3x2<T>& tmat3x2<T>::operator*= 
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tmat3x2<T>& tmat3x2<T>::operator*= (U s)
 	{
 		this->value[0] *= s;
 		this->value[1] *= s;
@@ -392,10 +383,7 @@ namespace detail
 
 	template <typename T> 
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat3x2<T> & tmat3x2<T>::operator/= 
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tmat3x2<T> & tmat3x2<T>::operator/= (U s)
 	{
 		this->value[0] /= s;
 		this->value[1] /= s;
diff --git a/glm/core/type_mat3x3.hpp b/glm/core/type_mat3x3.hpp
index aa988ae0..b2122d8e 100644
--- a/glm/core/type_mat3x3.hpp
+++ b/glm/core/type_mat3x3.hpp
@@ -137,19 +137,19 @@ namespace detail
 		template <typename U> 
 		GLM_FUNC_DECL tmat3x3<T>& operator=  (tmat3x3<U> const & m);
 		template <typename U> 
-		GLM_FUNC_DECL tmat3x3<T>& operator+= (U const & s);
+		GLM_FUNC_DECL tmat3x3<T>& operator+= (U s);
 		template <typename U> 
 		GLM_FUNC_DECL tmat3x3<T>& operator+= (tmat3x3<U> const & m);
 		template <typename U> 
-		GLM_FUNC_DECL tmat3x3<T>& operator-= (U const & s);
+		GLM_FUNC_DECL tmat3x3<T>& operator-= (U s);
 		template <typename U> 
 		GLM_FUNC_DECL tmat3x3<T>& operator-= (tmat3x3<U> const & m);
 		template <typename U> 
-		GLM_FUNC_DECL tmat3x3<T>& operator*= (U const & s);
+		GLM_FUNC_DECL tmat3x3<T>& operator*= (U s);
 		template <typename U> 
 		GLM_FUNC_DECL tmat3x3<T>& operator*= (tmat3x3<U> const & m);
 		template <typename U> 
-		GLM_FUNC_DECL tmat3x3<T>& operator/= (U const & s);
+		GLM_FUNC_DECL tmat3x3<T>& operator/= (U s);
 		template <typename U> 
 		GLM_FUNC_DECL tmat3x3<T>& operator/= (tmat3x3<U> const & m);
 		GLM_FUNC_DECL tmat3x3<T>& operator++ ();
diff --git a/glm/core/type_mat3x3.inl b/glm/core/type_mat3x3.inl
index 005ddd5d..73731e9e 100644
--- a/glm/core/type_mat3x3.inl
+++ b/glm/core/type_mat3x3.inl
@@ -320,10 +320,7 @@ namespace detail
 
 	template <typename T> 
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat3x3<T> & tmat3x3<T>::operator+= 
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tmat3x3<T> & tmat3x3<T>::operator+= (U s)
 	{
 		this->value[0] += s;
 		this->value[1] += s;
@@ -346,10 +343,7 @@ namespace detail
 
 	template <typename T> 
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat3x3<T> & tmat3x3<T>::operator-= 
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tmat3x3<T> & tmat3x3<T>::operator-= (U s)
 	{
 		this->value[0] -= s;
 		this->value[1] -= s;
@@ -372,10 +366,7 @@ namespace detail
 
 	template <typename T> 
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat3x3<T> & tmat3x3<T>::operator*= 
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tmat3x3<T> & tmat3x3<T>::operator*= (U s)
 	{
 		this->value[0] *= s;
 		this->value[1] *= s;
@@ -395,10 +386,7 @@ namespace detail
 
 	template <typename T> 
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat3x3<T> & tmat3x3<T>::operator/= 
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tmat3x3<T> & tmat3x3<T>::operator/= (U s)
 	{
 		this->value[0] /= s;
 		this->value[1] /= s;
diff --git a/glm/core/type_mat3x4.hpp b/glm/core/type_mat3x4.hpp
index e880834d..8fe31060 100644
--- a/glm/core/type_mat3x4.hpp
+++ b/glm/core/type_mat3x4.hpp
@@ -131,19 +131,19 @@ namespace detail
 		template <typename U> 
 		GLM_FUNC_DECL tmat3x4<T> & operator=  (tmat3x4<U> const & m);
 		template <typename U> 
-		GLM_FUNC_DECL tmat3x4<T> & operator+= (U const & s);
+		GLM_FUNC_DECL tmat3x4<T> & operator+= (U s);
 		template <typename U> 
 		GLM_FUNC_DECL tmat3x4<T> & operator+= (tmat3x4<U> const & m);
 		template <typename U> 
-		GLM_FUNC_DECL tmat3x4<T> & operator-= (U const & s);
+		GLM_FUNC_DECL tmat3x4<T> & operator-= (U s);
 		template <typename U> 
 		GLM_FUNC_DECL tmat3x4<T> & operator-= (tmat3x4<U> const & m);
 		template <typename U> 
-		GLM_FUNC_DECL tmat3x4<T> & operator*= (U const & s);
+		GLM_FUNC_DECL tmat3x4<T> & operator*= (U s);
 		template <typename U> 
 		GLM_FUNC_DECL tmat3x4<T> & operator*= (tmat3x4<U> const & m);
 		template <typename U> 
-		GLM_FUNC_DECL tmat3x4<T> & operator/= (U const & s);
+		GLM_FUNC_DECL tmat3x4<T> & operator/= (U s);
 
 		GLM_FUNC_DECL tmat3x4<T> & operator++ ();
 		GLM_FUNC_DECL tmat3x4<T> & operator-- ();
diff --git a/glm/core/type_mat3x4.inl b/glm/core/type_mat3x4.inl
index 4a55a012..be613d06 100644
--- a/glm/core/type_mat3x4.inl
+++ b/glm/core/type_mat3x4.inl
@@ -316,10 +316,7 @@ namespace detail
 
 	template <typename T> 
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat3x4<T>& tmat3x4<T>::operator+= 
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tmat3x4<T>& tmat3x4<T>::operator+= (U s)
 	{
 		this->value[0] += s;
 		this->value[1] += s;
@@ -342,10 +339,7 @@ namespace detail
 
 	template <typename T> 
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat3x4<T>& tmat3x4<T>::operator-= 
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tmat3x4<T>& tmat3x4<T>::operator-= (U s)
 	{
 		this->value[0] -= s;
 		this->value[1] -= s;
@@ -368,10 +362,7 @@ namespace detail
 
 	template <typename T> 
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat3x4<T>& tmat3x4<T>::operator*= 
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tmat3x4<T>& tmat3x4<T>::operator*= (U s)
 	{
 		this->value[0] *= s;
 		this->value[1] *= s;
@@ -391,10 +382,7 @@ namespace detail
 
 	template <typename T> 
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat3x4<T> & tmat3x4<T>::operator/= 
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tmat3x4<T> & tmat3x4<T>::operator/= (U s)
 	{
 		this->value[0] /= s;
 		this->value[1] /= s;
diff --git a/glm/core/type_mat4x2.hpp b/glm/core/type_mat4x2.hpp
index 01d61718..3bc6cc00 100644
--- a/glm/core/type_mat4x2.hpp
+++ b/glm/core/type_mat4x2.hpp
@@ -136,19 +136,19 @@ namespace detail
 		template <typename U> 
 		GLM_FUNC_DECL tmat4x2<T>& operator=  (tmat4x2<U> const & m);
 		template <typename U> 
-		GLM_FUNC_DECL tmat4x2<T>& operator+= (U const & s);
+		GLM_FUNC_DECL tmat4x2<T>& operator+= (U s);
 		template <typename U> 
 		GLM_FUNC_DECL tmat4x2<T>& operator+= (tmat4x2<U> const & m);
 		template <typename U> 
-		GLM_FUNC_DECL tmat4x2<T>& operator-= (U const & s);
+		GLM_FUNC_DECL tmat4x2<T>& operator-= (U s);
 		template <typename U> 
 		GLM_FUNC_DECL tmat4x2<T>& operator-= (tmat4x2<U> const & m);
 		template <typename U> 
-		GLM_FUNC_DECL tmat4x2<T>& operator*= (U const & s);
+		GLM_FUNC_DECL tmat4x2<T>& operator*= (U s);
 		template <typename U> 
 		GLM_FUNC_DECL tmat4x2<T>& operator*= (tmat4x2<U> const & m);
 		template <typename U> 
-		GLM_FUNC_DECL tmat4x2<T>& operator/= (U const & s);
+		GLM_FUNC_DECL tmat4x2<T>& operator/= (U s);
 
 		GLM_FUNC_DECL tmat4x2<T>& operator++ ();
 		GLM_FUNC_DECL tmat4x2<T>& operator-- ();
diff --git a/glm/core/type_mat4x2.inl b/glm/core/type_mat4x2.inl
index 64d4758a..3f65e63b 100644
--- a/glm/core/type_mat4x2.inl
+++ b/glm/core/type_mat4x2.inl
@@ -342,10 +342,7 @@ namespace detail
 
 	template <typename T> 
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat4x2<T> & tmat4x2<T>::operator+= 
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tmat4x2<T> & tmat4x2<T>::operator+= (U s)
 	{
 		this->value[0] += s;
 		this->value[1] += s;
@@ -370,10 +367,7 @@ namespace detail
 
 	template <typename T> 
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat4x2<T> & tmat4x2<T>::operator-= 
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tmat4x2<T> & tmat4x2<T>::operator-= (U s)
 	{
 		this->value[0] -= s;
 		this->value[1] -= s;
@@ -398,10 +392,7 @@ namespace detail
 
 	template <typename T> 
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat4x2<T> & tmat4x2<T>::operator*= 
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tmat4x2<T> & tmat4x2<T>::operator*= (U s)
 	{
 		this->value[0] *= s;
 		this->value[1] *= s;
@@ -422,10 +413,7 @@ namespace detail
 
 	template <typename T>
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat4x2<T> & tmat4x2<T>::operator/= 
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tmat4x2<T> & tmat4x2<T>::operator/= (U s)
 	{
 		this->value[0] /= s;
 		this->value[1] /= s;
diff --git a/glm/core/type_mat4x3.hpp b/glm/core/type_mat4x3.hpp
index bb2f5d8a..8465a837 100644
--- a/glm/core/type_mat4x3.hpp
+++ b/glm/core/type_mat4x3.hpp
@@ -134,19 +134,19 @@ namespace detail
 		template <typename U> 
 		GLM_FUNC_DECL tmat4x3<T> & operator=  (tmat4x3<U> const & m);
 		template <typename U> 
-		GLM_FUNC_DECL tmat4x3<T> & operator+= (U const & s);
+		GLM_FUNC_DECL tmat4x3<T> & operator+= (U s);
 		template <typename U> 
 		GLM_FUNC_DECL tmat4x3<T> & operator+= (tmat4x3<U> const & m);
 		template <typename U> 
-		GLM_FUNC_DECL tmat4x3<T> & operator-= (U const & s);
+		GLM_FUNC_DECL tmat4x3<T> & operator-= (U s);
 		template <typename U> 
 		GLM_FUNC_DECL tmat4x3<T> & operator-= (tmat4x3<U> const & m);
 		template <typename U> 
-		GLM_FUNC_DECL tmat4x3<T> & operator*= (U const & s);
+		GLM_FUNC_DECL tmat4x3<T> & operator*= (U s);
 		template <typename U> 
 		GLM_FUNC_DECL tmat4x3<T> & operator*= (tmat4x3<U> const & m);
 		template <typename U> 
-		GLM_FUNC_DECL tmat4x3<T> & operator/= (U const & s);
+		GLM_FUNC_DECL tmat4x3<T> & operator/= (U s);
 
 		GLM_FUNC_DECL tmat4x3<T> & operator++ ();
 		GLM_FUNC_DECL tmat4x3<T> & operator-- ();
diff --git a/glm/core/type_mat4x3.inl b/glm/core/type_mat4x3.inl
index e862b0dd..75307a5f 100644
--- a/glm/core/type_mat4x3.inl
+++ b/glm/core/type_mat4x3.inl
@@ -344,10 +344,7 @@ namespace detail
 
 	template <typename T> 
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat4x3<T> & tmat4x3<T>::operator+= 
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tmat4x3<T> & tmat4x3<T>::operator+= (U s)
 	{
 		this->value[0] += s;
 		this->value[1] += s;
@@ -372,10 +369,7 @@ namespace detail
 
 	template <typename T> 
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat4x3<T> & tmat4x3<T>::operator-= 
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tmat4x3<T> & tmat4x3<T>::operator-= (U s)
 	{
 		this->value[0] -= s;
 		this->value[1] -= s;
@@ -400,10 +394,7 @@ namespace detail
 
 	template <typename T> 
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat4x3<T> & tmat4x3<T>::operator*= 
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tmat4x3<T> & tmat4x3<T>::operator*= (U s)
 	{
 		this->value[0] *= s;
 		this->value[1] *= s;
@@ -424,10 +415,7 @@ namespace detail
 
 	template <typename T> 
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat4x3<T> & tmat4x3<T>::operator/= 
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tmat4x3<T> & tmat4x3<T>::operator/= (U s)
 	{
 		this->value[0] /= s;
 		this->value[1] /= s;
diff --git a/glm/core/type_mat4x4.hpp b/glm/core/type_mat4x4.hpp
index 07b981e9..85696b9a 100644
--- a/glm/core/type_mat4x4.hpp
+++ b/glm/core/type_mat4x4.hpp
@@ -140,19 +140,19 @@ namespace detail
 		template <typename U>
 		GLM_FUNC_DECL tmat4x4<T> & operator=  (tmat4x4<U> const & m);
 		template <typename U>
-		GLM_FUNC_DECL tmat4x4<T> & operator+= (U const & s);
+		GLM_FUNC_DECL tmat4x4<T> & operator+= (U s);
 		template <typename U>
 		GLM_FUNC_DECL tmat4x4<T> & operator+= (tmat4x4<U> const & m);
 		template <typename U>
-		GLM_FUNC_DECL tmat4x4<T> & operator-= (U const & s);
+		GLM_FUNC_DECL tmat4x4<T> & operator-= (U s);
 		template <typename U>
 		GLM_FUNC_DECL tmat4x4<T> & operator-= (tmat4x4<U> const & m);
 		template <typename U>
-		GLM_FUNC_DECL tmat4x4<T> & operator*= (U const & s);
+		GLM_FUNC_DECL tmat4x4<T> & operator*= (U s);
 		template <typename U>
 		GLM_FUNC_DECL tmat4x4<T> & operator*= (tmat4x4<U> const & m);
 		template <typename U>
-		GLM_FUNC_DECL tmat4x4<T> & operator/= (U const & s);
+		GLM_FUNC_DECL tmat4x4<T> & operator/= (U s);
 		template <typename U>
 		GLM_FUNC_DECL tmat4x4<T> & operator/= (tmat4x4<U> const & m);
 		GLM_FUNC_DECL tmat4x4<T> & operator++ ();
diff --git a/glm/core/type_mat4x4.inl b/glm/core/type_mat4x4.inl
index 9640acff..29f80d8e 100644
--- a/glm/core/type_mat4x4.inl
+++ b/glm/core/type_mat4x4.inl
@@ -374,10 +374,7 @@ namespace detail
 
 	template <typename T> 
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat4x4<T>& tmat4x4<T>::operator+= 
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tmat4x4<T>& tmat4x4<T>::operator+= (U s)
 	{
 		this->value[0] += s;
 		this->value[1] += s;
@@ -402,10 +399,7 @@ namespace detail
 
 	template <typename T> 
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat4x4<T> & tmat4x4<T>::operator-= 
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tmat4x4<T> & tmat4x4<T>::operator-= (U s)
 	{
 		this->value[0] -= s;
 		this->value[1] -= s;
@@ -430,10 +424,7 @@ namespace detail
 
 	template <typename T> 
 	template <typename U>
-	GLM_FUNC_QUALIFIER tmat4x4<T> & tmat4x4<T>::operator*= 
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tmat4x4<T> & tmat4x4<T>::operator*= (U s)
 	{
 		this->value[0] *= s;
 		this->value[1] *= s;
@@ -454,10 +445,7 @@ namespace detail
 
 	template <typename T> 
 	template <typename U>
-	GLM_FUNC_QUALIFIER tmat4x4<T> & tmat4x4<T>::operator/= 
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tmat4x4<T> & tmat4x4<T>::operator/= (U s)
 	{
 		this->value[0] /= s;
 		this->value[1] /= s;

From 579ab2b7d2242431e38ed19df6ddbb92597d15b9 Mon Sep 17 00:00:00 2001
From: Christophe Riccio <mail@g-truc.net>
Date: Tue, 17 Sep 2013 23:02:04 +0200
Subject: [PATCH 5/5] Fixed const ref issue for vector types. Backport from GLM
 0.9.5 branch #116

---
 glm/core/type_vec2.hpp | 20 ++++++++---------
 glm/core/type_vec2.inl | 50 +++++++++---------------------------------
 glm/core/type_vec3.hpp | 20 ++++++++---------
 glm/core/type_vec3.inl | 50 +++++++++---------------------------------
 glm/core/type_vec4.hpp | 20 ++++++++---------
 glm/core/type_vec4.inl | 50 +++++++++---------------------------------
 readme.txt             |  5 +++--
 7 files changed, 63 insertions(+), 152 deletions(-)

diff --git a/glm/core/type_vec2.hpp b/glm/core/type_vec2.hpp
index 3f8083d8..a8581980 100644
--- a/glm/core/type_vec2.hpp
+++ b/glm/core/type_vec2.hpp
@@ -165,19 +165,19 @@ namespace detail
 		GLM_FUNC_DECL tvec2<T> & operator= (tvec2<U> const & v);
 
 		template <typename U> 
-		GLM_FUNC_DECL tvec2<T> & operator+=(U const & s);
+		GLM_FUNC_DECL tvec2<T> & operator+=(U s);
 		template <typename U> 
 		GLM_FUNC_DECL tvec2<T> & operator+=(tvec2<U> const & v);
 		template <typename U> 
-		GLM_FUNC_DECL tvec2<T> & operator-=(U const & s);
+		GLM_FUNC_DECL tvec2<T> & operator-=(U s);
 		template <typename U> 
 		GLM_FUNC_DECL tvec2<T> & operator-=(tvec2<U> const & v);
 		template <typename U> 
-		GLM_FUNC_DECL tvec2<T> & operator*=(U const & s);
+		GLM_FUNC_DECL tvec2<T> & operator*=(U s);
 		template <typename U> 
 		GLM_FUNC_DECL tvec2<T> & operator*=(tvec2<U> const & v);
 		template <typename U> 
-		GLM_FUNC_DECL tvec2<T> & operator/=(U const & s);
+		GLM_FUNC_DECL tvec2<T> & operator/=(U s);
 		template <typename U> 
 		GLM_FUNC_DECL tvec2<T> & operator/=(tvec2<U> const & v);
 		GLM_FUNC_DECL tvec2<T> & operator++();
@@ -187,27 +187,27 @@ namespace detail
 		// Unary bit operators
 
 		template <typename U> 
-		GLM_FUNC_DECL tvec2<T> & operator%= (U const & s);
+		GLM_FUNC_DECL tvec2<T> & operator%= (U s);
 		template <typename U> 
 		GLM_FUNC_DECL tvec2<T> & operator%= (tvec2<U> const & v);
 		template <typename U> 
-		GLM_FUNC_DECL tvec2<T> & operator&= (U const & s);
+		GLM_FUNC_DECL tvec2<T> & operator&= (U s);
 		template <typename U> 
 		GLM_FUNC_DECL tvec2<T> & operator&= (tvec2<U> const & v);
 		template <typename U> 
-		GLM_FUNC_DECL tvec2<T> & operator|= (U const & s);
+		GLM_FUNC_DECL tvec2<T> & operator|= (U s);
 		template <typename U> 
 		GLM_FUNC_DECL tvec2<T> & operator|= (tvec2<U> const & v);
 		template <typename U> 
-		GLM_FUNC_DECL tvec2<T> & operator^= (U const & s);
+		GLM_FUNC_DECL tvec2<T> & operator^= (U s);
 		template <typename U> 
 		GLM_FUNC_DECL tvec2<T> & operator^= (tvec2<U> const & v);
 		template <typename U> 
-		GLM_FUNC_DECL tvec2<T> & operator<<=(U const & s);
+		GLM_FUNC_DECL tvec2<T> & operator<<=(U s);
 		template <typename U> 
 		GLM_FUNC_DECL tvec2<T> & operator<<=(tvec2<U> const & v);
 		template <typename U> 
-		GLM_FUNC_DECL tvec2<T> & operator>>=(U const & s);
+		GLM_FUNC_DECL tvec2<T> & operator>>=(U s);
 		template <typename U> 
 		GLM_FUNC_DECL tvec2<T> & operator>>=(tvec2<U> const & v);
 
diff --git a/glm/core/type_vec2.inl b/glm/core/type_vec2.inl
index fbad911b..32e4f9f5 100644
--- a/glm/core/type_vec2.inl
+++ b/glm/core/type_vec2.inl
@@ -204,10 +204,7 @@ namespace detail
 
 	template <typename T>
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator+=
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator+=(U s)
 	{
 		this->x += T(s);
 		this->y += T(s);
@@ -228,10 +225,7 @@ namespace detail
 
 	template <typename T>
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator-=
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator-=(U s)
 	{
 		this->x -= T(s);
 		this->y -= T(s);
@@ -252,10 +246,7 @@ namespace detail
 
 	template <typename T>
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator*=
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator*=(U s)
 	{
 		this->x *= T(s);
 		this->y *= T(s);
@@ -276,10 +267,7 @@ namespace detail
 
 	template <typename T>
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator/=
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator/=(U s)
 	{
 		this->x /= T(s);
 		this->y /= T(s);
@@ -342,10 +330,7 @@ namespace detail
 
 	template <typename T>
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator%=
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator%=(U s)
 	{
 		this->x %= T(s);
 		this->y %= T(s);
@@ -366,10 +351,7 @@ namespace detail
 
 	template <typename T>
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator&=
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator&=(U s)
 	{
 		this->x &= T(s);
 		this->y &= T(s);
@@ -390,10 +372,7 @@ namespace detail
 
 	template <typename T>
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator|=
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator|=(U s)
 	{
 		this->x |= T(s);
 		this->y |= T(s);
@@ -414,10 +393,7 @@ namespace detail
 
 	template <typename T>
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator^=
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator^=(U s)
 	{
 		this->x ^= T(s);
 		this->y ^= T(s);
@@ -438,10 +414,7 @@ namespace detail
 
 	template <typename T>
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator<<=
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator<<=(U s)
 	{
 		this->x <<= T(s);
 		this->y <<= T(s);
@@ -462,10 +435,7 @@ namespace detail
 
 	template <typename T>
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator>>=
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator>>=(U s)
 	{
 		this->x >>= T(s);
 		this->y >>= T(s);
diff --git a/glm/core/type_vec3.hpp b/glm/core/type_vec3.hpp
index 7165fa5d..ea265ca9 100644
--- a/glm/core/type_vec3.hpp
+++ b/glm/core/type_vec3.hpp
@@ -189,19 +189,19 @@ namespace detail
 		GLM_FUNC_DECL tvec3<T> & operator= (tvec3<U> const & v);
 
 		template <typename U> 
-		GLM_FUNC_DECL tvec3<T> & operator+=(U const & s);
+		GLM_FUNC_DECL tvec3<T> & operator+=(U s);
 		template <typename U> 
 		GLM_FUNC_DECL tvec3<T> & operator+=(tvec3<U> const & v);
 		template <typename U> 
-		GLM_FUNC_DECL tvec3<T> & operator-=(U const & s);
+		GLM_FUNC_DECL tvec3<T> & operator-=(U s);
 		template <typename U> 
 		GLM_FUNC_DECL tvec3<T> & operator-=(tvec3<U> const & v);
 		template <typename U> 
-		GLM_FUNC_DECL tvec3<T> & operator*=(U const & s);
+		GLM_FUNC_DECL tvec3<T> & operator*=(U s);
 		template <typename U> 
 		GLM_FUNC_DECL tvec3<T> & operator*=(tvec3<U> const & v);
 		template <typename U> 
-		GLM_FUNC_DECL tvec3<T> & operator/=(U const & s);
+		GLM_FUNC_DECL tvec3<T> & operator/=(U s);
 		template <typename U> 
 		GLM_FUNC_DECL tvec3<T> & operator/=(tvec3<U> const & v);
 		GLM_FUNC_DECL tvec3<T> & operator++();
@@ -211,27 +211,27 @@ namespace detail
 		// Unary bit operators
 
 		template <typename U>
-		GLM_FUNC_DECL tvec3<T> & operator%= (U const & s);
+		GLM_FUNC_DECL tvec3<T> & operator%= (U s);
 		template <typename U>
 		GLM_FUNC_DECL tvec3<T> & operator%= (tvec3<U> const & v);
 		template <typename U>
-		GLM_FUNC_DECL tvec3<T> & operator&= (U const & s);
+		GLM_FUNC_DECL tvec3<T> & operator&= (U s);
 		template <typename U>
 		GLM_FUNC_DECL tvec3<T> & operator&= (tvec3<U> const & v);
 		template <typename U>
-		GLM_FUNC_DECL tvec3<T> & operator|= (U const & s);
+		GLM_FUNC_DECL tvec3<T> & operator|= (U s);
 		template <typename U>
 		GLM_FUNC_DECL tvec3<T> & operator|= (tvec3<U> const & v);
 		template <typename U>
-		GLM_FUNC_DECL tvec3<T> & operator^= (U const & s);
+		GLM_FUNC_DECL tvec3<T> & operator^= (U s);
 		template <typename U>
 		GLM_FUNC_DECL tvec3<T> & operator^= (tvec3<U> const & v);
 		template <typename U>
-		GLM_FUNC_DECL tvec3<T> & operator<<=(U const & s);
+		GLM_FUNC_DECL tvec3<T> & operator<<=(U s);
 		template <typename U>
 		GLM_FUNC_DECL tvec3<T> & operator<<=(tvec3<U> const & v);
 		template <typename U>
-		GLM_FUNC_DECL tvec3<T> & operator>>=(U const & s);
+		GLM_FUNC_DECL tvec3<T> & operator>>=(U s);
 		template <typename U>
 		GLM_FUNC_DECL tvec3<T> & operator>>=(tvec3<U> const & v);
 
diff --git a/glm/core/type_vec3.inl b/glm/core/type_vec3.inl
index 3bcf1c8a..2279abf5 100644
--- a/glm/core/type_vec3.inl
+++ b/glm/core/type_vec3.inl
@@ -255,10 +255,7 @@ namespace detail
 
 	template <typename T>
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator+=
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator+=(U s)
 	{
 		this->x += T(s);
 		this->y += T(s);
@@ -281,10 +278,7 @@ namespace detail
 
 	template <typename T>
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator-=
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator-=(U s)
 	{
 		this->x -= T(s);
 		this->y -= T(s);
@@ -307,10 +301,7 @@ namespace detail
 
 	template <typename T>
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator*=
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator*=(U s)
 	{
 		this->x *= T(s);
 		this->y *= T(s);
@@ -333,10 +324,7 @@ namespace detail
 
 	template <typename T>
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator/=
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator/=(U s)
 	{
 		this->x /= T(s);
 		this->y /= T(s);
@@ -403,10 +391,7 @@ namespace detail
 
 	template <typename T>
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator%=
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator%=(U s)
 	{
 		this->x %= s;
 		this->y %= s;
@@ -429,10 +414,7 @@ namespace detail
 
 	template <typename T>
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator&=
-	(	
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator&=(U s)
 	{
 		this->x &= s;
 		this->y &= s;
@@ -455,10 +437,7 @@ namespace detail
 
 	template <typename T>
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator|=
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator|=(U s)
 	{
 		this->x |= s;
 		this->y |= s;
@@ -481,10 +460,7 @@ namespace detail
 
 	template <typename T>
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator^=
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator^=(U s)
 	{
 		this->x ^= s;
 		this->y ^= s;
@@ -507,10 +483,7 @@ namespace detail
 
 	template <typename T>
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator<<=
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator<<=(U s)
 	{
 		this->x <<= s;
 		this->y <<= s;
@@ -533,10 +506,7 @@ namespace detail
 
 	template <typename T>
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator>>=
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator>>=(U s)
 	{
 		this->x >>= T(s);
 		this->y >>= T(s);
diff --git a/glm/core/type_vec4.hpp b/glm/core/type_vec4.hpp
index c8860e22..d1e1b711 100644
--- a/glm/core/type_vec4.hpp
+++ b/glm/core/type_vec4.hpp
@@ -244,19 +244,19 @@ namespace detail
 		GLM_FUNC_DECL tvec4<T> & operator= (tvec4<U> const & v);
 
 		template <typename U>
-		GLM_FUNC_DECL tvec4<T> & operator+=(U const & s);
+		GLM_FUNC_DECL tvec4<T> & operator+=(U s);
 		template <typename U>
 		GLM_FUNC_DECL tvec4<T> & operator+=(tvec4<U> const & v);
 		template <typename U>
-		GLM_FUNC_DECL tvec4<T> & operator-=(U const & s);
+		GLM_FUNC_DECL tvec4<T> & operator-=(U s);
 		template <typename U>
 		GLM_FUNC_DECL tvec4<T> & operator-=(tvec4<U> const & v);
 		template <typename U>
-		GLM_FUNC_DECL tvec4<T> & operator*=(U const & s);
+		GLM_FUNC_DECL tvec4<T> & operator*=(U s);
 		template <typename U>
 		GLM_FUNC_DECL tvec4<T> & operator*=(tvec4<U> const & v);
 		template <typename U>
-		GLM_FUNC_DECL tvec4<T> & operator/=(U const & s);
+		GLM_FUNC_DECL tvec4<T> & operator/=(U s);
 		template <typename U>
 		GLM_FUNC_DECL tvec4<T> & operator/=(tvec4<U> const & v);
 		GLM_FUNC_DECL tvec4<T> & operator++();
@@ -266,27 +266,27 @@ namespace detail
 		// Unary bit operators
 
 		template <typename U>
-		GLM_FUNC_DECL tvec4<T> & operator%= (U const & s);
+		GLM_FUNC_DECL tvec4<T> & operator%= (U s);
 		template <typename U>
 		GLM_FUNC_DECL tvec4<T> & operator%= (tvec4<U> const & v);
 		template <typename U>
-		GLM_FUNC_DECL tvec4<T> & operator&= (U const & s);
+		GLM_FUNC_DECL tvec4<T> & operator&= (U s);
 		template <typename U>
 		GLM_FUNC_DECL tvec4<T> & operator&= (tvec4<U> const & v);
 		template <typename U>
-		GLM_FUNC_DECL tvec4<T> & operator|= (U const & s);
+		GLM_FUNC_DECL tvec4<T> & operator|= (U s);
 		template <typename U>
 		GLM_FUNC_DECL tvec4<T> & operator|= (tvec4<U> const & v);
 		template <typename U>
-		GLM_FUNC_DECL tvec4<T> & operator^= (U const & s);
+		GLM_FUNC_DECL tvec4<T> & operator^= (U s);
 		template <typename U>
 		GLM_FUNC_DECL tvec4<T> & operator^= (tvec4<U> const & v);
 		template <typename U>
-		GLM_FUNC_DECL tvec4<T> & operator<<=(U const & s);
+		GLM_FUNC_DECL tvec4<T> & operator<<=(U s);
 		template <typename U>
 		GLM_FUNC_DECL tvec4<T> & operator<<=(tvec4<U> const & v);
 		template <typename U>
-		GLM_FUNC_DECL tvec4<T> & operator>>=(U const & s);
+		GLM_FUNC_DECL tvec4<T> & operator>>=(U s);
 		template <typename U>
 		GLM_FUNC_DECL tvec4<T> & operator>>=(tvec4<U> const & v);
 
diff --git a/glm/core/type_vec4.inl b/glm/core/type_vec4.inl
index 744d2d0f..7f98c1b3 100644
--- a/glm/core/type_vec4.inl
+++ b/glm/core/type_vec4.inl
@@ -396,10 +396,7 @@ namespace detail
 
 	template <typename T>
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator+=
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator+= (U s)
 	{
 		this->x += T(s);
 		this->y += T(s);
@@ -424,10 +421,7 @@ namespace detail
 
 	template <typename T>
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator-=
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator-= (U s)
 	{
 		this->x -= T(s);
 		this->y -= T(s);
@@ -452,10 +446,7 @@ namespace detail
 
 	template <typename T>
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator*=
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator*= (U s)
 	{
 		this->x *= T(s);
 		this->y *= T(s);
@@ -480,10 +471,7 @@ namespace detail
 
 	template <typename T>
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator/=
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator/= (U s)
 	{
 		this->x /= T(s);
 		this->y /= T(s);
@@ -531,10 +519,7 @@ namespace detail
 
 	template <typename T>
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator%=
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator%= (U s)
 	{
 		this->x %= T(s);
 		this->y %= T(s);
@@ -559,10 +544,7 @@ namespace detail
 
 	template <typename T>
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator&=
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator&= (U s)
 	{
 		this->x &= T(s);
 		this->y &= T(s);
@@ -587,10 +569,7 @@ namespace detail
 
 	template <typename T>
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator|=
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator|= (U s)
 	{
 		this->x |= T(s);
 		this->y |= T(s);
@@ -615,10 +594,7 @@ namespace detail
 
 	template <typename T>
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator^=
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator^= (U s)
 	{
 		this->x ^= T(s);
 		this->y ^= T(s);
@@ -643,10 +619,7 @@ namespace detail
 
 	template <typename T>
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator<<=
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator<<= (U s)
 	{
 		this->x <<= T(s);
 		this->y <<= T(s);
@@ -671,10 +644,7 @@ namespace detail
 
 	template <typename T>
 	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator>>=
-	(
-		U const & s
-	)
+	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator>>= (U s)
 	{
 		this->x >>= T(s);
 		this->y >>= T(s);
diff --git a/readme.txt b/readme.txt
index 4216e268..6f2f406a 100644
--- a/readme.txt
+++ b/readme.txt
@@ -37,7 +37,7 @@ More informations in GLM manual:
 http://glm.g-truc.net/glm.pdf
 
 ================================================================================
-GLM 0.9.4.6: 2013-09-15
+GLM 0.9.4.6: 2013-09-18
 --------------------------------------------------------------------------------
 - Fixed detection to select the last known compiler if newer version #106
 - Fixed is_int and is_uint code duplication with GCC and C++11 #107 
@@ -45,10 +45,11 @@ GLM 0.9.4.6: 2013-09-15
 - Added c++1y mode support in CMake test suite
 - Removed ms extension mode to CMake when no using Visual C++
 - Added pedantic mode to CMake test suite for Clang and GCC
-- Added use of GCC frontend on Unix for ICC and Visual C++ fronted on Windows 
+- Added use of GCC frontend on Unix for ICC and Visual C++ fronted on Windows
   for ICC
 - Added compilation errors for unsupported compiler versions
 - Fixed glm::orientation with GLM_FORCE_RADIANS defined #112
+- Fixed const ref issue on assignment operator taking a scalar parameter #116
 
 ================================================================================
 GLM 0.9.4.5: 2013-08-12