external: import local copy of GLM 0.9.7.2

This allows building against the same version of GLM across all targets
and not deal with API changes of newer GLM versions which introduce
regressions. Long term we want to migrate away from GLM and stick to a
minimal self-written subset.

external/glm/test/gtx/CMakeLists.txt

@@ -0,0 +1,50 @@
+glmCreateTestGTC(gtx_associated_min_max)
+glmCreateTestGTC(gtx_closest_point)
+glmCreateTestGTC(gtx_color_space_YCoCg)
+glmCreateTestGTC(gtx_color_space)
+glmCreateTestGTC(gtx_common)
+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_integer)
+glmCreateTestGTC(gtx_intersect)
+glmCreateTestGTC(gtx_io)
+glmCreateTestGTC(gtx_log_base)
+glmCreateTestGTC(gtx_matrix_cross_product)
+glmCreateTestGTC(gtx_matrix_decompose)
+glmCreateTestGTC(gtx_matrix_interpolation)
+glmCreateTestGTC(gtx_matrix_major_storage)
+glmCreateTestGTC(gtx_matrix_operation)
+glmCreateTestGTC(gtx_matrix_query)
+glmCreateTestGTC(gtx_matrix_transform_2d)
+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_range)
+glmCreateTestGTC(gtx_rotate_normalized_axis)
+glmCreateTestGTC(gtx_rotate_vector)
+glmCreateTestGTC(gtx_scalar_multiplication)
+glmCreateTestGTC(gtx_scalar_relational)
+glmCreateTestGTC(gtx_simd_vec4)
+glmCreateTestGTC(gtx_simd_mat4)
+glmCreateTestGTC(gtx_spline)
+glmCreateTestGTC(gtx_string_cast)
+glmCreateTestGTC(gtx_type_aligned)
+glmCreateTestGTC(gtx_vector_angle)
+glmCreateTestGTC(gtx_vector_query)
+glmCreateTestGTC(gtx_wrap)

external/glm/test/gtx/gtx_associated_min_max.cpp

@@ -0,0 +1,40 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2015 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.
+/// 
+/// Restrictions:
+///		By making use of the Software for military purposes, you choose to make
+///		a Bunny unhappy.
+/// 
+/// 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.
+///
+/// @file test/gtx/gtx_associated_min_max.cpp
+/// @date 2013-10-25 / 2014-11-25
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#include <glm/gtc/type_precision.hpp>
+#include <glm/gtx/associated_min_max.hpp>
+
+int main()
+{
+	int Error(0);
+
+	return Error;
+}

external/glm/test/gtx/gtx_closest_point.cpp

@@ -0,0 +1,39 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2015 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.
+/// 
+/// Restrictions:
+///		By making use of the Software for military purposes, you choose to make
+///		a Bunny unhappy.
+/// 
+/// 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.
+///
+/// @file test/gtx/gtx_closest_point.cpp
+/// @date 2013-10-25 / 2014-11-25
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#include <glm/gtx/closest_point.hpp>
+
+int main()
+{
+	int Error(0);
+
+	return Error;
+}

external/glm/test/gtx/gtx_color_space.cpp

@@ -0,0 +1,50 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2015 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.
+/// 
+/// Restrictions:
+///		By making use of the Software for military purposes, you choose to make
+///		a Bunny unhappy.
+/// 
+/// 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.
+///
+/// @file test/gtx/gtx_color_space.cpp
+/// @date 2013-10-25 / 2014-11-25
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#include <glm/gtx/color_space.hpp>
+
+int test_saturation()
+{
+	int Error(0);
+	
+	glm::vec4 Color = glm::saturation(1.0f, glm::vec4(1.0, 0.5, 0.0, 1.0));
+
+	return Error;
+}
+
+int main()
+{
+	int Error(0);
+
+	Error += test_saturation();
+
+	return Error;
+}

external/glm/test/gtx/gtx_color_space_YCoCg.cpp

@@ -0,0 +1,39 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2015 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.
+/// 
+/// Restrictions:
+///		By making use of the Software for military purposes, you choose to make
+///		a Bunny unhappy.
+/// 
+/// 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.
+///
+/// @file test/gtx/gtx_color_space_YCoCg.cpp
+/// @date 2013-10-25 / 2014-11-25
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#include <glm/gtx/color_space_YCoCg.hpp>
+
+int main()
+{
+	int Error(0);
+
+	return Error;
+}

external/glm/test/gtx/gtx_common.cpp

@@ -0,0 +1,158 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2015 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.
+/// 
+/// Restrictions:
+///		By making use of the Software for military purposes, you choose to make
+///		a Bunny unhappy.
+/// 
+/// 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.
+///
+/// @file test/gtx/gtx_common.cpp
+/// @date 2014-09-08 / 2014-11-25
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#include <glm/gtx/common.hpp>
+#include <glm/gtc/integer.hpp>
+#include <glm/gtc/epsilon.hpp>
+#include <glm/vector_relational.hpp>
+#include <glm/common.hpp>
+
+namespace fmod_
+{
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType modTrunc(genType a, genType b)
+	{
+		return a - b * glm::trunc(a / b);
+	}
+
+	int test()
+	{
+		int Error(0);
+
+		{
+			float A0(3.0);
+			float B0(2.0f);
+			float C0 = glm::fmod(A0, B0);
+
+			Error += glm::abs(C0 - 1.0f) < 0.00001f ? 0 : 1;
+
+			glm::vec4 A1(3.0);
+			float B1(2.0f);
+			glm::vec4 C1 = glm::fmod(A1, B1);
+
+			Error += glm::all(glm::epsilonEqual(C1, glm::vec4(1.0f), 0.00001f)) ? 0 : 1;
+
+			glm::vec4 A2(3.0);
+			glm::vec4 B2(2.0f);
+			glm::vec4 C2 = glm::fmod(A2, B2);
+
+			Error += glm::all(glm::epsilonEqual(C2, glm::vec4(1.0f), 0.00001f)) ? 0 : 1;
+
+			glm::ivec4 A3(3);
+			int B3(2);
+			glm::ivec4 C3 = glm::fmod(A3, B3);
+
+			Error += glm::all(glm::equal(C3, glm::ivec4(1))) ? 0 : 1;
+
+			glm::ivec4 A4(3);
+			glm::ivec4 B4(2);
+			glm::ivec4 C4 = glm::fmod(A4, B4);
+
+			Error += glm::all(glm::equal(C4, glm::ivec4(1))) ? 0 : 1;
+		}
+
+		{
+			float A0(22.0);
+			float B0(-10.0f);
+			float C0 = glm::fmod(A0, B0);
+
+			Error += glm::abs(C0 - 2.0f) < 0.00001f ? 0 : 1;
+
+			glm::vec4 A1(22.0);
+			float B1(-10.0f);
+			glm::vec4 C1 = glm::fmod(A1, B1);
+
+			Error += glm::all(glm::epsilonEqual(C1, glm::vec4(2.0f), 0.00001f)) ? 0 : 1;
+
+			glm::vec4 A2(22.0);
+			glm::vec4 B2(-10.0f);
+			glm::vec4 C2 = glm::fmod(A2, B2);
+
+			Error += glm::all(glm::epsilonEqual(C2, glm::vec4(2.0f), 0.00001f)) ? 0 : 1;
+
+			glm::ivec4 A3(22);
+			int B3(-10);
+			glm::ivec4 C3 = glm::fmod(A3, B3);
+
+			Error += glm::all(glm::equal(C3, glm::ivec4(2))) ? 0 : 1;
+
+			glm::ivec4 A4(22);
+			glm::ivec4 B4(-10);
+			glm::ivec4 C4 = glm::fmod(A4, B4);
+
+			Error += glm::all(glm::equal(C4, glm::ivec4(2))) ? 0 : 1;
+		}
+
+		// http://stackoverflow.com/questions/7610631/glsl-mod-vs-hlsl-fmod
+		{
+			for (float y = -10.0f; y < 10.0f; y += 0.1f)
+			for (float x = -10.0f; x < 10.0f; x += 0.1f)
+			{
+				float const A(std::fmod(x, y));
+				//float const B(std::remainder(x, y));
+				float const C(glm::fmod(x, y));
+				float const D(modTrunc(x, y));
+
+				//Error += glm::epsilonEqual(A, B, 0.0001f) ? 0 : 1;
+				//assert(!Error);
+				Error += glm::epsilonEqual(A, C, 0.0001f) ? 0 : 1;
+				assert(!Error);
+				Error += glm::epsilonEqual(A, D, 0.00001f) ? 0 : 1;
+				assert(!Error);
+			}
+		}
+
+		return Error;
+	}
+}//namespace fmod_
+
+int test_isdenormal()
+{
+	int Error(0);
+
+	bool A = glm::isdenormal(1.0f);
+	glm::bvec1 B = glm::isdenormal(glm::vec1(1.0f));
+	glm::bvec2 C = glm::isdenormal(glm::vec2(1.0f));
+	glm::bvec3 D = glm::isdenormal(glm::vec3(1.0f));
+	glm::bvec4 E = glm::isdenormal(glm::vec4(1.0f));
+
+	return Error;
+}
+
+int main()
+{
+	int Error(0);
+
+	Error += test_isdenormal();
+	Error += ::fmod_::test();
+
+	return Error;
+}

external/glm/test/gtx/gtx_compatibility.cpp

@@ -0,0 +1,49 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2015 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.
+/// 
+/// Restrictions:
+///		By making use of the Software for military purposes, you choose to make
+///		a Bunny unhappy.
+/// 
+/// 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.
+///
+/// @file test/gtx/gtx_compatibility.cpp
+/// @date 2014-09-08 / 2014-11-25
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#include <glm/gtx/compatibility.hpp>
+
+int main()
+{
+	int Error(0);
+
+	Error += glm::isfinite(1.0f) ? 0 : 1;
+	Error += glm::isfinite(1.0) ? 0 : 1;
+	Error += glm::isfinite(-1.0f) ? 0 : 1;
+	Error += glm::isfinite(-1.0) ? 0 : 1;
+
+	Error += glm::all(glm::isfinite(glm::vec4(1.0f))) ? 0 : 1;
+	Error += glm::all(glm::isfinite(glm::dvec4(1.0))) ? 0 : 1;
+	Error += glm::all(glm::isfinite(glm::vec4(-1.0f))) ? 0 : 1;
+	Error += glm::all(glm::isfinite(glm::dvec4(-1.0))) ? 0 : 1;
+
+	return Error;
+}

external/glm/test/gtx/gtx_component_wise.cpp

@@ -0,0 +1,39 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2015 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.
+/// 
+/// Restrictions:
+///		By making use of the Software for military purposes, you choose to make
+///		a Bunny unhappy.
+/// 
+/// 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.
+///
+/// @file test/gtx/gtx_component_wise.cpp
+/// @date 2013-10-25 / 2014-11-25
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#include <glm/gtx/component_wise.hpp>
+
+int main()
+{
+	int Error(0);
+
+	return Error;
+}

external/glm/test/gtx/gtx_dual_quaternion.cpp

@@ -0,0 +1,223 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2015 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.
+/// 
+/// Restrictions:
+///		By making use of the Software for military purposes, you choose to make
+///		a Bunny unhappy.
+/// 
+/// 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.
+///
+/// @file test/gtx/gtx_dual_quaternion.cpp
+/// @date 2013-02-10 / 2014-11-25
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#include <glm/gtx/dual_quaternion.hpp>
+#include <glm/gtc/matrix_transform.hpp>
+#include <glm/gtc/epsilon.hpp>
+#include <glm/gtx/euler_angles.hpp>
+#include <glm/vector_relational.hpp>
+#if GLM_HAS_TRIVIAL_QUERIES
+#	include <type_traits>
+#endif
+
+int myrand()
+{
+	static int holdrand = 1;
+	return (((holdrand = holdrand * 214013L + 2531011L) >> 16) & 0x7fff);
+}
+
+float myfrand() // returns values from -1 to 1 inclusive
+{
+	return float(double(myrand()) / double( 0x7ffff )) * 2.0f - 1.0f;
+}
+
+int test_dquat_type()
+{
+	glm::dvec3 vA;
+	glm::dquat dqA,dqB;
+	glm::ddualquat C(dqA,dqB);
+	glm::ddualquat B(dqA);
+	glm::ddualquat D(dqA,vA);
+	return 0;
+}
+
+int test_scalars()
+{
+	float const Epsilon = 0.0001f;
+
+	int Error(0);
+
+	glm::quat src_q1 = glm::quat(1.0f,2.0f,3.0f,4.0f);
+	glm::quat src_q2 = glm::quat(5.0f,6.0f,7.0f,8.0f);
+	glm::dualquat src1(src_q1,src_q2);
+
+	{
+		glm::dualquat dst1 = src1 * 2.0f;
+		glm::dualquat dst2 = 2.0f * src1;
+		glm::dualquat dst3 = src1;
+		dst3 *= 2.0f;
+		glm::dualquat dstCmp(src_q1 * 2.0f,src_q2 * 2.0f);
+		Error += glm::all(glm::epsilonEqual(dst1.real,dstCmp.real, Epsilon)) && glm::all(glm::epsilonEqual(dst1.dual,dstCmp.dual, Epsilon)) ? 0 : 1;
+		Error += glm::all(glm::epsilonEqual(dst2.real,dstCmp.real, Epsilon)) && glm::all(glm::epsilonEqual(dst2.dual,dstCmp.dual, Epsilon)) ? 0 : 1;
+		Error += glm::all(glm::epsilonEqual(dst3.real,dstCmp.real, Epsilon)) && glm::all(glm::epsilonEqual(dst3.dual,dstCmp.dual, Epsilon)) ? 0 : 1;
+	}
+
+	{
+		glm::dualquat dst1 = src1 / 2.0f;
+		glm::dualquat dst2 = src1;
+		dst2 /= 2.0f;
+		glm::dualquat dstCmp(src_q1 / 2.0f,src_q2 / 2.0f);
+		Error += glm::all(glm::epsilonEqual(dst1.real,dstCmp.real, Epsilon)) && glm::all(glm::epsilonEqual(dst1.dual,dstCmp.dual, Epsilon)) ? 0 : 1;
+		Error += glm::all(glm::epsilonEqual(dst2.real,dstCmp.real, Epsilon)) && glm::all(glm::epsilonEqual(dst2.dual,dstCmp.dual, Epsilon)) ? 0 : 1;
+	}
+	return Error;
+}
+
+int test_inverse() 
+{
+	int Error(0);
+
+	float const Epsilon = 0.0001f;
+
+	glm::dualquat dqid;
+	glm::mat4x4 mid(1.0f);
+
+	for (int j = 0; j < 100; ++j)
+	{
+		glm::mat4x4 rot = glm::yawPitchRoll(myfrand() * 360.0f, myfrand() * 360.0f, myfrand() * 360.0f);
+		glm::vec3 vt = glm::vec3(myfrand() * 10.0f, myfrand() * 10.0f, myfrand() * 10.0f);
+
+		glm::mat4x4 m = glm::translate(mid, vt) * rot;
+
+		glm::quat qr = glm::quat_cast(m);
+
+		glm::dualquat dq(qr);
+
+		glm::dualquat invdq = glm::inverse(dq);
+
+		glm::dualquat r1 = invdq * dq;
+		glm::dualquat r2 = dq * invdq;
+
+		Error += glm::all(glm::epsilonEqual(r1.real, dqid.real, Epsilon)) && glm::all(glm::epsilonEqual(r1.dual, dqid.dual, Epsilon)) ? 0 : 1;
+		Error += glm::all(glm::epsilonEqual(r2.real, dqid.real, Epsilon)) && glm::all(glm::epsilonEqual(r2.dual, dqid.dual, Epsilon)) ? 0 : 1;
+
+		// testing commutative property
+		glm::dualquat r (   glm::quat( myfrand() * glm::pi<float>() * 2.0f, myfrand(), myfrand(), myfrand() ),
+							glm::vec3(myfrand() * 10.0f, myfrand() * 10.0f, myfrand() * 10.0f) );
+		glm::dualquat riq = (r * invdq) * dq;
+		glm::dualquat rqi = (r * dq) * invdq;
+
+		Error += glm::all(glm::epsilonEqual(riq.real, rqi.real, Epsilon)) && glm::all(glm::epsilonEqual(riq.dual, rqi.dual, Epsilon)) ? 0 : 1;
+	}
+
+	return Error;
+}
+
+int test_mul() 
+{
+	int Error(0);
+
+	float const Epsilon = 0.0001f;
+
+	glm::mat4x4 mid(1.0f);
+
+	for (int j = 0; j < 100; ++j)
+	{
+		// generate random rotations and translations and compare transformed by matrix and dualquats random points 
+		glm::vec3 vt1 = glm::vec3(myfrand() * 10.0f, myfrand() * 10.0f, myfrand() * 10.0f);
+		glm::vec3 vt2 = glm::vec3(myfrand() * 10.0f, myfrand() * 10.0f, myfrand() * 10.0f);
+
+		glm::mat4x4 rot1 = glm::yawPitchRoll(myfrand() * 360.0f, myfrand() * 360.0f, myfrand() * 360.0f);
+		glm::mat4x4 rot2 = glm::yawPitchRoll(myfrand() * 360.0f, myfrand() * 360.0f, myfrand() * 360.0f);
+		glm::mat4x4 m1 = glm::translate(mid, vt1) * rot1;
+		glm::mat4x4 m2 = glm::translate(mid, vt2) * rot2;
+		glm::mat4x4 m3 = m2 * m1;
+		glm::mat4x4 m4 = m1 * m2;
+
+		glm::quat qrot1 = glm::quat_cast(rot1);
+		glm::quat qrot2 = glm::quat_cast(rot2);
+
+		glm::dualquat dq1 = glm::dualquat(qrot1,vt1);
+		glm::dualquat dq2 = glm::dualquat(qrot2,vt2);
+		glm::dualquat dq3 = dq2 * dq1;
+		glm::dualquat dq4 = dq1 * dq2;
+
+		for (int i = 0; i < 100; ++i)
+		{
+			glm::vec4 src_pt = glm::vec4(myfrand() * 4.0f, myfrand() * 5.0f, myfrand() * 3.0f,1.0f);
+			// test both multiplication orders        
+			glm::vec4 dst_pt_m3  = m3 * src_pt; 
+			glm::vec4 dst_pt_dq3 = dq3 * src_pt;
+
+			glm::vec4 dst_pt_m3_i  = glm::inverse(m3) * src_pt;
+			glm::vec4 dst_pt_dq3_i = src_pt * dq3;
+
+			glm::vec4 dst_pt_m4  = m4 * src_pt;
+			glm::vec4 dst_pt_dq4 = dq4 * src_pt;
+
+			glm::vec4 dst_pt_m4_i  = glm::inverse(m4) * src_pt;
+			glm::vec4 dst_pt_dq4_i = src_pt * dq4;
+
+			Error += glm::all(glm::epsilonEqual(dst_pt_m3, dst_pt_dq3, Epsilon)) ? 0 : 1;
+			Error += glm::all(glm::epsilonEqual(dst_pt_m4, dst_pt_dq4, Epsilon)) ? 0 : 1;
+			Error += glm::all(glm::epsilonEqual(dst_pt_m3_i, dst_pt_dq3_i, Epsilon)) ? 0 : 1;
+			Error += glm::all(glm::epsilonEqual(dst_pt_m4_i, dst_pt_dq4_i, Epsilon)) ? 0 : 1;
+		}
+	} 
+
+	return Error;
+}
+
+int test_dual_quat_ctr()
+{
+	int Error(0);
+
+#	if GLM_HAS_TRIVIAL_QUERIES
+	//	Error += std::is_trivially_default_constructible<glm::dualquat>::value ? 0 : 1;
+	//	Error += std::is_trivially_default_constructible<glm::ddualquat>::value ? 0 : 1;
+	//	Error += std::is_trivially_copy_assignable<glm::dualquat>::value ? 0 : 1;
+	//	Error += std::is_trivially_copy_assignable<glm::ddualquat>::value ? 0 : 1;
+		Error += std::is_trivially_copyable<glm::dualquat>::value ? 0 : 1;
+		Error += std::is_trivially_copyable<glm::ddualquat>::value ? 0 : 1;
+
+		Error += std::is_copy_constructible<glm::dualquat>::value ? 0 : 1;
+		Error += std::is_copy_constructible<glm::ddualquat>::value ? 0 : 1;
+#	endif
+
+	return Error;
+}
+
+int main()
+{
+	int Error(0);
+
+#ifdef GLM_META_PROG_HELPERS
+		assert(glm::dualquat::components == glm::dualquat().length());
+#endif
+
+	Error += test_dual_quat_ctr();
+	Error += test_dquat_type();
+	Error += test_scalars();
+	Error += test_inverse();
+	Error += test_mul();
+
+	return Error;
+}

