Merge pull request #139 from regnirpsj/0.9.5

0.9.5: minor compile fixes, op+=/op*= for glm::quat, op<< for glm types

glm/core/setup.hpp

@@ -718,7 +718,7 @@
 
 #if(defined(GLM_MESSAGES) && !defined(GLM_MESSAGE_SWIZZLE_DISPLAYED))
 #	define GLM_MESSAGE_SWIZZLE_DISPLAYED
-#	if defined(GLM_SWIZZL)
+#	if defined(GLM_SWIZZLE)
 #		pragma message("GLM: Swizzling operators enabled")
 #	else
 #		pragma message("GLM: Swizzling operators disabled")

glm/ext.hpp

@@ -100,6 +100,7 @@
 #include "./gtx/int_10_10_10_2.hpp"
 #include "./gtx/integer.hpp"
 #include "./gtx/intersect.hpp"
+#include "./gtx/io.hpp"
 #include "./gtx/log_base.hpp"
 #include "./gtx/matrix_cross_product.hpp"
 #include "./gtx/matrix_interpolation.hpp"

glm/gtc/quaternion.hpp

@@ -106,6 +106,8 @@ namespace detail
 		GLM_FUNC_DECL T const & operator[](int i) const;
 
 		// Operators
+    GLM_FUNC_DECL tquat<T, P> & operator+=(tquat<T, P> const & q);
+    GLM_FUNC_DECL tquat<T, P> & operator*=(tquat<T, P> const & q);
 		GLM_FUNC_DECL tquat<T, P> & operator*=(T const & s);
 		GLM_FUNC_DECL tquat<T, P> & operator/=(T const & s);
 	};

glm/gtc/quaternion.inl

@@ -182,6 +182,34 @@ namespace detail
 	//////////////////////////////////////////////////////////////
 	// tquat<valType> operators
 
+  template <typename T, precision P>
+  GLM_FUNC_QUALIFIER tquat<T, P> & tquat<T, P>::operator +=
+  (
+   tquat<T, P> const & q
+  )
+  {
+    this->w += q.w;
+		this->x += q.x;
+		this->y += q.y;
+		this->z += q.z;
+		return *this;
+  }
+
+  template <typename T, precision P>
+  GLM_FUNC_QUALIFIER tquat<T, P> & tquat<T, P>::operator *=
+  (
+   tquat<T, P> const & q
+  )
+  {
+    tquat<T, P> const p(*this);
+    
+    this->w = p.w * q.w - p.x * q.x - p.y * q.y - p.z * q.z;
+		this->x = p.w * q.x + p.x * q.w + p.y * q.z - p.z * q.y;
+		this->y = p.w * q.y + p.y * q.w + p.z * q.x - p.x * q.z;
+		this->z = p.w * q.z + p.z * q.w + p.x * q.y - p.y * q.x;
+		return *this;
+  }
+    
 	template <typename T, precision P> 
 	GLM_FUNC_QUALIFIER tquat<T, P> & tquat<T, P>::operator *=
 	(
@@ -194,7 +222,7 @@ namespace detail
 		this->z *= s;
 		return *this;
 	}
-
+    
 	template <typename T, precision P> 
 	GLM_FUNC_QUALIFIER tquat<T, P> & tquat<T, P>::operator /=
 	(
@@ -227,11 +255,7 @@ namespace detail
 		detail::tquat<T, P> const & p
 	)
 	{
-		return detail::tquat<T, P>(
-			q.w + p.w,
-			q.x + p.x,
-			q.y + p.y,
-			q.z + p.z);
+		return detail::tquat<T, P>(q) += p;
 	}
 
 	template <typename T, precision P>
@@ -241,11 +265,7 @@ namespace detail
 		detail::tquat<T, P> const & p
 	)
 	{
-		return detail::tquat<T, P>(
-			q.w * p.w - q.x * p.x - q.y * p.y - q.z * p.z,
-			q.w * p.x + q.x * p.w + q.y * p.z - q.z * p.y,
-			q.w * p.y + q.y * p.w + q.z * p.x - q.x * p.z,
-			q.w * p.z + q.z * p.w + q.x * p.y - q.y * p.x);
+		return detail::tquat<T, P>(q) *= p;
 	}
 
 	// Transformation

glm/gtx/io.hpp

