Some Change in Gui.

Add shlwapi.lib to rpcs3-tests link dependencies.

.gitignore

@@ -32,7 +32,8 @@
 
 /build
 /bin
-/libs
+/lib
+/tmp
 /ipch
 /rpcs3/Debug
 /rpcs3/Release
@@ -51,9 +52,10 @@
 /bin/*.exp
 rpcs3/git-version.h
 
-# Visual Studio Profiler Files
+# Visual Studio Files
 *.vspx
 *.psess
+*.VC.*
 
 # Copyrighted files
 /bin/data/
@@ -70,9 +72,14 @@ rpcs3/git-version.h
 bin/dev_hdd0/*.txt
 x64/*
 rpcs3/x64/*
+rpcs3-tests/x64/*
 
-.DS_Store
-rpcs3/Emu/SysCalls/Modules/prx_*.h
-
-/CMakeFiles/
+# cmake
+Makefile
+*CMakeFiles*
 CMakeCache.txt
+*cmake_install.cmake*
+
+# cotire
+rpcs3/cotire/*
+rpcs3/rpcs3_*_cotire.cmake

.gitmodules

@@ -8,6 +8,7 @@
 [submodule "asmjit"]
 	path = asmjit
 	url = https://github.com/kobalicek/asmjit
+	ignore = dirty
 [submodule "llvm"]
 	path = llvm
 	url = https://github.com/llvm-mirror/llvm
@@ -15,3 +16,6 @@
 [submodule "minidx9"]
 	path = minidx9
 	url = https://github.com/hrydgard/minidx9.git
+[submodule "rsx_program_decompiler"]
+	path = rsx_program_decompiler
+	url = https://github.com/RPCS3/rsx_program_decompiler

.mention-bot

@@ -0,0 +1,3 @@
+{
+  "userBlacklist": [AlexAltea]
+}

.travis.yml

@@ -12,9 +12,9 @@ compiler:
 
 env:
   global:
-   - secure: "jA29KvTCTR7q4BMzPPUBGazjJwrIWa7k4fo5ZSMlyxh2NbztZTKQYwodgDcXBoptCd1KJ9H3FXwBnNdMNVnTkvoPL9uWnN4K/3D1D20FCag1kmlBwnaVqVei5cRiZ9TOMuaxhjkdg8pcrQLTlXEEdMZf6A2OW0VgoBGDVSX9nYc="
+   - secure: "Vf+FY48nip9JppMnq11105NealdErSWsoUhHo63/V3V+LKfA9guenxCp93/qoSIdSGC/sJwb0yIIMGvkTT/rxDJNh6Z+BWUTb2E0WEIIQbvTJNOSUzoq7dfF1LT61XjVjByFzcbC2xjtaBowmcAYEs1jGUUuEjYVCMmD5lY8hUg="
    # Which Travis environment to run Coverity on
-   - coverity_scan_run_condition='"$CC" = gcc -a "$TRAVIS_OS_NAME" != osx'
+   - coverity_scan_run_condition='"$TRAVIS_OS_NAME" = linux -a "$CC" = gcc'
    # Test mode is for testing if it's working with Coverity. Change to true if testing, to avoid reaching the quota.
    - coverity_scan_script_test_mode=false
 
@@ -32,50 +32,26 @@ git:
 
 before_install:
 # shutdown services on Travis, which may have a memory impact
-# show memory usage before and after shutdown of services
   - if [ "$TRAVIS_OS_NAME" = "linux" ]; then
-      sudo service --status-all;
-      sudo free -m -t;
-      sudo /etc/init.d/mysql stop;
-      sudo /etc/init.d/postgresql stop;
-      sudo /etc/init.d/couchdb stop;
-      sudo /etc/init.d/redis-server stop;
-      sudo free -m -t;
-
-      echo "yes" | sudo apt-key adv --fetch-keys 'http://repos.codelite.org/CodeLite.asc';
       echo "yes" | sudo apt-add-repository 'deb http://repos.codelite.org/wx3.0/ubuntu/ precise universe';
-      echo "yes" | sudo add-apt-repository 'deb http://ppa.launchpad.net/ubuntu-toolchain-r/test/ubuntu precise main';
-      echo "yes" | sudo add-apt-repository 'deb http://llvm.org/apt/precise/ llvm-toolchain-precise-3.6 main';
-      wget -O - http://llvm.org/apt/llvm-snapshot.gpg.key | sudo apt-key add -;
-      sudo add-apt-repository ppa:ubuntu-toolchain-r/test -y;
-      sudo apt-get update;
-      sudo apt-get install libwxgtk3.0-dev libopenal-dev freeglut3-dev libglew-dev libc6-dev llvm-3.6 llvm-3.6-dev libedit-dev;
-      sudo apt-get install aria2 -qq;
-      download_extract() { aria2c -x 16 $1 -o $2 && tar -xf $2; };
+      sudo apt-get install libwxgtk3.0-dev;
     fi;
   - if [ "$TRAVIS_OS_NAME" = "linux" ] && [ "$CXX" = "g++" ]; then
-      sudo apt-get install -qq g++-4.9;
       export CXX="g++-4.9" CC="gcc-4.9" CXXFLAGS="-Wno-format-security";
       export GCC_COLORS='error=01;31:warning=01;35:note=01;36:caret=01;32:locus=01:quote=01';
     elif [ "$TRAVIS_OS_NAME" = "linux" ]; then
-      sudo apt-get install -qq --allow-unauthenticated clang-3.6 libstdc++-4.8-dev;
       export CXX="clang++-3.6" CC="clang-3.6";
     fi;
-# Travis uses CMake 2.8.7. We require 2.8.8. Grab latest
 # Add coverall for C++ so coverall.io could be triggered. Even it should be --coverage and gcov.
   - if [ "$TRAVIS_OS_NAME" = "linux" ]; then
-      sudo apt-get install lib32stdc++6 -qq &&
-      aria2c -x 16 http://www.cmake.org/files/v3.0/cmake-3.0.0-Linux-i386.sh && 
-      chmod a+x cmake-3.0.0-Linux-i386.sh &&
-      sudo ./cmake-3.0.0-Linux-i386.sh --skip-license --prefix=/usr;
-      sudo pip install cpp-coveralls;
+      sudo pip install cpp-coveralls requests[security];
     else
       brew update; brew update;
       brew install glew wxwidgets llvm36;
     fi;
 
 before_script:
- - git submodule update --init asmjit ffmpeg
+ - git submodule update --init asmjit ffmpeg rsx_program_decompiler
  - mkdir build
  - cd build
  - if [ "$TRAVIS_OS_NAME" = "linux" ]; then cmake ..; else cmake .. -DLLVM_DIR=/usr/local/opt/llvm36/lib/llvm-3.6/share/llvm/cmake; fi
@@ -88,20 +64,31 @@ script:
 - if [ "$COVERITY_SCAN_BRANCH" != 1 ]; then make -j 4; fi
 
 addons:
+  apt:
+    sources:
+    - ubuntu-toolchain-r-test
+    - llvm-toolchain-precise-3.6
+    - kubuntu-backports
+    packages:
+    - cmake
+    - libopenal-dev
+    - freeglut3-dev
+    - libglew-dev
+    - libc6-dev
+    - llvm-3.6
+    - llvm-3.6-dev
+    - libedit-dev
+    - g++-4.9
+    - clang-3.6
+    - libstdc++-4.8-dev
+    - lib32stdc++6
   coverity_scan:
     project:
       name: $TRAVIS_REPO_SLUG
+      description: "PS3 emulator/debugger"
     notification_email: raul.tambre@gmail.com
-    build_command_prepend: ""
-    build_command:   "make -j 4"
-    branch_pattern: master
+    build_command: "make -j 4"
+    branch_pattern: coverity_scan
 
 after_success:
-- coveralls --extension .c --extension .cpp --extension .h;
-
-after_failure:
-# show memory usage again and show actions of the OOM killer
- - if [ "$TRAVIS_OS_NAME" = "linux" ]; then
-     sudo free -m -t;
-     sudo dmesg;
-   fi;
+- if [ "$COVERITY_SCAN_BRANCH" != 1 ] && [ "$TRAVIS_OS_NAME" = linux ]; then coveralls --extension .c --extension .cpp --extension .h; fi

README.md

@@ -3,17 +3,17 @@ RPCS3
 
 [![Build Status](https://travis-ci.org/RPCS3/rpcs3.svg?branch=master)](https://travis-ci.org/RPCS3/rpcs3)
 [![Build status](https://ci.appveyor.com/api/projects/status/411c4clmiohtx7eo/branch/master?svg=true)](https://ci.appveyor.com/project/rpcs3/rpcs3/branch/master)
-[![Coverity Status](https://scan.coverity.com/projects/3960/badge.svg)](https://scan.coverity.com/projects/3960)
-[![Coverage Status](https://coveralls.io/repos/DHrpcs3/rpcs3/badge.svg)](https://coveralls.io/r/DHrpcs3/rpcs3)
+[![Coverity Status](https://img.shields.io/coverity/scan/3960.svg)](https://scan.coverity.com/projects/3960)
+[![Coverage Status](https://coveralls.io/repos/RPCS3/rpcs3/badge.svg)](https://coveralls.io/r/RPCS3/rpcs3)
 
 An open-source PlayStation 3 emulator/debugger written in C++.
 
-You can find some basic information in the [FAQ](https://github.com/DHrpcs3/rpcs3/wiki/FAQ). For discussion about this emulator and PS3 emulation please visit the [official forums](http://www.emunewz.net/forum/forumdisplay.php?fid=162).
+You can find some basic information in the [FAQ](https://github.com/RPCS3/rpcs3/wiki/FAQ). For discussion about this emulator and PS3 emulation please visit the [official forums](http://www.emunewz.net/forum/forumdisplay.php?fid=162).
 
 
 ### Development
 
-If you want to contribute please take a took at the [Coding Style](https://github.com/DHrpcs3/rpcs3/wiki/Coding-Style), [Roadmap](https://github.com/DHrpcs3/rpcs3/wiki/Roadmap) and [Developer Information](https://github.com/DHrpcs3/rpcs3/wiki/Developer-Information) pages. You should as well contact any of the developers in the forum in order to know about the current situation of the emulator.
+If you want to contribute please take a took at the [Coding Style](https://github.com/RPCS3/rpcs3/wiki/Coding-Style), [Roadmap](https://github.com/RPCS3/rpcs3/wiki/Roadmap) and [Developer Information](https://github.com/RPCS3/rpcs3/wiki/Developer-Information) pages. You should as well contact any of the developers in the forum in order to know about the current situation of the emulator.
 
 
 ### Dependencies
@@ -21,14 +21,16 @@ If you want to contribute please take a took at the [Coding Style](https://githu
 __Windows__
 * [Visual Studio 2015](https://www.visualstudio.com/en-us/downloads/download-visual-studio-vs.aspx)
 * [Visual C++ Redistributable Packages for Visual Studio 2015](http://www.microsoft.com/en-us/download/details.aspx?id=48145)
-* [Cmake 3.1.0+](http://www.cmake.org/download/) (add to PATH)
-* [Python 2.7+](https://www.python.org/downloads/) (add to PATH)
+* [Cmake 3.1.0+](http://www.cmake.org/download/) (optional, required only for LLVM build; add to PATH)
+* [Python](https://www.python.org/downloads/) (optional, required only for LLVM build; add to PATH)
 
 __Linux__
+* GCC 4.9.0+ or Clang 3.5.0+
 * Debian & Ubuntu: `sudo apt-get install libopenal-dev libwxgtk3.0-dev build-essential libglew-dev`
 * Arch: `sudo pacman -S glew openal wxgtk cmake llvm`
 
 __Mac OSX__
+* Xcode 6+ (tested with Xcode 6.4)
 * Install with Homebrew: `brew install glew wxwidgets` (add `llvm36` to that list if you want to build with ppu jit)
 * Remove '-framework QuickTime' from '_ldflags' in /usr/local/bin/wx-config
 
@@ -37,11 +39,12 @@ __Mac OSX__
 
 To initialize the repository don't forget to execute `git submodule update --init` to pull the wxWidgets source.
 * __Windows__:
-Open the *.SLN* file, and press *Build* > *Rebuild Solution*.
+Open the *.SLN* file, and press *Build* > *Clean Solution*, then *Build Solution*. *Rebuild* may not work correctly.
 * __Linux & Mac OSX__:
 If you want to build with LLVM, then LLVM 3.6.2 is required.
-`cd rpcs3 && cmake CMakeLists.txt && make && cd ../` Then run with `cd bin && ./rpcs3`
+`cd rpcs3 && cmake CMakeLists.txt && make && cd ../` then run with `cd bin && ./rpcs3`.
 If you are on OSX and want to build with llvm don't forget to add `-DLLVM_DIR=/usr/local/opt/llvm36/lib/llvm-3.6/share/llvm/cmake` (or wherever llvm brew was installed) to cmake invocation.
+When using GDB, configure it to ignore SIGSEGV signal (`handle SIGSEGV nostop noprint`).
 
 ### Support
 * [Donate by PayPal](https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=MPJ3S9XQXCE3G)

Utilities/Atomic.h

@@ -161,11 +161,7 @@ inline u128 sync_fetch_and_add(volatile u128* dest, u128 value)
 		old.lo = dest->lo;
 		old.hi = dest->hi;
 
-		u128 _new;
-		_new.lo = old.lo + value.lo;
-		_new.hi = old.hi + value.hi + (_new.lo < value.lo);
-
-		if (sync_bool_compare_and_swap(dest, old, _new)) return old;
+		if (sync_bool_compare_and_swap(dest, old, old + value)) return old;
 	}
 }
 
@@ -199,11 +195,7 @@ inline u128 sync_fetch_and_sub(volatile u128* dest, u128 value)
 		old.lo = dest->lo;
 		old.hi = dest->hi;
 
-		u128 _new;
-		_new.lo = old.lo - value.lo;
-		_new.hi = old.hi - value.hi - (old.lo < value.lo);
-
-		if (sync_bool_compare_and_swap(dest, old, _new)) return old;
+		if (sync_bool_compare_and_swap(dest, old, old - value)) return old;
 	}
 }
 
@@ -237,11 +229,7 @@ inline u128 sync_fetch_and_or(volatile u128* dest, u128 value)
 		old.lo = dest->lo;
 		old.hi = dest->hi;
 
-		u128 _new;
-		_new.lo = old.lo | value.lo;
-		_new.hi = old.hi | value.hi;
-
-		if (sync_bool_compare_and_swap(dest, old, _new)) return old;
+		if (sync_bool_compare_and_swap(dest, old, old | value)) return old;
 	}
 }
 
@@ -275,11 +263,7 @@ inline u128 sync_fetch_and_and(volatile u128* dest, u128 value)
 		old.lo = dest->lo;
 		old.hi = dest->hi;
 
-		u128 _new;
-		_new.lo = old.lo & value.lo;
-		_new.hi = old.hi & value.hi;
-
-		if (sync_bool_compare_and_swap(dest, old, _new)) return old;
+		if (sync_bool_compare_and_swap(dest, old, old & value)) return old;
 	}
 }
 
@@ -313,11 +297,7 @@ inline u128 sync_fetch_and_xor(volatile u128* dest, u128 value)
 		old.lo = dest->lo;
 		old.hi = dest->hi;
 
-		u128 _new;
-		_new.lo = old.lo ^ value.lo;
-		_new.hi = old.hi ^ value.hi;
-
-		if (sync_bool_compare_and_swap(dest, old, _new)) return old;
+		if (sync_bool_compare_and_swap(dest, old, old ^ value)) return old;
 	}
 }
 
@@ -355,17 +335,17 @@ template<typename T> struct atomic_storage<T, 16>
 
 template<typename T> using atomic_storage_t = typename atomic_storage<T>::type;
 
-// result wrapper to deal with void result type
+// atomic result wrapper; implements special behaviour for void result type
 template<typename T, typename RT, typename VT> struct atomic_op_result_t
 {
 	RT result;
 
-	template<typename... Args> inline atomic_op_result_t(T func, VT& var, Args&&... args)
+	template<typename... Args> atomic_op_result_t(T func, VT& var, Args&&... args)
 		: result(std::move(func(var, std::forward<Args>(args)...)))
 	{
 	}
 
-	inline RT move()
+	RT move()
 	{
 		return std::move(result);
 	}
@@ -376,13 +356,13 @@ template<typename T, typename VT> struct atomic_op_result_t<T, void, VT>
 {
 	VT result;
 
-	template<typename... Args> inline atomic_op_result_t(T func, VT& var, Args&&... args)
+	template<typename... Args> atomic_op_result_t(T func, VT& var, Args&&... args)
 		: result(var)
 	{
 		func(var, std::forward<Args>(args)...);
 	}
 
-	inline VT move()
+	VT move()
 	{
 		return std::move(result);
 	}
@@ -393,12 +373,12 @@ template<typename CT, typename... FArgs, typename RT, typename VT> struct atomic
 {
 	RT result;
 
-	template<typename... Args> inline atomic_op_result_t(RT(CT::*func)(FArgs...), VT& var, Args&&... args)
+	template<typename... Args> atomic_op_result_t(RT(CT::*func)(FArgs...), VT& var, Args&&... args)
 		: result(std::move((var.*func)(std::forward<Args>(args)...)))
 	{
 	}
 
-	inline RT move()
+	RT move()
 	{
 		return std::move(result);
 	}
@@ -409,18 +389,19 @@ template<typename CT, typename... FArgs, typename VT> struct atomic_op_result_t<
 {
 	VT result;
 
-	template<typename... Args> inline atomic_op_result_t(void(CT::*func)(FArgs...), VT& var, Args&&... args)
+	template<typename... Args> atomic_op_result_t(void(CT::*func)(FArgs...), VT& var, Args&&... args)
 		: result(var)
 	{
 		(var.*func)(std::forward<Args>(args)...);
 	}
 
-	inline VT move()
+	VT move()
 	{
 		return std::move(result);
 	}
 };
 
+// Atomic type with lock-free and standard layout guarantees (and appropriate limitations)
 template<typename T> class atomic_t
 {
 	using type = std::remove_cv_t<T>;
@@ -466,18 +447,14 @@ public:
 
 	atomic_t(const atomic_t&) = delete;
 
-	atomic_t(atomic_t&&) = delete;
-
-	inline atomic_t(type value)
+	atomic_t(type value)
 		: m_data(to_subtype(value))
 	{
 	}
 
 	atomic_t& operator =(const atomic_t&) = delete;
 
-	atomic_t& operator =(atomic_t&&) = delete;
-
-	inline atomic_t& operator =(type value)
+	atomic_t& operator =(type value)
 	{
 		return write_relaxed(m_data, to_subtype(value)), *this;
 	}
@@ -500,31 +477,31 @@ public:
 	}
 
 	// Atomically compare data with cmp, replace with exch if equal, return previous data value anyway
-	inline const type compare_and_swap(const type& cmp, const type& exch) volatile
+	type compare_and_swap(const type& cmp, const type& exch) volatile
 	{
 		return from_subtype(sync_val_compare_and_swap(&m_data, to_subtype(cmp), to_subtype(exch)));
 	}
 
 	// Atomically compare data with cmp, replace with exch if equal, return true if data was replaced
-	inline bool compare_and_swap_test(const type& cmp, const type& exch) volatile
+	bool compare_and_swap_test(const type& cmp, const type& exch) volatile
 	{
 		return sync_bool_compare_and_swap(&m_data, to_subtype(cmp), to_subtype(exch));
 	}
 
 	// Atomically replace data with exch, return previous data value
-	inline const type exchange(const type& exch) volatile
+	type exchange(const type& exch) volatile
 	{
 		return from_subtype(sync_lock_test_and_set(&m_data, to_subtype(exch)));
 	}
 
 	// Atomically read data, possibly without memory barrier (not for 128 bit)
-	inline const type load() const volatile
+	type load() const volatile
 	{
 		return from_subtype(read_relaxed(m_data));
 	}
 
 	// Atomically write data, possibly without memory barrier (not for 128 bit)
-	inline void store(const type& value) volatile
+	void store(const type& value) volatile
 	{
 		write_relaxed(m_data, to_subtype(value));
 	}
@@ -550,40 +527,40 @@ public:
 	}
 
 	// Atomic bitwise OR, returns previous data
-	inline const type _or(const type& right) volatile
+	type _or(const type& right) volatile
 	{
 		return from_subtype(sync_fetch_and_or(&m_data, to_subtype(right)));
 	}
 
 	// Atomic bitwise AND, returns previous data
-	inline const type _and(const type& right) volatile
+	type _and(const type& right) volatile
 	{
 		return from_subtype(sync_fetch_and_and(&m_data, to_subtype(right)));
 	}
 
 	// Atomic bitwise AND NOT (inverts right argument), returns previous data
-	inline const type _and_not(const type& right) volatile
+	type _and_not(const type& right) volatile
 	{
 		return from_subtype(sync_fetch_and_and(&m_data, ~to_subtype(right)));
 	}
 
 	// Atomic bitwise XOR, returns previous data
-	inline const type _xor(const type& right) volatile
+	type _xor(const type& right) volatile
 	{
 		return from_subtype(sync_fetch_and_xor(&m_data, to_subtype(right)));
 	}
 
-	inline const type operator |=(const type& right) volatile
+	type operator |=(const type& right) volatile
 	{
 		return from_subtype(sync_fetch_and_or(&m_data, to_subtype(right)) | to_subtype(right));
 	}
 
-	inline const type operator &=(const type& right) volatile
+	type operator &=(const type& right) volatile
 	{
 		return from_subtype(sync_fetch_and_and(&m_data, to_subtype(right)) & to_subtype(right));
 	}
 
-	inline const type operator ^=(const type& right) volatile
+	type operator ^=(const type& right) volatile
 	{
 		return from_subtype(sync_fetch_and_xor(&m_data, to_subtype(right)) ^ to_subtype(right));
 	}
@@ -697,9 +674,11 @@ template<typename T, typename T2> inline std::enable_if_t<IS_INTEGRAL(T) && std:
 	});
 }
 
-template<typename T> using atomic_be_t = atomic_t<be_t<T>>; // Atomic BE Type (for PS3 virtual memory)
+// Atomic BE Type (for PS3 virtual memory)
+template<typename T> using atomic_be_t = atomic_t<be_t<T>>;
 
-template<typename T> using atomic_le_t = atomic_t<le_t<T>>; // Atomic LE Type (for PSV virtual memory)
+// Atomic LE Type (for PSV virtual memory)
+template<typename T> using atomic_le_t = atomic_t<le_t<T>>;
 
 // Algorithm for std::atomic; similar to atomic_t::atomic_op()
 template<typename T, typename F, typename... Args, typename RT = std::result_of_t<F(T&, Args...)>> auto atomic_op(std::atomic<T>& var, F func, Args&&... args) -> decltype(atomic_op_result_t<F, RT, T>::result)

Utilities/AutoPause.cpp

@@ -1,9 +1,9 @@
 #include "stdafx.h"
-#include "rpcs3/Ini.h"
 #include "AutoPause.h"
 #include "Utilities/Log.h"
 #include "Utilities/File.h"
 #include "Emu/System.h"
+#include "Emu/state.h"
 
 using namespace Debug;
 
@@ -43,14 +43,14 @@ AutoPause::~AutoPause(void)
 //This would be able to create in a GUI window.
 void AutoPause::Reload(void)
 {
-	if (fs::is_file("pause.bin"))
+	if (fs::is_file(fs::get_config_dir() + "pause.bin"))
 	{
 		m_pause_function.clear();
 		m_pause_function.reserve(16);
 		m_pause_syscall.clear();
 		m_pause_syscall.reserve(16);
 
-		fs::file list("pause.bin");
+		fs::file list(fs::get_config_dir() + "pause.bin");
 		//System calls ID and Function calls ID are all u32 iirc.
 		u32 num;
 		size_t fmax = list.size();
@@ -77,8 +77,8 @@ void AutoPause::Reload(void)
 		}
 	}
 
-	m_pause_syscall_enable = Ini.DBGAutoPauseSystemCall.GetValue();
-	m_pause_function_enable = Ini.DBGAutoPauseFunctionCall.GetValue();
+	m_pause_syscall_enable = rpcs3::config.misc.debug.auto_pause_syscall.value();
+	m_pause_function_enable = rpcs3::config.misc.debug.auto_pause_func_call.value();
 	initialized = true;
 }
 

Utilities/BEType.h

@@ -8,34 +8,34 @@
 
 #define IS_LE_MACHINE // only draft
 
-template<typename T, std::size_t N, std::size_t M> class masked_array_t // array type accessed as (index ^ M)
-{
-	T m_data[N];
-
-public:
-	T& operator [](std::size_t index)
-	{
-		return m_data[index ^ M];
-	}
-
-	const T& operator [](std::size_t index) const
-	{
-		return m_data[index ^ M];
-	}
-
-	T& at(std::size_t index)
-	{
-		return (index ^ M) < N ? m_data[index ^ M] : throw std::out_of_range("Masked array");
-	}
-
-	const T& at(std::size_t index) const
-	{
-		return (index ^ M) < N ? m_data[index ^ M] : throw std::out_of_range("Masked array");
-	}
-};
-
 union v128
 {
+	template<typename T, std::size_t N, std::size_t M> class masked_array_t // array type accessed as (index ^ M)
+	{
+		T m_data[N];
+
+	public:
+		T& operator [](std::size_t index)
+		{
+			return m_data[index ^ M];
+		}
+
+		const T& operator [](std::size_t index) const
+		{
+			return m_data[index ^ M];
+		}
+
+		T& at(std::size_t index)
+		{
+			return (index ^ M) < N ? m_data[index ^ M] : throw std::out_of_range(__FUNCTION__);
+		}
+
+		const T& at(std::size_t index) const
+		{
+			return (index ^ M) < N ? m_data[index ^ M] : throw std::out_of_range(__FUNCTION__);
+		}
+	};
+
 #ifdef IS_LE_MACHINE
 	template<typename T, std::size_t N = 16 / sizeof(T)> using normal_array_t = masked_array_t<T, N, 0>;
 	template<typename T, std::size_t N = 16 / sizeof(T)> using reversed_array_t = masked_array_t<T, N, N - 1>;
@@ -90,12 +90,12 @@ union v128
 			{
 			}
 
-			inline operator bool() const
+			operator bool() const
 			{
 				return (data & mask) != 0;
 			}
 
-			inline bit_element& operator =(const bool right)
+			bit_element& operator =(const bool right)
 			{
 				if (right)
 				{
@@ -108,7 +108,7 @@ union v128
 				return *this;
 			}
 
-			inline bit_element& operator =(const bit_element& right)
+			bit_element& operator =(const bit_element& right)
 			{
 				if (right)
 				{
@@ -144,14 +144,14 @@ union v128
 
 		bit_element at(u32 index)
 		{
-			if (index >= 128) throw std::out_of_range("Bit element");
+			if (index >= 128) throw std::out_of_range(__FUNCTION__);
 
 			return operator[](index);
 		}
 
 		bool at(u32 index) const
 		{
-			if (index >= 128) throw std::out_of_range("Bit element");
+			if (index >= 128) throw std::out_of_range(__FUNCTION__);
 
 			return operator[](index);
 		}
@@ -320,12 +320,12 @@ union v128
 		return _u64[0] != right._u64[0] || _u64[1] != right._u64[1];
 	}
 
-	inline bool is_any_1() const // check if any bit is 1
+	bool is_any_1() const // check if any bit is 1
 	{
 		return _u64[0] || _u64[1];
 	}
 
-	inline bool is_any_0() const // check if any bit is 0
+	bool is_any_0() const // check if any bit is 0
 	{
 		return ~_u64[0] || ~_u64[1];
 	}
@@ -383,19 +383,28 @@ template<typename T> struct se_storage<T, 2>
 {
 	using type = u16;
 
-	[[deprecated]] static constexpr u16 swap(u16 src) // for reference
+	[[deprecated]] static constexpr u16 _swap(u16 src) // for reference
 	{
 		return (src >> 8) | (src << 8);
 	}
 
+	static inline u16 swap(u16 src)
+	{
+#if defined(__GNUG__)
+		return __builtin_bswap16(src);
+#else
+		return _byteswap_ushort(src);
+#endif
+	}
+
 	static inline u16 to(const T& src)
 	{
-		return _byteswap_ushort(reinterpret_cast<const u16&>(src));
+		return swap(reinterpret_cast<const u16&>(src));
 	}
 
 	static inline T from(u16 src)
 	{
-		const u16 result = _byteswap_ushort(src);
+		const u16 result = swap(src);
 		return reinterpret_cast<const T&>(result);
 	}
 };
@@ -404,19 +413,28 @@ template<typename T> struct se_storage<T, 4>
 {
 	using type = u32;
 
-	[[deprecated]] static constexpr u32 swap(u32 src) // for reference
+	[[deprecated]] static constexpr u32 _swap(u32 src) // for reference
 	{
 		return (src >> 24) | (src << 24) | ((src >> 8) & 0x0000ff00) | ((src << 8) & 0x00ff0000);
 	}
 
+	static inline u32 swap(u32 src)
+	{
+#if defined(__GNUG__)
+		return __builtin_bswap32(src);
+#else
+		return _byteswap_ulong(src);
+#endif
+	}
+
 	static inline u32 to(const T& src)
 	{
-		return _byteswap_ulong(reinterpret_cast<const u32&>(src));
+		return swap(reinterpret_cast<const u32&>(src));
 	}
 
 	static inline T from(u32 src)
 	{
-		const u32 result = _byteswap_ulong(src);
+		const u32 result = swap(src);
 		return reinterpret_cast<const T&>(result);
 	}
 };
@@ -425,7 +443,7 @@ template<typename T> struct se_storage<T, 8>
 {
 	using type = u64;
 
-	[[deprecated]] static constexpr u64 swap(u64 src) // for reference
+	[[deprecated]] static constexpr u64 _swap(u64 src) // for reference
 	{
 		return (src >> 56) | (src << 56) |
 			((src >> 40) & 0x000000000000ff00) |
@@ -436,14 +454,23 @@ template<typename T> struct se_storage<T, 8>
 			((src << 40) & 0x00ff000000000000);
 	}
 
+	static inline u64 swap(u64 src)
+	{
+#if defined(__GNUG__)
+		return __builtin_bswap64(src);
+#else
+		return _byteswap_uint64(src);
+#endif
+	}
+
 	static inline u64 to(const T& src)
 	{
-		return _byteswap_uint64(reinterpret_cast<const u64&>(src));
+		return swap(reinterpret_cast<const u64&>(src));
 	}
 
 	static inline T from(u64 src)
 	{
-		const u64 result = _byteswap_uint64(src);
+		const u64 result = swap(src);
 		return reinterpret_cast<const T&>(result);
 	}
 };
@@ -486,14 +513,14 @@ template<typename T1, typename T2> struct se_convert
 	}
 };
 
-static struct se_raw_tag_t {} const se_raw{};
+static struct se_raw_tag_t {} constexpr se_raw{};
 
 template<typename T, bool Se = true> class se_t;
 
 // se_t with switched endianness
 template<typename T> class se_t<T, true>
 {
-	using type = std::remove_cv_t<T>;
+	using type = typename std::remove_cv<T>::type;
 	using stype = se_storage_t<type>;
 	using storage = se_storage<type>;
 
@@ -506,7 +533,7 @@ template<typename T> class se_t<T, true>
 	static_assert(!std::is_enum<type>::value, "se_t<> error: invalid type (enumeration), use integral type instead");
 	static_assert(alignof(type) == alignof(stype), "se_t<> error: unexpected alignment");
 
-	template<typename T2, bool = std::is_integral<T2>::value> struct bool_converter
+	template<typename T2, typename = void> struct bool_converter
 	{
 		static inline bool to_bool(const se_t<T2>& value)
 		{
@@ -514,7 +541,7 @@ template<typename T> class se_t<T, true>
 		}
 	};
 
-	template<typename T2> struct bool_converter<T2, true>
+	template<typename T2> struct bool_converter<T2, std::enable_if_t<std::is_integral<T2>::value>>
 	{
 		static inline bool to_bool(const se_t<T2>& value)
 		{
@@ -527,78 +554,78 @@ public:
 
 	se_t(const se_t& right) = default;
 
-	inline se_t(type value)
+	se_t(type value)
 		: m_data(storage::to(value))
 	{
 	}
 	
 	// construct directly from raw data (don't use)
-	inline se_t(const stype& raw_value, const se_raw_tag_t&)
+	constexpr se_t(const stype& raw_value, const se_raw_tag_t&)
 		: m_data(raw_value)
 	{
 	}
 
-	inline type value() const
+	type value() const
 	{
 		return storage::from(m_data);
 	}
 
 	// access underlying raw data (don't use)
-	inline const stype& raw_data() const noexcept
+	constexpr const stype& raw_data() const noexcept
 	{
 		return m_data;
 	}
 	
 	se_t& operator =(const se_t&) = default;
 
-	inline se_t& operator =(type value)
+	se_t& operator =(type value)
 	{
 		return m_data = storage::to(value), *this;
 	}
 
-	inline operator type() const
+	operator type() const
 	{
 		return storage::from(m_data);
 	}
 
 	// optimization
-	explicit inline operator bool() const
+	explicit operator bool() const
 	{
 		return bool_converter<type>::to_bool(*this);
 	}
 
 	// optimization
-	template<typename T2> inline std::enable_if_t<IS_BINARY_COMPARABLE(T, T2), se_t&> operator &=(const se_t<T2>& right)
+	template<typename T2> std::enable_if_t<IS_BINARY_COMPARABLE(T, T2), se_t&> operator &=(const se_t<T2>& right)
 	{
 		return m_data &= right.raw_data(), *this;
 	}
 
 	// optimization
-	template<typename CT> inline std::enable_if_t<IS_INTEGRAL(T) && std::is_convertible<CT, T>::value, se_t&> operator &=(CT right)
+	template<typename CT> std::enable_if_t<IS_INTEGRAL(T) && std::is_convertible<CT, T>::value, se_t&> operator &=(CT right)
 	{
 		return m_data &= storage::to(right), *this;
 	}
 
 	// optimization
-	template<typename T2> inline std::enable_if_t<IS_BINARY_COMPARABLE(T, T2), se_t&> operator |=(const se_t<T2>& right)
+	template<typename T2> std::enable_if_t<IS_BINARY_COMPARABLE(T, T2), se_t&> operator |=(const se_t<T2>& right)
 	{
 		return m_data |= right.raw_data(), *this;
 	}
 
 	// optimization
-	template<typename CT> inline std::enable_if_t<IS_INTEGRAL(T) && std::is_convertible<CT, T>::value, se_t&> operator |=(CT right)
+	template<typename CT> std::enable_if_t<IS_INTEGRAL(T) && std::is_convertible<CT, T>::value, se_t&> operator |=(CT right)
 	{
 		return m_data |= storage::to(right), *this;
 	}
 
 	// optimization
-	template<typename T2> inline std::enable_if_t<IS_BINARY_COMPARABLE(T, T2), se_t&> operator ^=(const se_t<T2>& right)
+	template<typename T2> std::enable_if_t<IS_BINARY_COMPARABLE(T, T2), se_t&> operator ^=(const se_t<T2>& right)
 	{
 		return m_data ^= right.raw_data(), *this;
 	}
 
 	// optimization
-	template<typename CT> inline std::enable_if_t<IS_INTEGRAL(T) && std::is_convertible<CT, T>::value, se_t&> operator ^=(CT right)
+	template<typename CT> std::enable_if_t<IS_INTEGRAL(T) && std::is_convertible<CT, T>::value, se_t&> operator ^=(CT right)
 	{
 		return m_data ^= storage::to(right), *this;
 	}
@@ -607,7 +634,7 @@ public:
 // se_t with native endianness
 template<typename T> class se_t<T, false>
 {
-	using type = std::remove_cv_t<T>;
+	using type = typename std::remove_cv<T>::type;
 
 	type m_data;
 
@@ -622,39 +649,39 @@ public:
 
 	se_t(const se_t&) = default;
 
-	inline se_t(type value)
+	constexpr se_t(type value)
 		: m_data(value)
 	{
 	}
 
-	inline type value() const
+	type value() const
 	{
 		return m_data;
 	}
 
 	se_t& operator =(const se_t& value) = default;
 
-	inline se_t& operator =(type value)
+	se_t& operator =(type value)
 	{
 		return m_data = value, *this;
 	}
 
-	inline operator type() const
+	operator type() const
 	{
 		return m_data;
 	}
 
-	template<typename CT> inline std::enable_if_t<IS_INTEGRAL(T) && std::is_convertible<CT, T>::value, se_t&> operator &=(const CT& right)
+	template<typename CT> std::enable_if_t<IS_INTEGRAL(T) && std::is_convertible<CT, T>::value, se_t&> operator &=(const CT& right)
 	{
 		return m_data &= right, *this;
 	}
 
-	template<typename CT> inline std::enable_if_t<IS_INTEGRAL(T) && std::is_convertible<CT, T>::value, se_t&> operator |=(const CT& right)
+	template<typename CT> std::enable_if_t<IS_INTEGRAL(T) && std::is_convertible<CT, T>::value, se_t&> operator |=(const CT& right)
 	{
 		return m_data |= right, *this;
 	}
 
-	template<typename CT> inline std::enable_if_t<IS_INTEGRAL(T) && std::is_convertible<CT, T>::value, se_t&> operator ^=(const CT& right)
+	template<typename CT> std::enable_if_t<IS_INTEGRAL(T) && std::is_convertible<CT, T>::value, se_t&> operator ^=(const CT& right)
 	{
 		return m_data ^= right, *this;
 	}
@@ -837,107 +864,77 @@ template<typename T> using be_t = se_t<T, false>;
 template<typename T> using le_t = se_t<T, true>;
 #endif
 
-template<typename T> struct is_be_t : public std::integral_constant<bool, false>
+
+template<typename T, bool Se, typename = void> struct to_se
 {
+	using type = typename std::conditional<std::is_arithmetic<T>::value || std::is_enum<T>::value, se_t<T, Se>, T>::type;
 };
 
-template<typename T> struct is_be_t<be_t<T>> : public std::integral_constant<bool, true>
+template<typename T, bool Se> struct to_se<const T, Se, std::enable_if_t<!std::is_array<T>::value>> // move const qualifier
 {
+	using type = const typename to_se<T, Se>::type;
 };
 
-template<typename T> struct is_be_t<const T> : public std::integral_constant<bool, is_be_t<T>::value>
+template<typename T, bool Se> struct to_se<volatile T, Se, std::enable_if_t<!std::is_array<T>::value && !std::is_const<T>::value>> // move volatile qualifier
 {
+	using type = volatile typename to_se<T, Se>::type;
 };
 
-template<typename T> struct is_be_t<volatile T> : public std::integral_constant<bool, is_be_t<T>::value>
+template<typename T, bool Se> struct to_se<T[], Se>
 {
+	using type = typename to_se<T, Se>::type[];
 };
 
-// to_be_t helper struct
-template<typename T> struct to_be
+template<typename T, bool Se, std::size_t N> struct to_se<T[N], Se>
 {
-	using type = std::conditional_t<std::is_arithmetic<T>::value || std::is_enum<T>::value || std::is_same<T, v128>::value || std::is_same<T, u128>::value, be_t<T>, T>;
+	using type = typename to_se<T, Se>::type[N];
 };
 
-// be_t<T> if possible, T otherwise
-template<typename T> using to_be_t = typename to_be<T>::type;
+template<bool Se> struct to_se<u128, Se> { using type = se_t<u128, Se>; };
+template<bool Se> struct to_se<v128, Se> { using type = se_t<v128, Se>; };
+template<bool Se> struct to_se<bool, Se> { using type = bool; };
+template<bool Se> struct to_se<char, Se> { using type = char; };
+template<bool Se> struct to_se<u8, Se>   { using type = u8; };
+template<bool Se> struct to_se<s8, Se>   { using type = s8; };
 
-template<typename T> struct to_be<const T> // move const qualifier
-{
-	using type = const to_be_t<T>;
-};
+#ifdef IS_LE_MACHINE
+template<typename T> using to_be_t = typename to_se<T, true>::type;
+template<typename T> using to_le_t = typename to_se<T, false>::type;
+#else
+template<typename T> using to_be_t = typename to_se<T, false>::type;
+template<typename T> using to_le_t = typename to_se<T, true>::type;
+#endif
 
-template<typename T> struct to_be<volatile T> // move volatile qualifier
-{
-	using type = volatile to_be_t<T>;
-};
 
-template<> struct to_be<void> { using type = void; };
-template<> struct to_be<bool> { using type = bool; };
-template<> struct to_be<char> { using type = char; };
-template<> struct to_be<u8> { using type = u8; };
-template<> struct to_be<s8> { using type = s8; };
-
-template<typename T> struct is_le_t : public std::integral_constant<bool, false>
-{
-};
-
-template<typename T> struct is_le_t<le_t<T>> : public std::integral_constant<bool, true>
-{
-};
-
-template<typename T> struct is_le_t<const T> : public std::integral_constant<bool, is_le_t<T>::value>
-{
-};
-
-template<typename T> struct is_le_t<volatile T> : public std::integral_constant<bool, is_le_t<T>::value>
-{
-};
-
-template<typename T> struct to_le
-{
-	using type = std::conditional_t<std::is_arithmetic<T>::value || std::is_enum<T>::value || std::is_same<T, v128>::value || std::is_same<T, u128>::value, le_t<T>, T>;
-};
-
-// le_t<T> if possible, T otherwise
-template<typename T> using to_le_t = typename to_le<T>::type;
-
-template<typename T> struct to_le<const T> // move const qualifier
-{
-	using type = const to_le_t<T>;
-};
-
-template<typename T> struct to_le<volatile T> // move volatile qualifier
-{
-	using type = volatile to_le_t<T>;
-};
-
-template<> struct to_le<void> { using type = void; };
-template<> struct to_le<bool> { using type = bool; };
-template<> struct to_le<char> { using type = char; };
-template<> struct to_le<u8> { using type = u8; };
-template<> struct to_le<s8> { using type = s8; };
-
-// to_ne_t helper struct
-template<typename T> struct to_ne
+template<typename T, typename = void> struct to_ne
 {
 	using type = T;
 };
 
 template<typename T, bool Se> struct to_ne<se_t<T, Se>>
 {
-	using type = T;
+	using type = typename std::remove_cv<T>::type;
+};
+
+template<typename T> struct to_ne<const T, std::enable_if_t<!std::is_array<T>::value>> // move const qualifier
+{
+	using type = const typename to_ne<T>::type;
+};
+
+template<typename T> struct to_ne<volatile T, std::enable_if_t<!std::is_array<T>::value && !std::is_const<T>::value>> // move volatile qualifier
+{
+	using type = volatile typename to_ne<T>::type;
+};
+
+template<typename T> struct to_ne<T[]>
+{
+	using type = typename to_ne<T>::type[];
+};
+
+template<typename T, std::size_t N> struct to_ne<T[N]>
+{
+	using type = typename to_ne<T>::type[N];
 };
 
 // restore native endianness for T: returns T for be_t<T> or le_t<T>, T otherwise
 template<typename T> using to_ne_t = typename to_ne<T>::type;
-
-template<typename T> struct to_ne<const T> // move const qualifier
-{
-	using type = const to_ne_t<T>;
-};
-
-template<typename T> struct to_ne<volatile T> // move volatile qualifier
-{
-	using type = volatile to_ne_t<T>;
-};

Utilities/BitField.h

@@ -0,0 +1,140 @@
+#pragma once
+
+// BitField access helper class (N bits from I position), intended to be put in union
+template<typename T, u32 I, u32 N> class bf_t
+{
+	// Checks
+	static_assert(I < sizeof(T) * 8, "bf_t<> error: I out of bounds");
+	static_assert(N < sizeof(T) * 8, "bf_t<> error: N out of bounds");
+	static_assert(I + N <= sizeof(T) * 8, "bf_t<> error: values out of bounds");
+
+	// Underlying data type
+	using type = typename std::remove_cv<T>::type;
+
+	// Underlying value type (native endianness)
+	using vtype = typename to_ne<type>::type;
+
+	// Mask of size N
+	constexpr static vtype s_mask = (static_cast<vtype>(1) << N) - 1;
+
+	// Underlying data member
+	type m_data;
+
+	// Conversion operator helper (uses SFINAE)
+	template<typename T2, typename = void> struct converter {};
+
+	template<typename T2> struct converter<T2, std::enable_if_t<std::is_unsigned<T2>::value>>
+	{
+		// Load unsigned value
+		static inline T2 convert(const type& data)
+		{
+			return (data >> I) & s_mask;
+		}
+	};
+
+	template<typename T2> struct converter<T2, std::enable_if_t<std::is_signed<T2>::value>>
+	{
+		// Load signed value (sign-extended)
+		static inline T2 convert(const type& data)
+		{
+			return data << (sizeof(T) * 8 - I - N) >> (sizeof(T) * 8 - N);
+		}
+	};
+
+public:
+	// Assignment operator (store bitfield value)
+	bf_t& operator =(vtype value)
+	{
+		m_data = (m_data & ~(s_mask << I)) | (value & s_mask) << I;
+		return *this;
+	}
+
+	// Conversion operator (load bitfield value)
+	operator vtype() const
+	{
+		return converter<vtype>::convert(m_data);
+	}
+
+	// Get raw data with mask applied
+	type unshifted() const
+	{
+		return (m_data & (s_mask << I));
+	}
+
+	// Optimized bool conversion
+	explicit operator bool() const
+	{
+		return unshifted() != 0;
+	}
+
+	// Postfix increment operator
+	vtype operator ++(int)
+	{
+		vtype result = *this;
+		*this = result + 1;
+		return result;
+	}
+
+	// Prefix increment operator
+	bf_t& operator ++()
+	{
+		return *this = *this + 1;
+	}
+
+	// Postfix decrement operator
+	vtype operator --(int)
+	{
+		vtype result = *this;
+		*this = result - 1;
+		return result;
+	}
+
+	// Prefix decrement operator
+	bf_t& operator --()
+	{
+		return *this = *this - 1;
+	}
+
+	// Addition assignment operator
+	bf_t& operator +=(vtype right)
+	{
+		return *this = *this + right;
+	}
+
+	// Subtraction assignment operator
+	bf_t& operator -=(vtype right)
+	{
+		return *this = *this - right;
+	}
+
+	// Multiplication assignment operator
+	bf_t& operator *=(vtype right)
+	{
+		return *this = *this * right;
+	}
+
+	// Bitwise AND assignment operator
+	bf_t& operator &=(vtype right)
+	{
+		m_data &= (right & s_mask) << I;
+		return *this;
+	}
+
+	// Bitwise OR assignment operator
+	bf_t& operator |=(vtype right)
+	{
+		m_data |= (right & s_mask) << I;
+		return *this;
+	}
+
+	// Bitwise XOR assignment operator
+	bf_t& operator ^=(vtype right)
+	{
+		m_data ^= (right & s_mask) << I;
+		return *this;
+	}
+};
+
+template<typename T, u32 I, u32 N> using bf_be_t = bf_t<be_t<T>, I, N>;
+
+template<typename T, u32 I, u32 N> using bf_le_t = bf_t<le_t<T>, I, N>;

Utilities/File.cpp

@@ -3,13 +3,13 @@
 #include "File.h"
 
 #ifdef _WIN32
+#define _WIN32_WINNT 0x0601
 #include <Windows.h>
+#include <Shlwapi.h>
 
 #define GET_API_ERROR static_cast<u64>(GetLastError())
 
-static_assert(fs::file::null == intptr_t(INVALID_HANDLE_VALUE) && fs::dir::null == fs::file::null, "Check fs::file::null definition");
-
-std::unique_ptr<wchar_t[]> to_wchar(const std::string& source)
+static std::unique_ptr<wchar_t[]> to_wchar(const std::string& source)
 {
 	const auto length = source.size() + 1; // size + null terminator
 
@@ -25,7 +25,7 @@ std::unique_ptr<wchar_t[]> to_wchar(const std::string& source)
 	return buffer;
 }
 
-void to_utf8(std::string& result, const wchar_t* source)
+static void to_utf8(std::string& result, const wchar_t* source)
 {
 	const int length = lstrlenW(source); // source length
 
@@ -49,30 +49,30 @@ void to_utf8(std::string& result, const wchar_t* source)
 	}
 }
 
-time_t to_time_t(const ULARGE_INTEGER& ft)
+static time_t to_time(const ULARGE_INTEGER& ft)
 {
 	return ft.QuadPart / 10000000ULL - 11644473600ULL;
 }
 
-time_t to_time_t(const LARGE_INTEGER& ft)
+static time_t to_time(const LARGE_INTEGER& ft)
 {
 	ULARGE_INTEGER v;
 	v.LowPart = ft.LowPart;
 	v.HighPart = ft.HighPart;
 
-	return to_time_t(v);
+	return to_time(v);
 }
 
-time_t to_time_t(const FILETIME& ft)
+static time_t to_time(const FILETIME& ft)
 {
 	ULARGE_INTEGER v;
 	v.LowPart = ft.dwLowDateTime;
 	v.HighPart = ft.dwHighDateTime;
 
-	return to_time_t(v);
+	return to_time(v);
 }
 
-bool truncate_file(const std::string& file, u64 length)
+static bool truncate_file(const std::string& file, u64 length)
 {
 	// open the file
 	const auto handle = CreateFileW(to_wchar(file).get(), GENERIC_WRITE, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
@@ -98,17 +98,21 @@ bool truncate_file(const std::string& file, u64 length)
 }
 
 #else
+#include <sys/mman.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <dirent.h>
 #include <fcntl.h>
+#include <libgen.h>
+#include <string.h>
 #include <unistd.h>
 #if defined(__APPLE__) || defined(__FreeBSD__)
 #include <copyfile.h>
+#include <mach-o/dyld.h>
 #else
 #include <sys/sendfile.h>
 #endif
-#include "errno.h"
+#include <errno.h>
 
 #define GET_API_ERROR static_cast<u64>(errno)
 
@@ -130,9 +134,9 @@ bool fs::stat(const std::string& path, stat_t& info)
 	info.is_directory = (attrs.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0;
 	info.is_writable = (attrs.dwFileAttributes & FILE_ATTRIBUTE_READONLY) == 0;
 	info.size = (u64)attrs.nFileSizeLow | ((u64)attrs.nFileSizeHigh << 32);
-	info.atime = to_time_t(attrs.ftLastAccessTime);
-	info.mtime = to_time_t(attrs.ftLastWriteTime);
-	info.ctime = to_time_t(attrs.ftCreationTime);
+	info.atime = to_time(attrs.ftLastAccessTime);
+	info.mtime = to_time(attrs.ftLastWriteTime);
+	info.ctime = to_time(attrs.ftCreationTime);
 #else
 	struct stat file_info;
 	if (stat(path.c_str(), &file_info) < 0)
@@ -216,7 +220,7 @@ bool fs::create_dir(const std::string& dir)
 #ifdef _WIN32
 	if (!CreateDirectoryW(to_wchar(dir).get(), NULL))
 #else
-	if (mkdir(dir.c_str(), 0777))
+	if (mkdir(dir.c_str(), S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH))
 #endif
 	{
 		LOG_WARNING(GENERAL, "Error creating directory '%s': 0x%llx", dir, GET_API_ERROR);
@@ -230,44 +234,24 @@ bool fs::create_path(const std::string& path)
 {
 	g_tls_error = fse::ok;
 
-	size_t start = 0;
-
-	while (true)
+	std::string parent;
 	{
-		// maybe it could be more optimal if goes from the end recursively
-		size_t pos = path.find_first_of("/\\", start);
-
-		if (pos == std::string::npos)
-		{
-			pos = path.length();
-		}
-
-		std::string dir = path.substr(0, pos);
-
-		start = ++pos;
-
-		if (dir.size() == 0)
-		{
-			continue;
-		}
-
-		if (!is_dir(dir))
-		{
-			// if doesn't exist or not a dir
-			if (!create_dir(dir))
-			{
-				// if creating failed
-				return false;
-			}
-		}
-
-		if (pos >= path.length())
-		{
-			break;
-		}
+#ifdef _WIN32
+		auto copy = to_wchar(path);
+		// PathRemoveFileSpecW only works on paths delimited by '\\'
+		std::replace(copy.get(), copy.get() + path.length(), '/', '\\');
+		PathRemoveFileSpecW(copy.get());
+		to_utf8(parent, copy.get());
+#else
+		std::unique_ptr<char, decltype(std::free) *> copy{ strdup(path.c_str()), std::free };
+		parent = dirname(copy.get());
+#endif
 	}
 
-	return true;
+	if (!is_dir(parent) && !create_path(parent))
+		return false;
+
+	return create_dir(path);
 }
 
 bool fs::remove_dir(const std::string& dir)
@@ -306,16 +290,18 @@ bool fs::rename(const std::string& from, const std::string& to)
 
 #ifndef _WIN32
 
-int OSCopyFile(const char* source, const char* destination, bool overwrite)
+static int OSCopyFile(const char* source, const char* destination, bool overwrite)
 {
-	/* This function was taken from http://stackoverflow.com/questions/2180079/how-can-i-copy-a-file-on-unix-using-c */
+	/* Source: http://stackoverflow.com/questions/2180079/how-can-i-copy-a-file-on-unix-using-c */
 
-	int input, output;
-	if ((input = open(source, O_RDONLY)) == -1)
+	const int input = open(source, O_RDONLY);
+	if (input == -1)
 	{
 		return -1;
 	}
-	if ((output = open(destination, O_WRONLY | O_CREAT | (overwrite ? O_TRUNC : O_EXCL), 0666)) == -1)
+
+	const int output = open(destination, O_WRONLY | O_CREAT | (overwrite ? O_TRUNC : O_EXCL), 0666);
+	if (output == -1)
 	{
 		close(input);
 		return -1;
@@ -324,13 +310,12 @@ int OSCopyFile(const char* source, const char* destination, bool overwrite)
 	//Here we use kernel-space copying for performance reasons
 #if defined(__APPLE__) || defined(__FreeBSD__)
 	//fcopyfile works on FreeBSD and OS X 10.5+ 
-	int result = fcopyfile(input, output, 0, COPYFILE_ALL);
+	const int result = fcopyfile(input, output, 0, COPYFILE_ALL);
 #else
 	//sendfile will work with non-socket output (i.e. regular file) on Linux 2.6.33+
 	off_t bytesCopied = 0;
 	struct stat fileinfo = { 0 };
-	fstat(input, &fileinfo);
-	int result = sendfile(output, input, &bytesCopied, fileinfo.st_size) == -1 ? -1 : 0;
+	const int result = fstat(input, &fileinfo) == -1 || sendfile(output, input, &bytesCopied, fileinfo.st_size) == -1 ? -1 : 0;
 #endif
 
 	close(input);
@@ -443,7 +428,7 @@ bool fs::file::open(const std::string& filename, u32 mode)
 		return false;
 	}
 
-	m_fd = (intptr_t)CreateFileW(to_wchar(filename).get(), access, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, NULL, disp, FILE_ATTRIBUTE_NORMAL, NULL);
+	m_fd = (std::intptr_t)CreateFileW(to_wchar(filename).get(), access, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, NULL, disp, FILE_ATTRIBUTE_NORMAL, NULL);
 #else
 	int flags = 0;
 
@@ -520,9 +505,9 @@ bool fs::file::stat(stat_t& info) const
 	info.is_directory = (basic_info.FileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0;
 	info.is_writable = (basic_info.FileAttributes & FILE_ATTRIBUTE_READONLY) == 0;
 	info.size = this->size();
-	info.atime = to_time_t(basic_info.LastAccessTime);
-	info.mtime = to_time_t(basic_info.ChangeTime);
-	info.ctime = to_time_t(basic_info.CreationTime);
+	info.atime = to_time(basic_info.LastAccessTime);
+	info.mtime = to_time(basic_info.ChangeTime);
+	info.ctime = to_time(basic_info.CreationTime);
 #else
 	struct stat file_info;
 	if (fstat(m_fd, &file_info) < 0)
@@ -564,6 +549,7 @@ u64 fs::file::read(void* buffer, u64 count) const
 {
 	g_tls_error = fse::ok;
 
+	// TODO (call ReadFile multiple times if count is too big)
 	const int size = count <= INT_MAX ? static_cast<int>(count) : throw EXCEPTION("Invalid count (0x%llx)", count);
 
 #ifdef _WIN32
@@ -583,6 +569,7 @@ u64 fs::file::write(const void* buffer, u64 count) const
 {
 	g_tls_error = fse::ok;
 
+	// TODO (call WriteFile multiple times if count is too big)
 	const int size = count <= INT_MAX ? static_cast<int>(count) : throw EXCEPTION("Invalid count (0x%llx)", count);
 
 #ifdef _WIN32
@@ -654,66 +641,64 @@ u64 fs::file::size() const
 
 fs::dir::~dir()
 {
-	if (m_dd != null)
+	if (m_path)
 	{
 #ifdef _WIN32
-		FindClose((HANDLE)m_dd);
+		if (m_dd != -1) FindClose((HANDLE)m_dd);
 #else
 		::closedir((DIR*)m_dd);
 #endif
 	}
 }
 
-void fs::dir::import(handle_type dd, const std::string& path)
+void fs::file_ptr::reset(const file& f)
 {
-	if (m_dd != null)
+	reset();
+
+	if (f)
 	{
 #ifdef _WIN32
-		FindClose((HANDLE)m_dd);
+		const HANDLE handle = ::CreateFileMapping((HANDLE)f.m_fd, NULL, PAGE_READONLY, 0, 0, NULL);
+		m_ptr = (char*)::MapViewOfFile(handle, FILE_MAP_READ, 0, 0, 0);
+		m_size = f.size();
+		::CloseHandle(handle);
 #else
-		::closedir((DIR*)m_dd);
+		m_ptr = (char*)::mmap(nullptr, m_size = f.size(), PROT_READ, MAP_SHARED, f.m_fd, 0);
+		if (m_ptr == (void*)-1) m_ptr = nullptr;
 #endif
 	}
+}
 
-	g_tls_error = fse::ok;
-
-	m_dd = dd;
-
+void fs::file_ptr::reset()
+{
+	if (m_ptr)
+	{
 #ifdef _WIN32
-	m_path = to_wchar(path);
+		::UnmapViewOfFile(m_ptr);
 #else
-	m_path.reset(new char[path.size() + 1]);
-	memcpy(m_path.get(), path.c_str(), path.size() + 1);
+		::munmap(m_ptr, m_size);
 #endif
+	}
 }
 
 bool fs::dir::open(const std::string& dirname)
 {
-	if (m_dd != null)
-	{
-#ifdef _WIN32
-		FindClose((HANDLE)m_dd);
-#else
-		::closedir((DIR*)m_dd);
-#endif
-	}
+	this->close();
 
 	g_tls_error = fse::ok;
 
-	m_dd = null;
-
-	m_path.reset();
-
 	if (!is_dir(dirname))
 	{
 		return false;
 	}
 
-#ifdef _WIN32
-	m_path = to_wchar(dirname + "/*");
-#else
 	m_path.reset(new char[dirname.size() + 1]);
-	memcpy(m_path.get(), dirname.c_str(), dirname.size() + 1);
+	std::memcpy(m_path.get(), dirname.c_str(), dirname.size() + 1);
+
+#ifdef _WIN32
+	m_dd = -1;
+#else
+	m_dd = (std::intptr_t)::opendir(m_path.get());
 #endif
 
 	return true;
@@ -723,46 +708,26 @@ bool fs::dir::close()
 {
 	g_tls_error = fse::ok;
 
-	if (m_dd == null)
+	if (!m_path)
 	{
-		if (m_path)
-		{
-			m_path.reset();
-			return true;
-		}
-		else
-		{
-			return false;
-		}
+		return false;
 	}
 
-	auto dd = m_dd;
-	m_dd = null;
-
 	m_path.reset();
 
 #ifdef _WIN32
-	return FindClose((HANDLE)dd);
+	CHECK_ASSERTION(m_dd == -1 || FindClose((HANDLE)m_dd));
 #else
-	return !::closedir((DIR*)dd);
+	CHECK_ASSERTION(!::closedir((DIR*)m_dd));
 #endif
+
+	return true;
 }
 
-bool fs::dir::get_first(std::string& name, stat_t& info)
+bool fs::dir::read(std::string& name, stat_t& info)
 {
-	if (m_dd != null) // close previous handle
-	{
-#ifdef _WIN32
-		FindClose((HANDLE)m_dd);
-#else
-		::closedir((DIR*)m_dd);
-#endif
-	}
-
 	g_tls_error = fse::ok;
 
-	m_dd = null;
-
 	if (!m_path)
 	{
 		return false;
@@ -771,9 +736,16 @@ bool fs::dir::get_first(std::string& name, stat_t& info)
 #ifdef _WIN32
 	WIN32_FIND_DATAW found;
 
-	m_dd = (intptr_t)FindFirstFileW(m_path.get(), &found);
+	if (m_dd == -1)
+	{
+		m_dd = (std::intptr_t)FindFirstFileW(to_wchar(m_path.get() + "/*"s).get(), &found);
 
-	if (m_dd == null)
+		if (m_dd == -1)
+		{
+			return false;
+		}
+	}
+	else if (!FindNextFileW((HANDLE)m_dd, &found))
 	{
 		return false;
 	}
@@ -783,43 +755,9 @@ bool fs::dir::get_first(std::string& name, stat_t& info)
 	info.is_directory = (found.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0;
 	info.is_writable = (found.dwFileAttributes & FILE_ATTRIBUTE_READONLY) == 0;
 	info.size = ((u64)found.nFileSizeHigh << 32) | (u64)found.nFileSizeLow;
-	info.atime = to_time_t(found.ftLastAccessTime);
-	info.mtime = to_time_t(found.ftLastWriteTime);
-	info.ctime = to_time_t(found.ftCreationTime);
-
-	return true;
-#else
-	m_dd = (intptr_t)::opendir(m_path.get());
-
-	return get_next(name, info);
-#endif
-}
-
-bool fs::dir::get_next(std::string& name, stat_t& info)
-{
-	g_tls_error = fse::ok;
-
-	if (m_dd == null)
-	{
-		return false;
-	}
-
-#ifdef _WIN32
-	WIN32_FIND_DATAW found;
-
-	if (!FindNextFileW((HANDLE)m_dd, &found))
-	{
-		return false;
-	}
-
-	to_utf8(name, found.cFileName);
-
-	info.is_directory = (found.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0;
-	info.is_writable = (found.dwFileAttributes & FILE_ATTRIBUTE_READONLY) == 0;
-	info.size = ((u64)found.nFileSizeHigh << 32) | (u64)found.nFileSizeLow;
-	info.atime = to_time_t(found.ftLastAccessTime);
-	info.mtime = to_time_t(found.ftLastWriteTime);
-	info.ctime = to_time_t(found.ftCreationTime);
+	info.atime = to_time(found.ftLastAccessTime);
+	info.mtime = to_time(found.ftLastWriteTime);
+	info.ctime = to_time(found.ftCreationTime);
 #else
 	const auto found = ::readdir((DIR*)m_dd);
 
@@ -841,3 +779,105 @@ bool fs::dir::get_next(std::string& name, stat_t& info)
 
 	return true;
 }
+
+bool fs::dir::first(std::string& name, stat_t& info)
+{
+#ifdef _WIN32
+	if (m_path && m_dd != -1)
+	{
+		CHECK_ASSERTION(FindClose((HANDLE)m_dd));
+		m_dd = -1;
+	}
+#else
+	if (m_path)
+	{
+		::rewinddir((DIR*)m_dd);
+	}
+#endif
+
+	return read(name, info);
+}
+
+std::string fs::get_config_dir()
+{
+	// Use magic static for dir initialization
+	static const std::string s_dir = []
+	{
+#ifdef _WIN32
+		return get_executable_dir(); // ?
+#else
+		std::string dir;
+
+		if (const char* home = ::getenv("XDG_CONFIG_HOME"))
+			dir = home;
+		else if (const char* home = ::getenv("HOME"))
+			dir = home + "/.config"s;
+		else // Just in case
+			dir = "./config";
+
+		dir += "/rpcs3/";
+
+		if (!is_dir(dir) && !create_path(dir))
+		{
+			std::printf("Failed to create configuration directory '%s' (%d).\n", dir.c_str(), errno);
+		}
+
+		return dir;
+#endif
+	}();
+
+	return s_dir;
+}
+
+std::string fs::get_executable_dir()
+{
+	// Use magic static for dir initialization
+	static const std::string s_dir = []
+	{
+		std::string dir;
+
+#ifdef _WIN32
+		wchar_t buf[2048];
+		if (GetModuleFileName(NULL, buf, ::size32(buf)) - 1 >= ::size32(buf) - 1)
+		{
+			MessageBoxA(0, fmt::format("GetModuleFileName() failed (0x%x).", GetLastError()).c_str(), "fs::get_config_dir()", MB_ICONERROR);
+			return dir; // empty
+		}
+	
+		to_utf8(dir, buf); // Convert to UTF-8
+
+#elif __APPLE__
+		char buf[4096];
+		u32 size = sizeof(buf);
+		if (_NSGetExecutablePath(buf, &size))
+		{
+			std::printf("_NSGetExecutablePath() failed (size=0x%x).\n", size);
+			return dir; // empty
+		}
+
+		dir = buf;
+#else
+		char buf[4096];
+		const auto size = ::readlink("/proc/self/exe", buf, sizeof(buf));
+		if (size <= 0 || size >= sizeof(buf))
+		{
+			std::printf("readlink(/proc/self/exe) failed (%d).\n", errno);
+			return dir; // empty
+		}
+
+		dir = { buf, static_cast<std::size_t>(size) };
+#endif
+
+		// Replace "\"
+		for (auto& c : dir)
+		{
+			if (c == '\\') c = '/';
+		}
+
+		// Leave only path
+		dir.resize(dir.rfind('/') + 1);
+		return dir;
+	}();
+
+	return s_dir;
+}

Utilities/File.h

@@ -11,12 +11,14 @@ namespace fom // file open mode
 {
 	enum : u32
 	{
-		read = 1 << 0,
-		write = 1 << 1,
-		append = 1 << 2,
-		create = 1 << 3,
-		trunc = 1 << 4,
-		excl = 1 << 5,
+		read = 1 << 0, // enable reading
+		write = 1 << 1, // enable writing
+		append = 1 << 2, // enable appending (always write to the end of file)
+		create = 1 << 3, // create file if it doesn't exist
+		trunc = 1 << 4, // clear opened file if it's not empty
+		excl = 1 << 5, // failure if the file already exists (used with `create`)
+
+		rewrite = write | create | trunc, // write + create + trunc
 	};
 };
 
@@ -26,16 +28,6 @@ enum class fse : u32 // filesystem (file or dir) error
 	invalid_arguments,
 };
 
-enum : u32 // obsolete flags
-{
-	o_read = fom::read,
-	o_write = fom::write,
-	o_append = fom::append,
-	o_create = fom::create,
-	o_trunc = fom::trunc,
-	o_excl = fom::excl,
-};
-
 namespace fs
 {
 	thread_local extern fse g_tls_error;
@@ -50,94 +42,330 @@ namespace fs
 		s64 ctime;
 	};
 
+	// Get file information
 	bool stat(const std::string& path, stat_t& info);
+
+	// Check whether a file or a directory exists (not recommended, use is_file() or is_dir() instead)
 	bool exists(const std::string& path);
+
+	// Check whether the file exists and is NOT a directory
 	bool is_file(const std::string& file);
+
+	// Check whether the directory exists and is NOT a file
 	bool is_dir(const std::string& dir);
+
+	// Delete empty directory
 	bool remove_dir(const std::string& dir);
+
+	// Create directory
 	bool create_dir(const std::string& dir);
+
+	// Create directories
 	bool create_path(const std::string& path);
+
+	// Rename (move) file or directory
 	bool rename(const std::string& from, const std::string& to);
+
+	// Copy file contents
 	bool copy_file(const std::string& from, const std::string& to, bool overwrite);
+
+	// Delete file
 	bool remove_file(const std::string& file);
+
+	// Change file size (possibly appending zeros)
 	bool truncate_file(const std::string& file, u64 length);
 
-	struct file final
+	class file final
 	{
 		using handle_type = std::intptr_t;
 
-		static const handle_type null = -1;
+		constexpr static handle_type null = -1;
 
-	private:
 		handle_type m_fd = null;
 
+		friend class file_ptr;
+
 	public:
 		file() = default;
+
+		explicit file(const std::string& filename, u32 mode = fom::read)
+		{
+			open(filename, mode);
+		}
+
+		file(file&& other)
+			: m_fd(other.m_fd)
+		{
+			other.m_fd = null;
+		}
+
+		file& operator =(file&& right)
+		{
+			std::swap(m_fd, right.m_fd);
+			return *this;
+		}
+
 		~file();
-		explicit file(const std::string& filename, u32 mode = fom::read) { open(filename, mode); }
 
-		file(const file&) = delete;
-		file(file&&) = delete; // possibly TODO
+		// Check whether the handle is valid (opened file)
+		bool is_opened() const
+		{
+			return m_fd != null;
+		}
 
-		file& operator =(const file&) = delete;
-		file& operator =(file&&) = delete; // possibly TODO
-
-		operator bool() const { return m_fd != null; }
-
-		void import(handle_type fd) { this->~file(); m_fd = fd; }
+		// Check whether the handle is valid (opened file)
+		explicit operator bool() const
+		{
+			return is_opened();
+		}
 
+		// Open specified file with specified mode
 		bool open(const std::string& filename, u32 mode = fom::read);
-		bool is_opened() const { return m_fd != null; }
-		bool trunc(u64 size) const; // change file size (possibly appending zero bytes)
-		bool stat(stat_t& info) const; // get file info
+
+		// Change file size (possibly appending zero bytes)
+		bool trunc(u64 size) const;
+
+		// Get file information
+		bool stat(stat_t& info) const;
+
+		// Close the file explicitly (destructor automatically closes the file)
 		bool close();
 
+		// Read the data from the file and return the amount of data written in buffer
 		u64 read(void* buffer, u64 count) const;
+
+		// Write the data to the file and return the amount of data actually written
 		u64 write(const void* buffer, u64 count) const;
+
+		// Move file pointer
 		u64 seek(s64 offset, fsm seek_mode = fsm::begin) const;
+
+		// Get file size
 		u64 size() const;
+
+		// Write std::string
+		const file& operator <<(const std::string& str) const
+		{
+			CHECK_ASSERTION(write(str.data(), str.size()) == str.size());
+			return *this;
+		}
+
+		// Write POD
+		template<typename T>
+		std::enable_if_t<std::is_pod<T>::value && !std::is_pointer<T>::value, const file&> operator <<(const T& data) const
+		{
+			CHECK_ASSERTION(write(std::addressof(data), sizeof(T)) == sizeof(T));
+			return *this;
+		}
+
+		// Write POD std::vector
+		template<typename T>
+		std::enable_if_t<std::is_pod<T>::value && !std::is_pointer<T>::value, const file&> operator <<(const std::vector<T>& vec) const
+		{
+			CHECK_ASSERTION(write(vec.data(), vec.size() * sizeof(T)) == vec.size() * sizeof(T));
+			return *this;
+		}
+
+		// Read std::string
+		bool read(std::string& str) const
+		{
+			return read(&str[0], str.size()) == str.size();
+		}
+
+		// Read POD
+		template<typename T>
+		std::enable_if_t<std::is_pod<T>::value && !std::is_pointer<T>::value, bool> read(T& data) const
+		{
+			return read(&data, sizeof(T)) == sizeof(T);
+		}
+
+		// Read POD std::vector
+		template<typename T>
+		std::enable_if_t<std::is_pod<T>::value && !std::is_pointer<T>::value, bool> read(std::vector<T>& vec) const
+		{
+			return read(vec.data(), sizeof(T) * vec.size()) == sizeof(T) * vec.size();
+		}
+
+		// Convert to std::string
+		operator std::string() const
+		{
+			std::string result;
+			result.resize(size() - seek(0, fsm::cur));
+			CHECK_ASSERTION(read(result));
+			return result;
+		}
 	};
 
-	struct dir final
+	class file_ptr final
 	{
-#ifdef _WIN32
-		using handle_type = intptr_t;
-		using name_type = std::unique_ptr<wchar_t[]>;
+		char* m_ptr = nullptr;
+		u64 m_size;
 
-		static const handle_type null = -1;
-#else
-		using handle_type = intptr_t;
-		using name_type = std::unique_ptr<char[]>;
+	public:
+		file_ptr() = default;
 
-		static const handle_type null = 0;
-#endif
+		file_ptr(file_ptr&& right)
+			: m_ptr(right.m_ptr)
+			, m_size(right.m_size)
+		{
+			right.m_ptr = 0;
+		}
 
-	private:
-		handle_type m_dd = null;
-		name_type m_path;
+		file_ptr& operator =(file_ptr&& right)
+		{
+			std::swap(m_ptr, right.m_ptr);
+			std::swap(m_size, right.m_size);
+			return *this;
+		}
+
+		file_ptr(const file& f)
+		{
+			reset(f);
+		}
+
+		~file_ptr()
+		{
+			reset();
+		}
+
+		// Open file mapping
+		void reset(const file& f);
+		
+		// Close file mapping
+		void reset();
+
+		// Get pointer
+		operator char*() const
+		{
+			return m_ptr;
+		}
+	};
+
+	class dir final
+	{
+		std::unique_ptr<char[]> m_path;
+		std::intptr_t m_dd; // handle (aux)
 
 	public:
 		dir() = default;
+
+		explicit dir(const std::string& dirname)
+		{
+			open(dirname);
+		}
+
+		dir(dir&& other)
+			: m_dd(other.m_dd)
+			, m_path(std::move(other.m_path))
+		{
+		}
+
+		dir& operator =(dir&& right)
+		{
+			std::swap(m_dd, right.m_dd);
+			std::swap(m_path, right.m_path);
+			return *this;
+		}
+
 		~dir();
-		explicit dir(const std::string& dirname) { open(dirname); }
 
-		dir(const dir&) = delete;
-		dir(dir&&) = delete; // possibly TODO
+		// Check whether the handle is valid (opened directory)
+		bool is_opened() const
+		{
+			return m_path.operator bool();
+		}
 
-		dir& operator =(const dir&) = delete;
-		dir& operator =(dir&&) = delete; // possibly TODO
-
-		operator bool() const { return m_path.operator bool(); }
-
-		void import(handle_type dd, const std::string& path);
+		// Check whether the handle is valid (opened directory)
+		explicit operator bool() const
+		{
+			return is_opened();
+		}
 
+		// Open specified directory
 		bool open(const std::string& dirname);
-		bool is_opened() const { return *this; }
+		
+		// Close the directory explicitly (destructor automatically closes the directory)
 		bool close();
 
-		bool get_first(std::string& name, stat_t& info);
-		//bool get_first(std::string& name);
-		bool get_next(std::string& name, stat_t& info);
-		//bool get_next(std::string& name);
+		// Get next directory entry (UTF-8 name and file stat)
+		bool read(std::string& name, stat_t& info);
+
+		bool first(std::string& name, stat_t& info);
+
+		struct entry
+		{
+			std::string name;
+			stat_t info;
+		};
+
+		class iterator
+		{
+			entry m_entry;
+			dir* m_parent;
+
+		public:
+			enum class mode
+			{
+				from_first,
+				from_current
+			};
+
+			iterator(dir* parent, mode mode_ = mode::from_first)
+				: m_parent(parent)
+			{
+				if (!m_parent)
+				{
+					return;
+				}
+
+				bool is_ok;
+
+				if (mode_ == mode::from_first)
+				{
+					is_ok = m_parent->first(m_entry.name, m_entry.info);
+				}
+				else
+				{
+					is_ok = m_parent->read(m_entry.name, m_entry.info);
+				}
+
+				if (!is_ok)
+				{
+					m_parent = nullptr;
+				}
+			}
+
+			entry& operator *()
+			{
+				return m_entry;
+			}
+
+			iterator& operator++()
+			{
+				*this = { m_parent, mode::from_current };
+				return *this;
+			}
+
+			bool operator !=(const iterator& rhs) const
+			{
+				return m_parent != rhs.m_parent;
+			}
+		};
+
+		iterator begin()
+		{
+			return{ this };
+		}
+
+		iterator end()
+		{
+			return{ nullptr };
+		}
 	};
+
+	// Get configuration directory
+	std::string get_config_dir();
+
+	// Get executable directory
+	std::string get_executable_dir();
 }

Utilities/GNU.cpp

@@ -49,11 +49,3 @@ int clock_gettime(clockid_t clk_id, struct timespec *tp)
     return retval;
 }
 #endif /* __APPLE__ */
-#if defined(__GNUG__)
-
-void * _aligned_malloc(size_t size, size_t alignment) {
-	void *buffer;
-	return (posix_memalign(&buffer, alignment, size) == 0) ? buffer : 0;
-}
-#endif
-

Utilities/GNU.h

@@ -40,25 +40,8 @@
 #endif
 
 #define _fpclass(x) std::fpclassify(x)
-#define _byteswap_ushort(x) __builtin_bswap16(x)
-#define _byteswap_ulong(x) __builtin_bswap32(x)
-#define _byteswap_uint64(x) __builtin_bswap64(x)
 #define INFINITE 0xFFFFFFFF
 
-inline uint64_t __umulh(uint64_t a, uint64_t b)
-{
-	uint64_t result;
-	__asm__("mulq %[b]" : "=d" (result) : [a] "a" (a), [b] "rm" (b));
-	return result;
-}
-
-inline int64_t  __mulh(int64_t a, int64_t b)
-{
-	int64_t result;
-	__asm__("imulq %[b]" : "=d" (result) : [a] "a" (a), [b] "rm" (b));
-	return result;
-}
-
 #ifdef __APPLE__
 
 // XXX only supports a single timer
@@ -81,202 +64,186 @@ int clock_gettime(clockid_t clk_id, struct timespec *tp);
 #endif /* __GNUG__ */
 
 #if defined(_MSC_VER)
+
 // Unsigned 128-bit integer implementation
-struct alignas(16) uint128_t
+struct alignas(16) u128
 {
-	uint64_t lo, hi;
+	std::uint64_t lo, hi;
 
-	uint128_t() = default;
+	u128() = default;
 
-	uint128_t(uint64_t l)
+	u128(const u128&) = default;
+
+	u128(std::uint64_t l)
 		: lo(l)
 		, hi(0)
 	{
 	}
 
-	[[deprecated("Not implemented")]] inline uint128_t operator +(const uint128_t& r) const
+	u128 operator +(const u128& r) const
 	{
-		return{};
-	}
-
-	inline uint128_t operator +(uint64_t r) const
-	{
-		uint128_t value;
-		value.lo = lo + r;
-		value.hi = value.lo < r ? hi + 1 : hi;
+		u128 value;
+		_addcarry_u64(_addcarry_u64(0, r.lo, lo, &value.lo), r.hi, hi, &value.hi);
 		return value;
 	}
 
-	[[deprecated("Not implemented")]] inline uint128_t operator -(const uint128_t& r) const
+	friend u128 operator +(const u128& l, std::uint64_t r)
 	{
-		return{};
-	}
-
-	inline uint128_t operator -(uint64_t r) const
-	{
-		uint128_t value;
-		value.lo = lo - r;
-		value.hi = lo < r ? hi - 1 : hi;
+		u128 value;
+		_addcarry_u64(_addcarry_u64(0, r, l.lo, &value.lo), l.hi, 0, &value.hi);
 		return value;
 	}
 
-	inline uint128_t operator +() const
+	friend u128 operator +(std::uint64_t l, const u128& r)
+	{
+		u128 value;
+		_addcarry_u64(_addcarry_u64(0, r.lo, l, &value.lo), 0, r.hi, &value.hi);
+		return value;
+	}
+
+	u128 operator -(const u128& r) const
+	{
+		u128 value;
+		_subborrow_u64(_subborrow_u64(0, r.lo, lo, &value.lo), r.hi, hi, &value.hi);
+		return value;
+	}
+
+	friend u128 operator -(const u128& l, std::uint64_t r)
+	{
+		u128 value;
+		_subborrow_u64(_subborrow_u64(0, r, l.lo, &value.lo), 0, l.hi, &value.hi);
+		return value;
+	}
+
+	friend u128 operator -(std::uint64_t l, const u128& r)
+	{
+		u128 value;
+		_subborrow_u64(_subborrow_u64(0, r.lo, l, &value.lo), r.hi, 0, &value.hi);
+		return value;
+	}
+
+	u128 operator +() const
 	{
 		return *this;
 	}
 
-	inline uint128_t operator -() const
+	u128 operator -() const
 	{
-		uint128_t value;
-		value.lo = ~lo + 1;
-		value.hi = lo ? ~hi : ~hi + 1;
+		u128 value;
+		_subborrow_u64(_subborrow_u64(0, lo, 0, &value.lo), hi, 0, &value.hi);
 		return value;
 	}
 
-	inline uint128_t& operator ++()
+	u128& operator ++()
 	{
-		if (!++lo) ++hi;
+		_addcarry_u64(_addcarry_u64(0, 1, lo, &lo), 0, hi, &hi);
 		return *this;
 	}
 
-	inline uint128_t operator ++(int)
+	u128 operator ++(int)
 	{
-		uint128_t value = *this;
-		if (!++lo) ++hi;
+		u128 value = *this;
+		_addcarry_u64(_addcarry_u64(0, 1, lo, &lo), 0, hi, &hi);
 		return value;
 	}
 
-	inline uint128_t& operator --()
+	u128& operator --()
 	{
-		if (!lo--) hi--;
+		_subborrow_u64(_subborrow_u64(0, 1, lo, &lo), 0, hi, &hi);
 		return *this;
 	}
 
-	inline uint128_t operator --(int)
+	u128 operator --(int)
 	{
-		uint128_t value = *this;
-		if (!lo--) hi--;
+		u128 value = *this;
+		_subborrow_u64(_subborrow_u64(0, 1, lo, &lo), 0, hi, &hi);
 		return value;
 	}
 
-	inline uint128_t operator ~() const
+	u128 operator ~() const
 	{
-		uint128_t value;
+		u128 value;
 		value.lo = ~lo;
 		value.hi = ~hi;
 		return value;
 	}
 
-	inline uint128_t operator &(const uint128_t& r) const
+	u128 operator &(const u128& r) const
 	{
-		uint128_t value;
+		u128 value;
 		value.lo = lo & r.lo;
 		value.hi = hi & r.hi;
 		return value;
 	}
 
-	inline uint128_t operator |(const uint128_t& r) const
+	u128 operator |(const u128& r) const
 	{
-		uint128_t value;
+		u128 value;
 		value.lo = lo | r.lo;
 		value.hi = hi | r.hi;
 		return value;
 	}
 
-	inline uint128_t operator ^(const uint128_t& r) const
+	u128 operator ^(const u128& r) const
 	{
-		uint128_t value;
+		u128 value;
 		value.lo = lo ^ r.lo;
 		value.hi = hi ^ r.hi;
 		return value;
 	}
 
-	[[deprecated("Not implemented")]] inline uint128_t& operator +=(const uint128_t& r)
+	u128& operator +=(const u128& r)
 	{
+		_addcarry_u64(_addcarry_u64(0, r.lo, lo, &lo), r.hi, hi, &hi);
 		return *this;
 	}
 
-	inline uint128_t& operator +=(uint64_t r)
+	u128& operator +=(uint64_t r)
 	{
-		hi = (lo += r) < r ? hi + 1 : hi;
+		_addcarry_u64(_addcarry_u64(0, r, lo, &lo), 0, hi, &hi);
 		return *this;
 	}
 
-	[[deprecated("Not implemented")]] inline uint128_t& operator -=(const uint128_t& r)
-	{
-		return *this;
-	}
-
-	inline uint128_t& operator &=(const uint128_t& r)
+	u128& operator &=(const u128& r)
 	{
 		lo &= r.lo;
 		hi &= r.hi;
 		return *this;
 	}
 
-	inline uint128_t& operator |=(const uint128_t& r)
+	u128& operator |=(const u128& r)
 	{
 		lo |= r.lo;
 		hi |= r.hi;
 		return *this;
 	}
 
-	inline uint128_t& operator ^=(const uint128_t& r)
+	u128& operator ^=(const u128& r)
 	{
 		lo ^= r.lo;
 		hi ^= r.hi;
 		return *this;
 	}
 };
-
-using __uint128_t = uint128_t;
 #endif
 
-inline uint32_t cntlz32(uint32_t arg)
+inline std::uint32_t cntlz32(std::uint32_t arg)
 {
 #if defined(_MSC_VER)
 	unsigned long res;
-	if (!_BitScanReverse(&res, arg))
-	{
-		return 32;
-	}
-	else
-	{
-		return res ^ 31;
-	}
+	return _BitScanReverse(&res, arg) ? res ^ 31 : 32;
 #else
-	if (arg)
-	{
-		return __builtin_clzll((uint64_t)arg) - 32;
-	}
-	else
-	{
-		return 32;
-	}
+	return arg ? __builtin_clzll(arg) - 32 : 32;
 #endif
 }
 
-inline uint64_t cntlz64(uint64_t arg)
+inline std::uint64_t cntlz64(std::uint64_t arg)
 {
 #if defined(_MSC_VER)
 	unsigned long res;
-	if (!_BitScanReverse64(&res, arg))
-	{
-		return 64;
-	}
-	else
-	{
-		return res ^ 63;
-	}
+	return _BitScanReverse64(&res, arg) ? res ^ 63 : 64;
 #else
-	if (arg)
-	{
-		return __builtin_clzll(arg);
-	}
-	else
-	{
-		return 64;
-	}
+	return arg ? __builtin_clzll(arg) : 64;
 #endif
 }
 

Utilities/Log.cpp

@@ -1,11 +1,13 @@
 #include "stdafx.h"
-#include "rPlatform.h"
-#include "Log.h"
-#include "rMsgBox.h"
 #include <iostream>
 #include <cinttypes>
 #include "Thread.h"
 #include "File.h"
+#include "Log.h"
+
+#ifdef _WIN32
+#include <Windows.h>
+#endif
 
 using namespace Log;
 
@@ -93,13 +95,17 @@ struct FileListener : LogListener
 	fs::file mFile;
 	bool mPrependChannelName;
 
-	FileListener(const std::string& name = _PRGNAME_, bool prependChannel = true)
-		: mFile(rPlatform::getConfigDir() + name + ".log", fom::write | fom::create | fom::trunc)
+	FileListener(const std::string& name = _PRGNAME_ ".log", bool prependChannel = true)
+		: mFile(fs::get_config_dir() + name, fom::rewrite)
 		, mPrependChannelName(prependChannel)
 	{
 		if (!mFile)
 		{
-			rMessageBox("Can't create log file! (" + name + ".log)", "Error", rICON_ERROR);
+#ifdef _WIN32
+			MessageBoxA(0, ("Can't create log file: " + name).c_str(), "Error", MB_ICONERROR);
+#else
+			std::printf("Can't create log file: %s\n", name.c_str());
+#endif
 		}
 	}
 
@@ -120,7 +126,7 @@ struct FileListener : LogListener
 			}
 		}
 
-		mFile.write(text.c_str(), text.size());
+		mFile << text;
 	}
 };
 
@@ -137,7 +143,7 @@ LogManager::LogManager()
 		it->addListener(listener);
 		it++;
 	}
-	std::shared_ptr<LogListener> TTYListener(new FileListener("TTY",false));
+	std::shared_ptr<LogListener> TTYListener(new FileListener("TTY.log", false));
 	getChannel(TTY).addListener(TTYListener);
 #ifdef BUFFERED_LOGGING
 	mLogConsumer = std::thread(&LogManager::consumeLog, this);
@@ -199,7 +205,7 @@ void LogManager::log(LogMessage msg)
 			prefix = "E ";
 			break;
 		}
-		if (auto thr = get_current_thread_ctrl())
+		if (auto thr = thread_ctrl::get_current())
 		{
 			prefix += "{" + thr->get_name() + "} ";
 		}
@@ -257,20 +263,23 @@ void log_message(Log::LogType type, Log::Severity sev, std::string text)
 {
 	if (g_log_manager)
 	{
-		// another msvc bug makes this not work, uncomment this when it's fixed
-		//g_log_manager->log({logType, severity, text});
-		Log::LogMessage msg{ type, sev, std::move(text) };
-		g_log_manager->log(msg);
+		g_log_manager->log({ type, sev, std::move(text) });
 	}
 	else
 	{
-		rMessageBox(text,
+		const auto severity =
 			sev == Severity::Notice ? "Notice" :
 			sev == Severity::Warning ? "Warning" :
 			sev == Severity::Success ? "Success" :
-			sev == Severity::Error ? "Error" : "Unknown",
-			sev == Severity::Notice ? rICON_INFORMATION :
-			sev == Severity::Warning ? rICON_EXCLAMATION :
-			sev == Severity::Error ? rICON_ERROR : rICON_INFORMATION);
+			sev == Severity::Error ? "Error" : "Unknown";
+
+#ifdef _WIN32
+		MessageBoxA(0, text.c_str(), severity,
+			sev == Severity::Notice ? MB_ICONINFORMATION :
+			sev == Severity::Warning ? MB_ICONEXCLAMATION :
+			sev == Severity::Error ? MB_ICONERROR : MB_ICONINFORMATION);
+#else
+		std::printf("[Log:%s] %s\n", severity, text.c_str());
+#endif
 	}
 }

Utilities/Log.h

@@ -79,7 +79,6 @@ namespace Log
 		LogChannel();
 		LogChannel(const std::string& name);
 		LogChannel(LogChannel& other) = delete;
-		LogChannel& operator = (LogChannel& other) = delete;
 		void log(const LogMessage &msg);
 		void addListener(std::shared_ptr<LogListener> listener);
 		void removeListener(std::shared_ptr<LogListener> listener);

Utilities/SharedMutex.cpp

@@ -1,152 +1,103 @@
 #include "stdafx.h"
 #include "SharedMutex.h"
 
-static const u32 MAX_READERS = 0x7fffffff; // 2^31-1
-
-inline bool shared_mutex_t::try_lock_shared()
+void shared_mutex::impl_lock_shared(u32 old_value)
 {
-	return m_info.atomic_op([](ownership_info_t& info) -> bool
+	// Throw if reader count breaks the "second" limit (it should be impossible)
+	CHECK_ASSERTION((old_value & SM_READER_COUNT) != SM_READER_COUNT);
+
+	std::unique_lock<std::mutex> lock(m_mutex);
+
+	// Notify non-zero reader queue size
+	m_ctrl |= SM_READER_QUEUE;
+
+	// Compensate incorrectly increased reader count
+	if ((--m_ctrl & SM_READER_COUNT) == 0 && m_wq_size)
 	{
-		if (info.readers < MAX_READERS && !info.writers && !info.waiting_readers && !info.waiting_writers)
-		{
-			info.readers++;
-			return true;
-		}
+		// Notify current exclusive owner (condition passed)
+		m_ocv.notify_one();
+	}
 
-		return false;
-	});
-}
+	CHECK_ASSERTION(++m_rq_size);
 
-void shared_mutex_t::lock_shared()
-{
-	if (!try_lock_shared())
+	// Obtain the reader lock
+	while (!atomic_op(m_ctrl, op_lock_shared))
 	{
-		std::unique_lock<std::mutex> lock(m_mutex);
+		m_rcv.wait(lock);
+	}
 
-		m_wrcv.wait(lock, WRAP_EXPR(m_info.atomic_op([](ownership_info_t& info) -> bool
-		{
-			if (info.waiting_readers < UINT16_MAX)
-			{
-				info.waiting_readers++;
-				return true;
-			}
+	CHECK_ASSERTION(m_rq_size--);
 
-			return false;
-		})));
-
-		m_rcv.wait(lock, WRAP_EXPR(m_info.atomic_op([](ownership_info_t& info) -> bool
-		{
-			if (!info.writers && !info.waiting_writers && info.readers < MAX_READERS)
-			{
-				info.readers++;
-				return true;
-			}
-
-			return false;
-		})));
-
-		const auto info = m_info.atomic_op([](ownership_info_t& info)
-		{
-			if (!info.waiting_readers--)
-			{
-				throw EXCEPTION("Invalid value");
-			}
-		});
-
-		if (info.waiting_readers == UINT16_MAX)
-		{
-			m_wrcv.notify_one();
-		}
+	if (m_rq_size == 0)
+	{
+		m_ctrl &= ~SM_READER_QUEUE;
 	}
 }
 
-void shared_mutex_t::unlock_shared()
+void shared_mutex::impl_unlock_shared(u32 new_value)
 {
-	const auto info = m_info.atomic_op([](ownership_info_t& info)
+	// Throw if reader count was zero
+	CHECK_ASSERTION((new_value & SM_READER_COUNT) != SM_READER_COUNT);
+
+	// Mutex cannot be unlocked before notification because m_ctrl has been changed outside
+	std::lock_guard<std::mutex> lock(m_mutex);
+
+	if (m_wq_size && (new_value & SM_READER_COUNT) == 0)
 	{
-		if (!info.readers--)
-		{
-			throw EXCEPTION("Not locked");
-		}
-	});
-
-	const bool notify_writers = info.readers == 1 && info.writers;
-	const bool notify_readers = info.readers == UINT32_MAX && info.waiting_readers;
-
-	if (notify_writers || notify_readers)
+		// Notify current exclusive owner that the latest reader is gone
+		m_ocv.notify_one();
+	}
+	else if (m_rq_size)
 	{
-		std::lock_guard<std::mutex> lock(m_mutex);
-
-		if (notify_writers) m_wcv.notify_one();
-		if (notify_readers) m_rcv.notify_one();
+		m_rcv.notify_one();
 	}
 }
 
-inline bool shared_mutex_t::try_lock()
+void shared_mutex::impl_lock_excl(u32 value)
 {
-	return m_info.compare_and_swap_test({ 0, 0, 0, 0 }, { 0, 1, 0, 0 });
-}
+	std::unique_lock<std::mutex> lock(m_mutex);
 
-void shared_mutex_t::lock()
-{
-	if (!try_lock())
+	// Notify non-zero writer queue size
+	m_ctrl |= SM_WRITER_QUEUE;
+
+	CHECK_ASSERTION(++m_wq_size);
+
+	// Obtain the writer lock
+	while (!atomic_op(m_ctrl, op_lock_excl))
 	{
-		std::unique_lock<std::mutex> lock(m_mutex);
+		m_wcv.wait(lock);
+	}
 
-		m_wwcv.wait(lock, WRAP_EXPR(m_info.atomic_op([](ownership_info_t& info) -> bool
-		{
-			if (info.waiting_writers < UINT16_MAX)
-			{
-				info.waiting_writers++;
-				return true;
-			}
+	// Wait for remaining readers
+	while ((m_ctrl & SM_READER_COUNT) != 0)
+	{
+		m_ocv.wait(lock);
+	}
 
-			return false;
-		})));
+	CHECK_ASSERTION(m_wq_size--);
 
-		m_wcv.wait(lock, WRAP_EXPR(m_info.atomic_op([](ownership_info_t& info) -> bool
-		{
-			if (!info.writers)
-			{
-				info.writers++;
-				return true;
-			}
-
-			return false;
-		})));
-
-		m_wcv.wait(lock, WRAP_EXPR(m_info.load().readers == 0));
-
-		const auto info = m_info.atomic_op([](ownership_info_t& info)
-		{
-			if (!info.waiting_writers--)
-			{
-				throw EXCEPTION("Invalid value");
-			}
-		});
-
-		if (info.waiting_writers == UINT16_MAX)
-		{
-			m_wwcv.notify_one();
-		}
+	if (m_wq_size == 0)
+	{
+		m_ctrl &= ~SM_WRITER_QUEUE;
 	}
 }
 
-void shared_mutex_t::unlock()
+void shared_mutex::impl_unlock_excl(u32 value)
 {
-	const auto info = m_info.atomic_op([](ownership_info_t& info)
-	{
-		if (!info.writers--)
-		{
-			throw EXCEPTION("Not locked");
-		}
-	});
+	// Throw if was not locked exclusively
+	CHECK_ASSERTION(value & SM_WRITER_LOCK);
 
-	if (info.waiting_writers || info.waiting_readers)
+	// Mutex cannot be unlocked before notification because m_ctrl has been changed outside
+	std::lock_guard<std::mutex> lock(m_mutex);
+	
+	if (m_wq_size)
 	{
-		std::lock_guard<std::mutex> lock(m_mutex);
-
-		if (info.waiting_writers) m_wcv.notify_one();
-		else if (info.waiting_readers) m_rcv.notify_all();
+		// Notify next exclusive owner
+		m_wcv.notify_one();
+	}
+	else if (m_rq_size)
+	{
+		// Notify all readers
+		m_rcv.notify_all();
 	}
 }

Utilities/SharedMutex.h

@@ -1,46 +1,136 @@
 #pragma once
 
-#include <shared_mutex>
-
-// An attempt to create lock-free (in optimistic case) implementation similar to std::shared_mutex;
-// MSVC implementation of std::shared_timed_mutex is not lock-free and thus may be slow, and std::shared_mutex is not available.
-class shared_mutex_t
+//! An attempt to create effective implementation of "shared mutex", lock-free in optimistic case.
+//! All locking and unlocking may be done by single LOCK XADD or LOCK CMPXCHG instructions.
+//! MSVC implementation of std::shared_timed_mutex seems suboptimal.
+//! std::shared_mutex is not available until C++17.
+class shared_mutex final
 {
-	struct ownership_info_t
+	enum : u32
 	{
-		u32 readers : 31;
-		u32 writers : 1;
-		u16 waiting_readers;
-		u16 waiting_writers;
+		SM_WRITER_LOCK  = 1u << 31, // Exclusive lock flag, must be MSB
+		SM_WRITER_QUEUE = 1u << 30, // Flag set if m_wq_size != 0
+		SM_READER_QUEUE = 1u << 29, // Flag set if m_rq_size != 0
+
+		SM_READER_COUNT = SM_READER_QUEUE - 1, // Valid reader count bit mask
+		SM_READER_MAX   = 1u << 24, // Max reader count
 	};
 
-	atomic_t<ownership_info_t> m_info{};
+	std::atomic<u32> m_ctrl{}; // Control atomic variable: reader count | SM_* flags
+	std::thread::id m_owner{}; // Current exclusive owner (TODO: implement only for debug mode?)
 
 	std::mutex m_mutex;
+
+	u32 m_rq_size{}; // Reader queue size (threads waiting on m_rcv)
+	u32 m_wq_size{}; // Writer queue size (threads waiting on m_wcv+m_ocv)
 	
-	std::condition_variable m_rcv;
-	std::condition_variable m_wcv;
-	std::condition_variable m_wrcv;
-	std::condition_variable m_wwcv;
+	std::condition_variable m_rcv; // Reader queue
+	std::condition_variable m_wcv; // Writer queue
+	std::condition_variable m_ocv; // For current exclusive owner
+
+	static bool op_lock_shared(u32& ctrl)
+	{
+		// Check writer flags and reader limit
+		return (ctrl & ~SM_READER_QUEUE) < SM_READER_MAX ? ctrl++, true : false;
+	}
+
+	static bool op_lock_excl(u32& ctrl)
+	{
+		// Test and set writer lock
+		return (ctrl & SM_WRITER_LOCK) == 0 ? ctrl |= SM_WRITER_LOCK, true : false;
+	}
+
+	void impl_lock_shared(u32 old_ctrl);
+	void impl_unlock_shared(u32 new_ctrl);
+	void impl_lock_excl(u32 ctrl);
+	void impl_unlock_excl(u32 ctrl);
 
 public:
-	shared_mutex_t() = default;
+	shared_mutex() = default;
 
 	// Lock in shared mode
-	void lock_shared();
+	void lock_shared()
+	{
+		const u32 old_ctrl = m_ctrl++;
+
+		// Check flags and reader limit
+		if (old_ctrl >= SM_READER_MAX)
+		{
+			impl_lock_shared(old_ctrl);
+		}
+	}
 
 	// Try to lock in shared mode
-	bool try_lock_shared();
+	bool try_lock_shared()
+	{
+		return atomic_op(m_ctrl, [](u32& ctrl)
+		{
+			// Check flags and reader limit
+			return ctrl < SM_READER_MAX ? ctrl++, true : false;
+		});
+	}
 
 	// Unlock in shared mode
-	void unlock_shared();
+	void unlock_shared()
+	{
+		const u32 new_ctrl = --m_ctrl;
+
+		// Check if notification required
+		if (new_ctrl >= SM_READER_MAX)
+		{
+			impl_unlock_shared(new_ctrl);
+		}
+	}
 
 	// Lock exclusively
-	void lock();
+	void lock()
+	{
+		u32 value = 0;
+
+		if (!m_ctrl.compare_exchange_strong(value, SM_WRITER_LOCK))
+		{
+			impl_lock_excl(value);
+		}
+	}
 
 	// Try to lock exclusively
-	bool try_lock();
+	bool try_lock()
+	{
+		u32 value = 0;
+
+		return m_ctrl.compare_exchange_strong(value, SM_WRITER_LOCK);
+	}
 
 	// Unlock exclusively
-	void unlock();
+	void unlock()
+	{
+		const u32 value = m_ctrl.fetch_add(SM_WRITER_LOCK);
+
+		// Check if notification required
+		if (value != SM_WRITER_LOCK)
+		{
+			impl_unlock_excl(value);
+		}
+	}
+};
+
+//! Simplified shared (reader) lock implementation, similar to std::lock_guard.
+//! std::shared_lock may be used instead if necessary.
+class reader_lock final
+{
+	shared_mutex& m_mutex;
+
+public:
+	reader_lock(const reader_lock&) = delete;
+
+	reader_lock(shared_mutex& mutex)
+		: m_mutex(mutex)
+	{
+		m_mutex.lock_shared();
+	}
+
+	~reader_lock()
+	{
+		m_mutex.unlock_shared();
+	}
 };

Utilities/SleepQueue.cpp

@@ -5,7 +5,7 @@
 
 void sleep_queue_entry_t::add_entry()
 {
-	m_queue.emplace_back(m_thread.shared_from_this());
+	m_queue.emplace_back(std::static_pointer_cast<CPUThread>(m_thread.shared_from_this()));
 }
 
 void sleep_queue_entry_t::remove_entry()
@@ -33,7 +33,7 @@ bool sleep_queue_entry_t::find() const
 	return false;
 }
 
-sleep_queue_entry_t::sleep_queue_entry_t(CPUThread& cpu, sleep_queue_t& queue)
+sleep_queue_entry_t::sleep_queue_entry_t(sleep_entry_t& cpu, sleep_queue_t& queue)
 	: m_thread(cpu)
 	, m_queue(queue)
 {
@@ -41,7 +41,7 @@ sleep_queue_entry_t::sleep_queue_entry_t(CPUThread& cpu, sleep_queue_t& queue)
 	cpu.sleep();
 }
 
-sleep_queue_entry_t::sleep_queue_entry_t(CPUThread& cpu, sleep_queue_t& queue, const defer_sleep_t&)
+sleep_queue_entry_t::sleep_queue_entry_t(sleep_entry_t& cpu, sleep_queue_t& queue, const defer_sleep_t&)
 	: m_thread(cpu)
 	, m_queue(queue)
 {

Utilities/SleepQueue.h

@@ -1,15 +1,14 @@
 #pragma once
 
-class CPUThread;
-
-using sleep_queue_t = std::deque<std::shared_ptr<CPUThread>>;
+using sleep_entry_t = class CPUThread;
+using sleep_queue_t = std::deque<std::shared_ptr<sleep_entry_t>>;
 
 static struct defer_sleep_t {} const defer_sleep{};
 
 // automatic object handling a thread entry in the sleep queue
 class sleep_queue_entry_t final
 {
-	CPUThread& m_thread;
+	sleep_entry_t& m_thread;
 	sleep_queue_t& m_queue;
 
 	void add_entry();
@@ -18,28 +17,28 @@ class sleep_queue_entry_t final
 
 public:
 	// add specified thread to the sleep queue
-	sleep_queue_entry_t(CPUThread& cpu, sleep_queue_t& queue);
+	sleep_queue_entry_t(sleep_entry_t& entry, sleep_queue_t& queue);
 
 	// don't add specified thread to the sleep queue
-	sleep_queue_entry_t(CPUThread& cpu, sleep_queue_t& queue, const defer_sleep_t&);
+	sleep_queue_entry_t(sleep_entry_t& entry, sleep_queue_t& queue, const defer_sleep_t&);
 
 	// removes specified thread from the sleep queue if added
 	~sleep_queue_entry_t();
 
 	// add thread to the sleep queue
-	inline void enter()
+	void enter()
 	{
 		add_entry();
 	}
 
 	// remove thread from the sleep queue
-	inline void leave()
+	void leave()
 	{
 		remove_entry();
 	}
 
 	// check whether the thread exists in the sleep queue
-	inline explicit operator bool() const
+	explicit operator bool() const
 	{
 		return find();
 	}

Utilities/StrFmt.cpp

@@ -15,9 +15,13 @@ std::string v128::to_xyzw() const
 	return fmt::format("x: %g y: %g z: %g w: %g", _f[3], _f[2], _f[1], _f[0]);
 }
 
-std::string fmt::to_hex(u64 value, size_t count)
+std::string fmt::to_hex(u64 value, u64 count)
 {
-	assert(count - 1 < 16);
+	if (count - 1 >= 16)
+	{
+		throw EXCEPTION("Invalid count: 0x%llx", count);
+	}
+
 	count = std::max<u64>(count, 16 - cntlz64(value) / 4);
 
 	char res[16] = {};
@@ -208,6 +212,16 @@ std::vector<std::string> fmt::split(const std::string& source, std::initializer_
 	return std::move(result);
 }
 
+std::string fmt::trim(const std::string& source, const std::string& values)
+{
+	std::size_t begin = source.find_first_not_of(values);
+
+	if (begin == source.npos)
+		return{};
+
+	return source.substr(begin, source.find_last_not_of(values) + 1);
+}
+
 std::string fmt::tolower(std::string source)
 {
 	std::transform(source.begin(), source.end(), source.begin(), ::tolower);
@@ -245,3 +259,42 @@ std::string fmt::escape(std::string source)
 
 	return source;
 }
+
+bool fmt::match(const std::string &source, const std::string &mask)
+{
+	std::size_t source_position = 0, mask_position = 0;
+
+	for (; source_position < source.size() && mask_position < mask.size(); ++mask_position, ++source_position)
+	{
+		switch (mask[mask_position])
+		{
+		case '?': break;
+
+		case '*':
+			for (std::size_t test_source_position = source_position; test_source_position < source.size(); ++test_source_position)
+			{
+				if (match(source.substr(test_source_position), mask.substr(mask_position + 1)))
+				{
+					return true;
+				}
+			}
+			return false;
+
+		default:
+			if (source[source_position] != mask[mask_position])
+			{
+				return false;
+			}
+
+			break;
+		}
+	}
+
+	if (source_position != source.size())
+		return false;
+
+	if (mask_position != mask.size())
+		return false;
+
+	return true;
+}

Utilities/StrFmt.h

@@ -141,7 +141,7 @@ namespace fmt
 		return src;
 	}
 
-	std::string to_hex(u64 value, size_t count = 1);
+	std::string to_hex(u64 value, u64 count = 1);
 	std::string to_udec(u64 value);
 	std::string to_sdec(s64 value);
 
@@ -233,12 +233,14 @@ namespace fmt
 
 		for (std::size_t buf_size = fixed_buf.size();;)
 		{
+#ifndef _MSC_VER
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wformat-security"
+#endif
 			const std::size_t len = std::snprintf(buf_addr, buf_size, fmt, do_unveil(args)...);
-
+#ifndef _MSC_VER
 #pragma GCC diagnostic pop
-
+#endif
 			if (len > INT_MAX)
 			{
 				throw std::runtime_error("std::snprintf() failed");
@@ -300,6 +302,7 @@ namespace fmt
 	std::vector<std::string> rSplit(const std::string& source, const std::string& delim);
 
 	std::vector<std::string> split(const std::string& source, std::initializer_list<std::string> separators, bool is_skip_empty = true);
+	std::string trim(const std::string& source, const std::string& values = " \t");
 
 	template<typename T>
 	std::string merge(const T& source, const std::string& separator)
@@ -351,4 +354,5 @@ namespace fmt
 	std::string tolower(std::string source);
 	std::string toupper(std::string source);
 	std::string escape(std::string source);
+	bool match(const std::string &source, const std::string &mask);
 }

Utilities/Thread.cpp

@@ -1,7 +1,7 @@
 #include "stdafx.h"
 #include "Log.h"
-#include "rpcs3/Ini.h"
 #include "Emu/System.h"
+#include "Emu/state.h"
 #include "Emu/CPU/CPUThreadManager.h"
 #include "Emu/CPU/CPUThread.h"
 #include "Emu/Cell/RawSPUThread.h"
@@ -19,6 +19,34 @@
 #include <ucontext.h>
 #endif
 
+void report_fatal_error(const std::string& msg)
+{
+#ifdef _WIN32
+	const auto& text = msg + "\n\nPlease report this error to the developers. Press (Ctrl+C) to copy this message.";
+	MessageBoxA(0, text.c_str(), "Fatal error", MB_ICONERROR); // TODO: unicode message
+#else
+	std::printf("Fatal error: %s\nPlease report this error to the developers.\n", msg.c_str());
+#endif
+}
+
+[[noreturn]] void catch_all_exceptions()
+{
+	try
+	{
+		throw;
+	}
+	catch (const std::exception& ex)
+	{
+		report_fatal_error("Unhandled exception: "s + ex.what());
+	}
+	catch (...)
+	{
+		report_fatal_error("Unhandled exception (unknown)");
+	}
+
+	std::abort();
+}
+
 void SetCurrentThreadDebugName(const char* threadName)
 {
 #if defined(_MSC_VER) // this is VS-specific way to set thread names for the debugger
@@ -113,10 +141,11 @@ enum x64_op_t : u32
 	X64OP_STOS,
 	X64OP_XCHG,
 	X64OP_CMPXCHG,
-	X64OP_LOAD_AND_STORE, // lock and [mem],reg
-	X64OP_LOAD_OR_STORE, // TODO: lock or [mem], reg
-	X64OP_INC, // TODO: lock inc [mem]
-	X64OP_DEC, // TODO: lock dec [mem]
+	X64OP_LOAD_AND_STORE, // lock and [mem], reg
+	X64OP_LOAD_OR_STORE,  // lock or  [mem], reg (TODO)
+	X64OP_LOAD_XOR_STORE, // lock xor [mem], reg (TODO)
+	X64OP_INC, // lock inc [mem] (TODO)
+	X64OP_DEC, // lock dec [mem] (TODO)
 };
 
 void decode_x64_reg_op(const u8* code, x64_op_t& out_op, x64_reg_t& out_reg, size_t& out_size, size_t& out_length)
@@ -495,6 +524,9 @@ typedef CONTEXT x64_context;
 #define XMMREG(context, reg) (reinterpret_cast<v128*>(&(&(context)->Xmm0)[reg]))
 #define EFLAGS(context) ((context)->EFlags)
 
+#define ARG1(context) RCX(context)
+#define ARG2(context) RDX(context)
+
 #else
 
 typedef ucontext_t x64_context;
@@ -510,50 +542,32 @@ uint64_t* darwin_x64reg(x64_context *context, int reg)
 	auto *state = &context->uc_mcontext->__ss;
 	switch(reg)
 	{
-	case 0: // RAX
-		return &state->__rax;
-	case 1: // RCX
-		return &state->__rcx;
-	case 2: // RDX
-		return &state->__rdx;
-	case 3: // RBX
-		return &state->__rbx;
-	case 4: // RSP
-		return &state->__rsp;
-	case 5: // RBP
-		return &state->__rbp;
-	case 6: // RSI
-		return &state->__rsi;
-	case 7: // RDI
-		return &state->__rdi;
-	case 8: // R8
-		return &state->__r8;
-	case 9: // R9
-		return &state->__r9;
-	case 10: // R10
-		return &state->__r10;
-	case 11: // R11
-		return &state->__r11;
-	case 12: // R12
-		return &state->__r12;
-	case 13: // R13
-		return &state->__r13;
-	case 14: // R14
-		return &state->__r14;
-	case 15: // R15
-		return &state->__r15;
-	case 16: // RIP
-		return &state->__rip;
-	default: // FAIL
-		assert(0);
+	case 0: return &state->__rax;
+	case 1: return &state->__rcx;
+	case 2: return &state->__rdx;
+	case 3: return &state->__rbx;
+	case 4: return &state->__rsp;
+	case 5: return &state->__rbp;
+	case 6: return &state->__rsi;
+	case 7: return &state->__rdi;
+	case 8: return &state->__r8;
+	case 9: return &state->__r9;
+	case 10: return &state->__r10;
+	case 11: return &state->__r11;
+	case 12: return &state->__r12;
+	case 13: return &state->__r13;
+	case 14: return &state->__r14;
+	case 15: return &state->__r15;
+	case 16: return &state->__rip;
+	default:
+		LOG_ERROR(GENERAL, "Invalid register index: %d", reg);
+		return nullptr;
 	}
 }
 
 #else
 
-typedef decltype(REG_RIP) reg_table_t;
-
-static const reg_table_t reg_table[17] =
+static const decltype(REG_RAX) reg_table[] =
 {
 	REG_RAX, REG_RCX, REG_RDX, REG_RBX, REG_RSP, REG_RBP, REG_RSI, REG_RDI,
 	REG_R8, REG_R9, REG_R10, REG_R11, REG_R12, REG_R13, REG_R14, REG_R15, REG_RIP
@@ -565,11 +579,15 @@ static const reg_table_t reg_table[17] =
 
 #endif // __APPLE__
 
+#define ARG1(context) RDI(context)
+#define ARG2(context) RSI(context)
+
 #endif
 
 #define RAX(c) (*X64REG((c), 0))
 #define RCX(c) (*X64REG((c), 1))
 #define RDX(c) (*X64REG((c), 2))
+#define RSP(c) (*X64REG((c), 4))
 #define RSI(c) (*X64REG((c), 6))
 #define RDI(c) (*X64REG((c), 7))
 #define RIP(c) (*X64REG((c), 16))
@@ -846,7 +864,7 @@ bool handle_access_violation(u32 addr, bool is_writing, x64_context* context)
 		case X64OP_LOAD:
 		{
 			u32 value;
-			if (is_writing || !thread->read_reg(addr, value) || !put_x64_reg_value(context, reg, d_size, _byteswap_ulong(value)))
+			if (is_writing || !thread->read_reg(addr, value) || !put_x64_reg_value(context, reg, d_size, se_storage<u32>::swap(value)))
 			{
 				return false;
 			}
@@ -856,7 +874,7 @@ bool handle_access_violation(u32 addr, bool is_writing, x64_context* context)
 		case X64OP_STORE:
 		{
 			u64 reg_value;
-			if (!is_writing || !get_x64_reg_value(context, reg, d_size, i_size, reg_value) || !thread->write_reg(addr, _byteswap_ulong((u32)reg_value)))
+			if (!is_writing || !get_x64_reg_value(context, reg, d_size, i_size, reg_value) || !thread->write_reg(addr, se_storage<u32>::swap((u32)reg_value)))
 			{
 				return false;
 			}
@@ -901,7 +919,7 @@ bool handle_access_violation(u32 addr, bool is_writing, x64_context* context)
 					return false;
 				}
 
-				memcpy(vm::priv_ptr(addr), XMMREG(context, reg - X64R_XMM0), 16);
+				std::memcpy(vm::base_priv(addr), XMMREG(context, reg - X64R_XMM0), 16);
 				break;
 			}
 
@@ -911,7 +929,7 @@ bool handle_access_violation(u32 addr, bool is_writing, x64_context* context)
 				return false;
 			}
 
-			memcpy(vm::priv_ptr(addr), &reg_value, d_size);
+			std::memcpy(vm::base_priv(addr), &reg_value, d_size);
 			break;
 		}
 		case X64OP_MOVS:
@@ -922,7 +940,7 @@ bool handle_access_violation(u32 addr, bool is_writing, x64_context* context)
 				return false;
 			}
 
-			if (vm::get_ptr(addr) != (void*)RDI(context))
+			if (vm::base(addr) != (void*)RDI(context))
 			{
 				LOG_ERROR(MEMORY, "X64OP_MOVS: rdi=0x%llx, rsi=0x%llx, addr=0x%x", (u64)RDI(context), (u64)RSI(context), addr);
 				return false;
@@ -935,8 +953,8 @@ bool handle_access_violation(u32 addr, bool is_writing, x64_context* context)
 				u64 value;
 
 				// copy data
-				memcpy(&value, (void*)RSI(context), d_size);
-				memcpy(vm::priv_ptr(a_addr), &value, d_size);
+				std::memcpy(&value, (void*)RSI(context), d_size);
+				std::memcpy(vm::base_priv(a_addr), &value, d_size);
 
 				// shift pointers
 				if (EFLAGS(context) & 0x400 /* direction flag */)
@@ -977,7 +995,7 @@ bool handle_access_violation(u32 addr, bool is_writing, x64_context* context)
 				return false;
 			}
 
-			if (vm::get_ptr(addr) != (void*)RDI(context))
+			if (vm::base(addr) != (void*)RDI(context))
 			{
 				LOG_ERROR(MEMORY, "X64OP_STOS: rdi=0x%llx, addr=0x%x", (u64)RDI(context), addr);
 				return false;
@@ -994,7 +1012,7 @@ bool handle_access_violation(u32 addr, bool is_writing, x64_context* context)
 			while (a_addr >> 12 == addr >> 12)
 			{
 				// fill data with value
-				memcpy(vm::priv_ptr(a_addr), &value, d_size);
+				std::memcpy(vm::base_priv(a_addr), &value, d_size);
 
 				// shift pointers
 				if (EFLAGS(context) & 0x400 /* direction flag */)
@@ -1035,10 +1053,10 @@ bool handle_access_violation(u32 addr, bool is_writing, x64_context* context)
 
 			switch (d_size)
 			{
-			case 1: reg_value = vm::priv_ref<atomic_t<u8>>(addr).exchange((u8)reg_value); break;
-			case 2: reg_value = vm::priv_ref<atomic_t<u16>>(addr).exchange((u16)reg_value); break;
-			case 4: reg_value = vm::priv_ref<atomic_t<u32>>(addr).exchange((u32)reg_value); break;
-			case 8: reg_value = vm::priv_ref<atomic_t<u64>>(addr).exchange((u64)reg_value); break;
+			case 1: reg_value = sync_lock_test_and_set((u8*)vm::base_priv(addr), (u8)reg_value); break;
+			case 2: reg_value = sync_lock_test_and_set((u16*)vm::base_priv(addr), (u16)reg_value); break;
+			case 4: reg_value = sync_lock_test_and_set((u32*)vm::base_priv(addr), (u32)reg_value); break;
+			case 8: reg_value = sync_lock_test_and_set((u64*)vm::base_priv(addr), (u64)reg_value); break;
 			default: return false;
 			}
 
@@ -1058,10 +1076,10 @@ bool handle_access_violation(u32 addr, bool is_writing, x64_context* context)
 
 			switch (d_size)
 			{
-			case 1: old_value = vm::priv_ref<atomic_t<u8>>(addr).compare_and_swap((u8)cmp_value, (u8)reg_value); break;
-			case 2: old_value = vm::priv_ref<atomic_t<u16>>(addr).compare_and_swap((u16)cmp_value, (u16)reg_value); break;
-			case 4: old_value = vm::priv_ref<atomic_t<u32>>(addr).compare_and_swap((u32)cmp_value, (u32)reg_value); break;
-			case 8: old_value = vm::priv_ref<atomic_t<u64>>(addr).compare_and_swap((u64)cmp_value, (u64)reg_value); break;
+			case 1: old_value = sync_val_compare_and_swap((u8*)vm::base_priv(addr), (u8)cmp_value, (u8)reg_value); break;
+			case 2: old_value = sync_val_compare_and_swap((u16*)vm::base_priv(addr), (u16)cmp_value, (u16)reg_value); break;
+			case 4: old_value = sync_val_compare_and_swap((u32*)vm::base_priv(addr), (u32)cmp_value, (u32)reg_value); break;
+			case 8: old_value = sync_val_compare_and_swap((u64*)vm::base_priv(addr), (u64)cmp_value, (u64)reg_value); break;
 			default: return false;
 			}
 
@@ -1081,10 +1099,10 @@ bool handle_access_violation(u32 addr, bool is_writing, x64_context* context)
 
 			switch (d_size)
 			{
-			case 1: value = vm::priv_ref<atomic_t<u8>>(addr) &= (u8)value; break;
-			case 2: value = vm::priv_ref<atomic_t<u16>>(addr) &= (u16)value; break;
-			case 4: value = vm::priv_ref<atomic_t<u32>>(addr) &= (u32)value; break;
-			case 8: value = vm::priv_ref<atomic_t<u64>>(addr) &= value; break;
+			case 1: value &= sync_fetch_and_and((u8*)vm::base_priv(addr), (u8)value); break;
+			case 2: value &= sync_fetch_and_and((u16*)vm::base_priv(addr), (u16)value); break;
+			case 4: value &= sync_fetch_and_and((u32*)vm::base_priv(addr), (u32)value); break;
+			case 8: value &= sync_fetch_and_and((u64*)vm::base_priv(addr), (u64)value); break;
 			default: return false;
 			}
 
@@ -1110,30 +1128,32 @@ bool handle_access_violation(u32 addr, bool is_writing, x64_context* context)
 	// TODO: allow recovering from a page fault as a feature of PS3 virtual memory
 }
 
-#ifdef _WIN32
-
-void _se_translator(unsigned int u, EXCEPTION_POINTERS* pExp)
+// Throw virtual memory access violation exception
+[[noreturn]] void throw_access_violation(const char* cause, u32 address) // Don't change function definition
 {
-	const u64 addr64 = (u64)pExp->ExceptionRecord->ExceptionInformation[1] - (u64)vm::g_base_addr;
-	const bool is_writing = pExp->ExceptionRecord->ExceptionInformation[0] != 0;
-
-	if (u == EXCEPTION_ACCESS_VIOLATION && (u32)addr64 == addr64)
-	{
-		throw EXCEPTION("Access violation %s location 0x%llx", is_writing ? "writing" : "reading", addr64);
-	}
-
-	//__int2c(); // if it crashed there, check the callstack for the actual source of the crash
+	throw EXCEPTION("Access violation %s location 0x%08x", cause, address);
 }
 
-const PVOID exception_handler = (atexit([]{ RemoveVectoredExceptionHandler(exception_handler); }), AddVectoredExceptionHandler(1, [](PEXCEPTION_POINTERS pExp) -> LONG
+// Modify context in order to convert hardware exception to C++ exception
+void prepare_throw_access_violation(x64_context* context, const char* cause, u32 address)
 {
-	const u64 addr64 = (u64)pExp->ExceptionRecord->ExceptionInformation[1] - (u64)vm::g_base_addr;
+	// Set throw_access_violation() call args (old register values are lost)
+	ARG1(context) = (u64)cause;
+	ARG2(context) = address;
+
+	// Push the exception address as a "return" address (throw_access_violation() shall not return)
+	*--(u64*&)(RSP(context)) = RIP(context);
+	RIP(context) = (u64)std::addressof(throw_access_violation);
+}
+
+#ifdef _WIN32
+
+const auto g_exception_handler = AddVectoredExceptionHandler(1, [](PEXCEPTION_POINTERS pExp) -> LONG
+{
+	const u64 addr64 = pExp->ExceptionRecord->ExceptionInformation[1] - (u64)vm::base(0);
 	const bool is_writing = pExp->ExceptionRecord->ExceptionInformation[0] != 0;
 
-	if (pExp->ExceptionRecord->ExceptionCode == EXCEPTION_ACCESS_VIOLATION &&
-		(u32)addr64 == addr64 &&
-		get_current_thread_ctrl() &&
-		handle_access_violation((u32)addr64, is_writing, pExp->ContextRecord))
+	if (pExp->ExceptionRecord->ExceptionCode == EXCEPTION_ACCESS_VIOLATION && addr64 < 0x100000000ull && thread_ctrl::get_current() && handle_access_violation((u32)addr64, is_writing, pExp->ContextRecord))
 	{
 		return EXCEPTION_CONTINUE_EXECUTION;
 	}
@@ -1141,12 +1161,40 @@ const PVOID exception_handler = (atexit([]{ RemoveVectoredExceptionHandler(excep
 	{
 		return EXCEPTION_CONTINUE_SEARCH;
 	}
-}));
+});
 
-const auto exception_filter = SetUnhandledExceptionFilter([](PEXCEPTION_POINTERS pExp) -> LONG
+const auto g_exception_filter = SetUnhandledExceptionFilter([](PEXCEPTION_POINTERS pExp) -> LONG
 {
-	_se_translator(pExp->ExceptionRecord->ExceptionCode, pExp);
+	std::string msg = fmt::format("Unhandled Win32 exception 0x%08X.\n", pExp->ExceptionRecord->ExceptionCode);
 
+	if (pExp->ExceptionRecord->ExceptionCode == EXCEPTION_ACCESS_VIOLATION)
+	{
+		const u64 addr64 = pExp->ExceptionRecord->ExceptionInformation[1] - (u64)vm::base(0);
+		const auto cause = pExp->ExceptionRecord->ExceptionInformation[0] != 0 ? "writing" : "reading";
+
+		if (addr64 < 0x100000000ull)
+		{
+			// Setup throw_access_violation() call on the context
+			prepare_throw_access_violation(pExp->ContextRecord, cause, (u32)addr64);
+			return EXCEPTION_CONTINUE_EXECUTION;
+		}
+
+		msg += fmt::format("Access violation %s location %p at %p.\n", cause, pExp->ExceptionRecord->ExceptionInformation[1], pExp->ExceptionRecord->ExceptionAddress);
+	}
+	else
+	{
+		msg += fmt::format("Exception address: %p.\n", pExp->ExceptionRecord->ExceptionAddress);
+
+		for (DWORD i = 0; i < pExp->ExceptionRecord->NumberParameters; i++)
+		{
+			msg += fmt::format("ExceptionInformation[0x%x]: %p.\n", i, pExp->ExceptionRecord->ExceptionInformation[i]);
+		}
+	}
+
+	msg += fmt::format("Image base: %p.", GetModuleHandle(NULL));
+
+	// Report fatal error
+	report_fatal_error(msg);
 	return EXCEPTION_CONTINUE_SEARCH;
 });
 
@@ -1154,30 +1202,35 @@ const auto exception_filter = SetUnhandledExceptionFilter([](PEXCEPTION_POINTERS
 
 void signal_handler(int sig, siginfo_t* info, void* uct)
 {
-	const u64 addr64 = (u64)info->si_addr - (u64)vm::g_base_addr;
+	x64_context* context = (ucontext_t*)uct;
 
 #ifdef __APPLE__
-	const bool is_writing = ((ucontext_t*)uct)->uc_mcontext->__es.__err & 0x2;
+	const bool is_writing = context->uc_mcontext->__es.__err & 0x2;
 #else
-	const bool is_writing = ((ucontext_t*)uct)->uc_mcontext.gregs[REG_ERR] & 0x2;
+	const bool is_writing = context->uc_mcontext.gregs[REG_ERR] & 0x2;
 #endif
 
-	if ((u32)addr64 == addr64 && get_current_thread_ctrl())
+	const u64 addr64 = (u64)info->si_addr - (u64)vm::base(0);
+	const auto cause = is_writing ? "writing" : "reading";
+
+	if (addr64 < 0x100000000ull && thread_ctrl::get_current())
 	{
-		if (handle_access_violation((u32)addr64, is_writing, (ucontext_t*)uct))
+		// Try to process access violation
+		if (!handle_access_violation((u32)addr64, is_writing, context))
 		{
-			return; // proceed execution
+			// Setup throw_access_violation() call on the context
+			prepare_throw_access_violation(context, cause, (u32)addr64);
 		}
-
-		// TODO: this may be wrong
-		throw EXCEPTION("Access violation %s location 0x%llx", is_writing ? "writing" : "reading", addr64);
 	}
-
-	// else some fatal error
-	exit(EXIT_FAILURE);
+	else
+	{
+		// TODO (debugger interaction)
+		report_fatal_error(fmt::format("Access violation %s location %p at %p.", cause, info->si_addr, RIP(context)));
+		std::abort();
+	}
 }
 
-const int sigaction_result = []() -> int
+int setup_signal_handler()
 {
 	struct sigaction sa;
 
@@ -1185,107 +1238,120 @@ const int sigaction_result = []() -> int
 	sigemptyset(&sa.sa_mask);
 	sa.sa_sigaction = signal_handler;
 	return sigaction(SIGSEGV, &sa, NULL);
-}();
+}
+
+const int g_sigaction_result = setup_signal_handler();
 
 #endif
 
-thread_local thread_ctrl_t* g_tls_this_thread = nullptr;
+thread_local thread_ctrl* thread_ctrl::g_tls_this_thread = nullptr;
 
-const thread_ctrl_t* get_current_thread_ctrl()
-{
-	return g_tls_this_thread;
-}
+// TODO
+std::atomic<u32> g_thread_count{ 0 };
 
-std::string thread_ctrl_t::get_name() const
+void thread_ctrl::initialize()
 {
-	return m_name();
-}
+	SetCurrentThreadDebugName(g_tls_this_thread->m_name().c_str());
 
-named_thread_t::named_thread_t(std::function<std::string()> name, std::function<void()> func)
-{
-	start(std::move(name), func);
-}
-
-named_thread_t::~named_thread_t()
-{
-	if (m_thread)
+#ifdef _WIN32
+	if (!g_exception_handler || !g_exception_filter)
+#else
+	if (g_sigaction_result == -1)
+#endif
 	{
-		std::printf("Fatal: thread '%s' is neither joined nor detached\n", this->get_name().c_str());
-		std::terminate();
+		report_fatal_error("Exception handler is not set correctly.");
+		std::abort();
 	}
+
+	// TODO
+	g_thread_count++;
+}
+
+void thread_ctrl::finalize() noexcept
+{
+	// TODO
+	vm::reservation_free();
+
+	// TODO
+	g_thread_count--;
+
+	// Call atexit functions
+	for (const auto& func : decltype(m_atexit)(std::move(g_tls_this_thread->m_atexit)))
+	{
+		func();
+	}
+}
+
+thread_ctrl::~thread_ctrl()
+{
+	m_thread.detach();
+
+	if (m_future.valid())
+	{
+		try
+		{
+			m_future.get();
+		}
+		catch (...)
+		{
+			catch_all_exceptions();
+		}
+	}
+}
+
+std::string thread_ctrl::get_name() const
+{
+	CHECK_ASSERTION(m_name);
+
+	return m_name();
 }
 
 std::string named_thread_t::get_name() const
 {
-	if (!m_thread)
-	{
-		throw EXCEPTION("Invalid thread");
-	}
-
-	if (!m_thread->m_name)
-	{
-		throw EXCEPTION("Invalid name getter");
-	}
-
-	return m_thread->m_name();
+	return fmt::format("('%s') Unnamed Thread", typeid(*this).name());
 }
 
-std::atomic<u32> g_thread_count{ 0 };
-
-void named_thread_t::start(std::function<std::string()> name, std::function<void()> func)
+void named_thread_t::start()
 {
-	if (m_thread)
+	CHECK_ASSERTION(!m_thread);
+
+	// Get shared_ptr instance (will throw if called from the constructor or the object has been created incorrectly)
+	auto ptr = shared_from_this();
+
+	// Make name getter
+	auto name = [wptr = std::weak_ptr<named_thread_t>(ptr), type = &typeid(*this)]()
 	{
-		throw EXCEPTION("Thread already exists");
-	}
+		// Return actual name if available
+		if (const auto ptr = wptr.lock())
+		{
+			return ptr->get_name();
+		}
+		else
+		{
+			return fmt::format("('%s') Deleted Thread", type->name());
+		}
+	};
 
-	// create new thread control variable
-	m_thread = std::make_shared<thread_ctrl_t>(std::move(name));
-
-	// start thread
-	m_thread->m_thread = std::thread([](std::shared_ptr<thread_ctrl_t> ctrl, std::function<void()> func)
+	// Run thread
+	m_thread = thread_ctrl::spawn(std::move(name), [thread = std::move(ptr)]()
 	{
-		g_tls_this_thread = ctrl.get();
-
-		SetCurrentThreadDebugName(ctrl->get_name().c_str());
-
-#if defined(_MSC_VER)
-		_set_se_translator(_se_translator);
-#endif
-
-#ifdef _WIN32
-		if (!exception_handler || !exception_filter)
-		{
-			LOG_ERROR(GENERAL, "exception_handler not set");
-			return;
-		}
-#else
-		if (sigaction_result == -1)
-		{
-			printf("sigaction() failed");
-			exit(EXIT_FAILURE);
-		}
-#endif
-
 		try
 		{
-			g_thread_count++;
-
-			if (Ini.HLELogging.GetValue())
+			if (rpcs3::config.misc.log.hle_logging.value())
 			{
 				LOG_NOTICE(GENERAL, "Thread started");
 			}
 
-			func();
+			thread->on_task();
 
-			if (Ini.HLELogging.GetValue())
+			if (rpcs3::config.misc.log.hle_logging.value())
 			{
 				LOG_NOTICE(GENERAL, "Thread ended");
 			}
 		}
 		catch (const std::exception& e)
 		{
-			LOG_ERROR(GENERAL, "Exception: %s", e.what());
+			LOG_ERROR(GENERAL, "Exception: %s\nPlease report this to the developers.", e.what());
 			Emu.Pause();
 		}
 		catch (EmulationStopped)
@@ -1293,75 +1359,24 @@ void named_thread_t::start(std::function<std::string()> name, std::function<void
 			LOG_NOTICE(GENERAL, "Thread aborted");
 		}
 
-		for (auto& func : ctrl->m_atexit)
-		{
-			func();
-
-			func = nullptr;
-		}
-
-		vm::reservation_free();
-
-		g_thread_count--;
-
-	}, m_thread, std::move(func));
-}
-
-void named_thread_t::detach()
-{
-	if (!m_thread)
-	{
-		throw EXCEPTION("Invalid thread");
-	}
-
-	// +clear m_thread
-	const auto ctrl = std::move(m_thread);
-
-	// notify if detached by another thread
-	if (g_tls_this_thread != m_thread.get())
-	{
-		// lock for reliable notification
-		std::lock_guard<std::mutex> lock(mutex);
-
-		cv.notify_one();
-	}
-
-	ctrl->m_thread.detach();
+		thread->on_exit();
+	});
 }
 
 void named_thread_t::join()
 {
-	if (!m_thread)
+	CHECK_ASSERTION(m_thread != nullptr);
+
+	try
 	{
-		throw EXCEPTION("Invalid thread");
+		m_thread->join();
+		m_thread.reset();
 	}
-
-	if (g_tls_this_thread == m_thread.get())
+	catch (...)
 	{
-		throw EXCEPTION("Deadlock");
+		m_thread.reset();
+		throw;
 	}
-
-	// +clear m_thread
-	const auto ctrl = std::move(m_thread);
-
-	{
-		// lock for reliable notification
-		std::lock_guard<std::mutex> lock(mutex);
-
-		cv.notify_one();
-	}
-
-	ctrl->m_thread.join();
-}
-
-bool named_thread_t::is_current() const
-{
-	if (!m_thread)
-	{
-		throw EXCEPTION("Invalid thread");
-	}
-
-	return g_tls_this_thread == m_thread.get();
 }
 
 const std::function<bool()> SQUEUE_ALWAYS_EXIT = [](){ return true; };

Utilities/Thread.h

@@ -1,110 +1,175 @@
 #pragma once
 
-const class thread_ctrl_t* get_current_thread_ctrl();
+// Will report exception and call std::abort() if put in catch(...)
+[[noreturn]] void catch_all_exceptions();
 
-// named thread control class
-class thread_ctrl_t final
+// Thread control class
+class thread_ctrl final
 {
-	friend class named_thread_t;
+	static thread_local thread_ctrl* g_tls_this_thread;
 
-	template<typename T> friend void current_thread_register_atexit(T);
+	// Name getter
+	std::function<std::string()> m_name;
 
-	// thread handler
+	// Thread handle (be careful)
 	std::thread m_thread;
 
-	// name getter
-	const std::function<std::string()> m_name;
+	// Thread result
+	std::future<void> m_future;
 
-	// functions executed at thread exit (temporarily)
-	std::vector<std::function<void()>> m_atexit;
+	// Functions scheduled at thread exit
+	std::deque<std::function<void()>> m_atexit;
+
+	// Called at the thread start
+	static void initialize();
+
+	// Called at the thread end
+	static void finalize() noexcept;
 
 public:
-	thread_ctrl_t(std::function<std::string()> name)
-		: m_name(std::move(name))
+	template<typename T>
+	thread_ctrl(T&& name)
+		: m_name(std::forward<T>(name))
 	{
 	}
 
-	// get thread name
+	// Disable copy/move constructors and operators
+	thread_ctrl(const thread_ctrl&) = delete;
+
+	~thread_ctrl();
+
+	// Get thread name
 	std::string get_name() const;
+
+	// Get future result (may throw)
+	void join()
+	{
+		return m_future.get();
+	}
+
+	// Get current thread (may be nullptr)
+	static const thread_ctrl* get_current()
+	{
+		return g_tls_this_thread;
+	}
+
+	// Register function at thread exit (for the current thread)
+	template<typename T>
+	static inline void at_exit(T&& func)
+	{
+		CHECK_ASSERTION(g_tls_this_thread);
+
+		g_tls_this_thread->m_atexit.emplace_front(std::forward<T>(func));
+	}
+
+	// Named thread factory
+	template<typename N, typename F>
+	static inline std::shared_ptr<thread_ctrl> spawn(N&& name, F&& func)
+	{
+		auto ctrl = std::make_shared<thread_ctrl>(std::forward<N>(name));
+
+		std::promise<void> promise;
+
+		ctrl->m_future = promise.get_future();
+
+		ctrl->m_thread = std::thread([ctrl, task = std::forward<F>(func)](std::promise<void> promise)
+		{
+			g_tls_this_thread = ctrl.get();
+
+			try
+			{
+				initialize();
+				task();
+				finalize();
+				promise.set_value();
+			}
+			catch (...)
+			{
+				finalize();
+				promise.set_exception(std::current_exception());
+			}
+
+		}, std::move(promise));
+
+		return ctrl;
+	}
 };
 
-// register function at thread exit (temporarily)
-template<typename T> void current_thread_register_atexit(T func)
+class named_thread_t : public std::enable_shared_from_this<named_thread_t>
 {
-	extern thread_local thread_ctrl_t* g_tls_this_thread;
-
-	g_tls_this_thread->m_atexit.emplace_back(func);
-}
-
-class named_thread_t
-{
-	// pointer to managed resource (shared with actual thread)
-	std::shared_ptr<thread_ctrl_t> m_thread;
+	// Pointer to managed resource (shared with actual thread)
+	std::shared_ptr<thread_ctrl> m_thread;
 
 public:
-	// thread mutex for external use
-	std::mutex mutex;
-
-	// thread condition variable for external use
+	// Thread condition variable for external use (this thread waits on it, other threads may notify)
 	std::condition_variable cv;
 
+	// Thread mutex for external use (can be used with `cv`)
+	std::mutex mutex;
+
+protected:
+	// Thread task (called in the thread)
+	virtual void on_task() = 0;
+
+	// Thread finalization (called after on_task)
+	virtual void on_exit() {}
+
+	// ID initialization (called through id_aux_initialize)
+	virtual void on_id_aux_initialize() { start(); }
+
+	// ID finalization (called through id_aux_finalize)
+	virtual void on_id_aux_finalize() { join(); }
+
 public:
-	// initialize in empty state
 	named_thread_t() = default;
 
-	// create named thread
-	named_thread_t(std::function<std::string()> name, std::function<void()> func);
-
-	// destructor, will terminate if thread is neither joined nor detached
-	virtual ~named_thread_t();
+	virtual ~named_thread_t() = default;
 
+	// Deleted copy/move constructors + copy/move operators
 	named_thread_t(const named_thread_t&) = delete;
 
-	named_thread_t& operator =(const named_thread_t&) = delete;
+	// Get thread name
+	virtual std::string get_name() const;
 
-public:
-	// get thread name
-	std::string get_name() const;
+	// Start thread (cannot be called from the constructor: should throw bad_weak_ptr in such case)
+	void start();
 
-	// create named thread (current state must be empty)
-	void start(std::function<std::string()> name, std::function<void()> func);
-
-	// detach thread -> empty state
-	void detach();
-
-	// join thread -> empty state
+	// Join thread (get future result)
 	void join();
 
-	// check if not empty
-	bool joinable() const { return m_thread.operator bool(); }
+	// Check whether the thread is not in "empty state"
+	bool is_started() const { return m_thread.operator bool(); }
 
-	// check whether it is the current running thread
-	bool is_current() const;
+	// Compare with the current thread
+	bool is_current() const { CHECK_ASSERTION(m_thread); return thread_ctrl::get_current() == m_thread.get(); }
 
-	// get internal thread pointer
-	const thread_ctrl_t* get_thread_ctrl() const { return m_thread.get(); }
+	// Get thread_ctrl
+	const thread_ctrl* get_thread_ctrl() const { return m_thread.get(); }
+
+	friend void id_aux_initialize(named_thread_t* ptr) { ptr->on_id_aux_initialize(); }
+	friend void id_aux_finalize(named_thread_t* ptr) { ptr->on_id_aux_finalize(); }
 };
 
-class autojoin_thread_t final : private named_thread_t
+// Wrapper for named thread, joins automatically in the destructor, can only be used in function scope
+class scope_thread_t final
 {
-public:
-	using named_thread_t::mutex;
-	using named_thread_t::cv;
+	std::shared_ptr<thread_ctrl> m_thread;
 
 public:
-	autojoin_thread_t() = delete;
-
-	autojoin_thread_t(std::function<std::string()> name, std::function<void()> func)
+	template<typename N, typename F>
+	scope_thread_t(N&& name, F&& func)
+		: m_thread(thread_ctrl::spawn(std::forward<N>(name), std::forward<F>(func)))
 	{
-		start(std::move(name), std::move(func));
 	}
 
-	virtual ~autojoin_thread_t() override
-	{
-		join();
-	}
+	// Deleted copy/move constructors + copy/move operators
+	scope_thread_t(const scope_thread_t&) = delete;
 
-	using named_thread_t::is_current;
+	// Destructor with exceptions allowed
+	~scope_thread_t() noexcept(false)
+	{
+		m_thread->join();
+	}
 };
 
 extern const std::function<bool()> SQUEUE_ALWAYS_EXIT;

Utilities/VirtualMemory.cpp

@@ -1,4 +1,5 @@
 #include "stdafx.h"
+#include "Utilities/Log.h"
 #include "VirtualMemory.h"
 #ifdef _WIN32
 #include <Windows.h>
@@ -15,27 +16,30 @@ namespace memory_helper
 	void* reserve_memory(size_t size)
 	{
 #ifdef _WIN32
-		return VirtualAlloc(NULL, size, MEM_RESERVE, PAGE_NOACCESS);
+		void* ret = VirtualAlloc(NULL, size, MEM_RESERVE, PAGE_NOACCESS);
+		CHECK_ASSERTION(ret != NULL);
 #else
-		return mmap(nullptr, size, PROT_NONE, MAP_ANON | MAP_PRIVATE, -1, 0);
+		void* ret = mmap(nullptr, size, PROT_NONE, MAP_ANON | MAP_PRIVATE, -1, 0);
+		CHECK_ASSERTION(ret != 0);
 #endif
+		return ret;
 	}
 
 	void commit_page_memory(void* pointer, size_t page_size)
 	{
 #ifdef _WIN32
-		VirtualAlloc((u8*)pointer, page_size, MEM_COMMIT, PAGE_READWRITE);
+		CHECK_ASSERTION(VirtualAlloc((u8*)pointer, page_size, MEM_COMMIT, PAGE_READWRITE) != NULL);
 #else
-		mprotect((u8*)pointer, page_size, PROT_READ | PROT_WRITE);
+		CHECK_ASSERTION(mprotect((u8*)pointer, page_size, PROT_READ | PROT_WRITE) != -1);
 #endif
 	}
 
 	void free_reserved_memory(void* pointer, size_t size)
 	{
 #ifdef _WIN32
-		VirtualFree(pointer, 0, MEM_RELEASE);
+		CHECK_ASSERTION(VirtualFree(pointer, 0, MEM_RELEASE) != 0);
 #else
-		munmap(pointer, size);
+		CHECK_ASSERTION(munmap(pointer, size) == 0);
 #endif
 	}
-}
+}

Utilities/config_context.cpp

@@ -0,0 +1,172 @@
+#include "stdafx.h"
+#include "config_context.h"
+#include "StrFmt.h"
+#include <iostream>
+#include <sstream>
+
+void config_context_t::group::init()
+{
+	if(!m_cfg->m_groups[full_name()])
+		m_cfg->m_groups[full_name()] = this;
+}
+
+config_context_t::group::group(config_context_t* cfg, const std::string& name)
+	: m_cfg(cfg)
+	, m_name(name)
+	, m_parent(nullptr)
+{
+	init();
+}
+
+config_context_t::group::group(group* parent, const std::string& name)
+	: m_cfg(parent->m_cfg)
+	, m_name(name)
+	, m_parent(parent)
+{
+	init();
+}
+
+void config_context_t::group::set_parent(config_context_t* cfg)
+{
+	m_cfg = cfg;
+	init();
+}
+
+std::string config_context_t::group::name() const
+{
+	return m_name;
+}
+
+std::string config_context_t::group::full_name() const
+{
+	if (m_parent)
+		return m_parent->full_name() + "/" + m_name;
+
+	return m_name;
+}
+
+void config_context_t::assign(const config_context_t& rhs)
+{
+	for (auto &rhs_g : rhs.m_groups)
+	{
+		auto g = m_groups.at(rhs_g.first);
+
+		for (auto rhs_e : rhs_g.second->entries)
+		{
+			if (g->entries[rhs_e.first])
+				g->entries[rhs_e.first]->value_from(rhs_e.second);
+			else
+				g->add_entry(rhs_e.first, rhs_e.second->string_value());
+		}
+	}
+}
+
+void config_context_t::deserialize(std::istream& stream)
+{
+	set_defaults();
+
+	uint line_index = 0;
+	std::string line;
+	group *current_group = nullptr;
+
+	while (std::getline(stream, line))
+	{
+		++line_index;
+		line = fmt::trim(line);
+
+		if (line.empty())
+			continue;
+
+		if (line.front() == '[' && line.back() == ']')
+		{
+			std::string group_name = line.substr(1, line.length() - 2);
+
+			auto found = m_groups.find(group_name);
+
+			if (found == m_groups.end())
+			{
+				std::cerr << line_index << ": group '" << group_name << "' not exists. ignored" << std::endl;
+				current_group = nullptr;
+				continue;
+			}
+
+			current_group = found->second;
+			continue;
+		}
+
+		if (current_group == nullptr)
+		{
+			std::cerr << line_index << ": line '" << line << "' ignored, no group." << std::endl;
+			continue;
+		}
+
+		auto name_value = fmt::split(line, { "=" });
+		switch (name_value.size())
+		{
+		case 1:
+		{
+			if (current_group->entries[fmt::trim(name_value[0])])
+				current_group->entries[fmt::trim(name_value[0])]->string_value({});
+
+			else
+				current_group->add_entry(fmt::trim(name_value[0]), std::string{});
+		}
+		break;
+
+		default:
+			std::cerr << line_index << ": line '" << line << "' has more than one symbol '='. used only first" << std::endl;
+		case 2:
+		{
+			if (current_group->entries[fmt::trim(name_value[0])])
+				current_group->entries[fmt::trim(name_value[0])]->string_value(fmt::trim(name_value[1]));
+
+			else
+				current_group->add_entry(fmt::trim(name_value[0]), fmt::trim(name_value[1]));
+		}
+		break;
+
+		}
+	}
+}
+
+void config_context_t::serialize(std::ostream& stream) const
+{
+	for (auto &g : m_groups)
+	{
+		stream << "[" + g.first + "]" << std::endl;
+
+		for (auto &e : g.second->entries)
+		{
+			stream << e.first << "=" << e.second->string_value() << std::endl;
+		}
+
+		stream << std::endl;
+	}
+}
+
+void config_context_t::set_defaults()
+{
+	for (auto &g : m_groups)
+	{
+		for (auto &e : g.second->entries)
+		{
+			e.second->to_default();
+		}
+	}
+}
+
+std::string config_context_t::to_string() const
+{
+	std::ostringstream result;
+	
+	serialize(result);
+
+	return result.str();
+}
+
+void config_context_t::from_string(const std::string& str)
+{
+	std::istringstream source(str);
+
+	deserialize(source);
+}

Utilities/config_context.h

@@ -0,0 +1,163 @@
+#pragma once
+#include <unordered_map>
+#include <string>
+#include "convert.h"
+
+class config_context_t
+{
+public:
+	class entry_base;
+
+protected:
+	class group
+	{
+		group* m_parent;
+		config_context_t* m_cfg;
+		std::string m_name;
+		std::vector<std::unique_ptr<entry_base>> m_entries;
+
+		void init();
+
+	public:
+		std::unordered_map<std::string, entry_base *> entries;
+
+		group(config_context_t* cfg, const std::string& name);
+		group(group* parent, const std::string& name);
+		void set_parent(config_context_t* cfg);
+
+		std::string name() const;
+		std::string full_name() const;
+
+		template<typename T>
+		void add_entry(const std::string& name, const T& def_value)
+		{
+			m_entries.emplace_back(std::make_unique<entry<T>>(this, name, def_value));
+		}
+
+		template<typename T>
+		T get_entry_value(const std::string& name, const T& def_value)
+		{
+			if (!entries[name])
+				add_entry(name, def_value);
+
+			return convert::to<T>(entries[name]->string_value());
+		}
+
+		template<typename T>
+		void set_entry_value(const std::string& name, const T& value)
+		{
+			if (entries[name])
+				entries[name]->string_value(convert::to<std::string>(value));
+
+			else
+				add_entry(name, value);
+		}
+
+		friend config_context_t;
+	};
+
+public:
+	class entry_base
+	{
+	public:
+		virtual std::string name() = 0;
+		virtual void to_default() = 0;
+		virtual std::string string_value() = 0;
+		virtual void string_value(const std::string& value) = 0;
+		virtual void value_from(const entry_base* rhs) = 0;
+	};
+
+	template<typename T>
+	class entry : public entry_base
+	{
+		T m_default_value;
+		T m_value;
+		group* m_parent;
+		std::string m_name;
+
+	public:
+		entry(group* parent, const std::string& name, const T& default_value)
+			: m_parent(parent)
+			, m_name(name)
+			, m_default_value(default_value)
+			, m_value(default_value)
+		{
+			if(!parent->entries[name])
+				parent->entries[name] = this;
+		}
+
+		T default_value() const
+		{
+			return m_default_value;
+		}
+
+		T value() const
+		{
+			return m_value;
+		}
+
+		void value(const T& new_value)
+		{
+			m_value = new_value;
+		}
+
+		std::string name() override
+		{
+			return m_name;
+		}
+
+		void to_default() override
+		{
+			value(default_value());
+		}
+
+		std::string string_value() override
+		{
+			return convert::to<std::string>(value());
+		}
+
+		void string_value(const std::string &new_value) override
+		{
+			value(convert::to<T>(new_value));
+		}
+
+		void value_from(const entry_base* rhs) override
+		{
+			value(static_cast<const entry*>(rhs)->value());
+		}
+
+		entry& operator = (const T& new_value)
+		{
+			value(new_value);
+			return *this;
+		}
+
+		template<typename T2>
+		entry& operator = (const T2& new_value)
+		{
+			value(static_cast<T>(new_value));
+			return *this;
+		}
+
+		explicit operator const T&() const
+		{
+			return m_value;
+		}
+	};
+
+private:
+	std::unordered_map<std::string, group*> m_groups;
+
+public:
+	config_context_t() = default;
+
+	void assign(const config_context_t& rhs);
+
+	void serialize(std::ostream& stream) const;
+	void deserialize(std::istream& stream);
+
+	void set_defaults();
+
+	std::string to_string() const;
+	void from_string(const std::string&);
+};

Utilities/convert.h

@@ -0,0 +1,279 @@
+#pragma once
+#include <string>
+#include "types.h"
+
+namespace convert
+{
+	template<typename ReturnType, typename FromType>
+	struct to_impl_t;
+
+	template<typename Type>
+	struct to_impl_t<Type, Type>
+	{
+		static Type func(const Type& value)
+		{
+			return value;
+		}
+	};
+
+	template<>
+	struct to_impl_t<std::string, bool>
+	{
+		static std::string func(bool value)
+		{
+			return value ? "true" : "false";
+		}
+	};
+
+	template<>
+	struct to_impl_t<bool, std::string>
+	{
+		static bool func(const std::string& value)
+		{
+			return value == "true" ? true : false;
+		}
+	};
+
+	template<>
+	struct to_impl_t<std::string, char>
+	{
+		static std::string func(char value)
+		{
+			return std::to_string(value);
+		}
+	};
+
+	template<>
+	struct to_impl_t<std::string, unsigned char>
+	{
+		static std::string func(unsigned char value)
+		{
+			return std::to_string(value);
+		}
+	};
+
+
+	template<>
+	struct to_impl_t<std::string, short>
+	{
+		static std::string func(short value)
+		{
+			return std::to_string(value);
+		}
+	};
+
+	template<>
+	struct to_impl_t<std::string, unsigned short>
+	{
+		static std::string func(unsigned short value)
+		{
+			return std::to_string(value);
+		}
+	};
+
+	template<>
+	struct to_impl_t<std::string, int>
+	{
+		static std::string func(int value)
+		{
+			return std::to_string(value);
+		}
+	};
+
+	template<>
+	struct to_impl_t<std::string, unsigned int>
+	{
+		static std::string func(unsigned int value)
+		{
+			return std::to_string(value);
+		}
+	};
+
+	template<>
+	struct to_impl_t<std::string, long>
+	{
+		static std::string func(long value)
+		{
+			return std::to_string(value);
+		}
+	};
+
+	template<>
+	struct to_impl_t<std::string, unsigned long>
+	{
+		static std::string func(unsigned long value)
+		{
+			return std::to_string(value);
+		}
+	};
+
+	template<>
+	struct to_impl_t<std::string, long long>
+	{
+		static std::string func(long long value)
+		{
+			return std::to_string(value);
+		}
+	};
+
+	template<>
+	struct to_impl_t<std::string, unsigned long long>
+	{
+		static std::string func(unsigned long long value)
+		{
+			return std::to_string(value);
+		}
+	};
+
+	template<>
+	struct to_impl_t<std::string, float>
+	{
+		static std::string func(float value)
+		{
+			return std::to_string(value);
+		}
+	};
+
+	template<>
+	struct to_impl_t<std::string, double>
+	{
+		static std::string func(double value)
+		{
+			return std::to_string(value);
+		}
+	};
+
+	template<>
+	struct to_impl_t<std::string, long double>
+	{
+		static std::string func(long double value)
+		{
+			return std::to_string(value);
+		}
+	};
+
+	template<>
+	struct to_impl_t<std::string, size2i>
+	{
+		static std::string func(size2i value)
+		{
+			return std::to_string(value.width) + "x" + std::to_string(value.height);
+		}
+	};
+
+	template<>
+	struct to_impl_t<std::string, position2i>
+	{
+		static std::string func(position2i value)
+		{
+			return std::to_string(value.x) + ":" + std::to_string(value.y);
+		}
+	};
+
+	template<>
+	struct to_impl_t<int, std::string>
+	{
+		static int func(const std::string& value)
+		{
+			return std::stoi(value);
+		}
+	};
+
+	template<>
+	struct to_impl_t<unsigned int, std::string>
+	{
+		static unsigned int func(const std::string& value)
+		{
+			return (unsigned long)std::stoul(value);
+		}
+	};
+
+	template<>
+	struct to_impl_t<long, std::string>
+	{
+		static long func(const std::string& value)
+		{
+			return std::stol(value);
+		}
+	};
+
+	template<>
+	struct to_impl_t<unsigned long, std::string>
+	{
+		static unsigned long func(const std::string& value)
+		{
+			return std::stoul(value);
+		}
+	};
+
+	template<>
+	struct to_impl_t<long long, std::string>
+	{
+		static long long func(const std::string& value)
+		{
+			return std::stoll(value);
+		}
+	};
+
+	template<>
+	struct to_impl_t<unsigned long long, std::string>
+	{
+		static unsigned long long func(const std::string& value)
+		{
+			return std::stoull(value);
+		}
+	};
+
+	template<>
+	struct to_impl_t<float, std::string>
+	{
+		static float func(const std::string& value)
+		{
+			return std::stof(value);
+		}
+	};
+
+	template<>
+	struct to_impl_t<double, std::string>
+	{
+		static double func(const std::string& value)
+		{
+			return std::stod(value);
+		}
+	};
+
+	template<>
+	struct to_impl_t<long double, std::string>
+	{
+		static long double func(const std::string& value)
+		{
+			return std::stold(value);
+		}
+	};
+
+	template<>
+	struct to_impl_t<size2i, std::string>
+	{
+		static size2i func(const std::string& value)
+		{
+			const auto& data = fmt::split(value, { "x" });
+			return { std::stoi(data[0]), std::stoi(data[1]) };
+		}
+	};
+
+	template<>
+	struct to_impl_t<position2i, std::string>
+	{
+		static position2i func(const std::string& value)
+		{
+			const auto& data = fmt::split(value, { ":" });
+			return { std::stoi(data[0]), std::stoi(data[1]) };
+		}
+	};
+	
+	template<typename ReturnType, typename FromType>
+	ReturnType to(FromType value)
+	{
+		return to_impl_t<std::remove_all_extents_t<ReturnType>, std::remove_all_extents_t<FromType>>::func(value);
+	}
+}

Utilities/event.h

@@ -0,0 +1,420 @@
+#pragma once
+#include <functional>
+#include <deque>
+#include <list>
+
+enum class event_result
+{
+	skip,
+	handled
+};
+
+class events_queue
+{
+	std::deque<std::function<void()>> m_queue;
+
+public:
+	/*template<typename Type>
+	events_queue& operator += (event<Type> &evt)
+	{
+		evt.set_queue(this);
+		return *this;
+	}
+*/
+	void invoke(std::function<void()> function)
+	{
+		m_queue.push_back(function);
+	}
+
+	void flush()
+	{
+		while (!m_queue.empty())
+		{
+			std::function<void()> function = m_queue.front();
+			function();
+			m_queue.pop_front();
+		}
+	}
+};
+
+template<typename ...AT>
+class event
+{
+	using func_t = std::function<event_result(AT...)>;
+	using entry_t = typename std::list<func_t>::iterator;
+
+	std::list<func_t> handlers;
+	events_queue& m_queue;
+
+public:
+	event(events_queue* queue = nullptr) : m_queue(*queue)
+	{
+	}
+
+	void invoke(AT... args)
+	{
+		m_queue.invoke(std::bind([&](AT... eargs)
+		{
+			for (auto &&handler : handlers)
+			{
+				if (handler(eargs...) == event_result::handled)
+					break;
+			}
+		}, args...));
+	}
+
+	void operator()(AT... args)
+	{
+		invoke(args...);
+	}
+
+	entry_t bind(func_t func)
+	{
+		handlers.push_front(func);
+		return handlers.begin();
+	}
+
+	template<typename T>
+	entry_t bind(T *caller, event_result(T::*callback)(AT...))
+	{
+		return bind([=](AT... args) { return (caller->*callback)(args...); });
+	}
+
+	template<typename T>
+	entry_t bind(T *caller, void(T::*callback)(AT...))
+	{
+		return bind([=](AT... args) { (caller->*callback)(args...); return event_result::skip; });
+	}
+
+	void unbind(entry_t entry)
+	{
+		handlers.erase(entry);
+	}
+
+	entry_t operator +=(func_t func)
+	{
+		return bind(func);
+	}
+
+	void operator -=(entry_t what)
+	{
+		return unbind(what);
+	}
+};
+
+template<>
+class event<void>
+{
+	using func_t = std::function<event_result()>;
+	using entry_t = std::list<func_t>::iterator;
+
+	std::list<func_t> m_listeners;
+	events_queue* m_queue;
+
+	void invoke_listeners()
+	{
+		for (auto &&listener : m_listeners)
+		{
+			if (listener() == event_result::handled)
+				break;
+		}
+	}
+
+public:
+	event(events_queue* queue = nullptr) : m_queue(queue)
+	{
+	}
+
+	void invoke()
+	{
+		if (m_queue)
+			m_queue->invoke([=]() { invoke_listeners(); });
+		else
+			invoke_listeners();
+	}
+
+	void operator()()
+	{
+		invoke();
+	}
+
+	entry_t bind(func_t func)
+	{
+		m_listeners.push_front(func);
+		return m_listeners.begin();
+	}
+
+	template<typename T>
+	entry_t bind(T *caller, event_result(T::*callback)())
+	{
+		return bind([=]() { return (caller->*callback)(); });
+	}
+
+	template<typename T>
+	entry_t bind(T *caller, void(T::*callback)())
+	{
+		return bind([=]() { (caller->*callback)(); return event_result::skip; });
+	}
+
+	void unbind(entry_t what)
+	{
+		m_listeners.erase(what);
+	}
+
+	entry_t operator +=(func_t func)
+	{
+		return bind(func);
+	}
+
+	void operator -=(entry_t what)
+	{
+		return unbind(what);
+	}
+};
+
+class event_binder_t
+{
+	template<typename Type>
+	class binder_impl_t
+	{
+		event_binder_t *m_binder;
+		event<Type> *m_event;
+
+	public:
+		binder_impl_t(event_binder_t *binder, event<Type> *evt)
+			: m_binder(binder)
+			, m_event(evt)
+		{
+		}
+	};
+
+public:
+	template<typename Type>
+	binder_impl_t<Type> operator()(event<Type>& evt) const
+	{
+		return{ this, &evt };
+	}
+};
+
+template<typename T>
+class combined_data;
+
+template<typename T>
+class local_data
+{
+public:
+	using type = T;
+
+protected:
+	type m_data;
+
+	void set(type value)
+	{
+		m_data = value;
+	}
+
+	type get() const
+	{
+		return m_data;
+	}
+
+	bool equals(T value) const
+	{
+		return get() == value;
+	}
+
+	bool invoke_event(type value)
+	{
+		return false;
+	}
+
+	friend combined_data<T>;
+};
+
+template<typename T>
+class combined_data
+{
+public:
+	using type = T;
+
+protected:
+	local_data<type> m_local_data;
+	std::function<void(type)> m_invoke_event_function;
+	std::function<type()> m_get_function;
+
+	bool invoke_event(type value)
+	{
+		if (m_invoke_event_function)
+		{
+			m_invoke_event_function(value);
+			return true;
+		}
+
+		return false;
+	}
+
+	void set(type value)
+	{
+		m_local_data.set(value);
+	}
+
+	type get() const
+	{
+		if (m_get_function)
+		{
+			return m_get_function();
+		}
+
+		return m_local_data.get();
+	}
+
+	type get_local() const
+	{
+		return m_local_data.get();
+	}
+
+	bool equals(T value) const
+	{
+		return get_local() == value;
+	}
+
+public:
+	void invoke_event_function(std::function<void(type)> function)
+	{
+		m_invoke_event_function = function;
+	}
+
+	void get_function(std::function<type()> function)
+	{
+		m_get_function = function;
+	}
+};
+
+template<typename T, typename base_type_ = local_data<T>>
+class data_event : public base_type_
+{
+public:
+	using type = T;
+	using base_type = base_type_;
+
+protected:
+	event_result dochange(type new_value)
+	{
+		auto old_value = get();
+		base_type::set(new_value);
+		onchanged(old_value);
+		return event_result::handled;
+	}
+
+public:
+	event<type> onchange;
+	event<type> onchanged;
+
+	data_event(events_queue *queue = nullptr)
+		: onchange(queue)
+		, onchanged(queue)
+	{
+		onchange.bind(this, &data_event::dochange);
+		base_type::set({});
+	}
+
+	type get() const
+	{
+		return base_type::get();
+	}
+
+	type operator()() const
+	{
+		return get();
+	}
+
+	void change(type value, bool use_custom_invoke_event = true)
+	{
+		if (!base_type::equals(value))
+		{
+			if (!use_custom_invoke_event || !base_type::invoke_event(value))
+			{
+				onchange(value);
+			}
+		}
+	}
+
+	operator const type() const
+	{
+		return get();
+	}
+
+	operator type()
+	{
+		return get();
+	}
+
+	data_event& operator = (type value)
+	{
+		change(value);
+		return *this;
+	}
+
+	template<typename aType> auto operator + (aType value) const { return get() + value; }
+	template<typename aType> auto operator - (aType value) const { return get() - value; }
+	template<typename aType> auto operator * (aType value) const { return get() * value; }
+	template<typename aType> auto operator / (aType value) const { return get() / value; }
+	template<typename aType> auto operator % (aType value) const { return get() % value; }
+	template<typename aType> auto operator & (aType value) const { return get() & value; }
+	template<typename aType> auto operator | (aType value) const { return get() | value; }
+	template<typename aType> auto operator ^ (aType value) const { return get() ^ value; }
+
+	template<typename aType> data_event& operator += (aType value) { return *this = get() + value; }
+	template<typename aType> data_event& operator -= (aType value) { return *this = get() - value; }
+	template<typename aType> data_event& operator *= (aType value) { return *this = get() * value; }
+	template<typename aType> data_event& operator /= (aType value) { return *this = get() / value; }
+	template<typename aType> data_event& operator %= (aType value) { return *this = get() % value; }
+	template<typename aType> data_event& operator &= (aType value) { return *this = get() & value; }
+	template<typename aType> data_event& operator |= (aType value) { return *this = get() | value; }
+	template<typename aType> data_event& operator ^= (aType value) { return *this = get() ^ value; }
+
+	data_event& operator ++()
+	{
+		type value = get();
+		return *this = ++value;
+	}
+
+	type operator ++(int)
+	{
+		type value = get();
+		type result = value;
+		*this = value++;
+		return result;
+	}
+
+	data_event& operator --()
+	{
+		type value = get();
+		return *this = --value;
+	}
+
+	type operator --(int)
+	{
+		type value = get();
+		type result = value;
+		*this = value--;
+		return result;
+	}
+};
+
+struct with_event_binder
+{
+	event_binder_t event_binder;
+};
+
+struct test_obj
+{
+	void test(int)
+	{
+		event<int> i;
+		auto it = i.bind(this, &test_obj::test);
+		i(5);
+		i.unbind(it);
+		i(6);
+	}
+};

Utilities/git-version-gen.cmd

@@ -53,7 +53,8 @@ if errorlevel 1 (
 	goto done
 )
 
-for /F %%I IN ('call %GIT% describe --always') do set GIT_VERSION=%%I
+for /F %%I IN ('call %GIT% rev-list HEAD --count') do set GIT_VERSION=%%I
+for /F %%I IN ('call %GIT% rev-parse --short HEAD') do set GIT_VERSION=%GIT_VERSION%-%%I
 
 rem // Don't modify the file if it already has the current version.
 if exist "%GIT_VERSION_FILE%" (

Utilities/rMsgBox.cpp

@@ -1,38 +0,0 @@
-#include "stdafx.h"
-#include "restore_new.h"
-#pragma warning(push)
-#pragma message("TODO: remove wx dependency: <wx/msgdlg.h>")
-#pragma warning(disable : 4996)
-#include <wx/msgdlg.h>
-#pragma warning(pop)
-#include "define_new_memleakdetect.h"
-#include "rMsgBox.h"
-
-#ifndef QT_UI
-rMessageDialog::rMessageDialog(void *parent, const std::string& msg, const std::string& title , long style )
-{
-	handle = reinterpret_cast<void*>(new wxMessageDialog(
-		reinterpret_cast<wxWindow*>(parent)
-		, fmt::FromUTF8(msg)
-		, fmt::FromUTF8(title)
-		, style
-		));
-}
-
-rMessageDialog::~rMessageDialog()
-{
-	delete reinterpret_cast<wxMessageDialog*>(handle);
-}
-
-long rMessageDialog::ShowModal()
-{
-	return reinterpret_cast<wxMessageDialog*>(handle)->ShowModal();
-}
-
-long rMessageBox(const std::string& message, const std::string& title, long style)
-{
-	return wxMessageBox(fmt::FromUTF8(message), fmt::FromUTF8(title),style);
-}
-
-#endif
-

Utilities/rMsgBox.h

@@ -1,38 +0,0 @@
-#pragma once
-
-enum MsgBoxParams : unsigned long
-{
-	rYES_DEFAULT      = 0x0,
-	rOK_DEFAULT       = 0x0,
-	rCENTRE           = 0x1,
-	rYES              = 0x2, //res
-	rOK               = 0x4,
-	rNO               = 0x8, //res
-	rCANCEL           = 0x10,
-	rYES_NO           = 0xA,
-	rNO_DEFAULT       = 0x80,
-	rICON_EXCLAMATION = 0x100,
-	rICON_ERROR       = 0x200,
-	rICON_HAND        = 0x200,
-	rICON_QUESTION    = 0x400,
-	rICON_INFORMATION = 0x800,
-	rHELP             = 0x1000,
-	rID_CANCEL        = 0x13ED,
-	rID_YES           = 0x13EF, //resDialog
-	rSTAY_ON_TOP      = 0x8000,
-	rICON_NONE        = 0x40000,
-	rICON_AUTH_NEEDED = 0x80000,
-	rCANCEL_DEFAULT   = 0x80000000,
-};
-
-struct rMessageDialog
-{
-	rMessageDialog(void *parent, const std::string& msg, const std::string& title = "RPCS3", long style = rOK | rCENTRE);
-	rMessageDialog(const rMessageDialog& other) = delete;
-	~rMessageDialog();
-	long ShowModal();
-	void *handle;
-};
-
-long rMessageBox(const std::string& message, const std::string& title,long style);
-

Utilities/rPlatform.cpp

@@ -1,5 +1,6 @@
 #include "stdafx.h"
 #include "restore_new.h"
+#include "Utilities/Log.h"
 #pragma warning(push)
 #pragma message("TODO: remove wx dependency: <wx/image.h>")
 #pragma warning(disable : 4996)
@@ -9,6 +10,7 @@
 
 #ifndef _WIN32
 #include <dirent.h>
+#include <errno.h>
 #endif
 
 #include "rPlatform.h"
@@ -38,24 +40,3 @@ void rImage::SaveFile(const std::string& name, rImageType type)
 		throw EXCEPTION("unsupported type");
 	}
 }
-
-std::string rPlatform::getConfigDir()
-{
-	static std::string dir = ".";
-	if (dir == ".") {
-#ifdef _WIN32
-		dir = "";
-		//mkdir(dir.c_str());
-#else
-		if (getenv("XDG_CONFIG_HOME") != NULL)
-			dir = getenv("XDG_CONFIG_HOME");
-		else if (getenv("HOME") != NULL)
-			dir = getenv("HOME") + std::string("/.config");
-		else // Just in case
-			dir = "./config";
-		dir = dir + "/rpcs3/";
-		mkdir(dir.c_str(), 0777);
-#endif
-	}
-	return dir;
-}

Utilities/rPlatform.h

@@ -1,10 +1,5 @@
 #pragma once
 
-struct rPlatform
-{
-	static std::string getConfigDir();
-};
-
 /**********************************************************************
 *********** RSX Debugger
 ************************************************************************/

Utilities/simpleini/ConvertUTF.c

@@ -1,539 +0,0 @@
-/*
- * Copyright 2001-2004 Unicode, Inc.
- * 
- * Disclaimer
- * 
- * This source code is provided as is by Unicode, Inc. No claims are
- * made as to fitness for any particular purpose. No warranties of any
- * kind are expressed or implied. The recipient agrees to determine
- * applicability of information provided. If this file has been
- * purchased on magnetic or optical media from Unicode, Inc., the
- * sole remedy for any claim will be exchange of defective media
- * within 90 days of receipt.
- * 
- * Limitations on Rights to Redistribute This Code
- * 
- * Unicode, Inc. hereby grants the right to freely use the information
- * supplied in this file in the creation of products supporting the
- * Unicode Standard, and to make copies of this file in any form
- * for internal or external distribution as long as this notice
- * remains attached.
- */
-
-/* ---------------------------------------------------------------------
-
-    Conversions between UTF32, UTF-16, and UTF-8. Source code file.
-    Author: Mark E. Davis, 1994.
-    Rev History: Rick McGowan, fixes & updates May 2001.
-    Sept 2001: fixed const & error conditions per
-	mods suggested by S. Parent & A. Lillich.
-    June 2002: Tim Dodd added detection and handling of incomplete
-	source sequences, enhanced error detection, added casts
-	to eliminate compiler warnings.
-    July 2003: slight mods to back out aggressive FFFE detection.
-    Jan 2004: updated switches in from-UTF8 conversions.
-    Oct 2004: updated to use UNI_MAX_LEGAL_UTF32 in UTF-32 conversions.
-
-    See the header file "ConvertUTF.h" for complete documentation.
-
------------------------------------------------------------------------- */
-
-
-#include "ConvertUTF.h"
-#ifdef CVTUTF_DEBUG
-#include <stdio.h>
-#endif
-
-static const int halfShift  = 10; /* used for shifting by 10 bits */
-
-static const UTF32 halfBase = 0x0010000UL;
-static const UTF32 halfMask = 0x3FFUL;
-
-#define UNI_SUR_HIGH_START  (UTF32)0xD800
-#define UNI_SUR_HIGH_END    (UTF32)0xDBFF
-#define UNI_SUR_LOW_START   (UTF32)0xDC00
-#define UNI_SUR_LOW_END     (UTF32)0xDFFF
-#define false	   0
-#define true	    1
-
-/* --------------------------------------------------------------------- */
-
-ConversionResult ConvertUTF32toUTF16 (
-	const UTF32** sourceStart, const UTF32* sourceEnd, 
-	UTF16** targetStart, UTF16* targetEnd, ConversionFlags flags) {
-    ConversionResult result = conversionOK;
-    const UTF32* source = *sourceStart;
-    UTF16* target = *targetStart;
-    while (source < sourceEnd) {
-	UTF32 ch;
-	if (target >= targetEnd) {
-	    result = targetExhausted; break;
-	}
-	ch = *source++;
-	if (ch <= UNI_MAX_BMP) { /* Target is a character <= 0xFFFF */
-	    /* UTF-16 surrogate values are illegal in UTF-32; 0xffff or 0xfffe are both reserved values */
-	    if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_LOW_END) {
-		if (flags == strictConversion) {
-		    --source; /* return to the illegal value itself */
-		    result = sourceIllegal;
-		    break;
-		} else {
-		    *target++ = UNI_REPLACEMENT_CHAR;
-		}
-	    } else {
-		*target++ = (UTF16)ch; /* normal case */
-	    }
-	} else if (ch > UNI_MAX_LEGAL_UTF32) {
-	    if (flags == strictConversion) {
-		result = sourceIllegal;
-	    } else {
-		*target++ = UNI_REPLACEMENT_CHAR;
-	    }
-	} else {
-	    /* target is a character in range 0xFFFF - 0x10FFFF. */
-	    if (target + 1 >= targetEnd) {
-		--source; /* Back up source pointer! */
-		result = targetExhausted; break;
-	    }
-	    ch -= halfBase;
-	    *target++ = (UTF16)((ch >> halfShift) + UNI_SUR_HIGH_START);
-	    *target++ = (UTF16)((ch & halfMask) + UNI_SUR_LOW_START);
-	}
-    }
-    *sourceStart = source;
-    *targetStart = target;
-    return result;
-}
-
-/* --------------------------------------------------------------------- */
-
-ConversionResult ConvertUTF16toUTF32 (
-	const UTF16** sourceStart, const UTF16* sourceEnd, 
-	UTF32** targetStart, UTF32* targetEnd, ConversionFlags flags) {
-    ConversionResult result = conversionOK;
-    const UTF16* source = *sourceStart;
-    UTF32* target = *targetStart;
-    UTF32 ch, ch2;
-    while (source < sourceEnd) {
-	const UTF16* oldSource = source; /*  In case we have to back up because of target overflow. */
-	ch = *source++;
-	/* If we have a surrogate pair, convert to UTF32 first. */
-	if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_HIGH_END) {
-	    /* If the 16 bits following the high surrogate are in the source buffer... */
-	    if (source < sourceEnd) {
-		ch2 = *source;
-		/* If it's a low surrogate, convert to UTF32. */
-		if (ch2 >= UNI_SUR_LOW_START && ch2 <= UNI_SUR_LOW_END) {
-		    ch = ((ch - UNI_SUR_HIGH_START) << halfShift)
-			+ (ch2 - UNI_SUR_LOW_START) + halfBase;
-		    ++source;
-		} else if (flags == strictConversion) { /* it's an unpaired high surrogate */
-		    --source; /* return to the illegal value itself */
-		    result = sourceIllegal;
-		    break;
-		}
-	    } else { /* We don't have the 16 bits following the high surrogate. */
-		--source; /* return to the high surrogate */
-		result = sourceExhausted;
-		break;
-	    }
-	} else if (flags == strictConversion) {
-	    /* UTF-16 surrogate values are illegal in UTF-32 */
-	    if (ch >= UNI_SUR_LOW_START && ch <= UNI_SUR_LOW_END) {
-		--source; /* return to the illegal value itself */
-		result = sourceIllegal;
-		break;
-	    }
-	}
-	if (target >= targetEnd) {
-	    source = oldSource; /* Back up source pointer! */
-	    result = targetExhausted; break;
-	}
-	*target++ = ch;
-    }
-    *sourceStart = source;
-    *targetStart = target;
-#ifdef CVTUTF_DEBUG
-if (result == sourceIllegal) {
-    fprintf(stderr, "ConvertUTF16toUTF32 illegal seq 0x%04x,%04x\n", ch, ch2);
-    fflush(stderr);
-}
-#endif
-    return result;
-}
-
-/* --------------------------------------------------------------------- */
-
-/*
- * Index into the table below with the first byte of a UTF-8 sequence to
- * get the number of trailing bytes that are supposed to follow it.
- * Note that *legal* UTF-8 values can't have 4 or 5-bytes. The table is
- * left as-is for anyone who may want to do such conversion, which was
- * allowed in earlier algorithms.
- */
-static const char trailingBytesForUTF8[256] = {
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-    2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, 3,3,3,3,3,3,3,3,4,4,4,4,5,5,5,5
-};
-
-/*
- * Magic values subtracted from a buffer value during UTF8 conversion.
- * This table contains as many values as there might be trailing bytes
- * in a UTF-8 sequence.
- */
-static const UTF32 offsetsFromUTF8[6] = { 0x00000000UL, 0x00003080UL, 0x000E2080UL, 
-		     0x03C82080UL, 0xFA082080UL, 0x82082080UL };
-
-/*
- * Once the bits are split out into bytes of UTF-8, this is a mask OR-ed
- * into the first byte, depending on how many bytes follow.  There are
- * as many entries in this table as there are UTF-8 sequence types.
- * (I.e., one byte sequence, two byte... etc.). Remember that sequencs
- * for *legal* UTF-8 will be 4 or fewer bytes total.
- */
-static const UTF8 firstByteMark[7] = { 0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC };
-
-/* --------------------------------------------------------------------- */
-
-/* The interface converts a whole buffer to avoid function-call overhead.
- * Constants have been gathered. Loops & conditionals have been removed as
- * much as possible for efficiency, in favor of drop-through switches.
- * (See "Note A" at the bottom of the file for equivalent code.)
- * If your compiler supports it, the "isLegalUTF8" call can be turned
- * into an inline function.
- */
-
-/* --------------------------------------------------------------------- */
-
-ConversionResult ConvertUTF16toUTF8 (
-	const UTF16** sourceStart, const UTF16* sourceEnd, 
-	UTF8** targetStart, UTF8* targetEnd, ConversionFlags flags) {
-    ConversionResult result = conversionOK;
-    const UTF16* source = *sourceStart;
-    UTF8* target = *targetStart;
-    while (source < sourceEnd) {
-	UTF32 ch;
-	unsigned short bytesToWrite = 0;
-	const UTF32 byteMask = 0xBF;
-	const UTF32 byteMark = 0x80; 
-	const UTF16* oldSource = source; /* In case we have to back up because of target overflow. */
-	ch = *source++;
-	/* If we have a surrogate pair, convert to UTF32 first. */
-	if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_HIGH_END) {
-	    /* If the 16 bits following the high surrogate are in the source buffer... */
-	    if (source < sourceEnd) {
-		UTF32 ch2 = *source;
-		/* If it's a low surrogate, convert to UTF32. */
-		if (ch2 >= UNI_SUR_LOW_START && ch2 <= UNI_SUR_LOW_END) {
-		    ch = ((ch - UNI_SUR_HIGH_START) << halfShift)
-			+ (ch2 - UNI_SUR_LOW_START) + halfBase;
-		    ++source;
-		} else if (flags == strictConversion) { /* it's an unpaired high surrogate */
-		    --source; /* return to the illegal value itself */
-		    result = sourceIllegal;
-		    break;
-		}
-	    } else { /* We don't have the 16 bits following the high surrogate. */
-		--source; /* return to the high surrogate */
-		result = sourceExhausted;
-		break;
-	    }
-	} else if (flags == strictConversion) {
-	    /* UTF-16 surrogate values are illegal in UTF-32 */
-	    if (ch >= UNI_SUR_LOW_START && ch <= UNI_SUR_LOW_END) {
-		--source; /* return to the illegal value itself */
-		result = sourceIllegal;
-		break;
-	    }
-	}
-	/* Figure out how many bytes the result will require */
-	if (ch < (UTF32)0x80) {	     bytesToWrite = 1;
-	} else if (ch < (UTF32)0x800) {     bytesToWrite = 2;
-	} else if (ch < (UTF32)0x10000) {   bytesToWrite = 3;
-	} else if (ch < (UTF32)0x110000) {  bytesToWrite = 4;
-	} else {			    bytesToWrite = 3;
-					    ch = UNI_REPLACEMENT_CHAR;
-	}
-
-	target += bytesToWrite;
-	if (target > targetEnd) {
-	    source = oldSource; /* Back up source pointer! */
-	    target -= bytesToWrite; result = targetExhausted; break;
-	}
-	switch (bytesToWrite) { /* note: everything falls through. */
-	    case 4: *--target = (UTF8)((ch | byteMark) & byteMask); ch >>= 6;
-	    case 3: *--target = (UTF8)((ch | byteMark) & byteMask); ch >>= 6;
-	    case 2: *--target = (UTF8)((ch | byteMark) & byteMask); ch >>= 6;
-	    case 1: *--target =  (UTF8)(ch | firstByteMark[bytesToWrite]);
-	}
-	target += bytesToWrite;
-    }
-    *sourceStart = source;
-    *targetStart = target;
-    return result;
-}
-
-/* --------------------------------------------------------------------- */
-
-/*
- * Utility routine to tell whether a sequence of bytes is legal UTF-8.
- * This must be called with the length pre-determined by the first byte.
- * If not calling this from ConvertUTF8to*, then the length can be set by:
- *  length = trailingBytesForUTF8[*source]+1;
- * and the sequence is illegal right away if there aren't that many bytes
- * available.
- * If presented with a length > 4, this returns false.  The Unicode
- * definition of UTF-8 goes up to 4-byte sequences.
- */
-
-static Boolean isLegalUTF8(const UTF8 *source, int length) {
-    UTF8 a;
-    const UTF8 *srcptr = source+length;
-    switch (length) {
-    default: return false;
-	/* Everything else falls through when "true"... */
-    case 4: if ((a = (*--srcptr)) < 0x80 || a > 0xBF) return false;
-    case 3: if ((a = (*--srcptr)) < 0x80 || a > 0xBF) return false;
-    case 2: if ((a = (*--srcptr)) > 0xBF) return false;
-
-	switch (*source) {
-	    /* no fall-through in this inner switch */
-	    case 0xE0: if (a < 0xA0) return false; break;
-	    case 0xED: if (a > 0x9F) return false; break;
-	    case 0xF0: if (a < 0x90) return false; break;
-	    case 0xF4: if (a > 0x8F) return false; break;
-	    default:   if (a < 0x80) return false;
-	}
-
-    case 1: if (*source >= 0x80 && *source < 0xC2) return false;
-    }
-    if (*source > 0xF4) return false;
-    return true;
-}
-
-/* --------------------------------------------------------------------- */
-
-/*
- * Exported function to return whether a UTF-8 sequence is legal or not.
- * This is not used here; it's just exported.
- */
-Boolean isLegalUTF8Sequence(const UTF8 *source, const UTF8 *sourceEnd) {
-    int length = trailingBytesForUTF8[*source]+1;
-    if (source+length > sourceEnd) {
-	return false;
-    }
-    return isLegalUTF8(source, length);
-}
-
-/* --------------------------------------------------------------------- */
-
-ConversionResult ConvertUTF8toUTF16 (
-	const UTF8** sourceStart, const UTF8* sourceEnd, 
-	UTF16** targetStart, UTF16* targetEnd, ConversionFlags flags) {
-    ConversionResult result = conversionOK;
-    const UTF8* source = *sourceStart;
-    UTF16* target = *targetStart;
-    while (source < sourceEnd) {
-	UTF32 ch = 0;
-	unsigned short extraBytesToRead = trailingBytesForUTF8[*source];
-	if (source + extraBytesToRead >= sourceEnd) {
-	    result = sourceExhausted; break;
-	}
-	/* Do this check whether lenient or strict */
-	if (! isLegalUTF8(source, extraBytesToRead+1)) {
-	    result = sourceIllegal;
-	    break;
-	}
-	/*
-	 * The cases all fall through. See "Note A" below.
-	 */
-	switch (extraBytesToRead) {
-	    case 5: ch += *source++; ch <<= 6; /* remember, illegal UTF-8 */
-	    case 4: ch += *source++; ch <<= 6; /* remember, illegal UTF-8 */
-	    case 3: ch += *source++; ch <<= 6;
-	    case 2: ch += *source++; ch <<= 6;
-	    case 1: ch += *source++; ch <<= 6;
-	    case 0: ch += *source++;
-	}
-	ch -= offsetsFromUTF8[extraBytesToRead];
-
-	if (target >= targetEnd) {
-	    source -= (extraBytesToRead+1); /* Back up source pointer! */
-	    result = targetExhausted; break;
-	}
-	if (ch <= UNI_MAX_BMP) { /* Target is a character <= 0xFFFF */
-	    /* UTF-16 surrogate values are illegal in UTF-32 */
-	    if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_LOW_END) {
-		if (flags == strictConversion) {
-		    source -= (extraBytesToRead+1); /* return to the illegal value itself */
-		    result = sourceIllegal;
-		    break;
-		} else {
-		    *target++ = UNI_REPLACEMENT_CHAR;
-		}
-	    } else {
-		*target++ = (UTF16)ch; /* normal case */
-	    }
-	} else if (ch > UNI_MAX_UTF16) {
-	    if (flags == strictConversion) {
-		result = sourceIllegal;
-		source -= (extraBytesToRead+1); /* return to the start */
-		break; /* Bail out; shouldn't continue */
-	    } else {
-		*target++ = UNI_REPLACEMENT_CHAR;
-	    }
-	} else {
-	    /* target is a character in range 0xFFFF - 0x10FFFF. */
-	    if (target + 1 >= targetEnd) {
-		source -= (extraBytesToRead+1); /* Back up source pointer! */
-		result = targetExhausted; break;
-	    }
-	    ch -= halfBase;
-	    *target++ = (UTF16)((ch >> halfShift) + UNI_SUR_HIGH_START);
-	    *target++ = (UTF16)((ch & halfMask) + UNI_SUR_LOW_START);
-	}
-    }
-    *sourceStart = source;
-    *targetStart = target;
-    return result;
-}
-
-/* --------------------------------------------------------------------- */
-
-ConversionResult ConvertUTF32toUTF8 (
-	const UTF32** sourceStart, const UTF32* sourceEnd, 
-	UTF8** targetStart, UTF8* targetEnd, ConversionFlags flags) {
-    ConversionResult result = conversionOK;
-    const UTF32* source = *sourceStart;
-    UTF8* target = *targetStart;
-    while (source < sourceEnd) {
-	UTF32 ch;
-	unsigned short bytesToWrite = 0;
-	const UTF32 byteMask = 0xBF;
-	const UTF32 byteMark = 0x80; 
-	ch = *source++;
-	if (flags == strictConversion ) {
-	    /* UTF-16 surrogate values are illegal in UTF-32 */
-	    if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_LOW_END) {
-		--source; /* return to the illegal value itself */
-		result = sourceIllegal;
-		break;
-	    }
-	}
-	/*
-	 * Figure out how many bytes the result will require. Turn any
-	 * illegally large UTF32 things (> Plane 17) into replacement chars.
-	 */
-	if (ch < (UTF32)0x80) {	     bytesToWrite = 1;
-	} else if (ch < (UTF32)0x800) {     bytesToWrite = 2;
-	} else if (ch < (UTF32)0x10000) {   bytesToWrite = 3;
-	} else if (ch <= UNI_MAX_LEGAL_UTF32) {  bytesToWrite = 4;
-	} else {			    bytesToWrite = 3;
-					    ch = UNI_REPLACEMENT_CHAR;
-					    result = sourceIllegal;
-	}
-	
-	target += bytesToWrite;
-	if (target > targetEnd) {
-	    --source; /* Back up source pointer! */
-	    target -= bytesToWrite; result = targetExhausted; break;
-	}
-	switch (bytesToWrite) { /* note: everything falls through. */
-	    case 4: *--target = (UTF8)((ch | byteMark) & byteMask); ch >>= 6;
-	    case 3: *--target = (UTF8)((ch | byteMark) & byteMask); ch >>= 6;
-	    case 2: *--target = (UTF8)((ch | byteMark) & byteMask); ch >>= 6;
-	    case 1: *--target = (UTF8) (ch | firstByteMark[bytesToWrite]);
-	}
-	target += bytesToWrite;
-    }
-    *sourceStart = source;
-    *targetStart = target;
-    return result;
-}
-
-/* --------------------------------------------------------------------- */
-
-ConversionResult ConvertUTF8toUTF32 (
-	const UTF8** sourceStart, const UTF8* sourceEnd, 
-	UTF32** targetStart, UTF32* targetEnd, ConversionFlags flags) {
-    ConversionResult result = conversionOK;
-    const UTF8* source = *sourceStart;
-    UTF32* target = *targetStart;
-    while (source < sourceEnd) {
-	UTF32 ch = 0;
-	unsigned short extraBytesToRead = trailingBytesForUTF8[*source];
-	if (source + extraBytesToRead >= sourceEnd) {
-	    result = sourceExhausted; break;
-	}
-	/* Do this check whether lenient or strict */
-	if (! isLegalUTF8(source, extraBytesToRead+1)) {
-	    result = sourceIllegal;
-	    break;
-	}
-	/*
-	 * The cases all fall through. See "Note A" below.
-	 */
-	switch (extraBytesToRead) {
-	    case 5: ch += *source++; ch <<= 6;
-	    case 4: ch += *source++; ch <<= 6;
-	    case 3: ch += *source++; ch <<= 6;
-	    case 2: ch += *source++; ch <<= 6;
-	    case 1: ch += *source++; ch <<= 6;
-	    case 0: ch += *source++;
-	}
-	ch -= offsetsFromUTF8[extraBytesToRead];
-
-	if (target >= targetEnd) {
-	    source -= (extraBytesToRead+1); /* Back up the source pointer! */
-	    result = targetExhausted; break;
-	}
-	if (ch <= UNI_MAX_LEGAL_UTF32) {
-	    /*
-	     * UTF-16 surrogate values are illegal in UTF-32, and anything
-	     * over Plane 17 (> 0x10FFFF) is illegal.
-	     */
-	    if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_LOW_END) {
-		if (flags == strictConversion) {
-		    source -= (extraBytesToRead+1); /* return to the illegal value itself */
-		    result = sourceIllegal;
-		    break;
-		} else {
-		    *target++ = UNI_REPLACEMENT_CHAR;
-		}
-	    } else {
-		*target++ = ch;
-	    }
-	} else { /* i.e., ch > UNI_MAX_LEGAL_UTF32 */
-	    result = sourceIllegal;
-	    *target++ = UNI_REPLACEMENT_CHAR;
-	}
-    }
-    *sourceStart = source;
-    *targetStart = target;
-    return result;
-}
-
-/* ---------------------------------------------------------------------
-
-    Note A.
-    The fall-through switches in UTF-8 reading code save a
-    temp variable, some decrements & conditionals.  The switches
-    are equivalent to the following loop:
-	{
-	    int tmpBytesToRead = extraBytesToRead+1;
-	    do {
-		ch += *source++;
-		--tmpBytesToRead;
-		if (tmpBytesToRead) ch <<= 6;
-	    } while (tmpBytesToRead > 0);
-	}
-    In UTF-8 writing code, the switches on "bytesToWrite" are
-    similarly unrolled loops.
-
-   --------------------------------------------------------------------- */

Utilities/simpleini/ConvertUTF.h

@@ -1,151 +0,0 @@
-#pragma once
-
-/*
- * Copyright 2001-2004 Unicode, Inc.
- * 
- * Disclaimer
- * 
- * This source code is provided as is by Unicode, Inc. No claims are
- * made as to fitness for any particular purpose. No warranties of any
- * kind are expressed or implied. The recipient agrees to determine
- * applicability of information provided. If this file has been
- * purchased on magnetic or optical media from Unicode, Inc., the
- * sole remedy for any claim will be exchange of defective media
- * within 90 days of receipt.
- * 
- * Limitations on Rights to Redistribute This Code
- * 
- * Unicode, Inc. hereby grants the right to freely use the information
- * supplied in this file in the creation of products supporting the
- * Unicode Standard, and to make copies of this file in any form
- * for internal or external distribution as long as this notice
- * remains attached.
- */
-
-/* ---------------------------------------------------------------------
-
-    Conversions between UTF32, UTF-16, and UTF-8.  Header file.
-
-    Several funtions are included here, forming a complete set of
-    conversions between the three formats.  UTF-7 is not included
-    here, but is handled in a separate source file.
-
-    Each of these routines takes pointers to input buffers and output
-    buffers.  The input buffers are const.
-
-    Each routine converts the text between *sourceStart and sourceEnd,
-    putting the result into the buffer between *targetStart and
-    targetEnd. Note: the end pointers are *after* the last item: e.g. 
-    *(sourceEnd - 1) is the last item.
-
-    The return result indicates whether the conversion was successful,
-    and if not, whether the problem was in the source or target buffers.
-    (Only the first encountered problem is indicated.)
-
-    After the conversion, *sourceStart and *targetStart are both
-    updated to point to the end of last text successfully converted in
-    the respective buffers.
-
-    Input parameters:
-	sourceStart - pointer to a pointer to the source buffer.
-		The contents of this are modified on return so that
-		it points at the next thing to be converted.
-	targetStart - similarly, pointer to pointer to the target buffer.
-	sourceEnd, targetEnd - respectively pointers to the ends of the
-		two buffers, for overflow checking only.
-
-    These conversion functions take a ConversionFlags argument. When this
-    flag is set to strict, both irregular sequences and isolated surrogates
-    will cause an error.  When the flag is set to lenient, both irregular
-    sequences and isolated surrogates are converted.
-
-    Whether the flag is strict or lenient, all illegal sequences will cause
-    an error return. This includes sequences such as: <F4 90 80 80>, <C0 80>,
-    or <A0> in UTF-8, and values above 0x10FFFF in UTF-32. Conformant code
-    must check for illegal sequences.
-
-    When the flag is set to lenient, characters over 0x10FFFF are converted
-    to the replacement character; otherwise (when the flag is set to strict)
-    they constitute an error.
-
-    Output parameters:
-	The value "sourceIllegal" is returned from some routines if the input
-	sequence is malformed.  When "sourceIllegal" is returned, the source
-	value will point to the illegal value that caused the problem. E.g.,
-	in UTF-8 when a sequence is malformed, it points to the start of the
-	malformed sequence.  
-
-    Author: Mark E. Davis, 1994.
-    Rev History: Rick McGowan, fixes & updates May 2001.
-		 Fixes & updates, Sept 2001.
-
------------------------------------------------------------------------- */
-
-/* ---------------------------------------------------------------------
-    The following 4 definitions are compiler-specific.
-    The C standard does not guarantee that wchar_t has at least
-    16 bits, so wchar_t is no less portable than unsigned short!
-    All should be unsigned values to avoid sign extension during
-    bit mask & shift operations.
------------------------------------------------------------------------- */
-
-typedef unsigned int	UTF32;	/* at least 32 bits */
-typedef unsigned short	UTF16;	/* at least 16 bits */
-typedef unsigned char	UTF8;	/* typically 8 bits */
-typedef unsigned char	Boolean; /* 0 or 1 */
-
-/* Some fundamental constants */
-#define UNI_REPLACEMENT_CHAR (UTF32)0x0000FFFD
-#define UNI_MAX_BMP (UTF32)0x0000FFFF
-#define UNI_MAX_UTF16 (UTF32)0x0010FFFF
-#define UNI_MAX_UTF32 (UTF32)0x7FFFFFFF
-#define UNI_MAX_LEGAL_UTF32 (UTF32)0x0010FFFF
-
-typedef enum {
-	conversionOK, 		/* conversion successful */
-	sourceExhausted,	/* partial character in source, but hit end */
-	targetExhausted,	/* insuff. room in target for conversion */
-	sourceIllegal		/* source sequence is illegal/malformed */
-} ConversionResult;
-
-typedef enum {
-	strictConversion = 0,
-	lenientConversion
-} ConversionFlags;
-
-/* This is for C++ and does no harm in C */
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-ConversionResult ConvertUTF8toUTF16 (
-		const UTF8** sourceStart, const UTF8* sourceEnd, 
-		UTF16** targetStart, UTF16* targetEnd, ConversionFlags flags);
-
-ConversionResult ConvertUTF16toUTF8 (
-		const UTF16** sourceStart, const UTF16* sourceEnd, 
-		UTF8** targetStart, UTF8* targetEnd, ConversionFlags flags);
-		
-ConversionResult ConvertUTF8toUTF32 (
-		const UTF8** sourceStart, const UTF8* sourceEnd, 
-		UTF32** targetStart, UTF32* targetEnd, ConversionFlags flags);
-
-ConversionResult ConvertUTF32toUTF8 (
-		const UTF32** sourceStart, const UTF32* sourceEnd, 
-		UTF8** targetStart, UTF8* targetEnd, ConversionFlags flags);
-		
-ConversionResult ConvertUTF16toUTF32 (
-		const UTF16** sourceStart, const UTF16* sourceEnd, 
-		UTF32** targetStart, UTF32* targetEnd, ConversionFlags flags);
-
-ConversionResult ConvertUTF32toUTF16 (
-		const UTF32** sourceStart, const UTF32* sourceEnd, 
-		UTF16** targetStart, UTF16* targetEnd, ConversionFlags flags);
-
-Boolean isLegalUTF8Sequence(const UTF8 *source, const UTF8 *sourceEnd);
-
-#ifdef __cplusplus
-}
-#endif
-
-/* --------------------------------------------------------------------- */

Utilities/simpleini/LICENCE.txt

@@ -1,20 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2006-2013 Brodie Thiesfield
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of
-this software and associated documentation files (the "Software"), to deal in
-the Software without restriction, including without limitation the rights to
-use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
-the Software, and to permit persons to whom the Software is furnished to do so,
-subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
-FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
-COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
-IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

Utilities/simpleini/README.md

@@ -1,150 +0,0 @@
-simpleini
-=========
-
-A cross-platform library that provides a simple API to read and write INI-style configuration files. It supports data files in ASCII, MBCS and Unicode. It is designed explicitly to be portable to any platform and has been tested on Windows, WinCE and Linux. Released as open-source and free using the MIT licence.
-
-# Feature Summary
-
-- MIT Licence allows free use in all software (including GPL and commercial)
-- multi-platform (Windows 95/98/ME/NT/2K/XP/2003, Windows CE, Linux, Unix)
-- loading and saving of INI-style configuration files
-- configuration files can have any newline format on all platforms
-- liberal acceptance of file format
-  * key/values with no section
-  * removal of whitespace around sections, keys and values
-- support for multi-line values (values with embedded newline characters)
-- optional support for multiple keys with the same name
-- optional case-insensitive sections and keys (for ASCII characters only)
-- saves files with sections and keys in the same order as they were loaded
-- preserves comments on the file, section and keys where possible.
-- supports both char or wchar_t programming interfaces
-- supports both MBCS (system locale) and UTF-8 file encodings
-- system locale does not need to be UTF-8 on Linux/Unix to load UTF-8 file
-- support for non-ASCII characters in section, keys, values and comments
-- support for non-standard character types or file encodings via user-written converter classes
-- support for adding/modifying values programmatically
-- compiles cleanly in the following compilers:
-  * Windows/VC6 (warning level 3)
-  * Windows/VC.NET 2003 (warning level 4)
-  * Windows/VC 2005 (warning level 4)
-  * Linux/gcc (-Wall)
-  * Windows/MinGW GCC
-
-# Documentation
-
-Full documentation of the interface is available in doxygen format.
-
-# Examples
-
-These snippets are included with the distribution in the file snippets.cpp.
-
-### SIMPLE USAGE
-
-```c++
-CSimpleIniA ini;
-ini.SetUnicode();
-ini.LoadFile("myfile.ini");
-const char * pVal = ini.GetValue("section", "key", "default");
-ini.SetValue("section", "key", "newvalue");
-```
-
-### LOADING DATA
-
-```c++
-// load from a data file
-CSimpleIniA ini(a_bIsUtf8, a_bUseMultiKey, a_bUseMultiLine);
-SI_Error rc = ini.LoadFile(a_pszFile);
-if (rc < 0) return false;
-
-// load from a string
-std::string strData;
-rc = ini.LoadData(strData.c_str(), strData.size());
-if (rc < 0) return false;
-```
-
-### GETTING SECTIONS AND KEYS
-
-```c++
-// get all sections
-CSimpleIniA::TNamesDepend sections;
-ini.GetAllSections(sections);
-
-// get all keys in a section
-CSimpleIniA::TNamesDepend keys;
-ini.GetAllKeys("section-name", keys);
-```
-
-### GETTING VALUES
-
-```c++
-// get the value of a key
-const char * pszValue = ini.GetValue("section-name", 
-    "key-name", NULL /*default*/);
-
-// get the value of a key which may have multiple 
-// values. If bHasMultipleValues is true, then just 
-// one value has been returned
-bool bHasMultipleValues;
-pszValue = ini.GetValue("section-name", "key-name", 
-    NULL /*default*/, &amp;bHasMultipleValues);
-
-// get all values of a key with multiple values
-CSimpleIniA::TNamesDepend values;
-ini.GetAllValues("section-name", "key-name", values);
-
-// sort the values into the original load order
-values.sort(CSimpleIniA::Entry::LoadOrder());
-
-// output all of the items
-CSimpleIniA::TNamesDepend::const_iterator i;
-for (i = values.begin(); i != values.end(); ++i) { 
-    printf("key-name = '%s'\n", i->pItem);
-}
-```
-
-### MODIFYING DATA
-
-```c++
-// adding a new section
-rc = ini.SetValue("new-section", NULL, NULL);
-if (rc < 0) return false;
-printf("section: %s\n", rc == SI_INSERTED ? 
-    "inserted" : "updated");
-
-// adding a new key ("new-section" will be added 
-// automatically if it doesn't already exist)
-rc = ini.SetValue("new-section", "new-key", "value");
-if (rc < 0) return false;
-printf("key: %s\n", rc == SI_INSERTED ? 
-    "inserted" : "updated");
-
-// changing the value of a key
-rc = ini.SetValue("section", "key", "updated-value");
-if (rc < 0) return false;
-printf("key: %s\n", rc == SI_INSERTED ? 
-    "inserted" : "updated");
-```
-
-### DELETING DATA
-
-```c++
-// deleting a key from a section. Optionally the entire
-// section may be deleted if it is now empty.
-ini.Delete("section-name", "key-name", 
-    true /*delete the section if empty*/);
-
-// deleting an entire section and all keys in it
-ini.Delete("section-name", NULL);
-```
-
-### SAVING DATA
-
-```c++
-// save the data to a string
-rc = ini.Save(strData);
-if (rc < 0) return false;
-
-// save the data back to the file
-rc = ini.SaveFile(a_pszFile);
-if (rc < 0) return false;
-```

appveyor.yml

@@ -14,7 +14,7 @@ branches:
 
 before_build:
  # until git for win 2.5 release with commit checkout
- - git submodule update --init ffmpeg asmjit minidx9
+ - git submodule update --init ffmpeg asmjit minidx9 rsx_program_decompiler
  - 7z x wxWidgets.7z -aos -oC:\rpcs3\wxWidgets > null
  - if %configuration%==Release (cmake -G "Visual Studio 14 Win64")
    else (7z x llvmlibs.7z -aos -oC:\rpcs3 > null && cmake -G "Visual Studio 14 Win64" -DLLVM_DIR=C:/rpcs3/llvm_build/share/llvm/cmake)

asmjitsrc/asmjit.vcxproj

@@ -68,6 +68,7 @@
   <PropertyGroup Label="Globals">
     <ProjectGuid>{AC40FF01-426E-4838-A317-66354CEFAE88}</ProjectGuid>
     <RootNamespace>asmjit</RootNamespace>
+    <WindowsTargetPlatformVersion>8.1</WindowsTargetPlatformVersion>
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
@@ -80,7 +81,6 @@
     <ConfigurationType>StaticLibrary</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
     <PlatformToolset>v140</PlatformToolset>
-    <WholeProgramOptimization>true</WholeProgramOptimization>
     <CharacterSet>Unicode</CharacterSet>
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
@@ -94,12 +94,12 @@
   </ImportGroup>
   <PropertyGroup Label="UserMacros" />
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
-    <OutDir>$(SolutionDir)libs\$(Configuration)\</OutDir>
+    <OutDir>$(SolutionDir)lib\$(Configuration)-$(Platform)\</OutDir>
     <IntDir>
     </IntDir>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
-    <OutDir>$(SolutionDir)libs\$(Configuration)\</OutDir>
+    <OutDir>$(SolutionDir)lib\$(Configuration)-$(Platform)\</OutDir>
     <IntDir>
     </IntDir>
   </PropertyGroup>

glm/CMakeLists.txt

@@ -0,0 +1,146 @@
+cmake_minimum_required(VERSION 2.6 FATAL_ERROR)
+
+project(glm)
+enable_testing()
+
+list(APPEND CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/cmake")
+include(GNUInstallDirs)
+
+add_definitions(-D_CRT_SECURE_NO_WARNINGS)
+
+option(GLM_TEST_ENABLE "GLM test" OFF)
+if(NOT GLM_TEST_ENABLE)
+	message(STATUS "GLM is a header only library, no need to build it. Set the option GLM_TEST_ENABLE with ON to build and run the test bench")
+endif()
+
+if(("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang") OR ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU") OR (("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Intel") AND UNIX))
+	option(GLM_TEST_ENABLE_CXX_98 "Enable C++ 98" OFF)
+	option(GLM_TEST_ENABLE_CXX_0X "Enable C++ 0x" OFF)
+	option(GLM_TEST_ENABLE_CXX_11 "Enable C++ 11" OFF)
+	option(GLM_TEST_ENABLE_CXX_1Y "Enable C++ 1y" OFF)
+	option(GLM_TEST_ENABLE_CXX_14 "Enable C++ 14" OFF)
+	option(GLM_TEST_ENABLE_CXX_1Z "Enable C++ 1z" OFF)
+
+	if(GLM_TEST_ENABLE_CXX_1Z)
+		set(CMAKE_XCODE_ATTRIBUTE_CLANG_CXX_LANGUAGE_STANDARD "c++1z")
+		set(CMAKE_XCODE_ATTRIBUTE_CLANG_CXX_LIBRARY "libc++")
+		set(CMAKE_CXX_FLAGS "-std=c++1Z")
+	elseif(GLM_TEST_ENABLE_CXX_14)
+		set(CMAKE_XCODE_ATTRIBUTE_CLANG_CXX_LANGUAGE_STANDARD "c++14")
+		set(CMAKE_XCODE_ATTRIBUTE_CLANG_CXX_LIBRARY "libc++")
+		set(CMAKE_CXX_FLAGS "-std=c++14")
+	elseif(GLM_TEST_ENABLE_CXX_1Y)
+		set(CMAKE_XCODE_ATTRIBUTE_CLANG_CXX_LANGUAGE_STANDARD "c++1y")
+		set(CMAKE_XCODE_ATTRIBUTE_CLANG_CXX_LIBRARY "libc++")
+		set(CMAKE_CXX_FLAGS "-std=c++1y")
+	elseif(GLM_TEST_ENABLE_CXX_11)
+		set(CMAKE_XCODE_ATTRIBUTE_CLANG_CXX_LANGUAGE_STANDARD "c++11")
+		set(CMAKE_XCODE_ATTRIBUTE_CLANG_CXX_LIBRARY "libc++")
+		set(CMAKE_CXX_FLAGS "-std=c++11")
+	elseif(GLM_TEST_ENABLE_CXX_0X)
+		set(CMAKE_XCODE_ATTRIBUTE_CLANG_CXX_LANGUAGE_STANDARD "c++0x")
+		set(CMAKE_XCODE_ATTRIBUTE_CLANG_CXX_LIBRARY "libc++")
+		set(CMAKE_CXX_FLAGS "-std=c++0x")
+	elseif(GLM_TEST_ENABLE_CXX_98)
+		set(CMAKE_XCODE_ATTRIBUTE_CLANG_CXX_LANGUAGE_STANDARD "c++98")
+		set(CMAKE_XCODE_ATTRIBUTE_CLANG_CXX_LIBRARY "libc++")
+		set(CMAKE_CXX_FLAGS "-std=c++98")
+	endif()
+endif()
+
+option(GLM_TEST_ENABLE_MS_EXTENSIONS "Enable MS extensions" OFF)
+
+if(GLM_TEST_ENABLE_MS_EXTENSIONS)
+	if(("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang") OR ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU"))
+		add_definitions(-Wgnu-anonymous-struct)
+		add_definitions(-Wnested-anon-types)
+	endif()
+else()
+	if(("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC") OR (("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Intel") AND WIN32))
+		add_definitions(/Za)
+	elseif(("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang") OR ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU"))
+		add_definitions(-pedantic)
+	endif()
+endif()
+
+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_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_COMPILER_IS_GNUCXX)
+		add_definitions(-mfpmath=387)
+	endif()
+elseif(GLM_TEST_ENABLE_SIMD_AVX2)
+	if(CMAKE_COMPILER_IS_GNUCXX)
+		add_definitions(-mavx2)
+	elseif(GLM_USE_INTEL)
+		add_definitions(/QxAVX2)
+	elseif(MSVC)
+		add_definitions(/arch:AVX2)
+	endif()
+elseif(GLM_TEST_ENABLE_SIMD_AVX)
+	if(CMAKE_COMPILER_IS_GNUCXX)
+		add_definitions(-mavx)
+	elseif(GLM_USE_INTEL)
+		add_definitions(/QxAVX)
+	elseif(MSVC)
+		add_definitions(/arch:AVX)
+	endif()
+elseif(GLM_TEST_ENABLE_SIMD_SSE3)
+	if(CMAKE_COMPILER_IS_GNUCXX)
+		add_definitions(-msse3)
+	elseif(GLM_USE_INTEL)
+		add_definitions(/QxSSE3)
+	elseif(MSVC)
+		add_definitions(/arch:SSE2) # VC doesn't support /arch:SSE3	
+	endif()
+elseif(GLM_TEST_ENABLE_SIMD_SSE2)
+	if(CMAKE_COMPILER_IS_GNUCXX)
+		add_definitions(-msse2)
+	elseif(GLM_USE_INTEL)
+		add_definitions(/QxSSE2)
+	elseif(MSVC)
+		if(NOT CMAKE_CL_64)
+			add_definitions(/arch:SSE2)
+		endif()
+	endif()
+endif()
+
+option(GLM_TEST_ENABLE_FAST_MATH "Enable fast math optimizations" OFF)
+if(GLM_TEST_ENABLE_FAST_MATH)
+	if(CMAKE_COMPILER_IS_GNUCXX)
+		add_definitions(-ffast-math)
+	endif()
+
+	if(MSVC)
+		add_definitions(/fp:fast)	
+	endif()
+elseif(NOT GLM_TEST_ENABLE_FAST_MATH)
+	if(MSVC)
+		add_definitions(/fp:precise)	
+	endif()
+endif()
+
+if(CMAKE_COMPILER_IS_GNUCXX)
+	#add_definitions(-S)
+	#add_definitions(-s)
+	add_definitions(-m64)
+	add_definitions(-O2)
+
+	#add_definitions(-fprofile-arcs -ftest-coverage) gcov
+	#ctest_enable_coverage()
+endif()
+
+include_directories("${PROJECT_SOURCE_DIR}")
+include_directories("${PROJECT_SOURCE_DIR}/test/external")
+
+add_subdirectory(glm)
+add_subdirectory(test)
+add_subdirectory(util)
+
+install(DIRECTORY glm DESTINATION ${CMAKE_INSTALL_FULL_INCLUDEDIR})

glm/CTestConfig.cmake

@@ -0,0 +1,13 @@
+## This file should be placed in the root directory of your project.
+## Then modify the CMakeLists.txt file in the root directory of your
+## project to incorporate the testing dashboard.
+## # The following are required to uses Dart and the Cdash dashboard
+##   ENABLE_TESTING()
+##   INCLUDE(CTest)
+set(CTEST_PROJECT_NAME "GLM")
+set(CTEST_NIGHTLY_START_TIME "00:00:00 EST")
+
+set(CTEST_DROP_METHOD "http")
+set(CTEST_DROP_SITE "my.cdash.org")
+set(CTEST_DROP_LOCATION "/submit.php?project=GLM")
+set(CTEST_DROP_SITE_CDASH TRUE)

glm/cmake/GNUInstallDirs.cmake

@@ -0,0 +1,188 @@
+# - Define GNU standard installation directories
+# Provides install directory variables as defined for GNU software:
+#  http://www.gnu.org/prep/standards/html_node/Directory-Variables.html
+# Inclusion of this module defines the following variables:
+#  CMAKE_INSTALL_<dir>      - destination for files of a given type
+#  CMAKE_INSTALL_FULL_<dir> - corresponding absolute path
+# where <dir> is one of:
+#  BINDIR           - user executables (bin)
+#  SBINDIR          - system admin executables (sbin)
+#  LIBEXECDIR       - program executables (libexec)
+#  SYSCONFDIR       - read-only single-machine data (etc)
+#  SHAREDSTATEDIR   - modifiable architecture-independent data (com)
+#  LOCALSTATEDIR    - modifiable single-machine data (var)
+#  LIBDIR           - object code libraries (lib or lib64 or lib/<multiarch-tuple> on Debian)
+#  INCLUDEDIR       - C header files (include)
+#  OLDINCLUDEDIR    - C header files for non-gcc (/usr/include)
+#  DATAROOTDIR      - read-only architecture-independent data root (share)
+#  DATADIR          - read-only architecture-independent data (DATAROOTDIR)
+#  INFODIR          - info documentation (DATAROOTDIR/info)
+#  LOCALEDIR        - locale-dependent data (DATAROOTDIR/locale)
+#  MANDIR           - man documentation (DATAROOTDIR/man)
+#  DOCDIR           - documentation root (DATAROOTDIR/doc/PROJECT_NAME)
+# Each CMAKE_INSTALL_<dir> value may be passed to the DESTINATION options of
+# install() commands for the corresponding file type.  If the includer does
+# not define a value the above-shown default will be used and the value will
+# appear in the cache for editing by the user.
+# Each CMAKE_INSTALL_FULL_<dir> value contains an absolute path constructed
+# from the corresponding destination by prepending (if necessary) the value
+# of CMAKE_INSTALL_PREFIX.
+
+#=============================================================================
+# Copyright 2011 Nikita Krupen'ko <krnekit@gmail.com>
+# Copyright 2011 Kitware, Inc.
+#
+# Distributed under the OSI-approved BSD License (the "License");
+# see accompanying file Copyright.txt for details.
+#
+# This software is distributed WITHOUT ANY WARRANTY; without even the
+# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See the License for more information.
+#=============================================================================
+# (To distribute this file outside of CMake, substitute the full
+#  License text for the above reference.)
+
+# Installation directories
+#
+if(NOT DEFINED CMAKE_INSTALL_BINDIR)
+  set(CMAKE_INSTALL_BINDIR "bin" CACHE PATH "user executables (bin)")
+endif()
+
+if(NOT DEFINED CMAKE_INSTALL_SBINDIR)
+  set(CMAKE_INSTALL_SBINDIR "sbin" CACHE PATH "system admin executables (sbin)")
+endif()
+
+if(NOT DEFINED CMAKE_INSTALL_LIBEXECDIR)
+  set(CMAKE_INSTALL_LIBEXECDIR "libexec" CACHE PATH "program executables (libexec)")
+endif()
+
+if(NOT DEFINED CMAKE_INSTALL_SYSCONFDIR)
+  set(CMAKE_INSTALL_SYSCONFDIR "etc" CACHE PATH "read-only single-machine data (etc)")
+endif()
+
+if(NOT DEFINED CMAKE_INSTALL_SHAREDSTATEDIR)
+  set(CMAKE_INSTALL_SHAREDSTATEDIR "com" CACHE PATH "modifiable architecture-independent data (com)")
+endif()
+
+if(NOT DEFINED CMAKE_INSTALL_LOCALSTATEDIR)
+  set(CMAKE_INSTALL_LOCALSTATEDIR "var" CACHE PATH "modifiable single-machine data (var)")
+endif()
+
+if(NOT DEFINED CMAKE_INSTALL_LIBDIR)
+  set(_LIBDIR_DEFAULT "lib")
+  # Override this default 'lib' with 'lib64' iff:
+  #  - we are on Linux system but NOT cross-compiling
+  #  - we are NOT on debian
+  #  - we are on a 64 bits system
+  # reason is: amd64 ABI: http://www.x86-64.org/documentation/abi.pdf
+  # For Debian with multiarch, use 'lib/${CMAKE_LIBRARY_ARCHITECTURE}' if
+  # CMAKE_LIBRARY_ARCHITECTURE is set (which contains e.g. "i386-linux-gnu"
+  # See http://wiki.debian.org/Multiarch
+  if((CMAKE_SYSTEM_NAME MATCHES "Linux|kFreeBSD" OR CMAKE_SYSTEM_NAME STREQUAL "GNU")
+      AND NOT CMAKE_CROSSCOMPILING)
+    if (EXISTS "/etc/debian_version") # is this a debian system ?
+       if(CMAKE_LIBRARY_ARCHITECTURE)
+         set(_LIBDIR_DEFAULT "lib/${CMAKE_LIBRARY_ARCHITECTURE}")
+       endif()
+    else() # not debian, rely on CMAKE_SIZEOF_VOID_P:
+      if(NOT DEFINED CMAKE_SIZEOF_VOID_P)
+        message(AUTHOR_WARNING
+          "Unable to determine default CMAKE_INSTALL_LIBDIR directory because no target architecture is known. "
+          "Please enable at least one language before including GNUInstallDirs.")
+      else()
+        if("${CMAKE_SIZEOF_VOID_P}" EQUAL "8")
+          set(_LIBDIR_DEFAULT "lib64")
+        endif()
+      endif()
+    endif()
+  endif()
+  set(CMAKE_INSTALL_LIBDIR "${_LIBDIR_DEFAULT}" CACHE PATH "object code libraries (${_LIBDIR_DEFAULT})")
+endif()
+
+if(NOT DEFINED CMAKE_INSTALL_INCLUDEDIR)
+  set(CMAKE_INSTALL_INCLUDEDIR "include" CACHE PATH "C header files (include)")
+endif()
+
+if(NOT DEFINED CMAKE_INSTALL_OLDINCLUDEDIR)
+  set(CMAKE_INSTALL_OLDINCLUDEDIR "/usr/include" CACHE PATH "C header files for non-gcc (/usr/include)")
+endif()
+
+if(NOT DEFINED CMAKE_INSTALL_DATAROOTDIR)
+  set(CMAKE_INSTALL_DATAROOTDIR "share" CACHE PATH "read-only architecture-independent data root (share)")
+endif()
+
+#-----------------------------------------------------------------------------
+# Values whose defaults are relative to DATAROOTDIR.  Store empty values in
+# the cache and store the defaults in local variables if the cache values are
+# not set explicitly.  This auto-updates the defaults as DATAROOTDIR changes.
+
+if(NOT CMAKE_INSTALL_DATADIR)
+  set(CMAKE_INSTALL_DATADIR "" CACHE PATH "read-only architecture-independent data (DATAROOTDIR)")
+  set(CMAKE_INSTALL_DATADIR "${CMAKE_INSTALL_DATAROOTDIR}")
+endif()
+
+if(NOT CMAKE_INSTALL_INFODIR)
+  set(CMAKE_INSTALL_INFODIR "" CACHE PATH "info documentation (DATAROOTDIR/info)")
+  set(CMAKE_INSTALL_INFODIR "${CMAKE_INSTALL_DATAROOTDIR}/info")
+endif()
+
+if(NOT CMAKE_INSTALL_LOCALEDIR)
+  set(CMAKE_INSTALL_LOCALEDIR "" CACHE PATH "locale-dependent data (DATAROOTDIR/locale)")
+  set(CMAKE_INSTALL_LOCALEDIR "${CMAKE_INSTALL_DATAROOTDIR}/locale")
+endif()
+
+if(NOT CMAKE_INSTALL_MANDIR)
+  set(CMAKE_INSTALL_MANDIR "" CACHE PATH "man documentation (DATAROOTDIR/man)")
+  set(CMAKE_INSTALL_MANDIR "${CMAKE_INSTALL_DATAROOTDIR}/man")
+endif()
+
+if(NOT CMAKE_INSTALL_DOCDIR)
+  set(CMAKE_INSTALL_DOCDIR "" CACHE PATH "documentation root (DATAROOTDIR/doc/PROJECT_NAME)")
+  set(CMAKE_INSTALL_DOCDIR "${CMAKE_INSTALL_DATAROOTDIR}/doc/${PROJECT_NAME}")
+endif()
+
+#-----------------------------------------------------------------------------
+
+mark_as_advanced(
+  CMAKE_INSTALL_BINDIR
+  CMAKE_INSTALL_SBINDIR
+  CMAKE_INSTALL_LIBEXECDIR
+  CMAKE_INSTALL_SYSCONFDIR
+  CMAKE_INSTALL_SHAREDSTATEDIR
+  CMAKE_INSTALL_LOCALSTATEDIR
+  CMAKE_INSTALL_LIBDIR
+  CMAKE_INSTALL_INCLUDEDIR
+  CMAKE_INSTALL_OLDINCLUDEDIR
+  CMAKE_INSTALL_DATAROOTDIR
+  CMAKE_INSTALL_DATADIR
+  CMAKE_INSTALL_INFODIR
+  CMAKE_INSTALL_LOCALEDIR
+  CMAKE_INSTALL_MANDIR
+  CMAKE_INSTALL_DOCDIR
+  )
+
+# Result directories
+#
+foreach(dir
+    BINDIR
+    SBINDIR
+    LIBEXECDIR
+    SYSCONFDIR
+    SHAREDSTATEDIR
+    LOCALSTATEDIR
+    LIBDIR
+    INCLUDEDIR
+    OLDINCLUDEDIR
+    DATAROOTDIR
+    DATADIR
+    INFODIR
+    LOCALEDIR
+    MANDIR
+    DOCDIR
+    )
+  if(NOT IS_ABSOLUTE ${CMAKE_INSTALL_${dir}})
+    set(CMAKE_INSTALL_FULL_${dir} "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_${dir}}")
+  else()
+    set(CMAKE_INSTALL_FULL_${dir} "${CMAKE_INSTALL_${dir}}")
+  endif()
+endforeach()

glm/copying.txt

@@ -0,0 +1,55 @@
+================================================================================
+OpenGL Mathematics (GLM)
+--------------------------------------------------------------------------------
+GLM can be distributed and/or modified under the terms of either
+a) The Happy Bunny License, or b) the MIT License.
+
+================================================================================
+The Happy Bunny License (Modified MIT License)
+--------------------------------------------------------------------------------
+Copyright (c) 2005 - 2015 G-Truc Creation
+
+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.
+
+================================================================================
+The MIT License
+--------------------------------------------------------------------------------
+Copyright (c) 2005 - 2015 G-Truc Creation
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

glm/glm/CMakeLists.txt

@@ -0,0 +1,43 @@
+set(NAME glm_dummy)
+
+file(GLOB ROOT_SOURCE *.cpp)
+file(GLOB ROOT_INLINE *.inl)
+file(GLOB ROOT_HEADER *.hpp)
+file(GLOB ROOT_TEXT ../*.txt)
+file(GLOB ROOT_NAT ../util/glm.natvis)
+
+file(GLOB_RECURSE CORE_SOURCE ./detail/*.cpp)
+file(GLOB_RECURSE CORE_INLINE ./detail/*.inl)
+file(GLOB_RECURSE CORE_HEADER ./detail/*.hpp)
+
+file(GLOB_RECURSE GTC_SOURCE ./gtc/*.cpp)
+file(GLOB_RECURSE GTC_INLINE ./gtc/*.inl)
+file(GLOB_RECURSE GTC_HEADER ./gtc/*.hpp)
+
+file(GLOB_RECURSE GTX_SOURCE ./gtx/*.cpp)
+file(GLOB_RECURSE GTX_INLINE ./gtx/*.inl)
+file(GLOB_RECURSE GTX_HEADER ./gtx/*.hpp)
+
+source_group("Text Files" FILES ${ROOT_TEXT})
+source_group("Core Files" FILES ${CORE_SOURCE})
+source_group("Core Files" FILES ${CORE_INLINE})
+source_group("Core Files" FILES ${CORE_HEADER})
+source_group("GTC Files" FILES ${GTC_SOURCE})
+source_group("GTC Files" FILES ${GTC_INLINE})
+source_group("GTC Files" FILES ${GTC_HEADER})
+source_group("GTX Files" FILES ${GTX_SOURCE})
+source_group("GTX Files" FILES ${GTX_INLINE})
+source_group("GTX Files" FILES ${GTX_HEADER})
+
+include_directories(${CMAKE_CURRENT_SOURCE_DIR}/..)
+
+if(GLM_TEST_ENABLE)
+	add_executable(${NAME} ${ROOT_TEXT} ${ROOT_NAT}
+		${ROOT_SOURCE}    ${ROOT_INLINE}    ${ROOT_HEADER}
+		${CORE_SOURCE}    ${CORE_INLINE}    ${CORE_HEADER}
+		${GTC_SOURCE}     ${GTC_INLINE}     ${GTC_HEADER}
+		${GTX_SOURCE}     ${GTX_INLINE}     ${GTX_HEADER})
+endif(GLM_TEST_ENABLE)
+
+#add_library(glm STATIC glm.cpp)
+#add_library(glm_shared SHARED glm.cpp)

glm/glm/common.hpp

@@ -0,0 +1,35 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// 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.
+///
+/// @ref core
+/// @file glm/common.hpp
+/// @date 2013-12-24 / 2013-12-24
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#pragma once
+
+#include "detail/func_common.hpp"

glm/glm/detail/_features.hpp

@@ -0,0 +1,428 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// 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.
+///
+/// @ref core
+/// @file glm/detail/_features.hpp
+/// @date 2013-02-20 / 2013-02-20
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#pragma once
+
+// #define GLM_CXX98_EXCEPTIONS
+// #define GLM_CXX98_RTTI
+
+// #define GLM_CXX11_RVALUE_REFERENCES
+// Rvalue references - GCC 4.3
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n2118.html
+
+// GLM_CXX11_TRAILING_RETURN
+// Rvalue references for *this - GCC not supported
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2439.htm
+
+// GLM_CXX11_NONSTATIC_MEMBER_INIT
+// Initialization of class objects by rvalues - GCC any
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1610.html
+
+// GLM_CXX11_NONSTATIC_MEMBER_INIT
+// Non-static data member initializers - GCC 4.7
+// http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2008/n2756.htm
+
+// #define GLM_CXX11_VARIADIC_TEMPLATE
+// Variadic templates - GCC 4.3
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2242.pdf
+
+// 
+// Extending variadic template template parameters - GCC 4.4
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2555.pdf
+
+// #define GLM_CXX11_GENERALIZED_INITIALIZERS
+// Initializer lists - GCC 4.4
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2672.htm
+
+// #define GLM_CXX11_STATIC_ASSERT 
+// Static assertions - GCC 4.3
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1720.html
+
+// #define GLM_CXX11_AUTO_TYPE
+// auto-typed variables - GCC 4.4
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1984.pdf
+
+// #define GLM_CXX11_AUTO_TYPE
+// Multi-declarator auto - GCC 4.4
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1737.pdf
+
+// #define GLM_CXX11_AUTO_TYPE
+// Removal of auto as a storage-class specifier - GCC 4.4
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2546.htm
+
+// #define GLM_CXX11_AUTO_TYPE
+// New function declarator syntax - GCC 4.4
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2541.htm
+
+// #define GLM_CXX11_LAMBDAS
+// New wording for C++0x lambdas - GCC 4.5
+// http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2009/n2927.pdf
+
+// #define GLM_CXX11_DECLTYPE
+// Declared type of an expression - GCC 4.3
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2343.pdf
+
+// 
+// Right angle brackets - GCC 4.3
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1757.html
+
+// 
+// Default template arguments for function templates	DR226	GCC 4.3
+// http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#226
+
+// 
+// Solving the SFINAE problem for expressions	DR339	GCC 4.4
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2634.html
+
+// #define GLM_CXX11_ALIAS_TEMPLATE
+// Template aliases	N2258	GCC 4.7
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2258.pdf
+
+// 
+// Extern templates	N1987	Yes
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1987.htm
+
+// #define GLM_CXX11_NULLPTR
+// Null pointer constant	N2431	GCC 4.6
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2431.pdf
+
+// #define GLM_CXX11_STRONG_ENUMS
+// Strongly-typed enums	N2347	GCC 4.4
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2347.pdf
+
+// 
+// Forward declarations for enums	N2764	GCC 4.6
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2764.pdf
+
+// 
+// Generalized attributes	N2761	GCC 4.8
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2761.pdf
+
+// 
+// Generalized constant expressions	N2235	GCC 4.6
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2235.pdf
+
+// 
+// Alignment support	N2341	GCC 4.8
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2341.pdf
+
+// #define GLM_CXX11_DELEGATING_CONSTRUCTORS
+// Delegating constructors	N1986	GCC 4.7
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1986.pdf
+
+// 
+// Inheriting constructors	N2540	GCC 4.8
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2540.htm
+
+// #define GLM_CXX11_EXPLICIT_CONVERSIONS
+// Explicit conversion operators	N2437	GCC 4.5
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2437.pdf
+
+// 
+// New character types	N2249	GCC 4.4
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2249.html
+
+// 
+// Unicode string literals	N2442	GCC 4.5
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2442.htm
+
+// 
+// Raw string literals	N2442	GCC 4.5
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2442.htm
+
+// 
+// Universal character name literals	N2170	GCC 4.5
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2170.html
+
+// #define GLM_CXX11_USER_LITERALS
+// User-defined literals		N2765	GCC 4.7
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2765.pdf
+
+// 
+// Standard Layout Types	N2342	GCC 4.5
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2342.htm
+
+// #define GLM_CXX11_DEFAULTED_FUNCTIONS
+// #define GLM_CXX11_DELETED_FUNCTIONS
+// Defaulted and deleted functions	N2346	GCC 4.4
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2346.htm
+
+// 
+// Extended friend declarations	N1791	GCC 4.7
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1791.pdf
+
+// 
+// Extending sizeof	N2253	GCC 4.4
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2253.html
+
+// #define GLM_CXX11_INLINE_NAMESPACES
+// Inline namespaces	N2535	GCC 4.4
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2535.htm
+
+// #define GLM_CXX11_UNRESTRICTED_UNIONS
+// Unrestricted unions	N2544	GCC 4.6
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2544.pdf
+
+// #define GLM_CXX11_LOCAL_TYPE_TEMPLATE_ARGS
+// Local and unnamed types as template arguments	N2657	GCC 4.5
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2657.htm
+
+// #define GLM_CXX11_RANGE_FOR
+// Range-based for	N2930	GCC 4.6
+// http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2009/n2930.html
+
+// #define GLM_CXX11_OVERRIDE_CONTROL
+// Explicit virtual overrides	N2928 N3206 N3272	GCC 4.7
+// http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2009/n2928.htm
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3206.htm
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2011/n3272.htm
+
+// 
+// Minimal support for garbage collection and reachability-based leak detection	N2670	No
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2670.htm
+
+// #define GLM_CXX11_NOEXCEPT
+// Allowing move constructors to throw [noexcept]	N3050	GCC 4.6 (core language only)
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3050.html
+
+// 
+// Defining move special member functions	N3053	GCC 4.6
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3053.html
+
+// 
+// Sequence points	N2239	Yes
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2239.html
+
+// 
+// Atomic operations	N2427	GCC 4.4
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2239.html
+
+// 
+// Strong Compare and Exchange	N2748	GCC 4.5
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2427.html
+
+// 
+// Bidirectional Fences	N2752	GCC 4.8
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2752.htm
+
+// 
+// Memory model	N2429	GCC 4.8
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2429.htm
+
+// 
+// Data-dependency ordering: atomics and memory model	N2664	GCC 4.4
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2664.htm
+
+// 
+// Propagating exceptions	N2179	GCC 4.4
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2179.html
+
+// 
+// Abandoning a process and at_quick_exit	N2440	GCC 4.8
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2440.htm
+
+// 
+// Allow atomics use in signal handlers	N2547	Yes
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2547.htm
+
+// 
+// Thread-local storage	N2659	GCC 4.8
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2659.htm
+
+// 
+// Dynamic initialization and destruction with concurrency	N2660	GCC 4.3
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2660.htm
+
+// 
+// __func__ predefined identifier	N2340	GCC 4.3
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2340.htm
+
+// 
+// C99 preprocessor	N1653	GCC 4.3
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1653.htm
+
+// 
+// long long	N1811	GCC 4.3
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1811.pdf
+
+// 
+// Extended integral types	N1988	Yes
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1988.pdf
+
+#if(GLM_COMPILER & GLM_COMPILER_GCC)
+
+#	if(GLM_COMPILER >= GLM_COMPILER_GCC43)
+#		define GLM_CXX11_STATIC_ASSERT
+#	endif
+
+#elif(GLM_COMPILER & (GLM_COMPILER_APPLE_CLANG | GLM_COMPILER_LLVM))
+#	if(__has_feature(cxx_exceptions))
+#		define GLM_CXX98_EXCEPTIONS
+#	endif
+
+#	if(__has_feature(cxx_rtti))
+#		define GLM_CXX98_RTTI
+#	endif
+
+#	if(__has_feature(cxx_access_control_sfinae))
+#		define GLM_CXX11_ACCESS_CONTROL_SFINAE
+#	endif
+
+#	if(__has_feature(cxx_alias_templates))
+#		define GLM_CXX11_ALIAS_TEMPLATE
+#	endif
+
+#	if(__has_feature(cxx_alignas))
+#		define GLM_CXX11_ALIGNAS
+#	endif
+
+#	if(__has_feature(cxx_attributes))
+#		define GLM_CXX11_ATTRIBUTES
+#	endif
+
+#	if(__has_feature(cxx_constexpr))
+#		define GLM_CXX11_CONSTEXPR
+#	endif
+
+#	if(__has_feature(cxx_decltype))
+#		define GLM_CXX11_DECLTYPE
+#	endif
+
+#	if(__has_feature(cxx_default_function_template_args))
+#		define GLM_CXX11_DEFAULT_FUNCTION_TEMPLATE_ARGS
+#	endif
+
+#	if(__has_feature(cxx_defaulted_functions))
+#		define GLM_CXX11_DEFAULTED_FUNCTIONS
+#	endif
+
+#	if(__has_feature(cxx_delegating_constructors))
+#		define GLM_CXX11_DELEGATING_CONSTRUCTORS
+#	endif
+
+#	if(__has_feature(cxx_deleted_functions))
+#		define GLM_CXX11_DELETED_FUNCTIONS
+#	endif
+
+#	if(__has_feature(cxx_explicit_conversions))
+#		define GLM_CXX11_EXPLICIT_CONVERSIONS
+#	endif
+
+#	if(__has_feature(cxx_generalized_initializers))
+#		define GLM_CXX11_GENERALIZED_INITIALIZERS
+#	endif
+
+#	if(__has_feature(cxx_implicit_moves))
+#		define GLM_CXX11_IMPLICIT_MOVES
+#	endif
+
+#	if(__has_feature(cxx_inheriting_constructors))
+#		define GLM_CXX11_INHERITING_CONSTRUCTORS
+#	endif
+
+#	if(__has_feature(cxx_inline_namespaces))
+#		define GLM_CXX11_INLINE_NAMESPACES
+#	endif
+
+#	if(__has_feature(cxx_lambdas))
+#		define GLM_CXX11_LAMBDAS
+#	endif
+
+#	if(__has_feature(cxx_local_type_template_args))
+#		define GLM_CXX11_LOCAL_TYPE_TEMPLATE_ARGS
+#	endif
+
+#	if(__has_feature(cxx_noexcept))
+#		define GLM_CXX11_NOEXCEPT
+#	endif
+
+#	if(__has_feature(cxx_nonstatic_member_init))
+#		define GLM_CXX11_NONSTATIC_MEMBER_INIT
+#	endif
+
+#	if(__has_feature(cxx_nullptr))
+#		define GLM_CXX11_NULLPTR
+#	endif
+
+#	if(__has_feature(cxx_override_control))
+#		define GLM_CXX11_OVERRIDE_CONTROL
+#	endif
+
+#	if(__has_feature(cxx_reference_qualified_functions))
+#		define GLM_CXX11_REFERENCE_QUALIFIED_FUNCTIONS
+#	endif
+
+#	if(__has_feature(cxx_range_for))
+#		define GLM_CXX11_RANGE_FOR
+#	endif
+
+#	if(__has_feature(cxx_raw_string_literals))
+#		define GLM_CXX11_RAW_STRING_LITERALS
+#	endif
+
+#	if(__has_feature(cxx_rvalue_references))
+#		define GLM_CXX11_RVALUE_REFERENCES
+#	endif
+
+#	if(__has_feature(cxx_static_assert))
+#		define GLM_CXX11_STATIC_ASSERT
+#	endif
+
+#	if(__has_feature(cxx_auto_type))
+#		define GLM_CXX11_AUTO_TYPE
+#	endif
+
+#	if(__has_feature(cxx_strong_enums))
+#		define GLM_CXX11_STRONG_ENUMS
+#	endif
+
+#	if(__has_feature(cxx_trailing_return))
+#		define GLM_CXX11_TRAILING_RETURN
+#	endif
+
+#	if(__has_feature(cxx_unicode_literals))
+#		define GLM_CXX11_UNICODE_LITERALS
+#	endif
+
+#	if(__has_feature(cxx_unrestricted_unions))
+#		define GLM_CXX11_UNRESTRICTED_UNIONS
+#	endif
+
+#	if(__has_feature(cxx_user_literals))
+#		define GLM_CXX11_USER_LITERALS
+#	endif
+
+#	if(__has_feature(cxx_variadic_templates))
+#		define GLM_CXX11_VARIADIC_TEMPLATES
+#	endif
+
+#endif//(GLM_COMPILER & (GLM_COMPILER_APPLE_CLANG | GLM_COMPILER_LLVM))

glm/glm/detail/_fixes.hpp

@@ -0,0 +1,59 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// 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.
+///
+/// @ref core
+/// @file glm/detail/_fixes.hpp
+/// @date 2011-02-21 / 2011-11-22
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#include <cmath>
+
+//! Workaround for compatibility with other libraries
+#ifdef max
+#undef max
+#endif
+
+//! Workaround for compatibility with other libraries
+#ifdef min
+#undef min
+#endif
+
+//! Workaround for Android
+#ifdef isnan
+#undef isnan
+#endif
+
+//! Workaround for Android
+#ifdef isinf
+#undef isinf
+#endif
+
+//! Workaround for Chrone Native Client
+#ifdef log2
+#undef log2
+#endif
+

glm/glm/detail/_noise.hpp

@@ -0,0 +1,136 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// 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.
+///
+/// @ref core
+/// @file glm/detail/_noise.hpp
+/// @date 2013-12-24 / 2013-12-24
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#pragma once
+
+#include "../vec2.hpp"
+#include "../vec3.hpp"
+#include "../vec4.hpp"
+#include "../common.hpp"
+
+namespace glm{
+namespace detail
+{
+	template <typename T>
+	GLM_FUNC_QUALIFIER T mod289(T const & x)
+	{
+		return x - floor(x * static_cast<T>(1.0) / static_cast<T>(289.0)) * static_cast<T>(289.0);
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER T permute(T const & x)
+	{
+		return mod289(((x * static_cast<T>(34)) + static_cast<T>(1)) * x);
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tvec2<T, P> permute(tvec2<T, P> const & x)
+	{
+		return mod289(((x * static_cast<T>(34)) + static_cast<T>(1)) * x);
+	}
+	
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tvec3<T, P> permute(tvec3<T, P> const & x)
+	{
+		return mod289(((x * static_cast<T>(34)) + static_cast<T>(1)) * x);
+	}
+	
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tvec4<T, P> permute(tvec4<T, P> const & x)
+	{
+		return mod289(((x * static_cast<T>(34)) + static_cast<T>(1)) * x);
+	}
+/*
+	template <typename T, precision P, template<typename> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> permute(vecType<T, P> const & x)
+	{
+		return mod289(((x * T(34)) + T(1)) * x);
+	}
+*/
+	template <typename T>
+	GLM_FUNC_QUALIFIER T taylorInvSqrt(T const & r)
+	{
+		return T(1.79284291400159) - T(0.85373472095314) * r;
+	}
+	
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tvec2<T, P> taylorInvSqrt(tvec2<T, P> const & r)
+	{
+		return T(1.79284291400159) - T(0.85373472095314) * r;
+	}
+	
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tvec3<T, P> taylorInvSqrt(tvec3<T, P> const & r)
+	{
+		return T(1.79284291400159) - T(0.85373472095314) * r;
+	}
+	
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tvec4<T, P> taylorInvSqrt(tvec4<T, P> const & r)
+	{
+		return T(1.79284291400159) - T(0.85373472095314) * r;
+	}
+/*
+	template <typename T, precision P, template<typename> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> taylorInvSqrt(vecType<T, P> const & r)
+	{
+		return T(1.79284291400159) - T(0.85373472095314) * r;
+	}
+*/
+	
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tvec2<T, P> fade(tvec2<T, P> const & t)
+	{
+		return (t * t * t) * (t * (t * T(6) - T(15)) + T(10));
+	}
+	
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tvec3<T, P> fade(tvec3<T, P> const & t)
+	{
+		return (t * t * t) * (t * (t * T(6) - T(15)) + T(10));
+	}
+	
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tvec4<T, P> fade(tvec4<T, P> const & t)
+	{
+		return (t * t * t) * (t * (t * T(6) - T(15)) + T(10));
+	}
+/*
+	template <typename T, precision P, template <typename> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> fade(vecType<T, P> const & t)
+	{
+		return (t * t * t) * (t * (t * T(6) - T(15)) + T(10));
+	}
+*/
+}//namespace detail
+}//namespace glm
+

glm/glm/detail/_swizzle.hpp

@@ -0,0 +1,833 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// 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.
+///
+/// @ref core
+/// @file glm/detail/_swizzle.hpp
+/// @date 2006-04-20 / 2011-02-16
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#pragma once
+
+namespace glm{
+namespace detail
+{
+	// Internal class for implementing swizzle operators
+	template <typename T, int N>
+	struct _swizzle_base0
+	{
+		typedef T       value_type;
+
+	protected:
+		GLM_FUNC_QUALIFIER value_type&         elem   (size_t i)       { return (reinterpret_cast<value_type*>(_buffer))[i]; }
+		GLM_FUNC_QUALIFIER const value_type&   elem   (size_t i) const { return (reinterpret_cast<const value_type*>(_buffer))[i]; }
+
+		// Use an opaque buffer to *ensure* the compiler doesn't call a constructor.
+		// The size 1 buffer is assumed to aligned to the actual members so that the
+		// elem() 
+		char    _buffer[1];
+	};
+
+	template <typename T, precision P, typename V, int E0, int E1, int E2, int E3, int N>
+	struct _swizzle_base1 : public _swizzle_base0<T, N>
+	{
+	};
+
+	template <typename T, precision P, typename V, int E0, int E1>
+	struct _swizzle_base1<T, P, V,E0,E1,-1,-2,2> : public _swizzle_base0<T, 2>
+	{
+		GLM_FUNC_QUALIFIER V operator ()()  const { return V(this->elem(E0), this->elem(E1)); }
+	};
+
+	template <typename T, precision P, typename V, int E0, int E1, int E2>
+	struct _swizzle_base1<T, P, V,E0,E1,E2,-1,3> : public _swizzle_base0<T, 3>
+	{
+		GLM_FUNC_QUALIFIER V operator ()()  const { return V(this->elem(E0), this->elem(E1), this->elem(E2)); }
+	};
+
+	template <typename T, precision P, typename V, int E0, int E1, int E2, int E3>
+	struct _swizzle_base1<T, P, V,E0,E1,E2,E3,4> : public _swizzle_base0<T, 4>
+	{ 
+		GLM_FUNC_QUALIFIER V operator ()()  const { return V(this->elem(E0), this->elem(E1), this->elem(E2), this->elem(E3)); }
+	};
+
+	// Internal class for implementing swizzle operators
+	/*
+		Template parameters:
+
+		ValueType = type of scalar values (e.g. float, double)
+		VecType   = class the swizzle is applies to (e.g. tvec3<float>)
+		N         = number of components in the vector (e.g. 3)
+		E0...3    = what index the n-th element of this swizzle refers to in the unswizzled vec
+
+		DUPLICATE_ELEMENTS = 1 if there is a repeated element, 0 otherwise (used to specialize swizzles
+			containing duplicate elements so that they cannot be used as r-values).            
+	*/
+	template <typename ValueType, precision P, typename VecType, int N, int E0, int E1, int E2, int E3, int DUPLICATE_ELEMENTS>
+	struct _swizzle_base2 : public _swizzle_base1<ValueType, P, VecType,E0,E1,E2,E3,N>
+	{
+		typedef VecType vec_type;
+		typedef ValueType value_type;
+
+		GLM_FUNC_QUALIFIER _swizzle_base2& operator= (const ValueType& t)
+		{
+			for (int i = 0; i < N; ++i)
+				(*this)[i] = t;
+			return *this;
+		}
+
+		GLM_FUNC_QUALIFIER _swizzle_base2& operator= (const VecType& that)
+		{
+			struct op { 
+				GLM_FUNC_QUALIFIER void operator() (value_type& e, value_type& t) { e = t; } 
+			};
+			_apply_op(that, op());
+			return *this;
+		}
+
+		GLM_FUNC_QUALIFIER void operator -= (const VecType& that)
+		{
+			struct op { 
+				GLM_FUNC_QUALIFIER void operator() (value_type& e, value_type& t) { e -= t; } 
+			};
+			_apply_op(that, op());
+		}
+
+		GLM_FUNC_QUALIFIER void operator += (const VecType& that)
+		{
+			struct op { 
+				GLM_FUNC_QUALIFIER void operator() (value_type& e, value_type& t) { e += t; } 
+			};
+			_apply_op(that, op());
+		}
+
+		GLM_FUNC_QUALIFIER void operator *= (const VecType& that)
+		{
+			struct op { 
+				GLM_FUNC_QUALIFIER void operator() (value_type& e, value_type& t) { e *= t; } 
+			};
+			_apply_op(that, op());
+		}
+
+		GLM_FUNC_QUALIFIER void operator /= (const VecType& that)
+		{
+			struct op { 
+				GLM_FUNC_QUALIFIER void operator() (value_type& e, value_type& t) { e /= t; } 
+			};
+			_apply_op(that, op());
+		}
+
+		GLM_FUNC_QUALIFIER value_type& operator[]  (size_t i)
+		{
+			const int offset_dst[4] = { E0, E1, E2, E3 };
+			return this->elem(offset_dst[i]);
+		}
+		GLM_FUNC_QUALIFIER value_type  operator[]  (size_t i) const
+		{
+			const int offset_dst[4] = { E0, E1, E2, E3 };
+			return this->elem(offset_dst[i]);
+		}
+
+	protected:
+		template <typename T>
+		GLM_FUNC_QUALIFIER void _apply_op(const VecType& that, T op)
+		{
+			// Make a copy of the data in this == &that.
+			// The copier should optimize out the copy in cases where the function is
+			// properly inlined and the copy is not necessary.
+			ValueType t[N];
+			for (int i = 0; i < N; ++i)
+				t[i] = that[i];
+			for (int i = 0; i < N; ++i)
+				op( (*this)[i], t[i] );
+		}
+	};
+
+	// Specialization for swizzles containing duplicate elements.  These cannot be modified.
+	template <typename ValueType, precision P, typename VecType, int N, int E0, int E1, int E2, int E3>
+	struct _swizzle_base2<ValueType, P, VecType,N,E0,E1,E2,E3,1> : public _swizzle_base1<ValueType, P, VecType,E0,E1,E2,E3,N>
+	{
+		typedef VecType         vec_type;        
+		typedef ValueType       value_type;
+
+		struct Stub {};
+		GLM_FUNC_QUALIFIER _swizzle_base2& operator= (Stub const &) { return *this; }
+
+		GLM_FUNC_QUALIFIER value_type  operator[]  (size_t i) const
+		{
+			const int offset_dst[4] = { E0, E1, E2, E3 };
+			return this->elem(offset_dst[i]);
+		}
+	};
+
+	template <int N,typename ValueType, precision P, typename VecType, int E0,int E1,int E2,int E3>
+	struct _swizzle : public _swizzle_base2<ValueType, P, VecType, N, E0, E1, E2, E3, (E0==E1||E0==E2||E0==E3||E1==E2||E1==E3||E2==E3)>
+	{
+		typedef _swizzle_base2<ValueType, P, VecType,N,E0,E1,E2,E3,(E0==E1||E0==E2||E0==E3||E1==E2||E1==E3||E2==E3)> base_type;
+
+		using base_type::operator=;
+
+		GLM_FUNC_QUALIFIER operator VecType () const { return (*this)(); }
+	};
+
+//
+// To prevent the C++ syntax from getting entirely overwhelming, define some alias macros
+//
+#define _GLM_SWIZZLE_TEMPLATE1   template <int N, typename T, precision P, typename V, int E0, int E1, int E2, int E3>
+#define _GLM_SWIZZLE_TEMPLATE2   template <int N, typename T, precision P, typename V, int E0, int E1, int E2, int E3, int F0, int F1, int F2, int F3>
+#define _GLM_SWIZZLE_TYPE1       _swizzle<N, T, P, V, E0, E1, E2, E3>
+#define _GLM_SWIZZLE_TYPE2       _swizzle<N, T, P, V, F0, F1, F2, F3>
+
+//
+// Wrapper for a binary operator (e.g. u.yy + v.zy)
+//
+#define _GLM_SWIZZLE_VECTOR_BINARY_OPERATOR_IMPLEMENTATION(OPERAND)                 \
+	_GLM_SWIZZLE_TEMPLATE2                                                          \
+	GLM_FUNC_QUALIFIER V operator OPERAND ( const _GLM_SWIZZLE_TYPE1& a, const _GLM_SWIZZLE_TYPE2& b)  \
+	{                                                                               \
+		return a() OPERAND b();                                                     \
+	}                                                                               \
+	_GLM_SWIZZLE_TEMPLATE1                                                          \
+	GLM_FUNC_QUALIFIER V operator OPERAND ( const _GLM_SWIZZLE_TYPE1& a, const V& b)                   \
+	{                                                                               \
+		return a() OPERAND b;                                                       \
+	}                                                                               \
+	_GLM_SWIZZLE_TEMPLATE1                                                          \
+	GLM_FUNC_QUALIFIER V operator OPERAND ( const V& a, const _GLM_SWIZZLE_TYPE1& b)                   \
+	{                                                                               \
+		return a OPERAND b();                                                       \
+	}
+
+//
+// Wrapper for a operand between a swizzle and a binary (e.g. 1.0f - u.xyz)
+//
+#define _GLM_SWIZZLE_SCALAR_BINARY_OPERATOR_IMPLEMENTATION(OPERAND)                 \
+	_GLM_SWIZZLE_TEMPLATE1                                                          \
+	GLM_FUNC_QUALIFIER V operator OPERAND ( const _GLM_SWIZZLE_TYPE1& a, const T& b)                   \
+	{                                                                               \
+		return a() OPERAND b;                                                       \
+	}                                                                               \
+	_GLM_SWIZZLE_TEMPLATE1                                                          \
+	GLM_FUNC_QUALIFIER V operator OPERAND ( const T& a, const _GLM_SWIZZLE_TYPE1& b)                   \
+	{                                                                               \
+		return a OPERAND b();                                                       \
+	}
+
+//
+// Macro for wrapping a function taking one argument (e.g. abs())
+//
+#define _GLM_SWIZZLE_FUNCTION_1_ARGS(RETURN_TYPE,FUNCTION)                          \
+	_GLM_SWIZZLE_TEMPLATE1                                                          \
+	GLM_FUNC_QUALIFIER typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const _GLM_SWIZZLE_TYPE1& a)  \
+	{                                                                               \
+		return FUNCTION(a());                                                       \
+	}
+
+//
+// Macro for wrapping a function taking two vector arguments (e.g. dot()).
+//
+#define _GLM_SWIZZLE_FUNCTION_2_ARGS(RETURN_TYPE,FUNCTION)                                                      \
+	_GLM_SWIZZLE_TEMPLATE2                                                                                      \
+	GLM_FUNC_QUALIFIER typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const _GLM_SWIZZLE_TYPE1& a, const _GLM_SWIZZLE_TYPE2& b) \
+	{                                                                                                           \
+		return FUNCTION(a(), b());                                                                              \
+	}                                                                                                           \
+	_GLM_SWIZZLE_TEMPLATE1                                                                                      \
+	GLM_FUNC_QUALIFIER typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const _GLM_SWIZZLE_TYPE1& a, const _GLM_SWIZZLE_TYPE1& b) \
+	{                                                                                                           \
+		return FUNCTION(a(), b());                                                                              \
+	}                                                                                                           \
+	_GLM_SWIZZLE_TEMPLATE1                                                                                      \
+	GLM_FUNC_QUALIFIER typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const _GLM_SWIZZLE_TYPE1& a, const typename V& b)         \
+	{                                                                                                           \
+		return FUNCTION(a(), b);                                                                                \
+	}                                                                                                           \
+	_GLM_SWIZZLE_TEMPLATE1                                                                                      \
+	GLM_FUNC_QUALIFIER typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const V& a, const _GLM_SWIZZLE_TYPE1& b)                  \
+	{                                                                                                           \
+		return FUNCTION(a, b());                                                                                \
+	} 
+
+//
+// Macro for wrapping a function take 2 vec arguments followed by a scalar (e.g. mix()).
+//
+#define _GLM_SWIZZLE_FUNCTION_2_ARGS_SCALAR(RETURN_TYPE,FUNCTION)                                                             \
+	_GLM_SWIZZLE_TEMPLATE2                                                                                                    \
+	GLM_FUNC_QUALIFIER typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const _GLM_SWIZZLE_TYPE1& a, const _GLM_SWIZZLE_TYPE2& b, const T& c)   \
+	{                                                                                                                         \
+		return FUNCTION(a(), b(), c);                                                                                         \
+	}                                                                                                                         \
+	_GLM_SWIZZLE_TEMPLATE1                                                                                                    \
+	GLM_FUNC_QUALIFIER typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const _GLM_SWIZZLE_TYPE1& a, const _GLM_SWIZZLE_TYPE1& b, const T& c)   \
+	{                                                                                                                         \
+		return FUNCTION(a(), b(), c);                                                                                         \
+	}                                                                                                                         \
+	_GLM_SWIZZLE_TEMPLATE1                                                                                                    \
+	GLM_FUNC_QUALIFIER typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const _GLM_SWIZZLE_TYPE1& a, const typename S0::vec_type& b, const T& c)\
+	{                                                                                                                         \
+		return FUNCTION(a(), b, c);                                                                                           \
+	}                                                                                                                         \
+	_GLM_SWIZZLE_TEMPLATE1                                                                                                    \
+	GLM_FUNC_QUALIFIER typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const typename V& a, const _GLM_SWIZZLE_TYPE1& b, const T& c)           \
+	{                                                                                                                         \
+		return FUNCTION(a, b(), c);                                                                                           \
+	} 
+ 
+}//namespace detail 
+}//namespace glm
+
+namespace glm
+{
+	namespace detail
+	{
+		_GLM_SWIZZLE_SCALAR_BINARY_OPERATOR_IMPLEMENTATION(-)
+		_GLM_SWIZZLE_SCALAR_BINARY_OPERATOR_IMPLEMENTATION(*)
+		_GLM_SWIZZLE_VECTOR_BINARY_OPERATOR_IMPLEMENTATION(+)
+		_GLM_SWIZZLE_VECTOR_BINARY_OPERATOR_IMPLEMENTATION(-)
+		_GLM_SWIZZLE_VECTOR_BINARY_OPERATOR_IMPLEMENTATION(*)
+		_GLM_SWIZZLE_VECTOR_BINARY_OPERATOR_IMPLEMENTATION(/)
+	}
+
+	//
+	// Swizzles are distinct types from the unswizzled type.  The below macros will
+	// provide template specializations for the swizzle types for the given functions
+	// so that the compiler does not have any ambiguity to choosing how to handle
+	// the function.
+	//
+	// The alternative is to use the operator()() when calling the function in order
+	// to explicitly convert the swizzled type to the unswizzled type.
+	//
+
+	//_GLM_SWIZZLE_FUNCTION_1_ARGS(vec_type,    abs);
+	//_GLM_SWIZZLE_FUNCTION_1_ARGS(vec_type,    acos);
+	//_GLM_SWIZZLE_FUNCTION_1_ARGS(vec_type,    acosh);
+	//_GLM_SWIZZLE_FUNCTION_1_ARGS(vec_type,    all);
+	//_GLM_SWIZZLE_FUNCTION_1_ARGS(vec_type,    any);
+
+	//_GLM_SWIZZLE_FUNCTION_2_ARGS(value_type,  dot);
+	//_GLM_SWIZZLE_FUNCTION_2_ARGS(vec_type,    cross);
+	//_GLM_SWIZZLE_FUNCTION_2_ARGS(vec_type,    step);    
+	//_GLM_SWIZZLE_FUNCTION_2_ARGS_SCALAR(vec_type, mix);
+}
+
+#define _GLM_SWIZZLE2_2_MEMBERS(T, P, V, E0,E1) \
+	struct { detail::_swizzle<2, T, P, V<T, P>, 0,0,-1,-2> E0 ## E0; }; \
+	struct { detail::_swizzle<2, T, P, V<T, P>, 0,1,-1,-2> E0 ## E1; }; \
+	struct { detail::_swizzle<2, T, P, V<T, P>, 1,0,-1,-2> E1 ## E0; }; \
+	struct { detail::_swizzle<2, T, P, V<T, P>, 1,1,-1,-2> E1 ## E1; }; 
+
+#define _GLM_SWIZZLE2_3_MEMBERS(T, P, V, E0,E1) \
+	struct { detail::_swizzle<3,T, P, V<T, P>, 0,0,0,-1> E0 ## E0 ## E0; }; \
+	struct { detail::_swizzle<3,T, P, V<T, P>, 0,0,1,-1> E0 ## E0 ## E1; }; \
+	struct { detail::_swizzle<3,T, P, V<T, P>, 0,1,0,-1> E0 ## E1 ## E0; }; \
+	struct { detail::_swizzle<3,T, P, V<T, P>, 0,1,1,-1> E0 ## E1 ## E1; }; \
+	struct { detail::_swizzle<3,T, P, V<T, P>, 1,0,0,-1> E1 ## E0 ## E0; }; \
+	struct { detail::_swizzle<3,T, P, V<T, P>, 1,0,1,-1> E1 ## E0 ## E1; }; \
+	struct { detail::_swizzle<3,T, P, V<T, P>, 1,1,0,-1> E1 ## E1 ## E0; }; \
+	struct { detail::_swizzle<3,T, P, V<T, P>, 1,1,1,-1> E1 ## E1 ## E1; };  
+
+#define _GLM_SWIZZLE2_4_MEMBERS(T, P, V, E0,E1) \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 0,0,0,0> E0 ## E0 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 0,0,0,1> E0 ## E0 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 0,0,1,0> E0 ## E0 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 0,0,1,1> E0 ## E0 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 0,1,0,0> E0 ## E1 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 0,1,0,1> E0 ## E1 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 0,1,1,0> E0 ## E1 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 0,1,1,1> E0 ## E1 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 1,0,0,0> E1 ## E0 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 1,0,0,1> E1 ## E0 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 1,0,1,0> E1 ## E0 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 1,0,1,1> E1 ## E0 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 1,1,0,0> E1 ## E1 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 1,1,0,1> E1 ## E1 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 1,1,1,0> E1 ## E1 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 1,1,1,1> E1 ## E1 ## E1 ## E1; };  
+
+#define _GLM_SWIZZLE3_2_MEMBERS(T, P, V, E0,E1,E2) \
+	struct { detail::_swizzle<2,T, P, V<T, P>, 0,0,-1,-2> E0 ## E0; }; \
+	struct { detail::_swizzle<2,T, P, V<T, P>, 0,1,-1,-2> E0 ## E1; }; \
+	struct { detail::_swizzle<2,T, P, V<T, P>, 0,2,-1,-2> E0 ## E2; }; \
+	struct { detail::_swizzle<2,T, P, V<T, P>, 1,0,-1,-2> E1 ## E0; }; \
+	struct { detail::_swizzle<2,T, P, V<T, P>, 1,1,-1,-2> E1 ## E1; }; \
+	struct { detail::_swizzle<2,T, P, V<T, P>, 1,2,-1,-2> E1 ## E2; }; \
+	struct { detail::_swizzle<2,T, P, V<T, P>, 2,0,-1,-2> E2 ## E0; }; \
+	struct { detail::_swizzle<2,T, P, V<T, P>, 2,1,-1,-2> E2 ## E1; }; \
+	struct { detail::_swizzle<2,T, P, V<T, P>, 2,2,-1,-2> E2 ## E2; }; 
+
+#define _GLM_SWIZZLE3_3_MEMBERS(T, P, V ,E0,E1,E2) \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 0,0,0,-1> E0 ## E0 ## E0; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 0,0,1,-1> E0 ## E0 ## E1; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 0,0,2,-1> E0 ## E0 ## E2; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 0,1,0,-1> E0 ## E1 ## E0; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 0,1,1,-1> E0 ## E1 ## E1; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 0,1,2,-1> E0 ## E1 ## E2; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 0,2,0,-1> E0 ## E2 ## E0; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 0,2,1,-1> E0 ## E2 ## E1; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 0,2,2,-1> E0 ## E2 ## E2; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 1,0,0,-1> E1 ## E0 ## E0; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 1,0,1,-1> E1 ## E0 ## E1; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 1,0,2,-1> E1 ## E0 ## E2; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 1,1,0,-1> E1 ## E1 ## E0; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 1,1,1,-1> E1 ## E1 ## E1; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 1,1,2,-1> E1 ## E1 ## E2; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 1,2,0,-1> E1 ## E2 ## E0; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 1,2,1,-1> E1 ## E2 ## E1; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 1,2,2,-1> E1 ## E2 ## E2; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 2,0,0,-1> E2 ## E0 ## E0; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 2,0,1,-1> E2 ## E0 ## E1; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 2,0,2,-1> E2 ## E0 ## E2; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 2,1,0,-1> E2 ## E1 ## E0; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 2,1,1,-1> E2 ## E1 ## E1; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 2,1,2,-1> E2 ## E1 ## E2; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 2,2,0,-1> E2 ## E2 ## E0; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 2,2,1,-1> E2 ## E2 ## E1; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 2,2,2,-1> E2 ## E2 ## E2; };
+
+#define _GLM_SWIZZLE3_4_MEMBERS(T, P, V, E0,E1,E2) \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 0,0,0,0> E0 ## E0 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 0,0,0,1> E0 ## E0 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 0,0,0,2> E0 ## E0 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 0,0,1,0> E0 ## E0 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 0,0,1,1> E0 ## E0 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 0,0,1,2> E0 ## E0 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 0,0,2,0> E0 ## E0 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 0,0,2,1> E0 ## E0 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 0,0,2,2> E0 ## E0 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 0,1,0,0> E0 ## E1 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 0,1,0,1> E0 ## E1 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 0,1,0,2> E0 ## E1 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 0,1,1,0> E0 ## E1 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 0,1,1,1> E0 ## E1 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 0,1,1,2> E0 ## E1 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 0,1,2,0> E0 ## E1 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 0,1,2,1> E0 ## E1 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 0,1,2,2> E0 ## E1 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 0,2,0,0> E0 ## E2 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 0,2,0,1> E0 ## E2 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 0,2,0,2> E0 ## E2 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 0,2,1,0> E0 ## E2 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 0,2,1,1> E0 ## E2 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 0,2,1,2> E0 ## E2 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 0,2,2,0> E0 ## E2 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 0,2,2,1> E0 ## E2 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 0,2,2,2> E0 ## E2 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 1,0,0,0> E1 ## E0 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 1,0,0,1> E1 ## E0 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 1,0,0,2> E1 ## E0 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 1,0,1,0> E1 ## E0 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 1,0,1,1> E1 ## E0 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 1,0,1,2> E1 ## E0 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 1,0,2,0> E1 ## E0 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 1,0,2,1> E1 ## E0 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 1,0,2,2> E1 ## E0 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 1,1,0,0> E1 ## E1 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 1,1,0,1> E1 ## E1 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 1,1,0,2> E1 ## E1 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 1,1,1,0> E1 ## E1 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 1,1,1,1> E1 ## E1 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 1,1,1,2> E1 ## E1 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 1,1,2,0> E1 ## E1 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 1,1,2,1> E1 ## E1 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 1,1,2,2> E1 ## E1 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 1,2,0,0> E1 ## E2 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 1,2,0,1> E1 ## E2 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 1,2,0,2> E1 ## E2 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 1,2,1,0> E1 ## E2 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 1,2,1,1> E1 ## E2 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 1,2,1,2> E1 ## E2 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 1,2,2,0> E1 ## E2 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 1,2,2,1> E1 ## E2 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 1,2,2,2> E1 ## E2 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 2,0,0,0> E2 ## E0 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 2,0,0,1> E2 ## E0 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 2,0,0,2> E2 ## E0 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 2,0,1,0> E2 ## E0 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 2,0,1,1> E2 ## E0 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 2,0,1,2> E2 ## E0 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 2,0,2,0> E2 ## E0 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 2,0,2,1> E2 ## E0 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 2,0,2,2> E2 ## E0 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 2,1,0,0> E2 ## E1 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 2,1,0,1> E2 ## E1 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 2,1,0,2> E2 ## E1 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 2,1,1,0> E2 ## E1 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 2,1,1,1> E2 ## E1 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 2,1,1,2> E2 ## E1 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 2,1,2,0> E2 ## E1 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 2,1,2,1> E2 ## E1 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 2,1,2,2> E2 ## E1 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 2,2,0,0> E2 ## E2 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 2,2,0,1> E2 ## E2 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 2,2,0,2> E2 ## E2 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 2,2,1,0> E2 ## E2 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 2,2,1,1> E2 ## E2 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 2,2,1,2> E2 ## E2 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 2,2,2,0> E2 ## E2 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 2,2,2,1> E2 ## E2 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4,T, P, V<T, P>, 2,2,2,2> E2 ## E2 ## E2 ## E2; }; 
+
+#define _GLM_SWIZZLE4_2_MEMBERS(T, P, V, E0,E1,E2,E3) \
+	struct { detail::_swizzle<2,T, P, V<T, P>, 0,0,-1,-2> E0 ## E0; }; \
+	struct { detail::_swizzle<2,T, P, V<T, P>, 0,1,-1,-2> E0 ## E1; }; \
+	struct { detail::_swizzle<2,T, P, V<T, P>, 0,2,-1,-2> E0 ## E2; }; \
+	struct { detail::_swizzle<2,T, P, V<T, P>, 0,3,-1,-2> E0 ## E3; }; \
+	struct { detail::_swizzle<2,T, P, V<T, P>, 1,0,-1,-2> E1 ## E0; }; \
+	struct { detail::_swizzle<2,T, P, V<T, P>, 1,1,-1,-2> E1 ## E1; }; \
+	struct { detail::_swizzle<2,T, P, V<T, P>, 1,2,-1,-2> E1 ## E2; }; \
+	struct { detail::_swizzle<2,T, P, V<T, P>, 1,3,-1,-2> E1 ## E3; }; \
+	struct { detail::_swizzle<2,T, P, V<T, P>, 2,0,-1,-2> E2 ## E0; }; \
+	struct { detail::_swizzle<2,T, P, V<T, P>, 2,1,-1,-2> E2 ## E1; }; \
+	struct { detail::_swizzle<2,T, P, V<T, P>, 2,2,-1,-2> E2 ## E2; }; \
+	struct { detail::_swizzle<2,T, P, V<T, P>, 2,3,-1,-2> E2 ## E3; }; \
+	struct { detail::_swizzle<2,T, P, V<T, P>, 3,0,-1,-2> E3 ## E0; }; \
+	struct { detail::_swizzle<2,T, P, V<T, P>, 3,1,-1,-2> E3 ## E1; }; \
+	struct { detail::_swizzle<2,T, P, V<T, P>, 3,2,-1,-2> E3 ## E2; }; \
+	struct { detail::_swizzle<2,T, P, V<T, P>, 3,3,-1,-2> E3 ## E3; }; 
+
+#define _GLM_SWIZZLE4_3_MEMBERS(T,P, V, E0,E1,E2,E3) \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 0,0,0,-1> E0 ## E0 ## E0; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 0,0,1,-1> E0 ## E0 ## E1; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 0,0,2,-1> E0 ## E0 ## E2; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 0,0,3,-1> E0 ## E0 ## E3; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 0,1,0,-1> E0 ## E1 ## E0; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 0,1,1,-1> E0 ## E1 ## E1; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 0,1,2,-1> E0 ## E1 ## E2; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 0,1,3,-1> E0 ## E1 ## E3; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 0,2,0,-1> E0 ## E2 ## E0; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 0,2,1,-1> E0 ## E2 ## E1; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 0,2,2,-1> E0 ## E2 ## E2; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 0,2,3,-1> E0 ## E2 ## E3; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 0,3,0,-1> E0 ## E3 ## E0; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 0,3,1,-1> E0 ## E3 ## E1; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 0,3,2,-1> E0 ## E3 ## E2; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 0,3,3,-1> E0 ## E3 ## E3; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 1,0,0,-1> E1 ## E0 ## E0; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 1,0,1,-1> E1 ## E0 ## E1; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 1,0,2,-1> E1 ## E0 ## E2; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 1,0,3,-1> E1 ## E0 ## E3; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 1,1,0,-1> E1 ## E1 ## E0; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 1,1,1,-1> E1 ## E1 ## E1; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 1,1,2,-1> E1 ## E1 ## E2; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 1,1,3,-1> E1 ## E1 ## E3; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 1,2,0,-1> E1 ## E2 ## E0; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 1,2,1,-1> E1 ## E2 ## E1; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 1,2,2,-1> E1 ## E2 ## E2; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 1,2,3,-1> E1 ## E2 ## E3; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 1,3,0,-1> E1 ## E3 ## E0; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 1,3,1,-1> E1 ## E3 ## E1; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 1,3,2,-1> E1 ## E3 ## E2; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 1,3,3,-1> E1 ## E3 ## E3; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 2,0,0,-1> E2 ## E0 ## E0; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 2,0,1,-1> E2 ## E0 ## E1; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 2,0,2,-1> E2 ## E0 ## E2; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 2,0,3,-1> E2 ## E0 ## E3; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 2,1,0,-1> E2 ## E1 ## E0; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 2,1,1,-1> E2 ## E1 ## E1; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 2,1,2,-1> E2 ## E1 ## E2; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 2,1,3,-1> E2 ## E1 ## E3; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 2,2,0,-1> E2 ## E2 ## E0; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 2,2,1,-1> E2 ## E2 ## E1; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 2,2,2,-1> E2 ## E2 ## E2; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 2,2,3,-1> E2 ## E2 ## E3; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 2,3,0,-1> E2 ## E3 ## E0; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 2,3,1,-1> E2 ## E3 ## E1; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 2,3,2,-1> E2 ## E3 ## E2; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 2,3,3,-1> E2 ## E3 ## E3; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 3,0,0,-1> E3 ## E0 ## E0; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 3,0,1,-1> E3 ## E0 ## E1; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 3,0,2,-1> E3 ## E0 ## E2; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 3,0,3,-1> E3 ## E0 ## E3; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 3,1,0,-1> E3 ## E1 ## E0; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 3,1,1,-1> E3 ## E1 ## E1; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 3,1,2,-1> E3 ## E1 ## E2; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 3,1,3,-1> E3 ## E1 ## E3; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 3,2,0,-1> E3 ## E2 ## E0; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 3,2,1,-1> E3 ## E2 ## E1; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 3,2,2,-1> E3 ## E2 ## E2; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 3,2,3,-1> E3 ## E2 ## E3; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 3,3,0,-1> E3 ## E3 ## E0; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 3,3,1,-1> E3 ## E3 ## E1; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 3,3,2,-1> E3 ## E3 ## E2; }; \
+	struct { detail::_swizzle<3,T,P, V<T, P>, 3,3,3,-1> E3 ## E3 ## E3; };  
+
+#define _GLM_SWIZZLE4_4_MEMBERS(T, P, V, E0,E1,E2,E3) \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 0,0,0,0> E0 ## E0 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 0,0,0,1> E0 ## E0 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 0,0,0,2> E0 ## E0 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 0,0,0,3> E0 ## E0 ## E0 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 0,0,1,0> E0 ## E0 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 0,0,1,1> E0 ## E0 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 0,0,1,2> E0 ## E0 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 0,0,1,3> E0 ## E0 ## E1 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 0,0,2,0> E0 ## E0 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 0,0,2,1> E0 ## E0 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 0,0,2,2> E0 ## E0 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 0,0,2,3> E0 ## E0 ## E2 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 0,0,3,0> E0 ## E0 ## E3 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 0,0,3,1> E0 ## E0 ## E3 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 0,0,3,2> E0 ## E0 ## E3 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 0,0,3,3> E0 ## E0 ## E3 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 0,1,0,0> E0 ## E1 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 0,1,0,1> E0 ## E1 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 0,1,0,2> E0 ## E1 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 0,1,0,3> E0 ## E1 ## E0 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 0,1,1,0> E0 ## E1 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 0,1,1,1> E0 ## E1 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 0,1,1,2> E0 ## E1 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 0,1,1,3> E0 ## E1 ## E1 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 0,1,2,0> E0 ## E1 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 0,1,2,1> E0 ## E1 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 0,1,2,2> E0 ## E1 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 0,1,2,3> E0 ## E1 ## E2 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 0,1,3,0> E0 ## E1 ## E3 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 0,1,3,1> E0 ## E1 ## E3 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 0,1,3,2> E0 ## E1 ## E3 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 0,1,3,3> E0 ## E1 ## E3 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 0,2,0,0> E0 ## E2 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 0,2,0,1> E0 ## E2 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 0,2,0,2> E0 ## E2 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 0,2,0,3> E0 ## E2 ## E0 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 0,2,1,0> E0 ## E2 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 0,2,1,1> E0 ## E2 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 0,2,1,2> E0 ## E2 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 0,2,1,3> E0 ## E2 ## E1 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 0,2,2,0> E0 ## E2 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 0,2,2,1> E0 ## E2 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 0,2,2,2> E0 ## E2 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 0,2,2,3> E0 ## E2 ## E2 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 0,2,3,0> E0 ## E2 ## E3 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 0,2,3,1> E0 ## E2 ## E3 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 0,2,3,2> E0 ## E2 ## E3 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 0,2,3,3> E0 ## E2 ## E3 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 0,3,0,0> E0 ## E3 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 0,3,0,1> E0 ## E3 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 0,3,0,2> E0 ## E3 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 0,3,0,3> E0 ## E3 ## E0 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 0,3,1,0> E0 ## E3 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 0,3,1,1> E0 ## E3 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 0,3,1,2> E0 ## E3 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 0,3,1,3> E0 ## E3 ## E1 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 0,3,2,0> E0 ## E3 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 0,3,2,1> E0 ## E3 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 0,3,2,2> E0 ## E3 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 0,3,2,3> E0 ## E3 ## E2 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 0,3,3,0> E0 ## E3 ## E3 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 0,3,3,1> E0 ## E3 ## E3 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 0,3,3,2> E0 ## E3 ## E3 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 0,3,3,3> E0 ## E3 ## E3 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 1,0,0,0> E1 ## E0 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 1,0,0,1> E1 ## E0 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 1,0,0,2> E1 ## E0 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 1,0,0,3> E1 ## E0 ## E0 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 1,0,1,0> E1 ## E0 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 1,0,1,1> E1 ## E0 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 1,0,1,2> E1 ## E0 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 1,0,1,3> E1 ## E0 ## E1 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 1,0,2,0> E1 ## E0 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 1,0,2,1> E1 ## E0 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 1,0,2,2> E1 ## E0 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 1,0,2,3> E1 ## E0 ## E2 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 1,0,3,0> E1 ## E0 ## E3 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 1,0,3,1> E1 ## E0 ## E3 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 1,0,3,2> E1 ## E0 ## E3 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 1,0,3,3> E1 ## E0 ## E3 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 1,1,0,0> E1 ## E1 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 1,1,0,1> E1 ## E1 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 1,1,0,2> E1 ## E1 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 1,1,0,3> E1 ## E1 ## E0 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 1,1,1,0> E1 ## E1 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 1,1,1,1> E1 ## E1 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 1,1,1,2> E1 ## E1 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 1,1,1,3> E1 ## E1 ## E1 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 1,1,2,0> E1 ## E1 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 1,1,2,1> E1 ## E1 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 1,1,2,2> E1 ## E1 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 1,1,2,3> E1 ## E1 ## E2 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 1,1,3,0> E1 ## E1 ## E3 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 1,1,3,1> E1 ## E1 ## E3 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 1,1,3,2> E1 ## E1 ## E3 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 1,1,3,3> E1 ## E1 ## E3 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 1,2,0,0> E1 ## E2 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 1,2,0,1> E1 ## E2 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 1,2,0,2> E1 ## E2 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 1,2,0,3> E1 ## E2 ## E0 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 1,2,1,0> E1 ## E2 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 1,2,1,1> E1 ## E2 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 1,2,1,2> E1 ## E2 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 1,2,1,3> E1 ## E2 ## E1 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 1,2,2,0> E1 ## E2 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 1,2,2,1> E1 ## E2 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 1,2,2,2> E1 ## E2 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 1,2,2,3> E1 ## E2 ## E2 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 1,2,3,0> E1 ## E2 ## E3 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 1,2,3,1> E1 ## E2 ## E3 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 1,2,3,2> E1 ## E2 ## E3 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 1,2,3,3> E1 ## E2 ## E3 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 1,3,0,0> E1 ## E3 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 1,3,0,1> E1 ## E3 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 1,3,0,2> E1 ## E3 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 1,3,0,3> E1 ## E3 ## E0 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 1,3,1,0> E1 ## E3 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 1,3,1,1> E1 ## E3 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 1,3,1,2> E1 ## E3 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 1,3,1,3> E1 ## E3 ## E1 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 1,3,2,0> E1 ## E3 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 1,3,2,1> E1 ## E3 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 1,3,2,2> E1 ## E3 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 1,3,2,3> E1 ## E3 ## E2 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 1,3,3,0> E1 ## E3 ## E3 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 1,3,3,1> E1 ## E3 ## E3 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 1,3,3,2> E1 ## E3 ## E3 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 1,3,3,3> E1 ## E3 ## E3 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 2,0,0,0> E2 ## E0 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 2,0,0,1> E2 ## E0 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 2,0,0,2> E2 ## E0 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 2,0,0,3> E2 ## E0 ## E0 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 2,0,1,0> E2 ## E0 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 2,0,1,1> E2 ## E0 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 2,0,1,2> E2 ## E0 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 2,0,1,3> E2 ## E0 ## E1 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 2,0,2,0> E2 ## E0 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 2,0,2,1> E2 ## E0 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 2,0,2,2> E2 ## E0 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 2,0,2,3> E2 ## E0 ## E2 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 2,0,3,0> E2 ## E0 ## E3 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 2,0,3,1> E2 ## E0 ## E3 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 2,0,3,2> E2 ## E0 ## E3 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 2,0,3,3> E2 ## E0 ## E3 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 2,1,0,0> E2 ## E1 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 2,1,0,1> E2 ## E1 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 2,1,0,2> E2 ## E1 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 2,1,0,3> E2 ## E1 ## E0 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 2,1,1,0> E2 ## E1 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 2,1,1,1> E2 ## E1 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 2,1,1,2> E2 ## E1 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 2,1,1,3> E2 ## E1 ## E1 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 2,1,2,0> E2 ## E1 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 2,1,2,1> E2 ## E1 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 2,1,2,2> E2 ## E1 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 2,1,2,3> E2 ## E1 ## E2 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 2,1,3,0> E2 ## E1 ## E3 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 2,1,3,1> E2 ## E1 ## E3 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 2,1,3,2> E2 ## E1 ## E3 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 2,1,3,3> E2 ## E1 ## E3 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 2,2,0,0> E2 ## E2 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 2,2,0,1> E2 ## E2 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 2,2,0,2> E2 ## E2 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 2,2,0,3> E2 ## E2 ## E0 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 2,2,1,0> E2 ## E2 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 2,2,1,1> E2 ## E2 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 2,2,1,2> E2 ## E2 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 2,2,1,3> E2 ## E2 ## E1 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 2,2,2,0> E2 ## E2 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 2,2,2,1> E2 ## E2 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 2,2,2,2> E2 ## E2 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 2,2,2,3> E2 ## E2 ## E2 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 2,2,3,0> E2 ## E2 ## E3 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 2,2,3,1> E2 ## E2 ## E3 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 2,2,3,2> E2 ## E2 ## E3 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 2,2,3,3> E2 ## E2 ## E3 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 2,3,0,0> E2 ## E3 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 2,3,0,1> E2 ## E3 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 2,3,0,2> E2 ## E3 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 2,3,0,3> E2 ## E3 ## E0 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 2,3,1,0> E2 ## E3 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 2,3,1,1> E2 ## E3 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 2,3,1,2> E2 ## E3 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 2,3,1,3> E2 ## E3 ## E1 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 2,3,2,0> E2 ## E3 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 2,3,2,1> E2 ## E3 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 2,3,2,2> E2 ## E3 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 2,3,2,3> E2 ## E3 ## E2 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 2,3,3,0> E2 ## E3 ## E3 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 2,3,3,1> E2 ## E3 ## E3 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 2,3,3,2> E2 ## E3 ## E3 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 2,3,3,3> E2 ## E3 ## E3 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 3,0,0,0> E3 ## E0 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 3,0,0,1> E3 ## E0 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 3,0,0,2> E3 ## E0 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 3,0,0,3> E3 ## E0 ## E0 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 3,0,1,0> E3 ## E0 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 3,0,1,1> E3 ## E0 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 3,0,1,2> E3 ## E0 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 3,0,1,3> E3 ## E0 ## E1 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 3,0,2,0> E3 ## E0 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 3,0,2,1> E3 ## E0 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 3,0,2,2> E3 ## E0 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 3,0,2,3> E3 ## E0 ## E2 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 3,0,3,0> E3 ## E0 ## E3 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 3,0,3,1> E3 ## E0 ## E3 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 3,0,3,2> E3 ## E0 ## E3 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 3,0,3,3> E3 ## E0 ## E3 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 3,1,0,0> E3 ## E1 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 3,1,0,1> E3 ## E1 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 3,1,0,2> E3 ## E1 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 3,1,0,3> E3 ## E1 ## E0 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 3,1,1,0> E3 ## E1 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 3,1,1,1> E3 ## E1 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 3,1,1,2> E3 ## E1 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 3,1,1,3> E3 ## E1 ## E1 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 3,1,2,0> E3 ## E1 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 3,1,2,1> E3 ## E1 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 3,1,2,2> E3 ## E1 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 3,1,2,3> E3 ## E1 ## E2 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 3,1,3,0> E3 ## E1 ## E3 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 3,1,3,1> E3 ## E1 ## E3 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 3,1,3,2> E3 ## E1 ## E3 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 3,1,3,3> E3 ## E1 ## E3 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 3,2,0,0> E3 ## E2 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 3,2,0,1> E3 ## E2 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 3,2,0,2> E3 ## E2 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 3,2,0,3> E3 ## E2 ## E0 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 3,2,1,0> E3 ## E2 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 3,2,1,1> E3 ## E2 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 3,2,1,2> E3 ## E2 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 3,2,1,3> E3 ## E2 ## E1 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 3,2,2,0> E3 ## E2 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 3,2,2,1> E3 ## E2 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 3,2,2,2> E3 ## E2 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 3,2,2,3> E3 ## E2 ## E2 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 3,2,3,0> E3 ## E2 ## E3 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 3,2,3,1> E3 ## E2 ## E3 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 3,2,3,2> E3 ## E2 ## E3 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 3,2,3,3> E3 ## E2 ## E3 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 3,3,0,0> E3 ## E3 ## E0 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 3,3,0,1> E3 ## E3 ## E0 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 3,3,0,2> E3 ## E3 ## E0 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 3,3,0,3> E3 ## E3 ## E0 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 3,3,1,0> E3 ## E3 ## E1 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 3,3,1,1> E3 ## E3 ## E1 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 3,3,1,2> E3 ## E3 ## E1 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 3,3,1,3> E3 ## E3 ## E1 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 3,3,2,0> E3 ## E3 ## E2 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 3,3,2,1> E3 ## E3 ## E2 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 3,3,2,2> E3 ## E3 ## E2 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 3,3,2,3> E3 ## E3 ## E2 ## E3; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 3,3,3,0> E3 ## E3 ## E3 ## E0; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 3,3,3,1> E3 ## E3 ## E3 ## E1; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 3,3,3,2> E3 ## E3 ## E3 ## E2; }; \
+	struct { detail::_swizzle<4, T, P, V<T, P>, 3,3,3,3> E3 ## E3 ## E3 ## E3; };

glm/glm/detail/_swizzle_func.hpp

@@ -0,0 +1,725 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// 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.
+///
+/// @ref core
+/// @file glm/detail/_swizzle_func.hpp
+/// @date 2011-10-16 / 2011-10-16
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#pragma once
+
+#define GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, CONST, A, B)	\
+	SWIZZLED_TYPE<TMPL_TYPE, PRECISION> A ## B() CONST												\
+	{																								\
+		return SWIZZLED_TYPE<TMPL_TYPE, PRECISION>(this->A, this->B);								\
+	}
+
+#define GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, CONST, A, B, C)		\
+	SWIZZLED_TYPE<TMPL_TYPE, PRECISION> A ## B ## C() CONST												\
+	{																									\
+		return SWIZZLED_TYPE<TMPL_TYPE, PRECISION>(this->A, this->B, this->C);							\
+	}
+
+#define GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, CONST, A, B, C, D)	\
+	SWIZZLED_TYPE<TMPL_TYPE, PRECISION> A ## B ## C ## D() CONST										\
+	{																									\
+		return SWIZZLED_TYPE<TMPL_TYPE, PRECISION>(this->A, this->B, this->C, this->D);					\
+	}
+
+#define GLM_SWIZZLE_GEN_VEC2_ENTRY_DEF(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, CONST, A, B)	\
+	template <typename TMPL_TYPE>																		\
+	SWIZZLED_TYPE<TMPL_TYPE> CLASS_TYPE<TMPL_TYPE, PRECISION>::A ## B() CONST							\
+	{																									\
+		return SWIZZLED_TYPE<TMPL_TYPE, PRECISION>(this->A, this->B);									\
+	}
+
+#define GLM_SWIZZLE_GEN_VEC3_ENTRY_DEF(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, CONST, A, B, C)		\
+	template <typename TMPL_TYPE>																			\
+	SWIZZLED_TYPE<TMPL_TYPE> CLASS_TYPE<TMPL_TYPE, PRECISION>::A ## B ## C() CONST							\
+	{																										\
+		return SWIZZLED_TYPE<TMPL_TYPE, PRECISION>(this->A, this->B, this->C);								\
+	}
+
+#define GLM_SWIZZLE_GEN_VEC4_ENTRY_DEF(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, CONST, A, B, C, D)	\
+	template <typename TMPL_TYPE>																			\
+	SWIZZLED_TYPE<TMPL_TYPE> CLASS_TYPE<TMPL_TYPE, PRECISION>::A ## B ## C ## D() CONST						\
+	{																										\
+		return SWIZZLED_TYPE<TMPL_TYPE, PRECISION>(this->A, this->B, this->C, this->D);						\
+	}
+
+#define GLM_MUTABLE
+
+#define GLM_SWIZZLE_GEN_REF2_FROM_VEC2_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, A, B) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, B, A)
+
+#define GLM_SWIZZLE_GEN_REF_FROM_VEC2(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE) \
+	GLM_SWIZZLE_GEN_REF2_FROM_VEC2_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, x, y) \
+	GLM_SWIZZLE_GEN_REF2_FROM_VEC2_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, r, g) \
+	GLM_SWIZZLE_GEN_REF2_FROM_VEC2_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, s, t)
+
+//GLM_SWIZZLE_GEN_REF_FROM_VEC2(valType, detail::vec2, detail::ref2)
+
+#define GLM_SWIZZLE_GEN_REF2_FROM_VEC3_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, A, B) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, A, C) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, B, A) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, B, C) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, C, A) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, C, B)
+
+#define GLM_SWIZZLE_GEN_REF3_FROM_VEC3_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, A, C, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, B, A, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, B, C, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, C, A, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, C, B, A)
+
+#define GLM_SWIZZLE_GEN_REF_FROM_VEC3_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, A, B, C) \
+	GLM_SWIZZLE_GEN_REF3_FROM_VEC3_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC3_TYPE, A, B, C) \
+	GLM_SWIZZLE_GEN_REF2_FROM_VEC3_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, A, B, C)
+
+#define GLM_SWIZZLE_GEN_REF_FROM_VEC3(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE) \
+	GLM_SWIZZLE_GEN_REF_FROM_VEC3_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, x, y, z) \
+	GLM_SWIZZLE_GEN_REF_FROM_VEC3_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, r, g, b) \
+	GLM_SWIZZLE_GEN_REF_FROM_VEC3_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, s, t, p)
+
+//GLM_SWIZZLE_GEN_REF_FROM_VEC3(valType, detail::vec3, detail::ref2, detail::ref3)
+
+#define GLM_SWIZZLE_GEN_REF2_FROM_VEC4_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B, C, D) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, A, B) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, A, C) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, A, D) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, B, A) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, B, C) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, B, D) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, C, A) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, C, B) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, C, D) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, D, A) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, D, B) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, D, C)
+
+#define GLM_SWIZZLE_GEN_REF3_FROM_VEC4_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B, C, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , A, B, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , A, B, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , A, C, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , A, C, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , A, D, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , A, D, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , B, A, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , B, A, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , B, C, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , B, C, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , B, D, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , B, D, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , C, A, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , C, A, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , C, B, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , C, B, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , C, D, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , C, D, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , D, A, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , D, A, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , D, B, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , D, B, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , D, C, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , D, C, B)
+
+#define GLM_SWIZZLE_GEN_REF4_FROM_VEC4_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , A, C, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , A, C, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , A, D, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , A, D, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , A, B, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , A, B, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , B, C, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , B, C, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , B, D, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , B, D, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , B, A, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , B, A, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , C, B, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , C, B, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , C, D, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , C, D, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , C, A, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , C, A, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , D, C, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , D, C, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , D, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , D, A, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , D, B, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, , D, B, C, A)
+
+#define GLM_SWIZZLE_GEN_REF_FROM_VEC4_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, A, B, C, D) \
+	GLM_SWIZZLE_GEN_REF2_FROM_VEC4_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, A, B, C, D) \
+	GLM_SWIZZLE_GEN_REF3_FROM_VEC4_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC3_TYPE, A, B, C, D) \
+	GLM_SWIZZLE_GEN_REF4_FROM_VEC4_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC4_TYPE, A, B, C, D)
+
+#define GLM_SWIZZLE_GEN_REF_FROM_VEC4(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE) \
+	GLM_SWIZZLE_GEN_REF_FROM_VEC4_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, x, y, z, w) \
+	GLM_SWIZZLE_GEN_REF_FROM_VEC4_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, r, g, b, a) \
+	GLM_SWIZZLE_GEN_REF_FROM_VEC4_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, s, t, p, q)
+
+//GLM_SWIZZLE_GEN_REF_FROM_VEC4(valType, detail::vec4, detail::ref2, detail::ref3, detail::ref4)
+
+#define GLM_SWIZZLE_GEN_VEC2_FROM_VEC2_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B)
+
+#define GLM_SWIZZLE_GEN_VEC3_FROM_VEC2_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B)
+
+#define GLM_SWIZZLE_GEN_VEC4_FROM_VEC2_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B, B)
+
+#define GLM_SWIZZLE_GEN_VEC_FROM_VEC2_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, A, B) \
+	GLM_SWIZZLE_GEN_VEC2_FROM_VEC2_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, A, B) \
+	GLM_SWIZZLE_GEN_VEC3_FROM_VEC2_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC3_TYPE, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_FROM_VEC2_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC4_TYPE, A, B)
+
+#define GLM_SWIZZLE_GEN_VEC_FROM_VEC2(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE)			\
+	GLM_SWIZZLE_GEN_VEC_FROM_VEC2_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, x, y)	\
+	GLM_SWIZZLE_GEN_VEC_FROM_VEC2_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, r, g)	\
+	GLM_SWIZZLE_GEN_VEC_FROM_VEC2_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, s, t)
+
+//GLM_SWIZZLE_GEN_VEC_FROM_VEC2(valType, detail::vec2, detail::vec2, detail::vec3, detail::vec4)
+
+#define GLM_SWIZZLE_GEN_VEC2_FROM_VEC3_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C)
+
+#define GLM_SWIZZLE_GEN_VEC3_FROM_VEC3_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, C)
+
+#define GLM_SWIZZLE_GEN_VEC4_FROM_VEC3_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, C, C)
+
+#define GLM_SWIZZLE_GEN_VEC_FROM_VEC3_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC2_FROM_VEC3_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC3_FROM_VEC3_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC3_TYPE, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_FROM_VEC3_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC4_TYPE, A, B, C)
+
+#define GLM_SWIZZLE_GEN_VEC_FROM_VEC3(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE) \
+	GLM_SWIZZLE_GEN_VEC_FROM_VEC3_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, x, y, z) \
+	GLM_SWIZZLE_GEN_VEC_FROM_VEC3_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, r, g, b) \
+	GLM_SWIZZLE_GEN_VEC_FROM_VEC3_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, s, t, p)
+
+//GLM_SWIZZLE_GEN_VEC_FROM_VEC3(valType, detail::vec3, detail::vec2, detail::vec3, detail::vec4)
+
+#define GLM_SWIZZLE_GEN_VEC2_FROM_VEC4_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B, C, D) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C) \
+	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D)
+
+#define GLM_SWIZZLE_GEN_VEC3_FROM_VEC4_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B, C, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, D) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, A) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, B) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, C) \
+	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, D)
+
+#define GLM_SWIZZLE_GEN_VEC4_FROM_VEC4_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, A, B, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, D, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, D, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, D, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, D, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, D, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, D, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, D, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, D, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, D, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, D, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, D, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, D, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, D, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, D, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, D, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, A, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, A, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, A, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, A, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, B, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, B, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, B, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, B, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, C, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, C, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, C, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, D, A) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, D, B) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, D, C) \
+	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, D, D)
+
+#define GLM_SWIZZLE_GEN_VEC_FROM_VEC4_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, A, B, C, D) \
+	GLM_SWIZZLE_GEN_VEC2_FROM_VEC4_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, A, B, C, D) \
+	GLM_SWIZZLE_GEN_VEC3_FROM_VEC4_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC3_TYPE, A, B, C, D) \
+	GLM_SWIZZLE_GEN_VEC4_FROM_VEC4_SWIZZLE(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC4_TYPE, A, B, C, D)
+
+#define GLM_SWIZZLE_GEN_VEC_FROM_VEC4(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE) \
+	GLM_SWIZZLE_GEN_VEC_FROM_VEC4_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, x, y, z, w) \
+	GLM_SWIZZLE_GEN_VEC_FROM_VEC4_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, r, g, b, a) \
+	GLM_SWIZZLE_GEN_VEC_FROM_VEC4_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, s, t, p, q)
+
+//GLM_SWIZZLE_GEN_VEC_FROM_VEC4(valType, detail::vec4, detail::vec2, detail::vec3, detail::vec4)

glm/glm/detail/_vectorize.hpp

@@ -0,0 +1,160 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// 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.
+///
+/// @ref core
+/// @file glm/detail/_vectorize.hpp
+/// @date 2011-10-14 / 2011-10-14
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#pragma once
+
+#include "type_vec1.hpp"
+#include "type_vec2.hpp"
+#include "type_vec3.hpp"
+#include "type_vec4.hpp"
+
+namespace glm{
+namespace detail
+{
+	template <typename R, typename T, precision P, template <typename, precision> class vecType>
+	struct functor1{};
+
+	template <typename R, typename T, precision P>
+	struct functor1<R, T, P, tvec1>
+	{
+		GLM_FUNC_QUALIFIER static tvec1<R, P> call(R (*Func) (T x), tvec1<T, P> const & v)
+		{
+			return tvec1<R, P>(Func(v.x));
+		}
+	};
+
+	template <typename R, typename T, precision P>
+	struct functor1<R, T, P, tvec2>
+	{
+		GLM_FUNC_QUALIFIER static tvec2<R, P> call(R (*Func) (T x), tvec2<T, P> const & v)
+		{
+			return tvec2<R, P>(Func(v.x), Func(v.y));
+		}
+	};
+
+	template <typename R, typename T, precision P>
+	struct functor1<R, T, P, tvec3>
+	{
+		GLM_FUNC_QUALIFIER static tvec3<R, P> call(R (*Func) (T x), tvec3<T, P> const & v)
+		{
+			return tvec3<R, P>(Func(v.x), Func(v.y), Func(v.z));
+		}
+	};
+
+	template <typename R, typename T, precision P>
+	struct functor1<R, T, P, tvec4>
+	{
+		GLM_FUNC_QUALIFIER static tvec4<R, P> call(R (*Func) (T x), tvec4<T, P> const & v)
+		{
+			return tvec4<R, P>(Func(v.x), Func(v.y), Func(v.z), Func(v.w));
+		}
+	};
+
+	template <typename T, precision P, template <typename, precision> class vecType>
+	struct functor2{};
+
+	template <typename T, precision P>
+	struct functor2<T, P, tvec1>
+	{
+		GLM_FUNC_QUALIFIER static tvec1<T, P> call(T (*Func) (T x, T y), tvec1<T, P> const & a, tvec1<T, P> const & b)
+		{
+			return tvec1<T, P>(Func(a.x, b.x));
+		}
+	};
+
+	template <typename T, precision P>
+	struct functor2<T, P, tvec2>
+	{
+		GLM_FUNC_QUALIFIER static tvec2<T, P> call(T (*Func) (T x, T y), tvec2<T, P> const & a, tvec2<T, P> const & b)
+		{
+			return tvec2<T, P>(Func(a.x, b.x), Func(a.y, b.y));
+		}
+	};
+
+	template <typename T, precision P>
+	struct functor2<T, P, tvec3>
+	{
+		GLM_FUNC_QUALIFIER static tvec3<T, P> call(T (*Func) (T x, T y), tvec3<T, P> const & a, tvec3<T, P> const & b)
+		{
+			return tvec3<T, P>(Func(a.x, b.x), Func(a.y, b.y), Func(a.z, b.z));
+		}
+	};
+
+	template <typename T, precision P>
+	struct functor2<T, P, tvec4>
+	{
+		GLM_FUNC_QUALIFIER static tvec4<T, P> call(T (*Func) (T x, T y), tvec4<T, P> const & a, tvec4<T, P> const & b)
+		{
+			return tvec4<T, P>(Func(a.x, b.x), Func(a.y, b.y), Func(a.z, b.z), Func(a.w, b.w));
+		}
+	};
+
+	template <typename T, precision P, template <typename, precision> class vecType>
+	struct functor2_vec_sca{};
+
+	template <typename T, precision P>
+	struct functor2_vec_sca<T, P, tvec1>
+	{
+		GLM_FUNC_QUALIFIER static tvec1<T, P> call(T (*Func) (T x, T y), tvec1<T, P> const & a, T b)
+		{
+			return tvec1<T, P>(Func(a.x, b));
+		}
+	};
+
+	template <typename T, precision P>
+	struct functor2_vec_sca<T, P, tvec2>
+	{
+		GLM_FUNC_QUALIFIER static tvec2<T, P> call(T (*Func) (T x, T y), tvec2<T, P> const & a, T b)
+		{
+			return tvec2<T, P>(Func(a.x, b), Func(a.y, b));
+		}
+	};
+
+	template <typename T, precision P>
+	struct functor2_vec_sca<T, P, tvec3>
+	{
+		GLM_FUNC_QUALIFIER static tvec3<T, P> call(T (*Func) (T x, T y), tvec3<T, P> const & a, T b)
+		{
+			return tvec3<T, P>(Func(a.x, b), Func(a.y, b), Func(a.z, b));
+		}
+	};
+
+	template <typename T, precision P>
+	struct functor2_vec_sca<T, P, tvec4>
+	{
+		GLM_FUNC_QUALIFIER static tvec4<T, P> call(T (*Func) (T x, T y), tvec4<T, P> const & a, T b)
+		{
+			return tvec4<T, P>(Func(a.x, b), Func(a.y, b), Func(a.z, b), Func(a.w, b));
+		}
+	};
+}//namespace detail
+}//namespace glm

glm/glm/detail/dummy.cpp

@@ -0,0 +1,232 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// 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.
+///
+/// @ref core
+/// @file glm/core/dummy.cpp
+/// @date 2011-01-19 / 2011-06-15
+/// @author Christophe Riccio
+///
+/// GLM is a header only library. There is nothing to compile. 
+/// dummy.cpp exist only a wordaround for CMake file.
+///////////////////////////////////////////////////////////////////////////////////
+
+#define GLM_MESSAGES
+#include <glm/glm.hpp>
+#include <glm/ext.hpp>
+#include <limits>
+
+struct material
+{
+	glm::vec4 emission; // Ecm
+	glm::vec4 ambient; // Acm
+	glm::vec4 diffuse; // Dcm
+	glm::vec4 specular; // Scm
+	float shininess; // Srm
+};
+
+struct light
+{
+	glm::vec4 ambient; // Acli
+	glm::vec4 diffuse; // Dcli
+	glm::vec4 specular; // Scli
+	glm::vec4 position; // Ppli
+	glm::vec4 halfVector; // Derived: Hi
+	glm::vec3 spotDirection; // Sdli
+	float spotExponent; // Srli
+	float spotCutoff; // Crli
+	// (range: [0.0,90.0], 180.0)
+	float spotCosCutoff; // Derived: cos(Crli)
+	// (range: [1.0,0.0],-1.0)
+	float constantAttenuation; // K0
+	float linearAttenuation; // K1
+	float quadraticAttenuation;// K2
+};
+
+
+// Sample 1
+#include <glm/vec3.hpp>// glm::vec3
+#include <glm/geometric.hpp>// glm::cross, glm::normalize
+
+glm::vec3 computeNormal
+(
+	glm::vec3 const & a,
+	glm::vec3 const & b,
+	glm::vec3 const & c
+)
+{
+	return glm::normalize(glm::cross(c - a, b - a));
+}
+
+typedef unsigned int GLuint;
+#define GL_FALSE 0
+void glUniformMatrix4fv(GLuint, int, int, float*){}
+
+// Sample 2
+#include <glm/vec3.hpp> // glm::vec3
+#include <glm/vec4.hpp> // glm::vec4, glm::ivec4
+#include <glm/mat4x4.hpp> // glm::mat4
+#include <glm/gtc/matrix_transform.hpp> // glm::translate, glm::rotate, glm::scale, glm::perspective
+#include <glm/gtc/type_ptr.hpp> // glm::value_ptr
+void func(GLuint LocationMVP, float Translate, glm::vec2 const & Rotate)
+{
+	glm::mat4 Projection = glm::perspective(45.0f, 4.0f / 3.0f, 0.1f, 100.f);
+	glm::mat4 ViewTranslate = glm::translate(glm::mat4(1.0f), glm::vec3(0.0f, 0.0f, -Translate));
+	glm::mat4 ViewRotateX = glm::rotate(ViewTranslate, Rotate.y, glm::vec3(-1.0f, 0.0f, 0.0f));
+	glm::mat4 View = glm::rotate(ViewRotateX, Rotate.x, glm::vec3(0.0f, 1.0f, 0.0f));
+	glm::mat4 Model = glm::scale(glm::mat4(1.0f), glm::vec3(0.5f));
+	glm::mat4 MVP = Projection * View * Model;
+	glUniformMatrix4fv(LocationMVP, 1, GL_FALSE, glm::value_ptr(MVP));
+}
+
+// Sample 3
+#include <glm/vec2.hpp>// glm::vec2
+#include <glm/packing.hpp>// glm::packUnorm2x16
+#include <glm/integer.hpp>// glm::uint
+#include <glm/gtc/type_precision.hpp>// glm::i8vec2, glm::i32vec2
+std::size_t const VertexCount = 4;
+// Float quad geometry
+std::size_t const PositionSizeF32 = VertexCount * sizeof(glm::vec2);
+glm::vec2 const PositionDataF32[VertexCount] =
+{
+	glm::vec2(-1.0f,-1.0f),
+	glm::vec2( 1.0f,-1.0f),
+	glm::vec2( 1.0f, 1.0f),
+	glm::vec2(-1.0f, 1.0f)
+	};
+// Half-float quad geometry
+std::size_t const PositionSizeF16 = VertexCount * sizeof(glm::uint);
+glm::uint const PositionDataF16[VertexCount] =
+{
+	glm::uint(glm::packUnorm2x16(glm::vec2(-1.0f, -1.0f))),
+	glm::uint(glm::packUnorm2x16(glm::vec2( 1.0f, -1.0f))),
+	glm::uint(glm::packUnorm2x16(glm::vec2( 1.0f, 1.0f))),
+	glm::uint(glm::packUnorm2x16(glm::vec2(-1.0f, 1.0f)))
+};
+// 8 bits signed integer quad geometry
+std::size_t const PositionSizeI8 = VertexCount * sizeof(glm::i8vec2);
+glm::i8vec2 const PositionDataI8[VertexCount] =
+{
+	glm::i8vec2(-1,-1),
+	glm::i8vec2( 1,-1),
+	glm::i8vec2( 1, 1),
+	glm::i8vec2(-1, 1)
+};
+// 32 bits signed integer quad geometry
+std::size_t const PositionSizeI32 = VertexCount * sizeof(glm::i32vec2);
+glm::i32vec2 const PositionDataI32[VertexCount] =
+{
+	glm::i32vec2 (-1,-1),
+	glm::i32vec2 ( 1,-1),
+	glm::i32vec2 ( 1, 1),
+	glm::i32vec2 (-1, 1)
+};
+
+struct intersection
+{
+	glm::vec4 position;
+	glm::vec3 normal;
+};
+
+/*
+// Sample 4
+#include <glm/vec3.hpp>// glm::vec3
+#include <glm/geometric.hpp>// glm::normalize, glm::dot, glm::reflect
+#include <glm/exponential.hpp>// glm::pow
+#include <glm/gtc/random.hpp>// glm::vecRand3
+glm::vec3 lighting
+(
+	intersection const & Intersection,
+	material const & Material,
+	light const & Light,
+	glm::vec3 const & View
+)
+{
+	glm::vec3 Color(0.0f);
+	glm::vec3 LightVertor(glm::normalize(
+		Light.position - Intersection.position +
+		glm::vecRand3(0.0f, Light.inaccuracy));
+
+	if(!shadow(Intersection.position, Light.position, LightVertor))
+	{
+		float Diffuse = glm::dot(Intersection.normal, LightVector);
+		if(Diffuse <= 0.0f)
+			return Color;
+		if(Material.isDiffuse())
+			Color += Light.color() * Material.diffuse * Diffuse;
+		if(Material.isSpecular())
+		{
+			glm::vec3 Reflect(glm::reflect(
+				glm::normalize(-LightVector),
+				glm::normalize(Intersection.normal)));
+			float Dot = glm::dot(Reflect, View);
+			float Base = Dot > 0.0f ? Dot : 0.0f;
+			float Specular = glm::pow(Base, Material.exponent);
+			Color += Material.specular * Specular;
+		}
+	}
+	return Color;
+}
+*/
+
+
+template <typename T, glm::precision P, template<typename, glm::precision> class vecType>
+T normalizeDotA(vecType<T, P> const & x, vecType<T, P> const & y)
+{
+	return glm::dot(x, y) * glm::inversesqrt(glm::dot(x, x) * glm::dot(y, y));
+}
+
+#define GLM_TEMPLATE_GENTYPE typename T, glm::precision P, template<typename, glm::precision> class
+
+template <GLM_TEMPLATE_GENTYPE vecType>
+T normalizeDotB(vecType<T, P> const & x, vecType<T, P> const & y)
+{
+	return glm::dot(x, y) * glm::inversesqrt(glm::dot(x, x) * glm::dot(y, y));
+}
+
+template <typename vecType>
+typename vecType::value_type normalizeDotC(vecType const & a, vecType const & b)
+{
+	return glm::dot(a, b) * glm::inversesqrt(glm::dot(a, a) * glm::dot(b, b));
+}
+
+int main()
+{
+	glm::vec1 o(1);
+	glm::vec2 a(1);
+	glm::vec3 b(1);
+	glm::vec4 c(1);
+
+	glm::quat q;
+	glm::dualquat p;
+
+	glm::mat4 m(1);
+
+	float a0 = normalizeDotA(a, a);
+	float b0 = normalizeDotB(b, b);
+	float c0 = normalizeDotC(c, c);
+
+	return 0;
+}

glm/glm/detail/func_common.hpp

@@ -0,0 +1,456 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// 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.
+///
+/// @ref core
+/// @file glm/detail/func_common.hpp
+/// @date 2008-03-08 / 2010-01-26
+/// @author Christophe Riccio
+/// 
+/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+///
+/// @defgroup core_func_common Common functions
+/// @ingroup core
+/// 
+/// These all operate component-wise. The description is per component.
+///////////////////////////////////////////////////////////////////////////////////
+
+#pragma once
+
+#include "setup.hpp"
+#include "precision.hpp"
+#include "type_int.hpp"
+#include "_fixes.hpp"
+
+namespace glm
+{
+	/// @addtogroup core_func_common
+	/// @{
+
+	/// Returns x if x >= 0; otherwise, it returns -x.
+	/// 
+	/// @tparam genType floating-point or signed integer; scalar or vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/abs.xml">GLSL abs man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template <typename genType>
+	GLM_FUNC_DECL genType abs(genType x);
+
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> abs(vecType<T, P> const & x);
+
+	/// Returns 1.0 if x > 0, 0.0 if x == 0, or -1.0 if x < 0. 
+	/// 
+	/// @tparam genType Floating-point or signed integer; scalar or vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/sign.xml">GLSL sign man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> sign(vecType<T, P> const & x);
+
+	/// Returns a value equal to the nearest integer that is less then or equal to x. 
+	/// 
+	/// @tparam genType Floating-point scalar or vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/floor.xml">GLSL floor man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> floor(vecType<T, P> const & x);
+
+	/// Returns a value equal to the nearest integer to x
+	/// whose absolute value is not larger than the absolute value of x.
+	/// 
+	/// @tparam genType Floating-point scalar or vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/trunc.xml">GLSL trunc man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> trunc(vecType<T, P> const & x);
+
+	/// Returns a value equal to the nearest integer to x.
+	/// The fraction 0.5 will round in a direction chosen by the
+	/// implementation, presumably the direction that is fastest.
+	/// This includes the possibility that round(x) returns the
+	/// same value as roundEven(x) for all values of x.
+	/// 
+	/// @tparam genType Floating-point scalar or vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/round.xml">GLSL round man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> round(vecType<T, P> const & x);
+
+	/// Returns a value equal to the nearest integer to x.
+	/// A fractional part of 0.5 will round toward the nearest even
+	/// integer. (Both 3.5 and 4.5 for x will return 4.0.)
+	///
+	/// @tparam genType Floating-point scalar or vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/roundEven.xml">GLSL roundEven man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	/// @see <a href="http://developer.amd.com/documentation/articles/pages/New-Round-to-Even-Technique.aspx">New round to even technique</a>
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> roundEven(vecType<T, P> const & x);
+
+	/// Returns a value equal to the nearest integer
+	/// that is greater than or equal to x.
+	/// 
+	/// @tparam genType Floating-point scalar or vector types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/ceil.xml">GLSL ceil man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> ceil(vecType<T, P> const & x);
+
+	/// Return x - floor(x).
+	/// 
+	/// @tparam genType Floating-point scalar or vector types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/fract.xml">GLSL fract man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template <typename genType>
+	GLM_FUNC_DECL genType fract(genType x);
+
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> fract(vecType<T, P> const & x);
+
+	/// Modulus. Returns x - y * floor(x / y)
+	/// for each component in x using the floating point value y.
+	///
+	/// @tparam genType Floating-point scalar or vector types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/mod.xml">GLSL mod man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template <typename genType>
+	GLM_FUNC_DECL genType mod(genType x, genType y);
+
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> mod(vecType<T, P> const & x, T y);
+
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> mod(vecType<T, P> const & x, vecType<T, P> const & y);
+
+	/// Returns the fractional part of x and sets i to the integer
+	/// part (as a whole number floating point value). Both the
+	/// return value and the output parameter will have the same
+	/// sign as x.
+	/// 
+	/// @tparam genType Floating-point scalar or vector types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/modf.xml">GLSL modf man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template <typename genType>
+	GLM_FUNC_DECL genType modf(genType x, genType & i);
+
+	/// Returns y if y < x; otherwise, it returns x.
+	///
+	/// @tparam genType Floating-point or integer; scalar or vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/min.xml">GLSL min man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template <typename genType>
+	GLM_FUNC_DECL genType min(genType x, genType y);
+
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> min(vecType<T, P> const & x, T y);
+
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> min(vecType<T, P> const & x, vecType<T, P> const & y);
+
+	/// Returns y if x < y; otherwise, it returns x.
+	/// 
+	/// @tparam genType Floating-point or integer; scalar or vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/max.xml">GLSL max man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template <typename genType>
+	GLM_FUNC_DECL genType max(genType x, genType y);
+
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> max(vecType<T, P> const & x, T y);
+
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> max(vecType<T, P> const & x, vecType<T, P> const & y);
+
+	/// Returns min(max(x, minVal), maxVal) for each component in x 
+	/// using the floating-point values minVal and maxVal.
+	///
+	/// @tparam genType Floating-point or integer; scalar or vector types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/clamp.xml">GLSL clamp man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template <typename genType>
+	GLM_FUNC_DECL genType clamp(genType x, genType minVal, genType maxVal);
+
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> clamp(vecType<T, P> const & x, T minVal, T maxVal);
+
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> clamp(vecType<T, P> const & x, vecType<T, P> const & minVal, vecType<T, P> const & maxVal);
+
+	/// If genTypeU is a floating scalar or vector:
+	/// Returns x * (1.0 - a) + y * a, i.e., the linear blend of
+	/// x and y using the floating-point value a.
+	/// The value for a is not restricted to the range [0, 1].
+	/// 
+	/// If genTypeU is a boolean scalar or vector:
+	/// Selects which vector each returned component comes
+	/// from. For a component of <a> that is false, the
+	/// corresponding component of x is returned. For a
+	/// component of a that is true, the corresponding
+	/// component of y is returned. Components of x and y that
+	/// are not selected are allowed to be invalid floating point
+	/// values and will have no effect on the results. Thus, this
+	/// provides different functionality than
+	/// genType mix(genType x, genType y, genType(a))
+	/// where a is a Boolean vector.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/mix.xml">GLSL mix man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	/// 
+	/// @param[in]  x Value to interpolate.
+	/// @param[in]  y Value to interpolate.
+	/// @param[in]  a Interpolant.
+	/// 
+	/// @tparam	genTypeT Floating point scalar or vector.
+	/// @tparam genTypeU Floating point or boolean scalar or vector. It can't be a vector if it is the length of genTypeT.
+	/// 
+	/// @code
+	/// #include <glm/glm.hpp>
+	/// ...
+	/// float a;
+	/// bool b;
+	/// glm::dvec3 e;
+	/// glm::dvec3 f;
+	/// glm::vec4 g;
+	/// glm::vec4 h;
+	/// ...
+	/// glm::vec4 r = glm::mix(g, h, a); // Interpolate with a floating-point scalar two vectors. 
+	/// glm::vec4 s = glm::mix(g, h, b); // Teturns g or h;
+	/// glm::dvec3 t = glm::mix(e, f, a); // Types of the third parameter is not required to match with the first and the second.
+	/// glm::vec4 u = glm::mix(g, h, r); // Interpolations can be perform per component with a vector for the last parameter.
+	/// @endcode
+	template <typename T, typename U, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> mix(vecType<T, P> const & x, vecType<T, P> const & y, vecType<U, P> const & a);
+
+	template <typename T, typename U, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> mix(vecType<T, P> const & x, vecType<T, P> const & y, U a);
+
+	template <typename genTypeT, typename genTypeU>
+	GLM_FUNC_DECL genTypeT mix(genTypeT x, genTypeT y, genTypeU a);
+
+	/// Returns 0.0 if x < edge, otherwise it returns 1.0 for each component of a genType.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/step.xml">GLSL step man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template <typename genType>
+	GLM_FUNC_DECL genType step(genType edge, genType x);
+
+	/// Returns 0.0 if x < edge, otherwise it returns 1.0.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/step.xml">GLSL step man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template <template <typename, precision> class vecType, typename T, precision P>
+	GLM_FUNC_DECL vecType<T, P> step(T edge, vecType<T, P> const & x);
+
+	/// Returns 0.0 if x < edge, otherwise it returns 1.0.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/step.xml">GLSL step man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template <template <typename, precision> class vecType, typename T, precision P>
+	GLM_FUNC_DECL vecType<T, P> step(vecType<T, P> const & edge, vecType<T, P> const & x);
+
+	/// Returns 0.0 if x <= edge0 and 1.0 if x >= edge1 and
+	/// performs smooth Hermite interpolation between 0 and 1
+	/// when edge0 < x < edge1. This is useful in cases where
+	/// you would want a threshold function with a smooth
+	/// transition. This is equivalent to:
+	/// genType t;
+	/// t = clamp ((x - edge0) / (edge1 - edge0), 0, 1);
+	/// return t * t * (3 - 2 * t);
+	/// Results are undefined if edge0 >= edge1.
+	///
+	/// @tparam genType Floating-point scalar or vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/smoothstep.xml">GLSL smoothstep man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template <typename genType>
+	GLM_FUNC_DECL genType smoothstep(genType edge0, genType edge1, genType x);
+
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> smoothstep(T edge0, T edge1, vecType<T, P> const & x);
+
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> smoothstep(vecType<T, P> const & edge0, vecType<T, P> const & edge1, vecType<T, P> const & x);
+
+	/// Returns true if x holds a NaN (not a number)
+	/// representation in the underlying implementation's set of
+	/// floating point representations. Returns false otherwise,
+	/// including for implementations with no NaN
+	/// representations.
+	/// 
+	/// /!\ When using compiler fast math, this function may fail.
+	/// 
+	/// @tparam genType Floating-point scalar or vector types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/isnan.xml">GLSL isnan man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<bool, P> isnan(vecType<T, P> const & x);
+
+	/// Returns true if x holds a positive infinity or negative
+	/// infinity representation in the underlying implementation's
+	/// set of floating point representations. Returns false
+	/// otherwise, including for implementations with no infinity
+	/// representations.
+	/// 
+	/// @tparam genType Floating-point scalar or vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/isinf.xml">GLSL isinf man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<bool, P> isinf(vecType<T, P> const & x);
+
+	/// Returns a signed integer value representing
+	/// the encoding of a floating-point value. The floating-point
+	/// value's bit-level representation is preserved.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/floatBitsToInt.xml">GLSL floatBitsToInt man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	GLM_FUNC_DECL int floatBitsToInt(float const & v);
+
+	/// Returns a signed integer value representing
+	/// the encoding of a floating-point value. The floatingpoint
+	/// value's bit-level representation is preserved.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/floatBitsToInt.xml">GLSL floatBitsToInt man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template <template <typename, precision> class vecType, precision P>
+	GLM_FUNC_DECL vecType<int, P> floatBitsToInt(vecType<float, P> const & v);
+
+	/// Returns a unsigned integer value representing
+	/// the encoding of a floating-point value. The floatingpoint
+	/// value's bit-level representation is preserved.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/floatBitsToUint.xml">GLSL floatBitsToUint man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	GLM_FUNC_DECL uint floatBitsToUint(float const & v);
+
+	/// Returns a unsigned integer value representing
+	/// the encoding of a floating-point value. The floatingpoint
+	/// value's bit-level representation is preserved.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/floatBitsToUint.xml">GLSL floatBitsToUint man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template <template <typename, precision> class vecType, precision P>
+	GLM_FUNC_DECL vecType<uint, P> floatBitsToUint(vecType<float, P> const & v);
+
+	/// Returns a floating-point value corresponding to a signed
+	/// integer encoding of a floating-point value.
+	/// If an inf or NaN is passed in, it will not signal, and the
+	/// resulting floating point value is unspecified. Otherwise,
+	/// the bit-level representation is preserved.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/intBitsToFloat.xml">GLSL intBitsToFloat man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	GLM_FUNC_DECL float intBitsToFloat(int const & v);
+
+	/// Returns a floating-point value corresponding to a signed
+	/// integer encoding of a floating-point value.
+	/// If an inf or NaN is passed in, it will not signal, and the
+	/// resulting floating point value is unspecified. Otherwise,
+	/// the bit-level representation is preserved.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/intBitsToFloat.xml">GLSL intBitsToFloat man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template <template <typename, precision> class vecType, precision P>
+	GLM_FUNC_DECL vecType<float, P> intBitsToFloat(vecType<int, P> const & v);
+
+	/// Returns a floating-point value corresponding to a
+	/// unsigned integer encoding of a floating-point value.
+	/// If an inf or NaN is passed in, it will not signal, and the
+	/// resulting floating point value is unspecified. Otherwise,
+	/// the bit-level representation is preserved.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/uintBitsToFloat.xml">GLSL uintBitsToFloat man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	GLM_FUNC_DECL float uintBitsToFloat(uint const & v);
+
+	/// Returns a floating-point value corresponding to a
+	/// unsigned integer encoding of a floating-point value.
+	/// If an inf or NaN is passed in, it will not signal, and the
+	/// resulting floating point value is unspecified. Otherwise,
+	/// the bit-level representation is preserved.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/uintBitsToFloat.xml">GLSL uintBitsToFloat man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template <template <typename, precision> class vecType, precision P>
+	GLM_FUNC_DECL vecType<float, P> uintBitsToFloat(vecType<uint, P> const & v);
+
+	/// Computes and returns a * b + c.
+	/// 
+	/// @tparam genType Floating-point scalar or vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/fma.xml">GLSL fma man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template <typename genType>
+	GLM_FUNC_DECL genType fma(genType const & a, genType const & b, genType const & c);
+
+	/// Splits x into a floating-point significand in the range
+	/// [0.5, 1.0) and an integral exponent of two, such that:
+	/// x = significand * exp(2, exponent)
+	/// 
+	/// The significand is returned by the function and the
+	/// exponent is returned in the parameter exp. For a
+	/// floating-point value of zero, the significant and exponent
+	/// are both zero. For a floating-point value that is an
+	/// infinity or is not a number, the results are undefined.
+	/// 
+	/// @tparam genType Floating-point scalar or vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/frexp.xml">GLSL frexp man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template <typename genType, typename genIType>
+	GLM_FUNC_DECL genType frexp(genType const & x, genIType & exp);
+
+	/// Builds a floating-point number from x and the
+	/// corresponding integral exponent of two in exp, returning:
+	/// significand * exp(2, exponent)
+	/// 
+	/// If this product is too large to be represented in the
+	/// floating-point type, the result is undefined.
+	/// 
+	/// @tparam genType Floating-point scalar or vector types.
+	///  
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/ldexp.xml">GLSL ldexp man page</a>; 
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template <typename genType, typename genIType>
+	GLM_FUNC_DECL genType ldexp(genType const & x, genIType const & exp);
+
+	/// @}
+}//namespace glm
+
+#include "func_common.inl"
+

glm/glm/detail/func_common.inl

@@ -0,0 +1,758 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// 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.
+///
+/// @ref core
+/// @file glm/detail/func_common.inl
+/// @date 2008-08-03 / 2011-06-15
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#include "func_vector_relational.hpp"
+#include "type_vec2.hpp"
+#include "type_vec3.hpp"
+#include "type_vec4.hpp"
+#include "_vectorize.hpp"
+#include <limits>
+
+namespace glm{
+namespace detail
+{
+	template <typename genFIType, bool /*signed*/>
+	struct compute_abs
+	{};
+
+	template <typename genFIType>
+	struct compute_abs<genFIType, true>
+	{
+		GLM_FUNC_QUALIFIER static genFIType call(genFIType x)
+		{
+			GLM_STATIC_ASSERT(
+				std::numeric_limits<genFIType>::is_iec559 || std::numeric_limits<genFIType>::is_signed,
+				"'abs' only accept floating-point and integer scalar or vector inputs");
+
+			return x >= genFIType(0) ? x : -x;
+			// TODO, perf comp with: *(((int *) &x) + 1) &= 0x7fffffff;
+		}
+	};
+
+	template <typename genFIType>
+	struct compute_abs<genFIType, false>
+	{
+		GLM_FUNC_QUALIFIER static genFIType call(genFIType x)
+		{
+			GLM_STATIC_ASSERT(
+				!std::numeric_limits<genFIType>::is_signed && std::numeric_limits<genFIType>::is_integer,
+				"'abs' only accept floating-point and integer scalar or vector inputs");
+			return x;
+		}
+	};
+
+	template <typename T, typename U, precision P, template <class, precision> class vecType>
+	struct compute_mix_vector
+	{
+		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x, vecType<T, P> const & y, vecType<U, P> const & a)
+		{
+			GLM_STATIC_ASSERT(std::numeric_limits<U>::is_iec559, "'mix' only accept floating-point inputs for the interpolator a");
+
+			return vecType<T, P>(vecType<U, P>(x) + a * vecType<U, P>(y - x));
+		}
+	};
+
+	template <typename T, precision P, template <class, precision> class vecType>
+	struct compute_mix_vector<T, bool, P, vecType>
+	{
+		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x, vecType<T, P> const & y, vecType<bool, P> const & a)
+		{
+			vecType<T, P> Result(uninitialize);
+			for(detail::component_count_t i = 0; i < detail::component_count(x); ++i)
+				Result[i] = a[i] ? y[i] : x[i];
+			return Result;
+		}
+	};
+
+	template <typename T, typename U, precision P, template <class, precision> class vecType>
+	struct compute_mix_scalar
+	{
+		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x, vecType<T, P> const & y, U const & a)
+		{
+			GLM_STATIC_ASSERT(std::numeric_limits<U>::is_iec559, "'mix' only accept floating-point inputs for the interpolator a");
+
+			return vecType<T, P>(vecType<U, P>(x) + a * vecType<U, P>(y - x));
+		}
+	};
+
+	template <typename T, precision P, template <class, precision> class vecType>
+	struct compute_mix_scalar<T, bool, P, vecType>
+	{
+		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x, vecType<T, P> const & y, bool const & a)
+		{
+			return a ? y : x;
+		}
+	};
+
+	template <typename T, typename U>
+	struct compute_mix
+	{
+		GLM_FUNC_QUALIFIER static T call(T const & x, T const & y, U const & a)
+		{
+			GLM_STATIC_ASSERT(std::numeric_limits<U>::is_iec559, "'mix' only accept floating-point inputs for the interpolator a");
+
+			return static_cast<T>(static_cast<U>(x) + a * static_cast<U>(y - x));
+		}
+	};
+
+	template <typename T>
+	struct compute_mix<T, bool>
+	{
+		GLM_FUNC_QUALIFIER static T call(T const & x, T const & y, bool const & a)
+		{
+			return a ? y : x;
+		}
+	};
+
+	template <typename T, precision P, template <class, precision> class vecType, bool isFloat = true, bool isSigned = true>
+	struct compute_sign
+	{
+		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x)
+		{
+			return vecType<T, P>(glm::lessThan(vecType<T, P>(0), x)) - vecType<T, P>(glm::lessThan(x, vecType<T, P>(0)));
+		}
+	};
+
+	template <typename T, precision P, template <class, precision> class vecType>
+	struct compute_sign<T, P, vecType, false, false>
+	{
+		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x)
+		{
+			return vecType<T, P>(glm::greaterThan(x , vecType<T, P>(0)));
+		}
+	};
+
+	template <typename T, precision P, template <class, precision> class vecType>
+	struct compute_sign<T, P, vecType, false, true>
+	{
+		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x)
+		{
+			T const Shift(static_cast<T>(sizeof(T) * 8 - 1));
+			vecType<T, P> const y(vecType<typename make_unsigned<T>::type, P>(-x) >> typename make_unsigned<T>::type(Shift));
+
+			return (x >> Shift) | y;
+		}
+	};
+
+	template <typename T, precision P, template <class, precision> class vecType, typename genType, bool isFloat = true>
+	struct compute_mod
+	{
+		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & a, genType const & b)
+		{
+			GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'mod' only accept floating-point inputs. Include <glm/gtc/integer.hpp> for integer inputs.");
+			return a - b * floor(a / b);
+		}
+	};
+}//namespace detail
+
+	// abs
+	template <>
+	GLM_FUNC_QUALIFIER int32 abs(int32 x)
+	{
+		int32 const y = x >> 31;
+		return (x ^ y) - y;
+	}
+
+	template <typename genFIType>
+	GLM_FUNC_QUALIFIER genFIType abs(genFIType x)
+	{
+		return detail::compute_abs<genFIType, std::numeric_limits<genFIType>::is_signed>::call(x);
+	}
+
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> abs(vecType<T, P> const & x)
+	{
+		return detail::functor1<T, T, P, vecType>::call(abs, x);
+	}
+
+	// sign
+	// fast and works for any type
+	template <typename genFIType> 
+	GLM_FUNC_QUALIFIER genFIType sign(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");
+		
+		return detail::compute_sign<genFIType, defaultp, tvec1, std::numeric_limits<genFIType>::is_iec559>::call(tvec1<genFIType>(x)).x;
+	}
+
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> sign(vecType<T, P> const & x)
+	{
+		GLM_STATIC_ASSERT(
+			std::numeric_limits<T>::is_iec559 || (std::numeric_limits<T>::is_signed && std::numeric_limits<T>::is_integer),
+			"'sign' only accept signed inputs");
+
+		return detail::compute_sign<T, P, vecType, std::numeric_limits<T>::is_iec559>::call(x);
+	}
+
+	// floor
+	using ::std::floor;
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> floor(vecType<T, P> const & x)
+	{
+		return detail::functor1<T, T, P, vecType>::call(floor, x);
+	}
+
+	// trunc
+#	if GLM_HAS_CXX11_STL
+		using ::std::trunc;
+#	else
+		template <typename genType>
+		GLM_FUNC_QUALIFIER genType trunc(genType x)
+		{
+			GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'trunc' only accept floating-point inputs");
+
+			return x < static_cast<genType>(0) ? -floor(-x) : floor(x);
+		}
+#	endif
+
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> trunc(vecType<T, P> const & x)
+	{
+		return detail::functor1<T, T, P, vecType>::call(trunc, x);
+	}
+
+	// round
+#	if GLM_HAS_CXX11_STL
+		using ::std::round;
+#	else
+		template <typename genType>
+		GLM_FUNC_QUALIFIER genType round(genType x)
+		{
+			GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'round' only accept floating-point inputs");
+
+			return x < static_cast<genType>(0) ? static_cast<genType>(int(x - static_cast<genType>(0.5))) : static_cast<genType>(int(x + static_cast<genType>(0.5)));
+		}
+#	endif
+
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> round(vecType<T, P> const & x)
+	{
+		return detail::functor1<T, T, P, vecType>::call(round, x);
+	}
+
+/*
+	// roundEven
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType roundEven(genType const& x)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'roundEven' only accept floating-point inputs");
+
+		return genType(int(x + genType(int(x) % 2)));
+	}
+*/
+
+	// roundEven
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType roundEven(genType x)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'roundEven' only accept floating-point inputs");
+		
+		int Integer = static_cast<int>(x);
+		genType IntegerPart = static_cast<genType>(Integer);
+		genType FractionalPart = fract(x);
+
+		if(FractionalPart > static_cast<genType>(0.5) || FractionalPart < static_cast<genType>(0.5))
+		{
+			return round(x);
+		}
+		else if((Integer % 2) == 0)
+		{
+			return IntegerPart;
+		}
+		else if(x <= static_cast<genType>(0)) // Work around... 
+		{
+			return IntegerPart - static_cast<genType>(1);
+		}
+		else
+		{
+			return IntegerPart + static_cast<genType>(1);
+		}
+		//else // Bug on MinGW 4.5.2
+		//{
+		//	return mix(IntegerPart + genType(-1), IntegerPart + genType(1), x <= genType(0));
+		//}
+	}
+
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> roundEven(vecType<T, P> const & x)
+	{
+		return detail::functor1<T, T, P, vecType>::call(roundEven, x);
+	}
+
+	// ceil
+	using ::std::ceil;
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> ceil(vecType<T, P> const & x)
+	{
+		return detail::functor1<T, T, P, vecType>::call(ceil, x);
+	}
+
+	// fract
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType fract(genType x)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'fract' only accept floating-point inputs");
+
+		return fract(tvec1<genType>(x)).x;
+	}
+
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> fract(vecType<T, P> const & x)
+	{
+		return x - floor(x);
+	}
+
+	// mod
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType mod(genType x, genType y)
+	{
+		return mod(tvec1<genType>(x), y).x;
+	}
+
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> mod(vecType<T, P> const & x, T y)
+	{
+		return detail::compute_mod<T, P, vecType, T, std::numeric_limits<T>::is_iec559>::call(x, y);
+	}
+
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> mod(vecType<T, P> const & x, vecType<T, P> const & y)
+	{
+		return detail::compute_mod<T, P, vecType, vecType<T, P>, std::numeric_limits<T>::is_iec559>::call(x, y);
+	}
+
+	// modf
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType modf(genType x, genType & i)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'modf' only accept floating-point inputs");
+
+		return std::modf(x, &i);
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tvec1<T, P> modf(tvec1<T, P> const & x, tvec1<T, P> & i)
+	{
+		return tvec1<T, P>(
+			modf(x.x, i.x));
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tvec2<T, P> modf(tvec2<T, P> const & x, tvec2<T, P> & i)
+	{
+		return tvec2<T, P>(
+			modf(x.x, i.x),
+			modf(x.y, i.y));
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tvec3<T, P> modf(tvec3<T, P> const & x, tvec3<T, P> & i)
+	{
+		return tvec3<T, P>(
+			modf(x.x, i.x),
+			modf(x.y, i.y),
+			modf(x.z, i.z));
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tvec4<T, P> modf(tvec4<T, P> const & x, tvec4<T, P> & i)
+	{
+		return tvec4<T, P>(
+			modf(x.x, i.x),
+			modf(x.y, i.y),
+			modf(x.z, i.z),
+			modf(x.w, i.w));
+	}
+
+	//// Only valid if (INT_MIN <= x-y <= INT_MAX)
+	//// min(x,y)
+	//r = y + ((x - y) & ((x - y) >> (sizeof(int) *
+	//CHAR_BIT - 1)));
+	//// max(x,y)
+	//r = x - ((x - y) & ((x - y) >> (sizeof(int) *
+	//CHAR_BIT - 1)));
+
+	// min
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType min(genType x, genType y)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || std::numeric_limits<genType>::is_integer, "'min' only accept floating-point or integer inputs");
+
+		return x < y ? x : y;
+	}
+
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> min(vecType<T, P> const & a, T b)
+	{
+		return detail::functor2_vec_sca<T, P, vecType>::call(min, a, b);
+	}
+
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> min(vecType<T, P> const & a, vecType<T, P> const & b)
+	{
+		return detail::functor2<T, P, vecType>::call(min, a, b);
+	}
+
+	// max
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType max(genType x, genType y)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || std::numeric_limits<genType>::is_integer, "'max' only accept floating-point or integer inputs");
+
+		return x > y ? x : y;
+	}
+
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> max(vecType<T, P> const & a, T b)
+	{
+		return detail::functor2_vec_sca<T, P, vecType>::call(max, a, b);
+	}
+
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> max(vecType<T, P> const & a, vecType<T, P> const & b)
+	{
+		return detail::functor2<T, P, vecType>::call(max, a, b);
+	}
+
+	// clamp
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType clamp(genType x, genType minVal, genType maxVal)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || std::numeric_limits<genType>::is_integer, "'clamp' only accept floating-point or integer inputs");
+		
+		return min(max(x, minVal), maxVal);
+	}
+
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> clamp(vecType<T, P> const & x, T minVal, T maxVal)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || std::numeric_limits<T>::is_integer, "'clamp' only accept floating-point or integer inputs");
+
+		return min(max(x, minVal), maxVal);
+	}
+
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> clamp(vecType<T, P> const & x, vecType<T, P> const & minVal, vecType<T, P> const & maxVal)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || std::numeric_limits<T>::is_integer, "'clamp' only accept floating-point or integer inputs");
+
+		return min(max(x, minVal), maxVal);
+	}
+
+	template <typename genTypeT, typename genTypeU>
+	GLM_FUNC_QUALIFIER genTypeT mix(genTypeT x, genTypeT y, genTypeU a)
+	{
+		return detail::compute_mix<genTypeT, genTypeU>::call(x, y, a);
+	}
+
+	template <typename T, typename U, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> mix(vecType<T, P> const & x, vecType<T, P> const & y, U a)
+	{
+		return detail::compute_mix_scalar<T, U, P, vecType>::call(x, y, a);
+	}
+	
+	template <typename T, typename U, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> mix(vecType<T, P> const & x, vecType<T, P> const & y, vecType<U, P> const & a)
+	{
+		return detail::compute_mix_vector<T, U, P, vecType>::call(x, y, a);
+	}
+
+	// step
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType step(genType edge, genType x)
+	{
+		return mix(static_cast<genType>(1), static_cast<genType>(0), glm::lessThan(x, edge));
+	}
+
+	template <template <typename, precision> class vecType, typename T, precision P>
+	GLM_FUNC_QUALIFIER vecType<T, P> step(T edge, vecType<T, P> const & x)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'step' only accept floating-point inputs");
+
+		return mix(vecType<T, P>(1), vecType<T, P>(0), glm::lessThan(x, vecType<T, P>(edge)));
+	}
+
+	template <template <typename, precision> class vecType, typename T, precision P>
+	GLM_FUNC_QUALIFIER vecType<T, P> step(vecType<T, P> const & edge, vecType<T, P> const & x)
+	{
+		return mix(vecType<T, P>(1), vecType<T, P>(0), glm::lessThan(x, edge));
+	}
+
+	// smoothstep
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType smoothstep(genType edge0, genType edge1, genType x)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'smoothstep' only accept floating-point inputs");
+
+		genType const tmp(clamp((x - edge0) / (edge1 - edge0), genType(0), genType(1)));
+		return tmp * tmp * (genType(3) - genType(2) * tmp);
+	}
+
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> smoothstep(T edge0, T edge1, vecType<T, P> const & x)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'smoothstep' only accept floating-point inputs");
+
+		vecType<T, P> const tmp(clamp((x - edge0) / (edge1 - edge0), static_cast<T>(0), static_cast<T>(1)));
+		return tmp * tmp * (static_cast<T>(3) - static_cast<T>(2) * tmp);
+	}
+
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> smoothstep(vecType<T, P> const & edge0, vecType<T, P> const & edge1, vecType<T, P> const & x)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'smoothstep' only accept floating-point inputs");
+
+		vecType<T, P> const tmp(clamp((x - edge0) / (edge1 - edge0), static_cast<T>(0), static_cast<T>(1)));
+		return tmp * tmp * (static_cast<T>(3) - static_cast<T>(2) * tmp);
+	}
+
+#	if GLM_HAS_CXX11_STL
+		using std::isnan;
+#	else
+		template <typename genType> 
+		GLM_FUNC_QUALIFIER bool isnan(genType x)
+		{
+			GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'isnan' only accept floating-point inputs");
+
+#			if GLM_HAS_CXX11_STL
+				return std::isnan(x);
+#			elif GLM_COMPILER & (GLM_COMPILER_VC | GLM_COMPILER_INTEL)
+				return _isnan(x) != 0;
+#			elif GLM_COMPILER & (GLM_COMPILER_GCC | (GLM_COMPILER_APPLE_CLANG | GLM_COMPILER_LLVM))
+#				if GLM_PLATFORM & GLM_PLATFORM_ANDROID && __cplusplus < 201103L
+					return _isnan(x) != 0;
+#				else
+					return std::isnan(x);
+#				endif
+#			elif GLM_COMPILER & GLM_COMPILER_CUDA
+				return isnan(x) != 0;
+#			else
+				return std::isnan(x);
+#			endif
+		}
+#	endif
+
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<bool, P> isnan(vecType<T, P> const & x)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'isnan' only accept floating-point inputs");
+
+		return detail::functor1<bool, T, P, vecType>::call(isnan, x);
+	}
+
+#	if GLM_HAS_CXX11_STL
+		using std::isinf;
+#	else
+		template <typename genType> 
+		GLM_FUNC_QUALIFIER bool isinf(genType x)
+		{
+			GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'isinf' only accept floating-point inputs");
+
+#			if GLM_HAS_CXX11_STL
+				return std::isinf(x);
+#			elif GLM_COMPILER & (GLM_COMPILER_INTEL | GLM_COMPILER_VC)
+				return _fpclass(x) == _FPCLASS_NINF || _fpclass(x) == _FPCLASS_PINF;
+#			elif GLM_COMPILER & (GLM_COMPILER_GCC | (GLM_COMPILER_APPLE_CLANG | GLM_COMPILER_LLVM))
+#				if(GLM_PLATFORM & GLM_PLATFORM_ANDROID && __cplusplus < 201103L)
+					return _isinf(x) != 0;
+#				else
+					return std::isinf(x);
+#				endif
+#			elif GLM_COMPILER & GLM_COMPILER_CUDA
+				// http://developer.download.nvidia.com/compute/cuda/4_2/rel/toolkit/docs/online/group__CUDA__MATH__DOUBLE_g13431dd2b40b51f9139cbb7f50c18fab.html#g13431dd2b40b51f9139cbb7f50c18fab
+				return isinf(double(x)) != 0;
+#			else
+				return std::isinf(x);
+#			endif
+	}
+#	endif
+
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<bool, P> isinf(vecType<T, P> const & x)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'isnan' only accept floating-point inputs");
+
+		return detail::functor1<bool, T, P, vecType>::call(isinf, x);
+	}
+
+	GLM_FUNC_QUALIFIER int floatBitsToInt(float const & v)
+	{
+		return reinterpret_cast<int&>(const_cast<float&>(v));
+	}
+
+	template <template <typename, precision> class vecType, precision P>
+	GLM_FUNC_QUALIFIER vecType<int, P> floatBitsToInt(vecType<float, P> const & v)
+	{
+		return reinterpret_cast<vecType<int, P>&>(const_cast<vecType<float, P>&>(v));
+	}
+
+	GLM_FUNC_QUALIFIER uint floatBitsToUint(float const & v)
+	{
+		return reinterpret_cast<uint&>(const_cast<float&>(v));
+	}
+
+	template <template <typename, precision> class vecType, precision P>
+	GLM_FUNC_QUALIFIER vecType<uint, P> floatBitsToUint(vecType<float, P> const & v)
+	{
+		return reinterpret_cast<vecType<uint, P>&>(const_cast<vecType<float, P>&>(v));
+	}
+
+	GLM_FUNC_QUALIFIER float intBitsToFloat(int const & v)
+	{
+		return reinterpret_cast<float&>(const_cast<int&>(v));
+	}
+
+	template <template <typename, precision> class vecType, precision P>
+	GLM_FUNC_QUALIFIER vecType<float, P> intBitsToFloat(vecType<int, P> const & v)
+	{
+		return reinterpret_cast<vecType<float, P>&>(const_cast<vecType<int, P>&>(v));
+	}
+
+	GLM_FUNC_QUALIFIER float uintBitsToFloat(uint const & v)
+	{
+		return reinterpret_cast<float&>(const_cast<uint&>(v));
+	}
+
+	template <template <typename, precision> class vecType, precision P>
+	GLM_FUNC_QUALIFIER vecType<float, P> uintBitsToFloat(vecType<uint, P> const & v)
+	{
+		return reinterpret_cast<vecType<float, P>&>(const_cast<vecType<uint, P>&>(v));
+	}
+	
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType fma(genType const & a, genType const & b, genType const & c)
+	{
+		return a * b + c;
+	}
+
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType frexp(genType x, int & exp)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'frexp' only accept floating-point inputs");
+
+		return std::frexp(x, exp);
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tvec1<T, P> frexp(tvec1<T, P> const & x, tvec1<int, P> & exp)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'frexp' only accept floating-point inputs");
+
+		return tvec1<T, P>(std::frexp(x.x, exp.x));
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tvec2<T, P> frexp(tvec2<T, P> const & x, tvec2<int, P> & exp)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'frexp' only accept floating-point inputs");
+
+		return tvec2<T, P>(
+			frexp(x.x, exp.x),
+			frexp(x.y, exp.y));
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tvec3<T, P> frexp(tvec3<T, P> const & x, tvec3<int, P> & exp)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'frexp' only accept floating-point inputs");
+
+		return tvec3<T, P>(
+			frexp(x.x, exp.x),
+			frexp(x.y, exp.y),
+			frexp(x.z, exp.z));
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tvec4<T, P> frexp(tvec4<T, P> const & x, tvec4<int, P> & exp)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'frexp' only accept floating-point inputs");
+
+		return tvec4<T, P>(
+			frexp(x.x, exp.x),
+			frexp(x.y, exp.y),
+			frexp(x.z, exp.z),
+			frexp(x.w, exp.w));
+	}
+
+	template <typename genType, precision P>
+	GLM_FUNC_QUALIFIER genType ldexp(genType const & x, int const & exp)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'ldexp' only accept floating-point inputs");
+
+		return std::ldexp(x, exp);
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tvec1<T, P> ldexp(tvec1<T, P> const & x, tvec1<int, P> const & exp)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'ldexp' only accept floating-point inputs");
+
+		return tvec1<T, P>(
+			ldexp(x.x, exp.x));
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tvec2<T, P> ldexp(tvec2<T, P> const & x, tvec2<int, P> const & exp)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'ldexp' only accept floating-point inputs");
+
+		return tvec2<T, P>(
+			ldexp(x.x, exp.x),
+			ldexp(x.y, exp.y));
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tvec3<T, P> ldexp(tvec3<T, P> const & x, tvec3<int, P> const & exp)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'ldexp' only accept floating-point inputs");
+
+		return tvec3<T, P>(
+			ldexp(x.x, exp.x),
+			ldexp(x.y, exp.y),
+			ldexp(x.z, exp.z));
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tvec4<T, P> ldexp(tvec4<T, P> const & x, tvec4<int, P> const & exp)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'ldexp' only accept floating-point inputs");
+
+		return tvec4<T, P>(
+			ldexp(x.x, exp.x),
+			ldexp(x.y, exp.y),
+			ldexp(x.z, exp.z),
+			ldexp(x.w, exp.w));
+	}
+}//namespace glm

glm/glm/detail/func_exponential.hpp

@@ -0,0 +1,132 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// 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.
+///
+/// @ref core
+/// @file glm/detail/func_exponential.hpp
+/// @date 2008-08-08 / 2011-06-14
+/// @author Christophe Riccio
+/// 
+/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
+///
+/// @defgroup core_func_exponential Exponential functions
+/// @ingroup core
+/// 
+/// These all operate component-wise. The description is per component.
+///////////////////////////////////////////////////////////////////////////////////
+
+#pragma once
+
+#include "type_vec1.hpp"
+#include "type_vec2.hpp"
+#include "type_vec3.hpp"
+#include "type_vec4.hpp"
+#include <cmath>
+
+namespace glm
+{
+	/// @addtogroup core_func_exponential
+	/// @{
+
+	/// Returns 'base' raised to the power 'exponent'. 
+	///
+	/// @param base Floating point value. pow function is defined for input values of 'base' defined in the range (inf-, inf+) in the limit of the type precision.
+	/// @param exponent Floating point value representing the 'exponent'.
+	/// @tparam genType Floating-point scalar or vector types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/pow.xml">GLSL pow man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> pow(vecType<T, P> const & base, vecType<T, P> const & exponent);
+
+	/// Returns the natural exponentiation of x, i.e., e^x.
+	///
+	/// @param v exp function is defined for input values of v defined in the range (inf-, inf+) in the limit of the type precision.
+	/// @tparam genType Floating-point scalar or vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/exp.xml">GLSL exp man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> exp(vecType<T, P> const & v);
+
+	/// Returns the natural logarithm of v, i.e., 
+	/// returns the value y which satisfies the equation x = e^y. 
+	/// Results are undefined if v <= 0.
+	///
+	/// @param v log function is defined for input values of v defined in the range (0, inf+) in the limit of the type precision.
+	/// @tparam genType Floating-point scalar or vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/log.xml">GLSL log man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> log(vecType<T, P> const & v);
+
+	/// Returns 2 raised to the v power.
+	/// 
+	/// @param v exp2 function is defined for input values of v defined in the range (inf-, inf+) in the limit of the type precision.
+	/// @tparam genType Floating-point scalar or vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/exp2.xml">GLSL exp2 man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> exp2(vecType<T, P> const & v);
+
+	/// Returns the base 2 log of x, i.e., returns the value y, 
+	/// which satisfies the equation x = 2 ^ y.
+	/// 
+	/// @param v log2 function is defined for input values of v defined in the range (0, inf+) in the limit of the type precision.
+	/// @tparam genType Floating-point scalar or vector types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/log2.xml">GLSL log2 man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> log2(vecType<T, P> const & v);
+
+	/// Returns the positive square root of v.
+	/// 
+	/// @param v sqrt function is defined for input values of v defined in the range [0, inf+) in the limit of the type precision.
+	/// @tparam genType Floating-point scalar or vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/sqrt.xml">GLSL sqrt man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
+	//template <typename genType>
+	//GLM_FUNC_DECL genType sqrt(genType const & x);
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> sqrt(vecType<T, P> const & v);
+	
+	/// Returns the reciprocal of the positive square root of v.
+	/// 
+	/// @param v inversesqrt function is defined for input values of v defined in the range [0, inf+) in the limit of the type precision.
+	/// @tparam genType Floating-point scalar or vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/inversesqrt.xml">GLSL inversesqrt man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> inversesqrt(vecType<T, P> const & v);
+
+	/// @}
+}//namespace glm
+
+#include "func_exponential.inl"

glm/glm/detail/func_exponential.inl

@@ -0,0 +1,161 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// 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.
+///
+/// @ref core
+/// @file glm/detail/func_exponential.inl
+/// @date 2008-08-03 / 2011-06-15
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#include "func_vector_relational.hpp"
+#include "_vectorize.hpp"
+#include <limits>
+#include <cmath>
+#include <cassert>
+
+namespace glm{
+namespace detail
+{
+#	if GLM_HAS_CXX11_STL
+		using std::log2;
+#	else
+		template <typename genType>
+		genType log2(genType Value)
+		{
+			return std::log(Value) * static_cast<genType>(1.4426950408889634073599246810019);
+		}
+#	endif
+
+	template <typename T, precision P, template <class, precision> class vecType, bool isFloat = true>
+	struct compute_log2
+	{
+		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & vec)
+		{
+			return detail::functor1<T, T, P, vecType>::call(log2, vec);
+		}
+	};
+
+	template <template <class, precision> class vecType, typename T, precision P>
+	struct compute_inversesqrt
+	{
+		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x)
+		{
+			return static_cast<T>(1) / sqrt(x);
+		}
+	};
+		
+	template <template <class, precision> class vecType>
+	struct compute_inversesqrt<vecType, float, lowp>
+	{
+		GLM_FUNC_QUALIFIER static vecType<float, lowp> call(vecType<float, lowp> const & x)
+		{
+			vecType<float, lowp> tmp(x);
+			vecType<float, lowp> xhalf(tmp * 0.5f);
+			vecType<uint, lowp>* p = reinterpret_cast<vecType<uint, lowp>*>(const_cast<vecType<float, lowp>*>(&x));
+			vecType<uint, lowp> i = vecType<uint, lowp>(0x5f375a86) - (*p >> vecType<uint, lowp>(1));
+			vecType<float, lowp>* ptmp = reinterpret_cast<vecType<float, lowp>*>(&i);
+			tmp = *ptmp;
+			tmp = tmp * (1.5f - xhalf * tmp * tmp);
+			return tmp;
+		}
+	};
+}//namespace detail
+
+	// pow
+	using std::pow;
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> pow(vecType<T, P> const & base, vecType<T, P> const & exponent)
+	{
+		return detail::functor2<T, P, vecType>::call(pow, base, exponent);
+	}
+
+	// exp
+	using std::exp;
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> exp(vecType<T, P> const & x)
+	{
+		return detail::functor1<T, T, P, vecType>::call(exp, x);
+	}
+
+	// log
+	using std::log;
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> log(vecType<T, P> const & x)
+	{
+		return detail::functor1<T, T, P, vecType>::call(log, x);
+	}
+
+	//exp2, ln2 = 0.69314718055994530941723212145818f
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType exp2(genType x)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'exp2' only accept floating-point inputs");
+
+		return std::exp(static_cast<genType>(0.69314718055994530941723212145818) * x);
+	}
+
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> exp2(vecType<T, P> const & x)
+	{
+		return detail::functor1<T, T, P, vecType>::call(exp2, x);
+	}
+
+	// log2, ln2 = 0.69314718055994530941723212145818f
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType log2(genType x)
+	{
+		return log2(tvec1<genType>(x)).x;
+	}
+
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> log2(vecType<T, P> const & x)
+	{
+		return detail::compute_log2<T, P, vecType, std::numeric_limits<T>::is_iec559>::call(x);
+	}
+
+	// sqrt
+	using std::sqrt;
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> sqrt(vecType<T, P> const & x)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'sqrt' only accept floating-point inputs");
+		return detail::functor1<T, T, P, vecType>::call(sqrt, x);
+	}
+
+	// inversesqrt
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType inversesqrt(genType x)
+	{
+		return static_cast<genType>(1) / sqrt(x);
+	}
+	
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> inversesqrt(vecType<T, P> const & x)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'inversesqrt' only accept floating-point inputs");
+		return detail::compute_inversesqrt<vecType, T, P>::call(x);
+	}
+}//namespace glm

glm/glm/detail/func_geometric.hpp

@@ -0,0 +1,142 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// 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.
+///
+/// @ref core
+/// @file glm/detail/func_geometric.hpp
+/// @date 2008-08-03 / 2011-06-14
+/// @author Christophe Riccio
+///
+/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
+/// 
+/// @defgroup core_func_geometric Geometric functions
+/// @ingroup core
+/// 
+/// These operate on vectors as vectors, not component-wise.
+///////////////////////////////////////////////////////////////////////////////////
+
+#pragma once
+
+#include "type_vec3.hpp"
+
+namespace glm
+{
+	/// @addtogroup core_func_geometric
+	/// @{
+
+	/// Returns the length of x, i.e., sqrt(x * x).
+	/// 
+	/// @tparam genType Floating-point vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/length.xml">GLSL length man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL T length(
+		vecType<T, P> const & x);
+
+	/// Returns the distance betwwen p0 and p1, i.e., length(p0 - p1).
+	///
+	/// @tparam genType Floating-point vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/distance.xml">GLSL distance man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL T distance(
+		vecType<T, P> const & p0,
+		vecType<T, P> const & p1);
+
+	/// Returns the dot product of x and y, i.e., result = x * y.
+	///
+	/// @tparam genType Floating-point vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/dot.xml">GLSL dot man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL T dot(
+		vecType<T, P> const & x,
+		vecType<T, P> const & y);
+
+	/// Returns the cross product of x and y.
+	///
+	/// @tparam valType Floating-point scalar types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/cross.xml">GLSL cross man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
+	template <typename T, precision P>
+	GLM_FUNC_DECL tvec3<T, P> cross(
+		tvec3<T, P> const & x,
+		tvec3<T, P> const & y);
+
+	/// Returns a vector in the same direction as x but with length of 1.
+	/// According to issue 10 GLSL 1.10 specification, if length(x) == 0 then result is undefined and generate an error.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/normalize.xml">GLSL normalize man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> normalize(
+		vecType<T, P> const & x);
+
+	/// If dot(Nref, I) < 0.0, return N, otherwise, return -N.
+	///
+	/// @tparam genType Floating-point vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/faceforward.xml">GLSL faceforward man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> faceforward(
+		vecType<T, P> const & N,
+		vecType<T, P> const & I,
+		vecType<T, P> const & Nref);
+
+	/// For the incident vector I and surface orientation N, 
+	/// returns the reflection direction : result = I - 2.0 * dot(N, I) * N.
+	///
+	/// @tparam genType Floating-point vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/reflect.xml">GLSL reflect man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
+	template <typename genType>
+	GLM_FUNC_DECL genType reflect(
+		genType const & I,
+		genType const & N);
+
+	/// For the incident vector I and surface normal N, 
+	/// and the ratio of indices of refraction eta, 
+	/// return the refraction vector.
+	///
+	/// @tparam genType Floating-point vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/refract.xml">GLSL refract man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> refract(
+		vecType<T, P> const & I,
+		vecType<T, P> const & N,
+		T eta);
+
+	/// @}
+}//namespace glm
+
+#include "func_geometric.inl"

glm/glm/detail/func_geometric.inl

@@ -0,0 +1,201 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// 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.
+///
+/// @ref core
+/// @file glm/detail/func_geometric.inl
+/// @date 2008-08-03 / 2011-06-15
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#include "func_exponential.hpp"
+#include "func_common.hpp"
+#include "type_vec2.hpp"
+#include "type_vec4.hpp"
+#include "type_float.hpp"
+
+namespace glm{
+namespace detail
+{
+	template <template <class, precision> class vecType, typename T, precision P>
+	struct compute_dot{};
+
+	template <typename T, precision P>
+	struct compute_dot<tvec1, T, P>
+	{
+		GLM_FUNC_QUALIFIER static T call(tvec1<T, P> const & a, tvec1<T, P> const & b)
+		{
+			return a.x * b.x;
+		}
+	};
+
+	template <typename T, precision P>
+	struct compute_dot<tvec2, T, P>
+	{
+		GLM_FUNC_QUALIFIER static T call(tvec2<T, P> const & x, tvec2<T, P> const & y)
+		{
+			tvec2<T, P> tmp(x * y);
+			return tmp.x + tmp.y;
+		}
+	};
+
+	template <typename T, precision P>
+	struct compute_dot<tvec3, T, P>
+	{
+		GLM_FUNC_QUALIFIER static T call(tvec3<T, P> const & x, tvec3<T, P> const & y)
+		{
+			tvec3<T, P> tmp(x * y);
+			return tmp.x + tmp.y + tmp.z;
+		}
+	};
+
+	template <typename T, precision P>
+	struct compute_dot<tvec4, T, P>
+	{
+		GLM_FUNC_QUALIFIER static T call(tvec4<T, P> const & x, tvec4<T, P> const & y)
+		{
+			tvec4<T, P> tmp(x * y);
+			return (tmp.x + tmp.y) + (tmp.z + tmp.w);
+		}
+	};
+}//namespace detail
+
+	// length
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType length(genType x)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'length' only accept floating-point inputs");
+
+		return abs(x);
+	}
+
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER T length(vecType<T, P> const & v)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'length' only accept floating-point inputs");
+
+		return sqrt(dot(v, v));
+	}
+
+	// distance
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType distance(genType const & p0, genType const & p1)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'distance' only accept floating-point inputs");
+
+		return length(p1 - p0);
+	}
+
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER T distance(vecType<T, P> const & p0, vecType<T, P> const & p1)
+	{
+		return length(p1 - p0);
+	}
+
+	// dot
+	template <typename T>
+	GLM_FUNC_QUALIFIER T dot(T x, T y)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'dot' only accept floating-point inputs");
+		return x * y;
+	}
+
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER T dot(vecType<T, P> const & x, vecType<T, P> const & y)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'dot' only accept floating-point inputs");
+		return detail::compute_dot<vecType, T, P>::call(x, y);
+	}
+
+	// cross
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tvec3<T, P> cross(tvec3<T, P> const & x, tvec3<T, P> const & y)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'cross' only accept floating-point inputs");
+
+		return tvec3<T, P>(
+			x.y * y.z - y.y * x.z,
+			x.z * y.x - y.z * x.x,
+			x.x * y.y - y.x * x.y);
+	}
+
+	// normalize
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType normalize(genType const & x)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'normalize' only accept floating-point inputs");
+
+		return x < genType(0) ? genType(-1) : genType(1);
+	}
+
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> normalize(vecType<T, P> const & x)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'normalize' only accept floating-point inputs");
+
+		return x * inversesqrt(dot(x, x));
+	}
+
+	// faceforward
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType faceforward(genType const & N, genType const & I, genType const & Nref)
+	{
+		return dot(Nref, I) < static_cast<genType>(0) ? N : -N;
+	}
+
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> faceforward(vecType<T, P> const & N, vecType<T, P> const & I, vecType<T, P> const & Nref)
+	{
+		return dot(Nref, I) < static_cast<T>(0) ? N : -N;
+	}
+
+	// reflect
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType reflect(genType const & I, genType const & N)
+	{
+		return I - N * dot(N, I) * static_cast<genType>(2);
+	}
+
+	// refract
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType refract(genType const & I, genType const & N, genType const & eta)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'refract' only accept floating-point inputs");
+
+		genType const dotValue(dot(N, I));
+		genType const k(static_cast<genType>(1) - eta * eta * (static_cast<genType>(1) - dotValue * dotValue));
+		return (eta * I - (eta * dotValue + sqrt(k)) * N) * static_cast<genType>(k >= static_cast<genType>(0));
+	}
+
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> refract(vecType<T, P> const & I, vecType<T, P> const & N, T eta)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'refract' only accept floating-point inputs");
+
+		T const dotValue(dot(N, I));
+		T const k(static_cast<T>(1) - eta * eta * (static_cast<T>(1) - dotValue * dotValue));
+		return (eta * I - (eta * dotValue + std::sqrt(k)) * N) * static_cast<T>(k >= static_cast<T>(0));
+	}
+}//namespace glm

glm/glm/detail/func_integer.hpp

@@ -0,0 +1,232 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// 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.
+///
+/// @ref core
+/// @file glm/detail/func_integer.hpp
+/// @date 2010-03-17 / 2011-06-18
+/// @author Christophe Riccio
+///
+/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
+/// 
+/// @defgroup core_func_integer Integer functions
+/// @ingroup core
+/// 
+/// These all operate component-wise. The description is per component. 
+/// The notation [a, b] means the set of bits from bit-number a through bit-number 
+/// b, inclusive. The lowest-order bit is bit 0.
+///////////////////////////////////////////////////////////////////////////////////
+
+#pragma once
+
+#include "setup.hpp"
+#include "precision.hpp"
+#include "func_common.hpp"
+#include "func_vector_relational.hpp"
+
+namespace glm
+{
+	/// @addtogroup core_func_integer
+	/// @{
+
+	/// Adds 32-bit unsigned integer x and y, returning the sum
+	/// modulo pow(2, 32). The value carry is set to 0 if the sum was
+	/// less than pow(2, 32), or to 1 otherwise.
+	///
+	/// @tparam genUType Unsigned integer scalar or vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/uaddCarry.xml">GLSL uaddCarry man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
+	template <precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<uint, P> uaddCarry(
+		vecType<uint, P> const & x,
+		vecType<uint, P> const & y,
+		vecType<uint, P> & carry);
+
+	/// Subtracts the 32-bit unsigned integer y from x, returning
+	/// the difference if non-negative, or pow(2, 32) plus the difference
+	/// otherwise. The value borrow is set to 0 if x >= y, or to 1 otherwise.
+	///
+	/// @tparam genUType Unsigned integer scalar or vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/usubBorrow.xml">GLSL usubBorrow man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
+	template <precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<uint, P> usubBorrow(
+		vecType<uint, P> const & x,
+		vecType<uint, P> const & y,
+		vecType<uint, P> & borrow);
+
+	/// Multiplies 32-bit integers x and y, producing a 64-bit
+	/// result. The 32 least-significant bits are returned in lsb.
+	/// The 32 most-significant bits are returned in msb.
+	///
+	/// @tparam genUType Unsigned integer scalar or vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/umulExtended.xml">GLSL umulExtended man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
+	template <precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL void umulExtended(
+		vecType<uint, P> const & x,
+		vecType<uint, P> const & y,
+		vecType<uint, P> & msb,
+		vecType<uint, P> & lsb);
+		
+	/// Multiplies 32-bit integers x and y, producing a 64-bit
+	/// result. The 32 least-significant bits are returned in lsb.
+	/// The 32 most-significant bits are returned in msb.
+	/// 
+	/// @tparam genIType Signed integer scalar or vector types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/imulExtended.xml">GLSL imulExtended man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
+	template <precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL void imulExtended(
+		vecType<int, P> const & x,
+		vecType<int, P> const & y,
+		vecType<int, P> & msb,
+		vecType<int, P> & lsb);
+
+	/// Extracts bits [offset, offset + bits - 1] from value,
+	/// returning them in the least significant bits of the result.
+	/// For unsigned data types, the most significant bits of the
+	/// result will be set to zero. For signed data types, the
+	/// most significant bits will be set to the value of bit offset + base - 1.
+	///
+	/// If bits is zero, the result will be zero. The result will be
+	/// undefined if offset or bits is negative, or if the sum of
+	/// offset and bits is greater than the number of bits used
+	/// to store the operand.
+	///
+	/// @tparam T Signed or unsigned integer scalar or vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/bitfieldExtract.xml">GLSL bitfieldExtract man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> bitfieldExtract(
+		vecType<T, P> const & Value,
+		int Offset,
+		int Bits);
+
+	/// Returns the insertion the bits least-significant bits of insert into base.
+	///
+	/// The result will have bits [offset, offset + bits - 1] taken
+	/// from bits [0, bits - 1] of insert, and all other bits taken
+	/// directly from the corresponding bits of base. If bits is
+	/// zero, the result will simply be base. The result will be
+	/// undefined if offset or bits is negative, or if the sum of
+	/// offset and bits is greater than the number of bits used to
+	/// store the operand.
+	///
+	/// @tparam T Signed or unsigned integer scalar or vector types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/bitfieldInsert.xml">GLSL bitfieldInsert man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> bitfieldInsert(
+		vecType<T, P> const & Base,
+		vecType<T, P> const & Insert,
+		int Offset,
+		int Bits);
+
+	/// Returns the reversal of the bits of value. 
+	/// The bit numbered n of the result will be taken from bit (bits - 1) - n of value, 
+	/// where bits is the total number of bits used to represent value.
+	///
+	/// @tparam T Signed or unsigned integer scalar or vector types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/bitfieldReverse.xml">GLSL bitfieldReverse man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> bitfieldReverse(vecType<T, P> const & v);
+
+	/// Returns the number of bits set to 1 in the binary representation of value.
+	///
+	/// @tparam T Signed or unsigned integer scalar or vector types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/bitCount.xml">GLSL bitCount man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
+	template <typename genType>
+	GLM_FUNC_DECL int bitCount(genType v);
+
+	/// Returns the number of bits set to 1 in the binary representation of value.
+	///
+	/// @tparam T Signed or unsigned integer scalar or vector types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/bitCount.xml">GLSL bitCount man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<int, P> bitCount(vecType<T, P> const & v);
+
+	/// Returns the bit number of the least significant bit set to
+	/// 1 in the binary representation of value. 
+	/// If value is zero, -1 will be returned.
+	///
+	/// @tparam T Signed or unsigned integer scalar types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/findLSB.xml">GLSL findLSB man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
+	template <typename genIUType>
+	GLM_FUNC_DECL int findLSB(genIUType x);
+
+	/// Returns the bit number of the least significant bit set to
+	/// 1 in the binary representation of value. 
+	/// If value is zero, -1 will be returned.
+	///
+	/// @tparam T Signed or unsigned integer scalar types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/findLSB.xml">GLSL findLSB man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<int, P> findLSB(vecType<T, P> const & v);
+
+	/// Returns the bit number of the most significant bit in the binary representation of value.
+	/// For positive integers, the result will be the bit number of the most significant bit set to 1. 
+	/// For negative integers, the result will be the bit number of the most significant
+	/// bit set to 0. For a value of zero or negative one, -1 will be returned.
+	///
+	/// @tparam T Signed or unsigned integer scalar types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/findMSB.xml">GLSL findMSB man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
+	template <typename genIUType>
+	GLM_FUNC_DECL int findMSB(genIUType x);
+
+	/// Returns the bit number of the most significant bit in the binary representation of value.
+	/// For positive integers, the result will be the bit number of the most significant bit set to 1. 
+	/// For negative integers, the result will be the bit number of the most significant
+	/// bit set to 0. For a value of zero or negative one, -1 will be returned.
+	///
+	/// @tparam T Signed or unsigned integer scalar types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/findMSB.xml">GLSL findMSB man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<int, P> findMSB(vecType<T, P> const & v);
+
+	/// @}
+}//namespace glm
+
+#include "func_integer.inl"

glm/glm/detail/func_integer.inl

@@ -0,0 +1,393 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// 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.
+///
+/// @ref core
+/// @file glm/detail/func_integer.inl
+/// @date 2010-03-17 / 2011-06-15
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#include "type_vec2.hpp"
+#include "type_vec3.hpp"
+#include "type_vec4.hpp"
+#include "type_int.hpp"
+#include "_vectorize.hpp"
+#if(GLM_ARCH != GLM_ARCH_PURE)
+#if(GLM_COMPILER & GLM_COMPILER_VC)
+#	include <intrin.h>
+#	pragma intrinsic(_BitScanReverse)
+#endif//(GLM_COMPILER & GLM_COMPILER_VC)
+#endif//(GLM_ARCH != GLM_ARCH_PURE)
+#include <limits>
+
+namespace glm{
+namespace detail
+{
+	template <typename T>
+	GLM_FUNC_QUALIFIER T mask(T Bits)
+	{
+		return Bits >= sizeof(T) * 8 ? ~static_cast<T>(0) : (static_cast<T>(1) << Bits) - static_cast<T>(1);
+	}
+
+	template <bool EXEC = false>
+	struct compute_bitfieldReverseStep
+	{
+		template <typename T, glm::precision P, template <class, glm::precision> class vecType>
+		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & v, T, T)
+		{
+			return v;
+		}
+	};
+
+	template <>
+	struct compute_bitfieldReverseStep<true>
+	{
+		template <typename T, glm::precision P, template <class, glm::precision> class vecType>
+		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & v, T Mask, T Shift)
+		{
+			return (v & Mask) << Shift | (v & (~Mask)) >> Shift;
+		}
+	};
+
+	template <bool EXEC = false>
+	struct compute_bitfieldBitCountStep
+	{
+		template <typename T, glm::precision P, template <class, glm::precision> class vecType>
+		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & v, T, T)
+		{
+			return v;
+		}
+	};
+
+	template <>
+	struct compute_bitfieldBitCountStep<true>
+	{
+		template <typename T, glm::precision P, template <class, glm::precision> class vecType>
+		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & v, T Mask, T Shift)
+		{
+			return (v & Mask) + ((v >> Shift) & Mask);
+		}
+	};
+
+	template <typename genIUType, size_t Bits>
+	struct compute_findLSB
+	{
+		GLM_FUNC_QUALIFIER static int call(genIUType Value)
+		{
+			if(Value == 0)
+				return -1;
+
+			return glm::bitCount(~Value & (Value - static_cast<genIUType>(1)));
+		}
+	};
+
+#	if GLM_HAS_BITSCAN_WINDOWS
+		template <typename genIUType>
+		struct compute_findLSB<genIUType, 32>
+		{
+			GLM_FUNC_QUALIFIER static int call(genIUType Value)
+			{
+				unsigned long Result(0);
+				unsigned char IsNotNull = _BitScanForward(&Result, *reinterpret_cast<unsigned long*>(&Value));
+				return IsNotNull ? int(Result) : -1;
+			}
+		};
+
+#		if !((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_MODEL == GLM_MODEL_32))
+		template <typename genIUType>
+		struct compute_findLSB<genIUType, 64>
+		{
+			GLM_FUNC_QUALIFIER static int call(genIUType Value)
+			{
+				unsigned long Result(0);
+				unsigned char IsNotNull = _BitScanForward64(&Result, *reinterpret_cast<unsigned __int64*>(&Value));
+				return IsNotNull ? int(Result) : -1;
+			}
+		};
+#		endif
+#	endif//GLM_HAS_BITSCAN_WINDOWS
+
+	template <typename T, glm::precision P, template <class, glm::precision> class vecType, bool EXEC = true>
+	struct compute_findMSB_step_vec
+	{
+		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x, T Shift)
+		{
+			return x | (x >> Shift);
+		}
+	};
+
+	template <typename T, glm::precision P, template <typename, glm::precision> class vecType>
+	struct compute_findMSB_step_vec<T, P, vecType, false>
+	{
+		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x, T)
+		{
+			return x;
+		}
+	};
+
+	template <typename T, glm::precision P, template <typename, glm::precision> class vecType, int>
+	struct compute_findMSB_vec
+	{
+		GLM_FUNC_QUALIFIER static vecType<int, P> call(vecType<T, P> const & vec)
+		{
+			vecType<T, P> x(vec);
+			x = compute_findMSB_step_vec<T, P, vecType, sizeof(T) * 8 >=  8>::call(x, static_cast<T>( 1));
+			x = compute_findMSB_step_vec<T, P, vecType, sizeof(T) * 8 >=  8>::call(x, static_cast<T>( 2));
+			x = compute_findMSB_step_vec<T, P, vecType, sizeof(T) * 8 >=  8>::call(x, static_cast<T>( 4));
+			x = compute_findMSB_step_vec<T, P, vecType, sizeof(T) * 8 >= 16>::call(x, static_cast<T>( 8));
+			x = compute_findMSB_step_vec<T, P, vecType, sizeof(T) * 8 >= 32>::call(x, static_cast<T>(16));
+			x = compute_findMSB_step_vec<T, P, vecType, sizeof(T) * 8 >= 64>::call(x, static_cast<T>(32));
+			return vecType<int, P>(sizeof(T) * 8 - 1) - glm::bitCount(~x);
+		}
+	};
+
+#	if GLM_HAS_BITSCAN_WINDOWS
+		template <typename genIUType>
+		GLM_FUNC_QUALIFIER int compute_findMSB_32(genIUType Value)
+		{
+			unsigned long Result(0);
+			unsigned char IsNotNull = _BitScanReverse(&Result, *reinterpret_cast<unsigned long*>(&Value));
+			return IsNotNull ? int(Result) : -1;
+		}
+
+		template <typename T, glm::precision P, template <class, glm::precision> class vecType>
+		struct compute_findMSB_vec<T, P, vecType, 32>
+		{
+			GLM_FUNC_QUALIFIER static vecType<int, P> call(vecType<T, P> const & x)
+			{
+				return detail::functor1<int, T, P, vecType>::call(compute_findMSB_32, x);
+			}
+		};
+
+#		if !((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_MODEL == GLM_MODEL_32))
+		template <typename genIUType>
+		GLM_FUNC_QUALIFIER int compute_findMSB_64(genIUType Value)
+		{
+			unsigned long Result(0);
+			unsigned char IsNotNull = _BitScanReverse64(&Result, *reinterpret_cast<unsigned __int64*>(&Value));
+			return IsNotNull ? int(Result) : -1;
+		}
+
+		template <typename T, glm::precision P, template <class, glm::precision> class vecType>
+		struct compute_findMSB_vec<T, P, vecType, 64>
+		{
+			GLM_FUNC_QUALIFIER static vecType<int, P> call(vecType<T, P> const & x)
+			{
+				return detail::functor1<int, T, P, vecType>::call(compute_findMSB_64, x);
+			}
+		};
+#		endif
+#	endif//GLM_HAS_BITSCAN_WINDOWS
+}//namespace detail
+
+	// uaddCarry
+	GLM_FUNC_QUALIFIER uint uaddCarry(uint const & x, uint const & y, uint & Carry)
+	{
+		uint64 const Value64(static_cast<uint64>(x) + static_cast<uint64>(y));
+		uint64 const Max32((static_cast<uint64>(1) << static_cast<uint64>(32)) - static_cast<uint64>(1));
+		Carry = Value64 > Max32 ? 1 : 0;
+		return static_cast<uint32>(Value64 % (Max32 + static_cast<uint64>(1)));
+	}
+
+	template <precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<uint, P> uaddCarry(vecType<uint, P> const & x, vecType<uint, P> const & y, vecType<uint, P> & Carry)
+	{
+		vecType<uint64, P> Value64(vecType<uint64, P>(x) + vecType<uint64, P>(y));
+		vecType<uint64, P> Max32((static_cast<uint64>(1) << static_cast<uint64>(32)) - static_cast<uint64>(1));
+		Carry = mix(vecType<uint32, P>(0), vecType<uint32, P>(1), greaterThan(Value64, Max32));
+		return vecType<uint32,P>(Value64 % (Max32 + static_cast<uint64>(1)));
+	}
+
+	// usubBorrow
+	GLM_FUNC_QUALIFIER uint usubBorrow(uint const & x, uint const & y, uint & Borrow)
+	{
+		GLM_STATIC_ASSERT(sizeof(uint) == sizeof(uint32), "uint and uint32 size mismatch");
+
+		Borrow = x >= y ? static_cast<uint32>(0) : static_cast<uint32>(1);
+		if(y >= x)
+			return y - x;
+		else
+			return static_cast<uint32>((static_cast<int64>(1) << static_cast<int64>(32)) + (static_cast<int64>(y) - static_cast<int64>(x)));
+	}
+
+	template <precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<uint, P> usubBorrow(vecType<uint, P> const & x, vecType<uint, P> const & y, vecType<uint, P> & Borrow)
+	{
+		Borrow = mix(vecType<uint, P>(1), vecType<uint, P>(0), greaterThanEqual(x, y));
+		vecType<uint, P> const YgeX(y - x);
+		vecType<uint, P> const XgeY(vecType<uint32, P>((static_cast<int64>(1) << static_cast<int64>(32)) + (vecType<int64, P>(y) - vecType<int64, P>(x))));
+		return mix(XgeY, YgeX, greaterThanEqual(y, x));
+	}
+
+	// umulExtended
+	GLM_FUNC_QUALIFIER void umulExtended(uint const & x, uint const & y, uint & msb, uint & lsb)
+	{
+		GLM_STATIC_ASSERT(sizeof(uint) == sizeof(uint32), "uint and uint32 size mismatch");
+
+		uint64 Value64 = static_cast<uint64>(x) * static_cast<uint64>(y);
+		uint32* PointerMSB = (reinterpret_cast<uint32*>(&Value64) + 1);
+		msb = *PointerMSB;
+		uint32* PointerLSB = (reinterpret_cast<uint32*>(&Value64) + 0);
+		lsb = *PointerLSB;
+	}
+
+	template <precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER void umulExtended(vecType<uint, P> const & x, vecType<uint, P> const & y, vecType<uint, P> & msb, vecType<uint, P> & lsb)
+	{
+		GLM_STATIC_ASSERT(sizeof(uint) == sizeof(uint32), "uint and uint32 size mismatch");
+
+		vecType<uint64, P> Value64(vecType<uint64, P>(x) * vecType<uint64, P>(y));
+		msb = vecType<uint32, P>(Value64 >> static_cast<uint64>(32));
+		lsb = vecType<uint32, P>(Value64);
+	}
+
+	// imulExtended
+	GLM_FUNC_QUALIFIER void imulExtended(int x, int y, int & msb, int & lsb)
+	{
+		GLM_STATIC_ASSERT(sizeof(int) == sizeof(int32), "int and int32 size mismatch");
+
+		int64 Value64 = static_cast<int64>(x) * static_cast<int64>(y);
+		int32* PointerMSB = (reinterpret_cast<int32*>(&Value64) + 1);
+		msb = *PointerMSB;
+		int32* PointerLSB = (reinterpret_cast<int32*>(&Value64));
+		lsb = *PointerLSB;
+	}
+
+	template <precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER void imulExtended(vecType<int, P> const & x, vecType<int, P> const & y, vecType<int, P> & msb, vecType<int, P> & lsb)
+	{
+		GLM_STATIC_ASSERT(sizeof(int) == sizeof(int32), "int and int32 size mismatch");
+
+		vecType<int64, P> Value64(vecType<int64, P>(x) * vecType<int64, P>(y));
+		lsb = vecType<int32, P>(Value64 & static_cast<int64>(0xFFFFFFFF));
+		msb = vecType<int32, P>((Value64 >> static_cast<int64>(32)) & static_cast<int64>(0xFFFFFFFF));
+	}
+
+	// bitfieldExtract
+	template <typename genIUType>
+	GLM_FUNC_QUALIFIER genIUType bitfieldExtract(genIUType Value, int Offset, int Bits)
+	{
+		return bitfieldExtract(tvec1<genIUType>(Value), Offset, Bits).x;
+	}
+
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> bitfieldExtract(vecType<T, P> const & Value, int Offset, int Bits)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_integer, "'bitfieldExtract' only accept integer inputs");
+
+		return (Value >> static_cast<T>(Offset)) & static_cast<T>(detail::mask(Bits));
+	}
+
+	// bitfieldInsert
+	template <typename genIUType>
+	GLM_FUNC_QUALIFIER genIUType bitfieldInsert(genIUType const & Base, genIUType const & Insert, int Offset, int Bits)
+	{
+		return bitfieldInsert(tvec1<genIUType>(Base), tvec1<genIUType>(Insert), Offset, Bits).x;
+	}
+
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> bitfieldInsert(vecType<T, P> const & Base, vecType<T, P> const & Insert, int Offset, int Bits)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_integer, "'bitfieldInsert' only accept integer values");
+
+		T const Mask = static_cast<T>(detail::mask(Bits) << Offset);
+		return (Base & ~Mask) | (Insert & Mask);
+	}
+
+	// bitfieldReverse
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType bitfieldReverse(genType x)
+	{
+		return bitfieldReverse(glm::tvec1<genType, glm::defaultp>(x)).x;
+	}
+
+	template <typename T, glm::precision P, template <typename, glm::precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> bitfieldReverse(vecType<T, P> const & v)
+	{
+		vecType<T, P> x(v);
+		x = detail::compute_bitfieldReverseStep<sizeof(T) * 8 >=  2>::call(x, T(0x5555555555555555ull), static_cast<T>( 1));
+		x = detail::compute_bitfieldReverseStep<sizeof(T) * 8 >=  4>::call(x, T(0x3333333333333333ull), static_cast<T>( 2));
+		x = detail::compute_bitfieldReverseStep<sizeof(T) * 8 >=  8>::call(x, T(0x0F0F0F0F0F0F0F0Full), static_cast<T>( 4));
+		x = detail::compute_bitfieldReverseStep<sizeof(T) * 8 >= 16>::call(x, T(0x00FF00FF00FF00FFull), static_cast<T>( 8));
+		x = detail::compute_bitfieldReverseStep<sizeof(T) * 8 >= 32>::call(x, T(0x0000FFFF0000FFFFull), static_cast<T>(16));
+		x = detail::compute_bitfieldReverseStep<sizeof(T) * 8 >= 64>::call(x, T(0x00000000FFFFFFFFull), static_cast<T>(32));
+		return x;
+	}
+
+	// bitCount
+	template <typename genType>
+	GLM_FUNC_QUALIFIER int bitCount(genType x)
+	{
+		return bitCount(glm::tvec1<genType, glm::defaultp>(x)).x;
+	}
+
+	template <typename T, glm::precision P, template <typename, glm::precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<int, P> bitCount(vecType<T, P> const & v)
+	{
+		vecType<typename detail::make_unsigned<T>::type, P> x(*reinterpret_cast<vecType<typename detail::make_unsigned<T>::type, P> const *>(&v));
+		x = detail::compute_bitfieldBitCountStep<sizeof(T) * 8 >=  2>::call(x, typename detail::make_unsigned<T>::type(0x5555555555555555ull), typename detail::make_unsigned<T>::type( 1));
+		x = detail::compute_bitfieldBitCountStep<sizeof(T) * 8 >=  4>::call(x, typename detail::make_unsigned<T>::type(0x3333333333333333ull), typename detail::make_unsigned<T>::type( 2));
+		x = detail::compute_bitfieldBitCountStep<sizeof(T) * 8 >=  8>::call(x, typename detail::make_unsigned<T>::type(0x0F0F0F0F0F0F0F0Full), typename detail::make_unsigned<T>::type( 4));
+		x = detail::compute_bitfieldBitCountStep<sizeof(T) * 8 >= 16>::call(x, typename detail::make_unsigned<T>::type(0x00FF00FF00FF00FFull), typename detail::make_unsigned<T>::type( 8));
+		x = detail::compute_bitfieldBitCountStep<sizeof(T) * 8 >= 32>::call(x, typename detail::make_unsigned<T>::type(0x0000FFFF0000FFFFull), typename detail::make_unsigned<T>::type(16));
+		x = detail::compute_bitfieldBitCountStep<sizeof(T) * 8 >= 64>::call(x, typename detail::make_unsigned<T>::type(0x00000000FFFFFFFFull), typename detail::make_unsigned<T>::type(32));
+		return vecType<int, P>(x);
+	}
+
+	// findLSB
+	template <typename genIUType>
+	GLM_FUNC_QUALIFIER int findLSB(genIUType Value)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'findLSB' only accept integer values");
+
+		return detail::compute_findLSB<genIUType, sizeof(genIUType) * 8>::call(Value);
+	}
+
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<int, P> findLSB(vecType<T, P> const & x)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_integer, "'findLSB' only accept integer values");
+
+		return detail::functor1<int, T, P, vecType>::call(findLSB, x);
+	}
+
+	// findMSB
+	template <typename genIUType>
+	GLM_FUNC_QUALIFIER int findMSB(genIUType x)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'findMSB' only accept integer values");
+
+		return findMSB(tvec1<genIUType>(x)).x;
+	}
+
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<int, P> findMSB(vecType<T, P> const & x)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_integer, "'findMSB' only accept integer values");
+
+		return detail::compute_findMSB_vec<T, P, vecType, sizeof(T) * 8>::call(x);
+	}
+}//namespace glm

glm/glm/detail/func_matrix.hpp

@@ -0,0 +1,178 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// 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.
+///
+/// @ref core
+/// @file glm/detail/func_matrix.hpp
+/// @date 2008-08-03 / 2011-06-15
+/// @author Christophe Riccio
+///
+/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a>
+/// 
+/// @defgroup core_func_matrix Matrix functions
+/// @ingroup core
+/// 
+/// For each of the following built-in matrix functions, there is both a 
+/// single-precision floating point version, where all arguments and return values 
+/// are single precision, and a double-precision floating version, where all 
+/// arguments and return values are double precision. Only the single-precision 
+/// floating point version is shown.
+///////////////////////////////////////////////////////////////////////////////////
+
+#pragma once
+
+// Dependencies
+#include "../detail/precision.hpp"
+#include "../detail/setup.hpp"
+#include "../detail/type_mat.hpp"
+#include "../vec2.hpp"
+#include "../vec3.hpp"
+#include "../vec4.hpp"
+#include "../mat2x2.hpp"
+#include "../mat2x3.hpp"
+#include "../mat2x4.hpp"
+#include "../mat3x2.hpp"
+#include "../mat3x3.hpp"
+#include "../mat3x4.hpp"
+#include "../mat4x2.hpp"
+#include "../mat4x3.hpp"
+#include "../mat4x4.hpp"
+
+namespace glm{
+namespace detail
+{
+	template <typename T, precision P>
+	struct outerProduct_trait<T, P, tvec2, tvec2>
+	{
+		typedef tmat2x2<T, P> type;
+	};
+
+	template <typename T, precision P>
+	struct outerProduct_trait<T, P, tvec2, tvec3>
+	{
+		typedef tmat2x3<T, P> type;
+	};
+
+	template <typename T, precision P>
+	struct outerProduct_trait<T, P, tvec2, tvec4>
+	{
+		typedef tmat2x4<T, P> type;
+	};
+
+	template <typename T, precision P>
+	struct outerProduct_trait<T, P, tvec3, tvec2>
+	{
+		typedef tmat3x2<T, P> type;
+	};
+
+	template <typename T, precision P>
+	struct outerProduct_trait<T, P, tvec3, tvec3>
+	{
+		typedef tmat3x3<T, P> type;
+	};
+
+	template <typename T, precision P>
+	struct outerProduct_trait<T, P, tvec3, tvec4>
+	{
+		typedef tmat3x4<T, P> type;
+	};
+
+	template <typename T, precision P>
+	struct outerProduct_trait<T, P, tvec4, tvec2>
+	{
+		typedef tmat4x2<T, P> type;
+	};
+
+	template <typename T, precision P>
+	struct outerProduct_trait<T, P, tvec4, tvec3>
+	{
+		typedef tmat4x3<T, P> type;
+	};
+
+	template <typename T, precision P>
+	struct outerProduct_trait<T, P, tvec4, tvec4>
+	{
+		typedef tmat4x4<T, P> type;
+	};
+
+}//namespace detail
+
+	/// @addtogroup core_func_matrix
+	/// @{
+
+	/// Multiply matrix x by matrix y component-wise, i.e., 
+	/// result[i][j] is the scalar product of x[i][j] and y[i][j].
+	/// 
+	/// @tparam matType Floating-point matrix types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/matrixCompMult.xml">GLSL matrixCompMult man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a>
+	template <typename T, precision P, template <typename, precision> class matType>
+	GLM_FUNC_DECL matType<T, P> matrixCompMult(matType<T, P> const & x, matType<T, P> const & y);
+
+	/// Treats the first parameter c as a column vector
+	/// and the second parameter r as a row vector
+	/// and does a linear algebraic matrix multiply c * r.
+	/// 
+	/// @tparam matType Floating-point matrix types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/outerProduct.xml">GLSL outerProduct man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a>
+	template <typename T, precision P, template <typename, precision> class vecTypeA, template <typename, precision> class vecTypeB>
+	GLM_FUNC_DECL typename detail::outerProduct_trait<T, P, vecTypeA, vecTypeB>::type outerProduct(vecTypeA<T, P> const & c, vecTypeB<T, P> const & r);
+
+	/// Returns the transposed matrix of x
+	/// 
+	/// @tparam matType Floating-point matrix types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/transpose.xml">GLSL transpose man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a>
+#	if((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC2012))
+		template <typename T, precision P, template <typename, precision> class matType>
+		GLM_FUNC_DECL typename matType<T, P>::transpose_type transpose(matType<T, P> const & x);
+#	endif
+	
+	/// Return the determinant of a squared matrix.
+	/// 
+	/// @tparam valType Floating-point scalar types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/determinant.xml">GLSL determinant man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a>	
+	template <typename T, precision P, template <typename, precision> class matType>
+	GLM_FUNC_DECL T determinant(matType<T, P> const & m);
+
+	/// Return the inverse of a squared matrix.
+	/// 
+	/// @tparam valType Floating-point scalar types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/inverse.xml">GLSL inverse man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a>	 
+	template <typename T, precision P, template <typename, precision> class matType>
+	GLM_FUNC_DECL matType<T, P> inverse(matType<T, P> const & m);
+
+	/// @}
+}//namespace glm
+
+#include "func_matrix.inl"

glm/glm/detail/func_matrix.inl

@@ -0,0 +1,310 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// 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.
+///
+/// @ref core
+/// @file glm/detail/func_matrix.inl
+/// @date 2008-03-08 / 2011-06-15
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#include "../geometric.hpp"
+#include <limits>
+
+namespace glm{
+namespace detail
+{
+	template <template <class, precision> class matType, typename T, precision P>
+	struct compute_transpose{};
+
+	template <typename T, precision P>
+	struct compute_transpose<tmat2x2, T, P>
+	{
+		GLM_FUNC_QUALIFIER static tmat2x2<T, P> call(tmat2x2<T, P> const & m)
+		{
+			tmat2x2<T, P> result(uninitialize);
+			result[0][0] = m[0][0];
+			result[0][1] = m[1][0];
+			result[1][0] = m[0][1];
+			result[1][1] = m[1][1];
+			return result;
+		}
+	};
+
+	template <typename T, precision P>
+	struct compute_transpose<tmat2x3, T, P>
+	{
+		GLM_FUNC_QUALIFIER static tmat3x2<T, P> call(tmat2x3<T, P> const & m)
+		{
+			tmat3x2<T, P> result(uninitialize);
+			result[0][0] = m[0][0];
+			result[0][1] = m[1][0];
+			result[1][0] = m[0][1];
+			result[1][1] = m[1][1];
+			result[2][0] = m[0][2];
+			result[2][1] = m[1][2];
+			return result;
+		}
+	};
+
+	template <typename T, precision P>
+	struct compute_transpose<tmat2x4, T, P>
+	{
+		GLM_FUNC_QUALIFIER static tmat4x2<T, P> call(tmat2x4<T, P> const & m)
+		{
+			tmat4x2<T, P> result(uninitialize);
+			result[0][0] = m[0][0];
+			result[0][1] = m[1][0];
+			result[1][0] = m[0][1];
+			result[1][1] = m[1][1];
+			result[2][0] = m[0][2];
+			result[2][1] = m[1][2];
+			result[3][0] = m[0][3];
+			result[3][1] = m[1][3];
+			return result;
+		}
+	};
+
+	template <typename T, precision P>
+	struct compute_transpose<tmat3x2, T, P>
+	{
+		GLM_FUNC_QUALIFIER static tmat2x3<T, P> call(tmat3x2<T, P> const & m)
+		{
+			tmat2x3<T, P> result(uninitialize);
+			result[0][0] = m[0][0];
+			result[0][1] = m[1][0];
+			result[0][2] = m[2][0];
+			result[1][0] = m[0][1];
+			result[1][1] = m[1][1];
+			result[1][2] = m[2][1];
+			return result;
+		}
+	};
+
+	template <typename T, precision P>
+	struct compute_transpose<tmat3x3, T, P>
+	{
+		GLM_FUNC_QUALIFIER static tmat3x3<T, P> call(tmat3x3<T, P> const & m)
+		{
+			tmat3x3<T, P> result(uninitialize);
+			result[0][0] = m[0][0];
+			result[0][1] = m[1][0];
+			result[0][2] = m[2][0];
+
+			result[1][0] = m[0][1];
+			result[1][1] = m[1][1];
+			result[1][2] = m[2][1];
+
+			result[2][0] = m[0][2];
+			result[2][1] = m[1][2];
+			result[2][2] = m[2][2];
+			return result;
+		}
+	};
+
+	template <typename T, precision P>
+	struct compute_transpose<tmat3x4, T, P>
+	{
+		GLM_FUNC_QUALIFIER static tmat4x3<T, P> call(tmat3x4<T, P> const & m)
+		{
+			tmat4x3<T, P> result(uninitialize);
+			result[0][0] = m[0][0];
+			result[0][1] = m[1][0];
+			result[0][2] = m[2][0];
+			result[1][0] = m[0][1];
+			result[1][1] = m[1][1];
+			result[1][2] = m[2][1];
+			result[2][0] = m[0][2];
+			result[2][1] = m[1][2];
+			result[2][2] = m[2][2];
+			result[3][0] = m[0][3];
+			result[3][1] = m[1][3];
+			result[3][2] = m[2][3];
+			return result;
+		}
+	};
+
+	template <typename T, precision P>
+	struct compute_transpose<tmat4x2, T, P>
+	{
+		GLM_FUNC_QUALIFIER static tmat2x4<T, P> call(tmat4x2<T, P> const & m)
+		{
+			tmat2x4<T, P> result(uninitialize);
+			result[0][0] = m[0][0];
+			result[0][1] = m[1][0];
+			result[0][2] = m[2][0];
+			result[0][3] = m[3][0];
+			result[1][0] = m[0][1];
+			result[1][1] = m[1][1];
+			result[1][2] = m[2][1];
+			result[1][3] = m[3][1];
+			return result;
+		}
+	};
+
+	template <typename T, precision P>
+	struct compute_transpose<tmat4x3, T, P>
+	{
+		GLM_FUNC_QUALIFIER static tmat3x4<T, P> call(tmat4x3<T, P> const & m)
+		{
+			tmat3x4<T, P> result(uninitialize);
+			result[0][0] = m[0][0];
+			result[0][1] = m[1][0];
+			result[0][2] = m[2][0];
+			result[0][3] = m[3][0];
+			result[1][0] = m[0][1];
+			result[1][1] = m[1][1];
+			result[1][2] = m[2][1];
+			result[1][3] = m[3][1];
+			result[2][0] = m[0][2];
+			result[2][1] = m[1][2];
+			result[2][2] = m[2][2];
+			result[2][3] = m[3][2];
+			return result;
+		}
+	};
+
+	template <typename T, precision P>
+	struct compute_transpose<tmat4x4, T, P>
+	{
+		GLM_FUNC_QUALIFIER static tmat4x4<T, P> call(tmat4x4<T, P> const & m)
+		{
+			tmat4x4<T, P> result(uninitialize);
+			result[0][0] = m[0][0];
+			result[0][1] = m[1][0];
+			result[0][2] = m[2][0];
+			result[0][3] = m[3][0];
+
+			result[1][0] = m[0][1];
+			result[1][1] = m[1][1];
+			result[1][2] = m[2][1];
+			result[1][3] = m[3][1];
+
+			result[2][0] = m[0][2];
+			result[2][1] = m[1][2];
+			result[2][2] = m[2][2];
+			result[2][3] = m[3][2];
+
+			result[3][0] = m[0][3];
+			result[3][1] = m[1][3];
+			result[3][2] = m[2][3];
+			result[3][3] = m[3][3];
+			return result;
+		}
+	};
+
+	template <template <class, precision> class matType, typename T, precision P>
+	struct compute_determinant{};
+
+	template <typename T, precision P>
+	struct compute_determinant<tmat2x2, T, P>
+	{
+		GLM_FUNC_QUALIFIER static T call(tmat2x2<T, P> const & m)
+		{
+			return m[0][0] * m[1][1] - m[1][0] * m[0][1];
+		}
+	};
+
+	template <typename T, precision P>
+	struct compute_determinant<tmat3x3, T, P>
+	{
+		GLM_FUNC_QUALIFIER static T call(tmat3x3<T, P> const & m)
+		{
+			return
+				+ m[0][0] * (m[1][1] * m[2][2] - m[2][1] * m[1][2])
+				- m[1][0] * (m[0][1] * m[2][2] - m[2][1] * m[0][2])
+				+ m[2][0] * (m[0][1] * m[1][2] - m[1][1] * m[0][2]);
+		}
+	};
+
+	template <typename T, precision P>
+	struct compute_determinant<tmat4x4, T, P>
+	{
+		GLM_FUNC_QUALIFIER static T call(tmat4x4<T, P> const & m)
+		{
+			T SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
+			T SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
+			T SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
+			T SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
+			T SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
+			T SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
+
+			tvec4<T, P> DetCof(
+				+ (m[1][1] * SubFactor00 - m[1][2] * SubFactor01 + m[1][3] * SubFactor02),
+				- (m[1][0] * SubFactor00 - m[1][2] * SubFactor03 + m[1][3] * SubFactor04),
+				+ (m[1][0] * SubFactor01 - m[1][1] * SubFactor03 + m[1][3] * SubFactor05),
+				- (m[1][0] * SubFactor02 - m[1][1] * SubFactor04 + m[1][2] * SubFactor05));
+
+			return
+				m[0][0] * DetCof[0] + m[0][1] * DetCof[1] +
+				m[0][2] * DetCof[2] + m[0][3] * DetCof[3];
+		}
+	};
+}//namespace detail
+
+	template <typename T, precision P, template <typename, precision> class matType>
+	GLM_FUNC_QUALIFIER matType<T, P> matrixCompMult(matType<T, P> const & x, matType<T, P> const & y)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'matrixCompMult' only accept floating-point inputs");
+
+		matType<T, P> result(uninitialize);
+		for(detail::component_count_t i = 0; i < detail::component_count(result); ++i)
+			result[i] = x[i] * y[i];
+		return result;
+	}
+
+	template<typename T, precision P, template <typename, precision> class vecTypeA, template <typename, precision> class vecTypeB>
+	GLM_FUNC_QUALIFIER typename detail::outerProduct_trait<T, P, vecTypeA, vecTypeB>::type outerProduct(vecTypeA<T, P> const & c, vecTypeB<T, P> const & r)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'outerProduct' only accept floating-point inputs");
+
+		typename detail::outerProduct_trait<T, P, vecTypeA, vecTypeB>::type m(uninitialize);
+		for(detail::component_count_t i = 0; i < detail::component_count(m); ++i)
+			m[i] = c * r[i];
+		return m;
+	}
+
+	template <typename T, precision P, template <typename, precision> class matType>
+	GLM_FUNC_QUALIFIER typename matType<T, P>::transpose_type transpose(matType<T, P> const & m)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'transpose' only accept floating-point inputs");
+		return detail::compute_transpose<matType, T, P>::call(m);
+	}
+
+	template <typename T, precision P, template <typename, precision> class matType>
+	GLM_FUNC_QUALIFIER T determinant(matType<T, P> const & m)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'determinant' only accept floating-point inputs");
+		return detail::compute_determinant<matType, T, P>::call(m);
+	}
+
+	template <typename T, precision P, template <typename, precision> class matType>
+	GLM_FUNC_QUALIFIER matType<T, P> inverse(matType<T, P> const & m)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'inverse' only accept floating-point inputs");
+		return detail::compute_inverse(m);
+	}
+
+}//namespace glm

glm/glm/detail/func_noise.hpp

@@ -0,0 +1,93 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// 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.
+///
+/// @ref core
+/// @file glm/detail/func_noise.hpp
+/// @date 2008-08-01 / 2011-06-18
+/// @author Christophe Riccio
+///
+/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.13 Noise Functions</a>
+/// 
+/// @defgroup core_func_noise Noise functions
+/// @ingroup core
+/// 
+/// Noise functions are stochastic functions that can be used to increase visual 
+/// complexity. Values returned by the following noise functions give the 
+/// appearance of randomness, but are not truly random.
+///////////////////////////////////////////////////////////////////////////////////
+
+#pragma once
+
+#include "type_vec1.hpp"
+#include "type_vec2.hpp"
+#include "type_vec3.hpp"
+#include "setup.hpp"
+
+namespace glm
+{
+	/// @addtogroup core_func_noise
+	/// @{
+
+	/// Returns a 1D noise value based on the input value x.
+	///
+	/// @tparam genType Floating-point scalar or vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/noise1.xml">GLSL noise1 man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.13 Noise Functions</a>
+	template <typename genType>
+	GLM_FUNC_DECL typename genType::value_type noise1(genType const & x);
+
+	/// Returns a 2D noise value based on the input value x.
+	///
+	/// @tparam genType Floating-point scalar or vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/noise2.xml">GLSL noise2 man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.13 Noise Functions</a>
+	template <typename genType>
+	GLM_FUNC_DECL tvec2<typename genType::value_type, defaultp> noise2(genType const & x);
+
+	/// Returns a 3D noise value based on the input value x.
+	///
+	/// @tparam genType Floating-point scalar or vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/noise3.xml">GLSL noise3 man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.13 Noise Functions</a>
+	template <typename genType>
+	GLM_FUNC_DECL tvec3<typename genType::value_type, defaultp> noise3(genType const & x);
+
+	/// Returns a 4D noise value based on the input value x.
+	///
+	/// @tparam genType Floating-point scalar or vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/noise4.xml">GLSL noise4 man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.13 Noise Functions</a>
+	template <typename genType>
+	GLM_FUNC_DECL tvec4<typename genType::value_type, defaultp> noise4(genType const & x);
+
+	/// @}
+}//namespace glm
+
+#include "func_noise.inl"

glm/glm/detail/func_noise.inl

@@ -0,0 +1,388 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// 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.
+///
+/// @ref core
+/// @file glm/detail/func_noise.inl
+/// @date 2008-08-01 / 2011-09-27
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#include "../detail/_noise.hpp"
+#include "./func_common.hpp"
+
+namespace glm{
+namespace detail
+{
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tvec4<T, P> grad4(T const & j, tvec4<T, P> const & ip)
+	{
+		tvec3<T, P> pXYZ = floor(fract(tvec3<T, P>(j) * tvec3<T, P>(ip)) * T(7)) * ip[2] - T(1);
+		T pW = static_cast<T>(1.5) - dot(abs(pXYZ), tvec3<T, P>(1));
+		tvec4<T, P> s = tvec4<T, P>(lessThan(tvec4<T, P>(pXYZ, pW), tvec4<T, P>(0.0)));
+		pXYZ = pXYZ + (tvec3<T, P>(s) * T(2) - T(1)) * s.w; 
+		return tvec4<T, P>(pXYZ, pW);
+	}
+}//namespace detail
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER T noise1(T const & x)
+	{
+		return noise1(tvec2<T, defaultp>(x, T(0)));
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER tvec2<T, defaultp> noise2(T const & x)
+	{
+		return tvec2<T, defaultp>(
+			noise1(x + T(0.0)),
+			noise1(x + T(1.0)));
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER tvec3<T, defaultp> noise3(T const & x)
+	{
+		return tvec3<T, defaultp>(
+			noise1(x - T(1.0)),
+			noise1(x + T(0.0)),
+			noise1(x + T(1.0)));
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER tvec4<T, defaultp> noise4(T const & x)
+	{
+		return tvec4<T, defaultp>(
+			noise1(x - T(1.0)),
+			noise1(x + T(0.0)),
+			noise1(x + T(1.0)),
+			noise1(x + T(2.0)));
+	}
+	
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER T noise1(tvec2<T, P> const & v)
+	{
+		tvec4<T, P> const C = tvec4<T, P>(
+			T( 0.211324865405187),		// (3.0 -  sqrt(3.0)) / 6.0
+			T( 0.366025403784439),		//  0.5 * (sqrt(3.0)  - 1.0)
+			T(-0.577350269189626),		// -1.0 + 2.0 * C.x
+			T( 0.024390243902439));		//  1.0 / 41.0
+		
+		// First corner
+		tvec2<T, P> i  = floor(v + dot(v, tvec2<T, P>(C[1])));
+		tvec2<T, P> x0 = v -   i + dot(i, tvec2<T, P>(C[0]));
+		
+		// Other corners
+		//i1.x = step( x0.y, x0.x ); // x0.x > x0.y ? 1.0 : 0.0
+		//i1.y = 1.0 - i1.x;
+		tvec2<T, P> i1 = (x0.x > x0.y) ? tvec2<T, P>(1, 0) : tvec2<T, P>(0, 1);
+
+		// x0 = x0 - 0.0 + 0.0 * C.xx ;
+		// x1 = x0 - i1 + 1.0 * C.xx ;
+		// x2 = x0 - 1.0 + 2.0 * C.xx ;
+		tvec4<T, P> x12 = tvec4<T, P>(x0.x, x0.y, x0.x, x0.y) + tvec4<T, P>(C.x, C.x, C.z, C.z);
+		x12 = tvec4<T, P>(tvec2<T, P>(x12) - i1, x12.z, x12.w);
+		
+		// Permutations
+		i = mod(i, T(289)); // Avoid truncation effects in permutation
+		tvec3<T, P> p = detail::permute(
+			detail::permute(i.y + tvec3<T, P>(T(0), i1.y, T(1))) + i.x + tvec3<T, P>(T(0), i1.x, T(1)));
+		
+		tvec3<T, P> m = max(T(0.5) - tvec3<T, P>(
+			dot(x0, x0),
+			dot(tvec2<T, P>(x12.x, x12.y), tvec2<T, P>(x12.x, x12.y)),
+			dot(tvec2<T, P>(x12.z, x12.w), tvec2<T, P>(x12.z, x12.w))), T(0));
+		
+		m = m * m;
+		m = m * m;
+		
+		// Gradients: 41 points uniformly over a line, mapped onto a diamond.
+		// The ring size 17*17 = 289 is close to a multiple of 41 (41*7 = 287)
+		
+		tvec3<T, P> x = static_cast<T>(2) * fract(p * C.w) - T(1);
+		tvec3<T, P> h = abs(x) - T(0.5);
+		tvec3<T, P> ox = floor(x + T(0.5));
+		tvec3<T, P> a0 = x - ox;
+		
+		// Normalise gradients implicitly by scaling m
+		// Inlined for speed: m *= taylorInvSqrt( a0*a0 + h*h );
+		m *= static_cast<T>(1.79284291400159) - T(0.85373472095314) * (a0 * a0 + h * h);
+		
+		// Compute final noise value at P
+		tvec3<T, P> g;
+		g.x  = a0.x  * x0.x  + h.x  * x0.y;
+		//g.yz = a0.yz * x12.xz + h.yz * x12.yw;
+		g.y = a0.y * x12.x + h.y * x12.y;
+		g.z = a0.z * x12.z + h.z * x12.w;
+		return T(130) * dot(m, g);
+	}
+	
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER T noise1(tvec3<T, P> const & v)
+	{
+		tvec2<T, P> const C(1.0 / 6.0, 1.0 / 3.0);
+		tvec4<T, P> const D(0.0, 0.5, 1.0, 2.0);
+		
+		// First corner
+		tvec3<T, P> i(floor(v + dot(v, tvec3<T, P>(C.y))));
+		tvec3<T, P> x0(v - i + dot(i, tvec3<T, P>(C.x)));
+		
+		// Other corners
+		tvec3<T, P> g(step(tvec3<T, P>(x0.y, x0.z, x0.x), x0));
+		tvec3<T, P> l(T(1) - g);
+		tvec3<T, P> i1(min(g, tvec3<T, P>(l.z, l.x, l.y)));
+		tvec3<T, P> i2(max(g, tvec3<T, P>(l.z, l.x, l.y)));
+		
+		// x0 = x0 - 0.0 + 0.0 * C.xxx;
+		// x1 = x0 - i1  + 1.0 * C.xxx;
+		// x2 = x0 - i2  + 2.0 * C.xxx;
+		// x3 = x0 - 1.0 + 3.0 * C.xxx;
+		tvec3<T, P> x1(x0 - i1 + C.x);
+		tvec3<T, P> x2(x0 - i2 + C.y);		// 2.0*C.x = 1/3 = C.y
+		tvec3<T, P> x3(x0 - D.y);			// -1.0+3.0*C.x = -0.5 = -D.y
+		
+		// Permutations
+		i = mod289(i); 
+		tvec4<T, P> p(detail::permute(detail::permute(detail::permute(
+			i.z + tvec4<T, P>(T(0), i1.z, i2.z, T(1))) +
+			i.y + tvec4<T, P>(T(0), i1.y, i2.y, T(1))) +
+			i.x + tvec4<T, P>(T(0), i1.x, i2.x, T(1))));
+		
+		// Gradients: 7x7 points over a square, mapped onto an octahedron.
+		// The ring size 17*17 = 289 is close to a multiple of 49 (49*6 = 294)
+		T n_ = static_cast<T>(0.142857142857); // 1.0/7.0
+		tvec3<T, P> ns(n_ * tvec3<T, P>(D.w, D.y, D.z) - tvec3<T, P>(D.x, D.z, D.x));
+		
+		tvec4<T, P> j(p - T(49) * floor(p * ns.z * ns.z));	// mod(p,7*7)
+		
+		tvec4<T, P> x_(floor(j * ns.z));
+		tvec4<T, P> y_(floor(j - T(7) * x_));				// mod(j,N)
+		
+		tvec4<T, P> x(x_ * ns.x + ns.y);
+		tvec4<T, P> y(y_ * ns.x + ns.y);
+		tvec4<T, P> h(T(1) - abs(x) - abs(y));
+		
+		tvec4<T, P> b0(x.x, x.y, y.x, y.y);
+		tvec4<T, P> b1(x.z, x.w, y.z, y.w);
+		
+		// vec4 s0 = vec4(lessThan(b0,0.0))*2.0 - 1.0;
+		// vec4 s1 = vec4(lessThan(b1,0.0))*2.0 - 1.0;
+		tvec4<T, P> s0(floor(b0) * T(2) + T(1));
+		tvec4<T, P> s1(floor(b1) * T(2) + T(1));
+		tvec4<T, P> sh(-step(h, tvec4<T, P>(0.0)));
+		
+		tvec4<T, P> a0 = tvec4<T, P>(b0.x, b0.z, b0.y, b0.w) + tvec4<T, P>(s0.x, s0.z, s0.y, s0.w) * tvec4<T, P>(sh.x, sh.x, sh.y, sh.y);
+		tvec4<T, P> a1 = tvec4<T, P>(b1.x, b1.z, b1.y, b1.w) + tvec4<T, P>(s1.x, s1.z, s1.y, s1.w) * tvec4<T, P>(sh.z, sh.z, sh.w, sh.w);
+		
+		tvec3<T, P> p0(a0.x, a0.y, h.x);
+		tvec3<T, P> p1(a0.z, a0.w, h.y);
+		tvec3<T, P> p2(a1.x, a1.y, h.z);
+		tvec3<T, P> p3(a1.z, a1.w, h.w);
+		
+		// Normalise gradients
+		tvec4<T, P> norm = taylorInvSqrt(tvec4<T, P>(dot(p0, p0), dot(p1, p1), dot(p2, p2), dot(p3, p3)));
+		p0 *= norm.x;
+		p1 *= norm.y;
+		p2 *= norm.z;
+		p3 *= norm.w;
+		
+		// Mix final noise value
+		tvec4<T, P> m = max(T(0.6) - tvec4<T, P>(dot(x0, x0), dot(x1, x1), dot(x2, x2), dot(x3, x3)), T(0));
+		m = m * m;
+		return T(42) * dot(m * m, tvec4<T, P>(dot(p0, x0), dot(p1, x1), dot(p2, x2), dot(p3, x3)));
+	}
+	
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER T noise1(tvec4<T, P> const & v)
+	{
+		tvec4<T, P> const C(
+			0.138196601125011,		// (5 - sqrt(5))/20  G4
+			0.276393202250021,		// 2 * G4
+			0.414589803375032,		// 3 * G4
+			-0.447213595499958);	// -1 + 4 * G4
+		
+		// (sqrt(5) - 1)/4 = F4, used once below
+		T const F4 = static_cast<T>(0.309016994374947451);
+		
+		// First corner
+		tvec4<T, P> i  = floor(v + dot(v, tvec4<T, P>(F4)));
+		tvec4<T, P> x0 = v -   i + dot(i, tvec4<T, P>(C.x));
+		
+		// Other corners
+		
+		// Rank sorting originally contributed by Bill Licea-Kane, AMD (formerly ATI)
+		tvec4<T, P> i0;
+		tvec3<T, P> isX = step(tvec3<T, P>(x0.y, x0.z, x0.w), tvec3<T, P>(x0.x));
+		tvec3<T, P> isYZ = step(tvec3<T, P>(x0.z, x0.w, x0.w), tvec3<T, P>(x0.y, x0.y, x0.z));
+		
+		//  i0.x = dot(isX, vec3(1.0));
+		//i0.x = isX.x + isX.y + isX.z;
+		//i0.yzw = static_cast<T>(1) - isX;
+		i0 = tvec4<T, P>(isX.x + isX.y + isX.z, T(1) - isX);
+		
+		//  i0.y += dot(isYZ.xy, vec2(1.0));
+		i0.y += isYZ.x + isYZ.y;
+		
+		//i0.zw += 1.0 - tvec2<T, P>(isYZ.x, isYZ.y);
+		i0.z += static_cast<T>(1) - isYZ.x;
+		i0.w += static_cast<T>(1) - isYZ.y;
+		i0.z += isYZ.z;
+		i0.w += static_cast<T>(1) - isYZ.z;
+		
+		// i0 now contains the unique values 0,1,2,3 in each channel
+		tvec4<T, P> i3 = clamp(i0, T(0), T(1));
+		tvec4<T, P> i2 = clamp(i0 - T(1), T(0), T(1));
+		tvec4<T, P> i1 = clamp(i0 - T(2), T(0), T(1));
+		
+		//  x0 = x0 - 0.0 + 0.0 * C.xxxx
+		//  x1 = x0 - i1  + 0.0 * C.xxxx
+		//  x2 = x0 - i2  + 0.0 * C.xxxx
+		//  x3 = x0 - i3  + 0.0 * C.xxxx
+		//  x4 = x0 - 1.0 + 4.0 * C.xxxx
+		tvec4<T, P> x1 = x0 - i1 + C.x;
+		tvec4<T, P> x2 = x0 - i2 + C.y;
+		tvec4<T, P> x3 = x0 - i3 + C.z;
+		tvec4<T, P> x4 = x0 + C.w;
+		
+		// Permutations
+		i = mod(i, T(289));
+		T j0 = detail::permute(detail::permute(detail::permute(detail::permute(i.w) + i.z) + i.y) + i.x);
+		tvec4<T, P> j1 = detail::permute(detail::permute(detail::permute(detail::permute(
+			i.w + tvec4<T, P>(i1.w, i2.w, i3.w, T(1))) +
+			i.z + tvec4<T, P>(i1.z, i2.z, i3.z, T(1))) +
+			i.y + tvec4<T, P>(i1.y, i2.y, i3.y, T(1))) +
+			i.x + tvec4<T, P>(i1.x, i2.x, i3.x, T(1)));
+		
+		// Gradients: 7x7x6 points over a cube, mapped onto a 4-cross polytope
+		// 7*7*6 = 294, which is close to the ring size 17*17 = 289.
+		tvec4<T, P> ip = tvec4<T, P>(T(1) / T(294), T(1) / T(49), T(1) / T(7), T(0));
+		
+		tvec4<T, P> p0 = detail::grad4(j0,   ip);
+		tvec4<T, P> p1 = detail::grad4(j1.x, ip);
+		tvec4<T, P> p2 = detail::grad4(j1.y, ip);
+		tvec4<T, P> p3 = detail::grad4(j1.z, ip);
+		tvec4<T, P> p4 = detail::grad4(j1.w, ip);
+		
+		// Normalise gradients
+		tvec4<T, P> norm = detail::taylorInvSqrt(tvec4<T, P>(dot(p0, p0), dot(p1, p1), dot(p2, p2), dot(p3, p3)));
+		p0 *= norm.x;
+		p1 *= norm.y;
+		p2 *= norm.z;
+		p3 *= norm.w;
+		p4 *= taylorInvSqrt(dot(p4, p4));
+		
+		// Mix contributions from the five corners
+		tvec3<T, P> m0 = max(T(0.6) - tvec3<T, P>(dot(x0, x0), dot(x1, x1), dot(x2, x2)), T(0));
+		tvec2<T, P> m1 = max(T(0.6) - tvec2<T, P>(dot(x3, x3), dot(x4, x4)             ), T(0));
+		m0 = m0 * m0;
+		m1 = m1 * m1;
+		
+		return T(49) * (
+			dot(m0 * m0, tvec3<T, P>(dot(p0, x0), dot(p1, x1), dot(p2, x2))) +
+			dot(m1 * m1, tvec2<T, P>(dot(p3, x3), dot(p4, x4))));
+	}
+	
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tvec2<T, P> noise2(tvec2<T, P> const & x)
+	{
+		return tvec2<T, P>(
+			noise1(x + tvec2<T, P>(0.0)),
+			noise1(tvec2<T, P>(0.0) - x));
+	}
+	
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tvec2<T, P> noise2(tvec3<T, P> const & x)
+	{
+		return tvec2<T, P>(
+			noise1(x + tvec3<T, P>(0.0)),
+			noise1(tvec3<T, P>(0.0) - x));
+	}
+	
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tvec2<T, P> noise2(tvec4<T, P> const & x)
+	{
+		return tvec2<T, P>(
+			noise1(x + tvec4<T, P>(0)),
+			noise1(tvec4<T, P>(0) - x));
+	}
+	
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tvec3<T, P> noise3(tvec2<T, P> const & x)
+	{
+		return tvec3<T, P>(
+			noise1(x - tvec2<T, P>(1.0)),
+			noise1(x + tvec2<T, P>(0.0)),
+			noise1(x + tvec2<T, P>(1.0)));
+	}
+	
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tvec3<T, P> noise3(tvec3<T, P> const & x)
+	{
+		return tvec3<T, P>(
+			noise1(x - tvec3<T, P>(1.0)),
+			noise1(x + tvec3<T, P>(0.0)),
+			noise1(x + tvec3<T, P>(1.0)));
+	}
+	
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tvec3<T, P> noise3(tvec4<T, P> const & x)
+	{
+		return tvec3<T, P>(
+			noise1(x - tvec4<T, P>(1)),
+			noise1(x + tvec4<T, P>(0)),
+			noise1(x + tvec4<T, P>(1)));
+	}
+	
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tvec4<T, P> noise4(tvec2<T, P> const & x)
+	{
+		return tvec4<T, P>(
+			noise1(x - tvec2<T, P>(1)),
+			noise1(x + tvec2<T, P>(0)),
+			noise1(x + tvec2<T, P>(1)),
+			noise1(x + tvec2<T, P>(2)));
+	}
+
+	
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tvec4<T, P> noise4(tvec3<T, P> const & x)
+	{
+		return tvec4<T, P>(
+			noise1(x - tvec3<T, P>(1)),
+			noise1(x + tvec3<T, P>(0)),
+			noise1(x + tvec3<T, P>(1)),
+			noise1(x + tvec3<T, P>(2)));
+	}
+	
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tvec4<T, P> noise4(tvec4<T, P> const & x)
+	{
+		return tvec4<T, P>(
+			noise1(x - tvec4<T, P>(1)),
+			noise1(x + tvec4<T, P>(0)),
+			noise1(x + tvec4<T, P>(1)),
+			noise1(x + tvec4<T, P>(2)));
+	}
+	
+}//namespace glm

glm/glm/detail/func_packing.hpp

@@ -0,0 +1,197 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// 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.
+///
+/// @ref core
+/// @file glm/detail/func_packing.hpp
+/// @date 2010-03-17 / 2011-06-15
+/// @author Christophe Riccio
+///
+/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
+/// @see gtc_packing
+/// 
+/// @defgroup core_func_packing Floating-Point Pack and Unpack Functions
+/// @ingroup core
+/// 
+/// These functions do not operate component-wise, rather as described in each case.
+///////////////////////////////////////////////////////////////////////////////////
+
+#pragma once
+
+#include "type_vec2.hpp"
+#include "type_vec4.hpp"
+
+namespace glm
+{
+	/// @addtogroup core_func_packing
+	/// @{
+
+	/// First, converts each component of the normalized floating-point value v into 8- or 16-bit integer values. 
+	/// Then, the results are packed into the returned 32-bit unsigned integer.
+	/// 
+	/// The conversion for component c of v to fixed point is done as follows:
+	/// packUnorm2x16: round(clamp(c, 0, +1) * 65535.0) 
+	/// 
+	/// The first component of the vector will be written to the least significant bits of the output; 
+	/// the last component will be written to the most significant bits.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packUnorm2x16.xml">GLSL packUnorm2x16 man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
+	GLM_FUNC_DECL uint packUnorm2x16(vec2 const & v);
+
+	/// First, converts each component of the normalized floating-point value v into 8- or 16-bit integer values. 
+	/// Then, the results are packed into the returned 32-bit unsigned integer.
+	/// 
+	/// The conversion for component c of v to fixed point is done as follows:
+	/// packSnorm2x16: round(clamp(v, -1, +1) * 32767.0)
+	/// 
+	/// The first component of the vector will be written to the least significant bits of the output; 
+	/// the last component will be written to the most significant bits.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packSnorm2x16.xml">GLSL packSnorm2x16 man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
+	GLM_FUNC_DECL uint packSnorm2x16(vec2 const & v);
+
+	/// First, converts each component of the normalized floating-point value v into 8- or 16-bit integer values. 
+	/// Then, the results are packed into the returned 32-bit unsigned integer.
+	/// 
+	/// The conversion for component c of v to fixed point is done as follows:
+	/// packUnorm4x8:	round(clamp(c, 0, +1) * 255.0)
+	/// 
+	/// The first component of the vector will be written to the least significant bits of the output; 
+	/// the last component will be written to the most significant bits.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packUnorm4x8.xml">GLSL packUnorm4x8 man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
+	GLM_FUNC_DECL uint packUnorm4x8(vec4 const & v);
+
+	/// First, converts each component of the normalized floating-point value v into 8- or 16-bit integer values. 
+	/// Then, the results are packed into the returned 32-bit unsigned integer.
+	/// 
+	/// The conversion for component c of v to fixed point is done as follows:
+	/// packSnorm4x8:	round(clamp(c, -1, +1) * 127.0) 
+	/// 
+	/// The first component of the vector will be written to the least significant bits of the output; 
+	/// the last component will be written to the most significant bits.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packSnorm4x8.xml">GLSL packSnorm4x8 man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
+	GLM_FUNC_DECL uint packSnorm4x8(vec4 const & v);
+
+	/// First, unpacks a single 32-bit unsigned integer p into a pair of 16-bit unsigned integers, four 8-bit unsigned integers, or four 8-bit signed integers. 
+	/// Then, each component is converted to a normalized floating-point value to generate the returned two- or four-component vector.
+	/// 
+	/// The conversion for unpacked fixed-point value f to floating point is done as follows:
+	/// unpackUnorm2x16: f / 65535.0 
+	/// 
+	/// The first component of the returned vector will be extracted from the least significant bits of the input; 
+	/// the last component will be extracted from the most significant bits.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackUnorm2x16.xml">GLSL unpackUnorm2x16 man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
+	GLM_FUNC_DECL vec2 unpackUnorm2x16(uint p);
+
+	/// First, unpacks a single 32-bit unsigned integer p into a pair of 16-bit unsigned integers, four 8-bit unsigned integers, or four 8-bit signed integers. 
+	/// Then, each component is converted to a normalized floating-point value to generate the returned two- or four-component vector.
+	/// 
+	/// The conversion for unpacked fixed-point value f to floating point is done as follows:
+	/// unpackSnorm2x16: clamp(f / 32767.0, -1, +1)
+	/// 
+	/// The first component of the returned vector will be extracted from the least significant bits of the input; 
+	/// the last component will be extracted from the most significant bits.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackSnorm2x16.xml">GLSL unpackSnorm2x16 man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
+	GLM_FUNC_DECL vec2 unpackSnorm2x16(uint p);
+
+	/// First, unpacks a single 32-bit unsigned integer p into a pair of 16-bit unsigned integers, four 8-bit unsigned integers, or four 8-bit signed integers. 
+	/// Then, each component is converted to a normalized floating-point value to generate the returned two- or four-component vector.
+	/// 
+	/// The conversion for unpacked fixed-point value f to floating point is done as follows:
+	/// unpackUnorm4x8: f / 255.0
+	/// 
+	/// The first component of the returned vector will be extracted from the least significant bits of the input; 
+	/// the last component will be extracted from the most significant bits.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackUnorm4x8.xml">GLSL unpackUnorm4x8 man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
+	GLM_FUNC_DECL vec4 unpackUnorm4x8(uint p);
+
+	/// First, unpacks a single 32-bit unsigned integer p into a pair of 16-bit unsigned integers, four 8-bit unsigned integers, or four 8-bit signed integers. 
+	/// Then, each component is converted to a normalized floating-point value to generate the returned two- or four-component vector.
+	/// 
+	/// The conversion for unpacked fixed-point value f to floating point is done as follows:
+	/// unpackSnorm4x8: clamp(f / 127.0, -1, +1)
+	/// 
+	/// The first component of the returned vector will be extracted from the least significant bits of the input; 
+	/// the last component will be extracted from the most significant bits.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackSnorm4x8.xml">GLSL unpackSnorm4x8 man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
+	GLM_FUNC_DECL vec4 unpackSnorm4x8(uint p);
+
+	/// Returns a double-precision value obtained by packing the components of v into a 64-bit value. 
+	/// If an IEEE 754 Inf or NaN is created, it will not signal, and the resulting floating point value is unspecified. 
+	/// Otherwise, the bit- level representation of v is preserved. 
+	/// The first vector component specifies the 32 least significant bits; 
+	/// the second component specifies the 32 most significant bits.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packDouble2x32.xml">GLSL packDouble2x32 man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
+	GLM_FUNC_DECL double packDouble2x32(uvec2 const & v);
+
+	/// Returns a two-component unsigned integer vector representation of v. 
+	/// The bit-level representation of v is preserved. 
+	/// The first component of the vector contains the 32 least significant bits of the double; 
+	/// the second component consists the 32 most significant bits.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackDouble2x32.xml">GLSL unpackDouble2x32 man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
+	GLM_FUNC_DECL uvec2 unpackDouble2x32(double v);
+
+	/// Returns an unsigned integer obtained by converting the components of a two-component floating-point vector 
+	/// to the 16-bit floating-point representation found in the OpenGL Specification, 
+	/// and then packing these two 16- bit integers into a 32-bit unsigned integer.
+	/// The first vector component specifies the 16 least-significant bits of the result; 
+	/// the second component specifies the 16 most-significant bits.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packHalf2x16.xml">GLSL packHalf2x16 man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
+	GLM_FUNC_DECL uint packHalf2x16(vec2 const & v);
+	
+	/// Returns a two-component floating-point vector with components obtained by unpacking a 32-bit unsigned integer into a pair of 16-bit values, 
+	/// interpreting those values as 16-bit floating-point numbers according to the OpenGL Specification, 
+	/// and converting them to 32-bit floating-point values.
+	/// The first component of the vector is obtained from the 16 least-significant bits of v; 
+	/// the second component is obtained from the 16 most-significant bits of v.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackHalf2x16.xml">GLSL unpackHalf2x16 man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
+	GLM_FUNC_DECL vec2 unpackHalf2x16(uint v);
+	
+	/// @}
+}//namespace glm
+
+#include "func_packing.inl"

glm/glm/detail/func_packing.inl

@@ -0,0 +1,119 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// 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.
+///
+/// @ref core
+/// @file glm/detail/func_packing.inl
+/// @date 2010-03-17 / 2011-06-15
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#include "func_common.hpp"
+#include "type_half.hpp"
+#include "../fwd.hpp"
+
+namespace glm
+{
+	GLM_FUNC_QUALIFIER uint packUnorm2x16(vec2 const & v)
+	{
+		u16vec2 const Topack(round(clamp(v, 0.0f, 1.0f) * 65535.0f));
+		return reinterpret_cast<uint const &>(Topack);
+	}
+
+	GLM_FUNC_QUALIFIER vec2 unpackUnorm2x16(uint p)
+	{
+		vec2 Unpack(reinterpret_cast<u16vec2 const &>(p));
+		return Unpack * float(1.5259021896696421759365224689097e-5); // 1.0 / 65535.0
+	}
+
+	GLM_FUNC_QUALIFIER uint packSnorm2x16(vec2 const & v)
+	{
+		i16vec2 const Topack(round(clamp(v ,-1.0f, 1.0f) * 32767.0f));
+		return reinterpret_cast<uint const &>(Topack);
+	}
+
+	GLM_FUNC_QUALIFIER vec2 unpackSnorm2x16(uint p)
+	{
+		vec2 const Unpack(reinterpret_cast<i16vec2 const &>(p));
+		return clamp(
+			Unpack * 3.0518509475997192297128208258309e-5f, //1.0f / 32767.0f,
+			-1.0f, 1.0f);
+	}
+
+	GLM_FUNC_QUALIFIER uint packUnorm4x8(vec4 const & v)
+	{
+		u8vec4 const Topack(round(clamp(v, 0.0f, 1.0f) * 255.0f));
+		return reinterpret_cast<uint const &>(Topack);
+	}
+
+	GLM_FUNC_QUALIFIER vec4 unpackUnorm4x8(uint p)
+	{
+		vec4 const Unpack(reinterpret_cast<u8vec4 const&>(p));
+		return Unpack * float(0.0039215686274509803921568627451); // 1 / 255
+	}
+	
+	GLM_FUNC_QUALIFIER uint packSnorm4x8(vec4 const & v)
+	{
+		i8vec4 const Topack(round(clamp(v ,-1.0f, 1.0f) * 127.0f));
+		return reinterpret_cast<uint const &>(Topack);
+	}
+	
+	GLM_FUNC_QUALIFIER glm::vec4 unpackSnorm4x8(uint p)
+	{
+		vec4 const Unpack(reinterpret_cast<i8vec4 const &>(p));
+		return clamp(
+			Unpack * 0.0078740157480315f, // 1.0f / 127.0f
+			-1.0f, 1.0f);
+	}
+
+	GLM_FUNC_QUALIFIER double packDouble2x32(uvec2 const & v)
+	{
+		return reinterpret_cast<double const &>(v);
+	}
+
+	GLM_FUNC_QUALIFIER uvec2 unpackDouble2x32(double v)
+	{
+		return reinterpret_cast<uvec2 const &>(v);
+	}
+
+	GLM_FUNC_QUALIFIER uint packHalf2x16(vec2 const & v)
+	{
+		i16vec2 const Unpack(
+			detail::toFloat16(v.x),
+			detail::toFloat16(v.y));
+
+		return reinterpret_cast<uint const &>(Unpack);
+	}
+
+	GLM_FUNC_QUALIFIER vec2 unpackHalf2x16(uint v)
+	{
+		i16vec2 const Unpack(reinterpret_cast<i16vec2 const &>(v));
+	
+		return vec2(
+			detail::toFloat32(Unpack.x), 
+			detail::toFloat32(Unpack.y));
+	}
+}//namespace glm
+

glm/glm/detail/func_trigonometric.hpp

@@ -0,0 +1,205 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// 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.
+///
+/// @ref core
+/// @file glm/detail/func_trigonometric.hpp
+/// @date 2008-08-01 / 2011-06-15
+/// @author Christophe Riccio
+///
+/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
+/// 
+/// @defgroup core_func_trigonometric Angle and Trigonometry Functions
+/// @ingroup core
+/// 
+/// Function parameters specified as angle are assumed to be in units of radians. 
+/// In no case will any of these functions result in a divide by zero error. If 
+/// the divisor of a ratio is 0, then results will be undefined.
+/// 
+/// These all operate component-wise. The description is per component.
+///////////////////////////////////////////////////////////////////////////////////
+
+#pragma once
+
+#include "setup.hpp"
+#include "precision.hpp"
+
+namespace glm
+{
+	/// @addtogroup core_func_trigonometric
+	/// @{
+
+	/// Converts degrees to radians and returns the result.
+	///
+	/// @tparam genType Floating-point scalar or vector types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/radians.xml">GLSL radians man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> radians(vecType<T, P> const & degrees);
+
+	/// Converts radians to degrees and returns the result.
+	///
+	/// @tparam genType Floating-point scalar or vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/degrees.xml">GLSL degrees man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> degrees(vecType<T, P> const & radians);
+
+	/// The standard trigonometric sine function. 
+	/// The values returned by this function will range from [-1, 1].
+	/// 
+	/// @tparam genType Floating-point scalar or vector types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/sin.xml">GLSL sin man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> sin(vecType<T, P> const & angle);
+
+	/// The standard trigonometric cosine function. 
+	/// The values returned by this function will range from [-1, 1].
+	/// 
+	/// @tparam genType Floating-point scalar or vector types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/cos.xml">GLSL cos man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> cos(vecType<T, P> const & angle);
+
+	/// The standard trigonometric tangent function.
+	///
+	/// @tparam genType Floating-point scalar or vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/tan.xml">GLSL tan man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> tan(vecType<T, P> const & angle); 
+
+	/// Arc sine. Returns an angle whose sine is x. 
+	/// The range of values returned by this function is [-PI/2, PI/2]. 
+	/// Results are undefined if |x| > 1.
+	///
+	/// @tparam genType Floating-point scalar or vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/asin.xml">GLSL asin man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> asin(vecType<T, P> const & x);
+
+	/// Arc cosine. Returns an angle whose sine is x. 
+	/// The range of values returned by this function is [0, PI]. 
+	/// Results are undefined if |x| > 1.
+	///
+	/// @tparam genType Floating-point scalar or vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/acos.xml">GLSL acos man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> acos(vecType<T, P> const & x);
+
+	/// Arc tangent. Returns an angle whose tangent is y/x. 
+	/// The signs of x and y are used to determine what 
+	/// quadrant the angle is in. The range of values returned 
+	/// by this function is [-PI, PI]. Results are undefined 
+	/// if x and y are both 0. 
+	///
+	/// @tparam genType Floating-point scalar or vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/atan.xml">GLSL atan man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> atan(vecType<T, P> const & y, vecType<T, P> const & x);
+
+	/// Arc tangent. Returns an angle whose tangent is y_over_x. 
+	/// The range of values returned by this function is [-PI/2, PI/2].
+	///
+	/// @tparam genType Floating-point scalar or vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/atan.xml">GLSL atan man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> atan(vecType<T, P> const & y_over_x);
+
+	/// Returns the hyperbolic sine function, (exp(x) - exp(-x)) / 2
+	///
+	/// @tparam genType Floating-point scalar or vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/sinh.xml">GLSL sinh man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> sinh(vecType<T, P> const & angle);
+
+	/// Returns the hyperbolic cosine function, (exp(x) + exp(-x)) / 2
+	///
+	/// @tparam genType Floating-point scalar or vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/cosh.xml">GLSL cosh man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> cosh(vecType<T, P> const & angle);
+
+	/// Returns the hyperbolic tangent function, sinh(angle) / cosh(angle)
+	///
+	/// @tparam genType Floating-point scalar or vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/tanh.xml">GLSL tanh man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> tanh(vecType<T, P> const & angle);
+
+	/// Arc hyperbolic sine; returns the inverse of sinh.
+	///
+	/// @tparam genType Floating-point scalar or vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/asinh.xml">GLSL asinh man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> asinh(vecType<T, P> const & x);
+	
+	/// Arc hyperbolic cosine; returns the non-negative inverse
+	/// of cosh. Results are undefined if x < 1.
+	///
+	/// @tparam genType Floating-point scalar or vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/acosh.xml">GLSL acosh man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> acosh(vecType<T, P> const & x);
+
+	/// Arc hyperbolic tangent; returns the inverse of tanh.
+	/// Results are undefined if abs(x) >= 1.
+	///
+	/// @tparam genType Floating-point scalar or vector types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/atanh.xml">GLSL atanh man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> atanh(vecType<T, P> const & x);
+
+	/// @}
+}//namespace glm
+
+#include "func_trigonometric.inl"

glm/glm/detail/func_trigonometric.inl

@@ -0,0 +1,224 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// 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.
+///
+/// @ref core
+/// @file glm/detail/func_trigonometric.inl
+/// @date 2008-08-03 / 2011-06-15
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#include "_vectorize.hpp"
+#include <cmath>
+#include <limits>
+
+namespace glm
+{
+	// radians
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType radians(genType degrees)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'radians' only accept floating-point input");
+
+		return degrees * static_cast<genType>(0.01745329251994329576923690768489);
+	}
+
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> radians(vecType<T, P> const & v)
+	{
+		return detail::functor1<T, T, P, vecType>::call(radians, v);
+	}
+	
+	// degrees
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType degrees(genType radians)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'degrees' only accept floating-point input");
+
+		return radians * static_cast<genType>(57.295779513082320876798154814105);
+	}
+
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> degrees(vecType<T, P> const & v)
+	{
+		return detail::functor1<T, T, P, vecType>::call(degrees, v);
+	}
+
+	// sin
+	using ::std::sin;
+
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> sin(vecType<T, P> const & v)
+	{
+		return detail::functor1<T, T, P, vecType>::call(sin, v);
+	}
+
+	// cos
+	using std::cos;
+
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> cos(vecType<T, P> const & v)
+	{
+		return detail::functor1<T, T, P, vecType>::call(cos, v);
+	}
+
+	// tan
+	using std::tan;
+
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> tan(vecType<T, P> const & v)
+	{
+		return detail::functor1<T, T, P, vecType>::call(tan, v);
+	}
+
+	// asin
+	using std::asin;
+
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> asin(vecType<T, P> const & v)
+	{
+		return detail::functor1<T, T, P, vecType>::call(asin, v);
+	}
+
+	// acos
+	using std::acos;
+
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> acos(vecType<T, P> const & v)
+	{
+		return detail::functor1<T, T, P, vecType>::call(acos, v);
+	}
+
+	// atan
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType atan(genType const & y, genType const & x)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'atan' only accept floating-point input");
+
+		return ::std::atan2(y, x);
+	}
+
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> atan(vecType<T, P> const & a, vecType<T, P> const & b)
+	{
+		return detail::functor2<T, P, vecType>::call(atan2, a, b);
+	}
+
+	using std::atan;
+
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> atan(vecType<T, P> const & v)
+	{
+		return detail::functor1<T, T, P, vecType>::call(atan, v);
+	}
+
+	// sinh
+	using std::sinh;
+
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> sinh(vecType<T, P> const & v)
+	{
+		return detail::functor1<T, T, P, vecType>::call(sinh, v);
+	}
+
+	// cosh
+	using std::cosh;
+
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> cosh(vecType<T, P> const & v)
+	{
+		return detail::functor1<T, T, P, vecType>::call(cosh, v);
+	}
+
+	// tanh
+	using std::tanh;
+
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> tanh(vecType<T, P> const & v)
+	{
+		return detail::functor1<T, T, P, vecType>::call(tanh, v);
+	}
+
+	// asinh
+#	if GLM_HAS_CXX11_STL
+		using std::asinh;
+#	else
+		template <typename genType> 
+		GLM_FUNC_QUALIFIER genType asinh(genType const & x)
+		{
+			GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'asinh' only accept floating-point input");
+
+			return (x < static_cast<genType>(0) ? static_cast<genType>(-1) : (x > static_cast<genType>(0) ? static_cast<genType>(1) : static_cast<genType>(0))) * log(abs(x) + sqrt(static_cast<genType>(1) + x * x));
+		}
+#	endif
+
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> asinh(vecType<T, P> const & v)
+	{
+		return detail::functor1<T, T, P, vecType>::call(asinh, v);
+	}
+
+	// acosh
+#	if GLM_HAS_CXX11_STL
+		using std::acosh;
+#	else
+		template <typename genType> 
+		GLM_FUNC_QUALIFIER genType acosh(genType const & x)
+		{
+			GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'acosh' only accept floating-point input");
+
+			if(x < static_cast<genType>(1))
+				return static_cast<genType>(0);
+			return log(x + sqrt(x * x - static_cast<genType>(1)));
+		}
+#	endif
+
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> acosh(vecType<T, P> const & v)
+	{
+		return detail::functor1<T, T, P, vecType>::call(acosh, v);
+	}
+
+	// atanh
+#	if GLM_HAS_CXX11_STL
+		using std::atanh;
+#	else
+		template <typename genType>
+		GLM_FUNC_QUALIFIER genType atanh(genType const & x)
+		{
+			GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'atanh' only accept floating-point input");
+		
+			if(abs(x) >= static_cast<genType>(1))
+				return 0;
+			return static_cast<genType>(0.5) * log((static_cast<genType>(1) + x) / (static_cast<genType>(1) - x));
+		}
+#	endif
+
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> atanh(vecType<T, P> const & v)
+	{
+		return detail::functor1<T, T, P, vecType>::call(atanh, v);
+	}
+}//namespace glm

glm/glm/detail/func_vector_relational.hpp

@@ -0,0 +1,140 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// 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.
+///
+/// @ref core
+/// @file glm/detail/func_vector_relational.hpp
+/// @date 2008-08-03 / 2011-06-15
+/// @author Christophe Riccio
+///
+/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a>
+/// 
+/// @defgroup core_func_vector_relational Vector Relational Functions
+/// @ingroup core
+/// 
+/// Relational and equality operators (<, <=, >, >=, ==, !=) are defined to 
+/// operate on scalars and produce scalar Boolean results. For vector results, 
+/// use the following built-in functions. 
+/// 
+/// In all cases, the sizes of all the input and return vectors for any particular 
+/// call must match.
+///////////////////////////////////////////////////////////////////////////////////
+
+#pragma once
+
+#include "precision.hpp"
+#include "setup.hpp"
+
+namespace glm
+{
+	/// @addtogroup core_func_vector_relational
+	/// @{
+
+	/// Returns the component-wise comparison result of x < y.
+	/// 
+	/// @tparam vecType Floating-point or integer vector types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/lessThan.xml">GLSL lessThan man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a>
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<bool, P> lessThan(vecType<T, P> const & x, vecType<T, P> const & y);
+
+	/// Returns the component-wise comparison of result x <= y.
+	///
+	/// @tparam vecType Floating-point or integer vector types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/lessThanEqual.xml">GLSL lessThanEqual man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a>
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<bool, P> lessThanEqual(vecType<T, P> const & x, vecType<T, P> const & y);
+
+	/// Returns the component-wise comparison of result x > y.
+	///
+	/// @tparam vecType Floating-point or integer vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/greaterThan.xml">GLSL greaterThan man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a>
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<bool, P> greaterThan(vecType<T, P> const & x, vecType<T, P> const & y);
+
+	/// Returns the component-wise comparison of result x >= y.
+	///
+	/// @tparam vecType Floating-point or integer vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/greaterThanEqual.xml">GLSL greaterThanEqual man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a>
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<bool, P> greaterThanEqual(vecType<T, P> const & x, vecType<T, P> const & y);
+
+	/// Returns the component-wise comparison of result x == y.
+	///
+	/// @tparam vecType Floating-point, integer or boolean vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/equal.xml">GLSL equal man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a>
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<bool, P> equal(vecType<T, P> const & x, vecType<T, P> const & y);
+
+	/// Returns the component-wise comparison of result x != y.
+	/// 
+	/// @tparam vecType Floating-point, integer or boolean vector types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/notEqual.xml">GLSL notEqual man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a>
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<bool, P> notEqual(vecType<T, P> const & x, vecType<T, P> const & y);
+
+	/// Returns true if any component of x is true.
+	///
+	/// @tparam vecType Boolean vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/any.xml">GLSL any man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a>
+	template <precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL bool any(vecType<bool, P> const & v);
+
+	/// Returns true if all components of x are true.
+	///
+	/// @tparam vecType Boolean vector types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/all.xml">GLSL all man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a>
+	template <precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL bool all(vecType<bool, P> const & v);
+
+	/// Returns the component-wise logical complement of x.
+	/// /!\ Because of language incompatibilities between C++ and GLSL, GLM defines the function not but not_ instead.
+	///
+	/// @tparam vecType Boolean vector types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/not.xml">GLSL not man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a>
+	template <precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<bool, P> not_(vecType<bool, P> const & v);
+
+	/// @}
+}//namespace glm
+
+#include "func_vector_relational.inl"

glm/glm/detail/func_vector_relational.inl

@@ -0,0 +1,131 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// 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.
+///
+/// @ref core
+/// @file glm/detail/func_vector_relational.inl
+/// @date 2008-08-03 / 2011-09-09
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#include <limits>
+
+namespace glm
+{
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<bool, P> lessThan(vecType<T, P> const & x, vecType<T, P> const & y)
+	{
+		assert(detail::component_count(x) == detail::component_count(y));
+
+		vecType<bool, P> Result(uninitialize);
+		for(detail::component_count_t i = 0; i < detail::component_count(x); ++i)
+			Result[i] = x[i] < y[i];
+
+		return Result;
+	}
+
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<bool, P> lessThanEqual(vecType<T, P> const & x, vecType<T, P> const & y)
+	{
+		assert(detail::component_count(x) == detail::component_count(y));
+
+		vecType<bool, P> Result(uninitialize);
+		for(detail::component_count_t i = 0; i < detail::component_count(x); ++i)
+			Result[i] = x[i] <= y[i];
+		return Result;
+	}
+
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<bool, P> greaterThan(vecType<T, P> const & x, vecType<T, P> const & y)
+	{
+		assert(detail::component_count(x) == detail::component_count(y));
+
+		vecType<bool, P> Result(uninitialize);
+		for(detail::component_count_t i = 0; i < detail::component_count(x); ++i)
+			Result[i] = x[i] > y[i];
+		return Result;
+	}
+
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<bool, P> greaterThanEqual(vecType<T, P> const & x, vecType<T, P> const & y)
+	{
+		assert(detail::component_count(x) == detail::component_count(y));
+
+		vecType<bool, P> Result(uninitialize);
+		for(detail::component_count_t i = 0; i < detail::component_count(x); ++i)
+			Result[i] = x[i] >= y[i];
+		return Result;
+	}
+
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<bool, P> equal(vecType<T, P> const & x, vecType<T, P> const & y)
+	{
+		assert(detail::component_count(x) == detail::component_count(y));
+
+		vecType<bool, P> Result(uninitialize);
+		for(detail::component_count_t i = 0; i < detail::component_count(x); ++i)
+			Result[i] = x[i] == y[i];
+		return Result;
+	}
+
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<bool, P> notEqual(vecType<T, P> const & x, vecType<T, P> const & y)
+	{
+		assert(detail::component_count(x) == detail::component_count(y));
+
+		vecType<bool, P> Result(uninitialize);
+		for(detail::component_count_t i = 0; i < detail::component_count(x); ++i)
+			Result[i] = x[i] != y[i];
+		return Result;
+	}
+
+	template <precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER bool any(vecType<bool, P> const & v)
+	{
+		bool Result = false;
+		for(detail::component_count_t i = 0; i < detail::component_count(v); ++i)
+			Result = Result || v[i];
+		return Result;
+	}
+
+	template <precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER bool all(vecType<bool, P> const & v)
+	{
+		bool Result = true;
+		for(detail::component_count_t i = 0; i < detail::component_count(v); ++i)
+			Result = Result && v[i];
+		return Result;
+	}
+
+	template <precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<bool, P> not_(vecType<bool, P> const & v)
+	{
+		vecType<bool, P> Result(uninitialize);
+		for(detail::component_count_t i = 0; i < detail::component_count(v); ++i)
+			Result[i] = !v[i];
+		return Result;
+	}
+}//namespace glm
+

glm/glm/detail/glm.cpp

@@ -0,0 +1,286 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// 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.
+///
+/// @ref core
+/// @file glm/glm.cpp
+/// @date 2013-04-22 / 2013-04-22
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#include <glm/glm.hpp>
+#include <glm/gtc/quaternion.hpp>
+#include <glm/gtx/dual_quaternion.hpp>
+
+namespace glm
+{
+// tvec1 type explicit instantiation
+template struct tvec1<uint8, lowp>;
+template struct tvec1<uint16, lowp>;
+template struct tvec1<uint32, lowp>;
+template struct tvec1<uint64, lowp>;
+template struct tvec1<int8, lowp>;
+template struct tvec1<int16, lowp>;
+template struct tvec1<int32, lowp>;
+template struct tvec1<int64, lowp>;
+template struct tvec1<float32, lowp>;
+template struct tvec1<float64, lowp>;
+
+template struct tvec1<uint8, mediump>;
+template struct tvec1<uint16, mediump>;
+template struct tvec1<uint32, mediump>;
+template struct tvec1<uint64, mediump>;
+template struct tvec1<int8, mediump>;
+template struct tvec1<int16, mediump>;
+template struct tvec1<int32, mediump>;
+template struct tvec1<int64, mediump>;
+template struct tvec1<float32, mediump>;
+template struct tvec1<float64, mediump>;
+
+template struct tvec1<uint8, highp>;
+template struct tvec1<uint16, highp>;
+template struct tvec1<uint32, highp>;
+template struct tvec1<uint64, highp>;
+template struct tvec1<int8, highp>;
+template struct tvec1<int16, highp>;
+template struct tvec1<int32, highp>;
+template struct tvec1<int64, highp>;
+template struct tvec1<float32, highp>;
+template struct tvec1<float64, highp>;
+
+// tvec2 type explicit instantiation
+template struct tvec2<uint8, lowp>;
+template struct tvec2<uint16, lowp>;
+template struct tvec2<uint32, lowp>;
+template struct tvec2<uint64, lowp>;
+template struct tvec2<int8, lowp>;
+template struct tvec2<int16, lowp>;
+template struct tvec2<int32, lowp>;
+template struct tvec2<int64, lowp>;
+template struct tvec2<float32, lowp>;
+template struct tvec2<float64, lowp>;
+
+template struct tvec2<uint8, mediump>;
+template struct tvec2<uint16, mediump>;
+template struct tvec2<uint32, mediump>;
+template struct tvec2<uint64, mediump>;
+template struct tvec2<int8, mediump>;
+template struct tvec2<int16, mediump>;
+template struct tvec2<int32, mediump>;
+template struct tvec2<int64, mediump>;
+template struct tvec2<float32, mediump>;
+template struct tvec2<float64, mediump>;
+
+template struct tvec2<uint8, highp>;
+template struct tvec2<uint16, highp>;
+template struct tvec2<uint32, highp>;
+template struct tvec2<uint64, highp>;
+template struct tvec2<int8, highp>;
+template struct tvec2<int16, highp>;
+template struct tvec2<int32, highp>;
+template struct tvec2<int64, highp>;
+template struct tvec2<float32, highp>;
+template struct tvec2<float64, highp>;
+
+// tvec3 type explicit instantiation
+template struct tvec3<uint8, lowp>;
+template struct tvec3<uint16, lowp>;
+template struct tvec3<uint32, lowp>;
+template struct tvec3<uint64, lowp>;
+template struct tvec3<int8, lowp>;
+template struct tvec3<int16, lowp>;
+template struct tvec3<int32, lowp>;
+template struct tvec3<int64, lowp>;
+template struct tvec3<float32, lowp>;
+template struct tvec3<float64, lowp>;
+
+template struct tvec3<uint8, mediump>;
+template struct tvec3<uint16, mediump>;
+template struct tvec3<uint32, mediump>;
+template struct tvec3<uint64, mediump>;
+template struct tvec3<int8, mediump>;
+template struct tvec3<int16, mediump>;
+template struct tvec3<int32, mediump>;
+template struct tvec3<int64, mediump>;
+template struct tvec3<float32, mediump>;
+template struct tvec3<float64, mediump>;
+
+template struct tvec3<uint8, highp>;
+template struct tvec3<uint16, highp>;
+template struct tvec3<uint32, highp>;
+template struct tvec3<uint64, highp>;
+template struct tvec3<int8, highp>;
+template struct tvec3<int16, highp>;
+template struct tvec3<int32, highp>;
+template struct tvec3<int64, highp>;
+template struct tvec3<float32, highp>;
+template struct tvec3<float64, highp>;
+
+// tvec4 type explicit instantiation
+template struct tvec4<uint8, lowp>;
+template struct tvec4<uint16, lowp>;
+template struct tvec4<uint32, lowp>;
+template struct tvec4<uint64, lowp>;
+template struct tvec4<int8, lowp>;
+template struct tvec4<int16, lowp>;
+template struct tvec4<int32, lowp>;
+template struct tvec4<int64, lowp>;
+template struct tvec4<float32, lowp>;
+template struct tvec4<float64, lowp>;
+
+template struct tvec4<uint8, mediump>;
+template struct tvec4<uint16, mediump>;
+template struct tvec4<uint32, mediump>;
+template struct tvec4<uint64, mediump>;
+template struct tvec4<int8, mediump>;
+template struct tvec4<int16, mediump>;
+template struct tvec4<int32, mediump>;
+template struct tvec4<int64, mediump>;
+template struct tvec4<float32, mediump>;
+template struct tvec4<float64, mediump>;
+
+template struct tvec4<uint8, highp>;
+template struct tvec4<uint16, highp>;
+template struct tvec4<uint32, highp>;
+template struct tvec4<uint64, highp>;
+template struct tvec4<int8, highp>;
+template struct tvec4<int16, highp>;
+template struct tvec4<int32, highp>;
+template struct tvec4<int64, highp>;
+template struct tvec4<float32, highp>;
+template struct tvec4<float64, highp>;
+
+// tmat2x2 type explicit instantiation
+template struct tmat2x2<float32, lowp>;
+template struct tmat2x2<float64, lowp>;
+
+template struct tmat2x2<float32, mediump>;
+template struct tmat2x2<float64, mediump>;
+
+template struct tmat2x2<float32, highp>;
+template struct tmat2x2<float64, highp>;
+
+// tmat2x3 type explicit instantiation
+template struct tmat2x3<float32, lowp>;
+template struct tmat2x3<float64, lowp>;
+
+template struct tmat2x3<float32, mediump>;
+template struct tmat2x3<float64, mediump>;
+
+template struct tmat2x3<float32, highp>;
+template struct tmat2x3<float64, highp>;
+
+// tmat2x4 type explicit instantiation
+template struct tmat2x4<float32, lowp>;
+template struct tmat2x4<float64, lowp>;
+
+template struct tmat2x4<float32, mediump>;
+template struct tmat2x4<float64, mediump>;
+
+template struct tmat2x4<float32, highp>;
+template struct tmat2x4<float64, highp>;
+
+// tmat3x2 type explicit instantiation
+template struct tmat3x2<float32, lowp>;
+template struct tmat3x2<float64, lowp>;
+
+template struct tmat3x2<float32, mediump>;
+template struct tmat3x2<float64, mediump>;
+
+template struct tmat3x2<float32, highp>;
+template struct tmat3x2<float64, highp>;
+
+// tmat3x3 type explicit instantiation
+template struct tmat3x3<float32, lowp>;
+template struct tmat3x3<float64, lowp>;
+
+template struct tmat3x3<float32, mediump>;
+template struct tmat3x3<float64, mediump>;
+
+template struct tmat3x3<float32, highp>;
+template struct tmat3x3<float64, highp>;
+
+// tmat3x4 type explicit instantiation
+template struct tmat3x4<float32, lowp>;
+template struct tmat3x4<float64, lowp>;
+
+template struct tmat3x4<float32, mediump>;
+template struct tmat3x4<float64, mediump>;
+
+template struct tmat3x4<float32, highp>;
+template struct tmat3x4<float64, highp>;
+
+// tmat4x2 type explicit instantiation
+template struct tmat4x2<float32, lowp>;
+template struct tmat4x2<float64, lowp>;
+
+template struct tmat4x2<float32, mediump>;
+template struct tmat4x2<float64, mediump>;
+
+template struct tmat4x2<float32, highp>;
+template struct tmat4x2<float64, highp>;
+
+// tmat4x3 type explicit instantiation
+template struct tmat4x3<float32, lowp>;
+template struct tmat4x3<float64, lowp>;
+
+template struct tmat4x3<float32, mediump>;
+template struct tmat4x3<float64, mediump>;
+
+template struct tmat4x3<float32, highp>;
+template struct tmat4x3<float64, highp>;
+
+// tmat4x4 type explicit instantiation
+template struct tmat4x4<float32, lowp>;
+template struct tmat4x4<float64, lowp>;
+
+template struct tmat4x4<float32, mediump>;
+template struct tmat4x4<float64, mediump>;
+
+template struct tmat4x4<float32, highp>;
+template struct tmat4x4<float64, highp>;
+
+// tquat type explicit instantiation
+template struct tquat<float32, lowp>;
+template struct tquat<float64, lowp>;
+
+template struct tquat<float32, mediump>;
+template struct tquat<float64, mediump>;
+
+template struct tquat<float32, highp>;
+template struct tquat<float64, highp>;
+
+//tdualquat type explicit instantiation
+template struct tdualquat<float32, lowp>;
+template struct tdualquat<float64, lowp>;
+
+template struct tdualquat<float32, mediump>;
+template struct tdualquat<float64, mediump>;
+
+template struct tdualquat<float32, highp>;
+template struct tdualquat<float64, highp>;
+
+}//namespace glm
+

glm/glm/detail/intrinsic_common.hpp

@@ -0,0 +1,87 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// 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.
+/// 
+/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+/// THE SOFTWARE.
+///
+/// @ref core
+/// @file glm/detail/intrinsic_common.hpp
+/// @date 2009-05-11 / 2011-06-15
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#pragma once
+
+#include "setup.hpp"
+
+#if(!(GLM_ARCH & GLM_ARCH_SSE2))
+#	error "SSE2 instructions not supported or enabled"
+#else
+
+namespace glm{
+namespace detail
+{
+	__m128 sse_abs_ps(__m128 x);
+
+	__m128 sse_sgn_ps(__m128 x);
+
+	//floor
+	__m128 sse_flr_ps(__m128 v);
+
+	//trunc
+	__m128 sse_trc_ps(__m128 v);
+
+	//round
+	__m128 sse_nd_ps(__m128 v);
+
+	//roundEven
+	__m128 sse_rde_ps(__m128 v);
+
+	__m128 sse_rnd_ps(__m128 x);
+
+	__m128 sse_ceil_ps(__m128 v);
+
+	__m128 sse_frc_ps(__m128 x);
+
+	__m128 sse_mod_ps(__m128 x, __m128 y);
+
+	__m128 sse_modf_ps(__m128 x, __m128i & i);
+
+	//GLM_FUNC_QUALIFIER __m128 sse_min_ps(__m128 x, __m128 y)
+
+	//GLM_FUNC_QUALIFIER __m128 sse_max_ps(__m128 x, __m128 y)
+
+	__m128 sse_clp_ps(__m128 v, __m128 minVal, __m128 maxVal);
+
+	__m128 sse_mix_ps(__m128 v1, __m128 v2, __m128 a);
+
+	__m128 sse_stp_ps(__m128 edge, __m128 x);
+
+	__m128 sse_ssp_ps(__m128 edge0, __m128 edge1, __m128 x);
+
+	__m128 sse_nan_ps(__m128 x);
+
+	__m128 sse_inf_ps(__m128 x);
+
+}//namespace detail
+}//namespace glm
+
+#include "intrinsic_common.inl"
+
+#endif//GLM_ARCH

glm/glm/detail/intrinsic_common.inl

@@ -0,0 +1,313 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// 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.
+/// 
+/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+/// THE SOFTWARE.
+///
+/// @ref core
+/// @file glm/detail/intrinsic_common.inl
+/// @date 2009-05-08 / 2011-06-15
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+namespace glm{
+namespace detail{
+
+#if(GLM_COMPILER & GLM_COMPILER_VC)
+#pragma warning(push)
+#pragma warning(disable : 4510 4512 4610)
+#endif
+
+	union ieee754_QNAN
+	{
+		const float f;
+		struct i
+		{
+			const unsigned int mantissa:23, exp:8, sign:1;
+		};
+
+		ieee754_QNAN() : f(0.0)/*, mantissa(0x7FFFFF), exp(0xFF), sign(0x0)*/ {}
+	};
+
+#if(GLM_COMPILER & GLM_COMPILER_VC)
+#pragma warning(pop)
+#endif
+
+	static const __m128 GLM_VAR_USED zero = _mm_setzero_ps();
+	static const __m128 GLM_VAR_USED one = _mm_set_ps1(1.0f);
+	static const __m128 GLM_VAR_USED minus_one = _mm_set_ps1(-1.0f);
+	static const __m128 GLM_VAR_USED two = _mm_set_ps1(2.0f);
+	static const __m128 GLM_VAR_USED three = _mm_set_ps1(3.0f);
+	static const __m128 GLM_VAR_USED pi = _mm_set_ps1(3.1415926535897932384626433832795f);
+	static const __m128 GLM_VAR_USED hundred_eighty = _mm_set_ps1(180.f);
+	static const __m128 GLM_VAR_USED pi_over_hundred_eighty = _mm_set_ps1(0.017453292519943295769236907684886f);
+	static const __m128 GLM_VAR_USED hundred_eighty_over_pi = _mm_set_ps1(57.295779513082320876798154814105f);
+
+	static const ieee754_QNAN absMask;
+	static const __m128 GLM_VAR_USED abs4Mask = _mm_set_ps1(absMask.f);
+
+	static const __m128 GLM_VAR_USED _epi32_sign_mask = _mm_castsi128_ps(_mm_set1_epi32(static_cast<int>(0x80000000)));
+	//static const __m128 GLM_VAR_USED _epi32_inv_sign_mask = _mm_castsi128_ps(_mm_set1_epi32(0x7FFFFFFF));
+	//static const __m128 GLM_VAR_USED _epi32_mant_mask = _mm_castsi128_ps(_mm_set1_epi32(0x7F800000));
+	//static const __m128 GLM_VAR_USED _epi32_inv_mant_mask = _mm_castsi128_ps(_mm_set1_epi32(0x807FFFFF));
+	//static const __m128 GLM_VAR_USED _epi32_min_norm_pos = _mm_castsi128_ps(_mm_set1_epi32(0x00800000));
+	static const __m128 GLM_VAR_USED _epi32_0 = _mm_set_ps1(0);
+	static const __m128 GLM_VAR_USED _epi32_1 = _mm_set_ps1(1);
+	static const __m128 GLM_VAR_USED _epi32_2 = _mm_set_ps1(2);
+	static const __m128 GLM_VAR_USED _epi32_3 = _mm_set_ps1(3);
+	static const __m128 GLM_VAR_USED _epi32_4 = _mm_set_ps1(4);
+	static const __m128 GLM_VAR_USED _epi32_5 = _mm_set_ps1(5);
+	static const __m128 GLM_VAR_USED _epi32_6 = _mm_set_ps1(6);
+	static const __m128 GLM_VAR_USED _epi32_7 = _mm_set_ps1(7);
+	static const __m128 GLM_VAR_USED _epi32_8 = _mm_set_ps1(8);
+	static const __m128 GLM_VAR_USED _epi32_9 = _mm_set_ps1(9);
+	static const __m128 GLM_VAR_USED _epi32_127 = _mm_set_ps1(127);
+	//static const __m128 GLM_VAR_USED _epi32_ninf = _mm_castsi128_ps(_mm_set1_epi32(0xFF800000));
+	//static const __m128 GLM_VAR_USED _epi32_pinf = _mm_castsi128_ps(_mm_set1_epi32(0x7F800000));
+
+	static const __m128 GLM_VAR_USED _ps_1_3 = _mm_set_ps1(0.33333333333333333333333333333333f);
+	static const __m128 GLM_VAR_USED _ps_0p5 = _mm_set_ps1(0.5f);
+	static const __m128 GLM_VAR_USED _ps_1 = _mm_set_ps1(1.0f);
+	static const __m128 GLM_VAR_USED _ps_m1 = _mm_set_ps1(-1.0f);
+	static const __m128 GLM_VAR_USED _ps_2 = _mm_set_ps1(2.0f);
+	static const __m128 GLM_VAR_USED _ps_3 = _mm_set_ps1(3.0f);
+	static const __m128 GLM_VAR_USED _ps_127 = _mm_set_ps1(127.0f);
+	static const __m128 GLM_VAR_USED _ps_255 = _mm_set_ps1(255.0f);
+	static const __m128 GLM_VAR_USED _ps_2pow23 = _mm_set_ps1(8388608.0f);
+
+	static const __m128 GLM_VAR_USED _ps_1_0_0_0 = _mm_set_ps(1.0f, 0.0f, 0.0f, 0.0f);
+	static const __m128 GLM_VAR_USED _ps_0_1_0_0 = _mm_set_ps(0.0f, 1.0f, 0.0f, 0.0f);
+	static const __m128 GLM_VAR_USED _ps_0_0_1_0 = _mm_set_ps(0.0f, 0.0f, 1.0f, 0.0f);
+	static const __m128 GLM_VAR_USED _ps_0_0_0_1 = _mm_set_ps(0.0f, 0.0f, 0.0f, 1.0f);
+
+	static const __m128 GLM_VAR_USED _ps_pi = _mm_set_ps1(3.1415926535897932384626433832795f);
+	static const __m128 GLM_VAR_USED _ps_pi2 = _mm_set_ps1(6.283185307179586476925286766560f);
+	static const __m128 GLM_VAR_USED _ps_2_pi = _mm_set_ps1(0.63661977236758134307553505349006f);
+	static const __m128 GLM_VAR_USED _ps_pi_2 = _mm_set_ps1(1.5707963267948966192313216916398f);
+	static const __m128 GLM_VAR_USED _ps_4_pi = _mm_set_ps1(1.2732395447351626861510701069801f);
+	static const __m128 GLM_VAR_USED _ps_pi_4 = _mm_set_ps1(0.78539816339744830961566084581988f);
+
+	static const __m128 GLM_VAR_USED _ps_sincos_p0 = _mm_set_ps1(0.15707963267948963959e1f);
+	static const __m128 GLM_VAR_USED _ps_sincos_p1 = _mm_set_ps1(-0.64596409750621907082e0f);
+	static const __m128 GLM_VAR_USED _ps_sincos_p2 = _mm_set_ps1(0.7969262624561800806e-1f);
+	static const __m128 GLM_VAR_USED _ps_sincos_p3 = _mm_set_ps1(-0.468175413106023168e-2f);
+	static const __m128 GLM_VAR_USED _ps_tan_p0 = _mm_set_ps1(-1.79565251976484877988e7f);
+	static const __m128 GLM_VAR_USED _ps_tan_p1 = _mm_set_ps1(1.15351664838587416140e6f);
+	static const __m128 GLM_VAR_USED _ps_tan_p2 = _mm_set_ps1(-1.30936939181383777646e4f);
+	static const __m128 GLM_VAR_USED _ps_tan_q0 = _mm_set_ps1(-5.38695755929454629881e7f);
+	static const __m128 GLM_VAR_USED _ps_tan_q1 = _mm_set_ps1(2.50083801823357915839e7f);
+	static const __m128 GLM_VAR_USED _ps_tan_q2 = _mm_set_ps1(-1.32089234440210967447e6f);
+	static const __m128 GLM_VAR_USED _ps_tan_q3 = _mm_set_ps1(1.36812963470692954678e4f);
+	static const __m128 GLM_VAR_USED _ps_tan_poleval = _mm_set_ps1(3.68935e19f);
+	static const __m128 GLM_VAR_USED _ps_atan_t0 = _mm_set_ps1(-0.91646118527267623468e-1f);
+	static const __m128 GLM_VAR_USED _ps_atan_t1 = _mm_set_ps1(-0.13956945682312098640e1f);
+	static const __m128 GLM_VAR_USED _ps_atan_t2 = _mm_set_ps1(-0.94393926122725531747e2f);
+	static const __m128 GLM_VAR_USED _ps_atan_t3 = _mm_set_ps1(0.12888383034157279340e2f);
+	static const __m128 GLM_VAR_USED _ps_atan_s0 = _mm_set_ps1(0.12797564625607904396e1f);
+	static const __m128 GLM_VAR_USED _ps_atan_s1 = _mm_set_ps1(0.21972168858277355914e1f);
+	static const __m128 GLM_VAR_USED _ps_atan_s2 = _mm_set_ps1(0.68193064729268275701e1f);
+	static const __m128 GLM_VAR_USED _ps_atan_s3 = _mm_set_ps1(0.28205206687035841409e2f);
+
+	static const __m128 GLM_VAR_USED _ps_exp_hi = _mm_set_ps1(88.3762626647949f);
+	static const __m128 GLM_VAR_USED _ps_exp_lo = _mm_set_ps1(-88.3762626647949f);
+	static const __m128 GLM_VAR_USED _ps_exp_rln2 = _mm_set_ps1(1.4426950408889634073599f);
+	static const __m128 GLM_VAR_USED _ps_exp_p0 = _mm_set_ps1(1.26177193074810590878e-4f);
+	static const __m128 GLM_VAR_USED _ps_exp_p1 = _mm_set_ps1(3.02994407707441961300e-2f);
+	static const __m128 GLM_VAR_USED _ps_exp_q0 = _mm_set_ps1(3.00198505138664455042e-6f);
+	static const __m128 GLM_VAR_USED _ps_exp_q1 = _mm_set_ps1(2.52448340349684104192e-3f);
+	static const __m128 GLM_VAR_USED _ps_exp_q2 = _mm_set_ps1(2.27265548208155028766e-1f);
+	static const __m128 GLM_VAR_USED _ps_exp_q3 = _mm_set_ps1(2.00000000000000000009e0f);
+	static const __m128 GLM_VAR_USED _ps_exp_c1 = _mm_set_ps1(6.93145751953125e-1f);
+	static const __m128 GLM_VAR_USED _ps_exp_c2 = _mm_set_ps1(1.42860682030941723212e-6f);
+	static const __m128 GLM_VAR_USED _ps_exp2_hi = _mm_set_ps1(127.4999961853f);
+	static const __m128 GLM_VAR_USED _ps_exp2_lo = _mm_set_ps1(-127.4999961853f);
+	static const __m128 GLM_VAR_USED _ps_exp2_p0 = _mm_set_ps1(2.30933477057345225087e-2f);
+	static const __m128 GLM_VAR_USED _ps_exp2_p1 = _mm_set_ps1(2.02020656693165307700e1f);
+	static const __m128 GLM_VAR_USED _ps_exp2_p2 = _mm_set_ps1(1.51390680115615096133e3f);
+	static const __m128 GLM_VAR_USED _ps_exp2_q0 = _mm_set_ps1(2.33184211722314911771e2f);
+	static const __m128 GLM_VAR_USED _ps_exp2_q1 = _mm_set_ps1(4.36821166879210612817e3f);
+	static const __m128 GLM_VAR_USED _ps_log_p0 = _mm_set_ps1(-7.89580278884799154124e-1f);
+	static const __m128 GLM_VAR_USED _ps_log_p1 = _mm_set_ps1(1.63866645699558079767e1f);
+	static const __m128 GLM_VAR_USED _ps_log_p2 = _mm_set_ps1(-6.41409952958715622951e1f);
+	static const __m128 GLM_VAR_USED _ps_log_q0 = _mm_set_ps1(-3.56722798256324312549e1f);
+	static const __m128 GLM_VAR_USED _ps_log_q1 = _mm_set_ps1(3.12093766372244180303e2f);
+	static const __m128 GLM_VAR_USED _ps_log_q2 = _mm_set_ps1(-7.69691943550460008604e2f);
+	static const __m128 GLM_VAR_USED _ps_log_c0 = _mm_set_ps1(0.693147180559945f);
+	static const __m128 GLM_VAR_USED _ps_log2_c0 = _mm_set_ps1(1.44269504088896340735992f);
+
+GLM_FUNC_QUALIFIER __m128 sse_abs_ps(__m128 x)
+{
+	return _mm_and_ps(glm::detail::abs4Mask, x);
+} 
+
+GLM_FUNC_QUALIFIER __m128 sse_sgn_ps(__m128 x)
+{
+	__m128 Neg = _mm_set1_ps(-1.0f);
+	__m128 Pos = _mm_set1_ps(1.0f);
+
+	__m128 Cmp0 = _mm_cmplt_ps(x, zero);
+	__m128 Cmp1 = _mm_cmpgt_ps(x, zero);
+
+	__m128 And0 = _mm_and_ps(Cmp0, Neg);
+	__m128 And1 = _mm_and_ps(Cmp1, Pos);
+
+	return _mm_or_ps(And0, And1);
+}
+
+//floor
+GLM_FUNC_QUALIFIER __m128 sse_flr_ps(__m128 x)
+{
+	__m128 rnd0 = sse_rnd_ps(x);
+	__m128 cmp0 = _mm_cmplt_ps(x, rnd0);
+	__m128 and0 = _mm_and_ps(cmp0, glm::detail::_ps_1);
+	__m128 sub0 = _mm_sub_ps(rnd0, and0);
+	return sub0;
+}
+
+//trunc
+/*
+GLM_FUNC_QUALIFIER __m128 _mm_trc_ps(__m128 v)
+{
+	return __m128();
+}
+*/
+//round
+GLM_FUNC_QUALIFIER __m128 sse_rnd_ps(__m128 x)
+{
+	__m128 and0 = _mm_and_ps(glm::detail::_epi32_sign_mask, x);
+	__m128 or0 = _mm_or_ps(and0, glm::detail::_ps_2pow23);
+	__m128 add0 = _mm_add_ps(x, or0);
+	__m128 sub0 = _mm_sub_ps(add0, or0);
+	return sub0;
+}
+
+//roundEven
+GLM_FUNC_QUALIFIER __m128 sse_rde_ps(__m128 x)
+{
+	__m128 and0 = _mm_and_ps(glm::detail::_epi32_sign_mask, x);
+	__m128 or0 = _mm_or_ps(and0, glm::detail::_ps_2pow23);
+	__m128 add0 = _mm_add_ps(x, or0);
+	__m128 sub0 = _mm_sub_ps(add0, or0);
+	return sub0;
+}
+
+GLM_FUNC_QUALIFIER __m128 sse_ceil_ps(__m128 x)
+{
+	__m128 rnd0 = sse_rnd_ps(x);
+	__m128 cmp0 = _mm_cmpgt_ps(x, rnd0);
+	__m128 and0 = _mm_and_ps(cmp0, glm::detail::_ps_1);
+	__m128 add0 = _mm_add_ps(rnd0, and0);
+	return add0;
+}
+
+GLM_FUNC_QUALIFIER __m128 sse_frc_ps(__m128 x)
+{
+	__m128 flr0 = sse_flr_ps(x);
+	__m128 sub0 = _mm_sub_ps(x, flr0);
+	return sub0;
+}
+
+GLM_FUNC_QUALIFIER __m128 sse_mod_ps(__m128 x, __m128 y)
+{
+	__m128 div0 = _mm_div_ps(x, y);
+	__m128 flr0 = sse_flr_ps(div0);
+	__m128 mul0 = _mm_mul_ps(y, flr0);
+	__m128 sub0 = _mm_sub_ps(x, mul0);
+	return sub0;
+}
+
+/// TODO
+/*
+GLM_FUNC_QUALIFIER __m128 sse_modf_ps(__m128 x, __m128i & i)
+{
+	__m128 empty;
+	return empty;
+}
+*/
+
+//GLM_FUNC_QUALIFIER __m128 _mm_min_ps(__m128 x, __m128 y)
+
+//GLM_FUNC_QUALIFIER __m128 _mm_max_ps(__m128 x, __m128 y)
+
+GLM_FUNC_QUALIFIER __m128 sse_clp_ps(__m128 v, __m128 minVal, __m128 maxVal)
+{
+	__m128 min0 = _mm_min_ps(v, maxVal);
+	__m128 max0 = _mm_max_ps(min0, minVal);
+	return max0;
+}
+
+GLM_FUNC_QUALIFIER __m128 sse_mix_ps(__m128 v1, __m128 v2, __m128 a)
+{
+	__m128 sub0 = _mm_sub_ps(glm::detail::one, a);
+	__m128 mul0 = _mm_mul_ps(v1, sub0);
+	__m128 mul1 = _mm_mul_ps(v2, a);
+	__m128 add0 = _mm_add_ps(mul0, mul1);
+	return add0;
+}
+
+GLM_FUNC_QUALIFIER __m128 sse_stp_ps(__m128 edge, __m128 x)
+{
+	__m128 cmp = _mm_cmple_ps(x, edge);
+	if(_mm_movemask_ps(cmp) == 0)
+		return glm::detail::one;
+	else
+		return glm::detail::zero;
+}
+
+GLM_FUNC_QUALIFIER __m128 sse_ssp_ps(__m128 edge0, __m128 edge1, __m128 x)
+{
+	__m128 sub0 = _mm_sub_ps(x, edge0);
+	__m128 sub1 = _mm_sub_ps(edge1, edge0);
+	__m128 div0 = _mm_sub_ps(sub0, sub1);
+	__m128 clp0 = sse_clp_ps(div0, glm::detail::zero, glm::detail::one);
+	__m128 mul0 = _mm_mul_ps(glm::detail::two, clp0);
+	__m128 sub2 = _mm_sub_ps(glm::detail::three, mul0);
+	__m128 mul1 = _mm_mul_ps(clp0, clp0);
+	__m128 mul2 = _mm_mul_ps(mul1, sub2);
+	return mul2;
+}
+
+/// \todo
+//GLM_FUNC_QUALIFIER __m128 sse_nan_ps(__m128 x)
+//{
+//	__m128 empty;
+//	return empty;
+//}
+
+/// \todo
+//GLM_FUNC_QUALIFIER __m128 sse_inf_ps(__m128 x)
+//{
+//	__m128 empty;
+//	return empty;
+//}
+
+// SSE scalar reciprocal sqrt using rsqrt op, plus one Newton-Rhaphson iteration
+// By Elan Ruskin, http://assemblyrequired.crashworks.org/
+GLM_FUNC_QUALIFIER __m128 sse_sqrt_wip_ss(__m128 const & x)
+{
+	__m128 const recip = _mm_rsqrt_ss(x);  // "estimate" opcode
+	__m128 const half = _mm_set_ps1(0.5f);
+	__m128 const halfrecip = _mm_mul_ss(half, recip);
+	__m128 const threeminus_xrr = _mm_sub_ss(three, _mm_mul_ss(x, _mm_mul_ss (recip, recip)));
+	return _mm_mul_ss(halfrecip, threeminus_xrr);
+}
+
+}//namespace detail
+}//namespace glms
+

glm/glm/detail/intrinsic_exponential.hpp

@@ -0,0 +1,77 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// 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.
+/// 
+/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+/// THE SOFTWARE.
+///
+/// @ref core
+/// @file glm/detail/intrinsic_exponential.hpp
+/// @date 2009-05-11 / 2011-06-15
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#pragma once
+
+#include "setup.hpp"
+
+#if(!(GLM_ARCH & GLM_ARCH_SSE2))
+#	error "SSE2 instructions not supported or enabled"
+#else
+
+namespace glm{
+namespace detail
+{
+/*
+GLM_FUNC_QUALIFIER __m128 sse_rsqrt_nr_ss(__m128 const x)
+{
+	__m128 recip = _mm_rsqrt_ss( x );  // "estimate" opcode
+	const static __m128 three = { 3, 3, 3, 3 }; // aligned consts for fast load
+	const static __m128 half = { 0.5,0.5,0.5,0.5 };
+	__m128 halfrecip = _mm_mul_ss( half, recip );
+	__m128 threeminus_xrr = _mm_sub_ss( three, _mm_mul_ss( x, _mm_mul_ss ( recip, recip ) ) );
+	return _mm_mul_ss( halfrecip, threeminus_xrr );
+}
+ 
+GLM_FUNC_QUALIFIER __m128 sse_normalize_fast_ps(  float * RESTRICT vOut, float * RESTRICT vIn )
+{
+        __m128 x = _mm_load_ss(&vIn[0]);
+        __m128 y = _mm_load_ss(&vIn[1]);
+        __m128 z = _mm_load_ss(&vIn[2]);
+ 
+        const __m128 l =  // compute x*x + y*y + z*z
+                _mm_add_ss(
+                 _mm_add_ss( _mm_mul_ss(x,x),
+                             _mm_mul_ss(y,y)
+                            ),
+                 _mm_mul_ss( z, z )
+                );
+ 
+ 
+        const __m128 rsqt = _mm_rsqrt_nr_ss( l );
+        _mm_store_ss( &vOut[0] , _mm_mul_ss( rsqt, x ) );
+        _mm_store_ss( &vOut[1] , _mm_mul_ss( rsqt, y ) );
+        _mm_store_ss( &vOut[2] , _mm_mul_ss( rsqt, z ) );
+ 
+        return _mm_mul_ss( l , rsqt );
+}
+*/
+}//namespace detail
+}//namespace glm
+
+#endif//GLM_ARCH

glm/glm/detail/intrinsic_exponential.inl

@@ -0,0 +1,27 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// 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.
+/// 
+/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+/// THE SOFTWARE.
+///
+/// @ref core
+/// @file glm/detail/intrinsic_exponential.inl
+/// @date 2011-06-15 / 2011-06-15
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////

glm/glm/detail/intrinsic_geometric.hpp

@@ -0,0 +1,74 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// 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.
+/// 
+/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+/// THE SOFTWARE.
+///
+/// @ref core
+/// @file glm/detail/intrinsic_geometric.hpp
+/// @date 2009-05-08 / 2011-06-15
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#pragma once
+
+#include "setup.hpp"
+
+#if(!(GLM_ARCH & GLM_ARCH_SSE2))
+#	error "SSE2 instructions not supported or enabled"
+#else
+
+#include "intrinsic_common.hpp"
+
+namespace glm{
+namespace detail
+{
+	//length
+	__m128 sse_len_ps(__m128 x);
+
+	//distance
+	__m128 sse_dst_ps(__m128 p0, __m128 p1);
+
+	//dot
+	__m128 sse_dot_ps(__m128 v1, __m128 v2);
+
+	// SSE1
+	__m128 sse_dot_ss(__m128 v1, __m128 v2);
+
+	//cross
+	__m128 sse_xpd_ps(__m128 v1, __m128 v2);
+
+	//normalize
+	__m128 sse_nrm_ps(__m128 v);
+
+	//faceforward
+	__m128 sse_ffd_ps(__m128 N, __m128 I, __m128 Nref);
+
+	//reflect
+	__m128 sse_rfe_ps(__m128 I, __m128 N);
+
+	//refract
+	__m128 sse_rfa_ps(__m128 I, __m128 N, __m128 eta);
+
+}//namespace detail
+}//namespace glm
+
+#include "intrinsic_geometric.inl"
+
+#endif//GLM_ARCH

glm/glm/detail/intrinsic_geometric.inl

@@ -0,0 +1,147 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// 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.
+/// 
+/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+/// THE SOFTWARE.
+///
+/// @ref core
+/// @file glm/detail/intrinsic_geometric.inl
+/// @date 2009-05-08 / 2011-06-15
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+namespace glm{
+namespace detail{
+
+//length
+GLM_FUNC_QUALIFIER __m128 sse_len_ps(__m128 x)
+{
+	__m128 dot0 = sse_dot_ps(x, x);
+	__m128 sqt0 = _mm_sqrt_ps(dot0);
+	return sqt0;
+}
+
+//distance
+GLM_FUNC_QUALIFIER __m128 sse_dst_ps(__m128 p0, __m128 p1)
+{
+	__m128 sub0 = _mm_sub_ps(p0, p1);
+	__m128 len0 = sse_len_ps(sub0);
+	return len0;
+}
+
+//dot
+GLM_FUNC_QUALIFIER __m128 sse_dot_ps(__m128 v1, __m128 v2)
+{
+
+#	if(GLM_ARCH & GLM_ARCH_AVX)
+		return _mm_dp_ps(v1, v2, 0xff);
+#	else
+		__m128 mul0 = _mm_mul_ps(v1, v2);
+		__m128 swp0 = _mm_shuffle_ps(mul0, mul0, _MM_SHUFFLE(2, 3, 0, 1));
+		__m128 add0 = _mm_add_ps(mul0, swp0);
+		__m128 swp1 = _mm_shuffle_ps(add0, add0, _MM_SHUFFLE(0, 1, 2, 3));
+		__m128 add1 = _mm_add_ps(add0, swp1);
+		return add1;
+#	endif
+}
+
+// SSE1
+GLM_FUNC_QUALIFIER __m128 sse_dot_ss(__m128 v1, __m128 v2)
+{
+	__m128 mul0 = _mm_mul_ps(v1, v2);
+	__m128 mov0 = _mm_movehl_ps(mul0, mul0);
+	__m128 add0 = _mm_add_ps(mov0, mul0);
+	__m128 swp1 = _mm_shuffle_ps(add0, add0, 1);
+	__m128 add1 = _mm_add_ss(add0, swp1);
+	return add1;
+}
+
+//cross
+GLM_FUNC_QUALIFIER __m128 sse_xpd_ps(__m128 v1, __m128 v2)
+{
+	__m128 swp0 = _mm_shuffle_ps(v1, v1, _MM_SHUFFLE(3, 0, 2, 1));
+	__m128 swp1 = _mm_shuffle_ps(v1, v1, _MM_SHUFFLE(3, 1, 0, 2));
+	__m128 swp2 = _mm_shuffle_ps(v2, v2, _MM_SHUFFLE(3, 0, 2, 1));
+	__m128 swp3 = _mm_shuffle_ps(v2, v2, _MM_SHUFFLE(3, 1, 0, 2));
+	__m128 mul0 = _mm_mul_ps(swp0, swp3);
+	__m128 mul1 = _mm_mul_ps(swp1, swp2);
+	__m128 sub0 = _mm_sub_ps(mul0, mul1);
+	return sub0;
+}
+
+//normalize
+GLM_FUNC_QUALIFIER __m128 sse_nrm_ps(__m128 v)
+{
+	__m128 dot0 = sse_dot_ps(v, v);
+	__m128 isr0 = _mm_rsqrt_ps(dot0);
+	__m128 mul0 = _mm_mul_ps(v, isr0);
+	return mul0;
+}
+
+//faceforward
+GLM_FUNC_QUALIFIER __m128 sse_ffd_ps(__m128 N, __m128 I, __m128 Nref)
+{
+	//__m128 dot0 = _mm_dot_ps(v, v);
+	//__m128 neg0 = _mm_neg_ps(N);
+	//__m128 sgn0 = _mm_sgn_ps(dot0);
+	//__m128 mix0 = _mm_mix_ps(N, neg0, sgn0);
+	//return mix0;
+
+	__m128 dot0 = sse_dot_ps(Nref, I);
+	__m128 sgn0 = sse_sgn_ps(dot0);
+	__m128 mul0 = _mm_mul_ps(sgn0, glm::detail::minus_one);
+	__m128 mul1 = _mm_mul_ps(N, mul0);
+	return mul1;
+}
+
+//reflect
+GLM_FUNC_QUALIFIER __m128 sse_rfe_ps(__m128 I, __m128 N)
+{
+	__m128 dot0 = sse_dot_ps(N, I);
+	__m128 mul0 = _mm_mul_ps(N, dot0);
+	__m128 mul1 = _mm_mul_ps(mul0, glm::detail::two);
+	__m128 sub0 = _mm_sub_ps(I, mul1);
+	return sub0;
+}
+
+//refract
+GLM_FUNC_QUALIFIER __m128 sse_rfa_ps(__m128 I, __m128 N, __m128 eta)
+{
+	__m128 dot0 = sse_dot_ps(N, I);
+	__m128 mul0 = _mm_mul_ps(eta, eta);
+	__m128 mul1 = _mm_mul_ps(dot0, dot0);
+	__m128 sub0 = _mm_sub_ps(glm::detail::one, mul0);
+	__m128 sub1 = _mm_sub_ps(glm::detail::one, mul1);
+	__m128 mul2 = _mm_mul_ps(sub0, sub1);
+	
+	if(_mm_movemask_ps(_mm_cmplt_ss(mul2, glm::detail::zero)) == 0)
+		return glm::detail::zero;
+
+	__m128 sqt0 = _mm_sqrt_ps(mul2);
+	__m128 mul3 = _mm_mul_ps(eta, dot0);
+	__m128 add0 = _mm_add_ps(mul3, sqt0);
+	__m128 mul4 = _mm_mul_ps(add0, N);
+	__m128 mul5 = _mm_mul_ps(eta, I);
+	__m128 sub2 = _mm_sub_ps(mul5, mul4);
+
+	return sub2;
+}
+
+}//namespace detail
+}//namespace glm

glm/glm/detail/intrinsic_integer.hpp

@@ -0,0 +1,48 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// 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.
+/// 
+/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+/// THE SOFTWARE.
+///
+/// @ref core
+/// @file glm/detail/intrinsic_integer.hpp
+/// @date 2009-05-11 / 2011-06-15
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#pragma once
+
+#include "glm/glm.hpp"
+
+#if(!(GLM_ARCH & GLM_ARCH_SSE2))
+#	error "SSE2 instructions not supported or enabled"
+#else
+
+namespace glm{
+namespace detail
+{
+	__m128i _mm_bit_interleave_si128(__m128i x);
+	__m128i _mm_bit_interleave_si128(__m128i x, __m128i y);
+
+}//namespace detail
+}//namespace glm
+
+#include "intrinsic_integer.inl"
+
+#endif//GLM_ARCH

glm/glm/detail/intrinsic_integer.inl

@@ -0,0 +1,139 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// 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.
+/// 
+/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+/// THE SOFTWARE.
+///
+/// @ref core
+/// @file glm/detail/intrinsic_integer.inl
+/// @date 2009-05-08 / 2011-06-15
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+namespace glm{
+namespace detail
+{
+	inline __m128i _mm_bit_interleave_si128(__m128i 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_unpacklo_epi64(x, y);
+		Reg1 = x;
+
+		//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);
+	
+		return Reg1;
+	}
+
+	inline __m128i _mm_bit_interleave_si128(__m128i x, __m128i y)
+	{
+		__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_unpacklo_epi64(x, y);
+
+		//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);
+	
+		return Reg1;
+	}
+}//namespace detail
+}//namespace glms

glm/glm/detail/intrinsic_matrix.hpp

@@ -0,0 +1,67 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// 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.
+/// 
+/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+/// THE SOFTWARE.
+///
+/// @ref core
+/// @file glm/detail/intrinsic_common.hpp
+/// @date 2009-06-05 / 2011-06-15
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#pragma once
+
+#include "setup.hpp"
+
+#if(!(GLM_ARCH & GLM_ARCH_SSE2))
+#	error "SSE2 instructions not supported or enabled"
+#else
+
+#include "intrinsic_geometric.hpp"
+
+namespace glm{
+namespace detail
+{
+	void sse_add_ps(__m128 in1[4], __m128 in2[4], __m128 out[4]);
+
+	void sse_sub_ps(__m128 in1[4], __m128 in2[4], __m128 out[4]);
+
+	__m128 sse_mul_ps(__m128 m[4], __m128 v);
+
+	__m128 sse_mul_ps(__m128 v, __m128 m[4]);
+
+	void sse_mul_ps(__m128 const in1[4], __m128 const in2[4], __m128 out[4]);
+
+	void sse_transpose_ps(__m128 const in[4], __m128 out[4]);
+
+	void sse_inverse_ps(__m128 const in[4], __m128 out[4]);
+
+	void sse_rotate_ps(__m128 const in[4], float Angle, float const v[3], __m128 out[4]);
+
+	__m128 sse_det_ps(__m128 const m[4]);
+
+	__m128 sse_slow_det_ps(__m128 const m[4]);
+
+}//namespace detail
+}//namespace glm
+
+#include "intrinsic_matrix.inl"
+
+#endif//GLM_ARCH

glm/glm/detail/intrinsic_trigonometric.hpp

@@ -0,0 +1,46 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// 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.
+/// 
+/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+/// THE SOFTWARE.
+///
+/// @ref core
+/// @file glm/detail/intrinsic_trigonometric.hpp
+/// @date 2009-06-09 / 2011-06-15
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#pragma once
+
+#include "setup.hpp"
+
+#if(!(GLM_ARCH & GLM_ARCH_SSE2))
+#	error "SSE2 instructions not supported or enabled"
+#else
+
+namespace glm{
+namespace detail
+{
+
+}//namespace detail
+}//namespace glm
+
+#include "intrinsic_trigonometric.inl"
+
+#endif//GLM_ARCH

glm/glm/detail/intrinsic_trigonometric.inl

@@ -0,0 +1,27 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// 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.
+/// 
+/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+/// THE SOFTWARE.
+///
+/// @ref core
+/// @file glm/detail/intrinsic_trigonometric.inl
+/// @date 2011-06-15 / 2011-06-15
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////

glm/glm/detail/intrinsic_vector_relational.hpp

@@ -0,0 +1,46 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// 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.
+/// 
+/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+/// THE SOFTWARE.
+///
+/// @ref core
+/// @file glm/detail/intrinsic_vector_relational.hpp
+/// @date 2009-06-09 / 2011-06-15
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#pragma once
+
+#include "setup.hpp"
+
+#if(!(GLM_ARCH & GLM_ARCH_SSE2))
+#	error "SSE2 instructions not supported or enabled"
+#else
+
+namespace glm{
+namespace detail
+{
+
+}//namespace detail
+}//namespace glm
+
+#include "intrinsic_vector_relational.inl"
+
+#endif//GLM_ARCH

glm/glm/detail/intrinsic_vector_relational.inl

@@ -0,0 +1,366 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// 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.
+/// 
+/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+/// THE SOFTWARE.
+///
+/// @ref core
+/// @file glm/detail/intrinsic_vector_relational.inl
+/// @date 2009-06-09 / 2011-06-15
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+//
+//// lessThan
+//template <typename valType>
+//GLM_FUNC_QUALIFIER typename tvec2<T, P>::bool_type lessThan
+//(
+//	tvec2<T, P> const & x, 
+//	tvec2<T, P> const & y
+//)
+//{
+//	GLM_STATIC_ASSERT(
+//		detail::type<valType>::is_float || 
+//		detail::type<valType>::is_int || 
+//		detail::type<valType>::is_uint);
+//
+//    return typename tvec2<bool>::bool_type(x.x < y.x, x.y < y.y);
+//}
+//
+//template <typename valType>
+//GLM_FUNC_QUALIFIER typename tvec3<T, P>::bool_type lessThan
+//(
+//	tvec3<T, P> const & x, 
+//	tvec3<T, P> const & y
+//)
+//{
+//	GLM_STATIC_ASSERT(
+//		detail::type<valType>::is_float || 
+//		detail::type<valType>::is_int || 
+//		detail::type<valType>::is_uint);
+//	
+//	return typename tvec3<bool>::bool_type(x.x < y.x, x.y < y.y, x.z < y.z);
+//}
+//
+//template <typename valType>
+//GLM_FUNC_QUALIFIER typename tvec4<T, P>::bool_type lessThan
+//(
+//	tvec4<T, P> const & x, 
+//	tvec4<T, P> const & y
+//)
+//{
+//	GLM_STATIC_ASSERT(
+//		detail::type<valType>::is_float || 
+//		detail::type<valType>::is_int || 
+//		detail::type<valType>::is_uint);
+//
+//	return typename tvec4<bool>::bool_type(x.x < y.x, x.y < y.y, x.z < y.z, x.w < y.w);
+//}
+//
+//// lessThanEqual
+//template <typename valType>
+//GLM_FUNC_QUALIFIER typename tvec2<T, P>::bool_type lessThanEqual
+//(
+//	tvec2<T, P> const & x, 
+//	tvec2<T, P> const & y
+//)
+//{
+//	GLM_STATIC_ASSERT(
+//		detail::type<valType>::is_float || 
+//		detail::type<valType>::is_int || 
+//		detail::type<valType>::is_uint);
+//
+//	return typename tvec2<bool>::bool_type(x.x <= y.x, x.y <= y.y);
+//}
+//
+//template <typename valType>
+//GLM_FUNC_QUALIFIER typename tvec3<T, P>::bool_type lessThanEqual
+//(
+//	tvec3<T, P> const & x, 
+//	tvec3<T, P> const & y
+//)
+//{
+//	GLM_STATIC_ASSERT(
+//		detail::type<valType>::is_float || 
+//		detail::type<valType>::is_int || 
+//		detail::type<valType>::is_uint);
+//	
+//	return typename tvec3<bool>::bool_type(x.x <= y.x, x.y <= y.y, x.z <= y.z);
+//}
+//
+//template <typename valType>
+//GLM_FUNC_QUALIFIER typename tvec4<T, P>::bool_type lessThanEqual
+//(
+//	tvec4<T, P> const & x, 
+//	tvec4<T, P> const & y
+//)
+//{
+//	GLM_STATIC_ASSERT(
+//		detail::type<valType>::is_float || 
+//		detail::type<valType>::is_int || 
+//		detail::type<valType>::is_uint);
+//	
+//	return typename tvec4<bool>::bool_type(x.x <= y.x, x.y <= y.y, x.z <= y.z, x.w <= y.w);
+//}
+//
+//// greaterThan
+//template <typename valType>
+//GLM_FUNC_QUALIFIER typename tvec2<T, P>::bool_type greaterThan
+//(
+//	tvec2<T, P> const & x, 
+//	tvec2<T, P> const & y
+//)
+//{
+//	GLM_STATIC_ASSERT(
+//		detail::type<valType>::is_float || 
+//		detail::type<valType>::is_int || 
+//		detail::type<valType>::is_uint);
+//
+//	return typename tvec2<bool>::bool_type(x.x > y.x, x.y > y.y);
+//}
+//
+//template <typename valType>
+//GLM_FUNC_QUALIFIER typename tvec3<T, P>::bool_type greaterThan
+//(
+//	tvec3<T, P> const & x, 
+//	tvec3<T, P> const & y
+//)
+//{
+//	GLM_STATIC_ASSERT(
+//		detail::type<valType>::is_float || 
+//		detail::type<valType>::is_int || 
+//		detail::type<valType>::is_uint);
+//	
+//	return typename tvec3<bool>::bool_type(x.x > y.x, x.y > y.y, x.z > y.z);
+//}
+//
+//template <typename valType>
+//GLM_FUNC_QUALIFIER typename tvec4<T, P>::bool_type greaterThan
+//(
+//	tvec4<T, P> const & x, 
+//	tvec4<T, P> const & y
+//)
+//{
+//	GLM_STATIC_ASSERT(
+//		detail::type<valType>::is_float || 
+//		detail::type<valType>::is_int || 
+//		detail::type<valType>::is_uint);
+//	
+//	return typename tvec4<bool>::bool_type(x.x > y.x, x.y > y.y, x.z > y.z, x.w > y.w);
+//}
+//
+//// greaterThanEqual
+//template <typename valType>
+//GLM_FUNC_QUALIFIER typename tvec2<T, P>::bool_type greaterThanEqual
+//(
+//	tvec2<T, P> const & x, 
+//	tvec2<T, P> const & y
+//)
+//{
+//	GLM_STATIC_ASSERT(
+//		detail::type<valType>::is_float || 
+//		detail::type<valType>::is_int || 
+//		detail::type<valType>::is_uint);
+//
+//	return typename tvec2<bool>::bool_type(x.x >= y.x, x.y >= y.y);
+//}
+//
+//template <typename valType>
+//GLM_FUNC_QUALIFIER typename tvec3<T, P>::bool_type greaterThanEqual
+//(
+//	tvec3<T, P> const & x, 
+//	tvec3<T, P> const & y
+//)
+//{
+//	GLM_STATIC_ASSERT(
+//		detail::type<valType>::is_float || 
+//		detail::type<valType>::is_int || 
+//		detail::type<valType>::is_uint);
+//
+//	return typename tvec3<bool>::bool_type(x.x >= y.x, x.y >= y.y, x.z >= y.z);
+//}
+//
+//template <typename valType>
+//GLM_FUNC_QUALIFIER typename tvec4<T, P>::bool_type greaterThanEqual
+//(
+//	tvec4<T, P> const & x, 
+//	tvec4<T, P> const & y
+//)
+//{
+//	GLM_STATIC_ASSERT(
+//		detail::type<valType>::is_float || 
+//		detail::type<valType>::is_int || 
+//		detail::type<valType>::is_uint);
+//
+//	return typename tvec4<bool>::bool_type(x.x >= y.x, x.y >= y.y, x.z >= y.z, x.w >= y.w);
+//}
+//
+//// equal
+//template <typename valType>
+//GLM_FUNC_QUALIFIER typename tvec2<T, P>::bool_type equal
+//(
+//	tvec2<T, P> const & x, 
+//	tvec2<T, P> const & y
+//)
+//{
+//	GLM_STATIC_ASSERT(
+//		detail::type<valType>::is_float || 
+//		detail::type<valType>::is_int || 
+//		detail::type<valType>::is_uint || 
+//		detail::type<valType>::is_bool);
+//
+//	return typename tvec2<T, P>::bool_type(x.x == y.x, x.y == y.y);
+//}
+//
+//template <typename valType>
+//GLM_FUNC_QUALIFIER typename tvec3<T, P>::bool_type equal
+//(
+//	tvec3<T, P> const & x, 
+//	tvec3<T, P> const & y
+//)
+//{
+//	GLM_STATIC_ASSERT(
+//		detail::type<valType>::is_float || 
+//		detail::type<valType>::is_int || 
+//		detail::type<valType>::is_uint || 
+//		detail::type<valType>::is_bool);
+//
+//	return typename tvec3<T, P>::bool_type(x.x == y.x, x.y == y.y, x.z == y.z);
+//}
+//
+//template <typename valType>
+//GLM_FUNC_QUALIFIER typename tvec4<T, P>::bool_type equal
+//(
+//	tvec4<T, P> const & x, 
+//	tvec4<T, P> const & y
+//)
+//{
+//	GLM_STATIC_ASSERT(
+//		detail::type<valType>::is_float || 
+//		detail::type<valType>::is_int || 
+//		detail::type<valType>::is_uint || 
+//		detail::type<valType>::is_bool);
+//
+//	return typename tvec4<T, P>::bool_type(x.x == y.x, x.y == y.y, x.z == y.z, x.w == y.w);
+//}
+//
+//// notEqual
+//template <typename valType>
+//GLM_FUNC_QUALIFIER typename tvec2<T, P>::bool_type notEqual
+//(
+//	tvec2<T, P> const & x, 
+//	tvec2<T, P> const & y
+//)
+//{
+//	GLM_STATIC_ASSERT(
+//		detail::type<valType>::is_float || 
+//		detail::type<valType>::is_int || 
+//		detail::type<valType>::is_uint || 
+//		detail::type<valType>::is_bool);
+//
+//	return typename tvec2<T, P>::bool_type(x.x != y.x, x.y != y.y);
+//}
+//
+//template <typename valType>
+//GLM_FUNC_QUALIFIER typename tvec3<T, P>::bool_type notEqual
+//(
+//	tvec3<T, P> const & x, 
+//	tvec3<T, P> const & y
+//)
+//{
+//	GLM_STATIC_ASSERT(
+//		detail::type<valType>::is_float || 
+//		detail::type<valType>::is_int || 
+//		detail::type<valType>::is_uint || 
+//		detail::type<valType>::is_bool);
+//
+//	return typename tvec3<T, P>::bool_type(x.x != y.x, x.y != y.y, x.z != y.z);
+//}
+//
+//template <typename valType>
+//GLM_FUNC_QUALIFIER typename tvec4<T, P>::bool_type notEqual
+//(
+//	tvec4<T, P> const & x, 
+//	tvec4<T, P> const & y
+//)
+//{
+//	GLM_STATIC_ASSERT(
+//		detail::type<valType>::is_float || 
+//		detail::type<valType>::is_int || 
+//		detail::type<valType>::is_uint || 
+//		detail::type<valType>::is_bool);
+//
+//	return typename tvec4<T, P>::bool_type(x.x != y.x, x.y != y.y, x.z != y.z, x.w != y.w);
+//}
+//
+//// any
+//GLM_FUNC_QUALIFIER bool any(tvec2<bool> const & x)
+//{
+//	return x.x || x.y;
+//}
+//
+//GLM_FUNC_QUALIFIER bool any(tvec3<bool> const & x)
+//{
+//    return x.x || x.y || x.z;
+//}
+//
+//GLM_FUNC_QUALIFIER bool any(tvec4<bool> const & x)
+//{
+//    return x.x || x.y || x.z || x.w;
+//}
+//
+//// all
+//GLM_FUNC_QUALIFIER bool all(const tvec2<bool>& x)
+//{
+//    return x.x && x.y;
+//}
+//
+//GLM_FUNC_QUALIFIER bool all(const tvec3<bool>& x)
+//{
+//    return x.x && x.y && x.z;
+//}
+//
+//GLM_FUNC_QUALIFIER bool all(const tvec4<bool>& x)
+//{
+//    return x.x && x.y && x.z && x.w;
+//}
+//
+//// not
+//GLM_FUNC_QUALIFIER tvec2<bool>::bool_type not_
+//(
+//	tvec2<bool> const & v
+//)
+//{
+//    return tvec2<bool>::bool_type(!v.x, !v.y);
+//}
+//
+//GLM_FUNC_QUALIFIER tvec3<bool>::bool_type not_
+//(
+//	tvec3<bool> const & v
+//)
+//{
+//    return tvec3<bool>::bool_type(!v.x, !v.y, !v.z);
+//}
+//
+//GLM_FUNC_QUALIFIER tvec4<bool>::bool_type not_
+//(
+//	tvec4<bool> const & v
+//)
+//{
+//    return tvec4<bool>::bool_type(!v.x, !v.y, !v.z, !v.w);
+//}

glm/glm/detail/precision.hpp

@@ -0,0 +1,44 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// 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.
+///
+/// @ref core
+/// @file glm/detail/precision.hpp
+/// @date 2013-04-01 / 2013-04-01
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#pragma once
+
+namespace glm
+{
+	enum precision
+	{
+		highp,
+		mediump,
+		lowp,
+		defaultp = highp
+	};
+}//namespace glm

glm/glm/detail/setup.hpp

@@ -0,0 +1,962 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// 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.
+///
+/// @ref core
+/// @file glm/detail/setup.hpp
+/// @date 2006-11-13 / 2014-10-05
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#pragma once
+
+#include <cassert>
+#include <cstddef>
+
+///////////////////////////////////////////////////////////////////////////////////
+// Version
+
+#define GLM_VERSION					96
+#define GLM_VERSION_MAJOR			0
+#define GLM_VERSION_MINOR			9
+#define GLM_VERSION_PATCH			6
+#define GLM_VERSION_REVISION		3
+
+#if(defined(GLM_MESSAGES) && !defined(GLM_MESSAGE_VERSION_DISPLAYED))
+#	define GLM_MESSAGE_VERSION_DISPLAYED
+#	pragma message ("GLM: version 0.9.6.3")
+#endif//GLM_MESSAGE
+
+///////////////////////////////////////////////////////////////////////////////////
+// Platform
+
+#define GLM_PLATFORM_UNKNOWN		0x00000000
+#define GLM_PLATFORM_WINDOWS		0x00010000
+#define GLM_PLATFORM_LINUX			0x00020000
+#define GLM_PLATFORM_APPLE			0x00040000
+//#define GLM_PLATFORM_IOS			0x00080000
+#define GLM_PLATFORM_ANDROID		0x00100000
+#define GLM_PLATFORM_CHROME_NACL	0x00200000
+#define GLM_PLATFORM_UNIX			0x00400000
+#define GLM_PLATFORM_QNXNTO			0x00800000
+#define GLM_PLATFORM_WINCE			0x01000000
+
+#ifdef GLM_FORCE_PLATFORM_UNKNOWN
+#	define GLM_PLATFORM GLM_PLATFORM_UNKNOWN
+#elif defined(__QNXNTO__)
+#	define GLM_PLATFORM GLM_PLATFORM_QNXNTO
+#elif defined(__APPLE__)
+#	define GLM_PLATFORM GLM_PLATFORM_APPLE
+#elif defined(WINCE)
+#	define GLM_PLATFORM GLM_PLATFORM_WINCE
+#elif defined(_WIN32)
+#	define GLM_PLATFORM GLM_PLATFORM_WINDOWS
+#elif defined(__native_client__)
+#	define GLM_PLATFORM GLM_PLATFORM_CHROME_NACL
+#elif defined(__ANDROID__)
+#	define GLM_PLATFORM GLM_PLATFORM_ANDROID
+#elif defined(__linux)
+#	define GLM_PLATFORM GLM_PLATFORM_LINUX
+#elif defined(__unix)
+#	define GLM_PLATFORM GLM_PLATFORM_UNIX
+#else
+#	define GLM_PLATFORM GLM_PLATFORM_UNKNOWN
+#endif//
+
+// Report platform detection
+#if(defined(GLM_MESSAGES) && !defined(GLM_MESSAGE_PLATFORM_DISPLAYED))
+#	define GLM_MESSAGE_PLATFORM_DISPLAYED
+#	if(GLM_PLATFORM & GLM_PLATFORM_QNXNTO)
+#		pragma message("GLM: QNX platform detected")
+//#	elif(GLM_PLATFORM & GLM_PLATFORM_IOS)
+//#		pragma message("GLM: iOS platform detected")
+#	elif(GLM_PLATFORM & GLM_PLATFORM_APPLE)
+#		pragma message("GLM: Apple platform detected")
+#	elif(GLM_PLATFORM & GLM_PLATFORM_WINCE)
+#		pragma message("GLM: WinCE platform detected")
+#	elif(GLM_PLATFORM & GLM_PLATFORM_WINDOWS)
+#		pragma message("GLM: Windows platform detected")
+#	elif(GLM_PLATFORM & GLM_PLATFORM_CHROME_NACL)
+#		pragma message("GLM: Native Client detected")
+#	elif(GLM_PLATFORM & GLM_PLATFORM_ANDROID)
+#		pragma message("GLM: Android platform detected")
+#	elif(GLM_PLATFORM & GLM_PLATFORM_LINUX)
+#		pragma message("GLM: Linux platform detected")
+#	elif(GLM_PLATFORM & GLM_PLATFORM_UNIX)
+#		pragma message("GLM: UNIX platform detected")
+#	elif(GLM_PLATFORM & GLM_PLATFORM_UNKNOWN)
+#		pragma message("GLM: platform unknown")
+#	else
+#		pragma message("GLM: platform not detected")
+#	endif
+#endif//GLM_MESSAGE
+
+///////////////////////////////////////////////////////////////////////////////////
+// Compiler
+
+// User defines: GLM_FORCE_COMPILER_UNKNOWN
+// TODO ? __llvm__ 
+
+#define GLM_COMPILER_UNKNOWN		0x00000000
+
+// Intel
+#define GLM_COMPILER_INTEL			0x00100000
+#define GLM_COMPILER_INTEL12		0x00100010
+#define GLM_COMPILER_INTEL12_1		0x00100020
+#define GLM_COMPILER_INTEL13		0x00100030
+#define GLM_COMPILER_INTEL14		0x00100040
+#define GLM_COMPILER_INTEL15		0x00100050
+
+// Visual C++ defines
+#define GLM_COMPILER_VC				0x01000000
+#define GLM_COMPILER_VC2010			0x01000090
+#define GLM_COMPILER_VC2012			0x010000A0
+#define GLM_COMPILER_VC2013			0x010000B0
+#define GLM_COMPILER_VC2015			0x010000C0
+
+// GCC defines
+#define GLM_COMPILER_GCC			0x02000000
+#define GLM_COMPILER_GCC44			0x020000B0
+#define GLM_COMPILER_GCC45			0x020000C0
+#define GLM_COMPILER_GCC46			0x020000D0
+#define GLM_COMPILER_GCC47			0x020000E0
+#define GLM_COMPILER_GCC48			0x020000F0
+#define GLM_COMPILER_GCC49			0x02000100
+#define GLM_COMPILER_GCC50			0x02000200
+
+// CUDA
+#define GLM_COMPILER_CUDA			0x10000000
+#define GLM_COMPILER_CUDA40			0x10000040
+#define GLM_COMPILER_CUDA41			0x10000050
+#define GLM_COMPILER_CUDA42			0x10000060
+#define GLM_COMPILER_CUDA50			0x10000070
+#define GLM_COMPILER_CUDA60			0x10000080
+#define GLM_COMPILER_CUDA65			0x10000090
+
+// LLVM
+#define GLM_COMPILER_LLVM			0x20000000
+#define GLM_COMPILER_LLVM32			0x20000030
+#define GLM_COMPILER_LLVM33			0x20000040
+#define GLM_COMPILER_LLVM34			0x20000050
+#define GLM_COMPILER_LLVM35			0x20000060
+
+// Apple Clang
+#define GLM_COMPILER_APPLE_CLANG	0x40000000
+#define GLM_COMPILER_APPLE_CLANG40	0x40000010
+#define GLM_COMPILER_APPLE_CLANG41	0x40000020
+#define GLM_COMPILER_APPLE_CLANG42	0x40000030
+#define GLM_COMPILER_APPLE_CLANG50	0x40000040
+#define GLM_COMPILER_APPLE_CLANG51	0x40000050
+#define GLM_COMPILER_APPLE_CLANG60	0x40000060
+
+// Build model
+#define GLM_MODEL_32				0x00000010
+#define GLM_MODEL_64				0x00000020
+
+// Force generic C++ compiler
+#ifdef GLM_FORCE_COMPILER_UNKNOWN
+#	define GLM_COMPILER GLM_COMPILER_UNKNOWN
+
+#elif defined(__INTEL_COMPILER)
+#	if __INTEL_COMPILER == 1200
+#		define GLM_COMPILER GLM_COMPILER_INTEL12
+#	elif __INTEL_COMPILER == 1210
+#		define GLM_COMPILER GLM_COMPILER_INTEL12_1
+#	elif __INTEL_COMPILER == 1300
+#		define GLM_COMPILER GLM_COMPILER_INTEL13
+#	elif __INTEL_COMPILER == 1400
+#		define GLM_COMPILER GLM_COMPILER_INTEL14
+#	elif __INTEL_COMPILER >= 1500
+#		define GLM_COMPILER GLM_COMPILER_INTEL15
+#	else
+#		define GLM_COMPILER GLM_COMPILER_INTEL
+#	endif
+
+// CUDA
+#elif defined(__CUDACC__)
+#	if !defined(CUDA_VERSION) && !defined(GLM_FORCE_CUDA)
+#		include <cuda.h>  // make sure version is defined since nvcc does not define it itself! 
+#	endif
+#	if CUDA_VERSION < 3000
+#		error "GLM requires CUDA 3.0 or higher"
+#	else
+#		define GLM_COMPILER GLM_COMPILER_CUDA
+#	endif
+
+// Visual C++
+#elif defined(_MSC_VER)
+#	if _MSC_VER < 1600
+#		error "GLM requires Visual C++ 2010 or higher"
+#	elif _MSC_VER == 1600
+#		define GLM_COMPILER GLM_COMPILER_VC2010
+#	elif _MSC_VER == 1700
+#		define GLM_COMPILER GLM_COMPILER_VC2012
+#	elif _MSC_VER == 1800
+#		define GLM_COMPILER GLM_COMPILER_VC2013
+#	elif _MSC_VER >= 1900
+#		define GLM_COMPILER GLM_COMPILER_VC2015
+#	else//_MSC_VER
+#		define GLM_COMPILER GLM_COMPILER_VC
+#	endif//_MSC_VER
+
+// Clang
+#elif defined(__clang__)
+#	if GLM_PLATFORM & GLM_PLATFORM_APPLE
+#		if __clang_major__ == 4 && __clang_minor__ == 0
+#			define GLM_COMPILER GLM_COMPILER_APPLE_CLANG40
+#		elif __clang_major__ == 4 && __clang_minor__ == 1
+#			define GLM_COMPILER GLM_COMPILER_APPLE_CLANG41
+#		elif __clang_major__ == 4 && __clang_minor__ == 2
+#			define GLM_COMPILER GLM_COMPILER_APPLE_CLANG42
+#		elif __clang_major__ == 5 && __clang_minor__ == 0
+#			define GLM_COMPILER GLM_COMPILER_APPLE_CLANG50
+#		elif __clang_major__ == 5 && __clang_minor__ == 1
+#			define GLM_COMPILER GLM_COMPILER_APPLE_CLANG51
+#		elif __clang_major__ >= 6
+#			define GLM_COMPILER GLM_COMPILER_APPLE_CLANG60
+#		endif
+#	else
+#		if __clang_major__ == 3 && __clang_minor__ == 0
+#			define GLM_COMPILER GLM_COMPILER_LLVM30
+#		elif __clang_major__ == 3 && __clang_minor__ == 1
+#			define GLM_COMPILER GLM_COMPILER_LLVM31
+#		elif __clang_major__ == 3 && __clang_minor__ == 2
+#			define GLM_COMPILER GLM_COMPILER_LLVM32
+#		elif __clang_major__ == 3 && __clang_minor__ == 3
+#			define GLM_COMPILER GLM_COMPILER_LLVM33
+#		elif __clang_major__ == 3 && __clang_minor__ == 4
+#			define GLM_COMPILER GLM_COMPILER_LLVM34
+#		elif __clang_major__ == 3 && __clang_minor__ == 5
+#			define GLM_COMPILER GLM_COMPILER_LLVM35
+#		else
+#			define GLM_COMPILER GLM_COMPILER_LLVM35
+#		endif
+#	endif
+
+// G++ 
+#elif defined(__GNUC__) || defined(__MINGW32__)
+#	if (__GNUC__ == 4) && (__GNUC_MINOR__ == 2)
+#		define GLM_COMPILER (GLM_COMPILER_GCC42)
+#	elif (__GNUC__ == 4) && (__GNUC_MINOR__ == 3)
+#		define GLM_COMPILER (GLM_COMPILER_GCC43)
+#	elif (__GNUC__ == 4) && (__GNUC_MINOR__ == 4)
+#		define GLM_COMPILER (GLM_COMPILER_GCC44)
+#	elif (__GNUC__ == 4) && (__GNUC_MINOR__ == 5)
+#		define GLM_COMPILER (GLM_COMPILER_GCC45)
+#	elif (__GNUC__ == 4) && (__GNUC_MINOR__ == 6)
+#		define GLM_COMPILER (GLM_COMPILER_GCC46)
+#	elif (__GNUC__ == 4) && (__GNUC_MINOR__ == 7)
+#		define GLM_COMPILER (GLM_COMPILER_GCC47)
+#	elif (__GNUC__ == 4) && (__GNUC_MINOR__ == 8)
+#		define GLM_COMPILER (GLM_COMPILER_GCC48)
+#	elif (__GNUC__ == 4) && (__GNUC_MINOR__ >= 9)
+#		define GLM_COMPILER (GLM_COMPILER_GCC49)
+#	elif (__GNUC__ > 4 )
+#		define GLM_COMPILER (GLM_COMPILER_GCC50)
+#	else
+#		define GLM_COMPILER (GLM_COMPILER_GCC)
+#	endif
+
+#else
+#	define GLM_COMPILER GLM_COMPILER_UNKNOWN
+#endif
+
+#ifndef GLM_COMPILER
+#error "GLM_COMPILER undefined, your compiler may not be supported by GLM. Add #define GLM_COMPILER 0 to ignore this message."
+#endif//GLM_COMPILER
+
+// Report compiler detection
+#if defined(GLM_MESSAGES) && !defined(GLM_MESSAGE_COMPILER_DISPLAYED)
+#	define GLM_MESSAGE_COMPILER_DISPLAYED
+#	if GLM_COMPILER & GLM_COMPILER_CUDA
+#		pragma message("GLM: CUDA compiler detected")
+#	elif GLM_COMPILER & GLM_COMPILER_VC
+#		pragma message("GLM: Visual C++ compiler detected")
+#	elif GLM_COMPILER & GLM_COMPILER_APPLE_CLANG
+#		pragma message("GLM: Clang compiler detected")
+#	elif GLM_COMPILER & GLM_COMPILER_LLVM
+#		pragma message("GLM: LLVM compiler detected")
+#	elif GLM_COMPILER & GLM_COMPILER_INTEL
+#		pragma message("GLM: Intel Compiler detected")
+#	elif GLM_COMPILER & GLM_COMPILER_GCC
+#		pragma message("GLM: GCC compiler detected")
+#	else
+#		pragma message("GLM: Compiler not detected")
+#	endif
+#endif//GLM_MESSAGE
+
+///////////////////////////////////////////////////////////////////////////////////
+// Build model
+
+#if defined(__arch64__) || defined(__LP64__) || defined(_M_X64) || defined(__ppc64__) || defined(__x86_64__)
+#		define GLM_MODEL	GLM_MODEL_64
+#elif defined(__i386__) || defined(__ppc__)
+#	define GLM_MODEL	GLM_MODEL_32
+#else
+#	define GLM_MODEL	GLM_MODEL_32
+#endif//
+
+#if !defined(GLM_MODEL) && GLM_COMPILER != 0
+#	error "GLM_MODEL undefined, your compiler may not be supported by GLM. Add #define GLM_MODEL 0 to ignore this message."
+#endif//GLM_MODEL
+
+#if defined(GLM_MESSAGES) && !defined(GLM_MESSAGE_MODEL_DISPLAYED)
+#	define GLM_MESSAGE_MODEL_DISPLAYED
+#	if(GLM_MODEL == GLM_MODEL_64)
+#		pragma message("GLM: 64 bits model")
+#	elif(GLM_MODEL == GLM_MODEL_32)
+#		pragma message("GLM: 32 bits model")
+#	endif//GLM_MODEL
+#endif//GLM_MESSAGE
+
+///////////////////////////////////////////////////////////////////////////////////
+// C++ Version
+
+// User defines: GLM_FORCE_CXX98, GLM_FORCE_CXX03, GLM_FORCE_CXX11, GLM_FORCE_CXX14
+
+#define GLM_LANG_CXX98_FLAG			(1 << 1)
+#define GLM_LANG_CXX03_FLAG			(1 << 2)
+#define GLM_LANG_CXX0X_FLAG			(1 << 3)
+#define GLM_LANG_CXX11_FLAG			(1 << 4)
+#define GLM_LANG_CXX1Y_FLAG			(1 << 5)
+#define GLM_LANG_CXX14_FLAG			(1 << 6)
+#define GLM_LANG_CXX1Z_FLAG			(1 << 7)
+#define GLM_LANG_CXXMS_FLAG			(1 << 8)
+#define GLM_LANG_CXXGNU_FLAG		(1 << 9)
+
+#define GLM_LANG_CXX98			GLM_LANG_CXX98_FLAG
+#define GLM_LANG_CXX03			(GLM_LANG_CXX98 | GLM_LANG_CXX03_FLAG)
+#define GLM_LANG_CXX0X			(GLM_LANG_CXX03 | GLM_LANG_CXX0X_FLAG)
+#define GLM_LANG_CXX11			(GLM_LANG_CXX0X | GLM_LANG_CXX11_FLAG)
+#define GLM_LANG_CXX1Y			(GLM_LANG_CXX11 | GLM_LANG_CXX1Y_FLAG)
+#define GLM_LANG_CXX14			(GLM_LANG_CXX1Y | GLM_LANG_CXX14_FLAG)
+#define GLM_LANG_CXX1Z			(GLM_LANG_CXX14 | GLM_LANG_CXX1Z_FLAG)
+#define GLM_LANG_CXXMS			GLM_LANG_CXXMS_FLAG
+#define GLM_LANG_CXXGNU			GLM_LANG_CXXGNU_FLAG
+
+#if defined(GLM_FORCE_CXX14)
+#	undef GLM_FORCE_CXX11
+#	undef GLM_FORCE_CXX03
+#	undef GLM_FORCE_CXX98
+#	define GLM_LANG GLM_LANG_CXX14
+#elif defined(GLM_FORCE_CXX11)
+#	undef GLM_FORCE_CXX03
+#	undef GLM_FORCE_CXX98
+#	define GLM_LANG GLM_LANG_CXX11
+#elif defined(GLM_FORCE_CXX03)
+#	undef GLM_FORCE_CXX98
+#	define GLM_LANG GLM_LANG_CXX03
+#elif defined(GLM_FORCE_CXX98)
+#	define GLM_LANG GLM_LANG_CXX98
+#else
+#	if GLM_COMPILER & (GLM_COMPILER_APPLE_CLANG | GLM_COMPILER_LLVM)
+#		if __cplusplus >= 201402L // GLM_COMPILER_LLVM34 + -std=c++14
+#			define GLM_LANG GLM_LANG_CXX14
+#		elif __has_feature(cxx_decltype_auto) && __has_feature(cxx_aggregate_nsdmi) // GLM_COMPILER_LLVM33 + -std=c++1y
+#			define GLM_LANG GLM_LANG_CXX1Y
+#		elif __cplusplus >= 201103L // GLM_COMPILER_LLVM33 + -std=c++11
+#			define GLM_LANG GLM_LANG_CXX11
+#		elif __has_feature(cxx_static_assert) // GLM_COMPILER_LLVM29 + -std=c++11
+#			define GLM_LANG GLM_LANG_CXX0X
+#		elif __cplusplus >= 199711L
+#			define GLM_LANG GLM_LANG_CXX98
+#		else
+#			define GLM_LANG GLM_LANG_CXX
+#		endif
+#	elif GLM_COMPILER & GLM_COMPILER_GCC
+#		if __cplusplus >= 201402L
+#			define GLM_LANG GLM_LANG_CXX14
+#		elif __cplusplus >= 201103L
+#			define GLM_LANG GLM_LANG_CXX11
+#		elif defined(__GXX_EXPERIMENTAL_CXX0X__)
+#			define GLM_LANG GLM_LANG_CXX0X
+#		else
+#			define GLM_LANG GLM_LANG_CXX98
+#		endif
+#	elif GLM_COMPILER & GLM_COMPILER_VC
+#		ifdef _MSC_EXTENSIONS
+#			if __cplusplus >= 201402L
+#				define GLM_LANG (GLM_LANG_CXX14 | GLM_LANG_CXXMS_FLAG)
+//#			elif GLM_COMPILER >= GLM_COMPILER_VC2015
+//#				define GLM_LANG (GLM_LANG_CXX1Y | GLM_LANG_CXXMS_FLAG)
+#			elif __cplusplus >= 201103L
+#				define GLM_LANG (GLM_LANG_CXX11 | GLM_LANG_CXXMS_FLAG)
+#			elif GLM_COMPILER >= GLM_COMPILER_VC2010
+#				define GLM_LANG (GLM_LANG_CXX0X | GLM_LANG_CXXMS_FLAG)
+#			elif __cplusplus >= 199711L
+#				define GLM_LANG (GLM_LANG_CXX98 | GLM_LANG_CXXMS_FLAG)
+#			else
+#				define GLM_LANG (GLM_LANG_CXX | GLM_LANG_CXXMS_FLAG)
+#			endif
+#		else
+#			if __cplusplus >= 201402L
+#				define GLM_LANG GLM_LANG_CXX14
+//#			elif GLM_COMPILER >= GLM_COMPILER_VC2015
+//#				define GLM_LANG GLM_LANG_CXX1Y
+#			elif __cplusplus >= 201103L
+#				define GLM_LANG GLM_LANG_CXX11
+#			elif GLM_COMPILER >= GLM_COMPILER_VC2010
+#				define GLM_LANG GLM_LANG_CXX0X
+#			elif __cplusplus >= 199711L
+#				define GLM_LANG GLM_LANG_CXX98
+#			else
+#				define GLM_LANG GLM_LANG_CXX
+#			endif
+#		endif
+#	elif GLM_COMPILER & GLM_COMPILER_INTEL
+#		ifdef _MSC_EXTENSIONS
+#			if __cplusplus >= 201402L
+#				define GLM_LANG (GLM_LANG_CXX14 | GLM_LANG_CXXMS_FLAG)
+#			elif __cplusplus >= 201103L
+#				define GLM_LANG (GLM_LANG_CXX11 | GLM_LANG_CXXMS_FLAG)
+#			elif GLM_COMPILER >= GLM_COMPILER_INTEL13
+#				define GLM_LANG (GLM_LANG_CXX0X | GLM_LANG_CXXMS_FLAG)
+#			elif __cplusplus >= 199711L
+#				define GLM_LANG (GLM_LANG_CXX98 | GLM_LANG_CXXMS_FLAG)
+#			else
+#				define GLM_LANG (GLM_LANG_CXX | GLM_LANG_CXXMS_FLAG)
+#			endif
+#		else
+#			if __cplusplus >= 201402L
+#				define GLM_LANG (GLM_LANG_CXX14 | GLM_LANG_CXXMS_FLAG)
+#			elif __cplusplus >= 201103L
+#				define GLM_LANG (GLM_LANG_CXX11 | GLM_LANG_CXXMS_FLAG)
+#			elif GLM_COMPILER >= GLM_COMPILER_INTEL13
+#				define GLM_LANG (GLM_LANG_CXX0X | GLM_LANG_CXXMS_FLAG)
+#			elif __cplusplus >= 199711L
+#				define GLM_LANG (GLM_LANG_CXX98 | GLM_LANG_CXXMS_FLAG)
+#			else
+#				define GLM_LANG (GLM_LANG_CXX | GLM_LANG_CXXMS_FLAG)
+#			endif
+#		endif
+#	else // Unkown compiler
+#		if __cplusplus >= 201402L
+#			define GLM_LANG GLM_LANG_CXX14
+#		elif __cplusplus >= 201103L
+#			define GLM_LANG GLM_LANG_CXX11
+#		elif __cplusplus >= 199711L
+#			define GLM_LANG GLM_LANG_CXX98
+#		else
+#			define GLM_LANG GLM_LANG_CXX // Good luck with that!
+#		endif
+#		ifndef GLM_FORCE_PURE
+#			define GLM_FORCE_PURE
+#		endif
+#	endif
+#endif
+
+#if defined(GLM_MESSAGES) && !defined(GLM_MESSAGE_LANG_DISPLAYED)
+#	define GLM_MESSAGE_LANG_DISPLAYED
+
+#	if GLM_LANG & GLM_LANG_CXX1Z_FLAG
+#		pragma message("GLM: C++1z")
+#	elif GLM_LANG & GLM_LANG_CXX14_FLAG
+#		pragma message("GLM: C++14")
+#	elif GLM_LANG & GLM_LANG_CXX1Y_FLAG
+#		pragma message("GLM: C++1y")
+#	elif GLM_LANG & GLM_LANG_CXX11_FLAG
+#		pragma message("GLM: C++11")
+#	elif GLM_LANG & GLM_LANG_CXX0X_FLAG
+#		pragma message("GLM: C++0x")
+#	elif GLM_LANG & GLM_LANG_CXX03_FLAG
+#		pragma message("GLM: C++03")
+#	elif GLM_LANG & GLM_LANG_CXX98_FLAG
+#		pragma message("GLM: C++98")
+#	else
+#		pragma message("GLM: C++ language undetected")
+#	endif//GLM_LANG
+
+#	if GLM_LANG & (GLM_LANG_CXXGNU_FLAG | GLM_LANG_CXXMS_FLAG)
+#		pragma message("GLM: Language extensions enabled")
+#	endif//GLM_LANG
+#endif//GLM_MESSAGE
+
+///////////////////////////////////////////////////////////////////////////////////
+// Has of C++ features
+
+// http://clang.llvm.org/cxx_status.html
+// http://gcc.gnu.org/projects/cxx0x.html
+// http://msdn.microsoft.com/en-us/library/vstudio/hh567368(v=vs.120).aspx
+
+#if GLM_PLATFORM == GLM_PLATFORM_ANDROID
+#	define GLM_HAS_CXX11_STL 0
+#elif GLM_COMPILER & (GLM_COMPILER_LLVM | GLM_COMPILER_APPLE_CLANG)
+#	define GLM_HAS_CXX11_STL __has_include(<__config>)
+#else
+#	define GLM_HAS_CXX11_STL ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && \
+		((GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC48)) || \
+		((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC2013)))
+#endif
+
+// N1720
+#if GLM_COMPILER & (GLM_COMPILER_LLVM | GLM_COMPILER_APPLE_CLANG)
+#	define GLM_HAS_STATIC_ASSERT __has_feature(cxx_static_assert)
+#elif GLM_LANG & GLM_LANG_CXX11_FLAG
+#	define GLM_HAS_STATIC_ASSERT 1
+#else
+#	define GLM_HAS_STATIC_ASSERT (GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\
+		((GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC43)) || \
+		((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC2010)))
+#endif
+
+// N1988
+#if GLM_LANG & GLM_LANG_CXX11_FLAG
+#	define GLM_HAS_EXTENDED_INTEGER_TYPE 1
+#else
+#	define GLM_HAS_EXTENDED_INTEGER_TYPE (\
+		((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC2012)) || \
+		((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC43)) || \
+		((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (GLM_COMPILER & GLM_COMPILER_LLVM) && (GLM_COMPILER >= GLM_COMPILER_LLVM30)) || \
+		((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (GLM_COMPILER & GLM_COMPILER_APPLE_CLANG) && (GLM_COMPILER >= GLM_COMPILER_APPLE_CLANG40)))
+#endif
+
+// N2235
+#if GLM_COMPILER & (GLM_COMPILER_LLVM | GLM_COMPILER_APPLE_CLANG)
+#	define GLM_HAS_CONSTEXPR __has_feature(cxx_constexpr)
+#	define GLM_HAS_CONSTEXPR_PARTIAL GLM_HAS_CONSTEXPR
+#elif GLM_LANG & GLM_LANG_CXX11_FLAG
+#	define GLM_HAS_CONSTEXPR 1
+#	define GLM_HAS_CONSTEXPR_PARTIAL GLM_HAS_CONSTEXPR
+#else
+#	define GLM_HAS_CONSTEXPR (GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\
+		((GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC46)))
+#	define GLM_HAS_CONSTEXPR_PARTIAL GLM_HAS_CONSTEXPR || ((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC2015))
+#endif
+
+// N2672
+#if GLM_COMPILER & (GLM_COMPILER_LLVM | GLM_COMPILER_APPLE_CLANG)
+#	define GLM_HAS_INITIALIZER_LISTS __has_feature(cxx_generalized_initializers)
+#elif GLM_LANG & GLM_LANG_CXX11_FLAG
+#	define GLM_HAS_INITIALIZER_LISTS 1
+#else
+#	define GLM_HAS_INITIALIZER_LISTS (GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\
+		((GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC44)) || \
+		((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC2013)))
+#endif
+
+// N2544 Unrestricted unions
+#if GLM_COMPILER & (GLM_COMPILER_LLVM | GLM_COMPILER_APPLE_CLANG)
+#	define GLM_HAS_UNRESTRICTED_UNIONS __has_feature(cxx_unrestricted_unions)
+#elif GLM_LANG & (GLM_LANG_CXX11_FLAG | GLM_LANG_CXXMS_FLAG)
+#	define GLM_HAS_UNRESTRICTED_UNIONS 1
+#else
+#	define GLM_HAS_UNRESTRICTED_UNIONS (GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\
+		((GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC46)))
+#endif
+
+// N2346
+#if GLM_COMPILER & (GLM_COMPILER_LLVM | GLM_COMPILER_APPLE_CLANG)
+#	define GLM_HAS_DEFAULTED_FUNCTIONS __has_feature(cxx_defaulted_functions)
+#elif GLM_LANG & GLM_LANG_CXX11_FLAG
+#	define GLM_HAS_DEFAULTED_FUNCTIONS 1
+#else
+#	define GLM_HAS_DEFAULTED_FUNCTIONS (GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\
+		((GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC44)) || \
+		((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC2013)))
+#endif
+
+// N2118
+#if GLM_COMPILER & (GLM_COMPILER_LLVM | GLM_COMPILER_APPLE_CLANG)
+#	define GLM_HAS_RVALUE_REFERENCES __has_feature(cxx_rvalue_references)
+#elif GLM_LANG & GLM_LANG_CXX11_FLAG
+#	define GLM_HAS_RVALUE_REFERENCES 1
+#else
+#	define GLM_HAS_RVALUE_REFERENCES (GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\
+		((GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC43)) || \
+		((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC2012)))
+#endif
+
+// N2437 http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2437.pdf
+#if GLM_COMPILER & (GLM_COMPILER_LLVM | GLM_COMPILER_APPLE_CLANG)
+#	define GLM_HAS_EXPLICIT_CONVERSION_OPERATORS __has_feature(cxx_explicit_conversions)
+#elif GLM_LANG & GLM_LANG_CXX11_FLAG
+#	define GLM_HAS_EXPLICIT_CONVERSION_OPERATORS 1
+#else
+#	define GLM_HAS_EXPLICIT_CONVERSION_OPERATORS (GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\
+		((GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC45)) || \
+		((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_COMPILER >= GLM_COMPILER_INTEL14)) || \
+		((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC2013)))
+#endif
+
+// N2258 http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2258.pdf
+#if GLM_COMPILER & (GLM_COMPILER_LLVM | GLM_COMPILER_APPLE_CLANG)
+#	define GLM_HAS_TEMPLATE_ALIASES __has_feature(cxx_alias_templates)
+#elif GLM_LANG & GLM_LANG_CXX11_FLAG
+#	define GLM_HAS_TEMPLATE_ALIASES 1
+#else
+#	define GLM_HAS_TEMPLATE_ALIASES (GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\
+		((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_COMPILER >= GLM_COMPILER_INTEL12_1)) || \
+		((GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC47)) || \
+		((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC2013)))
+#endif
+
+// N2930 http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2930.html
+#if GLM_COMPILER & (GLM_COMPILER_LLVM | GLM_COMPILER_APPLE_CLANG)
+#	define GLM_HAS_RANGE_FOR __has_feature(cxx_range_for)
+#elif GLM_LANG & GLM_LANG_CXX11_FLAG
+#	define GLM_HAS_RANGE_FOR 1
+#else
+#	define GLM_HAS_RANGE_FOR (GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\
+		((GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC46)) || \
+		((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_COMPILER >= GLM_COMPILER_INTEL13)) || \
+		((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC2012)))
+#endif
+
+// 
+#if GLM_LANG & GLM_LANG_CXX11_FLAG
+#	define GLM_HAS_ASSIGNABLE 1
+#else
+#	define GLM_HAS_ASSIGNABLE (GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\
+		((GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC49)))
+#endif
+
+// 
+#define GLM_HAS_TRIVIAL_QUERIES 0//( \
+	//((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC2013)))
+
+// 
+#if GLM_LANG & GLM_LANG_CXX11_FLAG
+#	define GLM_HAS_MAKE_SIGNED 1
+#else
+#	define GLM_HAS_MAKE_SIGNED (GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\
+		((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC2013)))
+#endif
+
+// 
+#if GLM_ARCH == GLM_ARCH_PURE
+#	define GLM_HAS_BITSCAN_WINDOWS 0
+#else
+#	define GLM_HAS_BITSCAN_WINDOWS (GLM_PLATFORM & GLM_PLATFORM_WINDOWS) && (\
+		(GLM_COMPILER & (GLM_COMPILER_VC | GLM_COMPILER_LLVM | GLM_COMPILER_INTEL))
+#endif
+
+// OpenMP
+#ifdef _OPENMP 
+#	if GLM_COMPILER & GLM_COMPILER_GCC
+#		if GLM_COMPILER >= GLM_COMPILER_GCC47
+#			define GLM_HAS_OPENMP 31
+#		elif GLM_COMPILER >= GLM_COMPILER_GCC44
+#			define GLM_HAS_OPENMP 30
+#		elif GLM_COMPILER >= GLM_COMPILER_GCC42
+#			define GLM_HAS_OPENMP 25
+#		endif
+#	endif// GLM_COMPILER & GLM_COMPILER_GCC
+
+#	if GLM_COMPILER & GLM_COMPILER_VC
+#		if GLM_COMPILER >= GLM_COMPILER_VC2010
+#			define GLM_HAS_OPENMP 20
+#		endif
+#	endif// GLM_COMPILER & GLM_COMPILER_VC
+#endif
+
+// Not standard
+#define GLM_HAS_ANONYMOUS_UNION (GLM_LANG & GLM_LANG_CXXMS_FLAG)
+
+///////////////////////////////////////////////////////////////////////////////////
+// Platform 
+
+// User defines: GLM_FORCE_PURE GLM_FORCE_SSE2 GLM_FORCE_SSE3 GLM_FORCE_AVX GLM_FORCE_AVX2
+
+#define GLM_ARCH_PURE		0x0000
+#define GLM_ARCH_ARM		0x0001
+#define GLM_ARCH_X86		0x0002
+#define GLM_ARCH_SSE2		0x0004
+#define GLM_ARCH_SSE3		0x0008
+#define GLM_ARCH_SSE4		0x0010
+#define GLM_ARCH_AVX		0x0020
+#define GLM_ARCH_AVX2		0x0040
+
+#if defined(GLM_FORCE_PURE)
+#	define GLM_ARCH GLM_ARCH_PURE
+#elif defined(GLM_FORCE_AVX2)
+#	define GLM_ARCH (GLM_ARCH_AVX2 | GLM_ARCH_AVX | GLM_ARCH_SSE4 | GLM_ARCH_SSE3 | GLM_ARCH_SSE2)
+#elif defined(GLM_FORCE_AVX)
+#	define GLM_ARCH (GLM_ARCH_AVX | GLM_ARCH_SSE4 | GLM_ARCH_SSE3 | GLM_ARCH_SSE2)
+#elif defined(GLM_FORCE_SSE4)
+#	define GLM_ARCH (GLM_ARCH_SSE4 | GLM_ARCH_SSE3 | GLM_ARCH_SSE2)
+#elif defined(GLM_FORCE_SSE3)
+#	define GLM_ARCH (GLM_ARCH_SSE3 | GLM_ARCH_SSE2)
+#elif defined(GLM_FORCE_SSE2)
+#	define GLM_ARCH (GLM_ARCH_SSE2)
+#elif (GLM_COMPILER & (GLM_COMPILER_APPLE_CLANG | GLM_COMPILER_LLVM | GLM_COMPILER_GCC)) || ((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_PLATFORM & GLM_PLATFORM_LINUX))
+#	if(__AVX2__)
+#		define GLM_ARCH (GLM_ARCH_AVX2 | GLM_ARCH_AVX | GLM_ARCH_SSE3 | GLM_ARCH_SSE2)
+#	elif(__AVX__)
+#		define GLM_ARCH (GLM_ARCH_AVX | GLM_ARCH_SSE3 | GLM_ARCH_SSE2)
+#	elif(__SSE3__)
+#		define GLM_ARCH (GLM_ARCH_SSE3 | GLM_ARCH_SSE2)
+#	elif(__SSE2__)
+#		define GLM_ARCH (GLM_ARCH_SSE2)
+#	else
+#		define GLM_ARCH GLM_ARCH_PURE
+#	endif
+#elif (GLM_COMPILER & GLM_COMPILER_VC) || ((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_PLATFORM & GLM_PLATFORM_WINDOWS))
+#	if defined(_M_ARM_FP)
+#		define GLM_ARCH (GLM_ARCH_ARM)
+#	elif defined(__AVX2__)
+#		define GLM_ARCH (GLM_ARCH_AVX2 | GLM_ARCH_AVX | GLM_ARCH_SSE4 | GLM_ARCH_SSE3 | GLM_ARCH_SSE2)
+#	elif defined(__AVX__)
+#		define GLM_ARCH (GLM_ARCH_AVX | GLM_ARCH_SSE4 | GLM_ARCH_SSE3 | GLM_ARCH_SSE2)
+#	elif _M_IX86_FP == 2
+#		define GLM_ARCH (GLM_ARCH_SSE2)
+#	else
+#		define GLM_ARCH (GLM_ARCH_PURE)
+#	endif
+#elif (GLM_COMPILER & GLM_COMPILER_GCC) && (defined(__i386__) || defined(__x86_64__))
+#	if defined(__AVX2__) 
+#		define GLM_ARCH (GLM_ARCH_AVX2 | GLM_ARCH_AVX | GLM_ARCH_SSE4 | GLM_ARCH_SSE3 | GLM_ARCH_SSE2)
+#	elif defined(__AVX__)
+#		define GLM_ARCH (GLM_ARCH_AVX | GLM_ARCH_SSE4 | GLM_ARCH_SSE3 | GLM_ARCH_SSE2)
+#	elif defined(__SSE4_1__ )
+#		define GLM_ARCH (GLM_ARCH_SSE4 | GLM_ARCH_SSE3 | GLM_ARCH_SSE2)
+#	elif defined(__SSE3__)
+#		define GLM_ARCH (GLM_ARCH_SSE3 | GLM_ARCH_SSE2)
+#	elif defined(__SSE2__)
+#		define GLM_ARCH (GLM_ARCH_SSE2)
+#	else
+#		define GLM_ARCH (GLM_ARCH_PURE)
+#	endif
+#else
+#	define GLM_ARCH GLM_ARCH_PURE
+#endif
+
+// With MinGW-W64, including intrinsic headers before intrin.h will produce some errors. The problem is
+// that windows.h (and maybe other headers) will silently include intrin.h, which of course causes problems.
+// To fix, we just explicitly include intrin.h here.
+#if defined(__MINGW64__) && (GLM_ARCH != GLM_ARCH_PURE)
+#	include <intrin.h>
+#endif
+
+#if GLM_ARCH & GLM_ARCH_AVX2
+#	include <immintrin.h>
+#endif//GLM_ARCH
+#if GLM_ARCH & GLM_ARCH_AVX
+#	include <immintrin.h>
+#endif//GLM_ARCH
+#if GLM_ARCH & GLM_ARCH_SSE4
+#	include <smmintrin.h>
+#endif//GLM_ARCH
+#if GLM_ARCH & GLM_ARCH_SSE3
+#	include <pmmintrin.h>
+#endif//GLM_ARCH
+#if GLM_ARCH & GLM_ARCH_SSE2
+#	include <emmintrin.h>
+#	if(GLM_COMPILER == GLM_COMPILER_VC2005) // VC2005 is missing some intrinsics, workaround
+		inline float _mm_cvtss_f32(__m128 A) { return A.m128_f32[0]; }
+		inline __m128 _mm_castpd_ps(__m128d PD) { union { __m128 ps; __m128d pd; } c; c.pd = PD; return c.ps; }
+		inline __m128d _mm_castps_pd(__m128 PS) { union { __m128 ps; __m128d pd; } c; c.ps = PS; return c.pd; }
+		inline __m128i _mm_castps_si128(__m128 PS) { union { __m128 ps; __m128i pi; } c; c.ps = PS; return c.pi; }
+		inline __m128 _mm_castsi128_ps(__m128i PI) { union { __m128 ps; __m128i pi; } c; c.pi = PI; return c.ps; }
+#	endif
+#endif//GLM_ARCH
+
+#if defined(GLM_MESSAGES) && !defined(GLM_MESSAGE_ARCH_DISPLAYED)
+#	define GLM_MESSAGE_ARCH_DISPLAYED
+#	if(GLM_ARCH == GLM_ARCH_PURE)
+#		pragma message("GLM: Platform independent code")
+#	elif(GLM_ARCH & GLM_ARCH_ARM)
+#		pragma message("GLM: ARM instruction set")
+#	elif(GLM_ARCH & GLM_ARCH_AVX2)
+#		pragma message("GLM: AVX2 instruction set")
+#	elif(GLM_ARCH & GLM_ARCH_AVX)
+#		pragma message("GLM: AVX instruction set")
+#	elif(GLM_ARCH & GLM_ARCH_SSE3)
+#		pragma message("GLM: SSE3 instruction set")
+#	elif(GLM_ARCH & GLM_ARCH_SSE2)
+#		pragma message("GLM: SSE2 instruction set")
+#	endif//GLM_ARCH
+#endif//GLM_MESSAGE
+
+///////////////////////////////////////////////////////////////////////////////////
+// Static assert
+
+#if GLM_HAS_STATIC_ASSERT
+#	define GLM_STATIC_ASSERT(x, message) static_assert(x, message)
+#elif defined(BOOST_STATIC_ASSERT)
+#	define GLM_STATIC_ASSERT(x, message) BOOST_STATIC_ASSERT(x)
+#elif GLM_COMPILER & GLM_COMPILER_VC
+#	define GLM_STATIC_ASSERT(x, message) typedef char __CASSERT__##__LINE__[(x) ? 1 : -1]
+#else
+#	define GLM_STATIC_ASSERT(x, message)
+#	define GLM_STATIC_ASSERT_NULL
+#endif//GLM_LANG
+
+///////////////////////////////////////////////////////////////////////////////////
+// Qualifiers
+
+#if GLM_COMPILER & GLM_COMPILER_CUDA
+#	define GLM_CUDA_FUNC_DEF __device__ __host__
+#	define GLM_CUDA_FUNC_DECL __device__ __host__
+#else
+#	define GLM_CUDA_FUNC_DEF
+#	define GLM_CUDA_FUNC_DECL
+#endif
+
+#if GLM_COMPILER & GLM_COMPILER_GCC
+#	define GLM_VAR_USED __attribute__ ((unused))
+#else
+#	define GLM_VAR_USED
+#endif
+
+#if defined(GLM_FORCE_INLINE)
+#	if GLM_COMPILER & GLM_COMPILER_VC
+#		define GLM_INLINE __forceinline
+#		define GLM_NEVER_INLINE __declspec((noinline))
+#	elif GLM_COMPILER & (GLM_COMPILER_GCC | GLM_COMPILER_APPLE_CLANG | GLM_COMPILER_LLVM)
+#		define GLM_INLINE inline __attribute__((__always_inline__))
+#		define GLM_NEVER_INLINE __attribute__((__noinline__))
+#	else
+#		define GLM_INLINE inline
+#		define GLM_NEVER_INLINE
+#	endif//GLM_COMPILER
+#else
+#	define GLM_INLINE inline
+#	define GLM_NEVER_INLINE
+#endif//defined(GLM_FORCE_INLINE)
+
+#define GLM_FUNC_DECL GLM_CUDA_FUNC_DECL
+#define GLM_FUNC_QUALIFIER GLM_CUDA_FUNC_DEF GLM_INLINE
+
+///////////////////////////////////////////////////////////////////////////////////
+// Swizzle operators
+
+// User defines: GLM_SWIZZLE
+
+#if defined(GLM_MESSAGES) && !defined(GLM_MESSAGE_SWIZZLE_DISPLAYED)
+#	define GLM_MESSAGE_SWIZZLE_DISPLAYED
+#	if defined(GLM_SWIZZLE)
+#		pragma message("GLM: Swizzling operators enabled")
+#	else
+#		pragma message("GLM: Swizzling operators disabled, #define GLM_SWIZZLE to enable swizzle operators")
+#	endif
+#endif//GLM_MESSAGE
+
+///////////////////////////////////////////////////////////////////////////////////
+// Qualifiers
+
+#if (GLM_COMPILER & GLM_COMPILER_VC) || ((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_PLATFORM & GLM_PLATFORM_WINDOWS))
+#	define GLM_DEPRECATED __declspec(deprecated)
+#	define GLM_ALIGN(x) __declspec(align(x))
+#	define GLM_ALIGNED_STRUCT(x) struct __declspec(align(x))
+#	define GLM_ALIGNED_TYPEDEF(type, name, alignment) typedef __declspec(align(alignment)) type name
+#	define GLM_RESTRICT __declspec(restrict)
+#	define GLM_RESTRICT_VAR __restrict
+#elif GLM_COMPILER & (GLM_COMPILER_GCC | GLM_COMPILER_APPLE_CLANG | GLM_COMPILER_LLVM | GLM_COMPILER_CUDA | GLM_COMPILER_INTEL)
+#	define GLM_DEPRECATED __attribute__((__deprecated__))
+#	define GLM_ALIGN(x) __attribute__((aligned(x)))
+#	define GLM_ALIGNED_STRUCT(x) struct __attribute__((aligned(x)))
+#	define GLM_ALIGNED_TYPEDEF(type, name, alignment) typedef type name __attribute__((aligned(alignment)))
+#	define GLM_RESTRICT __restrict__
+#	define GLM_RESTRICT_VAR __restrict__
+#else
+#	define GLM_DEPRECATED
+#	define GLM_ALIGN
+#	define GLM_ALIGNED_STRUCT(x) struct
+#	define GLM_ALIGNED_TYPEDEF(type, name, alignment) typedef type name
+#	define GLM_RESTRICT
+#	define GLM_RESTRICT_VAR
+#endif//GLM_COMPILER
+
+#if GLM_HAS_CONSTEXPR
+#	define GLM_CONSTEXPR constexpr
+#else
+#	define GLM_CONSTEXPR
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////
+// Length type
+
+// User defines: GLM_FORCE_SIZE_T_LENGTH GLM_FORCE_SIZE_FUNC
+
+namespace glm
+{
+	using std::size_t;
+#	if defined(GLM_FORCE_SIZE_T_LENGTH) || defined(GLM_FORCE_SIZE_FUNC)
+		typedef size_t length_t;
+#	else
+		typedef int length_t;
+#	endif
+
+namespace detail
+{
+#	ifdef GLM_FORCE_SIZE_FUNC
+		typedef size_t component_count_t;
+#	else
+		typedef length_t component_count_t;
+#	endif
+
+	template <typename genType>
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR component_count_t component_count(genType const & m)
+	{
+#		ifdef GLM_FORCE_SIZE_FUNC
+			return m.size();
+#		else
+			return m.length();
+#		endif
+	}
+}//namespace detail
+}//namespace glm
+
+#if defined(GLM_MESSAGES) && !defined(GLM_MESSAGE_FORCE_SIZE_T_LENGTH)
+#	define GLM_MESSAGE_FORCE_SIZE_T_LENGTH
+#	if defined GLM_FORCE_SIZE_FUNC
+#		pragma message("GLM: .length() is replaced by .size() and returns a std::size_t")
+#	elif defined GLM_FORCE_SIZE_T_LENGTH
+#		pragma message("GLM: .length() returns glm::length_t, a typedef of std::size_t")
+#	else
+#		pragma message("GLM: .length() returns glm::length_t, a typedef of int following the GLSL specification")
+#	endif
+#endif//GLM_MESSAGE
+
+///////////////////////////////////////////////////////////////////////////////////
+// countof
+
+#ifndef __has_feature
+#	define __has_feature(x) 0 // Compatibility with non-clang compilers.
+#endif
+
+#if GLM_HAS_CONSTEXPR_PARTIAL
+	namespace glm
+	{
+		template <typename T, std::size_t N>
+		constexpr std::size_t countof(T const (&)[N])
+		{
+			return N;
+		}
+	}//namespace glm
+#	define GLM_COUNTOF(arr) glm::countof(arr)
+#elif _MSC_VER
+#	define GLM_COUNTOF(arr) _countof(arr)
+#else
+#	define GLM_COUNTOF(arr) sizeof(arr) / sizeof(arr[0])
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////
+// Uninitialize constructors
+
+namespace glm
+{
+	enum ctor{uninitialize};
+}//namespace glm

glm/glm/detail/type_float.hpp

@@ -0,0 +1,96 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net)
+/// Permission is hereby granted, free of charge, to any person obtaining a copy
+/// of this software and associated documentation files (the "Software"), to deal
+/// in the Software without restriction, including without limitation the rights
+/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+/// copies of the Software, and to permit persons to whom the Software is
+/// furnished to do so, subject to the following conditions:
+/// 
+/// The above copyright notice and this permission notice shall be included in
+/// all copies or substantial portions of the Software.
+/// 
+/// Restrictions:
+///		By making use of the Software for military purposes, you choose to make
+///		a Bunny unhappy.
+/// 
+/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+/// THE SOFTWARE.
+///
+/// @ref core
+/// @file glm/detail/type_float.hpp
+/// @date 2008-08-22 / 2011-06-15
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#pragma once
+
+#include "setup.hpp"
+
+namespace glm{
+namespace detail
+{
+	typedef float				float32;
+	typedef double				float64;
+}//namespace detail
+	
+	typedef float				lowp_float_t;
+	typedef float				mediump_float_t;
+	typedef double				highp_float_t;
+
+	/// @addtogroup core_precision
+	/// @{
+
+	/// Low precision floating-point numbers. 
+	/// There is no guarantee on the actual precision.
+	/// 
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.4 Floats</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef lowp_float_t		lowp_float;
+
+	/// Medium precision floating-point numbers.
+	/// There is no guarantee on the actual precision.
+	/// 
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.4 Floats</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef mediump_float_t		mediump_float;
+
+	/// High precision floating-point numbers.
+	/// There is no guarantee on the actual precision.
+	/// 
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.4 Floats</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef highp_float_t		highp_float;
+
+#if(!defined(GLM_PRECISION_HIGHP_FLOAT) && !defined(GLM_PRECISION_MEDIUMP_FLOAT) && !defined(GLM_PRECISION_LOWP_FLOAT))
+	typedef mediump_float		float_t;
+#elif(defined(GLM_PRECISION_HIGHP_FLOAT) && !defined(GLM_PRECISION_MEDIUMP_FLOAT) && !defined(GLM_PRECISION_LOWP_FLOAT))
+	typedef highp_float			float_t;
+#elif(!defined(GLM_PRECISION_HIGHP_FLOAT) && defined(GLM_PRECISION_MEDIUMP_FLOAT) && !defined(GLM_PRECISION_LOWP_FLOAT))
+	typedef mediump_float		float_t;
+#elif(!defined(GLM_PRECISION_HIGHP_FLOAT) && !defined(GLM_PRECISION_MEDIUMP_FLOAT) && defined(GLM_PRECISION_LOWP_FLOAT))
+	typedef lowp_float			float_t;
+#else
+#	error "GLM error: multiple default precision requested for floating-point types"
+#endif
+
+	typedef float				float32;
+	typedef double				float64;
+
+////////////////////
+// check type sizes
+#ifndef GLM_STATIC_ASSERT_NULL
+	GLM_STATIC_ASSERT(sizeof(glm::float32) == 4, "float32 size isn't 4 bytes on this platform");
+	GLM_STATIC_ASSERT(sizeof(glm::float64) == 8, "float64 size isn't 8 bytes on this platform");
+#endif//GLM_STATIC_ASSERT_NULL
+
+	/// @}
+
+}//namespace glm

glm/glm/detail/type_gentype.hpp

@@ -0,0 +1,224 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// 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.
+///
+/// @ref core
+/// @file glm/detail/type_gentype.hpp
+/// @date 2008-10-05 / 2011-06-15
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#pragma once
+
+namespace glm
+{
+	enum profile
+	{
+		nice,
+		fast,
+		simd
+	};
+
+	typedef std::size_t sizeType;
+	
+namespace detail
+{
+	template
+	<
+		typename VALTYPE, 
+		template <typename> class TYPE
+	>
+	struct genType
+	{
+	public:
+		enum ctor{null};
+
+		typedef VALTYPE value_type;
+		typedef VALTYPE & value_reference;
+		typedef VALTYPE * value_pointer;
+		typedef VALTYPE const * value_const_pointer;
+		typedef TYPE<bool> bool_type;
+
+		typedef sizeType size_type;
+		static bool is_vector();
+		static bool is_matrix();
+		
+		typedef TYPE<VALTYPE> type;
+		typedef TYPE<VALTYPE> * pointer;
+		typedef TYPE<VALTYPE> const * const_pointer;
+		typedef TYPE<VALTYPE> const * const const_pointer_const;
+		typedef TYPE<VALTYPE> * const pointer_const;
+		typedef TYPE<VALTYPE> & reference;
+		typedef TYPE<VALTYPE> const & const_reference;
+		typedef TYPE<VALTYPE> const & param_type;
+
+		//////////////////////////////////////
+		// Address (Implementation details)
+
+		value_const_pointer value_address() const{return value_pointer(this);}
+		value_pointer value_address(){return value_pointer(this);}
+
+	//protected:
+	//	enum kind
+	//	{
+	//		GEN_TYPE,
+	//		VEC_TYPE,
+	//		MAT_TYPE
+	//	};
+
+	//	typedef typename TYPE::kind kind;
+	};
+
+	template
+	<
+		typename VALTYPE, 
+		template <typename> class TYPE
+	>
+	bool genType<VALTYPE, TYPE>::is_vector()
+	{
+		return true;
+	}
+/*
+	template <typename valTypeT, unsigned int colT, unsigned int rowT, profile proT = nice>
+	class base
+	{
+	public:
+		//////////////////////////////////////
+		// Traits
+
+		typedef sizeType							size_type;
+		typedef valTypeT							value_type;
+
+		typedef base<value_type, colT, rowT>		class_type;
+
+		typedef base<bool, colT, rowT>				bool_type;
+		typedef base<value_type, rowT, 1>			col_type;
+		typedef base<value_type, colT, 1>			row_type;
+		typedef base<value_type, rowT, colT>		transpose_type;
+
+		static size_type							col_size();
+		static size_type							row_size();
+		static size_type							value_size();
+		static bool									is_scalar();
+		static bool									is_vector();
+		static bool									is_matrix();
+
+	private:
+		// Data 
+		col_type value[colT];		
+
+	public:
+		//////////////////////////////////////
+		// Constructors
+		base();
+		base(class_type const & m);
+
+		explicit base(T const & x);
+		explicit base(value_type const * const x);
+		explicit base(col_type const * const x);
+
+		//////////////////////////////////////
+		// Conversions
+		template <typename vU, uint cU, uint rU, profile pU>
+		explicit base(base<vU, cU, rU, pU> const & m);
+
+		//////////////////////////////////////
+		// Accesses
+		col_type& operator[](size_type i);
+		col_type const & operator[](size_type i) const;
+
+		//////////////////////////////////////
+		// Unary updatable operators
+		class_type& operator=  (class_type const & x);
+		class_type& operator+= (T const & x);
+		class_type& operator+= (class_type const & x);
+		class_type& operator-= (T const & x);
+		class_type& operator-= (class_type const & x);
+		class_type& operator*= (T const & x);
+		class_type& operator*= (class_type const & x);
+		class_type& operator/= (T const & x);
+		class_type& operator/= (class_type const & x);
+		class_type& operator++ ();
+		class_type& operator-- ();
+	};
+*/
+	
+	//template <typename T>
+	//struct traits
+	//{
+	//	static const bool is_signed = false;
+	//	static const bool is_float = false;
+	//	static const bool is_vector = false;
+	//	static const bool is_matrix = false;
+	//	static const bool is_genType = false;
+	//	static const bool is_genIType = false;
+	//	static const bool is_genUType = false;
+	//};
+	
+	//template <>
+	//struct traits<half>
+	//{
+	//	static const bool is_float = true;
+	//	static const bool is_genType = true;
+	//};
+	
+	//template <>
+	//struct traits<float>
+	//{
+	//	static const bool is_float = true;
+	//	static const bool is_genType = true;
+	//};
+	
+	//template <>
+	//struct traits<double>
+	//{
+	//	static const bool is_float = true;
+	//	static const bool is_genType = true;
+	//};
+	
+	//template <typename genType>
+	//struct desc
+	//{
+	//	typedef genType							type;
+	//	typedef genType *						pointer;
+	//	typedef genType const*					const_pointer;
+	//	typedef genType const *const			const_pointer_const;
+	//	typedef genType *const					pointer_const;
+	//	typedef genType &						reference;
+	//	typedef genType const&					const_reference;
+	//	typedef genType const&					param_type;
+	
+	//	typedef typename genType::value_type	value_type;
+	//	typedef typename genType::size_type		size_type;
+	//	static const typename size_type			value_size;
+	//};
+	
+	//template <typename genType>
+	//const typename desc<genType>::size_type desc<genType>::value_size = genType::value_size();
+	
+}//namespace detail
+}//namespace glm
+
+//#include "type_gentype.inl"

glm/glm/detail/type_gentype.inl

@@ -0,0 +1,370 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// 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.
+///
+/// @ref core
+/// @file glm/detail/type_gentype.inl
+/// @date 2008-10-05 / 2011-06-15
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+namespace glm{
+namespace detail{
+
+/////////////////////////////////
+// Static functions
+
+template <typename vT, uint cT, uint rT, profile pT>
+typename base<vT, cT, rT, pT>::size_type base<vT, cT, rT, pT>::col_size()
+{
+	return cT;
+}
+
+template <typename vT, uint cT, uint rT, profile pT>
+typename base<vT, cT, rT, pT>::size_type base<vT, cT, rT, pT>::row_size()
+{
+	return rT;
+}
+
+template <typename vT, uint cT, uint rT, profile pT>
+typename base<vT, cT, rT, pT>::size_type base<vT, cT, rT, pT>::value_size()
+{
+	return rT * cT;
+}
+
+template <typename vT, uint cT, uint rT, profile pT>
+bool base<vT, cT, rT, pT>::is_scalar()
+{
+	return rT == 1 && cT == 1;
+}
+
+template <typename vT, uint cT, uint rT, profile pT>
+bool base<vT, cT, rT, pT>::is_vector()
+{
+	return rT == 1;
+}
+
+template <typename vT, uint cT, uint rT, profile pT>
+bool base<vT, cT, rT, pT>::is_matrix()
+{
+	return rT != 1;
+}
+
+/////////////////////////////////
+// Constructor
+
+template <typename vT, uint cT, uint rT, profile pT>
+base<vT, cT, rT, pT>::base()
+{
+	memset(&this->value, 0, cT * rT * sizeof(vT));
+}
+
+template <typename vT, uint cT, uint rT, profile pT>
+base<vT, cT, rT, pT>::base
+(
+	typename base<vT, cT, rT, pT>::class_type const & m
+)
+{
+	for
+	(
+		typename genType<vT, cT, rT, pT>::size_type i = typename base<vT, cT, rT, pT>::size_type(0);
+		i < base<vT, cT, rT, pT>::col_size();
+		++i
+	)
+	{
+		this->value[i] = m[i];
+	}
+}
+
+template <typename vT, uint cT, uint rT, profile pT>
+base<vT, cT, rT, pT>::base
+(
+	typename base<vT, cT, rT, pT>::T const & x
+)
+{
+	if(rT == 1) // vector
+	{
+		for
+		(
+			typename base<vT, cT, rT, pT>::size_type i = typename base<vT, cT, rT, pT>::size_type(0);
+			i < base<vT, cT, rT, pT>::col_size();
+			++i
+		)
+		{
+			this->value[i][rT] = x;
+		}
+	}
+	else // matrix
+	{
+		memset(&this->value, 0, cT * rT * sizeof(vT));
+
+		typename base<vT, cT, rT, pT>::size_type stop = cT < rT ? cT : rT;
+
+		for
+		(
+			typename base<vT, cT, rT, pT>::size_type i = typename base<vT, cT, rT, pT>::size_type(0);
+			i < stop;
+			++i
+		)
+		{
+			this->value[i][i] = x;
+		}
+	}
+}
+
+template <typename vT, uint cT, uint rT, profile pT>
+base<vT, cT, rT, pT>::base
+(
+	typename base<vT, cT, rT, pT>::value_type const * const x
+)
+{
+	memcpy(&this->value, &x.value, cT * rT * sizeof(vT));
+}
+
+template <typename vT, uint cT, uint rT, profile pT>
+base<vT, cT, rT, pT>::base
+(
+	typename base<vT, cT, rT, pT>::col_type const * const x
+)
+{
+	for
+	(
+		typename base<vT, cT, rT, pT>::size_type i = typename base<vT, cT, rT, pT>::size_type(0);
+		i < base<vT, cT, rT, pT>::col_size();
+		++i
+	)
+	{
+		this->value[i] = x[i];
+	}
+}
+
+template <typename vT, uint cT, uint rT, profile pT>
+template <typename vU, uint cU, uint rU, profile pU>
+base<vT, cT, rT, pT>::base
+(
+	base<vU, cU, rU, pU> const & m
+)
+{
+	for
+	(
+		typename base<vT, cT, rT, pT>::size_type i = typename base<vT, cT, rT, pT>::size_type(0);
+		i < base<vT, cT, rT, pT>::col_size();
+		++i
+	)
+	{
+		this->value[i] = base<vT, cT, rT, pT>(m[i]);
+	}
+}
+
+//////////////////////////////////////
+// Accesses
+
+template <typename vT, uint cT, uint rT, profile pT>
+typename base<vT, cT, rT, pT>::col_type& base<vT, cT, rT, pT>::operator[]
+(
+	typename base<vT, cT, rT, pT>::size_type i
+)
+{
+	return this->value[i];
+}
+
+template <typename vT, uint cT, uint rT, profile pT>
+typename base<vT, cT, rT, pT>::col_type const & base<vT, cT, rT, pT>::operator[]
+(
+	typename base<vT, cT, rT, pT>::size_type i
+) const
+{
+	return this->value[i];
+}
+
+//////////////////////////////////////
+// Unary updatable operators
+
+template <typename vT, uint cT, uint rT, profile pT>
+typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator= 
+(
+	typename base<vT, cT, rT, pT>::class_type const & x
+)
+{
+	memcpy(&this->value, &x.value, cT * rT * sizeof(vT));
+	return *this;
+}
+
+template <typename vT, uint cT, uint rT, profile pT>
+typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator+= 
+(
+	typename base<vT, cT, rT, pT>::T const & x
+)
+{
+	typename base<vT, cT, rT, pT>::size_type stop_col = x.col_size();
+	typename base<vT, cT, rT, pT>::size_type stop_row = x.row_size();
+
+	for(typename base<vT, cT, rT, pT>::size_type j = 0; j < stop_col; ++j)
+	for(typename base<vT, cT, rT, pT>::size_type i = 0; i < stop_row; ++i)
+		this->value[j][i] += x;
+
+	return *this;
+}
+
+template <typename vT, uint cT, uint rT, profile pT>
+typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator+= 
+(
+	typename base<vT, cT, rT, pT>::class_type const & x
+)
+{
+	typename base<vT, cT, rT, pT>::size_type stop_col = x.col_size();
+	typename base<vT, cT, rT, pT>::size_type stop_row = x.row_size();
+
+	for(typename base<vT, cT, rT, pT>::size_type j = 0; j < stop_col; ++j)
+	for(typename base<vT, cT, rT, pT>::size_type i = 0; i < stop_row; ++i)
+		this->value[j][i] += x[j][i];
+
+	return *this;
+}
+
+template <typename vT, uint cT, uint rT, profile pT>
+typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator-= 
+(
+	typename base<vT, cT, rT, pT>::T const & x
+)
+{
+	typename base<vT, cT, rT, pT>::size_type stop_col = x.col_size();
+	typename base<vT, cT, rT, pT>::size_type stop_row = x.row_size();
+
+	for(typename base<vT, cT, rT, pT>::size_type j = 0; j < stop_col; ++j)
+	for(typename base<vT, cT, rT, pT>::size_type i = 0; i < stop_row; ++i)
+		this->value[j][i] -= x;
+
+	return *this;
+}
+
+template <typename vT, uint cT, uint rT, profile pT>
+typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator-= 
+(
+	typename base<vT, cT, rT, pT>::class_type const & x
+)
+{
+	typename base<vT, cT, rT, pT>::size_type stop_col = x.col_size();
+	typename base<vT, cT, rT, pT>::size_type stop_row = x.row_size();
+
+	for(typename base<vT, cT, rT, pT>::size_type j = 0; j < stop_col; ++j)
+	for(typename base<vT, cT, rT, pT>::size_type i = 0; i < stop_row; ++i)
+		this->value[j][i] -= x[j][i];
+
+	return *this;
+}
+
+template <typename vT, uint cT, uint rT, profile pT>
+typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator*= 
+(
+	typename base<vT, cT, rT, pT>::T const & x
+)
+{
+	typename base<vT, cT, rT, pT>::size_type stop_col = x.col_size();
+	typename base<vT, cT, rT, pT>::size_type stop_row = x.row_size();
+
+	for(typename base<vT, cT, rT, pT>::size_type j = 0; j < stop_col; ++j)
+	for(typename base<vT, cT, rT, pT>::size_type i = 0; i < stop_row; ++i)
+		this->value[j][i] *= x;
+
+	return *this;
+}
+
+template <typename vT, uint cT, uint rT, profile pT>
+typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator*= 
+(
+	typename base<vT, cT, rT, pT>::class_type const & x
+)
+{
+	typename base<vT, cT, rT, pT>::size_type stop_col = x.col_size();
+	typename base<vT, cT, rT, pT>::size_type stop_row = x.row_size();
+
+	for(typename base<vT, cT, rT, pT>::size_type j = 0; j < stop_col; ++j)
+	for(typename base<vT, cT, rT, pT>::size_type i = 0; i < stop_row; ++i)
+		this->value[j][i] *= x[j][i];
+
+	return *this;
+}
+
+template <typename vT, uint cT, uint rT, profile pT>
+typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator/= 
+(
+	typename base<vT, cT, rT, pT>::T const & x
+)
+{
+	typename base<vT, cT, rT, pT>::size_type stop_col = x.col_size();
+	typename base<vT, cT, rT, pT>::size_type stop_row = x.row_size();
+
+	for(typename base<vT, cT, rT, pT>::size_type j = 0; j < stop_col; ++j)
+	for(typename base<vT, cT, rT, pT>::size_type i = 0; i < stop_row; ++i)
+		this->value[j][i] /= x;
+
+	return *this;
+}
+
+template <typename vT, uint cT, uint rT, profile pT>
+typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator/= 
+(
+	typename base<vT, cT, rT, pT>::class_type const & x
+)
+{
+	typename base<vT, cT, rT, pT>::size_type stop_col = x.col_size();
+	typename base<vT, cT, rT, pT>::size_type stop_row = x.row_size();
+
+	for(typename base<vT, cT, rT, pT>::size_type j = 0; j < stop_col; ++j)
+	for(typename base<vT, cT, rT, pT>::size_type i = 0; i < stop_row; ++i)
+		this->value[j][i] /= x[j][i];
+
+	return *this;
+}
+
+template <typename vT, uint cT, uint rT, profile pT>
+typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator++ ()
+{
+	typename base<vT, cT, rT, pT>::size_type stop_col = col_size();
+	typename base<vT, cT, rT, pT>::size_type stop_row = row_size();
+
+	for(typename base<vT, cT, rT, pT>::size_type j = 0; j < stop_col; ++j)
+	for(typename base<vT, cT, rT, pT>::size_type i = 0; i < stop_row; ++i)
+		++this->value[j][i];
+
+	return *this;
+}
+
+template <typename vT, uint cT, uint rT, profile pT>
+typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator-- ()
+{
+	typename base<vT, cT, rT, pT>::size_type stop_col = col_size();
+	typename base<vT, cT, rT, pT>::size_type stop_row = row_size();
+
+	for(typename base<vT, cT, rT, pT>::size_type j = 0; j < stop_col; ++j)
+	for(typename base<vT, cT, rT, pT>::size_type i = 0; i < stop_row; ++i)
+		--this->value[j][i];
+
+	return *this;
+}
+
+} //namespace detail
+} //namespace glm

glm/glm/detail/type_half.hpp

@@ -0,0 +1,48 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// 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.
+///
+/// @ref core
+/// @file glm/detail/type_half.hpp
+/// @date 2008-08-17 / 2011-09-20
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#pragma once
+
+#include "setup.hpp"
+
+namespace glm{
+namespace detail
+{
+	typedef short hdata;
+
+	GLM_FUNC_DECL float toFloat32(hdata value);
+	GLM_FUNC_DECL hdata toFloat16(float const & value);
+
+}//namespace detail
+}//namespace glm
+
+#include "type_half.inl"

glm/glm/detail/type_half.inl

@@ -0,0 +1,277 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net)
+///
+/// This half implementation is based on OpenEXR which is Copyright (c) 2002, 
+/// Industrial Light & Magic, a division of Lucas Digital Ltd. LLC
+///
+/// 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.
+///
+/// @ref core
+/// @file glm/detail/type_half.inl
+/// @date 2008-08-17 / 2011-06-15
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+namespace glm{
+namespace detail
+{
+	GLM_FUNC_QUALIFIER float overflow()
+	{
+		volatile float f = 1e10;
+
+		for(int i = 0; i < 10; ++i)	
+			f *= f; // this will overflow before the for loop terminates
+		return f;
+	}
+
+	union uif32
+	{
+		GLM_FUNC_QUALIFIER uif32() :
+			i(0)
+		{}
+
+		GLM_FUNC_QUALIFIER uif32(float f) :
+			f(f)
+		{}
+
+		GLM_FUNC_QUALIFIER uif32(uint32 i) :
+			i(i)
+		{}
+
+		float f;
+		uint32 i;
+	};
+
+	GLM_FUNC_QUALIFIER float toFloat32(hdata value)
+	{
+		int s = (value >> 15) & 0x00000001;
+		int e = (value >> 10) & 0x0000001f;
+		int m =  value        & 0x000003ff;
+
+		if(e == 0)
+		{
+			if(m == 0)
+			{
+				//
+				// Plus or minus zero
+				//
+
+				detail::uif32 result;
+				result.i = (unsigned int)(s << 31);
+				return result.f;
+			}
+			else
+			{
+				//
+				// Denormalized number -- renormalize it
+				//
+
+				while(!(m & 0x00000400))
+				{
+					m <<= 1;
+					e -=  1;
+				}
+
+				e += 1;
+				m &= ~0x00000400;
+			}
+		}
+		else if(e == 31)
+		{
+			if(m == 0)
+			{
+				//
+				// Positive or negative infinity
+				//
+
+				uif32 result;
+				result.i = (unsigned int)((s << 31) | 0x7f800000);
+				return result.f;
+			}
+			else
+			{
+				//
+				// Nan -- preserve sign and significand bits
+				//
+
+				uif32 result;
+				result.i = (unsigned int)((s << 31) | 0x7f800000 | (m << 13));
+				return result.f;
+			}
+		}
+
+		//
+		// Normalized number
+		//
+
+		e = e + (127 - 15);
+		m = m << 13;
+
+		//
+		// Assemble s, e and m.
+		//
+
+		uif32 Result;
+		Result.i = (unsigned int)((s << 31) | (e << 23) | m);
+		return Result.f;
+	}
+
+	GLM_FUNC_QUALIFIER hdata toFloat16(float const & f)
+	{
+		uif32 Entry;
+		Entry.f = f;
+		int i = (int)Entry.i;
+
+		//
+		// Our floating point number, f, is represented by the bit
+		// pattern in integer i.  Disassemble that bit pattern into
+		// the sign, s, the exponent, e, and the significand, m.
+		// Shift s into the position where it will go in in the
+		// resulting half number.
+		// Adjust e, accounting for the different exponent bias
+		// of float and half (127 versus 15).
+		//
+
+		int s =  (i >> 16) & 0x00008000;
+		int e = ((i >> 23) & 0x000000ff) - (127 - 15);
+		int m =   i        & 0x007fffff;
+
+		//
+		// Now reassemble s, e and m into a half:
+		//
+
+		if(e <= 0)
+		{
+			if(e < -10)
+			{
+				//
+				// E is less than -10.  The absolute value of f is
+				// less than half_MIN (f may be a small normalized
+				// float, a denormalized float or a zero).
+				//
+				// We convert f to a half zero.
+				//
+
+				return hdata(s);
+			}
+
+			//
+			// E is between -10 and 0.  F is a normalized float,
+			// whose magnitude is less than __half_NRM_MIN.
+			//
+			// We convert f to a denormalized half.
+			// 
+
+			m = (m | 0x00800000) >> (1 - e);
+
+			//
+			// Round to nearest, round "0.5" up.
+			//
+			// Rounding may cause the significand to overflow and make
+			// our number normalized.  Because of the way a half's bits
+			// are laid out, we don't have to treat this case separately;
+			// the code below will handle it correctly.
+			// 
+
+			if(m & 0x00001000) 
+				m += 0x00002000;
+
+			//
+			// Assemble the half from s, e (zero) and m.
+			//
+
+			return hdata(s | (m >> 13));
+		}
+		else if(e == 0xff - (127 - 15))
+		{
+			if(m == 0)
+			{
+				//
+				// F is an infinity; convert f to a half
+				// infinity with the same sign as f.
+				//
+
+				return hdata(s | 0x7c00);
+			}
+			else
+			{
+				//
+				// F is a NAN; we produce a half NAN that preserves
+				// the sign bit and the 10 leftmost bits of the
+				// significand of f, with one exception: If the 10
+				// leftmost bits are all zero, the NAN would turn 
+				// into an infinity, so we have to set at least one
+				// bit in the significand.
+				//
+
+				m >>= 13;
+
+				return hdata(s | 0x7c00 | m | (m == 0));
+			}
+		}
+		else
+		{
+			//
+			// E is greater than zero.  F is a normalized float.
+			// We try to convert f to a normalized half.
+			//
+
+			//
+			// Round to nearest, round "0.5" up
+			//
+
+			if(m &  0x00001000)
+			{
+				m += 0x00002000;
+
+				if(m & 0x00800000)
+				{
+					m =  0;     // overflow in significand,
+					e += 1;     // adjust exponent
+				}
+			}
+
+			//
+			// Handle exponent overflow
+			//
+
+			if (e > 30)
+			{
+				overflow();        // Cause a hardware floating point overflow;
+
+				return hdata(s | 0x7c00);
+				// if this returns, the half becomes an
+			}   // infinity with the same sign as f.
+
+			//
+			// Assemble the half from s, e and m.
+			//
+
+			return hdata(s | (e << 10) | (m >> 13));
+		}
+	}
+
+}//namespace detail
+}//namespace glm

glm/glm/detail/type_int.hpp

@@ -0,0 +1,326 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// 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.
+///
+/// @ref core
+/// @file glm/detail/type_int.hpp
+/// @date 2008-08-22 / 2013-03-30
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#pragma once
+
+#include "setup.hpp"
+#if GLM_HAS_MAKE_SIGNED
+#	include <type_traits>
+#endif
+
+#if GLM_HAS_EXTENDED_INTEGER_TYPE
+#	include <cstdint>
+#endif
+
+namespace glm{
+namespace detail
+{
+#	if GLM_HAS_EXTENDED_INTEGER_TYPE
+		typedef std::int8_t					int8;
+		typedef std::int16_t				int16;
+		typedef std::int32_t				int32;
+		typedef std::int64_t				int64;
+	
+		typedef std::uint8_t				uint8;
+		typedef std::uint16_t				uint16;
+		typedef std::uint32_t				uint32;
+		typedef std::uint64_t				uint64;
+#	else
+#		if(defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) // C99 detected, 64 bit types available
+			typedef int64_t					sint64;
+			typedef uint64_t				uint64;
+#		elif GLM_COMPILER & GLM_COMPILER_VC
+			typedef signed __int64			sint64;
+			typedef unsigned __int64		uint64;
+#		elif GLM_COMPILER & GLM_COMPILER_GCC
+			__extension__ typedef signed long long		sint64;
+			__extension__ typedef unsigned long long	uint64;
+#		else//unknown compiler
+			typedef signed long	long		sint64;
+			typedef unsigned long long		uint64;
+#		endif//GLM_COMPILER
+		
+		typedef signed char					int8;
+		typedef signed short				int16;
+		typedef signed int					int32;
+		typedef sint64						int64;
+	
+		typedef unsigned char				uint8;
+		typedef unsigned short				uint16;
+		typedef unsigned int				uint32;
+		typedef uint64						uint64;
+#endif//
+	
+	typedef signed int						lowp_int_t;
+	typedef signed int						mediump_int_t;
+	typedef signed int						highp_int_t;
+	
+	typedef unsigned int					lowp_uint_t;
+	typedef unsigned int					mediump_uint_t;
+	typedef unsigned int					highp_uint_t;
+
+#	if GLM_HAS_MAKE_SIGNED
+		using std::make_signed;
+		using std::make_unsigned;
+
+#	else//GLM_HAS_MAKE_SIGNED
+		template <typename genType>
+		struct make_signed
+		{};
+
+		template <>
+		struct make_signed<char>
+		{
+			typedef char type;
+		};
+
+		template <>
+		struct make_signed<short>
+		{
+			typedef short type;
+		};
+
+		template <>
+		struct make_signed<int>
+		{
+			typedef int type;
+		};
+
+		template <>
+		struct make_signed<long>
+		{
+			typedef long type;
+		};
+
+		template <>
+		struct make_signed<long long>
+		{
+			typedef long long type;
+		};
+
+		template <>
+		struct make_signed<unsigned char>
+		{
+			typedef char type;
+		};
+
+		template <>
+		struct make_signed<unsigned short>
+		{
+			typedef short type;
+		};
+
+		template <>
+		struct make_signed<unsigned int>
+		{
+			typedef int type;
+		};
+
+		template <>
+		struct make_signed<unsigned long>
+		{
+			typedef long type;
+		};
+
+		template <>
+		struct make_signed<unsigned long long>
+		{
+			typedef long long type;
+		};
+
+		template <typename genType>
+		struct make_unsigned
+		{};
+
+		template <>
+		struct make_unsigned<char>
+		{
+			typedef unsigned char type;
+		};
+
+		template <>
+		struct make_unsigned<short>
+		{
+			typedef unsigned short type;
+		};
+
+		template <>
+		struct make_unsigned<int>
+		{
+			typedef unsigned int type;
+		};
+
+		template <>
+		struct make_unsigned<long>
+		{
+			typedef unsigned long type;
+		};
+
+		template <>
+		struct make_unsigned<long long>
+		{
+			typedef unsigned long long type;
+		};
+
+		template <>
+		struct make_unsigned<unsigned char>
+		{
+			typedef unsigned char type;
+		};
+
+		template <>
+		struct make_unsigned<unsigned short>
+		{
+			typedef unsigned short type;
+		};
+
+		template <>
+		struct make_unsigned<unsigned int>
+		{
+			typedef unsigned int type;
+		};
+
+		template <>
+		struct make_unsigned<unsigned long>
+		{
+			typedef unsigned long type;
+		};
+
+		template <>
+		struct make_unsigned<unsigned long long>
+		{
+			typedef unsigned long long type;
+		};
+#	endif//GLM_HAS_MAKE_SIGNED
+}//namespace detail
+
+	typedef detail::int8					int8;
+	typedef detail::int16					int16;
+	typedef detail::int32					int32;
+	typedef detail::int64					int64;
+	
+	typedef detail::uint8					uint8;
+	typedef detail::uint16					uint16;
+	typedef detail::uint32					uint32;
+	typedef detail::uint64					uint64;
+
+	/// @addtogroup core_precision
+	/// @{
+
+	/// Low precision signed integer. 
+	/// There is no guarantee on the actual precision.
+	/// 
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.3 Integers</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef detail::lowp_int_t				lowp_int;
+
+	/// Medium precision signed integer. 
+	/// There is no guarantee on the actual precision.
+	/// 
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.3 Integers</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef detail::mediump_int_t			mediump_int;
+
+	/// High precision signed integer.
+	/// There is no guarantee on the actual precision.
+	/// 
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.3 Integers</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef detail::highp_int_t				highp_int;
+
+	/// Low precision unsigned integer. 
+	/// There is no guarantee on the actual precision.
+	/// 
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.3 Integers</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef detail::lowp_uint_t				lowp_uint;
+
+	/// Medium precision unsigned integer. 
+	/// There is no guarantee on the actual precision.
+	/// 
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.3 Integers</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef detail::mediump_uint_t			mediump_uint;
+
+	/// High precision unsigned integer. 
+	/// There is no guarantee on the actual precision.
+	/// 
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.3 Integers</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef detail::highp_uint_t			highp_uint;
+
+#if(!defined(GLM_PRECISION_HIGHP_INT) && !defined(GLM_PRECISION_MEDIUMP_INT) && !defined(GLM_PRECISION_LOWP_INT))
+	typedef mediump_int					int_t;
+#elif(defined(GLM_PRECISION_HIGHP_INT) && !defined(GLM_PRECISION_MEDIUMP_INT) && !defined(GLM_PRECISION_LOWP_INT))
+	typedef highp_int					int_t;
+#elif(!defined(GLM_PRECISION_HIGHP_INT) && defined(GLM_PRECISION_MEDIUMP_INT) && !defined(GLM_PRECISION_LOWP_INT))
+	typedef mediump_int					int_t;
+#elif(!defined(GLM_PRECISION_HIGHP_INT) && !defined(GLM_PRECISION_MEDIUMP_INT) && defined(GLM_PRECISION_LOWP_INT))
+	typedef lowp_int					int_t;
+#else
+#	error "GLM error: multiple default precision requested for signed interger types"
+#endif
+
+#if(!defined(GLM_PRECISION_HIGHP_UINT) && !defined(GLM_PRECISION_MEDIUMP_UINT) && !defined(GLM_PRECISION_LOWP_UINT))
+	typedef mediump_uint				uint_t;
+#elif(defined(GLM_PRECISION_HIGHP_UINT) && !defined(GLM_PRECISION_MEDIUMP_UINT) && !defined(GLM_PRECISION_LOWP_UINT))
+	typedef highp_uint					uint_t;
+#elif(!defined(GLM_PRECISION_HIGHP_UINT) && defined(GLM_PRECISION_MEDIUMP_UINT) && !defined(GLM_PRECISION_LOWP_UINT))
+	typedef mediump_uint				uint_t;
+#elif(!defined(GLM_PRECISION_HIGHP_UINT) && !defined(GLM_PRECISION_MEDIUMP_UINT) && defined(GLM_PRECISION_LOWP_UINT))
+	typedef lowp_uint					uint_t;
+#else
+#	error "GLM error: multiple default precision requested for unsigned interger types"
+#endif
+
+	/// Unsigned integer type.
+	/// 
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.3 Integers</a>
+	typedef unsigned int				uint;
+
+	/// @}
+
+////////////////////
+// check type sizes
+#ifndef GLM_STATIC_ASSERT_NULL
+	GLM_STATIC_ASSERT(sizeof(glm::int8) == 1, "int8 size isn't 1 byte on this platform");
+	GLM_STATIC_ASSERT(sizeof(glm::int16) == 2, "int16 size isn't 2 bytes on this platform");
+	GLM_STATIC_ASSERT(sizeof(glm::int32) == 4, "int32 size isn't 4 bytes on this platform");
+	GLM_STATIC_ASSERT(sizeof(glm::int64) == 8, "int64 size isn't 8 bytes on this platform");
+
+	GLM_STATIC_ASSERT(sizeof(glm::uint8) == 1, "uint8 size isn't 1 byte on this platform");
+	GLM_STATIC_ASSERT(sizeof(glm::uint16) == 2, "uint16 size isn't 2 bytes on this platform");
+	GLM_STATIC_ASSERT(sizeof(glm::uint32) == 4, "uint32 size isn't 4 bytes on this platform");
+	GLM_STATIC_ASSERT(sizeof(glm::uint64) == 8, "uint64 size isn't 8 bytes on this platform");
+#endif//GLM_STATIC_ASSERT_NULL
+
+}//namespace glm

glm/glm/detail/type_mat.hpp

@@ -0,0 +1,793 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// 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.
+///
+/// @ref core
+/// @file glm/detail/type_mat.hpp
+/// @date 2010-01-26 / 2011-06-15
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#pragma once
+
+#include "precision.hpp"
+
+namespace glm{
+namespace detail
+{
+	template <typename T, precision P, template <class, precision> class colType, template <class, precision> class rowType>
+	struct outerProduct_trait{};
+}//namespace detail
+
+	template <typename T, precision P> struct tvec2;
+	template <typename T, precision P> struct tvec3;
+	template <typename T, precision P> struct tvec4;
+	template <typename T, precision P> struct tmat2x2;
+	template <typename T, precision P> struct tmat2x3;
+	template <typename T, precision P> struct tmat2x4;
+	template <typename T, precision P> struct tmat3x2;
+	template <typename T, precision P> struct tmat3x3;
+	template <typename T, precision P> struct tmat3x4;
+	template <typename T, precision P> struct tmat4x2;
+	template <typename T, precision P> struct tmat4x3;
+	template <typename T, precision P> struct tmat4x4;
+
+	/// @addtogroup core_precision
+	/// @{
+	
+	/// 2 columns of 2 components matrix of low precision floating-point numbers.
+	/// There is no guarantee on the actual precision.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef tmat2x2<float, lowp>		lowp_mat2;
+	
+	/// 2 columns of 2 components matrix of medium precision floating-point numbers.
+	/// There is no guarantee on the actual precision.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef tmat2x2<float, mediump>		mediump_mat2;
+	
+	/// 2 columns of 2 components matrix of high precision floating-point numbers.
+	/// There is no guarantee on the actual precision.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef tmat2x2<float, highp>		highp_mat2;
+	
+	/// 2 columns of 2 components matrix of low precision floating-point numbers.
+	/// There is no guarantee on the actual precision.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef tmat2x2<float, lowp>		lowp_mat2x2;
+	
+	/// 2 columns of 2 components matrix of medium precision floating-point numbers.
+	/// There is no guarantee on the actual precision.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef tmat2x2<float, mediump>		mediump_mat2x2;
+	
+	/// 2 columns of 2 components matrix of high precision floating-point numbers.
+	/// There is no guarantee on the actual precision.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef tmat2x2<float, highp>		highp_mat2x2;
+	
+	/// @}
+	
+	/// @addtogroup core_precision
+	/// @{
+	
+	/// 2 columns of 3 components matrix of low precision floating-point numbers.
+	/// There is no guarantee on the actual precision.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef tmat2x3<float, lowp>		lowp_mat2x3;
+	
+	/// 2 columns of 3 components matrix of medium precision floating-point numbers.
+	/// There is no guarantee on the actual precision.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef tmat2x3<float, mediump>		mediump_mat2x3;
+	
+	/// 2 columns of 3 components matrix of high precision floating-point numbers.
+	/// There is no guarantee on the actual precision.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef tmat2x3<float, highp>		highp_mat2x3;
+	
+	/// @}
+	
+	/// @addtogroup core_precision
+	/// @{
+	
+	/// 2 columns of 4 components matrix of low precision floating-point numbers.
+	/// There is no guarantee on the actual precision.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef tmat2x4<float, lowp>		lowp_mat2x4;
+	
+	/// 2 columns of 4 components matrix of medium precision floating-point numbers.
+	/// There is no guarantee on the actual precision.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef tmat2x4<float, mediump>		mediump_mat2x4;
+	
+	/// 2 columns of 4 components matrix of high precision floating-point numbers.
+	/// There is no guarantee on the actual precision.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef tmat2x4<float, highp>		highp_mat2x4;
+	
+	/// @}
+	
+	/// @addtogroup core_precision
+	/// @{
+	
+	/// 3 columns of 2 components matrix of low precision floating-point numbers.
+	/// There is no guarantee on the actual precision.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef tmat3x2<float, lowp>		lowp_mat3x2;
+	
+	/// 3 columns of 2 components matrix of medium precision floating-point numbers.
+	/// There is no guarantee on the actual precision.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef tmat3x2<float, mediump>		mediump_mat3x2;
+	
+	/// 3 columns of 2 components matrix of high precision floating-point numbers.
+	/// There is no guarantee on the actual precision.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef tmat3x2<float, highp>		highp_mat3x2;
+	
+	/// @}
+	
+	/// @addtogroup core_precision
+	/// @{
+	
+	/// 3 columns of 3 components matrix of low precision floating-point numbers.
+	/// There is no guarantee on the actual precision.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef tmat3x3<float, lowp>		lowp_mat3;
+	
+	/// 3 columns of 3 components matrix of medium precision floating-point numbers.
+	/// There is no guarantee on the actual precision.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef tmat3x3<float, mediump>		mediump_mat3;
+	
+	/// 3 columns of 3 components matrix of high precision floating-point numbers.
+	/// There is no guarantee on the actual precision.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef tmat3x3<float, highp>		highp_mat3;
+	
+	/// 3 columns of 3 components matrix of low precision floating-point numbers.
+	/// There is no guarantee on the actual precision.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef tmat3x3<float, lowp>		lowp_mat3x3;
+	
+	/// 3 columns of 3 components matrix of medium precision floating-point numbers.
+	/// There is no guarantee on the actual precision.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef tmat3x3<float, mediump>		mediump_mat3x3;
+	
+	/// 3 columns of 3 components matrix of high precision floating-point numbers.
+	/// There is no guarantee on the actual precision.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef tmat3x3<float, highp>		highp_mat3x3;
+	
+	/// @}
+	
+	/// @addtogroup core_precision
+	/// @{
+	
+	/// 3 columns of 4 components matrix of low precision floating-point numbers.
+	/// There is no guarantee on the actual precision.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef tmat3x4<float, lowp>		lowp_mat3x4;
+	
+	/// 3 columns of 4 components matrix of medium precision floating-point numbers.
+	/// There is no guarantee on the actual precision.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef tmat3x4<float, mediump>		mediump_mat3x4;
+	
+	/// 3 columns of 4 components matrix of high precision floating-point numbers.
+	/// There is no guarantee on the actual precision.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef tmat3x4<float, highp>		highp_mat3x4;
+	
+	/// @}
+	
+	/// @addtogroup core_precision
+	/// @{
+	
+	/// 4 columns of 2 components matrix of low precision floating-point numbers.
+	/// There is no guarantee on the actual precision.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef tmat4x2<float, lowp>		lowp_mat4x2;
+	
+	/// 4 columns of 2 components matrix of medium precision floating-point numbers.
+	/// There is no guarantee on the actual precision.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef tmat4x2<float, mediump>		mediump_mat4x2;
+	
+	/// 4 columns of 2 components matrix of high precision floating-point numbers.
+	/// There is no guarantee on the actual precision.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef tmat4x2<float, highp>		highp_mat4x2;
+	
+	/// @}
+	
+	/// @addtogroup core_precision
+	/// @{
+	
+	/// 4 columns of 3 components matrix of low precision floating-point numbers.
+	/// There is no guarantee on the actual precision.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef tmat4x3<float, lowp>		lowp_mat4x3;
+	
+	/// 4 columns of 3 components matrix of medium precision floating-point numbers.
+	/// There is no guarantee on the actual precision.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef tmat4x3<float, mediump>		mediump_mat4x3;
+	
+	/// 4 columns of 3 components matrix of high precision floating-point numbers.
+	/// There is no guarantee on the actual precision.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef tmat4x3<float, highp>		highp_mat4x3;
+	
+	/// @}
+	
+	
+	/// @addtogroup core_precision
+	/// @{
+	
+	/// 4 columns of 4 components matrix of low precision floating-point numbers.
+	/// There is no guarantee on the actual precision.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef tmat4x4<float, lowp>		lowp_mat4;
+	
+	/// 4 columns of 4 components matrix of medium precision floating-point numbers.
+	/// There is no guarantee on the actual precision.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef tmat4x4<float, mediump>		mediump_mat4;
+	
+	/// 4 columns of 4 components matrix of high precision floating-point numbers.
+	/// There is no guarantee on the actual precision.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef tmat4x4<float, highp>		highp_mat4;
+	
+	/// 4 columns of 4 components matrix of low precision floating-point numbers.
+	/// There is no guarantee on the actual precision.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef tmat4x4<float, lowp>		lowp_mat4x4;
+	
+	/// 4 columns of 4 components matrix of medium precision floating-point numbers.
+	/// There is no guarantee on the actual precision.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef tmat4x4<float, mediump>		mediump_mat4x4;
+	
+	/// 4 columns of 4 components matrix of high precision floating-point numbers.
+	/// There is no guarantee on the actual precision.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef tmat4x4<float, highp>		highp_mat4x4;
+	
+	/// @}
+	
+	/// @addtogroup core_types
+	/// @{
+	
+	//////////////////////////
+	// Float definition
+	
+#if(defined(GLM_PRECISION_LOWP_FLOAT))
+	typedef lowp_mat2x2			mat2x2;
+	typedef lowp_mat2x3			mat2x3;
+	typedef lowp_mat2x4			mat2x4;
+	typedef lowp_mat3x2			mat3x2;
+	typedef lowp_mat3x3			mat3x3;
+	typedef lowp_mat3x4			mat3x4;
+	typedef lowp_mat4x2			mat4x2;
+	typedef lowp_mat4x3			mat4x3;
+	typedef lowp_mat4x4			mat4x4;
+#elif(defined(GLM_PRECISION_MEDIUMP_FLOAT))
+	typedef mediump_mat2x2		mat2x2;
+	typedef mediump_mat2x3		mat2x3;
+	typedef mediump_mat2x4		mat2x4;
+	typedef mediump_mat3x2		mat3x2;
+	typedef mediump_mat3x3		mat3x3;
+	typedef mediump_mat3x4		mat3x4;
+	typedef mediump_mat4x2		mat4x2;
+	typedef mediump_mat4x3		mat4x3;
+	typedef mediump_mat4x4		mat4x4;
+#else	
+	//! 2 columns of 2 components matrix of floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	typedef highp_mat2x2			mat2x2;
+	
+	//! 2 columns of 3 components matrix of floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	typedef highp_mat2x3			mat2x3;
+	
+	//! 2 columns of 4 components matrix of floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	typedef highp_mat2x4			mat2x4;
+	
+	//! 3 columns of 2 components matrix of floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	typedef highp_mat3x2			mat3x2;
+	
+	//! 3 columns of 3 components matrix of floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	typedef highp_mat3x3			mat3x3;
+	
+	//! 3 columns of 4 components matrix of floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	typedef highp_mat3x4			mat3x4;
+	
+	//! 4 columns of 2 components matrix of floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	typedef highp_mat4x2			mat4x2;
+	
+	//! 4 columns of 3 components matrix of floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	typedef highp_mat4x3			mat4x3;
+	
+	//! 4 columns of 4 components matrix of floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	typedef highp_mat4x4			mat4x4;
+	
+#endif//GLM_PRECISION
+	
+	//! 2 columns of 2 components matrix of floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	typedef mat2x2					mat2;
+	
+	//! 3 columns of 3 components matrix of floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	typedef mat3x3					mat3;
+	
+	//! 4 columns of 4 components matrix of floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	typedef mat4x4					mat4;
+		
+	//////////////////////////
+	// Double definition
+	
+	/// @addtogroup core_precision
+	/// @{
+	
+	/// 2 columns of 2 components matrix of low precision floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef tmat2x2<double, lowp>		lowp_dmat2;
+	
+	/// 2 columns of 2 components matrix of medium precision floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef tmat2x2<double, mediump>	mediump_dmat2;
+	
+	/// 2 columns of 2 components matrix of high precision floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef tmat2x2<double, highp>		highp_dmat2;
+	
+	/// 2 columns of 2 components matrix of low precision floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef tmat2x2<double, lowp>		lowp_dmat2x2;
+	
+	/// 2 columns of 2 components matrix of medium precision floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef tmat2x2<double, mediump>	mediump_dmat2x2;
+	
+	/// 2 columns of 2 components matrix of high precision floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef tmat2x2<double, highp>		highp_dmat2x2;
+	
+	/// @}
+	
+	/// @addtogroup core_precision
+	/// @{
+	
+	/// 2 columns of 3 components matrix of low precision floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef tmat2x3<double, lowp>		lowp_dmat2x3;
+	
+	/// 2 columns of 3 components matrix of medium precision floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef tmat2x3<double, mediump>	mediump_dmat2x3;
+	
+	/// 2 columns of 3 components matrix of high precision floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef tmat2x3<double, highp>		highp_dmat2x3;
+	
+	/// @}
+	
+	/// @addtogroup core_precision
+	/// @{
+	
+	/// 2 columns of 4 components matrix of low precision floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef tmat2x4<double, lowp>		lowp_dmat2x4;
+	
+	/// 2 columns of 4 components matrix of medium precision floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef tmat2x4<double, mediump>	mediump_dmat2x4;
+	
+	/// 2 columns of 4 components matrix of high precision floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef tmat2x4<double, highp>		highp_dmat2x4;
+	
+	/// @}
+	
+	/// @addtogroup core_precision
+	/// @{
+	
+	/// 3 columns of 2 components matrix of low precision floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef tmat3x2<double, lowp>		lowp_dmat3x2;
+	
+	/// 3 columns of 2 components matrix of medium precision floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef tmat3x2<double, mediump>	mediump_dmat3x2;
+	
+	/// 3 columns of 2 components matrix of high precision floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef tmat3x2<double, highp>		highp_dmat3x2;
+	
+	/// @}
+	
+	/// @addtogroup core_precision
+	/// @{
+	
+	/// 3 columns of 3 components matrix of low precision floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef tmat3x3<float, lowp>		lowp_dmat3;
+	
+	/// 3 columns of 3 components matrix of medium precision floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef tmat3x3<double, mediump>	mediump_dmat3;
+	
+	/// 3 columns of 3 components matrix of high precision floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef tmat3x3<double, highp>		highp_dmat3;
+	
+	/// 3 columns of 3 components matrix of low precision floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef tmat3x3<double, lowp>		lowp_dmat3x3;
+	
+	/// 3 columns of 3 components matrix of medium precision floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef tmat3x3<double, mediump>	mediump_dmat3x3;
+	
+	/// 3 columns of 3 components matrix of high precision floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef tmat3x3<double, highp>		highp_dmat3x3;
+	
+	/// @}
+	
+	/// @addtogroup core_precision
+	/// @{
+	
+	/// 3 columns of 4 components matrix of low precision floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef tmat3x4<double, lowp>		lowp_dmat3x4;
+	
+	/// 3 columns of 4 components matrix of medium precision floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef tmat3x4<double, mediump>	mediump_dmat3x4;
+	
+	/// 3 columns of 4 components matrix of high precision floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef tmat3x4<double, highp>		highp_dmat3x4;
+	
+	/// @}
+	
+	/// @addtogroup core_precision
+	/// @{
+	
+	/// 4 columns of 2 components matrix of low precision floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef tmat4x2<double, lowp>		lowp_dmat4x2;
+	
+	/// 4 columns of 2 components matrix of medium precision floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef tmat4x2<double, mediump>	mediump_dmat4x2;
+	
+	/// 4 columns of 2 components matrix of high precision floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef tmat4x2<double, highp>		highp_dmat4x2;
+	
+	/// @}
+	
+	/// @addtogroup core_precision
+	/// @{
+	
+	/// 4 columns of 3 components matrix of low precision floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef tmat4x3<double, lowp>		lowp_dmat4x3;
+	
+	/// 4 columns of 3 components matrix of medium precision floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef tmat4x3<double, mediump>	mediump_dmat4x3;
+	
+	/// 4 columns of 3 components matrix of high precision floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef tmat4x3<double, highp>		highp_dmat4x3;
+	
+	/// @}
+	
+	/// @addtogroup core_precision
+	/// @{
+	
+	/// 4 columns of 4 components matrix of low precision floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef tmat4x4<double, lowp>		lowp_dmat4;
+	
+	/// 4 columns of 4 components matrix of medium precision floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef tmat4x4<double, mediump>	mediump_dmat4;
+	
+	/// 4 columns of 4 components matrix of high precision floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef tmat4x4<double, highp>		highp_dmat4;
+	
+	/// 4 columns of 4 components matrix of low precision floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef tmat4x4<double, lowp>		lowp_dmat4x4;
+	
+	/// 4 columns of 4 components matrix of medium precision floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef tmat4x4<double, mediump>	mediump_dmat4x4;
+	
+	/// 4 columns of 4 components matrix of high precision floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
+	typedef tmat4x4<double, highp>		highp_dmat4x4;
+	
+	/// @}
+	
+#if(defined(GLM_PRECISION_LOWP_DOUBLE))
+	typedef lowp_dmat2x2		dmat2x2;
+	typedef lowp_dmat2x3		dmat2x3;
+	typedef lowp_dmat2x4		dmat2x4;
+	typedef lowp_dmat3x2		dmat3x2;
+	typedef lowp_dmat3x3		dmat3x3;
+	typedef lowp_dmat3x4		dmat3x4;
+	typedef lowp_dmat4x2		dmat4x2;
+	typedef lowp_dmat4x3		dmat4x3;
+	typedef lowp_dmat4x4		dmat4x4;
+#elif(defined(GLM_PRECISION_MEDIUMP_DOUBLE))
+	typedef mediump_dmat2x2		dmat2x2;
+	typedef mediump_dmat2x3		dmat2x3;
+	typedef mediump_dmat2x4		dmat2x4;
+	typedef mediump_dmat3x2		dmat3x2;
+	typedef mediump_dmat3x3		dmat3x3;
+	typedef mediump_dmat3x4		dmat3x4;
+	typedef mediump_dmat4x2		dmat4x2;
+	typedef mediump_dmat4x3		dmat4x3;
+	typedef mediump_dmat4x4		dmat4x4;
+#else //defined(GLM_PRECISION_HIGHP_DOUBLE)
+	
+	//! 2 * 2 matrix of double-precision floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	typedef highp_dmat2x2		dmat2;
+	
+	//! 3 * 3 matrix of double-precision floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	typedef highp_dmat3x3		dmat3;
+	
+	//! 4 * 4 matrix of double-precision floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	typedef highp_dmat4x4		dmat4;
+	
+	//! 2 * 2 matrix of double-precision floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	typedef highp_dmat2x2		dmat2x2;
+	
+	//! 2 * 3 matrix of double-precision floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	typedef highp_dmat2x3		dmat2x3;
+	
+	//! 2 * 4 matrix of double-precision floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	typedef highp_dmat2x4		dmat2x4;
+	
+	//! 3 * 2 matrix of double-precision floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	typedef highp_dmat3x2		dmat3x2;
+	
+	/// 3 * 3 matrix of double-precision floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	typedef highp_dmat3x3		dmat3x3;
+	
+	/// 3 * 4 matrix of double-precision floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	typedef highp_dmat3x4		dmat3x4;
+	
+	/// 4 * 2 matrix of double-precision floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	typedef highp_dmat4x2		dmat4x2;
+	
+	/// 4 * 3 matrix of double-precision floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	typedef highp_dmat4x3		dmat4x3;
+	
+	/// 4 * 4 matrix of double-precision floating-point numbers.
+	///
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
+	typedef highp_dmat4x4		dmat4x4;
+
+#endif//GLM_PRECISION
+	
+	/// @}
+}//namespace glm

glm/glm/detail/type_mat.inl

@@ -0,0 +1,32 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// 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.
+///
+/// @ref core
+/// @file glm/detail/type_mat.inl
+/// @date 2011-06-15 / 2011-06-15
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+

glm/glm/detail/type_mat2x2.hpp

@@ -0,0 +1,223 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// OpenGL Mathematics (glm.g-truc.net)
+///
+/// Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net)
+/// Permission is hereby granted, free of charge, to any person obtaining a copy
+/// of this software and associated documentation files (the "Software"), to deal
+/// in the Software without restriction, including without limitation the rights
+/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+/// copies of the Software, and to permit persons to whom the Software is
+/// furnished to do so, subject to the following conditions:
+/// 
+/// The above copyright notice and this permission notice shall be included in
+/// all copies or substantial portions of the Software.
+/// 
+/// Restrictions:
+///		By making use of the Software for military purposes, you choose to make
+///		a Bunny unhappy.
+/// 
+/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+/// THE SOFTWARE.
+///
+/// @ref core
+/// @file glm/detail/type_mat2x2.hpp
+/// @date 2005-01-27 / 2011-06-15
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#pragma once
+
+#include "../fwd.hpp"
+#include "type_vec2.hpp"
+#include "type_mat.hpp"
+#include <limits>
+#include <cstddef>
+
+namespace glm
+{
+	template <typename T, precision P = defaultp>
+	struct tmat2x2
+	{
+		typedef tvec2<T, P> col_type;
+		typedef tvec2<T, P> row_type;
+		typedef tmat2x2<T, P> type;
+		typedef tmat2x2<T, P> transpose_type;
+		typedef T value_type;
+
+		template <typename U, precision Q>
+		friend tvec2<U, Q> operator/(tmat2x2<U, Q> const & m, tvec2<U, Q> const & v);
+		template <typename U, precision Q>
+		friend tvec2<U, Q> operator/(tvec2<U, Q> const & v, tmat2x2<U, Q> const & m);
+
+	private:
+		/// @cond DETAIL
+		col_type value[2];
+		/// @endcond
+		
+	public:
+		//////////////////////////////////////
+		// Constructors
+		GLM_FUNC_DECL tmat2x2();
+		GLM_FUNC_DECL tmat2x2(tmat2x2<T, P> const & m);
+		template <precision Q>
+		GLM_FUNC_DECL tmat2x2(tmat2x2<T, Q> const & m);
+
+		GLM_FUNC_DECL explicit tmat2x2(ctor);
+		GLM_FUNC_DECL explicit tmat2x2(T const & x);
+		GLM_FUNC_DECL tmat2x2(
+			T const & x1, T const & y1,
+			T const & x2, T const & y2);
+		GLM_FUNC_DECL tmat2x2(
+			col_type const & v1,
+			col_type const & v2);
+
+		//////////////////////////////////////
+		// Conversions
+		template <typename U, typename V, typename M, typename N>
+		GLM_FUNC_DECL tmat2x2(
+			U const & x1, V const & y1,
+			M const & x2, N const & y2);
+
+		template <typename U, typename V>
+		GLM_FUNC_DECL tmat2x2(
+			tvec2<U, P> const & v1,
+			tvec2<V, P> const & v2);
+
+		//////////////////////////////////////
+		// Matrix conversions
+
+#		ifdef GLM_FORCE_EXPLICIT_CTOR
+			template <typename U, precision Q>
+			GLM_FUNC_DECL explicit tmat2x2(tmat2x2<U, Q> const & m);
+#		else
+			template <typename U, precision Q>
+			GLM_FUNC_DECL tmat2x2(tmat2x2<U, Q> const & m);
+#		endif
+
+		GLM_FUNC_DECL explicit tmat2x2(tmat3x3<T, P> const & x);
+		GLM_FUNC_DECL explicit tmat2x2(tmat4x4<T, P> const & x);
+		GLM_FUNC_DECL explicit tmat2x2(tmat2x3<T, P> const & x);
+		GLM_FUNC_DECL explicit tmat2x2(tmat3x2<T, P> const & x);
+		GLM_FUNC_DECL explicit tmat2x2(tmat2x4<T, P> const & x);
+		GLM_FUNC_DECL explicit tmat2x2(tmat4x2<T, P> const & x);
+		GLM_FUNC_DECL explicit tmat2x2(tmat3x4<T, P> const & x);
+		GLM_FUNC_DECL explicit tmat2x2(tmat4x3<T, P> const & x);
+
+		//////////////////////////////////////
+		// Accesses
+
+#		ifdef GLM_FORCE_SIZE_FUNC
+			typedef size_t size_type;
+			GLM_FUNC_DECL GLM_CONSTEXPR size_t size() const;
+
+			GLM_FUNC_DECL col_type & operator[](size_type i);
+			GLM_FUNC_DECL col_type const & operator[](size_type i) const;
+#		else
+			typedef length_t length_type;
+			GLM_FUNC_DECL GLM_CONSTEXPR length_type length() const;
+
+			GLM_FUNC_DECL col_type & operator[](length_type i);
+			GLM_FUNC_DECL col_type const & operator[](length_type i) const;
+#		endif//GLM_FORCE_SIZE_FUNC
+
+		//////////////////////////////////////
+		// Unary arithmetic operators
+
+		GLM_FUNC_DECL tmat2x2<T, P> & operator=(tmat2x2<T, P> const & v);
+
+		template <typename U> 
+		GLM_FUNC_DECL tmat2x2<T, P> & operator=(tmat2x2<U, P> const & m);
+		template <typename U> 
+		GLM_FUNC_DECL tmat2x2<T, P> & operator+=(U s);
+		template <typename U> 
+		GLM_FUNC_DECL tmat2x2<T, P> & operator+=(tmat2x2<U, P> const & m);
+		template <typename U> 
+		GLM_FUNC_DECL tmat2x2<T, P> & operator-=(U s);
+		template <typename U> 
+		GLM_FUNC_DECL tmat2x2<T, P> & operator-=(tmat2x2<U, P> const & m);
+		template <typename U> 
+		GLM_FUNC_DECL tmat2x2<T, P> & operator*=(U s);
+		template <typename U> 
+		GLM_FUNC_DECL tmat2x2<T, P> & operator*=(tmat2x2<U, P> const & m);
+		template <typename U> 
+		GLM_FUNC_DECL tmat2x2<T, P> & operator/=(U s);
+		template <typename U> 
+		GLM_FUNC_DECL tmat2x2<T, P> & operator/=(tmat2x2<U, P> const & m);
+
+		//////////////////////////////////////
+		// Increment and decrement operators
+
+		GLM_FUNC_DECL tmat2x2<T, P> & operator++ ();
+		GLM_FUNC_DECL tmat2x2<T, P> & operator-- ();
+		GLM_FUNC_DECL tmat2x2<T, P> operator++(int);
+		GLM_FUNC_DECL tmat2x2<T, P> operator--(int);
+	};
+
+	// Binary operators
+	template <typename T, precision P>
+	GLM_FUNC_DECL tmat2x2<T, P> operator+(tmat2x2<T, P> const & m, T const & s);
+
+	template <typename T, precision P>
+	GLM_FUNC_DECL tmat2x2<T, P> operator+(T const & s, tmat2x2<T, P> const & m);
+
+	template <typename T, precision P>
+	GLM_FUNC_DECL tmat2x2<T, P> operator+(tmat2x2<T, P> const & m1,	tmat2x2<T, P> const & m2);
+
+	template <typename T, precision P>
+	GLM_FUNC_DECL tmat2x2<T, P> operator-(tmat2x2<T, P> const & m, T const & s);
+
+	template <typename T, precision P>
+	GLM_FUNC_DECL tmat2x2<T, P> operator-(T const & s, tmat2x2<T, P> const & m);
+
+	template <typename T, precision P>
+	GLM_FUNC_DECL tmat2x2<T, P> operator-(tmat2x2<T, P> const & m1,	tmat2x2<T, P> const & m2);
+
+	template <typename T, precision P>
+	GLM_FUNC_DECL tmat2x2<T, P> operator*(tmat2x2<T, P> const & m, T const & s);
+
+	template <typename T, precision P>
+	GLM_FUNC_DECL tmat2x2<T, P> operator*(T const & s, tmat2x2<T, P> const & m);
+
+	template <typename T, precision P>
+	GLM_FUNC_DECL typename tmat2x2<T, P>::col_type operator*(tmat2x2<T, P> const & m, typename tmat2x2<T, P>::row_type const & v);
+
+	template <typename T, precision P>
+	GLM_FUNC_DECL typename tmat2x2<T, P>::row_type operator*(typename tmat2x2<T, P>::col_type const & v, tmat2x2<T, P> const & m);
+
+	template <typename T, precision P>
+	GLM_FUNC_DECL tmat2x2<T, P> operator*(tmat2x2<T, P> const & m1,	tmat2x2<T, P> const & m2);
+		
+	template <typename T, precision P>
+	GLM_FUNC_DECL tmat3x2<T, P> operator*(tmat2x2<T, P> const & m1, tmat3x2<T, P> const & m2);
+		
+	template <typename T, precision P>
+	GLM_FUNC_DECL tmat4x2<T, P> operator*(tmat2x2<T, P> const & m1, tmat4x2<T, P> const & m2);
+
+	template <typename T, precision P>
+	GLM_FUNC_DECL tmat2x2<T, P> operator/(tmat2x2<T, P> const & m, T const & s);
+
+	template <typename T, precision P>
+	GLM_FUNC_DECL tmat2x2<T, P> operator/(T const & s, tmat2x2<T, P> const & m);
+
+	template <typename T, precision P>
+	GLM_FUNC_DECL typename tmat2x2<T, P>::col_type operator/(tmat2x2<T, P> const & m, typename tmat2x2<T, P>::row_type const & v);
+
+	template <typename T, precision P>
+	GLM_FUNC_DECL typename tmat2x2<T, P>::row_type operator/(typename tmat2x2<T, P>::col_type const & v, tmat2x2<T, P> const & m);
+
+	template <typename T, precision P>
+	GLM_FUNC_DECL tmat2x2<T, P> operator/(tmat2x2<T, P> const & m1, tmat2x2<T, P> const & m2);
+
+	// Unary constant operators
+	template <typename T, precision P> 
+	GLM_FUNC_DECL tmat2x2<T, P> const operator-(tmat2x2<T, P> const & m);
+} //namespace glm
+
+#ifndef GLM_EXTERNAL_TEMPLATE
+#include "type_mat2x2.inl"
+#endif

glm/glm/detail/type_mat2x2.inl

@@ -0,0 +1,548 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// 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.
+///
+/// @ref core
+/// @file glm/detail/type_mat2x2.inl
+/// @date 2005-01-16 / 2011-06-15
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+namespace glm{
+namespace detail
+{
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tmat2x2<T, P> compute_inverse(tmat2x2<T, P> const & m)
+	{
+		T OneOverDeterminant = static_cast<T>(1) / (
+			+ m[0][0] * m[1][1]
+			- m[1][0] * m[0][1]);
+
+		tmat2x2<T, P> Inverse(
+			+ m[1][1] * OneOverDeterminant,
+			- m[0][1] * OneOverDeterminant,
+			- m[1][0] * OneOverDeterminant,
+			+ m[0][0] * OneOverDeterminant);
+
+		return Inverse;
+	}
+}//namespace detail
+
+	//////////////////////////////////////////////////////////////
+	// Constructors
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tmat2x2<T, P>::tmat2x2()
+	{
+#		ifndef GLM_FORCE_NO_CTOR_INIT 
+			this->value[0] = col_type(1, 0);
+			this->value[1] = col_type(0, 1);
+#		endif
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tmat2x2<T, P>::tmat2x2(tmat2x2<T, P> const & m)
+	{
+		this->value[0] = m.value[0];
+		this->value[1] = m.value[1];
+	}
+
+	template <typename T, precision P>
+	template <precision Q>
+	GLM_FUNC_QUALIFIER tmat2x2<T, P>::tmat2x2(tmat2x2<T, Q> const & m)
+	{
+		this->value[0] = m.value[0];
+		this->value[1] = m.value[1];
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tmat2x2<T, P>::tmat2x2(ctor)
+	{}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tmat2x2<T, P>::tmat2x2(T const & s)
+	{
+		this->value[0] = col_type(s, 0);
+		this->value[1] = col_type(0, s);
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tmat2x2<T, P>::tmat2x2
+	(
+		T const & x0, T const & y0,
+		T const & x1, T const & y1
+	)
+	{
+		this->value[0] = col_type(x0, y0);
+		this->value[1] = col_type(x1, y1);
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tmat2x2<T, P>::tmat2x2(col_type const & v0, col_type const & v1)
+	{
+		this->value[0] = v0;
+		this->value[1] = v1;
+	}
+
+	//////////////////////////////////////
+	// Conversion constructors
+	template <typename T, precision P>
+	template <typename X1, typename Y1, typename X2, typename Y2>
+	GLM_FUNC_QUALIFIER tmat2x2<T, P>::tmat2x2
+	(
+		X1 const & x1, Y1 const & y1,
+		X2 const & x2, Y2 const & y2
+	)
+	{
+		this->value[0] = col_type(static_cast<T>(x1), value_type(y1));
+		this->value[1] = col_type(static_cast<T>(x2), value_type(y2));
+	}
+	
+	template <typename T, precision P>
+	template <typename V1, typename V2>
+	GLM_FUNC_QUALIFIER tmat2x2<T, P>::tmat2x2(tvec2<V1, P> const & v1, tvec2<V2, P> const & v2)
+	{
+		this->value[0] = col_type(v1);
+		this->value[1] = col_type(v2);
+	}
+
+	//////////////////////////////////////////////////////////////
+	// mat2x2 matrix conversions
+
+	template <typename T, precision P>
+	template <typename U, precision Q>
+	GLM_FUNC_QUALIFIER tmat2x2<T, P>::tmat2x2(tmat2x2<U, Q> const & m)
+	{
+		this->value[0] = col_type(m[0]);
+		this->value[1] = col_type(m[1]);
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tmat2x2<T, P>::tmat2x2(tmat3x3<T, P> const & m)
+	{
+		this->value[0] = col_type(m[0]);
+		this->value[1] = col_type(m[1]);
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tmat2x2<T, P>::tmat2x2(tmat4x4<T, P> const & m)
+	{
+		this->value[0] = col_type(m[0]);
+		this->value[1] = col_type(m[1]);
+	}
+
+	template <typename T, precision P> 
+	GLM_FUNC_QUALIFIER tmat2x2<T, P>::tmat2x2(tmat2x3<T, P> const & m)
+	{
+		this->value[0] = col_type(m[0]);
+		this->value[1] = col_type(m[1]);
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tmat2x2<T, P>::tmat2x2(tmat3x2<T, P> const & m)
+	{
+		this->value[0] = m[0];
+		this->value[1] = m[1];
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tmat2x2<T, P>::tmat2x2(tmat2x4<T, P> const & m)
+	{
+		this->value[0] = col_type(m[0]);
+		this->value[1] = col_type(m[1]);
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tmat2x2<T, P>::tmat2x2(tmat4x2<T, P> const & m)
+	{
+		this->value[0] = m[0];
+		this->value[1] = m[1];
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tmat2x2<T, P>::tmat2x2(tmat3x4<T, P> const & m)
+	{
+		this->value[0] = col_type(m[0]);
+		this->value[1] = col_type(m[1]);
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tmat2x2<T, P>::tmat2x2(tmat4x3<T, P> const & m)
+	{
+		this->value[0] = col_type(m[0]);
+		this->value[1] = col_type(m[1]);
+	}
+
+	//////////////////////////////////////
+	// Accesses
+
+#	ifdef GLM_FORCE_SIZE_FUNC
+		template <typename T, precision P>
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR typename tmat2x2<T, P>::size_type tmat2x2<T, P>::size() const
+		{
+			return 2;
+		}
+
+		template <typename T, precision P>
+		GLM_FUNC_QUALIFIER typename tmat2x2<T, P>::col_type & tmat2x2<T, P>::operator[](typename tmat2x2<T, P>::size_type i)
+		{
+			assert(i < this->size());
+			return this->value[i];
+		}
+
+		template <typename T, precision P>
+		GLM_FUNC_QUALIFIER typename tmat2x2<T, P>::col_type const & tmat2x2<T, P>::operator[](typename tmat2x2<T, P>::size_type i) const
+		{
+			assert(i < this->size());
+			return this->value[i];
+		}
+#	else
+		template <typename T, precision P>
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR typename tmat2x2<T, P>::length_type tmat2x2<T, P>::length() const
+		{
+			return 2;
+		}
+
+		template <typename T, precision P>
+		GLM_FUNC_QUALIFIER typename tmat2x2<T, P>::col_type & tmat2x2<T, P>::operator[](typename tmat2x2<T, P>::length_type i)
+		{
+			assert(i < this->length());
+			return this->value[i];
+		}
+
+		template <typename T, precision P>
+		GLM_FUNC_QUALIFIER typename tmat2x2<T, P>::col_type const & tmat2x2<T, P>::operator[](typename tmat2x2<T, P>::length_type i) const
+		{
+			assert(i < this->length());
+			return this->value[i];
+		}
+#	endif//GLM_FORCE_SIZE_FUNC
+
+	//////////////////////////////////////////////////////////////
+	// Unary updatable operators
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tmat2x2<T, P>& tmat2x2<T, P>::operator=(tmat2x2<T, P> const & m)
+	{
+		this->value[0] = m[0];
+		this->value[1] = m[1];
+		return *this;
+	}
+
+	template <typename T, precision P>
+	template <typename U>
+	GLM_FUNC_QUALIFIER tmat2x2<T, P>& tmat2x2<T, P>::operator=(tmat2x2<U, P> const & m)
+	{
+		this->value[0] = m[0];
+		this->value[1] = m[1];
+		return *this;
+	}
+
+	template <typename T, precision P>
+	template <typename U>
+	GLM_FUNC_QUALIFIER tmat2x2<T, P>& tmat2x2<T, P>::operator+=(U s)
+	{
+		this->value[0] += s;
+		this->value[1] += s;
+		return *this;
+	}
+
+	template <typename T, precision P>
+	template <typename U>
+	GLM_FUNC_QUALIFIER tmat2x2<T, P>& tmat2x2<T, P>::operator+=(tmat2x2<U, P> const & m)
+	{
+		this->value[0] += m[0];
+		this->value[1] += m[1];
+		return *this;
+	}
+
+	template <typename T, precision P>
+	template <typename U>
+	GLM_FUNC_QUALIFIER tmat2x2<T, P>& tmat2x2<T, P>::operator-=(U s)
+	{
+		this->value[0] -= s;
+		this->value[1] -= s;
+		return *this;
+	}
+
+	template <typename T, precision P>
+	template <typename U>
+	GLM_FUNC_QUALIFIER tmat2x2<T, P>& tmat2x2<T, P>::operator-=(tmat2x2<U, P> const & m)
+	{
+		this->value[0] -= m[0];
+		this->value[1] -= m[1];
+		return *this;
+	}
+
+	template <typename T, precision P>
+	template <typename U>
+	GLM_FUNC_QUALIFIER tmat2x2<T, P>& tmat2x2<T, P>::operator*=(U s)
+	{
+		this->value[0] *= s;
+		this->value[1] *= s;
+		return *this;
+	}
+
+	template <typename T, precision P>
+	template <typename U>
+	GLM_FUNC_QUALIFIER tmat2x2<T, P>& tmat2x2<T, P>::operator*=(tmat2x2<U, P> const & m)
+	{
+		return (*this = *this * m);
+	}
+
+	template <typename T, precision P>
+	template <typename U>
+	GLM_FUNC_QUALIFIER tmat2x2<T, P>& tmat2x2<T, P>::operator/=(U s)
+	{
+		this->value[0] /= s;
+		this->value[1] /= s;
+		return *this;
+	}
+
+	template <typename T, precision P>
+	template <typename U>
+	GLM_FUNC_QUALIFIER tmat2x2<T, P>& tmat2x2<T, P>::operator/=(tmat2x2<U, P> const & m)
+	{
+		return (*this = *this * detail::compute_inverse<T, P>(m));
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tmat2x2<T, P>& tmat2x2<T, P>::operator++()
+	{
+		++this->value[0];
+		++this->value[1];
+		return *this;
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tmat2x2<T, P>& tmat2x2<T, P>::operator--()
+	{
+		--this->value[0];
+		--this->value[1];
+		return *this;
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tmat2x2<T, P> tmat2x2<T, P>::operator++(int)
+	{
+		tmat2x2<T, P> Result(*this);
+		++*this;
+		return Result;
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tmat2x2<T, P> tmat2x2<T, P>::operator--(int)
+	{
+		tmat2x2<T, P> Result(*this);
+		--*this;
+		return Result;
+	}
+
+	//////////////////////////////////////////////////////////////
+	// Binary operators
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tmat2x2<T, P> operator+(tmat2x2<T, P> const & m, T const & s)
+	{
+		return tmat2x2<T, P>(
+			m[0] + s,
+			m[1] + s);
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tmat2x2<T, P> operator+(T const & s, tmat2x2<T, P> const & m)
+	{
+		return tmat2x2<T, P>(
+			m[0] + s,
+			m[1] + s);
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tmat2x2<T, P> operator+(tmat2x2<T, P> const & m1, tmat2x2<T, P> const & m2)
+	{
+		return tmat2x2<T, P>(
+			m1[0] + m2[0],
+			m1[1] + m2[1]);
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tmat2x2<T, P> operator-(tmat2x2<T, P> const & m, T const & s)
+	{
+		return tmat2x2<T, P>(
+			m[0] - s,
+			m[1] - s);
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tmat2x2<T, P> operator-(T const & s, tmat2x2<T, P> const & m)
+	{
+		return tmat2x2<T, P>(
+			s - m[0],
+			s - m[1]);
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tmat2x2<T, P> operator-(tmat2x2<T, P> const & m1, tmat2x2<T, P> const & m2)
+	{
+		return tmat2x2<T, P>(
+			m1[0] - m2[0],
+			m1[1] - m2[1]);
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tmat2x2<T, P> operator*(tmat2x2<T, P> const & m,	T const & s)
+	{
+		return tmat2x2<T, P>(
+			m[0] * s,
+			m[1] * s);
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tmat2x2<T, P> operator*(T const & s, tmat2x2<T, P> const & m)
+	{
+		return tmat2x2<T, P>(
+			m[0] * s,
+			m[1] * s);
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER typename tmat2x2<T, P>::col_type operator*
+	(
+		tmat2x2<T, P> const & m,
+		typename tmat2x2<T, P>::row_type const & v
+	)
+	{
+		return tvec2<T, P>(
+			m[0][0] * v.x + m[1][0] * v.y,
+			m[0][1] * v.x + m[1][1] * v.y);
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER typename tmat2x2<T, P>::row_type operator*
+	(
+		typename tmat2x2<T, P>::col_type const & v,
+		tmat2x2<T, P> const & m
+	)
+	{
+		return tvec2<T, P>(
+			v.x * m[0][0] + v.y * m[0][1],
+			v.x * m[1][0] + v.y * m[1][1]);
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tmat2x2<T, P> operator*(tmat2x2<T, P> const & m1, tmat2x2<T, P> const & m2)
+	{
+		return tmat2x2<T, P>(
+			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1],
+			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1],
+			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1],
+			m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1]);
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tmat3x2<T, P> operator*(tmat2x2<T, P> const & m1, tmat3x2<T, P> const & m2)
+	{
+		return tmat3x2<T, P>(
+			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1],
+			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1],
+			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1],
+			m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1],
+			m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1],
+			m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1]);
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tmat4x2<T, P> operator*(tmat2x2<T, P> const & m1, tmat4x2<T, P> const & m2)
+	{
+		return tmat4x2<T, P>(
+			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1],
+			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1],
+			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1],
+			m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1],
+			m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1],
+			m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1],
+			m1[0][0] * m2[3][0] + m1[1][0] * m2[3][1],
+			m1[0][1] * m2[3][0] + m1[1][1] * m2[3][1]);
+	}
+
+	template <typename T, precision P> 
+	GLM_FUNC_QUALIFIER tmat2x2<T, P> operator/(tmat2x2<T, P> const & m,	T const & s)
+	{
+		return tmat2x2<T, P>(
+			m[0] / s,
+			m[1] / s);
+	}
+
+	template <typename T, precision P> 
+	GLM_FUNC_QUALIFIER tmat2x2<T, P> operator/(T const & s, tmat2x2<T, P> const & m)
+	{
+		return tmat2x2<T, P>(
+			s / m[0],
+			s / m[1]);
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER typename tmat2x2<T, P>::col_type operator/(tmat2x2<T, P> const & m, typename tmat2x2<T, P>::row_type const & v)
+	{
+		return detail::compute_inverse<T, P>(m) * v;
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER typename tmat2x2<T, P>::row_type operator/(typename tmat2x2<T, P>::col_type const & v, tmat2x2<T, P> const & m)
+	{
+		return v * detail::compute_inverse<T, P>(m);
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tmat2x2<T, P> operator/(tmat2x2<T, P> const & m1, tmat2x2<T, P> const & m2)
+	{	
+		tmat2x2<T, P> m1_copy(m1);
+		return m1_copy /= m2;
+	}
+
+	// Unary constant operators
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tmat2x2<T, P> const operator-(tmat2x2<T, P> const & m)
+	{
+		return tmat2x2<T, P>(
+			-m[0], 
+			-m[1]);
+	}
+
+	//////////////////////////////////////
+	// Boolean operators
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER bool operator==(tmat2x2<T, P> const & m1, tmat2x2<T, P> const & m2)
+	{
+		return (m1[0] == m2[0]) && (m1[1] == m2[1]);
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER bool operator!=(tmat2x2<T, P> const & m1, tmat2x2<T, P> const & m2)
+	{
+		return (m1[0] != m2[0]) || (m1[1] != m2[1]);
+	}
+} //namespace glm

glm/glm/detail/type_mat2x3.hpp

@@ -0,0 +1,201 @@
+///////////////////////////////////////////////////////////////////////////////////
+/// 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.
+///
+/// @ref core
+/// @file glm/detail/type_mat2x3.hpp
+/// @date 2006-10-01 / 2011-06-15
+/// @author Christophe Riccio
+///////////////////////////////////////////////////////////////////////////////////
+
+#pragma once
+
+#include "../fwd.hpp"
+#include "type_vec2.hpp"
+#include "type_vec3.hpp"
+#include "type_mat.hpp"
+#include <limits>
+#include <cstddef>
+
+namespace glm
+{
+	template <typename T, precision P = defaultp>
+	struct tmat2x3
+	{
+		typedef tvec3<T, P> col_type;
+		typedef tvec2<T, P> row_type;
+		typedef tmat2x3<T, P> type;
+		typedef tmat3x2<T, P> transpose_type;
+		typedef T value_type;
+
+	private:
+		/// @cond DETAIL 
+		col_type value[2];
+		/// @endcond
+		
+	public:
+		// Constructors
+		GLM_FUNC_DECL tmat2x3();
+		GLM_FUNC_DECL tmat2x3(tmat2x3<T, P> const & m);
+		template <precision Q>
+		GLM_FUNC_DECL tmat2x3(tmat2x3<T, Q> const & m);
+
+		GLM_FUNC_DECL explicit tmat2x3(ctor);
+		GLM_FUNC_DECL explicit tmat2x3(T const & s);
+		GLM_FUNC_DECL tmat2x3(
+			T const & x0, T const & y0, T const & z0,
+			T const & x1, T const & y1, T const & z1);
+		GLM_FUNC_DECL tmat2x3(
+			col_type const & v0,
+			col_type const & v1);
+
+		//////////////////////////////////////
+		// Conversions
+
+		template <typename X1, typename Y1, typename Z1, typename X2, typename Y2, typename Z2>
+		GLM_FUNC_DECL tmat2x3(
+			X1 const & x1, Y1 const & y1, Z1 const & z1,
+			X2 const & x2, Y2 const & y2, Z2 const & z2);
+			
+		template <typename U, typename V>
+		GLM_FUNC_DECL tmat2x3(
+			tvec3<U, P> const & v1,
+			tvec3<V, P> const & v2);
+
+		//////////////////////////////////////
+		// Matrix conversion
+
+#		ifdef GLM_FORCE_EXPLICIT_CTOR
+			template <typename U, precision Q>
+			GLM_FUNC_DECL explicit tmat2x3(tmat2x3<U, Q> const & m);
+#		else
+			template <typename U, precision Q>
+			GLM_FUNC_DECL tmat2x3(tmat2x3<U, Q> const & m);
+#		endif
+
+		GLM_FUNC_DECL explicit tmat2x3(tmat2x2<T, P> const & x);
+		GLM_FUNC_DECL explicit tmat2x3(tmat3x3<T, P> const & x);
+		GLM_FUNC_DECL explicit tmat2x3(tmat4x4<T, P> const & x);
+		GLM_FUNC_DECL explicit tmat2x3(tmat2x4<T, P> const & x);
+		GLM_FUNC_DECL explicit tmat2x3(tmat3x2<T, P> const & x);
+		GLM_FUNC_DECL explicit tmat2x3(tmat3x4<T, P> const & x);
+		GLM_FUNC_DECL explicit tmat2x3(tmat4x2<T, P> const & x);
+		GLM_FUNC_DECL explicit tmat2x3(tmat4x3<T, P> const & x);
+
+		//////////////////////////////////////
+		// Accesses
+
+#		ifdef GLM_FORCE_SIZE_FUNC
+			typedef size_t size_type;
+			GLM_FUNC_DECL GLM_CONSTEXPR size_t size() const;
+
+			GLM_FUNC_DECL col_type & operator[](size_type i);
+			GLM_FUNC_DECL col_type const & operator[](size_type i) const;
+#		else
+			typedef length_t length_type;
+			GLM_FUNC_DECL GLM_CONSTEXPR length_type length() const;
+
+			GLM_FUNC_DECL col_type & operator[](length_type i);
+			GLM_FUNC_DECL col_type const & operator[](length_type i) const;
+#		endif//GLM_FORCE_SIZE_FUNC
+
+		//////////////////////////////////////
+		// Unary arithmetic operators
+
+		GLM_FUNC_DECL tmat2x3<T, P> & operator=(tmat2x3<T, P> const & m);
+
+		template <typename U> 
+		GLM_FUNC_DECL tmat2x3<T, P> & operator=(tmat2x3<U, P> const & m);
+		template <typename U> 
+		GLM_FUNC_DECL tmat2x3<T, P> & operator+=(U s);
+		template <typename U> 
+		GLM_FUNC_DECL tmat2x3<T, P> & operator+=(tmat2x3<U, P> const & m);
+		template <typename U> 
+		GLM_FUNC_DECL tmat2x3<T, P> & operator-=(U s);
+		template <typename U> 
+		GLM_FUNC_DECL tmat2x3<T, P> & operator-=(tmat2x3<U, P> const & m);
+		template <typename U> 
+		GLM_FUNC_DECL tmat2x3<T, P> & operator*=(U s);
+		template <typename U> 
+		GLM_FUNC_DECL tmat2x3<T, P> & operator/=(U s);
+
+		//////////////////////////////////////
+		// Increment and decrement operators
+
+		GLM_FUNC_DECL tmat2x3<T, P> & operator++ ();
+		GLM_FUNC_DECL tmat2x3<T, P> & operator-- ();
+		GLM_FUNC_DECL tmat2x3<T, P> operator++(int);
+		GLM_FUNC_DECL tmat2x3<T, P> operator--(int);
+	};
+
+	// Binary operators
+
+	template <typename T, precision P>
+	GLM_FUNC_DECL tmat2x3<T, P> operator+(tmat2x3<T, P> const & m, T const & s);
+
+	template <typename T, precision P>
+	GLM_FUNC_DECL tmat2x3<T, P> operator+(tmat2x3<T, P> const & m1, tmat2x3<T, P> const & m2);
+
+	template <typename T, precision P>
+	GLM_FUNC_DECL tmat2x3<T, P> operator-(tmat2x3<T, P> const & m, T const & s);
+
+	template <typename T, precision P>
+	GLM_FUNC_DECL tmat2x3<T, P> operator-(tmat2x3<T, P> const & m1, tmat2x3<T, P> const & m2);
+
+	template <typename T, precision P>
+	GLM_FUNC_DECL tmat2x3<T, P> operator*(tmat2x3<T, P> const & m, T const & s);
+
+	template <typename T, precision P>
+	GLM_FUNC_DECL tmat2x3<T, P> operator*(T const & s, tmat2x3<T, P> const & m);
+
+	template <typename T, precision P>
+	GLM_FUNC_DECL typename tmat2x3<T, P>::col_type operator*(tmat2x3<T, P> const & m, typename tmat2x3<T, P>::row_type const & v);
+
+	template <typename T, precision P>
+	GLM_FUNC_DECL typename tmat2x3<T, P>::row_type operator*(typename tmat2x3<T, P>::col_type const & v, tmat2x3<T, P> const & m);
+
+	template <typename T, precision P>
+	GLM_FUNC_DECL tmat2x3<T, P> operator*(tmat2x3<T, P> const & m1, tmat2x2<T, P> const & m2);
+
+	template <typename T, precision P>
+	GLM_FUNC_DECL tmat3x3<T, P> operator*(tmat2x3<T, P> const & m1, tmat3x2<T, P> const & m2);
+		
+	template <typename T, precision P>
+	GLM_FUNC_DECL tmat4x3<T, P> operator*(tmat2x3<T, P> const & m1, tmat4x2<T, P> const & m2);
+
+	template <typename T, precision P>
+	GLM_FUNC_DECL tmat2x3<T, P> operator/(tmat2x3<T, P> const & m, T const & s);
+
+	template <typename T, precision P>
+	GLM_FUNC_DECL tmat2x3<T, P> operator/(T const & s, tmat2x3<T, P> const & m);
+
+	// Unary constant operators
+	template <typename T, precision P>
+	GLM_FUNC_DECL tmat2x3<T, P> const operator-(tmat2x3<T, P> const & m);
+}//namespace glm
+
+#ifndef GLM_EXTERNAL_TEMPLATE
+#include "type_mat2x3.inl"
+#endif