external/glm/test/gtx/gtx_euler_angle.cpp

@@ -0,0 +1,359 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2015 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.
+/// 
+/// Restrictions:
+///		By making use of the Software for military purposes, you choose to make
+///		a Bunny unhappy.
+/// 
+/// 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.
+///
+/// @file test/gtx/gtx_euler_angle.cpp
+/// @date 2013-10-25 / 2014-11-25
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+// Code sample from Filippo Ramaciotti
+
+#include <glm/gtc/matrix_transform.hpp>
+#include <glm/gtc/epsilon.hpp>
+#include <glm/gtx/string_cast.hpp>
+#include <glm/gtx/euler_angles.hpp>
+#include <cstdio>
+
+namespace test_eulerAngleX
+{
+	int test()
+	{
+		int Error = 0;
+
+		float const Angle(glm::pi<float>() * 0.5f);
+		glm::vec3 const X(1.0f, 0.0f, 0.0f);
+
+		glm::vec4 const Y(0.0f, 1.0f, 0.0f, 1.0f);
+		glm::vec4 const Y1 = glm::rotate(glm::mat4(1.0f), Angle, X) * Y;
+		glm::vec4 const Y2 = glm::eulerAngleX(Angle) * Y;
+		glm::vec4 const Y3 = glm::eulerAngleXY(Angle, 0.0f) * Y;
+		glm::vec4 const Y4 = glm::eulerAngleYX(0.0f, Angle) * Y;
+		glm::vec4 const Y5 = glm::eulerAngleXZ(Angle, 0.0f) * Y;
+		glm::vec4 const Y6 = glm::eulerAngleZX(0.0f, Angle) * Y;
+		glm::vec4 const Y7 = glm::eulerAngleYXZ(0.0f, Angle, 0.0f) * Y;
+		Error += glm::all(glm::epsilonEqual(Y1, Y2, 0.00001f)) ? 0 : 1;
+		Error += glm::all(glm::epsilonEqual(Y1, Y3, 0.00001f)) ? 0 : 1;
+		Error += glm::all(glm::epsilonEqual(Y1, Y4, 0.00001f)) ? 0 : 1;
+		Error += glm::all(glm::epsilonEqual(Y1, Y5, 0.00001f)) ? 0 : 1;
+		Error += glm::all(glm::epsilonEqual(Y1, Y6, 0.00001f)) ? 0 : 1;
+		Error += glm::all(glm::epsilonEqual(Y1, Y7, 0.00001f)) ? 0 : 1;
+
+		glm::vec4 const Z(0.0f, 0.0f, 1.0f, 1.0f);
+		glm::vec4 const Z1 = glm::rotate(glm::mat4(1.0f), Angle, X) * Z;
+		glm::vec4 const Z2 = glm::eulerAngleX(Angle) * Z;
+		glm::vec4 const Z3 = glm::eulerAngleXY(Angle, 0.0f) * Z;
+		glm::vec4 const Z4 = glm::eulerAngleYX(0.0f, Angle) * Z;
+		glm::vec4 const Z5 = glm::eulerAngleXZ(Angle, 0.0f) * Z;
+		glm::vec4 const Z6 = glm::eulerAngleZX(0.0f, Angle) * Z;
+		glm::vec4 const Z7 = glm::eulerAngleYXZ(0.0f, Angle, 0.0f) * Z;
+		Error += glm::all(glm::epsilonEqual(Z1, Z2, 0.00001f)) ? 0 : 1;
+		Error += glm::all(glm::epsilonEqual(Z1, Z3, 0.00001f)) ? 0 : 1;
+		Error += glm::all(glm::epsilonEqual(Z1, Z4, 0.00001f)) ? 0 : 1;
+		Error += glm::all(glm::epsilonEqual(Z1, Z5, 0.00001f)) ? 0 : 1;
+		Error += glm::all(glm::epsilonEqual(Z1, Z6, 0.00001f)) ? 0 : 1;
+		Error += glm::all(glm::epsilonEqual(Z1, Z7, 0.00001f)) ? 0 : 1;
+
+		return Error;
+	}
+}//namespace test_eulerAngleX
+
+namespace test_eulerAngleY
+{
+	int test()
+	{
+		int Error = 0;
+
+		float const Angle(glm::pi<float>() * 0.5f);
+		glm::vec3 const Y(0.0f, 1.0f, 0.0f);
+
+		glm::vec4 const X(1.0f, 0.0f, 0.0f, 1.0f);
+		glm::vec4 const X1 = glm::rotate(glm::mat4(1.0f), Angle, Y) * X;
+		glm::vec4 const X2 = glm::eulerAngleY(Angle) * X;
+		glm::vec4 const X3 = glm::eulerAngleYX(Angle, 0.0f) * X;
+		glm::vec4 const X4 = glm::eulerAngleXY(0.0f, Angle) * X;
+		glm::vec4 const X5 = glm::eulerAngleYZ(Angle, 0.0f) * X;
+		glm::vec4 const X6 = glm::eulerAngleZY(0.0f, Angle) * X;
+		glm::vec4 const X7 = glm::eulerAngleYXZ(Angle, 0.0f, 0.0f) * X;
+		Error += glm::all(glm::epsilonEqual(X1, X2, 0.00001f)) ? 0 : 1;
+		Error += glm::all(glm::epsilonEqual(X1, X3, 0.00001f)) ? 0 : 1;
+		Error += glm::all(glm::epsilonEqual(X1, X4, 0.00001f)) ? 0 : 1;
+		Error += glm::all(glm::epsilonEqual(X1, X5, 0.00001f)) ? 0 : 1;
+		Error += glm::all(glm::epsilonEqual(X1, X6, 0.00001f)) ? 0 : 1;
+		Error += glm::all(glm::epsilonEqual(X1, X7, 0.00001f)) ? 0 : 1;
+
+		glm::vec4 const Z(0.0f, 0.0f, 1.0f, 1.0f);
+		glm::vec4 const Z1 = glm::eulerAngleY(Angle) * Z;
+		glm::vec4 const Z2 = glm::rotate(glm::mat4(1.0f), Angle, Y) * Z;
+		glm::vec4 const Z3 = glm::eulerAngleYX(Angle, 0.0f) * Z;
+		glm::vec4 const Z4 = glm::eulerAngleXY(0.0f, Angle) * Z;
+		glm::vec4 const Z5 = glm::eulerAngleYZ(Angle, 0.0f) * Z;
+		glm::vec4 const Z6 = glm::eulerAngleZY(0.0f, Angle) * Z;
+		glm::vec4 const Z7 = glm::eulerAngleYXZ(Angle, 0.0f, 0.0f) * Z;
+		Error += glm::all(glm::epsilonEqual(Z1, Z2, 0.00001f)) ? 0 : 1;
+		Error += glm::all(glm::epsilonEqual(Z1, Z3, 0.00001f)) ? 0 : 1;
+		Error += glm::all(glm::epsilonEqual(Z1, Z4, 0.00001f)) ? 0 : 1;
+		Error += glm::all(glm::epsilonEqual(Z1, Z5, 0.00001f)) ? 0 : 1;
+		Error += glm::all(glm::epsilonEqual(Z1, Z6, 0.00001f)) ? 0 : 1;
+		Error += glm::all(glm::epsilonEqual(Z1, Z7, 0.00001f)) ? 0 : 1;
+
+		return Error;
+	}
+}//namespace test_eulerAngleY
+
+namespace test_eulerAngleZ
+{
+	int test()
+	{
+		int Error = 0;
+
+		float const Angle(glm::pi<float>() * 0.5f);
+		glm::vec3 const Z(0.0f, 0.0f, 1.0f);
+
+		glm::vec4 const X(1.0f, 0.0f, 0.0f, 1.0f);
+		glm::vec4 const X1 = glm::rotate(glm::mat4(1.0f), Angle, Z) * X;
+		glm::vec4 const X2 = glm::eulerAngleZ(Angle) * X;
+		glm::vec4 const X3 = glm::eulerAngleZX(Angle, 0.0f) * X;
+		glm::vec4 const X4 = glm::eulerAngleXZ(0.0f, Angle) * X;
+		glm::vec4 const X5 = glm::eulerAngleZY(Angle, 0.0f) * X;
+		glm::vec4 const X6 = glm::eulerAngleYZ(0.0f, Angle) * X;
+		glm::vec4 const X7 = glm::eulerAngleYXZ(0.0f, 0.0f, Angle) * X;
+		Error += glm::all(glm::epsilonEqual(X1, X2, 0.00001f)) ? 0 : 1;
+		Error += glm::all(glm::epsilonEqual(X1, X3, 0.00001f)) ? 0 : 1;
+		Error += glm::all(glm::epsilonEqual(X1, X4, 0.00001f)) ? 0 : 1;
+		Error += glm::all(glm::epsilonEqual(X1, X5, 0.00001f)) ? 0 : 1;
+		Error += glm::all(glm::epsilonEqual(X1, X6, 0.00001f)) ? 0 : 1;
+		Error += glm::all(glm::epsilonEqual(X1, X7, 0.00001f)) ? 0 : 1;
+
+		glm::vec4 const Y(1.0f, 0.0f, 0.0f, 1.0f);
+		glm::vec4 const Z1 = glm::rotate(glm::mat4(1.0f), Angle, Z) * Y;
+		glm::vec4 const Z2 = glm::eulerAngleZ(Angle) * Y;
+		glm::vec4 const Z3 = glm::eulerAngleZX(Angle, 0.0f) * Y;
+		glm::vec4 const Z4 = glm::eulerAngleXZ(0.0f, Angle) * Y;
+		glm::vec4 const Z5 = glm::eulerAngleZY(Angle, 0.0f) * Y;
+		glm::vec4 const Z6 = glm::eulerAngleYZ(0.0f, Angle) * Y;
+		glm::vec4 const Z7 = glm::eulerAngleYXZ(0.0f, 0.0f, Angle) * Y;
+		Error += glm::all(glm::epsilonEqual(Z1, Z2, 0.00001f)) ? 0 : 1;
+		Error += glm::all(glm::epsilonEqual(Z1, Z3, 0.00001f)) ? 0 : 1;
+		Error += glm::all(glm::epsilonEqual(Z1, Z4, 0.00001f)) ? 0 : 1;
+		Error += glm::all(glm::epsilonEqual(Z1, Z5, 0.00001f)) ? 0 : 1;
+		Error += glm::all(glm::epsilonEqual(Z1, Z6, 0.00001f)) ? 0 : 1;
+		Error += glm::all(glm::epsilonEqual(Z1, Z7, 0.00001f)) ? 0 : 1;
+
+		return Error;
+	}
+}//namespace test_eulerAngleZ
+
+namespace test_eulerAngleXY
+{
+	int test()
+	{
+		int Error = 0;
+
+		glm::vec4 const V(1.0f);
+
+		float const AngleX(glm::pi<float>() * 0.5f);
+		float const AngleY(glm::pi<float>() * 0.25f);
+
+		glm::vec3 const axisX(1.0f, 0.0f, 0.0f);
+		glm::vec3 const axisY(0.0f, 1.0f, 0.0f);
+
+		glm::vec4 const V1 = (glm::rotate(glm::mat4(1.0f), AngleX, axisX) * glm::rotate(glm::mat4(1.0f), AngleY, axisY)) * V;
+		glm::vec4 const V2 = glm::eulerAngleXY(AngleX, AngleY) * V;
+		glm::vec4 const V3 = glm::eulerAngleX(AngleX) * glm::eulerAngleY(AngleY) * V;
+		Error += glm::all(glm::epsilonEqual(V1, V2, 0.00001f)) ? 0 : 1;
+		Error += glm::all(glm::epsilonEqual(V1, V3, 0.00001f)) ? 0 : 1;
+
+		return Error;
+	}
+}//namespace test_eulerAngleXY
+
+namespace test_eulerAngleYX
+{
+	int test()
+	{
+		int Error = 0;
+
+		glm::vec4 const V(1.0f);
+
+		float const AngleX(glm::pi<float>() * 0.5f);
+		float const AngleY(glm::pi<float>() * 0.25f);
+
+		glm::vec3 const axisX(1.0f, 0.0f, 0.0f);
+		glm::vec3 const axisY(0.0f, 1.0f, 0.0f);
+
+		glm::vec4 const V1 = (glm::rotate(glm::mat4(1.0f), AngleY, axisY) * glm::rotate(glm::mat4(1.0f), AngleX, axisX)) * V;
+		glm::vec4 const V2 = glm::eulerAngleYX(AngleY, AngleX) * V;
+		glm::vec4 const V3 = glm::eulerAngleY(AngleY) * glm::eulerAngleX(AngleX) * V;
+		Error += glm::all(glm::epsilonEqual(V1, V2, 0.00001f)) ? 0 : 1;
+		Error += glm::all(glm::epsilonEqual(V1, V3, 0.00001f)) ? 0 : 1;
+
+		return Error;
+	}
+}//namespace test_eulerAngleYX
+
+namespace test_eulerAngleXZ
+{
+	int test()
+	{
+		int Error = 0;
+
+		glm::vec4 const V(1.0f);
+
+		float const AngleX(glm::pi<float>() * 0.5f);
+		float const AngleZ(glm::pi<float>() * 0.25f);
+
+		glm::vec3 const axisX(1.0f, 0.0f, 0.0f);
+		glm::vec3 const axisZ(0.0f, 0.0f, 1.0f);
+
+		glm::vec4 const V1 = (glm::rotate(glm::mat4(1.0f), AngleX, axisX) * glm::rotate(glm::mat4(1.0f), AngleZ, axisZ)) * V;
+		glm::vec4 const V2 = glm::eulerAngleXZ(AngleX, AngleZ) * V;
+		glm::vec4 const V3 = glm::eulerAngleX(AngleX) * glm::eulerAngleZ(AngleZ) * V;
+		Error += glm::all(glm::epsilonEqual(V1, V2, 0.00001f)) ? 0 : 1;
+		Error += glm::all(glm::epsilonEqual(V1, V3, 0.00001f)) ? 0 : 1;
+
+		return Error;
+	}
+}//namespace test_eulerAngleXZ
+
+namespace test_eulerAngleZX
+{
+	int test()
+	{
+		int Error = 0;
+
+		glm::vec4 const V(1.0f);
+
+		float const AngleX(glm::pi<float>() * 0.5f);
+		float const AngleZ(glm::pi<float>() * 0.25f);
+
+		glm::vec3 const axisX(1.0f, 0.0f, 0.0f);
+		glm::vec3 const axisZ(0.0f, 0.0f, 1.0f);
+
+		glm::vec4 const V1 = (glm::rotate(glm::mat4(1.0f), AngleZ, axisZ) * glm::rotate(glm::mat4(1.0f), AngleX, axisX)) * V;
+		glm::vec4 const V2 = glm::eulerAngleZX(AngleZ, AngleX) * V;
+		glm::vec4 const V3 = glm::eulerAngleZ(AngleZ) * glm::eulerAngleX(AngleX) * V;
+		Error += glm::all(glm::epsilonEqual(V1, V2, 0.00001f)) ? 0 : 1;
+		Error += glm::all(glm::epsilonEqual(V1, V3, 0.00001f)) ? 0 : 1;
+
+		return Error;
+	}
+}//namespace test_eulerAngleZX
+
+namespace test_eulerAngleYZ
+{
+	int test()
+	{
+		int Error = 0;
+
+		glm::vec4 const V(1.0f);
+
+		float const AngleY(glm::pi<float>() * 0.5f);
+		float const AngleZ(glm::pi<float>() * 0.25f);
+
+		glm::vec3 const axisX(1.0f, 0.0f, 0.0f);
+		glm::vec3 const axisY(0.0f, 1.0f, 0.0f);
+		glm::vec3 const axisZ(0.0f, 0.0f, 1.0f);
+
+		glm::vec4 const V1 = (glm::rotate(glm::mat4(1.0f), AngleY, axisY) * glm::rotate(glm::mat4(1.0f), AngleZ, axisZ)) * V;
+		glm::vec4 const V2 = glm::eulerAngleYZ(AngleY, AngleZ) * V;
+		glm::vec4 const V3 = glm::eulerAngleY(AngleY) * glm::eulerAngleZ(AngleZ) * V;
+		Error += glm::all(glm::epsilonEqual(V1, V2, 0.00001f)) ? 0 : 1;
+		Error += glm::all(glm::epsilonEqual(V1, V3, 0.00001f)) ? 0 : 1;
+
+		return Error;
+	}
+}//namespace test_eulerAngleYZ
+
+namespace test_eulerAngleZY
+{
+	int test()
+	{
+		int Error = 0;
+
+		glm::vec4 const V(1.0f);
+
+		float const AngleY(glm::pi<float>() * 0.5f);
+		float const AngleZ(glm::pi<float>() * 0.25f);
+
+		glm::vec3 const axisX(1.0f, 0.0f, 0.0f);
+		glm::vec3 const axisY(0.0f, 1.0f, 0.0f);
+		glm::vec3 const axisZ(0.0f, 0.0f, 1.0f);
+
+		glm::vec4 const V1 = (glm::rotate(glm::mat4(1.0f), AngleZ, axisZ) * glm::rotate(glm::mat4(1.0f), AngleY, axisY)) * V;
+		glm::vec4 const V2 = glm::eulerAngleZY(AngleZ, AngleY) * V;
+		glm::vec4 const V3 = glm::eulerAngleZ(AngleZ) * glm::eulerAngleY(AngleY) * V;
+		Error += glm::all(glm::epsilonEqual(V1, V2, 0.00001f)) ? 0 : 1;
+		Error += glm::all(glm::epsilonEqual(V1, V3, 0.00001f)) ? 0 : 1;
+
+		return Error;
+	}
+}//namespace test_eulerAngleZY
+
+namespace test_eulerAngleYXZ
+{
+	int test()
+	{
+		glm::f32 first =  1.046f;
+		glm::f32 second = 0.52f;
+		glm::f32 third = -0.785f;
+
+		glm::fmat4 rotationEuler = glm::eulerAngleYXZ(first, second, third); 
+
+		glm::fmat4 rotationInvertedY  = glm::eulerAngleY(-1.f*first) * glm::eulerAngleX(second) * glm::eulerAngleZ(third); 
+		glm::fmat4 rotationDumb = glm::fmat4(); 
+		rotationDumb = glm::rotate(rotationDumb, first, glm::fvec3(0,1,0));
+		rotationDumb = glm::rotate(rotationDumb, second, glm::fvec3(1,0,0));
+		rotationDumb = glm::rotate(rotationDumb, third, glm::fvec3(0,0,1));
+
+		std::printf("%s\n", glm::to_string(glm::fmat3(rotationEuler)).c_str());
+		std::printf("%s\n", glm::to_string(glm::fmat3(rotationDumb)).c_str());
+		std::printf("%s\n", glm::to_string(glm::fmat3(rotationInvertedY)).c_str());
+
+		std::printf("\nRESIDUAL\n");
+		std::printf("%s\n", glm::to_string(glm::fmat3(rotationEuler-(rotationDumb))).c_str());
+		std::printf("%s\n", glm::to_string(glm::fmat3(rotationEuler-(rotationInvertedY))).c_str());
+
+		return 0;
+	}
+}//namespace eulerAngleYXZ
+
+int main()
+{ 
+	int Error = 0;
+
+	Error += test_eulerAngleX::test();
+	Error += test_eulerAngleY::test();
+	Error += test_eulerAngleZ::test();
+	Error += test_eulerAngleXY::test();
+	Error += test_eulerAngleYX::test();
+	Error += test_eulerAngleXZ::test();
+	Error += test_eulerAngleZX::test();
+	Error += test_eulerAngleYZ::test();
+	Error += test_eulerAngleZY::test();
+	Error += test_eulerAngleYXZ::test();
+
+	return Error; 
+}