@@ -0,0 +1,159 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
+/// Permission is hereby granted, free of charge, to any person obtaining a copy
+/// of this software and associated documentation files (the "Software"), to deal
+/// in the Software without restriction, including without limitation the rights
+/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+/// copies of the Software, and to permit persons to whom the Software is
+/// furnished to do so, subject to the following conditions:
+/// 
+/// The above copyright notice and this permission notice shall be included in
+/// all copies or substantial portions of the Software.
+/// 
+/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+/// THE SOFTWARE.
+///
+/// @ref gtx_io
+/// @file glm/gtx/io.hpp
+/// @date 2013-11-22
+/// @author Jan P Springer ([email protected])
+///
+/// @see core (dependence)
+/// @see gtx_quaternion (dependence)
+///
+/// @defgroup gtx_io GLM_GTX_io
+/// @ingroup gtx
+/// 
+/// @brief std::[w]ostream support for glm types
+///
+/// <glm/gtx/io.hpp> needs to be included to use these functionalities.
+///////////////////////////////////////////////////////////////////////////////////
+
+#ifndef GLM_GTX_io
+#define GLM_GTX_io GLM_VERSION
+
+// Dependency:
+#include "../glm.hpp"
+#include "../gtx/quaternion.hpp"
+
+#if(defined(GLM_MESSAGES) && !defined(glm_ext))
+#	pragma message("GLM: GLM_GTX_io extension included")
+#endif
+
+#include <iosfwd>  // std::basic_ostream<> (fwd)
+#include <utility> // std::pair<>
+
+namespace glm
+{
+  /// @addtogroup gtx_io
+	/// @{
+  
+  namespace io
+  {
+    
+    class precision_guard {
+
+    public:
+      
+      GLM_FUNC_DECL explicit precision_guard();
+      GLM_FUNC_DECL         ~precision_guard();
+                
+    private:
+
+      unsigned precision_;
+      unsigned value_width_;
+      
+    };
+
+    enum class order_t { column_major, row_major, };
+
+    class format_guard {
+
+    public:
+
+      GLM_FUNC_DECL explicit format_guard();
+      GLM_FUNC_DECL         ~format_guard();
+                
+    private:
+
+      order_t order_;
+      char    cr_;
+      
+    };
+
+    // decimal places (dflt: 3)
+    GLM_FUNC_DECL unsigned& precision();
+
+    // sign + value + '.' + decimals (dflt: 1 + 4 + 1 + precision())
+    GLM_FUNC_DECL unsigned& value_width();
+
+    // matrix output order (dflt: row_major)
+    GLM_FUNC_DECL order_t& order();
+
+    // carriage/return char (dflt: '\n')
+    GLM_FUNC_DECL char& cr();
+
+    // matrix output order -> column_major
+    GLM_FUNC_DECL std::ios_base& column_major(std::ios_base&);
+
+    // matrix output order -> row_major
+    GLM_FUNC_DECL std::ios_base& row_major   (std::ios_base&);
+
+    // carriage/return char -> '\n'
+    GLM_FUNC_DECL std::ios_base& formatted   (std::ios_base&);
+
+    // carriage/return char -> ' '
+    GLM_FUNC_DECL std::ios_base& unformatted (std::ios_base&);
+
+  }//namespace io
+
+  namespace detail
+  {
+
+    template <typename CTy, typename CTr, typename T, precision P>
+    GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tquat<T,P> const&);
+    template <typename CTy, typename CTr, typename T, precision P>
+    GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tvec2<T,P> const&);
+    template <typename CTy, typename CTr, typename T, precision P>
+    GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tvec3<T,P> const&);
+    template <typename CTy, typename CTr, typename T, precision P>
+    GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tvec4<T,P> const&);
+    template <typename CTy, typename CTr, typename T, precision P>
+    GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat2x2<T,P> const&);
+    template <typename CTy, typename CTr, typename T, precision P>
+    GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat2x3<T,P> const&);
+    template <typename CTy, typename CTr, typename T, precision P>
+    GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat2x4<T,P> const&);
+    template <typename CTy, typename CTr, typename T, precision P>
+    GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat3x2<T,P> const&);
+    template <typename CTy, typename CTr, typename T, precision P>
+    GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat3x3<T,P> const&);
+    template <typename CTy, typename CTr, typename T, precision P>
+    GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat3x4<T,P> const&);
+    template <typename CTy, typename CTr, typename T, precision P>
+    GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat4x2<T,P> const&);
+    template <typename CTy, typename CTr, typename T, precision P>
+    GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat4x3<T,P> const&);
+    template <typename CTy, typename CTr, typename T, precision P>
+    GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat4x4<T,P> const&);
+    
+    template <typename CTy, typename CTr, typename T, precision P>
+    GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&,
+                                                          std::pair<tmat4x4<T,P> const,
+                                                                    tmat4x4<T,P> const> const&);
+    
+  }//namespace detail
+  
+	/// @}
+}//namespace glm
+
+#include "io.inl"
+
+#endif//GLM_GTX_io

