Added test files for all GTX extensions

glm/core/type_vec2.hpp

@@ -57,11 +57,12 @@ namespace detail
 		typedef tvec2<T, P> type;
 		typedef tvec2<bool, P> bool_type;
 		typedef T value_type;
+		typedef int size_type;
 
 		//////////////////////////////////////
 		// Helper
 
-		GLM_FUNC_DECL GLM_CONSTEXPR int length() const;
+		GLM_FUNC_DECL GLM_CONSTEXPR size_type length() const;
 
 		//////////////////////////////////////
 		// Data

glm/core/type_vec2.inl

@@ -30,7 +30,7 @@ namespace glm{
 namespace detail
 {
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR int tvec2<T, P>::length() const
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR typename tvec2<T, P>::size_type tvec2<T, P>::length() const
 	{
 		return 2;
 	}

glm/core/type_vec3.hpp

@@ -57,11 +57,12 @@ namespace detail
 		typedef tvec3<T, P> type;
 		typedef tvec3<bool, P> bool_type;
 		typedef T value_type;
+		typedef int size_type;
 
 		//////////////////////////////////////
 		// Helper
 
-		GLM_FUNC_DECL GLM_CONSTEXPR int length() const;
+		GLM_FUNC_DECL GLM_CONSTEXPR size_type length() const;
 
 		//////////////////////////////////////
 		// Data

glm/core/type_vec3.inl

@@ -30,7 +30,7 @@ namespace glm{
 namespace detail
 {
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR int tvec3<T, P>::length() const
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR typename tvec3<T, P>::size_type tvec3<T, P>::length() const
 	{
 		return 3;
 	}

glm/core/type_vec4.hpp

@@ -58,11 +58,12 @@ namespace detail
 		typedef tvec4<T, P> type;
 		typedef tvec4<bool, P> bool_type;
 		typedef T value_type;
+		typedef int size_type;
 
 		//////////////////////////////////////
 		// Helper
 
-		GLM_FUNC_DECL GLM_CONSTEXPR int length() const;
+		GLM_FUNC_DECL GLM_CONSTEXPR size_type length() const;
 
 		//////////////////////////////////////
 		// Data

glm/core/type_vec4.inl

@@ -30,7 +30,7 @@ namespace glm{
 namespace detail
 {
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR int tvec4<T, P>::length() const
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR typename tvec4<T, P>::size_type tvec4<T, P>::length() const
 	{
 		return 4;
 	}

glm/gtc/ulp.inl

@@ -284,7 +284,7 @@ namespace glm
 		if(x < y)
 		{
 			T temp = x;
-			while(temp != y && ulp < std::numeric_limits<std::size_t>::max())
+			while(temp != y)// && ulp < std::numeric_limits<std::size_t>::max())
 			{
 				++ulp;
 				temp = next_float(temp);
@@ -293,7 +293,7 @@ namespace glm
 		else if(y < x)
 		{
 			T temp = y;
-			while(temp != x && ulp < std::numeric_limits<std::size_t>::max())
+			while(temp != x)// && ulp < std::numeric_limits<std::size_t>::max())
 			{
 				++ulp;
 				temp = next_float(temp);

glm/gtx/color_cast.hpp

@@ -1,143 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// 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_color_cast
-/// @file glm/gtx/color_cast.hpp
-/// @date 2007-06-21 / 2011-06-07
-/// @author Christophe Riccio
-///
-/// @see core (dependence)
-/// @see gtx_number_precision (dependence)
-///
-/// @defgroup gtx_color_cast GLM_GTX_color_cast
-/// @ingroup gtx
-///
-/// @brief Conversion between two color types.
-/// 
-/// <glm/gtx/color_cast.hpp> need to be included to use these functionalities.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef GLM_GTX_color_cast
-#define GLM_GTX_color_cast GLM_VERSION
-
-// Dependency:
-#include "../glm.hpp"
-#include "../gtx/number_precision.hpp"
-
-#if(defined(GLM_MESSAGES) && !defined(glm_ext))
-#	pragma message("GLM: GLM_GTX_color_cast extension included")
-#endif
-
-namespace glm
-{
-	/// @addtogroup gtx_color_cast
-	/// @{
-
-	//! Conversion of a floating value into a 8bit unsigned int value. 
-	/// @see gtx_color_cast
-	template <typename valType>
-	GLM_DEPRECATED uint8 u8channel_cast(valType a);
-
-	template <typename T>
-	GLM_DEPRECATED uint32 u32_rgbx_cast(const detail::tvec3<T, P>& c);		//!< \brief Conversion of a 3 components color into an 32bit unsigned int value. (From GLM_GTX_color_cast extension)
-	template <typename T>
-	GLM_DEPRECATED uint32 u32_xrgb_cast(const detail::tvec3<T, P>& c);		//!< \brief Conversion of a 3 components color into an 32bit unsigned int value. (From GLM_GTX_color_cast extension)
-	template <typename T>
-	GLM_DEPRECATED uint32 u32_bgrx_cast(const detail::tvec3<T, P>& c);		//!< \brief Conversion of a 3 components color into an 32bit unsigned int value. (From GLM_GTX_color_cast extension)
-	template <typename T>
-	GLM_DEPRECATED uint32 u32_xbgr_cast(const detail::tvec3<T, P>& c);		//!< \brief Conversion of a 3 components color into an 32bit unsigned int value. (From GLM_GTX_color_cast extension)
-
-	template <typename T>
-	GLM_DEPRECATED uint32 u32_rgba_cast(const detail::tvec4<T, P>& c);		//!< \brief Conversion of a 4 components color into an 32bit unsigned int value. (From GLM_GTX_color_cast extension)
-	template <typename T>
-	GLM_DEPRECATED uint32 u32_argb_cast(const detail::tvec4<T, P>& c);		//!< \brief Conversion of a 4 components color into an 32bit unsigned int value. (From GLM_GTX_color_cast extension)
-	template <typename T>
-	GLM_DEPRECATED uint32 u32_bgra_cast(const detail::tvec4<T, P>& c);		//!< \brief Conversion of a 4 components color into an 32bit unsigned int value. (From GLM_GTX_color_cast extension)
-	template <typename T>
-	GLM_DEPRECATED uint32 u32_abgr_cast(const detail::tvec4<T, P>& c);		//!< \brief Conversion of a 4 components color into an 32bit unsigned int value. (From GLM_GTX_color_cast extension)
-
-	template <typename T>
-	GLM_DEPRECATED uint64 u64_rgbx_cast(const detail::tvec3<T, P>& c);		//!< \brief Conversion of a 3 components color into an 64bit unsigned int value. (From GLM_GTX_color_cast extension)
-	template <typename T>
-	GLM_DEPRECATED uint64 u64_xrgb_cast(const detail::tvec3<T, P>& c);		//!< \brief Conversion of a 3 components color into an 64bit unsigned int value. (From GLM_GTX_color_cast extension)
-	template <typename T>
-	GLM_DEPRECATED uint64 u64_bgrx_cast(const detail::tvec3<T, P>& c);		//!< \brief Conversion of a 3 components color into an 64bit unsigned int value. (From GLM_GTX_color_cast extension)
-	template <typename T>
-	GLM_DEPRECATED uint64 u64_xbgr_cast(const detail::tvec3<T, P>& c);		//!< \brief Conversion of a 3 components color into an 64bit unsigned int value. (From GLM_GTX_color_cast extension)
-
-	template <typename T>
-	GLM_DEPRECATED uint64 u64_rgba_cast(const detail::tvec4<T, P>& c);		//!< \brief Conversion of a 4 components color into an 64bit unsigned int value. (From GLM_GTX_color_cast extension)
-	template <typename T>
-	GLM_DEPRECATED uint64 u64_argb_cast(const detail::tvec4<T, P>& c);		//!< \brief Conversion of a 4 components color into an 64bit unsigned int value. (From GLM_GTX_color_cast extension)
-	template <typename T>
-	GLM_DEPRECATED uint64 u64_bgra_cast(const detail::tvec4<T, P>& c);		//!< \brief Conversion of a 4 components color into an 64bit unsigned int value. (From GLM_GTX_color_cast extension)
-	template <typename T>
-	GLM_DEPRECATED uint64 u64_abgr_cast(const detail::tvec4<T, P>& c);		//!< \brief Conversion of a 4 components color into an 64bit unsigned int value. (From GLM_GTX_color_cast extension)
-
-	template <typename T>
-	GLM_DEPRECATED f32 f32_channel_cast(T a);		//!< \brief Conversion of a u8 or u16 value to a single channel floating value. (From GLM_GTX_color_cast extension)
-
-	template <typename T>
-	GLM_DEPRECATED f32vec3 f32_rgbx_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
-	template <typename T>
-	GLM_DEPRECATED f32vec3 f32_xrgb_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
-	template <typename T>
-	GLM_DEPRECATED f32vec3 f32_bgrx_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
-	template <typename T>
-	GLM_DEPRECATED f32vec3 f32_xbgr_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
-
-	template <typename T>
-	GLM_DEPRECATED f32vec4 f32_rgba_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 4 components floating color. (From GLM_GTX_color_cast extension)
-	template <typename T>
-	GLM_DEPRECATED f32vec4 f32_argb_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 4 components floating color. (From GLM_GTX_color_cast extension)
-	template <typename T>
-	GLM_DEPRECATED f32vec4 f32_bgra_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 4 components floating color. (From GLM_GTX_color_cast extension)
-	template <typename T>
-	GLM_DEPRECATED f32vec4 f32_abgr_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 4 components floating color. (From GLM_GTX_color_cast extension)
-
-	template <typename T>
-	GLM_DEPRECATED f64 f64_channel_cast(T a);		//!< \brief Conversion of a u8 or u16 value to a single channel floating value. (From GLM_GTX_color_cast extension)
-
-	template <typename T>
-	GLM_DEPRECATED f64vec3 f64_rgbx_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
-	template <typename T>
-	GLM_DEPRECATED f64vec3 f64_xrgb_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
-	template <typename T>
-	GLM_DEPRECATED f64vec3 f64_bgrx_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
-	template <typename T>
-	GLM_DEPRECATED f64vec3 f64_xbgr_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
-
-	template <typename T>
-	GLM_DEPRECATED f64vec4 f64_rgba_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 4 components floating color. (From GLM_GTX_color_cast extension)
-	template <typename T>
-	GLM_DEPRECATED f64vec4 f64_argb_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 4 components floating color. (From GLM_GTX_color_cast extension)
-	template <typename T>
-	GLM_DEPRECATED f64vec4 f64_bgra_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 4 components floating color. (From GLM_GTX_color_cast extension)
-	template <typename T>
-	GLM_DEPRECATED f64vec4 f64_abgr_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 4 components floating color. (From GLM_GTX_color_cast extension)
-
-	/// @}
-}//namespace glm
-
-#include "color_cast.inl"
-
-#endif//GLM_GTX_color_cast

glm/gtx/color_cast.inl

@@ -1,733 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Created : 2007-06-21
-// Updated : 2007-08-03
-// Licence : This source is under MIT License
-// File    : glm/gtx/color_cast.inl
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-namespace glm
-{
-	template <typename T> 
-	GLM_FUNC_QUALIFIER uint8 u8channel_cast(T a)
-	{
-		return static_cast<uint8>(a * T(255));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER uint16 u16channel_cast(T a)
-	{
-		return static_cast<uint16>(a * T(65535));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER uint32 u32_rgbx_cast(const detail::tvec3<T, P>& c)
-	{
-		uint32 result = 0;
-		result += static_cast<uint32>(c.x * detail::tvec3<T, P>::value_type(255)) <<  0;
-		result += static_cast<uint32>(c.y * detail::tvec3<T, P>::value_type(255)) <<  8;
-		result += static_cast<uint32>(c.z * detail::tvec3<T, P>::value_type(255)) << 16;
-		return result;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER uint32 u32_xrgb_cast(const detail::tvec3<T, P>& c)
-	{
-		uint32 result = 0;
-		result += static_cast<uint32>(c.x * detail::tvec3<T, P>::value_type(255)) <<  8;
-		result += static_cast<uint32>(c.y * detail::tvec3<T, P>::value_type(255)) << 16;
-		result += static_cast<uint32>(c.z * detail::tvec3<T, P>::value_type(255)) << 24;
-		return result;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER uint32 u32_bgrx_cast(const detail::tvec3<T, P>& c)
-	{
-		uint32 result = 0;
-		result += static_cast<uint32>(c.x * detail::tvec3<T, P>::value_type(255)) << 16;
-		result += static_cast<uint32>(c.y * detail::tvec3<T, P>::value_type(255)) <<  8;
-		result += static_cast<uint32>(c.z * detail::tvec3<T, P>::value_type(255)) <<  0;
-		return result;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER uint32 u32_xbgr_cast(const detail::tvec3<T, P>& c)
-	{
-		uint32 result = 0;
-		result += static_cast<uint32>(c.x * detail::tvec3<T, P>::value_type(255)) << 24;
-		result += static_cast<uint32>(c.y * detail::tvec3<T, P>::value_type(255)) << 16;
-		result += static_cast<uint32>(c.z * detail::tvec3<T, P>::value_type(255)) <<  8;
-		result += static_cast<uint32>(c.w * detail::tvec3<T, P>::value_type(255)) <<  0;
-		return result;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER uint32 u32_rgba_cast(const detail::tvec4<T, P>& c)
-	{
-		uint32 result = 0;
-		result += static_cast<uint32>(c.x * detail::tvec4<T, P>::value_type(255)) <<  0;
-		result += static_cast<uint32>(c.y * detail::tvec4<T, P>::value_type(255)) <<  8;
-		result += static_cast<uint32>(c.z * detail::tvec4<T, P>::value_type(255)) << 16;
-		result += static_cast<uint32>(c.w * detail::tvec4<T, P>::value_type(255)) << 24;
-		return result;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER uint32 u32_argb_cast(const detail::tvec4<T, P>& c)
-	{
-		uint32 result = 0;
-		result += static_cast<uint32>(c.x * detail::tvec4<T, P>::value_type(255)) <<  8;
-		result += static_cast<uint32>(c.y * detail::tvec4<T, P>::value_type(255)) << 16;
-		result += static_cast<uint32>(c.z * detail::tvec4<T, P>::value_type(255)) << 24;
-		result += static_cast<uint32>(c.w * detail::tvec4<T, P>::value_type(255)) <<  0;
-		return result;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER uint32 u32_bgra_cast(const detail::tvec4<T, P>& c)
-	{
-		uint32 result = 0;
-		result += static_cast<uint32>(c.x * detail::tvec4<T, P>::value_type(255)) << 16;
-		result += static_cast<uint32>(c.y * detail::tvec4<T, P>::value_type(255)) <<  8;
-		result += static_cast<uint32>(c.z * detail::tvec4<T, P>::value_type(255)) <<  0;
-		result += static_cast<uint32>(c.w * detail::tvec4<T, P>::value_type(255)) << 24;
-		return result;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER uint32 u32_abgr_cast(const detail::tvec4<T, P>& c)
-	{
-		uint32 result = 0;
-		result += static_cast<uint32>(c.x * detail::tvec4<T, P>::value_type(255)) << 24;
-		result += static_cast<uint32>(c.y * detail::tvec4<T, P>::value_type(255)) << 16;
-		result += static_cast<uint32>(c.z * detail::tvec4<T, P>::value_type(255)) <<  8;
-		result += static_cast<uint32>(c.w * detail::tvec4<T, P>::value_type(255)) <<  0;
-		return result;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER uint64 u64_rgbx_cast(const detail::tvec3<T, P>& c)
-	{
-		uint64 result = 0;
-		result += static_cast<uint64>(c.x * detail::tvec3<T, P>::value_type(65535)) <<  0;
-		result += static_cast<uint64>(c.y * detail::tvec3<T, P>::value_type(65535)) << 16;
-		result += static_cast<uint64>(c.z * detail::tvec3<T, P>::value_type(65535)) << 32;
-		return result;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER uint64 u32_xrgb_cast(const detail::tvec3<T, P>& c)
-	{
-		uint64 result = 0;
-		result += static_cast<uint64>(c.x * detail::tvec3<T, P>::value_type(65535)) << 16;
-		result += static_cast<uint64>(c.y * detail::tvec3<T, P>::value_type(65535)) << 32;
-		result += static_cast<uint64>(c.z * detail::tvec3<T, P>::value_type(65535)) << 48;
-		return result;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER uint64 u32_bgrx_cast(const detail::tvec3<T, P>& c)
-	{
-		uint64 result = 0;
-		result += static_cast<uint64>(c.x * detail::tvec3<T, P>::value_type(65535)) << 32;
-		result += static_cast<uint64>(c.y * detail::tvec3<T, P>::value_type(65535)) << 16;
-		result += static_cast<uint64>(c.z * detail::tvec3<T, P>::value_type(65535)) <<  0;
-		return result;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER uint64 u32_xbgr_cast(const detail::tvec3<T, P>& c)
-	{
-		uint64 result = 0;
-		result += static_cast<uint64>(c.x * detail::tvec3<T, P>::value_type(65535)) << 48;
-		result += static_cast<uint64>(c.y * detail::tvec3<T, P>::value_type(65535)) << 32;
-		result += static_cast<uint64>(c.z * detail::tvec3<T, P>::value_type(65535)) << 16;
-		result += static_cast<uint64>(c.w * detail::tvec3<T, P>::value_type(65535)) <<  0;
-		return result;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER uint64 u64_rgba_cast(const detail::tvec4<T, P>& c)
-	{
-		uint64 result = 0;
-		result += static_cast<uint64>(c.x * detail::tvec4<T, P>::value_type(65535)) <<  0;
-		result += static_cast<uint64>(c.y * detail::tvec4<T, P>::value_type(65535)) << 16;
-		result += static_cast<uint64>(c.z * detail::tvec4<T, P>::value_type(65535)) << 32;
-		result += static_cast<uint64>(c.w * detail::tvec4<T, P>::value_type(65535)) << 48;
-		return result;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER uint64 u64_argb_cast(const detail::tvec4<T, P>& c)
-	{
-		uint64 result = 0;
-		result += static_cast<uint64>(c.x * detail::tvec4<T, P>::value_type(65535)) << 16;
-		result += static_cast<uint64>(c.y * detail::tvec4<T, P>::value_type(65535)) << 32;
-		result += static_cast<uint64>(c.z * detail::tvec4<T, P>::value_type(65535)) << 48;
-		result += static_cast<uint64>(c.w * detail::tvec4<T, P>::value_type(65535)) <<  0;
-		return result;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER uint64 u64_bgra_cast(const detail::tvec4<T, P>& c)
-	{
-		uint64 result = 0;
-		result += static_cast<uint64>(c.x * detail::tvec4<T, P>::value_type(65535)) << 32;
-		result += static_cast<uint64>(c.y * detail::tvec4<T, P>::value_type(65535)) << 16;
-		result += static_cast<uint64>(c.z * detail::tvec4<T, P>::value_type(65535)) <<  0;
-		result += static_cast<uint64>(c.w * detail::tvec4<T, P>::value_type(65535)) << 48;
-		return result;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER uint64 u64_abgr_cast(const detail::tvec4<T, P>& c)
-	{
-		uint64 result = 0;
-		result += static_cast<uint64>(c.x * detail::tvec4<T, P>::value_type(65535)) << 48;
-		result += static_cast<uint64>(c.y * detail::tvec4<T, P>::value_type(65535)) << 32;
-		result += static_cast<uint64>(c.z * detail::tvec4<T, P>::value_type(65535)) << 16;
-		result += static_cast<uint64>(c.w * detail::tvec4<T, P>::value_type(65535)) <<  0;
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER f16 f16_channel_cast<uint32>(uint32 color)
-	{
-		return f16(static_cast<float>(color >>  0) / static_cast<float>(255));
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER f16vec3 f16_rgbx_cast<uint32>(uint32 color)
-	{
-		f16vec3 result;
-		result.x = f16(static_cast<float>((color >>  0) & 0xFF) / static_cast<float>(255));
-		result.y = f16(static_cast<float>((color >>  8) & 0xFF) / static_cast<float>(255));
-		result.z = f16(static_cast<float>((color >> 16) & 0xFF) / static_cast<float>(255));
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER f16vec3 f16_xrgb_cast<uint32>(uint32 color)
-	{
-		f16vec3 result;
-		result.x = f16(static_cast<float>((color >>  8) & 0xFF) / static_cast<float>(255));
-		result.y = f16(static_cast<float>((color >> 16) & 0xFF) / static_cast<float>(255));
-		result.z = f16(static_cast<float>((color >> 24) & 0xFF) / static_cast<float>(255));
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER f16vec3 f16_bgrx_cast<uint32>(uint32 color)
-	{
-		f16vec3 result;
-		result.x = f16(static_cast<float>((color >> 16) & 0xFF) / static_cast<float>(255));
-		result.y = f16(static_cast<float>((color >>  8) & 0xFF) / static_cast<float>(255));
-		result.z = f16(static_cast<float>((color >>  0) & 0xFF) / static_cast<float>(255));
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER f16vec3 f16_xbgr_cast<uint32>(uint32 color)
-	{
-		f16vec3 result;
-		result.x = f16(static_cast<float>((color >> 24) & 0xFF) / static_cast<float>(255));
-		result.y = f16(static_cast<float>((color >> 16) & 0xFF) / static_cast<float>(255));
-		result.z = f16(static_cast<float>((color >>  8) & 0xFF) / static_cast<float>(255));
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER f16vec4 f16_rgba_cast<uint32>(uint32 color)
-	{
-		f16vec4 result;
-		result.x = f16(static_cast<float>((color >>  0) & 0xFF) / static_cast<float>(255));
-		result.y = f16(static_cast<float>((color >>  8) & 0xFF) / static_cast<float>(255));
-		result.z = f16(static_cast<float>((color >> 16) & 0xFF) / static_cast<float>(255));
-		result.w = f16(static_cast<float>((color >> 24) & 0xFF) / static_cast<float>(255));
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER f16vec4 f16_argb_cast<uint32>(uint32 color)
-	{
-		f16vec4 result;
-		result.x = f16(static_cast<float>((color >>  8) & 0xFF) / static_cast<float>(255));
-		result.y = f16(static_cast<float>((color >> 16) & 0xFF) / static_cast<float>(255));
-		result.z = f16(static_cast<float>((color >> 24) & 0xFF) / static_cast<float>(255));
-		result.w = f16(static_cast<float>((color >>  0) & 0xFF) / static_cast<float>(255));
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER f16vec4 f16_bgra_cast<uint32>(uint32 color)
-	{
-		f16vec4 result;
-		result.x = f16(static_cast<float>((color >> 16) & 0xFF) / static_cast<float>(255));
-		result.y = f16(static_cast<float>((color >>  8) & 0xFF) / static_cast<float>(255));
-		result.z = f16(static_cast<float>((color >>  0) & 0xFF) / static_cast<float>(255));
-		result.w = f16(static_cast<float>((color >> 24) & 0xFF) / static_cast<float>(255));
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER f16vec4 f16_abgr_cast<uint32>(uint32 color)
-	{
-		f16vec4 result;
-		result.x = f16(static_cast<float>((color >> 24) & 0xFF) / static_cast<float>(255));
-		result.y = f16(static_cast<float>((color >> 16) & 0xFF) / static_cast<float>(255));
-		result.z = f16(static_cast<float>((color >>  8) & 0xFF) / static_cast<float>(255));
-		result.w = f16(static_cast<float>((color >>  0) & 0xFF) / static_cast<float>(255));
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER float f32_channel_cast<uint8>(uint8 color)
-	{
-		return static_cast<float>(color >>  0) / static_cast<float>(255);
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER detail::tvec3<float> f32_rgbx_cast<uint32>(uint32 color)
-	{
-		detail::tvec3<float> result;
-		result.x = static_cast<float>((color >>  0) & 0xFF) / static_cast<float>(255);
-		result.y = static_cast<float>((color >>  8) & 0xFF) / static_cast<float>(255);
-		result.z = static_cast<float>((color >> 16) & 0xFF) / static_cast<float>(255);
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER detail::tvec3<float> f32_xrgb_cast<uint32>(uint32 color)
-	{
-		detail::tvec3<float> result;
-		result.x = static_cast<float>((color >>  8) & 0xFF) / static_cast<float>(255);
-		result.y = static_cast<float>((color >> 16) & 0xFF) / static_cast<float>(255);
-		result.z = static_cast<float>((color >> 24) & 0xFF) / static_cast<float>(255);
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER detail::tvec3<float> f32_bgrx_cast<uint32>(uint32 color)
-	{
-		detail::tvec3<float> result;
-		result.x = static_cast<float>((color >> 16) & 0xFF) / static_cast<float>(255);
-		result.y = static_cast<float>((color >>  8) & 0xFF) / static_cast<float>(255);
-		result.z = static_cast<float>((color >>  0) & 0xFF) / static_cast<float>(255);
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER detail::tvec3<float> f32_xbgr_cast<uint32>(uint32 color)
-	{
-		detail::tvec3<float> result;
-		result.x = static_cast<float>((color >> 24) & 0xFF) / static_cast<float>(255);
-		result.y = static_cast<float>((color >> 16) & 0xFF) / static_cast<float>(255);
-		result.z = static_cast<float>((color >>  8) & 0xFF) / static_cast<float>(255);
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER detail::tvec4<float> f32_rgba_cast<uint32>(uint32 color)
-	{
-		detail::tvec4<float> result;
-		result.x = static_cast<float>((color >>  0) & 0xFF) / static_cast<float>(255);
-		result.y = static_cast<float>((color >>  8) & 0xFF) / static_cast<float>(255);
-		result.z = static_cast<float>((color >> 16) & 0xFF) / static_cast<float>(255);
-		result.w = static_cast<float>((color >> 24) & 0xFF) / static_cast<float>(255);
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER detail::tvec4<float> f32_argb_cast<uint32>(uint32 color)
-	{
-		detail::tvec4<float> result;
-		result.x = static_cast<float>((color >>  8) & 0xFF) / static_cast<float>(255);
-		result.y = static_cast<float>((color >> 16) & 0xFF) / static_cast<float>(255);
-		result.z = static_cast<float>((color >> 24) & 0xFF) / static_cast<float>(255);
-		result.w = static_cast<float>((color >>  0) & 0xFF) / static_cast<float>(255);
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER detail::tvec4<float> f32_bgra_cast<uint32>(uint32 color)
-	{
-		detail::tvec4<float> result;
-		result.x = static_cast<float>((color >> 16) & 0xFF) / static_cast<float>(255);
-		result.y = static_cast<float>((color >>  8) & 0xFF) / static_cast<float>(255);
-		result.z = static_cast<float>((color >>  0) & 0xFF) / static_cast<float>(255);
-		result.w = static_cast<float>((color >> 24) & 0xFF) / static_cast<float>(255);
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER detail::tvec4<float> f32_abgr_cast<uint32>(uint32 color)
-	{
-		detail::tvec4<float> result;
-		result.x = static_cast<float>((color >> 24) & 0xFF) / static_cast<float>(255);
-		result.y = static_cast<float>((color >> 16) & 0xFF) / static_cast<float>(255);
-		result.z = static_cast<float>((color >>  8) & 0xFF) / static_cast<float>(255);
-		result.w = static_cast<float>((color >>  0) & 0xFF) / static_cast<float>(255);
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER double f64_channel_cast<uint8>(uint8 color)
-	{
-		return static_cast<double>(color >>  0) / static_cast<double>(255);
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER detail::tvec3<double> f64_rgbx_cast<uint32>(uint32 color)
-	{
-		detail::tvec3<double> result;
-		result.x = static_cast<double>((color >>  0) & 0xFF) / static_cast<double>(255);
-		result.y = static_cast<double>((color >>  8) & 0xFF) / static_cast<double>(255);
-		result.z = static_cast<double>((color >> 16) & 0xFF) / static_cast<double>(255);
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER detail::tvec3<double> f64_xrgb_cast<uint32>(uint32 color)
-	{
-		detail::tvec3<double> result;
-		result.x = static_cast<double>((color >>  8) & 0xFF) / static_cast<double>(255);
-		result.y = static_cast<double>((color >> 16) & 0xFF) / static_cast<double>(255);
-		result.z = static_cast<double>((color >> 24) & 0xFF) / static_cast<double>(255);
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER detail::tvec3<double> f64_bgrx_cast<uint32>(uint32 color)
-	{
-		detail::tvec3<double> result;
-		result.x = static_cast<double>((color >> 16) & 0xFF) / static_cast<double>(255);
-		result.y = static_cast<double>((color >>  8) & 0xFF) / static_cast<double>(255);
-		result.z = static_cast<double>((color >>  0) & 0xFF) / static_cast<double>(255);
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER detail::tvec3<double> f64_xbgr_cast<uint32>(uint32 color)
-	{
-		detail::tvec3<double> result;
-		result.x = static_cast<double>((color >> 24) & 0xFF) / static_cast<double>(255);
-		result.y = static_cast<double>((color >> 16) & 0xFF) / static_cast<double>(255);
-		result.z = static_cast<double>((color >>  8) & 0xFF) / static_cast<double>(255);
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER detail::tvec4<double> f64_rgba_cast<uint32>(uint32 color)
-	{
-		detail::tvec4<double> result;
-		result.x = static_cast<double>((color >>  0) & 0xFF) / static_cast<double>(255);
-		result.y = static_cast<double>((color >>  8) & 0xFF) / static_cast<double>(255);
-		result.z = static_cast<double>((color >> 16) & 0xFF) / static_cast<double>(255);
-		result.w = static_cast<double>((color >> 24) & 0xFF) / static_cast<double>(255);
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER detail::tvec4<double> f64_argb_cast<uint32>(uint32 color)
-	{
-		detail::tvec4<double> result;
-		result.x = static_cast<double>((color >>  8) & 0xFF) / static_cast<double>(255);
-		result.y = static_cast<double>((color >> 16) & 0xFF) / static_cast<double>(255);
-		result.z = static_cast<double>((color >> 24) & 0xFF) / static_cast<double>(255);
-		result.w = static_cast<double>((color >>  0) & 0xFF) / static_cast<double>(255);
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER detail::tvec4<double> f64_bgra_cast<uint32>(uint32 color)
-	{
-		detail::tvec4<double> result;
-		result.x = static_cast<double>((color >> 16) & 0xFF) / static_cast<double>(255);
-		result.y = static_cast<double>((color >>  8) & 0xFF) / static_cast<double>(255);
-		result.z = static_cast<double>((color >>  0) & 0xFF) / static_cast<double>(255);
-		result.w = static_cast<double>((color >> 24) & 0xFF) / static_cast<double>(255);
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER detail::tvec4<double> f64_abgr_cast<uint32>(uint32 color)
-	{
-		detail::tvec4<double> result;
-		result.x = static_cast<double>((color >> 24) & 0xFF) / static_cast<double>(255);
-		result.y = static_cast<double>((color >> 16) & 0xFF) / static_cast<double>(255);
-		result.z = static_cast<double>((color >>  8) & 0xFF) / static_cast<double>(255);
-		result.w = static_cast<double>((color >>  0) & 0xFF) / static_cast<double>(255);
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER detail::half f16_channel_cast<uint16>(uint16 color)
-	{
-		return detail::half(static_cast<float>(color >>  0) / static_cast<float>(65535));
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER detail::tvec3<detail::half> f16_rgbx_cast<uint64>(uint64 color)
-	{
-		detail::tvec3<detail::half> result;
-		result.x = detail::half(static_cast<float>((color >>  0) & 0xFFFF) / static_cast<float>(65535));
-		result.y = detail::half(static_cast<float>((color >> 16) & 0xFFFF) / static_cast<float>(65535));
-		result.z = detail::half(static_cast<float>((color >> 32) & 0xFFFF) / static_cast<float>(65535));
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER detail::tvec3<detail::half> f16_xrgb_cast<uint64>(uint64 color)
-	{
-		detail::tvec3<detail::half> result;
-		result.x = detail::half(static_cast<float>((color >> 16) & 0xFFFF) / static_cast<float>(65535));
-		result.y = detail::half(static_cast<float>((color >> 32) & 0xFFFF) / static_cast<float>(65535));
-		result.z = detail::half(static_cast<float>((color >> 48) & 0xFFFF) / static_cast<float>(65535));
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER detail::tvec3<detail::half> f16_bgrx_cast<uint64>(uint64 color)
-	{
-		detail::tvec3<detail::half> result;
-		result.x = detail::half(static_cast<float>((color >> 32) & 0xFFFF) / static_cast<float>(65535));
-		result.y = detail::half(static_cast<float>((color >> 16) & 0xFFFF) / static_cast<float>(65535));
-		result.z = detail::half(static_cast<float>((color >>  0) & 0xFFFF) / static_cast<float>(65535));
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER detail::tvec3<detail::half> f16_xbgr_cast<uint64>(uint64 color)
-	{
-		detail::tvec3<detail::half> result;
-		result.x = detail::half(static_cast<float>((color >> 48) & 0xFFFF) / static_cast<float>(65535));
-		result.y = detail::half(static_cast<float>((color >> 32) & 0xFFFF) / static_cast<float>(65535));
-		result.z = detail::half(static_cast<float>((color >> 16) & 0xFFFF) / static_cast<float>(65535));
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER detail::tvec4<detail::half> f16_rgba_cast<uint64>(uint64 color)
-	{
-		detail::tvec4<detail::half> result;
-		result.x = detail::half(static_cast<float>((color >>  0) & 0xFFFF) / static_cast<float>(65535));
-		result.y = detail::half(static_cast<float>((color >> 16) & 0xFFFF) / static_cast<float>(65535));
-		result.z = detail::half(static_cast<float>((color >> 32) & 0xFFFF) / static_cast<float>(65535));
-		result.w = detail::half(static_cast<float>((color >> 48) & 0xFFFF) / static_cast<float>(65535));
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER detail::tvec4<detail::half> f16_argb_cast<uint64>(uint64 color)
-	{
-		detail::tvec4<detail::half> result;
-		result.x = detail::half(static_cast<float>((color >> 16) & 0xFFFF) / static_cast<float>(65535));
-		result.y = detail::half(static_cast<float>((color >> 32) & 0xFFFF) / static_cast<float>(65535));
-		result.z = detail::half(static_cast<float>((color >> 48) & 0xFFFF) / static_cast<float>(65535));
-		result.w = detail::half(static_cast<float>((color >>  0) & 0xFFFF) / static_cast<float>(65535));
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER detail::tvec4<detail::half> f16_bgra_cast<uint64>(uint64 color)
-	{
-		detail::tvec4<detail::half> result;
-		result.x = detail::half(static_cast<float>((color >> 32) & 0xFFFF) / static_cast<float>(65535));
-		result.y = detail::half(static_cast<float>((color >> 16) & 0xFFFF) / static_cast<float>(65535));
-		result.z = detail::half(static_cast<float>((color >>  0) & 0xFFFF) / static_cast<float>(65535));
-		result.w = detail::half(static_cast<float>((color >> 48) & 0xFFFF) / static_cast<float>(65535));
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER detail::tvec4<detail::half> f16_abgr_cast<uint64>(uint64 color)
-	{
-		detail::tvec4<detail::half> result;
-		result.x = detail::half(static_cast<float>((color >> 48) & 0xFFFF) / static_cast<float>(65535));
-		result.y = detail::half(static_cast<float>((color >> 32) & 0xFFFF) / static_cast<float>(65535));
-		result.z = detail::half(static_cast<float>((color >> 16) & 0xFFFF) / static_cast<float>(65535));
-		result.w = detail::half(static_cast<float>((color >>  0) & 0xFFFF) / static_cast<float>(65535));
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER float f32_channel_cast<uint16>(uint16 color)
-	{
-		return static_cast<float>(color >>  0) / static_cast<float>(65535);
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER detail::tvec3<float> f32_rgbx_cast<uint64>(uint64 color)
-	{
-		detail::tvec3<float> result;
-		result.x = static_cast<float>((color >>  0) & 0xFFFF) / static_cast<float>(65535);
-		result.y = static_cast<float>((color >> 16) & 0xFFFF) / static_cast<float>(65535);
-		result.z = static_cast<float>((color >> 32) & 0xFFFF) / static_cast<float>(65535);
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER detail::tvec3<float> f32_xrgb_cast<uint64>(uint64 color)
-	{
-		detail::tvec3<float> result;
-		result.x = static_cast<float>((color >> 16) & 0xFFFF) / static_cast<float>(65535);
-		result.y = static_cast<float>((color >> 32) & 0xFFFF) / static_cast<float>(65535);
-		result.z = static_cast<float>((color >> 48) & 0xFFFF) / static_cast<float>(65535);
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER detail::tvec3<float> f32_bgrx_cast<uint64>(uint64 color)
-	{
-		detail::tvec3<float> result;
-		result.x = static_cast<float>((color >> 32) & 0xFFFF) / static_cast<float>(65535);
-		result.y = static_cast<float>((color >> 16) & 0xFFFF) / static_cast<float>(65535);
-		result.z = static_cast<float>((color >>  0) & 0xFFFF) / static_cast<float>(65535);
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER detail::tvec3<float> f32_xbgr_cast<uint64>(uint64 color)
-	{
-		detail::tvec3<float> result;
-		result.x = static_cast<float>((color >> 48) & 0xFFFF) / static_cast<float>(65535);
-		result.y = static_cast<float>((color >> 32) & 0xFFFF) / static_cast<float>(65535);
-		result.z = static_cast<float>((color >> 16) & 0xFFFF) / static_cast<float>(65535);
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER detail::tvec4<float> f32_rgba_cast<uint64>(uint64 color)
-	{
-		detail::tvec4<float> result;
-		result.x = static_cast<float>((color >>  0) & 0xFFFF) / static_cast<float>(65535);
-		result.y = static_cast<float>((color >> 16) & 0xFFFF) / static_cast<float>(65535);
-		result.z = static_cast<float>((color >> 32) & 0xFFFF) / static_cast<float>(65535);
-		result.w = static_cast<float>((color >> 48) & 0xFFFF) / static_cast<float>(65535);
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER detail::tvec4<float> f32_argb_cast<uint64>(uint64 color)
-	{
-		detail::tvec4<float> result;
-		result.x = static_cast<float>((color >> 16) & 0xFFFF) / static_cast<float>(65535);
-		result.y = static_cast<float>((color >> 32) & 0xFFFF) / static_cast<float>(65535);
-		result.z = static_cast<float>((color >> 48) & 0xFFFF) / static_cast<float>(65535);
-		result.w = static_cast<float>((color >>  0) & 0xFFFF) / static_cast<float>(65535);
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER detail::tvec4<float> f32_bgra_cast<uint64>(uint64 color)
-	{
-		detail::tvec4<float> result;
-		result.x = static_cast<float>((color >> 32) & 0xFFFF) / static_cast<float>(65535);
-		result.y = static_cast<float>((color >> 16) & 0xFFFF) / static_cast<float>(65535);
-		result.z = static_cast<float>((color >>  0) & 0xFFFF) / static_cast<float>(65535);
-		result.w = static_cast<float>((color >> 48) & 0xFFFF) / static_cast<float>(65535);
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER detail::tvec4<float> f32_abgr_cast<uint64>(uint64 color)
-	{
-		detail::tvec4<float> result;
-		result.x = static_cast<float>((color >> 48) & 0xFFFF) / static_cast<float>(65535);
-		result.y = static_cast<float>((color >> 32) & 0xFFFF) / static_cast<float>(65535);
-		result.z = static_cast<float>((color >> 16) & 0xFFFF) / static_cast<float>(65535);
-		result.w = static_cast<float>((color >>  0) & 0xFFFF) / static_cast<float>(65535);
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER double f64_channel_cast<uint16>(uint16 color)
-	{
-		return static_cast<double>(color >>  0) / static_cast<double>(65535);
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER detail::tvec3<double> f64_rgbx_cast<uint64>(uint64 color)
-	{
-		detail::tvec3<double> result;
-		result.x = static_cast<double>((color >>  0) & 0xFFFF) / static_cast<double>(65535);
-		result.y = static_cast<double>((color >> 16) & 0xFFFF) / static_cast<double>(65535);
-		result.z = static_cast<double>((color >> 32) & 0xFFFF) / static_cast<double>(65535);
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER detail::tvec3<double> f64_xrgb_cast<uint64>(uint64 color)
-	{
-		detail::tvec3<double> result;
-		result.x = static_cast<double>((color >> 16) & 0xFFFF) / static_cast<double>(65535);
-		result.y = static_cast<double>((color >> 32) & 0xFFFF) / static_cast<double>(65535);
-		result.z = static_cast<double>((color >> 48) & 0xFFFF) / static_cast<double>(65535);
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER detail::tvec3<double> f64_bgrx_cast<uint64>(uint64 color)
-	{
-		detail::tvec3<double> result;
-		result.x = static_cast<double>((color >> 32) & 0xFFFF) / static_cast<double>(65535);
-		result.y = static_cast<double>((color >> 16) & 0xFFFF) / static_cast<double>(65535);
-		result.z = static_cast<double>((color >>  0) & 0xFFFF) / static_cast<double>(65535);
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER detail::tvec3<double> f64_xbgr_cast<uint64>(uint64 color)
-	{
-		detail::tvec3<double> result;
-		result.x = static_cast<double>((color >> 48) & 0xFFFF) / static_cast<double>(65535);
-		result.y = static_cast<double>((color >> 32) & 0xFFFF) / static_cast<double>(65535);
-		result.z = static_cast<double>((color >> 16) & 0xFFFF) / static_cast<double>(65535);
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER detail::tvec4<double> f64_rgba_cast<uint64>(uint64 color)
-	{
-		detail::tvec4<double> result;
-		result.x = static_cast<double>((color >>  0) & 0xFFFF) / static_cast<double>(65535);
-		result.y = static_cast<double>((color >> 16) & 0xFFFF) / static_cast<double>(65535);
-		result.z = static_cast<double>((color >> 32) & 0xFFFF) / static_cast<double>(65535);
-		result.w = static_cast<double>((color >> 48) & 0xFFFF) / static_cast<double>(65535);
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER detail::tvec4<double> f64_argb_cast<uint64>(uint64 color)
-	{
-		detail::tvec4<double> result;
-		result.x = static_cast<double>((color >> 16) & 0xFFFF) / static_cast<double>(65535);
-		result.y = static_cast<double>((color >> 32) & 0xFFFF) / static_cast<double>(65535);
-		result.z = static_cast<double>((color >> 48) & 0xFFFF) / static_cast<double>(65535);
-		result.w = static_cast<double>((color >>  0) & 0xFFFF) / static_cast<double>(65535);
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER detail::tvec4<double> f64_bgra_cast<uint64>(uint64 color)
-	{
-		detail::tvec4<double> result;
-		result.x = static_cast<double>((color >> 32) & 0xFFFF) / static_cast<double>(65535);
-		result.y = static_cast<double>((color >> 16) & 0xFFFF) / static_cast<double>(65535);
-		result.z = static_cast<double>((color >>  0) & 0xFFFF) / static_cast<double>(65535);
-		result.w = static_cast<double>((color >> 48) & 0xFFFF) / static_cast<double>(65535);
-		return result;
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER detail::tvec4<double> f64_abgr_cast<uint64>(uint64 color)
-	{
-		detail::tvec4<double> result;
-		result.x = static_cast<double>((color >> 48) & 0xFFFF) / static_cast<double>(65535);
-		result.y = static_cast<double>((color >> 32) & 0xFFFF) / static_cast<double>(65535);
-		result.z = static_cast<double>((color >> 16) & 0xFFFF) / static_cast<double>(65535);
-		result.w = static_cast<double>((color >>  0) & 0xFFFF) / static_cast<double>(65535);
-		return result;
-	}
-}//namespace glm

glm/gtx/color_space.hpp

@@ -52,41 +52,41 @@ namespace glm
 
 	/// Converts a color from HSV color space to its color in RGB color space.
 	/// @see gtx_color_space
-	template <typename valType> 
-	detail::tvec3<valType> rgbColor(
-		detail::tvec3<valType> const & hsvValue);
+	template <typename T, precision P>
+	detail::tvec3<T, P> rgbColor(
+		detail::tvec3<T, P> const & hsvValue);
 
 	/// Converts a color from RGB color space to its color in HSV color space.
 	/// @see gtx_color_space
-	template <typename valType> 
-	detail::tvec3<valType> hsvColor(
-		detail::tvec3<valType> const & rgbValue);
+	template <typename T, precision P>
+	detail::tvec3<T, P> hsvColor(
+		detail::tvec3<T, P> const & rgbValue);
 		
 	/// Build a saturation matrix.
 	/// @see gtx_color_space
-	template <typename valType> 
-	detail::tmat4x4<valType> saturation(
-		valType const s);
+	template <typename T, precision P>
+	detail::tmat4x4<T, P> saturation(
+		T const s);
 
 	/// Modify the saturation of a color.
 	/// @see gtx_color_space
-	template <typename valType> 
-	detail::tvec3<valType> saturation(
-		valType const s, 
-		detail::tvec3<valType> const & color);
+	template <typename T, precision P>
+	detail::tvec3<T, P> saturation(
+		T const s,
+		detail::tvec3<T, P> const & color);
 		
 	/// Modify the saturation of a color.
 	/// @see gtx_color_space
-	template <typename valType> 
-	detail::tvec4<valType> saturation(
-		valType const s, 
-		detail::tvec4<valType> const & color);
+	template <typename T, precision P>
+	detail::tvec4<T, P> saturation(
+		T const s,
+		detail::tvec4<T, P> const & color);
 		
 	/// Compute color luminosity associating ratios (0.33, 0.59, 0.11) to RGB canals.
 	/// @see gtx_color_space
-	template <typename valType> 
-	valType luminosity(
-		detail::tvec3<valType> const & color);
+	template <typename T, precision P>
+	T luminosity(
+		detail::tvec3<T, P> const & color);
 
 	/// @}
 }//namespace glm

glm/gtx/color_space.inl

@@ -9,7 +9,7 @@
 
 namespace glm
 {
-	template <typename T> 
+	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER detail::tvec3<T, P> rgbColor(const detail::tvec3<T, P>& hsvColor)
 	{
 		detail::tvec3<T, P> hsv = hsvColor;
@@ -66,7 +66,7 @@ namespace glm
 		return rgbColor;
 	}
 
-	template <typename T> 
+	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER detail::tvec3<T, P> hsvColor(const detail::tvec3<T, P>& rgbColor)
 	{
 		detail::tvec3<T, P> hsv = rgbColor;
@@ -75,7 +75,7 @@ namespace glm
 		float Delta = Max - Min;
 
 		hsv.z = Max;                               
-    	
+
 		if(Max != static_cast<T>(0))
 		{
 			hsv.y = Delta / hsv.z;    
@@ -90,7 +90,7 @@ namespace glm
 			else
 				// between magenta & cyan
 				h = static_cast<T>(240) + T(60) * (rgbColor.r - rgbColor.g) / Delta;
-            
+
 			if(h < T(0)) 
 				hsv.x = h + T(360);
 			else
@@ -106,7 +106,7 @@ namespace glm
 		return hsv;
 	}
 
-	template <typename T> 
+	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER detail::tmat4x4<T, P> saturation(const T s)
 	{
 		detail::tvec3<T, P> rgbw = detail::tvec3<T, P>(T(0.2126), T(0.7152), T(0.0722));
@@ -128,19 +128,19 @@ namespace glm
 		return result;
 	}
 
-	template <typename T> 
+	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER detail::tvec3<T, P> saturation(const T s, const detail::tvec3<T, P>& color)
 	{
 		return detail::tvec3<T, P>(saturation(s) * detail::tvec4<T, P>(color, T(0)));
 	}
 
-	template <typename T> 
+	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER detail::tvec4<T, P> saturation(const T s, const detail::tvec4<T, P>& color)
 	{
 		return saturation(s) * color;
 	}
 
-	template <typename T> 
+	template <typename T, precision P> 
 	GLM_FUNC_QUALIFIER T luminosity(const detail::tvec3<T, P>& color)
 	{
 		const detail::tvec3<T, P> tmp = detail::tvec3<T, P>(0.33, 0.59, 0.11);

glm/gtx/color_space_YCoCg.hpp

@@ -52,29 +52,29 @@ namespace glm
 
 	/// Convert a color from RGB color space to YCoCg color space.
 	/// @see gtx_color_space_YCoCg
-	template <typename valType> 
-	detail::tvec3<valType> rgb2YCoCg(
-		detail::tvec3<valType> const & rgbColor);
+	template <typename T, precision P>
+	detail::tvec3<T, P> rgb2YCoCg(
+		detail::tvec3<T, P> const & rgbColor);
 
 	/// Convert a color from YCoCg color space to RGB color space.
 	/// @see gtx_color_space_YCoCg
-	template <typename valType> 
-	detail::tvec3<valType> YCoCg2rgb(
-		detail::tvec3<valType> const & YCoCgColor);
+	template <typename T, precision P>
+	detail::tvec3<T, P> YCoCg2rgb(
+		detail::tvec3<T, P> const & YCoCgColor);
 
 	/// Convert a color from RGB color space to YCoCgR color space.
 	/// @see "YCoCg-R: A Color Space with RGB Reversibility and Low Dynamic Range"
 	/// @see gtx_color_space_YCoCg
-	template <typename valType> 
-	detail::tvec3<valType> rgb2YCoCgR(
-		detail::tvec3<valType> const & rgbColor);
+	template <typename T, precision P>
+	detail::tvec3<T, P> rgb2YCoCgR(
+		detail::tvec3<T, P> const & rgbColor);
 
 	/// Convert a color from YCoCgR color space to RGB color space.
 	/// @see "YCoCg-R: A Color Space with RGB Reversibility and Low Dynamic Range"
 	/// @see gtx_color_space_YCoCg
-	template <typename valType> 
-	detail::tvec3<valType> YCoCgR2rgb(
-		detail::tvec3<valType> const & YCoCgColor);
+	template <typename T, precision P>
+	detail::tvec3<T, P> YCoCgR2rgb(
+		detail::tvec3<T, P> const & YCoCgColor);
 
 	/// @}
 }//namespace glm

glm/gtx/color_space_YCoCg.inl

@@ -9,55 +9,55 @@
 
 namespace glm
 {
-	template <typename valType> 
-	GLM_FUNC_QUALIFIER detail::tvec3<valType> rgb2YCoCg
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER detail::tvec3<T, P> rgb2YCoCg
 	(
-		detail::tvec3<valType> const & rgbColor
+		detail::tvec3<T, P> const & rgbColor
 	)
 	{
-		detail::tvec3<valType> result;
-		result.x/*Y */ =   rgbColor.r / valType(4) + rgbColor.g / valType(2) + rgbColor.b / valType(4);
-		result.y/*Co*/ =   rgbColor.r / valType(2) + rgbColor.g * valType(0) - rgbColor.b / valType(2);
-		result.z/*Cg*/ = - rgbColor.r / valType(4) + rgbColor.g / valType(2) - rgbColor.b / valType(4);
+		detail::tvec3<T, P> result;
+		result.x/*Y */ =   rgbColor.r / T(4) + rgbColor.g / T(2) + rgbColor.b / T(4);
+		result.y/*Co*/ =   rgbColor.r / T(2) + rgbColor.g * T(0) - rgbColor.b / T(2);
+		result.z/*Cg*/ = - rgbColor.r / T(4) + rgbColor.g / T(2) - rgbColor.b / T(4);
 		return result;
 	}
 
-	template <typename valType> 
-	GLM_FUNC_QUALIFIER detail::tvec3<valType> rgb2YCoCgR
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER detail::tvec3<T, P> rgb2YCoCgR
 	(
-		detail::tvec3<valType> const & rgbColor
+		detail::tvec3<T, P> const & rgbColor
 	)
 	{
-		detail::tvec3<valType> result;
-		result.x/*Y */ = rgbColor.g / valType(2) + (rgbColor.r + rgbColor.b) / valType(4);
+		detail::tvec3<T, P> result;
+		result.x/*Y */ = rgbColor.g / T(2) + (rgbColor.r + rgbColor.b) / T(4);
 		result.y/*Co*/ = rgbColor.r - rgbColor.b;
-		result.z/*Cg*/ = rgbColor.g - (rgbColor.r + rgbColor.b) / valType(2);
+		result.z/*Cg*/ = rgbColor.g - (rgbColor.r + rgbColor.b) / T(2);
 		return result;
 	}
 
-	template <typename valType> 
-	GLM_FUNC_QUALIFIER detail::tvec3<valType> YCoCg2rgb
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER detail::tvec3<T, P> YCoCg2rgb
 	(
-		detail::tvec3<valType> const & YCoCgColor
+		detail::tvec3<T, P> const & YCoCgColor
 	)
 	{
-		detail::tvec3<valType> result;
+		detail::tvec3<T, P> result;
 		result.r = YCoCgColor.x + YCoCgColor.y - YCoCgColor.z;
 		result.g = YCoCgColor.x                + YCoCgColor.z;
 		result.b = YCoCgColor.x - YCoCgColor.y - YCoCgColor.z;
 		return result;
 	}
 
-	template <typename valType> 
-	GLM_FUNC_QUALIFIER detail::tvec3<valType> YCoCgR2rgb
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER detail::tvec3<T, P> YCoCgR2rgb
 	(
-		detail::tvec3<valType> const & YCoCgRColor
+		detail::tvec3<T, P> const & YCoCgRColor
 	)
 	{
-		detail::tvec3<valType> result;
-		valType tmp = YCoCgRColor.x - (YCoCgRColor.z / valType(2));
+		detail::tvec3<T, P> result;
+		T tmp = YCoCgRColor.x - (YCoCgRColor.z / T(2));
 		result.g = YCoCgRColor.z + tmp;
-		result.b = tmp - (YCoCgRColor.y / valType(2));
+		result.b = tmp - (YCoCgRColor.y / T(2));
 		result.r = result.b + YCoCgRColor.y;
 		return result;
 	}

glm/gtx/compatibility.hpp

@@ -62,29 +62,29 @@ namespace glm
 	/// @{
 
 	template <typename T> GLM_FUNC_QUALIFIER T lerp(T x, T y, T a){return mix(x, y, a);}																					//!< \brief Returns x * (1.0 - a) + y * a, i.e., the linear blend of x and y using the floating-point value a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
-	template <typename T> GLM_FUNC_QUALIFIER detail::tvec2<T, P> lerp(const detail::tvec2<T, P>& x, const detail::tvec2<T, P>& y, T a){return mix(x, y, a);}							//!< \brief Returns x * (1.0 - a) + y * a, i.e., the linear blend of x and y using the floating-point value a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
-	template <typename T> GLM_FUNC_QUALIFIER detail::tvec3<T, P> lerp(const detail::tvec3<T, P>& x, const detail::tvec3<T, P>& y, T a){return mix(x, y, a);}							//!< \brief Returns x * (1.0 - a) + y * a, i.e., the linear blend of x and y using the floating-point value a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
-	template <typename T> GLM_FUNC_QUALIFIER detail::tvec4<T, P> lerp(const detail::tvec4<T, P>& x, const detail::tvec4<T, P>& y, T a){return mix(x, y, a);}							//!< \brief Returns x * (1.0 - a) + y * a, i.e., the linear blend of x and y using the floating-point value a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
-	template <typename T> GLM_FUNC_QUALIFIER detail::tvec2<T, P> lerp(const detail::tvec2<T, P>& x, const detail::tvec2<T, P>& y, const detail::tvec2<T, P>& a){return mix(x, y, a);}	//!< \brief Returns the component-wise result of x * (1.0 - a) + y * a, i.e., the linear blend of x and y using vector a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
-	template <typename T> GLM_FUNC_QUALIFIER detail::tvec3<T, P> lerp(const detail::tvec3<T, P>& x, const detail::tvec3<T, P>& y, const detail::tvec3<T, P>& a){return mix(x, y, a);}	//!< \brief Returns the component-wise result of x * (1.0 - a) + y * a, i.e., the linear blend of x and y using vector a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
-	template <typename T> GLM_FUNC_QUALIFIER detail::tvec4<T, P> lerp(const detail::tvec4<T, P>& x, const detail::tvec4<T, P>& y, const detail::tvec4<T, P>& a){return mix(x, y, a);}	//!< \brief Returns the component-wise result of x * (1.0 - a) + y * a, i.e., the linear blend of x and y using vector a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
+	template <typename T, precision P> GLM_FUNC_QUALIFIER detail::tvec2<T, P> lerp(const detail::tvec2<T, P>& x, const detail::tvec2<T, P>& y, T a){return mix(x, y, a);}							//!< \brief Returns x * (1.0 - a) + y * a, i.e., the linear blend of x and y using the floating-point value a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
+	template <typename T, precision P> GLM_FUNC_QUALIFIER detail::tvec3<T, P> lerp(const detail::tvec3<T, P>& x, const detail::tvec3<T, P>& y, T a){return mix(x, y, a);}							//!< \brief Returns x * (1.0 - a) + y * a, i.e., the linear blend of x and y using the floating-point value a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
+	template <typename T, precision P> GLM_FUNC_QUALIFIER detail::tvec4<T, P> lerp(const detail::tvec4<T, P>& x, const detail::tvec4<T, P>& y, T a){return mix(x, y, a);}							//!< \brief Returns x * (1.0 - a) + y * a, i.e., the linear blend of x and y using the floating-point value a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
+	template <typename T, precision P> GLM_FUNC_QUALIFIER detail::tvec2<T, P> lerp(const detail::tvec2<T, P>& x, const detail::tvec2<T, P>& y, const detail::tvec2<T, P>& a){return mix(x, y, a);}	//!< \brief Returns the component-wise result of x * (1.0 - a) + y * a, i.e., the linear blend of x and y using vector a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
+	template <typename T, precision P> GLM_FUNC_QUALIFIER detail::tvec3<T, P> lerp(const detail::tvec3<T, P>& x, const detail::tvec3<T, P>& y, const detail::tvec3<T, P>& a){return mix(x, y, a);}	//!< \brief Returns the component-wise result of x * (1.0 - a) + y * a, i.e., the linear blend of x and y using vector a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
+	template <typename T, precision P> GLM_FUNC_QUALIFIER detail::tvec4<T, P> lerp(const detail::tvec4<T, P>& x, const detail::tvec4<T, P>& y, const detail::tvec4<T, P>& a){return mix(x, y, a);}	//!< \brief Returns the component-wise result of x * (1.0 - a) + y * a, i.e., the linear blend of x and y using vector a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
 
-	template <typename T> GLM_FUNC_QUALIFIER T slerp(detail::tquat<T, P> const & x, detail::tquat<T, P> const & y, T const & a){return mix(x, y, a);} //!< \brief Returns the slurp interpolation between two quaternions.
+	template <typename T, precision P> GLM_FUNC_QUALIFIER T slerp(detail::tquat<T, P> const & x, detail::tquat<T, P> const & y, T const & a){return mix(x, y, a);} //!< \brief Returns the slurp interpolation between two quaternions.
 
-	template <typename T> GLM_FUNC_QUALIFIER T saturate(T x){return clamp(x, T(0), T(1));}														//!< \brief Returns clamp(x, 0, 1) for each component in x. (From GLM_GTX_compatibility)
-	template <typename T> GLM_FUNC_QUALIFIER detail::tvec2<T, P> saturate(const detail::tvec2<T, P>& x){return clamp(x, T(0), T(1));}					//!< \brief Returns clamp(x, 0, 1) for each component in x. (From GLM_GTX_compatibility)
-	template <typename T> GLM_FUNC_QUALIFIER detail::tvec3<T, P> saturate(const detail::tvec3<T, P>& x){return clamp(x, T(0), T(1));}					//!< \brief Returns clamp(x, 0, 1) for each component in x. (From GLM_GTX_compatibility)
-	template <typename T> GLM_FUNC_QUALIFIER detail::tvec4<T, P> saturate(const detail::tvec4<T, P>& x){return clamp(x, T(0), T(1));}					//!< \brief Returns clamp(x, 0, 1) for each component in x. (From GLM_GTX_compatibility)
+	template <typename T, precision P> GLM_FUNC_QUALIFIER T saturate(T x){return clamp(x, T(0), T(1));}														//!< \brief Returns clamp(x, 0, 1) for each component in x. (From GLM_GTX_compatibility)
+	template <typename T, precision P> GLM_FUNC_QUALIFIER detail::tvec2<T, P> saturate(const detail::tvec2<T, P>& x){return clamp(x, T(0), T(1));}					//!< \brief Returns clamp(x, 0, 1) for each component in x. (From GLM_GTX_compatibility)
+	template <typename T, precision P> GLM_FUNC_QUALIFIER detail::tvec3<T, P> saturate(const detail::tvec3<T, P>& x){return clamp(x, T(0), T(1));}					//!< \brief Returns clamp(x, 0, 1) for each component in x. (From GLM_GTX_compatibility)
+	template <typename T, precision P> GLM_FUNC_QUALIFIER detail::tvec4<T, P> saturate(const detail::tvec4<T, P>& x){return clamp(x, T(0), T(1));}					//!< \brief Returns clamp(x, 0, 1) for each component in x. (From GLM_GTX_compatibility)
 
-	template <typename T> GLM_FUNC_QUALIFIER T atan2(T x, T y){return atan(x, y);}																//!< \brief Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0. (From GLM_GTX_compatibility)
-	template <typename T> GLM_FUNC_QUALIFIER detail::tvec2<T, P> atan2(const detail::tvec2<T, P>& x, const detail::tvec2<T, P>& y){return atan(x, y);}	//!< \brief Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0. (From GLM_GTX_compatibility)
-	template <typename T> GLM_FUNC_QUALIFIER detail::tvec3<T, P> atan2(const detail::tvec3<T, P>& x, const detail::tvec3<T, P>& y){return atan(x, y);}	//!< \brief Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0. (From GLM_GTX_compatibility)
-	template <typename T> GLM_FUNC_QUALIFIER detail::tvec4<T, P> atan2(const detail::tvec4<T, P>& x, const detail::tvec4<T, P>& y){return atan(x, y);}	//!< \brief Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0. (From GLM_GTX_compatibility)
+	template <typename T, precision P> GLM_FUNC_QUALIFIER T atan2(T x, T y){return atan(x, y);}																//!< \brief Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0. (From GLM_GTX_compatibility)
+	template <typename T, precision P> GLM_FUNC_QUALIFIER detail::tvec2<T, P> atan2(const detail::tvec2<T, P>& x, const detail::tvec2<T, P>& y){return atan(x, y);}	//!< \brief Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0. (From GLM_GTX_compatibility)
+	template <typename T, precision P> GLM_FUNC_QUALIFIER detail::tvec3<T, P> atan2(const detail::tvec3<T, P>& x, const detail::tvec3<T, P>& y){return atan(x, y);}	//!< \brief Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0. (From GLM_GTX_compatibility)
+	template <typename T, precision P> GLM_FUNC_QUALIFIER detail::tvec4<T, P> atan2(const detail::tvec4<T, P>& x, const detail::tvec4<T, P>& y){return atan(x, y);}	//!< \brief Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0. (From GLM_GTX_compatibility)
 
 	template <typename genType> bool isfinite(genType const & x);											//!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
-	template <typename valType> detail::tvec2<bool> isfinite(const detail::tvec2<valType>& x);				//!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
-	template <typename valType> detail::tvec3<bool> isfinite(const detail::tvec3<valType>& x);				//!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
-	template <typename valType> detail::tvec4<bool> isfinite(const detail::tvec4<valType>& x);				//!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
+	template <typename T, precision P> detail::tvec2<bool, P> isfinite(const detail::tvec2<T, P>& x);				//!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
+	template <typename T, precision P> detail::tvec3<bool, P> isfinite(const detail::tvec3<T, P>& x);				//!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
+	template <typename T, precision P> detail::tvec4<bool, P> isfinite(const detail::tvec4<T, P>& x);				//!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
 
 	typedef bool						bool1;			//!< \brief boolean type with 1 component. (From GLM_GTX_compatibility extension)
 	typedef detail::tvec2<bool, highp>			bool2;			//!< \brief boolean type with 2 components. (From GLM_GTX_compatibility extension)

glm/gtx/compatibility.inl

@@ -27,30 +27,30 @@ namespace glm
 #		endif
 	}
 
-	template <typename valType> 
-	GLM_FUNC_QUALIFIER detail::tvec2<bool> isfinite(
-		detail::tvec2<valType> const & x)
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER detail::tvec2<bool, P> isfinite(
+		detail::tvec2<T, P> const & x)
 	{
-		return detail::tvec2<bool>(
+		return detail::tvec2<bool, P>(
 			isfinite(x.x),
 			isfinite(x.y));
 	}
 
-	template <typename valType> 
-	GLM_FUNC_QUALIFIER detail::tvec3<bool> isfinite(
-		detail::tvec3<valType> const & x)
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER detail::tvec3<bool, P> isfinite(
+		detail::tvec3<T, P> const & x)
 	{
-		return detail::tvec3<bool>(
+		return detail::tvec3<bool, P>(
 			isfinite(x.x),
 			isfinite(x.y),
 			isfinite(x.z));
 	}
 
-	template <typename valType> 
-	GLM_FUNC_QUALIFIER detail::tvec4<bool> isfinite(
-		detail::tvec4<valType> const & x)
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER detail::tvec4<bool, P> isfinite(
+		detail::tvec4<T, P> const & x)
 	{
-		return detail::tvec4<bool>(
+		return detail::tvec4<bool, P>(
 			isfinite(x.x),
 			isfinite(x.y),
 			isfinite(x.z),

glm/gtx/extend.inl

@@ -20,34 +20,34 @@ namespace glm
 		return Origin + (Source - Origin) * Distance;
 	}
 
-	template <typename valType>
-	GLM_FUNC_QUALIFIER detail::tvec2<valType> extend
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER detail::tvec2<T, P> extend
 	(
-		detail::tvec2<valType> const & Origin, 
-		detail::tvec2<valType> const & Source, 
-		valType const & Distance
+		detail::tvec2<T, P> const & Origin,
+		detail::tvec2<T, P> const & Source,
+		T const & Distance
 	)
 	{
 		return Origin + (Source - Origin) * Distance;
 	}
 
-	template <typename valType>
-	GLM_FUNC_QUALIFIER detail::tvec3<valType> extend
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER detail::tvec3<T, P> extend
 	(
-		detail::tvec3<valType> const & Origin, 
-		detail::tvec3<valType> const & Source, 
-		valType const & Distance
+		detail::tvec3<T, P> const & Origin,
+		detail::tvec3<T, P> const & Source,
+		T const & Distance
 	)
 	{
 		return Origin + (Source - Origin) * Distance;
 	}
 
-	template <typename valType>
-	GLM_FUNC_QUALIFIER detail::tvec4<valType> extend
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER detail::tvec4<T, P> extend
 	(
-		detail::tvec4<valType> const & Origin, 
-		detail::tvec4<valType> const & Source, 
-		valType const & Distance
+		detail::tvec4<T, P> const & Origin,
+		detail::tvec4<T, P> const & Source,
+		T const & Distance
 	)
 	{
 		return Origin + (Source - Origin) * Distance;

test/gtx/CMakeLists.txt

@@ -1,10 +1,37 @@
+glmCreateTestGTC(gtx_associated_min_max)
 glmCreateTestGTC(gtx_bit)
+glmCreateTestGTC(gtx_closest_point)
+glmCreateTestGTC(gtx_color_space_YCoCg)
+glmCreateTestGTC(gtx_color_space)
+glmCreateTestGTC(gtx_compatibility)
+glmCreateTestGTC(gtx_component_wise)
 glmCreateTestGTC(gtx_euler_angle)
+glmCreateTestGTC(gtx_extend)
+glmCreateTestGTC(gtx_extented_min_max)
+glmCreateTestGTC(gtx_fast_exponential)
+glmCreateTestGTC(gtx_fast_square_root)
+glmCreateTestGTC(gtx_fast_trigonometry)
 glmCreateTestGTC(gtx_gradient_paint)
+glmCreateTestGTC(gtx_handed_coordinate_space)
+glmCreateTestGTC(gtx_inertia)
 glmCreateTestGTC(gtx_integer)
+glmCreateTestGTC(gtx_intersect)
+glmCreateTestGTC(gtx_log_base)
+glmCreateTestGTC(gtx_matrix_cross_product)
 glmCreateTestGTC(gtx_matrix_interpolation)
+glmCreateTestGTC(gtx_matrix_major_storage)
+glmCreateTestGTC(gtx_matrix_operation)
 glmCreateTestGTC(gtx_matrix_query)
 glmCreateTestGTC(gtx_multiple)
+glmCreateTestGTC(gtx_norm)
+glmCreateTestGTC(gtx_normal)
+glmCreateTestGTC(gtx_normalize_dot)
+glmCreateTestGTC(gtx_number_precision)
+glmCreateTestGTC(gtx_orthonormalize)
+glmCreateTestGTC(gtx_optimum_pow)
+glmCreateTestGTC(gtx_perpendicular)
+glmCreateTestGTC(gtx_polar_coordinates)
+glmCreateTestGTC(gtx_projection)
 glmCreateTestGTC(gtx_quaternion)
 glmCreateTestGTC(gtx_dual_quaternion)
 glmCreateTestGTC(gtx_rotate_normalized_axis)
@@ -12,6 +39,7 @@ glmCreateTestGTC(gtx_rotate_vector)
 glmCreateTestGTC(gtx_scalar_relational)
 glmCreateTestGTC(gtx_simd_vec4)
 glmCreateTestGTC(gtx_simd_mat4)
+glmCreateTestGTC(gtx_spline)
 glmCreateTestGTC(gtx_string_cast)
 glmCreateTestGTC(gtx_vector_angle)
 glmCreateTestGTC(gtx_vector_query)

test/gtx/gtx_associated_min_max.cpp

@@ -0,0 +1,21 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2013-10-25
+// Updated : 2013-10-25
+// Licence : This source is under MIT licence
+// File    : test/gtx/associated_min_max.cpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#include <emmintrin.h>
+
+#include <glm/glm.hpp>
+#include <glm/gtc/type_precision.hpp>
+#include <glm/gtx/associated_min_max.hpp>
+
+int main()
+{
+	int Error(0);
+
+	return Error;
+}

test/gtx/gtx_closest_point.cpp

@@ -0,0 +1,21 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2013-10-25
+// Updated : 2013-10-25
+// Licence : This source is under MIT licence
+// File    : test/gtx/associated_min_max.cpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#include <emmintrin.h>
+
+#include <glm/glm.hpp>
+#include <glm/gtc/type_precision.hpp>
+#include <glm/gtx/associated_min_max.hpp>
+
+int main()
+{
+	int Error(0);
+
+	return Error;
+}

test/gtx/gtx_color_space.cpp

@@ -0,0 +1,21 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2013-10-25
+// Updated : 2013-10-25
+// Licence : This source is under MIT licence
+// File    : test/gtx/color_space.cpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#include <emmintrin.h>
+
+#include <glm/glm.hpp>
+#include <glm/gtc/type_precision.hpp>
+#include <glm/gtx/color_space.hpp>
+
+int main()
+{
+	int Error(0);
+
+	return Error;
+}

test/gtx/gtx_color_space_YCoCg.cpp

@@ -0,0 +1,21 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2013-10-25
+// Updated : 2013-10-25
+// Licence : This source is under MIT licence
+// File    : test/gtx/color_space_YCoCg.cpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#include <emmintrin.h>
+
+#include <glm/glm.hpp>
+#include <glm/gtc/type_precision.hpp>
+#include <glm/gtx/color_space_YCoCg.hpp>
+
+int main()
+{
+	int Error(0);
+
+	return Error;
+}

test/gtx/gtx_compatibility.cpp

@@ -0,0 +1,19 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2013-10-25
+// Updated : 2013-10-25
+// Licence : This source is under MIT licence
+// File    : test/gtx/compatibility.cpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#include <glm/glm.hpp>
+#include <glm/gtc/type_precision.hpp>
+#include <glm/gtx/compatibility.hpp>
+
+int main()
+{
+	int Error(0);
+
+	return Error;
+}

test/gtx/gtx_component_wise.cpp

@@ -0,0 +1,21 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2013-10-25
+// Updated : 2013-10-25
+// Licence : This source is under MIT licence
+// File    : test/gtx/component_wise.cpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#include <emmintrin.h>
+
+#include <glm/glm.hpp>
+#include <glm/gtc/type_precision.hpp>
+#include <glm/gtx/component_wise.hpp>
+
+int main()
+{
+	int Error(0);
+
+	return Error;
+}

test/gtx/gtx_extend.cpp

@@ -0,0 +1,19 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2013-10-25
+// Updated : 2013-10-25
+// Licence : This source is under MIT licence
+// File    : test/gtx/extend.cpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#include <glm/glm.hpp>
+#include <glm/gtc/type_precision.hpp>
+#include <glm/gtx/extend.hpp>
+
+int main()
+{
+	int Error(0);
+
+	return Error;
+}

test/gtx/gtx_extented_min_max.cpp

@@ -0,0 +1,21 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2013-10-25
+// Updated : 2013-10-25
+// Licence : This source is under MIT licence
+// File    : test/gtx/associated_min_max.cpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#include <emmintrin.h>
+
+#include <glm/glm.hpp>
+#include <glm/gtc/type_precision.hpp>
+#include <glm/gtx/associated_min_max.hpp>
+
+int main()
+{
+	int Error(0);
+
+	return Error;
+}

test/gtx/gtx_fast_exponential.cpp

@@ -0,0 +1,21 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2013-10-25
+// Updated : 2013-10-25
+// Licence : This source is under MIT licence
+// File    : test/gtx/associated_min_max.cpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#include <emmintrin.h>
+
+#include <glm/glm.hpp>
+#include <glm/gtc/type_precision.hpp>
+#include <glm/gtx/associated_min_max.hpp>
+
+int main()
+{
+	int Error(0);
+
+	return Error;
+}

test/gtx/gtx_fast_square_root.cpp

@@ -0,0 +1,21 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2013-10-25
+// Updated : 2013-10-25
+// Licence : This source is under MIT licence
+// File    : test/gtx/associated_min_max.cpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#include <emmintrin.h>
+
+#include <glm/glm.hpp>
+#include <glm/gtc/type_precision.hpp>
+#include <glm/gtx/associated_min_max.hpp>
+
+int main()
+{
+	int Error(0);
+
+	return Error;
+}

test/gtx/gtx_fast_trigonometry.cpp

@@ -0,0 +1,21 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2013-10-25
+// Updated : 2013-10-25
+// Licence : This source is under MIT licence
+// File    : test/gtx/associated_min_max.cpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#include <emmintrin.h>
+
+#include <glm/glm.hpp>
+#include <glm/gtc/type_precision.hpp>
+#include <glm/gtx/associated_min_max.hpp>
+
+int main()
+{
+	int Error(0);
+
+	return Error;
+}

test/gtx/gtx_handed_coordinate_space.cpp

@@ -0,0 +1,21 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2013-10-25
+// Updated : 2013-10-25
+// Licence : This source is under MIT licence
+// File    : test/gtx/associated_min_max.cpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#include <emmintrin.h>
+
+#include <glm/glm.hpp>
+#include <glm/gtc/type_precision.hpp>
+#include <glm/gtx/associated_min_max.hpp>
+
+int main()
+{
+	int Error(0);
+
+	return Error;
+}

test/gtx/gtx_inertia.cpp

@@ -0,0 +1,21 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2013-10-25
+// Updated : 2013-10-25
+// Licence : This source is under MIT licence
+// File    : test/gtx/associated_min_max.cpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#include <emmintrin.h>
+
+#include <glm/glm.hpp>
+#include <glm/gtc/type_precision.hpp>
+#include <glm/gtx/associated_min_max.hpp>
+
+int main()
+{
+	int Error(0);
+
+	return Error;
+}

test/gtx/gtx_int_10_10_10_2.cpp

@@ -0,0 +1,21 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2013-10-25
+// Updated : 2013-10-25
+// Licence : This source is under MIT licence
+// File    : test/gtx/associated_min_max.cpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#include <emmintrin.h>
+
+#include <glm/glm.hpp>
+#include <glm/gtc/type_precision.hpp>
+#include <glm/gtx/associated_min_max.hpp>
+
+int main()
+{
+	int Error(0);
+
+	return Error;
+}

test/gtx/gtx_intersect.cpp

@@ -0,0 +1,21 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2013-10-25
+// Updated : 2013-10-25
+// Licence : This source is under MIT licence
+// File    : test/gtx/associated_min_max.cpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#include <emmintrin.h>
+
+#include <glm/glm.hpp>
+#include <glm/gtc/type_precision.hpp>
+#include <glm/gtx/associated_min_max.hpp>
+
+int main()
+{
+	int Error(0);
+
+	return Error;
+}

test/gtx/gtx_log_base.cpp

@@ -0,0 +1,21 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2013-10-25
+// Updated : 2013-10-25
+// Licence : This source is under MIT licence
+// File    : test/gtx/associated_min_max.cpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#include <emmintrin.h>
+
+#include <glm/glm.hpp>
+#include <glm/gtc/type_precision.hpp>
+#include <glm/gtx/associated_min_max.hpp>
+
+int main()
+{
+	int Error(0);
+
+	return Error;
+}

test/gtx/gtx_matrix_cross_product.cpp

@@ -0,0 +1,21 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2013-10-25
+// Updated : 2013-10-25
+// Licence : This source is under MIT licence
+// File    : test/gtx/associated_min_max.cpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#include <emmintrin.h>
+
+#include <glm/glm.hpp>
+#include <glm/gtc/type_precision.hpp>
+#include <glm/gtx/associated_min_max.hpp>
+
+int main()
+{
+	int Error(0);
+
+	return Error;
+}

test/gtx/gtx_matrix_major_storage.cpp

@@ -0,0 +1,21 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2013-10-25
+// Updated : 2013-10-25
+// Licence : This source is under MIT licence
+// File    : test/gtx/associated_min_max.cpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#include <emmintrin.h>
+
+#include <glm/glm.hpp>
+#include <glm/gtc/type_precision.hpp>
+#include <glm/gtx/associated_min_max.hpp>
+
+int main()
+{
+	int Error(0);
+
+	return Error;
+}

test/gtx/gtx_matrix_operation.cpp

@@ -0,0 +1,21 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2013-10-25
+// Updated : 2013-10-25
+// Licence : This source is under MIT licence
+// File    : test/gtx/associated_min_max.cpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#include <emmintrin.h>
+
+#include <glm/glm.hpp>
+#include <glm/gtc/type_precision.hpp>
+#include <glm/gtx/associated_min_max.hpp>
+
+int main()
+{
+	int Error(0);
+
+	return Error;
+}

test/gtx/gtx_mixed_product.cpp

@@ -0,0 +1,21 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2013-10-25
+// Updated : 2013-10-25
+// Licence : This source is under MIT licence
+// File    : test/gtx/associated_min_max.cpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#include <emmintrin.h>
+
+#include <glm/glm.hpp>
+#include <glm/gtc/type_precision.hpp>
+#include <glm/gtx/associated_min_max.hpp>
+
+int main()
+{
+	int Error(0);
+
+	return Error;
+}

test/gtx/gtx_norm.cpp

@@ -0,0 +1,21 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2013-10-25
+// Updated : 2013-10-25
+// Licence : This source is under MIT licence
+// File    : test/gtx/associated_min_max.cpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#include <emmintrin.h>
+
+#include <glm/glm.hpp>
+#include <glm/gtc/type_precision.hpp>
+#include <glm/gtx/associated_min_max.hpp>
+
+int main()
+{
+	int Error(0);
+
+	return Error;
+}

test/gtx/gtx_normal.cpp

@@ -0,0 +1,21 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2013-10-25
+// Updated : 2013-10-25
+// Licence : This source is under MIT licence
+// File    : test/gtx/associated_min_max.cpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#include <emmintrin.h>
+
+#include <glm/glm.hpp>
+#include <glm/gtc/type_precision.hpp>
+#include <glm/gtx/associated_min_max.hpp>
+
+int main()
+{
+	int Error(0);
+
+	return Error;
+}

test/gtx/gtx_normalize_dot.cpp

@@ -0,0 +1,21 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2013-10-25
+// Updated : 2013-10-25
+// Licence : This source is under MIT licence
+// File    : test/gtx/associated_min_max.cpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#include <emmintrin.h>
+
+#include <glm/glm.hpp>
+#include <glm/gtc/type_precision.hpp>
+#include <glm/gtx/associated_min_max.hpp>
+
+int main()
+{
+	int Error(0);
+
+	return Error;
+}

test/gtx/gtx_number_precision.cpp

@@ -0,0 +1,21 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2013-10-25
+// Updated : 2013-10-25
+// Licence : This source is under MIT licence
+// File    : test/gtx/associated_min_max.cpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#include <emmintrin.h>
+
+#include <glm/glm.hpp>
+#include <glm/gtc/type_precision.hpp>
+#include <glm/gtx/associated_min_max.hpp>
+
+int main()
+{
+	int Error(0);
+
+	return Error;
+}

test/gtx/gtx_optimum_pow.cpp

@@ -0,0 +1,21 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2013-10-25
+// Updated : 2013-10-25
+// Licence : This source is under MIT licence
+// File    : test/gtx/associated_min_max.cpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#include <emmintrin.h>
+
+#include <glm/glm.hpp>
+#include <glm/gtc/type_precision.hpp>
+#include <glm/gtx/associated_min_max.hpp>
+
+int main()
+{
+	int Error(0);
+
+	return Error;
+}

test/gtx/gtx_orthonormalize.cpp

@@ -0,0 +1,21 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2013-10-25
+// Updated : 2013-10-25
+// Licence : This source is under MIT licence
+// File    : test/gtx/associated_min_max.cpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#include <emmintrin.h>
+
+#include <glm/glm.hpp>
+#include <glm/gtc/type_precision.hpp>
+#include <glm/gtx/associated_min_max.hpp>
+
+int main()
+{
+	int Error(0);
+
+	return Error;
+}

test/gtx/gtx_perpendicular.cpp

@@ -0,0 +1,21 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2013-10-25
+// Updated : 2013-10-25
+// Licence : This source is under MIT licence
+// File    : test/gtx/associated_min_max.cpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#include <emmintrin.h>
+
+#include <glm/glm.hpp>
+#include <glm/gtc/type_precision.hpp>
+#include <glm/gtx/associated_min_max.hpp>
+
+int main()
+{
+	int Error(0);
+
+	return Error;
+}

test/gtx/gtx_polar_coordinates.cpp

@@ -0,0 +1,21 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2013-10-25
+// Updated : 2013-10-25
+// Licence : This source is under MIT licence
+// File    : test/gtx/associated_min_max.cpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#include <emmintrin.h>
+
+#include <glm/glm.hpp>
+#include <glm/gtc/type_precision.hpp>
+#include <glm/gtx/associated_min_max.hpp>
+
+int main()
+{
+	int Error(0);
+
+	return Error;
+}

test/gtx/gtx_projection.cpp

@@ -0,0 +1,21 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2013-10-25
+// Updated : 2013-10-25
+// Licence : This source is under MIT licence
+// File    : test/gtx/associated_min_max.cpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#include <emmintrin.h>
+
+#include <glm/glm.hpp>
+#include <glm/gtc/type_precision.hpp>
+#include <glm/gtx/associated_min_max.hpp>
+
+int main()
+{
+	int Error(0);
+
+	return Error;
+}

test/gtx/gtx_spline.cpp

@@ -0,0 +1,19 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2013-10-25
+// Updated : 2013-10-25
+// Licence : This source is under MIT licence
+// File    : test/gtx/associated_min_max.cpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#include <glm/glm.hpp>
+#include <glm/gtc/type_precision.hpp>
+#include <glm/gtx/spline.hpp>
+
+int main()
+{
+	int Error(0);
+
+	return Error;
+}