external/glm/test/gtx/gtx_extend.cpp

@@ -0,0 +1,39 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2015 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.
+/// 
+/// Restrictions:
+///		By making use of the Software for military purposes, you choose to make
+///		a Bunny unhappy.
+/// 
+/// 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.
+///
+/// @file test/gtx/gtx_extend.cpp
+/// @date 2013-10-25 / 2014-11-25
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#include <glm/gtx/extend.hpp>
+
+int main()
+{
+	int Error(0);
+
+	return Error;
+}

external/glm/test/gtx/gtx_extented_min_max.cpp

@@ -0,0 +1,39 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2015 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.
+/// 
+/// Restrictions:
+///		By making use of the Software for military purposes, you choose to make
+///		a Bunny unhappy.
+/// 
+/// 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.
+///
+/// @file test/gtx/gtx_extented_min_max.cpp
+/// @date 2013-10-25 / 2014-11-25
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#include <glm/gtx/extented_min_max.hpp>
+
+int main()
+{
+	int Error(0);
+
+	return Error;
+}

external/glm/test/gtx/gtx_fast_exponential.cpp

@@ -0,0 +1,39 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2015 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.
+/// 
+/// Restrictions:
+///		By making use of the Software for military purposes, you choose to make
+///		a Bunny unhappy.
+/// 
+/// 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.
+///
+/// @file test/gtx/gtx_fast_exponential.cpp
+/// @date 2013-10-25 / 2014-11-25
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#include <glm/gtx/fast_exponential.hpp>
+
+int main()
+{
+	int Error(0);
+
+	return Error;
+}

external/glm/test/gtx/gtx_fast_square_root.cpp

@@ -0,0 +1,76 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2015 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.
+/// 
+/// Restrictions:
+///		By making use of the Software for military purposes, you choose to make
+///		a Bunny unhappy.
+/// 
+/// 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.
+///
+/// @file test/gtx/gtx_fast_square_root.cpp
+/// @date 2013-10-25 / 2014-11-25
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#include <glm/gtx/fast_square_root.hpp>
+#include <glm/gtc/type_precision.hpp>
+#include <glm/gtc/epsilon.hpp>
+#include <glm/vector_relational.hpp>
+
+int test_fastInverseSqrt()
+{
+	int Error(0);
+
+	Error += glm::epsilonEqual(glm::fastInverseSqrt(1.0f), 1.0f, 0.01f) ? 0 : 1;
+	Error += glm::epsilonEqual(glm::fastInverseSqrt(1.0), 1.0, 0.01) ? 0 : 1;
+	Error += glm::all(glm::epsilonEqual(glm::fastInverseSqrt(glm::vec2(1.0f)), glm::vec2(1.0f), 0.01f)) ? 0 : 1;
+	Error += glm::all(glm::epsilonEqual(glm::fastInverseSqrt(glm::dvec3(1.0)), glm::dvec3(1.0), 0.01)) ? 0 : 1;
+	Error += glm::all(glm::epsilonEqual(glm::fastInverseSqrt(glm::dvec4(1.0)), glm::dvec4(1.0), 0.01)) ? 0 : 1;
+
+	
+	return 0;
+}
+
+int test_fastDistance()
+{
+	int Error(0);
+
+	glm::mediump_f32 A = glm::fastDistance(glm::mediump_f32(0.0f), glm::mediump_f32(1.0f));
+	glm::mediump_f32 B = glm::fastDistance(glm::mediump_f32vec2(0.0f), glm::mediump_f32vec2(1.0f, 0.0f));
+	glm::mediump_f32 C = glm::fastDistance(glm::mediump_f32vec3(0.0f), glm::mediump_f32vec3(1.0f, 0.0f, 0.0f));
+	glm::mediump_f32 D = glm::fastDistance(glm::mediump_f32vec4(0.0f), glm::mediump_f32vec4(1.0f, 0.0f, 0.0f, 0.0f));
+
+	Error += glm::epsilonEqual(A, glm::mediump_f32(1.0f), glm::mediump_f32(0.01f)) ? 0 : 1;
+	Error += glm::epsilonEqual(B, glm::mediump_f32(1.0f), glm::mediump_f32(0.01f)) ? 0 : 1;
+	Error += glm::epsilonEqual(C, glm::mediump_f32(1.0f), glm::mediump_f32(0.01f)) ? 0 : 1;
+	Error += glm::epsilonEqual(D, glm::mediump_f32(1.0f), glm::mediump_f32(0.01f)) ? 0 : 1;
+
+	return Error;
+}
+
+int main()
+{
+	int Error(0);
+
+	Error += test_fastInverseSqrt();
+	Error += test_fastDistance();
+
+	return Error;
+}

external/glm/test/gtx/gtx_fast_trigonometry.cpp

@@ -0,0 +1,476 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2015 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.
+/// 
+/// Restrictions:
+///		By making use of the Software for military purposes, you choose to make
+///		a Bunny unhappy.
+/// 
+/// 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.
+///
+/// @file test/gtx/gtx_fast_trigonometry.cpp
+/// @date 2013-10-25 / 2014-11-25
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#include <glm/gtc/type_precision.hpp>
+#include <glm/gtx/fast_trigonometry.hpp>
+#include <glm/gtx/integer.hpp>
+#include <glm/gtx/common.hpp>
+#include <glm/gtc/constants.hpp>
+#include <glm/gtc/ulp.hpp>
+#include <glm/gtc/vec1.hpp>
+#include <glm/trigonometric.hpp>
+#include <cmath>
+#include <ctime>
+#include <cstdio>
+#include <vector>
+
+namespace fastCos
+{
+	int perf(bool NextFloat)
+	{
+		const float begin = -glm::pi<float>();
+		const float end = glm::pi<float>();
+		float result = 0.f;
+
+		const std::clock_t timestamp1 = std::clock();
+		for(float i = begin; i < end; i = NextFloat ? glm::next_float(i) : i += 0.1f)
+			result = glm::fastCos(i);
+
+		const std::clock_t timestamp2 = std::clock();
+		for(float i = begin; i < end; i = NextFloat ? glm::next_float(i) : i += 0.1f)
+			result = glm::cos(i);
+
+		const std::clock_t timestamp3 = std::clock();
+		const std::clock_t time_fast = timestamp2 - timestamp1;
+		const std::clock_t time_default = timestamp3 - timestamp2;
+		std::printf("fastCos Time %d clocks\n", static_cast<unsigned int>(time_fast));
+		std::printf("cos Time %d clocks\n", static_cast<unsigned int>(time_default));
+
+		return time_fast <= time_default ? 0 : 1;
+	}
+}//namespace fastCos
+
+namespace fastSin
+{
+	/*
+	float sin(float x) {
+	float temp;
+	temp = (x + M_PI) / ((2 * M_PI) - M_PI);
+	return limited_sin((x + M_PI) - ((2 * M_PI) - M_PI) * temp));
+	}
+	*/
+
+	int perf(bool NextFloat)
+	{
+		const float begin = -glm::pi<float>();
+		const float end = glm::pi<float>();
+		float result = 0.f;
+
+		const std::clock_t timestamp1 = std::clock();
+		for(float i = begin; i < end; i = NextFloat ? glm::next_float(i) : i += 0.1f)
+			result = glm::fastSin(i);
+
+		const std::clock_t timestamp2 = std::clock();
+		for(float i = begin; i < end; i = NextFloat ? glm::next_float(i) : i += 0.1f)
+			result = glm::sin(i);
+
+		const std::clock_t timestamp3 = std::clock();
+		const std::clock_t time_fast = timestamp2 - timestamp1;
+		const std::clock_t time_default = timestamp3 - timestamp2;
+		std::printf("fastSin Time %d clocks\n", static_cast<unsigned int>(time_fast));
+		std::printf("sin Time %d clocks\n", static_cast<unsigned int>(time_default));
+
+		return time_fast <= time_default ? 0 : 1;
+	}
+}//namespace fastSin
+
+namespace fastTan
+{
+	int perf(bool NextFloat)
+	{
+		const float begin = -glm::pi<float>();
+		const float end = glm::pi<float>();
+		float result = 0.f;
+
+		const std::clock_t timestamp1 = std::clock();
+		for(float i = begin; i < end; i = NextFloat ? glm::next_float(i) : i += 0.1f)
+			result = glm::fastTan(i);
+
+		const std::clock_t timestamp2 = std::clock();
+		for (float i = begin; i < end; i = NextFloat ? glm::next_float(i) : i += 0.1f)
+			result = glm::tan(i);
+
+		const std::clock_t timestamp3 = std::clock();
+		const std::clock_t time_fast = timestamp2 - timestamp1;
+		const std::clock_t time_default = timestamp3 - timestamp2;
+		std::printf("fastTan Time %d clocks\n", static_cast<unsigned int>(time_fast));
+		std::printf("tan Time %d clocks\n", static_cast<unsigned int>(time_default));
+
+		return time_fast <= time_default ? 0 : 1;
+	}
+}//namespace fastTan
+
+namespace fastAcos
+{
+	int perf(bool NextFloat)
+	{
+		const float begin = -glm::pi<float>();
+		const float end = glm::pi<float>();
+		float result = 0.f;
+
+		const std::clock_t timestamp1 = std::clock();
+		for(float i = begin; i < end; i = NextFloat ? glm::next_float(i) : i += 0.1f)
+			result = glm::fastAcos(i);
+
+		const std::clock_t timestamp2 = std::clock();
+		for(float i = begin; i < end; i = NextFloat ? glm::next_float(i) : i += 0.1f)
+			result = glm::acos(i);
+
+		const std::clock_t timestamp3 = std::clock();
+		const std::clock_t time_fast = timestamp2 - timestamp1;
+		const std::clock_t time_default = timestamp3 - timestamp2;
+
+		std::printf("fastAcos Time %d clocks\n", static_cast<unsigned int>(time_fast));
+		std::printf("acos Time %d clocks\n", static_cast<unsigned int>(time_default));
+
+		return time_fast <= time_default ? 0 : 1;
+	}
+}//namespace fastAcos
+
+namespace fastAsin
+{
+	int perf(bool NextFloat)
+	{
+		const float begin = -glm::pi<float>();
+		const float end = glm::pi<float>();
+		float result = 0.f;
+		const std::clock_t timestamp1 = std::clock();
+		for(float i = begin; i < end; i = NextFloat ? glm::next_float(i) : i += 0.1f)
+			result = glm::fastAsin(i);
+		const std::clock_t timestamp2 = std::clock();
+		for(float i = begin; i < end; i = NextFloat ? glm::next_float(i) : i += 0.1f)
+			result = glm::asin(i);
+		const std::clock_t timestamp3 = std::clock();
+		const std::clock_t time_fast = timestamp2 - timestamp1;
+		const std::clock_t time_default = timestamp3 - timestamp2;
+		std::printf("fastAsin Time %d clocks\n", static_cast<unsigned int>(time_fast));
+		std::printf("asin Time %d clocks\n", static_cast<unsigned int>(time_default));
+
+		return time_fast <= time_default ? 0 : 1;
+	}
+}//namespace fastAsin
+
+namespace fastAtan
+{
+	int perf(bool NextFloat)
+	{
+		const float begin = -glm::pi<float>();
+		const float end = glm::pi<float>();
+		float result = 0.f;
+		const std::clock_t timestamp1 = std::clock();
+		for(float i = begin; i < end; i = NextFloat ? glm::next_float(i) : i += 0.1f)
+			result = glm::fastAtan(i);
+		const std::clock_t timestamp2 = std::clock();
+		for(float i = begin; i < end; i = NextFloat ? glm::next_float(i) : i += 0.1f)
+			result = glm::atan(i);
+		const std::clock_t timestamp3 = std::clock();
+		const std::clock_t time_fast = timestamp2 - timestamp1;
+		const std::clock_t time_default = timestamp3 - timestamp2;
+		std::printf("fastAtan Time %d clocks\n", static_cast<unsigned int>(time_fast));
+		std::printf("atan Time %d clocks\n", static_cast<unsigned int>(time_default));
+
+		return time_fast <= time_default ? 0 : 1;
+	}
+}//namespace fastAtan
+
+namespace taylorCos
+{
+	glm::vec4 const AngleShift(0.0f, glm::pi<float>() * 0.5f, glm::pi<float>() * 1.0f, glm::pi<float>() * 1.5f);
+
+	template <typename T, glm::precision P, template <typename, glm::precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> taylorSeriesNewCos(vecType<T, P> const & x)
+	{
+		vecType<T, P> const Powed2(x * x);
+		vecType<T, P> const Powed4(Powed2 * Powed2);
+		vecType<T, P> const Powed6(Powed4 * Powed2);
+		vecType<T, P> const Powed8(Powed4 * Powed4);
+
+		return static_cast<T>(1)
+			- Powed2 * static_cast<T>(0.5)
+			+ Powed4 * static_cast<T>(0.04166666666666666666666666666667)
+			- Powed6 * static_cast<T>(0.00138888888888888888888888888889)
+			+ Powed8 * static_cast<T>(2.4801587301587301587301587301587e-5);
+	}
+
+	template <typename T, glm::precision P, template <typename, glm::precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> taylorSeriesNewCos6(vecType<T, P> const & x)
+	{
+		vecType<T, P> const Powed2(x * x);
+		vecType<T, P> const Powed4(Powed2 * Powed2);
+		vecType<T, P> const Powed6(Powed4 * Powed2);
+
+		return static_cast<T>(1)
+			- Powed2 * static_cast<T>(0.5)
+			+ Powed4 * static_cast<T>(0.04166666666666666666666666666667)
+			- Powed6 * static_cast<T>(0.00138888888888888888888888888889);
+	}
+
+	template <glm::precision P, template <typename, glm::precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<float, P> fastAbs(vecType<float, P> x)
+	{
+		int* Pointer = reinterpret_cast<int*>(&x[0]);
+		Pointer[0] &= 0x7fffffff;
+		Pointer[1] &= 0x7fffffff;
+		Pointer[2] &= 0x7fffffff;
+		Pointer[3] &= 0x7fffffff;
+		return x;
+	}
+
+	template <typename T, glm::precision P, template <typename, glm::precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> fastCosNew(vecType<T, P> const & x)
+	{
+		vecType<T, P> const Angle0_PI(fastAbs(fmod(x + glm::pi<T>(), glm::two_pi<T>()) - glm::pi<T>()));
+		return taylorSeriesNewCos6(x);
+/*
+		vecType<bool, P> const FirstQuarterPi(lessThanEqual(Angle0_PI, vecType<T, P>(glm::half_pi<T>())));
+
+		vecType<T, P> const RevertAngle(mix(vecType<T, P>(glm::pi<T>()), vecType<T, P>(0), FirstQuarterPi));
+		vecType<T, P> const ReturnSign(mix(vecType<T, P>(-1), vecType<T, P>(1), FirstQuarterPi));
+		vecType<T, P> const SectionAngle(RevertAngle - Angle0_PI);
+
+		return ReturnSign * taylorSeriesNewCos(SectionAngle);
+*/
+	}
+
+	int perf_fastCosNew(float Begin, float End, std::size_t Samples)
+	{
+		std::vector<glm::vec4> Results;
+		Results.resize(Samples);
+
+		float Steps = (End - Begin) / Samples;
+
+		std::clock_t const TimeStampBegin = std::clock();
+
+		for(std::size_t i = 0; i < Samples; ++i)
+			Results[i] = fastCosNew(AngleShift + glm::vec4(Begin + Steps * i));
+
+		std::clock_t const TimeStampEnd = std::clock();
+
+		std::printf("fastCosNew %ld clocks\n", TimeStampEnd - TimeStampBegin);
+
+		int Error = 0;
+		for(std::size_t i = 0; i < Samples; ++i)
+			Error += Results[i].x >= -1.0f && Results[i].x <= 1.0f ? 0 : 1;
+		return Error;
+	}
+
+	template <typename T, glm::precision P, template <typename, glm::precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> deterministic_fmod(vecType<T, P> const & x, T y)
+	{
+		return x - y * trunc(x / y);
+	}
+
+	template <typename T, glm::precision P, template <typename, glm::precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> fastCosDeterminisctic(vecType<T, P> const & x)
+	{
+		vecType<T, P> const Angle0_PI(abs(deterministic_fmod(x + glm::pi<T>(), glm::two_pi<T>()) - glm::pi<T>()));
+		vecType<bool, P> const FirstQuarterPi(lessThanEqual(Angle0_PI, vecType<T, P>(glm::half_pi<T>())));
+
+		vecType<T, P> const RevertAngle(mix(vecType<T, P>(glm::pi<T>()), vecType<T, P>(0), FirstQuarterPi));
+		vecType<T, P> const ReturnSign(mix(vecType<T, P>(-1), vecType<T, P>(1), FirstQuarterPi));
+		vecType<T, P> const SectionAngle(RevertAngle - Angle0_PI);
+
+		return ReturnSign * taylorSeriesNewCos(SectionAngle);
+	}
+
+	int perf_fastCosDeterminisctic(float Begin, float End, std::size_t Samples)
+	{
+		std::vector<glm::vec4> Results;
+		Results.resize(Samples);
+
+		float Steps = (End - Begin) / Samples;
+
+		std::clock_t const TimeStampBegin = std::clock();
+
+		for(std::size_t i = 0; i < Samples; ++i)
+			Results[i] = taylorCos::fastCosDeterminisctic(AngleShift + glm::vec4(Begin + Steps * i));
+
+		std::clock_t const TimeStampEnd = std::clock();
+
+		std::printf("fastCosDeterminisctic %ld clocks\n", TimeStampEnd - TimeStampBegin);
+
+		int Error = 0;
+		for(std::size_t i = 0; i < Samples; ++i)
+			Error += Results[i].x >= -1.0f && Results[i].x <= 1.0f ? 0 : 1;
+		return Error;
+	}
+
+	template <typename T, glm::precision P, template <typename, glm::precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> taylorSeriesRefCos(vecType<T, P> const & x)
+	{
+		return static_cast<T>(1)
+			- (x * x) / glm::factorial(static_cast<T>(2))
+			+ (x * x * x * x) / glm::factorial(static_cast<T>(4))
+			- (x * x * x * x * x * x) / glm::factorial(static_cast<T>(6))
+			+ (x * x * x * x * x * x * x * x) / glm::factorial(static_cast<T>(8));
+	}
+
+	template <typename T, glm::precision P, template <typename, glm::precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> fastRefCos(vecType<T, P> const & x)
+	{
+		vecType<T, P> const Angle0_PI(glm::abs(fmod(x + glm::pi<T>(), glm::two_pi<T>()) - glm::pi<T>()));
+//		return taylorSeriesRefCos(Angle0_PI);
+
+		vecType<bool, P> const FirstQuarterPi(lessThanEqual(Angle0_PI, vecType<T, P>(glm::half_pi<T>())));
+
+		vecType<T, P> const RevertAngle(mix(vecType<T, P>(glm::pi<T>()), vecType<T, P>(0), FirstQuarterPi));
+		vecType<T, P> const ReturnSign(mix(vecType<T, P>(-1), vecType<T, P>(1), FirstQuarterPi));
+		vecType<T, P> const SectionAngle(RevertAngle - Angle0_PI);
+
+		return ReturnSign * taylorSeriesRefCos(SectionAngle);
+	}
+
+	int perf_fastCosRef(float Begin, float End, std::size_t Samples)
+	{
+		std::vector<glm::vec4> Results;
+		Results.resize(Samples);
+
+		float Steps = (End - Begin) / Samples;
+
+		std::clock_t const TimeStampBegin = std::clock();
+
+		for(std::size_t i = 0; i < Samples; ++i)
+			Results[i] = taylorCos::fastRefCos(AngleShift + glm::vec4(Begin + Steps * i));
+
+		std::clock_t const TimeStampEnd = std::clock();
+
+		std::printf("fastCosRef %ld clocks\n", TimeStampEnd - TimeStampBegin);
+
+		int Error = 0;
+		for(std::size_t i = 0; i < Samples; ++i)
+			Error += Results[i].x >= -1.0f && Results[i].x <= 1.0f ? 0 : 1;
+		return Error;
+	}
+
+	int perf_fastCosOld(float Begin, float End, std::size_t Samples)
+	{
+		std::vector<glm::vec4> Results;
+		Results.resize(Samples);
+
+		float Steps = (End - Begin) / Samples;
+
+		std::clock_t const TimeStampBegin = std::clock();
+
+		for(std::size_t i = 0; i < Samples; ++i)
+			Results[i] = glm::fastCos(AngleShift + glm::vec4(Begin + Steps * i));
+
+		std::clock_t const TimeStampEnd = std::clock();
+
+		std::printf("fastCosOld %ld clocks\n", TimeStampEnd - TimeStampBegin);
+
+		int Error = 0;
+		for(std::size_t i = 0; i < Samples; ++i)
+			Error += Results[i].x >= -1.0f && Results[i].x <= 1.0f ? 0 : 1;
+		return Error;
+	}
+
+	int perf_cos(float Begin, float End, std::size_t Samples)
+	{
+		std::vector<glm::vec4> Results;
+		Results.resize(Samples);
+
+		float Steps = (End - Begin) / Samples;
+
+		std::clock_t const TimeStampBegin = std::clock();
+
+		for(std::size_t i = 0; i < Samples; ++i)
+			Results[i] = glm::cos(AngleShift + glm::vec4(Begin + Steps * i));
+
+		std::clock_t const TimeStampEnd = std::clock();
+
+		std::printf("cos %ld clocks\n", TimeStampEnd - TimeStampBegin);
+
+		int Error = 0;
+		for(std::size_t i = 0; i < Samples; ++i)
+			Error += Results[i].x >= -1.0f && Results[i].x <= 1.0f ? 0 : 1;
+		return Error;
+	}
+
+	int perf(std::size_t const Samples)
+	{
+		int Error = 0;
+
+		float const Begin = -glm::pi<float>();
+		float const End = glm::pi<float>();
+
+		Error += perf_cos(Begin, End, Samples);
+		Error += perf_fastCosOld(Begin, End, Samples);
+		Error += perf_fastCosRef(Begin, End, Samples);
+		//Error += perf_fastCosNew(Begin, End, Samples);
+		Error += perf_fastCosDeterminisctic(Begin, End, Samples);
+
+		return Error;
+	}
+
+	int test()
+	{
+		int Error = 0;
+
+		//for(float Angle = -4.0f * glm::pi<float>(); Angle < 4.0f * glm::pi<float>(); Angle += 0.1f)
+		//for(float Angle = -720.0f; Angle < 720.0f; Angle += 0.1f)
+		for(float Angle = 0.0f; Angle < 180.0f; Angle += 0.1f)
+		{
+			float const modAngle = std::fmod(glm::abs(Angle), 360.f);
+			assert(modAngle >= 0.0f && modAngle <= 360.f);
+			float const radAngle = glm::radians(modAngle);
+			float const Cos0 = std::cos(radAngle);
+
+			float const Cos1 = taylorCos::fastRefCos(glm::fvec1(radAngle)).x;
+			Error += glm::abs(Cos1 - Cos0) < 0.1f ? 0 : 1;
+
+			float const Cos2 = taylorCos::fastCosNew(glm::fvec1(radAngle)).x;
+			//Error += glm::abs(Cos2 - Cos0) < 0.1f ? 0 : 1;
+
+			assert(!Error);
+		}
+
+		return Error;
+	}
+}//namespace taylorCos
+
+int main()
+{
+	int Error(0);
+
+	Error += ::taylorCos::test();
+	Error += ::taylorCos::perf(1000);
+
+#	ifdef NDEBUG
+		::fastCos::perf(false);
+		::fastSin::perf(false);
+		::fastTan::perf(false);
+		::fastAcos::perf(false);
+		::fastAsin::perf(false);
+		::fastAtan::perf(false);
+#	endif//NDEBUG
+
+	return Error;
+}