glm/gtx/io.inl

@@ -0,0 +1,420 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2013-11-22
+// Updated : 2013-11-22
+// Licence : This source is under MIT License
+// File    : glm/gtx/inl.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+// #include <boost/io/ios_state.hpp> // boost::io::ios_all_saver
+#include <iomanip>                // std::setfill<>, std::fixed, std::setprecision, std::right,
+                                  // std::setw
+#include <ostream>                // std::basic_ostream<>
+
+namespace glm
+{
+  namespace io
+  {
+  
+    /* explicit */ GLM_FUNC_QUALIFIER
+    precision_guard::precision_guard()
+      : precision_  (precision()),
+        value_width_(value_width())
+    {}
+
+    GLM_FUNC_QUALIFIER
+    precision_guard::~precision_guard()
+    {
+      value_width() = value_width_;
+      precision()   = precision_;
+    }
+
+    /* explicit */ GLM_FUNC_QUALIFIER
+    format_guard::format_guard()
+      : order_(order()),
+        cr_   (cr())
+    {}
+
+    GLM_FUNC_QUALIFIER
+    format_guard::~format_guard()
+    {
+      cr()    = cr_;
+      order() = order_;
+    }
+
+    GLM_FUNC_QUALIFIER unsigned&
+    precision()
+    {
+      static unsigned p(3);
+
+      return p;
+    }
+    
+    GLM_FUNC_QUALIFIER unsigned&
+    value_width()
+    {
+      static unsigned p(9);
+
+      return p;
+    }
+    
+    GLM_FUNC_QUALIFIER order_t&
+    order()
+    {
+      static order_t p(order_t::row_major);
+
+      return p;
+    }
+    
+    GLM_FUNC_QUALIFIER char&
+    cr()
+    {
+      static char p('\n'); return p;
+    }
+    
+    GLM_FUNC_QUALIFIER std::ios_base&
+    column_major(std::ios_base& os)
+    {
+      order() = order_t::column_major;
+      
+      return os;
+    }
+    
+    GLM_FUNC_QUALIFIER std::ios_base&
+    row_major(std::ios_base& os)
+    {
+      order() = order_t::row_major;
+      
+      return os;
+    }
+
+    GLM_FUNC_QUALIFIER std::ios_base&
+    formatted(std::ios_base& os)
+    {
+      cr() = '\n';
+      
+      return os;
+    }
+    
+    GLM_FUNC_QUALIFIER std::ios_base&
+    unformatted(std::ios_base& os)
+    {
+      cr() = ' ';
+      
+      return os;
+    }
+    
+  } // namespace io
+  
+  namespace detail {
+    
+    // functions, inlined (inline)
+
+    template <typename CTy, typename CTr, typename T, precision P>
+    GLM_FUNC_QUALIFIER std::basic_ostream<CTy,CTr>&
+    operator<<(std::basic_ostream<CTy,CTr>& os, tquat<T,P> const& a)
+    {
+      typename std::basic_ostream<CTy,CTr>::sentry const cerberus(os);
+
+      if (cerberus) {
+        // boost::io::ios_all_saver const ias(os);
+      
+        os << std::fixed << std::setprecision(io::precision())
+           << '['
+           << std::right << std::setfill<CTy>(' ') << std::setw(io::value_width()) << a.w << ','
+           << std::right << std::setfill<CTy>(' ') << std::setw(io::value_width()) << a.x << ','
+           << std::right << std::setfill<CTy>(' ') << std::setw(io::value_width()) << a.y << ','
+           << std::right << std::setfill<CTy>(' ') << std::setw(io::value_width()) << a.z
+           << ']';
+      }
+
+      return os;
+    }
+    
+    template <typename CTy, typename CTr, typename T, precision P>
+    GLM_FUNC_QUALIFIER std::basic_ostream<CTy,CTr>&
+    operator<<(std::basic_ostream<CTy,CTr>& os, tvec2<T,P> const& a)
+    {
+      typename std::basic_ostream<CTy,CTr>::sentry const cerberus(os);
+
+      if (cerberus) {
+        // boost::io::ios_all_saver const ias(os);
+      
+        os << std::fixed << std::setprecision(io::precision())
+           << '['
+           << std::right << std::setfill<CTy>(' ') << std::setw(io::value_width()) << a.x << ','
+           << std::right << std::setfill<CTy>(' ') << std::setw(io::value_width()) << a.y
+           << ']';
+      }
+
+      return os;
+    }
+  
+    template <typename CTy, typename CTr, typename T, precision P>
+    GLM_FUNC_QUALIFIER std::basic_ostream<CTy,CTr>&
+    operator<<(std::basic_ostream<CTy,CTr>& os, tvec3<T,P> const& a)
+    {
+      typename std::basic_ostream<CTy,CTr>::sentry const cerberus(os);
+
+      if (cerberus) {
+        // boost::io::ios_all_saver const ias(os);
+      
+        os << std::fixed << std::setprecision(io::precision())
+           << '['
+           << std::right << std::setfill<CTy>(' ') << std::setw(io::value_width()) << a.x << ','
+           << std::right << std::setfill<CTy>(' ') << std::setw(io::value_width()) << a.y << ','
+           << std::right << std::setfill<CTy>(' ') << std::setw(io::value_width()) << a.z
+           << ']';
+      }
+
+      return os;
+    }
+
+    template <typename CTy, typename CTr, typename T, precision P>
+    GLM_FUNC_QUALIFIER std::basic_ostream<CTy,CTr>&
+    operator<<(std::basic_ostream<CTy,CTr>& os, tvec4<T,P> const& a)
+    {
+      typename std::basic_ostream<CTy,CTr>::sentry const cerberus(os);
+
+      if (cerberus) {
+        // boost::io::ios_all_saver const ias(os);
+      
+        os << std::fixed << std::setprecision(io::precision())
+           << '['
+           << std::right << std::setfill<CTy>(' ') << std::setw(io::value_width()) << a.x << ','
+           << std::right << std::setfill<CTy>(' ') << std::setw(io::value_width()) << a.y << ','
+           << std::right << std::setfill<CTy>(' ') << std::setw(io::value_width()) << a.z << ','
+           << std::right << std::setfill<CTy>(' ') << std::setw(io::value_width()) << a.w
+           << ']';
+      }
+
+      return os;
+    }
+
+    template <typename CTy, typename CTr, typename T, precision P>
+    GLM_FUNC_QUALIFIER std::basic_ostream<CTy,CTr>&
+    operator<<(std::basic_ostream<CTy,CTr>& os, tmat2x2<T,P> const& a)
+    {
+      typename std::basic_ostream<CTy,CTr>::sentry const cerberus(os);
+
+      if (cerberus) {
+        tmat2x2<T,P> m(a);
+
+        if (io::order_t::row_major == io::order()) {
+          m = transpose(a);
+        }
+        
+        os << io::cr()
+           << '[' << m[0] << io::cr()
+           << ' ' << m[1] << ']';
+      }
+
+      return os;
+    }
+
+    template <typename CTy, typename CTr, typename T, precision P>
+    GLM_FUNC_QUALIFIER std::basic_ostream<CTy,CTr>&
+    operator<<(std::basic_ostream<CTy,CTr>& os, tmat2x3<T,P> const& a)
+    {
+      typename std::basic_ostream<CTy,CTr>::sentry const cerberus(os);
+
+      if (cerberus) {
+        tmat3x2<T,P> m(a);
+
+        if (io::order_t::row_major == io::order()) {
+          m = transpose(a);
+        }
+
+        os << io::cr()
+           << '[' << m[0] << io::cr()
+           << ' ' << m[1] << io::cr()
+           << ' ' << m[2] << ']';
+      }
+
+      return os;
+    }
+
+    template <typename CTy, typename CTr, typename T, precision P>
+    GLM_FUNC_QUALIFIER std::basic_ostream<CTy,CTr>&
+    operator<<(std::basic_ostream<CTy,CTr>& os, tmat2x4<T,P> const& a)
+    {
+      typename std::basic_ostream<CTy,CTr>::sentry const cerberus(os);
+
+      if (cerberus) {
+        tmat4x2<T,P> m(a);
+
+        if (io::order_t::row_major == io::order()) {
+          m = transpose(a);
+        }
+
+        os << io::cr()
+           << '[' << m[0] << io::cr()
+           << ' ' << m[1] << io::cr()
+           << ' ' << m[2] << io::cr()
+           << ' ' << m[3] << ']';
+      }
+
+      return os;
+    }
+
+    template <typename CTy, typename CTr, typename T, precision P>
+    GLM_FUNC_QUALIFIER std::basic_ostream<CTy,CTr>&
+    operator<<(std::basic_ostream<CTy,CTr>& os, tmat3x2<T,P> const& a)
+    {
+      typename std::basic_ostream<CTy,CTr>::sentry const cerberus(os);
+
+      if (cerberus) {
+        tmat2x3<T,P> m(a);
+
+        if (io::order_t::row_major == io::order()) {
+          m = transpose(a);
+        }
+
+        os << io::cr()
+           << '[' << m[0] << io::cr()
+           << ' ' << m[1] << ']';
+      }
+
+      return os;
+    }
+
+    template <typename CTy, typename CTr, typename T, precision P>
+    GLM_FUNC_QUALIFIER std::basic_ostream<CTy,CTr>&
+    operator<<(std::basic_ostream<CTy,CTr>& os, tmat3x3<T,P> const& a)
+    {
+      typename std::basic_ostream<CTy,CTr>::sentry const cerberus(os);
+
+      if (cerberus) {
+        tmat3x3<T,P> m(a);
+
+        if (io::order_t::row_major == io::order()) {
+          m = transpose(a);
+        }
+
+        os << io::cr()
+           << '[' << m[0] << io::cr()
+           << ' ' << m[1] << io::cr()
+           << ' ' << m[2] << ']';
+      }
+
+      return os;
+    }
+
+    template <typename CTy, typename CTr, typename T, precision P>
+    GLM_FUNC_QUALIFIER std::basic_ostream<CTy,CTr>&
+    operator<<(std::basic_ostream<CTy,CTr>& os, tmat3x4<T,P> const& a)
+    {
+      typename std::basic_ostream<CTy,CTr>::sentry const cerberus(os);
+
+      if (cerberus) {
+        tmat4x3<T,P> m(a);
+
+        if (io::order_t::row_major == io::order()) {
+          m = transpose(a);
+        }
+
+        os << io::cr()
+           << '[' << m[0] << io::cr()
+           << ' ' << m[1] << io::cr()
+           << ' ' << m[2] << io::cr()
+           << ' ' << m[3] << ']';
+      }
+
+      return os;
+    }
+
+    template <typename CTy, typename CTr, typename T, precision P>
+    GLM_FUNC_QUALIFIER std::basic_ostream<CTy,CTr>&
+    operator<<(std::basic_ostream<CTy,CTr>& os, tmat4x2<T,P> const& a)
+    {
+      typename std::basic_ostream<CTy,CTr>::sentry const cerberus(os);
+
+      if (cerberus) {
+        tmat2x4<T,P> m(a);
+
+        if (io::order_t::row_major == io::order()) {
+          m = transpose(a);
+        }
+
+        os << io::cr()
+           << '[' << m[0] << io::cr()
+           << ' ' << m[1] << ']';
+      }
+
+      return os;
+    }
+
+    template <typename CTy, typename CTr, typename T, precision P>
+    GLM_FUNC_QUALIFIER std::basic_ostream<CTy,CTr>&
+    operator<<(std::basic_ostream<CTy,CTr>& os, tmat4x3<T,P> const& a)
+    {
+      typename std::basic_ostream<CTy,CTr>::sentry const cerberus(os);
+
+      if (cerberus) {
+        tmat3x4<T,P> m(a);
+
+        if (io::order_t::row_major == io::order()) {
+          m = transpose(a);
+        }
+
+        os << io::cr()
+           << '[' << m[0] << io::cr()
+           << ' ' << m[1] << io::cr()
+           << ' ' << m[2] << ']';
+      }
+
+      return os;
+    }
+
+    template <typename CTy, typename CTr, typename T, precision P>
+    GLM_FUNC_QUALIFIER std::basic_ostream<CTy,CTr>&
+    operator<<(std::basic_ostream<CTy,CTr>& os, tmat4x4<T,P> const& a)
+    {
+      typename std::basic_ostream<CTy,CTr>::sentry const cerberus(os);
+
+      if (cerberus) {
+        tmat4x4<T,P> m(a);
+
+        if (io::order_t::row_major == io::order()) {
+          m = transpose(a);
+        }
+
+        os << io::cr()
+           << '[' << m[0] << io::cr()
+           << ' ' << m[1] << io::cr()
+           << ' ' << m[2] << io::cr()
+           << ' ' << m[3] << ']';
+      }
+
+      return os;
+    }
+
+    template <typename CTy, typename CTr, typename T, precision P>
+    GLM_FUNC_QUALIFIER std::basic_ostream<CTy,CTr>&
+    operator<<(std::basic_ostream<CTy,CTr>& os,
+               std::pair<tmat4x4<T,P> const, tmat4x4<T,P> const> const& a)
+    {
+      typename std::basic_ostream<CTy,CTr>::sentry const cerberus(os);
+
+      if (cerberus) {
+        tmat4x4<T,P> ml(a.first);
+        tmat4x4<T,P> mr(a.second);
+
+        if (io::order_t::row_major == io::order()) {
+          ml = transpose(a.first);
+          mr = transpose(a.second);
+        }
+        
+        os << io::cr()
+           << '[' << ml[0] << "  [" << mr[0] << io::cr()
+           << ' ' << ml[1] << "   " << mr[1] << io::cr()
+           << ' ' << ml[2] << "   " << mr[2] << io::cr()
+           << ' ' << ml[3] << "]  " << mr[3] << ']';
+      }
+
+      return os;
+    }
+    
+  }//namespace detail
+}//namespace glm

