Changeset: 35 Fix missing sources in git submodules after migration to PlasticSCM

216 files changed, 29882 insertions, 0 deletions

diff --git a/3rdparty/glm/source/test/CMakeLists.txt b/3rdparty/glm/source/test/CMakeLists.txt
new file mode 100644
index 0000000..e7f85f1
--- /dev/null
+++ b/3rdparty/glm/source/test/CMakeLists.txt
@@ -0,0 +1,246 @@
+option(GLM_QUIET "No CMake Message" OFF)
+option(BUILD_SHARED_LIBS "Build shared library" ON)
+option(BUILD_STATIC_LIBS "Build static library" ON)
+option(GLM_TEST_ENABLE_CXX_98 "Enable C++ 98" OFF)
+option(GLM_TEST_ENABLE_CXX_11 "Enable C++ 11" OFF)
+option(GLM_TEST_ENABLE_CXX_14 "Enable C++ 14" OFF)
+option(GLM_TEST_ENABLE_CXX_17 "Enable C++ 17" OFF)
+option(GLM_TEST_ENABLE_CXX_20 "Enable C++ 20" OFF)
+
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+if(GLM_TEST_ENABLE_CXX_20)
+	set(CMAKE_CXX_STANDARD 20)
+	add_definitions(-DGLM_FORCE_CXX2A)
+	if(NOT GLM_QUIET)
+		message(STATUS "GLM: Build with C++20 features")
+	endif()
+
+elseif(GLM_TEST_ENABLE_CXX_17)
+	set(CMAKE_CXX_STANDARD 17)
+	add_definitions(-DGLM_FORCE_CXX17)
+	if(NOT GLM_QUIET)
+		message(STATUS "GLM: Build with C++17 features")
+	endif()
+
+elseif(GLM_TEST_ENABLE_CXX_14)
+	set(CMAKE_CXX_STANDARD 14)
+	add_definitions(-DGLM_FORCE_CXX14)
+	if(NOT GLM_QUIET)
+		message(STATUS "GLM: Build with C++14 features")
+	endif()
+
+elseif(GLM_TEST_ENABLE_CXX_11)
+	set(CMAKE_CXX_STANDARD 11)
+	add_definitions(-DGLM_FORCE_CXX11)
+	if(NOT GLM_QUIET)
+		message(STATUS "GLM: Build with C++11 features")
+	endif()
+
+elseif(GLM_TEST_ENABLE_CXX_98)
+	set(CMAKE_CXX_STANDARD 98)
+	add_definitions(-DGLM_FORCE_CXX98)
+	if(NOT GLM_QUIET)
+		message(STATUS "GLM: Build with C++98 features")
+	endif()
+endif()
+
+option(GLM_TEST_ENABLE_LANG_EXTENSIONS "Enable language extensions" OFF)
+
+option(GLM_DISABLE_AUTO_DETECTION "Enable language extensions" OFF)
+
+if(GLM_DISABLE_AUTO_DETECTION)
+	add_definitions(-DGLM_FORCE_PLATFORM_UNKNOWN -DGLM_FORCE_COMPILER_UNKNOWN -DGLM_FORCE_ARCH_UNKNOWN -DGLM_FORCE_CXX_UNKNOWN)
+endif()
+
+if(GLM_TEST_ENABLE_LANG_EXTENSIONS)
+	set(CMAKE_CXX_EXTENSIONS ON)
+	if((CMAKE_CXX_COMPILER_ID MATCHES "Clang") OR (CMAKE_CXX_COMPILER_ID MATCHES "GNU"))
+		add_compile_options(-fms-extensions)
+	endif()
+	message(STATUS "GLM: Build with C++ language extensions")
+else()
+	set(CMAKE_CXX_EXTENSIONS OFF)
+	if(CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
+		add_compile_options(/Za)
+		if(MSVC15)
+			add_compile_options(/permissive-)
+		endif()
+	endif()
+endif()
+
+option(GLM_TEST_ENABLE_FAST_MATH "Enable fast math optimizations" OFF)
+if(GLM_TEST_ENABLE_FAST_MATH)
+	if(NOT GLM_QUIET)
+		message(STATUS "GLM: Build with fast math optimizations")
+	endif()
+
+	if((CMAKE_CXX_COMPILER_ID MATCHES "Clang") OR (CMAKE_CXX_COMPILER_ID MATCHES "GNU"))
+		add_compile_options(-ffast-math)
+
+	elseif(CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
+		add_compile_options(/fp:fast)
+	endif()
+else()
+	if(CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
+		add_compile_options(/fp:precise)
+	endif()
+endif()
+
+option(GLM_TEST_ENABLE "Build unit tests" ON)
+option(GLM_TEST_ENABLE_SIMD_SSE2 "Enable SSE2 optimizations" OFF)
+option(GLM_TEST_ENABLE_SIMD_SSE3 "Enable SSE3 optimizations" OFF)
+option(GLM_TEST_ENABLE_SIMD_SSSE3 "Enable SSSE3 optimizations" OFF)
+option(GLM_TEST_ENABLE_SIMD_SSE4_1 "Enable SSE 4.1 optimizations" OFF)
+option(GLM_TEST_ENABLE_SIMD_SSE4_2 "Enable SSE 4.2 optimizations" OFF)
+option(GLM_TEST_ENABLE_SIMD_AVX "Enable AVX optimizations" OFF)
+option(GLM_TEST_ENABLE_SIMD_AVX2 "Enable AVX2 optimizations" OFF)
+option(GLM_TEST_FORCE_PURE "Force 'pure' instructions" OFF)
+
+if(GLM_TEST_FORCE_PURE)
+	add_definitions(-DGLM_FORCE_PURE)
+
+	if(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
+		add_compile_options(-mfpmath=387)
+	endif()
+	message(STATUS "GLM: No SIMD instruction set")
+
+elseif(GLM_TEST_ENABLE_SIMD_AVX2)
+	add_definitions(-DGLM_FORCE_INTRINSICS)
+
+	if((CMAKE_CXX_COMPILER_ID MATCHES "GNU") OR (CMAKE_CXX_COMPILER_ID MATCHES "Clang"))
+		add_compile_options(-mavx2)
+	elseif(CMAKE_CXX_COMPILER_ID MATCHES "Intel")
+		add_compile_options(/QxAVX2)
+	elseif(CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
+		add_compile_options(/arch:AVX2)
+	endif()
+	message(STATUS "GLM: AVX2 instruction set")
+
+elseif(GLM_TEST_ENABLE_SIMD_AVX)
+	add_definitions(-DGLM_FORCE_INTRINSICS)
+
+	if((CMAKE_CXX_COMPILER_ID MATCHES "GNU") OR (CMAKE_CXX_COMPILER_ID MATCHES "Clang"))
+		add_compile_options(-mavx)
+	elseif(CMAKE_CXX_COMPILER_ID MATCHES "Intel")
+		add_compile_options(/QxAVX)
+	elseif(CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
+		add_compile_options(/arch:AVX)
+	endif()
+	message(STATUS "GLM: AVX instruction set")
+
+elseif(GLM_TEST_ENABLE_SIMD_SSE4_2)
+	add_definitions(-DGLM_FORCE_INTRINSICS)
+
+	if((CMAKE_CXX_COMPILER_ID MATCHES "GNU") OR (CMAKE_CXX_COMPILER_ID MATCHES "Clang"))
+		add_compile_options(-msse4.2)
+	elseif(CMAKE_CXX_COMPILER_ID MATCHES "Intel")
+		add_compile_options(/QxSSE4.2)
+	elseif((CMAKE_CXX_COMPILER_ID MATCHES "MSVC") AND NOT CMAKE_CL_64)
+		add_compile_options(/arch:SSE2) # VC doesn't support SSE4.2
+	endif()
+	message(STATUS "GLM: SSE4.2 instruction set")
+
+elseif(GLM_TEST_ENABLE_SIMD_SSE4_1)
+	add_definitions(-DGLM_FORCE_INTRINSICS)
+
+	if((CMAKE_CXX_COMPILER_ID MATCHES "GNU") OR (CMAKE_CXX_COMPILER_ID MATCHES "Clang"))
+		add_compile_options(-msse4.1)
+	elseif(CMAKE_CXX_COMPILER_ID MATCHES "Intel")
+		add_compile_options(/QxSSE4.1)
+	elseif((CMAKE_CXX_COMPILER_ID MATCHES "MSVC") AND NOT CMAKE_CL_64)
+		add_compile_options(/arch:SSE2) # VC doesn't support SSE4.1
+	endif()
+	message(STATUS "GLM: SSE4.1 instruction set")
+
+elseif(GLM_TEST_ENABLE_SIMD_SSSE3)
+	add_definitions(-DGLM_FORCE_INTRINSICS)
+
+	if((CMAKE_CXX_COMPILER_ID MATCHES "GNU") OR (CMAKE_CXX_COMPILER_ID MATCHES "Clang"))
+		add_compile_options(-mssse3)
+	elseif(CMAKE_CXX_COMPILER_ID MATCHES "Intel")
+		add_compile_options(/QxSSSE3)
+	elseif((CMAKE_CXX_COMPILER_ID MATCHES "MSVC") AND NOT CMAKE_CL_64)
+		add_compile_options(/arch:SSE2) # VC doesn't support SSSE3
+	endif()
+	message(STATUS "GLM: SSSE3 instruction set")
+
+elseif(GLM_TEST_ENABLE_SIMD_SSE3)
+	add_definitions(-DGLM_FORCE_INTRINSICS)
+
+	if((CMAKE_CXX_COMPILER_ID MATCHES "GNU") OR (CMAKE_CXX_COMPILER_ID MATCHES "Clang"))
+		add_compile_options(-msse3)
+	elseif(CMAKE_CXX_COMPILER_ID MATCHES "Intel")
+		add_compile_options(/QxSSE3)
+	elseif((CMAKE_CXX_COMPILER_ID MATCHES "MSVC") AND NOT CMAKE_CL_64)
+		add_compile_options(/arch:SSE2) # VC doesn't support SSE3
+	endif()
+	message(STATUS "GLM: SSE3 instruction set")
+
+elseif(GLM_TEST_ENABLE_SIMD_SSE2)
+	add_definitions(-DGLM_FORCE_INTRINSICS)
+
+	if((CMAKE_CXX_COMPILER_ID MATCHES "GNU") OR (CMAKE_CXX_COMPILER_ID MATCHES "Clang"))
+		add_compile_options(-msse2)
+	elseif(CMAKE_CXX_COMPILER_ID MATCHES "Intel")
+		add_compile_options(/QxSSE2)
+	elseif((CMAKE_CXX_COMPILER_ID MATCHES "MSVC") AND NOT CMAKE_CL_64)
+		add_compile_options(/arch:SSE2)
+	endif()
+	message(STATUS "GLM: SSE2 instruction set")
+endif()
+
+# Compiler and default options
+
+if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+	if(NOT GLM_QUIET)
+		message("GLM: Clang - ${CMAKE_CXX_COMPILER_ID} compiler")
+	endif()
+
+	add_compile_options(-Werror -Weverything)
+	add_compile_options(-Wno-c++98-compat -Wno-c++98-compat-pedantic -Wno-c++11-long-long -Wno-padded -Wno-gnu-anonymous-struct -Wno-nested-anon-types)
+	add_compile_options(-Wno-undefined-reinterpret-cast -Wno-sign-conversion -Wno-unused-variable -Wno-missing-prototypes -Wno-unreachable-code -Wno-missing-variable-declarations -Wno-sign-compare -Wno-global-constructors -Wno-unused-macros -Wno-format-nonliteral)
+
+elseif(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
+	if(NOT GLM_QUIET)
+		message("GLM: GCC - ${CMAKE_CXX_COMPILER_ID} compiler")
+	endif()
+
+	add_compile_options(-O2)
+	add_compile_options(-Wno-long-long)
+
+elseif(CMAKE_CXX_COMPILER_ID MATCHES "Intel")
+	if(NOT GLM_QUIET)
+		message("GLM: Intel - ${CMAKE_CXX_COMPILER_ID} compiler")
+	endif()
+
+elseif(CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
+	if(NOT GLM_QUIET)
+		message("GLM: Visual C++ - ${CMAKE_CXX_COMPILER_ID} compiler")
+	endif()
+
+	add_compile_options(/W4 /WX)
+	add_compile_options(/wd4309 /wd4324 /wd4389 /wd4127 /wd4267 /wd4146 /wd4201 /wd4464 /wd4514 /wd4701 /wd4820 /wd4365)
+	add_definitions(-D_CRT_SECURE_NO_WARNINGS)
+endif()
+
+function(glmCreateTestGTC NAME)
+	set(SAMPLE_NAME test-${NAME})
+	add_executable(${SAMPLE_NAME} ${NAME}.cpp)
+
+	add_test(
+		NAME ${SAMPLE_NAME}
+		COMMAND $<TARGET_FILE:${SAMPLE_NAME}> )
+	target_link_libraries(${SAMPLE_NAME} PRIVATE glm::glm)
+endfunction()
+
+if(GLM_TEST_ENABLE)
+	add_subdirectory(bug)
+	add_subdirectory(core)
+	add_subdirectory(ext)
+	add_subdirectory(gtc)
+	add_subdirectory(gtx)
+	add_subdirectory(perf)
+endif()
+
+
diff --git a/3rdparty/glm/source/test/bug/CMakeLists.txt b/3rdparty/glm/source/test/bug/CMakeLists.txt
new file mode 100644
index 0000000..26e8569
--- /dev/null
+++ b/3rdparty/glm/source/test/bug/CMakeLists.txt
@@ -0,0 +1 @@
+glmCreateTestGTC(bug_ms_vec_static)
diff --git a/3rdparty/glm/source/test/bug/bug_ms_vec_static.cpp b/3rdparty/glm/source/test/bug/bug_ms_vec_static.cpp
new file mode 100644
index 0000000..7f44e40
--- /dev/null
+++ b/3rdparty/glm/source/test/bug/bug_ms_vec_static.cpp
@@ -0,0 +1,31 @@
+#include <glm/glm.hpp>
+
+#if GLM_CONFIG_ANONYMOUS_STRUCT == GLM_ENABLE
+struct vec2;
+
+struct _swizzle
+{
+	char _buffer[1];
+};
+
+struct vec2
+{
+	GLM_CONSTEXPR vec2() :
+		x(0), y(0)
+	{}
+
+	union
+	{
+		struct { float x, y; };
+		struct { _swizzle xx; };
+	};
+};
+#endif
+
+// Visual C++ has a bug generating the error: fatal error C1001: An internal error has occurred in the compiler.
+// vec2 Bar;
+
+int main()
+{
+	return 0;
+}
diff --git a/3rdparty/glm/source/test/cmake/CMakeLists.txt b/3rdparty/glm/source/test/cmake/CMakeLists.txt
new file mode 100644
index 0000000..5bc11ef
--- /dev/null
+++ b/3rdparty/glm/source/test/cmake/CMakeLists.txt
@@ -0,0 +1,8 @@
+cmake_minimum_required(VERSION 3.2 FATAL_ERROR)
+project(test_find_glm)
+
+find_package(glm REQUIRED)
+
+add_executable(test_find_glm test_find_glm.cpp)
+target_link_libraries(test_find_glm glm::glm)
+
diff --git a/3rdparty/glm/source/test/cmake/test_find_glm.cpp b/3rdparty/glm/source/test/cmake/test_find_glm.cpp
new file mode 100644
index 0000000..361b977
--- /dev/null
+++ b/3rdparty/glm/source/test/cmake/test_find_glm.cpp
@@ -0,0 +1,22 @@
+#include <iostream>
+#include <glm/glm.hpp>
+#include <glm/ext.hpp>
+
+glm::mat4 camera(float Translate, glm::vec2 const& Rotate)
+{
+	glm::mat4 Projection = glm::perspective(glm::pi<float>() * 0.25f, 4.0f / 3.0f, 0.1f, 100.f);
+	glm::mat4 View = glm::translate(glm::mat4(1.0f), glm::vec3(0.0f, 0.0f, -Translate));
+	View = glm::rotate(View, Rotate.y, glm::vec3(-1.0f, 0.0f, 0.0f));
+	View = glm::rotate(View, Rotate.x, glm::vec3(0.0f, 1.0f, 0.0f));
+	glm::mat4 Model = glm::scale(glm::mat4(1.0f), glm::vec3(0.5f));
+	return Projection * View * Model;
+}
+
+int main()
+{
+    const glm::mat4 m = camera(1.f, glm::vec2(1.f, 0.5f));
+    std::cout << "matrix diagonal: " << m[0][0] << ", "
+              << m[1][1] << ", " << m[2][2] << ", " << m[3][3] << "\n";
+    return 0;
+}
+
diff --git a/3rdparty/glm/source/test/core/CMakeLists.txt b/3rdparty/glm/source/test/core/CMakeLists.txt
new file mode 100644
index 0000000..6cd57b1
--- /dev/null
+++ b/3rdparty/glm/source/test/core/CMakeLists.txt
@@ -0,0 +1,52 @@
+glmCreateTestGTC(core_cpp_constexpr)
+glmCreateTestGTC(core_cpp_defaulted_ctor)
+glmCreateTestGTC(core_force_aligned_gentypes)
+glmCreateTestGTC(core_force_ctor_init)
+glmCreateTestGTC(core_force_cxx03)
+glmCreateTestGTC(core_force_cxx98)
+glmCreateTestGTC(core_force_arch_unknown)
+glmCreateTestGTC(core_force_compiler_unknown)
+glmCreateTestGTC(core_force_cxx_unknown)
+glmCreateTestGTC(core_force_explicit_ctor)
+glmCreateTestGTC(core_force_inline)
+glmCreateTestGTC(core_force_platform_unknown)
+glmCreateTestGTC(core_force_pure)
+glmCreateTestGTC(core_force_unrestricted_gentype)
+glmCreateTestGTC(core_force_xyzw_only)
+glmCreateTestGTC(core_force_quat_xyzw)
+glmCreateTestGTC(core_type_aligned)
+glmCreateTestGTC(core_type_cast)
+glmCreateTestGTC(core_type_ctor)
+glmCreateTestGTC(core_type_int)
+glmCreateTestGTC(core_type_length)
+glmCreateTestGTC(core_type_mat2x2)
+glmCreateTestGTC(core_type_mat2x3)
+glmCreateTestGTC(core_type_mat2x4)
+glmCreateTestGTC(core_type_mat3x2)
+glmCreateTestGTC(core_type_mat3x3)
+glmCreateTestGTC(core_type_mat3x4)
+glmCreateTestGTC(core_type_mat4x2)
+glmCreateTestGTC(core_type_mat4x3)
+glmCreateTestGTC(core_type_mat4x4)
+glmCreateTestGTC(core_type_vec1)
+glmCreateTestGTC(core_type_vec2)
+glmCreateTestGTC(core_type_vec3)
+glmCreateTestGTC(core_type_vec4)
+glmCreateTestGTC(core_func_common)
+glmCreateTestGTC(core_func_exponential)
+glmCreateTestGTC(core_func_geometric)
+glmCreateTestGTC(core_func_integer)
+glmCreateTestGTC(core_func_integer_bit_count)
+glmCreateTestGTC(core_func_integer_find_lsb)
+glmCreateTestGTC(core_func_integer_find_msb)
+glmCreateTestGTC(core_func_matrix)
+glmCreateTestGTC(core_func_noise)
+glmCreateTestGTC(core_func_packing)
+glmCreateTestGTC(core_func_trigonometric)
+glmCreateTestGTC(core_func_vector_relational)
+glmCreateTestGTC(core_func_swizzle)
+glmCreateTestGTC(core_setup_force_cxx98)
+glmCreateTestGTC(core_setup_force_size_t_length)
+glmCreateTestGTC(core_setup_message)
+glmCreateTestGTC(core_setup_platform_unknown)
+glmCreateTestGTC(core_setup_precision)
diff --git a/3rdparty/glm/source/test/core/core_cpp_constexpr.cpp b/3rdparty/glm/source/test/core/core_cpp_constexpr.cpp
new file mode 100644
index 0000000..3dc0a92
--- /dev/null
+++ b/3rdparty/glm/source/test/core/core_cpp_constexpr.cpp
@@ -0,0 +1,750 @@
+#include <glm/glm.hpp>
+
+#if GLM_CONFIG_CONSTEXP == GLM_ENABLE
+
+#include <glm/gtc/constants.hpp>
+#include <glm/gtc/quaternion.hpp>
+#include <glm/ext/vector_relational.hpp>
+#include <glm/ext/vector_int1.hpp>
+#include <glm/ext/vector_bool1.hpp>
+#include <glm/ext/vector_bool4.hpp>
+#include <glm/ext/vector_float1.hpp>
+#include <glm/vector_relational.hpp>
+
+static int test_vec1()
+{
+	int Error = 0;
+
+	{
+		constexpr glm::bvec1 B(true);
+		constexpr bool A = glm::all(B);
+		static_assert(A, "GLM: Failed constexpr");
+		
+		constexpr glm::bvec1 D(true);
+		constexpr bool C = glm::any(D);
+		static_assert(C, "GLM: Failed constexpr");
+	}
+	
+	{
+		constexpr glm::bvec2 C(true);
+		constexpr glm::bvec2 B(true);
+		static_assert(glm::any(glm::equal(C, B)), "GLM: Failed constexpr");
+	}
+	
+	{
+		constexpr glm::ivec1 O(glm::ivec1(1));
+		static_assert(glm::ivec1(1) == O, "GLM: Failed constexpr");
+
+		constexpr glm::ivec1 P(1);
+		static_assert(glm::ivec1(1) == P, "GLM: Failed constexpr");
+	}
+
+	{
+		constexpr glm::ivec1 L(glm::ivec2(1, 2));
+		static_assert(glm::ivec1(1) == L, "GLM: Failed constexpr");
+
+		constexpr glm::ivec1 M(glm::ivec3(1, 2, 3));
+		static_assert(glm::ivec1(1) == M, "GLM: Failed constexpr");
+
+		constexpr glm::ivec1 N(glm::ivec4(1, 2, 3, 4));
+		static_assert(glm::ivec1(1) == N, "GLM: Failed constexpr");
+	}
+
+	{
+		constexpr glm::ivec1 A(1);
+		static_assert(A[0] == 1, "GLM: Failed constexpr");
+		static_assert(glm::vec1(1.0f).x > 0.0f, "GLM: Failed constexpr");
+		static_assert(glm::vec1::length() == 1, "GLM: Failed constexpr");
+	}
+
+	{
+		constexpr glm::bvec1 A1(true);
+		constexpr glm::bvec1 A2(true);
+		constexpr glm::bvec1 B1(false);
+		constexpr glm::bvec1 B2(false);
+		static_assert(A1 == A2 && B1 == B2, "GLM: Failed constexpr");
+		static_assert(A1 == A2 || B1 == B2, "GLM: Failed constexpr");
+	}
+
+	{
+		constexpr glm::ivec1 A(1);
+		constexpr glm::ivec1 B = A + 1;
+		constexpr glm::ivec1 C(3);
+		static_assert(A + B == C, "GLM: Failed constexpr");
+
+		constexpr glm::ivec1 D = +A;
+		static_assert(D == A, "GLM: Failed constexpr");
+	}
+
+	{
+		constexpr glm::ivec1 A(3);
+		constexpr glm::ivec1 B = A - 1;
+		constexpr glm::ivec1 C(1);
+		static_assert(A - B == C, "GLM: Failed constexpr");
+
+		constexpr glm::ivec1 D = -A;
+		static_assert(-D == A, "GLM: Failed constexpr");
+	}
+
+	{
+		constexpr glm::ivec1 A(3);
+		constexpr glm::ivec1 B = A * 1;
+		static_assert(A == B, "GLM: Failed constexpr");
+
+		constexpr glm::ivec1 C(1);
+		static_assert(B * C == A, "GLM: Failed constexpr");
+	}
+
+	{
+		constexpr glm::ivec1 A(3);
+		constexpr glm::ivec1 B = A / 1;
+		static_assert(A == B, "GLM: Failed constexpr");
+
+		constexpr glm::ivec1 C(1);
+		static_assert(B / C == A, "GLM: Failed constexpr");
+	}
+
+	{
+		constexpr glm::ivec1 A(3);
+		constexpr glm::ivec1 B = A % 2;
+		constexpr glm::ivec1 C(1);
+		static_assert(B == C, "GLM: Failed constexpr");
+
+		constexpr glm::ivec1 D(2);
+		static_assert(A % D == C, "GLM: Failed constexpr");
+	}
+
+	{
+		constexpr glm::ivec1 A(1);
+		constexpr glm::ivec1 B = A & 1;
+		static_assert(A == B, "GLM: Failed constexpr");
+
+		constexpr glm::ivec1 C(1);
+		static_assert(A == (A & C), "GLM: Failed constexpr");
+	}
+
+	{
+		constexpr glm::ivec1 A(1);
+		constexpr glm::ivec1 B = A | 1;
+		static_assert(A == B, "GLM: Failed constexpr");
+
+		constexpr glm::ivec1 C(1);
+		static_assert(A == (A | C), "GLM: Failed constexpr");
+	}
+
+	{
+		constexpr glm::ivec1 A(1);
+		constexpr glm::ivec1 B = A ^ 0;
+		static_assert(A == B, "GLM: Failed constexpr");
+
+		constexpr glm::ivec1 C(0);
+		static_assert(A == (A ^ C), "GLM: Failed constexpr");
+	}
+
+	{
+		constexpr glm::ivec1 A(1);
+		constexpr glm::ivec1 B = A << 1;
+		static_assert(B == glm::ivec1(2), "GLM: Failed constexpr");
+
+		constexpr glm::ivec1 C(1);
+		static_assert(B == (A << C), "GLM: Failed constexpr");
+	}
+
+	{
+		constexpr glm::ivec1 A(2);
+		constexpr glm::ivec1 B = A >> 1;
+		static_assert(B == glm::ivec1(1), "GLM: Failed constexpr");
+
+		constexpr glm::ivec1 C(1);
+		static_assert(B == A >> C, "GLM: Failed constexpr");
+	}
+
+	{
+		constexpr glm::ivec1 A(~0);
+		constexpr glm::ivec1 B = ~A;
+		static_assert(A == ~B, "GLM: Failed constexpr");
+	}
+
+	return Error;
+}
+
+static int test_vec2()
+{
+	int Error = 0;
+
+	{
+		constexpr glm::bvec2 B(true);
+		constexpr bool A = glm::all(B);
+		static_assert(A, "GLM: Failed constexpr");
+		
+		constexpr glm::bvec2 D(true, false);
+		constexpr bool C = glm::any(D);
+		static_assert(C, "GLM: Failed constexpr");
+	}
+	
+	{
+		constexpr glm::bvec2 C(true);
+		constexpr glm::bvec2 B(true, false);
+		static_assert(glm::any(glm::equal(C, B)), "GLM: Failed constexpr");
+	}
+	
+	{
+		constexpr glm::ivec2 O(glm::ivec1(1));
+		static_assert(glm::ivec2(1) == O, "GLM: Failed constexpr");
+
+		constexpr glm::ivec2 A(1);
+		static_assert(glm::ivec2(1) == A, "GLM: Failed constexpr");
+	}
+
+	{
+		constexpr glm::ivec2 F(glm::ivec1(1), glm::ivec1(2));
+		static_assert(glm::ivec2(1, 2) == F, "GLM: Failed constexpr");
+
+		constexpr glm::ivec2 G(1, glm::ivec1(2));
+		static_assert(glm::ivec2(1, 2) == G, "GLM: Failed constexpr");
+
+		constexpr glm::ivec2 H(glm::ivec1(1), 2);
+		static_assert(glm::ivec2(1, 2) == H, "GLM: Failed constexpr");
+
+		constexpr glm::ivec2 I(1, 2);
+		static_assert(glm::ivec2(1, 2) == I, "GLM: Failed constexpr");
+	}
+
+	{
+		constexpr glm::ivec2 L(glm::ivec2(1, 2));
+		static_assert(glm::ivec2(1, 2) == L, "GLM: Failed constexpr");
+
+		constexpr glm::ivec2 M(glm::ivec3(1, 2, 3));
+		static_assert(glm::ivec2(1, 2) == M, "GLM: Failed constexpr");
+
+		constexpr glm::ivec2 N(glm::ivec4(1, 2, 3, 4));
+		static_assert(glm::ivec2(1, 2) == N, "GLM: Failed constexpr");
+	}
+
+	{
+		constexpr glm::ivec2 A(1);
+		static_assert(A[0] == 1, "GLM: Failed constexpr");
+		static_assert(glm::vec2(1.0f).x > 0.0f, "GLM: Failed constexpr");
+		static_assert(glm::vec2(1.0f, -1.0f).x > 0.0f, "GLM: Failed constexpr");
+		static_assert(glm::vec2(1.0f, -1.0f).y < 0.0f, "GLM: Failed constexpr");
+		static_assert(glm::vec2::length() == 2, "GLM: Failed constexpr");
+	}
+
+	{
+		constexpr glm::bvec2 A1(true);
+		constexpr glm::bvec2 A2(true);
+		constexpr glm::bvec2 B1(false);
+		constexpr glm::bvec2 B2(false);
+		static_assert(A1 == A2 && B1 == B2, "GLM: Failed constexpr");
+		static_assert(A1 == A2 || B1 == B2, "GLM: Failed constexpr");
+	}
+
+	{
+		constexpr glm::ivec2 A(1);
+		constexpr glm::ivec2 B = A + 1;
+		constexpr glm::ivec2 C(3);
+		static_assert(A + B == C, "GLM: Failed constexpr");
+
+		constexpr glm::ivec2 D = +A;
+		static_assert(D == A, "GLM: Failed constexpr");
+	}
+
+	{
+		constexpr glm::ivec2 A(3);
+		constexpr glm::ivec2 B = A - 1;
+		constexpr glm::ivec2 C(1);
+		static_assert(A - B == C, "GLM: Failed constexpr");
+
+		constexpr glm::ivec2 D = -A;
+		static_assert(-D == A, "GLM: Failed constexpr");
+	}
+
+	{
+		constexpr glm::ivec2 A(3);
+		constexpr glm::ivec2 B = A * 1;
+		static_assert(A == B, "GLM: Failed constexpr");
+
+		constexpr glm::ivec2 C(1);
+		static_assert(B * C == A, "GLM: Failed constexpr");
+	}
+
+	{
+		constexpr glm::ivec2 A(3);
+		constexpr glm::ivec2 B = A / 1;
+		static_assert(A == B, "GLM: Failed constexpr");
+
+		constexpr glm::ivec2 C(1);
+		static_assert(B / C == A, "GLM: Failed constexpr");
+	}
+
+	{
+		constexpr glm::ivec2 A(3);
+		constexpr glm::ivec2 B = A % 2;
+		constexpr glm::ivec2 C(1);
+		static_assert(B == C, "GLM: Failed constexpr");
+
+		constexpr glm::ivec1 D(2);
+		static_assert(A % D == C, "GLM: Failed constexpr");
+	}
+
+	{
+		constexpr glm::ivec2 A(1);
+		constexpr glm::ivec2 B = A & 1;
+		static_assert(A == B, "GLM: Failed constexpr");
+
+		constexpr glm::ivec1 C(1);
+		static_assert(A == (A & C), "GLM: Failed constexpr");
+	}
+
+	{
+		constexpr glm::ivec2 A(1);
+		constexpr glm::ivec2 B = A | 1;
+		static_assert(A == B, "GLM: Failed constexpr");
+
+		constexpr glm::ivec1 C(1);
+		static_assert(A == (A | C), "GLM: Failed constexpr");
+	}
+
+	{
+		constexpr glm::ivec2 A(1);
+		constexpr glm::ivec2 B = A ^ 0;
+		static_assert(A == B, "GLM: Failed constexpr");
+
+		constexpr glm::ivec1 C(0);
+		static_assert(A == (A ^ C), "GLM: Failed constexpr");
+	}
+
+	{
+		constexpr glm::ivec2 A(1);
+		constexpr glm::ivec2 B = A << 1;
+		static_assert(B == glm::ivec2(2), "GLM: Failed constexpr");
+
+		constexpr glm::ivec1 C(1);
+		static_assert(B == (A << C), "GLM: Failed constexpr");
+	}
+
+	{
+		constexpr glm::ivec2 A(2);
+		constexpr glm::ivec2 B = A >> 1;
+		static_assert(B == glm::ivec2(1), "GLM: Failed constexpr");
+
+		constexpr glm::ivec1 C(1);
+		static_assert(B == A >> C, "GLM: Failed constexpr");
+	}
+
+	{
+		constexpr glm::ivec2 A(~0);
+		constexpr glm::ivec2 B = ~A;
+		static_assert(A == ~B, "GLM: Failed constexpr");
+	}
+
+	return Error;
+}
+
+static int test_vec3()
+{
+	int Error = 0;
+
+	{
+		constexpr glm::bvec3 B(true);
+		constexpr bool A = glm::all(B);
+		static_assert(A, "GLM: Failed constexpr");
+		
+		constexpr glm::bvec3 D(true, false, true);
+		constexpr bool C = glm::any(D);
+		static_assert(C, "GLM: Failed constexpr");
+	}
+	
+	{
+		constexpr glm::bvec3 C(true);
+		constexpr glm::bvec3 B(true, false, true);
+		static_assert(glm::any(glm::equal(C, B)), "GLM: Failed constexpr");
+	}
+	
+	{
+		constexpr glm::ivec3 O(glm::ivec1(1));
+		static_assert(glm::ivec3(1) == O, "GLM: Failed constexpr");
+
+		constexpr glm::ivec3 A(1);
+		static_assert(glm::ivec3(1) == A, "GLM: Failed constexpr");
+	}
+
+	{
+		constexpr glm::ivec3 B(glm::ivec2(1, 2), 3);
+		static_assert(glm::ivec3(1, 2, 3) == B, "GLM: Failed constexpr");
+
+		constexpr glm::ivec3 C(1, glm::ivec2(2, 3));
+		static_assert(glm::ivec3(1, 2, 3) == C, "GLM: Failed constexpr");
+
+		constexpr glm::ivec3 D(glm::ivec1(1), glm::ivec2(2, 3));
+		static_assert(glm::ivec3(1, 2, 3) == D, "GLM: Failed constexpr");
+
+		constexpr glm::ivec3 E(glm::ivec2(1, 2), glm::ivec1(3));
+		static_assert(glm::ivec3(1, 2, 3) == E, "GLM: Failed constexpr");
+	}
+
+	{
+		constexpr glm::ivec3 F(glm::ivec1(1), glm::ivec1(2), glm::ivec1(3));
+		static_assert(glm::ivec3(1, 2, 3) == F, "GLM: Failed constexpr");
+
+		constexpr glm::ivec3 G(1, glm::ivec1(2), glm::ivec1(3));
+		static_assert(glm::ivec3(1, 2, 3) == G, "GLM: Failed constexpr");
+
+		constexpr glm::ivec3 H(glm::ivec1(1), 2, glm::ivec1(3));
+		static_assert(glm::ivec3(1, 2, 3) == H, "GLM: Failed constexpr");
+
+		constexpr glm::ivec3 I(1, 2, glm::ivec1(3));
+		static_assert(glm::ivec3(1, 2, 3) == I, "GLM: Failed constexpr");
+
+		constexpr glm::ivec3 J(glm::ivec1(1), glm::ivec1(2), 3);
+		static_assert(glm::ivec3(1, 2, 3) == J, "GLM: Failed constexpr");
+
+		constexpr glm::ivec3 K(1, glm::ivec1(2), 3);
+		static_assert(glm::ivec3(1, 2, 3) == K, "GLM: Failed constexpr");
+
+		constexpr glm::ivec3 L(glm::ivec1(1), 2, 3);
+		static_assert(glm::ivec3(1, 2, 3) == L, "GLM: Failed constexpr");
+
+		constexpr glm::ivec3 M(1, 2, 3);
+		static_assert(glm::ivec3(1, 2, 3) == M, "GLM: Failed constexpr");
+	}
+
+	{
+		constexpr glm::ivec3 N(glm::ivec4(1, 2, 3, 4));
+		static_assert(glm::ivec3(1, 2, 3) == N, "GLM: Failed constexpr");
+	}
+
+	{
+		constexpr glm::ivec3 const A(1);
+		static_assert(A[0] == 1, "GLM: Failed constexpr");
+		static_assert(glm::vec3(1.0f).x > 0.0f, "GLM: Failed constexpr");
+		static_assert(glm::vec3(1.0f, -1.0f, -1.0f).x > 0.0f, "GLM: Failed constexpr");
+		static_assert(glm::vec3(1.0f, -1.0f, -1.0f).y < 0.0f, "GLM: Failed constexpr");
+		static_assert(glm::vec3::length() == 3, "GLM: Failed constexpr");
+	}
+
+	{
+		constexpr glm::bvec3 A1(true);
+		constexpr glm::bvec3 A2(true);
+		constexpr glm::bvec3 B1(false);
+		constexpr glm::bvec3 B2(false);
+		static_assert(A1 == A2 && B1 == B2, "GLM: Failed constexpr");
+		static_assert(A1 == A2 || B1 == B2, "GLM: Failed constexpr");
+	}
+
+	{
+		constexpr glm::ivec3 A(1);
+		constexpr glm::ivec3 B = A + 1;
+		constexpr glm::ivec3 C(3);
+		static_assert(A + B == C, "GLM: Failed constexpr");
+
+		constexpr glm::ivec3 D = +A;
+		static_assert(D == A, "GLM: Failed constexpr");
+	}
+
+	{
+		constexpr glm::ivec3 A(3);
+		constexpr glm::ivec3 B = A - 1;
+		constexpr glm::ivec3 C(1);
+		static_assert(A - B == C, "GLM: Failed constexpr");
+
+		constexpr glm::ivec3 D = -A;
+		static_assert(-D == A, "GLM: Failed constexpr");
+	}
+
+	{
+		constexpr glm::ivec3 A(3);
+		constexpr glm::ivec3 B = A * 1;
+		static_assert(A == B, "GLM: Failed constexpr");
+
+		constexpr glm::ivec3 C(1);
+		static_assert(B * C == A, "GLM: Failed constexpr");
+	}
+
+	{
+		constexpr glm::ivec3 A(3);
+		constexpr glm::ivec3 B = A / 1;
+		static_assert(A == B, "GLM: Failed constexpr");
+
+		constexpr glm::ivec3 C(1);
+		static_assert(B / C == A, "GLM: Failed constexpr");
+	}
+
+	{
+		constexpr glm::ivec3 A(3);
+		constexpr glm::ivec3 B = A % 2;
+		constexpr glm::ivec3 C(1);
+		static_assert(B == C, "GLM: Failed constexpr");
+
+		constexpr glm::ivec1 D(2);
+		static_assert(A % D == C, "GLM: Failed constexpr");
+	}
+
+	{
+		constexpr glm::ivec3 A(1);
+		constexpr glm::ivec3 B = A & 1;
+		static_assert(A == B, "GLM: Failed constexpr");
+
+		constexpr glm::ivec1 C(1);
+		static_assert(A == (A & C), "GLM: Failed constexpr");
+	}
+
+	{
+		constexpr glm::ivec3 A(1);
+		constexpr glm::ivec3 B = A | 1;
+		static_assert(A == B, "GLM: Failed constexpr");
+
+		constexpr glm::ivec1 C(1);
+		static_assert(A == (A | C), "GLM: Failed constexpr");
+	}
+
+	{
+		constexpr glm::ivec3 A(1);
+		constexpr glm::ivec3 B = A ^ 0;
+		static_assert(A == B, "GLM: Failed constexpr");
+
+		constexpr glm::ivec1 C(0);
+		static_assert(A == (A ^ C), "GLM: Failed constexpr");
+	}
+
+	{
+		constexpr glm::ivec3 A(1);
+		constexpr glm::ivec3 B = A << 1;
+		static_assert(B == glm::ivec3(2), "GLM: Failed constexpr");
+
+		constexpr glm::ivec1 C(1);
+		static_assert(B == (A << C), "GLM: Failed constexpr");
+	}
+
+	{
+		constexpr glm::ivec3 A(2);
+		constexpr glm::ivec3 B = A >> 1;
+		static_assert(B == glm::ivec3(1), "GLM: Failed constexpr");
+
+		constexpr glm::ivec1 C(1);
+		static_assert(B == A >> C, "GLM: Failed constexpr");
+	}
+
+	{
+		constexpr glm::ivec3 A(~0);
+		constexpr glm::ivec3 B = ~A;
+		static_assert(A == ~B, "GLM: Failed constexpr");
+	}
+
+	return Error;
+}
+
+static int test_vec4()
+{
+	int Error = 0;
+	
+	{
+		constexpr glm::bvec4 B(true);
+		constexpr bool A = glm::all(B);
+		static_assert(A, "GLM: Failed constexpr");
+		
+		constexpr glm::bvec4 D(true, false, true, false);
+		constexpr bool C = glm::any(D);
+		static_assert(C, "GLM: Failed constexpr");
+	}
+	
+	{
+		constexpr glm::bvec4 C(true);
+		constexpr glm::bvec4 B(true, false, true, false);
+		static_assert(glm::any(glm::equal(C, B)), "GLM: Failed constexpr");
+	}
+
+	{
+		constexpr glm::ivec4 O(glm::ivec4(1));
+		static_assert(glm::ivec4(1) == O, "GLM: Failed constexpr");
+
+		constexpr glm::ivec4 A(1);
+		static_assert(glm::ivec4(1) == A, "GLM: Failed constexpr");
+
+		constexpr glm::ivec4 N(glm::ivec4(1, 2, 3, 4));
+		static_assert(glm::ivec4(1, 2, 3, 4) == N, "GLM: Failed constexpr");
+	}
+
+	{
+		constexpr glm::ivec4 A(glm::ivec3(1, 2, 3), 4);
+		static_assert(glm::ivec4(1, 2, 3, 4) == A, "GLM: Failed constexpr");
+
+		constexpr glm::ivec4 B(glm::ivec2(1, 2), glm::ivec2(3, 4));
+		static_assert(glm::ivec4(1, 2, 3, 4) == B, "GLM: Failed constexpr");
+
+		constexpr glm::ivec4 C(1, glm::ivec3(2, 3, 4));
+		static_assert(glm::ivec4(1, 2, 3, 4) == C, "GLM: Failed constexpr");
+
+		constexpr glm::ivec4 D(glm::ivec1(1), glm::ivec2(2, 3), glm::ivec1(4));
+		static_assert(glm::ivec4(1, 2, 3, 4) == D, "GLM: Failed constexpr");
+
+		constexpr glm::ivec4 E(glm::ivec2(1, 2), glm::ivec1(3), glm::ivec1(4));
+		static_assert(glm::ivec4(1, 2, 3, 4) == E, "GLM: Failed constexpr");
+
+		constexpr glm::ivec4 F(glm::ivec1(1), glm::ivec1(2), glm::ivec2(3, 4));
+		static_assert(glm::ivec4(1, 2, 3, 4) == F, "GLM: Failed constexpr");
+	}
+
+	{
+		constexpr glm::ivec4 A(1);
+		static_assert(A[0] == 1, "GLM: Failed constexpr");
+		static_assert(glm::ivec4(1).x > 0, "GLM: Failed constexpr");
+		static_assert(glm::ivec4(1.0f, -1.0f, -1.0f, 1.0f).x > 0, "GLM: Failed constexpr");
+		static_assert(glm::ivec4(1.0f, -1.0f, -1.0f, 1.0f).y < 0, "GLM: Failed constexpr");
+		static_assert(glm::ivec4::length() == 4, "GLM: Failed constexpr");
+	}
+
+	{
+		constexpr glm::bvec4 A1(true);
+		constexpr glm::bvec4 A2(true);
+		constexpr glm::bvec4 B1(false);
+		constexpr glm::bvec4 B2(false);
+		static_assert(A1 == A2 && B1 == B2, "GLM: Failed constexpr");
+		static_assert(A1 == A2 || B1 == B2, "GLM: Failed constexpr");
+	}
+
+	{
+		constexpr glm::ivec4 A(1);
+		constexpr glm::ivec4 B = A + 1;
+		constexpr glm::ivec4 C(3);
+		static_assert(A + B == C, "GLM: Failed constexpr");
+
+		constexpr glm::ivec4 D = +A;
+		static_assert(D == A, "GLM: Failed constexpr");
+	}
+
+	{
+		constexpr glm::ivec4 A(3);
+		constexpr glm::ivec4 B = A - 1;
+		constexpr glm::ivec4 C(1);
+		static_assert(A - B == C, "GLM: Failed constexpr");
+
+		constexpr glm::ivec4 D = -A;
+		static_assert(-D == A, "GLM: Failed constexpr");
+	}
+
+	{
+		constexpr glm::ivec4 A(3);
+		constexpr glm::ivec4 B = A * 1;
+		static_assert(A == B, "GLM: Failed constexpr");
+
+		constexpr glm::ivec4 C(1);
+		static_assert(B * C == A, "GLM: Failed constexpr");
+	}
+
+	{
+		constexpr glm::ivec4 A(3);
+		constexpr glm::ivec4 B = A / 1;
+		static_assert(A == B, "GLM: Failed constexpr");
+
+		constexpr glm::ivec4 C(1);
+		static_assert(B / C == A, "GLM: Failed constexpr");
+	}
+
+	{
+		constexpr glm::ivec4 A(3);
+		constexpr glm::ivec4 B = A % 2;
+		constexpr glm::ivec4 C(1);
+		static_assert(B == C, "GLM: Failed constexpr");
+
+		constexpr glm::ivec1 D(2);
+		static_assert(A % D == C, "GLM: Failed constexpr");
+	}
+
+	{
+		constexpr glm::ivec4 A(1);
+		constexpr glm::ivec4 B = A & 1;
+		static_assert(A == B, "GLM: Failed constexpr");
+
+		constexpr glm::ivec1 C(1);
+		static_assert(A == (A & C), "GLM: Failed constexpr");
+	}
+
+	{
+		constexpr glm::ivec4 A(1);
+		constexpr glm::ivec4 B = A | 1;
+		static_assert(A == B, "GLM: Failed constexpr");
+
+		constexpr glm::ivec1 C(1);
+		static_assert(A == (A | C), "GLM: Failed constexpr");
+	}
+
+	{
+		constexpr glm::ivec4 A(1);
+		constexpr glm::ivec4 B = A ^ 0;
+		static_assert(A == B, "GLM: Failed constexpr");
+
+		constexpr glm::ivec1 C(0);
+		static_assert(A == (A ^ C), "GLM: Failed constexpr");
+	}
+
+	{
+		constexpr glm::ivec4 A(1);
+		constexpr glm::ivec4 B = A << 1;
+		static_assert(B == glm::ivec4(2), "GLM: Failed constexpr");
+
+		constexpr glm::ivec1 C(1);
+		static_assert(B == (A << C), "GLM: Failed constexpr");
+	}
+
+	{
+		constexpr glm::ivec4 A(2);
+		constexpr glm::ivec4 B = A >> 1;
+		static_assert(B == glm::ivec4(1), "GLM: Failed constexpr");
+
+		constexpr glm::ivec1 C(1);
+		static_assert(B == A >> C, "GLM: Failed constexpr");
+	}
+
+	{
+		constexpr glm::ivec4 A(~0);
+		constexpr glm::ivec4 B = ~A;
+		static_assert(A == ~B, "GLM: Failed constexpr");
+	}
+
+	return Error;
+}
+
+static int test_quat()
+{
+	int Error = 0;
+
+	{
+		static_assert(glm::quat::length() == 4, "GLM: Failed constexpr");
+		static_assert(glm::quat(1.0f, glm::vec3(0.0f)).w > 0.0f, "GLM: Failed constexpr");
+		static_assert(glm::quat(1.0f, 0.0f, 0.0f, 0.0f).w > 0.0f, "GLM: Failed constexpr");
+
+		glm::quat constexpr Q = glm::identity<glm::quat>();
+		static_assert(Q.x - glm::quat(1.0f, glm::vec3(0.0f)).x <= glm::epsilon<float>(), "GLM: Failed constexpr");
+	}
+
+	return Error;
+}
+
+static int test_mat2x2()
+{
+	int Error = 0;
+
+	static_assert(glm::mat2x2::length() == 2, "GLM: Failed constexpr");
+
+	return Error;
+}
+
+#endif//GLM_CONFIG_CONSTEXP == GLM_ENABLE
+
+int main()
+{
+	int Error = 0;
+
+#	if GLM_CONFIG_CONSTEXP == GLM_ENABLE
+		Error += test_vec1();
+		Error += test_vec2();
+		Error += test_vec3();
+		Error += test_vec4();
+		Error += test_quat();
+		Error += test_mat2x2();
+#	endif//GLM_CONFIG_CONSTEXP == GLM_ENABLE
+
+	return Error;
+}
+
diff --git a/3rdparty/glm/source/test/core/core_cpp_defaulted_ctor.cpp b/3rdparty/glm/source/test/core/core_cpp_defaulted_ctor.cpp
new file mode 100644
index 0000000..07afd9c
--- /dev/null
+++ b/3rdparty/glm/source/test/core/core_cpp_defaulted_ctor.cpp
@@ -0,0 +1,145 @@
+#include <glm/glm.hpp>
+
+#if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_ENABLE
+
+#include <glm/gtc/constants.hpp>
+#include <glm/gtc/quaternion.hpp>
+#include <glm/gtc/vec1.hpp>
+#include <glm/ext/matrix_relational.hpp>
+#include <glm/ext/vector_relational.hpp>
+#include <cstring>
+
+static int test_vec_memcpy()
+{
+	int Error = 0;
+
+	{
+		glm::ivec1 const A = glm::ivec1(76);
+		glm::ivec1 B;
+		std::memcpy(&B, &A, sizeof(glm::ivec1));
+		Error += B == A ? 0 : 1;
+	}
+
+	{
+		glm::ivec2 const A = glm::ivec2(76);
+		glm::ivec2 B;
+		std::memcpy(&B, &A, sizeof(glm::ivec2));
+		Error += B == A ? 0 : 1;
+	}
+
+	{
+		glm::ivec3 const A = glm::ivec3(76);
+		glm::ivec3 B;
+		std::memcpy(&B, &A, sizeof(glm::ivec3));
+		Error += B == A ? 0 : 1;
+	}
+
+	{
+		glm::ivec4 const A = glm::ivec4(76);
+		glm::ivec4 B;
+		std::memcpy(&B, &A, sizeof(glm::ivec4));
+		Error += B == A ? 0 : 1;
+	}
+
+	return Error;
+}
+
+static int test_mat_memcpy()
+{
+	int Error = 0;
+
+	{
+		glm::mat2x2 const A = glm::mat2x2(76);
+		glm::mat2x2 B;
+		std::memcpy(&B, &A, sizeof(glm::mat2x2));
+		Error += glm::all(glm::equal(B, A, glm::epsilon<float>())) ? 0 : 1;
+	}
+
+	{
+		glm::mat2x3 const A = glm::mat2x3(76);
+		glm::mat2x3 B;
+		std::memcpy(&B, &A, sizeof(glm::mat2x3));
+		Error += glm::all(glm::equal(B, A, glm::epsilon<float>())) ? 0 : 1;
+	}
+
+	{
+		glm::mat2x4 const A = glm::mat2x4(76);
+		glm::mat2x4 B;
+		std::memcpy(&B, &A, sizeof(glm::mat2x4));
+		Error += glm::all(glm::equal(B, A, glm::epsilon<float>())) ? 0 : 1;
+	}
+
+	{
+		glm::mat3x2 const A = glm::mat3x2(76);
+		glm::mat3x2 B;
+		std::memcpy(&B, &A, sizeof(glm::mat3x2));
+		Error += glm::all(glm::equal(B, A, glm::epsilon<float>())) ? 0 : 1;
+	}
+
+	{
+		glm::mat3x3 const A = glm::mat3x3(76);
+		glm::mat3x3 B;
+		std::memcpy(&B, &A, sizeof(glm::mat3x3));
+		Error += glm::all(glm::equal(B, A, glm::epsilon<float>())) ? 0 : 1;
+	}
+
+	{
+		glm::mat3x4 const A = glm::mat3x4(76);
+		glm::mat3x4 B;
+		std::memcpy(&B, &A, sizeof(glm::mat3x4));
+		Error += glm::all(glm::equal(B, A, glm::epsilon<float>())) ? 0 : 1;
+	}
+
+	{
+		glm::mat4x2 const A = glm::mat4x2(76);
+		glm::mat4x2 B;
+		std::memcpy(&B, &A, sizeof(glm::mat4x2));
+		Error += glm::all(glm::equal(B, A, glm::epsilon<float>())) ? 0 : 1;
+	}
+
+	{
+		glm::mat4x3 const A = glm::mat4x3(76);
+		glm::mat4x3 B;
+		std::memcpy(&B, &A, sizeof(glm::mat4x3));
+		Error += glm::all(glm::equal(B, A, glm::epsilon<float>())) ? 0 : 1;
+	}
+
+	{
+		glm::mat4x4 const A = glm::mat4x4(76);
+		glm::mat4x4 B;
+		std::memcpy(&B, &A, sizeof(glm::mat4x4));
+		Error += glm::all(glm::equal(B, A, glm::epsilon<float>())) ? 0 : 1;
+	}
+
+	return Error;
+}
+
+static int test_quat_memcpy()
+{
+	int Error = 0;
+
+	{
+		glm::quat const A = glm::quat(1, 0, 0, 0);
+		glm::quat B;
+		std::memcpy(&B, &A, sizeof(glm::quat));
+		Error += glm::all(glm::equal(B, A, glm::epsilon<float>())) ? 0 : 1;
+	}
+
+	return Error;
+}
+
+#endif//GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_ENABLE
+
+int main()
+{
+	int Error = 0;
+
+#	if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_ENABLE
+		Error += test_vec_memcpy();
+		Error += test_mat_memcpy();
+		Error += test_quat_memcpy();
+#	endif//GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_ENABLE
+
+	return Error;
+}
+
diff --git a/3rdparty/glm/source/test/core/core_force_aligned_gentypes.cpp b/3rdparty/glm/source/test/core/core_force_aligned_gentypes.cpp
new file mode 100644
index 0000000..70713c4
--- /dev/null
+++ b/3rdparty/glm/source/test/core/core_force_aligned_gentypes.cpp
@@ -0,0 +1,10 @@
+#include <glm/glm.hpp>
+#include <glm/ext.hpp>
+
+int main()
+{
+	int Error = 0;
+
+	return Error;
+}
+
diff --git a/3rdparty/glm/source/test/core/core_force_arch_unknown.cpp b/3rdparty/glm/source/test/core/core_force_arch_unknown.cpp
new file mode 100644
index 0000000..45b51bf
--- /dev/null
+++ b/3rdparty/glm/source/test/core/core_force_arch_unknown.cpp
@@ -0,0 +1,14 @@
+#ifndef GLM_FORCE_ARCH_UNKNOWN
+#	define GLM_FORCE_ARCH_UNKNOWN
+#endif
+
+#include <glm/glm.hpp>
+#include <glm/ext.hpp>
+
+int main()
+{
+	int Error = 0;
+
+	return Error;
+}
+
diff --git a/3rdparty/glm/source/test/core/core_force_compiler_unknown.cpp b/3rdparty/glm/source/test/core/core_force_compiler_unknown.cpp
new file mode 100644
index 0000000..44d7fc3
--- /dev/null
+++ b/3rdparty/glm/source/test/core/core_force_compiler_unknown.cpp
@@ -0,0 +1,14 @@
+#ifndef GLM_FORCE_COMPILER_UNKNOWN
+#	define GLM_FORCE_COMPILER_UNKNOWN
+#endif
+
+#include <glm/glm.hpp>
+#include <glm/ext.hpp>
+
+int main()
+{
+	int Error = 0;
+
+	return Error;
+}
+
diff --git a/3rdparty/glm/source/test/core/core_force_ctor_init.cpp b/3rdparty/glm/source/test/core/core_force_ctor_init.cpp
new file mode 100644
index 0000000..298b7ed
--- /dev/null
+++ b/3rdparty/glm/source/test/core/core_force_ctor_init.cpp
@@ -0,0 +1,139 @@
+#define GLM_FORCE_CTOR_INIT
+
+#include <glm/glm.hpp>
+#include <glm/ext.hpp>
+
+static int test_vec()
+{
+	int Error = 0;
+
+	glm::vec1 V1;
+	Error += glm::all(glm::equal(V1, glm::vec1(0), glm::epsilon<float>())) ? 0 : 1;
+
+	glm::dvec1 U1;
+	Error += glm::all(glm::equal(U1, glm::dvec1(0), glm::epsilon<double>())) ? 0 : 1;
+
+	glm::vec2 V2;
+	Error += glm::all(glm::equal(V2, glm::vec2(0, 0), glm::epsilon<float>())) ? 0 : 1;
+
+	glm::dvec2 U2;
+	Error += glm::all(glm::equal(U2, glm::dvec2(0, 0), glm::epsilon<double>())) ? 0 : 1;
+
+	glm::vec3 V3;
+	Error += glm::all(glm::equal(V3, glm::vec3(0, 0, 0), glm::epsilon<float>())) ? 0 : 1;
+
+	glm::dvec3 U3;
+	Error += glm::all(glm::equal(U3, glm::dvec3(0, 0, 0), glm::epsilon<double>())) ? 0 : 1;
+
+	glm::vec4 V4;
+	Error += glm::all(glm::equal(V4, glm::vec4(0, 0, 0, 0), glm::epsilon<float>())) ? 0 : 1;
+
+	glm::dvec4 U4;
+	Error += glm::all(glm::equal(U4, glm::dvec4(0, 0, 0, 0), glm::epsilon<double>())) ? 0 : 1;
+
+	return Error;
+}
+
+static int test_mat()
+{
+	int Error = 0;
+
+	{
+		glm::mat2x2 F;
+		Error += glm::all(glm::equal(F, glm::mat2x2(1), glm::epsilon<float>())) ? 0 : 1;
+
+		glm::dmat2x2 D;
+		Error += glm::all(glm::equal(D, glm::dmat2x2(1), glm::epsilon<double>())) ? 0 : 1;
+	}
+
+	{
+		glm::mat2x3 F;
+		Error += glm::all(glm::equal(F, glm::mat2x3(1), glm::epsilon<float>())) ? 0 : 1;
+
+		glm::dmat2x3 D;
+		Error += glm::all(glm::equal(D, glm::dmat2x3(1), glm::epsilon<double>())) ? 0 : 1;
+	}
+
+	{
+		glm::mat2x4 F;
+		Error += glm::all(glm::equal(F, glm::mat2x4(1), glm::epsilon<float>())) ? 0 : 1;
+
+		glm::dmat2x4 D;
+		Error += glm::all(glm::equal(D, glm::dmat2x4(1), glm::epsilon<double>())) ? 0 : 1;
+	}
+
+	{
+		glm::mat3x2 F;
+		Error += glm::all(glm::equal(F, glm::mat3x2(1), glm::epsilon<float>())) ? 0 : 1;
+
+		glm::dmat3x2 D;
+		Error += glm::all(glm::equal(D, glm::dmat3x2(1), glm::epsilon<double>())) ? 0 : 1;
+	}
+
+	{
+		glm::mat3x3 F;
+		Error += glm::all(glm::equal(F, glm::mat3x3(1), glm::epsilon<float>())) ? 0 : 1;
+
+		glm::dmat3x3 D;
+		Error += glm::all(glm::equal(D, glm::dmat3x3(1), glm::epsilon<double>())) ? 0 : 1;
+	}
+
+	{
+		glm::mat3x4 F;
+		Error += glm::all(glm::equal(F, glm::mat3x4(1), glm::epsilon<float>())) ? 0 : 1;
+
+		glm::dmat3x4 D;
+		Error += glm::all(glm::equal(D, glm::dmat3x4(1), glm::epsilon<double>())) ? 0 : 1;
+	}
+
+	{
+		glm::mat4x2 F;
+		Error += glm::all(glm::equal(F, glm::mat4x2(1), glm::epsilon<float>())) ? 0 : 1;
+
+		glm::dmat4x2 D;
+		Error += glm::all(glm::equal(D, glm::dmat4x2(1), glm::epsilon<double>())) ? 0 : 1;
+	}
+
+	{
+		glm::mat4x3 F;
+		Error += glm::all(glm::equal(F, glm::mat4x3(1), glm::epsilon<float>())) ? 0 : 1;
+
+		glm::dmat4x3 D;
+		Error += glm::all(glm::equal(D, glm::dmat4x3(1), glm::epsilon<double>())) ? 0 : 1;
+	}
+
+	{
+		glm::mat4x4 F;
+		Error += glm::all(glm::equal(F, glm::mat4x4(1), glm::epsilon<float>())) ? 0 : 1;
+
+		glm::dmat4x4 D;
+		Error += glm::all(glm::equal(D, glm::dmat4x4(1), glm::epsilon<double>())) ? 0 : 1;
+	}
+
+	return Error;
+}
+
+static int test_qua()
+{
+	int Error = 0;
+
+	glm::quat F;
+	Error += glm::all(glm::equal(F, glm::quat(1, 0, 0, 0), glm::epsilon<float>())) ? 0 : 1;
+
+	glm::dquat D;
+	Error += glm::all(glm::equal(D, glm::dquat(1, 0, 0, 0), glm::epsilon<double>())) ? 0 : 1;
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_vec();
+	Error += test_mat();
+	Error += test_qua();
+
+	return Error;
+}
+
diff --git a/3rdparty/glm/source/test/core/core_force_cxx03.cpp b/3rdparty/glm/source/test/core/core_force_cxx03.cpp
new file mode 100644
index 0000000..fc6e9c5
--- /dev/null
+++ b/3rdparty/glm/source/test/core/core_force_cxx03.cpp
@@ -0,0 +1,14 @@
+#ifndef GLM_FORCE_CXX03
+#	define GLM_FORCE_CXX03
+#endif
+
+#include <glm/glm.hpp>
+#include <glm/ext.hpp>
+
+int main()
+{
+	int Error = 0;
+
+	return Error;
+}
+
diff --git a/3rdparty/glm/source/test/core/core_force_cxx98.cpp b/3rdparty/glm/source/test/core/core_force_cxx98.cpp
new file mode 100644
index 0000000..42a5c25
--- /dev/null
+++ b/3rdparty/glm/source/test/core/core_force_cxx98.cpp
@@ -0,0 +1,14 @@
+#ifndef GLM_FORCE_CXX98
+#	define GLM_FORCE_CXX98
+#endif
+
+#include <glm/glm.hpp>
+#include <glm/ext.hpp>
+
+int main()
+{
+	int Error = 0;
+
+	return Error;
+}
+
diff --git a/3rdparty/glm/source/test/core/core_force_cxx_unknown.cpp b/3rdparty/glm/source/test/core/core_force_cxx_unknown.cpp
new file mode 100644
index 0000000..62299d6
--- /dev/null
+++ b/3rdparty/glm/source/test/core/core_force_cxx_unknown.cpp
@@ -0,0 +1,14 @@
+#ifndef GLM_FORCE_CXX_UNKNOWN
+#	define GLM_FORCE_CXX_UNKNOWN
+#endif
+
+#include <glm/glm.hpp>
+#include <glm/ext.hpp>
+
+int main()
+{
+	int Error = 0;
+
+	return Error;
+}
+
diff --git a/3rdparty/glm/source/test/core/core_force_depth_zero_to_one.cpp b/3rdparty/glm/source/test/core/core_force_depth_zero_to_one.cpp
new file mode 100644
index 0000000..23b3615
--- /dev/null
+++ b/3rdparty/glm/source/test/core/core_force_depth_zero_to_one.cpp
@@ -0,0 +1,12 @@
+#define GLM_FORCE_DEPTH_ZERO_TO_ONE
+
+#include <glm/glm.hpp>
+#include <glm/ext.hpp>
+
+int main()
+{
+	int Error = 0;
+
+	return Error;
+}
+
diff --git a/3rdparty/glm/source/test/core/core_force_explicit_ctor.cpp b/3rdparty/glm/source/test/core/core_force_explicit_ctor.cpp
new file mode 100644
index 0000000..7af5b79
--- /dev/null
+++ b/3rdparty/glm/source/test/core/core_force_explicit_ctor.cpp
@@ -0,0 +1,17 @@
+#define GLM_FORCE_EXPLICIT_CTOR
+
+#include <glm/glm.hpp>
+#include <glm/ext.hpp>
+
+int main()
+{
+	int Error = 0;
+
+	glm::ivec4 B(1);
+	Error += B == glm::ivec4(1) ? 0 : 1;
+
+	//glm::vec4 A = B;
+
+	return Error;
+}
+
diff --git a/3rdparty/glm/source/test/core/core_force_inline.cpp b/3rdparty/glm/source/test/core/core_force_inline.cpp
new file mode 100644
index 0000000..cd23fd9
--- /dev/null
+++ b/3rdparty/glm/source/test/core/core_force_inline.cpp
@@ -0,0 +1,12 @@
+#define GLM_FORCE_INLINE
+
+#include <glm/glm.hpp>
+#include <glm/ext.hpp>
+
+int main()
+{
+	int Error = 0;
+
+	return Error;
+}
+
diff --git a/3rdparty/glm/source/test/core/core_force_left_handed.cpp b/3rdparty/glm/source/test/core/core_force_left_handed.cpp
new file mode 100644
index 0000000..b7ec31b
--- /dev/null
+++ b/3rdparty/glm/source/test/core/core_force_left_handed.cpp
@@ -0,0 +1,12 @@
+#define GLM_FORCE_LEFT_HANDED
+
+#include <glm/glm.hpp>
+#include <glm/ext.hpp>
+
+int main()
+{
+	int Error = 0;
+
+	return Error;
+}
+
diff --git a/3rdparty/glm/source/test/core/core_force_platform_unknown.cpp b/3rdparty/glm/source/test/core/core_force_platform_unknown.cpp
new file mode 100644
index 0000000..fb7fa75
--- /dev/null
+++ b/3rdparty/glm/source/test/core/core_force_platform_unknown.cpp
@@ -0,0 +1,14 @@
+#ifndef GLM_FORCE_PLATFORM_UNKNOWN
+#	define GLM_FORCE_PLATFORM_UNKNOWN
+#endif
+
+#include <glm/glm.hpp>
+#include <glm/ext.hpp>
+
+int main()
+{
+	int Error = 0;
+
+	return Error;
+}
+
diff --git a/3rdparty/glm/source/test/core/core_force_pure.cpp b/3rdparty/glm/source/test/core/core_force_pure.cpp
new file mode 100644
index 0000000..a32a4ed
--- /dev/null
+++ b/3rdparty/glm/source/test/core/core_force_pure.cpp
@@ -0,0 +1,434 @@
+#ifndef GLM_FORCE_PURE
+#	define GLM_FORCE_PURE
+#endif//GLM_FORCE_PURE
+#define GLM_FORCE_DEFAULT_ALIGNED_GENTYPES
+#define GLM_FORCE_SWIZZLE
+#include <glm/ext/vector_relational.hpp>
+#include <glm/vector_relational.hpp>
+#include <glm/vec2.hpp>
+#include <glm/vec3.hpp>
+#include <glm/vec4.hpp>
+#include <ctime>
+#include <vector>
+
+static int test_vec4_ctor()
+{
+	int Error = 0;
+
+	{
+		glm::ivec4 A(1, 2, 3, 4);
+		glm::ivec4 B(A);
+		Error += glm::all(glm::equal(A, B)) ? 0 : 1;
+	}
+
+#	if GLM_HAS_TRIVIAL_QUERIES
+	//	Error += std::is_trivially_default_constructible<glm::vec4>::value ? 0 : 1;
+	//	Error += std::is_trivially_copy_assignable<glm::vec4>::value ? 0 : 1;
+		Error += std::is_trivially_copyable<glm::vec4>::value ? 0 : 1;
+		Error += std::is_trivially_copyable<glm::dvec4>::value ? 0 : 1;
+		Error += std::is_trivially_copyable<glm::ivec4>::value ? 0 : 1;
+		Error += std::is_trivially_copyable<glm::uvec4>::value ? 0 : 1;
+
+		Error += std::is_copy_constructible<glm::vec4>::value ? 0 : 1;
+#	endif
+
+#if GLM_HAS_INITIALIZER_LISTS
+	{
+		glm::vec4 a{ 0, 1, 2, 3 };
+		std::vector<glm::vec4> v = {
+			{0, 1, 2, 3},
+			{4, 5, 6, 7},
+			{8, 9, 0, 1}};
+	}
+
+	{
+		glm::dvec4 a{ 0, 1, 2, 3 };
+		std::vector<glm::dvec4> v = {
+			{0, 1, 2, 3},
+			{4, 5, 6, 7},
+			{8, 9, 0, 1}};
+	}
+#endif
+
+#	if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR
+	{
+		glm::ivec4 A = glm::vec4(1.0f, 2.0f, 3.0f, 4.0f);
+		glm::ivec4 B = A.xyzw;
+		glm::ivec4 C(A.xyzw);
+		glm::ivec4 D(A.xyzw());
+		glm::ivec4 E(A.x, A.yzw);
+		glm::ivec4 F(A.x, A.yzw());
+		glm::ivec4 G(A.xyz, A.w);
+		glm::ivec4 H(A.xyz(), A.w);
+		glm::ivec4 I(A.xy, A.zw);
+		glm::ivec4 J(A.xy(), A.zw());
+		glm::ivec4 K(A.x, A.y, A.zw);
+		glm::ivec4 L(A.x, A.yz, A.w);
+		glm::ivec4 M(A.xy, A.z, A.w);
+
+		Error += glm::all(glm::equal(A, B)) ? 0 : 1;
+		Error += glm::all(glm::equal(A, C)) ? 0 : 1;
+		Error += glm::all(glm::equal(A, D)) ? 0 : 1;
+		Error += glm::all(glm::equal(A, E)) ? 0 : 1;
+		Error += glm::all(glm::equal(A, F)) ? 0 : 1;
+		Error += glm::all(glm::equal(A, G)) ? 0 : 1;
+		Error += glm::all(glm::equal(A, H)) ? 0 : 1;
+		Error += glm::all(glm::equal(A, I)) ? 0 : 1;
+		Error += glm::all(glm::equal(A, J)) ? 0 : 1;
+		Error += glm::all(glm::equal(A, K)) ? 0 : 1;
+		Error += glm::all(glm::equal(A, L)) ? 0 : 1;
+		Error += glm::all(glm::equal(A, M)) ? 0 : 1;
+	}
+#	endif
+
+#	if GLM_CONFIG_SWIZZLE
+	{
+		glm::ivec4 A = glm::vec4(1.0f, 2.0f, 3.0f, 4.0f);
+		glm::ivec4 B = A.xyzw();
+		glm::ivec4 C(A.xyzw());
+		glm::ivec4 D(A.xyzw());
+		glm::ivec4 E(A.x, A.yzw());
+		glm::ivec4 F(A.x, A.yzw());
+		glm::ivec4 G(A.xyz(), A.w);
+		glm::ivec4 H(A.xyz(), A.w);
+		glm::ivec4 I(A.xy(), A.zw());
+		glm::ivec4 J(A.xy(), A.zw());
+		glm::ivec4 K(A.x, A.y, A.zw());
+		glm::ivec4 L(A.x, A.yz(), A.w);
+		glm::ivec4 M(A.xy(), A.z, A.w);
+
+		Error += glm::all(glm::equal(A, B)) ? 0 : 1;
+		Error += glm::all(glm::equal(A, C)) ? 0 : 1;
+		Error += glm::all(glm::equal(A, D)) ? 0 : 1;
+		Error += glm::all(glm::equal(A, E)) ? 0 : 1;
+		Error += glm::all(glm::equal(A, F)) ? 0 : 1;
+		Error += glm::all(glm::equal(A, G)) ? 0 : 1;
+		Error += glm::all(glm::equal(A, H)) ? 0 : 1;
+		Error += glm::all(glm::equal(A, I)) ? 0 : 1;
+		Error += glm::all(glm::equal(A, J)) ? 0 : 1;
+		Error += glm::all(glm::equal(A, K)) ? 0 : 1;
+		Error += glm::all(glm::equal(A, L)) ? 0 : 1;
+		Error += glm::all(glm::equal(A, M)) ? 0 : 1;
+	}
+#	endif//GLM_CONFIG_SWIZZLE
+
+	{
+		glm::ivec4 A(1);
+		glm::ivec4 B(1, 1, 1, 1);
+		
+		Error += A == B ? 0 : 1;
+	}
+	
+	{
+		std::vector<glm::ivec4> Tests;
+		Tests.push_back(glm::ivec4(glm::ivec2(1, 2), 3, 4));
+		Tests.push_back(glm::ivec4(1, glm::ivec2(2, 3), 4));
+		Tests.push_back(glm::ivec4(1, 2, glm::ivec2(3, 4)));
+		Tests.push_back(glm::ivec4(glm::ivec3(1, 2, 3), 4));
+		Tests.push_back(glm::ivec4(1, glm::ivec3(2, 3, 4)));
+		Tests.push_back(glm::ivec4(glm::ivec2(1, 2), glm::ivec2(3, 4)));
+		Tests.push_back(glm::ivec4(1, 2, 3, 4));
+		Tests.push_back(glm::ivec4(glm::ivec4(1, 2, 3, 4)));
+		
+		for(std::size_t i = 0; i < Tests.size(); ++i)
+			Error += Tests[i] == glm::ivec4(1, 2, 3, 4) ? 0 : 1;
+	}
+	
+	return Error;
+}
+
+static int test_bvec4_ctor()
+{
+	int Error = 0;
+
+	glm::bvec4 const A(true);
+	glm::bvec4 const B(true);
+	glm::bvec4 const C(false);
+	glm::bvec4 const D = A && B;
+	glm::bvec4 const E = A && C;
+	glm::bvec4 const F = A || C;
+
+	Error += D == glm::bvec4(true) ? 0 : 1;
+	Error += E == glm::bvec4(false) ? 0 : 1;
+	Error += F == glm::bvec4(true) ? 0 : 1;
+
+	bool const G = A == C;
+	bool const H = A != C;
+
+	Error += !G ? 0 : 1;
+	Error += H ? 0 : 1;
+
+	return Error;
+}
+
+static int test_vec4_operators()
+{
+	int Error = 0;
+	
+	{
+		glm::ivec4 A(1);
+		glm::ivec4 B(1);
+		bool R = A != B;
+		bool S = A == B;
+
+		Error += (S && !R) ? 0 : 1;
+	}
+
+	{
+		glm::vec4 const A(1.0f, 2.0f, 3.0f, 4.0f);
+		glm::vec4 const B(4.0f, 5.0f, 6.0f, 7.0f);
+
+		glm::vec4 const C = A + B;
+		Error += glm::all(glm::equal(C, glm::vec4(5, 7, 9, 11), 0.001f)) ? 0 : 1;
+
+		glm::vec4 D = B - A;
+		Error += glm::all(glm::equal(D, glm::vec4(3, 3, 3, 3), 0.001f)) ? 0 : 1;
+
+		glm::vec4 E = A * B;
+		Error += glm::all(glm::equal(E, glm::vec4(4, 10, 18, 28), 0.001f)) ? 0 : 1;
+
+		glm::vec4 F = B / A;
+		Error += glm::all(glm::equal(F, glm::vec4(4, 2.5, 2, 7.0f / 4.0f), 0.001f)) ? 0 : 1;
+
+		glm::vec4 G = A + 1.0f;
+		Error += glm::all(glm::equal(G, glm::vec4(2, 3, 4, 5), 0.001f)) ? 0 : 1;
+
+		glm::vec4 H = B - 1.0f;
+		Error += glm::all(glm::equal(H, glm::vec4(3, 4, 5, 6), 0.001f)) ? 0 : 1;
+
+		glm::vec4 I = A * 2.0f;
+		Error += glm::all(glm::equal(I, glm::vec4(2, 4, 6, 8), 0.001f)) ? 0 : 1;
+
+		glm::vec4 J = B / 2.0f;
+		Error += glm::all(glm::equal(J, glm::vec4(2, 2.5, 3, 3.5), 0.001f)) ? 0 : 1;
+
+		glm::vec4 K = 1.0f + A;
+		Error += glm::all(glm::equal(K, glm::vec4(2, 3, 4, 5), 0.001f)) ? 0 : 1;
+
+		glm::vec4 L = 1.0f - B;
+		Error += glm::all(glm::equal(L, glm::vec4(-3, -4, -5, -6), 0.001f)) ? 0 : 1;
+
+		glm::vec4 M = 2.0f * A;
+		Error += glm::all(glm::equal(M, glm::vec4(2, 4, 6, 8), 0.001f)) ? 0 : 1;
+
+		glm::vec4 const N = 2.0f / B;
+		Error += glm::all(glm::equal(N, glm::vec4(0.5, 2.0 / 5.0, 2.0 / 6.0, 2.0 / 7.0), 0.0001f)) ? 0 : 1;
+	}
+
+	{
+		glm::ivec4 A(1.0f, 2.0f, 3.0f, 4.0f);
+		glm::ivec4 B(4.0f, 5.0f, 6.0f, 7.0f);
+
+		A += B;
+		Error += A == glm::ivec4(5, 7, 9, 11) ? 0 : 1;
+
+		A += 1;
+		Error += A == glm::ivec4(6, 8, 10, 12) ? 0 : 1;
+	}
+	{
+		glm::ivec4 A(1.0f, 2.0f, 3.0f, 4.0f);
+		glm::ivec4 B(4.0f, 5.0f, 6.0f, 7.0f);
+
+		B -= A;
+		Error += B == glm::ivec4(3, 3, 3, 3) ? 0 : 1;
+
+		B -= 1;
+		Error += B == glm::ivec4(2, 2, 2, 2) ? 0 : 1;
+	}
+	{
+		glm::ivec4 A(1.0f, 2.0f, 3.0f, 4.0f);
+		glm::ivec4 B(4.0f, 5.0f, 6.0f, 7.0f);
+
+		A *= B;
+		Error += A == glm::ivec4(4, 10, 18, 28) ? 0 : 1;
+
+		A *= 2;
+		Error += A == glm::ivec4(8, 20, 36, 56) ? 0 : 1;
+	}
+	{
+		glm::ivec4 A(1.0f, 2.0f, 3.0f, 4.0f);
+		glm::ivec4 B(4.0f, 4.0f, 6.0f, 8.0f);
+
+		B /= A;
+		Error += B == glm::ivec4(4, 2, 2, 2) ? 0 : 1;
+
+		B /= 2;
+		Error += B == glm::ivec4(2, 1, 1, 1) ? 0 : 1;
+	}
+	{
+		glm::ivec4 B(2);
+
+		B /= B.y;
+		Error += B == glm::ivec4(1) ? 0 : 1;
+	}
+
+	{
+		glm::ivec4 A(1.0f, 2.0f, 3.0f, 4.0f);
+		glm::ivec4 B = -A;
+		Error += B == glm::ivec4(-1.0f, -2.0f, -3.0f, -4.0f) ? 0 : 1;
+	}
+
+	{
+		glm::ivec4 A(1.0f, 2.0f, 3.0f, 4.0f);
+		glm::ivec4 B = --A;
+		Error += B == glm::ivec4(0.0f, 1.0f, 2.0f, 3.0f) ? 0 : 1;
+	}
+
+	{
+		glm::ivec4 A(1.0f, 2.0f, 3.0f, 4.0f);
+		glm::ivec4 B = A--;
+		Error += B == glm::ivec4(1.0f, 2.0f, 3.0f, 4.0f) ? 0 : 1;
+		Error += A == glm::ivec4(0.0f, 1.0f, 2.0f, 3.0f) ? 0 : 1;
+	}
+
+	{
+		glm::ivec4 A(1.0f, 2.0f, 3.0f, 4.0f);
+		glm::ivec4 B = ++A;
+		Error += B == glm::ivec4(2.0f, 3.0f, 4.0f, 5.0f) ? 0 : 1;
+	}
+
+	{
+		glm::ivec4 A(1.0f, 2.0f, 3.0f, 4.0f);
+		glm::ivec4 B = A++;
+		Error += B == glm::ivec4(1.0f, 2.0f, 3.0f, 4.0f) ? 0 : 1;
+		Error += A == glm::ivec4(2.0f, 3.0f, 4.0f, 5.0f) ? 0 : 1;
+	}
+
+	return Error;
+}
+
+static int test_vec4_equal()
+{
+	int Error = 0;
+
+	{
+		glm::uvec4 const A(1, 2, 3, 4);
+		glm::uvec4 const B(1, 2, 3, 4);
+		Error += A == B ? 0 : 1;
+		Error += A != B ? 1 : 0;
+	}
+
+	{
+		glm::ivec4 const A(1, 2, 3, 4);
+		glm::ivec4 const B(1, 2, 3, 4);
+		Error += A == B ? 0 : 1;
+		Error += A != B ? 1 : 0;
+	}
+
+	return Error;
+}
+
+static int test_vec4_size()
+{
+	int Error = 0;
+
+	Error += sizeof(glm::vec4) == sizeof(glm::lowp_vec4) ? 0 : 1;
+	Error += sizeof(glm::vec4) == sizeof(glm::mediump_vec4) ? 0 : 1;
+	Error += sizeof(glm::vec4) == sizeof(glm::highp_vec4) ? 0 : 1;
+	Error += 16 == sizeof(glm::mediump_vec4) ? 0 : 1;
+	Error += sizeof(glm::dvec4) == sizeof(glm::lowp_dvec4) ? 0 : 1;
+	Error += sizeof(glm::dvec4) == sizeof(glm::mediump_dvec4) ? 0 : 1;
+	Error += sizeof(glm::dvec4) == sizeof(glm::highp_dvec4) ? 0 : 1;
+	Error += 32 == sizeof(glm::highp_dvec4) ? 0 : 1;
+	Error += glm::vec4().length() == 4 ? 0 : 1;
+	Error += glm::dvec4().length() == 4 ? 0 : 1;
+
+	return Error;
+}
+
+static int test_vec4_swizzle_partial()
+{
+	int Error = 0;
+
+#	if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR
+
+	glm::ivec4 A(1, 2, 3, 4);
+
+	{
+		glm::ivec4 B(A.xy, A.zw);
+		Error += A == B ? 0 : 1;
+	}
+	{
+		glm::ivec4 B(A.xy, 3, 4);
+		Error += A == B ? 0 : 1;
+	}
+	{
+		glm::ivec4 B(1, A.yz, 4);
+		Error += A == B ? 0 : 1;
+	}
+	{
+		glm::ivec4 B(1, 2, A.zw);
+		Error += A == B ? 0 : 1;
+	}
+
+	{
+		glm::ivec4 B(A.xyz, 4);
+		Error += A == B ? 0 : 1;
+	}
+	{
+		glm::ivec4 B(1, A.yzw);
+		Error += A == B ? 0 : 1;
+	}
+#	endif
+
+	return Error;
+}
+
+static int test_operator_increment()
+{
+	int Error(0);
+
+	glm::ivec4 v0(1);
+	glm::ivec4 v1(v0);
+	glm::ivec4 v2(v0);
+	glm::ivec4 v3 = ++v1;
+	glm::ivec4 v4 = v2++;
+
+	Error += glm::all(glm::equal(v0, v4)) ? 0 : 1;
+	Error += glm::all(glm::equal(v1, v2)) ? 0 : 1;
+	Error += glm::all(glm::equal(v1, v3)) ? 0 : 1;
+
+	int i0(1);
+	int i1(i0);
+	int i2(i0);
+	int i3 = ++i1;
+	int i4 = i2++;
+
+	Error += i0 == i4 ? 0 : 1;
+	Error += i1 == i2 ? 0 : 1;
+	Error += i1 == i3 ? 0 : 1;
+
+	return Error;
+}
+
+static int test_vec4_simd()
+{
+	int Error = 0;
+
+	glm::vec4 const a(std::clock(), std::clock(), std::clock(), std::clock());
+	glm::vec4 const b(std::clock(), std::clock(), std::clock(), std::clock());
+
+	glm::vec4 const c(b * a);
+	glm::vec4 const d(a + c);
+
+	Error += glm::all(glm::greaterThanEqual(d, glm::vec4(0))) ? 0 : 1;
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_vec4_ctor();
+	Error += test_bvec4_ctor();
+	Error += test_vec4_size();
+	Error += test_vec4_operators();
+	Error += test_vec4_equal();
+	Error += test_vec4_swizzle_partial();
+	Error += test_vec4_simd();
+	Error += test_operator_increment();
+
+	return Error;
+}
+
diff --git a/3rdparty/glm/source/test/core/core_force_quat_xyzw.cpp b/3rdparty/glm/source/test/core/core_force_quat_xyzw.cpp
new file mode 100644
index 0000000..7d5281c
--- /dev/null
+++ b/3rdparty/glm/source/test/core/core_force_quat_xyzw.cpp
@@ -0,0 +1,13 @@
+#define GLM_FORCE_QUAT_DATA_XYZW
+#define GLM_FORCE_INLINE
+
+#include <glm/glm.hpp>
+#include <glm/ext.hpp>
+
+int main()
+{
+	int Error = 0;
+
+	return Error;
+}
+
diff --git a/3rdparty/glm/source/test/core/core_force_size_t_length.cpp b/3rdparty/glm/source/test/core/core_force_size_t_length.cpp
new file mode 100644
index 0000000..19dac89
--- /dev/null
+++ b/3rdparty/glm/source/test/core/core_force_size_t_length.cpp
@@ -0,0 +1,12 @@
+#define GLM_FORCE_SIZE_T_LENGTH
+
+#include <glm/glm.hpp>
+#include <glm/ext.hpp>
+
+int main()
+{
+	int Error = 0;
+
+	return Error;
+}
+
diff --git a/3rdparty/glm/source/test/core/core_force_unrestricted_gentype.cpp b/3rdparty/glm/source/test/core/core_force_unrestricted_gentype.cpp
new file mode 100644
index 0000000..21d6e52
--- /dev/null
+++ b/3rdparty/glm/source/test/core/core_force_unrestricted_gentype.cpp
@@ -0,0 +1,12 @@
+#define GLM_FORCE_UNRESTRICTED_GENTYPE
+
+#include <glm/glm.hpp>
+#include <glm/ext.hpp>
+
+int main()
+{
+	int Error = 0;
+
+	return Error;
+}
+
diff --git a/3rdparty/glm/source/test/core/core_force_xyzw_only.cpp b/3rdparty/glm/source/test/core/core_force_xyzw_only.cpp
new file mode 100644
index 0000000..d19509d
--- /dev/null
+++ b/3rdparty/glm/source/test/core/core_force_xyzw_only.cpp
@@ -0,0 +1,58 @@
+#define GLM_FORCE_XYZW_ONLY
+
+#include <glm/gtc/constants.hpp>
+#include <glm/gtc/vec1.hpp>
+#include <glm/ext/vector_relational.hpp>
+#include <glm/vec2.hpp>
+#include <glm/vec3.hpp>
+#include <glm/vec4.hpp>
+
+static int test_comp()
+{
+	int Error = 0;
+
+	{
+		glm::ivec1 const A(1);
+		Error += A.x == 1 ? 0 : 1;
+	}
+
+	{
+		glm::ivec2 const A(1, 2);
+		Error += A.x == 1 ? 0 : 1;
+		Error += A.y == 2 ? 0 : 1;
+	}
+
+	{
+		glm::ivec3 const A(1, 2, 3);
+		Error += A.x == 1 ? 0 : 1;
+		Error += A.y == 2 ? 0 : 1;
+		Error += A.z == 3 ? 0 : 1;
+	}
+
+	{
+		glm::ivec4 const A(1, 2, 3, 4);
+		Error += A.x == 1 ? 0 : 1;
+		Error += A.y == 2 ? 0 : 1;
+		Error += A.z == 3 ? 0 : 1;
+		Error += A.w == 4 ? 0 : 1;
+	}
+
+	return Error;
+}
+
+static int test_constexpr()
+{
+	int Error = 0;
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_comp();
+	Error += test_constexpr();
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/core/core_func_common.cpp b/3rdparty/glm/source/test/core/core_func_common.cpp
new file mode 100644
index 0000000..b8640de
--- /dev/null
+++ b/3rdparty/glm/source/test/core/core_func_common.cpp
@@ -0,0 +1,1349 @@
+#define GLM_FORCE_EXPLICIT_CTOR
+#include <glm/gtc/constants.hpp>
+#include <glm/gtc/random.hpp>
+#include <glm/gtc/vec1.hpp>
+#include <glm/ext/scalar_relational.hpp>
+#include <glm/ext/vector_relational.hpp>
+#include <glm/ext/vector_float1.hpp>
+#include <glm/common.hpp>
+#include <glm/vec4.hpp>
+#include <glm/vec3.hpp>
+#include <glm/vec2.hpp>
+#include <vector>
+#include <cstdio>
+#include <cmath>
+#include <ctime>
+
+// This file has divisions by zero to test isnan
+#if GLM_COMPILER & GLM_COMPILER_VC
+#	pragma warning(disable : 4723)
+#endif
+
+namespace floor_
+{
+	static int test()
+	{
+		int Error = 0;
+
+		{
+			float A = 1.1f;
+			float B = glm::floor(A);
+			Error += glm::equal(B, 1.f, 0.0001f) ? 0 : 1;
+		}
+
+		{
+			double A = 1.1;
+			double B = glm::floor(A);
+			Error += glm::equal(B, 1.0, 0.0001) ? 0 : 1;
+		}
+
+		{
+			glm::vec1 A(1.1f);
+			glm::vec1 B = glm::floor(A);
+
+			Error += glm::all(glm::equal(B, glm::vec1(1.0), 0.0001f)) ? 0 : 1;
+		}
+
+		{
+			glm::dvec1 A(1.1);
+			glm::dvec1 B = glm::floor(A);
+
+			Error += glm::all(glm::equal(B, glm::dvec1(1.0), 0.0001)) ? 0 : 1;
+		}
+
+		{
+			glm::vec2 A(1.1f);
+			glm::vec2 B = glm::floor(A);
+
+			Error += glm::all(glm::equal(B, glm::vec2(1.0), 0.0001f)) ? 0 : 1;
+		}
+
+		{
+			glm::dvec2 A(1.1);
+			glm::dvec2 B = glm::floor(A);
+
+			Error += glm::all(glm::equal(B, glm::dvec2(1.0), 0.0001)) ? 0 : 1;
+		}
+
+		{
+			glm::vec3 A(1.1f);
+			glm::vec3 B = glm::floor(A);
+
+			Error += glm::all(glm::equal(B, glm::vec3(1.0), 0.0001f)) ? 0 : 1;
+		}
+
+		{
+			glm::dvec3 A(1.1);
+			glm::dvec3 B = glm::floor(A);
+
+			Error += glm::all(glm::equal(B, glm::dvec3(1.0), 0.0001)) ? 0 : 1;
+		}
+
+		{
+			glm::vec4 A(1.1f);
+			glm::vec4 B = glm::floor(A);
+
+			Error += glm::all(glm::equal(B, glm::vec4(1.0), 0.0001f)) ? 0 : 1;
+		}
+
+		{
+			glm::dvec4 A(1.1);
+			glm::dvec4 B = glm::floor(A);
+
+			Error += glm::all(glm::equal(B, glm::dvec4(1.0), 0.0001)) ? 0 : 1;
+		}
+
+		return Error;
+	}
+}//namespace floor
+
+namespace modf_
+{
+	static int test()
+	{
+		int Error(0);
+
+		{
+			float X(1.5f);
+			float I(0.0f);
+			float A = glm::modf(X, I);
+
+			Error += glm::equal(I, 1.0f, 0.0001f) ? 0 : 1;
+			Error += glm::equal(A, 0.5f, 0.0001f) ? 0 : 1;
+		}
+
+		{
+			glm::vec4 X(1.1f, 1.2f, 1.5f, 1.7f);
+			glm::vec4 I(0.0f);
+			glm::vec4 A = glm::modf(X, I);
+
+			Error += glm::ivec4(I) == glm::ivec4(1) ? 0 : 1;
+			Error += glm::all(glm::equal(A, glm::vec4(0.1f, 0.2f, 0.5f, 0.7f), 0.00001f)) ? 0 : 1;
+		}
+
+		{
+			glm::dvec4 X(1.1, 1.2, 1.5, 1.7);
+			glm::dvec4 I(0.0);
+			glm::dvec4 A = glm::modf(X, I);
+
+			Error += glm::ivec4(I) == glm::ivec4(1) ? 0 : 1;
+			Error += glm::all(glm::equal(A, glm::dvec4(0.1, 0.2, 0.5, 0.7), 0.000000001)) ? 0 : 1;
+		}
+
+		{
+			double X(1.5);
+			double I(0.0);
+			double A = glm::modf(X, I);
+
+			Error += glm::equal(I, 1.0, 0.0001) ? 0 : 1;
+			Error += glm::equal(A, 0.5, 0.0001) ? 0 : 1;
+		}
+
+		return Error;
+	}
+}//namespace modf
+
+namespace mod_
+{
+	static int test()
+	{
+		int Error(0);
+
+		{
+			float A(1.5f);
+			float B(1.0f);
+			float C = glm::mod(A, B);
+
+			Error += glm::equal(C, 0.5f, 0.00001f) ? 0 : 1;
+		}
+
+		{
+			float A(-0.2f);
+			float B(1.0f);
+			float C = glm::mod(A, B);
+
+			Error += glm::equal(C, 0.8f, 0.00001f) ? 0 : 1;
+		}
+
+		{
+			float A(3.0);
+			float B(2.0f);
+			float C = glm::mod(A, B);
+
+			Error += glm::equal(C, 1.0f, 0.00001f) ? 0 : 1;
+		}
+
+		{
+			glm::vec4 A(3.0);
+			float B(2.0f);
+			glm::vec4 C = glm::mod(A, B);
+
+			Error += glm::all(glm::equal(C, glm::vec4(1.0f), 0.00001f)) ? 0 : 1;
+		}
+
+		{
+			glm::vec4 A(3.0);
+			glm::vec4 B(2.0f);
+			glm::vec4 C = glm::mod(A, B);
+
+			Error += glm::all(glm::equal(C, glm::vec4(1.0f), 0.00001f)) ? 0 : 1;
+		}
+
+		return Error;
+	}
+}//namespace mod_
+
+namespace floatBitsToInt
+{
+	static int test()
+	{
+		int Error = 0;
+	
+		{
+			float A = 1.0f;
+			int B = glm::floatBitsToInt(A);
+			float C = glm::intBitsToFloat(B);
+			Error += glm::equal(A, C, 0.0001f) ? 0 : 1;
+		}
+
+		{
+			glm::vec2 A(1.0f, 2.0f);
+			glm::ivec2 B = glm::floatBitsToInt(A);
+			glm::vec2 C = glm::intBitsToFloat(B);
+			Error += glm::all(glm::equal(A, C, 0.0001f)) ? 0 : 1;
+		}
+
+		{
+			glm::vec3 A(1.0f, 2.0f, 3.0f);
+			glm::ivec3 B = glm::floatBitsToInt(A);
+			glm::vec3 C = glm::intBitsToFloat(B);
+			Error += glm::all(glm::equal(A, C, 0.0001f)) ? 0 : 1;
+		}
+	
+		{
+			glm::vec4 A(1.0f, 2.0f, 3.0f, 4.0f);
+			glm::ivec4 B = glm::floatBitsToInt(A);
+			glm::vec4 C = glm::intBitsToFloat(B);
+			Error += glm::all(glm::equal(A, C, 0.0001f)) ? 0 : 1;
+		}
+	
+		return Error;
+	}
+}//namespace floatBitsToInt
+
+namespace floatBitsToUint
+{
+	static int test()
+	{
+		int Error = 0;
+	
+		{
+			float A = 1.0f;
+			glm::uint B = glm::floatBitsToUint(A);
+			float C = glm::uintBitsToFloat(B);
+			Error += glm::equal(A, C, 0.0001f) ? 0 : 1;
+		}
+	
+		{
+			glm::vec2 A(1.0f, 2.0f);
+			glm::uvec2 B = glm::floatBitsToUint(A);
+			glm::vec2 C = glm::uintBitsToFloat(B);
+			Error += glm::all(glm::equal(A, C, 0.0001f)) ? 0 : 1;
+		}
+	
+		{
+			glm::vec3 A(1.0f, 2.0f, 3.0f);
+			glm::uvec3 B = glm::floatBitsToUint(A);
+			glm::vec3 C = glm::uintBitsToFloat(B);
+			Error += glm::all(glm::equal(A, C, 0.0001f)) ? 0 : 1;
+		}
+	
+		{
+			glm::vec4 A(1.0f, 2.0f, 3.0f, 4.0f);
+			glm::uvec4 B = glm::floatBitsToUint(A);
+			glm::vec4 C = glm::uintBitsToFloat(B);
+			Error += glm::all(glm::equal(A, C, 0.0001f)) ? 0 : 1;
+		}
+	
+		return Error;
+	}
+}//namespace floatBitsToUint
+
+namespace min_
+{
+	static int test()
+	{
+		int Error = 0;
+
+		glm::vec1 A0 = glm::min(glm::vec1(1), glm::vec1(1));
+		bool A1 = glm::all(glm::equal(A0, glm::vec1(1), glm::epsilon<float>()));
+		Error += A1 ? 0 : 1;
+
+		glm::vec2 B0 = glm::min(glm::vec2(1), glm::vec2(1));
+		glm::vec2 B1 = glm::min(glm::vec2(1), 1.0f);
+		bool B2 = glm::all(glm::equal(B0, B1, glm::epsilon<float>()));
+		Error += B2 ? 0 : 1;
+
+		glm::vec3 C0 = glm::min(glm::vec3(1), glm::vec3(1));
+		glm::vec3 C1 = glm::min(glm::vec3(1), 1.0f);
+		bool C2 = glm::all(glm::equal(C0, C1, glm::epsilon<float>()));
+		Error += C2 ? 0 : 1;
+
+		glm::vec4 D0 = glm::min(glm::vec4(1), glm::vec4(1));
+		glm::vec4 D1 = glm::min(glm::vec4(1), 1.0f);
+		bool D2 = glm::all(glm::equal(D0, D1, glm::epsilon<float>()));
+		Error += D2 ? 0 : 1;
+
+		return Error;
+	}
+
+	int min_tern(int a, int b)
+	{
+		return a < b ? a : b;
+	}
+
+	int min_int(int x, int y)
+	{
+		return y ^ ((x ^ y) & -(x < y)); 
+	}
+
+	static int perf(std::size_t Count)
+	{
+		std::vector<int> A(Count);
+		std::vector<int> B(Count);
+
+		std::size_t const InternalCount = 200000;
+
+		for(std::size_t i = 0; i < Count; ++i)
+		{
+			A[i] = glm::linearRand(-1000, 1000);
+			B[i] = glm::linearRand(-1000, 1000);
+		}
+
+		int Error = 0;
+
+		glm::int32 SumA = 0;
+		{
+			std::clock_t Timestamp0 = std::clock();
+
+			for (std::size_t j = 0; j < InternalCount; ++j)
+			for (std::size_t i = 0; i < Count; ++i)
+				SumA += min_tern(A[i], B[i]);
+
+			std::clock_t Timestamp1 = std::clock();
+
+			std::printf("min_tern Time %d clocks\n", static_cast<int>(Timestamp1 - Timestamp0));
+		}
+
+		glm::int32 SumB = 0;
+		{
+			std::clock_t Timestamp0 = std::clock();
+
+			for (std::size_t j = 0; j < InternalCount; ++j)
+			for (std::size_t i = 0; i < Count; ++i)
+				SumB += min_int(A[i], B[i]);
+
+			std::clock_t Timestamp1 = std::clock();
+
+			std::printf("min_int Time %d clocks\n", static_cast<int>(Timestamp1 - Timestamp0));
+		}
+
+		Error += SumA == SumB ? 0 : 1;
+
+		return Error;
+	}
+}//namespace min_
+
+namespace max_
+{
+	static int test()
+	{
+		int Error = 0;
+
+		glm::vec1 A0 = glm::max(glm::vec1(1), glm::vec1(1));
+		bool A1 = glm::all(glm::equal(A0, glm::vec1(1), glm::epsilon<float>()));
+		Error += A1 ? 0 : 1;
+
+
+		glm::vec2 B0 = glm::max(glm::vec2(1), glm::vec2(1));
+		glm::vec2 B1 = glm::max(glm::vec2(1), 1.0f);
+		bool B2 = glm::all(glm::equal(B0, B1, glm::epsilon<float>()));
+		Error += B2 ? 0 : 1;
+
+		glm::vec3 C0 = glm::max(glm::vec3(1), glm::vec3(1));
+		glm::vec3 C1 = glm::max(glm::vec3(1), 1.0f);
+		bool C2 = glm::all(glm::equal(C0, C1, glm::epsilon<float>()));
+		Error += C2 ? 0 : 1;
+
+		glm::vec4 D0 = glm::max(glm::vec4(1), glm::vec4(1));
+		glm::vec4 D1 = glm::max(glm::vec4(1), 1.0f);
+		bool D2 = glm::all(glm::equal(D0, D1, glm::epsilon<float>()));
+		Error += D2 ? 0 : 1;
+
+		return Error;
+	}
+}//namespace max_
+
+namespace clamp_
+{
+	static int test()
+	{
+		int Error = 0;
+
+		return Error;
+	}
+}//namespace clamp_
+
+namespace mix_
+{
+	template<typename T, typename B>
+	struct entry
+	{
+		T x;
+		T y;
+		B a;
+		T Result;
+	};
+
+	entry<float, bool> const TestBool[] =
+	{
+		{0.0f, 1.0f, false, 0.0f},
+		{0.0f, 1.0f, true, 1.0f},
+		{-1.0f, 1.0f, false, -1.0f},
+		{-1.0f, 1.0f, true, 1.0f}
+	};
+
+	entry<float, float> const TestFloat[] =
+	{
+		{0.0f, 1.0f, 0.0f, 0.0f},
+		{0.0f, 1.0f, 1.0f, 1.0f},
+		{-1.0f, 1.0f, 0.0f, -1.0f},
+		{-1.0f, 1.0f, 1.0f, 1.0f}
+	};
+
+	entry<glm::vec2, bool> const TestVec2Bool[] =
+	{
+		{glm::vec2(0.0f), glm::vec2(1.0f), false, glm::vec2(0.0f)},
+		{glm::vec2(0.0f), glm::vec2(1.0f), true, glm::vec2(1.0f)},
+		{glm::vec2(-1.0f), glm::vec2(1.0f), false, glm::vec2(-1.0f)},
+		{glm::vec2(-1.0f), glm::vec2(1.0f), true, glm::vec2(1.0f)}
+	};
+
+	entry<glm::vec2, glm::bvec2> const TestBVec2[] =
+	{
+		{glm::vec2(0.0f), glm::vec2(1.0f), glm::bvec2(false), glm::vec2(0.0f)},
+		{glm::vec2(0.0f), glm::vec2(1.0f), glm::bvec2(true), glm::vec2(1.0f)},
+		{glm::vec2(-1.0f), glm::vec2(1.0f), glm::bvec2(false), glm::vec2(-1.0f)},
+		{glm::vec2(-1.0f), glm::vec2(1.0f), glm::bvec2(true), glm::vec2(1.0f)},
+		{glm::vec2(-1.0f), glm::vec2(1.0f), glm::bvec2(true, false), glm::vec2(1.0f, -1.0f)}
+	};
+
+	entry<glm::vec3, bool> const TestVec3Bool[] =
+	{
+		{glm::vec3(0.0f), glm::vec3(1.0f), false, glm::vec3(0.0f)},
+		{glm::vec3(0.0f), glm::vec3(1.0f), true, glm::vec3(1.0f)},
+		{glm::vec3(-1.0f), glm::vec3(1.0f), false, glm::vec3(-1.0f)},
+		{glm::vec3(-1.0f), glm::vec3(1.0f), true, glm::vec3(1.0f)}
+	};
+
+	entry<glm::vec3, glm::bvec3> const TestBVec3[] =
+	{
+		{glm::vec3(0.0f), glm::vec3(1.0f), glm::bvec3(false), glm::vec3(0.0f)},
+		{glm::vec3(0.0f), glm::vec3(1.0f), glm::bvec3(true), glm::vec3(1.0f)},
+		{glm::vec3(-1.0f), glm::vec3(1.0f), glm::bvec3(false), glm::vec3(-1.0f)},
+		{glm::vec3(-1.0f), glm::vec3(1.0f), glm::bvec3(true), glm::vec3(1.0f)},
+		{glm::vec3(1.0f, 2.0f, 3.0f), glm::vec3(4.0f, 5.0f, 6.0f), glm::bvec3(true, false, true), glm::vec3(4.0f, 2.0f, 6.0f)}
+	};
+
+	entry<glm::vec4, bool> const TestVec4Bool[] = 
+	{
+		{glm::vec4(0.0f), glm::vec4(1.0f), false, glm::vec4(0.0f)},
+		{glm::vec4(0.0f), glm::vec4(1.0f), true, glm::vec4(1.0f)},
+		{glm::vec4(-1.0f), glm::vec4(1.0f), false, glm::vec4(-1.0f)},
+		{glm::vec4(-1.0f), glm::vec4(1.0f), true, glm::vec4(1.0f)}
+	};
+
+	entry<glm::vec4, glm::bvec4> const TestBVec4[] = 
+	{
+		{glm::vec4(0.0f, 0.0f, 1.0f, 1.0f), glm::vec4(2.0f, 2.0f, 3.0f, 3.0f), glm::bvec4(false, true, false, true), glm::vec4(0.0f, 2.0f, 1.0f, 3.0f)},
+		{glm::vec4(0.0f), glm::vec4(1.0f), glm::bvec4(true), glm::vec4(1.0f)},
+		{glm::vec4(-1.0f), glm::vec4(1.0f), glm::bvec4(false), glm::vec4(-1.0f)},
+		{glm::vec4(-1.0f), glm::vec4(1.0f), glm::bvec4(true), glm::vec4(1.0f)},
+		{glm::vec4(1.0f, 2.0f, 3.0f, 4.0f), glm::vec4(5.0f, 6.0f, 7.0f, 8.0f), glm::bvec4(true, false, true, false), glm::vec4(5.0f, 2.0f, 7.0f, 4.0f)}
+	};
+
+	static int test()
+	{
+		int Error = 0;
+
+		// Float with bool
+		{
+			for(std::size_t i = 0; i < sizeof(TestBool) / sizeof(entry<float, bool>); ++i)
+			{
+				float Result = glm::mix(TestBool[i].x, TestBool[i].y, TestBool[i].a);
+				Error += glm::equal(Result, TestBool[i].Result, glm::epsilon<float>()) ? 0 : 1;
+			}
+		}
+
+		// Float with float
+		{
+			for(std::size_t i = 0; i < sizeof(TestFloat) / sizeof(entry<float, float>); ++i)
+			{
+				float Result = glm::mix(TestFloat[i].x, TestFloat[i].y, TestFloat[i].a);
+				Error += glm::equal(Result, TestFloat[i].Result, glm::epsilon<float>()) ? 0 : 1;
+			}
+		}
+
+		// vec2 with bool
+		{
+			for(std::size_t i = 0; i < sizeof(TestVec2Bool) / sizeof(entry<glm::vec2, bool>); ++i)
+			{
+				glm::vec2 Result = glm::mix(TestVec2Bool[i].x, TestVec2Bool[i].y, TestVec2Bool[i].a);
+				Error += glm::equal(Result.x, TestVec2Bool[i].Result.x, glm::epsilon<float>()) ? 0 : 1;
+				Error += glm::equal(Result.y, TestVec2Bool[i].Result.y, glm::epsilon<float>()) ? 0 : 1;
+			}
+		}
+
+		// vec2 with bvec2
+		{
+			for(std::size_t i = 0; i < sizeof(TestBVec2) / sizeof(entry<glm::vec2, glm::bvec2>); ++i)
+			{
+				glm::vec2 Result = glm::mix(TestBVec2[i].x, TestBVec2[i].y, TestBVec2[i].a);
+				Error += glm::equal(Result.x, TestBVec2[i].Result.x, glm::epsilon<float>()) ? 0 : 1;
+				Error += glm::equal(Result.y, TestBVec2[i].Result.y, glm::epsilon<float>()) ? 0 : 1;
+			}
+		}
+
+		// vec3 with bool
+		{
+			for(std::size_t i = 0; i < sizeof(TestVec3Bool) / sizeof(entry<glm::vec3, bool>); ++i)
+			{
+				glm::vec3 Result = glm::mix(TestVec3Bool[i].x, TestVec3Bool[i].y, TestVec3Bool[i].a);
+				Error += glm::equal(Result.x, TestVec3Bool[i].Result.x, glm::epsilon<float>()) ? 0 : 1;
+				Error += glm::equal(Result.y, TestVec3Bool[i].Result.y, glm::epsilon<float>()) ? 0 : 1;
+				Error += glm::equal(Result.z, TestVec3Bool[i].Result.z, glm::epsilon<float>()) ? 0 : 1;
+			}
+		}
+
+		// vec3 with bvec3
+		{
+			for(std::size_t i = 0; i < sizeof(TestBVec3) / sizeof(entry<glm::vec3, glm::bvec3>); ++i)
+			{
+				glm::vec3 Result = glm::mix(TestBVec3[i].x, TestBVec3[i].y, TestBVec3[i].a);
+				Error += glm::equal(Result.x, TestBVec3[i].Result.x, glm::epsilon<float>()) ? 0 : 1;
+				Error += glm::equal(Result.y, TestBVec3[i].Result.y, glm::epsilon<float>()) ? 0 : 1;
+				Error += glm::equal(Result.z, TestBVec3[i].Result.z, glm::epsilon<float>()) ? 0 : 1;
+			}
+		}
+
+		// vec4 with bool
+		{
+			for(std::size_t i = 0; i < sizeof(TestVec4Bool) / sizeof(entry<glm::vec4, bool>); ++i)
+			{
+				glm::vec4 Result = glm::mix(TestVec4Bool[i].x, TestVec4Bool[i].y, TestVec4Bool[i].a);
+				Error += glm::equal(Result.x, TestVec4Bool[i].Result.x, glm::epsilon<float>()) ? 0 : 1;
+				Error += glm::equal(Result.y, TestVec4Bool[i].Result.y, glm::epsilon<float>()) ? 0 : 1;
+				Error += glm::equal(Result.z, TestVec4Bool[i].Result.z, glm::epsilon<float>()) ? 0 : 1;
+				Error += glm::equal(Result.w, TestVec4Bool[i].Result.w, glm::epsilon<float>()) ? 0 : 1;
+			}
+		}
+
+		// vec4 with bvec4
+		{
+			for(std::size_t i = 0; i < sizeof(TestBVec4) / sizeof(entry<glm::vec4, glm::bvec4>); ++i)
+			{
+				glm::vec4 Result = glm::mix(TestBVec4[i].x, TestBVec4[i].y, TestBVec4[i].a);
+				Error += glm::equal(Result.x, TestBVec4[i].Result.x, glm::epsilon<float>()) ? 0 : 1;
+				Error += glm::equal(Result.y, TestBVec4[i].Result.y, glm::epsilon<float>()) ? 0 : 1;
+				Error += glm::equal(Result.z, TestBVec4[i].Result.z, glm::epsilon<float>()) ? 0 : 1;
+				Error += glm::equal(Result.w, TestBVec4[i].Result.w, glm::epsilon<float>()) ? 0 : 1;
+			}
+		}
+
+		return Error;
+	}
+}//namespace mix_
+
+namespace step_
+{
+	template<typename EDGE, typename VEC>
+	struct entry
+	{
+		EDGE edge;
+		VEC x;
+		VEC result;
+	};
+
+	entry<float, glm::vec4> TestVec4Scalar [] =
+	{
+		{ 1.0f, glm::vec4(1.0f, 2.0f, 3.0f, 4.0f), glm::vec4(1.0f) },
+		{ 0.0f, glm::vec4(1.0f, 2.0f, 3.0f, 4.0f), glm::vec4(1.0f) },
+		{ 0.0f, glm::vec4(-1.0f, -2.0f, -3.0f, -4.0f), glm::vec4(0.0f) }
+	};
+
+	entry<glm::vec4, glm::vec4> TestVec4Vector [] =
+	{
+		{ glm::vec4(-1.0f, -2.0f, -3.0f, -4.0f), glm::vec4(-2.0f, -3.0f, -4.0f, -5.0f), glm::vec4(0.0f) },
+		{ glm::vec4( 0.0f, 1.0f, 2.0f, 3.0f), glm::vec4( 1.0f, 2.0f, 3.0f, 4.0f), glm::vec4(1.0f) },
+		{ glm::vec4( 2.0f, 3.0f, 4.0f, 5.0f), glm::vec4( 1.0f, 2.0f, 3.0f, 4.0f), glm::vec4(0.0f) },
+		{ glm::vec4( 0.0f, 1.0f, 2.0f, 3.0f), glm::vec4(-1.0f,-2.0f,-3.0f,-4.0f), glm::vec4(0.0f) }
+	};
+
+	static int test()
+	{
+		int Error = 0;
+
+		// scalar
+		{
+			float const Edge = 2.0f;
+
+			float const A = glm::step(Edge, 1.0f);
+			Error += glm::equal(A, 0.0f, glm::epsilon<float>()) ? 0 : 1;
+
+			float const B = glm::step(Edge, 3.0f);
+			Error += glm::equal(B, 1.0f, glm::epsilon<float>()) ? 0 : 1;
+
+			float const C = glm::step(Edge, 2.0f);
+			Error += glm::equal(C, 1.0f, glm::epsilon<float>()) ? 0 : 1;
+		}
+
+		// vec4 and float
+		{
+			for (std::size_t i = 0; i < sizeof(TestVec4Scalar) / sizeof(entry<float, glm::vec4>); ++i)
+			{
+				glm::vec4 Result = glm::step(TestVec4Scalar[i].edge, TestVec4Scalar[i].x);
+				Error += glm::all(glm::equal(Result, TestVec4Scalar[i].result, glm::epsilon<float>())) ? 0 : 1;
+			}
+		}
+
+		// vec4 and vec4
+		{
+			for (std::size_t i = 0; i < sizeof(TestVec4Vector) / sizeof(entry<glm::vec4, glm::vec4>); ++i)
+			{
+				glm::vec4 Result = glm::step(TestVec4Vector[i].edge, TestVec4Vector[i].x);
+				Error += glm::all(glm::equal(Result, TestVec4Vector[i].result, glm::epsilon<float>())) ? 0 : 1;
+			}
+		}
+
+		return Error;
+	}
+}//namespace step_
+
+namespace round_
+{
+	static int test()
+	{
+		int Error = 0;
+
+		{
+			float A = glm::round(0.0f);
+			Error += glm::equal(A, 0.0f, glm::epsilon<float>()) ? 0 : 1;
+			float B = glm::round(0.5f);
+			Error += glm::equal(B, 1.0f, glm::epsilon<float>()) ? 0 : 1;
+			float C = glm::round(1.0f);
+			Error += glm::equal(C, 1.0f, glm::epsilon<float>()) ? 0 : 1;
+			float D = glm::round(0.1f);
+			Error += glm::equal(D, 0.0f, glm::epsilon<float>()) ? 0 : 1;
+			float E = glm::round(0.9f);
+			Error += glm::equal(E, 1.0f, glm::epsilon<float>()) ? 0 : 1;
+			float F = glm::round(1.5f);
+			Error += glm::equal(F, 2.0f, glm::epsilon<float>()) ? 0 : 1;
+			float G = glm::round(1.9f);
+			Error += glm::equal(G, 2.0f, glm::epsilon<float>()) ? 0 : 1;
+		}
+	
+		{
+			float A = glm::round(-0.0f);
+			Error += glm::equal(A, 0.0f, glm::epsilon<float>()) ? 0 : 1;
+			float B = glm::round(-0.5f);
+			Error += glm::equal(B, -1.0f, glm::epsilon<float>()) ? 0 : 1;
+			float C = glm::round(-1.0f);
+			Error += glm::equal(C, -1.0f, glm::epsilon<float>()) ? 0 : 1;
+			float D = glm::round(-0.1f);
+			Error += glm::equal(D, 0.0f, glm::epsilon<float>()) ? 0 : 1;
+			float E = glm::round(-0.9f);
+			Error += glm::equal(E, -1.0f, glm::epsilon<float>()) ? 0 : 1;
+			float F = glm::round(-1.5f);
+			Error += glm::equal(F, -2.0f, glm::epsilon<float>()) ? 0 : 1;
+			float G = glm::round(-1.9f);
+			Error += glm::equal(G, -2.0f, glm::epsilon<float>()) ? 0 : 1;
+		}
+	
+		return Error;
+	}
+}//namespace round_
+
+namespace roundEven
+{
+	static int test()
+	{
+		int Error = 0;
+
+		{
+			float A1 = glm::roundEven(-1.5f);
+			Error += glm::equal(A1, -2.0f, 0.0001f) ? 0 : 1;
+
+			float A2 = glm::roundEven(1.5f);
+			Error += glm::equal(A2, 2.0f, 0.0001f) ? 0 : 1;
+
+			float A5 = glm::roundEven(-2.5f);
+			Error += glm::equal(A5, -2.0f, 0.0001f) ? 0 : 1;
+
+			float A6 = glm::roundEven(2.5f);
+			Error += glm::equal(A6, 2.0f, 0.0001f) ? 0 : 1;
+
+			float A3 = glm::roundEven(-3.5f);
+			Error += glm::equal(A3, -4.0f, 0.0001f) ? 0 : 1;
+
+			float A4 = glm::roundEven(3.5f);
+			Error += glm::equal(A4, 4.0f, 0.0001f) ? 0 : 1;
+
+			float C7 = glm::roundEven(-4.5f);
+			Error += glm::equal(C7, -4.0f, 0.0001f) ? 0 : 1;
+
+			float C8 = glm::roundEven(4.5f);
+			Error += glm::equal(C8, 4.0f, 0.0001f) ? 0 : 1;
+
+			float C1 = glm::roundEven(-5.5f);
+			Error += glm::equal(C1, -6.0f, 0.0001f) ? 0 : 1;
+
+			float C2 = glm::roundEven(5.5f);
+			Error += glm::equal(C2, 6.0f, 0.0001f) ? 0 : 1;
+
+			float C3 = glm::roundEven(-6.5f);
+			Error += glm::equal(C3, -6.0f, 0.0001f) ? 0 : 1;
+
+			float C4 = glm::roundEven(6.5f);
+			Error += glm::equal(C4, 6.0f, 0.0001f) ? 0 : 1;
+
+			float C5 = glm::roundEven(-7.5f);
+			Error += glm::equal(C5, -8.0f, 0.0001f) ? 0 : 1;
+
+			float C6 = glm::roundEven(7.5f);
+			Error += glm::equal(C6, 8.0f, 0.0001f) ? 0 : 1;
+
+			Error += 0;
+		}
+
+		{
+			float A7 = glm::roundEven(-2.4f);
+			Error += glm::equal(A7, -2.0f, 0.0001f) ? 0 : 1;
+
+			float A8 = glm::roundEven(2.4f);
+			Error += glm::equal(A8, 2.0f, 0.0001f) ? 0 : 1;
+
+			float B1 = glm::roundEven(-2.6f);
+			Error += glm::equal(B1, -3.0f, 0.0001f) ? 0 : 1;
+
+			float B2 = glm::roundEven(2.6f);
+			Error += glm::equal(B2, 3.0f, 0.0001f) ? 0 : 1;
+
+			float B3 = glm::roundEven(-2.0f);
+			Error += glm::equal(B3, -2.0f, 0.0001f) ? 0 : 1;
+
+			float B4 = glm::roundEven(2.0f);
+			Error += glm::equal(B4, 2.0f, 0.0001f) ? 0 : 1;
+
+			Error += 0;
+		}
+
+		{
+			float A = glm::roundEven(0.0f);
+			Error += glm::equal(A, 0.0f, glm::epsilon<float>()) ? 0 : 1;
+			float B = glm::roundEven(0.5f);
+			Error += glm::equal(B, 0.0f, glm::epsilon<float>()) ? 0 : 1;
+			float C = glm::roundEven(1.0f);
+			Error += glm::equal(C, 1.0f, glm::epsilon<float>()) ? 0 : 1;
+			float D = glm::roundEven(0.1f);
+			Error += glm::equal(D, 0.0f, glm::epsilon<float>()) ? 0 : 1;
+			float E = glm::roundEven(0.9f);
+			Error += glm::equal(E, 1.0f, glm::epsilon<float>()) ? 0 : 1;
+			float F = glm::roundEven(1.5f);
+			Error += glm::equal(F, 2.0f, glm::epsilon<float>()) ? 0 : 1;
+			float G = glm::roundEven(1.9f);
+			Error += glm::equal(G, 2.0f, glm::epsilon<float>()) ? 0 : 1;
+		}
+
+		{
+			float A = glm::roundEven(-0.0f);
+			Error += glm::equal(A,  0.0f, glm::epsilon<float>()) ? 0 : 1;
+			float B = glm::roundEven(-0.5f);
+			Error += glm::equal(B, -0.0f, glm::epsilon<float>()) ? 0 : 1;
+			float C = glm::roundEven(-1.0f);
+			Error += glm::equal(C, -1.0f, glm::epsilon<float>()) ? 0 : 1;
+			float D = glm::roundEven(-0.1f);
+			Error += glm::equal(D,  0.0f, glm::epsilon<float>()) ? 0 : 1;
+			float E = glm::roundEven(-0.9f);
+			Error += glm::equal(E, -1.0f, glm::epsilon<float>()) ? 0 : 1;
+			float F = glm::roundEven(-1.5f);
+			Error += glm::equal(F, -2.0f, glm::epsilon<float>()) ? 0 : 1;
+			float G = glm::roundEven(-1.9f);
+			Error += glm::equal(G, -2.0f, glm::epsilon<float>()) ? 0 : 1;
+		}
+
+		{
+			float A = glm::roundEven(1.5f);
+			Error += glm::equal(A, 2.0f, glm::epsilon<float>()) ? 0 : 1;
+			float B = glm::roundEven(2.5f);
+			Error += glm::equal(B, 2.0f, glm::epsilon<float>()) ? 0 : 1;
+			float C = glm::roundEven(3.5f);
+			Error += glm::equal(C, 4.0f, glm::epsilon<float>()) ? 0 : 1;
+			float D = glm::roundEven(4.5f);
+			Error += glm::equal(D, 4.0f, glm::epsilon<float>()) ? 0 : 1;
+			float E = glm::roundEven(5.5f);
+			Error += glm::equal(E, 6.0f, glm::epsilon<float>()) ? 0 : 1;
+			float F = glm::roundEven(6.5f);
+			Error += glm::equal(F, 6.0f, glm::epsilon<float>()) ? 0 : 1;
+			float G = glm::roundEven(7.5f);
+			Error += glm::equal(G, 8.0f, glm::epsilon<float>()) ? 0 : 1;
+		}
+	
+		{
+			float A = glm::roundEven(-1.5f);
+			Error += glm::equal(A, -2.0f, glm::epsilon<float>()) ? 0 : 1;
+			float B = glm::roundEven(-2.5f);
+			Error += glm::equal(B, -2.0f, glm::epsilon<float>()) ? 0 : 1;
+			float C = glm::roundEven(-3.5f);
+			Error += glm::equal(C, -4.0f, glm::epsilon<float>()) ? 0 : 1;
+			float D = glm::roundEven(-4.5f);
+			Error += glm::equal(D, -4.0f, glm::epsilon<float>()) ? 0 : 1;
+			float E = glm::roundEven(-5.5f);
+			Error += glm::equal(E, -6.0f, glm::epsilon<float>()) ? 0 : 1;
+			float F = glm::roundEven(-6.5f);
+			Error += glm::equal(F, -6.0f, glm::epsilon<float>()) ? 0 : 1;
+			float G = glm::roundEven(-7.5f);
+			Error += glm::equal(G, -8.0f, glm::epsilon<float>()) ? 0 : 1;
+		}
+
+		return Error;
+	}
+}//namespace roundEven
+
+namespace isnan_
+{
+	static int test()
+	{
+		int Error = 0;
+
+		float Zero_f = 0.0;
+		double Zero_d = 0.0;
+
+		{
+			Error += true == glm::isnan(0.0/Zero_d) ? 0 : 1;
+			Error += true == glm::any(glm::isnan(glm::dvec2(0.0 / Zero_d))) ? 0 : 1;
+			Error += true == glm::any(glm::isnan(glm::dvec3(0.0 / Zero_d))) ? 0 : 1;
+			Error += true == glm::any(glm::isnan(glm::dvec4(0.0 / Zero_d))) ? 0 : 1;
+		}
+
+		{
+			Error += true == glm::isnan(0.0f/Zero_f) ? 0 : 1;
+			Error += true == glm::any(glm::isnan(glm::vec2(0.0f/Zero_f))) ? 0 : 1;
+			Error += true == glm::any(glm::isnan(glm::vec3(0.0f/Zero_f))) ? 0 : 1;
+			Error += true == glm::any(glm::isnan(glm::vec4(0.0f/Zero_f))) ? 0 : 1;
+		}
+
+		return Error;
+	}
+}//namespace isnan_
+
+namespace isinf_
+{
+	static int test()
+	{
+		int Error = 0;
+
+		float Zero_f = 0.0;
+		double Zero_d = 0.0;
+
+		{
+			Error += true == glm::isinf( 1.0/Zero_d) ? 0 : 1;
+			Error += true == glm::isinf(-1.0/Zero_d) ? 0 : 1;
+			Error += true == glm::any(glm::isinf(glm::dvec2( 1.0/Zero_d))) ? 0 : 1;
+			Error += true == glm::any(glm::isinf(glm::dvec2(-1.0/Zero_d))) ? 0 : 1;
+			Error += true == glm::any(glm::isinf(glm::dvec3( 1.0/Zero_d))) ? 0 : 1;
+			Error += true == glm::any(glm::isinf(glm::dvec3(-1.0/Zero_d))) ? 0 : 1;
+			Error += true == glm::any(glm::isinf(glm::dvec4( 1.0/Zero_d))) ? 0 : 1;
+			Error += true == glm::any(glm::isinf(glm::dvec4(-1.0/Zero_d))) ? 0 : 1;
+		}
+
+		{
+			Error += true == glm::isinf( 1.0f/Zero_f) ? 0 : 1;
+			Error += true == glm::isinf(-1.0f/Zero_f) ? 0 : 1;
+			Error += true == glm::any(glm::isinf(glm::vec2( 1.0f/Zero_f))) ? 0 : 1;
+			Error += true == glm::any(glm::isinf(glm::vec2(-1.0f/Zero_f))) ? 0 : 1;
+			Error += true == glm::any(glm::isinf(glm::vec3( 1.0f/Zero_f))) ? 0 : 1;
+			Error += true == glm::any(glm::isinf(glm::vec3(-1.0f/Zero_f))) ? 0 : 1;
+			Error += true == glm::any(glm::isinf(glm::vec4( 1.0f/Zero_f))) ? 0 : 1;
+			Error += true == glm::any(glm::isinf(glm::vec4(-1.0f/Zero_f))) ? 0 : 1;
+		}
+
+		return Error;
+	}
+}//namespace isinf_
+
+namespace sign
+{
+	template<typename genFIType> 
+	GLM_FUNC_QUALIFIER genFIType sign_if(genFIType x)
+	{
+		GLM_STATIC_ASSERT(
+			std::numeric_limits<genFIType>::is_iec559 ||
+			(std::numeric_limits<genFIType>::is_signed && std::numeric_limits<genFIType>::is_integer), "'sign' only accept signed inputs");
+
+		genFIType result;
+		if(x > genFIType(0))
+			result = genFIType(1);
+		else if(x < genFIType(0))
+			result = genFIType(-1);
+		else
+			result = genFIType(0);
+		return result;
+	}
+
+	template<typename genFIType> 
+	GLM_FUNC_QUALIFIER genFIType sign_alu1(genFIType x)
+	{
+		GLM_STATIC_ASSERT(
+			std::numeric_limits<genFIType>::is_signed && std::numeric_limits<genFIType>::is_integer, 
+			"'sign' only accept integer inputs");
+
+		return (x >> 31) | (static_cast<unsigned>(-x) >> 31);
+	}
+
+	GLM_FUNC_QUALIFIER int sign_alu2(int x)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<int>::is_signed && std::numeric_limits<int>::is_integer, "'sign' only accept integer inputs");
+
+#		if GLM_COMPILER & GLM_COMPILER_VC
+#			pragma warning(push)
+#			pragma warning(disable : 4146) //cast truncates constant value
+#		endif
+
+		return -(static_cast<unsigned>(x) >> 31) | (-static_cast<unsigned>(x) >> 31);
+
+#		if GLM_COMPILER & GLM_COMPILER_VC
+#			pragma warning(pop)
+#		endif
+	}
+
+	template<typename genFIType> 
+	GLM_FUNC_QUALIFIER genFIType sign_sub(genFIType x)
+	{
+		GLM_STATIC_ASSERT(
+			std::numeric_limits<genFIType>::is_signed && std::numeric_limits<genFIType>::is_integer, 
+			"'sign' only accept integer inputs");
+
+		return (static_cast<unsigned>(-x) >> 31) - (static_cast<unsigned>(x) >> 31);
+	}
+
+	template<typename genFIType> 
+	GLM_FUNC_QUALIFIER genFIType sign_cmp(genFIType x)
+	{
+		GLM_STATIC_ASSERT(
+			std::numeric_limits<genFIType>::is_signed && std::numeric_limits<genFIType>::is_integer, 
+			"'sign' only accept integer inputs");
+
+		return (x > 0) - (x < 0);
+	}
+
+	template<typename genType>
+	struct type
+	{
+		genType		Value;
+		genType		Return;
+	};
+
+	int test_int32()
+	{
+		type<glm::int32> const Data[] =
+		{
+			{ std::numeric_limits<glm::int32>::max(),  1},
+			{ std::numeric_limits<glm::int32>::min(), -1},
+			{ 0, 0},
+			{ 1, 1},
+			{ 2, 1},
+			{ 3, 1},
+			{-1,-1},
+			{-2,-1},
+			{-3,-1}
+		};
+
+		int Error = 0;
+
+		for(std::size_t i = 0; i < sizeof(Data) / sizeof(type<glm::int32>); ++i)
+		{
+			glm::int32 Result = glm::sign(Data[i].Value);
+			Error += Data[i].Return == Result ? 0 : 1;
+		}
+
+		for(std::size_t i = 0; i < sizeof(Data) / sizeof(type<glm::int32>); ++i)
+		{
+			glm::int32 Result = sign_cmp(Data[i].Value);
+			Error += Data[i].Return == Result ? 0 : 1;
+		}
+
+		for(std::size_t i = 0; i < sizeof(Data) / sizeof(type<glm::int32>); ++i)
+		{
+			glm::int32 Result = sign_if(Data[i].Value);
+			Error += Data[i].Return == Result ? 0 : 1;
+		}
+
+		for(std::size_t i = 0; i < sizeof(Data) / sizeof(type<glm::int32>); ++i)
+		{
+			glm::int32 Result = sign_alu1(Data[i].Value);
+			Error += Data[i].Return == Result ? 0 : 1;
+		}
+
+		for(std::size_t i = 0; i < sizeof(Data) / sizeof(type<glm::int32>); ++i)
+		{
+			glm::int32 Result = sign_alu2(Data[i].Value);
+			Error += Data[i].Return == Result ? 0 : 1;
+		}
+
+		return Error;
+	}
+
+	int test_i32vec4()
+	{
+		type<glm::ivec4> const Data[] =
+		{
+			{glm::ivec4( 1), glm::ivec4( 1)},
+			{glm::ivec4( 0), glm::ivec4( 0)},
+			{glm::ivec4( 2), glm::ivec4( 1)},
+			{glm::ivec4( 3), glm::ivec4( 1)},
+			{glm::ivec4(-1), glm::ivec4(-1)},
+			{glm::ivec4(-2), glm::ivec4(-1)},
+			{glm::ivec4(-3), glm::ivec4(-1)}
+		};
+
+		int Error = 0;
+
+		for(std::size_t i = 0; i < sizeof(Data) / sizeof(type<glm::ivec4>); ++i)
+		{
+			glm::ivec4 Result = glm::sign(Data[i].Value);
+			Error += glm::all(glm::equal(Data[i].Return, Result)) ? 0 : 1;
+		}
+
+		return Error;
+	}
+
+	int test_f32vec4()
+	{
+		type<glm::vec4> const Data[] =
+		{
+			{glm::vec4( 1), glm::vec4( 1)},
+			{glm::vec4( 0), glm::vec4( 0)},
+			{glm::vec4( 2), glm::vec4( 1)},
+			{glm::vec4( 3), glm::vec4( 1)},
+			{glm::vec4(-1), glm::vec4(-1)},
+			{glm::vec4(-2), glm::vec4(-1)},
+			{glm::vec4(-3), glm::vec4(-1)}
+		};
+
+		int Error = 0;
+
+		for(std::size_t i = 0; i < sizeof(Data) / sizeof(type<glm::vec4>); ++i)
+		{
+			glm::vec4 Result = glm::sign(Data[i].Value);
+			Error += glm::all(glm::equal(Data[i].Return, Result, glm::epsilon<float>())) ? 0 : 1;
+		}
+
+		return Error;
+	}
+
+	static int test()
+	{
+		int Error = 0;
+
+		Error += test_int32();
+		Error += test_i32vec4();
+		Error += test_f32vec4();
+
+		return Error;
+	}
+
+	int perf_rand(std::size_t Samples)
+	{
+		int Error = 0;
+
+		std::size_t const Count = Samples;
+		std::vector<glm::int32> Input, Output;
+		Input.resize(Count);
+		Output.resize(Count);
+		for(std::size_t i = 0; i < Count; ++i)
+			Input[i] = static_cast<glm::int32>(glm::linearRand(-65536.f, 65536.f));
+
+		std::clock_t Timestamp0 = std::clock();
+
+		for(std::size_t i = 0; i < Count; ++i)
+			Output[i] = sign_cmp(Input[i]);
+
+		std::clock_t Timestamp1 = std::clock();
+
+		for(std::size_t i = 0; i < Count; ++i)
+			Output[i] = sign_if(Input[i]);
+
+		std::clock_t Timestamp2 = std::clock();
+
+		for(std::size_t i = 0; i < Count; ++i)
+			Output[i] = sign_alu1(Input[i]);
+
+		std::clock_t Timestamp3 = std::clock();
+
+		for(std::size_t i = 0; i < Count; ++i)
+			Output[i] = sign_alu2(Input[i]);
+
+		std::clock_t Timestamp4 = std::clock();
+
+		for(std::size_t i = 0; i < Count; ++i)
+			Output[i] = sign_sub(Input[i]);
+
+		std::clock_t Timestamp5 = std::clock();
+
+		for(std::size_t i = 0; i < Count; ++i)
+			Output[i] = glm::sign(Input[i]);
+
+		std::clock_t Timestamp6 = std::clock();
+
+		std::printf("sign_cmp(rand) Time %d clocks\n", static_cast<int>(Timestamp1 - Timestamp0));
+		std::printf("sign_if(rand) Time %d clocks\n", static_cast<int>(Timestamp2 - Timestamp1));
+		std::printf("sign_alu1(rand) Time %d clocks\n", static_cast<int>(Timestamp3 - Timestamp2));
+		std::printf("sign_alu2(rand) Time %d clocks\n", static_cast<int>(Timestamp4 - Timestamp3));
+		std::printf("sign_sub(rand) Time %d clocks\n", static_cast<int>(Timestamp5 - Timestamp4));
+		std::printf("glm::sign(rand) Time %d clocks\n", static_cast<int>(Timestamp6 - Timestamp5));
+
+		return Error;
+	}
+
+	int perf_linear(std::size_t Samples)
+	{
+		int Error = 0;
+
+		std::size_t const Count = Samples;
+		std::vector<glm::int32> Input, Output;
+		Input.resize(Count);
+		Output.resize(Count);
+		for(std::size_t i = 0; i < Count; ++i)
+			Input[i] = static_cast<glm::int32>(i);
+
+		std::clock_t Timestamp0 = std::clock();
+
+		for(std::size_t i = 0; i < Count; ++i)
+			Output[i] = sign_cmp(Input[i]);
+
+		std::clock_t Timestamp1 = std::clock();
+
+		for(std::size_t i = 0; i < Count; ++i)
+			Output[i] = sign_if(Input[i]);
+
+		std::clock_t Timestamp2 = std::clock();
+
+		for(std::size_t i = 0; i < Count; ++i)
+			Output[i] = sign_alu1(Input[i]);
+
+		std::clock_t Timestamp3 = std::clock();
+
+		for(std::size_t i = 0; i < Count; ++i)
+			Output[i] = sign_alu2(Input[i]);
+
+		std::clock_t Timestamp4 = std::clock();
+
+		for(std::size_t i = 0; i < Count; ++i)
+			Output[i] = sign_sub(Input[i]);
+
+		std::clock_t Timestamp5 = std::clock();
+
+		std::printf("sign_cmp(linear) Time %d clocks\n", static_cast<int>(Timestamp1 - Timestamp0));
+		std::printf("sign_if(linear) Time %d clocks\n", static_cast<int>(Timestamp2 - Timestamp1));
+		std::printf("sign_alu1(linear) Time %d clocks\n", static_cast<int>(Timestamp3 - Timestamp2));
+		std::printf("sign_alu2(linear) Time %d clocks\n", static_cast<int>(Timestamp4 - Timestamp3));
+		std::printf("sign_sub(linear) Time %d clocks\n", static_cast<int>(Timestamp5 - Timestamp4));
+
+		return Error;
+	}
+
+	int perf_linear_cal(std::size_t Samples)
+	{
+		int Error = 0;
+
+		glm::int32 const Count = static_cast<glm::int32>(Samples);
+
+		std::clock_t Timestamp0 = std::clock();
+		glm::int32 Sum = 0;
+
+		for(glm::int32 i = 1; i < Count; ++i)
+			Sum += sign_cmp(i);
+
+		std::clock_t Timestamp1 = std::clock();
+
+		for(glm::int32 i = 1; i < Count; ++i)
+			Sum += sign_if(i);
+
+		std::clock_t Timestamp2 = std::clock();
+
+		for(glm::int32 i = 1; i < Count; ++i)
+			Sum += sign_alu1(i);
+
+		std::clock_t Timestamp3 = std::clock();
+
+		for(glm::int32 i = 1; i < Count; ++i)
+			Sum += sign_alu2(i);
+
+		std::clock_t Timestamp4 = std::clock();
+
+		for(glm::int32 i = 1; i < Count; ++i)
+			Sum += sign_sub(i);
+
+		std::clock_t Timestamp5 = std::clock();
+
+		std::printf("Sum %d\n", static_cast<int>(Sum));
+
+		std::printf("sign_cmp(linear_cal) Time %d clocks\n", static_cast<int>(Timestamp1 - Timestamp0));
+		std::printf("sign_if(linear_cal) Time %d clocks\n", static_cast<int>(Timestamp2 - Timestamp1));
+		std::printf("sign_alu1(linear_cal) Time %d clocks\n", static_cast<int>(Timestamp3 - Timestamp2));
+		std::printf("sign_alu2(linear_cal) Time %d clocks\n", static_cast<int>(Timestamp4 - Timestamp3));
+		std::printf("sign_sub(linear_cal) Time %d clocks\n", static_cast<int>(Timestamp5 - Timestamp4));
+
+		return Error;
+	}
+
+	static int perf(std::size_t Samples)
+	{
+		int Error(0);
+
+		Error += perf_linear_cal(Samples);
+		Error += perf_linear(Samples);
+		Error += perf_rand(Samples);
+
+		return Error;
+	}
+}//namespace sign
+
+namespace frexp_
+{
+	static int test()
+	{
+		int Error = 0;
+
+		{
+			glm::vec1 const x(1024);
+			glm::ivec1 exp;
+			glm::vec1 A = glm::frexp(x, exp);
+			Error += glm::all(glm::equal(A, glm::vec1(0.5), glm::epsilon<float>())) ? 0 : 1;
+			Error += glm::all(glm::equal(exp, glm::ivec1(11))) ? 0 : 1;
+		}
+
+		{
+			glm::vec2 const x(1024, 0.24);
+			glm::ivec2 exp;
+			glm::vec2 A = glm::frexp(x, exp);
+			Error += glm::all(glm::equal(A, glm::vec2(0.5, 0.96), glm::epsilon<float>())) ? 0 : 1;
+			Error += glm::all(glm::equal(exp, glm::ivec2(11, -2))) ? 0 : 1;
+		}
+
+		{
+			glm::vec3 const x(1024, 0.24, 0);
+			glm::ivec3 exp;
+			glm::vec3 A = glm::frexp(x, exp);
+			Error += glm::all(glm::equal(A, glm::vec3(0.5, 0.96, 0.0), glm::epsilon<float>())) ? 0 : 1;
+			Error += glm::all(glm::equal(exp, glm::ivec3(11, -2, 0))) ? 0 : 1;
+		}
+
+		{
+			glm::vec4 const x(1024, 0.24, 0, -1.33);
+			glm::ivec4 exp;
+			glm::vec4 A = glm::frexp(x, exp);
+			Error += glm::all(glm::equal(A, glm::vec4(0.5, 0.96, 0.0, -0.665), glm::epsilon<float>())) ? 0 : 1;
+			Error += glm::all(glm::equal(exp, glm::ivec4(11, -2, 0, 1))) ? 0 : 1;
+		}
+
+		return Error;
+	}
+}//namespace frexp_
+
+namespace ldexp_
+{
+	static int test()
+	{
+		int Error(0);
+
+		{
+			glm::vec1 A = glm::vec1(0.5);
+			glm::ivec1 exp = glm::ivec1(11);
+			glm::vec1 x = glm::ldexp(A, exp);
+			Error += glm::all(glm::equal(x, glm::vec1(1024),0.00001f)) ? 0 : 1;
+		}
+
+		{
+			glm::vec2 A = glm::vec2(0.5, 0.96);
+			glm::ivec2 exp = glm::ivec2(11, -2);
+			glm::vec2 x = glm::ldexp(A, exp);
+			Error += glm::all(glm::equal(x, glm::vec2(1024, .24),0.00001f)) ? 0 : 1;
+		}
+
+		{
+			glm::vec3 A = glm::vec3(0.5, 0.96, 0.0);
+			glm::ivec3 exp = glm::ivec3(11, -2, 0);
+			glm::vec3 x = glm::ldexp(A, exp);
+			Error += glm::all(glm::equal(x, glm::vec3(1024, .24, 0),0.00001f)) ? 0 : 1;
+		}
+
+		{
+			glm::vec4 A = glm::vec4(0.5, 0.96, 0.0, -0.665);
+			glm::ivec4 exp = glm::ivec4(11, -2, 0, 1);
+			glm::vec4 x = glm::ldexp(A, exp);
+			Error += glm::all(glm::equal(x, glm::vec4(1024, .24, 0, -1.33),0.00001f)) ? 0 : 1;
+		}
+
+		return Error;
+	}
+}//namespace ldexp_
+
+static int test_constexpr()
+{
+#if GLM_HAS_CONSTEXPR
+	static_assert(glm::abs(1.0f) > 0.0f, "GLM: Failed constexpr");
+	constexpr glm::vec1 const A = glm::abs(glm::vec1(1.0f));
+	constexpr glm::vec2 const B = glm::abs(glm::vec2(1.0f));
+	constexpr glm::vec3 const C = glm::abs(glm::vec3(1.0f));
+	constexpr glm::vec4 const D = glm::abs(glm::vec4(1.0f));
+#endif // GLM_HAS_CONSTEXPR
+
+	return 0;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_constexpr();
+	Error += sign::test();
+	Error += floor_::test();
+	Error += mod_::test();
+	Error += modf_::test();
+	Error += floatBitsToInt::test();
+	Error += floatBitsToUint::test();
+	Error += mix_::test();
+	Error += step_::test();
+	Error += max_::test();
+	Error += min_::test();
+	Error += clamp_::test();
+	Error += round_::test();
+	Error += roundEven::test();
+	Error += isnan_::test();
+	Error += isinf_::test();
+	Error += frexp_::test();
+	Error += ldexp_::test();
+
+#	ifdef NDEBUG
+		std::size_t Samples = 1000;
+#	else
+		std::size_t Samples = 1;
+#	endif
+	Error += sign::perf(Samples);
+
+	Error += min_::perf(Samples);
+
+	return Error;
+}
+
diff --git a/3rdparty/glm/source/test/core/core_func_exponential.cpp b/3rdparty/glm/source/test/core/core_func_exponential.cpp
new file mode 100644
index 0000000..380cdfb
--- /dev/null
+++ b/3rdparty/glm/source/test/core/core_func_exponential.cpp
@@ -0,0 +1,185 @@
+#include <glm/gtc/constants.hpp>
+#include <glm/ext/scalar_relational.hpp>
+#include <glm/ext/vector_relational.hpp>
+#include <glm/ext/vector_float1.hpp>
+#include <glm/ext/vector_float2.hpp>
+#include <glm/ext/vector_float3.hpp>
+#include <glm/ext/vector_float4.hpp>
+#include <glm/common.hpp>
+#include <glm/exponential.hpp>
+
+static int test_pow()
+{
+	int Error(0);
+
+	float A = glm::pow(2.f, 2.f);
+	Error += glm::equal(A, 4.f, 0.01f) ? 0 : 1;
+
+	glm::vec1 B = glm::pow(glm::vec1(2.f), glm::vec1(2.f));
+	Error += glm::all(glm::equal(B, glm::vec1(4.f), 0.01f)) ? 0 : 1;
+
+	glm::vec2 C = glm::pow(glm::vec2(2.f), glm::vec2(2.f));
+	Error += glm::all(glm::equal(C, glm::vec2(4.f), 0.01f)) ? 0 : 1;
+
+	glm::vec3 D = glm::pow(glm::vec3(2.f), glm::vec3(2.f));
+	Error += glm::all(glm::equal(D, glm::vec3(4.f), 0.01f)) ? 0 : 1;
+
+	glm::vec4 E = glm::pow(glm::vec4(2.f), glm::vec4(2.f));
+	Error += glm::all(glm::equal(E, glm::vec4(4.f), 0.01f)) ? 0 : 1;
+
+	return Error;
+}
+
+static int test_sqrt()
+{
+	int Error = 0;
+
+	float A = glm::sqrt(4.f);
+	Error += glm::equal(A, 2.f, 0.01f) ? 0 : 1;
+
+	glm::vec1 B = glm::sqrt(glm::vec1(4.f));
+	Error += glm::all(glm::equal(B, glm::vec1(2.f), 0.01f)) ? 0 : 1;
+
+	glm::vec2 C = glm::sqrt(glm::vec2(4.f));
+	Error += glm::all(glm::equal(C, glm::vec2(2.f), 0.01f)) ? 0 : 1;
+
+	glm::vec3 D = glm::sqrt(glm::vec3(4.f));
+	Error += glm::all(glm::equal(D, glm::vec3(2.f), 0.01f)) ? 0 : 1;
+
+	glm::vec4 E = glm::sqrt(glm::vec4(4.f));
+	Error += glm::all(glm::equal(E, glm::vec4(2.f), 0.01f)) ? 0 : 1;
+
+	return Error;
+}
+
+static int test_exp()
+{
+	int Error = 0;
+
+	float A = glm::exp(1.f);
+	Error += glm::equal(A, glm::e<float>(), 0.01f) ? 0 : 1;
+
+	glm::vec1 B = glm::exp(glm::vec1(1.f));
+	Error += glm::all(glm::equal(B, glm::vec1(glm::e<float>()), 0.01f)) ? 0 : 1;
+
+	glm::vec2 C = glm::exp(glm::vec2(1.f));
+	Error += glm::all(glm::equal(C, glm::vec2(glm::e<float>()), 0.01f)) ? 0 : 1;
+
+	glm::vec3 D = glm::exp(glm::vec3(1.f));
+	Error += glm::all(glm::equal(D, glm::vec3(glm::e<float>()), 0.01f)) ? 0 : 1;
+
+	glm::vec4 E = glm::exp(glm::vec4(1.f));
+	Error += glm::all(glm::equal(E, glm::vec4(glm::e<float>()), 0.01f)) ? 0 : 1;
+
+	return Error;
+}
+
+static int test_log()
+{
+	int Error = 0;
+
+	float const A = glm::log(glm::e<float>());
+	Error += glm::equal(A, 1.f, 0.01f) ? 0 : 1;
+
+	glm::vec1 const B = glm::log(glm::vec1(glm::e<float>()));
+	Error += glm::all(glm::equal(B, glm::vec1(1.f), 0.01f)) ? 0 : 1;
+
+	glm::vec2 const C = glm::log(glm::vec2(glm::e<float>()));
+	Error += glm::all(glm::equal(C, glm::vec2(1.f), 0.01f)) ? 0 : 1;
+
+	glm::vec3 const D = glm::log(glm::vec3(glm::e<float>()));
+	Error += glm::all(glm::equal(D, glm::vec3(1.f), 0.01f)) ? 0 : 1;
+
+	glm::vec4 const E = glm::log(glm::vec4(glm::e<float>()));
+	Error += glm::all(glm::equal(E, glm::vec4(1.f), 0.01f)) ? 0 : 1;
+
+	return Error;
+}
+
+static int test_exp2()
+{
+	int Error = 0;
+
+	float A = glm::exp2(4.f);
+	Error += glm::equal(A, 16.f, 0.01f) ? 0 : 1;
+
+	glm::vec1 B = glm::exp2(glm::vec1(4.f));
+	Error += glm::all(glm::equal(B, glm::vec1(16.f), 0.01f)) ? 0 : 1;
+
+	glm::vec2 C = glm::exp2(glm::vec2(4.f, 3.f));
+	Error += glm::all(glm::equal(C, glm::vec2(16.f, 8.f), 0.01f)) ? 0 : 1;
+
+	glm::vec3 D = glm::exp2(glm::vec3(4.f, 3.f, 2.f));
+	Error += glm::all(glm::equal(D, glm::vec3(16.f, 8.f, 4.f), 0.01f)) ? 0 : 1;
+
+	glm::vec4 E = glm::exp2(glm::vec4(4.f, 3.f, 2.f, 1.f));
+	Error += glm::all(glm::equal(E, glm::vec4(16.f, 8.f, 4.f, 2.f), 0.01f)) ? 0 : 1;
+
+#   if GLM_HAS_CXX11_STL
+	//large exponent
+	float F = glm::exp2(23.f);
+	Error += glm::equal(F, 8388608.f, 0.01f) ? 0 : 1;
+#   endif
+
+	return Error;
+}
+
+static int test_log2()
+{
+	int Error = 0;
+
+	float A = glm::log2(16.f);
+	Error += glm::equal(A, 4.f, 0.01f) ? 0 : 1;
+
+	glm::vec1 B = glm::log2(glm::vec1(16.f));
+	Error += glm::all(glm::equal(B, glm::vec1(4.f), 0.01f)) ? 0 : 1;
+
+	glm::vec2 C = glm::log2(glm::vec2(16.f, 8.f));
+	Error += glm::all(glm::equal(C, glm::vec2(4.f, 3.f), 0.01f)) ? 0 : 1;
+
+	glm::vec3 D = glm::log2(glm::vec3(16.f, 8.f, 4.f));
+	Error += glm::all(glm::equal(D, glm::vec3(4.f, 3.f, 2.f), 0.01f)) ? 0 : 1;
+
+	glm::vec4 E = glm::log2(glm::vec4(16.f, 8.f, 4.f, 2.f));
+	Error += glm::all(glm::equal(E, glm::vec4(4.f, 3.f, 2.f, 1.f), 0.01f)) ? 0 : 1;
+
+	return Error;
+}
+
+static int test_inversesqrt()
+{
+	int Error = 0;
+
+	float A = glm::inversesqrt(16.f) * glm::sqrt(16.f);
+	Error += glm::equal(A, 1.f, 0.01f) ? 0 : 1;
+
+	glm::vec1 B = glm::inversesqrt(glm::vec1(16.f)) * glm::sqrt(16.f);
+	Error += glm::all(glm::equal(B, glm::vec1(1.f), 0.01f)) ? 0 : 1;
+
+	glm::vec2 C = glm::inversesqrt(glm::vec2(16.f)) * glm::sqrt(16.f);
+	Error += glm::all(glm::equal(C, glm::vec2(1.f), 0.01f)) ? 0 : 1;
+
+	glm::vec3 D = glm::inversesqrt(glm::vec3(16.f)) * glm::sqrt(16.f);
+	Error += glm::all(glm::equal(D, glm::vec3(1.f), 0.01f)) ? 0 : 1;
+
+	glm::vec4 E = glm::inversesqrt(glm::vec4(16.f)) * glm::sqrt(16.f);
+	Error += glm::all(glm::equal(E, glm::vec4(1.f), 0.01f)) ? 0 : 1;
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_pow();
+	Error += test_sqrt();
+	Error += test_exp();
+	Error += test_log();
+	Error += test_exp2();
+	Error += test_log2();
+	Error += test_inversesqrt();
+
+	return Error;
+}
+
diff --git a/3rdparty/glm/source/test/core/core_func_geometric.cpp b/3rdparty/glm/source/test/core/core_func_geometric.cpp
new file mode 100644
index 0000000..7ef9c68
--- /dev/null
+++ b/3rdparty/glm/source/test/core/core_func_geometric.cpp
@@ -0,0 +1,200 @@
+#include <glm/geometric.hpp>
+#include <glm/trigonometric.hpp>
+#include <glm/ext/scalar_relational.hpp>
+#include <glm/ext/vector_relational.hpp>
+#include <glm/ext/vector_float1.hpp>
+#include <glm/ext/vector_float2.hpp>
+#include <glm/ext/vector_float3.hpp>
+#include <glm/ext/vector_float4.hpp>
+#include <glm/ext/vector_double2.hpp>
+#include <glm/ext/vector_double3.hpp>
+#include <glm/ext/vector_double4.hpp>
+#include <limits>
+
+namespace length
+{
+	int test()
+	{
+		float Length1 = glm::length(glm::vec1(1));
+		float Length2 = glm::length(glm::vec2(1, 0));
+		float Length3 = glm::length(glm::vec3(1, 0, 0));
+		float Length4 = glm::length(glm::vec4(1, 0, 0, 0));
+
+		int Error = 0;
+
+		Error += glm::abs(Length1 - 1.0f) < std::numeric_limits<float>::epsilon() ? 0 : 1;
+		Error += glm::abs(Length2 - 1.0f) < std::numeric_limits<float>::epsilon() ? 0 : 1;
+		Error += glm::abs(Length3 - 1.0f) < std::numeric_limits<float>::epsilon() ? 0 : 1;
+		Error += glm::abs(Length4 - 1.0f) < std::numeric_limits<float>::epsilon() ? 0 : 1;
+
+		return Error;
+	}
+}//namespace length
+
+namespace distance
+{
+	int test()
+	{
+		float Distance1 = glm::distance(glm::vec1(1), glm::vec1(1));
+		float Distance2 = glm::distance(glm::vec2(1, 0), glm::vec2(1, 0));
+		float Distance3 = glm::distance(glm::vec3(1, 0, 0), glm::vec3(1, 0, 0));
+		float Distance4 = glm::distance(glm::vec4(1, 0, 0, 0), glm::vec4(1, 0, 0, 0));
+
+		int Error = 0;
+
+		Error += glm::abs(Distance1) < std::numeric_limits<float>::epsilon() ? 0 : 1;
+		Error += glm::abs(Distance2) < std::numeric_limits<float>::epsilon() ? 0 : 1;
+		Error += glm::abs(Distance3) < std::numeric_limits<float>::epsilon() ? 0 : 1;
+		Error += glm::abs(Distance4) < std::numeric_limits<float>::epsilon() ? 0 : 1;
+
+		return Error;
+	}
+}//namespace distance
+
+namespace dot
+{
+	int test()
+	{
+		float Dot1 = glm::dot(glm::vec1(1), glm::vec1(1));
+		float Dot2 = glm::dot(glm::vec2(1), glm::vec2(1));
+		float Dot3 = glm::dot(glm::vec3(1), glm::vec3(1));
+		float Dot4 = glm::dot(glm::vec4(1), glm::vec4(1));
+
+		int Error = 0;
+
+		Error += glm::abs(Dot1 - 1.0f) < std::numeric_limits<float>::epsilon() ? 0 : 1;
+		Error += glm::abs(Dot2 - 2.0f) < std::numeric_limits<float>::epsilon() ? 0 : 1;
+		Error += glm::abs(Dot3 - 3.0f) < std::numeric_limits<float>::epsilon() ? 0 : 1;
+		Error += glm::abs(Dot4 - 4.0f) < std::numeric_limits<float>::epsilon() ? 0 : 1;
+
+		return Error;
+	}
+}//namespace dot
+
+namespace cross
+{
+	int test()
+	{
+		glm::vec3 Cross1 = glm::cross(glm::vec3(1, 0, 0), glm::vec3(0, 1, 0));
+		glm::vec3 Cross2 = glm::cross(glm::vec3(0, 1, 0), glm::vec3(1, 0, 0));
+
+		int Error = 0;
+
+		Error += glm::all(glm::lessThan(glm::abs(Cross1 - glm::vec3(0, 0, 1)), glm::vec3(std::numeric_limits<float>::epsilon()))) ? 0 : 1;
+		Error += glm::all(glm::lessThan(glm::abs(Cross2 - glm::vec3(0, 0,-1)), glm::vec3(std::numeric_limits<float>::epsilon()))) ? 0 : 1;
+
+		return Error;
+	}
+}//namespace cross
+
+namespace normalize
+{
+	int test()
+	{
+		glm::vec3 Normalize1 = glm::normalize(glm::vec3(1, 0, 0));
+		glm::vec3 Normalize2 = glm::normalize(glm::vec3(2, 0, 0));
+
+		glm::vec3 Normalize3 = glm::normalize(glm::vec3(-0.6, 0.7, -0.5));
+
+		glm::vec3 ro = glm::vec3(glm::cos(5.f) * 3.f, 2.f, glm::sin(5.f) * 3.f);
+		glm::vec3 w = glm::normalize(glm::vec3(0, -0.2f, 0) - ro);
+		glm::vec3 u = glm::normalize(glm::cross(w, glm::vec3(0, 1, 0)));
+		glm::vec3 v = glm::cross(u, w);
+
+		int Error = 0;
+
+		Error += glm::all(glm::lessThan(glm::abs(Normalize1 - glm::vec3(1, 0, 0)), glm::vec3(std::numeric_limits<float>::epsilon()))) ? 0 : 1;
+		Error += glm::all(glm::lessThan(glm::abs(Normalize2 - glm::vec3(1, 0, 0)), glm::vec3(std::numeric_limits<float>::epsilon()))) ? 0 : 1;
+
+		return Error;
+	}
+}//namespace normalize
+
+namespace faceforward
+{
+	int test()
+	{
+		int Error = 0;
+
+		{
+			glm::vec3 N(0.0f, 0.0f, 1.0f);
+			glm::vec3 I(1.0f, 0.0f, 1.0f);
+			glm::vec3 Nref(0.0f, 0.0f, 1.0f);
+			glm::vec3 F = glm::faceforward(N, I, Nref);
+		}
+
+		return Error;
+	}
+}//namespace faceforward
+
+namespace reflect
+{
+	int test()
+	{
+		int Error = 0;
+
+		{
+			glm::vec2 A(1.0f,-1.0f);
+			glm::vec2 B(0.0f, 1.0f);
+			glm::vec2 C = glm::reflect(A, B);
+			Error += glm::all(glm::equal(C, glm::vec2(1.0, 1.0), 0.0001f)) ? 0 : 1;
+		}
+
+		{
+			glm::dvec2 A(1.0f,-1.0f);
+			glm::dvec2 B(0.0f, 1.0f);
+			glm::dvec2 C = glm::reflect(A, B);
+			Error += glm::all(glm::equal(C, glm::dvec2(1.0, 1.0), 0.0001)) ? 0 : 1;
+		}
+
+		return Error;
+	}
+}//namespace reflect
+
+namespace refract
+{
+	int test()
+	{
+		int Error = 0;
+
+		{
+			float A(-1.0f);
+			float B(1.0f);
+			float C = glm::refract(A, B, 0.5f);
+			Error += glm::equal(C, -1.0f, 0.0001f) ? 0 : 1;
+		}
+
+		{
+			glm::vec2 A(0.0f,-1.0f);
+			glm::vec2 B(0.0f, 1.0f);
+			glm::vec2 C = glm::refract(A, B, 0.5f);
+			Error += glm::all(glm::equal(C, glm::vec2(0.0, -1.0), 0.0001f)) ? 0 : 1;
+		}
+
+		{
+			glm::dvec2 A(0.0f,-1.0f);
+			glm::dvec2 B(0.0f, 1.0f);
+			glm::dvec2 C = glm::refract(A, B, 0.5);
+			Error += glm::all(glm::equal(C, glm::dvec2(0.0, -1.0), 0.0001)) ? 0 : 1;
+		}
+
+		return Error;
+	}
+}//namespace refract
+
+int main()
+{
+	int Error(0);
+
+	Error += length::test();
+	Error += distance::test();
+	Error += dot::test();
+	Error += cross::test();
+	Error += normalize::test();
+	Error += faceforward::test();
+	Error += reflect::test();
+	Error += refract::test();
+
+	return Error;
+}
+
diff --git a/3rdparty/glm/source/test/core/core_func_integer.cpp b/3rdparty/glm/source/test/core/core_func_integer.cpp
new file mode 100644
index 0000000..95d650c
--- /dev/null
+++ b/3rdparty/glm/source/test/core/core_func_integer.cpp
@@ -0,0 +1,1556 @@
+#include <glm/integer.hpp>
+#include <glm/vector_relational.hpp>
+#include <glm/ext/vector_int1.hpp>
+#include <glm/ext/vector_int2.hpp>
+#include <glm/ext/vector_int3.hpp>
+#include <glm/ext/vector_int4.hpp>
+#include <glm/ext/vector_uint1.hpp>
+#include <glm/ext/vector_uint2.hpp>
+#include <glm/ext/vector_uint3.hpp>
+#include <glm/ext/vector_uint4.hpp>
+#include <glm/ext/scalar_int_sized.hpp>
+#include <glm/ext/scalar_uint_sized.hpp>
+#include <vector>
+#include <ctime>
+#include <cstdio>
+
+enum result
+{
+	SUCCESS,
+	FAIL,
+	ASSERT,
+	STATIC_ASSERT
+};
+
+namespace bitfieldInsert
+{
+	template<typename genType>
+	struct type
+	{
+		genType		Base;
+		genType		Insert;
+		int			Offset;
+		int			Bits;
+		genType		Return;
+	};
+
+	typedef type<glm::uint> typeU32;
+
+	typeU32 const Data32[] =
+	{
+		{0x00000000, 0xffffffff,  0, 32, 0xffffffff},
+		{0x00000000, 0xffffffff,  0, 31, 0x7fffffff},
+		{0x00000000, 0xffffffff,  0,  0, 0x00000000},
+		{0xff000000, 0x000000ff,  8,  8, 0xff00ff00},
+		{0xffff0000, 0xffff0000, 16, 16, 0x00000000},
+		{0x0000ffff, 0x0000ffff, 16, 16, 0xffffffff}
+	};
+
+	static int test()
+	{
+		int Error = 0;
+		glm::uint count = sizeof(Data32) / sizeof(typeU32);
+		
+		for(glm::uint i = 0; i < count; ++i)
+		{
+			glm::uint Return = glm::bitfieldInsert(
+				Data32[i].Base,
+				Data32[i].Insert,
+				Data32[i].Offset,
+				Data32[i].Bits);
+
+			Error += Data32[i].Return == Return ? 0 : 1;
+		}
+		
+		return Error;
+	}
+}//bitfieldInsert
+
+namespace bitfieldExtract
+{
+	template<typename genType>
+	struct type
+	{
+		genType		Value;
+		int			Offset;
+		int			Bits;
+		genType		Return;
+		result		Result;
+	};
+
+	typedef type<glm::uint> typeU32;
+
+	typeU32 const Data32[] =
+	{
+		{0xffffffff, 0,32, 0xffffffff, SUCCESS},
+		{0xffffffff, 8, 0, 0x00000000, SUCCESS},
+		{0x00000000, 0,32, 0x00000000, SUCCESS},
+		{0x0f0f0f0f, 0,32, 0x0f0f0f0f, SUCCESS},
+		{0x00000000, 8, 0, 0x00000000, SUCCESS},
+		{0x80000000,31, 1, 0x00000001, SUCCESS},
+		{0x7fffffff,31, 1, 0x00000000, SUCCESS},
+		{0x00000300, 8, 8, 0x00000003, SUCCESS},
+		{0x0000ff00, 8, 8, 0x000000ff, SUCCESS},
+		{0xfffffff0, 0, 5, 0x00000010, SUCCESS},
+		{0x000000ff, 1, 3, 0x00000007, SUCCESS},
+		{0x000000ff, 0, 3, 0x00000007, SUCCESS},
+		{0x00000000, 0, 2, 0x00000000, SUCCESS},
+		{0xffffffff, 0, 8, 0x000000ff, SUCCESS},
+		{0xffff0000,16,16, 0x0000ffff, SUCCESS},
+		{0xfffffff0, 0, 8, 0x00000000, FAIL},
+		{0xffffffff,16,16, 0x00000000, FAIL},
+		//{0xffffffff,32, 1, 0x00000000, ASSERT}, // Throw an assert 
+		//{0xffffffff, 0,33, 0x00000000, ASSERT}, // Throw an assert 
+		//{0xffffffff,16,16, 0x00000000, ASSERT}, // Throw an assert 
+	};
+
+	static int test()
+	{
+		int Error = 0;
+
+		glm::uint count = sizeof(Data32) / sizeof(typeU32);
+
+		for(glm::uint i = 0; i < count; ++i)
+		{
+			glm::uint Return = glm::bitfieldExtract(
+				Data32[i].Value, 
+				Data32[i].Offset, 
+				Data32[i].Bits);
+			
+			bool Compare = Data32[i].Return == Return;
+
+			if(Data32[i].Result == SUCCESS && Compare)
+				continue;
+			else if(Data32[i].Result == FAIL && !Compare)
+				continue;
+
+			Error += 1;
+		}
+
+		return Error;
+	}
+}//extractField
+
+namespace bitfieldReverse
+{
+/*
+	GLM_FUNC_QUALIFIER unsigned int bitfieldReverseLoop(unsigned int v)
+	{
+		unsigned int Result(0);
+		unsigned int const BitSize = static_cast<unsigned int>(sizeof(unsigned int) * 8);
+		for(unsigned int i = 0; i < BitSize; ++i)
+		{
+			unsigned int const BitSet(v & (static_cast<unsigned int>(1) << i));
+			unsigned int const BitFirst(BitSet >> i);
+			Result |= BitFirst << (BitSize - 1 - i);
+		}
+		return Result;
+	}
+
+	GLM_FUNC_QUALIFIER glm::uint64_t bitfieldReverseLoop(glm::uint64_t v)
+	{
+		glm::uint64_t Result(0);
+		glm::uint64_t const BitSize = static_cast<glm::uint64_t>(sizeof(unsigned int) * 8);
+		for(glm::uint64_t i = 0; i < BitSize; ++i)
+		{
+			glm::uint64_t const BitSet(v & (static_cast<glm::uint64_t>(1) << i));
+			glm::uint64_t const BitFirst(BitSet >> i);
+			Result |= BitFirst << (BitSize - 1 - i);
+		}
+		return Result;
+	}
+*/
+	template<glm::length_t L, typename T, glm::qualifier Q>
+	GLM_FUNC_QUALIFIER glm::vec<L, T, Q> bitfieldReverseLoop(glm::vec<L, T, Q> const& v)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_integer, "'bitfieldReverse' only accept integer values");
+
+		glm::vec<L, T, Q> Result(0);
+		T const BitSize = static_cast<T>(sizeof(T) * 8);
+		for(T i = 0; i < BitSize; ++i)
+		{
+			glm::vec<L, T, Q> const BitSet(v & (static_cast<T>(1) << i));
+			glm::vec<L, T, Q> const BitFirst(BitSet >> i);
+			Result |= BitFirst << (BitSize - 1 - i);
+		}
+		return Result;
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER T bitfieldReverseLoop(T v)
+	{
+		return bitfieldReverseLoop(glm::vec<1, T>(v)).x;
+	}
+
+	GLM_FUNC_QUALIFIER glm::uint32 bitfieldReverseUint32(glm::uint32 x)
+	{
+		x = (x & 0x55555555) <<  1 | (x & 0xAAAAAAAA) >>  1;
+		x = (x & 0x33333333) <<  2 | (x & 0xCCCCCCCC) >>  2;
+		x = (x & 0x0F0F0F0F) <<  4 | (x & 0xF0F0F0F0) >>  4;
+		x = (x & 0x00FF00FF) <<  8 | (x & 0xFF00FF00) >>  8;
+		x = (x & 0x0000FFFF) << 16 | (x & 0xFFFF0000) >> 16;
+		return x;
+	}
+
+	GLM_FUNC_QUALIFIER glm::uint64 bitfieldReverseUint64(glm::uint64 x)
+	{
+		x = (x & 0x5555555555555555) <<  1 | (x & 0xAAAAAAAAAAAAAAAA) >>  1;
+		x = (x & 0x3333333333333333) <<  2 | (x & 0xCCCCCCCCCCCCCCCC) >>  2;
+		x = (x & 0x0F0F0F0F0F0F0F0F) <<  4 | (x & 0xF0F0F0F0F0F0F0F0) >>  4;
+		x = (x & 0x00FF00FF00FF00FF) <<  8 | (x & 0xFF00FF00FF00FF00) >>  8;
+		x = (x & 0x0000FFFF0000FFFF) << 16 | (x & 0xFFFF0000FFFF0000) >> 16;
+		x = (x & 0x00000000FFFFFFFF) << 32 | (x & 0xFFFFFFFF00000000) >> 32;
+		return x;
+	}
+
+	template<bool EXEC = false>
+	struct compute_bitfieldReverseStep
+	{
+		template<glm::length_t L, typename T, glm::qualifier Q>
+		GLM_FUNC_QUALIFIER static glm::vec<L, T, Q> call(glm::vec<L, T, Q> const& v, T, T)
+		{
+			return v;
+		}
+	};
+
+	template<>
+	struct compute_bitfieldReverseStep<true>
+	{
+		template<glm::length_t L, typename T, glm::qualifier Q>
+		GLM_FUNC_QUALIFIER static glm::vec<L, T, Q> call(glm::vec<L, T, Q> const& v, T Mask, T Shift)
+		{
+			return (v & Mask) << Shift | (v & (~Mask)) >> Shift;
+		}
+	};
+
+	template<glm::length_t L, typename T, glm::qualifier Q>
+	GLM_FUNC_QUALIFIER glm::vec<L, T, Q> bitfieldReverseOps(glm::vec<L, T, Q> const& v)
+	{
+		glm::vec<L, T, Q> x(v);
+		x = compute_bitfieldReverseStep<sizeof(T) * 8 >=  2>::call(x, static_cast<T>(0x5555555555555555ull), static_cast<T>( 1));
+		x = compute_bitfieldReverseStep<sizeof(T) * 8 >=  4>::call(x, static_cast<T>(0x3333333333333333ull), static_cast<T>( 2));
+		x = compute_bitfieldReverseStep<sizeof(T) * 8 >=  8>::call(x, static_cast<T>(0x0F0F0F0F0F0F0F0Full), static_cast<T>( 4));
+		x = compute_bitfieldReverseStep<sizeof(T) * 8 >= 16>::call(x, static_cast<T>(0x00FF00FF00FF00FFull), static_cast<T>( 8));
+		x = compute_bitfieldReverseStep<sizeof(T) * 8 >= 32>::call(x, static_cast<T>(0x0000FFFF0000FFFFull), static_cast<T>(16));
+		x = compute_bitfieldReverseStep<sizeof(T) * 8 >= 64>::call(x, static_cast<T>(0x00000000FFFFFFFFull), static_cast<T>(32));
+		return x;
+	}
+
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType bitfieldReverseOps(genType x)
+	{
+		return bitfieldReverseOps(glm::vec<1, genType, glm::defaultp>(x)).x;
+	}
+
+	template<typename genType>
+	struct type
+	{
+		genType		Value;
+		genType		Return;
+		result		Result;
+	};
+
+	typedef type<glm::uint> typeU32;
+
+	typeU32 const Data32[] =
+	{
+		{0x00000001, 0x80000000, SUCCESS},
+		{0x0000000f, 0xf0000000, SUCCESS},
+		{0x000000ff, 0xff000000, SUCCESS},
+		{0xf0000000, 0x0000000f, SUCCESS},
+		{0xff000000, 0x000000ff, SUCCESS},
+		{0xffffffff, 0xffffffff, SUCCESS},
+		{0x00000000, 0x00000000, SUCCESS}
+	};
+
+	typedef type<glm::uint64> typeU64;
+
+	typeU64 const Data64[] =
+	{
+		{0x00000000000000ff, 0xff00000000000000, SUCCESS},
+		{0x000000000000000f, 0xf000000000000000, SUCCESS},
+		{0xf000000000000000, 0x000000000000000f, SUCCESS},
+		{0xffffffffffffffff, 0xffffffffffffffff, SUCCESS},
+		{0x0000000000000000, 0x0000000000000000, SUCCESS}
+	};
+
+	static int test32_bitfieldReverse()
+	{
+		int Error = 0;
+		std::size_t const Count = sizeof(Data32) / sizeof(typeU32);
+		
+		for(std::size_t i = 0; i < Count; ++i)
+		{
+			glm::uint Return = glm::bitfieldReverse(Data32[i].Value);
+			
+			bool Compare = Data32[i].Return == Return;
+			
+			if(Data32[i].Result == SUCCESS)
+				Error += Compare ? 0 : 1;
+			else
+				Error += Compare ? 1 : 0;
+		}
+		
+		return Error;
+	}
+
+	static int test32_bitfieldReverseLoop()
+	{
+		int Error = 0;
+		std::size_t const Count = sizeof(Data32) / sizeof(typeU32);
+		
+		for(std::size_t i = 0; i < Count; ++i)
+		{
+			glm::uint Return = bitfieldReverseLoop(Data32[i].Value);
+			
+			bool Compare = Data32[i].Return == Return;
+			
+			if(Data32[i].Result == SUCCESS)
+				Error += Compare ? 0 : 1;
+			else
+				Error += Compare ? 1 : 0;
+		}
+		
+		return Error;
+	}
+
+	static int test32_bitfieldReverseUint32()
+	{
+		int Error = 0;
+		std::size_t const Count = sizeof(Data32) / sizeof(typeU32);
+		
+		for(std::size_t i = 0; i < Count; ++i)
+		{
+			glm::uint Return = bitfieldReverseUint32(Data32[i].Value);
+			
+			bool Compare = Data32[i].Return == Return;
+			
+			if(Data32[i].Result == SUCCESS)
+				Error += Compare ? 0 : 1;
+			else
+				Error += Compare ? 1 : 0;
+		}
+		
+		return Error;
+	}
+
+	static int test32_bitfieldReverseOps()
+	{
+		int Error = 0;
+		std::size_t const Count = sizeof(Data32) / sizeof(typeU32);
+		
+		for(std::size_t i = 0; i < Count; ++i)
+		{
+			glm::uint Return = bitfieldReverseOps(Data32[i].Value);
+			
+			bool Compare = Data32[i].Return == Return;
+			
+			if(Data32[i].Result == SUCCESS)
+				Error += Compare ? 0 : 1;
+			else
+				Error += Compare ? 1 : 0;
+		}
+		
+		return Error;
+	}
+
+	static int test64_bitfieldReverse()
+	{
+		int Error = 0;
+		std::size_t const Count = sizeof(Data64) / sizeof(typeU64);
+		
+		for(std::size_t i = 0; i < Count; ++i)
+		{
+			glm::uint64 Return = glm::bitfieldReverse(Data64[i].Value);
+			
+			bool Compare = Data64[i].Return == Return;
+			
+			if(Data64[i].Result == SUCCESS)
+				Error += Compare ? 0 : 1;
+			else
+				Error += Compare ? 1 : 0;
+		}
+		
+		return Error;
+	}
+
+	static int test64_bitfieldReverseLoop()
+	{
+		int Error = 0;
+		std::size_t const Count = sizeof(Data64) / sizeof(typeU64);
+		
+		for(std::size_t i = 0; i < Count; ++i)
+		{
+			glm::uint64 Return = bitfieldReverseLoop(Data64[i].Value);
+			
+			bool Compare = Data64[i].Return == Return;
+			
+			if(Data32[i].Result == SUCCESS)
+				Error += Compare ? 0 : 1;
+			else
+				Error += Compare ? 1 : 0;
+		}
+		
+		return Error;
+	}
+
+	static int test64_bitfieldReverseUint64()
+	{
+		int Error = 0;
+		std::size_t const Count = sizeof(Data64) / sizeof(typeU64);
+		
+		for(std::size_t i = 0; i < Count; ++i)
+		{
+			glm::uint64 Return = bitfieldReverseUint64(Data64[i].Value);
+			
+			bool Compare = Data64[i].Return == Return;
+			
+			if(Data64[i].Result == SUCCESS)
+				Error += Compare ? 0 : 1;
+			else
+				Error += Compare ? 1 : 0;
+		}
+		
+		return Error;
+	}
+
+	static int test64_bitfieldReverseOps()
+	{
+		int Error = 0;
+		std::size_t const Count = sizeof(Data64) / sizeof(typeU64);
+		
+		for(std::size_t i = 0; i < Count; ++i)
+		{
+			glm::uint64 Return = bitfieldReverseOps(Data64[i].Value);
+			
+			bool Compare = Data64[i].Return == Return;
+			
+			if(Data64[i].Result == SUCCESS)
+				Error += Compare ? 0 : 1;
+			else
+				Error += Compare ? 1 : 0;
+		}
+		
+		return Error;
+	}
+
+	static int test()
+	{
+		int Error = 0;
+
+		Error += test32_bitfieldReverse();
+		Error += test32_bitfieldReverseLoop();
+		Error += test32_bitfieldReverseUint32();
+		Error += test32_bitfieldReverseOps();
+
+		Error += test64_bitfieldReverse();
+		Error += test64_bitfieldReverseLoop();
+		Error += test64_bitfieldReverseUint64();
+		Error += test64_bitfieldReverseOps();
+
+		return Error;
+	}
+
+	static int perf32(glm::uint32 Count)
+	{
+		int Error = 0;
+
+		std::vector<glm::uint32> Data;
+		Data.resize(static_cast<std::size_t>(Count));
+
+		std::clock_t Timestamps0 = std::clock();
+
+		for(glm::uint32 k = 0; k < Count; ++k)
+			Data[k] = glm::bitfieldReverse(k);
+
+		std::clock_t Timestamps1 = std::clock();
+
+		for(glm::uint32 k = 0; k < Count; ++k)
+			Data[k] = bitfieldReverseLoop(k);
+
+		std::clock_t Timestamps2 = std::clock();
+
+		for(glm::uint32 k = 0; k < Count; ++k)
+			Data[k] = bitfieldReverseUint32(k);
+
+		std::clock_t Timestamps3 = std::clock();
+
+		for(glm::uint32 k = 0; k < Count; ++k)
+			Data[k] = bitfieldReverseOps(k);
+
+		std::clock_t Timestamps4 = std::clock();
+
+		std::printf("glm::bitfieldReverse: %d clocks\n", static_cast<int>(Timestamps1 - Timestamps0));
+		std::printf("bitfieldReverseLoop: %d clocks\n", static_cast<int>(Timestamps2 - Timestamps1));
+		std::printf("bitfieldReverseUint32: %d clocks\n", static_cast<int>(Timestamps3 - Timestamps2));
+		std::printf("bitfieldReverseOps: %d clocks\n", static_cast<int>(Timestamps4 - Timestamps3));
+
+		return Error;
+	}
+
+	static int perf64(glm::uint64 Count)
+	{
+		int Error = 0;
+
+		std::vector<glm::uint64> Data;
+		Data.resize(static_cast<std::size_t>(Count));
+
+		std::clock_t Timestamps0 = std::clock();
+
+		for(glm::uint64 k = 0; k < Count; ++k)
+			Data[static_cast<std::size_t>(k)] = glm::bitfieldReverse(k);
+
+		std::clock_t Timestamps1 = std::clock();
+
+		for(glm::uint64 k = 0; k < Count; ++k)
+			Data[static_cast<std::size_t>(k)] = bitfieldReverseLoop<glm::uint64>(k);
+
+		std::clock_t Timestamps2 = std::clock();
+
+		for(glm::uint64 k = 0; k < Count; ++k)
+			Data[static_cast<std::size_t>(k)] = bitfieldReverseUint64(k);
+
+		std::clock_t Timestamps3 = std::clock();
+
+		for(glm::uint64 k = 0; k < Count; ++k)
+			Data[static_cast<std::size_t>(k)] = bitfieldReverseOps(k);
+
+		std::clock_t Timestamps4 = std::clock();
+
+		std::printf("glm::bitfieldReverse - 64: %d clocks\n", static_cast<int>(Timestamps1 - Timestamps0));
+		std::printf("bitfieldReverseLoop - 64: %d clocks\n", static_cast<int>(Timestamps2 - Timestamps1));
+		std::printf("bitfieldReverseUint - 64: %d clocks\n", static_cast<int>(Timestamps3 - Timestamps2));
+		std::printf("bitfieldReverseOps - 64: %d clocks\n", static_cast<int>(Timestamps4 - Timestamps3));
+
+		return Error;
+	}
+
+	static int perf(std::size_t Samples)
+	{
+		int Error = 0;
+
+		Error += perf32(static_cast<glm::uint32>(Samples));
+		Error += perf64(static_cast<glm::uint64>(Samples));
+
+		return Error;
+	}
+}//bitfieldReverse
+
+namespace findMSB
+{
+	template<typename genType, typename retType>
+	struct type
+	{
+		genType		Value;
+		retType		Return;
+	};
+
+#	if GLM_HAS_BITSCAN_WINDOWS
+		template<typename genIUType>
+		static int findMSB_intrinsic(genIUType Value)
+		{
+			GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'findMSB' only accept integer values");
+
+			if(Value == 0)
+				return -1;
+
+			unsigned long Result(0);
+			_BitScanReverse(&Result, Value);
+			return int(Result);
+		}
+#	endif//GLM_HAS_BITSCAN_WINDOWS
+
+#	if GLM_ARCH & GLM_ARCH_AVX && GLM_COMPILER & GLM_COMPILER_VC
+		template<typename genIUType>
+		static int findMSB_avx(genIUType Value)
+		{
+			GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'findMSB' only accept integer values");
+
+			if(Value == 0)
+				return -1;
+
+			return int(_tzcnt_u32(Value));
+		}
+#	endif//GLM_ARCH & GLM_ARCH_AVX && GLM_PLATFORM & GLM_PLATFORM_WINDOWS
+
+	template<typename genIUType>
+	static int findMSB_095(genIUType Value)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'findMSB' only accept integer values");
+		
+		if(Value == genIUType(0) || Value == genIUType(-1))
+			return -1;
+		else if(Value > 0)
+		{
+			genIUType Bit = genIUType(-1);
+			for(genIUType tmp = Value; tmp > 0; tmp >>= 1, ++Bit){}
+			return static_cast<int>(Bit);
+		}
+		else //if(Value < 0)
+		{
+			int const BitCount(sizeof(genIUType) * 8);
+			int MostSignificantBit(-1);
+			for(int BitIndex(0); BitIndex < BitCount; ++BitIndex)
+				MostSignificantBit = (Value & (1 << BitIndex)) ? MostSignificantBit : BitIndex;
+			assert(MostSignificantBit >= 0);
+			return MostSignificantBit;
+		}
+	}
+
+	template<typename genIUType>
+	static int findMSB_nlz1(genIUType x)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'findMSB' only accept integer values");
+
+		if (x == 0)
+			return -1;
+
+		int n = 0;
+		if (x <= 0x0000FFFF) {n = n +16; x = x <<16;}
+		if (x <= 0x00FFFFFF) {n = n + 8; x = x << 8;}
+		if (x <= 0x0FFFFFFF) {n = n + 4; x = x << 4;}
+		if (x <= 0x3FFFFFFF) {n = n + 2; x = x << 2;}
+		if (x <= 0x7FFFFFFF) {n = n + 1;}
+		return 31 - n;
+	}
+
+	static int findMSB_nlz2(unsigned int x)
+	{
+		unsigned int y;
+		int n = 32;
+
+		y = x >>16;  if (y != 0) {n = n -16;  x = y;}
+		y = x >> 8;  if (y != 0) {n = n - 8;  x = y;}
+		y = x >> 4;  if (y != 0) {n = n - 4;  x = y;}
+		y = x >> 2;  if (y != 0) {n = n - 2;  x = y;}
+		y = x >> 1;  if (y != 0) return n - 2;
+		return 32 - (n - static_cast<int>(x));
+	}
+
+	static int findMSB_pop(unsigned int x)
+	{
+		x = x | (x >> 1);
+		x = x | (x >> 2);
+		x = x | (x >> 4);
+		x = x | (x >> 8);
+		x = x | (x >>16);
+		return 31 - glm::bitCount(~x);
+	}
+
+	static int perf_int(std::size_t Count)
+	{
+		type<int, int> const Data[] =
+		{
+			{0x00000000, -1},
+			{0x00000001,  0},
+			{0x00000002,  1},
+			{0x00000003,  1},
+			{0x00000004,  2},
+			{0x00000005,  2},
+			{0x00000007,  2},
+			{0x00000008,  3},
+			{0x00000010,  4},
+			{0x00000020,  5},
+			{0x00000040,  6},
+			{0x00000080,  7},
+			{0x00000100,  8},
+			{0x00000200,  9},
+			{0x00000400, 10},
+			{0x00000800, 11},
+			{0x00001000, 12},
+			{0x00002000, 13},
+			{0x00004000, 14},
+			{0x00008000, 15},
+			{0x00010000, 16},
+			{0x00020000, 17},
+			{0x00040000, 18},
+			{0x00080000, 19},
+			{0x00100000, 20},
+			{0x00200000, 21},
+			{0x00400000, 22},
+			{0x00800000, 23},
+			{0x01000000, 24},
+			{0x02000000, 25},
+			{0x04000000, 26},
+			{0x08000000, 27},
+			{0x10000000, 28},
+			{0x20000000, 29},
+			{0x40000000, 30}
+		};
+
+		int Error(0);
+
+		std::clock_t Timestamps0 = std::clock();
+
+		for(std::size_t k = 0; k < Count; ++k)
+		for(std::size_t i = 0; i < sizeof(Data) / sizeof(type<int, int>); ++i)
+		{
+			int Result = glm::findMSB(Data[i].Value);
+			Error += Data[i].Return == Result ? 0 : 1;
+		}
+
+		std::clock_t Timestamps1 = std::clock();
+
+		for(std::size_t k = 0; k < Count; ++k)
+		for(std::size_t i = 0; i < sizeof(Data) / sizeof(type<int, int>); ++i)
+		{
+			int Result = findMSB_nlz1(Data[i].Value);
+			Error += Data[i].Return == Result ? 0 : 1;
+		}
+
+		std::clock_t Timestamps2 = std::clock();
+
+		for(std::size_t k = 0; k < Count; ++k)
+		for(std::size_t i = 0; i < sizeof(Data) / sizeof(type<int, int>); ++i)
+		{
+			int Result = findMSB_nlz2(static_cast<unsigned int>(Data[i].Value));
+			Error += Data[i].Return == Result ? 0 : 1;
+		}
+
+		std::clock_t Timestamps3 = std::clock();
+
+		for(std::size_t k = 0; k < Count; ++k)
+		for(std::size_t i = 0; i < sizeof(Data) / sizeof(type<int, int>); ++i)
+		{
+			int Result = findMSB_095(static_cast<unsigned int>(Data[i].Value));
+			Error += Data[i].Return == Result ? 0 : 1;
+		}
+
+		std::clock_t Timestamps4 = std::clock();
+
+#		if GLM_HAS_BITSCAN_WINDOWS
+			for(std::size_t k = 0; k < Count; ++k)
+			for(std::size_t i = 0; i < sizeof(Data) / sizeof(type<int, int>); ++i)
+			{
+				int Result = findMSB_intrinsic(Data[i].Value);
+				Error += Data[i].Return == Result ? 0 : 1;
+			}
+#		endif//GLM_HAS_BITSCAN_WINDOWS
+
+		std::clock_t Timestamps5 = std::clock();
+
+		for(std::size_t k = 0; k < Count; ++k)
+		for(std::size_t i = 0; i < sizeof(Data) / sizeof(type<int, int>); ++i)
+		{
+			int Result = findMSB_pop(static_cast<unsigned int>(Data[i].Value));
+			Error += Data[i].Return == Result ? 0 : 1;
+		}
+
+		std::clock_t Timestamps6 = std::clock();
+
+#		if GLM_ARCH & GLM_ARCH_AVX && GLM_COMPILER & GLM_COMPILER_VC
+			for(std::size_t k = 0; k < Count; ++k)
+			for(std::size_t i = 0; i < sizeof(Data) / sizeof(type<int, int>); ++i)
+			{
+				int Result = findMSB_avx(Data[i].Value);
+				Error += Data[i].Return == Result ? 0 : 1;
+			}
+
+			std::clock_t Timestamps7 = std::clock();
+#		endif
+
+		std::printf("glm::findMSB: %d clocks\n", static_cast<int>(Timestamps1 - Timestamps0));
+		std::printf("findMSB - nlz1: %d clocks\n", static_cast<int>(Timestamps2 - Timestamps1));
+		std::printf("findMSB - nlz2: %d clocks\n", static_cast<int>(Timestamps3 - Timestamps2));
+		std::printf("findMSB - 0.9.5: %d clocks\n", static_cast<int>(Timestamps4 - Timestamps3));
+
+#		if GLM_HAS_BITSCAN_WINDOWS
+			std::printf("findMSB - intrinsics: %d clocks\n", static_cast<int>(Timestamps5 - Timestamps4));
+#		endif//GLM_HAS_BITSCAN_WINDOWS
+		std::printf("findMSB - pop: %d clocks\n", static_cast<int>(Timestamps6 - Timestamps5));
+
+#		if GLM_ARCH & GLM_ARCH_AVX && GLM_COMPILER & GLM_COMPILER_VC
+			std::printf("findMSB - avx tzcnt: %d clocks\n", static_cast<int>(Timestamps7 - Timestamps6));
+#		endif//GLM_ARCH & GLM_ARCH_AVX && GLM_PLATFORM & GLM_PLATFORM_WINDOWS
+
+		return Error;
+	}
+
+	static int test_ivec4()
+	{
+		type<glm::ivec4, glm::ivec4> const Data[] =
+		{
+			{glm::ivec4(0x00000000), glm::ivec4(-1)},
+			{glm::ivec4(0x00000001), glm::ivec4( 0)},
+			{glm::ivec4(0x00000002), glm::ivec4( 1)},
+			{glm::ivec4(0x00000003), glm::ivec4( 1)},
+			{glm::ivec4(0x00000004), glm::ivec4( 2)},
+			{glm::ivec4(0x00000005), glm::ivec4( 2)},
+			{glm::ivec4(0x00000007), glm::ivec4( 2)},
+			{glm::ivec4(0x00000008), glm::ivec4( 3)},
+			{glm::ivec4(0x00000010), glm::ivec4( 4)},
+			{glm::ivec4(0x00000020), glm::ivec4( 5)},
+			{glm::ivec4(0x00000040), glm::ivec4( 6)},
+			{glm::ivec4(0x00000080), glm::ivec4( 7)},
+			{glm::ivec4(0x00000100), glm::ivec4( 8)},
+			{glm::ivec4(0x00000200), glm::ivec4( 9)},
+			{glm::ivec4(0x00000400), glm::ivec4(10)},
+			{glm::ivec4(0x00000800), glm::ivec4(11)},
+			{glm::ivec4(0x00001000), glm::ivec4(12)},
+			{glm::ivec4(0x00002000), glm::ivec4(13)},
+			{glm::ivec4(0x00004000), glm::ivec4(14)},
+			{glm::ivec4(0x00008000), glm::ivec4(15)},
+			{glm::ivec4(0x00010000), glm::ivec4(16)},
+			{glm::ivec4(0x00020000), glm::ivec4(17)},
+			{glm::ivec4(0x00040000), glm::ivec4(18)},
+			{glm::ivec4(0x00080000), glm::ivec4(19)},
+			{glm::ivec4(0x00100000), glm::ivec4(20)},
+			{glm::ivec4(0x00200000), glm::ivec4(21)},
+			{glm::ivec4(0x00400000), glm::ivec4(22)},
+			{glm::ivec4(0x00800000), glm::ivec4(23)},
+			{glm::ivec4(0x01000000), glm::ivec4(24)},
+			{glm::ivec4(0x02000000), glm::ivec4(25)},
+			{glm::ivec4(0x04000000), glm::ivec4(26)},
+			{glm::ivec4(0x08000000), glm::ivec4(27)},
+			{glm::ivec4(0x10000000), glm::ivec4(28)},
+			{glm::ivec4(0x20000000), glm::ivec4(29)},
+			{glm::ivec4(0x40000000), glm::ivec4(30)}
+		};
+
+		int Error(0);
+
+		for(std::size_t i = 0; i < sizeof(Data) / sizeof(type<glm::ivec4, glm::ivec4>); ++i)
+		{
+			glm::ivec4 Result0 = glm::findMSB(Data[i].Value);
+			Error += glm::all(glm::equal(Data[i].Return, Result0)) ? 0 : 1;
+		}
+
+		return Error;
+	}
+
+	static int test_int()
+	{
+		typedef type<glm::uint, int> entry;
+
+		entry const Data[] =
+		{
+			{0x00000000, -1},
+			{0x00000001,  0},
+			{0x00000002,  1},
+			{0x00000003,  1},
+			{0x00000004,  2},
+			{0x00000005,  2},
+			{0x00000007,  2},
+			{0x00000008,  3},
+			{0x00000010,  4},
+			{0x00000020,  5},
+			{0x00000040,  6},
+			{0x00000080,  7},
+			{0x00000100,  8},
+			{0x00000200,  9},
+			{0x00000400, 10},
+			{0x00000800, 11},
+			{0x00001000, 12},
+			{0x00002000, 13},
+			{0x00004000, 14},
+			{0x00008000, 15},
+			{0x00010000, 16},
+			{0x00020000, 17},
+			{0x00040000, 18},
+			{0x00080000, 19},
+			{0x00100000, 20},
+			{0x00200000, 21},
+			{0x00400000, 22},
+			{0x00800000, 23},
+			{0x01000000, 24},
+			{0x02000000, 25},
+			{0x04000000, 26},
+			{0x08000000, 27},
+			{0x10000000, 28},
+			{0x20000000, 29},
+			{0x40000000, 30}
+		};
+
+		int Error(0);
+
+		for(std::size_t i = 0; i < sizeof(Data) / sizeof(entry); ++i)
+		{
+			int Result0 = glm::findMSB(Data[i].Value);
+			Error += Data[i].Return == Result0 ? 0 : 1;
+		}
+
+		for(std::size_t i = 0; i < sizeof(Data) / sizeof(entry); ++i)
+		{
+			int Result0 = findMSB_nlz1(Data[i].Value);
+			Error += Data[i].Return == Result0 ? 0 : 1;
+		}
+/*
+		for(std::size_t i = 0; i < sizeof(Data) / sizeof(entry); ++i)
+		{
+			int Result0 = findMSB_nlz2(Data[i].Value);
+			Error += Data[i].Return == Result0 ? 0 : 1;
+		}
+*/
+		for(std::size_t i = 0; i < sizeof(Data) / sizeof(entry); ++i)
+		{
+			int Result0 = findMSB_095(Data[i].Value);
+			Error += Data[i].Return == Result0 ? 0 : 1;
+		}
+
+#		if GLM_HAS_BITSCAN_WINDOWS
+			for(std::size_t i = 0; i < sizeof(Data) / sizeof(entry); ++i)
+			{
+				int Result0 = findMSB_intrinsic(Data[i].Value);
+				Error += Data[i].Return == Result0 ? 0 : 1;
+			}
+#		endif//GLM_HAS_BITSCAN_WINDOWS
+
+		for(std::size_t i = 0; i < sizeof(Data) / sizeof(entry); ++i)
+		{
+			int Result0 = findMSB_pop(Data[i].Value);
+			Error += Data[i].Return == Result0 ? 0 : 1;
+		}
+
+		return Error;
+	}
+
+	static int test()
+	{
+		int Error(0);
+
+		Error += test_ivec4();
+		Error += test_int();
+
+		return Error;
+	}
+
+	static int perf(std::size_t Samples)
+	{
+		int Error(0);
+
+		Error += perf_int(Samples);
+
+		return Error;
+	}
+}//findMSB
+
+namespace findLSB
+{
+	template<typename genType, typename retType>
+	struct type
+	{
+		genType		Value;
+		retType		Return;
+	};
+
+	typedef type<int, int> entry;
+
+	entry const DataI32[] =
+	{
+		{0x00000001,  0},
+		{0x00000003,  0},
+		{0x00000002,  1},
+		// {0x80000000, 31}, // Clang generates an error with this
+		{0x00010000, 16},
+		{0x7FFF0000, 16},
+		{0x7F000000, 24},
+		{0x7F00FF00,  8},
+		{0x00000000, -1}
+	};
+
+#	if GLM_HAS_BITSCAN_WINDOWS
+		template<typename genIUType>
+		static int findLSB_intrinsic(genIUType Value)
+		{
+			GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'findLSB' only accept integer values");
+
+			if(Value == 0)
+				return -1;
+
+			unsigned long Result(0);
+			_BitScanForward(&Result, Value);
+			return int(Result);
+		}
+#	endif
+
+	template<typename genIUType>
+	static int findLSB_095(genIUType Value)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'findLSB' only accept integer values");
+		if(Value == 0)
+			return -1;
+
+		genIUType Bit;
+		for(Bit = genIUType(0); !(Value & (1 << Bit)); ++Bit){}
+		return Bit;
+	}
+
+	template<typename genIUType>
+	static int findLSB_ntz2(genIUType x)
+	{
+		if(x == 0)
+			return -1;
+
+		return glm::bitCount(~x & (x - static_cast<genIUType>(1)));
+	}
+
+	template<typename genIUType>
+	static int findLSB_branchfree(genIUType x)
+	{
+		bool IsNull(x == 0);
+		int const Keep(!IsNull);
+		int const Discard(IsNull);
+
+		return static_cast<int>(glm::bitCount(~x & (x - static_cast<genIUType>(1)))) * Keep + Discard * -1;
+	}
+
+	static int test_int()
+	{
+		int Error(0);
+
+		for(std::size_t i = 0; i < sizeof(DataI32) / sizeof(entry); ++i)
+		{
+			int Result = glm::findLSB(DataI32[i].Value);
+			Error += DataI32[i].Return == Result ? 0 : 1;
+		}
+
+		for(std::size_t i = 0; i < sizeof(DataI32) / sizeof(entry); ++i)
+		{
+			int Result = findLSB_095(DataI32[i].Value);
+			Error += DataI32[i].Return == Result ? 0 : 1;
+		}
+
+#		if GLM_HAS_BITSCAN_WINDOWS
+			for(std::size_t i = 0; i < sizeof(DataI32) / sizeof(entry); ++i)
+			{
+				int Result = findLSB_intrinsic(DataI32[i].Value);
+				Error += DataI32[i].Return == Result ? 0 : 1;
+			}
+#		endif
+
+		for(std::size_t i = 0; i < sizeof(DataI32) / sizeof(entry); ++i)
+		{
+			int Result = findLSB_ntz2(DataI32[i].Value);
+			Error += DataI32[i].Return == Result ? 0 : 1;
+		}
+
+		for(std::size_t i = 0; i < sizeof(DataI32) / sizeof(entry); ++i)
+		{
+			int Result = findLSB_branchfree(DataI32[i].Value);
+			Error += DataI32[i].Return == Result ? 0 : 1;
+		}
+
+		return Error;
+	}
+
+	static int test()
+	{
+		int Error(0);
+
+		Error += test_int();
+
+		return Error;
+	}
+
+	static int perf_int(std::size_t Count)
+	{
+		int Error(0);
+
+		std::clock_t Timestamps0 = std::clock();
+
+		for(std::size_t k = 0; k < Count; ++k)
+		for(std::size_t i = 0; i < sizeof(DataI32) / sizeof(entry); ++i)
+		{
+			int Result = glm::findLSB(DataI32[i].Value);
+			Error += DataI32[i].Return == Result ? 0 : 1;
+		}
+
+		std::clock_t Timestamps1 = std::clock();
+
+		for(std::size_t k = 0; k < Count; ++k)
+		for(std::size_t i = 0; i < sizeof(DataI32) / sizeof(entry); ++i)
+		{
+			int Result = findLSB_095(DataI32[i].Value);
+			Error += DataI32[i].Return == Result ? 0 : 1;
+		}
+
+		std::clock_t Timestamps2 = std::clock();
+
+#		if GLM_HAS_BITSCAN_WINDOWS
+			for(std::size_t k = 0; k < Count; ++k)
+			for(std::size_t i = 0; i < sizeof(DataI32) / sizeof(entry); ++i)
+			{
+				int Result = findLSB_intrinsic(DataI32[i].Value);
+				Error += DataI32[i].Return == Result ? 0 : 1;
+			}
+#		endif
+
+		std::clock_t Timestamps3 = std::clock();
+
+		for(std::size_t k = 0; k < Count; ++k)
+		for(std::size_t i = 0; i < sizeof(DataI32) / sizeof(entry); ++i)
+		{
+			int Result = findLSB_ntz2(DataI32[i].Value);
+			Error += DataI32[i].Return == Result ? 0 : 1;
+		}
+
+		std::clock_t Timestamps4 = std::clock();
+
+		for(std::size_t k = 0; k < Count; ++k)
+		for(std::size_t i = 0; i < sizeof(DataI32) / sizeof(entry); ++i)
+		{
+			int Result = findLSB_branchfree(DataI32[i].Value);
+			Error += DataI32[i].Return == Result ? 0 : 1;
+		}
+
+		std::clock_t Timestamps5 = std::clock();
+
+		std::printf("glm::findLSB: %d clocks\n", static_cast<int>(Timestamps1 - Timestamps0));
+		std::printf("findLSB - 0.9.5: %d clocks\n", static_cast<int>(Timestamps2 - Timestamps1));
+
+#		if GLM_HAS_BITSCAN_WINDOWS
+			std::printf("findLSB - intrinsics: %d clocks\n", static_cast<int>(Timestamps3 - Timestamps2));
+#		endif
+
+		std::printf("findLSB - ntz2: %d clocks\n", static_cast<int>(Timestamps4 - Timestamps3));
+		std::printf("findLSB - branchfree: %d clocks\n", static_cast<int>(Timestamps5 - Timestamps4));
+
+		return Error;
+	}
+
+	static int perf(std::size_t Samples)
+	{
+		int Error(0);
+
+		Error += perf_int(Samples);
+
+		return Error;
+	}
+}//findLSB
+
+namespace uaddCarry
+{
+	static int test()
+	{
+		int Error(0);
+		
+		{
+			glm::uint x = std::numeric_limits<glm::uint>::max();
+			glm::uint y = 0;
+			glm::uint Carry = 0;
+			glm::uint Result = glm::uaddCarry(x, y, Carry);
+
+			Error += Carry == 0 ? 0 : 1;
+			Error += Result == std::numeric_limits<glm::uint>::max() ? 0 : 1;
+		}
+
+		{
+			glm::uint x = std::numeric_limits<glm::uint>::max();
+			glm::uint y = 1;
+			glm::uint Carry = 0;
+			glm::uint Result = glm::uaddCarry(x, y, Carry);
+
+			Error += Carry == 1 ? 0 : 1;
+			Error += Result == 0 ? 0 : 1;
+		}
+
+		{
+			glm::uvec1 x(std::numeric_limits<glm::uint>::max());
+			glm::uvec1 y(0);
+			glm::uvec1 Carry(0);
+			glm::uvec1 Result(glm::uaddCarry(x, y, Carry));
+
+			Error += glm::all(glm::equal(Carry, glm::uvec1(0))) ? 0 : 1;
+			Error += glm::all(glm::equal(Result, glm::uvec1(std::numeric_limits<glm::uint>::max()))) ? 0 : 1;
+		}
+
+		{
+			glm::uvec1 x(std::numeric_limits<glm::uint>::max());
+			glm::uvec1 y(1);
+			glm::uvec1 Carry(0);
+			glm::uvec1 Result(glm::uaddCarry(x, y, Carry));
+
+			Error += glm::all(glm::equal(Carry, glm::uvec1(1))) ? 0 : 1;
+			Error += glm::all(glm::equal(Result, glm::uvec1(0))) ? 0 : 1;
+		}
+
+		return Error;
+	}
+}//namespace uaddCarry
+
+namespace usubBorrow
+{
+	static int test()
+	{
+		int Error(0);
+		
+		{
+			glm::uint x = 16;
+			glm::uint y = 17;
+			glm::uint Borrow = 0;
+			glm::uint Result = glm::usubBorrow(x, y, Borrow);
+
+			Error += Borrow == 1 ? 0 : 1;
+			Error += Result == 1 ? 0 : 1;
+		}
+
+		{
+			glm::uvec1 x(16);
+			glm::uvec1 y(17);
+			glm::uvec1 Borrow(0);
+			glm::uvec1 Result(glm::usubBorrow(x, y, Borrow));
+
+			Error += glm::all(glm::equal(Borrow, glm::uvec1(1))) ? 0 : 1;
+			Error += glm::all(glm::equal(Result, glm::uvec1(1))) ? 0 : 1;
+		}
+
+		{
+			glm::uvec2 x(16);
+			glm::uvec2 y(17);
+			glm::uvec2 Borrow(0);
+			glm::uvec2 Result(glm::usubBorrow(x, y, Borrow));
+
+			Error += glm::all(glm::equal(Borrow, glm::uvec2(1))) ? 0 : 1;
+			Error += glm::all(glm::equal(Result, glm::uvec2(1))) ? 0 : 1;
+		}
+
+		{
+			glm::uvec3 x(16);
+			glm::uvec3 y(17);
+			glm::uvec3 Borrow(0);
+			glm::uvec3 Result(glm::usubBorrow(x, y, Borrow));
+
+			Error += glm::all(glm::equal(Borrow, glm::uvec3(1))) ? 0 : 1;
+			Error += glm::all(glm::equal(Result, glm::uvec3(1))) ? 0 : 1;
+		}
+
+		{
+			glm::uvec4 x(16);
+			glm::uvec4 y(17);
+			glm::uvec4 Borrow(0);
+			glm::uvec4 Result(glm::usubBorrow(x, y, Borrow));
+
+			Error += glm::all(glm::equal(Borrow, glm::uvec4(1))) ? 0 : 1;
+			Error += glm::all(glm::equal(Result, glm::uvec4(1))) ? 0 : 1;
+		}
+
+		return Error;
+	}
+}//namespace usubBorrow
+
+namespace umulExtended
+{
+	static int test()
+	{
+		int Error(0);
+		
+		{
+			glm::uint x = 2;
+			glm::uint y = 3;
+			glm::uint msb = 0;
+			glm::uint lsb = 0;
+			glm::umulExtended(x, y, msb, lsb);
+
+			Error += msb == 0 ? 0 : 1;
+			Error += lsb == 6 ? 0 : 1;
+		}
+
+		{
+			glm::uvec1 x(2);
+			glm::uvec1 y(3);
+			glm::uvec1 msb(0);
+			glm::uvec1 lsb(0);
+			glm::umulExtended(x, y, msb, lsb);
+
+			Error += glm::all(glm::equal(msb, glm::uvec1(0))) ? 0 : 1;
+			Error += glm::all(glm::equal(lsb, glm::uvec1(6))) ? 0 : 1;
+		}
+
+		{
+			glm::uvec2 x(2);
+			glm::uvec2 y(3);
+			glm::uvec2 msb(0);
+			glm::uvec2 lsb(0);
+			glm::umulExtended(x, y, msb, lsb);
+
+			Error += glm::all(glm::equal(msb, glm::uvec2(0))) ? 0 : 1;
+			Error += glm::all(glm::equal(lsb, glm::uvec2(6))) ? 0 : 1;
+		}
+
+		{
+			glm::uvec3 x(2);
+			glm::uvec3 y(3);
+			glm::uvec3 msb(0);
+			glm::uvec3 lsb(0);
+			glm::umulExtended(x, y, msb, lsb);
+
+			Error += glm::all(glm::equal(msb, glm::uvec3(0))) ? 0 : 1;
+			Error += glm::all(glm::equal(lsb, glm::uvec3(6))) ? 0 : 1;
+		}
+
+		{
+			glm::uvec4 x(2);
+			glm::uvec4 y(3);
+			glm::uvec4 msb(0);
+			glm::uvec4 lsb(0);
+			glm::umulExtended(x, y, msb, lsb);
+
+			Error += glm::all(glm::equal(msb, glm::uvec4(0))) ? 0 : 1;
+			Error += glm::all(glm::equal(lsb, glm::uvec4(6))) ? 0 : 1;
+		}
+
+		return Error;
+	}
+}//namespace umulExtended
+
+namespace imulExtended
+{
+	static int test()
+	{
+		int Error(0);
+		
+		{
+			int x = 2;
+			int y = 3;
+			int msb = 0;
+			int lsb = 0;
+			glm::imulExtended(x, y, msb, lsb);
+
+			Error += msb == 0 ? 0 : 1;
+			Error += lsb == 6 ? 0 : 1;
+		}
+
+		{
+			glm::ivec1 x(2);
+			glm::ivec1 y(3);
+			glm::ivec1 msb(0);
+			glm::ivec1 lsb(0);
+			glm::imulExtended(x, y, msb, lsb);
+
+			Error += glm::all(glm::equal(msb, glm::ivec1(0))) ? 0 : 1;
+			Error += glm::all(glm::equal(lsb, glm::ivec1(6))) ? 0 : 1;
+		}
+
+		{
+			glm::ivec2 x(2);
+			glm::ivec2 y(3);
+			glm::ivec2 msb(0);
+			glm::ivec2 lsb(0);
+			glm::imulExtended(x, y, msb, lsb);
+
+			Error += glm::all(glm::equal(msb, glm::ivec2(0))) ? 0 : 1;
+			Error += glm::all(glm::equal(lsb, glm::ivec2(6))) ? 0 : 1;
+		}
+
+		{
+			glm::ivec3 x(2);
+			glm::ivec3 y(3);
+			glm::ivec3 msb(0);
+			glm::ivec3 lsb(0);
+			glm::imulExtended(x, y, msb, lsb);
+
+			Error += glm::all(glm::equal(msb, glm::ivec3(0))) ? 0 : 1;
+			Error += glm::all(glm::equal(lsb, glm::ivec3(6))) ? 0 : 1;
+		}
+
+		{
+			glm::ivec4 x(2);
+			glm::ivec4 y(3);
+			glm::ivec4 msb(0);
+			glm::ivec4 lsb(0);
+			glm::imulExtended(x, y, msb, lsb);
+
+			Error += glm::all(glm::equal(msb, glm::ivec4(0))) ? 0 : 1;
+			Error += glm::all(glm::equal(lsb, glm::ivec4(6))) ? 0 : 1;
+		}
+
+		return Error;
+	}
+}//namespace imulExtended
+
+namespace bitCount
+{
+	template<typename genType>
+	struct type
+	{
+		genType		Value;
+		genType		Return;
+	};
+
+	type<int> const DataI32[] =
+	{
+		{0x00000001,  1},
+		{0x00000003,  2},
+		{0x00000002,  1},
+		{0x7fffffff, 31},
+		{0x00000000,  0}
+	};
+
+	template<typename T>
+	inline int bitCount_if(T v)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_integer, "'bitCount' only accept integer values");
+
+		int Count(0);
+		for(T i = 0, n = static_cast<T>(sizeof(T) * 8); i < n; ++i)
+		{
+			if(v & static_cast<T>(1 << i))
+				++Count;
+		}
+		return Count;
+	}
+
+	template<typename T>
+	inline int bitCount_vec(T v)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_integer, "'bitCount' only accept integer values");
+
+		int Count(0);
+		for(T i = 0, n = static_cast<T>(sizeof(T) * 8); i < n; ++i)
+		{
+			Count += static_cast<int>((v >> i) & static_cast<T>(1));
+		}
+		return Count;
+	}
+
+	template<bool EXEC = false>
+	struct compute_bitfieldBitCountStep
+	{
+		template<glm::length_t L, typename T, glm::qualifier Q>
+		GLM_FUNC_QUALIFIER static glm::vec<L, T, Q> call(glm::vec<L, T, Q> const& v, T, T)
+		{
+			return v;
+		}
+	};
+
+	template<>
+	struct compute_bitfieldBitCountStep<true>
+	{
+		template<glm::length_t L, typename T, glm::qualifier Q>
+		GLM_FUNC_QUALIFIER static glm::vec<L, T, Q> call(glm::vec<L, T, Q> const& v, T Mask, T Shift)
+		{
+			return (v & Mask) + ((v >> Shift) & Mask);
+		}
+	};
+
+	template<glm::length_t L, typename T, glm::qualifier Q>
+	static glm::vec<L, int, Q> bitCount_bitfield(glm::vec<L, T, Q> const& v)
+	{
+		glm::vec<L, typename glm::detail::make_unsigned<T>::type, Q> x(*reinterpret_cast<glm::vec<L, typename glm::detail::make_unsigned<T>::type, Q> const *>(&v));
+		x = compute_bitfieldBitCountStep<sizeof(T) * 8 >=  2>::call(x, static_cast<typename glm::detail::make_unsigned<T>::type>(0x5555555555555555ull), static_cast<typename glm::detail::make_unsigned<T>::type>( 1));
+		x = compute_bitfieldBitCountStep<sizeof(T) * 8 >=  4>::call(x, static_cast<typename glm::detail::make_unsigned<T>::type>(0x3333333333333333ull), static_cast<typename glm::detail::make_unsigned<T>::type>( 2));
+		x = compute_bitfieldBitCountStep<sizeof(T) * 8 >=  8>::call(x, static_cast<typename glm::detail::make_unsigned<T>::type>(0x0F0F0F0F0F0F0F0Full), static_cast<typename glm::detail::make_unsigned<T>::type>( 4));
+		x = compute_bitfieldBitCountStep<sizeof(T) * 8 >= 16>::call(x, static_cast<typename glm::detail::make_unsigned<T>::type>(0x00FF00FF00FF00FFull), static_cast<typename glm::detail::make_unsigned<T>::type>( 8));
+		x = compute_bitfieldBitCountStep<sizeof(T) * 8 >= 32>::call(x, static_cast<typename glm::detail::make_unsigned<T>::type>(0x0000FFFF0000FFFFull), static_cast<typename glm::detail::make_unsigned<T>::type>(16));
+		x = compute_bitfieldBitCountStep<sizeof(T) * 8 >= 64>::call(x, static_cast<typename glm::detail::make_unsigned<T>::type>(0x00000000FFFFFFFFull), static_cast<typename glm::detail::make_unsigned<T>::type>(32));
+		return glm::vec<L, int, Q>(x);
+	}
+
+	template<typename genType>
+	static int bitCount_bitfield(genType x)
+	{
+		return bitCount_bitfield(glm::vec<1, genType, glm::defaultp>(x)).x;
+	}
+
+	static int perf(std::size_t Size)
+	{
+		int Error(0);
+
+		std::vector<int> v;
+		v.resize(Size);
+
+		std::vector<glm::ivec4> w;
+		w.resize(Size);
+
+
+		std::clock_t TimestampsA = std::clock();
+
+		// bitCount - TimeIf
+		{
+			for(std::size_t i = 0, n = v.size(); i < n; ++i)
+				v[i] = bitCount_if(static_cast<int>(i));
+		}
+
+		std::clock_t TimestampsB = std::clock();
+
+		// bitCount - TimeVec
+		{
+			for(std::size_t i = 0, n = v.size(); i < n; ++i)
+				v[i] = bitCount_vec(i);
+		}
+
+		std::clock_t TimestampsC = std::clock();
+
+		// bitCount - TimeDefault
+		{
+			for(std::size_t i = 0, n = v.size(); i < n; ++i)
+				v[i] = glm::bitCount(i);
+		}
+
+		std::clock_t TimestampsD = std::clock();
+
+		// bitCount - TimeVec4
+		{
+			for(std::size_t i = 0, n = v.size(); i < n; ++i)
+				w[i] = glm::bitCount(glm::ivec4(static_cast<int>(i)));
+		}
+
+		std::clock_t TimestampsE = std::clock();
+
+		{
+			for(std::size_t i = 0, n = v.size(); i < n; ++i)
+				v[i] = bitCount_bitfield(static_cast<int>(i));
+		}
+
+		std::clock_t TimestampsF = std::clock();
+
+		std::printf("bitCount - TimeIf %d\n", static_cast<int>(TimestampsB - TimestampsA));
+		std::printf("bitCount - TimeVec %d\n", static_cast<int>(TimestampsC - TimestampsB));
+		std::printf("bitCount - TimeDefault %d\n", static_cast<int>(TimestampsD - TimestampsC));
+		std::printf("bitCount - TimeVec4 %d\n", static_cast<int>(TimestampsE - TimestampsD));
+		std::printf("bitCount - bitfield %d\n", static_cast<int>(TimestampsF - TimestampsE));
+
+		return Error;
+	}
+
+	static int test()
+	{
+		int Error(0);
+
+		for(std::size_t i = 0, n = sizeof(DataI32) / sizeof(type<int>); i < n; ++i)
+		{
+			int ResultA = glm::bitCount(DataI32[i].Value);
+			int ResultB = bitCount_if(DataI32[i].Value);
+			int ResultC = bitCount_vec(DataI32[i].Value);
+			int ResultE = bitCount_bitfield(DataI32[i].Value);
+
+			Error += DataI32[i].Return == ResultA ? 0 : 1;
+			Error += DataI32[i].Return == ResultB ? 0 : 1;
+			Error += DataI32[i].Return == ResultC ? 0 : 1;
+			Error += DataI32[i].Return == ResultE ? 0 : 1;
+
+			assert(!Error);
+		}
+
+		return Error;
+	}
+}//bitCount
+
+int main()
+{
+	int Error = 0;
+
+	Error += ::bitCount::test();
+	Error += ::bitfieldReverse::test();
+	Error += ::findMSB::test();
+	Error += ::findLSB::test();
+	Error += ::umulExtended::test();
+	Error += ::imulExtended::test();
+	Error += ::uaddCarry::test();
+	Error += ::usubBorrow::test();
+	Error += ::bitfieldInsert::test();
+	Error += ::bitfieldExtract::test();
+
+#	ifdef NDEBUG
+		std::size_t const Samples = 1000;
+#	else
+		std::size_t const Samples = 1;
+#	endif
+
+	::bitCount::perf(Samples);
+	::bitfieldReverse::perf(Samples);
+	::findMSB::perf(Samples);
+	::findLSB::perf(Samples);
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/core/core_func_integer_bit_count.cpp b/3rdparty/glm/source/test/core/core_func_integer_bit_count.cpp
new file mode 100644
index 0000000..0fa11fb
--- /dev/null
+++ b/3rdparty/glm/source/test/core/core_func_integer_bit_count.cpp
@@ -0,0 +1,291 @@
+// This has the programs for computing the number of 1-bits
+// in a word, or byte, etc.
+// Max line length is 57, to fit in hacker.book.
+#include <cstdio>
+#include <cstdlib>     //To define "exit", req'd by XLC.
+#include <ctime>
+
+unsigned rotatel(unsigned x, int n)
+{
+	if (static_cast<unsigned>(n) > 63) { std::printf("rotatel, n out of range.\n"); std::exit(1);}
+	return (x << n) | (x >> (32 - n));
+}
+
+int pop0(unsigned x)
+{
+	x = (x & 0x55555555) + ((x >> 1) & 0x55555555);
+	x = (x & 0x33333333) + ((x >> 2) & 0x33333333);
+	x = (x & 0x0F0F0F0F) + ((x >> 4) & 0x0F0F0F0F);
+	x = (x & 0x00FF00FF) + ((x >> 8) & 0x00FF00FF);
+	x = (x & 0x0000FFFF) + ((x >>16) & 0x0000FFFF);
+	return x;
+}
+
+int pop1(unsigned x)
+{
+	x = x - ((x >> 1) & 0x55555555);
+	x = (x & 0x33333333) + ((x >> 2) & 0x33333333);
+	x = (x + (x >> 4)) & 0x0F0F0F0F;
+	x = x + (x >> 8);
+	x = x + (x >> 16);
+	return x & 0x0000003F;
+}
+/* Note: an alternative to the last three executable lines above is:
+   return x*0x01010101 >> 24;
+if your machine has a fast multiplier (suggested by Jari Kirma). */
+
+int pop2(unsigned x)
+{
+	unsigned n;
+
+	n = (x >> 1) & 033333333333;       // Count bits in
+	x = x - n;                         // each 3-bit
+	n = (n >> 1) & 033333333333;       // field.
+	x = x - n;
+	x = (x + (x >> 3)) & 030707070707; // 6-bit sums.
+	return x%63;                       // Add 6-bit sums.
+}
+
+/* An alternative to the "return" statement above is:
+   return ((x * 0404040404) >> 26) +  // Add 6-bit sums.
+           (x >> 30);
+which runs faster on most machines (suggested by Norbert Juffa). */
+
+int pop3(unsigned x)
+{
+	unsigned n;
+
+	n = (x >> 1) & 0x77777777;        // Count bits in
+	x = x - n;                        // each 4-bit
+	n = (n >> 1) & 0x77777777;        // field.
+	x = x - n;
+	n = (n >> 1) & 0x77777777;
+	x = x - n;
+	x = (x + (x >> 4)) & 0x0F0F0F0F;  // Get byte sums.
+	x = x*0x01010101;                 // Add the bytes.
+	return x >> 24;
+}
+
+int pop4(unsigned x)
+{
+	int n;
+
+	n = 0;
+	while (x != 0) {
+		n = n + 1;
+		x = x & (x - 1);
+	}
+	return n;
+}
+
+int pop5(unsigned x)
+{
+	int i, sum;
+
+	// Rotate and sum method        // Shift right & subtract
+
+	sum = x;                     // sum = x;
+	for (i = 1; i <= 31; i++) {  // while (x != 0) {
+		x = rotatel(x, 1);        //    x = x >> 1;
+		sum = sum + x;            //    sum = sum - x;
+	}                            // }
+	return -sum;                 // return sum;
+}
+
+int pop5a(unsigned x)
+{
+	int sum;
+
+	// Shift right & subtract
+
+	sum = x;
+	while (x != 0) {
+		x = x >> 1;
+		sum = sum - x;
+	}
+	return sum;
+}
+
+int pop6(unsigned x)
+{ // Table lookup.
+	static char table[256] = {
+		0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4,
+		1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
+		1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
+		2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+
+		1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
+		2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+		2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+		3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
+
+		1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
+		2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+		2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+		3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
+
+		2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+		3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
+		3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
+		4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8};
+
+	return table[x         & 0xFF] +
+			table[(x >>  8) & 0xFF] +
+			table[(x >> 16) & 0xFF] +
+			table[(x >> 24)];
+}
+
+// The following works only for 8-bit quantities.
+int pop7(unsigned x)
+{
+	x = x*0x08040201;    // Make 4 copies.
+	x = x >> 3;          // So next step hits proper bits.
+	x = x & 0x11111111;  // Every 4th bit.
+	x = x*0x11111111;    // Sum the digits (each 0 or 1).
+	x = x >> 28;         // Position the result.
+	return x;
+}
+
+// The following works only for 7-bit quantities.
+int pop8(unsigned x)
+{
+	x = x*0x02040810;    // Make 4 copies, left-adjusted.
+	x = x & 0x11111111;  // Every 4th bit.
+	x = x*0x11111111;    // Sum the digits (each 0 or 1).
+	x = x >> 28;         // Position the result.
+	return x;
+}
+
+// The following works only for 15-bit quantities.
+int pop9(unsigned x)
+{
+	unsigned long long y;
+	y = x * 0x0002000400080010ULL;
+	y = y & 0x1111111111111111ULL;
+	y = y * 0x1111111111111111ULL;
+	y = y >> 60;
+	return static_cast<int>(y);
+}
+
+int errors;
+void error(int x, int y)
+{
+	errors = errors + 1;
+	std::printf("Error for x = %08x, got %08x\n", x, y);
+}
+
+int main()
+{
+#	ifdef NDEBUG
+
+	int i, n;
+	static unsigned test[] = {0,0, 1,1, 2,1, 3,2, 4,1, 5,2, 6,2, 7,3,
+		8,1, 9,2, 10,2, 11,3, 12,2, 13,3, 14,3, 15,4, 16,1, 17,2,
+		0x3F,6, 0x40,1, 0x41,2, 0x7f,7, 0x80,1, 0x81,2, 0xfe,7, 0xff,8,
+		0x4000,1, 0x4001,2, 0x7000,3, 0x7fff,15,
+		0x55555555,16, 0xAAAAAAAA, 16, 0xFF000000,8, 0xC0C0C0C0,8,
+		0x0FFFFFF0,24, 0x80000000,1, 0xFFFFFFFF,32};
+
+	std::size_t const Count = 1000000;
+
+	n = sizeof(test)/4;
+
+	std::clock_t TimestampBeg = 0;
+	std::clock_t TimestampEnd = 0;
+
+	TimestampBeg = std::clock();
+	for (std::size_t k = 0; k < Count; ++k)
+	for (i = 0; i < n; i += 2) {
+		if (pop0(test[i]) != test[i+1]) error(test[i], pop0(test[i]));}
+	TimestampEnd = std::clock();
+
+	std::printf("pop0: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
+
+	TimestampBeg = std::clock();
+	for (std::size_t k = 0; k < Count; ++k)
+	for (i = 0; i < n; i += 2) {
+		if (pop1(test[i]) != test[i+1]) error(test[i], pop1(test[i]));}
+	TimestampEnd = std::clock();
+
+	std::printf("pop1: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
+
+	TimestampBeg = std::clock();
+	for (std::size_t k = 0; k < Count; ++k)
+	for (i = 0; i < n; i += 2) {
+		if (pop2(test[i]) != test[i+1]) error(test[i], pop2(test[i]));}
+	TimestampEnd = std::clock();
+
+	std::printf("pop2: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
+
+	TimestampBeg = std::clock();
+	for (std::size_t k = 0; k < Count; ++k)
+	for (i = 0; i < n; i += 2) {
+		if (pop3(test[i]) != test[i+1]) error(test[i], pop3(test[i]));}
+	TimestampEnd = std::clock();
+
+	std::printf("pop3: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
+
+	TimestampBeg = std::clock();
+	for (std::size_t k = 0; k < Count; ++k)
+	for (i = 0; i < n; i += 2) {
+		if (pop4(test[i]) != test[i+1]) error(test[i], pop4(test[i]));}
+	TimestampEnd = std::clock();
+
+	std::printf("pop4: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
+
+	TimestampBeg = std::clock();
+	for (std::size_t k = 0; k < Count; ++k)
+	for (i = 0; i < n; i += 2) {
+		if (pop5(test[i]) != test[i+1]) error(test[i], pop5(test[i]));}
+	TimestampEnd = std::clock();
+
+	std::printf("pop5: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
+
+	TimestampBeg = std::clock();
+	for (std::size_t k = 0; k < Count; ++k)
+	for (i = 0; i < n; i += 2) {
+		if (pop5a(test[i]) != test[i+1]) error(test[i], pop5a(test[i]));}
+	TimestampEnd = std::clock();
+
+	std::printf("pop5a: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
+
+	TimestampBeg = std::clock();
+	for (std::size_t k = 0; k < Count; ++k)
+	for (i = 0; i < n; i += 2) {
+		if (pop6(test[i]) != test[i+1]) error(test[i], pop6(test[i]));}
+	TimestampEnd = std::clock();
+
+	std::printf("pop6: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
+
+	TimestampBeg = std::clock();
+	for (std::size_t k = 0; k < Count; ++k)
+	for (i = 0; i < n; i += 2) {
+		if ((test[i] & 0xffffff00) == 0)
+		if (pop7(test[i]) != test[i+1]) error(test[i], pop7(test[i]));}
+	TimestampEnd = std::clock();
+
+	std::printf("pop7: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
+
+	TimestampBeg = std::clock();
+	for (std::size_t k = 0; k < Count; ++k)
+	for (i = 0; i < n; i += 2) {
+		if ((test[i] & 0xffffff80) == 0)
+		if (pop8(test[i]) != test[i+1]) error(test[i], pop8(test[i]));}
+	TimestampEnd = std::clock();
+
+	std::printf("pop8: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
+
+	TimestampBeg = std::clock();
+	for (std::size_t k = 0; k < Count; ++k)
+	for (i = 0; i < n; i += 2) {
+		if ((test[i] & 0xffff8000) == 0)
+		if (pop9(test[i]) != test[i+1]) error(test[i], pop9(test[i]));}
+	TimestampEnd = std::clock();
+
+	std::printf("pop9: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
+
+	if (errors == 0)
+		std::printf("Passed all %d cases.\n", static_cast<int>(sizeof(test)/8));
+
+#	endif//NDEBUG
+}
diff --git a/3rdparty/glm/source/test/core/core_func_integer_find_lsb.cpp b/3rdparty/glm/source/test/core/core_func_integer_find_lsb.cpp
new file mode 100644
index 0000000..7b42d33
--- /dev/null
+++ b/3rdparty/glm/source/test/core/core_func_integer_find_lsb.cpp
@@ -0,0 +1,416 @@
+#include <glm/glm.hpp>
+#include <cstdio>
+#include <cstdlib>     //To define "exit", req'd by XLC.
+#include <ctime>
+
+int nlz(unsigned x)
+{
+	int pop(unsigned x);
+
+	x = x | (x >> 1);
+	x = x | (x >> 2);
+	x = x | (x >> 4);
+	x = x | (x >> 8);
+	x = x | (x >>16);
+	return pop(~x);
+}
+
+int pop(unsigned x)
+{
+	x = x - ((x >> 1) & 0x55555555);
+	x = (x & 0x33333333) + ((x >> 2) & 0x33333333);
+	x = (x + (x >> 4)) & 0x0F0F0F0F;
+	x = x + (x << 8);
+	x = x + (x << 16);
+	return x >> 24;
+}
+
+int ntz1(unsigned x)
+{
+	return 32 - nlz(~x & (x-1));
+}
+
+int ntz2(unsigned x)
+{
+	return pop(~x & (x - 1));
+}
+
+int ntz3(unsigned x)
+{
+	int n;
+
+	if (x == 0) return(32);
+	n = 1;
+	if ((x & 0x0000FFFF) == 0) {n = n +16; x = x >>16;}
+	if ((x & 0x000000FF) == 0) {n = n + 8; x = x >> 8;}
+	if ((x & 0x0000000F) == 0) {n = n + 4; x = x >> 4;}
+	if ((x & 0x00000003) == 0) {n = n + 2; x = x >> 2;}
+	return n - (x & 1);
+}
+
+int ntz4(unsigned x)
+{
+	unsigned y;
+	int n;
+
+	if (x == 0) return 32;
+	n = 31;
+	y = x <<16;  if (y != 0) {n = n -16;  x = y;}
+	y = x << 8;  if (y != 0) {n = n - 8;  x = y;}
+	y = x << 4;  if (y != 0) {n = n - 4;  x = y;}
+	y = x << 2;  if (y != 0) {n = n - 2;  x = y;}
+	y = x << 1;  if (y != 0) {n = n - 1;}
+	return n;
+}
+
+int ntz4a(unsigned x)
+{
+	unsigned y;
+	int n;
+
+	if (x == 0) return 32;
+	n = 31;
+	y = x <<16;  if (y != 0) {n = n -16;  x = y;}
+	y = x << 8;  if (y != 0) {n = n - 8;  x = y;}
+	y = x << 4;  if (y != 0) {n = n - 4;  x = y;}
+	y = x << 2;  if (y != 0) {n = n - 2;  x = y;}
+	n = n - ((x << 1) >> 31);
+	return n;
+}
+
+int ntz5(char x)
+{
+	if (x & 15) {
+		if (x & 3) {
+			if (x & 1) return 0;
+			else return 1;
+		}
+		else if (x & 4) return 2;
+		else return 3;
+	}
+	else if (x & 0x30) {
+		if (x & 0x10) return 4;
+		else return 5;
+	}
+	else if (x & 0x40) return 6;
+	else if (x) return 7;
+	else return 8;
+}
+
+int ntz6(unsigned x)
+{
+	int n;
+
+	x = ~x & (x - 1);
+	n = 0;				// n = 32;
+	while(x != 0)
+	{					// while (x != 0) {
+		n = n + 1;		//    n = n - 1;
+		x = x >> 1;		//    x = x + x;
+	}					// }
+	return n;			// return n;
+}
+
+int ntz6a(unsigned x)
+{
+	int n = 32;
+
+	while (x != 0) {
+		n = n - 1;
+		x = x + x;
+	}
+	return n;
+}
+
+/* Dean Gaudet's algorithm. To be most useful there must be a good way
+to evaluate the C "conditional expression" (a?b:c construction) without
+branching. The result of a?b:c is b if a is true (nonzero), and c if a
+is false (0).
+   For example, a compare to zero op that sets a target GPR to 1 if the
+operand is 0, and to 0 if the operand is nonzero, will do it. With this
+instruction, the algorithm is entirely branch-free. But the most
+interesting thing about it is the high degree of parallelism. All six
+lines with conditional expressions can be executed in parallel (on a
+machine with sufficient computational units).
+   Although the instruction count is 30 measured statically, it could
+execute in only 10 cycles on a machine with sufficient parallelism.
+   The first two uses of y can instead be x, which would increase the
+useful parallelism on most machines (the assignments to y, bz, and b4
+could then all run in parallel). */
+
+int ntz7(unsigned x)
+{
+	unsigned y, bz, b4, b3, b2, b1, b0;
+
+	y = x & -x;               // Isolate rightmost 1-bit.
+	bz = y ? 0 : 1;           // 1 if y = 0.
+	b4 = (y & 0x0000FFFF) ? 0 : 16;
+	b3 = (y & 0x00FF00FF) ? 0 : 8;
+	b2 = (y & 0x0F0F0F0F) ? 0 : 4;
+	b1 = (y & 0x33333333) ? 0 : 2;
+	b0 = (y & 0x55555555) ? 0 : 1;
+	return bz + b4 + b3 + b2 + b1 + b0;
+}
+
+// This file has divisions by zero to test isnan
+#if GLM_COMPILER & GLM_COMPILER_VC
+#	pragma warning(disable : 4800)
+#endif
+
+int ntz7_christophe(unsigned x)
+{
+	unsigned y, bz, b4, b3, b2, b1, b0;
+
+	y = x & -x;               // Isolate rightmost 1-bit.
+	bz = unsigned(!bool(y));           // 1 if y = 0.
+	b4 = unsigned(!bool(y & 0x0000FFFF)) * 16;
+	b3 = unsigned(!bool(y & 0x00FF00FF)) * 8;
+	b2 = unsigned(!bool(y & 0x0F0F0F0F)) * 4;
+	b1 = unsigned(!bool(y & 0x33333333)) * 2;
+	b0 = unsigned(!bool(y & 0x55555555)) * 1;
+	return bz + b4 + b3 + b2 + b1 + b0;
+}
+
+/* Below is David Seal's algorithm, found at
+http://www.ciphersbyritter.com/NEWS4/BITCT.HTM Table
+entries marked "u" are unused. 6 ops including a
+multiply, plus an indexed load. */
+
+#define u 99
+int ntz8(unsigned x)
+{
+	static char table[64] =
+		{32, 0, 1,12, 2, 6, u,13,   3, u, 7, u, u, u, u,14,
+		10, 4, u, u, 8, u, u,25,   u, u, u, u, u,21,27,15,
+		31,11, 5, u, u, u, u, u,   9, u, u,24, u, u,20,26,
+		30, u, u, u, u,23, u,19,  29, u,22,18,28,17,16, u};
+
+	x = (x & -x)*0x0450FBAF;
+	return table[x >> 26];
+}
+
+/* Seal's algorithm with multiply expanded.
+9 elementary ops plus an indexed load. */
+
+int ntz8a(unsigned x)
+{
+	static char table[64] =
+		{32, 0, 1,12, 2, 6, u,13,   3, u, 7, u, u, u, u,14,
+		10, 4, u, u, 8, u, u,25,   u, u, u, u, u,21,27,15,
+		31,11, 5, u, u, u, u, u,   9, u, u,24, u, u,20,26,
+		30, u, u, u, u,23, u,19,  29, u,22,18,28,17,16, u};
+
+	x = (x & -x);
+	x = (x << 4) + x;    // x = x*17.
+	x = (x << 6) + x;    // x = x*65.
+	x = (x << 16) - x;   // x = x*65535.
+	return table[x >> 26];
+}
+
+/* Reiser's algorithm. Three ops including a "remainder,"
+plus an indexed load. */
+
+int ntz9(unsigned x)
+{
+	static char table[37] = {
+		32,  0,  1, 26,  2, 23, 27,
+		u,  3, 16, 24, 30, 28, 11,  u, 13,  4,
+		7, 17,  u, 25, 22, 31, 15, 29, 10, 12,
+		6,  u, 21, 14,  9,  5, 20,  8, 19, 18};
+
+	x = (x & -x)%37;
+	return table[x];
+}
+
+/* Using a de Bruijn sequence. This is a table lookup with a 32-entry
+table. The de Bruijn sequence used here is
+                0000 0100 1101 0111 0110 0101 0001 1111,
+obtained from Danny Dube's October 3, 1997, posting in
+comp.compression.research. Thanks to Norbert Juffa for this reference. */
+
+int ntz10(unsigned x) {
+
+   static char table[32] =
+     { 0, 1, 2,24, 3,19, 6,25,  22, 4,20,10,16, 7,12,26,
+      31,23,18, 5,21, 9,15,11,  30,17, 8,14,29,13,28,27};
+
+   if (x == 0) return 32;
+   x = (x & -x)*0x04D7651F;
+   return table[x >> 27];
+}
+
+/* Norbert Juffa's code, answer to exercise 1 of Chapter 5 (2nd ed). */
+
+#define SLOW_MUL
+int ntz11 (unsigned int n) {
+
+   static unsigned char tab[32] =
+   {   0,  1,  2, 24,  3, 19, 6,  25,
+      22,  4, 20, 10, 16,  7, 12, 26,
+      31, 23, 18,  5, 21,  9, 15, 11,
+      30, 17,  8, 14, 29, 13, 28, 27
+   };
+   unsigned int k;
+   n = n & (-n);        /* isolate lsb */
+   printf("n = %d\n", n);
+#if defined(SLOW_MUL)
+   k = (n << 11) - n;
+   k = (k <<  2) + k;
+   k = (k <<  8) + n;
+   k = (k <<  5) - k;
+#else
+   k = n * 0x4d7651f;
+#endif
+   return n ? tab[k>>27] : 32;
+}
+
+int errors;
+void error(int x, int y) {
+   errors = errors + 1;
+   std::printf("Error for x = %08x, got %d\n", x, y);
+}
+
+int main()
+{
+#	ifdef NDEBUG
+
+	int i, m, n;
+	static unsigned test[] = {0,32, 1,0, 2,1, 3,0, 4,2, 5,0, 6,1,  7,0,
+		8,3, 9,0, 16,4, 32,5, 64,6, 128,7, 255,0, 256,8, 512,9, 1024,10,
+		2048,11, 4096,12, 8192,13, 16384,14, 32768,15, 65536,16,
+		0x20000,17, 0x40000,18, 0x80000,19, 0x100000,20, 0x200000,21,
+		0x400000,22, 0x800000,23, 0x1000000,24, 0x2000000,25,
+		0x4000000,26, 0x8000000,27, 0x10000000,28, 0x20000000,29,
+		0x40000000,30, 0x80000000,31, 0xFFFFFFF0,4, 0x3000FF00,8,
+		0xC0000000,30, 0x60000000,29, 0x00011000, 12};
+
+	std::size_t const Count = 1000;
+
+	n = sizeof(test)/4;
+
+	std::clock_t TimestampBeg = 0;
+	std::clock_t TimestampEnd = 0;
+
+	TimestampBeg = std::clock();
+	for (std::size_t k = 0; k < Count; ++k)
+	for (i = 0; i < n; i += 2) {
+		if (ntz1(test[i]) != test[i+1]) error(test[i], ntz1(test[i]));}
+	TimestampEnd = std::clock();
+
+	std::printf("ntz1: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
+
+	TimestampBeg = std::clock();
+	for (std::size_t k = 0; k < Count; ++k)
+	for (i = 0; i < n; i += 2) {
+		if (ntz2(test[i]) != test[i+1]) error(test[i], ntz2(test[i]));}
+	TimestampEnd = std::clock();
+
+	std::printf("ntz2: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
+
+	TimestampBeg = std::clock();
+	for (std::size_t k = 0; k < Count; ++k)
+	for (i = 0; i < n; i += 2) {
+		if (ntz3(test[i]) != test[i+1]) error(test[i], ntz3(test[i]));}
+	TimestampEnd = std::clock();
+
+	std::printf("ntz3: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
+
+	TimestampBeg = std::clock();
+	for (std::size_t k = 0; k < Count; ++k)
+	for (i = 0; i < n; i += 2) {
+		if (ntz4(test[i]) != test[i+1]) error(test[i], ntz4(test[i]));}
+	TimestampEnd = std::clock();
+
+	std::printf("ntz4: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
+
+	TimestampBeg = std::clock();
+	for (std::size_t k = 0; k < Count; ++k)
+	for (i = 0; i < n; i += 2) {
+		if (ntz4a(test[i]) != test[i+1]) error(test[i], ntz4a(test[i]));}
+	TimestampEnd = std::clock();
+
+	std::printf("ntz4a: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
+
+	TimestampBeg = std::clock();
+	for(std::size_t k = 0; k < Count; ++k)
+	for(i = 0; i < n; i += 2)
+	{
+		m = test[i+1];
+		if(m > 8)
+			m = 8;
+		if(ntz5(static_cast<char>(test[i])) != m)
+			error(test[i], ntz5(static_cast<char>(test[i])));
+	}
+	TimestampEnd = std::clock();
+
+	std::printf("ntz5: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
+
+	TimestampBeg = std::clock();
+	for (std::size_t k = 0; k < Count; ++k)
+	for (i = 0; i < n; i += 2) {
+		if (ntz6(test[i]) != test[i+1]) error(test[i], ntz6(test[i]));}
+	TimestampEnd = std::clock();
+
+	std::printf("ntz6: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
+
+	TimestampBeg = std::clock();
+	for (std::size_t k = 0; k < Count; ++k)
+	for (i = 0; i < n; i += 2) {
+		if (ntz6a(test[i]) != test[i+1]) error(test[i], ntz6a(test[i]));}
+	TimestampEnd = std::clock();
+
+	std::printf("ntz6a: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
+
+	TimestampBeg = std::clock();
+	for (std::size_t k = 0; k < Count; ++k)
+	for (i = 0; i < n; i += 2) {
+		if (ntz7(test[i]) != test[i+1]) error(test[i], ntz7(test[i]));}
+	TimestampEnd = std::clock();
+
+	std::printf("ntz7: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
+
+	TimestampBeg = std::clock();
+	for (std::size_t k = 0; k < Count; ++k)
+	for (i = 0; i < n; i += 2) {
+		if (ntz7_christophe(test[i]) != test[i+1]) error(test[i], ntz7(test[i]));}
+	TimestampEnd = std::clock();
+
+	std::printf("ntz7_christophe: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
+
+	TimestampBeg = std::clock();
+	for (std::size_t k = 0; k < Count; ++k)
+	for (i = 0; i < n; i += 2) {
+		if (ntz8(test[i]) != test[i+1]) error(test[i], ntz8(test[i]));}
+	TimestampEnd = std::clock();
+
+	std::printf("ntz8: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
+
+	TimestampBeg = std::clock();
+	for (std::size_t k = 0; k < Count; ++k)
+	for (i = 0; i < n; i += 2) {
+		if (ntz8a(test[i]) != test[i+1]) error(test[i], ntz8a(test[i]));}
+	TimestampEnd = std::clock();
+
+	std::printf("ntz8a: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
+
+	TimestampBeg = std::clock();
+	for (std::size_t k = 0; k < Count; ++k)
+	for (i = 0; i < n; i += 2) {
+		if (ntz9(test[i]) != test[i+1]) error(test[i], ntz9(test[i]));}
+	TimestampEnd = std::clock();
+
+	std::printf("ntz9: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
+
+	TimestampBeg = std::clock();
+	for (std::size_t k = 0; k < Count; ++k)
+	for (i = 0; i < n; i += 2) {
+		if (ntz10(test[i]) != test[i+1]) error(test[i], ntz10(test[i]));}
+	TimestampEnd = std::clock();
+
+	std::printf("ntz10: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
+
+	if (errors == 0)
+		std::printf("Passed all %d cases.\n", static_cast<int>(sizeof(test)/8));
+
+#	endif//NDEBUG
+}
diff --git a/3rdparty/glm/source/test/core/core_func_integer_find_msb.cpp b/3rdparty/glm/source/test/core/core_func_integer_find_msb.cpp
new file mode 100644
index 0000000..c435467
--- /dev/null
+++ b/3rdparty/glm/source/test/core/core_func_integer_find_msb.cpp
@@ -0,0 +1,440 @@
+#include <glm/glm.hpp>
+#include <cstdio>
+#include <cstdlib>     // To define "exit", req'd by XLC.
+#include <ctime>
+
+#define LE 1            // 1 for little-endian, 0 for big-endian.
+
+int pop(unsigned x) {
+   x = x - ((x >> 1) & 0x55555555);
+   x = (x & 0x33333333) + ((x >> 2) & 0x33333333);
+   x = (x + (x >> 4)) & 0x0F0F0F0F;
+   x = x + (x << 8);
+   x = x + (x << 16);
+   return x >> 24;
+}
+
+int nlz1(unsigned x) {
+   int n;
+
+   if (x == 0) return(32);
+   n = 0;
+   if (x <= 0x0000FFFF) {n = n +16; x = x <<16;}
+   if (x <= 0x00FFFFFF) {n = n + 8; x = x << 8;}
+   if (x <= 0x0FFFFFFF) {n = n + 4; x = x << 4;}
+   if (x <= 0x3FFFFFFF) {n = n + 2; x = x << 2;}
+   if (x <= 0x7FFFFFFF) {n = n + 1;}
+   return n;
+}
+
+int nlz1a(unsigned x) {
+   int n;
+
+/* if (x == 0) return(32); */
+   if (static_cast<int>(x) <= 0) return (~x >> 26) & 32;
+   n = 1;
+   if ((x >> 16) == 0) {n = n +16; x = x <<16;}
+   if ((x >> 24) == 0) {n = n + 8; x = x << 8;}
+   if ((x >> 28) == 0) {n = n + 4; x = x << 4;}
+   if ((x >> 30) == 0) {n = n + 2; x = x << 2;}
+   n = n - (x >> 31);
+   return n;
+}
+// On basic Risc, 12 to 20 instructions.
+
+int nlz2(unsigned x) {
+   unsigned y;
+   int n;
+
+   n = 32;
+   y = x >>16;  if (y != 0) {n = n -16;  x = y;}
+   y = x >> 8;  if (y != 0) {n = n - 8;  x = y;}
+   y = x >> 4;  if (y != 0) {n = n - 4;  x = y;}
+   y = x >> 2;  if (y != 0) {n = n - 2;  x = y;}
+   y = x >> 1;  if (y != 0) return n - 2;
+   return n - x;
+}
+
+// As above but coded as a loop for compactness:
+// 23 to 33 basic Risc instructions.
+int nlz2a(unsigned x) {
+   unsigned y;
+   int n, c;
+
+   n = 32;
+   c = 16;
+   do {
+      y = x >> c;  if (y != 0) {n = n - c;  x = y;}
+      c = c >> 1;
+   } while (c != 0);
+   return n - x;
+}
+
+int nlz3(int x) {
+   int y, n;
+
+   n = 0;
+   y = x;
+L: if (x < 0) return n;
+   if (y == 0) return 32 - n;
+   n = n + 1;
+   x = x << 1;
+   y = y >> 1;
+   goto L;
+}
+
+int nlz4(unsigned x) {
+   int y, m, n;
+
+   y = -(x >> 16);      // If left half of x is 0,
+   m = (y >> 16) & 16;  // set n = 16.  If left half
+   n = 16 - m;          // is nonzero, set n = 0 and
+   x = x >> m;          // shift x right 16.
+                        // Now x is of the form 0000xxxx.
+   y = x - 0x100;       // If positions 8-15 are 0,
+   m = (y >> 16) & 8;   // add 8 to n and shift x left 8.
+   n = n + m;
+   x = x << m;
+
+   y = x - 0x1000;      // If positions 12-15 are 0,
+   m = (y >> 16) & 4;   // add 4 to n and shift x left 4.
+   n = n + m;
+   x = x << m;
+
+   y = x - 0x4000;      // If positions 14-15 are 0,
+   m = (y >> 16) & 2;   // add 2 to n and shift x left 2.
+   n = n + m;
+   x = x << m;
+
+   y = x >> 14;         // Set y = 0, 1, 2, or 3.
+   m = y & ~(y >> 1);   // Set m = 0, 1, 2, or 2 resp.
+   return n + 2 - m;
+}
+
+int nlz5(unsigned x) {
+   int pop(unsigned x);
+
+   x = x | (x >> 1);
+   x = x | (x >> 2);
+   x = x | (x >> 4);
+   x = x | (x >> 8);
+   x = x | (x >>16);
+   return pop(~x);
+}
+
+/* The four programs below are not valid ANSI C programs.  This is
+because they refer to the same storage locations as two different types.
+However, they work with xlc/AIX, gcc/AIX, and gcc/NT.  If you try to
+code them more compactly by declaring a variable xx to be "double," and
+then using
+
+   n = 1054 - (*((unsigned *)&xx + LE) >> 20);
+
+then you are violating not only the rule above, but also the ANSI C
+rule that pointer arithmetic can be performed only on pointers to
+array elements.
+   When coded with the above statement, the program fails with xlc,
+gcc/AIX, and gcc/NT, at some optimization levels.
+   BTW, these programs use the "anonymous union" feature of C++, not
+available in C. */
+
+int nlz6(unsigned k)
+{
+	union {
+		unsigned asInt[2];
+		double asDouble;
+	};
+	int n;
+
+	asDouble = static_cast<double>(k) + 0.5;
+	n = 1054 - (asInt[LE] >> 20);
+	return n;
+}
+
+int nlz7(unsigned k)
+{
+	union {
+		unsigned asInt[2];
+		double asDouble;
+	};
+	int n;
+
+	asDouble = static_cast<double>(k);
+	n = 1054 - (asInt[LE] >> 20);
+	n = (n & 31) + (n >> 9);
+	return n;
+}
+
+   /* In single qualifier, round-to-nearest mode, the basic method fails for:
+   k = 0, k = 01FFFFFF, 03FFFFFE <= k <= 03FFFFFF,
+                        07FFFFFC <= k <= 07FFFFFF,
+                        0FFFFFF8 <= k <= 0FFFFFFF,
+                                   ...
+                        7FFFFFC0 <= k <= 7FFFFFFF.
+                        FFFFFF80 <= k <= FFFFFFFF.
+   For k = 0 it gives 158, and for the other values it is too low by 1. */
+
+int nlz8(unsigned k)
+{
+	union {
+		unsigned asInt;
+		float asFloat;
+	};
+	int n;
+
+	k = k & ~(k >> 1);           /* Fix problem with rounding. */
+	asFloat = static_cast<float>(k) + 0.5f;
+	n = 158 - (asInt >> 23);
+	return n;
+}
+
+/* The example below shows how to make a macro for nlz.  It uses an
+extension to the C and C++ languages that is provided by the GNU C/C++
+compiler, namely, that of allowing statements and declarations in
+expressions (see "Using and Porting GNU CC", by Richard M. Stallman
+(1998).  The underscores are necessary to protect against the
+possibility that the macro argument will conflict with one of its local
+variables, e.g., NLZ(k). */
+
+int nlz9(unsigned k)
+{
+	union {
+		unsigned asInt;
+		float asFloat;
+	};
+	int n;
+
+	k = k & ~(k >> 1);           /* Fix problem with rounding. */
+	asFloat = static_cast<float>(k);
+	n = 158 - (asInt >> 23);
+	n = (n & 31) + (n >> 6);     /* Fix problem with k = 0. */
+	return n;
+}
+
+/* Below are three nearly equivalent programs for computing the number
+of leading zeros in a word. This material is not in HD, but may be in a
+future edition.
+   Immediately below is Robert Harley's algorithm, found at the
+comp.arch newsgroup entry dated 7/12/96, pointed out to me by Norbert
+Juffa.
+   Table entries marked "u" are unused. 14 ops including a multiply,
+plus an indexed load.
+   The smallest multiplier that works is 0x045BCED1 = 17*65*129*513 (all
+of form 2**k + 1). There are no multipliers of three terms of the form
+2**k +- 1 that work, with a table size of 64 or 128. There are some,
+with a table size of 64, if you precede the multiplication with x = x -
+(x >> 1), but that seems less elegant. There are also some if you use a
+table size of 256, the smallest is 0x01033CBF = 65*255*1025 (this would
+save two instructions in the form of this algorithm with the
+multiplication expanded into shifts and adds, but the table size is
+getting a bit large). */
+
+#define u 99
+int nlz10(unsigned x)
+{
+	static char table[64] =
+		{32,31, u,16, u,30, 3, u,  15, u, u, u,29,10, 2, u,
+		u, u,12,14,21, u,19, u,   u,28, u,25, u, 9, 1, u,
+		17, u, 4, u, u, u,11, u,  13,22,20, u,26, u, u,18,
+		5, u, u,23, u,27, u, 6,   u,24, 7, u, 8, u, 0, u};
+
+	x = x | (x >> 1);		// Propagate leftmost
+	x = x | (x >> 2);		// 1-bit to the right.
+	x = x | (x >> 4);
+	x = x | (x >> 8);
+	x = x | (x >>16);
+	x = x*0x06EB14F9;		// Multiplier is 7*255**3.
+	return table[x >> 26];
+}
+
+/* Harley's algorithm with multiply expanded.
+19 elementary ops plus an indexed load. */
+
+int nlz10a(unsigned x)
+{
+	static char table[64] =
+		{32,31, u,16, u,30, 3, u,  15, u, u, u,29,10, 2, u,
+		u, u,12,14,21, u,19, u,   u,28, u,25, u, 9, 1, u,
+		17, u, 4, u, u, u,11, u,  13,22,20, u,26, u, u,18,
+		5, u, u,23, u,27, u, 6,   u,24, 7, u, 8, u, 0, u};
+
+	x = x | (x >> 1);    // Propagate leftmost
+	x = x | (x >> 2);    // 1-bit to the right.
+	x = x | (x >> 4);
+	x = x | (x >> 8);
+	x = x | (x >> 16);
+	x = (x << 3) - x;    // Multiply by 7.
+	x = (x << 8) - x;    // Multiply by 255.
+	x = (x << 8) - x;    // Again.
+	x = (x << 8) - x;    // Again.
+	return table[x >> 26];
+}
+
+/* Julius Goryavsky's version of Harley's algorithm.
+17 elementary ops plus an indexed load, if the machine
+has "and not." */
+
+int nlz10b(unsigned x)
+{
+	static char table[64] =
+		{32,20,19, u, u,18, u, 7,  10,17, u, u,14, u, 6, u,
+		u, 9, u,16, u, u, 1,26,   u,13, u, u,24, 5, u, u,
+		u,21, u, 8,11, u,15, u,   u, u, u, 2,27, 0,25, u,
+		22, u,12, u, u, 3,28, u,  23, u, 4,29, u, u,30,31};
+
+	x = x | (x >> 1);    // Propagate leftmost
+	x = x | (x >> 2);    // 1-bit to the right.
+	x = x | (x >> 4);
+	x = x | (x >> 8);
+	x = x & ~(x >> 16);
+	x = x*0xFD7049FF;    // Activate this line or the following 3.
+	// x = (x << 9) - x;    // Multiply by 511.
+	// x = (x << 11) - x;   // Multiply by 2047.
+	// x = (x << 14) - x;   // Multiply by 16383.
+	return table[x >> 26];
+}
+
+int errors;
+void error(int x, int y)
+{
+	errors = errors + 1;
+	std::printf("Error for x = %08x, got %d\n", x, y);
+}
+
+int main()
+{
+#	ifdef NDEBUG
+
+	int i, n;
+	static unsigned test[] = {0,32, 1,31, 2,30, 3,30, 4,29, 5,29, 6,29,
+		7,29, 8,28, 9,28, 16,27, 32,26, 64,25, 128,24, 255,24, 256,23,
+		512,22, 1024,21, 2048,20, 4096,19, 8192,18, 16384,17, 32768,16,
+		65536,15, 0x20000,14, 0x40000,13, 0x80000,12, 0x100000,11,
+		0x200000,10, 0x400000,9, 0x800000,8, 0x1000000,7, 0x2000000,6,
+		0x4000000,5, 0x8000000,4, 0x0FFFFFFF,4, 0x10000000,3,
+		0x3000FFFF,2, 0x50003333,1, 0x7FFFFFFF,1, 0x80000000,0,
+		0xFFFFFFFF,0};
+	std::size_t const Count = 1000;
+
+	n = sizeof(test)/4;
+
+	std::clock_t TimestampBeg = 0;
+	std::clock_t TimestampEnd = 0;
+
+	TimestampBeg = std::clock();
+	for (std::size_t k = 0; k < Count; ++k)
+	for (i = 0; i < n; i += 2) {
+		if (nlz1(test[i]) != test[i+1]) error(test[i], nlz1(test[i]));}
+	TimestampEnd = std::clock();
+
+	std::printf("nlz1: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
+
+	TimestampBeg = std::clock();
+	for (std::size_t k = 0; k < Count; ++k)
+	for (i = 0; i < n; i += 2) {
+		if (nlz1a(test[i]) != test[i+1]) error(test[i], nlz1a(test[i]));}
+	TimestampEnd = std::clock();
+
+	std::printf("nlz1a: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
+
+	TimestampBeg = std::clock();
+	for (std::size_t k = 0; k < Count; ++k)
+	for (i = 0; i < n; i += 2) {
+		if (nlz2(test[i]) != test[i+1]) error(test[i], nlz2(test[i]));}
+	TimestampEnd = std::clock();
+
+	std::printf("nlz2: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
+
+	TimestampBeg = std::clock();
+	for (std::size_t k = 0; k < Count; ++k)
+	for (i = 0; i < n; i += 2) {
+		if (nlz2a(test[i]) != test[i+1]) error(test[i], nlz2a(test[i]));}
+	TimestampEnd = std::clock();
+
+	std::printf("nlz2a: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
+
+	TimestampBeg = std::clock();
+	for (std::size_t k = 0; k < Count; ++k)
+	for (i = 0; i < n; i += 2) {
+		if (nlz3(test[i]) != test[i+1]) error(test[i], nlz3(test[i]));}
+	TimestampEnd = std::clock();
+
+	std::printf("nlz3: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
+
+	TimestampBeg = std::clock();
+	for (std::size_t k = 0; k < Count; ++k)
+	for (i = 0; i < n; i += 2) {
+		if (nlz4(test[i]) != test[i+1]) error(test[i], nlz4(test[i]));}
+	TimestampEnd = std::clock();
+
+	std::printf("nlz4: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
+
+	TimestampBeg = std::clock();
+	for (std::size_t k = 0; k < Count; ++k)
+	for (i = 0; i < n; i += 2) {
+		if (nlz5(test[i]) != test[i+1]) error(test[i], nlz5(test[i]));}
+	TimestampEnd = std::clock();
+
+	std::printf("nlz5: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
+
+	TimestampBeg = std::clock();
+	for (std::size_t k = 0; k < Count; ++k)
+	for (i = 0; i < n; i += 2) {
+		if (nlz6(test[i]) != test[i+1]) error(test[i], nlz6(test[i]));}
+	TimestampEnd = std::clock();
+
+	std::printf("nlz6: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
+
+	TimestampBeg = std::clock();
+	for (std::size_t k = 0; k < Count; ++k)
+	for (i = 0; i < n; i += 2) {
+		if (nlz7(test[i]) != test[i+1]) error(test[i], nlz7(test[i]));}
+	TimestampEnd = std::clock();
+
+	std::printf("nlz7: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
+
+	TimestampBeg = std::clock();
+	for (std::size_t k = 0; k < Count; ++k)
+	for (i = 0; i < n; i += 2) {
+		if (nlz8(test[i]) != test[i+1]) error(test[i], nlz8(test[i]));}
+	TimestampEnd = std::clock();
+
+	std::printf("nlz8: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
+
+	TimestampBeg = std::clock();
+	for (std::size_t k = 0; k < Count; ++k)
+	for (i = 0; i < n; i += 2) {
+		if (nlz9(test[i]) != test[i+1]) error(test[i], nlz9(test[i]));}
+	TimestampEnd = std::clock();
+
+	std::printf("nlz9: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
+
+	TimestampBeg = std::clock();
+	for (std::size_t k = 0; k < Count; ++k)
+	for (i = 0; i < n; i += 2) {
+		if (nlz10(test[i]) != test[i+1]) error(test[i], nlz10(test[i]));}
+	TimestampEnd = std::clock();
+
+	std::printf("nlz10: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
+
+	TimestampBeg = std::clock();
+	for (std::size_t k = 0; k < Count; ++k)
+	for (i = 0; i < n; i += 2) {
+		if (nlz10a(test[i]) != test[i+1]) error(test[i], nlz10a(test[i]));}
+	TimestampEnd = std::clock();
+
+	std::printf("nlz10a: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
+
+	TimestampBeg = std::clock();
+	for (std::size_t k = 0; k < Count; ++k)
+	for (i = 0; i < n; i += 2) {
+		if (nlz10b(test[i]) != test[i+1]) error(test[i], nlz10b(test[i]));}
+	TimestampEnd = std::clock();
+
+	std::printf("nlz10b: %d clocks\n", static_cast<int>(TimestampEnd - TimestampBeg));
+
+	if (errors == 0)
+		std::printf("Passed all %d cases.\n", static_cast<int>(sizeof(test)/8));
+
+#	endif//NDEBUG
+}
diff --git a/3rdparty/glm/source/test/core/core_func_matrix.cpp b/3rdparty/glm/source/test/core/core_func_matrix.cpp
new file mode 100644
index 0000000..c5b2007
--- /dev/null
+++ b/3rdparty/glm/source/test/core/core_func_matrix.cpp
@@ -0,0 +1,312 @@
+#include <glm/ext/matrix_relational.hpp>
+#include <glm/ext/matrix_transform.hpp>
+#include <glm/ext/scalar_constants.hpp>
+#include <glm/mat2x2.hpp>
+#include <glm/mat2x3.hpp>
+#include <glm/mat2x4.hpp>
+#include <glm/mat3x2.hpp>
+#include <glm/mat3x3.hpp>
+#include <glm/mat3x4.hpp>
+#include <glm/mat4x2.hpp>
+#include <glm/mat4x3.hpp>
+#include <glm/mat4x4.hpp>
+#include <vector>
+#include <ctime>
+#include <cstdio>
+
+using namespace glm;
+
+int test_matrixCompMult()
+{
+	int Error(0);
+
+	{
+		mat2 m(0, 1, 2, 3);
+		mat2 n = matrixCompMult(m, m);
+		mat2 expected = mat2(0, 1, 4, 9);
+		Error += all(equal(n, expected, epsilon<float>())) ? 0 : 1;
+	}
+
+	{
+		mat2x3 m(0, 1, 2, 3, 4, 5);
+		mat2x3 n = matrixCompMult(m, m);
+		mat2x3 expected = mat2x3(0, 1, 4, 9, 16, 25);
+		Error += all(equal(n, expected, epsilon<float>())) ? 0 : 1;
+	}
+
+	{
+		mat2x4 m(0, 1, 2, 3, 4, 5, 6, 7);
+		mat2x4 n = matrixCompMult(m, m);
+		mat2x4 expected = mat2x4(0, 1, 4, 9, 16, 25, 36, 49);
+		Error += all(equal(n, expected, epsilon<float>())) ? 0 : 1;
+	}
+
+	{
+		mat3 m(0, 1, 2, 3, 4, 5, 6, 7, 8);
+		mat3 n = matrixCompMult(m, m);
+		mat3 expected = mat3(0, 1, 4, 9, 16, 25, 36, 49, 64);
+		Error += all(equal(n, expected, epsilon<float>())) ? 0 : 1;
+	}
+
+	{
+		mat3x2 m(0, 1, 2, 3, 4, 5);
+		mat3x2 n = matrixCompMult(m, m);
+		mat3x2 expected = mat3x2(0, 1, 4, 9, 16, 25);
+		Error += all(equal(n, expected, epsilon<float>())) ? 0 : 1;
+	}
+
+	{
+		mat3x4 m(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11);
+		mat3x4 n = matrixCompMult(m, m);
+		mat3x4 expected = mat3x4(0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121);
+		Error += all(equal(n, expected, epsilon<float>())) ? 0 : 1;
+	}
+
+	{
+		mat4 m(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
+		mat4 n = matrixCompMult(m, m);
+		mat4 expected = mat4(0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121, 144, 169, 196, 225);
+		Error += all(equal(n, expected, epsilon<float>())) ? 0 : 1;
+	}
+
+	{
+		mat4x2 m(0, 1, 2, 3, 4, 5, 6, 7);
+		mat4x2 n = matrixCompMult(m, m);
+		mat4x2 expected = mat4x2(0, 1, 4, 9, 16, 25, 36, 49);
+		Error += all(equal(n, expected, epsilon<float>())) ? 0 : 1;
+	}
+
+	{
+		mat4x3 m(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11);
+		mat4x3 n = matrixCompMult(m, m);
+		mat4x3 expected = mat4x3(0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121);
+		Error += all(equal(n, expected, epsilon<float>())) ? 0 : 1;
+	}
+
+	return Error;
+}
+
+int test_outerProduct()
+{
+	{ glm::mat2 m = glm::outerProduct(glm::vec2(1.0f), glm::vec2(1.0f)); }
+	{ glm::mat3 m = glm::outerProduct(glm::vec3(1.0f), glm::vec3(1.0f)); }
+	{ glm::mat4 m = glm::outerProduct(glm::vec4(1.0f), glm::vec4(1.0f)); }
+
+	{ glm::mat2x3 m = glm::outerProduct(glm::vec3(1.0f), glm::vec2(1.0f)); }
+	{ glm::mat2x4 m = glm::outerProduct(glm::vec4(1.0f), glm::vec2(1.0f)); }
+
+	{ glm::mat3x2 m = glm::outerProduct(glm::vec2(1.0f), glm::vec3(1.0f)); }
+	{ glm::mat3x4 m = glm::outerProduct(glm::vec4(1.0f), glm::vec3(1.0f)); }
+  
+	{ glm::mat4x2 m = glm::outerProduct(glm::vec2(1.0f), glm::vec4(1.0f)); }
+	{ glm::mat4x3 m = glm::outerProduct(glm::vec3(1.0f), glm::vec4(1.0f)); }
+
+	return 0;
+}
+
+int test_transpose()
+{
+	int Error(0);
+
+	{
+		mat2 const m(0, 1, 2, 3);
+		mat2 const t = transpose(m);
+		mat2 const expected = mat2(0, 2, 1, 3);
+		Error += all(equal(t, expected, epsilon<float>())) ? 0 : 1;
+	}
+
+	{
+		mat2x3 m(0, 1, 2, 3, 4, 5);
+		mat3x2 t = transpose(m);
+		mat3x2 const expected = mat3x2(0, 3, 1, 4, 2, 5);
+		Error += all(equal(t, expected, epsilon<float>())) ? 0 : 1;
+	}
+
+	{
+		mat2x4 m(0, 1, 2, 3, 4, 5, 6, 7);
+		mat4x2 t = transpose(m);
+		mat4x2 const expected = mat4x2(0, 4, 1, 5, 2, 6, 3, 7);
+		Error += all(equal(t, expected, epsilon<float>())) ? 0 : 1;
+	}
+
+	{
+		mat3 m(0, 1, 2, 3, 4, 5, 6, 7, 8);
+		mat3 t = transpose(m);
+		mat3 const expected = mat3(0, 3, 6, 1, 4, 7, 2, 5, 8);
+		Error += all(equal(t, expected, epsilon<float>())) ? 0 : 1;
+	}
+
+	{
+		mat3x2 m(0, 1, 2, 3, 4, 5);
+		mat2x3 t = transpose(m);
+		mat2x3 const expected = mat2x3(0, 2, 4, 1, 3, 5);
+		Error += all(equal(t, expected, epsilon<float>())) ? 0 : 1;
+	}
+
+	{
+		mat3x4 m(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11);
+		mat4x3 t = transpose(m);
+		mat4x3 const expected = mat4x3(0, 4, 8, 1, 5, 9, 2, 6, 10, 3, 7, 11);
+		Error += all(equal(t, expected, epsilon<float>())) ? 0 : 1;
+	}
+
+	{
+		mat4 m(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
+		mat4 t = transpose(m);
+		mat4 const expected = mat4(0, 4, 8, 12, 1, 5, 9, 13, 2, 6, 10, 14, 3, 7, 11, 15);
+		Error += all(equal(t, expected, epsilon<float>())) ? 0 : 1;
+	}
+
+	{
+		mat4x2 m(0, 1, 2, 3, 4, 5, 6, 7);
+		mat2x4 t = transpose(m);
+		mat2x4 const expected = mat2x4(0, 2, 4, 6, 1, 3, 5, 7);
+		Error += all(equal(t, expected, epsilon<float>())) ? 0 : 1;
+	}
+
+	{
+		mat4x3 m(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11);
+		mat3x4 t = transpose(m);
+		mat3x4 const expected = mat3x4(0, 3, 6, 9, 1, 4, 7, 10, 2, 5, 8, 11);
+		Error += all(equal(t, expected, epsilon<float>())) ? 0 : 1;
+	}
+
+	return Error;
+}
+
+int test_determinant()
+{
+
+
+	return 0;
+}
+
+int test_inverse()
+{
+	int Error = 0;
+
+	{
+		glm::mat4x4 A4x4(
+			glm::vec4(1, 0, 1, 0), 
+			glm::vec4(0, 1, 0, 0), 
+			glm::vec4(0, 0, 1, 0), 
+			glm::vec4(0, 0, 0, 1));
+		glm::mat4x4 B4x4 = inverse(A4x4);
+		glm::mat4x4 I4x4 = A4x4 * B4x4;
+		glm::mat4x4 Identity(1);
+		Error += all(equal(I4x4, Identity, epsilon<float>())) ? 0 : 1;
+	}
+
+	{
+		glm::mat3x3 A3x3(
+			glm::vec3(1, 0, 1), 
+			glm::vec3(0, 1, 0), 
+			glm::vec3(0, 0, 1));
+		glm::mat3x3 B3x3 = glm::inverse(A3x3);
+		glm::mat3x3 I3x3 = A3x3 * B3x3;
+		glm::mat3x3 Identity(1);
+		Error += all(equal(I3x3, Identity, epsilon<float>())) ? 0 : 1;
+	}
+
+	{
+		glm::mat2x2 A2x2(
+			glm::vec2(1, 1), 
+			glm::vec2(0, 1));
+		glm::mat2x2 B2x2 = glm::inverse(A2x2);
+		glm::mat2x2 I2x2 = A2x2 * B2x2;
+		glm::mat2x2 Identity(1);
+		Error += all(equal(I2x2, Identity, epsilon<float>())) ? 0 : 1;
+	}
+
+	return Error;
+}
+
+int test_inverse_simd()
+{
+	int Error = 0;
+
+	glm::mat4x4 const Identity(1);
+
+	glm::mat4x4 const A4x4(
+		glm::vec4(1, 0, 1, 0),
+		glm::vec4(0, 1, 0, 0),
+		glm::vec4(0, 0, 1, 0),
+		glm::vec4(0, 0, 0, 1));
+	glm::mat4x4 const B4x4 = glm::inverse(A4x4);
+	glm::mat4x4 const I4x4 = A4x4 * B4x4;
+
+	Error += glm::all(glm::equal(I4x4, Identity, 0.001f)) ? 0 : 1;
+
+	return Error;
+}
+
+template<typename VEC3, typename MAT4>
+int test_inverse_perf(std::size_t Count, std::size_t Instance, char const * Message)
+{
+	std::vector<MAT4> TestInputs;
+	TestInputs.resize(Count);
+	std::vector<MAT4> TestOutputs;
+	TestOutputs.resize(TestInputs.size());
+
+	VEC3 Axis(glm::normalize(VEC3(1.0f, 2.0f, 3.0f)));
+
+	for(std::size_t i = 0; i < TestInputs.size(); ++i)
+	{
+		typename MAT4::value_type f = static_cast<typename MAT4::value_type>(i + Instance) * typename MAT4::value_type(0.1) + typename MAT4::value_type(0.1);
+		TestInputs[i] = glm::rotate(glm::translate(MAT4(1), Axis * f), f, Axis);
+		//TestInputs[i] = glm::translate(MAT4(1), Axis * f);
+	}
+
+	std::clock_t StartTime = std::clock();
+
+	for(std::size_t i = 0; i < TestInputs.size(); ++i)
+		TestOutputs[i] = glm::inverse(TestInputs[i]);
+
+	std::clock_t EndTime = std::clock();
+
+	for(std::size_t i = 0; i < TestInputs.size(); ++i)
+		TestOutputs[i] = TestOutputs[i] * TestInputs[i];
+
+	typename MAT4::value_type Diff(0);
+	for(std::size_t Entry = 0; Entry < TestOutputs.size(); ++Entry)
+	{
+		MAT4 i(1.0);
+		MAT4 m(TestOutputs[Entry]);
+		for(glm::length_t y = 0; y < m.length(); ++y)
+		for(glm::length_t x = 0; x < m[y].length(); ++x)
+			Diff = glm::max(m[y][x], i[y][x]);
+	}
+
+	//glm::uint Ulp = 0;
+	//Ulp = glm::max(glm::float_distance(*Dst, *Src), Ulp);
+
+	std::printf("inverse<%s>(%f): %lu\n", Message, static_cast<double>(Diff), EndTime - StartTime);
+
+	return 0;
+}
+
+int main()
+{
+	int Error = 0;
+	Error += test_matrixCompMult();
+	Error += test_outerProduct();
+	Error += test_transpose();
+	Error += test_determinant();
+	Error += test_inverse();
+	Error += test_inverse_simd();
+
+#	ifdef NDEBUG
+	std::size_t const Samples = 1000;
+#	else
+	std::size_t const Samples = 1;
+#	endif//NDEBUG
+
+	for(std::size_t i = 0; i < 1; ++i)
+	{
+		Error += test_inverse_perf<glm::vec3, glm::mat4>(Samples, i, "mat4");
+		Error += test_inverse_perf<glm::dvec3, glm::dmat4>(Samples, i, "dmat4");
+	}
+
+	return Error;
+}
+
diff --git a/3rdparty/glm/source/test/core/core_func_noise.cpp b/3rdparty/glm/source/test/core/core_func_noise.cpp
new file mode 100644
index 0000000..4f0b430
--- /dev/null
+++ b/3rdparty/glm/source/test/core/core_func_noise.cpp
@@ -0,0 +1,7 @@
+int main()
+{
+	int Error = 0;
+
+	return Error;
+}
+
diff --git a/3rdparty/glm/source/test/core/core_func_packing.cpp b/3rdparty/glm/source/test/core/core_func_packing.cpp
new file mode 100644
index 0000000..c3cd14a
--- /dev/null
+++ b/3rdparty/glm/source/test/core/core_func_packing.cpp
@@ -0,0 +1,156 @@
+#include <glm/gtc/type_precision.hpp>
+#include <glm/gtc/epsilon.hpp>
+#include <glm/vector_relational.hpp>
+#include <glm/packing.hpp>
+#include <vector>
+
+int test_packUnorm2x16()
+{
+	int Error = 0;
+
+	std::vector<glm::vec2> A;
+	A.push_back(glm::vec2(1.0f, 0.0f));
+	A.push_back(glm::vec2(0.5f, 0.7f));
+	A.push_back(glm::vec2(0.1f, 0.2f));
+
+	for(std::size_t i = 0; i < A.size(); ++i)
+	{
+		glm::vec2 B(A[i]);
+		glm::uint32 C = glm::packUnorm2x16(B);
+		glm::vec2 D = glm::unpackUnorm2x16(C);
+		Error += glm::all(glm::epsilonEqual(B, D, 1.0f / 65535.f)) ? 0 : 1;
+		assert(!Error);
+	}
+	
+	return Error;
+}
+
+int test_packSnorm2x16()
+{
+	int Error = 0;
+
+	std::vector<glm::vec2> A;
+	A.push_back(glm::vec2( 1.0f, 0.0f));
+	A.push_back(glm::vec2(-0.5f,-0.7f));
+	A.push_back(glm::vec2(-0.1f, 0.1f));
+
+	for(std::size_t i = 0; i < A.size(); ++i)
+	{
+		glm::vec2 B(A[i]);
+		glm::uint32 C = glm::packSnorm2x16(B);
+		glm::vec2 D = glm::unpackSnorm2x16(C);
+		Error += glm::all(glm::epsilonEqual(B, D, 1.0f / 32767.0f * 2.0f)) ? 0 : 1;
+		assert(!Error);
+	}
+	
+	return Error;
+}
+
+int test_packUnorm4x8()
+{
+	int Error = 0;
+
+	glm::uint32 Packed = glm::packUnorm4x8(glm::vec4(1.0f, 0.5f, 0.0f, 1.0f));
+	glm::u8vec4 Vec(255, 128, 0, 255);
+	glm::uint32 & Ref = *reinterpret_cast<glm::uint32*>(&Vec[0]);
+
+	Error += Packed == Ref ? 0 : 1;
+
+	std::vector<glm::vec4> A;
+	A.push_back(glm::vec4(1.0f, 0.7f, 0.3f, 0.0f));
+	A.push_back(glm::vec4(0.5f, 0.1f, 0.2f, 0.3f));
+	
+	for(std::size_t i = 0; i < A.size(); ++i)
+	{
+		glm::vec4 B(A[i]);
+		glm::uint32 C = glm::packUnorm4x8(B);
+		glm::vec4 D = glm::unpackUnorm4x8(C);
+		Error += glm::all(glm::epsilonEqual(B, D, 1.0f / 255.f)) ? 0 : 1;
+		assert(!Error);
+	}
+	
+	return Error;
+}
+
+int test_packSnorm4x8()
+{
+	int Error = 0;
+	
+	std::vector<glm::vec4> A;
+	A.push_back(glm::vec4( 1.0f, 0.0f,-0.5f,-1.0f));
+	A.push_back(glm::vec4(-0.7f,-0.1f, 0.1f, 0.7f));
+	
+	for(std::size_t i = 0; i < A.size(); ++i)
+	{
+		glm::vec4 B(A[i]);
+		glm::uint32 C = glm::packSnorm4x8(B);
+		glm::vec4 D = glm::unpackSnorm4x8(C);
+		Error += glm::all(glm::epsilonEqual(B, D, 1.0f / 127.f)) ? 0 : 1;
+		assert(!Error);
+	}
+	
+	return Error;
+}
+
+int test_packHalf2x16()
+{
+	int Error = 0;
+/*
+	std::vector<glm::hvec2> A;
+	A.push_back(glm::hvec2(glm::half( 1.0f), glm::half( 2.0f)));
+	A.push_back(glm::hvec2(glm::half(-1.0f), glm::half(-2.0f)));
+	A.push_back(glm::hvec2(glm::half(-1.1f), glm::half( 1.1f)));
+*/
+	std::vector<glm::vec2> A;
+	A.push_back(glm::vec2( 1.0f, 2.0f));
+	A.push_back(glm::vec2(-1.0f,-2.0f));
+	A.push_back(glm::vec2(-1.1f, 1.1f));
+
+	for(std::size_t i = 0; i < A.size(); ++i)
+	{
+		glm::vec2 B(A[i]);
+		glm::uint C = glm::packHalf2x16(B);
+		glm::vec2 D = glm::unpackHalf2x16(C);
+		//Error += B == D ? 0 : 1;
+		Error += glm::all(glm::epsilonEqual(B, D, 1.0f / 127.f)) ? 0 : 1;
+		assert(!Error);
+	}
+	
+	return Error;
+}
+
+int test_packDouble2x32()
+{
+	int Error = 0;
+	
+	std::vector<glm::uvec2> A;
+	A.push_back(glm::uvec2( 1, 2));
+	A.push_back(glm::uvec2(-1,-2));
+	A.push_back(glm::uvec2(-1000, 1100));
+	
+	for(std::size_t i = 0; i < A.size(); ++i)
+	{
+		glm::uvec2 B(A[i]);
+		double C = glm::packDouble2x32(B);
+		glm::uvec2 D = glm::unpackDouble2x32(C);
+		Error += B == D ? 0 : 1;
+		assert(!Error);
+	}
+	
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+	
+	Error += test_packSnorm4x8();
+	Error += test_packUnorm4x8();
+	Error += test_packSnorm2x16();
+	Error += test_packUnorm2x16();
+	Error += test_packHalf2x16();
+	Error += test_packDouble2x32();
+
+	return Error;
+}
+
diff --git a/3rdparty/glm/source/test/core/core_func_swizzle.cpp b/3rdparty/glm/source/test/core/core_func_swizzle.cpp
new file mode 100644
index 0000000..9758533
--- /dev/null
+++ b/3rdparty/glm/source/test/core/core_func_swizzle.cpp
@@ -0,0 +1,164 @@
+#define GLM_FORCE_SWIZZLE
+#include <glm/ext/scalar_relational.hpp>
+#include <glm/ext/vector_relational.hpp>
+#include <glm/glm.hpp>
+
+static int test_ivec2_swizzle()
+{
+	int Error = 0;
+
+#	if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR || GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_FUNCTION
+	{
+		glm::ivec2 A(1, 2);
+		glm::ivec2 B = A.yx();
+		glm::ivec2 C = B.yx();
+
+		Error += A != B ? 0 : 1;
+		Error += A == C ? 0 : 1;
+	}
+#	endif//GLM_CONFIG_SWIZZLE
+
+#	if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR
+	{
+		glm::ivec2 A(1, 2);
+		glm::ivec2 B = A.yx;
+		glm::ivec2 C = A.yx;
+
+		Error += A != B ? 0 : 1;
+		Error += B == C ? 0 : 1;
+
+		B.xy = B.yx;
+		C.xy = C.yx;
+
+		Error += B == C ? 0 : 1;
+
+		glm::ivec2 D(0, 0);
+		D.yx = A.xy;
+		Error += A.yx() == D ? 0 : 1;
+
+		glm::ivec2 E = A.yx;
+		Error += E == D ? 0 : 1;
+	}
+#	endif//GLM_CONFIG_SWIZZLE
+
+	return Error;
+}
+
+int test_ivec3_swizzle()
+{
+	int Error = 0;
+
+#	if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR || GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_FUNCTION
+	{
+		glm::ivec3 A(1, 2, 3);
+		glm::ivec3 B = A.zyx();
+		glm::ivec3 C = B.zyx();
+
+		Error += A != B ? 0 : 1;
+		Error += A == C ? 0 : 1;
+	}
+#	endif
+
+#	if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR
+	{
+		glm::ivec3 const A(1, 2, 3);
+		glm::ivec2 B = A.yx;
+		glm::ivec2 C = A.yx;
+
+		Error += A.yx() == B ? 0 : 1;
+		Error += B == C ? 0 : 1;
+
+		B.xy = B.yx;
+		C.xy = C.yx;
+
+		Error += B == C ? 0 : 1;
+
+		glm::ivec2 D(0, 0);
+		D.yx = A.xy;
+
+		Error += A.yx() == D ? 0 : 1;
+
+		glm::ivec2 E(0, 0);
+		E.xy = A.xy();
+
+		Error += E == A.xy() ? 0 : 1;
+		Error += E.xy() == A.xy() ? 0 : 1;
+
+		glm::ivec3 const F = A.xxx + A.xxx;
+		Error += F == glm::ivec3(2) ? 0 : 1;
+
+		glm::ivec3 const G = A.xxx - A.xxx;
+		Error += G == glm::ivec3(0) ? 0 : 1;
+
+		glm::ivec3 const H = A.xxx * A.xxx;
+		Error += H == glm::ivec3(1) ? 0 : 1;
+
+		glm::ivec3 const I = A.xxx / A.xxx;
+		Error += I == glm::ivec3(1) ? 0 : 1;
+
+		glm::ivec3 J(1, 2, 3);
+		J.xyz += glm::ivec3(1);
+		Error += J == glm::ivec3(2, 3, 4) ? 0 : 1;
+
+		glm::ivec3 K(1, 2, 3);
+		K.xyz += A.xyz;
+		Error += K == glm::ivec3(2, 4, 6) ? 0 : 1;
+	}
+#	endif
+
+	return Error;
+}
+
+int test_ivec4_swizzle()
+{
+	int Error = 0;
+
+#	if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR || GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_FUNCTION
+	{
+		glm::ivec4 A(1, 2, 3, 4);
+		glm::ivec4 B = A.wzyx();
+		glm::ivec4 C = B.wzyx();
+
+		Error += A != B ? 0 : 1;
+		Error += A == C ? 0 : 1;
+	}
+#	endif
+
+	return Error;
+}
+
+int test_vec4_swizzle()
+{
+	int Error = 0;
+
+#	if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR || GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_FUNCTION
+	{
+		glm::vec4 A(1, 2, 3, 4);
+		glm::vec4 B = A.wzyx();
+		glm::vec4 C = B.wzyx();
+
+		Error += glm::any(glm::notEqual(A, B, 0.0001f)) ? 0 : 1;
+		Error += glm::all(glm::equal(A, C, 0.0001f)) ? 0 : 1;
+
+		float D = glm::dot(C.wzyx(), C.xyzw());
+		Error += glm::equal(D, 20.f, 0.001f) ? 0 : 1;
+	}
+#	endif
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_ivec2_swizzle();
+	Error += test_ivec3_swizzle();
+	Error += test_ivec4_swizzle();
+	Error += test_vec4_swizzle();
+
+	return Error;
+}
+
+
+
diff --git a/3rdparty/glm/source/test/core/core_func_trigonometric.cpp b/3rdparty/glm/source/test/core/core_func_trigonometric.cpp
new file mode 100644
index 0000000..3172340
--- /dev/null
+++ b/3rdparty/glm/source/test/core/core_func_trigonometric.cpp
@@ -0,0 +1,10 @@
+#include <glm/trigonometric.hpp>
+
+int main()
+{
+	int Error = 0;
+
+
+	return Error;
+}
+
diff --git a/3rdparty/glm/source/test/core/core_func_vector_relational.cpp b/3rdparty/glm/source/test/core/core_func_vector_relational.cpp
new file mode 100644
index 0000000..0a4e7e7
--- /dev/null
+++ b/3rdparty/glm/source/test/core/core_func_vector_relational.cpp
@@ -0,0 +1,180 @@
+#include <glm/vec2.hpp>
+#include <glm/vec3.hpp>
+#include <glm/vec4.hpp>
+#include <glm/vector_relational.hpp>
+#include <glm/gtc/vec1.hpp>
+
+static int test_not()
+{
+	int Error = 0;
+
+	{
+		glm::bvec1 v(false);
+		Error += glm::all(glm::not_(v)) ? 0 : 1;
+	}
+
+	{
+		glm::bvec2 v(false);
+		Error += glm::all(glm::not_(v)) ? 0 : 1;
+	}
+
+	{
+		glm::bvec3 v(false);
+		Error += glm::all(glm::not_(v)) ? 0 : 1;
+	}
+	
+	{
+		glm::bvec4 v(false);
+		Error += glm::all(glm::not_(v)) ? 0 : 1;
+	}
+
+	return Error;
+}
+
+static int test_less()
+{
+	int Error = 0;
+
+	{
+		glm::vec2 const A(1, 2);
+		glm::vec2 const B(2, 3);
+		Error += glm::all(glm::lessThan(A, B)) ? 0: 1;
+		Error += glm::all(glm::lessThanEqual(A, B)) ? 0: 1;
+	}
+
+	{
+		glm::vec3 const A(1, 2, 3);
+		glm::vec3 const B(2, 3, 4);
+		Error += glm::all(glm::lessThan(A, B)) ? 0: 1;
+		Error += glm::all(glm::lessThanEqual(A, B)) ? 0: 1;
+	}
+
+	{
+		glm::vec4 const A(1, 2, 3, 4);
+		glm::vec4 const B(2, 3, 4, 5);
+		Error += glm::all(glm::lessThan(A, B)) ? 0: 1;
+		Error += glm::all(glm::lessThanEqual(A, B)) ? 0: 1;
+	}
+
+	{
+		glm::ivec2 const A(1, 2);
+		glm::ivec2 const B(2, 3);
+		Error += glm::all(glm::lessThan(A, B)) ? 0: 1;
+
+		glm::ivec2 const C(1, 3);
+		Error += glm::all(glm::lessThanEqual(A, C)) ? 0: 1;
+	}
+
+	{
+		glm::ivec3 const A(1, 2, 3);
+		glm::ivec3 const B(2, 3, 4);
+		Error += glm::all(glm::lessThan(A, B)) ? 0: 1;
+
+		glm::ivec3 const C(1, 3, 4);
+		Error += glm::all(glm::lessThanEqual(A, C)) ? 0: 1;
+	}
+
+	{
+		glm::ivec4 const A(1, 2, 3, 4);
+		glm::ivec4 const B(2, 3, 4, 5);
+		Error += glm::all(glm::lessThan(A, B)) ? 0: 1;
+
+		glm::ivec4 const C(1, 3, 4, 5);
+		Error += glm::all(glm::lessThanEqual(A, C)) ? 0: 1;
+	}
+
+	return Error;
+}
+
+static int test_greater()
+{
+	int Error = 0;
+
+	{
+		glm::vec2 const A(1, 2);
+		glm::vec2 const B(2, 3);
+		Error += glm::all(glm::greaterThan(B, A)) ? 0: 1;
+		Error += glm::all(glm::greaterThanEqual(B, A)) ? 0: 1;
+	}
+
+	{
+		glm::vec3 const A(1, 2, 3);
+		glm::vec3 const B(2, 3, 4);
+		Error += glm::all(glm::greaterThan(B, A)) ? 0: 1;
+		Error += glm::all(glm::greaterThanEqual(B, A)) ? 0: 1;
+	}
+
+	{
+		glm::vec4 const A(1, 2, 3, 4);
+		glm::vec4 const B(2, 3, 4, 5);
+		Error += glm::all(glm::greaterThan(B, A)) ? 0: 1;
+		Error += glm::all(glm::greaterThanEqual(B, A)) ? 0: 1;
+	}
+
+	{
+		glm::ivec2 const A(1, 2);
+		glm::ivec2 const B(2, 3);
+		Error += glm::all(glm::greaterThan(B, A)) ? 0: 1;
+
+		glm::ivec2 const C(1, 3);
+		Error += glm::all(glm::greaterThanEqual(C, A)) ? 0: 1;
+	}
+
+	{
+		glm::ivec3 const A(1, 2, 3);
+		glm::ivec3 const B(2, 3, 4);
+		Error += glm::all(glm::greaterThan(B, A)) ? 0: 1;
+
+		glm::ivec3 const C(1, 3, 4);
+		Error += glm::all(glm::greaterThanEqual(C, A)) ? 0: 1;
+	}
+
+	{
+		glm::ivec4 const A(1, 2, 3, 4);
+		glm::ivec4 const B(2, 3, 4, 5);
+		Error += glm::all(glm::greaterThan(B, A)) ? 0: 1;
+
+		glm::ivec4 const C(1, 3, 4, 5);
+		Error += glm::all(glm::greaterThanEqual(C, A)) ? 0: 1;
+	}
+
+	return Error;
+}
+
+static int test_equal()
+{
+	int Error = 0;
+
+	{
+		glm::ivec2 const A(1, 2);
+		glm::ivec2 const B(1, 2);
+		Error += glm::all(glm::equal(B, A)) ? 0: 1;
+	}
+
+	{
+		glm::ivec3 const A(1, 2, 3);
+		glm::ivec3 const B(1, 2, 3);
+		Error += glm::all(glm::equal(B, A)) ? 0: 1;
+	}
+
+	{
+		glm::ivec4 const A(1, 2, 3, 4);
+		glm::ivec4 const B(1, 2, 3, 4);
+		Error += glm::all(glm::equal(B, A)) ? 0: 1;
+	}
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_not();
+	Error += test_less();
+	Error += test_greater();
+	Error += test_equal();
+
+	return Error;
+}
+
diff --git a/3rdparty/glm/source/test/core/core_setup_force_cxx98.cpp b/3rdparty/glm/source/test/core/core_setup_force_cxx98.cpp
new file mode 100644
index 0000000..32bb63c
--- /dev/null
+++ b/3rdparty/glm/source/test/core/core_setup_force_cxx98.cpp
@@ -0,0 +1,12 @@
+#ifndef GLM_FORCE_CXX98
+#	define GLM_FORCE_CXX98
+#endif
+#include <glm/glm.hpp>
+#include <glm/ext.hpp>
+
+int main()
+{
+	int Error = 0;
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/core/core_setup_force_size_t_length.cpp b/3rdparty/glm/source/test/core/core_setup_force_size_t_length.cpp
new file mode 100644
index 0000000..36010e3
--- /dev/null
+++ b/3rdparty/glm/source/test/core/core_setup_force_size_t_length.cpp
@@ -0,0 +1,22 @@
+#define GLM_FORCE_SIZE_T_LENGTH
+#include <glm/glm.hpp>
+#include <glm/ext.hpp>
+
+template <typename genType>
+genType add(genType const& a, genType const& b)
+{
+	genType result(0);
+	for(glm::length_t i = 0; i < a.length(); ++i)
+		result[i] = a[i] + b[i];
+	return result;
+}
+
+int main()
+{
+	int Error = 0;
+
+	glm::ivec4 v(1);
+	Error += add(v, v) == glm::ivec4(2) ? 0 : 1;
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/core/core_setup_message.cpp b/3rdparty/glm/source/test/core/core_setup_message.cpp
new file mode 100644
index 0000000..7594743
--- /dev/null
+++ b/3rdparty/glm/source/test/core/core_setup_message.cpp
@@ -0,0 +1,230 @@
+#define GLM_FORCE_MESSAGES
+#include <glm/vec3.hpp>
+#include <cstdio>
+
+int test_compiler()
+{
+	int Error(0);
+	
+	if(GLM_COMPILER & GLM_COMPILER_VC)
+	{
+		switch(GLM_COMPILER)
+		{
+		case GLM_COMPILER_VC12:
+			std::printf("Visual C++ 12 - 2013\n");
+			break;
+		case GLM_COMPILER_VC14:
+			std::printf("Visual C++ 14 - 2015\n");
+			break;
+		case GLM_COMPILER_VC15:
+			std::printf("Visual C++ 15 - 2017\n");
+			break;
+		case GLM_COMPILER_VC15_3:
+			std::printf("Visual C++ 15.3 - 2017\n");
+			break;
+		case GLM_COMPILER_VC15_5:
+			std::printf("Visual C++ 15.5 - 2017\n");
+			break;
+		case GLM_COMPILER_VC15_6:
+			std::printf("Visual C++ 15.6 - 2017\n");
+			break;
+		case GLM_COMPILER_VC15_7:
+			std::printf("Visual C++ 15.7 - 2017\n");
+			break;
+		case GLM_COMPILER_VC15_8:
+			std::printf("Visual C++ 15.8 - 2017\n");
+			break;
+		case GLM_COMPILER_VC15_9:
+			std::printf("Visual C++ 15.9 - 2017\n");
+			break;
+		case GLM_COMPILER_VC16:
+			std::printf("Visual C++ 16 - 2019\n");
+			break;
+		default:
+			std::printf("Visual C++ version not detected\n");
+			Error += 1;
+			break;
+		}
+	}
+	else if(GLM_COMPILER & GLM_COMPILER_GCC)
+	{
+		switch(GLM_COMPILER)
+		{
+		case GLM_COMPILER_GCC46:
+			std::printf("GCC 4.6\n");
+			break;
+		case GLM_COMPILER_GCC47:
+			std::printf("GCC 4.7\n");
+			break;
+		case GLM_COMPILER_GCC48:
+			std::printf("GCC 4.8\n");
+			break;
+		case GLM_COMPILER_GCC49:
+			std::printf("GCC 4.9\n");
+			break;
+		case GLM_COMPILER_GCC5:
+			std::printf("GCC 5\n");
+			break;
+		case GLM_COMPILER_GCC6:
+			std::printf("GCC 6\n");
+			break;
+		case GLM_COMPILER_GCC7:
+			std::printf("GCC 7\n");
+			break;
+		case GLM_COMPILER_GCC8:
+			std::printf("GCC 8\n");
+			break;
+		default:
+			std::printf("GCC version not detected\n");
+			Error += 1;
+			break;
+		}
+	}
+	else if(GLM_COMPILER & GLM_COMPILER_CUDA)
+	{
+		std::printf("CUDA\n");
+	}
+	else if(GLM_COMPILER & GLM_COMPILER_CLANG)
+	{
+		switch(GLM_COMPILER)
+		{
+		case GLM_COMPILER_CLANG34:
+			std::printf("Clang 3.4\n");
+			break;
+		case GLM_COMPILER_CLANG35:
+			std::printf("Clang 3.5\n");
+			break;
+		case GLM_COMPILER_CLANG36:
+			std::printf("Clang 3.6\n");
+			break;
+		case GLM_COMPILER_CLANG37:
+			std::printf("Clang 3.7\n");
+			break;
+		case GLM_COMPILER_CLANG38:
+			std::printf("Clang 3.8\n");
+			break;
+		case GLM_COMPILER_CLANG39:
+			std::printf("Clang 3.9\n");
+			break;
+		case GLM_COMPILER_CLANG40:
+			std::printf("Clang 4.0\n");
+			break;
+		case GLM_COMPILER_CLANG41:
+			std::printf("Clang 4.1\n");
+			break;
+		case GLM_COMPILER_CLANG42:
+			std::printf("Clang 4.2\n");
+			break;
+		default:
+			std::printf("LLVM version not detected\n");
+			break;
+		}
+	}
+	else if(GLM_COMPILER & GLM_COMPILER_INTEL)
+	{
+		switch(GLM_COMPILER)
+		{
+		case GLM_COMPILER_INTEL14:
+			std::printf("ICC 14 - 2013 SP1\n");
+			break;
+		case GLM_COMPILER_INTEL15:
+			std::printf("ICC 15 - 2015\n");
+			break;
+		case GLM_COMPILER_INTEL16:
+			std::printf("ICC 16 - 2017\n");
+			break;
+		case GLM_COMPILER_INTEL17:
+			std::printf("ICC 17 - 20XX\n");
+			break;
+		default:
+			std::printf("Intel compiler version not detected\n");
+			Error += 1;
+			break;
+		}
+	}
+	else
+	{
+		std::printf("Undetected compiler\n");
+		Error += 1;
+	}
+	
+	return Error;
+}
+
+int test_model()
+{
+	int Error = 0;
+	
+	Error += ((sizeof(void*) == 4) && (GLM_MODEL == GLM_MODEL_32)) || ((sizeof(void*) == 8) && (GLM_MODEL == GLM_MODEL_64)) ? 0 : 1;
+	
+	if(GLM_MODEL == GLM_MODEL_32)
+		std::printf("GLM_MODEL_32\n");
+	else if(GLM_MODEL == GLM_MODEL_64)
+		std::printf("GLM_MODEL_64\n");
+	
+	return Error;
+}
+
+int test_instruction_set()
+{
+	int Error = 0;
+
+	std::printf("GLM_ARCH: ");
+
+	if(GLM_ARCH & GLM_ARCH_ARM_BIT)
+		std::printf("ARM ");
+	if(GLM_ARCH & GLM_ARCH_NEON_BIT)
+		std::printf("NEON ");
+	if(GLM_ARCH & GLM_ARCH_AVX2_BIT)
+		std::printf("AVX2 ");
+	if(GLM_ARCH & GLM_ARCH_AVX_BIT)
+		std::printf("AVX ");
+	if(GLM_ARCH & GLM_ARCH_SSE42_BIT)
+		std::printf("SSE4.2 ");
+	if(GLM_ARCH & GLM_ARCH_SSE41_BIT)
+		std::printf("SSE4.1 ");
+	if(GLM_ARCH & GLM_ARCH_SSSE3_BIT)
+		std::printf("SSSE3 ");
+	if(GLM_ARCH & GLM_ARCH_SSE3_BIT)
+		std::printf("SSE3 ");
+	if(GLM_ARCH & GLM_ARCH_SSE2_BIT)
+		std::printf("SSE2 ");
+
+	std::printf("\n");
+
+	return Error;
+}
+
+int test_cpp_version()
+{
+	std::printf("__cplusplus: %d\n", static_cast<int>(__cplusplus));
+	
+	return 0;
+}
+
+int test_operators()
+{
+	glm::ivec3 A(1);
+	glm::ivec3 B(1);
+	bool R = A != B;
+	bool S = A == B;
+
+	return (S && !R) ? 0 : 1;
+}
+
+int main()
+{
+	int Error = 0;
+
+#	if !defined(GLM_FORCE_PLATFORM_UNKNOWN) && !defined(GLM_FORCE_COMPILER_UNKNOWN) && !defined(GLM_FORCE_ARCH_UNKNOWN) && !defined(GLM_FORCE_CXX_UNKNOWN)
+		
+		Error += test_cpp_version();
+		Error += test_compiler();
+		Error += test_model();
+		Error += test_instruction_set();
+		Error += test_operators();
+
+#	endif
+	
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/core/core_setup_platform_unknown.cpp b/3rdparty/glm/source/test/core/core_setup_platform_unknown.cpp
new file mode 100644
index 0000000..9feaee3
--- /dev/null
+++ b/3rdparty/glm/source/test/core/core_setup_platform_unknown.cpp
@@ -0,0 +1,21 @@
+#ifndef GLM_FORCE_PLATFORM_UNKNOWN
+#	define GLM_FORCE_PLATFORM_UNKNOWN
+#endif
+#ifndef GLM_FORCE_COMPILER_UNKNOWN
+#	define GLM_FORCE_COMPILER_UNKNOWN
+#endif
+#ifndef GLM_FORCE_ARCH_UNKNOWN
+#	define GLM_FORCE_ARCH_UNKNOWN
+#endif
+#ifndef GLM_FORCE_CXX_UNKNOWN
+#	define GLM_FORCE_CXX_UNKNOWN
+#endif
+#include <glm/glm.hpp>
+#include <glm/ext.hpp>
+
+int main()
+{
+	int Error = 0;
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/core/core_setup_precision.cpp b/3rdparty/glm/source/test/core/core_setup_precision.cpp
new file mode 100644
index 0000000..b44bc50
--- /dev/null
+++ b/3rdparty/glm/source/test/core/core_setup_precision.cpp
@@ -0,0 +1,58 @@
+#define GLM_FORCE_INLINE
+#define GLM_PRECISION_HIGHP_FLOAT
+#include <glm/glm.hpp>
+#include <glm/ext.hpp>
+
+static int test_mat()
+{
+	int Error = 0;
+
+	Error += sizeof(glm::mat2) == sizeof(glm::highp_mat2) ? 0 : 1;
+	Error += sizeof(glm::mat3) == sizeof(glm::highp_mat3) ? 0 : 1;
+	Error += sizeof(glm::mat4) == sizeof(glm::highp_mat4) ? 0 : 1;
+
+	Error += sizeof(glm::mat2x2) == sizeof(glm::highp_mat2x2) ? 0 : 1;
+	Error += sizeof(glm::mat2x3) == sizeof(glm::highp_mat2x3) ? 0 : 1;
+	Error += sizeof(glm::mat2x4) == sizeof(glm::highp_mat2x4) ? 0 : 1;
+	Error += sizeof(glm::mat3x2) == sizeof(glm::highp_mat3x2) ? 0 : 1;
+	Error += sizeof(glm::mat3x3) == sizeof(glm::highp_mat3x3) ? 0 : 1;
+	Error += sizeof(glm::mat3x4) == sizeof(glm::highp_mat3x4) ? 0 : 1;
+	Error += sizeof(glm::mat4x2) == sizeof(glm::highp_mat4x2) ? 0 : 1;
+	Error += sizeof(glm::mat4x3) == sizeof(glm::highp_mat4x3) ? 0 : 1;
+	Error += sizeof(glm::mat4x4) == sizeof(glm::highp_mat4x4) ? 0 : 1;
+
+	return Error;
+}
+
+static int test_vec()
+{
+	int Error = 0;
+
+	Error += sizeof(glm::vec2) == sizeof(glm::highp_vec2) ? 0 : 1;
+	Error += sizeof(glm::vec3) == sizeof(glm::highp_vec3) ? 0 : 1;
+	Error += sizeof(glm::vec4) == sizeof(glm::highp_vec4) ? 0 : 1;
+
+	return Error;
+}
+
+static int test_dvec()
+{
+	int Error = 0;
+	
+	Error += sizeof(glm::dvec2) == sizeof(glm::highp_dvec2) ? 0 : 1;
+	Error += sizeof(glm::dvec3) == sizeof(glm::highp_dvec3) ? 0 : 1;
+	Error += sizeof(glm::dvec4) == sizeof(glm::highp_dvec4) ? 0 : 1;
+	
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_mat();
+	Error += test_vec();
+	Error += test_dvec();
+	
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/core/core_type_aligned.cpp b/3rdparty/glm/source/test/core/core_type_aligned.cpp
new file mode 100644
index 0000000..dff0939
--- /dev/null
+++ b/3rdparty/glm/source/test/core/core_type_aligned.cpp
@@ -0,0 +1,92 @@
+#define GLM_FORCE_DEFAULT_ALIGNED_GENTYPES
+#include <glm/glm.hpp>
+
+#if GLM_CONFIG_ALIGNED_GENTYPES == GLM_ENABLE
+#include <type_traits>
+
+static_assert(sizeof(glm::bvec4) > sizeof(glm::bvec2), "Invalid sizeof");
+static_assert(sizeof(glm::ivec4) > sizeof(glm::uvec2), "Invalid sizeof");
+static_assert(sizeof(glm::dvec4) > sizeof(glm::dvec2), "Invalid sizeof");
+
+static_assert(sizeof(glm::bvec4) == sizeof(glm::bvec3), "Invalid sizeof");
+static_assert(sizeof(glm::uvec4) == sizeof(glm::uvec3), "Invalid sizeof");
+static_assert(sizeof(glm::dvec4) == sizeof(glm::dvec3), "Invalid sizeof");
+
+static int test_storage_aligned()
+{
+	int Error = 0;
+
+	size_t size1_aligned = sizeof(glm::detail::storage<1, int, true>::type);
+	Error += size1_aligned == sizeof(int) * 1 ? 0 : 1;
+	size_t size2_aligned = sizeof(glm::detail::storage<2, int, true>::type);
+	Error += size2_aligned == sizeof(int) * 2 ? 0 : 1;
+	size_t size4_aligned = sizeof(glm::detail::storage<4, int, true>::type);
+	Error += size4_aligned == sizeof(int) * 4 ? 0 : 1;
+
+	size_t align1_aligned = alignof(glm::detail::storage<1, int, true>::type);
+	Error += align1_aligned == 4 ? 0 : 1;
+	size_t align2_aligned = alignof(glm::detail::storage<2, int, true>::type);
+	Error += align2_aligned == 8 ? 0 : 1;
+	size_t align4_aligned = alignof(glm::detail::storage<4, int, true>::type);
+	Error += align4_aligned == 16 ? 0 : 1;
+
+	return Error;
+}
+
+static int test_storage_unaligned()
+{
+	int Error = 0;
+
+	size_t align1_unaligned = alignof(glm::detail::storage<1, int, false>::type);
+	Error += align1_unaligned == sizeof(int) ? 0 : 1;
+	size_t align2_unaligned = alignof(glm::detail::storage<2, int, false>::type);
+	Error += align2_unaligned == sizeof(int) ? 0 : 1;
+	size_t align3_unaligned = alignof(glm::detail::storage<3, int, false>::type);
+	Error += align3_unaligned == sizeof(int) ? 0 : 1;
+	size_t align4_unaligned = alignof(glm::detail::storage<4, int, false>::type);
+	Error += align4_unaligned == sizeof(int) ? 0 : 1;
+
+	return Error;
+}
+
+static int test_vec3_aligned()
+{
+	int Error = 0;
+
+	struct Struct1
+	{
+		glm::vec4 A;
+		float B;
+		glm::vec3 C;
+	};
+
+	std::size_t const Size1 = sizeof(Struct1);
+	Error += Size1 == 48 ? 0 : 1;
+
+	struct Struct2
+	{
+		glm::vec4 A;
+		glm::vec3 B;
+		float C;
+	};
+
+	std::size_t const Size2 = sizeof(Struct2);
+	Error += Size2 == 48 ? 0 : 1;
+
+	return Error;
+}
+
+#endif
+
+int main()
+{
+	int Error = 0;
+
+#	if GLM_CONFIG_ALIGNED_GENTYPES == GLM_ENABLE
+		Error += test_storage_aligned();
+		Error += test_storage_unaligned();
+		Error += test_vec3_aligned();
+#	endif
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/core/core_type_cast.cpp b/3rdparty/glm/source/test/core/core_type_cast.cpp
new file mode 100644
index 0000000..7ff1901
--- /dev/null
+++ b/3rdparty/glm/source/test/core/core_type_cast.cpp
@@ -0,0 +1,146 @@
+#include <glm/gtc/constants.hpp>
+#include <glm/ext/vector_relational.hpp>
+#include <glm/glm.hpp>
+#include <algorithm>
+#include <vector>
+#include <iterator>
+
+struct my_vec2
+{
+	operator glm::vec2() { return glm::vec2(x, y); }
+	float x, y;
+};
+
+int test_vec2_cast()
+{
+	glm::vec2 A(1.0f, 2.0f);
+	glm::lowp_vec2 B(A);
+	glm::mediump_vec2 C(A);
+	glm::highp_vec2 D(A);
+	
+	glm::vec2 E = static_cast<glm::vec2>(A);
+	glm::lowp_vec2 F = static_cast<glm::lowp_vec2>(A);
+	glm::mediump_vec2 G = static_cast<glm::mediump_vec2>(A);
+	glm::highp_vec2 H = static_cast<glm::highp_vec2>(A);
+	
+	my_vec2 I;
+	glm::vec2 J = static_cast<glm::vec2>(I);
+	glm::vec2 K(7.8f);
+
+	int Error(0);
+	
+	Error += glm::all(glm::equal(A, E, glm::epsilon<float>())) ? 0 : 1;
+	Error += glm::all(glm::equal(B, F, glm::epsilon<float>())) ? 0 : 1;
+	Error += glm::all(glm::equal(C, G, glm::epsilon<float>())) ? 0 : 1;
+	Error += glm::all(glm::equal(D, H, glm::epsilon<float>())) ? 0 : 1;
+	
+	return Error;
+}
+
+int test_vec3_cast()
+{
+	glm::vec3 A(1.0f, 2.0f, 3.0f);
+	glm::lowp_vec3 B(A);
+	glm::mediump_vec3 C(A);
+	glm::highp_vec3 D(A);
+	
+	glm::vec3 E = static_cast<glm::vec3>(A);
+	glm::lowp_vec3 F = static_cast<glm::lowp_vec3>(A);
+	glm::mediump_vec3 G = static_cast<glm::mediump_vec3>(A);
+	glm::highp_vec3 H = static_cast<glm::highp_vec3>(A);
+	
+	int Error(0);
+	
+	Error += glm::all(glm::equal(A, E, glm::epsilon<float>())) ? 0 : 1;
+	Error += glm::all(glm::equal(B, F, glm::epsilon<float>())) ? 0 : 1;
+	Error += glm::all(glm::equal(C, G, glm::epsilon<float>())) ? 0 : 1;
+	Error += glm::all(glm::equal(D, H, glm::epsilon<float>())) ? 0 : 1;
+	
+	return Error;
+}
+
+int test_vec4_cast()
+{
+	glm::vec4 A(1.0f, 2.0f, 3.0f, 4.0f);
+	glm::lowp_vec4 B(A);
+	glm::mediump_vec4 C(A);
+	glm::highp_vec4 D(A);
+	
+	glm::vec4 E = static_cast<glm::vec4>(A);
+	glm::lowp_vec4 F = static_cast<glm::lowp_vec4>(A);
+	glm::mediump_vec4 G = static_cast<glm::mediump_vec4>(A);
+	glm::highp_vec4 H = static_cast<glm::highp_vec4>(A);
+	
+	int Error(0);
+	
+	Error += glm::all(glm::equal(A, E, glm::epsilon<float>())) ? 0 : 1;
+	Error += glm::all(glm::equal(B, F, glm::epsilon<float>())) ? 0 : 1;
+	Error += glm::all(glm::equal(C, G, glm::epsilon<float>())) ? 0 : 1;
+	Error += glm::all(glm::equal(D, H, glm::epsilon<float>())) ? 0 : 1;
+	
+	return Error;
+}
+
+int test_std_copy()
+{
+	int Error = 0;
+
+	{
+		std::vector<int> High;
+		High.resize(64);
+		std::vector<int> Medium(High.size());
+		
+		std::copy(High.begin(), High.end(), Medium.begin());
+
+		*Medium.begin() = *High.begin();
+	}
+
+	{
+		std::vector<glm::dvec4> High4;
+		High4.resize(64);
+		std::vector<glm::vec4> Medium4(High4.size());
+		
+		std::copy(High4.begin(), High4.end(), Medium4.begin());
+
+		*Medium4.begin() = *High4.begin();
+	}
+
+	{
+		std::vector<glm::dvec3> High3;
+		High3.resize(64);
+		std::vector<glm::vec3> Medium3(High3.size());
+
+		std::copy(High3.begin(), High3.end(), Medium3.begin());
+
+		*Medium3.begin() = *High3.begin();
+	}
+
+	{
+		std::vector<glm::dvec2> High2;
+		High2.resize(64);
+		std::vector<glm::vec2> Medium2(High2.size());
+
+		std::copy(High2.begin(), High2.end(), Medium2.begin());
+
+		*Medium2.begin() = *High2.begin();
+	}
+
+	glm::dvec4 v1;
+	glm::vec4 v2;
+
+	v2 = v1;
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_std_copy();
+	Error += test_vec2_cast();
+	Error += test_vec3_cast();
+	Error += test_vec4_cast();
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/core/core_type_ctor.cpp b/3rdparty/glm/source/test/core/core_type_ctor.cpp
new file mode 100644
index 0000000..078fcdf
--- /dev/null
+++ b/3rdparty/glm/source/test/core/core_type_ctor.cpp
@@ -0,0 +1,351 @@
+#include <glm/gtc/vec1.hpp>
+#include <glm/gtc/quaternion.hpp>
+#include <glm/gtc/constants.hpp>
+#include <glm/ext/vector_relational.hpp>
+#include <glm/glm.hpp>
+
+static int test_vec1_ctor()
+{
+	int Error = 0;
+
+#	if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_ENABLE
+	{
+		union pack
+		{
+			glm::vec1 f;
+			glm::ivec1 i;
+		} A, B;
+
+		A.f = glm::vec1(0);
+		Error += glm::all(glm::equal(A.i, glm::ivec1(0))) ? 0 : 1;
+
+		B.f = glm::vec1(1);
+		Error += glm::all(glm::equal(B.i, glm::ivec1(1065353216))) ? 0 : 1;
+	}
+#	endif//GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_ENABLE
+
+	return Error;
+}
+
+static int test_vec2_ctor()
+{
+	int Error = 0;
+
+#	if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_ENABLE
+	{
+		union pack
+		{
+			glm::vec2 f;
+			glm::ivec2 i;
+		} A, B;
+
+		A.f = glm::vec2(0);
+		Error += glm::all(glm::equal(A.i, glm::ivec2(0))) ? 0 : 1;
+
+		B.f = glm::vec2(1);
+		Error += glm::all(glm::equal(B.i, glm::ivec2(1065353216))) ? 0 : 1;
+	}
+#	endif
+
+	return Error;
+}
+
+static int test_vec3_ctor()
+{
+	int Error = 0;
+
+#	if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_ENABLE
+	{
+		union pack
+		{
+			glm::vec3 f;
+			glm::ivec3 i;
+		} A, B;
+
+		A.f = glm::vec3(0);
+		Error += glm::all(glm::equal(A.i, glm::ivec3(0))) ? 0 : 1;
+
+		B.f = glm::vec3(1);
+		Error += glm::all(glm::equal(B.i, glm::ivec3(1065353216))) ? 0 : 1;
+	}
+#	endif
+
+	return Error;
+}
+
+static int test_vec4_ctor()
+{
+	int Error = 0;
+
+#	if GLM_CONFIG_DEFAULTED_FUNCTIONS == GLM_ENABLE
+	{
+		union pack
+		{
+			glm::vec4 f;
+			glm::ivec4 i;
+		} A, B;
+
+		A.f = glm::vec4(0);
+		Error += glm::all(glm::equal(A.i, glm::ivec4(0))) ? 0 : 1;
+
+		B.f = glm::vec4(1);
+		Error += glm::all(glm::equal(B.i, glm::ivec4(1065353216))) ? 0 : 1;
+	}
+#	endif
+
+	return Error;
+}
+
+static int test_mat2x2_ctor()
+{
+	int Error = 0;
+
+#	if GLM_LANG & GLM_LANG_CXX11_FLAG
+	{
+		union pack
+		{
+			glm::mat2x2 f;
+			glm::mat2x2 i;
+		} A, B;
+
+		A.f = glm::mat2x2(0);
+		Error += glm::all(glm::equal(A.i[0], glm::vec2(0), glm::epsilon<float>())) ? 0 : 1;
+
+		B.f = glm::mat2x2(1);
+		Error += glm::all(glm::equal(B.i[0], glm::vec2(1, 0), glm::epsilon<float>())) ? 0 : 1;
+	}
+#	endif//GLM_LANG & GLM_LANG_CXX11_FLAG
+
+	return Error;
+}
+
+static int test_mat2x3_ctor()
+{
+	int Error = 0;
+
+#	if GLM_LANG & GLM_LANG_CXX11_FLAG
+	{
+		union pack
+		{
+			glm::mat2x3 f;
+			glm::mat2x3 i;
+		} A, B;
+
+		A.f = glm::mat2x3(0);
+		Error += glm::all(glm::equal(A.i[0], glm::vec3(0), glm::epsilon<float>())) ? 0 : 1;
+
+		B.f = glm::mat2x3(1);
+		Error += glm::all(glm::equal(B.i[0], glm::vec3(1, 0, 0), glm::epsilon<float>())) ? 0 : 1;
+	}
+#	endif//GLM_LANG & GLM_LANG_CXX11_FLAG
+
+	return Error;
+}
+
+static int test_mat2x4_ctor()
+{
+	int Error = 0;
+
+#	if GLM_LANG & GLM_LANG_CXX11_FLAG
+	{
+		union pack
+		{
+			glm::mat2x4 f;
+			glm::mat2x4 i;
+		} A, B;
+
+		A.f = glm::mat2x4(0);
+		glm::vec4 const C(0, 0, 0, 0);
+		Error += glm::all(glm::equal(A.i[0], C, glm::epsilon<float>())) ? 0 : 1;
+
+		B.f = glm::mat2x4(1);
+		glm::vec4 const D(1, 0, 0, 0);
+		Error += glm::all(glm::equal(B.i[0], D, glm::epsilon<float>())) ? 0 : 1;
+	}
+#	endif//GLM_LANG & GLM_LANG_CXX11_FLAG
+
+	return Error;
+}
+
+static int test_mat3x2_ctor()
+{
+	int Error = 0;
+
+#	if GLM_LANG & GLM_LANG_CXX11_FLAG
+	{
+		union pack
+		{
+			glm::mat3x2 f;
+			glm::mat3x2 i;
+		} A, B;
+
+		A.f = glm::mat3x2(0);
+		Error += glm::all(glm::equal(A.i[0], glm::vec2(0), glm::epsilon<float>())) ? 0 : 1;
+
+		B.f = glm::mat3x2(1);
+		Error += glm::all(glm::equal(B.i[0], glm::vec2(1, 0), glm::epsilon<float>())) ? 0 : 1;
+	}
+#	endif//GLM_LANG & GLM_LANG_CXX11_FLAG
+
+	return Error;
+}
+
+static int test_mat3x3_ctor()
+{
+	int Error = 0;
+
+#	if GLM_LANG & GLM_LANG_CXX11_FLAG
+	{
+		union pack
+		{
+			glm::mat3x3 f;
+			glm::mat3x3 i;
+		} A, B;
+
+		A.f = glm::mat3x3(0);
+		Error += glm::all(glm::equal(A.i[0], glm::vec3(0), glm::epsilon<float>())) ? 0 : 1;
+
+		B.f = glm::mat3x3(1);
+		Error += glm::all(glm::equal(B.i[0], glm::vec3(1, 0, 0), glm::epsilon<float>())) ? 0 : 1;
+	}
+#	endif//GLM_LANG & GLM_LANG_CXX11_FLAG
+
+	return Error;
+}
+
+static int test_mat3x4_ctor()
+{
+	int Error = 0;
+
+#	if GLM_LANG & GLM_LANG_CXX11_FLAG
+	{
+		union pack
+		{
+			glm::mat3x4 f;
+			glm::mat3x4 i;
+		} A, B;
+
+		A.f = glm::mat3x4(0);
+		Error += glm::all(glm::equal(A.i[0], glm::vec4(0), glm::epsilon<float>())) ? 0 : 1;
+
+		B.f = glm::mat3x4(1);
+		Error += glm::all(glm::equal(B.i[0], glm::vec4(1, 0, 0, 0), glm::epsilon<float>())) ? 0 : 1;
+	}
+#	endif//GLM_LANG & GLM_LANG_CXX11_FLAG
+
+	return Error;
+}
+
+static int test_mat4x2_ctor()
+{
+	int Error = 0;
+
+#	if GLM_LANG & GLM_LANG_CXX11_FLAG
+	{
+		union pack
+		{
+			glm::mat4x2 f;
+			glm::mat4x2 i;
+		} A, B;
+
+		A.f = glm::mat4x2(0);
+		Error += glm::all(glm::equal(A.i[0], glm::vec2(0), glm::epsilon<float>())) ? 0 : 1;
+
+		B.f = glm::mat4x2(1);
+		Error += glm::all(glm::equal(B.i[0], glm::vec2(1, 0), glm::epsilon<float>())) ? 0 : 1;
+	}
+#	endif//GLM_LANG & GLM_LANG_CXX11_FLAG
+
+	return Error;
+}
+
+static int test_mat4x3_ctor()
+{
+	int Error = 0;
+
+#	if GLM_LANG & GLM_LANG_CXX11_FLAG
+	{
+		union pack
+		{
+			glm::mat4x3 f;
+			glm::mat4x3 i;
+		} A, B;
+
+		A.f = glm::mat4x3(0);
+		Error += glm::all(glm::equal(A.i[0], glm::vec3(0), glm::epsilon<float>())) ? 0 : 1;
+
+		B.f = glm::mat4x3(1);
+		Error += glm::all(glm::equal(B.i[0], glm::vec3(1, 0, 0), glm::epsilon<float>())) ? 0 : 1;
+	}
+#	endif//GLM_LANG & GLM_LANG_CXX11_FLAG
+
+	return Error;
+}
+
+static int test_mat4x4_ctor()
+{
+	int Error = 0;
+
+#	if GLM_LANG & GLM_LANG_CXX11_FLAG
+	{
+		union pack
+		{
+			glm::mat4 f;
+			glm::mat4 i;
+		} A, B;
+
+		A.f = glm::mat4(0);
+		Error += glm::all(glm::equal(A.i[0], glm::vec4(0), glm::epsilon<float>())) ? 0 : 1;
+
+		B.f = glm::mat4(1);
+		Error += glm::all(glm::equal(B.i[0], glm::vec4(1, 0, 0, 0), glm::epsilon<float>())) ? 0 : 1;
+	}
+#	endif//GLM_LANG & GLM_LANG_CXX11_FLAG
+
+	return Error;
+}
+
+static int test_quat_ctor()
+{
+	int Error = 0;
+
+#	if GLM_LANG & GLM_LANG_CXX11_FLAG
+	{
+		union pack
+		{
+			glm::quat f;
+			glm::quat i;
+		} A, B;
+
+		A.f = glm::quat(0, 0, 0, 0);
+		Error += glm::all(glm::equal(A.i, glm::quat(0, 0, 0, 0), glm::epsilon<float>())) ? 0 : 1;
+
+		B.f = glm::quat(1, 1, 1, 1);
+		Error += glm::all(glm::equal(B.i, glm::quat(1, 1, 1, 1), glm::epsilon<float>())) ? 0 : 1;
+	}
+#	endif//GLM_LANG & GLM_LANG_CXX11_FLAG
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_vec1_ctor();
+	Error += test_vec2_ctor();
+	Error += test_vec3_ctor();
+	Error += test_vec4_ctor();
+	Error += test_mat2x2_ctor();
+	Error += test_mat2x3_ctor();
+	Error += test_mat2x4_ctor();
+	Error += test_mat3x2_ctor();
+	Error += test_mat3x3_ctor();
+	Error += test_mat3x4_ctor();
+	Error += test_mat4x2_ctor();
+	Error += test_mat4x3_ctor();
+	Error += test_mat4x4_ctor();
+	Error += test_quat_ctor();
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/core/core_type_int.cpp b/3rdparty/glm/source/test/core/core_type_int.cpp
new file mode 100644
index 0000000..2631509
--- /dev/null
+++ b/3rdparty/glm/source/test/core/core_type_int.cpp
@@ -0,0 +1,26 @@
+#include <glm/glm.hpp>
+#include <glm/ext/scalar_int_sized.hpp>
+
+static int test_bit_operator()
+{
+	int Error = 0;
+
+	glm::ivec4 const a(1);
+	glm::ivec4 const b = ~a;
+	Error += glm::all(glm::equal(b, glm::ivec4(-2))) ? 0 : 1;
+
+	glm::int32 const c(1);
+	glm::int32 const d = ~c;
+	Error += d == -2 ? 0 : 1;
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_bit_operator();
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/core/core_type_length.cpp b/3rdparty/glm/source/test/core/core_type_length.cpp
new file mode 100644
index 0000000..f088cb3
--- /dev/null
+++ b/3rdparty/glm/source/test/core/core_type_length.cpp
@@ -0,0 +1,78 @@
+#include <glm/glm.hpp>
+
+static int test_length_mat_non_squared()
+{
+	int Error = 0;
+
+	Error += glm::mat2x3().length() == 2 ? 0 : 1;
+	Error += glm::mat2x4().length() == 2 ? 0 : 1;
+	Error += glm::mat3x2().length() == 3 ? 0 : 1;
+	Error += glm::mat3x4().length() == 3 ? 0 : 1;
+	Error += glm::mat4x2().length() == 4 ? 0 : 1;
+	Error += glm::mat4x3().length() == 4 ? 0 : 1;
+	
+	Error += glm::dmat2x3().length() == 2 ? 0 : 1;
+	Error += glm::dmat2x4().length() == 2 ? 0 : 1;
+	Error += glm::dmat3x2().length() == 3 ? 0 : 1;
+	Error += glm::dmat3x4().length() == 3 ? 0 : 1;
+	Error += glm::dmat4x2().length() == 4 ? 0 : 1;
+	Error += glm::dmat4x3().length() == 4 ? 0 : 1;
+	
+	return Error;
+}
+
+static int test_length_mat()
+{
+	int Error = 0;
+	
+	Error += glm::mat2().length() == 2 ? 0 : 1;
+	Error += glm::mat3().length() == 3 ? 0 : 1;
+	Error += glm::mat4().length() == 4 ? 0 : 1;
+	Error += glm::mat2x2().length() == 2 ? 0 : 1;
+	Error += glm::mat3x3().length() == 3 ? 0 : 1;
+	Error += glm::mat4x4().length() == 4 ? 0 : 1;
+	
+	Error += glm::dmat2().length() == 2 ? 0 : 1;
+	Error += glm::dmat3().length() == 3 ? 0 : 1;
+	Error += glm::dmat4().length() == 4 ? 0 : 1;
+	Error += glm::dmat2x2().length() == 2 ? 0 : 1;
+	Error += glm::dmat3x3().length() == 3 ? 0 : 1;
+	Error += glm::dmat4x4().length() == 4 ? 0 : 1;
+	
+	return Error;
+}
+
+static int test_length_vec()
+{
+	int Error = 0;
+	
+	Error += glm::vec2().length() == 2 ? 0 : 1;
+	Error += glm::vec3().length() == 3 ? 0 : 1;
+	Error += glm::vec4().length() == 4 ? 0 : 1;
+
+	Error += glm::ivec2().length() == 2 ? 0 : 1;
+	Error += glm::ivec3().length() == 3 ? 0 : 1;
+	Error += glm::ivec4().length() == 4 ? 0 : 1;
+
+	Error += glm::uvec2().length() == 2 ? 0 : 1;
+	Error += glm::uvec3().length() == 3 ? 0 : 1;
+	Error += glm::uvec4().length() == 4 ? 0 : 1;	
+	
+	Error += glm::dvec2().length() == 2 ? 0 : 1;
+	Error += glm::dvec3().length() == 3 ? 0 : 1;
+	Error += glm::dvec4().length() == 4 ? 0 : 1;
+	
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+	
+	Error += test_length_vec();
+	Error += test_length_mat();
+	Error += test_length_mat_non_squared();
+	
+	return Error;
+}
+
diff --git a/3rdparty/glm/source/test/core/core_type_mat2x2.cpp b/3rdparty/glm/source/test/core/core_type_mat2x2.cpp
new file mode 100644
index 0000000..2f8b018
--- /dev/null
+++ b/3rdparty/glm/source/test/core/core_type_mat2x2.cpp
@@ -0,0 +1,177 @@
+#include <glm/ext/matrix_relational.hpp>
+#include <glm/ext/vector_relational.hpp>
+#include <glm/ext/scalar_relational.hpp>
+#include <glm/gtc/constants.hpp>
+#include <glm/matrix.hpp>
+#include <glm/vector_relational.hpp>
+#include <glm/mat2x2.hpp>
+#include <glm/mat2x3.hpp>
+#include <glm/mat2x4.hpp>
+#include <glm/mat3x2.hpp>
+#include <glm/mat3x3.hpp>
+#include <glm/mat3x4.hpp>
+#include <glm/mat4x2.hpp>
+#include <glm/mat4x3.hpp>
+#include <glm/mat4x4.hpp>
+#include <vector>
+
+int test_operators()
+{
+	glm::mat2x2 l(1.0f);
+	glm::mat2x2 m(1.0f);
+	glm::vec2 u(1.0f);
+	glm::vec2 v(1.0f);
+	float x = 1.0f;
+	glm::vec2 a = m * u;
+	glm::vec2 b = v * m;
+	glm::mat2x2 n = x / m;
+	glm::mat2x2 o = m / x;
+	glm::mat2x2 p = x * m;
+	glm::mat2x2 q = m * x;
+	bool R = glm::any(glm::notEqual(m, q, glm::epsilon<float>()));
+	bool S = glm::all(glm::equal(m, l, glm::epsilon<float>()));
+
+	return (S && !R) ? 0 : 1;
+}
+
+int test_inverse()
+{
+	int Error(0);
+
+	{
+		glm::mat2 const Matrix(1, 2, 3, 4);
+		glm::mat2 const Inverse = glm::inverse(Matrix);
+		glm::mat2 const Identity = Matrix * Inverse;
+
+		Error += glm::all(glm::equal(Identity[0], glm::vec2(1.0f, 0.0f), glm::vec2(0.01f))) ? 0 : 1;
+		Error += glm::all(glm::equal(Identity[1], glm::vec2(0.0f, 1.0f), glm::vec2(0.01f))) ? 0 : 1;
+	}
+
+	{
+		glm::mat2 const Matrix(1, 2, 3, 4);
+		glm::mat2 const Identity = Matrix / Matrix;
+
+		Error += glm::all(glm::equal(Identity[0], glm::vec2(1.0f, 0.0f), glm::vec2(0.01f))) ? 0 : 1;
+		Error += glm::all(glm::equal(Identity[1], glm::vec2(0.0f, 1.0f), glm::vec2(0.01f))) ? 0 : 1;
+	}
+
+	return Error;
+}
+
+int test_ctr()
+{
+	int Error = 0;
+	
+	{
+		glm::mediump_mat2x2 const A(1.0f);
+		glm::highp_mat2x2 const B(A);
+		glm::mediump_mat2x2 const C(B);
+
+		Error += glm::all(glm::equal(A, C, glm::epsilon<float>())) ? 0 : 1;
+	}
+
+#if GLM_HAS_INITIALIZER_LISTS
+	glm::mat2x2 m0(
+		glm::vec2(0, 1),
+		glm::vec2(2, 3));
+
+	glm::mat2x2 m1{0, 1, 2, 3};
+
+	glm::mat2x2 m2{
+		{0, 1},
+		{2, 3}};
+
+	Error += glm::all(glm::equal(m0, m2, glm::epsilon<float>())) ? 0 : 1;
+	Error += glm::all(glm::equal(m1, m2, glm::epsilon<float>())) ? 0 : 1;
+
+	std::vector<glm::mat2x2> v1{
+		{0, 1, 2, 3},
+		{0, 1, 2, 3}
+	};
+
+	std::vector<glm::mat2x2> v2{
+		{
+			{ 0, 1},
+			{ 4, 5}
+		},
+		{
+			{ 0, 1},
+			{ 4, 5}
+		}
+	};
+
+#endif//GLM_HAS_INITIALIZER_LISTS
+
+	return Error;
+}
+
+namespace cast
+{
+	template<typename genType>
+	int entry()
+	{
+		int Error = 0;
+
+		genType A(1.0f);
+		glm::mat2 B(A);
+		glm::mat2 Identity(1.0f);
+
+		Error += glm::all(glm::equal(B, Identity, glm::epsilon<float>())) ? 0 : 1;
+
+		return Error;
+	}
+
+	int test()
+	{
+		int Error = 0;
+		
+		Error += entry<glm::mat2x2>();
+		Error += entry<glm::mat2x3>();
+		Error += entry<glm::mat2x4>();
+		Error += entry<glm::mat3x2>();
+		Error += entry<glm::mat3x3>();
+		Error += entry<glm::mat3x4>();
+		Error += entry<glm::mat4x2>();
+		Error += entry<glm::mat4x3>();
+		Error += entry<glm::mat4x4>();
+
+		return Error;
+	}
+}//namespace cast
+
+int test_size()
+{
+	int Error = 0;
+
+	Error += 16 == sizeof(glm::mat2x2) ? 0 : 1;
+	Error += 32 == sizeof(glm::dmat2x2) ? 0 : 1;
+	Error += glm::mat2x2().length() == 2 ? 0 : 1;
+	Error += glm::dmat2x2().length() == 2 ? 0 : 1;
+	Error += glm::mat2x2::length() == 2 ? 0 : 1;
+	Error += glm::dmat2x2::length() == 2 ? 0 : 1;
+
+	return Error;
+}
+
+int test_constexpr()
+{
+#if GLM_HAS_CONSTEXPR
+	static_assert(glm::mat2x2::length() == 2, "GLM: Failed constexpr");
+#endif
+
+	return 0;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += cast::test();
+	Error += test_ctr();
+	Error += test_operators();
+	Error += test_inverse();
+	Error += test_size();
+	Error += test_constexpr();
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/core/core_type_mat2x3.cpp b/3rdparty/glm/source/test/core/core_type_mat2x3.cpp
new file mode 100644
index 0000000..e3ad76b
--- /dev/null
+++ b/3rdparty/glm/source/test/core/core_type_mat2x3.cpp
@@ -0,0 +1,142 @@
+#include <glm/ext/scalar_relational.hpp>
+#include <glm/ext/vector_relational.hpp>
+#include <glm/ext/matrix_relational.hpp>
+#include <glm/gtc/constants.hpp>
+#include <glm/mat2x2.hpp>
+#include <glm/mat2x3.hpp>
+#include <glm/mat2x4.hpp>
+#include <glm/mat3x2.hpp>
+#include <glm/mat3x3.hpp>
+#include <glm/mat3x4.hpp>
+#include <glm/mat4x2.hpp>
+#include <glm/mat4x3.hpp>
+#include <glm/mat4x4.hpp>
+#include <vector>
+
+static int test_operators()
+{
+	glm::mat2x3 l(1.0f);
+	glm::mat2x3 m(1.0f);
+	glm::vec2 u(1.0f);
+	glm::vec3 v(1.0f);
+	float x = 1.0f;
+	glm::vec3 a = m * u;
+	glm::vec2 b = v * m;
+	glm::mat2x3 n = x / m;
+	glm::mat2x3 o = m / x;
+	glm::mat2x3 p = x * m;
+	glm::mat2x3 q = m * x;
+	bool R = glm::any(glm::notEqual(m, q, glm::epsilon<float>()));
+	bool S = glm::all(glm::equal(m, l, glm::epsilon<float>()));
+
+	return (S && !R) ? 0 : 1;
+}
+
+int test_ctr()
+{
+	int Error(0);
+
+#if GLM_HAS_INITIALIZER_LISTS
+	glm::mat2x3 m0(
+		glm::vec3(0, 1, 2),
+		glm::vec3(3, 4, 5));
+	
+	glm::mat2x3 m1{0, 1, 2, 3, 4, 5};
+	
+	glm::mat2x3 m2{
+		{0, 1, 2},
+		{3, 4, 5}};
+	
+	Error += glm::all(glm::equal(m0, m2, glm::epsilon<float>())) ? 0 : 1;
+	Error += glm::all(glm::equal(m1, m2, glm::epsilon<float>())) ? 0 : 1;
+	
+	std::vector<glm::mat2x3> v1{
+		{0, 1, 2, 3, 4, 5},
+		{0, 1, 2, 3, 4, 5}
+	};
+	
+	std::vector<glm::mat2x3> v2{
+		{
+			{ 0, 1, 2},
+			{ 4, 5, 6}
+		},
+		{
+			{ 0, 1, 2},
+			{ 4, 5, 6}
+		}
+	};
+	
+#endif//GLM_HAS_INITIALIZER_LISTS
+	
+	return Error;
+}
+
+namespace cast
+{
+	template<typename genType>
+	int entry()
+	{
+		int Error = 0;
+
+		genType A(1.0f);
+		glm::mat2x3 B(A);
+		glm::mat2x3 Identity(1.0f);
+
+		Error += glm::all(glm::equal(B, Identity, glm::epsilon<float>())) ? 0 : 1;
+
+		return Error;
+	}
+
+	int test()
+	{
+		int Error = 0;
+		
+		Error += entry<glm::mat2x2>();
+		Error += entry<glm::mat2x3>();
+		Error += entry<glm::mat2x4>();
+		Error += entry<glm::mat3x2>();
+		Error += entry<glm::mat3x3>();
+		Error += entry<glm::mat3x4>();
+		Error += entry<glm::mat4x2>();
+		Error += entry<glm::mat4x3>();
+		Error += entry<glm::mat4x4>();
+
+		return Error;
+	}
+}//namespace cast
+
+int test_size()
+{
+	int Error = 0;
+
+	Error += 24 == sizeof(glm::mat2x3) ? 0 : 1;
+	Error += 48 == sizeof(glm::dmat2x3) ? 0 : 1;
+	Error += glm::mat2x3().length() == 2 ? 0 : 1;
+	Error += glm::dmat2x3().length() == 2 ? 0 : 1;
+	Error += glm::mat2x3::length() == 2 ? 0 : 1;
+	Error += glm::dmat2x3::length() == 2 ? 0 : 1;
+
+	return Error;
+}
+
+int test_constexpr()
+{
+#if GLM_HAS_CONSTEXPR
+	static_assert(glm::mat2x3::length() == 2, "GLM: Failed constexpr");
+#endif
+
+	return 0;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += cast::test();
+	Error += test_ctr();
+	Error += test_operators();
+	Error += test_size();
+	Error += test_constexpr();
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/core/core_type_mat2x4.cpp b/3rdparty/glm/source/test/core/core_type_mat2x4.cpp
new file mode 100644
index 0000000..ade3a44
--- /dev/null
+++ b/3rdparty/glm/source/test/core/core_type_mat2x4.cpp
@@ -0,0 +1,147 @@
+#include <glm/gtc/epsilon.hpp>
+#include <glm/gtc/constants.hpp>
+#include <glm/ext/scalar_relational.hpp>
+#include <glm/ext/vector_relational.hpp>
+#include <glm/ext/matrix_relational.hpp>
+#include <glm/mat2x2.hpp>
+#include <glm/mat2x3.hpp>
+#include <glm/mat2x4.hpp>
+#include <glm/mat3x2.hpp>
+#include <glm/mat3x3.hpp>
+#include <glm/mat3x4.hpp>
+#include <glm/mat4x2.hpp>
+#include <glm/mat4x3.hpp>
+#include <glm/mat4x4.hpp>
+#include <vector>
+
+static int test_operators()
+{
+	glm::mat2x4 l(1.0f);
+	glm::mat2x4 m(1.0f);
+	glm::vec2 u(1.0f);
+	glm::vec4 v(1.0f);
+	float x = 1.0f;
+	glm::vec4 a = m * u;
+	glm::vec2 b = v * m;
+	glm::mat2x4 n = x / m;
+	glm::mat2x4 o = m / x;
+	glm::mat2x4 p = x * m;
+	glm::mat2x4 q = m * x;
+	bool R = glm::any(glm::notEqual(m, q, glm::epsilon<float>()));
+	bool S = glm::all(glm::equal(m, l, glm::epsilon<float>()));
+
+	return (S && !R) ? 0 : 1;
+}
+
+int test_ctr()
+{
+	int Error(0);
+
+#if(GLM_HAS_INITIALIZER_LISTS)
+	glm::mat2x4 m0(
+		glm::vec4(0, 1, 2, 3),
+		glm::vec4(4, 5, 6, 7));
+
+	glm::mat2x4 m1{0, 1, 2, 3, 4, 5, 6, 7};
+
+	glm::mat2x4 m2{
+		{0, 1, 2, 3},
+		{4, 5, 6, 7}};
+
+	Error += glm::all(glm::equal(m0, m2, glm::epsilon<float>())) ? 0 : 1;
+	Error += glm::all(glm::equal(m1, m2, glm::epsilon<float>())) ? 0 : 1;
+
+	std::vector<glm::mat2x4> v1{
+		{0, 1, 2, 3, 4, 5, 6, 7},
+		{0, 1, 2, 3, 4, 5, 6, 7}
+	};
+	
+	std::vector<glm::mat2x4> v2{
+		{
+			{ 0, 1, 2, 3},
+			{ 4, 5, 6, 7}
+		},
+		{
+			{ 0, 1, 2, 3},
+			{ 4, 5, 6, 7}
+		}
+	};
+	
+#endif//GLM_HAS_INITIALIZER_LISTS
+
+	return Error;
+}
+
+namespace cast
+{
+	template<typename genType>
+	int entry()
+	{
+		int Error = 0;
+
+		genType A(1.0f);
+		glm::mat2x4 B(A);
+		glm::mat2x4 Identity(1.0f);
+
+		for(glm::length_t i = 0, length = B.length(); i < length; ++i)
+			Error += glm::all(glm::epsilonEqual(B[i], Identity[i], glm::epsilon<float>())) ? 0 : 1;
+
+		return Error;
+	}
+
+	int test()
+	{
+		int Error = 0;
+		
+		Error += entry<glm::mat2x2>();
+		Error += entry<glm::mat2x3>();
+		Error += entry<glm::mat2x4>();
+		Error += entry<glm::mat3x2>();
+		Error += entry<glm::mat3x3>();
+		Error += entry<glm::mat3x4>();
+		Error += entry<glm::mat4x2>();
+		Error += entry<glm::mat4x3>();
+		Error += entry<glm::mat4x4>();
+
+		return Error;
+	}
+}//namespace cast
+
+static int test_size()
+{
+	int Error = 0;
+
+	Error += 32 == sizeof(glm::mat2x4) ? 0 : 1;
+	Error += 64 == sizeof(glm::dmat2x4) ? 0 : 1;
+	Error += glm::mat2x4().length() == 2 ? 0 : 1;
+	Error += glm::dmat2x4().length() == 2 ? 0 : 1;
+	Error += glm::mat2x4::length() == 2 ? 0 : 1;
+	Error += glm::dmat2x4::length() == 2 ? 0 : 1;
+
+	return Error;
+}
+
+static int test_constexpr()
+{
+#if GLM_HAS_CONSTEXPR
+	static_assert(glm::mat2x4::length() == 2, "GLM: Failed constexpr");
+#endif
+
+	return 0;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += cast::test();
+	Error += test_ctr();
+	Error += test_operators();
+	Error += test_size();
+	Error += test_constexpr();
+
+	return Error;
+}
+
+
+
diff --git a/3rdparty/glm/source/test/core/core_type_mat3x2.cpp b/3rdparty/glm/source/test/core/core_type_mat3x2.cpp
new file mode 100644
index 0000000..7a40f90
--- /dev/null
+++ b/3rdparty/glm/source/test/core/core_type_mat3x2.cpp
@@ -0,0 +1,148 @@
+#include <glm/gtc/constants.hpp>
+#include <glm/ext/scalar_relational.hpp>
+#include <glm/ext/vector_relational.hpp>
+#include <glm/ext/matrix_relational.hpp>
+#include <glm/mat2x2.hpp>
+#include <glm/mat2x3.hpp>
+#include <glm/mat2x4.hpp>
+#include <glm/mat3x2.hpp>
+#include <glm/mat3x3.hpp>
+#include <glm/mat3x4.hpp>
+#include <glm/mat4x2.hpp>
+#include <glm/mat4x3.hpp>
+#include <glm/mat4x4.hpp>
+#include <vector>
+
+static bool test_operators()
+{
+	glm::mat3x2 l(1.0f);
+	glm::mat3x2 m(1.0f);
+	glm::vec3 u(1.0f);
+	glm::vec2 v(1.0f);
+	float x = 1.0f;
+	glm::vec2 a = m * u;
+	glm::vec3 b = v * m;
+	glm::mat3x2 n = x / m;
+	glm::mat3x2 o = m / x;
+	glm::mat3x2 p = x * m;
+	glm::mat3x2 q = m * x;
+	bool R = glm::any(glm::notEqual(m, q, glm::epsilon<float>()));
+	bool S = glm::all(glm::equal(m, l, glm::epsilon<float>()));
+
+	return (S && !R) ? 0 : 1;
+}
+
+int test_ctr()
+{
+	int Error(0);
+
+#if(GLM_HAS_INITIALIZER_LISTS)
+	glm::mat3x2 m0(
+		glm::vec2(0, 1),
+		glm::vec2(2, 3),
+		glm::vec2(4, 5));
+	
+	glm::mat3x2 m1{0, 1, 2, 3, 4, 5};
+	
+	glm::mat3x2 m2{
+		{0, 1},
+		{2, 3},
+		{4, 5}};
+
+	Error += glm::all(glm::equal(m0, m2, glm::epsilon<float>())) ? 0 : 1;
+	Error += glm::all(glm::equal(m1, m2, glm::epsilon<float>())) ? 0 : 1;
+
+	std::vector<glm::mat3x2> v1{
+		{0, 1, 2, 3, 4, 5},
+		{0, 1, 2, 3, 4, 5}
+	};
+	
+	std::vector<glm::mat3x2> v2{
+		{
+			{ 0, 1},
+			{ 2, 3},
+			{ 4, 5}
+		},
+		{
+			{ 0, 1},
+			{ 2, 3},
+			{ 4, 5}
+		}
+	};
+	
+#endif//GLM_HAS_INITIALIZER_LISTS
+	
+	return Error;
+}
+
+namespace cast
+{
+	template<typename genType>
+	int entry()
+	{
+		int Error = 0;
+
+		genType A(1.0f);
+		glm::mat3x2 B(A);
+		glm::mat3x2 Identity(1.0f);
+
+		Error += glm::all(glm::equal(B, Identity, glm::epsilon<float>())) ? 0 : 1;
+
+		return Error;
+	}
+
+	int test()
+	{
+		int Error = 0;
+		
+		Error += entry<glm::mat2x2>();
+		Error += entry<glm::mat2x3>();
+		Error += entry<glm::mat2x4>();
+		Error += entry<glm::mat3x2>();
+		Error += entry<glm::mat3x3>();
+		Error += entry<glm::mat3x4>();
+		Error += entry<glm::mat4x2>();
+		Error += entry<glm::mat4x3>();
+		Error += entry<glm::mat4x4>();
+
+		return Error;
+	}
+}//namespace cast
+
+static int test_size()
+{
+	int Error = 0;
+
+	Error += 24 == sizeof(glm::mat3x2) ? 0 : 1;
+	Error += 48 == sizeof(glm::dmat3x2) ? 0 : 1;
+	Error += glm::mat3x2().length() == 3 ? 0 : 1;
+	Error += glm::dmat3x2().length() == 3 ? 0 : 1;
+	Error += glm::mat3x2::length() == 3 ? 0 : 1;
+	Error += glm::dmat3x2::length() == 3 ? 0 : 1;
+
+	return Error;
+}
+
+static int test_constexpr()
+{
+#if GLM_HAS_CONSTEXPR
+	static_assert(glm::mat3x2::length() == 3, "GLM: Failed constexpr");
+#endif
+
+	return 0;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += cast::test();
+	Error += test_ctr();
+	Error += test_operators();
+	Error += test_size();
+	Error += test_constexpr();
+
+	return Error;
+}
+
+
diff --git a/3rdparty/glm/source/test/core/core_type_mat3x3.cpp b/3rdparty/glm/source/test/core/core_type_mat3x3.cpp
new file mode 100644
index 0000000..99e1f41
--- /dev/null
+++ b/3rdparty/glm/source/test/core/core_type_mat3x3.cpp
@@ -0,0 +1,197 @@
+#include <glm/gtc/constants.hpp>
+#include <glm/ext/scalar_relational.hpp>
+#include <glm/ext/vector_relational.hpp>
+#include <glm/ext/matrix_relational.hpp>
+#include <glm/matrix.hpp>
+#include <glm/vector_relational.hpp>
+#include <glm/mat2x2.hpp>
+#include <glm/mat2x3.hpp>
+#include <glm/mat2x4.hpp>
+#include <glm/mat3x2.hpp>
+#include <glm/mat3x3.hpp>
+#include <glm/mat3x4.hpp>
+#include <glm/mat4x2.hpp>
+#include <glm/mat4x3.hpp>
+#include <glm/mat4x4.hpp>
+#include <vector>
+
+static int test_mat3x3()
+{
+	glm::dmat3 Mat0(
+		glm::dvec3(0.6f, 0.2f, 0.3f),
+		glm::dvec3(0.2f, 0.7f, 0.5f),
+		glm::dvec3(0.3f, 0.5f, 0.7f));
+	glm::dmat3 Inv0 = glm::inverse(Mat0);
+	glm::dmat3 Res0 = Mat0 * Inv0;
+
+	return glm::all(glm::equal(Res0, glm::dmat3(1.0), 0.01)) ? 0 : 1;
+}
+
+static int test_operators()
+{
+	glm::mat3x3 l(1.0f);
+	glm::mat3x3 m(1.0f);
+	glm::vec3 u(1.0f);
+	glm::vec3 v(1.0f);
+	float x = 1.0f;
+	glm::vec3 a = m * u;
+	glm::vec3 b = v * m;
+	glm::mat3x3 n = x / m;
+	glm::mat3x3 o = m / x;
+	glm::mat3x3 p = x * m;
+	glm::mat3x3 q = m * x;
+	bool R = glm::any(glm::notEqual(m, q, glm::epsilon<float>()));
+	bool S = glm::all(glm::equal(m, l, glm::epsilon<float>()));
+
+	return (S && !R) ? 0 : 1;
+}
+
+static int test_inverse()
+{
+	int Error(0);
+
+	{
+		glm::mat3 const Matrix(
+			glm::vec3(0.6f, 0.2f, 0.3f), 
+			glm::vec3(0.2f, 0.7f, 0.5f), 
+			glm::vec3(0.3f, 0.5f, 0.7f));
+		glm::mat3 const Inverse = glm::inverse(Matrix);
+		glm::mat3 const Identity = Matrix * Inverse;
+
+		Error += glm::all(glm::equal(Identity[0], glm::vec3(1.0f, 0.0f, 0.0f), glm::vec3(0.01f))) ? 0 : 1;
+		Error += glm::all(glm::equal(Identity[1], glm::vec3(0.0f, 1.0f, 0.0f), glm::vec3(0.01f))) ? 0 : 1;
+		Error += glm::all(glm::equal(Identity[2], glm::vec3(0.0f, 0.0f, 1.0f), glm::vec3(0.01f))) ? 0 : 1;
+	}
+
+	{
+		glm::mat3 const Matrix(
+			glm::vec3(0.6f, 0.2f, 0.3f), 
+			glm::vec3(0.2f, 0.7f, 0.5f), 
+			glm::vec3(0.3f, 0.5f, 0.7f));
+		glm::mat3 const Identity = Matrix / Matrix;
+
+		Error += glm::all(glm::equal(Identity[0], glm::vec3(1.0f, 0.0f, 0.0f), glm::vec3(0.01f))) ? 0 : 1;
+		Error += glm::all(glm::equal(Identity[1], glm::vec3(0.0f, 1.0f, 0.0f), glm::vec3(0.01f))) ? 0 : 1;
+		Error += glm::all(glm::equal(Identity[2], glm::vec3(0.0f, 0.0f, 1.0f), glm::vec3(0.01f))) ? 0 : 1;
+	}
+
+	return Error;
+}
+
+static int test_ctr()
+{
+	int Error(0);
+
+#if(GLM_HAS_INITIALIZER_LISTS)
+	glm::mat3x3 m0(
+		glm::vec3(0, 1, 2),
+		glm::vec3(3, 4, 5),
+		glm::vec3(6, 7, 8));
+	
+	glm::mat3x3 m1{0, 1, 2, 3, 4, 5, 6, 7, 8};
+	
+	glm::mat3x3 m2{
+		{0, 1, 2},
+		{3, 4, 5},
+		{6, 7, 8}};
+
+	Error += glm::all(glm::equal(m0, m2, glm::epsilon<float>())) ? 0 : 1;
+	Error += glm::all(glm::equal(m1, m2, glm::epsilon<float>())) ? 0 : 1;
+
+	std::vector<glm::mat3x3> v1{
+		{0, 1, 2, 3, 4, 5, 6, 7, 8},
+		{0, 1, 2, 3, 4, 5, 6, 7, 8}
+	};
+	
+	std::vector<glm::mat3x3> v2{
+		{
+			{ 0, 1, 2},
+			{ 3, 4, 5},
+			{ 6, 7, 8}
+		},
+		{
+			{ 0, 1, 2},
+			{ 3, 4, 5},
+			{ 6, 7, 8}
+		}
+	};
+	
+#endif//GLM_HAS_INITIALIZER_LISTS
+	
+	return Error;
+}
+
+namespace cast
+{
+	template<typename genType>
+	int entry()
+	{
+		int Error = 0;
+
+		genType A(1.0f);
+		glm::mat3x3 B(A);
+		glm::mat3x3 Identity(1.0f);
+
+		Error += glm::all(glm::equal(B, Identity, glm::epsilon<float>())) ? 0 : 1;
+
+		return Error;
+	}
+
+	int test()
+	{
+		int Error = 0;
+		
+		Error += entry<glm::mat2x2>();
+		Error += entry<glm::mat2x3>();
+		Error += entry<glm::mat2x4>();
+		Error += entry<glm::mat3x2>();
+		Error += entry<glm::mat3x3>();
+		Error += entry<glm::mat3x4>();
+		Error += entry<glm::mat4x2>();
+		Error += entry<glm::mat4x3>();
+		Error += entry<glm::mat4x4>();
+
+		return Error;
+	}
+}//namespace cast
+
+static int test_size()
+{
+	int Error = 0;
+
+	Error += 36 == sizeof(glm::mat3x3) ? 0 : 1;
+	Error += 72 == sizeof(glm::dmat3x3) ? 0 : 1;
+	Error += glm::mat3x3().length() == 3 ? 0 : 1;
+	Error += glm::dmat3x3().length() == 3 ? 0 : 1;
+	Error += glm::mat3x3::length() == 3 ? 0 : 1;
+	Error += glm::dmat3x3::length() == 3 ? 0 : 1;
+
+	return Error;
+}
+
+static int test_constexpr()
+{
+#if GLM_HAS_CONSTEXPR
+	static_assert(glm::mat3x3::length() == 3, "GLM: Failed constexpr");
+
+	constexpr glm::mat3x3 const Z(0.0f);
+#endif
+
+	return 0;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += cast::test();
+	Error += test_ctr();
+	Error += test_mat3x3();
+	Error += test_operators();
+	Error += test_inverse();
+	Error += test_size();
+	Error += test_constexpr();
+
+	return Error;
+}
+
diff --git a/3rdparty/glm/source/test/core/core_type_mat3x4.cpp b/3rdparty/glm/source/test/core/core_type_mat3x4.cpp
new file mode 100644
index 0000000..97d4574
--- /dev/null
+++ b/3rdparty/glm/source/test/core/core_type_mat3x4.cpp
@@ -0,0 +1,149 @@
+#include <glm/gtc/epsilon.hpp>
+#include <glm/gtc/constants.hpp>
+#include <glm/ext/scalar_relational.hpp>
+#include <glm/ext/vector_relational.hpp>
+#include <glm/ext/matrix_relational.hpp>
+#include <glm/mat2x2.hpp>
+#include <glm/mat2x3.hpp>
+#include <glm/mat2x4.hpp>
+#include <glm/mat3x2.hpp>
+#include <glm/mat3x3.hpp>
+#include <glm/mat3x4.hpp>
+#include <glm/mat4x2.hpp>
+#include <glm/mat4x3.hpp>
+#include <glm/mat4x4.hpp>
+#include <vector>
+
+static bool test_operators()
+{
+	glm::mat3x4 l(1.0f);
+	glm::mat3x4 m(1.0f);
+	glm::vec3 u(1.0f);
+	glm::vec4 v(1.0f);
+	float x = 1.0f;
+	glm::vec4 a = m * u;
+	glm::vec3 b = v * m;
+	glm::mat3x4 n = x / m;
+	glm::mat3x4 o = m / x;
+	glm::mat3x4 p = x * m;
+	glm::mat3x4 q = m * x;
+	bool R = glm::any(glm::notEqual(m, q, glm::epsilon<float>()));
+	bool S = glm::all(glm::equal(m, l, glm::epsilon<float>()));
+
+	return (S && !R) ? 0 : 1;
+}
+
+int test_ctr()
+{
+	int Error(0);
+
+#if(GLM_HAS_INITIALIZER_LISTS)
+	glm::mat3x4 m0(
+		glm::vec4(0, 1, 2, 3),
+		glm::vec4(4, 5, 6, 7),
+		glm::vec4(8, 9, 10, 11));
+
+	glm::mat3x4 m1{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
+
+	glm::mat3x4 m2{
+		{0, 1, 2, 3},
+		{4, 5, 6, 7},
+		{8, 9, 10, 11}};
+
+	Error += glm::all(glm::equal(m0, m2, glm::epsilon<float>())) ? 0 : 1;
+	Error += glm::all(glm::equal(m1, m2, glm::epsilon<float>())) ? 0 : 1;
+
+	std::vector<glm::mat3x4> v1{
+		{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11},
+		{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}
+	};
+	
+	std::vector<glm::mat3x4> v2{
+		{
+			{ 0, 1, 2, 3},
+			{ 4, 5, 6, 7},
+			{ 8, 9, 10, 11}
+		},
+		{
+			{ 0, 1, 2, 3},
+			{ 4, 5, 6, 7},
+			{ 8, 9, 10, 11}
+		}
+	};
+	
+#endif//GLM_HAS_INITIALIZER_LISTS
+	
+	return Error;
+}
+
+namespace cast
+{
+	template<typename genType>
+	int entry()
+	{
+		int Error = 0;
+
+		genType A(1.0f);
+		glm::mat3x4 B(A);
+		glm::mat3x4 Identity(1.0f);
+
+		for(glm::length_t i = 0, length = B.length(); i < length; ++i)
+			Error += glm::all(glm::epsilonEqual(B[i], Identity[i], glm::epsilon<float>())) ? 0 : 1;
+
+		return Error;
+	}
+
+	int test()
+	{
+		int Error = 0;
+		
+		Error += entry<glm::mat2x2>();
+		Error += entry<glm::mat2x3>();
+		Error += entry<glm::mat2x4>();
+		Error += entry<glm::mat3x2>();
+		Error += entry<glm::mat3x3>();
+		Error += entry<glm::mat3x4>();
+		Error += entry<glm::mat4x2>();
+		Error += entry<glm::mat4x3>();
+		Error += entry<glm::mat4x4>();
+
+		return Error;
+	}
+}//namespace cast
+
+static int test_size()
+{
+	int Error = 0;
+
+	Error += 48 == sizeof(glm::mat3x4) ? 0 : 1;
+	Error += 96 == sizeof(glm::dmat3x4) ? 0 : 1;
+	Error += glm::mat3x4().length() == 3 ? 0 : 1;
+	Error += glm::dmat3x4().length() == 3 ? 0 : 1;
+	Error += glm::mat3x4::length() == 3 ? 0 : 1;
+	Error += glm::dmat3x4::length() == 3 ? 0 : 1;
+
+	return Error;
+}
+
+static int test_constexpr()
+{
+#if GLM_HAS_CONSTEXPR
+	static_assert(glm::mat3x4::length() == 3, "GLM: Failed constexpr");
+#endif
+
+	return 0;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += cast::test();
+	Error += test_ctr();
+	Error += test_operators();
+	Error += test_size();
+	Error += test_constexpr();
+
+	return Error;
+}
+
diff --git a/3rdparty/glm/source/test/core/core_type_mat4x2.cpp b/3rdparty/glm/source/test/core/core_type_mat4x2.cpp
new file mode 100644
index 0000000..7133edc
--- /dev/null
+++ b/3rdparty/glm/source/test/core/core_type_mat4x2.cpp
@@ -0,0 +1,151 @@
+#include <glm/gtc/constants.hpp>
+#include <glm/ext/scalar_relational.hpp>
+#include <glm/ext/vector_relational.hpp>
+#include <glm/ext/matrix_relational.hpp>
+#include <glm/mat2x2.hpp>
+#include <glm/mat2x3.hpp>
+#include <glm/mat2x4.hpp>
+#include <glm/mat3x2.hpp>
+#include <glm/mat3x3.hpp>
+#include <glm/mat3x4.hpp>
+#include <glm/mat4x2.hpp>
+#include <glm/mat4x3.hpp>
+#include <glm/mat4x4.hpp>
+#include <vector>
+
+static int test_operators()
+{
+	glm::mat4x2 l(1.0f);
+	glm::mat4x2 m(1.0f);
+	glm::vec4 u(1.0f);
+	glm::vec2 v(1.0f);
+	float x = 1.0f;
+	glm::vec2 a = m * u;
+	glm::vec4 b = v * m;
+	glm::mat4x2 n = x / m;
+	glm::mat4x2 o = m / x;
+	glm::mat4x2 p = x * m;
+	glm::mat4x2 q = m * x;
+	bool R = glm::any(glm::notEqual(m, q, glm::epsilon<float>()));
+	bool S = glm::all(glm::equal(m, l, glm::epsilon<float>()));
+
+	return (S && !R) ? 0 : 1;
+}
+
+int test_ctr()
+{
+	int Error(0);
+
+#if(GLM_HAS_INITIALIZER_LISTS)
+	glm::mat4x2 m0(
+		glm::vec2(0, 1), 
+		glm::vec2(2, 3),
+		glm::vec2(4, 5),
+		glm::vec2(6, 7));
+
+	glm::mat4x2 m1{0, 1, 2, 3, 4, 5, 6, 7};
+
+	glm::mat4x2 m2{
+		{0, 1},
+		{2, 3},
+		{4, 5},
+		{6, 7}};
+
+	Error += glm::all(glm::equal(m0, m2, glm::epsilon<float>())) ? 0 : 1;
+	Error += glm::all(glm::equal(m1, m2, glm::epsilon<float>())) ? 0 : 1;
+
+	std::vector<glm::mat4x2> v1{
+		{0, 1, 2, 3, 4, 5, 6, 7},
+		{0, 1, 2, 3, 4, 5, 6, 7}
+	};
+
+	std::vector<glm::mat4x2> v2{
+		{
+			{ 0, 1},
+			{ 4, 5},
+			{ 8, 9},
+			{ 12, 13}
+		},
+		{
+			{ 0, 1},
+			{ 4, 5},
+			{ 8, 9},
+			{ 12, 13}
+		}
+	};
+
+#endif//GLM_HAS_INITIALIZER_LISTS
+
+	return Error;
+}
+
+namespace cast
+{
+	template<typename genType>
+	int entry()
+	{
+		int Error = 0;
+
+		genType A(1.0f);
+		glm::mat4x2 B(A);
+		glm::mat4x2 Identity(1.0f);
+
+		Error += glm::all(glm::equal(B, Identity, glm::epsilon<float>())) ? 0 : 1;
+
+		return Error;
+	}
+
+	int test()
+	{
+		int Error = 0;
+		
+		Error += entry<glm::mat2x2>();
+		Error += entry<glm::mat2x3>();
+		Error += entry<glm::mat2x4>();
+		Error += entry<glm::mat3x2>();
+		Error += entry<glm::mat3x3>();
+		Error += entry<glm::mat3x4>();
+		Error += entry<glm::mat4x2>();
+		Error += entry<glm::mat4x3>();
+		Error += entry<glm::mat4x4>();
+
+		return Error;
+	}
+}//namespace cast
+
+static int test_size()
+{
+	int Error = 0;
+
+	Error += 32 == sizeof(glm::mat4x2) ? 0 : 1;
+	Error += 64 == sizeof(glm::dmat4x2) ? 0 : 1;
+	Error += glm::mat4x2().length() == 4 ? 0 : 1;
+	Error += glm::dmat4x2().length() == 4 ? 0 : 1;
+	Error += glm::mat4x2::length() == 4 ? 0 : 1;
+	Error += glm::dmat4x2::length() == 4 ? 0 : 1;
+
+	return Error;
+}
+
+static int test_constexpr()
+{
+#if GLM_HAS_CONSTEXPR
+	static_assert(glm::mat4x2::length() == 4, "GLM: Failed constexpr");
+#endif
+
+	return 0;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += cast::test();
+	Error += test_ctr();
+	Error += test_operators();
+	Error += test_size();
+	Error += test_constexpr();
+
+	return Error;
+}
+
diff --git a/3rdparty/glm/source/test/core/core_type_mat4x3.cpp b/3rdparty/glm/source/test/core/core_type_mat4x3.cpp
new file mode 100644
index 0000000..1c65e7f
--- /dev/null
+++ b/3rdparty/glm/source/test/core/core_type_mat4x3.cpp
@@ -0,0 +1,152 @@
+#include <glm/gtc/constants.hpp>
+#include <glm/ext/scalar_relational.hpp>
+#include <glm/ext/vector_relational.hpp>
+#include <glm/ext/matrix_relational.hpp>
+#include <glm/mat2x2.hpp>
+#include <glm/mat2x3.hpp>
+#include <glm/mat2x4.hpp>
+#include <glm/mat3x2.hpp>
+#include <glm/mat3x3.hpp>
+#include <glm/mat3x4.hpp>
+#include <glm/mat4x2.hpp>
+#include <glm/mat4x3.hpp>
+#include <glm/mat4x4.hpp>
+#include <vector>
+
+static int test_operators()
+{
+	glm::mat4x3 l(1.0f);
+	glm::mat4x3 m(1.0f);
+	glm::vec4 u(1.0f);
+	glm::vec3 v(1.0f);
+	float x = 1.0f;
+	glm::vec3 a = m * u;
+	glm::vec4 b = v * m;
+	glm::mat4x3 n = x / m;
+	glm::mat4x3 o = m / x;
+	glm::mat4x3 p = x * m;
+	glm::mat4x3 q = m * x;
+	bool R = glm::any(glm::notEqual(m, q, glm::epsilon<float>()));
+	bool S = glm::all(glm::equal(m, l, glm::epsilon<float>()));
+
+	return (S && !R) ? 0 : 1;
+}
+
+int test_ctr()
+{
+	int Error(0);
+
+#if(GLM_HAS_INITIALIZER_LISTS)
+	glm::mat4x3 m0(
+		glm::vec3(0, 1, 2), 
+		glm::vec3(3, 4, 5),
+		glm::vec3(6, 7, 8),
+		glm::vec3(9, 10, 11));
+
+	glm::mat4x3 m1{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
+
+	glm::mat4x3 m2{
+		{0, 1, 2},
+		{3, 4, 5},
+		{6, 7, 8},
+		{9, 10, 11}};
+
+	Error += glm::all(glm::equal(m0, m2, glm::epsilon<float>())) ? 0 : 1;
+	Error += glm::all(glm::equal(m1, m2, glm::epsilon<float>())) ? 0 : 1;
+
+	std::vector<glm::mat4x3> v1{
+		{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11},
+		{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}
+	};
+
+	std::vector<glm::mat4x3> v2{
+		{
+			{ 0, 1, 2 },
+			{ 4, 5, 6 },
+			{ 8, 9, 10 },
+			{ 12, 13, 14 }
+		},
+		{
+			{ 0, 1, 2 },
+			{ 4, 5, 6 },
+			{ 8, 9, 10 },
+			{ 12, 13, 14 }
+		}
+	};
+
+#endif//GLM_HAS_INITIALIZER_LISTS
+
+	return Error;
+}
+
+namespace cast
+{
+	template<typename genType>
+	int entry()
+	{
+		int Error = 0;
+
+		genType A(1.0f);
+		glm::mat4x3 B(A);
+		glm::mat4x3 Identity(1.0f);
+
+		Error += glm::all(glm::equal(B, Identity, glm::epsilon<float>())) ? 0 : 1;
+
+		return Error;
+	}
+
+	int test()
+	{
+		int Error = 0;
+		
+		Error += entry<glm::mat2x2>();
+		Error += entry<glm::mat2x3>();
+		Error += entry<glm::mat2x4>();
+		Error += entry<glm::mat3x2>();
+		Error += entry<glm::mat3x3>();
+		Error += entry<glm::mat3x4>();
+		Error += entry<glm::mat4x2>();
+		Error += entry<glm::mat4x3>();
+		Error += entry<glm::mat4x4>();
+
+		return Error;
+	}
+}//namespace cast
+
+static int test_size()
+{
+	int Error = 0;
+
+	Error += 48 == sizeof(glm::mat4x3) ? 0 : 1;
+	Error += 96 == sizeof(glm::dmat4x3) ? 0 : 1;
+	Error += glm::mat4x3().length() == 4 ? 0 : 1;
+	Error += glm::dmat4x3().length() == 4 ? 0 : 1;
+	Error += glm::mat4x3::length() == 4 ? 0 : 1;
+	Error += glm::dmat4x3::length() == 4 ? 0 : 1;
+
+	return Error;
+}
+
+static int test_constexpr()
+{
+#if GLM_HAS_CONSTEXPR
+	static_assert(glm::mat4x3::length() == 4, "GLM: Failed constexpr");
+#endif
+
+	return 0;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += cast::test();
+	Error += test_ctr();
+	Error += test_operators();
+	Error += test_size();
+	Error += test_constexpr();
+
+	return Error;
+}
+
+
diff --git a/3rdparty/glm/source/test/core/core_type_mat4x4.cpp b/3rdparty/glm/source/test/core/core_type_mat4x4.cpp
new file mode 100644
index 0000000..0be87f1
--- /dev/null
+++ b/3rdparty/glm/source/test/core/core_type_mat4x4.cpp
@@ -0,0 +1,218 @@
+#include <glm/gtc/constants.hpp>
+#include <glm/ext/scalar_relational.hpp>
+#include <glm/ext/vector_relational.hpp>
+#include <glm/ext/matrix_relational.hpp>
+#include <glm/matrix.hpp>
+#include <glm/mat4x4.hpp>
+#include <glm/vec4.hpp>
+#include <vector>
+
+template <typename matType, typename vecType>
+static int test_operators()
+{
+	typedef typename matType::value_type value_type;
+
+	value_type const Epsilon = static_cast<value_type>(0.001);
+
+	int Error = 0;
+
+	matType const M(static_cast<value_type>(2.0f));
+	matType const N(static_cast<value_type>(1.0f));
+	vecType const U(static_cast<value_type>(2.0f));
+
+	{
+		matType const P = N * static_cast<value_type>(2.0f);
+		Error += glm::all(glm::equal(P, M, Epsilon)) ? 0 : 1;
+		
+		matType const Q = M / static_cast<value_type>(2.0f);
+		Error += glm::all(glm::equal(Q, N, Epsilon)) ? 0 : 1;
+	}
+	
+	{
+		vecType const V = M * U;
+		Error += glm::all(glm::equal(V, vecType(static_cast<value_type>(4.f)), Epsilon)) ? 0 : 1;
+		
+		vecType const W = U / M;
+		Error += glm::all(glm::equal(W, vecType(static_cast<value_type>(1.f)), Epsilon)) ? 0 : 1;
+	}
+
+	{
+		matType const O = M * N;
+		Error += glm::all(glm::equal(O, matType(static_cast<value_type>(2.f)), Epsilon)) ? 0 : 1;
+	}
+
+	return Error;
+}
+
+template <typename matType>
+static int test_inverse()
+{
+	typedef typename matType::value_type value_type;
+
+	value_type const Epsilon = static_cast<value_type>(0.001);
+	
+	int Error = 0;
+
+	matType const Identity(static_cast<value_type>(1.0f));
+	matType const Matrix(
+		glm::vec4(0.6f, 0.2f, 0.3f, 0.4f),
+		glm::vec4(0.2f, 0.7f, 0.5f, 0.3f),
+		glm::vec4(0.3f, 0.5f, 0.7f, 0.2f),
+		glm::vec4(0.4f, 0.3f, 0.2f, 0.6f));
+	matType const Inverse = Identity / Matrix;
+	matType const Result = Matrix * Inverse;
+
+	Error += glm::all(glm::equal(Identity, Result, Epsilon)) ? 0 : 1;
+	
+	return Error;
+}
+
+static int test_ctr()
+{
+	int Error = 0;
+
+#if GLM_HAS_TRIVIAL_QUERIES
+	//Error += std::is_trivially_default_constructible<glm::mat4>::value ? 0 : 1;
+	//Error += std::is_trivially_copy_assignable<glm::mat4>::value ? 0 : 1;
+	Error += std::is_trivially_copyable<glm::mat4>::value ? 0 : 1;
+	//Error += std::is_copy_constructible<glm::mat4>::value ? 0 : 1;
+	//Error += std::has_trivial_copy_constructor<glm::mat4>::value ? 0 : 1;
+#endif
+
+#if GLM_HAS_INITIALIZER_LISTS
+	glm::mat4 const m0(
+		glm::vec4(0, 1, 2, 3),
+		glm::vec4(4, 5, 6, 7),
+		glm::vec4(8, 9, 10, 11),
+		glm::vec4(12, 13, 14, 15));
+
+	assert(sizeof(m0) == 4 * 4 * 4);
+
+	glm::vec4 const V{0, 1, 2, 3};
+
+	glm::mat4 const m1{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
+
+	glm::mat4 const m2{
+		{0, 1, 2, 3},
+		{4, 5, 6, 7},
+		{8, 9, 10, 11},
+		{12, 13, 14, 15}};
+
+	Error += glm::all(glm::equal(m0, m2, glm::epsilon<float>())) ? 0 : 1;
+	Error += glm::all(glm::equal(m1, m2, glm::epsilon<float>())) ? 0 : 1;
+
+
+	std::vector<glm::mat4> const m3{
+		{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15},
+		{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15},
+		{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15},
+		{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}};
+
+	glm::mat4 const m4{
+		{1, 0, 0, 0},
+		{0, 1, 0, 0},
+		{0, 0, 1, 0},
+		{0, 0, 0, 1} };
+
+	Error += glm::equal(m4[0][0], 1.0f, 0.0001f) ? 0 : 1;
+	Error += glm::equal(m4[3][3], 1.0f, 0.0001f) ? 0 : 1;
+
+	std::vector<glm::mat4> const v1{
+		{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15},
+		{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}};
+
+	std::vector<glm::mat4> const v2{
+		{
+			{ 0, 1, 2, 3 },
+			{ 4, 5, 6, 7 },
+			{ 8, 9, 10, 11 },
+			{ 12, 13, 14, 15 }
+		},
+		{
+			{ 0, 1, 2, 3 },
+			{ 4, 5, 6, 7 },
+			{ 8, 9, 10, 11 },
+			{ 12, 13, 14, 15 }
+		}};
+
+#endif//GLM_HAS_INITIALIZER_LISTS
+
+	return Error;
+}
+
+static int test_member_alloc_bug()
+{
+	int Error = 0;
+	
+	struct repro
+	{
+		repro(){ this->matrix = new glm::mat4(); }
+		~repro(){delete this->matrix;}
+		
+		glm::mat4* matrix;
+	};
+	
+	repro Repro;
+	
+	return Error;
+}
+
+static int test_size()
+{
+	int Error = 0;
+
+	Error += 64 == sizeof(glm::mat4) ? 0 : 1;
+	Error += 128 == sizeof(glm::dmat4) ? 0 : 1;
+	Error += glm::mat4().length() == 4 ? 0 : 1;
+	Error += glm::dmat4().length() == 4 ? 0 : 1;
+	Error += glm::mat4::length() == 4 ? 0 : 1;
+	Error += glm::dmat4::length() == 4 ? 0 : 1;
+
+	return Error;
+}
+
+static int test_constexpr()
+{
+#if GLM_HAS_CONSTEXPR
+	static_assert(glm::mat4::length() == 4, "GLM: Failed constexpr");
+	constexpr glm::mat4 A(1.f);
+	constexpr glm::mat4 B(1.f);
+	constexpr glm::bvec4 C = glm::equal(A, B, 0.01f);
+	static_assert(glm::all(C), "GLM: Failed constexpr");
+#endif
+
+	return 0;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_member_alloc_bug();
+	Error += test_ctr();
+
+	Error += test_operators<glm::mat4, glm::vec4>();
+	Error += test_operators<glm::lowp_mat4, glm::lowp_vec4>();
+	Error += test_operators<glm::mediump_mat4, glm::mediump_vec4>();
+	Error += test_operators<glm::highp_mat4, glm::highp_vec4>();
+
+	Error += test_operators<glm::dmat4, glm::dvec4>();
+	Error += test_operators<glm::lowp_dmat4, glm::lowp_dvec4>();
+	Error += test_operators<glm::mediump_dmat4, glm::mediump_dvec4>();
+	Error += test_operators<glm::highp_dmat4, glm::highp_dvec4>();
+
+	Error += test_inverse<glm::mat4>();
+	Error += test_inverse<glm::lowp_mat4>();
+	Error += test_inverse<glm::mediump_mat4>();
+	Error += test_inverse<glm::highp_mat4>();
+
+	Error += test_inverse<glm::dmat4>();
+	Error += test_inverse<glm::lowp_dmat4>();
+	Error += test_inverse<glm::mediump_dmat4>();
+	Error += test_inverse<glm::highp_dmat4>();
+
+	Error += test_size();
+	Error += test_constexpr();
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/core/core_type_vec1.cpp b/3rdparty/glm/source/test/core/core_type_vec1.cpp
new file mode 100644
index 0000000..77f3f84
--- /dev/null
+++ b/3rdparty/glm/source/test/core/core_type_vec1.cpp
@@ -0,0 +1,169 @@
+#define GLM_FORCE_SWIZZLE
+#include <glm/gtc/constants.hpp>
+#include <glm/gtc/vec1.hpp>
+#include <glm/ext/vector_relational.hpp>
+#include <glm/vec2.hpp>
+#include <vector>
+
+static glm::vec1 g1;
+static glm::vec1 g2(1);
+
+int test_vec1_operators()
+{
+	int Error = 0;
+
+	glm::ivec1 A(1);
+	glm::ivec1 B(1);
+	{
+		bool R = A != B;
+		bool S = A == B;
+
+		Error += (S && !R) ? 0 : 1;
+	}
+
+	{
+		A *= 1;
+		B *= 1;
+		A += 1;
+		B += 1;
+
+		bool R = A != B;
+		bool S = A == B;
+
+		Error += (S && !R) ? 0 : 1;
+	}
+
+	return Error;
+}
+
+int test_vec1_ctor()
+{
+	int Error = 0;
+
+#	if GLM_HAS_TRIVIAL_QUERIES
+	//	Error += std::is_trivially_default_constructible<glm::vec1>::value ? 0 : 1;
+	//	Error += std::is_trivially_copy_assignable<glm::vec1>::value ? 0 : 1;
+		Error += std::is_trivially_copyable<glm::vec1>::value ? 0 : 1;
+		Error += std::is_trivially_copyable<glm::dvec1>::value ? 0 : 1;
+		Error += std::is_trivially_copyable<glm::ivec1>::value ? 0 : 1;
+		Error += std::is_trivially_copyable<glm::uvec1>::value ? 0 : 1;
+
+		Error += std::is_copy_constructible<glm::vec1>::value ? 0 : 1;
+#	endif
+
+/*
+#if GLM_HAS_INITIALIZER_LISTS
+	{
+		glm::vec1 a{ 0 };
+		std::vector<glm::vec1> v = {
+			{0.f},
+			{4.f},
+			{8.f}};
+	}
+
+	{
+		glm::dvec2 a{ 0 };
+		std::vector<glm::dvec1> v = {
+			{0.0},
+			{4.0},
+			{8.0}};
+	}
+#endif
+*/
+
+	{
+		glm::vec2 A = glm::vec2(2.0f);
+		glm::vec2 B = glm::vec2(2.0f, 3.0f);
+		glm::vec2 C = glm::vec2(2.0f, 3.0);
+		//glm::vec2 D = glm::dvec2(2.0); // Build error TODO: What does the specification says?
+		glm::vec2 E(glm::dvec2(2.0));
+		glm::vec2 F(glm::ivec2(2));
+	}
+
+	return Error;
+}
+
+static int test_vec1_size()
+{
+	int Error = 0;
+
+	Error += sizeof(glm::vec1) == sizeof(glm::mediump_vec1) ? 0 : 1;
+	Error += 4 == sizeof(glm::mediump_vec1) ? 0 : 1;
+	Error += sizeof(glm::dvec1) == sizeof(glm::highp_dvec1) ? 0 : 1;
+	Error += 8 == sizeof(glm::highp_dvec1) ? 0 : 1;
+	Error += glm::vec1().length() == 1 ? 0 : 1;
+	Error += glm::dvec1().length() == 1 ? 0 : 1;
+	Error += glm::vec1::length() == 1 ? 0 : 1;
+	Error += glm::dvec1::length() == 1 ? 0 : 1;
+
+	return Error;
+}
+
+static int test_vec1_operator_increment()
+{
+	int Error(0);
+
+	glm::ivec1 v0(1);
+	glm::ivec1 v1(v0);
+	glm::ivec1 v2(v0);
+	glm::ivec1 v3 = ++v1;
+	glm::ivec1 v4 = v2++;
+
+	Error += glm::all(glm::equal(v0, v4)) ? 0 : 1;
+	Error += glm::all(glm::equal(v1, v2)) ? 0 : 1;
+	Error += glm::all(glm::equal(v1, v3)) ? 0 : 1;
+
+	int i0(1);
+	int i1(i0);
+	int i2(i0);
+	int i3 = ++i1;
+	int i4 = i2++;
+
+	Error += i0 == i4 ? 0 : 1;
+	Error += i1 == i2 ? 0 : 1;
+	Error += i1 == i3 ? 0 : 1;
+
+	return Error;
+}
+
+static int test_swizzle()
+{
+	int Error = 0;
+
+#	if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR
+	{
+		glm::vec1 A = glm::vec1(1.0f);
+		//glm::vec1 B = A.x;
+		glm::vec1 C(A.x);
+
+		//Error += glm::all(glm::equal(A, B)) ? 0 : 1;
+		Error += glm::all(glm::equal(A, C, glm::epsilon<float>())) ? 0 : 1;
+	}
+#	endif//GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR
+
+	return Error;
+}
+
+static int test_constexpr()
+{
+#if GLM_HAS_CONSTEXPR
+	static_assert(glm::vec1::length() == 1, "GLM: Failed constexpr");
+	static_assert(glm::vec1(1.0f).x > 0.0f, "GLM: Failed constexpr");
+#endif
+
+	return 0;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_vec1_size();
+	Error += test_vec1_ctor();
+	Error += test_vec1_operators();
+	Error += test_vec1_operator_increment();
+	Error += test_swizzle();
+	Error += test_constexpr();
+	
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/core/core_type_vec2.cpp b/3rdparty/glm/source/test/core/core_type_vec2.cpp
new file mode 100644
index 0000000..308c61f
--- /dev/null
+++ b/3rdparty/glm/source/test/core/core_type_vec2.cpp
@@ -0,0 +1,392 @@
+#define GLM_FORCE_SWIZZLE
+#include <glm/gtc/vec1.hpp>
+#include <glm/gtc/constants.hpp>
+#include <glm/ext/vector_float1.hpp>
+#include <glm/ext/vector_relational.hpp>
+#include <glm/vector_relational.hpp>
+#include <glm/vec2.hpp>
+#include <vector>
+#if GLM_HAS_TRIVIAL_QUERIES
+#	include <type_traits>
+#endif
+
+static glm::ivec2 g1;
+static glm::ivec2 g2(1);
+static glm::ivec2 g3(1, 1);
+
+static int test_operators()
+{
+	int Error = 0;
+
+	{
+		glm::ivec2 A(1);
+		glm::ivec2 B(1);
+		Error += A != B ? 1 : 0;
+		Error += A == B ? 0 : 1;
+	}
+
+	{
+		glm::vec2 A(1.0f);
+		glm::vec2 C = A + 1.0f;
+		A += 1.0f;
+		Error += glm::all(glm::equal(A, glm::vec2(2.0f), glm::epsilon<float>())) ? 0 : 1;
+		Error += glm::all(glm::equal(A, C, glm::epsilon<float>())) ? 0 : 1;
+	}
+
+	{
+		glm::vec2 A(1.0f);
+		glm::vec2 B(2.0f,-1.0f);
+		glm::vec2 C = A + B;
+		A += B;
+		Error += glm::all(glm::equal(A, glm::vec2(3.0f, 0.0f), glm::epsilon<float>())) ? 0 : 1;
+		Error += glm::all(glm::equal(A, C, glm::epsilon<float>())) ? 0 : 1;
+	}
+
+	{
+		glm::vec2 A(1.0f);
+		glm::vec2 C = A - 1.0f;
+		A -= 1.0f;
+		Error += glm::all(glm::equal(A, glm::vec2(0.0f), glm::epsilon<float>())) ? 0 : 1;
+		Error += glm::all(glm::equal(A, C, glm::epsilon<float>())) ? 0 : 1;
+	}
+
+	{
+		glm::vec2 A(1.0f);
+		glm::vec2 B(2.0f,-1.0f);
+		glm::vec2 C = A - B;
+		A -= B;
+		Error += glm::all(glm::equal(A, glm::vec2(-1.0f, 2.0f), glm::epsilon<float>())) ? 0 : 1;
+		Error += glm::all(glm::equal(A, C, glm::epsilon<float>())) ? 0 : 1;
+	}
+
+	{
+		glm::vec2 A(1.0f);
+		glm::vec2 C = A * 2.0f;
+		A *= 2.0f;
+		Error += glm::all(glm::equal(A, glm::vec2(2.0f), glm::epsilon<float>())) ? 0 : 1;
+		Error += glm::all(glm::equal(A, C, glm::epsilon<float>())) ? 0 : 1;
+	}
+
+	{
+		glm::vec2 A(2.0f);
+		glm::vec2 B(2.0f);
+		glm::vec2 C = A / B;
+		A /= B;
+		Error += glm::all(glm::equal(A, glm::vec2(1.0f), glm::epsilon<float>())) ? 0 : 1;
+		Error += glm::all(glm::equal(A, C, glm::epsilon<float>())) ? 0 : 1;
+	}
+
+	{
+		glm::vec2 A(1.0f, 2.0f);
+		glm::vec2 B(4.0f, 5.0f);
+
+		glm::vec2 C = A + B;
+		Error += glm::all(glm::equal(C, glm::vec2(5, 7), glm::epsilon<float>())) ? 0 : 1;
+
+		glm::vec2 D = B - A;
+		Error += glm::all(glm::equal(D, glm::vec2(3, 3), glm::epsilon<float>())) ? 0 : 1;
+
+		glm::vec2 E = A * B;
+		Error += glm::all(glm::equal(E, glm::vec2(4, 10), glm::epsilon<float>())) ? 0 : 1;
+
+		glm::vec2 F = B / A;
+		Error += glm::all(glm::equal(F, glm::vec2(4, 2.5), glm::epsilon<float>())) ? 0 : 1;
+
+		glm::vec2 G = A + 1.0f;
+		Error += glm::all(glm::equal(G, glm::vec2(2, 3), glm::epsilon<float>())) ? 0 : 1;
+
+		glm::vec2 H = B - 1.0f;
+		Error += glm::all(glm::equal(H, glm::vec2(3, 4), glm::epsilon<float>())) ? 0 : 1;
+
+		glm::vec2 I = A * 2.0f;
+		Error += glm::all(glm::equal(I, glm::vec2(2, 4), glm::epsilon<float>())) ? 0 : 1;
+
+		glm::vec2 J = B / 2.0f;
+		Error += glm::all(glm::equal(J, glm::vec2(2, 2.5), glm::epsilon<float>())) ? 0 : 1;
+
+		glm::vec2 K = 1.0f + A;
+		Error += glm::all(glm::equal(K, glm::vec2(2, 3), glm::epsilon<float>())) ? 0 : 1;
+
+		glm::vec2 L = 1.0f - B;
+		Error += glm::all(glm::equal(L, glm::vec2(-3, -4), glm::epsilon<float>())) ? 0 : 1;
+
+		glm::vec2 M = 2.0f * A;
+		Error += glm::all(glm::equal(M, glm::vec2(2, 4), glm::epsilon<float>())) ? 0 : 1;
+
+		glm::vec2 N = 2.0f / B;
+		Error += glm::all(glm::equal(N, glm::vec2(0.5, 2.0 / 5.0), glm::epsilon<float>())) ? 0 : 1;
+	}
+
+	{
+		glm::vec2 A(1.0f, 2.0f);
+		glm::vec2 B(4.0f, 5.0f);
+
+		A += B;
+		Error += glm::all(glm::equal(A, glm::vec2(5, 7), glm::epsilon<float>())) ? 0 : 1;
+
+		A += 1.0f;
+		Error += glm::all(glm::equal(A, glm::vec2(6, 8), glm::epsilon<float>())) ? 0 : 1;
+	}
+	{
+		glm::ivec2 A(1.0f, 2.0f);
+		glm::ivec2 B(4.0f, 5.0f);
+
+		B -= A;
+		Error += B == glm::ivec2(3, 3) ? 0 : 1;
+
+		B -= 1.0f;
+		Error += B == glm::ivec2(2, 2) ? 0 : 1;
+	}
+	{
+		glm::ivec2 A(1.0f, 2.0f);
+		glm::ivec2 B(4.0f, 5.0f);
+
+		A *= B;
+		Error += A == glm::ivec2(4, 10) ? 0 : 1;
+
+		A *= 2;
+		Error += A == glm::ivec2(8, 20) ? 0 : 1;
+	}
+	{
+		glm::ivec2 A(1.0f, 2.0f);
+		glm::ivec2 B(4.0f, 16.0f);
+
+		B /= A;
+		Error += B == glm::ivec2(4, 8) ? 0 : 1;
+
+		B /= 2.0f;
+		Error += B == glm::ivec2(2, 4) ? 0 : 1;
+	}
+	{
+		glm::ivec2 B(2);
+
+		B /= B.y;
+		Error += B == glm::ivec2(1) ? 0 : 1;
+	}
+
+	{
+		glm::ivec2 A(1.0f, 2.0f);
+		glm::ivec2 B = -A;
+		Error += B == glm::ivec2(-1.0f, -2.0f) ? 0 : 1;
+	}
+
+	{
+		glm::ivec2 A(1.0f, 2.0f);
+		glm::ivec2 B = --A;
+		Error += B == glm::ivec2(0.0f, 1.0f) ? 0 : 1;
+	}
+
+	{
+		glm::ivec2 A(1.0f, 2.0f);
+		glm::ivec2 B = A--;
+		Error += B == glm::ivec2(1.0f, 2.0f) ? 0 : 1;
+		Error += A == glm::ivec2(0.0f, 1.0f) ? 0 : 1;
+	}
+
+	{
+		glm::ivec2 A(1.0f, 2.0f);
+		glm::ivec2 B = ++A;
+		Error += B == glm::ivec2(2.0f, 3.0f) ? 0 : 1;
+	}
+
+	{
+		glm::ivec2 A(1.0f, 2.0f);
+		glm::ivec2 B = A++;
+		Error += B == glm::ivec2(1.0f, 2.0f) ? 0 : 1;
+		Error += A == glm::ivec2(2.0f, 3.0f) ? 0 : 1;
+	}
+
+	return Error;
+}
+
+static int test_ctor()
+{
+	int Error = 0;
+
+	{
+		glm::ivec2 A(1);
+		glm::ivec2 B(A);
+		Error += A == B ? 0 : 1;
+	}
+
+#	if GLM_HAS_TRIVIAL_QUERIES
+	//	Error += std::is_trivially_default_constructible<glm::vec2>::value ? 0 : 1;
+	//	Error += std::is_trivially_copy_assignable<glm::vec2>::value ? 0 : 1;
+		Error += std::is_trivially_copyable<glm::vec2>::value ? 0 : 1;
+		Error += std::is_trivially_copyable<glm::dvec2>::value ? 0 : 1;
+		Error += std::is_trivially_copyable<glm::ivec2>::value ? 0 : 1;
+		Error += std::is_trivially_copyable<glm::uvec2>::value ? 0 : 1;
+
+		Error += std::is_copy_constructible<glm::vec2>::value ? 0 : 1;
+#	endif
+
+#if GLM_HAS_INITIALIZER_LISTS
+	{
+		glm::vec2 a{ 0, 1 };
+		std::vector<glm::vec2> v = {
+			{0, 1},
+			{4, 5},
+			{8, 9}};
+	}
+
+	{
+		glm::dvec2 a{ 0, 1 };
+		std::vector<glm::dvec2> v = {
+			{0, 1},
+			{4, 5},
+			{8, 9}};
+	}
+#endif
+
+	{
+		glm::vec2 A = glm::vec2(2.0f);
+		glm::vec2 B = glm::vec2(2.0f, 3.0f);
+		glm::vec2 C = glm::vec2(2.0f, 3.0);
+		//glm::vec2 D = glm::dvec2(2.0); // Build error TODO: What does the specification says?
+		glm::vec2 E(glm::dvec2(2.0));
+		glm::vec2 F(glm::ivec2(2));
+	}
+
+	{
+		glm::vec1 const R(1.0f);
+		glm::vec1 const S(2.0f);
+		glm::vec2 const O(1.0f, 2.0f);
+
+		glm::vec2 const A(R);
+		glm::vec2 const B(1.0f);
+		Error += glm::all(glm::equal(A, B, 0.0001f)) ? 0 : 1;
+
+		glm::vec2 const C(R, S);
+		Error += glm::all(glm::equal(C, O, 0.0001f)) ? 0 : 1;
+
+		glm::vec2 const D(R, 2.0f);
+		Error += glm::all(glm::equal(D, O, 0.0001f)) ? 0 : 1;
+
+		glm::vec2 const E(1.0f, S);
+		Error += glm::all(glm::equal(E, O, 0.0001f)) ? 0 : 1;
+	}
+
+	{
+		glm::vec1 const R(1.0f);
+		glm::dvec1 const S(2.0);
+		glm::vec2 const O(1.0, 2.0);
+
+		glm::vec2 const A(R);
+		glm::vec2 const B(1.0);
+		Error += glm::all(glm::equal(A, B, 0.0001f)) ? 0 : 1;
+
+		glm::vec2 const C(R, S);
+		Error += glm::all(glm::equal(C, O, 0.0001f)) ? 0 : 1;
+
+		glm::vec2 const D(R, 2.0);
+		Error += glm::all(glm::equal(D, O, 0.0001f)) ? 0 : 1;
+
+		glm::vec2 const E(1.0, S);
+		Error += glm::all(glm::equal(E, O, 0.0001f)) ? 0 : 1;
+	}
+
+	return Error;
+}
+
+static int test_size()
+{
+	int Error = 0;
+
+	Error += sizeof(glm::vec2) == sizeof(glm::mediump_vec2) ? 0 : 1;
+	Error += 8 == sizeof(glm::mediump_vec2) ? 0 : 1;
+	Error += sizeof(glm::dvec2) == sizeof(glm::highp_dvec2) ? 0 : 1;
+	Error += 16 == sizeof(glm::highp_dvec2) ? 0 : 1;
+	Error += glm::vec2().length() == 2 ? 0 : 1;
+	Error += glm::dvec2().length() == 2 ? 0 : 1;
+	Error += glm::vec2::length() == 2 ? 0 : 1;
+	Error += glm::dvec2::length() == 2 ? 0 : 1;
+
+	GLM_CONSTEXPR std::size_t Length = glm::vec2::length();
+	Error += Length == 2 ? 0 : 1;
+
+	return Error;
+}
+
+static int test_operator_increment()
+{
+	int Error = 0;
+
+	glm::ivec2 v0(1);
+	glm::ivec2 v1(v0);
+	glm::ivec2 v2(v0);
+	glm::ivec2 v3 = ++v1;
+	glm::ivec2 v4 = v2++;
+
+	Error += glm::all(glm::equal(v0, v4)) ? 0 : 1;
+	Error += glm::all(glm::equal(v1, v2)) ? 0 : 1;
+	Error += glm::all(glm::equal(v1, v3)) ? 0 : 1;
+
+	int i0(1);
+	int i1(i0);
+	int i2(i0);
+	int i3 = ++i1;
+	int i4 = i2++;
+
+	Error += i0 == i4 ? 0 : 1;
+	Error += i1 == i2 ? 0 : 1;
+	Error += i1 == i3 ? 0 : 1;
+
+	return Error;
+}
+
+static int test_constexpr()
+{
+#if GLM_HAS_CONSTEXPR
+	static_assert(glm::vec2::length() == 2, "GLM: Failed constexpr");
+	static_assert(glm::vec2(1.0f).x > 0.0f, "GLM: Failed constexpr");
+	static_assert(glm::vec2(1.0f, -1.0f).x > 0.0f, "GLM: Failed constexpr");
+	static_assert(glm::vec2(1.0f, -1.0f).y < 0.0f, "GLM: Failed constexpr");
+#endif
+
+	return 0;
+}
+
+static int test_swizzle()
+{
+	int Error = 0;
+
+#	if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR
+	{
+		glm::vec2 A = glm::vec2(1.0f, 2.0f);
+		glm::vec2 B = A.xy;
+		glm::vec2 C(A.xy);
+		glm::vec2 D(A.xy());
+
+		Error += glm::all(glm::equal(A, B, 0.0001f)) ? 0 : 1;
+		Error += glm::all(glm::equal(A, C, 0.0001f)) ? 0 : 1;
+		Error += glm::all(glm::equal(A, D, 0.0001f)) ? 0 : 1;
+	}
+#	endif//GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR
+
+#	if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR || GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_FUNCTION
+	{
+		glm::vec2 A = glm::vec2(1.0f, 2.0f);
+		glm::vec2 B = A.xy();
+		glm::vec2 C(A.xy());
+
+		Error += glm::all(glm::equal(A, B, 0.0001f)) ? 0 : 1;
+		Error += glm::all(glm::equal(A, C, 0.0001f)) ? 0 : 1;
+	}
+#	endif//GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR || GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_FUNCTION
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_size();
+	Error += test_ctor();
+	Error += test_operators();
+	Error += test_operator_increment();
+	Error += test_swizzle();
+	Error += test_constexpr();
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/core/core_type_vec3.cpp b/3rdparty/glm/source/test/core/core_type_vec3.cpp
new file mode 100644
index 0000000..4da8187
--- /dev/null
+++ b/3rdparty/glm/source/test/core/core_type_vec3.cpp
@@ -0,0 +1,628 @@
+#define GLM_FORCE_SWIZZLE
+#include <glm/gtc/constants.hpp>
+#include <glm/gtc/vec1.hpp>
+#include <glm/ext/vector_relational.hpp>
+#include <glm/vector_relational.hpp>
+#include <glm/geometric.hpp>
+#include <glm/vec2.hpp>
+#include <glm/vec3.hpp>
+#include <glm/vec4.hpp>
+#include <vector>
+
+static glm::vec3 g1;
+static glm::vec3 g2(1);
+static glm::vec3 g3(1, 1, 1);
+
+int test_vec3_ctor()
+{
+	int Error = 0;
+
+#	if GLM_HAS_TRIVIAL_QUERIES
+	//	Error += std::is_trivially_default_constructible<glm::vec3>::value ? 0 : 1;
+	//	Error += std::is_trivially_copy_assignable<glm::vec3>::value ? 0 : 1;
+		Error += std::is_trivially_copyable<glm::vec3>::value ? 0 : 1;
+		Error += std::is_trivially_copyable<glm::dvec3>::value ? 0 : 1;
+		Error += std::is_trivially_copyable<glm::ivec3>::value ? 0 : 1;
+		Error += std::is_trivially_copyable<glm::uvec3>::value ? 0 : 1;
+
+		Error += std::is_copy_constructible<glm::vec3>::value ? 0 : 1;
+#	endif
+
+#	if GLM_HAS_INITIALIZER_LISTS
+	{
+		glm::vec3 a{ 0, 1, 2 };
+		std::vector<glm::vec3> v = {
+			{0, 1, 2},
+			{4, 5, 6},
+			{8, 9, 0}};
+	}
+
+	{
+		glm::dvec3 a{ 0, 1, 2 };
+		std::vector<glm::dvec3> v = {
+			{0, 1, 2},
+			{4, 5, 6},
+			{8, 9, 0}};
+	}
+#	endif
+
+	{
+		glm::ivec3 A(1);
+		glm::ivec3 B(1, 1, 1);
+		
+		Error += A == B ? 0 : 1;
+	}
+
+	{
+		std::vector<glm::ivec3> Tests;
+		Tests.push_back(glm::ivec3(glm::ivec2(1, 2), 3));
+		Tests.push_back(glm::ivec3(1, glm::ivec2(2, 3)));
+		Tests.push_back(glm::ivec3(1, 2, 3));
+		Tests.push_back(glm::ivec3(glm::ivec4(1, 2, 3, 4)));
+
+		for(std::size_t i = 0; i < Tests.size(); ++i)
+			Error += Tests[i] == glm::ivec3(1, 2, 3) ? 0 : 1;
+	}
+
+	{
+		glm::vec1 const R(1.0f);
+		glm::vec1 const S(2.0f);
+		glm::vec1 const T(3.0f);
+		glm::vec3 const O(1.0f, 2.0f, 3.0f);
+
+		glm::vec3 const A(R);
+		glm::vec3 const B(1.0f);
+		Error += glm::all(glm::equal(A, B, glm::epsilon<float>())) ? 0 : 1;
+
+		glm::vec3 const C(R, S, T);
+		Error += glm::all(glm::equal(C, O, glm::epsilon<float>())) ? 0 : 1;
+
+		glm::vec3 const D(R, 2.0f, 3.0f);
+		Error += glm::all(glm::equal(D, O, glm::epsilon<float>())) ? 0 : 1;
+
+		glm::vec3 const E(1.0f, S, 3.0f);
+		Error += glm::all(glm::equal(E, O, glm::epsilon<float>())) ? 0 : 1;
+
+		glm::vec3 const F(1.0f, S, T);
+		Error += glm::all(glm::equal(F, O, glm::epsilon<float>())) ? 0 : 1;
+
+		glm::vec3 const G(R, 2.0f, T);
+		Error += glm::all(glm::equal(G, O, glm::epsilon<float>())) ? 0 : 1;
+
+		glm::vec3 const H(R, S, 3.0f);
+		Error += glm::all(glm::equal(H, O, glm::epsilon<float>())) ? 0 : 1;
+	}
+
+	{
+		glm::vec1 const R(1.0);
+		glm::dvec1 const S(2.0);
+		glm::vec1 const T(3.0);
+		glm::vec3 const O(1.0f, 2.0f, 3.0f);
+
+		glm::vec3 const A(R);
+		glm::vec3 const B(1.0);
+		Error += glm::all(glm::equal(A, B, glm::epsilon<float>())) ? 0 : 1;
+
+		glm::vec3 const C(R, S, T);
+		Error += glm::all(glm::equal(C, O, glm::epsilon<float>())) ? 0 : 1;
+
+		glm::vec3 const D(R, 2.0, 3.0);
+		Error += glm::all(glm::equal(D, O, glm::epsilon<float>())) ? 0 : 1;
+
+		glm::vec3 const E(1.0f, S, 3.0);
+		Error += glm::all(glm::equal(E, O, glm::epsilon<float>())) ? 0 : 1;
+
+		glm::vec3 const F(1.0, S, T);
+		Error += glm::all(glm::equal(F, O, glm::epsilon<float>())) ? 0 : 1;
+
+		glm::vec3 const G(R, 2.0, T);
+		Error += glm::all(glm::equal(G, O, glm::epsilon<float>())) ? 0 : 1;
+
+		glm::vec3 const H(R, S, 3.0);
+		Error += glm::all(glm::equal(H, O, glm::epsilon<float>())) ? 0 : 1;
+	}
+
+	return Error;
+}
+
+float foo()
+{
+	glm::vec3 bar = glm::vec3(0.0f, 1.0f, 1.0f);
+
+	return glm::length(bar);
+}
+
+static int test_bvec3_ctor()
+{
+	int Error = 0;
+
+	glm::bvec3 const A(true);
+	glm::bvec3 const B(true);
+	glm::bvec3 const C(false);
+	glm::bvec3 const D = A && B;
+	glm::bvec3 const E = A && C;
+	glm::bvec3 const F = A || C;
+
+	Error += D == glm::bvec3(true) ? 0 : 1;
+	Error += E == glm::bvec3(false) ? 0 : 1;
+	Error += F == glm::bvec3(true) ? 0 : 1;
+
+	bool const G = A == C;
+	bool const H = A != C;
+	Error += !G ? 0 : 1;
+	Error += H ? 0 : 1;
+
+	return Error;
+}
+
+static int test_vec3_operators()
+{
+	int Error = 0;
+	
+	{
+		glm::ivec3 A(1);
+		glm::ivec3 B(1);
+		bool R = A != B;
+		bool S = A == B;
+
+		Error += (S && !R) ? 0 : 1;
+	}
+
+	{
+		glm::vec3 const A(1.0f, 2.0f, 3.0f);
+		glm::vec3 const B(4.0f, 5.0f, 6.0f);
+
+		glm::vec3 const C = A + B;
+		Error += glm::all(glm::equal(C, glm::vec3(5, 7, 9), glm::epsilon<float>())) ? 0 : 1;
+
+		glm::vec3 const D = B - A;
+		Error += glm::all(glm::equal(D, glm::vec3(3, 3, 3), glm::epsilon<float>())) ? 0 : 1;
+
+		glm::vec3 const E = A * B;
+		Error += glm::all(glm::equal(E, glm::vec3(4, 10, 18), glm::epsilon<float>())) ? 0 : 1;
+
+		glm::vec3 const F = B / A;
+		Error += glm::all(glm::equal(F, glm::vec3(4, 2.5, 2), glm::epsilon<float>())) ? 0 : 1;
+
+		glm::vec3 const G = A + 1.0f;
+		Error += glm::all(glm::equal(G, glm::vec3(2, 3, 4), glm::epsilon<float>())) ? 0 : 1;
+
+		glm::vec3 const H = B - 1.0f;
+		Error += glm::all(glm::equal(H, glm::vec3(3, 4, 5), glm::epsilon<float>())) ? 0 : 1;
+
+		glm::vec3 const I = A * 2.0f;
+		Error += glm::all(glm::equal(I, glm::vec3(2, 4, 6), glm::epsilon<float>())) ? 0 : 1;
+
+		glm::vec3 const J = B / 2.0f;
+		Error += glm::all(glm::equal(J, glm::vec3(2, 2.5, 3), glm::epsilon<float>())) ? 0 : 1;
+
+		glm::vec3 const K = 1.0f + A;
+		Error += glm::all(glm::equal(K, glm::vec3(2, 3, 4), glm::epsilon<float>())) ? 0 : 1;
+
+		glm::vec3 const L = 1.0f - B;
+		Error += glm::all(glm::equal(L, glm::vec3(-3, -4, -5), glm::epsilon<float>())) ? 0 : 1;
+
+		glm::vec3 const M = 2.0f * A;
+		Error += glm::all(glm::equal(M, glm::vec3(2, 4, 6), glm::epsilon<float>())) ? 0 : 1;
+
+		glm::vec3 const N = 2.0f / B;
+		Error += glm::all(glm::equal(N, glm::vec3(0.5, 2.0 / 5.0, 2.0 / 6.0), glm::epsilon<float>())) ? 0 : 1;
+	}
+
+	{
+		glm::ivec3 A(1.0f, 2.0f, 3.0f);
+		glm::ivec3 B(4.0f, 5.0f, 6.0f);
+
+		A += B;
+		Error += A == glm::ivec3(5, 7, 9) ? 0 : 1;
+
+		A += 1;
+		Error += A == glm::ivec3(6, 8, 10) ? 0 : 1;
+	}
+	{
+		glm::ivec3 A(1.0f, 2.0f, 3.0f);
+		glm::ivec3 B(4.0f, 5.0f, 6.0f);
+
+		B -= A;
+		Error += B == glm::ivec3(3, 3, 3) ? 0 : 1;
+
+		B -= 1;
+		Error += B == glm::ivec3(2, 2, 2) ? 0 : 1;
+	}
+	{
+		glm::ivec3 A(1.0f, 2.0f, 3.0f);
+		glm::ivec3 B(4.0f, 5.0f, 6.0f);
+
+		A *= B;
+		Error += A == glm::ivec3(4, 10, 18) ? 0 : 1;
+
+		A *= 2;
+		Error += A == glm::ivec3(8, 20, 36) ? 0 : 1;
+	}
+	{
+		glm::ivec3 A(1.0f, 2.0f, 3.0f);
+		glm::ivec3 B(4.0f, 4.0f, 6.0f);
+
+		B /= A;
+		Error += B == glm::ivec3(4, 2, 2) ? 0 : 1;
+
+		B /= 2;
+		Error += B == glm::ivec3(2, 1, 1) ? 0 : 1;
+	}
+	{
+		glm::ivec3 B(2);
+
+		B /= B.y;
+		Error += B == glm::ivec3(1) ? 0 : 1;
+	}
+
+	{
+		glm::ivec3 A(1.0f, 2.0f, 3.0f);
+		glm::ivec3 B = -A;
+		Error += B == glm::ivec3(-1.0f, -2.0f, -3.0f) ? 0 : 1;
+	}
+
+	{
+		glm::ivec3 A(1.0f, 2.0f, 3.0f);
+		glm::ivec3 B = --A;
+		Error += B == glm::ivec3(0.0f, 1.0f, 2.0f) ? 0 : 1;
+	}
+
+	{
+		glm::ivec3 A(1.0f, 2.0f, 3.0f);
+		glm::ivec3 B = A--;
+		Error += B == glm::ivec3(1.0f, 2.0f, 3.0f) ? 0 : 1;
+		Error += A == glm::ivec3(0.0f, 1.0f, 2.0f) ? 0 : 1;
+	}
+
+	{
+		glm::ivec3 A(1.0f, 2.0f, 3.0f);
+		glm::ivec3 B = ++A;
+		Error += B == glm::ivec3(2.0f, 3.0f, 4.0f) ? 0 : 1;
+	}
+
+	{
+		glm::ivec3 A(1.0f, 2.0f, 3.0f);
+		glm::ivec3 B = A++;
+		Error += B == glm::ivec3(1.0f, 2.0f, 3.0f) ? 0 : 1;
+		Error += A == glm::ivec3(2.0f, 3.0f, 4.0f) ? 0 : 1;
+	}
+
+	return Error;
+}
+
+int test_vec3_size()
+{
+	int Error = 0;
+	
+	Error += sizeof(glm::vec3) == sizeof(glm::lowp_vec3) ? 0 : 1;
+	Error += sizeof(glm::vec3) == sizeof(glm::mediump_vec3) ? 0 : 1;
+	Error += sizeof(glm::vec3) == sizeof(glm::highp_vec3) ? 0 : 1;
+	Error += 12 == sizeof(glm::mediump_vec3) ? 0 : 1;
+	Error += sizeof(glm::dvec3) == sizeof(glm::lowp_dvec3) ? 0 : 1;
+	Error += sizeof(glm::dvec3) == sizeof(glm::mediump_dvec3) ? 0 : 1;
+	Error += sizeof(glm::dvec3) == sizeof(glm::highp_dvec3) ? 0 : 1;
+	Error += 24 == sizeof(glm::highp_dvec3) ? 0 : 1;
+	Error += glm::vec3().length() == 3 ? 0 : 1;
+	Error += glm::dvec3().length() == 3 ? 0 : 1;
+	Error += glm::vec3::length() == 3 ? 0 : 1;
+	Error += glm::dvec3::length() == 3 ? 0 : 1;
+
+	GLM_CONSTEXPR std::size_t Length = glm::vec3::length();
+	Error += Length == 3 ? 0 : 1;
+
+	return Error;
+}
+
+int test_vec3_swizzle3_2()
+{
+	int Error = 0;
+
+#	if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR
+	{
+		glm::ivec3 v(1, 2, 3);
+		glm::ivec2 u;
+
+		// Can not assign a vec3 swizzle to a vec2
+		//u = v.xyz;    //Illegal
+		//u = v.rgb;    //Illegal
+		//u = v.stp;    //Illegal
+
+		u = v.xx;       Error += (u.x == 1 && u.y == 1) ? 0 : 1;
+		u = v.xy;       Error += (u.x == 1 && u.y == 2) ? 0 : 1;
+		u = v.xz;       Error += (u.x == 1 && u.y == 3) ? 0 : 1;
+		u = v.yx;       Error += (u.x == 2 && u.y == 1) ? 0 : 1;
+		u = v.yy;       Error += (u.x == 2 && u.y == 2) ? 0 : 1;
+		u = v.yz;       Error += (u.x == 2 && u.y == 3) ? 0 : 1;
+		u = v.zx;       Error += (u.x == 3 && u.y == 1) ? 0 : 1;
+		u = v.zy;       Error += (u.x == 3 && u.y == 2) ? 0 : 1;
+		u = v.zz;       Error += (u.x == 3 && u.y == 3) ? 0 : 1;
+
+		u = v.rr;       Error += (u.r == 1 && u.g == 1) ? 0 : 1;
+		u = v.rg;       Error += (u.r == 1 && u.g == 2) ? 0 : 1;
+		u = v.rb;       Error += (u.r == 1 && u.g == 3) ? 0 : 1;
+		u = v.gr;       Error += (u.r == 2 && u.g == 1) ? 0 : 1;
+		u = v.gg;       Error += (u.r == 2 && u.g == 2) ? 0 : 1;
+		u = v.gb;       Error += (u.r == 2 && u.g == 3) ? 0 : 1;
+		u = v.br;       Error += (u.r == 3 && u.g == 1) ? 0 : 1;
+		u = v.bg;       Error += (u.r == 3 && u.g == 2) ? 0 : 1;
+		u = v.bb;       Error += (u.r == 3 && u.g == 3) ? 0 : 1;
+
+		u = v.ss;       Error += (u.s == 1 && u.t == 1) ? 0 : 1;
+		u = v.st;       Error += (u.s == 1 && u.t == 2) ? 0 : 1;
+		u = v.sp;       Error += (u.s == 1 && u.t == 3) ? 0 : 1;
+		u = v.ts;       Error += (u.s == 2 && u.t == 1) ? 0 : 1;
+		u = v.tt;       Error += (u.s == 2 && u.t == 2) ? 0 : 1;
+		u = v.tp;       Error += (u.s == 2 && u.t == 3) ? 0 : 1;
+		u = v.ps;       Error += (u.s == 3 && u.t == 1) ? 0 : 1;
+		u = v.pt;       Error += (u.s == 3 && u.t == 2) ? 0 : 1;
+		u = v.pp;       Error += (u.s == 3 && u.t == 3) ? 0 : 1;
+		// Mixed member aliases are not valid
+		//u = v.rx;     //Illegal
+		//u = v.sy;     //Illegal
+
+		u = glm::ivec2(1, 2);
+		v = glm::ivec3(1, 2, 3);
+		//v.xx = u;     //Illegal
+		v.xy = u;       Error += (v.x == 1 && v.y == 2 && v.z == 3) ? 0 : 1;
+		v.xz = u;       Error += (v.x == 1 && v.y == 2 && v.z == 2) ? 0 : 1;
+		v.yx = u;       Error += (v.x == 2 && v.y == 1 && v.z == 2) ? 0 : 1;
+		//v.yy = u;     //Illegal
+		v.yz = u;       Error += (v.x == 2 && v.y == 1 && v.z == 2) ? 0 : 1;
+		v.zx = u;       Error += (v.x == 2 && v.y == 1 && v.z == 1) ? 0 : 1;
+		v.zy = u;       Error += (v.x == 2 && v.y == 2 && v.z == 1) ? 0 : 1;
+		//v.zz = u;     //Illegal
+	}
+#	endif//GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR
+
+	return Error;
+}
+
+int test_vec3_swizzle3_3()
+{
+	int Error = 0;
+
+#	if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR
+	{
+		glm::ivec3 v(1, 2, 3);
+		glm::ivec3 u;
+
+		u = v;          Error += (u.x == 1 && u.y == 2 && u.z == 3) ? 0 : 1;
+
+		u = v.xyz;      Error += (u.x == 1 && u.y == 2 && u.z == 3) ? 0 : 1;
+		u = v.zyx;      Error += (u.x == 3 && u.y == 2 && u.z == 1) ? 0 : 1;
+		u.zyx = v;      Error += (u.x == 3 && u.y == 2 && u.z == 1) ? 0 : 1;
+
+		u = v.rgb;      Error += (u.x == 1 && u.y == 2 && u.z == 3) ? 0 : 1;
+		u = v.bgr;      Error += (u.x == 3 && u.y == 2 && u.z == 1) ? 0 : 1;
+		u.bgr = v;      Error += (u.x == 3 && u.y == 2 && u.z == 1) ? 0 : 1;
+
+		u = v.stp;      Error += (u.x == 1 && u.y == 2 && u.z == 3) ? 0 : 1;
+		u = v.pts;      Error += (u.x == 3 && u.y == 2 && u.z == 1) ? 0 : 1;
+		u.pts = v;      Error += (u.x == 3 && u.y == 2 && u.z == 1) ? 0 : 1;
+	}
+#	endif//GLM_LANG
+
+	return Error;
+}
+
+int test_vec3_swizzle_operators()
+{
+	int Error = 0;
+
+	glm::ivec3 const u = glm::ivec3(1, 2, 3);
+	glm::ivec3 const v = glm::ivec3(10, 20, 30);
+
+#	if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR
+	{
+		glm::ivec3 q;
+
+		// Swizzle, swizzle binary operators
+		q = u.xyz + v.xyz;          Error += (q == (u + v)) ? 0 : 1;
+		q = (u.zyx + v.zyx).zyx;    Error += (q == (u + v)) ? 0 : 1;
+		q = (u.xyz - v.xyz);        Error += (q == (u - v)) ? 0 : 1;
+		q = (u.xyz * v.xyz);        Error += (q == (u * v)) ? 0 : 1;
+		q = (u.xxx * v.xxx);        Error += (q == glm::ivec3(u.x * v.x)) ? 0 : 1;
+		q = (u.xyz / v.xyz);        Error += (q == (u / v)) ? 0 : 1;
+
+		// vec, swizzle binary operators
+		q = u + v.xyz;              Error += (q == (u + v)) ? 0 : 1;
+		q = (u - v.xyz);            Error += (q == (u - v)) ? 0 : 1;
+		q = (u * v.xyz);            Error += (q == (u * v)) ? 0 : 1;
+		q = (u * v.xxx);            Error += (q == v.x * u) ? 0 : 1;
+		q = (u / v.xyz);            Error += (q == (u / v)) ? 0 : 1;
+
+		// swizzle,vec binary operators
+		q = u.xyz + v;              Error += (q == (u + v)) ? 0 : 1;
+		q = (u.xyz - v);            Error += (q == (u - v)) ? 0 : 1;
+		q = (u.xyz * v);            Error += (q == (u * v)) ? 0 : 1;
+		q = (u.xxx * v);            Error += (q == u.x * v) ? 0 : 1;
+		q = (u.xyz / v);            Error += (q == (u / v)) ? 0 : 1;
+	}
+#	endif//GLM_LANG
+
+	// Compile errors
+	//q = (u.yz * v.xyz);
+	//q = (u * v.xy);
+
+	return Error;
+}
+
+int test_vec3_swizzle_functions()
+{
+	int Error = 0;
+
+#	if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR || GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_FUNCTION
+	{
+		// NOTE: template functions cannot pick up the implicit conversion from
+		// a swizzle to the unswizzled type, therefore the operator() must be 
+		// used.  E.g.:
+		//
+		// glm::dot(u.xy, v.xy);        <--- Compile error
+		// glm::dot(u.xy(), v.xy());    <--- Compiles correctly
+
+		float r;
+
+		// vec2
+		glm::vec2 a(1, 2);
+		glm::vec2 b(10, 20);
+		r = glm::dot(a, b);                 Error += (int(r) == 50) ? 0 : 1;
+		r = glm::dot(glm::vec2(a.xy()), glm::vec2(b.xy()));       Error += (int(r) == 50) ? 0 : 1;
+		r = glm::dot(glm::vec2(a.xy()), glm::vec2(b.yy()));       Error += (int(r) == 60) ? 0 : 1;
+
+		// vec3
+		glm::vec3 u = glm::vec3(1, 2, 3);
+		glm::vec3 v = glm::vec3(10, 20, 30);
+		r = glm::dot(u, v);                 Error += (int(r) == 140) ? 0 : 1;
+		r = glm::dot(u.xyz(), v.zyz());     Error += (int(r) == 160) ? 0 : 1;
+		r = glm::dot(u, v.zyx());           Error += (int(r) == 100) ? 0 : 1;
+		r = glm::dot(u.xyz(), v);           Error += (int(r) == 140) ? 0 : 1;
+		r = glm::dot(u.xy(), v.xy());       Error += (int(r) == 50) ? 0 : 1;
+
+		// vec4
+		glm::vec4 s = glm::vec4(1, 2, 3, 4);
+		glm::vec4 t = glm::vec4(10, 20, 30, 40);
+		r = glm::dot(s, t);                 Error += (int(r) == 300) ? 0 : 1;
+		r = glm::dot(s.xyzw(), t.xyzw());   Error += (int(r) == 300) ? 0 : 1;
+		r = glm::dot(s.xyz(), t.xyz());     Error += (int(r) == 140) ? 0 : 1;
+	}
+#	endif//GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR || GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_FUNCTION
+
+	return Error;
+}
+
+int test_vec3_swizzle_partial()
+{
+	int Error = 0;
+
+#	if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR
+	{
+		glm::vec3 const A(1, 2, 3);
+		glm::vec3 B(A.xy, 3);
+		Error += glm::all(glm::equal(A, B, glm::epsilon<float>())) ? 0 : 1;
+	}
+
+	{
+		glm::ivec3 const A(1, 2, 3);
+		glm::ivec3 const B(1, A.yz);
+		Error += A == B ? 0 : 1;
+	}
+
+	{
+		glm::ivec3 const A(1, 2, 3);
+		glm::ivec3 const B(A.xyz);
+		Error += A == B ? 0 : 1;
+	}
+#	endif//GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR
+
+	return Error;
+}
+
+static int test_operator_increment()
+{
+	int Error = 0;
+
+	glm::ivec3 v0(1);
+	glm::ivec3 v1(v0);
+	glm::ivec3 v2(v0);
+	glm::ivec3 v3 = ++v1;
+	glm::ivec3 v4 = v2++;
+
+	Error += glm::all(glm::equal(v0, v4)) ? 0 : 1;
+	Error += glm::all(glm::equal(v1, v2)) ? 0 : 1;
+	Error += glm::all(glm::equal(v1, v3)) ? 0 : 1;
+
+	int i0(1);
+	int i1(i0);
+	int i2(i0);
+	int i3 = ++i1;
+	int i4 = i2++;
+
+	Error += i0 == i4 ? 0 : 1;
+	Error += i1 == i2 ? 0 : 1;
+	Error += i1 == i3 ? 0 : 1;
+
+	return Error;
+}
+
+static int test_swizzle()
+{
+	int Error = 0;
+
+#	if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR
+	{
+		glm::vec3 A = glm::vec3(1.0f, 2.0f, 3.0f);
+		glm::vec3 B = A.xyz;
+		glm::vec3 C(A.xyz);
+		glm::vec3 D(A.xyz());
+		glm::vec3 E(A.x, A.yz);
+		glm::vec3 F(A.x, A.yz());
+		glm::vec3 G(A.xy, A.z);
+		glm::vec3 H(A.xy(), A.z);
+
+		Error += glm::all(glm::equal(A, B, glm::epsilon<float>())) ? 0 : 1;
+		Error += glm::all(glm::equal(A, C, glm::epsilon<float>())) ? 0 : 1;
+		Error += glm::all(glm::equal(A, D, glm::epsilon<float>())) ? 0 : 1;
+		Error += glm::all(glm::equal(A, E, glm::epsilon<float>())) ? 0 : 1;
+		Error += glm::all(glm::equal(A, F, glm::epsilon<float>())) ? 0 : 1;
+		Error += glm::all(glm::equal(A, G, glm::epsilon<float>())) ? 0 : 1;
+		Error += glm::all(glm::equal(A, H, glm::epsilon<float>())) ? 0 : 1;
+	}
+#	endif//GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR
+
+#	if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR || GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_FUNCTION
+	{
+		glm::vec3 A = glm::vec3(1.0f, 2.0f, 3.0f);
+		glm::vec3 B = A.xyz();
+		glm::vec3 C(A.xyz());
+		glm::vec3 D(A.xyz());
+		glm::vec3 E(A.x, A.yz());
+		glm::vec3 F(A.x, A.yz());
+		glm::vec3 G(A.xy(), A.z);
+		glm::vec3 H(A.xy(), A.z);
+
+		Error += glm::all(glm::equal(A, B, glm::epsilon<float>())) ? 0 : 1;
+		Error += glm::all(glm::equal(A, C, glm::epsilon<float>())) ? 0 : 1;
+		Error += glm::all(glm::equal(A, D, glm::epsilon<float>())) ? 0 : 1;
+		Error += glm::all(glm::equal(A, E, glm::epsilon<float>())) ? 0 : 1;
+		Error += glm::all(glm::equal(A, F, glm::epsilon<float>())) ? 0 : 1;
+		Error += glm::all(glm::equal(A, G, glm::epsilon<float>())) ? 0 : 1;
+		Error += glm::all(glm::equal(A, H, glm::epsilon<float>())) ? 0 : 1;
+	}
+#	endif//GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR || GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_FUNCTION
+
+	return Error;
+}
+
+static int test_constexpr()
+{
+#if GLM_HAS_CONSTEXPR
+	static_assert(glm::vec3::length() == 3, "GLM: Failed constexpr");
+	static_assert(glm::vec3(1.0f).x > 0.0f, "GLM: Failed constexpr");
+	static_assert(glm::vec3(1.0f, -1.0f, -1.0f).x > 0.0f, "GLM: Failed constexpr");
+	static_assert(glm::vec3(1.0f, -1.0f, -1.0f).y < 0.0f, "GLM: Failed constexpr");
+#endif
+
+	return 0;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_vec3_ctor();
+	Error += test_bvec3_ctor();
+	Error += test_vec3_operators();
+	Error += test_vec3_size();
+	Error += test_operator_increment();
+	Error += test_constexpr();
+
+	Error += test_swizzle();
+	Error += test_vec3_swizzle3_2();
+	Error += test_vec3_swizzle3_3();
+	Error += test_vec3_swizzle_partial();
+	Error += test_vec3_swizzle_operators();
+	Error += test_vec3_swizzle_functions();
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/core/core_type_vec4.cpp b/3rdparty/glm/source/test/core/core_type_vec4.cpp
new file mode 100644
index 0000000..5d65259
--- /dev/null
+++ b/3rdparty/glm/source/test/core/core_type_vec4.cpp
@@ -0,0 +1,850 @@
+#define GLM_FORCE_SWIZZLE
+#include <glm/gtc/constants.hpp>
+#include <glm/gtc/vec1.hpp>
+#include <glm/ext/scalar_relational.hpp>
+#include <glm/ext/vector_relational.hpp>
+#include <glm/vector_relational.hpp>
+#include <glm/vec2.hpp>
+#include <glm/vec3.hpp>
+#include <glm/vec4.hpp>
+#include <cstdio>
+#include <ctime>
+#include <vector>
+
+static glm::vec4 g1;
+static glm::vec4 g2(1);
+static glm::vec4 g3(1, 1, 1, 1);
+
+template <int Value>
+struct mask
+{
+	enum{value = Value};
+};
+
+enum comp
+{
+	X,
+	Y,
+	Z,
+	W
+};
+
+//template<comp X, comp Y, comp Z, comp W>
+//__m128 swizzle(glm::vec4 const& v)
+//{
+//	__m128 Src = _mm_set_ps(v.w, v.z, v.y, v.x);
+//	return _mm_shuffle_ps(Src, Src, mask<(int(W) << 6) | (int(Z) << 4) | (int(Y) << 2) | (int(X) << 0)>::value);
+//}
+
+static int test_vec4_ctor()
+{
+	int Error = 0;
+
+	{
+		glm::ivec4 A(1, 2, 3, 4);
+		glm::ivec4 B(A);
+		Error += glm::all(glm::equal(A, B)) ? 0 : 1;
+	}
+
+#	if GLM_HAS_TRIVIAL_QUERIES
+	//	Error += std::is_trivially_default_constructible<glm::vec4>::value ? 0 : 1;
+	//	Error += std::is_trivially_copy_assignable<glm::vec4>::value ? 0 : 1;
+		Error += std::is_trivially_copyable<glm::vec4>::value ? 0 : 1;
+		Error += std::is_trivially_copyable<glm::dvec4>::value ? 0 : 1;
+		Error += std::is_trivially_copyable<glm::ivec4>::value ? 0 : 1;
+		Error += std::is_trivially_copyable<glm::uvec4>::value ? 0 : 1;
+
+		Error += std::is_copy_constructible<glm::vec4>::value ? 0 : 1;
+#	endif
+
+#if GLM_HAS_INITIALIZER_LISTS
+	{
+		glm::vec4 a{ 0, 1, 2, 3 };
+		std::vector<glm::vec4> v = {
+			{0, 1, 2, 3},
+			{4, 5, 6, 7},
+			{8, 9, 0, 1}};
+	}
+
+	{
+		glm::dvec4 a{ 0, 1, 2, 3 };
+		std::vector<glm::dvec4> v = {
+			{0, 1, 2, 3},
+			{4, 5, 6, 7},
+			{8, 9, 0, 1}};
+	}
+#endif
+
+	{
+		glm::ivec4 const A(1);
+		glm::ivec4 const B(1, 1, 1, 1);
+		
+		Error += A == B ? 0 : 1;
+	}
+	
+	{
+		std::vector<glm::ivec4> Tests;
+		Tests.push_back(glm::ivec4(glm::ivec2(1, 2), 3, 4));
+		Tests.push_back(glm::ivec4(1, glm::ivec2(2, 3), 4));
+		Tests.push_back(glm::ivec4(1, 2, glm::ivec2(3, 4)));
+		Tests.push_back(glm::ivec4(glm::ivec3(1, 2, 3), 4));
+		Tests.push_back(glm::ivec4(1, glm::ivec3(2, 3, 4)));
+		Tests.push_back(glm::ivec4(glm::ivec2(1, 2), glm::ivec2(3, 4)));
+		Tests.push_back(glm::ivec4(1, 2, 3, 4));
+		Tests.push_back(glm::ivec4(glm::ivec4(1, 2, 3, 4)));
+		
+		for(std::size_t i = 0; i < Tests.size(); ++i)
+			Error += Tests[i] == glm::ivec4(1, 2, 3, 4) ? 0 : 1;
+	}
+
+	{
+		glm::vec1 const R(1.0f);
+		glm::vec1 const S(2.0f);
+		glm::vec1 const T(3.0f);
+		glm::vec1 const U(4.0f);
+		glm::vec4 const O(1.0f, 2.0f, 3.0f, 4.0f);
+
+		glm::vec4 const A(R);
+		glm::vec4 const B(1.0f);
+		Error += glm::all(glm::equal(A, B, glm::epsilon<float>())) ? 0 : 1;
+
+		glm::vec4 const C(R, S, T, U);
+		Error += glm::all(glm::equal(C, O, glm::epsilon<float>())) ? 0 : 1;
+
+		glm::vec4 const D(R, 2.0f, 3.0f, 4.0f);
+		Error += glm::all(glm::equal(D, O, glm::epsilon<float>())) ? 0 : 1;
+
+		glm::vec4 const E(1.0f, S, 3.0f, 4.0f);
+		Error += glm::all(glm::equal(E, O, glm::epsilon<float>())) ? 0 : 1;
+
+		glm::vec4 const F(R, S, 3.0f, 4.0f);
+		Error += glm::all(glm::equal(F, O, glm::epsilon<float>())) ? 0 : 1;
+
+		glm::vec4 const G(1.0f, 2.0f, T, 4.0f);
+		Error += glm::all(glm::equal(G, O, glm::epsilon<float>())) ? 0 : 1;
+
+		glm::vec4 const H(R, 2.0f, T, 4.0f);
+		Error += glm::all(glm::equal(H, O, glm::epsilon<float>())) ? 0 : 1;
+
+		glm::vec4 const I(1.0f, S, T, 4.0f);
+		Error += glm::all(glm::equal(I, O, glm::epsilon<float>())) ? 0 : 1;
+
+		glm::vec4 const J(R, S, T, 4.0f);
+		Error += glm::all(glm::equal(J, O, glm::epsilon<float>())) ? 0 : 1;
+
+		glm::vec4 const K(R, 2.0f, 3.0f, U);
+		Error += glm::all(glm::equal(K, O, glm::epsilon<float>())) ? 0 : 1;
+
+		glm::vec4 const L(1.0f, S, 3.0f, U);
+		Error += glm::all(glm::equal(L, O, glm::epsilon<float>())) ? 0 : 1;
+
+		glm::vec4 const M(R, S, 3.0f, U);
+		Error += glm::all(glm::equal(M, O, glm::epsilon<float>())) ? 0 : 1;
+
+		glm::vec4 const N(1.0f, 2.0f, T, U);
+		Error += glm::all(glm::equal(N, O, glm::epsilon<float>())) ? 0 : 1;
+
+		glm::vec4 const P(R, 2.0f, T, U);
+		Error += glm::all(glm::equal(P, O, glm::epsilon<float>())) ? 0 : 1;
+
+		glm::vec4 const Q(1.0f, S, T, U);
+		Error += glm::all(glm::equal(Q, O, glm::epsilon<float>())) ? 0 : 1;
+
+		glm::vec4 const V(R, S, T, U);
+		Error += glm::all(glm::equal(V, O, glm::epsilon<float>())) ? 0 : 1;
+	}
+
+	{
+		glm::vec1 const R(1.0f);
+		glm::dvec1 const S(2.0);
+		glm::vec1 const T(3.0);
+		glm::dvec1 const U(4.0);
+		glm::vec4 const O(1.0f, 2.0, 3.0f, 4.0);
+
+		glm::vec4 const A(R);
+		glm::vec4 const B(1.0);
+		Error += glm::all(glm::equal(A, B, glm::epsilon<float>())) ? 0 : 1;
+
+		glm::vec4 const C(R, S, T, U);
+		Error += glm::all(glm::equal(C, O, glm::epsilon<float>())) ? 0 : 1;
+
+		glm::vec4 const D(R, 2.0f, 3.0, 4.0f);
+		Error += glm::all(glm::equal(D, O, glm::epsilon<float>())) ? 0 : 1;
+
+		glm::vec4 const E(1.0, S, 3.0f, 4.0);
+		Error += glm::all(glm::equal(E, O, glm::epsilon<float>())) ? 0 : 1;
+
+		glm::vec4 const F(R, S, 3.0, 4.0f);
+		Error += glm::all(glm::equal(F, O, glm::epsilon<float>())) ? 0 : 1;
+
+		glm::vec4 const G(1.0f, 2.0, T, 4.0);
+		Error += glm::all(glm::equal(G, O, glm::epsilon<float>())) ? 0 : 1;
+
+		glm::vec4 const H(R, 2.0, T, 4.0);
+		Error += glm::all(glm::equal(H, O, glm::epsilon<float>())) ? 0 : 1;
+
+		glm::vec4 const I(1.0, S, T, 4.0f);
+		Error += glm::all(glm::equal(I, O, glm::epsilon<float>())) ? 0 : 1;
+
+		glm::vec4 const J(R, S, T, 4.0f);
+		Error += glm::all(glm::equal(J, O, glm::epsilon<float>())) ? 0 : 1;
+
+		glm::vec4 const K(R, 2.0f, 3.0, U);
+		Error += glm::all(glm::equal(K, O, glm::epsilon<float>())) ? 0 : 1;
+
+		glm::vec4 const L(1.0f, S, 3.0, U);
+		Error += glm::all(glm::equal(L, O, glm::epsilon<float>())) ? 0 : 1;
+
+		glm::vec4 const M(R, S, 3.0, U);
+		Error += glm::all(glm::equal(M, O, glm::epsilon<float>())) ? 0 : 1;
+
+		glm::vec4 const N(1.0f, 2.0, T, U);
+		Error += glm::all(glm::equal(N, O, glm::epsilon<float>())) ? 0 : 1;
+
+		glm::vec4 const P(R, 2.0, T, U);
+		Error += glm::all(glm::equal(P, O, glm::epsilon<float>())) ? 0 : 1;
+
+		glm::vec4 const Q(1.0f, S, T, U);
+		Error += glm::all(glm::equal(Q, O, glm::epsilon<float>())) ? 0 : 1;
+
+		glm::vec4 const V(R, S, T, U);
+		Error += glm::all(glm::equal(V, O, glm::epsilon<float>())) ? 0 : 1;
+	}
+
+	{
+		glm::vec1 const v1_0(1.0f);
+		glm::vec1 const v1_1(2.0f);
+		glm::vec1 const v1_2(3.0f);
+		glm::vec1 const v1_3(4.0f);
+
+		glm::vec2 const v2_0(1.0f, 2.0f);
+		glm::vec2 const v2_1(2.0f, 3.0f);
+		glm::vec2 const v2_2(3.0f, 4.0f);
+
+		glm::vec3 const v3_0(1.0f, 2.0f, 3.0f);
+		glm::vec3 const v3_1(2.0f, 3.0f, 4.0f);
+
+		glm::vec4 const O(1.0f, 2.0, 3.0f, 4.0);
+
+		glm::vec4 const A(v1_0, v1_1, v2_2);
+		Error += glm::all(glm::equal(A, O, glm::epsilon<float>())) ? 0 : 1;
+
+		glm::vec4 const B(1.0f, 2.0f, v2_2);
+		Error += glm::all(glm::equal(B, O, glm::epsilon<float>())) ? 0 : 1;
+
+		glm::vec4 const C(v1_0, 2.0f, v2_2);
+		Error += glm::all(glm::equal(C, O, glm::epsilon<float>())) ? 0 : 1;
+
+		glm::vec4 const D(1.0f, v1_1, v2_2);
+		Error += glm::all(glm::equal(D, O, glm::epsilon<float>())) ? 0 : 1;
+
+		glm::vec4 const E(v2_0, v1_2, v1_3);
+		Error += glm::all(glm::equal(E, O, glm::epsilon<float>())) ? 0 : 1;
+
+		glm::vec4 const F(v2_0, 3.0, v1_3);
+		Error += glm::all(glm::equal(F, O, glm::epsilon<float>())) ? 0 : 1;
+
+		glm::vec4 const G(v2_0, v1_2, 4.0);
+		Error += glm::all(glm::equal(G, O, glm::epsilon<float>())) ? 0 : 1;
+
+		glm::vec4 const H(v2_0, 3.0f, 4.0);
+		Error += glm::all(glm::equal(H, O, glm::epsilon<float>())) ? 0 : 1;
+	}
+
+	{
+		glm::vec1 const v1_0(1.0f);
+		glm::vec1 const v1_1(2.0f);
+		glm::vec1 const v1_2(3.0f);
+		glm::vec1 const v1_3(4.0f);
+
+		glm::vec2 const v2(2.0f, 3.0f);
+
+		glm::vec4 const O(1.0f, 2.0, 3.0f, 4.0);
+
+		glm::vec4 const A(v1_0, v2, v1_3);
+		Error += glm::all(glm::equal(A, O, glm::epsilon<float>())) ? 0 : 1;
+
+		glm::vec4 const B(v1_0, v2, 4.0);
+		Error += glm::all(glm::equal(B, O, glm::epsilon<float>())) ? 0 : 1;
+
+		glm::vec4 const C(1.0, v2, v1_3);
+		Error += glm::all(glm::equal(C, O, glm::epsilon<float>())) ? 0 : 1;
+
+		glm::vec4 const D(1.0f, v2, 4.0);
+		Error += glm::all(glm::equal(D, O, glm::epsilon<float>())) ? 0 : 1;
+
+		glm::vec4 const E(1.0, v2, 4.0f);
+		Error += glm::all(glm::equal(E, O, glm::epsilon<float>())) ? 0 : 1;
+	}
+
+	return Error;
+}
+
+static int test_bvec4_ctor()
+{
+	int Error = 0;
+
+	glm::bvec4 const A(true);
+	glm::bvec4 const B(true);
+	glm::bvec4 const C(false);
+	glm::bvec4 const D = A && B;
+	glm::bvec4 const E = A && C;
+	glm::bvec4 const F = A || C;
+
+	Error += D == glm::bvec4(true) ? 0 : 1;
+	Error += E == glm::bvec4(false) ? 0 : 1;
+	Error += F == glm::bvec4(true) ? 0 : 1;
+
+	bool const G = A == C;
+	bool const H = A != C;
+	Error += !G ? 0 : 1;
+	Error += H ? 0 : 1;
+
+	return Error;
+}
+
+static int test_operators()
+{
+	int Error = 0;
+	
+	{
+		glm::ivec4 A(1);
+		glm::ivec4 B(1);
+		bool R = A != B;
+		bool S = A == B;
+
+		Error += (S && !R) ? 0 : 1;
+	}
+
+	{
+		glm::vec4 const A(1.0f, 2.0f, 3.0f, 4.0f);
+		glm::vec4 const B(4.0f, 5.0f, 6.0f, 7.0f);
+
+		glm::vec4 const C = A + B;
+		Error += glm::all(glm::equal(C, glm::vec4(5, 7, 9, 11), glm::epsilon<float>())) ? 0 : 1;
+
+		glm::vec4 const D = B - A;
+		Error += glm::all(glm::equal(D, glm::vec4(3, 3, 3, 3), glm::epsilon<float>())) ? 0 : 1;
+
+		glm::vec4 const E = A * B;
+		Error += glm::all(glm::equal(E, glm::vec4(4, 10, 18, 28), glm::epsilon<float>()) )? 0 : 1;
+
+		glm::vec4 const F = B / A;
+		Error += glm::all(glm::equal(F, glm::vec4(4, 2.5, 2, 7.0f / 4.0f), glm::epsilon<float>())) ? 0 : 1;
+
+		glm::vec4 const G = A + 1.0f;
+		Error += glm::all(glm::equal(G, glm::vec4(2, 3, 4, 5), glm::epsilon<float>())) ? 0 : 1;
+
+		glm::vec4 const H = B - 1.0f;
+		Error += glm::all(glm::equal(H, glm::vec4(3, 4, 5, 6), glm::epsilon<float>())) ? 0 : 1;
+
+		glm::vec4 const I = A * 2.0f;
+		Error += glm::all(glm::equal(I, glm::vec4(2, 4, 6, 8), glm::epsilon<float>())) ? 0 : 1;
+
+		glm::vec4 const J = B / 2.0f;
+		Error += glm::all(glm::equal(J, glm::vec4(2, 2.5, 3, 3.5), glm::epsilon<float>())) ? 0 : 1;
+
+		glm::vec4 const K = 1.0f + A;
+		Error += glm::all(glm::equal(K, glm::vec4(2, 3, 4, 5), glm::epsilon<float>())) ? 0 : 1;
+
+		glm::vec4 const L = 1.0f - B;
+		Error += glm::all(glm::equal(L, glm::vec4(-3, -4, -5, -6), glm::epsilon<float>())) ? 0 : 1;
+
+		glm::vec4 const M = 2.0f * A;
+		Error += glm::all(glm::equal(M, glm::vec4(2, 4, 6, 8), glm::epsilon<float>())) ? 0 : 1;
+
+		glm::vec4 const N = 2.0f / B;
+		Error += glm::all(glm::equal(N, glm::vec4(0.5, 2.0 / 5.0, 2.0 / 6.0, 2.0 / 7.0), glm::epsilon<float>())) ? 0 : 1;
+	}
+
+	{
+		glm::ivec4 A(1.0f, 2.0f, 3.0f, 4.0f);
+		glm::ivec4 B(4.0f, 5.0f, 6.0f, 7.0f);
+
+		A += B;
+		Error += A == glm::ivec4(5, 7, 9, 11) ? 0 : 1;
+
+		A += 1;
+		Error += A == glm::ivec4(6, 8, 10, 12) ? 0 : 1;
+	}
+	{
+		glm::ivec4 A(1.0f, 2.0f, 3.0f, 4.0f);
+		glm::ivec4 B(4.0f, 5.0f, 6.0f, 7.0f);
+
+		B -= A;
+		Error += B == glm::ivec4(3, 3, 3, 3) ? 0 : 1;
+
+		B -= 1;
+		Error += B == glm::ivec4(2, 2, 2, 2) ? 0 : 1;
+	}
+	{
+		glm::ivec4 A(1.0f, 2.0f, 3.0f, 4.0f);
+		glm::ivec4 B(4.0f, 5.0f, 6.0f, 7.0f);
+
+		A *= B;
+		Error += A == glm::ivec4(4, 10, 18, 28) ? 0 : 1;
+
+		A *= 2;
+		Error += A == glm::ivec4(8, 20, 36, 56) ? 0 : 1;
+	}
+	{
+		glm::ivec4 A(1.0f, 2.0f, 2.0f, 4.0f);
+		glm::ivec4 B(4.0f, 4.0f, 8.0f, 8.0f);
+
+		B /= A;
+		Error += B == glm::ivec4(4, 2, 4, 2) ? 0 : 1;
+
+		B /= 2;
+		Error += B == glm::ivec4(2, 1, 2, 1) ? 0 : 1;
+	}
+	{
+		glm::ivec4 B(2);
+
+		B /= B.y;
+		Error += B == glm::ivec4(1) ? 0 : 1;
+	}
+
+	{
+		glm::ivec4 A(1.0f, 2.0f, 3.0f, 4.0f);
+		glm::ivec4 B = -A;
+		Error += B == glm::ivec4(-1.0f, -2.0f, -3.0f, -4.0f) ? 0 : 1;
+	}
+
+	{
+		glm::ivec4 A(1.0f, 2.0f, 3.0f, 4.0f);
+		glm::ivec4 B = --A;
+		Error += B == glm::ivec4(0.0f, 1.0f, 2.0f, 3.0f) ? 0 : 1;
+	}
+
+	{
+		glm::ivec4 A(1.0f, 2.0f, 3.0f, 4.0f);
+		glm::ivec4 B = A--;
+		Error += B == glm::ivec4(1.0f, 2.0f, 3.0f, 4.0f) ? 0 : 1;
+		Error += A == glm::ivec4(0.0f, 1.0f, 2.0f, 3.0f) ? 0 : 1;
+	}
+
+	{
+		glm::ivec4 A(1.0f, 2.0f, 3.0f, 4.0f);
+		glm::ivec4 B = ++A;
+		Error += B == glm::ivec4(2.0f, 3.0f, 4.0f, 5.0f) ? 0 : 1;
+	}
+
+	{
+		glm::ivec4 A(1.0f, 2.0f, 3.0f, 4.0f);
+		glm::ivec4 B = A++;
+		Error += B == glm::ivec4(1.0f, 2.0f, 3.0f, 4.0f) ? 0 : 1;
+		Error += A == glm::ivec4(2.0f, 3.0f, 4.0f, 5.0f) ? 0 : 1;
+	}
+
+	return Error;
+}
+
+static int test_equal()
+{
+	int Error = 0;
+
+	{
+		glm::uvec4 const A(1, 2, 3, 4);
+		glm::uvec4 const B(1, 2, 3, 4);
+		Error += A == B ? 0 : 1;
+		Error += A != B ? 1 : 0;
+	}
+
+	{
+		glm::ivec4 const A(1, 2, 3, 4);
+		glm::ivec4 const B(1, 2, 3, 4);
+		Error += A == B ? 0 : 1;
+		Error += A != B ? 1 : 0;
+	}
+
+	return Error;
+}
+
+static int test_size()
+{
+	int Error = 0;
+
+	Error += sizeof(glm::vec4) == sizeof(glm::lowp_vec4) ? 0 : 1;
+	Error += sizeof(glm::vec4) == sizeof(glm::mediump_vec4) ? 0 : 1;
+	Error += sizeof(glm::vec4) == sizeof(glm::highp_vec4) ? 0 : 1;
+	Error += 16 == sizeof(glm::mediump_vec4) ? 0 : 1;
+	Error += sizeof(glm::dvec4) == sizeof(glm::lowp_dvec4) ? 0 : 1;
+	Error += sizeof(glm::dvec4) == sizeof(glm::mediump_dvec4) ? 0 : 1;
+	Error += sizeof(glm::dvec4) == sizeof(glm::highp_dvec4) ? 0 : 1;
+	Error += 32 == sizeof(glm::highp_dvec4) ? 0 : 1;
+	Error += glm::vec4().length() == 4 ? 0 : 1;
+	Error += glm::dvec4().length() == 4 ? 0 : 1;
+	Error += glm::vec4::length() == 4 ? 0 : 1;
+	Error += glm::dvec4::length() == 4 ? 0 : 1;
+
+	return Error;
+}
+
+static int test_swizzle_partial()
+{
+	int Error = 0;
+
+	glm::vec4 const A(1, 2, 3, 4);
+
+#	if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR
+	{
+		glm::vec4 B(A.xy, A.zw);
+		Error += glm::all(glm::equal(A, B, glm::epsilon<float>())) ? 0 : 1;
+	}
+	{
+		glm::vec4 B(A.xy, 3.0f, 4.0f);
+		Error += glm::all(glm::equal(A, B, glm::epsilon<float>())) ? 0 : 1;
+	}
+	{
+		glm::vec4 B(1.0f, A.yz, 4.0f);
+		Error += glm::all(glm::equal(A, B, glm::epsilon<float>())) ? 0 : 1;
+	}
+	{
+		glm::vec4 B(1.0f, 2.0f, A.zw);
+		Error += glm::all(glm::equal(A, B, glm::epsilon<float>())) ? 0 : 1;
+	}
+
+	{
+		glm::vec4 B(A.xyz, 4.0f);
+		Error += glm::all(glm::equal(A, B, glm::epsilon<float>())) ? 0 : 1;
+	}
+	{
+		glm::vec4 B(1.0f, A.yzw);
+		Error += glm::all(glm::equal(A, B, glm::epsilon<float>())) ? 0 : 1;
+	}
+#	endif//GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR || GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_FUNCTION
+
+	return Error;
+}
+
+static int test_swizzle()
+{
+	int Error = 0;
+
+#	if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR
+	{
+		glm::ivec4 A = glm::ivec4(1.0f, 2.0f, 3.0f, 4.0f);
+		glm::ivec4 B = A.xyzw;
+		glm::ivec4 C(A.xyzw);
+		glm::ivec4 D(A.xyzw());
+		glm::ivec4 E(A.x, A.yzw);
+		glm::ivec4 F(A.x, A.yzw());
+		glm::ivec4 G(A.xyz, A.w);
+		glm::ivec4 H(A.xyz(), A.w);
+		glm::ivec4 I(A.xy, A.zw);
+		glm::ivec4 J(A.xy(), A.zw());
+		glm::ivec4 K(A.x, A.y, A.zw);
+		glm::ivec4 L(A.x, A.yz, A.w);
+		glm::ivec4 M(A.xy, A.z, A.w);
+
+		Error += glm::all(glm::equal(A, B)) ? 0 : 1;
+		Error += glm::all(glm::equal(A, C)) ? 0 : 1;
+		Error += glm::all(glm::equal(A, D)) ? 0 : 1;
+		Error += glm::all(glm::equal(A, E)) ? 0 : 1;
+		Error += glm::all(glm::equal(A, F)) ? 0 : 1;
+		Error += glm::all(glm::equal(A, G)) ? 0 : 1;
+		Error += glm::all(glm::equal(A, H)) ? 0 : 1;
+		Error += glm::all(glm::equal(A, I)) ? 0 : 1;
+		Error += glm::all(glm::equal(A, J)) ? 0 : 1;
+		Error += glm::all(glm::equal(A, K)) ? 0 : 1;
+		Error += glm::all(glm::equal(A, L)) ? 0 : 1;
+		Error += glm::all(glm::equal(A, M)) ? 0 : 1;
+	}
+#	endif//GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR
+
+#	if GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR || GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_FUNCTION
+	{
+		glm::vec4 A = glm::vec4(1.0f, 2.0f, 3.0f, 4.0f);
+		glm::vec4 B = A.xyzw();
+		glm::vec4 C(A.xyzw());
+		glm::vec4 D(A.xyzw());
+		glm::vec4 E(A.x, A.yzw());
+		glm::vec4 F(A.x, A.yzw());
+		glm::vec4 G(A.xyz(), A.w);
+		glm::vec4 H(A.xyz(), A.w);
+		glm::vec4 I(A.xy(), A.zw());
+		glm::vec4 J(A.xy(), A.zw());
+		glm::vec4 K(A.x, A.y, A.zw());
+		glm::vec4 L(A.x, A.yz(), A.w);
+		glm::vec4 M(A.xy(), A.z, A.w);
+
+		Error += glm::all(glm::equal(A, B, glm::epsilon<float>())) ? 0 : 1;
+		Error += glm::all(glm::equal(A, C, glm::epsilon<float>())) ? 0 : 1;
+		Error += glm::all(glm::equal(A, D, glm::epsilon<float>())) ? 0 : 1;
+		Error += glm::all(glm::equal(A, E, glm::epsilon<float>())) ? 0 : 1;
+		Error += glm::all(glm::equal(A, F, glm::epsilon<float>())) ? 0 : 1;
+		Error += glm::all(glm::equal(A, G, glm::epsilon<float>())) ? 0 : 1;
+		Error += glm::all(glm::equal(A, H, glm::epsilon<float>())) ? 0 : 1;
+		Error += glm::all(glm::equal(A, I, glm::epsilon<float>())) ? 0 : 1;
+		Error += glm::all(glm::equal(A, J, glm::epsilon<float>())) ? 0 : 1;
+		Error += glm::all(glm::equal(A, K, glm::epsilon<float>())) ? 0 : 1;
+		Error += glm::all(glm::equal(A, L, glm::epsilon<float>())) ? 0 : 1;
+		Error += glm::all(glm::equal(A, M, glm::epsilon<float>())) ? 0 : 1;
+	}
+#	endif//GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_OPERATOR || GLM_CONFIG_SWIZZLE == GLM_SWIZZLE_FUNCTION
+
+	return Error;
+}
+
+static int test_operator_increment()
+{
+	int Error = 0;
+
+	glm::ivec4 v0(1);
+	glm::ivec4 v1(v0);
+	glm::ivec4 v2(v0);
+	glm::ivec4 v3 = ++v1;
+	glm::ivec4 v4 = v2++;
+
+	Error += glm::all(glm::equal(v0, v4)) ? 0 : 1;
+	Error += glm::all(glm::equal(v1, v2)) ? 0 : 1;
+	Error += glm::all(glm::equal(v1, v3)) ? 0 : 1;
+
+	int i0(1);
+	int i1(i0);
+	int i2(i0);
+	int i3 = ++i1;
+	int i4 = i2++;
+
+	Error += i0 == i4 ? 0 : 1;
+	Error += i1 == i2 ? 0 : 1;
+	Error += i1 == i3 ? 0 : 1;
+
+	return Error;
+}
+
+struct AoS
+{
+	glm::vec4 A;
+	glm::vec3 B;
+	glm::vec3 C;
+	glm::vec2 D;
+};
+
+static int test_perf_AoS(std::size_t Size)
+{
+	int Error = 0;
+
+	std::vector<AoS> In;
+	std::vector<AoS> Out;
+	In.resize(Size);
+	Out.resize(Size);
+
+	std::clock_t StartTime = std::clock();
+
+	for(std::size_t i = 0; i < In.size(); ++i)
+		Out[i] = In[i];
+
+	std::clock_t EndTime = std::clock();
+
+	std::printf("AoS: %d\n", static_cast<int>(EndTime - StartTime));
+
+	return Error;
+}
+
+static int test_perf_SoA(std::size_t Size)
+{
+	int Error = 0;
+
+	std::vector<glm::vec4> InA;
+	std::vector<glm::vec3> InB;
+	std::vector<glm::vec3> InC;
+	std::vector<glm::vec2> InD;
+	std::vector<glm::vec4> OutA;
+	std::vector<glm::vec3> OutB;
+	std::vector<glm::vec3> OutC;
+	std::vector<glm::vec2> OutD;
+
+	InA.resize(Size);
+	InB.resize(Size);
+	InC.resize(Size);
+	InD.resize(Size);
+	OutA.resize(Size);
+	OutB.resize(Size);
+	OutC.resize(Size);
+	OutD.resize(Size);
+
+	std::clock_t StartTime = std::clock();
+
+	for(std::size_t i = 0; i < InA.size(); ++i)
+	{
+		OutA[i] = InA[i];
+		OutB[i] = InB[i];
+		OutC[i] = InC[i];
+		OutD[i] = InD[i];
+	}
+
+	std::clock_t EndTime = std::clock();
+
+	std::printf("SoA: %d\n", static_cast<int>(EndTime - StartTime));
+
+	return Error;
+}
+
+namespace heap
+{
+	struct A
+	{
+		float f;
+	};
+
+	struct B : public A
+	{
+		float g;
+		glm::vec4 v;
+	};
+
+	static int test()
+	{
+		int Error = 0;
+
+		A* p = new B;
+		p->f = 0.0f;
+		delete p;
+
+		Error += sizeof(B) == sizeof(glm::vec4) + sizeof(float) * 2 ? 0 : 1;
+
+		return Error;
+	}
+}//namespace heap
+
+static int test_simd()
+{
+	int Error = 0;
+
+	glm::vec4 const a(std::clock(), std::clock(), std::clock(), std::clock());
+	glm::vec4 const b(std::clock(), std::clock(), std::clock(), std::clock());
+
+	glm::vec4 const c(b * a);
+	glm::vec4 const d(a + c);
+
+	Error += glm::all(glm::greaterThanEqual(d, glm::vec4(0))) ? 0 : 1;
+
+	return Error;
+}
+
+static int test_inheritance()
+{
+	struct my_vec4 : public glm::vec4
+	{
+		my_vec4()
+			: glm::vec4(76.f, 75.f, 74.f, 73.f)
+			, member(82)
+		{}
+
+		int member;
+	};
+
+	int Error = 0;
+
+	my_vec4 v;
+
+	Error += v.member == 82 ? 0 : 1;
+	Error += glm::equal(v.x, 76.f, glm::epsilon<float>()) ? 0 : 1;
+	Error += glm::equal(v.y, 75.f, glm::epsilon<float>()) ? 0 : 1;
+	Error += glm::equal(v.z, 74.f, glm::epsilon<float>()) ? 0 : 1;
+	Error += glm::equal(v.w, 73.f, glm::epsilon<float>()) ? 0 : 1;
+
+	return Error;
+}
+
+static int test_constexpr()
+{
+#if GLM_HAS_CONSTEXPR
+	static_assert(glm::vec4::length() == 4, "GLM: Failed constexpr");
+	static_assert(glm::vec4(1.0f).x > 0.0f, "GLM: Failed constexpr");
+	static_assert(glm::vec4(1.0f, -1.0f, -1.0f, -1.0f).x > 0.0f, "GLM: Failed constexpr");
+	static_assert(glm::vec4(1.0f, -1.0f, -1.0f, -1.0f).y < 0.0f, "GLM: Failed constexpr");
+#endif
+
+	return 0;
+}
+/*
+static int test_simd_gen()
+{
+	int Error = 0;
+
+	int const C = static_cast<int>(std::clock());
+	int const D = static_cast<int>(std::clock());
+
+	glm::ivec4 const A(C);
+	glm::ivec4 const B(D);
+
+	Error += A != B ? 0 : 1;
+
+	return Error;
+}
+*/
+int main()
+{
+	int Error = 0;
+
+	//Error += test_simd_gen();
+
+/*
+	{
+		glm::ivec4 const a1(2);
+		glm::ivec4 const b1 = a1 >> 1;
+
+		__m128i const e1 = _mm_set1_epi32(2);
+		__m128i const f1 = _mm_srli_epi32(e1, 1);
+
+		glm::ivec4 const g1 = *reinterpret_cast<glm::ivec4 const* const>(&f1);
+
+		glm::ivec4 const a2(-2);
+		glm::ivec4 const b2 = a2 >> 1;
+
+		__m128i const e2 = _mm_set1_epi32(-1);
+		__m128i const f2 = _mm_srli_epi32(e2, 1);
+
+		glm::ivec4 const g2 = *reinterpret_cast<glm::ivec4 const* const>(&f2);
+
+		std::printf("GNI\n");
+	}
+
+	{
+		glm::uvec4 const a1(2);
+		glm::uvec4 const b1 = a1 >> 1u;
+
+		__m128i const e1 = _mm_set1_epi32(2);
+		__m128i const f1 = _mm_srli_epi32(e1, 1);
+
+		glm::uvec4 const g1 = *reinterpret_cast<glm::uvec4 const* const>(&f1);
+
+		glm::uvec4 const a2(-1);
+		glm::uvec4 const b2 = a2 >> 1u;
+
+		__m128i const e2 = _mm_set1_epi32(-1);
+		__m128i const f2 = _mm_srli_epi32(e2, 1);
+
+		glm::uvec4 const g2 = *reinterpret_cast<glm::uvec4 const* const>(&f2);
+
+		std::printf("GNI\n");
+	}
+*/
+
+#	ifdef NDEBUG
+	std::size_t const Size(1000000);
+#	else
+	std::size_t const Size(1);
+#	endif//NDEBUG
+
+	Error += test_perf_AoS(Size);
+	Error += test_perf_SoA(Size);
+
+	Error += test_vec4_ctor();
+	Error += test_bvec4_ctor();
+	Error += test_size();
+	Error += test_operators();
+	Error += test_equal();
+	Error += test_swizzle();
+	Error += test_swizzle_partial();
+	Error += test_simd();
+	Error += test_operator_increment();
+	Error += heap::test();
+	Error += test_inheritance();
+	Error += test_constexpr();
+
+	return Error;
+}
+
diff --git a/3rdparty/glm/source/test/ext/CMakeLists.txt b/3rdparty/glm/source/test/ext/CMakeLists.txt
new file mode 100644
index 0000000..40c91ba
--- /dev/null
+++ b/3rdparty/glm/source/test/ext/CMakeLists.txt
@@ -0,0 +1,55 @@
+glmCreateTestGTC(ext_matrix_relational)
+glmCreateTestGTC(ext_matrix_transform)
+glmCreateTestGTC(ext_matrix_common)
+glmCreateTestGTC(ext_matrix_integer)
+glmCreateTestGTC(ext_matrix_int2x2_sized)
+glmCreateTestGTC(ext_matrix_int2x3_sized)
+glmCreateTestGTC(ext_matrix_int2x4_sized)
+glmCreateTestGTC(ext_matrix_int3x2_sized)
+glmCreateTestGTC(ext_matrix_int3x3_sized)
+glmCreateTestGTC(ext_matrix_int3x4_sized)
+glmCreateTestGTC(ext_matrix_int4x2_sized)
+glmCreateTestGTC(ext_matrix_int4x3_sized)
+glmCreateTestGTC(ext_matrix_int4x4_sized)
+glmCreateTestGTC(ext_matrix_uint2x2_sized)
+glmCreateTestGTC(ext_matrix_uint2x3_sized)
+glmCreateTestGTC(ext_matrix_uint2x4_sized)
+glmCreateTestGTC(ext_matrix_uint3x2_sized)
+glmCreateTestGTC(ext_matrix_uint3x3_sized)
+glmCreateTestGTC(ext_matrix_uint3x4_sized)
+glmCreateTestGTC(ext_matrix_uint4x2_sized)
+glmCreateTestGTC(ext_matrix_uint4x3_sized)
+glmCreateTestGTC(ext_matrix_uint4x4_sized)
+glmCreateTestGTC(ext_quaternion_common)
+glmCreateTestGTC(ext_quaternion_exponential)
+glmCreateTestGTC(ext_quaternion_geometric)
+glmCreateTestGTC(ext_quaternion_relational)
+glmCreateTestGTC(ext_quaternion_transform)
+glmCreateTestGTC(ext_quaternion_trigonometric)
+glmCreateTestGTC(ext_quaternion_type)
+glmCreateTestGTC(ext_scalar_common)
+glmCreateTestGTC(ext_scalar_constants)
+glmCreateTestGTC(ext_scalar_int_sized)
+glmCreateTestGTC(ext_scalar_uint_sized)
+glmCreateTestGTC(ext_scalar_integer)
+glmCreateTestGTC(ext_scalar_ulp)
+glmCreateTestGTC(ext_scalar_reciprocal)
+glmCreateTestGTC(ext_scalar_relational)
+glmCreateTestGTC(ext_vec1)
+glmCreateTestGTC(ext_vector_bool1)
+glmCreateTestGTC(ext_vector_common)
+glmCreateTestGTC(ext_vector_iec559)
+glmCreateTestGTC(ext_vector_int1_sized)
+glmCreateTestGTC(ext_vector_int2_sized)
+glmCreateTestGTC(ext_vector_int3_sized)
+glmCreateTestGTC(ext_vector_int4_sized)
+glmCreateTestGTC(ext_vector_integer)
+glmCreateTestGTC(ext_vector_integer_sized)
+glmCreateTestGTC(ext_vector_uint1_sized)
+glmCreateTestGTC(ext_vector_uint2_sized)
+glmCreateTestGTC(ext_vector_uint3_sized)
+glmCreateTestGTC(ext_vector_uint4_sized)
+glmCreateTestGTC(ext_vector_reciprocal)
+glmCreateTestGTC(ext_vector_relational)
+glmCreateTestGTC(ext_vector_ulp)
+
diff --git a/3rdparty/glm/source/test/ext/ext_matrix_clip_space.cpp b/3rdparty/glm/source/test/ext/ext_matrix_clip_space.cpp
new file mode 100644
index 0000000..ca84c19
--- /dev/null
+++ b/3rdparty/glm/source/test/ext/ext_matrix_clip_space.cpp
@@ -0,0 +1,13 @@
+#include <glm/ext/matrix_relational.hpp>
+#include <glm/ext/matrix_clip_space.hpp>
+#include <glm/ext/matrix_float4x4.hpp>
+#include <glm/ext/vector_relational.hpp>
+#include <glm/ext/vector_float4.hpp>
+#include <glm/ext/vector_float3.hpp>
+
+int main()
+{
+	int Error = 0;
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/ext/ext_matrix_common.cpp b/3rdparty/glm/source/test/ext/ext_matrix_common.cpp
new file mode 100644
index 0000000..df0c3fe
--- /dev/null
+++ b/3rdparty/glm/source/test/ext/ext_matrix_common.cpp
@@ -0,0 +1,53 @@
+#include <glm/ext/matrix_common.hpp>
+#include <glm/ext/matrix_double4x4.hpp>
+#include <glm/ext/matrix_float4x4.hpp>
+#include <glm/ext/matrix_relational.hpp>
+#include <glm/ext/vector_bool4.hpp>
+
+static int test_mix()
+{
+	int Error = 0;
+
+	{
+		glm::mat4 A(2);
+		glm::mat4 B(4);
+		glm::mat4 C = glm::mix(A, B, 0.5f);
+		glm::bvec4 const D = glm::equal(C, glm::mat4(3), 1);
+		Error += glm::all(D) ? 0 : 1;
+	}
+
+	{
+		glm::mat4 A(2);
+		glm::mat4 B(4);
+		glm::mat4 C = glm::mix(A, B, 0.5);
+		glm::bvec4 const D = glm::equal(C, glm::mat4(3), 1);
+		Error += glm::all(D) ? 0 : 1;
+	}
+
+	{
+		glm::dmat4 A(2);
+		glm::dmat4 B(4);
+		glm::dmat4 C = glm::mix(A, B, 0.5);
+		glm::bvec4 const D = glm::equal(C, glm::dmat4(3), 1);
+		Error += glm::all(D) ? 0 : 1;
+	}
+
+	{
+		glm::dmat4 A(2);
+		glm::dmat4 B(4);
+		glm::dmat4 C = glm::mix(A, B, 0.5f);
+		glm::bvec4 const D = glm::equal(C, glm::dmat4(3), 1);
+		Error += glm::all(D) ? 0 : 1;
+	}
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_mix();
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/ext/ext_matrix_int2x2_sized.cpp b/3rdparty/glm/source/test/ext/ext_matrix_int2x2_sized.cpp
new file mode 100644
index 0000000..93b6e86
--- /dev/null
+++ b/3rdparty/glm/source/test/ext/ext_matrix_int2x2_sized.cpp
@@ -0,0 +1,28 @@
+#include <glm/ext/matrix_int2x2_sized.hpp>
+
+#if GLM_HAS_STATIC_ASSERT
+	static_assert(sizeof(glm::i8mat2x2) == 4, "int8 size isn't 1 byte on this platform");
+	static_assert(sizeof(glm::i16mat2x2) == 8, "int16 size isn't 2 bytes on this platform");
+	static_assert(sizeof(glm::i32mat2x2) == 16, "int32 size isn't 4 bytes on this platform");
+	static_assert(sizeof(glm::i64mat2x2) == 32, "int64 size isn't 8 bytes on this platform");
+#endif
+
+static int test_comp()
+{
+	int Error = 0;
+
+	Error += sizeof(glm::i8mat2x2) < sizeof(glm::i16mat2x2) ? 0 : 1;
+	Error += sizeof(glm::i16mat2x2) < sizeof(glm::i32mat2x2) ? 0 : 1;
+	Error += sizeof(glm::i32mat2x2) < sizeof(glm::i64mat2x2) ? 0 : 1;
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_comp();
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/ext/ext_matrix_int2x3_sized.cpp b/3rdparty/glm/source/test/ext/ext_matrix_int2x3_sized.cpp
new file mode 100644
index 0000000..058f57b
--- /dev/null
+++ b/3rdparty/glm/source/test/ext/ext_matrix_int2x3_sized.cpp
@@ -0,0 +1,28 @@
+#include <glm/ext/matrix_int2x3_sized.hpp>
+
+#if GLM_HAS_STATIC_ASSERT
+static_assert(sizeof(glm::i8mat2x3) == 6, "int8 size isn't 1 byte on this platform");
+static_assert(sizeof(glm::i16mat2x3) == 12, "int16 size isn't 2 bytes on this platform");
+static_assert(sizeof(glm::i32mat2x3) == 24, "int32 size isn't 4 bytes on this platform");
+static_assert(sizeof(glm::i64mat2x3) == 48, "int64 size isn't 8 bytes on this platform");
+#endif
+
+static int test_comp()
+{
+	int Error = 0;
+
+	Error += sizeof(glm::i8mat2x3) < sizeof(glm::i16mat2x3) ? 0 : 1;
+	Error += sizeof(glm::i16mat2x3) < sizeof(glm::i32mat2x3) ? 0 : 1;
+	Error += sizeof(glm::i32mat2x3) < sizeof(glm::i64mat2x3) ? 0 : 1;
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_comp();
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/ext/ext_matrix_int2x4_sized.cpp b/3rdparty/glm/source/test/ext/ext_matrix_int2x4_sized.cpp
new file mode 100644
index 0000000..c20198d
--- /dev/null
+++ b/3rdparty/glm/source/test/ext/ext_matrix_int2x4_sized.cpp
@@ -0,0 +1,28 @@
+#include <glm/ext/matrix_int2x4_sized.hpp>
+
+#if GLM_HAS_STATIC_ASSERT
+static_assert(sizeof(glm::i8mat2x4) == 8, "int8 size isn't 1 byte on this platform");
+static_assert(sizeof(glm::i16mat2x4) == 16, "int16 size isn't 2 bytes on this platform");
+static_assert(sizeof(glm::i32mat2x4) == 32, "int32 size isn't 4 bytes on this platform");
+static_assert(sizeof(glm::i64mat2x4) == 64, "int64 size isn't 8 bytes on this platform");
+#endif
+
+static int test_comp()
+{
+	int Error = 0;
+
+	Error += sizeof(glm::i8mat2x4) < sizeof(glm::i16mat2x4) ? 0 : 1;
+	Error += sizeof(glm::i16mat2x4) < sizeof(glm::i32mat2x4) ? 0 : 1;
+	Error += sizeof(glm::i32mat2x4) < sizeof(glm::i64mat2x4) ? 0 : 1;
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_comp();
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/ext/ext_matrix_int3x2_sized.cpp b/3rdparty/glm/source/test/ext/ext_matrix_int3x2_sized.cpp
new file mode 100644
index 0000000..1d14029
--- /dev/null
+++ b/3rdparty/glm/source/test/ext/ext_matrix_int3x2_sized.cpp
@@ -0,0 +1,28 @@
+#include <glm/ext/matrix_int3x2_sized.hpp>
+
+#if GLM_HAS_STATIC_ASSERT
+static_assert(sizeof(glm::i8mat3x2) == 6, "int8 size isn't 1 byte on this platform");
+static_assert(sizeof(glm::i16mat3x2) == 12, "int16 size isn't 2 bytes on this platform");
+static_assert(sizeof(glm::i32mat3x2) == 24, "int32 size isn't 4 bytes on this platform");
+static_assert(sizeof(glm::i64mat3x2) == 48, "int64 size isn't 8 bytes on this platform");
+#endif
+
+static int test_comp()
+{
+	int Error = 0;
+
+	Error += sizeof(glm::i8mat3x2) < sizeof(glm::i16mat3x2) ? 0 : 1;
+	Error += sizeof(glm::i16mat3x2) < sizeof(glm::i32mat3x2) ? 0 : 1;
+	Error += sizeof(glm::i32mat3x2) < sizeof(glm::i64mat3x2) ? 0 : 1;
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_comp();
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/ext/ext_matrix_int3x3_sized.cpp b/3rdparty/glm/source/test/ext/ext_matrix_int3x3_sized.cpp
new file mode 100644
index 0000000..d82836c
--- /dev/null
+++ b/3rdparty/glm/source/test/ext/ext_matrix_int3x3_sized.cpp
@@ -0,0 +1,28 @@
+#include <glm/ext/matrix_int3x3_sized.hpp>
+
+#if GLM_HAS_STATIC_ASSERT
+static_assert(sizeof(glm::i8mat3x3) == 9, "int8 size isn't 1 byte on this platform");
+static_assert(sizeof(glm::i16mat3x3) == 18, "int16 size isn't 2 bytes on this platform");
+static_assert(sizeof(glm::i32mat3x3) == 36, "int32 size isn't 4 bytes on this platform");
+static_assert(sizeof(glm::i64mat3x3) == 72, "int64 size isn't 8 bytes on this platform");
+#endif
+
+static int test_comp()
+{
+	int Error = 0;
+
+	Error += sizeof(glm::i8mat3x3) < sizeof(glm::i16mat3x3) ? 0 : 1;
+	Error += sizeof(glm::i16mat3x3) < sizeof(glm::i32mat3x3) ? 0 : 1;
+	Error += sizeof(glm::i32mat3x3) < sizeof(glm::i64mat3x3) ? 0 : 1;
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_comp();
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/ext/ext_matrix_int3x4_sized.cpp b/3rdparty/glm/source/test/ext/ext_matrix_int3x4_sized.cpp
new file mode 100644
index 0000000..52b7d52
--- /dev/null
+++ b/3rdparty/glm/source/test/ext/ext_matrix_int3x4_sized.cpp
@@ -0,0 +1,28 @@
+#include <glm/ext/matrix_int3x4_sized.hpp>
+
+#if GLM_HAS_STATIC_ASSERT
+static_assert(sizeof(glm::i8mat3x4) == 12, "int8 size isn't 1 byte on this platform");
+static_assert(sizeof(glm::i16mat3x4) == 24, "int16 size isn't 2 bytes on this platform");
+static_assert(sizeof(glm::i32mat3x4) == 48, "int32 size isn't 4 bytes on this platform");
+static_assert(sizeof(glm::i64mat3x4) == 96, "int64 size isn't 8 bytes on this platform");
+#endif
+
+static int test_comp()
+{
+	int Error = 0;
+
+	Error += sizeof(glm::i8mat3x4) < sizeof(glm::i16mat3x4) ? 0 : 1;
+	Error += sizeof(glm::i16mat3x4) < sizeof(glm::i32mat3x4) ? 0 : 1;
+	Error += sizeof(glm::i32mat3x4) < sizeof(glm::i64mat3x4) ? 0 : 1;
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_comp();
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/ext/ext_matrix_int4x2_sized.cpp b/3rdparty/glm/source/test/ext/ext_matrix_int4x2_sized.cpp
new file mode 100644
index 0000000..3c4566f
--- /dev/null
+++ b/3rdparty/glm/source/test/ext/ext_matrix_int4x2_sized.cpp
@@ -0,0 +1,28 @@
+#include <glm/ext/matrix_int4x2_sized.hpp>
+
+#if GLM_HAS_STATIC_ASSERT
+static_assert(sizeof(glm::i8mat4x2) == 8, "int8 size isn't 1 byte on this platform");
+static_assert(sizeof(glm::i16mat4x2) == 16, "int16 size isn't 2 bytes on this platform");
+static_assert(sizeof(glm::i32mat4x2) == 32, "int32 size isn't 4 bytes on this platform");
+static_assert(sizeof(glm::i64mat4x2) == 64, "int64 size isn't 8 bytes on this platform");
+#endif
+
+static int test_comp()
+{
+	int Error = 0;
+
+	Error += sizeof(glm::i8mat4x2) < sizeof(glm::i16mat4x2) ? 0 : 1;
+	Error += sizeof(glm::i16mat4x2) < sizeof(glm::i32mat4x2) ? 0 : 1;
+	Error += sizeof(glm::i32mat4x2) < sizeof(glm::i64mat4x2) ? 0 : 1;
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_comp();
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/ext/ext_matrix_int4x3_sized.cpp b/3rdparty/glm/source/test/ext/ext_matrix_int4x3_sized.cpp
new file mode 100644
index 0000000..fb882af
--- /dev/null
+++ b/3rdparty/glm/source/test/ext/ext_matrix_int4x3_sized.cpp
@@ -0,0 +1,28 @@
+#include <glm/ext/matrix_int4x3_sized.hpp>
+
+#if GLM_HAS_STATIC_ASSERT
+static_assert(sizeof(glm::i8mat4x3) == 12, "int8 size isn't 1 byte on this platform");
+static_assert(sizeof(glm::i16mat4x3) == 24, "int16 size isn't 2 bytes on this platform");
+static_assert(sizeof(glm::i32mat4x3) == 48, "int32 size isn't 4 bytes on this platform");
+static_assert(sizeof(glm::i64mat4x3) == 96, "int64 size isn't 8 bytes on this platform");
+#endif
+
+static int test_comp()
+{
+	int Error = 0;
+
+	Error += sizeof(glm::i8mat4x3) < sizeof(glm::i16mat4x3) ? 0 : 1;
+	Error += sizeof(glm::i16mat4x3) < sizeof(glm::i32mat4x3) ? 0 : 1;
+	Error += sizeof(glm::i32mat4x3) < sizeof(glm::i64mat4x3) ? 0 : 1;
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_comp();
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/ext/ext_matrix_int4x4_sized.cpp b/3rdparty/glm/source/test/ext/ext_matrix_int4x4_sized.cpp
new file mode 100644
index 0000000..02769ea
--- /dev/null
+++ b/3rdparty/glm/source/test/ext/ext_matrix_int4x4_sized.cpp
@@ -0,0 +1,28 @@
+#include <glm/ext/matrix_int4x4_sized.hpp>
+
+#if GLM_HAS_STATIC_ASSERT
+static_assert(sizeof(glm::i8mat4x4) == 16, "int8 size isn't 1 byte on this platform");
+static_assert(sizeof(glm::i16mat4x4) == 32, "int16 size isn't 2 bytes on this platform");
+static_assert(sizeof(glm::i32mat4x4) == 64, "int32 size isn't 4 bytes on this platform");
+static_assert(sizeof(glm::i64mat4x4) == 128, "int64 size isn't 8 bytes on this platform");
+#endif
+
+static int test_comp()
+{
+	int Error = 0;
+
+	Error += sizeof(glm::i8mat4x4) < sizeof(glm::i16mat4x4) ? 0 : 1;
+	Error += sizeof(glm::i16mat4x4) < sizeof(glm::i32mat4x4) ? 0 : 1;
+	Error += sizeof(glm::i32mat4x4) < sizeof(glm::i64mat4x4) ? 0 : 1;
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_comp();
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/ext/ext_matrix_integer.cpp b/3rdparty/glm/source/test/ext/ext_matrix_integer.cpp
new file mode 100644
index 0000000..c26d557
--- /dev/null
+++ b/3rdparty/glm/source/test/ext/ext_matrix_integer.cpp
@@ -0,0 +1,237 @@
+#include <glm/ext/matrix_relational.hpp>
+#include <glm/ext/matrix_integer.hpp>
+#include <glm/ext/matrix_int2x2.hpp>
+#include <glm/ext/matrix_int2x3.hpp>
+#include <glm/ext/matrix_int2x4.hpp>
+#include <glm/ext/matrix_int3x2.hpp>
+#include <glm/ext/matrix_int3x3.hpp>
+#include <glm/ext/matrix_int3x4.hpp>
+#include <glm/ext/matrix_int4x2.hpp>
+#include <glm/ext/matrix_int4x3.hpp>
+#include <glm/ext/matrix_int4x4.hpp>
+
+using namespace glm;
+
+int test_matrixCompMult()
+{
+	int Error = 0;
+
+	{
+		imat2 m(0, 1, 2, 3);
+		imat2 n = matrixCompMult(m, m);
+		imat2 expected = imat2(0, 1, 4, 9);
+		Error += all(equal(n, expected)) ? 0 : 1;
+	}
+
+	{
+		imat2x3 m(0, 1, 2, 3, 4, 5);
+		imat2x3 n = matrixCompMult(m, m);
+		imat2x3 expected = imat2x3(0, 1, 4, 9, 16, 25);
+		Error += all(equal(n, expected)) ? 0 : 1;
+	}
+
+	{
+		imat2x4 m(0, 1, 2, 3, 4, 5, 6, 7);
+		imat2x4 n = matrixCompMult(m, m);
+		imat2x4 expected = imat2x4(0, 1, 4, 9, 16, 25, 36, 49);
+		Error += all(equal(n, expected)) ? 0 : 1;
+	}
+
+	{
+		imat3 m(0, 1, 2, 3, 4, 5, 6, 7, 8);
+		imat3 n = matrixCompMult(m, m);
+		imat3 expected = imat3(0, 1, 4, 9, 16, 25, 36, 49, 64);
+		Error += all(equal(n, expected)) ? 0 : 1;
+	}
+
+	{
+		imat3x2 m(0, 1, 2, 3, 4, 5);
+		imat3x2 n = matrixCompMult(m, m);
+		imat3x2 expected = imat3x2(0, 1, 4, 9, 16, 25);
+		Error += all(equal(n, expected)) ? 0 : 1;
+	}
+
+	{
+		imat3x4 m(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11);
+		imat3x4 n = matrixCompMult(m, m);
+		imat3x4 expected = imat3x4(0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121);
+		Error += all(equal(n, expected)) ? 0 : 1;
+	}
+
+	{
+		imat4 m(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
+		imat4 n = matrixCompMult(m, m);
+		imat4 expected = imat4(0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121, 144, 169, 196, 225);
+		Error += all(equal(n, expected)) ? 0 : 1;
+	}
+
+	{
+		imat4x2 m(0, 1, 2, 3, 4, 5, 6, 7);
+		imat4x2 n = matrixCompMult(m, m);
+		imat4x2 expected = imat4x2(0, 1, 4, 9, 16, 25, 36, 49);
+		Error += all(equal(n, expected)) ? 0 : 1;
+	}
+
+	{
+		imat4x3 m(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11);
+		imat4x3 n = matrixCompMult(m, m);
+		imat4x3 expected = imat4x3(0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121);
+		Error += all(equal(n, expected)) ? 0 : 1;
+	}
+
+	return Error;
+}
+
+int test_outerProduct()
+{
+	int Error = 0;
+
+	{ 
+		glm::imat2x2 const m = glm::outerProduct(glm::ivec2(1), glm::ivec2(1));
+		Error += all(equal(m, glm::imat2x2(1, 1, 1, 1))) ? 0 : 1;
+	}
+	{ 
+		glm::imat2x3 const m = glm::outerProduct(glm::ivec3(1), glm::ivec2(1)); 
+		Error += all(equal(m, glm::imat2x3(1, 1, 1, 1, 1, 1))) ? 0 : 1;
+	}
+	{ 
+		glm::imat2x4 const m = glm::outerProduct(glm::ivec4(1), glm::ivec2(1)); 
+		Error += all(equal(m, glm::imat2x4(1, 1, 1, 1, 1, 1, 1, 1))) ? 0 : 1;
+	}
+
+	{
+		glm::imat3x2 const m = glm::outerProduct(glm::ivec2(1), glm::ivec3(1));
+		Error += all(equal(m, glm::imat3x2(1, 1, 1, 1, 1, 1))) ? 0 : 1;
+	}
+	{ 
+		glm::imat3x3 const m = glm::outerProduct(glm::ivec3(1), glm::ivec3(1)); 
+		Error += all(equal(m, glm::imat3x3(1, 1, 1, 1, 1, 1, 1, 1, 1))) ? 0 : 1;
+	}
+	{
+		glm::imat3x4 const m = glm::outerProduct(glm::ivec4(1), glm::ivec3(1));
+		Error += all(equal(m, glm::imat3x4(1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1))) ? 0 : 1;
+	}
+
+  
+	{ 
+		glm::imat4x2 const m = glm::outerProduct(glm::ivec2(1), glm::ivec4(1)); 
+		Error += all(equal(m, glm::imat4x2(1, 1, 1, 1, 1, 1, 1, 1))) ? 0 : 1;
+	}
+	{ 
+		glm::imat4x3 const m = glm::outerProduct(glm::ivec3(1), glm::ivec4(1));
+		Error += all(equal(m, glm::imat4x3(1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1))) ? 0 : 1;
+	}
+	{ 
+		glm::imat4x4 const m = glm::outerProduct(glm::ivec4(1), glm::ivec4(1)); 
+		Error += all(equal(m, glm::imat4x4(1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1))) ? 0 : 1;
+	}
+
+	return Error;
+}
+
+int test_transpose()
+{
+	int Error = 0;
+
+	{
+		imat2 const m(0, 1, 2, 3);
+		imat2 const t = transpose(m);
+		imat2 const expected = imat2(0, 2, 1, 3);
+		Error += all(equal(t, expected)) ? 0 : 1;
+	}
+
+	{
+		imat2x3 m(0, 1, 2, 3, 4, 5);
+		imat3x2 t = transpose(m);
+		imat3x2 const expected = imat3x2(0, 3, 1, 4, 2, 5);
+		Error += all(equal(t, expected)) ? 0 : 1;
+	}
+
+	{
+		imat2x4 m(0, 1, 2, 3, 4, 5, 6, 7);
+		imat4x2 t = transpose(m);
+		imat4x2 const expected = imat4x2(0, 4, 1, 5, 2, 6, 3, 7);
+		Error += all(equal(t, expected)) ? 0 : 1;
+	}
+
+	{
+		imat3 m(0, 1, 2, 3, 4, 5, 6, 7, 8);
+		imat3 t = transpose(m);
+		imat3 const expected = imat3(0, 3, 6, 1, 4, 7, 2, 5, 8);
+		Error += all(equal(t, expected)) ? 0 : 1;
+	}
+
+	{
+		imat3x2 m(0, 1, 2, 3, 4, 5);
+		imat2x3 t = transpose(m);
+		imat2x3 const expected = imat2x3(0, 2, 4, 1, 3, 5);
+		Error += all(equal(t, expected)) ? 0 : 1;
+	}
+
+	{
+		imat3x4 m(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11);
+		imat4x3 t = transpose(m);
+		imat4x3 const expected = imat4x3(0, 4, 8, 1, 5, 9, 2, 6, 10, 3, 7, 11);
+		Error += all(equal(t, expected)) ? 0 : 1;
+	}
+
+	{
+		imat4 m(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
+		imat4 t = transpose(m);
+		imat4 const expected = imat4(0, 4, 8, 12, 1, 5, 9, 13, 2, 6, 10, 14, 3, 7, 11, 15);
+		Error += all(equal(t, expected)) ? 0 : 1;
+	}
+
+	{
+		imat4x2 m(0, 1, 2, 3, 4, 5, 6, 7);
+		imat2x4 t = transpose(m);
+		imat2x4 const expected = imat2x4(0, 2, 4, 6, 1, 3, 5, 7);
+		Error += all(equal(t, expected)) ? 0 : 1;
+	}
+
+	{
+		imat4x3 m(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11);
+		imat3x4 t = transpose(m);
+		imat3x4 const expected = imat3x4(0, 3, 6, 9, 1, 4, 7, 10, 2, 5, 8, 11);
+		Error += all(equal(t, expected)) ? 0 : 1;
+	}
+
+	return Error;
+}
+
+int test_determinant()
+{
+	int Error = 0;
+
+	{
+		imat2 const m(1, 1, 1, 1);
+		int const t = determinant(m);
+		Error += t == 0 ? 0 : 1;
+	}
+
+	{
+		imat3 m(1, 1, 1, 1, 1, 1, 1, 1, 1);
+		int t = determinant(m);
+		Error += t == 0 ? 0 : 1;
+	}
+
+	{
+		imat4 m(1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1);
+		int t = determinant(m);
+		Error += t == 0 ? 0 : 1;
+	}
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_matrixCompMult();
+	Error += test_outerProduct();
+	Error += test_transpose();
+	Error += test_determinant();
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/ext/ext_matrix_projection.cpp b/3rdparty/glm/source/test/ext/ext_matrix_projection.cpp
new file mode 100644
index 0000000..88f6ae9
--- /dev/null
+++ b/3rdparty/glm/source/test/ext/ext_matrix_projection.cpp
@@ -0,0 +1,13 @@
+#include <glm/ext/matrix_relational.hpp>
+#include <glm/ext/matrix_projection.hpp>
+#include <glm/ext/matrix_float4x4.hpp>
+#include <glm/ext/vector_relational.hpp>
+#include <glm/ext/vector_float4.hpp>
+#include <glm/ext/vector_float3.hpp>
+
+int main()
+{
+	int Error = 0;
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/ext/ext_matrix_relational.cpp b/3rdparty/glm/source/test/ext/ext_matrix_relational.cpp
new file mode 100644
index 0000000..64c0dae
--- /dev/null
+++ b/3rdparty/glm/source/test/ext/ext_matrix_relational.cpp
@@ -0,0 +1,163 @@
+#include <glm/ext/matrix_relational.hpp>
+#include <glm/ext/matrix_double2x2.hpp>
+#include <glm/ext/matrix_double2x3.hpp>
+#include <glm/ext/matrix_double2x4.hpp>
+#include <glm/ext/matrix_double3x2.hpp>
+#include <glm/ext/matrix_double3x3.hpp>
+#include <glm/ext/matrix_double3x4.hpp>
+#include <glm/ext/matrix_double4x2.hpp>
+#include <glm/ext/matrix_double4x3.hpp>
+#include <glm/ext/matrix_double4x4.hpp>
+#include <glm/ext/vector_double2.hpp>
+#include <glm/ext/vector_double3.hpp>
+#include <glm/ext/vector_double4.hpp>
+#include <glm/ext/matrix_float2x2.hpp>
+#include <glm/ext/matrix_float2x3.hpp>
+#include <glm/ext/matrix_float2x4.hpp>
+#include <glm/ext/matrix_float3x2.hpp>
+#include <glm/ext/matrix_float3x3.hpp>
+#include <glm/ext/matrix_float3x4.hpp>
+#include <glm/ext/matrix_float4x2.hpp>
+#include <glm/ext/matrix_float4x3.hpp>
+#include <glm/ext/matrix_float4x4.hpp>
+#include <glm/ext/vector_float2.hpp>
+#include <glm/ext/vector_float3.hpp>
+#include <glm/ext/vector_float4.hpp>
+#include <glm/ext/scalar_ulp.hpp>
+
+template <typename matType, typename vecType>
+static int test_equal()
+{
+	typedef typename matType::value_type valType;
+
+	valType const Epsilon = static_cast<valType>(0.001f);
+	valType const One = static_cast<valType>(1);
+	valType const Two = static_cast<valType>(2);
+
+	int Error = 0;
+
+	Error += glm::all(glm::equal(matType(One), matType(One), Epsilon)) ? 0 : 1;
+	Error += glm::all(glm::equal(matType(One), matType(Two), vecType(Epsilon))) ? 1 : 0;
+
+	return Error;
+}
+
+template <typename matType, typename vecType>
+static int test_notEqual()
+{
+	typedef typename matType::value_type valType;
+
+	valType const Epsilon = static_cast<valType>(0.001f);
+	valType const One = static_cast<valType>(1);
+	valType const Two = static_cast<valType>(2);
+
+	int Error = 0;
+
+	Error += !glm::any(glm::notEqual(matType(One), matType(One), Epsilon)) ? 0 : 1;
+	Error += !glm::any(glm::notEqual(matType(One), matType(Two), vecType(Epsilon))) ? 1 : 0;
+
+	return Error;
+}
+
+
+template <typename T>
+static int test_equal_ulps()
+{
+	typedef glm::mat<4, 4, T, glm::defaultp> mat4;
+
+	T const One(1);
+	mat4 const Ones(1);
+
+	int Error = 0;
+
+	T const ULP1Plus = glm::nextFloat(One);
+	Error += glm::all(glm::equal(Ones, mat4(ULP1Plus), 1)) ? 0 : 1;
+
+	T const ULP2Plus = glm::nextFloat(ULP1Plus);
+	Error += !glm::all(glm::equal(Ones, mat4(ULP2Plus), 1)) ? 0 : 1;
+
+	T const ULP1Minus = glm::prevFloat(One);
+	Error += glm::all(glm::equal(Ones, mat4(ULP1Minus), 1)) ? 0 : 1;
+
+	T const ULP2Minus = glm::prevFloat(ULP1Minus);
+	Error += !glm::all(glm::equal(Ones, mat4(ULP2Minus), 1)) ? 0 : 1;
+
+	return Error;
+}
+
+template <typename T>
+static int test_notEqual_ulps()
+{
+	typedef glm::mat<4, 4, T, glm::defaultp> mat4;
+
+	T const One(1);
+	mat4 const Ones(1);
+
+	int Error = 0;
+
+	T const ULP1Plus = glm::nextFloat(One);
+	Error += !glm::all(glm::notEqual(Ones, mat4(ULP1Plus), 1)) ? 0 : 1;
+
+	T const ULP2Plus = glm::nextFloat(ULP1Plus);
+	Error += glm::all(glm::notEqual(Ones, mat4(ULP2Plus), 1)) ? 0 : 1;
+
+	T const ULP1Minus = glm::prevFloat(One);
+	Error += !glm::all(glm::notEqual(Ones, mat4(ULP1Minus), 1)) ? 0 : 1;
+
+	T const ULP2Minus = glm::prevFloat(ULP1Minus);
+	Error += glm::all(glm::notEqual(Ones, mat4(ULP2Minus), 1)) ? 0 : 1;
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_equal_ulps<float>();
+	Error += test_equal_ulps<double>();
+	Error += test_notEqual_ulps<float>();
+	Error += test_notEqual_ulps<double>();
+
+	Error += test_equal<glm::mat2x2, glm::vec2>();
+	Error += test_equal<glm::mat2x3, glm::vec2>();
+	Error += test_equal<glm::mat2x4, glm::vec2>();
+	Error += test_equal<glm::mat3x2, glm::vec3>();
+	Error += test_equal<glm::mat3x3, glm::vec3>();
+	Error += test_equal<glm::mat3x4, glm::vec3>();
+	Error += test_equal<glm::mat4x2, glm::vec4>();
+	Error += test_equal<glm::mat4x3, glm::vec4>();
+	Error += test_equal<glm::mat4x4, glm::vec4>();
+
+	Error += test_equal<glm::dmat2x2, glm::dvec2>();
+	Error += test_equal<glm::dmat2x3, glm::dvec2>();
+	Error += test_equal<glm::dmat2x4, glm::dvec2>();
+	Error += test_equal<glm::dmat3x2, glm::dvec3>();
+	Error += test_equal<glm::dmat3x3, glm::dvec3>();
+	Error += test_equal<glm::dmat3x4, glm::dvec3>();
+	Error += test_equal<glm::dmat4x2, glm::dvec4>();
+	Error += test_equal<glm::dmat4x3, glm::dvec4>();
+	Error += test_equal<glm::dmat4x4, glm::dvec4>();
+
+	Error += test_notEqual<glm::mat2x2, glm::vec2>();
+	Error += test_notEqual<glm::mat2x3, glm::vec2>();
+	Error += test_notEqual<glm::mat2x4, glm::vec2>();
+	Error += test_notEqual<glm::mat3x2, glm::vec3>();
+	Error += test_notEqual<glm::mat3x3, glm::vec3>();
+	Error += test_notEqual<glm::mat3x4, glm::vec3>();
+	Error += test_notEqual<glm::mat4x2, glm::vec4>();
+	Error += test_notEqual<glm::mat4x3, glm::vec4>();
+	Error += test_notEqual<glm::mat4x4, glm::vec4>();
+
+	Error += test_notEqual<glm::dmat2x2, glm::dvec2>();
+	Error += test_notEqual<glm::dmat2x3, glm::dvec2>();
+	Error += test_notEqual<glm::dmat2x4, glm::dvec2>();
+	Error += test_notEqual<glm::dmat3x2, glm::dvec3>();
+	Error += test_notEqual<glm::dmat3x3, glm::dvec3>();
+	Error += test_notEqual<glm::dmat3x4, glm::dvec3>();
+	Error += test_notEqual<glm::dmat4x2, glm::dvec4>();
+	Error += test_notEqual<glm::dmat4x3, glm::dvec4>();
+	Error += test_notEqual<glm::dmat4x4, glm::dvec4>();
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/ext/ext_matrix_transform.cpp b/3rdparty/glm/source/test/ext/ext_matrix_transform.cpp
new file mode 100644
index 0000000..cf653b7
--- /dev/null
+++ b/3rdparty/glm/source/test/ext/ext_matrix_transform.cpp
@@ -0,0 +1,61 @@
+#include <glm/ext/matrix_relational.hpp>
+#include <glm/ext/matrix_transform.hpp>
+#include <glm/ext/matrix_float4x4.hpp>
+#include <glm/ext/vector_relational.hpp>
+#include <glm/ext/vector_float4.hpp>
+#include <glm/ext/vector_float3.hpp>
+
+static int test_translate()
+{
+	int Error = 0;
+
+	glm::mat4 const M(1.0f);
+	glm::vec3 const V(1.0f);
+
+	glm::mat4 const T = glm::translate(M, V);
+	Error += glm::all(glm::equal(T[3], glm::vec4(1.0f), glm::epsilon<float>())) ? 0 : 1;
+
+	return Error;
+}
+
+static int test_scale()
+{
+	int Error = 0;
+
+	glm::mat4 const M(1.0f);
+	glm::vec3 const V(2.0f);
+
+	glm::mat4 const S = glm::scale(M, V);
+	glm::mat4 const R = glm::mat4(
+		glm::vec4(2, 0, 0, 0),
+		glm::vec4(0, 2, 0, 0),
+		glm::vec4(0, 0, 2, 0),
+		glm::vec4(0, 0, 0, 1));
+	Error += glm::all(glm::equal(S, R, glm::epsilon<float>())) ? 0 : 1;
+
+	return Error;
+}
+
+static int test_rotate()
+{
+	int Error = 0;
+
+	glm::vec4 const A(1.0f, 0.0f, 0.0f, 1.0f);
+
+	glm::mat4 const R = glm::rotate(glm::mat4(1.0f), glm::radians(90.f), glm::vec3(0, 0, 1));
+	glm::vec4 const B = R * A;
+	Error += glm::all(glm::equal(B, glm::vec4(0.0f, 1.0f, 0.0f, 1.0f), 0.0001f)) ? 0 : 1;
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_translate();
+	Error += test_scale();
+	Error += test_rotate();
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/ext/ext_matrix_uint2x2_sized.cpp b/3rdparty/glm/source/test/ext/ext_matrix_uint2x2_sized.cpp
new file mode 100644
index 0000000..a9bd49c
--- /dev/null
+++ b/3rdparty/glm/source/test/ext/ext_matrix_uint2x2_sized.cpp
@@ -0,0 +1,28 @@
+#include <glm/ext/matrix_uint2x2_sized.hpp>
+
+#if GLM_HAS_STATIC_ASSERT
+	static_assert(sizeof(glm::u8mat2x2) == 4, "uint8 size isn't 1 byte on this platform");
+	static_assert(sizeof(glm::u16mat2x2) == 8, "uint16 size isn't 2 bytes on this platform");
+	static_assert(sizeof(glm::u32mat2x2) == 16, "uint32 size isn't 4 bytes on this platform");
+	static_assert(sizeof(glm::u64mat2x2) == 32, "uint64 size isn't 8 bytes on this platform");
+#endif
+
+static int test_comp()
+{
+	int Error = 0;
+
+	Error += sizeof(glm::u8mat2x2) < sizeof(glm::u16mat2x2) ? 0 : 1;
+	Error += sizeof(glm::u16mat2x2) < sizeof(glm::u32mat2x2) ? 0 : 1;
+	Error += sizeof(glm::u32mat2x2) < sizeof(glm::u64mat2x2) ? 0 : 1;
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_comp();
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/ext/ext_matrix_uint2x3_sized.cpp b/3rdparty/glm/source/test/ext/ext_matrix_uint2x3_sized.cpp
new file mode 100644
index 0000000..0b75893
--- /dev/null
+++ b/3rdparty/glm/source/test/ext/ext_matrix_uint2x3_sized.cpp
@@ -0,0 +1,28 @@
+#include <glm/ext/matrix_uint2x3_sized.hpp>
+
+#if GLM_HAS_STATIC_ASSERT
+static_assert(sizeof(glm::u8mat2x3) == 6, "uint8 size isn't 1 byte on this platform");
+static_assert(sizeof(glm::u16mat2x3) == 12, "uint16 size isn't 2 bytes on this platform");
+static_assert(sizeof(glm::u32mat2x3) == 24, "uint32 size isn't 4 bytes on this platform");
+static_assert(sizeof(glm::u64mat2x3) == 48, "uint64 size isn't 8 bytes on this platform");
+#endif
+
+static int test_comp()
+{
+	int Error = 0;
+
+	Error += sizeof(glm::u8mat2x3) < sizeof(glm::u16mat2x3) ? 0 : 1;
+	Error += sizeof(glm::u16mat2x3) < sizeof(glm::u32mat2x3) ? 0 : 1;
+	Error += sizeof(glm::u32mat2x3) < sizeof(glm::u64mat2x3) ? 0 : 1;
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_comp();
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/ext/ext_matrix_uint2x4_sized.cpp b/3rdparty/glm/source/test/ext/ext_matrix_uint2x4_sized.cpp
new file mode 100644
index 0000000..84af4dd
--- /dev/null
+++ b/3rdparty/glm/source/test/ext/ext_matrix_uint2x4_sized.cpp
@@ -0,0 +1,28 @@
+#include <glm/ext/matrix_uint2x4_sized.hpp>
+
+#if GLM_HAS_STATIC_ASSERT
+static_assert(sizeof(glm::u8mat2x4) == 8, "uint8 size isn't 1 byte on this platform");
+static_assert(sizeof(glm::u16mat2x4) == 16, "uint16 size isn't 2 bytes on this platform");
+static_assert(sizeof(glm::u32mat2x4) == 32, "uint32 size isn't 4 bytes on this platform");
+static_assert(sizeof(glm::u64mat2x4) == 64, "uint64 size isn't 8 bytes on this platform");
+#endif
+
+static int test_comp()
+{
+	int Error = 0;
+
+	Error += sizeof(glm::u8mat2x4) < sizeof(glm::u16mat2x4) ? 0 : 1;
+	Error += sizeof(glm::u16mat2x4) < sizeof(glm::u32mat2x4) ? 0 : 1;
+	Error += sizeof(glm::u32mat2x4) < sizeof(glm::u64mat2x4) ? 0 : 1;
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_comp();
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/ext/ext_matrix_uint3x2_sized.cpp b/3rdparty/glm/source/test/ext/ext_matrix_uint3x2_sized.cpp
new file mode 100644
index 0000000..3c035e2
--- /dev/null
+++ b/3rdparty/glm/source/test/ext/ext_matrix_uint3x2_sized.cpp
@@ -0,0 +1,28 @@
+#include <glm/ext/matrix_uint3x2_sized.hpp>
+
+#if GLM_HAS_STATIC_ASSERT
+static_assert(sizeof(glm::u8mat3x2) == 6, "uint8 size isn't 1 byte on this platform");
+static_assert(sizeof(glm::u16mat3x2) == 12, "uint16 size isn't 2 bytes on this platform");
+static_assert(sizeof(glm::u32mat3x2) == 24, "uint32 size isn't 4 bytes on this platform");
+static_assert(sizeof(glm::u64mat3x2) == 48, "uint64 size isn't 8 bytes on this platform");
+#endif
+
+static int test_comp()
+{
+	int Error = 0;
+
+	Error += sizeof(glm::u8mat3x2) < sizeof(glm::u16mat3x2) ? 0 : 1;
+	Error += sizeof(glm::u16mat3x2) < sizeof(glm::u32mat3x2) ? 0 : 1;
+	Error += sizeof(glm::u32mat3x2) < sizeof(glm::u64mat3x2) ? 0 : 1;
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_comp();
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/ext/ext_matrix_uint3x3_sized.cpp b/3rdparty/glm/source/test/ext/ext_matrix_uint3x3_sized.cpp
new file mode 100644
index 0000000..64384ed
--- /dev/null
+++ b/3rdparty/glm/source/test/ext/ext_matrix_uint3x3_sized.cpp
@@ -0,0 +1,28 @@
+#include <glm/ext/matrix_uint3x3_sized.hpp>
+
+#if GLM_HAS_STATIC_ASSERT
+static_assert(sizeof(glm::u8mat3x3) == 9, "uint8 size isn't 1 byte on this platform");
+static_assert(sizeof(glm::u16mat3x3) == 18, "uint16 size isn't 2 bytes on this platform");
+static_assert(sizeof(glm::u32mat3x3) == 36, "uint32 size isn't 4 bytes on this platform");
+static_assert(sizeof(glm::u64mat3x3) == 72, "uint64 size isn't 8 bytes on this platform");
+#endif
+
+static int test_comp()
+{
+	int Error = 0;
+
+	Error += sizeof(glm::u8mat3x3) < sizeof(glm::u16mat3x3) ? 0 : 1;
+	Error += sizeof(glm::u16mat3x3) < sizeof(glm::u32mat3x3) ? 0 : 1;
+	Error += sizeof(glm::u32mat3x3) < sizeof(glm::u64mat3x3) ? 0 : 1;
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_comp();
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/ext/ext_matrix_uint3x4_sized.cpp b/3rdparty/glm/source/test/ext/ext_matrix_uint3x4_sized.cpp
new file mode 100644
index 0000000..7f743df
--- /dev/null
+++ b/3rdparty/glm/source/test/ext/ext_matrix_uint3x4_sized.cpp
@@ -0,0 +1,28 @@
+#include <glm/ext/matrix_uint3x4_sized.hpp>
+
+#if GLM_HAS_STATIC_ASSERT
+static_assert(sizeof(glm::u8mat3x4) == 12, "uint8 size isn't 1 byte on this platform");
+static_assert(sizeof(glm::u16mat3x4) == 24, "uint16 size isn't 2 bytes on this platform");
+static_assert(sizeof(glm::u32mat3x4) == 48, "uint32 size isn't 4 bytes on this platform");
+static_assert(sizeof(glm::u64mat3x4) == 96, "uint64 size isn't 8 bytes on this platform");
+#endif
+
+static int test_comp()
+{
+	int Error = 0;
+
+	Error += sizeof(glm::u8mat3x4) < sizeof(glm::u16mat3x4) ? 0 : 1;
+	Error += sizeof(glm::u16mat3x4) < sizeof(glm::u32mat3x4) ? 0 : 1;
+	Error += sizeof(glm::u32mat3x4) < sizeof(glm::u64mat3x4) ? 0 : 1;
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_comp();
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/ext/ext_matrix_uint4x2_sized.cpp b/3rdparty/glm/source/test/ext/ext_matrix_uint4x2_sized.cpp
new file mode 100644
index 0000000..2b4453f
--- /dev/null
+++ b/3rdparty/glm/source/test/ext/ext_matrix_uint4x2_sized.cpp
@@ -0,0 +1,28 @@
+#include <glm/ext/matrix_uint4x2_sized.hpp>
+
+#if GLM_HAS_STATIC_ASSERT
+static_assert(sizeof(glm::u8mat4x2) == 8, "uint8 size isn't 1 byte on this platform");
+static_assert(sizeof(glm::u16mat4x2) == 16, "uint16 size isn't 2 bytes on this platform");
+static_assert(sizeof(glm::u32mat4x2) == 32, "uint32 size isn't 4 bytes on this platform");
+static_assert(sizeof(glm::u64mat4x2) == 64, "uint64 size isn't 8 bytes on this platform");
+#endif
+
+static int test_comp()
+{
+	int Error = 0;
+
+	Error += sizeof(glm::u8mat4x2) < sizeof(glm::u16mat4x2) ? 0 : 1;
+	Error += sizeof(glm::u16mat4x2) < sizeof(glm::u32mat4x2) ? 0 : 1;
+	Error += sizeof(glm::u32mat4x2) < sizeof(glm::u64mat4x2) ? 0 : 1;
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_comp();
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/ext/ext_matrix_uint4x3_sized.cpp b/3rdparty/glm/source/test/ext/ext_matrix_uint4x3_sized.cpp
new file mode 100644
index 0000000..2820bde
--- /dev/null
+++ b/3rdparty/glm/source/test/ext/ext_matrix_uint4x3_sized.cpp
@@ -0,0 +1,28 @@
+#include <glm/ext/matrix_uint4x3_sized.hpp>
+
+#if GLM_HAS_STATIC_ASSERT
+static_assert(sizeof(glm::u8mat4x3) == 12, "uint8 size isn't 1 byte on this platform");
+static_assert(sizeof(glm::u16mat4x3) == 24, "uint16 size isn't 2 bytes on this platform");
+static_assert(sizeof(glm::u32mat4x3) == 48, "uint32 size isn't 4 bytes on this platform");
+static_assert(sizeof(glm::u64mat4x3) == 96, "uint64 size isn't 8 bytes on this platform");
+#endif
+
+static int test_comp()
+{
+	int Error = 0;
+
+	Error += sizeof(glm::u8mat4x3) < sizeof(glm::u16mat4x3) ? 0 : 1;
+	Error += sizeof(glm::u16mat4x3) < sizeof(glm::u32mat4x3) ? 0 : 1;
+	Error += sizeof(glm::u32mat4x3) < sizeof(glm::u64mat4x3) ? 0 : 1;
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_comp();
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/ext/ext_matrix_uint4x4_sized.cpp b/3rdparty/glm/source/test/ext/ext_matrix_uint4x4_sized.cpp
new file mode 100644
index 0000000..8f9e239
--- /dev/null
+++ b/3rdparty/glm/source/test/ext/ext_matrix_uint4x4_sized.cpp
@@ -0,0 +1,28 @@
+#include <glm/ext/matrix_uint4x4_sized.hpp>
+
+#if GLM_HAS_STATIC_ASSERT
+static_assert(sizeof(glm::u8mat4x4) == 16, "uint8 size isn't 1 byte on this platform");
+static_assert(sizeof(glm::u16mat4x4) == 32, "uint16 size isn't 2 bytes on this platform");
+static_assert(sizeof(glm::u32mat4x4) == 64, "uint32 size isn't 4 bytes on this platform");
+static_assert(sizeof(glm::u64mat4x4) == 128, "uint64 size isn't 8 bytes on this platform");
+#endif
+
+static int test_comp()
+{
+	int Error = 0;
+
+	Error += sizeof(glm::u8mat4x4) < sizeof(glm::u16mat4x4) ? 0 : 1;
+	Error += sizeof(glm::u16mat4x4) < sizeof(glm::u32mat4x4) ? 0 : 1;
+	Error += sizeof(glm::u32mat4x4) < sizeof(glm::u64mat4x4) ? 0 : 1;
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_comp();
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/ext/ext_quaternion_common.cpp b/3rdparty/glm/source/test/ext/ext_quaternion_common.cpp
new file mode 100644
index 0000000..861aa65
--- /dev/null
+++ b/3rdparty/glm/source/test/ext/ext_quaternion_common.cpp
@@ -0,0 +1,61 @@
+#include <glm/ext/vector_float3.hpp>
+#include <glm/ext/quaternion_common.hpp>
+#include <glm/ext/quaternion_float.hpp>
+#include <glm/ext/quaternion_relational.hpp>
+#include <glm/ext/quaternion_trigonometric.hpp>
+#include <glm/ext/scalar_constants.hpp>
+#include <glm/ext/scalar_relational.hpp>
+
+static int test_conjugate()
+{
+	int Error = 0;
+
+	glm::quat const A(glm::vec3(1, 0, 0), glm::vec3(0, 1, 0));
+	glm::quat const C = glm::conjugate(A);
+	Error += glm::any(glm::notEqual(A, C, glm::epsilon<float>())) ? 0 : 1;
+
+	glm::quat const B = glm::conjugate(C);
+	Error += glm::all(glm::equal(A, B, glm::epsilon<float>())) ? 0 : 1;
+
+	return Error;
+}
+
+static int test_mix()
+{
+	int Error = 0;
+
+	glm::quat const Q1(glm::vec3(1, 0, 0), glm::vec3(1, 0, 0));
+	glm::quat const Q2(glm::vec3(1, 0, 0), glm::vec3(0, 1, 0));
+
+	{
+		glm::quat const Q3 = glm::mix(Q1, Q2, 0.5f);
+		float const F3 = glm::degrees(glm::angle(Q3));
+		Error += glm::equal(F3, 45.0f, 0.001f) ? 0 : 1;
+
+		glm::quat const Q4 = glm::mix(Q2, Q1, 0.5f);
+		float const F4 = glm::degrees(glm::angle(Q4));
+		Error += glm::equal(F4, 45.0f, 0.001f) ? 0 : 1;
+	}
+
+	{
+		glm::quat const Q3 = glm::slerp(Q1, Q2, 0.5f);
+		float const F3 = glm::degrees(glm::angle(Q3));
+		Error += glm::equal(F3, 45.0f, 0.001f) ? 0 : 1;
+
+		glm::quat const Q4 = glm::slerp(Q2, Q1, 0.5f);
+		float const F4 = glm::degrees(glm::angle(Q4));
+		Error += glm::equal(F4, 45.0f, 0.001f) ? 0 : 1;
+	}
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_conjugate();
+	Error += test_mix();
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/ext/ext_quaternion_exponential.cpp b/3rdparty/glm/source/test/ext/ext_quaternion_exponential.cpp
new file mode 100644
index 0000000..fbcdbef
--- /dev/null
+++ b/3rdparty/glm/source/test/ext/ext_quaternion_exponential.cpp
@@ -0,0 +1,87 @@
+#include <glm/ext/quaternion_exponential.hpp>
+#include <glm/ext/quaternion_float.hpp>
+#include <glm/ext/quaternion_float_precision.hpp>
+#include <glm/ext/quaternion_double.hpp>
+#include <glm/ext/quaternion_double_precision.hpp>
+#include <glm/ext/quaternion_relational.hpp>
+#include <glm/ext/vector_float3.hpp>
+#include <glm/ext/vector_float3_precision.hpp>
+#include <glm/ext/vector_double3.hpp>
+#include <glm/ext/vector_double3_precision.hpp>
+#include <glm/ext/scalar_constants.hpp>
+
+template <typename quaType, typename vecType>
+int test_log()
+{
+	typedef typename quaType::value_type T;
+	
+	T const Epsilon = static_cast<T>(0.001f);
+	
+	int Error = 0;
+	
+	quaType const Q(vecType(1, 0, 0), vecType(0, 1, 0));
+	quaType const P = glm::log(Q);
+	Error += glm::any(glm::notEqual(Q, P, Epsilon)) ? 0 : 1;
+	
+	quaType const R = glm::exp(P);
+	Error += glm::all(glm::equal(Q, R, Epsilon)) ? 0 : 1;
+
+	return Error;
+}
+
+template <typename quaType, typename vecType>
+int test_pow()
+{
+	typedef typename quaType::value_type T;
+	
+	T const Epsilon = static_cast<T>(0.001f);
+	
+	int Error = 0;
+	
+	quaType const Q(vecType(1, 0, 0), vecType(0, 1, 0));
+	
+	{
+		T const One = static_cast<T>(1.0f);
+		quaType const P = glm::pow(Q, One);
+		Error += glm::all(glm::equal(Q, P, Epsilon)) ? 0 : 1;
+	}
+	
+	{
+		T const Two = static_cast<T>(2.0f);
+		quaType const P = glm::pow(Q, Two);
+		quaType const R = Q * Q;
+		Error += glm::all(glm::equal(P, R, Epsilon)) ? 0 : 1;
+
+		quaType const U = glm::sqrt(P);
+		Error += glm::all(glm::equal(Q, U, Epsilon)) ? 0 : 1;
+	}
+	
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_log<glm::quat, glm::vec3>();
+	Error += test_log<glm::lowp_quat, glm::lowp_vec3>();
+	Error += test_log<glm::mediump_quat, glm::mediump_vec3>();
+	Error += test_log<glm::highp_quat, glm::highp_vec3>();
+	
+	Error += test_log<glm::dquat, glm::dvec3>();
+	Error += test_log<glm::lowp_dquat, glm::lowp_dvec3>();
+	Error += test_log<glm::mediump_dquat, glm::mediump_dvec3>();
+	Error += test_log<glm::highp_dquat, glm::highp_dvec3>();
+
+	Error += test_pow<glm::quat, glm::vec3>();
+	Error += test_pow<glm::lowp_quat, glm::lowp_vec3>();
+	Error += test_pow<glm::mediump_quat, glm::mediump_vec3>();
+	Error += test_pow<glm::highp_quat, glm::highp_vec3>();
+	
+	Error += test_pow<glm::dquat, glm::dvec3>();
+	Error += test_pow<glm::lowp_dquat, glm::lowp_dvec3>();
+	Error += test_pow<glm::mediump_dquat, glm::mediump_dvec3>();
+	Error += test_pow<glm::highp_dquat, glm::highp_dvec3>();
+	
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/ext/ext_quaternion_geometric.cpp b/3rdparty/glm/source/test/ext/ext_quaternion_geometric.cpp
new file mode 100644
index 0000000..73b5dea
--- /dev/null
+++ b/3rdparty/glm/source/test/ext/ext_quaternion_geometric.cpp
@@ -0,0 +1,88 @@
+#include <glm/gtc/constants.hpp>
+#include <glm/ext/quaternion_geometric.hpp>
+#include <glm/ext/quaternion_float.hpp>
+#include <glm/ext/quaternion_trigonometric.hpp>
+#include <glm/ext/quaternion_float_precision.hpp>
+#include <glm/ext/quaternion_double.hpp>
+#include <glm/ext/quaternion_double_precision.hpp>
+#include <glm/ext/vector_float3.hpp>
+#include <glm/ext/vector_float3_precision.hpp>
+#include <glm/ext/vector_double3.hpp>
+#include <glm/ext/vector_double3_precision.hpp>
+#include <glm/ext/scalar_relational.hpp>
+
+float const Epsilon = 0.001f;
+
+static int test_length()
+{
+	int Error = 0;
+
+	{
+		float const A = glm::length(glm::quat(1, 0, 0, 0));
+		Error += glm::equal(A, 1.0f, Epsilon) ? 0 : 1;
+	}
+
+	{
+		float const A = glm::length(glm::quat(1, glm::vec3(0)));
+		Error += glm::equal(A, 1.0f, Epsilon) ? 0 : 1;
+	}
+
+	{
+		float const A = glm::length(glm::quat(glm::vec3(1, 0, 0), glm::vec3(0, 1, 0)));
+		Error += glm::equal(A, 1.0f, Epsilon) ? 0 : 1;
+	}
+
+	return Error;
+}
+
+static int test_normalize()
+{
+	int Error = 0;
+
+	{
+		glm::quat const A = glm::quat(1, 0, 0, 0);
+		glm::quat const N = glm::normalize(A);
+		Error += glm::all(glm::equal(A, N, Epsilon)) ? 0 : 1;
+	}
+
+	{
+		glm::quat const A = glm::quat(1, glm::vec3(0));
+		glm::quat const N = glm::normalize(A);
+		Error += glm::all(glm::equal(A, N, Epsilon)) ? 0 : 1;
+	}
+
+	return Error;
+}
+
+static int test_dot()
+{
+	int Error = 0;
+
+	{
+		glm::quat const A = glm::quat(1, 0, 0, 0);
+		glm::quat const B = glm::quat(1, 0, 0, 0);
+		float const C = glm::dot(A, B);
+		Error += glm::equal(C, 1.0f, Epsilon) ? 0 : 1;
+	}
+
+	return Error;
+}
+
+static int test_cross()
+{
+	int Error = 0;
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_length();
+	Error += test_normalize();
+	Error += test_dot();
+	Error += test_cross();
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/ext/ext_quaternion_relational.cpp b/3rdparty/glm/source/test/ext/ext_quaternion_relational.cpp
new file mode 100644
index 0000000..7f51fdc
--- /dev/null
+++ b/3rdparty/glm/source/test/ext/ext_quaternion_relational.cpp
@@ -0,0 +1,51 @@
+#include <glm/gtc/constants.hpp>
+#include <glm/ext/quaternion_relational.hpp>
+#include <glm/ext/quaternion_float.hpp>
+#include <glm/ext/quaternion_float_precision.hpp>
+#include <glm/ext/quaternion_double.hpp>
+#include <glm/ext/quaternion_double_precision.hpp>
+#include <glm/ext/vector_float3.hpp>
+#include <glm/ext/vector_float3_precision.hpp>
+#include <glm/ext/vector_double3.hpp>
+#include <glm/ext/vector_double3_precision.hpp>
+
+template <typename quaType>
+static int test_equal()
+{
+	int Error = 0;
+
+	quaType const Q(1, 0, 0, 0);
+	quaType const P(1, 0, 0, 0);
+	Error += glm::all(glm::equal(Q, P, glm::epsilon<float>())) ? 0 : 1;
+
+	return Error;
+}
+
+template <typename quaType>
+static int test_notEqual()
+{
+	int Error = 0;
+
+	quaType const Q(1, 0, 0, 0);
+	quaType const P(1, 0, 0, 0);
+	Error += glm::any(glm::notEqual(Q, P, glm::epsilon<float>())) ? 1 : 0;
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_equal<glm::quat>();
+	Error += test_equal<glm::lowp_quat>();
+	Error += test_equal<glm::mediump_quat>();
+	Error += test_equal<glm::highp_quat>();
+
+	Error += test_notEqual<glm::quat>();
+	Error += test_notEqual<glm::lowp_quat>();
+	Error += test_notEqual<glm::mediump_quat>();
+	Error += test_notEqual<glm::highp_quat>();
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/ext/ext_quaternion_transform.cpp b/3rdparty/glm/source/test/ext/ext_quaternion_transform.cpp
new file mode 100644
index 0000000..fefe88e
--- /dev/null
+++ b/3rdparty/glm/source/test/ext/ext_quaternion_transform.cpp
@@ -0,0 +1,45 @@
+#include <glm/ext/quaternion_transform.hpp>
+#include <glm/ext/quaternion_float.hpp>
+#include <glm/ext/vector_relational.hpp>
+#include <glm/ext/scalar_constants.hpp>
+
+#define GLM_ENABLE_EXPERIMENTAL
+#include <glm/gtx/quaternion.hpp>
+
+static int test_lookAt()
+{
+	int Error(0);
+
+	glm::vec3 eye(0.0f);
+	glm::vec3 center(1.1f, -2.0f, 3.1416f);
+	glm::vec3 up(-0.17f, 7.23f, -1.744f);
+
+	glm::quat test_quat = glm::quatLookAt(glm::normalize(center - eye), up);
+	glm::quat test_mat = glm::conjugate(glm::quat_cast(glm::lookAt(eye, center, up)));
+
+	Error += static_cast<int>(glm::abs(glm::length(test_quat) - 1.0f) > glm::epsilon<float>());
+	Error += static_cast<int>(glm::min(glm::length(test_quat + (-test_mat)), glm::length(test_quat + test_mat)) > glm::epsilon<float>());
+
+	// Test left-handed implementation
+	glm::quat test_quatLH = glm::quatLookAtLH(glm::normalize(center - eye), up);
+	glm::quat test_matLH = glm::conjugate(glm::quat_cast(glm::lookAtLH(eye, center, up)));
+	Error += static_cast<int>(glm::abs(glm::length(test_quatLH) - 1.0f) > glm::epsilon<float>());
+	Error += static_cast<int>(glm::min(glm::length(test_quatLH - test_matLH), glm::length(test_quatLH + test_matLH)) > glm::epsilon<float>());
+ 
+	// Test right-handed implementation
+	glm::quat test_quatRH = glm::quatLookAtRH(glm::normalize(center - eye), up);
+	glm::quat test_matRH = glm::conjugate(glm::quat_cast(glm::lookAtRH(eye, center, up)));
+	Error += static_cast<int>(glm::abs(glm::length(test_quatRH) - 1.0f) > glm::epsilon<float>());
+	Error += static_cast<int>(glm::min(glm::length(test_quatRH - test_matRH), glm::length(test_quatRH + test_matRH)) > glm::epsilon<float>());
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_lookAt();
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/ext/ext_quaternion_trigonometric.cpp b/3rdparty/glm/source/test/ext/ext_quaternion_trigonometric.cpp
new file mode 100644
index 0000000..d237125
--- /dev/null
+++ b/3rdparty/glm/source/test/ext/ext_quaternion_trigonometric.cpp
@@ -0,0 +1,40 @@
+#include <glm/ext/quaternion_trigonometric.hpp>
+#include <glm/ext/quaternion_float.hpp>
+#include <glm/ext/vector_relational.hpp>
+#include <glm/ext/scalar_relational.hpp>
+
+float const Epsilon = 0.001f;
+
+static int test_angle()
+{
+	int Error = 0;
+
+	{
+		glm::quat const Q = glm::quat(glm::vec3(1, 0, 0), glm::vec3(0, 1, 0));
+		float const A = glm::degrees(glm::angle(Q));
+		Error += glm::equal(A, 90.0f, Epsilon) ? 0 : 1;
+	}
+
+	{
+		glm::quat const Q = glm::quat(glm::vec3(0, 1, 0), glm::vec3(1, 0, 0));
+		float const A = glm::degrees(glm::angle(Q));
+		Error += glm::equal(A, 90.0f, Epsilon) ? 0 : 1;
+	}
+
+	{
+		glm::quat const Q = glm::angleAxis(glm::two_pi<float>() - 1.0f, glm::vec3(1, 0, 0));
+		float const A = glm::angle(Q);
+		Error += glm::equal(A, 1.0f, Epsilon) ? 1 : 0;
+	}
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_angle();
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/ext/ext_quaternion_type.cpp b/3rdparty/glm/source/test/ext/ext_quaternion_type.cpp
new file mode 100644
index 0000000..7e61149
--- /dev/null
+++ b/3rdparty/glm/source/test/ext/ext_quaternion_type.cpp
@@ -0,0 +1,113 @@
+#include <glm/gtc/constants.hpp>
+#include <glm/ext/quaternion_relational.hpp>
+#include <glm/ext/quaternion_float.hpp>
+#include <glm/ext/quaternion_float_precision.hpp>
+#include <glm/ext/quaternion_double.hpp>
+#include <glm/ext/quaternion_double_precision.hpp>
+#include <glm/ext/vector_float3.hpp>
+#include <vector>
+
+static int test_ctr()
+{
+	int Error(0);
+
+#	if GLM_HAS_TRIVIAL_QUERIES
+	//	Error += std::is_trivially_default_constructible<glm::quat>::value ? 0 : 1;
+	//	Error += std::is_trivially_default_constructible<glm::dquat>::value ? 0 : 1;
+	//	Error += std::is_trivially_copy_assignable<glm::quat>::value ? 0 : 1;
+	//	Error += std::is_trivially_copy_assignable<glm::dquat>::value ? 0 : 1;
+	Error += std::is_trivially_copyable<glm::quat>::value ? 0 : 1;
+	Error += std::is_trivially_copyable<glm::dquat>::value ? 0 : 1;
+
+	Error += std::is_copy_constructible<glm::quat>::value ? 0 : 1;
+	Error += std::is_copy_constructible<glm::dquat>::value ? 0 : 1;
+#	endif
+
+#	if GLM_HAS_INITIALIZER_LISTS
+	{
+		glm::quat A{0, 1, 2, 3};
+
+		std::vector<glm::quat> B{
+			{0, 1, 2, 3},
+		{0, 1, 2, 3}};
+	}
+#	endif//GLM_HAS_INITIALIZER_LISTS
+
+	return Error;
+}
+
+static int test_two_axis_ctr()
+{
+	int Error = 0;
+
+	glm::quat const q1(glm::vec3(1, 0, 0), glm::vec3(0, 1, 0));
+	glm::vec3 const v1 = q1 * glm::vec3(1, 0, 0);
+	Error += glm::all(glm::equal(v1, glm::vec3(0, 1, 0), 0.0001f)) ? 0 : 1;
+
+	glm::quat const q2 = q1 * q1;
+	glm::vec3 const v2 = q2 * glm::vec3(1, 0, 0);
+	Error += glm::all(glm::equal(v2, glm::vec3(-1, 0, 0), 0.0001f)) ? 0 : 1;
+
+	glm::quat const q3(glm::vec3(1, 0, 0), glm::vec3(-1, 0, 0));
+	glm::vec3 const v3 = q3 * glm::vec3(1, 0, 0);
+	Error += glm::all(glm::equal(v3, glm::vec3(-1, 0, 0), 0.0001f)) ? 0 : 1;
+
+	glm::quat const q4(glm::vec3(0, 1, 0), glm::vec3(0, -1, 0));
+	glm::vec3 const v4 = q4 * glm::vec3(0, 1, 0);
+	Error += glm::all(glm::equal(v4, glm::vec3(0, -1, 0), 0.0001f)) ? 0 : 1;
+
+	glm::quat const q5(glm::vec3(0, 0, 1), glm::vec3(0, 0, -1));
+	glm::vec3 const v5 = q5 * glm::vec3(0, 0, 1);
+	Error += glm::all(glm::equal(v5, glm::vec3(0, 0, -1), 0.0001f)) ? 0 : 1;
+
+	return Error;
+}
+
+static int test_size()
+{
+	int Error = 0;
+
+	std::size_t const A = sizeof(glm::quat);
+	Error += 16 == A ? 0 : 1;
+	std::size_t const B = sizeof(glm::dquat);
+	Error += 32 == B ? 0 : 1;
+	Error += glm::quat().length() == 4 ? 0 : 1;
+	Error += glm::dquat().length() == 4 ? 0 : 1;
+	Error += glm::quat::length() == 4 ? 0 : 1;
+	Error += glm::dquat::length() == 4 ? 0 : 1;
+
+	return Error;
+}
+
+static int test_precision()
+{
+	int Error = 0;
+
+	Error += sizeof(glm::lowp_quat) <= sizeof(glm::mediump_quat) ? 0 : 1;
+	Error += sizeof(glm::mediump_quat) <= sizeof(glm::highp_quat) ? 0 : 1;
+
+	return Error;
+}
+
+static int test_constexpr()
+{
+#if GLM_HAS_CONSTEXPR
+	static_assert(glm::quat::length() == 4, "GLM: Failed constexpr");
+	static_assert(glm::quat(1.0f, glm::vec3(0.0f)).w > 0.0f, "GLM: Failed constexpr");
+#endif
+
+	return 0;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_ctr();
+	Error += test_two_axis_ctr();
+	Error += test_size();
+	Error += test_precision();
+	Error += test_constexpr();
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/ext/ext_scalar_common.cpp b/3rdparty/glm/source/test/ext/ext_scalar_common.cpp
new file mode 100644
index 0000000..917a242
--- /dev/null
+++ b/3rdparty/glm/source/test/ext/ext_scalar_common.cpp
@@ -0,0 +1,360 @@
+#include <glm/ext/scalar_common.hpp>
+#include <glm/ext/scalar_constants.hpp>
+#include <glm/ext/scalar_relational.hpp>
+#include <glm/common.hpp>
+
+#if ((GLM_LANG & GLM_LANG_CXX11_FLAG) || (GLM_COMPILER & GLM_COMPILER_VC))
+#	define GLM_NAN(T) NAN
+#else
+#	define GLM_NAN(T) (static_cast<T>(0.0f) / static_cast<T>(0.0f))
+#endif
+
+template <typename T>
+static int test_min()
+{
+	int Error = 0;
+
+	T const N = static_cast<T>(0);
+	T const B = static_cast<T>(1);
+	Error += glm::equal(glm::min(N, B), N, glm::epsilon<T>()) ? 0 : 1;
+	Error += glm::equal(glm::min(B, N), N, glm::epsilon<T>()) ? 0 : 1;
+
+	T const C = static_cast<T>(2);
+	Error += glm::equal(glm::min(N, B, C), N, glm::epsilon<T>()) ? 0 : 1;
+	Error += glm::equal(glm::min(B, N, C), N, glm::epsilon<T>()) ? 0 : 1;
+	Error += glm::equal(glm::min(C, N, B), N, glm::epsilon<T>()) ? 0 : 1;
+	Error += glm::equal(glm::min(C, B, N), N, glm::epsilon<T>()) ? 0 : 1;
+	Error += glm::equal(glm::min(B, C, N), N, glm::epsilon<T>()) ? 0 : 1;
+	Error += glm::equal(glm::min(N, C, B), N, glm::epsilon<T>()) ? 0 : 1;
+
+	T const D = static_cast<T>(3);
+	Error += glm::equal(glm::min(D, N, B, C), N, glm::epsilon<T>()) ? 0 : 1;
+	Error += glm::equal(glm::min(B, D, N, C), N, glm::epsilon<T>()) ? 0 : 1;
+	Error += glm::equal(glm::min(C, N, D, B), N, glm::epsilon<T>()) ? 0 : 1;
+	Error += glm::equal(glm::min(C, B, D, N), N, glm::epsilon<T>()) ? 0 : 1;
+	Error += glm::equal(glm::min(B, C, N, D), N, glm::epsilon<T>()) ? 0 : 1;
+	Error += glm::equal(glm::min(N, C, B, D), N, glm::epsilon<T>()) ? 0 : 1;
+
+	return Error;
+}
+
+template <typename T>
+static int test_min_nan()
+{
+	int Error = 0;
+
+	T const B = static_cast<T>(1);
+	T const N = static_cast<T>(GLM_NAN(T));
+	Error += glm::isnan(glm::min(N, B)) ? 0 : 1;
+	Error += !glm::isnan(glm::min(B, N)) ? 0 : 1;
+
+	T const C = static_cast<T>(2);
+	Error += glm::isnan(glm::min(N, B, C)) ? 0 : 1;
+	Error += !glm::isnan(glm::min(B, N, C)) ? 0 : 1;
+	Error += !glm::isnan(glm::min(C, N, B)) ? 0 : 1;
+	Error += !glm::isnan(glm::min(C, B, N)) ? 0 : 1;
+	Error += !glm::isnan(glm::min(B, C, N)) ? 0 : 1;
+	Error += glm::isnan(glm::min(N, C, B)) ? 0 : 1;
+
+	T const D = static_cast<T>(3);
+	Error += !glm::isnan(glm::min(D, N, B, C)) ? 0 : 1;
+	Error += !glm::isnan(glm::min(B, D, N, C)) ? 0 : 1;
+	Error += !glm::isnan(glm::min(C, N, D, B)) ? 0 : 1;
+	Error += !glm::isnan(glm::min(C, B, D, N)) ? 0 : 1;
+	Error += !glm::isnan(glm::min(B, C, N, D)) ? 0 : 1;
+	Error += glm::isnan(glm::min(N, C, B, D)) ? 0 : 1;
+
+	return Error;
+}
+
+template <typename T>
+static int test_max()
+{
+	int Error = 0;
+
+	T const N = static_cast<T>(0);
+	T const B = static_cast<T>(1);
+	Error += glm::equal(glm::max(N, B), B, glm::epsilon<T>()) ? 0 : 1;
+	Error += glm::equal(glm::max(B, N), B, glm::epsilon<T>()) ? 0 : 1;
+
+	T const C = static_cast<T>(2);
+	Error += glm::equal(glm::max(N, B, C), C, glm::epsilon<T>()) ? 0 : 1;
+	Error += glm::equal(glm::max(B, N, C), C, glm::epsilon<T>()) ? 0 : 1;
+	Error += glm::equal(glm::max(C, N, B), C, glm::epsilon<T>()) ? 0 : 1;
+	Error += glm::equal(glm::max(C, B, N), C, glm::epsilon<T>()) ? 0 : 1;
+	Error += glm::equal(glm::max(B, C, N), C, glm::epsilon<T>()) ? 0 : 1;
+	Error += glm::equal(glm::max(N, C, B), C, glm::epsilon<T>()) ? 0 : 1;
+
+	T const D = static_cast<T>(3);
+	Error += glm::equal(glm::max(D, N, B, C), D, glm::epsilon<T>()) ? 0 : 1;
+	Error += glm::equal(glm::max(B, D, N, C), D, glm::epsilon<T>()) ? 0 : 1;
+	Error += glm::equal(glm::max(C, N, D, B), D, glm::epsilon<T>()) ? 0 : 1;
+	Error += glm::equal(glm::max(C, B, D, N), D, glm::epsilon<T>()) ? 0 : 1;
+	Error += glm::equal(glm::max(B, C, N, D), D, glm::epsilon<T>()) ? 0 : 1;
+	Error += glm::equal(glm::max(N, C, B, D), D, glm::epsilon<T>()) ? 0 : 1;
+
+	return Error;
+}
+
+template <typename T>
+static int test_max_nan()
+{
+	int Error = 0;
+
+	T const B = static_cast<T>(1);
+	T const N = static_cast<T>(GLM_NAN(T));
+	Error += glm::isnan(glm::max(N, B)) ? 0 : 1;
+	Error += !glm::isnan(glm::max(B, N)) ? 0 : 1;
+
+	T const C = static_cast<T>(2);
+	Error += glm::isnan(glm::max(N, B, C)) ? 0 : 1;
+	Error += !glm::isnan(glm::max(B, N, C)) ? 0 : 1;
+	Error += !glm::isnan(glm::max(C, N, B)) ? 0 : 1;
+	Error += !glm::isnan(glm::max(C, B, N)) ? 0 : 1;
+	Error += !glm::isnan(glm::max(B, C, N)) ? 0 : 1;
+	Error += glm::isnan(glm::max(N, C, B)) ? 0 : 1;
+
+	T const D = static_cast<T>(3);
+	Error += !glm::isnan(glm::max(D, N, B, C)) ? 0 : 1;
+	Error += !glm::isnan(glm::max(B, D, N, C)) ? 0 : 1;
+	Error += !glm::isnan(glm::max(C, N, D, B)) ? 0 : 1;
+	Error += !glm::isnan(glm::max(C, B, D, N)) ? 0 : 1;
+	Error += !glm::isnan(glm::max(B, C, N, D)) ? 0 : 1;
+	Error += glm::isnan(glm::max(N, C, B, D)) ? 0 : 1;
+
+	return Error;
+}
+
+template <typename T>
+static int test_fmin()
+{
+	int Error = 0;
+
+	T const B = static_cast<T>(1);
+	T const N = static_cast<T>(GLM_NAN(T));
+	Error += glm::equal(glm::fmin(N, B), B, glm::epsilon<T>()) ? 0 : 1;
+	Error += glm::equal(glm::fmin(B, N), B, glm::epsilon<T>()) ? 0 : 1;
+
+	T const C = static_cast<T>(2);
+	Error += glm::equal(glm::fmin(N, B, C), B, glm::epsilon<T>()) ? 0 : 1;
+	Error += glm::equal(glm::fmin(B, N, C), B, glm::epsilon<T>()) ? 0 : 1;
+	Error += glm::equal(glm::fmin(C, N, B), B, glm::epsilon<T>()) ? 0 : 1;
+	Error += glm::equal(glm::fmin(C, B, N), B, glm::epsilon<T>()) ? 0 : 1;
+	Error += glm::equal(glm::fmin(B, C, N), B, glm::epsilon<T>()) ? 0 : 1;
+	Error += glm::equal(glm::fmin(N, C, B), B, glm::epsilon<T>()) ? 0 : 1;
+
+	T const D = static_cast<T>(3);
+	Error += glm::equal(glm::fmin(D, N, B, C), B, glm::epsilon<T>()) ? 0 : 1;
+	Error += glm::equal(glm::fmin(B, D, N, C), B, glm::epsilon<T>()) ? 0 : 1;
+	Error += glm::equal(glm::fmin(C, N, D, B), B, glm::epsilon<T>()) ? 0 : 1;
+	Error += glm::equal(glm::fmin(C, B, D, N), B, glm::epsilon<T>()) ? 0 : 1;
+	Error += glm::equal(glm::fmin(B, C, N, D), B, glm::epsilon<T>()) ? 0 : 1;
+	Error += glm::equal(glm::fmin(N, C, B, D), B, glm::epsilon<T>()) ? 0 : 1;
+
+	return Error;
+}
+
+template <typename T>
+static int test_fmax()
+{
+	int Error = 0;
+
+	T const B = static_cast<T>(1);
+	T const N = static_cast<T>(GLM_NAN(T));
+	Error += glm::equal(glm::fmax(N, B), B, glm::epsilon<T>()) ? 0 : 1;
+	Error += glm::equal(glm::fmax(B, N), B, glm::epsilon<T>()) ? 0 : 1;
+
+	T const C = static_cast<T>(2);
+	Error += glm::equal(glm::fmax(N, B, C), C, glm::epsilon<T>()) ? 0 : 1;
+	Error += glm::equal(glm::fmax(B, N, C), C, glm::epsilon<T>()) ? 0 : 1;
+	Error += glm::equal(glm::fmax(C, N, B), C, glm::epsilon<T>()) ? 0 : 1;
+	Error += glm::equal(glm::fmax(C, B, N), C, glm::epsilon<T>()) ? 0 : 1;
+	Error += glm::equal(glm::fmax(B, C, N), C, glm::epsilon<T>()) ? 0 : 1;
+	Error += glm::equal(glm::fmax(N, C, B), C, glm::epsilon<T>()) ? 0 : 1;
+
+	T const D = static_cast<T>(3);
+	Error += glm::equal(glm::fmax(D, N, B, C), D, glm::epsilon<T>()) ? 0 : 1;
+	Error += glm::equal(glm::fmax(B, D, N, C), D, glm::epsilon<T>()) ? 0 : 1;
+	Error += glm::equal(glm::fmax(C, N, D, B), D, glm::epsilon<T>()) ? 0 : 1;
+	Error += glm::equal(glm::fmax(C, B, D, N), D, glm::epsilon<T>()) ? 0 : 1;
+	Error += glm::equal(glm::fmax(B, C, N, D), D, glm::epsilon<T>()) ? 0 : 1;
+	Error += glm::equal(glm::fmax(N, C, B, D), D, glm::epsilon<T>()) ? 0 : 1;
+
+	return Error;
+}
+
+static int test_clamp()
+{
+	int Error = 0;
+
+	float A = glm::clamp(0.5f);
+	Error += glm::equal(A, 0.5f, 0.00001f) ? 0 : 1;
+
+	float B = glm::clamp(0.0f);
+	Error += glm::equal(B, 0.0f, 0.00001f) ? 0 : 1;
+
+	float C = glm::clamp(1.0f);
+	Error += glm::equal(C, 1.0f, 0.00001f) ? 0 : 1;
+
+	float D = glm::clamp(-0.5f);
+	Error += glm::equal(D, 0.0f, 0.00001f) ? 0 : 1;
+
+	float E = glm::clamp(1.5f);
+	Error += glm::equal(E, 1.0f, 0.00001f) ? 0 : 1;
+
+	return Error;
+}
+
+static int test_repeat()
+{
+	int Error = 0;
+
+	float A = glm::repeat(0.5f);
+	Error += glm::equal(A, 0.5f, 0.00001f) ? 0 : 1;
+
+	float B = glm::repeat(0.0f);
+	Error += glm::equal(B, 0.0f, 0.00001f) ? 0 : 1;
+
+	float C = glm::repeat(1.0f);
+	Error += glm::equal(C, 0.0f, 0.00001f) ? 0 : 1;
+
+	float D = glm::repeat(-0.5f);
+	Error += glm::equal(D, 0.5f, 0.00001f) ? 0 : 1;
+
+	float E = glm::repeat(1.5f);
+	Error += glm::equal(E, 0.5f, 0.00001f) ? 0 : 1;
+
+	float F = glm::repeat(0.9f);
+	Error += glm::equal(F, 0.9f, 0.00001f) ? 0 : 1;
+
+	return Error;
+}
+
+static int test_mirrorClamp()
+{
+	int Error = 0;
+
+	float A = glm::mirrorClamp(0.5f);
+	Error += glm::equal(A, 0.5f, 0.00001f) ? 0 : 1;
+
+	float B = glm::mirrorClamp(0.0f);
+	Error += glm::equal(B, 0.0f, 0.00001f) ? 0 : 1;
+
+	float C = glm::mirrorClamp(1.1f);
+	Error += glm::equal(C, 0.1f, 0.00001f) ? 0 : 1;
+
+	float D = glm::mirrorClamp(-0.5f);
+	Error += glm::equal(D, 0.5f, 0.00001f) ? 0 : 1;
+
+	float E = glm::mirrorClamp(1.5f);
+	Error += glm::equal(E, 0.5f, 0.00001f) ? 0 : 1;
+
+	float F = glm::mirrorClamp(0.9f);
+	Error += glm::equal(F, 0.9f, 0.00001f) ? 0 : 1;
+
+	float G = glm::mirrorClamp(3.1f);
+	Error += glm::equal(G, 0.1f, 0.00001f) ? 0 : 1;
+
+	float H = glm::mirrorClamp(-3.1f);
+	Error += glm::equal(H, 0.1f, 0.00001f) ? 0 : 1;
+
+	float I = glm::mirrorClamp(-0.9f);
+	Error += glm::equal(I, 0.9f, 0.00001f) ? 0 : 1;
+
+	return Error;
+}
+
+static int test_mirrorRepeat()
+{
+	int Error = 0;
+
+	float A = glm::mirrorRepeat(0.5f);
+	Error += glm::equal(A, 0.5f, 0.00001f) ? 0 : 1;
+
+	float B = glm::mirrorRepeat(0.0f);
+	Error += glm::equal(B, 0.0f, 0.00001f) ? 0 : 1;
+
+	float C = glm::mirrorRepeat(1.0f);
+	Error += glm::equal(C, 1.0f, 0.00001f) ? 0 : 1;
+
+	float D = glm::mirrorRepeat(-0.5f);
+	Error += glm::equal(D, 0.5f, 0.00001f) ? 0 : 1;
+
+	float E = glm::mirrorRepeat(1.5f);
+	Error += glm::equal(E, 0.5f, 0.00001f) ? 0 : 1;
+
+	float F = glm::mirrorRepeat(0.9f);
+	Error += glm::equal(F, 0.9f, 0.00001f) ? 0 : 1;
+
+	float G = glm::mirrorRepeat(3.0f);
+	Error += glm::equal(G, 1.0f, 0.00001f) ? 0 : 1;
+
+	float H = glm::mirrorRepeat(-3.0f);
+	Error += glm::equal(H, 1.0f, 0.00001f) ? 0 : 1;
+
+	float I = glm::mirrorRepeat(-1.0f);
+	Error += glm::equal(I, 1.0f, 0.00001f) ? 0 : 1;
+
+	return Error;
+}
+
+static int test_iround()
+{
+	int Error = 0;
+
+	for(float f = 0.0f; f < 3.1f; f += 0.05f)
+	{
+		int RoundFast = static_cast<int>(glm::iround(f));
+		int RoundSTD = static_cast<int>(glm::round(f));
+		Error += RoundFast == RoundSTD ? 0 : 1;
+		assert(!Error);
+	}
+
+	return Error;
+}
+
+static int test_uround()
+{
+	int Error = 0;
+
+	for(float f = 0.0f; f < 3.1f; f += 0.05f)
+	{
+		int RoundFast = static_cast<int>(glm::uround(f));
+		int RoundSTD = static_cast<int>(glm::round(f));
+		Error += RoundFast == RoundSTD ? 0 : 1;
+		assert(!Error);
+	}
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_min<float>();
+	Error += test_min<double>();
+	Error += test_min_nan<float>();
+	Error += test_min_nan<double>();
+
+	Error += test_max<float>();
+	Error += test_max<double>();
+	Error += test_max_nan<float>();
+	Error += test_max_nan<double>();
+
+	Error += test_fmin<float>();
+	Error += test_fmin<double>();
+
+	Error += test_fmax<float>();
+	Error += test_fmax<double>();
+
+	Error += test_clamp();
+	Error += test_repeat();
+	Error += test_mirrorClamp();
+	Error += test_mirrorRepeat();
+
+	Error += test_iround();
+	Error += test_uround();
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/ext/ext_scalar_constants.cpp b/3rdparty/glm/source/test/ext/ext_scalar_constants.cpp
new file mode 100644
index 0000000..3af7099
--- /dev/null
+++ b/3rdparty/glm/source/test/ext/ext_scalar_constants.cpp
@@ -0,0 +1,36 @@
+#include <glm/ext/scalar_constants.hpp>
+
+template <typename valType>
+static int test_epsilon()
+{
+	int Error = 0;
+
+	valType const Test = glm::epsilon<valType>();
+	Error += Test > static_cast<valType>(0) ? 0 : 1;
+
+	return Error;
+}
+
+template <typename valType>
+static int test_pi()
+{
+	int Error = 0;
+
+	valType const Test = glm::pi<valType>();
+	Error += Test > static_cast<valType>(3.14) ? 0 : 1;
+	Error += Test < static_cast<valType>(3.15) ? 0 : 1;
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_epsilon<float>();
+	Error += test_epsilon<double>();
+	Error += test_pi<float>();
+	Error += test_pi<double>();
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/ext/ext_scalar_int_sized.cpp b/3rdparty/glm/source/test/ext/ext_scalar_int_sized.cpp
new file mode 100644
index 0000000..b55c6ca
--- /dev/null
+++ b/3rdparty/glm/source/test/ext/ext_scalar_int_sized.cpp
@@ -0,0 +1,43 @@
+#include <glm/ext/scalar_int_sized.hpp>
+
+#if GLM_HAS_STATIC_ASSERT
+	static_assert(sizeof(glm::int8) == 1, "int8 size isn't 1 byte on this platform");
+	static_assert(sizeof(glm::int16) == 2, "int16 size isn't 2 bytes on this platform");
+	static_assert(sizeof(glm::int32) == 4, "int32 size isn't 4 bytes on this platform");
+	static_assert(sizeof(glm::int64) == 8, "int64 size isn't 8 bytes on this platform");
+	static_assert(sizeof(glm::int16) == sizeof(short), "signed short size isn't 4 bytes on this platform");
+	static_assert(sizeof(glm::int32) == sizeof(int), "signed int size isn't 4 bytes on this platform");
+#endif
+
+static int test_size()
+{
+	int Error = 0;
+
+	Error += sizeof(glm::int8) == 1 ? 0 : 1;
+	Error += sizeof(glm::int16) == 2 ? 0 : 1;
+	Error += sizeof(glm::int32) == 4 ? 0 : 1;
+	Error += sizeof(glm::int64) == 8 ? 0 : 1;
+
+	return Error;
+}
+
+static int test_comp()
+{
+	int Error = 0;
+
+	Error += sizeof(glm::int8) < sizeof(glm::int16) ? 0 : 1;
+	Error += sizeof(glm::int16) < sizeof(glm::int32) ? 0 : 1;
+	Error += sizeof(glm::int32) < sizeof(glm::int64) ? 0 : 1;
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_size();
+	Error += test_comp();
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/ext/ext_scalar_integer.cpp b/3rdparty/glm/source/test/ext/ext_scalar_integer.cpp
new file mode 100644
index 0000000..f169e8a
--- /dev/null
+++ b/3rdparty/glm/source/test/ext/ext_scalar_integer.cpp
@@ -0,0 +1,686 @@
+#include <glm/ext/scalar_integer.hpp>
+#include <glm/ext/scalar_int_sized.hpp>
+#include <glm/ext/scalar_uint_sized.hpp>
+#include <vector>
+#include <ctime>
+#include <cstdio>
+
+#if GLM_LANG & GLM_LANG_CXX11_FLAG
+#include <chrono>
+
+namespace isPowerOfTwo
+{
+	template<typename genType>
+	struct type
+	{
+		genType		Value;
+		bool		Return;
+	};
+
+	int test_int16()
+	{
+		type<glm::int16> const Data[] =
+		{
+			{0x0001, true},
+			{0x0002, true},
+			{0x0004, true},
+			{0x0080, true},
+			{0x0000, true},
+			{0x0003, false}
+		};
+
+		int Error = 0;
+
+		for(std::size_t i = 0, n = sizeof(Data) / sizeof(type<glm::int16>); i < n; ++i)
+		{
+			bool Result = glm::isPowerOfTwo(Data[i].Value);
+			Error += Data[i].Return == Result ? 0 : 1;
+		}
+
+		return Error;
+	}
+
+	int test_uint16()
+	{
+		type<glm::uint16> const Data[] =
+		{
+			{0x0001, true},
+			{0x0002, true},
+			{0x0004, true},
+			{0x0000, true},
+			{0x0000, true},
+			{0x0003, false}
+		};
+
+		int Error = 0;
+
+		for(std::size_t i = 0, n = sizeof(Data) / sizeof(type<glm::uint16>); i < n; ++i)
+		{
+			bool Result = glm::isPowerOfTwo(Data[i].Value);
+			Error += Data[i].Return == Result ? 0 : 1;
+		}
+
+		return Error;
+	}
+
+	int test_int32()
+	{
+		type<int> const Data[] =
+		{
+			{0x00000001, true},
+			{0x00000002, true},
+			{0x00000004, true},
+			{0x0000000f, false},
+			{0x00000000, true},
+			{0x00000003, false}
+		};
+
+		int Error = 0;
+
+		for(std::size_t i = 0, n = sizeof(Data) / sizeof(type<int>); i < n; ++i)
+		{
+			bool Result = glm::isPowerOfTwo(Data[i].Value);
+			Error += Data[i].Return == Result ? 0 : 1;
+		}
+
+		return Error;
+	}
+
+	int test_uint32()
+	{
+		type<glm::uint> const Data[] =
+		{
+			{0x00000001, true},
+			{0x00000002, true},
+			{0x00000004, true},
+			{0x80000000, true},
+			{0x00000000, true},
+			{0x00000003, false}
+		};
+
+		int Error = 0;
+
+		for(std::size_t i = 0, n = sizeof(Data) / sizeof(type<glm::uint>); i < n; ++i)
+		{
+			bool Result = glm::isPowerOfTwo(Data[i].Value);
+			Error += Data[i].Return == Result ? 0 : 1;
+		}
+
+		return Error;
+	}
+
+	int test()
+	{
+		int Error = 0;
+
+		Error += test_int16();
+		Error += test_uint16();
+		Error += test_int32();
+		Error += test_uint32();
+
+		return Error;
+	}
+}//isPowerOfTwo
+
+namespace nextPowerOfTwo_advanced
+{
+	template<typename genIUType>
+	GLM_FUNC_QUALIFIER genIUType highestBitValue(genIUType Value)
+	{
+		genIUType tmp = Value;
+		genIUType result = genIUType(0);
+		while(tmp)
+		{
+			result = (tmp & (~tmp + 1)); // grab lowest bit
+			tmp &= ~result; // clear lowest bit
+		}
+		return result;
+	}
+
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType nextPowerOfTwo_loop(genType value)
+	{
+		return glm::isPowerOfTwo(value) ? value : highestBitValue(value) << 1;
+	}
+
+	template<typename genType>
+	struct type
+	{
+		genType		Value;
+		genType		Return;
+	};
+
+	int test_int32()
+	{
+		type<glm::int32> const Data[] =
+		{
+			{0x0000ffff, 0x00010000},
+			{-3, -4},
+			{-8, -8},
+			{0x00000001, 0x00000001},
+			{0x00000002, 0x00000002},
+			{0x00000004, 0x00000004},
+			{0x00000007, 0x00000008},
+			{0x0000fff0, 0x00010000},
+			{0x0000f000, 0x00010000},
+			{0x08000000, 0x08000000},
+			{0x00000000, 0x00000000},
+			{0x00000003, 0x00000004}
+		};
+
+		int Error(0);
+
+		for(std::size_t i = 0, n = sizeof(Data) / sizeof(type<glm::int32>); i < n; ++i)
+		{
+			glm::int32 Result = glm::nextPowerOfTwo(Data[i].Value);
+			Error += Data[i].Return == Result ? 0 : 1;
+		}
+
+		return Error;
+	}
+
+	int test_uint32()
+	{
+		type<glm::uint32> const Data[] =
+		{
+			{0x00000001, 0x00000001},
+			{0x00000002, 0x00000002},
+			{0x00000004, 0x00000004},
+			{0x00000007, 0x00000008},
+			{0x0000ffff, 0x00010000},
+			{0x0000fff0, 0x00010000},
+			{0x0000f000, 0x00010000},
+			{0x80000000, 0x80000000},
+			{0x00000000, 0x00000000},
+			{0x00000003, 0x00000004}
+		};
+
+		int Error(0);
+
+		for(std::size_t i = 0, n = sizeof(Data) / sizeof(type<glm::uint32>); i < n; ++i)
+		{
+			glm::uint32 Result = glm::nextPowerOfTwo(Data[i].Value);
+			Error += Data[i].Return == Result ? 0 : 1;
+		}
+
+		return Error;
+	}
+
+	int perf()
+	{
+		int Error(0);
+
+		std::vector<glm::uint> v;
+		v.resize(100000000);
+
+		std::clock_t Timestramp0 = std::clock();
+
+		for(glm::uint32 i = 0, n = static_cast<glm::uint>(v.size()); i < n; ++i)
+			v[i] = nextPowerOfTwo_loop(i);
+
+		std::clock_t Timestramp1 = std::clock();
+
+		for(glm::uint32 i = 0, n = static_cast<glm::uint>(v.size()); i < n; ++i)
+			v[i] = glm::nextPowerOfTwo(i);
+
+		std::clock_t Timestramp2 = std::clock();
+
+		std::printf("nextPowerOfTwo_loop: %d clocks\n", static_cast<int>(Timestramp1 - Timestramp0));
+		std::printf("glm::nextPowerOfTwo: %d clocks\n", static_cast<int>(Timestramp2 - Timestramp1));
+
+		return Error;
+	}
+
+	int test()
+	{
+		int Error(0);
+
+		Error += test_int32();
+		Error += test_uint32();
+
+		return Error;
+	}
+}//namespace nextPowerOfTwo_advanced
+
+namespace prevPowerOfTwo
+{
+	template <typename T>
+	int run()
+	{
+		int Error = 0;
+
+		T const A = glm::prevPowerOfTwo(static_cast<T>(7));
+		Error += A == static_cast<T>(4) ? 0 : 1;
+
+		T const B = glm::prevPowerOfTwo(static_cast<T>(15));
+		Error += B == static_cast<T>(8) ? 0 : 1;
+
+		T const C = glm::prevPowerOfTwo(static_cast<T>(31));
+		Error += C == static_cast<T>(16) ? 0 : 1;
+
+		T const D = glm::prevPowerOfTwo(static_cast<T>(32));
+		Error += D == static_cast<T>(32) ? 0 : 1;
+
+		return Error;
+	}
+
+	int test()
+	{
+		int Error = 0;
+
+		Error += run<glm::int8>();
+		Error += run<glm::int16>();
+		Error += run<glm::int32>();
+		Error += run<glm::int64>();
+
+		Error += run<glm::uint8>();
+		Error += run<glm::uint16>();
+		Error += run<glm::uint32>();
+		Error += run<glm::uint64>();
+
+		return Error;
+	}
+}//namespace prevPowerOfTwo
+
+namespace nextPowerOfTwo
+{
+	template <typename T>
+	int run()
+	{
+		int Error = 0;
+
+		T const A = glm::nextPowerOfTwo(static_cast<T>(7));
+		Error += A == static_cast<T>(8) ? 0 : 1;
+
+		T const B = glm::nextPowerOfTwo(static_cast<T>(15));
+		Error += B == static_cast<T>(16) ? 0 : 1;
+
+		T const C = glm::nextPowerOfTwo(static_cast<T>(31));
+		Error += C == static_cast<T>(32) ? 0 : 1;
+
+		T const D = glm::nextPowerOfTwo(static_cast<T>(32));
+		Error += D == static_cast<T>(32) ? 0 : 1;
+
+		return Error;
+	}
+
+	int test()
+	{
+		int Error = 0;
+
+		Error += run<glm::int8>();
+		Error += run<glm::int16>();
+		Error += run<glm::int32>();
+		Error += run<glm::int64>();
+
+		Error += run<glm::uint8>();
+		Error += run<glm::uint16>();
+		Error += run<glm::uint32>();
+		Error += run<glm::uint64>();
+
+		return Error;
+	}
+}//namespace nextPowerOfTwo
+
+namespace prevMultiple
+{
+	template<typename genIUType>
+	struct type
+	{
+		genIUType Source;
+		genIUType Multiple;
+		genIUType Return;
+	};
+
+	template <typename T>
+	int run()
+	{
+		type<T> const Data[] =
+		{
+			{8, 3, 6},
+			{7, 7, 7}
+		};
+
+		int Error = 0;
+		
+		for(std::size_t i = 0, n = sizeof(Data) / sizeof(type<T>); i < n; ++i)
+		{
+			T const Result = glm::prevMultiple(Data[i].Source, Data[i].Multiple);
+			Error += Data[i].Return == Result ? 0 : 1;
+		}
+
+		return Error;
+	}
+
+	int test()
+	{
+		int Error = 0;
+
+		Error += run<glm::int8>();
+		Error += run<glm::int16>();
+		Error += run<glm::int32>();
+		Error += run<glm::int64>();
+
+		Error += run<glm::uint8>();
+		Error += run<glm::uint16>();
+		Error += run<glm::uint32>();
+		Error += run<glm::uint64>();
+
+		return Error;
+	}
+}//namespace prevMultiple
+
+namespace nextMultiple
+{
+	static glm::uint const Multiples = 128;
+
+	int perf_nextMultiple(glm::uint Samples)
+	{
+		std::vector<glm::uint> Results(Samples * Multiples);
+
+		std::chrono::high_resolution_clock::time_point t0 = std::chrono::high_resolution_clock::now();
+
+		for(glm::uint Source = 0; Source < Samples; ++Source)
+		for(glm::uint Multiple = 0; Multiple < Multiples; ++Multiple)
+		{
+			Results[Source * Multiples + Multiple] = glm::nextMultiple(Source, Multiples);
+		}
+
+		std::chrono::high_resolution_clock::time_point t1 = std::chrono::high_resolution_clock::now();
+
+		std::printf("- glm::nextMultiple Time %d microseconds\n", static_cast<int>(std::chrono::duration_cast<std::chrono::microseconds>(t1 - t0).count()));
+
+		glm::uint Result = 0;
+		for(std::size_t i = 0, n = Results.size(); i < n; ++i)
+			Result += Results[i];
+
+		return Result > 0 ? 0 : 1;
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER T nextMultipleMod(T Source, T Multiple)
+	{
+		T const Tmp = Source - static_cast<T>(1);
+		return Tmp + (Multiple - (Tmp % Multiple));
+	}
+
+	int perf_nextMultipleMod(glm::uint Samples)
+	{
+		std::vector<glm::uint> Results(Samples * Multiples);
+
+		std::chrono::high_resolution_clock::time_point t0 = std::chrono::high_resolution_clock::now();
+
+		for(glm::uint Multiple = 0; Multiple < Multiples; ++Multiple)
+			for (glm::uint Source = 0; Source < Samples; ++Source)
+		{
+			Results[Source * Multiples + Multiple] = nextMultipleMod(Source, Multiples);
+		}
+
+		std::chrono::high_resolution_clock::time_point t1 = std::chrono::high_resolution_clock::now();
+
+		std::printf("- nextMultipleMod Time %d microseconds\n", static_cast<int>(std::chrono::duration_cast<std::chrono::microseconds>(t1 - t0).count()));
+
+		glm::uint Result = 0;
+		for(std::size_t i = 0, n = Results.size(); i < n; ++i)
+			Result += Results[i];
+
+		return Result > 0 ? 0 : 1;
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER T nextMultipleNeg(T Source, T Multiple)
+	{
+		if(Source > static_cast<T>(0))
+		{
+			T const Tmp = Source - static_cast<T>(1);
+			return Tmp + (Multiple - (Tmp % Multiple));
+		}
+		else
+			return Source + (-Source % Multiple);
+	}
+
+	int perf_nextMultipleNeg(glm::uint Samples)
+	{
+		std::vector<glm::uint> Results(Samples * Multiples);
+
+		std::chrono::high_resolution_clock::time_point t0 = std::chrono::high_resolution_clock::now();
+
+		for(glm::uint Source = 0; Source < Samples; ++Source)
+		for(glm::uint Multiple = 0; Multiple < Multiples; ++Multiple)
+		{
+			Results[Source * Multiples + Multiple] = nextMultipleNeg(Source, Multiples);
+		}
+
+		std::chrono::high_resolution_clock::time_point t1 = std::chrono::high_resolution_clock::now();
+
+		std::printf("- nextMultipleNeg Time %d microseconds\n", static_cast<int>(std::chrono::duration_cast<std::chrono::microseconds>(t1 - t0).count()));
+
+		glm::uint Result = 0;
+		for (std::size_t i = 0, n = Results.size(); i < n; ++i)
+			Result += Results[i];
+
+		return Result > 0 ? 0 : 1;
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER T nextMultipleUFloat(T Source, T Multiple)
+	{
+		return Source + (Multiple - std::fmod(Source, Multiple));
+	}
+
+	int perf_nextMultipleUFloat(glm::uint Samples)
+	{
+		std::vector<float> Results(Samples * Multiples);
+
+		std::chrono::high_resolution_clock::time_point t0 = std::chrono::high_resolution_clock::now();
+
+		for(glm::uint Source = 0; Source < Samples; ++Source)
+		for(glm::uint Multiple = 0; Multiple < Multiples; ++Multiple)
+		{
+			Results[Source * Multiples + Multiple] = nextMultipleUFloat(static_cast<float>(Source), static_cast<float>(Multiples));
+		}
+
+		std::chrono::high_resolution_clock::time_point t1 = std::chrono::high_resolution_clock::now();
+
+		std::printf("- nextMultipleUFloat Time %d microseconds\n", static_cast<int>(std::chrono::duration_cast<std::chrono::microseconds>(t1 - t0).count()));
+
+		float Result = 0;
+		for (std::size_t i = 0, n = Results.size(); i < n; ++i)
+			Result += Results[i];
+
+		return Result > 0.0f ? 0 : 1;
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER T nextMultipleFloat(T Source, T Multiple)
+	{
+		if(Source > static_cast<float>(0))
+			return Source + (Multiple - std::fmod(Source, Multiple));
+		else
+			return Source + std::fmod(-Source, Multiple);
+	}
+
+	int perf_nextMultipleFloat(glm::uint Samples)
+	{
+		std::vector<float> Results(Samples * Multiples);
+
+		std::chrono::high_resolution_clock::time_point t0 = std::chrono::high_resolution_clock::now();
+
+		for(glm::uint Source = 0; Source < Samples; ++Source)
+		for(glm::uint Multiple = 0; Multiple < Multiples; ++Multiple)
+		{
+			Results[Source * Multiples + Multiple] = nextMultipleFloat(static_cast<float>(Source), static_cast<float>(Multiples));
+		}
+
+		std::chrono::high_resolution_clock::time_point t1 = std::chrono::high_resolution_clock::now();
+
+		std::printf("- nextMultipleFloat Time %d microseconds\n", static_cast<int>(std::chrono::duration_cast<std::chrono::microseconds>(t1 - t0).count()));
+
+		float Result = 0;
+		for (std::size_t i = 0, n = Results.size(); i < n; ++i)
+			Result += Results[i];
+
+		return Result > 0.0f ? 0 : 1;
+	}
+
+	template<typename genIUType>
+	struct type
+	{
+		genIUType Source;
+		genIUType Multiple;
+		genIUType Return;
+	};
+
+	template <typename T>
+	int test_uint()
+	{
+		type<T> const Data[] =
+		{
+			{ 3, 4, 4 },
+			{ 6, 3, 6 },
+			{ 5, 3, 6 },
+			{ 7, 7, 7 },
+			{ 0, 1, 0 },
+			{ 8, 3, 9 }
+		};
+
+		int Error = 0;
+
+		for(std::size_t i = 0, n = sizeof(Data) / sizeof(type<T>); i < n; ++i)
+		{
+			T const Result0 = glm::nextMultiple(Data[i].Source, Data[i].Multiple);
+			Error += Data[i].Return == Result0 ? 0 : 1;
+			assert(!Error);
+
+			T const Result1 = nextMultipleMod(Data[i].Source, Data[i].Multiple);
+			Error += Data[i].Return == Result1 ? 0 : 1;
+			assert(!Error);
+		}
+
+		return Error;
+	}
+
+	int perf()
+	{
+		int Error = 0;
+
+		glm::uint const Samples = 10000;
+
+		for(int i = 0; i < 4; ++i)
+		{
+			std::printf("Run %d :\n", i);
+			Error += perf_nextMultiple(Samples);
+			Error += perf_nextMultipleMod(Samples);
+			Error += perf_nextMultipleNeg(Samples);
+			Error += perf_nextMultipleUFloat(Samples);
+			Error += perf_nextMultipleFloat(Samples);
+			std::printf("\n");
+		}
+
+		return Error;
+	}
+
+	int test()
+	{
+		int Error = 0;
+
+		Error += test_uint<glm::int8>();
+		Error += test_uint<glm::int16>();
+		Error += test_uint<glm::int32>();
+		Error += test_uint<glm::int64>();
+
+		Error += test_uint<glm::uint8>();
+		Error += test_uint<glm::uint16>();
+		Error += test_uint<glm::uint32>();
+		Error += test_uint<glm::uint64>();
+
+		return Error;
+	}
+}//namespace nextMultiple
+
+namespace findNSB
+{
+	template<typename T>
+	struct type
+	{
+		T Source;
+		int SignificantBitCount;
+		int Return;
+	};
+
+	template <typename T>
+	int run()
+	{
+		type<T> const Data[] =
+		{
+			{ 0x00, 1,-1 },
+			{ 0x01, 2,-1 },
+			{ 0x02, 2,-1 },
+			{ 0x06, 3,-1 },
+			{ 0x01, 1, 0 },
+			{ 0x03, 1, 0 },
+			{ 0x03, 2, 1 },
+			{ 0x07, 2, 1 },
+			{ 0x05, 2, 2 },
+			{ 0x0D, 2, 2 }
+		};
+
+		int Error = 0;
+
+		for (std::size_t i = 0, n = sizeof(Data) / sizeof(type<T>); i < n; ++i)
+		{
+			int const Result0 = glm::findNSB(Data[i].Source, Data[i].SignificantBitCount);
+			Error += Data[i].Return == Result0 ? 0 : 1;
+			assert(!Error);
+		}
+
+		return Error;
+	}
+
+	int test()
+	{
+		int Error = 0;
+
+		Error += run<glm::uint8>();
+		Error += run<glm::uint16>();
+		Error += run<glm::uint32>();
+		Error += run<glm::uint64>();
+
+		Error += run<glm::int8>();
+		Error += run<glm::int16>();
+		Error += run<glm::int32>();
+		Error += run<glm::int64>();
+
+		return Error;
+	}
+}//namespace findNSB
+
+int main()
+{
+	int Error = 0;
+
+	Error += findNSB::test();
+
+	Error += isPowerOfTwo::test();
+	Error += prevPowerOfTwo::test();
+	Error += nextPowerOfTwo::test();
+	Error += nextPowerOfTwo_advanced::test();
+	Error += prevMultiple::test();
+	Error += nextMultiple::test();
+
+#	ifdef NDEBUG
+		Error += nextPowerOfTwo_advanced::perf();
+		Error += nextMultiple::perf();
+#	endif//NDEBUG
+
+	return Error;
+}
+
+#else
+
+int main()
+{
+	return 0;
+}
+
+#endif
diff --git a/3rdparty/glm/source/test/ext/ext_scalar_packing.cpp b/3rdparty/glm/source/test/ext/ext_scalar_packing.cpp
new file mode 100644
index 0000000..77616e3
--- /dev/null
+++ b/3rdparty/glm/source/test/ext/ext_scalar_packing.cpp
@@ -0,0 +1,28 @@
+#include <glm/ext/scalar_packing.hpp>
+#include <glm/ext/scalar_relational.hpp>
+
+int test_packUnorm()
+{
+	int Error = 0;
+
+
+	return Error;
+}
+
+int test_packSnorm()
+{
+	int Error = 0;
+
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_packUnorm();
+	Error += test_packSnorm();
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/ext/ext_scalar_reciprocal.cpp b/3rdparty/glm/source/test/ext/ext_scalar_reciprocal.cpp
new file mode 100644
index 0000000..ebba10d
--- /dev/null
+++ b/3rdparty/glm/source/test/ext/ext_scalar_reciprocal.cpp
@@ -0,0 +1,171 @@
+#include <glm/ext/scalar_reciprocal.hpp>
+#include <glm/ext/scalar_relational.hpp>
+#include <glm/ext/scalar_constants.hpp>
+
+static int test_sec()
+{
+	int Error = 0;
+	
+	Error += glm::equal(glm::sec(0.0), 1.0, 0.01) ? 0 : 1;
+	Error += glm::equal(glm::sec(glm::pi<double>() * 2.0), 1.0, 0.01) ? 0 : 1;
+	Error += glm::equal(glm::sec(glm::pi<double>() * -2.0), 1.0, 0.01) ? 0 : 1;
+	Error += glm::equal(glm::sec(glm::pi<double>() * 1.0), -1.0, 0.01) ? 0 : 1;
+	Error += glm::equal(glm::sec(glm::pi<double>() * -1.0), -1.0, 0.01) ? 0 : 1;
+
+	return Error;
+}
+
+static int test_csc()
+{
+	int Error = 0;
+	
+	double const a = glm::csc(glm::pi<double>() * 0.5);
+	Error += glm::equal(a, 1.0, 0.01) ? 0 : 1;
+	double const b = glm::csc(glm::pi<double>() * -0.5);
+	Error += glm::equal(b, -1.0, 0.01) ? 0 : 1;
+
+	return Error;
+}
+
+static int test_cot()
+{
+	int Error = 0;
+	
+	double const a = glm::cot(glm::pi<double>() * 0.5);
+	Error += glm::equal(a, 0.0, 0.01) ? 0 : 1;
+	double const b = glm::cot(glm::pi<double>() * -0.5);
+	Error += glm::equal(b, 0.0, 0.01) ? 0 : 1;
+
+	return Error;
+}
+
+static int test_asec()
+{
+	int Error = 0;
+	
+	Error += glm::equal(glm::asec(100000.0), glm::pi<double>() * 0.5, 0.01) ? 0 : 1;
+	Error += glm::equal(glm::asec(-100000.0), glm::pi<double>() * 0.5, 0.01) ? 0 : 1;
+
+	return Error;
+}
+
+static int test_acsc()
+{
+	int Error = 0;
+	
+	Error += glm::equal(glm::acsc(100000.0), 0.0, 0.01) ? 0 : 1;
+	Error += glm::equal(glm::acsc(-100000.0), 0.0, 0.01) ? 0 : 1;
+
+	return Error;
+}
+
+static int test_acot()
+{
+	int Error = 0;
+	
+	Error += glm::equal(glm::acot(100000.0), 0.0, 0.01) ? 0 : 1;
+	Error += glm::equal(glm::acot(-100000.0), glm::pi<double>(), 0.01) ? 0 : 1;
+	Error += glm::equal(glm::acot(0.0), glm::pi<double>() * 0.5, 0.01) ? 0 : 1;
+
+	return Error;
+}
+
+static int test_sech()
+{
+	int Error = 0;
+	
+	Error += glm::equal(glm::sech(100000.0), 0.0, 0.01) ? 0 : 1;
+	Error += glm::equal(glm::sech(-100000.0), 0.0, 0.01) ? 0 : 1;
+	Error += glm::equal(glm::sech(0.0), 1.0, 0.01) ? 0 : 1;
+
+	return Error;
+}
+
+static int test_csch()
+{
+	int Error = 0;
+	
+	Error += glm::equal(glm::csch(100000.0), 0.0, 0.01) ? 0 : 1;
+	Error += glm::equal(glm::csch(-100000.0), 0.0, 0.01) ? 0 : 1;
+
+	return Error;
+}
+
+static int test_coth()
+{
+	int Error = 0;
+	
+	double const a = glm::coth(100.0);
+	Error += glm::equal(a, 1.0, 0.01) ? 0 : 1;
+	
+	double const b = glm::coth(-100.0);
+	Error += glm::equal(b, -1.0, 0.01) ? 0 : 1;
+
+	return Error;
+}
+
+static int test_asech()
+{
+	int Error = 0;
+	
+	double const a = glm::asech(1.0);
+	Error += glm::equal(a, 0.0, 0.01) ? 0 : 1;
+
+	return Error;
+}
+
+static int test_acsch()
+{
+	int Error = 0;
+	
+	Error += glm::acsch(0.01) > 1.0 ? 0 : 1;
+	Error += glm::acsch(-0.01) < -1.0 ? 0 : 1;
+
+	Error += glm::equal(glm::acsch(100.0), 0.0, 0.01) ? 0 : 1;
+	Error += glm::equal(glm::acsch(-100.0), 0.0, 0.01) ? 0 : 1;
+
+	return Error;
+}
+
+static int test_acoth()
+{
+	int Error = 0;
+	
+	double const a = glm::acoth(1.00001);
+	Error += a > 6.0 ? 0 : 1;
+	
+	double const b = glm::acoth(-1.00001);
+	Error += b < -6.0 ? 0 : 1;
+
+	double const c = glm::acoth(10000.0);
+	Error += glm::equal(c, 0.0, 0.01) ? 0 : 1;
+	
+	double const d = glm::acoth(-10000.0);
+	Error += glm::equal(d, 0.0, 0.01) ? 0 : 1;
+
+	return Error;
+}
+
+
+int main()
+{
+	int Error = 0;
+	
+	Error += test_sec();
+	Error += test_csc();
+	Error += test_cot();
+
+	Error += test_asec();
+	Error += test_acsc();
+	Error += test_acot();
+
+	Error += test_sech();
+	Error += test_csch();
+	Error += test_coth();
+
+	Error += test_asech();
+	Error += test_acsch();
+	Error += test_acoth();
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/ext/ext_scalar_relational.cpp b/3rdparty/glm/source/test/ext/ext_scalar_relational.cpp
new file mode 100644
index 0000000..61f1999
--- /dev/null
+++ b/3rdparty/glm/source/test/ext/ext_scalar_relational.cpp
@@ -0,0 +1,106 @@
+#include <glm/ext/scalar_relational.hpp>
+#include <glm/ext/scalar_integer.hpp>
+#include <glm/ext/scalar_ulp.hpp>
+#include <cmath>
+
+static int test_equal_epsilon()
+{
+#	if GLM_CONFIG_CONSTEXP == GLM_ENABLE
+		static_assert(glm::equal(1.01f, 1.02f, 0.1f), "GLM: Failed constexpr");
+		static_assert(!glm::equal(1.01f, 1.02f, 0.001f), "GLM: Failed constexpr");
+#	endif
+	
+	int Error = 0;
+
+	Error += glm::equal(1.01f, 1.02f, 0.1f) ? 0 : 1;
+	Error += !glm::equal(1.01f, 1.02f, 0.001f) ? 0 : 1;
+
+	return Error;
+}
+
+static int test_notEqual_epsilon()
+{
+#	if GLM_CONFIG_CONSTEXP == GLM_ENABLE
+		static_assert(glm::notEqual(1.01f, 1.02f, 0.001f), "GLM: Failed constexpr");
+		static_assert(!glm::notEqual(1.01f, 1.02f, 0.1f), "GLM: Failed constexpr");
+#	endif
+	
+	int Error = 0;
+
+	Error += glm::notEqual(1.01f, 1.02f, 0.001f) ? 0 : 1;
+	Error += !glm::notEqual(1.01f, 1.02f, 0.1f) ? 0 : 1;
+
+	return Error;
+}
+
+static int test_equal_ulps()
+{
+	int Error = 0;
+	
+	float const ULP1Plus = glm::nextFloat(1.0f);
+	Error += glm::equal(1.0f, ULP1Plus, 1) ? 0 : 1;
+
+	float const ULP2Plus = glm::nextFloat(ULP1Plus);
+	Error += !glm::equal(1.0f, ULP2Plus, 1) ? 0 : 1;
+	
+	float const ULP1Minus = glm::prevFloat(1.0f);
+	Error += glm::equal(1.0f, ULP1Minus, 1) ? 0 : 1;
+
+	float const ULP2Minus = glm::prevFloat(ULP1Minus);
+	Error += !glm::equal(1.0f, ULP2Minus, 1) ? 0 : 1;
+	
+	return Error;
+}
+
+static int test_notEqual_ulps()
+{
+	int Error = 0;
+	
+	float const ULP1Plus = glm::nextFloat(1.0f);
+	Error += !glm::notEqual(1.0f, ULP1Plus, 1) ? 0 : 1;
+	
+	float const ULP2Plus = glm::nextFloat(ULP1Plus);
+	Error += glm::notEqual(1.0f, ULP2Plus, 1) ? 0 : 1;
+	
+	float const ULP1Minus = glm::prevFloat(1.0f);
+	Error += !glm::notEqual(1.0f, ULP1Minus, 1) ? 0 : 1;
+	
+	float const ULP2Minus = glm::prevFloat(ULP1Minus);
+	Error += glm::notEqual(1.0f, ULP2Minus, 1) ? 0 : 1;
+	
+	return Error;
+}
+
+static int test_equal_sign()
+{
+	int Error = 0;
+
+	Error += !glm::equal(-0.0f, 0.0f, 2) ? 0 : 1;
+	Error += !glm::equal(-0.0, 0.0, 2) ? 0 : 1;
+
+	Error += !glm::equal(-1.0f, 2.0f, 2) ? 0 : 1;
+	Error += !glm::equal(-1.0, 2.0, 2) ? 0 : 1;
+
+	Error += !glm::equal(-0.00001f, 1.00000f, 2) ? 0 : 1;
+	Error += !glm::equal(-0.00001, 1.00000, 2) ? 0 : 1;
+
+	Error += !glm::equal(-1.0f, 1.0f, 2) ? 0 : 1;
+	Error += !glm::equal(-1.0, 1.0, 2) ? 0 : 1;
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_equal_epsilon();
+	Error += test_notEqual_epsilon();
+
+	Error += test_equal_ulps();
+	Error += test_notEqual_ulps();
+
+	Error += test_equal_sign();
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/ext/ext_scalar_uint_sized.cpp b/3rdparty/glm/source/test/ext/ext_scalar_uint_sized.cpp
new file mode 100644
index 0000000..1122947
--- /dev/null
+++ b/3rdparty/glm/source/test/ext/ext_scalar_uint_sized.cpp
@@ -0,0 +1,43 @@
+#include <glm/ext/scalar_uint_sized.hpp>
+
+#if GLM_HAS_STATIC_ASSERT
+	static_assert(sizeof(glm::uint8) == 1, "uint8 size isn't 1 byte on this platform");
+	static_assert(sizeof(glm::uint16) == 2, "uint16 size isn't 2 bytes on this platform");
+	static_assert(sizeof(glm::uint32) == 4, "uint32 size isn't 4 bytes on this platform");
+	static_assert(sizeof(glm::uint64) == 8, "uint64 size isn't 8 bytes on this platform");
+	static_assert(sizeof(glm::uint16) == sizeof(unsigned short), "unsigned short size isn't 4 bytes on this platform");
+	static_assert(sizeof(glm::uint32) == sizeof(unsigned int), "unsigned int size isn't 4 bytes on this platform");
+#endif
+
+static int test_size()
+{
+	int Error = 0;
+
+	Error += sizeof(glm::uint8) == 1 ? 0 : 1;
+	Error += sizeof(glm::uint16) == 2 ? 0 : 1;
+	Error += sizeof(glm::uint32) == 4 ? 0 : 1;
+	Error += sizeof(glm::uint64) == 8 ? 0 : 1;
+
+	return Error;
+}
+
+static int test_comp()
+{
+	int Error = 0;
+
+	Error += sizeof(glm::uint8) < sizeof(glm::uint16) ? 0 : 1;
+	Error += sizeof(glm::uint16) < sizeof(glm::uint32) ? 0 : 1;
+	Error += sizeof(glm::uint32) < sizeof(glm::uint64) ? 0 : 1;
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_size();
+	Error += test_comp();
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/ext/ext_scalar_ulp.cpp b/3rdparty/glm/source/test/ext/ext_scalar_ulp.cpp
new file mode 100644
index 0000000..a19b774
--- /dev/null
+++ b/3rdparty/glm/source/test/ext/ext_scalar_ulp.cpp
@@ -0,0 +1,96 @@
+#include <glm/ext/scalar_ulp.hpp>
+#include <glm/ext/scalar_relational.hpp>
+
+static int test_ulp_float_dist()
+{
+	int Error = 0;
+
+	float A = 1.0f;
+
+	float B = glm::nextFloat(A);
+	Error += glm::notEqual(A, B, 0) ? 0 : 1;
+	float C = glm::prevFloat(B);
+	Error += glm::equal(A, C, 0) ? 0 : 1;
+
+	int D = glm::floatDistance(A, B);
+	Error += D == 1 ? 0 : 1;
+	int E = glm::floatDistance(A, C);
+	Error += E == 0 ? 0 : 1;
+
+	return Error;
+}
+
+static int test_ulp_float_step()
+{
+	int Error = 0;
+
+	float A = 1.0f;
+
+	for(int i = 10; i < 1000; i *= 10)
+	{
+		float B = glm::nextFloat(A, i);
+		Error += glm::notEqual(A, B, 0) ? 0 : 1;
+		float C = glm::prevFloat(B, i);
+		Error += glm::equal(A, C, 0) ? 0 : 1;
+
+		int D = glm::floatDistance(A, B);
+		Error += D == i ? 0 : 1;
+		int E = glm::floatDistance(A, C);
+		Error += E == 0 ? 0 : 1;
+	}
+
+	return Error;
+}
+
+static int test_ulp_double_dist()
+{
+	int Error = 0;
+
+	double A = 1.0;
+
+	double B = glm::nextFloat(A);
+	Error += glm::notEqual(A, B, 0) ? 0 : 1;
+	double C = glm::prevFloat(B);
+	Error += glm::equal(A, C, 0) ? 0 : 1;
+
+	glm::int64 const D = glm::floatDistance(A, B);
+	Error += D == 1 ? 0 : 1;
+	glm::int64 const E = glm::floatDistance(A, C);
+	Error += E == 0 ? 0 : 1;
+
+	return Error;
+}
+
+static int test_ulp_double_step()
+{
+	int Error = 0;
+
+	double A = 1.0;
+
+	for(int i = 10; i < 1000; i *= 10)
+	{
+		double B = glm::nextFloat(A, i);
+		Error += glm::notEqual(A, B, 0) ? 0 : 1;
+		double C = glm::prevFloat(B, i);
+		Error += glm::equal(A, C, 0) ? 0 : 1;
+
+		glm::int64 const D = glm::floatDistance(A, B);
+		Error += D == i ? 0 : 1;
+		glm::int64 const E = glm::floatDistance(A, C);
+		Error += E == 0 ? 0 : 1;
+	}
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_ulp_float_dist();
+	Error += test_ulp_float_step();
+	Error += test_ulp_double_dist();
+	Error += test_ulp_double_step();
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/ext/ext_vec1.cpp b/3rdparty/glm/source/test/ext/ext_vec1.cpp
new file mode 100644
index 0000000..fc0b931
--- /dev/null
+++ b/3rdparty/glm/source/test/ext/ext_vec1.cpp
@@ -0,0 +1,157 @@
+#define GLM_FORCE_SWIZZLE
+#include <glm/vector_relational.hpp>
+#include <glm/gtc/vec1.hpp>
+#include <vector>
+
+static glm::vec1 g1;
+static glm::vec1 g2(1);
+
+static int test_vec1_operators()
+{
+	int Error(0);
+
+	glm::ivec1 A(1);
+	glm::ivec1 B(1);
+	{
+		bool R = A != B;
+		bool S = A == B;
+
+		Error += (S && !R) ? 0 : 1;
+	}
+
+	{
+		A *= 1;
+		B *= 1;
+		A += 1;
+		B += 1;
+
+		bool R = A != B;
+		bool S = A == B;
+
+		Error += (S && !R) ? 0 : 1;
+	}
+
+	return Error;
+}
+
+static int test_vec1_ctor()
+{
+	int Error = 0;
+
+#	if GLM_HAS_TRIVIAL_QUERIES
+	//	Error += std::is_trivially_default_constructible<glm::vec1>::value ? 0 : 1;
+	//	Error += std::is_trivially_copy_assignable<glm::vec1>::value ? 0 : 1;
+		Error += std::is_trivially_copyable<glm::vec1>::value ? 0 : 1;
+		Error += std::is_trivially_copyable<glm::dvec1>::value ? 0 : 1;
+		Error += std::is_trivially_copyable<glm::ivec1>::value ? 0 : 1;
+		Error += std::is_trivially_copyable<glm::uvec1>::value ? 0 : 1;
+
+		Error += std::is_copy_constructible<glm::vec1>::value ? 0 : 1;
+#	endif
+
+
+	{
+		glm::ivec1 A = glm::vec1(2.0f);
+
+		glm::ivec1 E(glm::dvec1(2.0));
+		Error += A == E ? 0 : 1;
+
+		glm::ivec1 F(glm::ivec1(2));
+		Error += A == F ? 0 : 1;
+	}
+
+	return Error;
+}
+
+static int test_vec1_size()
+{
+	int Error = 0;
+
+	Error += sizeof(glm::vec1) == sizeof(glm::mediump_vec1) ? 0 : 1;
+	Error += 4 == sizeof(glm::mediump_vec1) ? 0 : 1;
+	Error += sizeof(glm::dvec1) == sizeof(glm::highp_dvec1) ? 0 : 1;
+	Error += 8 == sizeof(glm::highp_dvec1) ? 0 : 1;
+	Error += glm::vec1().length() == 1 ? 0 : 1;
+	Error += glm::dvec1().length() == 1 ? 0 : 1;
+	Error += glm::vec1::length() == 1 ? 0 : 1;
+	Error += glm::dvec1::length() == 1 ? 0 : 1;
+
+	GLM_CONSTEXPR std::size_t Length = glm::vec1::length();
+	Error += Length == 1 ? 0 : 1;
+
+	return Error;
+}
+
+static int test_vec1_operator_increment()
+{
+	int Error(0);
+
+	glm::ivec1 v0(1);
+	glm::ivec1 v1(v0);
+	glm::ivec1 v2(v0);
+	glm::ivec1 v3 = ++v1;
+	glm::ivec1 v4 = v2++;
+
+	Error += glm::all(glm::equal(v0, v4)) ? 0 : 1;
+	Error += glm::all(glm::equal(v1, v2)) ? 0 : 1;
+	Error += glm::all(glm::equal(v1, v3)) ? 0 : 1;
+
+	int i0(1);
+	int i1(i0);
+	int i2(i0);
+	int i3 = ++i1;
+	int i4 = i2++;
+
+	Error += i0 == i4 ? 0 : 1;
+	Error += i1 == i2 ? 0 : 1;
+	Error += i1 == i3 ? 0 : 1;
+
+	return Error;
+}
+
+static int test_bvec1_ctor()
+{
+	int Error = 0;
+
+	glm::bvec1 const A(true);
+	glm::bvec1 const B(true);
+	glm::bvec1 const C(false);
+	glm::bvec1 const D = A && B;
+	glm::bvec1 const E = A && C;
+	glm::bvec1 const F = A || C;
+
+	Error += D == glm::bvec1(true) ? 0 : 1;
+	Error += E == glm::bvec1(false) ? 0 : 1;
+	Error += F == glm::bvec1(true) ? 0 : 1;
+
+	bool const G = A == C;
+	bool const H = A != C;
+	Error += !G ? 0 : 1;
+	Error += H ? 0 : 1;
+
+	return Error;
+}
+
+static int test_constexpr()
+{
+#if GLM_HAS_CONSTEXPR
+	static_assert(glm::vec1::length() == 1, "GLM: Failed constexpr");
+	static_assert(glm::vec1(1.0f).x > 0.0f, "GLM: Failed constexpr");
+#endif
+
+	return 0;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_vec1_size();
+	Error += test_vec1_ctor();
+	Error += test_bvec1_ctor();
+	Error += test_vec1_operators();
+	Error += test_vec1_operator_increment();
+	Error += test_constexpr();
+	
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/ext/ext_vector_bool1.cpp b/3rdparty/glm/source/test/ext/ext_vector_bool1.cpp
new file mode 100644
index 0000000..43eed57
--- /dev/null
+++ b/3rdparty/glm/source/test/ext/ext_vector_bool1.cpp
@@ -0,0 +1,104 @@
+#include <glm/ext/vector_bool1.hpp>
+#include <glm/ext/vector_bool1_precision.hpp>
+
+template <typename genType>
+static int test_operators()
+{
+	int Error = 0;
+
+	genType const A(true);
+	genType const B(true);
+	{
+		bool const R = A != B;
+		bool const S = A == B;
+		Error += (S && !R) ? 0 : 1;
+	}
+
+	return Error;
+}
+
+template <typename genType>
+static int test_ctor()
+{
+	int Error = 0;
+
+	glm::bvec1 const A = genType(true);
+
+	glm::bvec1 const E(genType(true));
+	Error += A == E ? 0 : 1;
+
+	glm::bvec1 const F(E);
+	Error += A == F ? 0 : 1;
+
+	return Error;
+}
+
+template <typename genType>
+static int test_size()
+{
+	int Error = 0;
+
+	Error += sizeof(glm::bvec1) == sizeof(genType) ? 0 : 1;
+	Error += genType().length() == 1 ? 0 : 1;
+	Error += genType::length() == 1 ? 0 : 1;
+
+	return Error;
+}
+
+template <typename genType>
+static int test_relational()
+{
+	int Error = 0;
+
+	genType const A(true);
+	genType const B(true);
+	genType const C(false);
+
+	Error += A == B ? 0 : 1;
+	Error += (A && B) == A ? 0 : 1;
+	Error += (A || C) == A ? 0 : 1;
+
+	return Error;
+}
+
+template <typename genType>
+static int test_constexpr()
+{
+#	if GLM_HAS_CONSTEXPR
+		static_assert(genType::length() == 1, "GLM: Failed constexpr");
+#	endif
+
+	return 0;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_operators<glm::bvec1>();
+	Error += test_operators<glm::lowp_bvec1>();
+	Error += test_operators<glm::mediump_bvec1>();
+	Error += test_operators<glm::highp_bvec1>();
+
+	Error += test_ctor<glm::bvec1>();
+	Error += test_ctor<glm::lowp_bvec1>();
+	Error += test_ctor<glm::mediump_bvec1>();
+	Error += test_ctor<glm::highp_bvec1>();
+
+	Error += test_size<glm::bvec1>();
+	Error += test_size<glm::lowp_bvec1>();
+	Error += test_size<glm::mediump_bvec1>();
+	Error += test_size<glm::highp_bvec1>();
+
+	Error += test_relational<glm::bvec1>();
+	Error += test_relational<glm::lowp_bvec1>();
+	Error += test_relational<glm::mediump_bvec1>();
+	Error += test_relational<glm::highp_bvec1>();
+
+	Error += test_constexpr<glm::bvec1>();
+	Error += test_constexpr<glm::lowp_bvec1>();
+	Error += test_constexpr<glm::mediump_bvec1>();
+	Error += test_constexpr<glm::highp_bvec1>();
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/ext/ext_vector_common.cpp b/3rdparty/glm/source/test/ext/ext_vector_common.cpp
new file mode 100644
index 0000000..211003f
--- /dev/null
+++ b/3rdparty/glm/source/test/ext/ext_vector_common.cpp
@@ -0,0 +1,365 @@
+#include <glm/ext/vector_common.hpp>
+
+#include <glm/ext/vector_bool1.hpp>
+#include <glm/ext/vector_bool1_precision.hpp>
+#include <glm/ext/vector_bool2.hpp>
+#include <glm/ext/vector_bool2_precision.hpp>
+#include <glm/ext/vector_bool3.hpp>
+#include <glm/ext/vector_bool3_precision.hpp>
+#include <glm/ext/vector_bool4.hpp>
+#include <glm/ext/vector_bool4_precision.hpp>
+
+#include <glm/ext/vector_float1.hpp>
+#include <glm/ext/vector_float1_precision.hpp>
+#include <glm/ext/vector_float2.hpp>
+#include <glm/ext/vector_float2_precision.hpp>
+#include <glm/ext/vector_float3.hpp>
+#include <glm/ext/vector_float3_precision.hpp>
+#include <glm/ext/vector_float4.hpp>
+#include <glm/ext/vector_float4_precision.hpp>
+#include <glm/ext/vector_double1.hpp>
+#include <glm/ext/vector_double1_precision.hpp>
+#include <glm/ext/vector_double2.hpp>
+#include <glm/ext/vector_double2_precision.hpp>
+#include <glm/ext/vector_double3.hpp>
+#include <glm/ext/vector_double3_precision.hpp>
+#include <glm/ext/vector_double4.hpp>
+#include <glm/ext/vector_double4_precision.hpp>
+#include <glm/ext/vector_relational.hpp>
+#include <glm/ext/scalar_constants.hpp>
+#include <glm/vector_relational.hpp>
+#include <glm/common.hpp>
+
+#if ((GLM_LANG & GLM_LANG_CXX11_FLAG) || (GLM_COMPILER & GLM_COMPILER_VC))
+#	define GLM_NAN(T) NAN
+#else
+#	define GLM_NAN(T) (static_cast<T>(0.0f) / static_cast<T>(0.0f))
+#endif
+
+template <typename vecType>
+static int test_min()
+{
+	typedef typename vecType::value_type T;
+
+	int Error = 0;
+
+	vecType const N(static_cast<T>(0));
+	vecType const B(static_cast<T>(1));
+
+	Error += glm::all(glm::equal(glm::min(N, B), N, glm::epsilon<T>())) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::min(B, N), N, glm::epsilon<T>())) ? 0 : 1;
+
+	vecType const C(static_cast<T>(2));
+	Error += glm::all(glm::equal(glm::min(N, B, C), N, glm::epsilon<T>())) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::min(B, N, C), N, glm::epsilon<T>())) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::min(C, N, B), N, glm::epsilon<T>())) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::min(C, B, N), N, glm::epsilon<T>())) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::min(B, C, N), N, glm::epsilon<T>())) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::min(N, C, B), N, glm::epsilon<T>())) ? 0 : 1;
+
+	vecType const D(static_cast<T>(3));
+	Error += glm::all(glm::equal(glm::min(D, N, B, C), N, glm::epsilon<T>())) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::min(B, D, N, C), N, glm::epsilon<T>())) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::min(C, N, D, B), N, glm::epsilon<T>())) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::min(C, B, D, N), N, glm::epsilon<T>())) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::min(B, C, N, D), N, glm::epsilon<T>())) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::min(N, C, B, D), N, glm::epsilon<T>())) ? 0 : 1;
+
+	return Error;
+}
+
+template <typename vecType>
+static int test_min_nan()
+{
+	typedef typename vecType::value_type T;
+
+	int Error = 0;
+
+	vecType const B(static_cast<T>(1));
+	vecType const N(GLM_NAN(T));
+
+	Error += glm::all(glm::isnan(glm::min(N, B))) ? 0 : 1;
+	Error += !glm::all(glm::isnan(glm::min(B, N))) ? 0 : 1;
+
+	vecType const C(static_cast<T>(2));
+	Error += glm::all(glm::isnan(glm::min(N, B, C))) ? 0 : 1;
+	Error += !glm::all(glm::isnan(glm::min(B, N, C))) ? 0 : 1;
+	Error += !glm::all(glm::isnan(glm::min(C, N, B))) ? 0 : 1;
+	Error += !glm::all(glm::isnan(glm::min(C, B, N))) ? 0 : 1;
+	Error += !glm::all(glm::isnan(glm::min(B, C, N))) ? 0 : 1;
+	Error += glm::all(glm::isnan(glm::min(N, C, B))) ? 0 : 1;
+
+	vecType const D(static_cast<T>(3));
+	Error += !glm::all(glm::isnan(glm::min(D, N, B, C))) ? 0 : 1;
+	Error += !glm::all(glm::isnan(glm::min(B, D, N, C))) ? 0 : 1;
+	Error += !glm::all(glm::isnan(glm::min(C, N, D, B))) ? 0 : 1;
+	Error += !glm::all(glm::isnan(glm::min(C, B, D, N))) ? 0 : 1;
+	Error += !glm::all(glm::isnan(glm::min(B, C, N, D))) ? 0 : 1;
+	Error += glm::all(glm::isnan(glm::min(N, C, B, D))) ? 0 : 1;
+
+	return Error;
+}
+
+template <typename vecType>
+static int test_max()
+{
+	typedef typename vecType::value_type T;
+
+	int Error = 0;
+
+	vecType const N(static_cast<T>(0));
+	vecType const B(static_cast<T>(1));
+	Error += glm::all(glm::equal(glm::max(N, B), B, glm::epsilon<T>())) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::max(B, N), B, glm::epsilon<T>())) ? 0 : 1;
+
+	vecType const C(static_cast<T>(2));
+	Error += glm::all(glm::equal(glm::max(N, B, C), C, glm::epsilon<T>())) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::max(B, N, C), C, glm::epsilon<T>())) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::max(C, N, B), C, glm::epsilon<T>())) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::max(C, B, N), C, glm::epsilon<T>())) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::max(B, C, N), C, glm::epsilon<T>())) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::max(N, C, B), C, glm::epsilon<T>())) ? 0 : 1;
+
+	vecType const D(static_cast<T>(3));
+	Error += glm::all(glm::equal(glm::max(D, N, B, C), D, glm::epsilon<T>())) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::max(B, D, N, C), D, glm::epsilon<T>())) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::max(C, N, D, B), D, glm::epsilon<T>())) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::max(C, B, D, N), D, glm::epsilon<T>())) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::max(B, C, N, D), D, glm::epsilon<T>())) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::max(N, C, B, D), D, glm::epsilon<T>())) ? 0 : 1;
+
+	return Error;
+}
+
+template <typename vecType>
+static int test_max_nan()
+{
+	typedef typename vecType::value_type T;
+
+	int Error = 0;
+
+	vecType const B(static_cast<T>(1));
+	vecType const N(GLM_NAN(T));
+
+	Error += glm::all(glm::isnan(glm::max(N, B))) ? 0 : 1;
+	Error += !glm::all(glm::isnan(glm::max(B, N))) ? 0 : 1;
+
+	vecType const C(static_cast<T>(2));
+	Error += glm::all(glm::isnan(glm::max(N, B, C))) ? 0 : 1;
+	Error += !glm::all(glm::isnan(glm::max(B, N, C))) ? 0 : 1;
+	Error += !glm::all(glm::isnan(glm::max(C, N, B))) ? 0 : 1;
+	Error += !glm::all(glm::isnan(glm::max(C, B, N))) ? 0 : 1;
+	Error += !glm::all(glm::isnan(glm::max(B, C, N))) ? 0 : 1;
+	Error += glm::all(glm::isnan(glm::max(N, C, B))) ? 0 : 1;
+
+	vecType const D(static_cast<T>(3));
+	Error += !glm::all(glm::isnan(glm::max(D, N, B, C))) ? 0 : 1;
+	Error += !glm::all(glm::isnan(glm::max(B, D, N, C))) ? 0 : 1;
+	Error += !glm::all(glm::isnan(glm::max(C, N, D, B))) ? 0 : 1;
+	Error += !glm::all(glm::isnan(glm::max(C, B, D, N))) ? 0 : 1;
+	Error += !glm::all(glm::isnan(glm::max(B, C, N, D))) ? 0 : 1;
+	Error += glm::all(glm::isnan(glm::max(N, C, B, D))) ? 0 : 1;
+
+	return Error;
+}
+
+template <typename vecType>
+static int test_fmin()
+{
+	typedef typename vecType::value_type T;
+
+	int Error = 0;
+
+	vecType const B(static_cast<T>(1));
+	vecType const N(GLM_NAN(T));
+
+	Error += glm::all(glm::equal(glm::fmin(N, B), B, glm::epsilon<T>())) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::fmin(B, N), B, glm::epsilon<T>())) ? 0 : 1;
+
+	vecType const C(static_cast<T>(2));
+	Error += glm::all(glm::equal(glm::fmin(N, B, C), B, glm::epsilon<T>())) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::fmin(B, N, C), B, glm::epsilon<T>())) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::fmin(C, N, B), B, glm::epsilon<T>())) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::fmin(C, B, N), B, glm::epsilon<T>())) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::fmin(B, C, N), B, glm::epsilon<T>())) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::fmin(N, C, B), B, glm::epsilon<T>())) ? 0 : 1;
+
+	vecType const D(static_cast<T>(3));
+	Error += glm::all(glm::equal(glm::fmin(D, N, B, C), B, glm::epsilon<T>())) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::fmin(B, D, N, C), B, glm::epsilon<T>())) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::fmin(C, N, D, B), B, glm::epsilon<T>())) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::fmin(C, B, D, N), B, glm::epsilon<T>())) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::fmin(B, C, N, D), B, glm::epsilon<T>())) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::fmin(N, C, B, D), B, glm::epsilon<T>())) ? 0 : 1;
+
+	return Error;
+}
+
+template <typename vecType>
+static int test_fmax()
+{
+	typedef typename vecType::value_type T;
+
+	int Error = 0;
+
+	vecType const B(static_cast<T>(1));
+	vecType const N(GLM_NAN(T));
+
+	Error += glm::all(glm::equal(glm::fmax(N, B), B, glm::epsilon<T>())) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::fmax(B, N), B, glm::epsilon<T>())) ? 0 : 1;
+
+	vecType const C(static_cast<T>(2));
+	Error += glm::all(glm::equal(glm::fmax(N, B, C), C, glm::epsilon<T>())) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::fmax(B, N, C), C, glm::epsilon<T>())) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::fmax(C, N, B), C, glm::epsilon<T>())) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::fmax(C, B, N), C, glm::epsilon<T>())) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::fmax(B, C, N), C, glm::epsilon<T>())) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::fmax(N, C, B), C, glm::epsilon<T>())) ? 0 : 1;
+
+	vecType const D(static_cast<T>(3));
+	Error += glm::all(glm::equal(glm::fmax(D, N, B, C), D, glm::epsilon<T>())) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::fmax(B, D, N, C), D, glm::epsilon<T>())) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::fmax(C, N, D, B), D, glm::epsilon<T>())) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::fmax(C, B, D, N), D, glm::epsilon<T>())) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::fmax(B, C, N, D), D, glm::epsilon<T>())) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::fmax(N, C, B, D), D, glm::epsilon<T>())) ? 0 : 1;
+
+	return Error;
+}
+
+static int test_clamp()
+{
+	int Error = 0;
+
+	glm::vec2 K = glm::clamp(glm::vec2(0.5f));
+	Error += glm::all(glm::equal(K, glm::vec2(0.5f), glm::vec2(0.00001f))) ? 0 : 1;
+
+	glm::vec3 L = glm::clamp(glm::vec3(0.5f));
+	Error += glm::all(glm::equal(L, glm::vec3(0.5f), glm::vec3(0.00001f))) ? 0 : 1;
+
+	glm::vec4 M = glm::clamp(glm::vec4(0.5f));
+	Error += glm::all(glm::equal(M, glm::vec4(0.5f), glm::vec4(0.00001f))) ? 0 : 1;
+
+	glm::vec1 N = glm::clamp(glm::vec1(0.5f));
+	Error += glm::all(glm::equal(N, glm::vec1(0.5f), glm::vec1(0.00001f))) ? 0 : 1;
+
+	return Error;
+}
+
+static int test_repeat()
+{
+	int Error = 0;
+
+	glm::vec2 K = glm::repeat(glm::vec2(0.5f));
+	Error += glm::all(glm::equal(K, glm::vec2(0.5f), glm::vec2(0.00001f))) ? 0 : 1;
+
+	glm::vec3 L = glm::repeat(glm::vec3(0.5f));
+	Error += glm::all(glm::equal(L, glm::vec3(0.5f), glm::vec3(0.00001f))) ? 0 : 1;
+
+	glm::vec4 M = glm::repeat(glm::vec4(0.5f));
+	Error += glm::all(glm::equal(M, glm::vec4(0.5f), glm::vec4(0.00001f))) ? 0 : 1;
+
+	glm::vec1 N = glm::repeat(glm::vec1(0.5f));
+	Error += glm::all(glm::equal(N, glm::vec1(0.5f), glm::vec1(0.00001f))) ? 0 : 1;
+
+	return Error;
+}
+
+static int test_mirrorClamp()
+{
+	int Error = 0;
+
+	glm::vec2 K = glm::mirrorClamp(glm::vec2(0.5f));
+	Error += glm::all(glm::equal(K, glm::vec2(0.5f), glm::vec2(0.00001f))) ? 0 : 1;
+
+	glm::vec3 L = glm::mirrorClamp(glm::vec3(0.5f));
+	Error += glm::all(glm::equal(L, glm::vec3(0.5f), glm::vec3(0.00001f))) ? 0 : 1;
+
+	glm::vec4 M = glm::mirrorClamp(glm::vec4(0.5f));
+	Error += glm::all(glm::equal(M, glm::vec4(0.5f), glm::vec4(0.00001f))) ? 0 : 1;
+
+	glm::vec1 N = glm::mirrorClamp(glm::vec1(0.5f));
+	Error += glm::all(glm::equal(N, glm::vec1(0.5f), glm::vec1(0.00001f))) ? 0 : 1;
+
+	return Error;
+}
+
+static int test_mirrorRepeat()
+{
+	int Error = 0;
+
+	glm::vec2 K = glm::mirrorRepeat(glm::vec2(0.5f));
+	Error += glm::all(glm::equal(K, glm::vec2(0.5f), glm::vec2(0.00001f))) ? 0 : 1;
+
+	glm::vec3 L = glm::mirrorRepeat(glm::vec3(0.5f));
+	Error += glm::all(glm::equal(L, glm::vec3(0.5f), glm::vec3(0.00001f))) ? 0 : 1;
+
+	glm::vec4 M = glm::mirrorRepeat(glm::vec4(0.5f));
+	Error += glm::all(glm::equal(M, glm::vec4(0.5f), glm::vec4(0.00001f))) ? 0 : 1;
+
+	glm::vec1 N = glm::mirrorRepeat(glm::vec1(0.5f));
+	Error += glm::all(glm::equal(N, glm::vec1(0.5f), glm::vec1(0.00001f))) ? 0 : 1;
+
+	return Error;
+}
+
+static int test_iround()
+{
+	int Error = 0;
+
+	for(float f = 0.0f; f < 3.1f; f += 0.05f)
+	{
+		int RoundFast = static_cast<int>(glm::iround(f));
+		int RoundSTD = static_cast<int>(glm::round(f));
+		Error += RoundFast == RoundSTD ? 0 : 1;
+		assert(!Error);
+	}
+
+	return Error;
+}
+
+static int test_uround()
+{
+	int Error = 0;
+
+	for(float f = 0.0f; f < 3.1f; f += 0.05f)
+	{
+		int RoundFast = static_cast<int>(glm::uround(f));
+		int RoundSTD = static_cast<int>(glm::round(f));
+		Error += RoundFast == RoundSTD ? 0 : 1;
+		assert(!Error);
+	}
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_min<glm::vec3>();
+	Error += test_min<glm::vec2>();
+	Error += test_min_nan<glm::vec3>();
+	Error += test_min_nan<glm::vec2>();
+
+	Error += test_max<glm::vec3>();
+	Error += test_max<glm::vec2>();
+	Error += test_max_nan<glm::vec3>();
+	Error += test_max_nan<glm::vec2>();
+
+	Error += test_fmin<glm::vec3>();
+	Error += test_fmin<glm::vec2>();
+
+	Error += test_fmax<glm::vec3>();
+	Error += test_fmax<glm::vec2>();
+
+	Error += test_clamp();
+	Error += test_repeat();
+	Error += test_mirrorClamp();
+	Error += test_mirrorRepeat();
+
+	Error += test_iround();
+	Error += test_uround();
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/ext/ext_vector_iec559.cpp b/3rdparty/glm/source/test/ext/ext_vector_iec559.cpp
new file mode 100644
index 0000000..5a9da50
--- /dev/null
+++ b/3rdparty/glm/source/test/ext/ext_vector_iec559.cpp
@@ -0,0 +1,166 @@
+#include <glm/gtc/constants.hpp>
+#include <glm/ext/scalar_relational.hpp>
+#include <glm/ext/vector_relational.hpp>
+#include <glm/ext/vector_double1.hpp>
+#include <glm/ext/vector_double1_precision.hpp>
+#include <glm/ext/vector_double2.hpp>
+#include <glm/ext/vector_double3.hpp>
+#include <glm/ext/vector_double4.hpp>
+#include <glm/ext/vector_float1.hpp>
+#include <glm/ext/vector_float1_precision.hpp>
+#include <glm/ext/vector_float2.hpp>
+#include <glm/ext/vector_float3.hpp>
+#include <glm/ext/vector_float4.hpp>
+
+template <typename genType>
+static int test_operators()
+{
+	typedef typename genType::value_type valType;
+	
+	int Error = 0;
+
+	{
+		genType const A(1);
+		genType const B(1);
+
+		genType const C = A + B;
+		Error += glm::all(glm::equal(C, genType(2), glm::epsilon<valType>())) ? 0 : 1;
+
+		genType const D = A - B;
+		Error += glm::all(glm::equal(D, genType(0), glm::epsilon<valType>())) ? 0 : 1;
+
+		genType const E = A * B;
+		Error += glm::all(glm::equal(E, genType(1), glm::epsilon<valType>())) ? 0 : 1;
+
+		genType const F = A / B;
+		Error += glm::all(glm::equal(F, genType(1), glm::epsilon<valType>())) ? 0 : 1;
+	}
+
+	return Error;
+}
+
+template <typename genType>
+static int test_ctor()
+{
+	typedef typename genType::value_type T;
+	
+	int Error = 0;
+
+	glm::vec<1, T> const A = genType(1);
+
+	glm::vec<1, T> const E(genType(1));
+	Error += glm::all(glm::equal(A, E, glm::epsilon<T>())) ? 0 : 1;
+
+	glm::vec<1, T> const F(E);
+	Error += glm::all(glm::equal(A, F, glm::epsilon<T>())) ? 0 : 1;
+
+	genType const B = genType(1);
+	genType const G(glm::vec<2, T>(1));
+	Error += glm::all(glm::equal(B, G, glm::epsilon<T>())) ? 0 : 1;
+
+	genType const H(glm::vec<3, T>(1));
+	Error += glm::all(glm::equal(B, H, glm::epsilon<T>())) ? 0 : 1;
+
+	genType const I(glm::vec<4, T>(1));
+	Error += glm::all(glm::equal(B, I, glm::epsilon<T>())) ? 0 : 1;
+
+	return Error;
+}
+
+template <typename genType>
+static int test_size()
+{
+	typedef typename genType::value_type T;
+	
+	int Error = 0;
+
+	Error += sizeof(glm::vec<1, T>) == sizeof(genType) ? 0 : 1;
+	Error += genType().length() == 1 ? 0 : 1;
+	Error += genType::length() == 1 ? 0 : 1;
+
+	return Error;
+}
+
+template <typename genType>
+static int test_relational()
+{
+	typedef typename genType::value_type valType;
+	
+	int Error = 0;
+
+	genType const A(1);
+	genType const B(1);
+	genType const C(0);
+
+	Error += all(equal(A, B, glm::epsilon<valType>())) ? 0 : 1;
+	Error += any(notEqual(A, C, glm::epsilon<valType>())) ? 0 : 1;
+
+	return Error;
+}
+
+template <typename genType>
+static int test_constexpr()
+{
+#	if GLM_CONFIG_CONSTEXP == GLM_ENABLE
+		static_assert(genType::length() == 1, "GLM: Failed constexpr");
+#	endif
+
+	return 0;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_operators<glm::dvec1>();
+	Error += test_operators<glm::lowp_dvec1>();
+	Error += test_operators<glm::mediump_dvec1>();
+	Error += test_operators<glm::highp_dvec1>();
+
+	Error += test_ctor<glm::dvec1>();
+	Error += test_ctor<glm::lowp_dvec1>();
+	Error += test_ctor<glm::mediump_dvec1>();
+	Error += test_ctor<glm::highp_dvec1>();
+
+	Error += test_size<glm::dvec1>();
+	Error += test_size<glm::lowp_dvec1>();
+	Error += test_size<glm::mediump_dvec1>();
+	Error += test_size<glm::highp_dvec1>();
+
+	Error += test_relational<glm::dvec1>();
+	Error += test_relational<glm::lowp_dvec1>();
+	Error += test_relational<glm::mediump_dvec1>();
+	Error += test_relational<glm::highp_dvec1>();
+
+	Error += test_constexpr<glm::dvec1>();
+	Error += test_constexpr<glm::lowp_dvec1>();
+	Error += test_constexpr<glm::mediump_dvec1>();
+	Error += test_constexpr<glm::highp_dvec1>();
+
+	Error += test_operators<glm::vec1>();
+	Error += test_operators<glm::lowp_vec1>();
+	Error += test_operators<glm::mediump_vec1>();
+	Error += test_operators<glm::highp_vec1>();
+	
+	Error += test_ctor<glm::vec1>();
+	Error += test_ctor<glm::lowp_vec1>();
+	Error += test_ctor<glm::mediump_vec1>();
+	Error += test_ctor<glm::highp_vec1>();
+	
+	Error += test_size<glm::vec1>();
+	Error += test_size<glm::lowp_vec1>();
+	Error += test_size<glm::mediump_vec1>();
+	Error += test_size<glm::highp_vec1>();
+	
+	Error += test_relational<glm::vec1>();
+	Error += test_relational<glm::lowp_vec1>();
+	Error += test_relational<glm::mediump_vec1>();
+	Error += test_relational<glm::highp_vec1>();
+	
+	Error += test_constexpr<glm::vec1>();
+	Error += test_constexpr<glm::lowp_vec1>();
+	Error += test_constexpr<glm::mediump_vec1>();
+	Error += test_constexpr<glm::highp_vec1>();
+	
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/ext/ext_vector_int1_sized.cpp b/3rdparty/glm/source/test/ext/ext_vector_int1_sized.cpp
new file mode 100644
index 0000000..c262f49
--- /dev/null
+++ b/3rdparty/glm/source/test/ext/ext_vector_int1_sized.cpp
@@ -0,0 +1,41 @@
+#include <glm/ext/vector_int1_sized.hpp>
+
+#if GLM_HAS_STATIC_ASSERT
+	static_assert(sizeof(glm::i8vec1) == 1, "int8 size isn't 1 byte on this platform");
+	static_assert(sizeof(glm::i16vec1) == 2, "int16 size isn't 2 bytes on this platform");
+	static_assert(sizeof(glm::i32vec1) == 4, "int32 size isn't 4 bytes on this platform");
+	static_assert(sizeof(glm::i64vec1) == 8, "int64 size isn't 8 bytes on this platform");
+#endif
+
+static int test_size()
+{
+	int Error = 0;
+
+	Error += sizeof(glm::i8vec1) == 1 ? 0 : 1;
+	Error += sizeof(glm::i16vec1) == 2 ? 0 : 1;
+	Error += sizeof(glm::i32vec1) == 4 ? 0 : 1;
+	Error += sizeof(glm::i64vec1) == 8 ? 0 : 1;
+
+	return Error;
+}
+
+static int test_comp()
+{
+	int Error = 0;
+
+	Error += sizeof(glm::i8vec1) < sizeof(glm::i16vec1) ? 0 : 1;
+	Error += sizeof(glm::i16vec1) < sizeof(glm::i32vec1) ? 0 : 1;
+	Error += sizeof(glm::i32vec1) < sizeof(glm::i64vec1) ? 0 : 1;
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_size();
+	Error += test_comp();
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/ext/ext_vector_int2_sized.cpp b/3rdparty/glm/source/test/ext/ext_vector_int2_sized.cpp
new file mode 100644
index 0000000..f4ad8b6
--- /dev/null
+++ b/3rdparty/glm/source/test/ext/ext_vector_int2_sized.cpp
@@ -0,0 +1,41 @@
+#include <glm/ext/vector_int2_sized.hpp>
+
+#if GLM_HAS_STATIC_ASSERT
+	static_assert(sizeof(glm::i8vec2) == 2, "int8 size isn't 1 byte on this platform");
+	static_assert(sizeof(glm::i16vec2) == 4, "int16 size isn't 2 bytes on this platform");
+	static_assert(sizeof(glm::i32vec2) == 8, "int32 size isn't 4 bytes on this platform");
+	static_assert(sizeof(glm::i64vec2) == 16, "int64 size isn't 8 bytes on this platform");
+#endif
+
+static int test_size()
+{
+	int Error = 0;
+
+	Error += sizeof(glm::i8vec2) == 2 ? 0 : 1;
+	Error += sizeof(glm::i16vec2) == 4 ? 0 : 1;
+	Error += sizeof(glm::i32vec2) == 8 ? 0 : 1;
+	Error += sizeof(glm::i64vec2) == 16 ? 0 : 1;
+
+	return Error;
+}
+
+static int test_comp()
+{
+	int Error = 0;
+
+	Error += sizeof(glm::i8vec2) < sizeof(glm::i16vec2) ? 0 : 1;
+	Error += sizeof(glm::i16vec2) < sizeof(glm::i32vec2) ? 0 : 1;
+	Error += sizeof(glm::i32vec2) < sizeof(glm::i64vec2) ? 0 : 1;
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_size();
+	Error += test_comp();
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/ext/ext_vector_int3_sized.cpp b/3rdparty/glm/source/test/ext/ext_vector_int3_sized.cpp
new file mode 100644
index 0000000..c51bfe7
--- /dev/null
+++ b/3rdparty/glm/source/test/ext/ext_vector_int3_sized.cpp
@@ -0,0 +1,41 @@
+#include <glm/ext/vector_int3_sized.hpp>
+
+#if GLM_HAS_STATIC_ASSERT
+	static_assert(sizeof(glm::i8vec3) == 3, "int8 size isn't 1 byte on this platform");
+	static_assert(sizeof(glm::i16vec3) == 6, "int16 size isn't 2 bytes on this platform");
+	static_assert(sizeof(glm::i32vec3) == 12, "int32 size isn't 4 bytes on this platform");
+	static_assert(sizeof(glm::i64vec3) == 24, "int64 size isn't 8 bytes on this platform");
+#endif
+
+static int test_size()
+{
+	int Error = 0;
+
+	Error += sizeof(glm::i8vec3) == 3 ? 0 : 1;
+	Error += sizeof(glm::i16vec3) == 6 ? 0 : 1;
+	Error += sizeof(glm::i32vec3) == 12 ? 0 : 1;
+	Error += sizeof(glm::i64vec3) == 24 ? 0 : 1;
+
+	return Error;
+}
+
+static int test_comp()
+{
+	int Error = 0;
+
+	Error += sizeof(glm::i8vec3) < sizeof(glm::i16vec3) ? 0 : 1;
+	Error += sizeof(glm::i16vec3) < sizeof(glm::i32vec3) ? 0 : 1;
+	Error += sizeof(glm::i32vec3) < sizeof(glm::i64vec3) ? 0 : 1;
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_size();
+	Error += test_comp();
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/ext/ext_vector_int4_sized.cpp b/3rdparty/glm/source/test/ext/ext_vector_int4_sized.cpp
new file mode 100644
index 0000000..93fd9ed
--- /dev/null
+++ b/3rdparty/glm/source/test/ext/ext_vector_int4_sized.cpp
@@ -0,0 +1,41 @@
+#include <glm/ext/vector_int4_sized.hpp>
+
+#if GLM_HAS_STATIC_ASSERT
+static_assert(sizeof(glm::i8vec4) == 4, "int8 size isn't 1 byte on this platform");
+static_assert(sizeof(glm::i16vec4) == 8, "int16 size isn't 2 bytes on this platform");
+static_assert(sizeof(glm::i32vec4) == 16, "int32 size isn't 4 bytes on this platform");
+static_assert(sizeof(glm::i64vec4) == 32, "int64 size isn't 8 bytes on this platform");
+#endif
+
+static int test_size()
+{
+	int Error = 0;
+
+	Error += sizeof(glm::i8vec4) == 4 ? 0 : 1;
+	Error += sizeof(glm::i16vec4) == 8 ? 0 : 1;
+	Error += sizeof(glm::i32vec4) == 16 ? 0 : 1;
+	Error += sizeof(glm::i64vec4) == 32 ? 0 : 1;
+
+	return Error;
+}
+
+static int test_comp()
+{
+	int Error = 0;
+
+	Error += sizeof(glm::i8vec4) < sizeof(glm::i16vec4) ? 0 : 1;
+	Error += sizeof(glm::i16vec4) < sizeof(glm::i32vec4) ? 0 : 1;
+	Error += sizeof(glm::i32vec4) < sizeof(glm::i64vec4) ? 0 : 1;
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_size();
+	Error += test_comp();
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/ext/ext_vector_integer.cpp b/3rdparty/glm/source/test/ext/ext_vector_integer.cpp
new file mode 100644
index 0000000..d7278d3
--- /dev/null
+++ b/3rdparty/glm/source/test/ext/ext_vector_integer.cpp
@@ -0,0 +1,547 @@
+#include <glm/ext/vector_integer.hpp>
+#include <glm/ext/scalar_int_sized.hpp>
+#include <glm/ext/scalar_uint_sized.hpp>
+#include <vector>
+#include <ctime>
+#include <cstdio>
+
+namespace isPowerOfTwo
+{
+	template<typename genType>
+	struct type
+	{
+		genType		Value;
+		bool		Return;
+	};
+
+	template <glm::length_t L>
+	int test_int16()
+	{
+		type<glm::int16> const Data[] =
+		{
+			{ 0x0001, true },
+			{ 0x0002, true },
+			{ 0x0004, true },
+			{ 0x0080, true },
+			{ 0x0000, true },
+			{ 0x0003, false }
+		};
+
+		int Error = 0;
+
+		for (std::size_t i = 0, n = sizeof(Data) / sizeof(type<glm::int16>); i < n; ++i)
+		{
+			glm::vec<L, bool> const Result = glm::isPowerOfTwo(glm::vec<L, glm::int16>(Data[i].Value));
+			Error += glm::vec<L, bool>(Data[i].Return) == Result ? 0 : 1;
+		}
+
+		return Error;
+	}
+
+	template <glm::length_t L>
+	int test_uint16()
+	{
+		type<glm::uint16> const Data[] =
+		{
+			{ 0x0001, true },
+			{ 0x0002, true },
+			{ 0x0004, true },
+			{ 0x0000, true },
+			{ 0x0000, true },
+			{ 0x0003, false }
+		};
+
+		int Error = 0;
+
+		for (std::size_t i = 0, n = sizeof(Data) / sizeof(type<glm::uint16>); i < n; ++i)
+		{
+			glm::vec<L, bool> const Result = glm::isPowerOfTwo(glm::vec<L, glm::uint16>(Data[i].Value));
+			Error += glm::vec<L, bool>(Data[i].Return) == Result ? 0 : 1;
+		}
+
+		return Error;
+	}
+
+	template <glm::length_t L>
+	int test_int32()
+	{
+		type<int> const Data[] =
+		{
+			{ 0x00000001, true },
+			{ 0x00000002, true },
+			{ 0x00000004, true },
+			{ 0x0000000f, false },
+			{ 0x00000000, true },
+			{ 0x00000003, false }
+		};
+
+		int Error = 0;
+
+		for (std::size_t i = 0, n = sizeof(Data) / sizeof(type<int>); i < n; ++i)
+		{
+			glm::vec<L, bool> const Result = glm::isPowerOfTwo(glm::vec<L, glm::int32>(Data[i].Value));
+			Error += glm::vec<L, bool>(Data[i].Return) == Result ? 0 : 1;
+		}
+
+		return Error;
+	}
+
+	template <glm::length_t L>
+	int test_uint32()
+	{
+		type<glm::uint> const Data[] =
+		{
+			{ 0x00000001, true },
+			{ 0x00000002, true },
+			{ 0x00000004, true },
+			{ 0x80000000, true },
+			{ 0x00000000, true },
+			{ 0x00000003, false }
+		};
+
+		int Error = 0;
+
+		for (std::size_t i = 0, n = sizeof(Data) / sizeof(type<glm::uint>); i < n; ++i)
+		{
+			glm::vec<L, bool> const Result = glm::isPowerOfTwo(glm::vec<L, glm::uint32>(Data[i].Value));
+			Error += glm::vec<L, bool>(Data[i].Return) == Result ? 0 : 1;
+		}
+
+		return Error;
+	}
+
+	int test()
+	{
+		int Error = 0;
+
+		Error += test_int16<1>();
+		Error += test_int16<2>();
+		Error += test_int16<3>();
+		Error += test_int16<4>();
+
+		Error += test_uint16<1>();
+		Error += test_uint16<2>();
+		Error += test_uint16<3>();
+		Error += test_uint16<4>();
+
+		Error += test_int32<1>();
+		Error += test_int32<2>();
+		Error += test_int32<3>();
+		Error += test_int32<4>();
+
+		Error += test_uint32<1>();
+		Error += test_uint32<2>();
+		Error += test_uint32<3>();
+		Error += test_uint32<4>();
+
+		return Error;
+	}
+}//isPowerOfTwo
+
+namespace prevPowerOfTwo
+{
+	template <glm::length_t L, typename T>
+	int run()
+	{
+		int Error = 0;
+
+		glm::vec<L, T> const A = glm::prevPowerOfTwo(glm::vec<L, T>(7));
+		Error += A == glm::vec<L, T>(4) ? 0 : 1;
+
+		glm::vec<L, T> const B = glm::prevPowerOfTwo(glm::vec<L, T>(15));
+		Error += B == glm::vec<L, T>(8) ? 0 : 1;
+
+		glm::vec<L, T> const C = glm::prevPowerOfTwo(glm::vec<L, T>(31));
+		Error += C == glm::vec<L, T>(16) ? 0 : 1;
+
+		glm::vec<L, T> const D = glm::prevPowerOfTwo(glm::vec<L, T>(32));
+		Error += D == glm::vec<L, T>(32) ? 0 : 1;
+
+		return Error;
+	}
+
+	int test()
+	{
+		int Error = 0;
+
+		Error += run<1, glm::int8>();
+		Error += run<2, glm::int8>();
+		Error += run<3, glm::int8>();
+		Error += run<4, glm::int8>();
+
+		Error += run<1, glm::int16>();
+		Error += run<2, glm::int16>();
+		Error += run<3, glm::int16>();
+		Error += run<4, glm::int16>();
+
+		Error += run<1, glm::int32>();
+		Error += run<2, glm::int32>();
+		Error += run<3, glm::int32>();
+		Error += run<4, glm::int32>();
+
+		Error += run<1, glm::int64>();
+		Error += run<2, glm::int64>();
+		Error += run<3, glm::int64>();
+		Error += run<4, glm::int64>();
+
+		Error += run<1, glm::uint8>();
+		Error += run<2, glm::uint8>();
+		Error += run<3, glm::uint8>();
+		Error += run<4, glm::uint8>();
+
+		Error += run<1, glm::uint16>();
+		Error += run<2, glm::uint16>();
+		Error += run<3, glm::uint16>();
+		Error += run<4, glm::uint16>();
+
+		Error += run<1, glm::uint32>();
+		Error += run<2, glm::uint32>();
+		Error += run<3, glm::uint32>();
+		Error += run<4, glm::uint32>();
+
+		Error += run<1, glm::uint64>();
+		Error += run<2, glm::uint64>();
+		Error += run<3, glm::uint64>();
+		Error += run<4, glm::uint64>();
+
+		return Error;
+	}
+}//namespace prevPowerOfTwo
+
+namespace nextPowerOfTwo
+{
+	template <glm::length_t L, typename T>
+	int run()
+	{
+		int Error = 0;
+
+		glm::vec<L, T> const A = glm::nextPowerOfTwo(glm::vec<L, T>(7));
+		Error += A == glm::vec<L, T>(8) ? 0 : 1;
+
+		glm::vec<L, T> const B = glm::nextPowerOfTwo(glm::vec<L, T>(15));
+		Error += B == glm::vec<L, T>(16) ? 0 : 1;
+
+		glm::vec<L, T> const C = glm::nextPowerOfTwo(glm::vec<L, T>(31));
+		Error += C == glm::vec<L, T>(32) ? 0 : 1;
+
+		glm::vec<L, T> const D = glm::nextPowerOfTwo(glm::vec<L, T>(32));
+		Error += D == glm::vec<L, T>(32) ? 0 : 1;
+
+		return Error;
+	}
+
+	int test()
+	{
+		int Error = 0;
+
+		Error += run<1, glm::int8>();
+		Error += run<2, glm::int8>();
+		Error += run<3, glm::int8>();
+		Error += run<4, glm::int8>();
+
+		Error += run<1, glm::int16>();
+		Error += run<2, glm::int16>();
+		Error += run<3, glm::int16>();
+		Error += run<4, glm::int16>();
+
+		Error += run<1, glm::int32>();
+		Error += run<2, glm::int32>();
+		Error += run<3, glm::int32>();
+		Error += run<4, glm::int32>();
+
+		Error += run<1, glm::int64>();
+		Error += run<2, glm::int64>();
+		Error += run<3, glm::int64>();
+		Error += run<4, glm::int64>();
+
+		Error += run<1, glm::uint8>();
+		Error += run<2, glm::uint8>();
+		Error += run<3, glm::uint8>();
+		Error += run<4, glm::uint8>();
+
+		Error += run<1, glm::uint16>();
+		Error += run<2, glm::uint16>();
+		Error += run<3, glm::uint16>();
+		Error += run<4, glm::uint16>();
+
+		Error += run<1, glm::uint32>();
+		Error += run<2, glm::uint32>();
+		Error += run<3, glm::uint32>();
+		Error += run<4, glm::uint32>();
+
+		Error += run<1, glm::uint64>();
+		Error += run<2, glm::uint64>();
+		Error += run<3, glm::uint64>();
+		Error += run<4, glm::uint64>();
+
+		return Error;
+	}
+}//namespace nextPowerOfTwo
+
+namespace prevMultiple
+{
+	template<typename genIUType>
+	struct type
+	{
+		genIUType Source;
+		genIUType Multiple;
+		genIUType Return;
+	};
+
+	template <glm::length_t L, typename T>
+	int run()
+	{
+		type<T> const Data[] =
+		{
+			{ 8, 3, 6 },
+			{ 7, 7, 7 }
+		};
+
+		int Error = 0;
+
+		for (std::size_t i = 0, n = sizeof(Data) / sizeof(type<T>); i < n; ++i)
+		{
+			glm::vec<L, T> const Result0 = glm::prevMultiple(glm::vec<L, T>(Data[i].Source), Data[i].Multiple);
+			Error += glm::vec<L, T>(Data[i].Return) == Result0 ? 0 : 1;
+
+			glm::vec<L, T> const Result1 = glm::prevMultiple(glm::vec<L, T>(Data[i].Source), glm::vec<L, T>(Data[i].Multiple));
+			Error += glm::vec<L, T>(Data[i].Return) == Result1 ? 0 : 1;
+		}
+
+		return Error;
+	}
+
+	int test()
+	{
+		int Error = 0;
+
+		Error += run<1, glm::int8>();
+		Error += run<2, glm::int8>();
+		Error += run<3, glm::int8>();
+		Error += run<4, glm::int8>();
+
+		Error += run<1, glm::int16>();
+		Error += run<2, glm::int16>();
+		Error += run<3, glm::int16>();
+		Error += run<4, glm::int16>();
+
+		Error += run<1, glm::int32>();
+		Error += run<2, glm::int32>();
+		Error += run<3, glm::int32>();
+		Error += run<4, glm::int32>();
+
+		Error += run<1, glm::int64>();
+		Error += run<2, glm::int64>();
+		Error += run<3, glm::int64>();
+		Error += run<4, glm::int64>();
+
+		Error += run<1, glm::uint8>();
+		Error += run<2, glm::uint8>();
+		Error += run<3, glm::uint8>();
+		Error += run<4, glm::uint8>();
+
+		Error += run<1, glm::uint16>();
+		Error += run<2, glm::uint16>();
+		Error += run<3, glm::uint16>();
+		Error += run<4, glm::uint16>();
+
+		Error += run<1, glm::uint32>();
+		Error += run<2, glm::uint32>();
+		Error += run<3, glm::uint32>();
+		Error += run<4, glm::uint32>();
+
+		Error += run<1, glm::uint64>();
+		Error += run<2, glm::uint64>();
+		Error += run<3, glm::uint64>();
+		Error += run<4, glm::uint64>();
+
+		return Error;
+	}
+}//namespace prevMultiple
+
+namespace nextMultiple
+{
+	template<typename genIUType>
+	struct type
+	{
+		genIUType Source;
+		genIUType Multiple;
+		genIUType Return;
+	};
+
+	template <glm::length_t L, typename T>
+	int run()
+	{
+		type<T> const Data[] =
+		{
+			{ 3, 4, 4 },
+			{ 6, 3, 6 },
+			{ 5, 3, 6 },
+			{ 7, 7, 7 },
+			{ 0, 1, 0 },
+			{ 8, 3, 9 }
+		};
+
+		int Error = 0;
+
+		for (std::size_t i = 0, n = sizeof(Data) / sizeof(type<T>); i < n; ++i)
+		{
+			glm::vec<L, T> const Result0 = glm::nextMultiple(glm::vec<L, T>(Data[i].Source), glm::vec<L, T>(Data[i].Multiple));
+			Error += glm::vec<L, T>(Data[i].Return) == Result0 ? 0 : 1;
+
+			glm::vec<L, T> const Result1 = glm::nextMultiple(glm::vec<L, T>(Data[i].Source), Data[i].Multiple);
+			Error += glm::vec<L, T>(Data[i].Return) == Result1 ? 0 : 1;
+		}
+
+		return Error;
+	}
+
+	int test()
+	{
+		int Error = 0;
+
+		Error += run<1, glm::int8>();
+		Error += run<2, glm::int8>();
+		Error += run<3, glm::int8>();
+		Error += run<4, glm::int8>();
+
+		Error += run<1, glm::int16>();
+		Error += run<2, glm::int16>();
+		Error += run<3, glm::int16>();
+		Error += run<4, glm::int16>();
+
+		Error += run<1, glm::int32>();
+		Error += run<2, glm::int32>();
+		Error += run<3, glm::int32>();
+		Error += run<4, glm::int32>();
+
+		Error += run<1, glm::int64>();
+		Error += run<2, glm::int64>();
+		Error += run<3, glm::int64>();
+		Error += run<4, glm::int64>();
+
+		Error += run<1, glm::uint8>();
+		Error += run<2, glm::uint8>();
+		Error += run<3, glm::uint8>();
+		Error += run<4, glm::uint8>();
+
+		Error += run<1, glm::uint16>();
+		Error += run<2, glm::uint16>();
+		Error += run<3, glm::uint16>();
+		Error += run<4, glm::uint16>();
+
+		Error += run<1, glm::uint32>();
+		Error += run<2, glm::uint32>();
+		Error += run<3, glm::uint32>();
+		Error += run<4, glm::uint32>();
+
+		Error += run<1, glm::uint64>();
+		Error += run<2, glm::uint64>();
+		Error += run<3, glm::uint64>();
+		Error += run<4, glm::uint64>();
+
+		return Error;
+	}
+}//namespace nextMultiple
+
+namespace findNSB
+{
+	template<typename T>
+	struct type
+	{
+		T Source;
+		int SignificantBitCount;
+		int Return;
+	};
+
+	template <glm::length_t L, typename T>
+	int run()
+	{
+		type<T> const Data[] =
+		{
+			{ 0x00, 1,-1 },
+			{ 0x01, 2,-1 },
+			{ 0x02, 2,-1 },
+			{ 0x06, 3,-1 },
+			{ 0x01, 1, 0 },
+			{ 0x03, 1, 0 },
+			{ 0x03, 2, 1 },
+			{ 0x07, 2, 1 },
+			{ 0x05, 2, 2 },
+			{ 0x0D, 2, 2 }
+		};
+
+		int Error = 0;
+
+		for (std::size_t i = 0, n = sizeof(Data) / sizeof(type<T>); i < n; ++i)
+		{
+			glm::vec<L, int> const Result0 = glm::findNSB<L, T, glm::defaultp>(glm::vec<L, T>(Data[i].Source), glm::vec<L, int>(Data[i].SignificantBitCount));
+			Error += glm::vec<L, int>(Data[i].Return) == Result0 ? 0 : 1;
+			assert(!Error);
+		}
+
+		return Error;
+	}
+
+	int test()
+	{
+		int Error = 0;
+
+		Error += run<1, glm::uint8>();
+		Error += run<2, glm::uint8>();
+		Error += run<3, glm::uint8>();
+		Error += run<4, glm::uint8>();
+
+		Error += run<1, glm::uint16>();
+		Error += run<2, glm::uint16>();
+		Error += run<3, glm::uint16>();
+		Error += run<4, glm::uint16>();
+
+		Error += run<1, glm::uint32>();
+		Error += run<2, glm::uint32>();
+		Error += run<3, glm::uint32>();
+		Error += run<4, glm::uint32>();
+
+		Error += run<1, glm::uint64>();
+		Error += run<2, glm::uint64>();
+		Error += run<3, glm::uint64>();
+		Error += run<4, glm::uint64>();
+
+		Error += run<1, glm::int8>();
+		Error += run<2, glm::int8>();
+		Error += run<3, glm::int8>();
+		Error += run<4, glm::int8>();
+
+		Error += run<1, glm::int16>();
+		Error += run<2, glm::int16>();
+		Error += run<3, glm::int16>();
+		Error += run<4, glm::int16>();
+
+		Error += run<1, glm::int32>();
+		Error += run<2, glm::int32>();
+		Error += run<3, glm::int32>();
+		Error += run<4, glm::int32>();
+
+		Error += run<1, glm::int64>();
+		Error += run<2, glm::int64>();
+		Error += run<3, glm::int64>();
+		Error += run<4, glm::int64>();
+
+
+		return Error;
+	}
+}//namespace findNSB
+
+int main()
+{
+	int Error = 0;
+
+	Error += isPowerOfTwo::test();
+	Error += prevPowerOfTwo::test();
+	Error += nextPowerOfTwo::test();
+	Error += prevMultiple::test();
+	Error += nextMultiple::test();
+	Error += findNSB::test();
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/ext/ext_vector_integer_sized.cpp b/3rdparty/glm/source/test/ext/ext_vector_integer_sized.cpp
new file mode 100644
index 0000000..52b3f4e
--- /dev/null
+++ b/3rdparty/glm/source/test/ext/ext_vector_integer_sized.cpp
@@ -0,0 +1,216 @@
+#include <glm/ext/vector_integer.hpp>
+#include <glm/ext/vector_int1.hpp>
+#include <glm/ext/vector_int1_sized.hpp>
+#include <glm/ext/vector_uint1.hpp>
+#include <glm/ext/vector_uint1_sized.hpp>
+
+template <typename genType>
+static int test_operators()
+{
+	int Error = 0;
+
+	{
+		genType const A(1);
+		genType const B(1);
+
+		bool const R = A != B;
+		bool const S = A == B;
+		Error += (S && !R) ? 0 : 1;
+	}
+
+	{
+		genType const A(1);
+		genType const B(1);
+
+		genType const C = A + B;
+		Error += C == genType(2) ? 0 : 1;
+
+		genType const D = A - B;
+		Error += D == genType(0) ? 0 : 1;
+
+		genType const E = A * B;
+		Error += E == genType(1) ? 0 : 1;
+
+		genType const F = A / B;
+		Error += F == genType(1) ? 0 : 1;
+	}
+
+	{
+		genType const A(3);
+		genType const B(2);
+
+		genType const C = A % B;
+		Error += C == genType(1) ? 0 : 1;
+	}
+
+	{
+		genType const A(1);
+		genType const B(1);
+		genType const C(0);
+
+		genType const I = A & B;
+		Error += I == genType(1) ? 0 : 1;
+		genType const D = A & C;
+		Error += D == genType(0) ? 0 : 1;
+
+		genType const E = A | B;
+		Error += E == genType(1) ? 0 : 1;
+		genType const F = A | C;
+		Error += F == genType(1) ? 0 : 1;
+
+		genType const G = A ^ B;
+		Error += G == genType(0) ? 0 : 1;
+		genType const H = A ^ C;
+		Error += H == genType(1) ? 0 : 1;
+	}
+
+	{
+		genType const A(0);
+		genType const B(1);
+		genType const C(2);
+
+		genType const D = B << B;
+		Error += D == genType(2) ? 0 : 1;
+		genType const E = C >> B;
+		Error += E == genType(1) ? 0 : 1;
+	}
+
+	return Error;
+}
+
+template <typename genType>
+static int test_ctor()
+{
+	typedef typename genType::value_type T;
+	
+	int Error = 0;
+
+	genType const A = genType(1);
+
+	genType const E(genType(1));
+	Error += A == E ? 0 : 1;
+
+	genType const F(E);
+	Error += A == F ? 0 : 1;
+
+	genType const B = genType(1);
+	genType const G(glm::vec<2, T>(1));
+	Error += B == G ? 0 : 1;
+
+	genType const H(glm::vec<3, T>(1));
+	Error += B == H ? 0 : 1;
+
+	genType const I(glm::vec<4, T>(1));
+	Error += B == I ? 0 : 1;
+
+	return Error;
+}
+
+template <typename genType>
+static int test_size()
+{
+	int Error = 0;
+
+	Error += sizeof(typename genType::value_type) == sizeof(genType) ? 0 : 1;
+	Error += genType().length() == 1 ? 0 : 1;
+	Error += genType::length() == 1 ? 0 : 1;
+
+	return Error;
+}
+
+template <typename genType>
+static int test_relational()
+{
+	int Error = 0;
+
+	genType const A(1);
+	genType const B(1);
+	genType const C(0);
+
+	Error += A == B ? 0 : 1;
+	Error += A != C ? 0 : 1;
+	Error += all(equal(A, B)) ? 0 : 1;
+	Error += any(notEqual(A, C)) ? 0 : 1;
+
+	return Error;
+}
+
+template <typename genType>
+static int test_constexpr()
+{
+#	if GLM_CONFIG_CONSTEXP == GLM_ENABLE
+		static_assert(genType::length() == 1, "GLM: Failed constexpr");
+		static_assert(genType(1)[0] == 1, "GLM: Failed constexpr");
+		static_assert(genType(1) == genType(1), "GLM: Failed constexpr");
+		static_assert(genType(1) != genType(0), "GLM: Failed constexpr");
+#	endif
+
+	return 0;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_operators<glm::ivec1>();
+	Error += test_operators<glm::i8vec1>();
+	Error += test_operators<glm::i16vec1>();
+	Error += test_operators<glm::i32vec1>();
+	Error += test_operators<glm::i64vec1>();
+
+	Error += test_ctor<glm::ivec1>();
+	Error += test_ctor<glm::i8vec1>();
+	Error += test_ctor<glm::i16vec1>();
+	Error += test_ctor<glm::i32vec1>();
+	Error += test_ctor<glm::i64vec1>();
+
+	Error += test_size<glm::ivec1>();
+	Error += test_size<glm::i8vec1>();
+	Error += test_size<glm::i16vec1>();
+	Error += test_size<glm::i32vec1>();
+	Error += test_size<glm::i64vec1>();
+
+	Error += test_relational<glm::ivec1>();
+	Error += test_relational<glm::i8vec1>();
+	Error += test_relational<glm::i16vec1>();
+	Error += test_relational<glm::i32vec1>();
+	Error += test_relational<glm::i64vec1>();
+
+	Error += test_constexpr<glm::ivec1>();
+	Error += test_constexpr<glm::i8vec1>();
+	Error += test_constexpr<glm::i16vec1>();
+	Error += test_constexpr<glm::i32vec1>();
+	Error += test_constexpr<glm::i64vec1>();
+
+	Error += test_operators<glm::uvec1>();
+	Error += test_operators<glm::u8vec1>();
+	Error += test_operators<glm::u16vec1>();
+	Error += test_operators<glm::u32vec1>();
+	Error += test_operators<glm::u64vec1>();
+	
+	Error += test_ctor<glm::uvec1>();
+	Error += test_ctor<glm::u8vec1>();
+	Error += test_ctor<glm::u16vec1>();
+	Error += test_ctor<glm::u32vec1>();
+	Error += test_ctor<glm::u64vec1>();
+	
+	Error += test_size<glm::uvec1>();
+	Error += test_size<glm::u8vec1>();
+	Error += test_size<glm::u16vec1>();
+	Error += test_size<glm::u32vec1>();
+	Error += test_size<glm::u64vec1>();
+	
+	Error += test_relational<glm::uvec1>();
+	Error += test_relational<glm::u8vec1>();
+	Error += test_relational<glm::u16vec1>();
+	Error += test_relational<glm::u32vec1>();
+	Error += test_relational<glm::u64vec1>();
+	
+	Error += test_constexpr<glm::uvec1>();
+	Error += test_constexpr<glm::u8vec1>();
+	Error += test_constexpr<glm::u16vec1>();
+	Error += test_constexpr<glm::u32vec1>();
+	Error += test_constexpr<glm::u64vec1>();
+	
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/ext/ext_vector_packing.cpp b/3rdparty/glm/source/test/ext/ext_vector_packing.cpp
new file mode 100644
index 0000000..d7cbce2
--- /dev/null
+++ b/3rdparty/glm/source/test/ext/ext_vector_packing.cpp
@@ -0,0 +1,58 @@
+#include <glm/ext/vector_packing.hpp>
+#include <glm/ext/vector_relational.hpp>
+#include <glm/ext/vector_uint2_sized.hpp>
+#include <glm/ext/vector_int2_sized.hpp>
+#include <glm/gtc/packing.hpp>
+#include <glm/vec2.hpp>
+#include <vector>
+
+int test_packUnorm()
+{
+	int Error = 0;
+
+	std::vector<glm::vec2> A;
+	A.push_back(glm::vec2(1.0f, 0.7f));
+	A.push_back(glm::vec2(0.5f, 0.1f));
+
+	for (std::size_t i = 0; i < A.size(); ++i)
+	{
+		glm::vec2 B(A[i]);
+		glm::u16vec2 C = glm::packUnorm<glm::uint16>(B);
+		glm::vec2 D = glm::unpackUnorm<float>(C);
+		Error += glm::all(glm::equal(B, D, 1.0f / 255.f)) ? 0 : 1;
+		assert(!Error);
+	}
+
+	return Error;
+}
+
+int test_packSnorm()
+{
+	int Error = 0;
+
+	std::vector<glm::vec2> A;
+	A.push_back(glm::vec2(1.0f, 0.0f));
+	A.push_back(glm::vec2(-0.5f, -0.7f));
+	A.push_back(glm::vec2(-0.1f, 0.1f));
+
+	for (std::size_t i = 0; i < A.size(); ++i)
+	{
+		glm::vec2 B(A[i]);
+		glm::i16vec2 C = glm::packSnorm<glm::int16>(B);
+		glm::vec2 D = glm::unpackSnorm<float>(C);
+		Error += glm::all(glm::equal(B, D, 1.0f / 32767.0f * 2.0f)) ? 0 : 1;
+		assert(!Error);
+	}
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_packUnorm();
+	Error += test_packSnorm();
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/ext/ext_vector_reciprocal.cpp b/3rdparty/glm/source/test/ext/ext_vector_reciprocal.cpp
new file mode 100644
index 0000000..f4b9f18
--- /dev/null
+++ b/3rdparty/glm/source/test/ext/ext_vector_reciprocal.cpp
@@ -0,0 +1,186 @@
+#include <glm/ext/vector_reciprocal.hpp>
+#include <glm/ext/vector_relational.hpp>
+#include <glm/ext/scalar_constants.hpp>
+#include <glm/ext/vector_double1.hpp>
+
+static int test_sec()
+{
+	int Error = 0;
+	
+	glm::dvec1 const a = glm::sec(glm::dvec1(0.0));
+	Error += glm::all(glm::equal(a, glm::dvec1(1.0), 0.01)) ? 0 : 1;
+
+	glm::dvec1 const b = glm::sec(glm::dvec1(glm::pi<double>() * 2.0));
+	Error += glm::all(glm::equal(b, glm::dvec1(1.0), 0.01)) ? 0 : 1;
+
+	glm::dvec1 const c = glm::sec(glm::dvec1(glm::pi<double>() * -2.0));
+	Error += glm::all(glm::equal(c, glm::dvec1(1.0), 0.01)) ? 0 : 1;
+
+	glm::dvec1 const d = glm::sec(glm::dvec1(glm::pi<double>() * 1.0));
+	Error += glm::all(glm::equal(d, -glm::dvec1(1.0), 0.01)) ? 0 : 1;
+
+	glm::dvec1 const e = glm::sec(glm::dvec1(glm::pi<double>() * -1.0));
+	Error += glm::all(glm::equal(e, -glm::dvec1(1.0), 0.01)) ? 0 : 1;
+
+	return Error;
+}
+
+static int test_csc()
+{
+	int Error = 0;
+	
+	glm::dvec1 const a = glm::csc(glm::dvec1(glm::pi<double>() * 0.5));
+	Error += glm::all(glm::equal(a, glm::dvec1(1.0), 0.01)) ? 0 : 1;
+
+	glm::dvec1 const b = glm::csc(glm::dvec1(glm::pi<double>() * -0.5));
+	Error += glm::all(glm::equal(b, glm::dvec1(-1.0), 0.01)) ? 0 : 1;
+
+	return Error;
+}
+
+static int test_cot()
+{
+	int Error = 0;
+	
+	glm::dvec1 const a = glm::cot(glm::dvec1(glm::pi<double>() * 0.5));
+	Error += glm::all(glm::equal(a, glm::dvec1(0.0), 0.01)) ? 0 : 1;
+
+	glm::dvec1 const b = glm::cot(glm::dvec1(glm::pi<double>() * -0.5));
+	Error += glm::all(glm::equal(b, glm::dvec1(0.0), 0.01)) ? 0 : 1;
+
+	return Error;
+}
+
+static int test_asec()
+{
+	int Error = 0;
+	
+	Error += glm::all(glm::equal(glm::asec(glm::dvec1(100000.0)), glm::dvec1(glm::pi<double>() * 0.5), 0.01)) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::asec(glm::dvec1(-100000.0)), glm::dvec1(glm::pi<double>() * 0.5), 0.01)) ? 0 : 1;
+
+	return Error;
+}
+
+static int test_acsc()
+{
+	int Error = 0;
+	
+	Error += glm::all(glm::equal(glm::acsc(glm::dvec1(100000.0)), glm::dvec1(0.0), 0.01)) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::acsc(glm::dvec1(-100000.0)), glm::dvec1(0.0), 0.01)) ? 0 : 1;
+
+	return Error;
+}
+
+static int test_acot()
+{
+	int Error = 0;
+	
+	Error += glm::all(glm::equal(glm::acot(glm::dvec1(100000.0)), glm::dvec1(0.0), 0.01)) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::acot(glm::dvec1(-100000.0)), glm::dvec1(glm::pi<double>()), 0.01)) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::acot(glm::dvec1(0.0)), glm::dvec1(glm::pi<double>() * 0.5), 0.01)) ? 0 : 1;
+
+	return Error;
+}
+
+static int test_sech()
+{
+	int Error = 0;
+	
+	Error += glm::all(glm::equal(glm::sech(glm::dvec1(100000.0)), glm::dvec1(0.0), 0.01)) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::sech(glm::dvec1(-100000.0)), glm::dvec1(0.0), 0.01)) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::sech(glm::dvec1(0.0)), glm::dvec1(1.0), 0.01)) ? 0 : 1;
+
+	return Error;
+}
+
+static int test_csch()
+{
+	int Error = 0;
+	
+	Error += glm::all(glm::equal(glm::csch(glm::dvec1(100000.0)), glm::dvec1(0.0), 0.01)) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::csch(glm::dvec1(-100000.0)), glm::dvec1(0.0), 0.01)) ? 0 : 1;
+
+	return Error;
+}
+
+static int test_coth()
+{
+	int Error = 0;
+	
+	glm::dvec1 const a = glm::coth(glm::dvec1(100.0));
+	Error += glm::all(glm::equal(a, glm::dvec1(1.0), 0.01)) ? 0 : 1;
+	
+	glm::dvec1 const b = glm::coth(glm::dvec1(-100.0));
+	Error += glm::all(glm::equal(b, glm::dvec1(-1.0), 0.01)) ? 0 : 1;
+
+	return Error;
+}
+
+static int test_asech()
+{
+	int Error = 0;
+	
+	glm::dvec1 const a = glm::asech(glm::dvec1(1.0));
+	Error += glm::all(glm::equal(a, glm::dvec1(0.0), 0.01)) ? 0 : 1;
+
+	return Error;
+}
+
+static int test_acsch()
+{
+	int Error = 0;
+	
+	glm::dvec1 const a(glm::acsch(glm::dvec1(0.01)));
+	Error += a.x > 1.0 ? 0 : 1;
+
+	glm::dvec1 const b(glm::acsch(glm::dvec1(-0.01)));
+	Error += b.x < -1.0 ? 0 : 1;
+
+	Error += glm::all(glm::equal(glm::acsch(glm::dvec1(100.0)), glm::dvec1(0.0), 0.01)) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::acsch(glm::dvec1(-100.0)), glm::dvec1(0.0), 0.01)) ? 0 : 1;
+
+	return Error;
+}
+
+static int test_acoth()
+{
+	int Error = 0;
+	
+	glm::dvec1 const a = glm::acoth(glm::dvec1(1.00001));
+	Error += a.x > 6.0 ? 0 : 1;
+	
+	glm::dvec1 const b = glm::acoth(glm::dvec1(-1.00001));
+	Error += b.x < -6.0 ? 0 : 1;
+
+	glm::dvec1 const c = glm::acoth(glm::dvec1(10000.0));
+	Error += glm::all(glm::equal(c, glm::dvec1(0.0), 0.01)) ? 0 : 1;
+	
+	glm::dvec1 const d = glm::acoth(glm::dvec1(-10000.0));
+	Error += glm::all(glm::equal(d, glm::dvec1(0.0), 0.01)) ? 0 : 1;
+
+	return Error;
+}
+
+
+int main()
+{
+	int Error = 0;
+	
+	Error += test_sec();
+	Error += test_csc();
+	Error += test_cot();
+
+	Error += test_asec();
+	Error += test_acsc();
+	Error += test_acot();
+
+	Error += test_sech();
+	Error += test_csch();
+	Error += test_coth();
+
+	Error += test_asech();
+	Error += test_acsch();
+	Error += test_acoth();
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/ext/ext_vector_relational.cpp b/3rdparty/glm/source/test/ext/ext_vector_relational.cpp
new file mode 100644
index 0000000..f6cd307
--- /dev/null
+++ b/3rdparty/glm/source/test/ext/ext_vector_relational.cpp
@@ -0,0 +1,205 @@
+#include <glm/ext/vector_relational.hpp>
+#include <glm/ext/vector_float1.hpp>
+#include <glm/ext/vector_float1_precision.hpp>
+#include <glm/ext/vector_float2.hpp>
+#include <glm/ext/vector_float2_precision.hpp>
+#include <glm/ext/vector_float3.hpp>
+#include <glm/ext/vector_float3_precision.hpp>
+#include <glm/ext/vector_float4.hpp>
+#include <glm/ext/vector_float4_precision.hpp>
+#include <glm/ext/vector_double1.hpp>
+#include <glm/ext/vector_double1_precision.hpp>
+#include <glm/ext/vector_double2.hpp>
+#include <glm/ext/vector_double2_precision.hpp>
+#include <glm/ext/vector_double3.hpp>
+#include <glm/ext/vector_double3_precision.hpp>
+#include <glm/ext/vector_double4.hpp>
+#include <glm/ext/vector_double4_precision.hpp>
+#include <glm/ext/vector_ulp.hpp>
+
+template <typename vecType>
+static int test_equal()
+{
+	typedef typename vecType::value_type valType;
+
+	valType const A = static_cast<valType>(1.01f);
+	valType const B = static_cast<valType>(1.02f);
+	valType const Epsilon1 = static_cast<valType>(0.1f);
+	valType const Epsilon2 = static_cast<valType>(0.001f);
+
+	int Error = 0;
+
+	Error += glm::all(glm::equal(vecType(A), vecType(B), Epsilon1)) ? 0 : 1;
+	Error += glm::all(glm::equal(vecType(A), vecType(B), vecType(Epsilon1))) ? 0 : 1;
+
+	Error += !glm::any(glm::equal(vecType(A), vecType(B), Epsilon2)) ? 0 : 1;
+	Error += !glm::any(glm::equal(vecType(A), vecType(B), vecType(Epsilon2))) ? 0 : 1;
+
+	return Error;
+}
+
+template <typename vecType>
+static int test_notEqual()
+{
+	typedef typename vecType::value_type valType;
+
+	valType const A = static_cast<valType>(1.01f);
+	valType const B = static_cast<valType>(1.02f);
+	valType const Epsilon1 = static_cast<valType>(0.1f);
+	valType const Epsilon2 = static_cast<valType>(0.001f);
+
+	int Error = 0;
+
+	Error += glm::all(glm::notEqual(vecType(A), vecType(B), Epsilon2)) ? 0 : 1;
+	Error += glm::all(glm::notEqual(vecType(A), vecType(B), vecType(Epsilon2))) ? 0 : 1;
+
+	Error += !glm::any(glm::notEqual(vecType(A), vecType(B), Epsilon1)) ? 0 : 1;
+	Error += !glm::any(glm::notEqual(vecType(A), vecType(B), vecType(Epsilon1))) ? 0 : 1;
+
+	return Error;
+}
+
+template <typename genType, typename valType>
+static int test_constexpr()
+{
+#	if GLM_CONFIG_CONSTEXP == GLM_ENABLE
+		static_assert(glm::all(glm::equal(genType(static_cast<valType>(1.01f)), genType(static_cast<valType>(1.02f)), static_cast<valType>(0.1f))), "GLM: Failed constexpr");
+#	endif
+
+	return 0;
+}
+
+template <typename T>
+static int test_equal_ulps()
+{
+	typedef glm::vec<4, T, glm::defaultp> vec4;
+
+	T const One(1);
+	vec4 const Ones(1);
+
+	int Error = 0;
+
+	T const ULP1Plus = glm::nextFloat(One);
+	Error += glm::all(glm::equal(Ones, vec4(ULP1Plus), 1)) ? 0 : 1;
+
+	T const ULP2Plus = glm::nextFloat(ULP1Plus);
+	Error += !glm::all(glm::equal(Ones, vec4(ULP2Plus), 1)) ? 0 : 1;
+
+	T const ULP1Minus = glm::prevFloat(One);
+	Error += glm::all(glm::equal(Ones, vec4(ULP1Minus), 1)) ? 0 : 1;
+
+	T const ULP2Minus = glm::prevFloat(ULP1Minus);
+	Error += !glm::all(glm::equal(Ones, vec4(ULP2Minus), 1)) ? 0 : 1;
+
+	return Error;
+}
+
+template <typename T>
+static int test_notEqual_ulps()
+{
+	typedef glm::vec<4, T, glm::defaultp> vec4;
+
+	T const One(1);
+	vec4 const Ones(1);
+
+	int Error = 0;
+
+	T const ULP1Plus = glm::nextFloat(One);
+	Error += !glm::all(glm::notEqual(Ones, vec4(ULP1Plus), 1)) ? 0 : 1;
+
+	T const ULP2Plus = glm::nextFloat(ULP1Plus);
+	Error += glm::all(glm::notEqual(Ones, vec4(ULP2Plus), 1)) ? 0 : 1;
+
+	T const ULP1Minus = glm::prevFloat(One);
+	Error += !glm::all(glm::notEqual(Ones, vec4(ULP1Minus), 1)) ? 0 : 1;
+
+	T const ULP2Minus = glm::prevFloat(ULP1Minus);
+	Error += glm::all(glm::notEqual(Ones, vec4(ULP2Minus), 1)) ? 0 : 1;
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_equal_ulps<float>();
+	Error += test_equal_ulps<double>();
+	Error += test_notEqual_ulps<float>();
+	Error += test_notEqual_ulps<double>();
+
+	Error += test_equal<glm::vec1>();
+	Error += test_equal<glm::lowp_vec1>();
+	Error += test_equal<glm::mediump_vec1>();
+	Error += test_equal<glm::highp_vec1>();
+	Error += test_equal<glm::vec2>();
+	Error += test_equal<glm::lowp_vec2>();
+	Error += test_equal<glm::mediump_vec2>();
+	Error += test_equal<glm::highp_vec2>();
+	Error += test_equal<glm::vec3>();
+	Error += test_equal<glm::lowp_vec3>();
+	Error += test_equal<glm::mediump_vec3>();
+	Error += test_equal<glm::highp_vec3>();
+	Error += test_equal<glm::vec4>();
+	Error += test_equal<glm::lowp_vec4>();
+	Error += test_equal<glm::mediump_vec4>();
+	Error += test_equal<glm::highp_vec4>();
+
+	Error += test_equal<glm::dvec1>();
+	Error += test_equal<glm::lowp_dvec1>();
+	Error += test_equal<glm::mediump_dvec1>();
+	Error += test_equal<glm::highp_dvec1>();
+	Error += test_equal<glm::dvec2>();
+	Error += test_equal<glm::lowp_dvec2>();
+	Error += test_equal<glm::mediump_dvec2>();
+	Error += test_equal<glm::highp_dvec2>();
+	Error += test_equal<glm::dvec3>();
+	Error += test_equal<glm::lowp_dvec3>();
+	Error += test_equal<glm::mediump_dvec3>();
+	Error += test_equal<glm::highp_dvec3>();
+	Error += test_equal<glm::dvec4>();
+	Error += test_equal<glm::lowp_dvec4>();
+	Error += test_equal<glm::mediump_dvec4>();
+	Error += test_equal<glm::highp_dvec4>();
+
+	Error += test_notEqual<glm::vec1>();
+	Error += test_notEqual<glm::lowp_vec1>();
+	Error += test_notEqual<glm::mediump_vec1>();
+	Error += test_notEqual<glm::highp_vec1>();
+	Error += test_notEqual<glm::vec2>();
+	Error += test_notEqual<glm::lowp_vec2>();
+	Error += test_notEqual<glm::mediump_vec2>();
+	Error += test_notEqual<glm::highp_vec2>();
+	Error += test_notEqual<glm::vec3>();
+	Error += test_notEqual<glm::lowp_vec3>();
+	Error += test_notEqual<glm::mediump_vec3>();
+	Error += test_notEqual<glm::highp_vec3>();
+	Error += test_notEqual<glm::vec4>();
+	Error += test_notEqual<glm::lowp_vec4>();
+	Error += test_notEqual<glm::mediump_vec4>();
+	Error += test_notEqual<glm::highp_vec4>();
+
+	Error += test_notEqual<glm::dvec1>();
+	Error += test_notEqual<glm::lowp_dvec1>();
+	Error += test_notEqual<glm::mediump_dvec1>();
+	Error += test_notEqual<glm::highp_dvec1>();
+	Error += test_notEqual<glm::dvec2>();
+	Error += test_notEqual<glm::lowp_dvec2>();
+	Error += test_notEqual<glm::mediump_dvec2>();
+	Error += test_notEqual<glm::highp_dvec2>();
+	Error += test_notEqual<glm::dvec3>();
+	Error += test_notEqual<glm::lowp_dvec3>();
+	Error += test_notEqual<glm::mediump_dvec3>();
+	Error += test_notEqual<glm::highp_dvec3>();
+	Error += test_notEqual<glm::dvec4>();
+	Error += test_notEqual<glm::lowp_dvec4>();
+	Error += test_notEqual<glm::mediump_dvec4>();
+	Error += test_notEqual<glm::highp_dvec4>();
+
+	Error += test_constexpr<glm::vec1, float>();
+	Error += test_constexpr<glm::vec2, float>();
+	Error += test_constexpr<glm::vec3, float>();
+	Error += test_constexpr<glm::vec4, float>();
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/ext/ext_vector_uint1_sized.cpp b/3rdparty/glm/source/test/ext/ext_vector_uint1_sized.cpp
new file mode 100644
index 0000000..f2e4624
--- /dev/null
+++ b/3rdparty/glm/source/test/ext/ext_vector_uint1_sized.cpp
@@ -0,0 +1,41 @@
+#include <glm/ext/vector_uint1_sized.hpp>
+
+#if GLM_HAS_STATIC_ASSERT
+	static_assert(sizeof(glm::u8vec1) == 1, "uint8 size isn't 1 byte on this platform");
+	static_assert(sizeof(glm::u16vec1) == 2, "uint16 size isn't 2 bytes on this platform");
+	static_assert(sizeof(glm::u32vec1) == 4, "uint32 size isn't 4 bytes on this platform");
+	static_assert(sizeof(glm::u64vec1) == 8, "uint64 size isn't 8 bytes on this platform");
+#endif
+
+static int test_size()
+{
+	int Error = 0;
+
+	Error += sizeof(glm::u8vec1) == 1 ? 0 : 1;
+	Error += sizeof(glm::u16vec1) == 2 ? 0 : 1;
+	Error += sizeof(glm::u32vec1) == 4 ? 0 : 1;
+	Error += sizeof(glm::u64vec1) == 8 ? 0 : 1;
+
+	return Error;
+}
+
+static int test_comp()
+{
+	int Error = 0;
+
+	Error += sizeof(glm::u8vec1) < sizeof(glm::u16vec1) ? 0 : 1;
+	Error += sizeof(glm::u16vec1) < sizeof(glm::u32vec1) ? 0 : 1;
+	Error += sizeof(glm::u32vec1) < sizeof(glm::u64vec1) ? 0 : 1;
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_size();
+	Error += test_comp();
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/ext/ext_vector_uint2_sized.cpp b/3rdparty/glm/source/test/ext/ext_vector_uint2_sized.cpp
new file mode 100644
index 0000000..9c0977e
--- /dev/null
+++ b/3rdparty/glm/source/test/ext/ext_vector_uint2_sized.cpp
@@ -0,0 +1,41 @@
+#include <glm/ext/vector_uint2_sized.hpp>
+
+#if GLM_HAS_STATIC_ASSERT
+static_assert(sizeof(glm::u8vec2) == 2, "int8 size isn't 1 byte on this platform");
+static_assert(sizeof(glm::u16vec2) == 4, "int16 size isn't 2 bytes on this platform");
+static_assert(sizeof(glm::u32vec2) == 8, "int32 size isn't 4 bytes on this platform");
+static_assert(sizeof(glm::u64vec2) == 16, "int64 size isn't 8 bytes on this platform");
+#endif
+
+static int test_size()
+{
+	int Error = 0;
+
+	Error += sizeof(glm::u8vec2) == 2 ? 0 : 1;
+	Error += sizeof(glm::u16vec2) == 4 ? 0 : 1;
+	Error += sizeof(glm::u32vec2) == 8 ? 0 : 1;
+	Error += sizeof(glm::u64vec2) == 16 ? 0 : 1;
+
+	return Error;
+}
+
+static int test_comp()
+{
+	int Error = 0;
+
+	Error += sizeof(glm::u8vec2) < sizeof(glm::u16vec2) ? 0 : 1;
+	Error += sizeof(glm::u16vec2) < sizeof(glm::u32vec2) ? 0 : 1;
+	Error += sizeof(glm::u32vec2) < sizeof(glm::u64vec2) ? 0 : 1;
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_size();
+	Error += test_comp();
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/ext/ext_vector_uint3_sized.cpp b/3rdparty/glm/source/test/ext/ext_vector_uint3_sized.cpp
new file mode 100644
index 0000000..4cc2e44
--- /dev/null
+++ b/3rdparty/glm/source/test/ext/ext_vector_uint3_sized.cpp
@@ -0,0 +1,41 @@
+#include <glm/ext/vector_uint3_sized.hpp>
+
+#if GLM_HAS_STATIC_ASSERT
+static_assert(sizeof(glm::u8vec3) == 3, "int8 size isn't 1 byte on this platform");
+static_assert(sizeof(glm::u16vec3) == 6, "int16 size isn't 2 bytes on this platform");
+static_assert(sizeof(glm::u32vec3) == 12, "int32 size isn't 4 bytes on this platform");
+static_assert(sizeof(glm::u64vec3) == 24, "int64 size isn't 8 bytes on this platform");
+#endif
+
+static int test_size()
+{
+	int Error = 0;
+
+	Error += sizeof(glm::u8vec3) == 3 ? 0 : 1;
+	Error += sizeof(glm::u16vec3) == 6 ? 0 : 1;
+	Error += sizeof(glm::u32vec3) == 12 ? 0 : 1;
+	Error += sizeof(glm::u64vec3) == 24 ? 0 : 1;
+
+	return Error;
+}
+
+static int test_comp()
+{
+	int Error = 0;
+
+	Error += sizeof(glm::u8vec3) < sizeof(glm::u16vec3) ? 0 : 1;
+	Error += sizeof(glm::u16vec3) < sizeof(glm::u32vec3) ? 0 : 1;
+	Error += sizeof(glm::u32vec3) < sizeof(glm::u64vec3) ? 0 : 1;
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_size();
+	Error += test_comp();
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/ext/ext_vector_uint4_sized.cpp b/3rdparty/glm/source/test/ext/ext_vector_uint4_sized.cpp
new file mode 100644
index 0000000..9e7ffe7
--- /dev/null
+++ b/3rdparty/glm/source/test/ext/ext_vector_uint4_sized.cpp
@@ -0,0 +1,41 @@
+#include <glm/ext/vector_uint4_sized.hpp>
+
+#if GLM_HAS_STATIC_ASSERT
+static_assert(sizeof(glm::u8vec4) == 4, "int8 size isn't 1 byte on this platform");
+static_assert(sizeof(glm::u16vec4) == 8, "int16 size isn't 2 bytes on this platform");
+static_assert(sizeof(glm::u32vec4) == 16, "int32 size isn't 4 bytes on this platform");
+static_assert(sizeof(glm::u64vec4) == 32, "int64 size isn't 8 bytes on this platform");
+#endif
+
+static int test_size()
+{
+	int Error = 0;
+
+	Error += sizeof(glm::u8vec4) == 4 ? 0 : 1;
+	Error += sizeof(glm::u16vec4) == 8 ? 0 : 1;
+	Error += sizeof(glm::u32vec4) == 16 ? 0 : 1;
+	Error += sizeof(glm::u64vec4) == 32 ? 0 : 1;
+
+	return Error;
+}
+
+static int test_comp()
+{
+	int Error = 0;
+
+	Error += sizeof(glm::u8vec4) < sizeof(glm::u16vec4) ? 0 : 1;
+	Error += sizeof(glm::u16vec4) < sizeof(glm::u32vec4) ? 0 : 1;
+	Error += sizeof(glm::u32vec4) < sizeof(glm::u64vec4) ? 0 : 1;
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_size();
+	Error += test_comp();
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/ext/ext_vector_ulp.cpp b/3rdparty/glm/source/test/ext/ext_vector_ulp.cpp
new file mode 100644
index 0000000..6ebd1a1
--- /dev/null
+++ b/3rdparty/glm/source/test/ext/ext_vector_ulp.cpp
@@ -0,0 +1,99 @@
+#include <glm/ext/vector_ulp.hpp>
+#include <glm/ext/vector_relational.hpp>
+#include <glm/ext/vector_float4.hpp>
+#include <glm/ext/vector_double4.hpp>
+#include <glm/ext/vector_int4.hpp>
+
+static int test_ulp_float_dist()
+{
+	int Error = 0;
+
+	glm::vec4 const A(1.0f);
+
+	glm::vec4 const B = glm::nextFloat(A);
+	Error += glm::any(glm::notEqual(A, B, 0)) ? 0 : 1;
+	glm::vec4 const C = glm::prevFloat(B);
+	Error += glm::all(glm::equal(A, C, 0)) ? 0 : 1;
+
+	glm::ivec4 const D = glm::floatDistance(A, B);
+	Error += D == glm::ivec4(1) ? 0 : 1;
+	glm::ivec4 const E = glm::floatDistance(A, C);
+	Error += E == glm::ivec4(0) ? 0 : 1;
+
+	return Error;
+}
+
+static int test_ulp_float_step()
+{
+	int Error = 0;
+
+	glm::vec4 const A(1.0f);
+
+	for(int i = 10; i < 1000; i *= 10)
+	{
+		glm::vec4 const B = glm::nextFloat(A, i);
+		Error += glm::any(glm::notEqual(A, B, 0)) ? 0 : 1;
+		glm::vec4 const C = glm::prevFloat(B, i);
+		Error += glm::all(glm::equal(A, C, 0)) ? 0 : 1;
+
+		glm::ivec4 const D = glm::floatDistance(A, B);
+		Error += D == glm::ivec4(i) ? 0 : 1;
+		glm::ivec4 const E = glm::floatDistance(A, C);
+		Error += E == glm::ivec4(0) ? 0 : 1;
+	}
+
+	return Error;
+}
+
+static int test_ulp_double_dist()
+{
+	int Error = 0;
+
+	glm::dvec4 const A(1.0);
+
+	glm::dvec4 const B = glm::nextFloat(A);
+	Error += glm::any(glm::notEqual(A, B, 0)) ? 0 : 1;
+	glm::dvec4 const C = glm::prevFloat(B);
+	Error += glm::all(glm::equal(A, C, 0)) ? 0 : 1;
+
+	glm::ivec4 const D(glm::floatDistance(A, B));
+	Error += D == glm::ivec4(1) ? 0 : 1;
+	glm::ivec4 const E = glm::floatDistance(A, C);
+	Error += E == glm::ivec4(0) ? 0 : 1;
+
+	return Error;
+}
+
+static int test_ulp_double_step()
+{
+	int Error = 0;
+
+	glm::dvec4 const A(1.0);
+
+	for(int i = 10; i < 1000; i *= 10)
+	{
+		glm::dvec4 const B = glm::nextFloat(A, i);
+		Error += glm::any(glm::notEqual(A, B, 0)) ? 0 : 1;
+		glm::dvec4 const C = glm::prevFloat(B, i);
+		Error += glm::all(glm::equal(A, C, 0)) ? 0 : 1;
+
+		glm::ivec4 const D(glm::floatDistance(A, B));
+		Error += D == glm::ivec4(i) ? 0 : 1;
+		glm::ivec4 const E(glm::floatDistance(A, C));
+		Error += E == glm::ivec4(0) ? 0 : 1;
+	}
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_ulp_float_dist();
+	Error += test_ulp_float_step();
+	Error += test_ulp_double_dist();
+	Error += test_ulp_double_step();
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/glm.cppcheck b/3rdparty/glm/source/test/glm.cppcheck
new file mode 100644
index 0000000..12081fe
--- /dev/null
+++ b/3rdparty/glm/source/test/glm.cppcheck
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="1">
+    <includedir>
+        <dir name="../glm"/>
+    </includedir>
+</project>
diff --git a/3rdparty/glm/source/test/gtc/CMakeLists.txt b/3rdparty/glm/source/test/gtc/CMakeLists.txt
new file mode 100644
index 0000000..4aef24a
--- /dev/null
+++ b/3rdparty/glm/source/test/gtc/CMakeLists.txt
@@ -0,0 +1,20 @@
+glmCreateTestGTC(gtc_bitfield)
+glmCreateTestGTC(gtc_color_space)
+glmCreateTestGTC(gtc_constants)
+glmCreateTestGTC(gtc_epsilon)
+glmCreateTestGTC(gtc_integer)
+glmCreateTestGTC(gtc_matrix_access)
+glmCreateTestGTC(gtc_matrix_integer)
+glmCreateTestGTC(gtc_matrix_inverse)
+glmCreateTestGTC(gtc_matrix_transform)
+glmCreateTestGTC(gtc_noise)
+glmCreateTestGTC(gtc_packing)
+glmCreateTestGTC(gtc_quaternion)
+glmCreateTestGTC(gtc_random)
+glmCreateTestGTC(gtc_round)
+glmCreateTestGTC(gtc_reciprocal)
+glmCreateTestGTC(gtc_type_aligned)
+glmCreateTestGTC(gtc_type_precision)
+glmCreateTestGTC(gtc_type_ptr)
+glmCreateTestGTC(gtc_ulp)
+glmCreateTestGTC(gtc_vec1)
diff --git a/3rdparty/glm/source/test/gtc/gtc_bitfield.cpp b/3rdparty/glm/source/test/gtc/gtc_bitfield.cpp
new file mode 100644
index 0000000..95c41f1
--- /dev/null
+++ b/3rdparty/glm/source/test/gtc/gtc_bitfield.cpp
@@ -0,0 +1,936 @@
+#include <glm/gtc/bitfield.hpp>
+#include <glm/gtc/type_precision.hpp>
+#include <glm/vector_relational.hpp>
+#include <glm/integer.hpp>
+#include <ctime>
+#include <cstdio>
+#include <vector>
+
+namespace mask
+{
+	template<typename genType>
+	struct type
+	{
+		genType		Value;
+		genType		Return;
+	};
+
+	inline int mask_zero(int Bits)
+	{
+		return ~((~0) << Bits);
+	}
+
+	inline int mask_mix(int Bits)
+	{
+		return Bits >= sizeof(int) * 8 ? 0xffffffff : (static_cast<int>(1) << Bits) - static_cast<int>(1);
+	}
+
+	inline int mask_half(int Bits)
+	{
+		// We do the shift in two steps because 1 << 32 on an int is undefined.
+
+		int const Half = Bits >> 1;
+		int const Fill = ~0;
+		int const ShiftHaft = (Fill << Half);
+		int const Rest = Bits - Half;
+		int const Reversed = ShiftHaft << Rest;
+
+		return ~Reversed;
+	}
+
+	inline int mask_loop(int Bits)
+	{
+		int Mask = 0;
+		for(int Bit = 0; Bit < Bits; ++Bit)
+			Mask |= (static_cast<int>(1) << Bit);
+		return Mask;
+	}
+
+	int perf()
+	{
+		int const Count = 100000000;
+
+		std::clock_t Timestamp1 = std::clock();
+
+		{
+			std::vector<int> Mask;
+			Mask.resize(Count);
+			for(int i = 0; i < Count; ++i)
+				Mask[i] = mask_mix(i % 32);
+		}
+
+		std::clock_t Timestamp2 = std::clock();
+
+		{
+			std::vector<int> Mask;
+			Mask.resize(Count);
+			for(int i = 0; i < Count; ++i)
+				Mask[i] = mask_loop(i % 32);
+		}
+
+		std::clock_t Timestamp3 = std::clock();
+
+		{
+			std::vector<int> Mask;
+			Mask.resize(Count);
+			for(int i = 0; i < Count; ++i)
+				Mask[i] = glm::mask(i % 32);
+		}
+
+		std::clock_t Timestamp4 = std::clock();
+
+		{
+			std::vector<int> Mask;
+			Mask.resize(Count);
+			for(int i = 0; i < Count; ++i)
+				Mask[i] = mask_zero(i % 32);
+		}
+
+		std::clock_t Timestamp5 = std::clock();
+
+		{
+			std::vector<int> Mask;
+			Mask.resize(Count);
+			for(int i = 0; i < Count; ++i)
+				Mask[i] = mask_half(i % 32);
+		}
+
+		std::clock_t Timestamp6 = std::clock();
+
+		std::clock_t TimeMix = Timestamp2 - Timestamp1;
+		std::clock_t TimeLoop = Timestamp3 - Timestamp2;
+		std::clock_t TimeDefault = Timestamp4 - Timestamp3;
+		std::clock_t TimeZero = Timestamp5 - Timestamp4;
+		std::clock_t TimeHalf = Timestamp6 - Timestamp5;
+
+		std::printf("mask[mix]: %d\n", static_cast<unsigned int>(TimeMix));
+		std::printf("mask[loop]: %d\n", static_cast<unsigned int>(TimeLoop));
+		std::printf("mask[default]: %d\n", static_cast<unsigned int>(TimeDefault));
+		std::printf("mask[zero]: %d\n", static_cast<unsigned int>(TimeZero));
+		std::printf("mask[half]: %d\n", static_cast<unsigned int>(TimeHalf));
+
+		return TimeDefault < TimeLoop ? 0 : 1;
+	}
+
+	int test_uint()
+	{
+		type<glm::uint> const Data[] =
+		{
+			{ 0, 0x00000000},
+			{ 1, 0x00000001},
+			{ 2, 0x00000003},
+			{ 3, 0x00000007},
+			{31, 0x7fffffff},
+			{32, 0xffffffff}
+		};
+
+		int Error = 0;
+/* mask_zero is sadly not a correct code
+		for(std::size_t i = 0; i < sizeof(Data) / sizeof(type<int>); ++i)
+		{
+			int Result = mask_zero(Data[i].Value);
+			Error += Data[i].Return == Result ? 0 : 1;
+		}
+*/
+		for(std::size_t i = 0; i < sizeof(Data) / sizeof(type<int>); ++i)
+		{
+			int Result = mask_mix(Data[i].Value);
+			Error += Data[i].Return == Result ? 0 : 1;
+		}
+
+		for(std::size_t i = 0; i < sizeof(Data) / sizeof(type<int>); ++i)
+		{
+			int Result = mask_half(Data[i].Value);
+			Error += Data[i].Return == Result ? 0 : 1;
+		}
+
+		for(std::size_t i = 0; i < sizeof(Data) / sizeof(type<int>); ++i)
+		{
+			int Result = mask_loop(Data[i].Value);
+			Error += Data[i].Return == Result ? 0 : 1;
+		}
+
+		for(std::size_t i = 0; i < sizeof(Data) / sizeof(type<int>); ++i)
+		{
+			int Result = glm::mask(Data[i].Value);
+			Error += Data[i].Return == Result ? 0 : 1;
+		}
+
+		return Error;
+	}
+
+	int test_uvec4()
+	{
+		type<glm::ivec4> const Data[] =
+		{
+			{glm::ivec4( 0), glm::ivec4(0x00000000)},
+			{glm::ivec4( 1), glm::ivec4(0x00000001)},
+			{glm::ivec4( 2), glm::ivec4(0x00000003)},
+			{glm::ivec4( 3), glm::ivec4(0x00000007)},
+			{glm::ivec4(31), glm::ivec4(0x7fffffff)},
+			{glm::ivec4(32), glm::ivec4(0xffffffff)}
+		};
+
+		int Error(0);
+
+		for(std::size_t i = 0, n = sizeof(Data) / sizeof(type<glm::ivec4>); i < n; ++i)
+		{
+			glm::ivec4 Result = glm::mask(Data[i].Value);
+			Error += glm::all(glm::equal(Data[i].Return, Result)) ? 0 : 1;
+		}
+
+		return Error;
+	}
+
+	int test()
+	{
+		int Error(0);
+
+		Error += test_uint();
+		Error += test_uvec4();
+
+		return Error;
+	}
+}//namespace mask
+
+namespace bitfieldInterleave3
+{
+	template<typename PARAM, typename RET>
+	inline RET refBitfieldInterleave(PARAM x, PARAM y, PARAM z)
+	{
+		RET Result = 0; 
+		for(RET i = 0; i < sizeof(PARAM) * 8; ++i)
+		{
+			Result |= ((RET(x) & (RET(1U) << i)) << ((i << 1) + 0));
+			Result |= ((RET(y) & (RET(1U) << i)) << ((i << 1) + 1));
+			Result |= ((RET(z) & (RET(1U) << i)) << ((i << 1) + 2));
+		}
+		return Result;
+	}
+
+	int test()
+	{
+		int Error(0);
+
+		glm::uint16 x_max = 1 << 11;
+		glm::uint16 y_max = 1 << 11;
+		glm::uint16 z_max = 1 << 11;
+
+		for(glm::uint16 z = 0; z < z_max; z += 27)
+		for(glm::uint16 y = 0; y < y_max; y += 27)
+		for(glm::uint16 x = 0; x < x_max; x += 27)
+		{
+			glm::uint64 ResultA = refBitfieldInterleave<glm::uint16, glm::uint64>(x, y, z);
+			glm::uint64 ResultB = glm::bitfieldInterleave(x, y, z);
+			Error += ResultA == ResultB ? 0 : 1;
+		}
+
+		return Error;
+	}
+}
+
+namespace bitfieldInterleave4
+{
+	template<typename PARAM, typename RET>
+	inline RET loopBitfieldInterleave(PARAM x, PARAM y, PARAM z, PARAM w)
+	{
+		RET const v[4] = {x, y, z, w};
+		RET Result = 0; 
+		for(RET i = 0; i < sizeof(PARAM) * 8; i++)
+		{
+			Result |= ((((v[0] >> i) & 1U)) << ((i << 2) + 0));
+			Result |= ((((v[1] >> i) & 1U)) << ((i << 2) + 1));
+			Result |= ((((v[2] >> i) & 1U)) << ((i << 2) + 2));
+			Result |= ((((v[3] >> i) & 1U)) << ((i << 2) + 3));
+		}
+		return Result;
+	}
+
+	int test()
+	{
+		int Error(0);
+
+		glm::uint16 x_max = 1 << 11;
+		glm::uint16 y_max = 1 << 11;
+		glm::uint16 z_max = 1 << 11;
+		glm::uint16 w_max = 1 << 11;
+
+		for(glm::uint16 w = 0; w < w_max; w += 27)
+		for(glm::uint16 z = 0; z < z_max; z += 27)
+		for(glm::uint16 y = 0; y < y_max; y += 27)
+		for(glm::uint16 x = 0; x < x_max; x += 27)
+		{
+			glm::uint64 ResultA = loopBitfieldInterleave<glm::uint16, glm::uint64>(x, y, z, w);
+			glm::uint64 ResultB = glm::bitfieldInterleave(x, y, z, w);
+			Error += ResultA == ResultB ? 0 : 1;
+		}
+
+		return Error;
+	}
+}
+
+namespace bitfieldInterleave
+{
+	inline glm::uint64 fastBitfieldInterleave(glm::uint32 x, glm::uint32 y)
+	{
+		glm::uint64 REG1;
+		glm::uint64 REG2;
+
+		REG1 = x;
+		REG1 = ((REG1 << 16) | REG1) & glm::uint64(0x0000FFFF0000FFFF);
+		REG1 = ((REG1 <<  8) | REG1) & glm::uint64(0x00FF00FF00FF00FF);
+		REG1 = ((REG1 <<  4) | REG1) & glm::uint64(0x0F0F0F0F0F0F0F0F);
+		REG1 = ((REG1 <<  2) | REG1) & glm::uint64(0x3333333333333333);
+		REG1 = ((REG1 <<  1) | REG1) & glm::uint64(0x5555555555555555);
+
+		REG2 = y;
+		REG2 = ((REG2 << 16) | REG2) & glm::uint64(0x0000FFFF0000FFFF);
+		REG2 = ((REG2 <<  8) | REG2) & glm::uint64(0x00FF00FF00FF00FF);
+		REG2 = ((REG2 <<  4) | REG2) & glm::uint64(0x0F0F0F0F0F0F0F0F);
+		REG2 = ((REG2 <<  2) | REG2) & glm::uint64(0x3333333333333333);
+		REG2 = ((REG2 <<  1) | REG2) & glm::uint64(0x5555555555555555);
+
+		return REG1 | (REG2 << 1);
+	}
+
+	inline glm::uint64 interleaveBitfieldInterleave(glm::uint32 x, glm::uint32 y)
+	{
+		glm::uint64 REG1;
+		glm::uint64 REG2;
+
+		REG1 = x;
+		REG2 = y;
+
+		REG1 = ((REG1 << 16) | REG1) & glm::uint64(0x0000FFFF0000FFFF);
+		REG2 = ((REG2 << 16) | REG2) & glm::uint64(0x0000FFFF0000FFFF);
+
+		REG1 = ((REG1 <<  8) | REG1) & glm::uint64(0x00FF00FF00FF00FF);
+		REG2 = ((REG2 <<  8) | REG2) & glm::uint64(0x00FF00FF00FF00FF);
+
+		REG1 = ((REG1 <<  4) | REG1) & glm::uint64(0x0F0F0F0F0F0F0F0F);
+		REG2 = ((REG2 <<  4) | REG2) & glm::uint64(0x0F0F0F0F0F0F0F0F);
+
+		REG1 = ((REG1 <<  2) | REG1) & glm::uint64(0x3333333333333333);
+		REG2 = ((REG2 <<  2) | REG2) & glm::uint64(0x3333333333333333);
+
+		REG1 = ((REG1 <<  1) | REG1) & glm::uint64(0x5555555555555555);
+		REG2 = ((REG2 <<  1) | REG2) & glm::uint64(0x5555555555555555);
+
+		return REG1 | (REG2 << 1);
+	}
+/*
+	inline glm::uint64 loopBitfieldInterleave(glm::uint32 x, glm::uint32 y)
+	{
+		static glm::uint64 const Mask[5] = 
+		{
+			0x5555555555555555,
+			0x3333333333333333,
+			0x0F0F0F0F0F0F0F0F,
+			0x00FF00FF00FF00FF,
+			0x0000FFFF0000FFFF
+		};
+
+		glm::uint64 REG1 = x;
+		glm::uint64 REG2 = y;
+		for(int i = 4; i >= 0; --i)
+		{
+			REG1 = ((REG1 << (1 << i)) | REG1) & Mask[i];
+			REG2 = ((REG2 << (1 << i)) | REG2) & Mask[i];
+		}
+
+		return REG1 | (REG2 << 1);
+	}
+*/
+#if GLM_ARCH & GLM_ARCH_SSE2_BIT
+	inline glm::uint64 sseBitfieldInterleave(glm::uint32 x, glm::uint32 y)
+	{
+		__m128i const Array = _mm_set_epi32(0, y, 0, x);
+
+		__m128i const Mask4 = _mm_set1_epi32(0x0000FFFF);
+		__m128i const Mask3 = _mm_set1_epi32(0x00FF00FF);
+		__m128i const Mask2 = _mm_set1_epi32(0x0F0F0F0F);
+		__m128i const Mask1 = _mm_set1_epi32(0x33333333);
+		__m128i const Mask0 = _mm_set1_epi32(0x55555555);
+
+		__m128i Reg1;
+		__m128i Reg2;
+
+		// REG1 = x;
+		// REG2 = y;
+		Reg1 = _mm_load_si128(&Array);
+
+		//REG1 = ((REG1 << 16) | REG1) & glm::uint64(0x0000FFFF0000FFFF);
+		//REG2 = ((REG2 << 16) | REG2) & glm::uint64(0x0000FFFF0000FFFF);
+		Reg2 = _mm_slli_si128(Reg1, 2);
+		Reg1 = _mm_or_si128(Reg2, Reg1);
+		Reg1 = _mm_and_si128(Reg1, Mask4);
+
+		//REG1 = ((REG1 <<  8) | REG1) & glm::uint64(0x00FF00FF00FF00FF);
+		//REG2 = ((REG2 <<  8) | REG2) & glm::uint64(0x00FF00FF00FF00FF);
+		Reg2 = _mm_slli_si128(Reg1, 1);
+		Reg1 = _mm_or_si128(Reg2, Reg1);
+		Reg1 = _mm_and_si128(Reg1, Mask3);
+
+		//REG1 = ((REG1 <<  4) | REG1) & glm::uint64(0x0F0F0F0F0F0F0F0F);
+		//REG2 = ((REG2 <<  4) | REG2) & glm::uint64(0x0F0F0F0F0F0F0F0F);
+		Reg2 = _mm_slli_epi32(Reg1, 4);
+		Reg1 = _mm_or_si128(Reg2, Reg1);
+		Reg1 = _mm_and_si128(Reg1, Mask2);
+
+		//REG1 = ((REG1 <<  2) | REG1) & glm::uint64(0x3333333333333333);
+		//REG2 = ((REG2 <<  2) | REG2) & glm::uint64(0x3333333333333333);
+		Reg2 = _mm_slli_epi32(Reg1, 2);
+		Reg1 = _mm_or_si128(Reg2, Reg1);
+		Reg1 = _mm_and_si128(Reg1, Mask1);
+
+		//REG1 = ((REG1 <<  1) | REG1) & glm::uint64(0x5555555555555555);
+		//REG2 = ((REG2 <<  1) | REG2) & glm::uint64(0x5555555555555555);
+		Reg2 = _mm_slli_epi32(Reg1, 1);
+		Reg1 = _mm_or_si128(Reg2, Reg1);
+		Reg1 = _mm_and_si128(Reg1, Mask0);
+
+		//return REG1 | (REG2 << 1);
+		Reg2 = _mm_slli_epi32(Reg1, 1);
+		Reg2 = _mm_srli_si128(Reg2, 8);
+		Reg1 = _mm_or_si128(Reg1, Reg2);
+	
+		__m128i Result;
+		_mm_store_si128(&Result, Reg1);
+		return *reinterpret_cast<glm::uint64*>(&Result);
+	}
+
+	inline glm::uint64 sseUnalignedBitfieldInterleave(glm::uint32 x, glm::uint32 y)
+	{
+		__m128i const Array = _mm_set_epi32(0, y, 0, x);
+
+		__m128i const Mask4 = _mm_set1_epi32(0x0000FFFF);
+		__m128i const Mask3 = _mm_set1_epi32(0x00FF00FF);
+		__m128i const Mask2 = _mm_set1_epi32(0x0F0F0F0F);
+		__m128i const Mask1 = _mm_set1_epi32(0x33333333);
+		__m128i const Mask0 = _mm_set1_epi32(0x55555555);
+
+		__m128i Reg1;
+		__m128i Reg2;
+
+		// REG1 = x;
+		// REG2 = y;
+		Reg1 = _mm_loadu_si128(&Array);
+
+		//REG1 = ((REG1 << 16) | REG1) & glm::uint64(0x0000FFFF0000FFFF);
+		//REG2 = ((REG2 << 16) | REG2) & glm::uint64(0x0000FFFF0000FFFF);
+		Reg2 = _mm_slli_si128(Reg1, 2);
+		Reg1 = _mm_or_si128(Reg2, Reg1);
+		Reg1 = _mm_and_si128(Reg1, Mask4);
+
+		//REG1 = ((REG1 <<  8) | REG1) & glm::uint64(0x00FF00FF00FF00FF);
+		//REG2 = ((REG2 <<  8) | REG2) & glm::uint64(0x00FF00FF00FF00FF);
+		Reg2 = _mm_slli_si128(Reg1, 1);
+		Reg1 = _mm_or_si128(Reg2, Reg1);
+		Reg1 = _mm_and_si128(Reg1, Mask3);
+
+		//REG1 = ((REG1 <<  4) | REG1) & glm::uint64(0x0F0F0F0F0F0F0F0F);
+		//REG2 = ((REG2 <<  4) | REG2) & glm::uint64(0x0F0F0F0F0F0F0F0F);
+		Reg2 = _mm_slli_epi32(Reg1, 4);
+		Reg1 = _mm_or_si128(Reg2, Reg1);
+		Reg1 = _mm_and_si128(Reg1, Mask2);
+
+		//REG1 = ((REG1 <<  2) | REG1) & glm::uint64(0x3333333333333333);
+		//REG2 = ((REG2 <<  2) | REG2) & glm::uint64(0x3333333333333333);
+		Reg2 = _mm_slli_epi32(Reg1, 2);
+		Reg1 = _mm_or_si128(Reg2, Reg1);
+		Reg1 = _mm_and_si128(Reg1, Mask1);
+
+		//REG1 = ((REG1 <<  1) | REG1) & glm::uint64(0x5555555555555555);
+		//REG2 = ((REG2 <<  1) | REG2) & glm::uint64(0x5555555555555555);
+		Reg2 = _mm_slli_epi32(Reg1, 1);
+		Reg1 = _mm_or_si128(Reg2, Reg1);
+		Reg1 = _mm_and_si128(Reg1, Mask0);
+
+		//return REG1 | (REG2 << 1);
+		Reg2 = _mm_slli_epi32(Reg1, 1);
+		Reg2 = _mm_srli_si128(Reg2, 8);
+		Reg1 = _mm_or_si128(Reg1, Reg2);
+
+		__m128i Result;
+		_mm_store_si128(&Result, Reg1);
+		return *reinterpret_cast<glm::uint64*>(&Result);
+	}
+#endif//GLM_ARCH & GLM_ARCH_SSE2_BIT
+
+	int test()
+	{
+		int Error = 0;
+
+/*
+		{
+			for(glm::uint32 y = 0; y < (1 << 10); ++y)
+			for(glm::uint32 x = 0; x < (1 << 10); ++x)
+			{
+				glm::uint64 A = glm::bitfieldInterleave(x, y);
+				glm::uint64 B = fastBitfieldInterleave(x, y);
+				//glm::uint64 C = loopBitfieldInterleave(x, y);
+				glm::uint64 D = interleaveBitfieldInterleave(x, y);
+
+				assert(A == B);
+				//assert(A == C);
+				assert(A == D);
+
+#				if GLM_ARCH & GLM_ARCH_SSE2_BIT
+					glm::uint64 E = sseBitfieldInterleave(x, y);
+					glm::uint64 F = sseUnalignedBitfieldInterleave(x, y);
+					assert(A == E);
+					assert(A == F);
+
+					__m128i G = glm_i128_interleave(_mm_set_epi32(0, y, 0, x));
+					glm::uint64 Result[2];
+					_mm_storeu_si128((__m128i*)Result, G);
+					assert(A == Result[0]);
+#				endif//GLM_ARCH & GLM_ARCH_SSE2_BIT
+			}
+		}
+*/
+		{
+			for(glm::uint8 y = 0; y < 127; ++y)
+			for(glm::uint8 x = 0; x < 127; ++x)
+			{
+				glm::uint64 A(glm::bitfieldInterleave(glm::u8vec2(x, y)));
+				glm::uint64 B(glm::bitfieldInterleave(glm::u16vec2(x, y)));
+				glm::uint64 C(glm::bitfieldInterleave(glm::u32vec2(x, y)));
+
+				Error += A == B ? 0 : 1;
+				Error += A == C ? 0 : 1;
+
+				glm::u32vec2 const& D = glm::bitfieldDeinterleave(C);
+				Error += D.x == x ? 0 : 1;
+				Error += D.y == y ? 0 : 1;
+			}
+		}
+
+		{
+			for(glm::uint8 y = 0; y < 127; ++y)
+			for(glm::uint8 x = 0; x < 127; ++x)
+			{
+				glm::int64 A(glm::bitfieldInterleave(glm::int8(x), glm::int8(y)));
+				glm::int64 B(glm::bitfieldInterleave(glm::int16(x), glm::int16(y)));
+				glm::int64 C(glm::bitfieldInterleave(glm::int32(x), glm::int32(y)));
+
+				Error += A == B ? 0 : 1;
+				Error += A == C ? 0 : 1;
+			}
+		}
+
+		return Error;
+	}
+
+	int perf()
+	{
+		glm::uint32 x_max = 1 << 11;
+		glm::uint32 y_max = 1 << 10;
+
+		// ALU
+		std::vector<glm::uint64> Data(x_max * y_max);
+		std::vector<glm::u32vec2> Param(x_max * y_max);
+		for(glm::uint32 i = 0; i < Param.size(); ++i)
+			Param[i] = glm::u32vec2(i % x_max, i / y_max);
+
+		{
+			std::clock_t LastTime = std::clock();
+
+			for(std::size_t i = 0; i < Data.size(); ++i)
+				Data[i] = glm::bitfieldInterleave(Param[i].x, Param[i].y);
+
+			std::clock_t Time = std::clock() - LastTime;
+
+			std::printf("glm::bitfieldInterleave Time %d clocks\n", static_cast<int>(Time));
+		}
+
+		{
+			std::clock_t LastTime = std::clock();
+
+			for(std::size_t i = 0; i < Data.size(); ++i)
+				Data[i] = fastBitfieldInterleave(Param[i].x, Param[i].y);
+
+			std::clock_t Time = std::clock() - LastTime;
+
+			std::printf("fastBitfieldInterleave Time %d clocks\n", static_cast<int>(Time));
+		}
+/*
+		{
+			std::clock_t LastTime = std::clock();
+
+			for(std::size_t i = 0; i < Data.size(); ++i)
+				Data[i] = loopBitfieldInterleave(Param[i].x, Param[i].y);
+
+			std::clock_t Time = std::clock() - LastTime;
+
+			std::printf("loopBitfieldInterleave Time %d clocks\n", static_cast<int>(Time));
+		}
+*/
+		{
+			std::clock_t LastTime = std::clock();
+
+			for(std::size_t i = 0; i < Data.size(); ++i)
+				Data[i] = interleaveBitfieldInterleave(Param[i].x, Param[i].y);
+
+			std::clock_t Time = std::clock() - LastTime;
+
+			std::printf("interleaveBitfieldInterleave Time %d clocks\n", static_cast<int>(Time));
+		}
+
+#		if GLM_ARCH & GLM_ARCH_SSE2_BIT
+		{
+			std::clock_t LastTime = std::clock();
+
+			for(std::size_t i = 0; i < Data.size(); ++i)
+				Data[i] = sseBitfieldInterleave(Param[i].x, Param[i].y);
+
+			std::clock_t Time = std::clock() - LastTime;
+
+			std::printf("sseBitfieldInterleave Time %d clocks\n", static_cast<int>(Time));
+		}
+
+		{
+			std::clock_t LastTime = std::clock();
+
+			for(std::size_t i = 0; i < Data.size(); ++i)
+				Data[i] = sseUnalignedBitfieldInterleave(Param[i].x, Param[i].y);
+
+			std::clock_t Time = std::clock() - LastTime;
+
+			std::printf("sseUnalignedBitfieldInterleave Time %d clocks\n", static_cast<int>(Time));
+		}
+#		endif//GLM_ARCH & GLM_ARCH_SSE2_BIT
+
+		{
+			std::clock_t LastTime = std::clock();
+
+			for(std::size_t i = 0; i < Data.size(); ++i)
+				Data[i] = glm::bitfieldInterleave(Param[i].x, Param[i].y, Param[i].x);
+
+			std::clock_t Time = std::clock() - LastTime;
+
+			std::printf("glm::detail::bitfieldInterleave Time %d clocks\n", static_cast<int>(Time));
+		}
+
+#		if(GLM_ARCH & GLM_ARCH_SSE2_BIT && !(GLM_COMPILER & GLM_COMPILER_GCC))
+		{
+			// SIMD
+			std::vector<__m128i> SimdData;
+			SimdData.resize(static_cast<std::size_t>(x_max * y_max));
+			std::vector<__m128i> SimdParam;
+			SimdParam.resize(static_cast<std::size_t>(x_max * y_max));
+			for(std::size_t i = 0; i < SimdParam.size(); ++i)
+				SimdParam[i] = _mm_set_epi32(static_cast<int>(i % static_cast<std::size_t>(x_max)), 0, static_cast<int>(i / static_cast<std::size_t>(y_max)), 0);
+
+			std::clock_t LastTime = std::clock();
+
+			for(std::size_t i = 0; i < SimdData.size(); ++i)
+				SimdData[i] = glm_i128_interleave(SimdParam[i]);
+
+			std::clock_t Time = std::clock() - LastTime;
+
+			std::printf("_mm_bit_interleave_si128 Time %d clocks\n", static_cast<int>(Time));
+		}
+#		endif//GLM_ARCH & GLM_ARCH_SSE2_BIT
+
+		return 0;
+	}
+}//namespace bitfieldInterleave
+
+namespace bitfieldInterleave5
+{
+	GLM_FUNC_QUALIFIER glm::uint16 bitfieldInterleave_u8vec2(glm::uint8 x, glm::uint8 y)
+	{
+		glm::uint32 Result = (glm::uint32(y) << 16) | glm::uint32(x);
+		Result = ((Result <<  4) | Result) & 0x0F0F0F0F;
+		Result = ((Result <<  2) | Result) & 0x33333333;
+		Result = ((Result <<  1) | Result) & 0x55555555;
+		return static_cast<glm::uint16>((Result & 0x0000FFFF) | (Result >> 15));
+	}
+
+	GLM_FUNC_QUALIFIER glm::u8vec2 bitfieldDeinterleave_u8vec2(glm::uint16 InterleavedBitfield)
+	{
+		glm::uint32 Result(InterleavedBitfield);
+		Result = ((Result << 15) | Result) & 0x55555555;
+		Result = ((Result >>  1) | Result) & 0x33333333;
+		Result = ((Result >>  2) | Result) & 0x0F0F0F0F;
+		Result = ((Result >>  4) | Result) & 0x00FF00FF;
+		return glm::u8vec2(Result & 0x0000FFFF, Result >> 16);
+	}
+
+	GLM_FUNC_QUALIFIER glm::uint32 bitfieldInterleave_u8vec4(glm::uint8 x, glm::uint8 y, glm::uint8 z, glm::uint8 w)
+	{
+		glm::uint64 Result = (glm::uint64(w) << 48) | (glm::uint64(z) << 32) | (glm::uint64(y) << 16) | glm::uint64(x);
+		Result = ((Result << 12) | Result) & 0x000F000F000F000Full;
+		Result = ((Result <<  6) | Result) & 0x0303030303030303ull;
+		Result = ((Result <<  3) | Result) & 0x1111111111111111ull;
+
+		const glm::uint32 a = static_cast<glm::uint32>((Result & 0x000000000000FFFF) >> ( 0 - 0));
+		const glm::uint32 b = static_cast<glm::uint32>((Result & 0x00000000FFFF0000) >> (16 - 3));
+		const glm::uint32 c = static_cast<glm::uint32>((Result & 0x0000FFFF00000000) >> (32 - 6));
+		const glm::uint32 d = static_cast<glm::uint32>((Result & 0xFFFF000000000000) >> (48 - 12));
+
+		return a | b | c | d;
+	}
+
+	GLM_FUNC_QUALIFIER glm::u8vec4 bitfieldDeinterleave_u8vec4(glm::uint32 InterleavedBitfield)
+	{
+		glm::uint64 Result(InterleavedBitfield);
+		Result = ((Result << 15) | Result) & 0x9249249249249249ull;
+		Result = ((Result >>  1) | Result) & 0x30C30C30C30C30C3ull;
+		Result = ((Result >>  2) | Result) & 0xF00F00F00F00F00Full;
+		Result = ((Result >>  4) | Result) & 0x00FF0000FF0000FFull;
+		return glm::u8vec4(
+			(Result >> 0) & 0x000000000000FFFFull,
+			(Result >> 16) & 0x00000000FFFF0000ull,
+			(Result >> 32) & 0x0000FFFF00000000ull,
+			(Result >> 48) & 0xFFFF000000000000ull);
+	}
+
+	GLM_FUNC_QUALIFIER glm::uint32 bitfieldInterleave_u16vec2(glm::uint16 x, glm::uint16 y)
+	{
+		glm::uint64 Result = (glm::uint64(y) << 32) | glm::uint64(x);
+		Result = ((Result <<  8) | Result) & static_cast<glm::uint32>(0x00FF00FF00FF00FFull);
+		Result = ((Result <<  4) | Result) & static_cast<glm::uint32>(0x0F0F0F0F0F0F0F0Full);
+		Result = ((Result <<  2) | Result) & static_cast<glm::uint32>(0x3333333333333333ull);
+		Result = ((Result <<  1) | Result) & static_cast<glm::uint32>(0x5555555555555555ull);
+		return static_cast<glm::uint32>((Result & 0x00000000FFFFFFFFull) | (Result >> 31));
+	}
+
+	GLM_FUNC_QUALIFIER glm::u16vec2 bitfieldDeinterleave_u16vec2(glm::uint32 InterleavedBitfield)
+	{
+		glm::uint64 Result(InterleavedBitfield);
+		Result = ((Result << 31) | Result) & 0x5555555555555555ull;
+		Result = ((Result >>  1) | Result) & 0x3333333333333333ull;
+		Result = ((Result >>  2) | Result) & 0x0F0F0F0F0F0F0F0Full;
+		Result = ((Result >>  4) | Result) & 0x00FF00FF00FF00FFull;
+		Result = ((Result >>  8) | Result) & 0x0000FFFF0000FFFFull;
+		return glm::u16vec2(Result & 0x00000000FFFFFFFFull, Result >> 32);
+	}
+
+	int test()
+	{
+		int Error = 0;
+
+		for(glm::size_t j = 0; j < 256; ++j)
+		for(glm::size_t i = 0; i < 256; ++i)
+		{
+			glm::uint16 A = bitfieldInterleave_u8vec2(glm::uint8(i), glm::uint8(j));
+			glm::uint16 B = glm::bitfieldInterleave(glm::uint8(i), glm::uint8(j));
+			Error += A == B ? 0 : 1;
+
+			glm::u8vec2 C = bitfieldDeinterleave_u8vec2(A);
+			Error += C.x == glm::uint8(i) ? 0 : 1;
+			Error += C.y == glm::uint8(j) ? 0 : 1;
+		}
+
+		for(glm::size_t j = 0; j < 256; ++j)
+		for(glm::size_t i = 0; i < 256; ++i)
+		{
+			glm::uint32 A = bitfieldInterleave_u8vec4(glm::uint8(i), glm::uint8(j), glm::uint8(i), glm::uint8(j));
+			glm::uint32 B = glm::bitfieldInterleave(glm::uint8(i), glm::uint8(j), glm::uint8(i), glm::uint8(j));
+			Error += A == B ? 0 : 1;
+/*
+			glm::u8vec4 C = bitfieldDeinterleave_u8vec4(A);
+			Error += C.x == glm::uint8(i) ? 0 : 1;
+			Error += C.y == glm::uint8(j) ? 0 : 1;
+			Error += C.z == glm::uint8(i) ? 0 : 1;
+			Error += C.w == glm::uint8(j) ? 0 : 1;
+*/
+		}
+
+		for(glm::size_t j = 0; j < 256; ++j)
+		for(glm::size_t i = 0; i < 256; ++i)
+		{
+			glm::uint32 A = bitfieldInterleave_u16vec2(glm::uint16(i), glm::uint16(j));
+			glm::uint32 B = glm::bitfieldInterleave(glm::uint16(i), glm::uint16(j));
+			Error += A == B ? 0 : 1;
+		}
+
+		return Error;
+	}
+
+	int perf_old_u8vec2(std::vector<glm::uint16>& Result)
+	{
+		int Error = 0;
+
+		const std::clock_t BeginTime = std::clock();
+		
+		for(glm::size_t k = 0; k < 10000; ++k)
+		for(glm::size_t j = 0; j < 256; ++j)
+		for(glm::size_t i = 0; i < 256; ++i)
+			Error += Result[j * 256 + i] == glm::bitfieldInterleave(glm::uint8(i), glm::uint8(j)) ? 0 : 1;
+
+		const std::clock_t EndTime = std::clock();
+
+		std::printf("glm::bitfieldInterleave<u8vec2> Time %d clocks\n", static_cast<int>(EndTime - BeginTime));
+
+		return Error;
+	}
+
+	int perf_new_u8vec2(std::vector<glm::uint16>& Result)
+	{
+		int Error = 0;
+
+		const std::clock_t BeginTime = std::clock();
+
+		for(glm::size_t k = 0; k < 10000; ++k)
+		for(glm::size_t j = 0; j < 256; ++j)
+		for(glm::size_t i = 0; i < 256; ++i)
+			Error += Result[j * 256 + i] == bitfieldInterleave_u8vec2(glm::uint8(i), glm::uint8(j)) ? 0 : 1;
+
+		const std::clock_t EndTime = std::clock();
+
+		std::printf("bitfieldInterleave_u8vec2 Time %d clocks\n", static_cast<int>(EndTime - BeginTime));
+
+		return Error;
+	}
+
+	int perf_old_u8vec4(std::vector<glm::uint32>& Result)
+	{
+		int Error = 0;
+
+		const std::clock_t BeginTime = std::clock();
+
+		for(glm::size_t k = 0; k < 10000; ++k)
+		for(glm::size_t j = 0; j < 256; ++j)
+		for(glm::size_t i = 0; i < 256; ++i)
+			Error += Result[j * 256 + i] == glm::bitfieldInterleave(glm::uint8(i), glm::uint8(j), glm::uint8(i), glm::uint8(j)) ? 0 : 1;
+
+		const std::clock_t EndTime = std::clock();
+
+		std::printf("glm::bitfieldInterleave<u8vec4> Time %d clocks\n", static_cast<int>(EndTime - BeginTime));
+
+		return Error;
+	}
+
+	int perf_new_u8vec4(std::vector<glm::uint32>& Result)
+	{
+		int Error = 0;
+
+		const std::clock_t BeginTime = std::clock();
+
+		for(glm::size_t k = 0; k < 10000; ++k)
+		for(glm::size_t j = 0; j < 256; ++j)
+		for(glm::size_t i = 0; i < 256; ++i)
+			Error += Result[j * 256 + i] == bitfieldInterleave_u8vec4(glm::uint8(i), glm::uint8(j), glm::uint8(i), glm::uint8(j)) ? 0 : 1;
+
+		const std::clock_t EndTime = std::clock();
+
+		std::printf("bitfieldInterleave_u8vec4 Time %d clocks\n", static_cast<int>(EndTime - BeginTime));
+
+		return Error;
+	}
+
+	int perf_old_u16vec2(std::vector<glm::uint32>& Result)
+	{
+		int Error = 0;
+
+		const std::clock_t BeginTime = std::clock();
+
+		for(glm::size_t k = 0; k < 10000; ++k)
+		for(glm::size_t j = 0; j < 256; ++j)
+		for(glm::size_t i = 0; i < 256; ++i)
+			Error += Result[j * 256 + i] == glm::bitfieldInterleave(glm::uint16(i), glm::uint16(j)) ? 0 : 1;
+
+		const std::clock_t EndTime = std::clock();
+
+		std::printf("glm::bitfieldInterleave<u16vec2> Time %d clocks\n", static_cast<int>(EndTime - BeginTime));
+
+		return Error;
+	}
+
+	int perf_new_u16vec2(std::vector<glm::uint32>& Result)
+	{
+		int Error = 0;
+
+		const std::clock_t BeginTime = std::clock();
+
+		for(glm::size_t k = 0; k < 10000; ++k)
+		for(glm::size_t j = 0; j < 256; ++j)
+		for(glm::size_t i = 0; i < 256; ++i)
+			Error += Result[j * 256 + i] == bitfieldInterleave_u16vec2(glm::uint16(i), glm::uint16(j)) ? 0 : 1;
+
+		const std::clock_t EndTime = std::clock();
+
+		std::printf("bitfieldInterleave_u16vec2 Time %d clocks\n", static_cast<int>(EndTime - BeginTime));
+
+		return Error;
+	}
+
+	int perf()
+	{
+		int Error = 0;
+
+		std::printf("bitfieldInterleave perf: init\r");
+
+		std::vector<glm::uint16> Result_u8vec2(256 * 256, 0);
+		for(glm::size_t j = 0; j < 256; ++j)
+		for(glm::size_t i = 0; i < 256; ++i)
+			Result_u8vec2[j * 256 + i] = glm::bitfieldInterleave(glm::uint8(i), glm::uint8(j));
+
+		Error += perf_old_u8vec2(Result_u8vec2);
+		Error += perf_new_u8vec2(Result_u8vec2);
+
+		std::vector<glm::uint32> Result_u8vec4(256 * 256, 0);
+		for(glm::size_t j = 0; j < 256; ++j)
+		for(glm::size_t i = 0; i < 256; ++i)
+			Result_u8vec4[j * 256 + i] = glm::bitfieldInterleave(glm::uint8(i), glm::uint8(j), glm::uint8(i), glm::uint8(j));
+		
+		Error += perf_old_u8vec4(Result_u8vec4);
+		Error += perf_new_u8vec4(Result_u8vec4);
+
+		std::vector<glm::uint32> Result_u16vec2(256 * 256, 0);
+		for(glm::size_t j = 0; j < 256; ++j)
+		for(glm::size_t i = 0; i < 256; ++i)
+			Result_u16vec2[j * 256 + i] = glm::bitfieldInterleave(glm::uint16(i), glm::uint16(j));
+
+		Error += perf_old_u16vec2(Result_u16vec2);
+		Error += perf_new_u16vec2(Result_u16vec2);
+
+		std::printf("bitfieldInterleave perf: %d Errors\n", Error);
+
+		return Error;
+	}
+
+}//namespace bitfieldInterleave5
+
+static int test_bitfieldRotateRight()
+{
+	glm::ivec4 const A = glm::bitfieldRotateRight(glm::ivec4(2), 1);
+	glm::ivec4 const B = glm::ivec4(2) >> 1;
+
+	return A == B;
+}
+
+static int test_bitfieldRotateLeft()
+{
+	glm::ivec4 const A = glm::bitfieldRotateLeft(glm::ivec4(2), 1);
+	glm::ivec4 const B = glm::ivec4(2) << 1;
+
+	return A == B;
+}
+
+int main()
+{
+	int Error = 0;
+
+/* Tests for a faster and to reserve bitfieldInterleave
+	Error += ::bitfieldInterleave5::test();
+	Error += ::bitfieldInterleave5::perf();
+*/
+	Error += ::mask::test();
+	Error += ::bitfieldInterleave3::test();
+	Error += ::bitfieldInterleave4::test();
+	Error += ::bitfieldInterleave::test();
+
+	Error += test_bitfieldRotateRight();
+	Error += test_bitfieldRotateLeft();
+
+#	ifdef NDEBUG
+		Error += ::mask::perf();
+		Error += ::bitfieldInterleave::perf();
+#	endif//NDEBUG
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/gtc/gtc_color_space.cpp b/3rdparty/glm/source/test/gtc/gtc_color_space.cpp
new file mode 100644
index 0000000..67650c5
--- /dev/null
+++ b/3rdparty/glm/source/test/gtc/gtc_color_space.cpp
@@ -0,0 +1,78 @@
+#include <glm/gtc/color_space.hpp>
+#include <glm/gtc/epsilon.hpp>
+#include <glm/gtc/constants.hpp>
+
+namespace srgb
+{
+	int test()
+	{
+		int Error(0);
+
+		glm::vec3 const ColorSourceRGB(1.0, 0.5, 0.0);
+
+		{
+			glm::vec3 const ColorSRGB = glm::convertLinearToSRGB(ColorSourceRGB);
+			glm::vec3 const ColorRGB = glm::convertSRGBToLinear(ColorSRGB);
+			Error += glm::all(glm::epsilonEqual(ColorSourceRGB, ColorRGB, 0.00001f)) ? 0 : 1;
+		}
+
+		{
+			glm::vec3 const ColorSRGB = glm::convertLinearToSRGB(ColorSourceRGB, 2.8f);
+			glm::vec3 const ColorRGB = glm::convertSRGBToLinear(ColorSRGB, 2.8f);
+			Error += glm::all(glm::epsilonEqual(ColorSourceRGB, ColorRGB, 0.00001f)) ? 0 : 1;
+		}
+
+		glm::vec4 const ColorSourceRGBA(1.0, 0.5, 0.0, 1.0);
+
+		{
+			glm::vec4 const ColorSRGB = glm::convertLinearToSRGB(ColorSourceRGBA);
+			glm::vec4 const ColorRGB = glm::convertSRGBToLinear(ColorSRGB);
+			Error += glm::all(glm::epsilonEqual(ColorSourceRGBA, ColorRGB, 0.00001f)) ? 0 : 1;
+		}
+
+		{
+			glm::vec4 const ColorSRGB = glm::convertLinearToSRGB(ColorSourceRGBA, 2.8f);
+			glm::vec4 const ColorRGB = glm::convertSRGBToLinear(ColorSRGB, 2.8f);
+			Error += glm::all(glm::epsilonEqual(ColorSourceRGBA, ColorRGB, 0.00001f)) ? 0 : 1;
+		}
+
+		glm::vec4 const ColorSourceGNI = glm::vec4(107, 107, 104, 131) / glm::vec4(255);
+
+		{
+			glm::vec4 const ColorGNA = glm::convertSRGBToLinear(ColorSourceGNI) * glm::vec4(255);
+			glm::vec4 const ColorGNE = glm::convertLinearToSRGB(ColorSourceGNI) * glm::vec4(255);
+			glm::vec4 const ColorSRGB = glm::convertLinearToSRGB(ColorSourceGNI);
+			glm::vec4 const ColorRGB = glm::convertSRGBToLinear(ColorSRGB);
+			Error += glm::all(glm::epsilonEqual(ColorSourceGNI, ColorRGB, 0.00001f)) ? 0 : 1;
+		}
+
+		return Error;
+	}
+}//namespace srgb
+
+namespace srgb_lowp
+{
+	int test()
+	{
+		int Error(0);
+
+		for(float Color = 0.0f; Color < 1.0f; Color += 0.01f)
+		{
+			glm::highp_vec3 const HighpSRGB = glm::convertLinearToSRGB(glm::highp_vec3(Color));
+			glm::lowp_vec3 const LowpSRGB = glm::convertLinearToSRGB(glm::lowp_vec3(Color));
+			Error += glm::all(glm::epsilonEqual(glm::abs(HighpSRGB - glm::highp_vec3(LowpSRGB)), glm::highp_vec3(0), 0.1f)) ? 0 : 1;
+		}
+
+		return Error;
+	}
+}//namespace srgb_lowp
+
+int main()
+{
+	int Error(0);
+
+	Error += srgb::test();
+	Error += srgb_lowp::test();
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/gtc/gtc_constants.cpp b/3rdparty/glm/source/test/gtc/gtc_constants.cpp
new file mode 100644
index 0000000..3897cd0
--- /dev/null
+++ b/3rdparty/glm/source/test/gtc/gtc_constants.cpp
@@ -0,0 +1,30 @@
+#include <glm/gtc/constants.hpp>
+
+int test_epsilon()
+{
+	int Error = 0;
+
+	{
+		float Test = glm::epsilon<float>();
+		Error += Test > 0.0f ? 0 : 1;
+	}
+
+	{
+		double Test = glm::epsilon<double>();
+		Error += Test > 0.0 ? 0 : 1;
+	}
+
+	return Error;
+}
+
+int main()
+{
+	int Error(0);
+
+	//float MinHalf = 0.0f;
+	//while (glm::half(MinHalf) == glm::half(0.0f))
+	//	MinHalf += std::numeric_limits<float>::epsilon();
+	Error += test_epsilon();
+	
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/gtc/gtc_epsilon.cpp b/3rdparty/glm/source/test/gtc/gtc_epsilon.cpp
new file mode 100644
index 0000000..f0e6c8a
--- /dev/null
+++ b/3rdparty/glm/source/test/gtc/gtc_epsilon.cpp
@@ -0,0 +1,78 @@
+#include <glm/gtc/epsilon.hpp>
+#include <glm/gtc/constants.hpp>
+#include <glm/gtc/quaternion.hpp>
+#include <glm/vector_relational.hpp>
+
+int test_defined()
+{
+	glm::epsilonEqual(glm::vec2(), glm::vec2(), glm::vec2());
+	glm::epsilonEqual(glm::vec3(), glm::vec3(), glm::vec3());
+	glm::epsilonEqual(glm::vec4(), glm::vec4(), glm::vec4());
+
+	glm::epsilonNotEqual(glm::vec2(), glm::vec2(), glm::vec2());
+	glm::epsilonNotEqual(glm::vec3(), glm::vec3(), glm::vec3());
+	glm::epsilonNotEqual(glm::vec4(), glm::vec4(), glm::vec4());
+	
+	glm::epsilonEqual(glm::vec2(), glm::vec2(), 0.0f);
+	glm::epsilonEqual(glm::vec3(), glm::vec3(), 0.0f);
+	glm::epsilonEqual(glm::vec4(), glm::vec4(), 0.0f);
+	glm::epsilonEqual(glm::quat(), glm::quat(), 0.0f);
+
+	glm::epsilonNotEqual(glm::vec2(), glm::vec2(), 0.0f);
+	glm::epsilonNotEqual(glm::vec3(), glm::vec3(), 0.0f);
+	glm::epsilonNotEqual(glm::vec4(), glm::vec4(), 0.0f);
+	glm::epsilonNotEqual(glm::quat(), glm::quat(), 0.0f);
+
+	return 0;
+}
+
+template<typename T>
+int test_equal()
+{
+	int Error(0);
+	
+	{
+		T A = glm::epsilon<T>();
+		T B = glm::epsilon<T>();
+		Error += glm::epsilonEqual(A, B, glm::epsilon<T>() * T(2)) ? 0 : 1;
+	}
+
+	{
+		T A(0);
+		T B = static_cast<T>(0) + glm::epsilon<T>();
+		Error += glm::epsilonEqual(A, B, glm::epsilon<T>() * T(2)) ? 0 : 1;
+	}
+
+	{
+		T A(0);
+		T B = static_cast<T>(0) - glm::epsilon<T>();
+		Error += glm::epsilonEqual(A, B, glm::epsilon<T>() * T(2)) ? 0 : 1;
+	}
+
+	{
+		T A = static_cast<T>(0) + glm::epsilon<T>();
+		T B = static_cast<T>(0);
+		Error += glm::epsilonEqual(A, B, glm::epsilon<T>() * T(2)) ? 0 : 1;
+	}
+
+	{
+		T A = static_cast<T>(0) - glm::epsilon<T>();
+		T B = static_cast<T>(0);
+		Error += glm::epsilonEqual(A, B, glm::epsilon<T>() * T(2)) ? 0 : 1;
+	}
+
+	return Error;
+}
+
+int main()
+{
+	int Error(0);
+
+	Error += test_defined();
+	Error += test_equal<float>();
+	Error += test_equal<double>();
+
+	return Error;
+}
+
+
diff --git a/3rdparty/glm/source/test/gtc/gtc_integer.cpp b/3rdparty/glm/source/test/gtc/gtc_integer.cpp
new file mode 100644
index 0000000..769d969
--- /dev/null
+++ b/3rdparty/glm/source/test/gtc/gtc_integer.cpp
@@ -0,0 +1,233 @@
+#define GLM_ENABLE_EXPERIMENTAL
+#define GLM_FORCE_INLINE
+#include <glm/gtc/epsilon.hpp>
+#include <glm/gtc/integer.hpp>
+#include <glm/gtc/type_precision.hpp>
+#include <glm/gtc/vec1.hpp>
+#include <glm/gtx/type_aligned.hpp>
+#include <glm/vector_relational.hpp>
+#include <glm/vec2.hpp>
+#include <glm/vec3.hpp>
+#include <glm/vec4.hpp>
+#include <ctime>
+#include <cstdio>
+#include <vector>
+#include <cmath>
+
+namespace log2_
+{
+	int test()
+	{
+		int Error = 0;
+
+		int A0 = static_cast<int>(glm::log2(16.f));
+		glm::ivec1 B0(glm::log2(glm::vec1(16.f)));
+		glm::ivec2 C0(glm::log2(glm::vec2(16.f)));
+		glm::ivec3 D0(glm::log2(glm::vec3(16.f)));
+		glm::ivec4 E0(glm::log2(glm::vec4(16.f)));
+
+		int A1 = glm::log2(int(16));
+		glm::ivec1 B1 = glm::log2(glm::ivec1(16));
+		glm::ivec2 C1 = glm::log2(glm::ivec2(16));
+		glm::ivec3 D1 = glm::log2(glm::ivec3(16));
+		glm::ivec4 E1 = glm::log2(glm::ivec4(16));
+
+		Error += A0 == A1 ? 0 : 1;
+		Error += glm::all(glm::equal(B0, B1)) ? 0 : 1;
+		Error += glm::all(glm::equal(C0, C1)) ? 0 : 1;
+		Error += glm::all(glm::equal(D0, D1)) ? 0 : 1;
+		Error += glm::all(glm::equal(E0, E1)) ? 0 : 1;
+
+		glm::uint64 A2 = glm::log2(glm::uint64(16));
+		glm::u64vec1 B2 = glm::log2(glm::u64vec1(16));
+		glm::u64vec2 C2 = glm::log2(glm::u64vec2(16));
+		glm::u64vec3 D2 = glm::log2(glm::u64vec3(16));
+		glm::u64vec4 E2 = glm::log2(glm::u64vec4(16));
+
+		Error += A2 == glm::uint64(4) ? 0 : 1;
+		Error += glm::all(glm::equal(B2, glm::u64vec1(4))) ? 0 : 1;
+		Error += glm::all(glm::equal(C2, glm::u64vec2(4))) ? 0 : 1;
+		Error += glm::all(glm::equal(D2, glm::u64vec3(4))) ? 0 : 1;
+		Error += glm::all(glm::equal(E2, glm::u64vec4(4))) ? 0 : 1;
+
+		return Error;
+	}
+
+	int perf(std::size_t Count)
+	{
+		int Error = 0;
+
+		{
+			std::vector<int> Result;
+			Result.resize(Count);
+
+			std::clock_t Begin = clock();
+
+			for(int i = 0; i < static_cast<int>(Count); ++i)
+				Result[i] = glm::log2(static_cast<int>(i));
+
+			std::clock_t End = clock();
+
+			std::printf("glm::log2<int>: %d clocks\n", static_cast<int>(End - Begin));
+		}
+
+		{
+			std::vector<glm::ivec4> Result;
+			Result.resize(Count);
+
+			std::clock_t Begin = clock();
+
+			for(int i = 0; i < static_cast<int>(Count); ++i)
+				Result[i] = glm::log2(glm::ivec4(i));
+
+			std::clock_t End = clock();
+
+			std::printf("glm::log2<ivec4>: %d clocks\n", static_cast<int>(End - Begin));
+		}
+
+#		if GLM_HAS_BITSCAN_WINDOWS
+		{
+			std::vector<glm::ivec4> Result;
+			Result.resize(Count);
+
+			std::clock_t Begin = clock();
+
+			for(std::size_t i = 0; i < Count; ++i)
+			{
+				glm::vec<4, unsigned long, glm::defaultp> Tmp;
+				_BitScanReverse(&Tmp.x, i);
+				_BitScanReverse(&Tmp.y, i);
+				_BitScanReverse(&Tmp.z, i);
+				_BitScanReverse(&Tmp.w, i);
+				Result[i] = glm::ivec4(Tmp);
+			}
+
+			std::clock_t End = clock();
+
+			std::printf("glm::log2<ivec4> inlined: %d clocks\n", static_cast<int>(End - Begin));
+		}
+
+
+		{
+			std::vector<glm::vec<4, unsigned long, glm::defaultp> > Result;
+			Result.resize(Count);
+
+			std::clock_t Begin = clock();
+
+			for(std::size_t i = 0; i < Count; ++i)
+			{
+				_BitScanReverse(&Result[i].x, i);
+				_BitScanReverse(&Result[i].y, i);
+				_BitScanReverse(&Result[i].z, i);
+				_BitScanReverse(&Result[i].w, i);
+			}
+
+			std::clock_t End = clock();
+
+			std::printf("glm::log2<ivec4> inlined no cast: %d clocks\n", static_cast<int>(End - Begin));
+		}
+
+
+		{
+			std::vector<glm::ivec4> Result;
+			Result.resize(Count);
+
+			std::clock_t Begin = clock();
+
+			for(std::size_t i = 0; i < Count; ++i)
+			{
+				_BitScanReverse(reinterpret_cast<unsigned long*>(&Result[i].x), i);
+				_BitScanReverse(reinterpret_cast<unsigned long*>(&Result[i].y), i);
+				_BitScanReverse(reinterpret_cast<unsigned long*>(&Result[i].z), i);
+				_BitScanReverse(reinterpret_cast<unsigned long*>(&Result[i].w), i);
+			}
+
+			std::clock_t End = clock();
+
+			std::printf("glm::log2<ivec4> reinterpret: %d clocks\n", static_cast<int>(End - Begin));
+		}
+#		endif//GLM_HAS_BITSCAN_WINDOWS
+
+		{
+			std::vector<float> Result;
+			Result.resize(Count);
+
+			std::clock_t Begin = clock();
+
+			for(std::size_t i = 0; i < Count; ++i)
+				Result[i] = glm::log2(static_cast<float>(i));
+
+			std::clock_t End = clock();
+
+			std::printf("glm::log2<float>: %d clocks\n", static_cast<int>(End - Begin));
+		}
+
+		{
+			std::vector<glm::vec4> Result;
+			Result.resize(Count);
+
+			std::clock_t Begin = clock();
+
+			for(int i = 0; i < static_cast<int>(Count); ++i)
+				Result[i] = glm::log2(glm::vec4(static_cast<float>(i)));
+
+			std::clock_t End = clock();
+
+			std::printf("glm::log2<vec4>: %d clocks\n", static_cast<int>(End - Begin));
+		}
+
+		return Error;
+	}
+}//namespace log2_
+
+namespace iround
+{
+	int test()
+	{
+		int Error = 0;
+
+		for(float f = 0.0f; f < 3.1f; f += 0.05f)
+		{
+			int RoundFast = static_cast<int>(glm::iround(f));
+			int RoundSTD = static_cast<int>(glm::round(f));
+			Error += RoundFast == RoundSTD ? 0 : 1;
+			assert(!Error);
+		}
+
+		return Error;
+	}
+}//namespace iround
+
+namespace uround
+{
+	int test()
+	{
+		int Error = 0;
+
+		for(float f = 0.0f; f < 3.1f; f += 0.05f)
+		{
+			int RoundFast = static_cast<int>(glm::uround(f));
+			int RoundSTD = static_cast<int>(glm::round(f));
+			Error += RoundFast == RoundSTD ? 0 : 1;
+			assert(!Error);
+		}
+
+		return Error;
+	}
+}//namespace uround
+
+int main()
+{
+	int Error(0);
+
+	Error += ::log2_::test();
+	Error += ::iround::test();
+	Error += ::uround::test();
+
+#	ifdef NDEBUG
+		std::size_t const Samples(1000);
+		Error += ::log2_::perf(Samples);
+#	endif//NDEBUG
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/gtc/gtc_matrix_access.cpp b/3rdparty/glm/source/test/gtc/gtc_matrix_access.cpp
new file mode 100644
index 0000000..1b966e2
--- /dev/null
+++ b/3rdparty/glm/source/test/gtc/gtc_matrix_access.cpp
@@ -0,0 +1,383 @@
+#include <glm/ext/vector_relational.hpp>
+#include <glm/gtc/constants.hpp>
+#include <glm/gtc/matrix_access.hpp>
+#include <glm/mat2x2.hpp>
+#include <glm/mat2x3.hpp>
+#include <glm/mat2x4.hpp>
+#include <glm/mat3x2.hpp>
+#include <glm/mat3x3.hpp>
+#include <glm/mat3x4.hpp>
+#include <glm/mat4x2.hpp>
+#include <glm/mat4x3.hpp>
+#include <glm/mat4x4.hpp>
+
+int test_mat2x2_row_set()
+{
+	int Error = 0;
+
+	glm::mat2x2 m(1);
+
+	m = glm::row(m, 0, glm::vec2( 0,  1));
+	m = glm::row(m, 1, glm::vec2( 4,  5));
+
+	Error += glm::all(glm::equal(glm::row(m, 0), glm::vec2( 0,  1), glm::epsilon<float>())) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::row(m, 1), glm::vec2( 4,  5), glm::epsilon<float>())) ? 0 : 1;
+
+	return Error;
+}
+
+int test_mat2x2_col_set()
+{
+	int Error = 0;
+
+	glm::mat2x2 m(1);
+
+	m = glm::column(m, 0, glm::vec2( 0,  1));
+	m = glm::column(m, 1, glm::vec2( 4,  5));
+
+	Error += glm::all(glm::equal(glm::column(m, 0), glm::vec2( 0,  1), glm::epsilon<float>())) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::column(m, 1), glm::vec2( 4,  5), glm::epsilon<float>())) ? 0 : 1;
+
+	return Error;
+}
+
+int test_mat2x3_row_set()
+{
+	int Error = 0;
+
+	glm::mat2x3 m(1);
+
+	m = glm::row(m, 0, glm::vec2( 0,  1));
+	m = glm::row(m, 1, glm::vec2( 4,  5));
+	m = glm::row(m, 2, glm::vec2( 8,  9));
+
+	Error += glm::all(glm::equal(glm::row(m, 0), glm::vec2( 0,  1), glm::epsilon<float>())) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::row(m, 1), glm::vec2( 4,  5), glm::epsilon<float>())) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::row(m, 2), glm::vec2( 8,  9), glm::epsilon<float>())) ? 0 : 1;
+
+	return Error;
+}
+
+int test_mat2x3_col_set()
+{
+	int Error = 0;
+
+	glm::mat2x3 m(1);
+
+	m = glm::column(m, 0, glm::vec3( 0,  1,  2));
+	m = glm::column(m, 1, glm::vec3( 4,  5,  6));
+
+	Error += glm::all(glm::equal(glm::column(m, 0), glm::vec3( 0,  1,  2), glm::epsilon<float>())) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::column(m, 1), glm::vec3( 4,  5,  6), glm::epsilon<float>())) ? 0 : 1;
+
+	return Error;
+}
+
+int test_mat2x4_row_set()
+{
+	int Error = 0;
+
+	glm::mat2x4 m(1);
+
+	m = glm::row(m, 0, glm::vec2( 0,  1));
+	m = glm::row(m, 1, glm::vec2( 4,  5));
+	m = glm::row(m, 2, glm::vec2( 8,  9));
+	m = glm::row(m, 3, glm::vec2(12, 13));
+
+	Error += glm::all(glm::equal(glm::row(m, 0), glm::vec2( 0,  1), glm::epsilon<float>())) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::row(m, 1), glm::vec2( 4,  5), glm::epsilon<float>())) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::row(m, 2), glm::vec2( 8,  9), glm::epsilon<float>())) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::row(m, 3), glm::vec2(12, 13), glm::epsilon<float>())) ? 0 : 1;
+
+	return Error;
+}
+
+int test_mat2x4_col_set()
+{
+	int Error = 0;
+
+	glm::mat2x4 m(1);
+
+	m = glm::column(m, 0, glm::vec4( 0,  1,  2, 3));
+	m = glm::column(m, 1, glm::vec4( 4,  5,  6, 7));
+
+	Error += glm::all(glm::equal(glm::column(m, 0), glm::vec4( 0,  1,  2, 3), glm::epsilon<float>())) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::column(m, 1), glm::vec4( 4,  5,  6, 7), glm::epsilon<float>())) ? 0 : 1;
+
+	return Error;
+}
+
+int test_mat3x2_row_set()
+{
+	int Error = 0;
+
+	glm::mat3x2 m(1);
+
+	m = glm::row(m, 0, glm::vec3( 0,  1,  2));
+	m = glm::row(m, 1, glm::vec3( 4,  5,  6));
+
+	Error += glm::all(glm::equal(glm::row(m, 0), glm::vec3( 0,  1,  2), glm::epsilon<float>())) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::row(m, 1), glm::vec3( 4,  5,  6), glm::epsilon<float>())) ? 0 : 1;
+
+	return Error;
+}
+
+int test_mat3x2_col_set()
+{
+	int Error = 0;
+
+	glm::mat3x2 m(1);
+
+	m = glm::column(m, 0, glm::vec2( 0,  1));
+	m = glm::column(m, 1, glm::vec2( 4,  5));
+	m = glm::column(m, 2, glm::vec2( 8,  9));
+
+	Error += glm::all(glm::equal(glm::column(m, 0), glm::vec2( 0,  1), glm::epsilon<float>())) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::column(m, 1), glm::vec2( 4,  5), glm::epsilon<float>())) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::column(m, 2), glm::vec2( 8,  9), glm::epsilon<float>())) ? 0 : 1;
+
+	return Error;
+}
+
+int test_mat3x3_row_set()
+{
+	int Error = 0;
+
+	glm::mat3x3 m(1);
+
+	m = glm::row(m, 0, glm::vec3( 0,  1,  2));
+	m = glm::row(m, 1, glm::vec3( 4,  5,  6));
+	m = glm::row(m, 2, glm::vec3( 8,  9, 10));
+
+	Error += glm::all(glm::equal(glm::row(m, 0), glm::vec3( 0,  1,  2), glm::epsilon<float>())) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::row(m, 1), glm::vec3( 4,  5,  6), glm::epsilon<float>())) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::row(m, 2), glm::vec3( 8,  9, 10), glm::epsilon<float>())) ? 0 : 1;
+
+	return Error;
+}
+
+int test_mat3x3_col_set()
+{
+	int Error = 0;
+
+	glm::mat3x3 m(1);
+
+	m = glm::column(m, 0, glm::vec3( 0,  1,  2));
+	m = glm::column(m, 1, glm::vec3( 4,  5,  6));
+	m = glm::column(m, 2, glm::vec3( 8,  9, 10));
+
+	Error += glm::all(glm::equal(glm::column(m, 0), glm::vec3( 0,  1,  2), glm::epsilon<float>())) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::column(m, 1), glm::vec3( 4,  5,  6), glm::epsilon<float>())) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::column(m, 2), glm::vec3( 8,  9, 10), glm::epsilon<float>())) ? 0 : 1;
+
+	return Error;
+}
+
+int test_mat3x4_row_set()
+{
+	int Error = 0;
+
+	glm::mat3x4 m(1);
+
+	m = glm::row(m, 0, glm::vec3( 0,  1,  2));
+	m = glm::row(m, 1, glm::vec3( 4,  5,  6));
+	m = glm::row(m, 2, glm::vec3( 8,  9, 10));
+	m = glm::row(m, 3, glm::vec3(12, 13, 14));
+
+	Error += glm::all(glm::equal(glm::row(m, 0), glm::vec3( 0,  1,  2), glm::epsilon<float>())) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::row(m, 1), glm::vec3( 4,  5,  6), glm::epsilon<float>())) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::row(m, 2), glm::vec3( 8,  9, 10), glm::epsilon<float>())) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::row(m, 3), glm::vec3(12, 13, 14), glm::epsilon<float>())) ? 0 : 1;
+
+	return Error;
+}
+
+int test_mat3x4_col_set()
+{
+	int Error = 0;
+
+	glm::mat3x4 m(1);
+
+	m = glm::column(m, 0, glm::vec4( 0,  1,  2, 3));
+	m = glm::column(m, 1, glm::vec4( 4,  5,  6, 7));
+	m = glm::column(m, 2, glm::vec4( 8,  9, 10, 11));
+
+	Error += glm::all(glm::equal(glm::column(m, 0), glm::vec4( 0,  1,  2, 3), glm::epsilon<float>())) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::column(m, 1), glm::vec4( 4,  5,  6, 7), glm::epsilon<float>())) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::column(m, 2), glm::vec4( 8,  9, 10, 11), glm::epsilon<float>())) ? 0 : 1;
+
+	return Error;
+}
+
+int test_mat4x2_row_set()
+{
+	int Error = 0;
+
+	glm::mat4x2 m(1);
+
+	m = glm::row(m, 0, glm::vec4( 0,  1,  2,  3));
+	m = glm::row(m, 1, glm::vec4( 4,  5,  6,  7));
+
+	Error += glm::all(glm::equal(glm::row(m, 0), glm::vec4( 0,  1,  2,  3), glm::epsilon<float>())) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::row(m, 1), glm::vec4( 4,  5,  6,  7), glm::epsilon<float>())) ? 0 : 1;
+
+	return Error;
+}
+
+int test_mat4x2_col_set()
+{
+	int Error = 0;
+
+	glm::mat4x2 m(1);
+
+	m = glm::column(m, 0, glm::vec2( 0,  1));
+	m = glm::column(m, 1, glm::vec2( 4,  5));
+	m = glm::column(m, 2, glm::vec2( 8,  9));
+	m = glm::column(m, 3, glm::vec2(12, 13));
+
+	Error += glm::all(glm::equal(glm::column(m, 0), glm::vec2( 0,  1), glm::epsilon<float>())) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::column(m, 1), glm::vec2( 4,  5), glm::epsilon<float>())) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::column(m, 2), glm::vec2( 8,  9), glm::epsilon<float>())) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::column(m, 3), glm::vec2(12, 13), glm::epsilon<float>())) ? 0 : 1;
+
+	return Error;
+}
+
+int test_mat4x3_row_set()
+{
+	int Error = 0;
+
+	glm::mat4x3 m(1);
+
+	m = glm::row(m, 0, glm::vec4( 0,  1,  2,  3));
+	m = glm::row(m, 1, glm::vec4( 4,  5,  6,  7));
+	m = glm::row(m, 2, glm::vec4( 8,  9, 10, 11));
+
+	Error += glm::all(glm::equal(glm::row(m, 0), glm::vec4( 0,  1,  2,  3), glm::epsilon<float>())) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::row(m, 1), glm::vec4( 4,  5,  6,  7), glm::epsilon<float>())) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::row(m, 2), glm::vec4( 8,  9, 10, 11), glm::epsilon<float>())) ? 0 : 1;
+
+	return Error;
+}
+
+int test_mat4x3_col_set()
+{
+	int Error = 0;
+
+	glm::mat4x3 m(1);
+
+	m = glm::column(m, 0, glm::vec3( 0,  1,  2));
+	m = glm::column(m, 1, glm::vec3( 4,  5,  6));
+	m = glm::column(m, 2, glm::vec3( 8,  9, 10));
+	m = glm::column(m, 3, glm::vec3(12, 13, 14));
+
+	Error += glm::all(glm::equal(glm::column(m, 0), glm::vec3( 0,  1,  2), glm::epsilon<float>())) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::column(m, 1), glm::vec3( 4,  5,  6), glm::epsilon<float>())) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::column(m, 2), glm::vec3( 8,  9, 10), glm::epsilon<float>())) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::column(m, 3), glm::vec3(12, 13, 14), glm::epsilon<float>())) ? 0 : 1;
+
+	return Error;
+}
+
+int test_mat4x4_row_set()
+{
+	int Error = 0;
+
+	glm::mat4 m(1);
+
+	m = glm::row(m, 0, glm::vec4( 0,  1,  2,  3));
+	m = glm::row(m, 1, glm::vec4( 4,  5,  6,  7));
+	m = glm::row(m, 2, glm::vec4( 8,  9, 10, 11));
+	m = glm::row(m, 3, glm::vec4(12, 13, 14, 15));
+
+	Error += glm::all(glm::equal(glm::row(m, 0), glm::vec4( 0,  1,  2,  3), glm::epsilon<float>())) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::row(m, 1), glm::vec4( 4,  5,  6,  7), glm::epsilon<float>())) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::row(m, 2), glm::vec4( 8,  9, 10, 11), glm::epsilon<float>())) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::row(m, 3), glm::vec4(12, 13, 14, 15), glm::epsilon<float>())) ? 0 : 1;
+
+	return Error;
+}
+
+int test_mat4x4_col_set()
+{
+	int Error = 0;
+
+	glm::mat4 m(1);
+
+	m = glm::column(m, 0, glm::vec4( 0,  1,  2,  3));
+	m = glm::column(m, 1, glm::vec4( 4,  5,  6,  7));
+	m = glm::column(m, 2, glm::vec4( 8,  9, 10, 11));
+	m = glm::column(m, 3, glm::vec4(12, 13, 14, 15));
+
+	Error += glm::all(glm::equal(glm::column(m, 0), glm::vec4( 0,  1,  2,  3), glm::epsilon<float>())) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::column(m, 1), glm::vec4( 4,  5,  6,  7), glm::epsilon<float>())) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::column(m, 2), glm::vec4( 8,  9, 10, 11), glm::epsilon<float>())) ? 0 : 1;
+	Error += glm::all(glm::equal(glm::column(m, 3), glm::vec4(12, 13, 14, 15), glm::epsilon<float>())) ? 0 : 1;
+
+	return Error;
+}
+
+int test_mat4x4_row_get()
+{
+	int Error = 0;
+
+	glm::mat4 m(1);
+
+	glm::vec4 A = glm::row(m, 0);
+	Error += glm::all(glm::equal(A, glm::vec4(1, 0, 0, 0), glm::epsilon<float>())) ? 0 : 1;
+	glm::vec4 B = glm::row(m, 1);
+	Error += glm::all(glm::equal(B, glm::vec4(0, 1, 0, 0), glm::epsilon<float>())) ? 0 : 1;
+	glm::vec4 C = glm::row(m, 2);
+	Error += glm::all(glm::equal(C, glm::vec4(0, 0, 1, 0), glm::epsilon<float>())) ? 0 : 1;
+	glm::vec4 D = glm::row(m, 3);
+	Error += glm::all(glm::equal(D, glm::vec4(0, 0, 0, 1), glm::epsilon<float>())) ? 0 : 1;
+
+	return Error;
+}
+
+int test_mat4x4_col_get()
+{
+	int Error = 0;
+
+	glm::mat4 m(1);
+
+	glm::vec4 A = glm::column(m, 0);
+	Error += glm::all(glm::equal(A, glm::vec4(1, 0, 0, 0), glm::epsilon<float>())) ? 0 : 1;
+	glm::vec4 B = glm::column(m, 1);
+	Error += glm::all(glm::equal(B, glm::vec4(0, 1, 0, 0), glm::epsilon<float>())) ? 0 : 1;
+	glm::vec4 C = glm::column(m, 2);
+	Error += glm::all(glm::equal(C, glm::vec4(0, 0, 1, 0), glm::epsilon<float>())) ? 0 : 1;
+	glm::vec4 D = glm::column(m, 3);
+	Error += glm::all(glm::equal(D, glm::vec4(0, 0, 0, 1), glm::epsilon<float>())) ? 0 : 1;
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_mat2x2_row_set();
+	Error += test_mat2x2_col_set();
+	Error += test_mat2x3_row_set();
+	Error += test_mat2x3_col_set();
+	Error += test_mat2x4_row_set();
+	Error += test_mat2x4_col_set();
+	Error += test_mat3x2_row_set();
+	Error += test_mat3x2_col_set();
+	Error += test_mat3x3_row_set();
+	Error += test_mat3x3_col_set();
+	Error += test_mat3x4_row_set();
+	Error += test_mat3x4_col_set();
+	Error += test_mat4x2_row_set();
+	Error += test_mat4x2_col_set();
+	Error += test_mat4x3_row_set();
+	Error += test_mat4x3_col_set();
+	Error += test_mat4x4_row_set();
+	Error += test_mat4x4_col_set();
+
+	Error += test_mat4x4_row_get();
+	Error += test_mat4x4_col_get();
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/gtc/gtc_matrix_integer.cpp b/3rdparty/glm/source/test/gtc/gtc_matrix_integer.cpp
new file mode 100644
index 0000000..108016a
--- /dev/null
+++ b/3rdparty/glm/source/test/gtc/gtc_matrix_integer.cpp
@@ -0,0 +1,8 @@
+#include <glm/gtc/matrix_integer.hpp>
+
+int main()
+{
+	int Error = 0;
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/gtc/gtc_matrix_inverse.cpp b/3rdparty/glm/source/test/gtc/gtc_matrix_inverse.cpp
new file mode 100644
index 0000000..eaec6e1
--- /dev/null
+++ b/3rdparty/glm/source/test/gtc/gtc_matrix_inverse.cpp
@@ -0,0 +1,51 @@
+#include <glm/gtc/matrix_inverse.hpp>
+#include <glm/gtc/epsilon.hpp>
+
+int test_affine()
+{
+	int Error = 0;
+
+	{
+		glm::mat3 const M(
+			2.f, 0.f, 0.f,
+			0.f, 2.f, 0.f,
+			0.f, 0.f, 1.f);
+		glm::mat3 const A = glm::affineInverse(M);
+		glm::mat3 const I = glm::inverse(M);
+		glm::mat3 const R = glm::affineInverse(A);
+
+		for(glm::length_t i = 0; i < A.length(); ++i)
+		{
+			Error += glm::all(glm::epsilonEqual(M[i], R[i], 0.01f)) ? 0 : 1;
+			Error += glm::all(glm::epsilonEqual(A[i], I[i], 0.01f)) ? 0 : 1;
+		}
+	}
+
+	{
+		glm::mat4 const M(
+			2.f, 0.f, 0.f, 0.f,
+			0.f, 2.f, 0.f, 0.f,
+			0.f, 0.f, 2.f, 0.f,
+			0.f, 0.f, 0.f, 1.f);
+		glm::mat4 const A = glm::affineInverse(M);
+		glm::mat4 const I = glm::inverse(M);
+		glm::mat4 const R = glm::affineInverse(A);
+
+		for(glm::length_t i = 0; i < A.length(); ++i)
+		{
+			Error += glm::all(glm::epsilonEqual(M[i], R[i], 0.01f)) ? 0 : 1;
+			Error += glm::all(glm::epsilonEqual(A[i], I[i], 0.01f)) ? 0 : 1;
+		}
+	}
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_affine();
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/gtc/gtc_matrix_transform.cpp b/3rdparty/glm/source/test/gtc/gtc_matrix_transform.cpp
new file mode 100644
index 0000000..b50666e
--- /dev/null
+++ b/3rdparty/glm/source/test/gtc/gtc_matrix_transform.cpp
@@ -0,0 +1,55 @@
+#include <glm/gtc/matrix_transform.hpp>
+#include <glm/gtc/constants.hpp>
+#include <glm/ext/matrix_relational.hpp>
+
+int test_perspective()
+{
+	int Error = 0;
+
+	glm::mat4 Projection = glm::perspective(glm::pi<float>() * 0.25f, 4.0f / 3.0f, 0.1f, 100.0f);
+
+	return Error;
+}
+
+int test_pick()
+{
+	int Error = 0;
+
+	glm::mat4 Pick = glm::pickMatrix(glm::vec2(1, 2), glm::vec2(3, 4), glm::ivec4(0, 0, 320, 240));
+
+	return Error;
+}
+
+int test_tweakedInfinitePerspective()
+{
+	int Error = 0;
+
+	glm::mat4 ProjectionA = glm::tweakedInfinitePerspective(45.f, 640.f/480.f, 1.0f);
+	glm::mat4 ProjectionB = glm::tweakedInfinitePerspective(45.f, 640.f/480.f, 1.0f, 0.001f);
+
+
+	return Error;
+}
+
+int test_translate()
+{
+	int Error = 0;
+
+	glm::lowp_vec3 v(1.0);
+	glm::lowp_mat4 m(0);
+	glm::lowp_mat4 t = glm::translate(m, v);
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_translate();
+	Error += test_tweakedInfinitePerspective();
+	Error += test_pick();
+	Error += test_perspective();
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/gtc/gtc_noise.cpp b/3rdparty/glm/source/test/gtc/gtc_noise.cpp
new file mode 100644
index 0000000..6ecec22
--- /dev/null
+++ b/3rdparty/glm/source/test/gtc/gtc_noise.cpp
@@ -0,0 +1,86 @@
+#define GLM_ENABLE_EXPERIMENTAL
+#include <glm/gtc/noise.hpp>
+#include <glm/gtc/type_precision.hpp>
+#include <glm/gtx/raw_data.hpp>
+
+static int test_simplex_float()
+{
+	int Error = 0;
+
+	glm::u8vec4 const PixelSimplex2D(glm::byte(glm::abs(glm::simplex(glm::vec2(0.f, 0.f))) * 255.f));
+	glm::u8vec4 const PixelSimplex3D(glm::byte(glm::abs(glm::simplex(glm::vec3(0.f, 0.f, 0.f))) * 255.f));
+	glm::u8vec4 const PixelSimplex4D(glm::byte(glm::abs(glm::simplex(glm::vec4(0.f, 0.f, 0.f, 0.f))) * 255.f));
+
+	return Error;
+}
+
+static int test_simplex_double()
+{
+	int Error = 0;
+
+	glm::u8vec4 const PixelSimplex2D(glm::byte(glm::abs(glm::simplex(glm::dvec2(0.f, 0.f))) * 255.));
+	glm::u8vec4 const PixelSimplex3D(glm::byte(glm::abs(glm::simplex(glm::dvec3(0.f, 0.f, 0.f))) * 255.));
+	glm::u8vec4 const PixelSimplex4D(glm::byte(glm::abs(glm::simplex(glm::dvec4(0.f, 0.f, 0.f, 0.f))) * 255.));
+
+	return Error;
+}
+
+static int test_perlin_float()
+{
+	int Error = 0;
+
+	glm::u8vec4 const PixelPerlin2D(glm::byte(glm::abs(glm::perlin(glm::vec2(0.f, 0.f))) * 255.f));
+	glm::u8vec4 const PixelPerlin3D(glm::byte(glm::abs(glm::perlin(glm::vec3(0.f, 0.f, 0.f))) * 255.f));
+	glm::u8vec4 const PixelPerlin4D(glm::byte(glm::abs(glm::perlin(glm::vec4(0.f, 0.f, 0.f, 0.f))) * 255.f));
+
+	return Error;
+}
+
+static int test_perlin_double()
+{
+	int Error = 0;
+
+	glm::u8vec4 const PixelPerlin2D(glm::byte(glm::abs(glm::perlin(glm::dvec2(0.f, 0.f))) * 255.));
+	glm::u8vec4 const PixelPerlin3D(glm::byte(glm::abs(glm::perlin(glm::dvec3(0.f, 0.f, 0.f))) * 255.));
+	glm::u8vec4 const PixelPerlin4D(glm::byte(glm::abs(glm::perlin(glm::dvec4(0.f, 0.f, 0.f, 0.f))) * 255.));
+
+	return Error;
+}
+
+static int test_perlin_pedioric_float()
+{
+	int Error = 0;
+
+	glm::u8vec4 const PixelPeriodic2D(glm::byte(glm::abs(glm::perlin(glm::vec2(0.f, 0.f), glm::vec2(2.0f))) * 255.f));
+	glm::u8vec4 const PixelPeriodic3D(glm::byte(glm::abs(glm::perlin(glm::vec3(0.f, 0.f, 0.f), glm::vec3(2.0f))) * 255.f));
+	glm::u8vec4 const PixelPeriodic4D(glm::byte(glm::abs(glm::perlin(glm::vec4(0.f, 0.f, 0.f, 0.f), glm::vec4(2.0f))) * 255.f));
+
+	return Error;
+}
+
+static int test_perlin_pedioric_double()
+{
+	int Error = 0;
+
+	glm::u8vec4 const PixelPeriodic2D(glm::byte(glm::abs(glm::perlin(glm::dvec2(0.f, 0.f), glm::dvec2(2.0))) * 255.));
+	glm::u8vec4 const PixelPeriodic3D(glm::byte(glm::abs(glm::perlin(glm::dvec3(0.f, 0.f, 0.f), glm::dvec3(2.0))) * 255.));
+	glm::u8vec4 const PixelPeriodic4D(glm::byte(glm::abs(glm::perlin(glm::dvec4(0.f, 0.f, 0.f, 0.f), glm::dvec4(2.0))) * 255.));
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_simplex_float();
+	Error += test_simplex_double();
+
+	Error += test_perlin_float();
+	Error += test_perlin_double();
+
+	Error += test_perlin_pedioric_float();
+	Error += test_perlin_pedioric_double();
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/gtc/gtc_packing.cpp b/3rdparty/glm/source/test/gtc/gtc_packing.cpp
new file mode 100644
index 0000000..df5b3bb
--- /dev/null
+++ b/3rdparty/glm/source/test/gtc/gtc_packing.cpp
@@ -0,0 +1,878 @@
+#include <glm/packing.hpp>
+#include <glm/gtc/packing.hpp>
+#include <glm/gtc/epsilon.hpp>
+#include <glm/ext/vector_relational.hpp>
+#include <cstdio>
+#include <vector>
+
+void print_bits(float const& s)
+{
+	union
+	{
+		float f;
+		unsigned int i;
+	} uif;
+
+	uif.f = s;
+
+	std::printf("f32: ");
+	for(std::size_t j = sizeof(s) * 8; j > 0; --j)
+	{
+		if(j == 23 || j == 31)
+			std::printf(" ");
+		std::printf("%d", (uif.i & (1 << (j - 1))) ? 1 : 0);
+	}
+}
+
+void print_10bits(glm::uint const& s)
+{
+	std::printf("10b: ");
+	for(std::size_t j = 10; j > 0; --j)
+	{
+		if(j == 5)
+			std::printf(" ");
+		std::printf("%d", (s & (1 << (j - 1))) ? 1 : 0);
+	}
+}
+
+void print_11bits(glm::uint const& s)
+{
+	std::printf("11b: ");
+	for(std::size_t j = 11; j > 0; --j)
+	{
+		if(j == 6)
+			std::printf(" ");
+		std::printf("%d", (s & (1 << (j - 1))) ? 1 : 0);
+	}
+}
+
+void print_value(float const& s)
+{
+	std::printf("%2.5f, ", static_cast<double>(s));
+	print_bits(s);
+	std::printf(", ");
+//	print_11bits(detail::floatTo11bit(s));
+//	std::printf(", ");
+//	print_10bits(detail::floatTo10bit(s));
+	std::printf("\n");
+}
+
+int test_Half1x16()
+{
+	int Error = 0;
+
+	std::vector<float> Tests;
+	Tests.push_back(0.0f);
+	Tests.push_back(1.0f);
+	Tests.push_back(-1.0f);
+	Tests.push_back(2.0f);
+	Tests.push_back(-2.0f);
+	Tests.push_back(1.9f);
+
+	for(std::size_t i = 0; i < Tests.size(); ++i)
+	{
+		glm::uint16 p0 = glm::packHalf1x16(Tests[i]);
+		float v0 = glm::unpackHalf1x16(p0);
+		glm::uint16 p1 = glm::packHalf1x16(v0);
+		float v1 = glm::unpackHalf1x16(p1);
+		Error += glm::epsilonEqual(v0, v1, glm::epsilon<float>()) ? 0 : 1;
+	}
+
+	return Error;
+}
+
+int test_Half4x16()
+{
+	int Error = 0;
+
+	std::vector<glm::vec4> Tests;
+	Tests.push_back(glm::vec4(1.0f));
+	Tests.push_back(glm::vec4(0.0f));
+	Tests.push_back(glm::vec4(2.0f));
+	Tests.push_back(glm::vec4(0.1f));
+	Tests.push_back(glm::vec4(0.5f));
+	Tests.push_back(glm::vec4(-0.9f));
+
+	for(std::size_t i = 0; i < Tests.size(); ++i)
+	{
+		glm::uint64 p0 = glm::packHalf4x16(Tests[i]);
+		glm::vec4 v0 = glm::unpackHalf4x16(p0);
+		glm::uint64 p1 = glm::packHalf4x16(v0);
+		glm::vec4 v1 = glm::unpackHalf4x16(p1);
+		glm::u16vec4 p2 = glm::packHalf(v0);
+		glm::vec4 v2 = glm::unpackHalf(p2);
+
+		Error += glm::all(glm::equal(v0, v1, glm::epsilon<float>())) ? 0 : 1;
+		Error += glm::all(glm::equal(v0, v2, glm::epsilon<float>())) ? 0 : 1;
+	}
+
+	return Error;
+}
+
+int test_I3x10_1x2()
+{
+	int Error = 0;
+
+	std::vector<glm::ivec4> Tests;
+	Tests.push_back(glm::ivec4(0));
+	Tests.push_back(glm::ivec4(1));
+	Tests.push_back(glm::ivec4(-1));
+	Tests.push_back(glm::ivec4(2));
+	Tests.push_back(glm::ivec4(-2));
+	Tests.push_back(glm::ivec4(3));
+
+	for(std::size_t i = 0; i < Tests.size(); ++i)
+	{
+		glm::uint32 p0 = glm::packI3x10_1x2(Tests[i]);
+		glm::ivec4 v0 = glm::unpackI3x10_1x2(p0);
+		glm::uint32 p1 = glm::packI3x10_1x2(v0);
+		glm::ivec4 v1 = glm::unpackI3x10_1x2(p1);
+		Error += glm::all(glm::equal(v0, v1)) ? 0 : 1;
+	}
+
+	return Error;
+}
+
+int test_U3x10_1x2()
+{
+	int Error = 0;
+
+	std::vector<glm::uvec4> Tests;
+	Tests.push_back(glm::uvec4(0));
+	Tests.push_back(glm::uvec4(1));
+	Tests.push_back(glm::uvec4(2));
+	Tests.push_back(glm::uvec4(3));
+	Tests.push_back(glm::uvec4(4));
+	Tests.push_back(glm::uvec4(5));
+
+	for(std::size_t i = 0; i < Tests.size(); ++i)
+	{
+		glm::uint32 p0 = glm::packU3x10_1x2(Tests[i]);
+		glm::uvec4 v0 = glm::unpackU3x10_1x2(p0);
+		glm::uint32 p1 = glm::packU3x10_1x2(v0);
+		glm::uvec4 v1 = glm::unpackU3x10_1x2(p1);
+		Error += glm::all(glm::equal(v0, v1)) ? 0 : 1;
+	}
+
+	glm::u8vec4 const v0(0xff, 0x77, 0x0, 0x33);
+	glm::uint32 const p0 = *reinterpret_cast<glm::uint32 const*>(&v0[0]);
+	glm::uint32 const r0 = 0x330077ff;
+
+	Error += p0 == r0 ? 0 : 1;
+
+	glm::uvec4 const v1(0xff, 0x77, 0x0, 0x33);
+	glm::uint32 const p1 = glm::packU3x10_1x2(v1);
+	glm::uint32 const r1 = 0xc001dcff;
+
+	Error += p1 == r1 ? 0 : 1;
+
+	return Error;
+}
+
+int test_Snorm3x10_1x2()
+{
+	int Error = 0;
+
+	std::vector<glm::vec4> Tests;
+	Tests.push_back(glm::vec4(1.0f));
+	Tests.push_back(glm::vec4(0.0f));
+	Tests.push_back(glm::vec4(2.0f));
+	Tests.push_back(glm::vec4(0.1f));
+	Tests.push_back(glm::vec4(0.5f));
+	Tests.push_back(glm::vec4(0.9f));
+
+	for(std::size_t i = 0; i < Tests.size(); ++i)
+	{
+		glm::uint32 p0 = glm::packSnorm3x10_1x2(Tests[i]);
+		glm::vec4 v0 = glm::unpackSnorm3x10_1x2(p0);
+		glm::uint32 p1 = glm::packSnorm3x10_1x2(v0);
+		glm::vec4 v1 = glm::unpackSnorm3x10_1x2(p1);
+
+		Error += glm::all(glm::epsilonEqual(v0, v1, 0.01f)) ? 0 : 1;
+	}
+
+	return Error;
+}
+
+int test_Unorm3x10_1x2()
+{
+	int Error = 0;
+
+	std::vector<glm::vec4> Tests;
+	Tests.push_back(glm::vec4(1.0f));
+	Tests.push_back(glm::vec4(0.0f));
+	Tests.push_back(glm::vec4(2.0f));
+	Tests.push_back(glm::vec4(0.1f));
+	Tests.push_back(glm::vec4(0.5f));
+	Tests.push_back(glm::vec4(0.9f));
+
+	for(std::size_t i = 0; i < Tests.size(); ++i)
+	{
+		glm::uint32 p0 = glm::packUnorm3x10_1x2(Tests[i]);
+		glm::vec4 v0 = glm::unpackUnorm3x10_1x2(p0);
+		glm::uint32 p1 = glm::packUnorm3x10_1x2(v0);
+		glm::vec4 v1 = glm::unpackUnorm3x10_1x2(p1);
+
+		Error += glm::all(glm::epsilonEqual(v0, v1, 0.001f)) ? 0 : 1;
+	}
+
+	return Error;
+}
+
+int test_F2x11_1x10()
+{
+	int Error = 0;
+
+	std::vector<glm::vec3> Tests;
+	Tests.push_back(glm::vec3(1.0f));
+	Tests.push_back(glm::vec3(0.0f));
+	Tests.push_back(glm::vec3(2.0f));
+	Tests.push_back(glm::vec3(0.1f));
+	Tests.push_back(glm::vec3(0.5f));
+	Tests.push_back(glm::vec3(0.9f));
+
+	for(std::size_t i = 0; i < Tests.size(); ++i)
+	{
+		glm::uint32 p0 = glm::packF2x11_1x10(Tests[i]);
+		glm::vec3 v0 = glm::unpackF2x11_1x10(p0);
+		glm::uint32 p1 = glm::packF2x11_1x10(v0);
+		glm::vec3 v1 = glm::unpackF2x11_1x10(p1);
+		Error += glm::all(glm::equal(v0, v1, glm::epsilon<float>())) ? 0 : 1;
+	}
+
+	return Error;
+}
+
+int test_F3x9_E1x5()
+{
+	int Error = 0;
+
+	std::vector<glm::vec3> Tests;
+	Tests.push_back(glm::vec3(1.0f));
+	Tests.push_back(glm::vec3(0.0f));
+	Tests.push_back(glm::vec3(2.0f));
+	Tests.push_back(glm::vec3(0.1f));
+	Tests.push_back(glm::vec3(0.5f));
+	Tests.push_back(glm::vec3(0.9f));
+
+	for(std::size_t i = 0; i < Tests.size(); ++i)
+	{
+		glm::uint32 p0 = glm::packF3x9_E1x5(Tests[i]);
+		glm::vec3 v0 = glm::unpackF3x9_E1x5(p0);
+		glm::uint32 p1 = glm::packF3x9_E1x5(v0);
+		glm::vec3 v1 = glm::unpackF3x9_E1x5(p1);
+		Error += glm::all(glm::equal(v0, v1, glm::epsilon<float>())) ? 0 : 1;
+	}
+
+	return Error;
+}
+
+int test_RGBM()
+{
+	int Error = 0;
+
+	for(std::size_t i = 0; i < 1024; ++i)
+	{
+		glm::vec3 const Color(static_cast<float>(i));
+		glm::vec4 const RGBM = glm::packRGBM(Color);
+		glm::vec3 const Result= glm::unpackRGBM(RGBM);
+
+		Error += glm::all(glm::equal(Color, Result, 0.01f)) ? 0 : 1;
+	}
+
+	return Error;
+}
+
+int test_packUnorm1x16()
+{
+	int Error = 0;
+
+	std::vector<glm::vec1> A;
+	A.push_back(glm::vec1(1.0f));
+	A.push_back(glm::vec1(0.5f));
+	A.push_back(glm::vec1(0.1f));
+	A.push_back(glm::vec1(0.0f));
+
+	for(std::size_t i = 0; i < A.size(); ++i)
+	{
+		glm::vec1 B(A[i]);
+		glm::uint16 C = glm::packUnorm1x16(B.x);
+		glm::vec1 D(glm::unpackUnorm1x16(C));
+		Error += glm::all(glm::epsilonEqual(B, D, 1.0f / 65535.f)) ? 0 : 1;
+		assert(!Error);
+	}
+	
+	return Error;
+}
+
+int test_packSnorm1x16()
+{
+	int Error = 0;
+
+	std::vector<glm::vec1> A;
+	A.push_back(glm::vec1( 1.0f));
+	A.push_back(glm::vec1( 0.0f));
+	A.push_back(glm::vec1(-0.5f));
+	A.push_back(glm::vec1(-0.1f));
+
+	for(std::size_t i = 0; i < A.size(); ++i)
+	{
+		glm::vec1 B(A[i]);
+		glm::uint16 C = glm::packSnorm1x16(B.x);
+		glm::vec1 D(glm::unpackSnorm1x16(C));
+		Error += glm::all(glm::epsilonEqual(B, D, 1.0f / 32767.0f * 2.0f)) ? 0 : 1;
+	}
+	
+	return Error;
+}
+
+int test_packUnorm2x16()
+{
+	int Error = 0;
+
+	std::vector<glm::vec2> A;
+	A.push_back(glm::vec2(1.0f, 0.0f));
+	A.push_back(glm::vec2(0.5f, 0.7f));
+	A.push_back(glm::vec2(0.1f, 0.2f));
+
+	for(std::size_t i = 0; i < A.size(); ++i)
+	{
+		glm::vec2 B(A[i]);
+		glm::uint32 C = glm::packUnorm2x16(B);
+		glm::vec2 D = glm::unpackUnorm2x16(C);
+		Error += glm::all(glm::epsilonEqual(B, D, 1.0f / 65535.f)) ? 0 : 1;
+		assert(!Error);
+	}
+	
+	return Error;
+}
+
+int test_packSnorm2x16()
+{
+	int Error = 0;
+
+	std::vector<glm::vec2> A;
+	A.push_back(glm::vec2( 1.0f, 0.0f));
+	A.push_back(glm::vec2(-0.5f,-0.7f));
+	A.push_back(glm::vec2(-0.1f, 0.1f));
+
+	for(std::size_t i = 0; i < A.size(); ++i)
+	{
+		glm::vec2 B(A[i]);
+		glm::uint32 C = glm::packSnorm2x16(B);
+		glm::vec2 D = glm::unpackSnorm2x16(C);
+		Error += glm::all(glm::epsilonEqual(B, D, 1.0f / 32767.0f * 2.0f)) ? 0 : 1;
+		assert(!Error);
+	}
+	
+	return Error;
+}
+
+int test_packUnorm4x16()
+{
+	int Error = 0;
+
+	std::vector<glm::vec4> A;
+	A.push_back(glm::vec4(1.0f));
+	A.push_back(glm::vec4(0.5f));
+	A.push_back(glm::vec4(0.1f));
+	A.push_back(glm::vec4(0.0f));
+
+	for(std::size_t i = 0; i < A.size(); ++i)
+	{
+		glm::vec4 B(A[i]);
+		glm::uint64 C = glm::packUnorm4x16(B);
+		glm::vec4 D(glm::unpackUnorm4x16(C));
+		Error += glm::all(glm::epsilonEqual(B, D, 1.0f / 65535.f)) ? 0 : 1;
+		assert(!Error);
+	}
+	
+	return Error;
+}
+
+int test_packSnorm4x16()
+{
+	int Error = 0;
+
+	std::vector<glm::vec4> A;
+	A.push_back(glm::vec4( 1.0f, 0.0f, -0.5f, 0.5f));
+	A.push_back(glm::vec4(-0.3f,-0.7f,  0.3f, 0.7f));
+	A.push_back(glm::vec4(-0.1f, 0.1f, -0.2f, 0.2f));
+
+	for(std::size_t i = 0; i < A.size(); ++i)
+	{
+		glm::vec4 B(A[i]);
+		glm::uint64 C = glm::packSnorm4x16(B);
+		glm::vec4 D(glm::unpackSnorm4x16(C));
+		Error += glm::all(glm::epsilonEqual(B, D, 1.0f / 32767.0f * 2.0f)) ? 0 : 1;
+		assert(!Error);
+	}
+	
+	return Error;
+}
+
+int test_packUnorm1x8()
+{
+	int Error = 0;
+	
+	std::vector<glm::vec1> A;
+	A.push_back(glm::vec1(1.0f));
+	A.push_back(glm::vec1(0.5f));
+	A.push_back(glm::vec1(0.0f));
+	
+	for(std::size_t i = 0; i < A.size(); ++i)
+	{
+		glm::vec1 B(A[i]);
+		glm::uint8 C = glm::packUnorm1x8(B.x);
+		glm::vec1 D(glm::unpackUnorm1x8(C));
+		Error += glm::all(glm::epsilonEqual(B, D, 1.0f / 255.f)) ? 0 : 1;
+		assert(!Error);
+	}
+	
+	return Error;
+}
+
+int test_packSnorm1x8()
+{
+	int Error = 0;
+	
+	std::vector<glm::vec1> A;
+	A.push_back(glm::vec1( 1.0f));
+	A.push_back(glm::vec1(-0.7f));
+	A.push_back(glm::vec1(-1.0f));
+	
+	for(std::size_t i = 0; i < A.size(); ++i)
+	{
+		glm::vec1 B(A[i]);
+		glm::uint8 C = glm::packSnorm1x8(B.x);
+		glm::vec1 D(glm::unpackSnorm1x8(C));
+		Error += glm::all(glm::epsilonEqual(B, D, 1.0f / 127.f)) ? 0 : 1;
+	}
+	
+	return Error;
+}
+
+int test_packUnorm2x8()
+{
+	int Error = 0;
+	
+	std::vector<glm::vec2> A;
+	A.push_back(glm::vec2(1.0f, 0.7f));
+	A.push_back(glm::vec2(0.5f, 0.1f));
+	
+	for(std::size_t i = 0; i < A.size(); ++i)
+	{
+		glm::vec2 B(A[i]);
+		glm::uint16 C = glm::packUnorm2x8(B);
+		glm::vec2 D = glm::unpackUnorm2x8(C);
+		Error += glm::all(glm::epsilonEqual(B, D, 1.0f / 255.f)) ? 0 : 1;
+		assert(!Error);
+	}
+	
+	return Error;
+}
+
+int test_packSnorm2x8()
+{
+	int Error = 0;
+	
+	std::vector<glm::vec2> A;
+	A.push_back(glm::vec2( 1.0f, 0.0f));
+	A.push_back(glm::vec2(-0.7f,-0.1f));
+	
+	for(std::size_t i = 0; i < A.size(); ++i)
+	{
+		glm::vec2 B(A[i]);
+		glm::uint16 C = glm::packSnorm2x8(B);
+		glm::vec2 D = glm::unpackSnorm2x8(C);
+		Error += glm::all(glm::epsilonEqual(B, D, 1.0f / 127.f)) ? 0 : 1;
+	}
+	
+	return Error;
+}
+
+int test_packUnorm4x8()
+{
+	int Error = 0;
+	
+	std::vector<glm::vec4> A;
+	A.push_back(glm::vec4(1.0f, 0.7f, 0.3f, 0.0f));
+	A.push_back(glm::vec4(0.5f, 0.1f, 0.2f, 0.3f));
+	
+	for(std::size_t i = 0; i < A.size(); ++i)
+	{
+		glm::vec4 B(A[i]);
+		glm::uint32 C = glm::packUnorm4x8(B);
+		glm::vec4 D = glm::unpackUnorm4x8(C);
+		Error += glm::all(glm::epsilonEqual(B, D, 1.0f / 255.f)) ? 0 : 1;
+		assert(!Error);
+	}
+	
+	return Error;
+}
+
+int test_packSnorm4x8()
+{
+	int Error = 0;
+	
+	std::vector<glm::vec4> A;
+	A.push_back(glm::vec4( 1.0f, 0.0f,-0.5f,-1.0f));
+	A.push_back(glm::vec4(-0.7f,-0.1f, 0.1f, 0.7f));
+	
+	for(std::size_t i = 0; i < A.size(); ++i)
+	{
+		glm::vec4 B(A[i]);
+		glm::uint32 C = glm::packSnorm4x8(B);
+		glm::vec4 D = glm::unpackSnorm4x8(C);
+		Error += glm::all(glm::epsilonEqual(B, D, 1.0f / 127.f)) ? 0 : 1;
+		assert(!Error);
+	}
+	
+	return Error;
+}
+
+int test_packUnorm()
+{
+	int Error = 0;
+
+	std::vector<glm::vec2> A;
+	A.push_back(glm::vec2(1.0f, 0.7f));
+	A.push_back(glm::vec2(0.5f, 0.1f));
+
+	for(std::size_t i = 0; i < A.size(); ++i)
+	{
+		glm::vec2 B(A[i]);
+		glm::u16vec2 C = glm::packUnorm<glm::uint16>(B);
+		glm::vec2 D = glm::unpackUnorm<float>(C);
+		Error += glm::all(glm::epsilonEqual(B, D, 1.0f / 255.f)) ? 0 : 1;
+		assert(!Error);
+	}
+
+	return Error;
+}
+
+int test_packSnorm()
+{
+	int Error = 0;
+
+	std::vector<glm::vec2> A;
+	A.push_back(glm::vec2( 1.0f, 0.0f));
+	A.push_back(glm::vec2(-0.5f,-0.7f));
+	A.push_back(glm::vec2(-0.1f, 0.1f));
+
+	for(std::size_t i = 0; i < A.size(); ++i)
+	{
+		glm::vec2 B(A[i]);
+		glm::i16vec2 C = glm::packSnorm<glm::int16>(B);
+		glm::vec2 D = glm::unpackSnorm<float>(C);
+		Error += glm::all(glm::epsilonEqual(B, D, 1.0f / 32767.0f * 2.0f)) ? 0 : 1;
+		assert(!Error);
+	}
+
+	return Error;
+}
+
+int test_packUnorm2x4()
+{
+	int Error = 0;
+
+	std::vector<glm::vec2> A;
+	A.push_back(glm::vec2(1.0f, 0.7f));
+	A.push_back(glm::vec2(0.5f, 0.0f));
+
+	for(std::size_t i = 0; i < A.size(); ++i)
+	{
+		glm::vec2 B(A[i]);
+		glm::uint8 C = glm::packUnorm2x4(B);
+		glm::vec2 D = glm::unpackUnorm2x4(C);
+		Error += glm::all(glm::epsilonEqual(B, D, 1.0f / 15.f)) ? 0 : 1;
+		assert(!Error);
+	}
+
+	return Error;
+}
+
+int test_packUnorm4x4()
+{
+	int Error = 0;
+
+	std::vector<glm::vec4> A;
+	A.push_back(glm::vec4(1.0f, 0.7f, 0.5f, 0.0f));
+	A.push_back(glm::vec4(0.5f, 0.1f, 0.0f, 1.0f));
+
+	for(std::size_t i = 0; i < A.size(); ++i)
+	{
+		glm::vec4 B(A[i]);
+		glm::uint16 C = glm::packUnorm4x4(B);
+		glm::vec4 D = glm::unpackUnorm4x4(C);
+		Error += glm::all(glm::epsilonEqual(B, D, 1.0f / 15.f)) ? 0 : 1;
+		assert(!Error);
+	}
+
+	return Error;
+}
+
+int test_packUnorm3x5_1x1()
+{
+	int Error = 0;
+
+	std::vector<glm::vec4> A;
+	A.push_back(glm::vec4(1.0f, 0.7f, 0.5f, 0.0f));
+	A.push_back(glm::vec4(0.5f, 0.1f, 0.0f, 1.0f));
+
+	for(std::size_t i = 0; i < A.size(); ++i)
+	{
+		glm::vec4 B(A[i]);
+		glm::uint16 C = glm::packUnorm3x5_1x1(B);
+		glm::vec4 D = glm::unpackUnorm3x5_1x1(C);
+		Error += glm::all(glm::epsilonEqual(B, D, 1.0f / 15.f)) ? 0 : 1;
+		assert(!Error);
+	}
+
+	return Error;
+}
+
+int test_packUnorm1x5_1x6_1x5()
+{
+	int Error = 0;
+
+	std::vector<glm::vec3> A;
+	A.push_back(glm::vec3(1.0f, 0.7f, 0.5f));
+	A.push_back(glm::vec3(0.5f, 0.1f, 0.0f));
+
+	for(std::size_t i = 0; i < A.size(); ++i)
+	{
+		glm::vec3 B(A[i]);
+		glm::uint16 C = glm::packUnorm1x5_1x6_1x5(B);
+		glm::vec3 D = glm::unpackUnorm1x5_1x6_1x5(C);
+		Error += glm::all(glm::epsilonEqual(B, D, 1.0f / 15.f)) ? 0 : 1;
+		assert(!Error);
+	}
+
+	return Error;
+}
+
+int test_packUnorm2x3_1x2()
+{
+	int Error = 0;
+
+	std::vector<glm::vec3> A;
+	A.push_back(glm::vec3(1.0f, 0.7f, 0.5f));
+	A.push_back(glm::vec3(0.5f, 0.1f, 0.0f));
+
+	for(std::size_t i = 0; i < A.size(); ++i)
+	{
+		glm::vec3 B(A[i]);
+		glm::uint8 C = glm::packUnorm2x3_1x2(B);
+		glm::vec3 D = glm::unpackUnorm2x3_1x2(C);
+		Error += glm::all(glm::epsilonEqual(B, D, 1.0f / 3.f)) ? 0 : 1;
+		assert(!Error);
+	}
+
+	return Error;
+}
+
+int test_packUint2x8()
+{
+	int Error = 0;
+
+	glm::u8vec2 const Source(1, 2);
+
+	glm::uint16 const Packed = glm::packUint2x8(Source);
+	Error += Packed != 0 ? 0 : 1;
+
+	glm::u8vec2 const Unpacked = glm::unpackUint2x8(Packed);
+	Error += Source == Unpacked ? 0 : 1;
+
+	return Error;
+}
+
+int test_packUint4x8()
+{
+	int Error = 0;
+
+	glm::u8vec4 const Source(1, 2, 3, 4);
+
+	glm::uint32 const Packed = glm::packUint4x8(Source);
+	Error += Packed != 0 ? 0 : 1;
+
+	glm::u8vec4 const Unpacked = glm::unpackUint4x8(Packed);
+	Error += Source == Unpacked ? 0 : 1;
+
+	return Error;
+}
+
+int test_packUint2x16()
+{
+	int Error = 0;
+
+	glm::u16vec2 const Source(1, 2);
+
+	glm::uint32 const Packed = glm::packUint2x16(Source);
+	Error += Packed != 0 ? 0 : 1;
+
+	glm::u16vec2 const Unpacked = glm::unpackUint2x16(Packed);
+	Error += Source == Unpacked ? 0 : 1;
+
+	return Error;
+}
+
+int test_packUint4x16()
+{
+	int Error = 0;
+
+	glm::u16vec4 const Source(1, 2, 3, 4);
+
+	glm::uint64 const Packed = glm::packUint4x16(Source);
+	Error += Packed != 0 ? 0 : 1;
+
+	glm::u16vec4 const Unpacked = glm::unpackUint4x16(Packed);
+	Error += Source == Unpacked ? 0 : 1;
+
+	return Error;
+}
+
+int test_packUint2x32()
+{
+	int Error = 0;
+
+	glm::u32vec2 const Source(1, 2);
+
+	glm::uint64 const Packed = glm::packUint2x32(Source);
+	Error += Packed != 0 ? 0 : 1;
+
+	glm::u32vec2 const Unpacked = glm::unpackUint2x32(Packed);
+	Error += Source == Unpacked ? 0 : 1;
+
+	return Error;
+}
+
+int test_packInt2x8()
+{
+	int Error = 0;
+
+	glm::i8vec2 const Source(1, 2);
+
+	glm::int16 const Packed = glm::packInt2x8(Source);
+	Error += Packed != 0 ? 0 : 1;
+
+	glm::i8vec2 const Unpacked = glm::unpackInt2x8(Packed);
+	Error += Source == Unpacked ? 0 : 1;
+
+	return Error;
+}
+
+int test_packInt4x8()
+{
+	int Error = 0;
+
+	glm::i8vec4 const Source(1, 2, 3, 4);
+
+	glm::int32 const Packed = glm::packInt4x8(Source);
+	Error += Packed != 0 ? 0 : 1;
+
+	glm::i8vec4 const Unpacked = glm::unpackInt4x8(Packed);
+	Error += Source == Unpacked ? 0 : 1;
+
+	return Error;
+}
+
+int test_packInt2x16()
+{
+	int Error = 0;
+
+	glm::i16vec2 const Source(1, 2);
+
+	glm::int32 const Packed = glm::packInt2x16(Source);
+	Error += Packed != 0 ? 0 : 1;
+
+	glm::i16vec2 const Unpacked = glm::unpackInt2x16(Packed);
+	Error += Source == Unpacked ? 0 : 1;
+
+	return Error;
+}
+
+int test_packInt4x16()
+{
+	int Error = 0;
+
+	glm::i16vec4 const Source(1, 2, 3, 4);
+
+	glm::int64 const Packed = glm::packInt4x16(Source);
+	Error += Packed != 0 ? 0 : 1;
+
+	glm::i16vec4 const Unpacked = glm::unpackInt4x16(Packed);
+	Error += Source == Unpacked ? 0 : 1;
+
+	return Error;
+}
+
+int test_packInt2x32()
+{
+	int Error = 0;
+
+	glm::i32vec2 const Source(1, 2);
+
+	glm::int64 const Packed = glm::packInt2x32(Source);
+	Error += Packed != 0 ? 0 : 1;
+
+	glm::i32vec2 const Unpacked = glm::unpackInt2x32(Packed);
+	Error += Source == Unpacked ? 0 : 1;
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_packUnorm();
+	Error += test_packSnorm();
+
+	Error += test_packSnorm1x16();
+	Error += test_packSnorm2x16();
+	Error += test_packSnorm4x16();
+
+	Error += test_packSnorm1x8();
+	Error += test_packSnorm2x8();
+	Error += test_packSnorm4x8();
+
+	Error += test_packUnorm1x16();
+	Error += test_packUnorm2x16();
+	Error += test_packUnorm4x16();
+
+	Error += test_packUnorm1x8();
+	Error += test_packUnorm2x8();
+	Error += test_packUnorm4x8();
+
+	Error += test_packUnorm2x4();
+	Error += test_packUnorm4x4();
+	Error += test_packUnorm3x5_1x1();
+	Error += test_packUnorm1x5_1x6_1x5();
+	Error += test_packUnorm2x3_1x2();
+
+	Error += test_packUint2x8();
+	Error += test_packUint4x8();
+	Error += test_packUint2x16();
+	Error += test_packUint4x16();
+	Error += test_packUint2x32();
+
+	Error += test_packInt2x8();
+	Error += test_packInt4x8();
+	Error += test_packInt2x16();
+	Error += test_packInt4x16();
+	Error += test_packInt2x32();
+
+	Error += test_F2x11_1x10();
+	Error += test_F3x9_E1x5();
+	Error += test_RGBM();
+	Error += test_Unorm3x10_1x2();
+	Error += test_Snorm3x10_1x2();
+
+	Error += test_I3x10_1x2();
+	Error += test_U3x10_1x2();
+	Error += test_Half1x16();
+	Error += test_Half4x16();
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/gtc/gtc_quaternion.cpp b/3rdparty/glm/source/test/gtc/gtc_quaternion.cpp
new file mode 100644
index 0000000..540ca42
--- /dev/null
+++ b/3rdparty/glm/source/test/gtc/gtc_quaternion.cpp
@@ -0,0 +1,345 @@
+#include <glm/gtc/constants.hpp>
+#include <glm/gtc/quaternion.hpp>
+#include <glm/gtc/matrix_transform.hpp>
+#include <glm/ext/matrix_relational.hpp>
+#include <glm/ext/vector_relational.hpp>
+#include <glm/ext/scalar_relational.hpp>
+#include <glm/glm.hpp>
+#include <vector>
+
+int test_quat_angle()
+{
+	int Error = 0;
+
+	{
+		glm::quat Q = glm::angleAxis(glm::pi<float>() * 0.25f, glm::vec3(0, 0, 1));
+		glm::quat N = glm::normalize(Q);
+		float L = glm::length(N);
+		Error += glm::equal(L, 1.0f, 0.01f) ? 0 : 1;
+		float A = glm::angle(N);
+		Error += glm::equal(A, glm::pi<float>() * 0.25f, 0.01f) ? 0 : 1;
+	}
+	{
+		glm::quat Q = glm::angleAxis(glm::pi<float>() * 0.25f, glm::normalize(glm::vec3(0, 1, 1)));
+		glm::quat N = glm::normalize(Q);
+		float L = glm::length(N);
+		Error += glm::equal(L, 1.0f, 0.01f) ? 0 : 1;
+		float A = glm::angle(N);
+		Error += glm::equal(A, glm::pi<float>() * 0.25f, 0.01f) ? 0 : 1;
+	}
+	{
+		glm::quat Q = glm::angleAxis(glm::pi<float>() * 0.25f, glm::normalize(glm::vec3(1, 2, 3)));
+		glm::quat N = glm::normalize(Q);
+		float L = glm::length(N);
+		Error += glm::equal(L, 1.0f, 0.01f) ? 0 : 1;
+		float A = glm::angle(N);
+		Error += glm::equal(A, glm::pi<float>() * 0.25f, 0.01f) ? 0 : 1;
+	}
+
+	return Error;
+}
+
+int test_quat_angleAxis()
+{
+	int Error = 0;
+
+	glm::quat A = glm::angleAxis(0.f, glm::vec3(0.f, 0.f, 1.f));
+	glm::quat B = glm::angleAxis(glm::pi<float>() * 0.5f, glm::vec3(0, 0, 1));
+	glm::quat C = glm::mix(A, B, 0.5f);
+	glm::quat D = glm::angleAxis(glm::pi<float>() * 0.25f, glm::vec3(0, 0, 1));
+
+	Error += glm::equal(C.x, D.x, 0.01f) ? 0 : 1;
+	Error += glm::equal(C.y, D.y, 0.01f) ? 0 : 1;
+	Error += glm::equal(C.z, D.z, 0.01f) ? 0 : 1;
+	Error += glm::equal(C.w, D.w, 0.01f) ? 0 : 1;
+
+	return Error;
+}
+
+int test_quat_mix()
+{
+	int Error = 0;
+
+	glm::quat A = glm::angleAxis(0.f, glm::vec3(0.f, 0.f, 1.f));
+	glm::quat B = glm::angleAxis(glm::pi<float>() * 0.5f, glm::vec3(0, 0, 1));
+	glm::quat C = glm::mix(A, B, 0.5f);
+	glm::quat D = glm::angleAxis(glm::pi<float>() * 0.25f, glm::vec3(0, 0, 1));
+
+	Error += glm::equal(C.x, D.x, 0.01f) ? 0 : 1;
+	Error += glm::equal(C.y, D.y, 0.01f) ? 0 : 1;
+	Error += glm::equal(C.z, D.z, 0.01f) ? 0 : 1;
+	Error += glm::equal(C.w, D.w, 0.01f) ? 0 : 1;
+
+	return Error;
+}
+
+int test_quat_normalize()
+{
+	int Error(0);
+
+	{
+		glm::quat Q = glm::angleAxis(glm::pi<float>() * 0.25f, glm::vec3(0, 0, 1));
+		glm::quat N = glm::normalize(Q);
+		float L = glm::length(N);
+		Error += glm::equal(L, 1.0f, 0.000001f) ? 0 : 1;
+	}
+	{
+		glm::quat Q = glm::angleAxis(glm::pi<float>() * 0.25f, glm::vec3(0, 0, 2));
+		glm::quat N = glm::normalize(Q);
+		float L = glm::length(N);
+		Error += glm::equal(L, 1.0f, 0.000001f) ? 0 : 1;
+	}
+	{
+		glm::quat Q = glm::angleAxis(glm::pi<float>() * 0.25f, glm::vec3(1, 2, 3));
+		glm::quat N = glm::normalize(Q);
+		float L = glm::length(N);
+		Error += glm::equal(L, 1.0f, 0.000001f) ? 0 : 1;
+	}
+
+	return Error;
+}
+
+int test_quat_euler()
+{
+	int Error = 0;
+
+	{
+		glm::quat q(1.0f, 0.0f, 0.0f, 1.0f);
+		float Roll = glm::roll(q);
+		float Pitch = glm::pitch(q);
+		float Yaw = glm::yaw(q);
+		glm::vec3 Angles = glm::eulerAngles(q);
+		Error += glm::all(glm::equal(Angles, glm::vec3(Pitch, Yaw, Roll), 0.000001f)) ? 0 : 1;
+	}
+
+	{
+		glm::dquat q(1.0, 0.0, 0.0, 1.0);
+		double Roll = glm::roll(q);
+		double Pitch = glm::pitch(q);
+		double Yaw = glm::yaw(q);
+		glm::dvec3 Angles = glm::eulerAngles(q);
+		Error += glm::all(glm::equal(Angles, glm::dvec3(Pitch, Yaw, Roll), 0.000001)) ? 0 : 1;
+	}
+
+	return Error;
+}
+
+int test_quat_slerp()
+{
+	int Error = 0;
+
+	float const Epsilon = 0.0001f;//glm::epsilon<float>();
+
+	float sqrt2 = std::sqrt(2.0f)/2.0f;
+	glm::quat id(static_cast<float>(1), static_cast<float>(0), static_cast<float>(0), static_cast<float>(0));
+	glm::quat Y90rot(sqrt2, 0.0f, sqrt2, 0.0f);
+	glm::quat Y180rot(0.0f, 0.0f, 1.0f, 0.0f);
+
+	// Testing a == 0
+	// Must be id
+	glm::quat id2 = glm::slerp(id, Y90rot, 0.0f);
+	Error += glm::all(glm::equal(id, id2, Epsilon)) ? 0 : 1;
+
+	// Testing a == 1
+	// Must be 90� rotation on Y : 0 0.7 0 0.7
+	glm::quat Y90rot2 = glm::slerp(id, Y90rot, 1.0f);
+	Error += glm::all(glm::equal(Y90rot, Y90rot2, Epsilon)) ? 0 : 1;
+
+	// Testing standard, easy case
+	// Must be 45� rotation on Y : 0 0.38 0 0.92
+	glm::quat Y45rot1 = glm::slerp(id, Y90rot, 0.5f);
+
+	// Testing reverse case
+	// Must be 45� rotation on Y : 0 0.38 0 0.92
+	glm::quat Ym45rot2 = glm::slerp(Y90rot, id, 0.5f);
+
+	// Testing against full circle around the sphere instead of shortest path
+	// Must be 45� rotation on Y
+	// certainly not a 135� rotation
+	glm::quat Y45rot3 = glm::slerp(id , -Y90rot, 0.5f);
+	float Y45angle3 = glm::angle(Y45rot3);
+	Error += glm::equal(Y45angle3, glm::pi<float>() * 0.25f, Epsilon) ? 0 : 1;
+	Error += glm::all(glm::equal(Ym45rot2, Y45rot3, Epsilon)) ? 0 : 1;
+
+	// Same, but inverted
+	// Must also be 45� rotation on Y :  0 0.38 0 0.92
+	// -0 -0.38 -0 -0.92 is ok too
+	glm::quat Y45rot4 = glm::slerp(-Y90rot, id, 0.5f);
+	Error += glm::all(glm::equal(Ym45rot2, -Y45rot4, Epsilon)) ? 0 : 1;
+
+	// Testing q1 = q2
+	// Must be 90� rotation on Y : 0 0.7 0 0.7
+	glm::quat Y90rot3 = glm::slerp(Y90rot, Y90rot, 0.5f);
+	Error += glm::all(glm::equal(Y90rot, Y90rot3, Epsilon)) ? 0 : 1;
+
+	// Testing 180� rotation
+	// Must be 90� rotation on almost any axis that is on the XZ plane
+	glm::quat XZ90rot = glm::slerp(id, -Y90rot, 0.5f);
+	float XZ90angle = glm::angle(XZ90rot); // Must be PI/4 = 0.78;
+	Error += glm::equal(XZ90angle, glm::pi<float>() * 0.25f, Epsilon) ? 0 : 1;
+
+	// Testing almost equal quaternions (this test should pass through the linear interpolation)
+	// Must be 0 0.00X 0 0.99999
+	glm::quat almostid = glm::slerp(id, glm::angleAxis(0.1f, glm::vec3(0.0f, 1.0f, 0.0f)), 0.5f);
+
+	// Testing quaternions with opposite sign
+	{
+		glm::quat a(-1, 0, 0, 0);
+
+		glm::quat result = glm::slerp(a, id, 0.5f);
+
+		Error += glm::equal(glm::pow(glm::dot(id, result), 2.f), 1.f, 0.01f) ? 0 : 1;
+	}
+
+	return Error;
+}
+
+int test_quat_slerp_spins()
+{
+    int Error = 0;
+
+    float const Epsilon = 0.0001f;//glm::epsilon<float>();
+
+    float sqrt2 = std::sqrt(2.0f) / 2.0f;
+    glm::quat id(static_cast<float>(1), static_cast<float>(0), static_cast<float>(0), static_cast<float>(0));
+    glm::quat Y90rot(sqrt2, 0.0f, sqrt2, 0.0f);
+    glm::quat Y180rot(0.0f, 0.0f, 1.0f, 0.0f);
+
+    // Testing a == 0, k == 1
+    // Must be id
+    glm::quat id2 = glm::slerp(id, id, 1.0f, 1);
+    Error += glm::all(glm::equal(id, id2, Epsilon)) ? 0 : 1;
+
+    // Testing a == 1, k == 2
+    // Must be id
+    glm::quat id3 = glm::slerp(id, id, 1.0f, 2);
+    Error += glm::all(glm::equal(id, id3, Epsilon)) ? 0 : 1;
+
+    // Testing a == 1, k == 1
+    // Must be 90� rotation on Y : 0 0.7 0 0.7
+    // Negative quaternion is representing same orientation
+    glm::quat Y90rot2 = glm::slerp(id, Y90rot, 1.0f, 1);
+    Error += glm::all(glm::equal(Y90rot, -Y90rot2, Epsilon)) ? 0 : 1;
+
+    // Testing a == 1, k == 2
+    // Must be id
+    glm::quat Y90rot3 = glm::slerp(id, Y90rot, 8.0f / 9.0f, 2);
+    Error += glm::all(glm::equal(id, Y90rot3, Epsilon)) ? 0 : 1;
+
+    // Testing a == 1, k == 1
+    // Must be 90� rotation on Y : 0 0.7 0 0.7
+    glm::quat Y90rot4 = glm::slerp(id, Y90rot, 0.2f, 1);
+    Error += glm::all(glm::equal(Y90rot, Y90rot4, Epsilon)) ? 0 : 1;
+
+    // Testing reverse case
+    // Must be 45� rotation on Y : 0 0.38 0 0.92
+    // Negative quaternion is representing same orientation
+    glm::quat Ym45rot2 = glm::slerp(Y90rot, id, 0.9f, 1);
+    glm::quat Ym45rot3 = glm::slerp(Y90rot, id, 0.5f);
+    Error += glm::all(glm::equal(-Ym45rot2, Ym45rot3, Epsilon)) ? 0 : 1;
+
+    // Testing against full circle around the sphere instead of shortest path
+    // Must be 45� rotation on Y
+    // certainly not a 135� rotation
+    glm::quat Y45rot3 = glm::slerp(id, -Y90rot, 0.5f, 0);
+    float Y45angle3 = glm::angle(Y45rot3);
+    Error += glm::equal(Y45angle3, glm::pi<float>() * 0.25f, Epsilon) ? 0 : 1;
+    Error += glm::all(glm::equal(Ym45rot3, Y45rot3, Epsilon)) ? 0 : 1;
+
+    // Same, but inverted
+    // Must also be 45� rotation on Y :  0 0.38 0 0.92
+    // -0 -0.38 -0 -0.92 is ok too
+    glm::quat Y45rot4 = glm::slerp(-Y90rot, id, 0.5f, 0);
+    Error += glm::all(glm::equal(Ym45rot2, Y45rot4, Epsilon)) ? 0 : 1;
+
+    // Testing q1 = q2 k == 2
+    // Must be 90� rotation on Y : 0 0.7 0 0.7
+    glm::quat Y90rot5 = glm::slerp(Y90rot, Y90rot, 0.5f, 2);
+    Error += glm::all(glm::equal(Y90rot, Y90rot5, Epsilon)) ? 0 : 1;
+
+    // Testing 180� rotation
+    // Must be 90� rotation on almost any axis that is on the XZ plane
+    glm::quat XZ90rot = glm::slerp(id, -Y90rot, 0.5f, 1);
+    float XZ90angle = glm::angle(XZ90rot); // Must be PI/4 = 0.78;
+    Error += glm::equal(XZ90angle, glm::pi<float>() * 1.25f, Epsilon) ? 0 : 1;
+
+    // Testing rotation over long arc
+    // Distance from id to 90� is 270�, so 2/3 of it should be 180�
+    // Negative quaternion is representing same orientation
+    glm::quat Neg90rot = glm::slerp(id, Y90rot, 2.0f / 3.0f, -1);
+    Error += glm::all(glm::equal(Y180rot, -Neg90rot, Epsilon)) ? 0 : 1;
+
+    return Error;
+}
+
+static int test_quat_mul_vec()
+{
+	int Error(0);
+
+	glm::quat q = glm::angleAxis(glm::pi<float>() * 0.5f, glm::vec3(0, 0, 1));
+	glm::vec3 v(1, 0, 0);
+	glm::vec3 u(q * v);
+	glm::vec3 w(u * q);
+
+	Error += glm::all(glm::equal(v, w, 0.01f)) ? 0 : 1;
+
+	return Error;
+}
+
+static int test_mul()
+{
+	int Error = 0;
+
+	glm::quat temp1 = glm::normalize(glm::quat(1.0f, glm::vec3(0.0, 1.0, 0.0)));
+	glm::quat temp2 = glm::normalize(glm::quat(0.5f, glm::vec3(1.0, 0.0, 0.0)));
+
+	glm::vec3 transformed0 = (temp1 * glm::vec3(0.0, 1.0, 0.0) * glm::inverse(temp1));
+	glm::vec3 temp4 = temp2 * transformed0 * glm::inverse(temp2);
+
+	glm::quat temp5 = glm::normalize(temp1 * temp2);
+	glm::vec3 temp6 = temp5 * glm::vec3(0.0, 1.0, 0.0) * glm::inverse(temp5);
+
+	glm::quat temp7(1.0f, glm::vec3(0.0, 1.0, 0.0));
+
+	temp7 *= temp5;
+	temp7 *= glm::inverse(temp5);
+
+	Error += glm::any(glm::notEqual(temp7, glm::quat(1.0f, glm::vec3(0.0, 1.0, 0.0)), glm::epsilon<float>())) ? 1 : 0;
+
+	return Error;
+}
+
+int test_identity()
+{
+	int Error = 0;
+
+	glm::quat const Q = glm::identity<glm::quat>();
+
+	Error += glm::all(glm::equal(Q, glm::quat(1, 0, 0, 0), 0.0001f)) ? 0 : 1;
+	Error += glm::any(glm::notEqual(Q, glm::quat(1, 0, 0, 0), 0.0001f)) ? 1 : 0;
+
+	glm::mat4 const M = glm::identity<glm::mat4x4>();
+	glm::mat4 const N(1.0f);
+
+	Error += glm::all(glm::equal(M, N, 0.0001f)) ? 0 : 1;
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_mul();
+	Error += test_quat_mul_vec();
+	Error += test_quat_angle();
+	Error += test_quat_angleAxis();
+	Error += test_quat_mix();
+	Error += test_quat_normalize();
+	Error += test_quat_euler();
+	Error += test_quat_slerp();
+    Error += test_quat_slerp_spins();
+	Error += test_identity();
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/gtc/gtc_random.cpp b/3rdparty/glm/source/test/gtc/gtc_random.cpp
new file mode 100644
index 0000000..60fb60c
--- /dev/null
+++ b/3rdparty/glm/source/test/gtc/gtc_random.cpp
@@ -0,0 +1,381 @@
+#define GLM_FORCE_DEFAULT_ALIGNED_GENTYPES
+#include <glm/gtc/random.hpp>
+#include <glm/gtc/epsilon.hpp>
+#include <glm/gtc/type_precision.hpp>
+#if GLM_LANG & GLM_LANG_CXX0X_FLAG
+#	include <array>
+#endif
+
+std::size_t const TestSamples = 10000;
+
+int test_linearRand()
+{
+	int Error = 0;
+
+	glm::int32 const Min = 16;
+	glm::int32 const Max = 32;
+
+	{
+		glm::u8vec2 AMin(std::numeric_limits<glm::u8>::max());
+		glm::u8vec2 AMax(std::numeric_limits<glm::u8>::min());
+		{
+			for(std::size_t i = 0; i < TestSamples; ++i)
+			{
+				glm::u8vec2 A = glm::linearRand(glm::u8vec2(Min), glm::u8vec2(Max));
+				AMin = glm::min(AMin, A);
+				AMax = glm::max(AMax, A);
+
+				if(!glm::all(glm::lessThanEqual(A, glm::u8vec2(Max))))
+					++Error;
+				if(!glm::all(glm::greaterThanEqual(A, glm::u8vec2(Min))))
+					++Error;
+				assert(!Error);
+			}
+
+			Error += glm::all(glm::equal(AMin, glm::u8vec2(Min))) ? 0 : 1;
+			Error += glm::all(glm::equal(AMax, glm::u8vec2(Max))) ? 0 : 1;
+			assert(!Error);
+		}
+
+		glm::u16vec2 BMin(std::numeric_limits<glm::u16>::max());
+		glm::u16vec2 BMax(std::numeric_limits<glm::u16>::min());
+		{
+			for(std::size_t i = 0; i < TestSamples; ++i)
+			{
+				glm::u16vec2 B = glm::linearRand(glm::u16vec2(Min), glm::u16vec2(Max));
+				BMin = glm::min(BMin, B);
+				BMax = glm::max(BMax, B);
+
+				if(!glm::all(glm::lessThanEqual(B, glm::u16vec2(Max))))
+					++Error;
+				if(!glm::all(glm::greaterThanEqual(B, glm::u16vec2(Min))))
+					++Error;
+				assert(!Error);
+			}
+
+			Error += glm::all(glm::equal(BMin, glm::u16vec2(Min))) ? 0 : 1;
+			Error += glm::all(glm::equal(BMax, glm::u16vec2(Max))) ? 0 : 1;
+			assert(!Error);
+		}
+
+		glm::u32vec2 CMin(std::numeric_limits<glm::u32>::max());
+		glm::u32vec2 CMax(std::numeric_limits<glm::u32>::min());
+		{
+			for(std::size_t i = 0; i < TestSamples; ++i)
+			{
+				glm::u32vec2 C = glm::linearRand(glm::u32vec2(Min), glm::u32vec2(Max));
+				CMin = glm::min(CMin, C);
+				CMax = glm::max(CMax, C);
+
+				if(!glm::all(glm::lessThanEqual(C, glm::u32vec2(Max))))
+					++Error;
+				if(!glm::all(glm::greaterThanEqual(C, glm::u32vec2(Min))))
+					++Error;
+				assert(!Error);
+			}
+
+			Error += glm::all(glm::equal(CMin, glm::u32vec2(Min))) ? 0 : 1;
+			Error += glm::all(glm::equal(CMax, glm::u32vec2(Max))) ? 0 : 1;
+			assert(!Error);
+		}
+
+		glm::u64vec2 DMin(std::numeric_limits<glm::u64>::max());
+		glm::u64vec2 DMax(std::numeric_limits<glm::u64>::min());
+		{
+			for(std::size_t i = 0; i < TestSamples; ++i)
+			{
+				glm::u64vec2 D = glm::linearRand(glm::u64vec2(Min), glm::u64vec2(Max));
+				DMin = glm::min(DMin, D);
+				DMax = glm::max(DMax, D);
+
+				if(!glm::all(glm::lessThanEqual(D, glm::u64vec2(Max))))
+					++Error;
+				if(!glm::all(glm::greaterThanEqual(D, glm::u64vec2(Min))))
+					++Error;
+				assert(!Error);
+			}
+
+			Error += glm::all(glm::equal(DMin, glm::u64vec2(Min))) ? 0 : 1;
+			Error += glm::all(glm::equal(DMax, glm::u64vec2(Max))) ? 0 : 1;
+			assert(!Error);
+		}
+	}
+
+	{
+		glm::i8vec2 AMin(std::numeric_limits<glm::i8>::max());
+		glm::i8vec2 AMax(std::numeric_limits<glm::i8>::min());
+		{
+			for(std::size_t i = 0; i < TestSamples; ++i)
+			{
+				glm::i8vec2 A = glm::linearRand(glm::i8vec2(Min), glm::i8vec2(Max));
+				AMin = glm::min(AMin, A);
+				AMax = glm::max(AMax, A);
+
+				if(!glm::all(glm::lessThanEqual(A, glm::i8vec2(Max))))
+					++Error;
+				if(!glm::all(glm::greaterThanEqual(A, glm::i8vec2(Min))))
+					++Error;
+				assert(!Error);
+			}
+
+			Error += glm::all(glm::equal(AMin, glm::i8vec2(Min))) ? 0 : 1;
+			Error += glm::all(glm::equal(AMax, glm::i8vec2(Max))) ? 0 : 1;
+			assert(!Error);
+		}
+
+		glm::i16vec2 BMin(std::numeric_limits<glm::i16>::max());
+		glm::i16vec2 BMax(std::numeric_limits<glm::i16>::min());
+		{
+			for(std::size_t i = 0; i < TestSamples; ++i)
+			{
+				glm::i16vec2 B = glm::linearRand(glm::i16vec2(Min), glm::i16vec2(Max));
+				BMin = glm::min(BMin, B);
+				BMax = glm::max(BMax, B);
+
+				if(!glm::all(glm::lessThanEqual(B, glm::i16vec2(Max))))
+					++Error;
+				if(!glm::all(glm::greaterThanEqual(B, glm::i16vec2(Min))))
+					++Error;
+				assert(!Error);
+			}
+
+			Error += glm::all(glm::equal(BMin, glm::i16vec2(Min))) ? 0 : 1;
+			Error += glm::all(glm::equal(BMax, glm::i16vec2(Max))) ? 0 : 1;
+			assert(!Error);
+		}
+
+		glm::i32vec2 CMin(std::numeric_limits<glm::i32>::max());
+		glm::i32vec2 CMax(std::numeric_limits<glm::i32>::min());
+		{
+			for(std::size_t i = 0; i < TestSamples; ++i)
+			{
+				glm::i32vec2 C = glm::linearRand(glm::i32vec2(Min), glm::i32vec2(Max));
+				CMin = glm::min(CMin, C);
+				CMax = glm::max(CMax, C);
+
+				if(!glm::all(glm::lessThanEqual(C, glm::i32vec2(Max))))
+					++Error;
+				if(!glm::all(glm::greaterThanEqual(C, glm::i32vec2(Min))))
+					++Error;
+				assert(!Error);
+			}
+
+			Error += glm::all(glm::equal(CMin, glm::i32vec2(Min))) ? 0 : 1;
+			Error += glm::all(glm::equal(CMax, glm::i32vec2(Max))) ? 0 : 1;
+			assert(!Error);
+		}
+
+		glm::i64vec2 DMin(std::numeric_limits<glm::i64>::max());
+		glm::i64vec2 DMax(std::numeric_limits<glm::i64>::min());
+		{
+			for(std::size_t i = 0; i < TestSamples; ++i)
+			{
+				glm::i64vec2 D = glm::linearRand(glm::i64vec2(Min), glm::i64vec2(Max));
+				DMin = glm::min(DMin, D);
+				DMax = glm::max(DMax, D);
+
+				if(!glm::all(glm::lessThanEqual(D, glm::i64vec2(Max))))
+					++Error;
+				if(!glm::all(glm::greaterThanEqual(D, glm::i64vec2(Min))))
+					++Error;
+				assert(!Error);
+			}
+
+			Error += glm::all(glm::equal(DMin, glm::i64vec2(Min))) ? 0 : 1;
+			Error += glm::all(glm::equal(DMax, glm::i64vec2(Max))) ? 0 : 1;
+			assert(!Error);
+		}
+	}
+
+	for(std::size_t i = 0; i < TestSamples; ++i)
+	{
+		glm::f32vec2 const A(glm::linearRand(glm::f32vec2(static_cast<float>(Min)), glm::f32vec2(static_cast<float>(Max))));
+		if(!glm::all(glm::lessThanEqual(A, glm::f32vec2(static_cast<float>(Max)))))
+			++Error;
+		if(!glm::all(glm::greaterThanEqual(A, glm::f32vec2(static_cast<float>(Min)))))
+			++Error;
+
+		glm::f64vec2 const B(glm::linearRand(glm::f64vec2(Min), glm::f64vec2(Max)));
+		if(!glm::all(glm::lessThanEqual(B, glm::f64vec2(Max))))
+			++Error;
+		if(!glm::all(glm::greaterThanEqual(B, glm::f64vec2(Min))))
+			++Error;
+		assert(!Error);
+	}
+
+	{
+		float ResultFloat = 0.0f;
+		double ResultDouble = 0.0;
+		for(std::size_t i = 0; i < TestSamples; ++i)
+		{
+			ResultFloat += glm::linearRand(-1.0f, 1.0f);
+			ResultDouble += glm::linearRand(-1.0, 1.0);
+		}
+
+		Error += glm::epsilonEqual(ResultFloat, 0.0f, 0.0001f);
+		Error += glm::epsilonEqual(ResultDouble, 0.0, 0.0001);
+		assert(!Error);
+	}
+
+	return Error;
+}
+
+int test_circularRand()
+{
+	int Error = 0;
+
+	{
+		std::size_t Max = TestSamples;
+		float ResultFloat = 0.0f;
+		double ResultDouble = 0.0;
+		double Radius = 2.0;
+
+		for(std::size_t i = 0; i < Max; ++i)
+		{
+			ResultFloat += glm::length(glm::circularRand(1.0f));
+			ResultDouble += glm::length(glm::circularRand(Radius));
+		}
+
+		Error += glm::epsilonEqual(ResultFloat, float(Max), 0.01f) ? 0 : 1;
+		Error += glm::epsilonEqual(ResultDouble, double(Max) * double(Radius), 0.01) ? 0 : 1;
+		assert(!Error);
+	}
+
+	return Error;
+}
+
+int test_sphericalRand()
+{
+	int Error = 0;
+
+	{
+		std::size_t Max = TestSamples;
+		float ResultFloatA = 0.0f;
+		float ResultFloatB = 0.0f;
+		float ResultFloatC = 0.0f;
+		double ResultDoubleA = 0.0;
+		double ResultDoubleB = 0.0;
+		double ResultDoubleC = 0.0;
+
+		for(std::size_t i = 0; i < Max; ++i)
+		{
+			ResultFloatA += glm::length(glm::sphericalRand(1.0f));
+			ResultDoubleA += glm::length(glm::sphericalRand(1.0));
+			ResultFloatB += glm::length(glm::sphericalRand(2.0f));
+			ResultDoubleB += glm::length(glm::sphericalRand(2.0));
+			ResultFloatC += glm::length(glm::sphericalRand(3.0f));
+			ResultDoubleC += glm::length(glm::sphericalRand(3.0));
+		}
+
+		Error += glm::epsilonEqual(ResultFloatA, float(Max), 0.01f) ? 0 : 1;
+		Error += glm::epsilonEqual(ResultDoubleA, double(Max), 0.0001) ? 0 : 1;
+		Error += glm::epsilonEqual(ResultFloatB, float(Max * 2), 0.01f) ? 0 : 1;
+		Error += glm::epsilonEqual(ResultDoubleB, double(Max * 2), 0.0001) ? 0 : 1;
+		Error += glm::epsilonEqual(ResultFloatC, float(Max * 3), 0.01f) ? 0 : 1;
+		Error += glm::epsilonEqual(ResultDoubleC, double(Max * 3), 0.01) ? 0 : 1;
+		assert(!Error);
+	}
+
+	return Error;
+}
+
+int test_diskRand()
+{
+	int Error = 0;
+
+	{
+		float ResultFloat = 0.0f;
+		double ResultDouble = 0.0;
+
+		for(std::size_t i = 0; i < TestSamples; ++i)
+		{
+			ResultFloat += glm::length(glm::diskRand(2.0f));
+			ResultDouble += glm::length(glm::diskRand(2.0));
+		}
+
+		Error += ResultFloat < float(TestSamples) * 2.f ? 0 : 1;
+		Error += ResultDouble < double(TestSamples) * 2.0 ? 0 : 1;
+		assert(!Error);
+	}
+
+	return Error;
+}
+
+int test_ballRand()
+{
+	int Error = 0;
+
+	{
+		float ResultFloat = 0.0f;
+		double ResultDouble = 0.0;
+
+		for(std::size_t i = 0; i < TestSamples; ++i)
+		{
+			ResultFloat += glm::length(glm::ballRand(2.0f));
+			ResultDouble += glm::length(glm::ballRand(2.0));
+		}
+
+		Error += ResultFloat < float(TestSamples) * 2.f ? 0 : 1;
+		Error += ResultDouble < double(TestSamples) * 2.0 ? 0 : 1;
+		assert(!Error);
+	}
+
+	return Error;
+}
+/*
+#if(GLM_LANG & GLM_LANG_CXX0X_FLAG)
+int test_grid()
+{
+	int Error = 0;
+
+	typedef std::array<int, 8> colors;
+	typedef std::array<int, 8 * 8> grid;
+
+	grid Grid;
+	colors Colors;
+
+	grid GridBest;
+	colors ColorsBest;
+
+	while(true)
+	{
+		for(std::size_t i = 0; i < Grid.size(); ++i)
+			Grid[i] = int(glm::linearRand(0.0, 8.0 * 8.0 * 8.0 - 1.0) / 64.0);
+
+		for(std::size_t i = 0; i < Grid.size(); ++i)
+			++Colors[Grid[i]];
+
+		bool Exit = true;
+		for(std::size_t i = 0; i < Colors.size(); ++i)
+		{
+			if(Colors[i] == 8)
+				continue;
+
+			Exit = false;
+			break;
+		}
+
+		if(Exit == true)
+			break;
+	}
+
+	return Error;
+}
+#endif
+*/
+int main()
+{
+	int Error = 0;
+
+	Error += test_linearRand();
+	Error += test_circularRand();
+	Error += test_sphericalRand();
+	Error += test_diskRand();
+	Error += test_ballRand();
+/*
+#if(GLM_LANG & GLM_LANG_CXX0X_FLAG)
+	Error += test_grid();
+#endif
+*/
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/gtc/gtc_reciprocal.cpp b/3rdparty/glm/source/test/gtc/gtc_reciprocal.cpp
new file mode 100644
index 0000000..5158413
--- /dev/null
+++ b/3rdparty/glm/source/test/gtc/gtc_reciprocal.cpp
@@ -0,0 +1,8 @@
+#include <glm/gtc/reciprocal.hpp>
+#include <ctime>
+
+int main()
+{
+	return 0;
+}
+
diff --git a/3rdparty/glm/source/test/gtc/gtc_round.cpp b/3rdparty/glm/source/test/gtc/gtc_round.cpp
new file mode 100644
index 0000000..60d9a85
--- /dev/null
+++ b/3rdparty/glm/source/test/gtc/gtc_round.cpp
@@ -0,0 +1,458 @@
+#include <glm/gtc/round.hpp>
+#include <glm/gtc/type_precision.hpp>
+#include <glm/gtc/vec1.hpp>
+#include <glm/gtc/epsilon.hpp>
+#include <vector>
+#include <ctime>
+#include <cstdio>
+
+namespace isPowerOfTwo
+{
+	template<typename genType>
+	struct type
+	{
+		genType		Value;
+		bool		Return;
+	};
+
+	int test_int16()
+	{
+		type<glm::int16> const Data[] =
+		{
+			{0x0001, true},
+			{0x0002, true},
+			{0x0004, true},
+			{0x0080, true},
+			{0x0000, true},
+			{0x0003, false}
+		};
+
+		int Error(0);
+
+		for(std::size_t i = 0, n = sizeof(Data) / sizeof(type<glm::int16>); i < n; ++i)
+		{
+			bool Result = glm::isPowerOfTwo(Data[i].Value);
+			Error += Data[i].Return == Result ? 0 : 1;
+		}
+
+		return Error;
+	}
+
+	int test_uint16()
+	{
+		type<glm::uint16> const Data[] =
+		{
+			{0x0001, true},
+			{0x0002, true},
+			{0x0004, true},
+			{0x0000, true},
+			{0x0000, true},
+			{0x0003, false}
+		};
+
+		int Error(0);
+
+		for(std::size_t i = 0, n = sizeof(Data) / sizeof(type<glm::uint16>); i < n; ++i)
+		{
+			bool Result = glm::isPowerOfTwo(Data[i].Value);
+			Error += Data[i].Return == Result ? 0 : 1;
+		}
+
+		return Error;
+	}
+
+	int test_int32()
+	{
+		type<int> const Data[] =
+		{
+			{0x00000001, true},
+			{0x00000002, true},
+			{0x00000004, true},
+			{0x0000000f, false},
+			{0x00000000, true},
+			{0x00000003, false}
+		};
+
+		int Error(0);
+
+		for(std::size_t i = 0, n = sizeof(Data) / sizeof(type<int>); i < n; ++i)
+		{
+			bool Result = glm::isPowerOfTwo(Data[i].Value);
+			Error += Data[i].Return == Result ? 0 : 1;
+		}
+
+		for(std::size_t i = 0, n = sizeof(Data) / sizeof(type<int>); i < n; ++i)
+		{
+			glm::bvec1 Result = glm::isPowerOfTwo(glm::ivec1(Data[i].Value));
+			Error += glm::all(glm::equal(glm::bvec1(Data[i].Return), Result)) ? 0 : 1;
+		}
+
+		for(std::size_t i = 0, n = sizeof(Data) / sizeof(type<int>); i < n; ++i)
+		{
+			glm::bvec2 Result = glm::isPowerOfTwo(glm::ivec2(Data[i].Value));
+			Error += glm::all(glm::equal(glm::bvec2(Data[i].Return), Result)) ? 0 : 1;
+		}
+
+		for(std::size_t i = 0, n = sizeof(Data) / sizeof(type<int>); i < n; ++i)
+		{
+			glm::bvec3 Result = glm::isPowerOfTwo(glm::ivec3(Data[i].Value));
+			Error += glm::all(glm::equal(glm::bvec3(Data[i].Return), Result)) ? 0 : 1;
+		}
+
+		for(std::size_t i = 0, n = sizeof(Data) / sizeof(type<int>); i < n; ++i)
+		{
+			glm::bvec4 Result = glm::isPowerOfTwo(glm::ivec4(Data[i].Value));
+			Error += glm::all(glm::equal(glm::bvec4(Data[i].Return), Result)) ? 0 : 1;
+		}
+
+		return Error;
+	}
+
+	int test_uint32()
+	{
+		type<glm::uint> const Data[] =
+		{
+			{0x00000001, true},
+			{0x00000002, true},
+			{0x00000004, true},
+			{0x80000000, true},
+			{0x00000000, true},
+			{0x00000003, false}
+		};
+
+		int Error(0);
+
+		for(std::size_t i = 0, n = sizeof(Data) / sizeof(type<glm::uint>); i < n; ++i)
+		{
+			bool Result = glm::isPowerOfTwo(Data[i].Value);
+			Error += Data[i].Return == Result ? 0 : 1;
+		}
+
+		return Error;
+	}
+
+	int test()
+	{
+		int Error(0);
+
+		Error += test_int16();
+		Error += test_uint16();
+		Error += test_int32();
+		Error += test_uint32();
+
+		return Error;
+	}
+}//isPowerOfTwo
+
+namespace ceilPowerOfTwo_advanced
+{
+	template<typename genIUType>
+	GLM_FUNC_QUALIFIER genIUType highestBitValue(genIUType Value)
+	{
+		genIUType tmp = Value;
+		genIUType result = genIUType(0);
+		while(tmp)
+		{
+			result = (tmp & (~tmp + 1)); // grab lowest bit
+			tmp &= ~result; // clear lowest bit
+		}
+		return result;
+	}
+
+	template<typename genType>
+	GLM_FUNC_QUALIFIER genType ceilPowerOfTwo_loop(genType value)
+	{
+		return glm::isPowerOfTwo(value) ? value : highestBitValue(value) << 1;
+	}
+
+	template<typename genType>
+	struct type
+	{
+		genType		Value;
+		genType		Return;
+	};
+
+	int test_int32()
+	{
+		type<glm::int32> const Data[] =
+		{
+			{0x0000ffff, 0x00010000},
+			{-3, -4},
+			{-8, -8},
+			{0x00000001, 0x00000001},
+			{0x00000002, 0x00000002},
+			{0x00000004, 0x00000004},
+			{0x00000007, 0x00000008},
+			{0x0000fff0, 0x00010000},
+			{0x0000f000, 0x00010000},
+			{0x08000000, 0x08000000},
+			{0x00000000, 0x00000000},
+			{0x00000003, 0x00000004}
+		};
+
+		int Error(0);
+
+		for(std::size_t i = 0, n = sizeof(Data) / sizeof(type<glm::int32>); i < n; ++i)
+		{
+			glm::int32 Result = glm::ceilPowerOfTwo(Data[i].Value);
+			Error += Data[i].Return == Result ? 0 : 1;
+		}
+
+		return Error;
+	}
+
+	int test_uint32()
+	{
+		type<glm::uint32> const Data[] =
+		{
+			{0x00000001, 0x00000001},
+			{0x00000002, 0x00000002},
+			{0x00000004, 0x00000004},
+			{0x00000007, 0x00000008},
+			{0x0000ffff, 0x00010000},
+			{0x0000fff0, 0x00010000},
+			{0x0000f000, 0x00010000},
+			{0x80000000, 0x80000000},
+			{0x00000000, 0x00000000},
+			{0x00000003, 0x00000004}
+		};
+
+		int Error(0);
+
+		for(std::size_t i = 0, n = sizeof(Data) / sizeof(type<glm::uint32>); i < n; ++i)
+		{
+			glm::uint32 Result = glm::ceilPowerOfTwo(Data[i].Value);
+			Error += Data[i].Return == Result ? 0 : 1;
+		}
+
+		return Error;
+	}
+
+	int perf()
+	{
+		int Error(0);
+
+		std::vector<glm::uint> v;
+		v.resize(100000000);
+
+		std::clock_t Timestramp0 = std::clock();
+
+		for(glm::uint32 i = 0, n = static_cast<glm::uint>(v.size()); i < n; ++i)
+			v[i] = ceilPowerOfTwo_loop(i);
+
+		std::clock_t Timestramp1 = std::clock();
+
+		for(glm::uint32 i = 0, n = static_cast<glm::uint>(v.size()); i < n; ++i)
+			v[i] = glm::ceilPowerOfTwo(i);
+
+		std::clock_t Timestramp2 = std::clock();
+
+		std::printf("ceilPowerOfTwo_loop: %d clocks\n", static_cast<int>(Timestramp1 - Timestramp0));
+		std::printf("glm::ceilPowerOfTwo: %d clocks\n", static_cast<int>(Timestramp2 - Timestramp1));
+
+		return Error;
+	}
+
+	int test()
+	{
+		int Error(0);
+
+		Error += test_int32();
+		Error += test_uint32();
+
+		return Error;
+	}
+}//namespace ceilPowerOfTwo_advanced
+
+namespace roundPowerOfTwo
+{
+	int test()
+	{
+		int Error = 0;
+		
+		glm::uint32 const A = glm::roundPowerOfTwo(7u);
+		Error += A == 8u ? 0 : 1;
+		
+		glm::uint32 const B = glm::roundPowerOfTwo(15u);
+		Error += B == 16u ? 0 : 1;
+
+		glm::uint32 const C = glm::roundPowerOfTwo(31u);
+		Error += C == 32u ? 0 : 1;
+		
+		glm::uint32 const D = glm::roundPowerOfTwo(9u);
+		Error += D == 8u ? 0 : 1;
+		
+		glm::uint32 const E = glm::roundPowerOfTwo(17u);
+		Error += E == 16u ? 0 : 1;
+		
+		glm::uint32 const F = glm::roundPowerOfTwo(33u);
+		Error += F == 32u ? 0 : 1;
+		
+		return Error;
+	}
+}//namespace roundPowerOfTwo
+
+namespace floorPowerOfTwo
+{
+	int test()
+	{
+		int Error = 0;
+		
+		glm::uint32 const A = glm::floorPowerOfTwo(7u);
+		Error += A == 4u ? 0 : 1;
+		
+		glm::uint32 const B = glm::floorPowerOfTwo(15u);
+		Error += B == 8u ? 0 : 1;
+		
+		glm::uint32 const C = glm::floorPowerOfTwo(31u);
+		Error += C == 16u ? 0 : 1;
+		
+		return Error;
+	}
+}//namespace floorPowerOfTwo
+
+namespace ceilPowerOfTwo
+{
+	int test()
+	{
+		int Error = 0;
+		
+		glm::uint32 const A = glm::ceilPowerOfTwo(7u);
+		Error += A == 8u ? 0 : 1;
+		
+		glm::uint32 const B = glm::ceilPowerOfTwo(15u);
+		Error += B == 16u ? 0 : 1;
+		
+		glm::uint32 const C = glm::ceilPowerOfTwo(31u);
+		Error += C == 32u ? 0 : 1;
+		
+		return Error;
+	}
+}//namespace ceilPowerOfTwo
+
+namespace floorMultiple
+{
+	template<typename genType>
+	struct type
+	{
+		genType		Source;
+		genType		Multiple;
+		genType		Return;
+		genType		Epsilon;
+	};
+
+	int test_float()
+	{
+		type<glm::float64> const Data[] = 
+		{
+			{3.4, 0.3, 3.3, 0.0001},
+			{-1.4, 0.3, -1.5, 0.0001},
+		};
+
+		int Error(0);
+		
+		for(std::size_t i = 0, n = sizeof(Data) / sizeof(type<glm::float64>); i < n; ++i)
+		{
+			glm::float64 Result = glm::floorMultiple(Data[i].Source, Data[i].Multiple);
+			Error += glm::epsilonEqual(Data[i].Return, Result, Data[i].Epsilon) ? 0 : 1;
+		}
+
+		return Error;
+	}
+
+	int test()
+	{
+		int Error(0);
+
+		Error += test_float();
+
+		return Error;
+	}
+}//namespace floorMultiple
+
+namespace ceilMultiple
+{
+	template<typename genType>
+	struct type
+	{
+		genType		Source;
+		genType		Multiple;
+		genType		Return;
+		genType		Epsilon;
+	};
+
+	int test_float()
+	{
+		type<glm::float64> const Data[] = 
+		{
+			{3.4, 0.3, 3.6, 0.0001},
+			{-1.4, 0.3, -1.2, 0.0001},
+		};
+
+		int Error(0);
+
+		for(std::size_t i = 0, n = sizeof(Data) / sizeof(type<glm::float64>); i < n; ++i)
+		{
+			glm::float64 Result = glm::ceilMultiple(Data[i].Source, Data[i].Multiple);
+			Error += glm::epsilonEqual(Data[i].Return, Result, Data[i].Epsilon) ? 0 : 1;
+		}
+
+		return Error;
+	}
+
+	int test_int()
+	{
+		type<int> const Data[] = 
+		{
+			{3, 4, 4, 0},
+			{7, 4, 8, 0},
+			{5, 4, 8, 0},
+			{1, 4, 4, 0},
+			{1, 3, 3, 0},
+			{4, 3, 6, 0},
+			{4, 1, 4, 0},
+			{1, 1, 1, 0},
+			{7, 1, 7, 0},
+		};
+
+		int Error(0);
+
+		for(std::size_t i = 0, n = sizeof(Data) / sizeof(type<int>); i < n; ++i)
+		{
+			int Result = glm::ceilMultiple(Data[i].Source, Data[i].Multiple);
+			Error += Data[i].Return == Result ? 0 : 1;
+		}
+
+		return Error;
+	}
+
+	int test()
+	{
+		int Error(0);
+
+		Error += test_int();
+		Error += test_float();
+
+		return Error;
+	}
+}//namespace ceilMultiple
+
+int main()
+{
+	int Error(0);
+
+	Error += isPowerOfTwo::test();
+	Error += floorPowerOfTwo::test();
+	Error += roundPowerOfTwo::test();
+	Error += ceilPowerOfTwo::test();
+	Error += ceilPowerOfTwo_advanced::test();
+	
+#	ifdef NDEBUG
+		Error += ceilPowerOfTwo_advanced::perf();
+#	endif//NDEBUG
+
+	Error += floorMultiple::test();
+	Error += ceilMultiple::test();
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/gtc/gtc_type_aligned.cpp b/3rdparty/glm/source/test/gtc/gtc_type_aligned.cpp
new file mode 100644
index 0000000..3c071ef
--- /dev/null
+++ b/3rdparty/glm/source/test/gtc/gtc_type_aligned.cpp
@@ -0,0 +1,181 @@
+#include <glm/glm.hpp>
+
+#if GLM_CONFIG_ALIGNED_GENTYPES == GLM_ENABLE
+#include <glm/gtc/type_aligned.hpp>
+#include <glm/gtc/type_precision.hpp>
+#include <glm/ext/vector_relational.hpp>
+#include <glm/ext/matrix_relational.hpp>
+
+GLM_STATIC_ASSERT(glm::detail::is_aligned<glm::aligned_lowp>::value, "aligned_lowp is not aligned");
+GLM_STATIC_ASSERT(glm::detail::is_aligned<glm::aligned_mediump>::value, "aligned_mediump is not aligned");
+GLM_STATIC_ASSERT(glm::detail::is_aligned<glm::aligned_highp>::value, "aligned_highp is not aligned");
+GLM_STATIC_ASSERT(!glm::detail::is_aligned<glm::packed_highp>::value, "packed_highp is aligned");
+GLM_STATIC_ASSERT(!glm::detail::is_aligned<glm::packed_mediump>::value, "packed_mediump is aligned");
+GLM_STATIC_ASSERT(!glm::detail::is_aligned<glm::packed_lowp>::value, "packed_lowp is aligned");
+
+struct my_vec4_packed
+{
+	glm::uint32 a;
+	glm::vec4 b;
+};
+GLM_STATIC_ASSERT(sizeof(my_vec4_packed) == sizeof(glm::uint32) + sizeof(glm::vec4), "glm::vec4 packed is not correct");
+
+struct my_vec4_aligned
+{
+	glm::uint32 a;
+	glm::aligned_vec4 b;
+};
+GLM_STATIC_ASSERT(sizeof(my_vec4_aligned) == sizeof(glm::aligned_vec4) * 2, "glm::vec4 aligned is not correct");
+
+struct my_dvec4_packed
+{
+	glm::uint64 a;
+	glm::dvec4 b;
+};
+GLM_STATIC_ASSERT(sizeof(my_dvec4_packed) == sizeof(glm::uint64) + sizeof(glm::dvec4), "glm::dvec4 packed is not correct");
+
+struct my_dvec4_aligned
+{
+	glm::uint64 a;
+	glm::aligned_dvec4 b;
+};
+//GLM_STATIC_ASSERT(sizeof(my_dvec4_aligned) == sizeof(glm::aligned_dvec4) * 2, "glm::dvec4 aligned is not correct");
+
+struct my_ivec4_packed
+{
+	glm::uint32 a;
+	glm::ivec4 b;
+};
+GLM_STATIC_ASSERT(sizeof(my_ivec4_packed) == sizeof(glm::uint32) + sizeof(glm::ivec4), "glm::ivec4 packed is not correct");
+
+struct my_ivec4_aligned
+{
+	glm::uint32 a;
+	glm::aligned_ivec4 b;
+};
+GLM_STATIC_ASSERT(sizeof(my_ivec4_aligned) == sizeof(glm::aligned_ivec4) * 2, "glm::ivec4 aligned is not correct");
+
+struct my_u8vec4_packed
+{
+	glm::uint32 a;
+	glm::u8vec4 b;
+};
+GLM_STATIC_ASSERT(sizeof(my_u8vec4_packed) == sizeof(glm::uint32) + sizeof(glm::u8vec4), "glm::u8vec4 packed is not correct");
+
+static int test_copy()
+{
+	int Error = 0;
+
+	{
+		glm::aligned_ivec4 const a(1, 2, 3, 4);
+		glm::ivec4 const u(a);
+
+		Error += a.x == u.x ? 0 : 1;
+		Error += a.y == u.y ? 0 : 1;
+		Error += a.z == u.z ? 0 : 1;
+		Error += a.w == u.w ? 0 : 1;
+	}
+
+	{
+		my_ivec4_aligned a;
+		a.b = glm::ivec4(1, 2, 3, 4);
+
+		my_ivec4_packed u;
+		u.b = a.b;
+
+		Error += a.b.x == u.b.x ? 0 : 1;
+		Error += a.b.y == u.b.y ? 0 : 1;
+		Error += a.b.z == u.b.z ? 0 : 1;
+		Error += a.b.w == u.b.w ? 0 : 1;
+	}
+
+	return Error;
+}
+
+static int test_ctor()
+{
+	int Error = 0;
+
+#	if GLM_HAS_CONSTEXPR
+	{
+		constexpr glm::aligned_ivec4 v(1);
+
+		Error += v.x == 1 ? 0 : 1;
+		Error += v.y == 1 ? 0 : 1;
+		Error += v.z == 1 ? 0 : 1;
+		Error += v.w == 1 ? 0 : 1;
+	}
+
+	{
+		constexpr glm::packed_ivec4 v(1);
+
+		Error += v.x == 1 ? 0 : 1;
+		Error += v.y == 1 ? 0 : 1;
+		Error += v.z == 1 ? 0 : 1;
+		Error += v.w == 1 ? 0 : 1;
+	}
+
+	{
+		constexpr glm::ivec4 v(1);
+
+		Error += v.x == 1 ? 0 : 1;
+		Error += v.y == 1 ? 0 : 1;
+		Error += v.z == 1 ? 0 : 1;
+		Error += v.w == 1 ? 0 : 1;
+	}
+#	endif//GLM_HAS_CONSTEXPR
+
+	return Error;
+}
+
+static int test_aligned_ivec4()
+{
+	int Error = 0;
+
+	glm::aligned_ivec4 const v(1, 2, 3, 4);
+	Error += glm::all(glm::equal(v, glm::aligned_ivec4(1, 2, 3, 4))) ? 0 : 1;
+
+	glm::aligned_ivec4 const u = v * 2;
+	Error += glm::all(glm::equal(u, glm::aligned_ivec4(2, 4, 6, 8))) ? 0 : 1;
+
+	return Error;
+}
+
+static int test_aligned_mat4()
+{
+	int Error = 0;
+
+	glm::aligned_vec4 const u(1.f, 2.f, 3.f, 4.f);
+	Error += glm::all(glm::equal(u, glm::aligned_vec4(1.f, 2.f, 3.f, 4.f), 0.0001f)) ? 0 : 1;
+
+	glm::aligned_vec4 const v(1, 2, 3, 4);
+	Error += glm::all(glm::equal(v, glm::aligned_vec4(1.f, 2.f, 3.f, 4.f), 0.0001f)) ? 0 : 1;
+
+	glm::aligned_mat4 const m(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
+	glm::aligned_mat4 const t = glm::transpose(m);
+	glm::aligned_mat4 const expected = glm::mat4(0, 4, 8, 12, 1, 5, 9, 13, 2, 6, 10, 14, 3, 7, 11, 15);
+	Error += glm::all(glm::equal(t, expected, 0.0001f)) ? 0 : 1;
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_ctor();
+	Error += test_copy();
+	Error += test_aligned_ivec4();
+	Error += test_aligned_mat4();
+
+	return Error;
+}
+
+#else
+
+int main()
+{
+	return 0;
+}
+
+#endif
diff --git a/3rdparty/glm/source/test/gtc/gtc_type_precision.cpp b/3rdparty/glm/source/test/gtc/gtc_type_precision.cpp
new file mode 100644
index 0000000..77f0686
--- /dev/null
+++ b/3rdparty/glm/source/test/gtc/gtc_type_precision.cpp
@@ -0,0 +1,1041 @@
+#include <glm/gtc/type_precision.hpp>
+#include <glm/gtc/quaternion.hpp>
+#include <glm/gtc/constants.hpp>
+#include <glm/ext/vector_relational.hpp>
+#include <vector>
+#if GLM_HAS_OPENMP
+#	include <omp.h>
+#endif
+
+#if GLM_HAS_STATIC_ASSERT
+static_assert(sizeof(glm::lowp_u8vec1) == 1, "uint8 size isn't 1 byte on this platform");
+static_assert(sizeof(glm::mediump_u8vec1) == 1, "uint8 size isn't 1 byte on this platform");
+static_assert(sizeof(glm::highp_u8vec1) == 1, "uint8 size isn't 1 byte on this platform");
+
+static_assert(sizeof(glm::lowp_u16vec1) == 2, "uint16 size isn't 2 bytes on this platform");
+static_assert(sizeof(glm::mediump_u16vec1) == 2, "uint16 size isn't 2 bytes on this platform");
+static_assert(sizeof(glm::highp_u16vec1) == 2, "uint16 size isn't 2 bytes on this platform");
+
+static_assert(sizeof(glm::lowp_u32vec1) == 4, "uint32 size isn't 4 bytes on this platform");
+static_assert(sizeof(glm::mediump_u32vec1) == 4, "uint32 size isn't 4 bytes on this platform");
+static_assert(sizeof(glm::highp_u32vec1) == 4, "uint32 size isn't 4 bytes on this platform");
+
+static_assert(sizeof(glm::lowp_u64vec1) == 8, "uint64 size isn't 8 bytes on this platform");
+static_assert(sizeof(glm::mediump_u64vec1) == 8, "uint64 size isn't 8 bytes on this platform");
+static_assert(sizeof(glm::highp_u64vec1) == 8, "uint64 size isn't 8 bytes on this platform");
+
+
+static_assert(sizeof(glm::lowp_u8vec2) == 2, "uint8 size isn't 1 byte on this platform");
+static_assert(sizeof(glm::mediump_u8vec2) == 2, "uint8 size isn't 1 byte on this platform");
+static_assert(sizeof(glm::highp_u8vec2) == 2, "uint8 size isn't 1 byte on this platform");
+
+static_assert(sizeof(glm::lowp_u16vec2) == 4, "uint16 size isn't 2 bytes on this platform");
+static_assert(sizeof(glm::mediump_u16vec2) == 4, "uint16 size isn't 2 bytes on this platform");
+static_assert(sizeof(glm::highp_u16vec2) == 4, "uint16 size isn't 2 bytes on this platform");
+
+static_assert(sizeof(glm::lowp_u32vec2) == 8, "uint32 size isn't 4 bytes on this platform");
+static_assert(sizeof(glm::mediump_u32vec2) == 8, "uint32 size isn't 4 bytes on this platform");
+static_assert(sizeof(glm::highp_u32vec2) == 8, "uint32 size isn't 4 bytes on this platform");
+
+static_assert(sizeof(glm::lowp_u64vec2) == 16, "uint64 size isn't 8 bytes on this platform");
+static_assert(sizeof(glm::mediump_u64vec2) == 16, "uint64 size isn't 8 bytes on this platform");
+static_assert(sizeof(glm::highp_u64vec2) == 16, "uint64 size isn't 8 bytes on this platform");
+
+
+static_assert(sizeof(glm::lowp_u8vec3) == 3, "uint8 size isn't 1 byte on this platform");
+static_assert(sizeof(glm::mediump_u8vec3) == 3, "uint8 size isn't 1 byte on this platform");
+static_assert(sizeof(glm::highp_u8vec3) == 3, "uint8 size isn't 1 byte on this platform");
+
+static_assert(sizeof(glm::lowp_u16vec3) == 6, "uint16 size isn't 2 bytes on this platform");
+static_assert(sizeof(glm::mediump_u16vec3) == 6, "uint16 size isn't 2 bytes on this platform");
+static_assert(sizeof(glm::highp_u16vec3) == 6, "uint16 size isn't 2 bytes on this platform");
+
+static_assert(sizeof(glm::lowp_u32vec3) == 12, "uint32 size isn't 4 bytes on this platform");
+static_assert(sizeof(glm::mediump_u32vec3) == 12, "uint32 size isn't 4 bytes on this platform");
+static_assert(sizeof(glm::highp_u32vec3) == 12, "uint32 size isn't 4 bytes on this platform");
+
+static_assert(sizeof(glm::lowp_u64vec3) == 24, "uint64 size isn't 8 bytes on this platform");
+static_assert(sizeof(glm::mediump_u64vec3) == 24, "uint64 size isn't 8 bytes on this platform");
+static_assert(sizeof(glm::highp_u64vec3) == 24, "uint64 size isn't 8 bytes on this platform");
+
+
+static_assert(sizeof(glm::lowp_u8vec4) == 4, "int8 size isn't 1 byte on this platform");
+static_assert(sizeof(glm::mediump_u8vec4) == 4, "int8 size isn't 1 byte on this platform");
+static_assert(sizeof(glm::highp_u8vec4) == 4, "int8 size isn't 1 byte on this platform");
+
+static_assert(sizeof(glm::lowp_u16vec4) == 8, "int16 size isn't 2 bytes on this platform");
+static_assert(sizeof(glm::mediump_u16vec4) == 8, "int16 size isn't 2 bytes on this platform");
+static_assert(sizeof(glm::highp_u16vec4) == 8, "int16 size isn't 2 bytes on this platform");
+
+static_assert(sizeof(glm::lowp_u32vec4) == 16, "int32 size isn't 4 bytes on this platform");
+static_assert(sizeof(glm::mediump_u32vec4) == 16, "int32 size isn't 4 bytes on this platform");
+static_assert(sizeof(glm::highp_u32vec4) == 16, "int32 size isn't 4 bytes on this platform");
+
+static_assert(sizeof(glm::lowp_u64vec4) == 32, "int64 size isn't 8 bytes on this platform");
+static_assert(sizeof(glm::mediump_u64vec4) == 32, "int64 size isn't 8 bytes on this platform");
+static_assert(sizeof(glm::highp_u64vec4) == 32, "int64 size isn't 8 bytes on this platform");
+
+
+static_assert(sizeof(glm::lowp_u8vec1) == 1, "uint8 size isn't 1 byte on this platform");
+static_assert(sizeof(glm::mediump_u8vec1) == 1, "uint8 size isn't 1 byte on this platform");
+static_assert(sizeof(glm::highp_u8vec1) == 1, "uint8 size isn't 1 byte on this platform");
+
+static_assert(sizeof(glm::lowp_u16vec1) == 2, "uint16 size isn't 2 bytes on this platform");
+static_assert(sizeof(glm::mediump_u16vec1) == 2, "uint16 size isn't 2 bytes on this platform");
+static_assert(sizeof(glm::highp_u16vec1) == 2, "uint16 size isn't 2 bytes on this platform");
+
+static_assert(sizeof(glm::lowp_u32vec1) == 4, "uint32 size isn't 4 bytes on this platform");
+static_assert(sizeof(glm::mediump_u32vec1) == 4, "uint32 size isn't 4 bytes on this platform");
+static_assert(sizeof(glm::highp_u32vec1) == 4, "uint32 size isn't 4 bytes on this platform");
+
+static_assert(sizeof(glm::lowp_u64vec1) == 8, "uint64 size isn't 8 bytes on this platform");
+static_assert(sizeof(glm::mediump_u64vec1) == 8, "uint64 size isn't 8 bytes on this platform");
+static_assert(sizeof(glm::highp_u64vec1) == 8, "uint64 size isn't 8 bytes on this platform");
+
+
+static_assert(sizeof(glm::lowp_u8vec2) == 2, "uint8 size isn't 1 byte on this platform");
+static_assert(sizeof(glm::mediump_u8vec2) == 2, "uint8 size isn't 1 byte on this platform");
+static_assert(sizeof(glm::highp_u8vec2) == 2, "uint8 size isn't 1 byte on this platform");
+
+static_assert(sizeof(glm::lowp_u16vec2) == 4, "uint16 size isn't 2 bytes on this platform");
+static_assert(sizeof(glm::mediump_u16vec2) == 4, "uint16 size isn't 2 bytes on this platform");
+static_assert(sizeof(glm::highp_u16vec2) == 4, "uint16 size isn't 2 bytes on this platform");
+
+static_assert(sizeof(glm::lowp_u32vec2) == 8, "uint32 size isn't 4 bytes on this platform");
+static_assert(sizeof(glm::mediump_u32vec2) == 8, "uint32 size isn't 4 bytes on this platform");
+static_assert(sizeof(glm::highp_u32vec2) == 8, "uint32 size isn't 4 bytes on this platform");
+
+static_assert(sizeof(glm::lowp_u64vec2) == 16, "uint64 size isn't 8 bytes on this platform");
+static_assert(sizeof(glm::mediump_u64vec2) == 16, "uint64 size isn't 8 bytes on this platform");
+static_assert(sizeof(glm::highp_u64vec2) == 16, "uint64 size isn't 8 bytes on this platform");
+
+
+static_assert(sizeof(glm::lowp_u8vec3) == 3, "uint8 size isn't 1 byte on this platform");
+static_assert(sizeof(glm::mediump_u8vec3) == 3, "uint8 size isn't 1 byte on this platform");
+static_assert(sizeof(glm::highp_u8vec3) == 3, "uint8 size isn't 1 byte on this platform");
+
+static_assert(sizeof(glm::lowp_u16vec3) == 6, "uint16 size isn't 2 bytes on this platform");
+static_assert(sizeof(glm::mediump_u16vec3) == 6, "uint16 size isn't 2 bytes on this platform");
+static_assert(sizeof(glm::highp_u16vec3) == 6, "uint16 size isn't 2 bytes on this platform");
+
+static_assert(sizeof(glm::lowp_u32vec3) == 12, "uint32 size isn't 4 bytes on this platform");
+static_assert(sizeof(glm::mediump_u32vec3) == 12, "uint32 size isn't 4 bytes on this platform");
+static_assert(sizeof(glm::highp_u32vec3) == 12, "uint32 size isn't 4 bytes on this platform");
+
+static_assert(sizeof(glm::lowp_u64vec3) == 24, "uint64 size isn't 8 bytes on this platform");
+static_assert(sizeof(glm::mediump_u64vec3) == 24, "uint64 size isn't 8 bytes on this platform");
+static_assert(sizeof(glm::highp_u64vec3) == 24, "uint64 size isn't 8 bytes on this platform");
+
+
+static_assert(sizeof(glm::lowp_u8vec4) == 4, "uint8 size isn't 1 byte on this platform");
+static_assert(sizeof(glm::mediump_u8vec4) == 4, "uint8 size isn't 1 byte on this platform");
+static_assert(sizeof(glm::highp_u8vec4) == 4, "uint8 size isn't 1 byte on this platform");
+
+static_assert(sizeof(glm::lowp_u16vec4) == 8, "uint16 size isn't 2 bytes on this platform");
+static_assert(sizeof(glm::mediump_u16vec4) == 8, "uint16 size isn't 2 bytes on this platform");
+static_assert(sizeof(glm::highp_u16vec4) == 8, "uint16 size isn't 2 bytes on this platform");
+
+static_assert(sizeof(glm::lowp_u32vec4) == 16, "uint32 size isn't 4 bytes on this platform");
+static_assert(sizeof(glm::mediump_u32vec4) == 16, "uint32 size isn't 4 bytes on this platform");
+static_assert(sizeof(glm::highp_u32vec4) == 16, "uint32 size isn't 4 bytes on this platform");
+
+static_assert(sizeof(glm::lowp_u64vec4) == 32, "uint64 size isn't 8 bytes on this platform");
+static_assert(sizeof(glm::mediump_u64vec4) == 32, "uint64 size isn't 8 bytes on this platform");
+static_assert(sizeof(glm::highp_u64vec4) == 32, "uint64 size isn't 8 bytes on this platform");
+
+#endif
+
+static int test_scalar_size()
+{
+	int Error = 0;
+
+	Error += sizeof(glm::int8) != 1;
+	Error += sizeof(glm::int16) != 2;
+	Error += sizeof(glm::int32) != 4;
+	Error += sizeof(glm::int64) != 8;
+	Error += sizeof(glm::uint8) != 1;
+	Error += sizeof(glm::uint16) != 2;
+	Error += sizeof(glm::uint32) != 4;
+	Error += sizeof(glm::uint64) != 8;
+	Error += sizeof(glm::float32) != 4;
+	Error += sizeof(glm::float64) != 8;
+
+	Error += sizeof(glm::lowp_int8) != 1;
+	Error += sizeof(glm::lowp_int16) != 2;
+	Error += sizeof(glm::lowp_int32) != 4;
+	Error += sizeof(glm::lowp_int64) != 8;
+	Error += sizeof(glm::lowp_uint8) != 1;
+	Error += sizeof(glm::lowp_uint16) != 2;
+	Error += sizeof(glm::lowp_uint32) != 4;
+	Error += sizeof(glm::lowp_uint64) != 8;
+	Error += sizeof(glm::lowp_float32) != 4;
+	Error += sizeof(glm::lowp_float64) != 8;
+
+	Error += sizeof(glm::mediump_int8) != 1;
+	Error += sizeof(glm::mediump_int16) != 2;
+	Error += sizeof(glm::mediump_int32) != 4;
+	Error += sizeof(glm::mediump_int64) != 8;
+	Error += sizeof(glm::mediump_uint8) != 1;
+	Error += sizeof(glm::mediump_uint16) != 2;
+	Error += sizeof(glm::mediump_uint32) != 4;
+	Error += sizeof(glm::mediump_uint64) != 8;
+	Error += sizeof(glm::mediump_float32) != 4;
+	Error += sizeof(glm::mediump_float64) != 8;
+
+	Error += sizeof(glm::highp_int8) != 1;
+	Error += sizeof(glm::highp_int16) != 2;
+	Error += sizeof(glm::highp_int32) != 4;
+	Error += sizeof(glm::highp_int64) != 8;
+	Error += sizeof(glm::highp_uint8) != 1;
+	Error += sizeof(glm::highp_uint16) != 2;
+	Error += sizeof(glm::highp_uint32) != 4;
+	Error += sizeof(glm::highp_uint64) != 8;
+	Error += sizeof(glm::highp_float32) != 4;
+	Error += sizeof(glm::highp_float64) != 8;
+
+	return Error;
+}
+
+static int test_fvec_size()
+{
+	int Error = 0;
+
+	Error += sizeof(glm::f32vec2) != 8;
+	Error += sizeof(glm::f32vec3) != 12;
+	Error += sizeof(glm::f32vec4) != 16;
+	Error += sizeof(glm::f64vec2) != 16;
+	Error += sizeof(glm::f64vec3) != 24;
+	Error += sizeof(glm::f64vec4) != 32;
+
+	Error += sizeof(glm::lowp_f32vec2) != 8;
+	Error += sizeof(glm::lowp_f32vec3) != 12;
+	Error += sizeof(glm::lowp_f32vec4) != 16;
+	Error += sizeof(glm::lowp_f64vec2) != 16;
+	Error += sizeof(glm::lowp_f64vec3) != 24;
+	Error += sizeof(glm::lowp_f64vec4) != 32;
+
+	Error += sizeof(glm::mediump_f32vec2) != 8;
+	Error += sizeof(glm::mediump_f32vec3) != 12;
+	Error += sizeof(glm::mediump_f32vec4) != 16;
+	Error += sizeof(glm::mediump_f64vec2) != 16;
+	Error += sizeof(glm::mediump_f64vec3) != 24;
+	Error += sizeof(glm::mediump_f64vec4) != 32;
+
+	Error += sizeof(glm::highp_f32vec2) != 8;
+	Error += sizeof(glm::highp_f32vec3) != 12;
+	Error += sizeof(glm::highp_f32vec4) != 16;
+	Error += sizeof(glm::highp_f64vec2) != 16;
+	Error += sizeof(glm::highp_f64vec3) != 24;
+	Error += sizeof(glm::highp_f64vec4) != 32;
+
+	return Error;
+}
+
+static int test_fvec_precision()
+{
+	int Error = 0;
+
+	{
+		glm::f32vec2 v1(1.f);
+		glm::lowp_f32vec2 v2(v1);
+		glm::mediump_f32vec2 v3(v1);
+		glm::highp_f32vec2 v4(v1);
+
+		Error += glm::all(glm::equal(v1, glm::f32vec2(v2), glm::epsilon<float>())) ? 0 : 1;
+		Error += glm::all(glm::equal(v1, glm::f32vec2(v3), glm::epsilon<float>())) ? 0 : 1;
+		Error += glm::all(glm::equal(v1, glm::f32vec2(v4), glm::epsilon<float>())) ? 0 : 1;
+	}
+
+	{
+		glm::f32vec3 v1(1.f);
+		glm::lowp_f32vec3 v2(v1);
+		glm::mediump_f32vec3 v3(v1);
+		glm::highp_f32vec3 v4(v1);
+
+		Error += glm::all(glm::equal(v1, glm::f32vec3(v2), glm::epsilon<float>())) ? 0 : 1;
+		Error += glm::all(glm::equal(v1, glm::f32vec3(v3), glm::epsilon<float>())) ? 0 : 1;
+		Error += glm::all(glm::equal(v1, glm::f32vec3(v4), glm::epsilon<float>())) ? 0 : 1;
+	}
+	
+	{
+		glm::f32vec4 v1(1.f);
+		glm::lowp_f32vec4 v2(v1);
+		glm::mediump_f32vec4 v3(v1);
+		glm::highp_f32vec4 v4(v1);
+
+		Error += glm::all(glm::equal(v1, glm::f32vec4(v2), glm::epsilon<float>())) ? 0 : 1;
+		Error += glm::all(glm::equal(v1, glm::f32vec4(v3), glm::epsilon<float>())) ? 0 : 1;
+		Error += glm::all(glm::equal(v1, glm::f32vec4(v4), glm::epsilon<float>())) ? 0 : 1;
+	}
+	
+	return Error;
+}
+
+static int test_dvec_precision()
+{
+	int Error = 0;
+
+	{
+		glm::f64vec2 v1(1.0);
+		glm::lowp_f64vec2 v2(v1);
+		glm::mediump_f64vec2 v3(v1);
+		glm::highp_f64vec2 v4(v1);
+
+		Error += glm::all(glm::equal(v1, glm::f64vec2(v2), glm::epsilon<double>())) ? 0 : 1;
+		Error += glm::all(glm::equal(v1, glm::f64vec2(v3), glm::epsilon<double>())) ? 0 : 1;
+		Error += glm::all(glm::equal(v1, glm::f64vec2(v4), glm::epsilon<double>())) ? 0 : 1;
+	}
+
+	{
+		glm::f64vec3 v1(1.0);
+		glm::lowp_f64vec3 v2(v1);
+		glm::mediump_f64vec3 v3(v1);
+		glm::highp_f64vec3 v4(v1);
+
+		Error += glm::all(glm::equal(v1, glm::f64vec3(v2), glm::epsilon<double>())) ? 0 : 1;
+		Error += glm::all(glm::equal(v1, glm::f64vec3(v3), glm::epsilon<double>())) ? 0 : 1;
+		Error += glm::all(glm::equal(v1, glm::f64vec3(v4), glm::epsilon<double>())) ? 0 : 1;
+	}
+
+	{
+		glm::f64vec4 v1(1.0);
+		glm::lowp_f64vec4 v2(v1);
+		glm::mediump_f64vec4 v3(v1);
+		glm::highp_f64vec4 v4(v1);
+
+		Error += glm::all(glm::equal(v1, glm::f64vec4(v2), glm::epsilon<double>())) ? 0 : 1;
+		Error += glm::all(glm::equal(v1, glm::f64vec4(v3), glm::epsilon<double>())) ? 0 : 1;
+		Error += glm::all(glm::equal(v1, glm::f64vec4(v4), glm::epsilon<double>())) ? 0 : 1;
+	}
+
+	return Error;
+}
+
+static int test_ivec_size()
+{
+	int Error = 0;
+
+	Error += sizeof(glm::i8vec2) != 2;
+	Error += sizeof(glm::i8vec3) != 3;
+	Error += sizeof(glm::i8vec4) != 4;
+	Error += sizeof(glm::i16vec2) != 4;
+	Error += sizeof(glm::i16vec3) != 6;
+	Error += sizeof(glm::i16vec4) != 8;
+	Error += sizeof(glm::i32vec2) != 8;
+	Error += sizeof(glm::i32vec3) != 12;
+	Error += sizeof(glm::i32vec4) != 16;
+	Error += sizeof(glm::i64vec2) != 16;
+	Error += sizeof(glm::i64vec3) != 24;
+	Error += sizeof(glm::i64vec4) != 32;
+
+	Error += sizeof(glm::lowp_i8vec2) != 2;
+	Error += sizeof(glm::lowp_i8vec3) != 3;
+	Error += sizeof(glm::lowp_i8vec4) != 4;
+	Error += sizeof(glm::lowp_i16vec2) != 4;
+	Error += sizeof(glm::lowp_i16vec3) != 6;
+	Error += sizeof(glm::lowp_i16vec4) != 8;
+	Error += sizeof(glm::lowp_i32vec2) != 8;
+	Error += sizeof(glm::lowp_i32vec3) != 12;
+	Error += sizeof(glm::lowp_i32vec4) != 16;
+	Error += sizeof(glm::lowp_i64vec2) != 16;
+	Error += sizeof(glm::lowp_i64vec3) != 24;
+	Error += sizeof(glm::lowp_i64vec4) != 32;
+
+	Error += sizeof(glm::mediump_i8vec2) != 2;
+	Error += sizeof(glm::mediump_i8vec3) != 3;
+	Error += sizeof(glm::mediump_i8vec4) != 4;
+	Error += sizeof(glm::mediump_i16vec2) != 4;
+	Error += sizeof(glm::mediump_i16vec3) != 6;
+	Error += sizeof(glm::mediump_i16vec4) != 8;
+	Error += sizeof(glm::mediump_i32vec2) != 8;
+	Error += sizeof(glm::mediump_i32vec3) != 12;
+	Error += sizeof(glm::mediump_i32vec4) != 16;
+	Error += sizeof(glm::mediump_i64vec2) != 16;
+	Error += sizeof(glm::mediump_i64vec3) != 24;
+	Error += sizeof(glm::mediump_i64vec4) != 32;
+
+	Error += sizeof(glm::highp_i8vec2) != 2;
+	Error += sizeof(glm::highp_i8vec3) != 3;
+	Error += sizeof(glm::highp_i8vec4) != 4;
+	Error += sizeof(glm::highp_i16vec2) != 4;
+	Error += sizeof(glm::highp_i16vec3) != 6;
+	Error += sizeof(glm::highp_i16vec4) != 8;
+	Error += sizeof(glm::highp_i32vec2) != 8;
+	Error += sizeof(glm::highp_i32vec3) != 12;
+	Error += sizeof(glm::highp_i32vec4) != 16;
+	Error += sizeof(glm::highp_i64vec2) != 16;
+	Error += sizeof(glm::highp_i64vec3) != 24;
+	Error += sizeof(glm::highp_i64vec4) != 32;
+
+	return Error;
+}
+
+static int test_ivec_precision()
+{
+	int Error = 0;
+
+	{
+		glm::i8vec2 v1(0);
+		glm::lowp_i8vec2 v2(v1);
+		glm::mediump_i8vec2 v3(v1);
+		glm::highp_i8vec2 v4(v1);
+
+		Error += glm::all(glm::equal(v1, glm::i8vec2(v2))) ? 0 : 1;
+		Error += glm::all(glm::equal(v1, glm::i8vec2(v3))) ? 0 : 1;
+		Error += glm::all(glm::equal(v1, glm::i8vec2(v4))) ? 0 : 1;
+	}
+
+	{
+		glm::i8vec3 v1(0);
+		glm::lowp_i8vec3 v2(v1);
+		glm::mediump_i8vec3 v3(v1);
+		glm::highp_i8vec3 v4(v1);
+
+		Error += glm::all(glm::equal(v1, glm::i8vec3(v2))) ? 0 : 1;
+		Error += glm::all(glm::equal(v1, glm::i8vec3(v3))) ? 0 : 1;
+		Error += glm::all(glm::equal(v1, glm::i8vec3(v4))) ? 0 : 1;
+	}
+
+	{
+		glm::i8vec4 v1(0);
+		glm::lowp_i8vec4 v2(v1);
+		glm::mediump_i8vec4 v3(v1);
+		glm::highp_i8vec4 v4(v1);
+
+		Error += glm::all(glm::equal(v1, glm::i8vec4(v2))) ? 0 : 1;
+		Error += glm::all(glm::equal(v1, glm::i8vec4(v3))) ? 0 : 1;
+		Error += glm::all(glm::equal(v1, glm::i8vec4(v4))) ? 0 : 1;
+	}
+
+	{
+		glm::i16vec2 v1(0);
+		glm::lowp_i16vec2 v2(v1);
+		glm::mediump_i16vec2 v3(v1);
+		glm::highp_i16vec2 v4(v1);
+
+		Error += glm::all(glm::equal(v1, glm::i16vec2(v2))) ? 0 : 1;
+		Error += glm::all(glm::equal(v1, glm::i16vec2(v3))) ? 0 : 1;
+		Error += glm::all(glm::equal(v1, glm::i16vec2(v4))) ? 0 : 1;
+	}
+
+	{
+		glm::i16vec3 v1(0);
+		glm::lowp_i16vec3 v2(v1);
+		glm::mediump_i16vec3 v3(v1);
+		glm::highp_i16vec3 v4(v1);
+
+		Error += glm::all(glm::equal(v1, glm::i16vec3(v2))) ? 0 : 1;
+		Error += glm::all(glm::equal(v1, glm::i16vec3(v3))) ? 0 : 1;
+		Error += glm::all(glm::equal(v1, glm::i16vec3(v4))) ? 0 : 1;
+	}
+
+	{
+		glm::i16vec4 v1(0);
+		glm::lowp_i16vec4 v2(v1);
+		glm::mediump_i16vec4 v3(v1);
+		glm::highp_i16vec4 v4(v1);
+
+		Error += glm::all(glm::equal(v1, glm::i16vec4(v2))) ? 0 : 1;
+		Error += glm::all(glm::equal(v1, glm::i16vec4(v3))) ? 0 : 1;
+		Error += glm::all(glm::equal(v1, glm::i16vec4(v4))) ? 0 : 1;
+	}
+
+	{
+		glm::i32vec2 v1(0);
+		glm::lowp_i32vec2 v2(v1);
+		glm::mediump_i32vec2 v3(v1);
+		glm::highp_i32vec2 v4(v1);
+
+		Error += glm::all(glm::equal(v1, glm::i32vec2(v2))) ? 0 : 1;
+		Error += glm::all(glm::equal(v1, glm::i32vec2(v3))) ? 0 : 1;
+		Error += glm::all(glm::equal(v1, glm::i32vec2(v4))) ? 0 : 1;
+	}
+
+	{
+		glm::i32vec3 v1(0);
+		glm::lowp_i32vec3 v2(v1);
+		glm::mediump_i32vec3 v3(v1);
+		glm::highp_i32vec3 v4(v1);
+
+		Error += glm::all(glm::equal(v1, glm::i32vec3(v2))) ? 0 : 1;
+		Error += glm::all(glm::equal(v1, glm::i32vec3(v3))) ? 0 : 1;
+		Error += glm::all(glm::equal(v1, glm::i32vec3(v4))) ? 0 : 1;
+	}
+
+	{
+		glm::i32vec4 v1(0);
+		glm::lowp_i32vec4 v2(v1);
+		glm::mediump_i32vec4 v3(v1);
+		glm::highp_i32vec4 v4(v1);
+
+		Error += glm::all(glm::equal(v1, glm::i32vec4(v2))) ? 0 : 1;
+		Error += glm::all(glm::equal(v1, glm::i32vec4(v3))) ? 0 : 1;
+		Error += glm::all(glm::equal(v1, glm::i32vec4(v4))) ? 0 : 1;
+	}
+
+	{
+		glm::i64vec2 v1(0);
+		glm::lowp_i64vec2 v2(v1);
+		glm::mediump_i64vec2 v3(v1);
+		glm::highp_i64vec2 v4(v1);
+
+		Error += glm::all(glm::equal(v1, glm::i64vec2(v2))) ? 0 : 1;
+		Error += glm::all(glm::equal(v1, glm::i64vec2(v3))) ? 0 : 1;
+		Error += glm::all(glm::equal(v1, glm::i64vec2(v4))) ? 0 : 1;
+	}
+
+	{
+		glm::i64vec3 v1(0);
+		glm::lowp_i64vec3 v2(v1);
+		glm::mediump_i64vec3 v3(v1);
+		glm::highp_i64vec3 v4(v1);
+
+		Error += glm::all(glm::equal(v1, glm::i64vec3(v2))) ? 0 : 1;
+		Error += glm::all(glm::equal(v1, glm::i64vec3(v3))) ? 0 : 1;
+		Error += glm::all(glm::equal(v1, glm::i64vec3(v4))) ? 0 : 1;
+	}
+
+	{
+		glm::i64vec4 v1(0);
+		glm::lowp_i64vec4 v2(v1);
+		glm::mediump_i64vec4 v3(v1);
+		glm::highp_i64vec4 v4(v1);
+
+		Error += glm::all(glm::equal(v1, glm::i64vec4(v2))) ? 0 : 1;
+		Error += glm::all(glm::equal(v1, glm::i64vec4(v3))) ? 0 : 1;
+		Error += glm::all(glm::equal(v1, glm::i64vec4(v4))) ? 0 : 1;
+	}
+
+	return Error;
+}
+
+static int test_uvec_size()
+{
+	int Error = 0;
+
+	Error += sizeof(glm::u8vec2) != 2;
+	Error += sizeof(glm::u8vec3) != 3;
+	Error += sizeof(glm::u8vec4) != 4;
+	Error += sizeof(glm::u16vec2) != 4;
+	Error += sizeof(glm::u16vec3) != 6;
+	Error += sizeof(glm::u16vec4) != 8;
+	Error += sizeof(glm::u32vec2) != 8;
+	Error += sizeof(glm::u32vec3) != 12;
+	Error += sizeof(glm::u32vec4) != 16;
+	Error += sizeof(glm::u64vec2) != 16;
+	Error += sizeof(glm::u64vec3) != 24;
+	Error += sizeof(glm::u64vec4) != 32;
+
+	Error += sizeof(glm::lowp_u8vec2) != 2;
+	Error += sizeof(glm::lowp_u8vec3) != 3;
+	Error += sizeof(glm::lowp_u8vec4) != 4;
+	Error += sizeof(glm::lowp_u16vec2) != 4;
+	Error += sizeof(glm::lowp_u16vec3) != 6;
+	Error += sizeof(glm::lowp_u16vec4) != 8;
+	Error += sizeof(glm::lowp_u32vec2) != 8;
+	Error += sizeof(glm::lowp_u32vec3) != 12;
+	Error += sizeof(glm::lowp_u32vec4) != 16;
+	Error += sizeof(glm::lowp_u64vec2) != 16;
+	Error += sizeof(glm::lowp_u64vec3) != 24;
+	Error += sizeof(glm::lowp_u64vec4) != 32;
+
+	Error += sizeof(glm::mediump_u8vec2) != 2;
+	Error += sizeof(glm::mediump_u8vec3) != 3;
+	Error += sizeof(glm::mediump_u8vec4) != 4;
+	Error += sizeof(glm::mediump_u16vec2) != 4;
+	Error += sizeof(glm::mediump_u16vec3) != 6;
+	Error += sizeof(glm::mediump_u16vec4) != 8;
+	Error += sizeof(glm::mediump_u32vec2) != 8;
+	Error += sizeof(glm::mediump_u32vec3) != 12;
+	Error += sizeof(glm::mediump_u32vec4) != 16;
+	Error += sizeof(glm::mediump_u64vec2) != 16;
+	Error += sizeof(glm::mediump_u64vec3) != 24;
+	Error += sizeof(glm::mediump_u64vec4) != 32;
+
+	Error += sizeof(glm::highp_u8vec2) != 2;
+	Error += sizeof(glm::highp_u8vec3) != 3;
+	Error += sizeof(glm::highp_u8vec4) != 4;
+	Error += sizeof(glm::highp_u16vec2) != 4;
+	Error += sizeof(glm::highp_u16vec3) != 6;
+	Error += sizeof(glm::highp_u16vec4) != 8;
+	Error += sizeof(glm::highp_u32vec2) != 8;
+	Error += sizeof(glm::highp_u32vec3) != 12;
+	Error += sizeof(glm::highp_u32vec4) != 16;
+	Error += sizeof(glm::highp_u64vec2) != 16;
+	Error += sizeof(glm::highp_u64vec3) != 24;
+	Error += sizeof(glm::highp_u64vec4) != 32;
+
+	return Error;
+}
+
+static int test_uvec_precision()
+{
+	int Error = 0;
+
+	{
+		glm::u8vec2 v1(0);
+		glm::lowp_u8vec2 v2(v1);
+		glm::mediump_u8vec2 v3(v1);
+		glm::highp_u8vec2 v4(v1);
+
+		Error += glm::all(glm::equal(v1, glm::u8vec2(v2))) ? 0 : 1;
+		Error += glm::all(glm::equal(v1, glm::u8vec2(v3))) ? 0 : 1;
+		Error += glm::all(glm::equal(v1, glm::u8vec2(v4))) ? 0 : 1;
+	}
+
+	{
+		glm::u8vec3 v1(0);
+		glm::lowp_u8vec3 v2(v1);
+		glm::mediump_u8vec3 v3(v1);
+		glm::highp_u8vec3 v4(v1);
+
+		Error += glm::all(glm::equal(v1, glm::u8vec3(v2))) ? 0 : 1;
+		Error += glm::all(glm::equal(v1, glm::u8vec3(v3))) ? 0 : 1;
+		Error += glm::all(glm::equal(v1, glm::u8vec3(v4))) ? 0 : 1;
+	}
+	
+	{
+		glm::u8vec4 v1(0);
+		glm::lowp_u8vec4 v2(v1);
+		glm::mediump_u8vec4 v3(v1);
+		glm::highp_u8vec4 v4(v1);
+
+		Error += glm::all(glm::equal(v1, glm::u8vec4(v2))) ? 0 : 1;
+		Error += glm::all(glm::equal(v1, glm::u8vec4(v3))) ? 0 : 1;
+		Error += glm::all(glm::equal(v1, glm::u8vec4(v4))) ? 0 : 1;
+	}
+
+	{
+		glm::u16vec2 v1(0);
+		glm::lowp_u16vec2 v2(v1);
+		glm::mediump_u16vec2 v3(v1);
+		glm::highp_u16vec2 v4(v1);
+
+		Error += glm::all(glm::equal(v1, glm::u16vec2(v2))) ? 0 : 1;
+		Error += glm::all(glm::equal(v1, glm::u16vec2(v3))) ? 0 : 1;
+		Error += glm::all(glm::equal(v1, glm::u16vec2(v4))) ? 0 : 1;
+	}
+
+	{
+		glm::u16vec3 v1(0);
+		glm::lowp_u16vec3 v2(v1);
+		glm::mediump_u16vec3 v3(v1);
+		glm::highp_u16vec3 v4(v1);
+
+		Error += glm::all(glm::equal(v1, glm::u16vec3(v2))) ? 0 : 1;
+		Error += glm::all(glm::equal(v1, glm::u16vec3(v3))) ? 0 : 1;
+		Error += glm::all(glm::equal(v1, glm::u16vec3(v4))) ? 0 : 1;
+	}
+	
+	{
+		glm::u16vec4 v1(0);
+		glm::lowp_u16vec4 v2(v1);
+		glm::mediump_u16vec4 v3(v1);
+		glm::highp_u16vec4 v4(v1);
+
+		Error += glm::all(glm::equal(v1, glm::u16vec4(v2))) ? 0 : 1;
+		Error += glm::all(glm::equal(v1, glm::u16vec4(v3))) ? 0 : 1;
+		Error += glm::all(glm::equal(v1, glm::u16vec4(v4))) ? 0 : 1;
+	}
+
+	{
+		glm::u32vec2 v1(0);
+		glm::lowp_u32vec2 v2(v1);
+		glm::mediump_u32vec2 v3(v1);
+		glm::highp_u32vec2 v4(v1);
+
+		Error += glm::all(glm::equal(v1, glm::u32vec2(v2))) ? 0 : 1;
+		Error += glm::all(glm::equal(v1, glm::u32vec2(v3))) ? 0 : 1;
+		Error += glm::all(glm::equal(v1, glm::u32vec2(v4))) ? 0 : 1;
+	}
+
+	{
+		glm::u32vec3 v1(0);
+		glm::lowp_u32vec3 v2(v1);
+		glm::mediump_u32vec3 v3(v1);
+		glm::highp_u32vec3 v4(v1);
+
+		Error += glm::all(glm::equal(v1, glm::u32vec3(v2))) ? 0 : 1;
+		Error += glm::all(glm::equal(v1, glm::u32vec3(v3))) ? 0 : 1;
+		Error += glm::all(glm::equal(v1, glm::u32vec3(v4))) ? 0 : 1;
+	}
+	
+	{
+		glm::u32vec4 v1(0);
+		glm::lowp_u32vec4 v2(v1);
+		glm::mediump_u32vec4 v3(v1);
+		glm::highp_u32vec4 v4(v1);
+
+		Error += glm::all(glm::equal(v1, glm::u32vec4(v2))) ? 0 : 1;
+		Error += glm::all(glm::equal(v1, glm::u32vec4(v3))) ? 0 : 1;
+		Error += glm::all(glm::equal(v1, glm::u32vec4(v4))) ? 0 : 1;
+	}
+	
+	{
+		glm::u64vec2 v1(0);
+		glm::lowp_u64vec2 v2(v1);
+		glm::mediump_u64vec2 v3(v1);
+		glm::highp_u64vec2 v4(v1);
+
+		Error += glm::all(glm::equal(v1, glm::u64vec2(v2))) ? 0 : 1;
+		Error += glm::all(glm::equal(v1, glm::u64vec2(v3))) ? 0 : 1;
+		Error += glm::all(glm::equal(v1, glm::u64vec2(v4))) ? 0 : 1;
+	}
+
+	{
+		glm::u64vec3 v1(0);
+		glm::lowp_u64vec3 v2(v1);
+		glm::mediump_u64vec3 v3(v1);
+		glm::highp_u64vec3 v4(v1);
+
+		Error += glm::all(glm::equal(v1, glm::u64vec3(v2))) ? 0 : 1;
+		Error += glm::all(glm::equal(v1, glm::u64vec3(v3))) ? 0 : 1;
+		Error += glm::all(glm::equal(v1, glm::u64vec3(v4))) ? 0 : 1;
+	}
+	
+	{
+		glm::u64vec4 v1(0);
+		glm::lowp_u64vec4 v2(v1);
+		glm::mediump_u64vec4 v3(v1);
+		glm::highp_u64vec4 v4(v1);
+
+		Error += glm::all(glm::equal(v1, glm::u64vec4(v2))) ? 0 : 1;
+		Error += glm::all(glm::equal(v1, glm::u64vec4(v3))) ? 0 : 1;
+		Error += glm::all(glm::equal(v1, glm::u64vec4(v4))) ? 0 : 1;
+	}
+	
+	return Error;
+}
+
+static int test_fmat_size()
+{
+	int Error = 0;
+
+	Error += sizeof(glm::mat2) != 16;
+	Error += sizeof(glm::mat3) != 36;
+	Error += sizeof(glm::mat4) != 64;
+	Error += sizeof(glm::mat2x2) != 16;
+	Error += sizeof(glm::mat2x3) != 24;
+	Error += sizeof(glm::mat2x4) != 32;
+	Error += sizeof(glm::mat3x2) != 24;
+	Error += sizeof(glm::mat3x3) != 36;
+	Error += sizeof(glm::mat3x4) != 48;
+	Error += sizeof(glm::mat4x2) != 32;
+	Error += sizeof(glm::mat4x3) != 48;
+	Error += sizeof(glm::mat4x4) != 64;
+
+	Error += sizeof(glm::fmat2) != 16;
+	Error += sizeof(glm::fmat3) != 36;
+	Error += sizeof(glm::fmat4) != 64;
+	Error += sizeof(glm::fmat2x2) != 16;
+	Error += sizeof(glm::fmat2x3) != 24;
+	Error += sizeof(glm::fmat2x4) != 32;
+	Error += sizeof(glm::fmat3x2) != 24;
+	Error += sizeof(glm::fmat3x3) != 36;
+	Error += sizeof(glm::fmat3x4) != 48;
+	Error += sizeof(glm::fmat4x2) != 32;
+	Error += sizeof(glm::fmat4x3) != 48;
+	Error += sizeof(glm::fmat4x4) != 64;
+
+	Error += sizeof(glm::f32mat2) != 16;
+	Error += sizeof(glm::f32mat3) != 36;
+	Error += sizeof(glm::f32mat4) != 64;
+	Error += sizeof(glm::f32mat2x2) != 16;
+	Error += sizeof(glm::f32mat2x3) != 24;
+	Error += sizeof(glm::f32mat2x4) != 32;
+	Error += sizeof(glm::f32mat3x2) != 24;
+	Error += sizeof(glm::f32mat3x3) != 36;
+	Error += sizeof(glm::f32mat3x4) != 48;
+	Error += sizeof(glm::f32mat4x2) != 32;
+	Error += sizeof(glm::f32mat4x3) != 48;
+	Error += sizeof(glm::f32mat4x4) != 64;
+
+
+	Error += sizeof(glm::lowp_mat2) != 16;
+	Error += sizeof(glm::lowp_mat3) != 36;
+	Error += sizeof(glm::lowp_mat4) != 64;
+	Error += sizeof(glm::lowp_mat2x2) != 16;
+	Error += sizeof(glm::lowp_mat2x3) != 24;
+	Error += sizeof(glm::lowp_mat2x4) != 32;
+	Error += sizeof(glm::lowp_mat3x2) != 24;
+	Error += sizeof(glm::lowp_mat3x3) != 36;
+	Error += sizeof(glm::lowp_mat3x4) != 48;
+	Error += sizeof(glm::lowp_mat4x2) != 32;
+	Error += sizeof(glm::lowp_mat4x3) != 48;
+	Error += sizeof(glm::lowp_mat4x4) != 64;
+
+	Error += sizeof(glm::lowp_fmat2) != 16;
+	Error += sizeof(glm::lowp_fmat3) != 36;
+	Error += sizeof(glm::lowp_fmat4) != 64;
+	Error += sizeof(glm::lowp_fmat2x2) != 16;
+	Error += sizeof(glm::lowp_fmat2x3) != 24;
+	Error += sizeof(glm::lowp_fmat2x4) != 32;
+	Error += sizeof(glm::lowp_fmat3x2) != 24;
+	Error += sizeof(glm::lowp_fmat3x3) != 36;
+	Error += sizeof(glm::lowp_fmat3x4) != 48;
+	Error += sizeof(glm::lowp_fmat4x2) != 32;
+	Error += sizeof(glm::lowp_fmat4x3) != 48;
+	Error += sizeof(glm::lowp_fmat4x4) != 64;
+
+	Error += sizeof(glm::lowp_f32mat2) != 16;
+	Error += sizeof(glm::lowp_f32mat3) != 36;
+	Error += sizeof(glm::lowp_f32mat4) != 64;
+	Error += sizeof(glm::lowp_f32mat2x2) != 16;
+	Error += sizeof(glm::lowp_f32mat2x3) != 24;
+	Error += sizeof(glm::lowp_f32mat2x4) != 32;
+	Error += sizeof(glm::lowp_f32mat3x2) != 24;
+	Error += sizeof(glm::lowp_f32mat3x3) != 36;
+	Error += sizeof(glm::lowp_f32mat3x4) != 48;
+	Error += sizeof(glm::lowp_f32mat4x2) != 32;
+	Error += sizeof(glm::lowp_f32mat4x3) != 48;
+	Error += sizeof(glm::lowp_f32mat4x4) != 64;
+
+	Error += sizeof(glm::mediump_mat2) != 16;
+	Error += sizeof(glm::mediump_mat3) != 36;
+	Error += sizeof(glm::mediump_mat4) != 64;
+	Error += sizeof(glm::mediump_mat2x2) != 16;
+	Error += sizeof(glm::mediump_mat2x3) != 24;
+	Error += sizeof(glm::mediump_mat2x4) != 32;
+	Error += sizeof(glm::mediump_mat3x2) != 24;
+	Error += sizeof(glm::mediump_mat3x3) != 36;
+	Error += sizeof(glm::mediump_mat3x4) != 48;
+	Error += sizeof(glm::mediump_mat4x2) != 32;
+	Error += sizeof(glm::mediump_mat4x3) != 48;
+	Error += sizeof(glm::mediump_mat4x4) != 64;
+
+	Error += sizeof(glm::mediump_fmat2) != 16;
+	Error += sizeof(glm::mediump_fmat3) != 36;
+	Error += sizeof(glm::mediump_fmat4) != 64;
+	Error += sizeof(glm::mediump_fmat2x2) != 16;
+	Error += sizeof(glm::mediump_fmat2x3) != 24;
+	Error += sizeof(glm::mediump_fmat2x4) != 32;
+	Error += sizeof(glm::mediump_fmat3x2) != 24;
+	Error += sizeof(glm::mediump_fmat3x3) != 36;
+	Error += sizeof(glm::mediump_fmat3x4) != 48;
+	Error += sizeof(glm::mediump_fmat4x2) != 32;
+	Error += sizeof(glm::mediump_fmat4x3) != 48;
+	Error += sizeof(glm::mediump_fmat4x4) != 64;
+
+	Error += sizeof(glm::mediump_f32mat2) != 16;
+	Error += sizeof(glm::mediump_f32mat3) != 36;
+	Error += sizeof(glm::mediump_f32mat4) != 64;
+	Error += sizeof(glm::mediump_f32mat2x2) != 16;
+	Error += sizeof(glm::mediump_f32mat2x3) != 24;
+	Error += sizeof(glm::mediump_f32mat2x4) != 32;
+	Error += sizeof(glm::mediump_f32mat3x2) != 24;
+	Error += sizeof(glm::mediump_f32mat3x3) != 36;
+	Error += sizeof(glm::mediump_f32mat3x4) != 48;
+	Error += sizeof(glm::mediump_f32mat4x2) != 32;
+	Error += sizeof(glm::mediump_f32mat4x3) != 48;
+	Error += sizeof(glm::mediump_f32mat4x4) != 64;
+
+	Error += sizeof(glm::highp_mat2) != 16;
+	Error += sizeof(glm::highp_mat3) != 36;
+	Error += sizeof(glm::highp_mat4) != 64;
+	Error += sizeof(glm::highp_mat2x2) != 16;
+	Error += sizeof(glm::highp_mat2x3) != 24;
+	Error += sizeof(glm::highp_mat2x4) != 32;
+	Error += sizeof(glm::highp_mat3x2) != 24;
+	Error += sizeof(glm::highp_mat3x3) != 36;
+	Error += sizeof(glm::highp_mat3x4) != 48;
+	Error += sizeof(glm::highp_mat4x2) != 32;
+	Error += sizeof(glm::highp_mat4x3) != 48;
+	Error += sizeof(glm::highp_mat4x4) != 64;
+
+	Error += sizeof(glm::highp_fmat2) != 16;
+	Error += sizeof(glm::highp_fmat3) != 36;
+	Error += sizeof(glm::highp_fmat4) != 64;
+	Error += sizeof(glm::highp_fmat2x2) != 16;
+	Error += sizeof(glm::highp_fmat2x3) != 24;
+	Error += sizeof(glm::highp_fmat2x4) != 32;
+	Error += sizeof(glm::highp_fmat3x2) != 24;
+	Error += sizeof(glm::highp_fmat3x3) != 36;
+	Error += sizeof(glm::highp_fmat3x4) != 48;
+	Error += sizeof(glm::highp_fmat4x2) != 32;
+	Error += sizeof(glm::highp_fmat4x3) != 48;
+	Error += sizeof(glm::highp_fmat4x4) != 64;
+
+	Error += sizeof(glm::highp_f32mat2) != 16;
+	Error += sizeof(glm::highp_f32mat3) != 36;
+	Error += sizeof(glm::highp_f32mat4) != 64;
+	Error += sizeof(glm::highp_f32mat2x2) != 16;
+	Error += sizeof(glm::highp_f32mat2x3) != 24;
+	Error += sizeof(glm::highp_f32mat2x4) != 32;
+	Error += sizeof(glm::highp_f32mat3x2) != 24;
+	Error += sizeof(glm::highp_f32mat3x3) != 36;
+	Error += sizeof(glm::highp_f32mat3x4) != 48;
+	Error += sizeof(glm::highp_f32mat4x2) != 32;
+	Error += sizeof(glm::highp_f32mat4x3) != 48;
+	Error += sizeof(glm::highp_f32mat4x4) != 64;
+
+	return Error;
+}
+
+static int test_dmat_size()
+{
+	int Error = 0;
+
+	Error += sizeof(glm::f64mat2) != 32;
+	Error += sizeof(glm::f64mat3) != 72;
+	Error += sizeof(glm::f64mat4) != 128;
+	Error += sizeof(glm::f64mat2x2) != 32;
+	Error += sizeof(glm::f64mat2x3) != 48;
+	Error += sizeof(glm::f64mat2x4) != 64;
+	Error += sizeof(glm::f64mat3x2) != 48;
+	Error += sizeof(glm::f64mat3x3) != 72;
+	Error += sizeof(glm::f64mat3x4) != 96;
+	Error += sizeof(glm::f64mat4x2) != 64;
+	Error += sizeof(glm::f64mat4x3) != 96;
+	Error += sizeof(glm::f64mat4x4) != 128;
+
+	Error += sizeof(glm::lowp_f64mat2) != 32;
+	Error += sizeof(glm::lowp_f64mat3) != 72;
+	Error += sizeof(glm::lowp_f64mat4) != 128;
+	Error += sizeof(glm::lowp_f64mat2x2) != 32;
+	Error += sizeof(glm::lowp_f64mat2x3) != 48;
+	Error += sizeof(glm::lowp_f64mat2x4) != 64;
+	Error += sizeof(glm::lowp_f64mat3x2) != 48;
+	Error += sizeof(glm::lowp_f64mat3x3) != 72;
+	Error += sizeof(glm::lowp_f64mat3x4) != 96;
+	Error += sizeof(glm::lowp_f64mat4x2) != 64;
+	Error += sizeof(glm::lowp_f64mat4x3) != 96;
+	Error += sizeof(glm::lowp_f64mat4x4) != 128;
+
+	Error += sizeof(glm::mediump_f64mat2) != 32;
+	Error += sizeof(glm::mediump_f64mat3) != 72;
+	Error += sizeof(glm::mediump_f64mat4) != 128;
+	Error += sizeof(glm::mediump_f64mat2x2) != 32;
+	Error += sizeof(glm::mediump_f64mat2x3) != 48;
+	Error += sizeof(glm::mediump_f64mat2x4) != 64;
+	Error += sizeof(glm::mediump_f64mat3x2) != 48;
+	Error += sizeof(glm::mediump_f64mat3x3) != 72;
+	Error += sizeof(glm::mediump_f64mat3x4) != 96;
+	Error += sizeof(glm::mediump_f64mat4x2) != 64;
+	Error += sizeof(glm::mediump_f64mat4x3) != 96;
+	Error += sizeof(glm::mediump_f64mat4x4) != 128;
+
+	Error += sizeof(glm::highp_f64mat2) != 32;
+	Error += sizeof(glm::highp_f64mat3) != 72;
+	Error += sizeof(glm::highp_f64mat4) != 128;
+	Error += sizeof(glm::highp_f64mat2x2) != 32;
+	Error += sizeof(glm::highp_f64mat2x3) != 48;
+	Error += sizeof(glm::highp_f64mat2x4) != 64;
+	Error += sizeof(glm::highp_f64mat3x2) != 48;
+	Error += sizeof(glm::highp_f64mat3x3) != 72;
+	Error += sizeof(glm::highp_f64mat3x4) != 96;
+	Error += sizeof(glm::highp_f64mat4x2) != 64;
+	Error += sizeof(glm::highp_f64mat4x3) != 96;
+	Error += sizeof(glm::highp_f64mat4x4) != 128;
+
+	return Error;
+}
+
+static int test_quat_size()
+{
+	int Error = 0;
+
+	Error += sizeof(glm::f32quat) != 16;
+	Error += sizeof(glm::f64quat) != 32;
+
+	Error += sizeof(glm::lowp_f32quat) != 16;
+	Error += sizeof(glm::lowp_f64quat) != 32;
+
+	Error += sizeof(glm::mediump_f32quat) != 16;
+	Error += sizeof(glm::mediump_f64quat) != 32;
+
+	Error += sizeof(glm::highp_f32quat) != 16;
+	Error += sizeof(glm::highp_f64quat) != 32;
+
+	return Error;
+}
+
+static int test_quat_precision()
+{
+	int Error = 0;
+	
+	{
+		glm::f32quat q1(0.f, glm::vec3(0.f, 0.f, 1.f));
+		glm::lowp_f32quat qA(q1);
+		glm::mediump_f32quat qB(q1);
+		glm::highp_f32quat qC(q1);
+		glm::f32quat q2(qA);
+		glm::f32quat q3(qB);
+		glm::f32quat q4(qC);
+		
+		Error += glm::all(glm::equal(q1, q2, glm::epsilon<float>())) ? 0 : 1;
+		Error += glm::all(glm::equal(q1, q3, glm::epsilon<float>())) ? 0 : 1;
+		Error += glm::all(glm::equal(q1, q4, glm::epsilon<float>())) ? 0 : 1;
+	}
+
+	return Error;
+}
+
+static int test_fvec_conversion()
+{
+	int Error(0);
+
+	{
+		glm::highp_vec4 a = glm::vec4(1, 2, 3, 4);
+		glm::mediump_vec4 b = glm::vec4(1, 2, 3, 4);
+		glm::lowp_vec4 c = b;
+		glm::mediump_vec4 d = c;
+		glm::lowp_ivec4 e = glm::ivec4(d);
+		glm::lowp_ivec3 f = glm::ivec3(e);
+
+		Error += glm::all(glm::equal(b, d, glm::epsilon<float>())) ? 0 : 1;
+	}
+
+	return Error;
+}
+
+#if GLM_HAS_OPENMP
+static int test_openmp()
+{
+	std::vector<glm::u8vec3> VectorA(1000);
+	std::vector<glm::u8vec3> VectorB(1000);
+	std::vector<glm::u8vec3> VectorC(1000);
+
+	for (std::size_t i = 0; i < VectorA.size(); ++i)
+	{
+		VectorA[i] = glm::u8vec3(1, 1, 1);
+		VectorB[i] = glm::u8vec3(1, 1, 1);
+	}
+
+	#pragma omp parallel for default(none) shared(VectorA, VectorB, VectorC)
+	for (int i = 0; i < static_cast<int>(VectorC.size()); ++i)
+	{
+		VectorC[i] = VectorA[i] + VectorB[i];
+	}
+
+	return 0;
+}
+#endif//GLM_HAS_OPENMP
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_scalar_size();
+	Error += test_fvec_size();
+
+	Error += test_fvec_precision();
+	Error += test_fvec_conversion();
+
+	Error += test_dvec_precision();
+
+	Error += test_uvec_size();
+	Error += test_uvec_precision();
+	Error += test_ivec_size();
+	Error += test_ivec_precision();
+
+	Error += test_fmat_size();
+	Error += test_dmat_size();
+	Error += test_quat_size();
+	Error += test_quat_precision();
+
+#	if GLM_HAS_OPENMP
+		Error += test_openmp();
+#	endif//
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/gtc/gtc_type_ptr.cpp b/3rdparty/glm/source/test/gtc/gtc_type_ptr.cpp
new file mode 100644
index 0000000..6fcd305
--- /dev/null
+++ b/3rdparty/glm/source/test/gtc/gtc_type_ptr.cpp
@@ -0,0 +1,335 @@
+#include <glm/gtc/type_ptr.hpp>
+#include <glm/gtc/vec1.hpp>
+#include <glm/gtc/constants.hpp>
+#include <glm/ext/vector_relational.hpp>
+
+int test_value_ptr_vec()
+{
+	int Error = 0;
+
+	{
+		glm::vec2 v(1.0);
+		float * p = glm::value_ptr(v);
+		Error += p == &v[0] ? 0 : 1;
+	}
+	{
+		glm::vec3 v(1.0);
+		float * p = glm::value_ptr(v);
+		Error += p == &v[0] ? 0 : 1;
+	}
+	{
+		glm::vec4 v(1.0);
+		float * p = glm::value_ptr(v);
+		Error += p == &v[0] ? 0 : 1;
+	}
+
+	{
+		glm::dvec2 v(1.0);
+		double * p = glm::value_ptr(v);
+		Error += p == &v[0] ? 0 : 1;
+	}
+	{
+		glm::dvec3 v(1.0);
+		double * p = glm::value_ptr(v);
+		Error += p == &v[0] ? 0 : 1;
+	}
+	{
+		glm::dvec4 v(1.0);
+		double * p = glm::value_ptr(v);
+		Error += p == &v[0] ? 0 : 1;
+	}
+
+	return Error;
+}
+
+int test_value_ptr_vec_const()
+{
+	int Error = 0;
+
+	{
+		glm::vec2 const v(1.0);
+		float const * p = glm::value_ptr(v);
+		Error += p == &v[0] ? 0 : 1;
+	}
+	{
+		glm::vec3 const v(1.0);
+		float const * p = glm::value_ptr(v);
+		Error += p == &v[0] ? 0 : 1;
+	}
+	{
+		glm::vec4 const v(1.0);
+		float const * p = glm::value_ptr(v);
+		Error += p == &v[0] ? 0 : 1;
+	}
+
+	{
+		glm::dvec2 const v(1.0);
+		double const * p = glm::value_ptr(v);
+		Error += p == &v[0] ? 0 : 1;
+	}
+	{
+		glm::dvec3 const v(1.0);
+		double const * p = glm::value_ptr(v);
+		Error += p == &v[0] ? 0 : 1;
+	}
+	{
+		glm::dvec4 const v(1.0);
+		double const * p = glm::value_ptr(v);
+		Error += p == &v[0] ? 0 : 1;
+	}
+
+	return Error;
+}
+
+int test_value_ptr_mat()
+{
+	int Error = 0;
+
+	{
+		glm::mat2x2 m(1.0);
+		float * p = glm::value_ptr(m);
+		Error += p == &m[0][0] ? 0 : 1;
+	}
+	{
+		glm::mat2x3 m(1.0);
+		float * p = glm::value_ptr(m);
+		Error += p == &m[0][0] ? 0 : 1;
+	}
+	{
+		glm::mat2x4 m(1.0);
+		float * p = glm::value_ptr(m);
+		Error += p == &m[0][0] ? 0 : 1;
+	}
+	{
+		glm::mat3x2 m(1.0);
+		float * p = glm::value_ptr(m);
+		Error += p == &m[0][0] ? 0 : 1;
+	}
+	{
+		glm::mat3x3 m(1.0);
+		float * p = glm::value_ptr(m);
+		Error += p == &m[0][0] ? 0 : 1;
+	}
+	{
+		glm::mat3x4 m(1.0);
+		float * p = glm::value_ptr(m);
+		Error += p == &m[0][0] ? 0 : 1;
+	}
+	{
+		glm::mat4x2 m(1.0);
+		float * p = glm::value_ptr(m);
+		Error += p == &m[0][0] ? 0 : 1;
+	}
+	{
+		glm::mat4x3 m(1.0);
+		float * p = glm::value_ptr(m);
+		Error += p == &m[0][0] ? 0 : 1;
+	}
+	{
+		glm::mat4x4 m(1.0);
+		float * p = glm::value_ptr(m);
+		Error += p == &m[0][0] ? 0 : 1;
+	}
+
+	return Error;
+}
+
+int test_value_ptr_mat_const()
+{
+	int Error = 0;
+
+	{
+		glm::mat2x2 const m(1.0);
+		float const * p = glm::value_ptr(m);
+		Error += p == &m[0][0] ? 0 : 1;
+	}
+	{
+		glm::mat2x3 const m(1.0);
+		float const * p = glm::value_ptr(m);
+		Error += p == &m[0][0] ? 0 : 1;
+	}
+	{
+		glm::mat2x4 const m(1.0);
+		float const * p = glm::value_ptr(m);
+		Error += p == &m[0][0] ? 0 : 1;
+	}
+	{
+		glm::mat3x2 const m(1.0);
+		float const * p = glm::value_ptr(m);
+		Error += p == &m[0][0] ? 0 : 1;
+	}
+	{
+		glm::mat3x3 const m(1.0);
+		float const * p = glm::value_ptr(m);
+		Error += p == &m[0][0] ? 0 : 1;
+	}
+	{
+		glm::mat3x4 const m(1.0);
+		float const * p = glm::value_ptr(m);
+		Error += p == &m[0][0] ? 0 : 1;
+	}
+	{
+		glm::mat4x2 const m(1.0);
+		float const * p = glm::value_ptr(m);
+		Error += p == &m[0][0] ? 0 : 1;
+	}
+	{
+		glm::mat4x3 const m(1.0);
+		float const * p = glm::value_ptr(m);
+		Error += p == &m[0][0] ? 0 : 1;
+	}
+	{
+		glm::mat4x4 const m(1.0);
+		float const * p = glm::value_ptr(m);
+		Error += p == &m[0][0] ? 0 : 1;
+	}
+
+	return Error;
+}
+
+int test_make_pointer_mat()
+{
+	int Error = 0;
+
+	float ArrayA[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
+	double ArrayB[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
+
+	glm::mat2x2 Mat2x2A = glm::make_mat2x2(ArrayA);
+	glm::mat2x3 Mat2x3A = glm::make_mat2x3(ArrayA);
+	glm::mat2x4 Mat2x4A = glm::make_mat2x4(ArrayA);
+	glm::mat3x2 Mat3x2A = glm::make_mat3x2(ArrayA);
+	glm::mat3x3 Mat3x3A = glm::make_mat3x3(ArrayA);
+	glm::mat3x4 Mat3x4A = glm::make_mat3x4(ArrayA);
+	glm::mat4x2 Mat4x2A = glm::make_mat4x2(ArrayA);
+	glm::mat4x3 Mat4x3A = glm::make_mat4x3(ArrayA);
+	glm::mat4x4 Mat4x4A = glm::make_mat4x4(ArrayA);
+
+	glm::dmat2x2 Mat2x2B = glm::make_mat2x2(ArrayB);
+	glm::dmat2x3 Mat2x3B = glm::make_mat2x3(ArrayB);
+	glm::dmat2x4 Mat2x4B = glm::make_mat2x4(ArrayB);
+	glm::dmat3x2 Mat3x2B = glm::make_mat3x2(ArrayB);
+	glm::dmat3x3 Mat3x3B = glm::make_mat3x3(ArrayB);
+	glm::dmat3x4 Mat3x4B = glm::make_mat3x4(ArrayB);
+	glm::dmat4x2 Mat4x2B = glm::make_mat4x2(ArrayB);
+	glm::dmat4x3 Mat4x3B = glm::make_mat4x3(ArrayB);
+	glm::dmat4x4 Mat4x4B = glm::make_mat4x4(ArrayB);
+
+	return Error;
+}
+
+int test_make_pointer_vec()
+{
+	int Error = 0;
+
+	float ArrayA[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
+	int ArrayB[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
+	bool ArrayC[] = {true, false, true, false, true, false, true, false, true, false, true, false, true, false, true, false};
+
+	glm::vec2 Vec2A = glm::make_vec2(ArrayA);
+	glm::vec3 Vec3A = glm::make_vec3(ArrayA);
+	glm::vec4 Vec4A = glm::make_vec4(ArrayA);
+
+	glm::ivec2 Vec2B = glm::make_vec2(ArrayB);
+	glm::ivec3 Vec3B = glm::make_vec3(ArrayB);
+	glm::ivec4 Vec4B = glm::make_vec4(ArrayB);
+
+	glm::bvec2 Vec2C = glm::make_vec2(ArrayC);
+	glm::bvec3 Vec3C = glm::make_vec3(ArrayC);
+	glm::bvec4 Vec4C = glm::make_vec4(ArrayC);
+
+	return Error;
+}
+
+int test_make_vec1()
+{
+	int Error = 0;
+
+	glm::ivec1 const v1 = glm::make_vec1(glm::ivec1(2));
+	Error += v1 == glm::ivec1(2) ? 0 : 1;
+
+	glm::ivec1 const v2 = glm::make_vec1(glm::ivec2(2));
+	Error += v2 == glm::ivec1(2) ? 0 : 1;
+
+	glm::ivec1 const v3 = glm::make_vec1(glm::ivec3(2));
+	Error += v3 == glm::ivec1(2) ? 0 : 1;
+
+	glm::ivec1 const v4 = glm::make_vec1(glm::ivec4(2));
+	Error += v3 == glm::ivec1(2) ? 0 : 1;
+
+	return Error;
+}
+
+int test_make_vec2()
+{
+	int Error = 0;
+
+	glm::ivec2 const v1 = glm::make_vec2(glm::ivec1(2));
+	Error += v1 == glm::ivec2(2, 0) ? 0 : 1;
+
+	glm::ivec2 const v2 = glm::make_vec2(glm::ivec2(2));
+	Error += v2 == glm::ivec2(2, 2) ? 0 : 1;
+
+	glm::ivec2 const v3 = glm::make_vec2(glm::ivec3(2));
+	Error += v3 == glm::ivec2(2, 2) ? 0 : 1;
+
+	glm::ivec2 const v4 = glm::make_vec2(glm::ivec4(2));
+	Error += v3 == glm::ivec2(2, 2) ? 0 : 1;
+
+	return Error;
+}
+
+int test_make_vec3()
+{
+	int Error = 0;
+
+	glm::ivec3 const v1 = glm::make_vec3(glm::ivec1(2));
+	Error += v1 == glm::ivec3(2, 0, 0) ? 0 : 1;
+
+	glm::ivec3 const v2 = glm::make_vec3(glm::ivec2(2));
+	Error += v2 == glm::ivec3(2, 2, 0) ? 0 : 1;
+
+	glm::ivec3 const v3 = glm::make_vec3(glm::ivec3(2));
+	Error += v3 == glm::ivec3(2, 2, 2) ? 0 : 1;
+
+	glm::ivec3 const v4 = glm::make_vec3(glm::ivec4(2));
+	Error += v3 == glm::ivec3(2, 2, 2) ? 0 : 1;
+
+	return Error;
+}
+
+int test_make_vec4()
+{
+	int Error = 0;
+
+	glm::ivec4 const v1 = glm::make_vec4(glm::ivec1(2));
+	Error += v1 == glm::ivec4(2, 0, 0, 1) ? 0 : 1;
+
+	glm::ivec4 const v2 = glm::make_vec4(glm::ivec2(2));
+	Error += v2 == glm::ivec4(2, 2, 0, 1) ? 0 : 1;
+
+	glm::ivec4 const v3 = glm::make_vec4(glm::ivec3(2));
+	Error += v3 == glm::ivec4(2, 2, 2, 1) ? 0 : 1;
+
+	glm::ivec4 const v4 = glm::make_vec4(glm::ivec4(2));
+	Error += v4 == glm::ivec4(2, 2, 2, 2) ? 0 : 1;
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_make_vec1();
+	Error += test_make_vec2();
+	Error += test_make_vec3();
+	Error += test_make_vec4();
+	Error += test_make_pointer_vec();
+	Error += test_make_pointer_mat();
+	Error += test_value_ptr_vec();
+	Error += test_value_ptr_vec_const();
+	Error += test_value_ptr_mat();
+	Error += test_value_ptr_mat_const();
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/gtc/gtc_ulp.cpp b/3rdparty/glm/source/test/gtc/gtc_ulp.cpp
new file mode 100644
index 0000000..d5074a3
--- /dev/null
+++ b/3rdparty/glm/source/test/gtc/gtc_ulp.cpp
@@ -0,0 +1,99 @@
+#include <glm/gtc/ulp.hpp>
+#include <glm/ext/scalar_relational.hpp>
+#include <limits>
+
+int test_ulp_float_dist()
+{
+	int Error = 0;
+
+	float A = 1.0f;
+
+	float B = glm::next_float(A);
+	Error += glm::notEqual(A, B, 0) ? 0 : 1;
+	float C = glm::prev_float(B);
+	Error += glm::equal(A, C, 0) ? 0 : 1;
+
+	int D = glm::float_distance(A, B);
+	Error += D == 1 ? 0 : 1;
+	int E = glm::float_distance(A, C);
+	Error += E == 0 ? 0 : 1;
+
+	return Error;
+}
+
+int test_ulp_float_step()
+{
+	int Error = 0;
+
+	float A = 1.0f;
+
+	for(int i = 10; i < 1000; i *= 10)
+	{
+		float B = glm::next_float(A, i);
+		Error += glm::notEqual(A, B, 0) ? 0 : 1;
+		float C = glm::prev_float(B, i);
+		Error += glm::equal(A, C, 0) ? 0 : 1;
+
+		int D = glm::float_distance(A, B);
+		Error += D == i ? 0 : 1;
+		int E = glm::float_distance(A, C);
+		Error += E == 0 ? 0 : 1;
+	}
+
+	return Error;
+}
+
+int test_ulp_double_dist()
+{
+	int Error = 0;
+
+	double A = 1.0;
+
+	double B = glm::next_float(A);
+	Error += glm::notEqual(A, B, 0) ? 0 : 1;
+	double C = glm::prev_float(B);
+	Error += glm::equal(A, C, 0) ? 0 : 1;
+
+	glm::int64 const D = glm::float_distance(A, B);
+	Error += D == 1 ? 0 : 1;
+	glm::int64 const E = glm::float_distance(A, C);
+	Error += E == 0 ? 0 : 1;
+
+	return Error;
+}
+
+int test_ulp_double_step()
+{
+	int Error = 0;
+
+	double A = 1.0;
+
+	for(int i = 10; i < 1000; i *= 10)
+	{
+		double B = glm::next_float(A, i);
+		Error += glm::notEqual(A, B, 0) ? 0 : 1;
+		double C = glm::prev_float(B, i);
+		Error += glm::equal(A, C, 0) ? 0 : 1;
+
+		glm::int64 const D = glm::float_distance(A, B);
+		Error += D == i ? 0 : 1;
+		glm::int64 const E = glm::float_distance(A, C);
+		Error += E == 0 ? 0 : 1;
+	}
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_ulp_float_dist();
+	Error += test_ulp_float_step();
+	Error += test_ulp_double_dist();
+	Error += test_ulp_double_step();
+
+	return Error;
+}
+
+
diff --git a/3rdparty/glm/source/test/gtc/gtc_user_defined_types.cpp b/3rdparty/glm/source/test/gtc/gtc_user_defined_types.cpp
new file mode 100644
index 0000000..af39620
--- /dev/null
+++ b/3rdparty/glm/source/test/gtc/gtc_user_defined_types.cpp
@@ -0,0 +1,30 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2010-09-16
+// Updated : 2011-05-27
+// Licence : This source is under MIT licence
+// File    : test/gtc/type_ptr.cpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#define GLM_FORCE_RADIANS
+#include <glm/gtc/user_defined_type.hpp>
+
+int test_make_pointer_vec()
+{
+	int Error = 0;
+
+	glm::func();
+	//func();
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_make_pointer_vec();
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/gtc/gtc_vec1.cpp b/3rdparty/glm/source/test/gtc/gtc_vec1.cpp
new file mode 100644
index 0000000..268d95e
--- /dev/null
+++ b/3rdparty/glm/source/test/gtc/gtc_vec1.cpp
@@ -0,0 +1,8 @@
+#include <glm/gtc/vec1.hpp>
+
+int main()
+{
+	int Error = 0;
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/gtx/CMakeLists.txt b/3rdparty/glm/source/test/gtx/CMakeLists.txt
new file mode 100644
index 0000000..ad7bf49
--- /dev/null
+++ b/3rdparty/glm/source/test/gtx/CMakeLists.txt
@@ -0,0 +1,59 @@
+glmCreateTestGTC(gtx)
+glmCreateTestGTC(gtx_associated_min_max)
+glmCreateTestGTC(gtx_closest_point)
+glmCreateTestGTC(gtx_color_encoding)
+glmCreateTestGTC(gtx_color_space_YCoCg)
+glmCreateTestGTC(gtx_color_space)
+glmCreateTestGTC(gtx_common)
+glmCreateTestGTC(gtx_compatibility)
+glmCreateTestGTC(gtx_component_wise)
+glmCreateTestGTC(gtx_easing)
+glmCreateTestGTC(gtx_euler_angle)
+glmCreateTestGTC(gtx_extend)
+glmCreateTestGTC(gtx_extended_min_max)
+glmCreateTestGTC(gtx_exterior_product)
+glmCreateTestGTC(gtx_fast_exponential)
+glmCreateTestGTC(gtx_fast_square_root)
+glmCreateTestGTC(gtx_fast_trigonometry)
+glmCreateTestGTC(gtx_functions)
+glmCreateTestGTC(gtx_gradient_paint)
+glmCreateTestGTC(gtx_handed_coordinate_space)
+glmCreateTestGTC(gtx_integer)
+glmCreateTestGTC(gtx_intersect)
+glmCreateTestGTC(gtx_io)
+glmCreateTestGTC(gtx_load)
+glmCreateTestGTC(gtx_log_base)
+glmCreateTestGTC(gtx_matrix_cross_product)
+glmCreateTestGTC(gtx_matrix_decompose)
+glmCreateTestGTC(gtx_matrix_factorisation)
+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_pca)
+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_spline)
+glmCreateTestGTC(gtx_string_cast)
+glmCreateTestGTC(gtx_texture)
+glmCreateTestGTC(gtx_type_aligned)
+glmCreateTestGTC(gtx_type_trait)
+glmCreateTestGTC(gtx_vec_swizzle)
+glmCreateTestGTC(gtx_vector_angle)
+glmCreateTestGTC(gtx_vector_query)
+glmCreateTestGTC(gtx_wrap)
diff --git a/3rdparty/glm/source/test/gtx/gtx.cpp b/3rdparty/glm/source/test/gtx/gtx.cpp
new file mode 100644
index 0000000..1b143b6
--- /dev/null
+++ b/3rdparty/glm/source/test/gtx/gtx.cpp
@@ -0,0 +1,8 @@
+#include <glm/ext.hpp>
+
+int main()
+{
+	int Error = 0;
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/gtx/gtx_associated_min_max.cpp b/3rdparty/glm/source/test/gtx/gtx_associated_min_max.cpp
new file mode 100644
index 0000000..9007f8a
--- /dev/null
+++ b/3rdparty/glm/source/test/gtx/gtx_associated_min_max.cpp
@@ -0,0 +1,10 @@
+#define GLM_ENABLE_EXPERIMENTAL
+#include <glm/gtc/type_precision.hpp>
+#include <glm/gtx/associated_min_max.hpp>
+
+int main()
+{
+	int Error(0);
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/gtx/gtx_closest_point.cpp b/3rdparty/glm/source/test/gtx/gtx_closest_point.cpp
new file mode 100644
index 0000000..0f6303a
--- /dev/null
+++ b/3rdparty/glm/source/test/gtx/gtx_closest_point.cpp
@@ -0,0 +1,9 @@
+#define GLM_ENABLE_EXPERIMENTAL
+#include <glm/gtx/closest_point.hpp>
+
+int main()
+{
+	int Error(0);
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/gtx/gtx_color_encoding.cpp b/3rdparty/glm/source/test/gtx/gtx_color_encoding.cpp
new file mode 100644
index 0000000..8b499be
--- /dev/null
+++ b/3rdparty/glm/source/test/gtx/gtx_color_encoding.cpp
@@ -0,0 +1,51 @@
+#include <glm/gtx/color_encoding.hpp>
+#include <glm/gtc/color_space.hpp>
+#include <glm/gtc/epsilon.hpp>
+#include <glm/gtc/constants.hpp>
+
+namespace srgb
+{
+	int test()
+	{
+		int Error(0);
+
+		glm::vec3 const ColorSourceRGB(1.0, 0.5, 0.0);
+/*
+		{
+			glm::vec3 const ColorSRGB = glm::convertLinearSRGBToD65XYZ(ColorSourceRGB);
+			glm::vec3 const ColorRGB = glm::convertD65XYZToLinearSRGB(ColorSRGB);
+			Error += glm::all(glm::epsilonEqual(ColorSourceRGB, ColorRGB, 0.00001f)) ? 0 : 1;
+		}
+*/
+		{
+			glm::vec3 const ColorSRGB = glm::convertLinearToSRGB(ColorSourceRGB, 2.8f);
+			glm::vec3 const ColorRGB = glm::convertSRGBToLinear(ColorSRGB, 2.8f);
+			Error += glm::all(glm::epsilonEqual(ColorSourceRGB, ColorRGB, 0.00001f)) ? 0 : 1;
+		}
+
+		glm::vec4 const ColorSourceRGBA(1.0, 0.5, 0.0, 1.0);
+
+		{
+			glm::vec4 const ColorSRGB = glm::convertLinearToSRGB(ColorSourceRGBA);
+			glm::vec4 const ColorRGB = glm::convertSRGBToLinear(ColorSRGB);
+			Error += glm::all(glm::epsilonEqual(ColorSourceRGBA, ColorRGB, 0.00001f)) ? 0 : 1;
+		}
+
+		{
+			glm::vec4 const ColorSRGB = glm::convertLinearToSRGB(ColorSourceRGBA, 2.8f);
+			glm::vec4 const ColorRGB = glm::convertSRGBToLinear(ColorSRGB, 2.8f);
+			Error += glm::all(glm::epsilonEqual(ColorSourceRGBA, ColorRGB, 0.00001f)) ? 0 : 1;
+		}
+
+		return Error;
+	}
+}//namespace srgb
+
+int main()
+{
+	int Error(0);
+
+	Error += srgb::test();
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/gtx/gtx_color_space.cpp b/3rdparty/glm/source/test/gtx/gtx_color_space.cpp
new file mode 100644
index 0000000..a23d2c8
--- /dev/null
+++ b/3rdparty/glm/source/test/gtx/gtx_color_space.cpp
@@ -0,0 +1,20 @@
+#define GLM_ENABLE_EXPERIMENTAL
+#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;
+}
diff --git a/3rdparty/glm/source/test/gtx/gtx_color_space_YCoCg.cpp b/3rdparty/glm/source/test/gtx/gtx_color_space_YCoCg.cpp
new file mode 100644
index 0000000..2ca131d
--- /dev/null
+++ b/3rdparty/glm/source/test/gtx/gtx_color_space_YCoCg.cpp
@@ -0,0 +1,9 @@
+#define GLM_ENABLE_EXPERIMENTAL
+#include <glm/gtx/color_space_YCoCg.hpp>
+
+int main()
+{
+	int Error(0);
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/gtx/gtx_common.cpp b/3rdparty/glm/source/test/gtx/gtx_common.cpp
new file mode 100644
index 0000000..fd4fa99
--- /dev/null
+++ b/3rdparty/glm/source/test/gtx/gtx_common.cpp
@@ -0,0 +1,161 @@
+#define GLM_ENABLE_EXPERIMENTAL
+#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);
+	Error += !A ? 0 : 1;
+
+	glm::bvec1 B = glm::isdenormal(glm::vec1(1.0f));
+	Error += !glm::any(B) ? 0 : 1;
+
+	glm::bvec2 C = glm::isdenormal(glm::vec2(1.0f));
+	Error += !glm::any(C) ? 0 : 1;
+
+	glm::bvec3 D = glm::isdenormal(glm::vec3(1.0f));
+	Error += !glm::any(D) ? 0 : 1;
+
+	glm::bvec4 E = glm::isdenormal(glm::vec4(1.0f));
+	Error += !glm::any(E) ? 0 : 1;
+
+	return Error;
+}
+
+int test_openBounded()
+{
+	int Error = 0;
+
+	Error += glm::all(glm::openBounded(glm::ivec2(2), glm::ivec2(1), glm::ivec2(3))) ? 0 : 1;
+	Error += !glm::all(glm::openBounded(glm::ivec2(1), glm::ivec2(1), glm::ivec2(3))) ? 0 : 1;
+	Error += !glm::all(glm::openBounded(glm::ivec2(3), glm::ivec2(1), glm::ivec2(3))) ? 0 : 1;
+
+	return Error;
+}
+
+int test_closeBounded()
+{
+	int Error = 0;
+
+	Error += glm::all(glm::closeBounded(glm::ivec2(2), glm::ivec2(1), glm::ivec2(3))) ? 0 : 1;
+	Error += glm::all(glm::closeBounded(glm::ivec2(1), glm::ivec2(1), glm::ivec2(3))) ? 0 : 1;
+	Error += glm::all(glm::closeBounded(glm::ivec2(3), glm::ivec2(1), glm::ivec2(3))) ? 0 : 1;
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_isdenormal();
+	Error += ::fmod_::test();
+	Error += test_openBounded();
+	Error += test_closeBounded();
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/gtx/gtx_compatibility.cpp b/3rdparty/glm/source/test/gtx/gtx_compatibility.cpp
new file mode 100644
index 0000000..e5351ce
--- /dev/null
+++ b/3rdparty/glm/source/test/gtx/gtx_compatibility.cpp
@@ -0,0 +1,19 @@
+#define GLM_ENABLE_EXPERIMENTAL
+#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;
+}
diff --git a/3rdparty/glm/source/test/gtx/gtx_component_wise.cpp b/3rdparty/glm/source/test/gtx/gtx_component_wise.cpp
new file mode 100644
index 0000000..29c81af
--- /dev/null
+++ b/3rdparty/glm/source/test/gtx/gtx_component_wise.cpp
@@ -0,0 +1,116 @@
+#define GLM_ENABLE_EXPERIMENTAL
+#include <glm/gtx/component_wise.hpp>
+#include <glm/gtc/type_precision.hpp>
+#include <glm/gtc/epsilon.hpp>
+#include <glm/gtc/constants.hpp>
+#include <limits>
+
+namespace compNormalize
+{
+	int run()
+	{
+		int Error(0);
+
+		{
+			glm::vec4 const A = glm::compNormalize<float>(glm::u8vec4(0, 127, 128, 255));
+
+			Error += glm::epsilonEqual(A.x, 0.0f, glm::epsilon<float>()) ? 0 : 1;
+			Error += A.y < 0.5f ? 0 : 1;
+			Error += A.z > 0.5f ? 0 : 1;
+			Error += glm::epsilonEqual(A.w, 1.0f, glm::epsilon<float>()) ? 0 : 1;
+		}
+
+		{
+			glm::vec4 const A = glm::compNormalize<float>(glm::i8vec4(-128, -1, 0, 127));
+
+			Error += glm::epsilonEqual(A.x,-1.0f, glm::epsilon<float>()) ? 0 : 1;
+			Error += A.y < 0.0f ? 0 : 1;
+			Error += A.z > 0.0f ? 0 : 1;
+			Error += glm::epsilonEqual(A.w, 1.0f, glm::epsilon<float>()) ? 0 : 1;
+		}
+
+		{
+			glm::vec4 const A = glm::compNormalize<float>(glm::u16vec4(
+				std::numeric_limits<glm::u16>::min(),
+				(std::numeric_limits<glm::u16>::max() >> 1) + 0,
+				(std::numeric_limits<glm::u16>::max() >> 1) + 1,
+				std::numeric_limits<glm::u16>::max()));
+
+			Error += glm::epsilonEqual(A.x, 0.0f, glm::epsilon<float>()) ? 0 : 1;
+			Error += A.y < 0.5f ? 0 : 1;
+			Error += A.z > 0.5f ? 0 : 1;
+			Error += glm::epsilonEqual(A.w, 1.0f, glm::epsilon<float>()) ? 0 : 1;
+		}
+
+		{
+			glm::vec4 const A = glm::compNormalize<float>(glm::i16vec4(
+				std::numeric_limits<glm::i16>::min(),
+				static_cast<glm::i16>(-1),
+				static_cast<glm::i16>(0),
+				std::numeric_limits<glm::i16>::max()));
+
+			Error += glm::epsilonEqual(A.x,-1.0f, glm::epsilon<float>()) ? 0 : 1;
+			Error += A.y < 0.0f ? 0 : 1;
+			Error += A.z > 0.0f ? 0 : 1;
+			Error += glm::epsilonEqual(A.w, 1.0f, glm::epsilon<float>()) ? 0 : 1;
+		}
+
+		return Error;
+	}
+}//namespace compNormalize
+
+namespace compScale
+{
+	int run()
+	{
+		int Error(0);
+
+		{
+			glm::u8vec4 const A = glm::compScale<glm::u8>(glm::vec4(0.0f, 0.2f, 0.5f, 1.0f));
+
+			Error += A.x == std::numeric_limits<glm::u8>::min() ? 0 : 1;
+			Error += A.y < (std::numeric_limits<glm::u8>::max() >> 2) ? 0 : 1;
+			Error += A.z == 127 ? 0 : 1;
+			Error += A.w == 255 ? 0 : 1;
+		}
+
+		{
+			glm::i8vec4 const A = glm::compScale<glm::i8>(glm::vec4(0.0f,-1.0f, 0.5f, 1.0f));
+
+			Error += A.x == 0 ? 0 : 1;
+			Error += A.y == -128 ? 0 : 1;
+			Error += A.z == 63 ? 0 : 1;
+			Error += A.w == 127 ? 0 : 1;
+		}
+
+		{
+			glm::u16vec4 const A = glm::compScale<glm::u16>(glm::vec4(0.0f, 0.2f, 0.5f, 1.0f));
+
+			Error += A.x == std::numeric_limits<glm::u16>::min() ? 0 : 1;
+			Error += A.y < (std::numeric_limits<glm::u16>::max() >> 2) ? 0 : 1;
+			Error += A.z == 32767 ? 0 : 1;
+			Error += A.w == 65535 ? 0 : 1;
+		}
+
+		{
+			glm::i16vec4 const A = glm::compScale<glm::i16>(glm::vec4(0.0f,-1.0f, 0.5f, 1.0f));
+
+			Error += A.x == 0 ? 0 : 1;
+			Error += A.y == -32768 ? 0 : 1;
+			Error += A.z == 16383 ? 0 : 1;
+			Error += A.w == 32767 ? 0 : 1;
+		}
+
+		return Error;
+	}
+}// compScale
+
+int main()
+{
+	int Error(0);
+
+	Error += compNormalize::run();
+	Error += compScale::run();
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/gtx/gtx_dual_quaternion.cpp b/3rdparty/glm/source/test/gtx/gtx_dual_quaternion.cpp
new file mode 100644
index 0000000..ceedc2c
--- /dev/null
+++ b/3rdparty/glm/source/test/gtx/gtx_dual_quaternion.cpp
@@ -0,0 +1,205 @@
+#define GLM_ENABLE_EXPERIMENTAL
+#define GLM_FORCE_CTOR_INIT
+#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::dual_quat_identity<float, glm::defaultp>();
+	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 test_size()
+{
+	int Error = 0;
+
+	Error += 32 == sizeof(glm::dualquat) ? 0 : 1;
+	Error += 64 == sizeof(glm::ddualquat) ? 0 : 1;
+	Error += glm::dualquat().length() == 2 ? 0 : 1;
+	Error += glm::ddualquat().length() == 2 ? 0 : 1;
+	Error += glm::dualquat::length() == 2 ? 0 : 1;
+	Error += glm::ddualquat::length() == 2 ? 0 : 1;
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_dual_quat_ctr();
+	Error += test_dquat_type();
+	Error += test_scalars();
+	Error += test_inverse();
+	Error += test_mul();
+	Error += test_size();
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/gtx/gtx_easing.cpp b/3rdparty/glm/source/test/gtx/gtx_easing.cpp
new file mode 100644
index 0000000..0e98cd5
--- /dev/null
+++ b/3rdparty/glm/source/test/gtx/gtx_easing.cpp
@@ -0,0 +1,65 @@
+#define GLM_ENABLE_EXPERIMENTAL
+#include <glm/glm.hpp>
+#include <glm/gtx/quaternion.hpp>
+#include <glm/gtx/easing.hpp>
+
+namespace
+{
+
+	template<typename T>
+	void _test_easing()
+	{
+		T a = static_cast<T>(0.5);
+		T r;
+
+		r = glm::linearInterpolation(a);
+
+		r = glm::quadraticEaseIn(a);
+		r = glm::quadraticEaseOut(a);
+		r = glm::quadraticEaseInOut(a);
+
+		r = glm::cubicEaseIn(a);
+		r = glm::cubicEaseOut(a);
+		r = glm::cubicEaseInOut(a);
+
+		r = glm::quarticEaseIn(a);
+		r = glm::quarticEaseOut(a);
+		r = glm::quinticEaseInOut(a);
+
+		r = glm::sineEaseIn(a);
+		r = glm::sineEaseOut(a);
+		r = glm::sineEaseInOut(a);
+
+		r = glm::circularEaseIn(a);
+		r = glm::circularEaseOut(a);
+		r = glm::circularEaseInOut(a);
+
+		r = glm::exponentialEaseIn(a);
+		r = glm::exponentialEaseOut(a);
+		r = glm::exponentialEaseInOut(a);
+
+		r = glm::elasticEaseIn(a);
+		r = glm::elasticEaseOut(a);
+		r = glm::elasticEaseInOut(a);
+
+		r = glm::backEaseIn(a);
+		r = glm::backEaseOut(a);
+		r = glm::backEaseInOut(a);
+
+		r = glm::bounceEaseIn(a);
+		r = glm::bounceEaseOut(a);
+		r = glm::bounceEaseInOut(a);
+	}
+
+}
+
+int main()
+{
+	int Error = 0;
+
+	_test_easing<float>();
+	_test_easing<double>();
+
+	return Error;
+}
+
diff --git a/3rdparty/glm/source/test/gtx/gtx_euler_angle.cpp b/3rdparty/glm/source/test/gtx/gtx_euler_angle.cpp
new file mode 100644
index 0000000..348f581
--- /dev/null
+++ b/3rdparty/glm/source/test/gtx/gtx_euler_angle.cpp
@@ -0,0 +1,539 @@
+// Code sample from Filippo Ramaciotti
+
+#define GLM_ENABLE_EXPERIMENTAL
+#include <glm/gtc/matrix_transform.hpp>
+#include <glm/gtx/matrix_cross_product.hpp>
+#include <glm/gtx/matrix_operation.hpp>
+#include <glm/gtc/epsilon.hpp>
+#include <glm/gtx/string_cast.hpp>
+#include <glm/gtx/euler_angles.hpp>
+#include <cstdio>
+#include <vector>
+#include <utility>
+
+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_derivedEulerAngles
+{
+	bool epsilonEqual(glm::mat4 const& mat1, glm::mat4 const& mat2, glm::mat4::value_type const& epsilon)
+	{
+		return glm::all(glm::epsilonEqual(mat1[0], mat2[0], epsilon)) ?
+				(
+					glm::all(glm::epsilonEqual(mat1[1], mat2[1], epsilon)) ?
+					(
+						glm::all(glm::epsilonEqual(mat1[2], mat2[2], epsilon)) ?
+						(
+							glm::all(glm::epsilonEqual(mat1[3], mat2[3], epsilon)) ? true : false
+						) : false
+					) : false
+				) : false;
+	}
+
+	template<typename RotationFunc, typename TestDerivedFunc>
+	int test(RotationFunc rotationFunc, TestDerivedFunc testDerivedFunc, const glm::vec3& basis)
+	{
+		int Error = 0;
+
+		typedef glm::vec3::value_type value;
+		value const zeroAngle(0.0f);
+		value const Angle(glm::pi<float>() * 0.75f);
+		value const negativeAngle(-Angle);
+		value const zeroAngleVelocity(0.0f);
+		value const AngleVelocity(glm::pi<float>() * 0.27f);
+		value const negativeAngleVelocity(-AngleVelocity);
+
+		typedef std::pair<value,value> AngleAndAngleVelocity;
+		std::vector<AngleAndAngleVelocity> testPairs;
+		testPairs.push_back(AngleAndAngleVelocity(zeroAngle, zeroAngleVelocity));
+		testPairs.push_back(AngleAndAngleVelocity(zeroAngle, AngleVelocity));
+		testPairs.push_back(AngleAndAngleVelocity(zeroAngle, negativeAngleVelocity));
+		testPairs.push_back(AngleAndAngleVelocity(Angle, zeroAngleVelocity));
+		testPairs.push_back(AngleAndAngleVelocity(Angle, AngleVelocity));
+		testPairs.push_back(AngleAndAngleVelocity(Angle, negativeAngleVelocity));
+		testPairs.push_back(AngleAndAngleVelocity(negativeAngle, zeroAngleVelocity));
+		testPairs.push_back(AngleAndAngleVelocity(negativeAngle, AngleVelocity));
+		testPairs.push_back(AngleAndAngleVelocity(negativeAngle, negativeAngleVelocity));
+
+		for (size_t i = 0, size = testPairs.size(); i < size; ++i)
+		{
+			AngleAndAngleVelocity const& pair = testPairs.at(i);
+
+			glm::mat4 const W = glm::matrixCross4(basis * pair.second);
+			glm::mat4 const rotMt = glm::transpose(rotationFunc(pair.first));
+			glm::mat4 const derivedRotM = testDerivedFunc(pair.first, pair.second);
+
+			Error += epsilonEqual(W, derivedRotM * rotMt, 0.00001f) ? 0 : 1;
+		}
+
+		return Error;
+	}
+}//namespace test_derivedEulerAngles
+
+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
+
+namespace test_eulerAngles
+{
+	template<typename TestRotationFunc>
+	int test(TestRotationFunc testRotationFunc, glm::vec3 const& I, glm::vec3 const& J, glm::vec3 const& K)
+	{
+		int Error = 0;
+
+		typedef glm::mat4::value_type value;
+		value const minAngle(-glm::pi<value>());
+		value const maxAngle(glm::pi<value>());
+		value const maxAngleWithDelta(maxAngle - 0.0000001f);
+		value const minMidAngle(-glm::pi<value>() * 0.5f);
+		value const maxMidAngle(glm::pi<value>() * 0.5f);
+
+		std::vector<glm::vec3> testEulerAngles;
+		testEulerAngles.push_back(glm::vec3(1.046f, 0.52f, -0.785f));
+		testEulerAngles.push_back(glm::vec3(minAngle, minMidAngle, minAngle));
+		testEulerAngles.push_back(glm::vec3(minAngle, minMidAngle, maxAngle));
+		testEulerAngles.push_back(glm::vec3(minAngle, minMidAngle, maxAngleWithDelta));
+		testEulerAngles.push_back(glm::vec3(minAngle, maxMidAngle, minAngle));
+		testEulerAngles.push_back(glm::vec3(minAngle, maxMidAngle, maxAngle));
+		testEulerAngles.push_back(glm::vec3(minAngle, maxMidAngle, maxAngleWithDelta));
+		testEulerAngles.push_back(glm::vec3(maxAngle, minMidAngle, minAngle));
+		testEulerAngles.push_back(glm::vec3(maxAngle, minMidAngle, maxAngle));
+		testEulerAngles.push_back(glm::vec3(maxAngle, minMidAngle, maxAngleWithDelta));
+		testEulerAngles.push_back(glm::vec3(maxAngleWithDelta, minMidAngle, maxAngle));
+		testEulerAngles.push_back(glm::vec3(maxAngleWithDelta, minMidAngle, maxAngleWithDelta));
+		testEulerAngles.push_back(glm::vec3(maxAngle, maxMidAngle, minAngle));
+		testEulerAngles.push_back(glm::vec3(maxAngleWithDelta, maxMidAngle, minAngle));
+		testEulerAngles.push_back(glm::vec3(maxAngle, maxMidAngle, maxAngle));
+		testEulerAngles.push_back(glm::vec3(maxAngle, maxMidAngle, maxAngleWithDelta));
+		testEulerAngles.push_back(glm::vec3(maxAngleWithDelta, maxMidAngle, maxAngle));
+		testEulerAngles.push_back(glm::vec3(maxAngleWithDelta, maxMidAngle, maxAngleWithDelta));
+		testEulerAngles.push_back(glm::vec3(minAngle, 0.0f, minAngle));
+		testEulerAngles.push_back(glm::vec3(minAngle, 0.0f, maxAngle));
+		testEulerAngles.push_back(glm::vec3(maxAngle, maxAngle, minAngle));
+		testEulerAngles.push_back(glm::vec3(maxAngle, maxAngle, maxAngle));
+
+		for (size_t i = 0, size = testEulerAngles.size(); i < size; ++i)
+		{
+			glm::vec3 const& angles = testEulerAngles.at(i);
+			glm::mat4 const rotationEuler = testRotationFunc(angles.x, angles.y, angles.z);
+
+			glm::mat4 rotationDumb = glm::diagonal4x4(glm::mat4::col_type(1.0f));
+			rotationDumb = glm::rotate(rotationDumb, angles.x, I);
+			rotationDumb = glm::rotate(rotationDumb, angles.y, J);
+			rotationDumb = glm::rotate(rotationDumb, angles.z, K);
+
+			glm::vec4 const V(1.0f,1.0f,1.0f,1.0f);
+			glm::vec4 const V1 = rotationEuler * V;
+			glm::vec4 const V2 = rotationDumb * V;
+
+			Error += glm::all(glm::epsilonEqual(V1, V2, 0.00001f)) ? 0 : 1;
+		}
+
+		return Error;
+	}
+}//namespace test_extractsEulerAngles
+
+namespace test_extractsEulerAngles
+{
+	template<typename RotationFunc, typename TestExtractionFunc>
+	int test(RotationFunc rotationFunc, TestExtractionFunc testExtractionFunc)
+	{
+		int Error = 0;
+
+		typedef glm::mat4::value_type value;
+		value const minAngle(-glm::pi<value>());
+		value const maxAngle(glm::pi<value>());
+		value const maxAngleWithDelta(maxAngle - 0.0000001f);
+		value const minMidAngle(-glm::pi<value>() * 0.5f);
+		value const maxMidAngle(glm::pi<value>() * 0.5f);
+
+		std::vector<glm::vec3> testEulerAngles;
+		testEulerAngles.push_back(glm::vec3(1.046f, 0.52f, -0.785f));
+		testEulerAngles.push_back(glm::vec3(minAngle, minMidAngle, minAngle));
+		testEulerAngles.push_back(glm::vec3(minAngle, minMidAngle, maxAngle));
+		testEulerAngles.push_back(glm::vec3(minAngle, minMidAngle, maxAngleWithDelta));
+		testEulerAngles.push_back(glm::vec3(minAngle, maxMidAngle, minAngle));
+		testEulerAngles.push_back(glm::vec3(minAngle, maxMidAngle, maxAngle));
+		testEulerAngles.push_back(glm::vec3(minAngle, maxMidAngle, maxAngleWithDelta));
+		testEulerAngles.push_back(glm::vec3(maxAngle, minMidAngle, minAngle));
+		testEulerAngles.push_back(glm::vec3(maxAngle, minMidAngle, maxAngle));
+		testEulerAngles.push_back(glm::vec3(maxAngle, minMidAngle, maxAngleWithDelta));
+		testEulerAngles.push_back(glm::vec3(maxAngleWithDelta, minMidAngle, maxAngle));
+		testEulerAngles.push_back(glm::vec3(maxAngleWithDelta, minMidAngle, maxAngleWithDelta));
+		testEulerAngles.push_back(glm::vec3(maxAngle, maxMidAngle, minAngle));
+		testEulerAngles.push_back(glm::vec3(maxAngleWithDelta, maxMidAngle, minAngle));
+		testEulerAngles.push_back(glm::vec3(maxAngle, maxMidAngle, maxAngle));
+		testEulerAngles.push_back(glm::vec3(maxAngle, maxMidAngle, maxAngleWithDelta));
+		testEulerAngles.push_back(glm::vec3(maxAngleWithDelta, maxMidAngle, maxAngle));
+		testEulerAngles.push_back(glm::vec3(maxAngleWithDelta, maxMidAngle, maxAngleWithDelta));
+		testEulerAngles.push_back(glm::vec3(minAngle, 0.0f, minAngle));
+		testEulerAngles.push_back(glm::vec3(minAngle, 0.0f, maxAngle));
+		testEulerAngles.push_back(glm::vec3(maxAngle, maxAngle, minAngle));
+		testEulerAngles.push_back(glm::vec3(maxAngle, maxAngle, maxAngle));
+
+		for (size_t i = 0, size = testEulerAngles.size(); i < size; ++i)
+		{
+			glm::vec3 const& angles = testEulerAngles.at(i);
+			glm::mat4 const rotation = rotationFunc(angles.x, angles.y, angles.z);
+
+			glm::vec3 extractedEulerAngles(0.0f);
+			testExtractionFunc(rotation, extractedEulerAngles.x, extractedEulerAngles.y, extractedEulerAngles.z);
+			glm::mat4 const extractedRotation = rotationFunc(extractedEulerAngles.x, extractedEulerAngles.y, extractedEulerAngles.z);
+
+			glm::vec4 const V(1.0f,1.0f,1.0f,1.0f);
+			glm::vec4 const V1 = rotation * V;
+			glm::vec4 const V2 = extractedRotation * V;
+
+			Error += glm::all(glm::epsilonEqual(V1, V2, 0.00001f)) ? 0 : 1;
+		}
+
+		return Error;
+	}
+}//namespace test_extractsEulerAngles
+
+int main()
+{ 
+	int Error = 0;
+
+	typedef glm::mat4::value_type value;
+	glm::vec3 const X(1.0f, 0.0f, 0.0f);
+	glm::vec3 const Y(0.0f, 1.0f, 0.0f);
+	glm::vec3 const Z(0.0f, 0.0f, 1.0f);
+
+	Error += test_eulerAngleX::test();
+	Error += test_eulerAngleY::test();
+	Error += test_eulerAngleZ::test();
+
+	Error += test_derivedEulerAngles::test(glm::eulerAngleX<value>, glm::derivedEulerAngleX<value>, X);
+	Error += test_derivedEulerAngles::test(glm::eulerAngleY<value>, glm::derivedEulerAngleY<value>, Y);
+	Error += test_derivedEulerAngles::test(glm::eulerAngleZ<value>, glm::derivedEulerAngleZ<value>, Z);
+
+	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();
+
+	Error += test_eulerAngles::test(glm::eulerAngleXZX<value>, X, Z, X);
+	Error += test_eulerAngles::test(glm::eulerAngleXYX<value>, X, Y, X);
+	Error += test_eulerAngles::test(glm::eulerAngleYXY<value>, Y, X, Y);
+	Error += test_eulerAngles::test(glm::eulerAngleYZY<value>, Y, Z, Y);
+	Error += test_eulerAngles::test(glm::eulerAngleZYZ<value>, Z, Y, Z);
+	Error += test_eulerAngles::test(glm::eulerAngleZXZ<value>, Z, X, Z);
+	Error += test_eulerAngles::test(glm::eulerAngleXZY<value>, X, Z, Y);
+	Error += test_eulerAngles::test(glm::eulerAngleYZX<value>, Y, Z, X);
+	Error += test_eulerAngles::test(glm::eulerAngleZYX<value>, Z, Y, X);
+	Error += test_eulerAngles::test(glm::eulerAngleZXY<value>, Z, X, Y);
+
+	Error += test_extractsEulerAngles::test(glm::eulerAngleYXZ<value>, glm::extractEulerAngleYXZ<value>);
+	Error += test_extractsEulerAngles::test(glm::eulerAngleXZX<value>, glm::extractEulerAngleXZX<value>);
+	Error += test_extractsEulerAngles::test(glm::eulerAngleXYX<value>, glm::extractEulerAngleXYX<value>);
+	Error += test_extractsEulerAngles::test(glm::eulerAngleYXY<value>, glm::extractEulerAngleYXY<value>);
+	Error += test_extractsEulerAngles::test(glm::eulerAngleYZY<value>, glm::extractEulerAngleYZY<value>);
+	Error += test_extractsEulerAngles::test(glm::eulerAngleZYZ<value>, glm::extractEulerAngleZYZ<value>);
+	Error += test_extractsEulerAngles::test(glm::eulerAngleZXZ<value>, glm::extractEulerAngleZXZ<value>);
+	Error += test_extractsEulerAngles::test(glm::eulerAngleXZY<value>, glm::extractEulerAngleXZY<value>);
+	Error += test_extractsEulerAngles::test(glm::eulerAngleYZX<value>, glm::extractEulerAngleYZX<value>);
+	Error += test_extractsEulerAngles::test(glm::eulerAngleZYX<value>, glm::extractEulerAngleZYX<value>);
+	Error += test_extractsEulerAngles::test(glm::eulerAngleZXY<value>, glm::extractEulerAngleZXY<value>);
+
+	return Error; 
+}
diff --git a/3rdparty/glm/source/test/gtx/gtx_extend.cpp b/3rdparty/glm/source/test/gtx/gtx_extend.cpp
new file mode 100644
index 0000000..0c37df5
--- /dev/null
+++ b/3rdparty/glm/source/test/gtx/gtx_extend.cpp
@@ -0,0 +1,9 @@
+#define GLM_ENABLE_EXPERIMENTAL
+#include <glm/gtx/extend.hpp>
+
+int main()
+{
+	int Error(0);
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/gtx/gtx_extended_min_max.cpp b/3rdparty/glm/source/test/gtx/gtx_extended_min_max.cpp
new file mode 100644
index 0000000..3d20f10
--- /dev/null
+++ b/3rdparty/glm/source/test/gtx/gtx_extended_min_max.cpp
@@ -0,0 +1,101 @@
+#define GLM_ENABLE_EXPERIMENTAL
+
+#include <glm/gtx/extended_min_max.hpp>
+#include <glm/gtc/vec1.hpp>
+#include <glm/gtc/constants.hpp>
+#include <glm/ext/scalar_relational.hpp>
+#include <glm/ext/vector_relational.hpp>
+
+// This file has divisions by zero to test isnan
+#if GLM_COMPILER & GLM_COMPILER_VC
+#	pragma warning(disable : 4723)
+#endif
+
+namespace fmin_
+{
+	static int test()
+	{
+		int Error = 0;
+
+		float Zero_f = 0.0f;
+		glm::vec1 A0 = glm::fmin(glm::vec1(1), glm::vec1(Zero_f / 0.0f));
+		Error += glm::equal(A0.x, 1.0f, glm::epsilon<float>()) ? 0 : 1;
+
+		glm::vec1 A1 = glm::fmin(glm::vec1(Zero_f / 0.0f), glm::vec1(1));
+		Error += glm::equal(A1.x, 1.0f, glm::epsilon<float>()) ? 0 : 1;
+
+		glm::vec2 B0 = glm::fmin(glm::vec2(1), glm::vec2(1));
+		glm::vec2 B1 = glm::fmin(glm::vec2(1), 1.0f);
+		bool B2 = glm::all(glm::equal(B0, B1, glm::epsilon<float>()));
+		Error += B2 ? 0 : 1;
+
+		glm::vec3 C0 = glm::fmin(glm::vec3(1), glm::vec3(1));
+		glm::vec3 C1 = glm::fmin(glm::vec3(1), 1.0f);
+		bool C2 = glm::all(glm::equal(C0, C1, glm::epsilon<float>()));
+		Error += C2 ? 0 : 1;
+
+		glm::vec4 D0 = glm::fmin(glm::vec4(1), glm::vec4(1));
+		glm::vec4 D1 = glm::fmin(glm::vec4(1), 1.0f);
+		bool D2 = glm::all(glm::equal(D0, D1, glm::epsilon<float>()));
+		Error += D2 ? 0 : 1;
+
+		return Error;
+	}
+}//namespace fmin_
+
+namespace fmax_
+{
+	static int test()
+	{
+		int Error = 0;
+
+		float Zero_f = 0.0f;
+		glm::vec1 A0 = glm::fmax(glm::vec1(1), glm::vec1(Zero_f / 0.0f));
+		Error += glm::equal(A0.x, 1.0f, glm::epsilon<float>()) ? 0 : 1;
+
+		glm::vec1 A1 = glm::fmax(glm::vec1(Zero_f / 0.0f), glm::vec1(1));
+		Error += glm::equal(A0.x, 1.0f, glm::epsilon<float>()) ? 0 : 1;
+
+		glm::vec2 B0 = glm::fmax(glm::vec2(1), glm::vec2(1));
+		glm::vec2 B1 = glm::fmax(glm::vec2(1), 1.0f);
+		bool B2 = glm::all(glm::equal(B0, B1, glm::epsilon<float>()));
+		Error += B2 ? 0 : 1;
+
+		glm::vec3 C0 = glm::fmax(glm::vec3(1), glm::vec3(1));
+		glm::vec3 C1 = glm::fmax(glm::vec3(1), 1.0f);
+		bool C2 = glm::all(glm::equal(C0, C1, glm::epsilon<float>()));
+		Error += C2 ? 0 : 1;
+
+		glm::vec4 D0 = glm::fmax(glm::vec4(1), glm::vec4(1));
+		glm::vec4 D1 = glm::fmax(glm::vec4(1), 1.0f);
+		bool D2 = glm::all(glm::equal(D0, D1, glm::epsilon<float>()));
+		Error += D2 ? 0 : 1;
+
+		return Error;
+	}
+}//namespace fmax_
+
+namespace fclamp_
+{
+	static int test()
+	{
+		int Error = 0;
+
+		float Zero_f = 0.0f;
+		glm::vec1 A0 = glm::fclamp(glm::vec1(1), glm::vec1(Zero_f / 0.0f), glm::vec1(2.0f));
+		Error += glm::equal(A0.x, 1.0f, glm::epsilon<float>()) ? 0 : 1;
+
+		return Error;
+	}
+}//namespace fclamp_
+
+int main()
+{
+	int Error = 0;
+
+	Error += fmin_::test();
+	Error += fmax_::test();
+	Error += fclamp_::test();
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/gtx/gtx_extented_min_max.cpp b/3rdparty/glm/source/test/gtx/gtx_extented_min_max.cpp
new file mode 100644
index 0000000..c8c7847
--- /dev/null
+++ b/3rdparty/glm/source/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/extended_min_max.hpp>
+
+int main()
+{
+	int Error(0);
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/gtx/gtx_exterior_product.cpp b/3rdparty/glm/source/test/gtx/gtx_exterior_product.cpp
new file mode 100644
index 0000000..a02c983
--- /dev/null
+++ b/3rdparty/glm/source/test/gtx/gtx_exterior_product.cpp
@@ -0,0 +1,14 @@
+#include <glm/gtx/exterior_product.hpp>
+#include <glm/gtc/epsilon.hpp>
+#include <glm/vec2.hpp>
+
+int main()
+{
+	int Error = 0;
+
+	float const f = glm::cross(glm::vec2(1.0f, 1.0f), glm::vec2(1.0f, 1.0f));
+	Error += glm::epsilonEqual(f, 0.0f, 0.001f) ? 0 : 1;
+
+	return Error;
+}
+
diff --git a/3rdparty/glm/source/test/gtx/gtx_fast_exponential.cpp b/3rdparty/glm/source/test/gtx/gtx_fast_exponential.cpp
new file mode 100644
index 0000000..341e26e
--- /dev/null
+++ b/3rdparty/glm/source/test/gtx/gtx_fast_exponential.cpp
@@ -0,0 +1,9 @@
+#define GLM_ENABLE_EXPERIMENTAL
+#include <glm/gtx/fast_exponential.hpp>
+
+int main()
+{
+	int Error(0);
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/gtx/gtx_fast_square_root.cpp b/3rdparty/glm/source/test/gtx/gtx_fast_square_root.cpp
new file mode 100644
index 0000000..80d7fe4
--- /dev/null
+++ b/3rdparty/glm/source/test/gtx/gtx_fast_square_root.cpp
@@ -0,0 +1,45 @@
+#define GLM_ENABLE_EXPERIMENTAL
+#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 Error;
+}
+
+int test_fastDistance()
+{
+	int Error = 0;
+
+	float const A = glm::fastDistance(0.0f, 1.0f);
+	float const B = glm::fastDistance(glm::vec2(0.0f), glm::vec2(1.0f, 0.0f));
+	float const C = glm::fastDistance(glm::vec3(0.0f), glm::vec3(1.0f, 0.0f, 0.0f));
+	float const D = glm::fastDistance(glm::vec4(0.0f), glm::vec4(1.0f, 0.0f, 0.0f, 0.0f));
+
+	Error += glm::epsilonEqual(A, 1.0f, 0.01f) ? 0 : 1;
+	Error += glm::epsilonEqual(B, 1.0f, 0.01f) ? 0 : 1;
+	Error += glm::epsilonEqual(C, 1.0f, 0.01f) ? 0 : 1;
+	Error += glm::epsilonEqual(D, 1.0f, 0.01f) ? 0 : 1;
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_fastInverseSqrt();
+	Error += test_fastDistance();
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/gtx/gtx_fast_trigonometry.cpp b/3rdparty/glm/source/test/gtx/gtx_fast_trigonometry.cpp
new file mode 100644
index 0000000..8bf86ba
--- /dev/null
+++ b/3rdparty/glm/source/test/gtx/gtx_fast_trigonometry.cpp
@@ -0,0 +1,564 @@
+#include <glm/ext/scalar_ulp.hpp>
+
+#define GLM_ENABLE_EXPERIMENTAL
+#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/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::nextFloat(i) : i += 0.1f)
+			result = glm::fastCos(i);
+
+		const std::clock_t timestamp2 = std::clock();
+		for(float i = begin; i < end; i = NextFloat ? glm::nextFloat(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<int>(time_fast));
+		std::printf("cos Time %d clocks\n", static_cast<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::nextFloat(i) : i += 0.1f)
+			result = glm::fastSin(i);
+
+		const std::clock_t timestamp2 = std::clock();
+		for(float i = begin; i < end; i = NextFloat ? glm::nextFloat(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<int>(time_fast));
+		std::printf("sin Time %d clocks\n", static_cast<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::nextFloat(i) : i += 0.1f)
+			result = glm::fastTan(i);
+
+		const std::clock_t timestamp2 = std::clock();
+		for (float i = begin; i < end; i = NextFloat ? glm::nextFloat(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<int>(time_fast));
+		std::printf("tan Time %d clocks\n", static_cast<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::nextFloat(i) : i += 0.1f)
+			result = glm::fastAcos(i);
+
+		const std::clock_t timestamp2 = std::clock();
+		for(float i = begin; i < end; i = NextFloat ? glm::nextFloat(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<int>(time_fast));
+		std::printf("acos Time %d clocks\n", static_cast<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::nextFloat(i) : i += 0.1f)
+			result = glm::fastAsin(i);
+		const std::clock_t timestamp2 = std::clock();
+		for(float i = begin; i < end; i = NextFloat ? glm::nextFloat(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<int>(time_fast));
+		std::printf("asin Time %d clocks\n", static_cast<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::nextFloat(i) : i += 0.1f)
+			result = glm::fastAtan(i);
+		const std::clock_t timestamp2 = std::clock();
+		for(float i = begin; i < end; i = NextFloat ? glm::nextFloat(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<int>(time_fast));
+		std::printf("atan Time %d clocks\n", static_cast<int>(time_default));
+
+		return time_fast <= time_default ? 0 : 1;
+	}
+}//namespace fastAtan
+
+namespace taylorCos
+{
+	using glm::qualifier;
+	using glm::length_t;
+	
+	glm::vec4 const AngleShift(0.0f, glm::half_pi<float>(), glm::pi<float>(), glm::three_over_two_pi<float>());
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER glm::vec<L, T, Q> taylorSeriesNewCos(glm::vec<L, T, Q> const& x)
+	{
+		glm::vec<L, T, Q> const Powed2(x * x);
+		glm::vec<L, T, Q> const Powed4(Powed2 * Powed2);
+		glm::vec<L, T, Q> const Powed6(Powed4 * Powed2);
+		glm::vec<L, T, Q> 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<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER glm::vec<L, T, Q> taylorSeriesNewCos6(glm::vec<L, T, Q> const& x)
+	{
+		glm::vec<L, T, Q> const Powed2(x * x);
+		glm::vec<L, T, Q> const Powed4(Powed2 * Powed2);
+		glm::vec<L, T, Q> 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::length_t L, qualifier Q>
+	GLM_FUNC_QUALIFIER glm::vec<L, float, Q> fastAbs(glm::vec<L, float, Q> x)
+	{
+		int* Pointer = reinterpret_cast<int*>(&x[0]);
+		Pointer[0] &= 0x7fffffff;
+		Pointer[1] &= 0x7fffffff;
+		Pointer[2] &= 0x7fffffff;
+		Pointer[3] &= 0x7fffffff;
+		return x;
+	}
+
+	template<glm::length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER glm::vec<L, T, Q> fastCosNew(glm::vec<L, T, Q> const& x)
+	{
+		glm::vec<L, T, Q> const Angle0_PI(fastAbs(fmod(x + glm::pi<T>(), glm::two_pi<T>()) - glm::pi<T>()));
+		return taylorSeriesNewCos6(x);
+/*
+		vec<L, bool, Q> const FirstQuarterPi(lessThanEqual(Angle0_PI, vec<L, T, Q>(glm::half_pi<T>())));
+
+		vec<L, T, Q> const RevertAngle(mix(vec<L, T, Q>(glm::pi<T>()), vec<L, T, Q>(0), FirstQuarterPi));
+		vec<L, T, Q> const ReturnSign(mix(vec<L, T, Q>(-1), vec<L, T, Q>(1), FirstQuarterPi));
+		vec<L, T, Q> 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 const Steps = (End - Begin) / static_cast<float>(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 * static_cast<float>(i)));
+
+		std::clock_t const TimeStampEnd = std::clock();
+
+		std::printf("fastCosNew %d clocks\n", static_cast<int>(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<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER glm::vec<L, T, Q> deterministic_fmod(glm::vec<L, T, Q> const& x, T y)
+	{
+		return x - y * trunc(x / y);
+	}
+
+	template<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER glm::vec<L, T, Q> fastCosDeterminisctic(glm::vec<L, T, Q> const& x)
+	{
+		glm::vec<L, T, Q> const Angle0_PI(abs(deterministic_fmod(x + glm::pi<T>(), glm::two_pi<T>()) - glm::pi<T>()));
+		glm::vec<L, bool, Q> const FirstQuarterPi(lessThanEqual(Angle0_PI, glm::vec<L, T, Q>(glm::half_pi<T>())));
+
+		glm::vec<L, T, Q> const RevertAngle(mix(glm::vec<L, T, Q>(glm::pi<T>()), glm::vec<L, T, Q>(0), FirstQuarterPi));
+		glm::vec<L, T, Q> const ReturnSign(mix(glm::vec<L, T, Q>(-1), glm::vec<L, T, Q>(1), FirstQuarterPi));
+		glm::vec<L, T, Q> 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 const Steps = (End - Begin) / static_cast<float>(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 * static_cast<float>(i)));
+
+		std::clock_t const TimeStampEnd = std::clock();
+
+		std::printf("fastCosDeterminisctic %d clocks\n", static_cast<int>(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<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER glm::vec<L, T, Q> taylorSeriesRefCos(glm::vec<L, T, Q> 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<length_t L, typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER glm::vec<L, T, Q> fastRefCos(glm::vec<L, T, Q> const& x)
+	{
+		glm::vec<L, T, Q> const Angle0_PI(glm::abs(fmod(x + glm::pi<T>(), glm::two_pi<T>()) - glm::pi<T>()));
+//		return taylorSeriesRefCos(Angle0_PI);
+
+		glm::vec<L, bool, Q> const FirstQuarterPi(lessThanEqual(Angle0_PI, glm::vec<L, T, Q>(glm::half_pi<T>())));
+
+		glm::vec<L, T, Q> const RevertAngle(mix(glm::vec<L, T, Q>(glm::pi<T>()), glm::vec<L, T, Q>(0), FirstQuarterPi));
+		glm::vec<L, T, Q> const ReturnSign(mix(glm::vec<L, T, Q>(-1), glm::vec<L, T, Q>(1), FirstQuarterPi));
+		glm::vec<L, T, Q> 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 const Steps = (End - Begin) / static_cast<float>(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 * static_cast<float>(i)));
+
+		std::clock_t const TimeStampEnd = std::clock();
+
+		std::printf("fastCosRef %d clocks\n", static_cast<int>(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 const Steps = (End - Begin) / static_cast<float>(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 * static_cast<float>(i)));
+
+		std::clock_t const TimeStampEnd = std::clock();
+
+		std::printf("fastCosOld %d clocks\n", static_cast<int>(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 const Steps = (End - Begin) / static_cast<float>(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 * static_cast<float>(i)));
+
+		std::clock_t const TimeStampEnd = std::clock();
+
+		std::printf("cos %d clocks\n", static_cast<int>(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
+
+namespace taylor2
+{
+	glm::vec4 const AngleShift(0.0f, glm::pi<float>() * 0.5f, glm::pi<float>() * 1.0f, glm::pi<float>() * 1.5f);
+
+	float taylorCosA(float x)
+	{
+		return 1.f
+			- (x * x) * (1.f / 2.f)
+			+ (x * x * x * x) * (1.f / 24.f)
+			- (x * x * x * x * x * x) * (1.f / 720.f)
+			+ (x * x * x * x * x * x * x * x) * (1.f / 40320.f);
+	}
+
+	float taylorCosB(float x)
+	{
+		return 1.f
+			- (x * x) * (1.f / 2.f)
+			+ (x * x * x * x) * (1.f / 24.f)
+			- (x * x * x * x * x * x) * (1.f / 720.f)
+			+ (x * x * x * x * x * x * x * x) * (1.f / 40320.f);
+	}
+
+	float taylorCosC(float x)
+	{
+		return 1.f
+			- (x * x) * (1.f / 2.f)
+			+ ((x * x) * (x * x)) * (1.f / 24.f)
+			- (((x * x) * (x * x)) * (x * x)) * (1.f / 720.f)
+			+ (((x * x) * (x * x)) * ((x * x) * (x * x))) * (1.f / 40320.f);
+	}
+
+	int perf_taylorCosA(float Begin, float End, std::size_t Samples)
+	{
+		std::vector<float> Results;
+		Results.resize(Samples);
+
+		float const Steps = (End - Begin) / static_cast<float>(Samples);
+
+		std::clock_t const TimeStampBegin = std::clock();
+
+		for(std::size_t i = 0; i < Samples; ++i)
+			Results[i] = taylorCosA(AngleShift.x + Begin + Steps * static_cast<float>(i));
+
+		std::clock_t const TimeStampEnd = std::clock();
+
+		std::printf("taylorCosA %d clocks\n", static_cast<int>(TimeStampEnd - TimeStampBegin));
+
+		int Error = 0;
+		for(std::size_t i = 0; i < Samples; ++i)
+			Error += Results[i] >= -1.0f && Results[i] <= 1.0f ? 0 : 1;
+		return Error;
+	}
+
+	int perf_taylorCosB(float Begin, float End, std::size_t Samples)
+	{
+		std::vector<float> Results;
+		Results.resize(Samples);
+
+		float const Steps = (End - Begin) / static_cast<float>(Samples);
+
+		std::clock_t const TimeStampBegin = std::clock();
+
+		for(std::size_t i = 0; i < Samples; ++i)
+			Results[i] = taylorCosB(AngleShift.x + Begin + Steps * static_cast<float>(i));
+
+		std::clock_t const TimeStampEnd = std::clock();
+
+		std::printf("taylorCosB %d clocks\n", static_cast<int>(TimeStampEnd - TimeStampBegin));
+
+		int Error = 0;
+		for(std::size_t i = 0; i < Samples; ++i)
+			Error += Results[i] >= -1.0f && Results[i] <= 1.0f ? 0 : 1;
+		return Error;
+	}
+
+	int perf_taylorCosC(float Begin, float End, std::size_t Samples)
+	{
+		std::vector<float> Results;
+		Results.resize(Samples);
+
+		float const Steps = (End - Begin) / static_cast<float>(Samples);
+
+		std::clock_t const TimeStampBegin = std::clock();
+
+		for(std::size_t i = 0; i < Samples; ++i)
+			Results[i] = taylorCosC(AngleShift.x + Begin + Steps * static_cast<float>(i));
+
+		std::clock_t const TimeStampEnd = std::clock();
+
+		std::printf("taylorCosC %d clocks\n", static_cast<int>(TimeStampEnd - TimeStampBegin));
+
+		int Error = 0;
+		for(std::size_t i = 0; i < Samples; ++i)
+			Error += Results[i] >= -1.0f && Results[i] <= 1.0f ? 0 : 1;
+		return Error;
+	}
+
+	int perf(std::size_t Samples)
+	{
+		int Error = 0;
+
+		float const Begin = -glm::pi<float>();
+		float const End = glm::pi<float>();
+
+		Error += perf_taylorCosA(Begin, End, Samples);
+		Error += perf_taylorCosB(Begin, End, Samples);
+		Error += perf_taylorCosC(Begin, End, Samples);
+
+		return Error;
+	}
+
+}//namespace taylor2
+
+int main()
+{
+	int Error(0);
+
+	Error += ::taylor2::perf(1000);
+	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;
+}
diff --git a/3rdparty/glm/source/test/gtx/gtx_functions.cpp b/3rdparty/glm/source/test/gtx/gtx_functions.cpp
new file mode 100644
index 0000000..48a6af0
--- /dev/null
+++ b/3rdparty/glm/source/test/gtx/gtx_functions.cpp
@@ -0,0 +1,36 @@
+#include <glm/gtx/functions.hpp>
+#include <glm/ext/vector_float2.hpp>
+#include <vector>
+
+int test_gauss_1d()
+{
+	int Error = 0;
+
+	std::vector<float> Result(20);
+	for(std::size_t i = 0, n = Result.size(); i < n; ++i)
+		Result[i] = glm::gauss(static_cast<float>(i) * 0.1f, 0.0f, 1.0f);
+
+	return Error;
+}
+
+int test_gauss_2d()
+{
+	int Error = 0;
+
+	std::vector<float> Result(20);
+	for(std::size_t i = 0, n = Result.size(); i < n; ++i)
+		Result[i] = glm::gauss(glm::vec2(static_cast<float>(i)) * 0.1f, glm::vec2(0.0f), glm::vec2(1.0f));
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_gauss_1d();
+	Error += test_gauss_2d();
+
+	return Error;
+}
+
diff --git a/3rdparty/glm/source/test/gtx/gtx_gradient_paint.cpp b/3rdparty/glm/source/test/gtx/gtx_gradient_paint.cpp
new file mode 100644
index 0000000..01f521b
--- /dev/null
+++ b/3rdparty/glm/source/test/gtx/gtx_gradient_paint.cpp
@@ -0,0 +1,34 @@
+#define GLM_ENABLE_EXPERIMENTAL
+#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;
+}
+
+
diff --git a/3rdparty/glm/source/test/gtx/gtx_handed_coordinate_space.cpp b/3rdparty/glm/source/test/gtx/gtx_handed_coordinate_space.cpp
new file mode 100644
index 0000000..e417688
--- /dev/null
+++ b/3rdparty/glm/source/test/gtx/gtx_handed_coordinate_space.cpp
@@ -0,0 +1,9 @@
+#define GLM_ENABLE_EXPERIMENTAL
+#include <glm/gtx/handed_coordinate_space.hpp>
+
+int main()
+{
+	int Error(0);
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/gtx/gtx_int_10_10_10_2.cpp b/3rdparty/glm/source/test/gtx/gtx_int_10_10_10_2.cpp
new file mode 100644
index 0000000..ab59bb2
--- /dev/null
+++ b/3rdparty/glm/source/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;
+}
diff --git a/3rdparty/glm/source/test/gtx/gtx_integer.cpp b/3rdparty/glm/source/test/gtx/gtx_integer.cpp
new file mode 100644
index 0000000..4c4225d
--- /dev/null
+++ b/3rdparty/glm/source/test/gtx/gtx_integer.cpp
@@ -0,0 +1,108 @@
+#define GLM_ENABLE_EXPERIMENTAL
+#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);
+
+		std::printf("Log2(%d) error A=%d, B=%d\n", 1 << i, A, B);
+	}
+
+	std::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 test_pow_uint()
+{
+	int Error = 0;
+
+	glm::uint const p0 = glm::pow(2u, 0u);
+	Error += p0 == 1u ? 0 : 1;
+
+	glm::uint const p1 = glm::pow(2u, 1u);
+	Error += p1 == 2u ? 0 : 1;
+
+	glm::uint const p2 = glm::pow(2u, 2u);
+	Error += p2 == 4u ? 0 : 1;
+
+	return Error;
+}
+
+int test_pow_int()
+{
+	int Error = 0;
+
+	int const p0 = glm::pow(2, 0u);
+	Error += p0 == 1 ? 0 : 1;
+
+	int const p1 = glm::pow(2, 1u);
+	Error += p1 == 2 ? 0 : 1;
+
+	int const p2 = glm::pow(2, 2u);
+	Error += p2 == 4 ? 0 : 1;
+
+	int const p0n = glm::pow(-2, 0u);
+	Error += p0n == -1 ? 0 : 1;
+
+	int const p1n = glm::pow(-2, 1u);
+	Error += p1n == -2 ? 0 : 1;
+
+	int const p2n = glm::pow(-2, 2u);
+	Error += p2n == 4 ? 0 : 1;
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_nlz();
+//	Error += test_floor_log2();
+	Error += test_log2();
+	Error += test_pow_uint();
+	Error += test_pow_int();
+
+	return Error;
+}
+
diff --git a/3rdparty/glm/source/test/gtx/gtx_intersect.cpp b/3rdparty/glm/source/test/gtx/gtx_intersect.cpp
new file mode 100644
index 0000000..c4a1b2a
--- /dev/null
+++ b/3rdparty/glm/source/test/gtx/gtx_intersect.cpp
@@ -0,0 +1,88 @@
+#define GLM_ENABLE_EXPERIMENTAL
+#include <glm/glm.hpp>
+#include <glm/gtc/epsilon.hpp>
+#include <glm/gtx/intersect.hpp>
+
+int test_intersectRayPlane()
+{
+	int Error = 0;
+	glm::vec3 const PlaneOrigin(0, 0, 1);
+	glm::vec3 const PlaneNormal(0, 0, -1);
+	glm::vec3 const RayOrigin(0, 0, 0);
+	glm::vec3 const RayDir(0, 0, 1);
+
+	// check that inversion of the plane normal has no effect
+	{
+		float Distance = 0;
+		bool const Result = glm::intersectRayPlane(RayOrigin, RayDir, PlaneOrigin, PlaneNormal, Distance);
+		Error += glm::abs(Distance - 1.f) <= std::numeric_limits<float>::epsilon() ? 0 : 1;
+		Error += Result ? 0 : 1;
+	}
+	{
+		float Distance = 0;
+		bool const Result = glm::intersectRayPlane(RayOrigin, RayDir, PlaneOrigin, -1.f * PlaneNormal, Distance);
+		Error += glm::abs(Distance - 1.f) <= std::numeric_limits<float>::epsilon() ? 0 : 1;
+		Error += Result ? 0 : 1;
+	}
+
+	// check if plane is before of behind the ray origin
+	{
+		float Distance = 9.9999f; // value should not be changed
+		bool const Result = glm::intersectRayPlane(RayOrigin, RayDir, -1.f * PlaneOrigin, PlaneNormal, Distance);
+		Error += glm::abs(Distance - 9.9999f) <= std::numeric_limits<float>::epsilon() ? 0 : 1;
+		Error += Result ? 1 : 0; // there is no intersection in front of the ray origin, only behind
+	}
+
+	return Error;
+}
+
+int test_intersectRayTriangle()
+{
+	int Error = 0;
+
+	glm::vec3 const Orig(0, 0, 2);
+	glm::vec3 const Dir(0, 0, -1);
+	glm::vec3 const Vert0(0, 0, 0);
+	glm::vec3 const Vert1(-1, -1, 0);
+	glm::vec3 const Vert2(1, -1, 0);
+	glm::vec2 BaryPosition(0);
+	float Distance = 0;
+
+	bool const Result = glm::intersectRayTriangle(Orig, Dir, Vert0, Vert1, Vert2, BaryPosition, Distance);
+
+	Error += glm::all(glm::epsilonEqual(BaryPosition, glm::vec2(0), std::numeric_limits<float>::epsilon())) ? 0 : 1;
+	Error += glm::abs(Distance - 2.f) <= std::numeric_limits<float>::epsilon() ? 0 : 1;
+	Error += Result ? 0 : 1;
+
+	return Error;
+}
+
+int test_intersectLineTriangle()
+{
+	int Error = 0;
+
+	glm::vec3 const Orig(0, 0, 2);
+	glm::vec3 const Dir(0, 0, -1);
+	glm::vec3 const Vert0(0, 0, 0);
+	glm::vec3 const Vert1(-1, -1, 0);
+	glm::vec3 const Vert2(1, -1, 0);
+	glm::vec3 Position(2.0f, 0.0f, 0.0f);
+
+	bool const Result = glm::intersectLineTriangle(Orig, Dir, Vert0, Vert1, Vert2, Position);
+
+	Error += glm::all(glm::epsilonEqual(Position, glm::vec3(2.0f, 0.0f, 0.0f), std::numeric_limits<float>::epsilon())) ? 0 : 1;
+	Error += Result ? 0 : 1;
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_intersectRayPlane();
+	Error += test_intersectRayTriangle();
+	Error += test_intersectLineTriangle();
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/gtx/gtx_io.cpp b/3rdparty/glm/source/test/gtx/gtx_io.cpp
new file mode 100644
index 0000000..7d90fd7
--- /dev/null
+++ b/3rdparty/glm/source/test/gtx/gtx_io.cpp
@@ -0,0 +1,186 @@
+#define GLM_ENABLE_EXPERIMENTAL
+#include <glm/glm.hpp>
+#if GLM_LANG & GLM_LANG_CXXMS_FLAG
+#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::qualifier const& a)
+	{
+		typename std::basic_ostream<CTy,CTr>::sentry const cerberus(os);
+
+		if (cerberus)
+		{
+			switch (a) {
+			case glm::highp:			os << "uhi"; break;
+			case glm::mediump:			os << "umd"; break;
+			case glm::lowp:				os << "ulo"; break;
+#			if GLM_CONFIG_ALIGNED_GENTYPES == GLM_ENABLE
+				case glm::aligned_highp:	os << "ahi"; break;
+				case glm::aligned_mediump:	os << "amd"; break;
+				case glm::aligned_lowp:		os << "alo"; break;
+#			endif
+			}
+		}
+
+		return os;
+	}
+
+	template<typename U, glm::qualifier P, typename T, typename CTy, typename CTr>
+	std::basic_string<CTy> type_name(std::basic_ostream<CTy,CTr>&, T const&)
+	{
+		std::basic_ostringstream<CTy,CTr> ostr;
+
+		if      (typeid(T) == typeid(glm::qua<U,P>))   { ostr << "quat"; }
+		else if (typeid(T) == typeid(glm::vec<2, U,P>))   { ostr << "vec2"; }
+		else if (typeid(T) == typeid(glm::vec<3, U,P>))   { ostr << "vec3"; }
+		else if (typeid(T) == typeid(glm::vec<4, U,P>))   { ostr << "vec4"; }
+		else if (typeid(T) == typeid(glm::mat<2, 2, U,P>)) { ostr << "mat2x2"; }
+		else if (typeid(T) == typeid(glm::mat<2, 3, U,P>)) { ostr << "mat2x3"; }
+		else if (typeid(T) == typeid(glm::mat<2, 4, U,P>)) { ostr << "mat2x4"; }
+		else if (typeid(T) == typeid(glm::mat<3, 2, U,P>)) { ostr << "mat3x2"; }
+		else if (typeid(T) == typeid(glm::mat<3, 3, U,P>)) { ostr << "mat3x3"; }
+		else if (typeid(T) == typeid(glm::mat<3, 4, U,P>)) { ostr << "mat3x4"; }
+		else if (typeid(T) == typeid(glm::mat<4, 2, U,P>)) { ostr << "mat4x2"; }
+		else if (typeid(T) == typeid(glm::mat<4, 3, U,P>)) { ostr << "mat4x3"; }
+		else if (typeid(T) == typeid(glm::mat<4, 4, U,P>)) { ostr << "mat4x4"; }
+		else                                             { ostr << "unknown"; }
+
+		ostr << '<' << typeid(U).name() << ',' << P << '>';
+
+		return ostr.str();
+	}
+} // namespace {
+
+template<typename T, glm::qualifier P, typename OS>
+int test_io_quat(OS& os)
+{
+	os << '\n' << typeid(OS).name() << '\n';
+
+	glm::qua<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::qualifier P, typename OS>
+int test_io_vec(OS& os)
+{
+	os << '\n' << typeid(OS).name() << '\n';
+
+	glm::vec<2, T,P> const v2(0, 1);
+	glm::vec<3, T,P> const v3(2, 3, 4);
+	glm::vec<4, 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::qualifier P, typename OS>
+int test_io_mat(OS& os, glm::io::order_type otype)
+{
+	os << '\n' << typeid(OS).name() << '\n';
+
+	glm::vec<2, T,P> const v2_1( 0,  1);
+	glm::vec<2, T,P> const v2_2( 2,  3);
+	glm::vec<2, T,P> const v2_3( 4,  5);
+	glm::vec<2, T,P> const v2_4( 6,  7);
+	glm::vec<3, T,P> const v3_1( 8,  9, 10);
+	glm::vec<3, T,P> const v3_2(11, 12, 13);
+	glm::vec<3, T,P> const v3_3(14, 15, 16);
+	glm::vec<3, T,P> const v3_4(17, 18, 19);
+	glm::vec<4, T,P> const v4_1(20, 21, 22, 23);
+	glm::vec<4, T,P> const v4_2(24, 25, 26, 27);
+	glm::vec<4, T,P> const v4_3(28, 29, 30, 31);
+	glm::vec<4, T,P> const v4_4(32, 33, 34, 35);
+
+	glm::io::basic_format_saver<typename OS::char_type> const iofs(os);
+
+	os << glm::io::precision(2) << glm::io::width(1 + 2 + 1 + 2)
+		<< glm::io::order(otype)
+		<< "mat2x2<" << typeid(T).name() << ',' << P << ">: " << glm::mat<2, 2, T,P>(v2_1, v2_2) << '\n'
+		<< "mat2x3<" << typeid(T).name() << ',' << P << ">: " << glm::mat<2, 3, T,P>(v3_1, v3_2) << '\n'
+		<< "mat2x4<" << typeid(T).name() << ',' << P << ">: " << glm::mat<2, 4, T,P>(v4_1, v4_2) << '\n'
+		<< "mat3x2<" << typeid(T).name() << ',' << P << ">: " << glm::mat<3, 2, T,P>(v2_1, v2_2, v2_3) << '\n'
+		<< "mat3x3<" << typeid(T).name() << ',' << P << ">: " << glm::mat<3, 3, T,P>(v3_1, v3_2, v3_3) << '\n'
+		<< "mat3x4<" << typeid(T).name() << ',' << P << ">: " << glm::mat<3, 4, T,P>(v4_1, v4_2, v4_3) << '\n'
+		<< "mat4x2<" << typeid(T).name() << ',' << P << ">: " << glm::mat<4, 2, T,P>(v2_1, v2_2, v2_3, v2_4) << '\n'
+		<< "mat4x3<" << typeid(T).name() << ',' << P << ">: " << glm::mat<4, 3, T,P>(v3_1, v3_2, v3_3, v3_4) << '\n'
+		<< "mat4x4<" << typeid(T).name() << ',' << P << ">: " << glm::mat<4, 4, T,P>(v4_1, v4_2, v4_3, v4_4) << '\n';
+
+	os << glm::io::unformatted
+		<< glm::io::order(otype)
+		<< "mat2x2<" << typeid(T).name() << ',' << P << ">: " << glm::mat<2, 2, T,P>(v2_1, v2_2) << '\n'
+		<< "mat2x3<" << typeid(T).name() << ',' << P << ">: " << glm::mat<2, 3, T,P>(v3_1, v3_2) << '\n'
+		<< "mat2x4<" << typeid(T).name() << ',' << P << ">: " << glm::mat<2, 4, T,P>(v4_1, v4_2) << '\n'
+		<< "mat3x2<" << typeid(T).name() << ',' << P << ">: " << glm::mat<3, 2, T,P>(v2_1, v2_2, v2_3) << '\n'
+		<< "mat3x3<" << typeid(T).name() << ',' << P << ">: " << glm::mat<3, 3, T,P>(v3_1, v3_2, v3_3) << '\n'
+		<< "mat3x4<" << typeid(T).name() << ',' << P << ">: " << glm::mat<3, 4, T,P>(v4_1, v4_2, v4_3) << '\n'
+		<< "mat4x2<" << typeid(T).name() << ',' << P << ">: " << glm::mat<4, 2, T,P>(v2_1, v2_2, v2_3, v2_4) << '\n'
+		<< "mat4x3<" << typeid(T).name() << ',' << P << ">: " << glm::mat<4, 3, T,P>(v3_1, v3_2, v3_3, v3_4) << '\n'
+		<< "mat4x4<" << typeid(T).name() << ',' << P << ">: " << glm::mat<4, 4, 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, glm::io::column_major);
+	Error += test_io_mat<float, glm::lowp>(std::wcout, glm::io::column_major);
+	Error += test_io_mat<float, glm::highp>(std::cout, glm::io::row_major);
+        Error += test_io_mat<float, glm::lowp>(std::wcout, glm::io::row_major);
+
+	return Error;
+}
+#else
+
+int main()
+{
+	return 0;
+}
+
+#endif// GLM_LANG & GLM_LANG_CXXMS_FLAG
diff --git a/3rdparty/glm/source/test/gtx/gtx_load.cpp b/3rdparty/glm/source/test/gtx/gtx_load.cpp
new file mode 100644
index 0000000..1467b9b
--- /dev/null
+++ b/3rdparty/glm/source/test/gtx/gtx_load.cpp
@@ -0,0 +1,124 @@
+#define GLM_ENABLE_EXPERIMENTAL
+#include <glm/glm.hpp>
+/*
+#if GLM_CONFIG_SIMD == GLM_ENABLE
+
+#include <glm/gtx/common.hpp>
+#include <glm/gtc/integer.hpp>
+#include <glm/gtc/epsilon.hpp>
+#include <glm/gtc/type_aligned.hpp>
+#include <glm/ext/vector_relational.hpp>
+
+namespace glm
+{
+	enum genTypeEnum
+	{
+		QUALIFIER_HIGHP,
+		QUALIFIER_MEDIUMP,
+		QUALIFIER_LOWP
+	};
+
+	template <typename genType>
+	struct genTypeTrait
+	{};
+
+	template <length_t L, typename T>
+	struct genTypeTrait<vec<L, T, aligned_highp> >
+	{
+		static const genTypeEnum GENTYPE = QUALIFIER_HIGHP;
+	};
+
+	template <length_t L, typename T>
+	struct genTypeTrait<vec<L, T, aligned_mediump> >
+	{
+		static const genTypeEnum GENTYPE = QUALIFIER_MEDIUMP;
+	};
+
+	template <length_t L, typename T>
+	struct genTypeTrait<vec<L, T, aligned_lowp> >
+	{
+		static const genTypeEnum GENTYPE = QUALIFIER_LOWP;
+	};
+
+	template<length_t L, typename T, qualifier Q, bool isAligned>
+	struct load_gentype
+	{
+	
+	};
+
+#	if GLM_ARCH & GLM_ARCH_SSE_BIT
+	template<qualifier Q>
+	struct load_gentype<4, float, Q, true>
+	{
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR static vec<4, float, Q> load(float const* Mem)
+		{
+			vec<4, float, Q> Result;
+			Result.data = _mm_loadu_ps(Mem);
+			return Result;
+		}
+	};
+#	endif//GLM_ARCH & GLM_ARCH_SSE_BIT
+
+	template<typename genType>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType example_identity()
+	{
+		return detail::init_gentype<genType, detail::genTypeTrait<genType>::GENTYPE>::identity();
+	}
+
+	template <typename genType, typename valType>
+	genType load(valType const* Mem)
+	{
+		
+	}
+
+	aligned_vec4 loadu(float const* Mem)
+	{
+		aligned_vec4 Result;
+#		if GLM_ARCH & GLM_ARCH_SSE_BIT
+			Result.data = _mm_loadu_ps(Mem);
+#		else
+			Result[0] = *(Mem + 0);
+			Result[1] = *(Mem + 1);
+			Result[2] = *(Mem + 2);
+			Result[3] = *(Mem + 3);
+#		endif//GLM_ARCH & GLM_ARCH_SSE_BIT
+		return Result;
+	}
+
+	aligned_vec4 loada(float const* Mem)
+	{
+		aligned_vec4 Result;
+#		if GLM_ARCH & GLM_ARCH_SSE_BIT
+			Result.data = _mm_load_ps(Mem);
+#		else
+			Result[0] = *(Mem + 0);
+			Result[1] = *(Mem + 1);
+			Result[2] = *(Mem + 2);
+			Result[3] = *(Mem + 3);
+#		endif//GLM_ARCH & GLM_ARCH_SSE_BIT
+		return Result;
+	}
+}//namespace glm
+
+int test_vec4_load()
+{
+	int Error = 0;
+
+	float Data[] = {1.f, 2.f, 3.f, 4.f};
+	glm::aligned_vec4 const V = glm::loadu(Data);
+	Error += glm::all(glm::equal(V, glm::aligned_vec4(1.f, 2.f, 3.f, 4.f), glm::epsilon<float>())) ? 0 : 1;
+
+	return Error;
+}
+#endif
+*/
+int main()
+{
+	int Error = 0;
+/*
+#	if GLM_CONFIG_SIMD == GLM_ENABLE
+		Error += test_vec4_load();
+#	endif
+*/
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/gtx/gtx_log_base.cpp b/3rdparty/glm/source/test/gtx/gtx_log_base.cpp
new file mode 100644
index 0000000..37c7464
--- /dev/null
+++ b/3rdparty/glm/source/test/gtx/gtx_log_base.cpp
@@ -0,0 +1,54 @@
+#define GLM_ENABLE_EXPERIMENTAL
+#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;
+}
diff --git a/3rdparty/glm/source/test/gtx/gtx_matrix_cross_product.cpp b/3rdparty/glm/source/test/gtx/gtx_matrix_cross_product.cpp
new file mode 100644
index 0000000..c1d0fa9
--- /dev/null
+++ b/3rdparty/glm/source/test/gtx/gtx_matrix_cross_product.cpp
@@ -0,0 +1,9 @@
+#define GLM_ENABLE_EXPERIMENTAL
+#include <glm/gtx/matrix_cross_product.hpp>
+
+int main()
+{
+	int Error(0);
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/gtx/gtx_matrix_decompose.cpp b/3rdparty/glm/source/test/gtx/gtx_matrix_decompose.cpp
new file mode 100644
index 0000000..5a1884e
--- /dev/null
+++ b/3rdparty/glm/source/test/gtx/gtx_matrix_decompose.cpp
@@ -0,0 +1,19 @@
+#define GLM_ENABLE_EXPERIMENTAL
+#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;
+}
diff --git a/3rdparty/glm/source/test/gtx/gtx_matrix_factorisation.cpp b/3rdparty/glm/source/test/gtx/gtx_matrix_factorisation.cpp
new file mode 100644
index 0000000..6771dba
--- /dev/null
+++ b/3rdparty/glm/source/test/gtx/gtx_matrix_factorisation.cpp
@@ -0,0 +1,105 @@
+#define GLM_ENABLE_EXPERIMENTAL
+#include <glm/gtx/matrix_factorisation.hpp>
+#include <glm/gtc/constants.hpp>
+#include <glm/gtc/epsilon.hpp>
+
+template <glm::length_t C, glm::length_t R, typename T, glm::qualifier Q>
+int test_qr(glm::mat<C, R, T, Q> m)
+{
+	int Error = 0;
+
+	T const epsilon = static_cast<T>(1e-10);
+
+	glm::mat<(C < R ? C : R), R, T, Q> q(-999);
+	glm::mat<C, (C < R ? C : R), T, Q> r(-999);
+
+	glm::qr_decompose(m, q, r);
+
+	//Test if q*r really equals the input matrix
+	glm::mat<C, R, T, Q> tm = q*r;
+	glm::mat<C, R, T, Q> err = tm - m;
+
+	for (glm::length_t i = 0; i < C; i++)
+	for (glm::length_t j = 0; j < R; j++)
+		Error += glm::abs(err[i][j]) > epsilon ? 1 : 0;
+
+	//Test if the columns of q are orthonormal
+	for (glm::length_t i = 0; i < (C < R ? C : R); i++)
+	{
+		Error += (length(q[i]) - 1) > epsilon ? 1 : 0;
+
+		for (glm::length_t j = 0; j<i; j++)
+			Error += glm::abs(dot(q[i], q[j])) > epsilon ? 1 : 0;
+	}
+
+	//Test if the matrix r is upper triangular
+	for (glm::length_t i = 0; i < C; i++)
+	for (glm::length_t j = i + 1; j < (C < R ? C : R); j++)
+		Error += glm::epsilonEqual(r[i][j], static_cast<T>(0), glm::epsilon<T>()) ? 0 : 1;
+
+	return Error;
+}
+
+template <glm::length_t C, glm::length_t R, typename T, glm::qualifier Q>
+int test_rq(glm::mat<C, R, T, Q> m)
+{
+	int Error = 0;
+
+	T const epsilon = static_cast<T>(1e-10);
+
+	glm::mat<C, (C < R ? C : R), T, Q> q(-999);
+	glm::mat<(C < R ? C : R), R, T, Q> r(-999);
+
+	glm::rq_decompose(m, r, q);
+
+	//Test if q*r really equals the input matrix
+	glm::mat<C, R, T, Q> tm = r*q;
+	glm::mat<C, R, T, Q> err = tm - m;
+
+	for (glm::length_t i = 0; i < C; i++)
+	for (glm::length_t j = 0; j < R; j++)
+		Error += glm::abs(err[i][j]) > epsilon ? 1 : 0;
+
+	//Test if the rows of q are orthonormal
+	glm::mat<(C < R ? C : R), C, T, Q> tq = transpose(q);
+
+	for (glm::length_t i = 0; i < (C < R ? C : R); i++)
+	{
+		Error += (length(tq[i]) - 1) > epsilon ? 1 : 0;
+
+		for (glm::length_t j = 0; j<i; j++)
+			Error += glm::abs(dot(tq[i], tq[j])) > epsilon ? 1 : 0;
+	}
+
+	//Test if the matrix r is upper triangular
+	for (glm::length_t i = 0; i < (C < R ? C : R); i++)
+	for (glm::length_t j = R - (C < R ? C : R) + i + 1; j < R; j++)
+		Error += glm::epsilonEqual(r[i][j], static_cast<T>(0), glm::epsilon<T>()) ? 0 : 1;
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+	//Test QR square
+	Error += test_qr(glm::dmat3(12.0, 6.0, -4.0, -51.0, 167.0, 24.0, 4.0, -68.0, -41.0)) ? 1 : 0;
+
+	//Test RQ square
+	Error += test_rq(glm::dmat3(12.0, 6.0, -4.0, -51.0, 167.0, 24.0, 4.0, -68.0, -41.0)) ? 1 : 0;
+
+	//Test QR triangular 1
+	Error += test_qr(glm::dmat3x4(12.0, 6.0, -4.0, -51.0, 167.0, 24.0, 4.0, -68.0, -41.0, 7.0, 2.0, 15.0)) ? 1 : 0;
+
+	//Test QR triangular 2
+	Error += test_qr(glm::dmat4x3(12.0, 6.0, -4.0, -51.0, 167.0, 24.0, 4.0, -68.0, -41.0, 7.0, 2.0, 15.0)) ? 1 : 0;
+
+	//Test RQ triangular 1 : Fails at the triangular test
+	Error += test_rq(glm::dmat3x4(12.0, 6.0, -4.0, -51.0, 167.0, 24.0, 4.0, -68.0, -41.0, 7.0, 2.0, 15.0)) ? 1 : 0;
+
+	//Test QR triangular 2
+	Error += test_rq(glm::dmat4x3(12.0, 6.0, -4.0, -51.0, 167.0, 24.0, 4.0, -68.0, -41.0, 7.0, 2.0, 15.0)) ? 1 : 0;
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/gtx/gtx_matrix_interpolation.cpp b/3rdparty/glm/source/test/gtx/gtx_matrix_interpolation.cpp
new file mode 100644
index 0000000..108f02e
--- /dev/null
+++ b/3rdparty/glm/source/test/gtx/gtx_matrix_interpolation.cpp
@@ -0,0 +1,122 @@
+#define GLM_ENABLE_EXPERIMENTAL
+#include <glm/gtc/quaternion.hpp>
+#include <glm/gtx/component_wise.hpp>
+#include <glm/gtx/matrix_interpolation.hpp>
+
+#include <iostream>
+#include <limits>
+#include <math.h>
+
+
+static int test_axisAngle()
+{
+	int Error = 0;
+
+	glm::mat4 m1(-0.9946f, 0.0f, -0.104531f, 0.0f,
+		0.0f, 1.0f, 0.0f, 0.0f,
+		0.104531f, 0.0f, -0.9946f, 0.0f,
+		0.0f, 0.0f, 0.0f, 1.0f);
+	glm::mat4 m2(-0.992624f, 0.0f, -0.121874f, 0.0f,
+		0.0f, 1.0f, 0.0f, 0.0f,
+		0.121874f, 0.0f, -0.992624f, 0.0f,
+		0.0f, 0.0f, 0.0f, 1.0f);
+
+	glm::mat4 const m1rot = glm::extractMatrixRotation(m1);
+	glm::mat4 const dltRotation = m2 * glm::transpose(m1rot);
+
+	glm::vec3 dltAxis(0.0f);
+	float dltAngle = 0.0f;
+	glm::axisAngle(dltRotation, dltAxis, dltAngle);
+
+	std::cout << "dltAxis: (" << dltAxis.x << ", " << dltAxis.y << ", " << dltAxis.z << "), dltAngle: " << dltAngle << std::endl;
+
+	glm::quat q = glm::quat_cast(dltRotation);
+	std::cout << "q: (" << q.x << ", " << q.y << ", " << q.z << ", " << q.w << ")" << std::endl;
+	float yaw = glm::yaw(q);
+	std::cout << "Yaw: " << yaw << std::endl;
+
+	return Error;
+}
+
+template <class T>
+int testForAxisAngle(glm::vec<3, T, glm::defaultp> const axisTrue, T const angleTrue)
+{
+    T const eps = std::sqrt(std::numeric_limits<T>::epsilon());
+
+    glm::mat<4, 4, T, glm::defaultp> const matTrue = glm::axisAngleMatrix(axisTrue, angleTrue);
+
+    glm::vec<3, T, glm::defaultp> axis;
+    T angle;
+    glm::axisAngle(matTrue, axis, angle);
+    glm::mat<4, 4, T, glm::defaultp> const matRebuilt = glm::axisAngleMatrix(axis, angle);
+
+    glm::mat<4, 4, T, glm::defaultp> const errMat = matTrue - matRebuilt;
+    T const maxErr = glm::compMax(glm::vec<4, T, glm::defaultp>(
+            glm::compMax(glm::abs(errMat[0])),
+            glm::compMax(glm::abs(errMat[1])),
+            glm::compMax(glm::abs(errMat[2])),
+            glm::compMax(glm::abs(errMat[3]))
+        ));
+    
+    return maxErr < eps ? 0 : 1;
+}
+
+static int test_axisAngle2()
+{
+	int Error = 0;
+    
+    Error += testForAxisAngle(glm::vec3(0.0f, 1.0f, 0.0f), 0.0f);
+    Error += testForAxisAngle(glm::vec3(0.358f, 0.0716f, 0.9309f), 0.00001f);
+    Error += testForAxisAngle(glm::vec3(1.0f, 0.0f, 0.0f), 0.0001f);
+    Error += testForAxisAngle(glm::vec3(0.0f, 0.0f, 1.0f), 0.001f);
+    Error += testForAxisAngle(glm::vec3(0.0f, 0.0f, 1.0f), 0.001f);
+    Error += testForAxisAngle(glm::vec3(0.0f, 1.0f, 0.0f), 0.005f);
+    Error += testForAxisAngle(glm::vec3(0.0f, 0.0f, 1.0f), 0.005f);
+    Error += testForAxisAngle(glm::vec3(0.358f, 0.0716f, 0.9309f), 0.03f);
+    Error += testForAxisAngle(glm::vec3(0.358f, 0.0716f, 0.9309f), 0.0003f);
+    Error += testForAxisAngle(glm::vec3(0.0f, 0.0f, 1.0f), 0.01f);
+    Error += testForAxisAngle(glm::dvec3(0.0f, 1.0f, 0.0f), 0.00005);
+    Error += testForAxisAngle(glm::dvec3(-1.0f, 0.0f, 0.0f), 0.000001);
+    Error += testForAxisAngle(glm::dvec3(0.7071f, 0.7071f, 0.0f), 0.5);
+    Error += testForAxisAngle(glm::dvec3(0.7071f, 0.0f, 0.7071f), 0.0002);
+    Error += testForAxisAngle(glm::dvec3(0.7071f, 0.0f, 0.7071f), 0.00002);
+    Error += testForAxisAngle(glm::dvec3(0.7071f, 0.0f, 0.7071f), 0.000002);
+    Error += testForAxisAngle(glm::dvec3(0.7071f, 0.0f, 0.7071f), 0.0000002);
+    Error += testForAxisAngle(glm::vec3(0.0f, 0.7071f, 0.7071f), 1.3f);
+    Error += testForAxisAngle(glm::vec3(0.0f, 0.7071f, 0.7071f), 6.3f);
+    Error += testForAxisAngle(glm::vec3(1.0f, 0.0f, 0.0f), -0.23456f);
+    Error += testForAxisAngle(glm::vec3(1.0f, 0.0f, 0.0f), glm::pi<float>());
+    Error += testForAxisAngle(glm::vec3(0.0f, 1.0f, 0.0f), -glm::pi<float>());
+    Error += testForAxisAngle(glm::vec3(0.358f, 0.0716f, 0.9309f), -glm::pi<float>());
+    Error += testForAxisAngle(glm::vec3(1.0f, 0.0f, 0.0f), glm::pi<float>() + 2e-6f);
+    Error += testForAxisAngle(glm::vec3(1.0f, 0.0f, 0.0f), glm::pi<float>() + 1e-4f);
+    Error += testForAxisAngle(glm::vec3(0.0f, 1.0f, 0.0f), -glm::pi<float>() + 1e-3f);
+    Error += testForAxisAngle(glm::vec3(0.358f, 0.0716f, 0.9309f), -glm::pi<float>() + 5e-3f);
+
+	return Error;
+}
+
+static int test_rotate()
+{
+	glm::mat4 m2(1.0);
+	float myAngle = 1.0f;
+	m2 = glm::rotate(m2, myAngle, glm::vec3(1.0f, 0.0f, 0.0f));
+	glm::vec3 m2Axis;
+	float m2Angle;
+	glm::axisAngle(m2, m2Axis, m2Angle);
+
+	return 0;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_axisAngle();
+	Error += test_axisAngle2();
+	Error += test_rotate();
+
+	return Error;
+}
+
+
diff --git a/3rdparty/glm/source/test/gtx/gtx_matrix_major_storage.cpp b/3rdparty/glm/source/test/gtx/gtx_matrix_major_storage.cpp
new file mode 100644
index 0000000..21de7f7
--- /dev/null
+++ b/3rdparty/glm/source/test/gtx/gtx_matrix_major_storage.cpp
@@ -0,0 +1,9 @@
+#define GLM_ENABLE_EXPERIMENTAL
+#include <glm/gtx/matrix_major_storage.hpp>
+
+int main()
+{
+	int Error(0);
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/gtx/gtx_matrix_operation.cpp b/3rdparty/glm/source/test/gtx/gtx_matrix_operation.cpp
new file mode 100644
index 0000000..79c95c5
--- /dev/null
+++ b/3rdparty/glm/source/test/gtx/gtx_matrix_operation.cpp
@@ -0,0 +1,86 @@
+#define GLM_ENABLE_EXPERIMENTAL
+#include <glm/glm.hpp>
+#include <glm/gtc/epsilon.hpp>
+#include <glm/gtx/matrix_operation.hpp>
+#include <limits>
+
+int test_adjugate()
+{
+	int Error = 0;
+
+	const float epsilon = std::numeric_limits<float>::epsilon();
+
+	// mat2
+	const glm::mat2 m2(
+		2, 3,
+		1, 5
+	);
+
+	const glm::mat2 eam2(
+		5, -3,
+		-1, 2
+	);
+
+	const glm::mat2 am2 = glm::adjugate(m2);
+
+	Error += glm::all(glm::bvec2(
+		glm::all(glm::epsilonEqual(am2[0], eam2[0], epsilon)),
+		glm::all(glm::epsilonEqual(am2[1], eam2[1], epsilon))
+	)) ? 0 : 1;
+
+	// mat3
+	const glm::mat3 m3(
+		2, 3, 3,
+		1, 5, 4,
+		4, 6, 8
+	);
+
+	const glm::mat3 eam3(
+		16, -6, -3,
+		8, 4, -5,
+		-14, 0, 7
+	);
+
+	const glm::mat3 am3 = glm::adjugate(m3);
+
+	Error += glm::all(glm::bvec3(
+		glm::all(glm::epsilonEqual(am3[0], eam3[0], epsilon)),
+		glm::all(glm::epsilonEqual(am3[1], eam3[1], epsilon)),
+		glm::all(glm::epsilonEqual(am3[2], eam3[2], epsilon))
+	)) ? 0 : 1;
+
+	// mat4
+	const glm::mat4 m4(
+		2, 3, 3, 1,
+		1, 5, 4, 3,
+		4, 6, 8, 5,
+		-2, -3, -3, 4
+	);
+
+	const glm::mat4 eam4(
+		97, -30, -15, 17,
+		45, 20, -25, 5,
+		-91, 0, 35, -21,
+		14, 0, 0, 14
+	);
+
+	const glm::mat4 am4 = glm::adjugate(m4);
+
+	Error += glm::all(glm::bvec4(
+		glm::all(glm::epsilonEqual(am4[0], eam4[0], epsilon)),
+		glm::all(glm::epsilonEqual(am4[1], eam4[1], epsilon)),
+		glm::all(glm::epsilonEqual(am4[2], eam4[2], epsilon)),
+		glm::all(glm::epsilonEqual(am4[3], eam4[3], epsilon))
+	)) ? 0 : 1;
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_adjugate();
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/gtx/gtx_matrix_query.cpp b/3rdparty/glm/source/test/gtx/gtx_matrix_query.cpp
new file mode 100644
index 0000000..0dda1f0
--- /dev/null
+++ b/3rdparty/glm/source/test/gtx/gtx_matrix_query.cpp
@@ -0,0 +1,66 @@
+#define GLM_ENABLE_EXPERIMENTAL
+#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;
+}
+
+
diff --git a/3rdparty/glm/source/test/gtx/gtx_matrix_transform_2d.cpp b/3rdparty/glm/source/test/gtx/gtx_matrix_transform_2d.cpp
new file mode 100644
index 0000000..f80d263
--- /dev/null
+++ b/3rdparty/glm/source/test/gtx/gtx_matrix_transform_2d.cpp
@@ -0,0 +1,9 @@
+#define GLM_ENABLE_EXPERIMENTAL
+#include <glm/gtx/matrix_transform_2d.hpp>
+
+int main()
+{
+	int Error(0);
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/gtx/gtx_mixed_product.cpp b/3rdparty/glm/source/test/gtx/gtx_mixed_product.cpp
new file mode 100644
index 0000000..ab59bb2
--- /dev/null
+++ b/3rdparty/glm/source/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;
+}
diff --git a/3rdparty/glm/source/test/gtx/gtx_norm.cpp b/3rdparty/glm/source/test/gtx/gtx_norm.cpp
new file mode 100644
index 0000000..e82102a
--- /dev/null
+++ b/3rdparty/glm/source/test/gtx/gtx_norm.cpp
@@ -0,0 +1,81 @@
+#define GLM_ENABLE_EXPERIMENTAL
+#include <glm/gtx/norm.hpp>
+
+
+int test_lMaxNorm()
+{
+	int Error(0);
+	
+	{
+		float norm = glm::lMaxNorm(glm::vec3(-1, -2, -3));
+		Error += glm::epsilonEqual(norm, 3.f, 0.00001f) ? 0 : 1;
+	}
+
+	{
+		float norm = glm::lMaxNorm(glm::vec3(2, 3, 1));
+		Error += glm::epsilonEqual(norm, 3.f, 0.00001f) ? 0 : 1;
+	}
+  
+	return Error;
+}
+
+int test_lxNorm()
+{
+	int Error(0);
+
+	{
+		unsigned int depth_1 = 1;
+		float normA = glm::lxNorm(glm::vec3(2, 3, 1), depth_1);
+		float normB = glm::l1Norm(glm::vec3(2, 3, 1));
+		Error += glm::epsilonEqual(normA, normB, 0.00001f) ? 0 : 1;
+		Error += glm::epsilonEqual(normA, 6.f, 0.00001f) ? 0 : 1;
+	}
+
+	{
+		unsigned int depth_1 = 1;
+		float normA = glm::lxNorm(glm::vec3(-1, -2, -3), depth_1);
+		float normB = glm::l1Norm(glm::vec3(-1, -2, -3));
+		Error += glm::epsilonEqual(normA, normB, 0.00001f) ? 0 : 1;
+		Error += glm::epsilonEqual(normA, 6.f, 0.00001f) ? 0 : 1;
+	}
+
+	{
+		unsigned int depth_2 = 2;
+		float normA = glm::lxNorm(glm::vec3(2, 3, 1), depth_2);
+		float normB = glm::l2Norm(glm::vec3(2, 3, 1));
+		Error += glm::epsilonEqual(normA, normB, 0.00001f) ? 0 : 1;
+		Error += glm::epsilonEqual(normA, 3.741657387f, 0.00001f) ? 0 : 1;
+	}
+
+	{
+		unsigned int depth_2 = 2;
+		float normA = glm::lxNorm(glm::vec3(-1, -2, -3), depth_2);
+		float normB = glm::l2Norm(glm::vec3(-1, -2, -3));
+		Error += glm::epsilonEqual(normA, normB, 0.00001f) ? 0 : 1;
+		Error += glm::epsilonEqual(normA, 3.741657387f, 0.00001f) ? 0 : 1;
+	}
+
+	{
+		unsigned int oddDepth = 3;
+		float norm = glm::lxNorm(glm::vec3(2, 3, 1), oddDepth);
+		Error += glm::epsilonEqual(norm, 3.301927249f, 0.00001f) ? 0 : 1;
+	}
+
+	{
+		unsigned int oddDepth = 3;
+		float norm = glm::lxNorm(glm::vec3(-1, -2, -3), oddDepth);
+		Error += glm::epsilonEqual(norm, 3.301927249f, 0.00001f) ? 0 : 1;
+	}
+
+	return Error;
+}
+
+int main()
+{
+	int Error(0);
+
+	Error += test_lMaxNorm();
+	Error += test_lxNorm();
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/gtx/gtx_normal.cpp b/3rdparty/glm/source/test/gtx/gtx_normal.cpp
new file mode 100644
index 0000000..7a01ec0
--- /dev/null
+++ b/3rdparty/glm/source/test/gtx/gtx_normal.cpp
@@ -0,0 +1,9 @@
+#define GLM_ENABLE_EXPERIMENTAL
+#include <glm/gtx/normal.hpp>
+
+int main()
+{
+	int Error(0);
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/gtx/gtx_normalize_dot.cpp b/3rdparty/glm/source/test/gtx/gtx_normalize_dot.cpp
new file mode 100644
index 0000000..9605863
--- /dev/null
+++ b/3rdparty/glm/source/test/gtx/gtx_normalize_dot.cpp
@@ -0,0 +1,9 @@
+#define GLM_ENABLE_EXPERIMENTAL
+#include <glm/gtx/normalize_dot.hpp>
+
+int main()
+{
+	int Error(0);
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/gtx/gtx_number_precision.cpp b/3rdparty/glm/source/test/gtx/gtx_number_precision.cpp
new file mode 100644
index 0000000..a5a3ef2
--- /dev/null
+++ b/3rdparty/glm/source/test/gtx/gtx_number_precision.cpp
@@ -0,0 +1,9 @@
+#define GLM_ENABLE_EXPERIMENTAL
+#include <glm/gtx/number_precision.hpp>
+
+int main()
+{
+	int Error(0);
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/gtx/gtx_optimum_pow.cpp b/3rdparty/glm/source/test/gtx/gtx_optimum_pow.cpp
new file mode 100644
index 0000000..c0a3fd4
--- /dev/null
+++ b/3rdparty/glm/source/test/gtx/gtx_optimum_pow.cpp
@@ -0,0 +1,9 @@
+#define GLM_ENABLE_EXPERIMENTAL
+#include <glm/gtx/optimum_pow.hpp>
+
+int main()
+{
+	int Error(0);
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/gtx/gtx_orthonormalize.cpp b/3rdparty/glm/source/test/gtx/gtx_orthonormalize.cpp
new file mode 100644
index 0000000..0e7a8c8
--- /dev/null
+++ b/3rdparty/glm/source/test/gtx/gtx_orthonormalize.cpp
@@ -0,0 +1,9 @@
+#define GLM_ENABLE_EXPERIMENTAL
+#include <glm/gtx/orthonormalize.hpp>
+
+int main()
+{
+	int Error(0);
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/gtx/gtx_pca.cpp b/3rdparty/glm/source/test/gtx/gtx_pca.cpp
new file mode 100644
index 0000000..120e277
--- /dev/null
+++ b/3rdparty/glm/source/test/gtx/gtx_pca.cpp
@@ -0,0 +1,724 @@
+#define GLM_ENABLE_EXPERIMENTAL
+#include <glm/glm.hpp>
+#include <glm/gtx/pca.hpp>
+#include <glm/gtc/epsilon.hpp>
+#include <glm/gtx/string_cast.hpp>
+
+#include <cstdio>
+#include <vector>
+#if GLM_HAS_CXX11_STL == 1
+#include <random>
+#endif
+
+template<typename T>
+T myEpsilon();
+template<>
+GLM_INLINE GLM_CONSTEXPR float myEpsilon<float>() { return 0.00001f; }
+template<>
+GLM_INLINE GLM_CONSTEXPR double myEpsilon<double>() { return 0.000001; }
+
+template<glm::length_t D, typename T, glm::qualifier Q>
+bool vectorEpsilonEqual(glm::vec<D, T, Q> const& a, glm::vec<D, T, Q> const& b, T epsilon)
+{
+	for (int c = 0; c < D; ++c)
+		if (!glm::epsilonEqual(a[c], b[c], epsilon))
+		{
+			fprintf(stderr, "failing vectorEpsilonEqual: [%d] %lf != %lf (~%lf)\n",
+				c,
+				static_cast<double>(a[c]),
+				static_cast<double>(b[c]),
+				static_cast<double>(epsilon)
+			);
+			return false;
+		}
+	return true;
+}
+
+template<glm::length_t D, typename T, glm::qualifier Q>
+bool matrixEpsilonEqual(glm::mat<D, D, T, Q> const& a, glm::mat<D, D, T, Q> const& b, T epsilon)
+{
+	for (int c = 0; c < D; ++c)
+		for (int r = 0; r < D; ++r)
+			if (!glm::epsilonEqual(a[c][r], b[c][r], epsilon))
+			{
+				fprintf(stderr, "failing vectorEpsilonEqual: [%d][%d] %lf != %lf (~%lf)\n",
+					c, r,
+					static_cast<double>(a[c][r]),
+					static_cast<double>(b[c][r]),
+					static_cast<double>(epsilon)
+				);
+				return false;
+			}
+	return true;
+}
+
+template<typename T>
+GLM_INLINE bool sameSign(T const& a, T const& b)
+{
+	return ((a >= 0) && (b >= 0)) || ((a < 0) && (b < 0));
+}
+
+template<typename T>
+T failReport(T line)
+{
+	fprintf(stderr, "Failed in line %d\n", static_cast<int>(line));
+	return line;
+}
+
+// Test data: 1AGA 'agarose double helix'
+// https://www.rcsb.org/structure/1aga
+// The fourth coordinate is randomized
+namespace _1aga
+{
+
+	// Fills `outTestData` with hard-coded atom positions from 1AGA
+	// The fourth coordinate is randomized
+	template<typename vec>
+	void fillTestData(std::vector<vec>& outTestData)
+	{
+		// x,y,z coordinates copied from RCSB PDB file of 1AGA
+		// w coordinate randomized with standard normal distribution
+		static const double _1aga[] = {
+			3.219, -0.637, 19.462, 2.286,
+			4.519, 0.024, 18.980, -0.828,
+			4.163, 1.425, 18.481, -0.810,
+			3.190, 1.341, 17.330, -0.170,
+			1.962, 0.991, 18.165, 0.816,
+			2.093, 1.952, 19.331, 0.276,
+			5.119, -0.701, 17.908, -0.490,
+			3.517, 2.147, 19.514, -0.207,
+			2.970, 2.609, 16.719, 0.552,
+			2.107, -0.398, 18.564, 0.403,
+			2.847, 2.618, 15.335, 0.315,
+			1.457, 3.124, 14.979, 0.683,
+			1.316, 3.291, 13.473, 0.446,
+			2.447, 4.155, 12.931, 1.324,
+			3.795, 3.614, 13.394, 0.112,
+			4.956, 4.494, 12.982, 0.253,
+			0.483, 2.217, 15.479, 1.316,
+			0.021, 3.962, 13.166, 1.522,
+			2.311, 5.497, 13.395, 0.248,
+			3.830, 3.522, 14.827, 0.591,
+			5.150, 4.461, 11.576, 0.635,
+			-1.057, 3.106, 13.132, 0.191,
+			-2.280, 3.902, 12.650, 1.135,
+			-3.316, 2.893, 12.151, 0.794,
+			-2.756, 2.092, 11.000, 0.720,
+			-1.839, 1.204, 11.835, -1.172,
+			-2.737, 0.837, 13.001, -0.313,
+			-1.952, 4.784, 11.578, 2.082,
+			-3.617, 1.972, 13.184, 0.653,
+			-3.744, 1.267, 10.389, -0.413,
+			-0.709, 2.024, 12.234, -1.747,
+			-3.690, 1.156, 9.005, -1.275,
+			-3.434, -0.300, 8.649, 0.441,
+			-3.508, -0.506, 7.143, 0.237,
+			-4.822, 0.042, 6.601, -2.856,
+			-5.027, 1.480, 7.064, 0.985,
+			-6.370, 2.045, 6.652, 0.915,
+			-2.162, -0.690, 9.149, 1.100,
+			-3.442, -1.963, 6.836, -0.081,
+			-5.916, -0.747, 7.065, -2.345,
+			-4.965, 1.556, 8.497, 0.504,
+			-6.439, 2.230, 5.246, 1.451,
+			-2.161, -2.469, 6.802, -1.171,
+			-2.239, -3.925, 6.320, -1.434,
+			-0.847, -4.318, 5.821, 0.098,
+			-0.434, -3.433, 4.670, -1.446,
+			-0.123, -2.195, 5.505, 0.182,
+			0.644, -2.789, 6.671, 0.865,
+			-3.167, -4.083, 5.248, -0.098,
+			0.101, -4.119, 6.854, -0.001,
+			0.775, -3.876, 4.059, 1.061,
+			-1.398, -1.625, 5.904, 0.230,
+			0.844, -3.774, 2.675, 1.313,
+			1.977, -2.824, 2.319, -0.112,
+			2.192, -2.785, 0.813, -0.981,
+			2.375, -4.197, 0.271, -0.355,
+			1.232, -5.093, 0.734, 0.632,
+			1.414, -6.539, 0.322, 0.576,
+			1.678, -1.527, 2.819, -1.187,
+			3.421, -1.999, 0.496, -1.770,
+			3.605, -4.750, 0.735, 1.099,
+			1.135, -5.078, 2.167, 0.854,
+			1.289, -6.691, -1.084, -0.487,
+			-1.057, 3.106, 22.602, -1.297,
+			-2.280, 3.902, 22.120, 0.376,
+			-3.316, 2.893, 21.621, 0.932,
+			-2.756, 2.092, 20.470, 1.680,
+			-1.839, 1.204, 21.305, 0.615,
+			-2.737, 0.837, 22.471, 0.899,
+			-1.952, 4.784, 21.048, -0.521,
+			-3.617, 1.972, 22.654, 0.133,
+			-3.744, 1.267, 19.859, 0.081,
+			-0.709, 2.024, 21.704, 1.420,
+			-3.690, 1.156, 18.475, -0.850,
+			-3.434, -0.300, 18.119, -0.249,
+			-3.508, -0.506, 16.613, 1.434,
+			-4.822, 0.042, 16.071, -2.466,
+			-5.027, 1.480, 16.534, -1.045,
+			-6.370, 2.045, 16.122, 1.707,
+			-2.162, -0.690, 18.619, -2.023,
+			-3.442, -1.963, 16.336, -0.304,
+			-5.916, -0.747, 16.535, 0.979,
+			-4.965, 1.556, 17.967, -1.165,
+			-6.439, 2.230, 14.716, 0.929,
+			-2.161, -2.469, 16.302, -0.234,
+			-2.239, -3.925, 15.820, -0.228,
+			-0.847, -4.318, 15.321, 1.844,
+			-0.434, -3.433, 14.170, 1.132,
+			-0.123, -2.195, 15.005, 0.211,
+			0.644, -2.789, 16.171, -0.632,
+			-3.167, -4.083, 14.748, -0.519,
+			0.101, -4.119, 16.354, 0.173,
+			0.775, -3.876, 13.559, 1.243,
+			-1.398, -1.625, 15.404, -0.187,
+			0.844, -3.774, 12.175, -1.332,
+			1.977, -2.824, 11.819, -1.616,
+			2.192, -2.785, 10.313, 1.320,
+			2.375, -4.197, 9.771, 0.237,
+			1.232, -5.093, 10.234, 0.851,
+			1.414, -6.539, 9.822, 1.816,
+			1.678, -1.527, 12.319, -1.657,
+			3.421, -1.999, 10.036, 1.559,
+			3.605, -4.750, 10.235, 0.831,
+			1.135, -5.078, 11.667, 0.060,
+			1.289, -6.691, 8.416, 1.066,
+			3.219, -0.637, 10.002, 2.111,
+			4.519, 0.024, 9.520, -0.874,
+			4.163, 1.425, 9.021, -1.012,
+			3.190, 1.341, 7.870, -0.250,
+			1.962, 0.991, 8.705, -1.359,
+			2.093, 1.952, 9.871, -0.126,
+			5.119, -0.701, 8.448, 0.995,
+			3.517, 2.147, 10.054, 0.941,
+			2.970, 2.609, 7.259, -0.562,
+			2.107, -0.398, 9.104, -0.038,
+			2.847, 2.618, 5.875, 0.398,
+			1.457, 3.124, 5.519, 0.481,
+			1.316, 3.291, 4.013, -0.187,
+			2.447, 4.155, 3.471, -0.429,
+			3.795, 3.614, 3.934, -0.432,
+			4.956, 4.494, 3.522, -0.788,
+			0.483, 2.217, 6.019, -0.923,
+			0.021, 3.962, 3.636, -0.316,
+			2.311, 5.497, 3.935, -1.917,
+			3.830, 3.522, 5.367, -0.302,
+			5.150, 4.461, 2.116, -1.615
+		};
+		static const glm::length_t _1agaSize = sizeof(_1aga) / (4 * sizeof(double));
+
+		outTestData.resize(_1agaSize);
+		for(glm::length_t i = 0; i < _1agaSize; ++i)
+			for(glm::length_t d = 0; d < static_cast<glm::length_t>(vec::length()); ++d)
+				outTestData[i][d] = static_cast<typename vec::value_type>(_1aga[i * 4 + d]);
+	}
+
+	// All reference values computed separately using symbolic precision
+	// https://github.com/sgrottel/exp-pca-precision
+	// This applies to all functions named: `_1aga::expected*()`
+
+	GLM_INLINE glm::dmat4 const& expectedCovarData()
+	{
+		static const glm::dmat4 covar4x4d(
+			9.62434068027210898322, -0.00006657369614512471, -4.29321376568405099761, 0.01879374187452758846,
+			-0.00006657369614512471, 9.62443937868480681175, 5.35113872637944076871, -0.11569259145880574080,
+			-4.29321376568405099761, 5.35113872637944076871, 35.62848549634668415820, 0.90874239254220201545,
+			0.01879374187452758846, -0.11569259145880574080, 0.90874239254220201545, 1.09705971856890904803
+		);
+		return covar4x4d;
+	}
+
+	template<glm::length_t D>
+	GLM_INLINE glm::vec<D, double, glm::defaultp> const& expectedEigenvalues();
+	template<>
+	GLM_INLINE glm::dvec2 const& expectedEigenvalues<2>()
+	{
+		static const glm::dvec2 evals2(
+			9.62447289926297399961763301774251330057894539467032275382255,
+			9.62430715969394210015560961264297422776572580714373620309355
+		);
+		return evals2;
+	}
+	template<>
+	GLM_INLINE glm::dvec3 const& expectedEigenvalues<3>()
+	{
+		static const glm::dvec3 evals3(
+				37.3274494274683425233695502581182052836449738530676689472257,
+				9.62431434161498823505729817436585077939509766554969096873168,
+				7.92550178622027216422369326567668971675332732240052872097887
+			);
+		return evals3;
+	}
+	template<>
+	GLM_INLINE glm::dvec4 const& expectedEigenvalues<4>()
+	{
+		static const glm::dvec4 evals4(
+				37.3477389918792213596879452204499702406947817221901007885630,
+				9.62470688921105696017807313860277172063600080413412567999700,
+				7.94017075281634999342344275928070533134615133171969063657713,
+				1.06170863996588365446060186982477896078741484440002343404155
+			);
+		return evals4;
+	}
+
+	template<glm::length_t D>
+	GLM_INLINE glm::mat<D, D, double, glm::defaultp> const& expectedEigenvectors();
+	template<>
+	GLM_INLINE glm::dmat2 const& expectedEigenvectors<2>()
+	{
+		static const glm::dmat2 evecs2(
+			glm::dvec2(
+				-0.503510847492551904906870957742619139443409162857537237123308,
+				1
+			),
+			glm::dvec2(
+				1.98605453086051402895741763848787613048533838388005162794043,
+				1
+			)
+		);
+		return evecs2;
+	}
+	template<>
+	GLM_INLINE glm::dmat3 const& expectedEigenvectors<3>()
+	{
+		static const glm::dmat3 evecs3(
+			glm::dvec3(
+				-0.154972738414395866005286433008304444294405085038689821864654,
+				0.193161285869815165989799191097521722568079378840201629578695,
+				1
+			),
+			glm::dvec3(
+				-158565.112775416943154745839952575022429933119522746586149868,
+				-127221.506282351944358932458687410410814983610301927832439675,
+				1
+			),
+			glm::dvec3(
+				2.52702248596556806145700361724323960543858113426446460406536,
+				-3.14959802931313870497377546974185300816008580801457419079412,
+				1
+			)
+		);
+		return evecs3;
+	}
+	template<>
+	GLM_INLINE glm::dmat4 const& expectedEigenvectors<4>()
+	{
+		static const glm::dmat4 evecs4(
+			glm::dvec4(
+				-6.35322390281037045217295803597357821705371650876122113027264,
+				7.91546394153385394517767054617789939529794642646629201212056,
+				41.0301543819240679808549819457450130787045236815736490549663,
+				1
+			),
+			glm::dvec4(
+				-114.622418941087829756565311692197154422302604224781253861297,
+				-92.2070185807065289900871215218752013659402949497379896153118,
+				0.0155846091025912430932734548933329458404665760587569100867246,
+				1
+			),
+			glm::dvec4(
+				13.1771887761559019483954743159026938257325190511642952175789,
+				-16.3688257459634877666638419310116970616615816436949741766895,
+				5.17386502341472097227408249233288958059579189051394773143190,
+				1
+			),
+			glm::dvec4(
+				-0.0192777078948229800494895064532553117703859768210647632969276,
+				0.0348034950916108873629241563077465542944938906271231198634442,
+				-0.0340715609308469289267379681032545422644143611273049912226126,
+				1
+			)
+		);
+		return evecs4;
+	}
+
+} // namespace _1aga
+
+// Compute center of gravity
+template<typename vec>
+vec computeCenter(const std::vector<vec>& testData)
+{
+	double c[4];
+	std::fill(c, c + vec::length(), 0.0);
+
+	typename std::vector<vec>::const_iterator e = testData.end();
+	for(typename std::vector<vec>::const_iterator i = testData.begin(); i != e; ++i)
+		for(glm::length_t d = 0; d < static_cast<glm::length_t>(vec::length()); ++d)
+			c[d] += static_cast<double>((*i)[d]);
+
+	vec cVec(0);
+	for(glm::length_t d = 0; d < static_cast<glm::length_t>(vec::length()); ++d)
+		cVec[d] = static_cast<typename vec::value_type>(c[d] / static_cast<double>(testData.size()));
+	return cVec;
+}
+
+// Test sorting of Eigenvalue&Eigenvector lists. Use exhaustive search.
+template<glm::length_t D, typename T, glm::qualifier Q>
+int testEigenvalueSort()
+{
+	// Test input data: four arbitrary values
+	static const glm::vec<D, T, Q> refVal(
+		glm::vec<4, T, Q>(
+			10, 8, 6, 4
+		)
+	);
+	// Test input data: four arbitrary vectors, which can be matched to the above values
+	static const glm::mat<D, D, T, Q> refVec(
+		glm::mat<4, 4, T, Q>(
+			10, 20, 5, 40,
+			8, 16, 4, 32,
+			6, 12, 3, 24,
+			4, 8, 2, 16
+		)
+	);
+	// Permutations of test input data for exhaustive check, based on `D` (1 <= D <= 4)
+	static const int permutationCount[] = {
+		0,
+		1,
+		2,
+		6,
+		24
+	};
+	// The permutations t perform, based on `D` (1 <= D <= 4)
+	static const glm::ivec4 permutation[] = {
+		glm::ivec4(0, 1, 2, 3),
+		glm::ivec4(1, 0, 2, 3), // last for D = 2
+		glm::ivec4(0, 2, 1, 3),
+		glm::ivec4(1, 2, 0, 3),
+		glm::ivec4(2, 0, 1, 3),
+		glm::ivec4(2, 1, 0, 3), // last for D = 3
+		glm::ivec4(0, 1, 3, 2),
+		glm::ivec4(1, 0, 3, 2),
+		glm::ivec4(0, 2, 3, 1),
+		glm::ivec4(1, 2, 3, 0),
+		glm::ivec4(2, 0, 3, 1),
+		glm::ivec4(2, 1, 3, 0),
+		glm::ivec4(0, 3, 1, 2),
+		glm::ivec4(1, 3, 0, 2),
+		glm::ivec4(0, 3, 2, 1),
+		glm::ivec4(1, 3, 2, 0),
+		glm::ivec4(2, 3, 0, 1),
+		glm::ivec4(2, 3, 1, 0),
+		glm::ivec4(3, 0, 1, 2),
+		glm::ivec4(3, 1, 0, 2),
+		glm::ivec4(3, 0, 2, 1),
+		glm::ivec4(3, 1, 2, 0),
+		glm::ivec4(3, 2, 0, 1),
+		glm::ivec4(3, 2, 1, 0)  // last for D = 4
+	};
+
+	// initial sanity check
+	if(!vectorEpsilonEqual(refVal, refVal, myEpsilon<T>()))
+		return failReport(__LINE__);
+	if(!matrixEpsilonEqual(refVec, refVec, myEpsilon<T>()))
+		return failReport(__LINE__);
+
+	// Exhaustive search through all permutations
+	for(int p = 0; p < permutationCount[D]; ++p)
+	{
+		glm::vec<D, T, Q> testVal;
+		glm::mat<D, D, T, Q> testVec;
+		for(int i = 0; i < D; ++i)
+		{
+			testVal[i] = refVal[permutation[p][i]];
+			testVec[i] = refVec[permutation[p][i]];
+		}
+
+		glm::sortEigenvalues(testVal, testVec);
+
+		if (!vectorEpsilonEqual(testVal, refVal, myEpsilon<T>()))
+			return failReport(__LINE__);
+		if (!matrixEpsilonEqual(testVec, refVec, myEpsilon<T>()))
+			return failReport(__LINE__);
+	}
+
+	return 0;
+}
+
+// Test covariance matrix creation functions
+template<glm::length_t D, typename T, glm::qualifier Q>
+int testCovar(
+#if GLM_HAS_CXX11_STL == 1
+	glm::length_t dataSize, unsigned int randomEngineSeed
+#else // GLM_HAS_CXX11_STL == 1
+	glm::length_t, unsigned int
+#endif // GLM_HAS_CXX11_STL == 1
+)
+{
+	typedef glm::vec<D, T, Q> vec;
+	typedef glm::mat<D, D, T, Q> mat;
+
+	// #1: test expected result with fixed data set
+	std::vector<vec> testData;
+	_1aga::fillTestData(testData);
+
+	// compute center of gravity
+	vec center = computeCenter(testData);
+
+	mat covarMat = glm::computeCovarianceMatrix(testData.data(), testData.size(), center);
+	if(!matrixEpsilonEqual(covarMat, mat(_1aga::expectedCovarData()), myEpsilon<T>()))
+	{
+		fprintf(stderr, "Reconstructed covarMat:\n%s\n", glm::to_string(covarMat).c_str());
+		return failReport(__LINE__);
+	}
+
+	// #2: test function variant consitency with random data
+#if GLM_HAS_CXX11_STL == 1
+	std::default_random_engine rndEng(randomEngineSeed);
+	std::normal_distribution<T> normalDist;
+	testData.resize(dataSize);
+	// some common offset of all data
+	T offset[D];
+	for(glm::length_t d = 0; d < D; ++d)
+		offset[d] = normalDist(rndEng);
+	// init data
+	for(glm::length_t i = 0; i < dataSize; ++i)
+		for(glm::length_t d = 0; d < D; ++d)
+			testData[i][d] = offset[d] + normalDist(rndEng);
+	center = computeCenter(testData);
+
+	std::vector<vec> centeredTestData;
+	centeredTestData.reserve(testData.size());
+	typename std::vector<vec>::const_iterator e = testData.end();
+	for(typename std::vector<vec>::const_iterator i = testData.begin(); i != e; ++i)
+		centeredTestData.push_back((*i) - center);
+
+	mat c1 = glm::computeCovarianceMatrix(centeredTestData.data(), centeredTestData.size());
+	mat c2 = glm::computeCovarianceMatrix<D, T, Q>(centeredTestData.begin(), centeredTestData.end());
+	mat c3 = glm::computeCovarianceMatrix(testData.data(), testData.size(), center);
+	mat c4 = glm::computeCovarianceMatrix<D, T, Q>(testData.rbegin(), testData.rend(), center);
+
+	if(!matrixEpsilonEqual(c1, c2, myEpsilon<T>()))
+		return failReport(__LINE__);
+	if(!matrixEpsilonEqual(c1, c3, myEpsilon<T>()))
+		return failReport(__LINE__);
+	if(!matrixEpsilonEqual(c1, c4, myEpsilon<T>()))
+		return failReport(__LINE__);
+#endif // GLM_HAS_CXX11_STL == 1
+	return 0;
+}
+
+// Computes eigenvalues and eigenvectors from well-known covariance matrix
+template<glm::length_t D, typename T, glm::qualifier Q>
+int testEigenvectors(T epsilon)
+{
+	typedef glm::vec<D, T, Q> vec;
+	typedef glm::mat<D, D, T, Q> mat;
+
+	// test expected result with fixed data set
+	std::vector<vec> testData;
+	mat covarMat(_1aga::expectedCovarData());
+
+	vec eigenvalues;
+	mat eigenvectors;
+	unsigned int c = glm::findEigenvaluesSymReal(covarMat, eigenvalues, eigenvectors);
+	if(c != D)
+		return failReport(__LINE__);
+	glm::sortEigenvalues(eigenvalues, eigenvectors);
+
+	if (!vectorEpsilonEqual(eigenvalues, vec(_1aga::expectedEigenvalues<D>()), epsilon))
+		return failReport(__LINE__);
+
+	for (int i = 0; i < D; ++i)
+	{
+		vec act = glm::normalize(eigenvectors[i]);
+		vec exp = glm::normalize(_1aga::expectedEigenvectors<D>()[i]);
+		if (!sameSign(act[0], exp[0])) exp = -exp;
+		if (!vectorEpsilonEqual(act, exp, epsilon))
+			return failReport(__LINE__);
+	}
+
+	return 0;
+}
+
+// A simple small smoke test:
+// - a uniformly sampled block
+// - reconstruct main axes
+// - check order of eigenvalues equals order of extends of block in direction of main axes
+int smokeTest()
+{
+	using glm::vec3;
+	using glm::mat3;
+	std::vector<vec3> pts;
+	pts.reserve(11 * 15 * 7);
+
+	for(int x = -5; x <= 5; ++x)
+		for(int y = -7; y <= 7; ++y)
+			for(int z = -3; z <= 3; ++z)
+				pts.push_back(vec3(x, y, z));
+
+	mat3 covar = glm::computeCovarianceMatrix(pts.data(), pts.size());
+	mat3 eVec;
+	vec3 eVal;
+	int eCnt = glm::findEigenvaluesSymReal(covar, eVal, eVec);
+	if(eCnt != 3)
+		return failReport(__LINE__);
+
+	// sort eVec by decending eVal
+	if(eVal[0] < eVal[1])
+	{
+		std::swap(eVal[0], eVal[1]);
+		std::swap(eVec[0], eVec[1]);
+	}
+	if(eVal[0] < eVal[2])
+	{
+		std::swap(eVal[0], eVal[2]);
+		std::swap(eVec[0], eVec[2]);
+	}
+	if(eVal[1] < eVal[2])
+	{
+		std::swap(eVal[1], eVal[2]);
+		std::swap(eVec[1], eVec[2]);
+	}
+
+	if(!vectorEpsilonEqual(glm::abs(eVec[0]), vec3(0, 1, 0), myEpsilon<float>()))
+		return failReport(__LINE__);
+	if(!vectorEpsilonEqual(glm::abs(eVec[1]), vec3(1, 0, 0), myEpsilon<float>()))
+		return failReport(__LINE__);
+	if(!vectorEpsilonEqual(glm::abs(eVec[2]), vec3(0, 0, 1), myEpsilon<float>()))
+		return failReport(__LINE__);
+
+	return 0;
+}
+
+#if GLM_HAS_CXX11_STL == 1
+int rndTest(unsigned int randomEngineSeed)
+{
+	std::default_random_engine rndEng(randomEngineSeed);
+	std::normal_distribution<double> normalDist;
+
+	// construct orthonormal system
+	glm::dvec3 x(normalDist(rndEng), normalDist(rndEng), normalDist(rndEng));
+	double l = glm::length(x);
+	while(l < myEpsilon<double>())
+		x = glm::dvec3(normalDist(rndEng), normalDist(rndEng), normalDist(rndEng));
+	x = glm::normalize(x);
+	glm::dvec3 y(normalDist(rndEng), normalDist(rndEng), normalDist(rndEng));
+	l = glm::length(y);
+	while(l < myEpsilon<double>())
+		y = glm::dvec3(normalDist(rndEng), normalDist(rndEng), normalDist(rndEng));
+	while(glm::abs(glm::dot(x, y)) < myEpsilon<double>())
+	{
+		y = glm::dvec3(normalDist(rndEng), normalDist(rndEng), normalDist(rndEng));
+		while(l < myEpsilon<double>())
+			y = glm::dvec3(normalDist(rndEng), normalDist(rndEng), normalDist(rndEng));
+	}
+	y = glm::normalize(y);
+	glm::dvec3 z = glm::normalize(glm::cross(x, y));
+	y = glm::normalize(glm::cross(z, x));
+
+	// generate input point data
+	std::vector<glm::dvec3> ptData;
+	static const int pattern[] = {
+		8, 0, 0,
+		4, 1, 2,
+		0, 2, 0,
+		0, 0, 4
+	};
+	glm::dvec3 offset(normalDist(rndEng), normalDist(rndEng), normalDist(rndEng));
+	for(int p = 0; p < 4; ++p)
+		for(int xs = 1; xs >= -1; xs -= 2)
+			for(int ys = 1; ys >= -1; ys -= 2)
+				for(int zs = 1; zs >= -1; zs -= 2)
+					ptData.push_back(
+						offset
+						+ x * static_cast<double>(pattern[p * 3 + 0] * xs)
+						+ y * static_cast<double>(pattern[p * 3 + 1] * ys)
+						+ z * static_cast<double>(pattern[p * 3 + 2] * zs));
+
+	// perform PCA:
+	glm::dvec3 center = computeCenter(ptData);
+	glm::dmat3 covarMat = glm::computeCovarianceMatrix(ptData.data(), ptData.size(), center);
+	glm::dvec3 evals;
+	glm::dmat3 evecs;
+	int evcnt = glm::findEigenvaluesSymReal(covarMat, evals, evecs);
+	if(evcnt != 3)
+		return failReport(__LINE__);
+	glm::sortEigenvalues(evals, evecs);
+
+	if (!sameSign(evecs[0][0], x[0])) evecs[0] = -evecs[0];
+	if(!vectorEpsilonEqual(x, evecs[0], myEpsilon<double>()))
+		return failReport(__LINE__);
+	if (!sameSign(evecs[2][0], y[0])) evecs[2] = -evecs[2];
+	if (!vectorEpsilonEqual(y, evecs[2], myEpsilon<double>()))
+		return failReport(__LINE__);
+	if (!sameSign(evecs[1][0], z[0])) evecs[1] = -evecs[1];
+	if (!vectorEpsilonEqual(z, evecs[1], myEpsilon<double>()))
+		return failReport(__LINE__);
+
+	return 0;
+}
+#endif // GLM_HAS_CXX11_STL == 1
+
+int main()
+{
+	int error(0);
+
+	// A small smoke test to fail early with most problems
+	if(smokeTest())
+		return failReport(__LINE__);
+
+	// test sorting utility.
+	if(testEigenvalueSort<2, float, glm::defaultp>() != 0)
+		error = failReport(__LINE__);
+	if(testEigenvalueSort<2, double, glm::defaultp>() != 0)
+		error = failReport(__LINE__);
+	if(testEigenvalueSort<3, float, glm::defaultp>() != 0)
+		error = failReport(__LINE__);
+	if(testEigenvalueSort<3, double, glm::defaultp>() != 0)
+		error = failReport(__LINE__);
+	if(testEigenvalueSort<4, float, glm::defaultp>() != 0)
+		error = failReport(__LINE__);
+	if(testEigenvalueSort<4, double, glm::defaultp>() != 0)
+		error = failReport(__LINE__);
+	if (error != 0)
+		return error;
+
+	// Note: the random engine uses a fixed seed to create consistent and reproducible test data
+	// test covariance matrix computation from different data sources
+	if(testCovar<2, float, glm::defaultp>(100, 12345) != 0)
+		error = failReport(__LINE__);
+	if(testCovar<2, double, glm::defaultp>(100, 42) != 0)
+		error = failReport(__LINE__);
+	if(testCovar<3, float, glm::defaultp>(100, 2021) != 0)
+		error = failReport(__LINE__);
+	if(testCovar<3, double, glm::defaultp>(100, 815) != 0)
+		error = failReport(__LINE__);
+	if(testCovar<4, float, glm::defaultp>(100, 3141) != 0)
+		error = failReport(__LINE__);
+	if(testCovar<4, double, glm::defaultp>(100, 174) != 0)
+		error = failReport(__LINE__);
+	if (error != 0)
+		return error;
+
+	// test PCA eigen vector reconstruction
+	// Expected epsilon precision evaluated separately:
+	// https://github.com/sgrottel/exp-pca-precision
+	if(testEigenvectors<2, float, glm::defaultp>(0.002f) != 0)
+		error = failReport(__LINE__);
+	if(testEigenvectors<2, double, glm::defaultp>(0.00000000001) != 0)
+		error = failReport(__LINE__);
+	if(testEigenvectors<3, float, glm::defaultp>(0.00001f) != 0)
+		error = failReport(__LINE__);
+	if(testEigenvectors<3, double, glm::defaultp>(0.0000000001) != 0)
+		error = failReport(__LINE__);
+	if(testEigenvectors<4, float, glm::defaultp>(0.0001f) != 0)
+		error = failReport(__LINE__);
+	if(testEigenvectors<4, double, glm::defaultp>(0.0000001) != 0)
+		error = failReport(__LINE__);
+	if(error != 0)
+		return error;
+
+	// Final tests with randomized data
+#if GLM_HAS_CXX11_STL == 1
+	if(rndTest(12345) != 0)
+		error = failReport(__LINE__);
+	if(rndTest(42) != 0)
+		error = failReport(__LINE__);
+	if (error != 0)
+		return error;
+#endif // GLM_HAS_CXX11_STL == 1
+
+	return error;
+}
diff --git a/3rdparty/glm/source/test/gtx/gtx_perpendicular.cpp b/3rdparty/glm/source/test/gtx/gtx_perpendicular.cpp
new file mode 100644
index 0000000..d14cfee
--- /dev/null
+++ b/3rdparty/glm/source/test/gtx/gtx_perpendicular.cpp
@@ -0,0 +1,9 @@
+#define GLM_ENABLE_EXPERIMENTAL
+#include <glm/gtx/perpendicular.hpp>
+
+int main()
+{
+	int Error(0);
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/gtx/gtx_polar_coordinates.cpp b/3rdparty/glm/source/test/gtx/gtx_polar_coordinates.cpp
new file mode 100644
index 0000000..da2fe53
--- /dev/null
+++ b/3rdparty/glm/source/test/gtx/gtx_polar_coordinates.cpp
@@ -0,0 +1,9 @@
+#define GLM_ENABLE_EXPERIMENTAL
+#include <glm/gtx/polar_coordinates.hpp>
+
+int main()
+{
+	int Error(0);
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/gtx/gtx_projection.cpp b/3rdparty/glm/source/test/gtx/gtx_projection.cpp
new file mode 100644
index 0000000..8f9f772
--- /dev/null
+++ b/3rdparty/glm/source/test/gtx/gtx_projection.cpp
@@ -0,0 +1,9 @@
+#define GLM_ENABLE_EXPERIMENTAL
+#include <glm/gtx/projection.hpp>
+
+int main()
+{
+	int Error(0);
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/gtx/gtx_quaternion.cpp b/3rdparty/glm/source/test/gtx/gtx_quaternion.cpp
new file mode 100644
index 0000000..80cbbac
--- /dev/null
+++ b/3rdparty/glm/source/test/gtx/gtx_quaternion.cpp
@@ -0,0 +1,107 @@
+#define GLM_ENABLE_EXPERIMENTAL
+#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);
+		Error += glm::epsilonEqual(p, glm::pi<float>() * 0.5f, 0.0001f) ? 0 : 1;
+	}
+
+	{
+		glm::quat q(1.0f, 0.0f, 0.0f, 1.0f);
+		float p = glm::pitch(q);
+		Error += glm::epsilonEqual(p, 0.f, 0.0001f) ? 0 : 1;
+	}
+
+	{
+		glm::quat q(1.0f, 0.0f, 0.0f, 1.0f);
+		float p = glm::yaw(q);
+		Error += glm::epsilonEqual(p, 0.f, 0.0001f) ? 0 : 1;
+	}
+
+	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_orientation();
+	Error += test_quat_fastMix();
+	Error += test_quat_shortMix();
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/gtx/gtx_random.cpp b/3rdparty/glm/source/test/gtx/gtx_random.cpp
new file mode 100644
index 0000000..e562c31
--- /dev/null
+++ b/3rdparty/glm/source/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;
+}
diff --git a/3rdparty/glm/source/test/gtx/gtx_range.cpp b/3rdparty/glm/source/test/gtx/gtx_range.cpp
new file mode 100644
index 0000000..434731b
--- /dev/null
+++ b/3rdparty/glm/source/test/gtx/gtx_range.cpp
@@ -0,0 +1,83 @@
+#define GLM_ENABLE_EXPERIMENTAL
+#include <glm/gtc/constants.hpp>
+#include <glm/ext/scalar_relational.hpp>
+#include <glm/ext/vector_relational.hpp>
+#include <glm/glm.hpp>
+
+#if GLM_HAS_RANGE_FOR
+
+#include <glm/gtx/range.hpp>
+
+int test_vec()
+{
+	int Error = 0;
+
+	{
+		glm::ivec3 const v(1, 2, 3);
+
+		int count = 0;
+		glm::ivec3 Result(0);
+		for(int x : v)
+		{
+			Result[count] = x;
+			count++;
+		}
+		Error += count == 3 ? 0 : 1;
+		Error += v == Result ? 0 : 1;
+	}
+
+	{
+		glm::ivec3 v(1, 2, 3);
+		for(int& x : v)
+			x = 0;
+		Error += glm::all(glm::equal(v, glm::ivec3(0))) ? 0 : 1;
+	}
+
+	return Error;
+}
+
+int test_mat()
+{
+	int Error = 0;
+
+	{
+		glm::mat4x3 m(1.0f);
+
+		int count = 0;
+		float Sum = 0.0f;
+		for(float x : m)
+		{
+			count++;
+			Sum += x;
+		}
+		Error += count == 12 ? 0 : 1;
+		Error += glm::equal(Sum, 3.0f, 0.001f) ? 0 : 1;
+	}
+
+	{
+		glm::mat4x3 m(1.0f);
+
+		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), glm::epsilon<float>())) ? 0 : 1;
+	}
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+	Error += test_vec();
+	Error += test_mat();
+	return Error;
+}
+
+#else
+
+int main()
+{
+	return 0;
+}
+
+#endif//GLM_HAS_RANGE_FOR
diff --git a/3rdparty/glm/source/test/gtx/gtx_rotate_normalized_axis.cpp b/3rdparty/glm/source/test/gtx/gtx_rotate_normalized_axis.cpp
new file mode 100644
index 0000000..d4eecdf
--- /dev/null
+++ b/3rdparty/glm/source/test/gtx/gtx_rotate_normalized_axis.cpp
@@ -0,0 +1,9 @@
+#define GLM_ENABLE_EXPERIMENTAL
+#include <glm/gtx/rotate_normalized_axis.hpp>
+
+int main()
+{
+	int Error(0);
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/gtx/gtx_rotate_vector.cpp b/3rdparty/glm/source/test/gtx/gtx_rotate_vector.cpp
new file mode 100644
index 0000000..becd63f
--- /dev/null
+++ b/3rdparty/glm/source/test/gtx/gtx_rotate_vector.cpp
@@ -0,0 +1,77 @@
+#define GLM_ENABLE_EXPERIMENTAL
+#include <glm/gtx/rotate_vector.hpp>
+#include <glm/gtc/constants.hpp>
+#include <glm/ext/vector_relational.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;
+}
+
+
diff --git a/3rdparty/glm/source/test/gtx/gtx_scalar_multiplication.cpp b/3rdparty/glm/source/test/gtx/gtx_scalar_multiplication.cpp
new file mode 100644
index 0000000..4aa96d6
--- /dev/null
+++ b/3rdparty/glm/source/test/gtx/gtx_scalar_multiplication.cpp
@@ -0,0 +1,37 @@
+#define GLM_ENABLE_EXPERIMENTAL
+#include <glm/gtc/constants.hpp>
+#include <glm/ext/vector_relational.hpp>
+#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, glm::epsilon<float>())) ? 0 : 1;
+	Error += glm::all(glm::equal(v, 1 * v, glm::epsilon<float>())) ? 0 : 1;
+	Error += glm::all(glm::equal(v, 1u * v, glm::epsilon<float>())) ? 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, glm::epsilon<float>())) ? 0 : 1;
+	Error += glm::all(glm::equal(m*(v/2), w, glm::epsilon<float>())) ? 0 : 1;
+	Error += glm::all(glm::equal((m/2)*v, w, glm::epsilon<float>())) ? 0 : 1;
+	Error += glm::all(glm::equal((0.5*m)*v, w, glm::epsilon<float>())) ? 0 : 1;
+	Error += glm::all(glm::equal(0.5*(m*v), w, glm::epsilon<float>())) ? 0 : 1;
+
+	return Error;
+}
+
+#else
+
+int main()
+{
+	return 0;
+}
+
+#endif
diff --git a/3rdparty/glm/source/test/gtx/gtx_scalar_relational.cpp b/3rdparty/glm/source/test/gtx/gtx_scalar_relational.cpp
new file mode 100644
index 0000000..fc6a09a
--- /dev/null
+++ b/3rdparty/glm/source/test/gtx/gtx_scalar_relational.cpp
@@ -0,0 +1,174 @@
+#define GLM_ENABLE_EXPERIMENTAL
+#include <glm/gtx/scalar_relational.hpp>
+#include <glm/gtc/constants.hpp>
+#include <glm/ext/scalar_relational.hpp>
+#include <glm/ext/vector_relational.hpp>
+#include <glm/ext/matrix_relational.hpp>
+#include <glm/glm.hpp>
+
+static 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;
+}
+
+static 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;
+}
+
+static 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;
+}
+
+static 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;
+}
+
+static 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, glm::epsilon<float>()) ? 1 : 0;
+	Error += glm::equal(1.0f, 0.0f, glm::epsilon<float>()) ? 1 : 0;
+	Error += glm::equal(0.0f, 0.0f, glm::epsilon<float>()) ? 0 : 1;
+	Error += glm::equal(1.0f, 1.0f, glm::epsilon<float>()) ? 0 : 1;
+	Error += glm::equal(0.0, 1.0, glm::epsilon<double>()) ? 1 : 0;
+	Error += glm::equal(1.0, 0.0, glm::epsilon<double>()) ? 1 : 0;
+	Error += glm::equal(0.0, 0.0, glm::epsilon<double>()) ? 0 : 1;
+	Error += glm::equal(1.0, 1.0, glm::epsilon<double>()) ? 0 : 1;
+
+	return Error;
+}
+
+static 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, glm::epsilon<float>()) ? 0 : 1;
+	Error += glm::notEqual(1.0f, 0.0f, glm::epsilon<float>()) ? 0 : 1;
+	Error += glm::notEqual(0.0f, 0.0f, glm::epsilon<float>()) ? 1 : 0;
+	Error += glm::notEqual(1.0f, 1.0f, glm::epsilon<float>()) ? 1 : 0;
+	Error += glm::notEqual(0.0, 1.0, glm::epsilon<double>()) ? 0 : 1;
+	Error += glm::notEqual(1.0, 0.0, glm::epsilon<double>()) ? 0 : 1;
+	Error += glm::notEqual(0.0, 0.0, glm::epsilon<double>()) ? 1 : 0;
+	Error += glm::notEqual(1.0, 1.0, glm::epsilon<double>()) ? 1 : 0;
+
+	return Error;
+}
+
+static int test_any()
+{
+	int Error = 0;
+
+	Error += glm::any(true) ? 0 : 1;
+	Error += glm::any(false) ? 1 : 0;
+
+	return Error;
+}
+
+static int test_all()
+{
+	int Error = 0;
+
+	Error += glm::all(true) ? 0 : 1;
+	Error += glm::all(false) ? 1 : 0;
+
+	return Error;
+}
+
+static 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;
+}
diff --git a/3rdparty/glm/source/test/gtx/gtx_simd_mat4.cpp b/3rdparty/glm/source/test/gtx/gtx_simd_mat4.cpp
new file mode 100644
index 0000000..28d7ec5
--- /dev/null
+++ b/3rdparty/glm/source/test/gtx/gtx_simd_mat4.cpp
@@ -0,0 +1,324 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// 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;
+
+	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)
diff --git a/3rdparty/glm/source/test/gtx/gtx_simd_vec4.cpp b/3rdparty/glm/source/test/gtx/gtx_simd_vec4.cpp
new file mode 100644
index 0000000..e71a60b
--- /dev/null
+++ b/3rdparty/glm/source/test/gtx/gtx_simd_vec4.cpp
@@ -0,0 +1,71 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// 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()
+{
+	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)
diff --git a/3rdparty/glm/source/test/gtx/gtx_spline.cpp b/3rdparty/glm/source/test/gtx/gtx_spline.cpp
new file mode 100644
index 0000000..c93ee17
--- /dev/null
+++ b/3rdparty/glm/source/test/gtx/gtx_spline.cpp
@@ -0,0 +1,100 @@
+#define GLM_ENABLE_EXPERIMENTAL
+#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;
+}
diff --git a/3rdparty/glm/source/test/gtx/gtx_string_cast.cpp b/3rdparty/glm/source/test/gtx/gtx_string_cast.cpp
new file mode 100644
index 0000000..b04c870
--- /dev/null
+++ b/3rdparty/glm/source/test/gtx/gtx_string_cast.cpp
@@ -0,0 +1,155 @@
+#define GLM_ENABLE_EXPERIMENTAL
+#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 test_string_cast_quaternion()
+{
+	int Error = 0;
+
+	glm::quat Q0 = glm::quat(1.0f, 2.0f, 3.0f, 4.0f);
+	std::string S0 = glm::to_string(Q0);
+	Error += S0 != std::string("quat(1.000000, {2.000000, 3.000000, 4.000000})") ? 1 : 0;
+
+	return Error;
+
+}
+
+int test_string_cast_dual_quaternion()
+{
+	int Error = 0;
+
+	glm::dualquat Q0 = glm::dualquat(glm::quat(1.0f, 2.0f, 3.0f, 4.0f), glm::quat(5.0f, 6.0f, 7.0f, 8.0f));
+	std::string S0 = glm::to_string(Q0);
+	Error += S0 != std::string("dualquat((1.000000, {2.000000, 3.000000, 4.000000}), (5.000000, {6.000000, 7.000000, 8.000000}))") ? 1 : 0;
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_string_cast_vector();
+	Error += test_string_cast_matrix();
+	Error += test_string_cast_quaternion();
+	Error += test_string_cast_dual_quaternion();
+
+	return Error;
+}
+
+
diff --git a/3rdparty/glm/source/test/gtx/gtx_texture.cpp b/3rdparty/glm/source/test/gtx/gtx_texture.cpp
new file mode 100644
index 0000000..0b98ed7
--- /dev/null
+++ b/3rdparty/glm/source/test/gtx/gtx_texture.cpp
@@ -0,0 +1,22 @@
+#define GLM_ENABLE_EXPERIMENTAL
+#include <glm/vec2.hpp>
+#include <glm/gtx/texture.hpp>
+
+int test_levels()
+{
+	int Error = 0;
+
+	int const Levels = glm::levels(glm::ivec2(3, 2));
+	Error += Levels == 2 ? 0 : 1;
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_levels();
+
+	return Error;
+}
diff --git a/3rdparty/glm/source/test/gtx/gtx_type_aligned.cpp b/3rdparty/glm/source/test/gtx/gtx_type_aligned.cpp
new file mode 100644
index 0000000..8d045c0
--- /dev/null
+++ b/3rdparty/glm/source/test/gtx/gtx_type_aligned.cpp
@@ -0,0 +1,114 @@
+#define GLM_ENABLE_EXPERIMENTAL
+#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;
+		};
+
+		std::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;
+		};
+
+		std::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;
+		};
+
+		std::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;
+		};
+
+		std::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)
+{
+	std::printf("mat4(\n");
+	std::printf("\tvec4(%2.9f, %2.9f, %2.9f, %2.9f)\n", static_cast<double>(Mat0[0][0]), static_cast<double>(Mat0[0][1]), static_cast<double>(Mat0[0][2]), static_cast<double>(Mat0[0][3]));
+	std::printf("\tvec4(%2.9f, %2.9f, %2.9f, %2.9f)\n", static_cast<double>(Mat0[1][0]), static_cast<double>(Mat0[1][1]), static_cast<double>(Mat0[1][2]), static_cast<double>(Mat0[1][3]));
+	std::printf("\tvec4(%2.9f, %2.9f, %2.9f, %2.9f)\n", static_cast<double>(Mat0[2][0]), static_cast<double>(Mat0[2][1]), static_cast<double>(Mat0[2][2]), static_cast<double>(Mat0[2][3]));
+	std::printf("\tvec4(%2.9f, %2.9f, %2.9f, %2.9f))\n\n", static_cast<double>(Mat0[3][0]), static_cast<double>(Mat0[3][1]), static_cast<double>(Mat0[3][2]), static_cast<double>(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;
+}
diff --git a/3rdparty/glm/source/test/gtx/gtx_type_trait.cpp b/3rdparty/glm/source/test/gtx/gtx_type_trait.cpp
new file mode 100644
index 0000000..9b96a36
--- /dev/null
+++ b/3rdparty/glm/source/test/gtx/gtx_type_trait.cpp
@@ -0,0 +1,13 @@
+#define GLM_ENABLE_EXPERIMENTAL
+#include <glm/vec4.hpp>
+#include <glm/gtx/type_trait.hpp>
+
+int main()
+{
+	int Error = 0;
+
+	
+
+	return Error;
+}
+
diff --git a/3rdparty/glm/source/test/gtx/gtx_vec_swizzle.cpp b/3rdparty/glm/source/test/gtx/gtx_vec_swizzle.cpp
new file mode 100644
index 0000000..0b0c8b8
--- /dev/null
+++ b/3rdparty/glm/source/test/gtx/gtx_vec_swizzle.cpp
@@ -0,0 +1,11 @@
+#define GLM_ENABLE_EXPERIMENTAL
+#include <glm/gtx/vec_swizzle.hpp>
+
+int main()
+{
+	int Error = 0;
+
+
+	return Error;
+}
+
diff --git a/3rdparty/glm/source/test/gtx/gtx_vector_angle.cpp b/3rdparty/glm/source/test/gtx/gtx_vector_angle.cpp
new file mode 100644
index 0000000..4e8172b
--- /dev/null
+++ b/3rdparty/glm/source/test/gtx/gtx_vector_angle.cpp
@@ -0,0 +1,59 @@
+#define GLM_ENABLE_EXPERIMENTAL
+#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 += glm::epsilonEqual(AngleA, glm::pi<float>() * 0.25f, 0.01f) ? 0 : 1;
+	float AngleB = glm::orientedAngle(glm::vec2(0, 1), glm::normalize(glm::vec2(1, 1)));
+	Error += glm::epsilonEqual(AngleB, -glm::pi<float>() * 0.25f, 0.01f) ? 0 : 1;
+	float AngleC = glm::orientedAngle(glm::normalize(glm::vec2(1, 1)), glm::vec2(0, 1));
+	Error += glm::epsilonEqual(AngleC, glm::pi<float>() * 0.25f, 0.01f) ? 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 += glm::epsilonEqual(AngleA, glm::pi<float>() * 0.25f, 0.01f) ? 0 : 1;
+	float AngleB = glm::orientedAngle(glm::vec3(0, 1, 0), glm::normalize(glm::vec3(1, 1, 0)), glm::vec3(0, 0, 1));
+	Error += glm::epsilonEqual(AngleB, -glm::pi<float>() * 0.25f, 0.01f) ? 0 : 1;
+	float AngleC = glm::orientedAngle(glm::normalize(glm::vec3(1, 1, 0)), glm::vec3(0, 1, 0), glm::vec3(0, 0, 1));
+	Error += glm::epsilonEqual(AngleC, glm::pi<float>() * 0.25f, 0.01f) ? 0 : 1;
+
+	return Error;
+}
+
+int main()
+{
+	int Error(0);
+	
+	Error += test_angle();
+	Error += test_orientedAngle_vec2();
+	Error += test_orientedAngle_vec3();
+
+	return Error;
+}
+
+
diff --git a/3rdparty/glm/source/test/gtx/gtx_vector_query.cpp b/3rdparty/glm/source/test/gtx/gtx_vector_query.cpp
new file mode 100644
index 0000000..729f9e1
--- /dev/null
+++ b/3rdparty/glm/source/test/gtx/gtx_vector_query.cpp
@@ -0,0 +1,82 @@
+#define GLM_ENABLE_EXPERIMENTAL
+#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;
+}
+
+
diff --git a/3rdparty/glm/source/test/gtx/gtx_wrap.cpp b/3rdparty/glm/source/test/gtx/gtx_wrap.cpp
new file mode 100644
index 0000000..2354cc8
--- /dev/null
+++ b/3rdparty/glm/source/test/gtx/gtx_wrap.cpp
@@ -0,0 +1,191 @@
+#define GLM_ENABLE_EXPERIMENTAL
+#include <glm/gtx/wrap.hpp>
+#include <glm/ext/scalar_relational.hpp>
+#include <glm/ext/vector_relational.hpp>
+
+namespace clamp
+{
+	int test()
+	{
+		int Error(0);
+
+		float A = glm::clamp(0.5f);
+		Error += glm::equal(A, 0.5f, 0.00001f) ? 0 : 1;
+
+		float B = glm::clamp(0.0f);
+		Error += glm::equal(B, 0.0f, 0.00001f) ? 0 : 1;
+
+		float C = glm::clamp(1.0f);
+		Error += glm::equal(C, 1.0f, 0.00001f) ? 0 : 1;
+
+		float D = glm::clamp(-0.5f);
+		Error += glm::equal(D, 0.0f, 0.00001f) ? 0 : 1;
+
+		float E = glm::clamp(1.5f);
+		Error += glm::equal(E, 1.0f, 0.00001f) ? 0 : 1;
+
+		glm::vec2 K = glm::clamp(glm::vec2(0.5f));
+		Error += glm::all(glm::equal(K, glm::vec2(0.5f), glm::vec2(0.00001f))) ? 0 : 1;
+
+		glm::vec3 L = glm::clamp(glm::vec3(0.5f));
+		Error += glm::all(glm::equal(L, glm::vec3(0.5f), glm::vec3(0.00001f))) ? 0 : 1;
+
+		glm::vec4 M = glm::clamp(glm::vec4(0.5f));
+		Error += glm::all(glm::equal(M, glm::vec4(0.5f), glm::vec4(0.00001f))) ? 0 : 1;
+
+		glm::vec1 N = glm::clamp(glm::vec1(0.5f));
+		Error += glm::all(glm::equal(N, glm::vec1(0.5f), glm::vec1(0.00001f))) ? 0 : 1;
+
+		return Error;
+	}
+}//namespace clamp
+
+namespace repeat
+{
+	int test()
+	{
+		int Error(0);
+
+		float A = glm::repeat(0.5f);
+		Error += glm::equal(A, 0.5f, 0.00001f) ? 0 : 1;
+
+		float B = glm::repeat(0.0f);
+		Error += glm::equal(B, 0.0f, 0.00001f) ? 0 : 1;
+
+		float C = glm::repeat(1.0f);
+		Error += glm::equal(C, 0.0f, 0.00001f) ? 0 : 1;
+
+		float D = glm::repeat(-0.5f);
+		Error += glm::equal(D, 0.5f, 0.00001f) ? 0 : 1;
+
+		float E = glm::repeat(1.5f);
+		Error += glm::equal(E, 0.5f, 0.00001f) ? 0 : 1;
+
+		float F = glm::repeat(0.9f);
+		Error += glm::equal(F, 0.9f, 0.00001f) ? 0 : 1;
+
+		glm::vec2 K = glm::repeat(glm::vec2(0.5f));
+		Error += glm::all(glm::equal(K, glm::vec2(0.5f), glm::vec2(0.00001f))) ? 0 : 1;
+
+		glm::vec3 L = glm::repeat(glm::vec3(0.5f));
+		Error += glm::all(glm::equal(L, glm::vec3(0.5f), glm::vec3(0.00001f))) ? 0 : 1;
+
+		glm::vec4 M = glm::repeat(glm::vec4(0.5f));
+		Error += glm::all(glm::equal(M, glm::vec4(0.5f), glm::vec4(0.00001f))) ? 0 : 1;
+
+		glm::vec1 N = glm::repeat(glm::vec1(0.5f));
+		Error += glm::all(glm::equal(N, glm::vec1(0.5f), glm::vec1(0.00001f))) ? 0 : 1;
+
+		return Error;
+	}
+}//namespace repeat
+
+namespace mirrorClamp
+{
+	int test()
+	{
+		int Error(0);
+
+		float A = glm::mirrorClamp(0.5f);
+		Error += glm::equal(A, 0.5f, 0.00001f) ? 0 : 1;
+
+		float B = glm::mirrorClamp(0.0f);
+		Error += glm::equal(B, 0.0f, 0.00001f) ? 0 : 1;
+
+		float C = glm::mirrorClamp(1.1f);
+		Error += glm::equal(C, 0.1f, 0.00001f) ? 0 : 1;
+
+		float D = glm::mirrorClamp(-0.5f);
+		Error += glm::equal(D, 0.5f, 0.00001f) ? 0 : 1;
+
+		float E = glm::mirrorClamp(1.5f);
+		Error += glm::equal(E, 0.5f, 0.00001f) ? 0 : 1;
+
+		float F = glm::mirrorClamp(0.9f);
+		Error += glm::equal(F, 0.9f, 0.00001f) ? 0 : 1;
+
+		float G = glm::mirrorClamp(3.1f);
+		Error += glm::equal(G, 0.1f, 0.00001f) ? 0 : 1;
+
+		float H = glm::mirrorClamp(-3.1f);
+		Error += glm::equal(H, 0.1f, 0.00001f) ? 0 : 1;
+
+		float I = glm::mirrorClamp(-0.9f);
+		Error += glm::equal(I, 0.9f, 0.00001f) ? 0 : 1;
+
+		glm::vec2 K = glm::mirrorClamp(glm::vec2(0.5f));
+		Error += glm::all(glm::equal(K, glm::vec2(0.5f), glm::vec2(0.00001f))) ? 0 : 1;
+
+		glm::vec3 L = glm::mirrorClamp(glm::vec3(0.5f));
+		Error += glm::all(glm::equal(L, glm::vec3(0.5f), glm::vec3(0.00001f))) ? 0 : 1;
+
+		glm::vec4 M = glm::mirrorClamp(glm::vec4(0.5f));
+		Error += glm::all(glm::equal(M, glm::vec4(0.5f), glm::vec4(0.00001f))) ? 0 : 1;
+
+		glm::vec1 N = glm::mirrorClamp(glm::vec1(0.5f));
+		Error += glm::all(glm::equal(N, glm::vec1(0.5f), glm::vec1(0.00001f))) ? 0 : 1;
+
+		return Error;
+	}
+}//namespace mirrorClamp
+
+namespace mirrorRepeat
+{
+	int test()
+	{
+		int Error(0);
+
+		float A = glm::mirrorRepeat(0.5f);
+		Error += glm::equal(A, 0.5f, 0.00001f) ? 0 : 1;
+
+		float B = glm::mirrorRepeat(0.0f);
+		Error += glm::equal(B, 0.0f, 0.00001f) ? 0 : 1;
+
+		float C = glm::mirrorRepeat(1.0f);
+		Error += glm::equal(C, 1.0f, 0.00001f) ? 0 : 1;
+
+		float D = glm::mirrorRepeat(-0.5f);
+		Error += glm::equal(D, 0.5f, 0.00001f) ? 0 : 1;
+
+		float E = glm::mirrorRepeat(1.5f);
+		Error += glm::equal(E, 0.5f, 0.00001f) ? 0 : 1;
+
+		float F = glm::mirrorRepeat(0.9f);
+		Error += glm::equal(F, 0.9f, 0.00001f) ? 0 : 1;
+
+		float G = glm::mirrorRepeat(3.0f);
+		Error += glm::equal(G, 1.0f, 0.00001f) ? 0 : 1;
+
+		float H = glm::mirrorRepeat(-3.0f);
+		Error += glm::equal(H, 1.0f, 0.00001f) ? 0 : 1;
+
+		float I = glm::mirrorRepeat(-1.0f);
+		Error += glm::equal(I, 1.0f, 0.00001f) ? 0 : 1;
+
+		glm::vec2 K = glm::mirrorRepeat(glm::vec2(0.5f));
+		Error += glm::all(glm::equal(K, glm::vec2(0.5f), glm::vec2(0.00001f))) ? 0 : 1;
+
+		glm::vec3 L = glm::mirrorRepeat(glm::vec3(0.5f));
+		Error += glm::all(glm::equal(L, glm::vec3(0.5f), glm::vec3(0.00001f))) ? 0 : 1;
+
+		glm::vec4 M = glm::mirrorRepeat(glm::vec4(0.5f));
+		Error += glm::all(glm::equal(M, glm::vec4(0.5f), glm::vec4(0.00001f))) ? 0 : 1;
+
+		glm::vec1 N = glm::mirrorRepeat(glm::vec1(0.5f));
+		Error += glm::all(glm::equal(N, glm::vec1(0.5f), glm::vec1(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;
+}
diff --git a/3rdparty/glm/source/test/perf/CMakeLists.txt b/3rdparty/glm/source/test/perf/CMakeLists.txt
new file mode 100644
index 0000000..19c7050
--- /dev/null
+++ b/3rdparty/glm/source/test/perf/CMakeLists.txt
@@ -0,0 +1,6 @@
+glmCreateTestGTC(perf_matrix_div)
+glmCreateTestGTC(perf_matrix_inverse)
+glmCreateTestGTC(perf_matrix_mul)
+glmCreateTestGTC(perf_matrix_mul_vector)
+glmCreateTestGTC(perf_matrix_transpose)
+glmCreateTestGTC(perf_vector_mul_matrix)
diff --git a/3rdparty/glm/source/test/perf/perf_matrix_div.cpp b/3rdparty/glm/source/test/perf/perf_matrix_div.cpp
new file mode 100644
index 0000000..630188d
--- /dev/null
+++ b/3rdparty/glm/source/test/perf/perf_matrix_div.cpp
@@ -0,0 +1,153 @@
+#define GLM_FORCE_INLINE
+#include <glm/ext/matrix_float4x4.hpp>
+#include <glm/ext/matrix_double4x4.hpp>
+#include <glm/ext/matrix_transform.hpp>
+#include <glm/ext/matrix_relational.hpp>
+#include <glm/ext/vector_float4.hpp>
+#if GLM_CONFIG_SIMD == GLM_ENABLE
+#include <glm/gtc/type_aligned.hpp>
+#include <vector>
+#include <chrono>
+#include <cstdio>
+
+template <typename matType>
+static void test_mat_div_mat(matType const& M, std::vector<matType> const& I, std::vector<matType>& O)
+{
+	for (std::size_t i = 0, n = I.size(); i < n; ++i)
+		O[i] = M / I[i];
+}
+
+template <typename matType>
+static int launch_mat_div_mat(std::vector<matType>& O, matType const& Transform, matType const& Scale, std::size_t Samples)
+{
+	typedef typename matType::value_type T;
+
+	std::vector<matType> I(Samples);
+	O.resize(Samples);
+
+	for(std::size_t i = 0; i < Samples; ++i)
+		I[i] = Scale * static_cast<T>(i) + Scale;
+
+	std::chrono::high_resolution_clock::time_point t1 = std::chrono::high_resolution_clock::now();
+	test_mat_div_mat<matType>(Transform, I, O);
+	std::chrono::high_resolution_clock::time_point t2 = std::chrono::high_resolution_clock::now();
+
+	return static_cast<int>(std::chrono::duration_cast<std::chrono::microseconds>(t2 - t1).count());
+}
+
+template <typename packedMatType, typename alignedMatType>
+static int comp_mat2_div_mat2(std::size_t Samples)
+{
+	typedef typename packedMatType::value_type T;
+	
+	int Error = 0;
+
+	packedMatType const Transform(1, 2, 3, 4);
+	packedMatType const Scale(0.01, 0.02, 0.03, 0.05);
+
+	std::vector<packedMatType> SISD;
+	std::printf("- SISD: %d us\n", launch_mat_div_mat<packedMatType>(SISD, Transform, Scale, Samples));
+
+	std::vector<alignedMatType> SIMD;
+	std::printf("- SIMD: %d us\n", launch_mat_div_mat<alignedMatType>(SIMD, Transform, Scale, Samples));
+
+	for(std::size_t i = 0; i < Samples; ++i)
+	{
+		packedMatType const A = SISD[i];
+		packedMatType const B = SIMD[i];
+		Error += glm::all(glm::equal(A, B, static_cast<T>(0.001))) ? 0 : 1;
+		assert(!Error);
+	}
+	
+	return Error;
+}
+
+template <typename packedMatType, typename alignedMatType>
+static int comp_mat3_div_mat3(std::size_t Samples)
+{
+	typedef typename packedMatType::value_type T;
+	
+	int Error = 0;
+
+	packedMatType const Transform(1, 2, 3, 4, 5, 6, 7, 8, 9);
+	packedMatType const Scale(0.01, 0.02, 0.03, 0.05, 0.01, 0.02, 0.03, 0.05, 0.01);
+
+	std::vector<packedMatType> SISD;
+	std::printf("- SISD: %d us\n", launch_mat_div_mat<packedMatType>(SISD, Transform, Scale, Samples));
+
+	std::vector<alignedMatType> SIMD;
+	std::printf("- SIMD: %d us\n", launch_mat_div_mat<alignedMatType>(SIMD, Transform, Scale, Samples));
+
+	for(std::size_t i = 0; i < Samples; ++i)
+	{
+		packedMatType const A = SISD[i];
+		packedMatType const B = SIMD[i];
+		Error += glm::all(glm::equal(A, B, static_cast<T>(0.001))) ? 0 : 1;
+		assert(!Error);
+	}
+	
+	return Error;
+}
+
+template <typename packedMatType, typename alignedMatType>
+static int comp_mat4_div_mat4(std::size_t Samples)
+{
+	typedef typename packedMatType::value_type T;
+	
+	int Error = 0;
+
+	packedMatType const Transform(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
+	packedMatType const Scale(0.01, 0.02, 0.05, 0.04, 0.02, 0.08, 0.05, 0.01, 0.08, 0.03, 0.05, 0.06, 0.02, 0.03, 0.07, 0.05);
+
+	std::vector<packedMatType> SISD;
+	std::printf("- SISD: %d us\n", launch_mat_div_mat<packedMatType>(SISD, Transform, Scale, Samples));
+
+	std::vector<alignedMatType> SIMD;
+	std::printf("- SIMD: %d us\n", launch_mat_div_mat<alignedMatType>(SIMD, Transform, Scale, Samples));
+
+	for(std::size_t i = 0; i < Samples; ++i)
+	{
+		packedMatType const A = SISD[i];
+		packedMatType const B = SIMD[i];
+		Error += glm::all(glm::equal(A, B, static_cast<T>(0.001))) ? 0 : 1;
+		assert(!Error);
+	}
+	
+	return Error;
+}
+
+int main()
+{
+	std::size_t const Samples = 100000;
+
+	int Error = 0;
+
+	std::printf("mat2 / mat2:\n");
+	Error += comp_mat2_div_mat2<glm::mat2, glm::aligned_mat2>(Samples);
+	
+	std::printf("dmat2 / dmat2:\n");
+	Error += comp_mat2_div_mat2<glm::dmat2, glm::aligned_dmat2>(Samples);
+
+	std::printf("mat3 / mat3:\n");
+	Error += comp_mat3_div_mat3<glm::mat3, glm::aligned_mat3>(Samples);
+	
+	std::printf("dmat3 / dmat3:\n");
+	Error += comp_mat3_div_mat3<glm::dmat3, glm::aligned_dmat3>(Samples);
+
+	std::printf("mat4 / mat4:\n");
+	Error += comp_mat4_div_mat4<glm::mat4, glm::aligned_mat4>(Samples);
+	
+	std::printf("dmat4 / dmat4:\n");
+	Error += comp_mat4_div_mat4<glm::dmat4, glm::aligned_dmat4>(Samples);
+
+	return Error;
+}
+
+#else
+
+int main()
+{
+	return 0;
+}
+
+#endif
diff --git a/3rdparty/glm/source/test/perf/perf_matrix_inverse.cpp b/3rdparty/glm/source/test/perf/perf_matrix_inverse.cpp
new file mode 100644
index 0000000..1a989ae
--- /dev/null
+++ b/3rdparty/glm/source/test/perf/perf_matrix_inverse.cpp
@@ -0,0 +1,150 @@
+#define GLM_FORCE_INLINE
+#include <glm/matrix.hpp>
+#include <glm/ext/matrix_float4x4.hpp>
+#include <glm/ext/matrix_double4x4.hpp>
+#include <glm/ext/matrix_relational.hpp>
+#include <glm/ext/vector_float4.hpp>
+#if GLM_CONFIG_SIMD == GLM_ENABLE
+#include <glm/gtc/type_aligned.hpp>
+#include <vector>
+#include <chrono>
+#include <cstdio>
+
+template <typename matType>
+static void test_mat_inverse(std::vector<matType> const& I, std::vector<matType>& O)
+{
+	for (std::size_t i = 0, n = I.size(); i < n; ++i)
+		O[i] = glm::inverse(I[i]);
+}
+
+template <typename matType>
+static int launch_mat_inverse(std::vector<matType>& O, matType const& Scale, std::size_t Samples)
+{
+	typedef typename matType::value_type T;
+
+	std::vector<matType> I(Samples);
+	O.resize(Samples);
+
+	for(std::size_t i = 0; i < Samples; ++i)
+		I[i] = Scale * static_cast<T>(i) + Scale;
+
+	std::chrono::high_resolution_clock::time_point t1 = std::chrono::high_resolution_clock::now();
+	test_mat_inverse<matType>(I, O);
+	std::chrono::high_resolution_clock::time_point t2 = std::chrono::high_resolution_clock::now();
+
+	return static_cast<int>(std::chrono::duration_cast<std::chrono::microseconds>(t2 - t1).count());
+}
+
+template <typename packedMatType, typename alignedMatType>
+static int comp_mat2_inverse(std::size_t Samples)
+{
+	typedef typename packedMatType::value_type T;
+	
+	int Error = 0;
+
+	packedMatType const Scale(0.01, 0.02, 0.03, 0.05);
+
+	std::vector<packedMatType> SISD;
+	std::printf("- SISD: %d us\n", launch_mat_inverse<packedMatType>(SISD, Scale, Samples));
+
+	std::vector<alignedMatType> SIMD;
+	std::printf("- SIMD: %d us\n", launch_mat_inverse<alignedMatType>(SIMD, Scale, Samples));
+
+	for(std::size_t i = 0; i < Samples; ++i)
+	{
+		packedMatType const A = SISD[i];
+		packedMatType const B = SIMD[i];
+		Error += glm::all(glm::equal(A, B, static_cast<T>(0.001))) ? 0 : 1;
+		assert(!Error);
+	}
+	
+	return Error;
+}
+
+template <typename packedMatType, typename alignedMatType>
+static int comp_mat3_inverse(std::size_t Samples)
+{
+	typedef typename packedMatType::value_type T;
+	
+	int Error = 0;
+
+	packedMatType const Scale(0.01, 0.02, 0.03, 0.05, 0.01, 0.02, 0.03, 0.05, 0.01);
+
+	std::vector<packedMatType> SISD;
+	std::printf("- SISD: %d us\n", launch_mat_inverse<packedMatType>(SISD, Scale, Samples));
+
+	std::vector<alignedMatType> SIMD;
+	std::printf("- SIMD: %d us\n", launch_mat_inverse<alignedMatType>(SIMD, Scale, Samples));
+
+	for(std::size_t i = 0; i < Samples; ++i)
+	{
+		packedMatType const A = SISD[i];
+		packedMatType const B = SIMD[i];
+		Error += glm::all(glm::equal(A, B, static_cast<T>(0.001))) ? 0 : 1;
+		assert(!Error);
+	}
+	
+	return Error;
+}
+
+template <typename packedMatType, typename alignedMatType>
+static int comp_mat4_inverse(std::size_t Samples)
+{
+	typedef typename packedMatType::value_type T;
+	
+	int Error = 0;
+
+	packedMatType const Scale(0.01, 0.02, 0.05, 0.04, 0.02, 0.08, 0.05, 0.01, 0.08, 0.03, 0.05, 0.06, 0.02, 0.03, 0.07, 0.05);
+
+	std::vector<packedMatType> SISD;
+	std::printf("- SISD: %d us\n", launch_mat_inverse<packedMatType>(SISD, Scale, Samples));
+
+	std::vector<alignedMatType> SIMD;
+	std::printf("- SIMD: %d us\n", launch_mat_inverse<alignedMatType>(SIMD, Scale, Samples));
+
+	for(std::size_t i = 0; i < Samples; ++i)
+	{
+		packedMatType const A = SISD[i];
+		packedMatType const B = SIMD[i];
+		Error += glm::all(glm::equal(A, B, static_cast<T>(0.001))) ? 0 : 1;
+		assert(!Error);
+	}
+	
+	return Error;
+}
+
+int main()
+{
+	std::size_t const Samples = 100000;
+
+	int Error = 0;
+
+	std::printf("glm::inverse(mat2):\n");
+	Error += comp_mat2_inverse<glm::mat2, glm::aligned_mat2>(Samples);
+	
+	std::printf("glm::inverse(dmat2):\n");
+	Error += comp_mat2_inverse<glm::dmat2, glm::aligned_dmat2>(Samples);
+
+	std::printf("glm::inverse(mat3):\n");
+	Error += comp_mat3_inverse<glm::mat3, glm::aligned_mat3>(Samples);
+	
+	std::printf("glm::inverse(dmat3):\n");
+	Error += comp_mat3_inverse<glm::dmat3, glm::aligned_dmat3>(Samples);
+
+	std::printf("glm::inverse(mat4):\n");
+	Error += comp_mat4_inverse<glm::mat4, glm::aligned_mat4>(Samples);
+	
+	std::printf("glm::inverse(dmat4):\n");
+	Error += comp_mat4_inverse<glm::dmat4, glm::aligned_dmat4>(Samples);
+
+	return Error;
+}
+
+#else
+
+int main()
+{
+	return 0;
+}
+
+#endif
diff --git a/3rdparty/glm/source/test/perf/perf_matrix_mul.cpp b/3rdparty/glm/source/test/perf/perf_matrix_mul.cpp
new file mode 100644
index 0000000..d6b1f10
--- /dev/null
+++ b/3rdparty/glm/source/test/perf/perf_matrix_mul.cpp
@@ -0,0 +1,154 @@
+#define GLM_FORCE_INLINE
+#include <glm/ext/matrix_float2x2.hpp>
+#include <glm/ext/matrix_double2x2.hpp>
+#include <glm/ext/matrix_float3x3.hpp>
+#include <glm/ext/matrix_double3x3.hpp>
+#include <glm/ext/matrix_float4x4.hpp>
+#include <glm/ext/matrix_double4x4.hpp>
+#include <glm/ext/matrix_transform.hpp>
+#include <glm/ext/matrix_relational.hpp>
+#include <glm/ext/vector_float4.hpp>
+#if GLM_CONFIG_SIMD == GLM_ENABLE
+#include <glm/gtc/type_aligned.hpp>
+#include <vector>
+#include <chrono>
+#include <cstdio>
+
+template <typename matType>
+static void test_mat_mul_mat(matType const& M, std::vector<matType> const& I, std::vector<matType>& O)
+{
+	for (std::size_t i = 0, n = I.size(); i < n; ++i)
+		O[i] = M * I[i];
+}
+
+template <typename matType>
+static int launch_mat_mul_mat(std::vector<matType>& O, matType const& Transform, matType const& Scale, std::size_t Samples)
+{
+	typedef typename matType::value_type T;
+
+	std::vector<matType> I(Samples);
+	O.resize(Samples);
+
+	for(std::size_t i = 0; i < Samples; ++i)
+		I[i] = Scale * static_cast<T>(i);
+
+	std::chrono::high_resolution_clock::time_point t1 = std::chrono::high_resolution_clock::now();
+	test_mat_mul_mat<matType>(Transform, I, O);
+	std::chrono::high_resolution_clock::time_point t2 = std::chrono::high_resolution_clock::now();
+
+	return static_cast<int>(std::chrono::duration_cast<std::chrono::microseconds>(t2 - t1).count());
+}
+
+template <typename packedMatType, typename alignedMatType>
+static int comp_mat2_mul_mat2(std::size_t Samples)
+{
+	typedef typename packedMatType::value_type T;
+	
+	int Error = 0;
+
+	packedMatType const Transform(1, 2, 3, 4);
+	packedMatType const Scale(0.01, 0.02, 0.03, 0.05);
+
+	std::vector<packedMatType> SISD;
+	std::printf("- SISD: %d us\n", launch_mat_mul_mat<packedMatType>(SISD, Transform, Scale, Samples));
+
+	std::vector<alignedMatType> SIMD;
+	std::printf("- SIMD: %d us\n", launch_mat_mul_mat<alignedMatType>(SIMD, Transform, Scale, Samples));
+
+	for(std::size_t i = 0; i < Samples; ++i)
+	{
+		packedMatType const A = SISD[i];
+		packedMatType const B = SIMD[i];
+		Error += glm::all(glm::equal(A, B, static_cast<T>(0.001))) ? 0 : 1;
+	}
+	
+	return Error;
+}
+
+template <typename packedMatType, typename alignedMatType>
+static int comp_mat3_mul_mat3(std::size_t Samples)
+{
+	typedef typename packedMatType::value_type T;
+	
+	int Error = 0;
+
+	packedMatType const Transform(1, 2, 3, 4, 5, 6, 7, 8, 9);
+	packedMatType const Scale(0.01, 0.02, 0.03, 0.05, 0.01, 0.02, 0.03, 0.05, 0.01);
+
+	std::vector<packedMatType> SISD;
+	std::printf("- SISD: %d us\n", launch_mat_mul_mat<packedMatType>(SISD, Transform, Scale, Samples));
+
+	std::vector<alignedMatType> SIMD;
+	std::printf("- SIMD: %d us\n", launch_mat_mul_mat<alignedMatType>(SIMD, Transform, Scale, Samples));
+
+	for(std::size_t i = 0; i < Samples; ++i)
+	{
+		packedMatType const A = SISD[i];
+		packedMatType const B = SIMD[i];
+		Error += glm::all(glm::equal(A, B, static_cast<T>(0.001))) ? 0 : 1;
+	}
+	
+	return Error;
+}
+
+template <typename packedMatType, typename alignedMatType>
+static int comp_mat4_mul_mat4(std::size_t Samples)
+{
+	typedef typename packedMatType::value_type T;
+	
+	int Error = 0;
+
+	packedMatType const Transform(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
+	packedMatType const Scale(0.01, 0.02, 0.03, 0.05, 0.01, 0.02, 0.03, 0.05, 0.01, 0.02, 0.03, 0.05, 0.01, 0.02, 0.03, 0.05);
+
+	std::vector<packedMatType> SISD;
+	std::printf("- SISD: %d us\n", launch_mat_mul_mat<packedMatType>(SISD, Transform, Scale, Samples));
+
+	std::vector<alignedMatType> SIMD;
+	std::printf("- SIMD: %d us\n", launch_mat_mul_mat<alignedMatType>(SIMD, Transform, Scale, Samples));
+
+	for(std::size_t i = 0; i < Samples; ++i)
+	{
+		packedMatType const A = SISD[i];
+		packedMatType const B = SIMD[i];
+		Error += glm::all(glm::equal(A, B, static_cast<T>(0.001))) ? 0 : 1;
+	}
+	
+	return Error;
+}
+
+int main()
+{
+	std::size_t const Samples = 100000;
+
+	int Error = 0;
+
+	std::printf("mat2 * mat2:\n");
+	Error += comp_mat2_mul_mat2<glm::mat2, glm::aligned_mat2>(Samples);
+	
+	std::printf("dmat2 * dmat2:\n");
+	Error += comp_mat2_mul_mat2<glm::dmat2, glm::aligned_dmat2>(Samples);
+
+	std::printf("mat3 * mat3:\n");
+	Error += comp_mat3_mul_mat3<glm::mat3, glm::aligned_mat3>(Samples);
+	
+	std::printf("dmat3 * dmat3:\n");
+	Error += comp_mat3_mul_mat3<glm::dmat3, glm::aligned_dmat3>(Samples);
+
+	std::printf("mat4 * mat4:\n");
+	Error += comp_mat4_mul_mat4<glm::mat4, glm::aligned_mat4>(Samples);
+	
+	std::printf("dmat4 * dmat4:\n");
+	Error += comp_mat4_mul_mat4<glm::dmat4, glm::aligned_dmat4>(Samples);
+
+	return Error;
+}
+
+#else
+
+int main()
+{
+	return 0;
+}
+
+#endif
diff --git a/3rdparty/glm/source/test/perf/perf_matrix_mul_vector.cpp b/3rdparty/glm/source/test/perf/perf_matrix_mul_vector.cpp
new file mode 100644
index 0000000..8e555f8
--- /dev/null
+++ b/3rdparty/glm/source/test/perf/perf_matrix_mul_vector.cpp
@@ -0,0 +1,154 @@
+#define GLM_FORCE_INLINE
+#include <glm/ext/matrix_float2x2.hpp>
+#include <glm/ext/matrix_double2x2.hpp>
+#include <glm/ext/matrix_float3x3.hpp>
+#include <glm/ext/matrix_double3x3.hpp>
+#include <glm/ext/matrix_float4x4.hpp>
+#include <glm/ext/matrix_double4x4.hpp>
+#include <glm/ext/matrix_transform.hpp>
+#include <glm/ext/matrix_relational.hpp>
+#include <glm/ext/vector_float4.hpp>
+#if GLM_CONFIG_SIMD == GLM_ENABLE
+#include <glm/gtc/type_aligned.hpp>
+#include <vector>
+#include <chrono>
+#include <cstdio>
+
+template <typename matType, typename vecType>
+static void test_mat_mul_vec(matType const& M, std::vector<vecType> const& I, std::vector<vecType>& O)
+{
+	for (std::size_t i = 0, n = I.size(); i < n; ++i)
+		O[i] = M * I[i];
+}
+
+template <typename matType, typename vecType>
+static int launch_mat_mul_vec(std::vector<vecType>& O, matType const& Transform, vecType const& Scale, std::size_t Samples)
+{
+	typedef typename matType::value_type T;
+
+	std::vector<vecType> I(Samples);
+	O.resize(Samples);
+
+	for(std::size_t i = 0; i < Samples; ++i)
+		I[i] = Scale * static_cast<T>(i);
+
+	std::chrono::high_resolution_clock::time_point t1 = std::chrono::high_resolution_clock::now();
+	test_mat_mul_vec<matType, vecType>(Transform, I, O);
+	std::chrono::high_resolution_clock::time_point t2 = std::chrono::high_resolution_clock::now();
+
+	return static_cast<int>(std::chrono::duration_cast<std::chrono::microseconds>(t2 - t1).count());
+}
+
+template <typename packedMatType, typename packedVecType, typename alignedMatType, typename alignedVecType>
+static int comp_mat2_mul_vec2(std::size_t Samples)
+{
+	typedef typename packedMatType::value_type T;
+	
+	int Error = 0;
+
+	packedMatType const Transform(1, 2, 3, 4);
+	packedVecType const Scale(0.01, 0.02);
+
+	std::vector<packedVecType> SISD;
+	std::printf("- SISD: %d us\n", launch_mat_mul_vec<packedMatType, packedVecType>(SISD, Transform, Scale, Samples));
+
+	std::vector<alignedVecType> SIMD;
+	std::printf("- SIMD: %d us\n", launch_mat_mul_vec<alignedMatType, alignedVecType>(SIMD, Transform, Scale, Samples));
+
+	for(std::size_t i = 0; i < Samples; ++i)
+	{
+		packedVecType const A = SISD[i];
+		packedVecType const B = packedVecType(SIMD[i]);
+		Error += glm::all(glm::equal(A, B, static_cast<T>(0.001))) ? 0 : 1;
+	}
+	
+	return Error;
+}
+
+template <typename packedMatType, typename packedVecType, typename alignedMatType, typename alignedVecType>
+static int comp_mat3_mul_vec3(std::size_t Samples)
+{
+	typedef typename packedMatType::value_type T;
+	
+	int Error = 0;
+
+	packedMatType const Transform(1, 2, 3, 4, 5, 6, 7, 8, 9);
+	packedVecType const Scale(0.01, 0.02, 0.05);
+
+	std::vector<packedVecType> SISD;
+	std::printf("- SISD: %d us\n", launch_mat_mul_vec<packedMatType, packedVecType>(SISD, Transform, Scale, Samples));
+
+	std::vector<alignedVecType> SIMD;
+	std::printf("- SIMD: %d us\n", launch_mat_mul_vec<alignedMatType, alignedVecType>(SIMD, Transform, Scale, Samples));
+
+	for(std::size_t i = 0; i < Samples; ++i)
+	{
+		packedVecType const A = SISD[i];
+		packedVecType const B = SIMD[i];
+		Error += glm::all(glm::equal(A, B, static_cast<T>(0.001))) ? 0 : 1;
+	}
+	
+	return Error;
+}
+
+template <typename packedMatType, typename packedVecType, typename alignedMatType, typename alignedVecType>
+static int comp_mat4_mul_vec4(std::size_t Samples)
+{
+	typedef typename packedMatType::value_type T;
+	
+	int Error = 0;
+
+	packedMatType const Transform(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
+	packedVecType const Scale(0.01, 0.02, 0.03, 0.05);
+
+	std::vector<packedVecType> SISD;
+	std::printf("- SISD: %d us\n", launch_mat_mul_vec<packedMatType, packedVecType>(SISD, Transform, Scale, Samples));
+
+	std::vector<alignedVecType> SIMD;
+	std::printf("- SIMD: %d us\n", launch_mat_mul_vec<alignedMatType, alignedVecType>(SIMD, Transform, Scale, Samples));
+
+	for(std::size_t i = 0; i < Samples; ++i)
+	{
+		packedVecType const A = SISD[i];
+		packedVecType const B = SIMD[i];
+		Error += glm::all(glm::equal(A, B, static_cast<T>(0.001))) ? 0 : 1;
+	}
+	
+	return Error;
+}
+
+int main()
+{
+	std::size_t const Samples = 100000;
+	
+	int Error = 0;
+
+	std::printf("mat2 * vec2:\n");
+	Error += comp_mat2_mul_vec2<glm::mat2, glm::vec2, glm::aligned_mat2, glm::aligned_vec2>(Samples);
+	
+	std::printf("dmat2 * dvec2:\n");
+	Error += comp_mat2_mul_vec2<glm::dmat2, glm::dvec2,glm::aligned_dmat2, glm::aligned_dvec2>(Samples);
+
+	std::printf("mat3 * vec3:\n");
+	Error += comp_mat3_mul_vec3<glm::mat3, glm::vec3, glm::aligned_mat3, glm::aligned_vec3>(Samples);
+	
+	std::printf("dmat3 * dvec3:\n");
+	Error += comp_mat3_mul_vec3<glm::dmat3, glm::dvec3, glm::aligned_dmat3, glm::aligned_dvec3>(Samples);
+
+	std::printf("mat4 * vec4:\n");
+	Error += comp_mat4_mul_vec4<glm::mat4, glm::vec4, glm::aligned_mat4, glm::aligned_vec4>(Samples);
+	
+	std::printf("dmat4 * dvec4:\n");
+	Error += comp_mat4_mul_vec4<glm::dmat4, glm::dvec4, glm::aligned_dmat4, glm::aligned_dvec4>(Samples);
+
+	return Error;
+}
+
+#else
+
+int main()
+{
+	return 0;
+}
+
+#endif
diff --git a/3rdparty/glm/source/test/perf/perf_matrix_transpose.cpp b/3rdparty/glm/source/test/perf/perf_matrix_transpose.cpp
new file mode 100644
index 0000000..2fdc782
--- /dev/null
+++ b/3rdparty/glm/source/test/perf/perf_matrix_transpose.cpp
@@ -0,0 +1,150 @@
+#define GLM_FORCE_INLINE
+#include <glm/matrix.hpp>
+#include <glm/ext/matrix_float4x4.hpp>
+#include <glm/ext/matrix_double4x4.hpp>
+#include <glm/ext/matrix_relational.hpp>
+#include <glm/ext/vector_float4.hpp>
+#if GLM_CONFIG_SIMD == GLM_ENABLE
+#include <glm/gtc/type_aligned.hpp>
+#include <vector>
+#include <chrono>
+#include <cstdio>
+
+template <typename matType>
+static void test_mat_transpose(std::vector<matType> const& I, std::vector<matType>& O)
+{
+	for (std::size_t i = 0, n = I.size(); i < n; ++i)
+		O[i] = glm::transpose(I[i]);
+}
+
+template <typename matType>
+static int launch_mat_transpose(std::vector<matType>& O, matType const& Scale, std::size_t Samples)
+{
+	typedef typename matType::value_type T;
+
+	std::vector<matType> I(Samples);
+	O.resize(Samples);
+
+	for(std::size_t i = 0; i < Samples; ++i)
+		I[i] = Scale * static_cast<T>(i) + Scale;
+
+	std::chrono::high_resolution_clock::time_point t1 = std::chrono::high_resolution_clock::now();
+	test_mat_transpose<matType>(I, O);
+	std::chrono::high_resolution_clock::time_point t2 = std::chrono::high_resolution_clock::now();
+
+	return static_cast<int>(std::chrono::duration_cast<std::chrono::microseconds>(t2 - t1).count());
+}
+
+template <typename packedMatType, typename alignedMatType>
+static int comp_mat2_transpose(std::size_t Samples)
+{
+	typedef typename packedMatType::value_type T;
+	
+	int Error = 0;
+
+	packedMatType const Scale(0.01, 0.02, 0.03, 0.05);
+
+	std::vector<packedMatType> SISD;
+	std::printf("- SISD: %d us\n", launch_mat_transpose<packedMatType>(SISD, Scale, Samples));
+
+	std::vector<alignedMatType> SIMD;
+	std::printf("- SIMD: %d us\n", launch_mat_transpose<alignedMatType>(SIMD, Scale, Samples));
+
+	for(std::size_t i = 0; i < Samples; ++i)
+	{
+		packedMatType const A = SISD[i];
+		packedMatType const B = SIMD[i];
+		Error += glm::all(glm::equal(A, B, static_cast<T>(0.001))) ? 0 : 1;
+		assert(!Error);
+	}
+	
+	return Error;
+}
+
+template <typename packedMatType, typename alignedMatType>
+static int comp_mat3_transpose(std::size_t Samples)
+{
+	typedef typename packedMatType::value_type T;
+	
+	int Error = 0;
+
+	packedMatType const Scale(0.01, 0.02, 0.03, 0.05, 0.01, 0.02, 0.03, 0.05, 0.01);
+
+	std::vector<packedMatType> SISD;
+	std::printf("- SISD: %d us\n", launch_mat_transpose<packedMatType>(SISD, Scale, Samples));
+
+	std::vector<alignedMatType> SIMD;
+	std::printf("- SIMD: %d us\n", launch_mat_transpose<alignedMatType>(SIMD, Scale, Samples));
+
+	for(std::size_t i = 0; i < Samples; ++i)
+	{
+		packedMatType const A = SISD[i];
+		packedMatType const B = SIMD[i];
+		Error += glm::all(glm::equal(A, B, static_cast<T>(0.001))) ? 0 : 1;
+		assert(!Error);
+	}
+	
+	return Error;
+}
+
+template <typename packedMatType, typename alignedMatType>
+static int comp_mat4_transpose(std::size_t Samples)
+{
+	typedef typename packedMatType::value_type T;
+	
+	int Error = 0;
+
+	packedMatType const Scale(0.01, 0.02, 0.05, 0.04, 0.02, 0.08, 0.05, 0.01, 0.08, 0.03, 0.05, 0.06, 0.02, 0.03, 0.07, 0.05);
+
+	std::vector<packedMatType> SISD;
+	std::printf("- SISD: %d us\n", launch_mat_transpose<packedMatType>(SISD, Scale, Samples));
+
+	std::vector<alignedMatType> SIMD;
+	std::printf("- SIMD: %d us\n", launch_mat_transpose<alignedMatType>(SIMD, Scale, Samples));
+
+	for(std::size_t i = 0; i < Samples; ++i)
+	{
+		packedMatType const A = SISD[i];
+		packedMatType const B = SIMD[i];
+		Error += glm::all(glm::equal(A, B, static_cast<T>(0.001))) ? 0 : 1;
+		assert(!Error);
+	}
+	
+	return Error;
+}
+
+int main()
+{
+	std::size_t const Samples = 100000;
+
+	int Error = 0;
+
+	std::printf("glm::transpose(mat2):\n");
+	Error += comp_mat2_transpose<glm::mat2, glm::aligned_mat2>(Samples);
+	
+	std::printf("glm::transpose(dmat2):\n");
+	Error += comp_mat2_transpose<glm::dmat2, glm::aligned_dmat2>(Samples);
+
+	std::printf("glm::transpose(mat3):\n");
+	Error += comp_mat3_transpose<glm::mat3, glm::aligned_mat3>(Samples);
+	
+	std::printf("glm::transpose(dmat3):\n");
+	Error += comp_mat3_transpose<glm::dmat3, glm::aligned_dmat3>(Samples);
+
+	std::printf("glm::transpose(mat4):\n");
+	Error += comp_mat4_transpose<glm::mat4, glm::aligned_mat4>(Samples);
+	
+	std::printf("glm::transpose(dmat4):\n");
+	Error += comp_mat4_transpose<glm::dmat4, glm::aligned_dmat4>(Samples);
+
+	return Error;
+}
+
+#else
+
+int main()
+{
+	return 0;
+}
+
+#endif
diff --git a/3rdparty/glm/source/test/perf/perf_vector_mul_matrix.cpp b/3rdparty/glm/source/test/perf/perf_vector_mul_matrix.cpp
new file mode 100644
index 0000000..20991df
--- /dev/null
+++ b/3rdparty/glm/source/test/perf/perf_vector_mul_matrix.cpp
@@ -0,0 +1,154 @@
+#define GLM_FORCE_INLINE
+#include <glm/ext/matrix_float2x2.hpp>
+#include <glm/ext/matrix_double2x2.hpp>
+#include <glm/ext/matrix_float3x3.hpp>
+#include <glm/ext/matrix_double3x3.hpp>
+#include <glm/ext/matrix_float4x4.hpp>
+#include <glm/ext/matrix_double4x4.hpp>
+#include <glm/ext/matrix_transform.hpp>
+#include <glm/ext/matrix_relational.hpp>
+#include <glm/ext/vector_float4.hpp>
+#if GLM_CONFIG_SIMD == GLM_ENABLE
+#include <glm/gtc/type_aligned.hpp>
+#include <vector>
+#include <chrono>
+#include <cstdio>
+
+template <typename matType, typename vecType>
+static void test_vec_mul_mat(matType const& M, std::vector<vecType> const& I, std::vector<vecType>& O)
+{
+	for (std::size_t i = 0, n = I.size(); i < n; ++i)
+		O[i] = I[i] * M;
+}
+
+template <typename matType, typename vecType>
+static int launch_vec_mul_mat(std::vector<vecType>& O, matType const& Transform, vecType const& Scale, std::size_t Samples)
+{
+	typedef typename matType::value_type T;
+
+	std::vector<vecType> I(Samples);
+	O.resize(Samples);
+
+	for(std::size_t i = 0; i < Samples; ++i)
+		I[i] = Scale * static_cast<T>(i);
+
+	std::chrono::high_resolution_clock::time_point t1 = std::chrono::high_resolution_clock::now();
+	test_vec_mul_mat<matType, vecType>(Transform, I, O);
+	std::chrono::high_resolution_clock::time_point t2 = std::chrono::high_resolution_clock::now();
+
+	return static_cast<int>(std::chrono::duration_cast<std::chrono::microseconds>(t2 - t1).count());
+}
+
+template <typename packedMatType, typename packedVecType, typename alignedMatType, typename alignedVecType>
+static int comp_vec2_mul_mat2(std::size_t Samples)
+{
+	typedef typename packedMatType::value_type T;
+	
+	int Error = 0;
+
+	packedMatType const Transform(1, 2, 3, 4);
+	packedVecType const Scale(0.01, 0.02);
+
+	std::vector<packedVecType> SISD;
+	std::printf("- SISD: %d us\n", launch_vec_mul_mat<packedMatType, packedVecType>(SISD, Transform, Scale, Samples));
+
+	std::vector<alignedVecType> SIMD;
+	std::printf("- SIMD: %d us\n", launch_vec_mul_mat<alignedMatType, alignedVecType>(SIMD, Transform, Scale, Samples));
+
+	for(std::size_t i = 0; i < Samples; ++i)
+	{
+		packedVecType const A = SISD[i];
+		packedVecType const B = packedVecType(SIMD[i]);
+		Error += glm::all(glm::equal(A, B, static_cast<T>(0.001))) ? 0 : 1;
+	}
+	
+	return Error;
+}
+
+template <typename packedMatType, typename packedVecType, typename alignedMatType, typename alignedVecType>
+static int comp_vec3_mul_mat3(std::size_t Samples)
+{
+	typedef typename packedMatType::value_type T;
+	
+	int Error = 0;
+
+	packedMatType const Transform(1, 2, 3, 4, 5, 6, 7, 8, 9);
+	packedVecType const Scale(0.01, 0.02, 0.05);
+
+	std::vector<packedVecType> SISD;
+	std::printf("- SISD: %d us\n", launch_vec_mul_mat<packedMatType, packedVecType>(SISD, Transform, Scale, Samples));
+
+	std::vector<alignedVecType> SIMD;
+	std::printf("- SIMD: %d us\n", launch_vec_mul_mat<alignedMatType, alignedVecType>(SIMD, Transform, Scale, Samples));
+
+	for(std::size_t i = 0; i < Samples; ++i)
+	{
+		packedVecType const A = SISD[i];
+		packedVecType const B = SIMD[i];
+		Error += glm::all(glm::equal(A, B, static_cast<T>(0.001))) ? 0 : 1;
+	}
+	
+	return Error;
+}
+
+template <typename packedMatType, typename packedVecType, typename alignedMatType, typename alignedVecType>
+static int comp_vec4_mul_mat4(std::size_t Samples)
+{
+	typedef typename packedMatType::value_type T;
+	
+	int Error = 0;
+
+	packedMatType const Transform(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
+	packedVecType const Scale(0.01, 0.02, 0.03, 0.05);
+
+	std::vector<packedVecType> SISD;
+	std::printf("- SISD: %d us\n", launch_vec_mul_mat<packedMatType, packedVecType>(SISD, Transform, Scale, Samples));
+
+	std::vector<alignedVecType> SIMD;
+	std::printf("- SIMD: %d us\n", launch_vec_mul_mat<alignedMatType, alignedVecType>(SIMD, Transform, Scale, Samples));
+
+	for(std::size_t i = 0; i < Samples; ++i)
+	{
+		packedVecType const A = SISD[i];
+		packedVecType const B = SIMD[i];
+		Error += glm::all(glm::equal(A, B, static_cast<T>(0.001))) ? 0 : 1;
+	}
+	
+	return Error;
+}
+
+int main()
+{
+	std::size_t const Samples = 100000;
+	
+	int Error = 0;
+
+	std::printf("vec2 * mat2:\n");
+	Error += comp_vec2_mul_mat2<glm::mat2, glm::vec2, glm::aligned_mat2, glm::aligned_vec2>(Samples);
+	
+	std::printf("dvec2 * dmat2:\n");
+	Error += comp_vec2_mul_mat2<glm::dmat2, glm::dvec2,glm::aligned_dmat2, glm::aligned_dvec2>(Samples);
+
+	std::printf("vec3 * mat3:\n");
+	Error += comp_vec3_mul_mat3<glm::mat3, glm::vec3, glm::aligned_mat3, glm::aligned_vec3>(Samples);
+	
+	std::printf("dvec3 * dmat3:\n");
+	Error += comp_vec3_mul_mat3<glm::dmat3, glm::dvec3, glm::aligned_dmat3, glm::aligned_dvec3>(Samples);
+
+	std::printf("vec4 * mat4:\n");
+	Error += comp_vec4_mul_mat4<glm::mat4, glm::vec4, glm::aligned_mat4, glm::aligned_vec4>(Samples);
+	
+	std::printf("dvec4 * dmat4:\n");
+	Error += comp_vec4_mul_mat4<glm::dmat4, glm::dvec4, glm::aligned_dmat4, glm::aligned_dvec4>(Samples);
+
+	return Error;
+}
+
+#else
+
+int main()
+{
+	return 0;
+}
+
+#endif