external/glm/test/gtx/gtx_gradient_paint.cpp

@@ -0,0 +1,64 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2015 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.
+/// 
+/// Restrictions:
+///		By making use of the Software for military purposes, you choose to make
+///		a Bunny unhappy.
+/// 
+/// 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.
+///
+/// @file test/gtx/gtx_gradient_paint.cpp
+/// @date 2011-10-13 / 2014-11-25
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#include <glm/gtx/gradient_paint.hpp>
+
+int test_radialGradient()
+{
+	int Error = 0;
+	
+	float Gradient = glm::radialGradient(glm::vec2(0), 1.0f, glm::vec2(1), glm::vec2(0.5));
+	Error += Gradient != 0.0f ? 0 : 1;
+	
+	return Error;
+}
+
+int test_linearGradient()
+{
+	int Error = 0;
+
+	float Gradient = glm::linearGradient(glm::vec2(0), glm::vec2(1), glm::vec2(0.5));
+	Error += Gradient != 0.0f ? 0 : 1;
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+    Error += test_radialGradient();
+    Error += test_linearGradient();
+    
+	return Error;
+}
+
+

external/glm/test/gtx/gtx_handed_coordinate_space.cpp

@@ -0,0 +1,39 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2015 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.
+/// 
+/// Restrictions:
+///		By making use of the Software for military purposes, you choose to make
+///		a Bunny unhappy.
+/// 
+/// 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.
+///
+/// @file test/gtx/gtx_handed_coordinate_space.cpp
+/// @date 2011-10-13 / 2014-11-25
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#include <glm/gtx/handed_coordinate_space.hpp>
+
+int main()
+{
+	int Error(0);
+
+	return Error;
+}

external/glm/test/gtx/gtx_int_10_10_10_2.cpp

@@ -0,0 +1,18 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// 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/gtc/type_precision.hpp>
+#include <glm/gtx/associated_min_max.hpp>
+
+int main()
+{
+	int Error(0);
+
+	return Error;
+}

external/glm/test/gtx/gtx_integer.cpp

@@ -0,0 +1,95 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2015 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.
+/// 
+/// Restrictions:
+///		By making use of the Software for military purposes, you choose to make
+///		a Bunny unhappy.
+/// 
+/// 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.
+///
+/// @file test/gtx/gtx_integer.cpp
+/// @date 2011-10-11 / 2014-11-25
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#include <glm/exponential.hpp>
+#include <glm/gtc/epsilon.hpp>
+#include <glm/gtx/integer.hpp>
+#include <cstdio>
+/*
+int test_floor_log2()
+{
+	int Error = 0;
+
+	for(std::size_t i = 1; i < 1000000; ++i)
+	{
+		glm::uint A = glm::floor_log2(glm::uint(i));
+		glm::uint B = glm::uint(glm::floor(glm::log2(double(i)))); // Will fail with float, lack of accuracy
+
+		Error += A == B ? 0 : 1;
+		assert(!Error);
+	}
+
+	return Error;
+}
+*/
+int test_log2()
+{
+	int Error = 0;
+
+	for(std::size_t i = 1; i < 24; ++i)
+	{
+		glm::uint A = glm::log2(glm::uint(1 << i));
+		glm::uint B = glm::uint(glm::log2(double(1 << i)));
+
+		//Error += glm::equalEpsilon(double(A), B, 1.0) ? 0 : 1;
+		Error += glm::abs(double(A) - B) <= 24 ? 0 : 1;
+		assert(!Error);
+
+		printf("Log2(%d) Error: %d, %d\n", 1 << i, A, B);
+	}
+
+	printf("log2 error: %d\n", Error);
+
+	return Error;
+}
+
+int test_nlz()
+{
+	int Error = 0;
+
+	for(glm::uint i = 1; i < glm::uint(33); ++i)
+		Error += glm::nlz(i) == glm::uint(31u) - glm::findMSB(i) ? 0 : 1;
+		//printf("%d, %d\n", glm::nlz(i), 31u - glm::findMSB(i));
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_nlz();
+//	Error += test_floor_log2();
+	Error += test_log2();
+
+	return Error;
+}
+

external/glm/test/gtx/gtx_intersect.cpp

@@ -0,0 +1,39 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2015 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.
+/// 
+/// Restrictions:
+///		By making use of the Software for military purposes, you choose to make
+///		a Bunny unhappy.
+/// 
+/// 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.
+///
+/// @file test/gtx/gtx_intersect.cpp
+/// @date 2013-10-25 / 2014-11-25
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#include <glm/gtx/intersect.hpp>
+
+int main()
+{
+	int Error(0);
+
+	return Error;
+}

external/glm/test/gtx/gtx_io.cpp

@@ -0,0 +1,210 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2015 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.
+/// 
+/// Restrictions:
+///		By making use of the Software for military purposes, you choose to make
+///		a Bunny unhappy.
+/// 
+/// 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.
+///
+/// @file test/gtx/gtx_io.cpp
+/// @date 2013-11-22 / 2014-11-25
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#include <glm/gtc/type_precision.hpp>
+#include <glm/gtx/io.hpp>
+#include <iostream>
+#include <sstream>
+#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;
+	}
+
+	template <typename U, glm::precision P, typename T, typename CTy, typename CTr>
+	std::basic_string<CTy> type_name(std::basic_ostream<CTy,CTr>& os, T const&)
+	{
+		std::basic_ostringstream<CTy,CTr> ostr;
+
+		if      (typeid(T) == typeid(glm::tquat<U,P>))   { ostr << "quat"; }
+		else if (typeid(T) == typeid(glm::tvec2<U,P>))   { ostr << "vec2"; }
+		else if (typeid(T) == typeid(glm::tvec3<U,P>))   { ostr << "vec3"; }
+		else if (typeid(T) == typeid(glm::tvec4<U,P>))   { ostr << "vec4"; }
+		else if (typeid(T) == typeid(glm::tmat2x2<U,P>)) { ostr << "mat2x2"; }
+		else if (typeid(T) == typeid(glm::tmat2x3<U,P>)) { ostr << "mat2x3"; }
+		else if (typeid(T) == typeid(glm::tmat2x4<U,P>)) { ostr << "mat2x4"; }
+		else if (typeid(T) == typeid(glm::tmat3x2<U,P>)) { ostr << "mat3x2"; }
+		else if (typeid(T) == typeid(glm::tmat3x3<U,P>)) { ostr << "mat3x3"; }
+		else if (typeid(T) == typeid(glm::tmat3x4<U,P>)) { ostr << "mat3x4"; }
+		else if (typeid(T) == typeid(glm::tmat4x2<U,P>)) { ostr << "mat4x2"; }
+		else if (typeid(T) == typeid(glm::tmat4x3<U,P>)) { ostr << "mat4x3"; }
+		else if (typeid(T) == typeid(glm::tmat4x4<U,P>)) { ostr << "mat4x4"; }
+		else                                             { ostr << "unknown"; }
+
+		ostr << '<' << typeid(U).name() << ',' << P << '>';
+
+		return ostr.str();
+	}
+} // namespace {
+
+template <typename T, glm::precision P, typename OS>
+int test_io_quat(OS& os)
+{
+	os << '\n' << typeid(OS).name() << '\n';
+
+	glm::tquat<T,P> const q(1, 0, 0, 0);
+
+	{
+		glm::io::basic_format_saver<typename OS::char_type> const iofs(os);
+
+		os << glm::io::precision(2) << glm::io::width(1 + 2 + 1 + 2)
+			<< type_name<T,P>(os, q) << ": " << q << '\n';
+	}
+
+	{
+		glm::io::basic_format_saver<typename OS::char_type> const iofs(os);
+
+		os << glm::io::unformatted
+			<< type_name<T,P>(os, q) << ": " << q << '\n';
+	}
+
+	return 0;
+}
+
+template <typename T, glm::precision P, typename OS>
+int test_io_vec(OS& os)
+{
+	os << '\n' << typeid(OS).name() << '\n';
+
+	glm::tvec2<T,P> const v2(0, 1);
+	glm::tvec3<T,P> const v3(2, 3, 4);
+	glm::tvec4<T,P> const v4(5, 6, 7, 8);
+
+	os << type_name<T,P>(os, v2) << ": " << v2 << '\n'
+		<< type_name<T,P>(os, v3) << ": " << v3 << '\n'
+		<< type_name<T,P>(os, v4) << ": " << v4 << '\n';
+
+	glm::io::basic_format_saver<typename OS::char_type> const iofs(os);
+
+	os << glm::io::precision(2) << glm::io::width(1 + 2 + 1 + 2)
+		<< type_name<T,P>(os, v2) << ": " << v2 << '\n'
+		<< type_name<T,P>(os, v3) << ": " << v3 << '\n'
+		<< type_name<T,P>(os, v4) << ": " << 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::tvec2<T,P> const v2_1( 0,  1);
+	glm::tvec2<T,P> const v2_2( 2,  3);
+	glm::tvec2<T,P> const v2_3( 4,  5);
+	glm::tvec2<T,P> const v2_4( 6,  7);
+	glm::tvec3<T,P> const v3_1( 8,  9, 10);
+	glm::tvec3<T,P> const v3_2(11, 12, 13);
+	glm::tvec3<T,P> const v3_3(14, 15, 16);
+	glm::tvec3<T,P> const v3_4(17, 18, 19);
+	glm::tvec4<T,P> const v4_1(20, 21, 22, 23);
+	glm::tvec4<T,P> const v4_2(24, 25, 26, 27);
+	glm::tvec4<T,P> const v4_3(28, 29, 30, 31);
+	glm::tvec4<T,P> const v4_4(32, 33, 34, 35);
+
+#if 0
+	os << "mat2x2<" << typeid(T).name() << ',' << P << ">: " << glm::tmat2x2<T,P>(v2_1, v2_2) << '\n'
+		<< "mat2x3<" << typeid(T).name() << ',' << P << ">: " << glm::tmat2x3<T,P>(v3_1, v3_2) << '\n'
+		<< "mat2x4<" << typeid(T).name() << ',' << P << ">: " << glm::tmat2x4<T,P>(v4_1, v4_2) << '\n'
+		<< "mat3x2<" << typeid(T).name() << ',' << P << ">: " << glm::tmat3x2<T,P>(v2_1, v2_2, v2_3) << '\n'
+		<< "mat3x3<" << typeid(T).name() << ',' << P << ">: " << glm::tmat3x3<T,P>(v3_1, v3_2, v3_3) << '\n'
+		<< "mat3x4<" << typeid(T).name() << ',' << P << ">: " << glm::tmat3x4<T,P>(v4_1, v4_2, v4_3) << '\n'
+		<< "mat4x2<" << typeid(T).name() << ',' << P << ">: " << glm::tmat4x2<T,P>(v2_1, v2_2, v2_3, v2_4) << '\n'
+		<< "mat4x3<" << typeid(T).name() << ',' << P << ">: " << glm::tmat4x3<T,P>(v3_1, v3_2, v3_3, v3_4) << '\n'
+		<< "mat4x4<" << typeid(T).name() << ',' << P << ">: " << glm::tmat4x4<T,P>(v4_1, v4_2, v4_3, v4_4) << '\n';
+#endif
+
+	glm::io::basic_format_saver<typename OS::char_type> const iofs(os);
+
+	os << glm::io::precision(2) << glm::io::width(1 + 2 + 1 + 2)
+		<< "mat2x2<" << typeid(T).name() << ',' << P << ">: " << glm::tmat2x2<T,P>(v2_1, v2_2) << '\n'
+		<< "mat2x3<" << typeid(T).name() << ',' << P << ">: " << glm::tmat2x3<T,P>(v3_1, v3_2) << '\n'
+		<< "mat2x4<" << typeid(T).name() << ',' << P << ">: " << glm::tmat2x4<T,P>(v4_1, v4_2) << '\n'
+		<< "mat3x2<" << typeid(T).name() << ',' << P << ">: " << glm::tmat3x2<T,P>(v2_1, v2_2, v2_3) << '\n'
+		<< "mat3x3<" << typeid(T).name() << ',' << P << ">: " << glm::tmat3x3<T,P>(v3_1, v3_2, v3_3) << '\n'
+		<< "mat3x4<" << typeid(T).name() << ',' << P << ">: " << glm::tmat3x4<T,P>(v4_1, v4_2, v4_3) << '\n'
+		<< "mat4x2<" << typeid(T).name() << ',' << P << ">: " << glm::tmat4x2<T,P>(v2_1, v2_2, v2_3, v2_4) << '\n'
+		<< "mat4x3<" << typeid(T).name() << ',' << P << ">: " << glm::tmat4x3<T,P>(v3_1, v3_2, v3_3, v3_4) << '\n'
+		<< "mat4x4<" << typeid(T).name() << ',' << P << ">: " << glm::tmat4x4<T,P>(v4_1, v4_2, v4_3, v4_4) << '\n';
+
+	os << glm::io::unformatted
+		<< glm::io::order(glm::io::column_major)
+		<< "mat2x2<" << typeid(T).name() << ',' << P << ">: " << glm::tmat2x2<T,P>(v2_1, v2_2) << '\n'
+		<< "mat2x3<" << typeid(T).name() << ',' << P << ">: " << glm::tmat2x3<T,P>(v3_1, v3_2) << '\n'
+		<< "mat2x4<" << typeid(T).name() << ',' << P << ">: " << glm::tmat2x4<T,P>(v4_1, v4_2) << '\n'
+		<< "mat3x2<" << typeid(T).name() << ',' << P << ">: " << glm::tmat3x2<T,P>(v2_1, v2_2, v2_3) << '\n'
+		<< "mat3x3<" << typeid(T).name() << ',' << P << ">: " << glm::tmat3x3<T,P>(v3_1, v3_2, v3_3) << '\n'
+		<< "mat3x4<" << typeid(T).name() << ',' << P << ">: " << glm::tmat3x4<T,P>(v4_1, v4_2, v4_3) << '\n'
+		<< "mat4x2<" << typeid(T).name() << ',' << P << ">: " << glm::tmat4x2<T,P>(v2_1, v2_2, v2_3, v2_4) << '\n'
+		<< "mat4x3<" << typeid(T).name() << ',' << P << ">: " << glm::tmat4x3<T,P>(v3_1, v3_2, v3_3, v3_4) << '\n'
+		<< "mat4x4<" << typeid(T).name() << ',' << P << ">: " << glm::tmat4x4<T,P>(v4_1, v4_2, v4_3, v4_4) << '\n';
+  
+	return 0;
+}
+
+int main()
+{
+	int Error(0);
+
+	Error += test_io_quat<float, glm::highp>(std::cout);
+	Error += test_io_quat<float, glm::highp>(std::wcout);
+	Error += test_io_quat<int, glm::mediump>(std::cout);
+	Error += test_io_quat<int, glm::mediump>(std::wcout);
+	Error += test_io_quat<glm::uint, glm::lowp>(std::cout);
+	Error += test_io_quat<glm::uint, glm::lowp>(std::wcout);
+
+	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<glm::uint, glm::lowp>(std::cout);
+	Error += test_io_vec<glm::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;
+}