test/core/core_type_vec4.cpp

@@ -11,6 +11,7 @@
 #include <glm/core/type_vec3.hpp>
 #include <glm/core/type_vec4.hpp>
 #include <glm/core/func_vector_relational.hpp>
+#include <cstdio>
 #include <ctime>
 #include <vector>
 
@@ -317,7 +318,7 @@ int test_vec4_perf_AoS(std::size_t Size)
 
 	std::clock_t EndTime = std::clock();
 
-	printf("AoS: %d\n", EndTime - StartTime);
+  std::printf("AoS: %d\n", EndTime - StartTime);
 
 	return Error;
 }
@@ -356,7 +357,7 @@ int test_vec4_perf_SoA(std::size_t Size)
 
 	std::clock_t EndTime = std::clock();
 
-	printf("SoA: %d\n", EndTime - StartTime);
+  std::printf("SoA: %d\n", EndTime - StartTime);
 
 	return Error;
 }

test/gtc/gtc_quaternion.cpp

@@ -210,6 +210,15 @@ int test_quat_mul()
 	glm::quat temp5 = glm::normalize(temp1 * temp2);
 	glm::vec3 temp6 = temp5 * glm::vec3(0.0, 1.0, 0.0) * glm::inverse(temp5);
 
+  {
+    glm::quat temp7;
+
+    temp7 *= temp5;
+    temp7 *= glm::inverse(temp5);
+
+    Error += temp7 != glm::quat();
+  }
+  
 	return Error;
 }
 