external/glm/test/gtx/gtx_log_base.cpp

@@ -0,0 +1,84 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2015 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.
+/// 
+/// Restrictions:
+///		By making use of the Software for military purposes, you choose to make
+///		a Bunny unhappy.
+/// 
+/// 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.
+///
+/// @file test/gtx/gtx_log_base.cpp
+/// @date 2013-10-25 / 2014-11-25
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#include <glm/gtx/log_base.hpp>
+#include <glm/gtc/vec1.hpp>
+#include <glm/gtc/epsilon.hpp>
+#include <glm/exponential.hpp>
+
+namespace test_log
+{
+	int run()
+	{
+		int Error = 0;
+
+		{
+			float A = glm::log(10.f, 2.0f);
+			float B = glm::log2(10.f);
+			Error += glm::epsilonEqual(A, B, 0.00001f) ? 0 : 1;
+		}
+
+		{
+			glm::vec1 A = glm::log(glm::vec1(10.f), glm::vec1(2.0f));
+			glm::vec1 B = glm::log2(glm::vec1(10.f));
+			Error += glm::all(glm::epsilonEqual(A, B, glm::vec1(0.00001f))) ? 0 : 1;
+		}
+
+		{
+			glm::vec2 A = glm::log(glm::vec2(10.f), glm::vec2(2.0f));
+			glm::vec2 B = glm::log2(glm::vec2(10.f));
+			Error += glm::all(glm::epsilonEqual(A, B, glm::vec2(0.00001f))) ? 0 : 1;
+		}
+
+		{
+			glm::vec3 A = glm::log(glm::vec3(10.f), glm::vec3(2.0f));
+			glm::vec3 B = glm::log2(glm::vec3(10.f));
+			Error += glm::all(glm::epsilonEqual(A, B, glm::vec3(0.00001f))) ? 0 : 1;
+		}
+
+		{
+			glm::vec4 A = glm::log(glm::vec4(10.f), glm::vec4(2.0f));
+			glm::vec4 B = glm::log2(glm::vec4(10.f));
+			Error += glm::all(glm::epsilonEqual(A, B, glm::vec4(0.00001f))) ? 0 : 1;
+		}
+
+		return Error;
+	}
+}//namespace test_log
+
+int main()
+{
+	int Error(0);
+
+	Error += test_log::run();
+
+	return Error;
+}

external/glm/test/gtx/gtx_matrix_cross_product.cpp

@@ -0,0 +1,39 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2015 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.
+/// 
+/// Restrictions:
+///		By making use of the Software for military purposes, you choose to make
+///		a Bunny unhappy.
+/// 
+/// 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.
+///
+/// @file test/gtx/gtx_matrix_cross_product.cpp
+/// @date 2013-10-25 / 2014-11-25
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#include <glm/gtx/matrix_cross_product.hpp>
+
+int main()
+{
+	int Error(0);
+
+	return Error;
+}

external/glm/test/gtx/gtx_matrix_decompose.cpp

@@ -0,0 +1,49 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2015 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.
+/// 
+/// Restrictions:
+///		By making use of the Software for military purposes, you choose to make
+///		a Bunny unhappy.
+/// 
+/// 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.
+///
+/// @file test/gtx/gtx_decomposition.cpp
+/// @date 2014-08-31 / 2014-11-25
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#include <glm/gtx/matrix_decompose.hpp>
+
+int main()
+{
+	int Error(0);
+
+	glm::mat4 Matrix(1);
+
+	glm::vec3 Scale;
+	glm::quat Orientation;
+	glm::vec3 Translation;
+	glm::vec3 Skew(1);
+	glm::vec4 Perspective(1);
+
+	glm::decompose(Matrix, Scale, Orientation, Translation, Skew, Perspective);
+
+	return Error;
+}

external/glm/test/gtx/gtx_matrix_interpolation.cpp

@@ -0,0 +1,41 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2015 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.
+/// 
+/// Restrictions:
+///		By making use of the Software for military purposes, you choose to make
+///		a Bunny unhappy.
+/// 
+/// 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.
+///
+/// @file test/gtx/gtx_matrix_interpolation.cpp
+/// @date 2012-09-19 / 2014-11-25
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#include <glm/gtx/matrix_interpolation.hpp>
+
+int main()
+{
+	int Error(0);
+
+	return Error;
+}
+
+

external/glm/test/gtx/gtx_matrix_major_storage.cpp

@@ -0,0 +1,39 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2015 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.
+/// 
+/// Restrictions:
+///		By making use of the Software for military purposes, you choose to make
+///		a Bunny unhappy.
+/// 
+/// 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.
+///
+/// @file test/gtx/gtx_matrix_major_storage.cpp
+/// @date 2013-10-25 / 2014-11-25
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#include <glm/gtx/matrix_major_storage.hpp>
+
+int main()
+{
+	int Error(0);
+
+	return Error;
+}

external/glm/test/gtx/gtx_matrix_operation.cpp

@@ -0,0 +1,39 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2015 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.
+/// 
+/// Restrictions:
+///		By making use of the Software for military purposes, you choose to make
+///		a Bunny unhappy.
+/// 
+/// 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.
+///
+/// @file test/gtx/gtx_matrix_operation.cpp
+/// @date 2013-10-25 / 2014-11-25
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#include <glm/gtx/matrix_operation.hpp>
+
+int main()
+{
+	int Error(0);
+
+	return Error;
+}

external/glm/test/gtx/gtx_matrix_query.cpp

@@ -0,0 +1,96 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2015 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.
+/// 
+/// Restrictions:
+///		By making use of the Software for military purposes, you choose to make
+///		a Bunny unhappy.
+/// 
+/// 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.
+///
+/// @file test/gtx/gtx_matrix_query.cpp
+/// @date 2011-11-22 / 2014-11-25
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#include <glm/gtx/matrix_query.hpp>
+
+int test_isNull()
+{
+	int Error(0);
+	
+	bool TestA = glm::isNull(glm::mat4(0), 0.00001f);
+	Error += TestA ? 0 : 1;
+
+	return Error;
+}
+
+int test_isIdentity()
+{
+	int Error(0);
+	
+	{
+		bool TestA = glm::isIdentity(glm::mat2(1), 0.00001f);
+		Error += TestA ? 0 : 1;
+	}
+	{
+		bool TestA = glm::isIdentity(glm::mat3(1), 0.00001f);
+		Error += TestA ? 0 : 1;
+	}
+	{
+		bool TestA = glm::isIdentity(glm::mat4(1), 0.00001f);
+		Error += TestA ? 0 : 1;
+	}
+
+	return Error;
+}
+
+int test_isNormalized()
+{
+	int Error(0);
+
+	bool TestA = glm::isNormalized(glm::mat4(1), 0.00001f);
+	Error += TestA ? 0 : 1;
+
+	return Error;
+}
+
+int test_isOrthogonal()
+{
+	int Error(0);
+
+	bool TestA = glm::isOrthogonal(glm::mat4(1), 0.00001f);
+	Error += TestA ? 0 : 1;
+
+	return Error;
+}
+
+int main()
+{
+	int Error(0);
+
+	Error += test_isNull();
+	Error += test_isIdentity();
+	Error += test_isNormalized();
+	Error += test_isOrthogonal();
+
+	return Error;
+}
+
+

external/glm/test/gtx/gtx_matrix_transform_2d.cpp

@@ -0,0 +1,39 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2015 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.
+/// 
+/// Restrictions:
+///		By making use of the Software for military purposes, you choose to make
+///		a Bunny unhappy.
+/// 
+/// 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.
+///
+/// @file test/gtx/gtx_matrix_transform_2d.cpp
+/// @date 2014-02-21 / 2014-11-25
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#include <glm/gtx/matrix_transform_2d.hpp>
+
+int main()
+{
+	int Error(0);
+
+	return Error;
+}

external/glm/test/gtx/gtx_mixed_product.cpp

@@ -0,0 +1,18 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// 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/gtc/type_precision.hpp>
+#include <glm/gtx/associated_min_max.hpp>
+
+int main()
+{
+	int Error(0);
+
+	return Error;
+}

external/glm/test/gtx/gtx_norm.cpp

@@ -0,0 +1,39 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2015 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.
+/// 
+/// Restrictions:
+///		By making use of the Software for military purposes, you choose to make
+///		a Bunny unhappy.
+/// 
+/// 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.
+///
+/// @file test/gtx/gtx_norm.cpp
+/// @date 2013-10-25 / 2014-11-25
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#include <glm/gtx/norm.hpp>
+
+int main()
+{
+	int Error(0);
+
+	return Error;
+}

external/glm/test/gtx/gtx_normal.cpp

@@ -0,0 +1,39 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2015 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.
+/// 
+/// Restrictions:
+///		By making use of the Software for military purposes, you choose to make
+///		a Bunny unhappy.
+/// 
+/// 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.
+///
+/// @file test/gtx/gtx_normal.cpp
+/// @date 2013-10-25 / 2014-11-25
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#include <glm/gtx/normal.hpp>
+
+int main()
+{
+	int Error(0);
+
+	return Error;
+}

external/glm/test/gtx/gtx_normalize_dot.cpp

@@ -0,0 +1,39 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2015 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.
+/// 
+/// Restrictions:
+///		By making use of the Software for military purposes, you choose to make
+///		a Bunny unhappy.
+/// 
+/// 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.
+///
+/// @file test/gtx/gtx_normalize_dot.cpp
+/// @date 2013-10-25 / 2014-11-25
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#include <glm/gtx/normalize_dot.hpp>
+
+int main()
+{
+	int Error(0);
+
+	return Error;
+}

external/glm/test/gtx/gtx_number_precision.cpp

@@ -0,0 +1,39 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2015 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.
+/// 
+/// Restrictions:
+///		By making use of the Software for military purposes, you choose to make
+///		a Bunny unhappy.
+/// 
+/// 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.
+///
+/// @file test/gtx/gtx_number_precision.cpp
+/// @date 2013-10-25 / 2014-11-25
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#include <glm/gtx/number_precision.hpp>
+
+int main()
+{
+	int Error(0);
+
+	return Error;
+}

external/glm/test/gtx/gtx_optimum_pow.cpp

@@ -0,0 +1,39 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2015 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.
+/// 
+/// Restrictions:
+///		By making use of the Software for military purposes, you choose to make
+///		a Bunny unhappy.
+/// 
+/// 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.
+///
+/// @file test/gtx/gtx_optimum_pow.cpp
+/// @date 2013-10-25 / 2014-11-25
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#include <glm/gtx/optimum_pow.hpp>
+
+int main()
+{
+	int Error(0);
+
+	return Error;
+}

external/glm/test/gtx/gtx_orthonormalize.cpp

@@ -0,0 +1,39 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2015 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.
+/// 
+/// Restrictions:
+///		By making use of the Software for military purposes, you choose to make
+///		a Bunny unhappy.
+/// 
+/// 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.
+///
+/// @file test/gtx/gtx_orthonormalize.cpp
+/// @date 2013-10-25 / 2014-11-25
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#include <glm/gtx/orthonormalize.hpp>
+
+int main()
+{
+	int Error(0);
+
+	return Error;
+}

external/glm/test/gtx/gtx_perpendicular.cpp

@@ -0,0 +1,39 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2015 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.
+/// 
+/// Restrictions:
+///		By making use of the Software for military purposes, you choose to make
+///		a Bunny unhappy.
+/// 
+/// 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.
+///
+/// @file test/gtx/gtx_perpendicular.cpp
+/// @date 2013-10-25 / 2014-11-25
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#include <glm/gtx/perpendicular.hpp>
+
+int main()
+{
+	int Error(0);
+
+	return Error;
+}

external/glm/test/gtx/gtx_polar_coordinates.cpp

@@ -0,0 +1,39 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2015 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.
+/// 
+/// Restrictions:
+///		By making use of the Software for military purposes, you choose to make
+///		a Bunny unhappy.
+/// 
+/// 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.
+///
+/// @file test/gtx/gtx_polar_coordinates.cpp
+/// @date 2013-10-25 / 2014-11-25
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#include <glm/gtx/polar_coordinates.hpp>
+
+int main()
+{
+	int Error(0);
+
+	return Error;
+}

external/glm/test/gtx/gtx_projection.cpp

@@ -0,0 +1,39 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2015 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.
+/// 
+/// Restrictions:
+///		By making use of the Software for military purposes, you choose to make
+///		a Bunny unhappy.
+/// 
+/// 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.
+///
+/// @file test/gtx/gtx_projection.cpp
+/// @date 2013-10-25 / 2014-11-25
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#include <glm/gtx/projection.hpp>
+
+int main()
+{
+	int Error(0);
+
+	return Error;
+}

external/glm/test/gtx/gtx_quaternion.cpp

@@ -0,0 +1,133 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2015 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.
+/// 
+/// Restrictions:
+///		By making use of the Software for military purposes, you choose to make
+///		a Bunny unhappy.
+/// 
+/// 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.
+///
+/// @file test/gtx/gtx_quaternion.cpp
+/// @date 2011-05-25 / 2014-11-25
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#include <glm/gtc/epsilon.hpp>
+#include <glm/gtc/type_ptr.hpp>
+#include <glm/gtc/matrix_transform.hpp>
+#include <glm/gtx/transform.hpp>
+#include <glm/gtx/quaternion.hpp>
+#include <glm/gtx/compatibility.hpp>
+#include <glm/ext.hpp>
+
+int test_quat_fastMix()
+{
+	int Error = 0;
+
+	glm::quat A = glm::angleAxis(0.0f, glm::vec3(0, 0, 1));
+	glm::quat B = glm::angleAxis(glm::pi<float>() * 0.5f, glm::vec3(0, 0, 1));
+	glm::quat C = glm::fastMix(A, B, 0.5f);
+	glm::quat D = glm::angleAxis(glm::pi<float>() * 0.25f, glm::vec3(0, 0, 1));
+
+	Error += glm::epsilonEqual(C.x, D.x, 0.01f) ? 0 : 1;
+	Error += glm::epsilonEqual(C.y, D.y, 0.01f) ? 0 : 1;
+	Error += glm::epsilonEqual(C.z, D.z, 0.01f) ? 0 : 1;
+	Error += glm::epsilonEqual(C.w, D.w, 0.01f) ? 0 : 1;
+
+	return Error;
+}
+
+int test_quat_shortMix()
+{
+	int Error(0);
+
+	glm::quat A = glm::angleAxis(0.0f, glm::vec3(0, 0, 1));
+	glm::quat B = glm::angleAxis(glm::pi<float>() * 0.5f, glm::vec3(0, 0, 1));
+	glm::quat C = glm::shortMix(A, B, 0.5f);
+	glm::quat D = glm::angleAxis(glm::pi<float>() * 0.25f, glm::vec3(0, 0, 1));
+
+	Error += glm::epsilonEqual(C.x, D.x, 0.01f) ? 0 : 1;
+	Error += glm::epsilonEqual(C.y, D.y, 0.01f) ? 0 : 1;
+	Error += glm::epsilonEqual(C.z, D.z, 0.01f) ? 0 : 1;
+	Error += glm::epsilonEqual(C.w, D.w, 0.01f) ? 0 : 1;
+
+	return Error;
+}
+
+int test_orientation()
+{
+	int Error(0);
+
+	{
+		glm::quat q(1.0f, 0.0f, 0.0f, 1.0f);
+		float p = glm::roll(q);
+	}
+
+	{
+		glm::quat q(1.0f, 0.0f, 0.0f, 1.0f);
+		float p = glm::pitch(q);
+	}
+
+	{
+		glm::quat q(1.0f, 0.0f, 0.0f, 1.0f);
+		float p = glm::yaw(q);
+	}
+
+	return Error;
+}
+
+int test_rotation()
+{
+	int Error(0);
+
+	glm::vec3 v(1, 0, 0);
+	glm::vec3 u(0, 1, 0);
+
+	glm::quat Rotation = glm::rotation(v, u);
+
+	float Angle = glm::angle(Rotation);
+
+	Error += glm::abs(Angle - glm::pi<float>() * 0.5f) < glm::epsilon<float>() ? 0 : 1;
+
+	return Error;
+}
+
+int test_log()
+{
+	int Error(0);
+	
+	glm::quat q;
+	glm::quat p = glm::log(q);
+	glm::quat r = glm::exp(p);
+
+	return Error;
+}
+
+int main()
+{
+	int Error(0);
+
+	Error += test_log();
+	Error += test_rotation();
+	Error += test_quat_fastMix();
+	Error += test_quat_shortMix();
+
+	return Error;
+}

external/glm/test/gtx/gtx_random.cpp

@@ -0,0 +1,99 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2012 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2011-05-31
+// Updated : 2011-05-31
+// Licence : This source is under MIT licence
+// File    : test/gtx/random.cpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#include <glm/glm.hpp>
+#include <glm/gtx/random.hpp>
+#include <glm/gtx/epsilon.hpp>
+#include <iostream>
+
+int test_signedRand1()
+{
+	int Error = 0;
+
+	{
+		float ResultFloat = 0.0f;
+		double ResultDouble = 0.0f;
+		for(std::size_t i = 0; i < 100000; ++i)
+		{
+			ResultFloat += glm::signedRand1<float>();
+			ResultDouble += glm::signedRand1<double>();
+		}
+
+		Error += glm::equalEpsilon(ResultFloat, 0.0f, 0.0001f);
+		Error += glm::equalEpsilon(ResultDouble, 0.0, 0.0001);
+	}
+
+	return Error;
+}
+
+int test_normalizedRand2()
+{
+	int Error = 0;
+
+	{
+		std::size_t Max = 100000;
+		float ResultFloat = 0.0f;
+		double ResultDouble = 0.0f;
+		for(std::size_t i = 0; i < Max; ++i)
+		{
+			ResultFloat += glm::length(glm::normalizedRand2<float>());
+			ResultDouble += glm::length(glm::normalizedRand2<double>());
+		}
+
+		Error += glm::equalEpsilon(ResultFloat, float(Max), 0.000001f) ? 0 : 1;
+		Error += glm::equalEpsilon(ResultDouble, double(Max), 0.000001) ? 0 : 1;
+		assert(!Error);
+	}
+
+	return Error;
+}
+
+int test_normalizedRand3()
+{
+	int Error = 0;
+
+	{
+		std::size_t Max = 100000;
+		float ResultFloatA = 0.0f;
+		float ResultFloatB = 0.0f;
+		float ResultFloatC = 0.0f;
+		double ResultDoubleA = 0.0f;
+		double ResultDoubleB = 0.0f;
+		double ResultDoubleC = 0.0f;
+		for(std::size_t i = 0; i < Max; ++i)
+		{
+			ResultFloatA += glm::length(glm::normalizedRand3<float>());
+			ResultDoubleA += glm::length(glm::normalizedRand3<double>());
+			ResultFloatB += glm::length(glm::normalizedRand3(2.0f, 2.0f));
+			ResultDoubleB += glm::length(glm::normalizedRand3(2.0, 2.0));
+			ResultFloatC += glm::length(glm::normalizedRand3(1.0f, 3.0f));
+			ResultDoubleC += glm::length(glm::normalizedRand3(1.0, 3.0));
+		}
+
+		Error += glm::equalEpsilon(ResultFloatA, float(Max), 0.0001f) ? 0 : 1;
+		Error += glm::equalEpsilon(ResultDoubleA, double(Max), 0.0001) ? 0 : 1;
+		Error += glm::equalEpsilon(ResultFloatB, float(Max * 2), 0.0001f) ? 0 : 1;
+		Error += glm::equalEpsilon(ResultDoubleB, double(Max * 2), 0.0001) ? 0 : 1;
+		Error += (ResultFloatC >= float(Max) && ResultFloatC <= float(Max * 3)) ? 0 : 1;
+		Error += (ResultDoubleC >= double(Max) && ResultDoubleC <= double(Max * 3)) ? 0 : 1;
+	}
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_signedRand1();
+	Error += test_normalizedRand2();
+	Error += test_normalizedRand3();
+
+	return Error;
+}

external/glm/test/gtx/gtx_range.cpp

@@ -0,0 +1,83 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2015 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.
+/// 
+/// Restrictions:
+///		By making use of the Software for military purposes, you choose to make
+///		a Bunny unhappy.
+/// 
+/// 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.
+///
+/// @file test/gtx/gtx_range.cpp
+/// @date 2014-09-19 / 2014-11-25
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#include <glm/glm.hpp>
+#include <glm/gtc/epsilon.hpp>
+
+#if GLM_HAS_RANGE_FOR
+
+#include <glm/gtx/range.hpp>
+
+int testVec()
+{
+	int Error(0);
+	glm::vec3 v(1, 2, 3);
+
+	int count = 0;
+	for(float x : v){ count++; }
+	Error += count == 3 ? 0 : 1;
+
+	for(float& x : v){ x = 0; }
+	Error += glm::all(glm::equal(v, glm::vec3(0, 0, 0))) ? 0 : 1;
+	return Error;
+}
+
+int testMat()
+{
+	int Error(0);
+	glm::mat4x3 m(1);
+
+	int count = 0;
+	for(float x : m){ count++; }
+	Error += count == 12 ? 0 : 1;
+
+	for(float& x : m){ x = 0; }
+	glm::vec4 v(1, 1, 1, 1);
+	Error += glm::all(glm::equal(m*v, glm::vec3(0, 0, 0))) ? 0 : 1;
+	return Error;
+}
+
+int main()
+{
+	int Error(0);
+	Error += testVec();
+	Error += testMat();
+	return Error;
+}
+
+#else
+
+int main()
+{
+	return 0;
+}
+
+#endif//GLM_HAS_RANGE_FOR

external/glm/test/gtx/gtx_rotate_normalized_axis.cpp

@@ -0,0 +1,39 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2012 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.
+/// 
+/// Restrictions:
+///		By making use of the Software for military purposes, you choose to make
+///		a Bunny unhappy.
+/// 
+/// 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.
+///
+/// @file test/gtx/gtx_rotate_normalized_axis.cpp
+/// @date 2012-12-13 / 2012-12-13
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#include <glm/gtx/rotate_normalized_axis.hpp>
+
+int main()
+{
+	int Error(0);
+
+	return Error;
+}

external/glm/test/gtx/gtx_rotate_vector.cpp

@@ -0,0 +1,106 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2012 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.
+/// 
+/// Restrictions:
+///		By making use of the Software for military purposes, you choose to make
+///		a Bunny unhappy.
+/// 
+/// 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.
+///
+/// @file test/gtx/gtx_rotate_vector.cpp
+/// @date 2011-05-16 / 2014-11-25
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#include <glm/gtc/constants.hpp>
+#include <glm/gtx/rotate_vector.hpp>
+
+int test_rotate()
+{
+	int Error = 0;
+
+	glm::vec2 A = glm::rotate(glm::vec2(1, 0), glm::pi<float>() * 0.5f);
+	glm::vec3 B = glm::rotate(glm::vec3(1, 0, 0), glm::pi<float>() * 0.5f, glm::vec3(0, 0, 1));
+	glm::vec4 C = glm::rotate(glm::vec4(1, 0, 0, 1), glm::pi<float>() * 0.5f, glm::vec3(0, 0, 1));
+	glm::vec3 D = glm::rotateX(glm::vec3(1, 0, 0), glm::pi<float>() * 0.5f);
+	glm::vec4 E = glm::rotateX(glm::vec4(1, 0, 0, 1), glm::pi<float>() * 0.5f);
+	glm::vec3 F = glm::rotateY(glm::vec3(1, 0, 0), glm::pi<float>() * 0.5f);
+	glm::vec4 G = glm::rotateY(glm::vec4(1, 0, 0, 1), glm::pi<float>() * 0.5f);
+	glm::vec3 H = glm::rotateZ(glm::vec3(1, 0, 0), glm::pi<float>() * 0.5f);
+	glm::vec4 I = glm::rotateZ(glm::vec4(1, 0, 0,1 ), glm::pi<float>() * 0.5f);
+	glm::mat4 O = glm::orientation(glm::normalize(glm::vec3(1)), glm::vec3(0, 0, 1));
+
+	return Error;
+}
+
+int test_rotateX()
+{
+	int Error = 0;
+
+	glm::vec3 D = glm::rotateX(glm::vec3(1, 0, 0), glm::pi<float>() * 0.5f);
+	glm::vec4 E = glm::rotateX(glm::vec4(1, 0, 0, 1), glm::pi<float>() * 0.5f);
+
+	return Error;
+}
+
+int test_rotateY()
+{
+	int Error = 0;
+
+	glm::vec3 F = glm::rotateY(glm::vec3(1, 0, 0), glm::pi<float>() * 0.5f);
+	glm::vec4 G = glm::rotateY(glm::vec4(1, 0, 0, 1), glm::pi<float>() * 0.5f);
+
+	return Error;
+}
+
+
+int test_rotateZ()
+{
+	int Error = 0;
+
+	glm::vec3 H = glm::rotateZ(glm::vec3(1, 0, 0), glm::pi<float>() * 0.5f);
+	glm::vec4 I = glm::rotateZ(glm::vec4(1, 0, 0,1 ), glm::pi<float>() * 0.5f);
+
+	return Error;
+}
+
+int test_orientation()
+{
+	int Error = 0;
+
+	glm::mat4 O = glm::orientation(glm::normalize(glm::vec3(1)), glm::vec3(0, 0, 1));
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_rotate();
+	Error += test_rotateX();
+	Error += test_rotateY();
+	Error += test_rotateZ();
+	Error += test_orientation();
+
+	return Error;
+}
+
+

external/glm/test/gtx/gtx_scalar_multiplication.cpp

@@ -0,0 +1,65 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2012 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.
+/// 
+/// Restrictions:
+///		By making use of the Software for military purposes, you choose to make
+///		a Bunny unhappy.
+/// 
+/// 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.
+///
+/// @file test/gtx/gtx_scalar_multiplication.cpp
+/// @date 2014-09-22 / 2014-11-25
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#include <glm/glm.hpp>
+
+#if GLM_HAS_TEMPLATE_ALIASES & !(GLM_COMPILER & GLM_COMPILER_GCC)
+#include <glm/gtx/scalar_multiplication.hpp>
+
+int main()
+{
+	int Error(0);
+	glm::vec3 v(0.5, 3.1, -9.1);
+
+	Error += glm::all(glm::equal(v, 1.0 * v)) ? 0 : 1;
+	Error += glm::all(glm::equal(v, 1 * v)) ? 0 : 1;
+	Error += glm::all(glm::equal(v, 1u * v)) ? 0 : 1;
+
+	glm::mat3 m(1, 2, 3, 4, 5, 6, 7, 8, 9);
+	glm::vec3 w = 0.5f * m * v;
+
+	Error += glm::all(glm::equal((m*v)/2, w)) ? 0 : 1;
+	Error += glm::all(glm::equal(m*(v/2), w)) ? 0 : 1;
+	Error += glm::all(glm::equal((m/2)*v, w)) ? 0 : 1;
+	Error += glm::all(glm::equal((0.5*m)*v, w)) ? 0 : 1;
+	Error += glm::all(glm::equal(0.5*(m*v), w)) ? 0 : 1;
+
+	return Error;
+}
+
+#else
+
+int main()
+{
+	return 0;
+}
+
+#endif

external/glm/test/gtx/gtx_scalar_relational.cpp

@@ -0,0 +1,201 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2012 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.
+/// 
+/// Restrictions:
+///		By making use of the Software for military purposes, you choose to make
+///		a Bunny unhappy.
+/// 
+/// 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.
+///
+/// @file test/gtx/gtx_scalar_relational.cpp
+/// @date 2013-02-04 / 2014-11-25
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#include <glm/glm.hpp>
+#include <glm/gtx/scalar_relational.hpp>
+#include <cstdio>
+
+int test_lessThan()
+{
+	int Error(0);
+
+	Error += glm::lessThan(0, 1) ? 0 : 1;
+	Error += glm::lessThan(1, 0) ? 1 : 0;
+	Error += glm::lessThan(0, 0) ? 1 : 0;
+	Error += glm::lessThan(1, 1) ? 1 : 0;
+	Error += glm::lessThan(0.0f, 1.0f) ? 0 : 1;
+	Error += glm::lessThan(1.0f, 0.0f) ? 1 : 0;
+	Error += glm::lessThan(0.0f, 0.0f) ? 1 : 0;
+	Error += glm::lessThan(1.0f, 1.0f) ? 1 : 0;
+	Error += glm::lessThan(0.0, 1.0) ? 0 : 1;
+	Error += glm::lessThan(1.0, 0.0) ? 1 : 0;
+	Error += glm::lessThan(0.0, 0.0) ? 1 : 0;
+	Error += glm::lessThan(1.0, 1.0) ? 1 : 0;
+
+	return Error;
+}
+
+int test_lessThanEqual()
+{
+	int Error(0);
+
+	Error += glm::lessThanEqual(0, 1) ? 0 : 1;
+	Error += glm::lessThanEqual(1, 0) ? 1 : 0;
+	Error += glm::lessThanEqual(0, 0) ? 0 : 1;
+	Error += glm::lessThanEqual(1, 1) ? 0 : 1;
+	Error += glm::lessThanEqual(0.0f, 1.0f) ? 0 : 1;
+	Error += glm::lessThanEqual(1.0f, 0.0f) ? 1 : 0;
+	Error += glm::lessThanEqual(0.0f, 0.0f) ? 0 : 1;
+	Error += glm::lessThanEqual(1.0f, 1.0f) ? 0 : 1;
+	Error += glm::lessThanEqual(0.0, 1.0) ? 0 : 1;
+	Error += glm::lessThanEqual(1.0, 0.0) ? 1 : 0;
+	Error += glm::lessThanEqual(0.0, 0.0) ? 0 : 1;
+	Error += glm::lessThanEqual(1.0, 1.0) ? 0 : 1;
+
+	return Error;
+}
+
+int test_greaterThan()
+{
+	int Error(0);
+
+	Error += glm::greaterThan(0, 1) ? 1 : 0;
+	Error += glm::greaterThan(1, 0) ? 0 : 1;
+	Error += glm::greaterThan(0, 0) ? 1 : 0;
+	Error += glm::greaterThan(1, 1) ? 1 : 0;
+	Error += glm::greaterThan(0.0f, 1.0f) ? 1 : 0;
+	Error += glm::greaterThan(1.0f, 0.0f) ? 0 : 1;
+	Error += glm::greaterThan(0.0f, 0.0f) ? 1 : 0;
+	Error += glm::greaterThan(1.0f, 1.0f) ? 1 : 0;
+	Error += glm::greaterThan(0.0, 1.0) ? 1 : 0;
+	Error += glm::greaterThan(1.0, 0.0) ? 0 : 1;
+	Error += glm::greaterThan(0.0, 0.0) ? 1 : 0;
+	Error += glm::greaterThan(1.0, 1.0) ? 1 : 0;
+
+	return Error;
+}
+
+int test_greaterThanEqual()
+{
+	int Error(0);
+
+	Error += glm::greaterThanEqual(0, 1) ? 1 : 0;
+	Error += glm::greaterThanEqual(1, 0) ? 0 : 1;
+	Error += glm::greaterThanEqual(0, 0) ? 0 : 1;
+	Error += glm::greaterThanEqual(1, 1) ? 0 : 1;
+	Error += glm::greaterThanEqual(0.0f, 1.0f) ? 1 : 0;
+	Error += glm::greaterThanEqual(1.0f, 0.0f) ? 0 : 1;
+	Error += glm::greaterThanEqual(0.0f, 0.0f) ? 0 : 1;
+	Error += glm::greaterThanEqual(1.0f, 1.0f) ? 0 : 1;
+	Error += glm::greaterThanEqual(0.0, 1.0) ? 1 : 0;
+	Error += glm::greaterThanEqual(1.0, 0.0) ? 0 : 1;
+	Error += glm::greaterThanEqual(0.0, 0.0) ? 0 : 1;
+	Error += glm::greaterThanEqual(1.0, 1.0) ? 0 : 1;
+
+	return Error;
+}
+
+int test_equal()
+{
+	int Error(0);
+
+	Error += glm::equal(0, 1) ? 1 : 0;
+	Error += glm::equal(1, 0) ? 1 : 0;
+	Error += glm::equal(0, 0) ? 0 : 1;
+	Error += glm::equal(1, 1) ? 0 : 1;
+	Error += glm::equal(0.0f, 1.0f) ? 1 : 0;
+	Error += glm::equal(1.0f, 0.0f) ? 1 : 0;
+	Error += glm::equal(0.0f, 0.0f) ? 0 : 1;
+	Error += glm::equal(1.0f, 1.0f) ? 0 : 1;
+	Error += glm::equal(0.0, 1.0) ? 1 : 0;
+	Error += glm::equal(1.0, 0.0) ? 1 : 0;
+	Error += glm::equal(0.0, 0.0) ? 0 : 1;
+	Error += glm::equal(1.0, 1.0) ? 0 : 1;
+
+	return Error;
+}
+
+int test_notEqual()
+{
+	int Error(0);
+
+	Error += glm::notEqual(0, 1) ? 0 : 1;
+	Error += glm::notEqual(1, 0) ? 0 : 1;
+	Error += glm::notEqual(0, 0) ? 1 : 0;
+	Error += glm::notEqual(1, 1) ? 1 : 0;
+	Error += glm::notEqual(0.0f, 1.0f) ? 0 : 1;
+	Error += glm::notEqual(1.0f, 0.0f) ? 0 : 1;
+	Error += glm::notEqual(0.0f, 0.0f) ? 1 : 0;
+	Error += glm::notEqual(1.0f, 1.0f) ? 1 : 0;
+	Error += glm::notEqual(0.0, 1.0) ? 0 : 1;
+	Error += glm::notEqual(1.0, 0.0) ? 0 : 1;
+	Error += glm::notEqual(0.0, 0.0) ? 1 : 0;
+	Error += glm::notEqual(1.0, 1.0) ? 1 : 0;
+
+	return Error;
+}
+
+int test_any()
+{
+	int Error(0);
+
+	Error += glm::any(true) ? 0 : 1;
+	Error += glm::any(false) ? 1 : 0;
+
+	return Error;
+}
+
+int test_all()
+{
+	int Error(0);
+
+	Error += glm::all(true) ? 0 : 1;
+	Error += glm::all(false) ? 1 : 0;
+
+	return Error;
+}
+
+int test_not()
+{
+	int Error(0);
+
+	Error += glm::not_(true) ? 1 : 0;
+	Error += glm::not_(false) ? 0 : 1;
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_lessThan();
+	Error += test_lessThanEqual();
+	Error += test_greaterThan();
+	Error += test_greaterThanEqual();
+	Error += test_equal();
+	Error += test_notEqual();
+	Error += test_any();
+	Error += test_all();
+	Error += test_not();
+
+	return Error;
+}

external/glm/test/gtx/gtx_simd_mat4.cpp