test/gtx/CMakeLists.txt

@@ -16,6 +16,7 @@ glmCreateTestGTC(gtx_handed_coordinate_space)
 glmCreateTestGTC(gtx_inertia)
 glmCreateTestGTC(gtx_integer)
 glmCreateTestGTC(gtx_intersect)
+glmCreateTestGTC(gtx_io)
 glmCreateTestGTC(gtx_log_base)
 glmCreateTestGTC(gtx_matrix_cross_product)
 glmCreateTestGTC(gtx_matrix_interpolation)

test/gtx/gtx_io.cpp

@@ -0,0 +1,140 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2013-11-22
+// Updated : 2013-11-22
+// Licence : This source is under MIT licence
+// File    : test/gtx/io.cpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#include <glm/glm.hpp>
+#include <glm/gtc/type_precision.hpp>
+#include <glm/gtx/io.hpp>
+#include <iostream>
+#include <typeinfo>
+
+namespace {
+  
+  template <typename CTy, typename CTr>
+  std::basic_ostream<CTy,CTr>&
+  operator<<(std::basic_ostream<CTy,CTr>& os, glm::precision const& a)
+  {
+    typename std::basic_ostream<CTy,CTr>::sentry const cerberus(os);
+
+    if (cerberus) {
+      switch (a) {
+      case glm::highp:   os << "hi"; break;
+      case glm::mediump: os << "md"; break;
+      case glm::lowp:    os << "lo"; break;
+      }
+    }
+
+    return os;
+  }
+
+} // namespace {
+
+template <typename T, glm::precision P, typename OS>
+int test_io_vec(OS& os)
+{
+  os << '\n'
+     << typeid(OS).name()
+     << '\n';
+  
+  glm::detail::tvec2<T,P> const v2(0, 1);
+  glm::detail::tvec3<T,P> const v3(2, 3, 4);
+  glm::detail::tvec4<T,P> const v4(5, 6, 7, 8);
+
+  os << "vec2<" << typeid(T).name() << ',' << P << ">: " << v2 << '\n'
+     << "vec3<" << typeid(T).name() << ',' << P << ">: " << v3 << '\n'
+     << "vec4<" << typeid(T).name() << ',' << P << ">: " << v4 << '\n';
+
+  glm::io::precision_guard const iopg;
+  
+  glm::io::precision()   = 2;
+  glm::io::value_width() = 1 + 2 + 1 + glm::io::precision();
+  
+  os << "vec2<" << typeid(T).name() << ',' << P << ">: " << v2 << '\n'
+     << "vec3<" << typeid(T).name() << ',' << P << ">: " << v3 << '\n'
+     << "vec4<" << typeid(T).name() << ',' << P << ">: " << v4 << '\n';
+
+  return 0;
+}
+
+template <typename T, glm::precision P, typename OS>
+int test_io_mat(OS& os)
+{
+  os << '\n'
+     << typeid(OS).name()
+     << '\n';
+
+  glm::detail::tvec2<T,P> const v2_1( 0,  1);
+  glm::detail::tvec2<T,P> const v2_2( 2,  3);
+  glm::detail::tvec2<T,P> const v2_3( 4,  5);
+  glm::detail::tvec2<T,P> const v2_4( 6,  7);
+  glm::detail::tvec3<T,P> const v3_1( 8,  9, 10);
+  glm::detail::tvec3<T,P> const v3_2(11, 12, 13);
+  glm::detail::tvec3<T,P> const v3_3(14, 15, 16);
+  glm::detail::tvec3<T,P> const v3_4(17, 18, 19);
+  glm::detail::tvec4<T,P> const v4_1(20, 21, 22, 23);
+  glm::detail::tvec4<T,P> const v4_2(24, 25, 26, 27);
+  glm::detail::tvec4<T,P> const v4_3(28, 29, 30, 31);
+  glm::detail::tvec4<T,P> const v4_4(32, 33, 34, 35);
+
+#if 0
+  os << "mat2x2<" << typeid(T).name() << ',' << P << ">: " << glm::detail::tmat2x2<T,P>(v2_1, v2_2) << '\n'
+     << "mat2x3<" << typeid(T).name() << ',' << P << ">: " << glm::detail::tmat2x3<T,P>(v3_1, v3_2) << '\n'
+     << "mat2x4<" << typeid(T).name() << ',' << P << ">: " << glm::detail::tmat2x4<T,P>(v4_1, v4_2) << '\n'
+     << "mat3x2<" << typeid(T).name() << ',' << P << ">: " << glm::detail::tmat3x2<T,P>(v2_1, v2_2, v2_3) << '\n'
+     << "mat3x3<" << typeid(T).name() << ',' << P << ">: " << glm::detail::tmat3x3<T,P>(v3_1, v3_2, v3_3) << '\n'
+     << "mat3x4<" << typeid(T).name() << ',' << P << ">: " << glm::detail::tmat3x4<T,P>(v4_1, v4_2, v4_3) << '\n'
+     << "mat4x2<" << typeid(T).name() << ',' << P << ">: " << glm::detail::tmat4x2<T,P>(v2_1, v2_2, v2_3, v2_4) << '\n'
+     << "mat4x3<" << typeid(T).name() << ',' << P << ">: " << glm::detail::tmat4x3<T,P>(v3_1, v3_2, v3_3, v3_4) << '\n'
+     << "mat4x4<" << typeid(T).name() << ',' << P << ">: " << glm::detail::tmat4x4<T,P>(v4_1, v4_2, v4_3, v4_4) << '\n';
+#endif
+  
+  glm::io::precision_guard const iopg;
+  
+  glm::io::precision()   = 2;
+  glm::io::value_width() = 1 + 2 + 1 + glm::io::precision();
+  
+  os << "mat2x2<" << typeid(T).name() << ',' << P << ">: " << glm::detail::tmat2x2<T,P>(v2_1, v2_2) << '\n'
+     << "mat2x3<" << typeid(T).name() << ',' << P << ">: " << glm::detail::tmat2x3<T,P>(v3_1, v3_2) << '\n'
+     << "mat2x4<" << typeid(T).name() << ',' << P << ">: " << glm::detail::tmat2x4<T,P>(v4_1, v4_2) << '\n'
+     << "mat3x2<" << typeid(T).name() << ',' << P << ">: " << glm::detail::tmat3x2<T,P>(v2_1, v2_2, v2_3) << '\n'
+     << "mat3x3<" << typeid(T).name() << ',' << P << ">: " << glm::detail::tmat3x3<T,P>(v3_1, v3_2, v3_3) << '\n'
+     << "mat3x4<" << typeid(T).name() << ',' << P << ">: " << glm::detail::tmat3x4<T,P>(v4_1, v4_2, v4_3) << '\n'
+     << "mat4x2<" << typeid(T).name() << ',' << P << ">: " << glm::detail::tmat4x2<T,P>(v2_1, v2_2, v2_3, v2_4) << '\n'
+     << "mat4x3<" << typeid(T).name() << ',' << P << ">: " << glm::detail::tmat4x3<T,P>(v3_1, v3_2, v3_3, v3_4) << '\n'
+     << "mat4x4<" << typeid(T).name() << ',' << P << ">: " << glm::detail::tmat4x4<T,P>(v4_1, v4_2, v4_3, v4_4) << '\n';
+  
+  os << glm::io::column_major
+     << "mat2x2<" << typeid(T).name() << ',' << P << ">: " << glm::detail::tmat2x2<T,P>(v2_1, v2_2) << '\n'
+     << "mat2x3<" << typeid(T).name() << ',' << P << ">: " << glm::detail::tmat2x3<T,P>(v3_1, v3_2) << '\n'
+     << "mat2x4<" << typeid(T).name() << ',' << P << ">: " << glm::detail::tmat2x4<T,P>(v4_1, v4_2) << '\n'
+     << "mat3x2<" << typeid(T).name() << ',' << P << ">: " << glm::detail::tmat3x2<T,P>(v2_1, v2_2, v2_3) << '\n'
+     << "mat3x3<" << typeid(T).name() << ',' << P << ">: " << glm::detail::tmat3x3<T,P>(v3_1, v3_2, v3_3) << '\n'
+     << "mat3x4<" << typeid(T).name() << ',' << P << ">: " << glm::detail::tmat3x4<T,P>(v4_1, v4_2, v4_3) << '\n'
+     << "mat4x2<" << typeid(T).name() << ',' << P << ">: " << glm::detail::tmat4x2<T,P>(v2_1, v2_2, v2_3, v2_4) << '\n'
+     << "mat4x3<" << typeid(T).name() << ',' << P << ">: " << glm::detail::tmat4x3<T,P>(v3_1, v3_2, v3_3, v3_4) << '\n'
+     << "mat4x4<" << typeid(T).name() << ',' << P << ">: " << glm::detail::tmat4x4<T,P>(v4_1, v4_2, v4_3, v4_4) << '\n';
+  
+  return 0;
+}
+
+int main()
+{
+	int Error(0);
+  
+  Error += test_io_vec<float,glm::highp>  (std::cout);
+  Error += test_io_vec<float,glm::highp>  (std::wcout);
+  Error += test_io_vec<int,  glm::mediump>(std::cout);
+  Error += test_io_vec<int,  glm::mediump>(std::wcout);
+  Error += test_io_vec<uint, glm::lowp>   (std::cout);
+  Error += test_io_vec<uint, glm::lowp>   (std::wcout);
+
+  Error += test_io_mat<float,glm::highp>  (std::cout);
+  Error += test_io_mat<float,glm::lowp>   (std::wcout);
+  
+	return Error;
+}

test/gtx/gtx_simd_vec4.cpp

@@ -34,7 +34,7 @@ int main()
 
 	glm::simdVec4 GNI(add0);
 
-	printf("%f\n", GNI.Data.m128_f32);
+	printf("%f\n", GNI.Data /* .m128_f32 */);
 
 	return 0;
 }