@@ -0,0 +1,334 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2012 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.
+/// 
+/// Restrictions:
+///		By making use of the Software for military purposes, you choose to make
+///		a Bunny unhappy.
+/// 
+/// 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.
+///
+/// @file test/gtx/gtx_simd_mat4.cpp
+/// @date 2010-09-16 / 2014-11-25
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#include <glm/glm.hpp>
+#include <glm/gtc/matrix_transform.hpp>
+#include <glm/gtc/quaternion.hpp>
+#include <glm/gtc/random.hpp>
+#include <glm/gtx/simd_vec4.hpp>
+#include <glm/gtx/simd_mat4.hpp>
+#include <cstdio>
+#include <ctime>
+#include <vector>
+
+#if(GLM_ARCH != GLM_ARCH_PURE)
+
+std::vector<float> test_detA(std::vector<glm::mat4> const & Data)
+{
+	std::vector<float> Test(Data.size());
+
+	std::clock_t TimeStart = clock();
+
+	for(std::size_t i = 0; i < Test.size() - 1; ++i)
+		Test[i] = glm::determinant(Data[i]);
+
+	std::clock_t TimeEnd = clock();
+	printf("Det A: %ld\n", TimeEnd - TimeStart);
+
+	return Test;
+}
+
+std::vector<float> test_detB(std::vector<glm::mat4> const & Data)
+{
+	std::vector<float> Test(Data.size());
+
+	std::clock_t TimeStart = clock();
+
+	for(std::size_t i = 0; i < Test.size() - 1; ++i)
+	{
+		_mm_prefetch((char*)&Data[i + 1], _MM_HINT_T0);
+		glm::simdMat4 m(Data[i]);
+		glm::simdVec4 d(glm::detail::sse_slow_det_ps((__m128 const * const)&m)); 
+		glm::vec4 v;//(d);
+		Test[i] = v.x;
+	}
+
+	std::clock_t TimeEnd = clock();
+	printf("Det B: %ld\n", TimeEnd - TimeStart);
+
+	return Test;
+}
+
+std::vector<float> test_detC(std::vector<glm::mat4> const & Data)
+{
+	std::vector<float> Test(Data.size());
+
+	std::clock_t TimeStart = clock();
+
+	for(std::size_t i = 0; i < Test.size() - 1; ++i)
+	{
+		_mm_prefetch((char*)&Data[i + 1], _MM_HINT_T0);
+		glm::simdMat4 m(Data[i]);
+		glm::simdVec4 d(glm::detail::sse_det_ps((__m128 const * const)&m));
+		glm::vec4 v;//(d);
+		Test[i] = v.x;
+	}
+
+	std::clock_t TimeEnd = clock();
+	printf("Det C: %ld\n", TimeEnd - TimeStart);
+
+	return Test;
+}
+
+std::vector<float> test_detD(std::vector<glm::mat4> const & Data)
+{
+	std::vector<float> Test(Data.size());
+
+	std::clock_t TimeStart = clock();
+
+	for(std::size_t i = 0; i < Test.size() - 1; ++i)
+	{
+		_mm_prefetch((char*)&Data[i + 1], _MM_HINT_T0);
+		glm::simdMat4 m(Data[i]);
+		glm::simdVec4 d(glm::detail::sse_detd_ps((__m128 const * const)&m));
+		glm::vec4 v;//(d); 
+		Test[i] = v.x;
+	}
+
+	std::clock_t TimeEnd = clock();
+	printf("Det D: %ld\n", TimeEnd - TimeStart);
+
+	return Test;
+}
+
+void test_invA(std::vector<glm::mat4> const & Data, std::vector<glm::mat4> & Out)
+{
+	//std::vector<float> Test(Data.size());
+	Out.resize(Data.size());
+
+	std::clock_t TimeStart = clock();
+
+	for(std::size_t i = 0; i < Out.size() - 1; ++i)
+	{
+		Out[i] = glm::inverse(Data[i]);
+	}
+
+	std::clock_t TimeEnd = clock();
+	printf("Inv A: %ld\n", TimeEnd - TimeStart);
+}
+
+void test_invC(std::vector<glm::mat4> const & Data, std::vector<glm::mat4> & Out)
+{
+	//std::vector<float> Test(Data.size());
+	Out.resize(Data.size());
+
+	std::clock_t TimeStart = clock();
+
+	for(std::size_t i = 0; i < Out.size() - 1; ++i)
+	{
+		_mm_prefetch((char*)&Data[i + 1], _MM_HINT_T0);
+		glm::simdMat4 m(Data[i]);
+		glm::simdMat4 o;
+		glm::detail::sse_inverse_fast_ps((__m128 const * const)&m, (__m128 *)&o);
+		Out[i] = *(glm::mat4*)&o;
+	}
+
+	std::clock_t TimeEnd = clock();
+	printf("Inv C: %ld\n", TimeEnd - TimeStart);
+}
+
+void test_invD(std::vector<glm::mat4> const & Data, std::vector<glm::mat4> & Out)
+{
+	//std::vector<float> Test(Data.size());
+	Out.resize(Data.size());
+
+	std::clock_t TimeStart = clock();
+
+	for(std::size_t i = 0; i < Out.size() - 1; ++i)
+	{
+		_mm_prefetch((char*)&Data[i + 1], _MM_HINT_T0);
+		glm::simdMat4 m(Data[i]);
+		glm::simdMat4 o;
+		glm::detail::sse_inverse_ps((__m128 const * const)&m, (__m128 *)&o);
+		Out[i] = *(glm::mat4*)&o;
+	}
+
+	std::clock_t TimeEnd = clock();
+	printf("Inv D: %ld\n", TimeEnd - TimeStart);
+}
+
+void test_mulA(std::vector<glm::mat4> const & Data, std::vector<glm::mat4> & Out)
+{
+	//std::vector<float> Test(Data.size());
+	Out.resize(Data.size());
+
+	std::clock_t TimeStart = clock();
+
+	for(std::size_t i = 0; i < Out.size() - 1; ++i)
+	{
+		Out[i] = Data[i] * Data[i];
+	}
+
+	std::clock_t TimeEnd = clock();
+	printf("Mul A: %ld\n", TimeEnd - TimeStart);
+}
+
+void test_mulD(std::vector<glm::mat4> const & Data, std::vector<glm::mat4> & Out)
+{
+	//std::vector<float> Test(Data.size());
+	Out.resize(Data.size());
+
+	std::clock_t TimeStart = clock();
+
+	for(std::size_t i = 0; i < Out.size() - 1; ++i)
+	{
+		_mm_prefetch((char*)&Data[i + 1], _MM_HINT_T0);
+		glm::simdMat4 m(Data[i]);
+		glm::simdMat4 o;
+		glm::detail::sse_mul_ps((__m128 const * const)&m, (__m128 const * const)&m, (__m128*)&o);
+		Out[i] = *(glm::mat4*)&o;
+	}
+
+	std::clock_t TimeEnd = clock();
+	printf("Mul D: %ld\n", TimeEnd - TimeStart);
+}
+
+int test_compute_glm()
+{
+	return 0;
+}
+
+int test_compute_gtx()
+{
+	std::vector<glm::vec4> Output(1000000);
+
+	std::clock_t TimeStart = clock();
+
+	for(std::size_t k = 0; k < Output.size(); ++k)
+	{
+		float i = float(k) / 1000.f + 0.001f;
+		glm::vec3 A = glm::normalize(glm::vec3(i));
+		glm::vec3 B = glm::cross(A, glm::normalize(glm::vec3(1, 1, 2)));
+		glm::mat4 C = glm::rotate(glm::mat4(1.0f), i, B);
+		glm::mat4 D = glm::scale(C, glm::vec3(0.8f, 1.0f, 1.2f));
+		glm::mat4 E = glm::translate(D, glm::vec3(1.4f, 1.2f, 1.1f));
+		glm::mat4 F = glm::perspective(i, 1.5f, 0.1f, 1000.f);
+		glm::mat4 G = glm::inverse(F * E);
+		glm::vec3 H = glm::unProject(glm::vec3(i), G, F, E[3]);
+		glm::vec3 I = glm::any(glm::isnan(glm::project(H, G, F, E[3]))) ? glm::vec3(2) : glm::vec3(1);
+		glm::mat4 J = glm::lookAt(glm::normalize(glm::max(B, glm::vec3(0.001f))), H, I);
+		glm::mat4 K = glm::transpose(J);
+		glm::quat L = glm::normalize(glm::quat_cast(K));
+		glm::vec4 M = L * glm::smoothstep(K[3], J[3], glm::vec4(i));
+		glm::mat4 N = glm::mat4(glm::normalize(glm::max(M, glm::vec4(0.001f))), K[3], J[3], glm::vec4(i));
+		glm::mat4 O = N * glm::inverse(N);
+		glm::vec4 P = O * glm::reflect(N[3], glm::vec4(A, 1.0f));
+		glm::vec4 Q = glm::vec4(glm::dot(M, P));
+		glm::vec4 R = glm::quat(Q.w, glm::vec3(Q)) * P;
+		Output[k] = R;
+	}
+
+	std::clock_t TimeEnd = clock();
+	printf("test_compute_gtx: %ld\n", TimeEnd - TimeStart);
+
+	return 0;
+}
+
+int main()
+{
+	int Error = 0;
+
+#ifdef GLM_META_PROG_HELPERS
+		assert(glm::simdMat4::rows == glm::simdMat4::row_type::components);
+		assert(glm::simdMat4::cols == glm::simdMat4::col_type::components);
+
+		assert(glm::simdMat4::components == glm::simdMat4::pure_type::components);
+		assert(glm::simdMat4::rows == glm::simdMat4::pure_row_type::components);
+		assert(glm::simdMat4::cols == glm::simdMat4::pure_col_type::components);
+#endif
+
+	std::vector<glm::mat4> Data(64 * 64 * 1);
+	for(std::size_t i = 0; i < Data.size(); ++i)
+		Data[i] = glm::mat4(
+			glm::vec4(glm::linearRand(glm::vec4(-2.0f), glm::vec4(2.0f))),
+			glm::vec4(glm::linearRand(glm::vec4(-2.0f), glm::vec4(2.0f))),
+			glm::vec4(glm::linearRand(glm::vec4(-2.0f), glm::vec4(2.0f))),
+			glm::vec4(glm::linearRand(glm::vec4(-2.0f), glm::vec4(2.0f))));
+
+	{
+		std::vector<glm::mat4> TestInvA;
+		test_invA(Data, TestInvA);
+	}
+	{
+		std::vector<glm::mat4> TestInvC;
+		test_invC(Data, TestInvC);
+	}
+	{
+		std::vector<glm::mat4> TestInvD;
+		test_invD(Data, TestInvD);
+	}
+
+	{
+		std::vector<glm::mat4> TestA;
+		test_mulA(Data, TestA);
+	}
+	{
+		std::vector<glm::mat4> TestD;
+		test_mulD(Data, TestD);
+	}
+
+	{
+		std::vector<float> TestDetA = test_detA(Data);
+		std::vector<float> TestDetB = test_detB(Data);
+		std::vector<float> TestDetD = test_detD(Data);
+		std::vector<float> TestDetC = test_detC(Data);
+
+		for(std::size_t i = 0; i < TestDetA.size(); ++i)
+			if(TestDetA[i] != TestDetB[i] && TestDetC[i] != TestDetB[i] && TestDetC[i] != TestDetD[i])
+				return 1;
+	}
+
+	// shuffle test
+	glm::simdVec4 A(1.0f, 2.0f, 3.0f, 4.0f);
+	glm::simdVec4 B(5.0f, 6.0f, 7.0f, 8.0f);
+	//__m128 C = _mm_shuffle_ps(A.Data, B.Data, _MM_SHUFFLE(1, 0, 1, 0));
+
+	Error += test_compute_glm();
+	Error += test_compute_gtx();
+	
+	float Det = glm::determinant(glm::simdMat4(1.0));
+	Error += Det == 1.0f ? 0 : 1;
+	
+	glm::simdMat4 D = glm::matrixCompMult(glm::simdMat4(1.0), glm::simdMat4(1.0));
+
+	return Error;
+}
+
+#else
+
+int main()
+{
+	int Error = 0;
+
+	return Error;
+}
+
+#endif//(GLM_ARCH != GLM_ARCH_PURE)

external/glm/test/gtx/gtx_simd_vec4.cpp

@@ -0,0 +1,76 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2012 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.
+/// 
+/// Restrictions:
+///		By making use of the Software for military purposes, you choose to make
+///		a Bunny unhappy.
+/// 
+/// 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.
+///
+/// @file test/gtx/gtx_simd_vec4.cpp
+/// @date 2010-09-16 / 2014-11-25
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#include <glm/glm.hpp>
+#include <glm/gtx/simd_vec4.hpp>
+#include <cstdio>
+
+#if(GLM_ARCH != GLM_ARCH_PURE)
+
+int main()
+{
+
+#ifdef GLM_META_PROG_HELPERS
+		assert(glm::simdVec4::components == glm::simdVec4::pure_type::components);
+#endif
+
+	glm::simdVec4 A1(0.0f, 0.1f, 0.2f, 0.3f);
+	glm::simdVec4 B1(0.4f, 0.5f, 0.6f, 0.7f);
+	glm::simdVec4 C1 = A1 + B1;
+	glm::simdVec4 D1 = A1.swizzle<glm::X, glm::Z, glm::Y, glm::W>();
+	glm::simdVec4 E1(glm::vec4(1.0f));
+	glm::vec4 F1 = glm::vec4_cast(E1);
+	//glm::vec4 G1(E1);
+
+	//printf("A1(%2.3f, %2.3f, %2.3f, %2.3f)\n", A1.x, A1.y, A1.z, A1.w);
+	//printf("B1(%2.3f, %2.3f, %2.3f, %2.3f)\n", B1.x, B1.y, B1.z, B1.w);
+	//printf("C1(%2.3f, %2.3f, %2.3f, %2.3f)\n", C1.x, C1.y, C1.z, C1.w);
+	//printf("D1(%2.3f, %2.3f, %2.3f, %2.3f)\n", D1.x, D1.y, D1.z, D1.w);
+
+	__m128 value = _mm_set1_ps(0.0f);
+	__m128 data = _mm_cmpeq_ps(value, value);
+	__m128 add0 = _mm_add_ps(data, data);
+
+	glm::simdVec4 GNI(add0);
+
+	return 0;
+}
+
+#else
+
+int main()
+{
+	int Error = 0;
+
+	return Error;
+}
+
+#endif//(GLM_ARCH != GLM_ARCH_PURE)

external/glm/test/gtx/gtx_spline.cpp

@@ -0,0 +1,130 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2012 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.
+/// 
+/// Restrictions:
+///		By making use of the Software for military purposes, you choose to make
+///		a Bunny unhappy.
+/// 
+/// 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.
+///
+/// @file test/gtx/gtx_spline.cpp
+/// @date 2013-10-25 / 2014-11-25
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#include <glm/vec2.hpp>
+#include <glm/vec3.hpp>
+#include <glm/vec4.hpp>
+#include <glm/gtx/spline.hpp>
+
+namespace catmullRom
+{
+	int test()
+	{
+		int Error(0);
+
+		glm::vec2 Result2 = glm::catmullRom(
+			glm::vec2(0.0f, 0.0f),
+			glm::vec2(1.0f, 0.0f),
+			glm::vec2(1.0f, 1.0f),
+			glm::vec2(0.0f, 1.0f), 0.5f);
+
+		glm::vec3 Result3 = glm::catmullRom(
+			glm::vec3(0.0f, 0.0f, 0.0f), 
+			glm::vec3(1.0f, 0.0f, 0.0f), 
+			glm::vec3(1.0f, 1.0f, 0.0f), 
+			glm::vec3(0.0f, 1.0f, 0.0f), 0.5f);
+
+		glm::vec4 Result4 = glm::catmullRom(
+			glm::vec4(0.0f, 0.0f, 0.0f, 1.0f), 
+			glm::vec4(1.0f, 0.0f, 0.0f, 1.0f), 
+			glm::vec4(1.0f, 1.0f, 0.0f, 1.0f), 
+			glm::vec4(0.0f, 1.0f, 0.0f, 1.0f), 0.5f);
+
+		return Error;
+	}
+}//catmullRom
+
+namespace hermite
+{
+	int test()
+	{
+		int Error(0);
+
+		glm::vec2 Result2 = glm::hermite(
+			glm::vec2(0.0f, 0.0f),
+			glm::vec2(1.0f, 0.0f),
+			glm::vec2(1.0f, 1.0f),
+			glm::vec2(0.0f, 1.0f), 0.5f);
+
+		glm::vec3 Result3 = glm::hermite(
+			glm::vec3(0.0f, 0.0f, 0.0f), 
+			glm::vec3(1.0f, 0.0f, 0.0f), 
+			glm::vec3(1.0f, 1.0f, 0.0f), 
+			glm::vec3(0.0f, 1.0f, 0.0f), 0.5f);
+
+		glm::vec4 Result4 = glm::hermite(
+			glm::vec4(0.0f, 0.0f, 0.0f, 1.0f), 
+			glm::vec4(1.0f, 0.0f, 0.0f, 1.0f), 
+			glm::vec4(1.0f, 1.0f, 0.0f, 1.0f), 
+			glm::vec4(0.0f, 1.0f, 0.0f, 1.0f), 0.5f);
+
+		return Error;
+	}
+}//catmullRom
+
+namespace cubic
+{
+	int test()
+	{
+		int Error(0);
+
+		glm::vec2 Result2 = glm::cubic(
+			glm::vec2(0.0f, 0.0f),
+			glm::vec2(1.0f, 0.0f),
+			glm::vec2(1.0f, 1.0f),
+			glm::vec2(0.0f, 1.0f), 0.5f);
+
+		glm::vec3 Result3 = glm::cubic(
+			glm::vec3(0.0f, 0.0f, 0.0f), 
+			glm::vec3(1.0f, 0.0f, 0.0f), 
+			glm::vec3(1.0f, 1.0f, 0.0f), 
+			glm::vec3(0.0f, 1.0f, 0.0f), 0.5f);
+
+		glm::vec4 Result = glm::cubic(
+			glm::vec4(0.0f, 0.0f, 0.0f, 1.0f), 
+			glm::vec4(1.0f, 0.0f, 0.0f, 1.0f), 
+			glm::vec4(1.0f, 1.0f, 0.0f, 1.0f), 
+			glm::vec4(0.0f, 1.0f, 0.0f, 1.0f), 0.5f);
+
+		return Error;
+	}
+}//catmullRom
+
+int main()
+{
+	int Error(0);
+
+	Error += catmullRom::test();
+	Error += hermite::test();
+	Error += cubic::test();
+
+	return Error;
+}

external/glm/test/gtx/gtx_string_cast.cpp

@@ -0,0 +1,159 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2012 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.
+/// 
+/// Restrictions:
+///		By making use of the Software for military purposes, you choose to make
+///		a Bunny unhappy.
+/// 
+/// 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.
+///
+/// @file test/gtx/gtx_string_cast.cpp
+/// @date 2011-09-01 / 2014-11-25
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#include <glm/glm.hpp>
+#include <glm/gtx/string_cast.hpp>
+#include <limits>
+
+int test_string_cast_vector()
+{
+	int Error = 0;
+
+	{
+		glm::vec2 A1(1, 2);
+		std::string A2 = glm::to_string(A1);
+		Error += A2 != std::string("vec2(1.000000, 2.000000)") ? 1 : 0;
+	
+		glm::vec3 B1(1, 2, 3);
+		std::string B2 = glm::to_string(B1);
+		Error += B2 != std::string("vec3(1.000000, 2.000000, 3.000000)") ? 1 : 0;
+
+		glm::vec4 C1(1, 2, 3, 4);
+		std::string C2 = glm::to_string(C1);
+		Error += C2 != std::string("vec4(1.000000, 2.000000, 3.000000, 4.000000)") ? 1 : 0;
+	
+		glm::dvec2 J1(1, 2);
+		std::string J2 = glm::to_string(J1);
+		Error += J2 != std::string("dvec2(1.000000, 2.000000)") ? 1 : 0;
+	
+		glm::dvec3 K1(1, 2, 3);
+		std::string K2 = glm::to_string(K1);
+		Error += K2 != std::string("dvec3(1.000000, 2.000000, 3.000000)") ? 1 : 0;
+	
+		glm::dvec4 L1(1, 2, 3, 4);
+		std::string L2 = glm::to_string(L1);
+		Error += L2 != std::string("dvec4(1.000000, 2.000000, 3.000000, 4.000000)") ? 1 : 0;
+	}
+
+	{
+		glm::bvec2 M1(false, true);
+		std::string M2 = glm::to_string(M1);
+		Error += M2 != std::string("bvec2(false, true)") ? 1 : 0;
+	
+		glm::bvec3 O1(false, true, false);
+		std::string O2 = glm::to_string(O1);
+		Error += O2 != std::string("bvec3(false, true, false)") ? 1 : 0;
+
+		glm::bvec4 P1(false, true, false, true);
+		std::string P2 = glm::to_string(P1);
+		Error += P2 != std::string("bvec4(false, true, false, true)") ? 1 : 0;
+	}
+
+	{
+		glm::ivec2 D1(1, 2);
+		std::string D2 = glm::to_string(D1);
+		Error += D2 != std::string("ivec2(1, 2)") ? 1 : 0;
+	
+		glm::ivec3 E1(1, 2, 3);
+		std::string E2 = glm::to_string(E1);
+		Error += E2 != std::string("ivec3(1, 2, 3)") ? 1 : 0;
+	
+		glm::ivec4 F1(1, 2, 3, 4);
+		std::string F2 = glm::to_string(F1);
+		Error += F2 != std::string("ivec4(1, 2, 3, 4)") ? 1 : 0;
+	}
+
+	{
+		glm::i8vec2 D1(1, 2);
+		std::string D2 = glm::to_string(D1);
+		Error += D2 != std::string("i8vec2(1, 2)") ? 1 : 0;
+	
+		glm::i8vec3 E1(1, 2, 3);
+		std::string E2 = glm::to_string(E1);
+		Error += E2 != std::string("i8vec3(1, 2, 3)") ? 1 : 0;
+	
+		glm::i8vec4 F1(1, 2, 3, 4);
+		std::string F2 = glm::to_string(F1);
+		Error += F2 != std::string("i8vec4(1, 2, 3, 4)") ? 1 : 0;
+	}
+
+	{
+		glm::i16vec2 D1(1, 2);
+		std::string D2 = glm::to_string(D1);
+		Error += D2 != std::string("i16vec2(1, 2)") ? 1 : 0;
+	
+		glm::i16vec3 E1(1, 2, 3);
+		std::string E2 = glm::to_string(E1);
+		Error += E2 != std::string("i16vec3(1, 2, 3)") ? 1 : 0;
+	
+		glm::i16vec4 F1(1, 2, 3, 4);
+		std::string F2 = glm::to_string(F1);
+		Error += F2 != std::string("i16vec4(1, 2, 3, 4)") ? 1 : 0;
+	}
+
+	{
+		glm::i64vec2 D1(1, 2);
+		std::string D2 = glm::to_string(D1);
+		Error += D2 != std::string("i64vec2(1, 2)") ? 1 : 0;
+	
+		glm::i64vec3 E1(1, 2, 3);
+		std::string E2 = glm::to_string(E1);
+		Error += E2 != std::string("i64vec3(1, 2, 3)") ? 1 : 0;
+	
+		glm::i64vec4 F1(1, 2, 3, 4);
+		std::string F2 = glm::to_string(F1);
+		Error += F2 != std::string("i64vec4(1, 2, 3, 4)") ? 1 : 0;
+	}
+
+	return Error;
+}
+
+int test_string_cast_matrix()
+{
+	int Error = 0;
+	
+	glm::mat2x2 A1(1.000000, 2.000000, 3.000000, 4.000000);
+	std::string A2 = glm::to_string(A1);
+	Error += A2 != std::string("mat2x2((1.000000, 2.000000), (3.000000, 4.000000))") ? 1 : 0;
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+	Error += test_string_cast_vector();
+	Error += test_string_cast_matrix();
+
+	return Error;
+}
+
+

external/glm/test/gtx/gtx_type_aligned.cpp

@@ -0,0 +1,144 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2012 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.
+/// 
+/// Restrictions:
+///		By making use of the Software for military purposes, you choose to make
+///		a Bunny unhappy.
+/// 
+/// 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.
+///
+/// @file test/gtx/gtx_type_aligned.cpp
+/// @date 2014-11-23 / 2014-11-25
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#include <glm/gtx/type_aligned.hpp>
+#include <cstdio>
+
+int test_decl()
+{
+	int Error(0);
+
+	{
+		struct S1
+		{
+			glm::aligned_vec4 B;
+		};
+
+		struct S2
+		{
+			glm::vec4 B;
+		};
+
+		printf("vec4 - Aligned: %d, unaligned: %d\n", static_cast<int>(sizeof(S1)), static_cast<int>(sizeof(S2)));
+
+		Error += sizeof(S1) >= sizeof(S2) ? 0 : 1;
+	}
+
+	{
+		struct S1
+		{
+			bool A;
+			glm::vec3 B;
+		};
+
+		struct S2
+		{
+			bool A;
+			glm::aligned_vec3 B;
+		};
+
+		printf("vec3 - Aligned: %d, unaligned: %d\n", static_cast<int>(sizeof(S1)), static_cast<int>(sizeof(S2)));
+
+		Error += sizeof(S1) <= sizeof(S2) ? 0 : 1;
+	}
+
+	{
+		struct S1
+		{
+			bool A;
+			glm::aligned_vec4 B;
+		};
+
+		struct S2
+		{
+			bool A;
+			glm::vec4 B;
+		};
+
+		printf("vec4 - Aligned: %d, unaligned: %d\n", static_cast<int>(sizeof(S1)), static_cast<int>(sizeof(S2)));
+
+		Error += sizeof(S1) >= sizeof(S2) ? 0 : 1;
+	}
+
+	{
+		struct S1
+		{
+			bool A;
+			glm::aligned_dvec4 B;
+		};
+
+		struct S2
+		{
+			bool A;
+			glm::dvec4 B;
+		};
+
+		printf("dvec4 - Aligned: %d, unaligned: %d\n", static_cast<int>(sizeof(S1)), static_cast<int>(sizeof(S2)));
+
+		Error += sizeof(S1) >= sizeof(S2) ? 0 : 1;
+	}
+
+	return Error;
+}
+
+template <typename genType>
+void print(genType const & Mat0)
+{
+	printf("mat4(\n");
+	printf("\tvec4(%2.9f, %2.9f, %2.9f, %2.9f)\n", Mat0[0][0], Mat0[0][1], Mat0[0][2], Mat0[0][3]);
+	printf("\tvec4(%2.9f, %2.9f, %2.9f, %2.9f)\n", Mat0[1][0], Mat0[1][1], Mat0[1][2], Mat0[1][3]);
+	printf("\tvec4(%2.9f, %2.9f, %2.9f, %2.9f)\n", Mat0[2][0], Mat0[2][1], Mat0[2][2], Mat0[2][3]);
+	printf("\tvec4(%2.9f, %2.9f, %2.9f, %2.9f))\n\n", Mat0[3][0], Mat0[3][1], Mat0[3][2], Mat0[3][3]);
+}
+
+int perf_mul()
+{
+	int Error = 0;
+
+	glm::mat4 A(1.0f);
+	glm::mat4 B(1.0f);
+
+	glm::mat4 C = A * B;
+
+	print(C);
+
+	return Error;
+}
+
+int main()
+{
+	int Error(0);
+
+	Error += test_decl();
+	Error += perf_mul();
+
+	return Error;
+}

external/glm/test/gtx/gtx_vector_angle.cpp

@@ -0,0 +1,89 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2012 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.
+/// 
+/// Restrictions:
+///		By making use of the Software for military purposes, you choose to make
+///		a Bunny unhappy.
+/// 
+/// 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.
+///
+/// @file test/gtx/gtx_vector_angle.cpp
+/// @date 2011-05-15 / 2014-11-25
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#include <glm/gtc/constants.hpp>
+#include <glm/gtx/vector_angle.hpp>
+#include <limits>
+
+int test_angle()
+{
+	int Error = 0;
+	
+	float AngleA = glm::angle(glm::vec2(1, 0), glm::normalize(glm::vec2(1, 1)));
+	Error += glm::epsilonEqual(AngleA, glm::pi<float>() * 0.25f, 0.01f) ? 0 : 1;
+	float AngleB = glm::angle(glm::vec3(1, 0, 0), glm::normalize(glm::vec3(1, 1, 0)));
+	Error += glm::epsilonEqual(AngleB, glm::pi<float>() * 0.25f, 0.01f) ? 0 : 1;
+	float AngleC = glm::angle(glm::vec4(1, 0, 0, 0), glm::normalize(glm::vec4(1, 1, 0, 0)));
+	Error += glm::epsilonEqual(AngleC, glm::pi<float>() * 0.25f, 0.01f) ? 0 : 1;
+
+	return Error;
+}
+
+int test_orientedAngle_vec2()
+{
+	int Error = 0;
+	
+	float AngleA = glm::orientedAngle(glm::vec2(1, 0), glm::normalize(glm::vec2(1, 1)));
+	Error += AngleA == glm::pi<float>() * 0.25f ? 0 : 1;
+	float AngleB = glm::orientedAngle(glm::vec2(0, 1), glm::normalize(glm::vec2(1, 1)));
+	Error += AngleB == -glm::pi<float>() * 0.25f ? 0 : 1;
+	float AngleC = glm::orientedAngle(glm::normalize(glm::vec2(1, 1)), glm::vec2(0, 1));
+	Error += AngleC == glm::pi<float>() * 0.25f ? 0 : 1;
+
+	return Error;
+}
+
+int test_orientedAngle_vec3()
+{
+	int Error = 0;
+	
+	float AngleA = glm::orientedAngle(glm::vec3(1, 0, 0), glm::normalize(glm::vec3(1, 1, 0)), glm::vec3(0, 0, 1));
+	Error += AngleA == glm::pi<float>() * 0.25f ? 0 : 1;
+	float AngleB = glm::orientedAngle(glm::vec3(0, 1, 0), glm::normalize(glm::vec3(1, 1, 0)), glm::vec3(0, 0, 1));
+	Error += AngleB == -glm::pi<float>() * 0.25f ? 0 : 1;
+	float AngleC = glm::orientedAngle(glm::normalize(glm::vec3(1, 1, 0)), glm::vec3(0, 1, 0), glm::vec3(0, 0, 1));
+	Error += AngleC == glm::pi<float>() * 0.25f ? 0 : 1;
+
+	return Error;
+}
+
+int main()
+{
+	int Error(0);
+	
+	Error += test_angle();
+	Error += test_orientedAngle_vec2();
+	Error += test_orientedAngle_vec3();
+
+	return Error;
+}
+
+

external/glm/test/gtx/gtx_vector_query.cpp

@@ -0,0 +1,112 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2012 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.
+/// 
+/// Restrictions:
+///		By making use of the Software for military purposes, you choose to make
+///		a Bunny unhappy.
+/// 
+/// 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.
+///
+/// @file test/gtx/gtx_vector_query.cpp
+/// @date 2011-11-23 / 2014-11-25
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#include <glm/vec2.hpp>
+#include <glm/vec3.hpp>
+#include <glm/vec4.hpp>
+#include <glm/gtx/vector_query.hpp>
+
+int test_areCollinear()
+{
+	int Error(0);
+
+	{
+		bool TestA = glm::areCollinear(glm::vec2(-1), glm::vec2(1), 0.00001f);
+		Error += TestA ? 0 : 1;
+	}
+
+	{
+		bool TestA = glm::areCollinear(glm::vec3(-1), glm::vec3(1), 0.00001f);
+		Error += TestA ? 0 : 1;
+	}
+
+	{
+		bool TestA = glm::areCollinear(glm::vec4(-1), glm::vec4(1), 0.00001f);
+		Error += TestA ? 0 : 1;
+	}
+
+	return Error;
+}
+
+int test_areOrthogonal()
+{
+	int Error(0);
+	
+	bool TestA = glm::areOrthogonal(glm::vec2(1, 0), glm::vec2(0, 1), 0.00001f);
+	Error += TestA ? 0 : 1;
+
+	return Error;
+}
+
+int test_isNormalized()
+{
+	int Error(0);
+	
+	bool TestA = glm::isNormalized(glm::vec4(1, 0, 0, 0), 0.00001f);
+	Error += TestA ? 0 : 1;
+
+	return Error;
+}
+
+int test_isNull()
+{
+	int Error(0);
+	
+	bool TestA = glm::isNull(glm::vec4(0), 0.00001f);
+	Error += TestA ? 0 : 1;
+
+	return Error;
+}
+
+int test_areOrthonormal()
+{
+	int Error(0);
+
+	bool TestA = glm::areOrthonormal(glm::vec2(1, 0), glm::vec2(0, 1), 0.00001f);
+	Error += TestA ? 0 : 1;
+
+	return Error;
+}
+
+int main()
+{
+	int Error(0);
+
+	Error += test_areCollinear();
+	Error += test_areOrthogonal();
+	Error += test_isNormalized();
+	Error += test_isNull();
+	Error += test_areOrthonormal();
+
+	return Error;
+}
+
+

external/glm/test/gtx/gtx_wrap.cpp

@@ -0,0 +1,172 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2015 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.
+/// 
+/// Restrictions:
+///		By making use of the Software for military purposes, you choose to make
+///		a Bunny unhappy.
+/// 
+/// 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.
+///
+/// @file test/gtx/gtx_normal.cpp
+/// @date 2013-10-25 / 2014-11-25
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#include <glm/gtx/wrap.hpp>
+#include <glm/gtc/epsilon.hpp>
+
+namespace clamp
+{
+	int test()
+	{
+		int Error(0);
+
+		float A = glm::clamp(0.5f);
+		Error += glm::epsilonEqual(A, 0.5f, 0.00001f) ? 0 : 1;
+
+		float B = glm::clamp(0.0f);
+		Error += glm::epsilonEqual(B, 0.0f, 0.00001f) ? 0 : 1;
+
+		float C = glm::clamp(1.0f);
+		Error += glm::epsilonEqual(C, 1.0f, 0.00001f) ? 0 : 1;
+
+		float D = glm::clamp(-0.5f);
+		Error += glm::epsilonEqual(D, 0.0f, 0.00001f) ? 0 : 1;
+
+		float E = glm::clamp(1.5f);
+		Error += glm::epsilonEqual(E, 1.0f, 0.00001f) ? 0 : 1;
+
+		return Error;
+	}
+}//namespace clamp
+
+namespace repeat
+{
+	int test()
+	{
+		int Error(0);
+
+		float A = glm::repeat(0.5f);
+		Error += glm::epsilonEqual(A, 0.5f, 0.00001f) ? 0 : 1;
+
+		float B = glm::repeat(0.0f);
+		Error += glm::epsilonEqual(B, 0.0f, 0.00001f) ? 0 : 1;
+
+		float C = glm::repeat(1.0f);
+		Error += glm::epsilonEqual(C, 0.0f, 0.00001f) ? 0 : 1;
+
+		float D = glm::repeat(-0.5f);
+		Error += glm::epsilonEqual(D, 0.5f, 0.00001f) ? 0 : 1;
+
+		float E = glm::repeat(1.5f);
+		Error += glm::epsilonEqual(E, 0.5f, 0.00001f) ? 0 : 1;
+
+		float F = glm::repeat(0.9f);
+		Error += glm::epsilonEqual(F, 0.9f, 0.00001f) ? 0 : 1;
+
+		return Error;
+	}
+}//namespace repeat
+
+namespace mirrorClamp
+{
+	int test()
+	{
+		int Error(0);
+
+		float A = glm::mirrorClamp(0.5f);
+		Error += glm::epsilonEqual(A, 0.5f, 0.00001f) ? 0 : 1;
+
+		float B = glm::mirrorClamp(0.0f);
+		Error += glm::epsilonEqual(B, 0.0f, 0.00001f) ? 0 : 1;
+
+		float C = glm::mirrorClamp(1.1f);
+		Error += glm::epsilonEqual(C, 0.1f, 0.00001f) ? 0 : 1;
+
+		float D = glm::mirrorClamp(-0.5f);
+		Error += glm::epsilonEqual(D, 0.5f, 0.00001f) ? 0 : 1;
+
+		float E = glm::mirrorClamp(1.5f);
+		Error += glm::epsilonEqual(E, 0.5f, 0.00001f) ? 0 : 1;
+
+		float F = glm::mirrorClamp(0.9f);
+		Error += glm::epsilonEqual(F, 0.9f, 0.00001f) ? 0 : 1;
+
+		float G = glm::mirrorClamp(3.1f);
+		Error += glm::epsilonEqual(G, 0.1f, 0.00001f) ? 0 : 1;
+
+		float H = glm::mirrorClamp(-3.1f);
+		Error += glm::epsilonEqual(H, 0.1f, 0.00001f) ? 0 : 1;
+
+		float I = glm::mirrorClamp(-0.9f);
+		Error += glm::epsilonEqual(I, 0.9f, 0.00001f) ? 0 : 1;
+
+		return Error;
+	}
+}//namespace mirrorClamp
+
+namespace mirrorRepeat
+{
+	int test()
+	{
+		int Error(0);
+
+		float A = glm::mirrorRepeat(0.5f);
+		Error += glm::epsilonEqual(A, 0.5f, 0.00001f) ? 0 : 1;
+
+		float B = glm::mirrorRepeat(0.0f);
+		Error += glm::epsilonEqual(B, 0.0f, 0.00001f) ? 0 : 1;
+
+		float C = glm::mirrorRepeat(1.0f);
+		Error += glm::epsilonEqual(C, 1.0f, 0.00001f) ? 0 : 1;
+
+		float D = glm::mirrorRepeat(-0.5f);
+		Error += glm::epsilonEqual(D, 0.5f, 0.00001f) ? 0 : 1;
+
+		float E = glm::mirrorRepeat(1.5f);
+		Error += glm::epsilonEqual(E, 0.5f, 0.00001f) ? 0 : 1;
+
+		float F = glm::mirrorRepeat(0.9f);
+		Error += glm::epsilonEqual(F, 0.9f, 0.00001f) ? 0 : 1;
+
+		float G = glm::mirrorRepeat(3.0f);
+		Error += glm::epsilonEqual(G, 1.0f, 0.00001f) ? 0 : 1;
+
+		float H = glm::mirrorRepeat(-3.0f);
+		Error += glm::epsilonEqual(H, 1.0f, 0.00001f) ? 0 : 1;
+
+		float I = glm::mirrorRepeat(-1.0f);
+		Error += glm::epsilonEqual(I, 1.0f, 0.00001f) ? 0 : 1;
+
+		return Error;
+	}
+}//namespace mirrorRepeat
+
+int main()
+{
+	int Error(0);
+
+	Error += clamp::test();
+	Error += repeat::test();
+	Error += mirrorClamp::test();
+	Error += mirrorRepeat::test();
+
+	return Error;
+}